From d22b7d0195dbe3ebe52fd71f43f42aac956d3e5e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Dumont?= Date: Thu, 10 Sep 2026 07:01:07 +0200 Subject: [PATCH 001/584] libstdc++: [_GLIBCXX_DEBUG] Simplify constant-evaluated checks In the C++26 std::__debug::inplace_vector implementation we can use: if consteval { ... } rather than: if (std::is_constant_evaluated()) libstdc++-v3/ChangeLog: * include/debug/inplace_vector (inplace_vector::emplace): Replace usages of std::is_constant_evaluated by consteval. (inplace_vector::insert): Likewise. (inplace_vector::erase): Likewise. --- libstdc++-v3/include/debug/inplace_vector | 49 ++++++++++++++--------- 1 file changed, 31 insertions(+), 18 deletions(-) diff --git a/libstdc++-v3/include/debug/inplace_vector b/libstdc++-v3/include/debug/inplace_vector index e579e8636f98..a0bf4c854423 100644 --- a/libstdc++-v3/include/debug/inplace_vector +++ b/libstdc++-v3/include/debug/inplace_vector @@ -400,10 +400,12 @@ namespace __debug constexpr iterator emplace(const_iterator __position, _Args&&... __args) { - if (std::is_constant_evaluated()) - return iterator(_Base::emplace(__position.base(), - std::forward<_Args>(__args)...), - this); + if consteval + { + return iterator(_Base::emplace(__position.base(), + std::forward<_Args>(__args)...), + this); + } __glibcxx_check_insert(__position); const difference_type __offset = __position.base() - _Base::cbegin(); @@ -424,10 +426,12 @@ namespace __debug constexpr iterator insert(const_iterator __position, size_type __n, const _Tp& __x) { - if (std::is_constant_evaluated()) - return iterator(_Base::insert(__position.base(), __n, __x), this); + if consteval + { + return iterator(_Base::insert(__position.base(), __n, __x), this); + } - __glibcxx_check_insert(__position); + __glibcxx_check_insert(__position); const difference_type __offset = __position.base() - _Base::cbegin(); _Base_iterator __res = _Base::insert(__position.base(), __n, __x); _M_invalidate_after_nth(__offset); @@ -439,10 +443,13 @@ namespace __debug insert(const_iterator __position, _InputIterator __first, _InputIterator __last) { - if (std::is_constant_evaluated()) - return iterator(_Base::insert(__position.base(), - __gnu_debug::__unsafe(__first), - __gnu_debug::__unsafe(__last)), this); + if consteval + { + return iterator(_Base::insert(__position.base(), + __gnu_debug::__unsafe(__first), + __gnu_debug::__unsafe(__last)), + this); + } typename __gnu_debug::_Distance_traits<_InputIterator>::__type __dist; __glibcxx_check_insert_range(__position, __first, __last, __dist); @@ -476,8 +483,10 @@ namespace __debug constexpr iterator insert(const_iterator __position, initializer_list<_Tp> __il) { - if (std::is_constant_evaluated()) - return iterator(_Base::insert(__position.base(), __il), this); + if consteval + { + return iterator(_Base::insert(__position.base(), __il), this); + } __glibcxx_check_insert(__position); const auto __size = size(); @@ -491,8 +500,10 @@ namespace __debug constexpr iterator erase(const_iterator __position) { - if (std::is_constant_evaluated()) - return iterator(_Base::erase(__position.base()), this); + if consteval + { + return iterator(_Base::erase(__position.base()), this); + } __glibcxx_check_erase(__position); difference_type __offset = __position.base() - _Base::cbegin(); @@ -504,9 +515,11 @@ namespace __debug constexpr iterator erase(const_iterator __first, const_iterator __last) { - if (std::is_constant_evaluated()) - return iterator(_Base::erase(__first.base(), __last.base()), - this); + if consteval + { + return iterator(_Base::erase(__first.base(), __last.base()), + this); + } __glibcxx_check_erase_range(__first, __last); From 7b60a368fb19b33f8676482a233d389cbc47b85e Mon Sep 17 00:00:00 2001 From: Joshua Berne Date: Mon, 14 Sep 2026 10:16:28 -0400 Subject: [PATCH 002/584] c++: fix nested instances of modifiable_tracker [PR127282] PR c++/127282 - [[assume]]: a nested assumption's side effects are not rolled back during constant evaluation During constant evaluation of the predicate of an [[assume]] attribute a pointer to a set of modifiable values is stored in the constexpr_global_ctx. The class modifiable_tracker populates this value when evaluation of the predicate starts and clears it when it is complete, which results in nullptr instead of the original set when an [[assume]] is evaluated during the evaluation of the predicate of another assume. Fix this by storing the previous value (nullptr in non-nested cases) and restoring it upon destruction instead of clearing the global value. PR c++/127282 gcc/cp/ChangeLog: * constexpr.cc (modifiable_tracker::modifiable_tracker): Save the current global pointer to the modifiable set. (modifiable_tracker::~modifiable_tracker): Restore the original pointer to the modifiable set instead of clearing it. gcc/testsuite/ChangeLog: * g++.dg/cpp23/attr-assume10.C: Add a case with a nested assumption. Signed-off-by: Joshua Berne --- gcc/cp/constexpr.cc | 10 +++++++--- gcc/testsuite/g++.dg/cpp23/attr-assume10.C | 19 ++++++++++++++++++- 2 files changed, 25 insertions(+), 4 deletions(-) diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc index 7219c55c9ceb..18d361c24325 100644 --- a/gcc/cp/constexpr.cc +++ b/gcc/cp/constexpr.cc @@ -1298,7 +1298,9 @@ class constexpr_global_ctx { /* Helper class for constexpr_global_ctx. In some cases we want to avoid side-effects from evaluation of a particular subexpression of a constant-expression. In such cases we use modifiable_tracker to prevent - modification of variables created outside of that subexpression. + modification of variables created outside of that subexpression. Keep and + then restore the original value of global->modifiable so that tracker + instantiations can nest. ??? We could change the hash_set to a hash_map, allow and track external modifications, and roll them back in the destructor. It's not clear to me @@ -1308,8 +1310,10 @@ class modifiable_tracker { hash_set set; constexpr_global_ctx *global; + hash_set *previous_set; public: - modifiable_tracker (constexpr_global_ctx *g): global(g) + modifiable_tracker (constexpr_global_ctx *g) + : global (g), previous_set (g->modifiable) { global->modifiable = &set; } @@ -1317,7 +1321,7 @@ class modifiable_tracker { for (tree t: set) global->clear_value (t); - global->modifiable = nullptr; + global->modifiable = previous_set; } }; diff --git a/gcc/testsuite/g++.dg/cpp23/attr-assume10.C b/gcc/testsuite/g++.dg/cpp23/attr-assume10.C index 475555ac415d..3f4af3fae95e 100644 --- a/gcc/testsuite/g++.dg/cpp23/attr-assume10.C +++ b/gcc/testsuite/g++.dg/cpp23/attr-assume10.C @@ -1,4 +1,4 @@ -// Test that s.i is not modified by the assume. +// Test that s.i is not modified by assume or a nested assume. // { dg-do compile { target c++17 } } struct string @@ -20,3 +20,20 @@ constexpr int f() } static_assert (f()); + +// PR c++/127282, a nested assume also needs to not modify values or allow +// other expressions within the enclosing assume to modify values. +constexpr int g() +{ + string s ("foobar"); + [[assume ( + [&](){[[assume (s.length () > 0)]]; return true; }() + && s.length () > 0) + ]]; + if (s.i != 0) __builtin_abort(); + int len = s.length (); + if (s.i != 1) __builtin_abort(); + return len; +} + +static_assert (g()); From b0730e1d39f95eae5f3edc720a6887cd0c535517 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Dumont?= Date: Mon, 14 Sep 2026 19:38:26 +0200 Subject: [PATCH 003/584] libstdc++: [_GLIBCXX_DEBUG] Fix coding style on if consteval Coding style imposes curly brasses to be open on same line, like this: if consteval { .... } libstdc++-v3/ChangeLog: * include/debug/inplace_vector: Apply proper coding style on all 'if consteval' expressions. --- libstdc++-v3/include/debug/inplace_vector | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-) diff --git a/libstdc++-v3/include/debug/inplace_vector b/libstdc++-v3/include/debug/inplace_vector index a0bf4c854423..3dc26d476a25 100644 --- a/libstdc++-v3/include/debug/inplace_vector +++ b/libstdc++-v3/include/debug/inplace_vector @@ -400,8 +400,7 @@ namespace __debug constexpr iterator emplace(const_iterator __position, _Args&&... __args) { - if consteval - { + if consteval { return iterator(_Base::emplace(__position.base(), std::forward<_Args>(__args)...), this); @@ -426,8 +425,7 @@ namespace __debug constexpr iterator insert(const_iterator __position, size_type __n, const _Tp& __x) { - if consteval - { + if consteval { return iterator(_Base::insert(__position.base(), __n, __x), this); } @@ -443,8 +441,7 @@ namespace __debug insert(const_iterator __position, _InputIterator __first, _InputIterator __last) { - if consteval - { + if consteval { return iterator(_Base::insert(__position.base(), __gnu_debug::__unsafe(__first), __gnu_debug::__unsafe(__last)), @@ -483,8 +480,7 @@ namespace __debug constexpr iterator insert(const_iterator __position, initializer_list<_Tp> __il) { - if consteval - { + if consteval { return iterator(_Base::insert(__position.base(), __il), this); } @@ -500,8 +496,7 @@ namespace __debug constexpr iterator erase(const_iterator __position) { - if consteval - { + if consteval { return iterator(_Base::erase(__position.base()), this); } @@ -515,8 +510,7 @@ namespace __debug constexpr iterator erase(const_iterator __first, const_iterator __last) { - if consteval - { + if consteval { return iterator(_Base::erase(__first.base(), __last.base()), this); } From 09463178dc462cd7f7cec1bf09856459702ca624 Mon Sep 17 00:00:00 2001 From: "James K. Lowden" Date: Fri, 11 Sep 2026 18:44:52 -0400 Subject: [PATCH 004/584] cobol: Improve data-item validation. Support Implicit PICTURE per ISO 13.16.2. A data item F with VALUE and no PICTURE is initially entered into the symbol table as invalid. If item F+1 is entered and is not subordinate, and F meets the conditions for an implicit PICTURE, mark it as valid. Correct currency symbol validation, fixes RT 3681. gcc/cobol/ChangeLog: * parse.y: Emit diagnostic if symbol_currency_add fails. * parse_ante.h (update_prior_invalid_field): New function. (field_add): Use update_prior_invalid_field to validate prior field. * scan.l: Document currency-symbol domain. * symbols.cc (symbols_update): Quell redundant diagnostic. (symbol_currency_symbol_ok): Validate currency symbol. (symbol_currency_add): Use symbol_currency_symbol_ok. --- gcc/cobol/parse.y | 13 ++++++++++--- gcc/cobol/parse_ante.h | 28 ++++++++++++++++++++++++++++ gcc/cobol/scan.l | 10 ++++++++++ gcc/cobol/symbols.cc | 18 ++++++++++++++++-- 4 files changed, 64 insertions(+), 5 deletions(-) diff --git a/gcc/cobol/parse.y b/gcc/cobol/parse.y index 6434c2685fb2..37f4ab6358f6 100644 --- a/gcc/cobol/parse.y +++ b/gcc/cobol/parse.y @@ -3115,7 +3115,10 @@ special_name: dev_mnemonic { error_msg(@lit, "'%s' has embedded NUL", $lit.data); YYERROR; } - symbol_currency_add( $picture_sym, $lit.data ); + if( ! symbol_currency_add($picture_sym, $lit.data) ) { + auto ch = $picture_sym[0]; + error_msg(@picture_sym, "invalid currency symbol: %qc", ch); + } } | DECIMAL_POINT is COMMA { @@ -3530,8 +3533,12 @@ data_div: %empty { parser_division( data_div_e, NULL, 0, NULL ); } } ; -data_sections: data_section - | data_sections data_section +data_sections: data_section { + update_prior_invalid_field(); + } + | data_sections data_section { + update_prior_invalid_field(); + } ; data_section: FILE_SECT '.' diff --git a/gcc/cobol/parse_ante.h b/gcc/cobol/parse_ante.h index c3214ce75b95..b8db55e49184 100644 --- a/gcc/cobol/parse_ante.h +++ b/gcc/cobol/parse_ante.h @@ -3315,6 +3315,32 @@ group_attr( const cbl_field_t * field ) { return p->attr; } +/* + * 13.16.3 Syntax rules + * a) if the literal is alphanumeric, 'PICTURE X(length)' + * b) if the literal is boolean, 'PICTURE 1(length)' + * c) if the literal is national, 'PICTURE N(length)' + * (We don't support boolean yet.) + */ +static void +update_prior_invalid_field( const cbl_field_t *field = nullptr) { + symbol_elem_t *e = field? symbol_at(field->our_index) : symbols_end(); + e--; + if( e->type == SymDataSection ) e--; + if( (e)->type == SymField ) { + auto f = cbl_field_of(e); + if( ! field ) field = f; // fake it + if( field->level <= f->level ) { + if( f->type == FldInvalid && f->data.has_initial_value() ) { + if( f->has_attr(quoted_e) ) { + f->type = FldAlphanumeric; + assert(0 < f->char_capacity()); + } + } + } + } +} + static struct cbl_field_t * field_add( const cbl_loc_t& loc, cbl_field_t *field ) { switch(current_data_section) { @@ -3349,6 +3375,8 @@ field_add( const cbl_loc_t& loc, cbl_field_t *field ) { return NULL; break; } + } else { + update_prior_invalid_field(field); } return field; } diff --git a/gcc/cobol/scan.l b/gcc/cobol/scan.l index 8b85d710e320..df76ad1da816 100644 --- a/gcc/cobol/scan.l +++ b/gcc/cobol/scan.l @@ -136,7 +136,17 @@ ALPHED {ALPHEDREQ}([AX9B0/]{COUNT}?)* NUMEDCHAR [BPVZ90/,]+{COUNT}? NUMEDCHARS {NUMEDCHAR}([.]?{NUMEDCHAR})* NUMED ([+-]{NUMEDCHARS}+)|({NUMEDCHARS}+[+-]?) + /* ISO specification 12.3.7.2: + * 27) Literal-8 may be any character from the + * computer's coded character set except for the + * following: + * a) digits 0 through 9; + * b) alphabetic characters A, B, C, D, E, N, P, R, S, V, X, Z, + * or their lowercase equivalents; or the space; + * c) characters '+' '–' ',' '.' '*' '/' ';' '(' ')' '"' '=' + */ CURRENCY [A-Zfhijklmoqtuwy\x80-\xFF]{-}[ABCDEGNPRSVXZ] +xCURRENCY [\x00-\xFF]{-}[ABCDEGNPRSVXZ 0-9 abcdegnprsvxz,.*/;()""=+-] NUMEDCUR (([.]?[$0B/Z*+,P9()V+-]|{CURRENCY}+|{COUNT})+([.][$0B/Z*+P9()V+-])*)+ NUMEDITED {NUMED}|{NUMEDCUR} diff --git a/gcc/cobol/symbols.cc b/gcc/cobol/symbols.cc index bef6f116c3b8..f732a67287bb 100644 --- a/gcc/cobol/symbols.cc +++ b/gcc/cobol/symbols.cc @@ -2030,8 +2030,10 @@ symbols_update( size_t first, bool parsed_ok ) { case FldNumericDisplay: case FldNumericEdited: if( ! (field->has_attr(register_e) || field->has_attr(hex_encoded_e)) ) { - error_msg(symbol_field_location(field_index(field)), - "internal: %qs encoding not defined", field->name); + if( ! mode_syntax_only() ) { + error_msg(symbol_field_location(field_index(field)), + "internal: %qs encoding not defined", field->name); + } } break; case FldClass: @@ -5132,15 +5134,27 @@ symbol_program_local( const char tgt_name[] ) { */ std::map currencies; +static bool +symbol_currency_symbol_ok( const char symbol ) { + static std::string never("ABCDEGNPRSUVXZ0-9abcdegnprsuvxz,.*/;()'\"=+-"); + return std::string::npos == never.find(symbol); +} + // cppcheck-suppress-begin [nullPointerRedundantCheck] bool symbol_currency_add( const char symbol[], const char sign[] ) { + static const std::string never("ABCDEGNPRSUVXZ0-9abcdegnprsuvxz,.*/;()'\"=+-"); // In service of CURRENCY sign PICTURE SYMBOL symbol // The single-character 'symbol' is replaced with multi-char 'sign' // by the NumericEdited processing. if( !symbol ) { symbol = xasprintf("%c", *sign); + } else { + if( ! symbol_currency_symbol_ok(symbol[0]) ) { + return false; + } } + currencies[*symbol] = sign; return true; } From af60ef97ec110b03745e42b614c315563101a6e2 Mon Sep 17 00:00:00 2001 From: Robert Dubner Date: Sat, 12 Sep 2026 14:03:48 -0400 Subject: [PATCH 005/584] cobol: Correct and expand tests with CURRENCY symbols and ROUNDING. gcc/testsuite/ChangeLog: * cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.cob: Use @ not U. * cobol.dg/group2/floating-point_ADD_FORMAT_1.cob: Test NEAREST-AWAY-FROM-ZERO. * cobol.dg/group2/floating-point_ADD_FORMAT_1.out: Test DISPLAY. --- .../CURRENCY_SIGN_WITH_PICTURE_SYMBOL.cob | 8 ++--- .../group2/floating-point_ADD_FORMAT_1.cob | 29 ++++++++++++++----- .../group2/floating-point_ADD_FORMAT_1.out | 14 ++++----- 3 files changed, 33 insertions(+), 18 deletions(-) diff --git a/gcc/testsuite/cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.cob b/gcc/testsuite/cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.cob index ebbcd3228020..6c742266f396 100644 --- a/gcc/testsuite/cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.cob +++ b/gcc/testsuite/cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.cob @@ -7,15 +7,15 @@ CONFIGURATION SECTION. SPECIAL-NAMES. *> note the space after EUR / before ct. - CURRENCY SIGN IS "EUR " WITH PICTURE SYMBOL "U", - CURRENCY SIGN IS " ct (EUR)" WITH PICTURE SYMBOL "c", + CURRENCY SIGN IS "EUR " WITH PICTURE SYMBOL "@", + CURRENCY SIGN IS " ct (EUR)" WITH PICTURE SYMBOL "&", Currency Sign is "$US" with Picture Symbol "$". DATA DIVISION. WORKING-STORAGE SECTION. 77 euro-val pic 99v99. - 77 EUROS PIC U99v99. - 77 cents PIC 9,999c. + 77 EUROS PIC @99v99. + 77 cents PIC 9,999&. 77 DOLLARS Pic $$,$$9.99. PROCEDURE DIVISION. diff --git a/gcc/testsuite/cobol.dg/group2/floating-point_ADD_FORMAT_1.cob b/gcc/testsuite/cobol.dg/group2/floating-point_ADD_FORMAT_1.cob index baf22560d95b..968efe768e72 100644 --- a/gcc/testsuite/cobol.dg/group2/floating-point_ADD_FORMAT_1.cob +++ b/gcc/testsuite/cobol.dg/group2/floating-point_ADD_FORMAT_1.cob @@ -20,6 +20,13 @@ 01 D5 FLOAT-SHORT . 01 D6 FLOAT-LONG . 01 D7 FLOAT-EXTENDED . + 01 D1D PIC 999999v99. + 01 D2D PIC 999999v99. + 01 D3D PIC 999999v99. + 01 D4D PIC 999999v99. + 01 D5D PIC 999999v99. + 01 D6D PIC 999999v99. + 01 D7D PIC 999999v99. PROCEDURE DIVISION. MOVE S1 TO D1 ADD S1 TO D1 MOVE S2 TO D2 ADD S2 TO D2 @@ -79,13 +86,21 @@ PERFORM DISPLAY-D. GOBACK. DISPLAY-D. - DISPLAY D1 SPACE - D2 SPACE - D3 SPACE - D4 SPACE - D5 SPACE - D6 SPACE - D7 . + ADD D1 TO D1D ROUNDED MODE IS NEAREST-AWAY-FROM-ZERO + ADD D2 TO D2D ROUNDED MODE IS NEAREST-AWAY-FROM-ZERO + ADD D3 TO D3D ROUNDED MODE IS NEAREST-AWAY-FROM-ZERO + ADD D4 TO D4D ROUNDED MODE IS NEAREST-AWAY-FROM-ZERO + ADD D5 TO D5D ROUNDED MODE IS NEAREST-AWAY-FROM-ZERO + ADD D6 TO D6D ROUNDED MODE IS NEAREST-AWAY-FROM-ZERO + ADD D7 TO D7D ROUNDED MODE IS NEAREST-AWAY-FROM-ZERO + DISPLAY D1D SPACE + D2D SPACE + D3D SPACE + D4D SPACE + D5D SPACE + D6D SPACE + D7D . MOVE 0 TO D1 D2 D3 D4 D5 D6 D7. + MOVE 0 TO D1D D2D D3D D4D D5D D6D D7D. END PROGRAM float-arith1. diff --git a/gcc/testsuite/cobol.dg/group2/floating-point_ADD_FORMAT_1.out b/gcc/testsuite/cobol.dg/group2/floating-point_ADD_FORMAT_1.out index d48643c9c19f..e572b9d231f3 100644 --- a/gcc/testsuite/cobol.dg/group2/floating-point_ADD_FORMAT_1.out +++ b/gcc/testsuite/cobol.dg/group2/floating-point_ADD_FORMAT_1.out @@ -1,8 +1,8 @@ -246.90 246.90 246.90 246.90 246.8999939 246.900000000000006 246.9000000000000000000000000000000049 -246.90 246.90 246.90 246.89 246.8999939 246.900000000000006 246.9000000000000000000000000000000049 -246.90 246.90 246.89 246.90 246.8999939 246.900000000000006 246.9000000000000000000000000000000049 -246.90 246.89 246.90 246.90 246.8999939 246.900000000000006 246.9000000000000000000000000000000049 -246.89 246.90 246.90 246.90 246.8999939 246.900000000000006 246.9000000000000000000000000000000049 -246.90 246.90 246.90 246.90 246.8999939 246.900000000000006 246.8999969482421874999999999999999901 -246.90 246.90 246.90 246.90 246.8999939 246.899996948242176 246.9000000000000028421709430404007336 +000246.90 000246.90 000246.90 000246.90 000246.90 000246.90 000246.90 +000246.90 000246.90 000246.90 000246.89 000246.90 000246.90 000246.90 +000246.90 000246.90 000246.89 000246.90 000246.90 000246.90 000246.90 +000246.90 000246.89 000246.90 000246.90 000246.90 000246.90 000246.90 +000246.89 000246.90 000246.90 000246.90 000246.90 000246.90 000246.90 +000246.90 000246.90 000246.90 000246.90 000246.90 000246.90 000246.90 +000246.90 000246.90 000246.90 000246.90 000246.90 000246.90 000246.90 From 63dd621df995fbfd9cb1db9fae9b0db9e7c353cd Mon Sep 17 00:00:00 2001 From: GCC Administrator Date: Tue, 15 Sep 2026 00:16:35 +0000 Subject: [PATCH 006/584] Daily bump. --- gcc/ChangeLog | 158 ++++++++++++++++++++++++++++++++++++++++ gcc/DATESTAMP | 2 +- gcc/cobol/ChangeLog | 10 +++ gcc/cp/ChangeLog | 24 ++++++ gcc/testsuite/ChangeLog | 123 +++++++++++++++++++++++++++++++ libstdc++-v3/ChangeLog | 32 ++++++++ 6 files changed, 348 insertions(+), 1 deletion(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index dd78d1b98f2b..997cecbb0d5d 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,161 @@ +2026-09-14 Jean-Didier Pailleux + + * config/aarch64/aarch64-sve-builtins-sme.def (REQUIRED_EXTENSIONS): Add + missing #undef. + +2026-09-14 Dominic P + + PR tree-optimization/127379 + * match.pd (ior_range_test_0): Require an integral type. + +2026-09-14 Wilco Dijkstra + + * config/aarch64/aarch64.h (TARGET_SVE_PREFER_ZEROING_MOVIMM): New + define. + * config/aarch64/aarch64-sve.md (*vcond_mask_): Add a + split condition for zero predicate. + * config/aarch64/aarch64-tuning-flags.def: Add AVOID_MOVIMM_Z tune. + * config/aarch64/tuning_models/neoversev1.h (tune_flags): Update. + * config/aarch64/tuning_models/neoversev2.h (tune_flags): Update. + +2026-09-14 xiezhiheng + + * haifa-sched.cc (max_issue): Cap max_lookahead_tries + +2026-09-14 Jakub Jelinek + + PR middle-end/127336 + * optabs.cc (maybe_emit_compare_and_swap_exchange_loop, + expand_atomic_fetch_op_no_fallback, expand_atomic_fetch_op): Force + val into a pseduo if it updates to mem could change its value + and when using val after the atomic op or inside of a loop. + +2026-09-14 Kyrylo Tkachov + + * genemit.cc (main): Choose an output file for each overloaded name. + +2026-09-14 Kyrylo Tkachov + + * rtl.h (note_split): Declare. + * emit-rtl.cc (note_split): New function. + * genemit.cc (gen_split): Call it rather than emitting the test and + the fprintf. + +2026-09-14 Kyrylo Tkachov + + * genrecog.cc (md_conditions, md_condition_ids): New variables. + (md_condition_id, print_md_conditions): New functions. + (print_test): Call a helper for a C test rather than emitting the + condition. + (main): Write the helpers to the header. + +2026-09-14 Kyrylo Tkachov + + * genextract.cc (MISSING_OPERAND_CHAR): New macro. + (pathpool, dupnums): New variables. + (add_path, print_string_literal, print_extractions): New functions. + (print_path): Remove. + (print_header): Only emit the prologue. + (main): Call print_extractions. + +2026-09-14 Kyrylo Tkachov + + * match-sat-alu.pd (unsigned_integer_sat_sub): Accept commuted + comparison operand orders and the arm order from a two-return source. + +2026-09-14 Kyrylo Tkachov + + * match-sat-alu.pd (unsigned_integer_sat_sub): Add the + X - MIN (X, Y) form. + * tree-ssa-math-opts.cc + (build_saturation_binary_arith_call_and_replace): Return whether a + replacement was made. + (match_saturation_add_with_assign): Likewise. + (match_unsigned_saturation_sub): Likewise. + (math_opts_dom_walker::after_dom_children): Check MINUS_EXPR for + saturation, and use the assign recognizer results. + +2026-09-14 Claudio Bantaloukas + + * config/aarch64/aarch64-acle-builtins.cc: + (function_resolver::resolve_to): Fix documentation comment. + * config/aarch64/aarch64-acle-builtins.h: (TYPES_tmop_base, + TYPES_tmop_h_bfloat, TYPES_tmop_h_float, TYPES_tmop_h_mf8, + TYPES_tmop_s_mf8): Add new DEF_SVE_TYPES_ARRAYs. + * config/aarch64/aarch64-c.cc: (__ARM_FEATURE_SME_TMOP): Add define. + * config/aarch64/aarch64-sme.md: + (@aarch64_sme_lane_): Add + new insn. + (@aarch64_sme_lane_): + Likewise. + (@aarch64_sme_lane_): + Likewise. + (@aarch64_sme_lane_): + Likewise. + (@aarch64_sme_lane_): + Likewise. + * config/aarch64/aarch64-sve-builtins-shapes.cc: + (ternary_za_uint_dual_single): Add new shape. + * config/aarch64/aarch64-sve-builtins-shapes.h: Likewise. + * config/aarch64/aarch64-sve-builtins-sme.cc: (svtmopa_lane_za_impl): + Add new function impl class. + (svtmopa_lane_za): Add new FUNCTION. + * config/aarch64/aarch64-sve-builtins-sme.def: (svtmopa_lane): Add new + DEF_SME_ZA_FUNCTION_GS entries. + * config/aarch64/aarch64-sve-builtins-sme.h: (svtmopa_lane_za): Add new. + * config/aarch64/aarch64.h: (TARGET_STREAMING_SME_TMOP): Add new define. + * config/aarch64/constraints.md (Uwo): Add new constraint for Control + Vector Register in TMOP operations. + * config/aarch64/iterators.md: (SME_TMOPA_BHSF, SME_TMOPA_FP8): Add new mode + iterators. + (UNSPEC_SME_FTMOPA, UNSPEC_SME_FTMOPA_FP8, UNSPEC_SME_STMOPA, + UNSPEC_SME_SUTMOPA, UNSPEC_SME_USTMOPA, UNSPEC_SME_UTMOPA): Add new + unspecs. + (SME_TMOP_INT, SME_TMOP_INT_CROSS, SME_TMOP_FP, SME_TMOP_FP8): Add new + iterators. + (za_imm_bits): Add new mode_attr. + (optab): Update with new unspecs. + * config/aarch64/predicates.md: (aarch64_imm1, aarch64_imm4): Add new + predicates. + +2026-09-14 Claudio Bantaloukas + + * config/aarch64/aarch64.md: Rename aarch64_imm3 as aarch64_shift_imm3. + * config/aarch64/aarch64-simd.md: Rename aarch64_lane_imm3 as aarch64_imm3. + * config/aarch64/predicates.md: Rename aarch64_imm3 as aarch64_shift_imm3 + and aarch64_lane_imm3 to aarch64_imm3. + +2026-09-14 Richard Biener + + PR tree-optimization/127377 + * tree-ssa-sccvn.cc (vn_walk_cb_data::push_partial_def): + Properly consider the padding before the object when + pruning the size. + +2026-09-14 Richard Biener + + PR tree-optimization/127363 + * tree-vect-stmts.cc (vectorizable_assignment): Properly + code-generate PAREN_EXPRs. + +2026-09-14 Artemiy Volkov + + PR target/126983 + * config/aarch64/aarch64-simd.md (*aarch64_combinez): + Split into VS32_I_SUB64_F_CONDFP16 and HFBF variants. Change + uxtw to uxt. + (*aarch64_combinez_be): Likewise. + * config/aarch64/iterators.md (VSSUB64_F): Remove iterator. + (VS32_I_SUB64_F): Amend by explicitly listing all modes. + (VS32_I_SUB64_F_CONDFP16): New iterator. + +2026-09-14 Rohith Kapelli + + PR ipa/123227 + * ipa-icf.cc (sem_function::equals_wpa): Compare TYPE_ATTRIBUTES + as a list rather than through comp_type_attributes. Reject a + METHOD_TYPE compared against a FUNCTION_TYPE. + 2026-09-13 Dominic P * generic-match-head.cc (gimple_match_no_overflow_p): New. diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index 1c5002a42eae..1ded3e06871f 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20260914 +20260915 diff --git a/gcc/cobol/ChangeLog b/gcc/cobol/ChangeLog index 118706264d31..12839ea39976 100644 --- a/gcc/cobol/ChangeLog +++ b/gcc/cobol/ChangeLog @@ -1,3 +1,13 @@ +2026-09-14 James K. Lowden + + * parse.y: Emit diagnostic if symbol_currency_add fails. + * parse_ante.h (update_prior_invalid_field): New function. + (field_add): Use update_prior_invalid_field to validate prior field. + * scan.l: Document currency-symbol domain. + * symbols.cc (symbols_update): Quell redundant diagnostic. + (symbol_currency_symbol_ok): Validate currency symbol. + (symbol_currency_add): Use symbol_currency_symbol_ok. + 2026-09-11 James K. Lowden * parse.y: Add wordop_t to each element. diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 86543ad9da12..43b5c5339503 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,27 @@ +2026-09-14 Joshua Berne + + PR c++/127282 + * constexpr.cc (modifiable_tracker::modifiable_tracker): Save the + current global pointer to the modifiable set. + (modifiable_tracker::~modifiable_tracker): Restore the original + pointer to the modifiable set instead of clearing it. + +2026-09-14 Marek Polacek + + PR c++/127349 + * pt.cc (lookup_template_class): Print %qE if d1 is not a type. + (tsubst) : Do lookup_qualified_name first + before lookup_template_class. Guard qualified_name_lookup_error + with a complain check. Use gcc_checking_assert instead of + gcc_assert. Use identifier_p. Give an error if we didn't get + a type. + +2026-09-14 Marek Polacek + + PR c++/126970 + * cp-gimplify.cc (immediate_escalating_function_p): Check + !user_provided_p. + 2026-09-13 Iain Sandoe PR c++/126811 diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index c9d4c37a53e5..dcd9a40ba8fc 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,126 @@ +2026-09-14 Robert Dubner + + * cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.cob: Use @ not U. + * cobol.dg/group2/floating-point_ADD_FORMAT_1.cob: Test NEAREST-AWAY-FROM-ZERO. + * cobol.dg/group2/floating-point_ADD_FORMAT_1.out: Test DISPLAY. + +2026-09-14 Joshua Berne + + PR c++/127282 + * g++.dg/cpp23/attr-assume10.C: Add a case with a nested assumption. + +2026-09-14 Jakub Jelinek + + * g++.dg/cpp26/within-lifetime1.C: Fix up C++26 paper number and name. + * g++.dg/cpp26/within-lifetime2.C: Likewise. + * g++.dg/cpp26/within-lifetime3.C: Likewise. + * g++.dg/cpp26/within-lifetime4.C: Likewise. + * g++.dg/cpp26/within-lifetime5.C: Likewise. + * g++.dg/cpp26/within-lifetime6.C: Likewise. + * g++.dg/cpp26/within-lifetime7.C: Likewise. + * g++.dg/cpp26/within-lifetime8.C: Likewise. + * g++.dg/cpp26/within-lifetime9.C: Likewise. + * g++.dg/cpp26/within-lifetime10.C: New test. + * g++.dg/cpp26/within-lifetime11.C: New test. + * g++.dg/cpp26/within-lifetime12.C: New test. + +2026-09-14 Marek Polacek + + PR c++/127349 + * g++.dg/reflect/ns7.C: New test. + +2026-09-14 Marek Polacek + + PR c++/126970 + * g++.dg/reflect/cwg3153-2.C: New test. + +2026-09-14 Dominic P + + PR tree-optimization/127379 + * gcc.dg/torture/pr127379.c: New test. + +2026-09-14 Wilco Dijkstra + + * gcc.target/aarch64/sve/zeroing_mov_z.c: New test. + +2026-09-14 Jakub Jelinek + + PR middle-end/127336 + * gcc.dg/pr127336.c: New test. + +2026-09-14 Kyrylo Tkachov + + * gcc.target/arm/short-it-ifcvt-2.c: Skip M-profile targets. + Match complete conditional branch mnemonics and allow lt and ge. + +2026-09-14 Kyrylo Tkachov + + * gcc.target/aarch64/sat_u_sub_swapped-1.c: New test. + +2026-09-14 Kyrylo Tkachov + + * gcc.target/aarch64/sat_u_sub_minmax-1.c: New test. + * gcc.target/aarch64/sat_u_sub_minmax-2.c: New test. + * gcc.target/aarch64/sat_u_sub_minmax-3.c: New test. + +2026-09-14 Claudio Bantaloukas + + * gcc.target/aarch64/pragma_cpp_predefs_6.c: Add tests checking that the + sme-tmop prefef is off by default, and checks for feature dependencies. + * gcc.target/aarch64/sme2/acle-asm/test_sme2_acle.h: (TEST_ZA_TMOP) Add + testing macro. + * gcc.target/aarch64/sme2/acle-asm/tmopa_lane_za16_bf16_bf16.c: + New test. + * gcc.target/aarch64/sme2/acle-asm/tmopa_lane_za16_f16_f16.c: + Likewise. + * gcc.target/aarch64/sme2/acle-asm/tmopa_lane_za16_mf8_mf8.c: + Likewise. + * gcc.target/aarch64/sme2/acle-asm/tmopa_lane_za32_bf16_bf16.c: + Likewise. + * gcc.target/aarch64/sme2/acle-asm/tmopa_lane_za32_f16_f16.c: + Likewise. + * gcc.target/aarch64/sme2/acle-asm/tmopa_lane_za32_f32_f32.c: + Likewise. + * gcc.target/aarch64/sme2/acle-asm/tmopa_lane_za32_mf8_mf8.c: + Likewise. + * gcc.target/aarch64/sme2/acle-asm/tmopa_lane_za32_s8_s8.c: Likewise. + * gcc.target/aarch64/sme2/acle-asm/tmopa_lane_za32_s8_u8.c: Likewise. + * gcc.target/aarch64/sme2/acle-asm/tmopa_lane_za32_s16_s16.c: + Likewise. + * gcc.target/aarch64/sme2/acle-asm/tmopa_lane_za32_u8_s8.c: Likewise. + * gcc.target/aarch64/sme2/acle-asm/tmopa_lane_za32_u8_u8.c: Likewise. + * gcc.target/aarch64/sme2/acle-asm/tmopa_lane_za32_u16_u16.c: + Likewise. + * gcc.target/aarch64/sve/acle/general-c/ternary_za_uint_dual_single_1.c: + Likewise. + * lib/target-supports.exp: Add check_effective_target support for + sme-tmop. + +2026-09-14 Richard Biener + + PR tree-optimization/127377 + * gcc.dg/torture/pr127377.c: New testcase. + +2026-09-14 Richard Biener + + PR tree-optimization/127363 + * gcc.dg/vect/vect-pr127363.c: New testcase. + +2026-09-14 Artemiy Volkov + + PR target/126983 + * gcc.target/aarch64/vec-init-23-nofp16.c: New test. + +2026-09-14 Rohith Kapelli + + PR ipa/123227 + * gcc.dg/ipa/pr123227.c: New test. + * g++.dg/ipa/pr123227.C: New test. + * gcc.dg/lto/pr123227_0.c: New test. + * gcc.dg/lto/pr123227_1.c: New test. + * g++.dg/lto/pr123227_0.C: New test. + * g++.dg/lto/pr123227_1.C: New test. + 2026-09-13 Dominic P * gcc.dg/torture/minmax-swar-1.c: New test. diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 1575ba80d395..8c0a3806f7b2 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,35 @@ +2026-09-14 François Dumont + + * include/debug/inplace_vector: Apply proper coding style on all + 'if consteval' expressions. + +2026-09-14 François Dumont + + * include/debug/inplace_vector + (inplace_vector::emplace): Replace usages of std::is_constant_evaluated + by consteval. + (inplace_vector::insert): Likewise. + (inplace_vector::erase): Likewise. + +2026-09-14 Jakub Jelinek + + * include/bits/version.def (within_lifetime): Change value from 202306 + to 202603. + * include/bits/version.h: Regenerate. + * include/std/type_traits: Implement C++26 P3450R1: Extend + std::is_within_lifetime paper. + (std::is_within_lifetime): Add _Up template argument defaulted to void + and verify static_cast(__p) is a constant + expression. + +2026-09-14 Yuao Ma + + * include/bits/ranges_algo.h (ranges::__for_each): Add + segemented iterators logic. Split out naive for-loop from ... + (__for_each_fn::operator()): ... here. + * testsuite/performance/25_algorithms/for_each.cc: Add + benchmark for ranges::for_each. + 2026-09-13 Marek Polacek PR c++/125820 From 6d1b92ce276d4705b12c21723f94238a9d34b055 Mon Sep 17 00:00:00 2001 From: Hongyu Wang Date: Thu, 10 Sep 2026 15:50:06 +0800 Subject: [PATCH 007/584] i386: Don't turn quiet FP comparisons into signaling ones [PR127177] The unordered compares (UNLT, UNLE, UNGT, UNGE and UNEQ) must not raise FE_INVALID on a quiet NaN. AVX and AVX512 have an imm8 encoding for the quiet _UQ predicate of each, so just select it. Legacy SSE2 has only 8 predicates and can express UNGE/UNGT/UNLT/UNLE only as the signaling NLT/NLE, so reject those four codes in the packed FP vec_cmp expanders when trapping math is in effect and NaNs are honored. gcc/ChangeLog: PR target/127177 * config/i386/i386-expand.cc (ix86_fp_cmp_code_to_pcmp_immediate): Return the _UQ predicate immediates for UNLE, UNLT, UNGE, UNGT and UNEQ. * config/i386/i386.cc (ix86_print_operand):Likewise to print the _uq suffixed AVX predicates for these codes. * config/i386/predicates.md (ix86_fp_vec_cmp_operator): New predicate. * config/i386/sse.md (vec_cmp): Use the new predicate for the VF_128 compare. * config/i386/mmx.md (vec_cmpv2sfv2si): Likewise. gcc/testsuite/ChangeLog: PR target/127177 * gcc.target/i386/pr127177-1.c: New test. * gcc.target/i386/pr127177-2.c: Likewise. * gcc.target/i386/pr127177-3.c: Likewise. * gcc.target/i386/pr127177-4.c: Likewise. * gcc.target/i386/pr127177-5.c: Likewise. --- gcc/config/i386/i386-expand.cc | 10 +++--- gcc/config/i386/i386.cc | 11 +++--- gcc/config/i386/mmx.md | 2 +- gcc/config/i386/predicates.md | 11 ++++++ gcc/config/i386/sse.md | 2 +- gcc/testsuite/gcc.target/i386/pr127177-1.c | 27 +++++++++++++++ gcc/testsuite/gcc.target/i386/pr127177-2.c | 13 ++++++++ gcc/testsuite/gcc.target/i386/pr127177-3.c | 14 ++++++++ gcc/testsuite/gcc.target/i386/pr127177-4.c | 9 +++++ gcc/testsuite/gcc.target/i386/pr127177-5.c | 39 ++++++++++++++++++++++ 10 files changed, 126 insertions(+), 12 deletions(-) create mode 100644 gcc/testsuite/gcc.target/i386/pr127177-1.c create mode 100644 gcc/testsuite/gcc.target/i386/pr127177-2.c create mode 100644 gcc/testsuite/gcc.target/i386/pr127177-3.c create mode 100644 gcc/testsuite/gcc.target/i386/pr127177-4.c create mode 100644 gcc/testsuite/gcc.target/i386/pr127177-5.c diff --git a/gcc/config/i386/i386-expand.cc b/gcc/config/i386/i386-expand.cc index 68c6791c9928..1c049d0c4410 100644 --- a/gcc/config/i386/i386-expand.cc +++ b/gcc/config/i386/i386-expand.cc @@ -4803,15 +4803,15 @@ ix86_fp_cmp_code_to_pcmp_immediate (enum rtx_code code) case LT: return 0x01; case UNLE: - return 0x0a; + return 0x1a; case UNLT: - return 0x09; + return 0x19; case UNGE: - return 0x05; + return 0x15; case UNGT: - return 0x06; + return 0x16; case UNEQ: - return 0x18; + return 0x08; case LTGT: return 0x0c; case ORDERED: diff --git a/gcc/config/i386/i386.cc b/gcc/config/i386/i386.cc index a8edf28f687f..bbb60163a754 100644 --- a/gcc/config/i386/i386.cc +++ b/gcc/config/i386/i386.cc @@ -14485,7 +14485,7 @@ ix86_print_operand (FILE *file, rtx x, int code) case UNEQ: if (TARGET_AVX) { - fputs ("eq_us", file); + fputs ("eq_uq", file); break; } /* FALLTHRU */ @@ -14495,7 +14495,7 @@ ix86_print_operand (FILE *file, rtx x, int code) case UNLT: if (TARGET_AVX) { - fputs ("nge", file); + fputs ("nge_uq", file); break; } /* FALLTHRU */ @@ -14505,7 +14505,7 @@ ix86_print_operand (FILE *file, rtx x, int code) case UNLE: if (TARGET_AVX) { - fputs ("ngt", file); + fputs ("ngt_uq", file); break; } /* FALLTHRU */ @@ -14533,7 +14533,8 @@ ix86_print_operand (FILE *file, rtx x, int code) } /* FALLTHRU */ case UNGE: - fputs ("nlt", file); + /* Only AVX has the quiet form. */ + fputs (TARGET_AVX ? "nlt_uq" : "nlt", file); break; case GT: if (TARGET_AVX) @@ -14543,7 +14544,7 @@ ix86_print_operand (FILE *file, rtx x, int code) } /* FALLTHRU */ case UNGT: - fputs ("nle", file); + fputs (TARGET_AVX ? "nle_uq" : "nle", file); break; case ORDERED: fputs ("ord", file); diff --git a/gcc/config/i386/mmx.md b/gcc/config/i386/mmx.md index 640b2c0e63f5..fc6286cfed2c 100644 --- a/gcc/config/i386/mmx.md +++ b/gcc/config/i386/mmx.md @@ -1254,7 +1254,7 @@ (define_expand "vec_cmpv2sfv2si" [(set (match_operand:V2SI 0 "register_operand") - (match_operator:V2SI 1 "" + (match_operator:V2SI 1 "ix86_fp_vec_cmp_operator" [(match_operand:V2SF 2 "nonimmediate_operand") (match_operand:V2SF 3 "nonimmediate_operand")]))] "TARGET_MMX_WITH_SSE && ix86_partial_vec_fp_math" diff --git a/gcc/config/i386/predicates.md b/gcc/config/i386/predicates.md index d295edd023de..2718232caf0f 100644 --- a/gcc/config/i386/predicates.md +++ b/gcc/config/i386/predicates.md @@ -1568,6 +1568,17 @@ (and (match_test "TARGET_AVX") (match_code "ge,gt,uneq,unle,unlt,ltgt")))) +;; SSE2 doesn't have quiet vector compare for UNLT/UNLE/UNGT/UNGE, so reject +;; them in the packed FP vec_cmp expanders when trapping math is in effect +;; and NaNs are honored + +(define_predicate "ix86_fp_vec_cmp_operator" + (and (match_operand 0 "comparison_operator") + (ior (not (match_code "unlt,unle,ungt,unge")) + (match_test "TARGET_AVX") + (not (match_test "flag_trapping_math")) + (not (match_test "HONOR_NANS (GET_MODE (XEXP (op, 0)))"))))) + (define_predicate "ix86_comparison_int_operator" (match_code "ne,eq,ge,gt,le,lt")) diff --git a/gcc/config/i386/sse.md b/gcc/config/i386/sse.md index a19472d63aec..a02e061c35c3 100644 --- a/gcc/config/i386/sse.md +++ b/gcc/config/i386/sse.md @@ -5431,7 +5431,7 @@ (define_expand "vec_cmp" [(set (match_operand: 0 "register_operand") - (match_operator: 1 "" + (match_operator: 1 "ix86_fp_vec_cmp_operator" [(match_operand:VF_128 2 "register_operand") (match_operand:VF_128 3 "vector_operand")]))] "TARGET_SSE" diff --git a/gcc/testsuite/gcc.target/i386/pr127177-1.c b/gcc/testsuite/gcc.target/i386/pr127177-1.c new file mode 100644 index 000000000000..979c677d3d6d --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr127177-1.c @@ -0,0 +1,27 @@ +/* PR target/127177 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -mavx -mno-avx512f -ftrapping-math -fdump-tree-vect-details" } */ + +/* The unordered compares are quiet, under AVX use the _uq predicates by + force. */ + +#define TEST(NAME, EXPR) \ + void NAME (int *r, float *a, float *b) \ + { \ + for (int i = 0; i < 1024; i++) \ + r[i] = EXPR; \ + } + +TEST (t_isless, __builtin_isless (a[i], b[i])) +TEST (t_islessequal, __builtin_islessequal (a[i], b[i])) +TEST (t_isgreater, __builtin_isgreater (a[i], b[i])) +TEST (t_isgreaterequal, __builtin_isgreaterequal (a[i], b[i])) +TEST (t_uneq, !__builtin_islessgreater (a[i], b[i])) + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 5 "vect" } } */ +/* { dg-final { scan-assembler-times "vcmpnlt_uqps" 2 } } */ +/* { dg-final { scan-assembler-times "vcmpnle_uqps" 2 } } */ +/* { dg-final { scan-assembler-times "vcmpeq_uqps" 1 } } */ +/* { dg-final { scan-assembler-not "vcmpnltps" } } */ +/* { dg-final { scan-assembler-not "vcmpnleps" } } */ +/* { dg-final { scan-assembler-not "vcmpeq_usps" } } */ diff --git a/gcc/testsuite/gcc.target/i386/pr127177-2.c b/gcc/testsuite/gcc.target/i386/pr127177-2.c new file mode 100644 index 000000000000..998ff323b7a9 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr127177-2.c @@ -0,0 +1,13 @@ +/* PR target/127177 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -mavx512vl -ftrapping-math" } */ + +#include "pr127177-1.c" + +/* { dg-final { scan-assembler "vcmpps\[ \t\]*\\\$21," } } */ +/* { dg-final { scan-assembler "vcmpps\[ \t\]*\\\$22," } } */ +/* { dg-final { scan-assembler "vcmpps\[ \t\]*\\\$25," } } */ +/* { dg-final { scan-assembler "vcmpps\[ \t\]*\\\$26," } } */ +/* { dg-final { scan-assembler "vcmpps\[ \t\]*\\\$8," } } */ +/* { dg-final { scan-assembler-not "vcmpps\[ \t\]*\\\$\[569\]," } } */ +/* { dg-final { scan-assembler-not "vcmpps\[ \t\]*\\\$1\[08\]," } } */ diff --git a/gcc/testsuite/gcc.target/i386/pr127177-3.c b/gcc/testsuite/gcc.target/i386/pr127177-3.c new file mode 100644 index 000000000000..8079f8cc7e52 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr127177-3.c @@ -0,0 +1,14 @@ +/* PR target/127177 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -msse2 -mno-avx -ftrapping-math -fdump-tree-vect-details" } */ +/* { dg-additional-options "-mfpmath=sse" { target ia32 } } */ + +/* With SSE2 only the unordered compares except UNEQ should not be vectorized under + -ftrapping-math, as they may raise FE_INVALID. */ + +#include "pr127177-1.c" + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ +/* { dg-final { scan-assembler-not "cmpnltps" } } */ +/* { dg-final { scan-assembler-not "cmpnleps" } } */ +/* { dg-final { scan-assembler "ucomiss" } } */ diff --git a/gcc/testsuite/gcc.target/i386/pr127177-4.c b/gcc/testsuite/gcc.target/i386/pr127177-4.c new file mode 100644 index 000000000000..96ec7ff88621 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr127177-4.c @@ -0,0 +1,9 @@ +/* PR target/127177 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -msse2 -mno-avx -fno-trapping-math -fdump-tree-vect-details" } */ + +/* Without -ftrapping-math the loops should be vectorized. */ + +#include "pr127177-1.c" + +/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 5 "vect" } } */ diff --git a/gcc/testsuite/gcc.target/i386/pr127177-5.c b/gcc/testsuite/gcc.target/i386/pr127177-5.c new file mode 100644 index 000000000000..f388e0366ed0 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr127177-5.c @@ -0,0 +1,39 @@ +/* PR target/127177 */ +/* { dg-do run } */ +/* { dg-options "-O2 -msse2 -mno-avx -ftrapping-math" } */ +/* { dg-require-effective-target fenv_exceptions } */ +/* { dg-additional-options "-mfpmath=sse" { target ia32 } } */ + +#include + +float a[64], b[64]; +int r[64]; + +__attribute__((noipa)) void +t_islessequal (int *r, float *a, float *b, int n) +{ + for (int i = 0; i < n; i++) + r[i] = __builtin_islessequal (a[i], b[i]); +} + +int +main (void) +{ + for (int i = 0; i < 64; i++) + { + a[i] = __builtin_nanf (""); /* quiet NaN */ + b[i] = 1.0f; + } + + /* A qNaN operand must not raise FE_INVALID here. */ + feclearexcept (FE_INVALID); + t_islessequal (r, a, b, 64); + if (fetestexcept (FE_INVALID)) + __builtin_abort (); + + for (int i = 0; i < 64; i++) + if (r[i] != 0) + __builtin_abort (); + + return 0; +} From 50be38676af8ed32744b856ad6864302f7b400bc Mon Sep 17 00:00:00 2001 From: Naveen Date: Mon, 14 Sep 2026 20:19:42 -0700 Subject: [PATCH 008/584] aarch64: Use UDOT for V8QI sad when dot product is available On TARGET_DOTPROD targets the SAD can be lowered to two instructions: UABD/SABD to compute the lane-wise absolute differences into a V8QI temporary followed by a single UDOT against a vector of all-ones to widen and accumulate the eight byte lanes into a V2SI result. The signed variant uses SABD but still feeds UDOT since absolute differences are unsigned. A new test sadv8qi-dotprod.c verifies that both unsigned and signed SAD loops emit UABD/SABD + UDOT on arm_v8_2a_dotprod targets. gcc/ChangeLog * config/aarch64/aarch64-simd.md: Add define_expand sadv8qi guarded by TARGET_DOTPROD. gcc/testsuite/ChangeLog * gcc.target/aarch64/sadv8qi-dotprod.c: New test. Signed-off-by: Naveen --- gcc/config/aarch64/aarch64-simd.md | 15 ++++++++ .../gcc.target/aarch64/sadv8qi-dotprod.c | 35 +++++++++++++++++++ 2 files changed, 50 insertions(+) create mode 100644 gcc/testsuite/gcc.target/aarch64/sadv8qi-dotprod.c diff --git a/gcc/config/aarch64/aarch64-simd.md b/gcc/config/aarch64/aarch64-simd.md index 5e87df2bb5fd..fe6cb4250f6a 100644 --- a/gcc/config/aarch64/aarch64-simd.md +++ b/gcc/config/aarch64/aarch64-simd.md @@ -1235,6 +1235,21 @@ [(set_attr "type" "neon_reduc_add")] ) +(define_expand "sadv8qi" + [(use (match_operand:V2SI 0 "register_operand")) + (USMAX:V8QI (match_operand:V8QI 1 "register_operand") + (match_operand:V8QI 2 "register_operand")) + (use (match_operand:V2SI 3 "register_operand"))] + "TARGET_DOTPROD" + { + rtx ones = force_reg (V8QImode, CONST1_RTX (V8QImode)); + rtx abd = gen_reg_rtx (V8QImode); + emit_insn (gen_aarch64_abdv8qi (abd, operands[1], operands[2])); + emit_insn (gen_udot_prodv2siv8qi (operands[0], abd, ones, operands[3])); + DONE; + } +) + ;; Emit a sequence to produce a sum-of-absolute-differences of the V16QI ;; inputs in operands 1 and 2. The sequence also has to perform a widening ;; reduction of the difference into a V4SI vector and accumulate that into diff --git a/gcc/testsuite/gcc.target/aarch64/sadv8qi-dotprod.c b/gcc/testsuite/gcc.target/aarch64/sadv8qi-dotprod.c new file mode 100644 index 000000000000..351bb66e1fbb --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/sadv8qi-dotprod.c @@ -0,0 +1,35 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target arm_v8_2a_dotprod_neon_ok } */ +/* { dg-add-options arm_v8_2a_dotprod_neon } */ +/* { dg-additional-options "-O3 -fno-unroll-loops" } */ + +#pragma GCC target "+nosve" + +#define N 8 + +unsigned char upix1[N], upix2[N]; +signed char spix1[N], spix2[N]; + +int +ufoo (void) +{ + int sum = 0; + int i; + for (i = 0; i < N; ++i) + sum += __builtin_abs (upix1[i] - upix2[i]); + return sum; +} + +int +sfoo (void) +{ + int sum = 0; + int i; + for (i = 0; i < N; ++i) + sum += __builtin_abs (spix1[i] - spix2[i]); + return sum; +} + +/* { dg-final { scan-assembler {\tuabd\tv[0-9]+\.8b, v[0-9]+\.8b, v[0-9]+\.8b} } } */ +/* { dg-final { scan-assembler {\tsabd\tv[0-9]+\.8b, v[0-9]+\.8b, v[0-9]+\.8b} } } */ +/* { dg-final { scan-assembler-times {\tudot\tv[0-9]+\.2s, v[0-9]+\.8b, v[0-9]+\.8b} 2 } } */ From 7ae96151ed91609c331d7199e71cf14072c120fd Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Thu, 3 Sep 2026 18:27:04 +0200 Subject: [PATCH 009/584] middle-end: Check GIMPLE memory LHSs as stores [PR127184] tree_could_trap_p describes evaluation as an rvalue. However, gimple_could_trap_p_1 uses it for an assignment LHS when store checks are requested. It also scans the LHS of other statements as an rvalue. A load can be safe while a store to the same address can trap. Use gimple_store_p and lhs_could_trap_p for memory LHSs when store checks are requested. This keeps register definitions as non-stores and includes memory results of GIMPLE_CALL. Omit every statement LHS from the rvalue operand scan. A nothrow call statement can still trap when the caller stores its result. The return-slot optimization flag permits direct construction in the destination, but expansion can use a temporary and a caller-side copy. Check a memory call LHS when non-call exceptions are enabled. Add self-tests for register definitions, assignment stores, and call result stores. Add a non-call exception test for nothrow call results. Bootstrapped and tested on aarch64-unknown-linux-gnu. Tested on x86_64-pc-linux-gnu. PR middle-end/127184 gcc/ChangeLog: * gimple.cc (gimple_could_trap_p_1): Check a memory LHS with lhs_could_trap_p. Do not inspect an LHS as an rvalue. (test_could_trap): New self-test. (gimple_cc_tests): Run it. * tree-eh.cc (stmt_could_throw_p): Check a nothrow call's memory LHS. gcc/testsuite/ChangeLog: * g++.dg/eh/noncall-store-call.C: New test. Signed-off-by: Kyrylo Tkachov --- gcc/gimple.cc | 74 +++++++++++++++++++- gcc/testsuite/g++.dg/eh/noncall-store-call.C | 49 +++++++++++++ gcc/tree-eh.cc | 12 +++- 3 files changed, 131 insertions(+), 4 deletions(-) create mode 100644 gcc/testsuite/g++.dg/eh/noncall-store-call.C diff --git a/gcc/gimple.cc b/gcc/gimple.cc index 3756a60a8e6e..04ad17f59556 100644 --- a/gcc/gimple.cc +++ b/gcc/gimple.cc @@ -2382,8 +2382,8 @@ gimple_has_side_effects (const gimple *s) /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p. Return true if S can trap. When INCLUDE_MEM is true, check whether - the memory operations could trap. When INCLUDE_STORES is true and - S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked. */ + the memory operations could trap. When INCLUDE_STORES is true, also + check a memory LHS with store semantics. */ bool gimple_could_trap_p_1 (const gimple *s, bool include_mem, bool include_stores) @@ -2393,7 +2393,17 @@ gimple_could_trap_p_1 (const gimple *s, bool include_mem, bool include_stores) if (include_mem) { - unsigned i, start = (is_gimple_assign (s) && !include_stores) ? 1 : 0; + unsigned i, start = 0; + + /* Use store semantics for the LHS. A call marked for return-slot + optimization can still use a temporary and a caller-side copy. */ + if (include_stores + && gimple_store_p (s) + && lhs_could_trap_p (gimple_get_lhs (s))) + return true; + + if (gimple_has_lhs (s)) + start = 1; for (i = start; i < gimple_num_ops (s); i++) if (tree_could_trap_p (gimple_op (s, i))) @@ -3670,6 +3680,63 @@ test_assign_binop () ASSERT_EQ (MULT_EXPR, gimple_assign_rhs_code (stmt)); } +/* Verify that GIMPLE trap queries distinguish a register definition and a + trapping store from their nontrapping right-hand sides. */ + +static void +test_could_trap () +{ + tree reg_lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL, + get_identifier ("readonly_reg"), + integer_type_node); + TREE_READONLY (reg_lhs) = 1; + gassign *stmt = gimple_build_assign (reg_lhs, integer_one_node); + + ASSERT_FALSE (gimple_store_p (stmt)); + ASSERT_FALSE (gimple_could_trap_p (stmt)); + ASSERT_FALSE (gimple_assign_rhs_could_trap_p (stmt)); + + tree mem_lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL, + get_identifier ("readonly_mem"), + integer_type_node); + TREE_READONLY (mem_lhs) = 1; + TREE_STATIC (mem_lhs) = 1; + TREE_ADDRESSABLE (mem_lhs) = 1; + stmt = gimple_build_assign (mem_lhs, integer_one_node); + + ASSERT_TRUE (gimple_store_p (stmt)); + ASSERT_TRUE (gimple_could_trap_p (stmt)); + ASSERT_FALSE (gimple_assign_rhs_could_trap_p (stmt)); + + tree record_type = make_node (RECORD_TYPE); + tree field = build_decl (UNKNOWN_LOCATION, FIELD_DECL, + get_identifier ("value"), integer_type_node); + DECL_CONTEXT (field) = record_type; + TYPE_FIELDS (record_type) = field; + layout_type (record_type); + + tree call_lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL, + get_identifier ("readonly_call_mem"), + record_type); + TREE_READONLY (call_lhs) = 1; + TREE_STATIC (call_lhs) = 1; + TREE_ADDRESSABLE (call_lhs) = 1; + + tree fn_type = build_function_type_list (record_type, NULL_TREE); + tree fn = build_fn_decl ("nothrow_call", fn_type); + gcall *call = gimple_build_call (fn, 0); + gimple_call_set_lhs (call, call_lhs); + gimple_call_set_nothrow (call, true); + + ASSERT_TRUE (gimple_store_p (call)); + ASSERT_TRUE (gimple_could_trap_p (call)); + ASSERT_FALSE (gimple_could_trap_p_1 (call, true, false)); + + gimple_call_set_return_slot_opt (call, true); + ASSERT_TRUE (gimple_could_trap_p (call)); + ASSERT_FALSE (gimple_could_trap_p_1 (call, true, false)); +} + /* Build a GIMPLE_NOP and verify various properties of it. */ static void @@ -3723,6 +3790,7 @@ gimple_cc_tests () { test_assign_single (); test_assign_binop (); + test_could_trap (); test_nop_stmt (); test_return_stmt (); test_return_without_value (); diff --git a/gcc/testsuite/g++.dg/eh/noncall-store-call.C b/gcc/testsuite/g++.dg/eh/noncall-store-call.C new file mode 100644 index 000000000000..0be0151450b7 --- /dev/null +++ b/gcc/testsuite/g++.dg/eh/noncall-store-call.C @@ -0,0 +1,49 @@ +// A nothrow call can still trap when the caller stores its result. Return +// slot optimization can fall back to a temporary and a caller-side copy. + +// { dg-do compile } +// { dg-options "-O2 -fnon-call-exceptions -fdump-tree-eh -fdump-tree-optimized-eh" } + +struct one +{ + __UINTPTR_TYPE__ value; +}; + +struct large +{ + __UINTPTR_TYPE__ value[8]; + ~large (); +}; + +extern one make_one () throw (); +extern large make_large () throw (); + +void +store_one (one &dest) +{ + try + { + dest = make_one (); + } + catch (...) + { + __builtin_trap (); + } +} + +void *operator new (__SIZE_TYPE__, void *) throw (); + +void +construct_large (large &dest) +{ + try + { + ::new (&dest) large (make_large ()); + } + catch (...) + { + __builtin_trap (); + } +} + +// { dg-final { scan-tree-dump-times "__cxa_begin_catch" 2 "optimized" } } diff --git a/gcc/tree-eh.cc b/gcc/tree-eh.cc index 1a781f7a0907..e3b8db0b6d01 100644 --- a/gcc/tree-eh.cc +++ b/gcc/tree-eh.cc @@ -3132,7 +3132,17 @@ stmt_could_throw_p (function *fun, gimple *stmt) return true; case GIMPLE_CALL: - return !gimple_call_nothrow_p (as_a (stmt)); + { + gcall *call = as_a (stmt); + if (!gimple_call_nothrow_p (call)) + return true; + /* Return slot optimization can fall back to a temporary and a + caller-side copy. */ + if ((fun && !fun->can_throw_non_call_exceptions) + || !gimple_store_p (call)) + return false; + return lhs_could_trap_p (gimple_call_lhs (call)); + } case GIMPLE_COND: { From 1bcce941ebbb9ad97997a86432da88c8a9117d4b Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Tue, 8 Sep 2026 11:05:32 +0200 Subject: [PATCH 010/584] middle-end: Use conservative store semantics for MEM_NOTRAP [PR127185] set_mem_attributes derives MEM_NOTRAP from tree_could_trap_p. That predicate describes a load. A store to readonly or otherwise unwritable memory can therefore be marked as nontrapping. RTL exception analysis can then omit an edge for a store that can raise a non-call exception. For example, the asm output in the test was marked nontrapping: (set (mem/u/c:SI (...) [ output+0 ]) ...) Use store trap semantics for it instead: (set (mem/u:SI (...) [ output+0 ]) ...) Add MAY_STORE_P to the memory attribute setters and use lhs_could_trap_p when it is true. Default MAY_STORE_P to true so that an unclassified caller cannot create an unsafe nontrapping claim. EXPAND_NORMAL is the only expand modifier that guarantees that a memory reference describes a load. Treat the other modifiers conservatively. This includes EXPAND_STACK_PARM and the direction-neutral EXPAND_MEMORY. Recompute MEM_NOTRAP on copied declaration RTL so that a normal load keeps the nontrapping form: (mem/u/c:SI (...) [ output+0 ]) This can lose MEM_NOTRAP precision for loads expanded with a direction-neutral modifier. Later patches restore that precision for get_memory_rtx, memory-only inline-assembly inputs, partial loads, and STRUB watermark loads. Bootstrapped and tested on aarch64-unknown-linux-gnu. Tested on x86_64-pc-linux-gnu. PR middle-end/127185 gcc/ChangeLog: * emit-rtl.cc (set_mem_attributes_minus_bitpos): Add MAY_STORE_P. Use lhs_could_trap_p when it is true. (set_mem_attributes): Add MAY_STORE_P and pass it through. * emit-rtl.h (set_mem_attributes): Add MAY_STORE_P with a conservative default. (set_mem_attributes_minus_bitpos): Likewise. * expr.cc (expand_assignment): Mark the destination as a store. (expand_expr_real_1): Treat only EXPAND_NORMAL as a known load. Set MEM_NOTRAP from the access direction. gcc/testsuite/ChangeLog: * g++.dg/eh/noncall-store-2.C: New test. * g++.dg/opt/mem-notrap-store-asm.C: New test. Signed-off-by: Kyrylo Tkachov --- gcc/emit-rtl.cc | 12 +++--- gcc/emit-rtl.h | 11 ++++-- gcc/expr.cc | 20 +++++++--- gcc/testsuite/g++.dg/eh/noncall-store-2.C | 39 +++++++++++++++++++ .../g++.dg/opt/mem-notrap-store-asm.C | 23 +++++++++++ 5 files changed, 91 insertions(+), 14 deletions(-) create mode 100644 gcc/testsuite/g++.dg/eh/noncall-store-2.C create mode 100644 gcc/testsuite/g++.dg/opt/mem-notrap-store-asm.C diff --git a/gcc/emit-rtl.cc b/gcc/emit-rtl.cc index a190429cf22c..d064b2a1064b 100644 --- a/gcc/emit-rtl.cc +++ b/gcc/emit-rtl.cc @@ -1959,11 +1959,12 @@ get_mem_align_offset (rtx mem, unsigned int align) /* Given REF (a MEM) and T, either the type of X or the expression corresponding to REF, set the memory attributes. OBJECTP is nonzero if we are making a new object of this type. BITPOS is nonzero if - there is an offset outstanding on T that will be applied later. */ + there is an offset outstanding on T that will be applied later. + MAY_STORE_P is true when REF can be the destination of a store. */ void set_mem_attributes_minus_bitpos (rtx ref, tree t, int objectp, - poly_int64 bitpos) + poly_int64 bitpos, bool may_store_p) { poly_int64 apply_bitpos = 0; tree type; @@ -2059,7 +2060,8 @@ set_mem_attributes_minus_bitpos (rtx ref, tree t, int objectp, t = TREE_OPERAND (t, 0); /* Note whether this expression can trap. */ - MEM_NOTRAP_P (ref) = !tree_could_trap_p (t); + MEM_NOTRAP_P (ref) + = !(may_store_p ? lhs_could_trap_p (t) : tree_could_trap_p (t)); base = get_base_address (t); if (base) @@ -2191,9 +2193,9 @@ set_mem_attributes_minus_bitpos (rtx ref, tree t, int objectp, } void -set_mem_attributes (rtx ref, tree t, int objectp) +set_mem_attributes (rtx ref, tree t, int objectp, bool may_store_p) { - set_mem_attributes_minus_bitpos (ref, t, objectp, 0); + set_mem_attributes_minus_bitpos (ref, t, objectp, 0, may_store_p); } /* Set the alias set of MEM to SET. */ diff --git a/gcc/emit-rtl.h b/gcc/emit-rtl.h index 0b572580a98e..5fae3264cb5e 100644 --- a/gcc/emit-rtl.h +++ b/gcc/emit-rtl.h @@ -552,13 +552,16 @@ extern rtx offset_address (rtx, rtx, unsigned HOST_WIDE_INT); /* Given REF, a MEM, and T, either the type of X or the expression corresponding to REF, set the memory attributes. OBJECTP is nonzero - if we are making a new object of this type. */ -extern void set_mem_attributes (rtx, tree, int); + if we are making a new object of this type. MAY_STORE_P is true when REF + can be the destination of a store. */ +extern void set_mem_attributes (rtx, tree, int, bool = true); /* Similar, except that BITPOS has not yet been applied to REF, so if we alter MEM_OFFSET according to T then we should subtract BITPOS - expecting that it'll be added back in later. */ -extern void set_mem_attributes_minus_bitpos (rtx, tree, int, poly_int64); + expecting that it'll be added back in later. MAY_STORE_P is true when REF + can be the destination of a store. */ +extern void set_mem_attributes_minus_bitpos (rtx, tree, int, poly_int64, + bool = true); /* Return OFFSET if XEXP (MEM, 0) - OFFSET is known to be ALIGN bits aligned for 0 <= OFFSET < ALIGN / BITS_PER_UNIT, or diff --git a/gcc/expr.cc b/gcc/expr.cc index a64fa974048d..a9157dc5d415 100644 --- a/gcc/expr.cc +++ b/gcc/expr.cc @@ -64,6 +64,7 @@ along with GCC; see the file COPYING3. If not see #include "gimple-fold.h" #include "rtx-vector-builder.h" #include "tree-pretty-print.h" +#include "tree-eh.h" #include "flags.h" #include "internal-fn.h" #include "gimple-range.h" @@ -6328,7 +6329,7 @@ expand_assignment (tree to, tree from, bool nontemporal) /* If the field is at offset zero, we could have been given the DECL_RTX of the parent struct. Don't munge it. */ to_rtx = shallow_copy_rtx (to_rtx); - set_mem_attributes_minus_bitpos (to_rtx, to, 0, bitpos); + set_mem_attributes_minus_bitpos (to_rtx, to, 0, bitpos, true); if (volatilep) MEM_VOLATILE_P (to_rtx) = 1; } @@ -11523,6 +11524,10 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode, tree ssa_name = NULL_TREE; gimple *g; + /* EXPAND_NORMAL is the only modifier that guarantees that a memory + reference describes a load. Use store semantics otherwise. */ + const bool may_store_p = modifier != EXPAND_NORMAL; + /* Some ABIs define padding bits in _BitInt uninitialized. Normally, RTL expansion sign/zero extends integral types with less than mode precision when reading from bit-fields and after arithmetic operations (see @@ -11760,6 +11765,11 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode, else decl_rtl = copy_rtx (decl_rtl); + if (exp && MEM_P (decl_rtl)) + MEM_NOTRAP_P (decl_rtl) + = !(may_store_p + ? lhs_could_trap_p (exp) : tree_could_trap_p (exp)); + /* Record writes to register variables. */ if (modifier == EXPAND_WRITE && REG_P (decl_rtl) @@ -12078,7 +12088,7 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode, op0 = addr_for_mem_ref (exp, as, true); op0 = memory_address_addr_space (mode, op0, as); temp = gen_rtx_MEM (mode, op0); - set_mem_attributes (temp, exp, 0); + set_mem_attributes (temp, exp, 0, may_store_p); set_mem_addr_space (temp, as); align = get_object_alignment (exp); if (modifier != EXPAND_WRITE @@ -12165,7 +12175,7 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode, op0 = memory_address_addr_space (mode, op0, as); } temp = gen_rtx_MEM (mode, op0); - set_mem_attributes (temp, exp, 0); + set_mem_attributes (temp, exp, 0, may_store_p); set_mem_addr_space (temp, as); if (TREE_THIS_VOLATILE (exp)) MEM_VOLATILE_P (temp) = 1; @@ -12734,7 +12744,7 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode, we should just honor its original memory attributes. */ if (!(TREE_CODE (tem) == SSA_NAME && (MEM_P (orig_op0) || CONSTANT_P (orig_op0)))) - set_mem_attributes (op0, exp, 0); + set_mem_attributes (op0, exp, 0, may_store_p); if (REG_P (XEXP (op0, 0))) mark_reg_pointer (XEXP (op0, 0), MEM_ALIGN (op0)); @@ -12866,7 +12876,7 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode, if (op0 == orig_op0) op0 = copy_rtx (op0); - set_mem_attributes (op0, treeop0, 0); + set_mem_attributes (op0, treeop0, 0, may_store_p); if (REG_P (XEXP (op0, 0))) mark_reg_pointer (XEXP (op0, 0), MEM_ALIGN (op0)); diff --git a/gcc/testsuite/g++.dg/eh/noncall-store-2.C b/gcc/testsuite/g++.dg/eh/noncall-store-2.C new file mode 100644 index 000000000000..c095c71ca930 --- /dev/null +++ b/gcc/testsuite/g++.dg/eh/noncall-store-2.C @@ -0,0 +1,39 @@ +// Direct stores through reference and this parameters can throw non-call +// exceptions. + +// { dg-do compile } +// { dg-options "-O2 -fnon-call-exceptions -fdump-rtl-expand" } + +void +store_ref (int &value) +{ + try + { + value = 1; + } + catch (...) + { + __builtin_trap (); + } +} + +struct S +{ + int value; + void store (); +}; + +void +S::store () +{ + try + { + value = 1; + } + catch (...) + { + __builtin_trap (); + } +} + +// { dg-final { scan-rtl-dump-times {REG_EH_REGION \(const_int [1-9][0-9]*} 2 "expand" } } diff --git a/gcc/testsuite/g++.dg/opt/mem-notrap-store-asm.C b/gcc/testsuite/g++.dg/opt/mem-notrap-store-asm.C new file mode 100644 index 000000000000..ef26e2283317 --- /dev/null +++ b/gcc/testsuite/g++.dg/opt/mem-notrap-store-asm.C @@ -0,0 +1,23 @@ +// Keep a normal load nontrapping. A memory asm output is a store even when +// expansion must return a MEM. + +// { dg-do compile } +// { dg-options "-O2 -fnon-call-exceptions -fdump-rtl-expand" } + +extern const int output; + +int +load () +{ + return output; +} + +void +store () +{ + asm volatile ("" : "=m" (const_cast (output))); +} + +// { dg-final { scan-rtl-dump {\(mem(?:/[a-z])*/c(?:/[a-z])*:[^\n\r]*\[[0-9]+ output\+0} "expand" } } +// { dg-final { scan-rtl-dump {\(set[ \t\n]+\(mem(?:/[a-z])*:[^\n\r]*\[[0-9]+ output\+0} "expand" } } +// { dg-final { scan-rtl-dump-not {\(set[ \t\n]+\(mem(?:/[a-z])*/c(?:/[a-z])*:[^\n\r]*\[[0-9]+ output\+0} "expand" } } From 740f6ebc5c61bef4c7dd9b9c6addc1946181f047 Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Tue, 8 Sep 2026 11:06:06 +0200 Subject: [PATCH 011/584] builtins: Pass access direction to get_memory_rtx [PR127185] get_memory_rtx creates memory operands for both sources and destinations of string operations. The memory attribute setter cannot infer the access direction from the address expression. Its conservative default therefore loses nontrapping information for known loads. An inline memcmp source changes from: (mem:QI (...) [ this ]) to: (mem/c:QI (...) [ this ]) Add a required STORE_P argument to get_memory_rtx. Mark destinations as stores and sources as loads at every caller. This keeps precise nontrapping information for loads without using it for stores. Bootstrapped and tested on aarch64-unknown-linux-gnu. Tested on x86_64-pc-linux-gnu. PR middle-end/127185 gcc/ChangeLog: * builtins.cc (get_memory_rtx): Add STORE_P. Pass it to set_mem_attributes. (expand_builtin_memory_copy_args): Mark the destination as a store and the source as a load. (expand_movstr): Likewise. (expand_builtin_strncpy): Mark the destination as a store. (expand_builtin_memset_args): Likewise. (expand_builtin_memcmp): Mark both memory operands as loads. (expand_builtin_strcmp): Likewise. (expand_builtin_strncmp): Likewise. (inline_string_cmp): Mark the memory operand as a load. * builtins.h (get_memory_rtx): Add STORE_P. * internal-fn.cc (expand_RAWMEMCHR): Mark the memory operand as a load. gcc/testsuite/ChangeLog: * g++.dg/opt/mem-notrap-load-builtin.C: New test. Signed-off-by: Kyrylo Tkachov --- gcc/builtins.cc | 35 ++++++++++--------- gcc/builtins.h | 2 +- gcc/internal-fn.cc | 2 +- .../g++.dg/opt/mem-notrap-load-builtin.C | 22 ++++++++++++ 4 files changed, 42 insertions(+), 19 deletions(-) create mode 100644 gcc/testsuite/g++.dg/opt/mem-notrap-load-builtin.C diff --git a/gcc/builtins.cc b/gcc/builtins.cc index 056fd20c4c6d..02170d74ae9b 100644 --- a/gcc/builtins.cc +++ b/gcc/builtins.cc @@ -1364,10 +1364,10 @@ expand_builtin_prefetch (tree exp) /* Get a MEM rtx for expression EXP which is the address of an operand to be used in a string instruction (cmpstrsi, cpymemsi, ..). LEN is the maximum length of the block of memory that might be accessed or - NULL if unknown. */ + NULL if unknown. STORE_P is true when EXP is the destination. */ rtx -get_memory_rtx (tree exp, tree len) +get_memory_rtx (tree exp, tree len, bool store_p) { tree orig_exp = exp, base; rtx addr, mem; @@ -1401,7 +1401,7 @@ get_memory_rtx (tree exp, tree len) from the original address we got, and build an all-aliasing unknown-sized access to that one. */ if (is_gimple_mem_ref_addr (TREE_OPERAND (exp, 0))) - set_mem_attributes (mem, exp, 0); + set_mem_attributes (mem, exp, 0, store_p); else if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR && (base = get_base_address (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)))) @@ -1414,7 +1414,7 @@ get_memory_rtx (tree exp, tree len) size_zero_node, NULL)), exp, build_int_cst (ptr_type_node, 0)); - set_mem_attributes (mem, exp, 0); + set_mem_attributes (mem, exp, 0, store_p); /* Since we stripped parts make sure the offset is unknown and the alignment is computed from the original address. */ clear_mem_offset (mem); @@ -3770,7 +3770,7 @@ expand_builtin_memory_copy_args (tree dest, tree src, tree len, if (expected_align < dest_align) expected_align = dest_align; - dest_mem = get_memory_rtx (dest, len); + dest_mem = get_memory_rtx (dest, len, true); set_mem_align (dest_mem, dest_align); len_rtx = expand_normal (len); determine_block_size (len, len_rtx, &min_size, &max_size, @@ -3804,7 +3804,7 @@ expand_builtin_memory_copy_args (tree dest, tree src, tree len, return dest_mem; } - src_mem = get_memory_rtx (src, len); + src_mem = get_memory_rtx (src, len, false); set_mem_align (src_mem, src_align); /* Copy word part most expediently. */ @@ -3873,8 +3873,8 @@ expand_movstr (tree dest, tree src, rtx target, memop_ret retmode) if (!targetm.have_movstr ()) return NULL_RTX; - dest_mem = get_memory_rtx (dest, NULL); - src_mem = get_memory_rtx (src, NULL); + dest_mem = get_memory_rtx (dest, NULL, true); + src_mem = get_memory_rtx (src, NULL, false); if (retmode == RETURN_BEGIN) { target = force_reg (Pmode, XEXP (dest_mem, 0)); @@ -4150,7 +4150,7 @@ expand_builtin_strncpy (tree exp, rtx target) dest_align, false)) return NULL_RTX; - dest_mem = get_memory_rtx (dest, len); + dest_mem = get_memory_rtx (dest, len, true); store_by_pieces (dest_mem, tree_to_uhwi (len), builtin_strncpy_read_str, const_cast (p), dest_align, false, @@ -4709,7 +4709,7 @@ expand_builtin_memset_args (tree dest, tree val, tree len, len_rtx = expand_normal (len); determine_block_size (len, len_rtx, &min_size, &max_size, &probable_max_size); - dest_mem = get_memory_rtx (dest, len); + dest_mem = get_memory_rtx (dest, len, true); val_mode = TYPE_MODE (unsigned_char_type_node); if (TREE_CODE (val) != INTEGER_CST @@ -4893,8 +4893,8 @@ expand_builtin_memcmp (tree exp, rtx target, bool result_eq) if (arg1_align == 0 || arg2_align == 0) return NULL_RTX; - rtx arg1_rtx = get_memory_rtx (arg1, len); - rtx arg2_rtx = get_memory_rtx (arg2, len); + rtx arg1_rtx = get_memory_rtx (arg1, len, false); + rtx arg2_rtx = get_memory_rtx (arg2, len, false); rtx len_rtx = expand_normal (fold_convert_loc (loc, sizetype, len)); /* Set MEM_SIZE as appropriate. */ @@ -4987,8 +4987,8 @@ expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target) arg1 = builtin_save_expr (arg1); arg2 = builtin_save_expr (arg2); - rtx arg1_rtx = get_memory_rtx (arg1, NULL); - rtx arg2_rtx = get_memory_rtx (arg2, NULL); + rtx arg1_rtx = get_memory_rtx (arg1, NULL, false); + rtx arg2_rtx = get_memory_rtx (arg2, NULL, false); /* Try to call cmpstrsi. */ if (cmpstr_icode != CODE_FOR_nothing) @@ -5144,8 +5144,8 @@ expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target, len = fold_convert_loc (loc, sizetype, len); len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len), len, len3); } - rtx arg1_rtx = get_memory_rtx (arg1, len); - rtx arg2_rtx = get_memory_rtx (arg2, len); + rtx arg1_rtx = get_memory_rtx (arg1, len, false); + rtx arg2_rtx = get_memory_rtx (arg2, len, false); rtx arg3_rtx = expand_normal (len); result = expand_cmpstrn_or_cmpmem (cmpstrn_icode, target, arg1_rtx, arg2_rtx, TREE_TYPE (len), arg3_rtx, @@ -7602,7 +7602,8 @@ inline_string_cmp (rtx target, tree var_str, const char *const_str, { HOST_WIDE_INT offset = 0; rtx var_rtx_array - = get_memory_rtx (var_str, build_int_cst (unsigned_type_node,length)); + = get_memory_rtx (var_str, build_int_cst (unsigned_type_node, length), + false); rtx var_rtx = NULL_RTX; rtx const_rtx = NULL_RTX; rtx result = target ? target : gen_reg_rtx (mode); diff --git a/gcc/builtins.h b/gcc/builtins.h index 9cca88c647cc..97b79908d0dd 100644 --- a/gcc/builtins.h +++ b/gcc/builtins.h @@ -162,7 +162,7 @@ extern char target_percent_s[3]; extern char target_percent_c[3]; extern char target_percent_s_newline[4]; extern bool target_char_cst_p (tree t, char *p); -extern rtx get_memory_rtx (tree exp, tree len); +extern rtx get_memory_rtx (tree exp, tree len, bool store_p); extern internal_fn associated_internal_fn (combined_fn, tree); extern internal_fn associated_internal_fn (tree); diff --git a/gcc/internal-fn.cc b/gcc/internal-fn.cc index c57b594ac591..eae0ca9bf51b 100644 --- a/gcc/internal-fn.cc +++ b/gcc/internal-fn.cc @@ -3404,7 +3404,7 @@ expand_RAWMEMCHR (internal_fn, gcall *stmt) create_call_lhs_operand (&ops[0], lhs_rtx, lhs_mode); tree mem = gimple_call_arg (stmt, 0); - rtx mem_rtx = get_memory_rtx (mem, NULL); + rtx mem_rtx = get_memory_rtx (mem, NULL, false); create_fixed_operand (&ops[1], mem_rtx); tree pattern = gimple_call_arg (stmt, 1); diff --git a/gcc/testsuite/g++.dg/opt/mem-notrap-load-builtin.C b/gcc/testsuite/g++.dg/opt/mem-notrap-load-builtin.C new file mode 100644 index 000000000000..1e8bfa0c603a --- /dev/null +++ b/gcc/testsuite/g++.dg/opt/mem-notrap-load-builtin.C @@ -0,0 +1,22 @@ +// Keep the source loads of an inline memcmp nontrapping. + +// { dg-do compile } +// { dg-options "-O2 -fdelete-null-pointer-checks -fnon-call-exceptions -finline-stringops=memcmp -fdump-rtl-expand" } +// { dg-require-effective-target ptr32plus } +// { dg-skip-if "" keeps_null_pointer_checks } + +struct blocks +{ + unsigned char first[16384]; + unsigned char second[16384]; + int compare () const; +}; + +int +blocks::compare () const +{ + return __builtin_memcmp (first, second, sizeof (first)); +} + +// { dg-final { scan-rtl-dump {\(mem(?:/[a-z])*/c(?:/[a-z])*:[^\n\r]*\[ this \]} "expand" } } +// { dg-final { scan-assembler-not {\mmemcmp\M} } } From dbda2911da5be5e11b7c776893fbc96938acf3ce Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Mon, 14 Sep 2026 11:56:09 +0200 Subject: [PATCH 012/584] middle-end: Restore MEM_NOTRAP for memory-only loads [PR127185] EXPAND_MEMORY requires a MEM result but does not state whether the access is a load or a store. Its conservative store semantics avoid unsafe MEM_NOTRAP claims, but two known load callers lose valid nontrapping information. On this patch's parent, a memory-only inline asm input is: (mem/u:SI (...) [ input+0 ]) Restore its load semantics: (mem/u/c:SI (...) [ input+0 ]) The partial-load expander has the same problem. It uses EXPAND_WRITE even though its MEM is the source of a masked or length-limited load. Its source MEM changes from: (mem/u:V4SI (...)) to: (mem/u/c:V4SI (...)) Use EXPAND_MEMORY for partial loads because they require a MEM, then set MEM_NOTRAP from tree_could_trap_p at both caller sites. Bootstrapped and tested on aarch64-unknown-linux-gnu. Tested on x86_64-pc-linux-gnu. PR middle-end/127185 gcc/ChangeLog: * cfgexpand.cc (expand_asm_stmt): Restore load MEM_NOTRAP for memory inputs. * internal-fn.cc: Include tree-eh.h. (expand_partial_load_optab_fn): Expand the source as memory and restore load MEM_NOTRAP. gcc/testsuite/ChangeLog: * g++.dg/opt/mem-notrap-load-asm.C: New test. * gcc.target/i386/mem-notrap-mask-load.c: New test. Signed-off-by: Kyrylo Tkachov --- gcc/cfgexpand.cc | 5 +++- gcc/internal-fn.cc | 4 +++- .../g++.dg/opt/mem-notrap-load-asm.C | 14 +++++++++++ .../gcc.target/i386/mem-notrap-mask-load.c | 23 +++++++++++++++++++ 4 files changed, 44 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/g++.dg/opt/mem-notrap-load-asm.C create mode 100644 gcc/testsuite/gcc.target/i386/mem-notrap-mask-load.c diff --git a/gcc/cfgexpand.cc b/gcc/cfgexpand.cc index 245ba357b5ef..4bd311b11a34 100644 --- a/gcc/cfgexpand.cc +++ b/gcc/cfgexpand.cc @@ -3781,7 +3781,10 @@ expand_asm_stmt (gasm *stmt) if (GET_CODE (op) == CONCAT) op = force_reg (GET_MODE (op), op); else if (MEM_P (op)) - op = validize_mem (op); + { + op = validize_mem (op); + MEM_NOTRAP_P (op) = !tree_could_trap_p (val); + } if (asm_operand_ok (op, constraint, NULL) <= 0) { diff --git a/gcc/internal-fn.cc b/gcc/internal-fn.cc index eae0ca9bf51b..3fdf89e0e6e1 100644 --- a/gcc/internal-fn.cc +++ b/gcc/internal-fn.cc @@ -25,6 +25,7 @@ along with GCC; see the file COPYING3. If not see #include "target.h" #include "rtl.h" #include "tree.h" +#include "tree-eh.h" #include "gimple.h" #include "predict.h" #include "stringpool.h" @@ -3144,8 +3145,9 @@ expand_partial_load_optab_fn (internal_fn ifn, gcall *stmt, convert_optab optab) icode = convert_optab_handler (optab, TYPE_MODE (type), TYPE_MODE (TREE_TYPE (maskt))); - mem = expand_expr (rhs, NULL_RTX, VOIDmode, EXPAND_WRITE); + mem = expand_expr (rhs, NULL_RTX, VOIDmode, EXPAND_MEMORY); gcc_assert (MEM_P (mem)); + MEM_NOTRAP_P (mem) = !tree_could_trap_p (rhs); /* The built MEM_REF does not accurately reflect that the load is only partial. Clear it. */ set_mem_expr (mem, NULL_TREE); diff --git a/gcc/testsuite/g++.dg/opt/mem-notrap-load-asm.C b/gcc/testsuite/g++.dg/opt/mem-notrap-load-asm.C new file mode 100644 index 000000000000..797d6793c0d3 --- /dev/null +++ b/gcc/testsuite/g++.dg/opt/mem-notrap-load-asm.C @@ -0,0 +1,14 @@ +// A memory-only asm input is a load even though expansion must return a MEM. + +// { dg-do compile } +// { dg-options "-O2 -fnon-call-exceptions -fdump-rtl-expand" } + +extern const int input; + +void +load () +{ + asm volatile ("" : : "m" (input)); +} + +// { dg-final { scan-rtl-dump {\(mem(?:/[a-z])*/c(?:/[a-z])*:[^\n\r]*\[[0-9]+ input\+0} "expand" } } diff --git a/gcc/testsuite/gcc.target/i386/mem-notrap-mask-load.c b/gcc/testsuite/gcc.target/i386/mem-notrap-mask-load.c new file mode 100644 index 000000000000..bc510e6ad4f7 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/mem-notrap-mask-load.c @@ -0,0 +1,23 @@ +/* A masked load is a read even though its expander requires a MEM. */ + +/* { dg-do compile } */ +/* { dg-options "-O -fgimple -mavx2 -mno-avx512f -fnon-call-exceptions -fdump-tree-optimized -fdump-rtl-expand" } */ + +typedef int v4si __attribute__ ((vector_size (16))); + +extern const v4si values; + +v4si __GIMPLE (ssa) +load (v4si mask) +{ + v4si result; + + __BB(2): + result_2 = .MASK_LOAD (&values, _Literal (v4si *) 128, + mask_1(D), + _Literal (v4si) { 0, 0, 0, 0 }); + return result_2; +} + +/* { dg-final { scan-tree-dump {\.MASK_LOAD} "optimized" } } */ +/* { dg-final { scan-rtl-dump-times {\(mem/u/c:V4SI} 1 "expand" } } */ From a0cbca7aefb94b0241e706fe737e0326eead413d Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Mon, 14 Sep 2026 10:33:55 +0200 Subject: [PATCH 013/584] strub: Preserve load MEM_NOTRAP for watermarks [PR127185] expand_builtin_strub_update expands a watermark with EXPAND_MEMORY because it needs a MEM. The same MEM is first loaded for a comparison and can then be the destination of a store. EXPAND_MEMORY has conservative store semantics, so the load loses its valid MEM_NOTRAP flag: (set (reg:DI ...) (mem/f:DI (... watermark_ptr ...))) (set (mem/f:DI (... watermark_ptr ...)) (reg:DI ...)) Make a shallow copy for the load and derive its MEM_NOTRAP flag with load trap semantics. Keep the original MEM for the store: (set (reg:DI ...) (mem/f/c:DI (... watermark_ptr ...))) (set (mem/f:DI (... watermark_ptr ...)) (reg:DI ...)) This keeps the memory-result requirement and does not mark the conditional store as nontrapping. Apply load trap semantics to the load-only watermarks in expand_builtin_strub_leave as well. Tighten the existing update test so that it identifies the load and store positions independently of the target mode and MEM flag order. Add a nested at-calls test that checks the incoming watermark loads from both update and leave. Bootstrapped and tested on aarch64-unknown-linux-gnu. Tested on x86_64-pc-linux-gnu. PR middle-end/127185 gcc/ChangeLog: * builtins.cc (expand_builtin_strub_update): Use a separate MEM with load trap semantics for each watermark load. (expand_builtin_strub_leave): Use load trap semantics for watermark MEMs. gcc/testsuite/ChangeLog: * c-c++-common/strub-mem-notrap.c: Tighten the load and store scans. * c-c++-common/strub-mem-notrap-leave.c: New test. Signed-off-by: Kyrylo Tkachov --- gcc/builtins.cc | 11 +++++++-- .../c-c++-common/strub-mem-notrap-leave.c | 23 +++++++++++++++++++ gcc/testsuite/c-c++-common/strub-mem-notrap.c | 7 +++--- 3 files changed, 36 insertions(+), 5 deletions(-) create mode 100644 gcc/testsuite/c-c++-common/strub-mem-notrap-leave.c diff --git a/gcc/builtins.cc b/gcc/builtins.cc index 02170d74ae9b..f2e21a57a59d 100644 --- a/gcc/builtins.cc +++ b/gcc/builtins.cc @@ -30,6 +30,7 @@ along with GCC; see the file COPYING3. If not see #include "tree.h" #include "memmodel.h" #include "gimple.h" +#include "tree-eh.h" #include "predict.h" #include "tm_p.h" #include "stringpool.h" @@ -5617,7 +5618,9 @@ expand_builtin_strub_update (tree exp) build_int_cst (TREE_TYPE (wmptr), 0)); rtx wmark = expand_expr (wmtree, NULL_RTX, ptr_mode, EXPAND_MEMORY); - rtx wmarkr = force_reg (ptr_mode, wmark); + rtx wmark_load = shallow_copy_rtx (wmark); + MEM_NOTRAP_P (wmark_load) = !tree_could_trap_p (wmtree); + rtx wmarkr = force_reg (ptr_mode, wmark_load); rtx_code_label *lab = gen_label_rtx (); do_compare_rtx_and_jump (stktop, wmarkr, STACK_TOPS, STACK_UNSIGNED, @@ -5642,7 +5645,9 @@ expand_builtin_strub_update (tree exp) wmtree = fold_build2 (MEM_REF, wmtype, wmptr, build_int_cst (TREE_TYPE (wmptr), 0)); wmark = expand_expr (wmtree, NULL_RTX, ptr_mode, EXPAND_MEMORY); - wmarkr = force_reg (ptr_mode, wmark); + wmark_load = shallow_copy_rtx (wmark); + MEM_NOTRAP_P (wmark_load) = !tree_could_trap_p (wmtree); + wmarkr = force_reg (ptr_mode, wmark_load); do_compare_rtx_and_jump (stktop, wmarkr, STACK_TOPS, STACK_UNSIGNED, ptr_mode, NULL_RTX, lab, NULL, @@ -5677,6 +5682,7 @@ expand_builtin_strub_leave (tree exp) tree wmtree = fold_build2 (MEM_REF, wmtype, wmptr, build_int_cst (TREE_TYPE (wmptr), 0)); rtx wmark = expand_expr (wmtree, NULL_RTX, ptr_mode, EXPAND_MEMORY); + MEM_NOTRAP_P (wmark) = !tree_could_trap_p (wmtree); stktop = force_reg (ptr_mode, wmark); } @@ -5688,6 +5694,7 @@ expand_builtin_strub_leave (tree exp) tree wmtree = fold_build2 (MEM_REF, wmtype, wmptr, build_int_cst (TREE_TYPE (wmptr), 0)); rtx wmark = expand_expr (wmtree, NULL_RTX, ptr_mode, EXPAND_MEMORY); + MEM_NOTRAP_P (wmark) = !tree_could_trap_p (wmtree); rtx wmarkr = force_reg (ptr_mode, wmark); diff --git a/gcc/testsuite/c-c++-common/strub-mem-notrap-leave.c b/gcc/testsuite/c-c++-common/strub-mem-notrap-leave.c new file mode 100644 index 000000000000..246c4c2088f3 --- /dev/null +++ b/gcc/testsuite/c-c++-common/strub-mem-notrap-leave.c @@ -0,0 +1,23 @@ +// Keep watermark loads nontrapping when a strub context calls another. + +// { dg-do compile } +// { dg-options "-O2 -fstrub=strict -fnon-call-exceptions" } +// { dg-additional-options "-fdelete-null-pointer-checks -fdump-rtl-expand" } +// { dg-require-effective-target strub } +// { dg-skip-if "" keeps_null_pointer_checks } + +extern int callee (int) + __attribute__ ((__strub__ ("at-calls"), __nothrow__)); +volatile int sink; + +__attribute__ ((__strub__ ("at-calls"), __noinline__)) +int +caller (int value) +{ + int result = callee (value); + sink = result; + return result + 1; +} + +// The incoming watermark is loaded once by update and once by leave. +// { dg-final { scan-rtl-dump-times {\(set[ \t\n]+\(reg(?:/[a-z])*:[^\n\r]*\)[ \t\n]+\(mem(?:/[a-z])*/c(?:/[a-z])*:[^\n\r]*[*][.]strub[.]watermark_ptr} 2 "expand" } } diff --git a/gcc/testsuite/c-c++-common/strub-mem-notrap.c b/gcc/testsuite/c-c++-common/strub-mem-notrap.c index ef9bbc39535a..e0f4fe7b34d8 100644 --- a/gcc/testsuite/c-c++-common/strub-mem-notrap.c +++ b/gcc/testsuite/c-c++-common/strub-mem-notrap.c @@ -16,6 +16,7 @@ scrubbed (int value) return sink; } -/* The watermark load is nontrapping. The conditional store can trap. */ -/* { dg-final { scan-rtl-dump {\(mem/f/c:[^\n]*watermark_ptr} "expand" } } */ -/* { dg-final { scan-rtl-dump {\(mem/f:[^\n]*watermark_ptr} "expand" } } */ +// The watermark load is nontrapping. The conditional store can trap. +// { dg-final { scan-rtl-dump {\(set[ \t\n]+\(reg(?:/[a-z])*:[^\n\r]*\)[ \t\n]+\(mem(?:/[a-z])*/c(?:/[a-z])*:[^\n\r]*[*][.]strub[.]watermark_ptr} "expand" } } +// { dg-final { scan-rtl-dump {\(set[ \t\n]+\(mem(?:/[a-z])*:[^\n\r]*[*][.]strub[.]watermark_ptr} "expand" } } +// { dg-final { scan-rtl-dump-not {\(set[ \t\n]+\(mem(?:/[a-z])*/c(?:/[a-z])*:[^\n\r]*[*][.]strub[.]watermark_ptr} "expand" } } From cbef1de0b7bbd566ce2250e5a0bada3be9b833c8 Mon Sep 17 00:00:00 2001 From: Haochen Jiang Date: Wed, 9 Sep 2026 15:28:44 +0800 Subject: [PATCH 014/584] i386: Unify predicate check for ACE tmm reg [PR127264] gcc/ChangeLog: PR target/127264 * config/i386/i386-expand.cc (ix86_expand_ace_builtin): Revise logic to avoid INTVAL check for non-constant operands. gcc/testsuite/ChangeLog: PR target/127264 * gcc.target/i386/pr127264.c: New test. --- gcc/config/i386/i386-expand.cc | 17 +++++++---------- gcc/testsuite/gcc.target/i386/pr127264.c | 7 +++++++ 2 files changed, 14 insertions(+), 10 deletions(-) create mode 100644 gcc/testsuite/gcc.target/i386/pr127264.c diff --git a/gcc/config/i386/i386-expand.cc b/gcc/config/i386/i386-expand.cc index 1c049d0c4410..04fef5841580 100644 --- a/gcc/config/i386/i386-expand.cc +++ b/gcc/config/i386/i386-expand.cc @@ -14773,19 +14773,16 @@ ix86_expand_ace_builtin (const struct builtin_description *d, tree exp, if (i == 0 || i == constant) { - if (i == 0 && !IN_RANGE (INTVAL (op), 0, 7)) + if (!insn_p->operand[i + arg_adjust].predicate (op, SImode)) { - /* This must be the tmm reg number constant. */ - error ("the tmm register number argument must be between 0 to 7"); - return const0_rtx; - } - else if (!insn_p->operand[i + arg_adjust].predicate(op, SImode)) - { - /* This must be the constant. */ - error ("the argument must be constant"); + if (i == 0) + /* This must be the tmm reg number constant. */ + error ("the tmm register number argument must be between 0 to 7"); + else + /* This must be the constant. */ + error ("the argument must be constant"); return const0_rtx; } - } else { diff --git a/gcc/testsuite/gcc.target/i386/pr127264.c b/gcc/testsuite/gcc.target/i386/pr127264.c new file mode 100644 index 000000000000..c83362f4b056 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr127264.c @@ -0,0 +1,7 @@ +/* { dg-do compile { target { ! ia32 } } } */ +/* { dg-options "-O2 -macev1" } */ + +void ace (char c) +{ + __builtin_ia32_tilezero (c); /* { dg-error "the tmm register number argument must be between 0 to 7" "" { target { ! ia32 } } 0 } */ +} From d956c5ad043f767bcde25e09ec48917afb2c8e8c Mon Sep 17 00:00:00 2001 From: Tamar Christina Date: Tue, 15 Sep 2026 08:10:40 +0100 Subject: [PATCH 015/584] AArch64: use alternate fix for FFR CSE bug [PR126629] In the review for the fix for PR126629 Alfie pointed out that this would break FFR widening loads. At the time I thought I could fix REE to handle this, but the patch didn't look appropriate. So after revisiting Alfie's original idea, my main issue was that it would be had to maintain. This approach instead moves the entire SET src UNSPEC into the update_ffr "token" parameter. This allows us to fix the CSE issue, while keeping maintainability and supporting FFR widening loads from the vectorizer. gcc/ChangeLog: PR target/126629 * config/aarch64/aarch64-sve-builtins-base.cc (emit_ldf1_ffr_update): New. (svldff1_gather_impl, svldff1_gather_extend, svldxf1_impl, svldxf1_extend_impl): Use it. * config/aarch64/aarch64-sve.md (aarch64_update_ffr): Update insn. --- .../aarch64/aarch64-sve-builtins-base.cc | 20 +++++++++++++++---- gcc/config/aarch64/aarch64-sve.md | 2 +- 2 files changed, 17 insertions(+), 5 deletions(-) diff --git a/gcc/config/aarch64/aarch64-sve-builtins-base.cc b/gcc/config/aarch64/aarch64-sve-builtins-base.cc index cf18ce7a205d..96697319fdc9 100644 --- a/gcc/config/aarch64/aarch64-sve-builtins-base.cc +++ b/gcc/config/aarch64/aarch64-sve-builtins-base.cc @@ -72,6 +72,18 @@ is_undef (tree val) return false; } +/* Emit the notional FFR update for an LDFF1 or LDNF1 instruction. + Use the load expression rather than the load result, so that later RTL + optimizers can still treat the load result as single-use. */ +static void +emit_ldf1_ffr_update (rtx_insn *load_insn) +{ + rtx set = single_set (load_insn); + gcc_assert (set && GET_CODE (SET_SRC (set)) == UNSPEC); + emit_insn (gen_aarch64_update_ffr (GET_MODE (SET_SRC (set)), + copy_rtx (SET_SRC (set)))); +} + /* Return the UNSPEC_CMLA* unspec for rotation amount ROT. */ static unspec unspec_cmla (int rot) @@ -2028,7 +2040,7 @@ class svldff1_gather_impl : public full_width_access /* See the block comment in aarch64-sve.md for details about the FFR handling. */ - emit_insn (gen_aarch64_update_ffr (mem_mode, res)); + emit_ldf1_ffr_update (get_last_insn ()); return res; } @@ -2055,7 +2067,7 @@ class svldff1_gather_extend : public extending_load rtx res = e.use_exact_insn (icode); /* See the block comment in aarch64-sve.md for details about the FFR handling. */ - emit_insn (gen_aarch64_update_ffr (e.vector_mode (0), res)); + emit_ldf1_ffr_update (get_last_insn ()); return res; } }; @@ -2100,7 +2112,7 @@ class svldxf1_impl : public full_width_access rtx res = e.use_contiguous_load_insn (icode); /* See the block comment in aarch64-sve.md for details about the FFR handling. */ - emit_insn (gen_aarch64_update_ffr (mode, res)); + emit_ldf1_ffr_update (get_last_insn ()); return res; } @@ -2131,7 +2143,7 @@ class svldxf1_extend_impl : public extending_load rtx res = e.use_contiguous_load_insn (icode); /* See the block comment in aarch64-sve.md for details about the FFR handling. */ - emit_insn (gen_aarch64_update_ffr (mode, res)); + emit_ldf1_ffr_update (get_last_insn ()); return res; } diff --git a/gcc/config/aarch64/aarch64-sve.md b/gcc/config/aarch64/aarch64-sve.md index 8b15e25e8b50..dc92cef4d888 100644 --- a/gcc/config/aarch64/aarch64-sve.md +++ b/gcc/config/aarch64/aarch64-sve.md @@ -1155,7 +1155,7 @@ (unspec:VNx16BI [(reg:VNx16BI FFRT_REGNUM) (reg:VNx16BI FFR_REGNUM) - (match_operand:SVE_ALL 0 "register_operand" "w") + (match_operand:SVE_ALL 0 "" "X") ] UNSPEC_UPDATE_FFR))] "TARGET_SVE" "" From afa2c7515d19b01a63bf0bca9a77ea9d55e556a1 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Wed, 2 Sep 2026 13:48:33 +0200 Subject: [PATCH 016/584] ivopts: fix the bound when eliminating an IV with a LT comparison iv_elimination_compare_lt turns a loop with the exit test i < b, entered with i = a and a pointer p = base + a stepping in lockstep with i, into a loop with the exit test p < p_0 - a + b, so as to eliminate the counter. This is unsound in two ways when the loop may roll zero times, i.e. when the number of iterations is a + 1 > b ? 0 : b - a - 1. The first one is that the bound is not recomputed by the function, but taken from cand_value_at, which evaluates the candidate at the number of iterations, i.e. computes p_0 + (b - a - 1 + 1) with b - a computed in the type of the number of iterations. If that type is narrower than the type of the offsets, converting the difference is not value preserving when the loop rolls zero times, since b - a is negative there. For example, with void f (char *p, unsigned int i, unsigned int n) { p += i; do { *p = 1; p += 1; i++; } while (i < n); } called as f (p, 2, 0), the bound is computed as p_0 + (sizetype) 0xfffffffd and the loop walks 4G bytes forward instead of exiting at the first test. The second one is that the comparison of the pointers is performed modulo the size of the address space, so replacing i < b by p_0 - a + i < p_0 - a + b requires the addition of p_0 - a to be order preserving on the values of i and b. That does not hold when the offsets are as wide as a pointer and either of them is large, e.g. for void f (char *p, uintptr_t i, uintptr_t n) { p += i; do { *p = 1; p += 1; i++; } while (i < n); } called as f (a + 2, -2, 8): the bound p_0 - a + b wraps around to the very end of the address space, the test holds and the loop again runs away. So recompute the bound as base + step * b - step * a, converting a and b to the offset type separately, and require the may_be_zero comparison to be an unsigned one and both scaled offsets to be provably non-negative and free of overflow. Since the recomputed bound is the value of the candidate after the last iteration, also require the exit test to come after the increment of the candidate. Finally, move the expression_expensive_p check on the bound after the call so that it applies to the recomputed bound. Assisted-by: Claude Opus 5 PR tree-optimization/113703 * tree-ssa-loop-ivopts.cc: Include gimple-range.h. (nonneg_scaled_offset_p): New function. (iv_elimination_compare_lt): Add USE and BOUND_P parameters. Bail out if the exit test does not come after the increment of the candidate, if the comparison in the number of iterations is signed or if the offsets are not known to be non-negative and to not overflow. Recompute the bound and store it in BOUND_P. (may_eliminate_iv): Adjust the call to iv_elimination_compare_lt and move the expensiveness check on the bound after it. * gcc.dg/tree-ssa/ivopts-lt.c: Use unsigned int counters, restrict to lp64. * gcc.dg/tree-ssa/ivopts-lt-2.c: Restrict to lp64. * gcc.dg/torture/pr113703-1.c: New test. * gcc.dg/torture/pr113703-2.c: New test. --- gcc/testsuite/gcc.dg/torture/pr113703-1.c | 34 ++++++ gcc/testsuite/gcc.dg/torture/pr113703-2.c | 37 ++++++ gcc/testsuite/gcc.dg/tree-ssa/ivopts-lt-2.c | 2 +- gcc/testsuite/gcc.dg/tree-ssa/ivopts-lt.c | 10 +- gcc/tree-ssa-loop-ivopts.cc | 118 ++++++++++++++++---- 5 files changed, 173 insertions(+), 28 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/torture/pr113703-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/pr113703-2.c diff --git a/gcc/testsuite/gcc.dg/torture/pr113703-1.c b/gcc/testsuite/gcc.dg/torture/pr113703-1.c new file mode 100644 index 000000000000..6446d32c039c --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr113703-1.c @@ -0,0 +1,34 @@ +/* { dg-do run } */ +/* { dg-additional-options "-fno-tree-vectorize -fno-tree-loop-distribute-patterns" } */ + +#include + +char a[16]; + +__attribute__((noipa)) void +f (char *p, uintptr_t i, uintptr_t n) +{ + p += i; + do + { + *p = 1; + p += 1; + i++; + } + while (i < n); +} + +int +main () +{ + /* I is -2 and thus not less than N, so the loop stores to A[0] only. + IVOPTs used to replace the exit test by P < (A + 2) + N, which does + not hold at the first test and makes the loop iterate on. */ + f (a + 2, -2, 8); + if (a[0] != 1) + __builtin_abort (); + for (int j = 1; j < 16; j++) + if (a[j] != 0) + __builtin_abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/pr113703-2.c b/gcc/testsuite/gcc.dg/torture/pr113703-2.c new file mode 100644 index 000000000000..0d93be206d78 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr113703-2.c @@ -0,0 +1,37 @@ +/* { dg-do run { target *-*-linux* *-*-gnu* *-*-uclinux* } } */ +/* { dg-additional-options "-fno-tree-vectorize -fno-tree-loop-distribute-patterns" } */ + +#include +#include + +__attribute__((noipa)) void +f (char *p, unsigned int i, unsigned int n) +{ + p += i; + do + { + *p = 1; + p += 1; + i++; + } + while (i < n); +} + +int +main () +{ + long pgsz = sysconf (_SC_PAGESIZE); + char *p = mmap (NULL, pgsz * 2, PROT_READ | PROT_WRITE, + MAP_ANONYMOUS | MAP_PRIVATE, 0, 0); + if (p == MAP_FAILED) + return 0; + mprotect (p + pgsz, pgsz, PROT_NONE); + /* I + 1 is not less than N, so the loop stores to P[4] only. IVOPTs + used to compute the bound of the transformed loop from the number of + iterations N - I - 1, which is (unsigned int) -3 here and gets zero + extended, so that the loop ran into the protected page. */ + f (p + 2, 2, 0); + if (p[4] != 1 || p[5] != 0) + __builtin_abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ivopts-lt-2.c b/gcc/testsuite/gcc.dg/tree-ssa/ivopts-lt-2.c index be325775fbb7..4d244ddadea3 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/ivopts-lt-2.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/ivopts-lt-2.c @@ -1,4 +1,4 @@ -/* { dg-do compile } */ +/* { dg-do compile { target lp64 } } */ /* { dg-options "-O2 -fno-tree-vectorize -fno-tree-loop-distribute-patterns -fdump-tree-ivopts" } */ /* { dg-skip-if "PR68644" { hppa*-*-* powerpc*-*-* } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ivopts-lt.c b/gcc/testsuite/gcc.dg/tree-ssa/ivopts-lt.c index 8d2b9d39355c..2ee43d125675 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/ivopts-lt.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/ivopts-lt.c @@ -1,11 +1,13 @@ -/* { dg-do compile } */ +/* { dg-do compile { target lp64 } } */ /* { dg-options "-O2 -fno-tree-vectorize -fno-tree-loop-distribute-patterns -fdump-tree-ivopts" } */ -/* { dg-require-effective-target stdint_types } */ -#include "stdint.h" +/* The counter can be eliminated in favour of P, since the offsets I and N + are known to be non-negative and small enough not to overflow. Note that + this is not the case for offsets of the width of a pointer, see + gcc.dg/torture/ivopts-lt-1.c. */ void -f1 (char *p, uintptr_t i, uintptr_t n) +f1 (char *p, unsigned int i, unsigned int n) { p += i; do diff --git a/gcc/tree-ssa-loop-ivopts.cc b/gcc/tree-ssa-loop-ivopts.cc index 5a4254290d8e..fa3c2c136fc0 100644 --- a/gcc/tree-ssa-loop-ivopts.cc +++ b/gcc/tree-ssa-loop-ivopts.cc @@ -133,6 +133,7 @@ along with GCC; see the file COPYING3. If not see #include "dbgcnt.h" #include "cfganal.h" #include "gimple-fold.h" +#include "gimple-range.h" /* For lang_hooks.types.type_for_mode. */ #include "langhooks.h" @@ -5234,14 +5235,40 @@ difference_cannot_overflow_p (struct ivopts_data *data, tree base, tree offset) } } +/* Return true if STEP * VAL, computed in OFF_TYPE, is known to be a + non-negative offset which does not overflow, i.e. if the value of VAL is + non-negative and multiplying it by STEP fits in the signed range of + OFF_TYPE. */ + +static bool +nonneg_scaled_offset_p (tree val, HOST_WIDE_INT step, tree off_type) +{ + if (!INTEGRAL_TYPE_P (TREE_TYPE (val)) || step == 0) + return false; + + signop sgn = TYPE_SIGN (TREE_TYPE (val)); + int_range_max r; + if (!get_range_query (cfun)->range_of_expr (r, val) + || r.undefined_p () + || wi::neg_p (r.lower_bound (), sgn)) + return false; + + widest_int max = widest_int::from (r.upper_bound (), sgn); + widest_int limit + = widest_int::from (wi::max_value (TYPE_PRECISION (off_type), SIGNED), + SIGNED); + return wi::leu_p (max, wi::udiv_trunc (limit, absu_hwi (step))); +} + /* Tries to replace loop exit by one formulated in terms of a LT_EXPR comparison with CAND. NITER describes the number of iterations of - the loops. If successful, the comparison in COMP_P is altered accordingly. + the loops. If successful, the comparison in COMP_P is altered accordingly + and the bound in BOUND_P is recomputed. We aim to handle the following situation: sometype *base, *p; - int a, b, i; + unsigned a, b, i; i = a; p = p_0 = base + a; @@ -5265,20 +5292,32 @@ difference_cannot_overflow_p (struct ivopts_data *data, tree base, tree offset) } while (p < p_0 - a + b); - This preserves the correctness, since the pointer arithmetics does not - overflow. More precisely: + Note that the bound has to be computed as p_0 - a + b and not from the + number of iterations as p_0 + (b - a): the latter is only equivalent if + b - a does not wrap, which is not the case when the loop rolls zero times. + + For this to preserve correctness, we need to know that the values compared + in the transformed loop are ordered the same way as i and b are. Since the + comparison of the pointers is performed modulo the size of the address + space, this needs a + 1 > b to be an unsigned comparison, and the offsets + a and b scaled by the step of the candidate to be non-negative and to not + overflow. Then: 1) if a + 1 <= b, then p_0 - a + b is the final value of p, hence there is no - overflow in computing it or the values of p. - 2) if a + 1 > b, then we need to verify that the expression p_0 - a does not - overflow. To prove this, we use the fact that p_0 = base + a. */ + overflow in computing it or the values of p, and the pointers increase + monotonically together with i. + 2) if a + 1 > b, then the loop exits at the first test, and b <= a implies + that p_0 - a + b lies between the valid addresses p_0 - a and p_0, so + the test indeed fails. Here we also need to verify that the expression + p_0 - a does not overflow, which we prove using p_0 = base + a. */ static bool -iv_elimination_compare_lt (struct ivopts_data *data, +iv_elimination_compare_lt (struct ivopts_data *data, struct iv_use *use, struct iv_cand *cand, enum tree_code *comp_p, - class tree_niter_desc *niter) + class tree_niter_desc *niter, tree *bound_p) { - tree cand_type, a, b, mbz, nit_type = TREE_TYPE (niter->niter), offset; + tree cand_type, a, b, mbz, nit_type = TREE_TYPE (niter->niter); + tree off_type, offset, bound; class aff_tree nit, tmpa, tmpb; enum tree_code comp; HOST_WIDE_INT step; @@ -5303,6 +5342,11 @@ iv_elimination_compare_lt (struct ivopts_data *data, return false; step = int_cst_value (cand->iv->step); + /* The bound we compute below is the value the candidate has after the last + iteration, so the exit test has to see the incremented candidate. */ + if (!stmt_after_increment (data->current_loop, cand, use->stmt)) + return false; + /* Check that the number of iterations matches the expected pattern: a + 1 > b ? 0 : b - a - 1. */ mbz = niter->may_be_zero; @@ -5346,14 +5390,25 @@ iv_elimination_compare_lt (struct ivopts_data *data, if (tmpb.n != 0 || maybe_ne (tmpb.offset, 1)) return false; - /* Finally, check that CAND->IV->BASE - CAND->IV->STEP * A does not - overflow. */ - offset = fold_build2 (MULT_EXPR, TREE_TYPE (cand->iv->step), - cand->iv->step, - fold_convert (TREE_TYPE (cand->iv->step), a)); + /* The comparison A + 1 > B only tells us that B is at most A if it is + an unsigned one; otherwise B may well be negative. */ + if (!TYPE_UNSIGNED (TREE_TYPE (a))) + return false; + + /* Check that CAND->IV->BASE - CAND->IV->STEP * A does not overflow. */ + off_type = TREE_TYPE (cand->iv->step); + offset = fold_build2 (MULT_EXPR, off_type, cand->iv->step, + fold_convert (off_type, a)); if (!difference_cannot_overflow_p (data, cand->iv->base, offset)) return false; + /* The candidate is compared as an unsigned quantity, so the offsets by + which A and B move it away from CAND->IV->BASE - CAND->IV->STEP * A have + to be ordered the same way as A and B themselves. */ + if (!nonneg_scaled_offset_p (a, step, off_type) + || !nonneg_scaled_offset_p (b, step, off_type)) + return false; + /* Determine the new comparison operator. */ comp = step < 0 ? GT_EXPR : LT_EXPR; if (*comp_p == NE_EXPR) @@ -5363,6 +5418,22 @@ iv_elimination_compare_lt (struct ivopts_data *data, else gcc_unreachable (); + /* Recompute the bound as CAND->IV->BASE - CAND->IV->STEP * A + + CAND->IV->STEP * B. Deriving it from the number of iterations, as + cand_value_at does, is not correct here: B - A is computed in NIT_TYPE + and converting it to OFF_TYPE is not value preserving when the loop + rolls zero times and B - A is thus negative. */ + bound = fold_build2 (MINUS_EXPR, off_type, + fold_build2 (MULT_EXPR, off_type, cand->iv->step, + fold_convert (off_type, b)), + offset); + cand_type = TREE_TYPE (cand->iv->base); + if (POINTER_TYPE_P (cand_type)) + *bound_p = fold_build_pointer_plus (cand->iv->base, bound); + else + *bound_p = fold_build2 (PLUS_EXPR, cand_type, cand->iv->base, + fold_convert (cand_type, bound)); + return true; } @@ -5472,12 +5543,6 @@ may_eliminate_iv (struct ivopts_data *data, aff_combination_to_tree (&bnd)); *comp = iv_elimination_compare (data, use); - /* It is unlikely that computing the number of iterations using division - would be more profitable than keeping the original induction variable. */ - bool cond_overflow_p; - if (expression_expensive_p (*bound, &cond_overflow_p)) - return false; - /* Sometimes, it is possible to handle the situation that the number of iterations may be zero unless additional assumptions by using < instead of != in the exit condition. @@ -5485,8 +5550,15 @@ may_eliminate_iv (struct ivopts_data *data, TODO: we could also calculate the value MAY_BE_ZERO ? 0 : NITER and base the exit condition on it. However, that is often too expensive. */ - if (!integer_zerop (desc->may_be_zero)) - return iv_elimination_compare_lt (data, cand, comp, desc); + if (!integer_zerop (desc->may_be_zero) + && !iv_elimination_compare_lt (data, use, cand, comp, desc, bound)) + return false; + + /* It is unlikely that computing the number of iterations using division + would be more profitable than keeping the original induction variable. */ + bool cond_overflow_p; + if (expression_expensive_p (*bound, &cond_overflow_p)) + return false; return true; } From 7249bc4aacc443faeb054d082d25e5d5cb819df9 Mon Sep 17 00:00:00 2001 From: Patrick Palka Date: Fri, 21 Aug 2026 09:20:47 -0400 Subject: [PATCH 017/584] libstdc++: Implement LWG 3749 changes to common_iterator A couple of backwards compatibility notes: Since iterator_traits is an empty type the new base class must depend on both the iterator and sentinel types so that two iterator_traits<_It, _Sent1> and iterator_traits<_It, _Sent2> subobjects continue to be potentially overlapping for _Sent1 != _Sent2. And it must be a public base so that iterator_traits continues to be an aggregate type. libstdc++-v3/ChangeLog: * include/bits/stl_iterator.h (__detail::__common_iterator_iter_cat): New. (iterator_traits): Use it to conditionally define iterator_category as per LWG 3749. * testsuite/24_iterators/common_iterator/1.cc (test_lwg3749): New test. Reviewed-by: Jonathan Wakely --- libstdc++-v3/include/bits/stl_iterator.h | 37 +++++++++++++------ .../24_iterators/common_iterator/1.cc | 23 ++++++++++++ 2 files changed, 49 insertions(+), 11 deletions(-) diff --git a/libstdc++-v3/include/bits/stl_iterator.h b/libstdc++-v3/include/bits/stl_iterator.h index f5f2abbb8b6b..bcc22c50de57 100644 --- a/libstdc++-v3/include/bits/stl_iterator.h +++ b/libstdc++-v3/include/bits/stl_iterator.h @@ -2297,8 +2297,33 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION using difference_type = iter_difference_t<_It>; }; + namespace __detail + { + template + struct __common_iterator_iter_cat + { }; + + template + requires integral> + struct __common_iterator_iter_cat<_It, _Sent> + { + static auto + _S_iter_cat() + { + if constexpr (requires { requires derived_from<__iter_category_t<_It>, + forward_iterator_tag>; }) + return forward_iterator_tag{}; + else + return input_iterator_tag{}; + } + + using iterator_category = decltype(_S_iter_cat()); + }; + } // namespace __detail + template struct iterator_traits> + : __detail::__common_iterator_iter_cat<_It, _Sent> { private: template @@ -2315,21 +2340,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION using type = decltype(std::declval().operator->()); }; - static auto - _S_iter_cat() - { - if constexpr (requires { requires derived_from<__iter_category_t<_It>, - forward_iterator_tag>; }) - return forward_iterator_tag{}; - else - return input_iterator_tag{}; - } - public: using iterator_concept = __conditional_t, forward_iterator_tag, input_iterator_tag>; - using iterator_category = decltype(_S_iter_cat()); + // iterator_category defined in base __common_iterator_iter_cat using value_type = iter_value_t<_It>; using difference_type = iter_difference_t<_It>; using pointer = typename __ptr<_It>::type; diff --git a/libstdc++-v3/testsuite/24_iterators/common_iterator/1.cc b/libstdc++-v3/testsuite/24_iterators/common_iterator/1.cc index 77ee33f8ee94..1f830766f912 100644 --- a/libstdc++-v3/testsuite/24_iterators/common_iterator/1.cc +++ b/libstdc++-v3/testsuite/24_iterators/common_iterator/1.cc @@ -18,6 +18,7 @@ // { dg-do run { target c++20 } } #include +#include #include void @@ -193,6 +194,28 @@ test_pr103992() static_assert( test_pr103992() ); +template +concept has_iter_cat = requires { typename std::iterator_traits::iterator_category; }; + +constexpr bool +test_lwg3749() +{ + // LWG 3749 - common_iterator should handle integer-class difference types +#if __SIZEOF_INT128__ + auto v = std::views::iota(__int128(0)); +#else + auto v = std::views::iota(0ll); +#endif + + using Iter = decltype(v.begin()); + static_assert( ! std::integral> ); + static_assert( ! has_iter_cat> ); + + return true; +} + +static_assert( test_lwg3749() ); + int main() { From b1d85e7f8ef2bd152763bbccf1c280ad4ee10ed4 Mon Sep 17 00:00:00 2001 From: Gaius Mulley Date: Tue, 15 Sep 2026 10:11:41 +0100 Subject: [PATCH 018/584] PR modula2/127359: Building modula2 support requires bash installed in path This patch removes direct invocation of bash in libgm2 and replaces bash with sh. libgm2/ChangeLog: PR modula2/127359 * libm2cor/Makefile.am: Replace bash with sh. * libm2iso/Makefile.am: Ditto. * libm2min/Makefile.am: Ditto. * libm2pim/Makefile.am: Ditto. * libm2iso/Makefile.in: Regenerate. * libm2cor/Makefile.in: Ditto. * libm2min/Makefile.in: Ditto. * libm2pim/Makefile.in: Ditto. Signed-off-by: Gaius Mulley --- libgm2/libm2cor/Makefile.am | 2 +- libgm2/libm2cor/Makefile.in | 2 +- libgm2/libm2iso/Makefile.am | 2 +- libgm2/libm2iso/Makefile.in | 2 +- libgm2/libm2min/Makefile.am | 2 +- libgm2/libm2min/Makefile.in | 2 +- libgm2/libm2pim/Makefile.am | 2 +- libgm2/libm2pim/Makefile.in | 2 +- 8 files changed, 8 insertions(+), 8 deletions(-) diff --git a/libgm2/libm2cor/Makefile.am b/libgm2/libm2cor/Makefile.am index dc8478b449a7..26d38dc7f4d6 100644 --- a/libgm2/libm2cor/Makefile.am +++ b/libgm2/libm2cor/Makefile.am @@ -143,7 +143,7 @@ CLEANFILES = SYSTEM.def M2LIBDIR = /m2/m2cor/ SYSTEM.def: Makefile - bash $(GM2_SRC)/tools-src/makeSystem -fpim \ + sh $(GM2_SRC)/tools-src/makeSystem -fpim \ $(GM2_SRC)/gm2-libs-cor-common/SYSTEM.def \ $(GM2_SRC)/gm2-libs-cor-common/SYSTEM.mod \ -I$(GM2_SRC)/gm2-libs-cor-common \ diff --git a/libgm2/libm2cor/Makefile.in b/libgm2/libm2cor/Makefile.in index 3ed34ac34237..8287896cbc4f 100644 --- a/libgm2/libm2cor/Makefile.in +++ b/libgm2/libm2cor/Makefile.in @@ -824,7 +824,7 @@ uninstall-am: uninstall-toolexeclibLTLIBRARIES @BUILD_CORLIB_TRUE@SYSTEM.def: Makefile -@BUILD_CORLIB_TRUE@ bash $(GM2_SRC)/tools-src/makeSystem -fpim \ +@BUILD_CORLIB_TRUE@ sh $(GM2_SRC)/tools-src/makeSystem -fpim \ @BUILD_CORLIB_TRUE@ $(GM2_SRC)/gm2-libs-cor-common/SYSTEM.def \ @BUILD_CORLIB_TRUE@ $(GM2_SRC)/gm2-libs-cor-common/SYSTEM.mod \ @BUILD_CORLIB_TRUE@ -I$(GM2_SRC)/gm2-libs-cor-common \ diff --git a/libgm2/libm2iso/Makefile.am b/libgm2/libm2iso/Makefile.am index e799fd83f808..a73d35d1c0b5 100644 --- a/libgm2/libm2iso/Makefile.am +++ b/libgm2/libm2iso/Makefile.am @@ -253,7 +253,7 @@ SYSTEM.def: Makefile -C="$(GM2_FOR_TARGET)" -o $@ else SYSTEM.def: Makefile - bash $(GM2_SRC)/tools-src/makeSystem -fiso \ + sh $(GM2_SRC)/tools-src/makeSystem -fiso \ $(GM2_SRC)/gm2-libs-iso-common/SYSTEM.def \ $(GM2_SRC)/gm2-libs-iso-common/SYSTEM.mod \ -I$(GM2_SRC)/gm2-libs-iso \ diff --git a/libgm2/libm2iso/Makefile.in b/libgm2/libm2iso/Makefile.in index 53d353d41ce5..a58928a0cf7a 100644 --- a/libgm2/libm2iso/Makefile.in +++ b/libgm2/libm2iso/Makefile.in @@ -965,7 +965,7 @@ uninstall-am: uninstall-toolexeclibLTLIBRARIES @BUILD_ISOLIB_TRUE@@HAVE_PYTHON_INTERPRETER_TRUE@ -I=$(GM2_SRC)/gm2-libs-iso-common \ @BUILD_ISOLIB_TRUE@@HAVE_PYTHON_INTERPRETER_TRUE@ -C="$(GM2_FOR_TARGET)" -o $@ @BUILD_ISOLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@SYSTEM.def: Makefile -@BUILD_ISOLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ bash $(GM2_SRC)/tools-src/makeSystem -fiso \ +@BUILD_ISOLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ sh $(GM2_SRC)/tools-src/makeSystem -fiso \ @BUILD_ISOLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ $(GM2_SRC)/gm2-libs-iso-common/SYSTEM.def \ @BUILD_ISOLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ $(GM2_SRC)/gm2-libs-iso-common/SYSTEM.mod \ @BUILD_ISOLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ -I$(GM2_SRC)/gm2-libs-iso \ diff --git a/libgm2/libm2min/Makefile.am b/libgm2/libm2min/Makefile.am index 3cb33ae6931c..47fa41644783 100644 --- a/libgm2/libm2min/Makefile.am +++ b/libgm2/libm2min/Makefile.am @@ -141,7 +141,7 @@ SYSTEM.def: Makefile -C="$(GM2_FOR_TARGET) -fno-exceptions" -o $@ else SYSTEM.def: Makefile - bash $(GM2_SRC)/tools-src/makeSystem -fpim \ + sh $(GM2_SRC)/tools-src/makeSystem -fpim \ $(GM2_SRC)/gm2-libs-min/SYSTEM.def \ $(GM2_SRC)/gm2-libs-min/SYSTEM.mod \ -I$(GM2_SRC)/gm2-libs-min -I$(GM2_SRC)/gm2-libs \ diff --git a/libgm2/libm2min/Makefile.in b/libgm2/libm2min/Makefile.in index 698e74df411e..12fe0322649f 100644 --- a/libgm2/libm2min/Makefile.in +++ b/libgm2/libm2min/Makefile.in @@ -781,7 +781,7 @@ libc.o: $(GM2_SRC)/gm2-libs-min/libc.c @HAVE_PYTHON_INTERPRETER_TRUE@ -I=$(GM2_SRC)/gm2-libs-min -I=$(GM2_SRC)/gm2-libs \ @HAVE_PYTHON_INTERPRETER_TRUE@ -C="$(GM2_FOR_TARGET) -fno-exceptions" -o $@ @HAVE_PYTHON_INTERPRETER_FALSE@SYSTEM.def: Makefile -@HAVE_PYTHON_INTERPRETER_FALSE@ bash $(GM2_SRC)/tools-src/makeSystem -fpim \ +@HAVE_PYTHON_INTERPRETER_FALSE@ sh $(GM2_SRC)/tools-src/makeSystem -fpim \ @HAVE_PYTHON_INTERPRETER_FALSE@ $(GM2_SRC)/gm2-libs-min/SYSTEM.def \ @HAVE_PYTHON_INTERPRETER_FALSE@ $(GM2_SRC)/gm2-libs-min/SYSTEM.mod \ @HAVE_PYTHON_INTERPRETER_FALSE@ -I$(GM2_SRC)/gm2-libs-min -I$(GM2_SRC)/gm2-libs \ diff --git a/libgm2/libm2pim/Makefile.am b/libgm2/libm2pim/Makefile.am index 5dfe3e7d6cef..4bf52343a21b 100644 --- a/libgm2/libm2pim/Makefile.am +++ b/libgm2/libm2pim/Makefile.am @@ -228,7 +228,7 @@ SYSTEM.def: Makefile -C="$(GM2_FOR_TARGET)" -o $@ else SYSTEM.def: Makefile - bash $(GM2_SRC)/tools-src/makeSystem -fpim \ + sh $(GM2_SRC)/tools-src/makeSystem -fpim \ $(GM2_SRC)/gm2-libs-pim-common/SYSTEM.def \ $(GM2_SRC)/gm2-libs-pim-common/SYSTEM.mod \ -I$(GM2_SRC)/gm2-libs-pim-common \ diff --git a/libgm2/libm2pim/Makefile.in b/libgm2/libm2pim/Makefile.in index 664cdbb2b8d5..b985eec1084f 100644 --- a/libgm2/libm2pim/Makefile.in +++ b/libgm2/libm2pim/Makefile.in @@ -940,7 +940,7 @@ uninstall-am: uninstall-toolexeclibLTLIBRARIES @BUILD_PIMLIB_TRUE@@HAVE_PYTHON_INTERPRETER_TRUE@ -I=$(GM2_SRC)/gm2-libs \ @BUILD_PIMLIB_TRUE@@HAVE_PYTHON_INTERPRETER_TRUE@ -C="$(GM2_FOR_TARGET)" -o $@ @BUILD_PIMLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@SYSTEM.def: Makefile -@BUILD_PIMLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ bash $(GM2_SRC)/tools-src/makeSystem -fpim \ +@BUILD_PIMLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ sh $(GM2_SRC)/tools-src/makeSystem -fpim \ @BUILD_PIMLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ $(GM2_SRC)/gm2-libs-pim-common/SYSTEM.def \ @BUILD_PIMLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ $(GM2_SRC)/gm2-libs-pim-common/SYSTEM.mod \ @BUILD_PIMLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ -I$(GM2_SRC)/gm2-libs-pim-common \ From 920fbabbc3b30c2677b2445c55b29c8547abf01c Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Tue, 15 Sep 2026 12:02:18 +0200 Subject: [PATCH 019/584] i386: Fix up split_double_mode [PR127352] The following testcase ICEs, because we try to split during split2 pass (insn 313 311 314 36 (parallel [ (set (reg:TI 36 r8 [orig:118 b_lsm.27 ] [118]) (and:TI (subreg:TI (reg:SI 36 r8 [orig:107 f ] [107]) 0) (const_int 15 [0xf]))) (clobber (reg:CC 17 flags)) ]) 734 {*andti3_doubleword} (nil)) where the paradoxical subreg is quite reasonable, const_int 15 doesn't have any non-zero bits in the high half, so what exact value we get in the other operand in the high 64 bits is irrelevant. But split_double_mode in that case just calls gen_reg_rtx (half_mode), which ICEs. The high bits of a paradoxical SUBREG can be anything, so this patch after RA chooses one particular value for that, 0 (as the cheapest one and something that likely matches the predicates/constraints of insns using it). 2026-09-15 Jakub Jelinek PR target/127352 * config/i386/i386-expand.cc (split_double_mode): For high halves of paradoxical subregs after RA use CONST0_RTX (half_mode) instead of ICE. * gcc.target/i386/pr127352.c: New test. Reviewed-by: Uros Bizjak --- gcc/config/i386/i386-expand.cc | 9 +++- gcc/testsuite/gcc.target/i386/pr127352.c | 53 ++++++++++++++++++++++++ 2 files changed, 60 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/gcc.target/i386/pr127352.c diff --git a/gcc/config/i386/i386-expand.cc b/gcc/config/i386/i386-expand.cc index 04fef5841580..9e112d017345 100644 --- a/gcc/config/i386/i386-expand.cc +++ b/gcc/config/i386/i386-expand.cc @@ -162,8 +162,13 @@ split_double_mode (machine_mode mode, rtx operands[], GET_MODE (op) == VOIDmode ? mode : GET_MODE (op), byte); /* simplify_gen_subreg will return NULL RTX for the - high half of the paradoxical subreg. */ - hi_half[num] = tmp ? tmp : gen_reg_rtx (half_mode); + high half of the paradoxical subreg. */ + if (tmp) + hi_half[num] = tmp; + else if (can_create_pseudo_p ()) + hi_half[num] = gen_reg_rtx (half_mode); + else + hi_half[num] = CONST0_RTX (half_mode); } } } diff --git a/gcc/testsuite/gcc.target/i386/pr127352.c b/gcc/testsuite/gcc.target/i386/pr127352.c new file mode 100644 index 000000000000..8f7b3a3c2522 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr127352.c @@ -0,0 +1,53 @@ +/* PR target/127352 */ +/* { dg-do compile { target int128 } } */ +/* { dg-options "-O3" } */ + +_BitInt(65) a, b, c; +__int128 d; +_BitInt(7) e; + +long +foo (long x) +{ + return x; +} + +_BitInt(13) +bar (unsigned x, _BitInt(3) y) +{ + return y == 0 ? : x; +} + +_BitInt(65) +baz (_BitInt(65) x, _BitInt(5) y) +{ + return y == 0 ? x : y; +} + +_BitInt(5) +qux () +{ + _BitInt(47) f; + unsigned g = d & 15; + for (unsigned i = 0; i < g; i++) + { + switch (a) + { + case 0: + b = 0; + case 8: + e = 0; + break; + case 10: + long h = g; + f = ~foo (~h); + e = f; + } + if (0 >= b) + continue; + for (unsigned j = 0; j < 1; j++) + b = (_BitInt(7)) (0 >= d ? bar (e, a) : 0); + e = c ? baz (b, i) : 0; + } + return b; +} From 444b851178006081d42e272541f251a86a597306 Mon Sep 17 00:00:00 2001 From: Mikael Morin Date: Tue, 15 Sep 2026 11:28:37 +0200 Subject: [PATCH 020/584] fortran: array descriptor: Move scalar type extraction to callers [PR122521] The function get_scalar_to_descriptor_type only uses the TREE_TYPE() of its first argument. Make the function take the type directly as argument, moving the TREE_TYPE() access to callers. PR fortran/122521 gcc/fortran/ChangeLog: * trans-expr.cc (get_scalar_to_descriptor_type): Remove argument `scalar'; add argument `scalar_type'. Replace `TREE_TYPE (scalar)' with `scalar_type'. (gfc_conv_scalar_to_descriptor, gfc_conv_derived_to_class, gfc_conv_class_to_class): Only pass the type as argument in callers. --- gcc/fortran/trans-expr.cc | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/gcc/fortran/trans-expr.cc b/gcc/fortran/trans-expr.cc index a2b8f12ede36..d7ce70de0e77 100644 --- a/gcc/fortran/trans-expr.cc +++ b/gcc/fortran/trans-expr.cc @@ -88,7 +88,7 @@ gfc_get_character_len_in_bytes (tree type) arrays. */ static tree -get_scalar_to_descriptor_type (tree scalar, symbol_attribute attr) +get_scalar_to_descriptor_type (tree scalar_type, symbol_attribute attr) { enum gfc_array_kind akind; tree *lbound = NULL, *ubound = NULL; @@ -101,18 +101,17 @@ get_scalar_to_descriptor_type (tree scalar, symbol_attribute attr) else akind = GFC_ARRAY_ASSUMED_SHAPE_CONT; - if (POINTER_TYPE_P (TREE_TYPE (scalar))) - scalar = TREE_TYPE (scalar); - if (TYPE_LANG_SPECIFIC (TREE_TYPE (scalar))) + if (POINTER_TYPE_P (scalar_type)) + scalar_type = TREE_TYPE (scalar_type); + if (TYPE_LANG_SPECIFIC (scalar_type)) { - struct lang_type *lang_specific = TYPE_LANG_SPECIFIC (TREE_TYPE (scalar)); + struct lang_type *lang_specific = TYPE_LANG_SPECIFIC (scalar_type); codim = lang_specific->corank; lbound = lang_specific->lbound; ubound = lang_specific->ubound; } - return gfc_get_array_type_bounds (TREE_TYPE (scalar), 0, codim, lbound, - ubound, 1, akind, - !(attr.pointer || attr.target)); + return gfc_get_array_type_bounds (scalar_type, 0, codim, lbound, ubound, 1, + akind, !(attr.pointer || attr.target)); } tree @@ -120,7 +119,7 @@ gfc_conv_scalar_to_descriptor (gfc_se *se, tree scalar, symbol_attribute attr) { tree desc, type, etype; - type = get_scalar_to_descriptor_type (scalar, attr); + type = get_scalar_to_descriptor_type (TREE_TYPE (scalar), attr); etype = TREE_TYPE (scalar); desc = gfc_create_var (type, "desc"); DECL_ARTIFICIAL (desc) = 1; @@ -964,7 +963,7 @@ gfc_conv_derived_to_class (gfc_se *parmse, gfc_expr *e, gfc_symbol *fsym, if (fsym->ts.u.derived->components->as) { tree type; - type = get_scalar_to_descriptor_type (parmse->expr, + type = get_scalar_to_descriptor_type (TREE_TYPE (parmse->expr), gfc_expr_attr (e)); gfc_conv_descriptor_dtype_set (&parmse->pre, ctree, gfc_get_dtype (type)); @@ -1405,7 +1404,7 @@ gfc_conv_class_to_class (gfc_se *parmse, gfc_expr *e, gfc_typespec class_ts, { if (e->rank == 0) { - tree type = get_scalar_to_descriptor_type (parmse->expr, + tree type = get_scalar_to_descriptor_type (TREE_TYPE (parmse->expr), gfc_expr_attr (e)); gfc_conv_descriptor_dtype_set (&block, ctree, gfc_get_dtype (type)); From c38e70f31f1767d13c11cfc97fbcc28d0a6c66ff Mon Sep 17 00:00:00 2001 From: Mikael Morin Date: Tue, 15 Sep 2026 11:28:46 +0200 Subject: [PATCH 021/584] fortran: array descriptor: Move scalar descriptor type creation [PR122521] In the next patch, a chunk of code using get_scalar_to_descriptor_type will be moved to trans-descriptor.cc, requiring the function to be visible outside of trans-expr.cc. Make it public now and move it to trans-types.cc. PR fortran/122521 gcc/fortran/ChangeLog: * trans-types.h (gfc_get_scalar_to_descriptor_type): New declaration. * trans-types.cc (gfc_get_scalar_to_descriptor_type): New function, moved from ... * trans-expr.cc (get_scalar_to_descriptor_type): ... here. (gfc_conv_scalar_to_descriptor, gfc_conv_derived_to_class, gfc_conv_class_to_class): Update function name in callers. --- gcc/fortran/trans-expr.cc | 43 +++++++------------------------------- gcc/fortran/trans-types.cc | 36 +++++++++++++++++++++++++++++++ gcc/fortran/trans-types.h | 1 + 3 files changed, 44 insertions(+), 36 deletions(-) diff --git a/gcc/fortran/trans-expr.cc b/gcc/fortran/trans-expr.cc index d7ce70de0e77..db1a87169e89 100644 --- a/gcc/fortran/trans-expr.cc +++ b/gcc/fortran/trans-expr.cc @@ -84,42 +84,12 @@ gfc_get_character_len_in_bytes (tree type) } -/* Convert a scalar to an array descriptor. To be used for assumed-rank - arrays. */ - -static tree -get_scalar_to_descriptor_type (tree scalar_type, symbol_attribute attr) -{ - enum gfc_array_kind akind; - tree *lbound = NULL, *ubound = NULL; - int codim = 0; - - if (attr.pointer) - akind = GFC_ARRAY_POINTER_CONT; - else if (attr.allocatable) - akind = GFC_ARRAY_ALLOCATABLE; - else - akind = GFC_ARRAY_ASSUMED_SHAPE_CONT; - - if (POINTER_TYPE_P (scalar_type)) - scalar_type = TREE_TYPE (scalar_type); - if (TYPE_LANG_SPECIFIC (scalar_type)) - { - struct lang_type *lang_specific = TYPE_LANG_SPECIFIC (scalar_type); - codim = lang_specific->corank; - lbound = lang_specific->lbound; - ubound = lang_specific->ubound; - } - return gfc_get_array_type_bounds (scalar_type, 0, codim, lbound, ubound, 1, - akind, !(attr.pointer || attr.target)); -} - tree gfc_conv_scalar_to_descriptor (gfc_se *se, tree scalar, symbol_attribute attr) { tree desc, type, etype; - type = get_scalar_to_descriptor_type (TREE_TYPE (scalar), attr); + type = gfc_get_scalar_to_descriptor_type (TREE_TYPE (scalar), attr); etype = TREE_TYPE (scalar); desc = gfc_create_var (type, "desc"); DECL_ARTIFICIAL (desc) = 1; @@ -962,9 +932,9 @@ gfc_conv_derived_to_class (gfc_se *parmse, gfc_expr *e, gfc_symbol *fsym, /* Scalar to an assumed-rank array. */ if (fsym->ts.u.derived->components->as) { - tree type; - type = get_scalar_to_descriptor_type (TREE_TYPE (parmse->expr), - gfc_expr_attr (e)); + tree expr_type = TREE_TYPE (parmse->expr); + tree type = gfc_get_scalar_to_descriptor_type (expr_type, + gfc_expr_attr (e)); gfc_conv_descriptor_dtype_set (&parmse->pre, ctree, gfc_get_dtype (type)); copy_coarray_desc_part (&parmse->pre, ctree, parmse->expr); @@ -1404,8 +1374,9 @@ gfc_conv_class_to_class (gfc_se *parmse, gfc_expr *e, gfc_typespec class_ts, { if (e->rank == 0) { - tree type = get_scalar_to_descriptor_type (TREE_TYPE (parmse->expr), - gfc_expr_attr (e)); + tree type; + type = gfc_get_scalar_to_descriptor_type (TREE_TYPE (parmse->expr), + gfc_expr_attr (e)); gfc_conv_descriptor_dtype_set (&block, ctree, gfc_get_dtype (type)); diff --git a/gcc/fortran/trans-types.cc b/gcc/fortran/trans-types.cc index bb7c1406c5a0..ef80cd8feabb 100644 --- a/gcc/fortran/trans-types.cc +++ b/gcc/fortran/trans-types.cc @@ -2258,6 +2258,42 @@ gfc_get_array_type_bounds (tree etype, int dimen, int codimen, tree * lbound, return fat_type; } + +/* Create and return a zero-rank array descriptor type suitable to hold a scalar + value of type SCALAR_TYPE having attributes ATTR. An array descriptor of the + returned type is to be used as implementation detail when a scalar actual + argument of type SCALAR_TYPE and having attributes ATTR is associated with an + assumed-rank dummy. */ + +tree +gfc_get_scalar_to_descriptor_type (tree scalar_type, symbol_attribute attr) +{ + enum gfc_array_kind akind; + + if (attr.pointer) + akind = GFC_ARRAY_POINTER_CONT; + else if (attr.allocatable) + akind = GFC_ARRAY_ALLOCATABLE; + else + akind = GFC_ARRAY_ASSUMED_SHAPE_CONT; + + if (POINTER_TYPE_P (scalar_type)) + scalar_type = TREE_TYPE (scalar_type); + + tree *lbound = NULL, *ubound = NULL; + int codim = 0; + if (TYPE_LANG_SPECIFIC (scalar_type)) + { + struct lang_type *lang_specific = TYPE_LANG_SPECIFIC (scalar_type); + codim = lang_specific->corank; + lbound = lang_specific->lbound; + ubound = lang_specific->ubound; + } + return gfc_get_array_type_bounds (scalar_type, 0, codim, lbound, ubound, 1, + akind, !(attr.pointer || attr.target)); +} + + /* Build a pointer type. This function is called from gfc_sym_type(). */ static tree diff --git a/gcc/fortran/trans-types.h b/gcc/fortran/trans-types.h index a2169e436c8b..0d75ecf72524 100644 --- a/gcc/fortran/trans-types.h +++ b/gcc/fortran/trans-types.h @@ -105,6 +105,7 @@ tree gfc_get_element_type (tree); tree gfc_get_array_type_bounds (tree, int, int, tree *, tree *, int, enum gfc_array_kind, bool); tree gfc_get_nodesc_array_type (tree, gfc_array_spec *, gfc_packed, bool); +tree gfc_get_scalar_to_descriptor_type (tree, symbol_attribute); /* Add a field of given name and type to a UNION_TYPE or RECORD_TYPE. */ tree gfc_add_field_to_struct (tree, tree, tree, tree **); From 56cd722b9352ce51ffab639b54e0781bdb3436b5 Mon Sep 17 00:00:00 2001 From: Mikael Morin Date: Tue, 15 Sep 2026 11:28:50 +0200 Subject: [PATCH 022/584] fortran: array descriptor: Move scalar descriptor init 1/3 [PR122521] The function gfc_conv_class_to_class has some specific code to initialize an array descriptor when it represents a scalar value. Move that code to its own function in trans-descriptor.cc. PR fortran/122521 gcc/fortran/ChangeLog: * trans-expr.cc (gfc_conv_class_to_class): Move descriptor initialization... * trans-descriptor.cc (gfc_set_descriptor_from_scalar_class): ... here as a new function. * trans-descriptor.h (gfc_set_descriptor_from_scalar_class): New declaration. --- gcc/fortran/trans-descriptor.cc | 23 +++++++++++++++++++++++ gcc/fortran/trans-descriptor.h | 3 +++ gcc/fortran/trans-expr.cc | 14 +------------- 3 files changed, 27 insertions(+), 13 deletions(-) diff --git a/gcc/fortran/trans-descriptor.cc b/gcc/fortran/trans-descriptor.cc index 9c273bf10ea9..177469593b9d 100644 --- a/gcc/fortran/trans-descriptor.cc +++ b/gcc/fortran/trans-descriptor.cc @@ -844,6 +844,29 @@ gfc_create_null_actual_descriptor (stmtblock_t *block, gfc_typespec *ts, } +/* Add code to BLOCK initializing the zero-rank array descriptor DESCR, so that + it represents the same data as the class descriptor reference SCALAR + corresponding to the scalar polymorphic expression SCALAR_EXPR. This is used + to implement the argument association between the actual argument SCALAR_EXPR + and an assumed-rank dummy argument. */ + +void +gfc_set_descriptor_from_scalar_class (stmtblock_t *block, tree descr, + tree scalar, gfc_expr *scalar_expr) +{ + tree type = gfc_get_scalar_to_descriptor_type (TREE_TYPE (scalar), + gfc_expr_attr (scalar_expr)); + gfc_conv_descriptor_dtype_set (block, descr, + gfc_get_dtype (type)); + + tree tmp = gfc_class_data_get (scalar); + if (!POINTER_TYPE_P (TREE_TYPE (tmp))) + tmp = gfc_build_addr_expr (NULL_TREE, tmp); + + gfc_conv_descriptor_data_set (block, descr, tmp); +} + + /* For an array descriptor, get the total number of elements. This is just the product of the extents along from_dim to to_dim. */ diff --git a/gcc/fortran/trans-descriptor.h b/gcc/fortran/trans-descriptor.h index c7f3df02def6..314e99819b43 100644 --- a/gcc/fortran/trans-descriptor.h +++ b/gcc/fortran/trans-descriptor.h @@ -73,6 +73,9 @@ tree gfc_create_unallocated_library_result_descriptor (stmtblock_t *, tree, tree gfc_create_null_actual_descriptor (stmtblock_t *, gfc_typespec *, symbol_attribute, int); +void gfc_set_descriptor_from_scalar_class (stmtblock_t *, tree, tree, + gfc_expr *); + tree gfc_conv_descriptor_size (tree, int); tree gfc_conv_descriptor_cosize (tree, int, int); diff --git a/gcc/fortran/trans-expr.cc b/gcc/fortran/trans-expr.cc index db1a87169e89..e51b02e5ecc8 100644 --- a/gcc/fortran/trans-expr.cc +++ b/gcc/fortran/trans-expr.cc @@ -1373,19 +1373,7 @@ gfc_conv_class_to_class (gfc_se *parmse, gfc_expr *e, gfc_typespec class_ts, && e->rank != class_ts.u.derived->components->as->rank) { if (e->rank == 0) - { - tree type; - type = gfc_get_scalar_to_descriptor_type (TREE_TYPE (parmse->expr), - gfc_expr_attr (e)); - gfc_conv_descriptor_dtype_set (&block, ctree, - gfc_get_dtype (type)); - - tmp = gfc_class_data_get (parmse->expr); - if (!POINTER_TYPE_P (TREE_TYPE (tmp))) - tmp = gfc_build_addr_expr (NULL_TREE, tmp); - - gfc_conv_descriptor_data_set (&block, ctree, tmp); - } + gfc_set_descriptor_from_scalar_class (&block, ctree, parmse->expr, e); else gfc_class_array_data_assign (&block, ctree, parmse->expr, false); } From 72e559d4229737724aa93388565177f72c51cbd4 Mon Sep 17 00:00:00 2001 From: Mikael Morin Date: Tue, 15 Sep 2026 11:28:54 +0200 Subject: [PATCH 023/584] fortran: array descriptor: Move coarray bounds copy [PR122521] In the next patch, a chunk of code using the function copy_coarray_desc_part will be moved to trans-descriptor.cc, requiring the function to be visible outside of trans-expr.cc. Make it public now and move it to trans-descriptor.cc. PR fortran/122521 gcc/fortran/ChangeLog: * trans-descriptor.h (gfc_copy_coarray_desc_part): New declaration. * trans-descriptor.cc (gfc_copy_coarray_desc_part): New function, moved from... * trans-expr.cc (copy_coarray_desc_part): ... here. (gfc_class_array_data_assign, gfc_conv_derived_to_class): Update function name in callers. --- gcc/fortran/trans-descriptor.cc | 40 +++++++++++++++++++++++++++++++++ gcc/fortran/trans-descriptor.h | 2 ++ gcc/fortran/trans-expr.cc | 36 ++--------------------------- 3 files changed, 44 insertions(+), 34 deletions(-) diff --git a/gcc/fortran/trans-descriptor.cc b/gcc/fortran/trans-descriptor.cc index 177469593b9d..4f4335b5332e 100644 --- a/gcc/fortran/trans-descriptor.cc +++ b/gcc/fortran/trans-descriptor.cc @@ -951,6 +951,46 @@ gfc_conv_shift_descriptor_lbound (stmtblock_t* block, tree desc, } +/* Add code to BLOCK copying the cobounds from array descriptor SRC to array + descriptor DEST. The values are picked from SRC's type if they are + set there. Otherwise the runtime values are used with references to SRC's + fields. The type of DEST is not enriched with the cobounds; only + assignments setting DEST's fields at runtime are generated. If SRC is not a + coarray, no code is generated. */ + +void +gfc_copy_coarray_desc_part (stmtblock_t *block, tree dest, tree src) +{ + tree src_type = TREE_TYPE (src); + if (TYPE_LANG_SPECIFIC (src_type) && TYPE_LANG_SPECIFIC (src_type)->corank) + { + struct lang_type *lang_specific = TYPE_LANG_SPECIFIC (src_type); + for (int c = 0; c < lang_specific->corank; ++c) + { + int dim = lang_specific->rank + c; + tree codim = gfc_rank_cst[dim]; + + if (lang_specific->lbound[dim]) + gfc_conv_descriptor_lbound_set (block, dest, codim, + lang_specific->lbound[dim]); + else + gfc_conv_descriptor_lbound_set ( + block, dest, codim, gfc_conv_descriptor_lbound_get (src, codim)); + if (dim + 1 < lang_specific->corank) + { + if (lang_specific->ubound[dim]) + gfc_conv_descriptor_ubound_set (block, dest, codim, + lang_specific->ubound[dim]); + else + gfc_conv_descriptor_ubound_set ( + block, dest, codim, + gfc_conv_descriptor_ubound_get (src, codim)); + } + } + } +} + + void gfc_copy_descriptor (stmtblock_t *block, tree dst, tree src, int rank) { diff --git a/gcc/fortran/trans-descriptor.h b/gcc/fortran/trans-descriptor.h index 314e99819b43..0c13266b7711 100644 --- a/gcc/fortran/trans-descriptor.h +++ b/gcc/fortran/trans-descriptor.h @@ -82,6 +82,8 @@ tree gfc_conv_descriptor_cosize (tree, int, int); /* Shift lower bound of descriptor, updating ubound and offset. */ void gfc_conv_shift_descriptor_lbound (stmtblock_t*, tree, int, tree); +void gfc_copy_coarray_desc_part (stmtblock_t *, tree, tree); + void gfc_copy_descriptor (stmtblock_t *, tree, tree, int); void gfc_grow_array (stmtblock_t *, tree, tree); diff --git a/gcc/fortran/trans-expr.cc b/gcc/fortran/trans-expr.cc index e51b02e5ecc8..e1828534d8d8 100644 --- a/gcc/fortran/trans-expr.cc +++ b/gcc/fortran/trans-expr.cc @@ -761,38 +761,6 @@ gfc_get_vptr_from_expr (tree expr) return NULL_TREE; } -static void -copy_coarray_desc_part (stmtblock_t *block, tree dest, tree src) -{ - tree src_type = TREE_TYPE (src); - if (TYPE_LANG_SPECIFIC (src_type) && TYPE_LANG_SPECIFIC (src_type)->corank) - { - struct lang_type *lang_specific = TYPE_LANG_SPECIFIC (src_type); - for (int c = 0; c < lang_specific->corank; ++c) - { - int dim = lang_specific->rank + c; - tree codim = gfc_rank_cst[dim]; - - if (lang_specific->lbound[dim]) - gfc_conv_descriptor_lbound_set (block, dest, codim, - lang_specific->lbound[dim]); - else - gfc_conv_descriptor_lbound_set ( - block, dest, codim, gfc_conv_descriptor_lbound_get (src, codim)); - if (dim + 1 < lang_specific->corank) - { - if (lang_specific->ubound[dim]) - gfc_conv_descriptor_ubound_set (block, dest, codim, - lang_specific->ubound[dim]); - else - gfc_conv_descriptor_ubound_set ( - block, dest, codim, - gfc_conv_descriptor_ubound_get (src, codim)); - } - } - } -} - void gfc_class_array_data_assign (stmtblock_t *block, tree lhs_desc, tree rhs_desc, bool lhs_type) @@ -821,7 +789,7 @@ gfc_class_array_data_assign (stmtblock_t *block, tree lhs_desc, tree rhs_desc, gfc_add_modify (block, lhs_dim, rhs_dim); /* The corank dimensions are not copied by the ARRAY_RANGE_REF. */ - copy_coarray_desc_part (block, lhs_desc, rhs_desc); + gfc_copy_coarray_desc_part (block, lhs_desc, rhs_desc); } /* Takes a derived type expression and returns the address of a temporary @@ -937,7 +905,7 @@ gfc_conv_derived_to_class (gfc_se *parmse, gfc_expr *e, gfc_symbol *fsym, gfc_expr_attr (e)); gfc_conv_descriptor_dtype_set (&parmse->pre, ctree, gfc_get_dtype (type)); - copy_coarray_desc_part (&parmse->pre, ctree, parmse->expr); + gfc_copy_coarray_desc_part (&parmse->pre, ctree, parmse->expr); if (optional) parmse->expr = build3_loc (input_location, COND_EXPR, TREE_TYPE (parmse->expr), From 0fb68e42be84a4eb7036fd778457f3d1301ceb90 Mon Sep 17 00:00:00 2001 From: Mikael Morin Date: Tue, 15 Sep 2026 11:28:57 +0200 Subject: [PATCH 024/584] fortran: array descriptor: Move scalar descriptor init 2/3 [PR122521] The function gfc_conv_derived_to_class contains code initializing an array descriptor representing a scalar value. Move that code to its own function in trans-descriptor.cc. PR fortran/122521 gcc/fortran/ChangeLog: * trans-expr.cc (gfc_conv_derived_to_class): Move scalar descriptor initialization code ... * trans-descriptor.cc (gfc_set_descriptor_from_scalar): ... here as a new function. * trans-descriptor.h (gfc_set_descriptor_from_scalar): New declaration. --- gcc/fortran/trans-descriptor.cc | 29 +++++++++++++++++++++++++++++ gcc/fortran/trans-descriptor.h | 2 ++ gcc/fortran/trans-expr.cc | 17 ++--------------- 3 files changed, 33 insertions(+), 15 deletions(-) diff --git a/gcc/fortran/trans-descriptor.cc b/gcc/fortran/trans-descriptor.cc index 4f4335b5332e..c6fe64d69d05 100644 --- a/gcc/fortran/trans-descriptor.cc +++ b/gcc/fortran/trans-descriptor.cc @@ -27,6 +27,7 @@ along with GCC; see the file COPYING3. If not see #include "trans-const.h" #include "trans-types.h" #include "trans-array.h" +#include "trans-descriptor.h" /* Array descriptor low level access routines. @@ -844,6 +845,34 @@ gfc_create_null_actual_descriptor (stmtblock_t *block, gfc_typespec *ts, } +/* Add code to BLOCK initializing the zero-rank array descriptor DESCR, so that + it represents the same data as the pointer-typed middle-end expression SCALAR + corresponding to the scalar front-end expression SCALAR_EXPR. If + COND_PRESENCE is set, make the value assigned to the data field either SCALAR + or nullptr depending on COND_PRESENCE; otherwise SCALAR unconditionally. + This is used to implement the argument association between the actual + argument SCALAR_EXPR and an assumed-rank dummy argument. */ + +void +gfc_set_descriptor_from_scalar (stmtblock_t *block, tree descr, + tree scalar, gfc_expr *scalar_expr, + tree cond_presence) +{ + tree type = gfc_get_scalar_to_descriptor_type (TREE_TYPE (scalar), + gfc_expr_attr (scalar_expr)); + gfc_conv_descriptor_dtype_set (block, descr, + gfc_get_dtype (type)); + gfc_copy_coarray_desc_part (block, descr, scalar); + if (cond_presence) + scalar = build3_loc (input_location, COND_EXPR, + TREE_TYPE (scalar), + cond_presence, scalar, + fold_convert (TREE_TYPE (scalar), + null_pointer_node)); + gfc_conv_descriptor_data_set (block, descr, scalar); +} + + /* Add code to BLOCK initializing the zero-rank array descriptor DESCR, so that it represents the same data as the class descriptor reference SCALAR corresponding to the scalar polymorphic expression SCALAR_EXPR. This is used diff --git a/gcc/fortran/trans-descriptor.h b/gcc/fortran/trans-descriptor.h index 0c13266b7711..e4ff7318a971 100644 --- a/gcc/fortran/trans-descriptor.h +++ b/gcc/fortran/trans-descriptor.h @@ -73,6 +73,8 @@ tree gfc_create_unallocated_library_result_descriptor (stmtblock_t *, tree, tree gfc_create_null_actual_descriptor (stmtblock_t *, gfc_typespec *, symbol_attribute, int); +void gfc_set_descriptor_from_scalar (stmtblock_t *, tree, tree, gfc_expr *, + tree); void gfc_set_descriptor_from_scalar_class (stmtblock_t *, tree, tree, gfc_expr *); diff --git a/gcc/fortran/trans-expr.cc b/gcc/fortran/trans-expr.cc index e1828534d8d8..489c4437872f 100644 --- a/gcc/fortran/trans-expr.cc +++ b/gcc/fortran/trans-expr.cc @@ -899,21 +899,8 @@ gfc_conv_derived_to_class (gfc_se *parmse, gfc_expr *e, gfc_symbol *fsym, /* Scalar to an assumed-rank array. */ if (fsym->ts.u.derived->components->as) - { - tree expr_type = TREE_TYPE (parmse->expr); - tree type = gfc_get_scalar_to_descriptor_type (expr_type, - gfc_expr_attr (e)); - gfc_conv_descriptor_dtype_set (&parmse->pre, ctree, - gfc_get_dtype (type)); - gfc_copy_coarray_desc_part (&parmse->pre, ctree, parmse->expr); - if (optional) - parmse->expr = build3_loc (input_location, COND_EXPR, - TREE_TYPE (parmse->expr), - cond_optional, parmse->expr, - fold_convert (TREE_TYPE (parmse->expr), - null_pointer_node)); - gfc_conv_descriptor_data_set (&parmse->pre, ctree, parmse->expr); - } + gfc_set_descriptor_from_scalar (&parmse->pre, ctree, + parmse->expr, e, cond_optional); else { tmp = fold_convert (TREE_TYPE (ctree), parmse->expr); From f101b231e51ee68aa3a18a676f4f9da96c8f1fbe Mon Sep 17 00:00:00 2001 From: Mikael Morin Date: Tue, 15 Sep 2026 11:29:00 +0200 Subject: [PATCH 025/584] fortran: array descriptor: Move scalar descriptor init 3/3 [PR122521] Move the array descriptor initialization part of gfc_conv_scalar_to_descriptor to its own function in trans-descriptor.cc. PR fortran/122521 gcc/fortran/ChangeLog: * trans-expr.cc (gfc_conv_scalar_to_descriptor): Move scalar descriptor initialization code ... * trans-descriptor.cc (gfc_set_descriptor_from_scalar): ... here as a new function. * trans-descriptor.h (gfc_set_descriptor_from_scalar): New declaration. --- gcc/fortran/trans-descriptor.cc | 22 ++++++++++++++++++++++ gcc/fortran/trans-descriptor.h | 1 + gcc/fortran/trans-expr.cc | 14 +++----------- 3 files changed, 26 insertions(+), 11 deletions(-) diff --git a/gcc/fortran/trans-descriptor.cc b/gcc/fortran/trans-descriptor.cc index c6fe64d69d05..2139cd9fc311 100644 --- a/gcc/fortran/trans-descriptor.cc +++ b/gcc/fortran/trans-descriptor.cc @@ -873,6 +873,28 @@ gfc_set_descriptor_from_scalar (stmtblock_t *block, tree descr, } +/* Add code to BLOCK initializing the zero-rank array descriptor DESCR, so that + it represents the same data as the scalar reference SCALAR. This is used to + implement the argument association between the actual argument SCALAR and an + assumed-rank dummy argument. */ + +void +gfc_set_descriptor_from_scalar (stmtblock_t *block, tree descr, tree scalar) +{ + tree etype = TREE_TYPE (scalar); + if (!POINTER_TYPE_P (TREE_TYPE (scalar))) + scalar = gfc_build_addr_expr (NULL_TREE, scalar); + else if (TREE_TYPE (etype) && TREE_CODE (TREE_TYPE (etype)) == ARRAY_TYPE) + etype = TREE_TYPE (etype); + + gfc_conv_descriptor_dtype_set (block, descr, + gfc_get_dtype_rank_type (0, etype)); + gfc_conv_descriptor_data_set (block, descr, scalar); + gfc_conv_descriptor_span_set (block, descr, + gfc_conv_descriptor_elem_len_get (descr)); +} + + /* Add code to BLOCK initializing the zero-rank array descriptor DESCR, so that it represents the same data as the class descriptor reference SCALAR corresponding to the scalar polymorphic expression SCALAR_EXPR. This is used diff --git a/gcc/fortran/trans-descriptor.h b/gcc/fortran/trans-descriptor.h index e4ff7318a971..3f611b1d76af 100644 --- a/gcc/fortran/trans-descriptor.h +++ b/gcc/fortran/trans-descriptor.h @@ -75,6 +75,7 @@ tree gfc_create_null_actual_descriptor (stmtblock_t *, gfc_typespec *, void gfc_set_descriptor_from_scalar (stmtblock_t *, tree, tree, gfc_expr *, tree); +void gfc_set_descriptor_from_scalar (stmtblock_t *, tree, tree); void gfc_set_descriptor_from_scalar_class (stmtblock_t *, tree, tree, gfc_expr *); diff --git a/gcc/fortran/trans-expr.cc b/gcc/fortran/trans-expr.cc index 489c4437872f..dc2888b896ca 100644 --- a/gcc/fortran/trans-expr.cc +++ b/gcc/fortran/trans-expr.cc @@ -87,10 +87,9 @@ gfc_get_character_len_in_bytes (tree type) tree gfc_conv_scalar_to_descriptor (gfc_se *se, tree scalar, symbol_attribute attr) { - tree desc, type, etype; + tree desc, type; type = gfc_get_scalar_to_descriptor_type (TREE_TYPE (scalar), attr); - etype = TREE_TYPE (scalar); desc = gfc_create_var (type, "desc"); DECL_ARTIFICIAL (desc) = 1; @@ -101,15 +100,8 @@ gfc_conv_scalar_to_descriptor (gfc_se *se, tree scalar, symbol_attribute attr) gfc_add_modify (&se->pre, tmp, scalar); scalar = tmp; } - if (!POINTER_TYPE_P (TREE_TYPE (scalar))) - scalar = gfc_build_addr_expr (NULL_TREE, scalar); - else if (TREE_TYPE (etype) && TREE_CODE (TREE_TYPE (etype)) == ARRAY_TYPE) - etype = TREE_TYPE (etype); - gfc_conv_descriptor_dtype_set (&se->pre, desc, - gfc_get_dtype_rank_type (0, etype)); - gfc_conv_descriptor_data_set (&se->pre, desc, scalar); - gfc_conv_descriptor_span_set (&se->pre, desc, - gfc_conv_descriptor_elem_len_get (desc)); + + gfc_set_descriptor_from_scalar (&se->pre, desc, scalar); /* Copy pointer address back - but only if it could have changed and if the actual argument is a pointer and not, e.g., NULL(). */ From 6e33c9be872cc7d2474b4224d1a16515e1b0d2b8 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Tue, 15 Sep 2026 11:34:30 +0200 Subject: [PATCH 026/584] tree-optimization/126760 - vectorization of switches When if-conversion converts a switch statement it requires a certain shape of the CFG. This is verified via if_convertible_switch_p but the check is incorrectly elided for blocks dominating the loop latch. The following rectifies this. PR tree-optimization/126760 PR tree-optimization/127391 * tree-if-conv.cc (if_convertible_stmt_p): Delay switch validation to ... (if_convertible_loop_p_1): ... the loop iterating over PHIs. * gcc.dg/vect/vect-pr126760.c: New testcase. * gcc.dg/vect/vect-pr127391.c: Likewise. --- gcc/testsuite/gcc.dg/vect/vect-pr126760.c | 33 +++++++++++++++++++++++ gcc/testsuite/gcc.dg/vect/vect-pr127391.c | 28 +++++++++++++++++++ gcc/tree-if-conv.cc | 10 +++++-- 3 files changed, 69 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/vect/vect-pr126760.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-pr127391.c diff --git a/gcc/testsuite/gcc.dg/vect/vect-pr126760.c b/gcc/testsuite/gcc.dg/vect/vect-pr126760.c new file mode 100644 index 000000000000..ded34a2e2f72 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-pr126760.c @@ -0,0 +1,33 @@ +#include "tree-vect.h" + +long __attribute__((noipa)) +foo (short a) +{ + long c = a; + unsigned f; + int d = 0, e; + for (; d < 6; d++) { + e = 0; + while (e < 6) { + e++; + f = c; + switch (f) { + case 1: + c = c + d; + case 3: + break; + default: + c = c + d; + } + } + } + return c; +} + +int main() +{ + check_vect (); + if (foo (0) != 3) + __builtin_abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/vect/vect-pr127391.c b/gcc/testsuite/gcc.dg/vect/vect-pr127391.c new file mode 100644 index 000000000000..b3d70171e850 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-pr127391.c @@ -0,0 +1,28 @@ +/* { dg-additional-options "-O3" } */ + +#include "tree-vect.h" + +int __attribute__((noipa)) +fn1 (void) +{ + int b = 0; + for (int f = 0; f < 16; f++) + switch (f % 3) { + case 2: + b += f; + break; + case 0: + b |= f; + case 1: + b |= f; + } + return b; +} +int main() +{ + check_vect (); + if (fn1 () != 63) + __builtin_abort (); + return 0; +} + diff --git a/gcc/tree-if-conv.cc b/gcc/tree-if-conv.cc index fe749f94bd0c..cc3e1dfb4ef2 100644 --- a/gcc/tree-if-conv.cc +++ b/gcc/tree-if-conv.cc @@ -1170,7 +1170,8 @@ if_convertible_stmt_p (gimple *stmt, vec refs) return true; case GIMPLE_SWITCH: - return if_convertible_switch_p (as_a (stmt)); + /* Checked elsewhere. */ + return true; case GIMPLE_ASSIGN: return if_convertible_gimple_assign_stmt_p (stmt, refs); @@ -1708,7 +1709,9 @@ if_convertible_loop_p_1 (class loop *loop, vec *refs) } /* Checking PHIs needs to be done after stmts, as the fact whether there - are any masked loads or stores affects the tests. */ + are any masked loads or stores affects the tests. Also check switch + stmts for supported shape as that cannot be skipped for always + executed blocks. */ for (i = 0; i < loop->num_nodes; i++) { basic_block bb = ifc_bbs[i]; @@ -1717,6 +1720,9 @@ if_convertible_loop_p_1 (class loop *loop, vec *refs) for (itr = gsi_start_phis (bb); !gsi_end_p (itr); gsi_next (&itr)) if (!if_convertible_phi_p (loop, bb, itr.phi ())) return false; + if (gswitch *s = safe_dyn_cast (*gsi_last_bb (bb))) + if (!if_convertible_switch_p (s)) + return false; } if (dump_file) From f4d579b7a2ace16c9b0b7912940ff6809f8ddf9c Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Fri, 7 Aug 2026 11:23:20 +0200 Subject: [PATCH 027/584] genattrtab: table-drive attributes that are functions of one other attribute A machine description often defines one attribute purely in terms of another, so that a scheduling model can group the several hundred values of `type' into the handful its pipeline actually distinguishes. In arm/types.md: (define_attr "mul32" "no,yes" (if_then_else (eq_attr "type" "smulxy,smlaxy,smulwy,smlawx,mul,muls,mla,mlas,smlawy,smuad,\ smuadx,smlad,smladx,smusd,smusdx,smlsd,smlsdx,smmul,smmulr,\ smmla,smlald,smlsld") (const_string "yes") (const_string "no"))) That is a total function from `type' to `mul32', and nothing else. But genattrtab does not represent it that way. optimize_attrs substitutes the definition of `type' into it and folds the result separately for every insn code, so what comes out is a switch over recog_memoized: attr_mul32 get_attr_mul32 (rtx_insn *insn ATTRIBUTE_UNUSED) { attr_type cached_type ATTRIBUTE_UNUSED; switch (recog_memoized (insn)) { case -1: if (GET_CODE (PATTERN (insn)) != ASM_INPUT && asm_noperands (PATTERN (insn)) < 0) fatal_insn_not_found (insn); /* FALLTHRU */ if (((cached_type = get_attr_type (insn)) == TYPE_SMULXY) || (cached_type == TYPE_SMLAXY) ... 20 more ... || (cached_type == TYPE_SMLSLD)) { return MUL32_YES; } else { return MUL32_NO; } case 424: /* *mulsi_neg_uxtw */ case 423: /* *muldi_neg */ ... 10 more ... case 413: /* mulsi3 */ return MUL32_YES; default: return MUL32_NO; } } Two things are worth noticing. The `case -1:' arm, reached for asm statements whose `type' is only known at run time, already contains the mapping in its original form: evaluate `type' once, then decide. Every other arm is that same decision, precomputed for one insn code and re-emitted. So the switch is a partially evaluated copy of a function that the file already knows how to write, keyed on the wrong thing. Emit the mapping directly instead: static const unsigned char mul32_from_type[] = { MUL32_NO, MUL32_NO, ..., MUL32_YES, ..., MUL32_NO, }; attr_mul32 get_attr_mul32 (rtx_insn *insn ATTRIBUTE_UNUSED) { return (attr_mul32) mul32_from_type[get_attr_type (insn)]; } The result is better in three ways. It is one array read rather than a search over insn codes, so it does not grow when the port gains patterns, only when `type' gains values. It has a single control-flow path, so the host compiler has nothing to optimise. And the asm case needs no special handling at all: get_attr_type still issues fatal_insn_not_found, and whatever `type' it returns indexes the same table as any other insn. This is correct by construction rather than by testing. The machine description says the attribute is a function of `type', and a table indexed by `type' is that function. The pass therefore only has to recognise the shape, which it does before optimize_attrs destroys it: a cond, or an if_then_else chain, in which every test selects a set of values of one single other attribute and every value including the default is constant. check_attr_test has already rewritten (eq_attr "type" "a,b,c") into an ior chain over single values, so a test is matched as a boolean combination of eq_attr. Anything else, in particular match_test, match_operand, eq_attr_alt and attr_flag, falls back to the existing expansion. An attribute that a define_insn sets directly is not a function of anything, so that is checked too. One extension is needed for the case that motivates all this. cortex_a57_neon_type is written as a cond over `type', except that its last arm tests is_neon_type, which is itself a function of `type'. So a test of an attribute already known to be a function of the driver counts as a test of the driver, and resolving it is a lookup in that attribute's own table. get_attr_order already supplies the topological order that guarantees the dependency is processed first. Without this, the largest of the transformed attributes is missed. Across the tree 107 of 558 attributes qualify, 62 of them on s390, where the driver is `mnemonic' with over a thousand values. On aarch64 there are eight, and the switches they replace are far from uniform in size: attribute switch lines table + getter lines mul32 39 466 widen_mul64 37 466 is_mve_type 75 466 is_neon_type 4406 466 cortex_a53_advsimd_type 4472 466 cortex_a57_neon_type 5146 466 exynos_m1_neon_type 4708 466 tsv110_neon_type 4523 466 A table is always |type| entries, so the three attributes that only a few patterns use get bigger in source. Emitting a table only when it is the smaller of the two would need a heuristic, and the shape of the generated code, not its size, is the point, so all of them are converted. In total insn-attrtab.cc goes from 4.26MB in 92424 lines to 3.28MB in 72584 lines. It compiles, together with insn-dfatab.cc and insn-latencytab.cc, in 12% less time, with peak memory 313MB against 332MB. Run time is unchanged. Compiling a 39-file C corpus with -mcpu=cortex-a57 takes the same time either way, within a run-to-run spread of about 1.5%. Note that attribute values are not memoised, so a derived attribute now runs get_attr_type's switch rather than its own inlined copy of it. The two are close enough in size that this does not show up. Verified by compiling that corpus with -mcpu=generic, cortex-a57, cortex-a53, exynos-m1, tsv110, neoverse-v2 and neoverse-n1: 273 compilations, and the assembly does not change. On the same compiler all 39 files differ between -mcpu=generic and -mcpu=cortex-a57, so the pipeline models these attributes feed are being exercised. Bootstrapped on aarch64-none-linux-gnu. gcc/ChangeLog: * genattrtab.cc (attr_value): Add enum_index. (attr_desc): Add num_values, derived_from and derived_table. (get_attr_value, add_attr_value, find_attr): Maintain them. (attr_value_index, eq_attr_value_set, simple_enum_attr_p) (sole_tested_attr, find_derived_attrs, write_derived_attr_get): New functions. (write_attr_get): Use write_derived_attr_get where it applies. (main): Call find_derived_attrs before optimize_attrs. Signed-off-by: Kyrylo Tkachov --- gcc/genattrtab.cc | 265 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 265 insertions(+) diff --git a/gcc/genattrtab.cc b/gcc/genattrtab.cc index a2cf08d53058..503c50637aa0 100644 --- a/gcc/genattrtab.cc +++ b/gcc/genattrtab.cc @@ -166,6 +166,8 @@ struct attr_value struct insn_ent *first_insn; /* First insn with this value. */ int num_insns; /* Number of insns with this value. */ int has_asm_insn; /* True if this value used for `asm' insns */ + int enum_index; /* Position in the attribute's enum, or -1 + for a value computed by genattrtab. */ }; /* Structure for each attribute. */ @@ -183,6 +185,13 @@ class attr_desc unsigned is_numeric : 1; /* Values of this attribute are numeric. */ unsigned is_const : 1; /* Attribute value constant for each run. */ unsigned is_special : 1; /* Don't call `write_attr_set'. */ + int num_values; /* Number of declared enum values. */ + + /* Set when the attribute is a function of one other attribute alone. + DERIVED_FROM is that attribute and DERIVED_TABLE maps each of its + enum values to one of ours. */ + class attr_desc *derived_from; + rtx *derived_table; }; /* Structure for each DEFINE_DELAY. */ @@ -1260,6 +1269,7 @@ get_attr_value (file_location loc, rtx value, class attr_desc *attr, av->first_insn = NULL; av->num_insns = 0; av->has_asm_insn = 0; + av->enum_index = -1; return av; } @@ -2886,6 +2896,247 @@ get_attr_order (class attr_desc ***ret) return num; } +/* Return the position of ATTR's enum value called NAME, or -1 if ATTR has + no such value. */ + +static int +attr_value_index (class attr_desc *attr, const char *name) +{ + for (struct attr_value *av = attr->first_value; av; av = av->next) + if (av->enum_index >= 0 && !strcmp (XSTR (av->value, 0), name)) + return av->enum_index; + return -1; +} + +/* Record in SET which of Y's enum values make the attribute test EXP true. + SET has Y->num_values entries. Return false if EXP tests anything beyond + Y and attributes already known to be functions of Y. */ + +static bool +eq_attr_value_set (rtx exp, class attr_desc *y, array_slice set) +{ + int i; + + switch (GET_CODE (exp)) + { + case EQ_ATTR: + { + const char *name = XSTR (exp, 0); + class attr_desc *z = find_attr (&name, 0); + + if (z == y) + { + int index = attr_value_index (y, XSTR (exp, 1)); + if (index < 0) + return false; + for (i = 0; i < y->num_values; i++) + set[i] = false; + set[index] = true; + return true; + } + + /* Testing an attribute that is itself a function of Y still selects + a set of Y values. */ + if (!z || z->derived_from != y) + return false; + for (i = 0; i < y->num_values; i++) + set[i] = !strcmp (XSTR (z->derived_table[i], 0), XSTR (exp, 1)); + return true; + } + + case IOR: + case AND: + { + auto_vec other; + other.safe_grow (y->num_values); + bool ok = (eq_attr_value_set (XEXP (exp, 0), y, set) + && eq_attr_value_set (XEXP (exp, 1), y, other)); + if (ok) + for (i = 0; i < y->num_values; i++) + set[i] = (GET_CODE (exp) == IOR + ? set[i] || other[i] : set[i] && other[i]); + return ok; + } + + case NOT: + if (!eq_attr_value_set (XEXP (exp, 0), y, set)) + return false; + for (i = 0; i < y->num_values; i++) + set[i] = !set[i]; + return true; + + case CONST_INT: + for (i = 0; i < y->num_values; i++) + set[i] = INTVAL (exp) != 0; + return true; + + default: + return false; + } +} + +/* Return true if ATTR's values are a plain enumeration, rather than numbers + or something genattrtab computes for itself. */ + +static bool +simple_enum_attr_p (class attr_desc *attr) +{ + return (!attr->is_const + && !attr->is_special + && !attr->is_numeric + && attr->name[0] != '*'); +} + +/* Return the one attribute that EXP tests, or null if it tests none or more + than one. SOFAR is the attribute found so far, or null. An attribute + already known to be a function of another reports that other one. */ + +static class attr_desc * +sole_tested_attr (rtx exp, class attr_desc *sofar) +{ + const char *fmt = GET_RTX_FORMAT (GET_CODE (exp)); + int i; + + if (GET_CODE (exp) == EQ_ATTR) + { + const char *name = XSTR (exp, 0); + class attr_desc *attr = find_attr (&name, 0); + + if (!attr) + return NULL; + if (attr->derived_from) + attr = attr->derived_from; + return sofar && sofar != attr ? NULL : attr; + } + + for (i = 0; i < GET_RTX_LENGTH (GET_CODE (exp)); i++) + if (fmt[i] == 'e') + { + sofar = sole_tested_attr (XEXP (exp, i), sofar); + if (!sofar) + return NULL; + } + return sofar; +} + +/* Note every attribute whose value is a function of one other attribute + alone, so that write_attr_get can emit a lookup table for it rather than + repeat the other attribute's decision tree for every insn code. + + Run this after fill_attr, so that a define_insn overriding the attribute + is visible, and before optimize_attrs, which folds the cond away. */ + +static void +find_derived_attrs (void) +{ + class attr_desc **order; + int num = get_attr_order (&order); + int n; + + for (n = 0; n < num; n++) + { + class attr_desc *attr = order[n]; + rtx cond = attr->default_val->value; + class attr_desc *y = NULL; + bool overridden = false; + rtx *table; + int i; + + if (!simple_enum_attr_p (attr) + || GET_CODE (cond) != COND) + continue; + + /* A define_insn that sets the attribute directly overrides the cond, + so the attribute is then not a function of anything. */ + for (struct attr_value *av = attr->first_value; av; av = av->next) + if (av != attr->default_val && av->num_insns != 0) + { + overridden = true; + break; + } + if (overridden) + continue; + + for (i = 0; i < XVECLEN (cond, 0); i += 2) + { + y = sole_tested_attr (XVECEXP (cond, 0, i), y); + if (!y || GET_CODE (XVECEXP (cond, 0, i + 1)) != CONST_STRING) + { + y = NULL; + break; + } + } + + /* Y must be a plain enum attribute whose values genattr-common.cc + numbers from zero, so that they can index the table. */ + if (!y + || y == attr + || y->num_values == 0 + || !simple_enum_attr_p (y) + || y->enum_name + || GET_CODE (XEXP (cond, 1)) != CONST_STRING) + continue; + + table = XCNEWVEC (rtx, y->num_values); + auto_vec set; + set.safe_grow (y->num_values); + + for (i = 0; i < XVECLEN (cond, 0); i += 2) + { + if (!eq_attr_value_set (XVECEXP (cond, 0, i), y, set)) + break; + /* The cond takes the first arm that matches, so an entry that is + already filled in stays as it is. */ + for (int k = 0; k < y->num_values; k++) + if (set[k] && !table[k]) + table[k] = XVECEXP (cond, 0, i + 1); + } + + if (i >= XVECLEN (cond, 0)) + { + for (i = 0; i < y->num_values; i++) + if (!table[i]) + table[i] = XEXP (cond, 1); + for (i = 0; i < y->num_values; i++) + gcc_assert (attr_value_index (attr, XSTR (table[i], 0)) >= 0); + attr->derived_from = y; + attr->derived_table = table; + } + else + free (table); + } + + free (order); +} + +/* Emit ATTR's getter as a lookup into a table indexed by the attribute it + is derived from. */ + +static void +write_derived_attr_get (FILE *outf, class attr_desc *attr) +{ + class attr_desc *y = attr->derived_from; + int i; + + gcc_assert (attr->num_values <= USHRT_MAX + 1); + fprintf (outf, "static const %s %s_from_%s[] = {\n", + attr->num_values <= UCHAR_MAX + 1 + ? "unsigned char" : "unsigned short", attr->name, y->name); + for (i = 0; i < y->num_values; i++) + { + fprintf (outf, " "); + write_attr_valueq (outf, attr, XSTR (attr->derived_table[i], 0)); + fprintf (outf, ",\n"); + } + fprintf (outf, "};\n\n"); + + fprintf (outf, "%s\n", attr->cxx_type); + fprintf (outf, "get_attr_%s (rtx_insn *insn ATTRIBUTE_UNUSED)\n{\n", + attr->name); + fprintf (outf, " return (%s) %s_from_%s[get_attr_%s (insn)];\n}\n\n", + attr->cxx_type, attr->name, y->name, y->name); +} + /* Optimize the attribute lists by seeing if we can determine conditional values from the known values of other attributes. This will save subroutine calls during the compilation. NUM_INSN_CODES is the number of unique @@ -3059,6 +3310,7 @@ add_attr_value (class attr_desc *attr, const char *name) av->first_insn = NULL; av->num_insns = 0; av->has_asm_insn = 0; + av->enum_index = attr->num_values++; } /* Create table entries for DEFINE_ATTR or DEFINE_ENUM_ATTR. */ @@ -4056,6 +4308,12 @@ write_attr_get (FILE *outf, class attr_desc *attr) struct attr_value *av, *common_av; int i, j; + if (attr->derived_from) + { + write_derived_attr_get (outf, attr); + return; + } + /* Find the most used attribute value. Handle that as the `default' of the switch we will generate. */ common_av = find_most_used (attr); @@ -4669,6 +4927,9 @@ find_attr (const char **name_p, int create) attr->cxx_type = nullptr; attr->first_value = attr->default_val = NULL; attr->is_numeric = attr->is_const = attr->is_special = 0; + attr->num_values = 0; + attr->derived_from = NULL; + attr->derived_table = NULL; attr->next = attrs[index]; attrs[index] = attr; @@ -5360,6 +5621,10 @@ main (int argc, const char **argv) /* Construct extra attributes for `length'. */ make_length_attrs (); + /* Note the attributes that are functions of one other attribute alone. + This has to happen before optimize_attrs folds their conds away. */ + find_derived_attrs (); + /* Perform any possible optimizations to speed up compilation. */ optimize_attrs (num_insn_codes); From de7711bf18144e6cdae5f78b94d385472f38f51d Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Tue, 4 Aug 2026 21:25:49 +0200 Subject: [PATCH 028/584] gensupport: Centralize machine-generator output management genemit and genrecog use the same size-based output selection, but each generator owns its file names, opens files during option parsing, and closes them separately. Adding more partitioned generators would copy this logic. Put the common output record and lifecycle helpers in gensupport. The helpers validate names, delay file opening until option parsing is complete, select only partition outputs by current size, and close every output with a useful diagnostic. Fixed outputs, such as headers, use the same record but do not participate in selection. Convert genemit and genrecog to the common interface. Also remove the unused output index and disabled round-robin code from choose_output, and remove a genrecog selection whose result is discarded. Diagnose missing or repeated genrecog -H options, remove its fixed header-name limit, and stop printing parsed output options to standard output. Robin Dapp added the shared choose_output helper for PR111600, following the size-based policy that Tamar Christina used in genmatch. The AArch64 all-gcc build and self-tests pass. The 20 normal emit and recog partition files come out unchanged, and so do the one-output files. Duplicate name, cross-role alias, missing option, open failure, and close failure tests pass. Bootstrapped on aarch64-none-linux-gnu. gcc/ChangeLog: * gensupport.h (generator_output): New structure. (add_generator_output, open_generator_outputs): Declare. (close_generator_outputs): Likewise. (choose_output): Accept generator_output records. Remove the output index parameter. * gensupport.cc (add_generator_output): New function. (open_generator_outputs, close_generator_outputs): Likewise. (choose_output): Select only partition records. Remove the output index and disabled round-robin implementation. (SIZED_BASED_CHUNKS): Remove. * genemit.cc (output_files): Use generator_output records. (handle_arg): Register output names. (main): Use the common open, selection, and close helpers. * genrecog.cc (print_subroutine_group): Accept generator_output records. (header_name): Change to a pointer. (header): Remove global variable. (output_files): Use generator_output records. (handle_arg): Register output names and validate -H. (main): Validate and register the header output. Use the common open, selection, and close helpers. Remove an unused output selection. Suggested-by: Tamar Christina Signed-off-by: Kyrylo Tkachov --- gcc/genemit.cc | 27 +++++++--------- gcc/genrecog.cc | 64 ++++++++++++++++---------------------- gcc/gensupport.cc | 78 +++++++++++++++++++++++++++++++++++------------ gcc/gensupport.h | 16 +++++++++- 4 files changed, 111 insertions(+), 74 deletions(-) diff --git a/gcc/genemit.cc b/gcc/genemit.cc index 9c881aa2baee..c40f7fc7fb1a 100644 --- a/gcc/genemit.cc +++ b/gcc/genemit.cc @@ -877,15 +877,14 @@ from the machine description file `md'. */\n\n"); fprintf (file, "#include \"target.h\"\n\n"); } -auto_vec output_files; +auto_vec output_files; static bool handle_arg (const char *arg) { if (arg[1] == 'O') { - FILE *file = fopen (&arg[2], "w"); - output_files.safe_push (file); + add_generator_output (output_files, &arg[2], true); return true; } return false; @@ -909,13 +908,13 @@ main (int argc, const char **argv) md_rtx_info info; if (output_files.is_empty ()) - output_files.safe_push (stdout); + add_generator_output (output_files, NULL, true); + open_generator_outputs (output_files); - for (auto f : output_files) - print_header (f); + for (const generator_output &output : output_files) + print_header (output.file); FILE *file = NULL; - unsigned file_idx; /* Read the machine description. */ while (read_md_rtx (&info)) @@ -940,7 +939,7 @@ main (int argc, const char **argv) for (auto &info : queue) { - file = choose_output (output_files, file_idx); + file = choose_output (output_files); fprintf (file, "/* %s:%d */\n", info.loc.filename, info.loc.lineno); switch (GET_CODE (info.def)) @@ -963,7 +962,7 @@ main (int argc, const char **argv) } } - file = choose_output (output_files, file_idx); + file = choose_output (output_files); /* Write out the routines to add CLOBBERs to a pattern and say whether they clobber a hard reg. */ @@ -976,15 +975,11 @@ main (int argc, const char **argv) for (overloaded_name *oname = rtx_reader_ptr->get_overloads (); oname; oname = oname->next) { - file = choose_output (output_files, file_idx); + file = choose_output (output_files); handle_overloaded_code_for (oname, file); handle_overloaded_gen (oname, file); } - int ret = SUCCESS_EXIT_CODE; - for (FILE *f : output_files) - if (fclose (f) != 0) - ret = FATAL_EXIT_CODE; - - return ret; + return (close_generator_outputs (output_files) + ? SUCCESS_EXIT_CODE : FATAL_EXIT_CODE); } diff --git a/gcc/genrecog.cc b/gcc/genrecog.cc index 04fc23300185..2adf29be705e 100644 --- a/gcc/genrecog.cc +++ b/gcc/genrecog.cc @@ -5340,11 +5340,10 @@ print_subroutine (FILE *f, output_state *os, state *s, int proc_id, /* Print out a routine of type TYPE that performs ROOT. */ static void -print_subroutine_group (vec &vec, FILE *header, output_state *os, +print_subroutine_group (const vec &outputs, FILE *header, + output_state *os, routine_type type, state *root) { - FILE *f; - unsigned idx; os->type = type; if (use_subroutines_p) { @@ -5357,19 +5356,14 @@ print_subroutine_group (vec &vec, FILE *header, output_state *os, unsigned int i; state *s; - FILE *f = header; FOR_EACH_VEC_ELT (subroutines, i, s) print_subroutine (header, os, s, i + 1, true); FOR_EACH_VEC_ELT (subroutines, i, s) - { - f = choose_output (vec, idx); - print_subroutine (f, os, s, i + 1); - } + print_subroutine (choose_output (outputs), os, s, i + 1); } /* Output the main routine. */ - f = choose_output (vec, idx); - print_subroutine (f, os, root, 0); + print_subroutine (choose_output (outputs), os, root, 0); } /* Return the rtx pattern for the list of rtxes in a define_peephole2. */ @@ -5440,24 +5434,22 @@ remove_clobbers (acceptance_type *acceptance_ptr, rtx *pattern_ptr) return true; } -auto_vec output_files; -char header_name[255]; -FILE *header = NULL; +auto_vec output_files; +const char *header_name; static bool handle_arg (const char *arg) { - printf ("%s\n", arg); if (arg[1] == 'O') { - FILE *file = fopen (&arg[2], "w"); - output_files.safe_push (file); + add_generator_output (output_files, &arg[2], true); return true; } if (arg[1] == 'H') { - snprintf (header_name, 255, "%s", &arg[2]); - header = fopen (header_name, "w"); + if (header_name) + fatal ("option -H specified more than once"); + header_name = &arg[2]; return true; } return false; @@ -5473,14 +5465,18 @@ main (int argc, const char **argv) if (!init_rtx_reader_args_cb (argc, argv, handle_arg)) return (FATAL_EXIT_CODE); + if (!header_name) + fatal ("no -H output file specified"); if (output_files.is_empty ()) - output_files.safe_push (stdout); - - for (auto f : output_files) - write_header (f, header_name); + add_generator_output (output_files, NULL, true); + unsigned int header_index + = add_generator_output (output_files, header_name, false); + open_generator_outputs (output_files); + FILE *header = output_files[header_index].file; - FILE *file = NULL; - unsigned file_idx; + for (const generator_output &output : output_files) + if (output.partition_p) + write_header (output.file, header_name); /* Read the machine description. */ @@ -5488,7 +5484,6 @@ main (int argc, const char **argv) while (read_md_rtx (&info)) { rtx def = info.def; - file = choose_output (output_files, file_idx); acceptance_type acceptance; acceptance.partial_p = false; @@ -5546,8 +5541,9 @@ main (int argc, const char **argv) if (have_error) return FATAL_EXIT_CODE; - for (auto f : output_files) - fprintf (f, "%s", "\n\n"); + for (const generator_output &output : output_files) + if (output.partition_p) + fprintf (output.file, "%s", "\n\n"); /* Optimize each routine in turn. */ optimize_subroutine_group ("recog", &insn_root); @@ -5574,10 +5570,7 @@ main (int argc, const char **argv) print_pattern (header, &os, routine, true); FOR_EACH_VEC_ELT (patterns, i, routine) - { - file = choose_output (output_files, file_idx); - print_pattern (file, &os, routine); - } + print_pattern (choose_output (output_files), &os, routine); } /* Print out the matching routines. */ @@ -5588,11 +5581,6 @@ main (int argc, const char **argv) /* Every test has been printed, so the set of conditions is complete. */ print_md_conditions (header); - fclose (header); - - int ret = SUCCESS_EXIT_CODE; - for (FILE *f : output_files) - if (fclose (f) != 0) - ret = FATAL_EXIT_CODE; - return ret; + return (close_generator_outputs (output_files) + ? SUCCESS_EXIT_CODE : FATAL_EXIT_CODE); } diff --git a/gcc/gensupport.cc b/gcc/gensupport.cc index 5fcc30d340eb..0bacafc848b1 100644 --- a/gcc/gensupport.cc +++ b/gcc/gensupport.cc @@ -3935,35 +3935,75 @@ find_optab (optab_pattern *p, const char *name) return false; } -/* Find the file to write into next. We try to evenly distribute the contents - over the different files. */ +/* Add output NAME to OUTPUTS. A null NAME means standard output. + PARTITION_P is true if the output participates in size-based selection. + Return its index. */ -#define SIZED_BASED_CHUNKS 1 +unsigned int +add_generator_output (vec &outputs, const char *name, + bool partition_p) +{ + gcc_assert (name || outputs.is_empty ()); + if (name) + for (const generator_output &output : outputs) + if (output.name && canonical_filename_eq (name, output.name)) + fatal ("output file %s specified more than once", name); + + generator_output output = { name, name ? NULL : stdout, partition_p }; + unsigned int index = outputs.length (); + outputs.safe_push (output); + return index; +} + +/* Open each named file in OUTPUTS. */ + +void +open_generator_outputs (vec &outputs) +{ + for (generator_output &output : outputs) + if (!output.file) + { + output.file = fopen (output.name, "w"); + if (!output.file) + fatal ("cannot open file %s: %s", output.name, xstrerror (errno)); + } +} + +/* Return the shortest partition file in OUTPUTS. */ FILE * -choose_output (const vec &parts, unsigned &idx) +choose_output (const vec &outputs) { - if (parts.length () == 0) - gcc_unreachable (); -#ifdef SIZED_BASED_CHUNKS FILE *shortest = NULL; long min = 0; - idx = 0; - for (unsigned i = 0; i < parts.length (); i++) + for (const generator_output &output : outputs) { - FILE *part = parts[i]; - long len = ftell (part); + if (!output.partition_p) + continue; + long len = ftell (output.file); if (!shortest || min > len) { - shortest = part; + shortest = output.file; min = len; - idx = i; - } + } } + if (!shortest) + gcc_unreachable (); return shortest; -#else - static int current_file; - idx = current_file++ % parts.length (); - return parts[idx]; -#endif +} + +/* Close all files in OUTPUTS. Return true if every close succeeds. */ + +bool +close_generator_outputs (const vec &outputs) +{ + bool ok = true; + for (const generator_output &output : outputs) + if (fclose (output.file) != 0) + { + error ("cannot close output %s: %s", + output.name ? output.name : "", xstrerror (errno)); + ok = false; + } + return ok; } diff --git a/gcc/gensupport.h b/gcc/gensupport.h index 86dd11034365..880505355b28 100644 --- a/gcc/gensupport.h +++ b/gcc/gensupport.h @@ -232,6 +232,20 @@ extern void compute_test_codes (rtx, file_location, char *); extern file_location get_file_location (rtx); extern const char *get_emit_function (rtx); extern bool find_optab (optab_pattern *, const char *); -extern FILE *choose_output (const vec &, unsigned &); + +/* An output file produced by a machine-description generator. Partition + files participate in size-based output selection. */ +struct generator_output +{ + const char *name; + FILE *file; + bool partition_p; +}; + +extern unsigned int add_generator_output (vec &, + const char *, bool); +extern void open_generator_outputs (vec &); +extern FILE *choose_output (const vec &); +extern bool close_generator_outputs (const vec &); #endif /* GCC_GENSUPPORT_H */ From 6b475612c288c4bfc40bc4747f7efa594c621a9f Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Tue, 4 Aug 2026 21:25:50 +0200 Subject: [PATCH 029/584] genattrtab: Distribute generated code across multiple files insn-attrtab.cc contains many independent get_attr_* functions. Several have large switches over every instruction code, making the single source one of the slowest objects in a measured AArch64 bootstrap. Let genattrtab write multiple attribute outputs, following genemit and genrecog. Reuse --with-insnemit-partitions and make -A repeatable. Register the -A, -D, and -L outputs through the common gensupport machinery. This gives all output roles one validation, open, selection, and close lifecycle. Also distribute the fixed delay and length functions. Keep DFA and latency functions in their existing single files. choose_output places each function in the shortest partition so far, which only balances well if the large functions are placed early. Attribute functions differ in size by two orders of magnitude, so an arbitrary order lets a late large function land on an already full partition. Sort the functions by the amount of text write_attr_get will produce, largest first. For a derived attribute that amount is the length of its lookup table, and otherwise the number of case labels that survive find_most_used. The functions refer to one another through insn-attr.h and insn-attr-common.h, so generated headers do not change. With one -A option the delay and latency outputs are unchanged from the previous generator. The attribute output holds the same lines at the same total size, reordered, because the sort applies at any partition count. On AArch64 with ten partitions the sorted order reduces the spread between the largest and smallest partition from 5.9x to 2.3x. The largest partition is then within 0.1% of the size that no assignment can beat, since one attribute function alone accounts for that much of the total. The largest attribute part is about 83% smaller than the original single source, and the slowest attribute object compiles about 76% faster. Native AArch64 and RISC-V cross all-gcc builds pass. Bootstrapped on aarch64-none-linux-gnu. gcc/ChangeLog: * Makefile.in (INSNATTRTAB_SPLITS_SEQ, INSNATTRTAB_SEQ_SRC) (INSNATTRTAB_SEQ_TMP, INSNATTRTAB_SEQ_O): New variables. (OBJS): Replace insn-attrtab.o with $(INSNATTRTAB_SEQ_O). (MOSTLYCLEANFILES): Add $(INSNATTRTAB_SEQ_SRC), retaining the legacy unnumbered source for cleanup. (.PRECIOUS): Use $(INSNATTRTAB_SEQ_SRC). (s-attrtab): Generate and move numbered attribute files. Stop when a move fails. * configure.ac (--with-insnemit-partitions): Document all generators which use the option. * configure: Regenerate. * genattrtab.cc (attr_file_name, attr_file, open_outfile): Remove. (output_files): New variable. (dfa_file_name, latency_file_name): Retain output names. (make_automaton_attrs): Write to the first attribute partition. (handle_arg): Register repeatable attribute outputs. (attr_output_size, cmp_attr_output_size): New functions. (main): Register fixed outputs and use the common output helpers. Distribute attribute, delay, and length functions, largest first. * final.cc (length_unit_log): Update comment for partitioned output. * config/arc/arc-protos.h (regno_clobbered_p): Likewise. * config/ia64/ia64.cc (bundling): Likewise. * config/ia64/t-ia64 (insn-attrtab.o-warn): Replace with per-partition warning variables. * config/sh/sh.h (code_for_indirect_jump_scratch): Update comment for partitioned output. contrib/ChangeLog: * filter-clang-warnings.py (skip_warning): Match numbered attribute files. Signed-off-by: Kyrylo Tkachov --- contrib/filter-clang-warnings.py | 2 +- gcc/Makefile.in | 32 +++++-- gcc/config/arc/arc-protos.h | 3 +- gcc/config/ia64/ia64.cc | 4 +- gcc/config/ia64/t-ia64 | 3 +- gcc/config/sh/sh.h | 5 +- gcc/configure | 11 ++- gcc/configure.ac | 6 +- gcc/final.cc | 2 +- gcc/genattrtab.cc | 152 ++++++++++++++++++++----------- 10 files changed, 145 insertions(+), 75 deletions(-) diff --git a/contrib/filter-clang-warnings.py b/contrib/filter-clang-warnings.py index 9de005990b52..ba2fa532f825 100755 --- a/contrib/filter-clang-warnings.py +++ b/contrib/filter-clang-warnings.py @@ -56,7 +56,7 @@ def skip_warning(filename, message): 'ipa-strub.cc': ['-Wunused-but-set-variable'], 'insn-modes.cc': ['-Wshift-count-overflow'], 'insn-emit': ['-Wtautological-compare'], - 'insn-attrtab.cc': ['-Wparentheses-equality'], + 'insn-attrtab': ['-Wparentheses-equality'], 'omp-builtins.def': ['-Wc++11-narrowing'], 'wide-int.h': ['-Wnontrivial-memcall'], 'i386.md': ['-Wparentheses-equality', '-Wtautological-compare', diff --git a/gcc/Makefile.in b/gcc/Makefile.in index c718585e6071..f88279839fd8 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -241,6 +241,14 @@ INSNRECOG_SEQ_SRC = $(patsubst %, insn-recog-%.cc, $(INSNRECOG_SPLITS_SEQ)) INSNRECOG_SEQ_TMP = $(patsubst %, tmp-recog-%.cc, $(INSNRECOG_SPLITS_SEQ)) INSNRECOG_SEQ_O = $(patsubst %, insn-recog-%.o, $(INSNRECOG_SPLITS_SEQ)) +# Re-use the split number for insn-attrtab as well. +INSNATTRTAB_SPLITS_SEQ = $(wordlist 1,$(NUM_INSNEMIT_SPLITS),$(one_to_9999)) +INSNATTRTAB_SEQ_SRC = $(patsubst %, insn-attrtab-%.cc, \ + $(INSNATTRTAB_SPLITS_SEQ)) +INSNATTRTAB_SEQ_TMP = $(patsubst %, tmp-attrtab-%.cc, \ + $(INSNATTRTAB_SPLITS_SEQ)) +INSNATTRTAB_SEQ_O = $(patsubst %, insn-attrtab-%.o, $(INSNATTRTAB_SPLITS_SEQ)) + # These files are to have specific diagnostics suppressed, or are not to # be subject to -Werror: # flex output may yield harmless "no previous prototype" warnings @@ -1405,7 +1413,7 @@ OBJS = \ $(GIMPLE_MATCH_PD_SEQ_O) \ gimple-match-exports.o \ $(GENERIC_MATCH_PD_SEQ_O) \ - insn-attrtab.o \ + $(INSNATTRTAB_SEQ_O) \ insn-automata.o \ insn-dfatab.o \ $(INSNEMIT_SEQ_O) \ @@ -1987,8 +1995,10 @@ FULL_DRIVER_NAME=$(target_noncanonical)-gcc-$(version)$(exeext) MOSTLYCLEANFILES = insn-flags.h insn-config.h insn-codes.h \ insn-output.cc $(INSNRECOG_SEQ_SRC) insn-recog.h \ $(INSNEMIT_SEQ_SRC) insn-extract.cc insn-peep.cc \ - insn-attr.h insn-attr-common.h insn-attrtab.cc insn-dfatab.cc \ - insn-latencytab.cc insn-opinit.cc insn-opinit.h insn-preds.cc insn-constants.h \ + insn-attr.h insn-attr-common.h $(INSNATTRTAB_SEQ_SRC) insn-attrtab.cc \ + insn-dfatab.cc insn-latencytab.cc insn-opinit.cc \ + insn-opinit.h insn-preds.cc \ + insn-constants.h \ tm-preds.h tm-constrs.h checksum-options $(GIMPLE_MATCH_PD_SEQ_SRC) \ $(GENERIC_MATCH_PD_SEQ_SRC) gimple-match-auto.h generic-match-auto.h \ tree-check.h min-insn-modes.cc insn-modes.cc insn-modes.h insn-modes-inline.h \ @@ -2764,7 +2774,7 @@ $(common_out_object_file): $(common_out_file) .PRECIOUS: insn-config.h insn-flags.h insn-codes.h insn-constants.h \ $(INSNEMIT_SEQ_SRC) insn-recog.h $(INSNRECOG_SEQ_SRC) \ insn-extract.cc insn-output.cc \ - insn-peep.cc insn-attr.h insn-attr-common.h insn-attrtab.cc \ + insn-peep.cc insn-attr.h insn-attr-common.h $(INSNATTRTAB_SEQ_SRC) \ insn-dfatab.cc insn-latencytab.cc insn-preds.cc \ $(GIMPLE_MATCH_PD_SEQ_SRC) $(GENERIC_MATCH_PD_SEQ_SRC) \ gimple-match-auto.h generic-match-auto.h insn-target-def.h @@ -2851,13 +2861,19 @@ s-check : build/gencheck$(build_exeext) $(SHELL) $(srcdir)/../move-if-change tmp-check.h tree-check.h $(STAMP) s-check -# genattrtab produces three files: tmp-{attrtab.cc,dfatab.cc,latencytab.cc} -insn-attrtab.cc insn-dfatab.cc insn-latencytab.cc: s-attrtab ; @true +# genattrtab splits the attribute functions like genemit and additionally +# produces tmp-dfatab.cc and tmp-latencytab.cc. +$(INSNATTRTAB_SEQ_SRC): s-attrtab ; @true +insn-dfatab.cc insn-latencytab.cc: s-attrtab ; @true s-attrtab : $(MD_DEPS) build/genattrtab$(build_exeext) \ insn-conditions.md $(RUN_GEN) build/genattrtab$(build_exeext) $(md_file) insn-conditions.md \ - -Atmp-attrtab.cc -Dtmp-dfatab.cc -Ltmp-latencytab.cc - $(SHELL) $(srcdir)/../move-if-change tmp-attrtab.cc insn-attrtab.cc + $(addprefix -A,${INSNATTRTAB_SEQ_TMP}) \ + -Dtmp-dfatab.cc -Ltmp-latencytab.cc + for id in $(INSNATTRTAB_SPLITS_SEQ); do \ + $(SHELL) $(srcdir)/../move-if-change tmp-attrtab-$$id.cc \ + insn-attrtab-$$id.cc || exit 1; \ + done $(SHELL) $(srcdir)/../move-if-change tmp-dfatab.cc insn-dfatab.cc $(SHELL) $(srcdir)/../move-if-change tmp-latencytab.cc insn-latencytab.cc $(STAMP) s-attrtab diff --git a/gcc/config/arc/arc-protos.h b/gcc/config/arc/arc-protos.h index fc36d52ead06..380f2c397771 100644 --- a/gcc/config/arc/arc-protos.h +++ b/gcc/config/arc/arc-protos.h @@ -93,7 +93,8 @@ extern bool arc_text_label (rtx_insn *insn); extern bool arc_short_comparison_p (rtx, int); extern bool arc_epilogue_uses (int regno); extern bool arc_eh_uses (int regno); -/* insn-attrtab.cc doesn't include reload.h, which declares regno_clobbered_p. */ +/* Generated attribute code does not include reload.h, which declares + regno_clobbered_p. */ extern int regno_clobbered_p (unsigned int, rtx_insn *, machine_mode, int); extern bool arc_legitimize_reload_address (rtx *, machine_mode, int, int); extern void arc_secondary_reload_conv (rtx, rtx, rtx, bool); diff --git a/gcc/config/ia64/ia64.cc b/gcc/config/ia64/ia64.cc index b06158ba7bc0..292c6b3d9390 100644 --- a/gcc/config/ia64/ia64.cc +++ b/gcc/config/ia64/ia64.cc @@ -9286,8 +9286,8 @@ bundling (FILE *dump, int verbose, rtx_insn *prev_head_insn, rtx_insn *tail) curr_state = curr_state->next) if (verbose >= 2 && dump) { - /* This structure is taken from generated code of the - pipeline hazard recognizer (see file insn-attrtab.cc). + /* This structure is taken from the generated pipeline hazard + recognizer code. Please don't forget to change the structure if a new automaton is added to .md file. */ struct DFA_chip diff --git a/gcc/config/ia64/t-ia64 b/gcc/config/ia64/t-ia64 index 4c37dd89fbab..2bf590d89dff 100644 --- a/gcc/config/ia64/t-ia64 +++ b/gcc/config/ia64/t-ia64 @@ -22,7 +22,8 @@ ia64-c.o: $(srcdir)/config/ia64/ia64-c.cc $(CONFIG_H) $(SYSTEM_H) \ $(srcdir)/config/ia64/ia64-c.cc # genattrtab generates very long string literals. -insn-attrtab.o-warn = -Wno-error +$(foreach id, $(INSNATTRTAB_SPLITS_SEQ), \ + $(eval insn-attrtab-$(id).o-warn = -Wno-error)) ia64.o: $(srcdir)/config/ia64/ia64.cc debug.h $(PARAMS_H) sel-sched.h reload.h \ $(OPTS_H) dumpfile.h $(HASH_TABLE_H) diff --git a/gcc/config/sh/sh.h b/gcc/config/sh/sh.h index 9b2ed6a33db8..f3973e7fcab4 100644 --- a/gcc/config/sh/sh.h +++ b/gcc/config/sh/sh.h @@ -24,8 +24,9 @@ along with GCC; see the file COPYING3. If not see #include "config/vxworks-dummy.h" -/* Unfortunately, insn-attrtab.cc doesn't include insn-codes.h. We can't - include it here, because bconfig.h is also included by gencodes.cc . */ +/* Unfortunately, generated attribute code does not include insn-codes.h. + We can't include it here, because bconfig.h is also included by + gencodes.cc . */ /* ??? No longer true. */ extern int code_for_indirect_jump_scratch; diff --git a/gcc/configure b/gcc/configure index 43ca45144b88..9f83764b09c5 100755 --- a/gcc/configure +++ b/gcc/configure @@ -1882,8 +1882,8 @@ Optional Packages: Set the number of partitions to make for gimple and generic when splitting match.pd. [default=10] --with-insnemit-partitions=num - Set the number of partitions of insn-emit.cc for - genemit and genrecog to create. [default=10] + Set the number of partitions used by genemit, + genrecog and genattrtab. [default=10] --with-dwarf2 force the default debug format to be DWARF 2 (or later) --with-specs=SPECS add SPECS to driver command-line processing @@ -7907,7 +7907,8 @@ fi -# Specify the number of splits of insn-emit.cc and insn-recog.cc to generate. +# Specify the number of output partitions used by the machine-description +# generators. # Check whether --with-insnemit-partitions was given. if test "${with_insnemit_partitions+set}" = set; then : @@ -21921,7 +21922,7 @@ else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF -#line 21924 "configure" +#line 21925 "configure" #include "confdefs.h" #if HAVE_DLFCN_H @@ -22027,7 +22028,7 @@ else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF -#line 22030 "configure" +#line 22031 "configure" #include "confdefs.h" #if HAVE_DLFCN_H diff --git a/gcc/configure.ac b/gcc/configure.ac index 075b6b68ffab..31aae8459702 100644 --- a/gcc/configure.ac +++ b/gcc/configure.ac @@ -902,10 +902,12 @@ fi AC_SUBST(DEFAULT_MATCHPD_PARTITIONS) -# Specify the number of splits of insn-emit.cc and insn-recog.cc to generate. +# Specify the number of output partitions used by the machine-description +# generators. AC_ARG_WITH(insnemit-partitions, [AS_HELP_STRING([--with-insnemit-partitions=num], -[Set the number of partitions of insn-emit.cc for genemit and genrecog to create. [default=10]])], +[Set the number of partitions used by genemit, genrecog and genattrtab. +[default=10]])], [DEFAULT_INSNEMIT_PARTITIONS="$with_insnemit_partitions"], [DEFAULT_INSNEMIT_PARTITIONS=10]) if (test $DEFAULT_INSNEMIT_PARTITIONS -lt 1); then AC_MSG_ERROR(m4_normalize([ diff --git a/gcc/final.cc b/gcc/final.cc index a99b188d0432..b6be9be99b7f 100644 --- a/gcc/final.cc +++ b/gcc/final.cc @@ -136,7 +136,7 @@ static const char *last_filename; /* Whether to force emission of a line note before the next insn. */ static bool force_source_line = false; -extern const int length_unit_log; /* This is defined in insn-attrtab.cc. */ +extern const int length_unit_log; /* Defined in generated attribute code. */ /* Nonzero while outputting an `asm' with operands. This means that inconsistencies are the user's fault, so don't die. diff --git a/gcc/genattrtab.cc b/gcc/genattrtab.cc index 503c50637aa0..966f5f9aaab3 100644 --- a/gcc/genattrtab.cc +++ b/gcc/genattrtab.cc @@ -314,16 +314,17 @@ static rtx min_fn (rtx); functions and tables. This made insn-attrtab.cc _the_ bottle-neck in a parallel build, and even made it impossible to build GCC on machines with relatively small RAM space (PR other/29442). Therefore, the - attribute functions/tables are now written out to three separate - files: all "*insn_default_latency" functions go to LATENCY_FILE_NAME, - all "*internal_dfa_insn_code" functions go to DFA_FILE_NAME, and the - rest goes to ATTR_FILE_NAME. */ + attribute functions/tables are now written out to separate files: all + "*insn_default_latency" functions go to the latency output, all + "*internal_dfa_insn_code" functions go to the DFA output, and the rest is + distributed across the attribute outputs the way genemit and genrecog + distribute their output. */ -static const char *attr_file_name = NULL; -static const char *dfa_file_name = NULL; -static const char *latency_file_name = NULL; +/* The files produced by the generator. */ +static auto_vec output_files; -static FILE *attr_file, *dfa_file, *latency_file; +static FILE *dfa_file, *latency_file; +static const char *dfa_file_name, *latency_file_name; /* Hash table for sharing RTL and strings. */ @@ -5242,6 +5243,9 @@ make_automaton_attrs (void) tune_attr = find_tune_attr (all_insn_reservs->condexp); if (tune_attr != NULL) { + /* The function pointers and init_sched_attrs go to the first + attribute file. */ + FILE *attr_file = output_files[0].file; rtx *condexps = XNEWVEC (rtx, n_insn_reservs * 3); struct attr_value *val; bool first = true; @@ -5467,29 +5471,22 @@ write_header (FILE *outf) fprintf (outf, "#define operands recog_data.operand\n\n"); } -static FILE * -open_outfile (const char *file_name) -{ - FILE *outf; - outf = fopen (file_name, "w"); - if (! outf) - fatal ("cannot open file %s: %s", file_name, xstrerror (errno)); - write_header (outf); - return outf; -} - static bool handle_arg (const char *arg) { switch (arg[1]) { case 'A': - attr_file_name = &arg[2]; + add_generator_output (output_files, &arg[2], true); return true; case 'D': + if (dfa_file_name) + fatal ("option -D specified more than once"); dfa_file_name = &arg[2]; return true; case 'L': + if (latency_file_name) + fatal ("option -L specified more than once"); latency_file_name = &arg[2]; return true; default: @@ -5497,6 +5494,36 @@ handle_arg (const char *arg) } } +/* Return a measure of how much text write_attr_get will produce for ATTR. + For a derived attribute that is the length of its lookup table, and + otherwise the number of case labels, since find_most_used turns the + remaining value into the default arm. */ + +static int +attr_output_size (class attr_desc *attr) +{ + if (attr->derived_from) + return attr->derived_from->num_values; + + struct attr_value *common = find_most_used (attr); + int size = 0; + for (struct attr_value *av = attr->first_value; av; av = av->next) + if (av != common) + size += av->num_insns; + return size; +} + +/* Sort attributes so that the ones producing the most text come first. */ + +static int +cmp_attr_output_size (const void *a, const void *b) +{ + class attr_desc *aa = *(class attr_desc *const *) a; + class attr_desc *bb = *(class attr_desc *const *) b; + int diff = attr_output_size (bb) - attr_output_size (aa); + return diff ? diff : strcmp (aa->name, bb->name); +} + int main (int argc, const char **argv) { @@ -5509,9 +5536,24 @@ main (int argc, const char **argv) if (!init_rtx_reader_args_cb (argc, argv, handle_arg)) return FATAL_EXIT_CODE; - attr_file = open_outfile (attr_file_name); - dfa_file = open_outfile (dfa_file_name); - latency_file = open_outfile (latency_file_name); + if (output_files.is_empty ()) + fatal ("no -A output file specified"); + if (!dfa_file_name) + fatal ("no -D output file specified"); + if (!latency_file_name) + fatal ("no -L output file specified"); + + /* Add the DFA and latency outputs after the attribute outputs, so that + the attribute outputs occupy the first entries of OUTPUT_FILES. */ + unsigned int dfa_index + = add_generator_output (output_files, dfa_file_name, false); + unsigned int latency_index + = add_generator_output (output_files, latency_file_name, false); + open_generator_outputs (output_files); + dfa_file = output_files[dfa_index].file; + latency_file = output_files[latency_index].file; + for (generator_output &output : output_files) + write_header (output.file); obstack_init (hash_obstack); obstack_init (temp_obstack); @@ -5628,50 +5670,56 @@ main (int argc, const char **argv) /* Perform any possible optimizations to speed up compilation. */ optimize_attrs (num_insn_codes); - /* Now write out all the `gen_attr_...' routines. Do these before the - special routines so that they get defined before they are used. */ + /* Now write out all the `get_attr_...' routines. The DFA and latency + routines go to their own files; the rest are distributed across the + attribute files. They only refer to each other through the extern + declarations in insn-attr.h and insn-attr-common.h. */ + auto_vec to_write; for (i = 0; i < MAX_ATTRS_INDEX; i++) for (attr = attrs[i]; attr; attr = attr->next) - { - FILE *outf; + if (!attr->is_special && !attr->is_const) + to_write.safe_push (attr); - if (startswith(attr->name, "*internal_dfa_insn_code")) - outf = dfa_file; - else if (startswith (attr->name, "*insn_default_latency")) - outf = latency_file; - else - outf = attr_file; + /* Give choose_output the largest functions first. It assigns each one to + the shortest output so far, and feeding it an arbitrary order lets a + late large function land on an already full partition. Attribute + functions differ in size by two orders of magnitude, so that happens + easily. */ + to_write.qsort (cmp_attr_output_size); - if (! attr->is_special && ! attr->is_const) - write_attr_get (outf, attr); - } + for (class attr_desc *a : to_write) + { + FILE *outf; + + if (startswith (a->name, "*internal_dfa_insn_code")) + outf = dfa_file; + else if (startswith (a->name, "*insn_default_latency")) + outf = latency_file; + else + outf = choose_output (output_files); + + write_attr_get (outf, a); + } /* Write out delay eligibility information, if DEFINE_DELAY present. (The function to compute the number of delay slots will be written below.) */ - write_eligible_delay (attr_file, "delay"); + write_eligible_delay (choose_output (output_files), "delay"); if (have_annul_true) - write_eligible_delay (attr_file, "annul_true"); + write_eligible_delay (choose_output (output_files), "annul_true"); else - write_dummy_eligible_delay (attr_file, "annul_true"); + write_dummy_eligible_delay (choose_output (output_files), "annul_true"); if (have_annul_false) - write_eligible_delay (attr_file, "annul_false"); + write_eligible_delay (choose_output (output_files), "annul_false"); else - write_dummy_eligible_delay (attr_file, "annul_false"); + write_dummy_eligible_delay (choose_output (output_files), "annul_false"); /* Write out constant delay slot info. */ - write_const_num_delay_slots (attr_file); - - write_length_unit_log (attr_file); + write_const_num_delay_slots (choose_output (output_files)); - if (fclose (attr_file) != 0) - fatal ("cannot close file %s: %s", attr_file_name, xstrerror (errno)); - if (fclose (dfa_file) != 0) - fatal ("cannot close file %s: %s", dfa_file_name, xstrerror (errno)); - if (fclose (latency_file) != 0) - fatal ("cannot close file %s: %s", latency_file_name, xstrerror (errno)); + write_length_unit_log (choose_output (output_files)); - return SUCCESS_EXIT_CODE; + return (close_generator_outputs (output_files) + ? SUCCESS_EXIT_CODE : FATAL_EXIT_CODE); } - From 0d96023e9f8dbde7c9ea53279f2904efb4a4d36f Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Wed, 5 Aug 2026 11:46:01 +0200 Subject: [PATCH 030/584] configure: Add target defaults for MD generator partitions The generated emit, recog, and attrtab sources have different shapes. One partition count therefore does not give each generator the same compile critical path. Tamar Christina suggested a colon-separated configuration value so that each generator can have an independent count. The existing --with-insnemit-partitions name refers only to genemit, but the option now controls three machine-description generators. Add --with-md-generator-partitions as the canonical name. Keep the old name as a deprecated alias and reject the use of both names together. Accept either one count for all three generators or E:R:A for separate genemit, genrecog, and genattrtab counts. Let config.gcc set the target default in either form. Keep 10 as the generic default and let an explicit configure option take precedence. Reject malformed values and counts outside the 1 to 9999 range supported by one_to_9999. Make each generator stamp depend on Makefile. This regenerates the source set after reconfigure changes a count, including when the new set has files that did not exist before. Stop when any emit or recog output move fails. The previous foreach command reported only the status of the last move. Remove all numbered generator sources during mostlyclean, including files left after a partition-count decrease. Set the AArch64 default to 6:6:1. After the preceding compaction patches, the longest emit and recog objects at six partitions each compile in under a fifth of the time of the longest object in the bootstrap, which is a gimple-match partition. Raising the counts further shortens objects that are no longer on the critical path, while every added partition repeats the per-file preamble and so costs bootstrap CPU. One attrtab partition is enough for the same reason. The single attrtab object already compiles in about an eighth of the time of the longest bootstrap object, so splitting it spends CPU without shortening the build. Bootstrapped on aarch64-none-linux-gnu. gcc/ChangeLog: * Makefile.in (NUM_INSNRECOG_SPLITS): New variable. (INSNRECOG_SPLITS_SEQ): Use it. (NUM_INSNATTRTAB_SPLITS): New variable. (INSNATTRTAB_SPLITS_SEQ): Use it. (MOSTLYCLEANFILES): Remove all numbered generator sources. (s-tmp-emit, s-tmp-recog): Stop when an output move fails. (s-tmp-emit, s-tmp-recog, s-attrtab): Depend on Makefile. * config.gcc (default_md_generator_partitions): New variable. Document its scalar and tuple forms. (aarch64*-*-*): Set the target default. * configure.ac (--with-md-generator-partitions): New option. (--with-insnemit-partitions): Keep as a deprecated alias. Use the target default when no option is specified. Validate and substitute all three counts. * configure: Regenerate. * doc/install.texi (--with-md-generator-partitions): Document. Suggested-by: Tamar Christina Signed-off-by: Kyrylo Tkachov --- gcc/Makefile.in | 37 ++++++++++-------- gcc/config.gcc | 8 ++++ gcc/configure | 89 ++++++++++++++++++++++++++++++++++++++------ gcc/configure.ac | 79 +++++++++++++++++++++++++++++++++++---- gcc/doc/install.texi | 13 +++++++ 5 files changed, 190 insertions(+), 36 deletions(-) diff --git a/gcc/Makefile.in b/gcc/Makefile.in index f88279839fd8..249f7ff81a59 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -235,14 +235,16 @@ INSNEMIT_SEQ_SRC = $(patsubst %, insn-emit-%.cc, $(INSNEMIT_SPLITS_SEQ)) INSNEMIT_SEQ_TMP = $(patsubst %, tmp-emit-%.cc, $(INSNEMIT_SPLITS_SEQ)) INSNEMIT_SEQ_O = $(patsubst %, insn-emit-%.o, $(INSNEMIT_SPLITS_SEQ)) -# Re-use the split number for insn-recog as well. -INSNRECOG_SPLITS_SEQ = $(wordlist 1,$(NUM_INSNEMIT_SPLITS),$(one_to_9999)) +# The number of splits to be made for the insn-recog files. +NUM_INSNRECOG_SPLITS = @DEFAULT_INSNRECOG_PARTITIONS@ +INSNRECOG_SPLITS_SEQ = $(wordlist 1,$(NUM_INSNRECOG_SPLITS),$(one_to_9999)) INSNRECOG_SEQ_SRC = $(patsubst %, insn-recog-%.cc, $(INSNRECOG_SPLITS_SEQ)) INSNRECOG_SEQ_TMP = $(patsubst %, tmp-recog-%.cc, $(INSNRECOG_SPLITS_SEQ)) INSNRECOG_SEQ_O = $(patsubst %, insn-recog-%.o, $(INSNRECOG_SPLITS_SEQ)) -# Re-use the split number for insn-attrtab as well. -INSNATTRTAB_SPLITS_SEQ = $(wordlist 1,$(NUM_INSNEMIT_SPLITS),$(one_to_9999)) +# The number of splits to be made for the insn-attrtab files. +NUM_INSNATTRTAB_SPLITS = @DEFAULT_INSNATTRTAB_PARTITIONS@ +INSNATTRTAB_SPLITS_SEQ = $(wordlist 1,$(NUM_INSNATTRTAB_SPLITS),$(one_to_9999)) INSNATTRTAB_SEQ_SRC = $(patsubst %, insn-attrtab-%.cc, \ $(INSNATTRTAB_SPLITS_SEQ)) INSNATTRTAB_SEQ_TMP = $(patsubst %, tmp-attrtab-%.cc, \ @@ -1993,9 +1995,9 @@ TREECHECKING = @TREECHECKING@ FULL_DRIVER_NAME=$(target_noncanonical)-gcc-$(version)$(exeext) MOSTLYCLEANFILES = insn-flags.h insn-config.h insn-codes.h \ - insn-output.cc $(INSNRECOG_SEQ_SRC) insn-recog.h \ - $(INSNEMIT_SEQ_SRC) insn-extract.cc insn-peep.cc \ - insn-attr.h insn-attr-common.h $(INSNATTRTAB_SEQ_SRC) insn-attrtab.cc \ + insn-output.cc insn-recog-*.cc insn-recog.h \ + insn-emit-*.cc insn-extract.cc insn-peep.cc \ + insn-attr.h insn-attr-common.h insn-attrtab-*.cc insn-attrtab.cc \ insn-dfatab.cc insn-latencytab.cc insn-opinit.cc \ insn-opinit.h insn-preds.cc \ insn-constants.h \ @@ -2832,24 +2834,27 @@ $(simple_generated_c:insn-%.cc=s-%): s-%: build/gen%$(build_exeext) # genemit splits its output into different files and doesn't write to # stdout. (but rather to tmp-emit-01.cc..tmp-emit-10.cc) $(INSNEMIT_SEQ_SRC): s-tmp-emit; @true -s-tmp-emit: build/genemit$(build_exeext) $(MD_DEPS) insn-conditions.md +s-tmp-emit: build/genemit$(build_exeext) $(MD_DEPS) insn-conditions.md Makefile $(RUN_GEN) build/genemit$(build_exeext) $(md_file) insn-conditions.md \ $(addprefix -O,${INSNEMIT_SEQ_TMP}) - $(foreach id, $(INSNEMIT_SPLITS_SEQ), \ - $(SHELL) $(srcdir)/../move-if-change tmp-emit-$(id).cc \ - insn-emit-$(id).cc;) + for id in $(INSNEMIT_SPLITS_SEQ); do \ + $(SHELL) $(srcdir)/../move-if-change tmp-emit-$$id.cc \ + insn-emit-$$id.cc || exit 1; \ + done $(STAMP) s-tmp-emit # Same for genrecog. $(INSNRECOG_SEQ_SRC): s-tmp-recog; @true insn-recog.h: s-tmp-recog; @true -s-tmp-recog: build/genrecog$(build_exeext) $(MD_DEPS) insn-conditions.md +s-tmp-recog: build/genrecog$(build_exeext) $(MD_DEPS) \ + insn-conditions.md Makefile $(RUN_GEN) build/genrecog$(build_exeext) $(md_file) insn-conditions.md \ -Hinsn-recog.h \ $(addprefix -O,${INSNRECOG_SEQ_TMP}) - $(foreach id, $(INSNRECOG_SPLITS_SEQ), \ - $(SHELL) $(srcdir)/../move-if-change tmp-recog-$(id).cc \ - insn-recog-$(id).cc;) + for id in $(INSNRECOG_SPLITS_SEQ); do \ + $(SHELL) $(srcdir)/../move-if-change tmp-recog-$$id.cc \ + insn-recog-$$id.cc || exit 1; \ + done $(STAMP) s-tmp-recog # gencheck doesn't read the machine description, and the file produced @@ -2866,7 +2871,7 @@ s-check : build/gencheck$(build_exeext) $(INSNATTRTAB_SEQ_SRC): s-attrtab ; @true insn-dfatab.cc insn-latencytab.cc: s-attrtab ; @true s-attrtab : $(MD_DEPS) build/genattrtab$(build_exeext) \ - insn-conditions.md + insn-conditions.md Makefile $(RUN_GEN) build/genattrtab$(build_exeext) $(md_file) insn-conditions.md \ $(addprefix -A,${INSNATTRTAB_SEQ_TMP}) \ -Dtmp-dfatab.cc -Ltmp-latencytab.cc diff --git a/gcc/config.gcc b/gcc/config.gcc index e600ae272dbb..ef117b293dfa 100644 --- a/gcc/config.gcc +++ b/gcc/config.gcc @@ -54,6 +54,12 @@ # support, the default value of # $default_gnu_indirect_function is set to # "no" except for targets which are known to be OK. +# +# default_md_generator_partitions +# The default partition counts for genemit, genrecog, +# and genattrtab. Set this to N to use the same count +# for all three generators, or to E:R:A to set each +# count separately. # This file sets the following shell variables for use by the # autoconf-generated configure script: @@ -240,6 +246,7 @@ gdb_needs_out_file_path= thread_file= default_use_cxa_atexit=no default_gnu_indirect_function=no +default_md_generator_partitions=10 target_gtfiles= need_64bit_isa= native_system_header_dir=/usr/include @@ -335,6 +342,7 @@ cpu_is_64bit= case ${target} in aarch64*-*-*) cpu_type=aarch64 + default_md_generator_partitions=6:6:1 extra_headers="${extra_headers} arm_fp16.h" extra_headers="${extra_headers} arm_neon.h" extra_headers="${extra_headers} arm_bf16.h" diff --git a/gcc/configure b/gcc/configure index 9f83764b09c5..cedf10b1d492 100755 --- a/gcc/configure +++ b/gcc/configure @@ -859,6 +859,8 @@ enable_gcov enable_shared enable_fixed_point enable_decimal_float +DEFAULT_INSNATTRTAB_PARTITIONS +DEFAULT_INSNRECOG_PARTITIONS DEFAULT_INSNEMIT_PARTITIONS DEFAULT_MATCHPD_PARTITIONS with_multi_buildlist @@ -987,6 +989,7 @@ enable_multilib enable_multiarch with_stack_clash_protection_guard_size with_matchpd_partitions +with_md_generator_partitions with_insnemit_partitions enable___cxa_atexit enable_decimal_float @@ -1881,9 +1884,12 @@ Optional Packages: --with-matchpd-partitions=num Set the number of partitions to make for gimple and generic when splitting match.pd. [default=10] - --with-insnemit-partitions=num - Set the number of partitions used by genemit, - genrecog and genattrtab. [default=10] + --with-md-generator-partitions=num|emit:recog:attrtab + Set the partition counts used by genemit, genrecog + and genattrtab. A single number sets all three + counts. [default=target dependent] + --with-insnemit-partitions=num|emit:recog:attrtab + Deprecated alias for --with-md-generator-partitions. --with-dwarf2 force the default debug format to be DWARF 2 (or later) --with-specs=SPECS add SPECS to driver command-line processing @@ -7908,21 +7914,33 @@ fi # Specify the number of output partitions used by the machine-description -# generators. +# generators. Select and validate the effective value after config.gcc has +# supplied the target default. +md_generator_partitions_set=no +md_generator_partitions_legacy=no + +# Check whether --with-md-generator-partitions was given. +if test "${with_md_generator_partitions+set}" = set; then : + withval=$with_md_generator_partitions; md_generator_partitions=$with_md_generator_partitions +md_generator_partitions_set=yes +fi + # Check whether --with-insnemit-partitions was given. if test "${with_insnemit_partitions+set}" = set; then : - withval=$with_insnemit_partitions; DEFAULT_INSNEMIT_PARTITIONS="$with_insnemit_partitions" -else - DEFAULT_INSNEMIT_PARTITIONS=10 + withval=$with_insnemit_partitions; if test "$md_generator_partitions_set" = yes; then + as_fn_error $? "--with-md-generator-partitions and --with-insnemit-partitions cannot be used together." "$LINENO" 5 fi - -if (test $DEFAULT_INSNEMIT_PARTITIONS -lt 1); then - as_fn_error $? "Invalid value $DEFAULT_INSNEMIT_PARTITIONS for --with-insnemit-partitions. Cannot be negative." "$LINENO" 5 +md_generator_partitions=$with_insnemit_partitions +md_generator_partitions_set=yes +md_generator_partitions_legacy=yes fi + + + # Enable __cxa_atexit for C++. # Check whether --enable-__cxa_atexit was given. if test "${enable___cxa_atexit+set}" = set; then : @@ -12995,6 +13013,53 @@ target_gtfiles= # Collect target-machine-specific information. . ${srcdir}/config.gcc || exit 1 +# Use the target default unless the user specified an option. +if test "$md_generator_partitions_set" = no; then + md_generator_partitions=$default_md_generator_partitions +fi + +# Set all three counts here and let the loop below reject anything that is +# empty, not a number, or out of range. A value with too many fields leaves +# its remainder in the last count, where the colon fails the same check. +case "$md_generator_partitions" in + *:*:*) + IFS=: read -r DEFAULT_INSNEMIT_PARTITIONS DEFAULT_INSNRECOG_PARTITIONS \ + DEFAULT_INSNATTRTAB_PARTITIONS <&5 +$as_echo "$as_me: WARNING: --with-insnemit-partitions is deprecated. Use --with-md-generator-partitions instead." >&2;} +fi + extra_objs="${host_extra_objs} ${extra_objs}" extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}" @@ -21922,7 +21987,7 @@ else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF -#line 21925 "configure" +#line 21990 "configure" #include "confdefs.h" #if HAVE_DLFCN_H @@ -22028,7 +22093,7 @@ else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF -#line 22031 "configure" +#line 22096 "configure" #include "confdefs.h" #if HAVE_DLFCN_H diff --git a/gcc/configure.ac b/gcc/configure.ac index 31aae8459702..54b89954ef03 100644 --- a/gcc/configure.ac +++ b/gcc/configure.ac @@ -903,19 +903,31 @@ fi AC_SUBST(DEFAULT_MATCHPD_PARTITIONS) # Specify the number of output partitions used by the machine-description -# generators. +# generators. Select and validate the effective value after config.gcc has +# supplied the target default. +md_generator_partitions_set=no +md_generator_partitions_legacy=no +AC_ARG_WITH(md-generator-partitions, +[AS_HELP_STRING([--with-md-generator-partitions=num|emit:recog:attrtab], +[Set the partition counts used by genemit, genrecog and genattrtab. +A single number sets all three counts. [default=target dependent]])], +[md_generator_partitions=$with_md_generator_partitions +md_generator_partitions_set=yes]) AC_ARG_WITH(insnemit-partitions, -[AS_HELP_STRING([--with-insnemit-partitions=num], -[Set the number of partitions used by genemit, genrecog and genattrtab. -[default=10]])], -[DEFAULT_INSNEMIT_PARTITIONS="$with_insnemit_partitions"], [DEFAULT_INSNEMIT_PARTITIONS=10]) -if (test $DEFAULT_INSNEMIT_PARTITIONS -lt 1); then +[AS_HELP_STRING([--with-insnemit-partitions=num|emit:recog:attrtab], +[Deprecated alias for --with-md-generator-partitions.])], +[if test "$md_generator_partitions_set" = yes; then AC_MSG_ERROR(m4_normalize([ - Invalid value $DEFAULT_INSNEMIT_PARTITIONS for --with-insnemit-partitions. \ - Cannot be negative.])) + --with-md-generator-partitions and --with-insnemit-partitions \ + cannot be used together.])) fi +md_generator_partitions=$with_insnemit_partitions +md_generator_partitions_set=yes +md_generator_partitions_legacy=yes]) AC_SUBST(DEFAULT_INSNEMIT_PARTITIONS) +AC_SUBST(DEFAULT_INSNRECOG_PARTITIONS) +AC_SUBST(DEFAULT_INSNATTRTAB_PARTITIONS) # Enable __cxa_atexit for C++. AC_ARG_ENABLE(__cxa_atexit, @@ -1928,6 +1940,57 @@ target_gtfiles= # Collect target-machine-specific information. . ${srcdir}/config.gcc || exit 1 +# Use the target default unless the user specified an option. +if test "$md_generator_partitions_set" = no; then + md_generator_partitions=$default_md_generator_partitions +fi + +# Set all three counts here and let the loop below reject anything that is +# empty, not a number, or out of range. A value with too many fields leaves +# its remainder in the last count, where the colon fails the same check. +case "$md_generator_partitions" in + *:*:*) + IFS=: read -r DEFAULT_INSNEMIT_PARTITIONS DEFAULT_INSNRECOG_PARTITIONS \ + DEFAULT_INSNATTRTAB_PARTITIONS < Date: Tue, 15 Sep 2026 10:52:22 +0200 Subject: [PATCH 031/584] tree-optimization/127390 - vectorization of _BitInt comparisons We fail to reject vectorizing of comparisons of non-mode precision integer types. Those need to be dealt with via bitfield lowering in ifcvt or pattern recognition. PR tree-optimization/127390 * tree-vect-stmts.cc (vectorizable_comparison_1): Reject bit-precision integer comparisons. * gcc.dg/vect/vect-pr127390.c: New testcase. --- gcc/testsuite/gcc.dg/vect/vect-pr127390.c | 29 +++++++++++++++++++++++ gcc/tree-vect-stmts.cc | 7 ++++++ 2 files changed, 36 insertions(+) create mode 100644 gcc/testsuite/gcc.dg/vect/vect-pr127390.c diff --git a/gcc/testsuite/gcc.dg/vect/vect-pr127390.c b/gcc/testsuite/gcc.dg/vect/vect-pr127390.c new file mode 100644 index 000000000000..05e0399ceba5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-pr127390.c @@ -0,0 +1,29 @@ +/* { dg-additional-options "-O3" } */ +/* { dg-add-options vect_early_break } */ +/* { dg-require-effective-target vect_early_break_hw } */ +/* { dg-require-effective-target bitint } */ + +#include +#include "tree-vect.h" + +typedef signed _BitInt(24) i24; +int8_t m0[2]; + +int __attribute__((noipa)) +foo (int16_t in2) +{ + int16_t x2; + int n = 0; + for (n = 0; n < 8; n++) { + if (((i24)(m0[1] ? m0[1] * 2 : 1) >= (i24)(x2 - 1))) break; + } + return n; +} + +int main(void) +{ + check_vect (); + if (foo (-1)) + __builtin_abort (); + return 0; +} diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc index 51d71270d1b6..8cd5fb2001e3 100644 --- a/gcc/tree-vect-stmts.cc +++ b/gcc/tree-vect-stmts.cc @@ -12456,6 +12456,13 @@ vectorizable_comparison_1 (vec_info *vinfo, tree vectype, && (VECTOR_BOOLEAN_TYPE_P (vectype1) ^ VECTOR_BOOLEAN_TYPE_P (vectype2))) return false; + /* We cannot compare non-mode precision _BitInt types. Unlike bool + or bit-precision INTEGER_TYPE the padding bit values are target + dependent and possibly undefined. */ + if (TREE_CODE (TREE_TYPE (rhs1)) == BITINT_TYPE + && !type_has_mode_precision_p (TREE_TYPE (rhs1))) + return false; + /* Boolean values may have another representation in vectors and therefore we prefer bit operations over comparison for them (which also works for scalar masks). We store opcodes From 9c09713871ad6d05e1bd2bd65cb3c78c823cb42e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B8rgen=20Kvalsvik?= Date: Tue, 15 Sep 2026 16:04:12 +0200 Subject: [PATCH 032/584] Compare right field when printing summary The check if (coverage->calls && coverage->calls == 0) will always be false (as reported by -Wlogical-op) and broken. I don't think there is a test suite for function summaries so this was not caught earlier. The logic is a bit awkward and could've been flipped to avoid checking calls_suppressed twice. When it was written I wanted to minimize patch and preserve the "natural" order, since the suppression pragma is an opt-in, in a way. PR gcov-profile/127408 gcc/ChangeLog: * gcov.cc (function_summary): Check calls_suppressed, not calls. --- gcc/gcov.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/gcov.cc b/gcc/gcov.cc index 06047a604607..ceed689c1c98 100644 --- a/gcc/gcov.cc +++ b/gcc/gcov.cc @@ -3421,7 +3421,7 @@ function_summary (const coverage_info *coverage) else fnotice (stdout, "No branches\n"); - if (coverage->calls && coverage->calls == 0) + if (coverage->calls && coverage->calls_suppressed == 0) fnotice (stdout, "Calls executed:%s of %d\n", format_gcov (coverage->calls_executed, coverage->calls, 2), coverage->calls); From 0c4d0fe4c998ea42cfc241c81678d59b708b1043 Mon Sep 17 00:00:00 2001 From: Takayuki 'January June' Suwa Date: Sun, 13 Sep 2026 04:59:10 +0900 Subject: [PATCH 033/584] xtensa: Revert "xtensa: Small changes to 'return' insn pattern" Specifying the hard registers used by the 'return' pattern (such as the one holding the return address) via the EPILOGUE_USES() macro has an effect similar to the presence of global register variables; consequently, DF information for these registers is attached to the entire function body before register allocation even takes place. This makes it extremely diffi- cult to assign these registers to pseudos for other purposes within the function body. While this behavior is desirable when the machine instruction for returning from a function requires exclusive use of those registers, it is undesirable for the Xtensa ISA under the CALL0 ABI configuration, which permits the hard register holding the return address to be repurposed for other uses. This patch effectively reverts an earlier commit (384c6aef "xtensa: Small changes to 'return' insn pattern") that had changed the speci- fication of the A0 hard register (used for holding the return address) from a USE RTX attached to the 'return' pattern to the EPILOGUE_USES() macro. gcc/ChangeLog: * config/xtensa/xtensa.h (EPILOGUE_USES): Remove. * config/xtensa/xtensa.md (return): Resurrect '(use (reg:SI A0_REG))' to the template description. (sibcall_epilogue): Revive emitting '(use (reg:SI A0_REG))'. gcc/testsuite/ChangeLog: * gcc.target/xtensa/regA0-allocatability.c: New test. --- gcc/config/xtensa/xtensa.h | 4 ---- gcc/config/xtensa/xtensa.md | 4 +++- .../gcc.target/xtensa/regA0-allocatability.c | 11 +++++++++++ 3 files changed, 14 insertions(+), 5 deletions(-) create mode 100644 gcc/testsuite/gcc.target/xtensa/regA0-allocatability.c diff --git a/gcc/config/xtensa/xtensa.h b/gcc/config/xtensa/xtensa.h index 99243486a6ab..5bf1645033c6 100644 --- a/gcc/config/xtensa/xtensa.h +++ b/gcc/config/xtensa/xtensa.h @@ -539,10 +539,6 @@ typedef struct xtensa_args /* Stack pointer value doesn't matter at exit. */ #define EXIT_IGNORE_STACK 1 -/* The "return" pattern requires A0 register as return address, and is - also required so that restoring A0 in the epilogue is not dead code. */ -#define EPILOGUE_USES(REGNO) ((REGNO) == A0_REG) - /* Size in bytes of the trampoline, as an integer. Make sure this is a multiple of TRAMPOLINE_ALIGNMENT to avoid -Wpadded warnings. */ #define TRAMPOLINE_SIZE (TARGET_WINDOWED_ABI ? \ diff --git a/gcc/config/xtensa/xtensa.md b/gcc/config/xtensa/xtensa.md index 753f23412be8..9df4fbe92187 100644 --- a/gcc/config/xtensa/xtensa.md +++ b/gcc/config/xtensa/xtensa.md @@ -2640,7 +2640,8 @@ (set_attr "length" "3")]) (define_insn "return" - [(return)] + [(return) + (use (reg:SI A0_REG))] "TARGET_WINDOWED_ABI || compute_frame_size (get_frame_size ()) == 0 || epilogue_completed" @@ -2707,6 +2708,7 @@ "!TARGET_WINDOWED_ABI" { xtensa_expand_epilogue (); + emit_use (gen_rtx_REG (SImode, A0_REG)); DONE; }) diff --git a/gcc/testsuite/gcc.target/xtensa/regA0-allocatability.c b/gcc/testsuite/gcc.target/xtensa/regA0-allocatability.c new file mode 100644 index 000000000000..e712fc3b826c --- /dev/null +++ b/gcc/testsuite/gcc.target/xtensa/regA0-allocatability.c @@ -0,0 +1,11 @@ +/* { dg-do compile } */ +/* { dg-options "-O1 -mabi=call0 -fdump-rtl-reload" } */ + +void test(void) +{ + asm volatile ("# clobber a2~a15, reg %0" : : "r"(0) : + "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9", + "a10", "a11", "a12", "a13", "a14", "a15"); +} + +/* { dg-final { scan-rtl-dump-not "Changing spilled pseudos to memory in insn #" "reload" } } */ From cfe20dd118f5b83cb5dfac890e02b5b0a169abc1 Mon Sep 17 00:00:00 2001 From: Takayuki 'January June' Suwa Date: Sun, 13 Sep 2026 05:00:33 +0900 Subject: [PATCH 034/584] xtensa: Exclude A0 register from RL_REGS regclass when TARGET_WINDOWED_ABI When the "Windowed Register Option" is configured in the Xtensa ISA, register A0 is reserved for the return address and cannot be used for other purposes. Therefore, the A0 register should be excluded from the "preferred reload register" set, ie., the RL_REGS regclass. gcc/ChangeLog: * config/xtensa/xtensa.cc (xtensa_conditional_register_usage): Clear the bit corresponding to the A0 register from the HARD_REG_SET associated with RL_REGS, if TARGET_WINDOWED_ABI is enabled. --- gcc/config/xtensa/xtensa.cc | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/gcc/config/xtensa/xtensa.cc b/gcc/config/xtensa/xtensa.cc index f4b1151d2e0e..b1daa0f0a998 100644 --- a/gcc/config/xtensa/xtensa.cc +++ b/gcc/config/xtensa/xtensa.cc @@ -5379,16 +5379,20 @@ xtensa_conditional_register_usage (void) call_used_regs[i] = !!(call_used_regs[i] & c_mask); } - /* Remove hard FP register from the preferred reload registers set. */ - CLEAR_HARD_REG_BIT (reg_class_contents[(int)RL_REGS], + /* Remove hard frame pointer from the preferred reload registers set. */ + CLEAR_HARD_REG_BIT (reg_class_contents[RL_REGS], HARD_FRAME_POINTER_REGNUM); - /* Register A0 holds the return address upon entry to a function - for the CALL0 ABI, but unlike the windowed register ABI, it is - not reserved for this purpose and may hold other values after - the return address has been saved. */ + /* Register A0 holds the return address upon entry to a function for + the CALL0 ABI, but unlike the windowed register ABI, it is not + reserved for this purpose and may hold other values after the return + address has been saved. In a similar vein, register A0 should be + excluded from the preferred reload registers set when the windowed + register ABI is in effect. */ if (!TARGET_WINDOWED_ABI) fixed_regs[A0_REG] = 0; + else + CLEAR_HARD_REG_BIT (reg_class_contents[RL_REGS], A0_REG); } /* Map hard register number to register class */ From 931289c27a84e5646fb876c99fbf02fba4fb5dd2 Mon Sep 17 00:00:00 2001 From: Takayuki 'January June' Suwa Date: Sun, 13 Sep 2026 05:06:30 +0900 Subject: [PATCH 035/584] xtensa: Reformat REG_ALLOC_ORDER Cosmetics for readability. Thus no functional changes. gcc/ChangeLog: * config/xtensa/xtensa.cc (xtensa_adjust_reg_alloc_order): Reformat the "reg_call0_alloc_order" array. * config/xtensa/xtensa.h (REG_ALLOC_ORDER): Reformat. --- gcc/config/xtensa/xtensa.cc | 6 ++---- gcc/config/xtensa/xtensa.h | 6 ++---- 2 files changed, 4 insertions(+), 8 deletions(-) diff --git a/gcc/config/xtensa/xtensa.cc b/gcc/config/xtensa/xtensa.cc index b1daa0f0a998..9f9d1b8ef49a 100644 --- a/gcc/config/xtensa/xtensa.cc +++ b/gcc/config/xtensa/xtensa.cc @@ -4471,11 +4471,9 @@ xtensa_adjust_reg_alloc_order (void) REG_ALLOC_ORDER; static const int reg_call0_alloc_order[FIRST_PSEUDO_REGISTER] = { - 9, 10, 11, 7, 6, 5, 4, 3, 2, 8, 0, 12, 13, 14, 15, - 18, + 9, 10, 11, 7, 6, 5, 4, 3, 2, 8, 0, 12, 13, 14, 15, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, - 1, 16, 17, - 35, + 1, 16, 17, 35, }; memcpy (reg_alloc_order, TARGET_WINDOWED_ABI ? diff --git a/gcc/config/xtensa/xtensa.h b/gcc/config/xtensa/xtensa.h index 5bf1645033c6..4fab1e055a18 100644 --- a/gcc/config/xtensa/xtensa.h +++ b/gcc/config/xtensa/xtensa.h @@ -249,11 +249,9 @@ along with GCC; see the file COPYING3. If not see #define REG_ALLOC_ORDER \ { \ - 8, 9, 10, 11, 12, 13, 14, 15, 7, 6, 5, 4, 3, 2, \ - 18, \ + 8, 9, 10, 11, 12, 13, 14, 15, 7, 6, 5, 4, 3, 2, 18, \ 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, \ - 0, 1, 16, 17, \ - 35, \ + 0, 1, 16, 17, 35, \ } #define ADJUST_REG_ALLOC_ORDER xtensa_adjust_reg_alloc_order () From f408d09eedfad5c9b470750c85444faea7f7ccc7 Mon Sep 17 00:00:00 2001 From: Takayuki 'January June' Suwa Date: Sun, 13 Sep 2026 05:08:17 +0900 Subject: [PATCH 036/584] xtensa: Revise REGNO_REG_CLASS() macro definition In the "Register Classes" chapter, gccint states the following regarding REGNO_REG_CLASS: " REGNO_REG_CLASS (regno) [Macro] A C expression whose value is a register class containing hard register regno. In general there is more than one such class; choose a class which is minimal, meaning that no smaller class also contains the register. " -- 19.8 Register Classes, gccint (the latest) This patch adds code to the end of the function specified by the TARGET_CONDITIONAL_REGISTER_USAGE macro to generate a regno-to-"minimal" regclass mapping, and ensures that this mapping is subsequently referenced via REGNO_REG_CLASS(). gcc/ChangeLog: * config/xtensa/xtensa-protos.h (xtensa_regno_to_class): Remove. * config/xtensa/xtensa.h (xtensa_regno_to_class): Declaration of a new global array. (REGNO_REG_CLASS): Change to reference the xtensa_regno_to_class array. * config/xtensa/xtensa.cc (xtensa_regno_to_class): Remove the original function definition and define it as a new global array. (xtensa_conditional_register_usage): Append code to the end that records a map in xtensa_regno_to_class showing which of the current regclass definitions each hardware register belongs to. --- gcc/config/xtensa/xtensa-protos.h | 1 - gcc/config/xtensa/xtensa.cc | 39 +++++++++++++------------------ gcc/config/xtensa/xtensa.h | 3 ++- 3 files changed, 18 insertions(+), 25 deletions(-) diff --git a/gcc/config/xtensa/xtensa-protos.h b/gcc/config/xtensa/xtensa-protos.h index d729b488397b..f3387dd3177d 100644 --- a/gcc/config/xtensa/xtensa-protos.h +++ b/gcc/config/xtensa/xtensa-protos.h @@ -81,7 +81,6 @@ extern long compute_frame_size (poly_int64); extern void xtensa_expand_prologue (void); extern void xtensa_expand_epilogue (void); extern void xtensa_adjust_reg_alloc_order (void); -extern enum reg_class xtensa_regno_to_class (int regno); extern HOST_WIDE_INT xtensa_initial_elimination_offset (int from, int to); extern const char **xtensa_get_config_strings (void); extern rtl_opt_pass *make_pass_xtensa_largeconst1 (gcc::context *); diff --git a/gcc/config/xtensa/xtensa.cc b/gcc/config/xtensa/xtensa.cc index 9f9d1b8ef49a..ae0cde876a26 100644 --- a/gcc/config/xtensa/xtensa.cc +++ b/gcc/config/xtensa/xtensa.cc @@ -112,6 +112,9 @@ struct GTY(()) machine_function bool postreload_completed; }; +/* Referenced by the REGNO_REG_CLASS() macro. */ +enum reg_class xtensa_regno_to_class[FIRST_PSEUDO_REGISTER]; + static void xtensa_option_override (void); static void xtensa_option_override_after_change (void); static enum internal_test map_test_to_internal_test (enum rtx_code); @@ -5365,7 +5368,7 @@ xtensa_reorg (void) static void xtensa_conditional_register_usage (void) { - unsigned i, c_mask; + unsigned int i, c_mask, cl; c_mask = TARGET_WINDOWED_ABI ? (1 << 1) : (1 << 2); @@ -5391,30 +5394,20 @@ xtensa_conditional_register_usage (void) fixed_regs[A0_REG] = 0; else CLEAR_HARD_REG_BIT (reg_class_contents[RL_REGS], A0_REG); -} - -/* Map hard register number to register class */ -enum reg_class xtensa_regno_to_class (int regno) -{ - static const enum reg_class regno_to_class[FIRST_PSEUDO_REGISTER] = - { - RL_REGS, SP_REG, RL_REGS, RL_REGS, - RL_REGS, RL_REGS, RL_REGS, RL_REGS, - RL_REGS, RL_REGS, RL_REGS, RL_REGS, - RL_REGS, RL_REGS, RL_REGS, RL_REGS, - AR_REGS, AR_REGS, BR_REGS, - FP_REGS, FP_REGS, FP_REGS, FP_REGS, - FP_REGS, FP_REGS, FP_REGS, FP_REGS, - FP_REGS, FP_REGS, FP_REGS, FP_REGS, - FP_REGS, FP_REGS, FP_REGS, FP_REGS, - ACC_REG, - }; + /* Generate the contents of the reverse-lookup array from the currently + active register class definitions. */ + for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i) + for (cl = NO_REGS + 1; cl < ALL_REGS; ++cl) + if (TEST_HARD_REG_BIT (reg_class_contents[cl], i)) + { + xtensa_regno_to_class[i] = (enum reg_class)cl; + break; + } - if (regno == HARD_FRAME_POINTER_REGNUM) - return GR_REGS; - else - return regno_to_class[regno]; + /* Verify the generated mapping for any omissions. */ + for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i) + gcc_assert (xtensa_regno_to_class[i] != NO_REGS); } /* Implement TARGET_CONSTANT_ALIGNMENT. Align string constants and diff --git a/gcc/config/xtensa/xtensa.h b/gcc/config/xtensa/xtensa.h index 4fab1e055a18..eea7323b326a 100644 --- a/gcc/config/xtensa/xtensa.h +++ b/gcc/config/xtensa/xtensa.h @@ -408,7 +408,8 @@ enum reg_class register REGNO. In general there is more that one such class; choose a class which is "minimal", meaning that no smaller class also contains the register. */ -#define REGNO_REG_CLASS(REGNO) xtensa_regno_to_class (REGNO) +extern enum reg_class xtensa_regno_to_class[FIRST_PSEUDO_REGISTER]; +#define REGNO_REG_CLASS(REGNO) xtensa_regno_to_class[REGNO] /* Use the Xtensa AR register file for base registers. No index registers. */ From a3d09e10900457d3ef91519611aac268b9e7dc42 Mon Sep 17 00:00:00 2001 From: Takayuki 'January June' Suwa Date: Sun, 13 Sep 2026 05:09:20 +0900 Subject: [PATCH 037/584] xtensa: Make xt_true_regnum() static The function xt_true_regnum(), defined in xtensa.cc, is not currently called from any other files. gcc/ChangeLog: * config/xtensa/xtensa-protos.h (xt_true_regnum): Remove. * config/xtensa/xtensa.cc (xt_true_regnum): Specify as a static function. --- gcc/config/xtensa/xtensa-protos.h | 1 - gcc/config/xtensa/xtensa.cc | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/gcc/config/xtensa/xtensa-protos.h b/gcc/config/xtensa/xtensa-protos.h index f3387dd3177d..f6fa6c40d331 100644 --- a/gcc/config/xtensa/xtensa-protos.h +++ b/gcc/config/xtensa/xtensa-protos.h @@ -34,7 +34,6 @@ extern bool xtensa_mem_offset (unsigned, machine_mode); /* Functions within xtensa.cc that we reference. */ #ifdef RTX_CODE -extern int xt_true_regnum (rtx); extern int xtensa_valid_move (machine_mode, rtx *); extern bool smalloffset_address_p (const_rtx); extern bool constantpool_address_p (const_rtx); diff --git a/gcc/config/xtensa/xtensa.cc b/gcc/config/xtensa/xtensa.cc index ae0cde876a26..5ff0f25cc279 100644 --- a/gcc/config/xtensa/xtensa.cc +++ b/gcc/config/xtensa/xtensa.cc @@ -541,7 +541,7 @@ xtensa_fp_const (const REAL_VALUE_TYPE *rval) /* This is just like the standard true_regnum() function except that it works even when reg_renumber is not initialized. */ -int +static int xt_true_regnum (rtx x) { if (REG_P (x)) From 812eccfa4da088eac83353f4d311a394c2886c7b Mon Sep 17 00:00:00 2001 From: Takayuki 'January June' Suwa Date: Sun, 13 Sep 2026 05:10:21 +0900 Subject: [PATCH 038/584] xtensa: Eliminate GP/BR/FP/ACC_REG_NUM macros Constant macros such as GP_REG_NUM, used in the definitions of the GP_REG_P(), BR_REG_P(), FP_REG_P() and ACC_REG_P() macros, are used only for that purpose, and their constant definitions can be eliminated by applying the start and end numbers of each hardware register to the IN_RANGE() macro instead. gcc/ChangeLog: * config/xtensa/xtensa.h (GP_REG_NUM, BR_REG_NUM, FP_REG_NUM, ACC_REG_NUM): Remove. (GP_REG_P, BR_REG_P, FP_REG_P, ACC_REG_P): Change to use the IN_RANGE() macro. --- gcc/config/xtensa/xtensa.h | 30 +++++++++++++----------------- 1 file changed, 13 insertions(+), 17 deletions(-) diff --git a/gcc/config/xtensa/xtensa.h b/gcc/config/xtensa/xtensa.h index eea7323b326a..ae0f32bbb2e8 100644 --- a/gcc/config/xtensa/xtensa.h +++ b/gcc/config/xtensa/xtensa.h @@ -262,29 +262,25 @@ along with GCC; see the file COPYING3. If not see /* Internal macros to classify a register number. */ /* 16 address registers + fake registers */ -#define GP_REG_FIRST 0 -#define GP_REG_LAST 17 -#define GP_REG_NUM (GP_REG_LAST - GP_REG_FIRST + 1) +#define GP_REG_FIRST 0 +#define GP_REG_LAST 17 /* Coprocessor registers */ -#define BR_REG_FIRST 18 -#define BR_REG_LAST 18 -#define BR_REG_NUM (BR_REG_LAST - BR_REG_FIRST + 1) +#define BR_REG_FIRST 18 +#define BR_REG_LAST 18 /* 16 floating-point registers */ -#define FP_REG_FIRST 19 -#define FP_REG_LAST 34 -#define FP_REG_NUM (FP_REG_LAST - FP_REG_FIRST + 1) +#define FP_REG_FIRST 19 +#define FP_REG_LAST 34 /* MAC16 accumulator */ -#define ACC_REG_FIRST 35 -#define ACC_REG_LAST 35 -#define ACC_REG_NUM (ACC_REG_LAST - ACC_REG_FIRST + 1) - -#define GP_REG_P(REGNO) ((unsigned) ((REGNO) - GP_REG_FIRST) < GP_REG_NUM) -#define BR_REG_P(REGNO) ((unsigned) ((REGNO) - BR_REG_FIRST) < BR_REG_NUM) -#define FP_REG_P(REGNO) ((unsigned) ((REGNO) - FP_REG_FIRST) < FP_REG_NUM) -#define ACC_REG_P(REGNO) ((unsigned) ((REGNO) - ACC_REG_FIRST) < ACC_REG_NUM) +#define ACC_REG_FIRST 35 +#define ACC_REG_LAST 35 + +#define GP_REG_P(REGNO) (IN_RANGE ((REGNO), GP_REG_FIRST, GP_REG_LAST)) +#define BR_REG_P(REGNO) (IN_RANGE ((REGNO), BR_REG_FIRST, BR_REG_LAST)) +#define FP_REG_P(REGNO) (IN_RANGE ((REGNO), FP_REG_FIRST, FP_REG_LAST)) +#define ACC_REG_P(REGNO) (IN_RANGE ((REGNO), ACC_REG_FIRST, ACC_REG_LAST)) /* Register to use for pushing function arguments. */ #define STACK_POINTER_REGNUM (GP_REG_FIRST + 1) From c66387c4b201e2576cbd06909e861ada1884685f Mon Sep 17 00:00:00 2001 From: Takayuki 'January June' Suwa Date: Sun, 13 Sep 2026 05:11:58 +0900 Subject: [PATCH 039/584] xtensa: Simplify xtensa_valid_move() The xtensa_valid_move() function, which is called from locations such as the condition clause of the "movsi_internal" MD insn pattern, was introduced in commit 71cc6aea (about 24 years ago) to prevent a non-register source from being directly assigned to the stack pointer when the "Windowed Register ABI" is configured (in such cases, the MOVSP instruction must be used via a scratch register). This is likely a workaround for the fact that Reload pass at the time was too lenient (or loose) with respect to the operand constraints of the insn pattern, and perhaps register allocation was performed under the assumption that non-register sources could be assigned to hard registers belonging to GENERAL_REGS (including the stack pointer in Xtensa). However, LRA has now replaced old Reload for the Xtensa target; since both instruction alternative selection and hard register allocation are performed in strict adherence to operand constraints, it is no longer necessary to employ workarounds like the one mentioned above. In this case, for example, since there is no alternative that simultaneously satisfies the constraints for the non-register source (such as a memory reference) and the stack pointer destination, LRA correctly recognizes and reloads the source into another scratch address (general-purpose) register. Therefore, this patch removes the workaround code mentioned above in xtensa_valid_move(). gcc/ChangeLog: * config/xtensa/xtensa.cc (xtensa_valid_move): Remove code that rejects non-register sources when the destination is the stack pointer. gcc/testsuite: * gcc.target/xtensa/MOVSP.c: New test. --- gcc/config/xtensa/xtensa.cc | 24 +++++++----------------- gcc/testsuite/gcc.target/xtensa/MOVSP.c | 12 ++++++++++++ 2 files changed, 19 insertions(+), 17 deletions(-) create mode 100644 gcc/testsuite/gcc.target/xtensa/MOVSP.c diff --git a/gcc/config/xtensa/xtensa.cc b/gcc/config/xtensa/xtensa.cc index 5ff0f25cc279..6b5d8d1099a9 100644 --- a/gcc/config/xtensa/xtensa.cc +++ b/gcc/config/xtensa/xtensa.cc @@ -581,27 +581,17 @@ xtensa_valid_move (machine_mode mode, rtx *operands) if (register_operand (operands[0], mode)) { - int dst_regnum = xt_true_regnum (operands[0]); - if (xtensa_tls_referenced_p (operands[1])) return FALSE; - /* The stack pointer can only be assigned with a MOVSP opcode. */ - if (dst_regnum == STACK_POINTER_REGNUM) - return !TARGET_WINDOWED_ABI - || (mode == SImode - && register_operand (operands[1], mode) - && !ACC_REG_P (xt_true_regnum (operands[1]))); - - if (!ACC_REG_P (dst_regnum)) - return true; - } - if (register_operand (operands[1], mode)) - { - int src_regnum = xt_true_regnum (operands[1]); - if (!ACC_REG_P (src_regnum)) - return true; + if (!ACC_REG_P (xt_true_regnum (operands[0]))) + return TRUE; } + + if (register_operand (operands[1], mode) + && !ACC_REG_P (xt_true_regnum (operands[1]))) + return TRUE; + return FALSE; } diff --git a/gcc/testsuite/gcc.target/xtensa/MOVSP.c b/gcc/testsuite/gcc.target/xtensa/MOVSP.c new file mode 100644 index 000000000000..d83f39bf04f9 --- /dev/null +++ b/gcc/testsuite/gcc.target/xtensa/MOVSP.c @@ -0,0 +1,12 @@ +/* { dg-do compile } */ +/* { dg-options "-O1 -mabi=windowed" } */ + +void test(int *p) +{ + register int sp asm("sp") = 0; + asm volatile ("# %0"::""(sp)); + sp = *p; + asm volatile ("# %0"::""(sp)); +} + +/* { dg-final { scan-assembler-times "movsp" 2 } } */ From b49c970eeb7ec8f5003dc7ed3faf30d7cfa0cb52 Mon Sep 17 00:00:00 2001 From: Gerald Pfeifer Date: Tue, 15 Sep 2026 12:01:13 +0200 Subject: [PATCH 040/584] doc: Update SARIF website URL gcc: * doc/libgdiagnostics/topics/sarif.rst: Update SARIF website URL. --- gcc/doc/libgdiagnostics/topics/sarif.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/doc/libgdiagnostics/topics/sarif.rst b/gcc/doc/libgdiagnostics/topics/sarif.rst index fbf360bb1946..502897a65a8f 100644 --- a/gcc/doc/libgdiagnostics/topics/sarif.rst +++ b/gcc/doc/libgdiagnostics/topics/sarif.rst @@ -20,7 +20,7 @@ SARIF support ============= -`SARIF `_ is a machine-readable format, originally +`SARIF `_ is a machine-readable format, originally designed for the output of static analysis tools, but which can be used for diagnostics in general. From 891246665b51b4fc662f08f706f1c7523b8800c4 Mon Sep 17 00:00:00 2001 From: GCC Administrator Date: Wed, 16 Sep 2026 00:16:36 +0000 Subject: [PATCH 041/584] Daily bump. --- contrib/ChangeLog | 5 + gcc/ChangeLog | 273 ++++++++++++++++++++++++++++++++++++++++ gcc/DATESTAMP | 2 +- gcc/fortran/ChangeLog | 60 +++++++++ gcc/testsuite/ChangeLog | 80 ++++++++++++ libgm2/ChangeLog | 12 ++ libstdc++-v3/ChangeLog | 9 ++ 7 files changed, 440 insertions(+), 1 deletion(-) diff --git a/contrib/ChangeLog b/contrib/ChangeLog index 6c85f6f49773..06b808611afa 100644 --- a/contrib/ChangeLog +++ b/contrib/ChangeLog @@ -1,3 +1,8 @@ +2026-09-15 Kyrylo Tkachov + + * filter-clang-warnings.py (skip_warning): Match numbered attribute + files. + 2026-09-11 Richard Biener * gcc-changelog/git_update_version.py: Remove gcc-13 branch diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 997cecbb0d5d..37e385eecf74 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,276 @@ +2026-09-15 Gerald Pfeifer + + * doc/libgdiagnostics/topics/sarif.rst: Update SARIF website URL. + +2026-09-15 Takayuki 'January June' Suwa + + * config/xtensa/xtensa.cc (xtensa_valid_move): + Remove code that rejects non-register sources when the destination + is the stack pointer. + +2026-09-15 Takayuki 'January June' Suwa + + * config/xtensa/xtensa.h + (GP_REG_NUM, BR_REG_NUM, FP_REG_NUM, ACC_REG_NUM): Remove. + (GP_REG_P, BR_REG_P, FP_REG_P, ACC_REG_P): + Change to use the IN_RANGE() macro. + +2026-09-15 Takayuki 'January June' Suwa + + * config/xtensa/xtensa-protos.h (xt_true_regnum): Remove. + * config/xtensa/xtensa.cc (xt_true_regnum): + Specify as a static function. + +2026-09-15 Takayuki 'January June' Suwa + + * config/xtensa/xtensa-protos.h (xtensa_regno_to_class): + Remove. + * config/xtensa/xtensa.h (xtensa_regno_to_class): + Declaration of a new global array. + (REGNO_REG_CLASS): + Change to reference the xtensa_regno_to_class array. + * config/xtensa/xtensa.cc (xtensa_regno_to_class): + Remove the original function definition and define it as a new global + array. + (xtensa_conditional_register_usage): + Append code to the end that records a map in xtensa_regno_to_class + showing which of the current regclass definitions each hardware + register belongs to. + +2026-09-15 Takayuki 'January June' Suwa + + * config/xtensa/xtensa.cc (xtensa_adjust_reg_alloc_order): + Reformat the "reg_call0_alloc_order" array. + * config/xtensa/xtensa.h (REG_ALLOC_ORDER): Reformat. + +2026-09-15 Takayuki 'January June' Suwa + + * config/xtensa/xtensa.cc (xtensa_conditional_register_usage): + Clear the bit corresponding to the A0 register from the + HARD_REG_SET associated with RL_REGS, if TARGET_WINDOWED_ABI + is enabled. + +2026-09-15 Takayuki 'January June' Suwa + + * config/xtensa/xtensa.h (EPILOGUE_USES): Remove. + * config/xtensa/xtensa.md (return): + Resurrect '(use (reg:SI A0_REG))' to the template description. + (sibcall_epilogue): Revive emitting '(use (reg:SI A0_REG))'. + +2026-09-15 Jørgen Kvalsvik + + PR gcov-profile/127408 + * gcov.cc (function_summary): Check calls_suppressed, not calls. + +2026-09-15 Richard Biener + + PR tree-optimization/127390 + * tree-vect-stmts.cc (vectorizable_comparison_1): Reject + bit-precision integer comparisons. + +2026-09-15 Kyrylo Tkachov + + * Makefile.in (NUM_INSNRECOG_SPLITS): New variable. + (INSNRECOG_SPLITS_SEQ): Use it. + (NUM_INSNATTRTAB_SPLITS): New variable. + (INSNATTRTAB_SPLITS_SEQ): Use it. + (MOSTLYCLEANFILES): Remove all numbered generator sources. + (s-tmp-emit, s-tmp-recog): Stop when an output move fails. + (s-tmp-emit, s-tmp-recog, s-attrtab): Depend on Makefile. + * config.gcc (default_md_generator_partitions): New variable. + Document its scalar and tuple forms. + (aarch64*-*-*): Set the target default. + * configure.ac (--with-md-generator-partitions): New option. + (--with-insnemit-partitions): Keep as a deprecated alias. + Use the target default when no option is specified. Validate and + substitute all three counts. + * configure: Regenerate. + * doc/install.texi (--with-md-generator-partitions): Document. + +2026-09-15 Kyrylo Tkachov + + * Makefile.in (INSNATTRTAB_SPLITS_SEQ, INSNATTRTAB_SEQ_SRC) + (INSNATTRTAB_SEQ_TMP, INSNATTRTAB_SEQ_O): New variables. + (OBJS): Replace insn-attrtab.o with $(INSNATTRTAB_SEQ_O). + (MOSTLYCLEANFILES): Add $(INSNATTRTAB_SEQ_SRC), retaining the legacy + unnumbered source for cleanup. + (.PRECIOUS): Use $(INSNATTRTAB_SEQ_SRC). + (s-attrtab): Generate and move numbered attribute files. Stop when a + move fails. + * configure.ac (--with-insnemit-partitions): Document all generators + which use the option. + * configure: Regenerate. + * genattrtab.cc (attr_file_name, attr_file, open_outfile): Remove. + (output_files): New variable. + (dfa_file_name, latency_file_name): Retain output names. + (make_automaton_attrs): Write to the first attribute partition. + (handle_arg): Register repeatable attribute outputs. + (attr_output_size, cmp_attr_output_size): New functions. + (main): Register fixed outputs and use the common output helpers. + Distribute attribute, delay, and length functions, largest first. + * final.cc (length_unit_log): Update comment for partitioned output. + * config/arc/arc-protos.h (regno_clobbered_p): Likewise. + * config/ia64/ia64.cc (bundling): Likewise. + * config/ia64/t-ia64 (insn-attrtab.o-warn): Replace with per-partition + warning variables. + * config/sh/sh.h (code_for_indirect_jump_scratch): Update comment for + partitioned output. + +2026-09-15 Kyrylo Tkachov + + * gensupport.h (generator_output): New structure. + (add_generator_output, open_generator_outputs): Declare. + (close_generator_outputs): Likewise. + (choose_output): Accept generator_output records. Remove the output + index parameter. + * gensupport.cc (add_generator_output): New function. + (open_generator_outputs, close_generator_outputs): Likewise. + (choose_output): Select only partition records. Remove the output index + and disabled round-robin implementation. + (SIZED_BASED_CHUNKS): Remove. + * genemit.cc (output_files): Use generator_output records. + (handle_arg): Register output names. + (main): Use the common open, selection, and close helpers. + * genrecog.cc (print_subroutine_group): Accept generator_output records. + (header_name): Change to a pointer. + (header): Remove global variable. + (output_files): Use generator_output records. + (handle_arg): Register output names and validate -H. + (main): Validate and register the header output. Use the common open, + selection, and close helpers. Remove an unused output selection. + +2026-09-15 Kyrylo Tkachov + + * genattrtab.cc (attr_value): Add enum_index. + (attr_desc): Add num_values, derived_from and derived_table. + (get_attr_value, add_attr_value, find_attr): Maintain them. + (attr_value_index, eq_attr_value_set, simple_enum_attr_p) + (sole_tested_attr, find_derived_attrs, write_derived_attr_get): New + functions. + (write_attr_get): Use write_derived_attr_get where it applies. + (main): Call find_derived_attrs before optimize_attrs. + +2026-09-15 Richard Biener + + PR tree-optimization/126760 + PR tree-optimization/127391 + * tree-if-conv.cc (if_convertible_stmt_p): Delay switch + validation to ... + (if_convertible_loop_p_1): ... the loop iterating over + PHIs. + +2026-09-15 Jakub Jelinek + + PR target/127352 + * config/i386/i386-expand.cc (split_double_mode): For high halves of + paradoxical subregs after RA use CONST0_RTX (half_mode) instead of + ICE. + +2026-09-15 Richard Biener + + PR tree-optimization/113703 + * tree-ssa-loop-ivopts.cc: Include gimple-range.h. + (nonneg_scaled_offset_p): New function. + (iv_elimination_compare_lt): Add USE and BOUND_P parameters. Bail + out if the exit test does not come after the increment of the + candidate, if the comparison in the number of iterations is signed + or if the offsets are not known to be non-negative and to not + overflow. Recompute the bound and store it in BOUND_P. + (may_eliminate_iv): Adjust the call to iv_elimination_compare_lt + and move the expensiveness check on the bound after it. + +2026-09-15 Tamar Christina + + PR target/126629 + * config/aarch64/aarch64-sve-builtins-base.cc + (emit_ldf1_ffr_update): New. + (svldff1_gather_impl, svldff1_gather_extend, svldxf1_impl, + svldxf1_extend_impl): Use it. + * config/aarch64/aarch64-sve.md (aarch64_update_ffr): Update insn. + +2026-09-15 Haochen Jiang + + PR target/127264 + * config/i386/i386-expand.cc (ix86_expand_ace_builtin): + Revise logic to avoid INTVAL check for non-constant + operands. + +2026-09-15 Kyrylo Tkachov + + PR middle-end/127185 + * builtins.cc (expand_builtin_strub_update): Use a separate MEM with + load trap semantics for each watermark load. + (expand_builtin_strub_leave): Use load trap semantics for watermark + MEMs. + +2026-09-15 Kyrylo Tkachov + + PR middle-end/127185 + * cfgexpand.cc (expand_asm_stmt): Restore load MEM_NOTRAP for memory + inputs. + * internal-fn.cc: Include tree-eh.h. + (expand_partial_load_optab_fn): Expand the source as memory and + restore load MEM_NOTRAP. + +2026-09-15 Kyrylo Tkachov + + PR middle-end/127185 + * builtins.cc (get_memory_rtx): Add STORE_P. Pass it to + set_mem_attributes. + (expand_builtin_memory_copy_args): Mark the destination as a store + and the source as a load. + (expand_movstr): Likewise. + (expand_builtin_strncpy): Mark the destination as a store. + (expand_builtin_memset_args): Likewise. + (expand_builtin_memcmp): Mark both memory operands as loads. + (expand_builtin_strcmp): Likewise. + (expand_builtin_strncmp): Likewise. + (inline_string_cmp): Mark the memory operand as a load. + * builtins.h (get_memory_rtx): Add STORE_P. + * internal-fn.cc (expand_RAWMEMCHR): Mark the memory operand as a + load. + +2026-09-15 Kyrylo Tkachov + + PR middle-end/127185 + * emit-rtl.cc (set_mem_attributes_minus_bitpos): Add MAY_STORE_P. + Use lhs_could_trap_p when it is true. + (set_mem_attributes): Add MAY_STORE_P and pass it through. + * emit-rtl.h (set_mem_attributes): Add MAY_STORE_P with a + conservative default. + (set_mem_attributes_minus_bitpos): Likewise. + * expr.cc (expand_assignment): Mark the destination as a store. + (expand_expr_real_1): Treat only EXPAND_NORMAL as a known load. + Set MEM_NOTRAP from the access direction. + +2026-09-15 Kyrylo Tkachov + + PR middle-end/127184 + * gimple.cc (gimple_could_trap_p_1): Check a memory LHS with + lhs_could_trap_p. Do not inspect an LHS as an rvalue. + (test_could_trap): New self-test. + (gimple_cc_tests): Run it. + * tree-eh.cc (stmt_could_throw_p): Check a nothrow call's memory LHS. + +2026-09-15 Naveen + + * config/aarch64/aarch64-simd.md: Add define_expand sadv8qi + guarded by TARGET_DOTPROD. + +2026-09-15 Hongyu Wang + + PR target/127177 + * config/i386/i386-expand.cc (ix86_fp_cmp_code_to_pcmp_immediate): + Return the _UQ predicate immediates for UNLE, UNLT, UNGE, UNGT and + UNEQ. + * config/i386/i386.cc (ix86_print_operand):Likewise to print the + _uq suffixed AVX predicates for these codes. + * config/i386/predicates.md (ix86_fp_vec_cmp_operator): New + predicate. + * config/i386/sse.md (vec_cmp): Use the + new predicate for the VF_128 compare. + * config/i386/mmx.md (vec_cmpv2sfv2si): Likewise. + 2026-09-14 Jean-Didier Pailleux * config/aarch64/aarch64-sve-builtins-sme.def (REQUIRED_EXTENSIONS): Add diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index 1ded3e06871f..ad5c2ea5d68f 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20260915 +20260916 diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog index 3f62aef87ef4..8d1a55002283 100644 --- a/gcc/fortran/ChangeLog +++ b/gcc/fortran/ChangeLog @@ -1,3 +1,63 @@ +2026-09-15 Mikael Morin + + PR fortran/122521 + * trans-expr.cc (gfc_conv_scalar_to_descriptor): Move scalar + descriptor initialization code ... + * trans-descriptor.cc (gfc_set_descriptor_from_scalar): ... here as + a new function. + * trans-descriptor.h (gfc_set_descriptor_from_scalar): New + declaration. + +2026-09-15 Mikael Morin + + PR fortran/122521 + * trans-expr.cc (gfc_conv_derived_to_class): Move scalar descriptor + initialization code ... + * trans-descriptor.cc (gfc_set_descriptor_from_scalar): ... here as + a new function. + * trans-descriptor.h (gfc_set_descriptor_from_scalar): New + declaration. + +2026-09-15 Mikael Morin + + PR fortran/122521 + * trans-descriptor.h (gfc_copy_coarray_desc_part): New declaration. + * trans-descriptor.cc (gfc_copy_coarray_desc_part): New function, + moved from... + * trans-expr.cc (copy_coarray_desc_part): ... here. + (gfc_class_array_data_assign, gfc_conv_derived_to_class): Update + function name in callers. + +2026-09-15 Mikael Morin + + PR fortran/122521 + * trans-expr.cc (gfc_conv_class_to_class): Move descriptor + initialization... + * trans-descriptor.cc (gfc_set_descriptor_from_scalar_class): + ... here as a new function. + * trans-descriptor.h (gfc_set_descriptor_from_scalar_class): New + declaration. + +2026-09-15 Mikael Morin + + PR fortran/122521 + * trans-types.h (gfc_get_scalar_to_descriptor_type): New + declaration. + * trans-types.cc (gfc_get_scalar_to_descriptor_type): New + function, moved from ... + * trans-expr.cc (get_scalar_to_descriptor_type): ... here. + (gfc_conv_scalar_to_descriptor, gfc_conv_derived_to_class, + gfc_conv_class_to_class): Update function name in callers. + +2026-09-15 Mikael Morin + + PR fortran/122521 + * trans-expr.cc (get_scalar_to_descriptor_type): Remove argument + `scalar'; add argument `scalar_type'. Replace `TREE_TYPE (scalar)' + with `scalar_type'. + (gfc_conv_scalar_to_descriptor, gfc_conv_derived_to_class, + gfc_conv_class_to_class): Only pass the type as argument in callers. + 2026-09-13 Jerry DeLisle PR fortran/103474 diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index dcd9a40ba8fc..d09847cb0055 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,83 @@ +2026-09-15 Takayuki 'January June' Suwa + + * gcc.target/xtensa/MOVSP.c: New test. + +2026-09-15 Takayuki 'January June' Suwa + + * gcc.target/xtensa/regA0-allocatability.c: New test. + +2026-09-15 Richard Biener + + PR tree-optimization/127390 + * gcc.dg/vect/vect-pr127390.c: New testcase. + +2026-09-15 Richard Biener + + PR tree-optimization/126760 + PR tree-optimization/127391 + * gcc.dg/vect/vect-pr126760.c: New testcase. + * gcc.dg/vect/vect-pr127391.c: Likewise. + +2026-09-15 Jakub Jelinek + + PR target/127352 + * gcc.target/i386/pr127352.c: New test. + +2026-09-15 Richard Biener + + PR tree-optimization/113703 + * gcc.dg/tree-ssa/ivopts-lt.c: Use unsigned int counters, + restrict to lp64. + * gcc.dg/tree-ssa/ivopts-lt-2.c: Restrict to lp64. + * gcc.dg/torture/pr113703-1.c: New test. + * gcc.dg/torture/pr113703-2.c: New test. + +2026-09-15 Haochen Jiang + + PR target/127264 + * gcc.target/i386/pr127264.c: New test. + +2026-09-15 Kyrylo Tkachov + + PR middle-end/127185 + * c-c++-common/strub-mem-notrap.c: Tighten the load and store scans. + * c-c++-common/strub-mem-notrap-leave.c: New test. + +2026-09-15 Kyrylo Tkachov + + PR middle-end/127185 + * g++.dg/opt/mem-notrap-load-asm.C: New test. + * gcc.target/i386/mem-notrap-mask-load.c: New test. + +2026-09-15 Kyrylo Tkachov + + PR middle-end/127185 + * g++.dg/opt/mem-notrap-load-builtin.C: New test. + +2026-09-15 Kyrylo Tkachov + + PR middle-end/127185 + * g++.dg/eh/noncall-store-2.C: New test. + * g++.dg/opt/mem-notrap-store-asm.C: New test. + +2026-09-15 Kyrylo Tkachov + + PR middle-end/127184 + * g++.dg/eh/noncall-store-call.C: New test. + +2026-09-15 Naveen + + * gcc.target/aarch64/sadv8qi-dotprod.c: New test. + +2026-09-15 Hongyu Wang + + PR target/127177 + * gcc.target/i386/pr127177-1.c: New test. + * gcc.target/i386/pr127177-2.c: Likewise. + * gcc.target/i386/pr127177-3.c: Likewise. + * gcc.target/i386/pr127177-4.c: Likewise. + * gcc.target/i386/pr127177-5.c: Likewise. + 2026-09-14 Robert Dubner * cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.cob: Use @ not U. diff --git a/libgm2/ChangeLog b/libgm2/ChangeLog index 38702ea48fd2..644d85759708 100644 --- a/libgm2/ChangeLog +++ b/libgm2/ChangeLog @@ -1,3 +1,15 @@ +2026-09-15 Gaius Mulley + + PR modula2/127359 + * libm2cor/Makefile.am: Replace bash with sh. + * libm2iso/Makefile.am: Ditto. + * libm2min/Makefile.am: Ditto. + * libm2pim/Makefile.am: Ditto. + * libm2iso/Makefile.in: Regenerate. + * libm2cor/Makefile.in: Ditto. + * libm2min/Makefile.in: Ditto. + * libm2pim/Makefile.in: Ditto. + 2026-09-13 Iain Sandoe * acinclude.m4: Rename configure variables to match the diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 8c0a3806f7b2..5890a97467f7 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,12 @@ +2026-09-15 Patrick Palka + + * include/bits/stl_iterator.h + (__detail::__common_iterator_iter_cat): New. + (iterator_traits): Use it to conditionally + define iterator_category as per LWG 3749. + * testsuite/24_iterators/common_iterator/1.cc (test_lwg3749): + New test. + 2026-09-14 François Dumont * include/debug/inplace_vector: Apply proper coding style on all From f311d59c4d45f5042029647c88966e2e48330adf Mon Sep 17 00:00:00 2001 From: Stefan Schulze Frielinghaus Date: Wed, 16 Sep 2026 08:27:33 +0200 Subject: [PATCH 042/584] ira: Treat hard register constraints similarly as single reg class constraints Treat a hard register constraint the same way as a constraint associated a single register class for process_single_reg_class_operands(). gcc/ChangeLog: * ira-lives.cc (single_reg_class): Compute regno in case of single reg class constraint or hard register constraint, and rename to ... (single_reg_class_regno): ... this. (single_reg_operand_class): Similarly as before and rename to ... (single_reg_operand_class_regno): ... this. (process_single_reg_class_operands): Utilize single_reg_operand_class_regno() and deal with regnos directly instead of single reg classes. (process_single_reg_class_operands): Rename to ... (process_single_reg_constrained_operands): ... this. (process_bb_node_lives): Refer to renamed function. gcc/testsuite/ChangeLog: * gcc.dg/asm-hard-reg-6.c: This patch would result in only one reload for alternative 1 in test_reg_reg which changes costing which in turn leads to choosing alternative 1 for which we didn't test. Restore the old behaviour by choosing for GPR3 r4 which results in two reloads in each alternative. * gcc.target/s390/asm-hard-reg-1.c: Similarly here we also compute a more precise conflicting register set which leads to choosing a different insn alternative for test_out_2. --- gcc/ira-lives.cc | 95 +++++++++++-------- gcc/testsuite/gcc.dg/asm-hard-reg-6.c | 4 +- .../gcc.target/s390/asm-hard-reg-1.c | 4 +- 3 files changed, 59 insertions(+), 44 deletions(-) diff --git a/gcc/ira-lives.cc b/gcc/ira-lives.cc index 9103b3e4ff29..7b9c03e91ad6 100644 --- a/gcc/ira-lives.cc +++ b/gcc/ira-lives.cc @@ -846,16 +846,16 @@ mark_hard_reg_early_clobbers (rtx_insn *insn, bool live_p) } /* Checks that CONSTRAINTS permits to use only one hard register. If - it is so, the function returns the class of the hard register. - Otherwise it returns NO_REGS. */ -static enum reg_class -single_reg_class (const char *constraints, rtx op, rtx equiv_const) + it is so, the function returns the register. Otherwise it returns -1. */ +static int +single_reg_class_regno (const char *constraints, rtx op, rtx equiv_const) { int c; - enum reg_class cl, next_cl; + int regno, next_regno; + enum reg_class next_cl; enum constraint_num cn; - cl = NO_REGS; + regno = -1; alternative_mask preferred = preferred_alternatives; while ((c = *constraints)) { @@ -867,7 +867,14 @@ single_reg_class (const char *constraints, rtx op, rtx equiv_const) switch (c) { case 'g': - return NO_REGS; + return -1; + + case '{': + next_regno = decode_hard_reg_constraint (constraints); + if (regno >= 0 && regno != next_regno) + return -1; + regno = next_regno; + break; default: /* ??? Is this the best way to handle memory constraints? */ @@ -876,21 +883,21 @@ single_reg_class (const char *constraints, rtx op, rtx equiv_const) || insn_extra_special_memory_constraint (cn) || insn_extra_relaxed_memory_constraint (cn) || insn_extra_address_constraint (cn)) - return NO_REGS; + return -1; if (constraint_satisfied_p (op, cn) || (equiv_const != NULL_RTX && CONSTANT_P (equiv_const) && constraint_satisfied_p (equiv_const, cn))) - return NO_REGS; + return -1; next_cl = reg_class_for_constraint (cn); if (next_cl == NO_REGS) break; - if (cl == NO_REGS - ? ira_class_singleton[next_cl][GET_MODE (op)] < 0 - : (ira_class_singleton[cl][GET_MODE (op)] - != ira_class_singleton[next_cl][GET_MODE (op)])) - return NO_REGS; - cl = next_cl; + next_regno = ira_class_singleton[next_cl][GET_MODE (op)]; + if (regno < 0 + ? next_regno < 0 + : regno != next_regno) + return -1; + regno = next_regno; break; case '0': case '1': case '2': case '3': case '4': @@ -899,33 +906,32 @@ single_reg_class (const char *constraints, rtx op, rtx equiv_const) char *end; unsigned long dup = strtoul (constraints, &end, 10); constraints = end; - next_cl - = single_reg_class (recog_data.constraints[dup], - recog_data.operand[dup], NULL_RTX); - if (cl == NO_REGS - ? ira_class_singleton[next_cl][GET_MODE (op)] < 0 - : (ira_class_singleton[cl][GET_MODE (op)] - != ira_class_singleton[next_cl][GET_MODE (op)])) - return NO_REGS; - cl = next_cl; + next_regno + = single_reg_class_regno (recog_data.constraints[dup], + recog_data.operand[dup], NULL_RTX); + if (regno < 0 + ? next_regno < 0 + : regno != next_regno) + return -1; + regno = next_regno; continue; } } constraints += CONSTRAINT_LEN (c, constraints); } - return cl; + return regno; } /* The function checks that operand OP_NUM of the current insn can use only one hard register. If it is so, the function returns the - class of the hard register. Otherwise it returns NO_REGS. */ -static enum reg_class -single_reg_operand_class (int op_num) + hard register. Otherwise it returns -1. */ +static int +single_reg_operand_class_regno (int op_num) { if (op_num < 0 || recog_data.n_alternatives == 0) - return NO_REGS; - return single_reg_class (recog_data.constraints[op_num], - recog_data.operand[op_num], NULL_RTX); + return -1; + return single_reg_class_regno (recog_data.constraints[op_num], + recog_data.operand[op_num], NULL_RTX); } /* The function sets up hard register set *SET to hard registers which @@ -989,9 +995,9 @@ ira_implicitly_set_insn_hard_regs (HARD_REG_SET *set, hard register and makes other currently living allocnos conflicting with the hard register. */ static void -process_single_reg_class_operands (bool in_p, int freq) +process_single_reg_constrained_operands (bool in_p, int freq) { - int i, regno; + int i, regno, hard_regno; unsigned int px; enum reg_class cl; rtx operand; @@ -1006,8 +1012,8 @@ process_single_reg_class_operands (bool in_p, int freq) if (! in_p && recog_data.operand_type[i] != OP_OUT && recog_data.operand_type[i] != OP_INOUT) continue; - cl = single_reg_operand_class (i); - if (cl == NO_REGS) + hard_regno = single_reg_operand_class_regno (i); + if (hard_regno < 0) continue; operand_a = NULL; @@ -1020,6 +1026,11 @@ process_single_reg_class_operands (bool in_p, int freq) { enum reg_class aclass; + cl = NO_REGS; + int nregs = hard_regno_nregs (hard_regno, recog_data.operand_mode[i]); + for (int j = 0; j < nregs; ++j) + cl = reg_class_superunion[cl][REGNO_REG_CLASS (hard_regno + j)]; + operand_a = ira_curr_regno_allocno_map[regno]; aclass = ALLOCNO_CLASS (operand_a); if (ira_class_subset_p[cl][aclass]) @@ -1036,7 +1047,7 @@ process_single_reg_class_operands (bool in_p, int freq) poly_int64 offset; xmode = recog_data.operand_mode[i]; - xregno = ira_class_singleton[cl][xmode]; + xregno = hard_regno; gcc_assert (xregno >= 0); ymode = ALLOCNO_MODE (operand_a); offset = subreg_lowpart_offset (ymode, xmode); @@ -1059,6 +1070,10 @@ process_single_reg_class_operands (bool in_p, int freq) } } + HARD_REG_SET hard_regs; + CLEAR_HARD_REG_SET (hard_regs); + add_to_hard_reg_set (&hard_regs, recog_data.operand_mode[i], hard_regno); + EXECUTE_IF_SET_IN_SPARSESET (objects_live, px) { ira_object_t obj = ira_object_id_map[px]; @@ -1068,8 +1083,8 @@ process_single_reg_class_operands (bool in_p, int freq) /* We could increase costs of A instead of making it conflicting with the hard register. But it works worse because it will be spilled in reload in anyway. */ - OBJECT_CONFLICT_HARD_REGS (obj) |= reg_class_contents[cl]; - OBJECT_TOTAL_CONFLICT_HARD_REGS (obj) |= reg_class_contents[cl]; + OBJECT_CONFLICT_HARD_REGS (obj) |= hard_regs; + OBJECT_TOTAL_CONFLICT_HARD_REGS (obj) |= hard_regs; } } } @@ -1540,7 +1555,7 @@ process_bb_node_lives (ira_loop_tree_node_t loop_tree_node) preferred_alternatives = ira_setup_alts (insn); process_register_constraint_filters (); process_dependent_filters (); - process_single_reg_class_operands (false, freq); + process_single_reg_constrained_operands (false, freq); if (call_p) { @@ -1618,7 +1633,7 @@ process_bb_node_lives (ira_loop_tree_node_t loop_tree_node) FOR_EACH_INSN_USE (use, insn) mark_ref_live (use); - process_single_reg_class_operands (true, freq); + process_single_reg_constrained_operands (true, freq); set_p = mark_hard_reg_early_clobbers (insn, true); diff --git a/gcc/testsuite/gcc.dg/asm-hard-reg-6.c b/gcc/testsuite/gcc.dg/asm-hard-reg-6.c index c87a8116a869..b42b4d2c198a 100644 --- a/gcc/testsuite/gcc.dg/asm-hard-reg-6.c +++ b/gcc/testsuite/gcc.dg/asm-hard-reg-6.c @@ -36,8 +36,8 @@ #elif defined (__s390__) # define GPR1 "{r0}" # define GPR2 "{r1}" -# define GPR3 "{r2}" -/* { dg-final { scan-assembler-times "foo\t%r0,%r2" 1 { target { s390*-*-* } } } } */ +# define GPR3 "{r4}" +/* { dg-final { scan-assembler-times "foo\t%r0,%r4" 1 { target { s390*-*-* } } } } */ /* { dg-final { scan-assembler-times "bar\t%r1,0\\(%r3\\)" 1 { target { s390*-*-* } } } } */ #elif defined (__x86_64__) # define GPR1 "{eax}" diff --git a/gcc/testsuite/gcc.target/s390/asm-hard-reg-1.c b/gcc/testsuite/gcc.target/s390/asm-hard-reg-1.c index 671c0ede6efa..53ac46eb40c8 100644 --- a/gcc/testsuite/gcc.target/s390/asm-hard-reg-1.c +++ b/gcc/testsuite/gcc.target/s390/asm-hard-reg-1.c @@ -75,8 +75,8 @@ test_out_1 (void) ** test_out_2: ** lgr (%r[0-9]+),%r2 ** foo %r2 -** ark (%r[0-9]+),\1,%r2 -** lgfr %r2,\2 +** ar %r2,\1 +** lgfr %r2,%r2 ** br %r14 */ From 2dbd6da80629584645fa2ca250569b89f3c8b653 Mon Sep 17 00:00:00 2001 From: Tamar Christina Date: Wed, 16 Sep 2026 08:44:38 +0100 Subject: [PATCH 043/584] AArch64: Fix SME builtins macro cleanups The macros introduced in the .def file should all be undef at the end to prevent overlap with the next .def file being included. The DEF_SME_FUNCTION_GS macro was missing an undef. gcc/ChangeLog: * config/aarch64/aarch64-sve-builtins-sme.def (DEF_SME_FUNCTION_GS): Undef at end. --- gcc/config/aarch64/aarch64-sve-builtins-sme.def | 1 + 1 file changed, 1 insertion(+) diff --git a/gcc/config/aarch64/aarch64-sve-builtins-sme.def b/gcc/config/aarch64/aarch64-sve-builtins-sme.def index 1f64c489a611..88c0dd68dc6a 100644 --- a/gcc/config/aarch64/aarch64-sve-builtins-sme.def +++ b/gcc/config/aarch64/aarch64-sve-builtins-sme.def @@ -408,3 +408,4 @@ DEF_SME_ZA_FUNCTION_GS_FPM (svtmopa_lane, ternary_za_uint_dual_single, tmop_s_mf #undef DEF_SME_ZA_FUNCTION_GS #undef DEF_SME_ZA_FUNCTION_GS_FPM #undef DEF_SME_FUNCTION +#undef DEF_SME_FUNCTION_GS From 9af2878b87da1f7890c17c50680fb8390936e38a Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Tue, 15 Sep 2026 13:22:57 +0200 Subject: [PATCH 044/584] _BitInt and conversion vectorization The following adds a missing check to prevent vectorizing conversions from _BitInt values which are not appropriately sign-/zero-extended to their mode. * tree-vect-stmts.cc (vectorizable_conversion): Prevent conversions from non-mode-precision _BitInt. * gcc.dg/vect/vect-bitint-1.c: New testcase. --- gcc/testsuite/gcc.dg/vect/vect-bitint-1.c | 40 +++++++++++++++++++++++ gcc/tree-vect-stmts.cc | 11 +++++++ 2 files changed, 51 insertions(+) create mode 100644 gcc/testsuite/gcc.dg/vect/vect-bitint-1.c diff --git a/gcc/testsuite/gcc.dg/vect/vect-bitint-1.c b/gcc/testsuite/gcc.dg/vect/vect-bitint-1.c new file mode 100644 index 000000000000..106ecd500f7c --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-bitint-1.c @@ -0,0 +1,40 @@ +/* { dg-require-effective-target bitint } */ + +#include +#include "tree-vect.h" + +void __attribute__((noipa)) +foo (int64_t *a, signed _BitInt(17) *b) +{ + for (int i = 0; i < 32; i++) + a[i] = b[i]; +} + +int +main () +{ + int64_t a[32]; + _BitInt(17) b[32]; + + check_vect (); + +#pragma GCC novector + for (int i = 0; i < 32; ++i) + b[i] = i; + /* Now set all padding bits in b[] to 1. */ + _BitInt(17) z = ~0; + __builtin_clear_padding (&z); +#pragma GCC novector + for (int i = 0; i < 32; ++i) + for (int j = 0; j < sizeof (z); ++j) + ((char *)&b[i])[j] |= ~(((char *)&z)[j]); + + foo (a, b); + +#pragma GCC novector + for (int i = 0; i < 32; ++i) + if (a[i] != i) + __builtin_abort (); + + return 0; +} diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc index 8cd5fb2001e3..eb78fd2eba39 100644 --- a/gcc/tree-vect-stmts.cc +++ b/gcc/tree-vect-stmts.cc @@ -5389,6 +5389,17 @@ vectorizable_conversion (vec_info *vinfo, return false; } + /* _BitInt values are not sign-/zero-extended to mode precision. */ + if (!VECTOR_BOOLEAN_TYPE_P (vectype_out) + && TREE_CODE (rhs_type) == BITINT_TYPE + && !type_has_mode_precision_p (rhs_type)) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "type conversion from _BitInt unsupported\n"); + return false; + } + if (op_type == binary_op) { gcc_assert (code == WIDEN_MULT_EXPR From 6faf5f174788cedb47a1b99f05a27bdf2d0905bc Mon Sep 17 00:00:00 2001 From: Yap Zhi Heng Date: Wed, 19 Aug 2026 22:45:48 +0800 Subject: [PATCH 045/584] gccrs: Add `unadjusted` and `platform-intrinsic` basic ABI support gcc/rust/ChangeLog: * util/rust-abi.h (ABI): Add PLATFORM_INTRINSIC and UNADJUSTED variants. * util/rust-abi.cc (ABI::get_abi_from_string): Implement cases for PLATFORM_INTRINSIC & UNADJUSTED. (ABI::get_string_from_abi): Ditto. Signed-off-by: Yap Zhi Heng --- gcc/rust/util/rust-abi.cc | 8 ++++++++ gcc/rust/util/rust-abi.h | 4 +++- 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/gcc/rust/util/rust-abi.cc b/gcc/rust/util/rust-abi.cc index d17402e163e6..0a2f9efe4916 100644 --- a/gcc/rust/util/rust-abi.cc +++ b/gcc/rust/util/rust-abi.cc @@ -41,6 +41,10 @@ get_abi_from_string (const std::string &abi) return Rust::ABI::SYSV64; else if (abi.compare ("win64") == 0) return Rust::ABI::WIN_64; + else if (abi.compare ("platform-intrinsic") == 0) + return Rust::ABI::PLATFORM_INTRINSIC; + else if (abi.compare ("unadjusted") == 0) + return Rust::ABI::UNADJUSTED; return Rust::ABI::UNKNOWN; } @@ -66,6 +70,10 @@ get_string_from_abi (Rust::ABI abi) return "sysv64"; case Rust::ABI::WIN_64: return "win64"; + case Rust::ABI::PLATFORM_INTRINSIC: + return "platform-intrinsic"; + case Rust::ABI::UNADJUSTED: + return "unadjusted"; case Rust::ABI::UNKNOWN: return "unknown"; diff --git a/gcc/rust/util/rust-abi.h b/gcc/rust/util/rust-abi.h index 357a5db95ffc..2168a1a9e76e 100644 --- a/gcc/rust/util/rust-abi.h +++ b/gcc/rust/util/rust-abi.h @@ -31,7 +31,9 @@ enum ABI STDCALL, FASTCALL, WIN_64, - SYSV64 + SYSV64, + PLATFORM_INTRINSIC, + UNADJUSTED, }; extern Rust::ABI get_abi_from_string (const std::string &abi); From f674b7ddb54267ade264db6dea822d4e0167399e Mon Sep 17 00:00:00 2001 From: Owen Avery Date: Wed, 19 Aug 2026 22:55:37 -0400 Subject: [PATCH 046/584] gccrs: Resolve lang item types Lang items might not already be resolved when an expression depending on them is resolved. The new test is a copy of for-loop1.rs in the same directory, but the main function item is moved towards the top of the file. It still produces a compiler error after type checking, but that can be resolved in another patch. gcc/rust/ChangeLog: * typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit (BoxExpr)): Attempt to resolve lang item, instead of just looking it up. (TypeCheckExpr::visit (RangeFromToExpr)): Likewise. (TypeCheckExpr::visit (RangeFromExpr)): Likewise. (TypeCheckExpr::visit (RangeToExpr)): Likewise. (TypeCheckExpr::visit (RangeFullExpr)): Likewise. gcc/testsuite/ChangeLog: * rust/compile/for-loop3.rs: New test. Signed-off-by: Owen Avery --- .../typecheck/rust-hir-type-check-expr.cc | 25 +- gcc/testsuite/rust/compile/for-loop3.rs | 549 ++++++++++++++++++ 2 files changed, 554 insertions(+), 20 deletions(-) create mode 100644 gcc/testsuite/rust/compile/for-loop3.rs diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc index aff96db1fd8f..8ba1df7d260d 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc @@ -197,11 +197,8 @@ TypeCheckExpr::visit (HIR::BoxExpr &expr) = mappings.get_lang_item (LangItem::Kind::OWNED_BOX, expr.get_locus ()); HIR::Item *item = mappings.lookup_defid (owned_box_defid).value (); - TyTy::BaseType *item_type = nullptr; + TyTy::BaseType *item_type = TypeCheckItem::Resolve (*item); - bool ok - = context->lookup_type (item->get_mappings ().get_hirid (), &item_type); - rust_assert (ok); if (item_type->get_kind () != TyTy::TypeKind::ADT) { rust_error_at (item->get_locus (), ErrorCode::E0718, @@ -829,10 +826,7 @@ TypeCheckExpr::visit (HIR::RangeFromToExpr &expr) // look it up and it _must_ be a struct definition HIR::Item *item = mappings.lookup_defid (respective_lang_item_id).value (); - TyTy::BaseType *item_type = nullptr; - bool ok - = context->lookup_type (item->get_mappings ().get_hirid (), &item_type); - rust_assert (ok); + TyTy::BaseType *item_type = TypeCheckItem::Resolve (*item); rust_assert (item_type->get_kind () == TyTy::TypeKind::ADT); TyTy::ADTType *adt = static_cast (item_type); @@ -880,10 +874,7 @@ TypeCheckExpr::visit (HIR::RangeFromExpr &expr) // look it up and it _must_ be a struct definition HIR::Item *item = mappings.lookup_defid (respective_lang_item_id).value (); - TyTy::BaseType *item_type = nullptr; - bool ok - = context->lookup_type (item->get_mappings ().get_hirid (), &item_type); - rust_assert (ok); + TyTy::BaseType *item_type = TypeCheckItem::Resolve (*item); rust_assert (item_type->get_kind () == TyTy::TypeKind::ADT); TyTy::ADTType *adt = static_cast (item_type); @@ -924,10 +915,7 @@ TypeCheckExpr::visit (HIR::RangeToExpr &expr) // look it up and it _must_ be a struct definition HIR::Item *item = mappings.lookup_defid (respective_lang_item_id).value (); - TyTy::BaseType *item_type = nullptr; - bool ok - = context->lookup_type (item->get_mappings ().get_hirid (), &item_type); - rust_assert (ok); + TyTy::BaseType *item_type = TypeCheckItem::Resolve (*item); rust_assert (item_type->get_kind () == TyTy::TypeKind::ADT); TyTy::ADTType *adt = static_cast (item_type); @@ -1065,10 +1053,7 @@ TypeCheckExpr::visit (HIR::RangeFullExpr &expr) // look it up and it _must_ be a struct definition HIR::Item *item = mappings.lookup_defid (respective_lang_item_id).value (); - TyTy::BaseType *item_type = nullptr; - bool ok - = context->lookup_type (item->get_mappings ().get_hirid (), &item_type); - rust_assert (ok); + TyTy::BaseType *item_type = TypeCheckItem::Resolve (*item); rust_assert (item_type->is_unit ()); infered = item_type; diff --git a/gcc/testsuite/rust/compile/for-loop3.rs b/gcc/testsuite/rust/compile/for-loop3.rs new file mode 100644 index 000000000000..56251056658b --- /dev/null +++ b/gcc/testsuite/rust/compile/for-loop3.rs @@ -0,0 +1,549 @@ +// { dg-additional-options "-frust-compile-until=compilation" } +// TODO: this should compile fully +// { dg-output "loop\r*\nloop\r*\n" } +#![feature(no_core)] +#![no_core] +#![feature(intrinsics, lang_items)] +#![feature(staged_api)] + +pub fn main() { + let a = 1usize..3usize; + + // TODO: warning is emitted later + for i in a { // { d g-warning "unused name" } + unsafe { puts("loop\0" as *const str as *const i8); } + } +} + +pub use option::Option::{self, None, Some}; +pub use result::Result::{self, Err, Ok}; + +extern "C" { + fn printf(s: *const i8, ...); + fn puts(s: *const i8); +} + +mod option { + pub enum Option { + #[lang = "None"] + None, + #[lang = "Some"] + Some(T), + } +} + +mod result { + enum Result { + Ok(T), + Err(E), + } +} + +#[lang = "sized"] +pub trait Sized {} + +#[lang = "clone"] +pub trait Clone: Sized { + fn clone(&self) -> Self; + + fn clone_from(&mut self, source: &Self) { + *self = source.clone() + } +} + +mod impls { + use super::Clone; + + macro_rules! impl_clone { + ($($t:ty)*) => { + $( + impl Clone for $t { + fn clone(&self) -> Self { + *self + } + } + )* + } + } + + impl_clone! { + usize u8 u16 u32 u64 // u128 + isize i8 i16 i32 i64 // i128 + f32 f64 + bool char + } +} + +#[lang = "copy"] +pub trait Copy: Clone { + // Empty. +} + +mod copy_impls { + use super::Copy; + + macro_rules! impl_copy { + ($($t:ty)*) => { + $( + impl Copy for $t {} + )* + } + } + + impl_copy! { + usize u8 u16 u32 u64 // u128 + isize i8 i16 i32 i64 // i128 + f32 f64 + bool char + } +} + +mod intrinsics { + extern "rust-intrinsic" { + pub fn add_with_overflow(x: T, y: T) -> (T, bool); + pub fn wrapping_add(a: T, b: T) -> T; + pub fn wrapping_sub(a: T, b: T) -> T; + pub fn rotate_left(a: T, b: T) -> T; + pub fn rotate_right(a: T, b: T) -> T; + pub fn offset(ptr: *const T, count: isize) -> *const T; + pub fn copy_nonoverlapping(src: *const T, dst: *mut T, count: usize); + pub fn move_val_init(dst: *mut T, src: T); + pub fn uninit() -> T; + } +} + +mod ptr { + #[lang = "const_ptr"] + impl *const T { + pub unsafe fn offset(self, count: isize) -> *const T { + crate::intrinsics::offset(self, count) + } + } + + #[lang = "mut_ptr"] + impl *mut T { + pub unsafe fn offset(self, count: isize) -> *mut T { + crate::intrinsics::offset(self, count) as *mut T + } + } + + pub unsafe fn swap_nonoverlapping(x: *mut T, y: *mut T, count: usize) { + let x = x as *mut u8; + let y = y as *mut u8; + let len = crate::mem::size_of::() * count; + swap_nonoverlapping_bytes(x, y, len) + } + + pub unsafe fn swap_nonoverlapping_one(x: *mut T, y: *mut T) { + // For types smaller than the block optimization below, + // just swap directly to avoid pessimizing codegen. + if crate::mem::size_of::() < 32 { + let z = read(x); + crate::intrinsics::copy_nonoverlapping(y, x, 1); + write(y, z); + } else { + swap_nonoverlapping(x, y, 1); + } + } + + pub unsafe fn write(dst: *mut T, src: T) { + crate::intrinsics::move_val_init(&mut *dst, src) + } + + pub unsafe fn read(src: *const T) -> T { + let mut tmp: T = crate::mem::uninitialized(); + crate::intrinsics::copy_nonoverlapping(src, &mut tmp, 1); + tmp + } + + pub unsafe fn swap_nonoverlapping_bytes(x: *mut u8, y: *mut u8, len: usize) { + struct Block(u64, u64, u64, u64); + struct UnalignedBlock(u64, u64, u64, u64); + + let block_size = crate::mem::size_of::(); + + // Loop through x & y, copying them `Block` at a time + // The optimizer should unroll the loop fully for most types + // N.B. We can't use a for loop as the `range` impl calls `mem::swap` recursively + let mut i: usize = 0; + while i + block_size <= len { + // Create some uninitialized memory as scratch space + // Declaring `t` here avoids aligning the stack when this loop is unused + let mut t: Block = crate::mem::uninitialized(); + let t = &mut t as *mut _ as *mut u8; + let x = x.offset(i as isize); + let y = y.offset(i as isize); + + // Swap a block of bytes of x & y, using t as a temporary buffer + // This should be optimized into efficient SIMD operations where available + crate::intrinsics::copy_nonoverlapping(x, t, block_size); + crate::intrinsics::copy_nonoverlapping(y, x, block_size); + crate::intrinsics::copy_nonoverlapping(t, y, block_size); + i += block_size; + } + + if i < len { + // Swap any remaining bytes + let mut t: UnalignedBlock = crate::mem::uninitialized(); + let rem = len - i; + + let t = &mut t as *mut _ as *mut u8; + let x = x.offset(i as isize); + let y = y.offset(i as isize); + + crate::intrinsics::copy_nonoverlapping(x, t, rem); + crate::intrinsics::copy_nonoverlapping(y, x, rem); + crate::intrinsics::copy_nonoverlapping(t, y, rem); + } + } +} + +mod mem { + extern "rust-intrinsic" { + #[rustc_const_stable(feature = "const_transmute", since = "1.46.0")] + pub fn transmute(_: T) -> U; + #[rustc_const_stable(feature = "const_size_of", since = "1.40.0")] + pub fn size_of() -> usize; + } + + pub fn swap(x: &mut T, y: &mut T) { + unsafe { + crate::ptr::swap_nonoverlapping_one(x, y); + } + } + + pub fn replace(dest: &mut T, mut src: T) -> T { + swap(dest, &mut src); + src + } + + pub unsafe fn uninitialized() -> T { + crate::intrinsics::uninit() + } +} + +macro_rules! impl_uint { + ($($ty:ident = $lang:literal),*) => { + $( + impl $ty { + pub fn wrapping_add(self, rhs: Self) -> Self { + unsafe { + crate::intrinsics::wrapping_add(self, rhs) + } + } + + pub fn wrapping_sub(self, rhs: Self) -> Self { + unsafe { + crate::intrinsics::wrapping_sub(self, rhs) + } + } + + pub fn rotate_left(self, n: u32) -> Self { + unsafe { + crate::intrinsics::rotate_left(self, n as Self) + } + } + + pub fn rotate_right(self, n: u32) -> Self { + unsafe { + crate::intrinsics::rotate_right(self, n as Self) + } + } + + pub fn to_le(self) -> Self { + #[cfg(target_endian = "little")] + { + self + } + } + + pub const fn from_le_bytes(bytes: [u8; crate::mem::size_of::()]) -> Self { + Self::from_le(Self::from_ne_bytes(bytes)) + } + + pub const fn from_le(x: Self) -> Self { + #[cfg(target_endian = "little")] + { + x + } + } + + pub const fn from_ne_bytes(bytes: [u8; crate::mem::size_of::()]) -> Self { + unsafe { crate::mem::transmute(bytes) } + } + + pub fn checked_add(self, rhs: Self) -> Option { + let (a, b) = self.overflowing_add(rhs); + if b { + Option::None + } else { + Option::Some(a) + } + } + + pub fn overflowing_add(self, rhs: Self) -> (Self, bool) { + let (a, b) = unsafe { crate::intrinsics::add_with_overflow(self as $ty, rhs as $ty) }; + (a as Self, b) + } + } + )* + } +} + +impl_uint!( + u8 = "u8", + u16 = "u16", + u32 = "u32", + u64 = "u64", + usize = "usize" +); + +#[lang = "add"] +pub trait Add { + type Output; + + fn add(self, rhs: RHS) -> Self::Output; +} +macro_rules! add_impl { + ($($t:ty)*) => ($( + impl Add for $t { + type Output = $t; + + fn add(self, other: $t) -> $t { self + other } + } + )*) +} + +add_impl! { usize u8 u16 u32 u64 /*isize i8 i16 i32 i64*/ f32 f64 } + +#[lang = "sub"] +pub trait Sub { + type Output; + + fn sub(self, rhs: RHS) -> Self::Output; +} +macro_rules! sub_impl { + ($($t:ty)*) => ($( + impl Sub for $t { + type Output = $t; + + fn sub(self, other: $t) -> $t { self - other } + } + )*) +} + +sub_impl! { usize u8 u16 u32 u64 /*isize i8 i16 i32 i64*/ f32 f64 } + +#[lang = "Range"] +pub struct Range { + pub start: Idx, + pub end: Idx, +} + +pub trait TryFrom: Sized { + /// The type returned in the event of a conversion error. + type Error; + + /// Performs the conversion. + fn try_from(value: T) -> Result; +} + +pub trait From: Sized { + fn from(_: T) -> Self; +} + +impl From for T { + fn from(t: T) -> T { + t + } +} + +impl TryFrom for T +where + T: From, +{ + type Error = !; + + fn try_from(value: U) -> Result { + Ok(T::from(value)) + } +} + +trait Step { + /// Returns the number of steps between two step objects. The count is + /// inclusive of `start` and exclusive of `end`. + /// + /// Returns `None` if it is not possible to calculate `steps_between` + /// without overflow. + fn steps_between(start: &Self, end: &Self) -> Option; + + /// Replaces this step with `1`, returning itself + fn replace_one(&mut self) -> Self; + + /// Replaces this step with `0`, returning itself + fn replace_zero(&mut self) -> Self; + + /// Adds one to this step, returning the result + fn add_one(&self) -> Self; + + /// Subtracts one to this step, returning the result + fn sub_one(&self) -> Self; + + /// Add an usize, returning None on overflow + fn add_usize(&self, n: usize) -> Option; +} + +// These are still macro-generated because the integer literals resolve to different types. +macro_rules! step_identical_methods { + () => { + #[inline] + fn replace_one(&mut self) -> Self { + crate::mem::replace(self, 1) + } + + #[inline] + fn replace_zero(&mut self) -> Self { + crate::mem::replace(self, 0) + } + + #[inline] + fn add_one(&self) -> Self { + Add::add(*self, 1) + } + + #[inline] + fn sub_one(&self) -> Self { + Sub::sub(*self, 1) + } + }; +} + +macro_rules! step_impl_unsigned { + ($($t:ty)*) => ($( + impl Step for $t { + fn steps_between(start: &$t, end: &$t) -> Option { + if *start < *end { + // Note: We assume $t <= usize here + Option::Some((*end - *start) as usize) + } else { + Option::Some(0) + } + } + + fn add_usize(&self, n: usize) -> Option { + match <$t>::try_from(n) { + Result::Ok(n_as_t) => self.checked_add(n_as_t), + Result::Err(_) => Option::None, + } + } + + step_identical_methods!(); + } + )*) +} +macro_rules! step_impl_signed { + ($( [$t:ty : $unsigned:ty] )*) => ($( + impl Step for $t { + #[inline] + #[allow(trivial_numeric_casts)] + fn steps_between(start: &$t, end: &$t) -> Option { + if *start < *end { + // Note: We assume $t <= isize here + // Use .wrapping_sub and cast to usize to compute the + // difference that may not fit inside the range of isize. + Option::Some((*end as isize).wrapping_sub(*start as isize) as usize) + } else { + Option::Some(0) + } + } + + #[inline] + #[allow(unreachable_patterns)] + fn add_usize(&self, n: usize) -> Option { + match <$unsigned>::try_from(n) { + Result::Ok(n_as_unsigned) => { + // Wrapping in unsigned space handles cases like + // `-120_i8.add_usize(200) == Option::Some(80_i8)`, + // even though 200_usize is out of range for i8. + let wrapped = (*self as $unsigned).wrapping_add(n_as_unsigned) as $t; + if wrapped >= *self { + Option::Some(wrapped) + } else { + Option::None // Addition overflowed + } + } + Result::Err(_) => Option::None, + } + } + + step_identical_methods!(); + } + )*) +} + +macro_rules! step_impl_no_between { + ($($t:ty)*) => ($( + impl Step for $t { + #[inline] + fn steps_between(_start: &Self, _end: &Self) -> Option { + Option::None + } + + #[inline] + fn add_usize(&self, n: usize) -> Option { + self.checked_add(n as $t) + } + + step_identical_methods!(); + } + )*) +} + +step_impl_unsigned!(usize); + +pub trait Iterator { + type Item; + + #[lang = "next"] + fn next(&mut self) -> Option; +} + +impl Iterator for Range { + type Item = A; + + fn next(&mut self) -> Option { + if self.start < self.end { + // We check for overflow here, even though it can't actually + // happen. Adding this check does however help llvm vectorize loops + // for some ranges that don't get vectorized otherwise, + // and this won't actually result in an extra check in an optimized build. + match self.start.add_usize(1) { + Option::Some(mut n) => { + crate::mem::swap(&mut n, &mut self.start); + Option::Some(n) + } + Option::None => Option::None, + } + } else { + Option::None + } + } +} + +pub trait IntoIterator { + type Item; + + type IntoIter: Iterator; + + #[lang = "into_iter"] + fn into_iter(self) -> Self::IntoIter; +} + +impl IntoIterator for I { + type Item = I::Item; + type IntoIter = I; + + fn into_iter(self) -> I { + self + } +} From 4c052de3d7a37c0cb5ec6f6261c27a1658a7af74 Mon Sep 17 00:00:00 2001 From: Utkarsh Bahuguna Date: Wed, 19 Aug 2026 02:11:50 +0530 Subject: [PATCH 047/584] gccrs: Report an error on an empty path expression The path parser previously returned an error node silently when the initial path segment failed to parse. Report a diagnostic for paths beginning with ::, where the resulting error node could otherwise lead to an ICE downstream. Do not apply the guard to bare $, since undefined metavariables already receive more specific diagnostics downstream. Remove the redundant parse_stmt_or_expr guard, which otherwise reports the same error twice. Fixes Rust-GCC/gccrs#4790 gcc/rust/ChangeLog: * parse/rust-parse-impl-path.hxx (Parser::parse_path_in_expression): Report an error when the initial segment of a scoped path fails to parse. * parse/rust-parse-impl.hxx (Parser::parse_stmt_or_expr): Remove the redundant expected-identifier error guard. gcc/testsuite/ChangeLog: * rust/compile/empty_path2.rs: New test. * rust/compile/empty_path3.rs: New test. Signed-off-by: Utkarsh Bahuguna --- gcc/rust/parse/rust-parse-impl-path.hxx | 7 +++++-- gcc/rust/parse/rust-parse-impl.hxx | 9 --------- gcc/testsuite/rust/compile/empty_path2.rs | 9 +++++++++ gcc/testsuite/rust/compile/empty_path3.rs | 12 ++++++++++++ 4 files changed, 26 insertions(+), 11 deletions(-) create mode 100644 gcc/testsuite/rust/compile/empty_path2.rs create mode 100644 gcc/testsuite/rust/compile/empty_path3.rs diff --git a/gcc/rust/parse/rust-parse-impl-path.hxx b/gcc/rust/parse/rust-parse-impl-path.hxx index 4ca12e98893a..0cc517e28156 100644 --- a/gcc/rust/parse/rust-parse-impl-path.hxx +++ b/gcc/rust/parse/rust-parse-impl-path.hxx @@ -389,8 +389,11 @@ Parser::parse_path_in_expression () AST::PathExprSegment initial_segment = parse_path_expr_segment (); if (initial_segment.is_error ()) { - // skip after somewhere? - // don't necessarily throw error but yeah + if (has_opening_scope_resolution) + { + Error error (locus, "expected identifier"); + add_error (std::move (error)); + } return AST::PathInExpression::create_error (); } segments.push_back (std::move (initial_segment)); diff --git a/gcc/rust/parse/rust-parse-impl.hxx b/gcc/rust/parse/rust-parse-impl.hxx index 49a5a45b9f41..b5f41768541c 100644 --- a/gcc/rust/parse/rust-parse-impl.hxx +++ b/gcc/rust/parse/rust-parse-impl.hxx @@ -7294,15 +7294,6 @@ Parser::parse_stmt_or_expr () case DOLLAR_SIGN: { AST::PathInExpression path = parse_path_in_expression (); - if (path.is_error ()) - { - Error error (t->get_locus (), "expected identifier"); - add_error (std::move (error)); - skip_after_semicolon (); - return tl::unexpected ( - Parse::Error::Node::CHILD_ERROR); - } - tl::expected, Parse::Error::Expr> null_denotation; diff --git a/gcc/testsuite/rust/compile/empty_path2.rs b/gcc/testsuite/rust/compile/empty_path2.rs new file mode 100644 index 000000000000..55357db04614 --- /dev/null +++ b/gcc/testsuite/rust/compile/empty_path2.rs @@ -0,0 +1,9 @@ +#![feature(no_core)] +#![no_core] + +// A path expression with no segments in a let initialiser segfaulted +// during type checking, see Rust-GCC/gccrs#4790. +fn main() { + let x = ::; + // { dg-error "expected identifier" "" { target *-*-* } .-1 } +} diff --git a/gcc/testsuite/rust/compile/empty_path3.rs b/gcc/testsuite/rust/compile/empty_path3.rs new file mode 100644 index 000000000000..551d0fefdff3 --- /dev/null +++ b/gcc/testsuite/rust/compile/empty_path3.rs @@ -0,0 +1,12 @@ +#![feature(no_core)] +#![no_core] + +// An empty path `::` in pattern position. The parser returned a path with no +// segments without reporting anything, so type checking dereferenced a null +// root type and the compiler crashed instead of diagnosing. Same defect as +// empty_path2.rs, which covers the let initialiser instead of the pattern. +// See Rust-GCC/gccrs#4790. +fn main() { + let :: = 1; + // { dg-error "expected identifier" "" { target *-*-* } .-1 } +} From 87fe1cad253d14cfbeab30809d6d0eeb0becf902 Mon Sep 17 00:00:00 2001 From: Owen Avery Date: Fri, 21 Aug 2026 22:29:49 -0400 Subject: [PATCH 048/584] gccrs: Function node links should be unnamed Functions shouldn't be usable as named node links. gcc/rust/ChangeLog: * resolve/rust-default-resolver.cc (DefaultResolver::visit (Function)): Don't pass a path parameter to function NameResolutionContext::scoped. gcc/testsuite/ChangeLog: * rust/compile/mod_fn_conflict.rs: New test. Signed-off-by: Owen Avery --- gcc/rust/resolve/rust-default-resolver.cc | 3 +-- gcc/testsuite/rust/compile/mod_fn_conflict.rs | 19 +++++++++++++++++++ 2 files changed, 20 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/rust/compile/mod_fn_conflict.rs diff --git a/gcc/rust/resolve/rust-default-resolver.cc b/gcc/rust/resolve/rust-default-resolver.cc index 7a54c6ee1343..ac2b7b196586 100644 --- a/gcc/rust/resolve/rust-default-resolver.cc +++ b/gcc/rust/resolve/rust-default-resolver.cc @@ -91,8 +91,7 @@ DefaultResolver::visit (AST::Function &function) std::move (def_fn_1)); }; - ctx.scoped (Rib::Kind::Function, function.get_node_id (), def_fn_2, - function.get_function_name ()); + ctx.scoped (Rib::Kind::Function, function.get_node_id (), def_fn_2); } void diff --git a/gcc/testsuite/rust/compile/mod_fn_conflict.rs b/gcc/testsuite/rust/compile/mod_fn_conflict.rs new file mode 100644 index 000000000000..b184e696b5b9 --- /dev/null +++ b/gcc/testsuite/rust/compile/mod_fn_conflict.rs @@ -0,0 +1,19 @@ +// TODO: allow(unused) should be disabling "function is never used" warnings +// { dg-additional-options "-w" } +#![no_core] +#![feature(no_core)] + +mod a { + pub mod b { + pub struct X; + } +} + +use a::*; + +#[allow(unused)] +fn b() {} + +trait Y {} + +impl Y for b::X {} From 8ac1edb96bc5f138212e5a26263ea8a4eddc7f48 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Sun, 23 Aug 2026 13:57:57 +0100 Subject: [PATCH 049/584] gccrs: fix bad projection normalize What can happen depending on order of operation is that the non trait position projections can resolve to generics where we can attempt to get the underlying type and base the projection on that. Fixes Rust-GCC/gccrs#4804 gcc/rust/ChangeLog: * typecheck/rust-type-util.cc (normalize_projection): add check gcc/testsuite/ChangeLog: * rust/execute/torture/issue-4804.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-type-util.cc | 17 +- .../rust/execute/torture/issue-4804.rs | 548 ++++++++++++++++++ 2 files changed, 564 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/rust/execute/torture/issue-4804.rs diff --git a/gcc/rust/typecheck/rust-type-util.cc b/gcc/rust/typecheck/rust-type-util.cc index 5f43bbdbeb56..4a6f444beeda 100644 --- a/gcc/rust/typecheck/rust-type-util.cc +++ b/gcc/rust/typecheck/rust-type-util.cc @@ -563,7 +563,22 @@ normalize_projection (TyTy::ProjectionType *proj, location_t locus, ScopedPush guard (active_projections, proj); if (!proj->is_trait_position ()) - return proj->get (); + { + TyTy::BaseType *base = proj->get (); + if (auto *param = base->try_as ()) + { + if (param->can_resolve ()) + { + TyTy::BaseType *resolved + = TyTy::TyVar (param->get_ty_ref ()).get_tyty (); + if (!resolved->is ()) + base = resolved; + } + } + if (auto *base_proj = base->try_as ()) + return normalize_projection (base_proj, locus, emit_errors, unify_self); + return base; + } // special case the discriminant_type lang item auto &mappings = Analysis::Mappings::get (); diff --git a/gcc/testsuite/rust/execute/torture/issue-4804.rs b/gcc/testsuite/rust/execute/torture/issue-4804.rs new file mode 100644 index 000000000000..8ce608a86011 --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/issue-4804.rs @@ -0,0 +1,548 @@ +// { dg-output "loop\r*\nloop\r*\n" } +#![feature(no_core)] +#![no_core] +#![feature(intrinsics, lang_items)] +#![feature(staged_api)] + +pub fn main() -> i32 { + let a = 1usize..3usize; + + for i in a { // { dg-warning "unused name" } + unsafe { puts("loop\0" as *const str as *const i8); } + } + + 0 +} + +pub use option::Option::{self, None, Some}; +pub use result::Result::{self, Err, Ok}; + +extern "C" { + fn printf(s: *const i8, ...); + fn puts(s: *const i8); +} + +mod option { + pub enum Option { + #[lang = "None"] + None, + #[lang = "Some"] + Some(T), + } +} + +mod result { + enum Result { + Ok(T), + Err(E), + } +} + +#[lang = "sized"] +pub trait Sized {} + +#[lang = "clone"] +pub trait Clone: Sized { + fn clone(&self) -> Self; + + fn clone_from(&mut self, source: &Self) { + *self = source.clone() + } +} + +mod impls { + use super::Clone; + + macro_rules! impl_clone { + ($($t:ty)*) => { + $( + impl Clone for $t { + fn clone(&self) -> Self { + *self + } + } + )* + } + } + + impl_clone! { + usize u8 u16 u32 u64 // u128 + isize i8 i16 i32 i64 // i128 + f32 f64 + bool char + } +} + +#[lang = "copy"] +pub trait Copy: Clone { + // Empty. +} + +mod copy_impls { + use super::Copy; + + macro_rules! impl_copy { + ($($t:ty)*) => { + $( + impl Copy for $t {} + )* + } + } + + impl_copy! { + usize u8 u16 u32 u64 // u128 + isize i8 i16 i32 i64 // i128 + f32 f64 + bool char + } +} + +mod intrinsics { + extern "rust-intrinsic" { + pub fn add_with_overflow(x: T, y: T) -> (T, bool); + pub fn wrapping_add(a: T, b: T) -> T; + pub fn wrapping_sub(a: T, b: T) -> T; + pub fn rotate_left(a: T, b: T) -> T; + pub fn rotate_right(a: T, b: T) -> T; + pub fn offset(ptr: *const T, count: isize) -> *const T; + pub fn copy_nonoverlapping(src: *const T, dst: *mut T, count: usize); + pub fn move_val_init(dst: *mut T, src: T); + pub fn uninit() -> T; + } +} + +mod ptr { + #[lang = "const_ptr"] + impl *const T { + pub unsafe fn offset(self, count: isize) -> *const T { + crate::intrinsics::offset(self, count) + } + } + + #[lang = "mut_ptr"] + impl *mut T { + pub unsafe fn offset(self, count: isize) -> *mut T { + crate::intrinsics::offset(self, count) as *mut T + } + } + + pub unsafe fn swap_nonoverlapping(x: *mut T, y: *mut T, count: usize) { + let x = x as *mut u8; + let y = y as *mut u8; + let len = crate::mem::size_of::() * count; + swap_nonoverlapping_bytes(x, y, len) + } + + pub unsafe fn swap_nonoverlapping_one(x: *mut T, y: *mut T) { + // For types smaller than the block optimization below, + // just swap directly to avoid pessimizing codegen. + if crate::mem::size_of::() < 32 { + let z = read(x); + crate::intrinsics::copy_nonoverlapping(y, x, 1); + write(y, z); + } else { + swap_nonoverlapping(x, y, 1); + } + } + + pub unsafe fn write(dst: *mut T, src: T) { + crate::intrinsics::move_val_init(&mut *dst, src) + } + + pub unsafe fn read(src: *const T) -> T { + let mut tmp: T = crate::mem::uninitialized(); + crate::intrinsics::copy_nonoverlapping(src, &mut tmp, 1); + tmp + } + + pub unsafe fn swap_nonoverlapping_bytes(x: *mut u8, y: *mut u8, len: usize) { + struct Block(u64, u64, u64, u64); + struct UnalignedBlock(u64, u64, u64, u64); + + let block_size = crate::mem::size_of::(); + + // Loop through x & y, copying them `Block` at a time + // The optimizer should unroll the loop fully for most types + // N.B. We can't use a for loop as the `range` impl calls `mem::swap` recursively + let mut i: usize = 0; + while i + block_size <= len { + // Create some uninitialized memory as scratch space + // Declaring `t` here avoids aligning the stack when this loop is unused + let mut t: Block = crate::mem::uninitialized(); + let t = &mut t as *mut _ as *mut u8; + let x = x.offset(i as isize); + let y = y.offset(i as isize); + + // Swap a block of bytes of x & y, using t as a temporary buffer + // This should be optimized into efficient SIMD operations where available + crate::intrinsics::copy_nonoverlapping(x, t, block_size); + crate::intrinsics::copy_nonoverlapping(y, x, block_size); + crate::intrinsics::copy_nonoverlapping(t, y, block_size); + i += block_size; + } + + if i < len { + // Swap any remaining bytes + let mut t: UnalignedBlock = crate::mem::uninitialized(); + let rem = len - i; + + let t = &mut t as *mut _ as *mut u8; + let x = x.offset(i as isize); + let y = y.offset(i as isize); + + crate::intrinsics::copy_nonoverlapping(x, t, rem); + crate::intrinsics::copy_nonoverlapping(y, x, rem); + crate::intrinsics::copy_nonoverlapping(t, y, rem); + } + } +} + +mod mem { + extern "rust-intrinsic" { + #[rustc_const_stable(feature = "const_transmute", since = "1.46.0")] + pub fn transmute(_: T) -> U; + #[rustc_const_stable(feature = "const_size_of", since = "1.40.0")] + pub fn size_of() -> usize; + } + + pub fn swap(x: &mut T, y: &mut T) { + unsafe { + crate::ptr::swap_nonoverlapping_one(x, y); + } + } + + pub fn replace(dest: &mut T, mut src: T) -> T { + swap(dest, &mut src); + src + } + + pub unsafe fn uninitialized() -> T { + crate::intrinsics::uninit() + } +} + +macro_rules! impl_uint { + ($($ty:ident = $lang:literal),*) => { + $( + impl $ty { + pub fn wrapping_add(self, rhs: Self) -> Self { + unsafe { + crate::intrinsics::wrapping_add(self, rhs) + } + } + + pub fn wrapping_sub(self, rhs: Self) -> Self { + unsafe { + crate::intrinsics::wrapping_sub(self, rhs) + } + } + + pub fn rotate_left(self, n: u32) -> Self { + unsafe { + crate::intrinsics::rotate_left(self, n as Self) + } + } + + pub fn rotate_right(self, n: u32) -> Self { + unsafe { + crate::intrinsics::rotate_right(self, n as Self) + } + } + + pub fn to_le(self) -> Self { + #[cfg(target_endian = "little")] + { + self + } + } + + pub const fn from_le_bytes(bytes: [u8; crate::mem::size_of::()]) -> Self { + Self::from_le(Self::from_ne_bytes(bytes)) + } + + pub const fn from_le(x: Self) -> Self { + #[cfg(target_endian = "little")] + { + x + } + } + + pub const fn from_ne_bytes(bytes: [u8; crate::mem::size_of::()]) -> Self { + unsafe { crate::mem::transmute(bytes) } + } + + pub fn checked_add(self, rhs: Self) -> Option { + let (a, b) = self.overflowing_add(rhs); + if b { + Option::None + } else { + Option::Some(a) + } + } + + pub fn overflowing_add(self, rhs: Self) -> (Self, bool) { + let (a, b) = unsafe { crate::intrinsics::add_with_overflow(self as $ty, rhs as $ty) }; + (a as Self, b) + } + } + )* + } +} + +impl_uint!( + u8 = "u8", + u16 = "u16", + u32 = "u32", + u64 = "u64", + usize = "usize" +); + +#[lang = "add"] +pub trait Add { + type Output; + + fn add(self, rhs: RHS) -> Self::Output; +} +macro_rules! add_impl { + ($($t:ty)*) => ($( + impl Add for $t { + type Output = $t; + + fn add(self, other: $t) -> $t { self + other } + } + )*) +} + +add_impl! { usize u8 u16 u32 u64 /*isize i8 i16 i32 i64*/ f32 f64 } + +#[lang = "sub"] +pub trait Sub { + type Output; + + fn sub(self, rhs: RHS) -> Self::Output; +} +macro_rules! sub_impl { + ($($t:ty)*) => ($( + impl Sub for $t { + type Output = $t; + + fn sub(self, other: $t) -> $t { self - other } + } + )*) +} + +sub_impl! { usize u8 u16 u32 u64 /*isize i8 i16 i32 i64*/ f32 f64 } + +#[lang = "Range"] +pub struct Range { + pub start: Idx, + pub end: Idx, +} + +pub trait TryFrom: Sized { + /// The type returned in the event of a conversion error. + type Error; + + /// Performs the conversion. + fn try_from(value: T) -> Result; +} + +pub trait From: Sized { + fn from(_: T) -> Self; +} + +impl From for T { + fn from(t: T) -> T { + t + } +} + +impl TryFrom for T +where + T: From, +{ + type Error = !; + + fn try_from(value: U) -> Result { + Ok(T::from(value)) + } +} + +trait Step { + /// Returns the number of steps between two step objects. The count is + /// inclusive of `start` and exclusive of `end`. + /// + /// Returns `None` if it is not possible to calculate `steps_between` + /// without overflow. + fn steps_between(start: &Self, end: &Self) -> Option; + + /// Replaces this step with `1`, returning itself + fn replace_one(&mut self) -> Self; + + /// Replaces this step with `0`, returning itself + fn replace_zero(&mut self) -> Self; + + /// Adds one to this step, returning the result + fn add_one(&self) -> Self; + + /// Subtracts one to this step, returning the result + fn sub_one(&self) -> Self; + + /// Add an usize, returning None on overflow + fn add_usize(&self, n: usize) -> Option; +} + +// These are still macro-generated because the integer literals resolve to different types. +macro_rules! step_identical_methods { + () => { + #[inline] + fn replace_one(&mut self) -> Self { + crate::mem::replace(self, 1) + } + + #[inline] + fn replace_zero(&mut self) -> Self { + crate::mem::replace(self, 0) + } + + #[inline] + fn add_one(&self) -> Self { + Add::add(*self, 1) + } + + #[inline] + fn sub_one(&self) -> Self { + Sub::sub(*self, 1) + } + }; +} + +macro_rules! step_impl_unsigned { + ($($t:ty)*) => ($( + impl Step for $t { + fn steps_between(start: &$t, end: &$t) -> Option { + if *start < *end { + // Note: We assume $t <= usize here + Option::Some((*end - *start) as usize) + } else { + Option::Some(0) + } + } + + fn add_usize(&self, n: usize) -> Option { + match <$t>::try_from(n) { + Result::Ok(n_as_t) => self.checked_add(n_as_t), + Result::Err(_) => Option::None, + } + } + + step_identical_methods!(); + } + )*) +} +macro_rules! step_impl_signed { + ($( [$t:ty : $unsigned:ty] )*) => ($( + impl Step for $t { + #[inline] + #[allow(trivial_numeric_casts)] + fn steps_between(start: &$t, end: &$t) -> Option { + if *start < *end { + // Note: We assume $t <= isize here + // Use .wrapping_sub and cast to usize to compute the + // difference that may not fit inside the range of isize. + Option::Some((*end as isize).wrapping_sub(*start as isize) as usize) + } else { + Option::Some(0) + } + } + + #[inline] + #[allow(unreachable_patterns)] + fn add_usize(&self, n: usize) -> Option { + match <$unsigned>::try_from(n) { + Result::Ok(n_as_unsigned) => { + // Wrapping in unsigned space handles cases like + // `-120_i8.add_usize(200) == Option::Some(80_i8)`, + // even though 200_usize is out of range for i8. + let wrapped = (*self as $unsigned).wrapping_add(n_as_unsigned) as $t; + if wrapped >= *self { + Option::Some(wrapped) + } else { + Option::None // Addition overflowed + } + } + Result::Err(_) => Option::None, + } + } + + step_identical_methods!(); + } + )*) +} + +macro_rules! step_impl_no_between { + ($($t:ty)*) => ($( + impl Step for $t { + #[inline] + fn steps_between(_start: &Self, _end: &Self) -> Option { + Option::None + } + + #[inline] + fn add_usize(&self, n: usize) -> Option { + self.checked_add(n as $t) + } + + step_identical_methods!(); + } + )*) +} + +step_impl_unsigned!(usize); + +pub trait Iterator { + type Item; + + #[lang = "next"] + fn next(&mut self) -> Option; +} + +impl Iterator for Range { + type Item = A; + + fn next(&mut self) -> Option { + if self.start < self.end { + // We check for overflow here, even though it can't actually + // happen. Adding this check does however help llvm vectorize loops + // for some ranges that don't get vectorized otherwise, + // and this won't actually result in an extra check in an optimized build. + match self.start.add_usize(1) { + Option::Some(mut n) => { + crate::mem::swap(&mut n, &mut self.start); + Option::Some(n) + } + Option::None => Option::None, + } + } else { + Option::None + } + } +} + +pub trait IntoIterator { + type Item; + + type IntoIter: Iterator; + + #[lang = "into_iter"] + fn into_iter(self) -> Self::IntoIter; +} + +impl IntoIterator for I { + type Item = I::Item; + type IntoIter = I; + + fn into_iter(self) -> I { + self + } +} From a04da45d8722e4a9eae4b2d1e995ff9b8f658751 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Sun, 23 Aug 2026 14:17:19 +0100 Subject: [PATCH 050/584] gccrs: Add missing unconstrained type parameters walker for const generics Fixes Rust-GCC/gccrs#4805 gcc/rust/ChangeLog: * typecheck/rust-hir-type-check-base.cc (walk_type_to_constrain): walk const generics gcc/testsuite/ChangeLog: * rust/compile/issue-4805.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-type-check-base.cc | 8 ++++++++ gcc/testsuite/rust/compile/issue-4805.rs | 7 +++++++ 2 files changed, 15 insertions(+) create mode 100644 gcc/testsuite/rust/compile/issue-4805.rs diff --git a/gcc/rust/typecheck/rust-hir-type-check-base.cc b/gcc/rust/typecheck/rust-hir-type-check-base.cc index 399b9594609a..97ff55400c3d 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-base.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-base.cc @@ -101,6 +101,7 @@ walk_type_to_constrain (std::set &constrained_symbols, TyTy::BaseType &r) { auto &arr = static_cast (r); walk_type_to_constrain (constrained_symbols, *arr.get_element_type ()); + walk_type_to_constrain (constrained_symbols, *arr.get_capacity ()); } break; case TyTy::TypeKind::FNDEF: @@ -117,6 +118,13 @@ walk_type_to_constrain (std::set &constrained_symbols, TyTy::BaseType &r) constrained_symbols.insert (param.get_ty_ref ()); } break; + case TyTy::TypeKind::CONST: + { + auto *constant = r.as_const_type (); + if (constant->const_kind () == TyTy::BaseConstType::ConstKind::Decl) + constrained_symbols.insert (r.get_ty_ref ()); + } + break; case TyTy::SLICE: { auto &slice = static_cast (r); diff --git a/gcc/testsuite/rust/compile/issue-4805.rs b/gcc/testsuite/rust/compile/issue-4805.rs new file mode 100644 index 000000000000..300e3d5aa08d --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4805.rs @@ -0,0 +1,7 @@ +#![no_core] +#![feature(no_core)] +#![feature(min_const_generics)] + +trait A {} + +impl A for [u8; N] {} From 6342dc8a7f9dcce8d960b45bca27c33da9911ede Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 17 Aug 2026 19:56:37 +0100 Subject: [PATCH 051/584] gccrs: Wrap rust_debugs into a do-while wrapper This reduces compile time when debug is turned off due to evaultion of any passed arguments. gcc/rust/ChangeLog: * rust-diagnostics.cc (rust_debug_loc): rename (rust_debug_loc_internal): no longer check if debug is enabled * rust-diagnostics.h (rust_debug): new wrapper (rust_debug_loc): likewise (rust_debug_loc_internal): likewise Signed-off-by: Philip Herron --- gcc/rust/rust-diagnostics.cc | 5 +---- gcc/rust/rust-diagnostics.h | 20 +++++++++++++++++--- 2 files changed, 18 insertions(+), 7 deletions(-) diff --git a/gcc/rust/rust-diagnostics.cc b/gcc/rust/rust-diagnostics.cc index 498805acc3e1..bdd78f7f29d2 100644 --- a/gcc/rust/rust-diagnostics.cc +++ b/gcc/rust/rust-diagnostics.cc @@ -398,11 +398,8 @@ rust_be_debug_p (void) } void -rust_debug_loc (const location_t location, const char *fmt, ...) +rust_debug_loc_internal (const location_t location, const char *fmt, ...) { - if (!rust_be_debug_p ()) - return; - va_list ap; va_start (ap, fmt); diff --git a/gcc/rust/rust-diagnostics.h b/gcc/rust/rust-diagnostics.h index 7fe2596e8d14..e15c3a4508b2 100644 --- a/gcc/rust/rust-diagnostics.h +++ b/gcc/rust/rust-diagnostics.h @@ -300,12 +300,26 @@ struct Error } // namespace Rust // rust_debug uses normal printf formatting, not GCC diagnostic formatting. -#define rust_debug(...) rust_debug_loc (UNDEF_LOCATION, __VA_ARGS__) +#define rust_debug(...) \ + do \ + { \ + if (rust_be_debug_p ()) \ + rust_debug_loc_internal (UNDEF_LOCATION, __VA_ARGS__); \ + } \ + while (0) + +#define rust_debug_loc(location, ...) \ + do \ + { \ + if (rust_be_debug_p ()) \ + rust_debug_loc_internal (location, __VA_ARGS__); \ + } \ + while (0) #define rust_sorry_at(location, ...) sorry_at (location, __VA_ARGS__) -void rust_debug_loc (const location_t location, const char *fmt, - ...) ATTRIBUTE_PRINTF_2; +void rust_debug_loc_internal (const location_t location, const char *fmt, + ...) ATTRIBUTE_PRINTF_2; // like rust_debug, but has gcc diagnostic formatting #define rust_debug_fmt(...) rust_debug_fmt_at (UNDEF_LOCATION, __VA_ARGS__) From 2c4a56101183636362c49a9a0d8db8d201b626a8 Mon Sep 17 00:00:00 2001 From: Enes Cevik Date: Mon, 10 Aug 2026 12:01:10 +0300 Subject: [PATCH 052/584] gccrs: Import liballoc 1.49.0 This commit imports liballoc 1.49.0. libgrust/ChangeLog: * rustc-lib/version-info: * rustc-lib/alloc/Cargo.toml: New file. * rustc-lib/alloc/benches/binary_heap.rs: New file. * rustc-lib/alloc/benches/btree/map.rs: New file. * rustc-lib/alloc/benches/btree/mod.rs: New file. * rustc-lib/alloc/benches/btree/set.rs: New file. * rustc-lib/alloc/benches/lib.rs: New file. * rustc-lib/alloc/benches/linked_list.rs: New file. * rustc-lib/alloc/benches/slice.rs: New file. * rustc-lib/alloc/benches/str.rs: New file. * rustc-lib/alloc/benches/string.rs: New file. * rustc-lib/alloc/benches/vec.rs: New file. * rustc-lib/alloc/benches/vec_deque.rs: New file. * rustc-lib/alloc/benches/vec_deque_append.rs: New file. * rustc-lib/alloc/src/alloc.rs: New file. * rustc-lib/alloc/src/alloc/tests.rs: New file. * rustc-lib/alloc/src/borrow.rs: New file. * rustc-lib/alloc/src/boxed.rs: New file. * rustc-lib/alloc/src/collections/binary_heap.rs: New file. * rustc-lib/alloc/src/collections/btree/append.rs: New file. * rustc-lib/alloc/src/collections/btree/borrow.rs: New file. * rustc-lib/alloc/src/collections/btree/borrow/tests.rs: New file. * rustc-lib/alloc/src/collections/btree/map.rs: New file. * rustc-lib/alloc/src/collections/btree/map/entry.rs: New file. * rustc-lib/alloc/src/collections/btree/map/tests.rs: New file. * rustc-lib/alloc/src/collections/btree/mem.rs: New file. * rustc-lib/alloc/src/collections/btree/merge_iter.rs: New file. * rustc-lib/alloc/src/collections/btree/mod.rs: New file. * rustc-lib/alloc/src/collections/btree/navigate.rs: New file. * rustc-lib/alloc/src/collections/btree/node.rs: New file. * rustc-lib/alloc/src/collections/btree/node/tests.rs: New file. * rustc-lib/alloc/src/collections/btree/remove.rs: New file. * rustc-lib/alloc/src/collections/btree/search.rs: New file. * rustc-lib/alloc/src/collections/btree/set.rs: New file. * rustc-lib/alloc/src/collections/btree/set/tests.rs: New file. * rustc-lib/alloc/src/collections/btree/split.rs: New file. * rustc-lib/alloc/src/collections/linked_list.rs: New file. * rustc-lib/alloc/src/collections/linked_list/tests.rs: New file. * rustc-lib/alloc/src/collections/mod.rs: New file. * rustc-lib/alloc/src/collections/vec_deque.rs: New file. * rustc-lib/alloc/src/collections/vec_deque/drain.rs: New file. * rustc-lib/alloc/src/collections/vec_deque/tests.rs: New file. * rustc-lib/alloc/src/fmt.rs: New file. * rustc-lib/alloc/src/lib.rs: New file. * rustc-lib/alloc/src/macros.rs: New file. * rustc-lib/alloc/src/prelude/mod.rs: New file. * rustc-lib/alloc/src/prelude/v1.rs: New file. * rustc-lib/alloc/src/raw_vec.rs: New file. * rustc-lib/alloc/src/raw_vec/tests.rs: New file. * rustc-lib/alloc/src/rc.rs: New file. * rustc-lib/alloc/src/rc/tests.rs: New file. * rustc-lib/alloc/src/slice.rs: New file. * rustc-lib/alloc/src/str.rs: New file. * rustc-lib/alloc/src/string.rs: New file. * rustc-lib/alloc/src/sync.rs: New file. * rustc-lib/alloc/src/sync/tests.rs: New file. * rustc-lib/alloc/src/task.rs: New file. * rustc-lib/alloc/src/tests.rs: New file. * rustc-lib/alloc/src/vec.rs: New file. * rustc-lib/alloc/tests/arc.rs: New file. * rustc-lib/alloc/tests/binary_heap.rs: New file. * rustc-lib/alloc/tests/borrow.rs: New file. * rustc-lib/alloc/tests/boxed.rs: New file. * rustc-lib/alloc/tests/btree_set_hash.rs: New file. * rustc-lib/alloc/tests/cow_str.rs: New file. * rustc-lib/alloc/tests/fmt.rs: New file. * rustc-lib/alloc/tests/heap.rs: New file. * rustc-lib/alloc/tests/lib.rs: New file. * rustc-lib/alloc/tests/linked_list.rs: New file. * rustc-lib/alloc/tests/rc.rs: New file. * rustc-lib/alloc/tests/slice.rs: New file. * rustc-lib/alloc/tests/str.rs: New file. * rustc-lib/alloc/tests/string.rs: New file. * rustc-lib/alloc/tests/vec.rs: New file. * rustc-lib/alloc/tests/vec_deque.rs: New file. Signed-off-by: Enes Cevik --- libgrust/rustc-lib/alloc/Cargo.toml | 33 + .../rustc-lib/alloc/benches/binary_heap.rs | 91 + libgrust/rustc-lib/alloc/benches/btree/map.rs | 586 +++ libgrust/rustc-lib/alloc/benches/btree/mod.rs | 2 + libgrust/rustc-lib/alloc/benches/btree/set.rs | 224 ++ libgrust/rustc-lib/alloc/benches/lib.rs | 18 + .../rustc-lib/alloc/benches/linked_list.rs | 77 + libgrust/rustc-lib/alloc/benches/slice.rs | 382 ++ libgrust/rustc-lib/alloc/benches/str.rs | 299 ++ libgrust/rustc-lib/alloc/benches/string.rs | 164 + libgrust/rustc-lib/alloc/benches/vec.rs | 673 ++++ libgrust/rustc-lib/alloc/benches/vec_deque.rs | 54 + .../alloc/benches/vec_deque_append.rs | 34 + libgrust/rustc-lib/alloc/src/alloc.rs | 411 ++ libgrust/rustc-lib/alloc/src/alloc/tests.rs | 30 + libgrust/rustc-lib/alloc/src/borrow.rs | 478 +++ libgrust/rustc-lib/alloc/src/boxed.rs | 1433 +++++++ .../alloc/src/collections/binary_heap.rs | 1459 +++++++ .../alloc/src/collections/btree/append.rs | 124 + .../alloc/src/collections/btree/borrow.rs | 47 + .../src/collections/btree/borrow/tests.rs | 19 + .../alloc/src/collections/btree/map.rs | 2145 ++++++++++ .../alloc/src/collections/btree/map/entry.rs | 475 +++ .../alloc/src/collections/btree/map/tests.rs | 1884 +++++++++ .../alloc/src/collections/btree/mem.rs | 34 + .../alloc/src/collections/btree/merge_iter.rs | 98 + .../alloc/src/collections/btree/mod.rs | 64 + .../alloc/src/collections/btree/navigate.rs | 528 +++ .../alloc/src/collections/btree/node.rs | 1709 ++++++++ .../alloc/src/collections/btree/node/tests.rs | 111 + .../alloc/src/collections/btree/remove.rs | 133 + .../alloc/src/collections/btree/search.rs | 83 + .../alloc/src/collections/btree/set.rs | 1509 ++++++++ .../alloc/src/collections/btree/set/tests.rs | 732 ++++ .../alloc/src/collections/btree/split.rs | 106 + .../alloc/src/collections/linked_list.rs | 1872 +++++++++ .../src/collections/linked_list/tests.rs | 430 +++ .../rustc-lib/alloc/src/collections/mod.rs | 103 + .../alloc/src/collections/vec_deque.rs | 3299 ++++++++++++++++ .../alloc/src/collections/vec_deque/drain.rs | 125 + .../alloc/src/collections/vec_deque/tests.rs | 586 +++ libgrust/rustc-lib/alloc/src/fmt.rs | 579 +++ libgrust/rustc-lib/alloc/src/lib.rs | 196 + libgrust/rustc-lib/alloc/src/macros.rs | 109 + libgrust/rustc-lib/alloc/src/prelude/mod.rs | 15 + libgrust/rustc-lib/alloc/src/prelude/v1.rs | 14 + libgrust/rustc-lib/alloc/src/raw_vec.rs | 543 +++ libgrust/rustc-lib/alloc/src/raw_vec/tests.rs | 79 + libgrust/rustc-lib/alloc/src/rc.rs | 2227 +++++++++++ libgrust/rustc-lib/alloc/src/rc/tests.rs | 520 +++ libgrust/rustc-lib/alloc/src/slice.rs | 1071 +++++ libgrust/rustc-lib/alloc/src/str.rs | 576 +++ libgrust/rustc-lib/alloc/src/string.rs | 2537 ++++++++++++ libgrust/rustc-lib/alloc/src/sync.rs | 2376 ++++++++++++ libgrust/rustc-lib/alloc/src/sync/tests.rs | 579 +++ libgrust/rustc-lib/alloc/src/task.rs | 91 + libgrust/rustc-lib/alloc/src/tests.rs | 151 + libgrust/rustc-lib/alloc/src/vec.rs | 3439 +++++++++++++++++ libgrust/rustc-lib/alloc/tests/arc.rs | 197 + libgrust/rustc-lib/alloc/tests/binary_heap.rs | 476 +++ libgrust/rustc-lib/alloc/tests/borrow.rs | 60 + libgrust/rustc-lib/alloc/tests/boxed.rs | 59 + .../rustc-lib/alloc/tests/btree_set_hash.rs | 19 + libgrust/rustc-lib/alloc/tests/cow_str.rs | 144 + libgrust/rustc-lib/alloc/tests/fmt.rs | 327 ++ libgrust/rustc-lib/alloc/tests/heap.rs | 44 + libgrust/rustc-lib/alloc/tests/lib.rs | 64 + libgrust/rustc-lib/alloc/tests/linked_list.rs | 705 ++++ libgrust/rustc-lib/alloc/tests/rc.rs | 193 + libgrust/rustc-lib/alloc/tests/slice.rs | 1900 +++++++++ libgrust/rustc-lib/alloc/tests/str.rs | 1973 ++++++++++ libgrust/rustc-lib/alloc/tests/string.rs | 778 ++++ libgrust/rustc-lib/alloc/tests/vec.rs | 1956 ++++++++++ libgrust/rustc-lib/alloc/tests/vec_deque.rs | 1730 +++++++++ libgrust/rustc-lib/version-info | 1 + 75 files changed, 48392 insertions(+) create mode 100644 libgrust/rustc-lib/alloc/Cargo.toml create mode 100644 libgrust/rustc-lib/alloc/benches/binary_heap.rs create mode 100644 libgrust/rustc-lib/alloc/benches/btree/map.rs create mode 100644 libgrust/rustc-lib/alloc/benches/btree/mod.rs create mode 100644 libgrust/rustc-lib/alloc/benches/btree/set.rs create mode 100644 libgrust/rustc-lib/alloc/benches/lib.rs create mode 100644 libgrust/rustc-lib/alloc/benches/linked_list.rs create mode 100644 libgrust/rustc-lib/alloc/benches/slice.rs create mode 100644 libgrust/rustc-lib/alloc/benches/str.rs create mode 100644 libgrust/rustc-lib/alloc/benches/string.rs create mode 100644 libgrust/rustc-lib/alloc/benches/vec.rs create mode 100644 libgrust/rustc-lib/alloc/benches/vec_deque.rs create mode 100644 libgrust/rustc-lib/alloc/benches/vec_deque_append.rs create mode 100644 libgrust/rustc-lib/alloc/src/alloc.rs create mode 100644 libgrust/rustc-lib/alloc/src/alloc/tests.rs create mode 100644 libgrust/rustc-lib/alloc/src/borrow.rs create mode 100644 libgrust/rustc-lib/alloc/src/boxed.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/binary_heap.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/btree/append.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/btree/borrow.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/btree/borrow/tests.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/btree/map.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/btree/map/entry.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/btree/map/tests.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/btree/mem.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/btree/merge_iter.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/btree/mod.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/btree/navigate.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/btree/node.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/btree/node/tests.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/btree/remove.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/btree/search.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/btree/set.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/btree/set/tests.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/btree/split.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/linked_list.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/linked_list/tests.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/mod.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/vec_deque.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/vec_deque/drain.rs create mode 100644 libgrust/rustc-lib/alloc/src/collections/vec_deque/tests.rs create mode 100644 libgrust/rustc-lib/alloc/src/fmt.rs create mode 100644 libgrust/rustc-lib/alloc/src/lib.rs create mode 100644 libgrust/rustc-lib/alloc/src/macros.rs create mode 100644 libgrust/rustc-lib/alloc/src/prelude/mod.rs create mode 100644 libgrust/rustc-lib/alloc/src/prelude/v1.rs create mode 100644 libgrust/rustc-lib/alloc/src/raw_vec.rs create mode 100644 libgrust/rustc-lib/alloc/src/raw_vec/tests.rs create mode 100644 libgrust/rustc-lib/alloc/src/rc.rs create mode 100644 libgrust/rustc-lib/alloc/src/rc/tests.rs create mode 100644 libgrust/rustc-lib/alloc/src/slice.rs create mode 100644 libgrust/rustc-lib/alloc/src/str.rs create mode 100644 libgrust/rustc-lib/alloc/src/string.rs create mode 100644 libgrust/rustc-lib/alloc/src/sync.rs create mode 100644 libgrust/rustc-lib/alloc/src/sync/tests.rs create mode 100644 libgrust/rustc-lib/alloc/src/task.rs create mode 100644 libgrust/rustc-lib/alloc/src/tests.rs create mode 100644 libgrust/rustc-lib/alloc/src/vec.rs create mode 100644 libgrust/rustc-lib/alloc/tests/arc.rs create mode 100644 libgrust/rustc-lib/alloc/tests/binary_heap.rs create mode 100644 libgrust/rustc-lib/alloc/tests/borrow.rs create mode 100644 libgrust/rustc-lib/alloc/tests/boxed.rs create mode 100644 libgrust/rustc-lib/alloc/tests/btree_set_hash.rs create mode 100644 libgrust/rustc-lib/alloc/tests/cow_str.rs create mode 100644 libgrust/rustc-lib/alloc/tests/fmt.rs create mode 100644 libgrust/rustc-lib/alloc/tests/heap.rs create mode 100644 libgrust/rustc-lib/alloc/tests/lib.rs create mode 100644 libgrust/rustc-lib/alloc/tests/linked_list.rs create mode 100644 libgrust/rustc-lib/alloc/tests/rc.rs create mode 100644 libgrust/rustc-lib/alloc/tests/slice.rs create mode 100644 libgrust/rustc-lib/alloc/tests/str.rs create mode 100644 libgrust/rustc-lib/alloc/tests/string.rs create mode 100644 libgrust/rustc-lib/alloc/tests/vec.rs create mode 100644 libgrust/rustc-lib/alloc/tests/vec_deque.rs diff --git a/libgrust/rustc-lib/alloc/Cargo.toml b/libgrust/rustc-lib/alloc/Cargo.toml new file mode 100644 index 000000000000..381750a5198c --- /dev/null +++ b/libgrust/rustc-lib/alloc/Cargo.toml @@ -0,0 +1,33 @@ +[package] +authors = ["The Rust Project Developers"] +name = "alloc" +version = "0.0.0" +autotests = false +autobenches = false +edition = "2018" + +[dependencies] +core = { path = "../core" } +compiler_builtins = { version = "0.1.10", features = ['rustc-dep-of-std'] } + +[dev-dependencies] +rand = "0.7" +rand_xorshift = "0.2" + +[[test]] +name = "collectionstests" +path = "tests/lib.rs" + +[[bench]] +name = "collectionsbenches" +path = "benches/lib.rs" +test = true + +[[bench]] +name = "vec_deque_append_bench" +path = "benches/vec_deque_append.rs" +harness = false + +[features] +compiler-builtins-mem = ['compiler_builtins/mem'] +compiler-builtins-c = ["compiler_builtins/c"] diff --git a/libgrust/rustc-lib/alloc/benches/binary_heap.rs b/libgrust/rustc-lib/alloc/benches/binary_heap.rs new file mode 100644 index 000000000000..5b6538ea6c6b --- /dev/null +++ b/libgrust/rustc-lib/alloc/benches/binary_heap.rs @@ -0,0 +1,91 @@ +use std::collections::BinaryHeap; + +use rand::{seq::SliceRandom, thread_rng}; +use test::{black_box, Bencher}; + +#[bench] +fn bench_find_smallest_1000(b: &mut Bencher) { + let mut rng = thread_rng(); + let mut vec: Vec = (0..100_000).collect(); + vec.shuffle(&mut rng); + + b.iter(|| { + let mut iter = vec.iter().copied(); + let mut heap: BinaryHeap<_> = iter.by_ref().take(1000).collect(); + + for x in iter { + let mut max = heap.peek_mut().unwrap(); + // This comparison should be true only 1% of the time. + // Unnecessary `sift_down`s will degrade performance + if x < *max { + *max = x; + } + } + + heap + }) +} + +#[bench] +fn bench_peek_mut_deref_mut(b: &mut Bencher) { + let mut bheap = BinaryHeap::from(vec![42]); + let vec: Vec = (0..1_000_000).collect(); + + b.iter(|| { + let vec = black_box(&vec); + let mut peek_mut = bheap.peek_mut().unwrap(); + // The compiler shouldn't be able to optimize away the `sift_down` + // assignment in `PeekMut`'s `DerefMut` implementation since + // the loop may not run. + for &i in vec.iter() { + *peek_mut = i; + } + // Remove the already minimal overhead of the sift_down + std::mem::forget(peek_mut); + }) +} + +#[bench] +fn bench_from_vec(b: &mut Bencher) { + let mut rng = thread_rng(); + let mut vec: Vec = (0..100_000).collect(); + vec.shuffle(&mut rng); + + b.iter(|| BinaryHeap::from(vec.clone())) +} + +#[bench] +fn bench_into_sorted_vec(b: &mut Bencher) { + let bheap: BinaryHeap = (0..10_000).collect(); + + b.iter(|| bheap.clone().into_sorted_vec()) +} + +#[bench] +fn bench_push(b: &mut Bencher) { + let mut bheap = BinaryHeap::with_capacity(50_000); + let mut rng = thread_rng(); + let mut vec: Vec = (0..50_000).collect(); + vec.shuffle(&mut rng); + + b.iter(|| { + for &i in vec.iter() { + bheap.push(i); + } + black_box(&mut bheap); + bheap.clear(); + }) +} + +#[bench] +fn bench_pop(b: &mut Bencher) { + let mut bheap = BinaryHeap::with_capacity(10_000); + + b.iter(|| { + bheap.extend((0..10_000).rev()); + black_box(&mut bheap); + while let Some(elem) = bheap.pop() { + black_box(elem); + } + }) +} diff --git a/libgrust/rustc-lib/alloc/benches/btree/map.rs b/libgrust/rustc-lib/alloc/benches/btree/map.rs new file mode 100644 index 000000000000..7c2e5694a62f --- /dev/null +++ b/libgrust/rustc-lib/alloc/benches/btree/map.rs @@ -0,0 +1,586 @@ +use std::collections::BTreeMap; +use std::iter::Iterator; +use std::ops::RangeBounds; +use std::vec::Vec; + +use rand::{seq::SliceRandom, thread_rng, Rng}; +use test::{black_box, Bencher}; + +macro_rules! map_insert_rand_bench { + ($name: ident, $n: expr, $map: ident) => { + #[bench] + pub fn $name(b: &mut Bencher) { + let n: usize = $n; + let mut map = $map::new(); + // setup + let mut rng = thread_rng(); + + for _ in 0..n { + let i = rng.gen::() % n; + map.insert(i, i); + } + + // measure + b.iter(|| { + let k = rng.gen::() % n; + map.insert(k, k); + map.remove(&k); + }); + black_box(map); + } + }; +} + +macro_rules! map_insert_seq_bench { + ($name: ident, $n: expr, $map: ident) => { + #[bench] + pub fn $name(b: &mut Bencher) { + let mut map = $map::new(); + let n: usize = $n; + // setup + for i in 0..n { + map.insert(i * 2, i * 2); + } + + // measure + let mut i = 1; + b.iter(|| { + map.insert(i, i); + map.remove(&i); + i = (i + 2) % n; + }); + black_box(map); + } + }; +} + +macro_rules! map_find_rand_bench { + ($name: ident, $n: expr, $map: ident) => { + #[bench] + pub fn $name(b: &mut Bencher) { + let mut map = $map::new(); + let n: usize = $n; + + // setup + let mut rng = thread_rng(); + let mut keys: Vec<_> = (0..n).map(|_| rng.gen::() % n).collect(); + + for &k in &keys { + map.insert(k, k); + } + + keys.shuffle(&mut rng); + + // measure + let mut i = 0; + b.iter(|| { + let t = map.get(&keys[i]); + i = (i + 1) % n; + black_box(t); + }) + } + }; +} + +macro_rules! map_find_seq_bench { + ($name: ident, $n: expr, $map: ident) => { + #[bench] + pub fn $name(b: &mut Bencher) { + let mut map = $map::new(); + let n: usize = $n; + + // setup + for i in 0..n { + map.insert(i, i); + } + + // measure + let mut i = 0; + b.iter(|| { + let x = map.get(&i); + i = (i + 1) % n; + black_box(x); + }) + } + }; +} + +map_insert_rand_bench! {insert_rand_100, 100, BTreeMap} +map_insert_rand_bench! {insert_rand_10_000, 10_000, BTreeMap} + +map_insert_seq_bench! {insert_seq_100, 100, BTreeMap} +map_insert_seq_bench! {insert_seq_10_000, 10_000, BTreeMap} + +map_find_rand_bench! {find_rand_100, 100, BTreeMap} +map_find_rand_bench! {find_rand_10_000, 10_000, BTreeMap} + +map_find_seq_bench! {find_seq_100, 100, BTreeMap} +map_find_seq_bench! {find_seq_10_000, 10_000, BTreeMap} + +fn bench_iteration(b: &mut Bencher, size: i32) { + let mut map = BTreeMap::::new(); + let mut rng = thread_rng(); + + for _ in 0..size { + map.insert(rng.gen(), rng.gen()); + } + + b.iter(|| { + for entry in &map { + black_box(entry); + } + }); +} + +#[bench] +pub fn iteration_20(b: &mut Bencher) { + bench_iteration(b, 20); +} + +#[bench] +pub fn iteration_1000(b: &mut Bencher) { + bench_iteration(b, 1000); +} + +#[bench] +pub fn iteration_100000(b: &mut Bencher) { + bench_iteration(b, 100000); +} + +fn bench_iteration_mut(b: &mut Bencher, size: i32) { + let mut map = BTreeMap::::new(); + let mut rng = thread_rng(); + + for _ in 0..size { + map.insert(rng.gen(), rng.gen()); + } + + b.iter(|| { + for kv in map.iter_mut() { + black_box(kv); + } + }); +} + +#[bench] +pub fn iteration_mut_20(b: &mut Bencher) { + bench_iteration_mut(b, 20); +} + +#[bench] +pub fn iteration_mut_1000(b: &mut Bencher) { + bench_iteration_mut(b, 1000); +} + +#[bench] +pub fn iteration_mut_100000(b: &mut Bencher) { + bench_iteration_mut(b, 100000); +} + +fn bench_first_and_last(b: &mut Bencher, size: i32) { + let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); + b.iter(|| { + for _ in 0..10 { + black_box(map.first_key_value()); + black_box(map.last_key_value()); + } + }); +} + +#[bench] +pub fn first_and_last_0(b: &mut Bencher) { + bench_first_and_last(b, 0); +} + +#[bench] +pub fn first_and_last_100(b: &mut Bencher) { + bench_first_and_last(b, 100); +} + +#[bench] +pub fn first_and_last_10k(b: &mut Bencher) { + bench_first_and_last(b, 10_000); +} + +const BENCH_RANGE_SIZE: i32 = 145; +const BENCH_RANGE_COUNT: i32 = BENCH_RANGE_SIZE * (BENCH_RANGE_SIZE - 1) / 2; + +fn bench_range(b: &mut Bencher, f: F) +where + F: Fn(i32, i32) -> R, + R: RangeBounds, +{ + let map: BTreeMap<_, _> = (0..BENCH_RANGE_SIZE).map(|i| (i, i)).collect(); + b.iter(|| { + let mut c = 0; + for i in 0..BENCH_RANGE_SIZE { + for j in i + 1..BENCH_RANGE_SIZE { + black_box(map.range(f(i, j))); + c += 1; + } + } + debug_assert_eq!(c, BENCH_RANGE_COUNT); + }); +} + +#[bench] +pub fn range_included_excluded(b: &mut Bencher) { + bench_range(b, |i, j| i..j); +} + +#[bench] +pub fn range_included_included(b: &mut Bencher) { + bench_range(b, |i, j| i..=j); +} + +#[bench] +pub fn range_included_unbounded(b: &mut Bencher) { + bench_range(b, |i, _| i..); +} + +#[bench] +pub fn range_unbounded_unbounded(b: &mut Bencher) { + bench_range(b, |_, _| ..); +} + +fn bench_iter(b: &mut Bencher, repeats: i32, size: i32) { + let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); + b.iter(|| { + for _ in 0..repeats { + black_box(map.iter()); + } + }); +} + +/// Contrast range_unbounded_unbounded with `iter()`. +#[bench] +pub fn range_unbounded_vs_iter(b: &mut Bencher) { + bench_iter(b, BENCH_RANGE_COUNT, BENCH_RANGE_SIZE); +} + +#[bench] +pub fn iter_0(b: &mut Bencher) { + bench_iter(b, 1_000, 0); +} + +#[bench] +pub fn iter_1(b: &mut Bencher) { + bench_iter(b, 1_000, 1); +} + +#[bench] +pub fn iter_100(b: &mut Bencher) { + bench_iter(b, 1_000, 100); +} + +#[bench] +pub fn iter_10k(b: &mut Bencher) { + bench_iter(b, 1_000, 10_000); +} + +#[bench] +pub fn iter_1m(b: &mut Bencher) { + bench_iter(b, 1_000, 1_000_000); +} + +const FAT: usize = 256; + +// The returned map has small keys and values. +// Benchmarks on it have a counterpart in set.rs with the same keys and no values at all. +fn slim_map(n: usize) -> BTreeMap { + (0..n).map(|i| (i, i)).collect::>() +} + +// The returned map has small keys and large values. +fn fat_val_map(n: usize) -> BTreeMap { + (0..n).map(|i| (i, [i; FAT])).collect::>() +} + +// The returned map has large keys and values. +fn fat_map(n: usize) -> BTreeMap<[usize; FAT], [usize; FAT]> { + (0..n).map(|i| ([i; FAT], [i; FAT])).collect::>() +} + +#[bench] +pub fn clone_slim_100(b: &mut Bencher) { + let src = slim_map(100); + b.iter(|| src.clone()) +} + +#[bench] +pub fn clone_slim_100_and_clear(b: &mut Bencher) { + let src = slim_map(100); + b.iter(|| src.clone().clear()) +} + +#[bench] +pub fn clone_slim_100_and_drain_all(b: &mut Bencher) { + let src = slim_map(100); + b.iter(|| src.clone().drain_filter(|_, _| true).count()) +} + +#[bench] +pub fn clone_slim_100_and_drain_half(b: &mut Bencher) { + let src = slim_map(100); + b.iter(|| { + let mut map = src.clone(); + assert_eq!(map.drain_filter(|i, _| i % 2 == 0).count(), 100 / 2); + assert_eq!(map.len(), 100 / 2); + }) +} + +#[bench] +pub fn clone_slim_100_and_into_iter(b: &mut Bencher) { + let src = slim_map(100); + b.iter(|| src.clone().into_iter().count()) +} + +#[bench] +pub fn clone_slim_100_and_pop_all(b: &mut Bencher) { + let src = slim_map(100); + b.iter(|| { + let mut map = src.clone(); + while map.pop_first().is_some() {} + map + }); +} + +#[bench] +pub fn clone_slim_100_and_remove_all(b: &mut Bencher) { + let src = slim_map(100); + b.iter(|| { + let mut map = src.clone(); + while let Some(elt) = map.iter().map(|(&i, _)| i).next() { + let v = map.remove(&elt); + debug_assert!(v.is_some()); + } + map + }); +} + +#[bench] +pub fn clone_slim_100_and_remove_half(b: &mut Bencher) { + let src = slim_map(100); + b.iter(|| { + let mut map = src.clone(); + for i in (0..100).step_by(2) { + let v = map.remove(&i); + debug_assert!(v.is_some()); + } + assert_eq!(map.len(), 100 / 2); + map + }) +} + +#[bench] +pub fn clone_slim_10k(b: &mut Bencher) { + let src = slim_map(10_000); + b.iter(|| src.clone()) +} + +#[bench] +pub fn clone_slim_10k_and_clear(b: &mut Bencher) { + let src = slim_map(10_000); + b.iter(|| src.clone().clear()) +} + +#[bench] +pub fn clone_slim_10k_and_drain_all(b: &mut Bencher) { + let src = slim_map(10_000); + b.iter(|| src.clone().drain_filter(|_, _| true).count()) +} + +#[bench] +pub fn clone_slim_10k_and_drain_half(b: &mut Bencher) { + let src = slim_map(10_000); + b.iter(|| { + let mut map = src.clone(); + assert_eq!(map.drain_filter(|i, _| i % 2 == 0).count(), 10_000 / 2); + assert_eq!(map.len(), 10_000 / 2); + }) +} + +#[bench] +pub fn clone_slim_10k_and_into_iter(b: &mut Bencher) { + let src = slim_map(10_000); + b.iter(|| src.clone().into_iter().count()) +} + +#[bench] +pub fn clone_slim_10k_and_pop_all(b: &mut Bencher) { + let src = slim_map(10_000); + b.iter(|| { + let mut map = src.clone(); + while map.pop_first().is_some() {} + map + }); +} + +#[bench] +pub fn clone_slim_10k_and_remove_all(b: &mut Bencher) { + let src = slim_map(10_000); + b.iter(|| { + let mut map = src.clone(); + while let Some(elt) = map.iter().map(|(&i, _)| i).next() { + let v = map.remove(&elt); + debug_assert!(v.is_some()); + } + map + }); +} + +#[bench] +pub fn clone_slim_10k_and_remove_half(b: &mut Bencher) { + let src = slim_map(10_000); + b.iter(|| { + let mut map = src.clone(); + for i in (0..10_000).step_by(2) { + let v = map.remove(&i); + debug_assert!(v.is_some()); + } + assert_eq!(map.len(), 10_000 / 2); + map + }) +} + +#[bench] +pub fn clone_fat_val_100(b: &mut Bencher) { + let src = fat_val_map(100); + b.iter(|| src.clone()) +} + +#[bench] +pub fn clone_fat_val_100_and_clear(b: &mut Bencher) { + let src = fat_val_map(100); + b.iter(|| src.clone().clear()) +} + +#[bench] +pub fn clone_fat_val_100_and_drain_all(b: &mut Bencher) { + let src = fat_val_map(100); + b.iter(|| src.clone().drain_filter(|_, _| true).count()) +} + +#[bench] +pub fn clone_fat_val_100_and_drain_half(b: &mut Bencher) { + let src = fat_val_map(100); + b.iter(|| { + let mut map = src.clone(); + assert_eq!(map.drain_filter(|i, _| i % 2 == 0).count(), 100 / 2); + assert_eq!(map.len(), 100 / 2); + }) +} + +#[bench] +pub fn clone_fat_val_100_and_into_iter(b: &mut Bencher) { + let src = fat_val_map(100); + b.iter(|| src.clone().into_iter().count()) +} + +#[bench] +pub fn clone_fat_val_100_and_pop_all(b: &mut Bencher) { + let src = fat_val_map(100); + b.iter(|| { + let mut map = src.clone(); + while map.pop_first().is_some() {} + map + }); +} + +#[bench] +pub fn clone_fat_val_100_and_remove_all(b: &mut Bencher) { + let src = fat_val_map(100); + b.iter(|| { + let mut map = src.clone(); + while let Some(elt) = map.iter().map(|(&i, _)| i).next() { + let v = map.remove(&elt); + debug_assert!(v.is_some()); + } + map + }); +} + +#[bench] +pub fn clone_fat_val_100_and_remove_half(b: &mut Bencher) { + let src = fat_val_map(100); + b.iter(|| { + let mut map = src.clone(); + for i in (0..100).step_by(2) { + let v = map.remove(&i); + debug_assert!(v.is_some()); + } + assert_eq!(map.len(), 100 / 2); + map + }) +} + +#[bench] +pub fn clone_fat_100(b: &mut Bencher) { + let src = fat_map(100); + b.iter(|| src.clone()) +} + +#[bench] +pub fn clone_fat_100_and_clear(b: &mut Bencher) { + let src = fat_map(100); + b.iter(|| src.clone().clear()) +} + +#[bench] +pub fn clone_fat_100_and_drain_all(b: &mut Bencher) { + let src = fat_map(100); + b.iter(|| src.clone().drain_filter(|_, _| true).count()) +} + +#[bench] +pub fn clone_fat_100_and_drain_half(b: &mut Bencher) { + let src = fat_map(100); + b.iter(|| { + let mut map = src.clone(); + assert_eq!(map.drain_filter(|i, _| i[0] % 2 == 0).count(), 100 / 2); + assert_eq!(map.len(), 100 / 2); + }) +} + +#[bench] +pub fn clone_fat_100_and_into_iter(b: &mut Bencher) { + let src = fat_map(100); + b.iter(|| src.clone().into_iter().count()) +} + +#[bench] +pub fn clone_fat_100_and_pop_all(b: &mut Bencher) { + let src = fat_map(100); + b.iter(|| { + let mut map = src.clone(); + while map.pop_first().is_some() {} + map + }); +} + +#[bench] +pub fn clone_fat_100_and_remove_all(b: &mut Bencher) { + let src = fat_map(100); + b.iter(|| { + let mut map = src.clone(); + while let Some(elt) = map.iter().map(|(&i, _)| i).next() { + let v = map.remove(&elt); + debug_assert!(v.is_some()); + } + map + }); +} + +#[bench] +pub fn clone_fat_100_and_remove_half(b: &mut Bencher) { + let src = fat_map(100); + b.iter(|| { + let mut map = src.clone(); + for i in (0..100).step_by(2) { + let v = map.remove(&[i; FAT]); + debug_assert!(v.is_some()); + } + assert_eq!(map.len(), 100 / 2); + map + }) +} diff --git a/libgrust/rustc-lib/alloc/benches/btree/mod.rs b/libgrust/rustc-lib/alloc/benches/btree/mod.rs new file mode 100644 index 000000000000..095ca5dd2e21 --- /dev/null +++ b/libgrust/rustc-lib/alloc/benches/btree/mod.rs @@ -0,0 +1,2 @@ +mod map; +mod set; diff --git a/libgrust/rustc-lib/alloc/benches/btree/set.rs b/libgrust/rustc-lib/alloc/benches/btree/set.rs new file mode 100644 index 000000000000..07bf5093727c --- /dev/null +++ b/libgrust/rustc-lib/alloc/benches/btree/set.rs @@ -0,0 +1,224 @@ +use std::collections::BTreeSet; + +use rand::{thread_rng, Rng}; +use test::Bencher; + +fn random(n: usize) -> BTreeSet { + let mut rng = thread_rng(); + let mut set = BTreeSet::new(); + while set.len() < n { + set.insert(rng.gen()); + } + assert_eq!(set.len(), n); + set +} + +fn neg(n: usize) -> BTreeSet { + let set: BTreeSet = (-(n as i32)..=-1).collect(); + assert_eq!(set.len(), n); + set +} + +fn pos(n: usize) -> BTreeSet { + let set: BTreeSet = (1..=(n as i32)).collect(); + assert_eq!(set.len(), n); + set +} + +fn stagger(n1: usize, factor: usize) -> [BTreeSet; 2] { + let n2 = n1 * factor; + let mut sets = [BTreeSet::new(), BTreeSet::new()]; + for i in 0..(n1 + n2) { + let b = i % (factor + 1) != 0; + sets[b as usize].insert(i as u32); + } + assert_eq!(sets[0].len(), n1); + assert_eq!(sets[1].len(), n2); + sets +} + +macro_rules! set_bench { + ($name: ident, $set_func: ident, $result_func: ident, $sets: expr) => { + #[bench] + pub fn $name(b: &mut Bencher) { + // setup + let sets = $sets; + + // measure + b.iter(|| sets[0].$set_func(&sets[1]).$result_func()) + } + }; +} + +fn slim_set(n: usize) -> BTreeSet { + (0..n).collect::>() +} + +#[bench] +pub fn clone_100(b: &mut Bencher) { + let src = slim_set(100); + b.iter(|| src.clone()) +} + +#[bench] +pub fn clone_100_and_clear(b: &mut Bencher) { + let src = slim_set(100); + b.iter(|| src.clone().clear()) +} + +#[bench] +pub fn clone_100_and_drain_all(b: &mut Bencher) { + let src = slim_set(100); + b.iter(|| src.clone().drain_filter(|_| true).count()) +} + +#[bench] +pub fn clone_100_and_drain_half(b: &mut Bencher) { + let src = slim_set(100); + b.iter(|| { + let mut set = src.clone(); + assert_eq!(set.drain_filter(|i| i % 2 == 0).count(), 100 / 2); + assert_eq!(set.len(), 100 / 2); + }) +} + +#[bench] +pub fn clone_100_and_into_iter(b: &mut Bencher) { + let src = slim_set(100); + b.iter(|| src.clone().into_iter().count()) +} + +#[bench] +pub fn clone_100_and_pop_all(b: &mut Bencher) { + let src = slim_set(100); + b.iter(|| { + let mut set = src.clone(); + while set.pop_first().is_some() {} + set + }); +} + +#[bench] +pub fn clone_100_and_remove_all(b: &mut Bencher) { + let src = slim_set(100); + b.iter(|| { + let mut set = src.clone(); + while let Some(elt) = set.iter().copied().next() { + let ok = set.remove(&elt); + debug_assert!(ok); + } + set + }); +} + +#[bench] +pub fn clone_100_and_remove_half(b: &mut Bencher) { + let src = slim_set(100); + b.iter(|| { + let mut set = src.clone(); + for i in (0..100).step_by(2) { + let ok = set.remove(&i); + debug_assert!(ok); + } + assert_eq!(set.len(), 100 / 2); + set + }) +} + +#[bench] +pub fn clone_10k(b: &mut Bencher) { + let src = slim_set(10_000); + b.iter(|| src.clone()) +} + +#[bench] +pub fn clone_10k_and_clear(b: &mut Bencher) { + let src = slim_set(10_000); + b.iter(|| src.clone().clear()) +} + +#[bench] +pub fn clone_10k_and_drain_all(b: &mut Bencher) { + let src = slim_set(10_000); + b.iter(|| src.clone().drain_filter(|_| true).count()) +} + +#[bench] +pub fn clone_10k_and_drain_half(b: &mut Bencher) { + let src = slim_set(10_000); + b.iter(|| { + let mut set = src.clone(); + assert_eq!(set.drain_filter(|i| i % 2 == 0).count(), 10_000 / 2); + assert_eq!(set.len(), 10_000 / 2); + }) +} + +#[bench] +pub fn clone_10k_and_into_iter(b: &mut Bencher) { + let src = slim_set(10_000); + b.iter(|| src.clone().into_iter().count()) +} + +#[bench] +pub fn clone_10k_and_pop_all(b: &mut Bencher) { + let src = slim_set(10_000); + b.iter(|| { + let mut set = src.clone(); + while set.pop_first().is_some() {} + set + }); +} + +#[bench] +pub fn clone_10k_and_remove_all(b: &mut Bencher) { + let src = slim_set(10_000); + b.iter(|| { + let mut set = src.clone(); + while let Some(elt) = set.iter().copied().next() { + let ok = set.remove(&elt); + debug_assert!(ok); + } + set + }); +} + +#[bench] +pub fn clone_10k_and_remove_half(b: &mut Bencher) { + let src = slim_set(10_000); + b.iter(|| { + let mut set = src.clone(); + for i in (0..10_000).step_by(2) { + let ok = set.remove(&i); + debug_assert!(ok); + } + assert_eq!(set.len(), 10_000 / 2); + set + }) +} + +set_bench! {intersection_100_neg_vs_100_pos, intersection, count, [neg(100), pos(100)]} +set_bench! {intersection_100_neg_vs_10k_pos, intersection, count, [neg(100), pos(10_000)]} +set_bench! {intersection_100_pos_vs_100_neg, intersection, count, [pos(100), neg(100)]} +set_bench! {intersection_100_pos_vs_10k_neg, intersection, count, [pos(100), neg(10_000)]} +set_bench! {intersection_10k_neg_vs_100_pos, intersection, count, [neg(10_000), pos(100)]} +set_bench! {intersection_10k_neg_vs_10k_pos, intersection, count, [neg(10_000), pos(10_000)]} +set_bench! {intersection_10k_pos_vs_100_neg, intersection, count, [pos(10_000), neg(100)]} +set_bench! {intersection_10k_pos_vs_10k_neg, intersection, count, [pos(10_000), neg(10_000)]} +set_bench! {intersection_random_100_vs_100, intersection, count, [random(100), random(100)]} +set_bench! {intersection_random_100_vs_10k, intersection, count, [random(100), random(10_000)]} +set_bench! {intersection_random_10k_vs_100, intersection, count, [random(10_000), random(100)]} +set_bench! {intersection_random_10k_vs_10k, intersection, count, [random(10_000), random(10_000)]} +set_bench! {intersection_staggered_100_vs_100, intersection, count, stagger(100, 1)} +set_bench! {intersection_staggered_10k_vs_10k, intersection, count, stagger(10_000, 1)} +set_bench! {intersection_staggered_100_vs_10k, intersection, count, stagger(100, 100)} +set_bench! {difference_random_100_vs_100, difference, count, [random(100), random(100)]} +set_bench! {difference_random_100_vs_10k, difference, count, [random(100), random(10_000)]} +set_bench! {difference_random_10k_vs_100, difference, count, [random(10_000), random(100)]} +set_bench! {difference_random_10k_vs_10k, difference, count, [random(10_000), random(10_000)]} +set_bench! {difference_staggered_100_vs_100, difference, count, stagger(100, 1)} +set_bench! {difference_staggered_10k_vs_10k, difference, count, stagger(10_000, 1)} +set_bench! {difference_staggered_100_vs_10k, difference, count, stagger(100, 100)} +set_bench! {is_subset_100_vs_100, is_subset, clone, [pos(100), pos(100)]} +set_bench! {is_subset_100_vs_10k, is_subset, clone, [pos(100), pos(10_000)]} +set_bench! {is_subset_10k_vs_100, is_subset, clone, [pos(10_000), pos(100)]} +set_bench! {is_subset_10k_vs_10k, is_subset, clone, [pos(10_000), pos(10_000)]} diff --git a/libgrust/rustc-lib/alloc/benches/lib.rs b/libgrust/rustc-lib/alloc/benches/lib.rs new file mode 100644 index 000000000000..32edb86d1011 --- /dev/null +++ b/libgrust/rustc-lib/alloc/benches/lib.rs @@ -0,0 +1,18 @@ +// Disabling on android for the time being +// See https://github.com/rust-lang/rust/issues/73535#event-3477699747 +#![cfg(not(target_os = "android"))] +#![feature(btree_drain_filter)] +#![feature(map_first_last)] +#![feature(repr_simd)] +#![feature(test)] + +extern crate test; + +mod binary_heap; +mod btree; +mod linked_list; +mod slice; +mod str; +mod string; +mod vec; +mod vec_deque; diff --git a/libgrust/rustc-lib/alloc/benches/linked_list.rs b/libgrust/rustc-lib/alloc/benches/linked_list.rs new file mode 100644 index 000000000000..29c5ad2bc6eb --- /dev/null +++ b/libgrust/rustc-lib/alloc/benches/linked_list.rs @@ -0,0 +1,77 @@ +use std::collections::LinkedList; +use test::Bencher; + +#[bench] +fn bench_collect_into(b: &mut Bencher) { + let v = &[0; 64]; + b.iter(|| { + let _: LinkedList<_> = v.iter().cloned().collect(); + }) +} + +#[bench] +fn bench_push_front(b: &mut Bencher) { + let mut m: LinkedList<_> = LinkedList::new(); + b.iter(|| { + m.push_front(0); + }) +} + +#[bench] +fn bench_push_back(b: &mut Bencher) { + let mut m: LinkedList<_> = LinkedList::new(); + b.iter(|| { + m.push_back(0); + }) +} + +#[bench] +fn bench_push_back_pop_back(b: &mut Bencher) { + let mut m: LinkedList<_> = LinkedList::new(); + b.iter(|| { + m.push_back(0); + m.pop_back(); + }) +} + +#[bench] +fn bench_push_front_pop_front(b: &mut Bencher) { + let mut m: LinkedList<_> = LinkedList::new(); + b.iter(|| { + m.push_front(0); + m.pop_front(); + }) +} + +#[bench] +fn bench_iter(b: &mut Bencher) { + let v = &[0; 128]; + let m: LinkedList<_> = v.iter().cloned().collect(); + b.iter(|| { + assert!(m.iter().count() == 128); + }) +} +#[bench] +fn bench_iter_mut(b: &mut Bencher) { + let v = &[0; 128]; + let mut m: LinkedList<_> = v.iter().cloned().collect(); + b.iter(|| { + assert!(m.iter_mut().count() == 128); + }) +} +#[bench] +fn bench_iter_rev(b: &mut Bencher) { + let v = &[0; 128]; + let m: LinkedList<_> = v.iter().cloned().collect(); + b.iter(|| { + assert!(m.iter().rev().count() == 128); + }) +} +#[bench] +fn bench_iter_mut_rev(b: &mut Bencher) { + let v = &[0; 128]; + let mut m: LinkedList<_> = v.iter().cloned().collect(); + b.iter(|| { + assert!(m.iter_mut().rev().count() == 128); + }) +} diff --git a/libgrust/rustc-lib/alloc/benches/slice.rs b/libgrust/rustc-lib/alloc/benches/slice.rs new file mode 100644 index 000000000000..e20c043286e6 --- /dev/null +++ b/libgrust/rustc-lib/alloc/benches/slice.rs @@ -0,0 +1,382 @@ +use std::{mem, ptr}; + +use rand::distributions::{Alphanumeric, Standard}; +use rand::{thread_rng, Rng, SeedableRng}; +use rand_xorshift::XorShiftRng; +use test::{black_box, Bencher}; + +#[bench] +fn iterator(b: &mut Bencher) { + // peculiar numbers to stop LLVM from optimising the summation + // out. + let v: Vec<_> = (0..100).map(|i| i ^ (i << 1) ^ (i >> 1)).collect(); + + b.iter(|| { + let mut sum = 0; + for x in &v { + sum += *x; + } + // sum == 11806, to stop dead code elimination. + if sum == 0 { + panic!() + } + }) +} + +#[bench] +fn mut_iterator(b: &mut Bencher) { + let mut v = vec![0; 100]; + + b.iter(|| { + let mut i = 0; + for x in &mut v { + *x = i; + i += 1; + } + }) +} + +#[bench] +fn concat(b: &mut Bencher) { + let xss: Vec> = (0..100).map(|i| (0..i).collect()).collect(); + b.iter(|| { + xss.concat(); + }); +} + +#[bench] +fn join(b: &mut Bencher) { + let xss: Vec> = (0..100).map(|i| (0..i).collect()).collect(); + b.iter(|| xss.join(&0)); +} + +#[bench] +fn push(b: &mut Bencher) { + let mut vec = Vec::::new(); + b.iter(|| { + vec.push(0); + black_box(&vec); + }); +} + +#[bench] +fn starts_with_same_vector(b: &mut Bencher) { + let vec: Vec<_> = (0..100).collect(); + b.iter(|| vec.starts_with(&vec)) +} + +#[bench] +fn starts_with_single_element(b: &mut Bencher) { + let vec: Vec<_> = vec![0]; + b.iter(|| vec.starts_with(&vec)) +} + +#[bench] +fn starts_with_diff_one_element_at_end(b: &mut Bencher) { + let vec: Vec<_> = (0..100).collect(); + let mut match_vec: Vec<_> = (0..99).collect(); + match_vec.push(0); + b.iter(|| vec.starts_with(&match_vec)) +} + +#[bench] +fn ends_with_same_vector(b: &mut Bencher) { + let vec: Vec<_> = (0..100).collect(); + b.iter(|| vec.ends_with(&vec)) +} + +#[bench] +fn ends_with_single_element(b: &mut Bencher) { + let vec: Vec<_> = vec![0]; + b.iter(|| vec.ends_with(&vec)) +} + +#[bench] +fn ends_with_diff_one_element_at_beginning(b: &mut Bencher) { + let vec: Vec<_> = (0..100).collect(); + let mut match_vec: Vec<_> = (0..100).collect(); + match_vec[0] = 200; + b.iter(|| vec.starts_with(&match_vec)) +} + +#[bench] +fn contains_last_element(b: &mut Bencher) { + let vec: Vec<_> = (0..100).collect(); + b.iter(|| vec.contains(&99)) +} + +#[bench] +fn zero_1kb_from_elem(b: &mut Bencher) { + b.iter(|| vec![0u8; 1024]); +} + +#[bench] +fn zero_1kb_set_memory(b: &mut Bencher) { + b.iter(|| { + let mut v = Vec::::with_capacity(1024); + unsafe { + let vp = v.as_mut_ptr(); + ptr::write_bytes(vp, 0, 1024); + v.set_len(1024); + } + v + }); +} + +#[bench] +fn zero_1kb_loop_set(b: &mut Bencher) { + b.iter(|| { + let mut v = Vec::::with_capacity(1024); + unsafe { + v.set_len(1024); + } + for i in 0..1024 { + v[i] = 0; + } + }); +} + +#[bench] +fn zero_1kb_mut_iter(b: &mut Bencher) { + b.iter(|| { + let mut v = Vec::::with_capacity(1024); + unsafe { + v.set_len(1024); + } + for x in &mut v { + *x = 0; + } + v + }); +} + +#[bench] +fn random_inserts(b: &mut Bencher) { + let mut rng = thread_rng(); + b.iter(|| { + let mut v = vec![(0, 0); 30]; + for _ in 0..100 { + let l = v.len(); + v.insert(rng.gen::() % (l + 1), (1, 1)); + } + }) +} + +#[bench] +fn random_removes(b: &mut Bencher) { + let mut rng = thread_rng(); + b.iter(|| { + let mut v = vec![(0, 0); 130]; + for _ in 0..100 { + let l = v.len(); + v.remove(rng.gen::() % l); + } + }) +} + +fn gen_ascending(len: usize) -> Vec { + (0..len as u64).collect() +} + +fn gen_descending(len: usize) -> Vec { + (0..len as u64).rev().collect() +} + +const SEED: [u8; 16] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]; + +fn gen_random(len: usize) -> Vec { + let mut rng = XorShiftRng::from_seed(SEED); + (&mut rng).sample_iter(&Standard).take(len).collect() +} + +fn gen_random_bytes(len: usize) -> Vec { + let mut rng = XorShiftRng::from_seed(SEED); + (&mut rng).sample_iter(&Standard).take(len).collect() +} + +fn gen_mostly_ascending(len: usize) -> Vec { + let mut rng = XorShiftRng::from_seed(SEED); + let mut v = gen_ascending(len); + for _ in (0usize..).take_while(|x| x * x <= len) { + let x = rng.gen::() % len; + let y = rng.gen::() % len; + v.swap(x, y); + } + v +} + +fn gen_mostly_descending(len: usize) -> Vec { + let mut rng = XorShiftRng::from_seed(SEED); + let mut v = gen_descending(len); + for _ in (0usize..).take_while(|x| x * x <= len) { + let x = rng.gen::() % len; + let y = rng.gen::() % len; + v.swap(x, y); + } + v +} + +fn gen_strings(len: usize) -> Vec { + let mut rng = XorShiftRng::from_seed(SEED); + let mut v = vec![]; + for _ in 0..len { + let n = rng.gen::() % 20 + 1; + v.push((&mut rng).sample_iter(&Alphanumeric).take(n).collect()); + } + v +} + +fn gen_big_random(len: usize) -> Vec<[u64; 16]> { + let mut rng = XorShiftRng::from_seed(SEED); + (&mut rng).sample_iter(&Standard).map(|x| [x; 16]).take(len).collect() +} + +macro_rules! sort { + ($f:ident, $name:ident, $gen:expr, $len:expr) => { + #[bench] + fn $name(b: &mut Bencher) { + let v = $gen($len); + b.iter(|| v.clone().$f()); + b.bytes = $len * mem::size_of_val(&$gen(1)[0]) as u64; + } + }; +} + +macro_rules! sort_strings { + ($f:ident, $name:ident, $gen:expr, $len:expr) => { + #[bench] + fn $name(b: &mut Bencher) { + let v = $gen($len); + let v = v.iter().map(|s| &**s).collect::>(); + b.iter(|| v.clone().$f()); + b.bytes = $len * mem::size_of::<&str>() as u64; + } + }; +} + +macro_rules! sort_expensive { + ($f:ident, $name:ident, $gen:expr, $len:expr) => { + #[bench] + fn $name(b: &mut Bencher) { + let v = $gen($len); + b.iter(|| { + let mut v = v.clone(); + let mut count = 0; + v.$f(|a: &u64, b: &u64| { + count += 1; + if count % 1_000_000_000 == 0 { + panic!("should not happen"); + } + (*a as f64).cos().partial_cmp(&(*b as f64).cos()).unwrap() + }); + black_box(count); + }); + b.bytes = $len * mem::size_of_val(&$gen(1)[0]) as u64; + } + }; +} + +macro_rules! sort_lexicographic { + ($f:ident, $name:ident, $gen:expr, $len:expr) => { + #[bench] + fn $name(b: &mut Bencher) { + let v = $gen($len); + b.iter(|| v.clone().$f(|x| x.to_string())); + b.bytes = $len * mem::size_of_val(&$gen(1)[0]) as u64; + } + }; +} + +sort!(sort, sort_small_ascending, gen_ascending, 10); +sort!(sort, sort_small_descending, gen_descending, 10); +sort!(sort, sort_small_random, gen_random, 10); +sort!(sort, sort_small_big, gen_big_random, 10); +sort!(sort, sort_medium_random, gen_random, 100); +sort!(sort, sort_large_ascending, gen_ascending, 10000); +sort!(sort, sort_large_descending, gen_descending, 10000); +sort!(sort, sort_large_mostly_ascending, gen_mostly_ascending, 10000); +sort!(sort, sort_large_mostly_descending, gen_mostly_descending, 10000); +sort!(sort, sort_large_random, gen_random, 10000); +sort!(sort, sort_large_big, gen_big_random, 10000); +sort_strings!(sort, sort_large_strings, gen_strings, 10000); +sort_expensive!(sort_by, sort_large_expensive, gen_random, 10000); + +sort!(sort_unstable, sort_unstable_small_ascending, gen_ascending, 10); +sort!(sort_unstable, sort_unstable_small_descending, gen_descending, 10); +sort!(sort_unstable, sort_unstable_small_random, gen_random, 10); +sort!(sort_unstable, sort_unstable_small_big, gen_big_random, 10); +sort!(sort_unstable, sort_unstable_medium_random, gen_random, 100); +sort!(sort_unstable, sort_unstable_large_ascending, gen_ascending, 10000); +sort!(sort_unstable, sort_unstable_large_descending, gen_descending, 10000); +sort!(sort_unstable, sort_unstable_large_mostly_ascending, gen_mostly_ascending, 10000); +sort!(sort_unstable, sort_unstable_large_mostly_descending, gen_mostly_descending, 10000); +sort!(sort_unstable, sort_unstable_large_random, gen_random, 10000); +sort!(sort_unstable, sort_unstable_large_big, gen_big_random, 10000); +sort_strings!(sort_unstable, sort_unstable_large_strings, gen_strings, 10000); +sort_expensive!(sort_unstable_by, sort_unstable_large_expensive, gen_random, 10000); + +sort_lexicographic!(sort_by_key, sort_by_key_lexicographic, gen_random, 10000); +sort_lexicographic!(sort_unstable_by_key, sort_unstable_by_key_lexicographic, gen_random, 10000); +sort_lexicographic!(sort_by_cached_key, sort_by_cached_key_lexicographic, gen_random, 10000); + +macro_rules! reverse { + ($name:ident, $ty:ty, $f:expr) => { + #[bench] + fn $name(b: &mut Bencher) { + // odd length and offset by 1 to be as unaligned as possible + let n = 0xFFFFF; + let mut v: Vec<_> = (0..1 + (n / mem::size_of::<$ty>() as u64)).map($f).collect(); + b.iter(|| black_box(&mut v[1..]).reverse()); + b.bytes = n; + } + }; +} + +reverse!(reverse_u8, u8, |x| x as u8); +reverse!(reverse_u16, u16, |x| x as u16); +reverse!(reverse_u8x3, [u8; 3], |x| [x as u8, (x >> 8) as u8, (x >> 16) as u8]); +reverse!(reverse_u32, u32, |x| x as u32); +reverse!(reverse_u64, u64, |x| x as u64); +reverse!(reverse_u128, u128, |x| x as u128); +#[repr(simd)] +struct F64x4(f64, f64, f64, f64); +reverse!(reverse_simd_f64x4, F64x4, |x| { + let x = x as f64; + F64x4(x, x, x, x) +}); + +macro_rules! rotate { + ($name:ident, $gen:expr, $len:expr, $mid:expr) => { + #[bench] + fn $name(b: &mut Bencher) { + let size = mem::size_of_val(&$gen(1)[0]); + let mut v = $gen($len * 8 / size); + b.iter(|| black_box(&mut v).rotate_left(($mid * 8 + size - 1) / size)); + b.bytes = (v.len() * size) as u64; + } + }; +} + +rotate!(rotate_tiny_by1, gen_random, 16, 1); +rotate!(rotate_tiny_half, gen_random, 16, 16 / 2); +rotate!(rotate_tiny_half_plus_one, gen_random, 16, 16 / 2 + 1); + +rotate!(rotate_medium_by1, gen_random, 9158, 1); +rotate!(rotate_medium_by727_u64, gen_random, 9158, 727); +rotate!(rotate_medium_by727_bytes, gen_random_bytes, 9158, 727); +rotate!(rotate_medium_by727_strings, gen_strings, 9158, 727); +rotate!(rotate_medium_half, gen_random, 9158, 9158 / 2); +rotate!(rotate_medium_half_plus_one, gen_random, 9158, 9158 / 2 + 1); + +// Intended to use more RAM than the machine has cache +rotate!(rotate_huge_by1, gen_random, 5 * 1024 * 1024, 1); +rotate!(rotate_huge_by9199_u64, gen_random, 5 * 1024 * 1024, 9199); +rotate!(rotate_huge_by9199_bytes, gen_random_bytes, 5 * 1024 * 1024, 9199); +rotate!(rotate_huge_by9199_strings, gen_strings, 5 * 1024 * 1024, 9199); +rotate!(rotate_huge_by9199_big, gen_big_random, 5 * 1024 * 1024, 9199); +rotate!(rotate_huge_by1234577_u64, gen_random, 5 * 1024 * 1024, 1234577); +rotate!(rotate_huge_by1234577_bytes, gen_random_bytes, 5 * 1024 * 1024, 1234577); +rotate!(rotate_huge_by1234577_strings, gen_strings, 5 * 1024 * 1024, 1234577); +rotate!(rotate_huge_by1234577_big, gen_big_random, 5 * 1024 * 1024, 1234577); +rotate!(rotate_huge_half, gen_random, 5 * 1024 * 1024, 5 * 1024 * 1024 / 2); +rotate!(rotate_huge_half_plus_one, gen_random, 5 * 1024 * 1024, 5 * 1024 * 1024 / 2 + 1); diff --git a/libgrust/rustc-lib/alloc/benches/str.rs b/libgrust/rustc-lib/alloc/benches/str.rs new file mode 100644 index 000000000000..391475bc0c75 --- /dev/null +++ b/libgrust/rustc-lib/alloc/benches/str.rs @@ -0,0 +1,299 @@ +use test::{black_box, Bencher}; + +#[bench] +fn char_iterator(b: &mut Bencher) { + let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb"; + + b.iter(|| s.chars().count()); +} + +#[bench] +fn char_iterator_for(b: &mut Bencher) { + let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb"; + + b.iter(|| { + for ch in s.chars() { + black_box(ch); + } + }); +} + +#[bench] +fn char_iterator_ascii(b: &mut Bencher) { + let s = "Mary had a little lamb, Little lamb + Mary had a little lamb, Little lamb + Mary had a little lamb, Little lamb + Mary had a little lamb, Little lamb + Mary had a little lamb, Little lamb + Mary had a little lamb, Little lamb"; + + b.iter(|| s.chars().count()); +} + +#[bench] +fn char_iterator_rev(b: &mut Bencher) { + let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb"; + + b.iter(|| s.chars().rev().count()); +} + +#[bench] +fn char_iterator_rev_for(b: &mut Bencher) { + let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb"; + + b.iter(|| { + for ch in s.chars().rev() { + black_box(ch); + } + }); +} + +#[bench] +fn char_indicesator(b: &mut Bencher) { + let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb"; + let len = s.chars().count(); + + b.iter(|| assert_eq!(s.char_indices().count(), len)); +} + +#[bench] +fn char_indicesator_rev(b: &mut Bencher) { + let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb"; + let len = s.chars().count(); + + b.iter(|| assert_eq!(s.char_indices().rev().count(), len)); +} + +#[bench] +fn split_unicode_ascii(b: &mut Bencher) { + let s = "ประเทศไทย中华Việt Namประเทศไทย中华Việt Nam"; + + b.iter(|| assert_eq!(s.split('V').count(), 3)); +} + +#[bench] +fn split_ascii(b: &mut Bencher) { + let s = "Mary had a little lamb, Little lamb, little-lamb."; + let len = s.split(' ').count(); + + b.iter(|| assert_eq!(s.split(' ').count(), len)); +} + +#[bench] +fn split_extern_fn(b: &mut Bencher) { + let s = "Mary had a little lamb, Little lamb, little-lamb."; + let len = s.split(' ').count(); + fn pred(c: char) -> bool { + c == ' ' + } + + b.iter(|| assert_eq!(s.split(pred).count(), len)); +} + +#[bench] +fn split_closure(b: &mut Bencher) { + let s = "Mary had a little lamb, Little lamb, little-lamb."; + let len = s.split(' ').count(); + + b.iter(|| assert_eq!(s.split(|c: char| c == ' ').count(), len)); +} + +#[bench] +fn split_slice(b: &mut Bencher) { + let s = "Mary had a little lamb, Little lamb, little-lamb."; + let len = s.split(' ').count(); + + let c: &[char] = &[' ']; + b.iter(|| assert_eq!(s.split(c).count(), len)); +} + +#[bench] +fn bench_join(b: &mut Bencher) { + let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb"; + let sep = "→"; + let v = vec![s, s, s, s, s, s, s, s, s, s]; + b.iter(|| { + assert_eq!(v.join(sep).len(), s.len() * 10 + sep.len() * 9); + }) +} + +#[bench] +fn bench_contains_short_short(b: &mut Bencher) { + let haystack = "Lorem ipsum dolor sit amet, consectetur adipiscing elit."; + let needle = "sit"; + + b.iter(|| { + assert!(haystack.contains(needle)); + }) +} + +#[bench] +fn bench_contains_short_long(b: &mut Bencher) { + let haystack = "\ +Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse quis lorem sit amet dolor \ +ultricies condimentum. Praesent iaculis purus elit, ac malesuada quam malesuada in. Duis sed orci \ +eros. Suspendisse sit amet magna mollis, mollis nunc luctus, imperdiet mi. Integer fringilla non \ +sem ut lacinia. Fusce varius tortor a risus porttitor hendrerit. Morbi mauris dui, ultricies nec \ +tempus vel, gravida nec quam. + +In est dui, tincidunt sed tempus interdum, adipiscing laoreet ante. Etiam tempor, tellus quis \ +sagittis interdum, nulla purus mattis sem, quis auctor erat odio ac tellus. In nec nunc sit amet \ +diam volutpat molestie at sed ipsum. Vestibulum laoreet consequat vulputate. Integer accumsan \ +lorem ac dignissim placerat. Suspendisse convallis faucibus lorem. Aliquam erat volutpat. In vel \ +eleifend felis. Sed suscipit nulla lorem, sed mollis est sollicitudin et. Nam fermentum egestas \ +interdum. Curabitur ut nisi justo. + +Sed sollicitudin ipsum tellus, ut condimentum leo eleifend nec. Cras ut velit ante. Phasellus nec \ +mollis odio. Mauris molestie erat in arcu mattis, at aliquet dolor vehicula. Quisque malesuada \ +lectus sit amet nisi pretium, a condimentum ipsum porta. Morbi at dapibus diam. Praesent egestas \ +est sed risus elementum, eu rutrum metus ultrices. Etiam fermentum consectetur magna, id rutrum \ +felis accumsan a. Aliquam ut pellentesque libero. Sed mi nulla, lobortis eu tortor id, suscipit \ +ultricies neque. Morbi iaculis sit amet risus at iaculis. Praesent eget ligula quis turpis \ +feugiat suscipit vel non arcu. Interdum et malesuada fames ac ante ipsum primis in faucibus. \ +Aliquam sit amet placerat lorem. + +Cras a lacus vel ante posuere elementum. Nunc est leo, bibendum ut facilisis vel, bibendum at \ +mauris. Nullam adipiscing diam vel odio ornare, luctus adipiscing mi luctus. Nulla facilisi. \ +Mauris adipiscing bibendum neque, quis adipiscing lectus tempus et. Sed feugiat erat et nisl \ +lobortis pharetra. Donec vitae erat enim. Nullam sit amet felis et quam lacinia tincidunt. Aliquam \ +suscipit dapibus urna. Sed volutpat urna in magna pulvinar volutpat. Phasellus nec tellus ac diam \ +cursus accumsan. + +Nam lectus enim, dapibus non nisi tempor, consectetur convallis massa. Maecenas eleifend dictum \ +feugiat. Etiam quis mauris vel risus luctus mattis a a nunc. Nullam orci quam, imperdiet id \ +vehicula in, porttitor ut nibh. Duis sagittis adipiscing nisl vitae congue. Donec mollis risus eu \ +leo suscipit, varius porttitor nulla porta. Pellentesque ut sem nec nisi euismod vehicula. Nulla \ +malesuada sollicitudin quam eu fermentum."; + let needle = "english"; + + b.iter(|| { + assert!(!haystack.contains(needle)); + }) +} + +#[bench] +fn bench_contains_bad_naive(b: &mut Bencher) { + let haystack = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; + let needle = "aaaaaaaab"; + + b.iter(|| { + assert!(!haystack.contains(needle)); + }) +} + +#[bench] +fn bench_contains_equal(b: &mut Bencher) { + let haystack = "Lorem ipsum dolor sit amet, consectetur adipiscing elit."; + let needle = "Lorem ipsum dolor sit amet, consectetur adipiscing elit."; + + b.iter(|| { + assert!(haystack.contains(needle)); + }) +} + +macro_rules! make_test_inner { + ($s:ident, $code:expr, $name:ident, $str:expr, $iters:expr) => { + #[bench] + fn $name(bencher: &mut Bencher) { + let mut $s = $str; + black_box(&mut $s); + bencher.iter(|| { + for _ in 0..$iters { + black_box($code); + } + }); + } + }; +} + +macro_rules! make_test { + ($name:ident, $s:ident, $code:expr) => { + make_test!($name, $s, $code, 1); + }; + ($name:ident, $s:ident, $code:expr, $iters:expr) => { + mod $name { + use test::Bencher; + use test::black_box; + + // Short strings: 65 bytes each + make_test_inner!($s, $code, short_ascii, + "Mary had a little lamb, Little lamb Mary had a littl lamb, lamb!", $iters); + make_test_inner!($s, $code, short_mixed, + "ศไทย中华Việt Nam; Mary had a little lamb, Little lam!", $iters); + make_test_inner!($s, $code, short_pile_of_poo, + "💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩!", $iters); + make_test_inner!($s, $code, long_lorem_ipsum,"\ +Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse quis lorem sit amet dolor \ +ultricies condimentum. Praesent iaculis purus elit, ac malesuada quam malesuada in. Duis sed orci \ +eros. Suspendisse sit amet magna mollis, mollis nunc luctus, imperdiet mi. Integer fringilla non \ +sem ut lacinia. Fusce varius tortor a risus porttitor hendrerit. Morbi mauris dui, ultricies nec \ +tempus vel, gravida nec quam. + +In est dui, tincidunt sed tempus interdum, adipiscing laoreet ante. Etiam tempor, tellus quis \ +sagittis interdum, nulla purus mattis sem, quis auctor erat odio ac tellus. In nec nunc sit amet \ +diam volutpat molestie at sed ipsum. Vestibulum laoreet consequat vulputate. Integer accumsan \ +lorem ac dignissim placerat. Suspendisse convallis faucibus lorem. Aliquam erat volutpat. In vel \ +eleifend felis. Sed suscipit nulla lorem, sed mollis est sollicitudin et. Nam fermentum egestas \ +interdum. Curabitur ut nisi justo. + +Sed sollicitudin ipsum tellus, ut condimentum leo eleifend nec. Cras ut velit ante. Phasellus nec \ +mollis odio. Mauris molestie erat in arcu mattis, at aliquet dolor vehicula. Quisque malesuada \ +lectus sit amet nisi pretium, a condimentum ipsum porta. Morbi at dapibus diam. Praesent egestas \ +est sed risus elementum, eu rutrum metus ultrices. Etiam fermentum consectetur magna, id rutrum \ +felis accumsan a. Aliquam ut pellentesque libero. Sed mi nulla, lobortis eu tortor id, suscipit \ +ultricies neque. Morbi iaculis sit amet risus at iaculis. Praesent eget ligula quis turpis \ +feugiat suscipit vel non arcu. Interdum et malesuada fames ac ante ipsum primis in faucibus. \ +Aliquam sit amet placerat lorem. + +Cras a lacus vel ante posuere elementum. Nunc est leo, bibendum ut facilisis vel, bibendum at \ +mauris. Nullam adipiscing diam vel odio ornare, luctus adipiscing mi luctus. Nulla facilisi. \ +Mauris adipiscing bibendum neque, quis adipiscing lectus tempus et. Sed feugiat erat et nisl \ +lobortis pharetra. Donec vitae erat enim. Nullam sit amet felis et quam lacinia tincidunt. Aliquam \ +suscipit dapibus urna. Sed volutpat urna in magna pulvinar volutpat. Phasellus nec tellus ac diam \ +cursus accumsan. + +Nam lectus enim, dapibus non nisi tempor, consectetur convallis massa. Maecenas eleifend dictum \ +feugiat. Etiam quis mauris vel risus luctus mattis a a nunc. Nullam orci quam, imperdiet id \ +vehicula in, porttitor ut nibh. Duis sagittis adipiscing nisl vitae congue. Donec mollis risus eu \ +leo suscipit, varius porttitor nulla porta. Pellentesque ut sem nec nisi euismod vehicula. Nulla \ +malesuada sollicitudin quam eu fermentum!", $iters); + } + } +} + +make_test!(chars_count, s, s.chars().count()); + +make_test!(contains_bang_str, s, s.contains("!")); +make_test!(contains_bang_char, s, s.contains('!')); + +make_test!(match_indices_a_str, s, s.match_indices("a").count()); + +make_test!(split_a_str, s, s.split("a").count()); + +make_test!(trim_ascii_char, s, { s.trim_matches(|c: char| c.is_ascii()) }); +make_test!(trim_start_ascii_char, s, { s.trim_start_matches(|c: char| c.is_ascii()) }); +make_test!(trim_end_ascii_char, s, { s.trim_end_matches(|c: char| c.is_ascii()) }); + +make_test!(find_underscore_char, s, s.find('_')); +make_test!(rfind_underscore_char, s, s.rfind('_')); +make_test!(find_underscore_str, s, s.find("_")); + +make_test!(find_zzz_char, s, s.find('\u{1F4A4}')); +make_test!(rfind_zzz_char, s, s.rfind('\u{1F4A4}')); +make_test!(find_zzz_str, s, s.find("\u{1F4A4}")); + +make_test!(starts_with_ascii_char, s, s.starts_with('/'), 1024); +make_test!(ends_with_ascii_char, s, s.ends_with('/'), 1024); +make_test!(starts_with_unichar, s, s.starts_with('\u{1F4A4}'), 1024); +make_test!(ends_with_unichar, s, s.ends_with('\u{1F4A4}'), 1024); +make_test!(starts_with_str, s, s.starts_with("💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩"), 1024); +make_test!(ends_with_str, s, s.ends_with("💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩"), 1024); + +make_test!(split_space_char, s, s.split(' ').count()); +make_test!(split_terminator_space_char, s, s.split_terminator(' ').count()); + +make_test!(splitn_space_char, s, s.splitn(10, ' ').count()); +make_test!(rsplitn_space_char, s, s.rsplitn(10, ' ').count()); + +make_test!(split_space_str, s, s.split(" ").count()); +make_test!(split_ad_str, s, s.split("ad").count()); diff --git a/libgrust/rustc-lib/alloc/benches/string.rs b/libgrust/rustc-lib/alloc/benches/string.rs new file mode 100644 index 000000000000..5c95160ba2d1 --- /dev/null +++ b/libgrust/rustc-lib/alloc/benches/string.rs @@ -0,0 +1,164 @@ +use std::iter::repeat; +use test::{black_box, Bencher}; + +#[bench] +fn bench_with_capacity(b: &mut Bencher) { + b.iter(|| String::with_capacity(100)); +} + +#[bench] +fn bench_push_str(b: &mut Bencher) { + let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb"; + b.iter(|| { + let mut r = String::new(); + r.push_str(s); + }); +} + +const REPETITIONS: u64 = 10_000; + +#[bench] +fn bench_push_str_one_byte(b: &mut Bencher) { + b.bytes = REPETITIONS; + b.iter(|| { + let mut r = String::new(); + for _ in 0..REPETITIONS { + r.push_str("a") + } + }); +} + +#[bench] +fn bench_push_char_one_byte(b: &mut Bencher) { + b.bytes = REPETITIONS; + b.iter(|| { + let mut r = String::new(); + for _ in 0..REPETITIONS { + r.push('a') + } + }); +} + +#[bench] +fn bench_push_char_two_bytes(b: &mut Bencher) { + b.bytes = REPETITIONS * 2; + b.iter(|| { + let mut r = String::new(); + for _ in 0..REPETITIONS { + r.push('â') + } + }); +} + +#[bench] +fn from_utf8_lossy_100_ascii(b: &mut Bencher) { + let s = b"Hello there, the quick brown fox jumped over the lazy dog! \ + Lorem ipsum dolor sit amet, consectetur. "; + + assert_eq!(100, s.len()); + b.iter(|| { + let _ = String::from_utf8_lossy(s); + }); +} + +#[bench] +fn from_utf8_lossy_100_multibyte(b: &mut Bencher) { + let s = "𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰".as_bytes(); + assert_eq!(100, s.len()); + b.iter(|| { + let _ = String::from_utf8_lossy(s); + }); +} + +#[bench] +fn from_utf8_lossy_invalid(b: &mut Bencher) { + let s = b"Hello\xC0\x80 There\xE6\x83 Goodbye"; + b.iter(|| { + let _ = String::from_utf8_lossy(s); + }); +} + +#[bench] +fn from_utf8_lossy_100_invalid(b: &mut Bencher) { + let s = repeat(0xf5).take(100).collect::>(); + b.iter(|| { + let _ = String::from_utf8_lossy(&s); + }); +} + +#[bench] +fn bench_exact_size_shrink_to_fit(b: &mut Bencher) { + let s = "Hello there, the quick brown fox jumped over the lazy dog! \ + Lorem ipsum dolor sit amet, consectetur. "; + // ensure our operation produces an exact-size string before we benchmark it + let mut r = String::with_capacity(s.len()); + r.push_str(s); + assert_eq!(r.len(), r.capacity()); + b.iter(|| { + let mut r = String::with_capacity(s.len()); + r.push_str(s); + r.shrink_to_fit(); + r + }); +} + +#[bench] +fn bench_from_str(b: &mut Bencher) { + let s = "Hello there, the quick brown fox jumped over the lazy dog! \ + Lorem ipsum dolor sit amet, consectetur. "; + b.iter(|| String::from(s)) +} + +#[bench] +fn bench_from(b: &mut Bencher) { + let s = "Hello there, the quick brown fox jumped over the lazy dog! \ + Lorem ipsum dolor sit amet, consectetur. "; + b.iter(|| String::from(s)) +} + +#[bench] +fn bench_to_string(b: &mut Bencher) { + let s = "Hello there, the quick brown fox jumped over the lazy dog! \ + Lorem ipsum dolor sit amet, consectetur. "; + b.iter(|| s.to_string()) +} + +#[bench] +fn bench_insert_char_short(b: &mut Bencher) { + let s = "Hello, World!"; + b.iter(|| { + let mut x = String::from(s); + black_box(&mut x).insert(6, black_box(' ')); + x + }) +} + +#[bench] +fn bench_insert_char_long(b: &mut Bencher) { + let s = "Hello, World!"; + b.iter(|| { + let mut x = String::from(s); + black_box(&mut x).insert(6, black_box('❤')); + x + }) +} + +#[bench] +fn bench_insert_str_short(b: &mut Bencher) { + let s = "Hello, World!"; + b.iter(|| { + let mut x = String::from(s); + black_box(&mut x).insert_str(6, black_box(" ")); + x + }) +} + +#[bench] +fn bench_insert_str_long(b: &mut Bencher) { + let s = "Hello, World!"; + b.iter(|| { + let mut x = String::from(s); + black_box(&mut x).insert_str(6, black_box(" rustic ")); + x + }) +} diff --git a/libgrust/rustc-lib/alloc/benches/vec.rs b/libgrust/rustc-lib/alloc/benches/vec.rs new file mode 100644 index 000000000000..89893b6209c0 --- /dev/null +++ b/libgrust/rustc-lib/alloc/benches/vec.rs @@ -0,0 +1,673 @@ +use rand::RngCore; +use std::iter::{repeat, FromIterator}; +use test::{black_box, Bencher}; + +#[bench] +fn bench_new(b: &mut Bencher) { + b.iter(|| { + let v: Vec = Vec::new(); + assert_eq!(v.len(), 0); + assert_eq!(v.capacity(), 0); + v + }) +} + +fn do_bench_with_capacity(b: &mut Bencher, src_len: usize) { + b.bytes = src_len as u64; + + b.iter(|| { + let v: Vec = Vec::with_capacity(src_len); + assert_eq!(v.len(), 0); + assert_eq!(v.capacity(), src_len); + v + }) +} + +#[bench] +fn bench_with_capacity_0000(b: &mut Bencher) { + do_bench_with_capacity(b, 0) +} + +#[bench] +fn bench_with_capacity_0010(b: &mut Bencher) { + do_bench_with_capacity(b, 10) +} + +#[bench] +fn bench_with_capacity_0100(b: &mut Bencher) { + do_bench_with_capacity(b, 100) +} + +#[bench] +fn bench_with_capacity_1000(b: &mut Bencher) { + do_bench_with_capacity(b, 1000) +} + +fn do_bench_from_fn(b: &mut Bencher, src_len: usize) { + b.bytes = src_len as u64; + + b.iter(|| { + let dst = (0..src_len).collect::>(); + assert_eq!(dst.len(), src_len); + assert!(dst.iter().enumerate().all(|(i, x)| i == *x)); + dst + }) +} + +#[bench] +fn bench_from_fn_0000(b: &mut Bencher) { + do_bench_from_fn(b, 0) +} + +#[bench] +fn bench_from_fn_0010(b: &mut Bencher) { + do_bench_from_fn(b, 10) +} + +#[bench] +fn bench_from_fn_0100(b: &mut Bencher) { + do_bench_from_fn(b, 100) +} + +#[bench] +fn bench_from_fn_1000(b: &mut Bencher) { + do_bench_from_fn(b, 1000) +} + +fn do_bench_from_elem(b: &mut Bencher, src_len: usize) { + b.bytes = src_len as u64; + + b.iter(|| { + let dst: Vec = repeat(5).take(src_len).collect(); + assert_eq!(dst.len(), src_len); + assert!(dst.iter().all(|x| *x == 5)); + dst + }) +} + +#[bench] +fn bench_from_elem_0000(b: &mut Bencher) { + do_bench_from_elem(b, 0) +} + +#[bench] +fn bench_from_elem_0010(b: &mut Bencher) { + do_bench_from_elem(b, 10) +} + +#[bench] +fn bench_from_elem_0100(b: &mut Bencher) { + do_bench_from_elem(b, 100) +} + +#[bench] +fn bench_from_elem_1000(b: &mut Bencher) { + do_bench_from_elem(b, 1000) +} + +fn do_bench_from_slice(b: &mut Bencher, src_len: usize) { + let src: Vec<_> = FromIterator::from_iter(0..src_len); + + b.bytes = src_len as u64; + + b.iter(|| { + let dst = src.clone()[..].to_vec(); + assert_eq!(dst.len(), src_len); + assert!(dst.iter().enumerate().all(|(i, x)| i == *x)); + dst + }); +} + +#[bench] +fn bench_from_slice_0000(b: &mut Bencher) { + do_bench_from_slice(b, 0) +} + +#[bench] +fn bench_from_slice_0010(b: &mut Bencher) { + do_bench_from_slice(b, 10) +} + +#[bench] +fn bench_from_slice_0100(b: &mut Bencher) { + do_bench_from_slice(b, 100) +} + +#[bench] +fn bench_from_slice_1000(b: &mut Bencher) { + do_bench_from_slice(b, 1000) +} + +fn do_bench_from_iter(b: &mut Bencher, src_len: usize) { + let src: Vec<_> = FromIterator::from_iter(0..src_len); + + b.bytes = src_len as u64; + + b.iter(|| { + let dst: Vec<_> = FromIterator::from_iter(src.clone()); + assert_eq!(dst.len(), src_len); + assert!(dst.iter().enumerate().all(|(i, x)| i == *x)); + dst + }); +} + +#[bench] +fn bench_from_iter_0000(b: &mut Bencher) { + do_bench_from_iter(b, 0) +} + +#[bench] +fn bench_from_iter_0010(b: &mut Bencher) { + do_bench_from_iter(b, 10) +} + +#[bench] +fn bench_from_iter_0100(b: &mut Bencher) { + do_bench_from_iter(b, 100) +} + +#[bench] +fn bench_from_iter_1000(b: &mut Bencher) { + do_bench_from_iter(b, 1000) +} + +fn do_bench_extend(b: &mut Bencher, dst_len: usize, src_len: usize) { + let dst: Vec<_> = FromIterator::from_iter(0..dst_len); + let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len); + + b.bytes = src_len as u64; + + b.iter(|| { + let mut dst = dst.clone(); + dst.extend(src.clone()); + assert_eq!(dst.len(), dst_len + src_len); + assert!(dst.iter().enumerate().all(|(i, x)| i == *x)); + dst + }); +} + +#[bench] +fn bench_extend_0000_0000(b: &mut Bencher) { + do_bench_extend(b, 0, 0) +} + +#[bench] +fn bench_extend_0000_0010(b: &mut Bencher) { + do_bench_extend(b, 0, 10) +} + +#[bench] +fn bench_extend_0000_0100(b: &mut Bencher) { + do_bench_extend(b, 0, 100) +} + +#[bench] +fn bench_extend_0000_1000(b: &mut Bencher) { + do_bench_extend(b, 0, 1000) +} + +#[bench] +fn bench_extend_0010_0010(b: &mut Bencher) { + do_bench_extend(b, 10, 10) +} + +#[bench] +fn bench_extend_0100_0100(b: &mut Bencher) { + do_bench_extend(b, 100, 100) +} + +#[bench] +fn bench_extend_1000_1000(b: &mut Bencher) { + do_bench_extend(b, 1000, 1000) +} + +fn do_bench_extend_from_slice(b: &mut Bencher, dst_len: usize, src_len: usize) { + let dst: Vec<_> = FromIterator::from_iter(0..dst_len); + let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len); + + b.bytes = src_len as u64; + + b.iter(|| { + let mut dst = dst.clone(); + dst.extend_from_slice(&src); + assert_eq!(dst.len(), dst_len + src_len); + assert!(dst.iter().enumerate().all(|(i, x)| i == *x)); + dst + }); +} + +#[bench] +fn bench_extend_recycle(b: &mut Bencher) { + let mut data = vec![0; 1000]; + + b.iter(|| { + let tmp = std::mem::take(&mut data); + let mut to_extend = black_box(Vec::new()); + to_extend.extend(tmp.into_iter()); + data = black_box(to_extend); + }); + + black_box(data); +} + +#[bench] +fn bench_extend_from_slice_0000_0000(b: &mut Bencher) { + do_bench_extend_from_slice(b, 0, 0) +} + +#[bench] +fn bench_extend_from_slice_0000_0010(b: &mut Bencher) { + do_bench_extend_from_slice(b, 0, 10) +} + +#[bench] +fn bench_extend_from_slice_0000_0100(b: &mut Bencher) { + do_bench_extend_from_slice(b, 0, 100) +} + +#[bench] +fn bench_extend_from_slice_0000_1000(b: &mut Bencher) { + do_bench_extend_from_slice(b, 0, 1000) +} + +#[bench] +fn bench_extend_from_slice_0010_0010(b: &mut Bencher) { + do_bench_extend_from_slice(b, 10, 10) +} + +#[bench] +fn bench_extend_from_slice_0100_0100(b: &mut Bencher) { + do_bench_extend_from_slice(b, 100, 100) +} + +#[bench] +fn bench_extend_from_slice_1000_1000(b: &mut Bencher) { + do_bench_extend_from_slice(b, 1000, 1000) +} + +fn do_bench_clone(b: &mut Bencher, src_len: usize) { + let src: Vec = FromIterator::from_iter(0..src_len); + + b.bytes = src_len as u64; + + b.iter(|| { + let dst = src.clone(); + assert_eq!(dst.len(), src_len); + assert!(dst.iter().enumerate().all(|(i, x)| i == *x)); + dst + }); +} + +#[bench] +fn bench_clone_0000(b: &mut Bencher) { + do_bench_clone(b, 0) +} + +#[bench] +fn bench_clone_0010(b: &mut Bencher) { + do_bench_clone(b, 10) +} + +#[bench] +fn bench_clone_0100(b: &mut Bencher) { + do_bench_clone(b, 100) +} + +#[bench] +fn bench_clone_1000(b: &mut Bencher) { + do_bench_clone(b, 1000) +} + +fn do_bench_clone_from(b: &mut Bencher, times: usize, dst_len: usize, src_len: usize) { + let dst: Vec<_> = FromIterator::from_iter(0..src_len); + let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len); + + b.bytes = (times * src_len) as u64; + + b.iter(|| { + let mut dst = dst.clone(); + + for _ in 0..times { + dst.clone_from(&src); + assert_eq!(dst.len(), src_len); + assert!(dst.iter().enumerate().all(|(i, x)| dst_len + i == *x)); + } + dst + }); +} + +#[bench] +fn bench_clone_from_01_0000_0000(b: &mut Bencher) { + do_bench_clone_from(b, 1, 0, 0) +} + +#[bench] +fn bench_clone_from_01_0000_0010(b: &mut Bencher) { + do_bench_clone_from(b, 1, 0, 10) +} + +#[bench] +fn bench_clone_from_01_0000_0100(b: &mut Bencher) { + do_bench_clone_from(b, 1, 0, 100) +} + +#[bench] +fn bench_clone_from_01_0000_1000(b: &mut Bencher) { + do_bench_clone_from(b, 1, 0, 1000) +} + +#[bench] +fn bench_clone_from_01_0010_0010(b: &mut Bencher) { + do_bench_clone_from(b, 1, 10, 10) +} + +#[bench] +fn bench_clone_from_01_0100_0100(b: &mut Bencher) { + do_bench_clone_from(b, 1, 100, 100) +} + +#[bench] +fn bench_clone_from_01_1000_1000(b: &mut Bencher) { + do_bench_clone_from(b, 1, 1000, 1000) +} + +#[bench] +fn bench_clone_from_01_0010_0100(b: &mut Bencher) { + do_bench_clone_from(b, 1, 10, 100) +} + +#[bench] +fn bench_clone_from_01_0100_1000(b: &mut Bencher) { + do_bench_clone_from(b, 1, 100, 1000) +} + +#[bench] +fn bench_clone_from_01_0010_0000(b: &mut Bencher) { + do_bench_clone_from(b, 1, 10, 0) +} + +#[bench] +fn bench_clone_from_01_0100_0010(b: &mut Bencher) { + do_bench_clone_from(b, 1, 100, 10) +} + +#[bench] +fn bench_clone_from_01_1000_0100(b: &mut Bencher) { + do_bench_clone_from(b, 1, 1000, 100) +} + +#[bench] +fn bench_clone_from_10_0000_0000(b: &mut Bencher) { + do_bench_clone_from(b, 10, 0, 0) +} + +#[bench] +fn bench_clone_from_10_0000_0010(b: &mut Bencher) { + do_bench_clone_from(b, 10, 0, 10) +} + +#[bench] +fn bench_clone_from_10_0000_0100(b: &mut Bencher) { + do_bench_clone_from(b, 10, 0, 100) +} + +#[bench] +fn bench_clone_from_10_0000_1000(b: &mut Bencher) { + do_bench_clone_from(b, 10, 0, 1000) +} + +#[bench] +fn bench_clone_from_10_0010_0010(b: &mut Bencher) { + do_bench_clone_from(b, 10, 10, 10) +} + +#[bench] +fn bench_clone_from_10_0100_0100(b: &mut Bencher) { + do_bench_clone_from(b, 10, 100, 100) +} + +#[bench] +fn bench_clone_from_10_1000_1000(b: &mut Bencher) { + do_bench_clone_from(b, 10, 1000, 1000) +} + +#[bench] +fn bench_clone_from_10_0010_0100(b: &mut Bencher) { + do_bench_clone_from(b, 10, 10, 100) +} + +#[bench] +fn bench_clone_from_10_0100_1000(b: &mut Bencher) { + do_bench_clone_from(b, 10, 100, 1000) +} + +#[bench] +fn bench_clone_from_10_0010_0000(b: &mut Bencher) { + do_bench_clone_from(b, 10, 10, 0) +} + +#[bench] +fn bench_clone_from_10_0100_0010(b: &mut Bencher) { + do_bench_clone_from(b, 10, 100, 10) +} + +#[bench] +fn bench_clone_from_10_1000_0100(b: &mut Bencher) { + do_bench_clone_from(b, 10, 1000, 100) +} + +macro_rules! bench_in_place { + ($($fname:ident, $type:ty, $count:expr, $init:expr);*) => { + $( + #[bench] + fn $fname(b: &mut Bencher) { + b.iter(|| { + let src: Vec<$type> = black_box(vec![$init; $count]); + let mut sink = src.into_iter() + .enumerate() + .map(|(idx, e)| idx as $type ^ e) + .collect::>(); + black_box(sink.as_mut_ptr()) + }); + } + )+ + }; +} + +bench_in_place![ + bench_in_place_xxu8_0010_i0, u8, 10, 0; + bench_in_place_xxu8_0100_i0, u8, 100, 0; + bench_in_place_xxu8_1000_i0, u8, 1000, 0; + bench_in_place_xxu8_0010_i1, u8, 10, 1; + bench_in_place_xxu8_0100_i1, u8, 100, 1; + bench_in_place_xxu8_1000_i1, u8, 1000, 1; + bench_in_place_xu32_0010_i0, u32, 10, 0; + bench_in_place_xu32_0100_i0, u32, 100, 0; + bench_in_place_xu32_1000_i0, u32, 1000, 0; + bench_in_place_xu32_0010_i1, u32, 10, 1; + bench_in_place_xu32_0100_i1, u32, 100, 1; + bench_in_place_xu32_1000_i1, u32, 1000, 1; + bench_in_place_u128_0010_i0, u128, 10, 0; + bench_in_place_u128_0100_i0, u128, 100, 0; + bench_in_place_u128_1000_i0, u128, 1000, 0; + bench_in_place_u128_0010_i1, u128, 10, 1; + bench_in_place_u128_0100_i1, u128, 100, 1; + bench_in_place_u128_1000_i1, u128, 1000, 1 +]; + +#[bench] +fn bench_in_place_recycle(b: &mut Bencher) { + let mut data = vec![0; 1000]; + + b.iter(|| { + let tmp = std::mem::take(&mut data); + data = black_box( + tmp.into_iter() + .enumerate() + .map(|(idx, e)| idx.wrapping_add(e)) + .fuse() + .peekable() + .collect::>(), + ); + }); +} + +#[bench] +fn bench_in_place_zip_recycle(b: &mut Bencher) { + let mut data = vec![0u8; 1000]; + let mut rng = rand::thread_rng(); + let mut subst = vec![0u8; 1000]; + rng.fill_bytes(&mut subst[..]); + + b.iter(|| { + let tmp = std::mem::take(&mut data); + let mangled = tmp + .into_iter() + .zip(subst.iter().copied()) + .enumerate() + .map(|(i, (d, s))| d.wrapping_add(i as u8) ^ s) + .collect::>(); + assert_eq!(mangled.len(), 1000); + data = black_box(mangled); + }); +} + +#[bench] +fn bench_in_place_zip_iter_mut(b: &mut Bencher) { + let mut data = vec![0u8; 256]; + let mut rng = rand::thread_rng(); + let mut subst = vec![0u8; 1000]; + rng.fill_bytes(&mut subst[..]); + + b.iter(|| { + data.iter_mut().enumerate().for_each(|(i, d)| { + *d = d.wrapping_add(i as u8) ^ subst[i]; + }); + }); + + black_box(data); +} + +#[derive(Clone)] +struct Droppable(usize); + +impl Drop for Droppable { + fn drop(&mut self) { + black_box(self); + } +} + +#[bench] +fn bench_in_place_collect_droppable(b: &mut Bencher) { + let v: Vec = std::iter::repeat_with(|| Droppable(0)).take(1000).collect(); + b.iter(|| { + v.clone() + .into_iter() + .skip(100) + .enumerate() + .map(|(i, e)| Droppable(i ^ e.0)) + .collect::>() + }) +} + +const LEN: usize = 16384; + +#[bench] +fn bench_chain_collect(b: &mut Bencher) { + let data = black_box([0; LEN]); + b.iter(|| data.iter().cloned().chain([1].iter().cloned()).collect::>()); +} + +#[bench] +fn bench_chain_chain_collect(b: &mut Bencher) { + let data = black_box([0; LEN]); + b.iter(|| { + data.iter() + .cloned() + .chain([1].iter().cloned()) + .chain([2].iter().cloned()) + .collect::>() + }); +} + +#[bench] +fn bench_nest_chain_chain_collect(b: &mut Bencher) { + let data = black_box([0; LEN]); + b.iter(|| { + data.iter().cloned().chain([1].iter().chain([2].iter()).cloned()).collect::>() + }); +} + +pub fn example_plain_slow(l: &[u32]) -> Vec { + let mut result = Vec::with_capacity(l.len()); + result.extend(l.iter().rev()); + result +} + +pub fn map_fast(l: &[(u32, u32)]) -> Vec { + let mut result = Vec::with_capacity(l.len()); + for i in 0..l.len() { + unsafe { + *result.get_unchecked_mut(i) = l[i].0; + result.set_len(i); + } + } + result +} + +#[bench] +fn bench_range_map_collect(b: &mut Bencher) { + b.iter(|| (0..LEN).map(|_| u32::default()).collect::>()); +} + +#[bench] +fn bench_chain_extend_ref(b: &mut Bencher) { + let data = black_box([0; LEN]); + b.iter(|| { + let mut v = Vec::::with_capacity(data.len() + 1); + v.extend(data.iter().chain([1].iter())); + v + }); +} + +#[bench] +fn bench_chain_extend_value(b: &mut Bencher) { + let data = black_box([0; LEN]); + b.iter(|| { + let mut v = Vec::::with_capacity(data.len() + 1); + v.extend(data.iter().cloned().chain(Some(1))); + v + }); +} + +#[bench] +fn bench_rev_1(b: &mut Bencher) { + let data = black_box([0; LEN]); + b.iter(|| { + let mut v = Vec::::new(); + v.extend(data.iter().rev()); + v + }); +} + +#[bench] +fn bench_rev_2(b: &mut Bencher) { + let data = black_box([0; LEN]); + b.iter(|| example_plain_slow(&data)); +} + +#[bench] +fn bench_map_regular(b: &mut Bencher) { + let data = black_box([(0, 0); LEN]); + b.iter(|| { + let mut v = Vec::::new(); + v.extend(data.iter().map(|t| t.1)); + v + }); +} + +#[bench] +fn bench_map_fast(b: &mut Bencher) { + let data = black_box([(0, 0); LEN]); + b.iter(|| map_fast(&data)); +} diff --git a/libgrust/rustc-lib/alloc/benches/vec_deque.rs b/libgrust/rustc-lib/alloc/benches/vec_deque.rs new file mode 100644 index 000000000000..bf2dffd1e931 --- /dev/null +++ b/libgrust/rustc-lib/alloc/benches/vec_deque.rs @@ -0,0 +1,54 @@ +use std::collections::VecDeque; +use test::{black_box, Bencher}; + +#[bench] +fn bench_new(b: &mut Bencher) { + b.iter(|| { + let ring: VecDeque = VecDeque::new(); + black_box(ring); + }) +} + +#[bench] +fn bench_grow_1025(b: &mut Bencher) { + b.iter(|| { + let mut deq = VecDeque::new(); + for i in 0..1025 { + deq.push_front(i); + } + black_box(deq); + }) +} + +#[bench] +fn bench_iter_1000(b: &mut Bencher) { + let ring: VecDeque<_> = (0..1000).collect(); + + b.iter(|| { + let mut sum = 0; + for &i in &ring { + sum += i; + } + black_box(sum); + }) +} + +#[bench] +fn bench_mut_iter_1000(b: &mut Bencher) { + let mut ring: VecDeque<_> = (0..1000).collect(); + + b.iter(|| { + let mut sum = 0; + for i in &mut ring { + sum += *i; + } + black_box(sum); + }) +} + +#[bench] +fn bench_try_fold(b: &mut Bencher) { + let ring: VecDeque<_> = (0..1000).collect(); + + b.iter(|| black_box(ring.iter().try_fold(0, |a, b| Some(a + b)))) +} diff --git a/libgrust/rustc-lib/alloc/benches/vec_deque_append.rs b/libgrust/rustc-lib/alloc/benches/vec_deque_append.rs new file mode 100644 index 000000000000..5825bdc355f2 --- /dev/null +++ b/libgrust/rustc-lib/alloc/benches/vec_deque_append.rs @@ -0,0 +1,34 @@ +use std::{collections::VecDeque, time::Instant}; + +const VECDEQUE_LEN: i32 = 100000; +const WARMUP_N: usize = 100; +const BENCH_N: usize = 1000; + +fn main() { + let a: VecDeque = (0..VECDEQUE_LEN).collect(); + let b: VecDeque = (0..VECDEQUE_LEN).collect(); + + for _ in 0..WARMUP_N { + let mut c = a.clone(); + let mut d = b.clone(); + c.append(&mut d); + } + + let mut durations = Vec::with_capacity(BENCH_N); + + for _ in 0..BENCH_N { + let mut c = a.clone(); + let mut d = b.clone(); + let before = Instant::now(); + c.append(&mut d); + let after = Instant::now(); + durations.push(after.duration_since(before)); + } + + let l = durations.len(); + durations.sort(); + + assert!(BENCH_N % 2 == 0); + let median = (durations[(l / 2) - 1] + durations[l / 2]) / 2; + println!("\ncustom-bench vec_deque_append {:?} ns/iter\n", median.as_nanos()); +} diff --git a/libgrust/rustc-lib/alloc/src/alloc.rs b/libgrust/rustc-lib/alloc/src/alloc.rs new file mode 100644 index 000000000000..0a4f88dedbb0 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/alloc.rs @@ -0,0 +1,411 @@ +//! Memory allocation APIs + +#![stable(feature = "alloc_module", since = "1.28.0")] + +#[cfg(not(test))] +use core::intrinsics; +use core::intrinsics::{min_align_of_val, size_of_val}; + +use core::ptr::Unique; +#[cfg(not(test))] +use core::ptr::{self, NonNull}; + +#[stable(feature = "alloc_module", since = "1.28.0")] +#[doc(inline)] +pub use core::alloc::*; + +#[cfg(test)] +mod tests; + +extern "Rust" { + // These are the magic symbols to call the global allocator. rustc generates + // them to call `__rg_alloc` etc. if there is a `#[global_allocator]` attribute + // (the code expanding that attribute macro generates those functions), or to call + // the default implementations in libstd (`__rdl_alloc` etc. in `library/std/src/alloc.rs`) + // otherwise. + #[rustc_allocator] + #[rustc_allocator_nounwind] + fn __rust_alloc(size: usize, align: usize) -> *mut u8; + #[rustc_allocator_nounwind] + fn __rust_dealloc(ptr: *mut u8, size: usize, align: usize); + #[rustc_allocator_nounwind] + fn __rust_realloc(ptr: *mut u8, old_size: usize, align: usize, new_size: usize) -> *mut u8; + #[rustc_allocator_nounwind] + fn __rust_alloc_zeroed(size: usize, align: usize) -> *mut u8; +} + +/// The global memory allocator. +/// +/// This type implements the [`AllocRef`] trait by forwarding calls +/// to the allocator registered with the `#[global_allocator]` attribute +/// if there is one, or the `std` crate’s default. +/// +/// Note: while this type is unstable, the functionality it provides can be +/// accessed through the [free functions in `alloc`](self#functions). +#[unstable(feature = "allocator_api", issue = "32838")] +#[derive(Copy, Clone, Default, Debug)] +#[cfg(not(test))] +pub struct Global; + +#[cfg(test)] +pub use std::alloc::Global; + +/// Allocate memory with the global allocator. +/// +/// This function forwards calls to the [`GlobalAlloc::alloc`] method +/// of the allocator registered with the `#[global_allocator]` attribute +/// if there is one, or the `std` crate’s default. +/// +/// This function is expected to be deprecated in favor of the `alloc` method +/// of the [`Global`] type when it and the [`AllocRef`] trait become stable. +/// +/// # Safety +/// +/// See [`GlobalAlloc::alloc`]. +/// +/// # Examples +/// +/// ``` +/// use std::alloc::{alloc, dealloc, Layout}; +/// +/// unsafe { +/// let layout = Layout::new::(); +/// let ptr = alloc(layout); +/// +/// *(ptr as *mut u16) = 42; +/// assert_eq!(*(ptr as *mut u16), 42); +/// +/// dealloc(ptr, layout); +/// } +/// ``` +#[stable(feature = "global_alloc", since = "1.28.0")] +#[inline] +pub unsafe fn alloc(layout: Layout) -> *mut u8 { + unsafe { __rust_alloc(layout.size(), layout.align()) } +} + +/// Deallocate memory with the global allocator. +/// +/// This function forwards calls to the [`GlobalAlloc::dealloc`] method +/// of the allocator registered with the `#[global_allocator]` attribute +/// if there is one, or the `std` crate’s default. +/// +/// This function is expected to be deprecated in favor of the `dealloc` method +/// of the [`Global`] type when it and the [`AllocRef`] trait become stable. +/// +/// # Safety +/// +/// See [`GlobalAlloc::dealloc`]. +#[stable(feature = "global_alloc", since = "1.28.0")] +#[inline] +pub unsafe fn dealloc(ptr: *mut u8, layout: Layout) { + unsafe { __rust_dealloc(ptr, layout.size(), layout.align()) } +} + +/// Reallocate memory with the global allocator. +/// +/// This function forwards calls to the [`GlobalAlloc::realloc`] method +/// of the allocator registered with the `#[global_allocator]` attribute +/// if there is one, or the `std` crate’s default. +/// +/// This function is expected to be deprecated in favor of the `realloc` method +/// of the [`Global`] type when it and the [`AllocRef`] trait become stable. +/// +/// # Safety +/// +/// See [`GlobalAlloc::realloc`]. +#[stable(feature = "global_alloc", since = "1.28.0")] +#[inline] +pub unsafe fn realloc(ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 { + unsafe { __rust_realloc(ptr, layout.size(), layout.align(), new_size) } +} + +/// Allocate zero-initialized memory with the global allocator. +/// +/// This function forwards calls to the [`GlobalAlloc::alloc_zeroed`] method +/// of the allocator registered with the `#[global_allocator]` attribute +/// if there is one, or the `std` crate’s default. +/// +/// This function is expected to be deprecated in favor of the `alloc_zeroed` method +/// of the [`Global`] type when it and the [`AllocRef`] trait become stable. +/// +/// # Safety +/// +/// See [`GlobalAlloc::alloc_zeroed`]. +/// +/// # Examples +/// +/// ``` +/// use std::alloc::{alloc_zeroed, dealloc, Layout}; +/// +/// unsafe { +/// let layout = Layout::new::(); +/// let ptr = alloc_zeroed(layout); +/// +/// assert_eq!(*(ptr as *mut u16), 0); +/// +/// dealloc(ptr, layout); +/// } +/// ``` +#[stable(feature = "global_alloc", since = "1.28.0")] +#[inline] +pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8 { + unsafe { __rust_alloc_zeroed(layout.size(), layout.align()) } +} + +#[cfg(not(test))] +impl Global { + #[inline] + fn alloc_impl(&self, layout: Layout, zeroed: bool) -> Result, AllocError> { + match layout.size() { + 0 => Ok(NonNull::slice_from_raw_parts(layout.dangling(), 0)), + // SAFETY: `layout` is non-zero in size, + size => unsafe { + let raw_ptr = if zeroed { alloc_zeroed(layout) } else { alloc(layout) }; + let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?; + Ok(NonNull::slice_from_raw_parts(ptr, size)) + }, + } + } + + // SAFETY: Same as `AllocRef::grow` + #[inline] + unsafe fn grow_impl( + &self, + ptr: NonNull, + old_layout: Layout, + new_layout: Layout, + zeroed: bool, + ) -> Result, AllocError> { + debug_assert!( + new_layout.size() >= old_layout.size(), + "`new_layout.size()` must be greater than or equal to `old_layout.size()`" + ); + + match old_layout.size() { + 0 => self.alloc_impl(new_layout, zeroed), + + // SAFETY: `new_size` is non-zero as `old_size` is greater than or equal to `new_size` + // as required by safety conditions. Other conditions must be upheld by the caller + old_size if old_layout.align() == new_layout.align() => unsafe { + let new_size = new_layout.size(); + + // `realloc` probably checks for `new_size >= old_layout.size()` or something similar. + intrinsics::assume(new_size >= old_layout.size()); + + let raw_ptr = realloc(ptr.as_ptr(), old_layout, new_size); + let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?; + if zeroed { + raw_ptr.add(old_size).write_bytes(0, new_size - old_size); + } + Ok(NonNull::slice_from_raw_parts(ptr, new_size)) + }, + + // SAFETY: because `new_layout.size()` must be greater than or equal to `old_size`, + // both the old and new memory allocation are valid for reads and writes for `old_size` + // bytes. Also, because the old allocation wasn't yet deallocated, it cannot overlap + // `new_ptr`. Thus, the call to `copy_nonoverlapping` is safe. The safety contract + // for `dealloc` must be upheld by the caller. + old_size => unsafe { + let new_ptr = self.alloc_impl(new_layout, zeroed)?; + ptr::copy_nonoverlapping(ptr.as_ptr(), new_ptr.as_mut_ptr(), old_size); + self.dealloc(ptr, old_layout); + Ok(new_ptr) + }, + } + } +} + +#[unstable(feature = "allocator_api", issue = "32838")] +#[cfg(not(test))] +unsafe impl AllocRef for Global { + #[inline] + fn alloc(&self, layout: Layout) -> Result, AllocError> { + self.alloc_impl(layout, false) + } + + #[inline] + fn alloc_zeroed(&self, layout: Layout) -> Result, AllocError> { + self.alloc_impl(layout, true) + } + + #[inline] + unsafe fn dealloc(&self, ptr: NonNull, layout: Layout) { + if layout.size() != 0 { + // SAFETY: `layout` is non-zero in size, + // other conditions must be upheld by the caller + unsafe { dealloc(ptr.as_ptr(), layout) } + } + } + + #[inline] + unsafe fn grow( + &self, + ptr: NonNull, + old_layout: Layout, + new_layout: Layout, + ) -> Result, AllocError> { + // SAFETY: all conditions must be upheld by the caller + unsafe { self.grow_impl(ptr, old_layout, new_layout, false) } + } + + #[inline] + unsafe fn grow_zeroed( + &self, + ptr: NonNull, + old_layout: Layout, + new_layout: Layout, + ) -> Result, AllocError> { + // SAFETY: all conditions must be upheld by the caller + unsafe { self.grow_impl(ptr, old_layout, new_layout, true) } + } + + #[inline] + unsafe fn shrink( + &self, + ptr: NonNull, + old_layout: Layout, + new_layout: Layout, + ) -> Result, AllocError> { + debug_assert!( + new_layout.size() <= old_layout.size(), + "`new_layout.size()` must be smaller than or equal to `old_layout.size()`" + ); + + match new_layout.size() { + // SAFETY: conditions must be upheld by the caller + 0 => unsafe { + self.dealloc(ptr, old_layout); + Ok(NonNull::slice_from_raw_parts(new_layout.dangling(), 0)) + }, + + // SAFETY: `new_size` is non-zero. Other conditions must be upheld by the caller + new_size if old_layout.align() == new_layout.align() => unsafe { + // `realloc` probably checks for `new_size <= old_layout.size()` or something similar. + intrinsics::assume(new_size <= old_layout.size()); + + let raw_ptr = realloc(ptr.as_ptr(), old_layout, new_size); + let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?; + Ok(NonNull::slice_from_raw_parts(ptr, new_size)) + }, + + // SAFETY: because `new_size` must be smaller than or equal to `old_layout.size()`, + // both the old and new memory allocation are valid for reads and writes for `new_size` + // bytes. Also, because the old allocation wasn't yet deallocated, it cannot overlap + // `new_ptr`. Thus, the call to `copy_nonoverlapping` is safe. The safety contract + // for `dealloc` must be upheld by the caller. + new_size => unsafe { + let new_ptr = self.alloc(new_layout)?; + ptr::copy_nonoverlapping(ptr.as_ptr(), new_ptr.as_mut_ptr(), new_size); + self.dealloc(ptr, old_layout); + Ok(new_ptr) + }, + } + } +} + +/// The allocator for unique pointers. +// This function must not unwind. If it does, MIR codegen will fail. +#[cfg(not(test))] +#[lang = "exchange_malloc"] +#[inline] +unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 { + let layout = unsafe { Layout::from_size_align_unchecked(size, align) }; + match Global.alloc(layout) { + Ok(ptr) => ptr.as_mut_ptr(), + Err(_) => handle_alloc_error(layout), + } +} + +#[cfg_attr(not(test), lang = "box_free")] +#[inline] +// This signature has to be the same as `Box`, otherwise an ICE will happen. +// When an additional parameter to `Box` is added (like `A: AllocRef`), this has to be added here as +// well. +// For example if `Box` is changed to `struct Box(Unique, A)`, +// this function has to be changed to `fn box_free(Unique, A)` as well. +pub(crate) unsafe fn box_free(ptr: Unique, alloc: A) { + unsafe { + let size = size_of_val(ptr.as_ref()); + let align = min_align_of_val(ptr.as_ref()); + let layout = Layout::from_size_align_unchecked(size, align); + alloc.dealloc(ptr.cast().into(), layout) + } +} + +// # Allocation error handler + +extern "Rust" { + // This is the magic symbol to call the global alloc error handler. rustc generates + // it to call `__rg_oom` if there is a `#[alloc_error_handler]`, or to call the + // default implementations below (`__rdl_oom`) otherwise. + #[rustc_allocator_nounwind] + fn __rust_alloc_error_handler(size: usize, align: usize) -> !; +} + +/// Abort on memory allocation error or failure. +/// +/// Callers of memory allocation APIs wishing to abort computation +/// in response to an allocation error are encouraged to call this function, +/// rather than directly invoking `panic!` or similar. +/// +/// The default behavior of this function is to print a message to standard error +/// and abort the process. +/// It can be replaced with [`set_alloc_error_hook`] and [`take_alloc_error_hook`]. +/// +/// [`set_alloc_error_hook`]: ../../std/alloc/fn.set_alloc_error_hook.html +/// [`take_alloc_error_hook`]: ../../std/alloc/fn.take_alloc_error_hook.html +#[stable(feature = "global_alloc", since = "1.28.0")] +#[cfg(not(any(test, bootstrap)))] +#[rustc_allocator_nounwind] +pub fn handle_alloc_error(layout: Layout) -> ! { + unsafe { + __rust_alloc_error_handler(layout.size(), layout.align()); + } +} + +// For alloc test `std::alloc::handle_alloc_error` can be used directly. +#[cfg(test)] +pub use std::alloc::handle_alloc_error; + +// In stage0 (bootstrap) `__rust_alloc_error_handler`, +// might not be generated yet, because an old compiler is used, +// so use the old direct call. +#[cfg(all(bootstrap, not(test)))] +#[stable(feature = "global_alloc", since = "1.28.0")] +#[doc(hidden)] +#[rustc_allocator_nounwind] +pub fn handle_alloc_error(layout: Layout) -> ! { + extern "Rust" { + #[lang = "oom"] + fn oom_impl(layout: Layout) -> !; + } + unsafe { oom_impl(layout) } +} + +#[cfg(not(any(target_os = "hermit", test, bootstrap)))] +#[doc(hidden)] +#[allow(unused_attributes)] +#[unstable(feature = "alloc_internals", issue = "none")] +pub mod __alloc_error_handler { + use crate::alloc::Layout; + + // called via generated `__rust_alloc_error_handler` + + // if there is no `#[alloc_error_handler]` + #[rustc_std_internal_symbol] + pub unsafe extern "C" fn __rdl_oom(size: usize, _align: usize) -> ! { + panic!("memory allocation of {} bytes failed", size) + } + + // if there is a `#[alloc_error_handler]` + #[rustc_std_internal_symbol] + pub unsafe extern "C" fn __rg_oom(size: usize, align: usize) -> ! { + let layout = unsafe { Layout::from_size_align_unchecked(size, align) }; + extern "Rust" { + #[lang = "oom"] + fn oom_impl(layout: Layout) -> !; + } + unsafe { oom_impl(layout) } + } +} diff --git a/libgrust/rustc-lib/alloc/src/alloc/tests.rs b/libgrust/rustc-lib/alloc/src/alloc/tests.rs new file mode 100644 index 000000000000..f7463d0daac9 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/alloc/tests.rs @@ -0,0 +1,30 @@ +use super::*; + +extern crate test; +use crate::boxed::Box; +use test::Bencher; + +#[test] +fn allocate_zeroed() { + unsafe { + let layout = Layout::from_size_align(1024, 1).unwrap(); + let ptr = + Global.alloc_zeroed(layout.clone()).unwrap_or_else(|_| handle_alloc_error(layout)); + + let mut i = ptr.as_non_null_ptr().as_ptr(); + let end = i.add(layout.size()); + while i < end { + assert_eq!(*i, 0); + i = i.offset(1); + } + Global.dealloc(ptr.as_non_null_ptr(), layout); + } +} + +#[bench] +#[cfg_attr(miri, ignore)] // isolated Miri does not support benchmarks +fn alloc_owned_small(b: &mut Bencher) { + b.iter(|| { + let _: Box<_> = box 10; + }) +} diff --git a/libgrust/rustc-lib/alloc/src/borrow.rs b/libgrust/rustc-lib/alloc/src/borrow.rs new file mode 100644 index 000000000000..f801c1ac75bc --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/borrow.rs @@ -0,0 +1,478 @@ +//! A module for working with borrowed data. + +#![stable(feature = "rust1", since = "1.0.0")] + +use core::cmp::Ordering; +use core::hash::{Hash, Hasher}; +use core::ops::{Add, AddAssign, Deref}; + +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::borrow::{Borrow, BorrowMut}; + +use crate::fmt; +use crate::string::String; + +use Cow::*; + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, B: ?Sized> Borrow for Cow<'a, B> +where + B: ToOwned, + ::Owned: 'a, +{ + fn borrow(&self) -> &B { + &**self + } +} + +/// A generalization of `Clone` to borrowed data. +/// +/// Some types make it possible to go from borrowed to owned, usually by +/// implementing the `Clone` trait. But `Clone` works only for going from `&T` +/// to `T`. The `ToOwned` trait generalizes `Clone` to construct owned data +/// from any borrow of a given type. +#[stable(feature = "rust1", since = "1.0.0")] +pub trait ToOwned { + /// The resulting type after obtaining ownership. + #[stable(feature = "rust1", since = "1.0.0")] + type Owned: Borrow; + + /// Creates owned data from borrowed data, usually by cloning. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s: &str = "a"; + /// let ss: String = s.to_owned(); + /// + /// let v: &[i32] = &[1, 2]; + /// let vv: Vec = v.to_owned(); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[must_use = "cloning is often expensive and is not expected to have side effects"] + fn to_owned(&self) -> Self::Owned; + + /// Uses borrowed data to replace owned data, usually by cloning. + /// + /// This is borrow-generalized version of `Clone::clone_from`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// # #![feature(toowned_clone_into)] + /// let mut s: String = String::new(); + /// "hello".clone_into(&mut s); + /// + /// let mut v: Vec = Vec::new(); + /// [1, 2][..].clone_into(&mut v); + /// ``` + #[unstable(feature = "toowned_clone_into", reason = "recently added", issue = "41263")] + fn clone_into(&self, target: &mut Self::Owned) { + *target = self.to_owned(); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ToOwned for T +where + T: Clone, +{ + type Owned = T; + fn to_owned(&self) -> T { + self.clone() + } + + fn clone_into(&self, target: &mut T) { + target.clone_from(self); + } +} + +/// A clone-on-write smart pointer. +/// +/// The type `Cow` is a smart pointer providing clone-on-write functionality: it +/// can enclose and provide immutable access to borrowed data, and clone the +/// data lazily when mutation or ownership is required. The type is designed to +/// work with general borrowed data via the `Borrow` trait. +/// +/// `Cow` implements `Deref`, which means that you can call +/// non-mutating methods directly on the data it encloses. If mutation +/// is desired, `to_mut` will obtain a mutable reference to an owned +/// value, cloning if necessary. +/// +/// # Examples +/// +/// ``` +/// use std::borrow::Cow; +/// +/// fn abs_all(input: &mut Cow<[i32]>) { +/// for i in 0..input.len() { +/// let v = input[i]; +/// if v < 0 { +/// // Clones into a vector if not already owned. +/// input.to_mut()[i] = -v; +/// } +/// } +/// } +/// +/// // No clone occurs because `input` doesn't need to be mutated. +/// let slice = [0, 1, 2]; +/// let mut input = Cow::from(&slice[..]); +/// abs_all(&mut input); +/// +/// // Clone occurs because `input` needs to be mutated. +/// let slice = [-1, 0, 1]; +/// let mut input = Cow::from(&slice[..]); +/// abs_all(&mut input); +/// +/// // No clone occurs because `input` is already owned. +/// let mut input = Cow::from(vec![-1, 0, 1]); +/// abs_all(&mut input); +/// ``` +/// +/// Another example showing how to keep `Cow` in a struct: +/// +/// ``` +/// use std::borrow::Cow; +/// +/// struct Items<'a, X: 'a> where [X]: ToOwned> { +/// values: Cow<'a, [X]>, +/// } +/// +/// impl<'a, X: Clone + 'a> Items<'a, X> where [X]: ToOwned> { +/// fn new(v: Cow<'a, [X]>) -> Self { +/// Items { values: v } +/// } +/// } +/// +/// // Creates a container from borrowed values of a slice +/// let readonly = [1, 2]; +/// let borrowed = Items::new((&readonly[..]).into()); +/// match borrowed { +/// Items { values: Cow::Borrowed(b) } => println!("borrowed {:?}", b), +/// _ => panic!("expect borrowed value"), +/// } +/// +/// let mut clone_on_write = borrowed; +/// // Mutates the data from slice into owned vec and pushes a new value on top +/// clone_on_write.values.to_mut().push(3); +/// println!("clone_on_write = {:?}", clone_on_write.values); +/// +/// // The data was mutated. Let check it out. +/// match clone_on_write { +/// Items { values: Cow::Owned(_) } => println!("clone_on_write contains owned data"), +/// _ => panic!("expect owned data"), +/// } +/// ``` +#[stable(feature = "rust1", since = "1.0.0")] +pub enum Cow<'a, B: ?Sized + 'a> +where + B: ToOwned, +{ + /// Borrowed data. + #[stable(feature = "rust1", since = "1.0.0")] + Borrowed(#[stable(feature = "rust1", since = "1.0.0")] &'a B), + + /// Owned data. + #[stable(feature = "rust1", since = "1.0.0")] + Owned(#[stable(feature = "rust1", since = "1.0.0")] ::Owned), +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Cow<'_, B> { + fn clone(&self) -> Self { + match *self { + Borrowed(b) => Borrowed(b), + Owned(ref o) => { + let b: &B = o.borrow(); + Owned(b.to_owned()) + } + } + } + + fn clone_from(&mut self, source: &Self) { + match (self, source) { + (&mut Owned(ref mut dest), &Owned(ref o)) => o.borrow().clone_into(dest), + (t, s) => *t = s.clone(), + } + } +} + +impl Cow<'_, B> { + /// Returns true if the data is borrowed, i.e. if `to_mut` would require additional work. + /// + /// # Examples + /// + /// ``` + /// #![feature(cow_is_borrowed)] + /// use std::borrow::Cow; + /// + /// let cow = Cow::Borrowed("moo"); + /// assert!(cow.is_borrowed()); + /// + /// let bull: Cow<'_, str> = Cow::Owned("...moo?".to_string()); + /// assert!(!bull.is_borrowed()); + /// ``` + #[unstable(feature = "cow_is_borrowed", issue = "65143")] + #[rustc_const_unstable(feature = "const_cow_is_borrowed", issue = "65143")] + pub const fn is_borrowed(&self) -> bool { + match *self { + Borrowed(_) => true, + Owned(_) => false, + } + } + + /// Returns true if the data is owned, i.e. if `to_mut` would be a no-op. + /// + /// # Examples + /// + /// ``` + /// #![feature(cow_is_borrowed)] + /// use std::borrow::Cow; + /// + /// let cow: Cow<'_, str> = Cow::Owned("moo".to_string()); + /// assert!(cow.is_owned()); + /// + /// let bull = Cow::Borrowed("...moo?"); + /// assert!(!bull.is_owned()); + /// ``` + #[unstable(feature = "cow_is_borrowed", issue = "65143")] + #[rustc_const_unstable(feature = "const_cow_is_borrowed", issue = "65143")] + pub const fn is_owned(&self) -> bool { + !self.is_borrowed() + } + + /// Acquires a mutable reference to the owned form of the data. + /// + /// Clones the data if it is not already owned. + /// + /// # Examples + /// + /// ``` + /// use std::borrow::Cow; + /// + /// let mut cow = Cow::Borrowed("foo"); + /// cow.to_mut().make_ascii_uppercase(); + /// + /// assert_eq!( + /// cow, + /// Cow::Owned(String::from("FOO")) as Cow + /// ); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn to_mut(&mut self) -> &mut ::Owned { + match *self { + Borrowed(borrowed) => { + *self = Owned(borrowed.to_owned()); + match *self { + Borrowed(..) => unreachable!(), + Owned(ref mut owned) => owned, + } + } + Owned(ref mut owned) => owned, + } + } + + /// Extracts the owned data. + /// + /// Clones the data if it is not already owned. + /// + /// # Examples + /// + /// Calling `into_owned` on a `Cow::Borrowed` clones the underlying data + /// and becomes a `Cow::Owned`: + /// + /// ``` + /// use std::borrow::Cow; + /// + /// let s = "Hello world!"; + /// let cow = Cow::Borrowed(s); + /// + /// assert_eq!( + /// cow.into_owned(), + /// String::from(s) + /// ); + /// ``` + /// + /// Calling `into_owned` on a `Cow::Owned` is a no-op: + /// + /// ``` + /// use std::borrow::Cow; + /// + /// let s = "Hello world!"; + /// let cow: Cow = Cow::Owned(String::from(s)); + /// + /// assert_eq!( + /// cow.into_owned(), + /// String::from(s) + /// ); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn into_owned(self) -> ::Owned { + match self { + Borrowed(borrowed) => borrowed.to_owned(), + Owned(owned) => owned, + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Deref for Cow<'_, B> { + type Target = B; + + fn deref(&self) -> &B { + match *self { + Borrowed(borrowed) => borrowed, + Owned(ref owned) => owned.borrow(), + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Eq for Cow<'_, B> where B: Eq + ToOwned {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Ord for Cow<'_, B> +where + B: Ord + ToOwned, +{ + #[inline] + fn cmp(&self, other: &Self) -> Ordering { + Ord::cmp(&**self, &**other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, 'b, B: ?Sized, C: ?Sized> PartialEq> for Cow<'a, B> +where + B: PartialEq + ToOwned, + C: ToOwned, +{ + #[inline] + fn eq(&self, other: &Cow<'b, C>) -> bool { + PartialEq::eq(&**self, &**other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, B: ?Sized> PartialOrd for Cow<'a, B> +where + B: PartialOrd + ToOwned, +{ + #[inline] + fn partial_cmp(&self, other: &Cow<'a, B>) -> Option { + PartialOrd::partial_cmp(&**self, &**other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Debug for Cow<'_, B> +where + B: fmt::Debug + ToOwned, +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match *self { + Borrowed(ref b) => fmt::Debug::fmt(b, f), + Owned(ref o) => fmt::Debug::fmt(o, f), + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Display for Cow<'_, B> +where + B: fmt::Display + ToOwned, +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match *self { + Borrowed(ref b) => fmt::Display::fmt(b, f), + Owned(ref o) => fmt::Display::fmt(o, f), + } + } +} + +#[stable(feature = "default", since = "1.11.0")] +impl Default for Cow<'_, B> +where + B: ToOwned, +{ + /// Creates an owned Cow<'a, B> with the default value for the contained owned value. + fn default() -> Self { + Owned(::Owned::default()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Hash for Cow<'_, B> +where + B: Hash + ToOwned, +{ + #[inline] + fn hash(&self, state: &mut H) { + Hash::hash(&**self, state) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl AsRef for Cow<'_, T> { + fn as_ref(&self) -> &T { + self + } +} + +#[stable(feature = "cow_add", since = "1.14.0")] +impl<'a> Add<&'a str> for Cow<'a, str> { + type Output = Cow<'a, str>; + + #[inline] + fn add(mut self, rhs: &'a str) -> Self::Output { + self += rhs; + self + } +} + +#[stable(feature = "cow_add", since = "1.14.0")] +impl<'a> Add> for Cow<'a, str> { + type Output = Cow<'a, str>; + + #[inline] + fn add(mut self, rhs: Cow<'a, str>) -> Self::Output { + self += rhs; + self + } +} + +#[stable(feature = "cow_add", since = "1.14.0")] +impl<'a> AddAssign<&'a str> for Cow<'a, str> { + fn add_assign(&mut self, rhs: &'a str) { + if self.is_empty() { + *self = Cow::Borrowed(rhs) + } else if !rhs.is_empty() { + if let Cow::Borrowed(lhs) = *self { + let mut s = String::with_capacity(lhs.len() + rhs.len()); + s.push_str(lhs); + *self = Cow::Owned(s); + } + self.to_mut().push_str(rhs); + } + } +} + +#[stable(feature = "cow_add", since = "1.14.0")] +impl<'a> AddAssign> for Cow<'a, str> { + fn add_assign(&mut self, rhs: Cow<'a, str>) { + if self.is_empty() { + *self = rhs + } else if !rhs.is_empty() { + if let Cow::Borrowed(lhs) = *self { + let mut s = String::with_capacity(lhs.len() + rhs.len()); + s.push_str(lhs); + *self = Cow::Owned(s); + } + self.to_mut().push_str(&rhs); + } + } +} diff --git a/libgrust/rustc-lib/alloc/src/boxed.rs b/libgrust/rustc-lib/alloc/src/boxed.rs new file mode 100644 index 000000000000..1512235da6a8 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/boxed.rs @@ -0,0 +1,1433 @@ +//! A pointer type for heap allocation. +//! +//! [`Box`], casually referred to as a 'box', provides the simplest form of +//! heap allocation in Rust. Boxes provide ownership for this allocation, and +//! drop their contents when they go out of scope. Boxes also ensure that they +//! never allocate more than `isize::MAX` bytes. +//! +//! # Examples +//! +//! Move a value from the stack to the heap by creating a [`Box`]: +//! +//! ``` +//! let val: u8 = 5; +//! let boxed: Box = Box::new(val); +//! ``` +//! +//! Move a value from a [`Box`] back to the stack by [dereferencing]: +//! +//! ``` +//! let boxed: Box = Box::new(5); +//! let val: u8 = *boxed; +//! ``` +//! +//! Creating a recursive data structure: +//! +//! ``` +//! #[derive(Debug)] +//! enum List { +//! Cons(T, Box>), +//! Nil, +//! } +//! +//! let list: List = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil)))); +//! println!("{:?}", list); +//! ``` +//! +//! This will print `Cons(1, Cons(2, Nil))`. +//! +//! Recursive structures must be boxed, because if the definition of `Cons` +//! looked like this: +//! +//! ```compile_fail,E0072 +//! # enum List { +//! Cons(T, List), +//! # } +//! ``` +//! +//! It wouldn't work. This is because the size of a `List` depends on how many +//! elements are in the list, and so we don't know how much memory to allocate +//! for a `Cons`. By introducing a [`Box`], which has a defined size, we know how +//! big `Cons` needs to be. +//! +//! # Memory layout +//! +//! For non-zero-sized values, a [`Box`] will use the [`Global`] allocator for +//! its allocation. It is valid to convert both ways between a [`Box`] and a +//! raw pointer allocated with the [`Global`] allocator, given that the +//! [`Layout`] used with the allocator is correct for the type. More precisely, +//! a `value: *mut T` that has been allocated with the [`Global`] allocator +//! with `Layout::for_value(&*value)` may be converted into a box using +//! [`Box::::from_raw(value)`]. Conversely, the memory backing a `value: *mut +//! T` obtained from [`Box::::into_raw`] may be deallocated using the +//! [`Global`] allocator with [`Layout::for_value(&*value)`]. +//! +//! So long as `T: Sized`, a `Box` is guaranteed to be represented +//! as a single pointer and is also ABI-compatible with C pointers +//! (i.e. the C type `T*`). This means that if you have extern "C" +//! Rust functions that will be called from C, you can define those +//! Rust functions using `Box` types, and use `T*` as corresponding +//! type on the C side. As an example, consider this C header which +//! declares functions that create and destroy some kind of `Foo` +//! value: +//! +//! ```c +//! /* C header */ +//! +//! /* Returns ownership to the caller */ +//! struct Foo* foo_new(void); +//! +//! /* Takes ownership from the caller; no-op when invoked with NULL */ +//! void foo_delete(struct Foo*); +//! ``` +//! +//! These two functions might be implemented in Rust as follows. Here, the +//! `struct Foo*` type from C is translated to `Box`, which captures +//! the ownership constraints. Note also that the nullable argument to +//! `foo_delete` is represented in Rust as `Option>`, since `Box` +//! cannot be null. +//! +//! ``` +//! #[repr(C)] +//! pub struct Foo; +//! +//! #[no_mangle] +//! #[allow(improper_ctypes_definitions)] +//! pub extern "C" fn foo_new() -> Box { +//! Box::new(Foo) +//! } +//! +//! #[no_mangle] +//! #[allow(improper_ctypes_definitions)] +//! pub extern "C" fn foo_delete(_: Option>) {} +//! ``` +//! +//! Even though `Box` has the same representation and C ABI as a C pointer, +//! this does not mean that you can convert an arbitrary `T*` into a `Box` +//! and expect things to work. `Box` values will always be fully aligned, +//! non-null pointers. Moreover, the destructor for `Box` will attempt to +//! free the value with the global allocator. In general, the best practice +//! is to only use `Box` for pointers that originated from the global +//! allocator. +//! +//! **Important.** At least at present, you should avoid using +//! `Box` types for functions that are defined in C but invoked +//! from Rust. In those cases, you should directly mirror the C types +//! as closely as possible. Using types like `Box` where the C +//! definition is just using `T*` can lead to undefined behavior, as +//! described in [rust-lang/unsafe-code-guidelines#198][ucg#198]. +//! +//! [ucg#198]: https://github.com/rust-lang/unsafe-code-guidelines/issues/198 +//! [dereferencing]: core::ops::Deref +//! [`Box`]: Box +//! [`Box::::from_raw(value)`]: Box::from_raw +//! [`Box::::into_raw`]: Box::into_raw +//! [`Global`]: crate::alloc::Global +//! [`Layout`]: crate::alloc::Layout +//! [`Layout::for_value(&*value)`]: crate::alloc::Layout::for_value + +#![stable(feature = "rust1", since = "1.0.0")] + +use core::any::Any; +use core::borrow; +use core::cmp::Ordering; +use core::convert::{From, TryFrom}; +use core::fmt; +use core::future::Future; +use core::hash::{Hash, Hasher}; +use core::iter::{FromIterator, FusedIterator, Iterator}; +use core::marker::{Unpin, Unsize}; +use core::mem; +use core::ops::{ + CoerceUnsized, Deref, DerefMut, DispatchFromDyn, Generator, GeneratorState, Receiver, +}; +use core::pin::Pin; +use core::ptr::{self, Unique}; +use core::task::{Context, Poll}; + +use crate::alloc::{handle_alloc_error, AllocRef, Global, Layout}; +use crate::borrow::Cow; +use crate::raw_vec::RawVec; +use crate::str::from_boxed_utf8_unchecked; +use crate::vec::Vec; + +/// A pointer type for heap allocation. +/// +/// See the [module-level documentation](../../std/boxed/index.html) for more. +#[lang = "owned_box"] +#[fundamental] +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Box< + T: ?Sized, + #[unstable(feature = "allocator_api", issue = "32838")] A: AllocRef = Global, +>(Unique, A); + +impl Box { + /// Allocates memory on the heap and then places `x` into it. + /// + /// This doesn't actually allocate if `T` is zero-sized. + /// + /// # Examples + /// + /// ``` + /// let five = Box::new(5); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline(always)] + pub fn new(x: T) -> Self { + box x + } + + /// Constructs a new box with uninitialized contents. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// let mut five = Box::::new_uninit(); + /// + /// let five = unsafe { + /// // Deferred initialization: + /// five.as_mut_ptr().write(5); + /// + /// five.assume_init() + /// }; + /// + /// assert_eq!(*five, 5) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + #[inline] + pub fn new_uninit() -> Box> { + Self::new_uninit_in(Global) + } + + /// Constructs a new `Box` with uninitialized contents, with the memory + /// being filled with `0` bytes. + /// + /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and incorrect usage + /// of this method. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// let zero = Box::::new_zeroed(); + /// let zero = unsafe { zero.assume_init() }; + /// + /// assert_eq!(*zero, 0) + /// ``` + /// + /// [zeroed]: mem::MaybeUninit::zeroed + #[unstable(feature = "new_uninit", issue = "63291")] + #[inline] + pub fn new_zeroed() -> Box> { + Self::new_zeroed_in(Global) + } + + /// Constructs a new `Pin>`. If `T` does not implement `Unpin`, then + /// `x` will be pinned in memory and unable to be moved. + #[stable(feature = "pin", since = "1.33.0")] + #[inline(always)] + pub fn pin(x: T) -> Pin> { + (box x).into() + } +} + +impl Box { + /// Allocates memory in the given allocator then places `x` into it. + /// + /// This doesn't actually allocate if `T` is zero-sized. + /// + /// # Examples + /// + /// ``` + /// #![feature(allocator_api)] + /// + /// use std::alloc::System; + /// + /// let five = Box::new_in(5, System); + /// ``` + #[unstable(feature = "allocator_api", issue = "32838")] + #[inline] + pub fn new_in(x: T, alloc: A) -> Self { + let mut boxed = Self::new_uninit_in(alloc); + unsafe { + boxed.as_mut_ptr().write(x); + boxed.assume_init() + } + } + + /// Constructs a new box with uninitialized contents in the provided allocator. + /// + /// # Examples + /// + /// ``` + /// #![feature(allocator_api, new_uninit)] + /// + /// use std::alloc::System; + /// + /// let mut five = Box::::new_uninit_in(System); + /// + /// let five = unsafe { + /// // Deferred initialization: + /// five.as_mut_ptr().write(5); + /// + /// five.assume_init() + /// }; + /// + /// assert_eq!(*five, 5) + /// ``` + #[unstable(feature = "allocator_api", issue = "32838")] + // #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_uninit_in(alloc: A) -> Box, A> { + let layout = Layout::new::>(); + let ptr = alloc.alloc(layout).unwrap_or_else(|_| handle_alloc_error(layout)).cast(); + unsafe { Box::from_raw_in(ptr.as_ptr(), alloc) } + } + + /// Constructs a new `Box` with uninitialized contents, with the memory + /// being filled with `0` bytes in the provided allocator. + /// + /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and incorrect usage + /// of this method. + /// + /// # Examples + /// + /// ``` + /// #![feature(allocator_api, new_uninit)] + /// + /// use std::alloc::System; + /// + /// let zero = Box::::new_zeroed_in(System); + /// let zero = unsafe { zero.assume_init() }; + /// + /// assert_eq!(*zero, 0) + /// ``` + /// + /// [zeroed]: mem::MaybeUninit::zeroed + #[unstable(feature = "allocator_api", issue = "32838")] + // #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_zeroed_in(alloc: A) -> Box, A> { + let layout = Layout::new::>(); + let ptr = alloc.alloc_zeroed(layout).unwrap_or_else(|_| handle_alloc_error(layout)).cast(); + unsafe { Box::from_raw_in(ptr.as_ptr(), alloc) } + } + + /// Constructs a new `Pin>`. If `T` does not implement `Unpin`, then + /// `x` will be pinned in memory and unable to be moved. + #[unstable(feature = "allocator_api", issue = "32838")] + #[inline(always)] + pub fn pin_in(x: T, alloc: A) -> Pin { + Self::new_in(x, alloc).into() + } + + /// Converts a `Box` into a `Box<[T]>` + /// + /// This conversion does not allocate on the heap and happens in place. + #[unstable(feature = "box_into_boxed_slice", issue = "71582")] + pub fn into_boxed_slice(boxed: Self) -> Box<[T], A> { + let (raw, alloc) = Box::into_raw_with_alloc(boxed); + unsafe { Box::from_raw_in(raw as *mut [T; 1], alloc) } + } +} + +impl Box<[T]> { + /// Constructs a new boxed slice with uninitialized contents. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// let mut values = Box::<[u32]>::new_uninit_slice(3); + /// + /// let values = unsafe { + /// // Deferred initialization: + /// values[0].as_mut_ptr().write(1); + /// values[1].as_mut_ptr().write(2); + /// values[2].as_mut_ptr().write(3); + /// + /// values.assume_init() + /// }; + /// + /// assert_eq!(*values, [1, 2, 3]) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit]> { + unsafe { RawVec::with_capacity(len).into_box(len) } + } + + /// Constructs a new boxed slice with uninitialized contents, with the memory + /// being filled with `0` bytes. + /// + /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and incorrect usage + /// of this method. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// let values = Box::<[u32]>::new_zeroed_slice(3); + /// let values = unsafe { values.assume_init() }; + /// + /// assert_eq!(*values, [0, 0, 0]) + /// ``` + /// + /// [zeroed]: mem::MaybeUninit::zeroed + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_zeroed_slice(len: usize) -> Box<[mem::MaybeUninit]> { + unsafe { RawVec::with_capacity_zeroed(len).into_box(len) } + } +} + +impl Box<[T], A> { + /// Constructs a new boxed slice with uninitialized contents in the provided allocator. + /// + /// # Examples + /// + /// ``` + /// #![feature(allocator_api, new_uninit)] + /// + /// use std::alloc::System; + /// + /// let mut values = Box::<[u32], _>::new_uninit_slice_in(3, System); + /// + /// let values = unsafe { + /// // Deferred initialization: + /// values[0].as_mut_ptr().write(1); + /// values[1].as_mut_ptr().write(2); + /// values[2].as_mut_ptr().write(3); + /// + /// values.assume_init() + /// }; + /// + /// assert_eq!(*values, [1, 2, 3]) + /// ``` + #[unstable(feature = "allocator_api", issue = "32838")] + // #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], A> { + unsafe { RawVec::with_capacity_in(len, alloc).into_box(len) } + } + + /// Constructs a new boxed slice with uninitialized contents in the provided allocator, + /// with the memory being filled with `0` bytes. + /// + /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and incorrect usage + /// of this method. + /// + /// # Examples + /// + /// ``` + /// #![feature(allocator_api, new_uninit)] + /// + /// use std::alloc::System; + /// + /// let values = Box::<[u32], _>::new_zeroed_slice_in(3, System); + /// let values = unsafe { values.assume_init() }; + /// + /// assert_eq!(*values, [0, 0, 0]) + /// ``` + /// + /// [zeroed]: mem::MaybeUninit::zeroed + #[unstable(feature = "allocator_api", issue = "32838")] + // #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], A> { + unsafe { RawVec::with_capacity_zeroed_in(len, alloc).into_box(len) } + } +} + +impl Box, A> { + /// Converts to `Box`. + /// + /// # Safety + /// + /// As with [`MaybeUninit::assume_init`], + /// it is up to the caller to guarantee that the value + /// really is in an initialized state. + /// Calling this when the content is not yet fully initialized + /// causes immediate undefined behavior. + /// + /// [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// let mut five = Box::::new_uninit(); + /// + /// let five: Box = unsafe { + /// // Deferred initialization: + /// five.as_mut_ptr().write(5); + /// + /// five.assume_init() + /// }; + /// + /// assert_eq!(*five, 5) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + #[inline] + pub unsafe fn assume_init(self) -> Box { + let (raw, alloc) = Box::into_raw_with_alloc(self); + unsafe { Box::from_raw_in(raw as *mut T, alloc) } + } +} + +impl Box<[mem::MaybeUninit], A> { + /// Converts to `Box<[T], A>`. + /// + /// # Safety + /// + /// As with [`MaybeUninit::assume_init`], + /// it is up to the caller to guarantee that the values + /// really are in an initialized state. + /// Calling this when the content is not yet fully initialized + /// causes immediate undefined behavior. + /// + /// [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// let mut values = Box::<[u32]>::new_uninit_slice(3); + /// + /// let values = unsafe { + /// // Deferred initialization: + /// values[0].as_mut_ptr().write(1); + /// values[1].as_mut_ptr().write(2); + /// values[2].as_mut_ptr().write(3); + /// + /// values.assume_init() + /// }; + /// + /// assert_eq!(*values, [1, 2, 3]) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + #[inline] + pub unsafe fn assume_init(self) -> Box<[T], A> { + let (raw, alloc) = Box::into_raw_with_alloc(self); + unsafe { Box::from_raw_in(raw as *mut [T], alloc) } + } +} + +impl Box { + /// Constructs a box from a raw pointer. + /// + /// After calling this function, the raw pointer is owned by the + /// resulting `Box`. Specifically, the `Box` destructor will call + /// the destructor of `T` and free the allocated memory. For this + /// to be safe, the memory must have been allocated in accordance + /// with the [memory layout] used by `Box` . + /// + /// # Safety + /// + /// This function is unsafe because improper use may lead to + /// memory problems. For example, a double-free may occur if the + /// function is called twice on the same raw pointer. + /// + /// # Examples + /// Recreate a `Box` which was previously converted to a raw pointer + /// using [`Box::into_raw`]: + /// ``` + /// let x = Box::new(5); + /// let ptr = Box::into_raw(x); + /// let x = unsafe { Box::from_raw(ptr) }; + /// ``` + /// Manually create a `Box` from scratch by using the global allocator: + /// ``` + /// use std::alloc::{alloc, Layout}; + /// + /// unsafe { + /// let ptr = alloc(Layout::new::()) as *mut i32; + /// // In general .write is required to avoid attempting to destruct + /// // the (uninitialized) previous contents of `ptr`, though for this + /// // simple example `*ptr = 5` would have worked as well. + /// ptr.write(5); + /// let x = Box::from_raw(ptr); + /// } + /// ``` + /// + /// [memory layout]: self#memory-layout + /// [`Layout`]: crate::Layout + #[stable(feature = "box_raw", since = "1.4.0")] + #[inline] + pub unsafe fn from_raw(raw: *mut T) -> Self { + unsafe { Self::from_raw_in(raw, Global) } + } +} + +impl Box { + /// Constructs a box from a raw pointer in the given allocator. + /// + /// After calling this function, the raw pointer is owned by the + /// resulting `Box`. Specifically, the `Box` destructor will call + /// the destructor of `T` and free the allocated memory. For this + /// to be safe, the memory must have been allocated in accordance + /// with the [memory layout] used by `Box` . + /// + /// # Safety + /// + /// This function is unsafe because improper use may lead to + /// memory problems. For example, a double-free may occur if the + /// function is called twice on the same raw pointer. + /// + /// + /// # Examples + /// + /// Recreate a `Box` which was previously converted to a raw pointer + /// using [`Box::into_raw_with_alloc`]: + /// ``` + /// #![feature(allocator_api)] + /// + /// use std::alloc::System; + /// + /// let x = Box::new_in(5, System); + /// let (ptr, alloc) = Box::into_raw_with_alloc(x); + /// let x = unsafe { Box::from_raw_in(ptr, alloc) }; + /// ``` + /// Manually create a `Box` from scratch by using the system allocator: + /// ``` + /// #![feature(allocator_api, slice_ptr_get)] + /// + /// use std::alloc::{AllocRef, Layout, System}; + /// + /// unsafe { + /// let ptr = System.alloc(Layout::new::())?.as_mut_ptr(); + /// // In general .write is required to avoid attempting to destruct + /// // the (uninitialized) previous contents of `ptr`, though for this + /// // simple example `*ptr = 5` would have worked as well. + /// ptr.write(5); + /// let x = Box::from_raw_in(ptr, System); + /// } + /// # Ok::<(), std::alloc::AllocError>(()) + /// ``` + /// + /// [memory layout]: self#memory-layout + /// [`Layout`]: crate::Layout + #[unstable(feature = "allocator_api", issue = "32838")] + #[inline] + pub unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Self { + Box(unsafe { Unique::new_unchecked(raw) }, alloc) + } + + /// Consumes the `Box`, returning a wrapped raw pointer. + /// + /// The pointer will be properly aligned and non-null. + /// + /// After calling this function, the caller is responsible for the + /// memory previously managed by the `Box`. In particular, the + /// caller should properly destroy `T` and release the memory, taking + /// into account the [memory layout] used by `Box`. The easiest way to + /// do this is to convert the raw pointer back into a `Box` with the + /// [`Box::from_raw`] function, allowing the `Box` destructor to perform + /// the cleanup. + /// + /// Note: this is an associated function, which means that you have + /// to call it as `Box::into_raw(b)` instead of `b.into_raw()`. This + /// is so that there is no conflict with a method on the inner type. + /// + /// # Examples + /// Converting the raw pointer back into a `Box` with [`Box::from_raw`] + /// for automatic cleanup: + /// ``` + /// let x = Box::new(String::from("Hello")); + /// let ptr = Box::into_raw(x); + /// let x = unsafe { Box::from_raw(ptr) }; + /// ``` + /// Manual cleanup by explicitly running the destructor and deallocating + /// the memory: + /// ``` + /// use std::alloc::{dealloc, Layout}; + /// use std::ptr; + /// + /// let x = Box::new(String::from("Hello")); + /// let p = Box::into_raw(x); + /// unsafe { + /// ptr::drop_in_place(p); + /// dealloc(p as *mut u8, Layout::new::()); + /// } + /// ``` + /// + /// [memory layout]: self#memory-layout + #[stable(feature = "box_raw", since = "1.4.0")] + #[inline] + pub fn into_raw(b: Self) -> *mut T { + Self::into_raw_with_alloc(b).0 + } + + /// Consumes the `Box`, returning a wrapped raw pointer and the allocator. + /// + /// The pointer will be properly aligned and non-null. + /// + /// After calling this function, the caller is responsible for the + /// memory previously managed by the `Box`. In particular, the + /// caller should properly destroy `T` and release the memory, taking + /// into account the [memory layout] used by `Box`. The easiest way to + /// do this is to convert the raw pointer back into a `Box` with the + /// [`Box::from_raw_in`] function, allowing the `Box` destructor to perform + /// the cleanup. + /// + /// Note: this is an associated function, which means that you have + /// to call it as `Box::into_raw_with_alloc(b)` instead of `b.into_raw_with_alloc()`. This + /// is so that there is no conflict with a method on the inner type. + /// + /// # Examples + /// Converting the raw pointer back into a `Box` with [`Box::from_raw_in`] + /// for automatic cleanup: + /// ``` + /// #![feature(allocator_api)] + /// + /// use std::alloc::System; + /// + /// let x = Box::new_in(String::from("Hello"), System); + /// let (ptr, alloc) = Box::into_raw_with_alloc(x); + /// let x = unsafe { Box::from_raw_in(ptr, alloc) }; + /// ``` + /// Manual cleanup by explicitly running the destructor and deallocating + /// the memory: + /// ``` + /// #![feature(allocator_api)] + /// + /// use std::alloc::{AllocRef, Layout, System}; + /// use std::ptr::{self, NonNull}; + /// + /// let x = Box::new_in(String::from("Hello"), System); + /// let (ptr, alloc) = Box::into_raw_with_alloc(x); + /// unsafe { + /// ptr::drop_in_place(ptr); + /// let non_null = NonNull::new_unchecked(ptr); + /// alloc.dealloc(non_null.cast(), Layout::new::()); + /// } + /// ``` + /// + /// [memory layout]: self#memory-layout + #[unstable(feature = "allocator_api", issue = "32838")] + #[inline] + pub fn into_raw_with_alloc(b: Self) -> (*mut T, A) { + let (leaked, alloc) = Box::into_unique(b); + (leaked.as_ptr(), alloc) + } + + #[unstable( + feature = "ptr_internals", + issue = "none", + reason = "use `Box::leak(b).into()` or `Unique::from(Box::leak(b))` instead" + )] + #[inline] + #[doc(hidden)] + pub fn into_unique(b: Self) -> (Unique, A) { + // Box is recognized as a "unique pointer" by Stacked Borrows, but internally it is a + // raw pointer for the type system. Turning it directly into a raw pointer would not be + // recognized as "releasing" the unique pointer to permit aliased raw accesses, + // so all raw pointer methods have to go through `Box::leak`. Turning *that* to a raw pointer + // behaves correctly. + let alloc = unsafe { ptr::read(&b.1) }; + (Unique::from(Box::leak(b)), alloc) + } + + /// Returns a reference to the underlying allocator. + /// + /// Note: this is an associated function, which means that you have + /// to call it as `Box::alloc_ref(&b)` instead of `b.alloc_ref()`. This + /// is so that there is no conflict with a method on the inner type. + #[unstable(feature = "allocator_api", issue = "32838")] + #[inline] + pub fn alloc_ref(b: &Self) -> &A { + &b.1 + } + + /// Consumes and leaks the `Box`, returning a mutable reference, + /// `&'a mut T`. Note that the type `T` must outlive the chosen lifetime + /// `'a`. If the type has only static references, or none at all, then this + /// may be chosen to be `'static`. + /// + /// This function is mainly useful for data that lives for the remainder of + /// the program's life. Dropping the returned reference will cause a memory + /// leak. If this is not acceptable, the reference should first be wrapped + /// with the [`Box::from_raw`] function producing a `Box`. This `Box` can + /// then be dropped which will properly destroy `T` and release the + /// allocated memory. + /// + /// Note: this is an associated function, which means that you have + /// to call it as `Box::leak(b)` instead of `b.leak()`. This + /// is so that there is no conflict with a method on the inner type. + /// + /// # Examples + /// + /// Simple usage: + /// + /// ``` + /// let x = Box::new(41); + /// let static_ref: &'static mut usize = Box::leak(x); + /// *static_ref += 1; + /// assert_eq!(*static_ref, 42); + /// ``` + /// + /// Unsized data: + /// + /// ``` + /// let x = vec![1, 2, 3].into_boxed_slice(); + /// let static_ref = Box::leak(x); + /// static_ref[0] = 4; + /// assert_eq!(*static_ref, [4, 2, 3]); + /// ``` + #[stable(feature = "box_leak", since = "1.26.0")] + #[inline] + pub fn leak<'a>(b: Self) -> &'a mut T + where + A: 'a, + { + unsafe { &mut *mem::ManuallyDrop::new(b).0.as_ptr() } + } + + /// Converts a `Box` into a `Pin>` + /// + /// This conversion does not allocate on the heap and happens in place. + /// + /// This is also available via [`From`]. + #[unstable(feature = "box_into_pin", issue = "62370")] + pub fn into_pin(boxed: Self) -> Pin { + // It's not possible to move or replace the insides of a `Pin>` + // when `T: !Unpin`, so it's safe to pin it directly without any + // additional requirements. + unsafe { Pin::new_unchecked(boxed) } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl<#[may_dangle] T: ?Sized, A: AllocRef> Drop for Box { + fn drop(&mut self) { + // FIXME: Do nothing, drop is currently performed by compiler. + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for Box { + /// Creates a `Box`, with the `Default` value for T. + fn default() -> Self { + box T::default() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for Box<[T]> { + fn default() -> Self { + Box::<[T; 0]>::new([]) + } +} + +#[stable(feature = "default_box_extra", since = "1.17.0")] +impl Default for Box { + fn default() -> Self { + unsafe { from_boxed_utf8_unchecked(Default::default()) } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Box { + /// Returns a new box with a `clone()` of this box's contents. + /// + /// # Examples + /// + /// ``` + /// let x = Box::new(5); + /// let y = x.clone(); + /// + /// // The value is the same + /// assert_eq!(x, y); + /// + /// // But they are unique objects + /// assert_ne!(&*x as *const i32, &*y as *const i32); + /// ``` + #[rustfmt::skip] + #[inline] + fn clone(&self) -> Self { + Self::new_in((**self).clone(), self.1.clone()) + } + + /// Copies `source`'s contents into `self` without creating a new allocation. + /// + /// # Examples + /// + /// ``` + /// let x = Box::new(5); + /// let mut y = Box::new(10); + /// let yp: *const i32 = &*y; + /// + /// y.clone_from(&x); + /// + /// // The value is the same + /// assert_eq!(x, y); + /// + /// // And no allocation occurred + /// assert_eq!(yp, &*y); + /// ``` + #[inline] + fn clone_from(&mut self, source: &Self) { + (**self).clone_from(&(**source)); + } +} + +#[stable(feature = "box_slice_clone", since = "1.3.0")] +impl Clone for Box { + fn clone(&self) -> Self { + // this makes a copy of the data + let buf: Box<[u8]> = self.as_bytes().into(); + unsafe { from_boxed_utf8_unchecked(buf) } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialEq for Box { + #[inline] + fn eq(&self, other: &Self) -> bool { + PartialEq::eq(&**self, &**other) + } + #[inline] + fn ne(&self, other: &Self) -> bool { + PartialEq::ne(&**self, &**other) + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialOrd for Box { + #[inline] + fn partial_cmp(&self, other: &Self) -> Option { + PartialOrd::partial_cmp(&**self, &**other) + } + #[inline] + fn lt(&self, other: &Self) -> bool { + PartialOrd::lt(&**self, &**other) + } + #[inline] + fn le(&self, other: &Self) -> bool { + PartialOrd::le(&**self, &**other) + } + #[inline] + fn ge(&self, other: &Self) -> bool { + PartialOrd::ge(&**self, &**other) + } + #[inline] + fn gt(&self, other: &Self) -> bool { + PartialOrd::gt(&**self, &**other) + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl Ord for Box { + #[inline] + fn cmp(&self, other: &Self) -> Ordering { + Ord::cmp(&**self, &**other) + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl Eq for Box {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Hash for Box { + fn hash(&self, state: &mut H) { + (**self).hash(state); + } +} + +#[stable(feature = "indirect_hasher_impl", since = "1.22.0")] +impl Hasher for Box { + fn finish(&self) -> u64 { + (**self).finish() + } + fn write(&mut self, bytes: &[u8]) { + (**self).write(bytes) + } + fn write_u8(&mut self, i: u8) { + (**self).write_u8(i) + } + fn write_u16(&mut self, i: u16) { + (**self).write_u16(i) + } + fn write_u32(&mut self, i: u32) { + (**self).write_u32(i) + } + fn write_u64(&mut self, i: u64) { + (**self).write_u64(i) + } + fn write_u128(&mut self, i: u128) { + (**self).write_u128(i) + } + fn write_usize(&mut self, i: usize) { + (**self).write_usize(i) + } + fn write_i8(&mut self, i: i8) { + (**self).write_i8(i) + } + fn write_i16(&mut self, i: i16) { + (**self).write_i16(i) + } + fn write_i32(&mut self, i: i32) { + (**self).write_i32(i) + } + fn write_i64(&mut self, i: i64) { + (**self).write_i64(i) + } + fn write_i128(&mut self, i: i128) { + (**self).write_i128(i) + } + fn write_isize(&mut self, i: isize) { + (**self).write_isize(i) + } +} + +#[stable(feature = "from_for_ptrs", since = "1.6.0")] +impl From for Box { + /// Converts a generic type `T` into a `Box` + /// + /// The conversion allocates on the heap and moves `t` + /// from the stack into it. + /// + /// # Examples + /// ```rust + /// let x = 5; + /// let boxed = Box::new(5); + /// + /// assert_eq!(Box::from(x), boxed); + /// ``` + fn from(t: T) -> Self { + Box::new(t) + } +} + +#[stable(feature = "pin", since = "1.33.0")] +impl From> for Pin> { + /// Converts a `Box` into a `Pin>` + /// + /// This conversion does not allocate on the heap and happens in place. + fn from(boxed: Box) -> Self { + Box::into_pin(boxed) + } +} + +#[stable(feature = "box_from_slice", since = "1.17.0")] +impl From<&[T]> for Box<[T]> { + /// Converts a `&[T]` into a `Box<[T]>` + /// + /// This conversion allocates on the heap + /// and performs a copy of `slice`. + /// + /// # Examples + /// ```rust + /// // create a &[u8] which will be used to create a Box<[u8]> + /// let slice: &[u8] = &[104, 101, 108, 108, 111]; + /// let boxed_slice: Box<[u8]> = Box::from(slice); + /// + /// println!("{:?}", boxed_slice); + /// ``` + fn from(slice: &[T]) -> Box<[T]> { + let len = slice.len(); + let buf = RawVec::with_capacity(len); + unsafe { + ptr::copy_nonoverlapping(slice.as_ptr(), buf.ptr(), len); + buf.into_box(slice.len()).assume_init() + } + } +} + +#[stable(feature = "box_from_cow", since = "1.45.0")] +impl From> for Box<[T]> { + #[inline] + fn from(cow: Cow<'_, [T]>) -> Box<[T]> { + match cow { + Cow::Borrowed(slice) => Box::from(slice), + Cow::Owned(slice) => Box::from(slice), + } + } +} + +#[stable(feature = "box_from_slice", since = "1.17.0")] +impl From<&str> for Box { + /// Converts a `&str` into a `Box` + /// + /// This conversion allocates on the heap + /// and performs a copy of `s`. + /// + /// # Examples + /// ```rust + /// let boxed: Box = Box::from("hello"); + /// println!("{}", boxed); + /// ``` + #[inline] + fn from(s: &str) -> Box { + unsafe { from_boxed_utf8_unchecked(Box::from(s.as_bytes())) } + } +} + +#[stable(feature = "box_from_cow", since = "1.45.0")] +impl From> for Box { + #[inline] + fn from(cow: Cow<'_, str>) -> Box { + match cow { + Cow::Borrowed(s) => Box::from(s), + Cow::Owned(s) => Box::from(s), + } + } +} + +#[stable(feature = "boxed_str_conv", since = "1.19.0")] +impl From> for Box<[u8], A> { + /// Converts a `Box` into a `Box<[u8]>` + /// + /// This conversion does not allocate on the heap and happens in place. + /// + /// # Examples + /// ```rust + /// // create a Box which will be used to create a Box<[u8]> + /// let boxed: Box = Box::from("hello"); + /// let boxed_str: Box<[u8]> = Box::from(boxed); + /// + /// // create a &[u8] which will be used to create a Box<[u8]> + /// let slice: &[u8] = &[104, 101, 108, 108, 111]; + /// let boxed_slice = Box::from(slice); + /// + /// assert_eq!(boxed_slice, boxed_str); + /// ``` + #[inline] + fn from(s: Box) -> Self { + let (raw, alloc) = Box::into_raw_with_alloc(s); + unsafe { Box::from_raw_in(raw as *mut [u8], alloc) } + } +} + +#[stable(feature = "box_from_array", since = "1.45.0")] +impl From<[T; N]> for Box<[T]> { + /// Converts a `[T; N]` into a `Box<[T]>` + /// + /// This conversion moves the array to newly heap-allocated memory. + /// + /// # Examples + /// ```rust + /// let boxed: Box<[u8]> = Box::from([4, 2]); + /// println!("{:?}", boxed); + /// ``` + fn from(array: [T; N]) -> Box<[T]> { + box array + } +} + +#[stable(feature = "boxed_slice_try_from", since = "1.43.0")] +impl TryFrom> for Box<[T; N]> { + type Error = Box<[T]>; + + fn try_from(boxed_slice: Box<[T]>) -> Result { + if boxed_slice.len() == N { + Ok(unsafe { Box::from_raw(Box::into_raw(boxed_slice) as *mut [T; N]) }) + } else { + Err(boxed_slice) + } + } +} + +impl Box { + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + /// Attempt to downcast the box to a concrete type. + /// + /// # Examples + /// + /// ``` + /// use std::any::Any; + /// + /// fn print_if_string(value: Box) { + /// if let Ok(string) = value.downcast::() { + /// println!("String ({}): {}", string.len(), string); + /// } + /// } + /// + /// let my_string = "Hello World".to_string(); + /// print_if_string(Box::new(my_string)); + /// print_if_string(Box::new(0i8)); + /// ``` + pub fn downcast(self) -> Result, Self> { + if self.is::() { + unsafe { + let (raw, alloc): (*mut dyn Any, _) = Box::into_raw_with_alloc(self); + Ok(Box::from_raw_in(raw as *mut T, alloc)) + } + } else { + Err(self) + } + } +} + +impl Box { + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + /// Attempt to downcast the box to a concrete type. + /// + /// # Examples + /// + /// ``` + /// use std::any::Any; + /// + /// fn print_if_string(value: Box) { + /// if let Ok(string) = value.downcast::() { + /// println!("String ({}): {}", string.len(), string); + /// } + /// } + /// + /// let my_string = "Hello World".to_string(); + /// print_if_string(Box::new(my_string)); + /// print_if_string(Box::new(0i8)); + /// ``` + pub fn downcast(self) -> Result, Self> { + if self.is::() { + unsafe { + let (raw, alloc): (*mut (dyn Any + Send), _) = Box::into_raw_with_alloc(self); + Ok(Box::from_raw_in(raw as *mut T, alloc)) + } + } else { + Err(self) + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Display for Box { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Display::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Debug for Box { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Debug::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Pointer for Box { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + // It's not possible to extract the inner Uniq directly from the Box, + // instead we cast it to a *const which aliases the Unique + let ptr: *const T = &**self; + fmt::Pointer::fmt(&ptr, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Deref for Box { + type Target = T; + + fn deref(&self) -> &T { + &**self + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl DerefMut for Box { + fn deref_mut(&mut self) -> &mut T { + &mut **self + } +} + +#[unstable(feature = "receiver_trait", issue = "none")] +impl Receiver for Box {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Iterator for Box { + type Item = I::Item; + fn next(&mut self) -> Option { + (**self).next() + } + fn size_hint(&self) -> (usize, Option) { + (**self).size_hint() + } + fn nth(&mut self, n: usize) -> Option { + (**self).nth(n) + } + fn last(self) -> Option { + BoxIter::last(self) + } +} + +trait BoxIter { + type Item; + fn last(self) -> Option; +} + +impl BoxIter for Box { + type Item = I::Item; + default fn last(self) -> Option { + #[inline] + fn some(_: Option, x: T) -> Option { + Some(x) + } + + self.fold(None, some) + } +} + +/// Specialization for sized `I`s that uses `I`s implementation of `last()` +/// instead of the default. +#[stable(feature = "rust1", since = "1.0.0")] +impl BoxIter for Box { + fn last(self) -> Option { + (*self).last() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl DoubleEndedIterator for Box { + fn next_back(&mut self) -> Option { + (**self).next_back() + } + fn nth_back(&mut self, n: usize) -> Option { + (**self).nth_back(n) + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for Box { + fn len(&self) -> usize { + (**self).len() + } + fn is_empty(&self) -> bool { + (**self).is_empty() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Box {} + +#[stable(feature = "boxed_closure_impls", since = "1.35.0")] +impl + ?Sized, A: AllocRef> FnOnce for Box { + type Output = >::Output; + + extern "rust-call" fn call_once(self, args: Args) -> Self::Output { + >::call_once(*self, args) + } +} + +#[stable(feature = "boxed_closure_impls", since = "1.35.0")] +impl + ?Sized, A: AllocRef> FnMut for Box { + extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output { + >::call_mut(self, args) + } +} + +#[stable(feature = "boxed_closure_impls", since = "1.35.0")] +impl + ?Sized, A: AllocRef> Fn for Box { + extern "rust-call" fn call(&self, args: Args) -> Self::Output { + >::call(self, args) + } +} + +#[unstable(feature = "coerce_unsized", issue = "27732")] +impl, U: ?Sized, A: AllocRef> CoerceUnsized> for Box {} + +#[unstable(feature = "dispatch_from_dyn", issue = "none")] +impl, U: ?Sized> DispatchFromDyn> for Box {} + +#[stable(feature = "boxed_slice_from_iter", since = "1.32.0")] +impl FromIterator for Box<[I]> { + fn from_iter>(iter: T) -> Self { + iter.into_iter().collect::>().into_boxed_slice() + } +} + +#[stable(feature = "box_slice_clone", since = "1.3.0")] +impl Clone for Box<[T]> { + fn clone(&self) -> Self { + self.to_vec().into_boxed_slice() + } + + fn clone_from(&mut self, other: &Self) { + if self.len() == other.len() { + self.clone_from_slice(&other); + } else { + *self = other.clone(); + } + } +} + +#[stable(feature = "box_borrow", since = "1.1.0")] +impl borrow::Borrow for Box { + fn borrow(&self) -> &T { + &**self + } +} + +#[stable(feature = "box_borrow", since = "1.1.0")] +impl borrow::BorrowMut for Box { + fn borrow_mut(&mut self) -> &mut T { + &mut **self + } +} + +#[stable(since = "1.5.0", feature = "smart_ptr_as_ref")] +impl AsRef for Box { + fn as_ref(&self) -> &T { + &**self + } +} + +#[stable(since = "1.5.0", feature = "smart_ptr_as_ref")] +impl AsMut for Box { + fn as_mut(&mut self) -> &mut T { + &mut **self + } +} + +/* Nota bene + * + * We could have chosen not to add this impl, and instead have written a + * function of Pin> to Pin. Such a function would not be sound, + * because Box implements Unpin even when T does not, as a result of + * this impl. + * + * We chose this API instead of the alternative for a few reasons: + * - Logically, it is helpful to understand pinning in regard to the + * memory region being pointed to. For this reason none of the + * standard library pointer types support projecting through a pin + * (Box is the only pointer type in std for which this would be + * safe.) + * - It is in practice very useful to have Box be unconditionally + * Unpin because of trait objects, for which the structural auto + * trait functionality does not apply (e.g., Box would + * otherwise not be Unpin). + * + * Another type with the same semantics as Box but only a conditional + * implementation of `Unpin` (where `T: Unpin`) would be valid/safe, and + * could have a method to project a Pin from it. + */ +#[stable(feature = "pin", since = "1.33.0")] +impl Unpin for Box {} + +#[unstable(feature = "generator_trait", issue = "43122")] +impl + Unpin, R, A: AllocRef> Generator for Box { + type Yield = G::Yield; + type Return = G::Return; + + fn resume(mut self: Pin<&mut Self>, arg: R) -> GeneratorState { + G::resume(Pin::new(&mut *self), arg) + } +} + +#[unstable(feature = "generator_trait", issue = "43122")] +impl, R, A: AllocRef> Generator for Pin> { + type Yield = G::Yield; + type Return = G::Return; + + fn resume(mut self: Pin<&mut Self>, arg: R) -> GeneratorState { + G::resume((*self).as_mut(), arg) + } +} + +#[stable(feature = "futures_api", since = "1.36.0")] +impl Future for Box { + type Output = F::Output; + + fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + F::poll(Pin::new(&mut *self), cx) + } +} diff --git a/libgrust/rustc-lib/alloc/src/collections/binary_heap.rs b/libgrust/rustc-lib/alloc/src/collections/binary_heap.rs new file mode 100644 index 000000000000..97ebc12175f7 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/binary_heap.rs @@ -0,0 +1,1459 @@ +//! A priority queue implemented with a binary heap. +//! +//! Insertion and popping the largest element have *O*(log(*n*)) time complexity. +//! Checking the largest element is *O*(1). Converting a vector to a binary heap +//! can be done in-place, and has *O*(*n*) complexity. A binary heap can also be +//! converted to a sorted vector in-place, allowing it to be used for an *O*(*n* \* log(*n*)) +//! in-place heapsort. +//! +//! # Examples +//! +//! This is a larger example that implements [Dijkstra's algorithm][dijkstra] +//! to solve the [shortest path problem][sssp] on a [directed graph][dir_graph]. +//! It shows how to use [`BinaryHeap`] with custom types. +//! +//! [dijkstra]: https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm +//! [sssp]: https://en.wikipedia.org/wiki/Shortest_path_problem +//! [dir_graph]: https://en.wikipedia.org/wiki/Directed_graph +//! +//! ``` +//! use std::cmp::Ordering; +//! use std::collections::BinaryHeap; +//! +//! #[derive(Copy, Clone, Eq, PartialEq)] +//! struct State { +//! cost: usize, +//! position: usize, +//! } +//! +//! // The priority queue depends on `Ord`. +//! // Explicitly implement the trait so the queue becomes a min-heap +//! // instead of a max-heap. +//! impl Ord for State { +//! fn cmp(&self, other: &Self) -> Ordering { +//! // Notice that the we flip the ordering on costs. +//! // In case of a tie we compare positions - this step is necessary +//! // to make implementations of `PartialEq` and `Ord` consistent. +//! other.cost.cmp(&self.cost) +//! .then_with(|| self.position.cmp(&other.position)) +//! } +//! } +//! +//! // `PartialOrd` needs to be implemented as well. +//! impl PartialOrd for State { +//! fn partial_cmp(&self, other: &Self) -> Option { +//! Some(self.cmp(other)) +//! } +//! } +//! +//! // Each node is represented as an `usize`, for a shorter implementation. +//! struct Edge { +//! node: usize, +//! cost: usize, +//! } +//! +//! // Dijkstra's shortest path algorithm. +//! +//! // Start at `start` and use `dist` to track the current shortest distance +//! // to each node. This implementation isn't memory-efficient as it may leave duplicate +//! // nodes in the queue. It also uses `usize::MAX` as a sentinel value, +//! // for a simpler implementation. +//! fn shortest_path(adj_list: &Vec>, start: usize, goal: usize) -> Option { +//! // dist[node] = current shortest distance from `start` to `node` +//! let mut dist: Vec<_> = (0..adj_list.len()).map(|_| usize::MAX).collect(); +//! +//! let mut heap = BinaryHeap::new(); +//! +//! // We're at `start`, with a zero cost +//! dist[start] = 0; +//! heap.push(State { cost: 0, position: start }); +//! +//! // Examine the frontier with lower cost nodes first (min-heap) +//! while let Some(State { cost, position }) = heap.pop() { +//! // Alternatively we could have continued to find all shortest paths +//! if position == goal { return Some(cost); } +//! +//! // Important as we may have already found a better way +//! if cost > dist[position] { continue; } +//! +//! // For each node we can reach, see if we can find a way with +//! // a lower cost going through this node +//! for edge in &adj_list[position] { +//! let next = State { cost: cost + edge.cost, position: edge.node }; +//! +//! // If so, add it to the frontier and continue +//! if next.cost < dist[next.position] { +//! heap.push(next); +//! // Relaxation, we have now found a better way +//! dist[next.position] = next.cost; +//! } +//! } +//! } +//! +//! // Goal not reachable +//! None +//! } +//! +//! fn main() { +//! // This is the directed graph we're going to use. +//! // The node numbers correspond to the different states, +//! // and the edge weights symbolize the cost of moving +//! // from one node to another. +//! // Note that the edges are one-way. +//! // +//! // 7 +//! // +-----------------+ +//! // | | +//! // v 1 2 | 2 +//! // 0 -----> 1 -----> 3 ---> 4 +//! // | ^ ^ ^ +//! // | | 1 | | +//! // | | | 3 | 1 +//! // +------> 2 -------+ | +//! // 10 | | +//! // +---------------+ +//! // +//! // The graph is represented as an adjacency list where each index, +//! // corresponding to a node value, has a list of outgoing edges. +//! // Chosen for its efficiency. +//! let graph = vec![ +//! // Node 0 +//! vec![Edge { node: 2, cost: 10 }, +//! Edge { node: 1, cost: 1 }], +//! // Node 1 +//! vec![Edge { node: 3, cost: 2 }], +//! // Node 2 +//! vec![Edge { node: 1, cost: 1 }, +//! Edge { node: 3, cost: 3 }, +//! Edge { node: 4, cost: 1 }], +//! // Node 3 +//! vec![Edge { node: 0, cost: 7 }, +//! Edge { node: 4, cost: 2 }], +//! // Node 4 +//! vec![]]; +//! +//! assert_eq!(shortest_path(&graph, 0, 1), Some(1)); +//! assert_eq!(shortest_path(&graph, 0, 3), Some(3)); +//! assert_eq!(shortest_path(&graph, 3, 0), Some(7)); +//! assert_eq!(shortest_path(&graph, 0, 4), Some(5)); +//! assert_eq!(shortest_path(&graph, 4, 0), None); +//! } +//! ``` + +#![allow(missing_docs)] +#![stable(feature = "rust1", since = "1.0.0")] + +use core::fmt; +use core::iter::{FromIterator, FusedIterator, InPlaceIterable, SourceIter, TrustedLen}; +use core::mem::{self, swap, ManuallyDrop}; +use core::ops::{Deref, DerefMut}; +use core::ptr; + +use crate::slice; +use crate::vec::{self, AsIntoIter, Vec}; + +use super::SpecExtend; + +/// A priority queue implemented with a binary heap. +/// +/// This will be a max-heap. +/// +/// It is a logic error for an item to be modified in such a way that the +/// item's ordering relative to any other item, as determined by the `Ord` +/// trait, changes while it is in the heap. This is normally only possible +/// through `Cell`, `RefCell`, global state, I/O, or unsafe code. +/// +/// # Examples +/// +/// ``` +/// use std::collections::BinaryHeap; +/// +/// // Type inference lets us omit an explicit type signature (which +/// // would be `BinaryHeap` in this example). +/// let mut heap = BinaryHeap::new(); +/// +/// // We can use peek to look at the next item in the heap. In this case, +/// // there's no items in there yet so we get None. +/// assert_eq!(heap.peek(), None); +/// +/// // Let's add some scores... +/// heap.push(1); +/// heap.push(5); +/// heap.push(2); +/// +/// // Now peek shows the most important item in the heap. +/// assert_eq!(heap.peek(), Some(&5)); +/// +/// // We can check the length of a heap. +/// assert_eq!(heap.len(), 3); +/// +/// // We can iterate over the items in the heap, although they are returned in +/// // a random order. +/// for x in &heap { +/// println!("{}", x); +/// } +/// +/// // If we instead pop these scores, they should come back in order. +/// assert_eq!(heap.pop(), Some(5)); +/// assert_eq!(heap.pop(), Some(2)); +/// assert_eq!(heap.pop(), Some(1)); +/// assert_eq!(heap.pop(), None); +/// +/// // We can clear the heap of any remaining items. +/// heap.clear(); +/// +/// // The heap should now be empty. +/// assert!(heap.is_empty()) +/// ``` +/// +/// ## Min-heap +/// +/// Either `std::cmp::Reverse` or a custom `Ord` implementation can be used to +/// make `BinaryHeap` a min-heap. This makes `heap.pop()` return the smallest +/// value instead of the greatest one. +/// +/// ``` +/// use std::collections::BinaryHeap; +/// use std::cmp::Reverse; +/// +/// let mut heap = BinaryHeap::new(); +/// +/// // Wrap values in `Reverse` +/// heap.push(Reverse(1)); +/// heap.push(Reverse(5)); +/// heap.push(Reverse(2)); +/// +/// // If we pop these scores now, they should come back in the reverse order. +/// assert_eq!(heap.pop(), Some(Reverse(1))); +/// assert_eq!(heap.pop(), Some(Reverse(2))); +/// assert_eq!(heap.pop(), Some(Reverse(5))); +/// assert_eq!(heap.pop(), None); +/// ``` +/// +/// # Time complexity +/// +/// | [push] | [pop] | [peek]/[peek\_mut] | +/// |--------|-----------|--------------------| +/// | O(1)~ | *O*(log(*n*)) | *O*(1) | +/// +/// The value for `push` is an expected cost; the method documentation gives a +/// more detailed analysis. +/// +/// [push]: BinaryHeap::push +/// [pop]: BinaryHeap::pop +/// [peek]: BinaryHeap::peek +/// [peek\_mut]: BinaryHeap::peek_mut +#[stable(feature = "rust1", since = "1.0.0")] +pub struct BinaryHeap { + data: Vec, +} + +/// Structure wrapping a mutable reference to the greatest item on a +/// `BinaryHeap`. +/// +/// This `struct` is created by the [`peek_mut`] method on [`BinaryHeap`]. See +/// its documentation for more. +/// +/// [`peek_mut`]: BinaryHeap::peek_mut +#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")] +pub struct PeekMut<'a, T: 'a + Ord> { + heap: &'a mut BinaryHeap, + sift: bool, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for PeekMut<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("PeekMut").field(&self.heap.data[0]).finish() + } +} + +#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")] +impl Drop for PeekMut<'_, T> { + fn drop(&mut self) { + if self.sift { + self.heap.sift_down(0); + } + } +} + +#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")] +impl Deref for PeekMut<'_, T> { + type Target = T; + fn deref(&self) -> &T { + debug_assert!(!self.heap.is_empty()); + // SAFE: PeekMut is only instantiated for non-empty heaps + unsafe { self.heap.data.get_unchecked(0) } + } +} + +#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")] +impl DerefMut for PeekMut<'_, T> { + fn deref_mut(&mut self) -> &mut T { + debug_assert!(!self.heap.is_empty()); + self.sift = true; + // SAFE: PeekMut is only instantiated for non-empty heaps + unsafe { self.heap.data.get_unchecked_mut(0) } + } +} + +impl<'a, T: Ord> PeekMut<'a, T> { + /// Removes the peeked value from the heap and returns it. + #[stable(feature = "binary_heap_peek_mut_pop", since = "1.18.0")] + pub fn pop(mut this: PeekMut<'a, T>) -> T { + let value = this.heap.pop().unwrap(); + this.sift = false; + value + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for BinaryHeap { + fn clone(&self) -> Self { + BinaryHeap { data: self.data.clone() } + } + + fn clone_from(&mut self, source: &Self) { + self.data.clone_from(&source.data); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for BinaryHeap { + /// Creates an empty `BinaryHeap`. + #[inline] + fn default() -> BinaryHeap { + BinaryHeap::new() + } +} + +#[stable(feature = "binaryheap_debug", since = "1.4.0")] +impl fmt::Debug for BinaryHeap { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.iter()).finish() + } +} + +impl BinaryHeap { + /// Creates an empty `BinaryHeap` as a max-heap. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::new(); + /// heap.push(4); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn new() -> BinaryHeap { + BinaryHeap { data: vec![] } + } + + /// Creates an empty `BinaryHeap` with a specific capacity. + /// This preallocates enough memory for `capacity` elements, + /// so that the `BinaryHeap` does not have to be reallocated + /// until it contains at least that many values. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::with_capacity(10); + /// heap.push(4); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn with_capacity(capacity: usize) -> BinaryHeap { + BinaryHeap { data: Vec::with_capacity(capacity) } + } + + /// Returns a mutable reference to the greatest item in the binary heap, or + /// `None` if it is empty. + /// + /// Note: If the `PeekMut` value is leaked, the heap may be in an + /// inconsistent state. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::new(); + /// assert!(heap.peek_mut().is_none()); + /// + /// heap.push(1); + /// heap.push(5); + /// heap.push(2); + /// { + /// let mut val = heap.peek_mut().unwrap(); + /// *val = 0; + /// } + /// assert_eq!(heap.peek(), Some(&2)); + /// ``` + /// + /// # Time complexity + /// + /// If the item is modified then the worst case time complexity is *O*(log(*n*)), + /// otherwise it's *O*(1). + #[stable(feature = "binary_heap_peek_mut", since = "1.12.0")] + pub fn peek_mut(&mut self) -> Option> { + if self.is_empty() { None } else { Some(PeekMut { heap: self, sift: false }) } + } + + /// Removes the greatest item from the binary heap and returns it, or `None` if it + /// is empty. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::from(vec![1, 3]); + /// + /// assert_eq!(heap.pop(), Some(3)); + /// assert_eq!(heap.pop(), Some(1)); + /// assert_eq!(heap.pop(), None); + /// ``` + /// + /// # Time complexity + /// + /// The worst case cost of `pop` on a heap containing *n* elements is *O*(log(*n*)). + #[stable(feature = "rust1", since = "1.0.0")] + pub fn pop(&mut self) -> Option { + self.data.pop().map(|mut item| { + if !self.is_empty() { + swap(&mut item, &mut self.data[0]); + self.sift_down_to_bottom(0); + } + item + }) + } + + /// Pushes an item onto the binary heap. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::new(); + /// heap.push(3); + /// heap.push(5); + /// heap.push(1); + /// + /// assert_eq!(heap.len(), 3); + /// assert_eq!(heap.peek(), Some(&5)); + /// ``` + /// + /// # Time complexity + /// + /// The expected cost of `push`, averaged over every possible ordering of + /// the elements being pushed, and over a sufficiently large number of + /// pushes, is *O*(1). This is the most meaningful cost metric when pushing + /// elements that are *not* already in any sorted pattern. + /// + /// The time complexity degrades if elements are pushed in predominantly + /// ascending order. In the worst case, elements are pushed in ascending + /// sorted order and the amortized cost per push is *O*(log(*n*)) against a heap + /// containing *n* elements. + /// + /// The worst case cost of a *single* call to `push` is *O*(*n*). The worst case + /// occurs when capacity is exhausted and needs a resize. The resize cost + /// has been amortized in the previous figures. + #[stable(feature = "rust1", since = "1.0.0")] + pub fn push(&mut self, item: T) { + let old_len = self.len(); + self.data.push(item); + self.sift_up(0, old_len); + } + + /// Consumes the `BinaryHeap` and returns a vector in sorted + /// (ascending) order. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// + /// let mut heap = BinaryHeap::from(vec![1, 2, 4, 5, 7]); + /// heap.push(6); + /// heap.push(3); + /// + /// let vec = heap.into_sorted_vec(); + /// assert_eq!(vec, [1, 2, 3, 4, 5, 6, 7]); + /// ``` + #[stable(feature = "binary_heap_extras_15", since = "1.5.0")] + pub fn into_sorted_vec(mut self) -> Vec { + let mut end = self.len(); + while end > 1 { + end -= 1; + // SAFETY: `end` goes from `self.len() - 1` to 1 (both included), + // so it's always a valid index to access. + // It is safe to access index 0 (i.e. `ptr`), because + // 1 <= end < self.len(), which means self.len() >= 2. + unsafe { + let ptr = self.data.as_mut_ptr(); + ptr::swap(ptr, ptr.add(end)); + } + self.sift_down_range(0, end); + } + self.into_vec() + } + + // The implementations of sift_up and sift_down use unsafe blocks in + // order to move an element out of the vector (leaving behind a + // hole), shift along the others and move the removed element back into the + // vector at the final location of the hole. + // The `Hole` type is used to represent this, and make sure + // the hole is filled back at the end of its scope, even on panic. + // Using a hole reduces the constant factor compared to using swaps, + // which involves twice as many moves. + fn sift_up(&mut self, start: usize, pos: usize) -> usize { + unsafe { + // Take out the value at `pos` and create a hole. + let mut hole = Hole::new(&mut self.data, pos); + + while hole.pos() > start { + let parent = (hole.pos() - 1) / 2; + if hole.element() <= hole.get(parent) { + break; + } + hole.move_to(parent); + } + hole.pos() + } + } + + /// Take an element at `pos` and move it down the heap, + /// while its children are larger. + fn sift_down_range(&mut self, pos: usize, end: usize) { + unsafe { + let mut hole = Hole::new(&mut self.data, pos); + let mut child = 2 * pos + 1; + while child < end - 1 { + // compare with the greater of the two children + child += (hole.get(child) <= hole.get(child + 1)) as usize; + // if we are already in order, stop. + if hole.element() >= hole.get(child) { + return; + } + hole.move_to(child); + child = 2 * hole.pos() + 1; + } + if child == end - 1 && hole.element() < hole.get(child) { + hole.move_to(child); + } + } + } + + fn sift_down(&mut self, pos: usize) { + let len = self.len(); + self.sift_down_range(pos, len); + } + + /// Take an element at `pos` and move it all the way down the heap, + /// then sift it up to its position. + /// + /// Note: This is faster when the element is known to be large / should + /// be closer to the bottom. + fn sift_down_to_bottom(&mut self, mut pos: usize) { + let end = self.len(); + let start = pos; + unsafe { + let mut hole = Hole::new(&mut self.data, pos); + let mut child = 2 * pos + 1; + while child < end - 1 { + child += (hole.get(child) <= hole.get(child + 1)) as usize; + hole.move_to(child); + child = 2 * hole.pos() + 1; + } + if child == end - 1 { + hole.move_to(child); + } + pos = hole.pos; + } + self.sift_up(start, pos); + } + + fn rebuild(&mut self) { + let mut n = self.len() / 2; + while n > 0 { + n -= 1; + self.sift_down(n); + } + } + + /// Moves all the elements of `other` into `self`, leaving `other` empty. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// + /// let v = vec![-10, 1, 2, 3, 3]; + /// let mut a = BinaryHeap::from(v); + /// + /// let v = vec![-20, 5, 43]; + /// let mut b = BinaryHeap::from(v); + /// + /// a.append(&mut b); + /// + /// assert_eq!(a.into_sorted_vec(), [-20, -10, 1, 2, 3, 3, 5, 43]); + /// assert!(b.is_empty()); + /// ``` + #[stable(feature = "binary_heap_append", since = "1.11.0")] + pub fn append(&mut self, other: &mut Self) { + if self.len() < other.len() { + swap(self, other); + } + + if other.is_empty() { + return; + } + + #[inline(always)] + fn log2_fast(x: usize) -> usize { + (usize::BITS - x.leading_zeros() - 1) as usize + } + + // `rebuild` takes O(len1 + len2) operations + // and about 2 * (len1 + len2) comparisons in the worst case + // while `extend` takes O(len2 * log(len1)) operations + // and about 1 * len2 * log_2(len1) comparisons in the worst case, + // assuming len1 >= len2. + #[inline] + fn better_to_rebuild(len1: usize, len2: usize) -> bool { + 2 * (len1 + len2) < len2 * log2_fast(len1) + } + + if better_to_rebuild(self.len(), other.len()) { + self.data.append(&mut other.data); + self.rebuild(); + } else { + self.extend(other.drain()); + } + } + + /// Returns an iterator which retrieves elements in heap order. + /// The retrieved elements are removed from the original heap. + /// The remaining elements will be removed on drop in heap order. + /// + /// Note: + /// * `.drain_sorted()` is *O*(*n* \* log(*n*)); much slower than `.drain()`. + /// You should use the latter for most cases. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// #![feature(binary_heap_drain_sorted)] + /// use std::collections::BinaryHeap; + /// + /// let mut heap = BinaryHeap::from(vec![1, 2, 3, 4, 5]); + /// assert_eq!(heap.len(), 5); + /// + /// drop(heap.drain_sorted()); // removes all elements in heap order + /// assert_eq!(heap.len(), 0); + /// ``` + #[inline] + #[unstable(feature = "binary_heap_drain_sorted", issue = "59278")] + pub fn drain_sorted(&mut self) -> DrainSorted<'_, T> { + DrainSorted { inner: self } + } + + /// Retains only the elements specified by the predicate. + /// + /// In other words, remove all elements `e` such that `f(&e)` returns + /// `false`. The elements are visited in unsorted (and unspecified) order. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// #![feature(binary_heap_retain)] + /// use std::collections::BinaryHeap; + /// + /// let mut heap = BinaryHeap::from(vec![-10, -5, 1, 2, 4, 13]); + /// + /// heap.retain(|x| x % 2 == 0); // only keep even numbers + /// + /// assert_eq!(heap.into_sorted_vec(), [-10, 2, 4]) + /// ``` + #[unstable(feature = "binary_heap_retain", issue = "71503")] + pub fn retain(&mut self, f: F) + where + F: FnMut(&T) -> bool, + { + self.data.retain(f); + self.rebuild(); + } +} + +impl BinaryHeap { + /// Returns an iterator visiting all values in the underlying vector, in + /// arbitrary order. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let heap = BinaryHeap::from(vec![1, 2, 3, 4]); + /// + /// // Print 1, 2, 3, 4 in arbitrary order + /// for x in heap.iter() { + /// println!("{}", x); + /// } + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn iter(&self) -> Iter<'_, T> { + Iter { iter: self.data.iter() } + } + + /// Returns an iterator which retrieves elements in heap order. + /// This method consumes the original heap. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// #![feature(binary_heap_into_iter_sorted)] + /// use std::collections::BinaryHeap; + /// let heap = BinaryHeap::from(vec![1, 2, 3, 4, 5]); + /// + /// assert_eq!(heap.into_iter_sorted().take(2).collect::>(), vec![5, 4]); + /// ``` + #[unstable(feature = "binary_heap_into_iter_sorted", issue = "59278")] + pub fn into_iter_sorted(self) -> IntoIterSorted { + IntoIterSorted { inner: self } + } + + /// Returns the greatest item in the binary heap, or `None` if it is empty. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::new(); + /// assert_eq!(heap.peek(), None); + /// + /// heap.push(1); + /// heap.push(5); + /// heap.push(2); + /// assert_eq!(heap.peek(), Some(&5)); + /// + /// ``` + /// + /// # Time complexity + /// + /// Cost is *O*(1) in the worst case. + #[stable(feature = "rust1", since = "1.0.0")] + pub fn peek(&self) -> Option<&T> { + self.data.get(0) + } + + /// Returns the number of elements the binary heap can hold without reallocating. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::with_capacity(100); + /// assert!(heap.capacity() >= 100); + /// heap.push(4); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn capacity(&self) -> usize { + self.data.capacity() + } + + /// Reserves the minimum capacity for exactly `additional` more elements to be inserted in the + /// given `BinaryHeap`. Does nothing if the capacity is already sufficient. + /// + /// Note that the allocator may give the collection more space than it requests. Therefore + /// capacity can not be relied upon to be precisely minimal. Prefer [`reserve`] if future + /// insertions are expected. + /// + /// # Panics + /// + /// Panics if the new capacity overflows `usize`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::new(); + /// heap.reserve_exact(100); + /// assert!(heap.capacity() >= 100); + /// heap.push(4); + /// ``` + /// + /// [`reserve`]: BinaryHeap::reserve + #[stable(feature = "rust1", since = "1.0.0")] + pub fn reserve_exact(&mut self, additional: usize) { + self.data.reserve_exact(additional); + } + + /// Reserves capacity for at least `additional` more elements to be inserted in the + /// `BinaryHeap`. The collection may reserve more space to avoid frequent reallocations. + /// + /// # Panics + /// + /// Panics if the new capacity overflows `usize`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::new(); + /// heap.reserve(100); + /// assert!(heap.capacity() >= 100); + /// heap.push(4); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn reserve(&mut self, additional: usize) { + self.data.reserve(additional); + } + + /// Discards as much additional capacity as possible. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap: BinaryHeap = BinaryHeap::with_capacity(100); + /// + /// assert!(heap.capacity() >= 100); + /// heap.shrink_to_fit(); + /// assert!(heap.capacity() == 0); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn shrink_to_fit(&mut self) { + self.data.shrink_to_fit(); + } + + /// Discards capacity with a lower bound. + /// + /// The capacity will remain at least as large as both the length + /// and the supplied value. + /// + /// Panics if the current capacity is smaller than the supplied + /// minimum capacity. + /// + /// # Examples + /// + /// ``` + /// #![feature(shrink_to)] + /// use std::collections::BinaryHeap; + /// let mut heap: BinaryHeap = BinaryHeap::with_capacity(100); + /// + /// assert!(heap.capacity() >= 100); + /// heap.shrink_to(10); + /// assert!(heap.capacity() >= 10); + /// ``` + #[inline] + #[unstable(feature = "shrink_to", reason = "new API", issue = "56431")] + pub fn shrink_to(&mut self, min_capacity: usize) { + self.data.shrink_to(min_capacity) + } + + /// Consumes the `BinaryHeap` and returns the underlying vector + /// in arbitrary order. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let heap = BinaryHeap::from(vec![1, 2, 3, 4, 5, 6, 7]); + /// let vec = heap.into_vec(); + /// + /// // Will print in some order + /// for x in vec { + /// println!("{}", x); + /// } + /// ``` + #[stable(feature = "binary_heap_extras_15", since = "1.5.0")] + pub fn into_vec(self) -> Vec { + self.into() + } + + /// Returns the length of the binary heap. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let heap = BinaryHeap::from(vec![1, 3]); + /// + /// assert_eq!(heap.len(), 2); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn len(&self) -> usize { + self.data.len() + } + + /// Checks if the binary heap is empty. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::new(); + /// + /// assert!(heap.is_empty()); + /// + /// heap.push(3); + /// heap.push(5); + /// heap.push(1); + /// + /// assert!(!heap.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// Clears the binary heap, returning an iterator over the removed elements. + /// + /// The elements are removed in arbitrary order. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::from(vec![1, 3]); + /// + /// assert!(!heap.is_empty()); + /// + /// for x in heap.drain() { + /// println!("{}", x); + /// } + /// + /// assert!(heap.is_empty()); + /// ``` + #[inline] + #[stable(feature = "drain", since = "1.6.0")] + pub fn drain(&mut self) -> Drain<'_, T> { + Drain { iter: self.data.drain(..) } + } + + /// Drops all items from the binary heap. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::from(vec![1, 3]); + /// + /// assert!(!heap.is_empty()); + /// + /// heap.clear(); + /// + /// assert!(heap.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn clear(&mut self) { + self.drain(); + } +} + +/// Hole represents a hole in a slice i.e., an index without valid value +/// (because it was moved from or duplicated). +/// In drop, `Hole` will restore the slice by filling the hole +/// position with the value that was originally removed. +struct Hole<'a, T: 'a> { + data: &'a mut [T], + elt: ManuallyDrop, + pos: usize, +} + +impl<'a, T> Hole<'a, T> { + /// Create a new `Hole` at index `pos`. + /// + /// Unsafe because pos must be within the data slice. + #[inline] + unsafe fn new(data: &'a mut [T], pos: usize) -> Self { + debug_assert!(pos < data.len()); + // SAFE: pos should be inside the slice + let elt = unsafe { ptr::read(data.get_unchecked(pos)) }; + Hole { data, elt: ManuallyDrop::new(elt), pos } + } + + #[inline] + fn pos(&self) -> usize { + self.pos + } + + /// Returns a reference to the element removed. + #[inline] + fn element(&self) -> &T { + &self.elt + } + + /// Returns a reference to the element at `index`. + /// + /// Unsafe because index must be within the data slice and not equal to pos. + #[inline] + unsafe fn get(&self, index: usize) -> &T { + debug_assert!(index != self.pos); + debug_assert!(index < self.data.len()); + unsafe { self.data.get_unchecked(index) } + } + + /// Move hole to new location + /// + /// Unsafe because index must be within the data slice and not equal to pos. + #[inline] + unsafe fn move_to(&mut self, index: usize) { + debug_assert!(index != self.pos); + debug_assert!(index < self.data.len()); + unsafe { + let ptr = self.data.as_mut_ptr(); + let index_ptr: *const _ = ptr.add(index); + let hole_ptr = ptr.add(self.pos); + ptr::copy_nonoverlapping(index_ptr, hole_ptr, 1); + } + self.pos = index; + } +} + +impl Drop for Hole<'_, T> { + #[inline] + fn drop(&mut self) { + // fill the hole again + unsafe { + let pos = self.pos; + ptr::copy_nonoverlapping(&*self.elt, self.data.get_unchecked_mut(pos), 1); + } + } +} + +/// An iterator over the elements of a `BinaryHeap`. +/// +/// This `struct` is created by [`BinaryHeap::iter()`]. See its +/// documentation for more. +/// +/// [`iter`]: BinaryHeap::iter +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Iter<'a, T: 'a> { + iter: slice::Iter<'a, T>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Iter<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Iter").field(&self.iter.as_slice()).finish() + } +} + +// FIXME(#26925) Remove in favor of `#[derive(Clone)]` +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Iter<'_, T> { + fn clone(&self) -> Self { + Iter { iter: self.iter.clone() } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> Iterator for Iter<'a, T> { + type Item = &'a T; + + #[inline] + fn next(&mut self) -> Option<&'a T> { + self.iter.next() + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } + + #[inline] + fn last(self) -> Option<&'a T> { + self.iter.last() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> DoubleEndedIterator for Iter<'a, T> { + #[inline] + fn next_back(&mut self) -> Option<&'a T> { + self.iter.next_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for Iter<'_, T> { + fn is_empty(&self) -> bool { + self.iter.is_empty() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Iter<'_, T> {} + +/// An owning iterator over the elements of a `BinaryHeap`. +/// +/// This `struct` is created by [`BinaryHeap::into_iter()`] +/// (provided by the `IntoIterator` trait). See its documentation for more. +/// +/// [`into_iter`]: BinaryHeap::into_iter +#[stable(feature = "rust1", since = "1.0.0")] +#[derive(Clone)] +pub struct IntoIter { + iter: vec::IntoIter, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for IntoIter { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("IntoIter").field(&self.iter.as_slice()).finish() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Iterator for IntoIter { + type Item = T; + + #[inline] + fn next(&mut self) -> Option { + self.iter.next() + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl DoubleEndedIterator for IntoIter { + #[inline] + fn next_back(&mut self) -> Option { + self.iter.next_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for IntoIter { + fn is_empty(&self) -> bool { + self.iter.is_empty() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for IntoIter {} + +#[unstable(issue = "none", feature = "inplace_iteration")] +unsafe impl SourceIter for IntoIter { + type Source = IntoIter; + + #[inline] + unsafe fn as_inner(&mut self) -> &mut Self::Source { + self + } +} + +#[unstable(issue = "none", feature = "inplace_iteration")] +unsafe impl InPlaceIterable for IntoIter {} + +impl AsIntoIter for IntoIter { + type Item = I; + + fn as_into_iter(&mut self) -> &mut vec::IntoIter { + &mut self.iter + } +} + +#[unstable(feature = "binary_heap_into_iter_sorted", issue = "59278")] +#[derive(Clone, Debug)] +pub struct IntoIterSorted { + inner: BinaryHeap, +} + +#[unstable(feature = "binary_heap_into_iter_sorted", issue = "59278")] +impl Iterator for IntoIterSorted { + type Item = T; + + #[inline] + fn next(&mut self) -> Option { + self.inner.pop() + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + let exact = self.inner.len(); + (exact, Some(exact)) + } +} + +#[unstable(feature = "binary_heap_into_iter_sorted", issue = "59278")] +impl ExactSizeIterator for IntoIterSorted {} + +#[unstable(feature = "binary_heap_into_iter_sorted", issue = "59278")] +impl FusedIterator for IntoIterSorted {} + +#[unstable(feature = "trusted_len", issue = "37572")] +unsafe impl TrustedLen for IntoIterSorted {} + +/// A draining iterator over the elements of a `BinaryHeap`. +/// +/// This `struct` is created by [`BinaryHeap::drain()`]. See its +/// documentation for more. +/// +/// [`drain`]: BinaryHeap::drain +#[stable(feature = "drain", since = "1.6.0")] +#[derive(Debug)] +pub struct Drain<'a, T: 'a> { + iter: vec::Drain<'a, T>, +} + +#[stable(feature = "drain", since = "1.6.0")] +impl Iterator for Drain<'_, T> { + type Item = T; + + #[inline] + fn next(&mut self) -> Option { + self.iter.next() + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } +} + +#[stable(feature = "drain", since = "1.6.0")] +impl DoubleEndedIterator for Drain<'_, T> { + #[inline] + fn next_back(&mut self) -> Option { + self.iter.next_back() + } +} + +#[stable(feature = "drain", since = "1.6.0")] +impl ExactSizeIterator for Drain<'_, T> { + fn is_empty(&self) -> bool { + self.iter.is_empty() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Drain<'_, T> {} + +/// A draining iterator over the elements of a `BinaryHeap`. +/// +/// This `struct` is created by [`BinaryHeap::drain_sorted()`]. See its +/// documentation for more. +/// +/// [`drain_sorted`]: BinaryHeap::drain_sorted +#[unstable(feature = "binary_heap_drain_sorted", issue = "59278")] +#[derive(Debug)] +pub struct DrainSorted<'a, T: Ord> { + inner: &'a mut BinaryHeap, +} + +#[unstable(feature = "binary_heap_drain_sorted", issue = "59278")] +impl<'a, T: Ord> Drop for DrainSorted<'a, T> { + /// Removes heap elements in heap order. + fn drop(&mut self) { + struct DropGuard<'r, 'a, T: Ord>(&'r mut DrainSorted<'a, T>); + + impl<'r, 'a, T: Ord> Drop for DropGuard<'r, 'a, T> { + fn drop(&mut self) { + while self.0.inner.pop().is_some() {} + } + } + + while let Some(item) = self.inner.pop() { + let guard = DropGuard(self); + drop(item); + mem::forget(guard); + } + } +} + +#[unstable(feature = "binary_heap_drain_sorted", issue = "59278")] +impl Iterator for DrainSorted<'_, T> { + type Item = T; + + #[inline] + fn next(&mut self) -> Option { + self.inner.pop() + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + let exact = self.inner.len(); + (exact, Some(exact)) + } +} + +#[unstable(feature = "binary_heap_drain_sorted", issue = "59278")] +impl ExactSizeIterator for DrainSorted<'_, T> {} + +#[unstable(feature = "binary_heap_drain_sorted", issue = "59278")] +impl FusedIterator for DrainSorted<'_, T> {} + +#[unstable(feature = "trusted_len", issue = "37572")] +unsafe impl TrustedLen for DrainSorted<'_, T> {} + +#[stable(feature = "binary_heap_extras_15", since = "1.5.0")] +impl From> for BinaryHeap { + /// Converts a `Vec` into a `BinaryHeap`. + /// + /// This conversion happens in-place, and has *O*(*n*) time complexity. + fn from(vec: Vec) -> BinaryHeap { + let mut heap = BinaryHeap { data: vec }; + heap.rebuild(); + heap + } +} + +#[stable(feature = "binary_heap_extras_15", since = "1.5.0")] +impl From> for Vec { + /// Converts a `BinaryHeap` into a `Vec`. + /// + /// This conversion requires no data movement or allocation, and has + /// constant time complexity. + fn from(heap: BinaryHeap) -> Vec { + heap.data + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl FromIterator for BinaryHeap { + fn from_iter>(iter: I) -> BinaryHeap { + BinaryHeap::from(iter.into_iter().collect::>()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl IntoIterator for BinaryHeap { + type Item = T; + type IntoIter = IntoIter; + + /// Creates a consuming iterator, that is, one that moves each value out of + /// the binary heap in arbitrary order. The binary heap cannot be used + /// after calling this. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let heap = BinaryHeap::from(vec![1, 2, 3, 4]); + /// + /// // Print 1, 2, 3, 4 in arbitrary order + /// for x in heap.into_iter() { + /// // x has type i32, not &i32 + /// println!("{}", x); + /// } + /// ``` + fn into_iter(self) -> IntoIter { + IntoIter { iter: self.data.into_iter() } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> IntoIterator for &'a BinaryHeap { + type Item = &'a T; + type IntoIter = Iter<'a, T>; + + fn into_iter(self) -> Iter<'a, T> { + self.iter() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Extend for BinaryHeap { + #[inline] + fn extend>(&mut self, iter: I) { + >::spec_extend(self, iter); + } + + #[inline] + fn extend_one(&mut self, item: T) { + self.push(item); + } + + #[inline] + fn extend_reserve(&mut self, additional: usize) { + self.reserve(additional); + } +} + +impl> SpecExtend for BinaryHeap { + default fn spec_extend(&mut self, iter: I) { + self.extend_desugared(iter.into_iter()); + } +} + +impl SpecExtend> for BinaryHeap { + fn spec_extend(&mut self, ref mut other: BinaryHeap) { + self.append(other); + } +} + +impl BinaryHeap { + fn extend_desugared>(&mut self, iter: I) { + let iterator = iter.into_iter(); + let (lower, _) = iterator.size_hint(); + + self.reserve(lower); + + iterator.for_each(move |elem| self.push(elem)); + } +} + +#[stable(feature = "extend_ref", since = "1.2.0")] +impl<'a, T: 'a + Ord + Copy> Extend<&'a T> for BinaryHeap { + fn extend>(&mut self, iter: I) { + self.extend(iter.into_iter().cloned()); + } + + #[inline] + fn extend_one(&mut self, &item: &'a T) { + self.push(item); + } + + #[inline] + fn extend_reserve(&mut self, additional: usize) { + self.reserve(additional); + } +} diff --git a/libgrust/rustc-lib/alloc/src/collections/btree/append.rs b/libgrust/rustc-lib/alloc/src/collections/btree/append.rs new file mode 100644 index 000000000000..e0362b2f37df --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/btree/append.rs @@ -0,0 +1,124 @@ +use super::map::MIN_LEN; +use super::merge_iter::MergeIterInner; +use super::node::{self, ForceResult::*, Root}; +use core::iter::FusedIterator; + +impl Root { + /// Appends all key-value pairs from the union of two ascending iterators, + /// incrementing a `length` variable along the way. The latter makes it + /// easier for the caller to avoid a leak when a drop handler panicks. + /// + /// If both iterators produce the same key, this method drops the pair from + /// the left iterator and appends the pair from the right iterator. + /// + /// If you want the tree to end up in a strictly ascending order, like for + /// a `BTreeMap`, both iterators should produce keys in strictly ascending + /// order, each greater than all keys in the tree, including any keys + /// already in the tree upon entry. + pub fn append_from_sorted_iters(&mut self, left: I, right: I, length: &mut usize) + where + K: Ord, + I: Iterator + FusedIterator, + { + // We prepare to merge `left` and `right` into a sorted sequence in linear time. + let iter = MergeIter(MergeIterInner::new(left, right)); + + // Meanwhile, we build a tree from the sorted sequence in linear time. + self.bulk_push(iter, length) + } + + /// Pushes all key-value pairs to the end of the tree, incrementing a + /// `length` variable along the way. The latter makes it easier for the + /// caller to avoid a leak when the iterator panicks. + fn bulk_push(&mut self, iter: I, length: &mut usize) + where + I: Iterator, + { + let mut cur_node = self.node_as_mut().last_leaf_edge().into_node(); + // Iterate through all key-value pairs, pushing them into nodes at the right level. + for (key, value) in iter { + // Try to push key-value pair into the current leaf node. + if cur_node.len() < node::CAPACITY { + cur_node.push(key, value); + } else { + // No space left, go up and push there. + let mut open_node; + let mut test_node = cur_node.forget_type(); + loop { + match test_node.ascend() { + Ok(parent) => { + let parent = parent.into_node(); + if parent.len() < node::CAPACITY { + // Found a node with space left, push here. + open_node = parent; + break; + } else { + // Go up again. + test_node = parent.forget_type(); + } + } + Err(_) => { + // We are at the top, create a new root node and push there. + open_node = self.push_internal_level(); + break; + } + } + } + + // Push key-value pair and new right subtree. + let tree_height = open_node.height() - 1; + let mut right_tree = Root::new_leaf(); + for _ in 0..tree_height { + right_tree.push_internal_level(); + } + open_node.push(key, value, right_tree); + + // Go down to the right-most leaf again. + cur_node = open_node.forget_type().last_leaf_edge().into_node(); + } + + // Increment length every iteration, to make sure the map drops + // the appended elements even if advancing the iterator panicks. + *length += 1; + } + self.fix_right_edge(); + } + + fn fix_right_edge(&mut self) { + // Handle underfull nodes, start from the top. + let mut cur_node = self.node_as_mut(); + while let Internal(internal) = cur_node.force() { + // Check if right-most child is underfull. + let mut last_edge = internal.last_edge(); + let right_child_len = last_edge.reborrow().descend().len(); + if right_child_len < MIN_LEN { + // We need to steal. + let mut last_kv = match last_edge.left_kv() { + Ok(left) => left, + Err(_) => unreachable!(), + }; + last_kv.bulk_steal_left(MIN_LEN - right_child_len); + last_edge = last_kv.right_edge(); + } + + // Go further down. + cur_node = last_edge.descend(); + } + } +} + +// An iterator for merging two sorted sequences into one +struct MergeIter>(MergeIterInner); + +impl Iterator for MergeIter +where + I: Iterator + FusedIterator, +{ + type Item = (K, V); + + /// If two keys are equal, returns the key-value pair from the right source. + fn next(&mut self) -> Option<(K, V)> { + let (a_next, b_next) = self.0.nexts(|a: &(K, V), b: &(K, V)| K::cmp(&a.0, &b.0)); + b_next.or(a_next) + } +} diff --git a/libgrust/rustc-lib/alloc/src/collections/btree/borrow.rs b/libgrust/rustc-lib/alloc/src/collections/btree/borrow.rs new file mode 100644 index 000000000000..016f139a501a --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/btree/borrow.rs @@ -0,0 +1,47 @@ +use core::marker::PhantomData; +use core::ptr::NonNull; + +/// Models a reborrow of some unique reference, when you know that the reborrow +/// and all its descendants (i.e., all pointers and references derived from it) +/// will not be used any more at some point, after which you want to use the +/// original unique reference again. +/// +/// The borrow checker usually handles this stacking of borrows for you, but +/// some control flows that accomplish this stacking are too complicated for +/// the compiler to follow. A `DormantMutRef` allows you to check borrowing +/// yourself, while still expressing its stacked nature, and encapsulating +/// the raw pointer code needed to do this without undefined behavior. +pub struct DormantMutRef<'a, T> { + ptr: NonNull, + _marker: PhantomData<&'a mut T>, +} + +unsafe impl<'a, T> Sync for DormantMutRef<'a, T> where &'a mut T: Sync {} +unsafe impl<'a, T> Send for DormantMutRef<'a, T> where &'a mut T: Send {} + +impl<'a, T> DormantMutRef<'a, T> { + /// Capture a unique borrow, and immediately reborrow it. For the compiler, + /// the lifetime of the new reference is the same as the lifetime of the + /// original reference, but you promise to use it for a shorter period. + pub fn new(t: &'a mut T) -> (&'a mut T, Self) { + let ptr = NonNull::from(t); + // SAFETY: we hold the borrow throughout 'a via `_marker`, and we expose + // only this reference, so it is unique. + let new_ref = unsafe { &mut *ptr.as_ptr() }; + (new_ref, Self { ptr, _marker: PhantomData }) + } + + /// Revert to the unique borrow initially captured. + /// + /// # Safety + /// + /// The reborrow must have ended, i.e., the reference returned by `new` and + /// all pointers and references derived from it, must not be used anymore. + pub unsafe fn awaken(self) -> &'a mut T { + // SAFETY: our own safety conditions imply this reference is again unique. + unsafe { &mut *self.ptr.as_ptr() } + } +} + +#[cfg(test)] +mod tests; diff --git a/libgrust/rustc-lib/alloc/src/collections/btree/borrow/tests.rs b/libgrust/rustc-lib/alloc/src/collections/btree/borrow/tests.rs new file mode 100644 index 000000000000..56a8434fc71e --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/btree/borrow/tests.rs @@ -0,0 +1,19 @@ +use super::DormantMutRef; + +#[test] +fn test_borrow() { + let mut data = 1; + let mut stack = vec![]; + let mut rr = &mut data; + for factor in [2, 3, 7].iter() { + let (r, dormant_r) = DormantMutRef::new(rr); + rr = r; + assert_eq!(*rr, 1); + stack.push((factor, dormant_r)); + } + while let Some((factor, dormant_r)) = stack.pop() { + let r = unsafe { dormant_r.awaken() }; + *r *= factor; + } + assert_eq!(data, 42); +} diff --git a/libgrust/rustc-lib/alloc/src/collections/btree/map.rs b/libgrust/rustc-lib/alloc/src/collections/btree/map.rs new file mode 100644 index 000000000000..49122f53d33a --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/btree/map.rs @@ -0,0 +1,2145 @@ +use core::borrow::Borrow; +use core::cmp::Ordering; +use core::fmt::{self, Debug}; +use core::hash::{Hash, Hasher}; +use core::iter::{FromIterator, FusedIterator}; +use core::marker::PhantomData; +use core::mem::{self, ManuallyDrop}; +use core::ops::{Index, RangeBounds}; +use core::ptr; + +use super::borrow::DormantMutRef; +use super::node::{self, marker, ForceResult::*, Handle, NodeRef}; +use super::search::{self, SearchResult::*}; +use super::unwrap_unchecked; + +mod entry; +pub use entry::{Entry, OccupiedEntry, VacantEntry}; +use Entry::*; + +/// Minimum number of elements in nodes that are not a root. +/// We might temporarily have fewer elements during methods. +pub(super) const MIN_LEN: usize = node::MIN_LEN_AFTER_SPLIT; + +/// A map based on a B-Tree. +/// +/// B-Trees represent a fundamental compromise between cache-efficiency and actually minimizing +/// the amount of work performed in a search. In theory, a binary search tree (BST) is the optimal +/// choice for a sorted map, as a perfectly balanced BST performs the theoretical minimum amount of +/// comparisons necessary to find an element (log2n). However, in practice the way this +/// is done is *very* inefficient for modern computer architectures. In particular, every element +/// is stored in its own individually heap-allocated node. This means that every single insertion +/// triggers a heap-allocation, and every single comparison should be a cache-miss. Since these +/// are both notably expensive things to do in practice, we are forced to at very least reconsider +/// the BST strategy. +/// +/// A B-Tree instead makes each node contain B-1 to 2B-1 elements in a contiguous array. By doing +/// this, we reduce the number of allocations by a factor of B, and improve cache efficiency in +/// searches. However, this does mean that searches will have to do *more* comparisons on average. +/// The precise number of comparisons depends on the node search strategy used. For optimal cache +/// efficiency, one could search the nodes linearly. For optimal comparisons, one could search +/// the node using binary search. As a compromise, one could also perform a linear search +/// that initially only checks every ith element for some choice of i. +/// +/// Currently, our implementation simply performs naive linear search. This provides excellent +/// performance on *small* nodes of elements which are cheap to compare. However in the future we +/// would like to further explore choosing the optimal search strategy based on the choice of B, +/// and possibly other factors. Using linear search, searching for a random element is expected +/// to take O(B * log(n)) comparisons, which is generally worse than a BST. In practice, +/// however, performance is excellent. +/// +/// It is a logic error for a key to be modified in such a way that the key's ordering relative to +/// any other key, as determined by the [`Ord`] trait, changes while it is in the map. This is +/// normally only possible through [`Cell`], [`RefCell`], global state, I/O, or unsafe code. +/// +/// [`Cell`]: core::cell::Cell +/// [`RefCell`]: core::cell::RefCell +/// +/// # Examples +/// +/// ``` +/// use std::collections::BTreeMap; +/// +/// // type inference lets us omit an explicit type signature (which +/// // would be `BTreeMap<&str, &str>` in this example). +/// let mut movie_reviews = BTreeMap::new(); +/// +/// // review some movies. +/// movie_reviews.insert("Office Space", "Deals with real issues in the workplace."); +/// movie_reviews.insert("Pulp Fiction", "Masterpiece."); +/// movie_reviews.insert("The Godfather", "Very enjoyable."); +/// movie_reviews.insert("The Blues Brothers", "Eye lyked it a lot."); +/// +/// // check for a specific one. +/// if !movie_reviews.contains_key("Les Misérables") { +/// println!("We've got {} reviews, but Les Misérables ain't one.", +/// movie_reviews.len()); +/// } +/// +/// // oops, this review has a lot of spelling mistakes, let's delete it. +/// movie_reviews.remove("The Blues Brothers"); +/// +/// // look up the values associated with some keys. +/// let to_find = ["Up!", "Office Space"]; +/// for movie in &to_find { +/// match movie_reviews.get(movie) { +/// Some(review) => println!("{}: {}", movie, review), +/// None => println!("{} is unreviewed.", movie) +/// } +/// } +/// +/// // Look up the value for a key (will panic if the key is not found). +/// println!("Movie review: {}", movie_reviews["Office Space"]); +/// +/// // iterate over everything. +/// for (movie, review) in &movie_reviews { +/// println!("{}: \"{}\"", movie, review); +/// } +/// ``` +/// +/// `BTreeMap` also implements an [`Entry API`], which allows for more complex +/// methods of getting, setting, updating and removing keys and their values: +/// +/// [`Entry API`]: BTreeMap::entry +/// +/// ``` +/// use std::collections::BTreeMap; +/// +/// // type inference lets us omit an explicit type signature (which +/// // would be `BTreeMap<&str, u8>` in this example). +/// let mut player_stats = BTreeMap::new(); +/// +/// fn random_stat_buff() -> u8 { +/// // could actually return some random value here - let's just return +/// // some fixed value for now +/// 42 +/// } +/// +/// // insert a key only if it doesn't already exist +/// player_stats.entry("health").or_insert(100); +/// +/// // insert a key using a function that provides a new value only if it +/// // doesn't already exist +/// player_stats.entry("defence").or_insert_with(random_stat_buff); +/// +/// // update a key, guarding against the key possibly not being set +/// let stat = player_stats.entry("attack").or_insert(100); +/// *stat += random_stat_buff(); +/// ``` +#[stable(feature = "rust1", since = "1.0.0")] +pub struct BTreeMap { + root: Option>, + length: usize, +} + +#[stable(feature = "btree_drop", since = "1.7.0")] +unsafe impl<#[may_dangle] K, #[may_dangle] V> Drop for BTreeMap { + fn drop(&mut self) { + unsafe { + drop(ptr::read(self).into_iter()); + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for BTreeMap { + fn clone(&self) -> BTreeMap { + fn clone_subtree<'a, K: Clone, V: Clone>( + node: node::NodeRef, K, V, marker::LeafOrInternal>, + ) -> BTreeMap + where + K: 'a, + V: 'a, + { + match node.force() { + Leaf(leaf) => { + let mut out_tree = BTreeMap { root: Some(node::Root::new_leaf()), length: 0 }; + + { + let root = out_tree.root.as_mut().unwrap(); // unwrap succeeds because we just wrapped + let mut out_node = match root.node_as_mut().force() { + Leaf(leaf) => leaf, + Internal(_) => unreachable!(), + }; + + let mut in_edge = leaf.first_edge(); + while let Ok(kv) = in_edge.right_kv() { + let (k, v) = kv.into_kv(); + in_edge = kv.right_edge(); + + out_node.push(k.clone(), v.clone()); + out_tree.length += 1; + } + } + + out_tree + } + Internal(internal) => { + let mut out_tree = clone_subtree(internal.first_edge().descend()); + + { + let out_root = BTreeMap::ensure_is_owned(&mut out_tree.root); + let mut out_node = out_root.push_internal_level(); + let mut in_edge = internal.first_edge(); + while let Ok(kv) = in_edge.right_kv() { + let (k, v) = kv.into_kv(); + in_edge = kv.right_edge(); + + let k = (*k).clone(); + let v = (*v).clone(); + let subtree = clone_subtree(in_edge.descend()); + + // We can't destructure subtree directly + // because BTreeMap implements Drop + let (subroot, sublength) = unsafe { + let subtree = ManuallyDrop::new(subtree); + let root = ptr::read(&subtree.root); + let length = subtree.length; + (root, length) + }; + + out_node.push(k, v, subroot.unwrap_or_else(node::Root::new_leaf)); + out_tree.length += 1 + sublength; + } + } + + out_tree + } + } + } + + if self.is_empty() { + // Ideally we'd call `BTreeMap::new` here, but that has the `K: + // Ord` constraint, which this method lacks. + BTreeMap { root: None, length: 0 } + } else { + clone_subtree(self.root.as_ref().unwrap().node_as_ref()) // unwrap succeeds because not empty + } + } +} + +impl super::Recover for BTreeMap +where + K: Borrow + Ord, + Q: Ord, +{ + type Key = K; + + fn get(&self, key: &Q) -> Option<&K> { + let root_node = self.root.as_ref()?.node_as_ref(); + match search::search_tree(root_node, key) { + Found(handle) => Some(handle.into_kv().0), + GoDown(_) => None, + } + } + + fn take(&mut self, key: &Q) -> Option { + let (map, dormant_map) = DormantMutRef::new(self); + let root_node = map.root.as_mut()?.node_as_mut(); + match search::search_tree(root_node, key) { + Found(handle) => { + Some(OccupiedEntry { handle, dormant_map, _marker: PhantomData }.remove_kv().0) + } + GoDown(_) => None, + } + } + + fn replace(&mut self, key: K) -> Option { + let (map, dormant_map) = DormantMutRef::new(self); + let root_node = Self::ensure_is_owned(&mut map.root).node_as_mut(); + match search::search_tree::, K, (), K>(root_node, &key) { + Found(handle) => Some(mem::replace(handle.into_key_mut(), key)), + GoDown(handle) => { + VacantEntry { key, handle, dormant_map, _marker: PhantomData }.insert(()); + None + } + } + } +} + +/// An iterator over the entries of a `BTreeMap`. +/// +/// This `struct` is created by the [`iter`] method on [`BTreeMap`]. See its +/// documentation for more. +/// +/// [`iter`]: BTreeMap::iter +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Iter<'a, K: 'a, V: 'a> { + range: Range<'a, K, V>, + length: usize, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Iter<'_, K, V> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.clone()).finish() + } +} + +/// A mutable iterator over the entries of a `BTreeMap`. +/// +/// This `struct` is created by the [`iter_mut`] method on [`BTreeMap`]. See its +/// documentation for more. +/// +/// [`iter_mut`]: BTreeMap::iter_mut +#[stable(feature = "rust1", since = "1.0.0")] +#[derive(Debug)] +pub struct IterMut<'a, K: 'a, V: 'a> { + range: RangeMut<'a, K, V>, + length: usize, +} + +/// An owning iterator over the entries of a `BTreeMap`. +/// +/// This `struct` is created by the [`into_iter`] method on [`BTreeMap`] +/// (provided by the `IntoIterator` trait). See its documentation for more. +/// +/// [`into_iter`]: IntoIterator::into_iter +#[stable(feature = "rust1", since = "1.0.0")] +pub struct IntoIter { + front: Option, marker::Edge>>, + back: Option, marker::Edge>>, + length: usize, +} + +impl IntoIter { + /// Returns an iterator of references over the remaining items. + #[inline] + pub(super) fn iter(&self) -> Iter<'_, K, V> { + let range = Range { + front: self.front.as_ref().map(|f| f.reborrow()), + back: self.back.as_ref().map(|b| b.reborrow()), + }; + + Iter { range: range, length: self.length } + } +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for IntoIter { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.iter()).finish() + } +} + +/// An iterator over the keys of a `BTreeMap`. +/// +/// This `struct` is created by the [`keys`] method on [`BTreeMap`]. See its +/// documentation for more. +/// +/// [`keys`]: BTreeMap::keys +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Keys<'a, K: 'a, V: 'a> { + inner: Iter<'a, K, V>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Keys<'_, K, V> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.clone()).finish() + } +} + +/// An iterator over the values of a `BTreeMap`. +/// +/// This `struct` is created by the [`values`] method on [`BTreeMap`]. See its +/// documentation for more. +/// +/// [`values`]: BTreeMap::values +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Values<'a, K: 'a, V: 'a> { + inner: Iter<'a, K, V>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Values<'_, K, V> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.clone()).finish() + } +} + +/// A mutable iterator over the values of a `BTreeMap`. +/// +/// This `struct` is created by the [`values_mut`] method on [`BTreeMap`]. See its +/// documentation for more. +/// +/// [`values_mut`]: BTreeMap::values_mut +#[stable(feature = "map_values_mut", since = "1.10.0")] +pub struct ValuesMut<'a, K: 'a, V: 'a> { + inner: IterMut<'a, K, V>, +} + +#[stable(feature = "map_values_mut", since = "1.10.0")] +impl fmt::Debug for ValuesMut<'_, K, V> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.inner.iter().map(|(_, val)| val)).finish() + } +} + +/// An owning iterator over the keys of a `BTreeMap`. +/// +/// This `struct` is created by the [`into_keys`] method on [`BTreeMap`]. +/// See its documentation for more. +/// +/// [`into_keys`]: BTreeMap::into_keys +#[unstable(feature = "map_into_keys_values", issue = "75294")] +pub struct IntoKeys { + inner: IntoIter, +} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl fmt::Debug for IntoKeys { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.inner.iter().map(|(key, _)| key)).finish() + } +} + +/// An owning iterator over the values of a `BTreeMap`. +/// +/// This `struct` is created by the [`into_values`] method on [`BTreeMap`]. +/// See its documentation for more. +/// +/// [`into_values`]: BTreeMap::into_values +#[unstable(feature = "map_into_keys_values", issue = "75294")] +pub struct IntoValues { + inner: IntoIter, +} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl fmt::Debug for IntoValues { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.inner.iter().map(|(_, val)| val)).finish() + } +} + +/// An iterator over a sub-range of entries in a `BTreeMap`. +/// +/// This `struct` is created by the [`range`] method on [`BTreeMap`]. See its +/// documentation for more. +/// +/// [`range`]: BTreeMap::range +#[stable(feature = "btree_range", since = "1.17.0")] +pub struct Range<'a, K: 'a, V: 'a> { + front: Option, K, V, marker::Leaf>, marker::Edge>>, + back: Option, K, V, marker::Leaf>, marker::Edge>>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Range<'_, K, V> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.clone()).finish() + } +} + +/// A mutable iterator over a sub-range of entries in a `BTreeMap`. +/// +/// This `struct` is created by the [`range_mut`] method on [`BTreeMap`]. See its +/// documentation for more. +/// +/// [`range_mut`]: BTreeMap::range_mut +#[stable(feature = "btree_range", since = "1.17.0")] +pub struct RangeMut<'a, K: 'a, V: 'a> { + front: Option, K, V, marker::Leaf>, marker::Edge>>, + back: Option, K, V, marker::Leaf>, marker::Edge>>, + + // Be invariant in `K` and `V` + _marker: PhantomData<&'a mut (K, V)>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for RangeMut<'_, K, V> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let range = Range { + front: self.front.as_ref().map(|f| f.reborrow()), + back: self.back.as_ref().map(|b| b.reborrow()), + }; + f.debug_list().entries(range).finish() + } +} + +impl BTreeMap { + /// Makes a new empty BTreeMap. + /// + /// Does not allocate anything on its own. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// + /// // entries can now be inserted into the empty map + /// map.insert(1, "a"); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_const_unstable(feature = "const_btree_new", issue = "71835")] + pub const fn new() -> BTreeMap { + BTreeMap { root: None, length: 0 } + } + + /// Clears the map, removing all elements. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// a.insert(1, "a"); + /// a.clear(); + /// assert!(a.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn clear(&mut self) { + *self = BTreeMap::new(); + } + + /// Returns a reference to the value corresponding to the key. + /// + /// The key may be any borrowed form of the map's key type, but the ordering + /// on the borrowed form *must* match the ordering on the key type. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// assert_eq!(map.get(&1), Some(&"a")); + /// assert_eq!(map.get(&2), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn get(&self, key: &Q) -> Option<&V> + where + K: Borrow, + Q: Ord, + { + let root_node = self.root.as_ref()?.node_as_ref(); + match search::search_tree(root_node, key) { + Found(handle) => Some(handle.into_kv().1), + GoDown(_) => None, + } + } + + /// Returns the key-value pair corresponding to the supplied key. + /// + /// The supplied key may be any borrowed form of the map's key type, but the ordering + /// on the borrowed form *must* match the ordering on the key type. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// assert_eq!(map.get_key_value(&1), Some((&1, &"a"))); + /// assert_eq!(map.get_key_value(&2), None); + /// ``` + #[stable(feature = "map_get_key_value", since = "1.40.0")] + pub fn get_key_value(&self, k: &Q) -> Option<(&K, &V)> + where + K: Borrow, + Q: Ord, + { + let root_node = self.root.as_ref()?.node_as_ref(); + match search::search_tree(root_node, k) { + Found(handle) => Some(handle.into_kv()), + GoDown(_) => None, + } + } + + /// Returns the first key-value pair in the map. + /// The key in this pair is the minimum key in the map. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// assert_eq!(map.first_key_value(), None); + /// map.insert(1, "b"); + /// map.insert(2, "a"); + /// assert_eq!(map.first_key_value(), Some((&1, &"b"))); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn first_key_value(&self) -> Option<(&K, &V)> { + let root_node = self.root.as_ref()?.node_as_ref(); + root_node.first_leaf_edge().right_kv().ok().map(Handle::into_kv) + } + + /// Returns the first entry in the map for in-place manipulation. + /// The key of this entry is the minimum key in the map. + /// + /// # Examples + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// map.insert(2, "b"); + /// if let Some(mut entry) = map.first_entry() { + /// if *entry.key() > 0 { + /// entry.insert("first"); + /// } + /// } + /// assert_eq!(*map.get(&1).unwrap(), "first"); + /// assert_eq!(*map.get(&2).unwrap(), "b"); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn first_entry(&mut self) -> Option> { + let (map, dormant_map) = DormantMutRef::new(self); + let root_node = map.root.as_mut()?.node_as_mut(); + let kv = root_node.first_leaf_edge().right_kv().ok()?; + Some(OccupiedEntry { handle: kv.forget_node_type(), dormant_map, _marker: PhantomData }) + } + + /// Removes and returns the first element in the map. + /// The key of this element is the minimum key that was in the map. + /// + /// # Examples + /// + /// Draining elements in ascending order, while keeping a usable map each iteration. + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// map.insert(2, "b"); + /// while let Some((key, _val)) = map.pop_first() { + /// assert!(map.iter().all(|(k, _v)| *k > key)); + /// } + /// assert!(map.is_empty()); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn pop_first(&mut self) -> Option<(K, V)> { + self.first_entry().map(|entry| entry.remove_entry()) + } + + /// Returns the last key-value pair in the map. + /// The key in this pair is the maximum key in the map. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "b"); + /// map.insert(2, "a"); + /// assert_eq!(map.last_key_value(), Some((&2, &"a"))); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn last_key_value(&self) -> Option<(&K, &V)> { + let root_node = self.root.as_ref()?.node_as_ref(); + root_node.last_leaf_edge().left_kv().ok().map(Handle::into_kv) + } + + /// Returns the last entry in the map for in-place manipulation. + /// The key of this entry is the maximum key in the map. + /// + /// # Examples + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// map.insert(2, "b"); + /// if let Some(mut entry) = map.last_entry() { + /// if *entry.key() > 0 { + /// entry.insert("last"); + /// } + /// } + /// assert_eq!(*map.get(&1).unwrap(), "a"); + /// assert_eq!(*map.get(&2).unwrap(), "last"); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn last_entry(&mut self) -> Option> { + let (map, dormant_map) = DormantMutRef::new(self); + let root_node = map.root.as_mut()?.node_as_mut(); + let kv = root_node.last_leaf_edge().left_kv().ok()?; + Some(OccupiedEntry { handle: kv.forget_node_type(), dormant_map, _marker: PhantomData }) + } + + /// Removes and returns the last element in the map. + /// The key of this element is the maximum key that was in the map. + /// + /// # Examples + /// + /// Draining elements in descending order, while keeping a usable map each iteration. + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// map.insert(2, "b"); + /// while let Some((key, _val)) = map.pop_last() { + /// assert!(map.iter().all(|(k, _v)| *k < key)); + /// } + /// assert!(map.is_empty()); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn pop_last(&mut self) -> Option<(K, V)> { + self.last_entry().map(|entry| entry.remove_entry()) + } + + /// Returns `true` if the map contains a value for the specified key. + /// + /// The key may be any borrowed form of the map's key type, but the ordering + /// on the borrowed form *must* match the ordering on the key type. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// assert_eq!(map.contains_key(&1), true); + /// assert_eq!(map.contains_key(&2), false); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn contains_key(&self, key: &Q) -> bool + where + K: Borrow, + Q: Ord, + { + self.get(key).is_some() + } + + /// Returns a mutable reference to the value corresponding to the key. + /// + /// The key may be any borrowed form of the map's key type, but the ordering + /// on the borrowed form *must* match the ordering on the key type. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// if let Some(x) = map.get_mut(&1) { + /// *x = "b"; + /// } + /// assert_eq!(map[&1], "b"); + /// ``` + // See `get` for implementation notes, this is basically a copy-paste with mut's added + #[stable(feature = "rust1", since = "1.0.0")] + pub fn get_mut(&mut self, key: &Q) -> Option<&mut V> + where + K: Borrow, + Q: Ord, + { + let root_node = self.root.as_mut()?.node_as_mut(); + match search::search_tree(root_node, key) { + Found(handle) => Some(handle.into_val_mut()), + GoDown(_) => None, + } + } + + /// Inserts a key-value pair into the map. + /// + /// If the map did not have this key present, `None` is returned. + /// + /// If the map did have this key present, the value is updated, and the old + /// value is returned. The key is not updated, though; this matters for + /// types that can be `==` without being identical. See the [module-level + /// documentation] for more. + /// + /// [module-level documentation]: index.html#insert-and-complex-keys + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// assert_eq!(map.insert(37, "a"), None); + /// assert_eq!(map.is_empty(), false); + /// + /// map.insert(37, "b"); + /// assert_eq!(map.insert(37, "c"), Some("b")); + /// assert_eq!(map[&37], "c"); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn insert(&mut self, key: K, value: V) -> Option { + match self.entry(key) { + Occupied(mut entry) => Some(entry.insert(value)), + Vacant(entry) => { + entry.insert(value); + None + } + } + } + + /// Removes a key from the map, returning the value at the key if the key + /// was previously in the map. + /// + /// The key may be any borrowed form of the map's key type, but the ordering + /// on the borrowed form *must* match the ordering on the key type. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// assert_eq!(map.remove(&1), Some("a")); + /// assert_eq!(map.remove(&1), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn remove(&mut self, key: &Q) -> Option + where + K: Borrow, + Q: Ord, + { + self.remove_entry(key).map(|(_, v)| v) + } + + /// Removes a key from the map, returning the stored key and value if the key + /// was previously in the map. + /// + /// The key may be any borrowed form of the map's key type, but the ordering + /// on the borrowed form *must* match the ordering on the key type. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// assert_eq!(map.remove_entry(&1), Some((1, "a"))); + /// assert_eq!(map.remove_entry(&1), None); + /// ``` + #[stable(feature = "btreemap_remove_entry", since = "1.45.0")] + pub fn remove_entry(&mut self, key: &Q) -> Option<(K, V)> + where + K: Borrow, + Q: Ord, + { + let (map, dormant_map) = DormantMutRef::new(self); + let root_node = map.root.as_mut()?.node_as_mut(); + match search::search_tree(root_node, key) { + Found(handle) => { + Some(OccupiedEntry { handle, dormant_map, _marker: PhantomData }.remove_entry()) + } + GoDown(_) => None, + } + } + + /// Moves all elements from `other` into `Self`, leaving `other` empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// a.insert(1, "a"); + /// a.insert(2, "b"); + /// a.insert(3, "c"); + /// + /// let mut b = BTreeMap::new(); + /// b.insert(3, "d"); + /// b.insert(4, "e"); + /// b.insert(5, "f"); + /// + /// a.append(&mut b); + /// + /// assert_eq!(a.len(), 5); + /// assert_eq!(b.len(), 0); + /// + /// assert_eq!(a[&1], "a"); + /// assert_eq!(a[&2], "b"); + /// assert_eq!(a[&3], "d"); + /// assert_eq!(a[&4], "e"); + /// assert_eq!(a[&5], "f"); + /// ``` + #[stable(feature = "btree_append", since = "1.11.0")] + pub fn append(&mut self, other: &mut Self) { + // Do we have to append anything at all? + if other.is_empty() { + return; + } + + // We can just swap `self` and `other` if `self` is empty. + if self.is_empty() { + mem::swap(self, other); + return; + } + + let self_iter = mem::take(self).into_iter(); + let other_iter = mem::take(other).into_iter(); + let root = BTreeMap::ensure_is_owned(&mut self.root); + root.append_from_sorted_iters(self_iter, other_iter, &mut self.length) + } + + /// Constructs a double-ended iterator over a sub-range of elements in the map. + /// The simplest way is to use the range syntax `min..max`, thus `range(min..max)` will + /// yield elements from min (inclusive) to max (exclusive). + /// The range may also be entered as `(Bound, Bound)`, so for example + /// `range((Excluded(4), Included(10)))` will yield a left-exclusive, right-inclusive + /// range from 4 to 10. + /// + /// # Panics + /// + /// Panics if range `start > end`. + /// Panics if range `start == end` and both bounds are `Excluded`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// use std::ops::Bound::Included; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(3, "a"); + /// map.insert(5, "b"); + /// map.insert(8, "c"); + /// for (&key, &value) in map.range((Included(&4), Included(&8))) { + /// println!("{}: {}", key, value); + /// } + /// assert_eq!(Some((&5, &"b")), map.range(4..).next()); + /// ``` + #[stable(feature = "btree_range", since = "1.17.0")] + pub fn range(&self, range: R) -> Range<'_, K, V> + where + T: Ord, + K: Borrow, + R: RangeBounds, + { + if let Some(root) = &self.root { + let (f, b) = root.node_as_ref().range_search(range); + + Range { front: Some(f), back: Some(b) } + } else { + Range { front: None, back: None } + } + } + + /// Constructs a mutable double-ended iterator over a sub-range of elements in the map. + /// The simplest way is to use the range syntax `min..max`, thus `range(min..max)` will + /// yield elements from min (inclusive) to max (exclusive). + /// The range may also be entered as `(Bound, Bound)`, so for example + /// `range((Excluded(4), Included(10)))` will yield a left-exclusive, right-inclusive + /// range from 4 to 10. + /// + /// # Panics + /// + /// Panics if range `start > end`. + /// Panics if range `start == end` and both bounds are `Excluded`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap<&str, i32> = ["Alice", "Bob", "Carol", "Cheryl"] + /// .iter() + /// .map(|&s| (s, 0)) + /// .collect(); + /// for (_, balance) in map.range_mut("B".."Cheryl") { + /// *balance += 100; + /// } + /// for (name, balance) in &map { + /// println!("{} => {}", name, balance); + /// } + /// ``` + #[stable(feature = "btree_range", since = "1.17.0")] + pub fn range_mut(&mut self, range: R) -> RangeMut<'_, K, V> + where + T: Ord, + K: Borrow, + R: RangeBounds, + { + if let Some(root) = &mut self.root { + let (f, b) = root.node_as_valmut().range_search(range); + + RangeMut { front: Some(f), back: Some(b), _marker: PhantomData } + } else { + RangeMut { front: None, back: None, _marker: PhantomData } + } + } + + /// Gets the given key's corresponding entry in the map for in-place manipulation. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut count: BTreeMap<&str, usize> = BTreeMap::new(); + /// + /// // count the number of occurrences of letters in the vec + /// for x in vec!["a","b","a","c","a","b"] { + /// *count.entry(x).or_insert(0) += 1; + /// } + /// + /// assert_eq!(count["a"], 3); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn entry(&mut self, key: K) -> Entry<'_, K, V> { + // FIXME(@porglezomp) Avoid allocating if we don't insert + let (map, dormant_map) = DormantMutRef::new(self); + let root_node = Self::ensure_is_owned(&mut map.root).node_as_mut(); + match search::search_tree(root_node, &key) { + Found(handle) => Occupied(OccupiedEntry { handle, dormant_map, _marker: PhantomData }), + GoDown(handle) => { + Vacant(VacantEntry { key, handle, dormant_map, _marker: PhantomData }) + } + } + } + + /// Splits the collection into two at the given key. Returns everything after the given key, + /// including the key. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// a.insert(1, "a"); + /// a.insert(2, "b"); + /// a.insert(3, "c"); + /// a.insert(17, "d"); + /// a.insert(41, "e"); + /// + /// let b = a.split_off(&3); + /// + /// assert_eq!(a.len(), 2); + /// assert_eq!(b.len(), 3); + /// + /// assert_eq!(a[&1], "a"); + /// assert_eq!(a[&2], "b"); + /// + /// assert_eq!(b[&3], "c"); + /// assert_eq!(b[&17], "d"); + /// assert_eq!(b[&41], "e"); + /// ``` + #[stable(feature = "btree_split_off", since = "1.11.0")] + pub fn split_off(&mut self, key: &Q) -> Self + where + K: Borrow, + { + if self.is_empty() { + return Self::new(); + } + + let total_num = self.len(); + let left_root = self.root.as_mut().unwrap(); // unwrap succeeds because not empty + + let mut right = Self::new(); + let right_root = Self::ensure_is_owned(&mut right.root); + + left_root.split_off(right_root, key); + + if left_root.height() < right_root.height() { + self.length = left_root.node_as_ref().calc_length(); + right.length = total_num - self.len(); + } else { + right.length = right_root.node_as_ref().calc_length(); + self.length = total_num - right.len(); + } + + right + } + + /// Creates an iterator which uses a closure to determine if an element should be removed. + /// + /// If the closure returns true, the element is removed from the map and yielded. + /// If the closure returns false, or panics, the element remains in the map and will not be + /// yielded. + /// + /// Note that `drain_filter` lets you mutate every value in the filter closure, regardless of + /// whether you choose to keep or remove it. + /// + /// If the iterator is only partially consumed or not consumed at all, each of the remaining + /// elements will still be subjected to the closure and removed and dropped if it returns true. + /// + /// It is unspecified how many more elements will be subjected to the closure + /// if a panic occurs in the closure, or a panic occurs while dropping an element, + /// or if the `DrainFilter` value is leaked. + /// + /// # Examples + /// + /// Splitting a map into even and odd keys, reusing the original map: + /// + /// ``` + /// #![feature(btree_drain_filter)] + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap = (0..8).map(|x| (x, x)).collect(); + /// let evens: BTreeMap<_, _> = map.drain_filter(|k, _v| k % 2 == 0).collect(); + /// let odds = map; + /// assert_eq!(evens.keys().copied().collect::>(), vec![0, 2, 4, 6]); + /// assert_eq!(odds.keys().copied().collect::>(), vec![1, 3, 5, 7]); + /// ``` + #[unstable(feature = "btree_drain_filter", issue = "70530")] + pub fn drain_filter(&mut self, pred: F) -> DrainFilter<'_, K, V, F> + where + F: FnMut(&K, &mut V) -> bool, + { + DrainFilter { pred, inner: self.drain_filter_inner() } + } + + pub(super) fn drain_filter_inner(&mut self) -> DrainFilterInner<'_, K, V> { + if let Some(root) = self.root.as_mut() { + let (root, dormant_root) = DormantMutRef::new(root); + let front = root.node_as_mut().first_leaf_edge(); + DrainFilterInner { + length: &mut self.length, + dormant_root: Some(dormant_root), + cur_leaf_edge: Some(front), + } + } else { + DrainFilterInner { length: &mut self.length, dormant_root: None, cur_leaf_edge: None } + } + } + + /// Creates a consuming iterator visiting all the keys, in sorted order. + /// The map cannot be used after calling this. + /// The iterator element type is `K`. + /// + /// # Examples + /// + /// ``` + /// #![feature(map_into_keys_values)] + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// a.insert(2, "b"); + /// a.insert(1, "a"); + /// + /// let keys: Vec = a.into_keys().collect(); + /// assert_eq!(keys, [1, 2]); + /// ``` + #[inline] + #[unstable(feature = "map_into_keys_values", issue = "75294")] + pub fn into_keys(self) -> IntoKeys { + IntoKeys { inner: self.into_iter() } + } + + /// Creates a consuming iterator visiting all the values, in order by key. + /// The map cannot be used after calling this. + /// The iterator element type is `V`. + /// + /// # Examples + /// + /// ``` + /// #![feature(map_into_keys_values)] + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// a.insert(1, "hello"); + /// a.insert(2, "goodbye"); + /// + /// let values: Vec<&str> = a.into_values().collect(); + /// assert_eq!(values, ["hello", "goodbye"]); + /// ``` + #[inline] + #[unstable(feature = "map_into_keys_values", issue = "75294")] + pub fn into_values(self) -> IntoValues { + IntoValues { inner: self.into_iter() } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K, V> IntoIterator for &'a BTreeMap { + type Item = (&'a K, &'a V); + type IntoIter = Iter<'a, K, V>; + + fn into_iter(self) -> Iter<'a, K, V> { + self.iter() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K: 'a, V: 'a> Iterator for Iter<'a, K, V> { + type Item = (&'a K, &'a V); + + fn next(&mut self) -> Option<(&'a K, &'a V)> { + if self.length == 0 { + None + } else { + self.length -= 1; + unsafe { Some(self.range.next_unchecked()) } + } + } + + fn size_hint(&self) -> (usize, Option) { + (self.length, Some(self.length)) + } + + fn last(mut self) -> Option<(&'a K, &'a V)> { + self.next_back() + } + + fn min(mut self) -> Option<(&'a K, &'a V)> { + self.next() + } + + fn max(mut self) -> Option<(&'a K, &'a V)> { + self.next_back() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Iter<'_, K, V> {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K: 'a, V: 'a> DoubleEndedIterator for Iter<'a, K, V> { + fn next_back(&mut self) -> Option<(&'a K, &'a V)> { + if self.length == 0 { + None + } else { + self.length -= 1; + unsafe { Some(self.range.next_back_unchecked()) } + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for Iter<'_, K, V> { + fn len(&self) -> usize { + self.length + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Iter<'_, K, V> { + fn clone(&self) -> Self { + Iter { range: self.range.clone(), length: self.length } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K, V> IntoIterator for &'a mut BTreeMap { + type Item = (&'a K, &'a mut V); + type IntoIter = IterMut<'a, K, V>; + + fn into_iter(self) -> IterMut<'a, K, V> { + self.iter_mut() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K: 'a, V: 'a> Iterator for IterMut<'a, K, V> { + type Item = (&'a K, &'a mut V); + + fn next(&mut self) -> Option<(&'a K, &'a mut V)> { + if self.length == 0 { + None + } else { + self.length -= 1; + let (k, v) = unsafe { self.range.next_unchecked() }; + Some((k, v)) // coerce k from `&mut K` to `&K` + } + } + + fn size_hint(&self) -> (usize, Option) { + (self.length, Some(self.length)) + } + + fn last(mut self) -> Option<(&'a K, &'a mut V)> { + self.next_back() + } + + fn min(mut self) -> Option<(&'a K, &'a mut V)> { + self.next() + } + + fn max(mut self) -> Option<(&'a K, &'a mut V)> { + self.next_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K: 'a, V: 'a> DoubleEndedIterator for IterMut<'a, K, V> { + fn next_back(&mut self) -> Option<(&'a K, &'a mut V)> { + if self.length == 0 { + None + } else { + self.length -= 1; + let (k, v) = unsafe { self.range.next_back_unchecked() }; + Some((k, v)) // coerce k from `&mut K` to `&K` + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for IterMut<'_, K, V> { + fn len(&self) -> usize { + self.length + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for IterMut<'_, K, V> {} + +impl<'a, K, V> IterMut<'a, K, V> { + /// Returns an iterator of references over the remaining items. + #[inline] + pub(super) fn iter(&self) -> Iter<'_, K, V> { + Iter { range: self.range.iter(), length: self.length } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl IntoIterator for BTreeMap { + type Item = (K, V); + type IntoIter = IntoIter; + + fn into_iter(self) -> IntoIter { + let mut me = ManuallyDrop::new(self); + if let Some(root) = me.root.take() { + let (f, b) = root.into_ref().full_range(); + + IntoIter { front: Some(f), back: Some(b), length: me.length } + } else { + IntoIter { front: None, back: None, length: 0 } + } + } +} + +#[stable(feature = "btree_drop", since = "1.7.0")] +impl Drop for IntoIter { + fn drop(&mut self) { + struct DropGuard<'a, K, V>(&'a mut IntoIter); + + impl<'a, K, V> Drop for DropGuard<'a, K, V> { + fn drop(&mut self) { + // Continue the same loop we perform below. This only runs when unwinding, so we + // don't have to care about panics this time (they'll abort). + while let Some(_) = self.0.next() {} + + unsafe { + let mut node = + unwrap_unchecked(ptr::read(&self.0.front)).into_node().forget_type(); + while let Some(parent) = node.deallocate_and_ascend() { + node = parent.into_node().forget_type(); + } + } + } + } + + while let Some(pair) = self.next() { + let guard = DropGuard(self); + drop(pair); + mem::forget(guard); + } + + unsafe { + if let Some(front) = ptr::read(&self.front) { + let mut node = front.into_node().forget_type(); + // Most of the nodes have been deallocated while traversing + // but one pile from a leaf up to the root is left standing. + while let Some(parent) = node.deallocate_and_ascend() { + node = parent.into_node().forget_type(); + } + } + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Iterator for IntoIter { + type Item = (K, V); + + fn next(&mut self) -> Option<(K, V)> { + if self.length == 0 { + None + } else { + self.length -= 1; + Some(unsafe { self.front.as_mut().unwrap().next_unchecked() }) + } + } + + fn size_hint(&self) -> (usize, Option) { + (self.length, Some(self.length)) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl DoubleEndedIterator for IntoIter { + fn next_back(&mut self) -> Option<(K, V)> { + if self.length == 0 { + None + } else { + self.length -= 1; + Some(unsafe { self.back.as_mut().unwrap().next_back_unchecked() }) + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for IntoIter { + fn len(&self) -> usize { + self.length + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for IntoIter {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K, V> Iterator for Keys<'a, K, V> { + type Item = &'a K; + + fn next(&mut self) -> Option<&'a K> { + self.inner.next().map(|(k, _)| k) + } + + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } + + fn last(mut self) -> Option<&'a K> { + self.next_back() + } + + fn min(mut self) -> Option<&'a K> { + self.next() + } + + fn max(mut self) -> Option<&'a K> { + self.next_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V> { + fn next_back(&mut self) -> Option<&'a K> { + self.inner.next_back().map(|(k, _)| k) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for Keys<'_, K, V> { + fn len(&self) -> usize { + self.inner.len() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Keys<'_, K, V> {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Keys<'_, K, V> { + fn clone(&self) -> Self { + Keys { inner: self.inner.clone() } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K, V> Iterator for Values<'a, K, V> { + type Item = &'a V; + + fn next(&mut self) -> Option<&'a V> { + self.inner.next().map(|(_, v)| v) + } + + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } + + fn last(mut self) -> Option<&'a V> { + self.next_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> { + fn next_back(&mut self) -> Option<&'a V> { + self.inner.next_back().map(|(_, v)| v) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for Values<'_, K, V> { + fn len(&self) -> usize { + self.inner.len() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Values<'_, K, V> {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Values<'_, K, V> { + fn clone(&self) -> Self { + Values { inner: self.inner.clone() } + } +} + +/// An iterator produced by calling `drain_filter` on BTreeMap. +#[unstable(feature = "btree_drain_filter", issue = "70530")] +pub struct DrainFilter<'a, K, V, F> +where + K: 'a, + V: 'a, + F: 'a + FnMut(&K, &mut V) -> bool, +{ + pred: F, + inner: DrainFilterInner<'a, K, V>, +} +/// Most of the implementation of DrainFilter, independent of the type +/// of the predicate, thus also serving for BTreeSet::DrainFilter. +pub(super) struct DrainFilterInner<'a, K: 'a, V: 'a> { + /// Reference to the length field in the borrowed map, updated live. + length: &'a mut usize, + /// Burried reference to the root field in the borrowed map. + /// Wrapped in `Option` to allow drop handler to `take` it. + dormant_root: Option>>, + /// Contains a leaf edge preceding the next element to be returned, or the last leaf edge. + /// Empty if the map has no root, if iteration went beyond the last leaf edge, + /// or if a panic occurred in the predicate. + cur_leaf_edge: Option, K, V, marker::Leaf>, marker::Edge>>, +} + +#[unstable(feature = "btree_drain_filter", issue = "70530")] +impl Drop for DrainFilter<'_, K, V, F> +where + F: FnMut(&K, &mut V) -> bool, +{ + fn drop(&mut self) { + self.for_each(drop); + } +} + +#[unstable(feature = "btree_drain_filter", issue = "70530")] +impl fmt::Debug for DrainFilter<'_, K, V, F> +where + K: fmt::Debug, + V: fmt::Debug, + F: FnMut(&K, &mut V) -> bool, +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("DrainFilter").field(&self.inner.peek()).finish() + } +} + +#[unstable(feature = "btree_drain_filter", issue = "70530")] +impl Iterator for DrainFilter<'_, K, V, F> +where + F: FnMut(&K, &mut V) -> bool, +{ + type Item = (K, V); + + fn next(&mut self) -> Option<(K, V)> { + self.inner.next(&mut self.pred) + } + + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } +} + +impl<'a, K: 'a, V: 'a> DrainFilterInner<'a, K, V> { + /// Allow Debug implementations to predict the next element. + pub(super) fn peek(&self) -> Option<(&K, &V)> { + let edge = self.cur_leaf_edge.as_ref()?; + edge.reborrow().next_kv().ok().map(Handle::into_kv) + } + + /// Implementation of a typical `DrainFilter::next` method, given the predicate. + pub(super) fn next(&mut self, pred: &mut F) -> Option<(K, V)> + where + F: FnMut(&K, &mut V) -> bool, + { + while let Ok(mut kv) = self.cur_leaf_edge.take()?.next_kv() { + let (k, v) = kv.kv_mut(); + if pred(k, v) { + *self.length -= 1; + let (kv, pos) = kv.remove_kv_tracking(|| { + // SAFETY: we will touch the root in a way that will not + // invalidate the position returned. + let root = unsafe { self.dormant_root.take().unwrap().awaken() }; + root.pop_internal_level(); + self.dormant_root = Some(DormantMutRef::new(root).1); + }); + self.cur_leaf_edge = Some(pos); + return Some(kv); + } + self.cur_leaf_edge = Some(kv.next_leaf_edge()); + } + None + } + + /// Implementation of a typical `DrainFilter::size_hint` method. + pub(super) fn size_hint(&self) -> (usize, Option) { + // In most of the btree iterators, `self.length` is the number of elements + // yet to be visited. Here, it includes elements that were visited and that + // the predicate decided not to drain. Making this upper bound more accurate + // requires maintaining an extra field and is not worth while. + (0, Some(*self.length)) + } +} + +#[unstable(feature = "btree_drain_filter", issue = "70530")] +impl FusedIterator for DrainFilter<'_, K, V, F> where F: FnMut(&K, &mut V) -> bool {} + +#[stable(feature = "btree_range", since = "1.17.0")] +impl<'a, K, V> Iterator for Range<'a, K, V> { + type Item = (&'a K, &'a V); + + fn next(&mut self) -> Option<(&'a K, &'a V)> { + if self.is_empty() { None } else { unsafe { Some(self.next_unchecked()) } } + } + + fn last(mut self) -> Option<(&'a K, &'a V)> { + self.next_back() + } + + fn min(mut self) -> Option<(&'a K, &'a V)> { + self.next() + } + + fn max(mut self) -> Option<(&'a K, &'a V)> { + self.next_back() + } +} + +#[stable(feature = "map_values_mut", since = "1.10.0")] +impl<'a, K, V> Iterator for ValuesMut<'a, K, V> { + type Item = &'a mut V; + + fn next(&mut self) -> Option<&'a mut V> { + self.inner.next().map(|(_, v)| v) + } + + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } + + fn last(mut self) -> Option<&'a mut V> { + self.next_back() + } +} + +#[stable(feature = "map_values_mut", since = "1.10.0")] +impl<'a, K, V> DoubleEndedIterator for ValuesMut<'a, K, V> { + fn next_back(&mut self) -> Option<&'a mut V> { + self.inner.next_back().map(|(_, v)| v) + } +} + +#[stable(feature = "map_values_mut", since = "1.10.0")] +impl ExactSizeIterator for ValuesMut<'_, K, V> { + fn len(&self) -> usize { + self.inner.len() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for ValuesMut<'_, K, V> {} + +impl<'a, K, V> Range<'a, K, V> { + fn is_empty(&self) -> bool { + self.front == self.back + } + + unsafe fn next_unchecked(&mut self) -> (&'a K, &'a V) { + unsafe { unwrap_unchecked(self.front.as_mut()).next_unchecked() } + } +} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl Iterator for IntoKeys { + type Item = K; + + fn next(&mut self) -> Option { + self.inner.next().map(|(k, _)| k) + } + + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } + + fn last(mut self) -> Option { + self.next_back() + } + + fn min(mut self) -> Option { + self.next() + } + + fn max(mut self) -> Option { + self.next_back() + } +} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl DoubleEndedIterator for IntoKeys { + fn next_back(&mut self) -> Option { + self.inner.next_back().map(|(k, _)| k) + } +} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl ExactSizeIterator for IntoKeys { + fn len(&self) -> usize { + self.inner.len() + } +} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl FusedIterator for IntoKeys {} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl Iterator for IntoValues { + type Item = V; + + fn next(&mut self) -> Option { + self.inner.next().map(|(_, v)| v) + } + + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } + + fn last(mut self) -> Option { + self.next_back() + } +} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl DoubleEndedIterator for IntoValues { + fn next_back(&mut self) -> Option { + self.inner.next_back().map(|(_, v)| v) + } +} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl ExactSizeIterator for IntoValues { + fn len(&self) -> usize { + self.inner.len() + } +} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl FusedIterator for IntoValues {} + +#[stable(feature = "btree_range", since = "1.17.0")] +impl<'a, K, V> DoubleEndedIterator for Range<'a, K, V> { + fn next_back(&mut self) -> Option<(&'a K, &'a V)> { + if self.is_empty() { None } else { Some(unsafe { self.next_back_unchecked() }) } + } +} + +impl<'a, K, V> Range<'a, K, V> { + unsafe fn next_back_unchecked(&mut self) -> (&'a K, &'a V) { + unsafe { unwrap_unchecked(self.back.as_mut()).next_back_unchecked() } + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Range<'_, K, V> {} + +#[stable(feature = "btree_range", since = "1.17.0")] +impl Clone for Range<'_, K, V> { + fn clone(&self) -> Self { + Range { front: self.front, back: self.back } + } +} + +#[stable(feature = "btree_range", since = "1.17.0")] +impl<'a, K, V> Iterator for RangeMut<'a, K, V> { + type Item = (&'a K, &'a mut V); + + fn next(&mut self) -> Option<(&'a K, &'a mut V)> { + if self.is_empty() { + None + } else { + let (k, v) = unsafe { self.next_unchecked() }; + Some((k, v)) // coerce k from `&mut K` to `&K` + } + } + + fn last(mut self) -> Option<(&'a K, &'a mut V)> { + self.next_back() + } + + fn min(mut self) -> Option<(&'a K, &'a mut V)> { + self.next() + } + + fn max(mut self) -> Option<(&'a K, &'a mut V)> { + self.next_back() + } +} + +impl<'a, K, V> RangeMut<'a, K, V> { + fn is_empty(&self) -> bool { + self.front == self.back + } + + unsafe fn next_unchecked(&mut self) -> (&'a K, &'a mut V) { + unsafe { unwrap_unchecked(self.front.as_mut()).next_unchecked() } + } + + /// Returns an iterator of references over the remaining items. + #[inline] + pub(super) fn iter(&self) -> Range<'_, K, V> { + Range { + front: self.front.as_ref().map(|f| f.reborrow()), + back: self.back.as_ref().map(|b| b.reborrow()), + } + } +} + +#[stable(feature = "btree_range", since = "1.17.0")] +impl<'a, K, V> DoubleEndedIterator for RangeMut<'a, K, V> { + fn next_back(&mut self) -> Option<(&'a K, &'a mut V)> { + if self.is_empty() { + None + } else { + let (k, v) = unsafe { self.next_back_unchecked() }; + Some((k, v)) // coerce k from `&mut K` to `&K` + } + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for RangeMut<'_, K, V> {} + +impl<'a, K, V> RangeMut<'a, K, V> { + unsafe fn next_back_unchecked(&mut self) -> (&'a K, &'a mut V) { + unsafe { unwrap_unchecked(self.back.as_mut()).next_back_unchecked() } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl FromIterator<(K, V)> for BTreeMap { + fn from_iter>(iter: T) -> BTreeMap { + let mut map = BTreeMap::new(); + map.extend(iter); + map + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Extend<(K, V)> for BTreeMap { + #[inline] + fn extend>(&mut self, iter: T) { + iter.into_iter().for_each(move |(k, v)| { + self.insert(k, v); + }); + } + + #[inline] + fn extend_one(&mut self, (k, v): (K, V)) { + self.insert(k, v); + } +} + +#[stable(feature = "extend_ref", since = "1.2.0")] +impl<'a, K: Ord + Copy, V: Copy> Extend<(&'a K, &'a V)> for BTreeMap { + fn extend>(&mut self, iter: I) { + self.extend(iter.into_iter().map(|(&key, &value)| (key, value))); + } + + #[inline] + fn extend_one(&mut self, (&k, &v): (&'a K, &'a V)) { + self.insert(k, v); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Hash for BTreeMap { + fn hash(&self, state: &mut H) { + for elt in self { + elt.hash(state); + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for BTreeMap { + /// Creates an empty `BTreeMap`. + fn default() -> BTreeMap { + BTreeMap::new() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialEq for BTreeMap { + fn eq(&self, other: &BTreeMap) -> bool { + self.len() == other.len() && self.iter().zip(other).all(|(a, b)| a == b) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Eq for BTreeMap {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialOrd for BTreeMap { + #[inline] + fn partial_cmp(&self, other: &BTreeMap) -> Option { + self.iter().partial_cmp(other.iter()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Ord for BTreeMap { + #[inline] + fn cmp(&self, other: &BTreeMap) -> Ordering { + self.iter().cmp(other.iter()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Debug for BTreeMap { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_map().entries(self.iter()).finish() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Index<&Q> for BTreeMap +where + K: Borrow, + Q: Ord, +{ + type Output = V; + + /// Returns a reference to the value corresponding to the supplied key. + /// + /// # Panics + /// + /// Panics if the key is not present in the `BTreeMap`. + #[inline] + fn index(&self, key: &Q) -> &V { + self.get(key).expect("no entry found for key") + } +} + +impl BTreeMap { + /// Gets an iterator over the entries of the map, sorted by key. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(3, "c"); + /// map.insert(2, "b"); + /// map.insert(1, "a"); + /// + /// for (key, value) in map.iter() { + /// println!("{}: {}", key, value); + /// } + /// + /// let (first_key, first_value) = map.iter().next().unwrap(); + /// assert_eq!((*first_key, *first_value), (1, "a")); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn iter(&self) -> Iter<'_, K, V> { + if let Some(root) = &self.root { + let (f, b) = root.node_as_ref().full_range(); + + Iter { range: Range { front: Some(f), back: Some(b) }, length: self.length } + } else { + Iter { range: Range { front: None, back: None }, length: 0 } + } + } + + /// Gets a mutable iterator over the entries of the map, sorted by key. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert("a", 1); + /// map.insert("b", 2); + /// map.insert("c", 3); + /// + /// // add 10 to the value if the key isn't "a" + /// for (key, value) in map.iter_mut() { + /// if key != &"a" { + /// *value += 10; + /// } + /// } + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn iter_mut(&mut self) -> IterMut<'_, K, V> { + if let Some(root) = &mut self.root { + let (f, b) = root.node_as_valmut().full_range(); + + IterMut { + range: RangeMut { front: Some(f), back: Some(b), _marker: PhantomData }, + length: self.length, + } + } else { + IterMut { range: RangeMut { front: None, back: None, _marker: PhantomData }, length: 0 } + } + } + + /// Gets an iterator over the keys of the map, in sorted order. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// a.insert(2, "b"); + /// a.insert(1, "a"); + /// + /// let keys: Vec<_> = a.keys().cloned().collect(); + /// assert_eq!(keys, [1, 2]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn keys(&self) -> Keys<'_, K, V> { + Keys { inner: self.iter() } + } + + /// Gets an iterator over the values of the map, in order by key. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// a.insert(1, "hello"); + /// a.insert(2, "goodbye"); + /// + /// let values: Vec<&str> = a.values().cloned().collect(); + /// assert_eq!(values, ["hello", "goodbye"]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn values(&self) -> Values<'_, K, V> { + Values { inner: self.iter() } + } + + /// Gets a mutable iterator over the values of the map, in order by key. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// a.insert(1, String::from("hello")); + /// a.insert(2, String::from("goodbye")); + /// + /// for value in a.values_mut() { + /// value.push_str("!"); + /// } + /// + /// let values: Vec = a.values().cloned().collect(); + /// assert_eq!(values, [String::from("hello!"), + /// String::from("goodbye!")]); + /// ``` + #[stable(feature = "map_values_mut", since = "1.10.0")] + pub fn values_mut(&mut self) -> ValuesMut<'_, K, V> { + ValuesMut { inner: self.iter_mut() } + } + + /// Returns the number of elements in the map. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// assert_eq!(a.len(), 0); + /// a.insert(1, "a"); + /// assert_eq!(a.len(), 1); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_const_unstable(feature = "const_btree_new", issue = "71835")] + pub const fn len(&self) -> usize { + self.length + } + + /// Returns `true` if the map contains no elements. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// assert!(a.is_empty()); + /// a.insert(1, "a"); + /// assert!(!a.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_const_unstable(feature = "const_btree_new", issue = "71835")] + pub const fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// If the root node is the empty (non-allocated) root node, allocate our + /// own node. Is an associated function to avoid borrowing the entire BTreeMap. + fn ensure_is_owned(root: &mut Option>) -> &mut node::Root { + root.get_or_insert_with(node::Root::new_leaf) + } +} + +#[cfg(test)] +mod tests; diff --git a/libgrust/rustc-lib/alloc/src/collections/btree/map/entry.rs b/libgrust/rustc-lib/alloc/src/collections/btree/map/entry.rs new file mode 100644 index 000000000000..73a0ca21f673 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/btree/map/entry.rs @@ -0,0 +1,475 @@ +use core::fmt::{self, Debug}; +use core::marker::PhantomData; +use core::mem; + +use super::super::borrow::DormantMutRef; +use super::super::node::{marker, Handle, InsertResult::*, NodeRef}; +use super::BTreeMap; + +use Entry::*; + +/// A view into a single entry in a map, which may either be vacant or occupied. +/// +/// This `enum` is constructed from the [`entry`] method on [`BTreeMap`]. +/// +/// [`entry`]: BTreeMap::entry +#[stable(feature = "rust1", since = "1.0.0")] +pub enum Entry<'a, K: 'a, V: 'a> { + /// A vacant entry. + #[stable(feature = "rust1", since = "1.0.0")] + Vacant(#[stable(feature = "rust1", since = "1.0.0")] VacantEntry<'a, K, V>), + + /// An occupied entry. + #[stable(feature = "rust1", since = "1.0.0")] + Occupied(#[stable(feature = "rust1", since = "1.0.0")] OccupiedEntry<'a, K, V>), +} + +#[stable(feature = "debug_btree_map", since = "1.12.0")] +impl Debug for Entry<'_, K, V> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match *self { + Vacant(ref v) => f.debug_tuple("Entry").field(v).finish(), + Occupied(ref o) => f.debug_tuple("Entry").field(o).finish(), + } + } +} + +/// A view into a vacant entry in a `BTreeMap`. +/// It is part of the [`Entry`] enum. +#[stable(feature = "rust1", since = "1.0.0")] +pub struct VacantEntry<'a, K: 'a, V: 'a> { + pub(super) key: K, + pub(super) handle: Handle, K, V, marker::Leaf>, marker::Edge>, + pub(super) dormant_map: DormantMutRef<'a, BTreeMap>, + + // Be invariant in `K` and `V` + pub(super) _marker: PhantomData<&'a mut (K, V)>, +} + +#[stable(feature = "debug_btree_map", since = "1.12.0")] +impl Debug for VacantEntry<'_, K, V> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("VacantEntry").field(self.key()).finish() + } +} + +/// A view into an occupied entry in a `BTreeMap`. +/// It is part of the [`Entry`] enum. +#[stable(feature = "rust1", since = "1.0.0")] +pub struct OccupiedEntry<'a, K: 'a, V: 'a> { + pub(super) handle: Handle, K, V, marker::LeafOrInternal>, marker::KV>, + pub(super) dormant_map: DormantMutRef<'a, BTreeMap>, + + // Be invariant in `K` and `V` + pub(super) _marker: PhantomData<&'a mut (K, V)>, +} + +#[stable(feature = "debug_btree_map", since = "1.12.0")] +impl Debug for OccupiedEntry<'_, K, V> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("OccupiedEntry").field("key", self.key()).field("value", self.get()).finish() + } +} + +impl<'a, K: Ord, V> Entry<'a, K, V> { + /// Ensures a value is in the entry by inserting the default if empty, and returns + /// a mutable reference to the value in the entry. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// map.entry("poneyland").or_insert(12); + /// + /// assert_eq!(map["poneyland"], 12); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn or_insert(self, default: V) -> &'a mut V { + match self { + Occupied(entry) => entry.into_mut(), + Vacant(entry) => entry.insert(default), + } + } + + /// Ensures a value is in the entry by inserting the result of the default function if empty, + /// and returns a mutable reference to the value in the entry. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap<&str, String> = BTreeMap::new(); + /// let s = "hoho".to_string(); + /// + /// map.entry("poneyland").or_insert_with(|| s); + /// + /// assert_eq!(map["poneyland"], "hoho".to_string()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn or_insert_with V>(self, default: F) -> &'a mut V { + match self { + Occupied(entry) => entry.into_mut(), + Vacant(entry) => entry.insert(default()), + } + } + + #[unstable(feature = "or_insert_with_key", issue = "71024")] + /// Ensures a value is in the entry by inserting, if empty, the result of the default function, + /// which takes the key as its argument, and returns a mutable reference to the value in the + /// entry. + /// + /// # Examples + /// + /// ``` + /// #![feature(or_insert_with_key)] + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// + /// map.entry("poneyland").or_insert_with_key(|key| key.chars().count()); + /// + /// assert_eq!(map["poneyland"], 9); + /// ``` + #[inline] + pub fn or_insert_with_key V>(self, default: F) -> &'a mut V { + match self { + Occupied(entry) => entry.into_mut(), + Vacant(entry) => { + let value = default(entry.key()); + entry.insert(value) + } + } + } + + /// Returns a reference to this entry's key. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// assert_eq!(map.entry("poneyland").key(), &"poneyland"); + /// ``` + #[stable(feature = "map_entry_keys", since = "1.10.0")] + pub fn key(&self) -> &K { + match *self { + Occupied(ref entry) => entry.key(), + Vacant(ref entry) => entry.key(), + } + } + + /// Provides in-place mutable access to an occupied entry before any + /// potential inserts into the map. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// + /// map.entry("poneyland") + /// .and_modify(|e| { *e += 1 }) + /// .or_insert(42); + /// assert_eq!(map["poneyland"], 42); + /// + /// map.entry("poneyland") + /// .and_modify(|e| { *e += 1 }) + /// .or_insert(42); + /// assert_eq!(map["poneyland"], 43); + /// ``` + #[stable(feature = "entry_and_modify", since = "1.26.0")] + pub fn and_modify(self, f: F) -> Self + where + F: FnOnce(&mut V), + { + match self { + Occupied(mut entry) => { + f(entry.get_mut()); + Occupied(entry) + } + Vacant(entry) => Vacant(entry), + } + } +} + +impl<'a, K: Ord, V: Default> Entry<'a, K, V> { + #[stable(feature = "entry_or_default", since = "1.28.0")] + /// Ensures a value is in the entry by inserting the default value if empty, + /// and returns a mutable reference to the value in the entry. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap<&str, Option> = BTreeMap::new(); + /// map.entry("poneyland").or_default(); + /// + /// assert_eq!(map["poneyland"], None); + /// ``` + pub fn or_default(self) -> &'a mut V { + match self { + Occupied(entry) => entry.into_mut(), + Vacant(entry) => entry.insert(Default::default()), + } + } +} + +impl<'a, K: Ord, V> VacantEntry<'a, K, V> { + /// Gets a reference to the key that would be used when inserting a value + /// through the VacantEntry. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// assert_eq!(map.entry("poneyland").key(), &"poneyland"); + /// ``` + #[stable(feature = "map_entry_keys", since = "1.10.0")] + pub fn key(&self) -> &K { + &self.key + } + + /// Take ownership of the key. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// use std::collections::btree_map::Entry; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// + /// if let Entry::Vacant(v) = map.entry("poneyland") { + /// v.into_key(); + /// } + /// ``` + #[stable(feature = "map_entry_recover_keys2", since = "1.12.0")] + pub fn into_key(self) -> K { + self.key + } + + /// Sets the value of the entry with the `VacantEntry`'s key, + /// and returns a mutable reference to it. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// use std::collections::btree_map::Entry; + /// + /// let mut map: BTreeMap<&str, u32> = BTreeMap::new(); + /// + /// if let Entry::Vacant(o) = map.entry("poneyland") { + /// o.insert(37); + /// } + /// assert_eq!(map["poneyland"], 37); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn insert(self, value: V) -> &'a mut V { + let out_ptr = match self.handle.insert_recursing(self.key, value) { + (Fit(_), val_ptr) => { + // Safety: We have consumed self.handle and the handle returned. + let map = unsafe { self.dormant_map.awaken() }; + map.length += 1; + val_ptr + } + (Split(ins), val_ptr) => { + drop(ins.left); + // Safety: We have consumed self.handle and the reference returned. + let map = unsafe { self.dormant_map.awaken() }; + let root = map.root.as_mut().unwrap(); + root.push_internal_level().push(ins.k, ins.v, ins.right); + map.length += 1; + val_ptr + } + }; + // Now that we have finished growing the tree using borrowed references, + // dereference the pointer to a part of it, that we picked up along the way. + unsafe { &mut *out_ptr } + } +} + +impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> { + /// Gets a reference to the key in the entry. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// map.entry("poneyland").or_insert(12); + /// assert_eq!(map.entry("poneyland").key(), &"poneyland"); + /// ``` + #[stable(feature = "map_entry_keys", since = "1.10.0")] + pub fn key(&self) -> &K { + self.handle.reborrow().into_kv().0 + } + + /// Take ownership of the key and value from the map. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// use std::collections::btree_map::Entry; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// map.entry("poneyland").or_insert(12); + /// + /// if let Entry::Occupied(o) = map.entry("poneyland") { + /// // We delete the entry from the map. + /// o.remove_entry(); + /// } + /// + /// // If now try to get the value, it will panic: + /// // println!("{}", map["poneyland"]); + /// ``` + #[stable(feature = "map_entry_recover_keys2", since = "1.12.0")] + pub fn remove_entry(self) -> (K, V) { + self.remove_kv() + } + + /// Gets a reference to the value in the entry. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// use std::collections::btree_map::Entry; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// map.entry("poneyland").or_insert(12); + /// + /// if let Entry::Occupied(o) = map.entry("poneyland") { + /// assert_eq!(o.get(), &12); + /// } + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn get(&self) -> &V { + self.handle.reborrow().into_kv().1 + } + + /// Gets a mutable reference to the value in the entry. + /// + /// If you need a reference to the `OccupiedEntry` that may outlive the + /// destruction of the `Entry` value, see [`into_mut`]. + /// + /// [`into_mut`]: OccupiedEntry::into_mut + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// use std::collections::btree_map::Entry; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// map.entry("poneyland").or_insert(12); + /// + /// assert_eq!(map["poneyland"], 12); + /// if let Entry::Occupied(mut o) = map.entry("poneyland") { + /// *o.get_mut() += 10; + /// assert_eq!(*o.get(), 22); + /// + /// // We can use the same Entry multiple times. + /// *o.get_mut() += 2; + /// } + /// assert_eq!(map["poneyland"], 24); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn get_mut(&mut self) -> &mut V { + self.handle.kv_mut().1 + } + + /// Converts the entry into a mutable reference to its value. + /// + /// If you need multiple references to the `OccupiedEntry`, see [`get_mut`]. + /// + /// [`get_mut`]: OccupiedEntry::get_mut + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// use std::collections::btree_map::Entry; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// map.entry("poneyland").or_insert(12); + /// + /// assert_eq!(map["poneyland"], 12); + /// if let Entry::Occupied(o) = map.entry("poneyland") { + /// *o.into_mut() += 10; + /// } + /// assert_eq!(map["poneyland"], 22); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn into_mut(self) -> &'a mut V { + self.handle.into_val_mut() + } + + /// Sets the value of the entry with the `OccupiedEntry`'s key, + /// and returns the entry's old value. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// use std::collections::btree_map::Entry; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// map.entry("poneyland").or_insert(12); + /// + /// if let Entry::Occupied(mut o) = map.entry("poneyland") { + /// assert_eq!(o.insert(15), 12); + /// } + /// assert_eq!(map["poneyland"], 15); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn insert(&mut self, value: V) -> V { + mem::replace(self.get_mut(), value) + } + + /// Takes the value of the entry out of the map, and returns it. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// use std::collections::btree_map::Entry; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// map.entry("poneyland").or_insert(12); + /// + /// if let Entry::Occupied(o) = map.entry("poneyland") { + /// assert_eq!(o.remove(), 12); + /// } + /// // If we try to get "poneyland"'s value, it'll panic: + /// // println!("{}", map["poneyland"]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn remove(self) -> V { + self.remove_kv().1 + } + + // Body of `remove_entry`, separate to keep the above implementations short. + pub(super) fn remove_kv(self) -> (K, V) { + let mut emptied_internal_root = false; + let (old_kv, _) = self.handle.remove_kv_tracking(|| emptied_internal_root = true); + // SAFETY: we consumed the intermediate root borrow, `self.handle`. + let map = unsafe { self.dormant_map.awaken() }; + map.length -= 1; + if emptied_internal_root { + let root = map.root.as_mut().unwrap(); + root.pop_internal_level(); + } + old_kv + } +} diff --git a/libgrust/rustc-lib/alloc/src/collections/btree/map/tests.rs b/libgrust/rustc-lib/alloc/src/collections/btree/map/tests.rs new file mode 100644 index 000000000000..dd3ebcccf76a --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/btree/map/tests.rs @@ -0,0 +1,1884 @@ +use super::super::{node, DeterministicRng}; +use super::Entry::{Occupied, Vacant}; +use super::*; +use crate::boxed::Box; +use crate::fmt::Debug; +use crate::rc::Rc; +use crate::string::{String, ToString}; +use crate::vec::Vec; +use std::convert::TryFrom; +use std::iter::{self, FromIterator}; +use std::mem; +use std::ops::Bound::{self, Excluded, Included, Unbounded}; +use std::ops::RangeBounds; +use std::panic::{catch_unwind, AssertUnwindSafe}; +use std::sync::atomic::{AtomicUsize, Ordering}; + +// Capacity of a tree with a single level, +// i.e., a tree who's root is a leaf node at height 0. +const NODE_CAPACITY: usize = node::CAPACITY; + +// Minimum number of elements to insert, to guarantee a tree with 2 levels, +// i.e., a tree who's root is an internal node at height 1, with edges to leaf nodes. +// It's not the minimum size: removing an element from such a tree does not always reduce height. +const MIN_INSERTS_HEIGHT_1: usize = NODE_CAPACITY + 1; + +// Minimum number of elements to insert in ascending order, to guarantee a tree with 3 levels, +// i.e., a tree who's root is an internal node at height 2, with edges to more internal nodes. +// It's not the minimum size: removing an element from such a tree does not always reduce height. +const MIN_INSERTS_HEIGHT_2: usize = 89; + +// Gather all references from a mutable iterator and make sure Miri notices if +// using them is dangerous. +fn test_all_refs<'a, T: 'a>(dummy: &mut T, iter: impl Iterator) { + // Gather all those references. + let mut refs: Vec<&mut T> = iter.collect(); + // Use them all. Twice, to be sure we got all interleavings. + for r in refs.iter_mut() { + mem::swap(dummy, r); + } + for r in refs { + mem::swap(dummy, r); + } +} + +impl BTreeMap { + /// Panics if the map (or the code navigating it) is corrupted. + fn check(&self) + where + K: Copy + Debug + Ord, + { + if let Some(root) = &self.root { + let root_node = root.node_as_ref(); + + assert!(root_node.ascend().is_err()); + root_node.assert_back_pointers(); + + assert_eq!(self.length, root_node.calc_length()); + + root_node.assert_min_len(if root_node.height() > 0 { 1 } else { 0 }); + } else { + assert_eq!(self.length, 0); + } + + self.assert_ascending(); + } + + /// Returns the height of the root, if any. + fn height(&self) -> Option { + self.root.as_ref().map(node::Root::height) + } + + fn dump_keys(&self) -> String + where + K: Debug, + { + if let Some(root) = self.root.as_ref() { + root.node_as_ref().dump_keys() + } else { + String::from("not yet allocated") + } + } + + /// Asserts that the keys are in strictly ascending order. + fn assert_ascending(&self) + where + K: Copy + Debug + Ord, + { + let mut num_seen = 0; + let mut keys = self.keys(); + if let Some(mut previous) = keys.next() { + num_seen = 1; + for next in keys { + assert!(previous < next, "{:?} >= {:?}", previous, next); + previous = next; + num_seen += 1; + } + } + assert_eq!(num_seen, self.len()); + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::LeafOrInternal> { + fn assert_min_len(self, min_len: usize) { + assert!(self.len() >= min_len, "{} < {}", self.len(), min_len); + if let node::ForceResult::Internal(node) = self.force() { + for idx in 0..=node.len() { + let edge = unsafe { Handle::new_edge(node, idx) }; + edge.descend().assert_min_len(MIN_LEN); + } + } + } +} + +// Test our value of MIN_INSERTS_HEIGHT_2. It may change according to the +// implementation of insertion, but it's best to be aware of when it does. +#[test] +fn test_levels() { + let mut map = BTreeMap::new(); + map.check(); + assert_eq!(map.height(), None); + assert_eq!(map.len(), 0); + + map.insert(0, ()); + while map.height() == Some(0) { + let last_key = *map.last_key_value().unwrap().0; + map.insert(last_key + 1, ()); + } + map.check(); + // Structure: + // - 1 element in internal root node with 2 children + // - 6 elements in left leaf child + // - 5 elements in right leaf child + assert_eq!(map.height(), Some(1)); + assert_eq!(map.len(), MIN_INSERTS_HEIGHT_1, "{}", map.dump_keys()); + + while map.height() == Some(1) { + let last_key = *map.last_key_value().unwrap().0; + map.insert(last_key + 1, ()); + } + map.check(); + // Structure: + // - 1 element in internal root node with 2 children + // - 6 elements in left internal child with 7 grandchildren + // - 42 elements in left child's 7 grandchildren with 6 elements each + // - 5 elements in right internal child with 6 grandchildren + // - 30 elements in right child's 5 first grandchildren with 6 elements each + // - 5 elements in right child's last grandchild + assert_eq!(map.height(), Some(2)); + assert_eq!(map.len(), MIN_INSERTS_HEIGHT_2, "{}", map.dump_keys()); +} + +#[test] +fn test_basic_large() { + let mut map = BTreeMap::new(); + // Miri is too slow + let size = if cfg!(miri) { MIN_INSERTS_HEIGHT_2 } else { 10000 }; + let size = size + (size % 2); // round up to even number + assert_eq!(map.len(), 0); + + for i in 0..size { + assert_eq!(map.insert(i, 10 * i), None); + assert_eq!(map.len(), i + 1); + } + + assert_eq!(map.first_key_value(), Some((&0, &0))); + assert_eq!(map.last_key_value(), Some((&(size - 1), &(10 * (size - 1))))); + assert_eq!(map.first_entry().unwrap().key(), &0); + assert_eq!(map.last_entry().unwrap().key(), &(size - 1)); + + for i in 0..size { + assert_eq!(map.get(&i).unwrap(), &(i * 10)); + } + + for i in size..size * 2 { + assert_eq!(map.get(&i), None); + } + + for i in 0..size { + assert_eq!(map.insert(i, 100 * i), Some(10 * i)); + assert_eq!(map.len(), size); + } + + for i in 0..size { + assert_eq!(map.get(&i).unwrap(), &(i * 100)); + } + + for i in 0..size / 2 { + assert_eq!(map.remove(&(i * 2)), Some(i * 200)); + assert_eq!(map.len(), size - i - 1); + } + + for i in 0..size / 2 { + assert_eq!(map.get(&(2 * i)), None); + assert_eq!(map.get(&(2 * i + 1)).unwrap(), &(i * 200 + 100)); + } + + for i in 0..size / 2 { + assert_eq!(map.remove(&(2 * i)), None); + assert_eq!(map.remove(&(2 * i + 1)), Some(i * 200 + 100)); + assert_eq!(map.len(), size / 2 - i - 1); + } + map.check(); +} + +#[test] +fn test_basic_small() { + let mut map = BTreeMap::new(); + // Empty, root is absent (None): + assert_eq!(map.remove(&1), None); + assert_eq!(map.len(), 0); + assert_eq!(map.get(&1), None); + assert_eq!(map.get_mut(&1), None); + assert_eq!(map.first_key_value(), None); + assert_eq!(map.last_key_value(), None); + assert_eq!(map.keys().count(), 0); + assert_eq!(map.values().count(), 0); + assert_eq!(map.range(..).next(), None); + assert_eq!(map.range(..1).next(), None); + assert_eq!(map.range(1..).next(), None); + assert_eq!(map.range(1..=1).next(), None); + assert_eq!(map.range(1..2).next(), None); + assert_eq!(map.height(), None); + assert_eq!(map.insert(1, 1), None); + assert_eq!(map.height(), Some(0)); + map.check(); + + // 1 key-value pair: + assert_eq!(map.len(), 1); + assert_eq!(map.get(&1), Some(&1)); + assert_eq!(map.get_mut(&1), Some(&mut 1)); + assert_eq!(map.first_key_value(), Some((&1, &1))); + assert_eq!(map.last_key_value(), Some((&1, &1))); + assert_eq!(map.keys().collect::>(), vec![&1]); + assert_eq!(map.values().collect::>(), vec![&1]); + assert_eq!(map.insert(1, 2), Some(1)); + assert_eq!(map.len(), 1); + assert_eq!(map.get(&1), Some(&2)); + assert_eq!(map.get_mut(&1), Some(&mut 2)); + assert_eq!(map.first_key_value(), Some((&1, &2))); + assert_eq!(map.last_key_value(), Some((&1, &2))); + assert_eq!(map.keys().collect::>(), vec![&1]); + assert_eq!(map.values().collect::>(), vec![&2]); + assert_eq!(map.insert(2, 4), None); + assert_eq!(map.height(), Some(0)); + map.check(); + + // 2 key-value pairs: + assert_eq!(map.len(), 2); + assert_eq!(map.get(&2), Some(&4)); + assert_eq!(map.get_mut(&2), Some(&mut 4)); + assert_eq!(map.first_key_value(), Some((&1, &2))); + assert_eq!(map.last_key_value(), Some((&2, &4))); + assert_eq!(map.keys().collect::>(), vec![&1, &2]); + assert_eq!(map.values().collect::>(), vec![&2, &4]); + assert_eq!(map.remove(&1), Some(2)); + assert_eq!(map.height(), Some(0)); + map.check(); + + // 1 key-value pair: + assert_eq!(map.len(), 1); + assert_eq!(map.get(&1), None); + assert_eq!(map.get_mut(&1), None); + assert_eq!(map.get(&2), Some(&4)); + assert_eq!(map.get_mut(&2), Some(&mut 4)); + assert_eq!(map.first_key_value(), Some((&2, &4))); + assert_eq!(map.last_key_value(), Some((&2, &4))); + assert_eq!(map.keys().collect::>(), vec![&2]); + assert_eq!(map.values().collect::>(), vec![&4]); + assert_eq!(map.remove(&2), Some(4)); + assert_eq!(map.height(), Some(0)); + map.check(); + + // Empty but root is owned (Some(...)): + assert_eq!(map.len(), 0); + assert_eq!(map.get(&1), None); + assert_eq!(map.get_mut(&1), None); + assert_eq!(map.first_key_value(), None); + assert_eq!(map.last_key_value(), None); + assert_eq!(map.keys().count(), 0); + assert_eq!(map.values().count(), 0); + assert_eq!(map.range(..).next(), None); + assert_eq!(map.range(..1).next(), None); + assert_eq!(map.range(1..).next(), None); + assert_eq!(map.range(1..=1).next(), None); + assert_eq!(map.range(1..2).next(), None); + assert_eq!(map.remove(&1), None); + assert_eq!(map.height(), Some(0)); + map.check(); +} + +#[test] +fn test_iter() { + // Miri is too slow + let size = if cfg!(miri) { 200 } else { 10000 }; + + let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); + + fn test(size: usize, mut iter: T) + where + T: Iterator, + { + for i in 0..size { + assert_eq!(iter.size_hint(), (size - i, Some(size - i))); + assert_eq!(iter.next().unwrap(), (i, i)); + } + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + } + test(size, map.iter().map(|(&k, &v)| (k, v))); + test(size, map.iter_mut().map(|(&k, &mut v)| (k, v))); + test(size, map.into_iter()); +} + +#[test] +fn test_iter_rev() { + // Miri is too slow + let size = if cfg!(miri) { 200 } else { 10000 }; + + let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); + + fn test(size: usize, mut iter: T) + where + T: Iterator, + { + for i in 0..size { + assert_eq!(iter.size_hint(), (size - i, Some(size - i))); + assert_eq!(iter.next().unwrap(), (size - i - 1, size - i - 1)); + } + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + } + test(size, map.iter().rev().map(|(&k, &v)| (k, v))); + test(size, map.iter_mut().rev().map(|(&k, &mut v)| (k, v))); + test(size, map.into_iter().rev()); +} + +/// Specifically tests iter_mut's ability to mutate the value of pairs in-line +fn do_test_iter_mut_mutation(size: usize) +where + T: Copy + Debug + Ord + TryFrom, + >::Error: Debug, +{ + let zero = T::try_from(0).unwrap(); + let mut map: BTreeMap = (0..size).map(|i| (T::try_from(i).unwrap(), zero)).collect(); + + // Forward and backward iteration sees enough pairs (also tested elsewhere) + assert_eq!(map.iter_mut().count(), size); + assert_eq!(map.iter_mut().rev().count(), size); + + // Iterate forwards, trying to mutate to unique values + for (i, (k, v)) in map.iter_mut().enumerate() { + assert_eq!(*k, T::try_from(i).unwrap()); + assert_eq!(*v, zero); + *v = T::try_from(i + 1).unwrap(); + } + + // Iterate backwards, checking that mutations succeeded and trying to mutate again + for (i, (k, v)) in map.iter_mut().rev().enumerate() { + assert_eq!(*k, T::try_from(size - i - 1).unwrap()); + assert_eq!(*v, T::try_from(size - i).unwrap()); + *v = T::try_from(2 * size - i).unwrap(); + } + + // Check that backward mutations succeeded + for (i, (k, v)) in map.iter_mut().enumerate() { + assert_eq!(*k, T::try_from(i).unwrap()); + assert_eq!(*v, T::try_from(size + i + 1).unwrap()); + } + map.check(); +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord)] +#[repr(align(32))] +struct Align32(usize); + +impl TryFrom for Align32 { + type Error = (); + + fn try_from(s: usize) -> Result { + Ok(Align32(s)) + } +} + +#[test] +fn test_iter_mut_mutation() { + // Check many alignments and trees with roots at various heights. + do_test_iter_mut_mutation::(0); + do_test_iter_mut_mutation::(1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_2); + do_test_iter_mut_mutation::(1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_2); + do_test_iter_mut_mutation::(1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_2); + do_test_iter_mut_mutation::(1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_2); + do_test_iter_mut_mutation::(1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_2); + do_test_iter_mut_mutation::(1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_2); +} + +#[test] +fn test_values_mut() { + let mut a: BTreeMap<_, _> = (0..MIN_INSERTS_HEIGHT_2).map(|i| (i, i)).collect(); + test_all_refs(&mut 13, a.values_mut()); + a.check(); +} + +#[test] +fn test_values_mut_mutation() { + let mut a = BTreeMap::new(); + a.insert(1, String::from("hello")); + a.insert(2, String::from("goodbye")); + + for value in a.values_mut() { + value.push_str("!"); + } + + let values: Vec = a.values().cloned().collect(); + assert_eq!(values, [String::from("hello!"), String::from("goodbye!")]); + a.check(); +} + +#[test] +fn test_iter_entering_root_twice() { + let mut map: BTreeMap<_, _> = (0..2).map(|i| (i, i)).collect(); + let mut it = map.iter_mut(); + let front = it.next().unwrap(); + let back = it.next_back().unwrap(); + assert_eq!(front, (&0, &mut 0)); + assert_eq!(back, (&1, &mut 1)); + *front.1 = 24; + *back.1 = 42; + assert_eq!(front, (&0, &mut 24)); + assert_eq!(back, (&1, &mut 42)); + map.check(); +} + +#[test] +fn test_iter_descending_to_same_node_twice() { + let mut map: BTreeMap<_, _> = (0..MIN_INSERTS_HEIGHT_1).map(|i| (i, i)).collect(); + let mut it = map.iter_mut(); + // Descend into first child. + let front = it.next().unwrap(); + // Descend into first child again, after running through second child. + while it.next_back().is_some() {} + // Check immutable access. + assert_eq!(front, (&0, &mut 0)); + // Perform mutable access. + *front.1 = 42; + map.check(); +} + +#[test] +fn test_iter_mixed() { + // Miri is too slow + let size = if cfg!(miri) { 200 } else { 10000 }; + + let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); + + fn test(size: usize, mut iter: T) + where + T: Iterator + DoubleEndedIterator, + { + for i in 0..size / 4 { + assert_eq!(iter.size_hint(), (size - i * 2, Some(size - i * 2))); + assert_eq!(iter.next().unwrap(), (i, i)); + assert_eq!(iter.next_back().unwrap(), (size - i - 1, size - i - 1)); + } + for i in size / 4..size * 3 / 4 { + assert_eq!(iter.size_hint(), (size * 3 / 4 - i, Some(size * 3 / 4 - i))); + assert_eq!(iter.next().unwrap(), (i, i)); + } + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + } + test(size, map.iter().map(|(&k, &v)| (k, v))); + test(size, map.iter_mut().map(|(&k, &mut v)| (k, v))); + test(size, map.into_iter()); +} + +#[test] +fn test_iter_min_max() { + let mut a = BTreeMap::new(); + assert_eq!(a.iter().min(), None); + assert_eq!(a.iter().max(), None); + assert_eq!(a.iter_mut().min(), None); + assert_eq!(a.iter_mut().max(), None); + assert_eq!(a.range(..).min(), None); + assert_eq!(a.range(..).max(), None); + assert_eq!(a.range_mut(..).min(), None); + assert_eq!(a.range_mut(..).max(), None); + assert_eq!(a.keys().min(), None); + assert_eq!(a.keys().max(), None); + assert_eq!(a.values().min(), None); + assert_eq!(a.values().max(), None); + assert_eq!(a.values_mut().min(), None); + assert_eq!(a.values_mut().max(), None); + a.insert(1, 42); + a.insert(2, 24); + assert_eq!(a.iter().min(), Some((&1, &42))); + assert_eq!(a.iter().max(), Some((&2, &24))); + assert_eq!(a.iter_mut().min(), Some((&1, &mut 42))); + assert_eq!(a.iter_mut().max(), Some((&2, &mut 24))); + assert_eq!(a.range(..).min(), Some((&1, &42))); + assert_eq!(a.range(..).max(), Some((&2, &24))); + assert_eq!(a.range_mut(..).min(), Some((&1, &mut 42))); + assert_eq!(a.range_mut(..).max(), Some((&2, &mut 24))); + assert_eq!(a.keys().min(), Some(&1)); + assert_eq!(a.keys().max(), Some(&2)); + assert_eq!(a.values().min(), Some(&24)); + assert_eq!(a.values().max(), Some(&42)); + assert_eq!(a.values_mut().min(), Some(&mut 24)); + assert_eq!(a.values_mut().max(), Some(&mut 42)); + a.check(); +} + +fn range_keys(map: &BTreeMap, range: impl RangeBounds) -> Vec { + map.range(range) + .map(|(&k, &v)| { + assert_eq!(k, v); + k + }) + .collect() +} + +#[test] +fn test_range_small() { + let size = 4; + + let map: BTreeMap<_, _> = (1..=size).map(|i| (i, i)).collect(); + let all: Vec<_> = (1..=size).collect(); + let (first, last) = (vec![all[0]], vec![all[size as usize - 1]]); + + assert_eq!(range_keys(&map, (Excluded(0), Excluded(size + 1))), all); + assert_eq!(range_keys(&map, (Excluded(0), Included(size + 1))), all); + assert_eq!(range_keys(&map, (Excluded(0), Included(size))), all); + assert_eq!(range_keys(&map, (Excluded(0), Unbounded)), all); + assert_eq!(range_keys(&map, (Included(0), Excluded(size + 1))), all); + assert_eq!(range_keys(&map, (Included(0), Included(size + 1))), all); + assert_eq!(range_keys(&map, (Included(0), Included(size))), all); + assert_eq!(range_keys(&map, (Included(0), Unbounded)), all); + assert_eq!(range_keys(&map, (Included(1), Excluded(size + 1))), all); + assert_eq!(range_keys(&map, (Included(1), Included(size + 1))), all); + assert_eq!(range_keys(&map, (Included(1), Included(size))), all); + assert_eq!(range_keys(&map, (Included(1), Unbounded)), all); + assert_eq!(range_keys(&map, (Unbounded, Excluded(size + 1))), all); + assert_eq!(range_keys(&map, (Unbounded, Included(size + 1))), all); + assert_eq!(range_keys(&map, (Unbounded, Included(size))), all); + assert_eq!(range_keys(&map, ..), all); + + assert_eq!(range_keys(&map, (Excluded(0), Excluded(1))), vec![]); + assert_eq!(range_keys(&map, (Excluded(0), Included(0))), vec![]); + assert_eq!(range_keys(&map, (Included(0), Included(0))), vec![]); + assert_eq!(range_keys(&map, (Included(0), Excluded(1))), vec![]); + assert_eq!(range_keys(&map, (Unbounded, Excluded(1))), vec![]); + assert_eq!(range_keys(&map, (Unbounded, Included(0))), vec![]); + assert_eq!(range_keys(&map, (Excluded(0), Excluded(2))), first); + assert_eq!(range_keys(&map, (Excluded(0), Included(1))), first); + assert_eq!(range_keys(&map, (Included(0), Excluded(2))), first); + assert_eq!(range_keys(&map, (Included(0), Included(1))), first); + assert_eq!(range_keys(&map, (Included(1), Excluded(2))), first); + assert_eq!(range_keys(&map, (Included(1), Included(1))), first); + assert_eq!(range_keys(&map, (Unbounded, Excluded(2))), first); + assert_eq!(range_keys(&map, (Unbounded, Included(1))), first); + assert_eq!(range_keys(&map, (Excluded(size - 1), Excluded(size + 1))), last); + assert_eq!(range_keys(&map, (Excluded(size - 1), Included(size + 1))), last); + assert_eq!(range_keys(&map, (Excluded(size - 1), Included(size))), last); + assert_eq!(range_keys(&map, (Excluded(size - 1), Unbounded)), last); + assert_eq!(range_keys(&map, (Included(size), Excluded(size + 1))), last); + assert_eq!(range_keys(&map, (Included(size), Included(size + 1))), last); + assert_eq!(range_keys(&map, (Included(size), Included(size))), last); + assert_eq!(range_keys(&map, (Included(size), Unbounded)), last); + assert_eq!(range_keys(&map, (Excluded(size), Excluded(size + 1))), vec![]); + assert_eq!(range_keys(&map, (Excluded(size), Included(size))), vec![]); + assert_eq!(range_keys(&map, (Excluded(size), Unbounded)), vec![]); + assert_eq!(range_keys(&map, (Included(size + 1), Excluded(size + 1))), vec![]); + assert_eq!(range_keys(&map, (Included(size + 1), Included(size + 1))), vec![]); + assert_eq!(range_keys(&map, (Included(size + 1), Unbounded)), vec![]); + + assert_eq!(range_keys(&map, ..3), vec![1, 2]); + assert_eq!(range_keys(&map, 3..), vec![3, 4]); + assert_eq!(range_keys(&map, 2..=3), vec![2, 3]); +} + +#[test] +fn test_range_height_1() { + // Tests tree with a root and 2 leaves. Depending on details we don't want or need + // to rely upon, the single key at the root will be 6 or 7. + + let map: BTreeMap<_, _> = (1..=MIN_INSERTS_HEIGHT_1 as i32).map(|i| (i, i)).collect(); + for &root in &[6, 7] { + assert_eq!(range_keys(&map, (Excluded(root), Excluded(root + 1))), vec![]); + assert_eq!(range_keys(&map, (Excluded(root), Included(root + 1))), vec![root + 1]); + assert_eq!(range_keys(&map, (Included(root), Excluded(root + 1))), vec![root]); + assert_eq!(range_keys(&map, (Included(root), Included(root + 1))), vec![root, root + 1]); + + assert_eq!(range_keys(&map, (Excluded(root - 1), Excluded(root))), vec![]); + assert_eq!(range_keys(&map, (Included(root - 1), Excluded(root))), vec![root - 1]); + assert_eq!(range_keys(&map, (Excluded(root - 1), Included(root))), vec![root]); + assert_eq!(range_keys(&map, (Included(root - 1), Included(root))), vec![root - 1, root]); + } +} + +#[test] +fn test_range_large() { + let size = 200; + + let map: BTreeMap<_, _> = (1..=size).map(|i| (i, i)).collect(); + let all: Vec<_> = (1..=size).collect(); + let (first, last) = (vec![all[0]], vec![all[size as usize - 1]]); + + assert_eq!(range_keys(&map, (Excluded(0), Excluded(size + 1))), all); + assert_eq!(range_keys(&map, (Excluded(0), Included(size + 1))), all); + assert_eq!(range_keys(&map, (Excluded(0), Included(size))), all); + assert_eq!(range_keys(&map, (Excluded(0), Unbounded)), all); + assert_eq!(range_keys(&map, (Included(0), Excluded(size + 1))), all); + assert_eq!(range_keys(&map, (Included(0), Included(size + 1))), all); + assert_eq!(range_keys(&map, (Included(0), Included(size))), all); + assert_eq!(range_keys(&map, (Included(0), Unbounded)), all); + assert_eq!(range_keys(&map, (Included(1), Excluded(size + 1))), all); + assert_eq!(range_keys(&map, (Included(1), Included(size + 1))), all); + assert_eq!(range_keys(&map, (Included(1), Included(size))), all); + assert_eq!(range_keys(&map, (Included(1), Unbounded)), all); + assert_eq!(range_keys(&map, (Unbounded, Excluded(size + 1))), all); + assert_eq!(range_keys(&map, (Unbounded, Included(size + 1))), all); + assert_eq!(range_keys(&map, (Unbounded, Included(size))), all); + assert_eq!(range_keys(&map, ..), all); + + assert_eq!(range_keys(&map, (Excluded(0), Excluded(1))), vec![]); + assert_eq!(range_keys(&map, (Excluded(0), Included(0))), vec![]); + assert_eq!(range_keys(&map, (Included(0), Included(0))), vec![]); + assert_eq!(range_keys(&map, (Included(0), Excluded(1))), vec![]); + assert_eq!(range_keys(&map, (Unbounded, Excluded(1))), vec![]); + assert_eq!(range_keys(&map, (Unbounded, Included(0))), vec![]); + assert_eq!(range_keys(&map, (Excluded(0), Excluded(2))), first); + assert_eq!(range_keys(&map, (Excluded(0), Included(1))), first); + assert_eq!(range_keys(&map, (Included(0), Excluded(2))), first); + assert_eq!(range_keys(&map, (Included(0), Included(1))), first); + assert_eq!(range_keys(&map, (Included(1), Excluded(2))), first); + assert_eq!(range_keys(&map, (Included(1), Included(1))), first); + assert_eq!(range_keys(&map, (Unbounded, Excluded(2))), first); + assert_eq!(range_keys(&map, (Unbounded, Included(1))), first); + assert_eq!(range_keys(&map, (Excluded(size - 1), Excluded(size + 1))), last); + assert_eq!(range_keys(&map, (Excluded(size - 1), Included(size + 1))), last); + assert_eq!(range_keys(&map, (Excluded(size - 1), Included(size))), last); + assert_eq!(range_keys(&map, (Excluded(size - 1), Unbounded)), last); + assert_eq!(range_keys(&map, (Included(size), Excluded(size + 1))), last); + assert_eq!(range_keys(&map, (Included(size), Included(size + 1))), last); + assert_eq!(range_keys(&map, (Included(size), Included(size))), last); + assert_eq!(range_keys(&map, (Included(size), Unbounded)), last); + assert_eq!(range_keys(&map, (Excluded(size), Excluded(size + 1))), vec![]); + assert_eq!(range_keys(&map, (Excluded(size), Included(size))), vec![]); + assert_eq!(range_keys(&map, (Excluded(size), Unbounded)), vec![]); + assert_eq!(range_keys(&map, (Included(size + 1), Excluded(size + 1))), vec![]); + assert_eq!(range_keys(&map, (Included(size + 1), Included(size + 1))), vec![]); + assert_eq!(range_keys(&map, (Included(size + 1), Unbounded)), vec![]); + + fn check<'a, L, R>(lhs: L, rhs: R) + where + L: IntoIterator, + R: IntoIterator, + { + let lhs: Vec<_> = lhs.into_iter().collect(); + let rhs: Vec<_> = rhs.into_iter().collect(); + assert_eq!(lhs, rhs); + } + + check(map.range(..=100), map.range(..101)); + check(map.range(5..=8), vec![(&5, &5), (&6, &6), (&7, &7), (&8, &8)]); + check(map.range(-1..=2), vec![(&1, &1), (&2, &2)]); +} + +#[test] +fn test_range_inclusive_max_value() { + let max = usize::MAX; + let map: BTreeMap<_, _> = vec![(max, 0)].into_iter().collect(); + + assert_eq!(map.range(max..=max).collect::>(), &[(&max, &0)]); +} + +#[test] +fn test_range_equal_empty_cases() { + let map: BTreeMap<_, _> = (0..5).map(|i| (i, i)).collect(); + assert_eq!(map.range((Included(2), Excluded(2))).next(), None); + assert_eq!(map.range((Excluded(2), Included(2))).next(), None); +} + +#[test] +#[should_panic] +fn test_range_equal_excluded() { + let map: BTreeMap<_, _> = (0..5).map(|i| (i, i)).collect(); + map.range((Excluded(2), Excluded(2))); +} + +#[test] +#[should_panic] +fn test_range_backwards_1() { + let map: BTreeMap<_, _> = (0..5).map(|i| (i, i)).collect(); + map.range((Included(3), Included(2))); +} + +#[test] +#[should_panic] +fn test_range_backwards_2() { + let map: BTreeMap<_, _> = (0..5).map(|i| (i, i)).collect(); + map.range((Included(3), Excluded(2))); +} + +#[test] +#[should_panic] +fn test_range_backwards_3() { + let map: BTreeMap<_, _> = (0..5).map(|i| (i, i)).collect(); + map.range((Excluded(3), Included(2))); +} + +#[test] +#[should_panic] +fn test_range_backwards_4() { + let map: BTreeMap<_, _> = (0..5).map(|i| (i, i)).collect(); + map.range((Excluded(3), Excluded(2))); +} + +#[test] +fn test_range_1000() { + // Miri is too slow + let size = if cfg!(miri) { MIN_INSERTS_HEIGHT_2 as u32 } else { 1000 }; + let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); + + fn test(map: &BTreeMap, size: u32, min: Bound<&u32>, max: Bound<&u32>) { + let mut kvs = map.range((min, max)).map(|(&k, &v)| (k, v)); + let mut pairs = (0..size).map(|i| (i, i)); + + for (kv, pair) in kvs.by_ref().zip(pairs.by_ref()) { + assert_eq!(kv, pair); + } + assert_eq!(kvs.next(), None); + assert_eq!(pairs.next(), None); + } + test(&map, size, Included(&0), Excluded(&size)); + test(&map, size, Unbounded, Excluded(&size)); + test(&map, size, Included(&0), Included(&(size - 1))); + test(&map, size, Unbounded, Included(&(size - 1))); + test(&map, size, Included(&0), Unbounded); + test(&map, size, Unbounded, Unbounded); +} + +#[test] +fn test_range_borrowed_key() { + let mut map = BTreeMap::new(); + map.insert("aardvark".to_string(), 1); + map.insert("baboon".to_string(), 2); + map.insert("coyote".to_string(), 3); + map.insert("dingo".to_string(), 4); + // NOTE: would like to use simply "b".."d" here... + let mut iter = map.range::((Included("b"), Excluded("d"))); + assert_eq!(iter.next(), Some((&"baboon".to_string(), &2))); + assert_eq!(iter.next(), Some((&"coyote".to_string(), &3))); + assert_eq!(iter.next(), None); +} + +#[test] +fn test_range() { + let size = 200; + // Miri is too slow + let step = if cfg!(miri) { 66 } else { 1 }; + let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); + + for i in (0..size).step_by(step) { + for j in (i..size).step_by(step) { + let mut kvs = map.range((Included(&i), Included(&j))).map(|(&k, &v)| (k, v)); + let mut pairs = (i..=j).map(|i| (i, i)); + + for (kv, pair) in kvs.by_ref().zip(pairs.by_ref()) { + assert_eq!(kv, pair); + } + assert_eq!(kvs.next(), None); + assert_eq!(pairs.next(), None); + } + } +} + +#[test] +fn test_range_mut() { + let size = 200; + // Miri is too slow + let step = if cfg!(miri) { 66 } else { 1 }; + let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); + + for i in (0..size).step_by(step) { + for j in (i..size).step_by(step) { + let mut kvs = map.range_mut((Included(&i), Included(&j))).map(|(&k, &mut v)| (k, v)); + let mut pairs = (i..=j).map(|i| (i, i)); + + for (kv, pair) in kvs.by_ref().zip(pairs.by_ref()) { + assert_eq!(kv, pair); + } + assert_eq!(kvs.next(), None); + assert_eq!(pairs.next(), None); + } + } + map.check(); +} + +mod test_drain_filter { + use super::*; + + #[test] + fn empty() { + let mut map: BTreeMap = BTreeMap::new(); + map.drain_filter(|_, _| unreachable!("there's nothing to decide on")); + assert!(map.is_empty()); + map.check(); + } + + #[test] + fn consuming_nothing() { + let pairs = (0..3).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.collect(); + assert!(map.drain_filter(|_, _| false).eq(iter::empty())); + map.check(); + } + + #[test] + fn consuming_all() { + let pairs = (0..3).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.clone().collect(); + assert!(map.drain_filter(|_, _| true).eq(pairs)); + map.check(); + } + + #[test] + fn mutating_and_keeping() { + let pairs = (0..3).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.collect(); + assert!( + map.drain_filter(|_, v| { + *v += 6; + false + }) + .eq(iter::empty()) + ); + assert!(map.keys().copied().eq(0..3)); + assert!(map.values().copied().eq(6..9)); + map.check(); + } + + #[test] + fn mutating_and_removing() { + let pairs = (0..3).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.collect(); + assert!( + map.drain_filter(|_, v| { + *v += 6; + true + }) + .eq((0..3).map(|i| (i, i + 6))) + ); + assert!(map.is_empty()); + map.check(); + } + + #[test] + fn underfull_keeping_all() { + let pairs = (0..3).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.collect(); + map.drain_filter(|_, _| false); + assert!(map.keys().copied().eq(0..3)); + map.check(); + } + + #[test] + fn underfull_removing_one() { + let pairs = (0..3).map(|i| (i, i)); + for doomed in 0..3 { + let mut map: BTreeMap<_, _> = pairs.clone().collect(); + map.drain_filter(|i, _| *i == doomed); + assert_eq!(map.len(), 2); + map.check(); + } + } + + #[test] + fn underfull_keeping_one() { + let pairs = (0..3).map(|i| (i, i)); + for sacred in 0..3 { + let mut map: BTreeMap<_, _> = pairs.clone().collect(); + map.drain_filter(|i, _| *i != sacred); + assert!(map.keys().copied().eq(sacred..=sacred)); + map.check(); + } + } + + #[test] + fn underfull_removing_all() { + let pairs = (0..3).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.collect(); + map.drain_filter(|_, _| true); + assert!(map.is_empty()); + map.check(); + } + + #[test] + fn height_0_keeping_all() { + let pairs = (0..NODE_CAPACITY).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.collect(); + map.drain_filter(|_, _| false); + assert!(map.keys().copied().eq(0..NODE_CAPACITY)); + map.check(); + } + + #[test] + fn height_0_removing_one() { + let pairs = (0..NODE_CAPACITY).map(|i| (i, i)); + for doomed in 0..NODE_CAPACITY { + let mut map: BTreeMap<_, _> = pairs.clone().collect(); + map.drain_filter(|i, _| *i == doomed); + assert_eq!(map.len(), NODE_CAPACITY - 1); + map.check(); + } + } + + #[test] + fn height_0_keeping_one() { + let pairs = (0..NODE_CAPACITY).map(|i| (i, i)); + for sacred in 0..NODE_CAPACITY { + let mut map: BTreeMap<_, _> = pairs.clone().collect(); + map.drain_filter(|i, _| *i != sacred); + assert!(map.keys().copied().eq(sacred..=sacred)); + map.check(); + } + } + + #[test] + fn height_0_removing_all() { + let pairs = (0..NODE_CAPACITY).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.collect(); + map.drain_filter(|_, _| true); + assert!(map.is_empty()); + map.check(); + } + + #[test] + fn height_0_keeping_half() { + let mut map: BTreeMap<_, _> = (0..16).map(|i| (i, i)).collect(); + assert_eq!(map.drain_filter(|i, _| *i % 2 == 0).count(), 8); + assert_eq!(map.len(), 8); + map.check(); + } + + #[test] + fn height_1_removing_all() { + let pairs = (0..MIN_INSERTS_HEIGHT_1).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.collect(); + map.drain_filter(|_, _| true); + assert!(map.is_empty()); + map.check(); + } + + #[test] + fn height_1_removing_one() { + let pairs = (0..MIN_INSERTS_HEIGHT_1).map(|i| (i, i)); + for doomed in 0..MIN_INSERTS_HEIGHT_1 { + let mut map: BTreeMap<_, _> = pairs.clone().collect(); + map.drain_filter(|i, _| *i == doomed); + assert_eq!(map.len(), MIN_INSERTS_HEIGHT_1 - 1); + map.check(); + } + } + + #[test] + fn height_1_keeping_one() { + let pairs = (0..MIN_INSERTS_HEIGHT_1).map(|i| (i, i)); + for sacred in 0..MIN_INSERTS_HEIGHT_1 { + let mut map: BTreeMap<_, _> = pairs.clone().collect(); + map.drain_filter(|i, _| *i != sacred); + assert!(map.keys().copied().eq(sacred..=sacred)); + map.check(); + } + } + + #[test] + fn height_2_removing_one() { + let pairs = (0..MIN_INSERTS_HEIGHT_2).map(|i| (i, i)); + for doomed in (0..MIN_INSERTS_HEIGHT_2).step_by(12) { + let mut map: BTreeMap<_, _> = pairs.clone().collect(); + map.drain_filter(|i, _| *i == doomed); + assert_eq!(map.len(), MIN_INSERTS_HEIGHT_2 - 1); + map.check(); + } + } + + #[test] + fn height_2_keeping_one() { + let pairs = (0..MIN_INSERTS_HEIGHT_2).map(|i| (i, i)); + for sacred in (0..MIN_INSERTS_HEIGHT_2).step_by(12) { + let mut map: BTreeMap<_, _> = pairs.clone().collect(); + map.drain_filter(|i, _| *i != sacred); + assert!(map.keys().copied().eq(sacred..=sacred)); + map.check(); + } + } + + #[test] + fn height_2_removing_all() { + let pairs = (0..MIN_INSERTS_HEIGHT_2).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.collect(); + map.drain_filter(|_, _| true); + assert!(map.is_empty()); + map.check(); + } + + #[test] + fn drop_panic_leak() { + static PREDS: AtomicUsize = AtomicUsize::new(0); + static DROPS: AtomicUsize = AtomicUsize::new(0); + + struct D; + impl Drop for D { + fn drop(&mut self) { + if DROPS.fetch_add(1, Ordering::SeqCst) == 1 { + panic!("panic in `drop`"); + } + } + } + + // Keys are multiples of 4, so that each key is counted by a hexadecimal digit. + let mut map = (0..3).map(|i| (i * 4, D)).collect::>(); + + catch_unwind(move || { + drop(map.drain_filter(|i, _| { + PREDS.fetch_add(1usize << i, Ordering::SeqCst); + true + })) + }) + .unwrap_err(); + + assert_eq!(PREDS.load(Ordering::SeqCst), 0x011); + assert_eq!(DROPS.load(Ordering::SeqCst), 3); + } + + #[test] + fn pred_panic_leak() { + static PREDS: AtomicUsize = AtomicUsize::new(0); + static DROPS: AtomicUsize = AtomicUsize::new(0); + + struct D; + impl Drop for D { + fn drop(&mut self) { + DROPS.fetch_add(1, Ordering::SeqCst); + } + } + + // Keys are multiples of 4, so that each key is counted by a hexadecimal digit. + let mut map = (0..3).map(|i| (i * 4, D)).collect::>(); + + catch_unwind(AssertUnwindSafe(|| { + drop(map.drain_filter(|i, _| { + PREDS.fetch_add(1usize << i, Ordering::SeqCst); + match i { + 0 => true, + _ => panic!(), + } + })) + })) + .unwrap_err(); + + assert_eq!(PREDS.load(Ordering::SeqCst), 0x011); + assert_eq!(DROPS.load(Ordering::SeqCst), 1); + assert_eq!(map.len(), 2); + assert_eq!(map.first_entry().unwrap().key(), &4); + assert_eq!(map.last_entry().unwrap().key(), &8); + map.check(); + } + + // Same as above, but attempt to use the iterator again after the panic in the predicate + #[test] + fn pred_panic_reuse() { + static PREDS: AtomicUsize = AtomicUsize::new(0); + static DROPS: AtomicUsize = AtomicUsize::new(0); + + struct D; + impl Drop for D { + fn drop(&mut self) { + DROPS.fetch_add(1, Ordering::SeqCst); + } + } + + // Keys are multiples of 4, so that each key is counted by a hexadecimal digit. + let mut map = (0..3).map(|i| (i * 4, D)).collect::>(); + + { + let mut it = map.drain_filter(|i, _| { + PREDS.fetch_add(1usize << i, Ordering::SeqCst); + match i { + 0 => true, + _ => panic!(), + } + }); + catch_unwind(AssertUnwindSafe(|| while it.next().is_some() {})).unwrap_err(); + // Iterator behaviour after a panic is explicitly unspecified, + // so this is just the current implementation: + let result = catch_unwind(AssertUnwindSafe(|| it.next())); + assert!(matches!(result, Ok(None))); + } + + assert_eq!(PREDS.load(Ordering::SeqCst), 0x011); + assert_eq!(DROPS.load(Ordering::SeqCst), 1); + assert_eq!(map.len(), 2); + assert_eq!(map.first_entry().unwrap().key(), &4); + assert_eq!(map.last_entry().unwrap().key(), &8); + map.check(); + } +} + +#[test] +fn test_borrow() { + // make sure these compile -- using the Borrow trait + { + let mut map = BTreeMap::new(); + map.insert("0".to_string(), 1); + assert_eq!(map["0"], 1); + } + + { + let mut map = BTreeMap::new(); + map.insert(Box::new(0), 1); + assert_eq!(map[&0], 1); + } + + { + let mut map = BTreeMap::new(); + map.insert(Box::new([0, 1]) as Box<[i32]>, 1); + assert_eq!(map[&[0, 1][..]], 1); + } + + { + let mut map = BTreeMap::new(); + map.insert(Rc::new(0), 1); + assert_eq!(map[&0], 1); + } +} + +#[test] +fn test_entry() { + let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)]; + + let mut map: BTreeMap<_, _> = xs.iter().cloned().collect(); + + // Existing key (insert) + match map.entry(1) { + Vacant(_) => unreachable!(), + Occupied(mut view) => { + assert_eq!(view.get(), &10); + assert_eq!(view.insert(100), 10); + } + } + assert_eq!(map.get(&1).unwrap(), &100); + assert_eq!(map.len(), 6); + + // Existing key (update) + match map.entry(2) { + Vacant(_) => unreachable!(), + Occupied(mut view) => { + let v = view.get_mut(); + *v *= 10; + } + } + assert_eq!(map.get(&2).unwrap(), &200); + assert_eq!(map.len(), 6); + map.check(); + + // Existing key (take) + match map.entry(3) { + Vacant(_) => unreachable!(), + Occupied(view) => { + assert_eq!(view.remove(), 30); + } + } + assert_eq!(map.get(&3), None); + assert_eq!(map.len(), 5); + map.check(); + + // Inexistent key (insert) + match map.entry(10) { + Occupied(_) => unreachable!(), + Vacant(view) => { + assert_eq!(*view.insert(1000), 1000); + } + } + assert_eq!(map.get(&10).unwrap(), &1000); + assert_eq!(map.len(), 6); + map.check(); +} + +#[test] +fn test_extend_ref() { + let mut a = BTreeMap::new(); + a.insert(1, "one"); + let mut b = BTreeMap::new(); + b.insert(2, "two"); + b.insert(3, "three"); + + a.extend(&b); + + assert_eq!(a.len(), 3); + assert_eq!(a[&1], "one"); + assert_eq!(a[&2], "two"); + assert_eq!(a[&3], "three"); + a.check(); +} + +#[test] +fn test_zst() { + let mut m = BTreeMap::new(); + assert_eq!(m.len(), 0); + + assert_eq!(m.insert((), ()), None); + assert_eq!(m.len(), 1); + + assert_eq!(m.insert((), ()), Some(())); + assert_eq!(m.len(), 1); + assert_eq!(m.iter().count(), 1); + + m.clear(); + assert_eq!(m.len(), 0); + + for _ in 0..100 { + m.insert((), ()); + } + + assert_eq!(m.len(), 1); + assert_eq!(m.iter().count(), 1); + m.check(); +} + +// This test's only purpose is to ensure that zero-sized keys with nonsensical orderings +// do not cause segfaults when used with zero-sized values. All other map behavior is +// undefined. +#[test] +fn test_bad_zst() { + use std::cmp::Ordering; + + #[derive(Clone, Copy, Debug)] + struct Bad; + + impl PartialEq for Bad { + fn eq(&self, _: &Self) -> bool { + false + } + } + + impl Eq for Bad {} + + impl PartialOrd for Bad { + fn partial_cmp(&self, _: &Self) -> Option { + Some(Ordering::Less) + } + } + + impl Ord for Bad { + fn cmp(&self, _: &Self) -> Ordering { + Ordering::Less + } + } + + let mut m = BTreeMap::new(); + + for _ in 0..100 { + m.insert(Bad, Bad); + } + m.check(); +} + +#[test] +fn test_clone() { + let mut map = BTreeMap::new(); + let size = MIN_INSERTS_HEIGHT_1; + assert_eq!(map.len(), 0); + + for i in 0..size { + assert_eq!(map.insert(i, 10 * i), None); + assert_eq!(map.len(), i + 1); + map.check(); + assert_eq!(map, map.clone()); + } + + for i in 0..size { + assert_eq!(map.insert(i, 100 * i), Some(10 * i)); + assert_eq!(map.len(), size); + map.check(); + assert_eq!(map, map.clone()); + } + + for i in 0..size / 2 { + assert_eq!(map.remove(&(i * 2)), Some(i * 200)); + assert_eq!(map.len(), size - i - 1); + map.check(); + assert_eq!(map, map.clone()); + } + + for i in 0..size / 2 { + assert_eq!(map.remove(&(2 * i)), None); + assert_eq!(map.remove(&(2 * i + 1)), Some(i * 200 + 100)); + assert_eq!(map.len(), size / 2 - i - 1); + map.check(); + assert_eq!(map, map.clone()); + } + + // Test a tree with 2 semi-full levels and a tree with 3 levels. + map = (1..MIN_INSERTS_HEIGHT_2).map(|i| (i, i)).collect(); + assert_eq!(map.len(), MIN_INSERTS_HEIGHT_2 - 1); + assert_eq!(map, map.clone()); + map.insert(0, 0); + assert_eq!(map.len(), MIN_INSERTS_HEIGHT_2); + assert_eq!(map, map.clone()); + map.check(); +} + +#[test] +fn test_clone_from() { + let mut map1 = BTreeMap::new(); + let max_size = MIN_INSERTS_HEIGHT_1; + + // Range to max_size inclusive, because i is the size of map1 being tested. + for i in 0..=max_size { + let mut map2 = BTreeMap::new(); + for j in 0..i { + let mut map1_copy = map2.clone(); + map1_copy.clone_from(&map1); // small cloned from large + assert_eq!(map1_copy, map1); + let mut map2_copy = map1.clone(); + map2_copy.clone_from(&map2); // large cloned from small + assert_eq!(map2_copy, map2); + map2.insert(100 * j + 1, 2 * j + 1); + } + map2.clone_from(&map1); // same length + map2.check(); + assert_eq!(map2, map1); + map1.insert(i, 10 * i); + map1.check(); + } +} + +#[allow(dead_code)] +fn test_variance() { + fn map_key<'new>(v: BTreeMap<&'static str, ()>) -> BTreeMap<&'new str, ()> { + v + } + fn map_val<'new>(v: BTreeMap<(), &'static str>) -> BTreeMap<(), &'new str> { + v + } + + fn iter_key<'a, 'new>(v: Iter<'a, &'static str, ()>) -> Iter<'a, &'new str, ()> { + v + } + fn iter_val<'a, 'new>(v: Iter<'a, (), &'static str>) -> Iter<'a, (), &'new str> { + v + } + + fn into_iter_key<'new>(v: IntoIter<&'static str, ()>) -> IntoIter<&'new str, ()> { + v + } + fn into_iter_val<'new>(v: IntoIter<(), &'static str>) -> IntoIter<(), &'new str> { + v + } + + fn into_keys_key<'new>(v: IntoKeys<&'static str, ()>) -> IntoKeys<&'new str, ()> { + v + } + fn into_keys_val<'new>(v: IntoKeys<(), &'static str>) -> IntoKeys<(), &'new str> { + v + } + + fn into_values_key<'new>(v: IntoValues<&'static str, ()>) -> IntoValues<&'new str, ()> { + v + } + fn into_values_val<'new>(v: IntoValues<(), &'static str>) -> IntoValues<(), &'new str> { + v + } + + fn range_key<'a, 'new>(v: Range<'a, &'static str, ()>) -> Range<'a, &'new str, ()> { + v + } + fn range_val<'a, 'new>(v: Range<'a, (), &'static str>) -> Range<'a, (), &'new str> { + v + } + + fn keys_key<'a, 'new>(v: Keys<'a, &'static str, ()>) -> Keys<'a, &'new str, ()> { + v + } + fn keys_val<'a, 'new>(v: Keys<'a, (), &'static str>) -> Keys<'a, (), &'new str> { + v + } + + fn values_key<'a, 'new>(v: Values<'a, &'static str, ()>) -> Values<'a, &'new str, ()> { + v + } + fn values_val<'a, 'new>(v: Values<'a, (), &'static str>) -> Values<'a, (), &'new str> { + v + } +} + +#[allow(dead_code)] +fn test_sync() { + fn map(v: &BTreeMap) -> impl Sync + '_ { + v + } + + fn into_iter(v: BTreeMap) -> impl Sync { + v.into_iter() + } + + fn into_keys(v: BTreeMap) -> impl Sync { + v.into_keys() + } + + fn into_values(v: BTreeMap) -> impl Sync { + v.into_values() + } + + fn drain_filter(v: &mut BTreeMap) -> impl Sync + '_ { + v.drain_filter(|_, _| false) + } + + fn iter(v: &BTreeMap) -> impl Sync + '_ { + v.iter() + } + + fn iter_mut(v: &mut BTreeMap) -> impl Sync + '_ { + v.iter_mut() + } + + fn keys(v: &BTreeMap) -> impl Sync + '_ { + v.keys() + } + + fn values(v: &BTreeMap) -> impl Sync + '_ { + v.values() + } + + fn values_mut(v: &mut BTreeMap) -> impl Sync + '_ { + v.values_mut() + } + + fn range(v: &BTreeMap) -> impl Sync + '_ { + v.range(..) + } + + fn range_mut(v: &mut BTreeMap) -> impl Sync + '_ { + v.range_mut(..) + } + + fn entry(v: &mut BTreeMap) -> impl Sync + '_ { + v.entry(Default::default()) + } + + fn occupied_entry(v: &mut BTreeMap) -> impl Sync + '_ { + match v.entry(Default::default()) { + Occupied(entry) => entry, + _ => unreachable!(), + } + } + + fn vacant_entry(v: &mut BTreeMap) -> impl Sync + '_ { + match v.entry(Default::default()) { + Vacant(entry) => entry, + _ => unreachable!(), + } + } +} + +#[allow(dead_code)] +fn test_send() { + fn map(v: BTreeMap) -> impl Send { + v + } + + fn into_iter(v: BTreeMap) -> impl Send { + v.into_iter() + } + + fn into_keys(v: BTreeMap) -> impl Send { + v.into_keys() + } + + fn into_values(v: BTreeMap) -> impl Send { + v.into_values() + } + + fn drain_filter(v: &mut BTreeMap) -> impl Send + '_ { + v.drain_filter(|_, _| false) + } + + fn iter(v: &BTreeMap) -> impl Send + '_ { + v.iter() + } + + fn iter_mut(v: &mut BTreeMap) -> impl Send + '_ { + v.iter_mut() + } + + fn keys(v: &BTreeMap) -> impl Send + '_ { + v.keys() + } + + fn values(v: &BTreeMap) -> impl Send + '_ { + v.values() + } + + fn values_mut(v: &mut BTreeMap) -> impl Send + '_ { + v.values_mut() + } + + fn range(v: &BTreeMap) -> impl Send + '_ { + v.range(..) + } + + fn range_mut(v: &mut BTreeMap) -> impl Send + '_ { + v.range_mut(..) + } + + fn entry(v: &mut BTreeMap) -> impl Send + '_ { + v.entry(Default::default()) + } + + fn occupied_entry(v: &mut BTreeMap) -> impl Send + '_ { + match v.entry(Default::default()) { + Occupied(entry) => entry, + _ => unreachable!(), + } + } + + fn vacant_entry(v: &mut BTreeMap) -> impl Send + '_ { + match v.entry(Default::default()) { + Vacant(entry) => entry, + _ => unreachable!(), + } + } +} + +#[allow(dead_code)] +fn test_const() { + const MAP: &'static BTreeMap<(), ()> = &BTreeMap::new(); + const LEN: usize = MAP.len(); + const IS_EMPTY: bool = MAP.is_empty(); +} + +#[test] +fn test_occupied_entry_key() { + let mut a = BTreeMap::new(); + let key = "hello there"; + let value = "value goes here"; + assert!(a.is_empty()); + a.insert(key.clone(), value.clone()); + assert_eq!(a.len(), 1); + assert_eq!(a[key], value); + + match a.entry(key.clone()) { + Vacant(_) => panic!(), + Occupied(e) => assert_eq!(key, *e.key()), + } + assert_eq!(a.len(), 1); + assert_eq!(a[key], value); + a.check(); +} + +#[test] +fn test_vacant_entry_key() { + let mut a = BTreeMap::new(); + let key = "hello there"; + let value = "value goes here"; + + assert!(a.is_empty()); + match a.entry(key.clone()) { + Occupied(_) => panic!(), + Vacant(e) => { + assert_eq!(key, *e.key()); + e.insert(value.clone()); + } + } + assert_eq!(a.len(), 1); + assert_eq!(a[key], value); + a.check(); +} + +#[test] +fn test_first_last_entry() { + let mut a = BTreeMap::new(); + assert!(a.first_entry().is_none()); + assert!(a.last_entry().is_none()); + a.insert(1, 42); + assert_eq!(a.first_entry().unwrap().key(), &1); + assert_eq!(a.last_entry().unwrap().key(), &1); + a.insert(2, 24); + assert_eq!(a.first_entry().unwrap().key(), &1); + assert_eq!(a.last_entry().unwrap().key(), &2); + a.insert(0, 6); + assert_eq!(a.first_entry().unwrap().key(), &0); + assert_eq!(a.last_entry().unwrap().key(), &2); + let (k1, v1) = a.first_entry().unwrap().remove_entry(); + assert_eq!(k1, 0); + assert_eq!(v1, 6); + let (k2, v2) = a.last_entry().unwrap().remove_entry(); + assert_eq!(k2, 2); + assert_eq!(v2, 24); + assert_eq!(a.first_entry().unwrap().key(), &1); + assert_eq!(a.last_entry().unwrap().key(), &1); + a.check(); +} + +#[test] +fn test_insert_into_full_left() { + let mut map: BTreeMap<_, _> = (0..NODE_CAPACITY).map(|i| (i * 2, ())).collect(); + assert!(map.insert(NODE_CAPACITY, ()).is_none()); + map.check(); +} + +#[test] +fn test_insert_into_full_right() { + let mut map: BTreeMap<_, _> = (0..NODE_CAPACITY).map(|i| (i * 2, ())).collect(); + assert!(map.insert(NODE_CAPACITY + 2, ()).is_none()); + map.check(); +} + +macro_rules! create_append_test { + ($name:ident, $len:expr) => { + #[test] + fn $name() { + let mut a = BTreeMap::new(); + for i in 0..8 { + a.insert(i, i); + } + + let mut b = BTreeMap::new(); + for i in 5..$len { + b.insert(i, 2 * i); + } + + a.append(&mut b); + + assert_eq!(a.len(), $len); + assert_eq!(b.len(), 0); + + for i in 0..$len { + if i < 5 { + assert_eq!(a[&i], i); + } else { + assert_eq!(a[&i], 2 * i); + } + } + + a.check(); + assert_eq!(a.remove(&($len - 1)), Some(2 * ($len - 1))); + assert_eq!(a.insert($len - 1, 20), None); + a.check(); + } + }; +} + +// These are mostly for testing the algorithm that "fixes" the right edge after insertion. +// Single node. +create_append_test!(test_append_9, 9); +// Two leafs that don't need fixing. +create_append_test!(test_append_17, 17); +// Two leafs where the second one ends up underfull and needs stealing at the end. +create_append_test!(test_append_14, 14); +// Two leafs where the second one ends up empty because the insertion finished at the root. +create_append_test!(test_append_12, 12); +// Three levels; insertion finished at the root. +create_append_test!(test_append_144, 144); +// Three levels; insertion finished at leaf while there is an empty node on the second level. +create_append_test!(test_append_145, 145); +// Tests for several randomly chosen sizes. +create_append_test!(test_append_170, 170); +create_append_test!(test_append_181, 181); +#[cfg(not(miri))] // Miri is too slow +create_append_test!(test_append_239, 239); +#[cfg(not(miri))] // Miri is too slow +create_append_test!(test_append_1700, 1700); + +#[test] +fn test_append_drop_leak() { + static DROPS: AtomicUsize = AtomicUsize::new(0); + + struct D; + + impl Drop for D { + fn drop(&mut self) { + if DROPS.fetch_add(1, Ordering::SeqCst) == 0 { + panic!("panic in `drop`"); + } + } + } + + let mut left = BTreeMap::new(); + let mut right = BTreeMap::new(); + left.insert(0, D); + left.insert(1, D); // first to be dropped during append + left.insert(2, D); + right.insert(1, D); + right.insert(2, D); + + catch_unwind(move || left.append(&mut right)).unwrap_err(); + + assert_eq!(DROPS.load(Ordering::SeqCst), 4); // Rust issue #47949 ate one little piggy +} + +fn rand_data(len: usize) -> Vec<(u32, u32)> { + assert!(len * 2 <= 70029); // from that point on numbers repeat + let mut rng = DeterministicRng::new(); + Vec::from_iter((0..len).map(|_| (rng.next(), rng.next()))) +} + +#[test] +fn test_split_off_empty_right() { + let mut data = rand_data(173); + + let mut map = BTreeMap::from_iter(data.clone()); + let right = map.split_off(&(data.iter().max().unwrap().0 + 1)); + map.check(); + right.check(); + + data.sort(); + assert!(map.into_iter().eq(data)); + assert!(right.into_iter().eq(None)); +} + +#[test] +fn test_split_off_empty_left() { + let mut data = rand_data(314); + + let mut map = BTreeMap::from_iter(data.clone()); + let right = map.split_off(&data.iter().min().unwrap().0); + map.check(); + right.check(); + + data.sort(); + assert!(map.into_iter().eq(None)); + assert!(right.into_iter().eq(data)); +} + +// In a tree with 3 levels, if all but a part of the first leaf node is split off, +// make sure fix_top eliminates both top levels. +#[test] +fn test_split_off_tiny_left_height_2() { + let pairs = (0..MIN_INSERTS_HEIGHT_2).map(|i| (i, i)); + let mut left: BTreeMap<_, _> = pairs.clone().collect(); + let right = left.split_off(&1); + left.check(); + right.check(); + assert_eq!(left.len(), 1); + assert_eq!(right.len(), MIN_INSERTS_HEIGHT_2 - 1); + assert_eq!(*left.first_key_value().unwrap().0, 0); + assert_eq!(*right.first_key_value().unwrap().0, 1); +} + +// In a tree with 3 levels, if only part of the last leaf node is split off, +// make sure fix_top eliminates both top levels. +#[test] +fn test_split_off_tiny_right_height_2() { + let pairs = (0..MIN_INSERTS_HEIGHT_2).map(|i| (i, i)); + let last = MIN_INSERTS_HEIGHT_2 - 1; + let mut left: BTreeMap<_, _> = pairs.clone().collect(); + assert_eq!(*left.last_key_value().unwrap().0, last); + let right = left.split_off(&last); + left.check(); + right.check(); + assert_eq!(left.len(), MIN_INSERTS_HEIGHT_2 - 1); + assert_eq!(right.len(), 1); + assert_eq!(*left.last_key_value().unwrap().0, last - 1); + assert_eq!(*right.last_key_value().unwrap().0, last); +} + +#[test] +fn test_split_off_large_random_sorted() { + // Miri is too slow + let mut data = if cfg!(miri) { rand_data(529) } else { rand_data(1529) }; + // special case with maximum height. + data.sort(); + + let mut map = BTreeMap::from_iter(data.clone()); + let key = data[data.len() / 2].0; + let right = map.split_off(&key); + map.check(); + right.check(); + + assert!(map.into_iter().eq(data.clone().into_iter().filter(|x| x.0 < key))); + assert!(right.into_iter().eq(data.into_iter().filter(|x| x.0 >= key))); +} + +#[test] +fn test_into_iter_drop_leak_height_0() { + static DROPS: AtomicUsize = AtomicUsize::new(0); + + struct D; + + impl Drop for D { + fn drop(&mut self) { + if DROPS.fetch_add(1, Ordering::SeqCst) == 3 { + panic!("panic in `drop`"); + } + } + } + + let mut map = BTreeMap::new(); + map.insert("a", D); + map.insert("b", D); + map.insert("c", D); + map.insert("d", D); + map.insert("e", D); + + catch_unwind(move || drop(map.into_iter())).unwrap_err(); + + assert_eq!(DROPS.load(Ordering::SeqCst), 5); +} + +#[test] +fn test_into_iter_drop_leak_height_1() { + let size = MIN_INSERTS_HEIGHT_1; + static DROPS: AtomicUsize = AtomicUsize::new(0); + static PANIC_POINT: AtomicUsize = AtomicUsize::new(0); + + struct D; + impl Drop for D { + fn drop(&mut self) { + if DROPS.fetch_add(1, Ordering::SeqCst) == PANIC_POINT.load(Ordering::SeqCst) { + panic!("panic in `drop`"); + } + } + } + + for panic_point in vec![0, 1, size - 2, size - 1] { + DROPS.store(0, Ordering::SeqCst); + PANIC_POINT.store(panic_point, Ordering::SeqCst); + let map: BTreeMap<_, _> = (0..size).map(|i| (i, D)).collect(); + catch_unwind(move || drop(map.into_iter())).unwrap_err(); + assert_eq!(DROPS.load(Ordering::SeqCst), size); + } +} + +#[test] +fn test_into_keys() { + let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')]; + let map: BTreeMap<_, _> = vec.into_iter().collect(); + let keys: Vec<_> = map.into_keys().collect(); + + assert_eq!(keys.len(), 3); + assert!(keys.contains(&1)); + assert!(keys.contains(&2)); + assert!(keys.contains(&3)); +} + +#[test] +fn test_into_values() { + let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')]; + let map: BTreeMap<_, _> = vec.into_iter().collect(); + let values: Vec<_> = map.into_values().collect(); + + assert_eq!(values.len(), 3); + assert!(values.contains(&'a')); + assert!(values.contains(&'b')); + assert!(values.contains(&'c')); +} + +#[test] +fn test_insert_remove_intertwined() { + let loops = if cfg!(miri) { 100 } else { 1_000_000 }; + let mut map = BTreeMap::new(); + let mut i = 1; + for _ in 0..loops { + i = (i + 421) & 0xFF; + map.insert(i, i); + map.remove(&(0xFF - i)); + } + + map.check(); +} diff --git a/libgrust/rustc-lib/alloc/src/collections/btree/mem.rs b/libgrust/rustc-lib/alloc/src/collections/btree/mem.rs new file mode 100644 index 000000000000..5e7d9fa3f91b --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/btree/mem.rs @@ -0,0 +1,34 @@ +use core::intrinsics; +use core::mem; +use core::ptr; + +/// This replaces the value behind the `v` unique reference by calling the +/// relevant function. +/// +/// If a panic occurs in the `change` closure, the entire process will be aborted. +#[inline] +pub fn take_mut(v: &mut T, change: impl FnOnce(T) -> T) { + replace(v, |value| (change(value), ())) +} + +/// This replaces the value behind the `v` unique reference by calling the +/// relevant function, and returns a result obtained along the way. +/// +/// If a panic occurs in the `change` closure, the entire process will be aborted. +#[inline] +pub fn replace(v: &mut T, change: impl FnOnce(T) -> (T, R)) -> R { + struct PanicGuard; + impl Drop for PanicGuard { + fn drop(&mut self) { + intrinsics::abort() + } + } + let guard = PanicGuard; + let value = unsafe { ptr::read(v) }; + let (new_value, ret) = change(value); + unsafe { + ptr::write(v, new_value); + } + mem::forget(guard); + ret +} diff --git a/libgrust/rustc-lib/alloc/src/collections/btree/merge_iter.rs b/libgrust/rustc-lib/alloc/src/collections/btree/merge_iter.rs new file mode 100644 index 000000000000..7f23d93b990f --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/btree/merge_iter.rs @@ -0,0 +1,98 @@ +use core::cmp::Ordering; +use core::fmt::{self, Debug}; +use core::iter::FusedIterator; + +/// Core of an iterator that merges the output of two strictly ascending iterators, +/// for instance a union or a symmetric difference. +pub struct MergeIterInner { + a: I, + b: I, + peeked: Option>, +} + +/// Benchmarks faster than wrapping both iterators in a Peekable, +/// probably because we can afford to impose a FusedIterator bound. +#[derive(Clone, Debug)] +enum Peeked { + A(I::Item), + B(I::Item), +} + +impl Clone for MergeIterInner +where + I: Clone, + I::Item: Clone, +{ + fn clone(&self) -> Self { + Self { a: self.a.clone(), b: self.b.clone(), peeked: self.peeked.clone() } + } +} + +impl Debug for MergeIterInner +where + I: Debug, + I::Item: Debug, +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("MergeIterInner").field(&self.a).field(&self.b).field(&self.peeked).finish() + } +} + +impl MergeIterInner { + /// Creates a new core for an iterator merging a pair of sources. + pub fn new(a: I, b: I) -> Self { + MergeIterInner { a, b, peeked: None } + } + + /// Returns the next pair of items stemming from the pair of sources + /// being merged. If both returned options contain a value, that value + /// is equal and occurs in both sources. If one of the returned options + /// contains a value, that value doesn't occur in the other source (or + /// the sources are not strictly ascending). If neither returned option + /// contains a value, iteration has finished and subsequent calls will + /// return the same empty pair. + pub fn nexts Ordering>( + &mut self, + cmp: Cmp, + ) -> (Option, Option) + where + I: FusedIterator, + { + let mut a_next; + let mut b_next; + match self.peeked.take() { + Some(Peeked::A(next)) => { + a_next = Some(next); + b_next = self.b.next(); + } + Some(Peeked::B(next)) => { + b_next = Some(next); + a_next = self.a.next(); + } + None => { + a_next = self.a.next(); + b_next = self.b.next(); + } + } + if let (Some(ref a1), Some(ref b1)) = (&a_next, &b_next) { + match cmp(a1, b1) { + Ordering::Less => self.peeked = b_next.take().map(Peeked::B), + Ordering::Greater => self.peeked = a_next.take().map(Peeked::A), + Ordering::Equal => (), + } + } + (a_next, b_next) + } + + /// Returns a pair of upper bounds for the `size_hint` of the final iterator. + pub fn lens(&self) -> (usize, usize) + where + I: ExactSizeIterator, + { + match self.peeked { + Some(Peeked::A(_)) => (1 + self.a.len(), self.b.len()), + Some(Peeked::B(_)) => (self.a.len(), 1 + self.b.len()), + _ => (self.a.len(), self.b.len()), + } + } +} diff --git a/libgrust/rustc-lib/alloc/src/collections/btree/mod.rs b/libgrust/rustc-lib/alloc/src/collections/btree/mod.rs new file mode 100644 index 000000000000..ebcbb0e467c4 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/btree/mod.rs @@ -0,0 +1,64 @@ +mod append; +mod borrow; +pub mod map; +mod mem; +mod merge_iter; +mod navigate; +mod node; +mod remove; +mod search; +pub mod set; +mod split; + +#[doc(hidden)] +trait Recover { + type Key; + + fn get(&self, key: &Q) -> Option<&Self::Key>; + fn take(&mut self, key: &Q) -> Option; + fn replace(&mut self, key: Self::Key) -> Option; +} + +/// Same purpose as `Option::unwrap` but doesn't always guarantee a panic +/// if the option contains no value. +/// SAFETY: the caller must ensure that the option contains a value. +#[inline(always)] +pub unsafe fn unwrap_unchecked(val: Option) -> T { + val.unwrap_or_else(|| { + if cfg!(debug_assertions) { + panic!("'unchecked' unwrap on None in BTreeMap"); + } else { + unsafe { + core::intrinsics::unreachable(); + } + } + }) +} + +#[cfg(test)] +/// XorShiftRng +struct DeterministicRng { + x: u32, + y: u32, + z: u32, + w: u32, +} + +#[cfg(test)] +impl DeterministicRng { + fn new() -> Self { + DeterministicRng { x: 0x193a6754, y: 0xa8a7d469, z: 0x97830e05, w: 0x113ba7bb } + } + + /// Guarantees that the first 70029 results are unique. + fn next(&mut self) -> u32 { + let x = self.x; + let t = x ^ (x << 11); + self.x = self.y; + self.y = self.z; + self.z = self.w; + let w_ = self.w; + self.w = w_ ^ (w_ >> 19) ^ (t ^ (t >> 8)); + self.w + } +} diff --git a/libgrust/rustc-lib/alloc/src/collections/btree/navigate.rs b/libgrust/rustc-lib/alloc/src/collections/btree/navigate.rs new file mode 100644 index 000000000000..de78148fc82b --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/btree/navigate.rs @@ -0,0 +1,528 @@ +use core::borrow::Borrow; +use core::cmp::Ordering; +use core::ops::Bound::{Excluded, Included, Unbounded}; +use core::ops::RangeBounds; +use core::ptr; + +use super::node::{marker, ForceResult::*, Handle, NodeRef}; +use super::search::{self, SearchResult}; +use super::unwrap_unchecked; + +/// Finds the leaf edges delimiting a specified range in or underneath a node. +fn range_search( + root1: NodeRef, + root2: NodeRef, + range: R, +) -> ( + Handle, marker::Edge>, + Handle, marker::Edge>, +) +where + Q: ?Sized + Ord, + K: Borrow, + R: RangeBounds, +{ + match (range.start_bound(), range.end_bound()) { + (Excluded(s), Excluded(e)) if s == e => { + panic!("range start and end are equal and excluded in BTreeMap") + } + (Included(s) | Excluded(s), Included(e) | Excluded(e)) if s > e => { + panic!("range start is greater than range end in BTreeMap") + } + _ => {} + }; + + let mut min_node = root1; + let mut max_node = root2; + let mut min_found = false; + let mut max_found = false; + + loop { + let front = match (min_found, range.start_bound()) { + (false, Included(key)) => match search::search_node(min_node, key) { + SearchResult::Found(kv) => { + min_found = true; + kv.left_edge() + } + SearchResult::GoDown(edge) => edge, + }, + (false, Excluded(key)) => match search::search_node(min_node, key) { + SearchResult::Found(kv) => { + min_found = true; + kv.right_edge() + } + SearchResult::GoDown(edge) => edge, + }, + (true, Included(_)) => min_node.last_edge(), + (true, Excluded(_)) => min_node.first_edge(), + (_, Unbounded) => min_node.first_edge(), + }; + + let back = match (max_found, range.end_bound()) { + (false, Included(key)) => match search::search_node(max_node, key) { + SearchResult::Found(kv) => { + max_found = true; + kv.right_edge() + } + SearchResult::GoDown(edge) => edge, + }, + (false, Excluded(key)) => match search::search_node(max_node, key) { + SearchResult::Found(kv) => { + max_found = true; + kv.left_edge() + } + SearchResult::GoDown(edge) => edge, + }, + (true, Included(_)) => max_node.first_edge(), + (true, Excluded(_)) => max_node.last_edge(), + (_, Unbounded) => max_node.last_edge(), + }; + + if front.partial_cmp(&back) == Some(Ordering::Greater) { + panic!("Ord is ill-defined in BTreeMap range"); + } + match (front.force(), back.force()) { + (Leaf(f), Leaf(b)) => { + return (f, b); + } + (Internal(min_int), Internal(max_int)) => { + min_node = min_int.descend(); + max_node = max_int.descend(); + } + _ => unreachable!("BTreeMap has different depths"), + }; + } +} + +/// Equivalent to `range_search(k, v, ..)` but without the `Ord` bound. +fn full_range( + root1: NodeRef, + root2: NodeRef, +) -> ( + Handle, marker::Edge>, + Handle, marker::Edge>, +) { + let mut min_node = root1; + let mut max_node = root2; + loop { + let front = min_node.first_edge(); + let back = max_node.last_edge(); + match (front.force(), back.force()) { + (Leaf(f), Leaf(b)) => { + return (f, b); + } + (Internal(min_int), Internal(max_int)) => { + min_node = min_int.descend(); + max_node = max_int.descend(); + } + _ => unreachable!("BTreeMap has different depths"), + }; + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::LeafOrInternal> { + /// Creates a pair of leaf edges delimiting a specified range in or underneath a node. + pub fn range_search( + self, + range: R, + ) -> ( + Handle, K, V, marker::Leaf>, marker::Edge>, + Handle, K, V, marker::Leaf>, marker::Edge>, + ) + where + Q: ?Sized + Ord, + K: Borrow, + R: RangeBounds, + { + range_search(self, self, range) + } + + /// Returns (self.first_leaf_edge(), self.last_leaf_edge()), but more efficiently. + pub fn full_range( + self, + ) -> ( + Handle, K, V, marker::Leaf>, marker::Edge>, + Handle, K, V, marker::Leaf>, marker::Edge>, + ) { + full_range(self, self) + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::LeafOrInternal> { + /// Splits a unique reference into a pair of leaf edges delimiting a specified range. + /// The result are non-unique references allowing (some) mutation, which must be used + /// carefully. + pub fn range_search( + self, + range: R, + ) -> ( + Handle, K, V, marker::Leaf>, marker::Edge>, + Handle, K, V, marker::Leaf>, marker::Edge>, + ) + where + Q: ?Sized + Ord, + K: Borrow, + R: RangeBounds, + { + // We duplicate the root NodeRef here -- we will never visit the same KV + // twice, and never end up with overlapping value references. + let self2 = unsafe { ptr::read(&self) }; + range_search(self, self2, range) + } + + /// Splits a unique reference into a pair of leaf edges delimiting the full range of the tree. + /// The results are non-unique references allowing mutation (of values only), so must be used + /// with care. + pub fn full_range( + self, + ) -> ( + Handle, K, V, marker::Leaf>, marker::Edge>, + Handle, K, V, marker::Leaf>, marker::Edge>, + ) { + // We duplicate the root NodeRef here -- we will never visit the same KV + // twice, and never end up with overlapping value references. + let self2 = unsafe { ptr::read(&self) }; + full_range(self, self2) + } +} + +impl NodeRef { + /// Splits a unique reference into a pair of leaf edges delimiting the full range of the tree. + /// The results are non-unique references allowing massively destructive mutation, so must be + /// used with the utmost care. + pub fn full_range( + self, + ) -> ( + Handle, marker::Edge>, + Handle, marker::Edge>, + ) { + // We duplicate the root NodeRef here -- we will never access it in a way + // that overlaps references obtained from the root. + let self2 = unsafe { ptr::read(&self) }; + full_range(self, self2) + } +} + +impl Handle, marker::Edge> { + /// Given a leaf edge handle, returns [`Result::Ok`] with a handle to the neighboring KV + /// on the right side, which is either in the same leaf node or in an ancestor node. + /// If the leaf edge is the last one in the tree, returns [`Result::Err`] with the root node. + pub fn next_kv( + self, + ) -> Result< + Handle, marker::KV>, + NodeRef, + > { + let mut edge = self.forget_node_type(); + loop { + edge = match edge.right_kv() { + Ok(kv) => return Ok(kv), + Err(last_edge) => match last_edge.into_node().ascend() { + Ok(parent_edge) => parent_edge.forget_node_type(), + Err(root) => return Err(root), + }, + } + } + } + + /// Given a leaf edge handle, returns [`Result::Ok`] with a handle to the neighboring KV + /// on the left side, which is either in the same leaf node or in an ancestor node. + /// If the leaf edge is the first one in the tree, returns [`Result::Err`] with the root node. + pub fn next_back_kv( + self, + ) -> Result< + Handle, marker::KV>, + NodeRef, + > { + let mut edge = self.forget_node_type(); + loop { + edge = match edge.left_kv() { + Ok(kv) => return Ok(kv), + Err(last_edge) => match last_edge.into_node().ascend() { + Ok(parent_edge) => parent_edge.forget_node_type(), + Err(root) => return Err(root), + }, + } + } + } +} + +impl Handle, marker::Edge> { + /// Given an internal edge handle, returns [`Result::Ok`] with a handle to the neighboring KV + /// on the right side, which is either in the same internal node or in an ancestor node. + /// If the internal edge is the last one in the tree, returns [`Result::Err`] with the root node. + pub fn next_kv( + self, + ) -> Result< + Handle, marker::KV>, + NodeRef, + > { + let mut edge = self; + loop { + edge = match edge.right_kv() { + Ok(internal_kv) => return Ok(internal_kv), + Err(last_edge) => match last_edge.into_node().ascend() { + Ok(parent_edge) => parent_edge, + Err(root) => return Err(root), + }, + } + } + } +} + +macro_rules! def_next_kv_uncheched_dealloc { + { unsafe fn $name:ident : $adjacent_kv:ident } => { + /// Given a leaf edge handle into an owned tree, returns a handle to the next KV, + /// while deallocating any node left behind yet leaving the corresponding edge + /// in its parent node dangling. + /// + /// # Safety + /// - The leaf edge must not be the last one in the direction travelled. + /// - The node carrying the next KV returned must not have been deallocated by a + /// previous call on any handle obtained for this tree. + unsafe fn $name ( + leaf_edge: Handle, marker::Edge>, + ) -> Handle, marker::KV> { + let mut edge = leaf_edge.forget_node_type(); + loop { + edge = match edge.$adjacent_kv() { + Ok(internal_kv) => return internal_kv, + Err(last_edge) => { + unsafe { + let parent_edge = last_edge.into_node().deallocate_and_ascend(); + unwrap_unchecked(parent_edge).forget_node_type() + } + } + } + } + } + }; +} + +def_next_kv_uncheched_dealloc! {unsafe fn next_kv_unchecked_dealloc: right_kv} +def_next_kv_uncheched_dealloc! {unsafe fn next_back_kv_unchecked_dealloc: left_kv} + +impl<'a, K, V> Handle, K, V, marker::Leaf>, marker::Edge> { + /// Moves the leaf edge handle to the next leaf edge and returns references to the + /// key and value in between. + /// + /// # Safety + /// There must be another KV in the direction travelled. + pub unsafe fn next_unchecked(&mut self) -> (&'a K, &'a V) { + super::mem::replace(self, |leaf_edge| { + let kv = leaf_edge.next_kv(); + let kv = unsafe { unwrap_unchecked(kv.ok()) }; + (kv.next_leaf_edge(), kv.into_kv()) + }) + } + + /// Moves the leaf edge handle to the previous leaf edge and returns references to the + /// key and value in between. + /// + /// # Safety + /// There must be another KV in the direction travelled. + pub unsafe fn next_back_unchecked(&mut self) -> (&'a K, &'a V) { + super::mem::replace(self, |leaf_edge| { + let kv = leaf_edge.next_back_kv(); + let kv = unsafe { unwrap_unchecked(kv.ok()) }; + (kv.next_back_leaf_edge(), kv.into_kv()) + }) + } +} + +impl<'a, K, V> Handle, K, V, marker::Leaf>, marker::Edge> { + /// Moves the leaf edge handle to the next leaf edge and returns references to the + /// key and value in between. + /// + /// # Safety + /// There must be another KV in the direction travelled. + pub unsafe fn next_unchecked(&mut self) -> (&'a K, &'a mut V) { + let kv = super::mem::replace(self, |leaf_edge| { + let kv = leaf_edge.next_kv(); + let kv = unsafe { unwrap_unchecked(kv.ok()) }; + (unsafe { ptr::read(&kv) }.next_leaf_edge(), kv) + }); + // Doing this last is faster, according to benchmarks. + kv.into_kv_valmut() + } + + /// Moves the leaf edge handle to the previous leaf and returns references to the + /// key and value in between. + /// + /// # Safety + /// There must be another KV in the direction travelled. + pub unsafe fn next_back_unchecked(&mut self) -> (&'a K, &'a mut V) { + let kv = super::mem::replace(self, |leaf_edge| { + let kv = leaf_edge.next_back_kv(); + let kv = unsafe { unwrap_unchecked(kv.ok()) }; + (unsafe { ptr::read(&kv) }.next_back_leaf_edge(), kv) + }); + // Doing this last is faster, according to benchmarks. + kv.into_kv_valmut() + } +} + +impl<'a, K, V> Handle, K, V, marker::Leaf>, marker::Edge> { + /// Moves the leaf edge handle to the next leaf edge. + /// + /// # Safety + /// There must be another KV in the direction travelled. + pub unsafe fn move_next_unchecked(&mut self) { + super::mem::take_mut(self, |leaf_edge| { + let kv = leaf_edge.next_kv(); + let kv = unsafe { unwrap_unchecked(kv.ok()) }; + kv.next_leaf_edge() + }) + } +} + +impl Handle, marker::Edge> { + /// Moves the leaf edge handle to the next leaf edge and returns the key and value + /// in between, deallocating any node left behind while leaving the corresponding + /// edge in its parent node dangling. + /// + /// # Safety + /// - There must be another KV in the direction travelled. + /// - That KV was not previously returned by counterpart `next_back_unchecked` + /// on any copy of the handles being used to traverse the tree. + /// + /// The only safe way to proceed with the updated handle is to compare it, drop it, + /// call this method again subject to its safety conditions, or call counterpart + /// `next_back_unchecked` subject to its safety conditions. + pub unsafe fn next_unchecked(&mut self) -> (K, V) { + super::mem::replace(self, |leaf_edge| { + let kv = unsafe { next_kv_unchecked_dealloc(leaf_edge) }; + let k = unsafe { ptr::read(kv.reborrow().into_kv().0) }; + let v = unsafe { ptr::read(kv.reborrow().into_kv().1) }; + (kv.next_leaf_edge(), (k, v)) + }) + } + + /// Moves the leaf edge handle to the previous leaf edge and returns the key and value + /// in between, deallocating any node left behind while leaving the corresponding + /// edge in its parent node dangling. + /// + /// # Safety + /// - There must be another KV in the direction travelled. + /// - That leaf edge was not previously returned by counterpart `next_unchecked` + /// on any copy of the handles being used to traverse the tree. + /// + /// The only safe way to proceed with the updated handle is to compare it, drop it, + /// call this method again subject to its safety conditions, or call counterpart + /// `next_unchecked` subject to its safety conditions. + pub unsafe fn next_back_unchecked(&mut self) -> (K, V) { + super::mem::replace(self, |leaf_edge| { + let kv = unsafe { next_back_kv_unchecked_dealloc(leaf_edge) }; + let k = unsafe { ptr::read(kv.reborrow().into_kv().0) }; + let v = unsafe { ptr::read(kv.reborrow().into_kv().1) }; + (kv.next_back_leaf_edge(), (k, v)) + }) + } +} + +impl NodeRef { + /// Returns the leftmost leaf edge in or underneath a node - in other words, the edge + /// you need first when navigating forward (or last when navigating backward). + #[inline] + pub fn first_leaf_edge(self) -> Handle, marker::Edge> { + let mut node = self; + loop { + match node.force() { + Leaf(leaf) => return leaf.first_edge(), + Internal(internal) => node = internal.first_edge().descend(), + } + } + } + + /// Returns the rightmost leaf edge in or underneath a node - in other words, the edge + /// you need last when navigating forward (or first when navigating backward). + #[inline] + pub fn last_leaf_edge(self) -> Handle, marker::Edge> { + let mut node = self; + loop { + match node.force() { + Leaf(leaf) => return leaf.last_edge(), + Internal(internal) => node = internal.last_edge().descend(), + } + } + } +} + +pub enum Position { + Leaf(NodeRef), + Internal(NodeRef), + InternalKV(Handle, marker::KV>), +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::LeafOrInternal> { + /// Visits leaf nodes and internal KVs in order of ascending keys, and also + /// visits internal nodes as a whole in a depth first order, meaning that + /// internal nodes precede their individual KVs and their child nodes. + pub fn visit_nodes_in_order(self, mut visit: F) + where + F: FnMut(Position, K, V>), + { + match self.force() { + Leaf(leaf) => visit(Position::Leaf(leaf)), + Internal(internal) => { + visit(Position::Internal(internal)); + let mut edge = internal.first_edge(); + loop { + edge = match edge.descend().force() { + Leaf(leaf) => { + visit(Position::Leaf(leaf)); + match edge.next_kv() { + Ok(kv) => { + visit(Position::InternalKV(kv)); + kv.right_edge() + } + Err(_) => return, + } + } + Internal(internal) => { + visit(Position::Internal(internal)); + internal.first_edge() + } + } + } + } + } + } + + /// Calculates the number of elements in a (sub)tree. + pub fn calc_length(self) -> usize { + let mut result = 0; + self.visit_nodes_in_order(|pos| match pos { + Position::Leaf(node) => result += node.len(), + Position::Internal(node) => result += node.len(), + Position::InternalKV(_) => (), + }); + result + } +} + +impl Handle, marker::KV> { + /// Returns the leaf edge closest to a KV for forward navigation. + pub fn next_leaf_edge(self) -> Handle, marker::Edge> { + match self.force() { + Leaf(leaf_kv) => leaf_kv.right_edge(), + Internal(internal_kv) => { + let next_internal_edge = internal_kv.right_edge(); + next_internal_edge.descend().first_leaf_edge() + } + } + } + + /// Returns the leaf edge closest to a KV for backward navigation. + pub fn next_back_leaf_edge( + self, + ) -> Handle, marker::Edge> { + match self.force() { + Leaf(leaf_kv) => leaf_kv.left_edge(), + Internal(internal_kv) => { + let next_internal_edge = internal_kv.left_edge(); + next_internal_edge.descend().last_leaf_edge() + } + } + } +} diff --git a/libgrust/rustc-lib/alloc/src/collections/btree/node.rs b/libgrust/rustc-lib/alloc/src/collections/btree/node.rs new file mode 100644 index 000000000000..dbf9031620ee --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/btree/node.rs @@ -0,0 +1,1709 @@ +// This is an attempt at an implementation following the ideal +// +// ``` +// struct BTreeMap { +// height: usize, +// root: Option>> +// } +// +// struct Node { +// keys: [K; 2 * B - 1], +// vals: [V; 2 * B - 1], +// edges: [if height > 0 { Box> } else { () }; 2 * B], +// parent: Option<(NonNull>, u16)>, +// len: u16, +// } +// ``` +// +// Since Rust doesn't actually have dependent types and polymorphic recursion, +// we make do with lots of unsafety. + +// A major goal of this module is to avoid complexity by treating the tree as a generic (if +// weirdly shaped) container and avoiding dealing with most of the B-Tree invariants. As such, +// this module doesn't care whether the entries are sorted, which nodes can be underfull, or +// even what underfull means. However, we do rely on a few invariants: +// +// - Trees must have uniform depth/height. This means that every path down to a leaf from a +// given node has exactly the same length. +// - A node of length `n` has `n` keys, `n` values, and `n + 1` edges. +// This implies that even an empty node has at least one edge. + +use core::cmp::Ordering; +use core::marker::PhantomData; +use core::mem::{self, MaybeUninit}; +use core::ptr::{self, NonNull, Unique}; + +use crate::alloc::{AllocRef, Global, Layout}; +use crate::boxed::Box; + +const B: usize = 6; +pub const CAPACITY: usize = 2 * B - 1; +pub const MIN_LEN_AFTER_SPLIT: usize = B - 1; +const KV_IDX_CENTER: usize = B - 1; +const EDGE_IDX_LEFT_OF_CENTER: usize = B - 1; +const EDGE_IDX_RIGHT_OF_CENTER: usize = B; + +/// The underlying representation of leaf nodes and part of the representation of internal nodes. +struct LeafNode { + /// We want to be covariant in `K` and `V`. + parent: Option>>, + + /// This node's index into the parent node's `edges` array. + /// `*node.parent.edges[node.parent_idx]` should be the same thing as `node`. + /// This is only guaranteed to be initialized when `parent` is non-null. + parent_idx: MaybeUninit, + + /// The number of keys and values this node stores. + len: u16, + + /// The arrays storing the actual data of the node. Only the first `len` elements of each + /// array are initialized and valid. + keys: [MaybeUninit; CAPACITY], + vals: [MaybeUninit; CAPACITY], +} + +impl LeafNode { + /// Creates a new `LeafNode`. Unsafe because all nodes should really be hidden behind + /// `BoxedNode`, preventing accidental dropping of uninitialized keys and values. + unsafe fn new() -> Self { + LeafNode { + // As a general policy, we leave fields uninitialized if they can be, as this should + // be both slightly faster and easier to track in Valgrind. + keys: MaybeUninit::uninit_array(), + vals: MaybeUninit::uninit_array(), + parent: None, + parent_idx: MaybeUninit::uninit(), + len: 0, + } + } +} + +/// The underlying representation of internal nodes. As with `LeafNode`s, these should be hidden +/// behind `BoxedNode`s to prevent dropping uninitialized keys and values. Any pointer to an +/// `InternalNode` can be directly casted to a pointer to the underlying `LeafNode` portion of the +/// node, allowing code to act on leaf and internal nodes generically without having to even check +/// which of the two a pointer is pointing at. This property is enabled by the use of `repr(C)`. +#[repr(C)] +// gdb_providers.py uses this type name for introspection. +struct InternalNode { + data: LeafNode, + + /// The pointers to the children of this node. `len + 1` of these are considered + /// initialized and valid. Although during the process of `into_iter` or `drop`, + /// some pointers are dangling while others still need to be traversed. + edges: [MaybeUninit>; 2 * B], +} + +impl InternalNode { + /// Creates a new `InternalNode`. + /// + /// This is unsafe for two reasons. First, it returns an `InternalNode` by value, risking + /// dropping of uninitialized fields. Second, an invariant of internal nodes is that `len + 1` + /// edges are initialized and valid, meaning that even when the node is empty (having a + /// `len` of 0), there must be one initialized and valid edge. This function does not set up + /// such an edge. + unsafe fn new() -> Self { + InternalNode { data: unsafe { LeafNode::new() }, edges: MaybeUninit::uninit_array() } + } +} + +/// A managed, non-null pointer to a node. This is either an owned pointer to +/// `LeafNode` or an owned pointer to `InternalNode`. +/// +/// However, `BoxedNode` contains no information as to which of the two types +/// of nodes it actually contains, and, partially due to this lack of information, +/// has no destructor. +struct BoxedNode { + ptr: Unique>, +} + +impl BoxedNode { + fn from_leaf(node: Box>) -> Self { + BoxedNode { ptr: Unique::from(Box::leak(node)) } + } + + fn from_internal(node: Box>) -> Self { + BoxedNode { ptr: Unique::from(Box::leak(node)).cast() } + } + + fn as_ptr(&self) -> NonNull> { + NonNull::from(self.ptr) + } +} + +/// An owned tree. +/// +/// Note that this does not have a destructor, and must be cleaned up manually. +pub struct Root { + node: BoxedNode, + /// The number of levels below the root node. + height: usize, +} + +unsafe impl Sync for Root {} +unsafe impl Send for Root {} + +impl Root { + /// Returns the number of levels below the root. + pub fn height(&self) -> usize { + self.height + } + + /// Returns a new owned tree, with its own root node that is initially empty. + pub fn new_leaf() -> Self { + Root { node: BoxedNode::from_leaf(Box::new(unsafe { LeafNode::new() })), height: 0 } + } + + /// Borrows and returns an immutable reference to the node owned by the root. + pub fn node_as_ref(&self) -> NodeRef, K, V, marker::LeafOrInternal> { + NodeRef { height: self.height, node: self.node.as_ptr(), _marker: PhantomData } + } + + /// Borrows and returns a mutable reference to the node owned by the root. + pub fn node_as_mut(&mut self) -> NodeRef, K, V, marker::LeafOrInternal> { + NodeRef { height: self.height, node: self.node.as_ptr(), _marker: PhantomData } + } + + /// Borrows and returns a mutable reference to the leaf node owned by the root. + /// # Safety + /// The root node is a leaf. + unsafe fn leaf_node_as_mut(&mut self) -> NodeRef, K, V, marker::Leaf> { + debug_assert!(self.height == 0); + NodeRef { height: self.height, node: self.node.as_ptr(), _marker: PhantomData } + } + + /// Borrows and returns a mutable reference to the internal node owned by the root. + /// # Safety + /// The root node is not a leaf. + unsafe fn internal_node_as_mut(&mut self) -> NodeRef, K, V, marker::Internal> { + debug_assert!(self.height > 0); + NodeRef { height: self.height, node: self.node.as_ptr(), _marker: PhantomData } + } + + pub fn node_as_valmut(&mut self) -> NodeRef, K, V, marker::LeafOrInternal> { + NodeRef { height: self.height, node: self.node.as_ptr(), _marker: PhantomData } + } + + pub fn into_ref(self) -> NodeRef { + NodeRef { height: self.height, node: self.node.as_ptr(), _marker: PhantomData } + } + + /// Packs the reference, aware of type and height, into a type-agnostic pointer. + fn into_boxed_node(self) -> BoxedNode { + self.node + } + + /// Adds a new internal node with a single edge pointing to the previous root node, + /// make that new node the root node, and return it. This increases the height by 1 + /// and is the opposite of `pop_internal_level`. + pub fn push_internal_level(&mut self) -> NodeRef, K, V, marker::Internal> { + let mut new_node = Box::new(unsafe { InternalNode::new() }); + new_node.edges[0].write(unsafe { ptr::read(&mut self.node) }); + + self.node = BoxedNode::from_internal(new_node); + self.height += 1; + + unsafe { + let mut ret = self.internal_node_as_mut(); + ret.reborrow_mut().first_edge().correct_parent_link(); + ret + } + } + + /// Removes the internal root node, using its first child as the new root node. + /// As it is intended only to be called when the root node has only one child, + /// no cleanup is done on any of the other children. + /// This decreases the height by 1 and is the opposite of `push_internal_level`. + /// + /// Requires exclusive access to the `Root` object but not to the root node; + /// it will not invalidate existing handles or references to the root node. + /// + /// Panics if there is no internal level, i.e., if the root node is a leaf. + pub fn pop_internal_level(&mut self) { + assert!(self.height > 0); + + let top = BoxedNode::as_ptr(&self.node); + + let mut internal_node = unsafe { self.internal_node_as_mut() }; + let internal_node = NodeRef::as_internal_mut(&mut internal_node); + self.node = unsafe { internal_node.edges[0].assume_init_read() }; + self.height -= 1; + self.node_as_mut().clear_parent_link(); + + unsafe { + Global.dealloc(top.cast(), Layout::new::>()); + } + } +} + +// N.B. `NodeRef` is always covariant in `K` and `V`, even when the `BorrowType` +// is `Mut`. This is technically wrong, but cannot result in any unsafety due to +// internal use of `NodeRef` because we stay completely generic over `K` and `V`. +// However, whenever a public type wraps `NodeRef`, make sure that it has the +// correct variance. +/// +/// A reference to a node. +/// +/// This type has a number of parameters that controls how it acts: +/// - `BorrowType`: A dummy type that describes the kind of borrow and carries a lifetime. +/// - When this is `Immut<'a>`, the `NodeRef` acts roughly like `&'a Node`. +/// - When this is `ValMut<'a>`, the `NodeRef` acts roughly like `&'a Node` +/// with respect to keys and tree structure, but also allows many +/// mutable references to values throughout the tree to coexist. +/// - When this is `Mut<'a>`, the `NodeRef` acts roughly like `&'a mut Node`, +/// although insert methods allow a mutable pointer to a value to coexist. +/// - When this is `Owned`, the `NodeRef` acts roughly like `Box`, +/// but does not have a destructor, and must be cleaned up manually. +/// - `K` and `V`: These are the types of keys and values stored in the nodes. +/// - `Type`: This can be `Leaf`, `Internal`, or `LeafOrInternal`. When this is +/// `Leaf`, the `NodeRef` points to a leaf node, when this is `Internal` the +/// `NodeRef` points to an internal node, and when this is `LeafOrInternal` the +/// `NodeRef` could be pointing to either type of node. +/// `Type` is named `NodeType` when used outside `NodeRef`. +/// +/// Both `BorrowType` and `NodeType` restrict what methods we implement, to +/// exploit static type safety. There are limitations in the way we can apply +/// such restrictions: +/// - For each type parameter, we can only define a method either generically +/// or for one particular type. For example, we cannot define a method like +/// `key_at` generically for all `BorrowType`, because we want to return +/// `&'a K` for most choices of `BorrowType`, but plain `K` for `Owned`. +/// We cannot define `key_at` once for all types that have a lifetime. +/// Therefore, we define it only for the least powerful type `Immut<'a>`. +/// - We cannot get implicit coercion from say `Mut<'a>` to `Immut<'a>`. +/// Therefore, we have to explicitly call `reborrow` on a more powerfull +/// `NodeRef` in order to reach a method like `key_at`. +/// - All methods on `NodeRef` that return some kind of reference, except +/// `reborrow` and `reborrow_mut`, take `self` by value and not by reference. +/// This avoids silently returning a second reference somewhere in the tree. +/// That is irrelevant when `BorrowType` is `Immut<'a>`, but the rule does +/// no harm because we make those `NodeRef` implicitly `Copy`. +/// The rule also avoids implicitly returning the lifetime of `&self`, +/// instead of the lifetime contained in `BorrowType`. +/// An exception to this rule are the insert functions. +/// - Given the above, we need a `reborrow_mut` to explicitly copy a `Mut<'a>` +/// `NodeRef` whenever we want to invoke a method returning an extra reference +/// somewhere in the tree. +pub struct NodeRef { + /// The number of levels below the node, a property of the node that cannot be + /// entirely described by `Type` and that the node does not store itself either. + /// Unconstrained if `Type` is `LeafOrInternal`, must be zero if `Type` is `Leaf`, + /// and must be non-zero if `Type` is `Internal`. + height: usize, + /// The pointer to the leaf or internal node. The definition of `InternalNode` + /// ensures that the pointer is valid either way. + node: NonNull>, + _marker: PhantomData<(BorrowType, Type)>, +} + +impl<'a, K: 'a, V: 'a, Type> Copy for NodeRef, K, V, Type> {} +impl<'a, K: 'a, V: 'a, Type> Clone for NodeRef, K, V, Type> { + fn clone(&self) -> Self { + *self + } +} + +unsafe impl Sync for NodeRef {} + +unsafe impl<'a, K: Sync + 'a, V: Sync + 'a, Type> Send for NodeRef, K, V, Type> {} +unsafe impl<'a, K: Send + 'a, V: Send + 'a, Type> Send for NodeRef, K, V, Type> {} +unsafe impl<'a, K: Send + 'a, V: Send + 'a, Type> Send for NodeRef, K, V, Type> {} +unsafe impl Send for NodeRef {} + +impl NodeRef { + /// Unpack a node reference that was packed by `Root::into_boxed_node`. + fn from_boxed_node(boxed_node: BoxedNode, height: usize) -> Self { + NodeRef { height, node: boxed_node.as_ptr(), _marker: PhantomData } + } +} + +impl NodeRef { + /// Unpack a node reference that was packed as `NodeRef::parent`. + fn from_internal(node: NonNull>, height: usize) -> Self { + debug_assert!(height > 0); + NodeRef { height, node: node.cast(), _marker: PhantomData } + } +} + +impl NodeRef { + /// Exposes the data of an internal node. + /// + /// Returns a raw ptr to avoid invalidating other references to this node. + fn as_internal_ptr(this: &Self) -> *mut InternalNode { + // SAFETY: the static node type is `Internal`. + this.node.as_ptr() as *mut InternalNode + } +} + +impl<'a, K, V> NodeRef, K, V, marker::Internal> { + /// Exposes the data of an internal node in an immutable tree. + fn as_internal(this: &Self) -> &'a InternalNode { + let ptr = Self::as_internal_ptr(this); + // SAFETY: there can be no mutable references into this tree borrowed as `Immut`. + unsafe { &*ptr } + } +} + +impl<'a, K, V> NodeRef, K, V, marker::Internal> { + /// Offers exclusive access to the data of an internal node. + fn as_internal_mut(this: &mut Self) -> &'a mut InternalNode { + let ptr = Self::as_internal_ptr(this); + unsafe { &mut *ptr } + } +} + +impl NodeRef { + /// Finds the length of the node. This is the number of keys or values. + /// The number of edges is `len() + 1`. + /// Note that, despite being safe, calling this function can have the side effect + /// of invalidating mutable references that unsafe code has created. + pub fn len(&self) -> usize { + // Crucially, we only access the `len` field here. If BorrowType is marker::ValMut, + // there might be outstanding mutable references to values that we must not invalidate. + unsafe { usize::from((*Self::as_leaf_ptr(self)).len) } + } + + /// Returns the height of this node with respect to the leaf level. Zero height means the + /// node is a leaf itself. + pub fn height(&self) -> usize { + self.height + } + + /// Temporarily takes out another, immutable reference to the same node. + pub fn reborrow(&self) -> NodeRef, K, V, Type> { + NodeRef { height: self.height, node: self.node, _marker: PhantomData } + } + + /// Exposes the leaf portion of any leaf or internal node. + /// + /// Returns a raw ptr to avoid invalidating other references to this node. + fn as_leaf_ptr(this: &Self) -> *mut LeafNode { + // The node must be valid for at least the LeafNode portion. + // This is not a reference in the NodeRef type because we don't know if + // it should be unique or shared. + this.node.as_ptr() + } +} + +impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { + /// Exposes one of the keys stored in the node. + /// + /// # Safety + /// The node has more than `idx` initialized elements. + pub unsafe fn key_at(self, idx: usize) -> &'a K { + debug_assert!(idx < self.len()); + unsafe { Self::as_leaf(&self).keys.get_unchecked(idx).assume_init_ref() } + } + + /// Exposes one of the values stored in the node. + /// + /// # Safety + /// The node has more than `idx` initialized elements. + unsafe fn val_at(self, idx: usize) -> &'a V { + debug_assert!(idx < self.len()); + unsafe { Self::as_leaf(&self).vals.get_unchecked(idx).assume_init_ref() } + } +} + +impl<'a, K, V> NodeRef, K, V, marker::Internal> { + /// Exposes the contents of one of the edges in the node. + /// + /// # Safety + /// The node has more than `idx` initialized elements. + unsafe fn edge_at(self, idx: usize) -> &'a BoxedNode { + debug_assert!(idx <= self.len()); + unsafe { Self::as_internal(&self).edges.get_unchecked(idx).assume_init_ref() } + } +} + +impl NodeRef { + /// Finds the parent of the current node. Returns `Ok(handle)` if the current + /// node actually has a parent, where `handle` points to the edge of the parent + /// that points to the current node. Returns `Err(self)` if the current node has + /// no parent, giving back the original `NodeRef`. + /// + /// `edge.descend().ascend().unwrap()` and `node.ascend().unwrap().descend()` should + /// both, upon success, do nothing. + pub fn ascend( + self, + ) -> Result, marker::Edge>, Self> { + // We need to use raw pointers to nodes because, if BorrowType is marker::ValMut, + // there might be outstanding mutable references to values that we must not invalidate. + let leaf_ptr: *const _ = Self::as_leaf_ptr(&self); + unsafe { (*leaf_ptr).parent } + .as_ref() + .map(|parent| Handle { + node: NodeRef::from_internal(*parent, self.height + 1), + idx: unsafe { usize::from((*leaf_ptr).parent_idx.assume_init()) }, + _marker: PhantomData, + }) + .ok_or(self) + } + + pub fn first_edge(self) -> Handle { + unsafe { Handle::new_edge(self, 0) } + } + + pub fn last_edge(self) -> Handle { + let len = self.len(); + unsafe { Handle::new_edge(self, len) } + } + + /// Note that `self` must be nonempty. + pub fn first_kv(self) -> Handle { + let len = self.len(); + assert!(len > 0); + unsafe { Handle::new_kv(self, 0) } + } + + /// Note that `self` must be nonempty. + pub fn last_kv(self) -> Handle { + let len = self.len(); + assert!(len > 0); + unsafe { Handle::new_kv(self, len - 1) } + } +} + +impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { + /// Exposes the leaf portion of any leaf or internal node in an immutable tree. + fn as_leaf(this: &Self) -> &'a LeafNode { + let ptr = Self::as_leaf_ptr(this); + // SAFETY: there can be no mutable references into this tree borrowed as `Immut`. + unsafe { &*ptr } + } +} + +impl NodeRef { + /// Similar to `ascend`, gets a reference to a node's parent node, but also + /// deallocate the current node in the process. This is unsafe because the + /// current node will still be accessible despite being deallocated. + pub unsafe fn deallocate_and_ascend( + self, + ) -> Option, marker::Edge>> { + let height = self.height; + let node = self.node; + let ret = self.ascend().ok(); + unsafe { + Global.dealloc( + node.cast(), + if height > 0 { + Layout::new::>() + } else { + Layout::new::>() + }, + ); + } + ret + } +} + +impl<'a, K, V, Type> NodeRef, K, V, Type> { + /// Unsafely asserts to the compiler the static information that this node is an `Internal`. + unsafe fn cast_to_internal_unchecked(self) -> NodeRef, K, V, marker::Internal> { + debug_assert!(self.height > 0); + NodeRef { height: self.height, node: self.node, _marker: PhantomData } + } + + /// Temporarily takes out another, mutable reference to the same node. Beware, as + /// this method is very dangerous, doubly so since it may not immediately appear + /// dangerous. + /// + /// Because mutable pointers can roam anywhere around the tree, the returned + /// pointer can easily be used to make the original pointer dangling, out of + /// bounds, or invalid under stacked borrow rules. + // FIXME(@gereeter) consider adding yet another type parameter to `NodeRef` + // that restricts the use of navigation methods on reborrowed pointers, + // preventing this unsafety. + unsafe fn reborrow_mut(&mut self) -> NodeRef, K, V, Type> { + NodeRef { height: self.height, node: self.node, _marker: PhantomData } + } + + /// Offers exclusive access to the leaf portion of any leaf or internal node. + fn as_leaf_mut(this: &mut Self) -> &'a mut LeafNode { + let ptr = Self::as_leaf_ptr(this); + // SAFETY: we have exclusive access to the entire node. + unsafe { &mut *ptr } + } +} + +impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { + /// Offers exclusive access to a part of the key storage area. + /// + /// # Safety + /// The node has more than `idx` initialized elements. + unsafe fn into_key_area_mut_at(mut self, idx: usize) -> &'a mut MaybeUninit { + debug_assert!(idx < self.len()); + unsafe { Self::as_leaf_mut(&mut self).keys.get_unchecked_mut(idx) } + } + + /// Offers exclusive access to a part of the value storage area. + /// + /// # Safety + /// The node has more than `idx` initialized elements. + unsafe fn into_val_area_mut_at(mut self, idx: usize) -> &'a mut MaybeUninit { + debug_assert!(idx < self.len()); + unsafe { Self::as_leaf_mut(&mut self).vals.get_unchecked_mut(idx) } + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::Internal> { + /// Offers exclusive access to a part of the storage area for edge contents. + /// + /// # Safety + /// The node has at least `idx` initialized elements. + unsafe fn into_edge_area_mut_at(mut self, idx: usize) -> &'a mut MaybeUninit> { + debug_assert!(idx <= self.len()); + unsafe { Self::as_internal_mut(&mut self).edges.get_unchecked_mut(idx) } + } +} + +impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { + /// Exposes the entire key storage area in the node, + /// regardless of the node's current length, + /// having exclusive access to the entire node. + unsafe fn key_area(self) -> &'a [MaybeUninit] { + Self::as_leaf(&self).keys.as_slice() + } + + /// Exposes the entire value storage area in the node, + /// regardless of the node's current length, + /// having exclusive access to the entire node. + unsafe fn val_area(self) -> &'a [MaybeUninit] { + Self::as_leaf(&self).vals.as_slice() + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::Internal> { + /// Exposes the entire storage area for edge contents in the node, + /// regardless of the node's current length, + /// having exclusive access to the entire node. + unsafe fn edge_area(self) -> &'a [MaybeUninit>] { + Self::as_internal(&self).edges.as_slice() + } +} + +impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { + /// Offers exclusive access to a sized slice of key storage area in the node. + unsafe fn into_key_area_slice(mut self) -> &'a mut [MaybeUninit] { + let len = self.len(); + // SAFETY: the caller will not be able to call further methods on self + // until the key slice reference is dropped, as we have unique access + // for the lifetime of the borrow. + unsafe { Self::as_leaf_mut(&mut self).keys.get_unchecked_mut(..len) } + } + + /// Offers exclusive access to a sized slice of value storage area in the node. + unsafe fn into_val_area_slice(mut self) -> &'a mut [MaybeUninit] { + let len = self.len(); + // SAFETY: the caller will not be able to call further methods on self + // until the value slice reference is dropped, as we have unique access + // for the lifetime of the borrow. + unsafe { Self::as_leaf_mut(&mut self).vals.get_unchecked_mut(..len) } + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::Internal> { + /// Offers exclusive access to a sized slice of storage area for edge contents in the node. + unsafe fn into_edge_area_slice(mut self) -> &'a mut [MaybeUninit>] { + let len = self.len(); + // SAFETY: the caller will not be able to call further methods on self + // until the edge slice reference is dropped, as we have unique access + // for the lifetime of the borrow. + unsafe { Self::as_internal_mut(&mut self).edges.get_unchecked_mut(..len + 1) } + } +} + +impl<'a, K, V, Type> NodeRef, K, V, Type> { + /// # Safety + /// - The node has more than `idx` initialized elements. + /// - The keys and values of the node must be initialized up to its current length. + unsafe fn into_key_val_mut_at(mut self, idx: usize) -> (&'a K, &'a mut V) { + // We only create a reference to the one element we are interested in, + // to avoid aliasing with outstanding references to other elements, + // in particular, those returned to the caller in earlier iterations. + let leaf = Self::as_leaf_ptr(&mut self); + let keys = unsafe { &raw const (*leaf).keys }; + let vals = unsafe { &raw mut (*leaf).vals }; + // We must coerce to unsized array pointers because of Rust issue #74679. + let keys: *const [_] = keys; + let vals: *mut [_] = vals; + let key = unsafe { (&*keys.get_unchecked(idx)).assume_init_ref() }; + let val = unsafe { (&mut *vals.get_unchecked_mut(idx)).assume_init_mut() }; + (key, val) + } +} + +impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { + /// Exposes exclusive access to the length of the node. + pub fn into_len_mut(mut self) -> &'a mut u16 { + &mut (*Self::as_leaf_mut(&mut self)).len + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::LeafOrInternal> { + /// Set or clear the node's link to its parent edge, + /// without invalidating other references to the node. + fn set_parent_link(&mut self, parent: NonNull>, parent_idx: usize) { + let leaf = Self::as_leaf_ptr(self); + unsafe { (*leaf).parent = Some(parent) }; + unsafe { (*leaf).parent_idx.write(parent_idx as u16) }; + } + + /// Clear the node's link to its parent edge, freeing it from its tree. + /// This only makes sense when there are no other references to the node. + fn clear_parent_link(&mut self) { + let leaf = Self::as_leaf_mut(self); + leaf.parent = None; + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::Leaf> { + /// Adds a key/value pair to the end of the node. + pub fn push(&mut self, key: K, val: V) { + let len = unsafe { self.reborrow_mut().into_len_mut() }; + let idx = usize::from(*len); + assert!(idx < CAPACITY); + *len += 1; + unsafe { + self.reborrow_mut().into_key_area_mut_at(idx).write(key); + self.reborrow_mut().into_val_area_mut_at(idx).write(val); + } + } + + /// Adds a key/value pair to the beginning of the node. + fn push_front(&mut self, key: K, val: V) { + assert!(self.len() < CAPACITY); + + unsafe { + *self.reborrow_mut().into_len_mut() += 1; + slice_insert(self.reborrow_mut().into_key_area_slice(), 0, key); + slice_insert(self.reborrow_mut().into_val_area_slice(), 0, val); + } + } +} + +impl<'a, K, V> NodeRef, K, V, marker::Internal> { + /// # Safety + /// Every item returned by `range` is a valid edge index for the node. + unsafe fn correct_childrens_parent_links>(&mut self, range: R) { + for i in range { + debug_assert!(i <= self.len()); + unsafe { Handle::new_edge(self.reborrow_mut(), i) }.correct_parent_link(); + } + } + + fn correct_all_childrens_parent_links(&mut self) { + let len = self.len(); + unsafe { self.correct_childrens_parent_links(0..=len) }; + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::Internal> { + /// Adds a key/value pair, and an edge to go to the right of that pair, + /// to the end of the node. + pub fn push(&mut self, key: K, val: V, edge: Root) { + assert!(edge.height == self.height - 1); + + let len = unsafe { self.reborrow_mut().into_len_mut() }; + let idx = usize::from(*len); + assert!(idx < CAPACITY); + *len += 1; + unsafe { + self.reborrow_mut().into_key_area_mut_at(idx).write(key); + self.reborrow_mut().into_val_area_mut_at(idx).write(val); + self.reborrow_mut().into_edge_area_mut_at(idx + 1).write(edge.into_boxed_node()); + Handle::new_edge(self.reborrow_mut(), idx + 1).correct_parent_link(); + } + } + + /// Adds a key/value pair, and an edge to go to the left of that pair, + /// to the beginning of the node. + fn push_front(&mut self, key: K, val: V, edge: Root) { + assert!(edge.height == self.height - 1); + assert!(self.len() < CAPACITY); + + unsafe { + *self.reborrow_mut().into_len_mut() += 1; + slice_insert(self.reborrow_mut().into_key_area_slice(), 0, key); + slice_insert(self.reborrow_mut().into_val_area_slice(), 0, val); + slice_insert(self.reborrow_mut().into_edge_area_slice(), 0, edge.into_boxed_node()); + } + + self.correct_all_childrens_parent_links(); + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::LeafOrInternal> { + /// Removes a key/value pair from the end of the node and returns the pair. + /// Also removes the edge that was to the right of that pair and, if the node + /// is internal, returns the orphaned subtree that this edge owned. + fn pop(&mut self) -> (K, V, Option>) { + debug_assert!(self.len() > 0); + + let idx = self.len() - 1; + + unsafe { + let key = ptr::read(self.reborrow().key_at(idx)); + let val = ptr::read(self.reborrow().val_at(idx)); + let edge = match self.reborrow_mut().force() { + ForceResult::Leaf(_) => None, + ForceResult::Internal(internal) => { + let boxed_node = ptr::read(internal.reborrow().edge_at(idx + 1)); + let mut edge = Root { node: boxed_node, height: internal.height - 1 }; + // In practice, clearing the parent is a waste of time, because we will + // insert the node elsewhere and set its parent link again. + edge.node_as_mut().clear_parent_link(); + Some(edge) + } + }; + + *self.reborrow_mut().into_len_mut() -= 1; + (key, val, edge) + } + } + + /// Removes a key/value pair from the beginning of the node and returns the pair. + /// Also removes the edge that was to the left of that pair and, if the node is + /// internal, returns the orphaned subtree that this edge owned. + fn pop_front(&mut self) -> (K, V, Option>) { + debug_assert!(self.len() > 0); + + let old_len = self.len(); + + unsafe { + let key = slice_remove(self.reborrow_mut().into_key_area_slice(), 0); + let val = slice_remove(self.reborrow_mut().into_val_area_slice(), 0); + let edge = match self.reborrow_mut().force() { + ForceResult::Leaf(_) => None, + ForceResult::Internal(mut internal) => { + let boxed_node = + slice_remove(internal.reborrow_mut().into_edge_area_slice(), 0); + let mut edge = Root { node: boxed_node, height: internal.height - 1 }; + // In practice, clearing the parent is a waste of time, because we will + // insert the node elsewhere and set its parent link again. + edge.node_as_mut().clear_parent_link(); + + internal.correct_childrens_parent_links(0..old_len); + + Some(edge) + } + }; + + *self.reborrow_mut().into_len_mut() -= 1; + + (key, val, edge) + } + } + + fn into_kv_pointers_mut(mut self) -> (*mut K, *mut V) { + let leaf = Self::as_leaf_mut(&mut self); + let keys = MaybeUninit::slice_as_mut_ptr(&mut leaf.keys); + let vals = MaybeUninit::slice_as_mut_ptr(&mut leaf.vals); + (keys, vals) + } +} + +impl NodeRef { + /// Checks whether a node is an `Internal` node or a `Leaf` node. + pub fn force( + self, + ) -> ForceResult< + NodeRef, + NodeRef, + > { + if self.height == 0 { + ForceResult::Leaf(NodeRef { + height: self.height, + node: self.node, + _marker: PhantomData, + }) + } else { + ForceResult::Internal(NodeRef { + height: self.height, + node: self.node, + _marker: PhantomData, + }) + } + } +} + +/// A reference to a specific key/value pair or edge within a node. The `Node` parameter +/// must be a `NodeRef`, while the `Type` can either be `KV` (signifying a handle on a key/value +/// pair) or `Edge` (signifying a handle on an edge). +/// +/// Note that even `Leaf` nodes can have `Edge` handles. Instead of representing a pointer to +/// a child node, these represent the spaces where child pointers would go between the key/value +/// pairs. For example, in a node with length 2, there would be 3 possible edge locations - one +/// to the left of the node, one between the two pairs, and one at the right of the node. +pub struct Handle { + node: Node, + idx: usize, + _marker: PhantomData, +} + +impl Copy for Handle {} +// We don't need the full generality of `#[derive(Clone)]`, as the only time `Node` will be +// `Clone`able is when it is an immutable reference and therefore `Copy`. +impl Clone for Handle { + fn clone(&self) -> Self { + *self + } +} + +impl Handle { + /// Retrieves the node that contains the edge or key/value pair this handle points to. + pub fn into_node(self) -> Node { + self.node + } + + /// Returns the position of this handle in the node. + pub fn idx(&self) -> usize { + self.idx + } +} + +impl Handle, marker::KV> { + /// Creates a new handle to a key/value pair in `node`. + /// Unsafe because the caller must ensure that `idx < node.len()`. + pub unsafe fn new_kv(node: NodeRef, idx: usize) -> Self { + debug_assert!(idx < node.len()); + + Handle { node, idx, _marker: PhantomData } + } + + pub fn left_edge(self) -> Handle, marker::Edge> { + unsafe { Handle::new_edge(self.node, self.idx) } + } + + pub fn right_edge(self) -> Handle, marker::Edge> { + unsafe { Handle::new_edge(self.node, self.idx + 1) } + } +} + +impl NodeRef { + /// Could be a public implementation of PartialEq, but only used in this module. + fn eq(&self, other: &Self) -> bool { + let Self { node, height, _marker: _ } = self; + if node.eq(&other.node) { + debug_assert_eq!(*height, other.height); + true + } else { + false + } + } +} + +impl PartialEq + for Handle, HandleType> +{ + fn eq(&self, other: &Self) -> bool { + let Self { node, idx, _marker: _ } = self; + node.eq(&other.node) && *idx == other.idx + } +} + +impl PartialOrd + for Handle, HandleType> +{ + fn partial_cmp(&self, other: &Self) -> Option { + let Self { node, idx, _marker: _ } = self; + if node.eq(&other.node) { Some(idx.cmp(&other.idx)) } else { None } + } +} + +impl + Handle, HandleType> +{ + /// Temporarily takes out another, immutable handle on the same location. + pub fn reborrow(&self) -> Handle, K, V, NodeType>, HandleType> { + // We can't use Handle::new_kv or Handle::new_edge because we don't know our type + Handle { node: self.node.reborrow(), idx: self.idx, _marker: PhantomData } + } +} + +impl<'a, K, V, NodeType, HandleType> Handle, K, V, NodeType>, HandleType> { + /// Temporarily takes out another, mutable handle on the same location. Beware, as + /// this method is very dangerous, doubly so since it may not immediately appear + /// dangerous. + /// + /// For details, see `NodeRef::reborrow_mut`. + pub unsafe fn reborrow_mut( + &mut self, + ) -> Handle, K, V, NodeType>, HandleType> { + // We can't use Handle::new_kv or Handle::new_edge because we don't know our type + Handle { node: unsafe { self.node.reborrow_mut() }, idx: self.idx, _marker: PhantomData } + } +} + +impl Handle, marker::Edge> { + /// Creates a new handle to an edge in `node`. + /// Unsafe because the caller must ensure that `idx <= node.len()`. + pub unsafe fn new_edge(node: NodeRef, idx: usize) -> Self { + debug_assert!(idx <= node.len()); + + Handle { node, idx, _marker: PhantomData } + } + + pub fn left_kv(self) -> Result, marker::KV>, Self> { + if self.idx > 0 { + Ok(unsafe { Handle::new_kv(self.node, self.idx - 1) }) + } else { + Err(self) + } + } + + pub fn right_kv(self) -> Result, marker::KV>, Self> { + if self.idx < self.node.len() { + Ok(unsafe { Handle::new_kv(self.node, self.idx) }) + } else { + Err(self) + } + } +} + +enum InsertionPlace { + Left(usize), + Right(usize), +} + +/// Given an edge index where we want to insert into a node filled to capacity, +/// computes a sensible KV index of a split point and where to perform the insertion. +/// The goal of the split point is for its key and value to end up in a parent node; +/// the keys, values and edges to the left of the split point become the left child; +/// the keys, values and edges to the right of the split point become the right child. +fn splitpoint(edge_idx: usize) -> (usize, InsertionPlace) { + debug_assert!(edge_idx <= CAPACITY); + // Rust issue #74834 tries to explain these symmetric rules. + match edge_idx { + 0..EDGE_IDX_LEFT_OF_CENTER => (KV_IDX_CENTER - 1, InsertionPlace::Left(edge_idx)), + EDGE_IDX_LEFT_OF_CENTER => (KV_IDX_CENTER, InsertionPlace::Left(edge_idx)), + EDGE_IDX_RIGHT_OF_CENTER => (KV_IDX_CENTER, InsertionPlace::Right(0)), + _ => (KV_IDX_CENTER + 1, InsertionPlace::Right(edge_idx - (KV_IDX_CENTER + 1 + 1))), + } +} + +impl<'a, K: 'a, V: 'a> Handle, K, V, marker::Leaf>, marker::Edge> { + /// Inserts a new key/value pair between the key/value pairs to the right and left of + /// this edge. This method assumes that there is enough space in the node for the new + /// pair to fit. + /// + /// The returned pointer points to the inserted value. + fn insert_fit(&mut self, key: K, val: V) -> *mut V { + debug_assert!(self.node.len() < CAPACITY); + + unsafe { + *self.node.reborrow_mut().into_len_mut() += 1; + slice_insert(self.node.reborrow_mut().into_key_area_slice(), self.idx, key); + slice_insert(self.node.reborrow_mut().into_val_area_slice(), self.idx, val); + + self.node.reborrow_mut().into_val_area_mut_at(self.idx).assume_init_mut() + } + } +} + +impl<'a, K: 'a, V: 'a> Handle, K, V, marker::Leaf>, marker::Edge> { + /// Inserts a new key/value pair between the key/value pairs to the right and left of + /// this edge. This method splits the node if there isn't enough room. + /// + /// The returned pointer points to the inserted value. + fn insert(mut self, key: K, val: V) -> (InsertResult<'a, K, V, marker::Leaf>, *mut V) { + if self.node.len() < CAPACITY { + let val_ptr = self.insert_fit(key, val); + let kv = unsafe { Handle::new_kv(self.node, self.idx) }; + (InsertResult::Fit(kv), val_ptr) + } else { + let (middle_kv_idx, insertion) = splitpoint(self.idx); + let middle = unsafe { Handle::new_kv(self.node, middle_kv_idx) }; + let (mut left, k, v, mut right) = middle.split(); + let mut insertion_edge = match insertion { + InsertionPlace::Left(insert_idx) => unsafe { + Handle::new_edge(left.reborrow_mut(), insert_idx) + }, + InsertionPlace::Right(insert_idx) => unsafe { + Handle::new_edge(right.leaf_node_as_mut(), insert_idx) + }, + }; + let val_ptr = insertion_edge.insert_fit(key, val); + (InsertResult::Split(SplitResult { left: left.forget_type(), k, v, right }), val_ptr) + } + } +} + +impl<'a, K, V> Handle, K, V, marker::Internal>, marker::Edge> { + /// Fixes the parent pointer and index in the child node below this edge. This is useful + /// when the ordering of edges has been changed, such as in the various `insert` methods. + fn correct_parent_link(self) { + // Create backpointer without invalidating other references to the node. + let ptr = unsafe { NonNull::new_unchecked(NodeRef::as_internal_ptr(&self.node)) }; + let idx = self.idx; + let mut child = self.descend(); + child.set_parent_link(ptr, idx); + } +} + +impl<'a, K: 'a, V: 'a> Handle, K, V, marker::Internal>, marker::Edge> { + /// Inserts a new key/value pair and an edge that will go to the right of that new pair + /// between this edge and the key/value pair to the right of this edge. This method assumes + /// that there is enough space in the node for the new pair to fit. + fn insert_fit(&mut self, key: K, val: V, edge: Root) { + debug_assert!(self.node.len() < CAPACITY); + debug_assert!(edge.height == self.node.height - 1); + + let boxed_node = edge.into_boxed_node(); + unsafe { + *self.node.reborrow_mut().into_len_mut() += 1; + slice_insert(self.node.reborrow_mut().into_key_area_slice(), self.idx, key); + slice_insert(self.node.reborrow_mut().into_val_area_slice(), self.idx, val); + slice_insert(self.node.reborrow_mut().into_edge_area_slice(), self.idx + 1, boxed_node); + + self.node.correct_childrens_parent_links((self.idx + 1)..=self.node.len()); + } + } + + /// Inserts a new key/value pair and an edge that will go to the right of that new pair + /// between this edge and the key/value pair to the right of this edge. This method splits + /// the node if there isn't enough room. + fn insert( + mut self, + key: K, + val: V, + edge: Root, + ) -> InsertResult<'a, K, V, marker::Internal> { + assert!(edge.height == self.node.height - 1); + + if self.node.len() < CAPACITY { + self.insert_fit(key, val, edge); + let kv = unsafe { Handle::new_kv(self.node, self.idx) }; + InsertResult::Fit(kv) + } else { + let (middle_kv_idx, insertion) = splitpoint(self.idx); + let middle = unsafe { Handle::new_kv(self.node, middle_kv_idx) }; + let (mut left, k, v, mut right) = middle.split(); + let mut insertion_edge = match insertion { + InsertionPlace::Left(insert_idx) => unsafe { + Handle::new_edge(left.reborrow_mut(), insert_idx) + }, + InsertionPlace::Right(insert_idx) => unsafe { + Handle::new_edge(right.internal_node_as_mut(), insert_idx) + }, + }; + insertion_edge.insert_fit(key, val, edge); + InsertResult::Split(SplitResult { left: left.forget_type(), k, v, right }) + } + } +} + +impl<'a, K: 'a, V: 'a> Handle, K, V, marker::Leaf>, marker::Edge> { + /// Inserts a new key/value pair between the key/value pairs to the right and left of + /// this edge. This method splits the node if there isn't enough room, and tries to + /// insert the split off portion into the parent node recursively, until the root is reached. + /// + /// If the returned result is a `Fit`, its handle's node can be this edge's node or an ancestor. + /// If the returned result is a `Split`, the `left` field will be the root node. + /// The returned pointer points to the inserted value. + pub fn insert_recursing( + self, + key: K, + value: V, + ) -> (InsertResult<'a, K, V, marker::LeafOrInternal>, *mut V) { + let (mut split, val_ptr) = match self.insert(key, value) { + (InsertResult::Fit(handle), ptr) => { + return (InsertResult::Fit(handle.forget_node_type()), ptr); + } + (InsertResult::Split(split), val_ptr) => (split, val_ptr), + }; + + loop { + split = match split.left.ascend() { + Ok(parent) => match parent.insert(split.k, split.v, split.right) { + InsertResult::Fit(handle) => { + return (InsertResult::Fit(handle.forget_node_type()), val_ptr); + } + InsertResult::Split(split) => split, + }, + Err(root) => { + return (InsertResult::Split(SplitResult { left: root, ..split }), val_ptr); + } + }; + } + } +} + +impl Handle, marker::Edge> { + /// Finds the node pointed to by this edge. + /// + /// `edge.descend().ascend().unwrap()` and `node.ascend().unwrap().descend()` should + /// both, upon success, do nothing. + pub fn descend(self) -> NodeRef { + // We need to use raw pointers to nodes because, if BorrowType is + // marker::ValMut, there might be outstanding mutable references to + // values that we must not invalidate. There's no worry accessing the + // height field because that value is copied. Beware that, once the + // node pointer is dereferenced, we access the edges array with a + // reference (Rust issue #73987) and invalidate any other references + // to or inside the array, should any be around. + let parent_ptr = NodeRef::as_internal_ptr(&self.node); + let boxed_node = unsafe { (*parent_ptr).edges.get_unchecked(self.idx).assume_init_read() }; + NodeRef::from_boxed_node(boxed_node, self.node.height - 1) + } +} + +impl<'a, K: 'a, V: 'a, NodeType> Handle, K, V, NodeType>, marker::KV> { + pub fn into_kv(self) -> (&'a K, &'a V) { + (unsafe { self.node.key_at(self.idx) }, unsafe { self.node.val_at(self.idx) }) + } +} + +impl<'a, K: 'a, V: 'a, NodeType> Handle, K, V, NodeType>, marker::KV> { + pub fn into_key_mut(self) -> &'a mut K { + unsafe { self.node.into_key_area_mut_at(self.idx).assume_init_mut() } + } + + pub fn into_val_mut(self) -> &'a mut V { + unsafe { self.node.into_val_area_mut_at(self.idx).assume_init_mut() } + } +} + +impl<'a, K, V, NodeType> Handle, K, V, NodeType>, marker::KV> { + pub fn into_kv_valmut(self) -> (&'a K, &'a mut V) { + unsafe { self.node.into_key_val_mut_at(self.idx) } + } +} + +impl<'a, K: 'a, V: 'a, NodeType> Handle, K, V, NodeType>, marker::KV> { + pub fn kv_mut(&mut self) -> (&mut K, &mut V) { + // We cannot call separate key and value methods, because calling the second one + // invalidates the reference returned by the first. + unsafe { + let leaf = NodeRef::as_leaf_mut(&mut self.node.reborrow_mut()); + let key = leaf.keys.get_unchecked_mut(self.idx).assume_init_mut(); + let val = leaf.vals.get_unchecked_mut(self.idx).assume_init_mut(); + (key, val) + } + } +} + +impl<'a, K: 'a, V: 'a, NodeType> Handle, K, V, NodeType>, marker::KV> { + /// Helps implementations of `split` for a particular `NodeType`, + /// by calculating the length of the new node. + fn split_new_node_len(&self) -> usize { + debug_assert!(self.idx < self.node.len()); + self.node.len() - self.idx - 1 + } + + /// Helps implementations of `split` for a particular `NodeType`, + /// by taking care of leaf data. + fn split_leaf_data(&mut self, new_node: &mut LeafNode) -> (K, V) { + let new_len = self.split_new_node_len(); + new_node.len = new_len as u16; + unsafe { + let k = ptr::read(self.node.reborrow().key_at(self.idx)); + let v = ptr::read(self.node.reborrow().val_at(self.idx)); + + ptr::copy_nonoverlapping( + self.node.reborrow().key_area().as_ptr().add(self.idx + 1), + new_node.keys.as_mut_ptr(), + new_len, + ); + ptr::copy_nonoverlapping( + self.node.reborrow().val_area().as_ptr().add(self.idx + 1), + new_node.vals.as_mut_ptr(), + new_len, + ); + + *self.node.reborrow_mut().into_len_mut() = self.idx as u16; + (k, v) + } + } +} + +impl<'a, K: 'a, V: 'a> Handle, K, V, marker::Leaf>, marker::KV> { + /// Splits the underlying node into three parts: + /// + /// - The node is truncated to only contain the key/value pairs to the left of + /// this handle. + /// - The key and value pointed to by this handle are extracted. + /// - All the key/value pairs to the right of this handle are put into a newly + /// allocated node. + pub fn split(mut self) -> (NodeRef, K, V, marker::Leaf>, K, V, Root) { + unsafe { + let mut new_node = Box::new(LeafNode::new()); + + let (k, v) = self.split_leaf_data(&mut new_node); + + let right = Root { node: BoxedNode::from_leaf(new_node), height: 0 }; + (self.node, k, v, right) + } + } + + /// Removes the key/value pair pointed to by this handle and returns it, along with the edge + /// that the key/value pair collapsed into. + pub fn remove( + mut self, + ) -> ((K, V), Handle, K, V, marker::Leaf>, marker::Edge>) { + unsafe { + let k = slice_remove(self.node.reborrow_mut().into_key_area_slice(), self.idx); + let v = slice_remove(self.node.reborrow_mut().into_val_area_slice(), self.idx); + *self.node.reborrow_mut().into_len_mut() -= 1; + ((k, v), self.left_edge()) + } + } +} + +impl<'a, K, V> Handle, K, V, marker::Internal>, marker::KV> { + /// Returns `true` if it is valid to call `.merge()`, i.e., whether there is enough room in + /// a node to hold the combination of the nodes to the left and right of this handle along + /// with the key/value pair at this handle. + pub fn can_merge(&self) -> bool { + (self.reborrow().left_edge().descend().len() + + self.reborrow().right_edge().descend().len() + + 1) + <= CAPACITY + } +} + +impl<'a, K: 'a, V: 'a> Handle, K, V, marker::Internal>, marker::KV> { + /// Splits the underlying node into three parts: + /// + /// - The node is truncated to only contain the edges and key/value pairs to the + /// left of this handle. + /// - The key and value pointed to by this handle are extracted. + /// - All the edges and key/value pairs to the right of this handle are put into + /// a newly allocated node. + pub fn split(mut self) -> (NodeRef, K, V, marker::Internal>, K, V, Root) { + unsafe { + let mut new_node = Box::new(InternalNode::new()); + let new_len = self.split_new_node_len(); + // Move edges out before reducing length: + ptr::copy_nonoverlapping( + self.node.reborrow().edge_area().as_ptr().add(self.idx + 1), + new_node.edges.as_mut_ptr(), + new_len + 1, + ); + let (k, v) = self.split_leaf_data(&mut new_node.data); + + let height = self.node.height; + let mut right = Root { node: BoxedNode::from_internal(new_node), height }; + + right.internal_node_as_mut().correct_childrens_parent_links(0..=new_len); + + (self.node, k, v, right) + } + } + + /// Combines the node immediately to the left of this handle, the key/value pair pointed + /// to by this handle, and the node immediately to the right of this handle into one new + /// child of the underlying node, returning an edge referencing that new child. + /// + /// Panics unless this edge `.can_merge()`. + pub fn merge( + mut self, + ) -> Handle, K, V, marker::Internal>, marker::Edge> { + let self1 = unsafe { ptr::read(&self) }; + let self2 = unsafe { ptr::read(&self) }; + let mut left_node = self1.left_edge().descend(); + let left_len = left_node.len(); + let right_node = self2.right_edge().descend(); + let right_len = right_node.len(); + + assert!(left_len + right_len < CAPACITY); + + unsafe { + *left_node.reborrow_mut().into_len_mut() += right_len as u16 + 1; + + let parent_key = slice_remove(self.node.reborrow_mut().into_key_area_slice(), self.idx); + left_node.reborrow_mut().into_key_area_mut_at(left_len).write(parent_key); + ptr::copy_nonoverlapping( + right_node.reborrow().key_area().as_ptr(), + left_node.reborrow_mut().into_key_area_slice().as_mut_ptr().add(left_len + 1), + right_len, + ); + + let parent_val = slice_remove(self.node.reborrow_mut().into_val_area_slice(), self.idx); + left_node.reborrow_mut().into_val_area_mut_at(left_len).write(parent_val); + ptr::copy_nonoverlapping( + right_node.reborrow().val_area().as_ptr(), + left_node.reborrow_mut().into_val_area_slice().as_mut_ptr().add(left_len + 1), + right_len, + ); + + slice_remove(&mut self.node.reborrow_mut().into_edge_area_slice(), self.idx + 1); + let self_len = self.node.len(); + self.node.correct_childrens_parent_links(self.idx + 1..self_len); + *self.node.reborrow_mut().into_len_mut() -= 1; + + if self.node.height > 1 { + // SAFETY: the height of the nodes being merged is one below the height + // of the node of this edge, thus above zero, so they are internal. + let mut left_node = left_node.cast_to_internal_unchecked(); + let right_node = right_node.cast_to_internal_unchecked(); + ptr::copy_nonoverlapping( + right_node.reborrow().edge_area().as_ptr(), + left_node.reborrow_mut().into_edge_area_slice().as_mut_ptr().add(left_len + 1), + right_len + 1, + ); + + left_node.correct_childrens_parent_links(left_len + 1..=left_len + 1 + right_len); + + Global.dealloc(right_node.node.cast(), Layout::new::>()); + } else { + Global.dealloc(right_node.node.cast(), Layout::new::>()); + } + + Handle::new_edge(self.node, self.idx) + } + } + + /// This removes a key/value pair from the left child and places it in the key/value storage + /// pointed to by this handle while pushing the old key/value pair of this handle into the right + /// child. + pub fn steal_left(&mut self) { + unsafe { + let (k, v, edge) = self.reborrow_mut().left_edge().descend().pop(); + + let k = mem::replace(self.kv_mut().0, k); + let v = mem::replace(self.kv_mut().1, v); + + match self.reborrow_mut().right_edge().descend().force() { + ForceResult::Leaf(mut leaf) => leaf.push_front(k, v), + ForceResult::Internal(mut internal) => internal.push_front(k, v, edge.unwrap()), + } + } + } + + /// This removes a key/value pair from the right child and places it in the key/value storage + /// pointed to by this handle while pushing the old key/value pair of this handle into the left + /// child. + pub fn steal_right(&mut self) { + unsafe { + let (k, v, edge) = self.reborrow_mut().right_edge().descend().pop_front(); + + let k = mem::replace(self.kv_mut().0, k); + let v = mem::replace(self.kv_mut().1, v); + + match self.reborrow_mut().left_edge().descend().force() { + ForceResult::Leaf(mut leaf) => leaf.push(k, v), + ForceResult::Internal(mut internal) => internal.push(k, v, edge.unwrap()), + } + } + } + + /// This does stealing similar to `steal_left` but steals multiple elements at once. + pub fn bulk_steal_left(&mut self, count: usize) { + unsafe { + let mut left_node = ptr::read(self).left_edge().descend(); + let left_len = left_node.len(); + let mut right_node = ptr::read(self).right_edge().descend(); + let right_len = right_node.len(); + + // Make sure that we may steal safely. + assert!(right_len + count <= CAPACITY); + assert!(left_len >= count); + + let new_left_len = left_len - count; + + // Move data. + { + let left_kv = left_node.reborrow_mut().into_kv_pointers_mut(); + let right_kv = right_node.reborrow_mut().into_kv_pointers_mut(); + let parent_kv = { + let kv = self.kv_mut(); + (kv.0 as *mut K, kv.1 as *mut V) + }; + + // Make room for stolen elements in the right child. + ptr::copy(right_kv.0, right_kv.0.add(count), right_len); + ptr::copy(right_kv.1, right_kv.1.add(count), right_len); + + // Move elements from the left child to the right one. + move_kv(left_kv, new_left_len + 1, right_kv, 0, count - 1); + + // Move parent's key/value pair to the right child. + move_kv(parent_kv, 0, right_kv, count - 1, 1); + + // Move the left-most stolen pair to the parent. + move_kv(left_kv, new_left_len, parent_kv, 0, 1); + } + + *left_node.reborrow_mut().into_len_mut() -= count as u16; + *right_node.reborrow_mut().into_len_mut() += count as u16; + + match (left_node.force(), right_node.force()) { + (ForceResult::Internal(left), ForceResult::Internal(mut right)) => { + // Make room for stolen edges. + let left = left.reborrow(); + let right_edges = right.reborrow_mut().into_edge_area_slice().as_mut_ptr(); + ptr::copy(right_edges, right_edges.add(count), right_len + 1); + right.correct_childrens_parent_links(count..count + right_len + 1); + + move_edges(left, new_left_len + 1, right, 0, count); + } + (ForceResult::Leaf(_), ForceResult::Leaf(_)) => {} + _ => unreachable!(), + } + } + } + + /// The symmetric clone of `bulk_steal_left`. + pub fn bulk_steal_right(&mut self, count: usize) { + unsafe { + let mut left_node = ptr::read(self).left_edge().descend(); + let left_len = left_node.len(); + let mut right_node = ptr::read(self).right_edge().descend(); + let right_len = right_node.len(); + + // Make sure that we may steal safely. + assert!(left_len + count <= CAPACITY); + assert!(right_len >= count); + + let new_right_len = right_len - count; + + // Move data. + { + let left_kv = left_node.reborrow_mut().into_kv_pointers_mut(); + let right_kv = right_node.reborrow_mut().into_kv_pointers_mut(); + let parent_kv = { + let kv = self.kv_mut(); + (kv.0 as *mut K, kv.1 as *mut V) + }; + + // Move parent's key/value pair to the left child. + move_kv(parent_kv, 0, left_kv, left_len, 1); + + // Move elements from the right child to the left one. + move_kv(right_kv, 0, left_kv, left_len + 1, count - 1); + + // Move the right-most stolen pair to the parent. + move_kv(right_kv, count - 1, parent_kv, 0, 1); + + // Fix right indexing + ptr::copy(right_kv.0.add(count), right_kv.0, new_right_len); + ptr::copy(right_kv.1.add(count), right_kv.1, new_right_len); + } + + *left_node.reborrow_mut().into_len_mut() += count as u16; + *right_node.reborrow_mut().into_len_mut() -= count as u16; + + match (left_node.force(), right_node.force()) { + (ForceResult::Internal(left), ForceResult::Internal(mut right)) => { + move_edges(right.reborrow(), 0, left, left_len + 1, count); + + // Fix right indexing. + let right_edges = right.reborrow_mut().into_edge_area_slice().as_mut_ptr(); + ptr::copy(right_edges.add(count), right_edges, new_right_len + 1); + right.correct_childrens_parent_links(0..=new_right_len); + } + (ForceResult::Leaf(_), ForceResult::Leaf(_)) => {} + _ => unreachable!(), + } + } + } +} + +unsafe fn move_kv( + source: (*mut K, *mut V), + source_offset: usize, + dest: (*mut K, *mut V), + dest_offset: usize, + count: usize, +) { + unsafe { + ptr::copy_nonoverlapping(source.0.add(source_offset), dest.0.add(dest_offset), count); + ptr::copy_nonoverlapping(source.1.add(source_offset), dest.1.add(dest_offset), count); + } +} + +// Source and destination must have the same height. +unsafe fn move_edges<'a, K: 'a, V: 'a>( + source: NodeRef, K, V, marker::Internal>, + source_offset: usize, + mut dest: NodeRef, K, V, marker::Internal>, + dest_offset: usize, + count: usize, +) { + unsafe { + let source_ptr = source.edge_area().as_ptr(); + let dest_ptr = dest.reborrow_mut().into_edge_area_slice().as_mut_ptr(); + ptr::copy_nonoverlapping(source_ptr.add(source_offset), dest_ptr.add(dest_offset), count); + dest.correct_childrens_parent_links(dest_offset..dest_offset + count); + } +} + +impl NodeRef { + /// Removes any static information asserting that this node is a `Leaf` node. + pub fn forget_type(self) -> NodeRef { + NodeRef { height: self.height, node: self.node, _marker: PhantomData } + } +} + +impl NodeRef { + /// Removes any static information asserting that this node is an `Internal` node. + pub fn forget_type(self) -> NodeRef { + NodeRef { height: self.height, node: self.node, _marker: PhantomData } + } +} + +impl Handle, marker::Edge> { + pub fn forget_node_type( + self, + ) -> Handle, marker::Edge> { + unsafe { Handle::new_edge(self.node.forget_type(), self.idx) } + } +} + +impl Handle, marker::Edge> { + pub fn forget_node_type( + self, + ) -> Handle, marker::Edge> { + unsafe { Handle::new_edge(self.node.forget_type(), self.idx) } + } +} + +impl Handle, marker::KV> { + pub fn forget_node_type( + self, + ) -> Handle, marker::KV> { + unsafe { Handle::new_kv(self.node.forget_type(), self.idx) } + } +} + +impl Handle, marker::KV> { + pub fn forget_node_type( + self, + ) -> Handle, marker::KV> { + unsafe { Handle::new_kv(self.node.forget_type(), self.idx) } + } +} + +impl + Handle, HandleType> +{ + /// Checks whether the underlying node is an `Internal` node or a `Leaf` node. + pub fn force( + self, + ) -> ForceResult< + Handle, HandleType>, + Handle, HandleType>, + > { + match self.node.force() { + ForceResult::Leaf(node) => { + ForceResult::Leaf(Handle { node, idx: self.idx, _marker: PhantomData }) + } + ForceResult::Internal(node) => { + ForceResult::Internal(Handle { node, idx: self.idx, _marker: PhantomData }) + } + } + } +} + +impl<'a, K, V> Handle, K, V, marker::LeafOrInternal>, marker::Edge> { + /// Move the suffix after `self` from one node to another one. `right` must be empty. + /// The first edge of `right` remains unchanged. + pub fn move_suffix( + &mut self, + right: &mut NodeRef, K, V, marker::LeafOrInternal>, + ) { + unsafe { + let left_new_len = self.idx; + let mut left_node = self.reborrow_mut().into_node(); + + let right_new_len = left_node.len() - left_new_len; + let mut right_node = right.reborrow_mut(); + + assert!(right_node.len() == 0); + assert!(left_node.height == right_node.height); + + if right_new_len > 0 { + let left_kv = left_node.reborrow_mut().into_kv_pointers_mut(); + let right_kv = right_node.reborrow_mut().into_kv_pointers_mut(); + + move_kv(left_kv, left_new_len, right_kv, 0, right_new_len); + + *left_node.reborrow_mut().into_len_mut() = left_new_len as u16; + *right_node.reborrow_mut().into_len_mut() = right_new_len as u16; + + match (left_node.force(), right_node.force()) { + (ForceResult::Internal(left), ForceResult::Internal(right)) => { + let left = left.reborrow(); + move_edges(left, left_new_len + 1, right, 1, right_new_len); + } + (ForceResult::Leaf(_), ForceResult::Leaf(_)) => {} + _ => unreachable!(), + } + } + } + } +} + +pub enum ForceResult { + Leaf(Leaf), + Internal(Internal), +} + +/// Result of insertion, when a node needed to expand beyond its capacity. +/// Does not distinguish between `Leaf` and `Internal` because `Root` doesn't. +pub struct SplitResult<'a, K, V> { + // Altered node in existing tree with elements and edges that belong to the left of `k`. + pub left: NodeRef, K, V, marker::LeafOrInternal>, + // Some key and value split off, to be inserted elsewhere. + pub k: K, + pub v: V, + // Owned, unattached, new node with elements and edges that belong to the right of `k`. + pub right: Root, +} + +pub enum InsertResult<'a, K, V, Type> { + Fit(Handle, K, V, Type>, marker::KV>), + Split(SplitResult<'a, K, V>), +} + +pub mod marker { + use core::marker::PhantomData; + + pub enum Leaf {} + pub enum Internal {} + pub enum LeafOrInternal {} + + pub enum Owned {} + pub struct Immut<'a>(PhantomData<&'a ()>); + pub struct Mut<'a>(PhantomData<&'a mut ()>); + pub struct ValMut<'a>(PhantomData<&'a mut ()>); + + pub enum KV {} + pub enum Edge {} +} + +/// Inserts a value into a slice of initialized elements followed by one uninitialized element. +/// +/// # Safety +/// The slice has more than `idx` elements. +unsafe fn slice_insert(slice: &mut [MaybeUninit], idx: usize, val: T) { + unsafe { + let len = slice.len(); + debug_assert!(len > idx); + let slice_ptr = slice.as_mut_ptr(); + if len > idx + 1 { + ptr::copy(slice_ptr.add(idx), slice_ptr.add(idx + 1), len - idx - 1); + } + (*slice_ptr.add(idx)).write(val); + } +} + +/// Removes and returns a value from a slice of all initialized elements, leaving behind one +/// trailing uninitialized element. +/// +/// # Safety +/// The slice has more than `idx` elements. +unsafe fn slice_remove(slice: &mut [MaybeUninit], idx: usize) -> T { + unsafe { + let len = slice.len(); + debug_assert!(idx < len); + let slice_ptr = slice.as_mut_ptr(); + let ret = (*slice_ptr.add(idx)).assume_init_read(); + ptr::copy(slice_ptr.add(idx + 1), slice_ptr.add(idx), len - idx - 1); + ret + } +} + +#[cfg(test)] +mod tests; diff --git a/libgrust/rustc-lib/alloc/src/collections/btree/node/tests.rs b/libgrust/rustc-lib/alloc/src/collections/btree/node/tests.rs new file mode 100644 index 000000000000..38c75de34eee --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/btree/node/tests.rs @@ -0,0 +1,111 @@ +use super::super::navigate; +use super::*; +use crate::fmt::Debug; +use crate::string::String; +use core::cmp::Ordering::*; + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::LeafOrInternal> { + /// Asserts that the back pointer in each reachable node points to its parent. + pub fn assert_back_pointers(self) { + if let ForceResult::Internal(node) = self.force() { + for idx in 0..=node.len() { + let edge = unsafe { Handle::new_edge(node, idx) }; + let child = edge.descend(); + assert!(child.ascend().ok() == Some(edge)); + child.assert_back_pointers(); + } + } + } + + pub fn dump_keys(self) -> String + where + K: Debug, + { + let mut result = String::new(); + self.visit_nodes_in_order(|pos| match pos { + navigate::Position::Leaf(leaf) => { + let depth = self.height(); + let indent = " ".repeat(depth); + result += &format!("\n{}", indent); + for idx in 0..leaf.len() { + if idx > 0 { + result += ", "; + } + result += &format!("{:?}", unsafe { leaf.key_at(idx) }); + } + } + navigate::Position::Internal(_) => {} + navigate::Position::InternalKV(kv) => { + let depth = self.height() - kv.into_node().height(); + let indent = " ".repeat(depth); + result += &format!("\n{}{:?}", indent, kv.into_kv().0); + } + }); + result + } +} + +#[test] +fn test_splitpoint() { + for idx in 0..=CAPACITY { + let (middle_kv_idx, insertion) = splitpoint(idx); + + // Simulate performing the split: + let mut left_len = middle_kv_idx; + let mut right_len = CAPACITY - middle_kv_idx - 1; + match insertion { + InsertionPlace::Left(edge_idx) => { + assert!(edge_idx <= left_len); + left_len += 1; + } + InsertionPlace::Right(edge_idx) => { + assert!(edge_idx <= right_len); + right_len += 1; + } + } + assert!(left_len >= MIN_LEN_AFTER_SPLIT); + assert!(right_len >= MIN_LEN_AFTER_SPLIT); + assert!(left_len + right_len == CAPACITY); + } +} + +#[test] +fn test_partial_cmp_eq() { + let mut root1: Root = Root::new_leaf(); + let mut leaf1 = unsafe { root1.leaf_node_as_mut() }; + leaf1.push(1, ()); + root1.push_internal_level(); + let root2: Root = Root::new_leaf(); + + let leaf_edge_1a = root1.node_as_ref().first_leaf_edge().forget_node_type(); + let leaf_edge_1b = root1.node_as_ref().last_leaf_edge().forget_node_type(); + let top_edge_1 = root1.node_as_ref().first_edge(); + let top_edge_2 = root2.node_as_ref().first_edge(); + + assert!(leaf_edge_1a == leaf_edge_1a); + assert!(leaf_edge_1a != leaf_edge_1b); + assert!(leaf_edge_1a != top_edge_1); + assert!(leaf_edge_1a != top_edge_2); + assert!(top_edge_1 == top_edge_1); + assert!(top_edge_1 != top_edge_2); + + assert_eq!(leaf_edge_1a.partial_cmp(&leaf_edge_1a), Some(Equal)); + assert_eq!(leaf_edge_1a.partial_cmp(&leaf_edge_1b), Some(Less)); + assert_eq!(leaf_edge_1a.partial_cmp(&top_edge_1), None); + assert_eq!(leaf_edge_1a.partial_cmp(&top_edge_2), None); + assert_eq!(top_edge_1.partial_cmp(&top_edge_1), Some(Equal)); + assert_eq!(top_edge_1.partial_cmp(&top_edge_2), None); + + root1.pop_internal_level(); + unsafe { root1.into_ref().deallocate_and_ascend() }; + unsafe { root2.into_ref().deallocate_and_ascend() }; +} + +#[test] +#[cfg(target_arch = "x86_64")] +fn test_sizes() { + assert_eq!(core::mem::size_of::>(), 16); + assert_eq!(core::mem::size_of::>(), 16 + CAPACITY * 8 * 2); + assert_eq!(core::mem::size_of::>(), 112); + assert_eq!(core::mem::size_of::>(), 112 + CAPACITY * 8 * 2); +} diff --git a/libgrust/rustc-lib/alloc/src/collections/btree/remove.rs b/libgrust/rustc-lib/alloc/src/collections/btree/remove.rs new file mode 100644 index 000000000000..99655d3e2bf6 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/btree/remove.rs @@ -0,0 +1,133 @@ +use super::map::MIN_LEN; +use super::node::{marker, ForceResult, Handle, NodeRef}; +use super::unwrap_unchecked; +use core::mem; +use core::ptr; + +impl<'a, K: 'a, V: 'a> Handle, K, V, marker::LeafOrInternal>, marker::KV> { + /// Removes a key/value-pair from the map, and returns that pair, as well as + /// the leaf edge corresponding to that former pair. + pub fn remove_kv_tracking( + self, + handle_emptied_internal_root: F, + ) -> ((K, V), Handle, K, V, marker::Leaf>, marker::Edge>) { + let (old_kv, mut pos, was_internal) = match self.force() { + ForceResult::Leaf(leaf) => { + let (old_kv, pos) = leaf.remove(); + (old_kv, pos, false) + } + ForceResult::Internal(mut internal) => { + // Replace the location freed in the internal node with an + // adjacent KV, and remove that adjacent KV from its leaf. + // Always choose the adjacent KV on the left side because + // it is typically faster to pop an element from the end + // of the KV arrays without needing to shift other elements. + + let key_loc = internal.kv_mut().0 as *mut K; + let val_loc = internal.kv_mut().1 as *mut V; + + let to_remove = internal.left_edge().descend().last_leaf_edge().left_kv().ok(); + let to_remove = unsafe { unwrap_unchecked(to_remove) }; + + let (kv, pos) = to_remove.remove(); + + let old_key = unsafe { mem::replace(&mut *key_loc, kv.0) }; + let old_val = unsafe { mem::replace(&mut *val_loc, kv.1) }; + + ((old_key, old_val), pos, true) + } + }; + + // Handle underflow + let mut cur_node = unsafe { ptr::read(&pos).into_node().forget_type() }; + let mut at_leaf = true; + while cur_node.len() < MIN_LEN { + match handle_underfull_node(cur_node) { + UnderflowResult::AtRoot => break, + UnderflowResult::Merged(edge, merged_with_left, offset) => { + // If we merged with our right sibling then our tracked + // position has not changed. However if we merged with our + // left sibling then our tracked position is now dangling. + if at_leaf && merged_with_left { + let idx = pos.idx() + offset; + let node = match unsafe { ptr::read(&edge).descend().force() } { + ForceResult::Leaf(leaf) => leaf, + ForceResult::Internal(_) => unreachable!(), + }; + pos = unsafe { Handle::new_edge(node, idx) }; + } + + let parent = edge.into_node(); + if parent.len() == 0 { + // The parent that was just emptied must be the root, + // because nodes on a lower level would not have been + // left with a single child. + handle_emptied_internal_root(); + break; + } else { + cur_node = parent.forget_type(); + at_leaf = false; + } + } + UnderflowResult::Stole(stole_from_left) => { + // Adjust the tracked position if we stole from a left sibling + if stole_from_left && at_leaf { + // SAFETY: This is safe since we just added an element to our node. + unsafe { + pos.move_next_unchecked(); + } + } + break; + } + } + } + + // If we deleted from an internal node then we need to compensate for + // the earlier swap and adjust the tracked position to point to the + // next element. + if was_internal { + pos = unsafe { unwrap_unchecked(pos.next_kv().ok()).next_leaf_edge() }; + } + + (old_kv, pos) + } +} + +enum UnderflowResult<'a, K, V> { + AtRoot, + Merged(Handle, K, V, marker::Internal>, marker::Edge>, bool, usize), + Stole(bool), +} + +fn handle_underfull_node<'a, K: 'a, V: 'a>( + node: NodeRef, K, V, marker::LeafOrInternal>, +) -> UnderflowResult<'_, K, V> { + let parent = match node.ascend() { + Ok(parent) => parent, + Err(_) => return UnderflowResult::AtRoot, + }; + + // Prefer the left KV if it exists. Merging with the left side is faster, + // since merging happens towards the left and `node` has fewer elements. + // Stealing from the left side is faster, since we can pop from the end of + // the KV arrays. + let (is_left, mut handle) = match parent.left_kv() { + Ok(left) => (true, left), + Err(parent) => { + let right = unsafe { unwrap_unchecked(parent.right_kv().ok()) }; + (false, right) + } + }; + + if handle.can_merge() { + let offset = if is_left { handle.reborrow().left_edge().descend().len() + 1 } else { 0 }; + UnderflowResult::Merged(handle.merge(), is_left, offset) + } else { + if is_left { + handle.steal_left(); + } else { + handle.steal_right(); + } + UnderflowResult::Stole(is_left) + } +} diff --git a/libgrust/rustc-lib/alloc/src/collections/btree/search.rs b/libgrust/rustc-lib/alloc/src/collections/btree/search.rs new file mode 100644 index 000000000000..701d5ec73e21 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/btree/search.rs @@ -0,0 +1,83 @@ +use core::borrow::Borrow; +use core::cmp::Ordering; + +use super::node::{marker, ForceResult::*, Handle, NodeRef}; + +use SearchResult::*; + +pub enum SearchResult { + Found(Handle, marker::KV>), + GoDown(Handle, marker::Edge>), +} + +/// Looks up a given key in a (sub)tree headed by the given node, recursively. +/// Returns a `Found` with the handle of the matching KV, if any. Otherwise, +/// returns a `GoDown` with the handle of the possible leaf edge where the key +/// belongs. +pub fn search_tree( + mut node: NodeRef, + key: &Q, +) -> SearchResult +where + Q: Ord, + K: Borrow, +{ + loop { + match search_node(node, key) { + Found(handle) => return Found(handle), + GoDown(handle) => match handle.force() { + Leaf(leaf) => return GoDown(leaf), + Internal(internal) => { + node = internal.descend(); + continue; + } + }, + } + } +} + +/// Looks up a given key in a given node, without recursion. +/// Returns a `Found` with the handle of the matching KV, if any. Otherwise, +/// returns a `GoDown` with the handle of the edge where the key might be found. +/// If the node is a leaf, a `GoDown` edge is not an actual edge but a possible edge. +pub fn search_node( + node: NodeRef, + key: &Q, +) -> SearchResult +where + Q: Ord, + K: Borrow, +{ + match search_linear(&node, key) { + (idx, true) => Found(unsafe { Handle::new_kv(node, idx) }), + (idx, false) => SearchResult::GoDown(unsafe { Handle::new_edge(node, idx) }), + } +} + +/// Returns the index in the node at which the key (or an equivalent) exists +/// or could exist, and whether it exists in the node itself. If it doesn't +/// exist in the node itself, it may exist in the subtree with that index +/// (if the node has subtrees). If the key doesn't exist in node or subtree, +/// the returned index is the position or subtree where the key belongs. +fn search_linear( + node: &NodeRef, + key: &Q, +) -> (usize, bool) +where + Q: Ord, + K: Borrow, +{ + // This function is defined over all borrow types (immutable, mutable, owned). + // Using `keys_at()` is fine here even if BorrowType is mutable, as all we return + // is an index -- not a reference. + let len = node.len(); + for i in 0..len { + let k = unsafe { node.reborrow().key_at(i) }; + match key.cmp(k.borrow()) { + Ordering::Greater => {} + Ordering::Equal => return (i, true), + Ordering::Less => return (i, false), + } + } + (len, false) +} diff --git a/libgrust/rustc-lib/alloc/src/collections/btree/set.rs b/libgrust/rustc-lib/alloc/src/collections/btree/set.rs new file mode 100644 index 000000000000..684019f8f5f5 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/btree/set.rs @@ -0,0 +1,1509 @@ +// This is pretty much entirely stolen from TreeSet, since BTreeMap has an identical interface +// to TreeMap + +use core::borrow::Borrow; +use core::cmp::Ordering::{Equal, Greater, Less}; +use core::cmp::{max, min}; +use core::fmt::{self, Debug}; +use core::iter::{FromIterator, FusedIterator, Peekable}; +use core::ops::{BitAnd, BitOr, BitXor, RangeBounds, Sub}; + +use super::map::{BTreeMap, Keys}; +use super::merge_iter::MergeIterInner; +use super::Recover; + +// FIXME(conventions): implement bounded iterators + +/// A set based on a B-Tree. +/// +/// See [`BTreeMap`]'s documentation for a detailed discussion of this collection's performance +/// benefits and drawbacks. +/// +/// It is a logic error for an item to be modified in such a way that the item's ordering relative +/// to any other item, as determined by the [`Ord`] trait, changes while it is in the set. This is +/// normally only possible through [`Cell`], [`RefCell`], global state, I/O, or unsafe code. +/// +/// [`Ord`]: core::cmp::Ord +/// [`Cell`]: core::cell::Cell +/// [`RefCell`]: core::cell::RefCell +/// +/// # Examples +/// +/// ``` +/// use std::collections::BTreeSet; +/// +/// // Type inference lets us omit an explicit type signature (which +/// // would be `BTreeSet<&str>` in this example). +/// let mut books = BTreeSet::new(); +/// +/// // Add some books. +/// books.insert("A Dance With Dragons"); +/// books.insert("To Kill a Mockingbird"); +/// books.insert("The Odyssey"); +/// books.insert("The Great Gatsby"); +/// +/// // Check for a specific one. +/// if !books.contains("The Winds of Winter") { +/// println!("We have {} books, but The Winds of Winter ain't one.", +/// books.len()); +/// } +/// +/// // Remove a book. +/// books.remove("The Odyssey"); +/// +/// // Iterate over everything. +/// for book in &books { +/// println!("{}", book); +/// } +/// ``` +#[derive(Hash, PartialEq, Eq, Ord, PartialOrd)] +#[stable(feature = "rust1", since = "1.0.0")] +pub struct BTreeSet { + map: BTreeMap, +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for BTreeSet { + fn clone(&self) -> Self { + BTreeSet { map: self.map.clone() } + } + + fn clone_from(&mut self, other: &Self) { + self.map.clone_from(&other.map); + } +} + +/// An iterator over the items of a `BTreeSet`. +/// +/// This `struct` is created by the [`iter`] method on [`BTreeSet`]. +/// See its documentation for more. +/// +/// [`iter`]: BTreeSet::iter +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Iter<'a, T: 'a> { + iter: Keys<'a, T, ()>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Iter<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Iter").field(&self.iter.clone()).finish() + } +} + +/// An owning iterator over the items of a `BTreeSet`. +/// +/// This `struct` is created by the [`into_iter`] method on [`BTreeSet`] +/// (provided by the `IntoIterator` trait). See its documentation for more. +/// +/// [`into_iter`]: BTreeSet#method.into_iter +#[stable(feature = "rust1", since = "1.0.0")] +#[derive(Debug)] +pub struct IntoIter { + iter: super::map::IntoIter, +} + +/// An iterator over a sub-range of items in a `BTreeSet`. +/// +/// This `struct` is created by the [`range`] method on [`BTreeSet`]. +/// See its documentation for more. +/// +/// [`range`]: BTreeSet::range +#[derive(Debug)] +#[stable(feature = "btree_range", since = "1.17.0")] +pub struct Range<'a, T: 'a> { + iter: super::map::Range<'a, T, ()>, +} + +/// A lazy iterator producing elements in the difference of `BTreeSet`s. +/// +/// This `struct` is created by the [`difference`] method on [`BTreeSet`]. +/// See its documentation for more. +/// +/// [`difference`]: BTreeSet::difference +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Difference<'a, T: 'a> { + inner: DifferenceInner<'a, T>, +} +#[derive(Debug)] +enum DifferenceInner<'a, T: 'a> { + Stitch { + // iterate all of `self` and some of `other`, spotting matches along the way + self_iter: Iter<'a, T>, + other_iter: Peekable>, + }, + Search { + // iterate `self`, look up in `other` + self_iter: Iter<'a, T>, + other_set: &'a BTreeSet, + }, + Iterate(Iter<'a, T>), // simply produce all values in `self` +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Difference<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Difference").field(&self.inner).finish() + } +} + +/// A lazy iterator producing elements in the symmetric difference of `BTreeSet`s. +/// +/// This `struct` is created by the [`symmetric_difference`] method on +/// [`BTreeSet`]. See its documentation for more. +/// +/// [`symmetric_difference`]: BTreeSet::symmetric_difference +#[stable(feature = "rust1", since = "1.0.0")] +pub struct SymmetricDifference<'a, T: 'a>(MergeIterInner>); + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for SymmetricDifference<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("SymmetricDifference").field(&self.0).finish() + } +} + +/// A lazy iterator producing elements in the intersection of `BTreeSet`s. +/// +/// This `struct` is created by the [`intersection`] method on [`BTreeSet`]. +/// See its documentation for more. +/// +/// [`intersection`]: BTreeSet::intersection +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Intersection<'a, T: 'a> { + inner: IntersectionInner<'a, T>, +} +#[derive(Debug)] +enum IntersectionInner<'a, T: 'a> { + Stitch { + // iterate similarly sized sets jointly, spotting matches along the way + a: Iter<'a, T>, + b: Iter<'a, T>, + }, + Search { + // iterate a small set, look up in the large set + small_iter: Iter<'a, T>, + large_set: &'a BTreeSet, + }, + Answer(Option<&'a T>), // return a specific value or emptiness +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Intersection<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Intersection").field(&self.inner).finish() + } +} + +/// A lazy iterator producing elements in the union of `BTreeSet`s. +/// +/// This `struct` is created by the [`union`] method on [`BTreeSet`]. +/// See its documentation for more. +/// +/// [`union`]: BTreeSet::union +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Union<'a, T: 'a>(MergeIterInner>); + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Union<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Union").field(&self.0).finish() + } +} + +// This constant is used by functions that compare two sets. +// It estimates the relative size at which searching performs better +// than iterating, based on the benchmarks in +// https://github.com/ssomers/rust_bench_btreeset_intersection; +// It's used to divide rather than multiply sizes, to rule out overflow, +// and it's a power of two to make that division cheap. +const ITER_PERFORMANCE_TIPPING_SIZE_DIFF: usize = 16; + +impl BTreeSet { + /// Makes a new `BTreeSet` with a reasonable choice of B. + /// + /// # Examples + /// + /// ``` + /// # #![allow(unused_mut)] + /// use std::collections::BTreeSet; + /// + /// let mut set: BTreeSet = BTreeSet::new(); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_const_unstable(feature = "const_btree_new", issue = "71835")] + pub const fn new() -> BTreeSet { + BTreeSet { map: BTreeMap::new() } + } + + /// Constructs a double-ended iterator over a sub-range of elements in the set. + /// The simplest way is to use the range syntax `min..max`, thus `range(min..max)` will + /// yield elements from min (inclusive) to max (exclusive). + /// The range may also be entered as `(Bound, Bound)`, so for example + /// `range((Excluded(4), Included(10)))` will yield a left-exclusive, right-inclusive + /// range from 4 to 10. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// use std::ops::Bound::Included; + /// + /// let mut set = BTreeSet::new(); + /// set.insert(3); + /// set.insert(5); + /// set.insert(8); + /// for &elem in set.range((Included(&4), Included(&8))) { + /// println!("{}", elem); + /// } + /// assert_eq!(Some(&5), set.range(4..).next()); + /// ``` + #[stable(feature = "btree_range", since = "1.17.0")] + pub fn range(&self, range: R) -> Range<'_, T> + where + K: Ord, + T: Borrow, + R: RangeBounds, + { + Range { iter: self.map.range(range) } + } + + /// Visits the values representing the difference, + /// i.e., the values that are in `self` but not in `other`, + /// in ascending order. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut a = BTreeSet::new(); + /// a.insert(1); + /// a.insert(2); + /// + /// let mut b = BTreeSet::new(); + /// b.insert(2); + /// b.insert(3); + /// + /// let diff: Vec<_> = a.difference(&b).cloned().collect(); + /// assert_eq!(diff, [1]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn difference<'a>(&'a self, other: &'a BTreeSet) -> Difference<'a, T> { + let (self_min, self_max) = + if let (Some(self_min), Some(self_max)) = (self.first(), self.last()) { + (self_min, self_max) + } else { + return Difference { inner: DifferenceInner::Iterate(self.iter()) }; + }; + let (other_min, other_max) = + if let (Some(other_min), Some(other_max)) = (other.first(), other.last()) { + (other_min, other_max) + } else { + return Difference { inner: DifferenceInner::Iterate(self.iter()) }; + }; + Difference { + inner: match (self_min.cmp(other_max), self_max.cmp(other_min)) { + (Greater, _) | (_, Less) => DifferenceInner::Iterate(self.iter()), + (Equal, _) => { + let mut self_iter = self.iter(); + self_iter.next(); + DifferenceInner::Iterate(self_iter) + } + (_, Equal) => { + let mut self_iter = self.iter(); + self_iter.next_back(); + DifferenceInner::Iterate(self_iter) + } + _ if self.len() <= other.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF => { + DifferenceInner::Search { self_iter: self.iter(), other_set: other } + } + _ => DifferenceInner::Stitch { + self_iter: self.iter(), + other_iter: other.iter().peekable(), + }, + }, + } + } + + /// Visits the values representing the symmetric difference, + /// i.e., the values that are in `self` or in `other` but not in both, + /// in ascending order. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut a = BTreeSet::new(); + /// a.insert(1); + /// a.insert(2); + /// + /// let mut b = BTreeSet::new(); + /// b.insert(2); + /// b.insert(3); + /// + /// let sym_diff: Vec<_> = a.symmetric_difference(&b).cloned().collect(); + /// assert_eq!(sym_diff, [1, 3]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn symmetric_difference<'a>( + &'a self, + other: &'a BTreeSet, + ) -> SymmetricDifference<'a, T> { + SymmetricDifference(MergeIterInner::new(self.iter(), other.iter())) + } + + /// Visits the values representing the intersection, + /// i.e., the values that are both in `self` and `other`, + /// in ascending order. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut a = BTreeSet::new(); + /// a.insert(1); + /// a.insert(2); + /// + /// let mut b = BTreeSet::new(); + /// b.insert(2); + /// b.insert(3); + /// + /// let intersection: Vec<_> = a.intersection(&b).cloned().collect(); + /// assert_eq!(intersection, [2]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn intersection<'a>(&'a self, other: &'a BTreeSet) -> Intersection<'a, T> { + let (self_min, self_max) = + if let (Some(self_min), Some(self_max)) = (self.first(), self.last()) { + (self_min, self_max) + } else { + return Intersection { inner: IntersectionInner::Answer(None) }; + }; + let (other_min, other_max) = + if let (Some(other_min), Some(other_max)) = (other.first(), other.last()) { + (other_min, other_max) + } else { + return Intersection { inner: IntersectionInner::Answer(None) }; + }; + Intersection { + inner: match (self_min.cmp(other_max), self_max.cmp(other_min)) { + (Greater, _) | (_, Less) => IntersectionInner::Answer(None), + (Equal, _) => IntersectionInner::Answer(Some(self_min)), + (_, Equal) => IntersectionInner::Answer(Some(self_max)), + _ if self.len() <= other.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF => { + IntersectionInner::Search { small_iter: self.iter(), large_set: other } + } + _ if other.len() <= self.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF => { + IntersectionInner::Search { small_iter: other.iter(), large_set: self } + } + _ => IntersectionInner::Stitch { a: self.iter(), b: other.iter() }, + }, + } + } + + /// Visits the values representing the union, + /// i.e., all the values in `self` or `other`, without duplicates, + /// in ascending order. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut a = BTreeSet::new(); + /// a.insert(1); + /// + /// let mut b = BTreeSet::new(); + /// b.insert(2); + /// + /// let union: Vec<_> = a.union(&b).cloned().collect(); + /// assert_eq!(union, [1, 2]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn union<'a>(&'a self, other: &'a BTreeSet) -> Union<'a, T> { + Union(MergeIterInner::new(self.iter(), other.iter())) + } + + /// Clears the set, removing all values. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut v = BTreeSet::new(); + /// v.insert(1); + /// v.clear(); + /// assert!(v.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn clear(&mut self) { + self.map.clear() + } + + /// Returns `true` if the set contains a value. + /// + /// The value may be any borrowed form of the set's value type, + /// but the ordering on the borrowed form *must* match the + /// ordering on the value type. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect(); + /// assert_eq!(set.contains(&1), true); + /// assert_eq!(set.contains(&4), false); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn contains(&self, value: &Q) -> bool + where + T: Borrow, + Q: Ord, + { + self.map.contains_key(value) + } + + /// Returns a reference to the value in the set, if any, that is equal to the given value. + /// + /// The value may be any borrowed form of the set's value type, + /// but the ordering on the borrowed form *must* match the + /// ordering on the value type. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect(); + /// assert_eq!(set.get(&2), Some(&2)); + /// assert_eq!(set.get(&4), None); + /// ``` + #[stable(feature = "set_recovery", since = "1.9.0")] + pub fn get(&self, value: &Q) -> Option<&T> + where + T: Borrow, + Q: Ord, + { + Recover::get(&self.map, value) + } + + /// Returns `true` if `self` has no elements in common with `other`. + /// This is equivalent to checking for an empty intersection. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let a: BTreeSet<_> = [1, 2, 3].iter().cloned().collect(); + /// let mut b = BTreeSet::new(); + /// + /// assert_eq!(a.is_disjoint(&b), true); + /// b.insert(4); + /// assert_eq!(a.is_disjoint(&b), true); + /// b.insert(1); + /// assert_eq!(a.is_disjoint(&b), false); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn is_disjoint(&self, other: &BTreeSet) -> bool { + self.intersection(other).next().is_none() + } + + /// Returns `true` if the set is a subset of another, + /// i.e., `other` contains at least all the values in `self`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let sup: BTreeSet<_> = [1, 2, 3].iter().cloned().collect(); + /// let mut set = BTreeSet::new(); + /// + /// assert_eq!(set.is_subset(&sup), true); + /// set.insert(2); + /// assert_eq!(set.is_subset(&sup), true); + /// set.insert(4); + /// assert_eq!(set.is_subset(&sup), false); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn is_subset(&self, other: &BTreeSet) -> bool { + // Same result as self.difference(other).next().is_none() + // but the code below is faster (hugely in some cases). + if self.len() > other.len() { + return false; + } + let (self_min, self_max) = + if let (Some(self_min), Some(self_max)) = (self.first(), self.last()) { + (self_min, self_max) + } else { + return true; // self is empty + }; + let (other_min, other_max) = + if let (Some(other_min), Some(other_max)) = (other.first(), other.last()) { + (other_min, other_max) + } else { + return false; // other is empty + }; + let mut self_iter = self.iter(); + match self_min.cmp(other_min) { + Less => return false, + Equal => { + self_iter.next(); + } + Greater => (), + } + match self_max.cmp(other_max) { + Greater => return false, + Equal => { + self_iter.next_back(); + } + Less => (), + } + if self_iter.len() <= other.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF { + for next in self_iter { + if !other.contains(next) { + return false; + } + } + } else { + let mut other_iter = other.iter(); + other_iter.next(); + other_iter.next_back(); + let mut self_next = self_iter.next(); + while let Some(self1) = self_next { + match other_iter.next().map_or(Less, |other1| self1.cmp(other1)) { + Less => return false, + Equal => self_next = self_iter.next(), + Greater => (), + } + } + } + true + } + + /// Returns `true` if the set is a superset of another, + /// i.e., `self` contains at least all the values in `other`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let sub: BTreeSet<_> = [1, 2].iter().cloned().collect(); + /// let mut set = BTreeSet::new(); + /// + /// assert_eq!(set.is_superset(&sub), false); + /// + /// set.insert(0); + /// set.insert(1); + /// assert_eq!(set.is_superset(&sub), false); + /// + /// set.insert(2); + /// assert_eq!(set.is_superset(&sub), true); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn is_superset(&self, other: &BTreeSet) -> bool { + other.is_subset(self) + } + + /// Returns a reference to the first value in the set, if any. + /// This value is always the minimum of all values in the set. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeSet; + /// + /// let mut map = BTreeSet::new(); + /// assert_eq!(map.first(), None); + /// map.insert(1); + /// assert_eq!(map.first(), Some(&1)); + /// map.insert(2); + /// assert_eq!(map.first(), Some(&1)); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn first(&self) -> Option<&T> { + self.map.first_key_value().map(|(k, _)| k) + } + + /// Returns a reference to the last value in the set, if any. + /// This value is always the maximum of all values in the set. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeSet; + /// + /// let mut map = BTreeSet::new(); + /// assert_eq!(map.first(), None); + /// map.insert(1); + /// assert_eq!(map.last(), Some(&1)); + /// map.insert(2); + /// assert_eq!(map.last(), Some(&2)); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn last(&self) -> Option<&T> { + self.map.last_key_value().map(|(k, _)| k) + } + + /// Removes the first value from the set and returns it, if any. + /// The first value is always the minimum value in the set. + /// + /// # Examples + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeSet; + /// + /// let mut set = BTreeSet::new(); + /// + /// set.insert(1); + /// while let Some(n) = set.pop_first() { + /// assert_eq!(n, 1); + /// } + /// assert!(set.is_empty()); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn pop_first(&mut self) -> Option { + self.map.first_entry().map(|entry| entry.remove_entry().0) + } + + /// Removes the last value from the set and returns it, if any. + /// The last value is always the maximum value in the set. + /// + /// # Examples + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeSet; + /// + /// let mut set = BTreeSet::new(); + /// + /// set.insert(1); + /// while let Some(n) = set.pop_last() { + /// assert_eq!(n, 1); + /// } + /// assert!(set.is_empty()); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn pop_last(&mut self) -> Option { + self.map.last_entry().map(|entry| entry.remove_entry().0) + } + + /// Adds a value to the set. + /// + /// If the set did not have this value present, `true` is returned. + /// + /// If the set did have this value present, `false` is returned, and the + /// entry is not updated. See the [module-level documentation] for more. + /// + /// [module-level documentation]: index.html#insert-and-complex-keys + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut set = BTreeSet::new(); + /// + /// assert_eq!(set.insert(2), true); + /// assert_eq!(set.insert(2), false); + /// assert_eq!(set.len(), 1); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn insert(&mut self, value: T) -> bool { + self.map.insert(value, ()).is_none() + } + + /// Adds a value to the set, replacing the existing value, if any, that is equal to the given + /// one. Returns the replaced value. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut set = BTreeSet::new(); + /// set.insert(Vec::::new()); + /// + /// assert_eq!(set.get(&[][..]).unwrap().capacity(), 0); + /// set.replace(Vec::with_capacity(10)); + /// assert_eq!(set.get(&[][..]).unwrap().capacity(), 10); + /// ``` + #[stable(feature = "set_recovery", since = "1.9.0")] + pub fn replace(&mut self, value: T) -> Option { + Recover::replace(&mut self.map, value) + } + + /// Removes a value from the set. Returns whether the value was + /// present in the set. + /// + /// The value may be any borrowed form of the set's value type, + /// but the ordering on the borrowed form *must* match the + /// ordering on the value type. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut set = BTreeSet::new(); + /// + /// set.insert(2); + /// assert_eq!(set.remove(&2), true); + /// assert_eq!(set.remove(&2), false); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn remove(&mut self, value: &Q) -> bool + where + T: Borrow, + Q: Ord, + { + self.map.remove(value).is_some() + } + + /// Removes and returns the value in the set, if any, that is equal to the given one. + /// + /// The value may be any borrowed form of the set's value type, + /// but the ordering on the borrowed form *must* match the + /// ordering on the value type. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect(); + /// assert_eq!(set.take(&2), Some(2)); + /// assert_eq!(set.take(&2), None); + /// ``` + #[stable(feature = "set_recovery", since = "1.9.0")] + pub fn take(&mut self, value: &Q) -> Option + where + T: Borrow, + Q: Ord, + { + Recover::take(&mut self.map, value) + } + + /// Moves all elements from `other` into `Self`, leaving `other` empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut a = BTreeSet::new(); + /// a.insert(1); + /// a.insert(2); + /// a.insert(3); + /// + /// let mut b = BTreeSet::new(); + /// b.insert(3); + /// b.insert(4); + /// b.insert(5); + /// + /// a.append(&mut b); + /// + /// assert_eq!(a.len(), 5); + /// assert_eq!(b.len(), 0); + /// + /// assert!(a.contains(&1)); + /// assert!(a.contains(&2)); + /// assert!(a.contains(&3)); + /// assert!(a.contains(&4)); + /// assert!(a.contains(&5)); + /// ``` + #[stable(feature = "btree_append", since = "1.11.0")] + pub fn append(&mut self, other: &mut Self) { + self.map.append(&mut other.map); + } + + /// Splits the collection into two at the given key. Returns everything after the given key, + /// including the key. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut a = BTreeSet::new(); + /// a.insert(1); + /// a.insert(2); + /// a.insert(3); + /// a.insert(17); + /// a.insert(41); + /// + /// let b = a.split_off(&3); + /// + /// assert_eq!(a.len(), 2); + /// assert_eq!(b.len(), 3); + /// + /// assert!(a.contains(&1)); + /// assert!(a.contains(&2)); + /// + /// assert!(b.contains(&3)); + /// assert!(b.contains(&17)); + /// assert!(b.contains(&41)); + /// ``` + #[stable(feature = "btree_split_off", since = "1.11.0")] + pub fn split_off(&mut self, key: &Q) -> Self + where + T: Borrow, + { + BTreeSet { map: self.map.split_off(key) } + } + + /// Creates an iterator which uses a closure to determine if a value should be removed. + /// + /// If the closure returns true, then the value is removed and yielded. + /// If the closure returns false, the value will remain in the list and will not be yielded + /// by the iterator. + /// + /// If the iterator is only partially consumed or not consumed at all, each of the remaining + /// values will still be subjected to the closure and removed and dropped if it returns true. + /// + /// It is unspecified how many more values will be subjected to the closure + /// if a panic occurs in the closure, or if a panic occurs while dropping a value, or if the + /// `DrainFilter` itself is leaked. + /// + /// # Examples + /// + /// Splitting a set into even and odd values, reusing the original set: + /// + /// ``` + /// #![feature(btree_drain_filter)] + /// use std::collections::BTreeSet; + /// + /// let mut set: BTreeSet = (0..8).collect(); + /// let evens: BTreeSet<_> = set.drain_filter(|v| v % 2 == 0).collect(); + /// let odds = set; + /// assert_eq!(evens.into_iter().collect::>(), vec![0, 2, 4, 6]); + /// assert_eq!(odds.into_iter().collect::>(), vec![1, 3, 5, 7]); + /// ``` + #[unstable(feature = "btree_drain_filter", issue = "70530")] + pub fn drain_filter<'a, F>(&'a mut self, pred: F) -> DrainFilter<'a, T, F> + where + F: 'a + FnMut(&T) -> bool, + { + DrainFilter { pred, inner: self.map.drain_filter_inner() } + } +} + +impl BTreeSet { + /// Gets an iterator that visits the values in the `BTreeSet` in ascending order. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let set: BTreeSet = [1, 2, 3].iter().cloned().collect(); + /// let mut set_iter = set.iter(); + /// assert_eq!(set_iter.next(), Some(&1)); + /// assert_eq!(set_iter.next(), Some(&2)); + /// assert_eq!(set_iter.next(), Some(&3)); + /// assert_eq!(set_iter.next(), None); + /// ``` + /// + /// Values returned by the iterator are returned in ascending order: + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let set: BTreeSet = [3, 1, 2].iter().cloned().collect(); + /// let mut set_iter = set.iter(); + /// assert_eq!(set_iter.next(), Some(&1)); + /// assert_eq!(set_iter.next(), Some(&2)); + /// assert_eq!(set_iter.next(), Some(&3)); + /// assert_eq!(set_iter.next(), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn iter(&self) -> Iter<'_, T> { + Iter { iter: self.map.keys() } + } + + /// Returns the number of elements in the set. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut v = BTreeSet::new(); + /// assert_eq!(v.len(), 0); + /// v.insert(1); + /// assert_eq!(v.len(), 1); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_const_unstable(feature = "const_btree_new", issue = "71835")] + pub const fn len(&self) -> usize { + self.map.len() + } + + /// Returns `true` if the set contains no elements. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut v = BTreeSet::new(); + /// assert!(v.is_empty()); + /// v.insert(1); + /// assert!(!v.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_const_unstable(feature = "const_btree_new", issue = "71835")] + pub const fn is_empty(&self) -> bool { + self.len() == 0 + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl FromIterator for BTreeSet { + fn from_iter>(iter: I) -> BTreeSet { + let mut set = BTreeSet::new(); + set.extend(iter); + set + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl IntoIterator for BTreeSet { + type Item = T; + type IntoIter = IntoIter; + + /// Gets an iterator for moving out the `BTreeSet`'s contents. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let set: BTreeSet = [1, 2, 3, 4].iter().cloned().collect(); + /// + /// let v: Vec<_> = set.into_iter().collect(); + /// assert_eq!(v, [1, 2, 3, 4]); + /// ``` + fn into_iter(self) -> IntoIter { + IntoIter { iter: self.map.into_iter() } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> IntoIterator for &'a BTreeSet { + type Item = &'a T; + type IntoIter = Iter<'a, T>; + + fn into_iter(self) -> Iter<'a, T> { + self.iter() + } +} + +/// An iterator produced by calling `drain_filter` on BTreeSet. +#[unstable(feature = "btree_drain_filter", issue = "70530")] +pub struct DrainFilter<'a, T, F> +where + T: 'a, + F: 'a + FnMut(&T) -> bool, +{ + pred: F, + inner: super::map::DrainFilterInner<'a, T, ()>, +} + +#[unstable(feature = "btree_drain_filter", issue = "70530")] +impl Drop for DrainFilter<'_, T, F> +where + F: FnMut(&T) -> bool, +{ + fn drop(&mut self) { + self.for_each(drop); + } +} + +#[unstable(feature = "btree_drain_filter", issue = "70530")] +impl fmt::Debug for DrainFilter<'_, T, F> +where + T: fmt::Debug, + F: FnMut(&T) -> bool, +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("DrainFilter").field(&self.inner.peek().map(|(k, _)| k)).finish() + } +} + +#[unstable(feature = "btree_drain_filter", issue = "70530")] +impl<'a, T, F> Iterator for DrainFilter<'_, T, F> +where + F: 'a + FnMut(&T) -> bool, +{ + type Item = T; + + fn next(&mut self) -> Option { + let pred = &mut self.pred; + let mut mapped_pred = |k: &T, _v: &mut ()| pred(k); + self.inner.next(&mut mapped_pred).map(|(k, _)| k) + } + + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } +} + +#[unstable(feature = "btree_drain_filter", issue = "70530")] +impl FusedIterator for DrainFilter<'_, T, F> where F: FnMut(&T) -> bool {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Extend for BTreeSet { + #[inline] + fn extend>(&mut self, iter: Iter) { + iter.into_iter().for_each(move |elem| { + self.insert(elem); + }); + } + + #[inline] + fn extend_one(&mut self, elem: T) { + self.insert(elem); + } +} + +#[stable(feature = "extend_ref", since = "1.2.0")] +impl<'a, T: 'a + Ord + Copy> Extend<&'a T> for BTreeSet { + fn extend>(&mut self, iter: I) { + self.extend(iter.into_iter().cloned()); + } + + #[inline] + fn extend_one(&mut self, &elem: &'a T) { + self.insert(elem); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for BTreeSet { + /// Makes an empty `BTreeSet` with a reasonable choice of B. + fn default() -> BTreeSet { + BTreeSet::new() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Sub<&BTreeSet> for &BTreeSet { + type Output = BTreeSet; + + /// Returns the difference of `self` and `rhs` as a new `BTreeSet`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect(); + /// let b: BTreeSet<_> = vec![3, 4, 5].into_iter().collect(); + /// + /// let result = &a - &b; + /// let result_vec: Vec<_> = result.into_iter().collect(); + /// assert_eq!(result_vec, [1, 2]); + /// ``` + fn sub(self, rhs: &BTreeSet) -> BTreeSet { + self.difference(rhs).cloned().collect() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl BitXor<&BTreeSet> for &BTreeSet { + type Output = BTreeSet; + + /// Returns the symmetric difference of `self` and `rhs` as a new `BTreeSet`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect(); + /// let b: BTreeSet<_> = vec![2, 3, 4].into_iter().collect(); + /// + /// let result = &a ^ &b; + /// let result_vec: Vec<_> = result.into_iter().collect(); + /// assert_eq!(result_vec, [1, 4]); + /// ``` + fn bitxor(self, rhs: &BTreeSet) -> BTreeSet { + self.symmetric_difference(rhs).cloned().collect() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl BitAnd<&BTreeSet> for &BTreeSet { + type Output = BTreeSet; + + /// Returns the intersection of `self` and `rhs` as a new `BTreeSet`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect(); + /// let b: BTreeSet<_> = vec![2, 3, 4].into_iter().collect(); + /// + /// let result = &a & &b; + /// let result_vec: Vec<_> = result.into_iter().collect(); + /// assert_eq!(result_vec, [2, 3]); + /// ``` + fn bitand(self, rhs: &BTreeSet) -> BTreeSet { + self.intersection(rhs).cloned().collect() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl BitOr<&BTreeSet> for &BTreeSet { + type Output = BTreeSet; + + /// Returns the union of `self` and `rhs` as a new `BTreeSet`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect(); + /// let b: BTreeSet<_> = vec![3, 4, 5].into_iter().collect(); + /// + /// let result = &a | &b; + /// let result_vec: Vec<_> = result.into_iter().collect(); + /// assert_eq!(result_vec, [1, 2, 3, 4, 5]); + /// ``` + fn bitor(self, rhs: &BTreeSet) -> BTreeSet { + self.union(rhs).cloned().collect() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Debug for BTreeSet { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_set().entries(self.iter()).finish() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Iter<'_, T> { + fn clone(&self) -> Self { + Iter { iter: self.iter.clone() } + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> Iterator for Iter<'a, T> { + type Item = &'a T; + + fn next(&mut self) -> Option<&'a T> { + self.iter.next() + } + + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } + + fn last(mut self) -> Option<&'a T> { + self.next_back() + } + + fn min(mut self) -> Option<&'a T> { + self.next() + } + + fn max(mut self) -> Option<&'a T> { + self.next_back() + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> DoubleEndedIterator for Iter<'a, T> { + fn next_back(&mut self) -> Option<&'a T> { + self.iter.next_back() + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for Iter<'_, T> { + fn len(&self) -> usize { + self.iter.len() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Iter<'_, T> {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Iterator for IntoIter { + type Item = T; + + fn next(&mut self) -> Option { + self.iter.next().map(|(k, _)| k) + } + + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl DoubleEndedIterator for IntoIter { + fn next_back(&mut self) -> Option { + self.iter.next_back().map(|(k, _)| k) + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for IntoIter { + fn len(&self) -> usize { + self.iter.len() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for IntoIter {} + +#[stable(feature = "btree_range", since = "1.17.0")] +impl Clone for Range<'_, T> { + fn clone(&self) -> Self { + Range { iter: self.iter.clone() } + } +} + +#[stable(feature = "btree_range", since = "1.17.0")] +impl<'a, T> Iterator for Range<'a, T> { + type Item = &'a T; + + fn next(&mut self) -> Option<&'a T> { + self.iter.next().map(|(k, _)| k) + } + + fn last(mut self) -> Option<&'a T> { + self.next_back() + } + + fn min(mut self) -> Option<&'a T> { + self.next() + } + + fn max(mut self) -> Option<&'a T> { + self.next_back() + } +} + +#[stable(feature = "btree_range", since = "1.17.0")] +impl<'a, T> DoubleEndedIterator for Range<'a, T> { + fn next_back(&mut self) -> Option<&'a T> { + self.iter.next_back().map(|(k, _)| k) + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Range<'_, T> {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Difference<'_, T> { + fn clone(&self) -> Self { + Difference { + inner: match &self.inner { + DifferenceInner::Stitch { self_iter, other_iter } => DifferenceInner::Stitch { + self_iter: self_iter.clone(), + other_iter: other_iter.clone(), + }, + DifferenceInner::Search { self_iter, other_set } => { + DifferenceInner::Search { self_iter: self_iter.clone(), other_set } + } + DifferenceInner::Iterate(iter) => DifferenceInner::Iterate(iter.clone()), + }, + } + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T: Ord> Iterator for Difference<'a, T> { + type Item = &'a T; + + fn next(&mut self) -> Option<&'a T> { + match &mut self.inner { + DifferenceInner::Stitch { self_iter, other_iter } => { + let mut self_next = self_iter.next()?; + loop { + match other_iter.peek().map_or(Less, |other_next| self_next.cmp(other_next)) { + Less => return Some(self_next), + Equal => { + self_next = self_iter.next()?; + other_iter.next(); + } + Greater => { + other_iter.next(); + } + } + } + } + DifferenceInner::Search { self_iter, other_set } => loop { + let self_next = self_iter.next()?; + if !other_set.contains(&self_next) { + return Some(self_next); + } + }, + DifferenceInner::Iterate(iter) => iter.next(), + } + } + + fn size_hint(&self) -> (usize, Option) { + let (self_len, other_len) = match &self.inner { + DifferenceInner::Stitch { self_iter, other_iter } => { + (self_iter.len(), other_iter.len()) + } + DifferenceInner::Search { self_iter, other_set } => (self_iter.len(), other_set.len()), + DifferenceInner::Iterate(iter) => (iter.len(), 0), + }; + (self_len.saturating_sub(other_len), Some(self_len)) + } + + fn min(mut self) -> Option<&'a T> { + self.next() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Difference<'_, T> {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for SymmetricDifference<'_, T> { + fn clone(&self) -> Self { + SymmetricDifference(self.0.clone()) + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T: Ord> Iterator for SymmetricDifference<'a, T> { + type Item = &'a T; + + fn next(&mut self) -> Option<&'a T> { + loop { + let (a_next, b_next) = self.0.nexts(Self::Item::cmp); + if a_next.and(b_next).is_none() { + return a_next.or(b_next); + } + } + } + + fn size_hint(&self) -> (usize, Option) { + let (a_len, b_len) = self.0.lens(); + // No checked_add, because even if a and b refer to the same set, + // and T is an empty type, the storage overhead of sets limits + // the number of elements to less than half the range of usize. + (0, Some(a_len + b_len)) + } + + fn min(mut self) -> Option<&'a T> { + self.next() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for SymmetricDifference<'_, T> {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Intersection<'_, T> { + fn clone(&self) -> Self { + Intersection { + inner: match &self.inner { + IntersectionInner::Stitch { a, b } => { + IntersectionInner::Stitch { a: a.clone(), b: b.clone() } + } + IntersectionInner::Search { small_iter, large_set } => { + IntersectionInner::Search { small_iter: small_iter.clone(), large_set } + } + IntersectionInner::Answer(answer) => IntersectionInner::Answer(*answer), + }, + } + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T: Ord> Iterator for Intersection<'a, T> { + type Item = &'a T; + + fn next(&mut self) -> Option<&'a T> { + match &mut self.inner { + IntersectionInner::Stitch { a, b } => { + let mut a_next = a.next()?; + let mut b_next = b.next()?; + loop { + match a_next.cmp(b_next) { + Less => a_next = a.next()?, + Greater => b_next = b.next()?, + Equal => return Some(a_next), + } + } + } + IntersectionInner::Search { small_iter, large_set } => loop { + let small_next = small_iter.next()?; + if large_set.contains(&small_next) { + return Some(small_next); + } + }, + IntersectionInner::Answer(answer) => answer.take(), + } + } + + fn size_hint(&self) -> (usize, Option) { + match &self.inner { + IntersectionInner::Stitch { a, b } => (0, Some(min(a.len(), b.len()))), + IntersectionInner::Search { small_iter, .. } => (0, Some(small_iter.len())), + IntersectionInner::Answer(None) => (0, Some(0)), + IntersectionInner::Answer(Some(_)) => (1, Some(1)), + } + } + + fn min(mut self) -> Option<&'a T> { + self.next() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Intersection<'_, T> {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Union<'_, T> { + fn clone(&self) -> Self { + Union(self.0.clone()) + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T: Ord> Iterator for Union<'a, T> { + type Item = &'a T; + + fn next(&mut self) -> Option<&'a T> { + let (a_next, b_next) = self.0.nexts(Self::Item::cmp); + a_next.or(b_next) + } + + fn size_hint(&self) -> (usize, Option) { + let (a_len, b_len) = self.0.lens(); + // No checked_add - see SymmetricDifference::size_hint. + (max(a_len, b_len), Some(a_len + b_len)) + } + + fn min(mut self) -> Option<&'a T> { + self.next() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Union<'_, T> {} + +#[cfg(test)] +mod tests; diff --git a/libgrust/rustc-lib/alloc/src/collections/btree/set/tests.rs b/libgrust/rustc-lib/alloc/src/collections/btree/set/tests.rs new file mode 100644 index 000000000000..52cde8299e41 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/btree/set/tests.rs @@ -0,0 +1,732 @@ +use super::super::DeterministicRng; +use super::*; +use crate::vec::Vec; +use std::iter::FromIterator; +use std::panic::{catch_unwind, AssertUnwindSafe}; +use std::sync::atomic::{AtomicU32, Ordering}; + +#[test] +fn test_clone_eq() { + let mut m = BTreeSet::new(); + + m.insert(1); + m.insert(2); + + assert_eq!(m.clone(), m); +} + +#[allow(dead_code)] +fn test_const() { + const SET: &'static BTreeSet<()> = &BTreeSet::new(); + const LEN: usize = SET.len(); + const IS_EMPTY: bool = SET.is_empty(); +} + +#[test] +fn test_iter_min_max() { + let mut a = BTreeSet::new(); + assert_eq!(a.iter().min(), None); + assert_eq!(a.iter().max(), None); + assert_eq!(a.range(..).min(), None); + assert_eq!(a.range(..).max(), None); + assert_eq!(a.difference(&BTreeSet::new()).min(), None); + assert_eq!(a.difference(&BTreeSet::new()).max(), None); + assert_eq!(a.intersection(&a).min(), None); + assert_eq!(a.intersection(&a).max(), None); + assert_eq!(a.symmetric_difference(&BTreeSet::new()).min(), None); + assert_eq!(a.symmetric_difference(&BTreeSet::new()).max(), None); + assert_eq!(a.union(&a).min(), None); + assert_eq!(a.union(&a).max(), None); + a.insert(1); + a.insert(2); + assert_eq!(a.iter().min(), Some(&1)); + assert_eq!(a.iter().max(), Some(&2)); + assert_eq!(a.range(..).min(), Some(&1)); + assert_eq!(a.range(..).max(), Some(&2)); + assert_eq!(a.difference(&BTreeSet::new()).min(), Some(&1)); + assert_eq!(a.difference(&BTreeSet::new()).max(), Some(&2)); + assert_eq!(a.intersection(&a).min(), Some(&1)); + assert_eq!(a.intersection(&a).max(), Some(&2)); + assert_eq!(a.symmetric_difference(&BTreeSet::new()).min(), Some(&1)); + assert_eq!(a.symmetric_difference(&BTreeSet::new()).max(), Some(&2)); + assert_eq!(a.union(&a).min(), Some(&1)); + assert_eq!(a.union(&a).max(), Some(&2)); +} + +fn check(a: &[i32], b: &[i32], expected: &[i32], f: F) +where + F: FnOnce(&BTreeSet, &BTreeSet, &mut dyn FnMut(&i32) -> bool) -> bool, +{ + let mut set_a = BTreeSet::new(); + let mut set_b = BTreeSet::new(); + + for x in a { + assert!(set_a.insert(*x)) + } + for y in b { + assert!(set_b.insert(*y)) + } + + let mut i = 0; + f(&set_a, &set_b, &mut |&x| { + if i < expected.len() { + assert_eq!(x, expected[i]); + } + i += 1; + true + }); + assert_eq!(i, expected.len()); +} + +#[test] +fn test_intersection() { + fn check_intersection(a: &[i32], b: &[i32], expected: &[i32]) { + check(a, b, expected, |x, y, f| x.intersection(y).all(f)) + } + + check_intersection(&[], &[], &[]); + check_intersection(&[1, 2, 3], &[], &[]); + check_intersection(&[], &[1, 2, 3], &[]); + check_intersection(&[2], &[1, 2, 3], &[2]); + check_intersection(&[1, 2, 3], &[2], &[2]); + check_intersection(&[11, 1, 3, 77, 103, 5, -5], &[2, 11, 77, -9, -42, 5, 3], &[3, 5, 11, 77]); + + if cfg!(miri) { + // Miri is too slow + return; + } + + let large = (0..100).collect::>(); + check_intersection(&[], &large, &[]); + check_intersection(&large, &[], &[]); + check_intersection(&[-1], &large, &[]); + check_intersection(&large, &[-1], &[]); + check_intersection(&[0], &large, &[0]); + check_intersection(&large, &[0], &[0]); + check_intersection(&[99], &large, &[99]); + check_intersection(&large, &[99], &[99]); + check_intersection(&[100], &large, &[]); + check_intersection(&large, &[100], &[]); + check_intersection(&[11, 5000, 1, 3, 77, 8924], &large, &[1, 3, 11, 77]); +} + +#[test] +fn test_intersection_size_hint() { + let x: BTreeSet = [3, 4].iter().copied().collect(); + let y: BTreeSet = [1, 2, 3].iter().copied().collect(); + let mut iter = x.intersection(&y); + assert_eq!(iter.size_hint(), (1, Some(1))); + assert_eq!(iter.next(), Some(&3)); + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + + iter = y.intersection(&y); + assert_eq!(iter.size_hint(), (0, Some(3))); + assert_eq!(iter.next(), Some(&1)); + assert_eq!(iter.size_hint(), (0, Some(2))); +} + +#[test] +fn test_difference() { + fn check_difference(a: &[i32], b: &[i32], expected: &[i32]) { + check(a, b, expected, |x, y, f| x.difference(y).all(f)) + } + + check_difference(&[], &[], &[]); + check_difference(&[1, 12], &[], &[1, 12]); + check_difference(&[], &[1, 2, 3, 9], &[]); + check_difference(&[1, 3, 5, 9, 11], &[3, 9], &[1, 5, 11]); + check_difference(&[1, 3, 5, 9, 11], &[3, 6, 9], &[1, 5, 11]); + check_difference(&[1, 3, 5, 9, 11], &[0, 1], &[3, 5, 9, 11]); + check_difference(&[1, 3, 5, 9, 11], &[11, 12], &[1, 3, 5, 9]); + check_difference( + &[-5, 11, 22, 33, 40, 42], + &[-12, -5, 14, 23, 34, 38, 39, 50], + &[11, 22, 33, 40, 42], + ); + + if cfg!(miri) { + // Miri is too slow + return; + } + + let large = (0..100).collect::>(); + check_difference(&[], &large, &[]); + check_difference(&[-1], &large, &[-1]); + check_difference(&[0], &large, &[]); + check_difference(&[99], &large, &[]); + check_difference(&[100], &large, &[100]); + check_difference(&[11, 5000, 1, 3, 77, 8924], &large, &[5000, 8924]); + check_difference(&large, &[], &large); + check_difference(&large, &[-1], &large); + check_difference(&large, &[100], &large); +} + +#[test] +fn test_difference_size_hint() { + let s246: BTreeSet = [2, 4, 6].iter().copied().collect(); + let s23456: BTreeSet = (2..=6).collect(); + let mut iter = s246.difference(&s23456); + assert_eq!(iter.size_hint(), (0, Some(3))); + assert_eq!(iter.next(), None); + + let s12345: BTreeSet = (1..=5).collect(); + iter = s246.difference(&s12345); + assert_eq!(iter.size_hint(), (0, Some(3))); + assert_eq!(iter.next(), Some(&6)); + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + + let s34567: BTreeSet = (3..=7).collect(); + iter = s246.difference(&s34567); + assert_eq!(iter.size_hint(), (0, Some(3))); + assert_eq!(iter.next(), Some(&2)); + assert_eq!(iter.size_hint(), (0, Some(2))); + assert_eq!(iter.next(), None); + + let s1: BTreeSet = (-9..=1).collect(); + iter = s246.difference(&s1); + assert_eq!(iter.size_hint(), (3, Some(3))); + + let s2: BTreeSet = (-9..=2).collect(); + iter = s246.difference(&s2); + assert_eq!(iter.size_hint(), (2, Some(2))); + assert_eq!(iter.next(), Some(&4)); + assert_eq!(iter.size_hint(), (1, Some(1))); + + let s23: BTreeSet = (2..=3).collect(); + iter = s246.difference(&s23); + assert_eq!(iter.size_hint(), (1, Some(3))); + assert_eq!(iter.next(), Some(&4)); + assert_eq!(iter.size_hint(), (1, Some(1))); + + let s4: BTreeSet = (4..=4).collect(); + iter = s246.difference(&s4); + assert_eq!(iter.size_hint(), (2, Some(3))); + assert_eq!(iter.next(), Some(&2)); + assert_eq!(iter.size_hint(), (1, Some(2))); + assert_eq!(iter.next(), Some(&6)); + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + + let s56: BTreeSet = (5..=6).collect(); + iter = s246.difference(&s56); + assert_eq!(iter.size_hint(), (1, Some(3))); + assert_eq!(iter.next(), Some(&2)); + assert_eq!(iter.size_hint(), (0, Some(2))); + + let s6: BTreeSet = (6..=19).collect(); + iter = s246.difference(&s6); + assert_eq!(iter.size_hint(), (2, Some(2))); + assert_eq!(iter.next(), Some(&2)); + assert_eq!(iter.size_hint(), (1, Some(1))); + + let s7: BTreeSet = (7..=19).collect(); + iter = s246.difference(&s7); + assert_eq!(iter.size_hint(), (3, Some(3))); +} + +#[test] +fn test_symmetric_difference() { + fn check_symmetric_difference(a: &[i32], b: &[i32], expected: &[i32]) { + check(a, b, expected, |x, y, f| x.symmetric_difference(y).all(f)) + } + + check_symmetric_difference(&[], &[], &[]); + check_symmetric_difference(&[1, 2, 3], &[2], &[1, 3]); + check_symmetric_difference(&[2], &[1, 2, 3], &[1, 3]); + check_symmetric_difference(&[1, 3, 5, 9, 11], &[-2, 3, 9, 14, 22], &[-2, 1, 5, 11, 14, 22]); +} + +#[test] +fn test_symmetric_difference_size_hint() { + let x: BTreeSet = [2, 4].iter().copied().collect(); + let y: BTreeSet = [1, 2, 3].iter().copied().collect(); + let mut iter = x.symmetric_difference(&y); + assert_eq!(iter.size_hint(), (0, Some(5))); + assert_eq!(iter.next(), Some(&1)); + assert_eq!(iter.size_hint(), (0, Some(4))); + assert_eq!(iter.next(), Some(&3)); + assert_eq!(iter.size_hint(), (0, Some(1))); +} + +#[test] +fn test_union() { + fn check_union(a: &[i32], b: &[i32], expected: &[i32]) { + check(a, b, expected, |x, y, f| x.union(y).all(f)) + } + + check_union(&[], &[], &[]); + check_union(&[1, 2, 3], &[2], &[1, 2, 3]); + check_union(&[2], &[1, 2, 3], &[1, 2, 3]); + check_union( + &[1, 3, 5, 9, 11, 16, 19, 24], + &[-2, 1, 5, 9, 13, 19], + &[-2, 1, 3, 5, 9, 11, 13, 16, 19, 24], + ); +} + +#[test] +fn test_union_size_hint() { + let x: BTreeSet = [2, 4].iter().copied().collect(); + let y: BTreeSet = [1, 2, 3].iter().copied().collect(); + let mut iter = x.union(&y); + assert_eq!(iter.size_hint(), (3, Some(5))); + assert_eq!(iter.next(), Some(&1)); + assert_eq!(iter.size_hint(), (2, Some(4))); + assert_eq!(iter.next(), Some(&2)); + assert_eq!(iter.size_hint(), (1, Some(2))); +} + +#[test] +// Only tests the simple function definition with respect to intersection +fn test_is_disjoint() { + let one = [1].iter().collect::>(); + let two = [2].iter().collect::>(); + assert!(one.is_disjoint(&two)); +} + +#[test] +// Also implicitly tests the trivial function definition of is_superset +fn test_is_subset() { + fn is_subset(a: &[i32], b: &[i32]) -> bool { + let set_a = a.iter().collect::>(); + let set_b = b.iter().collect::>(); + set_a.is_subset(&set_b) + } + + assert_eq!(is_subset(&[], &[]), true); + assert_eq!(is_subset(&[], &[1, 2]), true); + assert_eq!(is_subset(&[0], &[1, 2]), false); + assert_eq!(is_subset(&[1], &[1, 2]), true); + assert_eq!(is_subset(&[2], &[1, 2]), true); + assert_eq!(is_subset(&[3], &[1, 2]), false); + assert_eq!(is_subset(&[1, 2], &[1]), false); + assert_eq!(is_subset(&[1, 2], &[1, 2]), true); + assert_eq!(is_subset(&[1, 2], &[2, 3]), false); + assert_eq!( + is_subset(&[-5, 11, 22, 33, 40, 42], &[-12, -5, 11, 14, 22, 23, 33, 34, 38, 39, 40, 42]), + true + ); + assert_eq!(is_subset(&[-5, 11, 22, 33, 40, 42], &[-12, -5, 11, 14, 22, 23, 34, 38]), false); + + if cfg!(miri) { + // Miri is too slow + return; + } + + let large = (0..100).collect::>(); + assert_eq!(is_subset(&[], &large), true); + assert_eq!(is_subset(&large, &[]), false); + assert_eq!(is_subset(&[-1], &large), false); + assert_eq!(is_subset(&[0], &large), true); + assert_eq!(is_subset(&[1, 2], &large), true); + assert_eq!(is_subset(&[99, 100], &large), false); +} + +#[test] +fn test_drain_filter() { + let mut x: BTreeSet<_> = [1].iter().copied().collect(); + let mut y: BTreeSet<_> = [1].iter().copied().collect(); + + x.drain_filter(|_| true); + y.drain_filter(|_| false); + assert_eq!(x.len(), 0); + assert_eq!(y.len(), 1); +} + +#[test] +fn test_drain_filter_drop_panic_leak() { + static PREDS: AtomicU32 = AtomicU32::new(0); + static DROPS: AtomicU32 = AtomicU32::new(0); + + #[derive(PartialEq, Eq, PartialOrd, Ord)] + struct D(i32); + impl Drop for D { + fn drop(&mut self) { + if DROPS.fetch_add(1, Ordering::SeqCst) == 1 { + panic!("panic in `drop`"); + } + } + } + + let mut set = BTreeSet::new(); + set.insert(D(0)); + set.insert(D(4)); + set.insert(D(8)); + + catch_unwind(move || { + drop(set.drain_filter(|d| { + PREDS.fetch_add(1u32 << d.0, Ordering::SeqCst); + true + })) + }) + .ok(); + + assert_eq!(PREDS.load(Ordering::SeqCst), 0x011); + assert_eq!(DROPS.load(Ordering::SeqCst), 3); +} + +#[test] +fn test_drain_filter_pred_panic_leak() { + static PREDS: AtomicU32 = AtomicU32::new(0); + static DROPS: AtomicU32 = AtomicU32::new(0); + + #[derive(PartialEq, Eq, PartialOrd, Ord)] + struct D(i32); + impl Drop for D { + fn drop(&mut self) { + DROPS.fetch_add(1, Ordering::SeqCst); + } + } + + let mut set = BTreeSet::new(); + set.insert(D(0)); + set.insert(D(4)); + set.insert(D(8)); + + catch_unwind(AssertUnwindSafe(|| { + drop(set.drain_filter(|d| { + PREDS.fetch_add(1u32 << d.0, Ordering::SeqCst); + match d.0 { + 0 => true, + _ => panic!(), + } + })) + })) + .ok(); + + assert_eq!(PREDS.load(Ordering::SeqCst), 0x011); + assert_eq!(DROPS.load(Ordering::SeqCst), 1); + assert_eq!(set.len(), 2); + assert_eq!(set.first().unwrap().0, 4); + assert_eq!(set.last().unwrap().0, 8); +} + +#[test] +fn test_clear() { + let mut x = BTreeSet::new(); + x.insert(1); + + x.clear(); + assert!(x.is_empty()); +} + +#[test] +fn test_zip() { + let mut x = BTreeSet::new(); + x.insert(5); + x.insert(12); + x.insert(11); + + let mut y = BTreeSet::new(); + y.insert("foo"); + y.insert("bar"); + + let x = x; + let y = y; + let mut z = x.iter().zip(&y); + + assert_eq!(z.next().unwrap(), (&5, &("bar"))); + assert_eq!(z.next().unwrap(), (&11, &("foo"))); + assert!(z.next().is_none()); +} + +#[test] +fn test_from_iter() { + let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9]; + + let set: BTreeSet<_> = xs.iter().cloned().collect(); + + for x in &xs { + assert!(set.contains(x)); + } +} + +#[test] +fn test_show() { + let mut set = BTreeSet::new(); + let empty = BTreeSet::::new(); + + set.insert(1); + set.insert(2); + + let set_str = format!("{:?}", set); + + assert_eq!(set_str, "{1, 2}"); + assert_eq!(format!("{:?}", empty), "{}"); +} + +#[test] +fn test_extend_ref() { + let mut a = BTreeSet::new(); + a.insert(1); + + a.extend(&[2, 3, 4]); + + assert_eq!(a.len(), 4); + assert!(a.contains(&1)); + assert!(a.contains(&2)); + assert!(a.contains(&3)); + assert!(a.contains(&4)); + + let mut b = BTreeSet::new(); + b.insert(5); + b.insert(6); + + a.extend(&b); + + assert_eq!(a.len(), 6); + assert!(a.contains(&1)); + assert!(a.contains(&2)); + assert!(a.contains(&3)); + assert!(a.contains(&4)); + assert!(a.contains(&5)); + assert!(a.contains(&6)); +} + +#[test] +fn test_recovery() { + use std::cmp::Ordering; + + #[derive(Debug)] + struct Foo(&'static str, i32); + + impl PartialEq for Foo { + fn eq(&self, other: &Self) -> bool { + self.0 == other.0 + } + } + + impl Eq for Foo {} + + impl PartialOrd for Foo { + fn partial_cmp(&self, other: &Self) -> Option { + self.0.partial_cmp(&other.0) + } + } + + impl Ord for Foo { + fn cmp(&self, other: &Self) -> Ordering { + self.0.cmp(&other.0) + } + } + + let mut s = BTreeSet::new(); + assert_eq!(s.replace(Foo("a", 1)), None); + assert_eq!(s.len(), 1); + assert_eq!(s.replace(Foo("a", 2)), Some(Foo("a", 1))); + assert_eq!(s.len(), 1); + + { + let mut it = s.iter(); + assert_eq!(it.next(), Some(&Foo("a", 2))); + assert_eq!(it.next(), None); + } + + assert_eq!(s.get(&Foo("a", 1)), Some(&Foo("a", 2))); + assert_eq!(s.take(&Foo("a", 1)), Some(Foo("a", 2))); + assert_eq!(s.len(), 0); + + assert_eq!(s.get(&Foo("a", 1)), None); + assert_eq!(s.take(&Foo("a", 1)), None); + + assert_eq!(s.iter().next(), None); +} + +#[allow(dead_code)] +fn test_variance() { + fn set<'new>(v: BTreeSet<&'static str>) -> BTreeSet<&'new str> { + v + } + fn iter<'a, 'new>(v: Iter<'a, &'static str>) -> Iter<'a, &'new str> { + v + } + fn into_iter<'new>(v: IntoIter<&'static str>) -> IntoIter<&'new str> { + v + } + fn range<'a, 'new>(v: Range<'a, &'static str>) -> Range<'a, &'new str> { + v + } + // not applied to Difference, Intersection, SymmetricDifference, Union +} + +#[allow(dead_code)] +fn test_sync() { + fn set(v: &BTreeSet) -> impl Sync + '_ { + v + } + + fn iter(v: &BTreeSet) -> impl Sync + '_ { + v.iter() + } + + fn into_iter(v: BTreeSet) -> impl Sync { + v.into_iter() + } + + fn range(v: &BTreeSet) -> impl Sync + '_ { + v.range(..) + } + + fn drain_filter(v: &mut BTreeSet) -> impl Sync + '_ { + v.drain_filter(|_| false) + } + + fn difference(v: &BTreeSet) -> impl Sync + '_ { + v.difference(&v) + } + + fn intersection(v: &BTreeSet) -> impl Sync + '_ { + v.intersection(&v) + } + + fn symmetric_difference(v: &BTreeSet) -> impl Sync + '_ { + v.symmetric_difference(&v) + } + + fn union(v: &BTreeSet) -> impl Sync + '_ { + v.union(&v) + } +} + +#[allow(dead_code)] +fn test_send() { + fn set(v: BTreeSet) -> impl Send { + v + } + + fn iter(v: &BTreeSet) -> impl Send + '_ { + v.iter() + } + + fn into_iter(v: BTreeSet) -> impl Send { + v.into_iter() + } + + fn range(v: &BTreeSet) -> impl Send + '_ { + v.range(..) + } + + fn drain_filter(v: &mut BTreeSet) -> impl Send + '_ { + v.drain_filter(|_| false) + } + + fn difference(v: &BTreeSet) -> impl Send + '_ { + v.difference(&v) + } + + fn intersection(v: &BTreeSet) -> impl Send + '_ { + v.intersection(&v) + } + + fn symmetric_difference(v: &BTreeSet) -> impl Send + '_ { + v.symmetric_difference(&v) + } + + fn union(v: &BTreeSet) -> impl Send + '_ { + v.union(&v) + } +} + +#[test] +fn test_append() { + let mut a = BTreeSet::new(); + a.insert(1); + a.insert(2); + a.insert(3); + + let mut b = BTreeSet::new(); + b.insert(3); + b.insert(4); + b.insert(5); + + a.append(&mut b); + + assert_eq!(a.len(), 5); + assert_eq!(b.len(), 0); + + assert_eq!(a.contains(&1), true); + assert_eq!(a.contains(&2), true); + assert_eq!(a.contains(&3), true); + assert_eq!(a.contains(&4), true); + assert_eq!(a.contains(&5), true); +} + +#[test] +fn test_first_last() { + let mut a = BTreeSet::new(); + assert_eq!(a.first(), None); + assert_eq!(a.last(), None); + a.insert(1); + assert_eq!(a.first(), Some(&1)); + assert_eq!(a.last(), Some(&1)); + a.insert(2); + assert_eq!(a.first(), Some(&1)); + assert_eq!(a.last(), Some(&2)); + for i in 3..=12 { + a.insert(i); + } + assert_eq!(a.first(), Some(&1)); + assert_eq!(a.last(), Some(&12)); + assert_eq!(a.pop_first(), Some(1)); + assert_eq!(a.pop_last(), Some(12)); + assert_eq!(a.pop_first(), Some(2)); + assert_eq!(a.pop_last(), Some(11)); + assert_eq!(a.pop_first(), Some(3)); + assert_eq!(a.pop_last(), Some(10)); + assert_eq!(a.pop_first(), Some(4)); + assert_eq!(a.pop_first(), Some(5)); + assert_eq!(a.pop_first(), Some(6)); + assert_eq!(a.pop_first(), Some(7)); + assert_eq!(a.pop_first(), Some(8)); + assert_eq!(a.clone().pop_last(), Some(9)); + assert_eq!(a.pop_first(), Some(9)); + assert_eq!(a.pop_first(), None); + assert_eq!(a.pop_last(), None); +} + +fn rand_data(len: usize) -> Vec { + assert!(len <= 70029); // from that point on numbers repeat + let mut rng = DeterministicRng::new(); + Vec::from_iter((0..len).map(|_| rng.next())) +} + +#[test] +fn test_split_off_empty_right() { + let mut data = rand_data(173); + + let mut set = BTreeSet::from_iter(data.clone()); + let right = set.split_off(&(data.iter().max().unwrap() + 1)); + + data.sort(); + assert!(set.into_iter().eq(data)); + assert!(right.into_iter().eq(None)); +} + +#[test] +fn test_split_off_empty_left() { + let mut data = rand_data(314); + + let mut set = BTreeSet::from_iter(data.clone()); + let right = set.split_off(data.iter().min().unwrap()); + + data.sort(); + assert!(set.into_iter().eq(None)); + assert!(right.into_iter().eq(data)); +} + +#[test] +fn test_split_off_large_random_sorted() { + // Miri is too slow + let mut data = if cfg!(miri) { rand_data(529) } else { rand_data(1529) }; + // special case with maximum height. + data.sort(); + + let mut set = BTreeSet::from_iter(data.clone()); + let key = data[data.len() / 2]; + let right = set.split_off(&key); + + assert!(set.into_iter().eq(data.clone().into_iter().filter(|x| *x < key))); + assert!(right.into_iter().eq(data.into_iter().filter(|x| *x >= key))); +} diff --git a/libgrust/rustc-lib/alloc/src/collections/btree/split.rs b/libgrust/rustc-lib/alloc/src/collections/btree/split.rs new file mode 100644 index 000000000000..5f00a5a25aba --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/btree/split.rs @@ -0,0 +1,106 @@ +use super::map::MIN_LEN; +use super::node::{ForceResult::*, Root}; +use super::search::{search_node, SearchResult::*}; +use core::borrow::Borrow; + +impl Root { + pub fn split_off(&mut self, right_root: &mut Self, key: &Q) + where + K: Borrow, + { + debug_assert!(right_root.height() == 0); + debug_assert!(right_root.node_as_ref().len() == 0); + + let left_root = self; + for _ in 0..left_root.height() { + right_root.push_internal_level(); + } + + { + let mut left_node = left_root.node_as_mut(); + let mut right_node = right_root.node_as_mut(); + + loop { + let mut split_edge = match search_node(left_node, key) { + // key is going to the right tree + Found(handle) => handle.left_edge(), + GoDown(handle) => handle, + }; + + split_edge.move_suffix(&mut right_node); + + match (split_edge.force(), right_node.force()) { + (Internal(edge), Internal(node)) => { + left_node = edge.descend(); + right_node = node.first_edge().descend(); + } + (Leaf(_), Leaf(_)) => { + break; + } + _ => unreachable!(), + } + } + } + + left_root.fix_right_border(); + right_root.fix_left_border(); + } + + /// Removes empty levels on the top, but keeps an empty leaf if the entire tree is empty. + fn fix_top(&mut self) { + while self.height() > 0 && self.node_as_ref().len() == 0 { + self.pop_internal_level(); + } + } + + fn fix_right_border(&mut self) { + self.fix_top(); + + { + let mut cur_node = self.node_as_mut(); + + while let Internal(node) = cur_node.force() { + let mut last_kv = node.last_kv(); + + if last_kv.can_merge() { + cur_node = last_kv.merge().descend(); + } else { + let right_len = last_kv.reborrow().right_edge().descend().len(); + // `MIN_LEN + 1` to avoid readjust if merge happens on the next level. + if right_len < MIN_LEN + 1 { + last_kv.bulk_steal_left(MIN_LEN + 1 - right_len); + } + cur_node = last_kv.right_edge().descend(); + } + } + } + + self.fix_top(); + } + + /// The symmetric clone of `fix_right_border`. + fn fix_left_border(&mut self) { + self.fix_top(); + + { + let mut cur_node = self.node_as_mut(); + + while let Internal(node) = cur_node.force() { + let mut first_kv = node.first_kv(); + + if first_kv.can_merge() { + cur_node = first_kv.merge().descend(); + } else { + let left_len = first_kv.reborrow().left_edge().descend().len(); + // `MIN_LEN + 1` to avoid readjust if merge happens on the next level. + if left_len < MIN_LEN + 1 { + first_kv.bulk_steal_right(MIN_LEN + 1 - left_len); + } + cur_node = first_kv.left_edge().descend(); + } + } + } + + self.fix_top(); + } +} diff --git a/libgrust/rustc-lib/alloc/src/collections/linked_list.rs b/libgrust/rustc-lib/alloc/src/collections/linked_list.rs new file mode 100644 index 000000000000..412c65681e68 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/linked_list.rs @@ -0,0 +1,1872 @@ +//! A doubly-linked list with owned nodes. +//! +//! The `LinkedList` allows pushing and popping elements at either end +//! in constant time. +//! +//! NOTE: It is almost always better to use [`Vec`] or [`VecDeque`] because +//! array-based containers are generally faster, +//! more memory efficient, and make better use of CPU cache. +//! +//! [`Vec`]: crate::vec::Vec +//! [`VecDeque`]: super::vec_deque::VecDeque + +#![stable(feature = "rust1", since = "1.0.0")] + +use core::cmp::Ordering; +use core::fmt; +use core::hash::{Hash, Hasher}; +use core::iter::{FromIterator, FusedIterator}; +use core::marker::PhantomData; +use core::mem; +use core::ptr::NonNull; + +use super::SpecExtend; +use crate::boxed::Box; + +#[cfg(test)] +mod tests; + +/// A doubly-linked list with owned nodes. +/// +/// The `LinkedList` allows pushing and popping elements at either end +/// in constant time. +/// +/// NOTE: It is almost always better to use `Vec` or `VecDeque` because +/// array-based containers are generally faster, +/// more memory efficient, and make better use of CPU cache. +#[stable(feature = "rust1", since = "1.0.0")] +pub struct LinkedList { + head: Option>>, + tail: Option>>, + len: usize, + marker: PhantomData>>, +} + +struct Node { + next: Option>>, + prev: Option>>, + element: T, +} + +/// An iterator over the elements of a `LinkedList`. +/// +/// This `struct` is created by [`LinkedList::iter()`]. See its +/// documentation for more. +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Iter<'a, T: 'a> { + head: Option>>, + tail: Option>>, + len: usize, + marker: PhantomData<&'a Node>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Iter<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Iter").field(&self.len).finish() + } +} + +// FIXME(#26925) Remove in favor of `#[derive(Clone)]` +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Iter<'_, T> { + fn clone(&self) -> Self { + Iter { ..*self } + } +} + +/// A mutable iterator over the elements of a `LinkedList`. +/// +/// This `struct` is created by [`LinkedList::iter_mut()`]. See its +/// documentation for more. +#[stable(feature = "rust1", since = "1.0.0")] +pub struct IterMut<'a, T: 'a> { + // We do *not* exclusively own the entire list here, references to node's `element` + // have been handed out by the iterator! So be careful when using this; the methods + // called must be aware that there can be aliasing pointers to `element`. + list: &'a mut LinkedList, + head: Option>>, + tail: Option>>, + len: usize, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for IterMut<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("IterMut").field(&self.list).field(&self.len).finish() + } +} + +/// An owning iterator over the elements of a `LinkedList`. +/// +/// This `struct` is created by the [`into_iter`] method on [`LinkedList`] +/// (provided by the `IntoIterator` trait). See its documentation for more. +/// +/// [`into_iter`]: LinkedList::into_iter +#[derive(Clone)] +#[stable(feature = "rust1", since = "1.0.0")] +pub struct IntoIter { + list: LinkedList, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for IntoIter { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("IntoIter").field(&self.list).finish() + } +} + +impl Node { + fn new(element: T) -> Self { + Node { next: None, prev: None, element } + } + + fn into_element(self: Box) -> T { + self.element + } +} + +// private methods +impl LinkedList { + /// Adds the given node to the front of the list. + #[inline] + fn push_front_node(&mut self, mut node: Box>) { + // This method takes care not to create mutable references to whole nodes, + // to maintain validity of aliasing pointers into `element`. + unsafe { + node.next = self.head; + node.prev = None; + let node = Some(Box::leak(node).into()); + + match self.head { + None => self.tail = node, + // Not creating new mutable (unique!) references overlapping `element`. + Some(head) => (*head.as_ptr()).prev = node, + } + + self.head = node; + self.len += 1; + } + } + + /// Removes and returns the node at the front of the list. + #[inline] + fn pop_front_node(&mut self) -> Option>> { + // This method takes care not to create mutable references to whole nodes, + // to maintain validity of aliasing pointers into `element`. + self.head.map(|node| unsafe { + let node = Box::from_raw(node.as_ptr()); + self.head = node.next; + + match self.head { + None => self.tail = None, + // Not creating new mutable (unique!) references overlapping `element`. + Some(head) => (*head.as_ptr()).prev = None, + } + + self.len -= 1; + node + }) + } + + /// Adds the given node to the back of the list. + #[inline] + fn push_back_node(&mut self, mut node: Box>) { + // This method takes care not to create mutable references to whole nodes, + // to maintain validity of aliasing pointers into `element`. + unsafe { + node.next = None; + node.prev = self.tail; + let node = Some(Box::leak(node).into()); + + match self.tail { + None => self.head = node, + // Not creating new mutable (unique!) references overlapping `element`. + Some(tail) => (*tail.as_ptr()).next = node, + } + + self.tail = node; + self.len += 1; + } + } + + /// Removes and returns the node at the back of the list. + #[inline] + fn pop_back_node(&mut self) -> Option>> { + // This method takes care not to create mutable references to whole nodes, + // to maintain validity of aliasing pointers into `element`. + self.tail.map(|node| unsafe { + let node = Box::from_raw(node.as_ptr()); + self.tail = node.prev; + + match self.tail { + None => self.head = None, + // Not creating new mutable (unique!) references overlapping `element`. + Some(tail) => (*tail.as_ptr()).next = None, + } + + self.len -= 1; + node + }) + } + + /// Unlinks the specified node from the current list. + /// + /// Warning: this will not check that the provided node belongs to the current list. + /// + /// This method takes care not to create mutable references to `element`, to + /// maintain validity of aliasing pointers. + #[inline] + unsafe fn unlink_node(&mut self, mut node: NonNull>) { + let node = unsafe { node.as_mut() }; // this one is ours now, we can create an &mut. + + // Not creating new mutable (unique!) references overlapping `element`. + match node.prev { + Some(prev) => unsafe { (*prev.as_ptr()).next = node.next }, + // this node is the head node + None => self.head = node.next, + }; + + match node.next { + Some(next) => unsafe { (*next.as_ptr()).prev = node.prev }, + // this node is the tail node + None => self.tail = node.prev, + }; + + self.len -= 1; + } + + /// Splices a series of nodes between two existing nodes. + /// + /// Warning: this will not check that the provided node belongs to the two existing lists. + #[inline] + unsafe fn splice_nodes( + &mut self, + existing_prev: Option>>, + existing_next: Option>>, + mut splice_start: NonNull>, + mut splice_end: NonNull>, + splice_length: usize, + ) { + // This method takes care not to create multiple mutable references to whole nodes at the same time, + // to maintain validity of aliasing pointers into `element`. + if let Some(mut existing_prev) = existing_prev { + unsafe { + existing_prev.as_mut().next = Some(splice_start); + } + } else { + self.head = Some(splice_start); + } + if let Some(mut existing_next) = existing_next { + unsafe { + existing_next.as_mut().prev = Some(splice_end); + } + } else { + self.tail = Some(splice_end); + } + unsafe { + splice_start.as_mut().prev = existing_prev; + splice_end.as_mut().next = existing_next; + } + + self.len += splice_length; + } + + /// Detaches all nodes from a linked list as a series of nodes. + #[inline] + fn detach_all_nodes(mut self) -> Option<(NonNull>, NonNull>, usize)> { + let head = self.head.take(); + let tail = self.tail.take(); + let len = mem::replace(&mut self.len, 0); + if let Some(head) = head { + let tail = tail.unwrap_or_else(|| unsafe { core::hint::unreachable_unchecked() }); + Some((head, tail, len)) + } else { + None + } + } + + #[inline] + unsafe fn split_off_before_node( + &mut self, + split_node: Option>>, + at: usize, + ) -> Self { + // The split node is the new head node of the second part + if let Some(mut split_node) = split_node { + let first_part_head; + let first_part_tail; + unsafe { + first_part_tail = split_node.as_mut().prev.take(); + } + if let Some(mut tail) = first_part_tail { + unsafe { + tail.as_mut().next = None; + } + first_part_head = self.head; + } else { + first_part_head = None; + } + + let first_part = LinkedList { + head: first_part_head, + tail: first_part_tail, + len: at, + marker: PhantomData, + }; + + // Fix the head ptr of the second part + self.head = Some(split_node); + self.len = self.len - at; + + first_part + } else { + mem::replace(self, LinkedList::new()) + } + } + + #[inline] + unsafe fn split_off_after_node( + &mut self, + split_node: Option>>, + at: usize, + ) -> Self { + // The split node is the new tail node of the first part and owns + // the head of the second part. + if let Some(mut split_node) = split_node { + let second_part_head; + let second_part_tail; + unsafe { + second_part_head = split_node.as_mut().next.take(); + } + if let Some(mut head) = second_part_head { + unsafe { + head.as_mut().prev = None; + } + second_part_tail = self.tail; + } else { + second_part_tail = None; + } + + let second_part = LinkedList { + head: second_part_head, + tail: second_part_tail, + len: self.len - at, + marker: PhantomData, + }; + + // Fix the tail ptr of the first part + self.tail = Some(split_node); + self.len = at; + + second_part + } else { + mem::replace(self, LinkedList::new()) + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for LinkedList { + /// Creates an empty `LinkedList`. + #[inline] + fn default() -> Self { + Self::new() + } +} + +impl LinkedList { + /// Creates an empty `LinkedList`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let list: LinkedList = LinkedList::new(); + /// ``` + #[inline] + #[rustc_const_stable(feature = "const_linked_list_new", since = "1.32.0")] + #[stable(feature = "rust1", since = "1.0.0")] + pub const fn new() -> Self { + LinkedList { head: None, tail: None, len: 0, marker: PhantomData } + } + + /// Moves all elements from `other` to the end of the list. + /// + /// This reuses all the nodes from `other` and moves them into `self`. After + /// this operation, `other` becomes empty. + /// + /// This operation should compute in *O*(1) time and *O*(1) memory. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut list1 = LinkedList::new(); + /// list1.push_back('a'); + /// + /// let mut list2 = LinkedList::new(); + /// list2.push_back('b'); + /// list2.push_back('c'); + /// + /// list1.append(&mut list2); + /// + /// let mut iter = list1.iter(); + /// assert_eq!(iter.next(), Some(&'a')); + /// assert_eq!(iter.next(), Some(&'b')); + /// assert_eq!(iter.next(), Some(&'c')); + /// assert!(iter.next().is_none()); + /// + /// assert!(list2.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn append(&mut self, other: &mut Self) { + match self.tail { + None => mem::swap(self, other), + Some(mut tail) => { + // `as_mut` is okay here because we have exclusive access to the entirety + // of both lists. + if let Some(mut other_head) = other.head.take() { + unsafe { + tail.as_mut().next = Some(other_head); + other_head.as_mut().prev = Some(tail); + } + + self.tail = other.tail.take(); + self.len += mem::replace(&mut other.len, 0); + } + } + } + } + + /// Moves all elements from `other` to the begin of the list. + #[unstable(feature = "linked_list_prepend", issue = "none")] + pub fn prepend(&mut self, other: &mut Self) { + match self.head { + None => mem::swap(self, other), + Some(mut head) => { + // `as_mut` is okay here because we have exclusive access to the entirety + // of both lists. + if let Some(mut other_tail) = other.tail.take() { + unsafe { + head.as_mut().prev = Some(other_tail); + other_tail.as_mut().next = Some(head); + } + + self.head = other.head.take(); + self.len += mem::replace(&mut other.len, 0); + } + } + } + } + + /// Provides a forward iterator. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut list: LinkedList = LinkedList::new(); + /// + /// list.push_back(0); + /// list.push_back(1); + /// list.push_back(2); + /// + /// let mut iter = list.iter(); + /// assert_eq!(iter.next(), Some(&0)); + /// assert_eq!(iter.next(), Some(&1)); + /// assert_eq!(iter.next(), Some(&2)); + /// assert_eq!(iter.next(), None); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn iter(&self) -> Iter<'_, T> { + Iter { head: self.head, tail: self.tail, len: self.len, marker: PhantomData } + } + + /// Provides a forward iterator with mutable references. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut list: LinkedList = LinkedList::new(); + /// + /// list.push_back(0); + /// list.push_back(1); + /// list.push_back(2); + /// + /// for element in list.iter_mut() { + /// *element += 10; + /// } + /// + /// let mut iter = list.iter(); + /// assert_eq!(iter.next(), Some(&10)); + /// assert_eq!(iter.next(), Some(&11)); + /// assert_eq!(iter.next(), Some(&12)); + /// assert_eq!(iter.next(), None); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn iter_mut(&mut self) -> IterMut<'_, T> { + IterMut { head: self.head, tail: self.tail, len: self.len, list: self } + } + + /// Provides a cursor at the front element. + /// + /// The cursor is pointing to the "ghost" non-element if the list is empty. + #[inline] + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn cursor_front(&self) -> Cursor<'_, T> { + Cursor { index: 0, current: self.head, list: self } + } + + /// Provides a cursor with editing operations at the front element. + /// + /// The cursor is pointing to the "ghost" non-element if the list is empty. + #[inline] + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn cursor_front_mut(&mut self) -> CursorMut<'_, T> { + CursorMut { index: 0, current: self.head, list: self } + } + + /// Provides a cursor at the back element. + /// + /// The cursor is pointing to the "ghost" non-element if the list is empty. + #[inline] + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn cursor_back(&self) -> Cursor<'_, T> { + Cursor { index: self.len.checked_sub(1).unwrap_or(0), current: self.tail, list: self } + } + + /// Provides a cursor with editing operations at the back element. + /// + /// The cursor is pointing to the "ghost" non-element if the list is empty. + #[inline] + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn cursor_back_mut(&mut self) -> CursorMut<'_, T> { + CursorMut { index: self.len.checked_sub(1).unwrap_or(0), current: self.tail, list: self } + } + + /// Returns `true` if the `LinkedList` is empty. + /// + /// This operation should compute in *O*(1) time. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut dl = LinkedList::new(); + /// assert!(dl.is_empty()); + /// + /// dl.push_front("foo"); + /// assert!(!dl.is_empty()); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn is_empty(&self) -> bool { + self.head.is_none() + } + + /// Returns the length of the `LinkedList`. + /// + /// This operation should compute in *O*(1) time. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut dl = LinkedList::new(); + /// + /// dl.push_front(2); + /// assert_eq!(dl.len(), 1); + /// + /// dl.push_front(1); + /// assert_eq!(dl.len(), 2); + /// + /// dl.push_back(3); + /// assert_eq!(dl.len(), 3); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn len(&self) -> usize { + self.len + } + + /// Removes all elements from the `LinkedList`. + /// + /// This operation should compute in *O*(*n*) time. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut dl = LinkedList::new(); + /// + /// dl.push_front(2); + /// dl.push_front(1); + /// assert_eq!(dl.len(), 2); + /// assert_eq!(dl.front(), Some(&1)); + /// + /// dl.clear(); + /// assert_eq!(dl.len(), 0); + /// assert_eq!(dl.front(), None); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn clear(&mut self) { + *self = Self::new(); + } + + /// Returns `true` if the `LinkedList` contains an element equal to the + /// given value. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut list: LinkedList = LinkedList::new(); + /// + /// list.push_back(0); + /// list.push_back(1); + /// list.push_back(2); + /// + /// assert_eq!(list.contains(&0), true); + /// assert_eq!(list.contains(&10), false); + /// ``` + #[stable(feature = "linked_list_contains", since = "1.12.0")] + pub fn contains(&self, x: &T) -> bool + where + T: PartialEq, + { + self.iter().any(|e| e == x) + } + + /// Provides a reference to the front element, or `None` if the list is + /// empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut dl = LinkedList::new(); + /// assert_eq!(dl.front(), None); + /// + /// dl.push_front(1); + /// assert_eq!(dl.front(), Some(&1)); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn front(&self) -> Option<&T> { + unsafe { self.head.as_ref().map(|node| &node.as_ref().element) } + } + + /// Provides a mutable reference to the front element, or `None` if the list + /// is empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut dl = LinkedList::new(); + /// assert_eq!(dl.front(), None); + /// + /// dl.push_front(1); + /// assert_eq!(dl.front(), Some(&1)); + /// + /// match dl.front_mut() { + /// None => {}, + /// Some(x) => *x = 5, + /// } + /// assert_eq!(dl.front(), Some(&5)); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn front_mut(&mut self) -> Option<&mut T> { + unsafe { self.head.as_mut().map(|node| &mut node.as_mut().element) } + } + + /// Provides a reference to the back element, or `None` if the list is + /// empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut dl = LinkedList::new(); + /// assert_eq!(dl.back(), None); + /// + /// dl.push_back(1); + /// assert_eq!(dl.back(), Some(&1)); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn back(&self) -> Option<&T> { + unsafe { self.tail.as_ref().map(|node| &node.as_ref().element) } + } + + /// Provides a mutable reference to the back element, or `None` if the list + /// is empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut dl = LinkedList::new(); + /// assert_eq!(dl.back(), None); + /// + /// dl.push_back(1); + /// assert_eq!(dl.back(), Some(&1)); + /// + /// match dl.back_mut() { + /// None => {}, + /// Some(x) => *x = 5, + /// } + /// assert_eq!(dl.back(), Some(&5)); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn back_mut(&mut self) -> Option<&mut T> { + unsafe { self.tail.as_mut().map(|node| &mut node.as_mut().element) } + } + + /// Adds an element first in the list. + /// + /// This operation should compute in *O*(1) time. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut dl = LinkedList::new(); + /// + /// dl.push_front(2); + /// assert_eq!(dl.front().unwrap(), &2); + /// + /// dl.push_front(1); + /// assert_eq!(dl.front().unwrap(), &1); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn push_front(&mut self, elt: T) { + self.push_front_node(box Node::new(elt)); + } + + /// Removes the first element and returns it, or `None` if the list is + /// empty. + /// + /// This operation should compute in *O*(1) time. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut d = LinkedList::new(); + /// assert_eq!(d.pop_front(), None); + /// + /// d.push_front(1); + /// d.push_front(3); + /// assert_eq!(d.pop_front(), Some(3)); + /// assert_eq!(d.pop_front(), Some(1)); + /// assert_eq!(d.pop_front(), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn pop_front(&mut self) -> Option { + self.pop_front_node().map(Node::into_element) + } + + /// Appends an element to the back of a list. + /// + /// This operation should compute in *O*(1) time. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut d = LinkedList::new(); + /// d.push_back(1); + /// d.push_back(3); + /// assert_eq!(3, *d.back().unwrap()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn push_back(&mut self, elt: T) { + self.push_back_node(box Node::new(elt)); + } + + /// Removes the last element from a list and returns it, or `None` if + /// it is empty. + /// + /// This operation should compute in *O*(1) time. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut d = LinkedList::new(); + /// assert_eq!(d.pop_back(), None); + /// d.push_back(1); + /// d.push_back(3); + /// assert_eq!(d.pop_back(), Some(3)); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn pop_back(&mut self) -> Option { + self.pop_back_node().map(Node::into_element) + } + + /// Splits the list into two at the given index. Returns everything after the given index, + /// including the index. + /// + /// This operation should compute in *O*(*n*) time. + /// + /// # Panics + /// + /// Panics if `at > len`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut d = LinkedList::new(); + /// + /// d.push_front(1); + /// d.push_front(2); + /// d.push_front(3); + /// + /// let mut split = d.split_off(2); + /// + /// assert_eq!(split.pop_front(), Some(1)); + /// assert_eq!(split.pop_front(), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn split_off(&mut self, at: usize) -> LinkedList { + let len = self.len(); + assert!(at <= len, "Cannot split off at a nonexistent index"); + if at == 0 { + return mem::take(self); + } else if at == len { + return Self::new(); + } + + // Below, we iterate towards the `i-1`th node, either from the start or the end, + // depending on which would be faster. + let split_node = if at - 1 <= len - 1 - (at - 1) { + let mut iter = self.iter_mut(); + // instead of skipping using .skip() (which creates a new struct), + // we skip manually so we can access the head field without + // depending on implementation details of Skip + for _ in 0..at - 1 { + iter.next(); + } + iter.head + } else { + // better off starting from the end + let mut iter = self.iter_mut(); + for _ in 0..len - 1 - (at - 1) { + iter.next_back(); + } + iter.tail + }; + unsafe { self.split_off_after_node(split_node, at) } + } + + /// Removes the element at the given index and returns it. + /// + /// This operation should compute in *O*(*n*) time. + /// + /// # Panics + /// Panics if at >= len + /// + /// # Examples + /// + /// ``` + /// #![feature(linked_list_remove)] + /// use std::collections::LinkedList; + /// + /// let mut d = LinkedList::new(); + /// + /// d.push_front(1); + /// d.push_front(2); + /// d.push_front(3); + /// + /// assert_eq!(d.remove(1), 2); + /// assert_eq!(d.remove(0), 3); + /// assert_eq!(d.remove(0), 1); + /// ``` + #[unstable(feature = "linked_list_remove", issue = "69210")] + pub fn remove(&mut self, at: usize) -> T { + let len = self.len(); + assert!(at < len, "Cannot remove at an index outside of the list bounds"); + + // Below, we iterate towards the node at the given index, either from + // the start or the end, depending on which would be faster. + let offset_from_end = len - at - 1; + if at <= offset_from_end { + let mut cursor = self.cursor_front_mut(); + for _ in 0..at { + cursor.move_next(); + } + cursor.remove_current().unwrap() + } else { + let mut cursor = self.cursor_back_mut(); + for _ in 0..offset_from_end { + cursor.move_prev(); + } + cursor.remove_current().unwrap() + } + } + + /// Creates an iterator which uses a closure to determine if an element should be removed. + /// + /// If the closure returns true, then the element is removed and yielded. + /// If the closure returns false, the element will remain in the list and will not be yielded + /// by the iterator. + /// + /// Note that `drain_filter` lets you mutate every element in the filter closure, regardless of + /// whether you choose to keep or remove it. + /// + /// # Examples + /// + /// Splitting a list into evens and odds, reusing the original list: + /// + /// ``` + /// #![feature(drain_filter)] + /// use std::collections::LinkedList; + /// + /// let mut numbers: LinkedList = LinkedList::new(); + /// numbers.extend(&[1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15]); + /// + /// let evens = numbers.drain_filter(|x| *x % 2 == 0).collect::>(); + /// let odds = numbers; + /// + /// assert_eq!(evens.into_iter().collect::>(), vec![2, 4, 6, 8, 14]); + /// assert_eq!(odds.into_iter().collect::>(), vec![1, 3, 5, 9, 11, 13, 15]); + /// ``` + #[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] + pub fn drain_filter(&mut self, filter: F) -> DrainFilter<'_, T, F> + where + F: FnMut(&mut T) -> bool, + { + // avoid borrow issues. + let it = self.head; + let old_len = self.len; + + DrainFilter { list: self, it, pred: filter, idx: 0, old_len } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl<#[may_dangle] T> Drop for LinkedList { + fn drop(&mut self) { + struct DropGuard<'a, T>(&'a mut LinkedList); + + impl<'a, T> Drop for DropGuard<'a, T> { + fn drop(&mut self) { + // Continue the same loop we do below. This only runs when a destructor has + // panicked. If another one panics this will abort. + while self.0.pop_front_node().is_some() {} + } + } + + while let Some(node) = self.pop_front_node() { + let guard = DropGuard(self); + drop(node); + mem::forget(guard); + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> Iterator for Iter<'a, T> { + type Item = &'a T; + + #[inline] + fn next(&mut self) -> Option<&'a T> { + if self.len == 0 { + None + } else { + self.head.map(|node| unsafe { + // Need an unbound lifetime to get 'a + let node = &*node.as_ptr(); + self.len -= 1; + self.head = node.next; + &node.element + }) + } + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + (self.len, Some(self.len)) + } + + #[inline] + fn last(mut self) -> Option<&'a T> { + self.next_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> DoubleEndedIterator for Iter<'a, T> { + #[inline] + fn next_back(&mut self) -> Option<&'a T> { + if self.len == 0 { + None + } else { + self.tail.map(|node| unsafe { + // Need an unbound lifetime to get 'a + let node = &*node.as_ptr(); + self.len -= 1; + self.tail = node.prev; + &node.element + }) + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for Iter<'_, T> {} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Iter<'_, T> {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> Iterator for IterMut<'a, T> { + type Item = &'a mut T; + + #[inline] + fn next(&mut self) -> Option<&'a mut T> { + if self.len == 0 { + None + } else { + self.head.map(|node| unsafe { + // Need an unbound lifetime to get 'a + let node = &mut *node.as_ptr(); + self.len -= 1; + self.head = node.next; + &mut node.element + }) + } + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + (self.len, Some(self.len)) + } + + #[inline] + fn last(mut self) -> Option<&'a mut T> { + self.next_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> DoubleEndedIterator for IterMut<'a, T> { + #[inline] + fn next_back(&mut self) -> Option<&'a mut T> { + if self.len == 0 { + None + } else { + self.tail.map(|node| unsafe { + // Need an unbound lifetime to get 'a + let node = &mut *node.as_ptr(); + self.len -= 1; + self.tail = node.prev; + &mut node.element + }) + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for IterMut<'_, T> {} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for IterMut<'_, T> {} + +impl IterMut<'_, T> { + /// Inserts the given element just after the element most recently returned by `.next()`. + /// The inserted element does not appear in the iteration. + /// + /// This method will be removed soon. + #[inline] + #[unstable( + feature = "linked_list_extras", + reason = "this is probably better handled by a cursor type -- we'll see", + issue = "27794" + )] + #[rustc_deprecated( + reason = "Deprecated in favor of CursorMut methods. This method will be removed soon.", + since = "1.47.0" + )] + pub fn insert_next(&mut self, element: T) { + match self.head { + // `push_back` is okay with aliasing `element` references + None => self.list.push_back(element), + Some(head) => unsafe { + let prev = match head.as_ref().prev { + // `push_front` is okay with aliasing nodes + None => return self.list.push_front(element), + Some(prev) => prev, + }; + + let node = Some( + Box::leak(box Node { next: Some(head), prev: Some(prev), element }).into(), + ); + + // Not creating references to entire nodes to not invalidate the + // reference to `element` we handed to the user. + (*prev.as_ptr()).next = node; + (*head.as_ptr()).prev = node; + + self.list.len += 1; + }, + } + } + + /// Provides a reference to the next element, without changing the iterator. + /// + /// This method will be removed soon. + #[inline] + #[unstable( + feature = "linked_list_extras", + reason = "this is probably better handled by a cursor type -- we'll see", + issue = "27794" + )] + #[rustc_deprecated( + reason = "Deprecated in favor of CursorMut methods. This method will be removed soon.", + since = "1.47.0" + )] + pub fn peek_next(&mut self) -> Option<&mut T> { + if self.len == 0 { + None + } else { + unsafe { self.head.as_mut().map(|node| &mut node.as_mut().element) } + } + } +} + +/// A cursor over a `LinkedList`. +/// +/// A `Cursor` is like an iterator, except that it can freely seek back-and-forth. +/// +/// Cursors always rest between two elements in the list, and index in a logically circular way. +/// To accommodate this, there is a "ghost" non-element that yields `None` between the head and +/// tail of the list. +/// +/// When created, cursors start at the front of the list, or the "ghost" non-element if the list is empty. +#[unstable(feature = "linked_list_cursors", issue = "58533")] +pub struct Cursor<'a, T: 'a> { + index: usize, + current: Option>>, + list: &'a LinkedList, +} + +#[unstable(feature = "linked_list_cursors", issue = "58533")] +impl Clone for Cursor<'_, T> { + fn clone(&self) -> Self { + let Cursor { index, current, list } = *self; + Cursor { index, current, list } + } +} + +#[unstable(feature = "linked_list_cursors", issue = "58533")] +impl fmt::Debug for Cursor<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Cursor").field(&self.list).field(&self.index()).finish() + } +} + +/// A cursor over a `LinkedList` with editing operations. +/// +/// A `Cursor` is like an iterator, except that it can freely seek back-and-forth, and can +/// safely mutate the list during iteration. This is because the lifetime of its yielded +/// references is tied to its own lifetime, instead of just the underlying list. This means +/// cursors cannot yield multiple elements at once. +/// +/// Cursors always rest between two elements in the list, and index in a logically circular way. +/// To accommodate this, there is a "ghost" non-element that yields `None` between the head and +/// tail of the list. +#[unstable(feature = "linked_list_cursors", issue = "58533")] +pub struct CursorMut<'a, T: 'a> { + index: usize, + current: Option>>, + list: &'a mut LinkedList, +} + +#[unstable(feature = "linked_list_cursors", issue = "58533")] +impl fmt::Debug for CursorMut<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("CursorMut").field(&self.list).field(&self.index()).finish() + } +} + +impl<'a, T> Cursor<'a, T> { + /// Returns the cursor position index within the `LinkedList`. + /// + /// This returns `None` if the cursor is currently pointing to the + /// "ghost" non-element. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn index(&self) -> Option { + let _ = self.current?; + Some(self.index) + } + + /// Moves the cursor to the next element of the `LinkedList`. + /// + /// If the cursor is pointing to the "ghost" non-element then this will move it to + /// the first element of the `LinkedList`. If it is pointing to the last + /// element of the `LinkedList` then this will move it to the "ghost" non-element. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn move_next(&mut self) { + match self.current.take() { + // We had no current element; the cursor was sitting at the start position + // Next element should be the head of the list + None => { + self.current = self.list.head; + self.index = 0; + } + // We had a previous element, so let's go to its next + Some(current) => unsafe { + self.current = current.as_ref().next; + self.index += 1; + }, + } + } + + /// Moves the cursor to the previous element of the `LinkedList`. + /// + /// If the cursor is pointing to the "ghost" non-element then this will move it to + /// the last element of the `LinkedList`. If it is pointing to the first + /// element of the `LinkedList` then this will move it to the "ghost" non-element. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn move_prev(&mut self) { + match self.current.take() { + // No current. We're at the start of the list. Yield None and jump to the end. + None => { + self.current = self.list.tail; + self.index = self.list.len().checked_sub(1).unwrap_or(0); + } + // Have a prev. Yield it and go to the previous element. + Some(current) => unsafe { + self.current = current.as_ref().prev; + self.index = self.index.checked_sub(1).unwrap_or_else(|| self.list.len()); + }, + } + } + + /// Returns a reference to the element that the cursor is currently + /// pointing to. + /// + /// This returns `None` if the cursor is currently pointing to the + /// "ghost" non-element. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn current(&self) -> Option<&'a T> { + unsafe { self.current.map(|current| &(*current.as_ptr()).element) } + } + + /// Returns a reference to the next element. + /// + /// If the cursor is pointing to the "ghost" non-element then this returns + /// the first element of the `LinkedList`. If it is pointing to the last + /// element of the `LinkedList` then this returns `None`. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn peek_next(&self) -> Option<&'a T> { + unsafe { + let next = match self.current { + None => self.list.head, + Some(current) => current.as_ref().next, + }; + next.map(|next| &(*next.as_ptr()).element) + } + } + + /// Returns a reference to the previous element. + /// + /// If the cursor is pointing to the "ghost" non-element then this returns + /// the last element of the `LinkedList`. If it is pointing to the first + /// element of the `LinkedList` then this returns `None`. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn peek_prev(&self) -> Option<&'a T> { + unsafe { + let prev = match self.current { + None => self.list.tail, + Some(current) => current.as_ref().prev, + }; + prev.map(|prev| &(*prev.as_ptr()).element) + } + } +} + +impl<'a, T> CursorMut<'a, T> { + /// Returns the cursor position index within the `LinkedList`. + /// + /// This returns `None` if the cursor is currently pointing to the + /// "ghost" non-element. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn index(&self) -> Option { + let _ = self.current?; + Some(self.index) + } + + /// Moves the cursor to the next element of the `LinkedList`. + /// + /// If the cursor is pointing to the "ghost" non-element then this will move it to + /// the first element of the `LinkedList`. If it is pointing to the last + /// element of the `LinkedList` then this will move it to the "ghost" non-element. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn move_next(&mut self) { + match self.current.take() { + // We had no current element; the cursor was sitting at the start position + // Next element should be the head of the list + None => { + self.current = self.list.head; + self.index = 0; + } + // We had a previous element, so let's go to its next + Some(current) => unsafe { + self.current = current.as_ref().next; + self.index += 1; + }, + } + } + + /// Moves the cursor to the previous element of the `LinkedList`. + /// + /// If the cursor is pointing to the "ghost" non-element then this will move it to + /// the last element of the `LinkedList`. If it is pointing to the first + /// element of the `LinkedList` then this will move it to the "ghost" non-element. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn move_prev(&mut self) { + match self.current.take() { + // No current. We're at the start of the list. Yield None and jump to the end. + None => { + self.current = self.list.tail; + self.index = self.list.len().checked_sub(1).unwrap_or(0); + } + // Have a prev. Yield it and go to the previous element. + Some(current) => unsafe { + self.current = current.as_ref().prev; + self.index = self.index.checked_sub(1).unwrap_or_else(|| self.list.len()); + }, + } + } + + /// Returns a reference to the element that the cursor is currently + /// pointing to. + /// + /// This returns `None` if the cursor is currently pointing to the + /// "ghost" non-element. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn current(&mut self) -> Option<&mut T> { + unsafe { self.current.map(|current| &mut (*current.as_ptr()).element) } + } + + /// Returns a reference to the next element. + /// + /// If the cursor is pointing to the "ghost" non-element then this returns + /// the first element of the `LinkedList`. If it is pointing to the last + /// element of the `LinkedList` then this returns `None`. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn peek_next(&mut self) -> Option<&mut T> { + unsafe { + let next = match self.current { + None => self.list.head, + Some(current) => current.as_ref().next, + }; + next.map(|next| &mut (*next.as_ptr()).element) + } + } + + /// Returns a reference to the previous element. + /// + /// If the cursor is pointing to the "ghost" non-element then this returns + /// the last element of the `LinkedList`. If it is pointing to the first + /// element of the `LinkedList` then this returns `None`. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn peek_prev(&mut self) -> Option<&mut T> { + unsafe { + let prev = match self.current { + None => self.list.tail, + Some(current) => current.as_ref().prev, + }; + prev.map(|prev| &mut (*prev.as_ptr()).element) + } + } + + /// Returns a read-only cursor pointing to the current element. + /// + /// The lifetime of the returned `Cursor` is bound to that of the + /// `CursorMut`, which means it cannot outlive the `CursorMut` and that the + /// `CursorMut` is frozen for the lifetime of the `Cursor`. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn as_cursor(&self) -> Cursor<'_, T> { + Cursor { list: self.list, current: self.current, index: self.index } + } +} + +// Now the list editing operations + +impl<'a, T> CursorMut<'a, T> { + /// Inserts a new element into the `LinkedList` after the current one. + /// + /// If the cursor is pointing at the "ghost" non-element then the new element is + /// inserted at the front of the `LinkedList`. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn insert_after(&mut self, item: T) { + unsafe { + let spliced_node = Box::leak(Box::new(Node::new(item))).into(); + let node_next = match self.current { + None => self.list.head, + Some(node) => node.as_ref().next, + }; + self.list.splice_nodes(self.current, node_next, spliced_node, spliced_node, 1); + if self.current.is_none() { + // The "ghost" non-element's index has changed. + self.index = self.list.len; + } + } + } + + /// Inserts a new element into the `LinkedList` before the current one. + /// + /// If the cursor is pointing at the "ghost" non-element then the new element is + /// inserted at the end of the `LinkedList`. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn insert_before(&mut self, item: T) { + unsafe { + let spliced_node = Box::leak(Box::new(Node::new(item))).into(); + let node_prev = match self.current { + None => self.list.tail, + Some(node) => node.as_ref().prev, + }; + self.list.splice_nodes(node_prev, self.current, spliced_node, spliced_node, 1); + self.index += 1; + } + } + + /// Removes the current element from the `LinkedList`. + /// + /// The element that was removed is returned, and the cursor is + /// moved to point to the next element in the `LinkedList`. + /// + /// If the cursor is currently pointing to the "ghost" non-element then no element + /// is removed and `None` is returned. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn remove_current(&mut self) -> Option { + let unlinked_node = self.current?; + unsafe { + self.current = unlinked_node.as_ref().next; + self.list.unlink_node(unlinked_node); + let unlinked_node = Box::from_raw(unlinked_node.as_ptr()); + Some(unlinked_node.element) + } + } + + /// Removes the current element from the `LinkedList` without deallocating the list node. + /// + /// The node that was removed is returned as a new `LinkedList` containing only this node. + /// The cursor is moved to point to the next element in the current `LinkedList`. + /// + /// If the cursor is currently pointing to the "ghost" non-element then no element + /// is removed and `None` is returned. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn remove_current_as_list(&mut self) -> Option> { + let mut unlinked_node = self.current?; + unsafe { + self.current = unlinked_node.as_ref().next; + self.list.unlink_node(unlinked_node); + + unlinked_node.as_mut().prev = None; + unlinked_node.as_mut().next = None; + Some(LinkedList { + head: Some(unlinked_node), + tail: Some(unlinked_node), + len: 1, + marker: PhantomData, + }) + } + } + + /// Inserts the elements from the given `LinkedList` after the current one. + /// + /// If the cursor is pointing at the "ghost" non-element then the new elements are + /// inserted at the start of the `LinkedList`. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn splice_after(&mut self, list: LinkedList) { + unsafe { + let (splice_head, splice_tail, splice_len) = match list.detach_all_nodes() { + Some(parts) => parts, + _ => return, + }; + let node_next = match self.current { + None => self.list.head, + Some(node) => node.as_ref().next, + }; + self.list.splice_nodes(self.current, node_next, splice_head, splice_tail, splice_len); + if self.current.is_none() { + // The "ghost" non-element's index has changed. + self.index = self.list.len; + } + } + } + + /// Inserts the elements from the given `LinkedList` before the current one. + /// + /// If the cursor is pointing at the "ghost" non-element then the new elements are + /// inserted at the end of the `LinkedList`. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn splice_before(&mut self, list: LinkedList) { + unsafe { + let (splice_head, splice_tail, splice_len) = match list.detach_all_nodes() { + Some(parts) => parts, + _ => return, + }; + let node_prev = match self.current { + None => self.list.tail, + Some(node) => node.as_ref().prev, + }; + self.list.splice_nodes(node_prev, self.current, splice_head, splice_tail, splice_len); + self.index += splice_len; + } + } + + /// Splits the list into two after the current element. This will return a + /// new list consisting of everything after the cursor, with the original + /// list retaining everything before. + /// + /// If the cursor is pointing at the "ghost" non-element then the entire contents + /// of the `LinkedList` are moved. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn split_after(&mut self) -> LinkedList { + let split_off_idx = if self.index == self.list.len { 0 } else { self.index + 1 }; + if self.index == self.list.len { + // The "ghost" non-element's index has changed to 0. + self.index = 0; + } + unsafe { self.list.split_off_after_node(self.current, split_off_idx) } + } + + /// Splits the list into two before the current element. This will return a + /// new list consisting of everything before the cursor, with the original + /// list retaining everything after. + /// + /// If the cursor is pointing at the "ghost" non-element then the entire contents + /// of the `LinkedList` are moved. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn split_before(&mut self) -> LinkedList { + let split_off_idx = self.index; + self.index = 0; + unsafe { self.list.split_off_before_node(self.current, split_off_idx) } + } +} + +/// An iterator produced by calling `drain_filter` on LinkedList. +#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] +pub struct DrainFilter<'a, T: 'a, F: 'a> +where + F: FnMut(&mut T) -> bool, +{ + list: &'a mut LinkedList, + it: Option>>, + pred: F, + idx: usize, + old_len: usize, +} + +#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] +impl Iterator for DrainFilter<'_, T, F> +where + F: FnMut(&mut T) -> bool, +{ + type Item = T; + + fn next(&mut self) -> Option { + while let Some(mut node) = self.it { + unsafe { + self.it = node.as_ref().next; + self.idx += 1; + + if (self.pred)(&mut node.as_mut().element) { + // `unlink_node` is okay with aliasing `element` references. + self.list.unlink_node(node); + return Some(Box::from_raw(node.as_ptr()).element); + } + } + } + + None + } + + fn size_hint(&self) -> (usize, Option) { + (0, Some(self.old_len - self.idx)) + } +} + +#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] +impl Drop for DrainFilter<'_, T, F> +where + F: FnMut(&mut T) -> bool, +{ + fn drop(&mut self) { + struct DropGuard<'r, 'a, T, F>(&'r mut DrainFilter<'a, T, F>) + where + F: FnMut(&mut T) -> bool; + + impl<'r, 'a, T, F> Drop for DropGuard<'r, 'a, T, F> + where + F: FnMut(&mut T) -> bool, + { + fn drop(&mut self) { + self.0.for_each(drop); + } + } + + while let Some(item) = self.next() { + let guard = DropGuard(self); + drop(item); + mem::forget(guard); + } + } +} + +#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] +impl fmt::Debug for DrainFilter<'_, T, F> +where + F: FnMut(&mut T) -> bool, +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("DrainFilter").field(&self.list).finish() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Iterator for IntoIter { + type Item = T; + + #[inline] + fn next(&mut self) -> Option { + self.list.pop_front() + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + (self.list.len, Some(self.list.len)) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl DoubleEndedIterator for IntoIter { + #[inline] + fn next_back(&mut self) -> Option { + self.list.pop_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for IntoIter {} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for IntoIter {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl FromIterator for LinkedList { + fn from_iter>(iter: I) -> Self { + let mut list = Self::new(); + list.extend(iter); + list + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl IntoIterator for LinkedList { + type Item = T; + type IntoIter = IntoIter; + + /// Consumes the list into an iterator yielding elements by value. + #[inline] + fn into_iter(self) -> IntoIter { + IntoIter { list: self } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> IntoIterator for &'a LinkedList { + type Item = &'a T; + type IntoIter = Iter<'a, T>; + + fn into_iter(self) -> Iter<'a, T> { + self.iter() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> IntoIterator for &'a mut LinkedList { + type Item = &'a mut T; + type IntoIter = IterMut<'a, T>; + + fn into_iter(self) -> IterMut<'a, T> { + self.iter_mut() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Extend for LinkedList { + fn extend>(&mut self, iter: I) { + >::spec_extend(self, iter); + } + + #[inline] + fn extend_one(&mut self, elem: T) { + self.push_back(elem); + } +} + +impl SpecExtend for LinkedList { + default fn spec_extend(&mut self, iter: I) { + iter.into_iter().for_each(move |elt| self.push_back(elt)); + } +} + +impl SpecExtend> for LinkedList { + fn spec_extend(&mut self, ref mut other: LinkedList) { + self.append(other); + } +} + +#[stable(feature = "extend_ref", since = "1.2.0")] +impl<'a, T: 'a + Copy> Extend<&'a T> for LinkedList { + fn extend>(&mut self, iter: I) { + self.extend(iter.into_iter().cloned()); + } + + #[inline] + fn extend_one(&mut self, &elem: &'a T) { + self.push_back(elem); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialEq for LinkedList { + fn eq(&self, other: &Self) -> bool { + self.len() == other.len() && self.iter().eq(other) + } + + fn ne(&self, other: &Self) -> bool { + self.len() != other.len() || self.iter().ne(other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Eq for LinkedList {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialOrd for LinkedList { + fn partial_cmp(&self, other: &Self) -> Option { + self.iter().partial_cmp(other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Ord for LinkedList { + #[inline] + fn cmp(&self, other: &Self) -> Ordering { + self.iter().cmp(other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for LinkedList { + fn clone(&self) -> Self { + self.iter().cloned().collect() + } + + fn clone_from(&mut self, other: &Self) { + let mut iter_other = other.iter(); + if self.len() > other.len() { + self.split_off(other.len()); + } + for (elem, elem_other) in self.iter_mut().zip(&mut iter_other) { + elem.clone_from(elem_other); + } + if !iter_other.is_empty() { + self.extend(iter_other.cloned()); + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Debug for LinkedList { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self).finish() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Hash for LinkedList { + fn hash(&self, state: &mut H) { + self.len().hash(state); + for elt in self { + elt.hash(state); + } + } +} + +// Ensure that `LinkedList` and its read-only iterators are covariant in their type parameters. +#[allow(dead_code)] +fn assert_covariance() { + fn a<'a>(x: LinkedList<&'static str>) -> LinkedList<&'a str> { + x + } + fn b<'i, 'a>(x: Iter<'i, &'static str>) -> Iter<'i, &'a str> { + x + } + fn c<'a>(x: IntoIter<&'static str>) -> IntoIter<&'a str> { + x + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Send for LinkedList {} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Sync for LinkedList {} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Send for Iter<'_, T> {} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Sync for Iter<'_, T> {} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Send for IterMut<'_, T> {} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Sync for IterMut<'_, T> {} + +#[unstable(feature = "linked_list_cursors", issue = "58533")] +unsafe impl Send for Cursor<'_, T> {} + +#[unstable(feature = "linked_list_cursors", issue = "58533")] +unsafe impl Sync for Cursor<'_, T> {} + +#[unstable(feature = "linked_list_cursors", issue = "58533")] +unsafe impl Send for CursorMut<'_, T> {} + +#[unstable(feature = "linked_list_cursors", issue = "58533")] +unsafe impl Sync for CursorMut<'_, T> {} diff --git a/libgrust/rustc-lib/alloc/src/collections/linked_list/tests.rs b/libgrust/rustc-lib/alloc/src/collections/linked_list/tests.rs new file mode 100644 index 000000000000..ad643a7bdf19 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/linked_list/tests.rs @@ -0,0 +1,430 @@ +use super::*; + +use std::thread; +use std::vec::Vec; + +use rand::{thread_rng, RngCore}; + +fn list_from(v: &[T]) -> LinkedList { + v.iter().cloned().collect() +} + +pub fn check_links(list: &LinkedList) { + unsafe { + let mut len = 0; + let mut last_ptr: Option<&Node> = None; + let mut node_ptr: &Node; + match list.head { + None => { + // tail node should also be None. + assert!(list.tail.is_none()); + assert_eq!(0, list.len); + return; + } + Some(node) => node_ptr = &*node.as_ptr(), + } + loop { + match (last_ptr, node_ptr.prev) { + (None, None) => {} + (None, _) => panic!("prev link for head"), + (Some(p), Some(pptr)) => { + assert_eq!(p as *const Node, pptr.as_ptr() as *const Node); + } + _ => panic!("prev link is none, not good"), + } + match node_ptr.next { + Some(next) => { + last_ptr = Some(node_ptr); + node_ptr = &*next.as_ptr(); + len += 1; + } + None => { + len += 1; + break; + } + } + } + + // verify that the tail node points to the last node. + let tail = list.tail.as_ref().expect("some tail node").as_ref(); + assert_eq!(tail as *const Node, node_ptr as *const Node); + // check that len matches interior links. + assert_eq!(len, list.len); + } +} + +#[test] +fn test_append() { + // Empty to empty + { + let mut m = LinkedList::::new(); + let mut n = LinkedList::new(); + m.append(&mut n); + check_links(&m); + assert_eq!(m.len(), 0); + assert_eq!(n.len(), 0); + } + // Non-empty to empty + { + let mut m = LinkedList::new(); + let mut n = LinkedList::new(); + n.push_back(2); + m.append(&mut n); + check_links(&m); + assert_eq!(m.len(), 1); + assert_eq!(m.pop_back(), Some(2)); + assert_eq!(n.len(), 0); + check_links(&m); + } + // Empty to non-empty + { + let mut m = LinkedList::new(); + let mut n = LinkedList::new(); + m.push_back(2); + m.append(&mut n); + check_links(&m); + assert_eq!(m.len(), 1); + assert_eq!(m.pop_back(), Some(2)); + check_links(&m); + } + + // Non-empty to non-empty + let v = vec![1, 2, 3, 4, 5]; + let u = vec![9, 8, 1, 2, 3, 4, 5]; + let mut m = list_from(&v); + let mut n = list_from(&u); + m.append(&mut n); + check_links(&m); + let mut sum = v; + sum.extend_from_slice(&u); + assert_eq!(sum.len(), m.len()); + for elt in sum { + assert_eq!(m.pop_front(), Some(elt)) + } + assert_eq!(n.len(), 0); + // Let's make sure it's working properly, since we + // did some direct changes to private members. + n.push_back(3); + assert_eq!(n.len(), 1); + assert_eq!(n.pop_front(), Some(3)); + check_links(&n); +} + +#[test] +fn test_clone_from() { + // Short cloned from long + { + let v = vec![1, 2, 3, 4, 5]; + let u = vec![8, 7, 6, 2, 3, 4, 5]; + let mut m = list_from(&v); + let n = list_from(&u); + m.clone_from(&n); + check_links(&m); + assert_eq!(m, n); + for elt in u { + assert_eq!(m.pop_front(), Some(elt)) + } + } + // Long cloned from short + { + let v = vec![1, 2, 3, 4, 5]; + let u = vec![6, 7, 8]; + let mut m = list_from(&v); + let n = list_from(&u); + m.clone_from(&n); + check_links(&m); + assert_eq!(m, n); + for elt in u { + assert_eq!(m.pop_front(), Some(elt)) + } + } + // Two equal length lists + { + let v = vec![1, 2, 3, 4, 5]; + let u = vec![9, 8, 1, 2, 3]; + let mut m = list_from(&v); + let n = list_from(&u); + m.clone_from(&n); + check_links(&m); + assert_eq!(m, n); + for elt in u { + assert_eq!(m.pop_front(), Some(elt)) + } + } +} + +#[test] +#[cfg_attr(target_os = "emscripten", ignore)] +fn test_send() { + let n = list_from(&[1, 2, 3]); + thread::spawn(move || { + check_links(&n); + let a: &[_] = &[&1, &2, &3]; + assert_eq!(a, &*n.iter().collect::>()); + }) + .join() + .ok() + .unwrap(); +} + +#[test] +fn test_fuzz() { + for _ in 0..25 { + fuzz_test(3); + fuzz_test(16); + #[cfg(not(miri))] // Miri is too slow + fuzz_test(189); + } +} + +#[test] +fn test_26021() { + // There was a bug in split_off that failed to null out the RHS's head's prev ptr. + // This caused the RHS's dtor to walk up into the LHS at drop and delete all of + // its nodes. + // + // https://github.com/rust-lang/rust/issues/26021 + let mut v1 = LinkedList::new(); + v1.push_front(1); + v1.push_front(1); + v1.push_front(1); + v1.push_front(1); + let _ = v1.split_off(3); // Dropping this now should not cause laundry consumption + assert_eq!(v1.len(), 3); + + assert_eq!(v1.iter().len(), 3); + assert_eq!(v1.iter().collect::>().len(), 3); +} + +#[test] +fn test_split_off() { + let mut v1 = LinkedList::new(); + v1.push_front(1); + v1.push_front(1); + v1.push_front(1); + v1.push_front(1); + + // test all splits + for ix in 0..1 + v1.len() { + let mut a = v1.clone(); + let b = a.split_off(ix); + check_links(&a); + check_links(&b); + a.extend(b); + assert_eq!(v1, a); + } +} + +fn fuzz_test(sz: i32) { + let mut m: LinkedList<_> = LinkedList::new(); + let mut v = vec![]; + for i in 0..sz { + check_links(&m); + let r: u8 = thread_rng().next_u32() as u8; + match r % 6 { + 0 => { + m.pop_back(); + v.pop(); + } + 1 => { + if !v.is_empty() { + m.pop_front(); + v.remove(0); + } + } + 2 | 4 => { + m.push_front(-i); + v.insert(0, -i); + } + 3 | 5 | _ => { + m.push_back(i); + v.push(i); + } + } + } + + check_links(&m); + + let mut i = 0; + for (a, &b) in m.into_iter().zip(&v) { + i += 1; + assert_eq!(a, b); + } + assert_eq!(i, v.len()); +} + +#[test] +fn drain_filter_test() { + let mut m: LinkedList = LinkedList::new(); + m.extend(&[1, 2, 3, 4, 5, 6]); + let deleted = m.drain_filter(|v| *v < 4).collect::>(); + + check_links(&m); + + assert_eq!(deleted, &[1, 2, 3]); + assert_eq!(m.into_iter().collect::>(), &[4, 5, 6]); +} + +#[test] +fn drain_to_empty_test() { + let mut m: LinkedList = LinkedList::new(); + m.extend(&[1, 2, 3, 4, 5, 6]); + let deleted = m.drain_filter(|_| true).collect::>(); + + check_links(&m); + + assert_eq!(deleted, &[1, 2, 3, 4, 5, 6]); + assert_eq!(m.into_iter().collect::>(), &[]); +} + +#[test] +fn test_cursor_move_peek() { + let mut m: LinkedList = LinkedList::new(); + m.extend(&[1, 2, 3, 4, 5, 6]); + let mut cursor = m.cursor_front(); + assert_eq!(cursor.current(), Some(&1)); + assert_eq!(cursor.peek_next(), Some(&2)); + assert_eq!(cursor.peek_prev(), None); + assert_eq!(cursor.index(), Some(0)); + cursor.move_prev(); + assert_eq!(cursor.current(), None); + assert_eq!(cursor.peek_next(), Some(&1)); + assert_eq!(cursor.peek_prev(), Some(&6)); + assert_eq!(cursor.index(), None); + cursor.move_next(); + cursor.move_next(); + assert_eq!(cursor.current(), Some(&2)); + assert_eq!(cursor.peek_next(), Some(&3)); + assert_eq!(cursor.peek_prev(), Some(&1)); + assert_eq!(cursor.index(), Some(1)); + + let mut cursor = m.cursor_back(); + assert_eq!(cursor.current(), Some(&6)); + assert_eq!(cursor.peek_next(), None); + assert_eq!(cursor.peek_prev(), Some(&5)); + assert_eq!(cursor.index(), Some(5)); + cursor.move_next(); + assert_eq!(cursor.current(), None); + assert_eq!(cursor.peek_next(), Some(&1)); + assert_eq!(cursor.peek_prev(), Some(&6)); + assert_eq!(cursor.index(), None); + cursor.move_prev(); + cursor.move_prev(); + assert_eq!(cursor.current(), Some(&5)); + assert_eq!(cursor.peek_next(), Some(&6)); + assert_eq!(cursor.peek_prev(), Some(&4)); + assert_eq!(cursor.index(), Some(4)); + + let mut m: LinkedList = LinkedList::new(); + m.extend(&[1, 2, 3, 4, 5, 6]); + let mut cursor = m.cursor_front_mut(); + assert_eq!(cursor.current(), Some(&mut 1)); + assert_eq!(cursor.peek_next(), Some(&mut 2)); + assert_eq!(cursor.peek_prev(), None); + assert_eq!(cursor.index(), Some(0)); + cursor.move_prev(); + assert_eq!(cursor.current(), None); + assert_eq!(cursor.peek_next(), Some(&mut 1)); + assert_eq!(cursor.peek_prev(), Some(&mut 6)); + assert_eq!(cursor.index(), None); + cursor.move_next(); + cursor.move_next(); + assert_eq!(cursor.current(), Some(&mut 2)); + assert_eq!(cursor.peek_next(), Some(&mut 3)); + assert_eq!(cursor.peek_prev(), Some(&mut 1)); + assert_eq!(cursor.index(), Some(1)); + let mut cursor2 = cursor.as_cursor(); + assert_eq!(cursor2.current(), Some(&2)); + assert_eq!(cursor2.index(), Some(1)); + cursor2.move_next(); + assert_eq!(cursor2.current(), Some(&3)); + assert_eq!(cursor2.index(), Some(2)); + assert_eq!(cursor.current(), Some(&mut 2)); + assert_eq!(cursor.index(), Some(1)); + + let mut m: LinkedList = LinkedList::new(); + m.extend(&[1, 2, 3, 4, 5, 6]); + let mut cursor = m.cursor_back_mut(); + assert_eq!(cursor.current(), Some(&mut 6)); + assert_eq!(cursor.peek_next(), None); + assert_eq!(cursor.peek_prev(), Some(&mut 5)); + assert_eq!(cursor.index(), Some(5)); + cursor.move_next(); + assert_eq!(cursor.current(), None); + assert_eq!(cursor.peek_next(), Some(&mut 1)); + assert_eq!(cursor.peek_prev(), Some(&mut 6)); + assert_eq!(cursor.index(), None); + cursor.move_prev(); + cursor.move_prev(); + assert_eq!(cursor.current(), Some(&mut 5)); + assert_eq!(cursor.peek_next(), Some(&mut 6)); + assert_eq!(cursor.peek_prev(), Some(&mut 4)); + assert_eq!(cursor.index(), Some(4)); + let mut cursor2 = cursor.as_cursor(); + assert_eq!(cursor2.current(), Some(&5)); + assert_eq!(cursor2.index(), Some(4)); + cursor2.move_prev(); + assert_eq!(cursor2.current(), Some(&4)); + assert_eq!(cursor2.index(), Some(3)); + assert_eq!(cursor.current(), Some(&mut 5)); + assert_eq!(cursor.index(), Some(4)); +} + +#[test] +fn test_cursor_mut_insert() { + let mut m: LinkedList = LinkedList::new(); + m.extend(&[1, 2, 3, 4, 5, 6]); + let mut cursor = m.cursor_front_mut(); + cursor.insert_before(7); + cursor.insert_after(8); + check_links(&m); + assert_eq!(m.iter().cloned().collect::>(), &[7, 1, 8, 2, 3, 4, 5, 6]); + let mut cursor = m.cursor_front_mut(); + cursor.move_prev(); + cursor.insert_before(9); + cursor.insert_after(10); + check_links(&m); + assert_eq!(m.iter().cloned().collect::>(), &[10, 7, 1, 8, 2, 3, 4, 5, 6, 9]); + let mut cursor = m.cursor_front_mut(); + cursor.move_prev(); + assert_eq!(cursor.remove_current(), None); + cursor.move_next(); + cursor.move_next(); + assert_eq!(cursor.remove_current(), Some(7)); + cursor.move_prev(); + cursor.move_prev(); + cursor.move_prev(); + assert_eq!(cursor.remove_current(), Some(9)); + cursor.move_next(); + assert_eq!(cursor.remove_current(), Some(10)); + check_links(&m); + assert_eq!(m.iter().cloned().collect::>(), &[1, 8, 2, 3, 4, 5, 6]); + let mut cursor = m.cursor_front_mut(); + let mut p: LinkedList = LinkedList::new(); + p.extend(&[100, 101, 102, 103]); + let mut q: LinkedList = LinkedList::new(); + q.extend(&[200, 201, 202, 203]); + cursor.splice_after(p); + cursor.splice_before(q); + check_links(&m); + assert_eq!( + m.iter().cloned().collect::>(), + &[200, 201, 202, 203, 1, 100, 101, 102, 103, 8, 2, 3, 4, 5, 6] + ); + let mut cursor = m.cursor_front_mut(); + cursor.move_prev(); + let tmp = cursor.split_before(); + assert_eq!(m.into_iter().collect::>(), &[]); + m = tmp; + let mut cursor = m.cursor_front_mut(); + cursor.move_next(); + cursor.move_next(); + cursor.move_next(); + cursor.move_next(); + cursor.move_next(); + cursor.move_next(); + let tmp = cursor.split_after(); + assert_eq!(tmp.into_iter().collect::>(), &[102, 103, 8, 2, 3, 4, 5, 6]); + check_links(&m); + assert_eq!(m.iter().cloned().collect::>(), &[200, 201, 202, 203, 1, 100, 101]); +} diff --git a/libgrust/rustc-lib/alloc/src/collections/mod.rs b/libgrust/rustc-lib/alloc/src/collections/mod.rs new file mode 100644 index 000000000000..6b21e54f66aa --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/mod.rs @@ -0,0 +1,103 @@ +//! Collection types. + +#![stable(feature = "rust1", since = "1.0.0")] + +pub mod binary_heap; +mod btree; +pub mod linked_list; +pub mod vec_deque; + +#[stable(feature = "rust1", since = "1.0.0")] +pub mod btree_map { + //! A map based on a B-Tree. + #[stable(feature = "rust1", since = "1.0.0")] + pub use super::btree::map::*; +} + +#[stable(feature = "rust1", since = "1.0.0")] +pub mod btree_set { + //! A set based on a B-Tree. + #[stable(feature = "rust1", since = "1.0.0")] + pub use super::btree::set::*; +} + +#[stable(feature = "rust1", since = "1.0.0")] +#[doc(no_inline)] +pub use binary_heap::BinaryHeap; + +#[stable(feature = "rust1", since = "1.0.0")] +#[doc(no_inline)] +pub use btree_map::BTreeMap; + +#[stable(feature = "rust1", since = "1.0.0")] +#[doc(no_inline)] +pub use btree_set::BTreeSet; + +#[stable(feature = "rust1", since = "1.0.0")] +#[doc(no_inline)] +pub use linked_list::LinkedList; + +#[stable(feature = "rust1", since = "1.0.0")] +#[doc(no_inline)] +pub use vec_deque::VecDeque; + +use crate::alloc::{Layout, LayoutErr}; +use core::fmt::Display; + +/// The error type for `try_reserve` methods. +#[derive(Clone, PartialEq, Eq, Debug)] +#[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] +pub enum TryReserveError { + /// Error due to the computed capacity exceeding the collection's maximum + /// (usually `isize::MAX` bytes). + CapacityOverflow, + + /// The memory allocator returned an error + AllocError { + /// The layout of allocation request that failed + layout: Layout, + + #[doc(hidden)] + #[unstable( + feature = "container_error_extra", + issue = "none", + reason = "\ + Enable exposing the allocator’s custom error value \ + if an associated type is added in the future: \ + https://github.com/rust-lang/wg-allocators/issues/23" + )] + non_exhaustive: (), + }, +} + +#[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] +impl From for TryReserveError { + #[inline] + fn from(_: LayoutErr) -> Self { + TryReserveError::CapacityOverflow + } +} + +#[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] +impl Display for TryReserveError { + fn fmt( + &self, + fmt: &mut core::fmt::Formatter<'_>, + ) -> core::result::Result<(), core::fmt::Error> { + fmt.write_str("memory allocation failed")?; + let reason = match &self { + TryReserveError::CapacityOverflow => { + " because the computed capacity exceeded the collection's maximum" + } + TryReserveError::AllocError { .. } => " because the memory allocator returned a error", + }; + fmt.write_str(reason) + } +} + +/// An intermediate trait for specialization of `Extend`. +#[doc(hidden)] +trait SpecExtend { + /// Extends `self` with the contents of the given iterator. + fn spec_extend(&mut self, iter: I); +} diff --git a/libgrust/rustc-lib/alloc/src/collections/vec_deque.rs b/libgrust/rustc-lib/alloc/src/collections/vec_deque.rs new file mode 100644 index 000000000000..c0a3ca6a582b --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/vec_deque.rs @@ -0,0 +1,3299 @@ +//! A double-ended queue implemented with a growable ring buffer. +//! +//! This queue has *O*(1) amortized inserts and removals from both ends of the +//! container. It also has *O*(1) indexing like a vector. The contained elements +//! are not required to be copyable, and the queue will be sendable if the +//! contained type is sendable. + +#![stable(feature = "rust1", since = "1.0.0")] + +// ignore-tidy-filelength + +use core::array; +use core::cmp::{self, Ordering}; +use core::fmt; +use core::hash::{Hash, Hasher}; +use core::iter::{repeat_with, FromIterator, FusedIterator}; +use core::marker::PhantomData; +use core::mem::{self, replace, ManuallyDrop}; +use core::ops::{Index, IndexMut, Range, RangeBounds, Try}; +use core::ptr::{self, NonNull}; +use core::slice; + +use crate::collections::TryReserveError; +use crate::raw_vec::RawVec; +use crate::vec::Vec; + +#[stable(feature = "drain", since = "1.6.0")] +pub use self::drain::Drain; + +mod drain; + +#[cfg(test)] +mod tests; + +const INITIAL_CAPACITY: usize = 7; // 2^3 - 1 +const MINIMUM_CAPACITY: usize = 1; // 2 - 1 + +const MAXIMUM_ZST_CAPACITY: usize = 1 << (core::mem::size_of::() * 8 - 1); // Largest possible power of two + +/// A double-ended queue implemented with a growable ring buffer. +/// +/// The "default" usage of this type as a queue is to use [`push_back`] to add to +/// the queue, and [`pop_front`] to remove from the queue. [`extend`] and [`append`] +/// push onto the back in this manner, and iterating over `VecDeque` goes front +/// to back. +/// +/// Since `VecDeque` is a ring buffer, its elements are not necessarily contiguous +/// in memory. If you want to access the elements as a single slice, such as for +/// efficient sorting, you can use [`make_contiguous`]. It rotates the `VecDeque` +/// so that its elements do not wrap, and returns a mutable slice to the +/// now-contiguous element sequence. +/// +/// [`push_back`]: VecDeque::push_back +/// [`pop_front`]: VecDeque::pop_front +/// [`extend`]: VecDeque::extend +/// [`append`]: VecDeque::append +/// [`make_contiguous`]: VecDeque::make_contiguous +#[cfg_attr(not(test), rustc_diagnostic_item = "vecdeque_type")] +#[stable(feature = "rust1", since = "1.0.0")] +pub struct VecDeque { + // tail and head are pointers into the buffer. Tail always points + // to the first element that could be read, Head always points + // to where data should be written. + // If tail == head the buffer is empty. The length of the ringbuffer + // is defined as the distance between the two. + tail: usize, + head: usize, + buf: RawVec, +} + +/// PairSlices pairs up equal length slice parts of two deques +/// +/// For example, given deques "A" and "B" with the following division into slices: +/// +/// A: [0 1 2] [3 4 5] +/// B: [a b] [c d e] +/// +/// It produces the following sequence of matching slices: +/// +/// ([0 1], [a b]) +/// (\[2\], \[c\]) +/// ([3 4], [d e]) +/// +/// and the uneven remainder of either A or B is skipped. +struct PairSlices<'a, 'b, T> { + a0: &'a mut [T], + a1: &'a mut [T], + b0: &'b [T], + b1: &'b [T], +} + +impl<'a, 'b, T> PairSlices<'a, 'b, T> { + fn from(to: &'a mut VecDeque, from: &'b VecDeque) -> Self { + let (a0, a1) = to.as_mut_slices(); + let (b0, b1) = from.as_slices(); + PairSlices { a0, a1, b0, b1 } + } + + fn has_remainder(&self) -> bool { + !self.b0.is_empty() + } + + fn remainder(self) -> impl Iterator { + array::IntoIter::new([self.b0, self.b1]) + } +} + +impl<'a, 'b, T> Iterator for PairSlices<'a, 'b, T> { + type Item = (&'a mut [T], &'b [T]); + fn next(&mut self) -> Option { + // Get next part length + let part = cmp::min(self.a0.len(), self.b0.len()); + if part == 0 { + return None; + } + let (p0, p1) = replace(&mut self.a0, &mut []).split_at_mut(part); + let (q0, q1) = self.b0.split_at(part); + + // Move a1 into a0, if it's empty (and b1, b0 the same way). + self.a0 = p1; + self.b0 = q1; + if self.a0.is_empty() { + self.a0 = replace(&mut self.a1, &mut []); + } + if self.b0.is_empty() { + self.b0 = replace(&mut self.b1, &[]); + } + Some((p0, q0)) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for VecDeque { + fn clone(&self) -> VecDeque { + self.iter().cloned().collect() + } + + fn clone_from(&mut self, other: &Self) { + self.truncate(other.len()); + + let mut iter = PairSlices::from(self, other); + while let Some((dst, src)) = iter.next() { + dst.clone_from_slice(&src); + } + + if iter.has_remainder() { + for remainder in iter.remainder() { + self.extend(remainder.iter().cloned()); + } + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl<#[may_dangle] T> Drop for VecDeque { + fn drop(&mut self) { + /// Runs the destructor for all items in the slice when it gets dropped (normally or + /// during unwinding). + struct Dropper<'a, T>(&'a mut [T]); + + impl<'a, T> Drop for Dropper<'a, T> { + fn drop(&mut self) { + unsafe { + ptr::drop_in_place(self.0); + } + } + } + + let (front, back) = self.as_mut_slices(); + unsafe { + let _back_dropper = Dropper(back); + // use drop for [T] + ptr::drop_in_place(front); + } + // RawVec handles deallocation + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for VecDeque { + /// Creates an empty `VecDeque`. + #[inline] + fn default() -> VecDeque { + VecDeque::new() + } +} + +impl VecDeque { + /// Marginally more convenient + #[inline] + fn ptr(&self) -> *mut T { + self.buf.ptr() + } + + /// Marginally more convenient + #[inline] + fn cap(&self) -> usize { + if mem::size_of::() == 0 { + // For zero sized types, we are always at maximum capacity + MAXIMUM_ZST_CAPACITY + } else { + self.buf.capacity() + } + } + + /// Turn ptr into a slice + #[inline] + unsafe fn buffer_as_slice(&self) -> &[T] { + unsafe { slice::from_raw_parts(self.ptr(), self.cap()) } + } + + /// Turn ptr into a mut slice + #[inline] + unsafe fn buffer_as_mut_slice(&mut self) -> &mut [T] { + unsafe { slice::from_raw_parts_mut(self.ptr(), self.cap()) } + } + + /// Moves an element out of the buffer + #[inline] + unsafe fn buffer_read(&mut self, off: usize) -> T { + unsafe { ptr::read(self.ptr().add(off)) } + } + + /// Writes an element into the buffer, moving it. + #[inline] + unsafe fn buffer_write(&mut self, off: usize, value: T) { + unsafe { + ptr::write(self.ptr().add(off), value); + } + } + + /// Returns `true` if the buffer is at full capacity. + #[inline] + fn is_full(&self) -> bool { + self.cap() - self.len() == 1 + } + + /// Returns the index in the underlying buffer for a given logical element + /// index. + #[inline] + fn wrap_index(&self, idx: usize) -> usize { + wrap_index(idx, self.cap()) + } + + /// Returns the index in the underlying buffer for a given logical element + /// index + addend. + #[inline] + fn wrap_add(&self, idx: usize, addend: usize) -> usize { + wrap_index(idx.wrapping_add(addend), self.cap()) + } + + /// Returns the index in the underlying buffer for a given logical element + /// index - subtrahend. + #[inline] + fn wrap_sub(&self, idx: usize, subtrahend: usize) -> usize { + wrap_index(idx.wrapping_sub(subtrahend), self.cap()) + } + + /// Copies a contiguous block of memory len long from src to dst + #[inline] + unsafe fn copy(&self, dst: usize, src: usize, len: usize) { + debug_assert!( + dst + len <= self.cap(), + "cpy dst={} src={} len={} cap={}", + dst, + src, + len, + self.cap() + ); + debug_assert!( + src + len <= self.cap(), + "cpy dst={} src={} len={} cap={}", + dst, + src, + len, + self.cap() + ); + unsafe { + ptr::copy(self.ptr().add(src), self.ptr().add(dst), len); + } + } + + /// Copies a contiguous block of memory len long from src to dst + #[inline] + unsafe fn copy_nonoverlapping(&self, dst: usize, src: usize, len: usize) { + debug_assert!( + dst + len <= self.cap(), + "cno dst={} src={} len={} cap={}", + dst, + src, + len, + self.cap() + ); + debug_assert!( + src + len <= self.cap(), + "cno dst={} src={} len={} cap={}", + dst, + src, + len, + self.cap() + ); + unsafe { + ptr::copy_nonoverlapping(self.ptr().add(src), self.ptr().add(dst), len); + } + } + + /// Copies a potentially wrapping block of memory len long from src to dest. + /// (abs(dst - src) + len) must be no larger than cap() (There must be at + /// most one continuous overlapping region between src and dest). + unsafe fn wrap_copy(&self, dst: usize, src: usize, len: usize) { + #[allow(dead_code)] + fn diff(a: usize, b: usize) -> usize { + if a <= b { b - a } else { a - b } + } + debug_assert!( + cmp::min(diff(dst, src), self.cap() - diff(dst, src)) + len <= self.cap(), + "wrc dst={} src={} len={} cap={}", + dst, + src, + len, + self.cap() + ); + + if src == dst || len == 0 { + return; + } + + let dst_after_src = self.wrap_sub(dst, src) < len; + + let src_pre_wrap_len = self.cap() - src; + let dst_pre_wrap_len = self.cap() - dst; + let src_wraps = src_pre_wrap_len < len; + let dst_wraps = dst_pre_wrap_len < len; + + match (dst_after_src, src_wraps, dst_wraps) { + (_, false, false) => { + // src doesn't wrap, dst doesn't wrap + // + // S . . . + // 1 [_ _ A A B B C C _] + // 2 [_ _ A A A A B B _] + // D . . . + // + unsafe { + self.copy(dst, src, len); + } + } + (false, false, true) => { + // dst before src, src doesn't wrap, dst wraps + // + // S . . . + // 1 [A A B B _ _ _ C C] + // 2 [A A B B _ _ _ A A] + // 3 [B B B B _ _ _ A A] + // . . D . + // + unsafe { + self.copy(dst, src, dst_pre_wrap_len); + self.copy(0, src + dst_pre_wrap_len, len - dst_pre_wrap_len); + } + } + (true, false, true) => { + // src before dst, src doesn't wrap, dst wraps + // + // S . . . + // 1 [C C _ _ _ A A B B] + // 2 [B B _ _ _ A A B B] + // 3 [B B _ _ _ A A A A] + // . . D . + // + unsafe { + self.copy(0, src + dst_pre_wrap_len, len - dst_pre_wrap_len); + self.copy(dst, src, dst_pre_wrap_len); + } + } + (false, true, false) => { + // dst before src, src wraps, dst doesn't wrap + // + // . . S . + // 1 [C C _ _ _ A A B B] + // 2 [C C _ _ _ B B B B] + // 3 [C C _ _ _ B B C C] + // D . . . + // + unsafe { + self.copy(dst, src, src_pre_wrap_len); + self.copy(dst + src_pre_wrap_len, 0, len - src_pre_wrap_len); + } + } + (true, true, false) => { + // src before dst, src wraps, dst doesn't wrap + // + // . . S . + // 1 [A A B B _ _ _ C C] + // 2 [A A A A _ _ _ C C] + // 3 [C C A A _ _ _ C C] + // D . . . + // + unsafe { + self.copy(dst + src_pre_wrap_len, 0, len - src_pre_wrap_len); + self.copy(dst, src, src_pre_wrap_len); + } + } + (false, true, true) => { + // dst before src, src wraps, dst wraps + // + // . . . S . + // 1 [A B C D _ E F G H] + // 2 [A B C D _ E G H H] + // 3 [A B C D _ E G H A] + // 4 [B C C D _ E G H A] + // . . D . . + // + debug_assert!(dst_pre_wrap_len > src_pre_wrap_len); + let delta = dst_pre_wrap_len - src_pre_wrap_len; + unsafe { + self.copy(dst, src, src_pre_wrap_len); + self.copy(dst + src_pre_wrap_len, 0, delta); + self.copy(0, delta, len - dst_pre_wrap_len); + } + } + (true, true, true) => { + // src before dst, src wraps, dst wraps + // + // . . S . . + // 1 [A B C D _ E F G H] + // 2 [A A B D _ E F G H] + // 3 [H A B D _ E F G H] + // 4 [H A B D _ E F F G] + // . . . D . + // + debug_assert!(src_pre_wrap_len > dst_pre_wrap_len); + let delta = src_pre_wrap_len - dst_pre_wrap_len; + unsafe { + self.copy(delta, 0, len - src_pre_wrap_len); + self.copy(0, self.cap() - delta, delta); + self.copy(dst, src, dst_pre_wrap_len); + } + } + } + } + + /// Frobs the head and tail sections around to handle the fact that we + /// just reallocated. Unsafe because it trusts old_capacity. + #[inline] + unsafe fn handle_capacity_increase(&mut self, old_capacity: usize) { + let new_capacity = self.cap(); + + // Move the shortest contiguous section of the ring buffer + // T H + // [o o o o o o o . ] + // T H + // A [o o o o o o o . . . . . . . . . ] + // H T + // [o o . o o o o o ] + // T H + // B [. . . o o o o o o o . . . . . . ] + // H T + // [o o o o o . o o ] + // H T + // C [o o o o o . . . . . . . . . o o ] + + if self.tail <= self.head { + // A + // Nop + } else if self.head < old_capacity - self.tail { + // B + unsafe { + self.copy_nonoverlapping(old_capacity, 0, self.head); + } + self.head += old_capacity; + debug_assert!(self.head > self.tail); + } else { + // C + let new_tail = new_capacity - (old_capacity - self.tail); + unsafe { + self.copy_nonoverlapping(new_tail, self.tail, old_capacity - self.tail); + } + self.tail = new_tail; + debug_assert!(self.head < self.tail); + } + debug_assert!(self.head < self.cap()); + debug_assert!(self.tail < self.cap()); + debug_assert!(self.cap().count_ones() == 1); + } +} + +impl VecDeque { + /// Creates an empty `VecDeque`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let vector: VecDeque = VecDeque::new(); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn new() -> VecDeque { + VecDeque::with_capacity(INITIAL_CAPACITY) + } + + /// Creates an empty `VecDeque` with space for at least `capacity` elements. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let vector: VecDeque = VecDeque::with_capacity(10); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn with_capacity(capacity: usize) -> VecDeque { + // +1 since the ringbuffer always leaves one space empty + let cap = cmp::max(capacity + 1, MINIMUM_CAPACITY + 1).next_power_of_two(); + assert!(cap > capacity, "capacity overflow"); + + VecDeque { tail: 0, head: 0, buf: RawVec::with_capacity(cap) } + } + + /// Provides a reference to the element at the given index. + /// + /// Element at index 0 is the front of the queue. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(3); + /// buf.push_back(4); + /// buf.push_back(5); + /// assert_eq!(buf.get(1), Some(&4)); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn get(&self, index: usize) -> Option<&T> { + if index < self.len() { + let idx = self.wrap_add(self.tail, index); + unsafe { Some(&*self.ptr().add(idx)) } + } else { + None + } + } + + /// Provides a mutable reference to the element at the given index. + /// + /// Element at index 0 is the front of the queue. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(3); + /// buf.push_back(4); + /// buf.push_back(5); + /// if let Some(elem) = buf.get_mut(1) { + /// *elem = 7; + /// } + /// + /// assert_eq!(buf[1], 7); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn get_mut(&mut self, index: usize) -> Option<&mut T> { + if index < self.len() { + let idx = self.wrap_add(self.tail, index); + unsafe { Some(&mut *self.ptr().add(idx)) } + } else { + None + } + } + + /// Swaps elements at indices `i` and `j`. + /// + /// `i` and `j` may be equal. + /// + /// Element at index 0 is the front of the queue. + /// + /// # Panics + /// + /// Panics if either index is out of bounds. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(3); + /// buf.push_back(4); + /// buf.push_back(5); + /// assert_eq!(buf, [3, 4, 5]); + /// buf.swap(0, 2); + /// assert_eq!(buf, [5, 4, 3]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn swap(&mut self, i: usize, j: usize) { + assert!(i < self.len()); + assert!(j < self.len()); + let ri = self.wrap_add(self.tail, i); + let rj = self.wrap_add(self.tail, j); + unsafe { ptr::swap(self.ptr().add(ri), self.ptr().add(rj)) } + } + + /// Returns the number of elements the `VecDeque` can hold without + /// reallocating. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let buf: VecDeque = VecDeque::with_capacity(10); + /// assert!(buf.capacity() >= 10); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn capacity(&self) -> usize { + self.cap() - 1 + } + + /// Reserves the minimum capacity for exactly `additional` more elements to be inserted in the + /// given `VecDeque`. Does nothing if the capacity is already sufficient. + /// + /// Note that the allocator may give the collection more space than it requests. Therefore + /// capacity can not be relied upon to be precisely minimal. Prefer [`reserve`] if future + /// insertions are expected. + /// + /// # Panics + /// + /// Panics if the new capacity overflows `usize`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf: VecDeque = vec![1].into_iter().collect(); + /// buf.reserve_exact(10); + /// assert!(buf.capacity() >= 11); + /// ``` + /// + /// [`reserve`]: VecDeque::reserve + #[stable(feature = "rust1", since = "1.0.0")] + pub fn reserve_exact(&mut self, additional: usize) { + self.reserve(additional); + } + + /// Reserves capacity for at least `additional` more elements to be inserted in the given + /// `VecDeque`. The collection may reserve more space to avoid frequent reallocations. + /// + /// # Panics + /// + /// Panics if the new capacity overflows `usize`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf: VecDeque = vec![1].into_iter().collect(); + /// buf.reserve(10); + /// assert!(buf.capacity() >= 11); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn reserve(&mut self, additional: usize) { + let old_cap = self.cap(); + let used_cap = self.len() + 1; + let new_cap = used_cap + .checked_add(additional) + .and_then(|needed_cap| needed_cap.checked_next_power_of_two()) + .expect("capacity overflow"); + + if new_cap > old_cap { + self.buf.reserve_exact(used_cap, new_cap - used_cap); + unsafe { + self.handle_capacity_increase(old_cap); + } + } + } + + /// Tries to reserve the minimum capacity for exactly `additional` more elements to + /// be inserted in the given `VecDeque`. After calling `try_reserve_exact`, + /// capacity will be greater than or equal to `self.len() + additional`. + /// Does nothing if the capacity is already sufficient. + /// + /// Note that the allocator may give the collection more space than it + /// requests. Therefore, capacity can not be relied upon to be precisely + /// minimal. Prefer `reserve` if future insertions are expected. + /// + /// # Errors + /// + /// If the capacity overflows `usize`, or the allocator reports a failure, then an error + /// is returned. + /// + /// # Examples + /// + /// ``` + /// #![feature(try_reserve)] + /// use std::collections::TryReserveError; + /// use std::collections::VecDeque; + /// + /// fn process_data(data: &[u32]) -> Result, TryReserveError> { + /// let mut output = VecDeque::new(); + /// + /// // Pre-reserve the memory, exiting if we can't + /// output.try_reserve_exact(data.len())?; + /// + /// // Now we know this can't OOM(Out-Of-Memory) in the middle of our complex work + /// output.extend(data.iter().map(|&val| { + /// val * 2 + 5 // very complicated + /// })); + /// + /// Ok(output) + /// } + /// # process_data(&[1, 2, 3]).expect("why is the test harness OOMing on 12 bytes?"); + /// ``` + #[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] + pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveError> { + self.try_reserve(additional) + } + + /// Tries to reserve capacity for at least `additional` more elements to be inserted + /// in the given `VecDeque`. The collection may reserve more space to avoid + /// frequent reallocations. After calling `try_reserve`, capacity will be + /// greater than or equal to `self.len() + additional`. Does nothing if + /// capacity is already sufficient. + /// + /// # Errors + /// + /// If the capacity overflows `usize`, or the allocator reports a failure, then an error + /// is returned. + /// + /// # Examples + /// + /// ``` + /// #![feature(try_reserve)] + /// use std::collections::TryReserveError; + /// use std::collections::VecDeque; + /// + /// fn process_data(data: &[u32]) -> Result, TryReserveError> { + /// let mut output = VecDeque::new(); + /// + /// // Pre-reserve the memory, exiting if we can't + /// output.try_reserve(data.len())?; + /// + /// // Now we know this can't OOM in the middle of our complex work + /// output.extend(data.iter().map(|&val| { + /// val * 2 + 5 // very complicated + /// })); + /// + /// Ok(output) + /// } + /// # process_data(&[1, 2, 3]).expect("why is the test harness OOMing on 12 bytes?"); + /// ``` + #[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] + pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> { + let old_cap = self.cap(); + let used_cap = self.len() + 1; + let new_cap = used_cap + .checked_add(additional) + .and_then(|needed_cap| needed_cap.checked_next_power_of_two()) + .ok_or(TryReserveError::CapacityOverflow)?; + + if new_cap > old_cap { + self.buf.try_reserve_exact(used_cap, new_cap - used_cap)?; + unsafe { + self.handle_capacity_increase(old_cap); + } + } + Ok(()) + } + + /// Shrinks the capacity of the `VecDeque` as much as possible. + /// + /// It will drop down as close as possible to the length but the allocator may still inform the + /// `VecDeque` that there is space for a few more elements. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::with_capacity(15); + /// buf.extend(0..4); + /// assert_eq!(buf.capacity(), 15); + /// buf.shrink_to_fit(); + /// assert!(buf.capacity() >= 4); + /// ``` + #[stable(feature = "deque_extras_15", since = "1.5.0")] + pub fn shrink_to_fit(&mut self) { + self.shrink_to(0); + } + + /// Shrinks the capacity of the `VecDeque` with a lower bound. + /// + /// The capacity will remain at least as large as both the length + /// and the supplied value. + /// + /// Panics if the current capacity is smaller than the supplied + /// minimum capacity. + /// + /// # Examples + /// + /// ``` + /// #![feature(shrink_to)] + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::with_capacity(15); + /// buf.extend(0..4); + /// assert_eq!(buf.capacity(), 15); + /// buf.shrink_to(6); + /// assert!(buf.capacity() >= 6); + /// buf.shrink_to(0); + /// assert!(buf.capacity() >= 4); + /// ``` + #[unstable(feature = "shrink_to", reason = "new API", issue = "56431")] + pub fn shrink_to(&mut self, min_capacity: usize) { + assert!(self.capacity() >= min_capacity, "Tried to shrink to a larger capacity"); + + // +1 since the ringbuffer always leaves one space empty + // len + 1 can't overflow for an existing, well-formed ringbuffer. + let target_cap = cmp::max(cmp::max(min_capacity, self.len()) + 1, MINIMUM_CAPACITY + 1) + .next_power_of_two(); + + if target_cap < self.cap() { + // There are three cases of interest: + // All elements are out of desired bounds + // Elements are contiguous, and head is out of desired bounds + // Elements are discontiguous, and tail is out of desired bounds + // + // At all other times, element positions are unaffected. + // + // Indicates that elements at the head should be moved. + let head_outside = self.head == 0 || self.head >= target_cap; + // Move elements from out of desired bounds (positions after target_cap) + if self.tail >= target_cap && head_outside { + // T H + // [. . . . . . . . o o o o o o o . ] + // T H + // [o o o o o o o . ] + unsafe { + self.copy_nonoverlapping(0, self.tail, self.len()); + } + self.head = self.len(); + self.tail = 0; + } else if self.tail != 0 && self.tail < target_cap && head_outside { + // T H + // [. . . o o o o o o o . . . . . . ] + // H T + // [o o . o o o o o ] + let len = self.wrap_sub(self.head, target_cap); + unsafe { + self.copy_nonoverlapping(0, target_cap, len); + } + self.head = len; + debug_assert!(self.head < self.tail); + } else if self.tail >= target_cap { + // H T + // [o o o o o . . . . . . . . . o o ] + // H T + // [o o o o o . o o ] + debug_assert!(self.wrap_sub(self.head, 1) < target_cap); + let len = self.cap() - self.tail; + let new_tail = target_cap - len; + unsafe { + self.copy_nonoverlapping(new_tail, self.tail, len); + } + self.tail = new_tail; + debug_assert!(self.head < self.tail); + } + + self.buf.shrink_to_fit(target_cap); + + debug_assert!(self.head < self.cap()); + debug_assert!(self.tail < self.cap()); + debug_assert!(self.cap().count_ones() == 1); + } + } + + /// Shortens the `VecDeque`, keeping the first `len` elements and dropping + /// the rest. + /// + /// If `len` is greater than the `VecDeque`'s current length, this has no + /// effect. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(5); + /// buf.push_back(10); + /// buf.push_back(15); + /// assert_eq!(buf, [5, 10, 15]); + /// buf.truncate(1); + /// assert_eq!(buf, [5]); + /// ``` + #[stable(feature = "deque_extras", since = "1.16.0")] + pub fn truncate(&mut self, len: usize) { + /// Runs the destructor for all items in the slice when it gets dropped (normally or + /// during unwinding). + struct Dropper<'a, T>(&'a mut [T]); + + impl<'a, T> Drop for Dropper<'a, T> { + fn drop(&mut self) { + unsafe { + ptr::drop_in_place(self.0); + } + } + } + + // Safe because: + // + // * Any slice passed to `drop_in_place` is valid; the second case has + // `len <= front.len()` and returning on `len > self.len()` ensures + // `begin <= back.len()` in the first case + // * The head of the VecDeque is moved before calling `drop_in_place`, + // so no value is dropped twice if `drop_in_place` panics + unsafe { + if len > self.len() { + return; + } + let num_dropped = self.len() - len; + let (front, back) = self.as_mut_slices(); + if len > front.len() { + let begin = len - front.len(); + let drop_back = back.get_unchecked_mut(begin..) as *mut _; + self.head = self.wrap_sub(self.head, num_dropped); + ptr::drop_in_place(drop_back); + } else { + let drop_back = back as *mut _; + let drop_front = front.get_unchecked_mut(len..) as *mut _; + self.head = self.wrap_sub(self.head, num_dropped); + + // Make sure the second half is dropped even when a destructor + // in the first one panics. + let _back_dropper = Dropper(&mut *drop_back); + ptr::drop_in_place(drop_front); + } + } + } + + /// Returns a front-to-back iterator. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(5); + /// buf.push_back(3); + /// buf.push_back(4); + /// let b: &[_] = &[&5, &3, &4]; + /// let c: Vec<&i32> = buf.iter().collect(); + /// assert_eq!(&c[..], b); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn iter(&self) -> Iter<'_, T> { + Iter { tail: self.tail, head: self.head, ring: unsafe { self.buffer_as_slice() } } + } + + /// Returns a front-to-back iterator that returns mutable references. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(5); + /// buf.push_back(3); + /// buf.push_back(4); + /// for num in buf.iter_mut() { + /// *num = *num - 2; + /// } + /// let b: &[_] = &[&mut 3, &mut 1, &mut 2]; + /// assert_eq!(&buf.iter_mut().collect::>()[..], b); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn iter_mut(&mut self) -> IterMut<'_, T> { + // SAFETY: The internal `IterMut` safety invariant is established because the + // `ring` we create is a dereferencable slice for lifetime '_. + IterMut { + tail: self.tail, + head: self.head, + ring: ptr::slice_from_raw_parts_mut(self.ptr(), self.cap()), + phantom: PhantomData, + } + } + + /// Returns a pair of slices which contain, in order, the contents of the + /// `VecDeque`. + /// + /// If [`make_contiguous`] was previously called, all elements of the + /// `VecDeque` will be in the first slice and the second slice will be empty. + /// + /// [`make_contiguous`]: VecDeque::make_contiguous + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut vector = VecDeque::new(); + /// + /// vector.push_back(0); + /// vector.push_back(1); + /// vector.push_back(2); + /// + /// assert_eq!(vector.as_slices(), (&[0, 1, 2][..], &[][..])); + /// + /// vector.push_front(10); + /// vector.push_front(9); + /// + /// assert_eq!(vector.as_slices(), (&[9, 10][..], &[0, 1, 2][..])); + /// ``` + #[inline] + #[stable(feature = "deque_extras_15", since = "1.5.0")] + pub fn as_slices(&self) -> (&[T], &[T]) { + unsafe { + let buf = self.buffer_as_slice(); + RingSlices::ring_slices(buf, self.head, self.tail) + } + } + + /// Returns a pair of slices which contain, in order, the contents of the + /// `VecDeque`. + /// + /// If [`make_contiguous`] was previously called, all elements of the + /// `VecDeque` will be in the first slice and the second slice will be empty. + /// + /// [`make_contiguous`]: VecDeque::make_contiguous + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut vector = VecDeque::new(); + /// + /// vector.push_back(0); + /// vector.push_back(1); + /// + /// vector.push_front(10); + /// vector.push_front(9); + /// + /// vector.as_mut_slices().0[0] = 42; + /// vector.as_mut_slices().1[0] = 24; + /// assert_eq!(vector.as_slices(), (&[42, 10][..], &[24, 1][..])); + /// ``` + #[inline] + #[stable(feature = "deque_extras_15", since = "1.5.0")] + pub fn as_mut_slices(&mut self) -> (&mut [T], &mut [T]) { + unsafe { + let head = self.head; + let tail = self.tail; + let buf = self.buffer_as_mut_slice(); + RingSlices::ring_slices(buf, head, tail) + } + } + + /// Returns the number of elements in the `VecDeque`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut v = VecDeque::new(); + /// assert_eq!(v.len(), 0); + /// v.push_back(1); + /// assert_eq!(v.len(), 1); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn len(&self) -> usize { + count(self.tail, self.head, self.cap()) + } + + /// Returns `true` if the `VecDeque` is empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut v = VecDeque::new(); + /// assert!(v.is_empty()); + /// v.push_front(1); + /// assert!(!v.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn is_empty(&self) -> bool { + self.tail == self.head + } + + fn range_tail_head(&self, range: R) -> (usize, usize) + where + R: RangeBounds, + { + let Range { start, end } = range.assert_len(self.len()); + let tail = self.wrap_add(self.tail, start); + let head = self.wrap_add(self.tail, end); + (tail, head) + } + + /// Creates an iterator that covers the specified range in the `VecDeque`. + /// + /// # Panics + /// + /// Panics if the starting point is greater than the end point or if + /// the end point is greater than the length of the vector. + /// + /// # Examples + /// + /// ``` + /// #![feature(deque_range)] + /// + /// use std::collections::VecDeque; + /// + /// let v: VecDeque<_> = vec![1, 2, 3].into_iter().collect(); + /// let range = v.range(2..).copied().collect::>(); + /// assert_eq!(range, [3]); + /// + /// // A full range covers all contents + /// let all = v.range(..); + /// assert_eq!(all.len(), 3); + /// ``` + #[inline] + #[unstable(feature = "deque_range", issue = "74217")] + pub fn range(&self, range: R) -> Iter<'_, T> + where + R: RangeBounds, + { + let (tail, head) = self.range_tail_head(range); + Iter { + tail, + head, + // The shared reference we have in &self is maintained in the '_ of Iter. + ring: unsafe { self.buffer_as_slice() }, + } + } + + /// Creates an iterator that covers the specified mutable range in the `VecDeque`. + /// + /// # Panics + /// + /// Panics if the starting point is greater than the end point or if + /// the end point is greater than the length of the vector. + /// + /// # Examples + /// + /// ``` + /// #![feature(deque_range)] + /// + /// use std::collections::VecDeque; + /// + /// let mut v: VecDeque<_> = vec![1, 2, 3].into_iter().collect(); + /// for v in v.range_mut(2..) { + /// *v *= 2; + /// } + /// assert_eq!(v, vec![1, 2, 6]); + /// + /// // A full range covers all contents + /// for v in v.range_mut(..) { + /// *v *= 2; + /// } + /// assert_eq!(v, vec![2, 4, 12]); + /// ``` + #[inline] + #[unstable(feature = "deque_range", issue = "74217")] + pub fn range_mut(&mut self, range: R) -> IterMut<'_, T> + where + R: RangeBounds, + { + let (tail, head) = self.range_tail_head(range); + + // SAFETY: The internal `IterMut` safety invariant is established because the + // `ring` we create is a dereferencable slice for lifetime '_. + IterMut { + tail, + head, + ring: ptr::slice_from_raw_parts_mut(self.ptr(), self.cap()), + phantom: PhantomData, + } + } + + /// Creates a draining iterator that removes the specified range in the + /// `VecDeque` and yields the removed items. + /// + /// Note 1: The element range is removed even if the iterator is not + /// consumed until the end. + /// + /// Note 2: It is unspecified how many elements are removed from the deque, + /// if the `Drain` value is not dropped, but the borrow it holds expires + /// (e.g., due to `mem::forget`). + /// + /// # Panics + /// + /// Panics if the starting point is greater than the end point or if + /// the end point is greater than the length of the vector. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut v: VecDeque<_> = vec![1, 2, 3].into_iter().collect(); + /// let drained = v.drain(2..).collect::>(); + /// assert_eq!(drained, [3]); + /// assert_eq!(v, [1, 2]); + /// + /// // A full range clears all contents + /// v.drain(..); + /// assert!(v.is_empty()); + /// ``` + #[inline] + #[stable(feature = "drain", since = "1.6.0")] + pub fn drain(&mut self, range: R) -> Drain<'_, T> + where + R: RangeBounds, + { + // Memory safety + // + // When the Drain is first created, the source deque is shortened to + // make sure no uninitialized or moved-from elements are accessible at + // all if the Drain's destructor never gets to run. + // + // Drain will ptr::read out the values to remove. + // When finished, the remaining data will be copied back to cover the hole, + // and the head/tail values will be restored correctly. + // + let (drain_tail, drain_head) = self.range_tail_head(range); + + // The deque's elements are parted into three segments: + // * self.tail -> drain_tail + // * drain_tail -> drain_head + // * drain_head -> self.head + // + // T = self.tail; H = self.head; t = drain_tail; h = drain_head + // + // We store drain_tail as self.head, and drain_head and self.head as + // after_tail and after_head respectively on the Drain. This also + // truncates the effective array such that if the Drain is leaked, we + // have forgotten about the potentially moved values after the start of + // the drain. + // + // T t h H + // [. . . o o x x o o . . .] + // + let head = self.head; + + // "forget" about the values after the start of the drain until after + // the drain is complete and the Drain destructor is run. + self.head = drain_tail; + + Drain { + deque: NonNull::from(&mut *self), + after_tail: drain_head, + after_head: head, + iter: Iter { + tail: drain_tail, + head: drain_head, + // Crucially, we only create shared references from `self` here and read from + // it. We do not write to `self` nor reborrow to a mutable reference. + // Hence the raw pointer we created above, for `deque`, remains valid. + ring: unsafe { self.buffer_as_slice() }, + }, + } + } + + /// Clears the `VecDeque`, removing all values. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut v = VecDeque::new(); + /// v.push_back(1); + /// v.clear(); + /// assert!(v.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn clear(&mut self) { + self.truncate(0); + } + + /// Returns `true` if the `VecDeque` contains an element equal to the + /// given value. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut vector: VecDeque = VecDeque::new(); + /// + /// vector.push_back(0); + /// vector.push_back(1); + /// + /// assert_eq!(vector.contains(&1), true); + /// assert_eq!(vector.contains(&10), false); + /// ``` + #[stable(feature = "vec_deque_contains", since = "1.12.0")] + pub fn contains(&self, x: &T) -> bool + where + T: PartialEq, + { + let (a, b) = self.as_slices(); + a.contains(x) || b.contains(x) + } + + /// Provides a reference to the front element, or `None` if the `VecDeque` is + /// empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut d = VecDeque::new(); + /// assert_eq!(d.front(), None); + /// + /// d.push_back(1); + /// d.push_back(2); + /// assert_eq!(d.front(), Some(&1)); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn front(&self) -> Option<&T> { + if !self.is_empty() { Some(&self[0]) } else { None } + } + + /// Provides a mutable reference to the front element, or `None` if the + /// `VecDeque` is empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut d = VecDeque::new(); + /// assert_eq!(d.front_mut(), None); + /// + /// d.push_back(1); + /// d.push_back(2); + /// match d.front_mut() { + /// Some(x) => *x = 9, + /// None => (), + /// } + /// assert_eq!(d.front(), Some(&9)); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn front_mut(&mut self) -> Option<&mut T> { + if !self.is_empty() { Some(&mut self[0]) } else { None } + } + + /// Provides a reference to the back element, or `None` if the `VecDeque` is + /// empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut d = VecDeque::new(); + /// assert_eq!(d.back(), None); + /// + /// d.push_back(1); + /// d.push_back(2); + /// assert_eq!(d.back(), Some(&2)); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn back(&self) -> Option<&T> { + if !self.is_empty() { Some(&self[self.len() - 1]) } else { None } + } + + /// Provides a mutable reference to the back element, or `None` if the + /// `VecDeque` is empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut d = VecDeque::new(); + /// assert_eq!(d.back(), None); + /// + /// d.push_back(1); + /// d.push_back(2); + /// match d.back_mut() { + /// Some(x) => *x = 9, + /// None => (), + /// } + /// assert_eq!(d.back(), Some(&9)); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn back_mut(&mut self) -> Option<&mut T> { + let len = self.len(); + if !self.is_empty() { Some(&mut self[len - 1]) } else { None } + } + + /// Removes the first element and returns it, or `None` if the `VecDeque` is + /// empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut d = VecDeque::new(); + /// d.push_back(1); + /// d.push_back(2); + /// + /// assert_eq!(d.pop_front(), Some(1)); + /// assert_eq!(d.pop_front(), Some(2)); + /// assert_eq!(d.pop_front(), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn pop_front(&mut self) -> Option { + if self.is_empty() { + None + } else { + let tail = self.tail; + self.tail = self.wrap_add(self.tail, 1); + unsafe { Some(self.buffer_read(tail)) } + } + } + + /// Removes the last element from the `VecDeque` and returns it, or `None` if + /// it is empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// assert_eq!(buf.pop_back(), None); + /// buf.push_back(1); + /// buf.push_back(3); + /// assert_eq!(buf.pop_back(), Some(3)); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn pop_back(&mut self) -> Option { + if self.is_empty() { + None + } else { + self.head = self.wrap_sub(self.head, 1); + let head = self.head; + unsafe { Some(self.buffer_read(head)) } + } + } + + /// Prepends an element to the `VecDeque`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut d = VecDeque::new(); + /// d.push_front(1); + /// d.push_front(2); + /// assert_eq!(d.front(), Some(&2)); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn push_front(&mut self, value: T) { + if self.is_full() { + self.grow(); + } + + self.tail = self.wrap_sub(self.tail, 1); + let tail = self.tail; + unsafe { + self.buffer_write(tail, value); + } + } + + /// Appends an element to the back of the `VecDeque`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(1); + /// buf.push_back(3); + /// assert_eq!(3, *buf.back().unwrap()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn push_back(&mut self, value: T) { + if self.is_full() { + self.grow(); + } + + let head = self.head; + self.head = self.wrap_add(self.head, 1); + unsafe { self.buffer_write(head, value) } + } + + #[inline] + fn is_contiguous(&self) -> bool { + // FIXME: Should we consider `head == 0` to mean + // that `self` is contiguous? + self.tail <= self.head + } + + /// Removes an element from anywhere in the `VecDeque` and returns it, + /// replacing it with the first element. + /// + /// This does not preserve ordering, but is *O*(1). + /// + /// Returns `None` if `index` is out of bounds. + /// + /// Element at index 0 is the front of the queue. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// assert_eq!(buf.swap_remove_front(0), None); + /// buf.push_back(1); + /// buf.push_back(2); + /// buf.push_back(3); + /// assert_eq!(buf, [1, 2, 3]); + /// + /// assert_eq!(buf.swap_remove_front(2), Some(3)); + /// assert_eq!(buf, [2, 1]); + /// ``` + #[stable(feature = "deque_extras_15", since = "1.5.0")] + pub fn swap_remove_front(&mut self, index: usize) -> Option { + let length = self.len(); + if length > 0 && index < length && index != 0 { + self.swap(index, 0); + } else if index >= length { + return None; + } + self.pop_front() + } + + /// Removes an element from anywhere in the `VecDeque` and returns it, replacing it with the + /// last element. + /// + /// This does not preserve ordering, but is *O*(1). + /// + /// Returns `None` if `index` is out of bounds. + /// + /// Element at index 0 is the front of the queue. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// assert_eq!(buf.swap_remove_back(0), None); + /// buf.push_back(1); + /// buf.push_back(2); + /// buf.push_back(3); + /// assert_eq!(buf, [1, 2, 3]); + /// + /// assert_eq!(buf.swap_remove_back(0), Some(1)); + /// assert_eq!(buf, [3, 2]); + /// ``` + #[stable(feature = "deque_extras_15", since = "1.5.0")] + pub fn swap_remove_back(&mut self, index: usize) -> Option { + let length = self.len(); + if length > 0 && index < length - 1 { + self.swap(index, length - 1); + } else if index >= length { + return None; + } + self.pop_back() + } + + /// Inserts an element at `index` within the `VecDeque`, shifting all elements with indices + /// greater than or equal to `index` towards the back. + /// + /// Element at index 0 is the front of the queue. + /// + /// # Panics + /// + /// Panics if `index` is greater than `VecDeque`'s length + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut vec_deque = VecDeque::new(); + /// vec_deque.push_back('a'); + /// vec_deque.push_back('b'); + /// vec_deque.push_back('c'); + /// assert_eq!(vec_deque, &['a', 'b', 'c']); + /// + /// vec_deque.insert(1, 'd'); + /// assert_eq!(vec_deque, &['a', 'd', 'b', 'c']); + /// ``` + #[stable(feature = "deque_extras_15", since = "1.5.0")] + pub fn insert(&mut self, index: usize, value: T) { + assert!(index <= self.len(), "index out of bounds"); + if self.is_full() { + self.grow(); + } + + // Move the least number of elements in the ring buffer and insert + // the given object + // + // At most len/2 - 1 elements will be moved. O(min(n, n-i)) + // + // There are three main cases: + // Elements are contiguous + // - special case when tail is 0 + // Elements are discontiguous and the insert is in the tail section + // Elements are discontiguous and the insert is in the head section + // + // For each of those there are two more cases: + // Insert is closer to tail + // Insert is closer to head + // + // Key: H - self.head + // T - self.tail + // o - Valid element + // I - Insertion element + // A - The element that should be after the insertion point + // M - Indicates element was moved + + let idx = self.wrap_add(self.tail, index); + + let distance_to_tail = index; + let distance_to_head = self.len() - index; + + let contiguous = self.is_contiguous(); + + match (contiguous, distance_to_tail <= distance_to_head, idx >= self.tail) { + (true, true, _) if index == 0 => { + // push_front + // + // T + // I H + // [A o o o o o o . . . . . . . . .] + // + // H T + // [A o o o o o o o . . . . . I] + // + + self.tail = self.wrap_sub(self.tail, 1); + } + (true, true, _) => { + unsafe { + // contiguous, insert closer to tail: + // + // T I H + // [. . . o o A o o o o . . . . . .] + // + // T H + // [. . o o I A o o o o . . . . . .] + // M M + // + // contiguous, insert closer to tail and tail is 0: + // + // + // T I H + // [o o A o o o o . . . . . . . . .] + // + // H T + // [o I A o o o o o . . . . . . . o] + // M M + + let new_tail = self.wrap_sub(self.tail, 1); + + self.copy(new_tail, self.tail, 1); + // Already moved the tail, so we only copy `index - 1` elements. + self.copy(self.tail, self.tail + 1, index - 1); + + self.tail = new_tail; + } + } + (true, false, _) => { + unsafe { + // contiguous, insert closer to head: + // + // T I H + // [. . . o o o o A o o . . . . . .] + // + // T H + // [. . . o o o o I A o o . . . . .] + // M M M + + self.copy(idx + 1, idx, self.head - idx); + self.head = self.wrap_add(self.head, 1); + } + } + (false, true, true) => { + unsafe { + // discontiguous, insert closer to tail, tail section: + // + // H T I + // [o o o o o o . . . . . o o A o o] + // + // H T + // [o o o o o o . . . . o o I A o o] + // M M + + self.copy(self.tail - 1, self.tail, index); + self.tail -= 1; + } + } + (false, false, true) => { + unsafe { + // discontiguous, insert closer to head, tail section: + // + // H T I + // [o o . . . . . . . o o o o o A o] + // + // H T + // [o o o . . . . . . o o o o o I A] + // M M M M + + // copy elements up to new head + self.copy(1, 0, self.head); + + // copy last element into empty spot at bottom of buffer + self.copy(0, self.cap() - 1, 1); + + // move elements from idx to end forward not including ^ element + self.copy(idx + 1, idx, self.cap() - 1 - idx); + + self.head += 1; + } + } + (false, true, false) if idx == 0 => { + unsafe { + // discontiguous, insert is closer to tail, head section, + // and is at index zero in the internal buffer: + // + // I H T + // [A o o o o o o o o o . . . o o o] + // + // H T + // [A o o o o o o o o o . . o o o I] + // M M M + + // copy elements up to new tail + self.copy(self.tail - 1, self.tail, self.cap() - self.tail); + + // copy last element into empty spot at bottom of buffer + self.copy(self.cap() - 1, 0, 1); + + self.tail -= 1; + } + } + (false, true, false) => { + unsafe { + // discontiguous, insert closer to tail, head section: + // + // I H T + // [o o o A o o o o o o . . . o o o] + // + // H T + // [o o I A o o o o o o . . o o o o] + // M M M M M M + + // copy elements up to new tail + self.copy(self.tail - 1, self.tail, self.cap() - self.tail); + + // copy last element into empty spot at bottom of buffer + self.copy(self.cap() - 1, 0, 1); + + // move elements from idx-1 to end forward not including ^ element + self.copy(0, 1, idx - 1); + + self.tail -= 1; + } + } + (false, false, false) => { + unsafe { + // discontiguous, insert closer to head, head section: + // + // I H T + // [o o o o A o o . . . . . . o o o] + // + // H T + // [o o o o I A o o . . . . . o o o] + // M M M + + self.copy(idx + 1, idx, self.head - idx); + self.head += 1; + } + } + } + + // tail might've been changed so we need to recalculate + let new_idx = self.wrap_add(self.tail, index); + unsafe { + self.buffer_write(new_idx, value); + } + } + + /// Removes and returns the element at `index` from the `VecDeque`. + /// Whichever end is closer to the removal point will be moved to make + /// room, and all the affected elements will be moved to new positions. + /// Returns `None` if `index` is out of bounds. + /// + /// Element at index 0 is the front of the queue. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(1); + /// buf.push_back(2); + /// buf.push_back(3); + /// assert_eq!(buf, [1, 2, 3]); + /// + /// assert_eq!(buf.remove(1), Some(2)); + /// assert_eq!(buf, [1, 3]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn remove(&mut self, index: usize) -> Option { + if self.is_empty() || self.len() <= index { + return None; + } + + // There are three main cases: + // Elements are contiguous + // Elements are discontiguous and the removal is in the tail section + // Elements are discontiguous and the removal is in the head section + // - special case when elements are technically contiguous, + // but self.head = 0 + // + // For each of those there are two more cases: + // Insert is closer to tail + // Insert is closer to head + // + // Key: H - self.head + // T - self.tail + // o - Valid element + // x - Element marked for removal + // R - Indicates element that is being removed + // M - Indicates element was moved + + let idx = self.wrap_add(self.tail, index); + + let elem = unsafe { Some(self.buffer_read(idx)) }; + + let distance_to_tail = index; + let distance_to_head = self.len() - index; + + let contiguous = self.is_contiguous(); + + match (contiguous, distance_to_tail <= distance_to_head, idx >= self.tail) { + (true, true, _) => { + unsafe { + // contiguous, remove closer to tail: + // + // T R H + // [. . . o o x o o o o . . . . . .] + // + // T H + // [. . . . o o o o o o . . . . . .] + // M M + + self.copy(self.tail + 1, self.tail, index); + self.tail += 1; + } + } + (true, false, _) => { + unsafe { + // contiguous, remove closer to head: + // + // T R H + // [. . . o o o o x o o . . . . . .] + // + // T H + // [. . . o o o o o o . . . . . . .] + // M M + + self.copy(idx, idx + 1, self.head - idx - 1); + self.head -= 1; + } + } + (false, true, true) => { + unsafe { + // discontiguous, remove closer to tail, tail section: + // + // H T R + // [o o o o o o . . . . . o o x o o] + // + // H T + // [o o o o o o . . . . . . o o o o] + // M M + + self.copy(self.tail + 1, self.tail, index); + self.tail = self.wrap_add(self.tail, 1); + } + } + (false, false, false) => { + unsafe { + // discontiguous, remove closer to head, head section: + // + // R H T + // [o o o o x o o . . . . . . o o o] + // + // H T + // [o o o o o o . . . . . . . o o o] + // M M + + self.copy(idx, idx + 1, self.head - idx - 1); + self.head -= 1; + } + } + (false, false, true) => { + unsafe { + // discontiguous, remove closer to head, tail section: + // + // H T R + // [o o o . . . . . . o o o o o x o] + // + // H T + // [o o . . . . . . . o o o o o o o] + // M M M M + // + // or quasi-discontiguous, remove next to head, tail section: + // + // H T R + // [. . . . . . . . . o o o o o x o] + // + // T H + // [. . . . . . . . . o o o o o o .] + // M + + // draw in elements in the tail section + self.copy(idx, idx + 1, self.cap() - idx - 1); + + // Prevents underflow. + if self.head != 0 { + // copy first element into empty spot + self.copy(self.cap() - 1, 0, 1); + + // move elements in the head section backwards + self.copy(0, 1, self.head - 1); + } + + self.head = self.wrap_sub(self.head, 1); + } + } + (false, true, false) => { + unsafe { + // discontiguous, remove closer to tail, head section: + // + // R H T + // [o o x o o o o o o o . . . o o o] + // + // H T + // [o o o o o o o o o o . . . . o o] + // M M M M M + + // draw in elements up to idx + self.copy(1, 0, idx); + + // copy last element into empty spot + self.copy(0, self.cap() - 1, 1); + + // move elements from tail to end forward, excluding the last one + self.copy(self.tail + 1, self.tail, self.cap() - self.tail - 1); + + self.tail = self.wrap_add(self.tail, 1); + } + } + } + + elem + } + + /// Splits the `VecDeque` into two at the given index. + /// + /// Returns a newly allocated `VecDeque`. `self` contains elements `[0, at)`, + /// and the returned `VecDeque` contains elements `[at, len)`. + /// + /// Note that the capacity of `self` does not change. + /// + /// Element at index 0 is the front of the queue. + /// + /// # Panics + /// + /// Panics if `at > len`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf: VecDeque<_> = vec![1,2,3].into_iter().collect(); + /// let buf2 = buf.split_off(1); + /// assert_eq!(buf, [1]); + /// assert_eq!(buf2, [2, 3]); + /// ``` + #[inline] + #[must_use = "use `.truncate()` if you don't need the other half"] + #[stable(feature = "split_off", since = "1.4.0")] + pub fn split_off(&mut self, at: usize) -> Self { + let len = self.len(); + assert!(at <= len, "`at` out of bounds"); + + let other_len = len - at; + let mut other = VecDeque::with_capacity(other_len); + + unsafe { + let (first_half, second_half) = self.as_slices(); + + let first_len = first_half.len(); + let second_len = second_half.len(); + if at < first_len { + // `at` lies in the first half. + let amount_in_first = first_len - at; + + ptr::copy_nonoverlapping(first_half.as_ptr().add(at), other.ptr(), amount_in_first); + + // just take all of the second half. + ptr::copy_nonoverlapping( + second_half.as_ptr(), + other.ptr().add(amount_in_first), + second_len, + ); + } else { + // `at` lies in the second half, need to factor in the elements we skipped + // in the first half. + let offset = at - first_len; + let amount_in_second = second_len - offset; + ptr::copy_nonoverlapping( + second_half.as_ptr().add(offset), + other.ptr(), + amount_in_second, + ); + } + } + + // Cleanup where the ends of the buffers are + self.head = self.wrap_sub(self.head, other_len); + other.head = other.wrap_index(other_len); + + other + } + + /// Moves all the elements of `other` into `self`, leaving `other` empty. + /// + /// # Panics + /// + /// Panics if the new number of elements in self overflows a `usize`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf: VecDeque<_> = vec![1, 2].into_iter().collect(); + /// let mut buf2: VecDeque<_> = vec![3, 4].into_iter().collect(); + /// buf.append(&mut buf2); + /// assert_eq!(buf, [1, 2, 3, 4]); + /// assert_eq!(buf2, []); + /// ``` + #[inline] + #[stable(feature = "append", since = "1.4.0")] + pub fn append(&mut self, other: &mut Self) { + // naive impl + self.extend(other.drain(..)); + } + + /// Retains only the elements specified by the predicate. + /// + /// In other words, remove all elements `e` such that `f(&e)` returns false. + /// This method operates in place, visiting each element exactly once in the + /// original order, and preserves the order of the retained elements. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.extend(1..5); + /// buf.retain(|&x| x % 2 == 0); + /// assert_eq!(buf, [2, 4]); + /// ``` + /// + /// The exact order may be useful for tracking external state, like an index. + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.extend(1..6); + /// + /// let keep = [false, true, true, false, true]; + /// let mut i = 0; + /// buf.retain(|_| (keep[i], i += 1).0); + /// assert_eq!(buf, [2, 3, 5]); + /// ``` + #[stable(feature = "vec_deque_retain", since = "1.4.0")] + pub fn retain(&mut self, mut f: F) + where + F: FnMut(&T) -> bool, + { + let len = self.len(); + let mut del = 0; + for i in 0..len { + if !f(&self[i]) { + del += 1; + } else if del > 0 { + self.swap(i - del, i); + } + } + if del > 0 { + self.truncate(len - del); + } + } + + // This may panic or abort + #[inline(never)] + fn grow(&mut self) { + if self.is_full() { + let old_cap = self.cap(); + // Double the buffer size. + self.buf.reserve_exact(old_cap, old_cap); + assert!(self.cap() == old_cap * 2); + unsafe { + self.handle_capacity_increase(old_cap); + } + debug_assert!(!self.is_full()); + } + } + + /// Modifies the `VecDeque` in-place so that `len()` is equal to `new_len`, + /// either by removing excess elements from the back or by appending + /// elements generated by calling `generator` to the back. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(5); + /// buf.push_back(10); + /// buf.push_back(15); + /// assert_eq!(buf, [5, 10, 15]); + /// + /// buf.resize_with(5, Default::default); + /// assert_eq!(buf, [5, 10, 15, 0, 0]); + /// + /// buf.resize_with(2, || unreachable!()); + /// assert_eq!(buf, [5, 10]); + /// + /// let mut state = 100; + /// buf.resize_with(5, || { state += 1; state }); + /// assert_eq!(buf, [5, 10, 101, 102, 103]); + /// ``` + #[stable(feature = "vec_resize_with", since = "1.33.0")] + pub fn resize_with(&mut self, new_len: usize, generator: impl FnMut() -> T) { + let len = self.len(); + + if new_len > len { + self.extend(repeat_with(generator).take(new_len - len)) + } else { + self.truncate(new_len); + } + } + + /// Rearranges the internal storage of this deque so it is one contiguous + /// slice, which is then returned. + /// + /// This method does not allocate and does not change the order of the + /// inserted elements. As it returns a mutable slice, this can be used to + /// sort a deque. + /// + /// Once the internal storage is contiguous, the [`as_slices`] and + /// [`as_mut_slices`] methods will return the entire contents of the + /// `VecDeque` in a single slice. + /// + /// [`as_slices`]: VecDeque::as_slices + /// [`as_mut_slices`]: VecDeque::as_mut_slices + /// + /// # Examples + /// + /// Sorting the content of a deque. + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::with_capacity(15); + /// + /// buf.push_back(2); + /// buf.push_back(1); + /// buf.push_front(3); + /// + /// // sorting the deque + /// buf.make_contiguous().sort(); + /// assert_eq!(buf.as_slices(), (&[1, 2, 3] as &[_], &[] as &[_])); + /// + /// // sorting it in reverse order + /// buf.make_contiguous().sort_by(|a, b| b.cmp(a)); + /// assert_eq!(buf.as_slices(), (&[3, 2, 1] as &[_], &[] as &[_])); + /// ``` + /// + /// Getting immutable access to the contiguous slice. + /// + /// ```rust + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// + /// buf.push_back(2); + /// buf.push_back(1); + /// buf.push_front(3); + /// + /// buf.make_contiguous(); + /// if let (slice, &[]) = buf.as_slices() { + /// // we can now be sure that `slice` contains all elements of the deque, + /// // while still having immutable access to `buf`. + /// assert_eq!(buf.len(), slice.len()); + /// assert_eq!(slice, &[3, 2, 1] as &[_]); + /// } + /// ``` + #[stable(feature = "deque_make_contiguous", since = "1.48.0")] + pub fn make_contiguous(&mut self) -> &mut [T] { + if self.is_contiguous() { + let tail = self.tail; + let head = self.head; + return unsafe { RingSlices::ring_slices(self.buffer_as_mut_slice(), head, tail).0 }; + } + + let buf = self.buf.ptr(); + let cap = self.cap(); + let len = self.len(); + + let free = self.tail - self.head; + let tail_len = cap - self.tail; + + if free >= tail_len { + // there is enough free space to copy the tail in one go, + // this means that we first shift the head backwards, and then + // copy the tail to the correct position. + // + // from: DEFGH....ABC + // to: ABCDEFGH.... + unsafe { + ptr::copy(buf, buf.add(tail_len), self.head); + // ...DEFGH.ABC + ptr::copy_nonoverlapping(buf.add(self.tail), buf, tail_len); + // ABCDEFGH.... + + self.tail = 0; + self.head = len; + } + } else if free > self.head { + // FIXME: We currently do not consider ....ABCDEFGH + // to be contiguous because `head` would be `0` in this + // case. While we probably want to change this it + // isn't trivial as a few places expect `is_contiguous` + // to mean that we can just slice using `buf[tail..head]`. + + // there is enough free space to copy the head in one go, + // this means that we first shift the tail forwards, and then + // copy the head to the correct position. + // + // from: FGH....ABCDE + // to: ...ABCDEFGH. + unsafe { + ptr::copy(buf.add(self.tail), buf.add(self.head), tail_len); + // FGHABCDE.... + ptr::copy_nonoverlapping(buf, buf.add(self.head + tail_len), self.head); + // ...ABCDEFGH. + + self.tail = self.head; + self.head = self.wrap_add(self.tail, len); + } + } else { + // free is smaller than both head and tail, + // this means we have to slowly "swap" the tail and the head. + // + // from: EFGHI...ABCD or HIJK.ABCDEFG + // to: ABCDEFGHI... or ABCDEFGHIJK. + let mut left_edge: usize = 0; + let mut right_edge: usize = self.tail; + unsafe { + // The general problem looks like this + // GHIJKLM...ABCDEF - before any swaps + // ABCDEFM...GHIJKL - after 1 pass of swaps + // ABCDEFGHIJM...KL - swap until the left edge reaches the temp store + // - then restart the algorithm with a new (smaller) store + // Sometimes the temp store is reached when the right edge is at the end + // of the buffer - this means we've hit the right order with fewer swaps! + // E.g + // EF..ABCD + // ABCDEF.. - after four only swaps we've finished + while left_edge < len && right_edge != cap { + let mut right_offset = 0; + for i in left_edge..right_edge { + right_offset = (i - left_edge) % (cap - right_edge); + let src: isize = (right_edge + right_offset) as isize; + ptr::swap(buf.add(i), buf.offset(src)); + } + let n_ops = right_edge - left_edge; + left_edge += n_ops; + right_edge += right_offset + 1; + } + + self.tail = 0; + self.head = len; + } + } + + let tail = self.tail; + let head = self.head; + unsafe { RingSlices::ring_slices(self.buffer_as_mut_slice(), head, tail).0 } + } + + /// Rotates the double-ended queue `mid` places to the left. + /// + /// Equivalently, + /// - Rotates item `mid` into the first position. + /// - Pops the first `mid` items and pushes them to the end. + /// - Rotates `len() - mid` places to the right. + /// + /// # Panics + /// + /// If `mid` is greater than `len()`. Note that `mid == len()` + /// does _not_ panic and is a no-op rotation. + /// + /// # Complexity + /// + /// Takes `*O*(min(mid, len() - mid))` time and no extra space. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf: VecDeque<_> = (0..10).collect(); + /// + /// buf.rotate_left(3); + /// assert_eq!(buf, [3, 4, 5, 6, 7, 8, 9, 0, 1, 2]); + /// + /// for i in 1..10 { + /// assert_eq!(i * 3 % 10, buf[0]); + /// buf.rotate_left(3); + /// } + /// assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); + /// ``` + #[stable(feature = "vecdeque_rotate", since = "1.36.0")] + pub fn rotate_left(&mut self, mid: usize) { + assert!(mid <= self.len()); + let k = self.len() - mid; + if mid <= k { + unsafe { self.rotate_left_inner(mid) } + } else { + unsafe { self.rotate_right_inner(k) } + } + } + + /// Rotates the double-ended queue `k` places to the right. + /// + /// Equivalently, + /// - Rotates the first item into position `k`. + /// - Pops the last `k` items and pushes them to the front. + /// - Rotates `len() - k` places to the left. + /// + /// # Panics + /// + /// If `k` is greater than `len()`. Note that `k == len()` + /// does _not_ panic and is a no-op rotation. + /// + /// # Complexity + /// + /// Takes `*O*(min(k, len() - k))` time and no extra space. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf: VecDeque<_> = (0..10).collect(); + /// + /// buf.rotate_right(3); + /// assert_eq!(buf, [7, 8, 9, 0, 1, 2, 3, 4, 5, 6]); + /// + /// for i in 1..10 { + /// assert_eq!(0, buf[i * 3 % 10]); + /// buf.rotate_right(3); + /// } + /// assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); + /// ``` + #[stable(feature = "vecdeque_rotate", since = "1.36.0")] + pub fn rotate_right(&mut self, k: usize) { + assert!(k <= self.len()); + let mid = self.len() - k; + if k <= mid { + unsafe { self.rotate_right_inner(k) } + } else { + unsafe { self.rotate_left_inner(mid) } + } + } + + // SAFETY: the following two methods require that the rotation amount + // be less than half the length of the deque. + // + // `wrap_copy` requires that `min(x, cap() - x) + copy_len <= cap()`, + // but than `min` is never more than half the capacity, regardless of x, + // so it's sound to call here because we're calling with something + // less than half the length, which is never above half the capacity. + + unsafe fn rotate_left_inner(&mut self, mid: usize) { + debug_assert!(mid * 2 <= self.len()); + unsafe { + self.wrap_copy(self.head, self.tail, mid); + } + self.head = self.wrap_add(self.head, mid); + self.tail = self.wrap_add(self.tail, mid); + } + + unsafe fn rotate_right_inner(&mut self, k: usize) { + debug_assert!(k * 2 <= self.len()); + self.head = self.wrap_sub(self.head, k); + self.tail = self.wrap_sub(self.tail, k); + unsafe { + self.wrap_copy(self.tail, self.head, k); + } + } + + /// Binary searches this sorted `VecDeque` for a given element. + /// + /// If the value is found then [`Result::Ok`] is returned, containing the + /// index of the matching element. If there are multiple matches, then any + /// one of the matches could be returned. If the value is not found then + /// [`Result::Err`] is returned, containing the index where a matching + /// element could be inserted while maintaining sorted order. + /// + /// # Examples + /// + /// Looks up a series of four elements. The first is found, with a + /// uniquely determined position; the second and third are not + /// found; the fourth could match any position in `[1, 4]`. + /// + /// ``` + /// #![feature(vecdeque_binary_search)] + /// use std::collections::VecDeque; + /// + /// let deque: VecDeque<_> = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55].into(); + /// + /// assert_eq!(deque.binary_search(&13), Ok(9)); + /// assert_eq!(deque.binary_search(&4), Err(7)); + /// assert_eq!(deque.binary_search(&100), Err(13)); + /// let r = deque.binary_search(&1); + /// assert!(matches!(r, Ok(1..=4))); + /// ``` + /// + /// If you want to insert an item to a sorted `VecDeque`, while maintaining + /// sort order: + /// + /// ``` + /// #![feature(vecdeque_binary_search)] + /// use std::collections::VecDeque; + /// + /// let mut deque: VecDeque<_> = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55].into(); + /// let num = 42; + /// let idx = deque.binary_search(&num).unwrap_or_else(|x| x); + /// deque.insert(idx, num); + /// assert_eq!(deque, &[0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]); + /// ``` + #[unstable(feature = "vecdeque_binary_search", issue = "78021")] + #[inline] + pub fn binary_search(&self, x: &T) -> Result + where + T: Ord, + { + self.binary_search_by(|e| e.cmp(x)) + } + + /// Binary searches this sorted `VecDeque` with a comparator function. + /// + /// The comparator function should implement an order consistent + /// with the sort order of the underlying `VecDeque`, returning an + /// order code that indicates whether its argument is `Less`, + /// `Equal` or `Greater` than the desired target. + /// + /// If the value is found then [`Result::Ok`] is returned, containing the + /// index of the matching element. If there are multiple matches, then any + /// one of the matches could be returned. If the value is not found then + /// [`Result::Err`] is returned, containing the index where a matching + /// element could be inserted while maintaining sorted order. + /// + /// # Examples + /// + /// Looks up a series of four elements. The first is found, with a + /// uniquely determined position; the second and third are not + /// found; the fourth could match any position in `[1, 4]`. + /// + /// ``` + /// #![feature(vecdeque_binary_search)] + /// use std::collections::VecDeque; + /// + /// let deque: VecDeque<_> = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55].into(); + /// + /// assert_eq!(deque.binary_search_by(|x| x.cmp(&13)), Ok(9)); + /// assert_eq!(deque.binary_search_by(|x| x.cmp(&4)), Err(7)); + /// assert_eq!(deque.binary_search_by(|x| x.cmp(&100)), Err(13)); + /// let r = deque.binary_search_by(|x| x.cmp(&1)); + /// assert!(matches!(r, Ok(1..=4))); + /// ``` + #[unstable(feature = "vecdeque_binary_search", issue = "78021")] + pub fn binary_search_by<'a, F>(&'a self, mut f: F) -> Result + where + F: FnMut(&'a T) -> Ordering, + { + let (front, back) = self.as_slices(); + + if let Some(Ordering::Less | Ordering::Equal) = back.first().map(|elem| f(elem)) { + back.binary_search_by(f).map(|idx| idx + front.len()).map_err(|idx| idx + front.len()) + } else { + front.binary_search_by(f) + } + } + + /// Binary searches this sorted `VecDeque` with a key extraction function. + /// + /// Assumes that the `VecDeque` is sorted by the key, for instance with + /// [`make_contiguous().sort_by_key()`](#method.make_contiguous) using the same + /// key extraction function. + /// + /// If the value is found then [`Result::Ok`] is returned, containing the + /// index of the matching element. If there are multiple matches, then any + /// one of the matches could be returned. If the value is not found then + /// [`Result::Err`] is returned, containing the index where a matching + /// element could be inserted while maintaining sorted order. + /// + /// # Examples + /// + /// Looks up a series of four elements in a slice of pairs sorted by + /// their second elements. The first is found, with a uniquely + /// determined position; the second and third are not found; the + /// fourth could match any position in `[1, 4]`. + /// + /// ``` + /// #![feature(vecdeque_binary_search)] + /// use std::collections::VecDeque; + /// + /// let deque: VecDeque<_> = vec![(0, 0), (2, 1), (4, 1), (5, 1), + /// (3, 1), (1, 2), (2, 3), (4, 5), (5, 8), (3, 13), + /// (1, 21), (2, 34), (4, 55)].into(); + /// + /// assert_eq!(deque.binary_search_by_key(&13, |&(a,b)| b), Ok(9)); + /// assert_eq!(deque.binary_search_by_key(&4, |&(a,b)| b), Err(7)); + /// assert_eq!(deque.binary_search_by_key(&100, |&(a,b)| b), Err(13)); + /// let r = deque.binary_search_by_key(&1, |&(a,b)| b); + /// assert!(matches!(r, Ok(1..=4))); + /// ``` + #[unstable(feature = "vecdeque_binary_search", issue = "78021")] + #[inline] + pub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, mut f: F) -> Result + where + F: FnMut(&'a T) -> B, + B: Ord, + { + self.binary_search_by(|k| f(k).cmp(b)) + } +} + +impl VecDeque { + /// Modifies the `VecDeque` in-place so that `len()` is equal to new_len, + /// either by removing excess elements from the back or by appending clones of `value` + /// to the back. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(5); + /// buf.push_back(10); + /// buf.push_back(15); + /// assert_eq!(buf, [5, 10, 15]); + /// + /// buf.resize(2, 0); + /// assert_eq!(buf, [5, 10]); + /// + /// buf.resize(5, 20); + /// assert_eq!(buf, [5, 10, 20, 20, 20]); + /// ``` + #[stable(feature = "deque_extras", since = "1.16.0")] + pub fn resize(&mut self, new_len: usize, value: T) { + self.resize_with(new_len, || value.clone()); + } +} + +/// Returns the index in the underlying buffer for a given logical element index. +#[inline] +fn wrap_index(index: usize, size: usize) -> usize { + // size is always a power of 2 + debug_assert!(size.is_power_of_two()); + index & (size - 1) +} + +/// Returns the two slices that cover the `VecDeque`'s valid range +trait RingSlices: Sized { + fn slice(self, from: usize, to: usize) -> Self; + fn split_at(self, i: usize) -> (Self, Self); + + fn ring_slices(buf: Self, head: usize, tail: usize) -> (Self, Self) { + let contiguous = tail <= head; + if contiguous { + let (empty, buf) = buf.split_at(0); + (buf.slice(tail, head), empty) + } else { + let (mid, right) = buf.split_at(tail); + let (left, _) = mid.split_at(head); + (right, left) + } + } +} + +impl RingSlices for &[T] { + fn slice(self, from: usize, to: usize) -> Self { + &self[from..to] + } + fn split_at(self, i: usize) -> (Self, Self) { + (*self).split_at(i) + } +} + +impl RingSlices for &mut [T] { + fn slice(self, from: usize, to: usize) -> Self { + &mut self[from..to] + } + fn split_at(self, i: usize) -> (Self, Self) { + (*self).split_at_mut(i) + } +} + +impl RingSlices for *mut [T] { + fn slice(self, from: usize, to: usize) -> Self { + assert!(from <= to && to < self.len()); + // Not using `get_unchecked_mut` to keep this a safe operation. + let len = to - from; + ptr::slice_from_raw_parts_mut(self.as_mut_ptr().wrapping_add(from), len) + } + + fn split_at(self, mid: usize) -> (Self, Self) { + let len = self.len(); + let ptr = self.as_mut_ptr(); + assert!(mid <= len); + ( + ptr::slice_from_raw_parts_mut(ptr, mid), + ptr::slice_from_raw_parts_mut(ptr.wrapping_add(mid), len - mid), + ) + } +} + +/// Calculate the number of elements left to be read in the buffer +#[inline] +fn count(tail: usize, head: usize, size: usize) -> usize { + // size is always a power of 2 + (head.wrapping_sub(tail)) & (size - 1) +} + +/// An iterator over the elements of a `VecDeque`. +/// +/// This `struct` is created by the [`iter`] method on [`VecDeque`]. See its +/// documentation for more. +/// +/// [`iter`]: VecDeque::iter +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Iter<'a, T: 'a> { + ring: &'a [T], + tail: usize, + head: usize, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Iter<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail); + f.debug_tuple("Iter").field(&front).field(&back).finish() + } +} + +// FIXME(#26925) Remove in favor of `#[derive(Clone)]` +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Iter<'_, T> { + fn clone(&self) -> Self { + Iter { ring: self.ring, tail: self.tail, head: self.head } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> Iterator for Iter<'a, T> { + type Item = &'a T; + + #[inline] + fn next(&mut self) -> Option<&'a T> { + if self.tail == self.head { + return None; + } + let tail = self.tail; + self.tail = wrap_index(self.tail.wrapping_add(1), self.ring.len()); + unsafe { Some(self.ring.get_unchecked(tail)) } + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + let len = count(self.tail, self.head, self.ring.len()); + (len, Some(len)) + } + + fn fold(self, mut accum: Acc, mut f: F) -> Acc + where + F: FnMut(Acc, Self::Item) -> Acc, + { + let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail); + accum = front.iter().fold(accum, &mut f); + back.iter().fold(accum, &mut f) + } + + fn try_fold(&mut self, init: B, mut f: F) -> R + where + Self: Sized, + F: FnMut(B, Self::Item) -> R, + R: Try, + { + let (mut iter, final_res); + if self.tail <= self.head { + // single slice self.ring[self.tail..self.head] + iter = self.ring[self.tail..self.head].iter(); + final_res = iter.try_fold(init, &mut f); + } else { + // two slices: self.ring[self.tail..], self.ring[..self.head] + let (front, back) = self.ring.split_at(self.tail); + let mut back_iter = back.iter(); + let res = back_iter.try_fold(init, &mut f); + let len = self.ring.len(); + self.tail = (self.ring.len() - back_iter.len()) & (len - 1); + iter = front[..self.head].iter(); + final_res = iter.try_fold(res?, &mut f); + } + self.tail = self.head - iter.len(); + final_res + } + + fn nth(&mut self, n: usize) -> Option { + if n >= count(self.tail, self.head, self.ring.len()) { + self.tail = self.head; + None + } else { + self.tail = wrap_index(self.tail.wrapping_add(n), self.ring.len()); + self.next() + } + } + + #[inline] + fn last(mut self) -> Option<&'a T> { + self.next_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> DoubleEndedIterator for Iter<'a, T> { + #[inline] + fn next_back(&mut self) -> Option<&'a T> { + if self.tail == self.head { + return None; + } + self.head = wrap_index(self.head.wrapping_sub(1), self.ring.len()); + unsafe { Some(self.ring.get_unchecked(self.head)) } + } + + fn rfold(self, mut accum: Acc, mut f: F) -> Acc + where + F: FnMut(Acc, Self::Item) -> Acc, + { + let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail); + accum = back.iter().rfold(accum, &mut f); + front.iter().rfold(accum, &mut f) + } + + fn try_rfold(&mut self, init: B, mut f: F) -> R + where + Self: Sized, + F: FnMut(B, Self::Item) -> R, + R: Try, + { + let (mut iter, final_res); + if self.tail <= self.head { + // single slice self.ring[self.tail..self.head] + iter = self.ring[self.tail..self.head].iter(); + final_res = iter.try_rfold(init, &mut f); + } else { + // two slices: self.ring[self.tail..], self.ring[..self.head] + let (front, back) = self.ring.split_at(self.tail); + let mut front_iter = front[..self.head].iter(); + let res = front_iter.try_rfold(init, &mut f); + self.head = front_iter.len(); + iter = back.iter(); + final_res = iter.try_rfold(res?, &mut f); + } + self.head = self.tail + iter.len(); + final_res + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for Iter<'_, T> { + fn is_empty(&self) -> bool { + self.head == self.tail + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Iter<'_, T> {} + +/// A mutable iterator over the elements of a `VecDeque`. +/// +/// This `struct` is created by the [`iter_mut`] method on [`VecDeque`]. See its +/// documentation for more. +/// +/// [`iter_mut`]: VecDeque::iter_mut +#[stable(feature = "rust1", since = "1.0.0")] +pub struct IterMut<'a, T: 'a> { + // Internal safety invariant: the entire slice is dereferencable. + ring: *mut [T], + tail: usize, + head: usize, + phantom: PhantomData<&'a mut [T]>, +} + +// SAFETY: we do nothing thread-local and there is no interior mutability, +// so the usual structural `Send`/`Sync` apply. +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Send for IterMut<'_, T> {} +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Sync for IterMut<'_, T> {} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for IterMut<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail); + // SAFETY: these are the elements we have not handed out yet, so aliasing is fine. + // The `IterMut` invariant also ensures everything is dereferencable. + let (front, back) = unsafe { (&*front, &*back) }; + f.debug_tuple("IterMut").field(&front).field(&back).finish() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> Iterator for IterMut<'a, T> { + type Item = &'a mut T; + + #[inline] + fn next(&mut self) -> Option<&'a mut T> { + if self.tail == self.head { + return None; + } + let tail = self.tail; + self.tail = wrap_index(self.tail.wrapping_add(1), self.ring.len()); + + unsafe { + let elem = self.ring.get_unchecked_mut(tail); + Some(&mut *elem) + } + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + let len = count(self.tail, self.head, self.ring.len()); + (len, Some(len)) + } + + fn fold(self, mut accum: Acc, mut f: F) -> Acc + where + F: FnMut(Acc, Self::Item) -> Acc, + { + let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail); + // SAFETY: these are the elements we have not handed out yet, so aliasing is fine. + // The `IterMut` invariant also ensures everything is dereferencable. + let (front, back) = unsafe { (&mut *front, &mut *back) }; + accum = front.iter_mut().fold(accum, &mut f); + back.iter_mut().fold(accum, &mut f) + } + + fn nth(&mut self, n: usize) -> Option { + if n >= count(self.tail, self.head, self.ring.len()) { + self.tail = self.head; + None + } else { + self.tail = wrap_index(self.tail.wrapping_add(n), self.ring.len()); + self.next() + } + } + + #[inline] + fn last(mut self) -> Option<&'a mut T> { + self.next_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> DoubleEndedIterator for IterMut<'a, T> { + #[inline] + fn next_back(&mut self) -> Option<&'a mut T> { + if self.tail == self.head { + return None; + } + self.head = wrap_index(self.head.wrapping_sub(1), self.ring.len()); + + unsafe { + let elem = self.ring.get_unchecked_mut(self.head); + Some(&mut *elem) + } + } + + fn rfold(self, mut accum: Acc, mut f: F) -> Acc + where + F: FnMut(Acc, Self::Item) -> Acc, + { + let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail); + // SAFETY: these are the elements we have not handed out yet, so aliasing is fine. + // The `IterMut` invariant also ensures everything is dereferencable. + let (front, back) = unsafe { (&mut *front, &mut *back) }; + accum = back.iter_mut().rfold(accum, &mut f); + front.iter_mut().rfold(accum, &mut f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for IterMut<'_, T> { + fn is_empty(&self) -> bool { + self.head == self.tail + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for IterMut<'_, T> {} + +/// An owning iterator over the elements of a `VecDeque`. +/// +/// This `struct` is created by the [`into_iter`] method on [`VecDeque`] +/// (provided by the `IntoIterator` trait). See its documentation for more. +/// +/// [`into_iter`]: VecDeque::into_iter +#[derive(Clone)] +#[stable(feature = "rust1", since = "1.0.0")] +pub struct IntoIter { + inner: VecDeque, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for IntoIter { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("IntoIter").field(&self.inner).finish() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Iterator for IntoIter { + type Item = T; + + #[inline] + fn next(&mut self) -> Option { + self.inner.pop_front() + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + let len = self.inner.len(); + (len, Some(len)) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl DoubleEndedIterator for IntoIter { + #[inline] + fn next_back(&mut self) -> Option { + self.inner.pop_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for IntoIter { + fn is_empty(&self) -> bool { + self.inner.is_empty() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for IntoIter {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialEq for VecDeque { + fn eq(&self, other: &VecDeque) -> bool { + if self.len() != other.len() { + return false; + } + let (sa, sb) = self.as_slices(); + let (oa, ob) = other.as_slices(); + if sa.len() == oa.len() { + sa == oa && sb == ob + } else if sa.len() < oa.len() { + // Always divisible in three sections, for example: + // self: [a b c|d e f] + // other: [0 1 2 3|4 5] + // front = 3, mid = 1, + // [a b c] == [0 1 2] && [d] == [3] && [e f] == [4 5] + let front = sa.len(); + let mid = oa.len() - front; + + let (oa_front, oa_mid) = oa.split_at(front); + let (sb_mid, sb_back) = sb.split_at(mid); + debug_assert_eq!(sa.len(), oa_front.len()); + debug_assert_eq!(sb_mid.len(), oa_mid.len()); + debug_assert_eq!(sb_back.len(), ob.len()); + sa == oa_front && sb_mid == oa_mid && sb_back == ob + } else { + let front = oa.len(); + let mid = sa.len() - front; + + let (sa_front, sa_mid) = sa.split_at(front); + let (ob_mid, ob_back) = ob.split_at(mid); + debug_assert_eq!(sa_front.len(), oa.len()); + debug_assert_eq!(sa_mid.len(), ob_mid.len()); + debug_assert_eq!(sb.len(), ob_back.len()); + sa_front == oa && sa_mid == ob_mid && sb == ob_back + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Eq for VecDeque {} + +macro_rules! __impl_slice_eq1 { + ([$($vars:tt)*] $lhs:ty, $rhs:ty, $($constraints:tt)*) => { + #[stable(feature = "vec_deque_partial_eq_slice", since = "1.17.0")] + impl PartialEq<$rhs> for $lhs + where + A: PartialEq, + $($constraints)* + { + fn eq(&self, other: &$rhs) -> bool { + if self.len() != other.len() { + return false; + } + let (sa, sb) = self.as_slices(); + let (oa, ob) = other[..].split_at(sa.len()); + sa == oa && sb == ob + } + } + } +} + +__impl_slice_eq1! { [] VecDeque, Vec, } +__impl_slice_eq1! { [] VecDeque, &[B], } +__impl_slice_eq1! { [] VecDeque, &mut [B], } +__impl_slice_eq1! { [const N: usize] VecDeque, [B; N], } +__impl_slice_eq1! { [const N: usize] VecDeque, &[B; N], } +__impl_slice_eq1! { [const N: usize] VecDeque, &mut [B; N], } + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialOrd for VecDeque { + fn partial_cmp(&self, other: &VecDeque) -> Option { + self.iter().partial_cmp(other.iter()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Ord for VecDeque { + #[inline] + fn cmp(&self, other: &VecDeque) -> Ordering { + self.iter().cmp(other.iter()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Hash for VecDeque { + fn hash(&self, state: &mut H) { + self.len().hash(state); + let (a, b) = self.as_slices(); + Hash::hash_slice(a, state); + Hash::hash_slice(b, state); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Index for VecDeque { + type Output = A; + + #[inline] + fn index(&self, index: usize) -> &A { + self.get(index).expect("Out of bounds access") + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl IndexMut for VecDeque { + #[inline] + fn index_mut(&mut self, index: usize) -> &mut A { + self.get_mut(index).expect("Out of bounds access") + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl FromIterator for VecDeque { + fn from_iter>(iter: T) -> VecDeque { + let iterator = iter.into_iter(); + let (lower, _) = iterator.size_hint(); + let mut deq = VecDeque::with_capacity(lower); + deq.extend(iterator); + deq + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl IntoIterator for VecDeque { + type Item = T; + type IntoIter = IntoIter; + + /// Consumes the `VecDeque` into a front-to-back iterator yielding elements by + /// value. + fn into_iter(self) -> IntoIter { + IntoIter { inner: self } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> IntoIterator for &'a VecDeque { + type Item = &'a T; + type IntoIter = Iter<'a, T>; + + fn into_iter(self) -> Iter<'a, T> { + self.iter() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> IntoIterator for &'a mut VecDeque { + type Item = &'a mut T; + type IntoIter = IterMut<'a, T>; + + fn into_iter(self) -> IterMut<'a, T> { + self.iter_mut() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Extend for VecDeque { + fn extend>(&mut self, iter: T) { + // This function should be the moral equivalent of: + // + // for item in iter.into_iter() { + // self.push_back(item); + // } + let mut iter = iter.into_iter(); + while let Some(element) = iter.next() { + if self.len() == self.capacity() { + let (lower, _) = iter.size_hint(); + self.reserve(lower.saturating_add(1)); + } + + let head = self.head; + self.head = self.wrap_add(self.head, 1); + unsafe { + self.buffer_write(head, element); + } + } + } + + #[inline] + fn extend_one(&mut self, elem: A) { + self.push_back(elem); + } + + #[inline] + fn extend_reserve(&mut self, additional: usize) { + self.reserve(additional); + } +} + +#[stable(feature = "extend_ref", since = "1.2.0")] +impl<'a, T: 'a + Copy> Extend<&'a T> for VecDeque { + fn extend>(&mut self, iter: I) { + self.extend(iter.into_iter().cloned()); + } + + #[inline] + fn extend_one(&mut self, &elem: &T) { + self.push_back(elem); + } + + #[inline] + fn extend_reserve(&mut self, additional: usize) { + self.reserve(additional); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Debug for VecDeque { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self).finish() + } +} + +#[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")] +impl From> for VecDeque { + /// Turn a [`Vec`] into a [`VecDeque`]. + /// + /// [`Vec`]: crate::vec::Vec + /// [`VecDeque`]: crate::collections::VecDeque + /// + /// This avoids reallocating where possible, but the conditions for that are + /// strict, and subject to change, and so shouldn't be relied upon unless the + /// `Vec` came from `From>` and hasn't been reallocated. + fn from(other: Vec) -> Self { + unsafe { + let mut other = ManuallyDrop::new(other); + let other_buf = other.as_mut_ptr(); + let mut buf = RawVec::from_raw_parts(other_buf, other.capacity()); + let len = other.len(); + + // We need to extend the buf if it's not a power of two, too small + // or doesn't have at least one free space + if !buf.capacity().is_power_of_two() + || (buf.capacity() < (MINIMUM_CAPACITY + 1)) + || (buf.capacity() == len) + { + let cap = cmp::max(buf.capacity() + 1, MINIMUM_CAPACITY + 1).next_power_of_two(); + buf.reserve_exact(len, cap - len); + } + + VecDeque { tail: 0, head: len, buf } + } + } +} + +#[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")] +impl From> for Vec { + /// Turn a [`VecDeque`] into a [`Vec`]. + /// + /// [`Vec`]: crate::vec::Vec + /// [`VecDeque`]: crate::collections::VecDeque + /// + /// This never needs to re-allocate, but does need to do *O*(*n*) data movement if + /// the circular buffer doesn't happen to be at the beginning of the allocation. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// // This one is *O*(1). + /// let deque: VecDeque<_> = (1..5).collect(); + /// let ptr = deque.as_slices().0.as_ptr(); + /// let vec = Vec::from(deque); + /// assert_eq!(vec, [1, 2, 3, 4]); + /// assert_eq!(vec.as_ptr(), ptr); + /// + /// // This one needs data rearranging. + /// let mut deque: VecDeque<_> = (1..5).collect(); + /// deque.push_front(9); + /// deque.push_front(8); + /// let ptr = deque.as_slices().1.as_ptr(); + /// let vec = Vec::from(deque); + /// assert_eq!(vec, [8, 9, 1, 2, 3, 4]); + /// assert_eq!(vec.as_ptr(), ptr); + /// ``` + fn from(mut other: VecDeque) -> Self { + other.make_contiguous(); + + unsafe { + let other = ManuallyDrop::new(other); + let buf = other.buf.ptr(); + let len = other.len(); + let cap = other.cap(); + + if other.tail != 0 { + ptr::copy(buf.add(other.tail), buf, len); + } + Vec::from_raw_parts(buf, len, cap) + } + } +} diff --git a/libgrust/rustc-lib/alloc/src/collections/vec_deque/drain.rs b/libgrust/rustc-lib/alloc/src/collections/vec_deque/drain.rs new file mode 100644 index 000000000000..4ffb435d1e36 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/vec_deque/drain.rs @@ -0,0 +1,125 @@ +use core::iter::FusedIterator; +use core::ptr::{self, NonNull}; +use core::{fmt, mem}; + +use super::{count, Iter, VecDeque}; + +/// A draining iterator over the elements of a `VecDeque`. +/// +/// This `struct` is created by the [`drain`] method on [`VecDeque`]. See its +/// documentation for more. +/// +/// [`drain`]: VecDeque::drain +#[stable(feature = "drain", since = "1.6.0")] +pub struct Drain<'a, T: 'a> { + pub(crate) after_tail: usize, + pub(crate) after_head: usize, + pub(crate) iter: Iter<'a, T>, + pub(crate) deque: NonNull>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Drain<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Drain") + .field(&self.after_tail) + .field(&self.after_head) + .field(&self.iter) + .finish() + } +} + +#[stable(feature = "drain", since = "1.6.0")] +unsafe impl Sync for Drain<'_, T> {} +#[stable(feature = "drain", since = "1.6.0")] +unsafe impl Send for Drain<'_, T> {} + +#[stable(feature = "drain", since = "1.6.0")] +impl Drop for Drain<'_, T> { + fn drop(&mut self) { + struct DropGuard<'r, 'a, T>(&'r mut Drain<'a, T>); + + impl<'r, 'a, T> Drop for DropGuard<'r, 'a, T> { + fn drop(&mut self) { + self.0.for_each(drop); + + let source_deque = unsafe { self.0.deque.as_mut() }; + + // T = source_deque_tail; H = source_deque_head; t = drain_tail; h = drain_head + // + // T t h H + // [. . . o o x x o o . . .] + // + let orig_tail = source_deque.tail; + let drain_tail = source_deque.head; + let drain_head = self.0.after_tail; + let orig_head = self.0.after_head; + + let tail_len = count(orig_tail, drain_tail, source_deque.cap()); + let head_len = count(drain_head, orig_head, source_deque.cap()); + + // Restore the original head value + source_deque.head = orig_head; + + match (tail_len, head_len) { + (0, 0) => { + source_deque.head = 0; + source_deque.tail = 0; + } + (0, _) => { + source_deque.tail = drain_head; + } + (_, 0) => { + source_deque.head = drain_tail; + } + _ => unsafe { + if tail_len <= head_len { + source_deque.tail = source_deque.wrap_sub(drain_head, tail_len); + source_deque.wrap_copy(source_deque.tail, orig_tail, tail_len); + } else { + source_deque.head = source_deque.wrap_add(drain_tail, head_len); + source_deque.wrap_copy(drain_tail, drain_head, head_len); + } + }, + } + } + } + + while let Some(item) = self.next() { + let guard = DropGuard(self); + drop(item); + mem::forget(guard); + } + + DropGuard(self); + } +} + +#[stable(feature = "drain", since = "1.6.0")] +impl Iterator for Drain<'_, T> { + type Item = T; + + #[inline] + fn next(&mut self) -> Option { + self.iter.next().map(|elt| unsafe { ptr::read(elt) }) + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } +} + +#[stable(feature = "drain", since = "1.6.0")] +impl DoubleEndedIterator for Drain<'_, T> { + #[inline] + fn next_back(&mut self) -> Option { + self.iter.next_back().map(|elt| unsafe { ptr::read(elt) }) + } +} + +#[stable(feature = "drain", since = "1.6.0")] +impl ExactSizeIterator for Drain<'_, T> {} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Drain<'_, T> {} diff --git a/libgrust/rustc-lib/alloc/src/collections/vec_deque/tests.rs b/libgrust/rustc-lib/alloc/src/collections/vec_deque/tests.rs new file mode 100644 index 000000000000..21f52af056b2 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/collections/vec_deque/tests.rs @@ -0,0 +1,586 @@ +use super::*; + +#[bench] +#[cfg_attr(miri, ignore)] // isolated Miri does not support benchmarks +fn bench_push_back_100(b: &mut test::Bencher) { + let mut deq = VecDeque::with_capacity(101); + b.iter(|| { + for i in 0..100 { + deq.push_back(i); + } + deq.head = 0; + deq.tail = 0; + }) +} + +#[bench] +#[cfg_attr(miri, ignore)] // isolated Miri does not support benchmarks +fn bench_push_front_100(b: &mut test::Bencher) { + let mut deq = VecDeque::with_capacity(101); + b.iter(|| { + for i in 0..100 { + deq.push_front(i); + } + deq.head = 0; + deq.tail = 0; + }) +} + +#[bench] +#[cfg_attr(miri, ignore)] // isolated Miri does not support benchmarks +fn bench_pop_back_100(b: &mut test::Bencher) { + let mut deq = VecDeque::::with_capacity(101); + + b.iter(|| { + deq.head = 100; + deq.tail = 0; + while !deq.is_empty() { + test::black_box(deq.pop_back()); + } + }) +} + +#[bench] +#[cfg_attr(miri, ignore)] // isolated Miri does not support benchmarks +fn bench_pop_front_100(b: &mut test::Bencher) { + let mut deq = VecDeque::::with_capacity(101); + + b.iter(|| { + deq.head = 100; + deq.tail = 0; + while !deq.is_empty() { + test::black_box(deq.pop_front()); + } + }) +} + +#[test] +fn test_swap_front_back_remove() { + fn test(back: bool) { + // This test checks that every single combination of tail position and length is tested. + // Capacity 15 should be large enough to cover every case. + let mut tester = VecDeque::with_capacity(15); + let usable_cap = tester.capacity(); + let final_len = usable_cap / 2; + + for len in 0..final_len { + let expected: VecDeque<_> = + if back { (0..len).collect() } else { (0..len).rev().collect() }; + for tail_pos in 0..usable_cap { + tester.tail = tail_pos; + tester.head = tail_pos; + if back { + for i in 0..len * 2 { + tester.push_front(i); + } + for i in 0..len { + assert_eq!(tester.swap_remove_back(i), Some(len * 2 - 1 - i)); + } + } else { + for i in 0..len * 2 { + tester.push_back(i); + } + for i in 0..len { + let idx = tester.len() - 1 - i; + assert_eq!(tester.swap_remove_front(idx), Some(len * 2 - 1 - i)); + } + } + assert!(tester.tail < tester.cap()); + assert!(tester.head < tester.cap()); + assert_eq!(tester, expected); + } + } + } + test(true); + test(false); +} + +#[test] +fn test_insert() { + // This test checks that every single combination of tail position, length, and + // insertion position is tested. Capacity 15 should be large enough to cover every case. + + let mut tester = VecDeque::with_capacity(15); + // can't guarantee we got 15, so have to get what we got. + // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else + // this test isn't covering what it wants to + let cap = tester.capacity(); + + // len is the length *after* insertion + let minlen = if cfg!(miri) { cap - 1 } else { 1 }; // Miri is too slow + for len in minlen..cap { + // 0, 1, 2, .., len - 1 + let expected = (0..).take(len).collect::>(); + for tail_pos in 0..cap { + for to_insert in 0..len { + tester.tail = tail_pos; + tester.head = tail_pos; + for i in 0..len { + if i != to_insert { + tester.push_back(i); + } + } + tester.insert(to_insert, to_insert); + assert!(tester.tail < tester.cap()); + assert!(tester.head < tester.cap()); + assert_eq!(tester, expected); + } + } + } +} + +#[test] +fn make_contiguous_big_tail() { + let mut tester = VecDeque::with_capacity(15); + + for i in 0..3 { + tester.push_back(i); + } + + for i in 3..10 { + tester.push_front(i); + } + + // 012......9876543 + assert_eq!(tester.capacity(), 15); + assert_eq!((&[9, 8, 7, 6, 5, 4, 3] as &[_], &[0, 1, 2] as &[_]), tester.as_slices()); + + let expected_start = tester.head; + tester.make_contiguous(); + assert_eq!(tester.tail, expected_start); + assert_eq!((&[9, 8, 7, 6, 5, 4, 3, 0, 1, 2] as &[_], &[] as &[_]), tester.as_slices()); +} + +#[test] +fn make_contiguous_big_head() { + let mut tester = VecDeque::with_capacity(15); + + for i in 0..8 { + tester.push_back(i); + } + + for i in 8..10 { + tester.push_front(i); + } + + // 01234567......98 + let expected_start = 0; + tester.make_contiguous(); + assert_eq!(tester.tail, expected_start); + assert_eq!((&[9, 8, 0, 1, 2, 3, 4, 5, 6, 7] as &[_], &[] as &[_]), tester.as_slices()); +} + +#[test] +fn make_contiguous_small_free() { + let mut tester = VecDeque::with_capacity(15); + + for i in 'A' as u8..'I' as u8 { + tester.push_back(i as char); + } + + for i in 'I' as u8..'N' as u8 { + tester.push_front(i as char); + } + + // ABCDEFGH...MLKJI + let expected_start = 0; + tester.make_contiguous(); + assert_eq!(tester.tail, expected_start); + assert_eq!( + (&['M', 'L', 'K', 'J', 'I', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] as &[_], &[] as &[_]), + tester.as_slices() + ); + + tester.clear(); + for i in 'I' as u8..'N' as u8 { + tester.push_back(i as char); + } + + for i in 'A' as u8..'I' as u8 { + tester.push_front(i as char); + } + + // IJKLM...HGFEDCBA + let expected_start = 0; + tester.make_contiguous(); + assert_eq!(tester.tail, expected_start); + assert_eq!( + (&['H', 'G', 'F', 'E', 'D', 'C', 'B', 'A', 'I', 'J', 'K', 'L', 'M'] as &[_], &[] as &[_]), + tester.as_slices() + ); +} + +#[test] +fn make_contiguous_head_to_end() { + let mut dq = VecDeque::with_capacity(3); + dq.push_front('B'); + dq.push_front('A'); + dq.push_back('C'); + dq.make_contiguous(); + let expected_tail = 0; + let expected_head = 3; + assert_eq!(expected_tail, dq.tail); + assert_eq!(expected_head, dq.head); + assert_eq!((&['A', 'B', 'C'] as &[_], &[] as &[_]), dq.as_slices()); +} + +#[test] +fn test_remove() { + // This test checks that every single combination of tail position, length, and + // removal position is tested. Capacity 15 should be large enough to cover every case. + + let mut tester = VecDeque::with_capacity(15); + // can't guarantee we got 15, so have to get what we got. + // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else + // this test isn't covering what it wants to + let cap = tester.capacity(); + + // len is the length *after* removal + let minlen = if cfg!(miri) { cap - 2 } else { 0 }; // Miri is too slow + for len in minlen..cap - 1 { + // 0, 1, 2, .., len - 1 + let expected = (0..).take(len).collect::>(); + for tail_pos in 0..cap { + for to_remove in 0..=len { + tester.tail = tail_pos; + tester.head = tail_pos; + for i in 0..len { + if i == to_remove { + tester.push_back(1234); + } + tester.push_back(i); + } + if to_remove == len { + tester.push_back(1234); + } + tester.remove(to_remove); + assert!(tester.tail < tester.cap()); + assert!(tester.head < tester.cap()); + assert_eq!(tester, expected); + } + } + } +} + +#[test] +fn test_range() { + let mut tester: VecDeque = VecDeque::with_capacity(7); + + let cap = tester.capacity(); + let minlen = if cfg!(miri) { cap - 1 } else { 0 }; // Miri is too slow + for len in minlen..=cap { + for tail in 0..=cap { + for start in 0..=len { + for end in start..=len { + tester.tail = tail; + tester.head = tail; + for i in 0..len { + tester.push_back(i); + } + + // Check that we iterate over the correct values + let range: VecDeque<_> = tester.range(start..end).copied().collect(); + let expected: VecDeque<_> = (start..end).collect(); + assert_eq!(range, expected); + } + } + } + } +} + +#[test] +fn test_range_mut() { + let mut tester: VecDeque = VecDeque::with_capacity(7); + + let cap = tester.capacity(); + for len in 0..=cap { + for tail in 0..=cap { + for start in 0..=len { + for end in start..=len { + tester.tail = tail; + tester.head = tail; + for i in 0..len { + tester.push_back(i); + } + + let head_was = tester.head; + let tail_was = tester.tail; + + // Check that we iterate over the correct values + let range: VecDeque<_> = tester.range_mut(start..end).map(|v| *v).collect(); + let expected: VecDeque<_> = (start..end).collect(); + assert_eq!(range, expected); + + // We shouldn't have changed the capacity or made the + // head or tail out of bounds + assert_eq!(tester.capacity(), cap); + assert_eq!(tester.tail, tail_was); + assert_eq!(tester.head, head_was); + } + } + } + } +} + +#[test] +fn test_drain() { + let mut tester: VecDeque = VecDeque::with_capacity(7); + + let cap = tester.capacity(); + for len in 0..=cap { + for tail in 0..=cap { + for drain_start in 0..=len { + for drain_end in drain_start..=len { + tester.tail = tail; + tester.head = tail; + for i in 0..len { + tester.push_back(i); + } + + // Check that we drain the correct values + let drained: VecDeque<_> = tester.drain(drain_start..drain_end).collect(); + let drained_expected: VecDeque<_> = (drain_start..drain_end).collect(); + assert_eq!(drained, drained_expected); + + // We shouldn't have changed the capacity or made the + // head or tail out of bounds + assert_eq!(tester.capacity(), cap); + assert!(tester.tail < tester.cap()); + assert!(tester.head < tester.cap()); + + // We should see the correct values in the VecDeque + let expected: VecDeque<_> = (0..drain_start).chain(drain_end..len).collect(); + assert_eq!(expected, tester); + } + } + } + } +} + +#[test] +fn test_shrink_to_fit() { + // This test checks that every single combination of head and tail position, + // is tested. Capacity 15 should be large enough to cover every case. + + let mut tester = VecDeque::with_capacity(15); + // can't guarantee we got 15, so have to get what we got. + // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else + // this test isn't covering what it wants to + let cap = tester.capacity(); + tester.reserve(63); + let max_cap = tester.capacity(); + + for len in 0..=cap { + // 0, 1, 2, .., len - 1 + let expected = (0..).take(len).collect::>(); + for tail_pos in 0..=max_cap { + tester.tail = tail_pos; + tester.head = tail_pos; + tester.reserve(63); + for i in 0..len { + tester.push_back(i); + } + tester.shrink_to_fit(); + assert!(tester.capacity() <= cap); + assert!(tester.tail < tester.cap()); + assert!(tester.head < tester.cap()); + assert_eq!(tester, expected); + } + } +} + +#[test] +fn test_split_off() { + // This test checks that every single combination of tail position, length, and + // split position is tested. Capacity 15 should be large enough to cover every case. + + let mut tester = VecDeque::with_capacity(15); + // can't guarantee we got 15, so have to get what we got. + // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else + // this test isn't covering what it wants to + let cap = tester.capacity(); + + // len is the length *before* splitting + let minlen = if cfg!(miri) { cap - 1 } else { 0 }; // Miri is too slow + for len in minlen..cap { + // index to split at + for at in 0..=len { + // 0, 1, 2, .., at - 1 (may be empty) + let expected_self = (0..).take(at).collect::>(); + // at, at + 1, .., len - 1 (may be empty) + let expected_other = (at..).take(len - at).collect::>(); + + for tail_pos in 0..cap { + tester.tail = tail_pos; + tester.head = tail_pos; + for i in 0..len { + tester.push_back(i); + } + let result = tester.split_off(at); + assert!(tester.tail < tester.cap()); + assert!(tester.head < tester.cap()); + assert!(result.tail < result.cap()); + assert!(result.head < result.cap()); + assert_eq!(tester, expected_self); + assert_eq!(result, expected_other); + } + } + } +} + +#[test] +fn test_from_vec() { + use crate::vec::Vec; + for cap in 0..35 { + for len in 0..=cap { + let mut vec = Vec::with_capacity(cap); + vec.extend(0..len); + + let vd = VecDeque::from(vec.clone()); + assert!(vd.cap().is_power_of_two()); + assert_eq!(vd.len(), vec.len()); + assert!(vd.into_iter().eq(vec)); + } + } +} + +#[test] +fn test_vec_from_vecdeque() { + use crate::vec::Vec; + + fn create_vec_and_test_convert(capacity: usize, offset: usize, len: usize) { + let mut vd = VecDeque::with_capacity(capacity); + for _ in 0..offset { + vd.push_back(0); + vd.pop_front(); + } + vd.extend(0..len); + + let vec: Vec<_> = Vec::from(vd.clone()); + assert_eq!(vec.len(), vd.len()); + assert!(vec.into_iter().eq(vd)); + } + + // Miri is too slow + let max_pwr = if cfg!(miri) { 5 } else { 7 }; + + for cap_pwr in 0..max_pwr { + // Make capacity as a (2^x)-1, so that the ring size is 2^x + let cap = (2i32.pow(cap_pwr) - 1) as usize; + + // In these cases there is enough free space to solve it with copies + for len in 0..((cap + 1) / 2) { + // Test contiguous cases + for offset in 0..(cap - len) { + create_vec_and_test_convert(cap, offset, len) + } + + // Test cases where block at end of buffer is bigger than block at start + for offset in (cap - len)..(cap - (len / 2)) { + create_vec_and_test_convert(cap, offset, len) + } + + // Test cases where block at start of buffer is bigger than block at end + for offset in (cap - (len / 2))..cap { + create_vec_and_test_convert(cap, offset, len) + } + } + + // Now there's not (necessarily) space to straighten the ring with simple copies, + // the ring will use swapping when: + // (cap + 1 - offset) > (cap + 1 - len) && (len - (cap + 1 - offset)) > (cap + 1 - len)) + // right block size > free space && left block size > free space + for len in ((cap + 1) / 2)..cap { + // Test contiguous cases + for offset in 0..(cap - len) { + create_vec_and_test_convert(cap, offset, len) + } + + // Test cases where block at end of buffer is bigger than block at start + for offset in (cap - len)..(cap - (len / 2)) { + create_vec_and_test_convert(cap, offset, len) + } + + // Test cases where block at start of buffer is bigger than block at end + for offset in (cap - (len / 2))..cap { + create_vec_and_test_convert(cap, offset, len) + } + } + } +} + +#[test] +fn test_clone_from() { + let m = vec![1; 8]; + let n = vec![2; 12]; + let limit = if cfg!(miri) { 4 } else { 8 }; // Miri is too slow + for pfv in 0..limit { + for pfu in 0..limit { + for longer in 0..2 { + let (vr, ur) = if longer == 0 { (&m, &n) } else { (&n, &m) }; + let mut v = VecDeque::from(vr.clone()); + for _ in 0..pfv { + v.push_front(1); + } + let mut u = VecDeque::from(ur.clone()); + for _ in 0..pfu { + u.push_front(2); + } + v.clone_from(&u); + assert_eq!(&v, &u); + } + } + } +} + +#[test] +fn test_vec_deque_truncate_drop() { + static mut DROPS: u32 = 0; + #[derive(Clone)] + struct Elem(i32); + impl Drop for Elem { + fn drop(&mut self) { + unsafe { + DROPS += 1; + } + } + } + + let v = vec![Elem(1), Elem(2), Elem(3), Elem(4), Elem(5)]; + for push_front in 0..=v.len() { + let v = v.clone(); + let mut tester = VecDeque::with_capacity(5); + for (index, elem) in v.into_iter().enumerate() { + if index < push_front { + tester.push_front(elem); + } else { + tester.push_back(elem); + } + } + assert_eq!(unsafe { DROPS }, 0); + tester.truncate(3); + assert_eq!(unsafe { DROPS }, 2); + tester.truncate(0); + assert_eq!(unsafe { DROPS }, 5); + unsafe { + DROPS = 0; + } + } +} + +#[test] +fn issue_53529() { + use crate::boxed::Box; + + let mut dst = VecDeque::new(); + dst.push_front(Box::new(1)); + dst.push_front(Box::new(2)); + assert_eq!(*dst.pop_back().unwrap(), 1); + + let mut src = VecDeque::new(); + src.push_front(Box::new(2)); + dst.append(&mut src); + for a in dst { + assert_eq!(*a, 2); + } +} diff --git a/libgrust/rustc-lib/alloc/src/fmt.rs b/libgrust/rustc-lib/alloc/src/fmt.rs new file mode 100644 index 000000000000..5ebc4d6c4c14 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/fmt.rs @@ -0,0 +1,579 @@ +//! Utilities for formatting and printing `String`s. +//! +//! This module contains the runtime support for the [`format!`] syntax extension. +//! This macro is implemented in the compiler to emit calls to this module in +//! order to format arguments at runtime into strings. +//! +//! # Usage +//! +//! The [`format!`] macro is intended to be familiar to those coming from C's +//! `printf`/`fprintf` functions or Python's `str.format` function. +//! +//! Some examples of the [`format!`] extension are: +//! +//! ``` +//! format!("Hello"); // => "Hello" +//! format!("Hello, {}!", "world"); // => "Hello, world!" +//! format!("The number is {}", 1); // => "The number is 1" +//! format!("{:?}", (3, 4)); // => "(3, 4)" +//! format!("{value}", value=4); // => "4" +//! format!("{} {}", 1, 2); // => "1 2" +//! format!("{:04}", 42); // => "0042" with leading zeros +//! ``` +//! +//! From these, you can see that the first argument is a format string. It is +//! required by the compiler for this to be a string literal; it cannot be a +//! variable passed in (in order to perform validity checking). The compiler +//! will then parse the format string and determine if the list of arguments +//! provided is suitable to pass to this format string. +//! +//! To convert a single value to a string, use the [`to_string`] method. This +//! will use the [`Display`] formatting trait. +//! +//! ## Positional parameters +//! +//! Each formatting argument is allowed to specify which value argument it's +//! referencing, and if omitted it is assumed to be "the next argument". For +//! example, the format string `{} {} {}` would take three parameters, and they +//! would be formatted in the same order as they're given. The format string +//! `{2} {1} {0}`, however, would format arguments in reverse order. +//! +//! Things can get a little tricky once you start intermingling the two types of +//! positional specifiers. The "next argument" specifier can be thought of as an +//! iterator over the argument. Each time a "next argument" specifier is seen, +//! the iterator advances. This leads to behavior like this: +//! +//! ``` +//! format!("{1} {} {0} {}", 1, 2); // => "2 1 1 2" +//! ``` +//! +//! The internal iterator over the argument has not been advanced by the time +//! the first `{}` is seen, so it prints the first argument. Then upon reaching +//! the second `{}`, the iterator has advanced forward to the second argument. +//! Essentially, parameters that explicitly name their argument do not affect +//! parameters that do not name an argument in terms of positional specifiers. +//! +//! A format string is required to use all of its arguments, otherwise it is a +//! compile-time error. You may refer to the same argument more than once in the +//! format string. +//! +//! ## Named parameters +//! +//! Rust itself does not have a Python-like equivalent of named parameters to a +//! function, but the [`format!`] macro is a syntax extension that allows it to +//! leverage named parameters. Named parameters are listed at the end of the +//! argument list and have the syntax: +//! +//! ```text +//! identifier '=' expression +//! ``` +//! +//! For example, the following [`format!`] expressions all use named argument: +//! +//! ``` +//! format!("{argument}", argument = "test"); // => "test" +//! format!("{name} {}", 1, name = 2); // => "2 1" +//! format!("{a} {c} {b}", a="a", b='b', c=3); // => "a 3 b" +//! ``` +//! +//! It is not valid to put positional parameters (those without names) after +//! arguments that have names. Like with positional parameters, it is not +//! valid to provide named parameters that are unused by the format string. +//! +//! # Formatting Parameters +//! +//! Each argument being formatted can be transformed by a number of formatting +//! parameters (corresponding to `format_spec` in [the syntax](#syntax)). These +//! parameters affect the string representation of what's being formatted. +//! +//! ## Width +//! +//! ``` +//! // All of these print "Hello x !" +//! println!("Hello {:5}!", "x"); +//! println!("Hello {:1$}!", "x", 5); +//! println!("Hello {1:0$}!", 5, "x"); +//! println!("Hello {:width$}!", "x", width = 5); +//! ``` +//! +//! This is a parameter for the "minimum width" that the format should take up. +//! If the value's string does not fill up this many characters, then the +//! padding specified by fill/alignment will be used to take up the required +//! space (see below). +//! +//! The value for the width can also be provided as a [`usize`] in the list of +//! parameters by adding a postfix `$`, indicating that the second argument is +//! a [`usize`] specifying the width. +//! +//! Referring to an argument with the dollar syntax does not affect the "next +//! argument" counter, so it's usually a good idea to refer to arguments by +//! position, or use named arguments. +//! +//! ## Fill/Alignment +//! +//! ``` +//! assert_eq!(format!("Hello {:<5}!", "x"), "Hello x !"); +//! assert_eq!(format!("Hello {:-<5}!", "x"), "Hello x----!"); +//! assert_eq!(format!("Hello {:^5}!", "x"), "Hello x !"); +//! assert_eq!(format!("Hello {:>5}!", "x"), "Hello x!"); +//! ``` +//! +//! The optional fill character and alignment is provided normally in conjunction with the +//! [`width`](#width) parameter. It must be defined before `width`, right after the `:`. +//! This indicates that if the value being formatted is smaller than +//! `width` some extra characters will be printed around it. +//! Filling comes in the following variants for different alignments: +//! +//! * `[fill]<` - the argument is left-aligned in `width` columns +//! * `[fill]^` - the argument is center-aligned in `width` columns +//! * `[fill]>` - the argument is right-aligned in `width` columns +//! +//! The default [fill/alignment](#fillalignment) for non-numerics is a space and +//! left-aligned. The +//! default for numeric formatters is also a space character but with right-alignment. If +//! the `0` flag (see below) is specified for numerics, then the implicit fill character is +//! `0`. +//! +//! Note that alignment may not be implemented by some types. In particular, it +//! is not generally implemented for the `Debug` trait. A good way to ensure +//! padding is applied is to format your input, then pad this resulting string +//! to obtain your output: +//! +//! ``` +//! println!("Hello {:^15}!", format!("{:?}", Some("hi"))); // => "Hello Some("hi") !" +//! ``` +//! +//! ## Sign/`#`/`0` +//! +//! ``` +//! assert_eq!(format!("Hello {:+}!", 5), "Hello +5!"); +//! assert_eq!(format!("{:#x}!", 27), "0x1b!"); +//! assert_eq!(format!("Hello {:05}!", 5), "Hello 00005!"); +//! assert_eq!(format!("Hello {:05}!", -5), "Hello -0005!"); +//! assert_eq!(format!("{:#010x}!", 27), "0x0000001b!"); +//! ``` +//! +//! These are all flags altering the behavior of the formatter. +//! +//! * `+` - This is intended for numeric types and indicates that the sign +//! should always be printed. Positive signs are never printed by +//! default, and the negative sign is only printed by default for the +//! `Signed` trait. This flag indicates that the correct sign (`+` or `-`) +//! should always be printed. +//! * `-` - Currently not used +//! * `#` - This flag indicates that the "alternate" form of printing should +//! be used. The alternate forms are: +//! * `#?` - pretty-print the [`Debug`] formatting +//! * `#x` - precedes the argument with a `0x` +//! * `#X` - precedes the argument with a `0x` +//! * `#b` - precedes the argument with a `0b` +//! * `#o` - precedes the argument with a `0o` +//! * `0` - This is used to indicate for integer formats that the padding to `width` should +//! both be done with a `0` character as well as be sign-aware. A format +//! like `{:08}` would yield `00000001` for the integer `1`, while the +//! same format would yield `-0000001` for the integer `-1`. Notice that +//! the negative version has one fewer zero than the positive version. +//! Note that padding zeros are always placed after the sign (if any) +//! and before the digits. When used together with the `#` flag, a similar +//! rule applies: padding zeros are inserted after the prefix but before +//! the digits. The prefix is included in the total width. +//! +//! ## Precision +//! +//! For non-numeric types, this can be considered a "maximum width". If the resulting string is +//! longer than this width, then it is truncated down to this many characters and that truncated +//! value is emitted with proper `fill`, `alignment` and `width` if those parameters are set. +//! +//! For integral types, this is ignored. +//! +//! For floating-point types, this indicates how many digits after the decimal point should be +//! printed. +//! +//! There are three possible ways to specify the desired `precision`: +//! +//! 1. An integer `.N`: +//! +//! the integer `N` itself is the precision. +//! +//! 2. An integer or name followed by dollar sign `.N$`: +//! +//! use format *argument* `N` (which must be a `usize`) as the precision. +//! +//! 3. An asterisk `.*`: +//! +//! `.*` means that this `{...}` is associated with *two* format inputs rather than one: the +//! first input holds the `usize` precision, and the second holds the value to print. Note that +//! in this case, if one uses the format string `{:.*}`, then the `` part refers +//! to the *value* to print, and the `precision` must come in the input preceding ``. +//! +//! For example, the following calls all print the same thing `Hello x is 0.01000`: +//! +//! ``` +//! // Hello {arg 0 ("x")} is {arg 1 (0.01) with precision specified inline (5)} +//! println!("Hello {0} is {1:.5}", "x", 0.01); +//! +//! // Hello {arg 1 ("x")} is {arg 2 (0.01) with precision specified in arg 0 (5)} +//! println!("Hello {1} is {2:.0$}", 5, "x", 0.01); +//! +//! // Hello {arg 0 ("x")} is {arg 2 (0.01) with precision specified in arg 1 (5)} +//! println!("Hello {0} is {2:.1$}", "x", 5, 0.01); +//! +//! // Hello {next arg ("x")} is {second of next two args (0.01) with precision +//! // specified in first of next two args (5)} +//! println!("Hello {} is {:.*}", "x", 5, 0.01); +//! +//! // Hello {next arg ("x")} is {arg 2 (0.01) with precision +//! // specified in its predecessor (5)} +//! println!("Hello {} is {2:.*}", "x", 5, 0.01); +//! +//! // Hello {next arg ("x")} is {arg "number" (0.01) with precision specified +//! // in arg "prec" (5)} +//! println!("Hello {} is {number:.prec$}", "x", prec = 5, number = 0.01); +//! ``` +//! +//! While these: +//! +//! ``` +//! println!("{}, `{name:.*}` has 3 fractional digits", "Hello", 3, name=1234.56); +//! println!("{}, `{name:.*}` has 3 characters", "Hello", 3, name="1234.56"); +//! println!("{}, `{name:>8.*}` has 3 right-aligned characters", "Hello", 3, name="1234.56"); +//! ``` +//! +//! print three significantly different things: +//! +//! ```text +//! Hello, `1234.560` has 3 fractional digits +//! Hello, `123` has 3 characters +//! Hello, ` 123` has 3 right-aligned characters +//! ``` +//! +//! ## Localization +//! +//! In some programming languages, the behavior of string formatting functions +//! depends on the operating system's locale setting. The format functions +//! provided by Rust's standard library do not have any concept of locale and +//! will produce the same results on all systems regardless of user +//! configuration. +//! +//! For example, the following code will always print `1.5` even if the system +//! locale uses a decimal separator other than a dot. +//! +//! ``` +//! println!("The value is {}", 1.5); +//! ``` +//! +//! # Escaping +//! +//! The literal characters `{` and `}` may be included in a string by preceding +//! them with the same character. For example, the `{` character is escaped with +//! `{{` and the `}` character is escaped with `}}`. +//! +//! ``` +//! assert_eq!(format!("Hello {{}}"), "Hello {}"); +//! assert_eq!(format!("{{ Hello"), "{ Hello"); +//! ``` +//! +//! # Syntax +//! +//! To summarize, here you can find the full grammar of format strings. +//! The syntax for the formatting language used is drawn from other languages, +//! so it should not be too alien. Arguments are formatted with Python-like +//! syntax, meaning that arguments are surrounded by `{}` instead of the C-like +//! `%`. The actual grammar for the formatting syntax is: +//! +//! ```text +//! format_string := [ maybe-format ] * +//! maybe-format := '{' '{' | '}' '}' | +//! format := '{' [ argument ] [ ':' format_spec ] '}' +//! argument := integer | identifier +//! +//! format_spec := [[fill]align][sign]['#']['0'][width]['.' precision][type] +//! fill := character +//! align := '<' | '^' | '>' +//! sign := '+' | '-' +//! width := count +//! precision := count | '*' +//! type := identifier | '?' | '' +//! count := parameter | integer +//! parameter := argument '$' +//! ``` +//! +//! # Formatting traits +//! +//! When requesting that an argument be formatted with a particular type, you +//! are actually requesting that an argument ascribes to a particular trait. +//! This allows multiple actual types to be formatted via `{:x}` (like [`i8`] as +//! well as [`isize`]). The current mapping of types to traits is: +//! +//! * *nothing* ⇒ [`Display`] +//! * `?` ⇒ [`Debug`] +//! * `x?` ⇒ [`Debug`] with lower-case hexadecimal integers +//! * `X?` ⇒ [`Debug`] with upper-case hexadecimal integers +//! * `o` ⇒ [`Octal`] +//! * `x` ⇒ [`LowerHex`] +//! * `X` ⇒ [`UpperHex`] +//! * `p` ⇒ [`Pointer`] +//! * `b` ⇒ [`Binary`] +//! * `e` ⇒ [`LowerExp`] +//! * `E` ⇒ [`UpperExp`] +//! +//! What this means is that any type of argument which implements the +//! [`fmt::Binary`][`Binary`] trait can then be formatted with `{:b}`. Implementations +//! are provided for these traits for a number of primitive types by the +//! standard library as well. If no format is specified (as in `{}` or `{:6}`), +//! then the format trait used is the [`Display`] trait. +//! +//! When implementing a format trait for your own type, you will have to +//! implement a method of the signature: +//! +//! ``` +//! # #![allow(dead_code)] +//! # use std::fmt; +//! # struct Foo; // our custom type +//! # impl fmt::Display for Foo { +//! fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { +//! # write!(f, "testing, testing") +//! # } } +//! ``` +//! +//! Your type will be passed as `self` by-reference, and then the function +//! should emit output into the `f.buf` stream. It is up to each format trait +//! implementation to correctly adhere to the requested formatting parameters. +//! The values of these parameters will be listed in the fields of the +//! [`Formatter`] struct. In order to help with this, the [`Formatter`] struct also +//! provides some helper methods. +//! +//! Additionally, the return value of this function is [`fmt::Result`] which is a +//! type alias of [`Result`]`<(), `[`std::fmt::Error`]`>`. Formatting implementations +//! should ensure that they propagate errors from the [`Formatter`] (e.g., when +//! calling [`write!`]). However, they should never return errors spuriously. That +//! is, a formatting implementation must and may only return an error if the +//! passed-in [`Formatter`] returns an error. This is because, contrary to what +//! the function signature might suggest, string formatting is an infallible +//! operation. This function only returns a result because writing to the +//! underlying stream might fail and it must provide a way to propagate the fact +//! that an error has occurred back up the stack. +//! +//! An example of implementing the formatting traits would look +//! like: +//! +//! ``` +//! use std::fmt; +//! +//! #[derive(Debug)] +//! struct Vector2D { +//! x: isize, +//! y: isize, +//! } +//! +//! impl fmt::Display for Vector2D { +//! fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { +//! // The `f` value implements the `Write` trait, which is what the +//! // write! macro is expecting. Note that this formatting ignores the +//! // various flags provided to format strings. +//! write!(f, "({}, {})", self.x, self.y) +//! } +//! } +//! +//! // Different traits allow different forms of output of a type. The meaning +//! // of this format is to print the magnitude of a vector. +//! impl fmt::Binary for Vector2D { +//! fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { +//! let magnitude = (self.x * self.x + self.y * self.y) as f64; +//! let magnitude = magnitude.sqrt(); +//! +//! // Respect the formatting flags by using the helper method +//! // `pad_integral` on the Formatter object. See the method +//! // documentation for details, and the function `pad` can be used +//! // to pad strings. +//! let decimals = f.precision().unwrap_or(3); +//! let string = format!("{:.*}", decimals, magnitude); +//! f.pad_integral(true, "", &string) +//! } +//! } +//! +//! fn main() { +//! let myvector = Vector2D { x: 3, y: 4 }; +//! +//! println!("{}", myvector); // => "(3, 4)" +//! println!("{:?}", myvector); // => "Vector2D {x: 3, y:4}" +//! println!("{:10.3b}", myvector); // => " 5.000" +//! } +//! ``` +//! +//! ### `fmt::Display` vs `fmt::Debug` +//! +//! These two formatting traits have distinct purposes: +//! +//! - [`fmt::Display`][`Display`] implementations assert that the type can be faithfully +//! represented as a UTF-8 string at all times. It is **not** expected that +//! all types implement the [`Display`] trait. +//! - [`fmt::Debug`][`Debug`] implementations should be implemented for **all** public types. +//! Output will typically represent the internal state as faithfully as possible. +//! The purpose of the [`Debug`] trait is to facilitate debugging Rust code. In +//! most cases, using `#[derive(Debug)]` is sufficient and recommended. +//! +//! Some examples of the output from both traits: +//! +//! ``` +//! assert_eq!(format!("{} {:?}", 3, 4), "3 4"); +//! assert_eq!(format!("{} {:?}", 'a', 'b'), "a 'b'"); +//! assert_eq!(format!("{} {:?}", "foo\n", "bar\n"), "foo\n \"bar\\n\""); +//! ``` +//! +//! # Related macros +//! +//! There are a number of related macros in the [`format!`] family. The ones that +//! are currently implemented are: +//! +//! ```ignore (only-for-syntax-highlight) +//! format! // described above +//! write! // first argument is a &mut io::Write, the destination +//! writeln! // same as write but appends a newline +//! print! // the format string is printed to the standard output +//! println! // same as print but appends a newline +//! eprint! // the format string is printed to the standard error +//! eprintln! // same as eprint but appends a newline +//! format_args! // described below. +//! ``` +//! +//! ### `write!` +//! +//! This and [`writeln!`] are two macros which are used to emit the format string +//! to a specified stream. This is used to prevent intermediate allocations of +//! format strings and instead directly write the output. Under the hood, this +//! function is actually invoking the [`write_fmt`] function defined on the +//! [`std::io::Write`] trait. Example usage is: +//! +//! ``` +//! # #![allow(unused_must_use)] +//! use std::io::Write; +//! let mut w = Vec::new(); +//! write!(&mut w, "Hello {}!", "world"); +//! ``` +//! +//! ### `print!` +//! +//! This and [`println!`] emit their output to stdout. Similarly to the [`write!`] +//! macro, the goal of these macros is to avoid intermediate allocations when +//! printing output. Example usage is: +//! +//! ``` +//! print!("Hello {}!", "world"); +//! println!("I have a newline {}", "character at the end"); +//! ``` +//! ### `eprint!` +//! +//! The [`eprint!`] and [`eprintln!`] macros are identical to +//! [`print!`] and [`println!`], respectively, except they emit their +//! output to stderr. +//! +//! ### `format_args!` +//! +//! This is a curious macro used to safely pass around +//! an opaque object describing the format string. This object +//! does not require any heap allocations to create, and it only +//! references information on the stack. Under the hood, all of +//! the related macros are implemented in terms of this. First +//! off, some example usage is: +//! +//! ``` +//! # #![allow(unused_must_use)] +//! use std::fmt; +//! use std::io::{self, Write}; +//! +//! let mut some_writer = io::stdout(); +//! write!(&mut some_writer, "{}", format_args!("print with a {}", "macro")); +//! +//! fn my_fmt_fn(args: fmt::Arguments) { +//! write!(&mut io::stdout(), "{}", args); +//! } +//! my_fmt_fn(format_args!(", or a {} too", "function")); +//! ``` +//! +//! The result of the [`format_args!`] macro is a value of type [`fmt::Arguments`]. +//! This structure can then be passed to the [`write`] and [`format`] functions +//! inside this module in order to process the format string. +//! The goal of this macro is to even further prevent intermediate allocations +//! when dealing with formatting strings. +//! +//! For example, a logging library could use the standard formatting syntax, but +//! it would internally pass around this structure until it has been determined +//! where output should go to. +//! +//! [`fmt::Result`]: Result +//! [`Result`]: core::result::Result +//! [`std::fmt::Error`]: Error +//! [`write!`]: core::write +//! [`write`]: core::write +//! [`format!`]: crate::format +//! [`to_string`]: crate::string::ToString +//! [`writeln!`]: core::writeln +//! [`write_fmt`]: ../../std/io/trait.Write.html#method.write_fmt +//! [`std::io::Write`]: ../../std/io/trait.Write.html +//! [`print!`]: ../../std/macro.print.html +//! [`println!`]: ../../std/macro.println.html +//! [`eprint!`]: ../../std/macro.eprint.html +//! [`eprintln!`]: ../../std/macro.eprintln.html +//! [`format_args!`]: core::format_args +//! [`fmt::Arguments`]: Arguments +//! [`format`]: crate::format + +#![stable(feature = "rust1", since = "1.0.0")] + +#[unstable(feature = "fmt_internals", issue = "none")] +pub use core::fmt::rt; +#[stable(feature = "fmt_flags_align", since = "1.28.0")] +pub use core::fmt::Alignment; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::fmt::Error; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::fmt::{write, ArgumentV1, Arguments}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::fmt::{Binary, Octal}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::fmt::{Debug, Display}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::fmt::{DebugList, DebugMap, DebugSet, DebugStruct, DebugTuple}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::fmt::{Formatter, Result, Write}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::fmt::{LowerExp, UpperExp}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::fmt::{LowerHex, Pointer, UpperHex}; + +use crate::string; + +/// The `format` function takes an [`Arguments`] struct and returns the resulting +/// formatted string. +/// +/// The [`Arguments`] instance can be created with the [`format_args!`] macro. +/// +/// # Examples +/// +/// Basic usage: +/// +/// ``` +/// use std::fmt; +/// +/// let s = fmt::format(format_args!("Hello, {}!", "world")); +/// assert_eq!(s, "Hello, world!"); +/// ``` +/// +/// Please note that using [`format!`] might be preferable. +/// Example: +/// +/// ``` +/// let s = format!("Hello, {}!", "world"); +/// assert_eq!(s, "Hello, world!"); +/// ``` +/// +/// [`format_args!`]: core::format_args +/// [`format!`]: crate::format +#[stable(feature = "rust1", since = "1.0.0")] +pub fn format(args: Arguments<'_>) -> string::String { + let capacity = args.estimated_capacity(); + let mut output = string::String::with_capacity(capacity); + output.write_fmt(args).expect("a formatting trait implementation returned an error"); + output +} diff --git a/libgrust/rustc-lib/alloc/src/lib.rs b/libgrust/rustc-lib/alloc/src/lib.rs new file mode 100644 index 000000000000..f21fc8854d05 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/lib.rs @@ -0,0 +1,196 @@ +//! # The Rust core allocation and collections library +//! +//! This library provides smart pointers and collections for managing +//! heap-allocated values. +//! +//! This library, like libcore, normally doesn’t need to be used directly +//! since its contents are re-exported in the [`std` crate](../std/index.html). +//! Crates that use the `#![no_std]` attribute however will typically +//! not depend on `std`, so they’d use this crate instead. +//! +//! ## Boxed values +//! +//! The [`Box`] type is a smart pointer type. There can only be one owner of a +//! [`Box`], and the owner can decide to mutate the contents, which live on the +//! heap. +//! +//! This type can be sent among threads efficiently as the size of a `Box` value +//! is the same as that of a pointer. Tree-like data structures are often built +//! with boxes because each node often has only one owner, the parent. +//! +//! ## Reference counted pointers +//! +//! The [`Rc`] type is a non-threadsafe reference-counted pointer type intended +//! for sharing memory within a thread. An [`Rc`] pointer wraps a type, `T`, and +//! only allows access to `&T`, a shared reference. +//! +//! This type is useful when inherited mutability (such as using [`Box`]) is too +//! constraining for an application, and is often paired with the [`Cell`] or +//! [`RefCell`] types in order to allow mutation. +//! +//! ## Atomically reference counted pointers +//! +//! The [`Arc`] type is the threadsafe equivalent of the [`Rc`] type. It +//! provides all the same functionality of [`Rc`], except it requires that the +//! contained type `T` is shareable. Additionally, [`Arc`][`Arc`] is itself +//! sendable while [`Rc`][`Rc`] is not. +//! +//! This type allows for shared access to the contained data, and is often +//! paired with synchronization primitives such as mutexes to allow mutation of +//! shared resources. +//! +//! ## Collections +//! +//! Implementations of the most common general purpose data structures are +//! defined in this library. They are re-exported through the +//! [standard collections library](../std/collections/index.html). +//! +//! ## Heap interfaces +//! +//! The [`alloc`](alloc/index.html) module defines the low-level interface to the +//! default global allocator. It is not compatible with the libc allocator API. +//! +//! [`Arc`]: sync +//! [`Box`]: boxed +//! [`Cell`]: core::cell +//! [`Rc`]: rc +//! [`RefCell`]: core::cell + +#![allow(unused_attributes)] +#![stable(feature = "alloc", since = "1.36.0")] +#![doc( + html_root_url = "https://doc.rust-lang.org/nightly/", + html_playground_url = "https://play.rust-lang.org/", + issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/", + test(no_crate_inject, attr(allow(unused_variables), deny(warnings))) +)] +#![no_std] +#![needs_allocator] +#![warn(deprecated_in_future)] +#![warn(missing_docs)] +#![warn(missing_debug_implementations)] +#![allow(explicit_outlives_requirements)] +#![allow(incomplete_features)] +#![deny(unsafe_op_in_unsafe_fn)] +#![cfg_attr(not(bootstrap), feature(rustc_allow_const_fn_unstable))] +#![cfg_attr(not(test), feature(generator_trait))] +#![cfg_attr(test, feature(test))] +#![cfg_attr(test, feature(new_uninit))] +#![feature(allocator_api)] +#![feature(array_chunks)] +#![feature(array_methods)] +#![feature(array_value_iter)] +#![feature(array_windows)] +#![feature(allow_internal_unstable)] +#![feature(arbitrary_self_types)] +#![feature(box_patterns)] +#![feature(box_syntax)] +#![feature(cfg_sanitize)] +#![feature(cfg_target_has_atomic)] +#![feature(coerce_unsized)] +#![feature(const_btree_new)] +#![feature(const_fn)] +#![feature(const_generics)] +#![feature(const_in_array_repeat_expressions)] +#![feature(cow_is_borrowed)] +#![feature(const_cow_is_borrowed)] +#![feature(dispatch_from_dyn)] +#![feature(core_intrinsics)] +#![feature(dropck_eyepatch)] +#![feature(exact_size_is_empty)] +#![feature(exclusive_range_pattern)] +#![feature(extend_one)] +#![feature(fmt_internals)] +#![feature(fn_traits)] +#![feature(fundamental)] +#![feature(inplace_iteration)] +#![feature(int_bits_const)] +#![feature(lang_items)] +#![feature(layout_for_ptr)] +#![feature(maybe_uninit_ref)] +#![feature(negative_impls)] +#![feature(never_type)] +#![feature(nll)] +#![feature(nonnull_slice_from_raw_parts)] +#![feature(optin_builtin_traits)] +#![feature(or_patterns)] +#![feature(pattern)] +#![feature(ptr_internals)] +#![feature(range_bounds_assert_len)] +#![feature(raw_ref_op)] +#![feature(rustc_attrs)] +#![feature(receiver_trait)] +#![feature(min_specialization)] +#![feature(slice_ptr_get)] +#![feature(slice_ptr_len)] +#![feature(staged_api)] +#![feature(str_internals)] +#![feature(trusted_len)] +#![feature(unboxed_closures)] +#![feature(unicode_internals)] +#![feature(unsafe_block_in_unsafe_fn)] +#![feature(unsize)] +#![cfg_attr(not(bootstrap), feature(unsized_fn_params))] +#![cfg_attr(bootstrap, feature(unsized_locals))] +#![feature(allocator_internals)] +#![feature(slice_partition_dedup)] +#![feature(maybe_uninit_extra, maybe_uninit_slice, maybe_uninit_uninit_array)] +#![feature(alloc_layout_extra)] +#![feature(trusted_random_access)] +#![feature(try_trait)] +#![feature(type_alias_impl_trait)] +#![feature(associated_type_bounds)] +// Allow testing this library + +#[cfg(test)] +#[macro_use] +extern crate std; +#[cfg(test)] +extern crate test; + +// Module with internal macros used by other modules (needs to be included before other modules). +#[macro_use] +mod macros; + +// Heaps provided for low-level allocation strategies + +pub mod alloc; + +// Primitive types using the heaps above + +// Need to conditionally define the mod from `boxed.rs` to avoid +// duplicating the lang-items when building in test cfg; but also need +// to allow code to have `use boxed::Box;` declarations. +#[cfg(not(test))] +pub mod boxed; +#[cfg(test)] +mod boxed { + pub use std::boxed::Box; +} +pub mod borrow; +pub mod collections; +pub mod fmt; +pub mod prelude; +pub mod raw_vec; +pub mod rc; +pub mod slice; +pub mod str; +pub mod string; +#[cfg(target_has_atomic = "ptr")] +pub mod sync; +#[cfg(target_has_atomic = "ptr")] +pub mod task; +#[cfg(test)] +mod tests; +pub mod vec; + +#[cfg(not(test))] +mod std { + pub use core::ops; // RangeFull +} + +#[doc(hidden)] +#[unstable(feature = "liballoc_internals", issue = "none", reason = "implementation detail")] +pub mod __export { + pub use core::format_args; +} diff --git a/libgrust/rustc-lib/alloc/src/macros.rs b/libgrust/rustc-lib/alloc/src/macros.rs new file mode 100644 index 000000000000..a992d768d631 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/macros.rs @@ -0,0 +1,109 @@ +/// Creates a [`Vec`] containing the arguments. +/// +/// `vec!` allows `Vec`s to be defined with the same syntax as array expressions. +/// There are two forms of this macro: +/// +/// - Create a [`Vec`] containing a given list of elements: +/// +/// ``` +/// let v = vec![1, 2, 3]; +/// assert_eq!(v[0], 1); +/// assert_eq!(v[1], 2); +/// assert_eq!(v[2], 3); +/// ``` +/// +/// - Create a [`Vec`] from a given element and size: +/// +/// ``` +/// let v = vec![1; 3]; +/// assert_eq!(v, [1, 1, 1]); +/// ``` +/// +/// Note that unlike array expressions this syntax supports all elements +/// which implement [`Clone`] and the number of elements doesn't have to be +/// a constant. +/// +/// This will use `clone` to duplicate an expression, so one should be careful +/// using this with types having a nonstandard `Clone` implementation. For +/// example, `vec![Rc::new(1); 5]` will create a vector of five references +/// to the same boxed integer value, not five references pointing to independently +/// boxed integers. +/// +/// [`Vec`]: crate::vec::Vec +#[cfg(not(test))] +#[macro_export] +#[stable(feature = "rust1", since = "1.0.0")] +#[allow_internal_unstable(box_syntax)] +macro_rules! vec { + () => ( + $crate::vec::Vec::new() + ); + ($elem:expr; $n:expr) => ( + $crate::vec::from_elem($elem, $n) + ); + ($($x:expr),+ $(,)?) => ( + <[_]>::into_vec(box [$($x),+]) + ); +} + +// HACK(japaric): with cfg(test) the inherent `[T]::into_vec` method, which is +// required for this macro definition, is not available. Instead use the +// `slice::into_vec` function which is only available with cfg(test) +// NB see the slice::hack module in slice.rs for more information +#[cfg(test)] +macro_rules! vec { + () => ( + $crate::vec::Vec::new() + ); + ($elem:expr; $n:expr) => ( + $crate::vec::from_elem($elem, $n) + ); + ($($x:expr),*) => ( + $crate::slice::into_vec(box [$($x),*]) + ); + ($($x:expr,)*) => (vec![$($x),*]) +} + +/// Creates a `String` using interpolation of runtime expressions. +/// +/// The first argument `format!` receives is a format string. This must be a string +/// literal. The power of the formatting string is in the `{}`s contained. +/// +/// Additional parameters passed to `format!` replace the `{}`s within the +/// formatting string in the order given unless named or positional parameters +/// are used; see [`std::fmt`] for more information. +/// +/// A common use for `format!` is concatenation and interpolation of strings. +/// The same convention is used with [`print!`] and [`write!`] macros, +/// depending on the intended destination of the string. +/// +/// To convert a single value to a string, use the [`to_string`] method. This +/// will use the [`Display`] formatting trait. +/// +/// [`std::fmt`]: ../std/fmt/index.html +/// [`print!`]: ../std/macro.print.html +/// [`write!`]: core::write +/// [`to_string`]: crate::string::ToString +/// [`Display`]: core::fmt::Display +/// +/// # Panics +/// +/// `format!` panics if a formatting trait implementation returns an error. +/// This indicates an incorrect implementation +/// since `fmt::Write for String` never returns an error itself. +/// +/// # Examples +/// +/// ``` +/// format!("test"); +/// format!("hello {}", "world!"); +/// format!("x = {}, y = {y}", 10, y = 30); +/// ``` +#[macro_export] +#[stable(feature = "rust1", since = "1.0.0")] +macro_rules! format { + ($($arg:tt)*) => {{ + let res = $crate::fmt::format($crate::__export::format_args!($($arg)*)); + res + }} +} diff --git a/libgrust/rustc-lib/alloc/src/prelude/mod.rs b/libgrust/rustc-lib/alloc/src/prelude/mod.rs new file mode 100644 index 000000000000..0534ad3edc79 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/prelude/mod.rs @@ -0,0 +1,15 @@ +//! The alloc Prelude +//! +//! The purpose of this module is to alleviate imports of commonly-used +//! items of the `alloc` crate by adding a glob import to the top of modules: +//! +//! ``` +//! # #![allow(unused_imports)] +//! #![feature(alloc_prelude)] +//! extern crate alloc; +//! use alloc::prelude::v1::*; +//! ``` + +#![unstable(feature = "alloc_prelude", issue = "58935")] + +pub mod v1; diff --git a/libgrust/rustc-lib/alloc/src/prelude/v1.rs b/libgrust/rustc-lib/alloc/src/prelude/v1.rs new file mode 100644 index 000000000000..6a53b4ca1f6c --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/prelude/v1.rs @@ -0,0 +1,14 @@ +//! The first version of the prelude of `alloc` crate. +//! +//! See the [module-level documentation](../index.html) for more. + +#![unstable(feature = "alloc_prelude", issue = "58935")] + +#[unstable(feature = "alloc_prelude", issue = "58935")] +pub use crate::borrow::ToOwned; +#[unstable(feature = "alloc_prelude", issue = "58935")] +pub use crate::boxed::Box; +#[unstable(feature = "alloc_prelude", issue = "58935")] +pub use crate::string::{String, ToString}; +#[unstable(feature = "alloc_prelude", issue = "58935")] +pub use crate::vec::Vec; diff --git a/libgrust/rustc-lib/alloc/src/raw_vec.rs b/libgrust/rustc-lib/alloc/src/raw_vec.rs new file mode 100644 index 000000000000..a4240308bb35 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/raw_vec.rs @@ -0,0 +1,543 @@ +#![unstable(feature = "raw_vec_internals", reason = "implementation detail", issue = "none")] +#![doc(hidden)] + +use core::alloc::LayoutErr; +use core::cmp; +use core::intrinsics; +use core::mem::{self, ManuallyDrop, MaybeUninit}; +use core::ops::Drop; +use core::ptr::{self, NonNull, Unique}; +use core::slice; + +use crate::alloc::{handle_alloc_error, AllocRef, Global, Layout}; +use crate::boxed::Box; +use crate::collections::TryReserveError::{self, *}; + +#[cfg(test)] +mod tests; + +enum AllocInit { + /// The contents of the new memory are uninitialized. + Uninitialized, + /// The new memory is guaranteed to be zeroed. + Zeroed, +} + +/// A low-level utility for more ergonomically allocating, reallocating, and deallocating +/// a buffer of memory on the heap without having to worry about all the corner cases +/// involved. This type is excellent for building your own data structures like Vec and VecDeque. +/// In particular: +/// +/// * Produces `Unique::dangling()` on zero-sized types. +/// * Produces `Unique::dangling()` on zero-length allocations. +/// * Avoids freeing `Unique::dangling()`. +/// * Catches all overflows in capacity computations (promotes them to "capacity overflow" panics). +/// * Guards against 32-bit systems allocating more than isize::MAX bytes. +/// * Guards against overflowing your length. +/// * Calls `handle_alloc_error` for fallible allocations. +/// * Contains a `ptr::Unique` and thus endows the user with all related benefits. +/// * Uses the excess returned from the allocator to use the largest available capacity. +/// +/// This type does not in anyway inspect the memory that it manages. When dropped it *will* +/// free its memory, but it *won't* try to drop its contents. It is up to the user of `RawVec` +/// to handle the actual things *stored* inside of a `RawVec`. +/// +/// Note that the excess of a zero-sized types is always infinite, so `capacity()` always returns +/// `usize::MAX`. This means that you need to be careful when round-tripping this type with a +/// `Box<[T]>`, since `capacity()` won't yield the length. +#[allow(missing_debug_implementations)] +pub struct RawVec { + ptr: Unique, + cap: usize, + alloc: A, +} + +impl RawVec { + /// HACK(Centril): This exists because `#[unstable]` `const fn`s needn't conform + /// to `min_const_fn` and so they cannot be called in `min_const_fn`s either. + /// + /// If you change `RawVec::new` or dependencies, please take care to not + /// introduce anything that would truly violate `min_const_fn`. + /// + /// NOTE: We could avoid this hack and check conformance with some + /// `#[rustc_force_min_const_fn]` attribute which requires conformance + /// with `min_const_fn` but does not necessarily allow calling it in + /// `stable(...) const fn` / user code not enabling `foo` when + /// `#[rustc_const_unstable(feature = "foo", issue = "01234")]` is present. + pub const NEW: Self = Self::new(); + + /// Creates the biggest possible `RawVec` (on the system heap) + /// without allocating. If `T` has positive size, then this makes a + /// `RawVec` with capacity `0`. If `T` is zero-sized, then it makes a + /// `RawVec` with capacity `usize::MAX`. Useful for implementing + /// delayed allocation. + pub const fn new() -> Self { + Self::new_in(Global) + } + + /// Creates a `RawVec` (on the system heap) with exactly the + /// capacity and alignment requirements for a `[T; capacity]`. This is + /// equivalent to calling `RawVec::new` when `capacity` is `0` or `T` is + /// zero-sized. Note that if `T` is zero-sized this means you will + /// *not* get a `RawVec` with the requested capacity. + /// + /// # Panics + /// + /// Panics if the requested capacity exceeds `isize::MAX` bytes. + /// + /// # Aborts + /// + /// Aborts on OOM. + #[inline] + pub fn with_capacity(capacity: usize) -> Self { + Self::with_capacity_in(capacity, Global) + } + + /// Like `with_capacity`, but guarantees the buffer is zeroed. + #[inline] + pub fn with_capacity_zeroed(capacity: usize) -> Self { + Self::with_capacity_zeroed_in(capacity, Global) + } + + /// Reconstitutes a `RawVec` from a pointer and capacity. + /// + /// # Safety + /// + /// The `ptr` must be allocated (on the system heap), and with the given `capacity`. + /// The `capacity` cannot exceed `isize::MAX` for sized types. (only a concern on 32-bit + /// systems). ZST vectors may have a capacity up to `usize::MAX`. + /// If the `ptr` and `capacity` come from a `RawVec`, then this is guaranteed. + #[inline] + pub unsafe fn from_raw_parts(ptr: *mut T, capacity: usize) -> Self { + unsafe { Self::from_raw_parts_in(ptr, capacity, Global) } + } +} + +impl RawVec { + /// Like `new`, but parameterized over the choice of allocator for + /// the returned `RawVec`. + #[cfg_attr(not(bootstrap), rustc_allow_const_fn_unstable(const_fn))] + #[cfg_attr(bootstrap, allow_internal_unstable(const_fn))] + pub const fn new_in(alloc: A) -> Self { + // `cap: 0` means "unallocated". zero-sized types are ignored. + Self { ptr: Unique::dangling(), cap: 0, alloc } + } + + /// Like `with_capacity`, but parameterized over the choice of + /// allocator for the returned `RawVec`. + #[inline] + pub fn with_capacity_in(capacity: usize, alloc: A) -> Self { + Self::allocate_in(capacity, AllocInit::Uninitialized, alloc) + } + + /// Like `with_capacity_zeroed`, but parameterized over the choice + /// of allocator for the returned `RawVec`. + #[inline] + pub fn with_capacity_zeroed_in(capacity: usize, alloc: A) -> Self { + Self::allocate_in(capacity, AllocInit::Zeroed, alloc) + } + + /// Converts a `Box<[T]>` into a `RawVec`. + pub fn from_box(slice: Box<[T], A>) -> Self { + unsafe { + let (slice, alloc) = Box::into_raw_with_alloc(slice); + RawVec::from_raw_parts_in(slice.as_mut_ptr(), slice.len(), alloc) + } + } + + /// Converts the entire buffer into `Box<[MaybeUninit]>` with the specified `len`. + /// + /// Note that this will correctly reconstitute any `cap` changes + /// that may have been performed. (See description of type for details.) + /// + /// # Safety + /// + /// * `len` must be greater than or equal to the most recently requested capacity, and + /// * `len` must be less than or equal to `self.capacity()`. + /// + /// Note, that the requested capacity and `self.capacity()` could differ, as + /// an allocator could overallocate and return a greater memory block than requested. + pub unsafe fn into_box(self, len: usize) -> Box<[MaybeUninit], A> { + // Sanity-check one half of the safety requirement (we cannot check the other half). + debug_assert!( + len <= self.capacity(), + "`len` must be smaller than or equal to `self.capacity()`" + ); + + let me = ManuallyDrop::new(self); + unsafe { + let slice = slice::from_raw_parts_mut(me.ptr() as *mut MaybeUninit, len); + Box::from_raw_in(slice, ptr::read(&me.alloc)) + } + } + + fn allocate_in(capacity: usize, init: AllocInit, alloc: A) -> Self { + if mem::size_of::() == 0 { + Self::new_in(alloc) + } else { + // We avoid `unwrap_or_else` here because it bloats the amount of + // LLVM IR generated. + let layout = match Layout::array::(capacity) { + Ok(layout) => layout, + Err(_) => capacity_overflow(), + }; + match alloc_guard(layout.size()) { + Ok(_) => {} + Err(_) => capacity_overflow(), + } + let result = match init { + AllocInit::Uninitialized => alloc.alloc(layout), + AllocInit::Zeroed => alloc.alloc_zeroed(layout), + }; + let ptr = match result { + Ok(ptr) => ptr, + Err(_) => handle_alloc_error(layout), + }; + + Self { + ptr: unsafe { Unique::new_unchecked(ptr.cast().as_ptr()) }, + cap: Self::capacity_from_bytes(ptr.len()), + alloc, + } + } + } + + /// Reconstitutes a `RawVec` from a pointer, capacity, and allocator. + /// + /// # Safety + /// + /// The `ptr` must be allocated (via the given allocator `alloc`), and with the given + /// `capacity`. + /// The `capacity` cannot exceed `isize::MAX` for sized types. (only a concern on 32-bit + /// systems). ZST vectors may have a capacity up to `usize::MAX`. + /// If the `ptr` and `capacity` come from a `RawVec` created via `alloc`, then this is + /// guaranteed. + #[inline] + pub unsafe fn from_raw_parts_in(ptr: *mut T, capacity: usize, alloc: A) -> Self { + Self { ptr: unsafe { Unique::new_unchecked(ptr) }, cap: capacity, alloc } + } + + /// Gets a raw pointer to the start of the allocation. Note that this is + /// `Unique::dangling()` if `capacity == 0` or `T` is zero-sized. In the former case, you must + /// be careful. + pub fn ptr(&self) -> *mut T { + self.ptr.as_ptr() + } + + /// Gets the capacity of the allocation. + /// + /// This will always be `usize::MAX` if `T` is zero-sized. + #[inline(always)] + pub fn capacity(&self) -> usize { + if mem::size_of::() == 0 { usize::MAX } else { self.cap } + } + + /// Returns a shared reference to the allocator backing this `RawVec`. + pub fn alloc(&self) -> &A { + &self.alloc + } + + /// Returns a mutable reference to the allocator backing this `RawVec`. + pub fn alloc_mut(&mut self) -> &mut A { + &mut self.alloc + } + + fn current_memory(&self) -> Option<(NonNull, Layout)> { + if mem::size_of::() == 0 || self.cap == 0 { + None + } else { + // We have an allocated chunk of memory, so we can bypass runtime + // checks to get our current layout. + unsafe { + let align = mem::align_of::(); + let size = mem::size_of::() * self.cap; + let layout = Layout::from_size_align_unchecked(size, align); + Some((self.ptr.cast().into(), layout)) + } + } + } + + /// Ensures that the buffer contains at least enough space to hold `len + + /// additional` elements. If it doesn't already have enough capacity, will + /// reallocate enough space plus comfortable slack space to get amortized + /// *O*(1) behavior. Will limit this behavior if it would needlessly cause + /// itself to panic. + /// + /// If `len` exceeds `self.capacity()`, this may fail to actually allocate + /// the requested space. This is not really unsafe, but the unsafe + /// code *you* write that relies on the behavior of this function may break. + /// + /// This is ideal for implementing a bulk-push operation like `extend`. + /// + /// # Panics + /// + /// Panics if the new capacity exceeds `isize::MAX` bytes. + /// + /// # Aborts + /// + /// Aborts on OOM. + /// + /// # Examples + /// + /// ``` + /// # #![feature(raw_vec_internals)] + /// # extern crate alloc; + /// # use std::ptr; + /// # use alloc::raw_vec::RawVec; + /// struct MyVec { + /// buf: RawVec, + /// len: usize, + /// } + /// + /// impl MyVec { + /// pub fn push_all(&mut self, elems: &[T]) { + /// self.buf.reserve(self.len, elems.len()); + /// // reserve would have aborted or panicked if the len exceeded + /// // `isize::MAX` so this is safe to do unchecked now. + /// for x in elems { + /// unsafe { + /// ptr::write(self.buf.ptr().add(self.len), x.clone()); + /// } + /// self.len += 1; + /// } + /// } + /// } + /// # fn main() { + /// # let mut vector = MyVec { buf: RawVec::new(), len: 0 }; + /// # vector.push_all(&[1, 3, 5, 7, 9]); + /// # } + /// ``` + pub fn reserve(&mut self, len: usize, additional: usize) { + handle_reserve(self.try_reserve(len, additional)); + } + + /// The same as `reserve`, but returns on errors instead of panicking or aborting. + pub fn try_reserve(&mut self, len: usize, additional: usize) -> Result<(), TryReserveError> { + if self.needs_to_grow(len, additional) { + self.grow_amortized(len, additional) + } else { + Ok(()) + } + } + + /// Ensures that the buffer contains at least enough space to hold `len + + /// additional` elements. If it doesn't already, will reallocate the + /// minimum possible amount of memory necessary. Generally this will be + /// exactly the amount of memory necessary, but in principle the allocator + /// is free to give back more than we asked for. + /// + /// If `len` exceeds `self.capacity()`, this may fail to actually allocate + /// the requested space. This is not really unsafe, but the unsafe code + /// *you* write that relies on the behavior of this function may break. + /// + /// # Panics + /// + /// Panics if the new capacity exceeds `isize::MAX` bytes. + /// + /// # Aborts + /// + /// Aborts on OOM. + pub fn reserve_exact(&mut self, len: usize, additional: usize) { + handle_reserve(self.try_reserve_exact(len, additional)); + } + + /// The same as `reserve_exact`, but returns on errors instead of panicking or aborting. + pub fn try_reserve_exact( + &mut self, + len: usize, + additional: usize, + ) -> Result<(), TryReserveError> { + if self.needs_to_grow(len, additional) { self.grow_exact(len, additional) } else { Ok(()) } + } + + /// Shrinks the allocation down to the specified amount. If the given amount + /// is 0, actually completely deallocates. + /// + /// # Panics + /// + /// Panics if the given amount is *larger* than the current capacity. + /// + /// # Aborts + /// + /// Aborts on OOM. + pub fn shrink_to_fit(&mut self, amount: usize) { + handle_reserve(self.shrink(amount)); + } +} + +impl RawVec { + /// Returns if the buffer needs to grow to fulfill the needed extra capacity. + /// Mainly used to make inlining reserve-calls possible without inlining `grow`. + fn needs_to_grow(&self, len: usize, additional: usize) -> bool { + additional > self.capacity().wrapping_sub(len) + } + + fn capacity_from_bytes(excess: usize) -> usize { + debug_assert_ne!(mem::size_of::(), 0); + excess / mem::size_of::() + } + + fn set_ptr(&mut self, ptr: NonNull<[u8]>) { + self.ptr = unsafe { Unique::new_unchecked(ptr.cast().as_ptr()) }; + self.cap = Self::capacity_from_bytes(ptr.len()); + } + + // This method is usually instantiated many times. So we want it to be as + // small as possible, to improve compile times. But we also want as much of + // its contents to be statically computable as possible, to make the + // generated code run faster. Therefore, this method is carefully written + // so that all of the code that depends on `T` is within it, while as much + // of the code that doesn't depend on `T` as possible is in functions that + // are non-generic over `T`. + fn grow_amortized(&mut self, len: usize, additional: usize) -> Result<(), TryReserveError> { + // This is ensured by the calling contexts. + debug_assert!(additional > 0); + + if mem::size_of::() == 0 { + // Since we return a capacity of `usize::MAX` when `elem_size` is + // 0, getting to here necessarily means the `RawVec` is overfull. + return Err(CapacityOverflow); + } + + // Nothing we can really do about these checks, sadly. + let required_cap = len.checked_add(additional).ok_or(CapacityOverflow)?; + + // This guarantees exponential growth. The doubling cannot overflow + // because `cap <= isize::MAX` and the type of `cap` is `usize`. + let cap = cmp::max(self.cap * 2, required_cap); + + // Tiny Vecs are dumb. Skip to: + // - 8 if the element size is 1, because any heap allocators is likely + // to round up a request of less than 8 bytes to at least 8 bytes. + // - 4 if elements are moderate-sized (<= 1 KiB). + // - 1 otherwise, to avoid wasting too much space for very short Vecs. + // Note that `min_non_zero_cap` is computed statically. + let elem_size = mem::size_of::(); + let min_non_zero_cap = if elem_size == 1 { + 8 + } else if elem_size <= 1024 { + 4 + } else { + 1 + }; + let cap = cmp::max(min_non_zero_cap, cap); + + let new_layout = Layout::array::(cap); + + // `finish_grow` is non-generic over `T`. + let ptr = finish_grow(new_layout, self.current_memory(), &mut self.alloc)?; + self.set_ptr(ptr); + Ok(()) + } + + // The constraints on this method are much the same as those on + // `grow_amortized`, but this method is usually instantiated less often so + // it's less critical. + fn grow_exact(&mut self, len: usize, additional: usize) -> Result<(), TryReserveError> { + if mem::size_of::() == 0 { + // Since we return a capacity of `usize::MAX` when the type size is + // 0, getting to here necessarily means the `RawVec` is overfull. + return Err(CapacityOverflow); + } + + let cap = len.checked_add(additional).ok_or(CapacityOverflow)?; + let new_layout = Layout::array::(cap); + + // `finish_grow` is non-generic over `T`. + let ptr = finish_grow(new_layout, self.current_memory(), &mut self.alloc)?; + self.set_ptr(ptr); + Ok(()) + } + + fn shrink(&mut self, amount: usize) -> Result<(), TryReserveError> { + assert!(amount <= self.capacity(), "Tried to shrink to a larger capacity"); + + let (ptr, layout) = if let Some(mem) = self.current_memory() { mem } else { return Ok(()) }; + let new_size = amount * mem::size_of::(); + + let ptr = unsafe { + let new_layout = Layout::from_size_align_unchecked(new_size, layout.align()); + self.alloc.shrink(ptr, layout, new_layout).map_err(|_| TryReserveError::AllocError { + layout: new_layout, + non_exhaustive: (), + })? + }; + self.set_ptr(ptr); + Ok(()) + } +} + +// This function is outside `RawVec` to minimize compile times. See the comment +// above `RawVec::grow_amortized` for details. (The `A` parameter isn't +// significant, because the number of different `A` types seen in practice is +// much smaller than the number of `T` types.) +fn finish_grow( + new_layout: Result, + current_memory: Option<(NonNull, Layout)>, + alloc: &mut A, +) -> Result, TryReserveError> +where + A: AllocRef, +{ + // Check for the error here to minimize the size of `RawVec::grow_*`. + let new_layout = new_layout.map_err(|_| CapacityOverflow)?; + + alloc_guard(new_layout.size())?; + + let memory = if let Some((ptr, old_layout)) = current_memory { + debug_assert_eq!(old_layout.align(), new_layout.align()); + unsafe { + // The allocator checks for alignment equality + intrinsics::assume(old_layout.align() == new_layout.align()); + alloc.grow(ptr, old_layout, new_layout) + } + } else { + alloc.alloc(new_layout) + }; + + memory.map_err(|_| AllocError { layout: new_layout, non_exhaustive: () }) +} + +unsafe impl<#[may_dangle] T, A: AllocRef> Drop for RawVec { + /// Frees the memory owned by the `RawVec` *without* trying to drop its contents. + fn drop(&mut self) { + if let Some((ptr, layout)) = self.current_memory() { + unsafe { self.alloc.dealloc(ptr, layout) } + } + } +} + +// Central function for reserve error handling. +#[inline] +fn handle_reserve(result: Result<(), TryReserveError>) { + match result { + Err(CapacityOverflow) => capacity_overflow(), + Err(AllocError { layout, .. }) => handle_alloc_error(layout), + Ok(()) => { /* yay */ } + } +} + +// We need to guarantee the following: +// * We don't ever allocate `> isize::MAX` byte-size objects. +// * We don't overflow `usize::MAX` and actually allocate too little. +// +// On 64-bit we just need to check for overflow since trying to allocate +// `> isize::MAX` bytes will surely fail. On 32-bit and 16-bit we need to add +// an extra guard for this in case we're running on a platform which can use +// all 4GB in user-space, e.g., PAE or x32. + +#[inline] +fn alloc_guard(alloc_size: usize) -> Result<(), TryReserveError> { + if usize::BITS < 64 && alloc_size > isize::MAX as usize { + Err(CapacityOverflow) + } else { + Ok(()) + } +} + +// One central function responsible for reporting capacity overflows. This'll +// ensure that the code generation related to these panics is minimal as there's +// only one location which panics rather than a bunch throughout the module. +fn capacity_overflow() -> ! { + panic!("capacity overflow"); +} diff --git a/libgrust/rustc-lib/alloc/src/raw_vec/tests.rs b/libgrust/rustc-lib/alloc/src/raw_vec/tests.rs new file mode 100644 index 000000000000..cb4fe1b46cd7 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/raw_vec/tests.rs @@ -0,0 +1,79 @@ +use super::*; +use std::cell::Cell; + +#[test] +fn allocator_param() { + use crate::alloc::AllocError; + + // Writing a test of integration between third-party + // allocators and `RawVec` is a little tricky because the `RawVec` + // API does not expose fallible allocation methods, so we + // cannot check what happens when allocator is exhausted + // (beyond detecting a panic). + // + // Instead, this just checks that the `RawVec` methods do at + // least go through the Allocator API when it reserves + // storage. + + // A dumb allocator that consumes a fixed amount of fuel + // before allocation attempts start failing. + struct BoundedAlloc { + fuel: Cell, + } + unsafe impl AllocRef for BoundedAlloc { + fn alloc(&self, layout: Layout) -> Result, AllocError> { + let size = layout.size(); + if size > self.fuel.get() { + return Err(AllocError); + } + match Global.alloc(layout) { + ok @ Ok(_) => { + self.fuel.set(self.fuel.get() - size); + ok + } + err @ Err(_) => err, + } + } + unsafe fn dealloc(&self, ptr: NonNull, layout: Layout) { + unsafe { Global.dealloc(ptr, layout) } + } + } + + let a = BoundedAlloc { fuel: Cell::new(500) }; + let mut v: RawVec = RawVec::with_capacity_in(50, a); + assert_eq!(v.alloc.fuel.get(), 450); + v.reserve(50, 150); // (causes a realloc, thus using 50 + 150 = 200 units of fuel) + assert_eq!(v.alloc.fuel.get(), 250); +} + +#[test] +fn reserve_does_not_overallocate() { + { + let mut v: RawVec = RawVec::new(); + // First, `reserve` allocates like `reserve_exact`. + v.reserve(0, 9); + assert_eq!(9, v.capacity()); + } + + { + let mut v: RawVec = RawVec::new(); + v.reserve(0, 7); + assert_eq!(7, v.capacity()); + // 97 is more than double of 7, so `reserve` should work + // like `reserve_exact`. + v.reserve(7, 90); + assert_eq!(97, v.capacity()); + } + + { + let mut v: RawVec = RawVec::new(); + v.reserve(0, 12); + assert_eq!(12, v.capacity()); + v.reserve(12, 3); + // 3 is less than half of 12, so `reserve` must grow + // exponentially. At the time of writing this test grow + // factor is 2, so new capacity is 24, however, grow factor + // of 1.5 is OK too. Hence `>= 18` in assert. + assert!(v.capacity() >= 12 + 12 / 2); + } +} diff --git a/libgrust/rustc-lib/alloc/src/rc.rs b/libgrust/rustc-lib/alloc/src/rc.rs new file mode 100644 index 000000000000..7217d81d9d08 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/rc.rs @@ -0,0 +1,2227 @@ +//! Single-threaded reference-counting pointers. 'Rc' stands for 'Reference +//! Counted'. +//! +//! The type [`Rc`][`Rc`] provides shared ownership of a value of type `T`, +//! allocated in the heap. Invoking [`clone`][clone] on [`Rc`] produces a new +//! pointer to the same allocation in the heap. When the last [`Rc`] pointer to a +//! given allocation is destroyed, the value stored in that allocation (often +//! referred to as "inner value") is also dropped. +//! +//! Shared references in Rust disallow mutation by default, and [`Rc`] +//! is no exception: you cannot generally obtain a mutable reference to +//! something inside an [`Rc`]. If you need mutability, put a [`Cell`] +//! or [`RefCell`] inside the [`Rc`]; see [an example of mutability +//! inside an `Rc`][mutability]. +//! +//! [`Rc`] uses non-atomic reference counting. This means that overhead is very +//! low, but an [`Rc`] cannot be sent between threads, and consequently [`Rc`] +//! does not implement [`Send`][send]. As a result, the Rust compiler +//! will check *at compile time* that you are not sending [`Rc`]s between +//! threads. If you need multi-threaded, atomic reference counting, use +//! [`sync::Arc`][arc]. +//! +//! The [`downgrade`][downgrade] method can be used to create a non-owning +//! [`Weak`] pointer. A [`Weak`] pointer can be [`upgrade`][upgrade]d +//! to an [`Rc`], but this will return [`None`] if the value stored in the allocation has +//! already been dropped. In other words, `Weak` pointers do not keep the value +//! inside the allocation alive; however, they *do* keep the allocation +//! (the backing store for the inner value) alive. +//! +//! A cycle between [`Rc`] pointers will never be deallocated. For this reason, +//! [`Weak`] is used to break cycles. For example, a tree could have strong +//! [`Rc`] pointers from parent nodes to children, and [`Weak`] pointers from +//! children back to their parents. +//! +//! `Rc` automatically dereferences to `T` (via the [`Deref`] trait), +//! so you can call `T`'s methods on a value of type [`Rc`][`Rc`]. To avoid name +//! clashes with `T`'s methods, the methods of [`Rc`][`Rc`] itself are associated +//! functions, called using [fully qualified syntax]: +//! +//! ``` +//! use std::rc::Rc; +//! +//! let my_rc = Rc::new(()); +//! Rc::downgrade(&my_rc); +//! ``` +//! +//! `Rc`'s implementations of traits like `Clone` may also be called using +//! fully qualified syntax. Some people prefer to use fully qualified syntax, +//! while others prefer using method-call syntax. +//! +//! ``` +//! use std::rc::Rc; +//! +//! let rc = Rc::new(()); +//! // Method-call syntax +//! let rc2 = rc.clone(); +//! // Fully qualified syntax +//! let rc3 = Rc::clone(&rc); +//! ``` +//! +//! [`Weak`][`Weak`] does not auto-dereference to `T`, because the inner value may have +//! already been dropped. +//! +//! # Cloning references +//! +//! Creating a new reference to the same allocation as an existing reference counted pointer +//! is done using the `Clone` trait implemented for [`Rc`][`Rc`] and [`Weak`][`Weak`]. +//! +//! ``` +//! use std::rc::Rc; +//! +//! let foo = Rc::new(vec![1.0, 2.0, 3.0]); +//! // The two syntaxes below are equivalent. +//! let a = foo.clone(); +//! let b = Rc::clone(&foo); +//! // a and b both point to the same memory location as foo. +//! ``` +//! +//! The `Rc::clone(&from)` syntax is the most idiomatic because it conveys more explicitly +//! the meaning of the code. In the example above, this syntax makes it easier to see that +//! this code is creating a new reference rather than copying the whole content of foo. +//! +//! # Examples +//! +//! Consider a scenario where a set of `Gadget`s are owned by a given `Owner`. +//! We want to have our `Gadget`s point to their `Owner`. We can't do this with +//! unique ownership, because more than one gadget may belong to the same +//! `Owner`. [`Rc`] allows us to share an `Owner` between multiple `Gadget`s, +//! and have the `Owner` remain allocated as long as any `Gadget` points at it. +//! +//! ``` +//! use std::rc::Rc; +//! +//! struct Owner { +//! name: String, +//! // ...other fields +//! } +//! +//! struct Gadget { +//! id: i32, +//! owner: Rc, +//! // ...other fields +//! } +//! +//! fn main() { +//! // Create a reference-counted `Owner`. +//! let gadget_owner: Rc = Rc::new( +//! Owner { +//! name: "Gadget Man".to_string(), +//! } +//! ); +//! +//! // Create `Gadget`s belonging to `gadget_owner`. Cloning the `Rc` +//! // gives us a new pointer to the same `Owner` allocation, incrementing +//! // the reference count in the process. +//! let gadget1 = Gadget { +//! id: 1, +//! owner: Rc::clone(&gadget_owner), +//! }; +//! let gadget2 = Gadget { +//! id: 2, +//! owner: Rc::clone(&gadget_owner), +//! }; +//! +//! // Dispose of our local variable `gadget_owner`. +//! drop(gadget_owner); +//! +//! // Despite dropping `gadget_owner`, we're still able to print out the name +//! // of the `Owner` of the `Gadget`s. This is because we've only dropped a +//! // single `Rc`, not the `Owner` it points to. As long as there are +//! // other `Rc` pointing at the same `Owner` allocation, it will remain +//! // live. The field projection `gadget1.owner.name` works because +//! // `Rc` automatically dereferences to `Owner`. +//! println!("Gadget {} owned by {}", gadget1.id, gadget1.owner.name); +//! println!("Gadget {} owned by {}", gadget2.id, gadget2.owner.name); +//! +//! // At the end of the function, `gadget1` and `gadget2` are destroyed, and +//! // with them the last counted references to our `Owner`. Gadget Man now +//! // gets destroyed as well. +//! } +//! ``` +//! +//! If our requirements change, and we also need to be able to traverse from +//! `Owner` to `Gadget`, we will run into problems. An [`Rc`] pointer from `Owner` +//! to `Gadget` introduces a cycle. This means that their +//! reference counts can never reach 0, and the allocation will never be destroyed: +//! a memory leak. In order to get around this, we can use [`Weak`] +//! pointers. +//! +//! Rust actually makes it somewhat difficult to produce this loop in the first +//! place. In order to end up with two values that point at each other, one of +//! them needs to be mutable. This is difficult because [`Rc`] enforces +//! memory safety by only giving out shared references to the value it wraps, +//! and these don't allow direct mutation. We need to wrap the part of the +//! value we wish to mutate in a [`RefCell`], which provides *interior +//! mutability*: a method to achieve mutability through a shared reference. +//! [`RefCell`] enforces Rust's borrowing rules at runtime. +//! +//! ``` +//! use std::rc::Rc; +//! use std::rc::Weak; +//! use std::cell::RefCell; +//! +//! struct Owner { +//! name: String, +//! gadgets: RefCell>>, +//! // ...other fields +//! } +//! +//! struct Gadget { +//! id: i32, +//! owner: Rc, +//! // ...other fields +//! } +//! +//! fn main() { +//! // Create a reference-counted `Owner`. Note that we've put the `Owner`'s +//! // vector of `Gadget`s inside a `RefCell` so that we can mutate it through +//! // a shared reference. +//! let gadget_owner: Rc = Rc::new( +//! Owner { +//! name: "Gadget Man".to_string(), +//! gadgets: RefCell::new(vec![]), +//! } +//! ); +//! +//! // Create `Gadget`s belonging to `gadget_owner`, as before. +//! let gadget1 = Rc::new( +//! Gadget { +//! id: 1, +//! owner: Rc::clone(&gadget_owner), +//! } +//! ); +//! let gadget2 = Rc::new( +//! Gadget { +//! id: 2, +//! owner: Rc::clone(&gadget_owner), +//! } +//! ); +//! +//! // Add the `Gadget`s to their `Owner`. +//! { +//! let mut gadgets = gadget_owner.gadgets.borrow_mut(); +//! gadgets.push(Rc::downgrade(&gadget1)); +//! gadgets.push(Rc::downgrade(&gadget2)); +//! +//! // `RefCell` dynamic borrow ends here. +//! } +//! +//! // Iterate over our `Gadget`s, printing their details out. +//! for gadget_weak in gadget_owner.gadgets.borrow().iter() { +//! +//! // `gadget_weak` is a `Weak`. Since `Weak` pointers can't +//! // guarantee the allocation still exists, we need to call +//! // `upgrade`, which returns an `Option>`. +//! // +//! // In this case we know the allocation still exists, so we simply +//! // `unwrap` the `Option`. In a more complicated program, you might +//! // need graceful error handling for a `None` result. +//! +//! let gadget = gadget_weak.upgrade().unwrap(); +//! println!("Gadget {} owned by {}", gadget.id, gadget.owner.name); +//! } +//! +//! // At the end of the function, `gadget_owner`, `gadget1`, and `gadget2` +//! // are destroyed. There are now no strong (`Rc`) pointers to the +//! // gadgets, so they are destroyed. This zeroes the reference count on +//! // Gadget Man, so he gets destroyed as well. +//! } +//! ``` +//! +//! [clone]: Clone::clone +//! [`Cell`]: core::cell::Cell +//! [`RefCell`]: core::cell::RefCell +//! [send]: core::marker::Send +//! [arc]: crate::sync::Arc +//! [`Deref`]: core::ops::Deref +//! [downgrade]: Rc::downgrade +//! [upgrade]: Weak::upgrade +//! [mutability]: core::cell#introducing-mutability-inside-of-something-immutable + +#![stable(feature = "rust1", since = "1.0.0")] + +#[cfg(not(test))] +use crate::boxed::Box; +#[cfg(test)] +use std::boxed::Box; + +use core::any::Any; +use core::borrow; +use core::cell::Cell; +use core::cmp::Ordering; +use core::convert::{From, TryFrom}; +use core::fmt; +use core::hash::{Hash, Hasher}; +use core::intrinsics::abort; +use core::iter; +use core::marker::{self, PhantomData, Unpin, Unsize}; +use core::mem::{self, align_of_val_raw, forget, size_of_val}; +use core::ops::{CoerceUnsized, Deref, DispatchFromDyn, Receiver}; +use core::pin::Pin; +use core::ptr::{self, NonNull}; +use core::slice::from_raw_parts_mut; + +use crate::alloc::{box_free, handle_alloc_error, AllocError, AllocRef, Global, Layout}; +use crate::borrow::{Cow, ToOwned}; +use crate::string::String; +use crate::vec::Vec; + +#[cfg(test)] +mod tests; + +// This is repr(C) to future-proof against possible field-reordering, which +// would interfere with otherwise safe [into|from]_raw() of transmutable +// inner types. +#[repr(C)] +struct RcBox { + strong: Cell, + weak: Cell, + value: T, +} + +/// A single-threaded reference-counting pointer. 'Rc' stands for 'Reference +/// Counted'. +/// +/// See the [module-level documentation](./index.html) for more details. +/// +/// The inherent methods of `Rc` are all associated functions, which means +/// that you have to call them as e.g., [`Rc::get_mut(&mut value)`][get_mut] instead of +/// `value.get_mut()`. This avoids conflicts with methods of the inner type `T`. +/// +/// [get_mut]: Rc::get_mut +#[cfg_attr(not(test), rustc_diagnostic_item = "Rc")] +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Rc { + ptr: NonNull>, + phantom: PhantomData>, +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl !marker::Send for Rc {} +#[stable(feature = "rust1", since = "1.0.0")] +impl !marker::Sync for Rc {} + +#[unstable(feature = "coerce_unsized", issue = "27732")] +impl, U: ?Sized> CoerceUnsized> for Rc {} + +#[unstable(feature = "dispatch_from_dyn", issue = "none")] +impl, U: ?Sized> DispatchFromDyn> for Rc {} + +impl Rc { + #[inline(always)] + fn inner(&self) -> &RcBox { + // This unsafety is ok because while this Rc is alive we're guaranteed + // that the inner pointer is valid. + unsafe { self.ptr.as_ref() } + } + + fn from_inner(ptr: NonNull>) -> Self { + Self { ptr, phantom: PhantomData } + } + + unsafe fn from_ptr(ptr: *mut RcBox) -> Self { + Self::from_inner(unsafe { NonNull::new_unchecked(ptr) }) + } +} + +impl Rc { + /// Constructs a new `Rc`. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn new(value: T) -> Rc { + // There is an implicit weak pointer owned by all the strong + // pointers, which ensures that the weak destructor never frees + // the allocation while the strong destructor is running, even + // if the weak pointer is stored inside the strong one. + Self::from_inner( + Box::leak(box RcBox { strong: Cell::new(1), weak: Cell::new(1), value }).into(), + ) + } + + /// Constructs a new `Rc` using a weak reference to itself. Attempting + /// to upgrade the weak reference before this function returns will result + /// in a `None` value. However, the weak reference may be cloned freely and + /// stored for use at a later time. + #[unstable(feature = "arc_new_cyclic", issue = "75861")] + pub fn new_cyclic(data_fn: impl FnOnce(&Weak) -> T) -> Rc { + // Construct the inner in the "uninitialized" state with a single + // weak reference. + let uninit_ptr: NonNull<_> = Box::leak(box RcBox { + strong: Cell::new(0), + weak: Cell::new(1), + value: mem::MaybeUninit::::uninit(), + }) + .into(); + + let init_ptr: NonNull> = uninit_ptr.cast(); + + let weak = Weak { ptr: init_ptr }; + + // It's important we don't give up ownership of the weak pointer, or + // else the memory might be freed by the time `data_fn` returns. If + // we really wanted to pass ownership, we could create an additional + // weak pointer for ourselves, but this would result in additional + // updates to the weak reference count which might not be necessary + // otherwise. + let data = data_fn(&weak); + + unsafe { + let inner = init_ptr.as_ptr(); + ptr::write(&raw mut (*inner).value, data); + + let prev_value = (*inner).strong.get(); + debug_assert_eq!(prev_value, 0, "No prior strong references should exist"); + (*inner).strong.set(1); + } + + let strong = Rc::from_inner(init_ptr); + + // Strong references should collectively own a shared weak reference, + // so don't run the destructor for our old weak reference. + mem::forget(weak); + strong + } + + /// Constructs a new `Rc` with uninitialized contents. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// #![feature(get_mut_unchecked)] + /// + /// use std::rc::Rc; + /// + /// let mut five = Rc::::new_uninit(); + /// + /// let five = unsafe { + /// // Deferred initialization: + /// Rc::get_mut_unchecked(&mut five).as_mut_ptr().write(5); + /// + /// five.assume_init() + /// }; + /// + /// assert_eq!(*five, 5) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_uninit() -> Rc> { + unsafe { + Rc::from_ptr(Rc::allocate_for_layout( + Layout::new::(), + |layout| Global.alloc(layout), + |mem| mem as *mut RcBox>, + )) + } + } + + /// Constructs a new `Rc` with uninitialized contents, with the memory + /// being filled with `0` bytes. + /// + /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and + /// incorrect usage of this method. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// use std::rc::Rc; + /// + /// let zero = Rc::::new_zeroed(); + /// let zero = unsafe { zero.assume_init() }; + /// + /// assert_eq!(*zero, 0) + /// ``` + /// + /// [zeroed]: mem::MaybeUninit::zeroed + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_zeroed() -> Rc> { + unsafe { + Rc::from_ptr(Rc::allocate_for_layout( + Layout::new::(), + |layout| Global.alloc_zeroed(layout), + |mem| mem as *mut RcBox>, + )) + } + } + + /// Constructs a new `Pin>`. If `T` does not implement `Unpin`, then + /// `value` will be pinned in memory and unable to be moved. + #[stable(feature = "pin", since = "1.33.0")] + pub fn pin(value: T) -> Pin> { + unsafe { Pin::new_unchecked(Rc::new(value)) } + } + + /// Returns the inner value, if the `Rc` has exactly one strong reference. + /// + /// Otherwise, an [`Err`] is returned with the same `Rc` that was + /// passed in. + /// + /// This will succeed even if there are outstanding weak references. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let x = Rc::new(3); + /// assert_eq!(Rc::try_unwrap(x), Ok(3)); + /// + /// let x = Rc::new(4); + /// let _y = Rc::clone(&x); + /// assert_eq!(*Rc::try_unwrap(x).unwrap_err(), 4); + /// ``` + #[inline] + #[stable(feature = "rc_unique", since = "1.4.0")] + pub fn try_unwrap(this: Self) -> Result { + if Rc::strong_count(&this) == 1 { + unsafe { + let val = ptr::read(&*this); // copy the contained object + + // Indicate to Weaks that they can't be promoted by decrementing + // the strong count, and then remove the implicit "strong weak" + // pointer while also handling drop logic by just crafting a + // fake Weak. + this.inner().dec_strong(); + let _weak = Weak { ptr: this.ptr }; + forget(this); + Ok(val) + } + } else { + Err(this) + } + } +} + +impl Rc<[T]> { + /// Constructs a new reference-counted slice with uninitialized contents. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// #![feature(get_mut_unchecked)] + /// + /// use std::rc::Rc; + /// + /// let mut values = Rc::<[u32]>::new_uninit_slice(3); + /// + /// let values = unsafe { + /// // Deferred initialization: + /// Rc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1); + /// Rc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2); + /// Rc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3); + /// + /// values.assume_init() + /// }; + /// + /// assert_eq!(*values, [1, 2, 3]) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_uninit_slice(len: usize) -> Rc<[mem::MaybeUninit]> { + unsafe { Rc::from_ptr(Rc::allocate_for_slice(len)) } + } + + /// Constructs a new reference-counted slice with uninitialized contents, with the memory being + /// filled with `0` bytes. + /// + /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and + /// incorrect usage of this method. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// use std::rc::Rc; + /// + /// let values = Rc::<[u32]>::new_zeroed_slice(3); + /// let values = unsafe { values.assume_init() }; + /// + /// assert_eq!(*values, [0, 0, 0]) + /// ``` + /// + /// [zeroed]: mem::MaybeUninit::zeroed + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_zeroed_slice(len: usize) -> Rc<[mem::MaybeUninit]> { + unsafe { + Rc::from_ptr(Rc::allocate_for_layout( + Layout::array::(len).unwrap(), + |layout| Global.alloc_zeroed(layout), + |mem| { + ptr::slice_from_raw_parts_mut(mem as *mut T, len) + as *mut RcBox<[mem::MaybeUninit]> + }, + )) + } + } +} + +impl Rc> { + /// Converts to `Rc`. + /// + /// # Safety + /// + /// As with [`MaybeUninit::assume_init`], + /// it is up to the caller to guarantee that the inner value + /// really is in an initialized state. + /// Calling this when the content is not yet fully initialized + /// causes immediate undefined behavior. + /// + /// [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// #![feature(get_mut_unchecked)] + /// + /// use std::rc::Rc; + /// + /// let mut five = Rc::::new_uninit(); + /// + /// let five = unsafe { + /// // Deferred initialization: + /// Rc::get_mut_unchecked(&mut five).as_mut_ptr().write(5); + /// + /// five.assume_init() + /// }; + /// + /// assert_eq!(*five, 5) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + #[inline] + pub unsafe fn assume_init(self) -> Rc { + Rc::from_inner(mem::ManuallyDrop::new(self).ptr.cast()) + } +} + +impl Rc<[mem::MaybeUninit]> { + /// Converts to `Rc<[T]>`. + /// + /// # Safety + /// + /// As with [`MaybeUninit::assume_init`], + /// it is up to the caller to guarantee that the inner value + /// really is in an initialized state. + /// Calling this when the content is not yet fully initialized + /// causes immediate undefined behavior. + /// + /// [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// #![feature(get_mut_unchecked)] + /// + /// use std::rc::Rc; + /// + /// let mut values = Rc::<[u32]>::new_uninit_slice(3); + /// + /// let values = unsafe { + /// // Deferred initialization: + /// Rc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1); + /// Rc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2); + /// Rc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3); + /// + /// values.assume_init() + /// }; + /// + /// assert_eq!(*values, [1, 2, 3]) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + #[inline] + pub unsafe fn assume_init(self) -> Rc<[T]> { + unsafe { Rc::from_ptr(mem::ManuallyDrop::new(self).ptr.as_ptr() as _) } + } +} + +impl Rc { + /// Consumes the `Rc`, returning the wrapped pointer. + /// + /// To avoid a memory leak the pointer must be converted back to an `Rc` using + /// [`Rc::from_raw`][from_raw]. + /// + /// [from_raw]: Rc::from_raw + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let x = Rc::new("hello".to_owned()); + /// let x_ptr = Rc::into_raw(x); + /// assert_eq!(unsafe { &*x_ptr }, "hello"); + /// ``` + #[stable(feature = "rc_raw", since = "1.17.0")] + pub fn into_raw(this: Self) -> *const T { + let ptr = Self::as_ptr(&this); + mem::forget(this); + ptr + } + + /// Provides a raw pointer to the data. + /// + /// The counts are not affected in any way and the `Rc` is not consumed. The pointer is valid + /// for as long there are strong counts in the `Rc`. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let x = Rc::new("hello".to_owned()); + /// let y = Rc::clone(&x); + /// let x_ptr = Rc::as_ptr(&x); + /// assert_eq!(x_ptr, Rc::as_ptr(&y)); + /// assert_eq!(unsafe { &*x_ptr }, "hello"); + /// ``` + #[stable(feature = "weak_into_raw", since = "1.45.0")] + pub fn as_ptr(this: &Self) -> *const T { + let ptr: *mut RcBox = NonNull::as_ptr(this.ptr); + + // SAFETY: This cannot go through Deref::deref or Rc::inner because + // this is required to retain raw/mut provenance such that e.g. `get_mut` can + // write through the pointer after the Rc is recovered through `from_raw`. + unsafe { &raw const (*ptr).value } + } + + /// Constructs an `Rc` from a raw pointer. + /// + /// The raw pointer must have been previously returned by a call to + /// [`Rc::into_raw`][into_raw] where `U` must have the same size + /// and alignment as `T`. This is trivially true if `U` is `T`. + /// Note that if `U` is not `T` but has the same size and alignment, this is + /// basically like transmuting references of different types. See + /// [`mem::transmute`][transmute] for more information on what + /// restrictions apply in this case. + /// + /// The user of `from_raw` has to make sure a specific value of `T` is only + /// dropped once. + /// + /// This function is unsafe because improper use may lead to memory unsafety, + /// even if the returned `Rc` is never accessed. + /// + /// [into_raw]: Rc::into_raw + /// [transmute]: core::mem::transmute + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let x = Rc::new("hello".to_owned()); + /// let x_ptr = Rc::into_raw(x); + /// + /// unsafe { + /// // Convert back to an `Rc` to prevent leak. + /// let x = Rc::from_raw(x_ptr); + /// assert_eq!(&*x, "hello"); + /// + /// // Further calls to `Rc::from_raw(x_ptr)` would be memory-unsafe. + /// } + /// + /// // The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling! + /// ``` + #[stable(feature = "rc_raw", since = "1.17.0")] + pub unsafe fn from_raw(ptr: *const T) -> Self { + let offset = unsafe { data_offset(ptr) }; + + // Reverse the offset to find the original RcBox. + let fake_ptr = ptr as *mut RcBox; + let rc_ptr = unsafe { set_data_ptr(fake_ptr, (ptr as *mut u8).offset(-offset)) }; + + unsafe { Self::from_ptr(rc_ptr) } + } + + /// Creates a new [`Weak`] pointer to this allocation. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// + /// let weak_five = Rc::downgrade(&five); + /// ``` + #[stable(feature = "rc_weak", since = "1.4.0")] + pub fn downgrade(this: &Self) -> Weak { + this.inner().inc_weak(); + // Make sure we do not create a dangling Weak + debug_assert!(!is_dangling(this.ptr)); + Weak { ptr: this.ptr } + } + + /// Gets the number of [`Weak`] pointers to this allocation. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// let _weak_five = Rc::downgrade(&five); + /// + /// assert_eq!(1, Rc::weak_count(&five)); + /// ``` + #[inline] + #[stable(feature = "rc_counts", since = "1.15.0")] + pub fn weak_count(this: &Self) -> usize { + this.inner().weak() - 1 + } + + /// Gets the number of strong (`Rc`) pointers to this allocation. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// let _also_five = Rc::clone(&five); + /// + /// assert_eq!(2, Rc::strong_count(&five)); + /// ``` + #[inline] + #[stable(feature = "rc_counts", since = "1.15.0")] + pub fn strong_count(this: &Self) -> usize { + this.inner().strong() + } + + /// Returns `true` if there are no other `Rc` or [`Weak`] pointers to + /// this allocation. + #[inline] + fn is_unique(this: &Self) -> bool { + Rc::weak_count(this) == 0 && Rc::strong_count(this) == 1 + } + + /// Returns a mutable reference into the given `Rc`, if there are + /// no other `Rc` or [`Weak`] pointers to the same allocation. + /// + /// Returns [`None`] otherwise, because it is not safe to + /// mutate a shared value. + /// + /// See also [`make_mut`][make_mut], which will [`clone`][clone] + /// the inner value when there are other pointers. + /// + /// [make_mut]: Rc::make_mut + /// [clone]: Clone::clone + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let mut x = Rc::new(3); + /// *Rc::get_mut(&mut x).unwrap() = 4; + /// assert_eq!(*x, 4); + /// + /// let _y = Rc::clone(&x); + /// assert!(Rc::get_mut(&mut x).is_none()); + /// ``` + #[inline] + #[stable(feature = "rc_unique", since = "1.4.0")] + pub fn get_mut(this: &mut Self) -> Option<&mut T> { + if Rc::is_unique(this) { unsafe { Some(Rc::get_mut_unchecked(this)) } } else { None } + } + + /// Returns a mutable reference into the given `Rc`, + /// without any check. + /// + /// See also [`get_mut`], which is safe and does appropriate checks. + /// + /// [`get_mut`]: Rc::get_mut + /// + /// # Safety + /// + /// Any other `Rc` or [`Weak`] pointers to the same allocation must not be dereferenced + /// for the duration of the returned borrow. + /// This is trivially the case if no such pointers exist, + /// for example immediately after `Rc::new`. + /// + /// # Examples + /// + /// ``` + /// #![feature(get_mut_unchecked)] + /// + /// use std::rc::Rc; + /// + /// let mut x = Rc::new(String::new()); + /// unsafe { + /// Rc::get_mut_unchecked(&mut x).push_str("foo") + /// } + /// assert_eq!(*x, "foo"); + /// ``` + #[inline] + #[unstable(feature = "get_mut_unchecked", issue = "63292")] + pub unsafe fn get_mut_unchecked(this: &mut Self) -> &mut T { + // We are careful to *not* create a reference covering the "count" fields, as + // this would conflict with accesses to the reference counts (e.g. by `Weak`). + unsafe { &mut (*this.ptr.as_ptr()).value } + } + + #[inline] + #[stable(feature = "ptr_eq", since = "1.17.0")] + /// Returns `true` if the two `Rc`s point to the same allocation + /// (in a vein similar to [`ptr::eq`]). + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// let same_five = Rc::clone(&five); + /// let other_five = Rc::new(5); + /// + /// assert!(Rc::ptr_eq(&five, &same_five)); + /// assert!(!Rc::ptr_eq(&five, &other_five)); + /// ``` + /// + /// [`ptr::eq`]: core::ptr::eq + pub fn ptr_eq(this: &Self, other: &Self) -> bool { + this.ptr.as_ptr() == other.ptr.as_ptr() + } +} + +impl Rc { + /// Makes a mutable reference into the given `Rc`. + /// + /// If there are other `Rc` pointers to the same allocation, then `make_mut` will + /// [`clone`] the inner value to a new allocation to ensure unique ownership. This is also + /// referred to as clone-on-write. + /// + /// If there are no other `Rc` pointers to this allocation, then [`Weak`] + /// pointers to this allocation will be disassociated. + /// + /// See also [`get_mut`], which will fail rather than cloning. + /// + /// [`clone`]: Clone::clone + /// [`get_mut`]: Rc::get_mut + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let mut data = Rc::new(5); + /// + /// *Rc::make_mut(&mut data) += 1; // Won't clone anything + /// let mut other_data = Rc::clone(&data); // Won't clone inner data + /// *Rc::make_mut(&mut data) += 1; // Clones inner data + /// *Rc::make_mut(&mut data) += 1; // Won't clone anything + /// *Rc::make_mut(&mut other_data) *= 2; // Won't clone anything + /// + /// // Now `data` and `other_data` point to different allocations. + /// assert_eq!(*data, 8); + /// assert_eq!(*other_data, 12); + /// ``` + /// + /// [`Weak`] pointers will be disassociated: + /// + /// ``` + /// use std::rc::Rc; + /// + /// let mut data = Rc::new(75); + /// let weak = Rc::downgrade(&data); + /// + /// assert!(75 == *data); + /// assert!(75 == *weak.upgrade().unwrap()); + /// + /// *Rc::make_mut(&mut data) += 1; + /// + /// assert!(76 == *data); + /// assert!(weak.upgrade().is_none()); + /// ``` + #[inline] + #[stable(feature = "rc_unique", since = "1.4.0")] + pub fn make_mut(this: &mut Self) -> &mut T { + if Rc::strong_count(this) != 1 { + // Gotta clone the data, there are other Rcs + *this = Rc::new((**this).clone()) + } else if Rc::weak_count(this) != 0 { + // Can just steal the data, all that's left is Weaks + unsafe { + let mut swap = Rc::new(ptr::read(&this.ptr.as_ref().value)); + mem::swap(this, &mut swap); + swap.inner().dec_strong(); + // Remove implicit strong-weak ref (no need to craft a fake + // Weak here -- we know other Weaks can clean up for us) + swap.inner().dec_weak(); + forget(swap); + } + } + // This unsafety is ok because we're guaranteed that the pointer + // returned is the *only* pointer that will ever be returned to T. Our + // reference count is guaranteed to be 1 at this point, and we required + // the `Rc` itself to be `mut`, so we're returning the only possible + // reference to the allocation. + unsafe { &mut this.ptr.as_mut().value } + } +} + +impl Rc { + #[inline] + #[stable(feature = "rc_downcast", since = "1.29.0")] + /// Attempt to downcast the `Rc` to a concrete type. + /// + /// # Examples + /// + /// ``` + /// use std::any::Any; + /// use std::rc::Rc; + /// + /// fn print_if_string(value: Rc) { + /// if let Ok(string) = value.downcast::() { + /// println!("String ({}): {}", string.len(), string); + /// } + /// } + /// + /// let my_string = "Hello World".to_string(); + /// print_if_string(Rc::new(my_string)); + /// print_if_string(Rc::new(0i8)); + /// ``` + pub fn downcast(self) -> Result, Rc> { + if (*self).is::() { + let ptr = self.ptr.cast::>(); + forget(self); + Ok(Rc::from_inner(ptr)) + } else { + Err(self) + } + } +} + +impl Rc { + /// Allocates an `RcBox` with sufficient space for + /// a possibly-unsized inner value where the value has the layout provided. + /// + /// The function `mem_to_rcbox` is called with the data pointer + /// and must return back a (potentially fat)-pointer for the `RcBox`. + unsafe fn allocate_for_layout( + value_layout: Layout, + allocate: impl FnOnce(Layout) -> Result, AllocError>, + mem_to_rcbox: impl FnOnce(*mut u8) -> *mut RcBox, + ) -> *mut RcBox { + // Calculate layout using the given value layout. + // Previously, layout was calculated on the expression + // `&*(ptr as *const RcBox)`, but this created a misaligned + // reference (see #54908). + let layout = Layout::new::>().extend(value_layout).unwrap().0.pad_to_align(); + + // Allocate for the layout. + let ptr = allocate(layout).unwrap_or_else(|_| handle_alloc_error(layout)); + + // Initialize the RcBox + let inner = mem_to_rcbox(ptr.as_non_null_ptr().as_ptr()); + unsafe { + debug_assert_eq!(Layout::for_value(&*inner), layout); + + ptr::write(&mut (*inner).strong, Cell::new(1)); + ptr::write(&mut (*inner).weak, Cell::new(1)); + } + + inner + } + + /// Allocates an `RcBox` with sufficient space for an unsized inner value + unsafe fn allocate_for_ptr(ptr: *const T) -> *mut RcBox { + // Allocate for the `RcBox` using the given value. + unsafe { + Self::allocate_for_layout( + Layout::for_value(&*ptr), + |layout| Global.alloc(layout), + |mem| set_data_ptr(ptr as *mut T, mem) as *mut RcBox, + ) + } + } + + fn from_box(v: Box) -> Rc { + unsafe { + let (box_unique, alloc) = Box::into_unique(v); + let bptr = box_unique.as_ptr(); + + let value_size = size_of_val(&*bptr); + let ptr = Self::allocate_for_ptr(bptr); + + // Copy value as bytes + ptr::copy_nonoverlapping( + bptr as *const T as *const u8, + &mut (*ptr).value as *mut _ as *mut u8, + value_size, + ); + + // Free the allocation without dropping its contents + box_free(box_unique, alloc); + + Self::from_ptr(ptr) + } + } +} + +impl Rc<[T]> { + /// Allocates an `RcBox<[T]>` with the given length. + unsafe fn allocate_for_slice(len: usize) -> *mut RcBox<[T]> { + unsafe { + Self::allocate_for_layout( + Layout::array::(len).unwrap(), + |layout| Global.alloc(layout), + |mem| ptr::slice_from_raw_parts_mut(mem as *mut T, len) as *mut RcBox<[T]>, + ) + } + } +} + +/// Sets the data pointer of a `?Sized` raw pointer. +/// +/// For a slice/trait object, this sets the `data` field and leaves the rest +/// unchanged. For a sized raw pointer, this simply sets the pointer. +unsafe fn set_data_ptr(mut ptr: *mut T, data: *mut U) -> *mut T { + unsafe { + ptr::write(&mut ptr as *mut _ as *mut *mut u8, data as *mut u8); + } + ptr +} + +impl Rc<[T]> { + /// Copy elements from slice into newly allocated Rc<\[T\]> + /// + /// Unsafe because the caller must either take ownership or bind `T: Copy` + unsafe fn copy_from_slice(v: &[T]) -> Rc<[T]> { + unsafe { + let ptr = Self::allocate_for_slice(v.len()); + ptr::copy_nonoverlapping(v.as_ptr(), &mut (*ptr).value as *mut [T] as *mut T, v.len()); + Self::from_ptr(ptr) + } + } + + /// Constructs an `Rc<[T]>` from an iterator known to be of a certain size. + /// + /// Behavior is undefined should the size be wrong. + unsafe fn from_iter_exact(iter: impl iter::Iterator, len: usize) -> Rc<[T]> { + // Panic guard while cloning T elements. + // In the event of a panic, elements that have been written + // into the new RcBox will be dropped, then the memory freed. + struct Guard { + mem: NonNull, + elems: *mut T, + layout: Layout, + n_elems: usize, + } + + impl Drop for Guard { + fn drop(&mut self) { + unsafe { + let slice = from_raw_parts_mut(self.elems, self.n_elems); + ptr::drop_in_place(slice); + + Global.dealloc(self.mem, self.layout); + } + } + } + + unsafe { + let ptr = Self::allocate_for_slice(len); + + let mem = ptr as *mut _ as *mut u8; + let layout = Layout::for_value(&*ptr); + + // Pointer to first element + let elems = &mut (*ptr).value as *mut [T] as *mut T; + + let mut guard = Guard { mem: NonNull::new_unchecked(mem), elems, layout, n_elems: 0 }; + + for (i, item) in iter.enumerate() { + ptr::write(elems.add(i), item); + guard.n_elems += 1; + } + + // All clear. Forget the guard so it doesn't free the new RcBox. + forget(guard); + + Self::from_ptr(ptr) + } + } +} + +/// Specialization trait used for `From<&[T]>`. +trait RcFromSlice { + fn from_slice(slice: &[T]) -> Self; +} + +impl RcFromSlice for Rc<[T]> { + #[inline] + default fn from_slice(v: &[T]) -> Self { + unsafe { Self::from_iter_exact(v.iter().cloned(), v.len()) } + } +} + +impl RcFromSlice for Rc<[T]> { + #[inline] + fn from_slice(v: &[T]) -> Self { + unsafe { Rc::copy_from_slice(v) } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Deref for Rc { + type Target = T; + + #[inline(always)] + fn deref(&self) -> &T { + &self.inner().value + } +} + +#[unstable(feature = "receiver_trait", issue = "none")] +impl Receiver for Rc {} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl<#[may_dangle] T: ?Sized> Drop for Rc { + /// Drops the `Rc`. + /// + /// This will decrement the strong reference count. If the strong reference + /// count reaches zero then the only other references (if any) are + /// [`Weak`], so we `drop` the inner value. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// struct Foo; + /// + /// impl Drop for Foo { + /// fn drop(&mut self) { + /// println!("dropped!"); + /// } + /// } + /// + /// let foo = Rc::new(Foo); + /// let foo2 = Rc::clone(&foo); + /// + /// drop(foo); // Doesn't print anything + /// drop(foo2); // Prints "dropped!" + /// ``` + fn drop(&mut self) { + unsafe { + self.inner().dec_strong(); + if self.inner().strong() == 0 { + // destroy the contained object + ptr::drop_in_place(Self::get_mut_unchecked(self)); + + // remove the implicit "strong weak" pointer now that we've + // destroyed the contents. + self.inner().dec_weak(); + + if self.inner().weak() == 0 { + Global.dealloc(self.ptr.cast(), Layout::for_value(self.ptr.as_ref())); + } + } + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Rc { + /// Makes a clone of the `Rc` pointer. + /// + /// This creates another pointer to the same allocation, increasing the + /// strong reference count. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// + /// let _ = Rc::clone(&five); + /// ``` + #[inline] + fn clone(&self) -> Rc { + self.inner().inc_strong(); + Self::from_inner(self.ptr) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for Rc { + /// Creates a new `Rc`, with the `Default` value for `T`. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let x: Rc = Default::default(); + /// assert_eq!(*x, 0); + /// ``` + #[inline] + fn default() -> Rc { + Rc::new(Default::default()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +trait RcEqIdent { + fn eq(&self, other: &Rc) -> bool; + fn ne(&self, other: &Rc) -> bool; +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl RcEqIdent for Rc { + #[inline] + default fn eq(&self, other: &Rc) -> bool { + **self == **other + } + + #[inline] + default fn ne(&self, other: &Rc) -> bool { + **self != **other + } +} + +// Hack to allow specializing on `Eq` even though `Eq` has a method. +#[rustc_unsafe_specialization_marker] +pub(crate) trait MarkerEq: PartialEq {} + +impl MarkerEq for T {} + +/// We're doing this specialization here, and not as a more general optimization on `&T`, because it +/// would otherwise add a cost to all equality checks on refs. We assume that `Rc`s are used to +/// store large values, that are slow to clone, but also heavy to check for equality, causing this +/// cost to pay off more easily. It's also more likely to have two `Rc` clones, that point to +/// the same value, than two `&T`s. +/// +/// We can only do this when `T: Eq` as a `PartialEq` might be deliberately irreflexive. +#[stable(feature = "rust1", since = "1.0.0")] +impl RcEqIdent for Rc { + #[inline] + fn eq(&self, other: &Rc) -> bool { + Rc::ptr_eq(self, other) || **self == **other + } + + #[inline] + fn ne(&self, other: &Rc) -> bool { + !Rc::ptr_eq(self, other) && **self != **other + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialEq for Rc { + /// Equality for two `Rc`s. + /// + /// Two `Rc`s are equal if their inner values are equal, even if they are + /// stored in different allocation. + /// + /// If `T` also implements `Eq` (implying reflexivity of equality), + /// two `Rc`s that point to the same allocation are + /// always equal. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// + /// assert!(five == Rc::new(5)); + /// ``` + #[inline] + fn eq(&self, other: &Rc) -> bool { + RcEqIdent::eq(self, other) + } + + /// Inequality for two `Rc`s. + /// + /// Two `Rc`s are unequal if their inner values are unequal. + /// + /// If `T` also implements `Eq` (implying reflexivity of equality), + /// two `Rc`s that point to the same allocation are + /// never unequal. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// + /// assert!(five != Rc::new(6)); + /// ``` + #[inline] + fn ne(&self, other: &Rc) -> bool { + RcEqIdent::ne(self, other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Eq for Rc {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialOrd for Rc { + /// Partial comparison for two `Rc`s. + /// + /// The two are compared by calling `partial_cmp()` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// use std::cmp::Ordering; + /// + /// let five = Rc::new(5); + /// + /// assert_eq!(Some(Ordering::Less), five.partial_cmp(&Rc::new(6))); + /// ``` + #[inline(always)] + fn partial_cmp(&self, other: &Rc) -> Option { + (**self).partial_cmp(&**other) + } + + /// Less-than comparison for two `Rc`s. + /// + /// The two are compared by calling `<` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// + /// assert!(five < Rc::new(6)); + /// ``` + #[inline(always)] + fn lt(&self, other: &Rc) -> bool { + **self < **other + } + + /// 'Less than or equal to' comparison for two `Rc`s. + /// + /// The two are compared by calling `<=` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// + /// assert!(five <= Rc::new(5)); + /// ``` + #[inline(always)] + fn le(&self, other: &Rc) -> bool { + **self <= **other + } + + /// Greater-than comparison for two `Rc`s. + /// + /// The two are compared by calling `>` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// + /// assert!(five > Rc::new(4)); + /// ``` + #[inline(always)] + fn gt(&self, other: &Rc) -> bool { + **self > **other + } + + /// 'Greater than or equal to' comparison for two `Rc`s. + /// + /// The two are compared by calling `>=` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// + /// assert!(five >= Rc::new(5)); + /// ``` + #[inline(always)] + fn ge(&self, other: &Rc) -> bool { + **self >= **other + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Ord for Rc { + /// Comparison for two `Rc`s. + /// + /// The two are compared by calling `cmp()` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// use std::cmp::Ordering; + /// + /// let five = Rc::new(5); + /// + /// assert_eq!(Ordering::Less, five.cmp(&Rc::new(6))); + /// ``` + #[inline] + fn cmp(&self, other: &Rc) -> Ordering { + (**self).cmp(&**other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Hash for Rc { + fn hash(&self, state: &mut H) { + (**self).hash(state); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Display for Rc { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Display::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Debug for Rc { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Debug::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Pointer for Rc { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Pointer::fmt(&(&**self as *const T), f) + } +} + +#[stable(feature = "from_for_ptrs", since = "1.6.0")] +impl From for Rc { + fn from(t: T) -> Self { + Rc::new(t) + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From<&[T]> for Rc<[T]> { + #[inline] + fn from(v: &[T]) -> Rc<[T]> { + >::from_slice(v) + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From<&str> for Rc { + #[inline] + fn from(v: &str) -> Rc { + let rc = Rc::<[u8]>::from(v.as_bytes()); + unsafe { Rc::from_raw(Rc::into_raw(rc) as *const str) } + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From for Rc { + #[inline] + fn from(v: String) -> Rc { + Rc::from(&v[..]) + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From> for Rc { + #[inline] + fn from(v: Box) -> Rc { + Rc::from_box(v) + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From> for Rc<[T]> { + #[inline] + fn from(mut v: Vec) -> Rc<[T]> { + unsafe { + let rc = Rc::copy_from_slice(&v); + + // Allow the Vec to free its memory, but not destroy its contents + v.set_len(0); + + rc + } + } +} + +#[stable(feature = "shared_from_cow", since = "1.45.0")] +impl<'a, B> From> for Rc +where + B: ToOwned + ?Sized, + Rc: From<&'a B> + From, +{ + #[inline] + fn from(cow: Cow<'a, B>) -> Rc { + match cow { + Cow::Borrowed(s) => Rc::from(s), + Cow::Owned(s) => Rc::from(s), + } + } +} + +#[stable(feature = "boxed_slice_try_from", since = "1.43.0")] +impl TryFrom> for Rc<[T; N]> { + type Error = Rc<[T]>; + + fn try_from(boxed_slice: Rc<[T]>) -> Result { + if boxed_slice.len() == N { + Ok(unsafe { Rc::from_raw(Rc::into_raw(boxed_slice) as *mut [T; N]) }) + } else { + Err(boxed_slice) + } + } +} + +#[stable(feature = "shared_from_iter", since = "1.37.0")] +impl iter::FromIterator for Rc<[T]> { + /// Takes each element in the `Iterator` and collects it into an `Rc<[T]>`. + /// + /// # Performance characteristics + /// + /// ## The general case + /// + /// In the general case, collecting into `Rc<[T]>` is done by first + /// collecting into a `Vec`. That is, when writing the following: + /// + /// ```rust + /// # use std::rc::Rc; + /// let evens: Rc<[u8]> = (0..10).filter(|&x| x % 2 == 0).collect(); + /// # assert_eq!(&*evens, &[0, 2, 4, 6, 8]); + /// ``` + /// + /// this behaves as if we wrote: + /// + /// ```rust + /// # use std::rc::Rc; + /// let evens: Rc<[u8]> = (0..10).filter(|&x| x % 2 == 0) + /// .collect::>() // The first set of allocations happens here. + /// .into(); // A second allocation for `Rc<[T]>` happens here. + /// # assert_eq!(&*evens, &[0, 2, 4, 6, 8]); + /// ``` + /// + /// This will allocate as many times as needed for constructing the `Vec` + /// and then it will allocate once for turning the `Vec` into the `Rc<[T]>`. + /// + /// ## Iterators of known length + /// + /// When your `Iterator` implements `TrustedLen` and is of an exact size, + /// a single allocation will be made for the `Rc<[T]>`. For example: + /// + /// ```rust + /// # use std::rc::Rc; + /// let evens: Rc<[u8]> = (0..10).collect(); // Just a single allocation happens here. + /// # assert_eq!(&*evens, &*(0..10).collect::>()); + /// ``` + fn from_iter>(iter: I) -> Self { + ToRcSlice::to_rc_slice(iter.into_iter()) + } +} + +/// Specialization trait used for collecting into `Rc<[T]>`. +trait ToRcSlice: Iterator + Sized { + fn to_rc_slice(self) -> Rc<[T]>; +} + +impl> ToRcSlice for I { + default fn to_rc_slice(self) -> Rc<[T]> { + self.collect::>().into() + } +} + +impl> ToRcSlice for I { + fn to_rc_slice(self) -> Rc<[T]> { + // This is the case for a `TrustedLen` iterator. + let (low, high) = self.size_hint(); + if let Some(high) = high { + debug_assert_eq!( + low, + high, + "TrustedLen iterator's size hint is not exact: {:?}", + (low, high) + ); + + unsafe { + // SAFETY: We need to ensure that the iterator has an exact length and we have. + Rc::from_iter_exact(self, low) + } + } else { + // Fall back to normal implementation. + self.collect::>().into() + } + } +} + +/// `Weak` is a version of [`Rc`] that holds a non-owning reference to the +/// managed allocation. The allocation is accessed by calling [`upgrade`] on the `Weak` +/// pointer, which returns an [`Option`]`<`[`Rc`]`>`. +/// +/// Since a `Weak` reference does not count towards ownership, it will not +/// prevent the value stored in the allocation from being dropped, and `Weak` itself makes no +/// guarantees about the value still being present. Thus it may return [`None`] +/// when [`upgrade`]d. Note however that a `Weak` reference *does* prevent the allocation +/// itself (the backing store) from being deallocated. +/// +/// A `Weak` pointer is useful for keeping a temporary reference to the allocation +/// managed by [`Rc`] without preventing its inner value from being dropped. It is also used to +/// prevent circular references between [`Rc`] pointers, since mutual owning references +/// would never allow either [`Rc`] to be dropped. For example, a tree could +/// have strong [`Rc`] pointers from parent nodes to children, and `Weak` +/// pointers from children back to their parents. +/// +/// The typical way to obtain a `Weak` pointer is to call [`Rc::downgrade`]. +/// +/// [`upgrade`]: Weak::upgrade +#[stable(feature = "rc_weak", since = "1.4.0")] +pub struct Weak { + // This is a `NonNull` to allow optimizing the size of this type in enums, + // but it is not necessarily a valid pointer. + // `Weak::new` sets this to `usize::MAX` so that it doesn’t need + // to allocate space on the heap. That's not a value a real pointer + // will ever have because RcBox has alignment at least 2. + // This is only possible when `T: Sized`; unsized `T` never dangle. + ptr: NonNull>, +} + +#[stable(feature = "rc_weak", since = "1.4.0")] +impl !marker::Send for Weak {} +#[stable(feature = "rc_weak", since = "1.4.0")] +impl !marker::Sync for Weak {} + +#[unstable(feature = "coerce_unsized", issue = "27732")] +impl, U: ?Sized> CoerceUnsized> for Weak {} + +#[unstable(feature = "dispatch_from_dyn", issue = "none")] +impl, U: ?Sized> DispatchFromDyn> for Weak {} + +impl Weak { + /// Constructs a new `Weak`, without allocating any memory. + /// Calling [`upgrade`] on the return value always gives [`None`]. + /// + /// [`upgrade`]: Weak::upgrade + /// + /// # Examples + /// + /// ``` + /// use std::rc::Weak; + /// + /// let empty: Weak = Weak::new(); + /// assert!(empty.upgrade().is_none()); + /// ``` + #[stable(feature = "downgraded_weak", since = "1.10.0")] + pub fn new() -> Weak { + Weak { ptr: NonNull::new(usize::MAX as *mut RcBox).expect("MAX is not 0") } + } +} + +pub(crate) fn is_dangling(ptr: NonNull) -> bool { + let address = ptr.as_ptr() as *mut () as usize; + address == usize::MAX +} + +/// Helper type to allow accessing the reference counts without +/// making any assertions about the data field. +struct WeakInner<'a> { + weak: &'a Cell, + strong: &'a Cell, +} + +impl Weak { + /// Returns a raw pointer to the object `T` pointed to by this `Weak`. + /// + /// The pointer is valid only if there are some strong references. The pointer may be dangling, + /// unaligned or even [`null`] otherwise. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// use std::ptr; + /// + /// let strong = Rc::new("hello".to_owned()); + /// let weak = Rc::downgrade(&strong); + /// // Both point to the same object + /// assert!(ptr::eq(&*strong, weak.as_ptr())); + /// // The strong here keeps it alive, so we can still access the object. + /// assert_eq!("hello", unsafe { &*weak.as_ptr() }); + /// + /// drop(strong); + /// // But not any more. We can do weak.as_ptr(), but accessing the pointer would lead to + /// // undefined behaviour. + /// // assert_eq!("hello", unsafe { &*weak.as_ptr() }); + /// ``` + /// + /// [`null`]: core::ptr::null + #[stable(feature = "rc_as_ptr", since = "1.45.0")] + pub fn as_ptr(&self) -> *const T { + let ptr: *mut RcBox = NonNull::as_ptr(self.ptr); + + // SAFETY: we must offset the pointer manually, and said pointer may be + // a dangling weak (usize::MAX) if T is sized. data_offset is safe to call, + // because we know that a pointer to unsized T was derived from a real + // unsized T, as dangling weaks are only created for sized T. wrapping_offset + // is used so that we can use the same code path for the non-dangling + // unsized case and the potentially dangling sized case. + unsafe { + let offset = data_offset(ptr as *mut T); + set_data_ptr(ptr as *mut T, (ptr as *mut u8).wrapping_offset(offset)) + } + } + + /// Consumes the `Weak` and turns it into a raw pointer. + /// + /// This converts the weak pointer into a raw pointer, while still preserving the ownership of + /// one weak reference (the weak count is not modified by this operation). It can be turned + /// back into the `Weak` with [`from_raw`]. + /// + /// The same restrictions of accessing the target of the pointer as with + /// [`as_ptr`] apply. + /// + /// # Examples + /// + /// ``` + /// use std::rc::{Rc, Weak}; + /// + /// let strong = Rc::new("hello".to_owned()); + /// let weak = Rc::downgrade(&strong); + /// let raw = weak.into_raw(); + /// + /// assert_eq!(1, Rc::weak_count(&strong)); + /// assert_eq!("hello", unsafe { &*raw }); + /// + /// drop(unsafe { Weak::from_raw(raw) }); + /// assert_eq!(0, Rc::weak_count(&strong)); + /// ``` + /// + /// [`from_raw`]: Weak::from_raw + /// [`as_ptr`]: Weak::as_ptr + #[stable(feature = "weak_into_raw", since = "1.45.0")] + pub fn into_raw(self) -> *const T { + let result = self.as_ptr(); + mem::forget(self); + result + } + + /// Converts a raw pointer previously created by [`into_raw`] back into `Weak`. + /// + /// This can be used to safely get a strong reference (by calling [`upgrade`] + /// later) or to deallocate the weak count by dropping the `Weak`. + /// + /// It takes ownership of one weak reference (with the exception of pointers created by [`new`], + /// as these don't own anything; the method still works on them). + /// + /// # Safety + /// + /// The pointer must have originated from the [`into_raw`] and must still own its potential + /// weak reference. + /// + /// It is allowed for the strong count to be 0 at the time of calling this. Nevertheless, this + /// takes ownership of one weak reference currently represented as a raw pointer (the weak + /// count is not modified by this operation) and therefore it must be paired with a previous + /// call to [`into_raw`]. + /// + /// # Examples + /// + /// ``` + /// use std::rc::{Rc, Weak}; + /// + /// let strong = Rc::new("hello".to_owned()); + /// + /// let raw_1 = Rc::downgrade(&strong).into_raw(); + /// let raw_2 = Rc::downgrade(&strong).into_raw(); + /// + /// assert_eq!(2, Rc::weak_count(&strong)); + /// + /// assert_eq!("hello", &*unsafe { Weak::from_raw(raw_1) }.upgrade().unwrap()); + /// assert_eq!(1, Rc::weak_count(&strong)); + /// + /// drop(strong); + /// + /// // Decrement the last weak count. + /// assert!(unsafe { Weak::from_raw(raw_2) }.upgrade().is_none()); + /// ``` + /// + /// [`into_raw`]: Weak::into_raw + /// [`upgrade`]: Weak::upgrade + /// [`new`]: Weak::new + #[stable(feature = "weak_into_raw", since = "1.45.0")] + pub unsafe fn from_raw(ptr: *const T) -> Self { + // SAFETY: data_offset is safe to call, because this pointer originates from a Weak. + // See Weak::as_ptr for context on how the input pointer is derived. + let offset = unsafe { data_offset(ptr) }; + + // Reverse the offset to find the original RcBox. + // SAFETY: we use wrapping_offset here because the pointer may be dangling (but only if T: Sized). + let ptr = unsafe { + set_data_ptr(ptr as *mut RcBox, (ptr as *mut u8).wrapping_offset(-offset)) + }; + + // SAFETY: we now have recovered the original Weak pointer, so can create the Weak. + Weak { ptr: unsafe { NonNull::new_unchecked(ptr) } } + } +} + +impl Weak { + /// Attempts to upgrade the `Weak` pointer to an [`Rc`], delaying + /// dropping of the inner value if successful. + /// + /// Returns [`None`] if the inner value has since been dropped. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// + /// let weak_five = Rc::downgrade(&five); + /// + /// let strong_five: Option> = weak_five.upgrade(); + /// assert!(strong_five.is_some()); + /// + /// // Destroy all strong pointers. + /// drop(strong_five); + /// drop(five); + /// + /// assert!(weak_five.upgrade().is_none()); + /// ``` + #[stable(feature = "rc_weak", since = "1.4.0")] + pub fn upgrade(&self) -> Option> { + let inner = self.inner()?; + if inner.strong() == 0 { + None + } else { + inner.inc_strong(); + Some(Rc::from_inner(self.ptr)) + } + } + + /// Gets the number of strong (`Rc`) pointers pointing to this allocation. + /// + /// If `self` was created using [`Weak::new`], this will return 0. + #[stable(feature = "weak_counts", since = "1.41.0")] + pub fn strong_count(&self) -> usize { + if let Some(inner) = self.inner() { inner.strong() } else { 0 } + } + + /// Gets the number of `Weak` pointers pointing to this allocation. + /// + /// If no strong pointers remain, this will return zero. + #[stable(feature = "weak_counts", since = "1.41.0")] + pub fn weak_count(&self) -> usize { + self.inner() + .map(|inner| { + if inner.strong() > 0 { + inner.weak() - 1 // subtract the implicit weak ptr + } else { + 0 + } + }) + .unwrap_or(0) + } + + /// Returns `None` when the pointer is dangling and there is no allocated `RcBox`, + /// (i.e., when this `Weak` was created by `Weak::new`). + #[inline] + fn inner(&self) -> Option> { + if is_dangling(self.ptr) { + None + } else { + // We are careful to *not* create a reference covering the "data" field, as + // the field may be mutated concurrently (for example, if the last `Rc` + // is dropped, the data field will be dropped in-place). + Some(unsafe { + let ptr = self.ptr.as_ptr(); + WeakInner { strong: &(*ptr).strong, weak: &(*ptr).weak } + }) + } + } + + /// Returns `true` if the two `Weak`s point to the same allocation (similar to + /// [`ptr::eq`]), or if both don't point to any allocation + /// (because they were created with `Weak::new()`). + /// + /// # Notes + /// + /// Since this compares pointers it means that `Weak::new()` will equal each + /// other, even though they don't point to any allocation. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let first_rc = Rc::new(5); + /// let first = Rc::downgrade(&first_rc); + /// let second = Rc::downgrade(&first_rc); + /// + /// assert!(first.ptr_eq(&second)); + /// + /// let third_rc = Rc::new(5); + /// let third = Rc::downgrade(&third_rc); + /// + /// assert!(!first.ptr_eq(&third)); + /// ``` + /// + /// Comparing `Weak::new`. + /// + /// ``` + /// use std::rc::{Rc, Weak}; + /// + /// let first = Weak::new(); + /// let second = Weak::new(); + /// assert!(first.ptr_eq(&second)); + /// + /// let third_rc = Rc::new(()); + /// let third = Rc::downgrade(&third_rc); + /// assert!(!first.ptr_eq(&third)); + /// ``` + /// + /// [`ptr::eq`]: core::ptr::eq + #[inline] + #[stable(feature = "weak_ptr_eq", since = "1.39.0")] + pub fn ptr_eq(&self, other: &Self) -> bool { + self.ptr.as_ptr() == other.ptr.as_ptr() + } +} + +#[stable(feature = "rc_weak", since = "1.4.0")] +impl Drop for Weak { + /// Drops the `Weak` pointer. + /// + /// # Examples + /// + /// ``` + /// use std::rc::{Rc, Weak}; + /// + /// struct Foo; + /// + /// impl Drop for Foo { + /// fn drop(&mut self) { + /// println!("dropped!"); + /// } + /// } + /// + /// let foo = Rc::new(Foo); + /// let weak_foo = Rc::downgrade(&foo); + /// let other_weak_foo = Weak::clone(&weak_foo); + /// + /// drop(weak_foo); // Doesn't print anything + /// drop(foo); // Prints "dropped!" + /// + /// assert!(other_weak_foo.upgrade().is_none()); + /// ``` + fn drop(&mut self) { + let inner = if let Some(inner) = self.inner() { inner } else { return }; + + inner.dec_weak(); + // the weak count starts at 1, and will only go to zero if all + // the strong pointers have disappeared. + if inner.weak() == 0 { + unsafe { + Global.dealloc(self.ptr.cast(), Layout::for_value(self.ptr.as_ref())); + } + } + } +} + +#[stable(feature = "rc_weak", since = "1.4.0")] +impl Clone for Weak { + /// Makes a clone of the `Weak` pointer that points to the same allocation. + /// + /// # Examples + /// + /// ``` + /// use std::rc::{Rc, Weak}; + /// + /// let weak_five = Rc::downgrade(&Rc::new(5)); + /// + /// let _ = Weak::clone(&weak_five); + /// ``` + #[inline] + fn clone(&self) -> Weak { + if let Some(inner) = self.inner() { + inner.inc_weak() + } + Weak { ptr: self.ptr } + } +} + +#[stable(feature = "rc_weak", since = "1.4.0")] +impl fmt::Debug for Weak { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "(Weak)") + } +} + +#[stable(feature = "downgraded_weak", since = "1.10.0")] +impl Default for Weak { + /// Constructs a new `Weak`, allocating memory for `T` without initializing + /// it. Calling [`upgrade`] on the return value always gives [`None`]. + /// + /// [`None`]: Option + /// [`upgrade`]: Weak::upgrade + /// + /// # Examples + /// + /// ``` + /// use std::rc::Weak; + /// + /// let empty: Weak = Default::default(); + /// assert!(empty.upgrade().is_none()); + /// ``` + fn default() -> Weak { + Weak::new() + } +} + +// NOTE: We checked_add here to deal with mem::forget safely. In particular +// if you mem::forget Rcs (or Weaks), the ref-count can overflow, and then +// you can free the allocation while outstanding Rcs (or Weaks) exist. +// We abort because this is such a degenerate scenario that we don't care about +// what happens -- no real program should ever experience this. +// +// This should have negligible overhead since you don't actually need to +// clone these much in Rust thanks to ownership and move-semantics. + +#[doc(hidden)] +trait RcInnerPtr { + fn weak_ref(&self) -> &Cell; + fn strong_ref(&self) -> &Cell; + + #[inline] + fn strong(&self) -> usize { + self.strong_ref().get() + } + + #[inline] + fn inc_strong(&self) { + let strong = self.strong(); + + // We want to abort on overflow instead of dropping the value. + // The reference count will never be zero when this is called; + // nevertheless, we insert an abort here to hint LLVM at + // an otherwise missed optimization. + if strong == 0 || strong == usize::MAX { + abort(); + } + self.strong_ref().set(strong + 1); + } + + #[inline] + fn dec_strong(&self) { + self.strong_ref().set(self.strong() - 1); + } + + #[inline] + fn weak(&self) -> usize { + self.weak_ref().get() + } + + #[inline] + fn inc_weak(&self) { + let weak = self.weak(); + + // We want to abort on overflow instead of dropping the value. + // The reference count will never be zero when this is called; + // nevertheless, we insert an abort here to hint LLVM at + // an otherwise missed optimization. + if weak == 0 || weak == usize::MAX { + abort(); + } + self.weak_ref().set(weak + 1); + } + + #[inline] + fn dec_weak(&self) { + self.weak_ref().set(self.weak() - 1); + } +} + +impl RcInnerPtr for RcBox { + #[inline(always)] + fn weak_ref(&self) -> &Cell { + &self.weak + } + + #[inline(always)] + fn strong_ref(&self) -> &Cell { + &self.strong + } +} + +impl<'a> RcInnerPtr for WeakInner<'a> { + #[inline(always)] + fn weak_ref(&self) -> &Cell { + self.weak + } + + #[inline(always)] + fn strong_ref(&self) -> &Cell { + self.strong + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl borrow::Borrow for Rc { + fn borrow(&self) -> &T { + &**self + } +} + +#[stable(since = "1.5.0", feature = "smart_ptr_as_ref")] +impl AsRef for Rc { + fn as_ref(&self) -> &T { + &**self + } +} + +#[stable(feature = "pin", since = "1.33.0")] +impl Unpin for Rc {} + +/// Get the offset within an `RcBox` for +/// a payload of type described by a pointer. +/// +/// # Safety +/// +/// This has the same safety requirements as `align_of_val_raw`. In effect: +/// +/// - This function is safe for any argument if `T` is sized, and +/// - if `T` is unsized, the pointer must have appropriate pointer metadata +/// acquired from the real instance that you are getting this offset for. +unsafe fn data_offset(ptr: *const T) -> isize { + // Align the unsized value to the end of the `RcBox`. + // Because it is ?Sized, it will always be the last field in memory. + // Note: This is a detail of the current implementation of the compiler, + // and is not a guaranteed language detail. Do not rely on it outside of std. + unsafe { data_offset_align(align_of_val_raw(ptr)) } +} + +#[inline] +fn data_offset_align(align: usize) -> isize { + let layout = Layout::new::>(); + (layout.size() + layout.padding_needed_for(align)) as isize +} diff --git a/libgrust/rustc-lib/alloc/src/rc/tests.rs b/libgrust/rustc-lib/alloc/src/rc/tests.rs new file mode 100644 index 000000000000..2d183a8c88c6 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/rc/tests.rs @@ -0,0 +1,520 @@ +use super::*; + +use std::boxed::Box; +use std::cell::RefCell; +use std::clone::Clone; +use std::convert::{From, TryInto}; +use std::mem::drop; +use std::option::Option::{self, None, Some}; +use std::result::Result::{Err, Ok}; + +#[test] +fn test_clone() { + let x = Rc::new(RefCell::new(5)); + let y = x.clone(); + *x.borrow_mut() = 20; + assert_eq!(*y.borrow(), 20); +} + +#[test] +fn test_simple() { + let x = Rc::new(5); + assert_eq!(*x, 5); +} + +#[test] +fn test_simple_clone() { + let x = Rc::new(5); + let y = x.clone(); + assert_eq!(*x, 5); + assert_eq!(*y, 5); +} + +#[test] +fn test_destructor() { + let x: Rc> = Rc::new(box 5); + assert_eq!(**x, 5); +} + +#[test] +fn test_live() { + let x = Rc::new(5); + let y = Rc::downgrade(&x); + assert!(y.upgrade().is_some()); +} + +#[test] +fn test_dead() { + let x = Rc::new(5); + let y = Rc::downgrade(&x); + drop(x); + assert!(y.upgrade().is_none()); +} + +#[test] +fn weak_self_cyclic() { + struct Cycle { + x: RefCell>>, + } + + let a = Rc::new(Cycle { x: RefCell::new(None) }); + let b = Rc::downgrade(&a.clone()); + *a.x.borrow_mut() = Some(b); + + // hopefully we don't double-free (or leak)... +} + +#[test] +fn is_unique() { + let x = Rc::new(3); + assert!(Rc::is_unique(&x)); + let y = x.clone(); + assert!(!Rc::is_unique(&x)); + drop(y); + assert!(Rc::is_unique(&x)); + let w = Rc::downgrade(&x); + assert!(!Rc::is_unique(&x)); + drop(w); + assert!(Rc::is_unique(&x)); +} + +#[test] +fn test_strong_count() { + let a = Rc::new(0); + assert!(Rc::strong_count(&a) == 1); + let w = Rc::downgrade(&a); + assert!(Rc::strong_count(&a) == 1); + let b = w.upgrade().expect("upgrade of live rc failed"); + assert!(Rc::strong_count(&b) == 2); + assert!(Rc::strong_count(&a) == 2); + drop(w); + drop(a); + assert!(Rc::strong_count(&b) == 1); + let c = b.clone(); + assert!(Rc::strong_count(&b) == 2); + assert!(Rc::strong_count(&c) == 2); +} + +#[test] +fn test_weak_count() { + let a = Rc::new(0); + assert!(Rc::strong_count(&a) == 1); + assert!(Rc::weak_count(&a) == 0); + let w = Rc::downgrade(&a); + assert!(Rc::strong_count(&a) == 1); + assert!(Rc::weak_count(&a) == 1); + drop(w); + assert!(Rc::strong_count(&a) == 1); + assert!(Rc::weak_count(&a) == 0); + let c = a.clone(); + assert!(Rc::strong_count(&a) == 2); + assert!(Rc::weak_count(&a) == 0); + drop(c); +} + +#[test] +fn weak_counts() { + assert_eq!(Weak::weak_count(&Weak::::new()), 0); + assert_eq!(Weak::strong_count(&Weak::::new()), 0); + + let a = Rc::new(0); + let w = Rc::downgrade(&a); + assert_eq!(Weak::strong_count(&w), 1); + assert_eq!(Weak::weak_count(&w), 1); + let w2 = w.clone(); + assert_eq!(Weak::strong_count(&w), 1); + assert_eq!(Weak::weak_count(&w), 2); + assert_eq!(Weak::strong_count(&w2), 1); + assert_eq!(Weak::weak_count(&w2), 2); + drop(w); + assert_eq!(Weak::strong_count(&w2), 1); + assert_eq!(Weak::weak_count(&w2), 1); + let a2 = a.clone(); + assert_eq!(Weak::strong_count(&w2), 2); + assert_eq!(Weak::weak_count(&w2), 1); + drop(a2); + drop(a); + assert_eq!(Weak::strong_count(&w2), 0); + assert_eq!(Weak::weak_count(&w2), 0); + drop(w2); +} + +#[test] +fn try_unwrap() { + let x = Rc::new(3); + assert_eq!(Rc::try_unwrap(x), Ok(3)); + let x = Rc::new(4); + let _y = x.clone(); + assert_eq!(Rc::try_unwrap(x), Err(Rc::new(4))); + let x = Rc::new(5); + let _w = Rc::downgrade(&x); + assert_eq!(Rc::try_unwrap(x), Ok(5)); +} + +#[test] +fn into_from_raw() { + let x = Rc::new(box "hello"); + let y = x.clone(); + + let x_ptr = Rc::into_raw(x); + drop(y); + unsafe { + assert_eq!(**x_ptr, "hello"); + + let x = Rc::from_raw(x_ptr); + assert_eq!(**x, "hello"); + + assert_eq!(Rc::try_unwrap(x).map(|x| *x), Ok("hello")); + } +} + +#[test] +fn test_into_from_raw_unsized() { + use std::fmt::Display; + use std::string::ToString; + + let rc: Rc = Rc::from("foo"); + + let ptr = Rc::into_raw(rc.clone()); + let rc2 = unsafe { Rc::from_raw(ptr) }; + + assert_eq!(unsafe { &*ptr }, "foo"); + assert_eq!(rc, rc2); + + let rc: Rc = Rc::new(123); + + let ptr = Rc::into_raw(rc.clone()); + let rc2 = unsafe { Rc::from_raw(ptr) }; + + assert_eq!(unsafe { &*ptr }.to_string(), "123"); + assert_eq!(rc2.to_string(), "123"); +} + +#[test] +fn into_from_weak_raw() { + let x = Rc::new(box "hello"); + let y = Rc::downgrade(&x); + + let y_ptr = Weak::into_raw(y); + unsafe { + assert_eq!(**y_ptr, "hello"); + + let y = Weak::from_raw(y_ptr); + let y_up = Weak::upgrade(&y).unwrap(); + assert_eq!(**y_up, "hello"); + drop(y_up); + + assert_eq!(Rc::try_unwrap(x).map(|x| *x), Ok("hello")); + } +} + +#[test] +fn get_mut() { + let mut x = Rc::new(3); + *Rc::get_mut(&mut x).unwrap() = 4; + assert_eq!(*x, 4); + let y = x.clone(); + assert!(Rc::get_mut(&mut x).is_none()); + drop(y); + assert!(Rc::get_mut(&mut x).is_some()); + let _w = Rc::downgrade(&x); + assert!(Rc::get_mut(&mut x).is_none()); +} + +#[test] +fn test_cowrc_clone_make_unique() { + let mut cow0 = Rc::new(75); + let mut cow1 = cow0.clone(); + let mut cow2 = cow1.clone(); + + assert!(75 == *Rc::make_mut(&mut cow0)); + assert!(75 == *Rc::make_mut(&mut cow1)); + assert!(75 == *Rc::make_mut(&mut cow2)); + + *Rc::make_mut(&mut cow0) += 1; + *Rc::make_mut(&mut cow1) += 2; + *Rc::make_mut(&mut cow2) += 3; + + assert!(76 == *cow0); + assert!(77 == *cow1); + assert!(78 == *cow2); + + // none should point to the same backing memory + assert!(*cow0 != *cow1); + assert!(*cow0 != *cow2); + assert!(*cow1 != *cow2); +} + +#[test] +fn test_cowrc_clone_unique2() { + let mut cow0 = Rc::new(75); + let cow1 = cow0.clone(); + let cow2 = cow1.clone(); + + assert!(75 == *cow0); + assert!(75 == *cow1); + assert!(75 == *cow2); + + *Rc::make_mut(&mut cow0) += 1; + + assert!(76 == *cow0); + assert!(75 == *cow1); + assert!(75 == *cow2); + + // cow1 and cow2 should share the same contents + // cow0 should have a unique reference + assert!(*cow0 != *cow1); + assert!(*cow0 != *cow2); + assert!(*cow1 == *cow2); +} + +#[test] +fn test_cowrc_clone_weak() { + let mut cow0 = Rc::new(75); + let cow1_weak = Rc::downgrade(&cow0); + + assert!(75 == *cow0); + assert!(75 == *cow1_weak.upgrade().unwrap()); + + *Rc::make_mut(&mut cow0) += 1; + + assert!(76 == *cow0); + assert!(cow1_weak.upgrade().is_none()); +} + +#[test] +fn test_show() { + let foo = Rc::new(75); + assert_eq!(format!("{:?}", foo), "75"); +} + +#[test] +fn test_unsized() { + let foo: Rc<[i32]> = Rc::new([1, 2, 3]); + assert_eq!(foo, foo.clone()); +} + +#[test] +fn test_from_owned() { + let foo = 123; + let foo_rc = Rc::from(foo); + assert!(123 == *foo_rc); +} + +#[test] +fn test_new_weak() { + let foo: Weak = Weak::new(); + assert!(foo.upgrade().is_none()); +} + +#[test] +fn test_ptr_eq() { + let five = Rc::new(5); + let same_five = five.clone(); + let other_five = Rc::new(5); + + assert!(Rc::ptr_eq(&five, &same_five)); + assert!(!Rc::ptr_eq(&five, &other_five)); +} + +#[test] +fn test_from_str() { + let r: Rc = Rc::from("foo"); + + assert_eq!(&r[..], "foo"); +} + +#[test] +fn test_copy_from_slice() { + let s: &[u32] = &[1, 2, 3]; + let r: Rc<[u32]> = Rc::from(s); + + assert_eq!(&r[..], [1, 2, 3]); +} + +#[test] +fn test_clone_from_slice() { + #[derive(Clone, Debug, Eq, PartialEq)] + struct X(u32); + + let s: &[X] = &[X(1), X(2), X(3)]; + let r: Rc<[X]> = Rc::from(s); + + assert_eq!(&r[..], s); +} + +#[test] +#[should_panic] +fn test_clone_from_slice_panic() { + use std::string::{String, ToString}; + + struct Fail(u32, String); + + impl Clone for Fail { + fn clone(&self) -> Fail { + if self.0 == 2 { + panic!(); + } + Fail(self.0, self.1.clone()) + } + } + + let s: &[Fail] = + &[Fail(0, "foo".to_string()), Fail(1, "bar".to_string()), Fail(2, "baz".to_string())]; + + // Should panic, but not cause memory corruption + let _r: Rc<[Fail]> = Rc::from(s); +} + +#[test] +fn test_from_box() { + let b: Box = box 123; + let r: Rc = Rc::from(b); + + assert_eq!(*r, 123); +} + +#[test] +fn test_from_box_str() { + use std::string::String; + + let s = String::from("foo").into_boxed_str(); + let r: Rc = Rc::from(s); + + assert_eq!(&r[..], "foo"); +} + +#[test] +fn test_from_box_slice() { + let s = vec![1, 2, 3].into_boxed_slice(); + let r: Rc<[u32]> = Rc::from(s); + + assert_eq!(&r[..], [1, 2, 3]); +} + +#[test] +fn test_from_box_trait() { + use std::fmt::Display; + use std::string::ToString; + + let b: Box = box 123; + let r: Rc = Rc::from(b); + + assert_eq!(r.to_string(), "123"); +} + +#[test] +fn test_from_box_trait_zero_sized() { + use std::fmt::Debug; + + let b: Box = box (); + let r: Rc = Rc::from(b); + + assert_eq!(format!("{:?}", r), "()"); +} + +#[test] +fn test_from_vec() { + let v = vec![1, 2, 3]; + let r: Rc<[u32]> = Rc::from(v); + + assert_eq!(&r[..], [1, 2, 3]); +} + +#[test] +fn test_downcast() { + use std::any::Any; + + let r1: Rc = Rc::new(i32::MAX); + let r2: Rc = Rc::new("abc"); + + assert!(r1.clone().downcast::().is_err()); + + let r1i32 = r1.downcast::(); + assert!(r1i32.is_ok()); + assert_eq!(r1i32.unwrap(), Rc::new(i32::MAX)); + + assert!(r2.clone().downcast::().is_err()); + + let r2str = r2.downcast::<&'static str>(); + assert!(r2str.is_ok()); + assert_eq!(r2str.unwrap(), Rc::new("abc")); +} + +#[test] +fn test_array_from_slice() { + let v = vec![1, 2, 3]; + let r: Rc<[u32]> = Rc::from(v); + + let a: Result, _> = r.clone().try_into(); + assert!(a.is_ok()); + + let a: Result, _> = r.clone().try_into(); + assert!(a.is_err()); +} + +#[test] +fn test_rc_cyclic_with_zero_refs() { + struct ZeroRefs { + inner: Weak, + } + + let zero_refs = Rc::new_cyclic(|inner| { + assert_eq!(inner.strong_count(), 0); + assert!(inner.upgrade().is_none()); + ZeroRefs { inner: Weak::new() } + }); + + assert_eq!(Rc::strong_count(&zero_refs), 1); + assert_eq!(Rc::weak_count(&zero_refs), 0); + assert_eq!(zero_refs.inner.strong_count(), 0); + assert_eq!(zero_refs.inner.weak_count(), 0); +} + +#[test] +fn test_rc_cyclic_with_one_ref() { + struct OneRef { + inner: Weak, + } + + let one_ref = Rc::new_cyclic(|inner| { + assert_eq!(inner.strong_count(), 0); + assert!(inner.upgrade().is_none()); + OneRef { inner: inner.clone() } + }); + + assert_eq!(Rc::strong_count(&one_ref), 1); + assert_eq!(Rc::weak_count(&one_ref), 1); + + let one_ref2 = Weak::upgrade(&one_ref.inner).unwrap(); + assert!(Rc::ptr_eq(&one_ref, &one_ref2)); + + assert_eq!(one_ref.inner.strong_count(), 2); + assert_eq!(one_ref.inner.weak_count(), 1); +} + +#[test] +fn test_rc_cyclic_with_two_ref() { + struct TwoRefs { + inner: Weak, + inner1: Weak, + } + + let two_refs = Rc::new_cyclic(|inner| { + assert_eq!(inner.strong_count(), 0); + assert!(inner.upgrade().is_none()); + TwoRefs { inner: inner.clone(), inner1: inner.clone() } + }); + + assert_eq!(Rc::strong_count(&two_refs), 1); + assert_eq!(Rc::weak_count(&two_refs), 2); + + let two_ref3 = Weak::upgrade(&two_refs.inner).unwrap(); + assert!(Rc::ptr_eq(&two_refs, &two_ref3)); + + let two_ref2 = Weak::upgrade(&two_refs.inner1).unwrap(); + assert!(Rc::ptr_eq(&two_refs, &two_ref2)); + + assert_eq!(Rc::strong_count(&two_refs), 3); + assert_eq!(Rc::weak_count(&two_refs), 2); +} diff --git a/libgrust/rustc-lib/alloc/src/slice.rs b/libgrust/rustc-lib/alloc/src/slice.rs new file mode 100644 index 000000000000..3db66964941c --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/slice.rs @@ -0,0 +1,1071 @@ +//! A dynamically-sized view into a contiguous sequence, `[T]`. +//! +//! *[See also the slice primitive type](../../std/primitive.slice.html).* +//! +//! Slices are a view into a block of memory represented as a pointer and a +//! length. +//! +//! ``` +//! // slicing a Vec +//! let vec = vec![1, 2, 3]; +//! let int_slice = &vec[..]; +//! // coercing an array to a slice +//! let str_slice: &[&str] = &["one", "two", "three"]; +//! ``` +//! +//! Slices are either mutable or shared. The shared slice type is `&[T]`, +//! while the mutable slice type is `&mut [T]`, where `T` represents the element +//! type. For example, you can mutate the block of memory that a mutable slice +//! points to: +//! +//! ``` +//! let x = &mut [1, 2, 3]; +//! x[1] = 7; +//! assert_eq!(x, &[1, 7, 3]); +//! ``` +//! +//! Here are some of the things this module contains: +//! +//! ## Structs +//! +//! There are several structs that are useful for slices, such as [`Iter`], which +//! represents iteration over a slice. +//! +//! ## Trait Implementations +//! +//! There are several implementations of common traits for slices. Some examples +//! include: +//! +//! * [`Clone`] +//! * [`Eq`], [`Ord`] - for slices whose element type are [`Eq`] or [`Ord`]. +//! * [`Hash`] - for slices whose element type is [`Hash`]. +//! +//! ## Iteration +//! +//! The slices implement `IntoIterator`. The iterator yields references to the +//! slice elements. +//! +//! ``` +//! let numbers = &[0, 1, 2]; +//! for n in numbers { +//! println!("{} is a number!", n); +//! } +//! ``` +//! +//! The mutable slice yields mutable references to the elements: +//! +//! ``` +//! let mut scores = [7, 8, 9]; +//! for score in &mut scores[..] { +//! *score += 1; +//! } +//! ``` +//! +//! This iterator yields mutable references to the slice's elements, so while +//! the element type of the slice is `i32`, the element type of the iterator is +//! `&mut i32`. +//! +//! * [`.iter`] and [`.iter_mut`] are the explicit methods to return the default +//! iterators. +//! * Further methods that return iterators are [`.split`], [`.splitn`], +//! [`.chunks`], [`.windows`] and more. +//! +//! [`Hash`]: core::hash::Hash +//! [`.iter`]: ../../std/primitive.slice.html#method.iter +//! [`.iter_mut`]: ../../std/primitive.slice.html#method.iter_mut +//! [`.split`]: ../../std/primitive.slice.html#method.split +//! [`.splitn`]: ../../std/primitive.slice.html#method.splitn +//! [`.chunks`]: ../../std/primitive.slice.html#method.chunks +//! [`.windows`]: ../../std/primitive.slice.html#method.windows +#![stable(feature = "rust1", since = "1.0.0")] +// Many of the usings in this module are only used in the test configuration. +// It's cleaner to just turn off the unused_imports warning than to fix them. +#![cfg_attr(test, allow(unused_imports, dead_code))] + +use core::borrow::{Borrow, BorrowMut}; +use core::cmp::Ordering::{self, Less}; +use core::mem::{self, size_of}; +use core::ptr; + +use crate::borrow::ToOwned; +use crate::boxed::Box; +use crate::vec::Vec; + +#[unstable(feature = "array_chunks", issue = "74985")] +pub use core::slice::ArrayChunks; +#[unstable(feature = "array_chunks", issue = "74985")] +pub use core::slice::ArrayChunksMut; +#[unstable(feature = "array_windows", issue = "75027")] +pub use core::slice::ArrayWindows; +#[stable(feature = "slice_get_slice", since = "1.28.0")] +pub use core::slice::SliceIndex; +#[stable(feature = "from_ref", since = "1.28.0")] +pub use core::slice::{from_mut, from_ref}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::slice::{from_raw_parts, from_raw_parts_mut}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::slice::{Chunks, Windows}; +#[stable(feature = "chunks_exact", since = "1.31.0")] +pub use core::slice::{ChunksExact, ChunksExactMut}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::slice::{ChunksMut, Split, SplitMut}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::slice::{Iter, IterMut}; +#[stable(feature = "rchunks", since = "1.31.0")] +pub use core::slice::{RChunks, RChunksExact, RChunksExactMut, RChunksMut}; +#[stable(feature = "slice_rsplit", since = "1.27.0")] +pub use core::slice::{RSplit, RSplitMut}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::slice::{RSplitN, RSplitNMut, SplitN, SplitNMut}; + +//////////////////////////////////////////////////////////////////////////////// +// Basic slice extension methods +//////////////////////////////////////////////////////////////////////////////// + +// HACK(japaric) needed for the implementation of `vec!` macro during testing +// N.B., see the `hack` module in this file for more details. +#[cfg(test)] +pub use hack::into_vec; + +// HACK(japaric) needed for the implementation of `Vec::clone` during testing +// N.B., see the `hack` module in this file for more details. +#[cfg(test)] +pub use hack::to_vec; + +// HACK(japaric): With cfg(test) `impl [T]` is not available, these three +// functions are actually methods that are in `impl [T]` but not in +// `core::slice::SliceExt` - we need to supply these functions for the +// `test_permutations` test +mod hack { + use crate::boxed::Box; + use crate::vec::Vec; + + // We shouldn't add inline attribute to this since this is used in + // `vec!` macro mostly and causes perf regression. See #71204 for + // discussion and perf results. + pub fn into_vec(b: Box<[T]>) -> Vec { + unsafe { + let len = b.len(); + let b = Box::into_raw(b); + Vec::from_raw_parts(b as *mut T, len, len) + } + } + + #[inline] + pub fn to_vec(s: &[T]) -> Vec + where + T: Clone, + { + let mut vec = Vec::with_capacity(s.len()); + vec.extend_from_slice(s); + vec + } +} + +#[lang = "slice_alloc"] +#[cfg(not(test))] +impl [T] { + /// Sorts the slice. + /// + /// This sort is stable (i.e., does not reorder equal elements) and *O*(*n* \* log(*n*)) worst-case. + /// + /// When applicable, unstable sorting is preferred because it is generally faster than stable + /// sorting and it doesn't allocate auxiliary memory. + /// See [`sort_unstable`](#method.sort_unstable). + /// + /// # Current implementation + /// + /// The current algorithm is an adaptive, iterative merge sort inspired by + /// [timsort](https://en.wikipedia.org/wiki/Timsort). + /// It is designed to be very fast in cases where the slice is nearly sorted, or consists of + /// two or more sorted sequences concatenated one after another. + /// + /// Also, it allocates temporary storage half the size of `self`, but for short slices a + /// non-allocating insertion sort is used instead. + /// + /// # Examples + /// + /// ``` + /// let mut v = [-5, 4, 1, -3, 2]; + /// + /// v.sort(); + /// assert!(v == [-5, -3, 1, 2, 4]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn sort(&mut self) + where + T: Ord, + { + merge_sort(self, |a, b| a.lt(b)); + } + + /// Sorts the slice with a comparator function. + /// + /// This sort is stable (i.e., does not reorder equal elements) and *O*(*n* \* log(*n*)) worst-case. + /// + /// The comparator function must define a total ordering for the elements in the slice. If + /// the ordering is not total, the order of the elements is unspecified. An order is a + /// total order if it is (for all `a`, `b` and `c`): + /// + /// * total and antisymmetric: exactly one of `a < b`, `a == b` or `a > b` is true, and + /// * transitive, `a < b` and `b < c` implies `a < c`. The same must hold for both `==` and `>`. + /// + /// For example, while [`f64`] doesn't implement [`Ord`] because `NaN != NaN`, we can use + /// `partial_cmp` as our sort function when we know the slice doesn't contain a `NaN`. + /// + /// ``` + /// let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0]; + /// floats.sort_by(|a, b| a.partial_cmp(b).unwrap()); + /// assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]); + /// ``` + /// + /// When applicable, unstable sorting is preferred because it is generally faster than stable + /// sorting and it doesn't allocate auxiliary memory. + /// See [`sort_unstable_by`](#method.sort_unstable_by). + /// + /// # Current implementation + /// + /// The current algorithm is an adaptive, iterative merge sort inspired by + /// [timsort](https://en.wikipedia.org/wiki/Timsort). + /// It is designed to be very fast in cases where the slice is nearly sorted, or consists of + /// two or more sorted sequences concatenated one after another. + /// + /// Also, it allocates temporary storage half the size of `self`, but for short slices a + /// non-allocating insertion sort is used instead. + /// + /// # Examples + /// + /// ``` + /// let mut v = [5, 4, 1, 3, 2]; + /// v.sort_by(|a, b| a.cmp(b)); + /// assert!(v == [1, 2, 3, 4, 5]); + /// + /// // reverse sorting + /// v.sort_by(|a, b| b.cmp(a)); + /// assert!(v == [5, 4, 3, 2, 1]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn sort_by(&mut self, mut compare: F) + where + F: FnMut(&T, &T) -> Ordering, + { + merge_sort(self, |a, b| compare(a, b) == Less); + } + + /// Sorts the slice with a key extraction function. + /// + /// This sort is stable (i.e., does not reorder equal elements) and *O*(*m* \* *n* \* log(*n*)) + /// worst-case, where the key function is *O*(*m*). + /// + /// For expensive key functions (e.g. functions that are not simple property accesses or + /// basic operations), [`sort_by_cached_key`](#method.sort_by_cached_key) is likely to be + /// significantly faster, as it does not recompute element keys. + /// + /// When applicable, unstable sorting is preferred because it is generally faster than stable + /// sorting and it doesn't allocate auxiliary memory. + /// See [`sort_unstable_by_key`](#method.sort_unstable_by_key). + /// + /// # Current implementation + /// + /// The current algorithm is an adaptive, iterative merge sort inspired by + /// [timsort](https://en.wikipedia.org/wiki/Timsort). + /// It is designed to be very fast in cases where the slice is nearly sorted, or consists of + /// two or more sorted sequences concatenated one after another. + /// + /// Also, it allocates temporary storage half the size of `self`, but for short slices a + /// non-allocating insertion sort is used instead. + /// + /// # Examples + /// + /// ``` + /// let mut v = [-5i32, 4, 1, -3, 2]; + /// + /// v.sort_by_key(|k| k.abs()); + /// assert!(v == [1, 2, -3, 4, -5]); + /// ``` + #[stable(feature = "slice_sort_by_key", since = "1.7.0")] + #[inline] + pub fn sort_by_key(&mut self, mut f: F) + where + F: FnMut(&T) -> K, + K: Ord, + { + merge_sort(self, |a, b| f(a).lt(&f(b))); + } + + /// Sorts the slice with a key extraction function. + /// + /// During sorting, the key function is called only once per element. + /// + /// This sort is stable (i.e., does not reorder equal elements) and *O*(*m* \* *n* + *n* \* log(*n*)) + /// worst-case, where the key function is *O*(*m*). + /// + /// For simple key functions (e.g., functions that are property accesses or + /// basic operations), [`sort_by_key`](#method.sort_by_key) is likely to be + /// faster. + /// + /// # Current implementation + /// + /// The current algorithm is based on [pattern-defeating quicksort][pdqsort] by Orson Peters, + /// which combines the fast average case of randomized quicksort with the fast worst case of + /// heapsort, while achieving linear time on slices with certain patterns. It uses some + /// randomization to avoid degenerate cases, but with a fixed seed to always provide + /// deterministic behavior. + /// + /// In the worst case, the algorithm allocates temporary storage in a `Vec<(K, usize)>` the + /// length of the slice. + /// + /// # Examples + /// + /// ``` + /// let mut v = [-5i32, 4, 32, -3, 2]; + /// + /// v.sort_by_cached_key(|k| k.to_string()); + /// assert!(v == [-3, -5, 2, 32, 4]); + /// ``` + /// + /// [pdqsort]: https://github.com/orlp/pdqsort + #[stable(feature = "slice_sort_by_cached_key", since = "1.34.0")] + #[inline] + pub fn sort_by_cached_key(&mut self, f: F) + where + F: FnMut(&T) -> K, + K: Ord, + { + // Helper macro for indexing our vector by the smallest possible type, to reduce allocation. + macro_rules! sort_by_key { + ($t:ty, $slice:ident, $f:ident) => {{ + let mut indices: Vec<_> = + $slice.iter().map($f).enumerate().map(|(i, k)| (k, i as $t)).collect(); + // The elements of `indices` are unique, as they are indexed, so any sort will be + // stable with respect to the original slice. We use `sort_unstable` here because + // it requires less memory allocation. + indices.sort_unstable(); + for i in 0..$slice.len() { + let mut index = indices[i].1; + while (index as usize) < i { + index = indices[index as usize].1; + } + indices[i].1 = index; + $slice.swap(i, index as usize); + } + }}; + } + + let sz_u8 = mem::size_of::<(K, u8)>(); + let sz_u16 = mem::size_of::<(K, u16)>(); + let sz_u32 = mem::size_of::<(K, u32)>(); + let sz_usize = mem::size_of::<(K, usize)>(); + + let len = self.len(); + if len < 2 { + return; + } + if sz_u8 < sz_u16 && len <= (u8::MAX as usize) { + return sort_by_key!(u8, self, f); + } + if sz_u16 < sz_u32 && len <= (u16::MAX as usize) { + return sort_by_key!(u16, self, f); + } + if sz_u32 < sz_usize && len <= (u32::MAX as usize) { + return sort_by_key!(u32, self, f); + } + sort_by_key!(usize, self, f) + } + + /// Copies `self` into a new `Vec`. + /// + /// # Examples + /// + /// ``` + /// let s = [10, 40, 30]; + /// let x = s.to_vec(); + /// // Here, `s` and `x` can be modified independently. + /// ``` + #[rustc_conversion_suggestion] + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn to_vec(&self) -> Vec + where + T: Clone, + { + // N.B., see the `hack` module in this file for more details. + hack::to_vec(self) + } + + /// Converts `self` into a vector without clones or allocation. + /// + /// The resulting vector can be converted back into a box via + /// `Vec`'s `into_boxed_slice` method. + /// + /// # Examples + /// + /// ``` + /// let s: Box<[i32]> = Box::new([10, 40, 30]); + /// let x = s.into_vec(); + /// // `s` cannot be used anymore because it has been converted into `x`. + /// + /// assert_eq!(x, vec![10, 40, 30]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn into_vec(self: Box) -> Vec { + // N.B., see the `hack` module in this file for more details. + hack::into_vec(self) + } + + /// Creates a vector by repeating a slice `n` times. + /// + /// # Panics + /// + /// This function will panic if the capacity would overflow. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// assert_eq!([1, 2].repeat(3), vec![1, 2, 1, 2, 1, 2]); + /// ``` + /// + /// A panic upon overflow: + /// + /// ```should_panic + /// // this will panic at runtime + /// b"0123456789abcdef".repeat(usize::MAX); + /// ``` + #[stable(feature = "repeat_generic_slice", since = "1.40.0")] + pub fn repeat(&self, n: usize) -> Vec + where + T: Copy, + { + if n == 0 { + return Vec::new(); + } + + // If `n` is larger than zero, it can be split as + // `n = 2^expn + rem (2^expn > rem, expn >= 0, rem >= 0)`. + // `2^expn` is the number represented by the leftmost '1' bit of `n`, + // and `rem` is the remaining part of `n`. + + // Using `Vec` to access `set_len()`. + let capacity = self.len().checked_mul(n).expect("capacity overflow"); + let mut buf = Vec::with_capacity(capacity); + + // `2^expn` repetition is done by doubling `buf` `expn`-times. + buf.extend(self); + { + let mut m = n >> 1; + // If `m > 0`, there are remaining bits up to the leftmost '1'. + while m > 0 { + // `buf.extend(buf)`: + unsafe { + ptr::copy_nonoverlapping( + buf.as_ptr(), + (buf.as_mut_ptr() as *mut T).add(buf.len()), + buf.len(), + ); + // `buf` has capacity of `self.len() * n`. + let buf_len = buf.len(); + buf.set_len(buf_len * 2); + } + + m >>= 1; + } + } + + // `rem` (`= n - 2^expn`) repetition is done by copying + // first `rem` repetitions from `buf` itself. + let rem_len = capacity - buf.len(); // `self.len() * rem` + if rem_len > 0 { + // `buf.extend(buf[0 .. rem_len])`: + unsafe { + // This is non-overlapping since `2^expn > rem`. + ptr::copy_nonoverlapping( + buf.as_ptr(), + (buf.as_mut_ptr() as *mut T).add(buf.len()), + rem_len, + ); + // `buf.len() + rem_len` equals to `buf.capacity()` (`= self.len() * n`). + buf.set_len(capacity); + } + } + buf + } + + /// Flattens a slice of `T` into a single value `Self::Output`. + /// + /// # Examples + /// + /// ``` + /// assert_eq!(["hello", "world"].concat(), "helloworld"); + /// assert_eq!([[1, 2], [3, 4]].concat(), [1, 2, 3, 4]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn concat(&self) -> >::Output + where + Self: Concat, + { + Concat::concat(self) + } + + /// Flattens a slice of `T` into a single value `Self::Output`, placing a + /// given separator between each. + /// + /// # Examples + /// + /// ``` + /// assert_eq!(["hello", "world"].join(" "), "hello world"); + /// assert_eq!([[1, 2], [3, 4]].join(&0), [1, 2, 0, 3, 4]); + /// assert_eq!([[1, 2], [3, 4]].join(&[0, 0][..]), [1, 2, 0, 0, 3, 4]); + /// ``` + #[stable(feature = "rename_connect_to_join", since = "1.3.0")] + pub fn join(&self, sep: Separator) -> >::Output + where + Self: Join, + { + Join::join(self, sep) + } + + /// Flattens a slice of `T` into a single value `Self::Output`, placing a + /// given separator between each. + /// + /// # Examples + /// + /// ``` + /// # #![allow(deprecated)] + /// assert_eq!(["hello", "world"].connect(" "), "hello world"); + /// assert_eq!([[1, 2], [3, 4]].connect(&0), [1, 2, 0, 3, 4]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_deprecated(since = "1.3.0", reason = "renamed to join")] + pub fn connect(&self, sep: Separator) -> >::Output + where + Self: Join, + { + Join::join(self, sep) + } +} + +#[lang = "slice_u8_alloc"] +#[cfg(not(test))] +impl [u8] { + /// Returns a vector containing a copy of this slice where each byte + /// is mapped to its ASCII upper case equivalent. + /// + /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z', + /// but non-ASCII letters are unchanged. + /// + /// To uppercase the value in-place, use [`make_ascii_uppercase`]. + /// + /// [`make_ascii_uppercase`]: u8::make_ascii_uppercase + #[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")] + #[inline] + pub fn to_ascii_uppercase(&self) -> Vec { + let mut me = self.to_vec(); + me.make_ascii_uppercase(); + me + } + + /// Returns a vector containing a copy of this slice where each byte + /// is mapped to its ASCII lower case equivalent. + /// + /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z', + /// but non-ASCII letters are unchanged. + /// + /// To lowercase the value in-place, use [`make_ascii_lowercase`]. + /// + /// [`make_ascii_lowercase`]: u8::make_ascii_lowercase + #[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")] + #[inline] + pub fn to_ascii_lowercase(&self) -> Vec { + let mut me = self.to_vec(); + me.make_ascii_lowercase(); + me + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Extension traits for slices over specific kinds of data +//////////////////////////////////////////////////////////////////////////////// + +/// Helper trait for [`[T]::concat`](../../std/primitive.slice.html#method.concat). +/// +/// Note: the `Item` type parameter is not used in this trait, +/// but it allows impls to be more generic. +/// Without it, we get this error: +/// +/// ```error +/// error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predica +/// --> src/liballoc/slice.rs:608:6 +/// | +/// 608 | impl> Concat for [V] { +/// | ^ unconstrained type parameter +/// ``` +/// +/// This is because there could exist `V` types with multiple `Borrow<[_]>` impls, +/// such that multiple `T` types would apply: +/// +/// ``` +/// # #[allow(dead_code)] +/// pub struct Foo(Vec, Vec); +/// +/// impl std::borrow::Borrow<[u32]> for Foo { +/// fn borrow(&self) -> &[u32] { &self.0 } +/// } +/// +/// impl std::borrow::Borrow<[String]> for Foo { +/// fn borrow(&self) -> &[String] { &self.1 } +/// } +/// ``` +#[unstable(feature = "slice_concat_trait", issue = "27747")] +pub trait Concat { + #[unstable(feature = "slice_concat_trait", issue = "27747")] + /// The resulting type after concatenation + type Output; + + /// Implementation of [`[T]::concat`](../../std/primitive.slice.html#method.concat) + #[unstable(feature = "slice_concat_trait", issue = "27747")] + fn concat(slice: &Self) -> Self::Output; +} + +/// Helper trait for [`[T]::join`](../../std/primitive.slice.html#method.join) +#[unstable(feature = "slice_concat_trait", issue = "27747")] +pub trait Join { + #[unstable(feature = "slice_concat_trait", issue = "27747")] + /// The resulting type after concatenation + type Output; + + /// Implementation of [`[T]::join`](../../std/primitive.slice.html#method.join) + #[unstable(feature = "slice_concat_trait", issue = "27747")] + fn join(slice: &Self, sep: Separator) -> Self::Output; +} + +#[unstable(feature = "slice_concat_ext", issue = "27747")] +impl> Concat for [V] { + type Output = Vec; + + fn concat(slice: &Self) -> Vec { + let size = slice.iter().map(|slice| slice.borrow().len()).sum(); + let mut result = Vec::with_capacity(size); + for v in slice { + result.extend_from_slice(v.borrow()) + } + result + } +} + +#[unstable(feature = "slice_concat_ext", issue = "27747")] +impl> Join<&T> for [V] { + type Output = Vec; + + fn join(slice: &Self, sep: &T) -> Vec { + let mut iter = slice.iter(); + let first = match iter.next() { + Some(first) => first, + None => return vec![], + }; + let size = slice.iter().map(|v| v.borrow().len()).sum::() + slice.len() - 1; + let mut result = Vec::with_capacity(size); + result.extend_from_slice(first.borrow()); + + for v in iter { + result.push(sep.clone()); + result.extend_from_slice(v.borrow()) + } + result + } +} + +#[unstable(feature = "slice_concat_ext", issue = "27747")] +impl> Join<&[T]> for [V] { + type Output = Vec; + + fn join(slice: &Self, sep: &[T]) -> Vec { + let mut iter = slice.iter(); + let first = match iter.next() { + Some(first) => first, + None => return vec![], + }; + let size = + slice.iter().map(|v| v.borrow().len()).sum::() + sep.len() * (slice.len() - 1); + let mut result = Vec::with_capacity(size); + result.extend_from_slice(first.borrow()); + + for v in iter { + result.extend_from_slice(sep); + result.extend_from_slice(v.borrow()) + } + result + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Standard trait implementations for slices +//////////////////////////////////////////////////////////////////////////////// + +#[stable(feature = "rust1", since = "1.0.0")] +impl Borrow<[T]> for Vec { + fn borrow(&self) -> &[T] { + &self[..] + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl BorrowMut<[T]> for Vec { + fn borrow_mut(&mut self) -> &mut [T] { + &mut self[..] + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ToOwned for [T] { + type Owned = Vec; + #[cfg(not(test))] + fn to_owned(&self) -> Vec { + self.to_vec() + } + + #[cfg(test)] + fn to_owned(&self) -> Vec { + hack::to_vec(self) + } + + fn clone_into(&self, target: &mut Vec) { + // drop anything in target that will not be overwritten + target.truncate(self.len()); + + // target.len <= self.len due to the truncate above, so the + // slices here are always in-bounds. + let (init, tail) = self.split_at(target.len()); + + // reuse the contained values' allocations/resources. + target.clone_from_slice(init); + target.extend_from_slice(tail); + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Sorting +//////////////////////////////////////////////////////////////////////////////// + +/// Inserts `v[0]` into pre-sorted sequence `v[1..]` so that whole `v[..]` becomes sorted. +/// +/// This is the integral subroutine of insertion sort. +fn insert_head(v: &mut [T], is_less: &mut F) +where + F: FnMut(&T, &T) -> bool, +{ + if v.len() >= 2 && is_less(&v[1], &v[0]) { + unsafe { + // There are three ways to implement insertion here: + // + // 1. Swap adjacent elements until the first one gets to its final destination. + // However, this way we copy data around more than is necessary. If elements are big + // structures (costly to copy), this method will be slow. + // + // 2. Iterate until the right place for the first element is found. Then shift the + // elements succeeding it to make room for it and finally place it into the + // remaining hole. This is a good method. + // + // 3. Copy the first element into a temporary variable. Iterate until the right place + // for it is found. As we go along, copy every traversed element into the slot + // preceding it. Finally, copy data from the temporary variable into the remaining + // hole. This method is very good. Benchmarks demonstrated slightly better + // performance than with the 2nd method. + // + // All methods were benchmarked, and the 3rd showed best results. So we chose that one. + let mut tmp = mem::ManuallyDrop::new(ptr::read(&v[0])); + + // Intermediate state of the insertion process is always tracked by `hole`, which + // serves two purposes: + // 1. Protects integrity of `v` from panics in `is_less`. + // 2. Fills the remaining hole in `v` in the end. + // + // Panic safety: + // + // If `is_less` panics at any point during the process, `hole` will get dropped and + // fill the hole in `v` with `tmp`, thus ensuring that `v` still holds every object it + // initially held exactly once. + let mut hole = InsertionHole { src: &mut *tmp, dest: &mut v[1] }; + ptr::copy_nonoverlapping(&v[1], &mut v[0], 1); + + for i in 2..v.len() { + if !is_less(&v[i], &*tmp) { + break; + } + ptr::copy_nonoverlapping(&v[i], &mut v[i - 1], 1); + hole.dest = &mut v[i]; + } + // `hole` gets dropped and thus copies `tmp` into the remaining hole in `v`. + } + } + + // When dropped, copies from `src` into `dest`. + struct InsertionHole { + src: *mut T, + dest: *mut T, + } + + impl Drop for InsertionHole { + fn drop(&mut self) { + unsafe { + ptr::copy_nonoverlapping(self.src, self.dest, 1); + } + } + } +} + +/// Merges non-decreasing runs `v[..mid]` and `v[mid..]` using `buf` as temporary storage, and +/// stores the result into `v[..]`. +/// +/// # Safety +/// +/// The two slices must be non-empty and `mid` must be in bounds. Buffer `buf` must be long enough +/// to hold a copy of the shorter slice. Also, `T` must not be a zero-sized type. +unsafe fn merge(v: &mut [T], mid: usize, buf: *mut T, is_less: &mut F) +where + F: FnMut(&T, &T) -> bool, +{ + let len = v.len(); + let v = v.as_mut_ptr(); + let (v_mid, v_end) = unsafe { (v.add(mid), v.add(len)) }; + + // The merge process first copies the shorter run into `buf`. Then it traces the newly copied + // run and the longer run forwards (or backwards), comparing their next unconsumed elements and + // copying the lesser (or greater) one into `v`. + // + // As soon as the shorter run is fully consumed, the process is done. If the longer run gets + // consumed first, then we must copy whatever is left of the shorter run into the remaining + // hole in `v`. + // + // Intermediate state of the process is always tracked by `hole`, which serves two purposes: + // 1. Protects integrity of `v` from panics in `is_less`. + // 2. Fills the remaining hole in `v` if the longer run gets consumed first. + // + // Panic safety: + // + // If `is_less` panics at any point during the process, `hole` will get dropped and fill the + // hole in `v` with the unconsumed range in `buf`, thus ensuring that `v` still holds every + // object it initially held exactly once. + let mut hole; + + if mid <= len - mid { + // The left run is shorter. + unsafe { + ptr::copy_nonoverlapping(v, buf, mid); + hole = MergeHole { start: buf, end: buf.add(mid), dest: v }; + } + + // Initially, these pointers point to the beginnings of their arrays. + let left = &mut hole.start; + let mut right = v_mid; + let out = &mut hole.dest; + + while *left < hole.end && right < v_end { + // Consume the lesser side. + // If equal, prefer the left run to maintain stability. + unsafe { + let to_copy = if is_less(&*right, &**left) { + get_and_increment(&mut right) + } else { + get_and_increment(left) + }; + ptr::copy_nonoverlapping(to_copy, get_and_increment(out), 1); + } + } + } else { + // The right run is shorter. + unsafe { + ptr::copy_nonoverlapping(v_mid, buf, len - mid); + hole = MergeHole { start: buf, end: buf.add(len - mid), dest: v_mid }; + } + + // Initially, these pointers point past the ends of their arrays. + let left = &mut hole.dest; + let right = &mut hole.end; + let mut out = v_end; + + while v < *left && buf < *right { + // Consume the greater side. + // If equal, prefer the right run to maintain stability. + unsafe { + let to_copy = if is_less(&*right.offset(-1), &*left.offset(-1)) { + decrement_and_get(left) + } else { + decrement_and_get(right) + }; + ptr::copy_nonoverlapping(to_copy, decrement_and_get(&mut out), 1); + } + } + } + // Finally, `hole` gets dropped. If the shorter run was not fully consumed, whatever remains of + // it will now be copied into the hole in `v`. + + unsafe fn get_and_increment(ptr: &mut *mut T) -> *mut T { + let old = *ptr; + *ptr = unsafe { ptr.offset(1) }; + old + } + + unsafe fn decrement_and_get(ptr: &mut *mut T) -> *mut T { + *ptr = unsafe { ptr.offset(-1) }; + *ptr + } + + // When dropped, copies the range `start..end` into `dest..`. + struct MergeHole { + start: *mut T, + end: *mut T, + dest: *mut T, + } + + impl Drop for MergeHole { + fn drop(&mut self) { + // `T` is not a zero-sized type, so it's okay to divide by its size. + let len = (self.end as usize - self.start as usize) / mem::size_of::(); + unsafe { + ptr::copy_nonoverlapping(self.start, self.dest, len); + } + } + } +} + +/// This merge sort borrows some (but not all) ideas from TimSort, which is described in detail +/// [here](http://svn.python.org/projects/python/trunk/Objects/listsort.txt). +/// +/// The algorithm identifies strictly descending and non-descending subsequences, which are called +/// natural runs. There is a stack of pending runs yet to be merged. Each newly found run is pushed +/// onto the stack, and then some pairs of adjacent runs are merged until these two invariants are +/// satisfied: +/// +/// 1. for every `i` in `1..runs.len()`: `runs[i - 1].len > runs[i].len` +/// 2. for every `i` in `2..runs.len()`: `runs[i - 2].len > runs[i - 1].len + runs[i].len` +/// +/// The invariants ensure that the total running time is *O*(*n* \* log(*n*)) worst-case. +fn merge_sort(v: &mut [T], mut is_less: F) +where + F: FnMut(&T, &T) -> bool, +{ + // Slices of up to this length get sorted using insertion sort. + const MAX_INSERTION: usize = 20; + // Very short runs are extended using insertion sort to span at least this many elements. + const MIN_RUN: usize = 10; + + // Sorting has no meaningful behavior on zero-sized types. + if size_of::() == 0 { + return; + } + + let len = v.len(); + + // Short arrays get sorted in-place via insertion sort to avoid allocations. + if len <= MAX_INSERTION { + if len >= 2 { + for i in (0..len - 1).rev() { + insert_head(&mut v[i..], &mut is_less); + } + } + return; + } + + // Allocate a buffer to use as scratch memory. We keep the length 0 so we can keep in it + // shallow copies of the contents of `v` without risking the dtors running on copies if + // `is_less` panics. When merging two sorted runs, this buffer holds a copy of the shorter run, + // which will always have length at most `len / 2`. + let mut buf = Vec::with_capacity(len / 2); + + // In order to identify natural runs in `v`, we traverse it backwards. That might seem like a + // strange decision, but consider the fact that merges more often go in the opposite direction + // (forwards). According to benchmarks, merging forwards is slightly faster than merging + // backwards. To conclude, identifying runs by traversing backwards improves performance. + let mut runs = vec![]; + let mut end = len; + while end > 0 { + // Find the next natural run, and reverse it if it's strictly descending. + let mut start = end - 1; + if start > 0 { + start -= 1; + unsafe { + if is_less(v.get_unchecked(start + 1), v.get_unchecked(start)) { + while start > 0 && is_less(v.get_unchecked(start), v.get_unchecked(start - 1)) { + start -= 1; + } + v[start..end].reverse(); + } else { + while start > 0 && !is_less(v.get_unchecked(start), v.get_unchecked(start - 1)) + { + start -= 1; + } + } + } + } + + // Insert some more elements into the run if it's too short. Insertion sort is faster than + // merge sort on short sequences, so this significantly improves performance. + while start > 0 && end - start < MIN_RUN { + start -= 1; + insert_head(&mut v[start..end], &mut is_less); + } + + // Push this run onto the stack. + runs.push(Run { start, len: end - start }); + end = start; + + // Merge some pairs of adjacent runs to satisfy the invariants. + while let Some(r) = collapse(&runs) { + let left = runs[r + 1]; + let right = runs[r]; + unsafe { + merge( + &mut v[left.start..right.start + right.len], + left.len, + buf.as_mut_ptr(), + &mut is_less, + ); + } + runs[r] = Run { start: left.start, len: left.len + right.len }; + runs.remove(r + 1); + } + } + + // Finally, exactly one run must remain in the stack. + debug_assert!(runs.len() == 1 && runs[0].start == 0 && runs[0].len == len); + + // Examines the stack of runs and identifies the next pair of runs to merge. More specifically, + // if `Some(r)` is returned, that means `runs[r]` and `runs[r + 1]` must be merged next. If the + // algorithm should continue building a new run instead, `None` is returned. + // + // TimSort is infamous for its buggy implementations, as described here: + // http://envisage-project.eu/timsort-specification-and-verification/ + // + // The gist of the story is: we must enforce the invariants on the top four runs on the stack. + // Enforcing them on just top three is not sufficient to ensure that the invariants will still + // hold for *all* runs in the stack. + // + // This function correctly checks invariants for the top four runs. Additionally, if the top + // run starts at index 0, it will always demand a merge operation until the stack is fully + // collapsed, in order to complete the sort. + #[inline] + fn collapse(runs: &[Run]) -> Option { + let n = runs.len(); + if n >= 2 + && (runs[n - 1].start == 0 + || runs[n - 2].len <= runs[n - 1].len + || (n >= 3 && runs[n - 3].len <= runs[n - 2].len + runs[n - 1].len) + || (n >= 4 && runs[n - 4].len <= runs[n - 3].len + runs[n - 2].len)) + { + if n >= 3 && runs[n - 3].len < runs[n - 1].len { Some(n - 3) } else { Some(n - 2) } + } else { + None + } + } + + #[derive(Clone, Copy)] + struct Run { + start: usize, + len: usize, + } +} diff --git a/libgrust/rustc-lib/alloc/src/str.rs b/libgrust/rustc-lib/alloc/src/str.rs new file mode 100644 index 000000000000..339592728ac2 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/str.rs @@ -0,0 +1,576 @@ +//! Unicode string slices. +//! +//! *[See also the `str` primitive type](../../std/primitive.str.html).* +//! +//! The `&str` type is one of the two main string types, the other being `String`. +//! Unlike its `String` counterpart, its contents are borrowed. +//! +//! # Basic Usage +//! +//! A basic string declaration of `&str` type: +//! +//! ``` +//! let hello_world = "Hello, World!"; +//! ``` +//! +//! Here we have declared a string literal, also known as a string slice. +//! String literals have a static lifetime, which means the string `hello_world` +//! is guaranteed to be valid for the duration of the entire program. +//! We can explicitly specify `hello_world`'s lifetime as well: +//! +//! ``` +//! let hello_world: &'static str = "Hello, world!"; +//! ``` + +#![stable(feature = "rust1", since = "1.0.0")] +// Many of the usings in this module are only used in the test configuration. +// It's cleaner to just turn off the unused_imports warning than to fix them. +#![allow(unused_imports)] + +use core::borrow::{Borrow, BorrowMut}; +use core::iter::FusedIterator; +use core::mem; +use core::ptr; +use core::str::pattern::{DoubleEndedSearcher, Pattern, ReverseSearcher, Searcher}; +use core::unicode::conversions; + +use crate::borrow::ToOwned; +use crate::boxed::Box; +use crate::slice::{Concat, Join, SliceIndex}; +use crate::string::String; +use crate::vec::Vec; + +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::pattern; +#[stable(feature = "encode_utf16", since = "1.8.0")] +pub use core::str::EncodeUtf16; +#[stable(feature = "split_ascii_whitespace", since = "1.34.0")] +pub use core::str::SplitAsciiWhitespace; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::SplitWhitespace; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::{from_utf8, from_utf8_mut, Bytes, CharIndices, Chars}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::{from_utf8_unchecked, from_utf8_unchecked_mut, ParseBoolError}; +#[stable(feature = "str_escape", since = "1.34.0")] +pub use core::str::{EscapeDebug, EscapeDefault, EscapeUnicode}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::{FromStr, Utf8Error}; +#[allow(deprecated)] +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::{Lines, LinesAny}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::{MatchIndices, RMatchIndices}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::{Matches, RMatches}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::{RSplit, Split}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::{RSplitN, SplitN}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::{RSplitTerminator, SplitTerminator}; + +/// Note: `str` in `Concat` is not meaningful here. +/// This type parameter of the trait only exists to enable another impl. +#[unstable(feature = "slice_concat_ext", issue = "27747")] +impl> Concat for [S] { + type Output = String; + + fn concat(slice: &Self) -> String { + Join::join(slice, "") + } +} + +#[unstable(feature = "slice_concat_ext", issue = "27747")] +impl> Join<&str> for [S] { + type Output = String; + + fn join(slice: &Self, sep: &str) -> String { + unsafe { String::from_utf8_unchecked(join_generic_copy(slice, sep.as_bytes())) } + } +} + +macro_rules! spezialize_for_lengths { + ($separator:expr, $target:expr, $iter:expr; $($num:expr),*) => { + let mut target = $target; + let iter = $iter; + let sep_bytes = $separator; + match $separator.len() { + $( + // loops with hardcoded sizes run much faster + // specialize the cases with small separator lengths + $num => { + for s in iter { + copy_slice_and_advance!(target, sep_bytes); + copy_slice_and_advance!(target, s.borrow().as_ref()); + } + }, + )* + _ => { + // arbitrary non-zero size fallback + for s in iter { + copy_slice_and_advance!(target, sep_bytes); + copy_slice_and_advance!(target, s.borrow().as_ref()); + } + } + } + }; +} + +macro_rules! copy_slice_and_advance { + ($target:expr, $bytes:expr) => { + let len = $bytes.len(); + let (head, tail) = { $target }.split_at_mut(len); + head.copy_from_slice($bytes); + $target = tail; + }; +} + +// Optimized join implementation that works for both Vec (T: Copy) and String's inner vec +// Currently (2018-05-13) there is a bug with type inference and specialization (see issue #36262) +// For this reason SliceConcat is not specialized for T: Copy and SliceConcat is the +// only user of this function. It is left in place for the time when that is fixed. +// +// the bounds for String-join are S: Borrow and for Vec-join Borrow<[T]> +// [T] and str both impl AsRef<[T]> for some T +// => s.borrow().as_ref() and we always have slices +fn join_generic_copy(slice: &[S], sep: &[T]) -> Vec +where + T: Copy, + B: AsRef<[T]> + ?Sized, + S: Borrow, +{ + let sep_len = sep.len(); + let mut iter = slice.iter(); + + // the first slice is the only one without a separator preceding it + let first = match iter.next() { + Some(first) => first, + None => return vec![], + }; + + // compute the exact total length of the joined Vec + // if the `len` calculation overflows, we'll panic + // we would have run out of memory anyway and the rest of the function requires + // the entire Vec pre-allocated for safety + let len = sep_len + .checked_mul(iter.len()) + .and_then(|n| { + slice.iter().map(|s| s.borrow().as_ref().len()).try_fold(n, usize::checked_add) + }) + .expect("attempt to join into collection with len > usize::MAX"); + + // crucial for safety + let mut result = Vec::with_capacity(len); + assert!(result.capacity() >= len); + + result.extend_from_slice(first.borrow().as_ref()); + + unsafe { + { + let pos = result.len(); + let target = result.get_unchecked_mut(pos..len); + + // copy separator and slices over without bounds checks + // generate loops with hardcoded offsets for small separators + // massive improvements possible (~ x2) + spezialize_for_lengths!(sep, target, iter; 0, 1, 2, 3, 4); + } + result.set_len(len); + } + result +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Borrow for String { + #[inline] + fn borrow(&self) -> &str { + &self[..] + } +} + +#[stable(feature = "string_borrow_mut", since = "1.36.0")] +impl BorrowMut for String { + #[inline] + fn borrow_mut(&mut self) -> &mut str { + &mut self[..] + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ToOwned for str { + type Owned = String; + #[inline] + fn to_owned(&self) -> String { + unsafe { String::from_utf8_unchecked(self.as_bytes().to_owned()) } + } + + fn clone_into(&self, target: &mut String) { + let mut b = mem::take(target).into_bytes(); + self.as_bytes().clone_into(&mut b); + *target = unsafe { String::from_utf8_unchecked(b) } + } +} + +/// Methods for string slices. +#[lang = "str_alloc"] +#[cfg(not(test))] +impl str { + /// Converts a `Box` into a `Box<[u8]>` without copying or allocating. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = "this is a string"; + /// let boxed_str = s.to_owned().into_boxed_str(); + /// let boxed_bytes = boxed_str.into_boxed_bytes(); + /// assert_eq!(*boxed_bytes, *s.as_bytes()); + /// ``` + #[stable(feature = "str_box_extras", since = "1.20.0")] + #[inline] + pub fn into_boxed_bytes(self: Box) -> Box<[u8]> { + self.into() + } + + /// Replaces all matches of a pattern with another string. + /// + /// `replace` creates a new [`String`], and copies the data from this string slice into it. + /// While doing so, it attempts to find matches of a pattern. If it finds any, it + /// replaces them with the replacement string slice. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = "this is old"; + /// + /// assert_eq!("this is new", s.replace("old", "new")); + /// ``` + /// + /// When the pattern doesn't match: + /// + /// ``` + /// let s = "this is old"; + /// assert_eq!(s, s.replace("cookie monster", "little lamb")); + /// ``` + #[must_use = "this returns the replaced string as a new allocation, \ + without modifying the original"] + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn replace<'a, P: Pattern<'a>>(&'a self, from: P, to: &str) -> String { + let mut result = String::new(); + let mut last_end = 0; + for (start, part) in self.match_indices(from) { + result.push_str(unsafe { self.get_unchecked(last_end..start) }); + result.push_str(to); + last_end = start + part.len(); + } + result.push_str(unsafe { self.get_unchecked(last_end..self.len()) }); + result + } + + /// Replaces first N matches of a pattern with another string. + /// + /// `replacen` creates a new [`String`], and copies the data from this string slice into it. + /// While doing so, it attempts to find matches of a pattern. If it finds any, it + /// replaces them with the replacement string slice at most `count` times. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = "foo foo 123 foo"; + /// assert_eq!("new new 123 foo", s.replacen("foo", "new", 2)); + /// assert_eq!("faa fao 123 foo", s.replacen('o', "a", 3)); + /// assert_eq!("foo foo new23 foo", s.replacen(char::is_numeric, "new", 1)); + /// ``` + /// + /// When the pattern doesn't match: + /// + /// ``` + /// let s = "this is old"; + /// assert_eq!(s, s.replacen("cookie monster", "little lamb", 10)); + /// ``` + #[must_use = "this returns the replaced string as a new allocation, \ + without modifying the original"] + #[stable(feature = "str_replacen", since = "1.16.0")] + pub fn replacen<'a, P: Pattern<'a>>(&'a self, pat: P, to: &str, count: usize) -> String { + // Hope to reduce the times of re-allocation + let mut result = String::with_capacity(32); + let mut last_end = 0; + for (start, part) in self.match_indices(pat).take(count) { + result.push_str(unsafe { self.get_unchecked(last_end..start) }); + result.push_str(to); + last_end = start + part.len(); + } + result.push_str(unsafe { self.get_unchecked(last_end..self.len()) }); + result + } + + /// Returns the lowercase equivalent of this string slice, as a new [`String`]. + /// + /// 'Lowercase' is defined according to the terms of the Unicode Derived Core Property + /// `Lowercase`. + /// + /// Since some characters can expand into multiple characters when changing + /// the case, this function returns a [`String`] instead of modifying the + /// parameter in-place. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = "HELLO"; + /// + /// assert_eq!("hello", s.to_lowercase()); + /// ``` + /// + /// A tricky example, with sigma: + /// + /// ``` + /// let sigma = "Σ"; + /// + /// assert_eq!("σ", sigma.to_lowercase()); + /// + /// // but at the end of a word, it's ς, not σ: + /// let odysseus = "ὈΔΥΣΣΕΎΣ"; + /// + /// assert_eq!("ὀδυσσεύς", odysseus.to_lowercase()); + /// ``` + /// + /// Languages without case are not changed: + /// + /// ``` + /// let new_year = "农历新年"; + /// + /// assert_eq!(new_year, new_year.to_lowercase()); + /// ``` + #[stable(feature = "unicode_case_mapping", since = "1.2.0")] + pub fn to_lowercase(&self) -> String { + let mut s = String::with_capacity(self.len()); + for (i, c) in self[..].char_indices() { + if c == 'Σ' { + // Σ maps to σ, except at the end of a word where it maps to ς. + // This is the only conditional (contextual) but language-independent mapping + // in `SpecialCasing.txt`, + // so hard-code it rather than have a generic "condition" mechanism. + // See https://github.com/rust-lang/rust/issues/26035 + map_uppercase_sigma(self, i, &mut s) + } else { + match conversions::to_lower(c) { + [a, '\0', _] => s.push(a), + [a, b, '\0'] => { + s.push(a); + s.push(b); + } + [a, b, c] => { + s.push(a); + s.push(b); + s.push(c); + } + } + } + } + return s; + + fn map_uppercase_sigma(from: &str, i: usize, to: &mut String) { + // See http://www.unicode.org/versions/Unicode7.0.0/ch03.pdf#G33992 + // for the definition of `Final_Sigma`. + debug_assert!('Σ'.len_utf8() == 2); + let is_word_final = case_ignoreable_then_cased(from[..i].chars().rev()) + && !case_ignoreable_then_cased(from[i + 2..].chars()); + to.push_str(if is_word_final { "ς" } else { "σ" }); + } + + fn case_ignoreable_then_cased>(iter: I) -> bool { + use core::unicode::derived_property::{Case_Ignorable, Cased}; + match iter.skip_while(|&c| Case_Ignorable(c)).next() { + Some(c) => Cased(c), + None => false, + } + } + } + + /// Returns the uppercase equivalent of this string slice, as a new [`String`]. + /// + /// 'Uppercase' is defined according to the terms of the Unicode Derived Core Property + /// `Uppercase`. + /// + /// Since some characters can expand into multiple characters when changing + /// the case, this function returns a [`String`] instead of modifying the + /// parameter in-place. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = "hello"; + /// + /// assert_eq!("HELLO", s.to_uppercase()); + /// ``` + /// + /// Scripts without case are not changed: + /// + /// ``` + /// let new_year = "农历新年"; + /// + /// assert_eq!(new_year, new_year.to_uppercase()); + /// ``` + /// + /// One character can become multiple: + /// ``` + /// let s = "tschüß"; + /// + /// assert_eq!("TSCHÜSS", s.to_uppercase()); + /// ``` + #[stable(feature = "unicode_case_mapping", since = "1.2.0")] + pub fn to_uppercase(&self) -> String { + let mut s = String::with_capacity(self.len()); + for c in self[..].chars() { + match conversions::to_upper(c) { + [a, '\0', _] => s.push(a), + [a, b, '\0'] => { + s.push(a); + s.push(b); + } + [a, b, c] => { + s.push(a); + s.push(b); + s.push(c); + } + } + } + s + } + + /// Converts a [`Box`] into a [`String`] without copying or allocating. + /// + /// [`Box`]: Box + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let string = String::from("birthday gift"); + /// let boxed_str = string.clone().into_boxed_str(); + /// + /// assert_eq!(boxed_str.into_string(), string); + /// ``` + #[stable(feature = "box_str", since = "1.4.0")] + #[inline] + pub fn into_string(self: Box) -> String { + let slice = Box::<[u8]>::from(self); + unsafe { String::from_utf8_unchecked(slice.into_vec()) } + } + + /// Creates a new [`String`] by repeating a string `n` times. + /// + /// # Panics + /// + /// This function will panic if the capacity would overflow. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// assert_eq!("abc".repeat(4), String::from("abcabcabcabc")); + /// ``` + /// + /// A panic upon overflow: + /// + /// ```should_panic + /// // this will panic at runtime + /// "0123456789abcdef".repeat(usize::MAX); + /// ``` + #[stable(feature = "repeat_str", since = "1.16.0")] + pub fn repeat(&self, n: usize) -> String { + unsafe { String::from_utf8_unchecked(self.as_bytes().repeat(n)) } + } + + /// Returns a copy of this string where each character is mapped to its + /// ASCII upper case equivalent. + /// + /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z', + /// but non-ASCII letters are unchanged. + /// + /// To uppercase the value in-place, use [`make_ascii_uppercase`]. + /// + /// To uppercase ASCII characters in addition to non-ASCII characters, use + /// [`to_uppercase`]. + /// + /// # Examples + /// + /// ``` + /// let s = "Grüße, Jürgen ❤"; + /// + /// assert_eq!("GRüßE, JüRGEN ❤", s.to_ascii_uppercase()); + /// ``` + /// + /// [`make_ascii_uppercase`]: str::make_ascii_uppercase + /// [`to_uppercase`]: #method.to_uppercase + #[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")] + #[inline] + pub fn to_ascii_uppercase(&self) -> String { + let mut bytes = self.as_bytes().to_vec(); + bytes.make_ascii_uppercase(); + // make_ascii_uppercase() preserves the UTF-8 invariant. + unsafe { String::from_utf8_unchecked(bytes) } + } + + /// Returns a copy of this string where each character is mapped to its + /// ASCII lower case equivalent. + /// + /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z', + /// but non-ASCII letters are unchanged. + /// + /// To lowercase the value in-place, use [`make_ascii_lowercase`]. + /// + /// To lowercase ASCII characters in addition to non-ASCII characters, use + /// [`to_lowercase`]. + /// + /// # Examples + /// + /// ``` + /// let s = "Grüße, Jürgen ❤"; + /// + /// assert_eq!("grüße, jürgen ❤", s.to_ascii_lowercase()); + /// ``` + /// + /// [`make_ascii_lowercase`]: str::make_ascii_lowercase + /// [`to_lowercase`]: #method.to_lowercase + #[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")] + #[inline] + pub fn to_ascii_lowercase(&self) -> String { + let mut bytes = self.as_bytes().to_vec(); + bytes.make_ascii_lowercase(); + // make_ascii_lowercase() preserves the UTF-8 invariant. + unsafe { String::from_utf8_unchecked(bytes) } + } +} + +/// Converts a boxed slice of bytes to a boxed string slice without checking +/// that the string contains valid UTF-8. +/// +/// # Examples +/// +/// Basic usage: +/// +/// ``` +/// let smile_utf8 = Box::new([226, 152, 186]); +/// let smile = unsafe { std::str::from_boxed_utf8_unchecked(smile_utf8) }; +/// +/// assert_eq!("☺", &*smile); +/// ``` +#[stable(feature = "str_box_extras", since = "1.20.0")] +#[inline] +pub unsafe fn from_boxed_utf8_unchecked(v: Box<[u8]>) -> Box { + unsafe { Box::from_raw(Box::into_raw(v) as *mut str) } +} diff --git a/libgrust/rustc-lib/alloc/src/string.rs b/libgrust/rustc-lib/alloc/src/string.rs new file mode 100644 index 000000000000..ce216e5336eb --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/string.rs @@ -0,0 +1,2537 @@ +//! A UTF-8–encoded, growable string. +//! +//! This module contains the [`String`] type, the [`ToString`] trait for +//! converting to strings, and several error types that may result from +//! working with [`String`]s. +//! +//! # Examples +//! +//! There are multiple ways to create a new [`String`] from a string literal: +//! +//! ``` +//! let s = "Hello".to_string(); +//! +//! let s = String::from("world"); +//! let s: String = "also this".into(); +//! ``` +//! +//! You can create a new [`String`] from an existing one by concatenating with +//! `+`: +//! +//! ``` +//! let s = "Hello".to_string(); +//! +//! let message = s + " world!"; +//! ``` +//! +//! If you have a vector of valid UTF-8 bytes, you can make a [`String`] out of +//! it. You can do the reverse too. +//! +//! ``` +//! let sparkle_heart = vec![240, 159, 146, 150]; +//! +//! // We know these bytes are valid, so we'll use `unwrap()`. +//! let sparkle_heart = String::from_utf8(sparkle_heart).unwrap(); +//! +//! assert_eq!("💖", sparkle_heart); +//! +//! let bytes = sparkle_heart.into_bytes(); +//! +//! assert_eq!(bytes, [240, 159, 146, 150]); +//! ``` + +#![stable(feature = "rust1", since = "1.0.0")] + +use core::char::{decode_utf16, REPLACEMENT_CHARACTER}; +use core::fmt; +use core::hash; +use core::iter::{FromIterator, FusedIterator}; +use core::ops::Bound::{Excluded, Included, Unbounded}; +use core::ops::{self, Add, AddAssign, Index, IndexMut, Range, RangeBounds}; +use core::ptr; +use core::str::{lossy, pattern::Pattern}; + +use crate::borrow::{Cow, ToOwned}; +use crate::boxed::Box; +use crate::collections::TryReserveError; +use crate::str::{self, from_boxed_utf8_unchecked, Chars, FromStr, Utf8Error}; +use crate::vec::Vec; + +/// A UTF-8–encoded, growable string. +/// +/// The `String` type is the most common string type that has ownership over the +/// contents of the string. It has a close relationship with its borrowed +/// counterpart, the primitive [`str`]. +/// +/// # Examples +/// +/// You can create a `String` from [a literal string][`str`] with [`String::from`]: +/// +/// [`String::from`]: From::from +/// +/// ``` +/// let hello = String::from("Hello, world!"); +/// ``` +/// +/// You can append a [`char`] to a `String` with the [`push`] method, and +/// append a [`&str`] with the [`push_str`] method: +/// +/// ``` +/// let mut hello = String::from("Hello, "); +/// +/// hello.push('w'); +/// hello.push_str("orld!"); +/// ``` +/// +/// [`push`]: String::push +/// [`push_str`]: String::push_str +/// +/// If you have a vector of UTF-8 bytes, you can create a `String` from it with +/// the [`from_utf8`] method: +/// +/// ``` +/// // some bytes, in a vector +/// let sparkle_heart = vec![240, 159, 146, 150]; +/// +/// // We know these bytes are valid, so we'll use `unwrap()`. +/// let sparkle_heart = String::from_utf8(sparkle_heart).unwrap(); +/// +/// assert_eq!("💖", sparkle_heart); +/// ``` +/// +/// [`from_utf8`]: String::from_utf8 +/// +/// # UTF-8 +/// +/// `String`s are always valid UTF-8. This has a few implications, the first of +/// which is that if you need a non-UTF-8 string, consider [`OsString`]. It is +/// similar, but without the UTF-8 constraint. The second implication is that +/// you cannot index into a `String`: +/// +/// ```compile_fail,E0277 +/// let s = "hello"; +/// +/// println!("The first letter of s is {}", s[0]); // ERROR!!! +/// ``` +/// +/// [`OsString`]: ../../std/ffi/struct.OsString.html +/// +/// Indexing is intended to be a constant-time operation, but UTF-8 encoding +/// does not allow us to do this. Furthermore, it's not clear what sort of +/// thing the index should return: a byte, a codepoint, or a grapheme cluster. +/// The [`bytes`] and [`chars`] methods return iterators over the first +/// two, respectively. +/// +/// [`bytes`]: str::bytes +/// [`chars`]: str::chars +/// +/// # Deref +/// +/// `String`s implement [`Deref`]``, and so inherit all of [`str`]'s +/// methods. In addition, this means that you can pass a `String` to a +/// function which takes a [`&str`] by using an ampersand (`&`): +/// +/// ``` +/// fn takes_str(s: &str) { } +/// +/// let s = String::from("Hello"); +/// +/// takes_str(&s); +/// ``` +/// +/// This will create a [`&str`] from the `String` and pass it in. This +/// conversion is very inexpensive, and so generally, functions will accept +/// [`&str`]s as arguments unless they need a `String` for some specific +/// reason. +/// +/// In certain cases Rust doesn't have enough information to make this +/// conversion, known as [`Deref`] coercion. In the following example a string +/// slice [`&'a str`][`&str`] implements the trait `TraitExample`, and the function +/// `example_func` takes anything that implements the trait. In this case Rust +/// would need to make two implicit conversions, which Rust doesn't have the +/// means to do. For that reason, the following example will not compile. +/// +/// ```compile_fail,E0277 +/// trait TraitExample {} +/// +/// impl<'a> TraitExample for &'a str {} +/// +/// fn example_func(example_arg: A) {} +/// +/// let example_string = String::from("example_string"); +/// example_func(&example_string); +/// ``` +/// +/// There are two options that would work instead. The first would be to +/// change the line `example_func(&example_string);` to +/// `example_func(example_string.as_str());`, using the method [`as_str()`] +/// to explicitly extract the string slice containing the string. The second +/// way changes `example_func(&example_string);` to +/// `example_func(&*example_string);`. In this case we are dereferencing a +/// `String` to a [`str`][`&str`], then referencing the [`str`][`&str`] back to +/// [`&str`]. The second way is more idiomatic, however both work to do the +/// conversion explicitly rather than relying on the implicit conversion. +/// +/// # Representation +/// +/// A `String` is made up of three components: a pointer to some bytes, a +/// length, and a capacity. The pointer points to an internal buffer `String` +/// uses to store its data. The length is the number of bytes currently stored +/// in the buffer, and the capacity is the size of the buffer in bytes. As such, +/// the length will always be less than or equal to the capacity. +/// +/// This buffer is always stored on the heap. +/// +/// You can look at these with the [`as_ptr`], [`len`], and [`capacity`] +/// methods: +/// +/// ``` +/// use std::mem; +/// +/// let story = String::from("Once upon a time..."); +/// +// FIXME Update this when vec_into_raw_parts is stabilized +/// // Prevent automatically dropping the String's data +/// let mut story = mem::ManuallyDrop::new(story); +/// +/// let ptr = story.as_mut_ptr(); +/// let len = story.len(); +/// let capacity = story.capacity(); +/// +/// // story has nineteen bytes +/// assert_eq!(19, len); +/// +/// // We can re-build a String out of ptr, len, and capacity. This is all +/// // unsafe because we are responsible for making sure the components are +/// // valid: +/// let s = unsafe { String::from_raw_parts(ptr, len, capacity) } ; +/// +/// assert_eq!(String::from("Once upon a time..."), s); +/// ``` +/// +/// [`as_ptr`]: str::as_ptr +/// [`len`]: String::len +/// [`capacity`]: String::capacity +/// +/// If a `String` has enough capacity, adding elements to it will not +/// re-allocate. For example, consider this program: +/// +/// ``` +/// let mut s = String::new(); +/// +/// println!("{}", s.capacity()); +/// +/// for _ in 0..5 { +/// s.push_str("hello"); +/// println!("{}", s.capacity()); +/// } +/// ``` +/// +/// This will output the following: +/// +/// ```text +/// 0 +/// 5 +/// 10 +/// 20 +/// 20 +/// 40 +/// ``` +/// +/// At first, we have no memory allocated at all, but as we append to the +/// string, it increases its capacity appropriately. If we instead use the +/// [`with_capacity`] method to allocate the correct capacity initially: +/// +/// ``` +/// let mut s = String::with_capacity(25); +/// +/// println!("{}", s.capacity()); +/// +/// for _ in 0..5 { +/// s.push_str("hello"); +/// println!("{}", s.capacity()); +/// } +/// ``` +/// +/// [`with_capacity`]: String::with_capacity +/// +/// We end up with a different output: +/// +/// ```text +/// 25 +/// 25 +/// 25 +/// 25 +/// 25 +/// 25 +/// ``` +/// +/// Here, there's no need to allocate more memory inside the loop. +/// +/// [`str`]: prim@str +/// [`&str`]: prim@str +/// [`Deref`]: core::ops::Deref +/// [`as_str()`]: String::as_str +#[derive(PartialOrd, Eq, Ord)] +#[cfg_attr(not(test), rustc_diagnostic_item = "string_type")] +#[stable(feature = "rust1", since = "1.0.0")] +pub struct String { + vec: Vec, +} + +/// A possible error value when converting a `String` from a UTF-8 byte vector. +/// +/// This type is the error type for the [`from_utf8`] method on [`String`]. It +/// is designed in such a way to carefully avoid reallocations: the +/// [`into_bytes`] method will give back the byte vector that was used in the +/// conversion attempt. +/// +/// [`from_utf8`]: String::from_utf8 +/// [`into_bytes`]: FromUtf8Error::into_bytes +/// +/// The [`Utf8Error`] type provided by [`std::str`] represents an error that may +/// occur when converting a slice of [`u8`]s to a [`&str`]. In this sense, it's +/// an analogue to `FromUtf8Error`, and you can get one from a `FromUtf8Error` +/// through the [`utf8_error`] method. +/// +/// [`Utf8Error`]: core::str::Utf8Error +/// [`std::str`]: core::str +/// [`&str`]: prim@str +/// [`utf8_error`]: Self::utf8_error +/// +/// # Examples +/// +/// Basic usage: +/// +/// ``` +/// // some invalid bytes, in a vector +/// let bytes = vec![0, 159]; +/// +/// let value = String::from_utf8(bytes); +/// +/// assert!(value.is_err()); +/// assert_eq!(vec![0, 159], value.unwrap_err().into_bytes()); +/// ``` +#[stable(feature = "rust1", since = "1.0.0")] +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FromUtf8Error { + bytes: Vec, + error: Utf8Error, +} + +/// A possible error value when converting a `String` from a UTF-16 byte slice. +/// +/// This type is the error type for the [`from_utf16`] method on [`String`]. +/// +/// [`from_utf16`]: String::from_utf16 +/// # Examples +/// +/// Basic usage: +/// +/// ``` +/// // 𝄞muic +/// let v = &[0xD834, 0xDD1E, 0x006d, 0x0075, +/// 0xD800, 0x0069, 0x0063]; +/// +/// assert!(String::from_utf16(v).is_err()); +/// ``` +#[stable(feature = "rust1", since = "1.0.0")] +#[derive(Debug)] +pub struct FromUtf16Error(()); + +impl String { + /// Creates a new empty `String`. + /// + /// Given that the `String` is empty, this will not allocate any initial + /// buffer. While that means that this initial operation is very + /// inexpensive, it may cause excessive allocation later when you add + /// data. If you have an idea of how much data the `String` will hold, + /// consider the [`with_capacity`] method to prevent excessive + /// re-allocation. + /// + /// [`with_capacity`]: String::with_capacity + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = String::new(); + /// ``` + #[inline] + #[rustc_const_stable(feature = "const_string_new", since = "1.32.0")] + #[stable(feature = "rust1", since = "1.0.0")] + pub const fn new() -> String { + String { vec: Vec::new() } + } + + /// Creates a new empty `String` with a particular capacity. + /// + /// `String`s have an internal buffer to hold their data. The capacity is + /// the length of that buffer, and can be queried with the [`capacity`] + /// method. This method creates an empty `String`, but one with an initial + /// buffer that can hold `capacity` bytes. This is useful when you may be + /// appending a bunch of data to the `String`, reducing the number of + /// reallocations it needs to do. + /// + /// [`capacity`]: String::capacity + /// + /// If the given capacity is `0`, no allocation will occur, and this method + /// is identical to the [`new`] method. + /// + /// [`new`]: String::new + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::with_capacity(10); + /// + /// // The String contains no chars, even though it has capacity for more + /// assert_eq!(s.len(), 0); + /// + /// // These are all done without reallocating... + /// let cap = s.capacity(); + /// for _ in 0..10 { + /// s.push('a'); + /// } + /// + /// assert_eq!(s.capacity(), cap); + /// + /// // ...but this may make the string reallocate + /// s.push('a'); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn with_capacity(capacity: usize) -> String { + String { vec: Vec::with_capacity(capacity) } + } + + // HACK(japaric): with cfg(test) the inherent `[T]::to_vec` method, which is + // required for this method definition, is not available. Since we don't + // require this method for testing purposes, I'll just stub it + // NB see the slice::hack module in slice.rs for more information + #[inline] + #[cfg(test)] + pub fn from_str(_: &str) -> String { + panic!("not available with cfg(test)"); + } + + /// Converts a vector of bytes to a `String`. + /// + /// A string ([`String`]) is made of bytes ([`u8`]), and a vector of bytes + /// ([`Vec`]) is made of bytes, so this function converts between the + /// two. Not all byte slices are valid `String`s, however: `String` + /// requires that it is valid UTF-8. `from_utf8()` checks to ensure that + /// the bytes are valid UTF-8, and then does the conversion. + /// + /// If you are sure that the byte slice is valid UTF-8, and you don't want + /// to incur the overhead of the validity check, there is an unsafe version + /// of this function, [`from_utf8_unchecked`], which has the same behavior + /// but skips the check. + /// + /// This method will take care to not copy the vector, for efficiency's + /// sake. + /// + /// If you need a [`&str`] instead of a `String`, consider + /// [`str::from_utf8`]. + /// + /// The inverse of this method is [`into_bytes`]. + /// + /// # Errors + /// + /// Returns [`Err`] if the slice is not UTF-8 with a description as to why the + /// provided bytes are not UTF-8. The vector you moved in is also included. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// // some bytes, in a vector + /// let sparkle_heart = vec![240, 159, 146, 150]; + /// + /// // We know these bytes are valid, so we'll use `unwrap()`. + /// let sparkle_heart = String::from_utf8(sparkle_heart).unwrap(); + /// + /// assert_eq!("💖", sparkle_heart); + /// ``` + /// + /// Incorrect bytes: + /// + /// ``` + /// // some invalid bytes, in a vector + /// let sparkle_heart = vec![0, 159, 146, 150]; + /// + /// assert!(String::from_utf8(sparkle_heart).is_err()); + /// ``` + /// + /// See the docs for [`FromUtf8Error`] for more details on what you can do + /// with this error. + /// + /// [`from_utf8_unchecked`]: String::from_utf8_unchecked + /// [`Vec`]: crate::vec::Vec + /// [`&str`]: prim@str + /// [`into_bytes`]: String::into_bytes + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn from_utf8(vec: Vec) -> Result { + match str::from_utf8(&vec) { + Ok(..) => Ok(String { vec }), + Err(e) => Err(FromUtf8Error { bytes: vec, error: e }), + } + } + + /// Converts a slice of bytes to a string, including invalid characters. + /// + /// Strings are made of bytes ([`u8`]), and a slice of bytes + /// ([`&[u8]`][byteslice]) is made of bytes, so this function converts + /// between the two. Not all byte slices are valid strings, however: strings + /// are required to be valid UTF-8. During this conversion, + /// `from_utf8_lossy()` will replace any invalid UTF-8 sequences with + /// [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD], which looks like this: � + /// + /// [byteslice]: ../../std/primitive.slice.html + /// [U+FFFD]: core::char::REPLACEMENT_CHARACTER + /// + /// If you are sure that the byte slice is valid UTF-8, and you don't want + /// to incur the overhead of the conversion, there is an unsafe version + /// of this function, [`from_utf8_unchecked`], which has the same behavior + /// but skips the checks. + /// + /// [`from_utf8_unchecked`]: String::from_utf8_unchecked + /// + /// This function returns a [`Cow<'a, str>`]. If our byte slice is invalid + /// UTF-8, then we need to insert the replacement characters, which will + /// change the size of the string, and hence, require a `String`. But if + /// it's already valid UTF-8, we don't need a new allocation. This return + /// type allows us to handle both cases. + /// + /// [`Cow<'a, str>`]: crate::borrow::Cow + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// // some bytes, in a vector + /// let sparkle_heart = vec![240, 159, 146, 150]; + /// + /// let sparkle_heart = String::from_utf8_lossy(&sparkle_heart); + /// + /// assert_eq!("💖", sparkle_heart); + /// ``` + /// + /// Incorrect bytes: + /// + /// ``` + /// // some invalid bytes + /// let input = b"Hello \xF0\x90\x80World"; + /// let output = String::from_utf8_lossy(input); + /// + /// assert_eq!("Hello �World", output); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn from_utf8_lossy(v: &[u8]) -> Cow<'_, str> { + let mut iter = lossy::Utf8Lossy::from_bytes(v).chunks(); + + let (first_valid, first_broken) = if let Some(chunk) = iter.next() { + let lossy::Utf8LossyChunk { valid, broken } = chunk; + if valid.len() == v.len() { + debug_assert!(broken.is_empty()); + return Cow::Borrowed(valid); + } + (valid, broken) + } else { + return Cow::Borrowed(""); + }; + + const REPLACEMENT: &str = "\u{FFFD}"; + + let mut res = String::with_capacity(v.len()); + res.push_str(first_valid); + if !first_broken.is_empty() { + res.push_str(REPLACEMENT); + } + + for lossy::Utf8LossyChunk { valid, broken } in iter { + res.push_str(valid); + if !broken.is_empty() { + res.push_str(REPLACEMENT); + } + } + + Cow::Owned(res) + } + + /// Decode a UTF-16–encoded vector `v` into a `String`, returning [`Err`] + /// if `v` contains any invalid data. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// // 𝄞music + /// let v = &[0xD834, 0xDD1E, 0x006d, 0x0075, + /// 0x0073, 0x0069, 0x0063]; + /// assert_eq!(String::from("𝄞music"), + /// String::from_utf16(v).unwrap()); + /// + /// // 𝄞muic + /// let v = &[0xD834, 0xDD1E, 0x006d, 0x0075, + /// 0xD800, 0x0069, 0x0063]; + /// assert!(String::from_utf16(v).is_err()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn from_utf16(v: &[u16]) -> Result { + // This isn't done via collect::>() for performance reasons. + // FIXME: the function can be simplified again when #48994 is closed. + let mut ret = String::with_capacity(v.len()); + for c in decode_utf16(v.iter().cloned()) { + if let Ok(c) = c { + ret.push(c); + } else { + return Err(FromUtf16Error(())); + } + } + Ok(ret) + } + + /// Decode a UTF-16–encoded slice `v` into a `String`, replacing + /// invalid data with [the replacement character (`U+FFFD`)][U+FFFD]. + /// + /// Unlike [`from_utf8_lossy`] which returns a [`Cow<'a, str>`], + /// `from_utf16_lossy` returns a `String` since the UTF-16 to UTF-8 + /// conversion requires a memory allocation. + /// + /// [`from_utf8_lossy`]: String::from_utf8_lossy + /// [`Cow<'a, str>`]: crate::borrow::Cow + /// [U+FFFD]: core::char::REPLACEMENT_CHARACTER + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// // 𝄞music + /// let v = &[0xD834, 0xDD1E, 0x006d, 0x0075, + /// 0x0073, 0xDD1E, 0x0069, 0x0063, + /// 0xD834]; + /// + /// assert_eq!(String::from("𝄞mus\u{FFFD}ic\u{FFFD}"), + /// String::from_utf16_lossy(v)); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn from_utf16_lossy(v: &[u16]) -> String { + decode_utf16(v.iter().cloned()).map(|r| r.unwrap_or(REPLACEMENT_CHARACTER)).collect() + } + + /// Decomposes a `String` into its raw components. + /// + /// Returns the raw pointer to the underlying data, the length of + /// the string (in bytes), and the allocated capacity of the data + /// (in bytes). These are the same arguments in the same order as + /// the arguments to [`from_raw_parts`]. + /// + /// After calling this function, the caller is responsible for the + /// memory previously managed by the `String`. The only way to do + /// this is to convert the raw pointer, length, and capacity back + /// into a `String` with the [`from_raw_parts`] function, allowing + /// the destructor to perform the cleanup. + /// + /// [`from_raw_parts`]: String::from_raw_parts + /// + /// # Examples + /// + /// ``` + /// #![feature(vec_into_raw_parts)] + /// let s = String::from("hello"); + /// + /// let (ptr, len, cap) = s.into_raw_parts(); + /// + /// let rebuilt = unsafe { String::from_raw_parts(ptr, len, cap) }; + /// assert_eq!(rebuilt, "hello"); + /// ``` + #[unstable(feature = "vec_into_raw_parts", reason = "new API", issue = "65816")] + pub fn into_raw_parts(self) -> (*mut u8, usize, usize) { + self.vec.into_raw_parts() + } + + /// Creates a new `String` from a length, capacity, and pointer. + /// + /// # Safety + /// + /// This is highly unsafe, due to the number of invariants that aren't + /// checked: + /// + /// * The memory at `buf` needs to have been previously allocated by the + /// same allocator the standard library uses, with a required alignment of exactly 1. + /// * `length` needs to be less than or equal to `capacity`. + /// * `capacity` needs to be the correct value. + /// * The first `length` bytes at `buf` need to be valid UTF-8. + /// + /// Violating these may cause problems like corrupting the allocator's + /// internal data structures. + /// + /// The ownership of `buf` is effectively transferred to the + /// `String` which may then deallocate, reallocate or change the + /// contents of memory pointed to by the pointer at will. Ensure + /// that nothing else uses the pointer after calling this + /// function. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::mem; + /// + /// unsafe { + /// let s = String::from("hello"); + /// + // FIXME Update this when vec_into_raw_parts is stabilized + /// // Prevent automatically dropping the String's data + /// let mut s = mem::ManuallyDrop::new(s); + /// + /// let ptr = s.as_mut_ptr(); + /// let len = s.len(); + /// let capacity = s.capacity(); + /// + /// let s = String::from_raw_parts(ptr, len, capacity); + /// + /// assert_eq!(String::from("hello"), s); + /// } + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub unsafe fn from_raw_parts(buf: *mut u8, length: usize, capacity: usize) -> String { + unsafe { String { vec: Vec::from_raw_parts(buf, length, capacity) } } + } + + /// Converts a vector of bytes to a `String` without checking that the + /// string contains valid UTF-8. + /// + /// See the safe version, [`from_utf8`], for more details. + /// + /// [`from_utf8`]: String::from_utf8 + /// + /// # Safety + /// + /// This function is unsafe because it does not check that the bytes passed + /// to it are valid UTF-8. If this constraint is violated, it may cause + /// memory unsafety issues with future users of the `String`, as the rest of + /// the standard library assumes that `String`s are valid UTF-8. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// // some bytes, in a vector + /// let sparkle_heart = vec![240, 159, 146, 150]; + /// + /// let sparkle_heart = unsafe { + /// String::from_utf8_unchecked(sparkle_heart) + /// }; + /// + /// assert_eq!("💖", sparkle_heart); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub unsafe fn from_utf8_unchecked(bytes: Vec) -> String { + String { vec: bytes } + } + + /// Converts a `String` into a byte vector. + /// + /// This consumes the `String`, so we do not need to copy its contents. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = String::from("hello"); + /// let bytes = s.into_bytes(); + /// + /// assert_eq!(&[104, 101, 108, 108, 111][..], &bytes[..]); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn into_bytes(self) -> Vec { + self.vec + } + + /// Extracts a string slice containing the entire `String`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = String::from("foo"); + /// + /// assert_eq!("foo", s.as_str()); + /// ``` + #[inline] + #[stable(feature = "string_as_str", since = "1.7.0")] + pub fn as_str(&self) -> &str { + self + } + + /// Converts a `String` into a mutable string slice. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("foobar"); + /// let s_mut_str = s.as_mut_str(); + /// + /// s_mut_str.make_ascii_uppercase(); + /// + /// assert_eq!("FOOBAR", s_mut_str); + /// ``` + #[inline] + #[stable(feature = "string_as_str", since = "1.7.0")] + pub fn as_mut_str(&mut self) -> &mut str { + self + } + + /// Appends a given string slice onto the end of this `String`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("foo"); + /// + /// s.push_str("bar"); + /// + /// assert_eq!("foobar", s); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn push_str(&mut self, string: &str) { + self.vec.extend_from_slice(string.as_bytes()) + } + + /// Returns this `String`'s capacity, in bytes. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = String::with_capacity(10); + /// + /// assert!(s.capacity() >= 10); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn capacity(&self) -> usize { + self.vec.capacity() + } + + /// Ensures that this `String`'s capacity is at least `additional` bytes + /// larger than its length. + /// + /// The capacity may be increased by more than `additional` bytes if it + /// chooses, to prevent frequent reallocations. + /// + /// If you do not want this "at least" behavior, see the [`reserve_exact`] + /// method. + /// + /// # Panics + /// + /// Panics if the new capacity overflows [`usize`]. + /// + /// [`reserve_exact`]: String::reserve_exact + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::new(); + /// + /// s.reserve(10); + /// + /// assert!(s.capacity() >= 10); + /// ``` + /// + /// This may not actually increase the capacity: + /// + /// ``` + /// let mut s = String::with_capacity(10); + /// s.push('a'); + /// s.push('b'); + /// + /// // s now has a length of 2 and a capacity of 10 + /// assert_eq!(2, s.len()); + /// assert_eq!(10, s.capacity()); + /// + /// // Since we already have an extra 8 capacity, calling this... + /// s.reserve(8); + /// + /// // ... doesn't actually increase. + /// assert_eq!(10, s.capacity()); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn reserve(&mut self, additional: usize) { + self.vec.reserve(additional) + } + + /// Ensures that this `String`'s capacity is `additional` bytes + /// larger than its length. + /// + /// Consider using the [`reserve`] method unless you absolutely know + /// better than the allocator. + /// + /// [`reserve`]: String::reserve + /// + /// # Panics + /// + /// Panics if the new capacity overflows `usize`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::new(); + /// + /// s.reserve_exact(10); + /// + /// assert!(s.capacity() >= 10); + /// ``` + /// + /// This may not actually increase the capacity: + /// + /// ``` + /// let mut s = String::with_capacity(10); + /// s.push('a'); + /// s.push('b'); + /// + /// // s now has a length of 2 and a capacity of 10 + /// assert_eq!(2, s.len()); + /// assert_eq!(10, s.capacity()); + /// + /// // Since we already have an extra 8 capacity, calling this... + /// s.reserve_exact(8); + /// + /// // ... doesn't actually increase. + /// assert_eq!(10, s.capacity()); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn reserve_exact(&mut self, additional: usize) { + self.vec.reserve_exact(additional) + } + + /// Tries to reserve capacity for at least `additional` more elements to be inserted + /// in the given `String`. The collection may reserve more space to avoid + /// frequent reallocations. After calling `reserve`, capacity will be + /// greater than or equal to `self.len() + additional`. Does nothing if + /// capacity is already sufficient. + /// + /// # Errors + /// + /// If the capacity overflows, or the allocator reports a failure, then an error + /// is returned. + /// + /// # Examples + /// + /// ``` + /// #![feature(try_reserve)] + /// use std::collections::TryReserveError; + /// + /// fn process_data(data: &str) -> Result { + /// let mut output = String::new(); + /// + /// // Pre-reserve the memory, exiting if we can't + /// output.try_reserve(data.len())?; + /// + /// // Now we know this can't OOM in the middle of our complex work + /// output.push_str(data); + /// + /// Ok(output) + /// } + /// # process_data("rust").expect("why is the test harness OOMing on 4 bytes?"); + /// ``` + #[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] + pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> { + self.vec.try_reserve(additional) + } + + /// Tries to reserves the minimum capacity for exactly `additional` more elements to + /// be inserted in the given `String`. After calling `reserve_exact`, + /// capacity will be greater than or equal to `self.len() + additional`. + /// Does nothing if the capacity is already sufficient. + /// + /// Note that the allocator may give the collection more space than it + /// requests. Therefore, capacity can not be relied upon to be precisely + /// minimal. Prefer `reserve` if future insertions are expected. + /// + /// # Errors + /// + /// If the capacity overflows, or the allocator reports a failure, then an error + /// is returned. + /// + /// # Examples + /// + /// ``` + /// #![feature(try_reserve)] + /// use std::collections::TryReserveError; + /// + /// fn process_data(data: &str) -> Result { + /// let mut output = String::new(); + /// + /// // Pre-reserve the memory, exiting if we can't + /// output.try_reserve(data.len())?; + /// + /// // Now we know this can't OOM in the middle of our complex work + /// output.push_str(data); + /// + /// Ok(output) + /// } + /// # process_data("rust").expect("why is the test harness OOMing on 4 bytes?"); + /// ``` + #[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] + pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveError> { + self.vec.try_reserve_exact(additional) + } + + /// Shrinks the capacity of this `String` to match its length. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("foo"); + /// + /// s.reserve(100); + /// assert!(s.capacity() >= 100); + /// + /// s.shrink_to_fit(); + /// assert_eq!(3, s.capacity()); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn shrink_to_fit(&mut self) { + self.vec.shrink_to_fit() + } + + /// Shrinks the capacity of this `String` with a lower bound. + /// + /// The capacity will remain at least as large as both the length + /// and the supplied value. + /// + /// Panics if the current capacity is smaller than the supplied + /// minimum capacity. + /// + /// # Examples + /// + /// ``` + /// #![feature(shrink_to)] + /// let mut s = String::from("foo"); + /// + /// s.reserve(100); + /// assert!(s.capacity() >= 100); + /// + /// s.shrink_to(10); + /// assert!(s.capacity() >= 10); + /// s.shrink_to(0); + /// assert!(s.capacity() >= 3); + /// ``` + #[inline] + #[unstable(feature = "shrink_to", reason = "new API", issue = "56431")] + pub fn shrink_to(&mut self, min_capacity: usize) { + self.vec.shrink_to(min_capacity) + } + + /// Appends the given [`char`] to the end of this `String`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("abc"); + /// + /// s.push('1'); + /// s.push('2'); + /// s.push('3'); + /// + /// assert_eq!("abc123", s); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn push(&mut self, ch: char) { + match ch.len_utf8() { + 1 => self.vec.push(ch as u8), + _ => self.vec.extend_from_slice(ch.encode_utf8(&mut [0; 4]).as_bytes()), + } + } + + /// Returns a byte slice of this `String`'s contents. + /// + /// The inverse of this method is [`from_utf8`]. + /// + /// [`from_utf8`]: String::from_utf8 + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = String::from("hello"); + /// + /// assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes()); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn as_bytes(&self) -> &[u8] { + &self.vec + } + + /// Shortens this `String` to the specified length. + /// + /// If `new_len` is greater than the string's current length, this has no + /// effect. + /// + /// Note that this method has no effect on the allocated capacity + /// of the string + /// + /// # Panics + /// + /// Panics if `new_len` does not lie on a [`char`] boundary. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("hello"); + /// + /// s.truncate(2); + /// + /// assert_eq!("he", s); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn truncate(&mut self, new_len: usize) { + if new_len <= self.len() { + assert!(self.is_char_boundary(new_len)); + self.vec.truncate(new_len) + } + } + + /// Removes the last character from the string buffer and returns it. + /// + /// Returns [`None`] if this `String` is empty. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("foo"); + /// + /// assert_eq!(s.pop(), Some('o')); + /// assert_eq!(s.pop(), Some('o')); + /// assert_eq!(s.pop(), Some('f')); + /// + /// assert_eq!(s.pop(), None); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn pop(&mut self) -> Option { + let ch = self.chars().rev().next()?; + let newlen = self.len() - ch.len_utf8(); + unsafe { + self.vec.set_len(newlen); + } + Some(ch) + } + + /// Removes a [`char`] from this `String` at a byte position and returns it. + /// + /// This is an *O*(*n*) operation, as it requires copying every element in the + /// buffer. + /// + /// # Panics + /// + /// Panics if `idx` is larger than or equal to the `String`'s length, + /// or if it does not lie on a [`char`] boundary. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("foo"); + /// + /// assert_eq!(s.remove(0), 'f'); + /// assert_eq!(s.remove(1), 'o'); + /// assert_eq!(s.remove(0), 'o'); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn remove(&mut self, idx: usize) -> char { + let ch = match self[idx..].chars().next() { + Some(ch) => ch, + None => panic!("cannot remove a char from the end of a string"), + }; + + let next = idx + ch.len_utf8(); + let len = self.len(); + unsafe { + ptr::copy(self.vec.as_ptr().add(next), self.vec.as_mut_ptr().add(idx), len - next); + self.vec.set_len(len - (next - idx)); + } + ch + } + + /// Retains only the characters specified by the predicate. + /// + /// In other words, remove all characters `c` such that `f(c)` returns `false`. + /// This method operates in place, visiting each character exactly once in the + /// original order, and preserves the order of the retained characters. + /// + /// # Examples + /// + /// ``` + /// let mut s = String::from("f_o_ob_ar"); + /// + /// s.retain(|c| c != '_'); + /// + /// assert_eq!(s, "foobar"); + /// ``` + /// + /// The exact order may be useful for tracking external state, like an index. + /// + /// ``` + /// let mut s = String::from("abcde"); + /// let keep = [false, true, true, false, true]; + /// let mut i = 0; + /// s.retain(|_| (keep[i], i += 1).0); + /// assert_eq!(s, "bce"); + /// ``` + #[inline] + #[stable(feature = "string_retain", since = "1.26.0")] + pub fn retain(&mut self, mut f: F) + where + F: FnMut(char) -> bool, + { + let len = self.len(); + let mut del_bytes = 0; + let mut idx = 0; + + unsafe { + self.vec.set_len(0); + } + + while idx < len { + let ch = unsafe { self.get_unchecked(idx..len).chars().next().unwrap() }; + let ch_len = ch.len_utf8(); + + if !f(ch) { + del_bytes += ch_len; + } else if del_bytes > 0 { + unsafe { + ptr::copy( + self.vec.as_ptr().add(idx), + self.vec.as_mut_ptr().add(idx - del_bytes), + ch_len, + ); + } + } + + // Point idx to the next char + idx += ch_len; + } + + unsafe { + self.vec.set_len(len - del_bytes); + } + } + + /// Inserts a character into this `String` at a byte position. + /// + /// This is an *O*(*n*) operation as it requires copying every element in the + /// buffer. + /// + /// # Panics + /// + /// Panics if `idx` is larger than the `String`'s length, or if it does not + /// lie on a [`char`] boundary. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::with_capacity(3); + /// + /// s.insert(0, 'f'); + /// s.insert(1, 'o'); + /// s.insert(2, 'o'); + /// + /// assert_eq!("foo", s); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn insert(&mut self, idx: usize, ch: char) { + assert!(self.is_char_boundary(idx)); + let mut bits = [0; 4]; + let bits = ch.encode_utf8(&mut bits).as_bytes(); + + unsafe { + self.insert_bytes(idx, bits); + } + } + + unsafe fn insert_bytes(&mut self, idx: usize, bytes: &[u8]) { + let len = self.len(); + let amt = bytes.len(); + self.vec.reserve(amt); + + unsafe { + ptr::copy(self.vec.as_ptr().add(idx), self.vec.as_mut_ptr().add(idx + amt), len - idx); + ptr::copy(bytes.as_ptr(), self.vec.as_mut_ptr().add(idx), amt); + self.vec.set_len(len + amt); + } + } + + /// Inserts a string slice into this `String` at a byte position. + /// + /// This is an *O*(*n*) operation as it requires copying every element in the + /// buffer. + /// + /// # Panics + /// + /// Panics if `idx` is larger than the `String`'s length, or if it does not + /// lie on a [`char`] boundary. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("bar"); + /// + /// s.insert_str(0, "foo"); + /// + /// assert_eq!("foobar", s); + /// ``` + #[inline] + #[stable(feature = "insert_str", since = "1.16.0")] + pub fn insert_str(&mut self, idx: usize, string: &str) { + assert!(self.is_char_boundary(idx)); + + unsafe { + self.insert_bytes(idx, string.as_bytes()); + } + } + + /// Returns a mutable reference to the contents of this `String`. + /// + /// # Safety + /// + /// This function is unsafe because it does not check that the bytes passed + /// to it are valid UTF-8. If this constraint is violated, it may cause + /// memory unsafety issues with future users of the `String`, as the rest of + /// the standard library assumes that `String`s are valid UTF-8. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("hello"); + /// + /// unsafe { + /// let vec = s.as_mut_vec(); + /// assert_eq!(&[104, 101, 108, 108, 111][..], &vec[..]); + /// + /// vec.reverse(); + /// } + /// assert_eq!(s, "olleh"); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub unsafe fn as_mut_vec(&mut self) -> &mut Vec { + &mut self.vec + } + + /// Returns the length of this `String`, in bytes, not [`char`]s or + /// graphemes. In other words, it may not be what a human considers the + /// length of the string. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let a = String::from("foo"); + /// assert_eq!(a.len(), 3); + /// + /// let fancy_f = String::from("ƒoo"); + /// assert_eq!(fancy_f.len(), 4); + /// assert_eq!(fancy_f.chars().count(), 3); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn len(&self) -> usize { + self.vec.len() + } + + /// Returns `true` if this `String` has a length of zero, and `false` otherwise. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut v = String::new(); + /// assert!(v.is_empty()); + /// + /// v.push('a'); + /// assert!(!v.is_empty()); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// Splits the string into two at the given index. + /// + /// Returns a newly allocated `String`. `self` contains bytes `[0, at)`, and + /// the returned `String` contains bytes `[at, len)`. `at` must be on the + /// boundary of a UTF-8 code point. + /// + /// Note that the capacity of `self` does not change. + /// + /// # Panics + /// + /// Panics if `at` is not on a `UTF-8` code point boundary, or if it is beyond the last + /// code point of the string. + /// + /// # Examples + /// + /// ``` + /// # fn main() { + /// let mut hello = String::from("Hello, World!"); + /// let world = hello.split_off(7); + /// assert_eq!(hello, "Hello, "); + /// assert_eq!(world, "World!"); + /// # } + /// ``` + #[inline] + #[stable(feature = "string_split_off", since = "1.16.0")] + #[must_use = "use `.truncate()` if you don't need the other half"] + pub fn split_off(&mut self, at: usize) -> String { + assert!(self.is_char_boundary(at)); + let other = self.vec.split_off(at); + unsafe { String::from_utf8_unchecked(other) } + } + + /// Truncates this `String`, removing all contents. + /// + /// While this means the `String` will have a length of zero, it does not + /// touch its capacity. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("foo"); + /// + /// s.clear(); + /// + /// assert!(s.is_empty()); + /// assert_eq!(0, s.len()); + /// assert_eq!(3, s.capacity()); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn clear(&mut self) { + self.vec.clear() + } + + /// Creates a draining iterator that removes the specified range in the `String` + /// and yields the removed `chars`. + /// + /// Note: The element range is removed even if the iterator is not + /// consumed until the end. + /// + /// # Panics + /// + /// Panics if the starting point or end point do not lie on a [`char`] + /// boundary, or if they're out of bounds. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("α is alpha, β is beta"); + /// let beta_offset = s.find('β').unwrap_or(s.len()); + /// + /// // Remove the range up until the β from the string + /// let t: String = s.drain(..beta_offset).collect(); + /// assert_eq!(t, "α is alpha, "); + /// assert_eq!(s, "β is beta"); + /// + /// // A full range clears the string + /// s.drain(..); + /// assert_eq!(s, ""); + /// ``` + #[stable(feature = "drain", since = "1.6.0")] + pub fn drain(&mut self, range: R) -> Drain<'_> + where + R: RangeBounds, + { + // Memory safety + // + // The String version of Drain does not have the memory safety issues + // of the vector version. The data is just plain bytes. + // Because the range removal happens in Drop, if the Drain iterator is leaked, + // the removal will not happen. + let Range { start, end } = range.assert_len(self.len()); + assert!(self.is_char_boundary(start)); + assert!(self.is_char_boundary(end)); + + // Take out two simultaneous borrows. The &mut String won't be accessed + // until iteration is over, in Drop. + let self_ptr = self as *mut _; + // SAFETY: `assert_len` and `is_char_boundary` do the appropriate bounds checks. + let chars_iter = unsafe { self.get_unchecked(start..end) }.chars(); + + Drain { start, end, iter: chars_iter, string: self_ptr } + } + + /// Removes the specified range in the string, + /// and replaces it with the given string. + /// The given string doesn't need to be the same length as the range. + /// + /// # Panics + /// + /// Panics if the starting point or end point do not lie on a [`char`] + /// boundary, or if they're out of bounds. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("α is alpha, β is beta"); + /// let beta_offset = s.find('β').unwrap_or(s.len()); + /// + /// // Replace the range up until the β from the string + /// s.replace_range(..beta_offset, "Α is capital alpha; "); + /// assert_eq!(s, "Α is capital alpha; β is beta"); + /// ``` + #[stable(feature = "splice", since = "1.27.0")] + pub fn replace_range(&mut self, range: R, replace_with: &str) + where + R: RangeBounds, + { + // Memory safety + // + // Replace_range does not have the memory safety issues of a vector Splice. + // of the vector version. The data is just plain bytes. + + match range.start_bound() { + Included(&n) => assert!(self.is_char_boundary(n)), + Excluded(&n) => assert!(self.is_char_boundary(n + 1)), + Unbounded => {} + }; + match range.end_bound() { + Included(&n) => assert!(self.is_char_boundary(n + 1)), + Excluded(&n) => assert!(self.is_char_boundary(n)), + Unbounded => {} + }; + + unsafe { self.as_mut_vec() }.splice(range, replace_with.bytes()); + } + + /// Converts this `String` into a [`Box`]`<`[`str`]`>`. + /// + /// This will drop any excess capacity. + /// + /// [`str`]: prim@str + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = String::from("hello"); + /// + /// let b = s.into_boxed_str(); + /// ``` + #[stable(feature = "box_str", since = "1.4.0")] + #[inline] + pub fn into_boxed_str(self) -> Box { + let slice = self.vec.into_boxed_slice(); + unsafe { from_boxed_utf8_unchecked(slice) } + } +} + +impl FromUtf8Error { + /// Returns a slice of [`u8`]s bytes that were attempted to convert to a `String`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// // some invalid bytes, in a vector + /// let bytes = vec![0, 159]; + /// + /// let value = String::from_utf8(bytes); + /// + /// assert_eq!(&[0, 159], value.unwrap_err().as_bytes()); + /// ``` + #[stable(feature = "from_utf8_error_as_bytes", since = "1.26.0")] + pub fn as_bytes(&self) -> &[u8] { + &self.bytes[..] + } + + /// Returns the bytes that were attempted to convert to a `String`. + /// + /// This method is carefully constructed to avoid allocation. It will + /// consume the error, moving out the bytes, so that a copy of the bytes + /// does not need to be made. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// // some invalid bytes, in a vector + /// let bytes = vec![0, 159]; + /// + /// let value = String::from_utf8(bytes); + /// + /// assert_eq!(vec![0, 159], value.unwrap_err().into_bytes()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn into_bytes(self) -> Vec { + self.bytes + } + + /// Fetch a `Utf8Error` to get more details about the conversion failure. + /// + /// The [`Utf8Error`] type provided by [`std::str`] represents an error that may + /// occur when converting a slice of [`u8`]s to a [`&str`]. In this sense, it's + /// an analogue to `FromUtf8Error`. See its documentation for more details + /// on using it. + /// + /// [`std::str`]: core::str + /// [`&str`]: prim@str + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// // some invalid bytes, in a vector + /// let bytes = vec![0, 159]; + /// + /// let error = String::from_utf8(bytes).unwrap_err().utf8_error(); + /// + /// // the first byte is invalid here + /// assert_eq!(1, error.valid_up_to()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn utf8_error(&self) -> Utf8Error { + self.error + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Display for FromUtf8Error { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Display::fmt(&self.error, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Display for FromUtf16Error { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Display::fmt("invalid utf-16: lone surrogate found", f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for String { + fn clone(&self) -> Self { + String { vec: self.vec.clone() } + } + + fn clone_from(&mut self, source: &Self) { + self.vec.clone_from(&source.vec); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl FromIterator for String { + fn from_iter>(iter: I) -> String { + let mut buf = String::new(); + buf.extend(iter); + buf + } +} + +#[stable(feature = "string_from_iter_by_ref", since = "1.17.0")] +impl<'a> FromIterator<&'a char> for String { + fn from_iter>(iter: I) -> String { + let mut buf = String::new(); + buf.extend(iter); + buf + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a> FromIterator<&'a str> for String { + fn from_iter>(iter: I) -> String { + let mut buf = String::new(); + buf.extend(iter); + buf + } +} + +#[stable(feature = "extend_string", since = "1.4.0")] +impl FromIterator for String { + fn from_iter>(iter: I) -> String { + let mut iterator = iter.into_iter(); + + // Because we're iterating over `String`s, we can avoid at least + // one allocation by getting the first string from the iterator + // and appending to it all the subsequent strings. + match iterator.next() { + None => String::new(), + Some(mut buf) => { + buf.extend(iterator); + buf + } + } + } +} + +#[stable(feature = "box_str2", since = "1.45.0")] +impl FromIterator> for String { + fn from_iter>>(iter: I) -> String { + let mut buf = String::new(); + buf.extend(iter); + buf + } +} + +#[stable(feature = "herd_cows", since = "1.19.0")] +impl<'a> FromIterator> for String { + fn from_iter>>(iter: I) -> String { + let mut iterator = iter.into_iter(); + + // Because we're iterating over CoWs, we can (potentially) avoid at least + // one allocation by getting the first item and appending to it all the + // subsequent items. + match iterator.next() { + None => String::new(), + Some(cow) => { + let mut buf = cow.into_owned(); + buf.extend(iterator); + buf + } + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Extend for String { + fn extend>(&mut self, iter: I) { + let iterator = iter.into_iter(); + let (lower_bound, _) = iterator.size_hint(); + self.reserve(lower_bound); + iterator.for_each(move |c| self.push(c)); + } + + #[inline] + fn extend_one(&mut self, c: char) { + self.push(c); + } + + #[inline] + fn extend_reserve(&mut self, additional: usize) { + self.reserve(additional); + } +} + +#[stable(feature = "extend_ref", since = "1.2.0")] +impl<'a> Extend<&'a char> for String { + fn extend>(&mut self, iter: I) { + self.extend(iter.into_iter().cloned()); + } + + #[inline] + fn extend_one(&mut self, &c: &'a char) { + self.push(c); + } + + #[inline] + fn extend_reserve(&mut self, additional: usize) { + self.reserve(additional); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a> Extend<&'a str> for String { + fn extend>(&mut self, iter: I) { + iter.into_iter().for_each(move |s| self.push_str(s)); + } + + #[inline] + fn extend_one(&mut self, s: &'a str) { + self.push_str(s); + } +} + +#[stable(feature = "box_str2", since = "1.45.0")] +impl Extend> for String { + fn extend>>(&mut self, iter: I) { + iter.into_iter().for_each(move |s| self.push_str(&s)); + } +} + +#[stable(feature = "extend_string", since = "1.4.0")] +impl Extend for String { + fn extend>(&mut self, iter: I) { + iter.into_iter().for_each(move |s| self.push_str(&s)); + } + + #[inline] + fn extend_one(&mut self, s: String) { + self.push_str(&s); + } +} + +#[stable(feature = "herd_cows", since = "1.19.0")] +impl<'a> Extend> for String { + fn extend>>(&mut self, iter: I) { + iter.into_iter().for_each(move |s| self.push_str(&s)); + } + + #[inline] + fn extend_one(&mut self, s: Cow<'a, str>) { + self.push_str(&s); + } +} + +/// A convenience impl that delegates to the impl for `&str`. +/// +/// # Examples +/// +/// ``` +/// assert_eq!(String::from("Hello world").find("world"), Some(6)); +/// ``` +#[unstable( + feature = "pattern", + reason = "API not fully fleshed out and ready to be stabilized", + issue = "27721" +)] +impl<'a, 'b> Pattern<'a> for &'b String { + type Searcher = <&'b str as Pattern<'a>>::Searcher; + + fn into_searcher(self, haystack: &'a str) -> <&'b str as Pattern<'a>>::Searcher { + self[..].into_searcher(haystack) + } + + #[inline] + fn is_contained_in(self, haystack: &'a str) -> bool { + self[..].is_contained_in(haystack) + } + + #[inline] + fn is_prefix_of(self, haystack: &'a str) -> bool { + self[..].is_prefix_of(haystack) + } + + #[inline] + fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str> { + self[..].strip_prefix_of(haystack) + } + + #[inline] + fn is_suffix_of(self, haystack: &'a str) -> bool { + self[..].is_suffix_of(haystack) + } + + #[inline] + fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> { + self[..].strip_suffix_of(haystack) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialEq for String { + #[inline] + fn eq(&self, other: &String) -> bool { + PartialEq::eq(&self[..], &other[..]) + } + #[inline] + fn ne(&self, other: &String) -> bool { + PartialEq::ne(&self[..], &other[..]) + } +} + +macro_rules! impl_eq { + ($lhs:ty, $rhs: ty) => { + #[stable(feature = "rust1", since = "1.0.0")] + #[allow(unused_lifetimes)] + impl<'a, 'b> PartialEq<$rhs> for $lhs { + #[inline] + fn eq(&self, other: &$rhs) -> bool { + PartialEq::eq(&self[..], &other[..]) + } + #[inline] + fn ne(&self, other: &$rhs) -> bool { + PartialEq::ne(&self[..], &other[..]) + } + } + + #[stable(feature = "rust1", since = "1.0.0")] + #[allow(unused_lifetimes)] + impl<'a, 'b> PartialEq<$lhs> for $rhs { + #[inline] + fn eq(&self, other: &$lhs) -> bool { + PartialEq::eq(&self[..], &other[..]) + } + #[inline] + fn ne(&self, other: &$lhs) -> bool { + PartialEq::ne(&self[..], &other[..]) + } + } + }; +} + +impl_eq! { String, str } +impl_eq! { String, &'a str } +impl_eq! { Cow<'a, str>, str } +impl_eq! { Cow<'a, str>, &'b str } +impl_eq! { Cow<'a, str>, String } + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for String { + /// Creates an empty `String`. + #[inline] + fn default() -> String { + String::new() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Display for String { + #[inline] + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Display::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Debug for String { + #[inline] + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Debug::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl hash::Hash for String { + #[inline] + fn hash(&self, hasher: &mut H) { + (**self).hash(hasher) + } +} + +/// Implements the `+` operator for concatenating two strings. +/// +/// This consumes the `String` on the left-hand side and re-uses its buffer (growing it if +/// necessary). This is done to avoid allocating a new `String` and copying the entire contents on +/// every operation, which would lead to *O*(*n*^2) running time when building an *n*-byte string by +/// repeated concatenation. +/// +/// The string on the right-hand side is only borrowed; its contents are copied into the returned +/// `String`. +/// +/// # Examples +/// +/// Concatenating two `String`s takes the first by value and borrows the second: +/// +/// ``` +/// let a = String::from("hello"); +/// let b = String::from(" world"); +/// let c = a + &b; +/// // `a` is moved and can no longer be used here. +/// ``` +/// +/// If you want to keep using the first `String`, you can clone it and append to the clone instead: +/// +/// ``` +/// let a = String::from("hello"); +/// let b = String::from(" world"); +/// let c = a.clone() + &b; +/// // `a` is still valid here. +/// ``` +/// +/// Concatenating `&str` slices can be done by converting the first to a `String`: +/// +/// ``` +/// let a = "hello"; +/// let b = " world"; +/// let c = a.to_string() + b; +/// ``` +#[stable(feature = "rust1", since = "1.0.0")] +impl Add<&str> for String { + type Output = String; + + #[inline] + fn add(mut self, other: &str) -> String { + self.push_str(other); + self + } +} + +/// Implements the `+=` operator for appending to a `String`. +/// +/// This has the same behavior as the [`push_str`][String::push_str] method. +#[stable(feature = "stringaddassign", since = "1.12.0")] +impl AddAssign<&str> for String { + #[inline] + fn add_assign(&mut self, other: &str) { + self.push_str(other); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ops::Index> for String { + type Output = str; + + #[inline] + fn index(&self, index: ops::Range) -> &str { + &self[..][index] + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl ops::Index> for String { + type Output = str; + + #[inline] + fn index(&self, index: ops::RangeTo) -> &str { + &self[..][index] + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl ops::Index> for String { + type Output = str; + + #[inline] + fn index(&self, index: ops::RangeFrom) -> &str { + &self[..][index] + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl ops::Index for String { + type Output = str; + + #[inline] + fn index(&self, _index: ops::RangeFull) -> &str { + unsafe { str::from_utf8_unchecked(&self.vec) } + } +} +#[stable(feature = "inclusive_range", since = "1.26.0")] +impl ops::Index> for String { + type Output = str; + + #[inline] + fn index(&self, index: ops::RangeInclusive) -> &str { + Index::index(&**self, index) + } +} +#[stable(feature = "inclusive_range", since = "1.26.0")] +impl ops::Index> for String { + type Output = str; + + #[inline] + fn index(&self, index: ops::RangeToInclusive) -> &str { + Index::index(&**self, index) + } +} + +#[stable(feature = "derefmut_for_string", since = "1.3.0")] +impl ops::IndexMut> for String { + #[inline] + fn index_mut(&mut self, index: ops::Range) -> &mut str { + &mut self[..][index] + } +} +#[stable(feature = "derefmut_for_string", since = "1.3.0")] +impl ops::IndexMut> for String { + #[inline] + fn index_mut(&mut self, index: ops::RangeTo) -> &mut str { + &mut self[..][index] + } +} +#[stable(feature = "derefmut_for_string", since = "1.3.0")] +impl ops::IndexMut> for String { + #[inline] + fn index_mut(&mut self, index: ops::RangeFrom) -> &mut str { + &mut self[..][index] + } +} +#[stable(feature = "derefmut_for_string", since = "1.3.0")] +impl ops::IndexMut for String { + #[inline] + fn index_mut(&mut self, _index: ops::RangeFull) -> &mut str { + unsafe { str::from_utf8_unchecked_mut(&mut *self.vec) } + } +} +#[stable(feature = "inclusive_range", since = "1.26.0")] +impl ops::IndexMut> for String { + #[inline] + fn index_mut(&mut self, index: ops::RangeInclusive) -> &mut str { + IndexMut::index_mut(&mut **self, index) + } +} +#[stable(feature = "inclusive_range", since = "1.26.0")] +impl ops::IndexMut> for String { + #[inline] + fn index_mut(&mut self, index: ops::RangeToInclusive) -> &mut str { + IndexMut::index_mut(&mut **self, index) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ops::Deref for String { + type Target = str; + + #[inline] + fn deref(&self) -> &str { + unsafe { str::from_utf8_unchecked(&self.vec) } + } +} + +#[stable(feature = "derefmut_for_string", since = "1.3.0")] +impl ops::DerefMut for String { + #[inline] + fn deref_mut(&mut self) -> &mut str { + unsafe { str::from_utf8_unchecked_mut(&mut *self.vec) } + } +} + +/// A type alias for [`Infallible`]. +/// +/// This alias exists for backwards compatibility, and may be eventually deprecated. +/// +/// [`Infallible`]: core::convert::Infallible +#[stable(feature = "str_parse_error", since = "1.5.0")] +pub type ParseError = core::convert::Infallible; + +#[stable(feature = "rust1", since = "1.0.0")] +impl FromStr for String { + type Err = core::convert::Infallible; + #[inline] + fn from_str(s: &str) -> Result { + Ok(String::from(s)) + } +} + +/// A trait for converting a value to a `String`. +/// +/// This trait is automatically implemented for any type which implements the +/// [`Display`] trait. As such, `ToString` shouldn't be implemented directly: +/// [`Display`] should be implemented instead, and you get the `ToString` +/// implementation for free. +/// +/// [`Display`]: fmt::Display +#[stable(feature = "rust1", since = "1.0.0")] +pub trait ToString { + /// Converts the given value to a `String`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let i = 5; + /// let five = String::from("5"); + /// + /// assert_eq!(five, i.to_string()); + /// ``` + #[rustc_conversion_suggestion] + #[stable(feature = "rust1", since = "1.0.0")] + fn to_string(&self) -> String; +} + +/// # Panics +/// +/// In this implementation, the `to_string` method panics +/// if the `Display` implementation returns an error. +/// This indicates an incorrect `Display` implementation +/// since `fmt::Write for String` never returns an error itself. +#[stable(feature = "rust1", since = "1.0.0")] +impl ToString for T { + // A common guideline is to not inline generic functions. However, + // removing `#[inline]` from this method causes non-negligible regressions. + // See , the last attempt + // to try to remove it. + #[inline] + default fn to_string(&self) -> String { + use fmt::Write; + let mut buf = String::new(); + buf.write_fmt(format_args!("{}", self)) + .expect("a Display implementation returned an error unexpectedly"); + buf + } +} + +#[stable(feature = "char_to_string_specialization", since = "1.46.0")] +impl ToString for char { + #[inline] + fn to_string(&self) -> String { + String::from(self.encode_utf8(&mut [0; 4])) + } +} + +#[stable(feature = "str_to_string_specialization", since = "1.9.0")] +impl ToString for str { + #[inline] + fn to_string(&self) -> String { + String::from(self) + } +} + +#[stable(feature = "cow_str_to_string_specialization", since = "1.17.0")] +impl ToString for Cow<'_, str> { + #[inline] + fn to_string(&self) -> String { + self[..].to_owned() + } +} + +#[stable(feature = "string_to_string_specialization", since = "1.17.0")] +impl ToString for String { + #[inline] + fn to_string(&self) -> String { + self.to_owned() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl AsRef for String { + #[inline] + fn as_ref(&self) -> &str { + self + } +} + +#[stable(feature = "string_as_mut", since = "1.43.0")] +impl AsMut for String { + #[inline] + fn as_mut(&mut self) -> &mut str { + self + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl AsRef<[u8]> for String { + #[inline] + fn as_ref(&self) -> &[u8] { + self.as_bytes() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl From<&str> for String { + #[inline] + fn from(s: &str) -> String { + s.to_owned() + } +} + +#[stable(feature = "from_mut_str_for_string", since = "1.44.0")] +impl From<&mut str> for String { + /// Converts a `&mut str` into a `String`. + /// + /// The result is allocated on the heap. + #[inline] + fn from(s: &mut str) -> String { + s.to_owned() + } +} + +#[stable(feature = "from_ref_string", since = "1.35.0")] +impl From<&String> for String { + #[inline] + fn from(s: &String) -> String { + s.clone() + } +} + +// note: test pulls in libstd, which causes errors here +#[cfg(not(test))] +#[stable(feature = "string_from_box", since = "1.18.0")] +impl From> for String { + /// Converts the given boxed `str` slice to a `String`. + /// It is notable that the `str` slice is owned. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s1: String = String::from("hello world"); + /// let s2: Box = s1.into_boxed_str(); + /// let s3: String = String::from(s2); + /// + /// assert_eq!("hello world", s3) + /// ``` + fn from(s: Box) -> String { + s.into_string() + } +} + +#[stable(feature = "box_from_str", since = "1.20.0")] +impl From for Box { + /// Converts the given `String` to a boxed `str` slice that is owned. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s1: String = String::from("hello world"); + /// let s2: Box = Box::from(s1); + /// let s3: String = String::from(s2); + /// + /// assert_eq!("hello world", s3) + /// ``` + fn from(s: String) -> Box { + s.into_boxed_str() + } +} + +#[stable(feature = "string_from_cow_str", since = "1.14.0")] +impl<'a> From> for String { + fn from(s: Cow<'a, str>) -> String { + s.into_owned() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a> From<&'a str> for Cow<'a, str> { + #[inline] + fn from(s: &'a str) -> Cow<'a, str> { + Cow::Borrowed(s) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a> From for Cow<'a, str> { + #[inline] + fn from(s: String) -> Cow<'a, str> { + Cow::Owned(s) + } +} + +#[stable(feature = "cow_from_string_ref", since = "1.28.0")] +impl<'a> From<&'a String> for Cow<'a, str> { + #[inline] + fn from(s: &'a String) -> Cow<'a, str> { + Cow::Borrowed(s.as_str()) + } +} + +#[stable(feature = "cow_str_from_iter", since = "1.12.0")] +impl<'a> FromIterator for Cow<'a, str> { + fn from_iter>(it: I) -> Cow<'a, str> { + Cow::Owned(FromIterator::from_iter(it)) + } +} + +#[stable(feature = "cow_str_from_iter", since = "1.12.0")] +impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str> { + fn from_iter>(it: I) -> Cow<'a, str> { + Cow::Owned(FromIterator::from_iter(it)) + } +} + +#[stable(feature = "cow_str_from_iter", since = "1.12.0")] +impl<'a> FromIterator for Cow<'a, str> { + fn from_iter>(it: I) -> Cow<'a, str> { + Cow::Owned(FromIterator::from_iter(it)) + } +} + +#[stable(feature = "from_string_for_vec_u8", since = "1.14.0")] +impl From for Vec { + /// Converts the given `String` to a vector `Vec` that holds values of type `u8`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s1 = String::from("hello world"); + /// let v1 = Vec::from(s1); + /// + /// for b in v1 { + /// println!("{}", b); + /// } + /// ``` + fn from(string: String) -> Vec { + string.into_bytes() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Write for String { + #[inline] + fn write_str(&mut self, s: &str) -> fmt::Result { + self.push_str(s); + Ok(()) + } + + #[inline] + fn write_char(&mut self, c: char) -> fmt::Result { + self.push(c); + Ok(()) + } +} + +/// A draining iterator for `String`. +/// +/// This struct is created by the [`drain`] method on [`String`]. See its +/// documentation for more. +/// +/// [`drain`]: String::drain +#[stable(feature = "drain", since = "1.6.0")] +pub struct Drain<'a> { + /// Will be used as &'a mut String in the destructor + string: *mut String, + /// Start of part to remove + start: usize, + /// End of part to remove + end: usize, + /// Current remaining range to remove + iter: Chars<'a>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Drain<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Drain").field(&self.as_str()).finish() + } +} + +#[stable(feature = "drain", since = "1.6.0")] +unsafe impl Sync for Drain<'_> {} +#[stable(feature = "drain", since = "1.6.0")] +unsafe impl Send for Drain<'_> {} + +#[stable(feature = "drain", since = "1.6.0")] +impl Drop for Drain<'_> { + fn drop(&mut self) { + unsafe { + // Use Vec::drain. "Reaffirm" the bounds checks to avoid + // panic code being inserted again. + let self_vec = (*self.string).as_mut_vec(); + if self.start <= self.end && self.end <= self_vec.len() { + self_vec.drain(self.start..self.end); + } + } + } +} + +impl<'a> Drain<'a> { + /// Returns the remaining (sub)string of this iterator as a slice. + /// + /// # Examples + /// + /// ``` + /// #![feature(string_drain_as_str)] + /// let mut s = String::from("abc"); + /// let mut drain = s.drain(..); + /// assert_eq!(drain.as_str(), "abc"); + /// let _ = drain.next().unwrap(); + /// assert_eq!(drain.as_str(), "bc"); + /// ``` + #[unstable(feature = "string_drain_as_str", issue = "76905")] // Note: uncomment AsRef impls below when stabilizing. + pub fn as_str(&self) -> &str { + self.iter.as_str() + } +} + +// Uncomment when stabilizing `string_drain_as_str`. +// #[unstable(feature = "string_drain_as_str", issue = "76905")] +// impl<'a> AsRef for Drain<'a> { +// fn as_ref(&self) -> &str { +// self.as_str() +// } +// } +// +// #[unstable(feature = "string_drain_as_str", issue = "76905")] +// impl<'a> AsRef<[u8]> for Drain<'a> { +// fn as_ref(&self) -> &[u8] { +// self.as_str().as_bytes() +// } +// } + +#[stable(feature = "drain", since = "1.6.0")] +impl Iterator for Drain<'_> { + type Item = char; + + #[inline] + fn next(&mut self) -> Option { + self.iter.next() + } + + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } + + #[inline] + fn last(mut self) -> Option { + self.next_back() + } +} + +#[stable(feature = "drain", since = "1.6.0")] +impl DoubleEndedIterator for Drain<'_> { + #[inline] + fn next_back(&mut self) -> Option { + self.iter.next_back() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Drain<'_> {} + +#[stable(feature = "from_char_for_string", since = "1.46.0")] +impl From for String { + #[inline] + fn from(c: char) -> Self { + c.to_string() + } +} diff --git a/libgrust/rustc-lib/alloc/src/sync.rs b/libgrust/rustc-lib/alloc/src/sync.rs new file mode 100644 index 000000000000..5db9132f945f --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/sync.rs @@ -0,0 +1,2376 @@ +#![stable(feature = "rust1", since = "1.0.0")] + +//! Thread-safe reference-counting pointers. +//! +//! See the [`Arc`][Arc] documentation for more details. + +use core::any::Any; +use core::borrow; +use core::cmp::Ordering; +use core::convert::{From, TryFrom}; +use core::fmt; +use core::hash::{Hash, Hasher}; +use core::hint; +use core::intrinsics::abort; +use core::iter; +use core::marker::{PhantomData, Unpin, Unsize}; +use core::mem::{self, align_of_val, size_of_val}; +use core::ops::{CoerceUnsized, Deref, DispatchFromDyn, Receiver}; +use core::pin::Pin; +use core::ptr::{self, NonNull}; +use core::slice::from_raw_parts_mut; +use core::sync::atomic; +use core::sync::atomic::Ordering::{Acquire, Relaxed, Release, SeqCst}; + +use crate::alloc::{box_free, handle_alloc_error, AllocError, AllocRef, Global, Layout}; +use crate::borrow::{Cow, ToOwned}; +use crate::boxed::Box; +use crate::rc::is_dangling; +use crate::string::String; +use crate::vec::Vec; + +#[cfg(test)] +mod tests; + +/// A soft limit on the amount of references that may be made to an `Arc`. +/// +/// Going above this limit will abort your program (although not +/// necessarily) at _exactly_ `MAX_REFCOUNT + 1` references. +const MAX_REFCOUNT: usize = (isize::MAX) as usize; + +#[cfg(not(sanitize = "thread"))] +macro_rules! acquire { + ($x:expr) => { + atomic::fence(Acquire) + }; +} + +// ThreadSanitizer does not support memory fences. To avoid false positive +// reports in Arc / Weak implementation use atomic loads for synchronization +// instead. +#[cfg(sanitize = "thread")] +macro_rules! acquire { + ($x:expr) => { + $x.load(Acquire) + }; +} + +/// A thread-safe reference-counting pointer. 'Arc' stands for 'Atomically +/// Reference Counted'. +/// +/// The type `Arc` provides shared ownership of a value of type `T`, +/// allocated in the heap. Invoking [`clone`][clone] on `Arc` produces +/// a new `Arc` instance, which points to the same allocation on the heap as the +/// source `Arc`, while increasing a reference count. When the last `Arc` +/// pointer to a given allocation is destroyed, the value stored in that allocation (often +/// referred to as "inner value") is also dropped. +/// +/// Shared references in Rust disallow mutation by default, and `Arc` is no +/// exception: you cannot generally obtain a mutable reference to something +/// inside an `Arc`. If you need to mutate through an `Arc`, use +/// [`Mutex`][mutex], [`RwLock`][rwlock], or one of the [`Atomic`][atomic] +/// types. +/// +/// ## Thread Safety +/// +/// Unlike [`Rc`], `Arc` uses atomic operations for its reference +/// counting. This means that it is thread-safe. The disadvantage is that +/// atomic operations are more expensive than ordinary memory accesses. If you +/// are not sharing reference-counted allocations between threads, consider using +/// [`Rc`] for lower overhead. [`Rc`] is a safe default, because the +/// compiler will catch any attempt to send an [`Rc`] between threads. +/// However, a library might choose `Arc` in order to give library consumers +/// more flexibility. +/// +/// `Arc` will implement [`Send`] and [`Sync`] as long as the `T` implements +/// [`Send`] and [`Sync`]. Why can't you put a non-thread-safe type `T` in an +/// `Arc` to make it thread-safe? This may be a bit counter-intuitive at +/// first: after all, isn't the point of `Arc` thread safety? The key is +/// this: `Arc` makes it thread safe to have multiple ownership of the same +/// data, but it doesn't add thread safety to its data. Consider +/// `Arc<`[`RefCell`]`>`. [`RefCell`] isn't [`Sync`], and if `Arc` was always +/// [`Send`], `Arc<`[`RefCell`]`>` would be as well. But then we'd have a problem: +/// [`RefCell`] is not thread safe; it keeps track of the borrowing count using +/// non-atomic operations. +/// +/// In the end, this means that you may need to pair `Arc` with some sort of +/// [`std::sync`] type, usually [`Mutex`][mutex]. +/// +/// ## Breaking cycles with `Weak` +/// +/// The [`downgrade`][downgrade] method can be used to create a non-owning +/// [`Weak`] pointer. A [`Weak`] pointer can be [`upgrade`][upgrade]d +/// to an `Arc`, but this will return [`None`] if the value stored in the allocation has +/// already been dropped. In other words, `Weak` pointers do not keep the value +/// inside the allocation alive; however, they *do* keep the allocation +/// (the backing store for the value) alive. +/// +/// A cycle between `Arc` pointers will never be deallocated. For this reason, +/// [`Weak`] is used to break cycles. For example, a tree could have +/// strong `Arc` pointers from parent nodes to children, and [`Weak`] +/// pointers from children back to their parents. +/// +/// # Cloning references +/// +/// Creating a new reference from an existing reference-counted pointer is done using the +/// `Clone` trait implemented for [`Arc`][Arc] and [`Weak`][Weak]. +/// +/// ``` +/// use std::sync::Arc; +/// let foo = Arc::new(vec![1.0, 2.0, 3.0]); +/// // The two syntaxes below are equivalent. +/// let a = foo.clone(); +/// let b = Arc::clone(&foo); +/// // a, b, and foo are all Arcs that point to the same memory location +/// ``` +/// +/// ## `Deref` behavior +/// +/// `Arc` automatically dereferences to `T` (via the [`Deref`][deref] trait), +/// so you can call `T`'s methods on a value of type `Arc`. To avoid name +/// clashes with `T`'s methods, the methods of `Arc` itself are associated +/// functions, called using [fully qualified syntax]: +/// +/// ``` +/// use std::sync::Arc; +/// +/// let my_arc = Arc::new(()); +/// Arc::downgrade(&my_arc); +/// ``` +/// +/// `Arc`'s implementations of traits like `Clone` may also be called using +/// fully qualified syntax. Some people prefer to use fully qualified syntax, +/// while others prefer using method-call syntax. +/// +/// ``` +/// use std::sync::Arc; +/// +/// let arc = Arc::new(()); +/// // Method-call syntax +/// let arc2 = arc.clone(); +/// // Fully qualified syntax +/// let arc3 = Arc::clone(&arc); +/// ``` +/// +/// [`Weak`][Weak] does not auto-dereference to `T`, because the inner value may have +/// already been dropped. +/// +/// [`Rc`]: crate::rc::Rc +/// [clone]: Clone::clone +/// [mutex]: ../../std/sync/struct.Mutex.html +/// [rwlock]: ../../std/sync/struct.RwLock.html +/// [atomic]: core::sync::atomic +/// [`Send`]: core::marker::Send +/// [`Sync`]: core::marker::Sync +/// [deref]: core::ops::Deref +/// [downgrade]: Arc::downgrade +/// [upgrade]: Weak::upgrade +/// [`RefCell`]: core::cell::RefCell +/// [`std::sync`]: ../../std/sync/index.html +/// [`Arc::clone(&from)`]: Arc::clone +/// [fully qualified syntax]: https://doc.rust-lang.org/book/ch19-03-advanced-traits.html#fully-qualified-syntax-for-disambiguation-calling-methods-with-the-same-name +/// +/// # Examples +/// +/// Sharing some immutable data between threads: +/// +// Note that we **do not** run these tests here. The windows builders get super +// unhappy if a thread outlives the main thread and then exits at the same time +// (something deadlocks) so we just avoid this entirely by not running these +// tests. +/// ```no_run +/// use std::sync::Arc; +/// use std::thread; +/// +/// let five = Arc::new(5); +/// +/// for _ in 0..10 { +/// let five = Arc::clone(&five); +/// +/// thread::spawn(move || { +/// println!("{:?}", five); +/// }); +/// } +/// ``` +/// +/// Sharing a mutable [`AtomicUsize`]: +/// +/// [`AtomicUsize`]: core::sync::atomic::AtomicUsize +/// +/// ```no_run +/// use std::sync::Arc; +/// use std::sync::atomic::{AtomicUsize, Ordering}; +/// use std::thread; +/// +/// let val = Arc::new(AtomicUsize::new(5)); +/// +/// for _ in 0..10 { +/// let val = Arc::clone(&val); +/// +/// thread::spawn(move || { +/// let v = val.fetch_add(1, Ordering::SeqCst); +/// println!("{:?}", v); +/// }); +/// } +/// ``` +/// +/// See the [`rc` documentation][rc_examples] for more examples of reference +/// counting in general. +/// +/// [rc_examples]: crate::rc#examples +#[cfg_attr(not(test), rustc_diagnostic_item = "Arc")] +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Arc { + ptr: NonNull>, + phantom: PhantomData>, +} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Send for Arc {} +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Sync for Arc {} + +#[unstable(feature = "coerce_unsized", issue = "27732")] +impl, U: ?Sized> CoerceUnsized> for Arc {} + +#[unstable(feature = "dispatch_from_dyn", issue = "none")] +impl, U: ?Sized> DispatchFromDyn> for Arc {} + +impl Arc { + fn from_inner(ptr: NonNull>) -> Self { + Self { ptr, phantom: PhantomData } + } + + unsafe fn from_ptr(ptr: *mut ArcInner) -> Self { + unsafe { Self::from_inner(NonNull::new_unchecked(ptr)) } + } +} + +/// `Weak` is a version of [`Arc`] that holds a non-owning reference to the +/// managed allocation. The allocation is accessed by calling [`upgrade`] on the `Weak` +/// pointer, which returns an [`Option`]`<`[`Arc`]`>`. +/// +/// Since a `Weak` reference does not count towards ownership, it will not +/// prevent the value stored in the allocation from being dropped, and `Weak` itself makes no +/// guarantees about the value still being present. Thus it may return [`None`] +/// when [`upgrade`]d. Note however that a `Weak` reference *does* prevent the allocation +/// itself (the backing store) from being deallocated. +/// +/// A `Weak` pointer is useful for keeping a temporary reference to the allocation +/// managed by [`Arc`] without preventing its inner value from being dropped. It is also used to +/// prevent circular references between [`Arc`] pointers, since mutual owning references +/// would never allow either [`Arc`] to be dropped. For example, a tree could +/// have strong [`Arc`] pointers from parent nodes to children, and `Weak` +/// pointers from children back to their parents. +/// +/// The typical way to obtain a `Weak` pointer is to call [`Arc::downgrade`]. +/// +/// [`upgrade`]: Weak::upgrade +#[stable(feature = "arc_weak", since = "1.4.0")] +pub struct Weak { + // This is a `NonNull` to allow optimizing the size of this type in enums, + // but it is not necessarily a valid pointer. + // `Weak::new` sets this to `usize::MAX` so that it doesn’t need + // to allocate space on the heap. That's not a value a real pointer + // will ever have because RcBox has alignment at least 2. + // This is only possible when `T: Sized`; unsized `T` never dangle. + ptr: NonNull>, +} + +#[stable(feature = "arc_weak", since = "1.4.0")] +unsafe impl Send for Weak {} +#[stable(feature = "arc_weak", since = "1.4.0")] +unsafe impl Sync for Weak {} + +#[unstable(feature = "coerce_unsized", issue = "27732")] +impl, U: ?Sized> CoerceUnsized> for Weak {} +#[unstable(feature = "dispatch_from_dyn", issue = "none")] +impl, U: ?Sized> DispatchFromDyn> for Weak {} + +#[stable(feature = "arc_weak", since = "1.4.0")] +impl fmt::Debug for Weak { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "(Weak)") + } +} + +// This is repr(C) to future-proof against possible field-reordering, which +// would interfere with otherwise safe [into|from]_raw() of transmutable +// inner types. +#[repr(C)] +struct ArcInner { + strong: atomic::AtomicUsize, + + // the value usize::MAX acts as a sentinel for temporarily "locking" the + // ability to upgrade weak pointers or downgrade strong ones; this is used + // to avoid races in `make_mut` and `get_mut`. + weak: atomic::AtomicUsize, + + data: T, +} + +unsafe impl Send for ArcInner {} +unsafe impl Sync for ArcInner {} + +impl Arc { + /// Constructs a new `Arc`. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn new(data: T) -> Arc { + // Start the weak pointer count as 1 which is the weak pointer that's + // held by all the strong pointers (kinda), see std/rc.rs for more info + let x: Box<_> = box ArcInner { + strong: atomic::AtomicUsize::new(1), + weak: atomic::AtomicUsize::new(1), + data, + }; + Self::from_inner(Box::leak(x).into()) + } + + /// Constructs a new `Arc` using a weak reference to itself. Attempting + /// to upgrade the weak reference before this function returns will result + /// in a `None` value. However, the weak reference may be cloned freely and + /// stored for use at a later time. + /// + /// # Examples + /// ``` + /// #![feature(arc_new_cyclic)] + /// #![allow(dead_code)] + /// + /// use std::sync::{Arc, Weak}; + /// + /// struct Foo { + /// me: Weak, + /// } + /// + /// let foo = Arc::new_cyclic(|me| Foo { + /// me: me.clone(), + /// }); + /// ``` + #[inline] + #[unstable(feature = "arc_new_cyclic", issue = "75861")] + pub fn new_cyclic(data_fn: impl FnOnce(&Weak) -> T) -> Arc { + // Construct the inner in the "uninitialized" state with a single + // weak reference. + let uninit_ptr: NonNull<_> = Box::leak(box ArcInner { + strong: atomic::AtomicUsize::new(0), + weak: atomic::AtomicUsize::new(1), + data: mem::MaybeUninit::::uninit(), + }) + .into(); + let init_ptr: NonNull> = uninit_ptr.cast(); + + let weak = Weak { ptr: init_ptr }; + + // It's important we don't give up ownership of the weak pointer, or + // else the memory might be freed by the time `data_fn` returns. If + // we really wanted to pass ownership, we could create an additional + // weak pointer for ourselves, but this would result in additional + // updates to the weak reference count which might not be necessary + // otherwise. + let data = data_fn(&weak); + + // Now we can properly initialize the inner value and turn our weak + // reference into a strong reference. + unsafe { + let inner = init_ptr.as_ptr(); + ptr::write(&raw mut (*inner).data, data); + + // The above write to the data field must be visible to any threads which + // observe a non-zero strong count. Therefore we need at least "Release" ordering + // in order to synchronize with the `compare_exchange_weak` in `Weak::upgrade`. + // + // "Acquire" ordering is not required. When considering the possible behaviours + // of `data_fn` we only need to look at what it could do with a reference to a + // non-upgradeable `Weak`: + // - It can *clone* the `Weak`, increasing the weak reference count. + // - It can drop those clones, decreasing the weak reference count (but never to zero). + // + // These side effects do not impact us in any way, and no other side effects are + // possible with safe code alone. + let prev_value = (*inner).strong.fetch_add(1, Release); + debug_assert_eq!(prev_value, 0, "No prior strong references should exist"); + } + + let strong = Arc::from_inner(init_ptr); + + // Strong references should collectively own a shared weak reference, + // so don't run the destructor for our old weak reference. + mem::forget(weak); + strong + } + + /// Constructs a new `Arc` with uninitialized contents. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// #![feature(get_mut_unchecked)] + /// + /// use std::sync::Arc; + /// + /// let mut five = Arc::::new_uninit(); + /// + /// let five = unsafe { + /// // Deferred initialization: + /// Arc::get_mut_unchecked(&mut five).as_mut_ptr().write(5); + /// + /// five.assume_init() + /// }; + /// + /// assert_eq!(*five, 5) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_uninit() -> Arc> { + unsafe { + Arc::from_ptr(Arc::allocate_for_layout( + Layout::new::(), + |layout| Global.alloc(layout), + |mem| mem as *mut ArcInner>, + )) + } + } + + /// Constructs a new `Arc` with uninitialized contents, with the memory + /// being filled with `0` bytes. + /// + /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and incorrect usage + /// of this method. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// use std::sync::Arc; + /// + /// let zero = Arc::::new_zeroed(); + /// let zero = unsafe { zero.assume_init() }; + /// + /// assert_eq!(*zero, 0) + /// ``` + /// + /// [zeroed]: ../../std/mem/union.MaybeUninit.html#method.zeroed + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_zeroed() -> Arc> { + unsafe { + Arc::from_ptr(Arc::allocate_for_layout( + Layout::new::(), + |layout| Global.alloc_zeroed(layout), + |mem| mem as *mut ArcInner>, + )) + } + } + + /// Constructs a new `Pin>`. If `T` does not implement `Unpin`, then + /// `data` will be pinned in memory and unable to be moved. + #[stable(feature = "pin", since = "1.33.0")] + pub fn pin(data: T) -> Pin> { + unsafe { Pin::new_unchecked(Arc::new(data)) } + } + + /// Returns the inner value, if the `Arc` has exactly one strong reference. + /// + /// Otherwise, an [`Err`] is returned with the same `Arc` that was + /// passed in. + /// + /// This will succeed even if there are outstanding weak references. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let x = Arc::new(3); + /// assert_eq!(Arc::try_unwrap(x), Ok(3)); + /// + /// let x = Arc::new(4); + /// let _y = Arc::clone(&x); + /// assert_eq!(*Arc::try_unwrap(x).unwrap_err(), 4); + /// ``` + #[inline] + #[stable(feature = "arc_unique", since = "1.4.0")] + pub fn try_unwrap(this: Self) -> Result { + if this.inner().strong.compare_exchange(1, 0, Relaxed, Relaxed).is_err() { + return Err(this); + } + + acquire!(this.inner().strong); + + unsafe { + let elem = ptr::read(&this.ptr.as_ref().data); + + // Make a weak pointer to clean up the implicit strong-weak reference + let _weak = Weak { ptr: this.ptr }; + mem::forget(this); + + Ok(elem) + } + } +} + +impl Arc<[T]> { + /// Constructs a new atomically reference-counted slice with uninitialized contents. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// #![feature(get_mut_unchecked)] + /// + /// use std::sync::Arc; + /// + /// let mut values = Arc::<[u32]>::new_uninit_slice(3); + /// + /// let values = unsafe { + /// // Deferred initialization: + /// Arc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1); + /// Arc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2); + /// Arc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3); + /// + /// values.assume_init() + /// }; + /// + /// assert_eq!(*values, [1, 2, 3]) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_uninit_slice(len: usize) -> Arc<[mem::MaybeUninit]> { + unsafe { Arc::from_ptr(Arc::allocate_for_slice(len)) } + } + + /// Constructs a new atomically reference-counted slice with uninitialized contents, with the memory being + /// filled with `0` bytes. + /// + /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and + /// incorrect usage of this method. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// use std::sync::Arc; + /// + /// let values = Arc::<[u32]>::new_zeroed_slice(3); + /// let values = unsafe { values.assume_init() }; + /// + /// assert_eq!(*values, [0, 0, 0]) + /// ``` + /// + /// [zeroed]: ../../std/mem/union.MaybeUninit.html#method.zeroed + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_zeroed_slice(len: usize) -> Arc<[mem::MaybeUninit]> { + unsafe { + Arc::from_ptr(Arc::allocate_for_layout( + Layout::array::(len).unwrap(), + |layout| Global.alloc_zeroed(layout), + |mem| { + ptr::slice_from_raw_parts_mut(mem as *mut T, len) + as *mut ArcInner<[mem::MaybeUninit]> + }, + )) + } + } +} + +impl Arc> { + /// Converts to `Arc`. + /// + /// # Safety + /// + /// As with [`MaybeUninit::assume_init`], + /// it is up to the caller to guarantee that the inner value + /// really is in an initialized state. + /// Calling this when the content is not yet fully initialized + /// causes immediate undefined behavior. + /// + /// [`MaybeUninit::assume_init`]: ../../std/mem/union.MaybeUninit.html#method.assume_init + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// #![feature(get_mut_unchecked)] + /// + /// use std::sync::Arc; + /// + /// let mut five = Arc::::new_uninit(); + /// + /// let five = unsafe { + /// // Deferred initialization: + /// Arc::get_mut_unchecked(&mut five).as_mut_ptr().write(5); + /// + /// five.assume_init() + /// }; + /// + /// assert_eq!(*five, 5) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + #[inline] + pub unsafe fn assume_init(self) -> Arc { + Arc::from_inner(mem::ManuallyDrop::new(self).ptr.cast()) + } +} + +impl Arc<[mem::MaybeUninit]> { + /// Converts to `Arc<[T]>`. + /// + /// # Safety + /// + /// As with [`MaybeUninit::assume_init`], + /// it is up to the caller to guarantee that the inner value + /// really is in an initialized state. + /// Calling this when the content is not yet fully initialized + /// causes immediate undefined behavior. + /// + /// [`MaybeUninit::assume_init`]: ../../std/mem/union.MaybeUninit.html#method.assume_init + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// #![feature(get_mut_unchecked)] + /// + /// use std::sync::Arc; + /// + /// let mut values = Arc::<[u32]>::new_uninit_slice(3); + /// + /// let values = unsafe { + /// // Deferred initialization: + /// Arc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1); + /// Arc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2); + /// Arc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3); + /// + /// values.assume_init() + /// }; + /// + /// assert_eq!(*values, [1, 2, 3]) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + #[inline] + pub unsafe fn assume_init(self) -> Arc<[T]> { + unsafe { Arc::from_ptr(mem::ManuallyDrop::new(self).ptr.as_ptr() as _) } + } +} + +impl Arc { + /// Consumes the `Arc`, returning the wrapped pointer. + /// + /// To avoid a memory leak the pointer must be converted back to an `Arc` using + /// [`Arc::from_raw`]. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let x = Arc::new("hello".to_owned()); + /// let x_ptr = Arc::into_raw(x); + /// assert_eq!(unsafe { &*x_ptr }, "hello"); + /// ``` + #[stable(feature = "rc_raw", since = "1.17.0")] + pub fn into_raw(this: Self) -> *const T { + let ptr = Self::as_ptr(&this); + mem::forget(this); + ptr + } + + /// Provides a raw pointer to the data. + /// + /// The counts are not affected in any way and the `Arc` is not consumed. The pointer is valid for + /// as long as there are strong counts in the `Arc`. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let x = Arc::new("hello".to_owned()); + /// let y = Arc::clone(&x); + /// let x_ptr = Arc::as_ptr(&x); + /// assert_eq!(x_ptr, Arc::as_ptr(&y)); + /// assert_eq!(unsafe { &*x_ptr }, "hello"); + /// ``` + #[stable(feature = "rc_as_ptr", since = "1.45.0")] + pub fn as_ptr(this: &Self) -> *const T { + let ptr: *mut ArcInner = NonNull::as_ptr(this.ptr); + + // SAFETY: This cannot go through Deref::deref or RcBoxPtr::inner because + // this is required to retain raw/mut provenance such that e.g. `get_mut` can + // write through the pointer after the Rc is recovered through `from_raw`. + unsafe { &raw const (*ptr).data } + } + + /// Constructs an `Arc` from a raw pointer. + /// + /// The raw pointer must have been previously returned by a call to + /// [`Arc::into_raw`][into_raw] where `U` must have the same size and + /// alignment as `T`. This is trivially true if `U` is `T`. + /// Note that if `U` is not `T` but has the same size and alignment, this is + /// basically like transmuting references of different types. See + /// [`mem::transmute`][transmute] for more information on what + /// restrictions apply in this case. + /// + /// The user of `from_raw` has to make sure a specific value of `T` is only + /// dropped once. + /// + /// This function is unsafe because improper use may lead to memory unsafety, + /// even if the returned `Arc` is never accessed. + /// + /// [into_raw]: Arc::into_raw + /// [transmute]: core::mem::transmute + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let x = Arc::new("hello".to_owned()); + /// let x_ptr = Arc::into_raw(x); + /// + /// unsafe { + /// // Convert back to an `Arc` to prevent leak. + /// let x = Arc::from_raw(x_ptr); + /// assert_eq!(&*x, "hello"); + /// + /// // Further calls to `Arc::from_raw(x_ptr)` would be memory-unsafe. + /// } + /// + /// // The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling! + /// ``` + #[stable(feature = "rc_raw", since = "1.17.0")] + pub unsafe fn from_raw(ptr: *const T) -> Self { + unsafe { + let offset = data_offset(ptr); + + // Reverse the offset to find the original ArcInner. + let fake_ptr = ptr as *mut ArcInner; + let arc_ptr = set_data_ptr(fake_ptr, (ptr as *mut u8).offset(-offset)); + + Self::from_ptr(arc_ptr) + } + } + + /// Creates a new [`Weak`] pointer to this allocation. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// let weak_five = Arc::downgrade(&five); + /// ``` + #[stable(feature = "arc_weak", since = "1.4.0")] + pub fn downgrade(this: &Self) -> Weak { + // This Relaxed is OK because we're checking the value in the CAS + // below. + let mut cur = this.inner().weak.load(Relaxed); + + loop { + // check if the weak counter is currently "locked"; if so, spin. + if cur == usize::MAX { + hint::spin_loop(); + cur = this.inner().weak.load(Relaxed); + continue; + } + + // NOTE: this code currently ignores the possibility of overflow + // into usize::MAX; in general both Rc and Arc need to be adjusted + // to deal with overflow. + + // Unlike with Clone(), we need this to be an Acquire read to + // synchronize with the write coming from `is_unique`, so that the + // events prior to that write happen before this read. + match this.inner().weak.compare_exchange_weak(cur, cur + 1, Acquire, Relaxed) { + Ok(_) => { + // Make sure we do not create a dangling Weak + debug_assert!(!is_dangling(this.ptr)); + return Weak { ptr: this.ptr }; + } + Err(old) => cur = old, + } + } + } + + /// Gets the number of [`Weak`] pointers to this allocation. + /// + /// # Safety + /// + /// This method by itself is safe, but using it correctly requires extra care. + /// Another thread can change the weak count at any time, + /// including potentially between calling this method and acting on the result. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// let _weak_five = Arc::downgrade(&five); + /// + /// // This assertion is deterministic because we haven't shared + /// // the `Arc` or `Weak` between threads. + /// assert_eq!(1, Arc::weak_count(&five)); + /// ``` + #[inline] + #[stable(feature = "arc_counts", since = "1.15.0")] + pub fn weak_count(this: &Self) -> usize { + let cnt = this.inner().weak.load(SeqCst); + // If the weak count is currently locked, the value of the + // count was 0 just before taking the lock. + if cnt == usize::MAX { 0 } else { cnt - 1 } + } + + /// Gets the number of strong (`Arc`) pointers to this allocation. + /// + /// # Safety + /// + /// This method by itself is safe, but using it correctly requires extra care. + /// Another thread can change the strong count at any time, + /// including potentially between calling this method and acting on the result. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// let _also_five = Arc::clone(&five); + /// + /// // This assertion is deterministic because we haven't shared + /// // the `Arc` between threads. + /// assert_eq!(2, Arc::strong_count(&five)); + /// ``` + #[inline] + #[stable(feature = "arc_counts", since = "1.15.0")] + pub fn strong_count(this: &Self) -> usize { + this.inner().strong.load(SeqCst) + } + + /// Increments the strong reference count on the `Arc` associated with the + /// provided pointer by one. + /// + /// # Safety + /// + /// The pointer must have been obtained through `Arc::into_raw`, and the + /// associated `Arc` instance must be valid (i.e. the strong count must be at + /// least 1) for the duration of this method. + /// + /// # Examples + /// + /// ``` + /// #![feature(arc_mutate_strong_count)] + /// + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// unsafe { + /// let ptr = Arc::into_raw(five); + /// Arc::incr_strong_count(ptr); + /// + /// // This assertion is deterministic because we haven't shared + /// // the `Arc` between threads. + /// let five = Arc::from_raw(ptr); + /// assert_eq!(2, Arc::strong_count(&five)); + /// } + /// ``` + #[inline] + #[unstable(feature = "arc_mutate_strong_count", issue = "71983")] + pub unsafe fn incr_strong_count(ptr: *const T) { + // Retain Arc, but don't touch refcount by wrapping in ManuallyDrop + let arc = unsafe { mem::ManuallyDrop::new(Arc::::from_raw(ptr)) }; + // Now increase refcount, but don't drop new refcount either + let _arc_clone: mem::ManuallyDrop<_> = arc.clone(); + } + + /// Decrements the strong reference count on the `Arc` associated with the + /// provided pointer by one. + /// + /// # Safety + /// + /// The pointer must have been obtained through `Arc::into_raw`, and the + /// associated `Arc` instance must be valid (i.e. the strong count must be at + /// least 1) when invoking this method. This method can be used to release the final + /// `Arc` and backing storage, but **should not** be called after the final `Arc` has been + /// released. + /// + /// # Examples + /// + /// ``` + /// #![feature(arc_mutate_strong_count)] + /// + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// unsafe { + /// let ptr = Arc::into_raw(five); + /// Arc::incr_strong_count(ptr); + /// + /// // Those assertions are deterministic because we haven't shared + /// // the `Arc` between threads. + /// let five = Arc::from_raw(ptr); + /// assert_eq!(2, Arc::strong_count(&five)); + /// Arc::decr_strong_count(ptr); + /// assert_eq!(1, Arc::strong_count(&five)); + /// } + /// ``` + #[inline] + #[unstable(feature = "arc_mutate_strong_count", issue = "71983")] + pub unsafe fn decr_strong_count(ptr: *const T) { + unsafe { mem::drop(Arc::from_raw(ptr)) }; + } + + #[inline] + fn inner(&self) -> &ArcInner { + // This unsafety is ok because while this arc is alive we're guaranteed + // that the inner pointer is valid. Furthermore, we know that the + // `ArcInner` structure itself is `Sync` because the inner data is + // `Sync` as well, so we're ok loaning out an immutable pointer to these + // contents. + unsafe { self.ptr.as_ref() } + } + + // Non-inlined part of `drop`. + #[inline(never)] + unsafe fn drop_slow(&mut self) { + // Destroy the data at this time, even though we may not free the box + // allocation itself (there may still be weak pointers lying around). + unsafe { ptr::drop_in_place(Self::get_mut_unchecked(self)) }; + + // Drop the weak ref collectively held by all strong references + drop(Weak { ptr: self.ptr }); + } + + #[inline] + #[stable(feature = "ptr_eq", since = "1.17.0")] + /// Returns `true` if the two `Arc`s point to the same allocation + /// (in a vein similar to [`ptr::eq`]). + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// let same_five = Arc::clone(&five); + /// let other_five = Arc::new(5); + /// + /// assert!(Arc::ptr_eq(&five, &same_five)); + /// assert!(!Arc::ptr_eq(&five, &other_five)); + /// ``` + /// + /// [`ptr::eq`]: core::ptr::eq + pub fn ptr_eq(this: &Self, other: &Self) -> bool { + this.ptr.as_ptr() == other.ptr.as_ptr() + } +} + +impl Arc { + /// Allocates an `ArcInner` with sufficient space for + /// a possibly-unsized inner value where the value has the layout provided. + /// + /// The function `mem_to_arcinner` is called with the data pointer + /// and must return back a (potentially fat)-pointer for the `ArcInner`. + unsafe fn allocate_for_layout( + value_layout: Layout, + allocate: impl FnOnce(Layout) -> Result, AllocError>, + mem_to_arcinner: impl FnOnce(*mut u8) -> *mut ArcInner, + ) -> *mut ArcInner { + // Calculate layout using the given value layout. + // Previously, layout was calculated on the expression + // `&*(ptr as *const ArcInner)`, but this created a misaligned + // reference (see #54908). + let layout = Layout::new::>().extend(value_layout).unwrap().0.pad_to_align(); + + let ptr = allocate(layout).unwrap_or_else(|_| handle_alloc_error(layout)); + + // Initialize the ArcInner + let inner = mem_to_arcinner(ptr.as_non_null_ptr().as_ptr()); + debug_assert_eq!(unsafe { Layout::for_value(&*inner) }, layout); + + unsafe { + ptr::write(&mut (*inner).strong, atomic::AtomicUsize::new(1)); + ptr::write(&mut (*inner).weak, atomic::AtomicUsize::new(1)); + } + + inner + } + + /// Allocates an `ArcInner` with sufficient space for an unsized inner value. + unsafe fn allocate_for_ptr(ptr: *const T) -> *mut ArcInner { + // Allocate for the `ArcInner` using the given value. + unsafe { + Self::allocate_for_layout( + Layout::for_value(&*ptr), + |layout| Global.alloc(layout), + |mem| set_data_ptr(ptr as *mut T, mem) as *mut ArcInner, + ) + } + } + + fn from_box(v: Box) -> Arc { + unsafe { + let (box_unique, alloc) = Box::into_unique(v); + let bptr = box_unique.as_ptr(); + + let value_size = size_of_val(&*bptr); + let ptr = Self::allocate_for_ptr(bptr); + + // Copy value as bytes + ptr::copy_nonoverlapping( + bptr as *const T as *const u8, + &mut (*ptr).data as *mut _ as *mut u8, + value_size, + ); + + // Free the allocation without dropping its contents + box_free(box_unique, alloc); + + Self::from_ptr(ptr) + } + } +} + +impl Arc<[T]> { + /// Allocates an `ArcInner<[T]>` with the given length. + unsafe fn allocate_for_slice(len: usize) -> *mut ArcInner<[T]> { + unsafe { + Self::allocate_for_layout( + Layout::array::(len).unwrap(), + |layout| Global.alloc(layout), + |mem| ptr::slice_from_raw_parts_mut(mem as *mut T, len) as *mut ArcInner<[T]>, + ) + } + } +} + +/// Sets the data pointer of a `?Sized` raw pointer. +/// +/// For a slice/trait object, this sets the `data` field and leaves the rest +/// unchanged. For a sized raw pointer, this simply sets the pointer. +unsafe fn set_data_ptr(mut ptr: *mut T, data: *mut U) -> *mut T { + unsafe { + ptr::write(&mut ptr as *mut _ as *mut *mut u8, data as *mut u8); + } + ptr +} + +impl Arc<[T]> { + /// Copy elements from slice into newly allocated Arc<\[T\]> + /// + /// Unsafe because the caller must either take ownership or bind `T: Copy`. + unsafe fn copy_from_slice(v: &[T]) -> Arc<[T]> { + unsafe { + let ptr = Self::allocate_for_slice(v.len()); + + ptr::copy_nonoverlapping(v.as_ptr(), &mut (*ptr).data as *mut [T] as *mut T, v.len()); + + Self::from_ptr(ptr) + } + } + + /// Constructs an `Arc<[T]>` from an iterator known to be of a certain size. + /// + /// Behavior is undefined should the size be wrong. + unsafe fn from_iter_exact(iter: impl iter::Iterator, len: usize) -> Arc<[T]> { + // Panic guard while cloning T elements. + // In the event of a panic, elements that have been written + // into the new ArcInner will be dropped, then the memory freed. + struct Guard { + mem: NonNull, + elems: *mut T, + layout: Layout, + n_elems: usize, + } + + impl Drop for Guard { + fn drop(&mut self) { + unsafe { + let slice = from_raw_parts_mut(self.elems, self.n_elems); + ptr::drop_in_place(slice); + + Global.dealloc(self.mem, self.layout); + } + } + } + + unsafe { + let ptr = Self::allocate_for_slice(len); + + let mem = ptr as *mut _ as *mut u8; + let layout = Layout::for_value(&*ptr); + + // Pointer to first element + let elems = &mut (*ptr).data as *mut [T] as *mut T; + + let mut guard = Guard { mem: NonNull::new_unchecked(mem), elems, layout, n_elems: 0 }; + + for (i, item) in iter.enumerate() { + ptr::write(elems.add(i), item); + guard.n_elems += 1; + } + + // All clear. Forget the guard so it doesn't free the new ArcInner. + mem::forget(guard); + + Self::from_ptr(ptr) + } + } +} + +/// Specialization trait used for `From<&[T]>`. +trait ArcFromSlice { + fn from_slice(slice: &[T]) -> Self; +} + +impl ArcFromSlice for Arc<[T]> { + #[inline] + default fn from_slice(v: &[T]) -> Self { + unsafe { Self::from_iter_exact(v.iter().cloned(), v.len()) } + } +} + +impl ArcFromSlice for Arc<[T]> { + #[inline] + fn from_slice(v: &[T]) -> Self { + unsafe { Arc::copy_from_slice(v) } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Arc { + /// Makes a clone of the `Arc` pointer. + /// + /// This creates another pointer to the same allocation, increasing the + /// strong reference count. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// let _ = Arc::clone(&five); + /// ``` + #[inline] + fn clone(&self) -> Arc { + // Using a relaxed ordering is alright here, as knowledge of the + // original reference prevents other threads from erroneously deleting + // the object. + // + // As explained in the [Boost documentation][1], Increasing the + // reference counter can always be done with memory_order_relaxed: New + // references to an object can only be formed from an existing + // reference, and passing an existing reference from one thread to + // another must already provide any required synchronization. + // + // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html) + let old_size = self.inner().strong.fetch_add(1, Relaxed); + + // However we need to guard against massive refcounts in case someone + // is `mem::forget`ing Arcs. If we don't do this the count can overflow + // and users will use-after free. We racily saturate to `isize::MAX` on + // the assumption that there aren't ~2 billion threads incrementing + // the reference count at once. This branch will never be taken in + // any realistic program. + // + // We abort because such a program is incredibly degenerate, and we + // don't care to support it. + if old_size > MAX_REFCOUNT { + abort(); + } + + Self::from_inner(self.ptr) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Deref for Arc { + type Target = T; + + #[inline] + fn deref(&self) -> &T { + &self.inner().data + } +} + +#[unstable(feature = "receiver_trait", issue = "none")] +impl Receiver for Arc {} + +impl Arc { + /// Makes a mutable reference into the given `Arc`. + /// + /// If there are other `Arc` or [`Weak`] pointers to the same allocation, + /// then `make_mut` will create a new allocation and invoke [`clone`][clone] on the inner value + /// to ensure unique ownership. This is also referred to as clone-on-write. + /// + /// Note that this differs from the behavior of [`Rc::make_mut`] which disassociates + /// any remaining `Weak` pointers. + /// + /// See also [`get_mut`][get_mut], which will fail rather than cloning. + /// + /// [clone]: Clone::clone + /// [get_mut]: Arc::get_mut + /// [`Rc::make_mut`]: super::rc::Rc::make_mut + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let mut data = Arc::new(5); + /// + /// *Arc::make_mut(&mut data) += 1; // Won't clone anything + /// let mut other_data = Arc::clone(&data); // Won't clone inner data + /// *Arc::make_mut(&mut data) += 1; // Clones inner data + /// *Arc::make_mut(&mut data) += 1; // Won't clone anything + /// *Arc::make_mut(&mut other_data) *= 2; // Won't clone anything + /// + /// // Now `data` and `other_data` point to different allocations. + /// assert_eq!(*data, 8); + /// assert_eq!(*other_data, 12); + /// ``` + #[inline] + #[stable(feature = "arc_unique", since = "1.4.0")] + pub fn make_mut(this: &mut Self) -> &mut T { + // Note that we hold both a strong reference and a weak reference. + // Thus, releasing our strong reference only will not, by itself, cause + // the memory to be deallocated. + // + // Use Acquire to ensure that we see any writes to `weak` that happen + // before release writes (i.e., decrements) to `strong`. Since we hold a + // weak count, there's no chance the ArcInner itself could be + // deallocated. + if this.inner().strong.compare_exchange(1, 0, Acquire, Relaxed).is_err() { + // Another strong pointer exists; clone + *this = Arc::new((**this).clone()); + } else if this.inner().weak.load(Relaxed) != 1 { + // Relaxed suffices in the above because this is fundamentally an + // optimization: we are always racing with weak pointers being + // dropped. Worst case, we end up allocated a new Arc unnecessarily. + + // We removed the last strong ref, but there are additional weak + // refs remaining. We'll move the contents to a new Arc, and + // invalidate the other weak refs. + + // Note that it is not possible for the read of `weak` to yield + // usize::MAX (i.e., locked), since the weak count can only be + // locked by a thread with a strong reference. + + // Materialize our own implicit weak pointer, so that it can clean + // up the ArcInner as needed. + let weak = Weak { ptr: this.ptr }; + + // mark the data itself as already deallocated + unsafe { + // there is no data race in the implicit write caused by `read` + // here (due to zeroing) because data is no longer accessed by + // other threads (due to there being no more strong refs at this + // point). + let mut swap = Arc::new(ptr::read(&weak.ptr.as_ref().data)); + mem::swap(this, &mut swap); + mem::forget(swap); + } + } else { + // We were the sole reference of either kind; bump back up the + // strong ref count. + this.inner().strong.store(1, Release); + } + + // As with `get_mut()`, the unsafety is ok because our reference was + // either unique to begin with, or became one upon cloning the contents. + unsafe { Self::get_mut_unchecked(this) } + } +} + +impl Arc { + /// Returns a mutable reference into the given `Arc`, if there are + /// no other `Arc` or [`Weak`] pointers to the same allocation. + /// + /// Returns [`None`] otherwise, because it is not safe to + /// mutate a shared value. + /// + /// See also [`make_mut`][make_mut], which will [`clone`][clone] + /// the inner value when there are other pointers. + /// + /// [make_mut]: Arc::make_mut + /// [clone]: Clone::clone + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let mut x = Arc::new(3); + /// *Arc::get_mut(&mut x).unwrap() = 4; + /// assert_eq!(*x, 4); + /// + /// let _y = Arc::clone(&x); + /// assert!(Arc::get_mut(&mut x).is_none()); + /// ``` + #[inline] + #[stable(feature = "arc_unique", since = "1.4.0")] + pub fn get_mut(this: &mut Self) -> Option<&mut T> { + if this.is_unique() { + // This unsafety is ok because we're guaranteed that the pointer + // returned is the *only* pointer that will ever be returned to T. Our + // reference count is guaranteed to be 1 at this point, and we required + // the Arc itself to be `mut`, so we're returning the only possible + // reference to the inner data. + unsafe { Some(Arc::get_mut_unchecked(this)) } + } else { + None + } + } + + /// Returns a mutable reference into the given `Arc`, + /// without any check. + /// + /// See also [`get_mut`], which is safe and does appropriate checks. + /// + /// [`get_mut`]: Arc::get_mut + /// + /// # Safety + /// + /// Any other `Arc` or [`Weak`] pointers to the same allocation must not be dereferenced + /// for the duration of the returned borrow. + /// This is trivially the case if no such pointers exist, + /// for example immediately after `Arc::new`. + /// + /// # Examples + /// + /// ``` + /// #![feature(get_mut_unchecked)] + /// + /// use std::sync::Arc; + /// + /// let mut x = Arc::new(String::new()); + /// unsafe { + /// Arc::get_mut_unchecked(&mut x).push_str("foo") + /// } + /// assert_eq!(*x, "foo"); + /// ``` + #[inline] + #[unstable(feature = "get_mut_unchecked", issue = "63292")] + pub unsafe fn get_mut_unchecked(this: &mut Self) -> &mut T { + // We are careful to *not* create a reference covering the "count" fields, as + // this would alias with concurrent access to the reference counts (e.g. by `Weak`). + unsafe { &mut (*this.ptr.as_ptr()).data } + } + + /// Determine whether this is the unique reference (including weak refs) to + /// the underlying data. + /// + /// Note that this requires locking the weak ref count. + fn is_unique(&mut self) -> bool { + // lock the weak pointer count if we appear to be the sole weak pointer + // holder. + // + // The acquire label here ensures a happens-before relationship with any + // writes to `strong` (in particular in `Weak::upgrade`) prior to decrements + // of the `weak` count (via `Weak::drop`, which uses release). If the upgraded + // weak ref was never dropped, the CAS here will fail so we do not care to synchronize. + if self.inner().weak.compare_exchange(1, usize::MAX, Acquire, Relaxed).is_ok() { + // This needs to be an `Acquire` to synchronize with the decrement of the `strong` + // counter in `drop` -- the only access that happens when any but the last reference + // is being dropped. + let unique = self.inner().strong.load(Acquire) == 1; + + // The release write here synchronizes with a read in `downgrade`, + // effectively preventing the above read of `strong` from happening + // after the write. + self.inner().weak.store(1, Release); // release the lock + unique + } else { + false + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl<#[may_dangle] T: ?Sized> Drop for Arc { + /// Drops the `Arc`. + /// + /// This will decrement the strong reference count. If the strong reference + /// count reaches zero then the only other references (if any) are + /// [`Weak`], so we `drop` the inner value. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// struct Foo; + /// + /// impl Drop for Foo { + /// fn drop(&mut self) { + /// println!("dropped!"); + /// } + /// } + /// + /// let foo = Arc::new(Foo); + /// let foo2 = Arc::clone(&foo); + /// + /// drop(foo); // Doesn't print anything + /// drop(foo2); // Prints "dropped!" + /// ``` + #[inline] + fn drop(&mut self) { + // Because `fetch_sub` is already atomic, we do not need to synchronize + // with other threads unless we are going to delete the object. This + // same logic applies to the below `fetch_sub` to the `weak` count. + if self.inner().strong.fetch_sub(1, Release) != 1 { + return; + } + + // This fence is needed to prevent reordering of use of the data and + // deletion of the data. Because it is marked `Release`, the decreasing + // of the reference count synchronizes with this `Acquire` fence. This + // means that use of the data happens before decreasing the reference + // count, which happens before this fence, which happens before the + // deletion of the data. + // + // As explained in the [Boost documentation][1], + // + // > It is important to enforce any possible access to the object in one + // > thread (through an existing reference) to *happen before* deleting + // > the object in a different thread. This is achieved by a "release" + // > operation after dropping a reference (any access to the object + // > through this reference must obviously happened before), and an + // > "acquire" operation before deleting the object. + // + // In particular, while the contents of an Arc are usually immutable, it's + // possible to have interior writes to something like a Mutex. Since a + // Mutex is not acquired when it is deleted, we can't rely on its + // synchronization logic to make writes in thread A visible to a destructor + // running in thread B. + // + // Also note that the Acquire fence here could probably be replaced with an + // Acquire load, which could improve performance in highly-contended + // situations. See [2]. + // + // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html) + // [2]: (https://github.com/rust-lang/rust/pull/41714) + acquire!(self.inner().strong); + + unsafe { + self.drop_slow(); + } + } +} + +impl Arc { + #[inline] + #[stable(feature = "rc_downcast", since = "1.29.0")] + /// Attempt to downcast the `Arc` to a concrete type. + /// + /// # Examples + /// + /// ``` + /// use std::any::Any; + /// use std::sync::Arc; + /// + /// fn print_if_string(value: Arc) { + /// if let Ok(string) = value.downcast::() { + /// println!("String ({}): {}", string.len(), string); + /// } + /// } + /// + /// let my_string = "Hello World".to_string(); + /// print_if_string(Arc::new(my_string)); + /// print_if_string(Arc::new(0i8)); + /// ``` + pub fn downcast(self) -> Result, Self> + where + T: Any + Send + Sync + 'static, + { + if (*self).is::() { + let ptr = self.ptr.cast::>(); + mem::forget(self); + Ok(Arc::from_inner(ptr)) + } else { + Err(self) + } + } +} + +impl Weak { + /// Constructs a new `Weak`, without allocating any memory. + /// Calling [`upgrade`] on the return value always gives [`None`]. + /// + /// [`upgrade`]: Weak::upgrade + /// + /// # Examples + /// + /// ``` + /// use std::sync::Weak; + /// + /// let empty: Weak = Weak::new(); + /// assert!(empty.upgrade().is_none()); + /// ``` + #[stable(feature = "downgraded_weak", since = "1.10.0")] + pub fn new() -> Weak { + Weak { ptr: NonNull::new(usize::MAX as *mut ArcInner).expect("MAX is not 0") } + } +} + +/// Helper type to allow accessing the reference counts without +/// making any assertions about the data field. +struct WeakInner<'a> { + weak: &'a atomic::AtomicUsize, + strong: &'a atomic::AtomicUsize, +} + +impl Weak { + /// Returns a raw pointer to the object `T` pointed to by this `Weak`. + /// + /// The pointer is valid only if there are some strong references. The pointer may be dangling, + /// unaligned or even [`null`] otherwise. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// use std::ptr; + /// + /// let strong = Arc::new("hello".to_owned()); + /// let weak = Arc::downgrade(&strong); + /// // Both point to the same object + /// assert!(ptr::eq(&*strong, weak.as_ptr())); + /// // The strong here keeps it alive, so we can still access the object. + /// assert_eq!("hello", unsafe { &*weak.as_ptr() }); + /// + /// drop(strong); + /// // But not any more. We can do weak.as_ptr(), but accessing the pointer would lead to + /// // undefined behaviour. + /// // assert_eq!("hello", unsafe { &*weak.as_ptr() }); + /// ``` + /// + /// [`null`]: core::ptr::null + #[stable(feature = "weak_into_raw", since = "1.45.0")] + pub fn as_ptr(&self) -> *const T { + let ptr: *mut ArcInner = NonNull::as_ptr(self.ptr); + + // SAFETY: we must offset the pointer manually, and said pointer may be + // a dangling weak (usize::MAX) if T is sized. data_offset is safe to call, + // because we know that a pointer to unsized T was derived from a real + // unsized T, as dangling weaks are only created for sized T. wrapping_offset + // is used so that we can use the same code path for the non-dangling + // unsized case and the potentially dangling sized case. + unsafe { + let offset = data_offset(ptr as *mut T); + set_data_ptr(ptr as *mut T, (ptr as *mut u8).wrapping_offset(offset)) + } + } + + /// Consumes the `Weak` and turns it into a raw pointer. + /// + /// This converts the weak pointer into a raw pointer, while still preserving the ownership of + /// one weak reference (the weak count is not modified by this operation). It can be turned + /// back into the `Weak` with [`from_raw`]. + /// + /// The same restrictions of accessing the target of the pointer as with + /// [`as_ptr`] apply. + /// + /// # Examples + /// + /// ``` + /// use std::sync::{Arc, Weak}; + /// + /// let strong = Arc::new("hello".to_owned()); + /// let weak = Arc::downgrade(&strong); + /// let raw = weak.into_raw(); + /// + /// assert_eq!(1, Arc::weak_count(&strong)); + /// assert_eq!("hello", unsafe { &*raw }); + /// + /// drop(unsafe { Weak::from_raw(raw) }); + /// assert_eq!(0, Arc::weak_count(&strong)); + /// ``` + /// + /// [`from_raw`]: Weak::from_raw + /// [`as_ptr`]: Weak::as_ptr + #[stable(feature = "weak_into_raw", since = "1.45.0")] + pub fn into_raw(self) -> *const T { + let result = self.as_ptr(); + mem::forget(self); + result + } + + /// Converts a raw pointer previously created by [`into_raw`] back into `Weak`. + /// + /// This can be used to safely get a strong reference (by calling [`upgrade`] + /// later) or to deallocate the weak count by dropping the `Weak`. + /// + /// It takes ownership of one weak reference (with the exception of pointers created by [`new`], + /// as these don't own anything; the method still works on them). + /// + /// # Safety + /// + /// The pointer must have originated from the [`into_raw`] and must still own its potential + /// weak reference. + /// + /// It is allowed for the strong count to be 0 at the time of calling this. Nevertheless, this + /// takes ownership of one weak reference currently represented as a raw pointer (the weak + /// count is not modified by this operation) and therefore it must be paired with a previous + /// call to [`into_raw`]. + /// # Examples + /// + /// ``` + /// use std::sync::{Arc, Weak}; + /// + /// let strong = Arc::new("hello".to_owned()); + /// + /// let raw_1 = Arc::downgrade(&strong).into_raw(); + /// let raw_2 = Arc::downgrade(&strong).into_raw(); + /// + /// assert_eq!(2, Arc::weak_count(&strong)); + /// + /// assert_eq!("hello", &*unsafe { Weak::from_raw(raw_1) }.upgrade().unwrap()); + /// assert_eq!(1, Arc::weak_count(&strong)); + /// + /// drop(strong); + /// + /// // Decrement the last weak count. + /// assert!(unsafe { Weak::from_raw(raw_2) }.upgrade().is_none()); + /// ``` + /// + /// [`new`]: Weak::new + /// [`into_raw`]: Weak::into_raw + /// [`upgrade`]: Weak::upgrade + /// [`forget`]: std::mem::forget + #[stable(feature = "weak_into_raw", since = "1.45.0")] + pub unsafe fn from_raw(ptr: *const T) -> Self { + // SAFETY: data_offset is safe to call, because this pointer originates from a Weak. + // See Weak::as_ptr for context on how the input pointer is derived. + let offset = unsafe { data_offset(ptr) }; + + // Reverse the offset to find the original ArcInner. + // SAFETY: we use wrapping_offset here because the pointer may be dangling (but only if T: Sized) + let ptr = unsafe { + set_data_ptr(ptr as *mut ArcInner, (ptr as *mut u8).wrapping_offset(-offset)) + }; + + // SAFETY: we now have recovered the original Weak pointer, so can create the Weak. + unsafe { Weak { ptr: NonNull::new_unchecked(ptr) } } + } +} + +impl Weak { + /// Attempts to upgrade the `Weak` pointer to an [`Arc`], delaying + /// dropping of the inner value if successful. + /// + /// Returns [`None`] if the inner value has since been dropped. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// let weak_five = Arc::downgrade(&five); + /// + /// let strong_five: Option> = weak_five.upgrade(); + /// assert!(strong_five.is_some()); + /// + /// // Destroy all strong pointers. + /// drop(strong_five); + /// drop(five); + /// + /// assert!(weak_five.upgrade().is_none()); + /// ``` + #[stable(feature = "arc_weak", since = "1.4.0")] + pub fn upgrade(&self) -> Option> { + // We use a CAS loop to increment the strong count instead of a + // fetch_add as this function should never take the reference count + // from zero to one. + let inner = self.inner()?; + + // Relaxed load because any write of 0 that we can observe + // leaves the field in a permanently zero state (so a + // "stale" read of 0 is fine), and any other value is + // confirmed via the CAS below. + let mut n = inner.strong.load(Relaxed); + + loop { + if n == 0 { + return None; + } + + // See comments in `Arc::clone` for why we do this (for `mem::forget`). + if n > MAX_REFCOUNT { + abort(); + } + + // Relaxed is fine for the failure case because we don't have any expectations about the new state. + // Acquire is necessary for the success case to synchronise with `Arc::new_cyclic`, when the inner + // value can be initialized after `Weak` references have already been created. In that case, we + // expect to observe the fully initialized value. + match inner.strong.compare_exchange_weak(n, n + 1, Acquire, Relaxed) { + Ok(_) => return Some(Arc::from_inner(self.ptr)), // null checked above + Err(old) => n = old, + } + } + } + + /// Gets the number of strong (`Arc`) pointers pointing to this allocation. + /// + /// If `self` was created using [`Weak::new`], this will return 0. + #[stable(feature = "weak_counts", since = "1.41.0")] + pub fn strong_count(&self) -> usize { + if let Some(inner) = self.inner() { inner.strong.load(SeqCst) } else { 0 } + } + + /// Gets an approximation of the number of `Weak` pointers pointing to this + /// allocation. + /// + /// If `self` was created using [`Weak::new`], or if there are no remaining + /// strong pointers, this will return 0. + /// + /// # Accuracy + /// + /// Due to implementation details, the returned value can be off by 1 in + /// either direction when other threads are manipulating any `Arc`s or + /// `Weak`s pointing to the same allocation. + #[stable(feature = "weak_counts", since = "1.41.0")] + pub fn weak_count(&self) -> usize { + self.inner() + .map(|inner| { + let weak = inner.weak.load(SeqCst); + let strong = inner.strong.load(SeqCst); + if strong == 0 { + 0 + } else { + // Since we observed that there was at least one strong pointer + // after reading the weak count, we know that the implicit weak + // reference (present whenever any strong references are alive) + // was still around when we observed the weak count, and can + // therefore safely subtract it. + weak - 1 + } + }) + .unwrap_or(0) + } + + /// Returns `None` when the pointer is dangling and there is no allocated `ArcInner`, + /// (i.e., when this `Weak` was created by `Weak::new`). + #[inline] + fn inner(&self) -> Option> { + if is_dangling(self.ptr) { + None + } else { + // We are careful to *not* create a reference covering the "data" field, as + // the field may be mutated concurrently (for example, if the last `Arc` + // is dropped, the data field will be dropped in-place). + Some(unsafe { + let ptr = self.ptr.as_ptr(); + WeakInner { strong: &(*ptr).strong, weak: &(*ptr).weak } + }) + } + } + + /// Returns `true` if the two `Weak`s point to the same allocation (similar to + /// [`ptr::eq`]), or if both don't point to any allocation + /// (because they were created with `Weak::new()`). + /// + /// # Notes + /// + /// Since this compares pointers it means that `Weak::new()` will equal each + /// other, even though they don't point to any allocation. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let first_rc = Arc::new(5); + /// let first = Arc::downgrade(&first_rc); + /// let second = Arc::downgrade(&first_rc); + /// + /// assert!(first.ptr_eq(&second)); + /// + /// let third_rc = Arc::new(5); + /// let third = Arc::downgrade(&third_rc); + /// + /// assert!(!first.ptr_eq(&third)); + /// ``` + /// + /// Comparing `Weak::new`. + /// + /// ``` + /// use std::sync::{Arc, Weak}; + /// + /// let first = Weak::new(); + /// let second = Weak::new(); + /// assert!(first.ptr_eq(&second)); + /// + /// let third_rc = Arc::new(()); + /// let third = Arc::downgrade(&third_rc); + /// assert!(!first.ptr_eq(&third)); + /// ``` + /// + /// [`ptr::eq`]: core::ptr::eq + #[inline] + #[stable(feature = "weak_ptr_eq", since = "1.39.0")] + pub fn ptr_eq(&self, other: &Self) -> bool { + self.ptr.as_ptr() == other.ptr.as_ptr() + } +} + +#[stable(feature = "arc_weak", since = "1.4.0")] +impl Clone for Weak { + /// Makes a clone of the `Weak` pointer that points to the same allocation. + /// + /// # Examples + /// + /// ``` + /// use std::sync::{Arc, Weak}; + /// + /// let weak_five = Arc::downgrade(&Arc::new(5)); + /// + /// let _ = Weak::clone(&weak_five); + /// ``` + #[inline] + fn clone(&self) -> Weak { + let inner = if let Some(inner) = self.inner() { + inner + } else { + return Weak { ptr: self.ptr }; + }; + // See comments in Arc::clone() for why this is relaxed. This can use a + // fetch_add (ignoring the lock) because the weak count is only locked + // where are *no other* weak pointers in existence. (So we can't be + // running this code in that case). + let old_size = inner.weak.fetch_add(1, Relaxed); + + // See comments in Arc::clone() for why we do this (for mem::forget). + if old_size > MAX_REFCOUNT { + abort(); + } + + Weak { ptr: self.ptr } + } +} + +#[stable(feature = "downgraded_weak", since = "1.10.0")] +impl Default for Weak { + /// Constructs a new `Weak`, without allocating memory. + /// Calling [`upgrade`] on the return value always + /// gives [`None`]. + /// + /// [`upgrade`]: Weak::upgrade + /// + /// # Examples + /// + /// ``` + /// use std::sync::Weak; + /// + /// let empty: Weak = Default::default(); + /// assert!(empty.upgrade().is_none()); + /// ``` + fn default() -> Weak { + Weak::new() + } +} + +#[stable(feature = "arc_weak", since = "1.4.0")] +impl Drop for Weak { + /// Drops the `Weak` pointer. + /// + /// # Examples + /// + /// ``` + /// use std::sync::{Arc, Weak}; + /// + /// struct Foo; + /// + /// impl Drop for Foo { + /// fn drop(&mut self) { + /// println!("dropped!"); + /// } + /// } + /// + /// let foo = Arc::new(Foo); + /// let weak_foo = Arc::downgrade(&foo); + /// let other_weak_foo = Weak::clone(&weak_foo); + /// + /// drop(weak_foo); // Doesn't print anything + /// drop(foo); // Prints "dropped!" + /// + /// assert!(other_weak_foo.upgrade().is_none()); + /// ``` + fn drop(&mut self) { + // If we find out that we were the last weak pointer, then its time to + // deallocate the data entirely. See the discussion in Arc::drop() about + // the memory orderings + // + // It's not necessary to check for the locked state here, because the + // weak count can only be locked if there was precisely one weak ref, + // meaning that drop could only subsequently run ON that remaining weak + // ref, which can only happen after the lock is released. + let inner = if let Some(inner) = self.inner() { inner } else { return }; + + if inner.weak.fetch_sub(1, Release) == 1 { + acquire!(inner.weak); + unsafe { Global.dealloc(self.ptr.cast(), Layout::for_value(self.ptr.as_ref())) } + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +trait ArcEqIdent { + fn eq(&self, other: &Arc) -> bool; + fn ne(&self, other: &Arc) -> bool; +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ArcEqIdent for Arc { + #[inline] + default fn eq(&self, other: &Arc) -> bool { + **self == **other + } + #[inline] + default fn ne(&self, other: &Arc) -> bool { + **self != **other + } +} + +/// We're doing this specialization here, and not as a more general optimization on `&T`, because it +/// would otherwise add a cost to all equality checks on refs. We assume that `Arc`s are used to +/// store large values, that are slow to clone, but also heavy to check for equality, causing this +/// cost to pay off more easily. It's also more likely to have two `Arc` clones, that point to +/// the same value, than two `&T`s. +/// +/// We can only do this when `T: Eq` as a `PartialEq` might be deliberately irreflexive. +#[stable(feature = "rust1", since = "1.0.0")] +impl ArcEqIdent for Arc { + #[inline] + fn eq(&self, other: &Arc) -> bool { + Arc::ptr_eq(self, other) || **self == **other + } + + #[inline] + fn ne(&self, other: &Arc) -> bool { + !Arc::ptr_eq(self, other) && **self != **other + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialEq for Arc { + /// Equality for two `Arc`s. + /// + /// Two `Arc`s are equal if their inner values are equal, even if they are + /// stored in different allocation. + /// + /// If `T` also implements `Eq` (implying reflexivity of equality), + /// two `Arc`s that point to the same allocation are always equal. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// assert!(five == Arc::new(5)); + /// ``` + #[inline] + fn eq(&self, other: &Arc) -> bool { + ArcEqIdent::eq(self, other) + } + + /// Inequality for two `Arc`s. + /// + /// Two `Arc`s are unequal if their inner values are unequal. + /// + /// If `T` also implements `Eq` (implying reflexivity of equality), + /// two `Arc`s that point to the same value are never unequal. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// assert!(five != Arc::new(6)); + /// ``` + #[inline] + fn ne(&self, other: &Arc) -> bool { + ArcEqIdent::ne(self, other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialOrd for Arc { + /// Partial comparison for two `Arc`s. + /// + /// The two are compared by calling `partial_cmp()` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// use std::cmp::Ordering; + /// + /// let five = Arc::new(5); + /// + /// assert_eq!(Some(Ordering::Less), five.partial_cmp(&Arc::new(6))); + /// ``` + fn partial_cmp(&self, other: &Arc) -> Option { + (**self).partial_cmp(&**other) + } + + /// Less-than comparison for two `Arc`s. + /// + /// The two are compared by calling `<` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// assert!(five < Arc::new(6)); + /// ``` + fn lt(&self, other: &Arc) -> bool { + *(*self) < *(*other) + } + + /// 'Less than or equal to' comparison for two `Arc`s. + /// + /// The two are compared by calling `<=` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// assert!(five <= Arc::new(5)); + /// ``` + fn le(&self, other: &Arc) -> bool { + *(*self) <= *(*other) + } + + /// Greater-than comparison for two `Arc`s. + /// + /// The two are compared by calling `>` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// assert!(five > Arc::new(4)); + /// ``` + fn gt(&self, other: &Arc) -> bool { + *(*self) > *(*other) + } + + /// 'Greater than or equal to' comparison for two `Arc`s. + /// + /// The two are compared by calling `>=` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// assert!(five >= Arc::new(5)); + /// ``` + fn ge(&self, other: &Arc) -> bool { + *(*self) >= *(*other) + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl Ord for Arc { + /// Comparison for two `Arc`s. + /// + /// The two are compared by calling `cmp()` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// use std::cmp::Ordering; + /// + /// let five = Arc::new(5); + /// + /// assert_eq!(Ordering::Less, five.cmp(&Arc::new(6))); + /// ``` + fn cmp(&self, other: &Arc) -> Ordering { + (**self).cmp(&**other) + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl Eq for Arc {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Display for Arc { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Display::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Debug for Arc { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Debug::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Pointer for Arc { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Pointer::fmt(&(&**self as *const T), f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for Arc { + /// Creates a new `Arc`, with the `Default` value for `T`. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let x: Arc = Default::default(); + /// assert_eq!(*x, 0); + /// ``` + fn default() -> Arc { + Arc::new(Default::default()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Hash for Arc { + fn hash(&self, state: &mut H) { + (**self).hash(state) + } +} + +#[stable(feature = "from_for_ptrs", since = "1.6.0")] +impl From for Arc { + fn from(t: T) -> Self { + Arc::new(t) + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From<&[T]> for Arc<[T]> { + #[inline] + fn from(v: &[T]) -> Arc<[T]> { + >::from_slice(v) + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From<&str> for Arc { + #[inline] + fn from(v: &str) -> Arc { + let arc = Arc::<[u8]>::from(v.as_bytes()); + unsafe { Arc::from_raw(Arc::into_raw(arc) as *const str) } + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From for Arc { + #[inline] + fn from(v: String) -> Arc { + Arc::from(&v[..]) + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From> for Arc { + #[inline] + fn from(v: Box) -> Arc { + Arc::from_box(v) + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From> for Arc<[T]> { + #[inline] + fn from(mut v: Vec) -> Arc<[T]> { + unsafe { + let arc = Arc::copy_from_slice(&v); + + // Allow the Vec to free its memory, but not destroy its contents + v.set_len(0); + + arc + } + } +} + +#[stable(feature = "shared_from_cow", since = "1.45.0")] +impl<'a, B> From> for Arc +where + B: ToOwned + ?Sized, + Arc: From<&'a B> + From, +{ + #[inline] + fn from(cow: Cow<'a, B>) -> Arc { + match cow { + Cow::Borrowed(s) => Arc::from(s), + Cow::Owned(s) => Arc::from(s), + } + } +} + +#[stable(feature = "boxed_slice_try_from", since = "1.43.0")] +impl TryFrom> for Arc<[T; N]> { + type Error = Arc<[T]>; + + fn try_from(boxed_slice: Arc<[T]>) -> Result { + if boxed_slice.len() == N { + Ok(unsafe { Arc::from_raw(Arc::into_raw(boxed_slice) as *mut [T; N]) }) + } else { + Err(boxed_slice) + } + } +} + +#[stable(feature = "shared_from_iter", since = "1.37.0")] +impl iter::FromIterator for Arc<[T]> { + /// Takes each element in the `Iterator` and collects it into an `Arc<[T]>`. + /// + /// # Performance characteristics + /// + /// ## The general case + /// + /// In the general case, collecting into `Arc<[T]>` is done by first + /// collecting into a `Vec`. That is, when writing the following: + /// + /// ```rust + /// # use std::sync::Arc; + /// let evens: Arc<[u8]> = (0..10).filter(|&x| x % 2 == 0).collect(); + /// # assert_eq!(&*evens, &[0, 2, 4, 6, 8]); + /// ``` + /// + /// this behaves as if we wrote: + /// + /// ```rust + /// # use std::sync::Arc; + /// let evens: Arc<[u8]> = (0..10).filter(|&x| x % 2 == 0) + /// .collect::>() // The first set of allocations happens here. + /// .into(); // A second allocation for `Arc<[T]>` happens here. + /// # assert_eq!(&*evens, &[0, 2, 4, 6, 8]); + /// ``` + /// + /// This will allocate as many times as needed for constructing the `Vec` + /// and then it will allocate once for turning the `Vec` into the `Arc<[T]>`. + /// + /// ## Iterators of known length + /// + /// When your `Iterator` implements `TrustedLen` and is of an exact size, + /// a single allocation will be made for the `Arc<[T]>`. For example: + /// + /// ```rust + /// # use std::sync::Arc; + /// let evens: Arc<[u8]> = (0..10).collect(); // Just a single allocation happens here. + /// # assert_eq!(&*evens, &*(0..10).collect::>()); + /// ``` + fn from_iter>(iter: I) -> Self { + ToArcSlice::to_arc_slice(iter.into_iter()) + } +} + +/// Specialization trait used for collecting into `Arc<[T]>`. +trait ToArcSlice: Iterator + Sized { + fn to_arc_slice(self) -> Arc<[T]>; +} + +impl> ToArcSlice for I { + default fn to_arc_slice(self) -> Arc<[T]> { + self.collect::>().into() + } +} + +impl> ToArcSlice for I { + fn to_arc_slice(self) -> Arc<[T]> { + // This is the case for a `TrustedLen` iterator. + let (low, high) = self.size_hint(); + if let Some(high) = high { + debug_assert_eq!( + low, + high, + "TrustedLen iterator's size hint is not exact: {:?}", + (low, high) + ); + + unsafe { + // SAFETY: We need to ensure that the iterator has an exact length and we have. + Arc::from_iter_exact(self, low) + } + } else { + // Fall back to normal implementation. + self.collect::>().into() + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl borrow::Borrow for Arc { + fn borrow(&self) -> &T { + &**self + } +} + +#[stable(since = "1.5.0", feature = "smart_ptr_as_ref")] +impl AsRef for Arc { + fn as_ref(&self) -> &T { + &**self + } +} + +#[stable(feature = "pin", since = "1.33.0")] +impl Unpin for Arc {} + +/// Get the offset within an `ArcInner` for +/// a payload of type described by a pointer. +/// +/// # Safety +/// +/// This has the same safety requirements as `align_of_val_raw`. In effect: +/// +/// - This function is safe for any argument if `T` is sized, and +/// - if `T` is unsized, the pointer must have appropriate pointer metadata +/// acquired from the real instance that you are getting this offset for. +unsafe fn data_offset(ptr: *const T) -> isize { + // Align the unsized value to the end of the `ArcInner`. + // Because it is `?Sized`, it will always be the last field in memory. + // Note: This is a detail of the current implementation of the compiler, + // and is not a guaranteed language detail. Do not rely on it outside of std. + unsafe { data_offset_align(align_of_val(&*ptr)) } +} + +#[inline] +fn data_offset_align(align: usize) -> isize { + let layout = Layout::new::>(); + (layout.size() + layout.padding_needed_for(align)) as isize +} diff --git a/libgrust/rustc-lib/alloc/src/sync/tests.rs b/libgrust/rustc-lib/alloc/src/sync/tests.rs new file mode 100644 index 000000000000..e8e1e66da5ed --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/sync/tests.rs @@ -0,0 +1,579 @@ +use super::*; + +use std::boxed::Box; +use std::clone::Clone; +use std::convert::{From, TryInto}; +use std::mem::drop; +use std::ops::Drop; +use std::option::Option::{self, None, Some}; +use std::sync::atomic::{ + self, + Ordering::{Acquire, SeqCst}, +}; +use std::sync::mpsc::channel; +use std::sync::Mutex; +use std::thread; + +use crate::vec::Vec; + +struct Canary(*mut atomic::AtomicUsize); + +impl Drop for Canary { + fn drop(&mut self) { + unsafe { + match *self { + Canary(c) => { + (*c).fetch_add(1, SeqCst); + } + } + } + } +} + +#[test] +#[cfg_attr(target_os = "emscripten", ignore)] +fn manually_share_arc() { + let v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; + let arc_v = Arc::new(v); + + let (tx, rx) = channel(); + + let _t = thread::spawn(move || { + let arc_v: Arc> = rx.recv().unwrap(); + assert_eq!((*arc_v)[3], 4); + }); + + tx.send(arc_v.clone()).unwrap(); + + assert_eq!((*arc_v)[2], 3); + assert_eq!((*arc_v)[4], 5); +} + +#[test] +fn test_arc_get_mut() { + let mut x = Arc::new(3); + *Arc::get_mut(&mut x).unwrap() = 4; + assert_eq!(*x, 4); + let y = x.clone(); + assert!(Arc::get_mut(&mut x).is_none()); + drop(y); + assert!(Arc::get_mut(&mut x).is_some()); + let _w = Arc::downgrade(&x); + assert!(Arc::get_mut(&mut x).is_none()); +} + +#[test] +fn weak_counts() { + assert_eq!(Weak::weak_count(&Weak::::new()), 0); + assert_eq!(Weak::strong_count(&Weak::::new()), 0); + + let a = Arc::new(0); + let w = Arc::downgrade(&a); + assert_eq!(Weak::strong_count(&w), 1); + assert_eq!(Weak::weak_count(&w), 1); + let w2 = w.clone(); + assert_eq!(Weak::strong_count(&w), 1); + assert_eq!(Weak::weak_count(&w), 2); + assert_eq!(Weak::strong_count(&w2), 1); + assert_eq!(Weak::weak_count(&w2), 2); + drop(w); + assert_eq!(Weak::strong_count(&w2), 1); + assert_eq!(Weak::weak_count(&w2), 1); + let a2 = a.clone(); + assert_eq!(Weak::strong_count(&w2), 2); + assert_eq!(Weak::weak_count(&w2), 1); + drop(a2); + drop(a); + assert_eq!(Weak::strong_count(&w2), 0); + assert_eq!(Weak::weak_count(&w2), 0); + drop(w2); +} + +#[test] +fn try_unwrap() { + let x = Arc::new(3); + assert_eq!(Arc::try_unwrap(x), Ok(3)); + let x = Arc::new(4); + let _y = x.clone(); + assert_eq!(Arc::try_unwrap(x), Err(Arc::new(4))); + let x = Arc::new(5); + let _w = Arc::downgrade(&x); + assert_eq!(Arc::try_unwrap(x), Ok(5)); +} + +#[test] +fn into_from_raw() { + let x = Arc::new(box "hello"); + let y = x.clone(); + + let x_ptr = Arc::into_raw(x); + drop(y); + unsafe { + assert_eq!(**x_ptr, "hello"); + + let x = Arc::from_raw(x_ptr); + assert_eq!(**x, "hello"); + + assert_eq!(Arc::try_unwrap(x).map(|x| *x), Ok("hello")); + } +} + +#[test] +fn test_into_from_raw_unsized() { + use std::fmt::Display; + use std::string::ToString; + + let arc: Arc = Arc::from("foo"); + + let ptr = Arc::into_raw(arc.clone()); + let arc2 = unsafe { Arc::from_raw(ptr) }; + + assert_eq!(unsafe { &*ptr }, "foo"); + assert_eq!(arc, arc2); + + let arc: Arc = Arc::new(123); + + let ptr = Arc::into_raw(arc.clone()); + let arc2 = unsafe { Arc::from_raw(ptr) }; + + assert_eq!(unsafe { &*ptr }.to_string(), "123"); + assert_eq!(arc2.to_string(), "123"); +} + +#[test] +fn into_from_weak_raw() { + let x = Arc::new(box "hello"); + let y = Arc::downgrade(&x); + + let y_ptr = Weak::into_raw(y); + unsafe { + assert_eq!(**y_ptr, "hello"); + + let y = Weak::from_raw(y_ptr); + let y_up = Weak::upgrade(&y).unwrap(); + assert_eq!(**y_up, "hello"); + drop(y_up); + + assert_eq!(Arc::try_unwrap(x).map(|x| *x), Ok("hello")); + } +} + +#[test] +fn test_cowarc_clone_make_mut() { + let mut cow0 = Arc::new(75); + let mut cow1 = cow0.clone(); + let mut cow2 = cow1.clone(); + + assert!(75 == *Arc::make_mut(&mut cow0)); + assert!(75 == *Arc::make_mut(&mut cow1)); + assert!(75 == *Arc::make_mut(&mut cow2)); + + *Arc::make_mut(&mut cow0) += 1; + *Arc::make_mut(&mut cow1) += 2; + *Arc::make_mut(&mut cow2) += 3; + + assert!(76 == *cow0); + assert!(77 == *cow1); + assert!(78 == *cow2); + + // none should point to the same backing memory + assert!(*cow0 != *cow1); + assert!(*cow0 != *cow2); + assert!(*cow1 != *cow2); +} + +#[test] +fn test_cowarc_clone_unique2() { + let mut cow0 = Arc::new(75); + let cow1 = cow0.clone(); + let cow2 = cow1.clone(); + + assert!(75 == *cow0); + assert!(75 == *cow1); + assert!(75 == *cow2); + + *Arc::make_mut(&mut cow0) += 1; + assert!(76 == *cow0); + assert!(75 == *cow1); + assert!(75 == *cow2); + + // cow1 and cow2 should share the same contents + // cow0 should have a unique reference + assert!(*cow0 != *cow1); + assert!(*cow0 != *cow2); + assert!(*cow1 == *cow2); +} + +#[test] +fn test_cowarc_clone_weak() { + let mut cow0 = Arc::new(75); + let cow1_weak = Arc::downgrade(&cow0); + + assert!(75 == *cow0); + assert!(75 == *cow1_weak.upgrade().unwrap()); + + *Arc::make_mut(&mut cow0) += 1; + + assert!(76 == *cow0); + assert!(cow1_weak.upgrade().is_none()); +} + +#[test] +fn test_live() { + let x = Arc::new(5); + let y = Arc::downgrade(&x); + assert!(y.upgrade().is_some()); +} + +#[test] +fn test_dead() { + let x = Arc::new(5); + let y = Arc::downgrade(&x); + drop(x); + assert!(y.upgrade().is_none()); +} + +#[test] +fn weak_self_cyclic() { + struct Cycle { + x: Mutex>>, + } + + let a = Arc::new(Cycle { x: Mutex::new(None) }); + let b = Arc::downgrade(&a.clone()); + *a.x.lock().unwrap() = Some(b); + + // hopefully we don't double-free (or leak)... +} + +#[test] +fn drop_arc() { + let mut canary = atomic::AtomicUsize::new(0); + let x = Arc::new(Canary(&mut canary as *mut atomic::AtomicUsize)); + drop(x); + assert!(canary.load(Acquire) == 1); +} + +#[test] +fn drop_arc_weak() { + let mut canary = atomic::AtomicUsize::new(0); + let arc = Arc::new(Canary(&mut canary as *mut atomic::AtomicUsize)); + let arc_weak = Arc::downgrade(&arc); + assert!(canary.load(Acquire) == 0); + drop(arc); + assert!(canary.load(Acquire) == 1); + drop(arc_weak); +} + +#[test] +fn test_strong_count() { + let a = Arc::new(0); + assert!(Arc::strong_count(&a) == 1); + let w = Arc::downgrade(&a); + assert!(Arc::strong_count(&a) == 1); + let b = w.upgrade().expect(""); + assert!(Arc::strong_count(&b) == 2); + assert!(Arc::strong_count(&a) == 2); + drop(w); + drop(a); + assert!(Arc::strong_count(&b) == 1); + let c = b.clone(); + assert!(Arc::strong_count(&b) == 2); + assert!(Arc::strong_count(&c) == 2); +} + +#[test] +fn test_weak_count() { + let a = Arc::new(0); + assert!(Arc::strong_count(&a) == 1); + assert!(Arc::weak_count(&a) == 0); + let w = Arc::downgrade(&a); + assert!(Arc::strong_count(&a) == 1); + assert!(Arc::weak_count(&a) == 1); + let x = w.clone(); + assert!(Arc::weak_count(&a) == 2); + drop(w); + drop(x); + assert!(Arc::strong_count(&a) == 1); + assert!(Arc::weak_count(&a) == 0); + let c = a.clone(); + assert!(Arc::strong_count(&a) == 2); + assert!(Arc::weak_count(&a) == 0); + let d = Arc::downgrade(&c); + assert!(Arc::weak_count(&c) == 1); + assert!(Arc::strong_count(&c) == 2); + + drop(a); + drop(c); + drop(d); +} + +#[test] +fn show_arc() { + let a = Arc::new(5); + assert_eq!(format!("{:?}", a), "5"); +} + +// Make sure deriving works with Arc +#[derive(Eq, Ord, PartialEq, PartialOrd, Clone, Debug, Default)] +struct Foo { + inner: Arc, +} + +#[test] +fn test_unsized() { + let x: Arc<[i32]> = Arc::new([1, 2, 3]); + assert_eq!(format!("{:?}", x), "[1, 2, 3]"); + let y = Arc::downgrade(&x.clone()); + drop(x); + assert!(y.upgrade().is_none()); +} + +#[test] +fn test_from_owned() { + let foo = 123; + let foo_arc = Arc::from(foo); + assert!(123 == *foo_arc); +} + +#[test] +fn test_new_weak() { + let foo: Weak = Weak::new(); + assert!(foo.upgrade().is_none()); +} + +#[test] +fn test_ptr_eq() { + let five = Arc::new(5); + let same_five = five.clone(); + let other_five = Arc::new(5); + + assert!(Arc::ptr_eq(&five, &same_five)); + assert!(!Arc::ptr_eq(&five, &other_five)); +} + +#[test] +#[cfg_attr(target_os = "emscripten", ignore)] +fn test_weak_count_locked() { + let mut a = Arc::new(atomic::AtomicBool::new(false)); + let a2 = a.clone(); + let t = thread::spawn(move || { + // Miri is too slow + let count = if cfg!(miri) { 1000 } else { 1000000 }; + for _i in 0..count { + Arc::get_mut(&mut a); + } + a.store(true, SeqCst); + }); + + while !a2.load(SeqCst) { + let n = Arc::weak_count(&a2); + assert!(n < 2, "bad weak count: {}", n); + #[cfg(miri)] // Miri's scheduler does not guarantee liveness, and thus needs this hint. + atomic::spin_loop_hint(); + } + t.join().unwrap(); +} + +#[test] +fn test_from_str() { + let r: Arc = Arc::from("foo"); + + assert_eq!(&r[..], "foo"); +} + +#[test] +fn test_copy_from_slice() { + let s: &[u32] = &[1, 2, 3]; + let r: Arc<[u32]> = Arc::from(s); + + assert_eq!(&r[..], [1, 2, 3]); +} + +#[test] +fn test_clone_from_slice() { + #[derive(Clone, Debug, Eq, PartialEq)] + struct X(u32); + + let s: &[X] = &[X(1), X(2), X(3)]; + let r: Arc<[X]> = Arc::from(s); + + assert_eq!(&r[..], s); +} + +#[test] +#[should_panic] +fn test_clone_from_slice_panic() { + use std::string::{String, ToString}; + + struct Fail(u32, String); + + impl Clone for Fail { + fn clone(&self) -> Fail { + if self.0 == 2 { + panic!(); + } + Fail(self.0, self.1.clone()) + } + } + + let s: &[Fail] = + &[Fail(0, "foo".to_string()), Fail(1, "bar".to_string()), Fail(2, "baz".to_string())]; + + // Should panic, but not cause memory corruption + let _r: Arc<[Fail]> = Arc::from(s); +} + +#[test] +fn test_from_box() { + let b: Box = box 123; + let r: Arc = Arc::from(b); + + assert_eq!(*r, 123); +} + +#[test] +fn test_from_box_str() { + use std::string::String; + + let s = String::from("foo").into_boxed_str(); + let r: Arc = Arc::from(s); + + assert_eq!(&r[..], "foo"); +} + +#[test] +fn test_from_box_slice() { + let s = vec![1, 2, 3].into_boxed_slice(); + let r: Arc<[u32]> = Arc::from(s); + + assert_eq!(&r[..], [1, 2, 3]); +} + +#[test] +fn test_from_box_trait() { + use std::fmt::Display; + use std::string::ToString; + + let b: Box = box 123; + let r: Arc = Arc::from(b); + + assert_eq!(r.to_string(), "123"); +} + +#[test] +fn test_from_box_trait_zero_sized() { + use std::fmt::Debug; + + let b: Box = box (); + let r: Arc = Arc::from(b); + + assert_eq!(format!("{:?}", r), "()"); +} + +#[test] +fn test_from_vec() { + let v = vec![1, 2, 3]; + let r: Arc<[u32]> = Arc::from(v); + + assert_eq!(&r[..], [1, 2, 3]); +} + +#[test] +fn test_downcast() { + use std::any::Any; + + let r1: Arc = Arc::new(i32::MAX); + let r2: Arc = Arc::new("abc"); + + assert!(r1.clone().downcast::().is_err()); + + let r1i32 = r1.downcast::(); + assert!(r1i32.is_ok()); + assert_eq!(r1i32.unwrap(), Arc::new(i32::MAX)); + + assert!(r2.clone().downcast::().is_err()); + + let r2str = r2.downcast::<&'static str>(); + assert!(r2str.is_ok()); + assert_eq!(r2str.unwrap(), Arc::new("abc")); +} + +#[test] +fn test_array_from_slice() { + let v = vec![1, 2, 3]; + let r: Arc<[u32]> = Arc::from(v); + + let a: Result, _> = r.clone().try_into(); + assert!(a.is_ok()); + + let a: Result, _> = r.clone().try_into(); + assert!(a.is_err()); +} + +#[test] +fn test_arc_cyclic_with_zero_refs() { + struct ZeroRefs { + inner: Weak, + } + let zero_refs = Arc::new_cyclic(|inner| { + assert_eq!(inner.strong_count(), 0); + assert!(inner.upgrade().is_none()); + ZeroRefs { inner: Weak::new() } + }); + + assert_eq!(Arc::strong_count(&zero_refs), 1); + assert_eq!(Arc::weak_count(&zero_refs), 0); + assert_eq!(zero_refs.inner.strong_count(), 0); + assert_eq!(zero_refs.inner.weak_count(), 0); +} + +#[test] +fn test_arc_new_cyclic_one_ref() { + struct OneRef { + inner: Weak, + } + let one_ref = Arc::new_cyclic(|inner| { + assert_eq!(inner.strong_count(), 0); + assert!(inner.upgrade().is_none()); + OneRef { inner: inner.clone() } + }); + + assert_eq!(Arc::strong_count(&one_ref), 1); + assert_eq!(Arc::weak_count(&one_ref), 1); + + let one_ref2 = Weak::upgrade(&one_ref.inner).unwrap(); + assert!(Arc::ptr_eq(&one_ref, &one_ref2)); + + assert_eq!(Arc::strong_count(&one_ref), 2); + assert_eq!(Arc::weak_count(&one_ref), 1); +} + +#[test] +fn test_arc_cyclic_two_refs() { + struct TwoRefs { + inner1: Weak, + inner2: Weak, + } + let two_refs = Arc::new_cyclic(|inner| { + assert_eq!(inner.strong_count(), 0); + assert!(inner.upgrade().is_none()); + + let inner1 = inner.clone(); + let inner2 = inner1.clone(); + + TwoRefs { inner1, inner2 } + }); + + assert_eq!(Arc::strong_count(&two_refs), 1); + assert_eq!(Arc::weak_count(&two_refs), 2); + + let two_refs1 = Weak::upgrade(&two_refs.inner1).unwrap(); + assert!(Arc::ptr_eq(&two_refs, &two_refs1)); + + let two_refs2 = Weak::upgrade(&two_refs.inner2).unwrap(); + assert!(Arc::ptr_eq(&two_refs, &two_refs2)); + + assert_eq!(Arc::strong_count(&two_refs), 3); + assert_eq!(Arc::weak_count(&two_refs), 2); +} diff --git a/libgrust/rustc-lib/alloc/src/task.rs b/libgrust/rustc-lib/alloc/src/task.rs new file mode 100644 index 000000000000..fcab3fd0badc --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/task.rs @@ -0,0 +1,91 @@ +#![unstable(feature = "wake_trait", issue = "69912")] +//! Types and Traits for working with asynchronous tasks. +use core::mem::ManuallyDrop; +use core::task::{RawWaker, RawWakerVTable, Waker}; + +use crate::sync::Arc; + +/// The implementation of waking a task on an executor. +/// +/// This trait can be used to create a [`Waker`]. An executor can define an +/// implementation of this trait, and use that to construct a Waker to pass +/// to the tasks that are executed on that executor. +/// +/// This trait is a memory-safe and ergonomic alternative to constructing a +/// [`RawWaker`]. It supports the common executor design in which the data used +/// to wake up a task is stored in an [`Arc`]. Some executors (especially +/// those for embedded systems) cannot use this API, which is why [`RawWaker`] +/// exists as an alternative for those systems. +#[unstable(feature = "wake_trait", issue = "69912")] +pub trait Wake { + /// Wake this task. + #[unstable(feature = "wake_trait", issue = "69912")] + fn wake(self: Arc); + + /// Wake this task without consuming the waker. + /// + /// If an executor supports a cheaper way to wake without consuming the + /// waker, it should override this method. By default, it clones the + /// [`Arc`] and calls `wake` on the clone. + #[unstable(feature = "wake_trait", issue = "69912")] + fn wake_by_ref(self: &Arc) { + self.clone().wake(); + } +} + +#[allow(rustc::ineffective_unstable_trait_impl)] +#[unstable(feature = "wake_trait", issue = "69912")] +impl From> for Waker { + fn from(waker: Arc) -> Waker { + // SAFETY: This is safe because raw_waker safely constructs + // a RawWaker from Arc. + unsafe { Waker::from_raw(raw_waker(waker)) } + } +} + +#[allow(rustc::ineffective_unstable_trait_impl)] +#[unstable(feature = "wake_trait", issue = "69912")] +impl From> for RawWaker { + fn from(waker: Arc) -> RawWaker { + raw_waker(waker) + } +} + +// NB: This private function for constructing a RawWaker is used, rather than +// inlining this into the `From> for RawWaker` impl, to ensure that +// the safety of `From> for Waker` does not depend on the correct +// trait dispatch - instead both impls call this function directly and +// explicitly. +#[inline(always)] +fn raw_waker(waker: Arc) -> RawWaker { + // Increment the reference count of the arc to clone it. + unsafe fn clone_waker(waker: *const ()) -> RawWaker { + unsafe { Arc::incr_strong_count(waker as *const W) }; + RawWaker::new( + waker as *const (), + &RawWakerVTable::new(clone_waker::, wake::, wake_by_ref::, drop_waker::), + ) + } + + // Wake by value, moving the Arc into the Wake::wake function + unsafe fn wake(waker: *const ()) { + let waker = unsafe { Arc::from_raw(waker as *const W) }; + ::wake(waker); + } + + // Wake by reference, wrap the waker in ManuallyDrop to avoid dropping it + unsafe fn wake_by_ref(waker: *const ()) { + let waker = unsafe { ManuallyDrop::new(Arc::from_raw(waker as *const W)) }; + ::wake_by_ref(&waker); + } + + // Decrement the reference count of the Arc on drop + unsafe fn drop_waker(waker: *const ()) { + unsafe { Arc::decr_strong_count(waker as *const W) }; + } + + RawWaker::new( + Arc::into_raw(waker) as *const (), + &RawWakerVTable::new(clone_waker::, wake::, wake_by_ref::, drop_waker::), + ) +} diff --git a/libgrust/rustc-lib/alloc/src/tests.rs b/libgrust/rustc-lib/alloc/src/tests.rs new file mode 100644 index 000000000000..bddaab0c7618 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/tests.rs @@ -0,0 +1,151 @@ +//! Test for `boxed` mod. + +use core::any::Any; +use core::clone::Clone; +use core::convert::TryInto; +use core::ops::Deref; +use core::result::Result::{Err, Ok}; + +use std::boxed::Box; + +#[test] +fn test_owned_clone() { + let a = Box::new(5); + let b: Box = a.clone(); + assert!(a == b); +} + +#[derive(PartialEq, Eq)] +struct Test; + +#[test] +fn any_move() { + let a = Box::new(8) as Box; + let b = Box::new(Test) as Box; + + match a.downcast::() { + Ok(a) => { + assert!(a == Box::new(8)); + } + Err(..) => panic!(), + } + match b.downcast::() { + Ok(a) => { + assert!(a == Box::new(Test)); + } + Err(..) => panic!(), + } + + let a = Box::new(8) as Box; + let b = Box::new(Test) as Box; + + assert!(a.downcast::>().is_err()); + assert!(b.downcast::>().is_err()); +} + +#[test] +fn test_show() { + let a = Box::new(8) as Box; + let b = Box::new(Test) as Box; + let a_str = format!("{:?}", a); + let b_str = format!("{:?}", b); + assert_eq!(a_str, "Any"); + assert_eq!(b_str, "Any"); + + static EIGHT: usize = 8; + static TEST: Test = Test; + let a = &EIGHT as &dyn Any; + let b = &TEST as &dyn Any; + let s = format!("{:?}", a); + assert_eq!(s, "Any"); + let s = format!("{:?}", b); + assert_eq!(s, "Any"); +} + +#[test] +fn deref() { + fn homura>(_: T) {} + homura(Box::new(765)); +} + +#[test] +fn raw_sized() { + let x = Box::new(17); + let p = Box::into_raw(x); + unsafe { + assert_eq!(17, *p); + *p = 19; + let y = Box::from_raw(p); + assert_eq!(19, *y); + } +} + +#[test] +fn raw_trait() { + trait Foo { + fn get(&self) -> u32; + fn set(&mut self, value: u32); + } + + struct Bar(u32); + + impl Foo for Bar { + fn get(&self) -> u32 { + self.0 + } + + fn set(&mut self, value: u32) { + self.0 = value; + } + } + + let x: Box = Box::new(Bar(17)); + let p = Box::into_raw(x); + unsafe { + assert_eq!(17, (*p).get()); + (*p).set(19); + let y: Box = Box::from_raw(p); + assert_eq!(19, y.get()); + } +} + +#[test] +fn f64_slice() { + let slice: &[f64] = &[-1.0, 0.0, 1.0, f64::INFINITY]; + let boxed: Box<[f64]> = Box::from(slice); + assert_eq!(&*boxed, slice) +} + +#[test] +fn i64_slice() { + let slice: &[i64] = &[i64::MIN, -2, -1, 0, 1, 2, i64::MAX]; + let boxed: Box<[i64]> = Box::from(slice); + assert_eq!(&*boxed, slice) +} + +#[test] +fn str_slice() { + let s = "Hello, world!"; + let boxed: Box = Box::from(s); + assert_eq!(&*boxed, s) +} + +#[test] +fn boxed_slice_from_iter() { + let iter = 0..100; + let boxed: Box<[u32]> = iter.collect(); + assert_eq!(boxed.len(), 100); + assert_eq!(boxed[7], 7); +} + +#[test] +fn test_array_from_slice() { + let v = vec![1, 2, 3]; + let r: Box<[u32]> = v.into_boxed_slice(); + + let a: Result, _> = r.clone().try_into(); + assert!(a.is_ok()); + + let a: Result, _> = r.clone().try_into(); + assert!(a.is_err()); +} diff --git a/libgrust/rustc-lib/alloc/src/vec.rs b/libgrust/rustc-lib/alloc/src/vec.rs new file mode 100644 index 000000000000..2c8bc3d53ef7 --- /dev/null +++ b/libgrust/rustc-lib/alloc/src/vec.rs @@ -0,0 +1,3439 @@ +// ignore-tidy-filelength +//! A contiguous growable array type with heap-allocated contents, written +//! `Vec`. +//! +//! Vectors have `O(1)` indexing, amortized `O(1)` push (to the end) and +//! `O(1)` pop (from the end). +//! +//! Vectors ensure they never allocate more than `isize::MAX` bytes. +//! +//! # Examples +//! +//! You can explicitly create a [`Vec`] with [`Vec::new`]: +//! +//! ``` +//! let v: Vec = Vec::new(); +//! ``` +//! +//! ...or by using the [`vec!`] macro: +//! +//! ``` +//! let v: Vec = vec![]; +//! +//! let v = vec![1, 2, 3, 4, 5]; +//! +//! let v = vec![0; 10]; // ten zeroes +//! ``` +//! +//! You can [`push`] values onto the end of a vector (which will grow the vector +//! as needed): +//! +//! ``` +//! let mut v = vec![1, 2]; +//! +//! v.push(3); +//! ``` +//! +//! Popping values works in much the same way: +//! +//! ``` +//! let mut v = vec![1, 2]; +//! +//! let two = v.pop(); +//! ``` +//! +//! Vectors also support indexing (through the [`Index`] and [`IndexMut`] traits): +//! +//! ``` +//! let mut v = vec![1, 2, 3]; +//! let three = v[2]; +//! v[1] = v[1] + 5; +//! ``` +//! +//! [`push`]: Vec::push + +#![stable(feature = "rust1", since = "1.0.0")] + +use core::cmp::{self, Ordering}; +use core::convert::TryFrom; +use core::fmt; +use core::hash::{Hash, Hasher}; +use core::intrinsics::{arith_offset, assume}; +use core::iter::{ + FromIterator, FusedIterator, InPlaceIterable, SourceIter, TrustedLen, TrustedRandomAccess, +}; +use core::marker::PhantomData; +use core::mem::{self, ManuallyDrop, MaybeUninit}; +use core::ops::{self, Index, IndexMut, Range, RangeBounds}; +use core::ptr::{self, NonNull}; +use core::slice::{self, SliceIndex}; + +use crate::borrow::{Cow, ToOwned}; +use crate::boxed::Box; +use crate::collections::TryReserveError; +use crate::raw_vec::RawVec; + +/// A contiguous growable array type, written `Vec` but pronounced 'vector'. +/// +/// # Examples +/// +/// ``` +/// let mut vec = Vec::new(); +/// vec.push(1); +/// vec.push(2); +/// +/// assert_eq!(vec.len(), 2); +/// assert_eq!(vec[0], 1); +/// +/// assert_eq!(vec.pop(), Some(2)); +/// assert_eq!(vec.len(), 1); +/// +/// vec[0] = 7; +/// assert_eq!(vec[0], 7); +/// +/// vec.extend([1, 2, 3].iter().copied()); +/// +/// for x in &vec { +/// println!("{}", x); +/// } +/// assert_eq!(vec, [7, 1, 2, 3]); +/// ``` +/// +/// The [`vec!`] macro is provided to make initialization more convenient: +/// +/// ``` +/// let mut vec = vec![1, 2, 3]; +/// vec.push(4); +/// assert_eq!(vec, [1, 2, 3, 4]); +/// ``` +/// +/// It can also initialize each element of a `Vec` with a given value. +/// This may be more efficient than performing allocation and initialization +/// in separate steps, especially when initializing a vector of zeros: +/// +/// ``` +/// let vec = vec![0; 5]; +/// assert_eq!(vec, [0, 0, 0, 0, 0]); +/// +/// // The following is equivalent, but potentially slower: +/// let mut vec = Vec::with_capacity(5); +/// vec.resize(5, 0); +/// assert_eq!(vec, [0, 0, 0, 0, 0]); +/// ``` +/// +/// For more information, see +/// [Capacity and Reallocation](#capacity-and-reallocation). +/// +/// Use a `Vec` as an efficient stack: +/// +/// ``` +/// let mut stack = Vec::new(); +/// +/// stack.push(1); +/// stack.push(2); +/// stack.push(3); +/// +/// while let Some(top) = stack.pop() { +/// // Prints 3, 2, 1 +/// println!("{}", top); +/// } +/// ``` +/// +/// # Indexing +/// +/// The `Vec` type allows to access values by index, because it implements the +/// [`Index`] trait. An example will be more explicit: +/// +/// ``` +/// let v = vec![0, 2, 4, 6]; +/// println!("{}", v[1]); // it will display '2' +/// ``` +/// +/// However be careful: if you try to access an index which isn't in the `Vec`, +/// your software will panic! You cannot do this: +/// +/// ```should_panic +/// let v = vec![0, 2, 4, 6]; +/// println!("{}", v[6]); // it will panic! +/// ``` +/// +/// Use [`get`] and [`get_mut`] if you want to check whether the index is in +/// the `Vec`. +/// +/// # Slicing +/// +/// A `Vec` can be mutable. Slices, on the other hand, are read-only objects. +/// To get a [slice], use [`&`]. Example: +/// +/// ``` +/// fn read_slice(slice: &[usize]) { +/// // ... +/// } +/// +/// let v = vec![0, 1]; +/// read_slice(&v); +/// +/// // ... and that's all! +/// // you can also do it like this: +/// let u: &[usize] = &v; +/// // or like this: +/// let u: &[_] = &v; +/// ``` +/// +/// In Rust, it's more common to pass slices as arguments rather than vectors +/// when you just want to provide read access. The same goes for [`String`] and +/// [`&str`]. +/// +/// # Capacity and reallocation +/// +/// The capacity of a vector is the amount of space allocated for any future +/// elements that will be added onto the vector. This is not to be confused with +/// the *length* of a vector, which specifies the number of actual elements +/// within the vector. If a vector's length exceeds its capacity, its capacity +/// will automatically be increased, but its elements will have to be +/// reallocated. +/// +/// For example, a vector with capacity 10 and length 0 would be an empty vector +/// with space for 10 more elements. Pushing 10 or fewer elements onto the +/// vector will not change its capacity or cause reallocation to occur. However, +/// if the vector's length is increased to 11, it will have to reallocate, which +/// can be slow. For this reason, it is recommended to use [`Vec::with_capacity`] +/// whenever possible to specify how big the vector is expected to get. +/// +/// # Guarantees +/// +/// Due to its incredibly fundamental nature, `Vec` makes a lot of guarantees +/// about its design. This ensures that it's as low-overhead as possible in +/// the general case, and can be correctly manipulated in primitive ways +/// by unsafe code. Note that these guarantees refer to an unqualified `Vec`. +/// If additional type parameters are added (e.g., to support custom allocators), +/// overriding their defaults may change the behavior. +/// +/// Most fundamentally, `Vec` is and always will be a (pointer, capacity, length) +/// triplet. No more, no less. The order of these fields is completely +/// unspecified, and you should use the appropriate methods to modify these. +/// The pointer will never be null, so this type is null-pointer-optimized. +/// +/// However, the pointer may not actually point to allocated memory. In particular, +/// if you construct a `Vec` with capacity 0 via [`Vec::new`], [`vec![]`][`vec!`], +/// [`Vec::with_capacity(0)`][`Vec::with_capacity`], or by calling [`shrink_to_fit`] +/// on an empty Vec, it will not allocate memory. Similarly, if you store zero-sized +/// types inside a `Vec`, it will not allocate space for them. *Note that in this case +/// the `Vec` may not report a [`capacity`] of 0*. `Vec` will allocate if and only +/// if [`mem::size_of::`]`() * capacity() > 0`. In general, `Vec`'s allocation +/// details are very subtle — if you intend to allocate memory using a `Vec` +/// and use it for something else (either to pass to unsafe code, or to build your +/// own memory-backed collection), be sure to deallocate this memory by using +/// `from_raw_parts` to recover the `Vec` and then dropping it. +/// +/// If a `Vec` *has* allocated memory, then the memory it points to is on the heap +/// (as defined by the allocator Rust is configured to use by default), and its +/// pointer points to [`len`] initialized, contiguous elements in order (what +/// you would see if you coerced it to a slice), followed by [`capacity`]` - +/// `[`len`] logically uninitialized, contiguous elements. +/// +/// `Vec` will never perform a "small optimization" where elements are actually +/// stored on the stack for two reasons: +/// +/// * It would make it more difficult for unsafe code to correctly manipulate +/// a `Vec`. The contents of a `Vec` wouldn't have a stable address if it were +/// only moved, and it would be more difficult to determine if a `Vec` had +/// actually allocated memory. +/// +/// * It would penalize the general case, incurring an additional branch +/// on every access. +/// +/// `Vec` will never automatically shrink itself, even if completely empty. This +/// ensures no unnecessary allocations or deallocations occur. Emptying a `Vec` +/// and then filling it back up to the same [`len`] should incur no calls to +/// the allocator. If you wish to free up unused memory, use +/// [`shrink_to_fit`]. +/// +/// [`push`] and [`insert`] will never (re)allocate if the reported capacity is +/// sufficient. [`push`] and [`insert`] *will* (re)allocate if +/// [`len`]` == `[`capacity`]. That is, the reported capacity is completely +/// accurate, and can be relied on. It can even be used to manually free the memory +/// allocated by a `Vec` if desired. Bulk insertion methods *may* reallocate, even +/// when not necessary. +/// +/// `Vec` does not guarantee any particular growth strategy when reallocating +/// when full, nor when [`reserve`] is called. The current strategy is basic +/// and it may prove desirable to use a non-constant growth factor. Whatever +/// strategy is used will of course guarantee *O*(1) amortized [`push`]. +/// +/// `vec![x; n]`, `vec![a, b, c, d]`, and +/// [`Vec::with_capacity(n)`][`Vec::with_capacity`], will all produce a `Vec` +/// with exactly the requested capacity. If [`len`]` == `[`capacity`], +/// (as is the case for the [`vec!`] macro), then a `Vec` can be converted to +/// and from a [`Box<[T]>`][owned slice] without reallocating or moving the elements. +/// +/// `Vec` will not specifically overwrite any data that is removed from it, +/// but also won't specifically preserve it. Its uninitialized memory is +/// scratch space that it may use however it wants. It will generally just do +/// whatever is most efficient or otherwise easy to implement. Do not rely on +/// removed data to be erased for security purposes. Even if you drop a `Vec`, its +/// buffer may simply be reused by another `Vec`. Even if you zero a `Vec`'s memory +/// first, that may not actually happen because the optimizer does not consider +/// this a side-effect that must be preserved. There is one case which we will +/// not break, however: using `unsafe` code to write to the excess capacity, +/// and then increasing the length to match, is always valid. +/// +/// `Vec` does not currently guarantee the order in which elements are dropped. +/// The order has changed in the past and may change again. +/// +/// [`get`]: ../../std/vec/struct.Vec.html#method.get +/// [`get_mut`]: ../../std/vec/struct.Vec.html#method.get_mut +/// [`String`]: crate::string::String +/// [`&str`]: type@str +/// [`shrink_to_fit`]: Vec::shrink_to_fit +/// [`capacity`]: Vec::capacity +/// [`mem::size_of::`]: core::mem::size_of +/// [`len`]: Vec::len +/// [`push`]: Vec::push +/// [`insert`]: Vec::insert +/// [`reserve`]: Vec::reserve +/// [owned slice]: Box +/// [slice]: ../../std/primitive.slice.html +/// [`&`]: ../../std/primitive.reference.html +#[stable(feature = "rust1", since = "1.0.0")] +#[cfg_attr(not(test), rustc_diagnostic_item = "vec_type")] +pub struct Vec { + buf: RawVec, + len: usize, +} + +//////////////////////////////////////////////////////////////////////////////// +// Inherent methods +//////////////////////////////////////////////////////////////////////////////// + +impl Vec { + /// Constructs a new, empty `Vec`. + /// + /// The vector will not allocate until elements are pushed onto it. + /// + /// # Examples + /// + /// ``` + /// # #![allow(unused_mut)] + /// let mut vec: Vec = Vec::new(); + /// ``` + #[inline] + #[rustc_const_stable(feature = "const_vec_new", since = "1.39.0")] + #[stable(feature = "rust1", since = "1.0.0")] + pub const fn new() -> Vec { + Vec { buf: RawVec::NEW, len: 0 } + } + + /// Constructs a new, empty `Vec` with the specified capacity. + /// + /// The vector will be able to hold exactly `capacity` elements without + /// reallocating. If `capacity` is 0, the vector will not allocate. + /// + /// It is important to note that although the returned vector has the + /// *capacity* specified, the vector will have a zero *length*. For an + /// explanation of the difference between length and capacity, see + /// *[Capacity and reallocation]*. + /// + /// [Capacity and reallocation]: #capacity-and-reallocation + /// + /// # Examples + /// + /// ``` + /// let mut vec = Vec::with_capacity(10); + /// + /// // The vector contains no items, even though it has capacity for more + /// assert_eq!(vec.len(), 0); + /// assert_eq!(vec.capacity(), 10); + /// + /// // These are all done without reallocating... + /// for i in 0..10 { + /// vec.push(i); + /// } + /// assert_eq!(vec.len(), 10); + /// assert_eq!(vec.capacity(), 10); + /// + /// // ...but this may make the vector reallocate + /// vec.push(11); + /// assert_eq!(vec.len(), 11); + /// assert!(vec.capacity() >= 11); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn with_capacity(capacity: usize) -> Vec { + Vec { buf: RawVec::with_capacity(capacity), len: 0 } + } + + /// Decomposes a `Vec` into its raw components. + /// + /// Returns the raw pointer to the underlying data, the length of + /// the vector (in elements), and the allocated capacity of the + /// data (in elements). These are the same arguments in the same + /// order as the arguments to [`from_raw_parts`]. + /// + /// After calling this function, the caller is responsible for the + /// memory previously managed by the `Vec`. The only way to do + /// this is to convert the raw pointer, length, and capacity back + /// into a `Vec` with the [`from_raw_parts`] function, allowing + /// the destructor to perform the cleanup. + /// + /// [`from_raw_parts`]: Vec::from_raw_parts + /// + /// # Examples + /// + /// ``` + /// #![feature(vec_into_raw_parts)] + /// let v: Vec = vec![-1, 0, 1]; + /// + /// let (ptr, len, cap) = v.into_raw_parts(); + /// + /// let rebuilt = unsafe { + /// // We can now make changes to the components, such as + /// // transmuting the raw pointer to a compatible type. + /// let ptr = ptr as *mut u32; + /// + /// Vec::from_raw_parts(ptr, len, cap) + /// }; + /// assert_eq!(rebuilt, [4294967295, 0, 1]); + /// ``` + #[unstable(feature = "vec_into_raw_parts", reason = "new API", issue = "65816")] + pub fn into_raw_parts(self) -> (*mut T, usize, usize) { + let mut me = ManuallyDrop::new(self); + (me.as_mut_ptr(), me.len(), me.capacity()) + } + + /// Creates a `Vec` directly from the raw components of another vector. + /// + /// # Safety + /// + /// This is highly unsafe, due to the number of invariants that aren't + /// checked: + /// + /// * `ptr` needs to have been previously allocated via [`String`]/`Vec` + /// (at least, it's highly likely to be incorrect if it wasn't). + /// * `T` needs to have the same size and alignment as what `ptr` was allocated with. + /// (`T` having a less strict alignment is not sufficient, the alignment really + /// needs to be equal to satisfy the [`dealloc`] requirement that memory must be + /// allocated and deallocated with the same layout.) + /// * `length` needs to be less than or equal to `capacity`. + /// * `capacity` needs to be the capacity that the pointer was allocated with. + /// + /// Violating these may cause problems like corrupting the allocator's + /// internal data structures. For example it is **not** safe + /// to build a `Vec` from a pointer to a C `char` array with length `size_t`. + /// It's also not safe to build one from a `Vec` and its length, because + /// the allocator cares about the alignment, and these two types have different + /// alignments. The buffer was allocated with alignment 2 (for `u16`), but after + /// turning it into a `Vec` it'll be deallocated with alignment 1. + /// + /// The ownership of `ptr` is effectively transferred to the + /// `Vec` which may then deallocate, reallocate or change the + /// contents of memory pointed to by the pointer at will. Ensure + /// that nothing else uses the pointer after calling this + /// function. + /// + /// [`String`]: crate::string::String + /// [`dealloc`]: crate::alloc::GlobalAlloc::dealloc + /// + /// # Examples + /// + /// ``` + /// use std::ptr; + /// use std::mem; + /// + /// let v = vec![1, 2, 3]; + /// + // FIXME Update this when vec_into_raw_parts is stabilized + /// // Prevent running `v`'s destructor so we are in complete control + /// // of the allocation. + /// let mut v = mem::ManuallyDrop::new(v); + /// + /// // Pull out the various important pieces of information about `v` + /// let p = v.as_mut_ptr(); + /// let len = v.len(); + /// let cap = v.capacity(); + /// + /// unsafe { + /// // Overwrite memory with 4, 5, 6 + /// for i in 0..len as isize { + /// ptr::write(p.offset(i), 4 + i); + /// } + /// + /// // Put everything back together into a Vec + /// let rebuilt = Vec::from_raw_parts(p, len, cap); + /// assert_eq!(rebuilt, [4, 5, 6]); + /// } + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub unsafe fn from_raw_parts(ptr: *mut T, length: usize, capacity: usize) -> Vec { + unsafe { Vec { buf: RawVec::from_raw_parts(ptr, capacity), len: length } } + } + + /// Returns the number of elements the vector can hold without + /// reallocating. + /// + /// # Examples + /// + /// ``` + /// let vec: Vec = Vec::with_capacity(10); + /// assert_eq!(vec.capacity(), 10); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn capacity(&self) -> usize { + self.buf.capacity() + } + + /// Reserves capacity for at least `additional` more elements to be inserted + /// in the given `Vec`. The collection may reserve more space to avoid + /// frequent reallocations. After calling `reserve`, capacity will be + /// greater than or equal to `self.len() + additional`. Does nothing if + /// capacity is already sufficient. + /// + /// # Panics + /// + /// Panics if the new capacity exceeds `isize::MAX` bytes. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1]; + /// vec.reserve(10); + /// assert!(vec.capacity() >= 11); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn reserve(&mut self, additional: usize) { + self.buf.reserve(self.len, additional); + } + + /// Reserves the minimum capacity for exactly `additional` more elements to + /// be inserted in the given `Vec`. After calling `reserve_exact`, + /// capacity will be greater than or equal to `self.len() + additional`. + /// Does nothing if the capacity is already sufficient. + /// + /// Note that the allocator may give the collection more space than it + /// requests. Therefore, capacity can not be relied upon to be precisely + /// minimal. Prefer `reserve` if future insertions are expected. + /// + /// # Panics + /// + /// Panics if the new capacity overflows `usize`. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1]; + /// vec.reserve_exact(10); + /// assert!(vec.capacity() >= 11); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn reserve_exact(&mut self, additional: usize) { + self.buf.reserve_exact(self.len, additional); + } + + /// Tries to reserve capacity for at least `additional` more elements to be inserted + /// in the given `Vec`. The collection may reserve more space to avoid + /// frequent reallocations. After calling `try_reserve`, capacity will be + /// greater than or equal to `self.len() + additional`. Does nothing if + /// capacity is already sufficient. + /// + /// # Errors + /// + /// If the capacity overflows, or the allocator reports a failure, then an error + /// is returned. + /// + /// # Examples + /// + /// ``` + /// #![feature(try_reserve)] + /// use std::collections::TryReserveError; + /// + /// fn process_data(data: &[u32]) -> Result, TryReserveError> { + /// let mut output = Vec::new(); + /// + /// // Pre-reserve the memory, exiting if we can't + /// output.try_reserve(data.len())?; + /// + /// // Now we know this can't OOM in the middle of our complex work + /// output.extend(data.iter().map(|&val| { + /// val * 2 + 5 // very complicated + /// })); + /// + /// Ok(output) + /// } + /// # process_data(&[1, 2, 3]).expect("why is the test harness OOMing on 12 bytes?"); + /// ``` + #[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] + pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> { + self.buf.try_reserve(self.len, additional) + } + + /// Tries to reserve the minimum capacity for exactly `additional` + /// elements to be inserted in the given `Vec`. After calling + /// `try_reserve_exact`, capacity will be greater than or equal to + /// `self.len() + additional` if it returns `Ok(())`. + /// Does nothing if the capacity is already sufficient. + /// + /// Note that the allocator may give the collection more space than it + /// requests. Therefore, capacity can not be relied upon to be precisely + /// minimal. Prefer `reserve` if future insertions are expected. + /// + /// # Errors + /// + /// If the capacity overflows, or the allocator reports a failure, then an error + /// is returned. + /// + /// # Examples + /// + /// ``` + /// #![feature(try_reserve)] + /// use std::collections::TryReserveError; + /// + /// fn process_data(data: &[u32]) -> Result, TryReserveError> { + /// let mut output = Vec::new(); + /// + /// // Pre-reserve the memory, exiting if we can't + /// output.try_reserve_exact(data.len())?; + /// + /// // Now we know this can't OOM in the middle of our complex work + /// output.extend(data.iter().map(|&val| { + /// val * 2 + 5 // very complicated + /// })); + /// + /// Ok(output) + /// } + /// # process_data(&[1, 2, 3]).expect("why is the test harness OOMing on 12 bytes?"); + /// ``` + #[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] + pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveError> { + self.buf.try_reserve_exact(self.len, additional) + } + + /// Shrinks the capacity of the vector as much as possible. + /// + /// It will drop down as close as possible to the length but the allocator + /// may still inform the vector that there is space for a few more elements. + /// + /// # Examples + /// + /// ``` + /// let mut vec = Vec::with_capacity(10); + /// vec.extend([1, 2, 3].iter().cloned()); + /// assert_eq!(vec.capacity(), 10); + /// vec.shrink_to_fit(); + /// assert!(vec.capacity() >= 3); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn shrink_to_fit(&mut self) { + // The capacity is never less than the length, and there's nothing to do when + // they are equal, so we can avoid the panic case in `RawVec::shrink_to_fit` + // by only calling it with a greater capacity. + if self.capacity() > self.len { + self.buf.shrink_to_fit(self.len); + } + } + + /// Shrinks the capacity of the vector with a lower bound. + /// + /// The capacity will remain at least as large as both the length + /// and the supplied value. + /// + /// # Panics + /// + /// Panics if the current capacity is smaller than the supplied + /// minimum capacity. + /// + /// # Examples + /// + /// ``` + /// #![feature(shrink_to)] + /// let mut vec = Vec::with_capacity(10); + /// vec.extend([1, 2, 3].iter().cloned()); + /// assert_eq!(vec.capacity(), 10); + /// vec.shrink_to(4); + /// assert!(vec.capacity() >= 4); + /// vec.shrink_to(0); + /// assert!(vec.capacity() >= 3); + /// ``` + #[unstable(feature = "shrink_to", reason = "new API", issue = "56431")] + pub fn shrink_to(&mut self, min_capacity: usize) { + self.buf.shrink_to_fit(cmp::max(self.len, min_capacity)); + } + + /// Converts the vector into [`Box<[T]>`][owned slice]. + /// + /// Note that this will drop any excess capacity. + /// + /// [owned slice]: Box + /// + /// # Examples + /// + /// ``` + /// let v = vec![1, 2, 3]; + /// + /// let slice = v.into_boxed_slice(); + /// ``` + /// + /// Any excess capacity is removed: + /// + /// ``` + /// let mut vec = Vec::with_capacity(10); + /// vec.extend([1, 2, 3].iter().cloned()); + /// + /// assert_eq!(vec.capacity(), 10); + /// let slice = vec.into_boxed_slice(); + /// assert_eq!(slice.into_vec().capacity(), 3); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn into_boxed_slice(mut self) -> Box<[T]> { + unsafe { + self.shrink_to_fit(); + let me = ManuallyDrop::new(self); + let buf = ptr::read(&me.buf); + let len = me.len(); + buf.into_box(len).assume_init() + } + } + + /// Shortens the vector, keeping the first `len` elements and dropping + /// the rest. + /// + /// If `len` is greater than the vector's current length, this has no + /// effect. + /// + /// The [`drain`] method can emulate `truncate`, but causes the excess + /// elements to be returned instead of dropped. + /// + /// Note that this method has no effect on the allocated capacity + /// of the vector. + /// + /// # Examples + /// + /// Truncating a five element vector to two elements: + /// + /// ``` + /// let mut vec = vec![1, 2, 3, 4, 5]; + /// vec.truncate(2); + /// assert_eq!(vec, [1, 2]); + /// ``` + /// + /// No truncation occurs when `len` is greater than the vector's current + /// length: + /// + /// ``` + /// let mut vec = vec![1, 2, 3]; + /// vec.truncate(8); + /// assert_eq!(vec, [1, 2, 3]); + /// ``` + /// + /// Truncating when `len == 0` is equivalent to calling the [`clear`] + /// method. + /// + /// ``` + /// let mut vec = vec![1, 2, 3]; + /// vec.truncate(0); + /// assert_eq!(vec, []); + /// ``` + /// + /// [`clear`]: Vec::clear + /// [`drain`]: Vec::drain + #[stable(feature = "rust1", since = "1.0.0")] + pub fn truncate(&mut self, len: usize) { + // This is safe because: + // + // * the slice passed to `drop_in_place` is valid; the `len > self.len` + // case avoids creating an invalid slice, and + // * the `len` of the vector is shrunk before calling `drop_in_place`, + // such that no value will be dropped twice in case `drop_in_place` + // were to panic once (if it panics twice, the program aborts). + unsafe { + if len > self.len { + return; + } + let remaining_len = self.len - len; + let s = ptr::slice_from_raw_parts_mut(self.as_mut_ptr().add(len), remaining_len); + self.len = len; + ptr::drop_in_place(s); + } + } + + /// Extracts a slice containing the entire vector. + /// + /// Equivalent to `&s[..]`. + /// + /// # Examples + /// + /// ``` + /// use std::io::{self, Write}; + /// let buffer = vec![1, 2, 3, 5, 8]; + /// io::sink().write(buffer.as_slice()).unwrap(); + /// ``` + #[inline] + #[stable(feature = "vec_as_slice", since = "1.7.0")] + pub fn as_slice(&self) -> &[T] { + self + } + + /// Extracts a mutable slice of the entire vector. + /// + /// Equivalent to `&mut s[..]`. + /// + /// # Examples + /// + /// ``` + /// use std::io::{self, Read}; + /// let mut buffer = vec![0; 3]; + /// io::repeat(0b101).read_exact(buffer.as_mut_slice()).unwrap(); + /// ``` + #[inline] + #[stable(feature = "vec_as_slice", since = "1.7.0")] + pub fn as_mut_slice(&mut self) -> &mut [T] { + self + } + + /// Returns a raw pointer to the vector's buffer. + /// + /// The caller must ensure that the vector outlives the pointer this + /// function returns, or else it will end up pointing to garbage. + /// Modifying the vector may cause its buffer to be reallocated, + /// which would also make any pointers to it invalid. + /// + /// The caller must also ensure that the memory the pointer (non-transitively) points to + /// is never written to (except inside an `UnsafeCell`) using this pointer or any pointer + /// derived from it. If you need to mutate the contents of the slice, use [`as_mut_ptr`]. + /// + /// # Examples + /// + /// ``` + /// let x = vec![1, 2, 4]; + /// let x_ptr = x.as_ptr(); + /// + /// unsafe { + /// for i in 0..x.len() { + /// assert_eq!(*x_ptr.add(i), 1 << i); + /// } + /// } + /// ``` + /// + /// [`as_mut_ptr`]: Vec::as_mut_ptr + #[stable(feature = "vec_as_ptr", since = "1.37.0")] + #[inline] + pub fn as_ptr(&self) -> *const T { + // We shadow the slice method of the same name to avoid going through + // `deref`, which creates an intermediate reference. + let ptr = self.buf.ptr(); + unsafe { + assume(!ptr.is_null()); + } + ptr + } + + /// Returns an unsafe mutable pointer to the vector's buffer. + /// + /// The caller must ensure that the vector outlives the pointer this + /// function returns, or else it will end up pointing to garbage. + /// Modifying the vector may cause its buffer to be reallocated, + /// which would also make any pointers to it invalid. + /// + /// # Examples + /// + /// ``` + /// // Allocate vector big enough for 4 elements. + /// let size = 4; + /// let mut x: Vec = Vec::with_capacity(size); + /// let x_ptr = x.as_mut_ptr(); + /// + /// // Initialize elements via raw pointer writes, then set length. + /// unsafe { + /// for i in 0..size { + /// *x_ptr.add(i) = i as i32; + /// } + /// x.set_len(size); + /// } + /// assert_eq!(&*x, &[0,1,2,3]); + /// ``` + #[stable(feature = "vec_as_ptr", since = "1.37.0")] + #[inline] + pub fn as_mut_ptr(&mut self) -> *mut T { + // We shadow the slice method of the same name to avoid going through + // `deref_mut`, which creates an intermediate reference. + let ptr = self.buf.ptr(); + unsafe { + assume(!ptr.is_null()); + } + ptr + } + + /// Forces the length of the vector to `new_len`. + /// + /// This is a low-level operation that maintains none of the normal + /// invariants of the type. Normally changing the length of a vector + /// is done using one of the safe operations instead, such as + /// [`truncate`], [`resize`], [`extend`], or [`clear`]. + /// + /// [`truncate`]: Vec::truncate + /// [`resize`]: Vec::resize + /// [`extend`]: Extend::extend + /// [`clear`]: Vec::clear + /// + /// # Safety + /// + /// - `new_len` must be less than or equal to [`capacity()`]. + /// - The elements at `old_len..new_len` must be initialized. + /// + /// [`capacity()`]: Vec::capacity + /// + /// # Examples + /// + /// This method can be useful for situations in which the vector + /// is serving as a buffer for other code, particularly over FFI: + /// + /// ```no_run + /// # #![allow(dead_code)] + /// # // This is just a minimal skeleton for the doc example; + /// # // don't use this as a starting point for a real library. + /// # pub struct StreamWrapper { strm: *mut std::ffi::c_void } + /// # const Z_OK: i32 = 0; + /// # extern "C" { + /// # fn deflateGetDictionary( + /// # strm: *mut std::ffi::c_void, + /// # dictionary: *mut u8, + /// # dictLength: *mut usize, + /// # ) -> i32; + /// # } + /// # impl StreamWrapper { + /// pub fn get_dictionary(&self) -> Option> { + /// // Per the FFI method's docs, "32768 bytes is always enough". + /// let mut dict = Vec::with_capacity(32_768); + /// let mut dict_length = 0; + /// // SAFETY: When `deflateGetDictionary` returns `Z_OK`, it holds that: + /// // 1. `dict_length` elements were initialized. + /// // 2. `dict_length` <= the capacity (32_768) + /// // which makes `set_len` safe to call. + /// unsafe { + /// // Make the FFI call... + /// let r = deflateGetDictionary(self.strm, dict.as_mut_ptr(), &mut dict_length); + /// if r == Z_OK { + /// // ...and update the length to what was initialized. + /// dict.set_len(dict_length); + /// Some(dict) + /// } else { + /// None + /// } + /// } + /// } + /// # } + /// ``` + /// + /// While the following example is sound, there is a memory leak since + /// the inner vectors were not freed prior to the `set_len` call: + /// + /// ``` + /// let mut vec = vec![vec![1, 0, 0], + /// vec![0, 1, 0], + /// vec![0, 0, 1]]; + /// // SAFETY: + /// // 1. `old_len..0` is empty so no elements need to be initialized. + /// // 2. `0 <= capacity` always holds whatever `capacity` is. + /// unsafe { + /// vec.set_len(0); + /// } + /// ``` + /// + /// Normally, here, one would use [`clear`] instead to correctly drop + /// the contents and thus not leak memory. + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub unsafe fn set_len(&mut self, new_len: usize) { + debug_assert!(new_len <= self.capacity()); + + self.len = new_len; + } + + /// Removes an element from the vector and returns it. + /// + /// The removed element is replaced by the last element of the vector. + /// + /// This does not preserve ordering, but is O(1). + /// + /// # Panics + /// + /// Panics if `index` is out of bounds. + /// + /// # Examples + /// + /// ``` + /// let mut v = vec!["foo", "bar", "baz", "qux"]; + /// + /// assert_eq!(v.swap_remove(1), "bar"); + /// assert_eq!(v, ["foo", "qux", "baz"]); + /// + /// assert_eq!(v.swap_remove(0), "foo"); + /// assert_eq!(v, ["baz", "qux"]); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn swap_remove(&mut self, index: usize) -> T { + #[cold] + #[inline(never)] + fn assert_failed(index: usize, len: usize) -> ! { + panic!("swap_remove index (is {}) should be < len (is {})", index, len); + } + + let len = self.len(); + if index >= len { + assert_failed(index, len); + } + unsafe { + // We replace self[index] with the last element. Note that if the + // bounds check above succeeds there must be a last element (which + // can be self[index] itself). + let last = ptr::read(self.as_ptr().add(len - 1)); + let hole = self.as_mut_ptr().add(index); + self.set_len(len - 1); + ptr::replace(hole, last) + } + } + + /// Inserts an element at position `index` within the vector, shifting all + /// elements after it to the right. + /// + /// # Panics + /// + /// Panics if `index > len`. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1, 2, 3]; + /// vec.insert(1, 4); + /// assert_eq!(vec, [1, 4, 2, 3]); + /// vec.insert(4, 5); + /// assert_eq!(vec, [1, 4, 2, 3, 5]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn insert(&mut self, index: usize, element: T) { + #[cold] + #[inline(never)] + fn assert_failed(index: usize, len: usize) -> ! { + panic!("insertion index (is {}) should be <= len (is {})", index, len); + } + + let len = self.len(); + if index > len { + assert_failed(index, len); + } + + // space for the new element + if len == self.buf.capacity() { + self.reserve(1); + } + + unsafe { + // infallible + // The spot to put the new value + { + let p = self.as_mut_ptr().add(index); + // Shift everything over to make space. (Duplicating the + // `index`th element into two consecutive places.) + ptr::copy(p, p.offset(1), len - index); + // Write it in, overwriting the first copy of the `index`th + // element. + ptr::write(p, element); + } + self.set_len(len + 1); + } + } + + /// Removes and returns the element at position `index` within the vector, + /// shifting all elements after it to the left. + /// + /// # Panics + /// + /// Panics if `index` is out of bounds. + /// + /// # Examples + /// + /// ``` + /// let mut v = vec![1, 2, 3]; + /// assert_eq!(v.remove(1), 2); + /// assert_eq!(v, [1, 3]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn remove(&mut self, index: usize) -> T { + #[cold] + #[inline(never)] + fn assert_failed(index: usize, len: usize) -> ! { + panic!("removal index (is {}) should be < len (is {})", index, len); + } + + let len = self.len(); + if index >= len { + assert_failed(index, len); + } + unsafe { + // infallible + let ret; + { + // the place we are taking from. + let ptr = self.as_mut_ptr().add(index); + // copy it out, unsafely having a copy of the value on + // the stack and in the vector at the same time. + ret = ptr::read(ptr); + + // Shift everything down to fill in that spot. + ptr::copy(ptr.offset(1), ptr, len - index - 1); + } + self.set_len(len - 1); + ret + } + } + + /// Retains only the elements specified by the predicate. + /// + /// In other words, remove all elements `e` such that `f(&e)` returns `false`. + /// This method operates in place, visiting each element exactly once in the + /// original order, and preserves the order of the retained elements. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1, 2, 3, 4]; + /// vec.retain(|&x| x % 2 == 0); + /// assert_eq!(vec, [2, 4]); + /// ``` + /// + /// The exact order may be useful for tracking external state, like an index. + /// + /// ``` + /// let mut vec = vec![1, 2, 3, 4, 5]; + /// let keep = [false, true, true, false, true]; + /// let mut i = 0; + /// vec.retain(|_| (keep[i], i += 1).0); + /// assert_eq!(vec, [2, 3, 5]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn retain(&mut self, mut f: F) + where + F: FnMut(&T) -> bool, + { + let len = self.len(); + let mut del = 0; + { + let v = &mut **self; + + for i in 0..len { + if !f(&v[i]) { + del += 1; + } else if del > 0 { + v.swap(i - del, i); + } + } + } + if del > 0 { + self.truncate(len - del); + } + } + + /// Removes all but the first of consecutive elements in the vector that resolve to the same + /// key. + /// + /// If the vector is sorted, this removes all duplicates. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![10, 20, 21, 30, 20]; + /// + /// vec.dedup_by_key(|i| *i / 10); + /// + /// assert_eq!(vec, [10, 20, 30, 20]); + /// ``` + #[stable(feature = "dedup_by", since = "1.16.0")] + #[inline] + pub fn dedup_by_key(&mut self, mut key: F) + where + F: FnMut(&mut T) -> K, + K: PartialEq, + { + self.dedup_by(|a, b| key(a) == key(b)) + } + + /// Removes all but the first of consecutive elements in the vector satisfying a given equality + /// relation. + /// + /// The `same_bucket` function is passed references to two elements from the vector and + /// must determine if the elements compare equal. The elements are passed in opposite order + /// from their order in the slice, so if `same_bucket(a, b)` returns `true`, `a` is removed. + /// + /// If the vector is sorted, this removes all duplicates. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"]; + /// + /// vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b)); + /// + /// assert_eq!(vec, ["foo", "bar", "baz", "bar"]); + /// ``` + #[stable(feature = "dedup_by", since = "1.16.0")] + pub fn dedup_by(&mut self, same_bucket: F) + where + F: FnMut(&mut T, &mut T) -> bool, + { + let len = { + let (dedup, _) = self.as_mut_slice().partition_dedup_by(same_bucket); + dedup.len() + }; + self.truncate(len); + } + + /// Appends an element to the back of a collection. + /// + /// # Panics + /// + /// Panics if the new capacity exceeds `isize::MAX` bytes. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1, 2]; + /// vec.push(3); + /// assert_eq!(vec, [1, 2, 3]); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn push(&mut self, value: T) { + // This will panic or abort if we would allocate > isize::MAX bytes + // or if the length increment would overflow for zero-sized types. + if self.len == self.buf.capacity() { + self.reserve(1); + } + unsafe { + let end = self.as_mut_ptr().add(self.len); + ptr::write(end, value); + self.len += 1; + } + } + + /// Removes the last element from a vector and returns it, or [`None`] if it + /// is empty. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1, 2, 3]; + /// assert_eq!(vec.pop(), Some(3)); + /// assert_eq!(vec, [1, 2]); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn pop(&mut self) -> Option { + if self.len == 0 { + None + } else { + unsafe { + self.len -= 1; + Some(ptr::read(self.as_ptr().add(self.len()))) + } + } + } + + /// Moves all the elements of `other` into `Self`, leaving `other` empty. + /// + /// # Panics + /// + /// Panics if the number of elements in the vector overflows a `usize`. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1, 2, 3]; + /// let mut vec2 = vec![4, 5, 6]; + /// vec.append(&mut vec2); + /// assert_eq!(vec, [1, 2, 3, 4, 5, 6]); + /// assert_eq!(vec2, []); + /// ``` + #[inline] + #[stable(feature = "append", since = "1.4.0")] + pub fn append(&mut self, other: &mut Self) { + unsafe { + self.append_elements(other.as_slice() as _); + other.set_len(0); + } + } + + /// Appends elements to `Self` from other buffer. + #[inline] + unsafe fn append_elements(&mut self, other: *const [T]) { + let count = unsafe { (*other).len() }; + self.reserve(count); + let len = self.len(); + unsafe { ptr::copy_nonoverlapping(other as *const T, self.as_mut_ptr().add(len), count) }; + self.len += count; + } + + /// Creates a draining iterator that removes the specified range in the vector + /// and yields the removed items. + /// + /// When the iterator **is** dropped, all elements in the range are removed + /// from the vector, even if the iterator was not fully consumed. If the + /// iterator **is not** dropped (with [`mem::forget`] for example), it is + /// unspecified how many elements are removed. + /// + /// # Panics + /// + /// Panics if the starting point is greater than the end point or if + /// the end point is greater than the length of the vector. + /// + /// # Examples + /// + /// ``` + /// let mut v = vec![1, 2, 3]; + /// let u: Vec<_> = v.drain(1..).collect(); + /// assert_eq!(v, &[1]); + /// assert_eq!(u, &[2, 3]); + /// + /// // A full range clears the vector + /// v.drain(..); + /// assert_eq!(v, &[]); + /// ``` + #[stable(feature = "drain", since = "1.6.0")] + pub fn drain(&mut self, range: R) -> Drain<'_, T> + where + R: RangeBounds, + { + // Memory safety + // + // When the Drain is first created, it shortens the length of + // the source vector to make sure no uninitialized or moved-from elements + // are accessible at all if the Drain's destructor never gets to run. + // + // Drain will ptr::read out the values to remove. + // When finished, remaining tail of the vec is copied back to cover + // the hole, and the vector length is restored to the new length. + // + let len = self.len(); + let Range { start, end } = range.assert_len(len); + + unsafe { + // set self.vec length's to start, to be safe in case Drain is leaked + self.set_len(start); + // Use the borrow in the IterMut to indicate borrowing behavior of the + // whole Drain iterator (like &mut T). + let range_slice = slice::from_raw_parts_mut(self.as_mut_ptr().add(start), end - start); + Drain { + tail_start: end, + tail_len: len - end, + iter: range_slice.iter(), + vec: NonNull::from(self), + } + } + } + + /// Clears the vector, removing all values. + /// + /// Note that this method has no effect on the allocated capacity + /// of the vector. + /// + /// # Examples + /// + /// ``` + /// let mut v = vec![1, 2, 3]; + /// + /// v.clear(); + /// + /// assert!(v.is_empty()); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn clear(&mut self) { + self.truncate(0) + } + + /// Returns the number of elements in the vector, also referred to + /// as its 'length'. + /// + /// # Examples + /// + /// ``` + /// let a = vec![1, 2, 3]; + /// assert_eq!(a.len(), 3); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn len(&self) -> usize { + self.len + } + + /// Returns `true` if the vector contains no elements. + /// + /// # Examples + /// + /// ``` + /// let mut v = Vec::new(); + /// assert!(v.is_empty()); + /// + /// v.push(1); + /// assert!(!v.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// Splits the collection into two at the given index. + /// + /// Returns a newly allocated vector containing the elements in the range + /// `[at, len)`. After the call, the original vector will be left containing + /// the elements `[0, at)` with its previous capacity unchanged. + /// + /// # Panics + /// + /// Panics if `at > len`. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1,2,3]; + /// let vec2 = vec.split_off(1); + /// assert_eq!(vec, [1]); + /// assert_eq!(vec2, [2, 3]); + /// ``` + #[inline] + #[must_use = "use `.truncate()` if you don't need the other half"] + #[stable(feature = "split_off", since = "1.4.0")] + pub fn split_off(&mut self, at: usize) -> Self { + #[cold] + #[inline(never)] + fn assert_failed(at: usize, len: usize) -> ! { + panic!("`at` split index (is {}) should be <= len (is {})", at, len); + } + + if at > self.len() { + assert_failed(at, self.len()); + } + + if at == 0 { + // the new vector can take over the original buffer and avoid the copy + return mem::replace(self, Vec::with_capacity(self.capacity())); + } + + let other_len = self.len - at; + let mut other = Vec::with_capacity(other_len); + + // Unsafely `set_len` and copy items to `other`. + unsafe { + self.set_len(at); + other.set_len(other_len); + + ptr::copy_nonoverlapping(self.as_ptr().add(at), other.as_mut_ptr(), other.len()); + } + other + } + + /// Resizes the `Vec` in-place so that `len` is equal to `new_len`. + /// + /// If `new_len` is greater than `len`, the `Vec` is extended by the + /// difference, with each additional slot filled with the result of + /// calling the closure `f`. The return values from `f` will end up + /// in the `Vec` in the order they have been generated. + /// + /// If `new_len` is less than `len`, the `Vec` is simply truncated. + /// + /// This method uses a closure to create new values on every push. If + /// you'd rather [`Clone`] a given value, use [`Vec::resize`]. If you + /// want to use the [`Default`] trait to generate values, you can + /// pass [`Default::default`] as the second argument. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1, 2, 3]; + /// vec.resize_with(5, Default::default); + /// assert_eq!(vec, [1, 2, 3, 0, 0]); + /// + /// let mut vec = vec![]; + /// let mut p = 1; + /// vec.resize_with(4, || { p *= 2; p }); + /// assert_eq!(vec, [2, 4, 8, 16]); + /// ``` + #[stable(feature = "vec_resize_with", since = "1.33.0")] + pub fn resize_with(&mut self, new_len: usize, f: F) + where + F: FnMut() -> T, + { + let len = self.len(); + if new_len > len { + self.extend_with(new_len - len, ExtendFunc(f)); + } else { + self.truncate(new_len); + } + } + + /// Consumes and leaks the `Vec`, returning a mutable reference to the contents, + /// `&'a mut [T]`. Note that the type `T` must outlive the chosen lifetime + /// `'a`. If the type has only static references, or none at all, then this + /// may be chosen to be `'static`. + /// + /// This function is similar to the [`leak`][Box::leak] function on [`Box`] + /// except that there is no way to recover the leaked memory. + /// + /// This function is mainly useful for data that lives for the remainder of + /// the program's life. Dropping the returned reference will cause a memory + /// leak. + /// + /// # Examples + /// + /// Simple usage: + /// + /// ``` + /// let x = vec![1, 2, 3]; + /// let static_ref: &'static mut [usize] = x.leak(); + /// static_ref[0] += 1; + /// assert_eq!(static_ref, &[2, 2, 3]); + /// ``` + #[stable(feature = "vec_leak", since = "1.47.0")] + #[inline] + pub fn leak<'a>(self) -> &'a mut [T] + where + T: 'a, // Technically not needed, but kept to be explicit. + { + Box::leak(self.into_boxed_slice()) + } + + /// Returns the remaining spare capacity of the vector as a slice of + /// `MaybeUninit`. + /// + /// The returned slice can be used to fill the vector with data (e.g. by + /// reading from a file) before marking the data as initialized using the + /// [`set_len`] method. + /// + /// [`set_len`]: Vec::set_len + /// + /// # Examples + /// + /// ``` + /// #![feature(vec_spare_capacity, maybe_uninit_extra)] + /// + /// // Allocate vector big enough for 10 elements. + /// let mut v = Vec::with_capacity(10); + /// + /// // Fill in the first 3 elements. + /// let uninit = v.spare_capacity_mut(); + /// uninit[0].write(0); + /// uninit[1].write(1); + /// uninit[2].write(2); + /// + /// // Mark the first 3 elements of the vector as being initialized. + /// unsafe { + /// v.set_len(3); + /// } + /// + /// assert_eq!(&v, &[0, 1, 2]); + /// ``` + #[unstable(feature = "vec_spare_capacity", issue = "75017")] + #[inline] + pub fn spare_capacity_mut(&mut self) -> &mut [MaybeUninit] { + unsafe { + slice::from_raw_parts_mut( + self.as_mut_ptr().add(self.len) as *mut MaybeUninit, + self.buf.capacity() - self.len, + ) + } + } +} + +impl Vec { + /// Resizes the `Vec` in-place so that `len` is equal to `new_len`. + /// + /// If `new_len` is greater than `len`, the `Vec` is extended by the + /// difference, with each additional slot filled with `value`. + /// If `new_len` is less than `len`, the `Vec` is simply truncated. + /// + /// This method requires `T` to implement [`Clone`], + /// in order to be able to clone the passed value. + /// If you need more flexibility (or want to rely on [`Default`] instead of + /// [`Clone`]), use [`Vec::resize_with`]. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec!["hello"]; + /// vec.resize(3, "world"); + /// assert_eq!(vec, ["hello", "world", "world"]); + /// + /// let mut vec = vec![1, 2, 3, 4]; + /// vec.resize(2, 0); + /// assert_eq!(vec, [1, 2]); + /// ``` + #[stable(feature = "vec_resize", since = "1.5.0")] + pub fn resize(&mut self, new_len: usize, value: T) { + let len = self.len(); + + if new_len > len { + self.extend_with(new_len - len, ExtendElement(value)) + } else { + self.truncate(new_len); + } + } + + /// Clones and appends all elements in a slice to the `Vec`. + /// + /// Iterates over the slice `other`, clones each element, and then appends + /// it to this `Vec`. The `other` vector is traversed in-order. + /// + /// Note that this function is same as [`extend`] except that it is + /// specialized to work with slices instead. If and when Rust gets + /// specialization this function will likely be deprecated (but still + /// available). + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1]; + /// vec.extend_from_slice(&[2, 3, 4]); + /// assert_eq!(vec, [1, 2, 3, 4]); + /// ``` + /// + /// [`extend`]: Vec::extend + #[stable(feature = "vec_extend_from_slice", since = "1.6.0")] + pub fn extend_from_slice(&mut self, other: &[T]) { + self.spec_extend(other.iter()) + } +} + +// This code generalizes `extend_with_{element,default}`. +trait ExtendWith { + fn next(&mut self) -> T; + fn last(self) -> T; +} + +struct ExtendElement(T); +impl ExtendWith for ExtendElement { + fn next(&mut self) -> T { + self.0.clone() + } + fn last(self) -> T { + self.0 + } +} + +struct ExtendDefault; +impl ExtendWith for ExtendDefault { + fn next(&mut self) -> T { + Default::default() + } + fn last(self) -> T { + Default::default() + } +} + +struct ExtendFunc(F); +impl T> ExtendWith for ExtendFunc { + fn next(&mut self) -> T { + (self.0)() + } + fn last(mut self) -> T { + (self.0)() + } +} + +impl Vec { + /// Extend the vector by `n` values, using the given generator. + fn extend_with>(&mut self, n: usize, mut value: E) { + self.reserve(n); + + unsafe { + let mut ptr = self.as_mut_ptr().add(self.len()); + // Use SetLenOnDrop to work around bug where compiler + // may not realize the store through `ptr` through self.set_len() + // don't alias. + let mut local_len = SetLenOnDrop::new(&mut self.len); + + // Write all elements except the last one + for _ in 1..n { + ptr::write(ptr, value.next()); + ptr = ptr.offset(1); + // Increment the length in every step in case next() panics + local_len.increment_len(1); + } + + if n > 0 { + // We can write the last element directly without cloning needlessly + ptr::write(ptr, value.last()); + local_len.increment_len(1); + } + + // len set by scope guard + } + } +} + +// Set the length of the vec when the `SetLenOnDrop` value goes out of scope. +// +// The idea is: The length field in SetLenOnDrop is a local variable +// that the optimizer will see does not alias with any stores through the Vec's data +// pointer. This is a workaround for alias analysis issue #32155 +struct SetLenOnDrop<'a> { + len: &'a mut usize, + local_len: usize, +} + +impl<'a> SetLenOnDrop<'a> { + #[inline] + fn new(len: &'a mut usize) -> Self { + SetLenOnDrop { local_len: *len, len } + } + + #[inline] + fn increment_len(&mut self, increment: usize) { + self.local_len += increment; + } +} + +impl Drop for SetLenOnDrop<'_> { + #[inline] + fn drop(&mut self) { + *self.len = self.local_len; + } +} + +impl Vec { + /// Removes consecutive repeated elements in the vector according to the + /// [`PartialEq`] trait implementation. + /// + /// If the vector is sorted, this removes all duplicates. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1, 2, 2, 3, 2]; + /// + /// vec.dedup(); + /// + /// assert_eq!(vec, [1, 2, 3, 2]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn dedup(&mut self) { + self.dedup_by(|a, b| a == b) + } +} + +impl Vec { + /// Removes the first instance of `item` from the vector if the item exists. + /// + /// This method will be removed soon. + #[unstable(feature = "vec_remove_item", reason = "recently added", issue = "40062")] + #[rustc_deprecated( + reason = "Removing the first item equal to a needle is already easily possible \ + with iterators and the current Vec methods. Furthermore, having a method for \ + one particular case of removal (linear search, only the first item, no swap remove) \ + but not for others is inconsistent. This method will be removed soon.", + since = "1.46.0" + )] + pub fn remove_item(&mut self, item: &V) -> Option + where + T: PartialEq, + { + let pos = self.iter().position(|x| *x == *item)?; + Some(self.remove(pos)) + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Internal methods and functions +//////////////////////////////////////////////////////////////////////////////// + +#[doc(hidden)] +#[stable(feature = "rust1", since = "1.0.0")] +pub fn from_elem(elem: T, n: usize) -> Vec { + ::from_elem(elem, n) +} + +// Specialization trait used for Vec::from_elem +trait SpecFromElem: Sized { + fn from_elem(elem: Self, n: usize) -> Vec; +} + +impl SpecFromElem for T { + default fn from_elem(elem: Self, n: usize) -> Vec { + let mut v = Vec::with_capacity(n); + v.extend_with(n, ExtendElement(elem)); + v + } +} + +impl SpecFromElem for i8 { + #[inline] + fn from_elem(elem: i8, n: usize) -> Vec { + if elem == 0 { + return Vec { buf: RawVec::with_capacity_zeroed(n), len: n }; + } + unsafe { + let mut v = Vec::with_capacity(n); + ptr::write_bytes(v.as_mut_ptr(), elem as u8, n); + v.set_len(n); + v + } + } +} + +impl SpecFromElem for u8 { + #[inline] + fn from_elem(elem: u8, n: usize) -> Vec { + if elem == 0 { + return Vec { buf: RawVec::with_capacity_zeroed(n), len: n }; + } + unsafe { + let mut v = Vec::with_capacity(n); + ptr::write_bytes(v.as_mut_ptr(), elem, n); + v.set_len(n); + v + } + } +} + +impl SpecFromElem for T { + #[inline] + fn from_elem(elem: T, n: usize) -> Vec { + if elem.is_zero() { + return Vec { buf: RawVec::with_capacity_zeroed(n), len: n }; + } + let mut v = Vec::with_capacity(n); + v.extend_with(n, ExtendElement(elem)); + v + } +} + +#[rustc_specialization_trait] +unsafe trait IsZero { + /// Whether this value is zero + fn is_zero(&self) -> bool; +} + +macro_rules! impl_is_zero { + ($t:ty, $is_zero:expr) => { + unsafe impl IsZero for $t { + #[inline] + fn is_zero(&self) -> bool { + $is_zero(*self) + } + } + }; +} + +impl_is_zero!(i16, |x| x == 0); +impl_is_zero!(i32, |x| x == 0); +impl_is_zero!(i64, |x| x == 0); +impl_is_zero!(i128, |x| x == 0); +impl_is_zero!(isize, |x| x == 0); + +impl_is_zero!(u16, |x| x == 0); +impl_is_zero!(u32, |x| x == 0); +impl_is_zero!(u64, |x| x == 0); +impl_is_zero!(u128, |x| x == 0); +impl_is_zero!(usize, |x| x == 0); + +impl_is_zero!(bool, |x| x == false); +impl_is_zero!(char, |x| x == '\0'); + +impl_is_zero!(f32, |x: f32| x.to_bits() == 0); +impl_is_zero!(f64, |x: f64| x.to_bits() == 0); + +unsafe impl IsZero for *const T { + #[inline] + fn is_zero(&self) -> bool { + (*self).is_null() + } +} + +unsafe impl IsZero for *mut T { + #[inline] + fn is_zero(&self) -> bool { + (*self).is_null() + } +} + +// `Option<&T>` and `Option>` are guaranteed to represent `None` as null. +// For fat pointers, the bytes that would be the pointer metadata in the `Some` +// variant are padding in the `None` variant, so ignoring them and +// zero-initializing instead is ok. +// `Option<&mut T>` never implements `Clone`, so there's no need for an impl of +// `SpecFromElem`. + +unsafe impl IsZero for Option<&T> { + #[inline] + fn is_zero(&self) -> bool { + self.is_none() + } +} + +unsafe impl IsZero for Option> { + #[inline] + fn is_zero(&self) -> bool { + self.is_none() + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Common trait implementations for Vec +//////////////////////////////////////////////////////////////////////////////// + +#[stable(feature = "rust1", since = "1.0.0")] +impl ops::Deref for Vec { + type Target = [T]; + + fn deref(&self) -> &[T] { + unsafe { slice::from_raw_parts(self.as_ptr(), self.len) } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ops::DerefMut for Vec { + fn deref_mut(&mut self) -> &mut [T] { + unsafe { slice::from_raw_parts_mut(self.as_mut_ptr(), self.len) } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Vec { + #[cfg(not(test))] + fn clone(&self) -> Vec { + <[T]>::to_vec(&**self) + } + + // HACK(japaric): with cfg(test) the inherent `[T]::to_vec` method, which is + // required for this method definition, is not available. Instead use the + // `slice::to_vec` function which is only available with cfg(test) + // NB see the slice::hack module in slice.rs for more information + #[cfg(test)] + fn clone(&self) -> Vec { + crate::slice::to_vec(&**self) + } + + fn clone_from(&mut self, other: &Vec) { + other.as_slice().clone_into(self); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Hash for Vec { + #[inline] + fn hash(&self, state: &mut H) { + Hash::hash(&**self, state) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +#[rustc_on_unimplemented( + message = "vector indices are of type `usize` or ranges of `usize`", + label = "vector indices are of type `usize` or ranges of `usize`" +)] +impl> Index for Vec { + type Output = I::Output; + + #[inline] + fn index(&self, index: I) -> &Self::Output { + Index::index(&**self, index) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +#[rustc_on_unimplemented( + message = "vector indices are of type `usize` or ranges of `usize`", + label = "vector indices are of type `usize` or ranges of `usize`" +)] +impl> IndexMut for Vec { + #[inline] + fn index_mut(&mut self, index: I) -> &mut Self::Output { + IndexMut::index_mut(&mut **self, index) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl FromIterator for Vec { + #[inline] + fn from_iter>(iter: I) -> Vec { + >::from_iter(iter.into_iter()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl IntoIterator for Vec { + type Item = T; + type IntoIter = IntoIter; + + /// Creates a consuming iterator, that is, one that moves each value out of + /// the vector (from start to end). The vector cannot be used after calling + /// this. + /// + /// # Examples + /// + /// ``` + /// let v = vec!["a".to_string(), "b".to_string()]; + /// for s in v.into_iter() { + /// // s has type String, not &String + /// println!("{}", s); + /// } + /// ``` + #[inline] + fn into_iter(self) -> IntoIter { + unsafe { + let mut me = ManuallyDrop::new(self); + let begin = me.as_mut_ptr(); + let end = if mem::size_of::() == 0 { + arith_offset(begin as *const i8, me.len() as isize) as *const T + } else { + begin.add(me.len()) as *const T + }; + let cap = me.buf.capacity(); + IntoIter { + buf: NonNull::new_unchecked(begin), + phantom: PhantomData, + cap, + ptr: begin, + end, + } + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> IntoIterator for &'a Vec { + type Item = &'a T; + type IntoIter = slice::Iter<'a, T>; + + fn into_iter(self) -> slice::Iter<'a, T> { + self.iter() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> IntoIterator for &'a mut Vec { + type Item = &'a mut T; + type IntoIter = slice::IterMut<'a, T>; + + fn into_iter(self) -> slice::IterMut<'a, T> { + self.iter_mut() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Extend for Vec { + #[inline] + fn extend>(&mut self, iter: I) { + >::spec_extend(self, iter.into_iter()) + } + + #[inline] + fn extend_one(&mut self, item: T) { + self.push(item); + } + + #[inline] + fn extend_reserve(&mut self, additional: usize) { + self.reserve(additional); + } +} + +/// Specialization trait used for Vec::from_iter +/// +/// ## The delegation graph: +/// +/// ```text +/// +-------------+ +/// |FromIterator | +/// +-+-----------+ +/// | +/// v +/// +-+-------------------------------+ +---------------------+ +/// |SpecFromIter +---->+SpecFromIterNested | +/// |where I: | | |where I: | +/// | Iterator (default)----------+ | | Iterator (default) | +/// | vec::IntoIter | | | TrustedLen | +/// | SourceIterMarker---fallback-+ | | | +/// | slice::Iter | | | +/// | Iterator | +---------------------+ +/// +---------------------------------+ +/// ``` +trait SpecFromIter { + fn from_iter(iter: I) -> Self; +} + +/// Another specialization trait for Vec::from_iter +/// necessary to manually prioritize overlapping specializations +/// see [`SpecFromIter`] for details. +trait SpecFromIterNested { + fn from_iter(iter: I) -> Self; +} + +impl SpecFromIterNested for Vec +where + I: Iterator, +{ + default fn from_iter(mut iterator: I) -> Self { + // Unroll the first iteration, as the vector is going to be + // expanded on this iteration in every case when the iterable is not + // empty, but the loop in extend_desugared() is not going to see the + // vector being full in the few subsequent loop iterations. + // So we get better branch prediction. + let mut vector = match iterator.next() { + None => return Vec::new(), + Some(element) => { + let (lower, _) = iterator.size_hint(); + let mut vector = Vec::with_capacity(lower.saturating_add(1)); + unsafe { + ptr::write(vector.as_mut_ptr(), element); + vector.set_len(1); + } + vector + } + }; + // must delegate to spec_extend() since extend() itself delegates + // to spec_from for empty Vecs + as SpecExtend>::spec_extend(&mut vector, iterator); + vector + } +} + +impl SpecFromIterNested for Vec +where + I: TrustedLen, +{ + fn from_iter(iterator: I) -> Self { + let mut vector = Vec::new(); + // must delegate to spec_extend() since extend() itself delegates + // to spec_from for empty Vecs + vector.spec_extend(iterator); + vector + } +} + +impl SpecFromIter for Vec +where + I: Iterator, +{ + default fn from_iter(iterator: I) -> Self { + SpecFromIterNested::from_iter(iterator) + } +} + +// A helper struct for in-place iteration that drops the destination slice of iteration, +// i.e. the head. The source slice (the tail) is dropped by IntoIter. +struct InPlaceDrop { + inner: *mut T, + dst: *mut T, +} + +impl InPlaceDrop { + fn len(&self) -> usize { + unsafe { self.dst.offset_from(self.inner) as usize } + } +} + +impl Drop for InPlaceDrop { + #[inline] + fn drop(&mut self) { + unsafe { + ptr::drop_in_place(slice::from_raw_parts_mut(self.inner, self.len())); + } + } +} + +impl SpecFromIter> for Vec { + fn from_iter(iterator: IntoIter) -> Self { + // A common case is passing a vector into a function which immediately + // re-collects into a vector. We can short circuit this if the IntoIter + // has not been advanced at all. + // When it has been advanced We can also reuse the memory and move the data to the front. + // But we only do so when the resulting Vec wouldn't have more unused capacity + // than creating it through the generic FromIterator implementation would. That limitation + // is not strictly necessary as Vec's allocation behavior is intentionally unspecified. + // But it is a conservative choice. + let has_advanced = iterator.buf.as_ptr() as *const _ != iterator.ptr; + if !has_advanced || iterator.len() >= iterator.cap / 2 { + unsafe { + let it = ManuallyDrop::new(iterator); + if has_advanced { + ptr::copy(it.ptr, it.buf.as_ptr(), it.len()); + } + return Vec::from_raw_parts(it.buf.as_ptr(), it.len(), it.cap); + } + } + + let mut vec = Vec::new(); + // must delegate to spec_extend() since extend() itself delegates + // to spec_from for empty Vecs + vec.spec_extend(iterator); + vec + } +} + +fn write_in_place_with_drop( + src_end: *const T, +) -> impl FnMut(InPlaceDrop, T) -> Result, !> { + move |mut sink, item| { + unsafe { + // the InPlaceIterable contract cannot be verified precisely here since + // try_fold has an exclusive reference to the source pointer + // all we can do is check if it's still in range + debug_assert!(sink.dst as *const _ <= src_end, "InPlaceIterable contract violation"); + ptr::write(sink.dst, item); + sink.dst = sink.dst.add(1); + } + Ok(sink) + } +} + +/// Specialization marker for collecting an iterator pipeline into a Vec while reusing the +/// source allocation, i.e. executing the pipeline in place. +/// +/// The SourceIter parent trait is necessary for the specializing function to access the allocation +/// which is to be reused. But it is not sufficient for the specialization to be valid. See +/// additional bounds on the impl. +#[rustc_unsafe_specialization_marker] +trait SourceIterMarker: SourceIter {} + +// The std-internal SourceIter/InPlaceIterable traits are only implemented by chains of +// Adapter>> (all owned by core/std). Additional bounds +// on the adapter implementations (beyond `impl Trait for Adapter`) only depend on other +// traits already marked as specialization traits (Copy, TrustedRandomAccess, FusedIterator). +// I.e. the marker does not depend on lifetimes of user-supplied types. Modulo the Copy hole, which +// several other specializations already depend on. +impl SourceIterMarker for T where T: SourceIter + InPlaceIterable {} + +impl SpecFromIter for Vec +where + I: Iterator + SourceIterMarker, +{ + default fn from_iter(mut iterator: I) -> Self { + // Additional requirements which cannot expressed via trait bounds. We rely on const eval + // instead: + // a) no ZSTs as there would be no allocation to reuse and pointer arithmetic would panic + // b) size match as required by Alloc contract + // c) alignments match as required by Alloc contract + if mem::size_of::() == 0 + || mem::size_of::() + != mem::size_of::<<::Source as AsIntoIter>::Item>() + || mem::align_of::() + != mem::align_of::<<::Source as AsIntoIter>::Item>() + { + // fallback to more generic implementations + return SpecFromIterNested::from_iter(iterator); + } + + let (src_buf, src_ptr, dst_buf, dst_end, cap) = unsafe { + let inner = iterator.as_inner().as_into_iter(); + ( + inner.buf.as_ptr(), + inner.ptr, + inner.buf.as_ptr() as *mut T, + inner.end as *const T, + inner.cap, + ) + }; + + // use try-fold since + // - it vectorizes better for some iterator adapters + // - unlike most internal iteration methods, it only takes a &mut self + // - it lets us thread the write pointer through its innards and get it back in the end + let sink = InPlaceDrop { inner: dst_buf, dst: dst_buf }; + let sink = iterator + .try_fold::<_, _, Result<_, !>>(sink, write_in_place_with_drop(dst_end)) + .unwrap(); + // iteration succeeded, don't drop head + let dst = ManuallyDrop::new(sink).dst; + + let src = unsafe { iterator.as_inner().as_into_iter() }; + // check if SourceIter contract was upheld + // caveat: if they weren't we may not even make it to this point + debug_assert_eq!(src_buf, src.buf.as_ptr()); + // check InPlaceIterable contract. This is only possible if the iterator advanced the + // source pointer at all. If it uses unchecked access via TrustedRandomAccess + // then the source pointer will stay in its initial position and we can't use it as reference + if src.ptr != src_ptr { + debug_assert!( + dst as *const _ <= src.ptr, + "InPlaceIterable contract violation, write pointer advanced beyond read pointer" + ); + } + + // drop any remaining values at the tail of the source + src.drop_remaining(); + // but prevent drop of the allocation itself once IntoIter goes out of scope + src.forget_allocation(); + + let vec = unsafe { + let len = dst.offset_from(dst_buf) as usize; + Vec::from_raw_parts(dst_buf, len, cap) + }; + + vec + } +} + +impl<'a, T: 'a, I> SpecFromIter<&'a T, I> for Vec +where + I: Iterator, + T: Clone, +{ + default fn from_iter(iterator: I) -> Self { + SpecFromIter::from_iter(iterator.cloned()) + } +} + +impl<'a, T: 'a> SpecFromIter<&'a T, slice::Iter<'a, T>> for Vec +where + T: Copy, +{ + // reuses the extend specialization for T: Copy + fn from_iter(iterator: slice::Iter<'a, T>) -> Self { + let mut vec = Vec::new(); + // must delegate to spec_extend() since extend() itself delegates + // to spec_from for empty Vecs + vec.spec_extend(iterator); + vec + } +} + +// Specialization trait used for Vec::extend +trait SpecExtend { + fn spec_extend(&mut self, iter: I); +} + +impl SpecExtend for Vec +where + I: Iterator, +{ + default fn spec_extend(&mut self, iter: I) { + self.extend_desugared(iter) + } +} + +impl SpecExtend for Vec +where + I: TrustedLen, +{ + default fn spec_extend(&mut self, iterator: I) { + // This is the case for a TrustedLen iterator. + let (low, high) = iterator.size_hint(); + if let Some(high_value) = high { + debug_assert_eq!( + low, + high_value, + "TrustedLen iterator's size hint is not exact: {:?}", + (low, high) + ); + } + if let Some(additional) = high { + self.reserve(additional); + unsafe { + let mut ptr = self.as_mut_ptr().add(self.len()); + let mut local_len = SetLenOnDrop::new(&mut self.len); + iterator.for_each(move |element| { + ptr::write(ptr, element); + ptr = ptr.offset(1); + // NB can't overflow since we would have had to alloc the address space + local_len.increment_len(1); + }); + } + } else { + self.extend_desugared(iterator) + } + } +} + +impl SpecExtend> for Vec { + fn spec_extend(&mut self, mut iterator: IntoIter) { + unsafe { + self.append_elements(iterator.as_slice() as _); + } + iterator.ptr = iterator.end; + } +} + +impl<'a, T: 'a, I> SpecExtend<&'a T, I> for Vec +where + I: Iterator, + T: Clone, +{ + default fn spec_extend(&mut self, iterator: I) { + self.spec_extend(iterator.cloned()) + } +} + +impl<'a, T: 'a> SpecExtend<&'a T, slice::Iter<'a, T>> for Vec +where + T: Copy, +{ + fn spec_extend(&mut self, iterator: slice::Iter<'a, T>) { + let slice = iterator.as_slice(); + unsafe { self.append_elements(slice) }; + } +} + +impl Vec { + // leaf method to which various SpecFrom/SpecExtend implementations delegate when + // they have no further optimizations to apply + fn extend_desugared>(&mut self, mut iterator: I) { + // This is the case for a general iterator. + // + // This function should be the moral equivalent of: + // + // for item in iterator { + // self.push(item); + // } + while let Some(element) = iterator.next() { + let len = self.len(); + if len == self.capacity() { + let (lower, _) = iterator.size_hint(); + self.reserve(lower.saturating_add(1)); + } + unsafe { + ptr::write(self.as_mut_ptr().add(len), element); + // NB can't overflow since we would have had to alloc the address space + self.set_len(len + 1); + } + } + } + + /// Creates a splicing iterator that replaces the specified range in the vector + /// with the given `replace_with` iterator and yields the removed items. + /// `replace_with` does not need to be the same length as `range`. + /// + /// `range` is removed even if the iterator is not consumed until the end. + /// + /// It is unspecified how many elements are removed from the vector + /// if the `Splice` value is leaked. + /// + /// The input iterator `replace_with` is only consumed when the `Splice` value is dropped. + /// + /// This is optimal if: + /// + /// * The tail (elements in the vector after `range`) is empty, + /// * or `replace_with` yields fewer elements than `range`’s length + /// * or the lower bound of its `size_hint()` is exact. + /// + /// Otherwise, a temporary vector is allocated and the tail is moved twice. + /// + /// # Panics + /// + /// Panics if the starting point is greater than the end point or if + /// the end point is greater than the length of the vector. + /// + /// # Examples + /// + /// ``` + /// let mut v = vec![1, 2, 3]; + /// let new = [7, 8]; + /// let u: Vec<_> = v.splice(..2, new.iter().cloned()).collect(); + /// assert_eq!(v, &[7, 8, 3]); + /// assert_eq!(u, &[1, 2]); + /// ``` + #[inline] + #[stable(feature = "vec_splice", since = "1.21.0")] + pub fn splice(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter> + where + R: RangeBounds, + I: IntoIterator, + { + Splice { drain: self.drain(range), replace_with: replace_with.into_iter() } + } + + /// Creates an iterator which uses a closure to determine if an element should be removed. + /// + /// If the closure returns true, then the element is removed and yielded. + /// If the closure returns false, the element will remain in the vector and will not be yielded + /// by the iterator. + /// + /// Using this method is equivalent to the following code: + /// + /// ``` + /// # let some_predicate = |x: &mut i32| { *x == 2 || *x == 3 || *x == 6 }; + /// # let mut vec = vec![1, 2, 3, 4, 5, 6]; + /// let mut i = 0; + /// while i != vec.len() { + /// if some_predicate(&mut vec[i]) { + /// let val = vec.remove(i); + /// // your code here + /// } else { + /// i += 1; + /// } + /// } + /// + /// # assert_eq!(vec, vec![1, 4, 5]); + /// ``` + /// + /// But `drain_filter` is easier to use. `drain_filter` is also more efficient, + /// because it can backshift the elements of the array in bulk. + /// + /// Note that `drain_filter` also lets you mutate every element in the filter closure, + /// regardless of whether you choose to keep or remove it. + /// + /// # Examples + /// + /// Splitting an array into evens and odds, reusing the original allocation: + /// + /// ``` + /// #![feature(drain_filter)] + /// let mut numbers = vec![1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15]; + /// + /// let evens = numbers.drain_filter(|x| *x % 2 == 0).collect::>(); + /// let odds = numbers; + /// + /// assert_eq!(evens, vec![2, 4, 6, 8, 14]); + /// assert_eq!(odds, vec![1, 3, 5, 9, 11, 13, 15]); + /// ``` + #[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] + pub fn drain_filter(&mut self, filter: F) -> DrainFilter<'_, T, F> + where + F: FnMut(&mut T) -> bool, + { + let old_len = self.len(); + + // Guard against us getting leaked (leak amplification) + unsafe { + self.set_len(0); + } + + DrainFilter { vec: self, idx: 0, del: 0, old_len, pred: filter, panic_flag: false } + } +} + +/// Extend implementation that copies elements out of references before pushing them onto the Vec. +/// +/// This implementation is specialized for slice iterators, where it uses [`copy_from_slice`] to +/// append the entire slice at once. +/// +/// [`copy_from_slice`]: ../../std/primitive.slice.html#method.copy_from_slice +#[stable(feature = "extend_ref", since = "1.2.0")] +impl<'a, T: 'a + Copy> Extend<&'a T> for Vec { + fn extend>(&mut self, iter: I) { + self.spec_extend(iter.into_iter()) + } + + #[inline] + fn extend_one(&mut self, &item: &'a T) { + self.push(item); + } + + #[inline] + fn extend_reserve(&mut self, additional: usize) { + self.reserve(additional); + } +} + +macro_rules! __impl_slice_eq1 { + ([$($vars:tt)*] $lhs:ty, $rhs:ty $(where $ty:ty: $bound:ident)?, #[$stability:meta]) => { + #[$stability] + impl PartialEq<$rhs> for $lhs + where + A: PartialEq, + $($ty: $bound)? + { + #[inline] + fn eq(&self, other: &$rhs) -> bool { self[..] == other[..] } + #[inline] + fn ne(&self, other: &$rhs) -> bool { self[..] != other[..] } + } + } +} + +__impl_slice_eq1! { [] Vec, Vec, #[stable(feature = "rust1", since = "1.0.0")] } +__impl_slice_eq1! { [] Vec, &[B], #[stable(feature = "rust1", since = "1.0.0")] } +__impl_slice_eq1! { [] Vec, &mut [B], #[stable(feature = "rust1", since = "1.0.0")] } +__impl_slice_eq1! { [] &[A], Vec, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")] } +__impl_slice_eq1! { [] &mut [A], Vec, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")] } +__impl_slice_eq1! { [] Vec, [B], #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")] } +__impl_slice_eq1! { [] [A], Vec, #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")] } +__impl_slice_eq1! { [] Cow<'_, [A]>, Vec where A: Clone, #[stable(feature = "rust1", since = "1.0.0")] } +__impl_slice_eq1! { [] Cow<'_, [A]>, &[B] where A: Clone, #[stable(feature = "rust1", since = "1.0.0")] } +__impl_slice_eq1! { [] Cow<'_, [A]>, &mut [B] where A: Clone, #[stable(feature = "rust1", since = "1.0.0")] } +__impl_slice_eq1! { [const N: usize] Vec, [B; N], #[stable(feature = "rust1", since = "1.0.0")] } +__impl_slice_eq1! { [const N: usize] Vec, &[B; N], #[stable(feature = "rust1", since = "1.0.0")] } + +// NOTE: some less important impls are omitted to reduce code bloat +// FIXME(Centril): Reconsider this? +//__impl_slice_eq1! { [const N: usize] Vec, &mut [B; N], } +//__impl_slice_eq1! { [const N: usize] [A; N], Vec, } +//__impl_slice_eq1! { [const N: usize] &[A; N], Vec, } +//__impl_slice_eq1! { [const N: usize] &mut [A; N], Vec, } +//__impl_slice_eq1! { [const N: usize] Cow<'a, [A]>, [B; N], } +//__impl_slice_eq1! { [const N: usize] Cow<'a, [A]>, &[B; N], } +//__impl_slice_eq1! { [const N: usize] Cow<'a, [A]>, &mut [B; N], } + +/// Implements comparison of vectors, [lexicographically](core::cmp::Ord#lexicographical-comparison). +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialOrd for Vec { + #[inline] + fn partial_cmp(&self, other: &Vec) -> Option { + PartialOrd::partial_cmp(&**self, &**other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Eq for Vec {} + +/// Implements ordering of vectors, [lexicographically](core::cmp::Ord#lexicographical-comparison). +#[stable(feature = "rust1", since = "1.0.0")] +impl Ord for Vec { + #[inline] + fn cmp(&self, other: &Vec) -> Ordering { + Ord::cmp(&**self, &**other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl<#[may_dangle] T> Drop for Vec { + fn drop(&mut self) { + unsafe { + // use drop for [T] + // use a raw slice to refer to the elements of the vector as weakest necessary type; + // could avoid questions of validity in certain cases + ptr::drop_in_place(ptr::slice_from_raw_parts_mut(self.as_mut_ptr(), self.len)) + } + // RawVec handles deallocation + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for Vec { + /// Creates an empty `Vec`. + fn default() -> Vec { + Vec::new() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Debug for Vec { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Debug::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl AsRef> for Vec { + fn as_ref(&self) -> &Vec { + self + } +} + +#[stable(feature = "vec_as_mut", since = "1.5.0")] +impl AsMut> for Vec { + fn as_mut(&mut self) -> &mut Vec { + self + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl AsRef<[T]> for Vec { + fn as_ref(&self) -> &[T] { + self + } +} + +#[stable(feature = "vec_as_mut", since = "1.5.0")] +impl AsMut<[T]> for Vec { + fn as_mut(&mut self) -> &mut [T] { + self + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl From<&[T]> for Vec { + #[cfg(not(test))] + fn from(s: &[T]) -> Vec { + s.to_vec() + } + #[cfg(test)] + fn from(s: &[T]) -> Vec { + crate::slice::to_vec(s) + } +} + +#[stable(feature = "vec_from_mut", since = "1.19.0")] +impl From<&mut [T]> for Vec { + #[cfg(not(test))] + fn from(s: &mut [T]) -> Vec { + s.to_vec() + } + #[cfg(test)] + fn from(s: &mut [T]) -> Vec { + crate::slice::to_vec(s) + } +} + +#[stable(feature = "vec_from_array", since = "1.44.0")] +impl From<[T; N]> for Vec { + #[cfg(not(test))] + fn from(s: [T; N]) -> Vec { + <[T]>::into_vec(box s) + } + #[cfg(test)] + fn from(s: [T; N]) -> Vec { + crate::slice::into_vec(box s) + } +} + +#[stable(feature = "vec_from_cow_slice", since = "1.14.0")] +impl<'a, T> From> for Vec +where + [T]: ToOwned>, +{ + fn from(s: Cow<'a, [T]>) -> Vec { + s.into_owned() + } +} + +// note: test pulls in libstd, which causes errors here +#[cfg(not(test))] +#[stable(feature = "vec_from_box", since = "1.18.0")] +impl From> for Vec { + fn from(s: Box<[T]>) -> Vec { + s.into_vec() + } +} + +// note: test pulls in libstd, which causes errors here +#[cfg(not(test))] +#[stable(feature = "box_from_vec", since = "1.20.0")] +impl From> for Box<[T]> { + fn from(v: Vec) -> Box<[T]> { + v.into_boxed_slice() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl From<&str> for Vec { + fn from(s: &str) -> Vec { + From::from(s.as_bytes()) + } +} + +#[stable(feature = "array_try_from_vec", since = "1.48.0")] +impl TryFrom> for [T; N] { + type Error = Vec; + + /// Gets the entire contents of the `Vec` as an array, + /// if its size exactly matches that of the requested array. + /// + /// # Examples + /// + /// ``` + /// use std::convert::TryInto; + /// assert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3])); + /// assert_eq!(>::new().try_into(), Ok([])); + /// ``` + /// + /// If the length doesn't match, the input comes back in `Err`: + /// ``` + /// use std::convert::TryInto; + /// let r: Result<[i32; 4], _> = (0..10).collect::>().try_into(); + /// assert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9])); + /// ``` + /// + /// If you're fine with just getting a prefix of the `Vec`, + /// you can call [`.truncate(N)`](Vec::truncate) first. + /// ``` + /// use std::convert::TryInto; + /// let mut v = String::from("hello world").into_bytes(); + /// v.sort(); + /// v.truncate(2); + /// let [a, b]: [_; 2] = v.try_into().unwrap(); + /// assert_eq!(a, b' '); + /// assert_eq!(b, b'd'); + /// ``` + fn try_from(mut vec: Vec) -> Result<[T; N], Vec> { + if vec.len() != N { + return Err(vec); + } + + // SAFETY: `.set_len(0)` is always sound. + unsafe { vec.set_len(0) }; + + // SAFETY: A `Vec`'s pointer is always aligned properly, and + // the alignment the array needs is the same as the items. + // We checked earlier that we have sufficient items. + // The items will not double-drop as the `set_len` + // tells the `Vec` not to also drop them. + let array = unsafe { ptr::read(vec.as_ptr() as *const [T; N]) }; + Ok(array) + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Clone-on-write +//////////////////////////////////////////////////////////////////////////////// + +#[stable(feature = "cow_from_vec", since = "1.8.0")] +impl<'a, T: Clone> From<&'a [T]> for Cow<'a, [T]> { + fn from(s: &'a [T]) -> Cow<'a, [T]> { + Cow::Borrowed(s) + } +} + +#[stable(feature = "cow_from_vec", since = "1.8.0")] +impl<'a, T: Clone> From> for Cow<'a, [T]> { + fn from(v: Vec) -> Cow<'a, [T]> { + Cow::Owned(v) + } +} + +#[stable(feature = "cow_from_vec_ref", since = "1.28.0")] +impl<'a, T: Clone> From<&'a Vec> for Cow<'a, [T]> { + fn from(v: &'a Vec) -> Cow<'a, [T]> { + Cow::Borrowed(v.as_slice()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> FromIterator for Cow<'a, [T]> +where + T: Clone, +{ + fn from_iter>(it: I) -> Cow<'a, [T]> { + Cow::Owned(FromIterator::from_iter(it)) + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Iterators +//////////////////////////////////////////////////////////////////////////////// + +/// An iterator that moves out of a vector. +/// +/// This `struct` is created by the `into_iter` method on [`Vec`] (provided +/// by the [`IntoIterator`] trait). +/// +/// # Example +/// +/// ``` +/// let v = vec![0, 1, 2]; +/// let iter: std::vec::IntoIter<_> = v.into_iter(); +/// ``` +#[stable(feature = "rust1", since = "1.0.0")] +pub struct IntoIter { + buf: NonNull, + phantom: PhantomData, + cap: usize, + ptr: *const T, + end: *const T, +} + +#[stable(feature = "vec_intoiter_debug", since = "1.13.0")] +impl fmt::Debug for IntoIter { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("IntoIter").field(&self.as_slice()).finish() + } +} + +impl IntoIter { + /// Returns the remaining items of this iterator as a slice. + /// + /// # Examples + /// + /// ``` + /// let vec = vec!['a', 'b', 'c']; + /// let mut into_iter = vec.into_iter(); + /// assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']); + /// let _ = into_iter.next().unwrap(); + /// assert_eq!(into_iter.as_slice(), &['b', 'c']); + /// ``` + #[stable(feature = "vec_into_iter_as_slice", since = "1.15.0")] + pub fn as_slice(&self) -> &[T] { + unsafe { slice::from_raw_parts(self.ptr, self.len()) } + } + + /// Returns the remaining items of this iterator as a mutable slice. + /// + /// # Examples + /// + /// ``` + /// let vec = vec!['a', 'b', 'c']; + /// let mut into_iter = vec.into_iter(); + /// assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']); + /// into_iter.as_mut_slice()[2] = 'z'; + /// assert_eq!(into_iter.next().unwrap(), 'a'); + /// assert_eq!(into_iter.next().unwrap(), 'b'); + /// assert_eq!(into_iter.next().unwrap(), 'z'); + /// ``` + #[stable(feature = "vec_into_iter_as_slice", since = "1.15.0")] + pub fn as_mut_slice(&mut self) -> &mut [T] { + unsafe { &mut *self.as_raw_mut_slice() } + } + + fn as_raw_mut_slice(&mut self) -> *mut [T] { + ptr::slice_from_raw_parts_mut(self.ptr as *mut T, self.len()) + } + + fn drop_remaining(&mut self) { + unsafe { + ptr::drop_in_place(self.as_mut_slice()); + } + self.ptr = self.end; + } + + /// Relinquishes the backing allocation, equivalent to + /// `ptr::write(&mut self, Vec::new().into_iter())` + fn forget_allocation(&mut self) { + self.cap = 0; + self.buf = unsafe { NonNull::new_unchecked(RawVec::NEW.ptr()) }; + self.ptr = self.buf.as_ptr(); + self.end = self.buf.as_ptr(); + } +} + +#[stable(feature = "vec_intoiter_as_ref", since = "1.46.0")] +impl AsRef<[T]> for IntoIter { + fn as_ref(&self) -> &[T] { + self.as_slice() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Send for IntoIter {} +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Sync for IntoIter {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Iterator for IntoIter { + type Item = T; + + #[inline] + fn next(&mut self) -> Option { + if self.ptr as *const _ == self.end { + None + } else if mem::size_of::() == 0 { + // purposefully don't use 'ptr.offset' because for + // vectors with 0-size elements this would return the + // same pointer. + self.ptr = unsafe { arith_offset(self.ptr as *const i8, 1) as *mut T }; + + // Make up a value of this ZST. + Some(unsafe { mem::zeroed() }) + } else { + let old = self.ptr; + self.ptr = unsafe { self.ptr.offset(1) }; + + Some(unsafe { ptr::read(old) }) + } + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + let exact = if mem::size_of::() == 0 { + (self.end as usize).wrapping_sub(self.ptr as usize) + } else { + unsafe { self.end.offset_from(self.ptr) as usize } + }; + (exact, Some(exact)) + } + + #[inline] + fn count(self) -> usize { + self.len() + } + + unsafe fn __iterator_get_unchecked(&mut self, i: usize) -> Self::Item + where + Self: TrustedRandomAccess, + { + // SAFETY: the caller must guarantee that `i` is in bounds of the + // `Vec`, so `i` cannot overflow an `isize`, and the `self.ptr.add(i)` + // is guaranteed to pointer to an element of the `Vec` and + // thus guaranteed to be valid to dereference. + // + // Also note the implementation of `Self: TrustedRandomAccess` requires + // that `T: Copy` so reading elements from the buffer doesn't invalidate + // them for `Drop`. + unsafe { + if mem::size_of::() == 0 { mem::zeroed() } else { ptr::read(self.ptr.add(i)) } + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl DoubleEndedIterator for IntoIter { + #[inline] + fn next_back(&mut self) -> Option { + if self.end == self.ptr { + None + } else if mem::size_of::() == 0 { + // See above for why 'ptr.offset' isn't used + self.end = unsafe { arith_offset(self.end as *const i8, -1) as *mut T }; + + // Make up a value of this ZST. + Some(unsafe { mem::zeroed() }) + } else { + self.end = unsafe { self.end.offset(-1) }; + + Some(unsafe { ptr::read(self.end) }) + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for IntoIter { + fn is_empty(&self) -> bool { + self.ptr == self.end + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for IntoIter {} + +#[unstable(feature = "trusted_len", issue = "37572")] +unsafe impl TrustedLen for IntoIter {} + +#[doc(hidden)] +#[unstable(issue = "none", feature = "std_internals")] +// T: Copy as approximation for !Drop since get_unchecked does not advance self.ptr +// and thus we can't implement drop-handling +unsafe impl TrustedRandomAccess for IntoIter +where + T: Copy, +{ + fn may_have_side_effect() -> bool { + false + } +} + +#[stable(feature = "vec_into_iter_clone", since = "1.8.0")] +impl Clone for IntoIter { + fn clone(&self) -> IntoIter { + self.as_slice().to_owned().into_iter() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl<#[may_dangle] T> Drop for IntoIter { + fn drop(&mut self) { + struct DropGuard<'a, T>(&'a mut IntoIter); + + impl Drop for DropGuard<'_, T> { + fn drop(&mut self) { + // RawVec handles deallocation + let _ = unsafe { RawVec::from_raw_parts(self.0.buf.as_ptr(), self.0.cap) }; + } + } + + let guard = DropGuard(self); + // destroy the remaining elements + unsafe { + ptr::drop_in_place(guard.0.as_raw_mut_slice()); + } + // now `guard` will be dropped and do the rest + } +} + +#[unstable(issue = "none", feature = "inplace_iteration")] +unsafe impl InPlaceIterable for IntoIter {} + +#[unstable(issue = "none", feature = "inplace_iteration")] +unsafe impl SourceIter for IntoIter { + type Source = IntoIter; + + #[inline] + unsafe fn as_inner(&mut self) -> &mut Self::Source { + self + } +} + +// internal helper trait for in-place iteration specialization. +#[rustc_specialization_trait] +pub(crate) trait AsIntoIter { + type Item; + fn as_into_iter(&mut self) -> &mut IntoIter; +} + +impl AsIntoIter for IntoIter { + type Item = T; + + fn as_into_iter(&mut self) -> &mut IntoIter { + self + } +} + +/// A draining iterator for `Vec`. +/// +/// This `struct` is created by [`Vec::drain`]. +/// See its documentation for more. +/// +/// # Example +/// +/// ``` +/// let mut v = vec![0, 1, 2]; +/// let iter: std::vec::Drain<_> = v.drain(..); +/// ``` +#[stable(feature = "drain", since = "1.6.0")] +pub struct Drain<'a, T: 'a> { + /// Index of tail to preserve + tail_start: usize, + /// Length of tail + tail_len: usize, + /// Current remaining range to remove + iter: slice::Iter<'a, T>, + vec: NonNull>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Drain<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Drain").field(&self.iter.as_slice()).finish() + } +} + +impl<'a, T> Drain<'a, T> { + /// Returns the remaining items of this iterator as a slice. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec!['a', 'b', 'c']; + /// let mut drain = vec.drain(..); + /// assert_eq!(drain.as_slice(), &['a', 'b', 'c']); + /// let _ = drain.next().unwrap(); + /// assert_eq!(drain.as_slice(), &['b', 'c']); + /// ``` + #[stable(feature = "vec_drain_as_slice", since = "1.46.0")] + pub fn as_slice(&self) -> &[T] { + self.iter.as_slice() + } +} + +#[stable(feature = "vec_drain_as_slice", since = "1.46.0")] +impl<'a, T> AsRef<[T]> for Drain<'a, T> { + fn as_ref(&self) -> &[T] { + self.as_slice() + } +} + +#[stable(feature = "drain", since = "1.6.0")] +unsafe impl Sync for Drain<'_, T> {} +#[stable(feature = "drain", since = "1.6.0")] +unsafe impl Send for Drain<'_, T> {} + +#[stable(feature = "drain", since = "1.6.0")] +impl Iterator for Drain<'_, T> { + type Item = T; + + #[inline] + fn next(&mut self) -> Option { + self.iter.next().map(|elt| unsafe { ptr::read(elt as *const _) }) + } + + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } +} + +#[stable(feature = "drain", since = "1.6.0")] +impl DoubleEndedIterator for Drain<'_, T> { + #[inline] + fn next_back(&mut self) -> Option { + self.iter.next_back().map(|elt| unsafe { ptr::read(elt as *const _) }) + } +} + +#[stable(feature = "drain", since = "1.6.0")] +impl Drop for Drain<'_, T> { + fn drop(&mut self) { + /// Continues dropping the remaining elements in the `Drain`, then moves back the + /// un-`Drain`ed elements to restore the original `Vec`. + struct DropGuard<'r, 'a, T>(&'r mut Drain<'a, T>); + + impl<'r, 'a, T> Drop for DropGuard<'r, 'a, T> { + fn drop(&mut self) { + // Continue the same loop we have below. If the loop already finished, this does + // nothing. + self.0.for_each(drop); + + if self.0.tail_len > 0 { + unsafe { + let source_vec = self.0.vec.as_mut(); + // memmove back untouched tail, update to new length + let start = source_vec.len(); + let tail = self.0.tail_start; + if tail != start { + let src = source_vec.as_ptr().add(tail); + let dst = source_vec.as_mut_ptr().add(start); + ptr::copy(src, dst, self.0.tail_len); + } + source_vec.set_len(start + self.0.tail_len); + } + } + } + } + + // exhaust self first + while let Some(item) = self.next() { + let guard = DropGuard(self); + drop(item); + mem::forget(guard); + } + + // Drop a `DropGuard` to move back the non-drained tail of `self`. + DropGuard(self); + } +} + +#[stable(feature = "drain", since = "1.6.0")] +impl ExactSizeIterator for Drain<'_, T> { + fn is_empty(&self) -> bool { + self.iter.is_empty() + } +} + +#[unstable(feature = "trusted_len", issue = "37572")] +unsafe impl TrustedLen for Drain<'_, T> {} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Drain<'_, T> {} + +/// A splicing iterator for `Vec`. +/// +/// This struct is created by [`Vec::splice()`]. +/// See its documentation for more. +/// +/// # Example +/// +/// ``` +/// let mut v = vec![0, 1, 2]; +/// let new = [7, 8]; +/// let iter: std::vec::Splice<_> = v.splice(1.., new.iter().cloned()); +/// ``` +#[derive(Debug)] +#[stable(feature = "vec_splice", since = "1.21.0")] +pub struct Splice<'a, I: Iterator + 'a> { + drain: Drain<'a, I::Item>, + replace_with: I, +} + +#[stable(feature = "vec_splice", since = "1.21.0")] +impl Iterator for Splice<'_, I> { + type Item = I::Item; + + fn next(&mut self) -> Option { + self.drain.next() + } + + fn size_hint(&self) -> (usize, Option) { + self.drain.size_hint() + } +} + +#[stable(feature = "vec_splice", since = "1.21.0")] +impl DoubleEndedIterator for Splice<'_, I> { + fn next_back(&mut self) -> Option { + self.drain.next_back() + } +} + +#[stable(feature = "vec_splice", since = "1.21.0")] +impl ExactSizeIterator for Splice<'_, I> {} + +#[stable(feature = "vec_splice", since = "1.21.0")] +impl Drop for Splice<'_, I> { + fn drop(&mut self) { + self.drain.by_ref().for_each(drop); + + unsafe { + if self.drain.tail_len == 0 { + self.drain.vec.as_mut().extend(self.replace_with.by_ref()); + return; + } + + // First fill the range left by drain(). + if !self.drain.fill(&mut self.replace_with) { + return; + } + + // There may be more elements. Use the lower bound as an estimate. + // FIXME: Is the upper bound a better guess? Or something else? + let (lower_bound, _upper_bound) = self.replace_with.size_hint(); + if lower_bound > 0 { + self.drain.move_tail(lower_bound); + if !self.drain.fill(&mut self.replace_with) { + return; + } + } + + // Collect any remaining elements. + // This is a zero-length vector which does not allocate if `lower_bound` was exact. + let mut collected = self.replace_with.by_ref().collect::>().into_iter(); + // Now we have an exact count. + if collected.len() > 0 { + self.drain.move_tail(collected.len()); + let filled = self.drain.fill(&mut collected); + debug_assert!(filled); + debug_assert_eq!(collected.len(), 0); + } + } + // Let `Drain::drop` move the tail back if necessary and restore `vec.len`. + } +} + +/// Private helper methods for `Splice::drop` +impl Drain<'_, T> { + /// The range from `self.vec.len` to `self.tail_start` contains elements + /// that have been moved out. + /// Fill that range as much as possible with new elements from the `replace_with` iterator. + /// Returns `true` if we filled the entire range. (`replace_with.next()` didn’t return `None`.) + unsafe fn fill>(&mut self, replace_with: &mut I) -> bool { + let vec = unsafe { self.vec.as_mut() }; + let range_start = vec.len; + let range_end = self.tail_start; + let range_slice = unsafe { + slice::from_raw_parts_mut(vec.as_mut_ptr().add(range_start), range_end - range_start) + }; + + for place in range_slice { + if let Some(new_item) = replace_with.next() { + unsafe { ptr::write(place, new_item) }; + vec.len += 1; + } else { + return false; + } + } + true + } + + /// Makes room for inserting more elements before the tail. + unsafe fn move_tail(&mut self, additional: usize) { + let vec = unsafe { self.vec.as_mut() }; + let len = self.tail_start + self.tail_len; + vec.buf.reserve(len, additional); + + let new_tail_start = self.tail_start + additional; + unsafe { + let src = vec.as_ptr().add(self.tail_start); + let dst = vec.as_mut_ptr().add(new_tail_start); + ptr::copy(src, dst, self.tail_len); + } + self.tail_start = new_tail_start; + } +} + +/// An iterator which uses a closure to determine if an element should be removed. +/// +/// This struct is created by [`Vec::drain_filter`]. +/// See its documentation for more. +/// +/// # Example +/// +/// ``` +/// #![feature(drain_filter)] +/// +/// let mut v = vec![0, 1, 2]; +/// let iter: std::vec::DrainFilter<_, _> = v.drain_filter(|x| *x % 2 == 0); +/// ``` +#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] +#[derive(Debug)] +pub struct DrainFilter<'a, T, F> +where + F: FnMut(&mut T) -> bool, +{ + vec: &'a mut Vec, + /// The index of the item that will be inspected by the next call to `next`. + idx: usize, + /// The number of items that have been drained (removed) thus far. + del: usize, + /// The original length of `vec` prior to draining. + old_len: usize, + /// The filter test predicate. + pred: F, + /// A flag that indicates a panic has occurred in the filter test predicate. + /// This is used as a hint in the drop implementation to prevent consumption + /// of the remainder of the `DrainFilter`. Any unprocessed items will be + /// backshifted in the `vec`, but no further items will be dropped or + /// tested by the filter predicate. + panic_flag: bool, +} + +#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] +impl Iterator for DrainFilter<'_, T, F> +where + F: FnMut(&mut T) -> bool, +{ + type Item = T; + + fn next(&mut self) -> Option { + unsafe { + while self.idx < self.old_len { + let i = self.idx; + let v = slice::from_raw_parts_mut(self.vec.as_mut_ptr(), self.old_len); + self.panic_flag = true; + let drained = (self.pred)(&mut v[i]); + self.panic_flag = false; + // Update the index *after* the predicate is called. If the index + // is updated prior and the predicate panics, the element at this + // index would be leaked. + self.idx += 1; + if drained { + self.del += 1; + return Some(ptr::read(&v[i])); + } else if self.del > 0 { + let del = self.del; + let src: *const T = &v[i]; + let dst: *mut T = &mut v[i - del]; + ptr::copy_nonoverlapping(src, dst, 1); + } + } + None + } + } + + fn size_hint(&self) -> (usize, Option) { + (0, Some(self.old_len - self.idx)) + } +} + +#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] +impl Drop for DrainFilter<'_, T, F> +where + F: FnMut(&mut T) -> bool, +{ + fn drop(&mut self) { + struct BackshiftOnDrop<'a, 'b, T, F> + where + F: FnMut(&mut T) -> bool, + { + drain: &'b mut DrainFilter<'a, T, F>, + } + + impl<'a, 'b, T, F> Drop for BackshiftOnDrop<'a, 'b, T, F> + where + F: FnMut(&mut T) -> bool, + { + fn drop(&mut self) { + unsafe { + if self.drain.idx < self.drain.old_len && self.drain.del > 0 { + // This is a pretty messed up state, and there isn't really an + // obviously right thing to do. We don't want to keep trying + // to execute `pred`, so we just backshift all the unprocessed + // elements and tell the vec that they still exist. The backshift + // is required to prevent a double-drop of the last successfully + // drained item prior to a panic in the predicate. + let ptr = self.drain.vec.as_mut_ptr(); + let src = ptr.add(self.drain.idx); + let dst = src.sub(self.drain.del); + let tail_len = self.drain.old_len - self.drain.idx; + src.copy_to(dst, tail_len); + } + self.drain.vec.set_len(self.drain.old_len - self.drain.del); + } + } + } + + let backshift = BackshiftOnDrop { drain: self }; + + // Attempt to consume any remaining elements if the filter predicate + // has not yet panicked. We'll backshift any remaining elements + // whether we've already panicked or if the consumption here panics. + if !backshift.drain.panic_flag { + backshift.drain.for_each(drop); + } + } +} diff --git a/libgrust/rustc-lib/alloc/tests/arc.rs b/libgrust/rustc-lib/alloc/tests/arc.rs new file mode 100644 index 000000000000..c02ba267056d --- /dev/null +++ b/libgrust/rustc-lib/alloc/tests/arc.rs @@ -0,0 +1,197 @@ +use std::any::Any; +use std::cell::RefCell; +use std::cmp::PartialEq; +use std::iter::TrustedLen; +use std::mem; +use std::sync::{Arc, Weak}; + +#[test] +fn uninhabited() { + enum Void {} + let mut a = Weak::::new(); + a = a.clone(); + assert!(a.upgrade().is_none()); + + let mut a: Weak = a; // Unsizing + a = a.clone(); + assert!(a.upgrade().is_none()); +} + +#[test] +fn slice() { + let a: Arc<[u32; 3]> = Arc::new([3, 2, 1]); + let a: Arc<[u32]> = a; // Unsizing + let b: Arc<[u32]> = Arc::from(&[3, 2, 1][..]); // Conversion + assert_eq!(a, b); + + // Exercise is_dangling() with a DST + let mut a = Arc::downgrade(&a); + a = a.clone(); + assert!(a.upgrade().is_some()); +} + +#[test] +fn trait_object() { + let a: Arc = Arc::new(4); + let a: Arc = a; // Unsizing + + // Exercise is_dangling() with a DST + let mut a = Arc::downgrade(&a); + a = a.clone(); + assert!(a.upgrade().is_some()); + + let mut b = Weak::::new(); + b = b.clone(); + assert!(b.upgrade().is_none()); + let mut b: Weak = b; // Unsizing + b = b.clone(); + assert!(b.upgrade().is_none()); +} + +#[test] +fn float_nan_ne() { + let x = Arc::new(f32::NAN); + assert!(x != x); + assert!(!(x == x)); +} + +#[test] +fn partial_eq() { + struct TestPEq(RefCell); + impl PartialEq for TestPEq { + fn eq(&self, other: &TestPEq) -> bool { + *self.0.borrow_mut() += 1; + *other.0.borrow_mut() += 1; + true + } + } + let x = Arc::new(TestPEq(RefCell::new(0))); + assert!(x == x); + assert!(!(x != x)); + assert_eq!(*x.0.borrow(), 4); +} + +#[test] +fn eq() { + #[derive(Eq)] + struct TestEq(RefCell); + impl PartialEq for TestEq { + fn eq(&self, other: &TestEq) -> bool { + *self.0.borrow_mut() += 1; + *other.0.borrow_mut() += 1; + true + } + } + let x = Arc::new(TestEq(RefCell::new(0))); + assert!(x == x); + assert!(!(x != x)); + assert_eq!(*x.0.borrow(), 0); +} + +// The test code below is identical to that in `rc.rs`. +// For better maintainability we therefore define this type alias. +type Rc = Arc; + +const SHARED_ITER_MAX: u16 = 100; + +fn assert_trusted_len(_: &I) {} + +#[test] +fn shared_from_iter_normal() { + // Exercise the base implementation for non-`TrustedLen` iterators. + { + // `Filter` is never `TrustedLen` since we don't + // know statically how many elements will be kept: + let iter = (0..SHARED_ITER_MAX).filter(|x| x % 2 == 0).map(Box::new); + + // Collecting into a `Vec` or `Rc<[T]>` should make no difference: + let vec = iter.clone().collect::>(); + let rc = iter.collect::>(); + assert_eq!(&*vec, &*rc); + + // Clone a bit and let these get dropped. + { + let _rc_2 = rc.clone(); + let _rc_3 = rc.clone(); + let _rc_4 = Rc::downgrade(&_rc_3); + } + } // Drop what hasn't been here. +} + +#[test] +fn shared_from_iter_trustedlen_normal() { + // Exercise the `TrustedLen` implementation under normal circumstances + // where `size_hint()` matches `(_, Some(exact_len))`. + { + let iter = (0..SHARED_ITER_MAX).map(Box::new); + assert_trusted_len(&iter); + + // Collecting into a `Vec` or `Rc<[T]>` should make no difference: + let vec = iter.clone().collect::>(); + let rc = iter.collect::>(); + assert_eq!(&*vec, &*rc); + assert_eq!(mem::size_of::>() * SHARED_ITER_MAX as usize, mem::size_of_val(&*rc)); + + // Clone a bit and let these get dropped. + { + let _rc_2 = rc.clone(); + let _rc_3 = rc.clone(); + let _rc_4 = Rc::downgrade(&_rc_3); + } + } // Drop what hasn't been here. + + // Try a ZST to make sure it is handled well. + { + let iter = (0..SHARED_ITER_MAX).map(drop); + let vec = iter.clone().collect::>(); + let rc = iter.collect::>(); + assert_eq!(&*vec, &*rc); + assert_eq!(0, mem::size_of_val(&*rc)); + { + let _rc_2 = rc.clone(); + let _rc_3 = rc.clone(); + let _rc_4 = Rc::downgrade(&_rc_3); + } + } +} + +#[test] +#[should_panic = "I've almost got 99 problems."] +fn shared_from_iter_trustedlen_panic() { + // Exercise the `TrustedLen` implementation when `size_hint()` matches + // `(_, Some(exact_len))` but where `.next()` drops before the last iteration. + let iter = (0..SHARED_ITER_MAX).map(|val| match val { + 98 => panic!("I've almost got 99 problems."), + _ => Box::new(val), + }); + assert_trusted_len(&iter); + let _ = iter.collect::>(); + + panic!("I am unreachable."); +} + +#[test] +fn shared_from_iter_trustedlen_no_fuse() { + // Exercise the `TrustedLen` implementation when `size_hint()` matches + // `(_, Some(exact_len))` but where the iterator does not behave in a fused manner. + struct Iter(std::vec::IntoIter>>); + + unsafe impl TrustedLen for Iter {} + + impl Iterator for Iter { + fn size_hint(&self) -> (usize, Option) { + (2, Some(2)) + } + + type Item = Box; + + fn next(&mut self) -> Option { + self.0.next().flatten() + } + } + + let vec = vec![Some(Box::new(42)), Some(Box::new(24)), None, Some(Box::new(12))]; + let iter = Iter(vec.into_iter()); + assert_trusted_len(&iter); + assert_eq!(&[Box::new(42), Box::new(24)], &*iter.collect::>()); +} diff --git a/libgrust/rustc-lib/alloc/tests/binary_heap.rs b/libgrust/rustc-lib/alloc/tests/binary_heap.rs new file mode 100644 index 000000000000..ce794a9a4afa --- /dev/null +++ b/libgrust/rustc-lib/alloc/tests/binary_heap.rs @@ -0,0 +1,476 @@ +use std::collections::binary_heap::{Drain, PeekMut}; +use std::collections::BinaryHeap; +use std::iter::TrustedLen; +use std::panic::{catch_unwind, AssertUnwindSafe}; +use std::sync::atomic::{AtomicU32, Ordering}; + +#[test] +fn test_iterator() { + let data = vec![5, 9, 3]; + let iterout = [9, 5, 3]; + let heap = BinaryHeap::from(data); + let mut i = 0; + for el in &heap { + assert_eq!(*el, iterout[i]); + i += 1; + } +} + +#[test] +fn test_iter_rev_cloned_collect() { + let data = vec![5, 9, 3]; + let iterout = vec![3, 5, 9]; + let pq = BinaryHeap::from(data); + + let v: Vec<_> = pq.iter().rev().cloned().collect(); + assert_eq!(v, iterout); +} + +#[test] +fn test_into_iter_collect() { + let data = vec![5, 9, 3]; + let iterout = vec![9, 5, 3]; + let pq = BinaryHeap::from(data); + + let v: Vec<_> = pq.into_iter().collect(); + assert_eq!(v, iterout); +} + +#[test] +fn test_into_iter_size_hint() { + let data = vec![5, 9]; + let pq = BinaryHeap::from(data); + + let mut it = pq.into_iter(); + + assert_eq!(it.size_hint(), (2, Some(2))); + assert_eq!(it.next(), Some(9)); + + assert_eq!(it.size_hint(), (1, Some(1))); + assert_eq!(it.next(), Some(5)); + + assert_eq!(it.size_hint(), (0, Some(0))); + assert_eq!(it.next(), None); +} + +#[test] +fn test_into_iter_rev_collect() { + let data = vec![5, 9, 3]; + let iterout = vec![3, 5, 9]; + let pq = BinaryHeap::from(data); + + let v: Vec<_> = pq.into_iter().rev().collect(); + assert_eq!(v, iterout); +} + +#[test] +fn test_into_iter_sorted_collect() { + let heap = BinaryHeap::from(vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]); + let it = heap.into_iter_sorted(); + let sorted = it.collect::>(); + assert_eq!(sorted, vec![10, 9, 8, 7, 6, 5, 4, 3, 2, 2, 1, 1, 0]); +} + +#[test] +fn test_drain_sorted_collect() { + let mut heap = BinaryHeap::from(vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]); + let it = heap.drain_sorted(); + let sorted = it.collect::>(); + assert_eq!(sorted, vec![10, 9, 8, 7, 6, 5, 4, 3, 2, 2, 1, 1, 0]); +} + +fn check_exact_size_iterator(len: usize, it: I) { + let mut it = it; + + for i in 0..it.len() { + let (lower, upper) = it.size_hint(); + assert_eq!(Some(lower), upper); + assert_eq!(lower, len - i); + assert_eq!(it.len(), len - i); + it.next(); + } + assert_eq!(it.len(), 0); + assert!(it.is_empty()); +} + +#[test] +fn test_exact_size_iterator() { + let heap = BinaryHeap::from(vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]); + check_exact_size_iterator(heap.len(), heap.iter()); + check_exact_size_iterator(heap.len(), heap.clone().into_iter()); + check_exact_size_iterator(heap.len(), heap.clone().into_iter_sorted()); + check_exact_size_iterator(heap.len(), heap.clone().drain()); + check_exact_size_iterator(heap.len(), heap.clone().drain_sorted()); +} + +fn check_trusted_len(len: usize, it: I) { + let mut it = it; + for i in 0..len { + let (lower, upper) = it.size_hint(); + if upper.is_some() { + assert_eq!(Some(lower), upper); + assert_eq!(lower, len - i); + } + it.next(); + } +} + +#[test] +fn test_trusted_len() { + let heap = BinaryHeap::from(vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]); + check_trusted_len(heap.len(), heap.clone().into_iter_sorted()); + check_trusted_len(heap.len(), heap.clone().drain_sorted()); +} + +#[test] +fn test_peek_and_pop() { + let data = vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]; + let mut sorted = data.clone(); + sorted.sort(); + let mut heap = BinaryHeap::from(data); + while !heap.is_empty() { + assert_eq!(heap.peek().unwrap(), sorted.last().unwrap()); + assert_eq!(heap.pop().unwrap(), sorted.pop().unwrap()); + } +} + +#[test] +fn test_peek_mut() { + let data = vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]; + let mut heap = BinaryHeap::from(data); + assert_eq!(heap.peek(), Some(&10)); + { + let mut top = heap.peek_mut().unwrap(); + *top -= 2; + } + assert_eq!(heap.peek(), Some(&9)); +} + +#[test] +fn test_peek_mut_pop() { + let data = vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]; + let mut heap = BinaryHeap::from(data); + assert_eq!(heap.peek(), Some(&10)); + { + let mut top = heap.peek_mut().unwrap(); + *top -= 2; + assert_eq!(PeekMut::pop(top), 8); + } + assert_eq!(heap.peek(), Some(&9)); +} + +#[test] +fn test_push() { + let mut heap = BinaryHeap::from(vec![2, 4, 9]); + assert_eq!(heap.len(), 3); + assert!(*heap.peek().unwrap() == 9); + heap.push(11); + assert_eq!(heap.len(), 4); + assert!(*heap.peek().unwrap() == 11); + heap.push(5); + assert_eq!(heap.len(), 5); + assert!(*heap.peek().unwrap() == 11); + heap.push(27); + assert_eq!(heap.len(), 6); + assert!(*heap.peek().unwrap() == 27); + heap.push(3); + assert_eq!(heap.len(), 7); + assert!(*heap.peek().unwrap() == 27); + heap.push(103); + assert_eq!(heap.len(), 8); + assert!(*heap.peek().unwrap() == 103); +} + +#[test] +fn test_push_unique() { + let mut heap = BinaryHeap::>::from(vec![box 2, box 4, box 9]); + assert_eq!(heap.len(), 3); + assert!(**heap.peek().unwrap() == 9); + heap.push(box 11); + assert_eq!(heap.len(), 4); + assert!(**heap.peek().unwrap() == 11); + heap.push(box 5); + assert_eq!(heap.len(), 5); + assert!(**heap.peek().unwrap() == 11); + heap.push(box 27); + assert_eq!(heap.len(), 6); + assert!(**heap.peek().unwrap() == 27); + heap.push(box 3); + assert_eq!(heap.len(), 7); + assert!(**heap.peek().unwrap() == 27); + heap.push(box 103); + assert_eq!(heap.len(), 8); + assert!(**heap.peek().unwrap() == 103); +} + +fn check_to_vec(mut data: Vec) { + let heap = BinaryHeap::from(data.clone()); + let mut v = heap.clone().into_vec(); + v.sort(); + data.sort(); + + assert_eq!(v, data); + assert_eq!(heap.into_sorted_vec(), data); +} + +#[test] +fn test_to_vec() { + check_to_vec(vec![]); + check_to_vec(vec![5]); + check_to_vec(vec![3, 2]); + check_to_vec(vec![2, 3]); + check_to_vec(vec![5, 1, 2]); + check_to_vec(vec![1, 100, 2, 3]); + check_to_vec(vec![1, 3, 5, 7, 9, 2, 4, 6, 8, 0]); + check_to_vec(vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]); + check_to_vec(vec![9, 11, 9, 9, 9, 9, 11, 2, 3, 4, 11, 9, 0, 0, 0, 0]); + check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); + check_to_vec(vec![10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]); + check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 2]); + check_to_vec(vec![5, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 1]); +} + +#[test] +fn test_in_place_iterator_specialization() { + let src: Vec = vec![1, 2, 3]; + let src_ptr = src.as_ptr(); + let heap: BinaryHeap<_> = src.into_iter().map(std::convert::identity).collect(); + let heap_ptr = heap.iter().next().unwrap() as *const usize; + assert_eq!(src_ptr, heap_ptr); + let sink: Vec<_> = heap.into_iter().map(std::convert::identity).collect(); + let sink_ptr = sink.as_ptr(); + assert_eq!(heap_ptr, sink_ptr); +} + +#[test] +fn test_empty_pop() { + let mut heap = BinaryHeap::::new(); + assert!(heap.pop().is_none()); +} + +#[test] +fn test_empty_peek() { + let empty = BinaryHeap::::new(); + assert!(empty.peek().is_none()); +} + +#[test] +fn test_empty_peek_mut() { + let mut empty = BinaryHeap::::new(); + assert!(empty.peek_mut().is_none()); +} + +#[test] +fn test_from_iter() { + let xs = vec![9, 8, 7, 6, 5, 4, 3, 2, 1]; + + let mut q: BinaryHeap<_> = xs.iter().rev().cloned().collect(); + + for &x in &xs { + assert_eq!(q.pop().unwrap(), x); + } +} + +#[test] +fn test_drain() { + let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect(); + + assert_eq!(q.drain().take(5).count(), 5); + + assert!(q.is_empty()); +} + +#[test] +fn test_drain_sorted() { + let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect(); + + assert_eq!(q.drain_sorted().take(5).collect::>(), vec![9, 8, 7, 6, 5]); + + assert!(q.is_empty()); +} + +#[test] +fn test_drain_sorted_leak() { + static DROPS: AtomicU32 = AtomicU32::new(0); + + #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)] + struct D(u32, bool); + + impl Drop for D { + fn drop(&mut self) { + DROPS.fetch_add(1, Ordering::SeqCst); + + if self.1 { + panic!("panic in `drop`"); + } + } + } + + let mut q = BinaryHeap::from(vec![ + D(0, false), + D(1, false), + D(2, false), + D(3, true), + D(4, false), + D(5, false), + ]); + + catch_unwind(AssertUnwindSafe(|| drop(q.drain_sorted()))).ok(); + + assert_eq!(DROPS.load(Ordering::SeqCst), 6); +} + +#[test] +fn test_extend_ref() { + let mut a = BinaryHeap::new(); + a.push(1); + a.push(2); + + a.extend(&[3, 4, 5]); + + assert_eq!(a.len(), 5); + assert_eq!(a.into_sorted_vec(), [1, 2, 3, 4, 5]); + + let mut a = BinaryHeap::new(); + a.push(1); + a.push(2); + let mut b = BinaryHeap::new(); + b.push(3); + b.push(4); + b.push(5); + + a.extend(&b); + + assert_eq!(a.len(), 5); + assert_eq!(a.into_sorted_vec(), [1, 2, 3, 4, 5]); +} + +#[test] +fn test_append() { + let mut a = BinaryHeap::from(vec![-10, 1, 2, 3, 3]); + let mut b = BinaryHeap::from(vec![-20, 5, 43]); + + a.append(&mut b); + + assert_eq!(a.into_sorted_vec(), [-20, -10, 1, 2, 3, 3, 5, 43]); + assert!(b.is_empty()); +} + +#[test] +fn test_append_to_empty() { + let mut a = BinaryHeap::new(); + let mut b = BinaryHeap::from(vec![-20, 5, 43]); + + a.append(&mut b); + + assert_eq!(a.into_sorted_vec(), [-20, 5, 43]); + assert!(b.is_empty()); +} + +#[test] +fn test_extend_specialization() { + let mut a = BinaryHeap::from(vec![-10, 1, 2, 3, 3]); + let b = BinaryHeap::from(vec![-20, 5, 43]); + + a.extend(b); + + assert_eq!(a.into_sorted_vec(), [-20, -10, 1, 2, 3, 3, 5, 43]); +} + +#[allow(dead_code)] +fn assert_covariance() { + fn drain<'new>(d: Drain<'static, &'static str>) -> Drain<'new, &'new str> { + d + } +} + +#[test] +fn test_retain() { + let mut a = BinaryHeap::from(vec![-10, -5, 1, 2, 4, 13]); + a.retain(|x| x % 2 == 0); + + assert_eq!(a.into_sorted_vec(), [-10, 2, 4]) +} + +// old binaryheap failed this test +// +// Integrity means that all elements are present after a comparison panics, +// even if the order may not be correct. +// +// Destructors must be called exactly once per element. +// FIXME: re-enable emscripten once it can unwind again +#[test] +#[cfg(not(target_os = "emscripten"))] +fn panic_safe() { + use rand::{seq::SliceRandom, thread_rng}; + use std::cmp; + use std::panic::{self, AssertUnwindSafe}; + use std::sync::atomic::{AtomicUsize, Ordering}; + + static DROP_COUNTER: AtomicUsize = AtomicUsize::new(0); + + #[derive(Eq, PartialEq, Ord, Clone, Debug)] + struct PanicOrd(T, bool); + + impl Drop for PanicOrd { + fn drop(&mut self) { + // update global drop count + DROP_COUNTER.fetch_add(1, Ordering::SeqCst); + } + } + + impl PartialOrd for PanicOrd { + fn partial_cmp(&self, other: &Self) -> Option { + if self.1 || other.1 { + panic!("Panicking comparison"); + } + self.0.partial_cmp(&other.0) + } + } + let mut rng = thread_rng(); + const DATASZ: usize = 32; + // Miri is too slow + let ntest = if cfg!(miri) { 1 } else { 10 }; + + // don't use 0 in the data -- we want to catch the zeroed-out case. + let data = (1..=DATASZ).collect::>(); + + // since it's a fuzzy test, run several tries. + for _ in 0..ntest { + for i in 1..=DATASZ { + DROP_COUNTER.store(0, Ordering::SeqCst); + + let mut panic_ords: Vec<_> = + data.iter().filter(|&&x| x != i).map(|&x| PanicOrd(x, false)).collect(); + let panic_item = PanicOrd(i, true); + + // heapify the sane items + panic_ords.shuffle(&mut rng); + let mut heap = BinaryHeap::from(panic_ords); + let inner_data; + + { + // push the panicking item to the heap and catch the panic + let thread_result = { + let mut heap_ref = AssertUnwindSafe(&mut heap); + panic::catch_unwind(move || { + heap_ref.push(panic_item); + }) + }; + assert!(thread_result.is_err()); + + // Assert no elements were dropped + let drops = DROP_COUNTER.load(Ordering::SeqCst); + assert!(drops == 0, "Must not drop items. drops={}", drops); + inner_data = heap.clone().into_vec(); + drop(heap); + } + let drops = DROP_COUNTER.load(Ordering::SeqCst); + assert_eq!(drops, DATASZ); + + let mut data_sorted = inner_data.into_iter().map(|p| p.0).collect::>(); + data_sorted.sort(); + assert_eq!(data_sorted, data); + } + } +} diff --git a/libgrust/rustc-lib/alloc/tests/borrow.rs b/libgrust/rustc-lib/alloc/tests/borrow.rs new file mode 100644 index 000000000000..57976aa6cdfd --- /dev/null +++ b/libgrust/rustc-lib/alloc/tests/borrow.rs @@ -0,0 +1,60 @@ +use std::borrow::{Cow, ToOwned}; +use std::ffi::{CStr, OsStr}; +use std::path::Path; +use std::rc::Rc; +use std::sync::Arc; + +macro_rules! test_from_cow { + ($value:ident => $($ty:ty),+) => {$( + let borrowed = <$ty>::from(Cow::Borrowed($value)); + let owned = <$ty>::from(Cow::Owned($value.to_owned())); + assert_eq!($value, &*borrowed); + assert_eq!($value, &*owned); + )+}; + ($value:ident : & $ty:ty) => { + test_from_cow!($value => Box<$ty>, Rc<$ty>, Arc<$ty>); + } +} + +#[test] +fn test_from_cow_slice() { + let slice: &[i32] = &[1, 2, 3]; + test_from_cow!(slice: &[i32]); +} + +#[test] +fn test_from_cow_str() { + let string = "hello"; + test_from_cow!(string: &str); +} + +#[test] +fn test_from_cow_c_str() { + let string = CStr::from_bytes_with_nul(b"hello\0").unwrap(); + test_from_cow!(string: &CStr); +} + +#[test] +fn test_from_cow_os_str() { + let string = OsStr::new("hello"); + test_from_cow!(string: &OsStr); +} + +#[test] +fn test_from_cow_path() { + let path = Path::new("hello"); + test_from_cow!(path: &Path); +} + +#[test] +fn cow_const() { + // test that the methods of `Cow` are usable in a const context + + const COW: Cow<'_, str> = Cow::Borrowed("moo"); + + const IS_BORROWED: bool = COW.is_borrowed(); + assert!(IS_BORROWED); + + const IS_OWNED: bool = COW.is_owned(); + assert!(!IS_OWNED); +} diff --git a/libgrust/rustc-lib/alloc/tests/boxed.rs b/libgrust/rustc-lib/alloc/tests/boxed.rs new file mode 100644 index 000000000000..6a83f5da87cc --- /dev/null +++ b/libgrust/rustc-lib/alloc/tests/boxed.rs @@ -0,0 +1,59 @@ +use std::cell::Cell; +use std::mem::MaybeUninit; +use std::ptr::NonNull; + +#[test] +fn unitialized_zero_size_box() { + assert_eq!( + &*Box::<()>::new_uninit() as *const _, + NonNull::>::dangling().as_ptr(), + ); + assert_eq!( + Box::<[()]>::new_uninit_slice(4).as_ptr(), + NonNull::>::dangling().as_ptr(), + ); + assert_eq!( + Box::<[String]>::new_uninit_slice(0).as_ptr(), + NonNull::>::dangling().as_ptr(), + ); +} + +#[derive(Clone, PartialEq, Eq, Debug)] +struct Dummy { + _data: u8, +} + +#[test] +fn box_clone_and_clone_from_equivalence() { + for size in (0..8).map(|i| 2usize.pow(i)) { + let control = vec![Dummy { _data: 42 }; size].into_boxed_slice(); + let clone = control.clone(); + let mut copy = vec![Dummy { _data: 84 }; size].into_boxed_slice(); + copy.clone_from(&control); + assert_eq!(control, clone); + assert_eq!(control, copy); + } +} + +/// This test might give a false positive in case the box realocates, but the alocator keeps the +/// original pointer. +/// +/// On the other hand it won't give a false negative, if it fails than the memory was definitely not +/// reused +#[test] +fn box_clone_from_ptr_stability() { + for size in (0..8).map(|i| 2usize.pow(i)) { + let control = vec![Dummy { _data: 42 }; size].into_boxed_slice(); + let mut copy = vec![Dummy { _data: 84 }; size].into_boxed_slice(); + let copy_raw = copy.as_ptr() as usize; + copy.clone_from(&control); + assert_eq!(copy.as_ptr() as usize, copy_raw); + } +} + +#[test] +fn box_deref_lval() { + let x = Box::new(Cell::new(5)); + x.set(1000); + assert_eq!(x.get(), 1000); +} diff --git a/libgrust/rustc-lib/alloc/tests/btree_set_hash.rs b/libgrust/rustc-lib/alloc/tests/btree_set_hash.rs new file mode 100644 index 000000000000..e06a95ded94c --- /dev/null +++ b/libgrust/rustc-lib/alloc/tests/btree_set_hash.rs @@ -0,0 +1,19 @@ +use std::collections::BTreeSet; + +#[test] +fn test_hash() { + use crate::hash; + + let mut x = BTreeSet::new(); + let mut y = BTreeSet::new(); + + x.insert(1); + x.insert(2); + x.insert(3); + + y.insert(3); + y.insert(2); + y.insert(1); + + assert_eq!(hash(&x), hash(&y)); +} diff --git a/libgrust/rustc-lib/alloc/tests/cow_str.rs b/libgrust/rustc-lib/alloc/tests/cow_str.rs new file mode 100644 index 000000000000..62a5c245a542 --- /dev/null +++ b/libgrust/rustc-lib/alloc/tests/cow_str.rs @@ -0,0 +1,144 @@ +use std::borrow::Cow; + +// check that Cow<'a, str> implements addition +#[test] +fn check_cow_add_cow() { + let borrowed1 = Cow::Borrowed("Hello, "); + let borrowed2 = Cow::Borrowed("World!"); + let borrow_empty = Cow::Borrowed(""); + + let owned1: Cow<'_, str> = Cow::Owned(String::from("Hi, ")); + let owned2: Cow<'_, str> = Cow::Owned(String::from("Rustaceans!")); + let owned_empty: Cow<'_, str> = Cow::Owned(String::new()); + + assert_eq!("Hello, World!", borrowed1.clone() + borrowed2.clone()); + assert_eq!("Hello, Rustaceans!", borrowed1.clone() + owned2.clone()); + + assert_eq!("Hi, World!", owned1.clone() + borrowed2.clone()); + assert_eq!("Hi, Rustaceans!", owned1.clone() + owned2.clone()); + + if let Cow::Owned(_) = borrowed1.clone() + borrow_empty.clone() { + panic!("Adding empty strings to a borrow should note allocate"); + } + if let Cow::Owned(_) = borrow_empty.clone() + borrowed1.clone() { + panic!("Adding empty strings to a borrow should note allocate"); + } + if let Cow::Owned(_) = borrowed1.clone() + owned_empty.clone() { + panic!("Adding empty strings to a borrow should note allocate"); + } + if let Cow::Owned(_) = owned_empty.clone() + borrowed1.clone() { + panic!("Adding empty strings to a borrow should note allocate"); + } +} + +#[test] +fn check_cow_add_str() { + let borrowed = Cow::Borrowed("Hello, "); + let borrow_empty = Cow::Borrowed(""); + + let owned: Cow<'_, str> = Cow::Owned(String::from("Hi, ")); + let owned_empty: Cow<'_, str> = Cow::Owned(String::new()); + + assert_eq!("Hello, World!", borrowed.clone() + "World!"); + + assert_eq!("Hi, World!", owned.clone() + "World!"); + + if let Cow::Owned(_) = borrowed.clone() + "" { + panic!("Adding empty strings to a borrow should note allocate"); + } + if let Cow::Owned(_) = borrow_empty.clone() + "Hello, " { + panic!("Adding empty strings to a borrow should note allocate"); + } + if let Cow::Owned(_) = owned_empty.clone() + "Hello, " { + panic!("Adding empty strings to a borrow should note allocate"); + } +} + +#[test] +fn check_cow_add_assign_cow() { + let mut borrowed1 = Cow::Borrowed("Hello, "); + let borrowed2 = Cow::Borrowed("World!"); + let borrow_empty = Cow::Borrowed(""); + + let mut owned1: Cow<'_, str> = Cow::Owned(String::from("Hi, ")); + let owned2: Cow<'_, str> = Cow::Owned(String::from("Rustaceans!")); + let owned_empty: Cow<'_, str> = Cow::Owned(String::new()); + + let mut s = borrowed1.clone(); + s += borrow_empty.clone(); + assert_eq!("Hello, ", s); + if let Cow::Owned(_) = s { + panic!("Adding empty strings to a borrow should note allocate"); + } + let mut s = borrow_empty.clone(); + s += borrowed1.clone(); + assert_eq!("Hello, ", s); + if let Cow::Owned(_) = s { + panic!("Adding empty strings to a borrow should note allocate"); + } + let mut s = borrowed1.clone(); + s += owned_empty.clone(); + assert_eq!("Hello, ", s); + if let Cow::Owned(_) = s { + panic!("Adding empty strings to a borrow should note allocate"); + } + let mut s = owned_empty.clone(); + s += borrowed1.clone(); + assert_eq!("Hello, ", s); + if let Cow::Owned(_) = s { + panic!("Adding empty strings to a borrow should note allocate"); + } + + owned1 += borrowed2; + borrowed1 += owned2; + + assert_eq!("Hi, World!", owned1); + assert_eq!("Hello, Rustaceans!", borrowed1); +} + +#[test] +fn check_cow_add_assign_str() { + let mut borrowed = Cow::Borrowed("Hello, "); + let borrow_empty = Cow::Borrowed(""); + + let mut owned: Cow<'_, str> = Cow::Owned(String::from("Hi, ")); + let owned_empty: Cow<'_, str> = Cow::Owned(String::new()); + + let mut s = borrowed.clone(); + s += ""; + assert_eq!("Hello, ", s); + if let Cow::Owned(_) = s { + panic!("Adding empty strings to a borrow should note allocate"); + } + let mut s = borrow_empty.clone(); + s += "World!"; + assert_eq!("World!", s); + if let Cow::Owned(_) = s { + panic!("Adding empty strings to a borrow should note allocate"); + } + let mut s = owned_empty.clone(); + s += "World!"; + assert_eq!("World!", s); + if let Cow::Owned(_) = s { + panic!("Adding empty strings to a borrow should note allocate"); + } + + owned += "World!"; + borrowed += "World!"; + + assert_eq!("Hi, World!", owned); + assert_eq!("Hello, World!", borrowed); +} + +#[test] +fn check_cow_clone_from() { + let mut c1: Cow<'_, str> = Cow::Owned(String::with_capacity(25)); + let s: String = "hi".to_string(); + assert!(s.capacity() < 25); + let c2: Cow<'_, str> = Cow::Owned(s); + c1.clone_from(&c2); + assert!(c1.into_owned().capacity() >= 25); + let mut c3: Cow<'_, str> = Cow::Borrowed("bye"); + c3.clone_from(&c2); + assert_eq!(c2, c3); +} diff --git a/libgrust/rustc-lib/alloc/tests/fmt.rs b/libgrust/rustc-lib/alloc/tests/fmt.rs new file mode 100644 index 000000000000..757fddd24185 --- /dev/null +++ b/libgrust/rustc-lib/alloc/tests/fmt.rs @@ -0,0 +1,327 @@ +#![deny(warnings)] + +use std::cell::RefCell; +use std::fmt::{self, Write}; + +#[test] +fn test_format() { + let s = fmt::format(format_args!("Hello, {}!", "world")); + assert_eq!(s, "Hello, world!"); +} + +struct A; +struct B; +struct C; +struct D; + +impl fmt::LowerHex for A { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("aloha") + } +} +impl fmt::UpperHex for B { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("adios") + } +} +impl fmt::Display for C { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.pad_integral(true, "☃", "123") + } +} +impl fmt::Binary for D { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str("aa")?; + f.write_char('☃')?; + f.write_str("bb") + } +} + +macro_rules! t { + ($a:expr, $b:expr) => { + assert_eq!($a, $b) + }; +} + +#[test] +fn test_format_macro_interface() { + // Various edge cases without formats + t!(format!(""), ""); + t!(format!("hello"), "hello"); + t!(format!("hello {{"), "hello {"); + + // default formatters should work + t!(format!("{}", 1.0f32), "1"); + t!(format!("{}", 1.0f64), "1"); + t!(format!("{}", "a"), "a"); + t!(format!("{}", "a".to_string()), "a"); + t!(format!("{}", false), "false"); + t!(format!("{}", 'a'), "a"); + + // At least exercise all the formats + t!(format!("{}", true), "true"); + t!(format!("{}", '☃'), "☃"); + t!(format!("{}", 10), "10"); + t!(format!("{}", 10_usize), "10"); + t!(format!("{:?}", '☃'), "'☃'"); + t!(format!("{:?}", 10), "10"); + t!(format!("{:?}", 10_usize), "10"); + t!(format!("{:?}", "true"), "\"true\""); + t!(format!("{:?}", "foo\nbar"), "\"foo\\nbar\""); + t!( + format!("{:?}", "foo\n\"bar\"\r\n\'baz\'\t\\qux\\"), + r#""foo\n\"bar\"\r\n\'baz\'\t\\qux\\""# + ); + t!(format!("{:?}", "foo\0bar\x01baz\u{7f}q\u{75}x"), r#""foo\u{0}bar\u{1}baz\u{7f}qux""#); + t!(format!("{:o}", 10_usize), "12"); + t!(format!("{:x}", 10_usize), "a"); + t!(format!("{:X}", 10_usize), "A"); + t!(format!("{}", "foo"), "foo"); + t!(format!("{}", "foo".to_string()), "foo"); + if cfg!(target_pointer_width = "32") { + t!(format!("{:#p}", 0x1234 as *const isize), "0x00001234"); + t!(format!("{:#p}", 0x1234 as *mut isize), "0x00001234"); + } else { + t!(format!("{:#p}", 0x1234 as *const isize), "0x0000000000001234"); + t!(format!("{:#p}", 0x1234 as *mut isize), "0x0000000000001234"); + } + t!(format!("{:p}", 0x1234 as *const isize), "0x1234"); + t!(format!("{:p}", 0x1234 as *mut isize), "0x1234"); + t!(format!("{:x}", A), "aloha"); + t!(format!("{:X}", B), "adios"); + t!(format!("foo {} ☃☃☃☃☃☃", "bar"), "foo bar ☃☃☃☃☃☃"); + t!(format!("{1} {0}", 0, 1), "1 0"); + t!(format!("{foo} {bar}", foo = 0, bar = 1), "0 1"); + t!(format!("{foo} {1} {bar} {0}", 0, 1, foo = 2, bar = 3), "2 1 3 0"); + t!(format!("{} {0}", "a"), "a a"); + t!(format!("{_foo}", _foo = 6usize), "6"); + t!(format!("{foo_bar}", foo_bar = 1), "1"); + t!(format!("{}", 5 + 5), "10"); + t!(format!("{:#4}", C), "☃123"); + t!(format!("{:b}", D), "aa☃bb"); + + let a: &dyn fmt::Debug = &1; + t!(format!("{:?}", a), "1"); + + // Formatting strings and their arguments + t!(format!("{}", "a"), "a"); + t!(format!("{:4}", "a"), "a "); + t!(format!("{:4}", "☃"), "☃ "); + t!(format!("{:>4}", "a"), " a"); + t!(format!("{:<4}", "a"), "a "); + t!(format!("{:^5}", "a"), " a "); + t!(format!("{:^5}", "aa"), " aa "); + t!(format!("{:^4}", "a"), " a "); + t!(format!("{:^4}", "aa"), " aa "); + t!(format!("{:.4}", "a"), "a"); + t!(format!("{:4.4}", "a"), "a "); + t!(format!("{:4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa"); + t!(format!("{:<4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa"); + t!(format!("{:>4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa"); + t!(format!("{:^4.4}", "aaaaaaaaaaaaaaaaaa"), "aaaa"); + t!(format!("{:>10.4}", "aaaaaaaaaaaaaaaaaa"), " aaaa"); + t!(format!("{:2.4}", "aaaaa"), "aaaa"); + t!(format!("{:2.4}", "aaaa"), "aaaa"); + t!(format!("{:2.4}", "aaa"), "aaa"); + t!(format!("{:2.4}", "aa"), "aa"); + t!(format!("{:2.4}", "a"), "a "); + t!(format!("{:0>2}", "a"), "0a"); + t!(format!("{:.*}", 4, "aaaaaaaaaaaaaaaaaa"), "aaaa"); + t!(format!("{:.1$}", "aaaaaaaaaaaaaaaaaa", 4), "aaaa"); + t!(format!("{:.a$}", "aaaaaaaaaaaaaaaaaa", a = 4), "aaaa"); + t!(format!("{:._a$}", "aaaaaaaaaaaaaaaaaa", _a = 4), "aaaa"); + t!(format!("{:1$}", "a", 4), "a "); + t!(format!("{1:0$}", 4, "a"), "a "); + t!(format!("{:a$}", "a", a = 4), "a "); + t!(format!("{:-#}", "a"), "a"); + t!(format!("{:+#}", "a"), "a"); + t!(format!("{:/^10.8}", "1234567890"), "/12345678/"); + + // Some float stuff + t!(format!("{:}", 1.0f32), "1"); + t!(format!("{:}", 1.0f64), "1"); + t!(format!("{:.3}", 1.0f64), "1.000"); + t!(format!("{:10.3}", 1.0f64), " 1.000"); + t!(format!("{:+10.3}", 1.0f64), " +1.000"); + t!(format!("{:+10.3}", -1.0f64), " -1.000"); + + t!(format!("{:e}", 1.2345e6f32), "1.2345e6"); + t!(format!("{:e}", 1.2345e6f64), "1.2345e6"); + t!(format!("{:E}", 1.2345e6f64), "1.2345E6"); + t!(format!("{:.3e}", 1.2345e6f64), "1.234e6"); + t!(format!("{:10.3e}", 1.2345e6f64), " 1.234e6"); + t!(format!("{:+10.3e}", 1.2345e6f64), " +1.234e6"); + t!(format!("{:+10.3e}", -1.2345e6f64), " -1.234e6"); + + // Float edge cases + t!(format!("{}", -0.0), "0"); + t!(format!("{:?}", -0.0), "-0.0"); + t!(format!("{:?}", 0.0), "0.0"); + + // sign aware zero padding + t!(format!("{:<3}", 1), "1 "); + t!(format!("{:>3}", 1), " 1"); + t!(format!("{:^3}", 1), " 1 "); + t!(format!("{:03}", 1), "001"); + t!(format!("{:<03}", 1), "001"); + t!(format!("{:>03}", 1), "001"); + t!(format!("{:^03}", 1), "001"); + t!(format!("{:+03}", 1), "+01"); + t!(format!("{:<+03}", 1), "+01"); + t!(format!("{:>+03}", 1), "+01"); + t!(format!("{:^+03}", 1), "+01"); + t!(format!("{:#05x}", 1), "0x001"); + t!(format!("{:<#05x}", 1), "0x001"); + t!(format!("{:>#05x}", 1), "0x001"); + t!(format!("{:^#05x}", 1), "0x001"); + t!(format!("{:05}", 1.2), "001.2"); + t!(format!("{:<05}", 1.2), "001.2"); + t!(format!("{:>05}", 1.2), "001.2"); + t!(format!("{:^05}", 1.2), "001.2"); + t!(format!("{:05}", -1.2), "-01.2"); + t!(format!("{:<05}", -1.2), "-01.2"); + t!(format!("{:>05}", -1.2), "-01.2"); + t!(format!("{:^05}", -1.2), "-01.2"); + t!(format!("{:+05}", 1.2), "+01.2"); + t!(format!("{:<+05}", 1.2), "+01.2"); + t!(format!("{:>+05}", 1.2), "+01.2"); + t!(format!("{:^+05}", 1.2), "+01.2"); + + // Ergonomic format_args! + t!(format!("{0:x} {0:X}", 15), "f F"); + t!(format!("{0:x} {0:X} {}", 15), "f F 15"); + t!(format!("{:x}{0:X}{a:x}{:X}{1:x}{a:X}", 13, 14, a = 15), "dDfEeF"); + t!(format!("{a:x} {a:X}", a = 15), "f F"); + + // And its edge cases + t!( + format!( + "{a:.0$} {b:.0$} {0:.0$}\n{a:.c$} {b:.c$} {c:.c$}", + 4, + a = "abcdefg", + b = "hijklmn", + c = 3 + ), + "abcd hijk 4\nabc hij 3" + ); + t!(format!("{a:.*} {0} {:.*}", 4, 3, "efgh", a = "abcdef"), "abcd 4 efg"); + t!(format!("{:.a$} {a} {a:#x}", "aaaaaa", a = 2), "aa 2 0x2"); + + // Test that pointers don't get truncated. + { + let val = usize::MAX; + let exp = format!("{:#x}", val); + t!(format!("{:p}", val as *const isize), exp); + } + + // Escaping + t!(format!("{{"), "{"); + t!(format!("}}"), "}"); + + // make sure that format! doesn't move out of local variables + let a = Box::new(3); + format!("{}", a); + format!("{}", a); + + // make sure that format! doesn't cause spurious unused-unsafe warnings when + // it's inside of an outer unsafe block + unsafe { + let a: isize = ::std::mem::transmute(3_usize); + format!("{}", a); + } + + // test that trailing commas are acceptable + format!("{}", "test",); + format!("{foo}", foo = "test",); +} + +// Basic test to make sure that we can invoke the `write!` macro with an +// fmt::Write instance. +#[test] +fn test_write() { + let mut buf = String::new(); + let _ = write!(&mut buf, "{}", 3); + { + let w = &mut buf; + let _ = write!(w, "{foo}", foo = 4); + let _ = write!(w, "{}", "hello"); + let _ = writeln!(w, "{}", "line"); + let _ = writeln!(w, "{foo}", foo = "bar"); + let _ = w.write_char('☃'); + let _ = w.write_str("str"); + } + + t!(buf, "34helloline\nbar\n☃str"); +} + +// Just make sure that the macros are defined, there's not really a lot that we +// can do with them just yet (to test the output) +#[test] +fn test_print() { + print!("hi"); + print!("{:?}", vec![0u8]); + println!("hello"); + println!("this is a {}", "test"); + println!("{foo}", foo = "bar"); +} + +// Just make sure that the macros are defined, there's not really a lot that we +// can do with them just yet (to test the output) +#[test] +fn test_format_args() { + let mut buf = String::new(); + { + let w = &mut buf; + let _ = write!(w, "{}", format_args!("{}", 1)); + let _ = write!(w, "{}", format_args!("test")); + let _ = write!(w, "{}", format_args!("{test}", test = 3)); + } + let s = buf; + t!(s, "1test3"); + + let s = fmt::format(format_args!("hello {}", "world")); + t!(s, "hello world"); + let s = format!("{}: {}", "args were", format_args!("hello {}", "world")); + t!(s, "args were: hello world"); +} + +#[test] +fn test_order() { + // Make sure format!() arguments are always evaluated in a left-to-right + // ordering + fn foo() -> isize { + static mut FOO: isize = 0; + unsafe { + FOO += 1; + FOO + } + } + assert_eq!( + format!("{} {} {a} {b} {} {c}", foo(), foo(), foo(), a = foo(), b = foo(), c = foo()), + "1 2 4 5 3 6".to_string() + ); +} + +#[test] +fn test_once() { + // Make sure each argument are evaluated only once even though it may be + // formatted multiple times + fn foo() -> isize { + static mut FOO: isize = 0; + unsafe { + FOO += 1; + FOO + } + } + assert_eq!(format!("{0} {0} {0} {a} {a} {a}", foo(), a = foo()), "1 1 1 2 2 2".to_string()); +} + +#[test] +fn test_refcell() { + let refcell = RefCell::new(5); + assert_eq!(format!("{:?}", refcell), "RefCell { value: 5 }"); + let borrow = refcell.borrow_mut(); + assert_eq!(format!("{:?}", refcell), "RefCell { value: }"); + drop(borrow); + assert_eq!(format!("{:?}", refcell), "RefCell { value: 5 }"); +} diff --git a/libgrust/rustc-lib/alloc/tests/heap.rs b/libgrust/rustc-lib/alloc/tests/heap.rs new file mode 100644 index 000000000000..a7239a4b14fa --- /dev/null +++ b/libgrust/rustc-lib/alloc/tests/heap.rs @@ -0,0 +1,44 @@ +use std::alloc::{AllocRef, Global, Layout, System}; + +/// Issue #45955 and #62251. +#[test] +fn alloc_system_overaligned_request() { + check_overalign_requests(System) +} + +#[test] +fn std_heap_overaligned_request() { + check_overalign_requests(Global) +} + +fn check_overalign_requests(allocator: T) { + for &align in &[4, 8, 16, 32] { + // less than and bigger than `MIN_ALIGN` + for &size in &[align / 2, align - 1] { + // size less than alignment + let iterations = 128; + unsafe { + let pointers: Vec<_> = (0..iterations) + .map(|_| { + allocator.alloc(Layout::from_size_align(size, align).unwrap()).unwrap() + }) + .collect(); + for &ptr in &pointers { + assert_eq!( + (ptr.as_non_null_ptr().as_ptr() as usize) % align, + 0, + "Got a pointer less aligned than requested" + ) + } + + // Clean up + for &ptr in &pointers { + allocator.dealloc( + ptr.as_non_null_ptr(), + Layout::from_size_align(size, align).unwrap(), + ) + } + } + } + } +} diff --git a/libgrust/rustc-lib/alloc/tests/lib.rs b/libgrust/rustc-lib/alloc/tests/lib.rs new file mode 100644 index 000000000000..b7cc03f8eb99 --- /dev/null +++ b/libgrust/rustc-lib/alloc/tests/lib.rs @@ -0,0 +1,64 @@ +#![feature(allocator_api)] +#![feature(box_syntax)] +#![feature(cow_is_borrowed)] +#![feature(const_cow_is_borrowed)] +#![feature(drain_filter)] +#![feature(exact_size_is_empty)] +#![feature(new_uninit)] +#![feature(pattern)] +#![feature(str_split_once)] +#![feature(trusted_len)] +#![feature(try_reserve)] +#![feature(unboxed_closures)] +#![feature(associated_type_bounds)] +#![feature(binary_heap_into_iter_sorted)] +#![feature(binary_heap_drain_sorted)] +#![feature(slice_ptr_get)] +#![feature(split_inclusive)] +#![feature(binary_heap_retain)] +#![feature(deque_range)] +#![feature(inplace_iteration)] +#![feature(iter_map_while)] +#![feature(int_bits_const)] +#![feature(vecdeque_binary_search)] + +use std::collections::hash_map::DefaultHasher; +use std::hash::{Hash, Hasher}; + +mod arc; +mod binary_heap; +mod borrow; +mod boxed; +mod btree_set_hash; +mod cow_str; +mod fmt; +mod heap; +mod linked_list; +mod rc; +mod slice; +mod str; +mod string; +mod vec; +mod vec_deque; + +fn hash(t: &T) -> u64 { + let mut s = DefaultHasher::new(); + t.hash(&mut s); + s.finish() +} + +// FIXME: Instantiated functions with i128 in the signature is not supported in Emscripten. +// See https://github.com/kripken/emscripten-fastcomp/issues/169 +#[cfg(not(target_os = "emscripten"))] +#[test] +fn test_boxed_hasher() { + let ordinary_hash = hash(&5u32); + + let mut hasher_1 = Box::new(DefaultHasher::new()); + 5u32.hash(&mut hasher_1); + assert_eq!(ordinary_hash, hasher_1.finish()); + + let mut hasher_2 = Box::new(DefaultHasher::new()) as Box; + 5u32.hash(&mut hasher_2); + assert_eq!(ordinary_hash, hasher_2.finish()); +} diff --git a/libgrust/rustc-lib/alloc/tests/linked_list.rs b/libgrust/rustc-lib/alloc/tests/linked_list.rs new file mode 100644 index 000000000000..afcb9e03fd09 --- /dev/null +++ b/libgrust/rustc-lib/alloc/tests/linked_list.rs @@ -0,0 +1,705 @@ +use std::collections::LinkedList; +use std::panic::{catch_unwind, AssertUnwindSafe}; + +#[test] +fn test_basic() { + let mut m = LinkedList::>::new(); + assert_eq!(m.pop_front(), None); + assert_eq!(m.pop_back(), None); + assert_eq!(m.pop_front(), None); + m.push_front(box 1); + assert_eq!(m.pop_front(), Some(box 1)); + m.push_back(box 2); + m.push_back(box 3); + assert_eq!(m.len(), 2); + assert_eq!(m.pop_front(), Some(box 2)); + assert_eq!(m.pop_front(), Some(box 3)); + assert_eq!(m.len(), 0); + assert_eq!(m.pop_front(), None); + m.push_back(box 1); + m.push_back(box 3); + m.push_back(box 5); + m.push_back(box 7); + assert_eq!(m.pop_front(), Some(box 1)); + + let mut n = LinkedList::new(); + n.push_front(2); + n.push_front(3); + { + assert_eq!(n.front().unwrap(), &3); + let x = n.front_mut().unwrap(); + assert_eq!(*x, 3); + *x = 0; + } + { + assert_eq!(n.back().unwrap(), &2); + let y = n.back_mut().unwrap(); + assert_eq!(*y, 2); + *y = 1; + } + assert_eq!(n.pop_front(), Some(0)); + assert_eq!(n.pop_front(), Some(1)); +} + +fn generate_test() -> LinkedList { + list_from(&[0, 1, 2, 3, 4, 5, 6]) +} + +fn list_from(v: &[T]) -> LinkedList { + v.iter().cloned().collect() +} + +#[test] +fn test_split_off() { + // singleton + { + let mut m = LinkedList::new(); + m.push_back(1); + + let p = m.split_off(0); + assert_eq!(m.len(), 0); + assert_eq!(p.len(), 1); + assert_eq!(p.back(), Some(&1)); + assert_eq!(p.front(), Some(&1)); + } + + // not singleton, forwards + { + let u = vec![1, 2, 3, 4, 5]; + let mut m = list_from(&u); + let mut n = m.split_off(2); + assert_eq!(m.len(), 2); + assert_eq!(n.len(), 3); + for elt in 1..3 { + assert_eq!(m.pop_front(), Some(elt)); + } + for elt in 3..6 { + assert_eq!(n.pop_front(), Some(elt)); + } + } + // not singleton, backwards + { + let u = vec![1, 2, 3, 4, 5]; + let mut m = list_from(&u); + let mut n = m.split_off(4); + assert_eq!(m.len(), 4); + assert_eq!(n.len(), 1); + for elt in 1..5 { + assert_eq!(m.pop_front(), Some(elt)); + } + for elt in 5..6 { + assert_eq!(n.pop_front(), Some(elt)); + } + } + + // no-op on the last index + { + let mut m = LinkedList::new(); + m.push_back(1); + + let p = m.split_off(1); + assert_eq!(m.len(), 1); + assert_eq!(p.len(), 0); + assert_eq!(m.back(), Some(&1)); + assert_eq!(m.front(), Some(&1)); + } +} + +#[test] +fn test_iterator() { + let m = generate_test(); + for (i, elt) in m.iter().enumerate() { + assert_eq!(i as i32, *elt); + } + let mut n = LinkedList::new(); + assert_eq!(n.iter().next(), None); + n.push_front(4); + let mut it = n.iter(); + assert_eq!(it.size_hint(), (1, Some(1))); + assert_eq!(it.next().unwrap(), &4); + assert_eq!(it.size_hint(), (0, Some(0))); + assert_eq!(it.next(), None); +} + +#[test] +fn test_iterator_clone() { + let mut n = LinkedList::new(); + n.push_back(2); + n.push_back(3); + n.push_back(4); + let mut it = n.iter(); + it.next(); + let mut jt = it.clone(); + assert_eq!(it.next(), jt.next()); + assert_eq!(it.next_back(), jt.next_back()); + assert_eq!(it.next(), jt.next()); +} + +#[test] +fn test_iterator_double_end() { + let mut n = LinkedList::new(); + assert_eq!(n.iter().next(), None); + n.push_front(4); + n.push_front(5); + n.push_front(6); + let mut it = n.iter(); + assert_eq!(it.size_hint(), (3, Some(3))); + assert_eq!(it.next().unwrap(), &6); + assert_eq!(it.size_hint(), (2, Some(2))); + assert_eq!(it.next_back().unwrap(), &4); + assert_eq!(it.size_hint(), (1, Some(1))); + assert_eq!(it.next_back().unwrap(), &5); + assert_eq!(it.next_back(), None); + assert_eq!(it.next(), None); +} + +#[test] +fn test_rev_iter() { + let m = generate_test(); + for (i, elt) in m.iter().rev().enumerate() { + assert_eq!((6 - i) as i32, *elt); + } + let mut n = LinkedList::new(); + assert_eq!(n.iter().rev().next(), None); + n.push_front(4); + let mut it = n.iter().rev(); + assert_eq!(it.size_hint(), (1, Some(1))); + assert_eq!(it.next().unwrap(), &4); + assert_eq!(it.size_hint(), (0, Some(0))); + assert_eq!(it.next(), None); +} + +#[test] +fn test_mut_iter() { + let mut m = generate_test(); + let mut len = m.len(); + for (i, elt) in m.iter_mut().enumerate() { + assert_eq!(i as i32, *elt); + len -= 1; + } + assert_eq!(len, 0); + let mut n = LinkedList::new(); + assert!(n.iter_mut().next().is_none()); + n.push_front(4); + n.push_back(5); + let mut it = n.iter_mut(); + assert_eq!(it.size_hint(), (2, Some(2))); + assert!(it.next().is_some()); + assert!(it.next().is_some()); + assert_eq!(it.size_hint(), (0, Some(0))); + assert!(it.next().is_none()); +} + +#[test] +fn test_iterator_mut_double_end() { + let mut n = LinkedList::new(); + assert!(n.iter_mut().next_back().is_none()); + n.push_front(4); + n.push_front(5); + n.push_front(6); + let mut it = n.iter_mut(); + assert_eq!(it.size_hint(), (3, Some(3))); + assert_eq!(*it.next().unwrap(), 6); + assert_eq!(it.size_hint(), (2, Some(2))); + assert_eq!(*it.next_back().unwrap(), 4); + assert_eq!(it.size_hint(), (1, Some(1))); + assert_eq!(*it.next_back().unwrap(), 5); + assert!(it.next_back().is_none()); + assert!(it.next().is_none()); +} + +#[test] +fn test_mut_rev_iter() { + let mut m = generate_test(); + for (i, elt) in m.iter_mut().rev().enumerate() { + assert_eq!((6 - i) as i32, *elt); + } + let mut n = LinkedList::new(); + assert!(n.iter_mut().rev().next().is_none()); + n.push_front(4); + let mut it = n.iter_mut().rev(); + assert!(it.next().is_some()); + assert!(it.next().is_none()); +} + +#[test] +fn test_eq() { + let mut n = list_from(&[]); + let mut m = list_from(&[]); + assert!(n == m); + n.push_front(1); + assert!(n != m); + m.push_back(1); + assert!(n == m); + + let n = list_from(&[2, 3, 4]); + let m = list_from(&[1, 2, 3]); + assert!(n != m); +} + +#[test] +fn test_hash() { + use crate::hash; + + let mut x = LinkedList::new(); + let mut y = LinkedList::new(); + + assert!(hash(&x) == hash(&y)); + + x.push_back(1); + x.push_back(2); + x.push_back(3); + + y.push_front(3); + y.push_front(2); + y.push_front(1); + + assert!(hash(&x) == hash(&y)); +} + +#[test] +fn test_ord() { + let n = list_from(&[]); + let m = list_from(&[1, 2, 3]); + assert!(n < m); + assert!(m > n); + assert!(n <= n); + assert!(n >= n); +} + +#[test] +fn test_ord_nan() { + let nan = 0.0f64 / 0.0; + let n = list_from(&[nan]); + let m = list_from(&[nan]); + assert!(!(n < m)); + assert!(!(n > m)); + assert!(!(n <= m)); + assert!(!(n >= m)); + + let n = list_from(&[nan]); + let one = list_from(&[1.0f64]); + assert!(!(n < one)); + assert!(!(n > one)); + assert!(!(n <= one)); + assert!(!(n >= one)); + + let u = list_from(&[1.0f64, 2.0, nan]); + let v = list_from(&[1.0f64, 2.0, 3.0]); + assert!(!(u < v)); + assert!(!(u > v)); + assert!(!(u <= v)); + assert!(!(u >= v)); + + let s = list_from(&[1.0f64, 2.0, 4.0, 2.0]); + let t = list_from(&[1.0f64, 2.0, 3.0, 2.0]); + assert!(!(s < t)); + assert!(s > one); + assert!(!(s <= one)); + assert!(s >= one); +} + +#[test] +fn test_show() { + let list: LinkedList<_> = (0..10).collect(); + assert_eq!(format!("{:?}", list), "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"); + + let list: LinkedList<_> = vec!["just", "one", "test", "more"].iter().cloned().collect(); + assert_eq!(format!("{:?}", list), "[\"just\", \"one\", \"test\", \"more\"]"); +} + +#[test] +fn test_extend_ref() { + let mut a = LinkedList::new(); + a.push_back(1); + + a.extend(&[2, 3, 4]); + + assert_eq!(a.len(), 4); + assert_eq!(a, list_from(&[1, 2, 3, 4])); + + let mut b = LinkedList::new(); + b.push_back(5); + b.push_back(6); + a.extend(&b); + + assert_eq!(a.len(), 6); + assert_eq!(a, list_from(&[1, 2, 3, 4, 5, 6])); +} + +#[test] +fn test_extend() { + let mut a = LinkedList::new(); + a.push_back(1); + a.extend(vec![2, 3, 4]); // uses iterator + + assert_eq!(a.len(), 4); + assert!(a.iter().eq(&[1, 2, 3, 4])); + + let b: LinkedList<_> = vec![5, 6, 7].into_iter().collect(); + a.extend(b); // specializes to `append` + + assert_eq!(a.len(), 7); + assert!(a.iter().eq(&[1, 2, 3, 4, 5, 6, 7])); +} + +#[test] +fn test_contains() { + let mut l = LinkedList::new(); + l.extend(&[2, 3, 4]); + + assert!(l.contains(&3)); + assert!(!l.contains(&1)); + + l.clear(); + + assert!(!l.contains(&3)); +} + +#[test] +fn drain_filter_empty() { + let mut list: LinkedList = LinkedList::new(); + + { + let mut iter = list.drain_filter(|_| true); + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + assert_eq!(iter.size_hint(), (0, Some(0))); + } + + assert_eq!(list.len(), 0); + assert_eq!(list.into_iter().collect::>(), vec![]); +} + +#[test] +fn drain_filter_zst() { + let mut list: LinkedList<_> = vec![(), (), (), (), ()].into_iter().collect(); + let initial_len = list.len(); + let mut count = 0; + + { + let mut iter = list.drain_filter(|_| true); + assert_eq!(iter.size_hint(), (0, Some(initial_len))); + while let Some(_) = iter.next() { + count += 1; + assert_eq!(iter.size_hint(), (0, Some(initial_len - count))); + } + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + assert_eq!(iter.size_hint(), (0, Some(0))); + } + + assert_eq!(count, initial_len); + assert_eq!(list.len(), 0); + assert_eq!(list.into_iter().collect::>(), vec![]); +} + +#[test] +fn drain_filter_false() { + let mut list: LinkedList<_> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10].into_iter().collect(); + + let initial_len = list.len(); + let mut count = 0; + + { + let mut iter = list.drain_filter(|_| false); + assert_eq!(iter.size_hint(), (0, Some(initial_len))); + for _ in iter.by_ref() { + count += 1; + } + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + assert_eq!(iter.size_hint(), (0, Some(0))); + } + + assert_eq!(count, 0); + assert_eq!(list.len(), initial_len); + assert_eq!(list.into_iter().collect::>(), vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); +} + +#[test] +fn drain_filter_true() { + let mut list: LinkedList<_> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10].into_iter().collect(); + + let initial_len = list.len(); + let mut count = 0; + + { + let mut iter = list.drain_filter(|_| true); + assert_eq!(iter.size_hint(), (0, Some(initial_len))); + while let Some(_) = iter.next() { + count += 1; + assert_eq!(iter.size_hint(), (0, Some(initial_len - count))); + } + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + assert_eq!(iter.size_hint(), (0, Some(0))); + } + + assert_eq!(count, initial_len); + assert_eq!(list.len(), 0); + assert_eq!(list.into_iter().collect::>(), vec![]); +} + +#[test] +fn drain_filter_complex() { + { + // [+xxx++++++xxxxx++++x+x++] + let mut list = vec![ + 1, 2, 4, 6, 7, 9, 11, 13, 15, 17, 18, 20, 22, 24, 26, 27, 29, 31, 33, 34, 35, 36, 37, + 39, + ] + .into_iter() + .collect::>(); + + let removed = list.drain_filter(|x| *x % 2 == 0).collect::>(); + assert_eq!(removed.len(), 10); + assert_eq!(removed, vec![2, 4, 6, 18, 20, 22, 24, 26, 34, 36]); + + assert_eq!(list.len(), 14); + assert_eq!( + list.into_iter().collect::>(), + vec![1, 7, 9, 11, 13, 15, 17, 27, 29, 31, 33, 35, 37, 39] + ); + } + + { + // [xxx++++++xxxxx++++x+x++] + let mut list = vec![ + 2, 4, 6, 7, 9, 11, 13, 15, 17, 18, 20, 22, 24, 26, 27, 29, 31, 33, 34, 35, 36, 37, 39, + ] + .into_iter() + .collect::>(); + + let removed = list.drain_filter(|x| *x % 2 == 0).collect::>(); + assert_eq!(removed.len(), 10); + assert_eq!(removed, vec![2, 4, 6, 18, 20, 22, 24, 26, 34, 36]); + + assert_eq!(list.len(), 13); + assert_eq!( + list.into_iter().collect::>(), + vec![7, 9, 11, 13, 15, 17, 27, 29, 31, 33, 35, 37, 39] + ); + } + + { + // [xxx++++++xxxxx++++x+x] + let mut list = + vec![2, 4, 6, 7, 9, 11, 13, 15, 17, 18, 20, 22, 24, 26, 27, 29, 31, 33, 34, 35, 36] + .into_iter() + .collect::>(); + + let removed = list.drain_filter(|x| *x % 2 == 0).collect::>(); + assert_eq!(removed.len(), 10); + assert_eq!(removed, vec![2, 4, 6, 18, 20, 22, 24, 26, 34, 36]); + + assert_eq!(list.len(), 11); + assert_eq!( + list.into_iter().collect::>(), + vec![7, 9, 11, 13, 15, 17, 27, 29, 31, 33, 35] + ); + } + + { + // [xxxxxxxxxx+++++++++++] + let mut list = vec![2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19] + .into_iter() + .collect::>(); + + let removed = list.drain_filter(|x| *x % 2 == 0).collect::>(); + assert_eq!(removed.len(), 10); + assert_eq!(removed, vec![2, 4, 6, 8, 10, 12, 14, 16, 18, 20]); + + assert_eq!(list.len(), 10); + assert_eq!(list.into_iter().collect::>(), vec![1, 3, 5, 7, 9, 11, 13, 15, 17, 19]); + } + + { + // [+++++++++++xxxxxxxxxx] + let mut list = vec![1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20] + .into_iter() + .collect::>(); + + let removed = list.drain_filter(|x| *x % 2 == 0).collect::>(); + assert_eq!(removed.len(), 10); + assert_eq!(removed, vec![2, 4, 6, 8, 10, 12, 14, 16, 18, 20]); + + assert_eq!(list.len(), 10); + assert_eq!(list.into_iter().collect::>(), vec![1, 3, 5, 7, 9, 11, 13, 15, 17, 19]); + } +} + +#[test] +fn drain_filter_drop_panic_leak() { + static mut DROPS: i32 = 0; + + struct D(bool); + + impl Drop for D { + fn drop(&mut self) { + unsafe { + DROPS += 1; + } + + if self.0 { + panic!("panic in `drop`"); + } + } + } + + let mut q = LinkedList::new(); + q.push_back(D(false)); + q.push_back(D(false)); + q.push_back(D(false)); + q.push_back(D(false)); + q.push_back(D(false)); + q.push_front(D(false)); + q.push_front(D(true)); + q.push_front(D(false)); + + catch_unwind(AssertUnwindSafe(|| drop(q.drain_filter(|_| true)))).ok(); + + assert_eq!(unsafe { DROPS }, 8); + assert!(q.is_empty()); +} + +#[test] +fn drain_filter_pred_panic_leak() { + static mut DROPS: i32 = 0; + + #[derive(Debug)] + struct D(u32); + + impl Drop for D { + fn drop(&mut self) { + unsafe { + DROPS += 1; + } + } + } + + let mut q = LinkedList::new(); + q.push_back(D(3)); + q.push_back(D(4)); + q.push_back(D(5)); + q.push_back(D(6)); + q.push_back(D(7)); + q.push_front(D(2)); + q.push_front(D(1)); + q.push_front(D(0)); + + catch_unwind(AssertUnwindSafe(|| { + drop(q.drain_filter(|item| if item.0 >= 2 { panic!() } else { true })) + })) + .ok(); + + assert_eq!(unsafe { DROPS }, 2); // 0 and 1 + assert_eq!(q.len(), 6); +} + +#[test] +fn test_drop() { + static mut DROPS: i32 = 0; + struct Elem; + impl Drop for Elem { + fn drop(&mut self) { + unsafe { + DROPS += 1; + } + } + } + + let mut ring = LinkedList::new(); + ring.push_back(Elem); + ring.push_front(Elem); + ring.push_back(Elem); + ring.push_front(Elem); + drop(ring); + + assert_eq!(unsafe { DROPS }, 4); +} + +#[test] +fn test_drop_with_pop() { + static mut DROPS: i32 = 0; + struct Elem; + impl Drop for Elem { + fn drop(&mut self) { + unsafe { + DROPS += 1; + } + } + } + + let mut ring = LinkedList::new(); + ring.push_back(Elem); + ring.push_front(Elem); + ring.push_back(Elem); + ring.push_front(Elem); + + drop(ring.pop_back()); + drop(ring.pop_front()); + assert_eq!(unsafe { DROPS }, 2); + + drop(ring); + assert_eq!(unsafe { DROPS }, 4); +} + +#[test] +fn test_drop_clear() { + static mut DROPS: i32 = 0; + struct Elem; + impl Drop for Elem { + fn drop(&mut self) { + unsafe { + DROPS += 1; + } + } + } + + let mut ring = LinkedList::new(); + ring.push_back(Elem); + ring.push_front(Elem); + ring.push_back(Elem); + ring.push_front(Elem); + ring.clear(); + assert_eq!(unsafe { DROPS }, 4); + + drop(ring); + assert_eq!(unsafe { DROPS }, 4); +} + +#[test] +fn test_drop_panic() { + static mut DROPS: i32 = 0; + + struct D(bool); + + impl Drop for D { + fn drop(&mut self) { + unsafe { + DROPS += 1; + } + + if self.0 { + panic!("panic in `drop`"); + } + } + } + + let mut q = LinkedList::new(); + q.push_back(D(false)); + q.push_back(D(false)); + q.push_back(D(false)); + q.push_back(D(false)); + q.push_back(D(false)); + q.push_front(D(false)); + q.push_front(D(false)); + q.push_front(D(true)); + + catch_unwind(move || drop(q)).ok(); + + assert_eq!(unsafe { DROPS }, 8); +} diff --git a/libgrust/rustc-lib/alloc/tests/rc.rs b/libgrust/rustc-lib/alloc/tests/rc.rs new file mode 100644 index 000000000000..501b4f0f816b --- /dev/null +++ b/libgrust/rustc-lib/alloc/tests/rc.rs @@ -0,0 +1,193 @@ +use std::any::Any; +use std::cell::RefCell; +use std::cmp::PartialEq; +use std::iter::TrustedLen; +use std::mem; +use std::rc::{Rc, Weak}; + +#[test] +fn uninhabited() { + enum Void {} + let mut a = Weak::::new(); + a = a.clone(); + assert!(a.upgrade().is_none()); + + let mut a: Weak = a; // Unsizing + a = a.clone(); + assert!(a.upgrade().is_none()); +} + +#[test] +fn slice() { + let a: Rc<[u32; 3]> = Rc::new([3, 2, 1]); + let a: Rc<[u32]> = a; // Unsizing + let b: Rc<[u32]> = Rc::from(&[3, 2, 1][..]); // Conversion + assert_eq!(a, b); + + // Exercise is_dangling() with a DST + let mut a = Rc::downgrade(&a); + a = a.clone(); + assert!(a.upgrade().is_some()); +} + +#[test] +fn trait_object() { + let a: Rc = Rc::new(4); + let a: Rc = a; // Unsizing + + // Exercise is_dangling() with a DST + let mut a = Rc::downgrade(&a); + a = a.clone(); + assert!(a.upgrade().is_some()); + + let mut b = Weak::::new(); + b = b.clone(); + assert!(b.upgrade().is_none()); + let mut b: Weak = b; // Unsizing + b = b.clone(); + assert!(b.upgrade().is_none()); +} + +#[test] +fn float_nan_ne() { + let x = Rc::new(f32::NAN); + assert!(x != x); + assert!(!(x == x)); +} + +#[test] +fn partial_eq() { + struct TestPEq(RefCell); + impl PartialEq for TestPEq { + fn eq(&self, other: &TestPEq) -> bool { + *self.0.borrow_mut() += 1; + *other.0.borrow_mut() += 1; + true + } + } + let x = Rc::new(TestPEq(RefCell::new(0))); + assert!(x == x); + assert!(!(x != x)); + assert_eq!(*x.0.borrow(), 4); +} + +#[test] +fn eq() { + #[derive(Eq)] + struct TestEq(RefCell); + impl PartialEq for TestEq { + fn eq(&self, other: &TestEq) -> bool { + *self.0.borrow_mut() += 1; + *other.0.borrow_mut() += 1; + true + } + } + let x = Rc::new(TestEq(RefCell::new(0))); + assert!(x == x); + assert!(!(x != x)); + assert_eq!(*x.0.borrow(), 0); +} + +const SHARED_ITER_MAX: u16 = 100; + +fn assert_trusted_len(_: &I) {} + +#[test] +fn shared_from_iter_normal() { + // Exercise the base implementation for non-`TrustedLen` iterators. + { + // `Filter` is never `TrustedLen` since we don't + // know statically how many elements will be kept: + let iter = (0..SHARED_ITER_MAX).filter(|x| x % 2 == 0).map(Box::new); + + // Collecting into a `Vec` or `Rc<[T]>` should make no difference: + let vec = iter.clone().collect::>(); + let rc = iter.collect::>(); + assert_eq!(&*vec, &*rc); + + // Clone a bit and let these get dropped. + { + let _rc_2 = rc.clone(); + let _rc_3 = rc.clone(); + let _rc_4 = Rc::downgrade(&_rc_3); + } + } // Drop what hasn't been here. +} + +#[test] +fn shared_from_iter_trustedlen_normal() { + // Exercise the `TrustedLen` implementation under normal circumstances + // where `size_hint()` matches `(_, Some(exact_len))`. + { + let iter = (0..SHARED_ITER_MAX).map(Box::new); + assert_trusted_len(&iter); + + // Collecting into a `Vec` or `Rc<[T]>` should make no difference: + let vec = iter.clone().collect::>(); + let rc = iter.collect::>(); + assert_eq!(&*vec, &*rc); + assert_eq!(mem::size_of::>() * SHARED_ITER_MAX as usize, mem::size_of_val(&*rc)); + + // Clone a bit and let these get dropped. + { + let _rc_2 = rc.clone(); + let _rc_3 = rc.clone(); + let _rc_4 = Rc::downgrade(&_rc_3); + } + } // Drop what hasn't been here. + + // Try a ZST to make sure it is handled well. + { + let iter = (0..SHARED_ITER_MAX).map(drop); + let vec = iter.clone().collect::>(); + let rc = iter.collect::>(); + assert_eq!(&*vec, &*rc); + assert_eq!(0, mem::size_of_val(&*rc)); + { + let _rc_2 = rc.clone(); + let _rc_3 = rc.clone(); + let _rc_4 = Rc::downgrade(&_rc_3); + } + } +} + +#[test] +#[should_panic = "I've almost got 99 problems."] +fn shared_from_iter_trustedlen_panic() { + // Exercise the `TrustedLen` implementation when `size_hint()` matches + // `(_, Some(exact_len))` but where `.next()` drops before the last iteration. + let iter = (0..SHARED_ITER_MAX).map(|val| match val { + 98 => panic!("I've almost got 99 problems."), + _ => Box::new(val), + }); + assert_trusted_len(&iter); + let _ = iter.collect::>(); + + panic!("I am unreachable."); +} + +#[test] +fn shared_from_iter_trustedlen_no_fuse() { + // Exercise the `TrustedLen` implementation when `size_hint()` matches + // `(_, Some(exact_len))` but where the iterator does not behave in a fused manner. + struct Iter(std::vec::IntoIter>>); + + unsafe impl TrustedLen for Iter {} + + impl Iterator for Iter { + fn size_hint(&self) -> (usize, Option) { + (2, Some(2)) + } + + type Item = Box; + + fn next(&mut self) -> Option { + self.0.next().flatten() + } + } + + let vec = vec![Some(Box::new(42)), Some(Box::new(24)), None, Some(Box::new(12))]; + let iter = Iter(vec.into_iter()); + assert_trusted_len(&iter); + assert_eq!(&[Box::new(42), Box::new(24)], &*iter.collect::>()); +} diff --git a/libgrust/rustc-lib/alloc/tests/slice.rs b/libgrust/rustc-lib/alloc/tests/slice.rs new file mode 100644 index 000000000000..a4f0fb415fb3 --- /dev/null +++ b/libgrust/rustc-lib/alloc/tests/slice.rs @@ -0,0 +1,1900 @@ +use std::cell::Cell; +use std::cmp::Ordering::{self, Equal, Greater, Less}; +use std::convert::identity; +use std::mem; +use std::panic; +use std::rc::Rc; +use std::sync::atomic::{AtomicUsize, Ordering::Relaxed}; + +use rand::distributions::Standard; +use rand::seq::SliceRandom; +use rand::{thread_rng, Rng, RngCore}; + +fn square(n: usize) -> usize { + n * n +} + +fn is_odd(n: &usize) -> bool { + *n % 2 == 1 +} + +#[test] +fn test_from_fn() { + // Test on-stack from_fn. + let mut v: Vec<_> = (0..3).map(square).collect(); + { + let v = v; + assert_eq!(v.len(), 3); + assert_eq!(v[0], 0); + assert_eq!(v[1], 1); + assert_eq!(v[2], 4); + } + + // Test on-heap from_fn. + v = (0..5).map(square).collect(); + { + let v = v; + assert_eq!(v.len(), 5); + assert_eq!(v[0], 0); + assert_eq!(v[1], 1); + assert_eq!(v[2], 4); + assert_eq!(v[3], 9); + assert_eq!(v[4], 16); + } +} + +#[test] +fn test_from_elem() { + // Test on-stack from_elem. + let mut v = vec![10, 10]; + { + let v = v; + assert_eq!(v.len(), 2); + assert_eq!(v[0], 10); + assert_eq!(v[1], 10); + } + + // Test on-heap from_elem. + v = vec![20; 6]; + { + let v = &v[..]; + assert_eq!(v[0], 20); + assert_eq!(v[1], 20); + assert_eq!(v[2], 20); + assert_eq!(v[3], 20); + assert_eq!(v[4], 20); + assert_eq!(v[5], 20); + } +} + +#[test] +fn test_is_empty() { + let xs: [i32; 0] = []; + assert!(xs.is_empty()); + assert!(![0].is_empty()); +} + +#[test] +fn test_len_divzero() { + type Z = [i8; 0]; + let v0: &[Z] = &[]; + let v1: &[Z] = &[[]]; + let v2: &[Z] = &[[], []]; + assert_eq!(mem::size_of::(), 0); + assert_eq!(v0.len(), 0); + assert_eq!(v1.len(), 1); + assert_eq!(v2.len(), 2); +} + +#[test] +fn test_get() { + let mut a = vec![11]; + assert_eq!(a.get(1), None); + a = vec![11, 12]; + assert_eq!(a.get(1).unwrap(), &12); + a = vec![11, 12, 13]; + assert_eq!(a.get(1).unwrap(), &12); +} + +#[test] +fn test_first() { + let mut a = vec![]; + assert_eq!(a.first(), None); + a = vec![11]; + assert_eq!(a.first().unwrap(), &11); + a = vec![11, 12]; + assert_eq!(a.first().unwrap(), &11); +} + +#[test] +fn test_first_mut() { + let mut a = vec![]; + assert_eq!(a.first_mut(), None); + a = vec![11]; + assert_eq!(*a.first_mut().unwrap(), 11); + a = vec![11, 12]; + assert_eq!(*a.first_mut().unwrap(), 11); +} + +#[test] +fn test_split_first() { + let mut a = vec![11]; + let b: &[i32] = &[]; + assert!(b.split_first().is_none()); + assert_eq!(a.split_first(), Some((&11, b))); + a = vec![11, 12]; + let b: &[i32] = &[12]; + assert_eq!(a.split_first(), Some((&11, b))); +} + +#[test] +fn test_split_first_mut() { + let mut a = vec![11]; + let b: &mut [i32] = &mut []; + assert!(b.split_first_mut().is_none()); + assert!(a.split_first_mut() == Some((&mut 11, b))); + a = vec![11, 12]; + let b: &mut [_] = &mut [12]; + assert!(a.split_first_mut() == Some((&mut 11, b))); +} + +#[test] +fn test_split_last() { + let mut a = vec![11]; + let b: &[i32] = &[]; + assert!(b.split_last().is_none()); + assert_eq!(a.split_last(), Some((&11, b))); + a = vec![11, 12]; + let b: &[_] = &[11]; + assert_eq!(a.split_last(), Some((&12, b))); +} + +#[test] +fn test_split_last_mut() { + let mut a = vec![11]; + let b: &mut [i32] = &mut []; + assert!(b.split_last_mut().is_none()); + assert!(a.split_last_mut() == Some((&mut 11, b))); + + a = vec![11, 12]; + let b: &mut [_] = &mut [11]; + assert!(a.split_last_mut() == Some((&mut 12, b))); +} + +#[test] +fn test_last() { + let mut a = vec![]; + assert_eq!(a.last(), None); + a = vec![11]; + assert_eq!(a.last().unwrap(), &11); + a = vec![11, 12]; + assert_eq!(a.last().unwrap(), &12); +} + +#[test] +fn test_last_mut() { + let mut a = vec![]; + assert_eq!(a.last_mut(), None); + a = vec![11]; + assert_eq!(*a.last_mut().unwrap(), 11); + a = vec![11, 12]; + assert_eq!(*a.last_mut().unwrap(), 12); +} + +#[test] +fn test_slice() { + // Test fixed length vector. + let vec_fixed = [1, 2, 3, 4]; + let v_a = vec_fixed[1..vec_fixed.len()].to_vec(); + assert_eq!(v_a.len(), 3); + + assert_eq!(v_a[0], 2); + assert_eq!(v_a[1], 3); + assert_eq!(v_a[2], 4); + + // Test on stack. + let vec_stack: &[_] = &[1, 2, 3]; + let v_b = vec_stack[1..3].to_vec(); + assert_eq!(v_b.len(), 2); + + assert_eq!(v_b[0], 2); + assert_eq!(v_b[1], 3); + + // Test `Box<[T]>` + let vec_unique = vec![1, 2, 3, 4, 5, 6]; + let v_d = vec_unique[1..6].to_vec(); + assert_eq!(v_d.len(), 5); + + assert_eq!(v_d[0], 2); + assert_eq!(v_d[1], 3); + assert_eq!(v_d[2], 4); + assert_eq!(v_d[3], 5); + assert_eq!(v_d[4], 6); +} + +#[test] +fn test_slice_from() { + let vec: &[_] = &[1, 2, 3, 4]; + assert_eq!(&vec[..], vec); + let b: &[_] = &[3, 4]; + assert_eq!(&vec[2..], b); + let b: &[_] = &[]; + assert_eq!(&vec[4..], b); +} + +#[test] +fn test_slice_to() { + let vec: &[_] = &[1, 2, 3, 4]; + assert_eq!(&vec[..4], vec); + let b: &[_] = &[1, 2]; + assert_eq!(&vec[..2], b); + let b: &[_] = &[]; + assert_eq!(&vec[..0], b); +} + +#[test] +fn test_pop() { + let mut v = vec![5]; + let e = v.pop(); + assert_eq!(v.len(), 0); + assert_eq!(e, Some(5)); + let f = v.pop(); + assert_eq!(f, None); + let g = v.pop(); + assert_eq!(g, None); +} + +#[test] +fn test_swap_remove() { + let mut v = vec![1, 2, 3, 4, 5]; + let mut e = v.swap_remove(0); + assert_eq!(e, 1); + assert_eq!(v, [5, 2, 3, 4]); + e = v.swap_remove(3); + assert_eq!(e, 4); + assert_eq!(v, [5, 2, 3]); +} + +#[test] +#[should_panic] +fn test_swap_remove_fail() { + let mut v = vec![1]; + let _ = v.swap_remove(0); + let _ = v.swap_remove(0); +} + +#[test] +fn test_swap_remove_noncopyable() { + // Tests that we don't accidentally run destructors twice. + let mut v: Vec> = Vec::new(); + v.push(box 0); + v.push(box 0); + v.push(box 0); + let mut _e = v.swap_remove(0); + assert_eq!(v.len(), 2); + _e = v.swap_remove(1); + assert_eq!(v.len(), 1); + _e = v.swap_remove(0); + assert_eq!(v.len(), 0); +} + +#[test] +fn test_push() { + // Test on-stack push(). + let mut v = vec![]; + v.push(1); + assert_eq!(v.len(), 1); + assert_eq!(v[0], 1); + + // Test on-heap push(). + v.push(2); + assert_eq!(v.len(), 2); + assert_eq!(v[0], 1); + assert_eq!(v[1], 2); +} + +#[test] +fn test_truncate() { + let mut v: Vec> = vec![box 6, box 5, box 4]; + v.truncate(1); + let v = v; + assert_eq!(v.len(), 1); + assert_eq!(*(v[0]), 6); + // If the unsafe block didn't drop things properly, we blow up here. +} + +#[test] +fn test_clear() { + let mut v: Vec> = vec![box 6, box 5, box 4]; + v.clear(); + assert_eq!(v.len(), 0); + // If the unsafe block didn't drop things properly, we blow up here. +} + +#[test] +fn test_retain() { + let mut v = vec![1, 2, 3, 4, 5]; + v.retain(is_odd); + assert_eq!(v, [1, 3, 5]); +} + +#[test] +fn test_binary_search() { + assert_eq!([1, 2, 3, 4, 5].binary_search(&5).ok(), Some(4)); + assert_eq!([1, 2, 3, 4, 5].binary_search(&4).ok(), Some(3)); + assert_eq!([1, 2, 3, 4, 5].binary_search(&3).ok(), Some(2)); + assert_eq!([1, 2, 3, 4, 5].binary_search(&2).ok(), Some(1)); + assert_eq!([1, 2, 3, 4, 5].binary_search(&1).ok(), Some(0)); + + assert_eq!([2, 4, 6, 8, 10].binary_search(&1).ok(), None); + assert_eq!([2, 4, 6, 8, 10].binary_search(&5).ok(), None); + assert_eq!([2, 4, 6, 8, 10].binary_search(&4).ok(), Some(1)); + assert_eq!([2, 4, 6, 8, 10].binary_search(&10).ok(), Some(4)); + + assert_eq!([2, 4, 6, 8].binary_search(&1).ok(), None); + assert_eq!([2, 4, 6, 8].binary_search(&5).ok(), None); + assert_eq!([2, 4, 6, 8].binary_search(&4).ok(), Some(1)); + assert_eq!([2, 4, 6, 8].binary_search(&8).ok(), Some(3)); + + assert_eq!([2, 4, 6].binary_search(&1).ok(), None); + assert_eq!([2, 4, 6].binary_search(&5).ok(), None); + assert_eq!([2, 4, 6].binary_search(&4).ok(), Some(1)); + assert_eq!([2, 4, 6].binary_search(&6).ok(), Some(2)); + + assert_eq!([2, 4].binary_search(&1).ok(), None); + assert_eq!([2, 4].binary_search(&5).ok(), None); + assert_eq!([2, 4].binary_search(&2).ok(), Some(0)); + assert_eq!([2, 4].binary_search(&4).ok(), Some(1)); + + assert_eq!([2].binary_search(&1).ok(), None); + assert_eq!([2].binary_search(&5).ok(), None); + assert_eq!([2].binary_search(&2).ok(), Some(0)); + + assert_eq!([].binary_search(&1).ok(), None); + assert_eq!([].binary_search(&5).ok(), None); + + assert!([1, 1, 1, 1, 1].binary_search(&1).ok() != None); + assert!([1, 1, 1, 1, 2].binary_search(&1).ok() != None); + assert!([1, 1, 1, 2, 2].binary_search(&1).ok() != None); + assert!([1, 1, 2, 2, 2].binary_search(&1).ok() != None); + assert_eq!([1, 2, 2, 2, 2].binary_search(&1).ok(), Some(0)); + + assert_eq!([1, 2, 3, 4, 5].binary_search(&6).ok(), None); + assert_eq!([1, 2, 3, 4, 5].binary_search(&0).ok(), None); +} + +#[test] +fn test_reverse() { + let mut v = vec![10, 20]; + assert_eq!(v[0], 10); + assert_eq!(v[1], 20); + v.reverse(); + assert_eq!(v[0], 20); + assert_eq!(v[1], 10); + + let mut v3 = Vec::::new(); + v3.reverse(); + assert!(v3.is_empty()); + + // check the 1-byte-types path + let mut v = (-50..51i8).collect::>(); + v.reverse(); + assert_eq!(v, (-50..51i8).rev().collect::>()); + + // check the 2-byte-types path + let mut v = (-50..51i16).collect::>(); + v.reverse(); + assert_eq!(v, (-50..51i16).rev().collect::>()); +} + +#[test] +#[cfg_attr(miri, ignore)] // Miri is too slow +fn test_sort() { + let mut rng = thread_rng(); + + for len in (2..25).chain(500..510) { + for &modulus in &[5, 10, 100, 1000] { + for _ in 0..10 { + let orig: Vec<_> = + rng.sample_iter::(&Standard).map(|x| x % modulus).take(len).collect(); + + // Sort in default order. + let mut v = orig.clone(); + v.sort(); + assert!(v.windows(2).all(|w| w[0] <= w[1])); + + // Sort in ascending order. + let mut v = orig.clone(); + v.sort_by(|a, b| a.cmp(b)); + assert!(v.windows(2).all(|w| w[0] <= w[1])); + + // Sort in descending order. + let mut v = orig.clone(); + v.sort_by(|a, b| b.cmp(a)); + assert!(v.windows(2).all(|w| w[0] >= w[1])); + + // Sort in lexicographic order. + let mut v1 = orig.clone(); + let mut v2 = orig.clone(); + v1.sort_by_key(|x| x.to_string()); + v2.sort_by_cached_key(|x| x.to_string()); + assert!(v1.windows(2).all(|w| w[0].to_string() <= w[1].to_string())); + assert!(v1 == v2); + + // Sort with many pre-sorted runs. + let mut v = orig.clone(); + v.sort(); + v.reverse(); + for _ in 0..5 { + let a = rng.gen::() % len; + let b = rng.gen::() % len; + if a < b { + v[a..b].reverse(); + } else { + v.swap(a, b); + } + } + v.sort(); + assert!(v.windows(2).all(|w| w[0] <= w[1])); + } + } + } + + // Sort using a completely random comparison function. + // This will reorder the elements *somehow*, but won't panic. + let mut v = [0; 500]; + for i in 0..v.len() { + v[i] = i as i32; + } + v.sort_by(|_, _| *[Less, Equal, Greater].choose(&mut rng).unwrap()); + v.sort(); + for i in 0..v.len() { + assert_eq!(v[i], i as i32); + } + + // Should not panic. + [0i32; 0].sort(); + [(); 10].sort(); + [(); 100].sort(); + + let mut v = [0xDEADBEEFu64]; + v.sort(); + assert!(v == [0xDEADBEEF]); +} + +#[test] +fn test_sort_stability() { + // Miri is too slow + let large_range = if cfg!(miri) { 0..0 } else { 500..510 }; + let rounds = if cfg!(miri) { 1 } else { 10 }; + + for len in (2..25).chain(large_range) { + for _ in 0..rounds { + let mut counts = [0; 10]; + + // create a vector like [(6, 1), (5, 1), (6, 2), ...], + // where the first item of each tuple is random, but + // the second item represents which occurrence of that + // number this element is, i.e., the second elements + // will occur in sorted order. + let orig: Vec<_> = (0..len) + .map(|_| { + let n = thread_rng().gen::() % 10; + counts[n] += 1; + (n, counts[n]) + }) + .collect(); + + let mut v = orig.clone(); + // Only sort on the first element, so an unstable sort + // may mix up the counts. + v.sort_by(|&(a, _), &(b, _)| a.cmp(&b)); + + // This comparison includes the count (the second item + // of the tuple), so elements with equal first items + // will need to be ordered with increasing + // counts... i.e., exactly asserting that this sort is + // stable. + assert!(v.windows(2).all(|w| w[0] <= w[1])); + + let mut v = orig.clone(); + v.sort_by_cached_key(|&(x, _)| x); + assert!(v.windows(2).all(|w| w[0] <= w[1])); + } + } +} + +#[test] +fn test_rotate_left() { + let expected: Vec<_> = (0..13).collect(); + let mut v = Vec::new(); + + // no-ops + v.clone_from(&expected); + v.rotate_left(0); + assert_eq!(v, expected); + v.rotate_left(expected.len()); + assert_eq!(v, expected); + let mut zst_array = [(), (), ()]; + zst_array.rotate_left(2); + + // happy path + v = (5..13).chain(0..5).collect(); + v.rotate_left(8); + assert_eq!(v, expected); + + let expected: Vec<_> = (0..1000).collect(); + + // small rotations in large slice, uses ptr::copy + v = (2..1000).chain(0..2).collect(); + v.rotate_left(998); + assert_eq!(v, expected); + v = (998..1000).chain(0..998).collect(); + v.rotate_left(2); + assert_eq!(v, expected); + + // non-small prime rotation, has a few rounds of swapping + v = (389..1000).chain(0..389).collect(); + v.rotate_left(1000 - 389); + assert_eq!(v, expected); +} + +#[test] +fn test_rotate_right() { + let expected: Vec<_> = (0..13).collect(); + let mut v = Vec::new(); + + // no-ops + v.clone_from(&expected); + v.rotate_right(0); + assert_eq!(v, expected); + v.rotate_right(expected.len()); + assert_eq!(v, expected); + let mut zst_array = [(), (), ()]; + zst_array.rotate_right(2); + + // happy path + v = (5..13).chain(0..5).collect(); + v.rotate_right(5); + assert_eq!(v, expected); + + let expected: Vec<_> = (0..1000).collect(); + + // small rotations in large slice, uses ptr::copy + v = (2..1000).chain(0..2).collect(); + v.rotate_right(2); + assert_eq!(v, expected); + v = (998..1000).chain(0..998).collect(); + v.rotate_right(998); + assert_eq!(v, expected); + + // non-small prime rotation, has a few rounds of swapping + v = (389..1000).chain(0..389).collect(); + v.rotate_right(389); + assert_eq!(v, expected); +} + +#[test] +fn test_concat() { + let v: [Vec; 0] = []; + let c = v.concat(); + assert_eq!(c, []); + let d = [vec![1], vec![2, 3]].concat(); + assert_eq!(d, [1, 2, 3]); + + let v: &[&[_]] = &[&[1], &[2, 3]]; + assert_eq!(v.join(&0), [1, 0, 2, 3]); + let v: &[&[_]] = &[&[1], &[2], &[3]]; + assert_eq!(v.join(&0), [1, 0, 2, 0, 3]); +} + +#[test] +fn test_join() { + let v: [Vec; 0] = []; + assert_eq!(v.join(&0), []); + assert_eq!([vec![1], vec![2, 3]].join(&0), [1, 0, 2, 3]); + assert_eq!([vec![1], vec![2], vec![3]].join(&0), [1, 0, 2, 0, 3]); + + let v: [&[_]; 2] = [&[1], &[2, 3]]; + assert_eq!(v.join(&0), [1, 0, 2, 3]); + let v: [&[_]; 3] = [&[1], &[2], &[3]]; + assert_eq!(v.join(&0), [1, 0, 2, 0, 3]); +} + +#[test] +fn test_join_nocopy() { + let v: [String; 0] = []; + assert_eq!(v.join(","), ""); + assert_eq!(["a".to_string(), "ab".into()].join(","), "a,ab"); + assert_eq!(["a".to_string(), "ab".into(), "abc".into()].join(","), "a,ab,abc"); + assert_eq!(["a".to_string(), "ab".into(), "".into()].join(","), "a,ab,"); +} + +#[test] +fn test_insert() { + let mut a = vec![1, 2, 4]; + a.insert(2, 3); + assert_eq!(a, [1, 2, 3, 4]); + + let mut a = vec![1, 2, 3]; + a.insert(0, 0); + assert_eq!(a, [0, 1, 2, 3]); + + let mut a = vec![1, 2, 3]; + a.insert(3, 4); + assert_eq!(a, [1, 2, 3, 4]); + + let mut a = vec![]; + a.insert(0, 1); + assert_eq!(a, [1]); +} + +#[test] +#[should_panic] +fn test_insert_oob() { + let mut a = vec![1, 2, 3]; + a.insert(4, 5); +} + +#[test] +fn test_remove() { + let mut a = vec![1, 2, 3, 4]; + + assert_eq!(a.remove(2), 3); + assert_eq!(a, [1, 2, 4]); + + assert_eq!(a.remove(2), 4); + assert_eq!(a, [1, 2]); + + assert_eq!(a.remove(0), 1); + assert_eq!(a, [2]); + + assert_eq!(a.remove(0), 2); + assert_eq!(a, []); +} + +#[test] +#[should_panic] +fn test_remove_fail() { + let mut a = vec![1]; + let _ = a.remove(0); + let _ = a.remove(0); +} + +#[test] +fn test_capacity() { + let mut v = vec![0]; + v.reserve_exact(10); + assert!(v.capacity() >= 11); +} + +#[test] +fn test_slice_2() { + let v = vec![1, 2, 3, 4, 5]; + let v = &v[1..3]; + assert_eq!(v.len(), 2); + assert_eq!(v[0], 2); + assert_eq!(v[1], 3); +} + +macro_rules! assert_order { + (Greater, $a:expr, $b:expr) => { + assert_eq!($a.cmp($b), Greater); + assert!($a > $b); + }; + (Less, $a:expr, $b:expr) => { + assert_eq!($a.cmp($b), Less); + assert!($a < $b); + }; + (Equal, $a:expr, $b:expr) => { + assert_eq!($a.cmp($b), Equal); + assert_eq!($a, $b); + }; +} + +#[test] +fn test_total_ord_u8() { + let c = &[1u8, 2, 3]; + assert_order!(Greater, &[1u8, 2, 3, 4][..], &c[..]); + let c = &[1u8, 2, 3, 4]; + assert_order!(Less, &[1u8, 2, 3][..], &c[..]); + let c = &[1u8, 2, 3, 6]; + assert_order!(Equal, &[1u8, 2, 3, 6][..], &c[..]); + let c = &[1u8, 2, 3, 4, 5, 6]; + assert_order!(Less, &[1u8, 2, 3, 4, 5, 5, 5, 5][..], &c[..]); + let c = &[1u8, 2, 3, 4]; + assert_order!(Greater, &[2u8, 2][..], &c[..]); +} + +#[test] +fn test_total_ord_i32() { + let c = &[1, 2, 3]; + assert_order!(Greater, &[1, 2, 3, 4][..], &c[..]); + let c = &[1, 2, 3, 4]; + assert_order!(Less, &[1, 2, 3][..], &c[..]); + let c = &[1, 2, 3, 6]; + assert_order!(Equal, &[1, 2, 3, 6][..], &c[..]); + let c = &[1, 2, 3, 4, 5, 6]; + assert_order!(Less, &[1, 2, 3, 4, 5, 5, 5, 5][..], &c[..]); + let c = &[1, 2, 3, 4]; + assert_order!(Greater, &[2, 2][..], &c[..]); +} + +#[test] +fn test_iterator() { + let xs = [1, 2, 5, 10, 11]; + let mut it = xs.iter(); + assert_eq!(it.size_hint(), (5, Some(5))); + assert_eq!(it.next().unwrap(), &1); + assert_eq!(it.size_hint(), (4, Some(4))); + assert_eq!(it.next().unwrap(), &2); + assert_eq!(it.size_hint(), (3, Some(3))); + assert_eq!(it.next().unwrap(), &5); + assert_eq!(it.size_hint(), (2, Some(2))); + assert_eq!(it.next().unwrap(), &10); + assert_eq!(it.size_hint(), (1, Some(1))); + assert_eq!(it.next().unwrap(), &11); + assert_eq!(it.size_hint(), (0, Some(0))); + assert!(it.next().is_none()); +} + +#[test] +fn test_iter_size_hints() { + let mut xs = [1, 2, 5, 10, 11]; + assert_eq!(xs.iter().size_hint(), (5, Some(5))); + assert_eq!(xs.iter_mut().size_hint(), (5, Some(5))); +} + +#[test] +fn test_iter_as_slice() { + let xs = [1, 2, 5, 10, 11]; + let mut iter = xs.iter(); + assert_eq!(iter.as_slice(), &[1, 2, 5, 10, 11]); + iter.next(); + assert_eq!(iter.as_slice(), &[2, 5, 10, 11]); +} + +#[test] +fn test_iter_as_ref() { + let xs = [1, 2, 5, 10, 11]; + let mut iter = xs.iter(); + assert_eq!(iter.as_ref(), &[1, 2, 5, 10, 11]); + iter.next(); + assert_eq!(iter.as_ref(), &[2, 5, 10, 11]); +} + +#[test] +fn test_iter_clone() { + let xs = [1, 2, 5]; + let mut it = xs.iter(); + it.next(); + let mut jt = it.clone(); + assert_eq!(it.next(), jt.next()); + assert_eq!(it.next(), jt.next()); + assert_eq!(it.next(), jt.next()); +} + +#[test] +fn test_iter_is_empty() { + let xs = [1, 2, 5, 10, 11]; + for i in 0..xs.len() { + for j in i..xs.len() { + assert_eq!(xs[i..j].iter().is_empty(), xs[i..j].is_empty()); + } + } +} + +#[test] +fn test_mut_iterator() { + let mut xs = [1, 2, 3, 4, 5]; + for x in &mut xs { + *x += 1; + } + assert!(xs == [2, 3, 4, 5, 6]) +} + +#[test] +fn test_rev_iterator() { + let xs = [1, 2, 5, 10, 11]; + let ys = [11, 10, 5, 2, 1]; + let mut i = 0; + for &x in xs.iter().rev() { + assert_eq!(x, ys[i]); + i += 1; + } + assert_eq!(i, 5); +} + +#[test] +fn test_mut_rev_iterator() { + let mut xs = [1, 2, 3, 4, 5]; + for (i, x) in xs.iter_mut().rev().enumerate() { + *x += i; + } + assert!(xs == [5, 5, 5, 5, 5]) +} + +#[test] +fn test_move_iterator() { + let xs = vec![1, 2, 3, 4, 5]; + assert_eq!(xs.into_iter().fold(0, |a: usize, b: usize| 10 * a + b), 12345); +} + +#[test] +fn test_move_rev_iterator() { + let xs = vec![1, 2, 3, 4, 5]; + assert_eq!(xs.into_iter().rev().fold(0, |a: usize, b: usize| 10 * a + b), 54321); +} + +#[test] +fn test_splitator() { + let xs = &[1, 2, 3, 4, 5]; + + let splits: &[&[_]] = &[&[1], &[3], &[5]]; + assert_eq!(xs.split(|x| *x % 2 == 0).collect::>(), splits); + let splits: &[&[_]] = &[&[], &[2, 3, 4, 5]]; + assert_eq!(xs.split(|x| *x == 1).collect::>(), splits); + let splits: &[&[_]] = &[&[1, 2, 3, 4], &[]]; + assert_eq!(xs.split(|x| *x == 5).collect::>(), splits); + let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; + assert_eq!(xs.split(|x| *x == 10).collect::>(), splits); + let splits: &[&[_]] = &[&[], &[], &[], &[], &[], &[]]; + assert_eq!(xs.split(|_| true).collect::>(), splits); + + let xs: &[i32] = &[]; + let splits: &[&[i32]] = &[&[]]; + assert_eq!(xs.split(|x| *x == 5).collect::>(), splits); +} + +#[test] +fn test_splitator_inclusive() { + let xs = &[1, 2, 3, 4, 5]; + + let splits: &[&[_]] = &[&[1, 2], &[3, 4], &[5]]; + assert_eq!(xs.split_inclusive(|x| *x % 2 == 0).collect::>(), splits); + let splits: &[&[_]] = &[&[1], &[2, 3, 4, 5]]; + assert_eq!(xs.split_inclusive(|x| *x == 1).collect::>(), splits); + let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; + assert_eq!(xs.split_inclusive(|x| *x == 5).collect::>(), splits); + let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; + assert_eq!(xs.split_inclusive(|x| *x == 10).collect::>(), splits); + let splits: &[&[_]] = &[&[1], &[2], &[3], &[4], &[5]]; + assert_eq!(xs.split_inclusive(|_| true).collect::>(), splits); + + let xs: &[i32] = &[]; + let splits: &[&[i32]] = &[&[]]; + assert_eq!(xs.split_inclusive(|x| *x == 5).collect::>(), splits); +} + +#[test] +fn test_splitator_inclusive_reverse() { + let xs = &[1, 2, 3, 4, 5]; + + let splits: &[&[_]] = &[&[5], &[3, 4], &[1, 2]]; + assert_eq!(xs.split_inclusive(|x| *x % 2 == 0).rev().collect::>(), splits); + let splits: &[&[_]] = &[&[2, 3, 4, 5], &[1]]; + assert_eq!(xs.split_inclusive(|x| *x == 1).rev().collect::>(), splits); + let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; + assert_eq!(xs.split_inclusive(|x| *x == 5).rev().collect::>(), splits); + let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; + assert_eq!(xs.split_inclusive(|x| *x == 10).rev().collect::>(), splits); + let splits: &[&[_]] = &[&[5], &[4], &[3], &[2], &[1]]; + assert_eq!(xs.split_inclusive(|_| true).rev().collect::>(), splits); + + let xs: &[i32] = &[]; + let splits: &[&[i32]] = &[&[]]; + assert_eq!(xs.split_inclusive(|x| *x == 5).rev().collect::>(), splits); +} + +#[test] +fn test_splitator_mut_inclusive() { + let xs = &mut [1, 2, 3, 4, 5]; + + let splits: &[&[_]] = &[&[1, 2], &[3, 4], &[5]]; + assert_eq!(xs.split_inclusive_mut(|x| *x % 2 == 0).collect::>(), splits); + let splits: &[&[_]] = &[&[1], &[2, 3, 4, 5]]; + assert_eq!(xs.split_inclusive_mut(|x| *x == 1).collect::>(), splits); + let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; + assert_eq!(xs.split_inclusive_mut(|x| *x == 5).collect::>(), splits); + let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; + assert_eq!(xs.split_inclusive_mut(|x| *x == 10).collect::>(), splits); + let splits: &[&[_]] = &[&[1], &[2], &[3], &[4], &[5]]; + assert_eq!(xs.split_inclusive_mut(|_| true).collect::>(), splits); + + let xs: &mut [i32] = &mut []; + let splits: &[&[i32]] = &[&[]]; + assert_eq!(xs.split_inclusive_mut(|x| *x == 5).collect::>(), splits); +} + +#[test] +fn test_splitator_mut_inclusive_reverse() { + let xs = &mut [1, 2, 3, 4, 5]; + + let splits: &[&[_]] = &[&[5], &[3, 4], &[1, 2]]; + assert_eq!(xs.split_inclusive_mut(|x| *x % 2 == 0).rev().collect::>(), splits); + let splits: &[&[_]] = &[&[2, 3, 4, 5], &[1]]; + assert_eq!(xs.split_inclusive_mut(|x| *x == 1).rev().collect::>(), splits); + let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; + assert_eq!(xs.split_inclusive_mut(|x| *x == 5).rev().collect::>(), splits); + let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; + assert_eq!(xs.split_inclusive_mut(|x| *x == 10).rev().collect::>(), splits); + let splits: &[&[_]] = &[&[5], &[4], &[3], &[2], &[1]]; + assert_eq!(xs.split_inclusive_mut(|_| true).rev().collect::>(), splits); + + let xs: &mut [i32] = &mut []; + let splits: &[&[i32]] = &[&[]]; + assert_eq!(xs.split_inclusive_mut(|x| *x == 5).rev().collect::>(), splits); +} + +#[test] +fn test_splitnator() { + let xs = &[1, 2, 3, 4, 5]; + + let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; + assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::>(), splits); + let splits: &[&[_]] = &[&[1], &[3, 4, 5]]; + assert_eq!(xs.splitn(2, |x| *x % 2 == 0).collect::>(), splits); + let splits: &[&[_]] = &[&[], &[], &[], &[4, 5]]; + assert_eq!(xs.splitn(4, |_| true).collect::>(), splits); + + let xs: &[i32] = &[]; + let splits: &[&[i32]] = &[&[]]; + assert_eq!(xs.splitn(2, |x| *x == 5).collect::>(), splits); +} + +#[test] +fn test_splitnator_mut() { + let xs = &mut [1, 2, 3, 4, 5]; + + let splits: &[&mut [_]] = &[&mut [1, 2, 3, 4, 5]]; + assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::>(), splits); + let splits: &[&mut [_]] = &[&mut [1], &mut [3, 4, 5]]; + assert_eq!(xs.splitn_mut(2, |x| *x % 2 == 0).collect::>(), splits); + let splits: &[&mut [_]] = &[&mut [], &mut [], &mut [], &mut [4, 5]]; + assert_eq!(xs.splitn_mut(4, |_| true).collect::>(), splits); + + let xs: &mut [i32] = &mut []; + let splits: &[&mut [i32]] = &[&mut []]; + assert_eq!(xs.splitn_mut(2, |x| *x == 5).collect::>(), splits); +} + +#[test] +fn test_rsplitator() { + let xs = &[1, 2, 3, 4, 5]; + + let splits: &[&[_]] = &[&[5], &[3], &[1]]; + assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::>(), splits); + let splits: &[&[_]] = &[&[2, 3, 4, 5], &[]]; + assert_eq!(xs.split(|x| *x == 1).rev().collect::>(), splits); + let splits: &[&[_]] = &[&[], &[1, 2, 3, 4]]; + assert_eq!(xs.split(|x| *x == 5).rev().collect::>(), splits); + let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; + assert_eq!(xs.split(|x| *x == 10).rev().collect::>(), splits); + + let xs: &[i32] = &[]; + let splits: &[&[i32]] = &[&[]]; + assert_eq!(xs.split(|x| *x == 5).rev().collect::>(), splits); +} + +#[test] +fn test_rsplitnator() { + let xs = &[1, 2, 3, 4, 5]; + + let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]]; + assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::>(), splits); + let splits: &[&[_]] = &[&[5], &[1, 2, 3]]; + assert_eq!(xs.rsplitn(2, |x| *x % 2 == 0).collect::>(), splits); + let splits: &[&[_]] = &[&[], &[], &[], &[1, 2]]; + assert_eq!(xs.rsplitn(4, |_| true).collect::>(), splits); + + let xs: &[i32] = &[]; + let splits: &[&[i32]] = &[&[]]; + assert_eq!(xs.rsplitn(2, |x| *x == 5).collect::>(), splits); + assert!(xs.rsplitn(0, |x| *x % 2 == 0).next().is_none()); +} + +#[test] +fn test_windowsator() { + let v = &[1, 2, 3, 4]; + + let wins: &[&[_]] = &[&[1, 2], &[2, 3], &[3, 4]]; + assert_eq!(v.windows(2).collect::>(), wins); + + let wins: &[&[_]] = &[&[1, 2, 3], &[2, 3, 4]]; + assert_eq!(v.windows(3).collect::>(), wins); + assert!(v.windows(6).next().is_none()); + + let wins: &[&[_]] = &[&[3, 4], &[2, 3], &[1, 2]]; + assert_eq!(v.windows(2).rev().collect::>(), wins); +} + +#[test] +#[should_panic] +fn test_windowsator_0() { + let v = &[1, 2, 3, 4]; + let _it = v.windows(0); +} + +#[test] +fn test_chunksator() { + let v = &[1, 2, 3, 4, 5]; + + assert_eq!(v.chunks(2).len(), 3); + + let chunks: &[&[_]] = &[&[1, 2], &[3, 4], &[5]]; + assert_eq!(v.chunks(2).collect::>(), chunks); + let chunks: &[&[_]] = &[&[1, 2, 3], &[4, 5]]; + assert_eq!(v.chunks(3).collect::>(), chunks); + let chunks: &[&[_]] = &[&[1, 2, 3, 4, 5]]; + assert_eq!(v.chunks(6).collect::>(), chunks); + + let chunks: &[&[_]] = &[&[5], &[3, 4], &[1, 2]]; + assert_eq!(v.chunks(2).rev().collect::>(), chunks); +} + +#[test] +#[should_panic] +fn test_chunksator_0() { + let v = &[1, 2, 3, 4]; + let _it = v.chunks(0); +} + +#[test] +fn test_chunks_exactator() { + let v = &[1, 2, 3, 4, 5]; + + assert_eq!(v.chunks_exact(2).len(), 2); + + let chunks: &[&[_]] = &[&[1, 2], &[3, 4]]; + assert_eq!(v.chunks_exact(2).collect::>(), chunks); + let chunks: &[&[_]] = &[&[1, 2, 3]]; + assert_eq!(v.chunks_exact(3).collect::>(), chunks); + let chunks: &[&[_]] = &[]; + assert_eq!(v.chunks_exact(6).collect::>(), chunks); + + let chunks: &[&[_]] = &[&[3, 4], &[1, 2]]; + assert_eq!(v.chunks_exact(2).rev().collect::>(), chunks); +} + +#[test] +#[should_panic] +fn test_chunks_exactator_0() { + let v = &[1, 2, 3, 4]; + let _it = v.chunks_exact(0); +} + +#[test] +fn test_rchunksator() { + let v = &[1, 2, 3, 4, 5]; + + assert_eq!(v.rchunks(2).len(), 3); + + let chunks: &[&[_]] = &[&[4, 5], &[2, 3], &[1]]; + assert_eq!(v.rchunks(2).collect::>(), chunks); + let chunks: &[&[_]] = &[&[3, 4, 5], &[1, 2]]; + assert_eq!(v.rchunks(3).collect::>(), chunks); + let chunks: &[&[_]] = &[&[1, 2, 3, 4, 5]]; + assert_eq!(v.rchunks(6).collect::>(), chunks); + + let chunks: &[&[_]] = &[&[1], &[2, 3], &[4, 5]]; + assert_eq!(v.rchunks(2).rev().collect::>(), chunks); +} + +#[test] +#[should_panic] +fn test_rchunksator_0() { + let v = &[1, 2, 3, 4]; + let _it = v.rchunks(0); +} + +#[test] +fn test_rchunks_exactator() { + let v = &[1, 2, 3, 4, 5]; + + assert_eq!(v.rchunks_exact(2).len(), 2); + + let chunks: &[&[_]] = &[&[4, 5], &[2, 3]]; + assert_eq!(v.rchunks_exact(2).collect::>(), chunks); + let chunks: &[&[_]] = &[&[3, 4, 5]]; + assert_eq!(v.rchunks_exact(3).collect::>(), chunks); + let chunks: &[&[_]] = &[]; + assert_eq!(v.rchunks_exact(6).collect::>(), chunks); + + let chunks: &[&[_]] = &[&[2, 3], &[4, 5]]; + assert_eq!(v.rchunks_exact(2).rev().collect::>(), chunks); +} + +#[test] +#[should_panic] +fn test_rchunks_exactator_0() { + let v = &[1, 2, 3, 4]; + let _it = v.rchunks_exact(0); +} + +#[test] +fn test_reverse_part() { + let mut values = [1, 2, 3, 4, 5]; + values[1..4].reverse(); + assert!(values == [1, 4, 3, 2, 5]); +} + +#[test] +fn test_show() { + macro_rules! test_show_vec { + ($x:expr, $x_str:expr) => {{ + let (x, x_str) = ($x, $x_str); + assert_eq!(format!("{:?}", x), x_str); + assert_eq!(format!("{:?}", x), x_str); + }}; + } + let empty = Vec::::new(); + test_show_vec!(empty, "[]"); + test_show_vec!(vec![1], "[1]"); + test_show_vec!(vec![1, 2, 3], "[1, 2, 3]"); + test_show_vec!(vec![vec![], vec![1], vec![1, 1]], "[[], [1], [1, 1]]"); + + let empty_mut: &mut [i32] = &mut []; + test_show_vec!(empty_mut, "[]"); + let v = &mut [1]; + test_show_vec!(v, "[1]"); + let v = &mut [1, 2, 3]; + test_show_vec!(v, "[1, 2, 3]"); + let v: &mut [&mut [_]] = &mut [&mut [], &mut [1], &mut [1, 1]]; + test_show_vec!(v, "[[], [1], [1, 1]]"); +} + +#[test] +fn test_vec_default() { + macro_rules! t { + ($ty:ty) => {{ + let v: $ty = Default::default(); + assert!(v.is_empty()); + }}; + } + + t!(&[i32]); + t!(Vec); +} + +#[test] +#[should_panic] +fn test_overflow_does_not_cause_segfault() { + let mut v = vec![]; + v.reserve_exact(!0); + v.push(1); + v.push(2); +} + +#[test] +#[should_panic] +fn test_overflow_does_not_cause_segfault_managed() { + let mut v = vec![Rc::new(1)]; + v.reserve_exact(!0); + v.push(Rc::new(2)); +} + +#[test] +fn test_mut_split_at() { + let mut values = [1, 2, 3, 4, 5]; + { + let (left, right) = values.split_at_mut(2); + { + let left: &[_] = left; + assert!(left[..left.len()] == [1, 2]); + } + for p in left { + *p += 1; + } + + { + let right: &[_] = right; + assert!(right[..right.len()] == [3, 4, 5]); + } + for p in right { + *p += 2; + } + } + + assert!(values == [2, 3, 5, 6, 7]); +} + +#[derive(Clone, PartialEq)] +struct Foo; + +#[test] +fn test_iter_zero_sized() { + let mut v = vec![Foo, Foo, Foo]; + assert_eq!(v.len(), 3); + let mut cnt = 0; + + for f in &v { + assert!(*f == Foo); + cnt += 1; + } + assert_eq!(cnt, 3); + + for f in &v[1..3] { + assert!(*f == Foo); + cnt += 1; + } + assert_eq!(cnt, 5); + + for f in &mut v { + assert!(*f == Foo); + cnt += 1; + } + assert_eq!(cnt, 8); + + for f in v { + assert!(f == Foo); + cnt += 1; + } + assert_eq!(cnt, 11); + + let xs: [Foo; 3] = [Foo, Foo, Foo]; + cnt = 0; + for f in &xs { + assert!(*f == Foo); + cnt += 1; + } + assert!(cnt == 3); +} + +#[test] +fn test_shrink_to_fit() { + let mut xs = vec![0, 1, 2, 3]; + for i in 4..100 { + xs.push(i) + } + assert_eq!(xs.capacity(), 128); + xs.shrink_to_fit(); + assert_eq!(xs.capacity(), 100); + assert_eq!(xs, (0..100).collect::>()); +} + +#[test] +fn test_starts_with() { + assert!(b"foobar".starts_with(b"foo")); + assert!(!b"foobar".starts_with(b"oob")); + assert!(!b"foobar".starts_with(b"bar")); + assert!(!b"foo".starts_with(b"foobar")); + assert!(!b"bar".starts_with(b"foobar")); + assert!(b"foobar".starts_with(b"foobar")); + let empty: &[u8] = &[]; + assert!(empty.starts_with(empty)); + assert!(!empty.starts_with(b"foo")); + assert!(b"foobar".starts_with(empty)); +} + +#[test] +fn test_ends_with() { + assert!(b"foobar".ends_with(b"bar")); + assert!(!b"foobar".ends_with(b"oba")); + assert!(!b"foobar".ends_with(b"foo")); + assert!(!b"foo".ends_with(b"foobar")); + assert!(!b"bar".ends_with(b"foobar")); + assert!(b"foobar".ends_with(b"foobar")); + let empty: &[u8] = &[]; + assert!(empty.ends_with(empty)); + assert!(!empty.ends_with(b"foo")); + assert!(b"foobar".ends_with(empty)); +} + +#[test] +fn test_mut_splitator() { + let mut xs = [0, 1, 0, 2, 3, 0, 0, 4, 5, 0]; + assert_eq!(xs.split_mut(|x| *x == 0).count(), 6); + for slice in xs.split_mut(|x| *x == 0) { + slice.reverse(); + } + assert!(xs == [0, 1, 0, 3, 2, 0, 0, 5, 4, 0]); + + let mut xs = [0, 1, 0, 2, 3, 0, 0, 4, 5, 0, 6, 7]; + for slice in xs.split_mut(|x| *x == 0).take(5) { + slice.reverse(); + } + assert!(xs == [0, 1, 0, 3, 2, 0, 0, 5, 4, 0, 6, 7]); +} + +#[test] +fn test_mut_splitator_rev() { + let mut xs = [1, 2, 0, 3, 4, 0, 0, 5, 6, 0]; + for slice in xs.split_mut(|x| *x == 0).rev().take(4) { + slice.reverse(); + } + assert!(xs == [1, 2, 0, 4, 3, 0, 0, 6, 5, 0]); +} + +#[test] +fn test_get_mut() { + let mut v = [0, 1, 2]; + assert_eq!(v.get_mut(3), None); + v.get_mut(1).map(|e| *e = 7); + assert_eq!(v[1], 7); + let mut x = 2; + assert_eq!(v.get_mut(2), Some(&mut x)); +} + +#[test] +fn test_mut_chunks() { + let mut v = [0, 1, 2, 3, 4, 5, 6]; + assert_eq!(v.chunks_mut(3).len(), 3); + for (i, chunk) in v.chunks_mut(3).enumerate() { + for x in chunk { + *x = i as u8; + } + } + let result = [0, 0, 0, 1, 1, 1, 2]; + assert_eq!(v, result); +} + +#[test] +fn test_mut_chunks_rev() { + let mut v = [0, 1, 2, 3, 4, 5, 6]; + for (i, chunk) in v.chunks_mut(3).rev().enumerate() { + for x in chunk { + *x = i as u8; + } + } + let result = [2, 2, 2, 1, 1, 1, 0]; + assert_eq!(v, result); +} + +#[test] +#[should_panic] +fn test_mut_chunks_0() { + let mut v = [1, 2, 3, 4]; + let _it = v.chunks_mut(0); +} + +#[test] +fn test_mut_chunks_exact() { + let mut v = [0, 1, 2, 3, 4, 5, 6]; + assert_eq!(v.chunks_exact_mut(3).len(), 2); + for (i, chunk) in v.chunks_exact_mut(3).enumerate() { + for x in chunk { + *x = i as u8; + } + } + let result = [0, 0, 0, 1, 1, 1, 6]; + assert_eq!(v, result); +} + +#[test] +fn test_mut_chunks_exact_rev() { + let mut v = [0, 1, 2, 3, 4, 5, 6]; + for (i, chunk) in v.chunks_exact_mut(3).rev().enumerate() { + for x in chunk { + *x = i as u8; + } + } + let result = [1, 1, 1, 0, 0, 0, 6]; + assert_eq!(v, result); +} + +#[test] +#[should_panic] +fn test_mut_chunks_exact_0() { + let mut v = [1, 2, 3, 4]; + let _it = v.chunks_exact_mut(0); +} + +#[test] +fn test_mut_rchunks() { + let mut v = [0, 1, 2, 3, 4, 5, 6]; + assert_eq!(v.rchunks_mut(3).len(), 3); + for (i, chunk) in v.rchunks_mut(3).enumerate() { + for x in chunk { + *x = i as u8; + } + } + let result = [2, 1, 1, 1, 0, 0, 0]; + assert_eq!(v, result); +} + +#[test] +fn test_mut_rchunks_rev() { + let mut v = [0, 1, 2, 3, 4, 5, 6]; + for (i, chunk) in v.rchunks_mut(3).rev().enumerate() { + for x in chunk { + *x = i as u8; + } + } + let result = [0, 1, 1, 1, 2, 2, 2]; + assert_eq!(v, result); +} + +#[test] +#[should_panic] +fn test_mut_rchunks_0() { + let mut v = [1, 2, 3, 4]; + let _it = v.rchunks_mut(0); +} + +#[test] +fn test_mut_rchunks_exact() { + let mut v = [0, 1, 2, 3, 4, 5, 6]; + assert_eq!(v.rchunks_exact_mut(3).len(), 2); + for (i, chunk) in v.rchunks_exact_mut(3).enumerate() { + for x in chunk { + *x = i as u8; + } + } + let result = [0, 1, 1, 1, 0, 0, 0]; + assert_eq!(v, result); +} + +#[test] +fn test_mut_rchunks_exact_rev() { + let mut v = [0, 1, 2, 3, 4, 5, 6]; + for (i, chunk) in v.rchunks_exact_mut(3).rev().enumerate() { + for x in chunk { + *x = i as u8; + } + } + let result = [0, 0, 0, 0, 1, 1, 1]; + assert_eq!(v, result); +} + +#[test] +#[should_panic] +fn test_mut_rchunks_exact_0() { + let mut v = [1, 2, 3, 4]; + let _it = v.rchunks_exact_mut(0); +} + +#[test] +fn test_mut_last() { + let mut x = [1, 2, 3, 4, 5]; + let h = x.last_mut(); + assert_eq!(*h.unwrap(), 5); + + let y: &mut [i32] = &mut []; + assert!(y.last_mut().is_none()); +} + +#[test] +fn test_to_vec() { + let xs: Box<_> = box [1, 2, 3]; + let ys = xs.to_vec(); + assert_eq!(ys, [1, 2, 3]); +} + +#[test] +fn test_in_place_iterator_specialization() { + let src: Box<[usize]> = box [1, 2, 3]; + let src_ptr = src.as_ptr(); + let sink: Box<_> = src.into_vec().into_iter().map(std::convert::identity).collect(); + let sink_ptr = sink.as_ptr(); + assert_eq!(src_ptr, sink_ptr); +} + +#[test] +fn test_box_slice_clone() { + let data = vec![vec![0, 1], vec![0], vec![1]]; + let data2 = data.clone().into_boxed_slice().clone().to_vec(); + + assert_eq!(data, data2); +} + +#[test] +#[allow(unused_must_use)] // here, we care about the side effects of `.clone()` +#[cfg_attr(target_os = "emscripten", ignore)] +fn test_box_slice_clone_panics() { + use std::sync::atomic::{AtomicUsize, Ordering}; + use std::sync::Arc; + + struct Canary { + count: Arc, + panics: bool, + } + + impl Drop for Canary { + fn drop(&mut self) { + self.count.fetch_add(1, Ordering::SeqCst); + } + } + + impl Clone for Canary { + fn clone(&self) -> Self { + if self.panics { + panic!() + } + + Canary { count: self.count.clone(), panics: self.panics } + } + } + + let drop_count = Arc::new(AtomicUsize::new(0)); + let canary = Canary { count: drop_count.clone(), panics: false }; + let panic = Canary { count: drop_count.clone(), panics: true }; + + std::panic::catch_unwind(move || { + // When xs is dropped, +5. + let xs = + vec![canary.clone(), canary.clone(), canary.clone(), panic, canary].into_boxed_slice(); + + // When panic is cloned, +3. + xs.clone(); + }) + .unwrap_err(); + + // Total = 8 + assert_eq!(drop_count.load(Ordering::SeqCst), 8); +} + +#[test] +fn test_copy_from_slice() { + let src = [0, 1, 2, 3, 4, 5]; + let mut dst = [0; 6]; + dst.copy_from_slice(&src); + assert_eq!(src, dst) +} + +#[test] +#[should_panic(expected = "source slice length (4) does not match destination slice length (5)")] +fn test_copy_from_slice_dst_longer() { + let src = [0, 1, 2, 3]; + let mut dst = [0; 5]; + dst.copy_from_slice(&src); +} + +#[test] +#[should_panic(expected = "source slice length (4) does not match destination slice length (3)")] +fn test_copy_from_slice_dst_shorter() { + let src = [0, 1, 2, 3]; + let mut dst = [0; 3]; + dst.copy_from_slice(&src); +} + +const MAX_LEN: usize = 80; + +static DROP_COUNTS: [AtomicUsize; MAX_LEN] = [ + // FIXME(RFC 1109): AtomicUsize is not Copy. + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), + AtomicUsize::new(0), +]; + +static VERSIONS: AtomicUsize = AtomicUsize::new(0); + +#[derive(Clone, Eq)] +struct DropCounter { + x: u32, + id: usize, + version: Cell, +} + +impl PartialEq for DropCounter { + fn eq(&self, other: &Self) -> bool { + self.partial_cmp(other) == Some(Ordering::Equal) + } +} + +impl PartialOrd for DropCounter { + fn partial_cmp(&self, other: &Self) -> Option { + self.version.set(self.version.get() + 1); + other.version.set(other.version.get() + 1); + VERSIONS.fetch_add(2, Relaxed); + self.x.partial_cmp(&other.x) + } +} + +impl Ord for DropCounter { + fn cmp(&self, other: &Self) -> Ordering { + self.partial_cmp(other).unwrap() + } +} + +impl Drop for DropCounter { + fn drop(&mut self) { + DROP_COUNTS[self.id].fetch_add(1, Relaxed); + VERSIONS.fetch_sub(self.version.get(), Relaxed); + } +} + +macro_rules! test { + ($input:ident, $func:ident) => { + let len = $input.len(); + + // Work out the total number of comparisons required to sort + // this array... + let mut count = 0usize; + $input.to_owned().$func(|a, b| { + count += 1; + a.cmp(b) + }); + + // ... and then panic on each and every single one. + for panic_countdown in 0..count { + // Refresh the counters. + VERSIONS.store(0, Relaxed); + for i in 0..len { + DROP_COUNTS[i].store(0, Relaxed); + } + + let v = $input.to_owned(); + let _ = std::panic::catch_unwind(move || { + let mut v = v; + let mut panic_countdown = panic_countdown; + v.$func(|a, b| { + if panic_countdown == 0 { + SILENCE_PANIC.with(|s| s.set(true)); + panic!(); + } + panic_countdown -= 1; + a.cmp(b) + }) + }); + + // Check that the number of things dropped is exactly + // what we expect (i.e., the contents of `v`). + for (i, c) in DROP_COUNTS.iter().enumerate().take(len) { + let count = c.load(Relaxed); + assert!(count == 1, "found drop count == {} for i == {}, len == {}", count, i, len); + } + + // Check that the most recent versions of values were dropped. + assert_eq!(VERSIONS.load(Relaxed), 0); + } + }; +} + +thread_local!(static SILENCE_PANIC: Cell = Cell::new(false)); + +#[test] +#[cfg_attr(target_os = "emscripten", ignore)] // no threads +fn panic_safe() { + let prev = panic::take_hook(); + panic::set_hook(Box::new(move |info| { + if !SILENCE_PANIC.with(|s| s.get()) { + prev(info); + } + })); + + let mut rng = thread_rng(); + + // Miri is too slow (but still need to `chain` to make the types match) + let lens = if cfg!(miri) { (1..10).chain(0..0) } else { (1..20).chain(70..MAX_LEN) }; + let moduli: &[u32] = if cfg!(miri) { &[5] } else { &[5, 20, 50] }; + + for len in lens { + for &modulus in moduli { + for &has_runs in &[false, true] { + let mut input = (0..len) + .map(|id| DropCounter { + x: rng.next_u32() % modulus, + id: id, + version: Cell::new(0), + }) + .collect::>(); + + if has_runs { + for c in &mut input { + c.x = c.id as u32; + } + + for _ in 0..5 { + let a = rng.gen::() % len; + let b = rng.gen::() % len; + if a < b { + input[a..b].reverse(); + } else { + input.swap(a, b); + } + } + } + + test!(input, sort_by); + test!(input, sort_unstable_by); + } + } + } + + // Set default panic hook again. + drop(panic::take_hook()); +} + +#[test] +fn repeat_generic_slice() { + assert_eq!([1, 2].repeat(2), vec![1, 2, 1, 2]); + assert_eq!([1, 2, 3, 4].repeat(0), vec![]); + assert_eq!([1, 2, 3, 4].repeat(1), vec![1, 2, 3, 4]); + assert_eq!([1, 2, 3, 4].repeat(3), vec![1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]); +} + +#[test] +#[allow(unreachable_patterns)] +fn subslice_patterns() { + // This test comprehensively checks the passing static and dynamic semantics + // of subslice patterns `..`, `x @ ..`, `ref x @ ..`, and `ref mut @ ..` + // in slice patterns `[$($pat), $(,)?]` . + + #[derive(PartialEq, Debug, Clone)] + struct N(u8); + + macro_rules! n { + ($($e:expr),* $(,)?) => { + [$(N($e)),*] + } + } + + macro_rules! c { + ($inp:expr, $typ:ty, $out:expr $(,)?) => { + assert_eq!($out, identity::<$typ>($inp)); + }; + } + + macro_rules! m { + ($e:expr, $p:pat => $b:expr) => { + match $e { + $p => $b, + _ => panic!(), + } + }; + } + + // == Slices == + + // Matching slices using `ref` patterns: + let mut v = vec![N(0), N(1), N(2), N(3), N(4)]; + let mut vc = (0..=4).collect::>(); + + let [..] = v[..]; // Always matches. + m!(v[..], [N(0), ref sub @ .., N(4)] => c!(sub, &[N], n![1, 2, 3])); + m!(v[..], [N(0), ref sub @ ..] => c!(sub, &[N], n![1, 2, 3, 4])); + m!(v[..], [ref sub @ .., N(4)] => c!(sub, &[N], n![0, 1, 2, 3])); + m!(v[..], [ref sub @ .., _, _, _, _, _] => c!(sub, &[N], &n![] as &[N])); + m!(v[..], [_, _, _, _, _, ref sub @ ..] => c!(sub, &[N], &n![] as &[N])); + m!(vc[..], [x, .., y] => c!((x, y), (u8, u8), (0, 4))); + + // Matching slices using `ref mut` patterns: + let [..] = v[..]; // Always matches. + m!(v[..], [N(0), ref mut sub @ .., N(4)] => c!(sub, &mut [N], n![1, 2, 3])); + m!(v[..], [N(0), ref mut sub @ ..] => c!(sub, &mut [N], n![1, 2, 3, 4])); + m!(v[..], [ref mut sub @ .., N(4)] => c!(sub, &mut [N], n![0, 1, 2, 3])); + m!(v[..], [ref mut sub @ .., _, _, _, _, _] => c!(sub, &mut [N], &mut n![] as &mut [N])); + m!(v[..], [_, _, _, _, _, ref mut sub @ ..] => c!(sub, &mut [N], &mut n![] as &mut [N])); + m!(vc[..], [x, .., y] => c!((x, y), (u8, u8), (0, 4))); + + // Matching slices using default binding modes (&): + let [..] = &v[..]; // Always matches. + m!(&v[..], [N(0), sub @ .., N(4)] => c!(sub, &[N], n![1, 2, 3])); + m!(&v[..], [N(0), sub @ ..] => c!(sub, &[N], n![1, 2, 3, 4])); + m!(&v[..], [sub @ .., N(4)] => c!(sub, &[N], n![0, 1, 2, 3])); + m!(&v[..], [sub @ .., _, _, _, _, _] => c!(sub, &[N], &n![] as &[N])); + m!(&v[..], [_, _, _, _, _, sub @ ..] => c!(sub, &[N], &n![] as &[N])); + m!(&vc[..], [x, .., y] => c!((x, y), (&u8, &u8), (&0, &4))); + + // Matching slices using default binding modes (&mut): + let [..] = &mut v[..]; // Always matches. + m!(&mut v[..], [N(0), sub @ .., N(4)] => c!(sub, &mut [N], n![1, 2, 3])); + m!(&mut v[..], [N(0), sub @ ..] => c!(sub, &mut [N], n![1, 2, 3, 4])); + m!(&mut v[..], [sub @ .., N(4)] => c!(sub, &mut [N], n![0, 1, 2, 3])); + m!(&mut v[..], [sub @ .., _, _, _, _, _] => c!(sub, &mut [N], &mut n![] as &mut [N])); + m!(&mut v[..], [_, _, _, _, _, sub @ ..] => c!(sub, &mut [N], &mut n![] as &mut [N])); + m!(&mut vc[..], [x, .., y] => c!((x, y), (&mut u8, &mut u8), (&mut 0, &mut 4))); + + // == Arrays == + let mut v = n![0, 1, 2, 3, 4]; + let vc = [0, 1, 2, 3, 4]; + + // Matching arrays by value: + m!(v.clone(), [N(0), sub @ .., N(4)] => c!(sub, [N; 3], n![1, 2, 3])); + m!(v.clone(), [N(0), sub @ ..] => c!(sub, [N; 4], n![1, 2, 3, 4])); + m!(v.clone(), [sub @ .., N(4)] => c!(sub, [N; 4], n![0, 1, 2, 3])); + m!(v.clone(), [sub @ .., _, _, _, _, _] => c!(sub, [N; 0], n![] as [N; 0])); + m!(v.clone(), [_, _, _, _, _, sub @ ..] => c!(sub, [N; 0], n![] as [N; 0])); + m!(v.clone(), [x, .., y] => c!((x, y), (N, N), (N(0), N(4)))); + m!(v.clone(), [..] => ()); + + // Matching arrays by ref patterns: + m!(v, [N(0), ref sub @ .., N(4)] => c!(sub, &[N; 3], &n![1, 2, 3])); + m!(v, [N(0), ref sub @ ..] => c!(sub, &[N; 4], &n![1, 2, 3, 4])); + m!(v, [ref sub @ .., N(4)] => c!(sub, &[N; 4], &n![0, 1, 2, 3])); + m!(v, [ref sub @ .., _, _, _, _, _] => c!(sub, &[N; 0], &n![] as &[N; 0])); + m!(v, [_, _, _, _, _, ref sub @ ..] => c!(sub, &[N; 0], &n![] as &[N; 0])); + m!(vc, [x, .., y] => c!((x, y), (u8, u8), (0, 4))); + + // Matching arrays by ref mut patterns: + m!(v, [N(0), ref mut sub @ .., N(4)] => c!(sub, &mut [N; 3], &mut n![1, 2, 3])); + m!(v, [N(0), ref mut sub @ ..] => c!(sub, &mut [N; 4], &mut n![1, 2, 3, 4])); + m!(v, [ref mut sub @ .., N(4)] => c!(sub, &mut [N; 4], &mut n![0, 1, 2, 3])); + m!(v, [ref mut sub @ .., _, _, _, _, _] => c!(sub, &mut [N; 0], &mut n![] as &mut [N; 0])); + m!(v, [_, _, _, _, _, ref mut sub @ ..] => c!(sub, &mut [N; 0], &mut n![] as &mut [N; 0])); + + // Matching arrays by default binding modes (&): + m!(&v, [N(0), sub @ .., N(4)] => c!(sub, &[N; 3], &n![1, 2, 3])); + m!(&v, [N(0), sub @ ..] => c!(sub, &[N; 4], &n![1, 2, 3, 4])); + m!(&v, [sub @ .., N(4)] => c!(sub, &[N; 4], &n![0, 1, 2, 3])); + m!(&v, [sub @ .., _, _, _, _, _] => c!(sub, &[N; 0], &n![] as &[N; 0])); + m!(&v, [_, _, _, _, _, sub @ ..] => c!(sub, &[N; 0], &n![] as &[N; 0])); + m!(&v, [..] => ()); + m!(&v, [x, .., y] => c!((x, y), (&N, &N), (&N(0), &N(4)))); + + // Matching arrays by default binding modes (&mut): + m!(&mut v, [N(0), sub @ .., N(4)] => c!(sub, &mut [N; 3], &mut n![1, 2, 3])); + m!(&mut v, [N(0), sub @ ..] => c!(sub, &mut [N; 4], &mut n![1, 2, 3, 4])); + m!(&mut v, [sub @ .., N(4)] => c!(sub, &mut [N; 4], &mut n![0, 1, 2, 3])); + m!(&mut v, [sub @ .., _, _, _, _, _] => c!(sub, &mut [N; 0], &mut n![] as &[N; 0])); + m!(&mut v, [_, _, _, _, _, sub @ ..] => c!(sub, &mut [N; 0], &mut n![] as &[N; 0])); + m!(&mut v, [..] => ()); + m!(&mut v, [x, .., y] => c!((x, y), (&mut N, &mut N), (&mut N(0), &mut N(4)))); +} diff --git a/libgrust/rustc-lib/alloc/tests/str.rs b/libgrust/rustc-lib/alloc/tests/str.rs new file mode 100644 index 000000000000..834dd4656ff7 --- /dev/null +++ b/libgrust/rustc-lib/alloc/tests/str.rs @@ -0,0 +1,1973 @@ +use std::borrow::Cow; +use std::cmp::Ordering::{Equal, Greater, Less}; +use std::str::from_utf8; + +#[test] +fn test_le() { + assert!("" <= ""); + assert!("" <= "foo"); + assert!("foo" <= "foo"); + assert_ne!("foo", "bar"); +} + +#[test] +fn test_find() { + assert_eq!("hello".find('l'), Some(2)); + assert_eq!("hello".find(|c: char| c == 'o'), Some(4)); + assert!("hello".find('x').is_none()); + assert!("hello".find(|c: char| c == 'x').is_none()); + assert_eq!("ประเทศไทย中华Việt Nam".find('华'), Some(30)); + assert_eq!("ประเทศไทย中华Việt Nam".find(|c: char| c == '华'), Some(30)); +} + +#[test] +fn test_rfind() { + assert_eq!("hello".rfind('l'), Some(3)); + assert_eq!("hello".rfind(|c: char| c == 'o'), Some(4)); + assert!("hello".rfind('x').is_none()); + assert!("hello".rfind(|c: char| c == 'x').is_none()); + assert_eq!("ประเทศไทย中华Việt Nam".rfind('华'), Some(30)); + assert_eq!("ประเทศไทย中华Việt Nam".rfind(|c: char| c == '华'), Some(30)); +} + +#[test] +fn test_collect() { + let empty = ""; + let s: String = empty.chars().collect(); + assert_eq!(empty, s); + let data = "ประเทศไทย中"; + let s: String = data.chars().collect(); + assert_eq!(data, s); +} + +#[test] +fn test_into_bytes() { + let data = String::from("asdf"); + let buf = data.into_bytes(); + assert_eq!(buf, b"asdf"); +} + +#[test] +fn test_find_str() { + // byte positions + assert_eq!("".find(""), Some(0)); + assert!("banana".find("apple pie").is_none()); + + let data = "abcabc"; + assert_eq!(data[0..6].find("ab"), Some(0)); + assert_eq!(data[2..6].find("ab"), Some(3 - 2)); + assert!(data[2..4].find("ab").is_none()); + + let string = "ประเทศไทย中华Việt Nam"; + let mut data = String::from(string); + data.push_str(string); + assert!(data.find("ไท华").is_none()); + assert_eq!(data[0..43].find(""), Some(0)); + assert_eq!(data[6..43].find(""), Some(6 - 6)); + + assert_eq!(data[0..43].find("ประ"), Some(0)); + assert_eq!(data[0..43].find("ทศไ"), Some(12)); + assert_eq!(data[0..43].find("ย中"), Some(24)); + assert_eq!(data[0..43].find("iệt"), Some(34)); + assert_eq!(data[0..43].find("Nam"), Some(40)); + + assert_eq!(data[43..86].find("ประ"), Some(43 - 43)); + assert_eq!(data[43..86].find("ทศไ"), Some(55 - 43)); + assert_eq!(data[43..86].find("ย中"), Some(67 - 43)); + assert_eq!(data[43..86].find("iệt"), Some(77 - 43)); + assert_eq!(data[43..86].find("Nam"), Some(83 - 43)); + + // find every substring -- assert that it finds it, or an earlier occurrence. + let string = "Việt Namacbaabcaabaaba"; + for (i, ci) in string.char_indices() { + let ip = i + ci.len_utf8(); + for j in string[ip..].char_indices().map(|(i, _)| i).chain(Some(string.len() - ip)) { + let pat = &string[i..ip + j]; + assert!(match string.find(pat) { + None => false, + Some(x) => x <= i, + }); + assert!(match string.rfind(pat) { + None => false, + Some(x) => x >= i, + }); + } + } +} + +fn s(x: &str) -> String { + x.to_string() +} + +macro_rules! test_concat { + ($expected: expr, $string: expr) => {{ + let s: String = $string.concat(); + assert_eq!($expected, s); + }}; +} + +#[test] +fn test_concat_for_different_types() { + test_concat!("ab", vec![s("a"), s("b")]); + test_concat!("ab", vec!["a", "b"]); +} + +#[test] +fn test_concat_for_different_lengths() { + let empty: &[&str] = &[]; + test_concat!("", empty); + test_concat!("a", ["a"]); + test_concat!("ab", ["a", "b"]); + test_concat!("abc", ["", "a", "bc"]); +} + +macro_rules! test_join { + ($expected: expr, $string: expr, $delim: expr) => {{ + let s = $string.join($delim); + assert_eq!($expected, s); + }}; +} + +#[test] +fn test_join_for_different_types() { + test_join!("a-b", ["a", "b"], "-"); + let hyphen = "-".to_string(); + test_join!("a-b", [s("a"), s("b")], &*hyphen); + test_join!("a-b", vec!["a", "b"], &*hyphen); + test_join!("a-b", &*vec!["a", "b"], "-"); + test_join!("a-b", vec![s("a"), s("b")], "-"); +} + +#[test] +fn test_join_for_different_lengths() { + let empty: &[&str] = &[]; + test_join!("", empty, "-"); + test_join!("a", ["a"], "-"); + test_join!("a-b", ["a", "b"], "-"); + test_join!("-a-bc", ["", "a", "bc"], "-"); +} + +// join has fast paths for small separators up to 4 bytes +// this tests the slow paths. +#[test] +fn test_join_for_different_lengths_with_long_separator() { + assert_eq!("～～～～～".len(), 15); + + let empty: &[&str] = &[]; + test_join!("", empty, "～～～～～"); + test_join!("a", ["a"], "～～～～～"); + test_join!("a～～～～～b", ["a", "b"], "～～～～～"); + test_join!("～～～～～a～～～～～bc", ["", "a", "bc"], "～～～～～"); +} + +#[test] +#[cfg_attr(miri, ignore)] // Miri is too slow +fn test_unsafe_slice() { + assert_eq!("ab", unsafe { "abc".get_unchecked(0..2) }); + assert_eq!("bc", unsafe { "abc".get_unchecked(1..3) }); + assert_eq!("", unsafe { "abc".get_unchecked(1..1) }); + fn a_million_letter_a() -> String { + let mut i = 0; + let mut rs = String::new(); + while i < 100000 { + rs.push_str("aaaaaaaaaa"); + i += 1; + } + rs + } + fn half_a_million_letter_a() -> String { + let mut i = 0; + let mut rs = String::new(); + while i < 100000 { + rs.push_str("aaaaa"); + i += 1; + } + rs + } + let letters = a_million_letter_a(); + assert_eq!(half_a_million_letter_a(), unsafe { letters.get_unchecked(0..500000) }); +} + +#[test] +fn test_starts_with() { + assert!("".starts_with("")); + assert!("abc".starts_with("")); + assert!("abc".starts_with("a")); + assert!(!"a".starts_with("abc")); + assert!(!"".starts_with("abc")); + assert!(!"ödd".starts_with("-")); + assert!("ödd".starts_with("öd")); +} + +#[test] +fn test_ends_with() { + assert!("".ends_with("")); + assert!("abc".ends_with("")); + assert!("abc".ends_with("c")); + assert!(!"a".ends_with("abc")); + assert!(!"".ends_with("abc")); + assert!(!"ddö".ends_with("-")); + assert!("ddö".ends_with("dö")); +} + +#[test] +fn test_is_empty() { + assert!("".is_empty()); + assert!(!"a".is_empty()); +} + +#[test] +fn test_replacen() { + assert_eq!("".replacen('a', "b", 5), ""); + assert_eq!("acaaa".replacen("a", "b", 3), "bcbba"); + assert_eq!("aaaa".replacen("a", "b", 0), "aaaa"); + + let test = "test"; + assert_eq!(" test test ".replacen(test, "toast", 3), " toast toast "); + assert_eq!(" test test ".replacen(test, "toast", 0), " test test "); + assert_eq!(" test test ".replacen(test, "", 5), " "); + + assert_eq!("qwer123zxc789".replacen(char::is_numeric, "", 3), "qwerzxc789"); +} + +#[test] +fn test_replace() { + let a = "a"; + assert_eq!("".replace(a, "b"), ""); + assert_eq!("a".replace(a, "b"), "b"); + assert_eq!("ab".replace(a, "b"), "bb"); + let test = "test"; + assert_eq!(" test test ".replace(test, "toast"), " toast toast "); + assert_eq!(" test test ".replace(test, ""), " "); +} + +#[test] +fn test_replace_2a() { + let data = "ประเทศไทย中华"; + let repl = "دولة الكويت"; + + let a = "ประเ"; + let a2 = "دولة الكويتทศไทย中华"; + assert_eq!(data.replace(a, repl), a2); +} + +#[test] +fn test_replace_2b() { + let data = "ประเทศไทย中华"; + let repl = "دولة الكويت"; + + let b = "ะเ"; + let b2 = "ปรدولة الكويتทศไทย中华"; + assert_eq!(data.replace(b, repl), b2); +} + +#[test] +fn test_replace_2c() { + let data = "ประเทศไทย中华"; + let repl = "دولة الكويت"; + + let c = "中华"; + let c2 = "ประเทศไทยدولة الكويت"; + assert_eq!(data.replace(c, repl), c2); +} + +#[test] +fn test_replace_2d() { + let data = "ประเทศไทย中华"; + let repl = "دولة الكويت"; + + let d = "ไท华"; + assert_eq!(data.replace(d, repl), data); +} + +#[test] +fn test_replace_pattern() { + let data = "abcdαβγδabcdαβγδ"; + assert_eq!(data.replace("dαβ", "😺😺😺"), "abc😺😺😺γδabc😺😺😺γδ"); + assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ"); + assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ"); + assert_eq!(data.replace(|c| c == 'γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ"); +} + +// The current implementation of SliceIndex fails to handle methods +// orthogonally from range types; therefore, it is worth testing +// all of the indexing operations on each input. +mod slice_index { + // Test a slicing operation **that should succeed,** + // testing it on all of the indexing methods. + // + // This is not suitable for testing failure on invalid inputs. + macro_rules! assert_range_eq { + ($s:expr, $range:expr, $expected:expr) => { + let mut s: String = $s.to_owned(); + let mut expected: String = $expected.to_owned(); + { + let s: &str = &s; + let expected: &str = &expected; + + assert_eq!(&s[$range], expected, "(in assertion for: index)"); + assert_eq!(s.get($range), Some(expected), "(in assertion for: get)"); + unsafe { + assert_eq!( + s.get_unchecked($range), + expected, + "(in assertion for: get_unchecked)", + ); + } + } + { + let s: &mut str = &mut s; + let expected: &mut str = &mut expected; + + assert_eq!(&mut s[$range], expected, "(in assertion for: index_mut)",); + assert_eq!( + s.get_mut($range), + Some(&mut expected[..]), + "(in assertion for: get_mut)", + ); + unsafe { + assert_eq!( + s.get_unchecked_mut($range), + expected, + "(in assertion for: get_unchecked_mut)", + ); + } + } + }; + } + + // Make sure the macro can actually detect bugs, + // because if it can't, then what are we even doing here? + // + // (Be aware this only demonstrates the ability to detect bugs + // in the FIRST method that panics, as the macro is not designed + // to be used in `should_panic`) + #[test] + #[should_panic(expected = "out of bounds")] + fn assert_range_eq_can_fail_by_panic() { + assert_range_eq!("abc", 0..5, "abc"); + } + + // (Be aware this only demonstrates the ability to detect bugs + // in the FIRST method it calls, as the macro is not designed + // to be used in `should_panic`) + #[test] + #[should_panic(expected = "==")] + fn assert_range_eq_can_fail_by_inequality() { + assert_range_eq!("abc", 0..2, "abc"); + } + + // Generates test cases for bad index operations. + // + // This generates `should_panic` test cases for Index/IndexMut + // and `None` test cases for get/get_mut. + macro_rules! panic_cases { + ($( + in mod $case_name:ident { + data: $data:expr; + + // optional: + // + // a similar input for which DATA[input] succeeds, and the corresponding + // output str. This helps validate "critical points" where an input range + // straddles the boundary between valid and invalid. + // (such as the input `len..len`, which is just barely valid) + $( + good: data[$good:expr] == $output:expr; + )* + + bad: data[$bad:expr]; + message: $expect_msg:expr; // must be a literal + } + )*) => {$( + mod $case_name { + #[test] + fn pass() { + let mut v: String = $data.into(); + + $( assert_range_eq!(v, $good, $output); )* + + { + let v: &str = &v; + assert_eq!(v.get($bad), None, "(in None assertion for get)"); + } + + { + let v: &mut str = &mut v; + assert_eq!(v.get_mut($bad), None, "(in None assertion for get_mut)"); + } + } + + #[test] + #[should_panic(expected = $expect_msg)] + fn index_fail() { + let v: String = $data.into(); + let v: &str = &v; + let _v = &v[$bad]; + } + + #[test] + #[should_panic(expected = $expect_msg)] + fn index_mut_fail() { + let mut v: String = $data.into(); + let v: &mut str = &mut v; + let _v = &mut v[$bad]; + } + } + )*}; + } + + #[test] + fn simple_ascii() { + assert_range_eq!("abc", .., "abc"); + + assert_range_eq!("abc", 0..2, "ab"); + assert_range_eq!("abc", 0..=1, "ab"); + assert_range_eq!("abc", ..2, "ab"); + assert_range_eq!("abc", ..=1, "ab"); + + assert_range_eq!("abc", 1..3, "bc"); + assert_range_eq!("abc", 1..=2, "bc"); + assert_range_eq!("abc", 1..1, ""); + assert_range_eq!("abc", 1..=0, ""); + } + + #[test] + fn simple_unicode() { + // 日本 + assert_range_eq!("\u{65e5}\u{672c}", .., "\u{65e5}\u{672c}"); + + assert_range_eq!("\u{65e5}\u{672c}", 0..3, "\u{65e5}"); + assert_range_eq!("\u{65e5}\u{672c}", 0..=2, "\u{65e5}"); + assert_range_eq!("\u{65e5}\u{672c}", ..3, "\u{65e5}"); + assert_range_eq!("\u{65e5}\u{672c}", ..=2, "\u{65e5}"); + + assert_range_eq!("\u{65e5}\u{672c}", 3..6, "\u{672c}"); + assert_range_eq!("\u{65e5}\u{672c}", 3..=5, "\u{672c}"); + assert_range_eq!("\u{65e5}\u{672c}", 3.., "\u{672c}"); + + let data = "ประเทศไทย中华"; + assert_range_eq!(data, 0..3, "ป"); + assert_range_eq!(data, 3..6, "ร"); + assert_range_eq!(data, 3..3, ""); + assert_range_eq!(data, 30..33, "华"); + + /*0: 中 + 3: 华 + 6: V + 7: i + 8: ệ + 11: t + 12: + 13: N + 14: a + 15: m */ + let ss = "中华Việt Nam"; + assert_range_eq!(ss, 3..6, "华"); + assert_range_eq!(ss, 6..16, "Việt Nam"); + assert_range_eq!(ss, 6..=15, "Việt Nam"); + assert_range_eq!(ss, 6.., "Việt Nam"); + + assert_range_eq!(ss, 0..3, "中"); + assert_range_eq!(ss, 3..7, "华V"); + assert_range_eq!(ss, 3..=6, "华V"); + assert_range_eq!(ss, 3..3, ""); + assert_range_eq!(ss, 3..=2, ""); + } + + #[test] + #[cfg_attr(target_os = "emscripten", ignore)] // hits an OOM + #[cfg_attr(miri, ignore)] // Miri is too slow + fn simple_big() { + fn a_million_letter_x() -> String { + let mut i = 0; + let mut rs = String::new(); + while i < 100000 { + rs.push_str("华华华华华华华华华华"); + i += 1; + } + rs + } + fn half_a_million_letter_x() -> String { + let mut i = 0; + let mut rs = String::new(); + while i < 100000 { + rs.push_str("华华华华华"); + i += 1; + } + rs + } + let letters = a_million_letter_x(); + assert_range_eq!(letters, 0..3 * 500000, half_a_million_letter_x()); + } + + #[test] + #[should_panic] + fn test_slice_fail() { + &"中华Việt Nam"[0..2]; + } + + panic_cases! { + in mod rangefrom_len { + data: "abcdef"; + good: data[6..] == ""; + bad: data[7..]; + message: "out of bounds"; + } + + in mod rangeto_len { + data: "abcdef"; + good: data[..6] == "abcdef"; + bad: data[..7]; + message: "out of bounds"; + } + + in mod rangetoinclusive_len { + data: "abcdef"; + good: data[..=5] == "abcdef"; + bad: data[..=6]; + message: "out of bounds"; + } + + in mod rangeinclusive_len { + data: "abcdef"; + good: data[0..=5] == "abcdef"; + bad: data[0..=6]; + message: "out of bounds"; + } + + in mod range_len_len { + data: "abcdef"; + good: data[6..6] == ""; + bad: data[7..7]; + message: "out of bounds"; + } + + in mod rangeinclusive_len_len { + data: "abcdef"; + good: data[6..=5] == ""; + bad: data[7..=6]; + message: "out of bounds"; + } + } + + panic_cases! { + in mod rangeinclusive_exhausted { + data: "abcdef"; + + good: data[0..=5] == "abcdef"; + good: data[{ + let mut iter = 0..=5; + iter.by_ref().count(); // exhaust it + iter + }] == ""; + + // 0..=6 is out of bounds before exhaustion, so it + // stands to reason that it still would be after. + bad: data[{ + let mut iter = 0..=6; + iter.by_ref().count(); // exhaust it + iter + }]; + message: "out of bounds"; + } + } + + panic_cases! { + in mod range_neg_width { + data: "abcdef"; + good: data[4..4] == ""; + bad: data[4..3]; + message: "begin <= end (4 <= 3)"; + } + + in mod rangeinclusive_neg_width { + data: "abcdef"; + good: data[4..=3] == ""; + bad: data[4..=2]; + message: "begin <= end (4 <= 3)"; + } + } + + mod overflow { + panic_cases! { + in mod rangeinclusive { + data: "hello"; + // note: using 0 specifically ensures that the result of overflowing is 0..0, + // so that `get` doesn't simply return None for the wrong reason. + bad: data[0..=usize::MAX]; + message: "maximum usize"; + } + + in mod rangetoinclusive { + data: "hello"; + bad: data[..=usize::MAX]; + message: "maximum usize"; + } + } + } + + mod boundary { + const DATA: &str = "abcαβγ"; + + const BAD_START: usize = 4; + const GOOD_START: usize = 3; + const BAD_END: usize = 6; + const GOOD_END: usize = 7; + const BAD_END_INCL: usize = BAD_END - 1; + const GOOD_END_INCL: usize = GOOD_END - 1; + + // it is especially important to test all of the different range types here + // because some of the logic may be duplicated as part of micro-optimizations + // to dodge unicode boundary checks on half-ranges. + panic_cases! { + in mod range_1 { + data: super::DATA; + bad: data[super::BAD_START..super::GOOD_END]; + message: + "byte index 4 is not a char boundary; it is inside 'α' (bytes 3..5) of"; + } + + in mod range_2 { + data: super::DATA; + bad: data[super::GOOD_START..super::BAD_END]; + message: + "byte index 6 is not a char boundary; it is inside 'β' (bytes 5..7) of"; + } + + in mod rangefrom { + data: super::DATA; + bad: data[super::BAD_START..]; + message: + "byte index 4 is not a char boundary; it is inside 'α' (bytes 3..5) of"; + } + + in mod rangeto { + data: super::DATA; + bad: data[..super::BAD_END]; + message: + "byte index 6 is not a char boundary; it is inside 'β' (bytes 5..7) of"; + } + + in mod rangeinclusive_1 { + data: super::DATA; + bad: data[super::BAD_START..=super::GOOD_END_INCL]; + message: + "byte index 4 is not a char boundary; it is inside 'α' (bytes 3..5) of"; + } + + in mod rangeinclusive_2 { + data: super::DATA; + bad: data[super::GOOD_START..=super::BAD_END_INCL]; + message: + "byte index 6 is not a char boundary; it is inside 'β' (bytes 5..7) of"; + } + + in mod rangetoinclusive { + data: super::DATA; + bad: data[..=super::BAD_END_INCL]; + message: + "byte index 6 is not a char boundary; it is inside 'β' (bytes 5..7) of"; + } + } + } + + const LOREM_PARAGRAPH: &str = "\ + Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse quis lorem \ + sit amet dolor ultricies condimentum. Praesent iaculis purus elit, ac malesuada \ + quam malesuada in. Duis sed orci eros. Suspendisse sit amet magna mollis, mollis \ + nunc luctus, imperdiet mi. Integer fringilla non sem ut lacinia. Fusce varius \ + tortor a risus porttitor hendrerit. Morbi mauris dui, ultricies nec tempus vel, \ + gravida nec quam."; + + // check the panic includes the prefix of the sliced string + #[test] + #[should_panic(expected = "byte index 1024 is out of bounds of `Lorem ipsum dolor sit amet")] + fn test_slice_fail_truncated_1() { + &LOREM_PARAGRAPH[..1024]; + } + // check the truncation in the panic message + #[test] + #[should_panic(expected = "luctus, im`[...]")] + fn test_slice_fail_truncated_2() { + &LOREM_PARAGRAPH[..1024]; + } +} + +#[test] +fn test_str_slice_rangetoinclusive_ok() { + let s = "abcαβγ"; + assert_eq!(&s[..=2], "abc"); + assert_eq!(&s[..=4], "abcα"); +} + +#[test] +#[should_panic] +fn test_str_slice_rangetoinclusive_notok() { + let s = "abcαβγ"; + &s[..=3]; +} + +#[test] +fn test_str_slicemut_rangetoinclusive_ok() { + let mut s = "abcαβγ".to_owned(); + let s: &mut str = &mut s; + assert_eq!(&mut s[..=2], "abc"); + assert_eq!(&mut s[..=4], "abcα"); +} + +#[test] +#[should_panic] +fn test_str_slicemut_rangetoinclusive_notok() { + let mut s = "abcαβγ".to_owned(); + let s: &mut str = &mut s; + &mut s[..=3]; +} + +#[test] +fn test_is_char_boundary() { + let s = "ศไทย中华Việt Nam β-release 🐱123"; + assert!(s.is_char_boundary(0)); + assert!(s.is_char_boundary(s.len())); + assert!(!s.is_char_boundary(s.len() + 1)); + for (i, ch) in s.char_indices() { + // ensure character locations are boundaries and continuation bytes are not + assert!(s.is_char_boundary(i), "{} is a char boundary in {:?}", i, s); + for j in 1..ch.len_utf8() { + assert!( + !s.is_char_boundary(i + j), + "{} should not be a char boundary in {:?}", + i + j, + s + ); + } + } +} + +#[test] +fn test_trim_start_matches() { + let v: &[char] = &[]; + assert_eq!(" *** foo *** ".trim_start_matches(v), " *** foo *** "); + let chars: &[char] = &['*', ' ']; + assert_eq!(" *** foo *** ".trim_start_matches(chars), "foo *** "); + assert_eq!(" *** *** ".trim_start_matches(chars), ""); + assert_eq!("foo *** ".trim_start_matches(chars), "foo *** "); + + assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11"); + let chars: &[char] = &['1', '2']; + assert_eq!("12foo1bar12".trim_start_matches(chars), "foo1bar12"); + assert_eq!("123foo1bar123".trim_start_matches(|c: char| c.is_numeric()), "foo1bar123"); +} + +#[test] +fn test_trim_end_matches() { + let v: &[char] = &[]; + assert_eq!(" *** foo *** ".trim_end_matches(v), " *** foo *** "); + let chars: &[char] = &['*', ' ']; + assert_eq!(" *** foo *** ".trim_end_matches(chars), " *** foo"); + assert_eq!(" *** *** ".trim_end_matches(chars), ""); + assert_eq!(" *** foo".trim_end_matches(chars), " *** foo"); + + assert_eq!("11foo1bar11".trim_end_matches('1'), "11foo1bar"); + let chars: &[char] = &['1', '2']; + assert_eq!("12foo1bar12".trim_end_matches(chars), "12foo1bar"); + assert_eq!("123foo1bar123".trim_end_matches(|c: char| c.is_numeric()), "123foo1bar"); +} + +#[test] +fn test_trim_matches() { + let v: &[char] = &[]; + assert_eq!(" *** foo *** ".trim_matches(v), " *** foo *** "); + let chars: &[char] = &['*', ' ']; + assert_eq!(" *** foo *** ".trim_matches(chars), "foo"); + assert_eq!(" *** *** ".trim_matches(chars), ""); + assert_eq!("foo".trim_matches(chars), "foo"); + + assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar"); + let chars: &[char] = &['1', '2']; + assert_eq!("12foo1bar12".trim_matches(chars), "foo1bar"); + assert_eq!("123foo1bar123".trim_matches(|c: char| c.is_numeric()), "foo1bar"); +} + +#[test] +fn test_trim_start() { + assert_eq!("".trim_start(), ""); + assert_eq!("a".trim_start(), "a"); + assert_eq!(" ".trim_start(), ""); + assert_eq!(" blah".trim_start(), "blah"); + assert_eq!(" \u{3000} wut".trim_start(), "wut"); + assert_eq!("hey ".trim_start(), "hey "); +} + +#[test] +fn test_trim_end() { + assert_eq!("".trim_end(), ""); + assert_eq!("a".trim_end(), "a"); + assert_eq!(" ".trim_end(), ""); + assert_eq!("blah ".trim_end(), "blah"); + assert_eq!("wut \u{3000} ".trim_end(), "wut"); + assert_eq!(" hey".trim_end(), " hey"); +} + +#[test] +fn test_trim() { + assert_eq!("".trim(), ""); + assert_eq!("a".trim(), "a"); + assert_eq!(" ".trim(), ""); + assert_eq!(" blah ".trim(), "blah"); + assert_eq!("\nwut \u{3000} ".trim(), "wut"); + assert_eq!(" hey dude ".trim(), "hey dude"); +} + +#[test] +fn test_is_whitespace() { + assert!("".chars().all(|c| c.is_whitespace())); + assert!(" ".chars().all(|c| c.is_whitespace())); + assert!("\u{2009}".chars().all(|c| c.is_whitespace())); // Thin space + assert!(" \n\t ".chars().all(|c| c.is_whitespace())); + assert!(!" _ ".chars().all(|c| c.is_whitespace())); +} + +#[test] +fn test_is_utf8() { + // deny overlong encodings + assert!(from_utf8(&[0xc0, 0x80]).is_err()); + assert!(from_utf8(&[0xc0, 0xae]).is_err()); + assert!(from_utf8(&[0xe0, 0x80, 0x80]).is_err()); + assert!(from_utf8(&[0xe0, 0x80, 0xaf]).is_err()); + assert!(from_utf8(&[0xe0, 0x81, 0x81]).is_err()); + assert!(from_utf8(&[0xf0, 0x82, 0x82, 0xac]).is_err()); + assert!(from_utf8(&[0xf4, 0x90, 0x80, 0x80]).is_err()); + + // deny surrogates + assert!(from_utf8(&[0xED, 0xA0, 0x80]).is_err()); + assert!(from_utf8(&[0xED, 0xBF, 0xBF]).is_err()); + + assert!(from_utf8(&[0xC2, 0x80]).is_ok()); + assert!(from_utf8(&[0xDF, 0xBF]).is_ok()); + assert!(from_utf8(&[0xE0, 0xA0, 0x80]).is_ok()); + assert!(from_utf8(&[0xED, 0x9F, 0xBF]).is_ok()); + assert!(from_utf8(&[0xEE, 0x80, 0x80]).is_ok()); + assert!(from_utf8(&[0xEF, 0xBF, 0xBF]).is_ok()); + assert!(from_utf8(&[0xF0, 0x90, 0x80, 0x80]).is_ok()); + assert!(from_utf8(&[0xF4, 0x8F, 0xBF, 0xBF]).is_ok()); +} + +#[test] +fn from_utf8_mostly_ascii() { + // deny invalid bytes embedded in long stretches of ascii + for i in 32..64 { + let mut data = [0; 128]; + data[i] = 0xC0; + assert!(from_utf8(&data).is_err()); + data[i] = 0xC2; + assert!(from_utf8(&data).is_err()); + } +} + +#[test] +fn from_utf8_error() { + macro_rules! test { + ($input: expr, $expected_valid_up_to: expr, $expected_error_len: expr) => { + let error = from_utf8($input).unwrap_err(); + assert_eq!(error.valid_up_to(), $expected_valid_up_to); + assert_eq!(error.error_len(), $expected_error_len); + }; + } + test!(b"A\xC3\xA9 \xFF ", 4, Some(1)); + test!(b"A\xC3\xA9 \x80 ", 4, Some(1)); + test!(b"A\xC3\xA9 \xC1 ", 4, Some(1)); + test!(b"A\xC3\xA9 \xC1", 4, Some(1)); + test!(b"A\xC3\xA9 \xC2", 4, None); + test!(b"A\xC3\xA9 \xC2 ", 4, Some(1)); + test!(b"A\xC3\xA9 \xC2\xC0", 4, Some(1)); + test!(b"A\xC3\xA9 \xE0", 4, None); + test!(b"A\xC3\xA9 \xE0\x9F", 4, Some(1)); + test!(b"A\xC3\xA9 \xE0\xA0", 4, None); + test!(b"A\xC3\xA9 \xE0\xA0\xC0", 4, Some(2)); + test!(b"A\xC3\xA9 \xE0\xA0 ", 4, Some(2)); + test!(b"A\xC3\xA9 \xED\xA0\x80 ", 4, Some(1)); + test!(b"A\xC3\xA9 \xF1", 4, None); + test!(b"A\xC3\xA9 \xF1\x80", 4, None); + test!(b"A\xC3\xA9 \xF1\x80\x80", 4, None); + test!(b"A\xC3\xA9 \xF1 ", 4, Some(1)); + test!(b"A\xC3\xA9 \xF1\x80 ", 4, Some(2)); + test!(b"A\xC3\xA9 \xF1\x80\x80 ", 4, Some(3)); +} + +#[test] +fn test_as_bytes() { + // no null + let v = [ + 224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228, 184, 173, 229, 141, 142, + 86, 105, 225, 187, 135, 116, 32, 78, 97, 109, + ]; + let b: &[u8] = &[]; + assert_eq!("".as_bytes(), b); + assert_eq!("abc".as_bytes(), b"abc"); + assert_eq!("ศไทย中华Việt Nam".as_bytes(), v); +} + +#[test] +#[should_panic] +fn test_as_bytes_fail() { + // Don't double free. (I'm not sure if this exercises the + // original problem code path anymore.) + let s = String::from(""); + let _bytes = s.as_bytes(); + panic!(); +} + +#[test] +fn test_as_ptr() { + let buf = "hello".as_ptr(); + unsafe { + assert_eq!(*buf.offset(0), b'h'); + assert_eq!(*buf.offset(1), b'e'); + assert_eq!(*buf.offset(2), b'l'); + assert_eq!(*buf.offset(3), b'l'); + assert_eq!(*buf.offset(4), b'o'); + } +} + +#[test] +fn vec_str_conversions() { + let s1: String = String::from("All mimsy were the borogoves"); + + let v: Vec = s1.as_bytes().to_vec(); + let s2: String = String::from(from_utf8(&v).unwrap()); + let mut i = 0; + let n1 = s1.len(); + let n2 = v.len(); + assert_eq!(n1, n2); + while i < n1 { + let a: u8 = s1.as_bytes()[i]; + let b: u8 = s2.as_bytes()[i]; + assert_eq!(a, b); + i += 1; + } +} + +#[test] +fn test_contains() { + assert!("abcde".contains("bcd")); + assert!("abcde".contains("abcd")); + assert!("abcde".contains("bcde")); + assert!("abcde".contains("")); + assert!("".contains("")); + assert!(!"abcde".contains("def")); + assert!(!"".contains("a")); + + let data = "ประเทศไทย中华Việt Nam"; + assert!(data.contains("ประเ")); + assert!(data.contains("ะเ")); + assert!(data.contains("中华")); + assert!(!data.contains("ไท华")); +} + +#[test] +fn test_contains_char() { + assert!("abc".contains('b')); + assert!("a".contains('a')); + assert!(!"abc".contains('d')); + assert!(!"".contains('a')); +} + +#[test] +fn test_split_at() { + let s = "ศไทย中华Việt Nam"; + for (index, _) in s.char_indices() { + let (a, b) = s.split_at(index); + assert_eq!(&s[..a.len()], a); + assert_eq!(&s[a.len()..], b); + } + let (a, b) = s.split_at(s.len()); + assert_eq!(a, s); + assert_eq!(b, ""); +} + +#[test] +fn test_split_at_mut() { + let mut s = "Hello World".to_string(); + { + let (a, b) = s.split_at_mut(5); + a.make_ascii_uppercase(); + b.make_ascii_lowercase(); + } + assert_eq!(s, "HELLO world"); +} + +#[test] +#[should_panic] +fn test_split_at_boundscheck() { + let s = "ศไทย中华Việt Nam"; + s.split_at(1); +} + +#[test] +fn test_escape_unicode() { + assert_eq!("abc".escape_unicode().to_string(), "\\u{61}\\u{62}\\u{63}"); + assert_eq!("a c".escape_unicode().to_string(), "\\u{61}\\u{20}\\u{63}"); + assert_eq!("\r\n\t".escape_unicode().to_string(), "\\u{d}\\u{a}\\u{9}"); + assert_eq!("'\"\\".escape_unicode().to_string(), "\\u{27}\\u{22}\\u{5c}"); + assert_eq!("\x00\x01\u{fe}\u{ff}".escape_unicode().to_string(), "\\u{0}\\u{1}\\u{fe}\\u{ff}"); + assert_eq!("\u{100}\u{ffff}".escape_unicode().to_string(), "\\u{100}\\u{ffff}"); + assert_eq!("\u{10000}\u{10ffff}".escape_unicode().to_string(), "\\u{10000}\\u{10ffff}"); + assert_eq!("ab\u{fb00}".escape_unicode().to_string(), "\\u{61}\\u{62}\\u{fb00}"); + assert_eq!("\u{1d4ea}\r".escape_unicode().to_string(), "\\u{1d4ea}\\u{d}"); +} + +#[test] +fn test_escape_debug() { + // Note that there are subtleties with the number of backslashes + // on the left- and right-hand sides. In particular, Unicode code points + // are usually escaped with two backslashes on the right-hand side, as + // they are escaped. However, when the character is unescaped (e.g., for + // printable characters), only a single backslash appears (as the character + // itself appears in the debug string). + assert_eq!("abc".escape_debug().to_string(), "abc"); + assert_eq!("a c".escape_debug().to_string(), "a c"); + assert_eq!("éèê".escape_debug().to_string(), "éèê"); + assert_eq!("\r\n\t".escape_debug().to_string(), "\\r\\n\\t"); + assert_eq!("'\"\\".escape_debug().to_string(), "\\'\\\"\\\\"); + assert_eq!("\u{7f}\u{ff}".escape_debug().to_string(), "\\u{7f}\u{ff}"); + assert_eq!("\u{100}\u{ffff}".escape_debug().to_string(), "\u{100}\\u{ffff}"); + assert_eq!("\u{10000}\u{10ffff}".escape_debug().to_string(), "\u{10000}\\u{10ffff}"); + assert_eq!("ab\u{200b}".escape_debug().to_string(), "ab\\u{200b}"); + assert_eq!("\u{10d4ea}\r".escape_debug().to_string(), "\\u{10d4ea}\\r"); + assert_eq!( + "\u{301}a\u{301}bé\u{e000}".escape_debug().to_string(), + "\\u{301}a\u{301}bé\\u{e000}" + ); +} + +#[test] +fn test_escape_default() { + assert_eq!("abc".escape_default().to_string(), "abc"); + assert_eq!("a c".escape_default().to_string(), "a c"); + assert_eq!("éèê".escape_default().to_string(), "\\u{e9}\\u{e8}\\u{ea}"); + assert_eq!("\r\n\t".escape_default().to_string(), "\\r\\n\\t"); + assert_eq!("'\"\\".escape_default().to_string(), "\\'\\\"\\\\"); + assert_eq!("\u{7f}\u{ff}".escape_default().to_string(), "\\u{7f}\\u{ff}"); + assert_eq!("\u{100}\u{ffff}".escape_default().to_string(), "\\u{100}\\u{ffff}"); + assert_eq!("\u{10000}\u{10ffff}".escape_default().to_string(), "\\u{10000}\\u{10ffff}"); + assert_eq!("ab\u{200b}".escape_default().to_string(), "ab\\u{200b}"); + assert_eq!("\u{10d4ea}\r".escape_default().to_string(), "\\u{10d4ea}\\r"); +} + +#[test] +fn test_total_ord() { + assert_eq!("1234".cmp("123"), Greater); + assert_eq!("123".cmp("1234"), Less); + assert_eq!("1234".cmp("1234"), Equal); + assert_eq!("12345555".cmp("123456"), Less); + assert_eq!("22".cmp("1234"), Greater); +} + +#[test] +fn test_iterator() { + let s = "ศไทย中华Việt Nam"; + let v = ['ศ', 'ไ', 'ท', 'ย', '中', '华', 'V', 'i', 'ệ', 't', ' ', 'N', 'a', 'm']; + + let mut pos = 0; + let it = s.chars(); + + for c in it { + assert_eq!(c, v[pos]); + pos += 1; + } + assert_eq!(pos, v.len()); + assert_eq!(s.chars().count(), v.len()); +} + +#[test] +fn test_rev_iterator() { + let s = "ศไทย中华Việt Nam"; + let v = ['m', 'a', 'N', ' ', 't', 'ệ', 'i', 'V', '华', '中', 'ย', 'ท', 'ไ', 'ศ']; + + let mut pos = 0; + let it = s.chars().rev(); + + for c in it { + assert_eq!(c, v[pos]); + pos += 1; + } + assert_eq!(pos, v.len()); +} + +#[test] +#[cfg_attr(miri, ignore)] // Miri is too slow +fn test_chars_decoding() { + let mut bytes = [0; 4]; + for c in (0..0x110000).filter_map(std::char::from_u32) { + let s = c.encode_utf8(&mut bytes); + if Some(c) != s.chars().next() { + panic!("character {:x}={} does not decode correctly", c as u32, c); + } + } +} + +#[test] +#[cfg_attr(miri, ignore)] // Miri is too slow +fn test_chars_rev_decoding() { + let mut bytes = [0; 4]; + for c in (0..0x110000).filter_map(std::char::from_u32) { + let s = c.encode_utf8(&mut bytes); + if Some(c) != s.chars().rev().next() { + panic!("character {:x}={} does not decode correctly", c as u32, c); + } + } +} + +#[test] +fn test_iterator_clone() { + let s = "ศไทย中华Việt Nam"; + let mut it = s.chars(); + it.next(); + assert!(it.clone().zip(it).all(|(x, y)| x == y)); +} + +#[test] +fn test_iterator_last() { + let s = "ศไทย中华Việt Nam"; + let mut it = s.chars(); + it.next(); + assert_eq!(it.last(), Some('m')); +} + +#[test] +fn test_chars_debug() { + let s = "ศไทย中华Việt Nam"; + let c = s.chars(); + assert_eq!( + format!("{:?}", c), + r#"Chars(['ศ', 'ไ', 'ท', 'ย', '中', '华', 'V', 'i', 'ệ', 't', ' ', 'N', 'a', 'm'])"# + ); +} + +#[test] +fn test_bytesator() { + let s = "ศไทย中华Việt Nam"; + let v = [ + 224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228, 184, 173, 229, 141, 142, + 86, 105, 225, 187, 135, 116, 32, 78, 97, 109, + ]; + let mut pos = 0; + + for b in s.bytes() { + assert_eq!(b, v[pos]); + pos += 1; + } +} + +#[test] +fn test_bytes_revator() { + let s = "ศไทย中华Việt Nam"; + let v = [ + 224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228, 184, 173, 229, 141, 142, + 86, 105, 225, 187, 135, 116, 32, 78, 97, 109, + ]; + let mut pos = v.len(); + + for b in s.bytes().rev() { + pos -= 1; + assert_eq!(b, v[pos]); + } +} + +#[test] +fn test_bytesator_nth() { + let s = "ศไทย中华Việt Nam"; + let v = [ + 224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228, 184, 173, 229, 141, 142, + 86, 105, 225, 187, 135, 116, 32, 78, 97, 109, + ]; + + let mut b = s.bytes(); + assert_eq!(b.nth(2).unwrap(), v[2]); + assert_eq!(b.nth(10).unwrap(), v[10]); + assert_eq!(b.nth(200), None); +} + +#[test] +fn test_bytesator_count() { + let s = "ศไทย中华Việt Nam"; + + let b = s.bytes(); + assert_eq!(b.count(), 28) +} + +#[test] +fn test_bytesator_last() { + let s = "ศไทย中华Việt Nam"; + + let b = s.bytes(); + assert_eq!(b.last().unwrap(), 109) +} + +#[test] +fn test_char_indicesator() { + let s = "ศไทย中华Việt Nam"; + let p = [0, 3, 6, 9, 12, 15, 18, 19, 20, 23, 24, 25, 26, 27]; + let v = ['ศ', 'ไ', 'ท', 'ย', '中', '华', 'V', 'i', 'ệ', 't', ' ', 'N', 'a', 'm']; + + let mut pos = 0; + let it = s.char_indices(); + + for c in it { + assert_eq!(c, (p[pos], v[pos])); + pos += 1; + } + assert_eq!(pos, v.len()); + assert_eq!(pos, p.len()); +} + +#[test] +fn test_char_indices_revator() { + let s = "ศไทย中华Việt Nam"; + let p = [27, 26, 25, 24, 23, 20, 19, 18, 15, 12, 9, 6, 3, 0]; + let v = ['m', 'a', 'N', ' ', 't', 'ệ', 'i', 'V', '华', '中', 'ย', 'ท', 'ไ', 'ศ']; + + let mut pos = 0; + let it = s.char_indices().rev(); + + for c in it { + assert_eq!(c, (p[pos], v[pos])); + pos += 1; + } + assert_eq!(pos, v.len()); + assert_eq!(pos, p.len()); +} + +#[test] +fn test_char_indices_last() { + let s = "ศไทย中华Việt Nam"; + let mut it = s.char_indices(); + it.next(); + assert_eq!(it.last(), Some((27, 'm'))); +} + +#[test] +fn test_splitn_char_iterator() { + let data = "\nMäry häd ä little lämb\nLittle lämb\n"; + + let split: Vec<&str> = data.splitn(4, ' ').collect(); + assert_eq!(split, ["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]); + + let split: Vec<&str> = data.splitn(4, |c: char| c == ' ').collect(); + assert_eq!(split, ["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]); + + // Unicode + let split: Vec<&str> = data.splitn(4, 'ä').collect(); + assert_eq!(split, ["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]); + + let split: Vec<&str> = data.splitn(4, |c: char| c == 'ä').collect(); + assert_eq!(split, ["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]); +} + +#[test] +fn test_split_char_iterator_no_trailing() { + let data = "\nMäry häd ä little lämb\nLittle lämb\n"; + + let split: Vec<&str> = data.split('\n').collect(); + assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb", ""]); + + let split: Vec<&str> = data.split_terminator('\n').collect(); + assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb"]); +} + +#[test] +fn test_split_char_iterator_inclusive() { + let data = "\nMäry häd ä little lämb\nLittle lämb\n"; + + let split: Vec<&str> = data.split_inclusive('\n').collect(); + assert_eq!(split, ["\n", "Märy häd ä little lämb\n", "Little lämb\n"]); + + let uppercase_separated = "SheePSharKTurtlECaT"; + let mut first_char = true; + let split: Vec<&str> = uppercase_separated + .split_inclusive(|c: char| { + let split = !first_char && c.is_uppercase(); + first_char = split; + split + }) + .collect(); + assert_eq!(split, ["SheeP", "SharK", "TurtlE", "CaT"]); +} + +#[test] +fn test_split_char_iterator_inclusive_rev() { + let data = "\nMäry häd ä little lämb\nLittle lämb\n"; + + let split: Vec<&str> = data.split_inclusive('\n').rev().collect(); + assert_eq!(split, ["Little lämb\n", "Märy häd ä little lämb\n", "\n"]); + + // Note that the predicate is stateful and thus dependent + // on the iteration order. + // (A different predicate is needed for reverse iterator vs normal iterator.) + // Not sure if anything can be done though. + let uppercase_separated = "SheePSharKTurtlECaT"; + let mut term_char = true; + let split: Vec<&str> = uppercase_separated + .split_inclusive(|c: char| { + let split = term_char && c.is_uppercase(); + term_char = c.is_uppercase(); + split + }) + .rev() + .collect(); + assert_eq!(split, ["CaT", "TurtlE", "SharK", "SheeP"]); +} + +#[test] +fn test_rsplit() { + let data = "\nMäry häd ä little lämb\nLittle lämb\n"; + + let split: Vec<&str> = data.rsplit(' ').collect(); + assert_eq!(split, ["lämb\n", "lämb\nLittle", "little", "ä", "häd", "\nMäry"]); + + let split: Vec<&str> = data.rsplit("lämb").collect(); + assert_eq!(split, ["\n", "\nLittle ", "\nMäry häd ä little "]); + + let split: Vec<&str> = data.rsplit(|c: char| c == 'ä').collect(); + assert_eq!(split, ["mb\n", "mb\nLittle l", " little l", "d ", "ry h", "\nM"]); +} + +#[test] +fn test_rsplitn() { + let data = "\nMäry häd ä little lämb\nLittle lämb\n"; + + let split: Vec<&str> = data.rsplitn(2, ' ').collect(); + assert_eq!(split, ["lämb\n", "\nMäry häd ä little lämb\nLittle"]); + + let split: Vec<&str> = data.rsplitn(2, "lämb").collect(); + assert_eq!(split, ["\n", "\nMäry häd ä little lämb\nLittle "]); + + let split: Vec<&str> = data.rsplitn(2, |c: char| c == 'ä').collect(); + assert_eq!(split, ["mb\n", "\nMäry häd ä little lämb\nLittle l"]); +} + +#[test] +fn test_split_once() { + assert_eq!("".split_once("->"), None); + assert_eq!("-".split_once("->"), None); + assert_eq!("->".split_once("->"), Some(("", ""))); + assert_eq!("a->".split_once("->"), Some(("a", ""))); + assert_eq!("->b".split_once("->"), Some(("", "b"))); + assert_eq!("a->b".split_once("->"), Some(("a", "b"))); + assert_eq!("a->b->c".split_once("->"), Some(("a", "b->c"))); + assert_eq!("---".split_once("--"), Some(("", "-"))); +} + +#[test] +fn test_rsplit_once() { + assert_eq!("".rsplit_once("->"), None); + assert_eq!("-".rsplit_once("->"), None); + assert_eq!("->".rsplit_once("->"), Some(("", ""))); + assert_eq!("a->".rsplit_once("->"), Some(("a", ""))); + assert_eq!("->b".rsplit_once("->"), Some(("", "b"))); + assert_eq!("a->b".rsplit_once("->"), Some(("a", "b"))); + assert_eq!("a->b->c".rsplit_once("->"), Some(("a->b", "c"))); + assert_eq!("---".rsplit_once("--"), Some(("-", ""))); +} + +#[test] +fn test_split_whitespace() { + let data = "\n \tMäry häd\tä little lämb\nLittle lämb\n"; + let words: Vec<&str> = data.split_whitespace().collect(); + assert_eq!(words, ["Märy", "häd", "ä", "little", "lämb", "Little", "lämb"]) +} + +#[test] +fn test_lines() { + let data = "\nMäry häd ä little lämb\n\r\nLittle lämb\n"; + let lines: Vec<&str> = data.lines().collect(); + assert_eq!(lines, ["", "Märy häd ä little lämb", "", "Little lämb"]); + + let data = "\r\nMäry häd ä little lämb\n\nLittle lämb"; // no trailing \n + let lines: Vec<&str> = data.lines().collect(); + assert_eq!(lines, ["", "Märy häd ä little lämb", "", "Little lämb"]); +} + +#[test] +fn test_splitator() { + fn t(s: &str, sep: &str, u: &[&str]) { + let v: Vec<&str> = s.split(sep).collect(); + assert_eq!(v, u); + } + t("--1233345--", "12345", &["--1233345--"]); + t("abc::hello::there", "::", &["abc", "hello", "there"]); + t("::hello::there", "::", &["", "hello", "there"]); + t("hello::there::", "::", &["hello", "there", ""]); + t("::hello::there::", "::", &["", "hello", "there", ""]); + t("ประเทศไทย中华Việt Nam", "中华", &["ประเทศไทย", "Việt Nam"]); + t("zzXXXzzYYYzz", "zz", &["", "XXX", "YYY", ""]); + t("zzXXXzYYYz", "XXX", &["zz", "zYYYz"]); + t(".XXX.YYY.", ".", &["", "XXX", "YYY", ""]); + t("", ".", &[""]); + t("zz", "zz", &["", ""]); + t("ok", "z", &["ok"]); + t("zzz", "zz", &["", "z"]); + t("zzzzz", "zz", &["", "", "z"]); +} + +#[test] +fn test_str_default() { + use std::default::Default; + + fn t>() { + let s: S = Default::default(); + assert_eq!(s.as_ref(), ""); + } + + t::<&str>(); + t::(); + t::<&mut str>(); +} + +#[test] +fn test_str_container() { + fn sum_len(v: &[&str]) -> usize { + v.iter().map(|x| x.len()).sum() + } + + let s = "01234"; + assert_eq!(5, sum_len(&["012", "", "34"])); + assert_eq!(5, sum_len(&["01", "2", "34", ""])); + assert_eq!(5, sum_len(&[s])); +} + +#[test] +fn test_str_from_utf8() { + let xs = b"hello"; + assert_eq!(from_utf8(xs), Ok("hello")); + + let xs = "ศไทย中华Việt Nam".as_bytes(); + assert_eq!(from_utf8(xs), Ok("ศไทย中华Việt Nam")); + + let xs = b"hello\xFF"; + assert!(from_utf8(xs).is_err()); +} + +#[test] +fn test_pattern_deref_forward() { + let data = "aabcdaa"; + assert!(data.contains("bcd")); + assert!(data.contains(&"bcd")); + assert!(data.contains(&"bcd".to_string())); +} + +#[test] +fn test_empty_match_indices() { + let data = "aä中!"; + let vec: Vec<_> = data.match_indices("").collect(); + assert_eq!(vec, [(0, ""), (1, ""), (3, ""), (6, ""), (7, "")]); +} + +#[test] +fn test_bool_from_str() { + assert_eq!("true".parse().ok(), Some(true)); + assert_eq!("false".parse().ok(), Some(false)); + assert_eq!("not even a boolean".parse::().ok(), None); +} + +fn check_contains_all_substrings(s: &str) { + assert!(s.contains("")); + for i in 0..s.len() { + for j in i + 1..=s.len() { + assert!(s.contains(&s[i..j])); + } + } +} + +#[test] +#[cfg_attr(miri, ignore)] // Miri is too slow +fn strslice_issue_16589() { + assert!("bananas".contains("nana")); + + // prior to the fix for #16589, x.contains("abcdabcd") returned false + // test all substrings for good measure + check_contains_all_substrings("012345678901234567890123456789bcdabcdabcd"); +} + +#[test] +fn strslice_issue_16878() { + assert!(!"1234567ah012345678901ah".contains("hah")); + assert!(!"00abc01234567890123456789abc".contains("bcabc")); +} + +#[test] +#[cfg_attr(miri, ignore)] // Miri is too slow +fn test_strslice_contains() { + let x = "There are moments, Jeeves, when one asks oneself, 'Do trousers matter?'"; + check_contains_all_substrings(x); +} + +#[test] +fn test_rsplitn_char_iterator() { + let data = "\nMäry häd ä little lämb\nLittle lämb\n"; + + let mut split: Vec<&str> = data.rsplitn(4, ' ').collect(); + split.reverse(); + assert_eq!(split, ["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]); + + let mut split: Vec<&str> = data.rsplitn(4, |c: char| c == ' ').collect(); + split.reverse(); + assert_eq!(split, ["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]); + + // Unicode + let mut split: Vec<&str> = data.rsplitn(4, 'ä').collect(); + split.reverse(); + assert_eq!(split, ["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]); + + let mut split: Vec<&str> = data.rsplitn(4, |c: char| c == 'ä').collect(); + split.reverse(); + assert_eq!(split, ["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]); +} + +#[test] +fn test_split_char_iterator() { + let data = "\nMäry häd ä little lämb\nLittle lämb\n"; + + let split: Vec<&str> = data.split(' ').collect(); + assert_eq!(split, ["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); + + let mut rsplit: Vec<&str> = data.split(' ').rev().collect(); + rsplit.reverse(); + assert_eq!(rsplit, ["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); + + let split: Vec<&str> = data.split(|c: char| c == ' ').collect(); + assert_eq!(split, ["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); + + let mut rsplit: Vec<&str> = data.split(|c: char| c == ' ').rev().collect(); + rsplit.reverse(); + assert_eq!(rsplit, ["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]); + + // Unicode + let split: Vec<&str> = data.split('ä').collect(); + assert_eq!(split, ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); + + let mut rsplit: Vec<&str> = data.split('ä').rev().collect(); + rsplit.reverse(); + assert_eq!(rsplit, ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); + + let split: Vec<&str> = data.split(|c: char| c == 'ä').collect(); + assert_eq!(split, ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); + + let mut rsplit: Vec<&str> = data.split(|c: char| c == 'ä').rev().collect(); + rsplit.reverse(); + assert_eq!(rsplit, ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]); +} + +#[test] +fn test_rev_split_char_iterator_no_trailing() { + let data = "\nMäry häd ä little lämb\nLittle lämb\n"; + + let mut split: Vec<&str> = data.split('\n').rev().collect(); + split.reverse(); + assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb", ""]); + + let mut split: Vec<&str> = data.split_terminator('\n').rev().collect(); + split.reverse(); + assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb"]); +} + +#[test] +fn test_utf16_code_units() { + assert_eq!("é\u{1F4A9}".encode_utf16().collect::>(), [0xE9, 0xD83D, 0xDCA9]) +} + +#[test] +fn starts_with_in_unicode() { + assert!(!"├── Cargo.toml".starts_with("# ")); +} + +#[test] +fn starts_short_long() { + assert!(!"".starts_with("##")); + assert!(!"##".starts_with("####")); + assert!("####".starts_with("##")); + assert!(!"##ä".starts_with("####")); + assert!("####ä".starts_with("##")); + assert!(!"##".starts_with("####ä")); + assert!("##ä##".starts_with("##ä")); + + assert!("".starts_with("")); + assert!("ä".starts_with("")); + assert!("#ä".starts_with("")); + assert!("##ä".starts_with("")); + assert!("ä###".starts_with("")); + assert!("#ä##".starts_with("")); + assert!("##ä#".starts_with("")); +} + +#[test] +fn contains_weird_cases() { + assert!("* \t".contains(' ')); + assert!(!"* \t".contains('?')); + assert!(!"* \t".contains('\u{1F4A9}')); +} + +#[test] +fn trim_ws() { + assert_eq!(" \t a \t ".trim_start_matches(|c: char| c.is_whitespace()), "a \t "); + assert_eq!(" \t a \t ".trim_end_matches(|c: char| c.is_whitespace()), " \t a"); + assert_eq!(" \t a \t ".trim_start_matches(|c: char| c.is_whitespace()), "a \t "); + assert_eq!(" \t a \t ".trim_end_matches(|c: char| c.is_whitespace()), " \t a"); + assert_eq!(" \t a \t ".trim_matches(|c: char| c.is_whitespace()), "a"); + assert_eq!(" \t \t ".trim_start_matches(|c: char| c.is_whitespace()), ""); + assert_eq!(" \t \t ".trim_end_matches(|c: char| c.is_whitespace()), ""); + assert_eq!(" \t \t ".trim_start_matches(|c: char| c.is_whitespace()), ""); + assert_eq!(" \t \t ".trim_end_matches(|c: char| c.is_whitespace()), ""); + assert_eq!(" \t \t ".trim_matches(|c: char| c.is_whitespace()), ""); +} + +#[test] +fn to_lowercase() { + assert_eq!("".to_lowercase(), ""); + assert_eq!("AÉDžaé ".to_lowercase(), "aédžaé "); + + // https://github.com/rust-lang/rust/issues/26035 + assert_eq!("ΑΣ".to_lowercase(), "ας"); + assert_eq!("Α'Σ".to_lowercase(), "α'ς"); + assert_eq!("Α''Σ".to_lowercase(), "α''ς"); + + assert_eq!("ΑΣ Α".to_lowercase(), "ας α"); + assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α"); + assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α"); + + assert_eq!("ΑΣ' Α".to_lowercase(), "ας' α"); + assert_eq!("ΑΣ'' Α".to_lowercase(), "ας'' α"); + + assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α"); + assert_eq!("Α''Σ'' Α".to_lowercase(), "α''ς'' α"); + + assert_eq!("Α Σ".to_lowercase(), "α σ"); + assert_eq!("Α 'Σ".to_lowercase(), "α 'σ"); + assert_eq!("Α ''Σ".to_lowercase(), "α ''σ"); + + assert_eq!("Σ".to_lowercase(), "σ"); + assert_eq!("'Σ".to_lowercase(), "'σ"); + assert_eq!("''Σ".to_lowercase(), "''σ"); + + assert_eq!("ΑΣΑ".to_lowercase(), "ασα"); + assert_eq!("ΑΣ'Α".to_lowercase(), "ασ'α"); + assert_eq!("ΑΣ''Α".to_lowercase(), "ασ''α"); +} + +#[test] +fn to_uppercase() { + assert_eq!("".to_uppercase(), ""); + assert_eq!("aéDžßfiᾀ".to_uppercase(), "AÉDŽSSFIἈΙ"); +} + +#[test] +fn test_into_string() { + // The only way to acquire a Box in the first place is through a String, so just + // test that we can round-trip between Box and String. + let string = String::from("Some text goes here"); + assert_eq!(string.clone().into_boxed_str().into_string(), string); +} + +#[test] +fn test_box_slice_clone() { + let data = String::from("hello HELLO hello HELLO yes YES 5 中ä华!!!"); + let data2 = data.clone().into_boxed_str().clone().into_string(); + + assert_eq!(data, data2); +} + +#[test] +fn test_cow_from() { + let borrowed = "borrowed"; + let owned = String::from("owned"); + match (Cow::from(owned.clone()), Cow::from(borrowed)) { + (Cow::Owned(o), Cow::Borrowed(b)) => assert!(o == owned && b == borrowed), + _ => panic!("invalid `Cow::from`"), + } +} + +#[test] +fn test_repeat() { + assert_eq!("".repeat(3), ""); + assert_eq!("abc".repeat(0), ""); + assert_eq!("α".repeat(3), "ααα"); +} + +mod pattern { + use std::str::pattern::SearchStep::{self, Done, Match, Reject}; + use std::str::pattern::{Pattern, ReverseSearcher, Searcher}; + + macro_rules! make_test { + ($name:ident, $p:expr, $h:expr, [$($e:expr,)*]) => { + #[allow(unused_imports)] + mod $name { + use std::str::pattern::SearchStep::{Match, Reject}; + use super::{cmp_search_to_vec}; + #[test] + fn fwd() { + cmp_search_to_vec(false, $p, $h, vec![$($e),*]); + } + #[test] + fn bwd() { + cmp_search_to_vec(true, $p, $h, vec![$($e),*]); + } + } + } + } + + fn cmp_search_to_vec<'a>( + rev: bool, + pat: impl Pattern<'a, Searcher: ReverseSearcher<'a>>, + haystack: &'a str, + right: Vec, + ) { + let mut searcher = pat.into_searcher(haystack); + let mut v = vec![]; + loop { + match if !rev { searcher.next() } else { searcher.next_back() } { + Match(a, b) => v.push(Match(a, b)), + Reject(a, b) => v.push(Reject(a, b)), + Done => break, + } + } + if rev { + v.reverse(); + } + + let mut first_index = 0; + let mut err = None; + + for (i, e) in right.iter().enumerate() { + match *e { + Match(a, b) | Reject(a, b) if a <= b && a == first_index => { + first_index = b; + } + _ => { + err = Some(i); + break; + } + } + } + + if let Some(err) = err { + panic!("Input skipped range at {}", err); + } + + if first_index != haystack.len() { + panic!("Did not cover whole input"); + } + + assert_eq!(v, right); + } + + make_test!( + str_searcher_ascii_haystack, + "bb", + "abbcbbd", + [Reject(0, 1), Match(1, 3), Reject(3, 4), Match(4, 6), Reject(6, 7),] + ); + make_test!( + str_searcher_ascii_haystack_seq, + "bb", + "abbcbbbbd", + [Reject(0, 1), Match(1, 3), Reject(3, 4), Match(4, 6), Match(6, 8), Reject(8, 9),] + ); + make_test!( + str_searcher_empty_needle_ascii_haystack, + "", + "abbcbbd", + [ + Match(0, 0), + Reject(0, 1), + Match(1, 1), + Reject(1, 2), + Match(2, 2), + Reject(2, 3), + Match(3, 3), + Reject(3, 4), + Match(4, 4), + Reject(4, 5), + Match(5, 5), + Reject(5, 6), + Match(6, 6), + Reject(6, 7), + Match(7, 7), + ] + ); + make_test!( + str_searcher_multibyte_haystack, + " ", + "├──", + [Reject(0, 3), Reject(3, 6), Reject(6, 9),] + ); + make_test!( + str_searcher_empty_needle_multibyte_haystack, + "", + "├──", + [ + Match(0, 0), + Reject(0, 3), + Match(3, 3), + Reject(3, 6), + Match(6, 6), + Reject(6, 9), + Match(9, 9), + ] + ); + make_test!(str_searcher_empty_needle_empty_haystack, "", "", [Match(0, 0),]); + make_test!(str_searcher_nonempty_needle_empty_haystack, "├", "", []); + make_test!( + char_searcher_ascii_haystack, + 'b', + "abbcbbd", + [ + Reject(0, 1), + Match(1, 2), + Match(2, 3), + Reject(3, 4), + Match(4, 5), + Match(5, 6), + Reject(6, 7), + ] + ); + make_test!( + char_searcher_multibyte_haystack, + ' ', + "├──", + [Reject(0, 3), Reject(3, 6), Reject(6, 9),] + ); + make_test!( + char_searcher_short_haystack, + '\u{1F4A9}', + "* \t", + [Reject(0, 1), Reject(1, 2), Reject(2, 3),] + ); +} + +macro_rules! generate_iterator_test { + { + $name:ident { + $( + ($($arg:expr),*) -> [$($t:tt)*]; + )* + } + with $fwd:expr, $bwd:expr; + } => { + #[test] + fn $name() { + $( + { + let res = vec![$($t)*]; + + let fwd_vec: Vec<_> = ($fwd)($($arg),*).collect(); + assert_eq!(fwd_vec, res); + + let mut bwd_vec: Vec<_> = ($bwd)($($arg),*).collect(); + bwd_vec.reverse(); + assert_eq!(bwd_vec, res); + } + )* + } + }; + { + $name:ident { + $( + ($($arg:expr),*) -> [$($t:tt)*]; + )* + } + with $fwd:expr; + } => { + #[test] + fn $name() { + $( + { + let res = vec![$($t)*]; + + let fwd_vec: Vec<_> = ($fwd)($($arg),*).collect(); + assert_eq!(fwd_vec, res); + } + )* + } + } +} + +generate_iterator_test! { + double_ended_split { + ("foo.bar.baz", '.') -> ["foo", "bar", "baz"]; + ("foo::bar::baz", "::") -> ["foo", "bar", "baz"]; + } + with str::split, str::rsplit; +} + +generate_iterator_test! { + double_ended_split_terminator { + ("foo;bar;baz;", ';') -> ["foo", "bar", "baz"]; + } + with str::split_terminator, str::rsplit_terminator; +} + +generate_iterator_test! { + double_ended_matches { + ("a1b2c3", char::is_numeric) -> ["1", "2", "3"]; + } + with str::matches, str::rmatches; +} + +generate_iterator_test! { + double_ended_match_indices { + ("a1b2c3", char::is_numeric) -> [(1, "1"), (3, "2"), (5, "3")]; + } + with str::match_indices, str::rmatch_indices; +} + +generate_iterator_test! { + not_double_ended_splitn { + ("foo::bar::baz", 2, "::") -> ["foo", "bar::baz"]; + } + with str::splitn; +} + +generate_iterator_test! { + not_double_ended_rsplitn { + ("foo::bar::baz", 2, "::") -> ["baz", "foo::bar"]; + } + with str::rsplitn; +} + +#[test] +fn different_str_pattern_forwarding_lifetimes() { + use std::str::pattern::Pattern; + + fn foo<'a, P>(p: P) + where + for<'b> &'b P: Pattern<'a>, + { + for _ in 0..3 { + "asdf".find(&p); + } + } + + foo::<&str>("x"); +} + +#[test] +fn test_str_multiline() { + let a: String = "this \ +is a test" + .to_string(); + let b: String = "this \ + is \ + another \ + test" + .to_string(); + assert_eq!(a, "this is a test".to_string()); + assert_eq!(b, "this is another test".to_string()); +} + +#[test] +fn test_str_escapes() { + let x = "\\\\\ + "; + assert_eq!(x, r"\\"); // extraneous whitespace stripped +} diff --git a/libgrust/rustc-lib/alloc/tests/string.rs b/libgrust/rustc-lib/alloc/tests/string.rs new file mode 100644 index 000000000000..b28694186b65 --- /dev/null +++ b/libgrust/rustc-lib/alloc/tests/string.rs @@ -0,0 +1,778 @@ +use std::borrow::Cow; +use std::collections::TryReserveError::*; +use std::ops::Bound::*; +use std::panic; + +pub trait IntoCow<'a, B: ?Sized> +where + B: ToOwned, +{ + fn into_cow(self) -> Cow<'a, B>; +} + +impl<'a> IntoCow<'a, str> for String { + fn into_cow(self) -> Cow<'a, str> { + Cow::Owned(self) + } +} + +impl<'a> IntoCow<'a, str> for &'a str { + fn into_cow(self) -> Cow<'a, str> { + Cow::Borrowed(self) + } +} + +#[test] +fn test_from_str() { + let owned: Option = "string".parse().ok(); + assert_eq!(owned.as_ref().map(|s| &**s), Some("string")); +} + +#[test] +fn test_from_cow_str() { + assert_eq!(String::from(Cow::Borrowed("string")), "string"); + assert_eq!(String::from(Cow::Owned(String::from("string"))), "string"); +} + +#[test] +fn test_unsized_to_string() { + let s: &str = "abc"; + let _: String = (*s).to_string(); +} + +#[test] +fn test_from_utf8() { + let xs = b"hello".to_vec(); + assert_eq!(String::from_utf8(xs).unwrap(), String::from("hello")); + + let xs = "ศไทย中华Việt Nam".as_bytes().to_vec(); + assert_eq!(String::from_utf8(xs).unwrap(), String::from("ศไทย中华Việt Nam")); + + let xs = b"hello\xFF".to_vec(); + let err = String::from_utf8(xs).unwrap_err(); + assert_eq!(err.as_bytes(), b"hello\xff"); + let err_clone = err.clone(); + assert_eq!(err, err_clone); + assert_eq!(err.into_bytes(), b"hello\xff".to_vec()); + assert_eq!(err_clone.utf8_error().valid_up_to(), 5); +} + +#[test] +fn test_from_utf8_lossy() { + let xs = b"hello"; + let ys: Cow<'_, str> = "hello".into_cow(); + assert_eq!(String::from_utf8_lossy(xs), ys); + + let xs = "ศไทย中华Việt Nam".as_bytes(); + let ys: Cow<'_, str> = "ศไทย中华Việt Nam".into_cow(); + assert_eq!(String::from_utf8_lossy(xs), ys); + + let xs = b"Hello\xC2 There\xFF Goodbye"; + assert_eq!( + String::from_utf8_lossy(xs), + String::from("Hello\u{FFFD} There\u{FFFD} Goodbye").into_cow() + ); + + let xs = b"Hello\xC0\x80 There\xE6\x83 Goodbye"; + assert_eq!( + String::from_utf8_lossy(xs), + String::from("Hello\u{FFFD}\u{FFFD} There\u{FFFD} Goodbye").into_cow() + ); + + let xs = b"\xF5foo\xF5\x80bar"; + assert_eq!( + String::from_utf8_lossy(xs), + String::from("\u{FFFD}foo\u{FFFD}\u{FFFD}bar").into_cow() + ); + + let xs = b"\xF1foo\xF1\x80bar\xF1\x80\x80baz"; + assert_eq!( + String::from_utf8_lossy(xs), + String::from("\u{FFFD}foo\u{FFFD}bar\u{FFFD}baz").into_cow() + ); + + let xs = b"\xF4foo\xF4\x80bar\xF4\xBFbaz"; + assert_eq!( + String::from_utf8_lossy(xs), + String::from("\u{FFFD}foo\u{FFFD}bar\u{FFFD}\u{FFFD}baz").into_cow() + ); + + let xs = b"\xF0\x80\x80\x80foo\xF0\x90\x80\x80bar"; + assert_eq!( + String::from_utf8_lossy(xs), + String::from("\u{FFFD}\u{FFFD}\u{FFFD}\u{FFFD}foo\u{10000}bar").into_cow() + ); + + // surrogates + let xs = b"\xED\xA0\x80foo\xED\xBF\xBFbar"; + assert_eq!( + String::from_utf8_lossy(xs), + String::from("\u{FFFD}\u{FFFD}\u{FFFD}foo\u{FFFD}\u{FFFD}\u{FFFD}bar").into_cow() + ); +} + +#[test] +fn test_from_utf16() { + let pairs = [ + ( + String::from("𐍅𐌿𐌻𐍆𐌹𐌻𐌰\n"), + vec![ + 0xd800, 0xdf45, 0xd800, 0xdf3f, 0xd800, 0xdf3b, 0xd800, 0xdf46, 0xd800, 0xdf39, + 0xd800, 0xdf3b, 0xd800, 0xdf30, 0x000a, + ], + ), + ( + String::from("𐐒𐑉𐐮𐑀𐐲𐑋 𐐏𐐲𐑍\n"), + vec![ + 0xd801, 0xdc12, 0xd801, 0xdc49, 0xd801, 0xdc2e, 0xd801, 0xdc40, 0xd801, 0xdc32, + 0xd801, 0xdc4b, 0x0020, 0xd801, 0xdc0f, 0xd801, 0xdc32, 0xd801, 0xdc4d, 0x000a, + ], + ), + ( + String::from("𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n"), + vec![ + 0xd800, 0xdf00, 0xd800, 0xdf16, 0xd800, 0xdf0b, 0xd800, 0xdf04, 0xd800, 0xdf11, + 0xd800, 0xdf09, 0x00b7, 0xd800, 0xdf0c, 0xd800, 0xdf04, 0xd800, 0xdf15, 0xd800, + 0xdf04, 0xd800, 0xdf0b, 0xd800, 0xdf09, 0xd800, 0xdf11, 0x000a, + ], + ), + ( + String::from("𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n"), + vec![ + 0xd801, 0xdc8b, 0xd801, 0xdc98, 0xd801, 0xdc88, 0xd801, 0xdc91, 0xd801, 0xdc9b, + 0xd801, 0xdc92, 0x0020, 0xd801, 0xdc95, 0xd801, 0xdc93, 0x0020, 0xd801, 0xdc88, + 0xd801, 0xdc9a, 0xd801, 0xdc8d, 0x0020, 0xd801, 0xdc8f, 0xd801, 0xdc9c, 0xd801, + 0xdc92, 0xd801, 0xdc96, 0xd801, 0xdc86, 0x0020, 0xd801, 0xdc95, 0xd801, 0xdc86, + 0x000a, + ], + ), + // Issue #12318, even-numbered non-BMP planes + (String::from("\u{20000}"), vec![0xD840, 0xDC00]), + ]; + + for p in &pairs { + let (s, u) = (*p).clone(); + let s_as_utf16 = s.encode_utf16().collect::>(); + let u_as_string = String::from_utf16(&u).unwrap(); + + assert!(core::char::decode_utf16(u.iter().cloned()).all(|r| r.is_ok())); + assert_eq!(s_as_utf16, u); + + assert_eq!(u_as_string, s); + assert_eq!(String::from_utf16_lossy(&u), s); + + assert_eq!(String::from_utf16(&s_as_utf16).unwrap(), s); + assert_eq!(u_as_string.encode_utf16().collect::>(), u); + } +} + +#[test] +fn test_utf16_invalid() { + // completely positive cases tested above. + // lead + eof + assert!(String::from_utf16(&[0xD800]).is_err()); + // lead + lead + assert!(String::from_utf16(&[0xD800, 0xD800]).is_err()); + + // isolated trail + assert!(String::from_utf16(&[0x0061, 0xDC00]).is_err()); + + // general + assert!(String::from_utf16(&[0xD800, 0xd801, 0xdc8b, 0xD800]).is_err()); +} + +#[test] +fn test_from_utf16_lossy() { + // completely positive cases tested above. + // lead + eof + assert_eq!(String::from_utf16_lossy(&[0xD800]), String::from("\u{FFFD}")); + // lead + lead + assert_eq!(String::from_utf16_lossy(&[0xD800, 0xD800]), String::from("\u{FFFD}\u{FFFD}")); + + // isolated trail + assert_eq!(String::from_utf16_lossy(&[0x0061, 0xDC00]), String::from("a\u{FFFD}")); + + // general + assert_eq!( + String::from_utf16_lossy(&[0xD800, 0xd801, 0xdc8b, 0xD800]), + String::from("\u{FFFD}𐒋\u{FFFD}") + ); +} + +#[test] +fn test_push_bytes() { + let mut s = String::from("ABC"); + unsafe { + let mv = s.as_mut_vec(); + mv.extend_from_slice(&[b'D']); + } + assert_eq!(s, "ABCD"); +} + +#[test] +fn test_push_str() { + let mut s = String::new(); + s.push_str(""); + assert_eq!(&s[0..], ""); + s.push_str("abc"); + assert_eq!(&s[0..], "abc"); + s.push_str("ประเทศไทย中华Việt Nam"); + assert_eq!(&s[0..], "abcประเทศไทย中华Việt Nam"); +} + +#[test] +fn test_add_assign() { + let mut s = String::new(); + s += ""; + assert_eq!(s.as_str(), ""); + s += "abc"; + assert_eq!(s.as_str(), "abc"); + s += "ประเทศไทย中华Việt Nam"; + assert_eq!(s.as_str(), "abcประเทศไทย中华Việt Nam"); +} + +#[test] +fn test_push() { + let mut data = String::from("ประเทศไทย中"); + data.push('华'); + data.push('b'); // 1 byte + data.push('¢'); // 2 byte + data.push('€'); // 3 byte + data.push('𤭢'); // 4 byte + assert_eq!(data, "ประเทศไทย中华b¢€𤭢"); +} + +#[test] +fn test_pop() { + let mut data = String::from("ประเทศไทย中华b¢€𤭢"); + assert_eq!(data.pop().unwrap(), '𤭢'); // 4 bytes + assert_eq!(data.pop().unwrap(), '€'); // 3 bytes + assert_eq!(data.pop().unwrap(), '¢'); // 2 bytes + assert_eq!(data.pop().unwrap(), 'b'); // 1 bytes + assert_eq!(data.pop().unwrap(), '华'); + assert_eq!(data, "ประเทศไทย中"); +} + +#[test] +fn test_split_off_empty() { + let orig = "Hello, world!"; + let mut split = String::from(orig); + let empty: String = split.split_off(orig.len()); + assert!(empty.is_empty()); +} + +#[test] +#[should_panic] +fn test_split_off_past_end() { + let orig = "Hello, world!"; + let mut split = String::from(orig); + let _ = split.split_off(orig.len() + 1); +} + +#[test] +#[should_panic] +fn test_split_off_mid_char() { + let mut shan = String::from("山"); + let _broken_mountain = shan.split_off(1); +} + +#[test] +fn test_split_off_ascii() { + let mut ab = String::from("ABCD"); + let orig_capacity = ab.capacity(); + let cd = ab.split_off(2); + assert_eq!(ab, "AB"); + assert_eq!(cd, "CD"); + assert_eq!(ab.capacity(), orig_capacity); +} + +#[test] +fn test_split_off_unicode() { + let mut nihon = String::from("日本語"); + let orig_capacity = nihon.capacity(); + let go = nihon.split_off("日本".len()); + assert_eq!(nihon, "日本"); + assert_eq!(go, "語"); + assert_eq!(nihon.capacity(), orig_capacity); +} + +#[test] +fn test_str_truncate() { + let mut s = String::from("12345"); + s.truncate(5); + assert_eq!(s, "12345"); + s.truncate(3); + assert_eq!(s, "123"); + s.truncate(0); + assert_eq!(s, ""); + + let mut s = String::from("12345"); + let p = s.as_ptr(); + s.truncate(3); + s.push_str("6"); + let p_ = s.as_ptr(); + assert_eq!(p_, p); +} + +#[test] +fn test_str_truncate_invalid_len() { + let mut s = String::from("12345"); + s.truncate(6); + assert_eq!(s, "12345"); +} + +#[test] +#[should_panic] +fn test_str_truncate_split_codepoint() { + let mut s = String::from("\u{FC}"); // ü + s.truncate(1); +} + +#[test] +fn test_str_clear() { + let mut s = String::from("12345"); + s.clear(); + assert_eq!(s.len(), 0); + assert_eq!(s, ""); +} + +#[test] +fn test_str_add() { + let a = String::from("12345"); + let b = a + "2"; + let b = b + "2"; + assert_eq!(b.len(), 7); + assert_eq!(b, "1234522"); +} + +#[test] +fn remove() { + let mut s = "ศไทย中华Việt Nam; foobar".to_string(); + assert_eq!(s.remove(0), 'ศ'); + assert_eq!(s.len(), 33); + assert_eq!(s, "ไทย中华Việt Nam; foobar"); + assert_eq!(s.remove(17), 'ệ'); + assert_eq!(s, "ไทย中华Vit Nam; foobar"); +} + +#[test] +#[should_panic] +fn remove_bad() { + "ศ".to_string().remove(1); +} + +#[test] +fn test_retain() { + let mut s = String::from("α_β_γ"); + + s.retain(|_| true); + assert_eq!(s, "α_β_γ"); + + s.retain(|c| c != '_'); + assert_eq!(s, "αβγ"); + + s.retain(|c| c != 'β'); + assert_eq!(s, "αγ"); + + s.retain(|c| c == 'α'); + assert_eq!(s, "α"); + + s.retain(|_| false); + assert_eq!(s, ""); + + let mut s = String::from("0è0"); + let _ = panic::catch_unwind(panic::AssertUnwindSafe(|| { + let mut count = 0; + s.retain(|_| { + count += 1; + match count { + 1 => false, + 2 => true, + _ => panic!(), + } + }); + })); + assert!(std::str::from_utf8(s.as_bytes()).is_ok()); +} + +#[test] +fn insert() { + let mut s = "foobar".to_string(); + s.insert(0, 'ệ'); + assert_eq!(s, "ệfoobar"); + s.insert(6, 'ย'); + assert_eq!(s, "ệfooยbar"); +} + +#[test] +#[should_panic] +fn insert_bad1() { + "".to_string().insert(1, 't'); +} +#[test] +#[should_panic] +fn insert_bad2() { + "ệ".to_string().insert(1, 't'); +} + +#[test] +fn test_slicing() { + let s = "foobar".to_string(); + assert_eq!("foobar", &s[..]); + assert_eq!("foo", &s[..3]); + assert_eq!("bar", &s[3..]); + assert_eq!("oob", &s[1..4]); +} + +#[test] +fn test_simple_types() { + assert_eq!(1.to_string(), "1"); + assert_eq!((-1).to_string(), "-1"); + assert_eq!(200.to_string(), "200"); + assert_eq!(2.to_string(), "2"); + assert_eq!(true.to_string(), "true"); + assert_eq!(false.to_string(), "false"); + assert_eq!(("hi".to_string()).to_string(), "hi"); +} + +#[test] +fn test_vectors() { + let x: Vec = vec![]; + assert_eq!(format!("{:?}", x), "[]"); + assert_eq!(format!("{:?}", vec![1]), "[1]"); + assert_eq!(format!("{:?}", vec![1, 2, 3]), "[1, 2, 3]"); + assert!(format!("{:?}", vec![vec![], vec![1], vec![1, 1]]) == "[[], [1], [1, 1]]"); +} + +#[test] +fn test_from_iterator() { + let s = "ศไทย中华Việt Nam".to_string(); + let t = "ศไทย中华"; + let u = "Việt Nam"; + + let a: String = s.chars().collect(); + assert_eq!(s, a); + + let mut b = t.to_string(); + b.extend(u.chars()); + assert_eq!(s, b); + + let c: String = vec![t, u].into_iter().collect(); + assert_eq!(s, c); + + let mut d = t.to_string(); + d.extend(vec![u]); + assert_eq!(s, d); +} + +#[test] +fn test_drain() { + let mut s = String::from("αβγ"); + assert_eq!(s.drain(2..4).collect::(), "β"); + assert_eq!(s, "αγ"); + + let mut t = String::from("abcd"); + t.drain(..0); + assert_eq!(t, "abcd"); + t.drain(..1); + assert_eq!(t, "bcd"); + t.drain(3..); + assert_eq!(t, "bcd"); + t.drain(..); + assert_eq!(t, ""); +} + +#[test] +#[should_panic] +fn test_drain_start_overflow() { + let mut s = String::from("abc"); + s.drain((Excluded(usize::MAX), Included(0))); +} + +#[test] +#[should_panic] +fn test_drain_end_overflow() { + let mut s = String::from("abc"); + s.drain((Included(0), Included(usize::MAX))); +} + +#[test] +fn test_replace_range() { + let mut s = "Hello, world!".to_owned(); + s.replace_range(7..12, "世界"); + assert_eq!(s, "Hello, 世界!"); +} + +#[test] +#[should_panic] +fn test_replace_range_char_boundary() { + let mut s = "Hello, 世界!".to_owned(); + s.replace_range(..8, ""); +} + +#[test] +fn test_replace_range_inclusive_range() { + let mut v = String::from("12345"); + v.replace_range(2..=3, "789"); + assert_eq!(v, "127895"); + v.replace_range(1..=2, "A"); + assert_eq!(v, "1A895"); +} + +#[test] +#[should_panic] +fn test_replace_range_out_of_bounds() { + let mut s = String::from("12345"); + s.replace_range(5..6, "789"); +} + +#[test] +#[should_panic] +fn test_replace_range_inclusive_out_of_bounds() { + let mut s = String::from("12345"); + s.replace_range(5..=5, "789"); +} + +#[test] +#[should_panic] +fn test_replace_range_start_overflow() { + let mut s = String::from("123"); + s.replace_range((Excluded(usize::MAX), Included(0)), ""); +} + +#[test] +#[should_panic] +fn test_replace_range_end_overflow() { + let mut s = String::from("456"); + s.replace_range((Included(0), Included(usize::MAX)), ""); +} + +#[test] +fn test_replace_range_empty() { + let mut s = String::from("12345"); + s.replace_range(1..2, ""); + assert_eq!(s, "1345"); +} + +#[test] +fn test_replace_range_unbounded() { + let mut s = String::from("12345"); + s.replace_range(.., ""); + assert_eq!(s, ""); +} + +#[test] +fn test_extend_ref() { + let mut a = "foo".to_string(); + a.extend(&['b', 'a', 'r']); + + assert_eq!(&a, "foobar"); +} + +#[test] +fn test_into_boxed_str() { + let xs = String::from("hello my name is bob"); + let ys = xs.into_boxed_str(); + assert_eq!(&*ys, "hello my name is bob"); +} + +#[test] +fn test_reserve_exact() { + // This is all the same as test_reserve + + let mut s = String::new(); + assert_eq!(s.capacity(), 0); + + s.reserve_exact(2); + assert!(s.capacity() >= 2); + + for _i in 0..16 { + s.push('0'); + } + + assert!(s.capacity() >= 16); + s.reserve_exact(16); + assert!(s.capacity() >= 32); + + s.push('0'); + + s.reserve_exact(16); + assert!(s.capacity() >= 33) +} + +#[test] +#[cfg_attr(miri, ignore)] // Miri does not support signalling OOM +#[cfg_attr(target_os = "android", ignore)] // Android used in CI has a broken dlmalloc +fn test_try_reserve() { + // These are the interesting cases: + // * exactly isize::MAX should never trigger a CapacityOverflow (can be OOM) + // * > isize::MAX should always fail + // * On 16/32-bit should CapacityOverflow + // * On 64-bit should OOM + // * overflow may trigger when adding `len` to `cap` (in number of elements) + // * overflow may trigger when multiplying `new_cap` by size_of:: (to get bytes) + + const MAX_CAP: usize = isize::MAX as usize; + const MAX_USIZE: usize = usize::MAX; + + // On 16/32-bit, we check that allocations don't exceed isize::MAX, + // on 64-bit, we assume the OS will give an OOM for such a ridiculous size. + // Any platform that succeeds for these requests is technically broken with + // ptr::offset because LLVM is the worst. + let guards_against_isize = usize::BITS < 64; + + { + // Note: basic stuff is checked by test_reserve + let mut empty_string: String = String::new(); + + // Check isize::MAX doesn't count as an overflow + if let Err(CapacityOverflow) = empty_string.try_reserve(MAX_CAP) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + // Play it again, frank! (just to be sure) + if let Err(CapacityOverflow) = empty_string.try_reserve(MAX_CAP) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + + if guards_against_isize { + // Check isize::MAX + 1 does count as overflow + if let Err(CapacityOverflow) = empty_string.try_reserve(MAX_CAP + 1) { + } else { + panic!("isize::MAX + 1 should trigger an overflow!") + } + + // Check usize::MAX does count as overflow + if let Err(CapacityOverflow) = empty_string.try_reserve(MAX_USIZE) { + } else { + panic!("usize::MAX should trigger an overflow!") + } + } else { + // Check isize::MAX + 1 is an OOM + if let Err(AllocError { .. }) = empty_string.try_reserve(MAX_CAP + 1) { + } else { + panic!("isize::MAX + 1 should trigger an OOM!") + } + + // Check usize::MAX is an OOM + if let Err(AllocError { .. }) = empty_string.try_reserve(MAX_USIZE) { + } else { + panic!("usize::MAX should trigger an OOM!") + } + } + } + + { + // Same basic idea, but with non-zero len + let mut ten_bytes: String = String::from("0123456789"); + + if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_CAP - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_CAP - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if guards_against_isize { + if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_CAP - 9) { + } else { + panic!("isize::MAX + 1 should trigger an overflow!"); + } + } else { + if let Err(AllocError { .. }) = ten_bytes.try_reserve(MAX_CAP - 9) { + } else { + panic!("isize::MAX + 1 should trigger an OOM!") + } + } + // Should always overflow in the add-to-len + if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_USIZE) { + } else { + panic!("usize::MAX should trigger an overflow!") + } + } +} + +#[test] +#[cfg_attr(miri, ignore)] // Miri does not support signalling OOM +#[cfg_attr(target_os = "android", ignore)] // Android used in CI has a broken dlmalloc +fn test_try_reserve_exact() { + // This is exactly the same as test_try_reserve with the method changed. + // See that test for comments. + + const MAX_CAP: usize = isize::MAX as usize; + const MAX_USIZE: usize = usize::MAX; + + let guards_against_isize = usize::BITS < 64; + + { + let mut empty_string: String = String::new(); + + if let Err(CapacityOverflow) = empty_string.try_reserve_exact(MAX_CAP) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if let Err(CapacityOverflow) = empty_string.try_reserve_exact(MAX_CAP) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + + if guards_against_isize { + if let Err(CapacityOverflow) = empty_string.try_reserve_exact(MAX_CAP + 1) { + } else { + panic!("isize::MAX + 1 should trigger an overflow!") + } + + if let Err(CapacityOverflow) = empty_string.try_reserve_exact(MAX_USIZE) { + } else { + panic!("usize::MAX should trigger an overflow!") + } + } else { + if let Err(AllocError { .. }) = empty_string.try_reserve_exact(MAX_CAP + 1) { + } else { + panic!("isize::MAX + 1 should trigger an OOM!") + } + + if let Err(AllocError { .. }) = empty_string.try_reserve_exact(MAX_USIZE) { + } else { + panic!("usize::MAX should trigger an OOM!") + } + } + } + + { + let mut ten_bytes: String = String::from("0123456789"); + + if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_CAP - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_CAP - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if guards_against_isize { + if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_CAP - 9) { + } else { + panic!("isize::MAX + 1 should trigger an overflow!"); + } + } else { + if let Err(AllocError { .. }) = ten_bytes.try_reserve_exact(MAX_CAP - 9) { + } else { + panic!("isize::MAX + 1 should trigger an OOM!") + } + } + if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_USIZE) { + } else { + panic!("usize::MAX should trigger an overflow!") + } + } +} + +#[test] +fn test_from_char() { + assert_eq!(String::from('a'), 'a'.to_string()); + let s: String = 'x'.into(); + assert_eq!(s, 'x'.to_string()); +} + +#[test] +fn test_str_concat() { + let a: String = "hello".to_string(); + let b: String = "world".to_string(); + let s: String = format!("{}{}", a, b); + assert_eq!(s.as_bytes()[9], 'd' as u8); +} diff --git a/libgrust/rustc-lib/alloc/tests/vec.rs b/libgrust/rustc-lib/alloc/tests/vec.rs new file mode 100644 index 000000000000..47ebe56f9fd3 --- /dev/null +++ b/libgrust/rustc-lib/alloc/tests/vec.rs @@ -0,0 +1,1956 @@ +use std::borrow::Cow; +use std::cell::Cell; +use std::collections::TryReserveError::*; +use std::fmt::Debug; +use std::iter::InPlaceIterable; +use std::mem::{size_of, swap}; +use std::ops::Bound::*; +use std::panic::{catch_unwind, AssertUnwindSafe}; +use std::rc::Rc; +use std::vec::{Drain, IntoIter}; + +struct DropCounter<'a> { + count: &'a mut u32, +} + +impl Drop for DropCounter<'_> { + fn drop(&mut self) { + *self.count += 1; + } +} + +#[test] +fn test_small_vec_struct() { + assert_eq!(size_of::>(), size_of::() * 3); +} + +#[test] +fn test_double_drop() { + struct TwoVec { + x: Vec, + y: Vec, + } + + let (mut count_x, mut count_y) = (0, 0); + { + let mut tv = TwoVec { x: Vec::new(), y: Vec::new() }; + tv.x.push(DropCounter { count: &mut count_x }); + tv.y.push(DropCounter { count: &mut count_y }); + + // If Vec had a drop flag, here is where it would be zeroed. + // Instead, it should rely on its internal state to prevent + // doing anything significant when dropped multiple times. + drop(tv.x); + + // Here tv goes out of scope, tv.y should be dropped, but not tv.x. + } + + assert_eq!(count_x, 1); + assert_eq!(count_y, 1); +} + +#[test] +fn test_reserve() { + let mut v = Vec::new(); + assert_eq!(v.capacity(), 0); + + v.reserve(2); + assert!(v.capacity() >= 2); + + for i in 0..16 { + v.push(i); + } + + assert!(v.capacity() >= 16); + v.reserve(16); + assert!(v.capacity() >= 32); + + v.push(16); + + v.reserve(16); + assert!(v.capacity() >= 33) +} + +#[test] +fn test_zst_capacity() { + assert_eq!(Vec::<()>::new().capacity(), usize::MAX); +} + +#[test] +fn test_indexing() { + let v: Vec = vec![10, 20]; + assert_eq!(v[0], 10); + assert_eq!(v[1], 20); + let mut x: usize = 0; + assert_eq!(v[x], 10); + assert_eq!(v[x + 1], 20); + x = x + 1; + assert_eq!(v[x], 20); + assert_eq!(v[x - 1], 10); +} + +#[test] +fn test_debug_fmt() { + let vec1: Vec = vec![]; + assert_eq!("[]", format!("{:?}", vec1)); + + let vec2 = vec![0, 1]; + assert_eq!("[0, 1]", format!("{:?}", vec2)); + + let slice: &[isize] = &[4, 5]; + assert_eq!("[4, 5]", format!("{:?}", slice)); +} + +#[test] +fn test_push() { + let mut v = vec![]; + v.push(1); + assert_eq!(v, [1]); + v.push(2); + assert_eq!(v, [1, 2]); + v.push(3); + assert_eq!(v, [1, 2, 3]); +} + +#[test] +fn test_extend() { + let mut v = Vec::new(); + let mut w = Vec::new(); + + v.extend(w.clone()); + assert_eq!(v, &[]); + + v.extend(0..3); + for i in 0..3 { + w.push(i) + } + + assert_eq!(v, w); + + v.extend(3..10); + for i in 3..10 { + w.push(i) + } + + assert_eq!(v, w); + + v.extend(w.clone()); // specializes to `append` + assert!(v.iter().eq(w.iter().chain(w.iter()))); + + // Zero sized types + #[derive(PartialEq, Debug)] + struct Foo; + + let mut a = Vec::new(); + let b = vec![Foo, Foo]; + + a.extend(b); + assert_eq!(a, &[Foo, Foo]); + + // Double drop + let mut count_x = 0; + { + let mut x = Vec::new(); + let y = vec![DropCounter { count: &mut count_x }]; + x.extend(y); + } + assert_eq!(count_x, 1); +} + +#[test] +fn test_extend_from_slice() { + let a: Vec = vec![1, 2, 3, 4, 5]; + let b: Vec = vec![6, 7, 8, 9, 0]; + + let mut v: Vec = a; + + v.extend_from_slice(&b); + + assert_eq!(v, [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]); +} + +#[test] +fn test_extend_ref() { + let mut v = vec![1, 2]; + v.extend(&[3, 4, 5]); + + assert_eq!(v.len(), 5); + assert_eq!(v, [1, 2, 3, 4, 5]); + + let w = vec![6, 7]; + v.extend(&w); + + assert_eq!(v.len(), 7); + assert_eq!(v, [1, 2, 3, 4, 5, 6, 7]); +} + +#[test] +fn test_slice_from_ref() { + let values = vec![1, 2, 3, 4, 5]; + let slice = &values[1..3]; + + assert_eq!(slice, [2, 3]); +} + +#[test] +fn test_slice_from_mut() { + let mut values = vec![1, 2, 3, 4, 5]; + { + let slice = &mut values[2..]; + assert!(slice == [3, 4, 5]); + for p in slice { + *p += 2; + } + } + + assert!(values == [1, 2, 5, 6, 7]); +} + +#[test] +fn test_slice_to_mut() { + let mut values = vec![1, 2, 3, 4, 5]; + { + let slice = &mut values[..2]; + assert!(slice == [1, 2]); + for p in slice { + *p += 1; + } + } + + assert!(values == [2, 3, 3, 4, 5]); +} + +#[test] +fn test_split_at_mut() { + let mut values = vec![1, 2, 3, 4, 5]; + { + let (left, right) = values.split_at_mut(2); + { + let left: &[_] = left; + assert!(&left[..left.len()] == &[1, 2]); + } + for p in left { + *p += 1; + } + + { + let right: &[_] = right; + assert!(&right[..right.len()] == &[3, 4, 5]); + } + for p in right { + *p += 2; + } + } + + assert_eq!(values, [2, 3, 5, 6, 7]); +} + +#[test] +fn test_clone() { + let v: Vec = vec![]; + let w = vec![1, 2, 3]; + + assert_eq!(v, v.clone()); + + let z = w.clone(); + assert_eq!(w, z); + // they should be disjoint in memory. + assert!(w.as_ptr() != z.as_ptr()) +} + +#[test] +fn test_clone_from() { + let mut v = vec![]; + let three: Vec> = vec![box 1, box 2, box 3]; + let two: Vec> = vec![box 4, box 5]; + // zero, long + v.clone_from(&three); + assert_eq!(v, three); + + // equal + v.clone_from(&three); + assert_eq!(v, three); + + // long, short + v.clone_from(&two); + assert_eq!(v, two); + + // short, long + v.clone_from(&three); + assert_eq!(v, three) +} + +#[test] +fn test_retain() { + let mut vec = vec![1, 2, 3, 4]; + vec.retain(|&x| x % 2 == 0); + assert_eq!(vec, [2, 4]); +} + +#[test] +fn test_dedup() { + fn case(a: Vec, b: Vec) { + let mut v = a; + v.dedup(); + assert_eq!(v, b); + } + case(vec![], vec![]); + case(vec![1], vec![1]); + case(vec![1, 1], vec![1]); + case(vec![1, 2, 3], vec![1, 2, 3]); + case(vec![1, 1, 2, 3], vec![1, 2, 3]); + case(vec![1, 2, 2, 3], vec![1, 2, 3]); + case(vec![1, 2, 3, 3], vec![1, 2, 3]); + case(vec![1, 1, 2, 2, 2, 3, 3], vec![1, 2, 3]); +} + +#[test] +fn test_dedup_by_key() { + fn case(a: Vec, b: Vec) { + let mut v = a; + v.dedup_by_key(|i| *i / 10); + assert_eq!(v, b); + } + case(vec![], vec![]); + case(vec![10], vec![10]); + case(vec![10, 11], vec![10]); + case(vec![10, 20, 30], vec![10, 20, 30]); + case(vec![10, 11, 20, 30], vec![10, 20, 30]); + case(vec![10, 20, 21, 30], vec![10, 20, 30]); + case(vec![10, 20, 30, 31], vec![10, 20, 30]); + case(vec![10, 11, 20, 21, 22, 30, 31], vec![10, 20, 30]); +} + +#[test] +fn test_dedup_by() { + let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"]; + vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b)); + + assert_eq!(vec, ["foo", "bar", "baz", "bar"]); + + let mut vec = vec![("foo", 1), ("foo", 2), ("bar", 3), ("bar", 4), ("bar", 5)]; + vec.dedup_by(|a, b| { + a.0 == b.0 && { + b.1 += a.1; + true + } + }); + + assert_eq!(vec, [("foo", 3), ("bar", 12)]); +} + +#[test] +fn test_dedup_unique() { + let mut v0: Vec> = vec![box 1, box 1, box 2, box 3]; + v0.dedup(); + let mut v1: Vec> = vec![box 1, box 2, box 2, box 3]; + v1.dedup(); + let mut v2: Vec> = vec![box 1, box 2, box 3, box 3]; + v2.dedup(); + // If the boxed pointers were leaked or otherwise misused, valgrind + // and/or rt should raise errors. +} + +#[test] +fn zero_sized_values() { + let mut v = Vec::new(); + assert_eq!(v.len(), 0); + v.push(()); + assert_eq!(v.len(), 1); + v.push(()); + assert_eq!(v.len(), 2); + assert_eq!(v.pop(), Some(())); + assert_eq!(v.pop(), Some(())); + assert_eq!(v.pop(), None); + + assert_eq!(v.iter().count(), 0); + v.push(()); + assert_eq!(v.iter().count(), 1); + v.push(()); + assert_eq!(v.iter().count(), 2); + + for &() in &v {} + + assert_eq!(v.iter_mut().count(), 2); + v.push(()); + assert_eq!(v.iter_mut().count(), 3); + v.push(()); + assert_eq!(v.iter_mut().count(), 4); + + for &mut () in &mut v {} + unsafe { + v.set_len(0); + } + assert_eq!(v.iter_mut().count(), 0); +} + +#[test] +fn test_partition() { + assert_eq!(vec![].into_iter().partition(|x: &i32| *x < 3), (vec![], vec![])); + assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 4), (vec![1, 2, 3], vec![])); + assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 2), (vec![1], vec![2, 3])); + assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 0), (vec![], vec![1, 2, 3])); +} + +#[test] +fn test_zip_unzip() { + let z1 = vec![(1, 4), (2, 5), (3, 6)]; + + let (left, right): (Vec<_>, Vec<_>) = z1.iter().cloned().unzip(); + + assert_eq!((1, 4), (left[0], right[0])); + assert_eq!((2, 5), (left[1], right[1])); + assert_eq!((3, 6), (left[2], right[2])); +} + +#[test] +fn test_cmp() { + let x: &[isize] = &[1, 2, 3, 4, 5]; + let cmp: &[isize] = &[1, 2, 3, 4, 5]; + assert_eq!(&x[..], cmp); + let cmp: &[isize] = &[3, 4, 5]; + assert_eq!(&x[2..], cmp); + let cmp: &[isize] = &[1, 2, 3]; + assert_eq!(&x[..3], cmp); + let cmp: &[isize] = &[2, 3, 4]; + assert_eq!(&x[1..4], cmp); + + let x: Vec = vec![1, 2, 3, 4, 5]; + let cmp: &[isize] = &[1, 2, 3, 4, 5]; + assert_eq!(&x[..], cmp); + let cmp: &[isize] = &[3, 4, 5]; + assert_eq!(&x[2..], cmp); + let cmp: &[isize] = &[1, 2, 3]; + assert_eq!(&x[..3], cmp); + let cmp: &[isize] = &[2, 3, 4]; + assert_eq!(&x[1..4], cmp); +} + +#[test] +fn test_vec_truncate_drop() { + static mut DROPS: u32 = 0; + struct Elem(i32); + impl Drop for Elem { + fn drop(&mut self) { + unsafe { + DROPS += 1; + } + } + } + + let mut v = vec![Elem(1), Elem(2), Elem(3), Elem(4), Elem(5)]; + assert_eq!(unsafe { DROPS }, 0); + v.truncate(3); + assert_eq!(unsafe { DROPS }, 2); + v.truncate(0); + assert_eq!(unsafe { DROPS }, 5); +} + +#[test] +#[should_panic] +fn test_vec_truncate_fail() { + struct BadElem(i32); + impl Drop for BadElem { + fn drop(&mut self) { + let BadElem(ref mut x) = *self; + if *x == 0xbadbeef { + panic!("BadElem panic: 0xbadbeef") + } + } + } + + let mut v = vec![BadElem(1), BadElem(2), BadElem(0xbadbeef), BadElem(4)]; + v.truncate(0); +} + +#[test] +fn test_index() { + let vec = vec![1, 2, 3]; + assert!(vec[1] == 2); +} + +#[test] +#[should_panic] +fn test_index_out_of_bounds() { + let vec = vec![1, 2, 3]; + let _ = vec[3]; +} + +#[test] +#[should_panic] +fn test_slice_out_of_bounds_1() { + let x = vec![1, 2, 3, 4, 5]; + &x[!0..]; +} + +#[test] +#[should_panic] +fn test_slice_out_of_bounds_2() { + let x = vec![1, 2, 3, 4, 5]; + &x[..6]; +} + +#[test] +#[should_panic] +fn test_slice_out_of_bounds_3() { + let x = vec![1, 2, 3, 4, 5]; + &x[!0..4]; +} + +#[test] +#[should_panic] +fn test_slice_out_of_bounds_4() { + let x = vec![1, 2, 3, 4, 5]; + &x[1..6]; +} + +#[test] +#[should_panic] +fn test_slice_out_of_bounds_5() { + let x = vec![1, 2, 3, 4, 5]; + &x[3..2]; +} + +#[test] +#[should_panic] +fn test_swap_remove_empty() { + let mut vec = Vec::::new(); + vec.swap_remove(0); +} + +#[test] +fn test_move_items() { + let vec = vec![1, 2, 3]; + let mut vec2 = vec![]; + for i in vec { + vec2.push(i); + } + assert_eq!(vec2, [1, 2, 3]); +} + +#[test] +fn test_move_items_reverse() { + let vec = vec![1, 2, 3]; + let mut vec2 = vec![]; + for i in vec.into_iter().rev() { + vec2.push(i); + } + assert_eq!(vec2, [3, 2, 1]); +} + +#[test] +fn test_move_items_zero_sized() { + let vec = vec![(), (), ()]; + let mut vec2 = vec![]; + for i in vec { + vec2.push(i); + } + assert_eq!(vec2, [(), (), ()]); +} + +#[test] +fn test_drain_items() { + let mut vec = vec![1, 2, 3]; + let mut vec2 = vec![]; + for i in vec.drain(..) { + vec2.push(i); + } + assert_eq!(vec, []); + assert_eq!(vec2, [1, 2, 3]); +} + +#[test] +fn test_drain_items_reverse() { + let mut vec = vec![1, 2, 3]; + let mut vec2 = vec![]; + for i in vec.drain(..).rev() { + vec2.push(i); + } + assert_eq!(vec, []); + assert_eq!(vec2, [3, 2, 1]); +} + +#[test] +fn test_drain_items_zero_sized() { + let mut vec = vec![(), (), ()]; + let mut vec2 = vec![]; + for i in vec.drain(..) { + vec2.push(i); + } + assert_eq!(vec, []); + assert_eq!(vec2, [(), (), ()]); +} + +#[test] +#[should_panic] +fn test_drain_out_of_bounds() { + let mut v = vec![1, 2, 3, 4, 5]; + v.drain(5..6); +} + +#[test] +fn test_drain_range() { + let mut v = vec![1, 2, 3, 4, 5]; + for _ in v.drain(4..) {} + assert_eq!(v, &[1, 2, 3, 4]); + + let mut v: Vec<_> = (1..6).map(|x| x.to_string()).collect(); + for _ in v.drain(1..4) {} + assert_eq!(v, &[1.to_string(), 5.to_string()]); + + let mut v: Vec<_> = (1..6).map(|x| x.to_string()).collect(); + for _ in v.drain(1..4).rev() {} + assert_eq!(v, &[1.to_string(), 5.to_string()]); + + let mut v: Vec<_> = vec![(); 5]; + for _ in v.drain(1..4).rev() {} + assert_eq!(v, &[(), ()]); +} + +#[test] +fn test_drain_inclusive_range() { + let mut v = vec!['a', 'b', 'c', 'd', 'e']; + for _ in v.drain(1..=3) {} + assert_eq!(v, &['a', 'e']); + + let mut v: Vec<_> = (0..=5).map(|x| x.to_string()).collect(); + for _ in v.drain(1..=5) {} + assert_eq!(v, &["0".to_string()]); + + let mut v: Vec = (0..=5).map(|x| x.to_string()).collect(); + for _ in v.drain(0..=5) {} + assert_eq!(v, Vec::::new()); + + let mut v: Vec<_> = (0..=5).map(|x| x.to_string()).collect(); + for _ in v.drain(0..=3) {} + assert_eq!(v, &["4".to_string(), "5".to_string()]); + + let mut v: Vec<_> = (0..=1).map(|x| x.to_string()).collect(); + for _ in v.drain(..=0) {} + assert_eq!(v, &["1".to_string()]); +} + +#[test] +fn test_drain_max_vec_size() { + let mut v = Vec::<()>::with_capacity(usize::MAX); + unsafe { + v.set_len(usize::MAX); + } + for _ in v.drain(usize::MAX - 1..) {} + assert_eq!(v.len(), usize::MAX - 1); + + let mut v = Vec::<()>::with_capacity(usize::MAX); + unsafe { + v.set_len(usize::MAX); + } + for _ in v.drain(usize::MAX - 1..=usize::MAX - 1) {} + assert_eq!(v.len(), usize::MAX - 1); +} + +#[test] +#[should_panic] +fn test_drain_index_overflow() { + let mut v = Vec::<()>::with_capacity(usize::MAX); + unsafe { + v.set_len(usize::MAX); + } + v.drain(0..=usize::MAX); +} + +#[test] +#[should_panic] +fn test_drain_inclusive_out_of_bounds() { + let mut v = vec![1, 2, 3, 4, 5]; + v.drain(5..=5); +} + +#[test] +#[should_panic] +fn test_drain_start_overflow() { + let mut v = vec![1, 2, 3]; + v.drain((Excluded(usize::MAX), Included(0))); +} + +#[test] +#[should_panic] +fn test_drain_end_overflow() { + let mut v = vec![1, 2, 3]; + v.drain((Included(0), Included(usize::MAX))); +} + +#[test] +fn test_drain_leak() { + static mut DROPS: i32 = 0; + + #[derive(Debug, PartialEq)] + struct D(u32, bool); + + impl Drop for D { + fn drop(&mut self) { + unsafe { + DROPS += 1; + } + + if self.1 { + panic!("panic in `drop`"); + } + } + } + + let mut v = vec![ + D(0, false), + D(1, false), + D(2, false), + D(3, false), + D(4, true), + D(5, false), + D(6, false), + ]; + + catch_unwind(AssertUnwindSafe(|| { + v.drain(2..=5); + })) + .ok(); + + assert_eq!(unsafe { DROPS }, 4); + assert_eq!(v, vec![D(0, false), D(1, false), D(6, false),]); +} + +#[test] +fn test_splice() { + let mut v = vec![1, 2, 3, 4, 5]; + let a = [10, 11, 12]; + v.splice(2..4, a.iter().cloned()); + assert_eq!(v, &[1, 2, 10, 11, 12, 5]); + v.splice(1..3, Some(20)); + assert_eq!(v, &[1, 20, 11, 12, 5]); +} + +#[test] +fn test_splice_inclusive_range() { + let mut v = vec![1, 2, 3, 4, 5]; + let a = [10, 11, 12]; + let t1: Vec<_> = v.splice(2..=3, a.iter().cloned()).collect(); + assert_eq!(v, &[1, 2, 10, 11, 12, 5]); + assert_eq!(t1, &[3, 4]); + let t2: Vec<_> = v.splice(1..=2, Some(20)).collect(); + assert_eq!(v, &[1, 20, 11, 12, 5]); + assert_eq!(t2, &[2, 10]); +} + +#[test] +#[should_panic] +fn test_splice_out_of_bounds() { + let mut v = vec![1, 2, 3, 4, 5]; + let a = [10, 11, 12]; + v.splice(5..6, a.iter().cloned()); +} + +#[test] +#[should_panic] +fn test_splice_inclusive_out_of_bounds() { + let mut v = vec![1, 2, 3, 4, 5]; + let a = [10, 11, 12]; + v.splice(5..=5, a.iter().cloned()); +} + +#[test] +fn test_splice_items_zero_sized() { + let mut vec = vec![(), (), ()]; + let vec2 = vec![]; + let t: Vec<_> = vec.splice(1..2, vec2.iter().cloned()).collect(); + assert_eq!(vec, &[(), ()]); + assert_eq!(t, &[()]); +} + +#[test] +fn test_splice_unbounded() { + let mut vec = vec![1, 2, 3, 4, 5]; + let t: Vec<_> = vec.splice(.., None).collect(); + assert_eq!(vec, &[]); + assert_eq!(t, &[1, 2, 3, 4, 5]); +} + +#[test] +fn test_splice_forget() { + let mut v = vec![1, 2, 3, 4, 5]; + let a = [10, 11, 12]; + std::mem::forget(v.splice(2..4, a.iter().cloned())); + assert_eq!(v, &[1, 2]); +} + +#[test] +fn test_into_boxed_slice() { + let xs = vec![1, 2, 3]; + let ys = xs.into_boxed_slice(); + assert_eq!(&*ys, [1, 2, 3]); +} + +#[test] +fn test_append() { + let mut vec = vec![1, 2, 3]; + let mut vec2 = vec![4, 5, 6]; + vec.append(&mut vec2); + assert_eq!(vec, [1, 2, 3, 4, 5, 6]); + assert_eq!(vec2, []); +} + +#[test] +fn test_split_off() { + let mut vec = vec![1, 2, 3, 4, 5, 6]; + let orig_capacity = vec.capacity(); + let vec2 = vec.split_off(4); + assert_eq!(vec, [1, 2, 3, 4]); + assert_eq!(vec2, [5, 6]); + assert_eq!(vec.capacity(), orig_capacity); +} + +#[test] +fn test_split_off_take_all() { + let mut vec = vec![1, 2, 3, 4, 5, 6]; + let orig_ptr = vec.as_ptr(); + let orig_capacity = vec.capacity(); + let vec2 = vec.split_off(0); + assert_eq!(vec, []); + assert_eq!(vec2, [1, 2, 3, 4, 5, 6]); + assert_eq!(vec.capacity(), orig_capacity); + assert_eq!(vec2.as_ptr(), orig_ptr); +} + +#[test] +fn test_into_iter_as_slice() { + let vec = vec!['a', 'b', 'c']; + let mut into_iter = vec.into_iter(); + assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']); + let _ = into_iter.next().unwrap(); + assert_eq!(into_iter.as_slice(), &['b', 'c']); + let _ = into_iter.next().unwrap(); + let _ = into_iter.next().unwrap(); + assert_eq!(into_iter.as_slice(), &[]); +} + +#[test] +fn test_into_iter_as_mut_slice() { + let vec = vec!['a', 'b', 'c']; + let mut into_iter = vec.into_iter(); + assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']); + into_iter.as_mut_slice()[0] = 'x'; + into_iter.as_mut_slice()[1] = 'y'; + assert_eq!(into_iter.next().unwrap(), 'x'); + assert_eq!(into_iter.as_slice(), &['y', 'c']); +} + +#[test] +fn test_into_iter_debug() { + let vec = vec!['a', 'b', 'c']; + let into_iter = vec.into_iter(); + let debug = format!("{:?}", into_iter); + assert_eq!(debug, "IntoIter(['a', 'b', 'c'])"); +} + +#[test] +fn test_into_iter_count() { + assert_eq!(vec![1, 2, 3].into_iter().count(), 3); +} + +#[test] +fn test_into_iter_clone() { + fn iter_equal>(it: I, slice: &[i32]) { + let v: Vec = it.collect(); + assert_eq!(&v[..], slice); + } + let mut it = vec![1, 2, 3].into_iter(); + iter_equal(it.clone(), &[1, 2, 3]); + assert_eq!(it.next(), Some(1)); + let mut it = it.rev(); + iter_equal(it.clone(), &[3, 2]); + assert_eq!(it.next(), Some(3)); + iter_equal(it.clone(), &[2]); + assert_eq!(it.next(), Some(2)); + iter_equal(it.clone(), &[]); + assert_eq!(it.next(), None); +} + +#[test] +fn test_into_iter_leak() { + static mut DROPS: i32 = 0; + + struct D(bool); + + impl Drop for D { + fn drop(&mut self) { + unsafe { + DROPS += 1; + } + + if self.0 { + panic!("panic in `drop`"); + } + } + } + + let v = vec![D(false), D(true), D(false)]; + + catch_unwind(move || drop(v.into_iter())).ok(); + + assert_eq!(unsafe { DROPS }, 3); +} + +#[test] +fn test_from_iter_specialization() { + let src: Vec = vec![0usize; 1]; + let srcptr = src.as_ptr(); + let sink = src.into_iter().collect::>(); + let sinkptr = sink.as_ptr(); + assert_eq!(srcptr, sinkptr); +} + +#[test] +fn test_from_iter_partially_drained_in_place_specialization() { + let src: Vec = vec![0usize; 10]; + let srcptr = src.as_ptr(); + let mut iter = src.into_iter(); + iter.next(); + iter.next(); + let sink = iter.collect::>(); + let sinkptr = sink.as_ptr(); + assert_eq!(srcptr, sinkptr); +} + +#[test] +fn test_from_iter_specialization_with_iterator_adapters() { + fn assert_in_place_trait(_: &T) {}; + let src: Vec = vec![0usize; 256]; + let srcptr = src.as_ptr(); + let iter = src + .into_iter() + .enumerate() + .map(|i| i.0 + i.1) + .zip(std::iter::repeat(1usize)) + .map(|(a, b)| a + b) + .map_while(Option::Some) + .peekable() + .skip(1) + .map(|e| std::num::NonZeroUsize::new(e)); + assert_in_place_trait(&iter); + let sink = iter.collect::>(); + let sinkptr = sink.as_ptr(); + assert_eq!(srcptr, sinkptr as *const usize); +} + +#[test] +fn test_from_iter_specialization_head_tail_drop() { + let drop_count: Vec<_> = (0..=2).map(|_| Rc::new(())).collect(); + let src: Vec<_> = drop_count.iter().cloned().collect(); + let srcptr = src.as_ptr(); + let iter = src.into_iter(); + let sink: Vec<_> = iter.skip(1).take(1).collect(); + let sinkptr = sink.as_ptr(); + assert_eq!(srcptr, sinkptr, "specialization was applied"); + assert_eq!(Rc::strong_count(&drop_count[0]), 1, "front was dropped"); + assert_eq!(Rc::strong_count(&drop_count[1]), 2, "one element was collected"); + assert_eq!(Rc::strong_count(&drop_count[2]), 1, "tail was dropped"); + assert_eq!(sink.len(), 1); +} + +#[test] +fn test_from_iter_specialization_panic_drop() { + let drop_count: Vec<_> = (0..=2).map(|_| Rc::new(())).collect(); + let src: Vec<_> = drop_count.iter().cloned().collect(); + let iter = src.into_iter(); + + let _ = std::panic::catch_unwind(AssertUnwindSafe(|| { + let _ = iter + .enumerate() + .filter_map(|(i, e)| { + if i == 1 { + std::panic!("aborting iteration"); + } + Some(e) + }) + .collect::>(); + })); + + assert!( + drop_count.iter().map(Rc::strong_count).all(|count| count == 1), + "all items were dropped once" + ); +} + +#[test] +fn test_cow_from() { + let borrowed: &[_] = &["borrowed", "(slice)"]; + let owned = vec!["owned", "(vec)"]; + match (Cow::from(owned.clone()), Cow::from(borrowed)) { + (Cow::Owned(o), Cow::Borrowed(b)) => assert!(o == owned && b == borrowed), + _ => panic!("invalid `Cow::from`"), + } +} + +#[test] +fn test_from_cow() { + let borrowed: &[_] = &["borrowed", "(slice)"]; + let owned = vec!["owned", "(vec)"]; + assert_eq!(Vec::from(Cow::Borrowed(borrowed)), vec!["borrowed", "(slice)"]); + assert_eq!(Vec::from(Cow::Owned(owned)), vec!["owned", "(vec)"]); +} + +#[allow(dead_code)] +fn assert_covariance() { + fn drain<'new>(d: Drain<'static, &'static str>) -> Drain<'new, &'new str> { + d + } + fn into_iter<'new>(i: IntoIter<&'static str>) -> IntoIter<&'new str> { + i + } +} + +#[test] +fn from_into_inner() { + let vec = vec![1, 2, 3]; + let ptr = vec.as_ptr(); + let vec = vec.into_iter().collect::>(); + assert_eq!(vec, [1, 2, 3]); + assert_eq!(vec.as_ptr(), ptr); + + let ptr = &vec[1] as *const _; + let mut it = vec.into_iter(); + it.next().unwrap(); + let vec = it.collect::>(); + assert_eq!(vec, [2, 3]); + assert!(ptr != vec.as_ptr()); +} + +#[test] +fn overaligned_allocations() { + #[repr(align(256))] + struct Foo(usize); + let mut v = vec![Foo(273)]; + for i in 0..0x1000 { + v.reserve_exact(i); + assert!(v[0].0 == 273); + assert!(v.as_ptr() as usize & 0xff == 0); + v.shrink_to_fit(); + assert!(v[0].0 == 273); + assert!(v.as_ptr() as usize & 0xff == 0); + } +} + +#[test] +fn drain_filter_empty() { + let mut vec: Vec = vec![]; + + { + let mut iter = vec.drain_filter(|_| true); + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + assert_eq!(iter.size_hint(), (0, Some(0))); + } + assert_eq!(vec.len(), 0); + assert_eq!(vec, vec![]); +} + +#[test] +fn drain_filter_zst() { + let mut vec = vec![(), (), (), (), ()]; + let initial_len = vec.len(); + let mut count = 0; + { + let mut iter = vec.drain_filter(|_| true); + assert_eq!(iter.size_hint(), (0, Some(initial_len))); + while let Some(_) = iter.next() { + count += 1; + assert_eq!(iter.size_hint(), (0, Some(initial_len - count))); + } + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + assert_eq!(iter.size_hint(), (0, Some(0))); + } + + assert_eq!(count, initial_len); + assert_eq!(vec.len(), 0); + assert_eq!(vec, vec![]); +} + +#[test] +fn drain_filter_false() { + let mut vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; + + let initial_len = vec.len(); + let mut count = 0; + { + let mut iter = vec.drain_filter(|_| false); + assert_eq!(iter.size_hint(), (0, Some(initial_len))); + for _ in iter.by_ref() { + count += 1; + } + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + assert_eq!(iter.size_hint(), (0, Some(0))); + } + + assert_eq!(count, 0); + assert_eq!(vec.len(), initial_len); + assert_eq!(vec, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); +} + +#[test] +fn drain_filter_true() { + let mut vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; + + let initial_len = vec.len(); + let mut count = 0; + { + let mut iter = vec.drain_filter(|_| true); + assert_eq!(iter.size_hint(), (0, Some(initial_len))); + while let Some(_) = iter.next() { + count += 1; + assert_eq!(iter.size_hint(), (0, Some(initial_len - count))); + } + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + assert_eq!(iter.size_hint(), (0, Some(0))); + } + + assert_eq!(count, initial_len); + assert_eq!(vec.len(), 0); + assert_eq!(vec, vec![]); +} + +#[test] +fn drain_filter_complex() { + { + // [+xxx++++++xxxxx++++x+x++] + let mut vec = vec![ + 1, 2, 4, 6, 7, 9, 11, 13, 15, 17, 18, 20, 22, 24, 26, 27, 29, 31, 33, 34, 35, 36, 37, + 39, + ]; + + let removed = vec.drain_filter(|x| *x % 2 == 0).collect::>(); + assert_eq!(removed.len(), 10); + assert_eq!(removed, vec![2, 4, 6, 18, 20, 22, 24, 26, 34, 36]); + + assert_eq!(vec.len(), 14); + assert_eq!(vec, vec![1, 7, 9, 11, 13, 15, 17, 27, 29, 31, 33, 35, 37, 39]); + } + + { + // [xxx++++++xxxxx++++x+x++] + let mut vec = vec![ + 2, 4, 6, 7, 9, 11, 13, 15, 17, 18, 20, 22, 24, 26, 27, 29, 31, 33, 34, 35, 36, 37, 39, + ]; + + let removed = vec.drain_filter(|x| *x % 2 == 0).collect::>(); + assert_eq!(removed.len(), 10); + assert_eq!(removed, vec![2, 4, 6, 18, 20, 22, 24, 26, 34, 36]); + + assert_eq!(vec.len(), 13); + assert_eq!(vec, vec![7, 9, 11, 13, 15, 17, 27, 29, 31, 33, 35, 37, 39]); + } + + { + // [xxx++++++xxxxx++++x+x] + let mut vec = + vec![2, 4, 6, 7, 9, 11, 13, 15, 17, 18, 20, 22, 24, 26, 27, 29, 31, 33, 34, 35, 36]; + + let removed = vec.drain_filter(|x| *x % 2 == 0).collect::>(); + assert_eq!(removed.len(), 10); + assert_eq!(removed, vec![2, 4, 6, 18, 20, 22, 24, 26, 34, 36]); + + assert_eq!(vec.len(), 11); + assert_eq!(vec, vec![7, 9, 11, 13, 15, 17, 27, 29, 31, 33, 35]); + } + + { + // [xxxxxxxxxx+++++++++++] + let mut vec = vec![2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19]; + + let removed = vec.drain_filter(|x| *x % 2 == 0).collect::>(); + assert_eq!(removed.len(), 10); + assert_eq!(removed, vec![2, 4, 6, 8, 10, 12, 14, 16, 18, 20]); + + assert_eq!(vec.len(), 10); + assert_eq!(vec, vec![1, 3, 5, 7, 9, 11, 13, 15, 17, 19]); + } + + { + // [+++++++++++xxxxxxxxxx] + let mut vec = vec![1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]; + + let removed = vec.drain_filter(|x| *x % 2 == 0).collect::>(); + assert_eq!(removed.len(), 10); + assert_eq!(removed, vec![2, 4, 6, 8, 10, 12, 14, 16, 18, 20]); + + assert_eq!(vec.len(), 10); + assert_eq!(vec, vec![1, 3, 5, 7, 9, 11, 13, 15, 17, 19]); + } +} + +// FIXME: re-enable emscripten once it can unwind again +#[test] +#[cfg(not(target_os = "emscripten"))] +fn drain_filter_consumed_panic() { + use std::rc::Rc; + use std::sync::Mutex; + + struct Check { + index: usize, + drop_counts: Rc>>, + }; + + impl Drop for Check { + fn drop(&mut self) { + self.drop_counts.lock().unwrap()[self.index] += 1; + println!("drop: {}", self.index); + } + } + + let check_count = 10; + let drop_counts = Rc::new(Mutex::new(vec![0_usize; check_count])); + let mut data: Vec = (0..check_count) + .map(|index| Check { index, drop_counts: Rc::clone(&drop_counts) }) + .collect(); + + let _ = std::panic::catch_unwind(move || { + let filter = |c: &mut Check| { + if c.index == 2 { + panic!("panic at index: {}", c.index); + } + // Verify that if the filter could panic again on another element + // that it would not cause a double panic and all elements of the + // vec would still be dropped exactly once. + if c.index == 4 { + panic!("panic at index: {}", c.index); + } + c.index < 6 + }; + let drain = data.drain_filter(filter); + + // NOTE: The DrainFilter is explicitly consumed + drain.for_each(drop); + }); + + let drop_counts = drop_counts.lock().unwrap(); + assert_eq!(check_count, drop_counts.len()); + + for (index, count) in drop_counts.iter().cloned().enumerate() { + assert_eq!(1, count, "unexpected drop count at index: {} (count: {})", index, count); + } +} + +// FIXME: Re-enable emscripten once it can catch panics +#[test] +#[cfg(not(target_os = "emscripten"))] +fn drain_filter_unconsumed_panic() { + use std::rc::Rc; + use std::sync::Mutex; + + struct Check { + index: usize, + drop_counts: Rc>>, + }; + + impl Drop for Check { + fn drop(&mut self) { + self.drop_counts.lock().unwrap()[self.index] += 1; + println!("drop: {}", self.index); + } + } + + let check_count = 10; + let drop_counts = Rc::new(Mutex::new(vec![0_usize; check_count])); + let mut data: Vec = (0..check_count) + .map(|index| Check { index, drop_counts: Rc::clone(&drop_counts) }) + .collect(); + + let _ = std::panic::catch_unwind(move || { + let filter = |c: &mut Check| { + if c.index == 2 { + panic!("panic at index: {}", c.index); + } + // Verify that if the filter could panic again on another element + // that it would not cause a double panic and all elements of the + // vec would still be dropped exactly once. + if c.index == 4 { + panic!("panic at index: {}", c.index); + } + c.index < 6 + }; + let _drain = data.drain_filter(filter); + + // NOTE: The DrainFilter is dropped without being consumed + }); + + let drop_counts = drop_counts.lock().unwrap(); + assert_eq!(check_count, drop_counts.len()); + + for (index, count) in drop_counts.iter().cloned().enumerate() { + assert_eq!(1, count, "unexpected drop count at index: {} (count: {})", index, count); + } +} + +#[test] +fn drain_filter_unconsumed() { + let mut vec = vec![1, 2, 3, 4]; + let drain = vec.drain_filter(|&mut x| x % 2 != 0); + drop(drain); + assert_eq!(vec, [2, 4]); +} + +#[test] +fn test_reserve_exact() { + // This is all the same as test_reserve + + let mut v = Vec::new(); + assert_eq!(v.capacity(), 0); + + v.reserve_exact(2); + assert!(v.capacity() >= 2); + + for i in 0..16 { + v.push(i); + } + + assert!(v.capacity() >= 16); + v.reserve_exact(16); + assert!(v.capacity() >= 32); + + v.push(16); + + v.reserve_exact(16); + assert!(v.capacity() >= 33) +} + +#[test] +#[cfg_attr(miri, ignore)] // Miri does not support signalling OOM +#[cfg_attr(target_os = "android", ignore)] // Android used in CI has a broken dlmalloc +fn test_try_reserve() { + // These are the interesting cases: + // * exactly isize::MAX should never trigger a CapacityOverflow (can be OOM) + // * > isize::MAX should always fail + // * On 16/32-bit should CapacityOverflow + // * On 64-bit should OOM + // * overflow may trigger when adding `len` to `cap` (in number of elements) + // * overflow may trigger when multiplying `new_cap` by size_of:: (to get bytes) + + const MAX_CAP: usize = isize::MAX as usize; + const MAX_USIZE: usize = usize::MAX; + + // On 16/32-bit, we check that allocations don't exceed isize::MAX, + // on 64-bit, we assume the OS will give an OOM for such a ridiculous size. + // Any platform that succeeds for these requests is technically broken with + // ptr::offset because LLVM is the worst. + let guards_against_isize = usize::BITS < 64; + + { + // Note: basic stuff is checked by test_reserve + let mut empty_bytes: Vec = Vec::new(); + + // Check isize::MAX doesn't count as an overflow + if let Err(CapacityOverflow) = empty_bytes.try_reserve(MAX_CAP) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + // Play it again, frank! (just to be sure) + if let Err(CapacityOverflow) = empty_bytes.try_reserve(MAX_CAP) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + + if guards_against_isize { + // Check isize::MAX + 1 does count as overflow + if let Err(CapacityOverflow) = empty_bytes.try_reserve(MAX_CAP + 1) { + } else { + panic!("isize::MAX + 1 should trigger an overflow!") + } + + // Check usize::MAX does count as overflow + if let Err(CapacityOverflow) = empty_bytes.try_reserve(MAX_USIZE) { + } else { + panic!("usize::MAX should trigger an overflow!") + } + } else { + // Check isize::MAX + 1 is an OOM + if let Err(AllocError { .. }) = empty_bytes.try_reserve(MAX_CAP + 1) { + } else { + panic!("isize::MAX + 1 should trigger an OOM!") + } + + // Check usize::MAX is an OOM + if let Err(AllocError { .. }) = empty_bytes.try_reserve(MAX_USIZE) { + } else { + panic!("usize::MAX should trigger an OOM!") + } + } + } + + { + // Same basic idea, but with non-zero len + let mut ten_bytes: Vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; + + if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_CAP - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_CAP - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if guards_against_isize { + if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_CAP - 9) { + } else { + panic!("isize::MAX + 1 should trigger an overflow!"); + } + } else { + if let Err(AllocError { .. }) = ten_bytes.try_reserve(MAX_CAP - 9) { + } else { + panic!("isize::MAX + 1 should trigger an OOM!") + } + } + // Should always overflow in the add-to-len + if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_USIZE) { + } else { + panic!("usize::MAX should trigger an overflow!") + } + } + + { + // Same basic idea, but with interesting type size + let mut ten_u32s: Vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; + + if let Err(CapacityOverflow) = ten_u32s.try_reserve(MAX_CAP / 4 - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if let Err(CapacityOverflow) = ten_u32s.try_reserve(MAX_CAP / 4 - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if guards_against_isize { + if let Err(CapacityOverflow) = ten_u32s.try_reserve(MAX_CAP / 4 - 9) { + } else { + panic!("isize::MAX + 1 should trigger an overflow!"); + } + } else { + if let Err(AllocError { .. }) = ten_u32s.try_reserve(MAX_CAP / 4 - 9) { + } else { + panic!("isize::MAX + 1 should trigger an OOM!") + } + } + // Should fail in the mul-by-size + if let Err(CapacityOverflow) = ten_u32s.try_reserve(MAX_USIZE - 20) { + } else { + panic!("usize::MAX should trigger an overflow!"); + } + } +} + +#[test] +#[cfg_attr(miri, ignore)] // Miri does not support signalling OOM +#[cfg_attr(target_os = "android", ignore)] // Android used in CI has a broken dlmalloc +fn test_try_reserve_exact() { + // This is exactly the same as test_try_reserve with the method changed. + // See that test for comments. + + const MAX_CAP: usize = isize::MAX as usize; + const MAX_USIZE: usize = usize::MAX; + + let guards_against_isize = size_of::() < 8; + + { + let mut empty_bytes: Vec = Vec::new(); + + if let Err(CapacityOverflow) = empty_bytes.try_reserve_exact(MAX_CAP) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if let Err(CapacityOverflow) = empty_bytes.try_reserve_exact(MAX_CAP) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + + if guards_against_isize { + if let Err(CapacityOverflow) = empty_bytes.try_reserve_exact(MAX_CAP + 1) { + } else { + panic!("isize::MAX + 1 should trigger an overflow!") + } + + if let Err(CapacityOverflow) = empty_bytes.try_reserve_exact(MAX_USIZE) { + } else { + panic!("usize::MAX should trigger an overflow!") + } + } else { + if let Err(AllocError { .. }) = empty_bytes.try_reserve_exact(MAX_CAP + 1) { + } else { + panic!("isize::MAX + 1 should trigger an OOM!") + } + + if let Err(AllocError { .. }) = empty_bytes.try_reserve_exact(MAX_USIZE) { + } else { + panic!("usize::MAX should trigger an OOM!") + } + } + } + + { + let mut ten_bytes: Vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; + + if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_CAP - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_CAP - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if guards_against_isize { + if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_CAP - 9) { + } else { + panic!("isize::MAX + 1 should trigger an overflow!"); + } + } else { + if let Err(AllocError { .. }) = ten_bytes.try_reserve_exact(MAX_CAP - 9) { + } else { + panic!("isize::MAX + 1 should trigger an OOM!") + } + } + if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_USIZE) { + } else { + panic!("usize::MAX should trigger an overflow!") + } + } + + { + let mut ten_u32s: Vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; + + if let Err(CapacityOverflow) = ten_u32s.try_reserve_exact(MAX_CAP / 4 - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if let Err(CapacityOverflow) = ten_u32s.try_reserve_exact(MAX_CAP / 4 - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if guards_against_isize { + if let Err(CapacityOverflow) = ten_u32s.try_reserve_exact(MAX_CAP / 4 - 9) { + } else { + panic!("isize::MAX + 1 should trigger an overflow!"); + } + } else { + if let Err(AllocError { .. }) = ten_u32s.try_reserve_exact(MAX_CAP / 4 - 9) { + } else { + panic!("isize::MAX + 1 should trigger an OOM!") + } + } + if let Err(CapacityOverflow) = ten_u32s.try_reserve_exact(MAX_USIZE - 20) { + } else { + panic!("usize::MAX should trigger an overflow!") + } + } +} + +#[test] +fn test_stable_pointers() { + /// Pull an element from the iterator, then drop it. + /// Useful to cover both the `next` and `drop` paths of an iterator. + fn next_then_drop(mut i: I) { + i.next().unwrap(); + drop(i); + } + + // Test that, if we reserved enough space, adding and removing elements does not + // invalidate references into the vector (such as `v0`). This test also + // runs in Miri, which would detect such problems. + // Note that this test does *not* constitute a stable guarantee that all these functions do not + // reallocate! Only what is explicitly documented at + // is stably guaranteed. + let mut v = Vec::with_capacity(128); + v.push(13); + + // Laundering the lifetime -- we take care that `v` does not reallocate, so that's okay. + let v0 = &mut v[0]; + let v0 = unsafe { &mut *(v0 as *mut _) }; + // Now do a bunch of things and occasionally use `v0` again to assert it is still valid. + + // Pushing/inserting and popping/removing + v.push(1); + v.push(2); + v.insert(1, 1); + assert_eq!(*v0, 13); + v.remove(1); + v.pop().unwrap(); + assert_eq!(*v0, 13); + v.push(1); + v.swap_remove(1); + assert_eq!(v.len(), 2); + v.swap_remove(1); // swap_remove the last element + assert_eq!(*v0, 13); + + // Appending + v.append(&mut vec![27, 19]); + assert_eq!(*v0, 13); + + // Extending + v.extend_from_slice(&[1, 2]); + v.extend(&[1, 2]); // `slice::Iter` (with `T: Copy`) specialization + v.extend(vec![2, 3]); // `vec::IntoIter` specialization + v.extend(std::iter::once(3)); // `TrustedLen` specialization + v.extend(std::iter::empty::()); // `TrustedLen` specialization with empty iterator + v.extend(std::iter::once(3).filter(|_| true)); // base case + v.extend(std::iter::once(&3)); // `cloned` specialization + assert_eq!(*v0, 13); + + // Truncation + v.truncate(2); + assert_eq!(*v0, 13); + + // Resizing + v.resize_with(v.len() + 10, || 42); + assert_eq!(*v0, 13); + v.resize_with(2, || panic!()); + assert_eq!(*v0, 13); + + // No-op reservation + v.reserve(32); + v.reserve_exact(32); + assert_eq!(*v0, 13); + + // Partial draining + v.resize_with(10, || 42); + next_then_drop(v.drain(5..)); + assert_eq!(*v0, 13); + + // Splicing + v.resize_with(10, || 42); + next_then_drop(v.splice(5.., vec![1, 2, 3, 4, 5])); // empty tail after range + assert_eq!(*v0, 13); + next_then_drop(v.splice(5..8, vec![1])); // replacement is smaller than original range + assert_eq!(*v0, 13); + next_then_drop(v.splice(5..6, vec![1; 10].into_iter().filter(|_| true))); // lower bound not exact + assert_eq!(*v0, 13); + + // Smoke test that would fire even outside Miri if an actual relocation happened. + *v0 -= 13; + assert_eq!(v[0], 0); +} + +// https://github.com/rust-lang/rust/pull/49496 introduced specialization based on: +// +// ``` +// unsafe impl IsZero for *mut T { +// fn is_zero(&self) -> bool { +// (*self).is_null() +// } +// } +// ``` +// +// … to call `RawVec::with_capacity_zeroed` for creating `Vec<*mut T>`, +// which is incorrect for fat pointers since `<*mut T>::is_null` only looks at the data component. +// That is, a fat pointer can be “null” without being made entirely of zero bits. +#[test] +fn vec_macro_repeating_null_raw_fat_pointer() { + let raw_dyn = &mut (|| ()) as &mut dyn Fn() as *mut dyn Fn(); + let vtable = dbg!(ptr_metadata(raw_dyn)); + let null_raw_dyn = ptr_from_raw_parts(std::ptr::null_mut(), vtable); + assert!(null_raw_dyn.is_null()); + + let vec = vec![null_raw_dyn; 1]; + dbg!(ptr_metadata(vec[0])); + assert!(vec[0] == null_raw_dyn); + + // Polyfill for https://github.com/rust-lang/rfcs/pull/2580 + + fn ptr_metadata(ptr: *mut dyn Fn()) -> *mut () { + unsafe { std::mem::transmute::<*mut dyn Fn(), DynRepr>(ptr).vtable } + } + + fn ptr_from_raw_parts(data: *mut (), vtable: *mut ()) -> *mut dyn Fn() { + unsafe { std::mem::transmute::(DynRepr { data, vtable }) } + } + + #[repr(C)] + struct DynRepr { + data: *mut (), + vtable: *mut (), + } +} + +// This test will likely fail if you change the capacities used in +// `RawVec::grow_amortized`. +#[test] +fn test_push_growth_strategy() { + // If the element size is 1, we jump from 0 to 8, then double. + { + let mut v1: Vec = vec![]; + assert_eq!(v1.capacity(), 0); + + for _ in 0..8 { + v1.push(0); + assert_eq!(v1.capacity(), 8); + } + + for _ in 8..16 { + v1.push(0); + assert_eq!(v1.capacity(), 16); + } + + for _ in 16..32 { + v1.push(0); + assert_eq!(v1.capacity(), 32); + } + + for _ in 32..64 { + v1.push(0); + assert_eq!(v1.capacity(), 64); + } + } + + // If the element size is 2..=1024, we jump from 0 to 4, then double. + { + let mut v2: Vec = vec![]; + let mut v1024: Vec<[u8; 1024]> = vec![]; + assert_eq!(v2.capacity(), 0); + assert_eq!(v1024.capacity(), 0); + + for _ in 0..4 { + v2.push(0); + v1024.push([0; 1024]); + assert_eq!(v2.capacity(), 4); + assert_eq!(v1024.capacity(), 4); + } + + for _ in 4..8 { + v2.push(0); + v1024.push([0; 1024]); + assert_eq!(v2.capacity(), 8); + assert_eq!(v1024.capacity(), 8); + } + + for _ in 8..16 { + v2.push(0); + v1024.push([0; 1024]); + assert_eq!(v2.capacity(), 16); + assert_eq!(v1024.capacity(), 16); + } + + for _ in 16..32 { + v2.push(0); + v1024.push([0; 1024]); + assert_eq!(v2.capacity(), 32); + assert_eq!(v1024.capacity(), 32); + } + + for _ in 32..64 { + v2.push(0); + v1024.push([0; 1024]); + assert_eq!(v2.capacity(), 64); + assert_eq!(v1024.capacity(), 64); + } + } + + // If the element size is > 1024, we jump from 0 to 1, then double. + { + let mut v1025: Vec<[u8; 1025]> = vec![]; + assert_eq!(v1025.capacity(), 0); + + for _ in 0..1 { + v1025.push([0; 1025]); + assert_eq!(v1025.capacity(), 1); + } + + for _ in 1..2 { + v1025.push([0; 1025]); + assert_eq!(v1025.capacity(), 2); + } + + for _ in 2..4 { + v1025.push([0; 1025]); + assert_eq!(v1025.capacity(), 4); + } + + for _ in 4..8 { + v1025.push([0; 1025]); + assert_eq!(v1025.capacity(), 8); + } + + for _ in 8..16 { + v1025.push([0; 1025]); + assert_eq!(v1025.capacity(), 16); + } + + for _ in 16..32 { + v1025.push([0; 1025]); + assert_eq!(v1025.capacity(), 32); + } + + for _ in 32..64 { + v1025.push([0; 1025]); + assert_eq!(v1025.capacity(), 64); + } + } +} + +macro_rules! generate_assert_eq_vec_and_prim { + ($name:ident<$B:ident>($type:ty)) => { + fn $name + Debug, $B: Debug>(a: Vec, b: $type) { + assert!(a == b); + assert_eq!(a, b); + } + }; +} + +generate_assert_eq_vec_and_prim! { assert_eq_vec_and_slice (&[B]) } +generate_assert_eq_vec_and_prim! { assert_eq_vec_and_array_3([B; 3]) } + +#[test] +fn partialeq_vec_and_prim() { + assert_eq_vec_and_slice(vec![1, 2, 3], &[1, 2, 3]); + assert_eq_vec_and_array_3(vec![1, 2, 3], [1, 2, 3]); +} + +macro_rules! assert_partial_eq_valid { + ($a2:expr, $a3:expr; $b2:expr, $b3: expr) => { + assert!($a2 == $b2); + assert!($a2 != $b3); + assert!($a3 != $b2); + assert!($a3 == $b3); + assert_eq!($a2, $b2); + assert_ne!($a2, $b3); + assert_ne!($a3, $b2); + assert_eq!($a3, $b3); + }; +} + +#[test] +fn partialeq_vec_full() { + let vec2: Vec<_> = vec![1, 2]; + let vec3: Vec<_> = vec![1, 2, 3]; + let slice2: &[_] = &[1, 2]; + let slice3: &[_] = &[1, 2, 3]; + let slicemut2: &[_] = &mut [1, 2]; + let slicemut3: &[_] = &mut [1, 2, 3]; + let array2: [_; 2] = [1, 2]; + let array3: [_; 3] = [1, 2, 3]; + let arrayref2: &[_; 2] = &[1, 2]; + let arrayref3: &[_; 3] = &[1, 2, 3]; + + assert_partial_eq_valid!(vec2,vec3; vec2,vec3); + assert_partial_eq_valid!(vec2,vec3; slice2,slice3); + assert_partial_eq_valid!(vec2,vec3; slicemut2,slicemut3); + assert_partial_eq_valid!(slice2,slice3; vec2,vec3); + assert_partial_eq_valid!(slicemut2,slicemut3; vec2,vec3); + assert_partial_eq_valid!(vec2,vec3; array2,array3); + assert_partial_eq_valid!(vec2,vec3; arrayref2,arrayref3); + assert_partial_eq_valid!(vec2,vec3; arrayref2[..],arrayref3[..]); +} + +#[test] +fn test_vec_cycle() { + #[derive(Debug)] + struct C<'a> { + v: Vec>>>, + } + + impl<'a> C<'a> { + fn new() -> C<'a> { + C { v: Vec::new() } + } + } + + let mut c1 = C::new(); + let mut c2 = C::new(); + let mut c3 = C::new(); + + // Push + c1.v.push(Cell::new(None)); + c1.v.push(Cell::new(None)); + + c2.v.push(Cell::new(None)); + c2.v.push(Cell::new(None)); + + c3.v.push(Cell::new(None)); + c3.v.push(Cell::new(None)); + + // Set + c1.v[0].set(Some(&c2)); + c1.v[1].set(Some(&c3)); + + c2.v[0].set(Some(&c2)); + c2.v[1].set(Some(&c3)); + + c3.v[0].set(Some(&c1)); + c3.v[1].set(Some(&c2)); +} + +#[test] +fn test_vec_cycle_wrapped() { + struct Refs<'a> { + v: Vec>>>, + } + + struct C<'a> { + refs: Refs<'a>, + } + + impl<'a> Refs<'a> { + fn new() -> Refs<'a> { + Refs { v: Vec::new() } + } + } + + impl<'a> C<'a> { + fn new() -> C<'a> { + C { refs: Refs::new() } + } + } + + let mut c1 = C::new(); + let mut c2 = C::new(); + let mut c3 = C::new(); + + c1.refs.v.push(Cell::new(None)); + c1.refs.v.push(Cell::new(None)); + c2.refs.v.push(Cell::new(None)); + c2.refs.v.push(Cell::new(None)); + c3.refs.v.push(Cell::new(None)); + c3.refs.v.push(Cell::new(None)); + + c1.refs.v[0].set(Some(&c2)); + c1.refs.v[1].set(Some(&c3)); + c2.refs.v[0].set(Some(&c2)); + c2.refs.v[1].set(Some(&c3)); + c3.refs.v[0].set(Some(&c1)); + c3.refs.v[1].set(Some(&c2)); +} + +#[test] +fn test_zero_sized_vec_push() { + const N: usize = 8; + + for len in 0..N { + let mut tester = Vec::with_capacity(len); + assert_eq!(tester.len(), 0); + assert!(tester.capacity() >= len); + for _ in 0..len { + tester.push(()); + } + assert_eq!(tester.len(), len); + assert_eq!(tester.iter().count(), len); + tester.clear(); + } +} + +#[test] +fn test_vec_macro_repeat() { + assert_eq!(vec![1; 3], vec![1, 1, 1]); + assert_eq!(vec![1; 2], vec![1, 1]); + assert_eq!(vec![1; 1], vec![1]); + assert_eq!(vec![1; 0], vec![]); + + // from_elem syntax (see RFC 832) + let el = Box::new(1); + let n = 3; + assert_eq!(vec![el; n], vec![Box::new(1), Box::new(1), Box::new(1)]); +} + +#[test] +fn test_vec_swap() { + let mut a: Vec = vec![0, 1, 2, 3, 4, 5, 6]; + a.swap(2, 4); + assert_eq!(a[2], 4); + assert_eq!(a[4], 2); + let mut n = 42; + swap(&mut n, &mut a[0]); + assert_eq!(a[0], 42); + assert_eq!(n, 0); +} diff --git a/libgrust/rustc-lib/alloc/tests/vec_deque.rs b/libgrust/rustc-lib/alloc/tests/vec_deque.rs new file mode 100644 index 000000000000..705f0d62fbb7 --- /dev/null +++ b/libgrust/rustc-lib/alloc/tests/vec_deque.rs @@ -0,0 +1,1730 @@ +use std::collections::TryReserveError::*; +use std::collections::{vec_deque::Drain, VecDeque}; +use std::fmt::Debug; +use std::mem::size_of; +use std::ops::Bound::*; +use std::panic::{catch_unwind, AssertUnwindSafe}; + +use crate::hash; + +use Taggy::*; +use Taggypar::*; + +#[test] +fn test_simple() { + let mut d = VecDeque::new(); + assert_eq!(d.len(), 0); + d.push_front(17); + d.push_front(42); + d.push_back(137); + assert_eq!(d.len(), 3); + d.push_back(137); + assert_eq!(d.len(), 4); + assert_eq!(*d.front().unwrap(), 42); + assert_eq!(*d.back().unwrap(), 137); + let mut i = d.pop_front(); + assert_eq!(i, Some(42)); + i = d.pop_back(); + assert_eq!(i, Some(137)); + i = d.pop_back(); + assert_eq!(i, Some(137)); + i = d.pop_back(); + assert_eq!(i, Some(17)); + assert_eq!(d.len(), 0); + d.push_back(3); + assert_eq!(d.len(), 1); + d.push_front(2); + assert_eq!(d.len(), 2); + d.push_back(4); + assert_eq!(d.len(), 3); + d.push_front(1); + assert_eq!(d.len(), 4); + assert_eq!(d[0], 1); + assert_eq!(d[1], 2); + assert_eq!(d[2], 3); + assert_eq!(d[3], 4); +} + +fn test_parameterized(a: T, b: T, c: T, d: T) { + let mut deq = VecDeque::new(); + assert_eq!(deq.len(), 0); + deq.push_front(a.clone()); + deq.push_front(b.clone()); + deq.push_back(c.clone()); + assert_eq!(deq.len(), 3); + deq.push_back(d.clone()); + assert_eq!(deq.len(), 4); + assert_eq!((*deq.front().unwrap()).clone(), b.clone()); + assert_eq!((*deq.back().unwrap()).clone(), d.clone()); + assert_eq!(deq.pop_front().unwrap(), b.clone()); + assert_eq!(deq.pop_back().unwrap(), d.clone()); + assert_eq!(deq.pop_back().unwrap(), c.clone()); + assert_eq!(deq.pop_back().unwrap(), a.clone()); + assert_eq!(deq.len(), 0); + deq.push_back(c.clone()); + assert_eq!(deq.len(), 1); + deq.push_front(b.clone()); + assert_eq!(deq.len(), 2); + deq.push_back(d.clone()); + assert_eq!(deq.len(), 3); + deq.push_front(a.clone()); + assert_eq!(deq.len(), 4); + assert_eq!(deq[0].clone(), a.clone()); + assert_eq!(deq[1].clone(), b.clone()); + assert_eq!(deq[2].clone(), c.clone()); + assert_eq!(deq[3].clone(), d.clone()); +} + +#[test] +fn test_push_front_grow() { + let mut deq = VecDeque::new(); + for i in 0..66 { + deq.push_front(i); + } + assert_eq!(deq.len(), 66); + + for i in 0..66 { + assert_eq!(deq[i], 65 - i); + } + + let mut deq = VecDeque::new(); + for i in 0..66 { + deq.push_back(i); + } + + for i in 0..66 { + assert_eq!(deq[i], i); + } +} + +#[test] +fn test_index() { + let mut deq = VecDeque::new(); + for i in 1..4 { + deq.push_front(i); + } + assert_eq!(deq[1], 2); +} + +#[test] +#[should_panic] +fn test_index_out_of_bounds() { + let mut deq = VecDeque::new(); + for i in 1..4 { + deq.push_front(i); + } + deq[3]; +} + +#[test] +#[should_panic] +fn test_range_start_overflow() { + let deq = VecDeque::from(vec![1, 2, 3]); + deq.range((Included(0), Included(usize::MAX))); +} + +#[test] +#[should_panic] +fn test_range_end_overflow() { + let deq = VecDeque::from(vec![1, 2, 3]); + deq.range((Excluded(usize::MAX), Included(0))); +} + +#[derive(Clone, PartialEq, Debug)] +enum Taggy { + One(i32), + Two(i32, i32), + Three(i32, i32, i32), +} + +#[derive(Clone, PartialEq, Debug)] +enum Taggypar { + Onepar(T), + Twopar(T, T), + Threepar(T, T, T), +} + +#[derive(Clone, PartialEq, Debug)] +struct RecCy { + x: i32, + y: i32, + t: Taggy, +} + +#[test] +fn test_param_int() { + test_parameterized::(5, 72, 64, 175); +} + +#[test] +fn test_param_taggy() { + test_parameterized::(One(1), Two(1, 2), Three(1, 2, 3), Two(17, 42)); +} + +#[test] +fn test_param_taggypar() { + test_parameterized::>( + Onepar::(1), + Twopar::(1, 2), + Threepar::(1, 2, 3), + Twopar::(17, 42), + ); +} + +#[test] +fn test_param_reccy() { + let reccy1 = RecCy { x: 1, y: 2, t: One(1) }; + let reccy2 = RecCy { x: 345, y: 2, t: Two(1, 2) }; + let reccy3 = RecCy { x: 1, y: 777, t: Three(1, 2, 3) }; + let reccy4 = RecCy { x: 19, y: 252, t: Two(17, 42) }; + test_parameterized::(reccy1, reccy2, reccy3, reccy4); +} + +#[test] +fn test_with_capacity() { + let mut d = VecDeque::with_capacity(0); + d.push_back(1); + assert_eq!(d.len(), 1); + let mut d = VecDeque::with_capacity(50); + d.push_back(1); + assert_eq!(d.len(), 1); +} + +#[test] +fn test_with_capacity_non_power_two() { + let mut d3 = VecDeque::with_capacity(3); + d3.push_back(1); + + // X = None, | = lo + // [|1, X, X] + assert_eq!(d3.pop_front(), Some(1)); + // [X, |X, X] + assert_eq!(d3.front(), None); + + // [X, |3, X] + d3.push_back(3); + // [X, |3, 6] + d3.push_back(6); + // [X, X, |6] + assert_eq!(d3.pop_front(), Some(3)); + + // Pushing the lo past half way point to trigger + // the 'B' scenario for growth + // [9, X, |6] + d3.push_back(9); + // [9, 12, |6] + d3.push_back(12); + + d3.push_back(15); + // There used to be a bug here about how the + // VecDeque made growth assumptions about the + // underlying Vec which didn't hold and lead + // to corruption. + // (Vec grows to next power of two) + // good- [9, 12, 15, X, X, X, X, |6] + // bug- [15, 12, X, X, X, |6, X, X] + assert_eq!(d3.pop_front(), Some(6)); + + // Which leads us to the following state which + // would be a failure case. + // bug- [15, 12, X, X, X, X, |X, X] + assert_eq!(d3.front(), Some(&9)); +} + +#[test] +fn test_reserve_exact() { + let mut d = VecDeque::new(); + d.push_back(0); + d.reserve_exact(50); + assert!(d.capacity() >= 51); +} + +#[test] +fn test_reserve() { + let mut d = VecDeque::new(); + d.push_back(0); + d.reserve(50); + assert!(d.capacity() >= 51); +} + +#[test] +fn test_swap() { + let mut d: VecDeque<_> = (0..5).collect(); + d.pop_front(); + d.swap(0, 3); + assert_eq!(d.iter().cloned().collect::>(), [4, 2, 3, 1]); +} + +#[test] +fn test_iter() { + let mut d = VecDeque::new(); + assert_eq!(d.iter().next(), None); + assert_eq!(d.iter().size_hint(), (0, Some(0))); + + for i in 0..5 { + d.push_back(i); + } + { + let b: &[_] = &[&0, &1, &2, &3, &4]; + assert_eq!(d.iter().collect::>(), b); + } + + for i in 6..9 { + d.push_front(i); + } + { + let b: &[_] = &[&8, &7, &6, &0, &1, &2, &3, &4]; + assert_eq!(d.iter().collect::>(), b); + } + + let mut it = d.iter(); + let mut len = d.len(); + loop { + match it.next() { + None => break, + _ => { + len -= 1; + assert_eq!(it.size_hint(), (len, Some(len))) + } + } + } +} + +#[test] +fn test_rev_iter() { + let mut d = VecDeque::new(); + assert_eq!(d.iter().rev().next(), None); + + for i in 0..5 { + d.push_back(i); + } + { + let b: &[_] = &[&4, &3, &2, &1, &0]; + assert_eq!(d.iter().rev().collect::>(), b); + } + + for i in 6..9 { + d.push_front(i); + } + let b: &[_] = &[&4, &3, &2, &1, &0, &6, &7, &8]; + assert_eq!(d.iter().rev().collect::>(), b); +} + +#[test] +fn test_mut_rev_iter_wrap() { + let mut d = VecDeque::with_capacity(3); + assert!(d.iter_mut().rev().next().is_none()); + + d.push_back(1); + d.push_back(2); + d.push_back(3); + assert_eq!(d.pop_front(), Some(1)); + d.push_back(4); + + assert_eq!(d.iter_mut().rev().map(|x| *x).collect::>(), vec![4, 3, 2]); +} + +#[test] +fn test_mut_iter() { + let mut d = VecDeque::new(); + assert!(d.iter_mut().next().is_none()); + + for i in 0..3 { + d.push_front(i); + } + + for (i, elt) in d.iter_mut().enumerate() { + assert_eq!(*elt, 2 - i); + *elt = i; + } + + { + let mut it = d.iter_mut(); + assert_eq!(*it.next().unwrap(), 0); + assert_eq!(*it.next().unwrap(), 1); + assert_eq!(*it.next().unwrap(), 2); + assert!(it.next().is_none()); + } +} + +#[test] +fn test_mut_rev_iter() { + let mut d = VecDeque::new(); + assert!(d.iter_mut().rev().next().is_none()); + + for i in 0..3 { + d.push_front(i); + } + + for (i, elt) in d.iter_mut().rev().enumerate() { + assert_eq!(*elt, i); + *elt = i; + } + + { + let mut it = d.iter_mut().rev(); + assert_eq!(*it.next().unwrap(), 0); + assert_eq!(*it.next().unwrap(), 1); + assert_eq!(*it.next().unwrap(), 2); + assert!(it.next().is_none()); + } +} + +#[test] +fn test_into_iter() { + // Empty iter + { + let d: VecDeque = VecDeque::new(); + let mut iter = d.into_iter(); + + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + assert_eq!(iter.size_hint(), (0, Some(0))); + } + + // simple iter + { + let mut d = VecDeque::new(); + for i in 0..5 { + d.push_back(i); + } + + let b = vec![0, 1, 2, 3, 4]; + assert_eq!(d.into_iter().collect::>(), b); + } + + // wrapped iter + { + let mut d = VecDeque::new(); + for i in 0..5 { + d.push_back(i); + } + for i in 6..9 { + d.push_front(i); + } + + let b = vec![8, 7, 6, 0, 1, 2, 3, 4]; + assert_eq!(d.into_iter().collect::>(), b); + } + + // partially used + { + let mut d = VecDeque::new(); + for i in 0..5 { + d.push_back(i); + } + for i in 6..9 { + d.push_front(i); + } + + let mut it = d.into_iter(); + assert_eq!(it.size_hint(), (8, Some(8))); + assert_eq!(it.next(), Some(8)); + assert_eq!(it.size_hint(), (7, Some(7))); + assert_eq!(it.next_back(), Some(4)); + assert_eq!(it.size_hint(), (6, Some(6))); + assert_eq!(it.next(), Some(7)); + assert_eq!(it.size_hint(), (5, Some(5))); + } +} + +#[test] +fn test_drain() { + // Empty iter + { + let mut d: VecDeque = VecDeque::new(); + + { + let mut iter = d.drain(..); + + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + assert_eq!(iter.size_hint(), (0, Some(0))); + } + + assert!(d.is_empty()); + } + + // simple iter + { + let mut d = VecDeque::new(); + for i in 0..5 { + d.push_back(i); + } + + assert_eq!(d.drain(..).collect::>(), [0, 1, 2, 3, 4]); + assert!(d.is_empty()); + } + + // wrapped iter + { + let mut d = VecDeque::new(); + for i in 0..5 { + d.push_back(i); + } + for i in 6..9 { + d.push_front(i); + } + + assert_eq!(d.drain(..).collect::>(), [8, 7, 6, 0, 1, 2, 3, 4]); + assert!(d.is_empty()); + } + + // partially used + { + let mut d: VecDeque<_> = VecDeque::new(); + for i in 0..5 { + d.push_back(i); + } + for i in 6..9 { + d.push_front(i); + } + + { + let mut it = d.drain(..); + assert_eq!(it.size_hint(), (8, Some(8))); + assert_eq!(it.next(), Some(8)); + assert_eq!(it.size_hint(), (7, Some(7))); + assert_eq!(it.next_back(), Some(4)); + assert_eq!(it.size_hint(), (6, Some(6))); + assert_eq!(it.next(), Some(7)); + assert_eq!(it.size_hint(), (5, Some(5))); + } + assert!(d.is_empty()); + } +} + +#[test] +fn test_from_iter() { + let v = vec![1, 2, 3, 4, 5, 6, 7]; + let deq: VecDeque<_> = v.iter().cloned().collect(); + let u: Vec<_> = deq.iter().cloned().collect(); + assert_eq!(u, v); + + let seq = (0..).step_by(2).take(256); + let deq: VecDeque<_> = seq.collect(); + for (i, &x) in deq.iter().enumerate() { + assert_eq!(2 * i, x); + } + assert_eq!(deq.len(), 256); +} + +#[test] +fn test_clone() { + let mut d = VecDeque::new(); + d.push_front(17); + d.push_front(42); + d.push_back(137); + d.push_back(137); + assert_eq!(d.len(), 4); + let mut e = d.clone(); + assert_eq!(e.len(), 4); + while !d.is_empty() { + assert_eq!(d.pop_back(), e.pop_back()); + } + assert_eq!(d.len(), 0); + assert_eq!(e.len(), 0); +} + +#[test] +fn test_eq() { + let mut d = VecDeque::new(); + assert!(d == VecDeque::with_capacity(0)); + d.push_front(137); + d.push_front(17); + d.push_front(42); + d.push_back(137); + let mut e = VecDeque::with_capacity(0); + e.push_back(42); + e.push_back(17); + e.push_back(137); + e.push_back(137); + assert!(&e == &d); + e.pop_back(); + e.push_back(0); + assert!(e != d); + e.clear(); + assert!(e == VecDeque::new()); +} + +#[test] +fn test_partial_eq_array() { + let d = VecDeque::::new(); + assert!(d == []); + + let mut d = VecDeque::new(); + d.push_front('a'); + assert!(d == ['a']); + + let mut d = VecDeque::new(); + d.push_back('a'); + assert!(d == ['a']); + + let mut d = VecDeque::new(); + d.push_back('a'); + d.push_back('b'); + assert!(d == ['a', 'b']); +} + +#[test] +fn test_hash() { + let mut x = VecDeque::new(); + let mut y = VecDeque::new(); + + x.push_back(1); + x.push_back(2); + x.push_back(3); + + y.push_back(0); + y.push_back(1); + y.pop_front(); + y.push_back(2); + y.push_back(3); + + assert!(hash(&x) == hash(&y)); +} + +#[test] +fn test_hash_after_rotation() { + // test that two deques hash equal even if elements are laid out differently + let len = 28; + let mut ring: VecDeque = (0..len as i32).collect(); + let orig = ring.clone(); + for _ in 0..ring.capacity() { + // shift values 1 step to the right by pop, sub one, push + ring.pop_front(); + for elt in &mut ring { + *elt -= 1; + } + ring.push_back(len - 1); + assert_eq!(hash(&orig), hash(&ring)); + assert_eq!(orig, ring); + assert_eq!(ring, orig); + } +} + +#[test] +fn test_eq_after_rotation() { + // test that two deques are equal even if elements are laid out differently + let len = 28; + let mut ring: VecDeque = (0..len as i32).collect(); + let mut shifted = ring.clone(); + for _ in 0..10 { + // shift values 1 step to the right by pop, sub one, push + ring.pop_front(); + for elt in &mut ring { + *elt -= 1; + } + ring.push_back(len - 1); + } + + // try every shift + for _ in 0..shifted.capacity() { + shifted.pop_front(); + for elt in &mut shifted { + *elt -= 1; + } + shifted.push_back(len - 1); + assert_eq!(shifted, ring); + assert_eq!(ring, shifted); + } +} + +#[test] +fn test_ord() { + let x = VecDeque::new(); + let mut y = VecDeque::new(); + y.push_back(1); + y.push_back(2); + y.push_back(3); + assert!(x < y); + assert!(y > x); + assert!(x <= x); + assert!(x >= x); +} + +#[test] +fn test_show() { + let ringbuf: VecDeque<_> = (0..10).collect(); + assert_eq!(format!("{:?}", ringbuf), "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"); + + let ringbuf: VecDeque<_> = vec!["just", "one", "test", "more"].iter().cloned().collect(); + assert_eq!(format!("{:?}", ringbuf), "[\"just\", \"one\", \"test\", \"more\"]"); +} + +#[test] +fn test_drop() { + static mut DROPS: i32 = 0; + struct Elem; + impl Drop for Elem { + fn drop(&mut self) { + unsafe { + DROPS += 1; + } + } + } + + let mut ring = VecDeque::new(); + ring.push_back(Elem); + ring.push_front(Elem); + ring.push_back(Elem); + ring.push_front(Elem); + drop(ring); + + assert_eq!(unsafe { DROPS }, 4); +} + +#[test] +fn test_drop_with_pop() { + static mut DROPS: i32 = 0; + struct Elem; + impl Drop for Elem { + fn drop(&mut self) { + unsafe { + DROPS += 1; + } + } + } + + let mut ring = VecDeque::new(); + ring.push_back(Elem); + ring.push_front(Elem); + ring.push_back(Elem); + ring.push_front(Elem); + + drop(ring.pop_back()); + drop(ring.pop_front()); + assert_eq!(unsafe { DROPS }, 2); + + drop(ring); + assert_eq!(unsafe { DROPS }, 4); +} + +#[test] +fn test_drop_clear() { + static mut DROPS: i32 = 0; + struct Elem; + impl Drop for Elem { + fn drop(&mut self) { + unsafe { + DROPS += 1; + } + } + } + + let mut ring = VecDeque::new(); + ring.push_back(Elem); + ring.push_front(Elem); + ring.push_back(Elem); + ring.push_front(Elem); + ring.clear(); + assert_eq!(unsafe { DROPS }, 4); + + drop(ring); + assert_eq!(unsafe { DROPS }, 4); +} + +#[test] +fn test_drop_panic() { + static mut DROPS: i32 = 0; + + struct D(bool); + + impl Drop for D { + fn drop(&mut self) { + unsafe { + DROPS += 1; + } + + if self.0 { + panic!("panic in `drop`"); + } + } + } + + let mut q = VecDeque::new(); + q.push_back(D(false)); + q.push_back(D(false)); + q.push_back(D(false)); + q.push_back(D(false)); + q.push_back(D(false)); + q.push_front(D(false)); + q.push_front(D(false)); + q.push_front(D(true)); + + catch_unwind(move || drop(q)).ok(); + + assert_eq!(unsafe { DROPS }, 8); +} + +#[test] +fn test_reserve_grow() { + // test growth path A + // [T o o H] -> [T o o H . . . . ] + let mut ring = VecDeque::with_capacity(4); + for i in 0..3 { + ring.push_back(i); + } + ring.reserve(7); + for i in 0..3 { + assert_eq!(ring.pop_front(), Some(i)); + } + + // test growth path B + // [H T o o] -> [. T o o H . . . ] + let mut ring = VecDeque::with_capacity(4); + for i in 0..1 { + ring.push_back(i); + assert_eq!(ring.pop_front(), Some(i)); + } + for i in 0..3 { + ring.push_back(i); + } + ring.reserve(7); + for i in 0..3 { + assert_eq!(ring.pop_front(), Some(i)); + } + + // test growth path C + // [o o H T] -> [o o H . . . . T ] + let mut ring = VecDeque::with_capacity(4); + for i in 0..3 { + ring.push_back(i); + assert_eq!(ring.pop_front(), Some(i)); + } + for i in 0..3 { + ring.push_back(i); + } + ring.reserve(7); + for i in 0..3 { + assert_eq!(ring.pop_front(), Some(i)); + } +} + +#[test] +fn test_get() { + let mut ring = VecDeque::new(); + ring.push_back(0); + assert_eq!(ring.get(0), Some(&0)); + assert_eq!(ring.get(1), None); + + ring.push_back(1); + assert_eq!(ring.get(0), Some(&0)); + assert_eq!(ring.get(1), Some(&1)); + assert_eq!(ring.get(2), None); + + ring.push_back(2); + assert_eq!(ring.get(0), Some(&0)); + assert_eq!(ring.get(1), Some(&1)); + assert_eq!(ring.get(2), Some(&2)); + assert_eq!(ring.get(3), None); + + assert_eq!(ring.pop_front(), Some(0)); + assert_eq!(ring.get(0), Some(&1)); + assert_eq!(ring.get(1), Some(&2)); + assert_eq!(ring.get(2), None); + + assert_eq!(ring.pop_front(), Some(1)); + assert_eq!(ring.get(0), Some(&2)); + assert_eq!(ring.get(1), None); + + assert_eq!(ring.pop_front(), Some(2)); + assert_eq!(ring.get(0), None); + assert_eq!(ring.get(1), None); +} + +#[test] +fn test_get_mut() { + let mut ring = VecDeque::new(); + for i in 0..3 { + ring.push_back(i); + } + + match ring.get_mut(1) { + Some(x) => *x = -1, + None => (), + }; + + assert_eq!(ring.get_mut(0), Some(&mut 0)); + assert_eq!(ring.get_mut(1), Some(&mut -1)); + assert_eq!(ring.get_mut(2), Some(&mut 2)); + assert_eq!(ring.get_mut(3), None); + + assert_eq!(ring.pop_front(), Some(0)); + assert_eq!(ring.get_mut(0), Some(&mut -1)); + assert_eq!(ring.get_mut(1), Some(&mut 2)); + assert_eq!(ring.get_mut(2), None); +} + +#[test] +fn test_front() { + let mut ring = VecDeque::new(); + ring.push_back(10); + ring.push_back(20); + assert_eq!(ring.front(), Some(&10)); + ring.pop_front(); + assert_eq!(ring.front(), Some(&20)); + ring.pop_front(); + assert_eq!(ring.front(), None); +} + +#[test] +fn test_as_slices() { + let mut ring: VecDeque = VecDeque::with_capacity(127); + let cap = ring.capacity() as i32; + let first = cap / 2; + let last = cap - first; + for i in 0..first { + ring.push_back(i); + + let (left, right) = ring.as_slices(); + let expected: Vec<_> = (0..=i).collect(); + assert_eq!(left, &expected[..]); + assert_eq!(right, []); + } + + for j in -last..0 { + ring.push_front(j); + let (left, right) = ring.as_slices(); + let expected_left: Vec<_> = (-last..=j).rev().collect(); + let expected_right: Vec<_> = (0..first).collect(); + assert_eq!(left, &expected_left[..]); + assert_eq!(right, &expected_right[..]); + } + + assert_eq!(ring.len() as i32, cap); + assert_eq!(ring.capacity() as i32, cap); +} + +#[test] +fn test_as_mut_slices() { + let mut ring: VecDeque = VecDeque::with_capacity(127); + let cap = ring.capacity() as i32; + let first = cap / 2; + let last = cap - first; + for i in 0..first { + ring.push_back(i); + + let (left, right) = ring.as_mut_slices(); + let expected: Vec<_> = (0..=i).collect(); + assert_eq!(left, &expected[..]); + assert_eq!(right, []); + } + + for j in -last..0 { + ring.push_front(j); + let (left, right) = ring.as_mut_slices(); + let expected_left: Vec<_> = (-last..=j).rev().collect(); + let expected_right: Vec<_> = (0..first).collect(); + assert_eq!(left, &expected_left[..]); + assert_eq!(right, &expected_right[..]); + } + + assert_eq!(ring.len() as i32, cap); + assert_eq!(ring.capacity() as i32, cap); +} + +#[test] +fn test_append() { + let mut a: VecDeque<_> = vec![1, 2, 3].into_iter().collect(); + let mut b: VecDeque<_> = vec![4, 5, 6].into_iter().collect(); + + // normal append + a.append(&mut b); + assert_eq!(a.iter().cloned().collect::>(), [1, 2, 3, 4, 5, 6]); + assert_eq!(b.iter().cloned().collect::>(), []); + + // append nothing to something + a.append(&mut b); + assert_eq!(a.iter().cloned().collect::>(), [1, 2, 3, 4, 5, 6]); + assert_eq!(b.iter().cloned().collect::>(), []); + + // append something to nothing + b.append(&mut a); + assert_eq!(b.iter().cloned().collect::>(), [1, 2, 3, 4, 5, 6]); + assert_eq!(a.iter().cloned().collect::>(), []); +} + +#[test] +fn test_append_permutations() { + fn construct_vec_deque( + push_back: usize, + pop_back: usize, + push_front: usize, + pop_front: usize, + ) -> VecDeque { + let mut out = VecDeque::new(); + for a in 0..push_back { + out.push_back(a); + } + for b in 0..push_front { + out.push_front(push_back + b); + } + for _ in 0..pop_back { + out.pop_back(); + } + for _ in 0..pop_front { + out.pop_front(); + } + out + } + + // Miri is too slow + let max = if cfg!(miri) { 3 } else { 5 }; + + // Many different permutations of both the `VecDeque` getting appended to + // and the one getting appended are generated to check `append`. + // This ensures all 6 code paths of `append` are tested. + for src_push_back in 0..max { + for src_push_front in 0..max { + // doesn't pop more values than are pushed + for src_pop_back in 0..(src_push_back + src_push_front) { + for src_pop_front in 0..(src_push_back + src_push_front - src_pop_back) { + let src = construct_vec_deque( + src_push_back, + src_pop_back, + src_push_front, + src_pop_front, + ); + + for dst_push_back in 0..max { + for dst_push_front in 0..max { + for dst_pop_back in 0..(dst_push_back + dst_push_front) { + for dst_pop_front in + 0..(dst_push_back + dst_push_front - dst_pop_back) + { + let mut dst = construct_vec_deque( + dst_push_back, + dst_pop_back, + dst_push_front, + dst_pop_front, + ); + let mut src = src.clone(); + + // Assert that appending `src` to `dst` gives the same order + // of values as iterating over both in sequence. + let correct = dst + .iter() + .chain(src.iter()) + .cloned() + .collect::>(); + dst.append(&mut src); + assert_eq!(dst, correct); + assert!(src.is_empty()); + } + } + } + } + } + } + } + } +} + +struct DropCounter<'a> { + count: &'a mut u32, +} + +impl Drop for DropCounter<'_> { + fn drop(&mut self) { + *self.count += 1; + } +} + +#[test] +fn test_append_double_drop() { + let (mut count_a, mut count_b) = (0, 0); + { + let mut a = VecDeque::new(); + let mut b = VecDeque::new(); + a.push_back(DropCounter { count: &mut count_a }); + b.push_back(DropCounter { count: &mut count_b }); + + a.append(&mut b); + } + assert_eq!(count_a, 1); + assert_eq!(count_b, 1); +} + +#[test] +fn test_retain() { + let mut buf = VecDeque::new(); + buf.extend(1..5); + buf.retain(|&x| x % 2 == 0); + let v: Vec<_> = buf.into_iter().collect(); + assert_eq!(&v[..], &[2, 4]); +} + +#[test] +fn test_extend_ref() { + let mut v = VecDeque::new(); + v.push_back(1); + v.extend(&[2, 3, 4]); + + assert_eq!(v.len(), 4); + assert_eq!(v[0], 1); + assert_eq!(v[1], 2); + assert_eq!(v[2], 3); + assert_eq!(v[3], 4); + + let mut w = VecDeque::new(); + w.push_back(5); + w.push_back(6); + v.extend(&w); + + assert_eq!(v.len(), 6); + assert_eq!(v[0], 1); + assert_eq!(v[1], 2); + assert_eq!(v[2], 3); + assert_eq!(v[3], 4); + assert_eq!(v[4], 5); + assert_eq!(v[5], 6); +} + +#[test] +fn test_contains() { + let mut v = VecDeque::new(); + v.extend(&[2, 3, 4]); + + assert!(v.contains(&3)); + assert!(!v.contains(&1)); + + v.clear(); + + assert!(!v.contains(&3)); +} + +#[allow(dead_code)] +fn assert_covariance() { + fn drain<'new>(d: Drain<'static, &'static str>) -> Drain<'new, &'new str> { + d + } +} + +#[test] +fn test_is_empty() { + let mut v = VecDeque::::new(); + assert!(v.is_empty()); + assert!(v.iter().is_empty()); + assert!(v.iter_mut().is_empty()); + v.extend(&[2, 3, 4]); + assert!(!v.is_empty()); + assert!(!v.iter().is_empty()); + assert!(!v.iter_mut().is_empty()); + while let Some(_) = v.pop_front() { + assert_eq!(v.is_empty(), v.len() == 0); + assert_eq!(v.iter().is_empty(), v.iter().len() == 0); + assert_eq!(v.iter_mut().is_empty(), v.iter_mut().len() == 0); + } + assert!(v.is_empty()); + assert!(v.iter().is_empty()); + assert!(v.iter_mut().is_empty()); + assert!(v.into_iter().is_empty()); +} + +#[test] +fn test_reserve_exact_2() { + // This is all the same as test_reserve + + let mut v = VecDeque::new(); + + v.reserve_exact(2); + assert!(v.capacity() >= 2); + + for i in 0..16 { + v.push_back(i); + } + + assert!(v.capacity() >= 16); + v.reserve_exact(16); + assert!(v.capacity() >= 32); + + v.push_back(16); + + v.reserve_exact(16); + assert!(v.capacity() >= 48) +} + +#[test] +#[cfg_attr(miri, ignore)] // Miri does not support signalling OOM +#[cfg_attr(target_os = "android", ignore)] // Android used in CI has a broken dlmalloc +fn test_try_reserve() { + // These are the interesting cases: + // * exactly isize::MAX should never trigger a CapacityOverflow (can be OOM) + // * > isize::MAX should always fail + // * On 16/32-bit should CapacityOverflow + // * On 64-bit should OOM + // * overflow may trigger when adding `len` to `cap` (in number of elements) + // * overflow may trigger when multiplying `new_cap` by size_of:: (to get bytes) + + const MAX_CAP: usize = (isize::MAX as usize + 1) / 2 - 1; + const MAX_USIZE: usize = usize::MAX; + + // On 16/32-bit, we check that allocations don't exceed isize::MAX, + // on 64-bit, we assume the OS will give an OOM for such a ridiculous size. + // Any platform that succeeds for these requests is technically broken with + // ptr::offset because LLVM is the worst. + let guards_against_isize = size_of::() < 8; + + { + // Note: basic stuff is checked by test_reserve + let mut empty_bytes: VecDeque = VecDeque::new(); + + // Check isize::MAX doesn't count as an overflow + if let Err(CapacityOverflow) = empty_bytes.try_reserve(MAX_CAP) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + // Play it again, frank! (just to be sure) + if let Err(CapacityOverflow) = empty_bytes.try_reserve(MAX_CAP) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + + if guards_against_isize { + // Check isize::MAX + 1 does count as overflow + if let Err(CapacityOverflow) = empty_bytes.try_reserve(MAX_CAP + 1) { + } else { + panic!("isize::MAX + 1 should trigger an overflow!") + } + + // Check usize::MAX does count as overflow + if let Err(CapacityOverflow) = empty_bytes.try_reserve(MAX_USIZE) { + } else { + panic!("usize::MAX should trigger an overflow!") + } + } else { + // Check isize::MAX is an OOM + // VecDeque starts with capacity 7, always adds 1 to the capacity + // and also rounds the number to next power of 2 so this is the + // furthest we can go without triggering CapacityOverflow + if let Err(AllocError { .. }) = empty_bytes.try_reserve(MAX_CAP) { + } else { + panic!("isize::MAX + 1 should trigger an OOM!") + } + } + } + + { + // Same basic idea, but with non-zero len + let mut ten_bytes: VecDeque = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10].into_iter().collect(); + + if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_CAP - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_CAP - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if guards_against_isize { + if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_CAP - 9) { + } else { + panic!("isize::MAX + 1 should trigger an overflow!"); + } + } else { + if let Err(AllocError { .. }) = ten_bytes.try_reserve(MAX_CAP - 9) { + } else { + panic!("isize::MAX + 1 should trigger an OOM!") + } + } + // Should always overflow in the add-to-len + if let Err(CapacityOverflow) = ten_bytes.try_reserve(MAX_USIZE) { + } else { + panic!("usize::MAX should trigger an overflow!") + } + } + + { + // Same basic idea, but with interesting type size + let mut ten_u32s: VecDeque = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10].into_iter().collect(); + + if let Err(CapacityOverflow) = ten_u32s.try_reserve(MAX_CAP / 4 - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if let Err(CapacityOverflow) = ten_u32s.try_reserve(MAX_CAP / 4 - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if guards_against_isize { + if let Err(CapacityOverflow) = ten_u32s.try_reserve(MAX_CAP / 4 - 9) { + } else { + panic!("isize::MAX + 1 should trigger an overflow!"); + } + } else { + if let Err(AllocError { .. }) = ten_u32s.try_reserve(MAX_CAP / 4 - 9) { + } else { + panic!("isize::MAX + 1 should trigger an OOM!") + } + } + // Should fail in the mul-by-size + if let Err(CapacityOverflow) = ten_u32s.try_reserve(MAX_USIZE - 20) { + } else { + panic!("usize::MAX should trigger an overflow!"); + } + } +} + +#[test] +#[cfg_attr(miri, ignore)] // Miri does not support signalling OOM +#[cfg_attr(target_os = "android", ignore)] // Android used in CI has a broken dlmalloc +fn test_try_reserve_exact() { + // This is exactly the same as test_try_reserve with the method changed. + // See that test for comments. + + const MAX_CAP: usize = (isize::MAX as usize + 1) / 2 - 1; + const MAX_USIZE: usize = usize::MAX; + + let guards_against_isize = size_of::() < 8; + + { + let mut empty_bytes: VecDeque = VecDeque::new(); + + if let Err(CapacityOverflow) = empty_bytes.try_reserve_exact(MAX_CAP) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if let Err(CapacityOverflow) = empty_bytes.try_reserve_exact(MAX_CAP) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + + if guards_against_isize { + if let Err(CapacityOverflow) = empty_bytes.try_reserve_exact(MAX_CAP + 1) { + } else { + panic!("isize::MAX + 1 should trigger an overflow!") + } + + if let Err(CapacityOverflow) = empty_bytes.try_reserve_exact(MAX_USIZE) { + } else { + panic!("usize::MAX should trigger an overflow!") + } + } else { + // Check isize::MAX is an OOM + // VecDeque starts with capacity 7, always adds 1 to the capacity + // and also rounds the number to next power of 2 so this is the + // furthest we can go without triggering CapacityOverflow + if let Err(AllocError { .. }) = empty_bytes.try_reserve_exact(MAX_CAP) { + } else { + panic!("isize::MAX + 1 should trigger an OOM!") + } + } + } + + { + let mut ten_bytes: VecDeque = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10].into_iter().collect(); + + if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_CAP - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_CAP - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if guards_against_isize { + if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_CAP - 9) { + } else { + panic!("isize::MAX + 1 should trigger an overflow!"); + } + } else { + if let Err(AllocError { .. }) = ten_bytes.try_reserve_exact(MAX_CAP - 9) { + } else { + panic!("isize::MAX + 1 should trigger an OOM!") + } + } + if let Err(CapacityOverflow) = ten_bytes.try_reserve_exact(MAX_USIZE) { + } else { + panic!("usize::MAX should trigger an overflow!") + } + } + + { + let mut ten_u32s: VecDeque = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10].into_iter().collect(); + + if let Err(CapacityOverflow) = ten_u32s.try_reserve_exact(MAX_CAP / 4 - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if let Err(CapacityOverflow) = ten_u32s.try_reserve_exact(MAX_CAP / 4 - 10) { + panic!("isize::MAX shouldn't trigger an overflow!"); + } + if guards_against_isize { + if let Err(CapacityOverflow) = ten_u32s.try_reserve_exact(MAX_CAP / 4 - 9) { + } else { + panic!("isize::MAX + 1 should trigger an overflow!"); + } + } else { + if let Err(AllocError { .. }) = ten_u32s.try_reserve_exact(MAX_CAP / 4 - 9) { + } else { + panic!("isize::MAX + 1 should trigger an OOM!") + } + } + if let Err(CapacityOverflow) = ten_u32s.try_reserve_exact(MAX_USIZE - 20) { + } else { + panic!("usize::MAX should trigger an overflow!") + } + } +} + +#[test] +fn test_rotate_nop() { + let mut v: VecDeque<_> = (0..10).collect(); + assert_unchanged(&v); + + v.rotate_left(0); + assert_unchanged(&v); + + v.rotate_left(10); + assert_unchanged(&v); + + v.rotate_right(0); + assert_unchanged(&v); + + v.rotate_right(10); + assert_unchanged(&v); + + v.rotate_left(3); + v.rotate_right(3); + assert_unchanged(&v); + + v.rotate_right(3); + v.rotate_left(3); + assert_unchanged(&v); + + v.rotate_left(6); + v.rotate_right(6); + assert_unchanged(&v); + + v.rotate_right(6); + v.rotate_left(6); + assert_unchanged(&v); + + v.rotate_left(3); + v.rotate_left(7); + assert_unchanged(&v); + + v.rotate_right(4); + v.rotate_right(6); + assert_unchanged(&v); + + v.rotate_left(1); + v.rotate_left(2); + v.rotate_left(3); + v.rotate_left(4); + assert_unchanged(&v); + + v.rotate_right(1); + v.rotate_right(2); + v.rotate_right(3); + v.rotate_right(4); + assert_unchanged(&v); + + fn assert_unchanged(v: &VecDeque) { + assert_eq!(v, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); + } +} + +#[test] +fn test_rotate_left_parts() { + let mut v: VecDeque<_> = (1..=7).collect(); + v.rotate_left(2); + assert_eq!(v.as_slices(), (&[3, 4, 5, 6, 7, 1][..], &[2][..])); + v.rotate_left(2); + assert_eq!(v.as_slices(), (&[5, 6, 7, 1][..], &[2, 3, 4][..])); + v.rotate_left(2); + assert_eq!(v.as_slices(), (&[7, 1][..], &[2, 3, 4, 5, 6][..])); + v.rotate_left(2); + assert_eq!(v.as_slices(), (&[2, 3, 4, 5, 6, 7, 1][..], &[][..])); + v.rotate_left(2); + assert_eq!(v.as_slices(), (&[4, 5, 6, 7, 1, 2][..], &[3][..])); + v.rotate_left(2); + assert_eq!(v.as_slices(), (&[6, 7, 1, 2][..], &[3, 4, 5][..])); + v.rotate_left(2); + assert_eq!(v.as_slices(), (&[1, 2][..], &[3, 4, 5, 6, 7][..])); +} + +#[test] +fn test_rotate_right_parts() { + let mut v: VecDeque<_> = (1..=7).collect(); + v.rotate_right(2); + assert_eq!(v.as_slices(), (&[6, 7][..], &[1, 2, 3, 4, 5][..])); + v.rotate_right(2); + assert_eq!(v.as_slices(), (&[4, 5, 6, 7][..], &[1, 2, 3][..])); + v.rotate_right(2); + assert_eq!(v.as_slices(), (&[2, 3, 4, 5, 6, 7][..], &[1][..])); + v.rotate_right(2); + assert_eq!(v.as_slices(), (&[7, 1, 2, 3, 4, 5, 6][..], &[][..])); + v.rotate_right(2); + assert_eq!(v.as_slices(), (&[5, 6][..], &[7, 1, 2, 3, 4][..])); + v.rotate_right(2); + assert_eq!(v.as_slices(), (&[3, 4, 5, 6][..], &[7, 1, 2][..])); + v.rotate_right(2); + assert_eq!(v.as_slices(), (&[1, 2, 3, 4, 5, 6][..], &[7][..])); +} + +#[test] +fn test_rotate_left_random() { + let shifts = [ + 6, 1, 0, 11, 12, 1, 11, 7, 9, 3, 6, 1, 4, 0, 5, 1, 3, 1, 12, 8, 3, 1, 11, 11, 9, 4, 12, 3, + 12, 9, 11, 1, 7, 9, 7, 2, + ]; + let n = 12; + let mut v: VecDeque<_> = (0..n).collect(); + let mut total_shift = 0; + for shift in shifts.iter().cloned() { + v.rotate_left(shift); + total_shift += shift; + for i in 0..n { + assert_eq!(v[i], (i + total_shift) % n); + } + } +} + +#[test] +fn test_rotate_right_random() { + let shifts = [ + 6, 1, 0, 11, 12, 1, 11, 7, 9, 3, 6, 1, 4, 0, 5, 1, 3, 1, 12, 8, 3, 1, 11, 11, 9, 4, 12, 3, + 12, 9, 11, 1, 7, 9, 7, 2, + ]; + let n = 12; + let mut v: VecDeque<_> = (0..n).collect(); + let mut total_shift = 0; + for shift in shifts.iter().cloned() { + v.rotate_right(shift); + total_shift += shift; + for i in 0..n { + assert_eq!(v[(i + total_shift) % n], i); + } + } +} + +#[test] +fn test_try_fold_empty() { + assert_eq!(Some(0), VecDeque::::new().iter().try_fold(0, |_, _| None)); +} + +#[test] +fn test_try_fold_none() { + let v: VecDeque = (0..12).collect(); + assert_eq!(None, v.into_iter().try_fold(0, |a, b| if b < 11 { Some(a + b) } else { None })); +} + +#[test] +fn test_try_fold_ok() { + let v: VecDeque = (0..12).collect(); + assert_eq!(Ok::<_, ()>(66), v.into_iter().try_fold(0, |a, b| Ok(a + b))); +} + +#[test] +fn test_try_fold_unit() { + let v: VecDeque<()> = std::iter::repeat(()).take(42).collect(); + assert_eq!(Some(()), v.into_iter().try_fold((), |(), ()| Some(()))); +} + +#[test] +fn test_try_fold_unit_none() { + let v: std::collections::VecDeque<()> = [(); 10].iter().cloned().collect(); + let mut iter = v.into_iter(); + assert!(iter.try_fold((), |_, _| None).is_none()); + assert_eq!(iter.len(), 9); +} + +#[test] +fn test_try_fold_rotated() { + let mut v: VecDeque<_> = (0..12).collect(); + for n in 0..10 { + if n & 1 == 0 { + v.rotate_left(n); + } else { + v.rotate_right(n); + } + assert_eq!(Ok::<_, ()>(66), v.iter().try_fold(0, |a, b| Ok(a + b))); + } +} + +#[test] +fn test_try_fold_moves_iter() { + let v: VecDeque<_> = [10, 20, 30, 40, 100, 60, 70, 80, 90].iter().collect(); + let mut iter = v.into_iter(); + assert_eq!(iter.try_fold(0_i8, |acc, &x| acc.checked_add(x)), None); + assert_eq!(iter.next(), Some(&60)); +} + +#[test] +fn test_try_fold_exhaust_wrap() { + let mut v = VecDeque::with_capacity(7); + v.push_back(1); + v.push_back(1); + v.push_back(1); + v.pop_front(); + v.pop_front(); + let mut iter = v.iter(); + let _ = iter.try_fold(0, |_, _| Some(1)); + assert!(iter.is_empty()); +} + +#[test] +fn test_try_fold_wraparound() { + let mut v = VecDeque::with_capacity(8); + v.push_back(7); + v.push_back(8); + v.push_back(9); + v.push_front(2); + v.push_front(1); + let mut iter = v.iter(); + let _ = iter.find(|&&x| x == 2); + assert_eq!(Some(&7), iter.next()); +} + +#[test] +fn test_try_rfold_rotated() { + let mut v: VecDeque<_> = (0..12).collect(); + for n in 0..10 { + if n & 1 == 0 { + v.rotate_left(n); + } else { + v.rotate_right(n); + } + assert_eq!(Ok::<_, ()>(66), v.iter().try_rfold(0, |a, b| Ok(a + b))); + } +} + +#[test] +fn test_try_rfold_moves_iter() { + let v: VecDeque<_> = [10, 20, 30, 40, 100, 60, 70, 80, 90].iter().collect(); + let mut iter = v.into_iter(); + assert_eq!(iter.try_rfold(0_i8, |acc, &x| acc.checked_add(x)), None); + assert_eq!(iter.next_back(), Some(&70)); +} + +#[test] +fn truncate_leak() { + static mut DROPS: i32 = 0; + + struct D(bool); + + impl Drop for D { + fn drop(&mut self) { + unsafe { + DROPS += 1; + } + + if self.0 { + panic!("panic in `drop`"); + } + } + } + + let mut q = VecDeque::new(); + q.push_back(D(false)); + q.push_back(D(false)); + q.push_back(D(false)); + q.push_back(D(false)); + q.push_back(D(false)); + q.push_front(D(true)); + q.push_front(D(false)); + q.push_front(D(false)); + + catch_unwind(AssertUnwindSafe(|| q.truncate(1))).ok(); + + assert_eq!(unsafe { DROPS }, 7); +} + +#[test] +fn test_drain_leak() { + static mut DROPS: i32 = 0; + + #[derive(Debug, PartialEq)] + struct D(u32, bool); + + impl Drop for D { + fn drop(&mut self) { + unsafe { + DROPS += 1; + } + + if self.1 { + panic!("panic in `drop`"); + } + } + } + + let mut v = VecDeque::new(); + v.push_back(D(4, false)); + v.push_back(D(5, false)); + v.push_back(D(6, false)); + v.push_front(D(3, false)); + v.push_front(D(2, true)); + v.push_front(D(1, false)); + v.push_front(D(0, false)); + + catch_unwind(AssertUnwindSafe(|| { + v.drain(1..=4); + })) + .ok(); + + assert_eq!(unsafe { DROPS }, 4); + assert_eq!(v.len(), 3); + drop(v); + assert_eq!(unsafe { DROPS }, 7); +} + +#[test] +fn test_binary_search() { + // Contiguous (front only) search: + let deque: VecDeque<_> = vec![1, 2, 3, 5, 6].into(); + assert!(deque.as_slices().1.is_empty()); + assert_eq!(deque.binary_search(&3), Ok(2)); + assert_eq!(deque.binary_search(&4), Err(3)); + + // Split search (both front & back non-empty): + let mut deque: VecDeque<_> = vec![5, 6].into(); + deque.push_front(3); + deque.push_front(2); + deque.push_front(1); + deque.push_back(10); + assert!(!deque.as_slices().0.is_empty()); + assert!(!deque.as_slices().1.is_empty()); + assert_eq!(deque.binary_search(&0), Err(0)); + assert_eq!(deque.binary_search(&1), Ok(0)); + assert_eq!(deque.binary_search(&5), Ok(3)); + assert_eq!(deque.binary_search(&7), Err(5)); + assert_eq!(deque.binary_search(&20), Err(6)); +} + +#[test] +fn test_binary_search_by() { + let deque: VecDeque<_> = vec![(1,), (2,), (3,), (5,), (6,)].into(); + + assert_eq!(deque.binary_search_by(|&(v,)| v.cmp(&3)), Ok(2)); + assert_eq!(deque.binary_search_by(|&(v,)| v.cmp(&4)), Err(3)); +} + +#[test] +fn test_binary_search_by_key() { + let deque: VecDeque<_> = vec![(1,), (2,), (3,), (5,), (6,)].into(); + + assert_eq!(deque.binary_search_by_key(&3, |&(v,)| v), Ok(2)); + assert_eq!(deque.binary_search_by_key(&4, |&(v,)| v), Err(3)); +} + +#[test] +fn test_zero_sized_push() { + const N: usize = 8; + + // Zero sized type + struct Zst; + + // Test that for all possible sequences of push_front / push_back, + // we end up with a deque of the correct size + + for len in 0..N { + let mut tester = VecDeque::with_capacity(len); + assert_eq!(tester.len(), 0); + assert!(tester.capacity() >= len); + for case in 0..(1 << len) { + assert_eq!(tester.len(), 0); + for bit in 0..len { + if case & (1 << bit) != 0 { + tester.push_front(Zst); + } else { + tester.push_back(Zst); + } + } + assert_eq!(tester.len(), len); + assert_eq!(tester.iter().count(), len); + tester.clear(); + } + } +} diff --git a/libgrust/rustc-lib/version-info b/libgrust/rustc-lib/version-info index 696ca2dbe799..f1f9e9861317 100644 --- a/libgrust/rustc-lib/version-info +++ b/libgrust/rustc-lib/version-info @@ -1 +1,2 @@ LIBCORE_TAG=1.49.0 +LIBALLOC_TAG=1.49.0 From ac8cf5a80da8060046f9adc20338394bab47c415 Mon Sep 17 00:00:00 2001 From: Enes Cevik Date: Wed, 8 Jul 2026 15:19:36 +0300 Subject: [PATCH 053/584] gccrs: testsuite: Add the alloc crate to the testsuite This patch adds the alloc to the testsuite with some temporary modifications: - Comment out unsupported features in lib.rs. - Comment out the `ForceResult` enum due to issue Rust-GCC/gccrs#4687 in collections/btree/node.rs. gcc/testsuite/ChangeLog: * rust/alloc/alloc.exp: New test. * rust/alloc/alloc/src/alloc.rs: New test. * rust/alloc/alloc/src/alloc/tests.rs: New test. * rust/alloc/alloc/src/borrow.rs: New test. * rust/alloc/alloc/src/boxed.rs: New test. * rust/alloc/alloc/src/collections/binary_heap.rs: New test. * rust/alloc/alloc/src/collections/btree/append.rs: New test. * rust/alloc/alloc/src/collections/btree/borrow.rs: New test. * rust/alloc/alloc/src/collections/btree/borrow/tests.rs: New test. * rust/alloc/alloc/src/collections/btree/map.rs: New test. * rust/alloc/alloc/src/collections/btree/map/entry.rs: New test. * rust/alloc/alloc/src/collections/btree/map/tests.rs: New test. * rust/alloc/alloc/src/collections/btree/mem.rs: New test. * rust/alloc/alloc/src/collections/btree/merge_iter.rs: New test. * rust/alloc/alloc/src/collections/btree/mod.rs: New test. * rust/alloc/alloc/src/collections/btree/navigate.rs: New test. * rust/alloc/alloc/src/collections/btree/node.rs: New test. * rust/alloc/alloc/src/collections/btree/node/tests.rs: New test. * rust/alloc/alloc/src/collections/btree/remove.rs: New test. * rust/alloc/alloc/src/collections/btree/search.rs: New test. * rust/alloc/alloc/src/collections/btree/set.rs: New test. * rust/alloc/alloc/src/collections/btree/set/tests.rs: New test. * rust/alloc/alloc/src/collections/btree/split.rs: New test. * rust/alloc/alloc/src/collections/linked_list.rs: New test. * rust/alloc/alloc/src/collections/linked_list/tests.rs: New test. * rust/alloc/alloc/src/collections/mod.rs: New test. * rust/alloc/alloc/src/collections/vec_deque.rs: New test. * rust/alloc/alloc/src/collections/vec_deque/drain.rs: New test. * rust/alloc/alloc/src/collections/vec_deque/tests.rs: New test. * rust/alloc/alloc/src/fmt.rs: New test. * rust/alloc/alloc/src/lib.rs: New test. * rust/alloc/alloc/src/macros.rs: New test. * rust/alloc/alloc/src/prelude/mod.rs: New test. * rust/alloc/alloc/src/prelude/v1.rs: New test. * rust/alloc/alloc/src/raw_vec.rs: New test. * rust/alloc/alloc/src/raw_vec/tests.rs: New test. * rust/alloc/alloc/src/rc.rs: New test. * rust/alloc/alloc/src/rc/tests.rs: New test. * rust/alloc/alloc/src/slice.rs: New test. * rust/alloc/alloc/src/str.rs: New test. * rust/alloc/alloc/src/string.rs: New test. * rust/alloc/alloc/src/sync.rs: New test. * rust/alloc/alloc/src/sync/tests.rs: New test. * rust/alloc/alloc/src/task.rs: New test. * rust/alloc/alloc/src/tests.rs: New test. * rust/alloc/alloc/src/vec.rs: New test. * rust/alloc/core.rs: New test. * rust/alloc/prelude.rs: New test. Signed-off-by: Enes Cevik --- gcc/testsuite/rust/alloc/alloc.exp | 47 + gcc/testsuite/rust/alloc/alloc/src/alloc.rs | 418 ++ .../rust/alloc/alloc/src/alloc/tests.rs | 30 + gcc/testsuite/rust/alloc/alloc/src/borrow.rs | 480 +++ gcc/testsuite/rust/alloc/alloc/src/boxed.rs | 1435 +++++++ .../alloc/src/collections/binary_heap.rs | 1486 +++++++ .../alloc/src/collections/btree/append.rs | 126 + .../alloc/src/collections/btree/borrow.rs | 49 + .../src/collections/btree/borrow/tests.rs | 19 + .../alloc/alloc/src/collections/btree/map.rs | 2147 ++++++++++ .../alloc/src/collections/btree/map/entry.rs | 477 +++ .../alloc/src/collections/btree/map/tests.rs | 1884 +++++++++ .../alloc/alloc/src/collections/btree/mem.rs | 36 + .../alloc/src/collections/btree/merge_iter.rs | 100 + .../alloc/alloc/src/collections/btree/mod.rs | 71 + .../alloc/src/collections/btree/navigate.rs | 530 +++ .../alloc/alloc/src/collections/btree/node.rs | 1955 ++++++++++ .../alloc/src/collections/btree/node/tests.rs | 111 + .../alloc/src/collections/btree/remove.rs | 135 + .../alloc/src/collections/btree/search.rs | 85 + .../alloc/alloc/src/collections/btree/set.rs | 1511 ++++++++ .../alloc/src/collections/btree/set/tests.rs | 732 ++++ .../alloc/src/collections/btree/split.rs | 108 + .../alloc/src/collections/linked_list.rs | 1874 +++++++++ .../src/collections/linked_list/tests.rs | 430 ++ .../rust/alloc/alloc/src/collections/mod.rs | 105 + .../alloc/alloc/src/collections/vec_deque.rs | 3350 ++++++++++++++++ .../alloc/src/collections/vec_deque/drain.rs | 127 + .../alloc/src/collections/vec_deque/tests.rs | 586 +++ gcc/testsuite/rust/alloc/alloc/src/fmt.rs | 583 +++ gcc/testsuite/rust/alloc/alloc/src/lib.rs | 207 + gcc/testsuite/rust/alloc/alloc/src/macros.rs | 109 + .../rust/alloc/alloc/src/prelude/mod.rs | 15 + .../rust/alloc/alloc/src/prelude/v1.rs | 14 + gcc/testsuite/rust/alloc/alloc/src/raw_vec.rs | 578 +++ .../rust/alloc/alloc/src/raw_vec/tests.rs | 79 + gcc/testsuite/rust/alloc/alloc/src/rc.rs | 2229 +++++++++++ .../rust/alloc/alloc/src/rc/tests.rs | 520 +++ gcc/testsuite/rust/alloc/alloc/src/slice.rs | 1100 ++++++ gcc/testsuite/rust/alloc/alloc/src/str.rs | 578 +++ gcc/testsuite/rust/alloc/alloc/src/string.rs | 2539 ++++++++++++ gcc/testsuite/rust/alloc/alloc/src/sync.rs | 2378 ++++++++++++ .../rust/alloc/alloc/src/sync/tests.rs | 579 +++ gcc/testsuite/rust/alloc/alloc/src/task.rs | 94 + gcc/testsuite/rust/alloc/alloc/src/tests.rs | 151 + gcc/testsuite/rust/alloc/alloc/src/vec.rs | 3441 +++++++++++++++++ gcc/testsuite/rust/alloc/core.rs | 1902 +++++++++ gcc/testsuite/rust/alloc/prelude.rs | 19 + 48 files changed, 37559 insertions(+) create mode 100644 gcc/testsuite/rust/alloc/alloc.exp create mode 100644 gcc/testsuite/rust/alloc/alloc/src/alloc.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/alloc/tests.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/borrow.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/boxed.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/binary_heap.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/btree/append.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/btree/borrow.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/btree/borrow/tests.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/btree/map.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/btree/map/entry.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/btree/map/tests.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/btree/mem.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/btree/merge_iter.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/btree/mod.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/btree/navigate.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/btree/node.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/btree/node/tests.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/btree/remove.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/btree/search.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/btree/set.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/btree/set/tests.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/btree/split.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/linked_list.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/linked_list/tests.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/mod.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/vec_deque.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/vec_deque/drain.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/collections/vec_deque/tests.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/fmt.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/lib.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/macros.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/prelude/mod.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/prelude/v1.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/raw_vec.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/raw_vec/tests.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/rc.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/rc/tests.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/slice.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/str.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/string.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/sync.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/sync/tests.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/task.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/tests.rs create mode 100644 gcc/testsuite/rust/alloc/alloc/src/vec.rs create mode 100644 gcc/testsuite/rust/alloc/core.rs create mode 100644 gcc/testsuite/rust/alloc/prelude.rs diff --git a/gcc/testsuite/rust/alloc/alloc.exp b/gcc/testsuite/rust/alloc/alloc.exp new file mode 100644 index 000000000000..d412b50cf22e --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc.exp @@ -0,0 +1,47 @@ +# Copyright (C) 2026 Free Software Foundation, Inc. + +# This program 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 of the License, or +# (at your option) any later version. +# +# This program 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 +# . + +# Compile test liballoc, no torture testing. +# +# These tests focus on successfully compiling liballoc. + +# Load support procs. +load_lib rust-dg.exp + +# Initialize `dg'. +dg-init + +if { [check_effective_target_lp64] } { + # Main loop. + set saved-dg-do-what-default ${dg-do-what-default} + + set dg-do-what-default "compile" + set individual_timeout 600 + + dg-additional-files [ lsort [ glob -nocomplain \ + $srcdir/$subdir/core.rs \ + $srcdir/$subdir/prelude.rs \ + $srcdir/$subdir/alloc/* \ + ]] + + dg-runtest $srcdir/$subdir/alloc/src/lib.rs "-frust-edition=2015 -frust-crate=alloc -frust-compile-until=nameresolution -frust-cfg=target_has_atomic=\"ptr\" -w" "" + set dg-do-what-default ${saved-dg-do-what-default} +} else { + unsupported "alloc crate tests require a 64-bit target " +} + +# All done. +dg-finish diff --git a/gcc/testsuite/rust/alloc/alloc/src/alloc.rs b/gcc/testsuite/rust/alloc/alloc/src/alloc.rs new file mode 100644 index 000000000000..af9acbe2fc14 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/alloc.rs @@ -0,0 +1,418 @@ +//! Memory allocation APIs + +#![stable(feature = "alloc_module", since = "1.28.0")] + +use crate::gccrs_core_prelude::*; + +#[cfg(not(test))] +use core::intrinsics; +use core::intrinsics::{min_align_of_val, size_of_val}; + +use core::ptr::Unique; +#[cfg(not(test))] +use core::ptr::{self, NonNull}; + +#[stable(feature = "alloc_module", since = "1.28.0")] +#[doc(inline)] +pub use core::alloc::*; + +#[cfg(test)] +mod tests; + +extern "Rust" { + // These are the magic symbols to call the global allocator. rustc generates + // them to call `__rg_alloc` etc. if there is a `#[global_allocator]` attribute + // (the code expanding that attribute macro generates those functions), or to call + // the default implementations in libstd (`__rdl_alloc` etc. in `library/std/src/alloc.rs`) + // otherwise. + #[rustc_allocator] + #[rustc_allocator_nounwind] + fn __rust_alloc(size: usize, align: usize) -> *mut u8; + #[rustc_allocator_nounwind] + fn __rust_dealloc(ptr: *mut u8, size: usize, align: usize); + #[rustc_allocator_nounwind] + fn __rust_realloc(ptr: *mut u8, old_size: usize, align: usize, new_size: usize) -> *mut u8; + #[rustc_allocator_nounwind] + fn __rust_alloc_zeroed(size: usize, align: usize) -> *mut u8; +} + +/// The global memory allocator. +/// +/// This type implements the [`AllocRef`] trait by forwarding calls +/// to the allocator registered with the `#[global_allocator]` attribute +/// if there is one, or the `std` crate’s default. +/// +/// Note: while this type is unstable, the functionality it provides can be +/// accessed through the [free functions in `alloc`](self#functions). +#[unstable(feature = "allocator_api", issue = "32838")] +#[derive(Copy, Clone, Default, Debug)] +#[cfg(not(test))] +pub struct Global; + +#[cfg(test)] +pub use std::alloc::Global; + +/// Allocate memory with the global allocator. +/// +/// This function forwards calls to the [`GlobalAlloc::alloc`] method +/// of the allocator registered with the `#[global_allocator]` attribute +/// if there is one, or the `std` crate’s default. +/// +/// This function is expected to be deprecated in favor of the `alloc` method +/// of the [`Global`] type when it and the [`AllocRef`] trait become stable. +/// +/// # Safety +/// +/// See [`GlobalAlloc::alloc`]. +/// +/// # Examples +/// +/// ``` +/// use std::alloc::{alloc, dealloc, Layout}; +/// +/// unsafe { +/// let layout = Layout::new::(); +/// let ptr = alloc(layout); +/// +/// *(ptr as *mut u16) = 42; +/// assert_eq!(*(ptr as *mut u16), 42); +/// +/// dealloc(ptr, layout); +/// } +/// ``` +#[stable(feature = "global_alloc", since = "1.28.0")] +#[inline] +pub unsafe fn alloc(layout: Layout) -> *mut u8 { + unsafe { __rust_alloc(layout.size(), layout.align()) } +} + +/// Deallocate memory with the global allocator. +/// +/// This function forwards calls to the [`GlobalAlloc::dealloc`] method +/// of the allocator registered with the `#[global_allocator]` attribute +/// if there is one, or the `std` crate’s default. +/// +/// This function is expected to be deprecated in favor of the `dealloc` method +/// of the [`Global`] type when it and the [`AllocRef`] trait become stable. +/// +/// # Safety +/// +/// See [`GlobalAlloc::dealloc`]. +#[stable(feature = "global_alloc", since = "1.28.0")] +#[inline] +pub unsafe fn dealloc(ptr: *mut u8, layout: Layout) { + unsafe { __rust_dealloc(ptr, layout.size(), layout.align()) } +} + +/// Reallocate memory with the global allocator. +/// +/// This function forwards calls to the [`GlobalAlloc::realloc`] method +/// of the allocator registered with the `#[global_allocator]` attribute +/// if there is one, or the `std` crate’s default. +/// +/// This function is expected to be deprecated in favor of the `realloc` method +/// of the [`Global`] type when it and the [`AllocRef`] trait become stable. +/// +/// # Safety +/// +/// See [`GlobalAlloc::realloc`]. +#[stable(feature = "global_alloc", since = "1.28.0")] +#[inline] +pub unsafe fn realloc(ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 { + unsafe { __rust_realloc(ptr, layout.size(), layout.align(), new_size) } +} + +/// Allocate zero-initialized memory with the global allocator. +/// +/// This function forwards calls to the [`GlobalAlloc::alloc_zeroed`] method +/// of the allocator registered with the `#[global_allocator]` attribute +/// if there is one, or the `std` crate’s default. +/// +/// This function is expected to be deprecated in favor of the `alloc_zeroed` method +/// of the [`Global`] type when it and the [`AllocRef`] trait become stable. +/// +/// # Safety +/// +/// See [`GlobalAlloc::alloc_zeroed`]. +/// +/// # Examples +/// +/// ``` +/// use std::alloc::{alloc_zeroed, dealloc, Layout}; +/// +/// unsafe { +/// let layout = Layout::new::(); +/// let ptr = alloc_zeroed(layout); +/// +/// assert_eq!(*(ptr as *mut u16), 0); +/// +/// dealloc(ptr, layout); +/// } +/// ``` +#[stable(feature = "global_alloc", since = "1.28.0")] +#[inline] +pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8 { + unsafe { __rust_alloc_zeroed(layout.size(), layout.align()) } +} + +#[cfg(not(test))] +impl Global { + #[inline] + fn alloc_impl(&self, layout: Layout, zeroed: bool) -> Result, AllocError> { + match layout.size() { + 0 => Ok(NonNull::slice_from_raw_parts(layout.dangling(), 0)), + // SAFETY: `layout` is non-zero in size, + size => unsafe { + let raw_ptr = if zeroed { + alloc_zeroed(layout) + } else { + alloc(layout) + }; + let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?; + Ok(NonNull::slice_from_raw_parts(ptr, size)) + }, + } + } + + // SAFETY: Same as `AllocRef::grow` + #[inline] + unsafe fn grow_impl( + &self, + ptr: NonNull, + old_layout: Layout, + new_layout: Layout, + zeroed: bool, + ) -> Result, AllocError> { + debug_assert!( + new_layout.size() >= old_layout.size(), + "`new_layout.size()` must be greater than or equal to `old_layout.size()`" + ); + + match old_layout.size() { + 0 => self.alloc_impl(new_layout, zeroed), + + // SAFETY: `new_size` is non-zero as `old_size` is greater than or equal to `new_size` + // as required by safety conditions. Other conditions must be upheld by the caller + old_size if old_layout.align() == new_layout.align() => unsafe { + let new_size = new_layout.size(); + + // `realloc` probably checks for `new_size >= old_layout.size()` or something similar. + intrinsics::assume(new_size >= old_layout.size()); + + let raw_ptr = realloc(ptr.as_ptr(), old_layout, new_size); + let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?; + if zeroed { + raw_ptr.add(old_size).write_bytes(0, new_size - old_size); + } + Ok(NonNull::slice_from_raw_parts(ptr, new_size)) + }, + + // SAFETY: because `new_layout.size()` must be greater than or equal to `old_size`, + // both the old and new memory allocation are valid for reads and writes for `old_size` + // bytes. Also, because the old allocation wasn't yet deallocated, it cannot overlap + // `new_ptr`. Thus, the call to `copy_nonoverlapping` is safe. The safety contract + // for `dealloc` must be upheld by the caller. + old_size => unsafe { + let new_ptr = self.alloc_impl(new_layout, zeroed)?; + ptr::copy_nonoverlapping(ptr.as_ptr(), new_ptr.as_mut_ptr(), old_size); + self.dealloc(ptr, old_layout); + Ok(new_ptr) + }, + } + } +} + +#[unstable(feature = "allocator_api", issue = "32838")] +#[cfg(not(test))] +unsafe impl AllocRef for Global { + #[inline] + fn alloc(&self, layout: Layout) -> Result, AllocError> { + self.alloc_impl(layout, false) + } + + #[inline] + fn alloc_zeroed(&self, layout: Layout) -> Result, AllocError> { + self.alloc_impl(layout, true) + } + + #[inline] + unsafe fn dealloc(&self, ptr: NonNull, layout: Layout) { + if layout.size() != 0 { + // SAFETY: `layout` is non-zero in size, + // other conditions must be upheld by the caller + unsafe { dealloc(ptr.as_ptr(), layout) } + } + } + + #[inline] + unsafe fn grow( + &self, + ptr: NonNull, + old_layout: Layout, + new_layout: Layout, + ) -> Result, AllocError> { + // SAFETY: all conditions must be upheld by the caller + unsafe { self.grow_impl(ptr, old_layout, new_layout, false) } + } + + #[inline] + unsafe fn grow_zeroed( + &self, + ptr: NonNull, + old_layout: Layout, + new_layout: Layout, + ) -> Result, AllocError> { + // SAFETY: all conditions must be upheld by the caller + unsafe { self.grow_impl(ptr, old_layout, new_layout, true) } + } + + #[inline] + unsafe fn shrink( + &self, + ptr: NonNull, + old_layout: Layout, + new_layout: Layout, + ) -> Result, AllocError> { + debug_assert!( + new_layout.size() <= old_layout.size(), + "`new_layout.size()` must be smaller than or equal to `old_layout.size()`" + ); + + match new_layout.size() { + // SAFETY: conditions must be upheld by the caller + 0 => unsafe { + self.dealloc(ptr, old_layout); + Ok(NonNull::slice_from_raw_parts(new_layout.dangling(), 0)) + }, + + // SAFETY: `new_size` is non-zero. Other conditions must be upheld by the caller + new_size if old_layout.align() == new_layout.align() => unsafe { + // `realloc` probably checks for `new_size <= old_layout.size()` or something similar. + intrinsics::assume(new_size <= old_layout.size()); + + let raw_ptr = realloc(ptr.as_ptr(), old_layout, new_size); + let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?; + Ok(NonNull::slice_from_raw_parts(ptr, new_size)) + }, + + // SAFETY: because `new_size` must be smaller than or equal to `old_layout.size()`, + // both the old and new memory allocation are valid for reads and writes for `new_size` + // bytes. Also, because the old allocation wasn't yet deallocated, it cannot overlap + // `new_ptr`. Thus, the call to `copy_nonoverlapping` is safe. The safety contract + // for `dealloc` must be upheld by the caller. + new_size => unsafe { + let new_ptr = self.alloc(new_layout)?; + ptr::copy_nonoverlapping(ptr.as_ptr(), new_ptr.as_mut_ptr(), new_size); + self.dealloc(ptr, old_layout); + Ok(new_ptr) + }, + } + } +} + +/// The allocator for unique pointers. +// This function must not unwind. If it does, MIR codegen will fail. +#[cfg(not(test))] +#[lang = "exchange_malloc"] +#[inline] +unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 { + let layout = unsafe { Layout::from_size_align_unchecked(size, align) }; + match Global.alloc(layout) { + Ok(ptr) => ptr.as_mut_ptr(), + Err(_) => handle_alloc_error(layout), + } +} + +#[cfg_attr(not(test), lang = "box_free")] +#[inline] +// This signature has to be the same as `Box`, otherwise an ICE will happen. +// When an additional parameter to `Box` is added (like `A: AllocRef`), this has to be added here as +// well. +// For example if `Box` is changed to `struct Box(Unique, A)`, +// this function has to be changed to `fn box_free(Unique, A)` as well. +pub(crate) unsafe fn box_free(ptr: Unique, alloc: A) { + unsafe { + let size = size_of_val(ptr.as_ref()); + let align = min_align_of_val(ptr.as_ref()); + let layout = Layout::from_size_align_unchecked(size, align); + alloc.dealloc(ptr.cast().into(), layout) + } +} + +// # Allocation error handler + +extern "Rust" { + // This is the magic symbol to call the global alloc error handler. rustc generates + // it to call `__rg_oom` if there is a `#[alloc_error_handler]`, or to call the + // default implementations below (`__rdl_oom`) otherwise. + #[rustc_allocator_nounwind] + fn __rust_alloc_error_handler(size: usize, align: usize) -> !; +} + +/// Abort on memory allocation error or failure. +/// +/// Callers of memory allocation APIs wishing to abort computation +/// in response to an allocation error are encouraged to call this function, +/// rather than directly invoking `panic!` or similar. +/// +/// The default behavior of this function is to print a message to standard error +/// and abort the process. +/// It can be replaced with [`set_alloc_error_hook`] and [`take_alloc_error_hook`]. +/// +/// [`set_alloc_error_hook`]: ../../std/alloc/fn.set_alloc_error_hook.html +/// [`take_alloc_error_hook`]: ../../std/alloc/fn.take_alloc_error_hook.html +#[stable(feature = "global_alloc", since = "1.28.0")] +#[cfg(not(any(test, bootstrap)))] +#[rustc_allocator_nounwind] +pub fn handle_alloc_error(layout: Layout) -> ! { + unsafe { + __rust_alloc_error_handler(layout.size(), layout.align()); + } +} + +// For alloc test `std::alloc::handle_alloc_error` can be used directly. +#[cfg(test)] +pub use std::alloc::handle_alloc_error; + +// In stage0 (bootstrap) `__rust_alloc_error_handler`, +// might not be generated yet, because an old compiler is used, +// so use the old direct call. +#[cfg(all(bootstrap, not(test)))] +#[stable(feature = "global_alloc", since = "1.28.0")] +#[doc(hidden)] +#[rustc_allocator_nounwind] +pub fn handle_alloc_error(layout: Layout) -> ! { + extern "Rust" { + #[lang = "oom"] + fn oom_impl(layout: Layout) -> !; + } + unsafe { oom_impl(layout) } +} + +#[cfg(not(any(target_os = "hermit", test, bootstrap)))] +#[doc(hidden)] +#[allow(unused_attributes)] +#[unstable(feature = "alloc_internals", issue = "none")] +pub mod __alloc_error_handler { + use crate::alloc::Layout; + use crate::panic;//gccrs + + // called via generated `__rust_alloc_error_handler` + + // if there is no `#[alloc_error_handler]` + #[rustc_std_internal_symbol] + pub unsafe extern "C" fn __rdl_oom(size: usize, _align: usize) -> ! { + panic!("memory allocation of {} bytes failed", size) + } + + // if there is a `#[alloc_error_handler]` + #[rustc_std_internal_symbol] + pub unsafe extern "C" fn __rg_oom(size: usize, align: usize) -> ! { + let layout = unsafe { Layout::from_size_align_unchecked(size, align) }; + extern "Rust" { + #[lang = "oom"] + fn oom_impl(layout: Layout) -> !; + } + unsafe { oom_impl(layout) } + } +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/alloc/tests.rs b/gcc/testsuite/rust/alloc/alloc/src/alloc/tests.rs new file mode 100644 index 000000000000..f7463d0daac9 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/alloc/tests.rs @@ -0,0 +1,30 @@ +use super::*; + +extern crate test; +use crate::boxed::Box; +use test::Bencher; + +#[test] +fn allocate_zeroed() { + unsafe { + let layout = Layout::from_size_align(1024, 1).unwrap(); + let ptr = + Global.alloc_zeroed(layout.clone()).unwrap_or_else(|_| handle_alloc_error(layout)); + + let mut i = ptr.as_non_null_ptr().as_ptr(); + let end = i.add(layout.size()); + while i < end { + assert_eq!(*i, 0); + i = i.offset(1); + } + Global.dealloc(ptr.as_non_null_ptr(), layout); + } +} + +#[bench] +#[cfg_attr(miri, ignore)] // isolated Miri does not support benchmarks +fn alloc_owned_small(b: &mut Bencher) { + b.iter(|| { + let _: Box<_> = box 10; + }) +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/borrow.rs b/gcc/testsuite/rust/alloc/alloc/src/borrow.rs new file mode 100644 index 000000000000..6d07c0bb9d10 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/borrow.rs @@ -0,0 +1,480 @@ +//! A module for working with borrowed data. + +#![stable(feature = "rust1", since = "1.0.0")] + +use crate::gccrs_core_prelude::*; + +use core::cmp::Ordering; +use core::hash::{Hash, Hasher}; +use core::ops::{Add, AddAssign, Deref}; + +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::borrow::{Borrow, BorrowMut}; + +use crate::fmt; +use crate::string::String; + +use Cow::*; + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, B: ?Sized> Borrow for Cow<'a, B> +where + B: ToOwned, + ::Owned: 'a, +{ + fn borrow(&self) -> &B { + &**self + } +} + +/// A generalization of `Clone` to borrowed data. +/// +/// Some types make it possible to go from borrowed to owned, usually by +/// implementing the `Clone` trait. But `Clone` works only for going from `&T` +/// to `T`. The `ToOwned` trait generalizes `Clone` to construct owned data +/// from any borrow of a given type. +#[stable(feature = "rust1", since = "1.0.0")] +pub trait ToOwned { + /// The resulting type after obtaining ownership. + #[stable(feature = "rust1", since = "1.0.0")] + type Owned: Borrow; + + /// Creates owned data from borrowed data, usually by cloning. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s: &str = "a"; + /// let ss: String = s.to_owned(); + /// + /// let v: &[i32] = &[1, 2]; + /// let vv: Vec = v.to_owned(); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[must_use = "cloning is often expensive and is not expected to have side effects"] + fn to_owned(&self) -> Self::Owned; + + /// Uses borrowed data to replace owned data, usually by cloning. + /// + /// This is borrow-generalized version of `Clone::clone_from`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// # #![feature(toowned_clone_into)] + /// let mut s: String = String::new(); + /// "hello".clone_into(&mut s); + /// + /// let mut v: Vec = Vec::new(); + /// [1, 2][..].clone_into(&mut v); + /// ``` + #[unstable(feature = "toowned_clone_into", reason = "recently added", issue = "41263")] + fn clone_into(&self, target: &mut Self::Owned) { + *target = self.to_owned(); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ToOwned for T +where + T: Clone, +{ + type Owned = T; + fn to_owned(&self) -> T { + self.clone() + } + + fn clone_into(&self, target: &mut T) { + target.clone_from(self); + } +} + +/// A clone-on-write smart pointer. +/// +/// The type `Cow` is a smart pointer providing clone-on-write functionality: it +/// can enclose and provide immutable access to borrowed data, and clone the +/// data lazily when mutation or ownership is required. The type is designed to +/// work with general borrowed data via the `Borrow` trait. +/// +/// `Cow` implements `Deref`, which means that you can call +/// non-mutating methods directly on the data it encloses. If mutation +/// is desired, `to_mut` will obtain a mutable reference to an owned +/// value, cloning if necessary. +/// +/// # Examples +/// +/// ``` +/// use std::borrow::Cow; +/// +/// fn abs_all(input: &mut Cow<[i32]>) { +/// for i in 0..input.len() { +/// let v = input[i]; +/// if v < 0 { +/// // Clones into a vector if not already owned. +/// input.to_mut()[i] = -v; +/// } +/// } +/// } +/// +/// // No clone occurs because `input` doesn't need to be mutated. +/// let slice = [0, 1, 2]; +/// let mut input = Cow::from(&slice[..]); +/// abs_all(&mut input); +/// +/// // Clone occurs because `input` needs to be mutated. +/// let slice = [-1, 0, 1]; +/// let mut input = Cow::from(&slice[..]); +/// abs_all(&mut input); +/// +/// // No clone occurs because `input` is already owned. +/// let mut input = Cow::from(vec![-1, 0, 1]); +/// abs_all(&mut input); +/// ``` +/// +/// Another example showing how to keep `Cow` in a struct: +/// +/// ``` +/// use std::borrow::Cow; +/// +/// struct Items<'a, X: 'a> where [X]: ToOwned> { +/// values: Cow<'a, [X]>, +/// } +/// +/// impl<'a, X: Clone + 'a> Items<'a, X> where [X]: ToOwned> { +/// fn new(v: Cow<'a, [X]>) -> Self { +/// Items { values: v } +/// } +/// } +/// +/// // Creates a container from borrowed values of a slice +/// let readonly = [1, 2]; +/// let borrowed = Items::new((&readonly[..]).into()); +/// match borrowed { +/// Items { values: Cow::Borrowed(b) } => println!("borrowed {:?}", b), +/// _ => panic!("expect borrowed value"), +/// } +/// +/// let mut clone_on_write = borrowed; +/// // Mutates the data from slice into owned vec and pushes a new value on top +/// clone_on_write.values.to_mut().push(3); +/// println!("clone_on_write = {:?}", clone_on_write.values); +/// +/// // The data was mutated. Let check it out. +/// match clone_on_write { +/// Items { values: Cow::Owned(_) } => println!("clone_on_write contains owned data"), +/// _ => panic!("expect owned data"), +/// } +/// ``` +#[stable(feature = "rust1", since = "1.0.0")] +pub enum Cow<'a, B: ?Sized + 'a> +where + B: ToOwned, +{ + /// Borrowed data. + #[stable(feature = "rust1", since = "1.0.0")] + Borrowed(#[stable(feature = "rust1", since = "1.0.0")] &'a B), + + /// Owned data. + #[stable(feature = "rust1", since = "1.0.0")] + Owned(#[stable(feature = "rust1", since = "1.0.0")] ::Owned), +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Cow<'_, B> { + fn clone(&self) -> Self { + match *self { + Borrowed(b) => Borrowed(b), + Owned(ref o) => { + let b: &B = o.borrow(); + Owned(b.to_owned()) + } + } + } + + fn clone_from(&mut self, source: &Self) { + match (self, source) { + (&mut Owned(ref mut dest), &Owned(ref o)) => o.borrow().clone_into(dest), + (t, s) => *t = s.clone(), + } + } +} + +impl Cow<'_, B> { + /// Returns true if the data is borrowed, i.e. if `to_mut` would require additional work. + /// + /// # Examples + /// + /// ``` + /// #![feature(cow_is_borrowed)] + /// use std::borrow::Cow; + /// + /// let cow = Cow::Borrowed("moo"); + /// assert!(cow.is_borrowed()); + /// + /// let bull: Cow<'_, str> = Cow::Owned("...moo?".to_string()); + /// assert!(!bull.is_borrowed()); + /// ``` + #[unstable(feature = "cow_is_borrowed", issue = "65143")] + #[rustc_const_unstable(feature = "const_cow_is_borrowed", issue = "65143")] + pub const fn is_borrowed(&self) -> bool { + match *self { + Borrowed(_) => true, + Owned(_) => false, + } + } + + /// Returns true if the data is owned, i.e. if `to_mut` would be a no-op. + /// + /// # Examples + /// + /// ``` + /// #![feature(cow_is_borrowed)] + /// use std::borrow::Cow; + /// + /// let cow: Cow<'_, str> = Cow::Owned("moo".to_string()); + /// assert!(cow.is_owned()); + /// + /// let bull = Cow::Borrowed("...moo?"); + /// assert!(!bull.is_owned()); + /// ``` + #[unstable(feature = "cow_is_borrowed", issue = "65143")] + #[rustc_const_unstable(feature = "const_cow_is_borrowed", issue = "65143")] + pub const fn is_owned(&self) -> bool { + !self.is_borrowed() + } + + /// Acquires a mutable reference to the owned form of the data. + /// + /// Clones the data if it is not already owned. + /// + /// # Examples + /// + /// ``` + /// use std::borrow::Cow; + /// + /// let mut cow = Cow::Borrowed("foo"); + /// cow.to_mut().make_ascii_uppercase(); + /// + /// assert_eq!( + /// cow, + /// Cow::Owned(String::from("FOO")) as Cow + /// ); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn to_mut(&mut self) -> &mut ::Owned { + match *self { + Borrowed(borrowed) => { + *self = Owned(borrowed.to_owned()); + match *self { + Borrowed(..) => unreachable!(), + Owned(ref mut owned) => owned, + } + } + Owned(ref mut owned) => owned, + } + } + + /// Extracts the owned data. + /// + /// Clones the data if it is not already owned. + /// + /// # Examples + /// + /// Calling `into_owned` on a `Cow::Borrowed` clones the underlying data + /// and becomes a `Cow::Owned`: + /// + /// ``` + /// use std::borrow::Cow; + /// + /// let s = "Hello world!"; + /// let cow = Cow::Borrowed(s); + /// + /// assert_eq!( + /// cow.into_owned(), + /// String::from(s) + /// ); + /// ``` + /// + /// Calling `into_owned` on a `Cow::Owned` is a no-op: + /// + /// ``` + /// use std::borrow::Cow; + /// + /// let s = "Hello world!"; + /// let cow: Cow = Cow::Owned(String::from(s)); + /// + /// assert_eq!( + /// cow.into_owned(), + /// String::from(s) + /// ); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn into_owned(self) -> ::Owned { + match self { + Borrowed(borrowed) => borrowed.to_owned(), + Owned(owned) => owned, + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Deref for Cow<'_, B> { + type Target = B; + + fn deref(&self) -> &B { + match *self { + Borrowed(borrowed) => borrowed, + Owned(ref owned) => owned.borrow(), + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Eq for Cow<'_, B> where B: Eq + ToOwned {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Ord for Cow<'_, B> +where + B: Ord + ToOwned, +{ + #[inline] + fn cmp(&self, other: &Self) -> Ordering { + Ord::cmp(&**self, &**other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, 'b, B: ?Sized, C: ?Sized> PartialEq> for Cow<'a, B> +where + B: PartialEq + ToOwned, + C: ToOwned, +{ + #[inline] + fn eq(&self, other: &Cow<'b, C>) -> bool { + PartialEq::eq(&**self, &**other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, B: ?Sized> PartialOrd for Cow<'a, B> +where + B: PartialOrd + ToOwned, +{ + #[inline] + fn partial_cmp(&self, other: &Cow<'a, B>) -> Option { + PartialOrd::partial_cmp(&**self, &**other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Debug for Cow<'_, B> +where + B: fmt::Debug + ToOwned, +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match *self { + Borrowed(ref b) => fmt::Debug::fmt(b, f), + Owned(ref o) => fmt::Debug::fmt(o, f), + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Display for Cow<'_, B> +where + B: fmt::Display + ToOwned, +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match *self { + Borrowed(ref b) => fmt::Display::fmt(b, f), + Owned(ref o) => fmt::Display::fmt(o, f), + } + } +} + +#[stable(feature = "default", since = "1.11.0")] +impl Default for Cow<'_, B> +where + B: ToOwned, +{ + /// Creates an owned Cow<'a, B> with the default value for the contained owned value. + fn default() -> Self { + Owned(::Owned::default()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Hash for Cow<'_, B> +where + B: Hash + ToOwned, +{ + #[inline] + fn hash(&self, state: &mut H) { + Hash::hash(&**self, state) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl AsRef for Cow<'_, T> { + fn as_ref(&self) -> &T { + self + } +} + +#[stable(feature = "cow_add", since = "1.14.0")] +impl<'a> Add<&'a str> for Cow<'a, str> { + type Output = Cow<'a, str>; + + #[inline] + fn add(mut self, rhs: &'a str) -> Self::Output { + self += rhs; + self + } +} + +#[stable(feature = "cow_add", since = "1.14.0")] +impl<'a> Add> for Cow<'a, str> { + type Output = Cow<'a, str>; + + #[inline] + fn add(mut self, rhs: Cow<'a, str>) -> Self::Output { + self += rhs; + self + } +} + +#[stable(feature = "cow_add", since = "1.14.0")] +impl<'a> AddAssign<&'a str> for Cow<'a, str> { + fn add_assign(&mut self, rhs: &'a str) { + if self.is_empty() { + *self = Cow::Borrowed(rhs) + } else if !rhs.is_empty() { + if let Cow::Borrowed(lhs) = *self { + let mut s = String::with_capacity(lhs.len() + rhs.len()); + s.push_str(lhs); + *self = Cow::Owned(s); + } + self.to_mut().push_str(rhs); + } + } +} + +#[stable(feature = "cow_add", since = "1.14.0")] +impl<'a> AddAssign> for Cow<'a, str> { + fn add_assign(&mut self, rhs: Cow<'a, str>) { + if self.is_empty() { + *self = rhs + } else if !rhs.is_empty() { + if let Cow::Borrowed(lhs) = *self { + let mut s = String::with_capacity(lhs.len() + rhs.len()); + s.push_str(lhs); + *self = Cow::Owned(s); + } + self.to_mut().push_str(&rhs); + } + } +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/boxed.rs b/gcc/testsuite/rust/alloc/alloc/src/boxed.rs new file mode 100644 index 000000000000..b82a860624c6 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/boxed.rs @@ -0,0 +1,1435 @@ +//! A pointer type for heap allocation. +//! +//! [`Box`], casually referred to as a 'box', provides the simplest form of +//! heap allocation in Rust. Boxes provide ownership for this allocation, and +//! drop their contents when they go out of scope. Boxes also ensure that they +//! never allocate more than `isize::MAX` bytes. +//! +//! # Examples +//! +//! Move a value from the stack to the heap by creating a [`Box`]: +//! +//! ``` +//! let val: u8 = 5; +//! let boxed: Box = Box::new(val); +//! ``` +//! +//! Move a value from a [`Box`] back to the stack by [dereferencing]: +//! +//! ``` +//! let boxed: Box = Box::new(5); +//! let val: u8 = *boxed; +//! ``` +//! +//! Creating a recursive data structure: +//! +//! ``` +//! #[derive(Debug)] +//! enum List { +//! Cons(T, Box>), +//! Nil, +//! } +//! +//! let list: List = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil)))); +//! println!("{:?}", list); +//! ``` +//! +//! This will print `Cons(1, Cons(2, Nil))`. +//! +//! Recursive structures must be boxed, because if the definition of `Cons` +//! looked like this: +//! +//! ```compile_fail,E0072 +//! # enum List { +//! Cons(T, List), +//! # } +//! ``` +//! +//! It wouldn't work. This is because the size of a `List` depends on how many +//! elements are in the list, and so we don't know how much memory to allocate +//! for a `Cons`. By introducing a [`Box`], which has a defined size, we know how +//! big `Cons` needs to be. +//! +//! # Memory layout +//! +//! For non-zero-sized values, a [`Box`] will use the [`Global`] allocator for +//! its allocation. It is valid to convert both ways between a [`Box`] and a +//! raw pointer allocated with the [`Global`] allocator, given that the +//! [`Layout`] used with the allocator is correct for the type. More precisely, +//! a `value: *mut T` that has been allocated with the [`Global`] allocator +//! with `Layout::for_value(&*value)` may be converted into a box using +//! [`Box::::from_raw(value)`]. Conversely, the memory backing a `value: *mut +//! T` obtained from [`Box::::into_raw`] may be deallocated using the +//! [`Global`] allocator with [`Layout::for_value(&*value)`]. +//! +//! So long as `T: Sized`, a `Box` is guaranteed to be represented +//! as a single pointer and is also ABI-compatible with C pointers +//! (i.e. the C type `T*`). This means that if you have extern "C" +//! Rust functions that will be called from C, you can define those +//! Rust functions using `Box` types, and use `T*` as corresponding +//! type on the C side. As an example, consider this C header which +//! declares functions that create and destroy some kind of `Foo` +//! value: +//! +//! ```c +//! /* C header */ +//! +//! /* Returns ownership to the caller */ +//! struct Foo* foo_new(void); +//! +//! /* Takes ownership from the caller; no-op when invoked with NULL */ +//! void foo_delete(struct Foo*); +//! ``` +//! +//! These two functions might be implemented in Rust as follows. Here, the +//! `struct Foo*` type from C is translated to `Box`, which captures +//! the ownership constraints. Note also that the nullable argument to +//! `foo_delete` is represented in Rust as `Option>`, since `Box` +//! cannot be null. +//! +//! ``` +//! #[repr(C)] +//! pub struct Foo; +//! +//! #[no_mangle] +//! #[allow(improper_ctypes_definitions)] +//! pub extern "C" fn foo_new() -> Box { +//! Box::new(Foo) +//! } +//! +//! #[no_mangle] +//! #[allow(improper_ctypes_definitions)] +//! pub extern "C" fn foo_delete(_: Option>) {} +//! ``` +//! +//! Even though `Box` has the same representation and C ABI as a C pointer, +//! this does not mean that you can convert an arbitrary `T*` into a `Box` +//! and expect things to work. `Box` values will always be fully aligned, +//! non-null pointers. Moreover, the destructor for `Box` will attempt to +//! free the value with the global allocator. In general, the best practice +//! is to only use `Box` for pointers that originated from the global +//! allocator. +//! +//! **Important.** At least at present, you should avoid using +//! `Box` types for functions that are defined in C but invoked +//! from Rust. In those cases, you should directly mirror the C types +//! as closely as possible. Using types like `Box` where the C +//! definition is just using `T*` can lead to undefined behavior, as +//! described in [rust-lang/unsafe-code-guidelines#198][ucg#198]. +//! +//! [ucg#198]: https://github.com/rust-lang/unsafe-code-guidelines/issues/198 +//! [dereferencing]: core::ops::Deref +//! [`Box`]: Box +//! [`Box::::from_raw(value)`]: Box::from_raw +//! [`Box::::into_raw`]: Box::into_raw +//! [`Global`]: crate::alloc::Global +//! [`Layout`]: crate::alloc::Layout +//! [`Layout::for_value(&*value)`]: crate::alloc::Layout::for_value + +#![stable(feature = "rust1", since = "1.0.0")] + +use crate::gccrs_core_prelude::*; + +use core::any::Any; +use core::borrow; +use core::cmp::Ordering; +use core::convert::{From, TryFrom}; +use core::fmt; +use core::future::Future; +use core::hash::{Hash, Hasher}; +use core::iter::{FromIterator, FusedIterator, Iterator}; +use core::marker::{Unpin, Unsize}; +use core::mem; +use core::ops::{ + CoerceUnsized, Deref, DerefMut, DispatchFromDyn, Generator, GeneratorState, Receiver, +}; +use core::pin::Pin; +use core::ptr::{self, Unique}; +use core::task::{Context, Poll}; + +use crate::alloc::{handle_alloc_error, AllocRef, Global, Layout}; +use crate::borrow::Cow; +use crate::raw_vec::RawVec; +use crate::str::from_boxed_utf8_unchecked; +use crate::vec::Vec; + +/// A pointer type for heap allocation. +/// +/// See the [module-level documentation](../../std/boxed/index.html) for more. +#[lang = "owned_box"] +#[fundamental] +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Box< + T: ?Sized, + #[unstable(feature = "allocator_api", issue = "32838")] A: AllocRef = Global, +>(Unique, A); + +impl Box { + /// Allocates memory on the heap and then places `x` into it. + /// + /// This doesn't actually allocate if `T` is zero-sized. + /// + /// # Examples + /// + /// ``` + /// let five = Box::new(5); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline(always)] + pub fn new(x: T) -> Self { + box x + } + + /// Constructs a new box with uninitialized contents. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// let mut five = Box::::new_uninit(); + /// + /// let five = unsafe { + /// // Deferred initialization: + /// five.as_mut_ptr().write(5); + /// + /// five.assume_init() + /// }; + /// + /// assert_eq!(*five, 5) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + #[inline] + pub fn new_uninit() -> Box> { + Self::new_uninit_in(Global) + } + + /// Constructs a new `Box` with uninitialized contents, with the memory + /// being filled with `0` bytes. + /// + /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and incorrect usage + /// of this method. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// let zero = Box::::new_zeroed(); + /// let zero = unsafe { zero.assume_init() }; + /// + /// assert_eq!(*zero, 0) + /// ``` + /// + /// [zeroed]: mem::MaybeUninit::zeroed + #[unstable(feature = "new_uninit", issue = "63291")] + #[inline] + pub fn new_zeroed() -> Box> { + Self::new_zeroed_in(Global) + } + + /// Constructs a new `Pin>`. If `T` does not implement `Unpin`, then + /// `x` will be pinned in memory and unable to be moved. + #[stable(feature = "pin", since = "1.33.0")] + #[inline(always)] + pub fn pin(x: T) -> Pin> { + (box x).into() + } +} + +impl Box { + /// Allocates memory in the given allocator then places `x` into it. + /// + /// This doesn't actually allocate if `T` is zero-sized. + /// + /// # Examples + /// + /// ``` + /// #![feature(allocator_api)] + /// + /// use std::alloc::System; + /// + /// let five = Box::new_in(5, System); + /// ``` + #[unstable(feature = "allocator_api", issue = "32838")] + #[inline] + pub fn new_in(x: T, alloc: A) -> Self { + let mut boxed = Self::new_uninit_in(alloc); + unsafe { + boxed.as_mut_ptr().write(x); + boxed.assume_init() + } + } + + /// Constructs a new box with uninitialized contents in the provided allocator. + /// + /// # Examples + /// + /// ``` + /// #![feature(allocator_api, new_uninit)] + /// + /// use std::alloc::System; + /// + /// let mut five = Box::::new_uninit_in(System); + /// + /// let five = unsafe { + /// // Deferred initialization: + /// five.as_mut_ptr().write(5); + /// + /// five.assume_init() + /// }; + /// + /// assert_eq!(*five, 5) + /// ``` + #[unstable(feature = "allocator_api", issue = "32838")] + // #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_uninit_in(alloc: A) -> Box, A> { + let layout = Layout::new::>(); + let ptr = alloc.alloc(layout).unwrap_or_else(|_| handle_alloc_error(layout)).cast(); + unsafe { Box::from_raw_in(ptr.as_ptr(), alloc) } + } + + /// Constructs a new `Box` with uninitialized contents, with the memory + /// being filled with `0` bytes in the provided allocator. + /// + /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and incorrect usage + /// of this method. + /// + /// # Examples + /// + /// ``` + /// #![feature(allocator_api, new_uninit)] + /// + /// use std::alloc::System; + /// + /// let zero = Box::::new_zeroed_in(System); + /// let zero = unsafe { zero.assume_init() }; + /// + /// assert_eq!(*zero, 0) + /// ``` + /// + /// [zeroed]: mem::MaybeUninit::zeroed + #[unstable(feature = "allocator_api", issue = "32838")] + // #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_zeroed_in(alloc: A) -> Box, A> { + let layout = Layout::new::>(); + let ptr = alloc.alloc_zeroed(layout).unwrap_or_else(|_| handle_alloc_error(layout)).cast(); + unsafe { Box::from_raw_in(ptr.as_ptr(), alloc) } + } + + /// Constructs a new `Pin>`. If `T` does not implement `Unpin`, then + /// `x` will be pinned in memory and unable to be moved. + #[unstable(feature = "allocator_api", issue = "32838")] + #[inline(always)] + pub fn pin_in(x: T, alloc: A) -> Pin { + Self::new_in(x, alloc).into() + } + + /// Converts a `Box` into a `Box<[T]>` + /// + /// This conversion does not allocate on the heap and happens in place. + #[unstable(feature = "box_into_boxed_slice", issue = "71582")] + pub fn into_boxed_slice(boxed: Self) -> Box<[T], A> { + let (raw, alloc) = Box::into_raw_with_alloc(boxed); + unsafe { Box::from_raw_in(raw as *mut [T; 1], alloc) } + } +} + +impl Box<[T]> { + /// Constructs a new boxed slice with uninitialized contents. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// let mut values = Box::<[u32]>::new_uninit_slice(3); + /// + /// let values = unsafe { + /// // Deferred initialization: + /// values[0].as_mut_ptr().write(1); + /// values[1].as_mut_ptr().write(2); + /// values[2].as_mut_ptr().write(3); + /// + /// values.assume_init() + /// }; + /// + /// assert_eq!(*values, [1, 2, 3]) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit]> { + unsafe { RawVec::with_capacity(len).into_box(len) } + } + + /// Constructs a new boxed slice with uninitialized contents, with the memory + /// being filled with `0` bytes. + /// + /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and incorrect usage + /// of this method. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// let values = Box::<[u32]>::new_zeroed_slice(3); + /// let values = unsafe { values.assume_init() }; + /// + /// assert_eq!(*values, [0, 0, 0]) + /// ``` + /// + /// [zeroed]: mem::MaybeUninit::zeroed + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_zeroed_slice(len: usize) -> Box<[mem::MaybeUninit]> { + unsafe { RawVec::with_capacity_zeroed(len).into_box(len) } + } +} + +impl Box<[T], A> { + /// Constructs a new boxed slice with uninitialized contents in the provided allocator. + /// + /// # Examples + /// + /// ``` + /// #![feature(allocator_api, new_uninit)] + /// + /// use std::alloc::System; + /// + /// let mut values = Box::<[u32], _>::new_uninit_slice_in(3, System); + /// + /// let values = unsafe { + /// // Deferred initialization: + /// values[0].as_mut_ptr().write(1); + /// values[1].as_mut_ptr().write(2); + /// values[2].as_mut_ptr().write(3); + /// + /// values.assume_init() + /// }; + /// + /// assert_eq!(*values, [1, 2, 3]) + /// ``` + #[unstable(feature = "allocator_api", issue = "32838")] + // #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], A> { + unsafe { RawVec::with_capacity_in(len, alloc).into_box(len) } + } + + /// Constructs a new boxed slice with uninitialized contents in the provided allocator, + /// with the memory being filled with `0` bytes. + /// + /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and incorrect usage + /// of this method. + /// + /// # Examples + /// + /// ``` + /// #![feature(allocator_api, new_uninit)] + /// + /// use std::alloc::System; + /// + /// let values = Box::<[u32], _>::new_zeroed_slice_in(3, System); + /// let values = unsafe { values.assume_init() }; + /// + /// assert_eq!(*values, [0, 0, 0]) + /// ``` + /// + /// [zeroed]: mem::MaybeUninit::zeroed + #[unstable(feature = "allocator_api", issue = "32838")] + // #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], A> { + unsafe { RawVec::with_capacity_zeroed_in(len, alloc).into_box(len) } + } +} + +impl Box, A> { + /// Converts to `Box`. + /// + /// # Safety + /// + /// As with [`MaybeUninit::assume_init`], + /// it is up to the caller to guarantee that the value + /// really is in an initialized state. + /// Calling this when the content is not yet fully initialized + /// causes immediate undefined behavior. + /// + /// [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// let mut five = Box::::new_uninit(); + /// + /// let five: Box = unsafe { + /// // Deferred initialization: + /// five.as_mut_ptr().write(5); + /// + /// five.assume_init() + /// }; + /// + /// assert_eq!(*five, 5) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + #[inline] + pub unsafe fn assume_init(self) -> Box { + let (raw, alloc) = Box::into_raw_with_alloc(self); + unsafe { Box::from_raw_in(raw as *mut T, alloc) } + } +} + +impl Box<[mem::MaybeUninit], A> { + /// Converts to `Box<[T], A>`. + /// + /// # Safety + /// + /// As with [`MaybeUninit::assume_init`], + /// it is up to the caller to guarantee that the values + /// really are in an initialized state. + /// Calling this when the content is not yet fully initialized + /// causes immediate undefined behavior. + /// + /// [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// let mut values = Box::<[u32]>::new_uninit_slice(3); + /// + /// let values = unsafe { + /// // Deferred initialization: + /// values[0].as_mut_ptr().write(1); + /// values[1].as_mut_ptr().write(2); + /// values[2].as_mut_ptr().write(3); + /// + /// values.assume_init() + /// }; + /// + /// assert_eq!(*values, [1, 2, 3]) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + #[inline] + pub unsafe fn assume_init(self) -> Box<[T], A> { + let (raw, alloc) = Box::into_raw_with_alloc(self); + unsafe { Box::from_raw_in(raw as *mut [T], alloc) } + } +} + +impl Box { + /// Constructs a box from a raw pointer. + /// + /// After calling this function, the raw pointer is owned by the + /// resulting `Box`. Specifically, the `Box` destructor will call + /// the destructor of `T` and free the allocated memory. For this + /// to be safe, the memory must have been allocated in accordance + /// with the [memory layout] used by `Box` . + /// + /// # Safety + /// + /// This function is unsafe because improper use may lead to + /// memory problems. For example, a double-free may occur if the + /// function is called twice on the same raw pointer. + /// + /// # Examples + /// Recreate a `Box` which was previously converted to a raw pointer + /// using [`Box::into_raw`]: + /// ``` + /// let x = Box::new(5); + /// let ptr = Box::into_raw(x); + /// let x = unsafe { Box::from_raw(ptr) }; + /// ``` + /// Manually create a `Box` from scratch by using the global allocator: + /// ``` + /// use std::alloc::{alloc, Layout}; + /// + /// unsafe { + /// let ptr = alloc(Layout::new::()) as *mut i32; + /// // In general .write is required to avoid attempting to destruct + /// // the (uninitialized) previous contents of `ptr`, though for this + /// // simple example `*ptr = 5` would have worked as well. + /// ptr.write(5); + /// let x = Box::from_raw(ptr); + /// } + /// ``` + /// + /// [memory layout]: self#memory-layout + /// [`Layout`]: crate::Layout + #[stable(feature = "box_raw", since = "1.4.0")] + #[inline] + pub unsafe fn from_raw(raw: *mut T) -> Self { + unsafe { Self::from_raw_in(raw, Global) } + } +} + +impl Box { + /// Constructs a box from a raw pointer in the given allocator. + /// + /// After calling this function, the raw pointer is owned by the + /// resulting `Box`. Specifically, the `Box` destructor will call + /// the destructor of `T` and free the allocated memory. For this + /// to be safe, the memory must have been allocated in accordance + /// with the [memory layout] used by `Box` . + /// + /// # Safety + /// + /// This function is unsafe because improper use may lead to + /// memory problems. For example, a double-free may occur if the + /// function is called twice on the same raw pointer. + /// + /// + /// # Examples + /// + /// Recreate a `Box` which was previously converted to a raw pointer + /// using [`Box::into_raw_with_alloc`]: + /// ``` + /// #![feature(allocator_api)] + /// + /// use std::alloc::System; + /// + /// let x = Box::new_in(5, System); + /// let (ptr, alloc) = Box::into_raw_with_alloc(x); + /// let x = unsafe { Box::from_raw_in(ptr, alloc) }; + /// ``` + /// Manually create a `Box` from scratch by using the system allocator: + /// ``` + /// #![feature(allocator_api, slice_ptr_get)] + /// + /// use std::alloc::{AllocRef, Layout, System}; + /// + /// unsafe { + /// let ptr = System.alloc(Layout::new::())?.as_mut_ptr(); + /// // In general .write is required to avoid attempting to destruct + /// // the (uninitialized) previous contents of `ptr`, though for this + /// // simple example `*ptr = 5` would have worked as well. + /// ptr.write(5); + /// let x = Box::from_raw_in(ptr, System); + /// } + /// # Ok::<(), std::alloc::AllocError>(()) + /// ``` + /// + /// [memory layout]: self#memory-layout + /// [`Layout`]: crate::Layout + #[unstable(feature = "allocator_api", issue = "32838")] + #[inline] + pub unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Self { + Box(unsafe { Unique::new_unchecked(raw) }, alloc) + } + + /// Consumes the `Box`, returning a wrapped raw pointer. + /// + /// The pointer will be properly aligned and non-null. + /// + /// After calling this function, the caller is responsible for the + /// memory previously managed by the `Box`. In particular, the + /// caller should properly destroy `T` and release the memory, taking + /// into account the [memory layout] used by `Box`. The easiest way to + /// do this is to convert the raw pointer back into a `Box` with the + /// [`Box::from_raw`] function, allowing the `Box` destructor to perform + /// the cleanup. + /// + /// Note: this is an associated function, which means that you have + /// to call it as `Box::into_raw(b)` instead of `b.into_raw()`. This + /// is so that there is no conflict with a method on the inner type. + /// + /// # Examples + /// Converting the raw pointer back into a `Box` with [`Box::from_raw`] + /// for automatic cleanup: + /// ``` + /// let x = Box::new(String::from("Hello")); + /// let ptr = Box::into_raw(x); + /// let x = unsafe { Box::from_raw(ptr) }; + /// ``` + /// Manual cleanup by explicitly running the destructor and deallocating + /// the memory: + /// ``` + /// use std::alloc::{dealloc, Layout}; + /// use std::ptr; + /// + /// let x = Box::new(String::from("Hello")); + /// let p = Box::into_raw(x); + /// unsafe { + /// ptr::drop_in_place(p); + /// dealloc(p as *mut u8, Layout::new::()); + /// } + /// ``` + /// + /// [memory layout]: self#memory-layout + #[stable(feature = "box_raw", since = "1.4.0")] + #[inline] + pub fn into_raw(b: Self) -> *mut T { + Self::into_raw_with_alloc(b).0 + } + + /// Consumes the `Box`, returning a wrapped raw pointer and the allocator. + /// + /// The pointer will be properly aligned and non-null. + /// + /// After calling this function, the caller is responsible for the + /// memory previously managed by the `Box`. In particular, the + /// caller should properly destroy `T` and release the memory, taking + /// into account the [memory layout] used by `Box`. The easiest way to + /// do this is to convert the raw pointer back into a `Box` with the + /// [`Box::from_raw_in`] function, allowing the `Box` destructor to perform + /// the cleanup. + /// + /// Note: this is an associated function, which means that you have + /// to call it as `Box::into_raw_with_alloc(b)` instead of `b.into_raw_with_alloc()`. This + /// is so that there is no conflict with a method on the inner type. + /// + /// # Examples + /// Converting the raw pointer back into a `Box` with [`Box::from_raw_in`] + /// for automatic cleanup: + /// ``` + /// #![feature(allocator_api)] + /// + /// use std::alloc::System; + /// + /// let x = Box::new_in(String::from("Hello"), System); + /// let (ptr, alloc) = Box::into_raw_with_alloc(x); + /// let x = unsafe { Box::from_raw_in(ptr, alloc) }; + /// ``` + /// Manual cleanup by explicitly running the destructor and deallocating + /// the memory: + /// ``` + /// #![feature(allocator_api)] + /// + /// use std::alloc::{AllocRef, Layout, System}; + /// use std::ptr::{self, NonNull}; + /// + /// let x = Box::new_in(String::from("Hello"), System); + /// let (ptr, alloc) = Box::into_raw_with_alloc(x); + /// unsafe { + /// ptr::drop_in_place(ptr); + /// let non_null = NonNull::new_unchecked(ptr); + /// alloc.dealloc(non_null.cast(), Layout::new::()); + /// } + /// ``` + /// + /// [memory layout]: self#memory-layout + #[unstable(feature = "allocator_api", issue = "32838")] + #[inline] + pub fn into_raw_with_alloc(b: Self) -> (*mut T, A) { + let (leaked, alloc) = Box::into_unique(b); + (leaked.as_ptr(), alloc) + } + + #[unstable( + feature = "ptr_internals", + issue = "none", + reason = "use `Box::leak(b).into()` or `Unique::from(Box::leak(b))` instead" + )] + #[inline] + #[doc(hidden)] + pub fn into_unique(b: Self) -> (Unique, A) { + // Box is recognized as a "unique pointer" by Stacked Borrows, but internally it is a + // raw pointer for the type system. Turning it directly into a raw pointer would not be + // recognized as "releasing" the unique pointer to permit aliased raw accesses, + // so all raw pointer methods have to go through `Box::leak`. Turning *that* to a raw pointer + // behaves correctly. + let alloc = unsafe { ptr::read(&b.1) }; + (Unique::from(Box::leak(b)), alloc) + } + + /// Returns a reference to the underlying allocator. + /// + /// Note: this is an associated function, which means that you have + /// to call it as `Box::alloc_ref(&b)` instead of `b.alloc_ref()`. This + /// is so that there is no conflict with a method on the inner type. + #[unstable(feature = "allocator_api", issue = "32838")] + #[inline] + pub fn alloc_ref(b: &Self) -> &A { + &b.1 + } + + /// Consumes and leaks the `Box`, returning a mutable reference, + /// `&'a mut T`. Note that the type `T` must outlive the chosen lifetime + /// `'a`. If the type has only static references, or none at all, then this + /// may be chosen to be `'static`. + /// + /// This function is mainly useful for data that lives for the remainder of + /// the program's life. Dropping the returned reference will cause a memory + /// leak. If this is not acceptable, the reference should first be wrapped + /// with the [`Box::from_raw`] function producing a `Box`. This `Box` can + /// then be dropped which will properly destroy `T` and release the + /// allocated memory. + /// + /// Note: this is an associated function, which means that you have + /// to call it as `Box::leak(b)` instead of `b.leak()`. This + /// is so that there is no conflict with a method on the inner type. + /// + /// # Examples + /// + /// Simple usage: + /// + /// ``` + /// let x = Box::new(41); + /// let static_ref: &'static mut usize = Box::leak(x); + /// *static_ref += 1; + /// assert_eq!(*static_ref, 42); + /// ``` + /// + /// Unsized data: + /// + /// ``` + /// let x = vec![1, 2, 3].into_boxed_slice(); + /// let static_ref = Box::leak(x); + /// static_ref[0] = 4; + /// assert_eq!(*static_ref, [4, 2, 3]); + /// ``` + #[stable(feature = "box_leak", since = "1.26.0")] + #[inline] + pub fn leak<'a>(b: Self) -> &'a mut T + where + A: 'a, + { + unsafe { &mut *mem::ManuallyDrop::new(b).0.as_ptr() } + } + + /// Converts a `Box` into a `Pin>` + /// + /// This conversion does not allocate on the heap and happens in place. + /// + /// This is also available via [`From`]. + #[unstable(feature = "box_into_pin", issue = "62370")] + pub fn into_pin(boxed: Self) -> Pin { + // It's not possible to move or replace the insides of a `Pin>` + // when `T: !Unpin`, so it's safe to pin it directly without any + // additional requirements. + unsafe { Pin::new_unchecked(boxed) } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl<#[may_dangle] T: ?Sized, A: AllocRef> Drop for Box { + fn drop(&mut self) { + // FIXME: Do nothing, drop is currently performed by compiler. + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for Box { + /// Creates a `Box`, with the `Default` value for T. + fn default() -> Self { + box T::default() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for Box<[T]> { + fn default() -> Self { + Box::<[T; 0]>::new([]) + } +} + +#[stable(feature = "default_box_extra", since = "1.17.0")] +impl Default for Box { + fn default() -> Self { + unsafe { from_boxed_utf8_unchecked(Default::default()) } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Box { + /// Returns a new box with a `clone()` of this box's contents. + /// + /// # Examples + /// + /// ``` + /// let x = Box::new(5); + /// let y = x.clone(); + /// + /// // The value is the same + /// assert_eq!(x, y); + /// + /// // But they are unique objects + /// assert_ne!(&*x as *const i32, &*y as *const i32); + /// ``` + #[rustfmt::skip] + #[inline] + fn clone(&self) -> Self { + Self::new_in((**self).clone(), self.1.clone()) + } + + /// Copies `source`'s contents into `self` without creating a new allocation. + /// + /// # Examples + /// + /// ``` + /// let x = Box::new(5); + /// let mut y = Box::new(10); + /// let yp: *const i32 = &*y; + /// + /// y.clone_from(&x); + /// + /// // The value is the same + /// assert_eq!(x, y); + /// + /// // And no allocation occurred + /// assert_eq!(yp, &*y); + /// ``` + #[inline] + fn clone_from(&mut self, source: &Self) { + (**self).clone_from(&(**source)); + } +} + +#[stable(feature = "box_slice_clone", since = "1.3.0")] +impl Clone for Box { + fn clone(&self) -> Self { + // this makes a copy of the data + let buf: Box<[u8]> = self.as_bytes().into(); + unsafe { from_boxed_utf8_unchecked(buf) } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialEq for Box { + #[inline] + fn eq(&self, other: &Self) -> bool { + PartialEq::eq(&**self, &**other) + } + #[inline] + fn ne(&self, other: &Self) -> bool { + PartialEq::ne(&**self, &**other) + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialOrd for Box { + #[inline] + fn partial_cmp(&self, other: &Self) -> Option { + PartialOrd::partial_cmp(&**self, &**other) + } + #[inline] + fn lt(&self, other: &Self) -> bool { + PartialOrd::lt(&**self, &**other) + } + #[inline] + fn le(&self, other: &Self) -> bool { + PartialOrd::le(&**self, &**other) + } + #[inline] + fn ge(&self, other: &Self) -> bool { + PartialOrd::ge(&**self, &**other) + } + #[inline] + fn gt(&self, other: &Self) -> bool { + PartialOrd::gt(&**self, &**other) + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl Ord for Box { + #[inline] + fn cmp(&self, other: &Self) -> Ordering { + Ord::cmp(&**self, &**other) + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl Eq for Box {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Hash for Box { + fn hash(&self, state: &mut H) { + (**self).hash(state); + } +} + +#[stable(feature = "indirect_hasher_impl", since = "1.22.0")] +impl Hasher for Box { + fn finish(&self) -> u64 { + (**self).finish() + } + fn write(&mut self, bytes: &[u8]) { + (**self).write(bytes) + } + fn write_u8(&mut self, i: u8) { + (**self).write_u8(i) + } + fn write_u16(&mut self, i: u16) { + (**self).write_u16(i) + } + fn write_u32(&mut self, i: u32) { + (**self).write_u32(i) + } + fn write_u64(&mut self, i: u64) { + (**self).write_u64(i) + } + fn write_u128(&mut self, i: u128) { + (**self).write_u128(i) + } + fn write_usize(&mut self, i: usize) { + (**self).write_usize(i) + } + fn write_i8(&mut self, i: i8) { + (**self).write_i8(i) + } + fn write_i16(&mut self, i: i16) { + (**self).write_i16(i) + } + fn write_i32(&mut self, i: i32) { + (**self).write_i32(i) + } + fn write_i64(&mut self, i: i64) { + (**self).write_i64(i) + } + fn write_i128(&mut self, i: i128) { + (**self).write_i128(i) + } + fn write_isize(&mut self, i: isize) { + (**self).write_isize(i) + } +} + +#[stable(feature = "from_for_ptrs", since = "1.6.0")] +impl From for Box { + /// Converts a generic type `T` into a `Box` + /// + /// The conversion allocates on the heap and moves `t` + /// from the stack into it. + /// + /// # Examples + /// ```rust + /// let x = 5; + /// let boxed = Box::new(5); + /// + /// assert_eq!(Box::from(x), boxed); + /// ``` + fn from(t: T) -> Self { + Box::new(t) + } +} + +#[stable(feature = "pin", since = "1.33.0")] +impl From> for Pin> { + /// Converts a `Box` into a `Pin>` + /// + /// This conversion does not allocate on the heap and happens in place. + fn from(boxed: Box) -> Self { + Box::into_pin(boxed) + } +} + +#[stable(feature = "box_from_slice", since = "1.17.0")] +impl From<&[T]> for Box<[T]> { + /// Converts a `&[T]` into a `Box<[T]>` + /// + /// This conversion allocates on the heap + /// and performs a copy of `slice`. + /// + /// # Examples + /// ```rust + /// // create a &[u8] which will be used to create a Box<[u8]> + /// let slice: &[u8] = &[104, 101, 108, 108, 111]; + /// let boxed_slice: Box<[u8]> = Box::from(slice); + /// + /// println!("{:?}", boxed_slice); + /// ``` + fn from(slice: &[T]) -> Box<[T]> { + let len = slice.len(); + let buf = RawVec::with_capacity(len); + unsafe { + ptr::copy_nonoverlapping(slice.as_ptr(), buf.ptr(), len); + buf.into_box(slice.len()).assume_init() + } + } +} + +#[stable(feature = "box_from_cow", since = "1.45.0")] +impl From> for Box<[T]> { + #[inline] + fn from(cow: Cow<'_, [T]>) -> Box<[T]> { + match cow { + Cow::Borrowed(slice) => Box::from(slice), + Cow::Owned(slice) => Box::from(slice), + } + } +} + +#[stable(feature = "box_from_slice", since = "1.17.0")] +impl From<&str> for Box { + /// Converts a `&str` into a `Box` + /// + /// This conversion allocates on the heap + /// and performs a copy of `s`. + /// + /// # Examples + /// ```rust + /// let boxed: Box = Box::from("hello"); + /// println!("{}", boxed); + /// ``` + #[inline] + fn from(s: &str) -> Box { + unsafe { from_boxed_utf8_unchecked(Box::from(s.as_bytes())) } + } +} + +#[stable(feature = "box_from_cow", since = "1.45.0")] +impl From> for Box { + #[inline] + fn from(cow: Cow<'_, str>) -> Box { + match cow { + Cow::Borrowed(s) => Box::from(s), + Cow::Owned(s) => Box::from(s), + } + } +} + +#[stable(feature = "boxed_str_conv", since = "1.19.0")] +impl From> for Box<[u8], A> { + /// Converts a `Box` into a `Box<[u8]>` + /// + /// This conversion does not allocate on the heap and happens in place. + /// + /// # Examples + /// ```rust + /// // create a Box which will be used to create a Box<[u8]> + /// let boxed: Box = Box::from("hello"); + /// let boxed_str: Box<[u8]> = Box::from(boxed); + /// + /// // create a &[u8] which will be used to create a Box<[u8]> + /// let slice: &[u8] = &[104, 101, 108, 108, 111]; + /// let boxed_slice = Box::from(slice); + /// + /// assert_eq!(boxed_slice, boxed_str); + /// ``` + #[inline] + fn from(s: Box) -> Self { + let (raw, alloc) = Box::into_raw_with_alloc(s); + unsafe { Box::from_raw_in(raw as *mut [u8], alloc) } + } +} + +#[stable(feature = "box_from_array", since = "1.45.0")] +impl From<[T; N]> for Box<[T]> { + /// Converts a `[T; N]` into a `Box<[T]>` + /// + /// This conversion moves the array to newly heap-allocated memory. + /// + /// # Examples + /// ```rust + /// let boxed: Box<[u8]> = Box::from([4, 2]); + /// println!("{:?}", boxed); + /// ``` + fn from(array: [T; N]) -> Box<[T]> { + box array + } +} + +#[stable(feature = "boxed_slice_try_from", since = "1.43.0")] +impl TryFrom> for Box<[T; N]> { + type Error = Box<[T]>; + + fn try_from(boxed_slice: Box<[T]>) -> Result { + if boxed_slice.len() == N { + Ok(unsafe { Box::from_raw(Box::into_raw(boxed_slice) as *mut [T; N]) }) + } else { + Err(boxed_slice) + } + } +} + +impl Box { + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + /// Attempt to downcast the box to a concrete type. + /// + /// # Examples + /// + /// ``` + /// use std::any::Any; + /// + /// fn print_if_string(value: Box) { + /// if let Ok(string) = value.downcast::() { + /// println!("String ({}): {}", string.len(), string); + /// } + /// } + /// + /// let my_string = "Hello World".to_string(); + /// print_if_string(Box::new(my_string)); + /// print_if_string(Box::new(0i8)); + /// ``` + pub fn downcast(self) -> Result, Self> { + if self.is::() { + unsafe { + let (raw, alloc): (*mut dyn Any, _) = Box::into_raw_with_alloc(self); + Ok(Box::from_raw_in(raw as *mut T, alloc)) + } + } else { + Err(self) + } + } +} + +impl Box { + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + /// Attempt to downcast the box to a concrete type. + /// + /// # Examples + /// + /// ``` + /// use std::any::Any; + /// + /// fn print_if_string(value: Box) { + /// if let Ok(string) = value.downcast::() { + /// println!("String ({}): {}", string.len(), string); + /// } + /// } + /// + /// let my_string = "Hello World".to_string(); + /// print_if_string(Box::new(my_string)); + /// print_if_string(Box::new(0i8)); + /// ``` + pub fn downcast(self) -> Result, Self> { + if self.is::() { + unsafe { + let (raw, alloc): (*mut (dyn Any + Send), _) = Box::into_raw_with_alloc(self); + Ok(Box::from_raw_in(raw as *mut T, alloc)) + } + } else { + Err(self) + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Display for Box { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Display::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Debug for Box { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Debug::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Pointer for Box { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + // It's not possible to extract the inner Uniq directly from the Box, + // instead we cast it to a *const which aliases the Unique + let ptr: *const T = &**self; + fmt::Pointer::fmt(&ptr, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Deref for Box { + type Target = T; + + fn deref(&self) -> &T { + &**self + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl DerefMut for Box { + fn deref_mut(&mut self) -> &mut T { + &mut **self + } +} + +#[unstable(feature = "receiver_trait", issue = "none")] +impl Receiver for Box {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Iterator for Box { + type Item = I::Item; + fn next(&mut self) -> Option { + (**self).next() + } + fn size_hint(&self) -> (usize, Option) { + (**self).size_hint() + } + fn nth(&mut self, n: usize) -> Option { + (**self).nth(n) + } + fn last(self) -> Option { + BoxIter::last(self) + } +} + +trait BoxIter { + type Item; + fn last(self) -> Option; +} + +impl BoxIter for Box { + type Item = I::Item; + default fn last(self) -> Option { + #[inline] + fn some(_: Option, x: T) -> Option { + Some(x) + } + + self.fold(None, some) + } +} + +/// Specialization for sized `I`s that uses `I`s implementation of `last()` +/// instead of the default. +#[stable(feature = "rust1", since = "1.0.0")] +impl BoxIter for Box { + fn last(self) -> Option { + (*self).last() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl DoubleEndedIterator for Box { + fn next_back(&mut self) -> Option { + (**self).next_back() + } + fn nth_back(&mut self, n: usize) -> Option { + (**self).nth_back(n) + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for Box { + fn len(&self) -> usize { + (**self).len() + } + fn is_empty(&self) -> bool { + (**self).is_empty() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Box {} + +#[stable(feature = "boxed_closure_impls", since = "1.35.0")] +impl + ?Sized, A: AllocRef> FnOnce for Box { + type Output = >::Output; + + extern "rust-call" fn call_once(self, args: Args) -> Self::Output { + >::call_once(*self, args) + } +} + +#[stable(feature = "boxed_closure_impls", since = "1.35.0")] +impl + ?Sized, A: AllocRef> FnMut for Box { + extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output { + >::call_mut(self, args) + } +} + +#[stable(feature = "boxed_closure_impls", since = "1.35.0")] +impl + ?Sized, A: AllocRef> Fn for Box { + extern "rust-call" fn call(&self, args: Args) -> Self::Output { + >::call(self, args) + } +} + +#[unstable(feature = "coerce_unsized", issue = "27732")] +impl, U: ?Sized, A: AllocRef> CoerceUnsized> for Box {} + +#[unstable(feature = "dispatch_from_dyn", issue = "none")] +impl, U: ?Sized> DispatchFromDyn> for Box {} + +#[stable(feature = "boxed_slice_from_iter", since = "1.32.0")] +impl FromIterator for Box<[I]> { + fn from_iter>(iter: T) -> Self { + iter.into_iter().collect::>().into_boxed_slice() + } +} + +#[stable(feature = "box_slice_clone", since = "1.3.0")] +impl Clone for Box<[T]> { + fn clone(&self) -> Self { + self.to_vec().into_boxed_slice() + } + + fn clone_from(&mut self, other: &Self) { + if self.len() == other.len() { + self.clone_from_slice(&other); + } else { + *self = other.clone(); + } + } +} + +#[stable(feature = "box_borrow", since = "1.1.0")] +impl borrow::Borrow for Box { + fn borrow(&self) -> &T { + &**self + } +} + +#[stable(feature = "box_borrow", since = "1.1.0")] +impl borrow::BorrowMut for Box { + fn borrow_mut(&mut self) -> &mut T { + &mut **self + } +} + +#[stable(since = "1.5.0", feature = "smart_ptr_as_ref")] +impl AsRef for Box { + fn as_ref(&self) -> &T { + &**self + } +} + +#[stable(since = "1.5.0", feature = "smart_ptr_as_ref")] +impl AsMut for Box { + fn as_mut(&mut self) -> &mut T { + &mut **self + } +} + +/* Nota bene + * + * We could have chosen not to add this impl, and instead have written a + * function of Pin> to Pin. Such a function would not be sound, + * because Box implements Unpin even when T does not, as a result of + * this impl. + * + * We chose this API instead of the alternative for a few reasons: + * - Logically, it is helpful to understand pinning in regard to the + * memory region being pointed to. For this reason none of the + * standard library pointer types support projecting through a pin + * (Box is the only pointer type in std for which this would be + * safe.) + * - It is in practice very useful to have Box be unconditionally + * Unpin because of trait objects, for which the structural auto + * trait functionality does not apply (e.g., Box would + * otherwise not be Unpin). + * + * Another type with the same semantics as Box but only a conditional + * implementation of `Unpin` (where `T: Unpin`) would be valid/safe, and + * could have a method to project a Pin from it. + */ +#[stable(feature = "pin", since = "1.33.0")] +impl Unpin for Box {} + +#[unstable(feature = "generator_trait", issue = "43122")] +impl + Unpin, R, A: AllocRef> Generator for Box { + type Yield = G::Yield; + type Return = G::Return; + + fn resume(mut self: Pin<&mut Self>, arg: R) -> GeneratorState { + G::resume(Pin::new(&mut *self), arg) + } +} + +#[unstable(feature = "generator_trait", issue = "43122")] +impl, R, A: AllocRef> Generator for Pin> { + type Yield = G::Yield; + type Return = G::Return; + + fn resume(mut self: Pin<&mut Self>, arg: R) -> GeneratorState { + G::resume((*self).as_mut(), arg) + } +} + +#[stable(feature = "futures_api", since = "1.36.0")] +impl Future for Box { + type Output = F::Output; + + fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + F::poll(Pin::new(&mut *self), cx) + } +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/binary_heap.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/binary_heap.rs new file mode 100644 index 000000000000..01f454f5abe4 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/binary_heap.rs @@ -0,0 +1,1486 @@ +//! A priority queue implemented with a binary heap. +//! +//! Insertion and popping the largest element have *O*(log(*n*)) time complexity. +//! Checking the largest element is *O*(1). Converting a vector to a binary heap +//! can be done in-place, and has *O*(*n*) complexity. A binary heap can also be +//! converted to a sorted vector in-place, allowing it to be used for an *O*(*n* \* log(*n*)) +//! in-place heapsort. +//! +//! # Examples +//! +//! This is a larger example that implements [Dijkstra's algorithm][dijkstra] +//! to solve the [shortest path problem][sssp] on a [directed graph][dir_graph]. +//! It shows how to use [`BinaryHeap`] with custom types. +//! +//! [dijkstra]: https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm +//! [sssp]: https://en.wikipedia.org/wiki/Shortest_path_problem +//! [dir_graph]: https://en.wikipedia.org/wiki/Directed_graph +//! +//! ``` +//! use std::cmp::Ordering; +//! use std::collections::BinaryHeap; +//! +//! #[derive(Copy, Clone, Eq, PartialEq)] +//! struct State { +//! cost: usize, +//! position: usize, +//! } +//! +//! // The priority queue depends on `Ord`. +//! // Explicitly implement the trait so the queue becomes a min-heap +//! // instead of a max-heap. +//! impl Ord for State { +//! fn cmp(&self, other: &Self) -> Ordering { +//! // Notice that the we flip the ordering on costs. +//! // In case of a tie we compare positions - this step is necessary +//! // to make implementations of `PartialEq` and `Ord` consistent. +//! other.cost.cmp(&self.cost) +//! .then_with(|| self.position.cmp(&other.position)) +//! } +//! } +//! +//! // `PartialOrd` needs to be implemented as well. +//! impl PartialOrd for State { +//! fn partial_cmp(&self, other: &Self) -> Option { +//! Some(self.cmp(other)) +//! } +//! } +//! +//! // Each node is represented as an `usize`, for a shorter implementation. +//! struct Edge { +//! node: usize, +//! cost: usize, +//! } +//! +//! // Dijkstra's shortest path algorithm. +//! +//! // Start at `start` and use `dist` to track the current shortest distance +//! // to each node. This implementation isn't memory-efficient as it may leave duplicate +//! // nodes in the queue. It also uses `usize::MAX` as a sentinel value, +//! // for a simpler implementation. +//! fn shortest_path(adj_list: &Vec>, start: usize, goal: usize) -> Option { +//! // dist[node] = current shortest distance from `start` to `node` +//! let mut dist: Vec<_> = (0..adj_list.len()).map(|_| usize::MAX).collect(); +//! +//! let mut heap = BinaryHeap::new(); +//! +//! // We're at `start`, with a zero cost +//! dist[start] = 0; +//! heap.push(State { cost: 0, position: start }); +//! +//! // Examine the frontier with lower cost nodes first (min-heap) +//! while let Some(State { cost, position }) = heap.pop() { +//! // Alternatively we could have continued to find all shortest paths +//! if position == goal { return Some(cost); } +//! +//! // Important as we may have already found a better way +//! if cost > dist[position] { continue; } +//! +//! // For each node we can reach, see if we can find a way with +//! // a lower cost going through this node +//! for edge in &adj_list[position] { +//! let next = State { cost: cost + edge.cost, position: edge.node }; +//! +//! // If so, add it to the frontier and continue +//! if next.cost < dist[next.position] { +//! heap.push(next); +//! // Relaxation, we have now found a better way +//! dist[next.position] = next.cost; +//! } +//! } +//! } +//! +//! // Goal not reachable +//! None +//! } +//! +//! fn main() { +//! // This is the directed graph we're going to use. +//! // The node numbers correspond to the different states, +//! // and the edge weights symbolize the cost of moving +//! // from one node to another. +//! // Note that the edges are one-way. +//! // +//! // 7 +//! // +-----------------+ +//! // | | +//! // v 1 2 | 2 +//! // 0 -----> 1 -----> 3 ---> 4 +//! // | ^ ^ ^ +//! // | | 1 | | +//! // | | | 3 | 1 +//! // +------> 2 -------+ | +//! // 10 | | +//! // +---------------+ +//! // +//! // The graph is represented as an adjacency list where each index, +//! // corresponding to a node value, has a list of outgoing edges. +//! // Chosen for its efficiency. +//! let graph = vec![ +//! // Node 0 +//! vec![Edge { node: 2, cost: 10 }, +//! Edge { node: 1, cost: 1 }], +//! // Node 1 +//! vec![Edge { node: 3, cost: 2 }], +//! // Node 2 +//! vec![Edge { node: 1, cost: 1 }, +//! Edge { node: 3, cost: 3 }, +//! Edge { node: 4, cost: 1 }], +//! // Node 3 +//! vec![Edge { node: 0, cost: 7 }, +//! Edge { node: 4, cost: 2 }], +//! // Node 4 +//! vec![]]; +//! +//! assert_eq!(shortest_path(&graph, 0, 1), Some(1)); +//! assert_eq!(shortest_path(&graph, 0, 3), Some(3)); +//! assert_eq!(shortest_path(&graph, 3, 0), Some(7)); +//! assert_eq!(shortest_path(&graph, 0, 4), Some(5)); +//! assert_eq!(shortest_path(&graph, 4, 0), None); +//! } +//! ``` + +#![allow(missing_docs)] +#![stable(feature = "rust1", since = "1.0.0")] + +use crate::gccrs_core_prelude::*; + +use core::fmt; +use core::iter::{FromIterator, FusedIterator, InPlaceIterable, SourceIter, TrustedLen}; +use core::mem::{self, swap, ManuallyDrop}; +use core::ops::{Deref, DerefMut}; +use core::ptr; + +use crate::slice; +use crate::vec::{self, AsIntoIter, Vec}; + +use super::SpecExtend; + +/// A priority queue implemented with a binary heap. +/// +/// This will be a max-heap. +/// +/// It is a logic error for an item to be modified in such a way that the +/// item's ordering relative to any other item, as determined by the `Ord` +/// trait, changes while it is in the heap. This is normally only possible +/// through `Cell`, `RefCell`, global state, I/O, or unsafe code. +/// +/// # Examples +/// +/// ``` +/// use std::collections::BinaryHeap; +/// +/// // Type inference lets us omit an explicit type signature (which +/// // would be `BinaryHeap` in this example). +/// let mut heap = BinaryHeap::new(); +/// +/// // We can use peek to look at the next item in the heap. In this case, +/// // there's no items in there yet so we get None. +/// assert_eq!(heap.peek(), None); +/// +/// // Let's add some scores... +/// heap.push(1); +/// heap.push(5); +/// heap.push(2); +/// +/// // Now peek shows the most important item in the heap. +/// assert_eq!(heap.peek(), Some(&5)); +/// +/// // We can check the length of a heap. +/// assert_eq!(heap.len(), 3); +/// +/// // We can iterate over the items in the heap, although they are returned in +/// // a random order. +/// for x in &heap { +/// println!("{}", x); +/// } +/// +/// // If we instead pop these scores, they should come back in order. +/// assert_eq!(heap.pop(), Some(5)); +/// assert_eq!(heap.pop(), Some(2)); +/// assert_eq!(heap.pop(), Some(1)); +/// assert_eq!(heap.pop(), None); +/// +/// // We can clear the heap of any remaining items. +/// heap.clear(); +/// +/// // The heap should now be empty. +/// assert!(heap.is_empty()) +/// ``` +/// +/// ## Min-heap +/// +/// Either `std::cmp::Reverse` or a custom `Ord` implementation can be used to +/// make `BinaryHeap` a min-heap. This makes `heap.pop()` return the smallest +/// value instead of the greatest one. +/// +/// ``` +/// use std::collections::BinaryHeap; +/// use std::cmp::Reverse; +/// +/// let mut heap = BinaryHeap::new(); +/// +/// // Wrap values in `Reverse` +/// heap.push(Reverse(1)); +/// heap.push(Reverse(5)); +/// heap.push(Reverse(2)); +/// +/// // If we pop these scores now, they should come back in the reverse order. +/// assert_eq!(heap.pop(), Some(Reverse(1))); +/// assert_eq!(heap.pop(), Some(Reverse(2))); +/// assert_eq!(heap.pop(), Some(Reverse(5))); +/// assert_eq!(heap.pop(), None); +/// ``` +/// +/// # Time complexity +/// +/// | [push] | [pop] | [peek]/[peek\_mut] | +/// |--------|-----------|--------------------| +/// | O(1)~ | *O*(log(*n*)) | *O*(1) | +/// +/// The value for `push` is an expected cost; the method documentation gives a +/// more detailed analysis. +/// +/// [push]: BinaryHeap::push +/// [pop]: BinaryHeap::pop +/// [peek]: BinaryHeap::peek +/// [peek\_mut]: BinaryHeap::peek_mut +#[stable(feature = "rust1", since = "1.0.0")] +pub struct BinaryHeap { + data: Vec, +} + +/// Structure wrapping a mutable reference to the greatest item on a +/// `BinaryHeap`. +/// +/// This `struct` is created by the [`peek_mut`] method on [`BinaryHeap`]. See +/// its documentation for more. +/// +/// [`peek_mut`]: BinaryHeap::peek_mut +#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")] +pub struct PeekMut<'a, T: 'a + Ord> { + heap: &'a mut BinaryHeap, + sift: bool, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for PeekMut<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("PeekMut").field(&self.heap.data[0]).finish() + } +} + +#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")] +impl Drop for PeekMut<'_, T> { + fn drop(&mut self) { + if self.sift { + self.heap.sift_down(0); + } + } +} + +#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")] +impl Deref for PeekMut<'_, T> { + type Target = T; + fn deref(&self) -> &T { + debug_assert!(!self.heap.is_empty()); + // SAFE: PeekMut is only instantiated for non-empty heaps + unsafe { self.heap.data.get_unchecked(0) } + } +} + +#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")] +impl DerefMut for PeekMut<'_, T> { + fn deref_mut(&mut self) -> &mut T { + debug_assert!(!self.heap.is_empty()); + self.sift = true; + // SAFE: PeekMut is only instantiated for non-empty heaps + unsafe { self.heap.data.get_unchecked_mut(0) } + } +} + +impl<'a, T: Ord> PeekMut<'a, T> { + /// Removes the peeked value from the heap and returns it. + #[stable(feature = "binary_heap_peek_mut_pop", since = "1.18.0")] + pub fn pop(mut this: PeekMut<'a, T>) -> T { + let value = this.heap.pop().unwrap(); + this.sift = false; + value + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for BinaryHeap { + fn clone(&self) -> Self { + BinaryHeap { + data: self.data.clone(), + } + } + + fn clone_from(&mut self, source: &Self) { + self.data.clone_from(&source.data); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for BinaryHeap { + /// Creates an empty `BinaryHeap`. + #[inline] + fn default() -> BinaryHeap { + BinaryHeap::new() + } +} + +#[stable(feature = "binaryheap_debug", since = "1.4.0")] +impl fmt::Debug for BinaryHeap { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.iter()).finish() + } +} + +impl BinaryHeap { + /// Creates an empty `BinaryHeap` as a max-heap. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::new(); + /// heap.push(4); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn new() -> BinaryHeap { + BinaryHeap { data: vec![] } + } + + /// Creates an empty `BinaryHeap` with a specific capacity. + /// This preallocates enough memory for `capacity` elements, + /// so that the `BinaryHeap` does not have to be reallocated + /// until it contains at least that many values. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::with_capacity(10); + /// heap.push(4); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn with_capacity(capacity: usize) -> BinaryHeap { + BinaryHeap { + data: Vec::with_capacity(capacity), + } + } + + /// Returns a mutable reference to the greatest item in the binary heap, or + /// `None` if it is empty. + /// + /// Note: If the `PeekMut` value is leaked, the heap may be in an + /// inconsistent state. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::new(); + /// assert!(heap.peek_mut().is_none()); + /// + /// heap.push(1); + /// heap.push(5); + /// heap.push(2); + /// { + /// let mut val = heap.peek_mut().unwrap(); + /// *val = 0; + /// } + /// assert_eq!(heap.peek(), Some(&2)); + /// ``` + /// + /// # Time complexity + /// + /// If the item is modified then the worst case time complexity is *O*(log(*n*)), + /// otherwise it's *O*(1). + #[stable(feature = "binary_heap_peek_mut", since = "1.12.0")] + pub fn peek_mut(&mut self) -> Option> { + if self.is_empty() { + None + } else { + Some(PeekMut { + heap: self, + sift: false, + }) + } + } + + /// Removes the greatest item from the binary heap and returns it, or `None` if it + /// is empty. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::from(vec![1, 3]); + /// + /// assert_eq!(heap.pop(), Some(3)); + /// assert_eq!(heap.pop(), Some(1)); + /// assert_eq!(heap.pop(), None); + /// ``` + /// + /// # Time complexity + /// + /// The worst case cost of `pop` on a heap containing *n* elements is *O*(log(*n*)). + #[stable(feature = "rust1", since = "1.0.0")] + pub fn pop(&mut self) -> Option { + self.data.pop().map(|mut item| { + if !self.is_empty() { + swap(&mut item, &mut self.data[0]); + self.sift_down_to_bottom(0); + } + item + }) + } + + /// Pushes an item onto the binary heap. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::new(); + /// heap.push(3); + /// heap.push(5); + /// heap.push(1); + /// + /// assert_eq!(heap.len(), 3); + /// assert_eq!(heap.peek(), Some(&5)); + /// ``` + /// + /// # Time complexity + /// + /// The expected cost of `push`, averaged over every possible ordering of + /// the elements being pushed, and over a sufficiently large number of + /// pushes, is *O*(1). This is the most meaningful cost metric when pushing + /// elements that are *not* already in any sorted pattern. + /// + /// The time complexity degrades if elements are pushed in predominantly + /// ascending order. In the worst case, elements are pushed in ascending + /// sorted order and the amortized cost per push is *O*(log(*n*)) against a heap + /// containing *n* elements. + /// + /// The worst case cost of a *single* call to `push` is *O*(*n*). The worst case + /// occurs when capacity is exhausted and needs a resize. The resize cost + /// has been amortized in the previous figures. + #[stable(feature = "rust1", since = "1.0.0")] + pub fn push(&mut self, item: T) { + let old_len = self.len(); + self.data.push(item); + self.sift_up(0, old_len); + } + + /// Consumes the `BinaryHeap` and returns a vector in sorted + /// (ascending) order. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// + /// let mut heap = BinaryHeap::from(vec![1, 2, 4, 5, 7]); + /// heap.push(6); + /// heap.push(3); + /// + /// let vec = heap.into_sorted_vec(); + /// assert_eq!(vec, [1, 2, 3, 4, 5, 6, 7]); + /// ``` + #[stable(feature = "binary_heap_extras_15", since = "1.5.0")] + pub fn into_sorted_vec(mut self) -> Vec { + let mut end = self.len(); + while end > 1 { + end -= 1; + // SAFETY: `end` goes from `self.len() - 1` to 1 (both included), + // so it's always a valid index to access. + // It is safe to access index 0 (i.e. `ptr`), because + // 1 <= end < self.len(), which means self.len() >= 2. + unsafe { + let ptr = self.data.as_mut_ptr(); + ptr::swap(ptr, ptr.add(end)); + } + self.sift_down_range(0, end); + } + self.into_vec() + } + + // The implementations of sift_up and sift_down use unsafe blocks in + // order to move an element out of the vector (leaving behind a + // hole), shift along the others and move the removed element back into the + // vector at the final location of the hole. + // The `Hole` type is used to represent this, and make sure + // the hole is filled back at the end of its scope, even on panic. + // Using a hole reduces the constant factor compared to using swaps, + // which involves twice as many moves. + fn sift_up(&mut self, start: usize, pos: usize) -> usize { + unsafe { + // Take out the value at `pos` and create a hole. + let mut hole = Hole::new(&mut self.data, pos); + + while hole.pos() > start { + let parent = (hole.pos() - 1) / 2; + if hole.element() <= hole.get(parent) { + break; + } + hole.move_to(parent); + } + hole.pos() + } + } + + /// Take an element at `pos` and move it down the heap, + /// while its children are larger. + fn sift_down_range(&mut self, pos: usize, end: usize) { + unsafe { + let mut hole = Hole::new(&mut self.data, pos); + let mut child = 2 * pos + 1; + while child < end - 1 { + // compare with the greater of the two children + child += (hole.get(child) <= hole.get(child + 1)) as usize; + // if we are already in order, stop. + if hole.element() >= hole.get(child) { + return; + } + hole.move_to(child); + child = 2 * hole.pos() + 1; + } + if child == end - 1 && hole.element() < hole.get(child) { + hole.move_to(child); + } + } + } + + fn sift_down(&mut self, pos: usize) { + let len = self.len(); + self.sift_down_range(pos, len); + } + + /// Take an element at `pos` and move it all the way down the heap, + /// then sift it up to its position. + /// + /// Note: This is faster when the element is known to be large / should + /// be closer to the bottom. + fn sift_down_to_bottom(&mut self, mut pos: usize) { + let end = self.len(); + let start = pos; + unsafe { + let mut hole = Hole::new(&mut self.data, pos); + let mut child = 2 * pos + 1; + while child < end - 1 { + child += (hole.get(child) <= hole.get(child + 1)) as usize; + hole.move_to(child); + child = 2 * hole.pos() + 1; + } + if child == end - 1 { + hole.move_to(child); + } + pos = hole.pos; + } + self.sift_up(start, pos); + } + + fn rebuild(&mut self) { + let mut n = self.len() / 2; + while n > 0 { + n -= 1; + self.sift_down(n); + } + } + + /// Moves all the elements of `other` into `self`, leaving `other` empty. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// + /// let v = vec![-10, 1, 2, 3, 3]; + /// let mut a = BinaryHeap::from(v); + /// + /// let v = vec![-20, 5, 43]; + /// let mut b = BinaryHeap::from(v); + /// + /// a.append(&mut b); + /// + /// assert_eq!(a.into_sorted_vec(), [-20, -10, 1, 2, 3, 3, 5, 43]); + /// assert!(b.is_empty()); + /// ``` + #[stable(feature = "binary_heap_append", since = "1.11.0")] + pub fn append(&mut self, other: &mut Self) { + if self.len() < other.len() { + swap(self, other); + } + + if other.is_empty() { + return; + } + + #[inline(always)] + fn log2_fast(x: usize) -> usize { + (usize::BITS - x.leading_zeros() - 1) as usize + } + + // `rebuild` takes O(len1 + len2) operations + // and about 2 * (len1 + len2) comparisons in the worst case + // while `extend` takes O(len2 * log(len1)) operations + // and about 1 * len2 * log_2(len1) comparisons in the worst case, + // assuming len1 >= len2. + #[inline] + fn better_to_rebuild(len1: usize, len2: usize) -> bool { + 2 * (len1 + len2) < len2 * log2_fast(len1) + } + + if better_to_rebuild(self.len(), other.len()) { + self.data.append(&mut other.data); + self.rebuild(); + } else { + self.extend(other.drain()); + } + } + + /// Returns an iterator which retrieves elements in heap order. + /// The retrieved elements are removed from the original heap. + /// The remaining elements will be removed on drop in heap order. + /// + /// Note: + /// * `.drain_sorted()` is *O*(*n* \* log(*n*)); much slower than `.drain()`. + /// You should use the latter for most cases. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// #![feature(binary_heap_drain_sorted)] + /// use std::collections::BinaryHeap; + /// + /// let mut heap = BinaryHeap::from(vec![1, 2, 3, 4, 5]); + /// assert_eq!(heap.len(), 5); + /// + /// drop(heap.drain_sorted()); // removes all elements in heap order + /// assert_eq!(heap.len(), 0); + /// ``` + #[inline] + #[unstable(feature = "binary_heap_drain_sorted", issue = "59278")] + pub fn drain_sorted(&mut self) -> DrainSorted<'_, T> { + DrainSorted { inner: self } + } + + /// Retains only the elements specified by the predicate. + /// + /// In other words, remove all elements `e` such that `f(&e)` returns + /// `false`. The elements are visited in unsorted (and unspecified) order. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// #![feature(binary_heap_retain)] + /// use std::collections::BinaryHeap; + /// + /// let mut heap = BinaryHeap::from(vec![-10, -5, 1, 2, 4, 13]); + /// + /// heap.retain(|x| x % 2 == 0); // only keep even numbers + /// + /// assert_eq!(heap.into_sorted_vec(), [-10, 2, 4]) + /// ``` + #[unstable(feature = "binary_heap_retain", issue = "71503")] + pub fn retain(&mut self, f: F) + where + F: FnMut(&T) -> bool, + { + self.data.retain(f); + self.rebuild(); + } +} + +impl BinaryHeap { + /// Returns an iterator visiting all values in the underlying vector, in + /// arbitrary order. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let heap = BinaryHeap::from(vec![1, 2, 3, 4]); + /// + /// // Print 1, 2, 3, 4 in arbitrary order + /// for x in heap.iter() { + /// println!("{}", x); + /// } + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn iter(&self) -> Iter<'_, T> { + Iter { + iter: self.data.iter(), + } + } + + /// Returns an iterator which retrieves elements in heap order. + /// This method consumes the original heap. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// #![feature(binary_heap_into_iter_sorted)] + /// use std::collections::BinaryHeap; + /// let heap = BinaryHeap::from(vec![1, 2, 3, 4, 5]); + /// + /// assert_eq!(heap.into_iter_sorted().take(2).collect::>(), vec![5, 4]); + /// ``` + #[unstable(feature = "binary_heap_into_iter_sorted", issue = "59278")] + pub fn into_iter_sorted(self) -> IntoIterSorted { + IntoIterSorted { inner: self } + } + + /// Returns the greatest item in the binary heap, or `None` if it is empty. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::new(); + /// assert_eq!(heap.peek(), None); + /// + /// heap.push(1); + /// heap.push(5); + /// heap.push(2); + /// assert_eq!(heap.peek(), Some(&5)); + /// + /// ``` + /// + /// # Time complexity + /// + /// Cost is *O*(1) in the worst case. + #[stable(feature = "rust1", since = "1.0.0")] + pub fn peek(&self) -> Option<&T> { + self.data.get(0) + } + + /// Returns the number of elements the binary heap can hold without reallocating. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::with_capacity(100); + /// assert!(heap.capacity() >= 100); + /// heap.push(4); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn capacity(&self) -> usize { + self.data.capacity() + } + + /// Reserves the minimum capacity for exactly `additional` more elements to be inserted in the + /// given `BinaryHeap`. Does nothing if the capacity is already sufficient. + /// + /// Note that the allocator may give the collection more space than it requests. Therefore + /// capacity can not be relied upon to be precisely minimal. Prefer [`reserve`] if future + /// insertions are expected. + /// + /// # Panics + /// + /// Panics if the new capacity overflows `usize`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::new(); + /// heap.reserve_exact(100); + /// assert!(heap.capacity() >= 100); + /// heap.push(4); + /// ``` + /// + /// [`reserve`]: BinaryHeap::reserve + #[stable(feature = "rust1", since = "1.0.0")] + pub fn reserve_exact(&mut self, additional: usize) { + self.data.reserve_exact(additional); + } + + /// Reserves capacity for at least `additional` more elements to be inserted in the + /// `BinaryHeap`. The collection may reserve more space to avoid frequent reallocations. + /// + /// # Panics + /// + /// Panics if the new capacity overflows `usize`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::new(); + /// heap.reserve(100); + /// assert!(heap.capacity() >= 100); + /// heap.push(4); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn reserve(&mut self, additional: usize) { + self.data.reserve(additional); + } + + /// Discards as much additional capacity as possible. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap: BinaryHeap = BinaryHeap::with_capacity(100); + /// + /// assert!(heap.capacity() >= 100); + /// heap.shrink_to_fit(); + /// assert!(heap.capacity() == 0); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn shrink_to_fit(&mut self) { + self.data.shrink_to_fit(); + } + + /// Discards capacity with a lower bound. + /// + /// The capacity will remain at least as large as both the length + /// and the supplied value. + /// + /// Panics if the current capacity is smaller than the supplied + /// minimum capacity. + /// + /// # Examples + /// + /// ``` + /// #![feature(shrink_to)] + /// use std::collections::BinaryHeap; + /// let mut heap: BinaryHeap = BinaryHeap::with_capacity(100); + /// + /// assert!(heap.capacity() >= 100); + /// heap.shrink_to(10); + /// assert!(heap.capacity() >= 10); + /// ``` + #[inline] + #[unstable(feature = "shrink_to", reason = "new API", issue = "56431")] + pub fn shrink_to(&mut self, min_capacity: usize) { + self.data.shrink_to(min_capacity) + } + + /// Consumes the `BinaryHeap` and returns the underlying vector + /// in arbitrary order. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let heap = BinaryHeap::from(vec![1, 2, 3, 4, 5, 6, 7]); + /// let vec = heap.into_vec(); + /// + /// // Will print in some order + /// for x in vec { + /// println!("{}", x); + /// } + /// ``` + #[stable(feature = "binary_heap_extras_15", since = "1.5.0")] + pub fn into_vec(self) -> Vec { + self.into() + } + + /// Returns the length of the binary heap. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let heap = BinaryHeap::from(vec![1, 3]); + /// + /// assert_eq!(heap.len(), 2); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn len(&self) -> usize { + self.data.len() + } + + /// Checks if the binary heap is empty. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::new(); + /// + /// assert!(heap.is_empty()); + /// + /// heap.push(3); + /// heap.push(5); + /// heap.push(1); + /// + /// assert!(!heap.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// Clears the binary heap, returning an iterator over the removed elements. + /// + /// The elements are removed in arbitrary order. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::from(vec![1, 3]); + /// + /// assert!(!heap.is_empty()); + /// + /// for x in heap.drain() { + /// println!("{}", x); + /// } + /// + /// assert!(heap.is_empty()); + /// ``` + #[inline] + #[stable(feature = "drain", since = "1.6.0")] + pub fn drain(&mut self) -> Drain<'_, T> { + Drain { + iter: self.data.drain(..), + } + } + + /// Drops all items from the binary heap. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let mut heap = BinaryHeap::from(vec![1, 3]); + /// + /// assert!(!heap.is_empty()); + /// + /// heap.clear(); + /// + /// assert!(heap.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn clear(&mut self) { + self.drain(); + } +} + +/// Hole represents a hole in a slice i.e., an index without valid value +/// (because it was moved from or duplicated). +/// In drop, `Hole` will restore the slice by filling the hole +/// position with the value that was originally removed. +struct Hole<'a, T: 'a> { + data: &'a mut [T], + elt: ManuallyDrop, + pos: usize, +} + +impl<'a, T> Hole<'a, T> { + /// Create a new `Hole` at index `pos`. + /// + /// Unsafe because pos must be within the data slice. + #[inline] + unsafe fn new(data: &'a mut [T], pos: usize) -> Self { + debug_assert!(pos < data.len()); + // SAFE: pos should be inside the slice + let elt = unsafe { ptr::read(data.get_unchecked(pos)) }; + Hole { + data, + elt: ManuallyDrop::new(elt), + pos, + } + } + + #[inline] + fn pos(&self) -> usize { + self.pos + } + + /// Returns a reference to the element removed. + #[inline] + fn element(&self) -> &T { + &self.elt + } + + /// Returns a reference to the element at `index`. + /// + /// Unsafe because index must be within the data slice and not equal to pos. + #[inline] + unsafe fn get(&self, index: usize) -> &T { + debug_assert!(index != self.pos); + debug_assert!(index < self.data.len()); + unsafe { self.data.get_unchecked(index) } + } + + /// Move hole to new location + /// + /// Unsafe because index must be within the data slice and not equal to pos. + #[inline] + unsafe fn move_to(&mut self, index: usize) { + debug_assert!(index != self.pos); + debug_assert!(index < self.data.len()); + unsafe { + let ptr = self.data.as_mut_ptr(); + let index_ptr: *const _ = ptr.add(index); + let hole_ptr = ptr.add(self.pos); + ptr::copy_nonoverlapping(index_ptr, hole_ptr, 1); + } + self.pos = index; + } +} + +impl Drop for Hole<'_, T> { + #[inline] + fn drop(&mut self) { + // fill the hole again + unsafe { + let pos = self.pos; + ptr::copy_nonoverlapping(&*self.elt, self.data.get_unchecked_mut(pos), 1); + } + } +} + +/// An iterator over the elements of a `BinaryHeap`. +/// +/// This `struct` is created by [`BinaryHeap::iter()`]. See its +/// documentation for more. +/// +/// [`iter`]: BinaryHeap::iter +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Iter<'a, T: 'a> { + iter: slice::Iter<'a, T>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Iter<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Iter").field(&self.iter.as_slice()).finish() + } +} + +// FIXME(#26925) Remove in favor of `#[derive(Clone)]` +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Iter<'_, T> { + fn clone(&self) -> Self { + Iter { + iter: self.iter.clone(), + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> Iterator for Iter<'a, T> { + type Item = &'a T; + + #[inline] + fn next(&mut self) -> Option<&'a T> { + self.iter.next() + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } + + #[inline] + fn last(self) -> Option<&'a T> { + self.iter.last() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> DoubleEndedIterator for Iter<'a, T> { + #[inline] + fn next_back(&mut self) -> Option<&'a T> { + self.iter.next_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for Iter<'_, T> { + fn is_empty(&self) -> bool { + self.iter.is_empty() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Iter<'_, T> {} + +/// An owning iterator over the elements of a `BinaryHeap`. +/// +/// This `struct` is created by [`BinaryHeap::into_iter()`] +/// (provided by the `IntoIterator` trait). See its documentation for more. +/// +/// [`into_iter`]: BinaryHeap::into_iter +#[stable(feature = "rust1", since = "1.0.0")] +#[derive(Clone)] +pub struct IntoIter { + iter: vec::IntoIter, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for IntoIter { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("IntoIter") + .field(&self.iter.as_slice()) + .finish() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Iterator for IntoIter { + type Item = T; + + #[inline] + fn next(&mut self) -> Option { + self.iter.next() + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl DoubleEndedIterator for IntoIter { + #[inline] + fn next_back(&mut self) -> Option { + self.iter.next_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for IntoIter { + fn is_empty(&self) -> bool { + self.iter.is_empty() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for IntoIter {} + +#[unstable(issue = "none", feature = "inplace_iteration")] +unsafe impl SourceIter for IntoIter { + type Source = IntoIter; + + #[inline] + unsafe fn as_inner(&mut self) -> &mut Self::Source { + self + } +} + +#[unstable(issue = "none", feature = "inplace_iteration")] +unsafe impl InPlaceIterable for IntoIter {} + +impl AsIntoIter for IntoIter { + type Item = I; + + fn as_into_iter(&mut self) -> &mut vec::IntoIter { + &mut self.iter + } +} + +#[unstable(feature = "binary_heap_into_iter_sorted", issue = "59278")] +#[derive(Clone, Debug)] +pub struct IntoIterSorted { + inner: BinaryHeap, +} + +#[unstable(feature = "binary_heap_into_iter_sorted", issue = "59278")] +impl Iterator for IntoIterSorted { + type Item = T; + + #[inline] + fn next(&mut self) -> Option { + self.inner.pop() + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + let exact = self.inner.len(); + (exact, Some(exact)) + } +} + +#[unstable(feature = "binary_heap_into_iter_sorted", issue = "59278")] +impl ExactSizeIterator for IntoIterSorted {} + +#[unstable(feature = "binary_heap_into_iter_sorted", issue = "59278")] +impl FusedIterator for IntoIterSorted {} + +#[unstable(feature = "trusted_len", issue = "37572")] +unsafe impl TrustedLen for IntoIterSorted {} + +/// A draining iterator over the elements of a `BinaryHeap`. +/// +/// This `struct` is created by [`BinaryHeap::drain()`]. See its +/// documentation for more. +/// +/// [`drain`]: BinaryHeap::drain +#[stable(feature = "drain", since = "1.6.0")] +#[derive(Debug)] +pub struct Drain<'a, T: 'a> { + iter: vec::Drain<'a, T>, +} + +#[stable(feature = "drain", since = "1.6.0")] +impl Iterator for Drain<'_, T> { + type Item = T; + + #[inline] + fn next(&mut self) -> Option { + self.iter.next() + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } +} + +#[stable(feature = "drain", since = "1.6.0")] +impl DoubleEndedIterator for Drain<'_, T> { + #[inline] + fn next_back(&mut self) -> Option { + self.iter.next_back() + } +} + +#[stable(feature = "drain", since = "1.6.0")] +impl ExactSizeIterator for Drain<'_, T> { + fn is_empty(&self) -> bool { + self.iter.is_empty() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Drain<'_, T> {} + +/// A draining iterator over the elements of a `BinaryHeap`. +/// +/// This `struct` is created by [`BinaryHeap::drain_sorted()`]. See its +/// documentation for more. +/// +/// [`drain_sorted`]: BinaryHeap::drain_sorted +#[unstable(feature = "binary_heap_drain_sorted", issue = "59278")] +#[derive(Debug)] +pub struct DrainSorted<'a, T: Ord> { + inner: &'a mut BinaryHeap, +} + +#[unstable(feature = "binary_heap_drain_sorted", issue = "59278")] +impl<'a, T: Ord> Drop for DrainSorted<'a, T> { + /// Removes heap elements in heap order. + fn drop(&mut self) { + struct DropGuard<'r, 'a, T: Ord>(&'r mut DrainSorted<'a, T>); + + impl<'r, 'a, T: Ord> Drop for DropGuard<'r, 'a, T> { + fn drop(&mut self) { + while self.0.inner.pop().is_some() {} + } + } + + while let Some(item) = self.inner.pop() { + let guard = DropGuard(self); + drop(item); + mem::forget(guard); + } + } +} + +#[unstable(feature = "binary_heap_drain_sorted", issue = "59278")] +impl Iterator for DrainSorted<'_, T> { + type Item = T; + + #[inline] + fn next(&mut self) -> Option { + self.inner.pop() + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + let exact = self.inner.len(); + (exact, Some(exact)) + } +} + +#[unstable(feature = "binary_heap_drain_sorted", issue = "59278")] +impl ExactSizeIterator for DrainSorted<'_, T> {} + +#[unstable(feature = "binary_heap_drain_sorted", issue = "59278")] +impl FusedIterator for DrainSorted<'_, T> {} + +#[unstable(feature = "trusted_len", issue = "37572")] +unsafe impl TrustedLen for DrainSorted<'_, T> {} + +#[stable(feature = "binary_heap_extras_15", since = "1.5.0")] +impl From> for BinaryHeap { + /// Converts a `Vec` into a `BinaryHeap`. + /// + /// This conversion happens in-place, and has *O*(*n*) time complexity. + fn from(vec: Vec) -> BinaryHeap { + let mut heap = BinaryHeap { data: vec }; + heap.rebuild(); + heap + } +} + +#[stable(feature = "binary_heap_extras_15", since = "1.5.0")] +impl From> for Vec { + /// Converts a `BinaryHeap` into a `Vec`. + /// + /// This conversion requires no data movement or allocation, and has + /// constant time complexity. + fn from(heap: BinaryHeap) -> Vec { + heap.data + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl FromIterator for BinaryHeap { + fn from_iter>(iter: I) -> BinaryHeap { + BinaryHeap::from(iter.into_iter().collect::>()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl IntoIterator for BinaryHeap { + type Item = T; + type IntoIter = IntoIter; + + /// Creates a consuming iterator, that is, one that moves each value out of + /// the binary heap in arbitrary order. The binary heap cannot be used + /// after calling this. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BinaryHeap; + /// let heap = BinaryHeap::from(vec![1, 2, 3, 4]); + /// + /// // Print 1, 2, 3, 4 in arbitrary order + /// for x in heap.into_iter() { + /// // x has type i32, not &i32 + /// println!("{}", x); + /// } + /// ``` + fn into_iter(self) -> IntoIter { + IntoIter { + iter: self.data.into_iter(), + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> IntoIterator for &'a BinaryHeap { + type Item = &'a T; + type IntoIter = Iter<'a, T>; + + fn into_iter(self) -> Iter<'a, T> { + self.iter() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Extend for BinaryHeap { + #[inline] + fn extend>(&mut self, iter: I) { + >::spec_extend(self, iter); + } + + #[inline] + fn extend_one(&mut self, item: T) { + self.push(item); + } + + #[inline] + fn extend_reserve(&mut self, additional: usize) { + self.reserve(additional); + } +} + +impl> SpecExtend for BinaryHeap { + default fn spec_extend(&mut self, iter: I) { + self.extend_desugared(iter.into_iter()); + } +} + +impl SpecExtend> for BinaryHeap { + fn spec_extend(&mut self, ref mut other: BinaryHeap) { + self.append(other); + } +} + +impl BinaryHeap { + fn extend_desugared>(&mut self, iter: I) { + let iterator = iter.into_iter(); + let (lower, _) = iterator.size_hint(); + + self.reserve(lower); + + iterator.for_each(move |elem| self.push(elem)); + } +} + +#[stable(feature = "extend_ref", since = "1.2.0")] +impl<'a, T: 'a + Ord + Copy> Extend<&'a T> for BinaryHeap { + fn extend>(&mut self, iter: I) { + self.extend(iter.into_iter().cloned()); + } + + #[inline] + fn extend_one(&mut self, &item: &'a T) { + self.push(item); + } + + #[inline] + fn extend_reserve(&mut self, additional: usize) { + self.reserve(additional); + } +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/btree/append.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/append.rs new file mode 100644 index 000000000000..ab41e3a8d117 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/append.rs @@ -0,0 +1,126 @@ +use crate::gccrs_core_prelude::*; + +use super::map::MIN_LEN; +use super::merge_iter::MergeIterInner; +use super::node::{self, ForceResult::*, Root}; +use core::iter::FusedIterator; + +impl Root { + /// Appends all key-value pairs from the union of two ascending iterators, + /// incrementing a `length` variable along the way. The latter makes it + /// easier for the caller to avoid a leak when a drop handler panicks. + /// + /// If both iterators produce the same key, this method drops the pair from + /// the left iterator and appends the pair from the right iterator. + /// + /// If you want the tree to end up in a strictly ascending order, like for + /// a `BTreeMap`, both iterators should produce keys in strictly ascending + /// order, each greater than all keys in the tree, including any keys + /// already in the tree upon entry. + pub fn append_from_sorted_iters(&mut self, left: I, right: I, length: &mut usize) + where + K: Ord, + I: Iterator + FusedIterator, + { + // We prepare to merge `left` and `right` into a sorted sequence in linear time. + let iter = MergeIter(MergeIterInner::new(left, right)); + + // Meanwhile, we build a tree from the sorted sequence in linear time. + self.bulk_push(iter, length) + } + + /// Pushes all key-value pairs to the end of the tree, incrementing a + /// `length` variable along the way. The latter makes it easier for the + /// caller to avoid a leak when the iterator panicks. + fn bulk_push(&mut self, iter: I, length: &mut usize) + where + I: Iterator, + { + let mut cur_node = self.node_as_mut().last_leaf_edge().into_node(); + // Iterate through all key-value pairs, pushing them into nodes at the right level. + for (key, value) in iter { + // Try to push key-value pair into the current leaf node. + if cur_node.len() < node::CAPACITY { + cur_node.push(key, value); + } else { + // No space left, go up and push there. + let mut open_node; + let mut test_node = cur_node.forget_type(); + loop { + match test_node.ascend() { + Ok(parent) => { + let parent = parent.into_node(); + if parent.len() < node::CAPACITY { + // Found a node with space left, push here. + open_node = parent; + break; + } else { + // Go up again. + test_node = parent.forget_type(); + } + } + Err(_) => { + // We are at the top, create a new root node and push there. + open_node = self.push_internal_level(); + break; + } + } + } + + // Push key-value pair and new right subtree. + let tree_height = open_node.height() - 1; + let mut right_tree = Root::new_leaf(); + for _ in 0..tree_height { + right_tree.push_internal_level(); + } + open_node.push(key, value, right_tree); + + // Go down to the right-most leaf again. + cur_node = open_node.forget_type().last_leaf_edge().into_node(); + } + + // Increment length every iteration, to make sure the map drops + // the appended elements even if advancing the iterator panicks. + *length += 1; + } + self.fix_right_edge(); + } + + fn fix_right_edge(&mut self) { + // Handle underfull nodes, start from the top. + let mut cur_node = self.node_as_mut(); + while let Internal(internal) = cur_node.force() { + // Check if right-most child is underfull. + let mut last_edge = internal.last_edge(); + let right_child_len = last_edge.reborrow().descend().len(); + if right_child_len < MIN_LEN { + // We need to steal. + let mut last_kv = match last_edge.left_kv() { + Ok(left) => left, + Err(_) => unreachable!(), + }; + last_kv.bulk_steal_left(MIN_LEN - right_child_len); + last_edge = last_kv.right_edge(); + } + + // Go further down. + cur_node = last_edge.descend(); + } + } +} + +// An iterator for merging two sorted sequences into one +struct MergeIter>(MergeIterInner); + +impl Iterator for MergeIter +where + I: Iterator + FusedIterator, +{ + type Item = (K, V); + + /// If two keys are equal, returns the key-value pair from the right source. + fn next(&mut self) -> Option<(K, V)> { + let (a_next, b_next) = self.0.nexts(|a: &(K, V), b: &(K, V)| K::cmp(&a.0, &b.0)); + b_next.or(a_next) + } +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/btree/borrow.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/borrow.rs new file mode 100644 index 000000000000..5b4b09930249 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/borrow.rs @@ -0,0 +1,49 @@ +use crate::gccrs_core_prelude::*; + +use core::marker::PhantomData; +use core::ptr::NonNull; + +/// Models a reborrow of some unique reference, when you know that the reborrow +/// and all its descendants (i.e., all pointers and references derived from it) +/// will not be used any more at some point, after which you want to use the +/// original unique reference again. +/// +/// The borrow checker usually handles this stacking of borrows for you, but +/// some control flows that accomplish this stacking are too complicated for +/// the compiler to follow. A `DormantMutRef` allows you to check borrowing +/// yourself, while still expressing its stacked nature, and encapsulating +/// the raw pointer code needed to do this without undefined behavior. +pub struct DormantMutRef<'a, T> { + ptr: NonNull, + _marker: PhantomData<&'a mut T>, +} + +unsafe impl<'a, T> Sync for DormantMutRef<'a, T> where &'a mut T: Sync {} +unsafe impl<'a, T> Send for DormantMutRef<'a, T> where &'a mut T: Send {} + +impl<'a, T> DormantMutRef<'a, T> { + /// Capture a unique borrow, and immediately reborrow it. For the compiler, + /// the lifetime of the new reference is the same as the lifetime of the + /// original reference, but you promise to use it for a shorter period. + pub fn new(t: &'a mut T) -> (&'a mut T, Self) { + let ptr = NonNull::from(t); + // SAFETY: we hold the borrow throughout 'a via `_marker`, and we expose + // only this reference, so it is unique. + let new_ref = unsafe { &mut *ptr.as_ptr() }; + (new_ref, Self { ptr, _marker: PhantomData }) + } + + /// Revert to the unique borrow initially captured. + /// + /// # Safety + /// + /// The reborrow must have ended, i.e., the reference returned by `new` and + /// all pointers and references derived from it, must not be used anymore. + pub unsafe fn awaken(self) -> &'a mut T { + // SAFETY: our own safety conditions imply this reference is again unique. + unsafe { &mut *self.ptr.as_ptr() } + } +} + +#[cfg(test)] +mod tests; diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/btree/borrow/tests.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/borrow/tests.rs new file mode 100644 index 000000000000..56a8434fc71e --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/borrow/tests.rs @@ -0,0 +1,19 @@ +use super::DormantMutRef; + +#[test] +fn test_borrow() { + let mut data = 1; + let mut stack = vec![]; + let mut rr = &mut data; + for factor in [2, 3, 7].iter() { + let (r, dormant_r) = DormantMutRef::new(rr); + rr = r; + assert_eq!(*rr, 1); + stack.push((factor, dormant_r)); + } + while let Some((factor, dormant_r)) = stack.pop() { + let r = unsafe { dormant_r.awaken() }; + *r *= factor; + } + assert_eq!(data, 42); +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/btree/map.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/map.rs new file mode 100644 index 000000000000..bc8a73d4a9b1 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/map.rs @@ -0,0 +1,2147 @@ +use crate::gccrs_core_prelude::*; + +use core::borrow::Borrow; +use core::cmp::Ordering; +use core::fmt::{self, Debug}; +use core::hash::{Hash, Hasher}; +use core::iter::{FromIterator, FusedIterator}; +use core::marker::PhantomData; +use core::mem::{self, ManuallyDrop}; +use core::ops::{Index, RangeBounds}; +use core::ptr; + +use super::borrow::DormantMutRef; +use super::node::{self, marker, ForceResult::*, Handle, NodeRef}; +use super::search::{self, SearchResult::*}; +use super::unwrap_unchecked; + +mod entry; +pub use entry::{Entry, OccupiedEntry, VacantEntry}; +use Entry::*; + +/// Minimum number of elements in nodes that are not a root. +/// We might temporarily have fewer elements during methods. +pub(super) const MIN_LEN: usize = node::MIN_LEN_AFTER_SPLIT; + +/// A map based on a B-Tree. +/// +/// B-Trees represent a fundamental compromise between cache-efficiency and actually minimizing +/// the amount of work performed in a search. In theory, a binary search tree (BST) is the optimal +/// choice for a sorted map, as a perfectly balanced BST performs the theoretical minimum amount of +/// comparisons necessary to find an element (log2n). However, in practice the way this +/// is done is *very* inefficient for modern computer architectures. In particular, every element +/// is stored in its own individually heap-allocated node. This means that every single insertion +/// triggers a heap-allocation, and every single comparison should be a cache-miss. Since these +/// are both notably expensive things to do in practice, we are forced to at very least reconsider +/// the BST strategy. +/// +/// A B-Tree instead makes each node contain B-1 to 2B-1 elements in a contiguous array. By doing +/// this, we reduce the number of allocations by a factor of B, and improve cache efficiency in +/// searches. However, this does mean that searches will have to do *more* comparisons on average. +/// The precise number of comparisons depends on the node search strategy used. For optimal cache +/// efficiency, one could search the nodes linearly. For optimal comparisons, one could search +/// the node using binary search. As a compromise, one could also perform a linear search +/// that initially only checks every ith element for some choice of i. +/// +/// Currently, our implementation simply performs naive linear search. This provides excellent +/// performance on *small* nodes of elements which are cheap to compare. However in the future we +/// would like to further explore choosing the optimal search strategy based on the choice of B, +/// and possibly other factors. Using linear search, searching for a random element is expected +/// to take O(B * log(n)) comparisons, which is generally worse than a BST. In practice, +/// however, performance is excellent. +/// +/// It is a logic error for a key to be modified in such a way that the key's ordering relative to +/// any other key, as determined by the [`Ord`] trait, changes while it is in the map. This is +/// normally only possible through [`Cell`], [`RefCell`], global state, I/O, or unsafe code. +/// +/// [`Cell`]: core::cell::Cell +/// [`RefCell`]: core::cell::RefCell +/// +/// # Examples +/// +/// ``` +/// use std::collections::BTreeMap; +/// +/// // type inference lets us omit an explicit type signature (which +/// // would be `BTreeMap<&str, &str>` in this example). +/// let mut movie_reviews = BTreeMap::new(); +/// +/// // review some movies. +/// movie_reviews.insert("Office Space", "Deals with real issues in the workplace."); +/// movie_reviews.insert("Pulp Fiction", "Masterpiece."); +/// movie_reviews.insert("The Godfather", "Very enjoyable."); +/// movie_reviews.insert("The Blues Brothers", "Eye lyked it a lot."); +/// +/// // check for a specific one. +/// if !movie_reviews.contains_key("Les Misérables") { +/// println!("We've got {} reviews, but Les Misérables ain't one.", +/// movie_reviews.len()); +/// } +/// +/// // oops, this review has a lot of spelling mistakes, let's delete it. +/// movie_reviews.remove("The Blues Brothers"); +/// +/// // look up the values associated with some keys. +/// let to_find = ["Up!", "Office Space"]; +/// for movie in &to_find { +/// match movie_reviews.get(movie) { +/// Some(review) => println!("{}: {}", movie, review), +/// None => println!("{} is unreviewed.", movie) +/// } +/// } +/// +/// // Look up the value for a key (will panic if the key is not found). +/// println!("Movie review: {}", movie_reviews["Office Space"]); +/// +/// // iterate over everything. +/// for (movie, review) in &movie_reviews { +/// println!("{}: \"{}\"", movie, review); +/// } +/// ``` +/// +/// `BTreeMap` also implements an [`Entry API`], which allows for more complex +/// methods of getting, setting, updating and removing keys and their values: +/// +/// [`Entry API`]: BTreeMap::entry +/// +/// ``` +/// use std::collections::BTreeMap; +/// +/// // type inference lets us omit an explicit type signature (which +/// // would be `BTreeMap<&str, u8>` in this example). +/// let mut player_stats = BTreeMap::new(); +/// +/// fn random_stat_buff() -> u8 { +/// // could actually return some random value here - let's just return +/// // some fixed value for now +/// 42 +/// } +/// +/// // insert a key only if it doesn't already exist +/// player_stats.entry("health").or_insert(100); +/// +/// // insert a key using a function that provides a new value only if it +/// // doesn't already exist +/// player_stats.entry("defence").or_insert_with(random_stat_buff); +/// +/// // update a key, guarding against the key possibly not being set +/// let stat = player_stats.entry("attack").or_insert(100); +/// *stat += random_stat_buff(); +/// ``` +#[stable(feature = "rust1", since = "1.0.0")] +pub struct BTreeMap { + root: Option>, + length: usize, +} + +#[stable(feature = "btree_drop", since = "1.7.0")] +unsafe impl<#[may_dangle] K, #[may_dangle] V> Drop for BTreeMap { + fn drop(&mut self) { + unsafe { + drop(ptr::read(self).into_iter()); + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for BTreeMap { + fn clone(&self) -> BTreeMap { + fn clone_subtree<'a, K: Clone, V: Clone>( + node: node::NodeRef, K, V, marker::LeafOrInternal>, + ) -> BTreeMap + where + K: 'a, + V: 'a, + { + match node.force() { + Leaf(leaf) => { + let mut out_tree = BTreeMap { root: Some(node::Root::new_leaf()), length: 0 }; + + { + let root = out_tree.root.as_mut().unwrap(); // unwrap succeeds because we just wrapped + let mut out_node = match root.node_as_mut().force() { + Leaf(leaf) => leaf, + Internal(_) => unreachable!(), + }; + + let mut in_edge = leaf.first_edge(); + while let Ok(kv) = in_edge.right_kv() { + let (k, v) = kv.into_kv(); + in_edge = kv.right_edge(); + + out_node.push(k.clone(), v.clone()); + out_tree.length += 1; + } + } + + out_tree + } + Internal(internal) => { + let mut out_tree = clone_subtree(internal.first_edge().descend()); + + { + let out_root = BTreeMap::ensure_is_owned(&mut out_tree.root); + let mut out_node = out_root.push_internal_level(); + let mut in_edge = internal.first_edge(); + while let Ok(kv) = in_edge.right_kv() { + let (k, v) = kv.into_kv(); + in_edge = kv.right_edge(); + + let k = (*k).clone(); + let v = (*v).clone(); + let subtree = clone_subtree(in_edge.descend()); + + // We can't destructure subtree directly + // because BTreeMap implements Drop + let (subroot, sublength) = unsafe { + let subtree = ManuallyDrop::new(subtree); + let root = ptr::read(&subtree.root); + let length = subtree.length; + (root, length) + }; + + out_node.push(k, v, subroot.unwrap_or_else(node::Root::new_leaf)); + out_tree.length += 1 + sublength; + } + } + + out_tree + } + } + } + + if self.is_empty() { + // Ideally we'd call `BTreeMap::new` here, but that has the `K: + // Ord` constraint, which this method lacks. + BTreeMap { root: None, length: 0 } + } else { + clone_subtree(self.root.as_ref().unwrap().node_as_ref()) // unwrap succeeds because not empty + } + } +} + +impl super::Recover for BTreeMap +where + K: Borrow + Ord, + Q: Ord, +{ + type Key = K; + + fn get(&self, key: &Q) -> Option<&K> { + let root_node = self.root.as_ref()?.node_as_ref(); + match search::search_tree(root_node, key) { + Found(handle) => Some(handle.into_kv().0), + GoDown(_) => None, + } + } + + fn take(&mut self, key: &Q) -> Option { + let (map, dormant_map) = DormantMutRef::new(self); + let root_node = map.root.as_mut()?.node_as_mut(); + match search::search_tree(root_node, key) { + Found(handle) => { + Some(OccupiedEntry { handle, dormant_map, _marker: PhantomData }.remove_kv().0) + } + GoDown(_) => None, + } + } + + fn replace(&mut self, key: K) -> Option { + let (map, dormant_map) = DormantMutRef::new(self); + let root_node = Self::ensure_is_owned(&mut map.root).node_as_mut(); + match search::search_tree::, K, (), K>(root_node, &key) { + Found(handle) => Some(mem::replace(handle.into_key_mut(), key)), + GoDown(handle) => { + VacantEntry { key, handle, dormant_map, _marker: PhantomData }.insert(()); + None + } + } + } +} + +/// An iterator over the entries of a `BTreeMap`. +/// +/// This `struct` is created by the [`iter`] method on [`BTreeMap`]. See its +/// documentation for more. +/// +/// [`iter`]: BTreeMap::iter +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Iter<'a, K: 'a, V: 'a> { + range: Range<'a, K, V>, + length: usize, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Iter<'_, K, V> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.clone()).finish() + } +} + +/// A mutable iterator over the entries of a `BTreeMap`. +/// +/// This `struct` is created by the [`iter_mut`] method on [`BTreeMap`]. See its +/// documentation for more. +/// +/// [`iter_mut`]: BTreeMap::iter_mut +#[stable(feature = "rust1", since = "1.0.0")] +#[derive(Debug)] +pub struct IterMut<'a, K: 'a, V: 'a> { + range: RangeMut<'a, K, V>, + length: usize, +} + +/// An owning iterator over the entries of a `BTreeMap`. +/// +/// This `struct` is created by the [`into_iter`] method on [`BTreeMap`] +/// (provided by the `IntoIterator` trait). See its documentation for more. +/// +/// [`into_iter`]: IntoIterator::into_iter +#[stable(feature = "rust1", since = "1.0.0")] +pub struct IntoIter { + front: Option, marker::Edge>>, + back: Option, marker::Edge>>, + length: usize, +} + +impl IntoIter { + /// Returns an iterator of references over the remaining items. + #[inline] + pub(super) fn iter(&self) -> Iter<'_, K, V> { + let range = Range { + front: self.front.as_ref().map(|f| f.reborrow()), + back: self.back.as_ref().map(|b| b.reborrow()), + }; + + Iter { range: range, length: self.length } + } +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for IntoIter { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.iter()).finish() + } +} + +/// An iterator over the keys of a `BTreeMap`. +/// +/// This `struct` is created by the [`keys`] method on [`BTreeMap`]. See its +/// documentation for more. +/// +/// [`keys`]: BTreeMap::keys +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Keys<'a, K: 'a, V: 'a> { + inner: Iter<'a, K, V>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Keys<'_, K, V> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.clone()).finish() + } +} + +/// An iterator over the values of a `BTreeMap`. +/// +/// This `struct` is created by the [`values`] method on [`BTreeMap`]. See its +/// documentation for more. +/// +/// [`values`]: BTreeMap::values +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Values<'a, K: 'a, V: 'a> { + inner: Iter<'a, K, V>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Values<'_, K, V> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.clone()).finish() + } +} + +/// A mutable iterator over the values of a `BTreeMap`. +/// +/// This `struct` is created by the [`values_mut`] method on [`BTreeMap`]. See its +/// documentation for more. +/// +/// [`values_mut`]: BTreeMap::values_mut +#[stable(feature = "map_values_mut", since = "1.10.0")] +pub struct ValuesMut<'a, K: 'a, V: 'a> { + inner: IterMut<'a, K, V>, +} + +#[stable(feature = "map_values_mut", since = "1.10.0")] +impl fmt::Debug for ValuesMut<'_, K, V> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.inner.iter().map(|(_, val)| val)).finish() + } +} + +/// An owning iterator over the keys of a `BTreeMap`. +/// +/// This `struct` is created by the [`into_keys`] method on [`BTreeMap`]. +/// See its documentation for more. +/// +/// [`into_keys`]: BTreeMap::into_keys +#[unstable(feature = "map_into_keys_values", issue = "75294")] +pub struct IntoKeys { + inner: IntoIter, +} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl fmt::Debug for IntoKeys { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.inner.iter().map(|(key, _)| key)).finish() + } +} + +/// An owning iterator over the values of a `BTreeMap`. +/// +/// This `struct` is created by the [`into_values`] method on [`BTreeMap`]. +/// See its documentation for more. +/// +/// [`into_values`]: BTreeMap::into_values +#[unstable(feature = "map_into_keys_values", issue = "75294")] +pub struct IntoValues { + inner: IntoIter, +} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl fmt::Debug for IntoValues { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.inner.iter().map(|(_, val)| val)).finish() + } +} + +/// An iterator over a sub-range of entries in a `BTreeMap`. +/// +/// This `struct` is created by the [`range`] method on [`BTreeMap`]. See its +/// documentation for more. +/// +/// [`range`]: BTreeMap::range +#[stable(feature = "btree_range", since = "1.17.0")] +pub struct Range<'a, K: 'a, V: 'a> { + front: Option, K, V, marker::Leaf>, marker::Edge>>, + back: Option, K, V, marker::Leaf>, marker::Edge>>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Range<'_, K, V> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self.clone()).finish() + } +} + +/// A mutable iterator over a sub-range of entries in a `BTreeMap`. +/// +/// This `struct` is created by the [`range_mut`] method on [`BTreeMap`]. See its +/// documentation for more. +/// +/// [`range_mut`]: BTreeMap::range_mut +#[stable(feature = "btree_range", since = "1.17.0")] +pub struct RangeMut<'a, K: 'a, V: 'a> { + front: Option, K, V, marker::Leaf>, marker::Edge>>, + back: Option, K, V, marker::Leaf>, marker::Edge>>, + + // Be invariant in `K` and `V` + _marker: PhantomData<&'a mut (K, V)>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for RangeMut<'_, K, V> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let range = Range { + front: self.front.as_ref().map(|f| f.reborrow()), + back: self.back.as_ref().map(|b| b.reborrow()), + }; + f.debug_list().entries(range).finish() + } +} + +impl BTreeMap { + /// Makes a new empty BTreeMap. + /// + /// Does not allocate anything on its own. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// + /// // entries can now be inserted into the empty map + /// map.insert(1, "a"); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_const_unstable(feature = "const_btree_new", issue = "71835")] + pub const fn new() -> BTreeMap { + BTreeMap { root: None, length: 0 } + } + + /// Clears the map, removing all elements. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// a.insert(1, "a"); + /// a.clear(); + /// assert!(a.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn clear(&mut self) { + *self = BTreeMap::new(); + } + + /// Returns a reference to the value corresponding to the key. + /// + /// The key may be any borrowed form of the map's key type, but the ordering + /// on the borrowed form *must* match the ordering on the key type. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// assert_eq!(map.get(&1), Some(&"a")); + /// assert_eq!(map.get(&2), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn get(&self, key: &Q) -> Option<&V> + where + K: Borrow, + Q: Ord, + { + let root_node = self.root.as_ref()?.node_as_ref(); + match search::search_tree(root_node, key) { + Found(handle) => Some(handle.into_kv().1), + GoDown(_) => None, + } + } + + /// Returns the key-value pair corresponding to the supplied key. + /// + /// The supplied key may be any borrowed form of the map's key type, but the ordering + /// on the borrowed form *must* match the ordering on the key type. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// assert_eq!(map.get_key_value(&1), Some((&1, &"a"))); + /// assert_eq!(map.get_key_value(&2), None); + /// ``` + #[stable(feature = "map_get_key_value", since = "1.40.0")] + pub fn get_key_value(&self, k: &Q) -> Option<(&K, &V)> + where + K: Borrow, + Q: Ord, + { + let root_node = self.root.as_ref()?.node_as_ref(); + match search::search_tree(root_node, k) { + Found(handle) => Some(handle.into_kv()), + GoDown(_) => None, + } + } + + /// Returns the first key-value pair in the map. + /// The key in this pair is the minimum key in the map. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// assert_eq!(map.first_key_value(), None); + /// map.insert(1, "b"); + /// map.insert(2, "a"); + /// assert_eq!(map.first_key_value(), Some((&1, &"b"))); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn first_key_value(&self) -> Option<(&K, &V)> { + let root_node = self.root.as_ref()?.node_as_ref(); + root_node.first_leaf_edge().right_kv().ok().map(Handle::into_kv) + } + + /// Returns the first entry in the map for in-place manipulation. + /// The key of this entry is the minimum key in the map. + /// + /// # Examples + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// map.insert(2, "b"); + /// if let Some(mut entry) = map.first_entry() { + /// if *entry.key() > 0 { + /// entry.insert("first"); + /// } + /// } + /// assert_eq!(*map.get(&1).unwrap(), "first"); + /// assert_eq!(*map.get(&2).unwrap(), "b"); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn first_entry(&mut self) -> Option> { + let (map, dormant_map) = DormantMutRef::new(self); + let root_node = map.root.as_mut()?.node_as_mut(); + let kv = root_node.first_leaf_edge().right_kv().ok()?; + Some(OccupiedEntry { handle: kv.forget_node_type(), dormant_map, _marker: PhantomData }) + } + + /// Removes and returns the first element in the map. + /// The key of this element is the minimum key that was in the map. + /// + /// # Examples + /// + /// Draining elements in ascending order, while keeping a usable map each iteration. + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// map.insert(2, "b"); + /// while let Some((key, _val)) = map.pop_first() { + /// assert!(map.iter().all(|(k, _v)| *k > key)); + /// } + /// assert!(map.is_empty()); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn pop_first(&mut self) -> Option<(K, V)> { + self.first_entry().map(|entry| entry.remove_entry()) + } + + /// Returns the last key-value pair in the map. + /// The key in this pair is the maximum key in the map. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "b"); + /// map.insert(2, "a"); + /// assert_eq!(map.last_key_value(), Some((&2, &"a"))); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn last_key_value(&self) -> Option<(&K, &V)> { + let root_node = self.root.as_ref()?.node_as_ref(); + root_node.last_leaf_edge().left_kv().ok().map(Handle::into_kv) + } + + /// Returns the last entry in the map for in-place manipulation. + /// The key of this entry is the maximum key in the map. + /// + /// # Examples + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// map.insert(2, "b"); + /// if let Some(mut entry) = map.last_entry() { + /// if *entry.key() > 0 { + /// entry.insert("last"); + /// } + /// } + /// assert_eq!(*map.get(&1).unwrap(), "a"); + /// assert_eq!(*map.get(&2).unwrap(), "last"); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn last_entry(&mut self) -> Option> { + let (map, dormant_map) = DormantMutRef::new(self); + let root_node = map.root.as_mut()?.node_as_mut(); + let kv = root_node.last_leaf_edge().left_kv().ok()?; + Some(OccupiedEntry { handle: kv.forget_node_type(), dormant_map, _marker: PhantomData }) + } + + /// Removes and returns the last element in the map. + /// The key of this element is the maximum key that was in the map. + /// + /// # Examples + /// + /// Draining elements in descending order, while keeping a usable map each iteration. + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// map.insert(2, "b"); + /// while let Some((key, _val)) = map.pop_last() { + /// assert!(map.iter().all(|(k, _v)| *k < key)); + /// } + /// assert!(map.is_empty()); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn pop_last(&mut self) -> Option<(K, V)> { + self.last_entry().map(|entry| entry.remove_entry()) + } + + /// Returns `true` if the map contains a value for the specified key. + /// + /// The key may be any borrowed form of the map's key type, but the ordering + /// on the borrowed form *must* match the ordering on the key type. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// assert_eq!(map.contains_key(&1), true); + /// assert_eq!(map.contains_key(&2), false); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn contains_key(&self, key: &Q) -> bool + where + K: Borrow, + Q: Ord, + { + self.get(key).is_some() + } + + /// Returns a mutable reference to the value corresponding to the key. + /// + /// The key may be any borrowed form of the map's key type, but the ordering + /// on the borrowed form *must* match the ordering on the key type. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// if let Some(x) = map.get_mut(&1) { + /// *x = "b"; + /// } + /// assert_eq!(map[&1], "b"); + /// ``` + // See `get` for implementation notes, this is basically a copy-paste with mut's added + #[stable(feature = "rust1", since = "1.0.0")] + pub fn get_mut(&mut self, key: &Q) -> Option<&mut V> + where + K: Borrow, + Q: Ord, + { + let root_node = self.root.as_mut()?.node_as_mut(); + match search::search_tree(root_node, key) { + Found(handle) => Some(handle.into_val_mut()), + GoDown(_) => None, + } + } + + /// Inserts a key-value pair into the map. + /// + /// If the map did not have this key present, `None` is returned. + /// + /// If the map did have this key present, the value is updated, and the old + /// value is returned. The key is not updated, though; this matters for + /// types that can be `==` without being identical. See the [module-level + /// documentation] for more. + /// + /// [module-level documentation]: index.html#insert-and-complex-keys + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// assert_eq!(map.insert(37, "a"), None); + /// assert_eq!(map.is_empty(), false); + /// + /// map.insert(37, "b"); + /// assert_eq!(map.insert(37, "c"), Some("b")); + /// assert_eq!(map[&37], "c"); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn insert(&mut self, key: K, value: V) -> Option { + match self.entry(key) { + Occupied(mut entry) => Some(entry.insert(value)), + Vacant(entry) => { + entry.insert(value); + None + } + } + } + + /// Removes a key from the map, returning the value at the key if the key + /// was previously in the map. + /// + /// The key may be any borrowed form of the map's key type, but the ordering + /// on the borrowed form *must* match the ordering on the key type. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// assert_eq!(map.remove(&1), Some("a")); + /// assert_eq!(map.remove(&1), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn remove(&mut self, key: &Q) -> Option + where + K: Borrow, + Q: Ord, + { + self.remove_entry(key).map(|(_, v)| v) + } + + /// Removes a key from the map, returning the stored key and value if the key + /// was previously in the map. + /// + /// The key may be any borrowed form of the map's key type, but the ordering + /// on the borrowed form *must* match the ordering on the key type. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(1, "a"); + /// assert_eq!(map.remove_entry(&1), Some((1, "a"))); + /// assert_eq!(map.remove_entry(&1), None); + /// ``` + #[stable(feature = "btreemap_remove_entry", since = "1.45.0")] + pub fn remove_entry(&mut self, key: &Q) -> Option<(K, V)> + where + K: Borrow, + Q: Ord, + { + let (map, dormant_map) = DormantMutRef::new(self); + let root_node = map.root.as_mut()?.node_as_mut(); + match search::search_tree(root_node, key) { + Found(handle) => { + Some(OccupiedEntry { handle, dormant_map, _marker: PhantomData }.remove_entry()) + } + GoDown(_) => None, + } + } + + /// Moves all elements from `other` into `Self`, leaving `other` empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// a.insert(1, "a"); + /// a.insert(2, "b"); + /// a.insert(3, "c"); + /// + /// let mut b = BTreeMap::new(); + /// b.insert(3, "d"); + /// b.insert(4, "e"); + /// b.insert(5, "f"); + /// + /// a.append(&mut b); + /// + /// assert_eq!(a.len(), 5); + /// assert_eq!(b.len(), 0); + /// + /// assert_eq!(a[&1], "a"); + /// assert_eq!(a[&2], "b"); + /// assert_eq!(a[&3], "d"); + /// assert_eq!(a[&4], "e"); + /// assert_eq!(a[&5], "f"); + /// ``` + #[stable(feature = "btree_append", since = "1.11.0")] + pub fn append(&mut self, other: &mut Self) { + // Do we have to append anything at all? + if other.is_empty() { + return; + } + + // We can just swap `self` and `other` if `self` is empty. + if self.is_empty() { + mem::swap(self, other); + return; + } + + let self_iter = mem::take(self).into_iter(); + let other_iter = mem::take(other).into_iter(); + let root = BTreeMap::ensure_is_owned(&mut self.root); + root.append_from_sorted_iters(self_iter, other_iter, &mut self.length) + } + + /// Constructs a double-ended iterator over a sub-range of elements in the map. + /// The simplest way is to use the range syntax `min..max`, thus `range(min..max)` will + /// yield elements from min (inclusive) to max (exclusive). + /// The range may also be entered as `(Bound, Bound)`, so for example + /// `range((Excluded(4), Included(10)))` will yield a left-exclusive, right-inclusive + /// range from 4 to 10. + /// + /// # Panics + /// + /// Panics if range `start > end`. + /// Panics if range `start == end` and both bounds are `Excluded`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// use std::ops::Bound::Included; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(3, "a"); + /// map.insert(5, "b"); + /// map.insert(8, "c"); + /// for (&key, &value) in map.range((Included(&4), Included(&8))) { + /// println!("{}: {}", key, value); + /// } + /// assert_eq!(Some((&5, &"b")), map.range(4..).next()); + /// ``` + #[stable(feature = "btree_range", since = "1.17.0")] + pub fn range(&self, range: R) -> Range<'_, K, V> + where + T: Ord, + K: Borrow, + R: RangeBounds, + { + if let Some(root) = &self.root { + let (f, b) = root.node_as_ref().range_search(range); + + Range { front: Some(f), back: Some(b) } + } else { + Range { front: None, back: None } + } + } + + /// Constructs a mutable double-ended iterator over a sub-range of elements in the map. + /// The simplest way is to use the range syntax `min..max`, thus `range(min..max)` will + /// yield elements from min (inclusive) to max (exclusive). + /// The range may also be entered as `(Bound, Bound)`, so for example + /// `range((Excluded(4), Included(10)))` will yield a left-exclusive, right-inclusive + /// range from 4 to 10. + /// + /// # Panics + /// + /// Panics if range `start > end`. + /// Panics if range `start == end` and both bounds are `Excluded`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap<&str, i32> = ["Alice", "Bob", "Carol", "Cheryl"] + /// .iter() + /// .map(|&s| (s, 0)) + /// .collect(); + /// for (_, balance) in map.range_mut("B".."Cheryl") { + /// *balance += 100; + /// } + /// for (name, balance) in &map { + /// println!("{} => {}", name, balance); + /// } + /// ``` + #[stable(feature = "btree_range", since = "1.17.0")] + pub fn range_mut(&mut self, range: R) -> RangeMut<'_, K, V> + where + T: Ord, + K: Borrow, + R: RangeBounds, + { + if let Some(root) = &mut self.root { + let (f, b) = root.node_as_valmut().range_search(range); + + RangeMut { front: Some(f), back: Some(b), _marker: PhantomData } + } else { + RangeMut { front: None, back: None, _marker: PhantomData } + } + } + + /// Gets the given key's corresponding entry in the map for in-place manipulation. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut count: BTreeMap<&str, usize> = BTreeMap::new(); + /// + /// // count the number of occurrences of letters in the vec + /// for x in vec!["a","b","a","c","a","b"] { + /// *count.entry(x).or_insert(0) += 1; + /// } + /// + /// assert_eq!(count["a"], 3); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn entry(&mut self, key: K) -> Entry<'_, K, V> { + // FIXME(@porglezomp) Avoid allocating if we don't insert + let (map, dormant_map) = DormantMutRef::new(self); + let root_node = Self::ensure_is_owned(&mut map.root).node_as_mut(); + match search::search_tree(root_node, &key) { + Found(handle) => Occupied(OccupiedEntry { handle, dormant_map, _marker: PhantomData }), + GoDown(handle) => { + Vacant(VacantEntry { key, handle, dormant_map, _marker: PhantomData }) + } + } + } + + /// Splits the collection into two at the given key. Returns everything after the given key, + /// including the key. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// a.insert(1, "a"); + /// a.insert(2, "b"); + /// a.insert(3, "c"); + /// a.insert(17, "d"); + /// a.insert(41, "e"); + /// + /// let b = a.split_off(&3); + /// + /// assert_eq!(a.len(), 2); + /// assert_eq!(b.len(), 3); + /// + /// assert_eq!(a[&1], "a"); + /// assert_eq!(a[&2], "b"); + /// + /// assert_eq!(b[&3], "c"); + /// assert_eq!(b[&17], "d"); + /// assert_eq!(b[&41], "e"); + /// ``` + #[stable(feature = "btree_split_off", since = "1.11.0")] + pub fn split_off(&mut self, key: &Q) -> Self + where + K: Borrow, + { + if self.is_empty() { + return Self::new(); + } + + let total_num = self.len(); + let left_root = self.root.as_mut().unwrap(); // unwrap succeeds because not empty + + let mut right = Self::new(); + let right_root = Self::ensure_is_owned(&mut right.root); + + left_root.split_off(right_root, key); + + if left_root.height() < right_root.height() { + self.length = left_root.node_as_ref().calc_length(); + right.length = total_num - self.len(); + } else { + right.length = right_root.node_as_ref().calc_length(); + self.length = total_num - right.len(); + } + + right + } + + /// Creates an iterator which uses a closure to determine if an element should be removed. + /// + /// If the closure returns true, the element is removed from the map and yielded. + /// If the closure returns false, or panics, the element remains in the map and will not be + /// yielded. + /// + /// Note that `drain_filter` lets you mutate every value in the filter closure, regardless of + /// whether you choose to keep or remove it. + /// + /// If the iterator is only partially consumed or not consumed at all, each of the remaining + /// elements will still be subjected to the closure and removed and dropped if it returns true. + /// + /// It is unspecified how many more elements will be subjected to the closure + /// if a panic occurs in the closure, or a panic occurs while dropping an element, + /// or if the `DrainFilter` value is leaked. + /// + /// # Examples + /// + /// Splitting a map into even and odd keys, reusing the original map: + /// + /// ``` + /// #![feature(btree_drain_filter)] + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap = (0..8).map(|x| (x, x)).collect(); + /// let evens: BTreeMap<_, _> = map.drain_filter(|k, _v| k % 2 == 0).collect(); + /// let odds = map; + /// assert_eq!(evens.keys().copied().collect::>(), vec![0, 2, 4, 6]); + /// assert_eq!(odds.keys().copied().collect::>(), vec![1, 3, 5, 7]); + /// ``` + #[unstable(feature = "btree_drain_filter", issue = "70530")] + pub fn drain_filter(&mut self, pred: F) -> DrainFilter<'_, K, V, F> + where + F: FnMut(&K, &mut V) -> bool, + { + DrainFilter { pred, inner: self.drain_filter_inner() } + } + + pub(super) fn drain_filter_inner(&mut self) -> DrainFilterInner<'_, K, V> { + if let Some(root) = self.root.as_mut() { + let (root, dormant_root) = DormantMutRef::new(root); + let front = root.node_as_mut().first_leaf_edge(); + DrainFilterInner { + length: &mut self.length, + dormant_root: Some(dormant_root), + cur_leaf_edge: Some(front), + } + } else { + DrainFilterInner { length: &mut self.length, dormant_root: None, cur_leaf_edge: None } + } + } + + /// Creates a consuming iterator visiting all the keys, in sorted order. + /// The map cannot be used after calling this. + /// The iterator element type is `K`. + /// + /// # Examples + /// + /// ``` + /// #![feature(map_into_keys_values)] + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// a.insert(2, "b"); + /// a.insert(1, "a"); + /// + /// let keys: Vec = a.into_keys().collect(); + /// assert_eq!(keys, [1, 2]); + /// ``` + #[inline] + #[unstable(feature = "map_into_keys_values", issue = "75294")] + pub fn into_keys(self) -> IntoKeys { + IntoKeys { inner: self.into_iter() } + } + + /// Creates a consuming iterator visiting all the values, in order by key. + /// The map cannot be used after calling this. + /// The iterator element type is `V`. + /// + /// # Examples + /// + /// ``` + /// #![feature(map_into_keys_values)] + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// a.insert(1, "hello"); + /// a.insert(2, "goodbye"); + /// + /// let values: Vec<&str> = a.into_values().collect(); + /// assert_eq!(values, ["hello", "goodbye"]); + /// ``` + #[inline] + #[unstable(feature = "map_into_keys_values", issue = "75294")] + pub fn into_values(self) -> IntoValues { + IntoValues { inner: self.into_iter() } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K, V> IntoIterator for &'a BTreeMap { + type Item = (&'a K, &'a V); + type IntoIter = Iter<'a, K, V>; + + fn into_iter(self) -> Iter<'a, K, V> { + self.iter() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K: 'a, V: 'a> Iterator for Iter<'a, K, V> { + type Item = (&'a K, &'a V); + + fn next(&mut self) -> Option<(&'a K, &'a V)> { + if self.length == 0 { + None + } else { + self.length -= 1; + unsafe { Some(self.range.next_unchecked()) } + } + } + + fn size_hint(&self) -> (usize, Option) { + (self.length, Some(self.length)) + } + + fn last(mut self) -> Option<(&'a K, &'a V)> { + self.next_back() + } + + fn min(mut self) -> Option<(&'a K, &'a V)> { + self.next() + } + + fn max(mut self) -> Option<(&'a K, &'a V)> { + self.next_back() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Iter<'_, K, V> {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K: 'a, V: 'a> DoubleEndedIterator for Iter<'a, K, V> { + fn next_back(&mut self) -> Option<(&'a K, &'a V)> { + if self.length == 0 { + None + } else { + self.length -= 1; + unsafe { Some(self.range.next_back_unchecked()) } + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for Iter<'_, K, V> { + fn len(&self) -> usize { + self.length + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Iter<'_, K, V> { + fn clone(&self) -> Self { + Iter { range: self.range.clone(), length: self.length } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K, V> IntoIterator for &'a mut BTreeMap { + type Item = (&'a K, &'a mut V); + type IntoIter = IterMut<'a, K, V>; + + fn into_iter(self) -> IterMut<'a, K, V> { + self.iter_mut() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K: 'a, V: 'a> Iterator for IterMut<'a, K, V> { + type Item = (&'a K, &'a mut V); + + fn next(&mut self) -> Option<(&'a K, &'a mut V)> { + if self.length == 0 { + None + } else { + self.length -= 1; + let (k, v) = unsafe { self.range.next_unchecked() }; + Some((k, v)) // coerce k from `&mut K` to `&K` + } + } + + fn size_hint(&self) -> (usize, Option) { + (self.length, Some(self.length)) + } + + fn last(mut self) -> Option<(&'a K, &'a mut V)> { + self.next_back() + } + + fn min(mut self) -> Option<(&'a K, &'a mut V)> { + self.next() + } + + fn max(mut self) -> Option<(&'a K, &'a mut V)> { + self.next_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K: 'a, V: 'a> DoubleEndedIterator for IterMut<'a, K, V> { + fn next_back(&mut self) -> Option<(&'a K, &'a mut V)> { + if self.length == 0 { + None + } else { + self.length -= 1; + let (k, v) = unsafe { self.range.next_back_unchecked() }; + Some((k, v)) // coerce k from `&mut K` to `&K` + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for IterMut<'_, K, V> { + fn len(&self) -> usize { + self.length + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for IterMut<'_, K, V> {} + +impl<'a, K, V> IterMut<'a, K, V> { + /// Returns an iterator of references over the remaining items. + #[inline] + pub(super) fn iter(&self) -> Iter<'_, K, V> { + Iter { range: self.range.iter(), length: self.length } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl IntoIterator for BTreeMap { + type Item = (K, V); + type IntoIter = IntoIter; + + fn into_iter(self) -> IntoIter { + let mut me = ManuallyDrop::new(self); + if let Some(root) = me.root.take() { + let (f, b) = root.into_ref().full_range(); + + IntoIter { front: Some(f), back: Some(b), length: me.length } + } else { + IntoIter { front: None, back: None, length: 0 } + } + } +} + +#[stable(feature = "btree_drop", since = "1.7.0")] +impl Drop for IntoIter { + fn drop(&mut self) { + struct DropGuard<'a, K, V>(&'a mut IntoIter); + + impl<'a, K, V> Drop for DropGuard<'a, K, V> { + fn drop(&mut self) { + // Continue the same loop we perform below. This only runs when unwinding, so we + // don't have to care about panics this time (they'll abort). + while let Some(_) = self.0.next() {} + + unsafe { + let mut node = + unwrap_unchecked(ptr::read(&self.0.front)).into_node().forget_type(); + while let Some(parent) = node.deallocate_and_ascend() { + node = parent.into_node().forget_type(); + } + } + } + } + + while let Some(pair) = self.next() { + let guard = DropGuard(self); + drop(pair); + mem::forget(guard); + } + + unsafe { + if let Some(front) = ptr::read(&self.front) { + let mut node = front.into_node().forget_type(); + // Most of the nodes have been deallocated while traversing + // but one pile from a leaf up to the root is left standing. + while let Some(parent) = node.deallocate_and_ascend() { + node = parent.into_node().forget_type(); + } + } + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Iterator for IntoIter { + type Item = (K, V); + + fn next(&mut self) -> Option<(K, V)> { + if self.length == 0 { + None + } else { + self.length -= 1; + Some(unsafe { self.front.as_mut().unwrap().next_unchecked() }) + } + } + + fn size_hint(&self) -> (usize, Option) { + (self.length, Some(self.length)) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl DoubleEndedIterator for IntoIter { + fn next_back(&mut self) -> Option<(K, V)> { + if self.length == 0 { + None + } else { + self.length -= 1; + Some(unsafe { self.back.as_mut().unwrap().next_back_unchecked() }) + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for IntoIter { + fn len(&self) -> usize { + self.length + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for IntoIter {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K, V> Iterator for Keys<'a, K, V> { + type Item = &'a K; + + fn next(&mut self) -> Option<&'a K> { + self.inner.next().map(|(k, _)| k) + } + + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } + + fn last(mut self) -> Option<&'a K> { + self.next_back() + } + + fn min(mut self) -> Option<&'a K> { + self.next() + } + + fn max(mut self) -> Option<&'a K> { + self.next_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V> { + fn next_back(&mut self) -> Option<&'a K> { + self.inner.next_back().map(|(k, _)| k) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for Keys<'_, K, V> { + fn len(&self) -> usize { + self.inner.len() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Keys<'_, K, V> {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Keys<'_, K, V> { + fn clone(&self) -> Self { + Keys { inner: self.inner.clone() } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K, V> Iterator for Values<'a, K, V> { + type Item = &'a V; + + fn next(&mut self) -> Option<&'a V> { + self.inner.next().map(|(_, v)| v) + } + + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } + + fn last(mut self) -> Option<&'a V> { + self.next_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> { + fn next_back(&mut self) -> Option<&'a V> { + self.inner.next_back().map(|(_, v)| v) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for Values<'_, K, V> { + fn len(&self) -> usize { + self.inner.len() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Values<'_, K, V> {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Values<'_, K, V> { + fn clone(&self) -> Self { + Values { inner: self.inner.clone() } + } +} + +/// An iterator produced by calling `drain_filter` on BTreeMap. +#[unstable(feature = "btree_drain_filter", issue = "70530")] +pub struct DrainFilter<'a, K, V, F> +where + K: 'a, + V: 'a, + F: 'a + FnMut(&K, &mut V) -> bool, +{ + pred: F, + inner: DrainFilterInner<'a, K, V>, +} +/// Most of the implementation of DrainFilter, independent of the type +/// of the predicate, thus also serving for BTreeSet::DrainFilter. +pub(super) struct DrainFilterInner<'a, K: 'a, V: 'a> { + /// Reference to the length field in the borrowed map, updated live. + length: &'a mut usize, + /// Burried reference to the root field in the borrowed map. + /// Wrapped in `Option` to allow drop handler to `take` it. + dormant_root: Option>>, + /// Contains a leaf edge preceding the next element to be returned, or the last leaf edge. + /// Empty if the map has no root, if iteration went beyond the last leaf edge, + /// or if a panic occurred in the predicate. + cur_leaf_edge: Option, K, V, marker::Leaf>, marker::Edge>>, +} + +#[unstable(feature = "btree_drain_filter", issue = "70530")] +impl Drop for DrainFilter<'_, K, V, F> +where + F: FnMut(&K, &mut V) -> bool, +{ + fn drop(&mut self) { + self.for_each(drop); + } +} + +#[unstable(feature = "btree_drain_filter", issue = "70530")] +impl fmt::Debug for DrainFilter<'_, K, V, F> +where + K: fmt::Debug, + V: fmt::Debug, + F: FnMut(&K, &mut V) -> bool, +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("DrainFilter").field(&self.inner.peek()).finish() + } +} + +#[unstable(feature = "btree_drain_filter", issue = "70530")] +impl Iterator for DrainFilter<'_, K, V, F> +where + F: FnMut(&K, &mut V) -> bool, +{ + type Item = (K, V); + + fn next(&mut self) -> Option<(K, V)> { + self.inner.next(&mut self.pred) + } + + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } +} + +impl<'a, K: 'a, V: 'a> DrainFilterInner<'a, K, V> { + /// Allow Debug implementations to predict the next element. + pub(super) fn peek(&self) -> Option<(&K, &V)> { + let edge = self.cur_leaf_edge.as_ref()?; + edge.reborrow().next_kv().ok().map(Handle::into_kv) + } + + /// Implementation of a typical `DrainFilter::next` method, given the predicate. + pub(super) fn next(&mut self, pred: &mut F) -> Option<(K, V)> + where + F: FnMut(&K, &mut V) -> bool, + { + while let Ok(mut kv) = self.cur_leaf_edge.take()?.next_kv() { + let (k, v) = kv.kv_mut(); + if pred(k, v) { + *self.length -= 1; + let (kv, pos) = kv.remove_kv_tracking(|| { + // SAFETY: we will touch the root in a way that will not + // invalidate the position returned. + let root = unsafe { self.dormant_root.take().unwrap().awaken() }; + root.pop_internal_level(); + self.dormant_root = Some(DormantMutRef::new(root).1); + }); + self.cur_leaf_edge = Some(pos); + return Some(kv); + } + self.cur_leaf_edge = Some(kv.next_leaf_edge()); + } + None + } + + /// Implementation of a typical `DrainFilter::size_hint` method. + pub(super) fn size_hint(&self) -> (usize, Option) { + // In most of the btree iterators, `self.length` is the number of elements + // yet to be visited. Here, it includes elements that were visited and that + // the predicate decided not to drain. Making this upper bound more accurate + // requires maintaining an extra field and is not worth while. + (0, Some(*self.length)) + } +} + +#[unstable(feature = "btree_drain_filter", issue = "70530")] +impl FusedIterator for DrainFilter<'_, K, V, F> where F: FnMut(&K, &mut V) -> bool {} + +#[stable(feature = "btree_range", since = "1.17.0")] +impl<'a, K, V> Iterator for Range<'a, K, V> { + type Item = (&'a K, &'a V); + + fn next(&mut self) -> Option<(&'a K, &'a V)> { + if self.is_empty() { None } else { unsafe { Some(self.next_unchecked()) } } + } + + fn last(mut self) -> Option<(&'a K, &'a V)> { + self.next_back() + } + + fn min(mut self) -> Option<(&'a K, &'a V)> { + self.next() + } + + fn max(mut self) -> Option<(&'a K, &'a V)> { + self.next_back() + } +} + +#[stable(feature = "map_values_mut", since = "1.10.0")] +impl<'a, K, V> Iterator for ValuesMut<'a, K, V> { + type Item = &'a mut V; + + fn next(&mut self) -> Option<&'a mut V> { + self.inner.next().map(|(_, v)| v) + } + + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } + + fn last(mut self) -> Option<&'a mut V> { + self.next_back() + } +} + +#[stable(feature = "map_values_mut", since = "1.10.0")] +impl<'a, K, V> DoubleEndedIterator for ValuesMut<'a, K, V> { + fn next_back(&mut self) -> Option<&'a mut V> { + self.inner.next_back().map(|(_, v)| v) + } +} + +#[stable(feature = "map_values_mut", since = "1.10.0")] +impl ExactSizeIterator for ValuesMut<'_, K, V> { + fn len(&self) -> usize { + self.inner.len() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for ValuesMut<'_, K, V> {} + +impl<'a, K, V> Range<'a, K, V> { + fn is_empty(&self) -> bool { + self.front == self.back + } + + unsafe fn next_unchecked(&mut self) -> (&'a K, &'a V) { + unsafe { unwrap_unchecked(self.front.as_mut()).next_unchecked() } + } +} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl Iterator for IntoKeys { + type Item = K; + + fn next(&mut self) -> Option { + self.inner.next().map(|(k, _)| k) + } + + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } + + fn last(mut self) -> Option { + self.next_back() + } + + fn min(mut self) -> Option { + self.next() + } + + fn max(mut self) -> Option { + self.next_back() + } +} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl DoubleEndedIterator for IntoKeys { + fn next_back(&mut self) -> Option { + self.inner.next_back().map(|(k, _)| k) + } +} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl ExactSizeIterator for IntoKeys { + fn len(&self) -> usize { + self.inner.len() + } +} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl FusedIterator for IntoKeys {} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl Iterator for IntoValues { + type Item = V; + + fn next(&mut self) -> Option { + self.inner.next().map(|(_, v)| v) + } + + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } + + fn last(mut self) -> Option { + self.next_back() + } +} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl DoubleEndedIterator for IntoValues { + fn next_back(&mut self) -> Option { + self.inner.next_back().map(|(_, v)| v) + } +} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl ExactSizeIterator for IntoValues { + fn len(&self) -> usize { + self.inner.len() + } +} + +#[unstable(feature = "map_into_keys_values", issue = "75294")] +impl FusedIterator for IntoValues {} + +#[stable(feature = "btree_range", since = "1.17.0")] +impl<'a, K, V> DoubleEndedIterator for Range<'a, K, V> { + fn next_back(&mut self) -> Option<(&'a K, &'a V)> { + if self.is_empty() { None } else { Some(unsafe { self.next_back_unchecked() }) } + } +} + +impl<'a, K, V> Range<'a, K, V> { + unsafe fn next_back_unchecked(&mut self) -> (&'a K, &'a V) { + unsafe { unwrap_unchecked(self.back.as_mut()).next_back_unchecked() } + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Range<'_, K, V> {} + +#[stable(feature = "btree_range", since = "1.17.0")] +impl Clone for Range<'_, K, V> { + fn clone(&self) -> Self { + Range { front: self.front, back: self.back } + } +} + +#[stable(feature = "btree_range", since = "1.17.0")] +impl<'a, K, V> Iterator for RangeMut<'a, K, V> { + type Item = (&'a K, &'a mut V); + + fn next(&mut self) -> Option<(&'a K, &'a mut V)> { + if self.is_empty() { + None + } else { + let (k, v) = unsafe { self.next_unchecked() }; + Some((k, v)) // coerce k from `&mut K` to `&K` + } + } + + fn last(mut self) -> Option<(&'a K, &'a mut V)> { + self.next_back() + } + + fn min(mut self) -> Option<(&'a K, &'a mut V)> { + self.next() + } + + fn max(mut self) -> Option<(&'a K, &'a mut V)> { + self.next_back() + } +} + +impl<'a, K, V> RangeMut<'a, K, V> { + fn is_empty(&self) -> bool { + self.front == self.back + } + + unsafe fn next_unchecked(&mut self) -> (&'a K, &'a mut V) { + unsafe { unwrap_unchecked(self.front.as_mut()).next_unchecked() } + } + + /// Returns an iterator of references over the remaining items. + #[inline] + pub(super) fn iter(&self) -> Range<'_, K, V> { + Range { + front: self.front.as_ref().map(|f| f.reborrow()), + back: self.back.as_ref().map(|b| b.reborrow()), + } + } +} + +#[stable(feature = "btree_range", since = "1.17.0")] +impl<'a, K, V> DoubleEndedIterator for RangeMut<'a, K, V> { + fn next_back(&mut self) -> Option<(&'a K, &'a mut V)> { + if self.is_empty() { + None + } else { + let (k, v) = unsafe { self.next_back_unchecked() }; + Some((k, v)) // coerce k from `&mut K` to `&K` + } + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for RangeMut<'_, K, V> {} + +impl<'a, K, V> RangeMut<'a, K, V> { + unsafe fn next_back_unchecked(&mut self) -> (&'a K, &'a mut V) { + unsafe { unwrap_unchecked(self.back.as_mut()).next_back_unchecked() } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl FromIterator<(K, V)> for BTreeMap { + fn from_iter>(iter: T) -> BTreeMap { + let mut map = BTreeMap::new(); + map.extend(iter); + map + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Extend<(K, V)> for BTreeMap { + #[inline] + fn extend>(&mut self, iter: T) { + iter.into_iter().for_each(move |(k, v)| { + self.insert(k, v); + }); + } + + #[inline] + fn extend_one(&mut self, (k, v): (K, V)) { + self.insert(k, v); + } +} + +#[stable(feature = "extend_ref", since = "1.2.0")] +impl<'a, K: Ord + Copy, V: Copy> Extend<(&'a K, &'a V)> for BTreeMap { + fn extend>(&mut self, iter: I) { + self.extend(iter.into_iter().map(|(&key, &value)| (key, value))); + } + + #[inline] + fn extend_one(&mut self, (&k, &v): (&'a K, &'a V)) { + self.insert(k, v); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Hash for BTreeMap { + fn hash(&self, state: &mut H) { + for elt in self { + elt.hash(state); + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for BTreeMap { + /// Creates an empty `BTreeMap`. + fn default() -> BTreeMap { + BTreeMap::new() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialEq for BTreeMap { + fn eq(&self, other: &BTreeMap) -> bool { + self.len() == other.len() && self.iter().zip(other).all(|(a, b)| a == b) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Eq for BTreeMap {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialOrd for BTreeMap { + #[inline] + fn partial_cmp(&self, other: &BTreeMap) -> Option { + self.iter().partial_cmp(other.iter()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Ord for BTreeMap { + #[inline] + fn cmp(&self, other: &BTreeMap) -> Ordering { + self.iter().cmp(other.iter()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Debug for BTreeMap { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_map().entries(self.iter()).finish() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Index<&Q> for BTreeMap +where + K: Borrow, + Q: Ord, +{ + type Output = V; + + /// Returns a reference to the value corresponding to the supplied key. + /// + /// # Panics + /// + /// Panics if the key is not present in the `BTreeMap`. + #[inline] + fn index(&self, key: &Q) -> &V { + self.get(key).expect("no entry found for key") + } +} + +impl BTreeMap { + /// Gets an iterator over the entries of the map, sorted by key. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert(3, "c"); + /// map.insert(2, "b"); + /// map.insert(1, "a"); + /// + /// for (key, value) in map.iter() { + /// println!("{}: {}", key, value); + /// } + /// + /// let (first_key, first_value) = map.iter().next().unwrap(); + /// assert_eq!((*first_key, *first_value), (1, "a")); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn iter(&self) -> Iter<'_, K, V> { + if let Some(root) = &self.root { + let (f, b) = root.node_as_ref().full_range(); + + Iter { range: Range { front: Some(f), back: Some(b) }, length: self.length } + } else { + Iter { range: Range { front: None, back: None }, length: 0 } + } + } + + /// Gets a mutable iterator over the entries of the map, sorted by key. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map = BTreeMap::new(); + /// map.insert("a", 1); + /// map.insert("b", 2); + /// map.insert("c", 3); + /// + /// // add 10 to the value if the key isn't "a" + /// for (key, value) in map.iter_mut() { + /// if key != &"a" { + /// *value += 10; + /// } + /// } + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn iter_mut(&mut self) -> IterMut<'_, K, V> { + if let Some(root) = &mut self.root { + let (f, b) = root.node_as_valmut().full_range(); + + IterMut { + range: RangeMut { front: Some(f), back: Some(b), _marker: PhantomData }, + length: self.length, + } + } else { + IterMut { range: RangeMut { front: None, back: None, _marker: PhantomData }, length: 0 } + } + } + + /// Gets an iterator over the keys of the map, in sorted order. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// a.insert(2, "b"); + /// a.insert(1, "a"); + /// + /// let keys: Vec<_> = a.keys().cloned().collect(); + /// assert_eq!(keys, [1, 2]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn keys(&self) -> Keys<'_, K, V> { + Keys { inner: self.iter() } + } + + /// Gets an iterator over the values of the map, in order by key. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// a.insert(1, "hello"); + /// a.insert(2, "goodbye"); + /// + /// let values: Vec<&str> = a.values().cloned().collect(); + /// assert_eq!(values, ["hello", "goodbye"]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn values(&self) -> Values<'_, K, V> { + Values { inner: self.iter() } + } + + /// Gets a mutable iterator over the values of the map, in order by key. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// a.insert(1, String::from("hello")); + /// a.insert(2, String::from("goodbye")); + /// + /// for value in a.values_mut() { + /// value.push_str("!"); + /// } + /// + /// let values: Vec = a.values().cloned().collect(); + /// assert_eq!(values, [String::from("hello!"), + /// String::from("goodbye!")]); + /// ``` + #[stable(feature = "map_values_mut", since = "1.10.0")] + pub fn values_mut(&mut self) -> ValuesMut<'_, K, V> { + ValuesMut { inner: self.iter_mut() } + } + + /// Returns the number of elements in the map. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// assert_eq!(a.len(), 0); + /// a.insert(1, "a"); + /// assert_eq!(a.len(), 1); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_const_unstable(feature = "const_btree_new", issue = "71835")] + pub const fn len(&self) -> usize { + self.length + } + + /// Returns `true` if the map contains no elements. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut a = BTreeMap::new(); + /// assert!(a.is_empty()); + /// a.insert(1, "a"); + /// assert!(!a.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_const_unstable(feature = "const_btree_new", issue = "71835")] + pub const fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// If the root node is the empty (non-allocated) root node, allocate our + /// own node. Is an associated function to avoid borrowing the entire BTreeMap. + fn ensure_is_owned(root: &mut Option>) -> &mut node::Root { + root.get_or_insert_with(node::Root::new_leaf) + } +} + +#[cfg(test)] +mod tests; diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/btree/map/entry.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/map/entry.rs new file mode 100644 index 000000000000..0563acada8b9 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/map/entry.rs @@ -0,0 +1,477 @@ +use crate::gccrs_core_prelude::*; + +use core::fmt::{self, Debug}; +use core::marker::PhantomData; +use core::mem; + +use super::super::borrow::DormantMutRef; +use super::super::node::{marker, Handle, InsertResult::*, NodeRef}; +use super::BTreeMap; + +use Entry::*; + +/// A view into a single entry in a map, which may either be vacant or occupied. +/// +/// This `enum` is constructed from the [`entry`] method on [`BTreeMap`]. +/// +/// [`entry`]: BTreeMap::entry +#[stable(feature = "rust1", since = "1.0.0")] +pub enum Entry<'a, K: 'a, V: 'a> { + /// A vacant entry. + #[stable(feature = "rust1", since = "1.0.0")] + Vacant(#[stable(feature = "rust1", since = "1.0.0")] VacantEntry<'a, K, V>), + + /// An occupied entry. + #[stable(feature = "rust1", since = "1.0.0")] + Occupied(#[stable(feature = "rust1", since = "1.0.0")] OccupiedEntry<'a, K, V>), +} + +#[stable(feature = "debug_btree_map", since = "1.12.0")] +impl Debug for Entry<'_, K, V> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match *self { + Vacant(ref v) => f.debug_tuple("Entry").field(v).finish(), + Occupied(ref o) => f.debug_tuple("Entry").field(o).finish(), + } + } +} + +/// A view into a vacant entry in a `BTreeMap`. +/// It is part of the [`Entry`] enum. +#[stable(feature = "rust1", since = "1.0.0")] +pub struct VacantEntry<'a, K: 'a, V: 'a> { + pub(super) key: K, + pub(super) handle: Handle, K, V, marker::Leaf>, marker::Edge>, + pub(super) dormant_map: DormantMutRef<'a, BTreeMap>, + + // Be invariant in `K` and `V` + pub(super) _marker: PhantomData<&'a mut (K, V)>, +} + +#[stable(feature = "debug_btree_map", since = "1.12.0")] +impl Debug for VacantEntry<'_, K, V> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("VacantEntry").field(self.key()).finish() + } +} + +/// A view into an occupied entry in a `BTreeMap`. +/// It is part of the [`Entry`] enum. +#[stable(feature = "rust1", since = "1.0.0")] +pub struct OccupiedEntry<'a, K: 'a, V: 'a> { + pub(super) handle: Handle, K, V, marker::LeafOrInternal>, marker::KV>, + pub(super) dormant_map: DormantMutRef<'a, BTreeMap>, + + // Be invariant in `K` and `V` + pub(super) _marker: PhantomData<&'a mut (K, V)>, +} + +#[stable(feature = "debug_btree_map", since = "1.12.0")] +impl Debug for OccupiedEntry<'_, K, V> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("OccupiedEntry").field("key", self.key()).field("value", self.get()).finish() + } +} + +impl<'a, K: Ord, V> Entry<'a, K, V> { + /// Ensures a value is in the entry by inserting the default if empty, and returns + /// a mutable reference to the value in the entry. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// map.entry("poneyland").or_insert(12); + /// + /// assert_eq!(map["poneyland"], 12); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn or_insert(self, default: V) -> &'a mut V { + match self { + Occupied(entry) => entry.into_mut(), + Vacant(entry) => entry.insert(default), + } + } + + /// Ensures a value is in the entry by inserting the result of the default function if empty, + /// and returns a mutable reference to the value in the entry. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap<&str, String> = BTreeMap::new(); + /// let s = "hoho".to_string(); + /// + /// map.entry("poneyland").or_insert_with(|| s); + /// + /// assert_eq!(map["poneyland"], "hoho".to_string()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn or_insert_with V>(self, default: F) -> &'a mut V { + match self { + Occupied(entry) => entry.into_mut(), + Vacant(entry) => entry.insert(default()), + } + } + + #[unstable(feature = "or_insert_with_key", issue = "71024")] + /// Ensures a value is in the entry by inserting, if empty, the result of the default function, + /// which takes the key as its argument, and returns a mutable reference to the value in the + /// entry. + /// + /// # Examples + /// + /// ``` + /// #![feature(or_insert_with_key)] + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// + /// map.entry("poneyland").or_insert_with_key(|key| key.chars().count()); + /// + /// assert_eq!(map["poneyland"], 9); + /// ``` + #[inline] + pub fn or_insert_with_key V>(self, default: F) -> &'a mut V { + match self { + Occupied(entry) => entry.into_mut(), + Vacant(entry) => { + let value = default(entry.key()); + entry.insert(value) + } + } + } + + /// Returns a reference to this entry's key. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// assert_eq!(map.entry("poneyland").key(), &"poneyland"); + /// ``` + #[stable(feature = "map_entry_keys", since = "1.10.0")] + pub fn key(&self) -> &K { + match *self { + Occupied(ref entry) => entry.key(), + Vacant(ref entry) => entry.key(), + } + } + + /// Provides in-place mutable access to an occupied entry before any + /// potential inserts into the map. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// + /// map.entry("poneyland") + /// .and_modify(|e| { *e += 1 }) + /// .or_insert(42); + /// assert_eq!(map["poneyland"], 42); + /// + /// map.entry("poneyland") + /// .and_modify(|e| { *e += 1 }) + /// .or_insert(42); + /// assert_eq!(map["poneyland"], 43); + /// ``` + #[stable(feature = "entry_and_modify", since = "1.26.0")] + pub fn and_modify(self, f: F) -> Self + where + F: FnOnce(&mut V), + { + match self { + Occupied(mut entry) => { + f(entry.get_mut()); + Occupied(entry) + } + Vacant(entry) => Vacant(entry), + } + } +} + +impl<'a, K: Ord, V: Default> Entry<'a, K, V> { + #[stable(feature = "entry_or_default", since = "1.28.0")] + /// Ensures a value is in the entry by inserting the default value if empty, + /// and returns a mutable reference to the value in the entry. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap<&str, Option> = BTreeMap::new(); + /// map.entry("poneyland").or_default(); + /// + /// assert_eq!(map["poneyland"], None); + /// ``` + pub fn or_default(self) -> &'a mut V { + match self { + Occupied(entry) => entry.into_mut(), + Vacant(entry) => entry.insert(Default::default()), + } + } +} + +impl<'a, K: Ord, V> VacantEntry<'a, K, V> { + /// Gets a reference to the key that would be used when inserting a value + /// through the VacantEntry. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// assert_eq!(map.entry("poneyland").key(), &"poneyland"); + /// ``` + #[stable(feature = "map_entry_keys", since = "1.10.0")] + pub fn key(&self) -> &K { + &self.key + } + + /// Take ownership of the key. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// use std::collections::btree_map::Entry; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// + /// if let Entry::Vacant(v) = map.entry("poneyland") { + /// v.into_key(); + /// } + /// ``` + #[stable(feature = "map_entry_recover_keys2", since = "1.12.0")] + pub fn into_key(self) -> K { + self.key + } + + /// Sets the value of the entry with the `VacantEntry`'s key, + /// and returns a mutable reference to it. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// use std::collections::btree_map::Entry; + /// + /// let mut map: BTreeMap<&str, u32> = BTreeMap::new(); + /// + /// if let Entry::Vacant(o) = map.entry("poneyland") { + /// o.insert(37); + /// } + /// assert_eq!(map["poneyland"], 37); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn insert(self, value: V) -> &'a mut V { + let out_ptr = match self.handle.insert_recursing(self.key, value) { + (Fit(_), val_ptr) => { + // Safety: We have consumed self.handle and the handle returned. + let map = unsafe { self.dormant_map.awaken() }; + map.length += 1; + val_ptr + } + (Split(ins), val_ptr) => { + drop(ins.left); + // Safety: We have consumed self.handle and the reference returned. + let map = unsafe { self.dormant_map.awaken() }; + let root = map.root.as_mut().unwrap(); + root.push_internal_level().push(ins.k, ins.v, ins.right); + map.length += 1; + val_ptr + } + }; + // Now that we have finished growing the tree using borrowed references, + // dereference the pointer to a part of it, that we picked up along the way. + unsafe { &mut *out_ptr } + } +} + +impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> { + /// Gets a reference to the key in the entry. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// map.entry("poneyland").or_insert(12); + /// assert_eq!(map.entry("poneyland").key(), &"poneyland"); + /// ``` + #[stable(feature = "map_entry_keys", since = "1.10.0")] + pub fn key(&self) -> &K { + self.handle.reborrow().into_kv().0 + } + + /// Take ownership of the key and value from the map. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// use std::collections::btree_map::Entry; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// map.entry("poneyland").or_insert(12); + /// + /// if let Entry::Occupied(o) = map.entry("poneyland") { + /// // We delete the entry from the map. + /// o.remove_entry(); + /// } + /// + /// // If now try to get the value, it will panic: + /// // println!("{}", map["poneyland"]); + /// ``` + #[stable(feature = "map_entry_recover_keys2", since = "1.12.0")] + pub fn remove_entry(self) -> (K, V) { + self.remove_kv() + } + + /// Gets a reference to the value in the entry. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// use std::collections::btree_map::Entry; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// map.entry("poneyland").or_insert(12); + /// + /// if let Entry::Occupied(o) = map.entry("poneyland") { + /// assert_eq!(o.get(), &12); + /// } + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn get(&self) -> &V { + self.handle.reborrow().into_kv().1 + } + + /// Gets a mutable reference to the value in the entry. + /// + /// If you need a reference to the `OccupiedEntry` that may outlive the + /// destruction of the `Entry` value, see [`into_mut`]. + /// + /// [`into_mut`]: OccupiedEntry::into_mut + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// use std::collections::btree_map::Entry; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// map.entry("poneyland").or_insert(12); + /// + /// assert_eq!(map["poneyland"], 12); + /// if let Entry::Occupied(mut o) = map.entry("poneyland") { + /// *o.get_mut() += 10; + /// assert_eq!(*o.get(), 22); + /// + /// // We can use the same Entry multiple times. + /// *o.get_mut() += 2; + /// } + /// assert_eq!(map["poneyland"], 24); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn get_mut(&mut self) -> &mut V { + self.handle.kv_mut().1 + } + + /// Converts the entry into a mutable reference to its value. + /// + /// If you need multiple references to the `OccupiedEntry`, see [`get_mut`]. + /// + /// [`get_mut`]: OccupiedEntry::get_mut + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// use std::collections::btree_map::Entry; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// map.entry("poneyland").or_insert(12); + /// + /// assert_eq!(map["poneyland"], 12); + /// if let Entry::Occupied(o) = map.entry("poneyland") { + /// *o.into_mut() += 10; + /// } + /// assert_eq!(map["poneyland"], 22); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn into_mut(self) -> &'a mut V { + self.handle.into_val_mut() + } + + /// Sets the value of the entry with the `OccupiedEntry`'s key, + /// and returns the entry's old value. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// use std::collections::btree_map::Entry; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// map.entry("poneyland").or_insert(12); + /// + /// if let Entry::Occupied(mut o) = map.entry("poneyland") { + /// assert_eq!(o.insert(15), 12); + /// } + /// assert_eq!(map["poneyland"], 15); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn insert(&mut self, value: V) -> V { + mem::replace(self.get_mut(), value) + } + + /// Takes the value of the entry out of the map, and returns it. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeMap; + /// use std::collections::btree_map::Entry; + /// + /// let mut map: BTreeMap<&str, usize> = BTreeMap::new(); + /// map.entry("poneyland").or_insert(12); + /// + /// if let Entry::Occupied(o) = map.entry("poneyland") { + /// assert_eq!(o.remove(), 12); + /// } + /// // If we try to get "poneyland"'s value, it'll panic: + /// // println!("{}", map["poneyland"]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn remove(self) -> V { + self.remove_kv().1 + } + + // Body of `remove_entry`, separate to keep the above implementations short. + pub(super) fn remove_kv(self) -> (K, V) { + let mut emptied_internal_root = false; + let (old_kv, _) = self.handle.remove_kv_tracking(|| emptied_internal_root = true); + // SAFETY: we consumed the intermediate root borrow, `self.handle`. + let map = unsafe { self.dormant_map.awaken() }; + map.length -= 1; + if emptied_internal_root { + let root = map.root.as_mut().unwrap(); + root.pop_internal_level(); + } + old_kv + } +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/btree/map/tests.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/map/tests.rs new file mode 100644 index 000000000000..dd3ebcccf76a --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/map/tests.rs @@ -0,0 +1,1884 @@ +use super::super::{node, DeterministicRng}; +use super::Entry::{Occupied, Vacant}; +use super::*; +use crate::boxed::Box; +use crate::fmt::Debug; +use crate::rc::Rc; +use crate::string::{String, ToString}; +use crate::vec::Vec; +use std::convert::TryFrom; +use std::iter::{self, FromIterator}; +use std::mem; +use std::ops::Bound::{self, Excluded, Included, Unbounded}; +use std::ops::RangeBounds; +use std::panic::{catch_unwind, AssertUnwindSafe}; +use std::sync::atomic::{AtomicUsize, Ordering}; + +// Capacity of a tree with a single level, +// i.e., a tree who's root is a leaf node at height 0. +const NODE_CAPACITY: usize = node::CAPACITY; + +// Minimum number of elements to insert, to guarantee a tree with 2 levels, +// i.e., a tree who's root is an internal node at height 1, with edges to leaf nodes. +// It's not the minimum size: removing an element from such a tree does not always reduce height. +const MIN_INSERTS_HEIGHT_1: usize = NODE_CAPACITY + 1; + +// Minimum number of elements to insert in ascending order, to guarantee a tree with 3 levels, +// i.e., a tree who's root is an internal node at height 2, with edges to more internal nodes. +// It's not the minimum size: removing an element from such a tree does not always reduce height. +const MIN_INSERTS_HEIGHT_2: usize = 89; + +// Gather all references from a mutable iterator and make sure Miri notices if +// using them is dangerous. +fn test_all_refs<'a, T: 'a>(dummy: &mut T, iter: impl Iterator) { + // Gather all those references. + let mut refs: Vec<&mut T> = iter.collect(); + // Use them all. Twice, to be sure we got all interleavings. + for r in refs.iter_mut() { + mem::swap(dummy, r); + } + for r in refs { + mem::swap(dummy, r); + } +} + +impl BTreeMap { + /// Panics if the map (or the code navigating it) is corrupted. + fn check(&self) + where + K: Copy + Debug + Ord, + { + if let Some(root) = &self.root { + let root_node = root.node_as_ref(); + + assert!(root_node.ascend().is_err()); + root_node.assert_back_pointers(); + + assert_eq!(self.length, root_node.calc_length()); + + root_node.assert_min_len(if root_node.height() > 0 { 1 } else { 0 }); + } else { + assert_eq!(self.length, 0); + } + + self.assert_ascending(); + } + + /// Returns the height of the root, if any. + fn height(&self) -> Option { + self.root.as_ref().map(node::Root::height) + } + + fn dump_keys(&self) -> String + where + K: Debug, + { + if let Some(root) = self.root.as_ref() { + root.node_as_ref().dump_keys() + } else { + String::from("not yet allocated") + } + } + + /// Asserts that the keys are in strictly ascending order. + fn assert_ascending(&self) + where + K: Copy + Debug + Ord, + { + let mut num_seen = 0; + let mut keys = self.keys(); + if let Some(mut previous) = keys.next() { + num_seen = 1; + for next in keys { + assert!(previous < next, "{:?} >= {:?}", previous, next); + previous = next; + num_seen += 1; + } + } + assert_eq!(num_seen, self.len()); + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::LeafOrInternal> { + fn assert_min_len(self, min_len: usize) { + assert!(self.len() >= min_len, "{} < {}", self.len(), min_len); + if let node::ForceResult::Internal(node) = self.force() { + for idx in 0..=node.len() { + let edge = unsafe { Handle::new_edge(node, idx) }; + edge.descend().assert_min_len(MIN_LEN); + } + } + } +} + +// Test our value of MIN_INSERTS_HEIGHT_2. It may change according to the +// implementation of insertion, but it's best to be aware of when it does. +#[test] +fn test_levels() { + let mut map = BTreeMap::new(); + map.check(); + assert_eq!(map.height(), None); + assert_eq!(map.len(), 0); + + map.insert(0, ()); + while map.height() == Some(0) { + let last_key = *map.last_key_value().unwrap().0; + map.insert(last_key + 1, ()); + } + map.check(); + // Structure: + // - 1 element in internal root node with 2 children + // - 6 elements in left leaf child + // - 5 elements in right leaf child + assert_eq!(map.height(), Some(1)); + assert_eq!(map.len(), MIN_INSERTS_HEIGHT_1, "{}", map.dump_keys()); + + while map.height() == Some(1) { + let last_key = *map.last_key_value().unwrap().0; + map.insert(last_key + 1, ()); + } + map.check(); + // Structure: + // - 1 element in internal root node with 2 children + // - 6 elements in left internal child with 7 grandchildren + // - 42 elements in left child's 7 grandchildren with 6 elements each + // - 5 elements in right internal child with 6 grandchildren + // - 30 elements in right child's 5 first grandchildren with 6 elements each + // - 5 elements in right child's last grandchild + assert_eq!(map.height(), Some(2)); + assert_eq!(map.len(), MIN_INSERTS_HEIGHT_2, "{}", map.dump_keys()); +} + +#[test] +fn test_basic_large() { + let mut map = BTreeMap::new(); + // Miri is too slow + let size = if cfg!(miri) { MIN_INSERTS_HEIGHT_2 } else { 10000 }; + let size = size + (size % 2); // round up to even number + assert_eq!(map.len(), 0); + + for i in 0..size { + assert_eq!(map.insert(i, 10 * i), None); + assert_eq!(map.len(), i + 1); + } + + assert_eq!(map.first_key_value(), Some((&0, &0))); + assert_eq!(map.last_key_value(), Some((&(size - 1), &(10 * (size - 1))))); + assert_eq!(map.first_entry().unwrap().key(), &0); + assert_eq!(map.last_entry().unwrap().key(), &(size - 1)); + + for i in 0..size { + assert_eq!(map.get(&i).unwrap(), &(i * 10)); + } + + for i in size..size * 2 { + assert_eq!(map.get(&i), None); + } + + for i in 0..size { + assert_eq!(map.insert(i, 100 * i), Some(10 * i)); + assert_eq!(map.len(), size); + } + + for i in 0..size { + assert_eq!(map.get(&i).unwrap(), &(i * 100)); + } + + for i in 0..size / 2 { + assert_eq!(map.remove(&(i * 2)), Some(i * 200)); + assert_eq!(map.len(), size - i - 1); + } + + for i in 0..size / 2 { + assert_eq!(map.get(&(2 * i)), None); + assert_eq!(map.get(&(2 * i + 1)).unwrap(), &(i * 200 + 100)); + } + + for i in 0..size / 2 { + assert_eq!(map.remove(&(2 * i)), None); + assert_eq!(map.remove(&(2 * i + 1)), Some(i * 200 + 100)); + assert_eq!(map.len(), size / 2 - i - 1); + } + map.check(); +} + +#[test] +fn test_basic_small() { + let mut map = BTreeMap::new(); + // Empty, root is absent (None): + assert_eq!(map.remove(&1), None); + assert_eq!(map.len(), 0); + assert_eq!(map.get(&1), None); + assert_eq!(map.get_mut(&1), None); + assert_eq!(map.first_key_value(), None); + assert_eq!(map.last_key_value(), None); + assert_eq!(map.keys().count(), 0); + assert_eq!(map.values().count(), 0); + assert_eq!(map.range(..).next(), None); + assert_eq!(map.range(..1).next(), None); + assert_eq!(map.range(1..).next(), None); + assert_eq!(map.range(1..=1).next(), None); + assert_eq!(map.range(1..2).next(), None); + assert_eq!(map.height(), None); + assert_eq!(map.insert(1, 1), None); + assert_eq!(map.height(), Some(0)); + map.check(); + + // 1 key-value pair: + assert_eq!(map.len(), 1); + assert_eq!(map.get(&1), Some(&1)); + assert_eq!(map.get_mut(&1), Some(&mut 1)); + assert_eq!(map.first_key_value(), Some((&1, &1))); + assert_eq!(map.last_key_value(), Some((&1, &1))); + assert_eq!(map.keys().collect::>(), vec![&1]); + assert_eq!(map.values().collect::>(), vec![&1]); + assert_eq!(map.insert(1, 2), Some(1)); + assert_eq!(map.len(), 1); + assert_eq!(map.get(&1), Some(&2)); + assert_eq!(map.get_mut(&1), Some(&mut 2)); + assert_eq!(map.first_key_value(), Some((&1, &2))); + assert_eq!(map.last_key_value(), Some((&1, &2))); + assert_eq!(map.keys().collect::>(), vec![&1]); + assert_eq!(map.values().collect::>(), vec![&2]); + assert_eq!(map.insert(2, 4), None); + assert_eq!(map.height(), Some(0)); + map.check(); + + // 2 key-value pairs: + assert_eq!(map.len(), 2); + assert_eq!(map.get(&2), Some(&4)); + assert_eq!(map.get_mut(&2), Some(&mut 4)); + assert_eq!(map.first_key_value(), Some((&1, &2))); + assert_eq!(map.last_key_value(), Some((&2, &4))); + assert_eq!(map.keys().collect::>(), vec![&1, &2]); + assert_eq!(map.values().collect::>(), vec![&2, &4]); + assert_eq!(map.remove(&1), Some(2)); + assert_eq!(map.height(), Some(0)); + map.check(); + + // 1 key-value pair: + assert_eq!(map.len(), 1); + assert_eq!(map.get(&1), None); + assert_eq!(map.get_mut(&1), None); + assert_eq!(map.get(&2), Some(&4)); + assert_eq!(map.get_mut(&2), Some(&mut 4)); + assert_eq!(map.first_key_value(), Some((&2, &4))); + assert_eq!(map.last_key_value(), Some((&2, &4))); + assert_eq!(map.keys().collect::>(), vec![&2]); + assert_eq!(map.values().collect::>(), vec![&4]); + assert_eq!(map.remove(&2), Some(4)); + assert_eq!(map.height(), Some(0)); + map.check(); + + // Empty but root is owned (Some(...)): + assert_eq!(map.len(), 0); + assert_eq!(map.get(&1), None); + assert_eq!(map.get_mut(&1), None); + assert_eq!(map.first_key_value(), None); + assert_eq!(map.last_key_value(), None); + assert_eq!(map.keys().count(), 0); + assert_eq!(map.values().count(), 0); + assert_eq!(map.range(..).next(), None); + assert_eq!(map.range(..1).next(), None); + assert_eq!(map.range(1..).next(), None); + assert_eq!(map.range(1..=1).next(), None); + assert_eq!(map.range(1..2).next(), None); + assert_eq!(map.remove(&1), None); + assert_eq!(map.height(), Some(0)); + map.check(); +} + +#[test] +fn test_iter() { + // Miri is too slow + let size = if cfg!(miri) { 200 } else { 10000 }; + + let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); + + fn test(size: usize, mut iter: T) + where + T: Iterator, + { + for i in 0..size { + assert_eq!(iter.size_hint(), (size - i, Some(size - i))); + assert_eq!(iter.next().unwrap(), (i, i)); + } + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + } + test(size, map.iter().map(|(&k, &v)| (k, v))); + test(size, map.iter_mut().map(|(&k, &mut v)| (k, v))); + test(size, map.into_iter()); +} + +#[test] +fn test_iter_rev() { + // Miri is too slow + let size = if cfg!(miri) { 200 } else { 10000 }; + + let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); + + fn test(size: usize, mut iter: T) + where + T: Iterator, + { + for i in 0..size { + assert_eq!(iter.size_hint(), (size - i, Some(size - i))); + assert_eq!(iter.next().unwrap(), (size - i - 1, size - i - 1)); + } + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + } + test(size, map.iter().rev().map(|(&k, &v)| (k, v))); + test(size, map.iter_mut().rev().map(|(&k, &mut v)| (k, v))); + test(size, map.into_iter().rev()); +} + +/// Specifically tests iter_mut's ability to mutate the value of pairs in-line +fn do_test_iter_mut_mutation(size: usize) +where + T: Copy + Debug + Ord + TryFrom, + >::Error: Debug, +{ + let zero = T::try_from(0).unwrap(); + let mut map: BTreeMap = (0..size).map(|i| (T::try_from(i).unwrap(), zero)).collect(); + + // Forward and backward iteration sees enough pairs (also tested elsewhere) + assert_eq!(map.iter_mut().count(), size); + assert_eq!(map.iter_mut().rev().count(), size); + + // Iterate forwards, trying to mutate to unique values + for (i, (k, v)) in map.iter_mut().enumerate() { + assert_eq!(*k, T::try_from(i).unwrap()); + assert_eq!(*v, zero); + *v = T::try_from(i + 1).unwrap(); + } + + // Iterate backwards, checking that mutations succeeded and trying to mutate again + for (i, (k, v)) in map.iter_mut().rev().enumerate() { + assert_eq!(*k, T::try_from(size - i - 1).unwrap()); + assert_eq!(*v, T::try_from(size - i).unwrap()); + *v = T::try_from(2 * size - i).unwrap(); + } + + // Check that backward mutations succeeded + for (i, (k, v)) in map.iter_mut().enumerate() { + assert_eq!(*k, T::try_from(i).unwrap()); + assert_eq!(*v, T::try_from(size + i + 1).unwrap()); + } + map.check(); +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord)] +#[repr(align(32))] +struct Align32(usize); + +impl TryFrom for Align32 { + type Error = (); + + fn try_from(s: usize) -> Result { + Ok(Align32(s)) + } +} + +#[test] +fn test_iter_mut_mutation() { + // Check many alignments and trees with roots at various heights. + do_test_iter_mut_mutation::(0); + do_test_iter_mut_mutation::(1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_2); + do_test_iter_mut_mutation::(1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_2); + do_test_iter_mut_mutation::(1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_2); + do_test_iter_mut_mutation::(1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_2); + do_test_iter_mut_mutation::(1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_2); + do_test_iter_mut_mutation::(1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_1); + do_test_iter_mut_mutation::(MIN_INSERTS_HEIGHT_2); +} + +#[test] +fn test_values_mut() { + let mut a: BTreeMap<_, _> = (0..MIN_INSERTS_HEIGHT_2).map(|i| (i, i)).collect(); + test_all_refs(&mut 13, a.values_mut()); + a.check(); +} + +#[test] +fn test_values_mut_mutation() { + let mut a = BTreeMap::new(); + a.insert(1, String::from("hello")); + a.insert(2, String::from("goodbye")); + + for value in a.values_mut() { + value.push_str("!"); + } + + let values: Vec = a.values().cloned().collect(); + assert_eq!(values, [String::from("hello!"), String::from("goodbye!")]); + a.check(); +} + +#[test] +fn test_iter_entering_root_twice() { + let mut map: BTreeMap<_, _> = (0..2).map(|i| (i, i)).collect(); + let mut it = map.iter_mut(); + let front = it.next().unwrap(); + let back = it.next_back().unwrap(); + assert_eq!(front, (&0, &mut 0)); + assert_eq!(back, (&1, &mut 1)); + *front.1 = 24; + *back.1 = 42; + assert_eq!(front, (&0, &mut 24)); + assert_eq!(back, (&1, &mut 42)); + map.check(); +} + +#[test] +fn test_iter_descending_to_same_node_twice() { + let mut map: BTreeMap<_, _> = (0..MIN_INSERTS_HEIGHT_1).map(|i| (i, i)).collect(); + let mut it = map.iter_mut(); + // Descend into first child. + let front = it.next().unwrap(); + // Descend into first child again, after running through second child. + while it.next_back().is_some() {} + // Check immutable access. + assert_eq!(front, (&0, &mut 0)); + // Perform mutable access. + *front.1 = 42; + map.check(); +} + +#[test] +fn test_iter_mixed() { + // Miri is too slow + let size = if cfg!(miri) { 200 } else { 10000 }; + + let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); + + fn test(size: usize, mut iter: T) + where + T: Iterator + DoubleEndedIterator, + { + for i in 0..size / 4 { + assert_eq!(iter.size_hint(), (size - i * 2, Some(size - i * 2))); + assert_eq!(iter.next().unwrap(), (i, i)); + assert_eq!(iter.next_back().unwrap(), (size - i - 1, size - i - 1)); + } + for i in size / 4..size * 3 / 4 { + assert_eq!(iter.size_hint(), (size * 3 / 4 - i, Some(size * 3 / 4 - i))); + assert_eq!(iter.next().unwrap(), (i, i)); + } + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + } + test(size, map.iter().map(|(&k, &v)| (k, v))); + test(size, map.iter_mut().map(|(&k, &mut v)| (k, v))); + test(size, map.into_iter()); +} + +#[test] +fn test_iter_min_max() { + let mut a = BTreeMap::new(); + assert_eq!(a.iter().min(), None); + assert_eq!(a.iter().max(), None); + assert_eq!(a.iter_mut().min(), None); + assert_eq!(a.iter_mut().max(), None); + assert_eq!(a.range(..).min(), None); + assert_eq!(a.range(..).max(), None); + assert_eq!(a.range_mut(..).min(), None); + assert_eq!(a.range_mut(..).max(), None); + assert_eq!(a.keys().min(), None); + assert_eq!(a.keys().max(), None); + assert_eq!(a.values().min(), None); + assert_eq!(a.values().max(), None); + assert_eq!(a.values_mut().min(), None); + assert_eq!(a.values_mut().max(), None); + a.insert(1, 42); + a.insert(2, 24); + assert_eq!(a.iter().min(), Some((&1, &42))); + assert_eq!(a.iter().max(), Some((&2, &24))); + assert_eq!(a.iter_mut().min(), Some((&1, &mut 42))); + assert_eq!(a.iter_mut().max(), Some((&2, &mut 24))); + assert_eq!(a.range(..).min(), Some((&1, &42))); + assert_eq!(a.range(..).max(), Some((&2, &24))); + assert_eq!(a.range_mut(..).min(), Some((&1, &mut 42))); + assert_eq!(a.range_mut(..).max(), Some((&2, &mut 24))); + assert_eq!(a.keys().min(), Some(&1)); + assert_eq!(a.keys().max(), Some(&2)); + assert_eq!(a.values().min(), Some(&24)); + assert_eq!(a.values().max(), Some(&42)); + assert_eq!(a.values_mut().min(), Some(&mut 24)); + assert_eq!(a.values_mut().max(), Some(&mut 42)); + a.check(); +} + +fn range_keys(map: &BTreeMap, range: impl RangeBounds) -> Vec { + map.range(range) + .map(|(&k, &v)| { + assert_eq!(k, v); + k + }) + .collect() +} + +#[test] +fn test_range_small() { + let size = 4; + + let map: BTreeMap<_, _> = (1..=size).map(|i| (i, i)).collect(); + let all: Vec<_> = (1..=size).collect(); + let (first, last) = (vec![all[0]], vec![all[size as usize - 1]]); + + assert_eq!(range_keys(&map, (Excluded(0), Excluded(size + 1))), all); + assert_eq!(range_keys(&map, (Excluded(0), Included(size + 1))), all); + assert_eq!(range_keys(&map, (Excluded(0), Included(size))), all); + assert_eq!(range_keys(&map, (Excluded(0), Unbounded)), all); + assert_eq!(range_keys(&map, (Included(0), Excluded(size + 1))), all); + assert_eq!(range_keys(&map, (Included(0), Included(size + 1))), all); + assert_eq!(range_keys(&map, (Included(0), Included(size))), all); + assert_eq!(range_keys(&map, (Included(0), Unbounded)), all); + assert_eq!(range_keys(&map, (Included(1), Excluded(size + 1))), all); + assert_eq!(range_keys(&map, (Included(1), Included(size + 1))), all); + assert_eq!(range_keys(&map, (Included(1), Included(size))), all); + assert_eq!(range_keys(&map, (Included(1), Unbounded)), all); + assert_eq!(range_keys(&map, (Unbounded, Excluded(size + 1))), all); + assert_eq!(range_keys(&map, (Unbounded, Included(size + 1))), all); + assert_eq!(range_keys(&map, (Unbounded, Included(size))), all); + assert_eq!(range_keys(&map, ..), all); + + assert_eq!(range_keys(&map, (Excluded(0), Excluded(1))), vec![]); + assert_eq!(range_keys(&map, (Excluded(0), Included(0))), vec![]); + assert_eq!(range_keys(&map, (Included(0), Included(0))), vec![]); + assert_eq!(range_keys(&map, (Included(0), Excluded(1))), vec![]); + assert_eq!(range_keys(&map, (Unbounded, Excluded(1))), vec![]); + assert_eq!(range_keys(&map, (Unbounded, Included(0))), vec![]); + assert_eq!(range_keys(&map, (Excluded(0), Excluded(2))), first); + assert_eq!(range_keys(&map, (Excluded(0), Included(1))), first); + assert_eq!(range_keys(&map, (Included(0), Excluded(2))), first); + assert_eq!(range_keys(&map, (Included(0), Included(1))), first); + assert_eq!(range_keys(&map, (Included(1), Excluded(2))), first); + assert_eq!(range_keys(&map, (Included(1), Included(1))), first); + assert_eq!(range_keys(&map, (Unbounded, Excluded(2))), first); + assert_eq!(range_keys(&map, (Unbounded, Included(1))), first); + assert_eq!(range_keys(&map, (Excluded(size - 1), Excluded(size + 1))), last); + assert_eq!(range_keys(&map, (Excluded(size - 1), Included(size + 1))), last); + assert_eq!(range_keys(&map, (Excluded(size - 1), Included(size))), last); + assert_eq!(range_keys(&map, (Excluded(size - 1), Unbounded)), last); + assert_eq!(range_keys(&map, (Included(size), Excluded(size + 1))), last); + assert_eq!(range_keys(&map, (Included(size), Included(size + 1))), last); + assert_eq!(range_keys(&map, (Included(size), Included(size))), last); + assert_eq!(range_keys(&map, (Included(size), Unbounded)), last); + assert_eq!(range_keys(&map, (Excluded(size), Excluded(size + 1))), vec![]); + assert_eq!(range_keys(&map, (Excluded(size), Included(size))), vec![]); + assert_eq!(range_keys(&map, (Excluded(size), Unbounded)), vec![]); + assert_eq!(range_keys(&map, (Included(size + 1), Excluded(size + 1))), vec![]); + assert_eq!(range_keys(&map, (Included(size + 1), Included(size + 1))), vec![]); + assert_eq!(range_keys(&map, (Included(size + 1), Unbounded)), vec![]); + + assert_eq!(range_keys(&map, ..3), vec![1, 2]); + assert_eq!(range_keys(&map, 3..), vec![3, 4]); + assert_eq!(range_keys(&map, 2..=3), vec![2, 3]); +} + +#[test] +fn test_range_height_1() { + // Tests tree with a root and 2 leaves. Depending on details we don't want or need + // to rely upon, the single key at the root will be 6 or 7. + + let map: BTreeMap<_, _> = (1..=MIN_INSERTS_HEIGHT_1 as i32).map(|i| (i, i)).collect(); + for &root in &[6, 7] { + assert_eq!(range_keys(&map, (Excluded(root), Excluded(root + 1))), vec![]); + assert_eq!(range_keys(&map, (Excluded(root), Included(root + 1))), vec![root + 1]); + assert_eq!(range_keys(&map, (Included(root), Excluded(root + 1))), vec![root]); + assert_eq!(range_keys(&map, (Included(root), Included(root + 1))), vec![root, root + 1]); + + assert_eq!(range_keys(&map, (Excluded(root - 1), Excluded(root))), vec![]); + assert_eq!(range_keys(&map, (Included(root - 1), Excluded(root))), vec![root - 1]); + assert_eq!(range_keys(&map, (Excluded(root - 1), Included(root))), vec![root]); + assert_eq!(range_keys(&map, (Included(root - 1), Included(root))), vec![root - 1, root]); + } +} + +#[test] +fn test_range_large() { + let size = 200; + + let map: BTreeMap<_, _> = (1..=size).map(|i| (i, i)).collect(); + let all: Vec<_> = (1..=size).collect(); + let (first, last) = (vec![all[0]], vec![all[size as usize - 1]]); + + assert_eq!(range_keys(&map, (Excluded(0), Excluded(size + 1))), all); + assert_eq!(range_keys(&map, (Excluded(0), Included(size + 1))), all); + assert_eq!(range_keys(&map, (Excluded(0), Included(size))), all); + assert_eq!(range_keys(&map, (Excluded(0), Unbounded)), all); + assert_eq!(range_keys(&map, (Included(0), Excluded(size + 1))), all); + assert_eq!(range_keys(&map, (Included(0), Included(size + 1))), all); + assert_eq!(range_keys(&map, (Included(0), Included(size))), all); + assert_eq!(range_keys(&map, (Included(0), Unbounded)), all); + assert_eq!(range_keys(&map, (Included(1), Excluded(size + 1))), all); + assert_eq!(range_keys(&map, (Included(1), Included(size + 1))), all); + assert_eq!(range_keys(&map, (Included(1), Included(size))), all); + assert_eq!(range_keys(&map, (Included(1), Unbounded)), all); + assert_eq!(range_keys(&map, (Unbounded, Excluded(size + 1))), all); + assert_eq!(range_keys(&map, (Unbounded, Included(size + 1))), all); + assert_eq!(range_keys(&map, (Unbounded, Included(size))), all); + assert_eq!(range_keys(&map, ..), all); + + assert_eq!(range_keys(&map, (Excluded(0), Excluded(1))), vec![]); + assert_eq!(range_keys(&map, (Excluded(0), Included(0))), vec![]); + assert_eq!(range_keys(&map, (Included(0), Included(0))), vec![]); + assert_eq!(range_keys(&map, (Included(0), Excluded(1))), vec![]); + assert_eq!(range_keys(&map, (Unbounded, Excluded(1))), vec![]); + assert_eq!(range_keys(&map, (Unbounded, Included(0))), vec![]); + assert_eq!(range_keys(&map, (Excluded(0), Excluded(2))), first); + assert_eq!(range_keys(&map, (Excluded(0), Included(1))), first); + assert_eq!(range_keys(&map, (Included(0), Excluded(2))), first); + assert_eq!(range_keys(&map, (Included(0), Included(1))), first); + assert_eq!(range_keys(&map, (Included(1), Excluded(2))), first); + assert_eq!(range_keys(&map, (Included(1), Included(1))), first); + assert_eq!(range_keys(&map, (Unbounded, Excluded(2))), first); + assert_eq!(range_keys(&map, (Unbounded, Included(1))), first); + assert_eq!(range_keys(&map, (Excluded(size - 1), Excluded(size + 1))), last); + assert_eq!(range_keys(&map, (Excluded(size - 1), Included(size + 1))), last); + assert_eq!(range_keys(&map, (Excluded(size - 1), Included(size))), last); + assert_eq!(range_keys(&map, (Excluded(size - 1), Unbounded)), last); + assert_eq!(range_keys(&map, (Included(size), Excluded(size + 1))), last); + assert_eq!(range_keys(&map, (Included(size), Included(size + 1))), last); + assert_eq!(range_keys(&map, (Included(size), Included(size))), last); + assert_eq!(range_keys(&map, (Included(size), Unbounded)), last); + assert_eq!(range_keys(&map, (Excluded(size), Excluded(size + 1))), vec![]); + assert_eq!(range_keys(&map, (Excluded(size), Included(size))), vec![]); + assert_eq!(range_keys(&map, (Excluded(size), Unbounded)), vec![]); + assert_eq!(range_keys(&map, (Included(size + 1), Excluded(size + 1))), vec![]); + assert_eq!(range_keys(&map, (Included(size + 1), Included(size + 1))), vec![]); + assert_eq!(range_keys(&map, (Included(size + 1), Unbounded)), vec![]); + + fn check<'a, L, R>(lhs: L, rhs: R) + where + L: IntoIterator, + R: IntoIterator, + { + let lhs: Vec<_> = lhs.into_iter().collect(); + let rhs: Vec<_> = rhs.into_iter().collect(); + assert_eq!(lhs, rhs); + } + + check(map.range(..=100), map.range(..101)); + check(map.range(5..=8), vec![(&5, &5), (&6, &6), (&7, &7), (&8, &8)]); + check(map.range(-1..=2), vec![(&1, &1), (&2, &2)]); +} + +#[test] +fn test_range_inclusive_max_value() { + let max = usize::MAX; + let map: BTreeMap<_, _> = vec![(max, 0)].into_iter().collect(); + + assert_eq!(map.range(max..=max).collect::>(), &[(&max, &0)]); +} + +#[test] +fn test_range_equal_empty_cases() { + let map: BTreeMap<_, _> = (0..5).map(|i| (i, i)).collect(); + assert_eq!(map.range((Included(2), Excluded(2))).next(), None); + assert_eq!(map.range((Excluded(2), Included(2))).next(), None); +} + +#[test] +#[should_panic] +fn test_range_equal_excluded() { + let map: BTreeMap<_, _> = (0..5).map(|i| (i, i)).collect(); + map.range((Excluded(2), Excluded(2))); +} + +#[test] +#[should_panic] +fn test_range_backwards_1() { + let map: BTreeMap<_, _> = (0..5).map(|i| (i, i)).collect(); + map.range((Included(3), Included(2))); +} + +#[test] +#[should_panic] +fn test_range_backwards_2() { + let map: BTreeMap<_, _> = (0..5).map(|i| (i, i)).collect(); + map.range((Included(3), Excluded(2))); +} + +#[test] +#[should_panic] +fn test_range_backwards_3() { + let map: BTreeMap<_, _> = (0..5).map(|i| (i, i)).collect(); + map.range((Excluded(3), Included(2))); +} + +#[test] +#[should_panic] +fn test_range_backwards_4() { + let map: BTreeMap<_, _> = (0..5).map(|i| (i, i)).collect(); + map.range((Excluded(3), Excluded(2))); +} + +#[test] +fn test_range_1000() { + // Miri is too slow + let size = if cfg!(miri) { MIN_INSERTS_HEIGHT_2 as u32 } else { 1000 }; + let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); + + fn test(map: &BTreeMap, size: u32, min: Bound<&u32>, max: Bound<&u32>) { + let mut kvs = map.range((min, max)).map(|(&k, &v)| (k, v)); + let mut pairs = (0..size).map(|i| (i, i)); + + for (kv, pair) in kvs.by_ref().zip(pairs.by_ref()) { + assert_eq!(kv, pair); + } + assert_eq!(kvs.next(), None); + assert_eq!(pairs.next(), None); + } + test(&map, size, Included(&0), Excluded(&size)); + test(&map, size, Unbounded, Excluded(&size)); + test(&map, size, Included(&0), Included(&(size - 1))); + test(&map, size, Unbounded, Included(&(size - 1))); + test(&map, size, Included(&0), Unbounded); + test(&map, size, Unbounded, Unbounded); +} + +#[test] +fn test_range_borrowed_key() { + let mut map = BTreeMap::new(); + map.insert("aardvark".to_string(), 1); + map.insert("baboon".to_string(), 2); + map.insert("coyote".to_string(), 3); + map.insert("dingo".to_string(), 4); + // NOTE: would like to use simply "b".."d" here... + let mut iter = map.range::((Included("b"), Excluded("d"))); + assert_eq!(iter.next(), Some((&"baboon".to_string(), &2))); + assert_eq!(iter.next(), Some((&"coyote".to_string(), &3))); + assert_eq!(iter.next(), None); +} + +#[test] +fn test_range() { + let size = 200; + // Miri is too slow + let step = if cfg!(miri) { 66 } else { 1 }; + let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); + + for i in (0..size).step_by(step) { + for j in (i..size).step_by(step) { + let mut kvs = map.range((Included(&i), Included(&j))).map(|(&k, &v)| (k, v)); + let mut pairs = (i..=j).map(|i| (i, i)); + + for (kv, pair) in kvs.by_ref().zip(pairs.by_ref()) { + assert_eq!(kv, pair); + } + assert_eq!(kvs.next(), None); + assert_eq!(pairs.next(), None); + } + } +} + +#[test] +fn test_range_mut() { + let size = 200; + // Miri is too slow + let step = if cfg!(miri) { 66 } else { 1 }; + let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect(); + + for i in (0..size).step_by(step) { + for j in (i..size).step_by(step) { + let mut kvs = map.range_mut((Included(&i), Included(&j))).map(|(&k, &mut v)| (k, v)); + let mut pairs = (i..=j).map(|i| (i, i)); + + for (kv, pair) in kvs.by_ref().zip(pairs.by_ref()) { + assert_eq!(kv, pair); + } + assert_eq!(kvs.next(), None); + assert_eq!(pairs.next(), None); + } + } + map.check(); +} + +mod test_drain_filter { + use super::*; + + #[test] + fn empty() { + let mut map: BTreeMap = BTreeMap::new(); + map.drain_filter(|_, _| unreachable!("there's nothing to decide on")); + assert!(map.is_empty()); + map.check(); + } + + #[test] + fn consuming_nothing() { + let pairs = (0..3).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.collect(); + assert!(map.drain_filter(|_, _| false).eq(iter::empty())); + map.check(); + } + + #[test] + fn consuming_all() { + let pairs = (0..3).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.clone().collect(); + assert!(map.drain_filter(|_, _| true).eq(pairs)); + map.check(); + } + + #[test] + fn mutating_and_keeping() { + let pairs = (0..3).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.collect(); + assert!( + map.drain_filter(|_, v| { + *v += 6; + false + }) + .eq(iter::empty()) + ); + assert!(map.keys().copied().eq(0..3)); + assert!(map.values().copied().eq(6..9)); + map.check(); + } + + #[test] + fn mutating_and_removing() { + let pairs = (0..3).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.collect(); + assert!( + map.drain_filter(|_, v| { + *v += 6; + true + }) + .eq((0..3).map(|i| (i, i + 6))) + ); + assert!(map.is_empty()); + map.check(); + } + + #[test] + fn underfull_keeping_all() { + let pairs = (0..3).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.collect(); + map.drain_filter(|_, _| false); + assert!(map.keys().copied().eq(0..3)); + map.check(); + } + + #[test] + fn underfull_removing_one() { + let pairs = (0..3).map(|i| (i, i)); + for doomed in 0..3 { + let mut map: BTreeMap<_, _> = pairs.clone().collect(); + map.drain_filter(|i, _| *i == doomed); + assert_eq!(map.len(), 2); + map.check(); + } + } + + #[test] + fn underfull_keeping_one() { + let pairs = (0..3).map(|i| (i, i)); + for sacred in 0..3 { + let mut map: BTreeMap<_, _> = pairs.clone().collect(); + map.drain_filter(|i, _| *i != sacred); + assert!(map.keys().copied().eq(sacred..=sacred)); + map.check(); + } + } + + #[test] + fn underfull_removing_all() { + let pairs = (0..3).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.collect(); + map.drain_filter(|_, _| true); + assert!(map.is_empty()); + map.check(); + } + + #[test] + fn height_0_keeping_all() { + let pairs = (0..NODE_CAPACITY).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.collect(); + map.drain_filter(|_, _| false); + assert!(map.keys().copied().eq(0..NODE_CAPACITY)); + map.check(); + } + + #[test] + fn height_0_removing_one() { + let pairs = (0..NODE_CAPACITY).map(|i| (i, i)); + for doomed in 0..NODE_CAPACITY { + let mut map: BTreeMap<_, _> = pairs.clone().collect(); + map.drain_filter(|i, _| *i == doomed); + assert_eq!(map.len(), NODE_CAPACITY - 1); + map.check(); + } + } + + #[test] + fn height_0_keeping_one() { + let pairs = (0..NODE_CAPACITY).map(|i| (i, i)); + for sacred in 0..NODE_CAPACITY { + let mut map: BTreeMap<_, _> = pairs.clone().collect(); + map.drain_filter(|i, _| *i != sacred); + assert!(map.keys().copied().eq(sacred..=sacred)); + map.check(); + } + } + + #[test] + fn height_0_removing_all() { + let pairs = (0..NODE_CAPACITY).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.collect(); + map.drain_filter(|_, _| true); + assert!(map.is_empty()); + map.check(); + } + + #[test] + fn height_0_keeping_half() { + let mut map: BTreeMap<_, _> = (0..16).map(|i| (i, i)).collect(); + assert_eq!(map.drain_filter(|i, _| *i % 2 == 0).count(), 8); + assert_eq!(map.len(), 8); + map.check(); + } + + #[test] + fn height_1_removing_all() { + let pairs = (0..MIN_INSERTS_HEIGHT_1).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.collect(); + map.drain_filter(|_, _| true); + assert!(map.is_empty()); + map.check(); + } + + #[test] + fn height_1_removing_one() { + let pairs = (0..MIN_INSERTS_HEIGHT_1).map(|i| (i, i)); + for doomed in 0..MIN_INSERTS_HEIGHT_1 { + let mut map: BTreeMap<_, _> = pairs.clone().collect(); + map.drain_filter(|i, _| *i == doomed); + assert_eq!(map.len(), MIN_INSERTS_HEIGHT_1 - 1); + map.check(); + } + } + + #[test] + fn height_1_keeping_one() { + let pairs = (0..MIN_INSERTS_HEIGHT_1).map(|i| (i, i)); + for sacred in 0..MIN_INSERTS_HEIGHT_1 { + let mut map: BTreeMap<_, _> = pairs.clone().collect(); + map.drain_filter(|i, _| *i != sacred); + assert!(map.keys().copied().eq(sacred..=sacred)); + map.check(); + } + } + + #[test] + fn height_2_removing_one() { + let pairs = (0..MIN_INSERTS_HEIGHT_2).map(|i| (i, i)); + for doomed in (0..MIN_INSERTS_HEIGHT_2).step_by(12) { + let mut map: BTreeMap<_, _> = pairs.clone().collect(); + map.drain_filter(|i, _| *i == doomed); + assert_eq!(map.len(), MIN_INSERTS_HEIGHT_2 - 1); + map.check(); + } + } + + #[test] + fn height_2_keeping_one() { + let pairs = (0..MIN_INSERTS_HEIGHT_2).map(|i| (i, i)); + for sacred in (0..MIN_INSERTS_HEIGHT_2).step_by(12) { + let mut map: BTreeMap<_, _> = pairs.clone().collect(); + map.drain_filter(|i, _| *i != sacred); + assert!(map.keys().copied().eq(sacred..=sacred)); + map.check(); + } + } + + #[test] + fn height_2_removing_all() { + let pairs = (0..MIN_INSERTS_HEIGHT_2).map(|i| (i, i)); + let mut map: BTreeMap<_, _> = pairs.collect(); + map.drain_filter(|_, _| true); + assert!(map.is_empty()); + map.check(); + } + + #[test] + fn drop_panic_leak() { + static PREDS: AtomicUsize = AtomicUsize::new(0); + static DROPS: AtomicUsize = AtomicUsize::new(0); + + struct D; + impl Drop for D { + fn drop(&mut self) { + if DROPS.fetch_add(1, Ordering::SeqCst) == 1 { + panic!("panic in `drop`"); + } + } + } + + // Keys are multiples of 4, so that each key is counted by a hexadecimal digit. + let mut map = (0..3).map(|i| (i * 4, D)).collect::>(); + + catch_unwind(move || { + drop(map.drain_filter(|i, _| { + PREDS.fetch_add(1usize << i, Ordering::SeqCst); + true + })) + }) + .unwrap_err(); + + assert_eq!(PREDS.load(Ordering::SeqCst), 0x011); + assert_eq!(DROPS.load(Ordering::SeqCst), 3); + } + + #[test] + fn pred_panic_leak() { + static PREDS: AtomicUsize = AtomicUsize::new(0); + static DROPS: AtomicUsize = AtomicUsize::new(0); + + struct D; + impl Drop for D { + fn drop(&mut self) { + DROPS.fetch_add(1, Ordering::SeqCst); + } + } + + // Keys are multiples of 4, so that each key is counted by a hexadecimal digit. + let mut map = (0..3).map(|i| (i * 4, D)).collect::>(); + + catch_unwind(AssertUnwindSafe(|| { + drop(map.drain_filter(|i, _| { + PREDS.fetch_add(1usize << i, Ordering::SeqCst); + match i { + 0 => true, + _ => panic!(), + } + })) + })) + .unwrap_err(); + + assert_eq!(PREDS.load(Ordering::SeqCst), 0x011); + assert_eq!(DROPS.load(Ordering::SeqCst), 1); + assert_eq!(map.len(), 2); + assert_eq!(map.first_entry().unwrap().key(), &4); + assert_eq!(map.last_entry().unwrap().key(), &8); + map.check(); + } + + // Same as above, but attempt to use the iterator again after the panic in the predicate + #[test] + fn pred_panic_reuse() { + static PREDS: AtomicUsize = AtomicUsize::new(0); + static DROPS: AtomicUsize = AtomicUsize::new(0); + + struct D; + impl Drop for D { + fn drop(&mut self) { + DROPS.fetch_add(1, Ordering::SeqCst); + } + } + + // Keys are multiples of 4, so that each key is counted by a hexadecimal digit. + let mut map = (0..3).map(|i| (i * 4, D)).collect::>(); + + { + let mut it = map.drain_filter(|i, _| { + PREDS.fetch_add(1usize << i, Ordering::SeqCst); + match i { + 0 => true, + _ => panic!(), + } + }); + catch_unwind(AssertUnwindSafe(|| while it.next().is_some() {})).unwrap_err(); + // Iterator behaviour after a panic is explicitly unspecified, + // so this is just the current implementation: + let result = catch_unwind(AssertUnwindSafe(|| it.next())); + assert!(matches!(result, Ok(None))); + } + + assert_eq!(PREDS.load(Ordering::SeqCst), 0x011); + assert_eq!(DROPS.load(Ordering::SeqCst), 1); + assert_eq!(map.len(), 2); + assert_eq!(map.first_entry().unwrap().key(), &4); + assert_eq!(map.last_entry().unwrap().key(), &8); + map.check(); + } +} + +#[test] +fn test_borrow() { + // make sure these compile -- using the Borrow trait + { + let mut map = BTreeMap::new(); + map.insert("0".to_string(), 1); + assert_eq!(map["0"], 1); + } + + { + let mut map = BTreeMap::new(); + map.insert(Box::new(0), 1); + assert_eq!(map[&0], 1); + } + + { + let mut map = BTreeMap::new(); + map.insert(Box::new([0, 1]) as Box<[i32]>, 1); + assert_eq!(map[&[0, 1][..]], 1); + } + + { + let mut map = BTreeMap::new(); + map.insert(Rc::new(0), 1); + assert_eq!(map[&0], 1); + } +} + +#[test] +fn test_entry() { + let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)]; + + let mut map: BTreeMap<_, _> = xs.iter().cloned().collect(); + + // Existing key (insert) + match map.entry(1) { + Vacant(_) => unreachable!(), + Occupied(mut view) => { + assert_eq!(view.get(), &10); + assert_eq!(view.insert(100), 10); + } + } + assert_eq!(map.get(&1).unwrap(), &100); + assert_eq!(map.len(), 6); + + // Existing key (update) + match map.entry(2) { + Vacant(_) => unreachable!(), + Occupied(mut view) => { + let v = view.get_mut(); + *v *= 10; + } + } + assert_eq!(map.get(&2).unwrap(), &200); + assert_eq!(map.len(), 6); + map.check(); + + // Existing key (take) + match map.entry(3) { + Vacant(_) => unreachable!(), + Occupied(view) => { + assert_eq!(view.remove(), 30); + } + } + assert_eq!(map.get(&3), None); + assert_eq!(map.len(), 5); + map.check(); + + // Inexistent key (insert) + match map.entry(10) { + Occupied(_) => unreachable!(), + Vacant(view) => { + assert_eq!(*view.insert(1000), 1000); + } + } + assert_eq!(map.get(&10).unwrap(), &1000); + assert_eq!(map.len(), 6); + map.check(); +} + +#[test] +fn test_extend_ref() { + let mut a = BTreeMap::new(); + a.insert(1, "one"); + let mut b = BTreeMap::new(); + b.insert(2, "two"); + b.insert(3, "three"); + + a.extend(&b); + + assert_eq!(a.len(), 3); + assert_eq!(a[&1], "one"); + assert_eq!(a[&2], "two"); + assert_eq!(a[&3], "three"); + a.check(); +} + +#[test] +fn test_zst() { + let mut m = BTreeMap::new(); + assert_eq!(m.len(), 0); + + assert_eq!(m.insert((), ()), None); + assert_eq!(m.len(), 1); + + assert_eq!(m.insert((), ()), Some(())); + assert_eq!(m.len(), 1); + assert_eq!(m.iter().count(), 1); + + m.clear(); + assert_eq!(m.len(), 0); + + for _ in 0..100 { + m.insert((), ()); + } + + assert_eq!(m.len(), 1); + assert_eq!(m.iter().count(), 1); + m.check(); +} + +// This test's only purpose is to ensure that zero-sized keys with nonsensical orderings +// do not cause segfaults when used with zero-sized values. All other map behavior is +// undefined. +#[test] +fn test_bad_zst() { + use std::cmp::Ordering; + + #[derive(Clone, Copy, Debug)] + struct Bad; + + impl PartialEq for Bad { + fn eq(&self, _: &Self) -> bool { + false + } + } + + impl Eq for Bad {} + + impl PartialOrd for Bad { + fn partial_cmp(&self, _: &Self) -> Option { + Some(Ordering::Less) + } + } + + impl Ord for Bad { + fn cmp(&self, _: &Self) -> Ordering { + Ordering::Less + } + } + + let mut m = BTreeMap::new(); + + for _ in 0..100 { + m.insert(Bad, Bad); + } + m.check(); +} + +#[test] +fn test_clone() { + let mut map = BTreeMap::new(); + let size = MIN_INSERTS_HEIGHT_1; + assert_eq!(map.len(), 0); + + for i in 0..size { + assert_eq!(map.insert(i, 10 * i), None); + assert_eq!(map.len(), i + 1); + map.check(); + assert_eq!(map, map.clone()); + } + + for i in 0..size { + assert_eq!(map.insert(i, 100 * i), Some(10 * i)); + assert_eq!(map.len(), size); + map.check(); + assert_eq!(map, map.clone()); + } + + for i in 0..size / 2 { + assert_eq!(map.remove(&(i * 2)), Some(i * 200)); + assert_eq!(map.len(), size - i - 1); + map.check(); + assert_eq!(map, map.clone()); + } + + for i in 0..size / 2 { + assert_eq!(map.remove(&(2 * i)), None); + assert_eq!(map.remove(&(2 * i + 1)), Some(i * 200 + 100)); + assert_eq!(map.len(), size / 2 - i - 1); + map.check(); + assert_eq!(map, map.clone()); + } + + // Test a tree with 2 semi-full levels and a tree with 3 levels. + map = (1..MIN_INSERTS_HEIGHT_2).map(|i| (i, i)).collect(); + assert_eq!(map.len(), MIN_INSERTS_HEIGHT_2 - 1); + assert_eq!(map, map.clone()); + map.insert(0, 0); + assert_eq!(map.len(), MIN_INSERTS_HEIGHT_2); + assert_eq!(map, map.clone()); + map.check(); +} + +#[test] +fn test_clone_from() { + let mut map1 = BTreeMap::new(); + let max_size = MIN_INSERTS_HEIGHT_1; + + // Range to max_size inclusive, because i is the size of map1 being tested. + for i in 0..=max_size { + let mut map2 = BTreeMap::new(); + for j in 0..i { + let mut map1_copy = map2.clone(); + map1_copy.clone_from(&map1); // small cloned from large + assert_eq!(map1_copy, map1); + let mut map2_copy = map1.clone(); + map2_copy.clone_from(&map2); // large cloned from small + assert_eq!(map2_copy, map2); + map2.insert(100 * j + 1, 2 * j + 1); + } + map2.clone_from(&map1); // same length + map2.check(); + assert_eq!(map2, map1); + map1.insert(i, 10 * i); + map1.check(); + } +} + +#[allow(dead_code)] +fn test_variance() { + fn map_key<'new>(v: BTreeMap<&'static str, ()>) -> BTreeMap<&'new str, ()> { + v + } + fn map_val<'new>(v: BTreeMap<(), &'static str>) -> BTreeMap<(), &'new str> { + v + } + + fn iter_key<'a, 'new>(v: Iter<'a, &'static str, ()>) -> Iter<'a, &'new str, ()> { + v + } + fn iter_val<'a, 'new>(v: Iter<'a, (), &'static str>) -> Iter<'a, (), &'new str> { + v + } + + fn into_iter_key<'new>(v: IntoIter<&'static str, ()>) -> IntoIter<&'new str, ()> { + v + } + fn into_iter_val<'new>(v: IntoIter<(), &'static str>) -> IntoIter<(), &'new str> { + v + } + + fn into_keys_key<'new>(v: IntoKeys<&'static str, ()>) -> IntoKeys<&'new str, ()> { + v + } + fn into_keys_val<'new>(v: IntoKeys<(), &'static str>) -> IntoKeys<(), &'new str> { + v + } + + fn into_values_key<'new>(v: IntoValues<&'static str, ()>) -> IntoValues<&'new str, ()> { + v + } + fn into_values_val<'new>(v: IntoValues<(), &'static str>) -> IntoValues<(), &'new str> { + v + } + + fn range_key<'a, 'new>(v: Range<'a, &'static str, ()>) -> Range<'a, &'new str, ()> { + v + } + fn range_val<'a, 'new>(v: Range<'a, (), &'static str>) -> Range<'a, (), &'new str> { + v + } + + fn keys_key<'a, 'new>(v: Keys<'a, &'static str, ()>) -> Keys<'a, &'new str, ()> { + v + } + fn keys_val<'a, 'new>(v: Keys<'a, (), &'static str>) -> Keys<'a, (), &'new str> { + v + } + + fn values_key<'a, 'new>(v: Values<'a, &'static str, ()>) -> Values<'a, &'new str, ()> { + v + } + fn values_val<'a, 'new>(v: Values<'a, (), &'static str>) -> Values<'a, (), &'new str> { + v + } +} + +#[allow(dead_code)] +fn test_sync() { + fn map(v: &BTreeMap) -> impl Sync + '_ { + v + } + + fn into_iter(v: BTreeMap) -> impl Sync { + v.into_iter() + } + + fn into_keys(v: BTreeMap) -> impl Sync { + v.into_keys() + } + + fn into_values(v: BTreeMap) -> impl Sync { + v.into_values() + } + + fn drain_filter(v: &mut BTreeMap) -> impl Sync + '_ { + v.drain_filter(|_, _| false) + } + + fn iter(v: &BTreeMap) -> impl Sync + '_ { + v.iter() + } + + fn iter_mut(v: &mut BTreeMap) -> impl Sync + '_ { + v.iter_mut() + } + + fn keys(v: &BTreeMap) -> impl Sync + '_ { + v.keys() + } + + fn values(v: &BTreeMap) -> impl Sync + '_ { + v.values() + } + + fn values_mut(v: &mut BTreeMap) -> impl Sync + '_ { + v.values_mut() + } + + fn range(v: &BTreeMap) -> impl Sync + '_ { + v.range(..) + } + + fn range_mut(v: &mut BTreeMap) -> impl Sync + '_ { + v.range_mut(..) + } + + fn entry(v: &mut BTreeMap) -> impl Sync + '_ { + v.entry(Default::default()) + } + + fn occupied_entry(v: &mut BTreeMap) -> impl Sync + '_ { + match v.entry(Default::default()) { + Occupied(entry) => entry, + _ => unreachable!(), + } + } + + fn vacant_entry(v: &mut BTreeMap) -> impl Sync + '_ { + match v.entry(Default::default()) { + Vacant(entry) => entry, + _ => unreachable!(), + } + } +} + +#[allow(dead_code)] +fn test_send() { + fn map(v: BTreeMap) -> impl Send { + v + } + + fn into_iter(v: BTreeMap) -> impl Send { + v.into_iter() + } + + fn into_keys(v: BTreeMap) -> impl Send { + v.into_keys() + } + + fn into_values(v: BTreeMap) -> impl Send { + v.into_values() + } + + fn drain_filter(v: &mut BTreeMap) -> impl Send + '_ { + v.drain_filter(|_, _| false) + } + + fn iter(v: &BTreeMap) -> impl Send + '_ { + v.iter() + } + + fn iter_mut(v: &mut BTreeMap) -> impl Send + '_ { + v.iter_mut() + } + + fn keys(v: &BTreeMap) -> impl Send + '_ { + v.keys() + } + + fn values(v: &BTreeMap) -> impl Send + '_ { + v.values() + } + + fn values_mut(v: &mut BTreeMap) -> impl Send + '_ { + v.values_mut() + } + + fn range(v: &BTreeMap) -> impl Send + '_ { + v.range(..) + } + + fn range_mut(v: &mut BTreeMap) -> impl Send + '_ { + v.range_mut(..) + } + + fn entry(v: &mut BTreeMap) -> impl Send + '_ { + v.entry(Default::default()) + } + + fn occupied_entry(v: &mut BTreeMap) -> impl Send + '_ { + match v.entry(Default::default()) { + Occupied(entry) => entry, + _ => unreachable!(), + } + } + + fn vacant_entry(v: &mut BTreeMap) -> impl Send + '_ { + match v.entry(Default::default()) { + Vacant(entry) => entry, + _ => unreachable!(), + } + } +} + +#[allow(dead_code)] +fn test_const() { + const MAP: &'static BTreeMap<(), ()> = &BTreeMap::new(); + const LEN: usize = MAP.len(); + const IS_EMPTY: bool = MAP.is_empty(); +} + +#[test] +fn test_occupied_entry_key() { + let mut a = BTreeMap::new(); + let key = "hello there"; + let value = "value goes here"; + assert!(a.is_empty()); + a.insert(key.clone(), value.clone()); + assert_eq!(a.len(), 1); + assert_eq!(a[key], value); + + match a.entry(key.clone()) { + Vacant(_) => panic!(), + Occupied(e) => assert_eq!(key, *e.key()), + } + assert_eq!(a.len(), 1); + assert_eq!(a[key], value); + a.check(); +} + +#[test] +fn test_vacant_entry_key() { + let mut a = BTreeMap::new(); + let key = "hello there"; + let value = "value goes here"; + + assert!(a.is_empty()); + match a.entry(key.clone()) { + Occupied(_) => panic!(), + Vacant(e) => { + assert_eq!(key, *e.key()); + e.insert(value.clone()); + } + } + assert_eq!(a.len(), 1); + assert_eq!(a[key], value); + a.check(); +} + +#[test] +fn test_first_last_entry() { + let mut a = BTreeMap::new(); + assert!(a.first_entry().is_none()); + assert!(a.last_entry().is_none()); + a.insert(1, 42); + assert_eq!(a.first_entry().unwrap().key(), &1); + assert_eq!(a.last_entry().unwrap().key(), &1); + a.insert(2, 24); + assert_eq!(a.first_entry().unwrap().key(), &1); + assert_eq!(a.last_entry().unwrap().key(), &2); + a.insert(0, 6); + assert_eq!(a.first_entry().unwrap().key(), &0); + assert_eq!(a.last_entry().unwrap().key(), &2); + let (k1, v1) = a.first_entry().unwrap().remove_entry(); + assert_eq!(k1, 0); + assert_eq!(v1, 6); + let (k2, v2) = a.last_entry().unwrap().remove_entry(); + assert_eq!(k2, 2); + assert_eq!(v2, 24); + assert_eq!(a.first_entry().unwrap().key(), &1); + assert_eq!(a.last_entry().unwrap().key(), &1); + a.check(); +} + +#[test] +fn test_insert_into_full_left() { + let mut map: BTreeMap<_, _> = (0..NODE_CAPACITY).map(|i| (i * 2, ())).collect(); + assert!(map.insert(NODE_CAPACITY, ()).is_none()); + map.check(); +} + +#[test] +fn test_insert_into_full_right() { + let mut map: BTreeMap<_, _> = (0..NODE_CAPACITY).map(|i| (i * 2, ())).collect(); + assert!(map.insert(NODE_CAPACITY + 2, ()).is_none()); + map.check(); +} + +macro_rules! create_append_test { + ($name:ident, $len:expr) => { + #[test] + fn $name() { + let mut a = BTreeMap::new(); + for i in 0..8 { + a.insert(i, i); + } + + let mut b = BTreeMap::new(); + for i in 5..$len { + b.insert(i, 2 * i); + } + + a.append(&mut b); + + assert_eq!(a.len(), $len); + assert_eq!(b.len(), 0); + + for i in 0..$len { + if i < 5 { + assert_eq!(a[&i], i); + } else { + assert_eq!(a[&i], 2 * i); + } + } + + a.check(); + assert_eq!(a.remove(&($len - 1)), Some(2 * ($len - 1))); + assert_eq!(a.insert($len - 1, 20), None); + a.check(); + } + }; +} + +// These are mostly for testing the algorithm that "fixes" the right edge after insertion. +// Single node. +create_append_test!(test_append_9, 9); +// Two leafs that don't need fixing. +create_append_test!(test_append_17, 17); +// Two leafs where the second one ends up underfull and needs stealing at the end. +create_append_test!(test_append_14, 14); +// Two leafs where the second one ends up empty because the insertion finished at the root. +create_append_test!(test_append_12, 12); +// Three levels; insertion finished at the root. +create_append_test!(test_append_144, 144); +// Three levels; insertion finished at leaf while there is an empty node on the second level. +create_append_test!(test_append_145, 145); +// Tests for several randomly chosen sizes. +create_append_test!(test_append_170, 170); +create_append_test!(test_append_181, 181); +#[cfg(not(miri))] // Miri is too slow +create_append_test!(test_append_239, 239); +#[cfg(not(miri))] // Miri is too slow +create_append_test!(test_append_1700, 1700); + +#[test] +fn test_append_drop_leak() { + static DROPS: AtomicUsize = AtomicUsize::new(0); + + struct D; + + impl Drop for D { + fn drop(&mut self) { + if DROPS.fetch_add(1, Ordering::SeqCst) == 0 { + panic!("panic in `drop`"); + } + } + } + + let mut left = BTreeMap::new(); + let mut right = BTreeMap::new(); + left.insert(0, D); + left.insert(1, D); // first to be dropped during append + left.insert(2, D); + right.insert(1, D); + right.insert(2, D); + + catch_unwind(move || left.append(&mut right)).unwrap_err(); + + assert_eq!(DROPS.load(Ordering::SeqCst), 4); // Rust issue #47949 ate one little piggy +} + +fn rand_data(len: usize) -> Vec<(u32, u32)> { + assert!(len * 2 <= 70029); // from that point on numbers repeat + let mut rng = DeterministicRng::new(); + Vec::from_iter((0..len).map(|_| (rng.next(), rng.next()))) +} + +#[test] +fn test_split_off_empty_right() { + let mut data = rand_data(173); + + let mut map = BTreeMap::from_iter(data.clone()); + let right = map.split_off(&(data.iter().max().unwrap().0 + 1)); + map.check(); + right.check(); + + data.sort(); + assert!(map.into_iter().eq(data)); + assert!(right.into_iter().eq(None)); +} + +#[test] +fn test_split_off_empty_left() { + let mut data = rand_data(314); + + let mut map = BTreeMap::from_iter(data.clone()); + let right = map.split_off(&data.iter().min().unwrap().0); + map.check(); + right.check(); + + data.sort(); + assert!(map.into_iter().eq(None)); + assert!(right.into_iter().eq(data)); +} + +// In a tree with 3 levels, if all but a part of the first leaf node is split off, +// make sure fix_top eliminates both top levels. +#[test] +fn test_split_off_tiny_left_height_2() { + let pairs = (0..MIN_INSERTS_HEIGHT_2).map(|i| (i, i)); + let mut left: BTreeMap<_, _> = pairs.clone().collect(); + let right = left.split_off(&1); + left.check(); + right.check(); + assert_eq!(left.len(), 1); + assert_eq!(right.len(), MIN_INSERTS_HEIGHT_2 - 1); + assert_eq!(*left.first_key_value().unwrap().0, 0); + assert_eq!(*right.first_key_value().unwrap().0, 1); +} + +// In a tree with 3 levels, if only part of the last leaf node is split off, +// make sure fix_top eliminates both top levels. +#[test] +fn test_split_off_tiny_right_height_2() { + let pairs = (0..MIN_INSERTS_HEIGHT_2).map(|i| (i, i)); + let last = MIN_INSERTS_HEIGHT_2 - 1; + let mut left: BTreeMap<_, _> = pairs.clone().collect(); + assert_eq!(*left.last_key_value().unwrap().0, last); + let right = left.split_off(&last); + left.check(); + right.check(); + assert_eq!(left.len(), MIN_INSERTS_HEIGHT_2 - 1); + assert_eq!(right.len(), 1); + assert_eq!(*left.last_key_value().unwrap().0, last - 1); + assert_eq!(*right.last_key_value().unwrap().0, last); +} + +#[test] +fn test_split_off_large_random_sorted() { + // Miri is too slow + let mut data = if cfg!(miri) { rand_data(529) } else { rand_data(1529) }; + // special case with maximum height. + data.sort(); + + let mut map = BTreeMap::from_iter(data.clone()); + let key = data[data.len() / 2].0; + let right = map.split_off(&key); + map.check(); + right.check(); + + assert!(map.into_iter().eq(data.clone().into_iter().filter(|x| x.0 < key))); + assert!(right.into_iter().eq(data.into_iter().filter(|x| x.0 >= key))); +} + +#[test] +fn test_into_iter_drop_leak_height_0() { + static DROPS: AtomicUsize = AtomicUsize::new(0); + + struct D; + + impl Drop for D { + fn drop(&mut self) { + if DROPS.fetch_add(1, Ordering::SeqCst) == 3 { + panic!("panic in `drop`"); + } + } + } + + let mut map = BTreeMap::new(); + map.insert("a", D); + map.insert("b", D); + map.insert("c", D); + map.insert("d", D); + map.insert("e", D); + + catch_unwind(move || drop(map.into_iter())).unwrap_err(); + + assert_eq!(DROPS.load(Ordering::SeqCst), 5); +} + +#[test] +fn test_into_iter_drop_leak_height_1() { + let size = MIN_INSERTS_HEIGHT_1; + static DROPS: AtomicUsize = AtomicUsize::new(0); + static PANIC_POINT: AtomicUsize = AtomicUsize::new(0); + + struct D; + impl Drop for D { + fn drop(&mut self) { + if DROPS.fetch_add(1, Ordering::SeqCst) == PANIC_POINT.load(Ordering::SeqCst) { + panic!("panic in `drop`"); + } + } + } + + for panic_point in vec![0, 1, size - 2, size - 1] { + DROPS.store(0, Ordering::SeqCst); + PANIC_POINT.store(panic_point, Ordering::SeqCst); + let map: BTreeMap<_, _> = (0..size).map(|i| (i, D)).collect(); + catch_unwind(move || drop(map.into_iter())).unwrap_err(); + assert_eq!(DROPS.load(Ordering::SeqCst), size); + } +} + +#[test] +fn test_into_keys() { + let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')]; + let map: BTreeMap<_, _> = vec.into_iter().collect(); + let keys: Vec<_> = map.into_keys().collect(); + + assert_eq!(keys.len(), 3); + assert!(keys.contains(&1)); + assert!(keys.contains(&2)); + assert!(keys.contains(&3)); +} + +#[test] +fn test_into_values() { + let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')]; + let map: BTreeMap<_, _> = vec.into_iter().collect(); + let values: Vec<_> = map.into_values().collect(); + + assert_eq!(values.len(), 3); + assert!(values.contains(&'a')); + assert!(values.contains(&'b')); + assert!(values.contains(&'c')); +} + +#[test] +fn test_insert_remove_intertwined() { + let loops = if cfg!(miri) { 100 } else { 1_000_000 }; + let mut map = BTreeMap::new(); + let mut i = 1; + for _ in 0..loops { + i = (i + 421) & 0xFF; + map.insert(i, i); + map.remove(&(0xFF - i)); + } + + map.check(); +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/btree/mem.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/mem.rs new file mode 100644 index 000000000000..aad78aabd2b1 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/mem.rs @@ -0,0 +1,36 @@ +use crate::gccrs_core_prelude::*; + +use core::intrinsics; +use core::mem; +use core::ptr; + +/// This replaces the value behind the `v` unique reference by calling the +/// relevant function. +/// +/// If a panic occurs in the `change` closure, the entire process will be aborted. +#[inline] +pub fn take_mut(v: &mut T, change: impl FnOnce(T) -> T) { + replace(v, |value| (change(value), ())) +} + +/// This replaces the value behind the `v` unique reference by calling the +/// relevant function, and returns a result obtained along the way. +/// +/// If a panic occurs in the `change` closure, the entire process will be aborted. +#[inline] +pub fn replace(v: &mut T, change: impl FnOnce(T) -> (T, R)) -> R { + struct PanicGuard; + impl Drop for PanicGuard { + fn drop(&mut self) { + intrinsics::abort() + } + } + let guard = PanicGuard; + let value = unsafe { ptr::read(v) }; + let (new_value, ret) = change(value); + unsafe { + ptr::write(v, new_value); + } + mem::forget(guard); + ret +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/btree/merge_iter.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/merge_iter.rs new file mode 100644 index 000000000000..9c0c5a4b8cfd --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/merge_iter.rs @@ -0,0 +1,100 @@ +use crate::gccrs_core_prelude::*; + +use core::cmp::Ordering; +use core::fmt::{self, Debug}; +use core::iter::FusedIterator; + +/// Core of an iterator that merges the output of two strictly ascending iterators, +/// for instance a union or a symmetric difference. +pub struct MergeIterInner { + a: I, + b: I, + peeked: Option>, +} + +/// Benchmarks faster than wrapping both iterators in a Peekable, +/// probably because we can afford to impose a FusedIterator bound. +#[derive(Clone, Debug)] +enum Peeked { + A(I::Item), + B(I::Item), +} + +impl Clone for MergeIterInner +where + I: Clone, + I::Item: Clone, +{ + fn clone(&self) -> Self { + Self { a: self.a.clone(), b: self.b.clone(), peeked: self.peeked.clone() } + } +} + +impl Debug for MergeIterInner +where + I: Debug, + I::Item: Debug, +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("MergeIterInner").field(&self.a).field(&self.b).field(&self.peeked).finish() + } +} + +impl MergeIterInner { + /// Creates a new core for an iterator merging a pair of sources. + pub fn new(a: I, b: I) -> Self { + MergeIterInner { a, b, peeked: None } + } + + /// Returns the next pair of items stemming from the pair of sources + /// being merged. If both returned options contain a value, that value + /// is equal and occurs in both sources. If one of the returned options + /// contains a value, that value doesn't occur in the other source (or + /// the sources are not strictly ascending). If neither returned option + /// contains a value, iteration has finished and subsequent calls will + /// return the same empty pair. + pub fn nexts Ordering>( + &mut self, + cmp: Cmp, + ) -> (Option, Option) + where + I: FusedIterator, + { + let mut a_next; + let mut b_next; + match self.peeked.take() { + Some(Peeked::A(next)) => { + a_next = Some(next); + b_next = self.b.next(); + } + Some(Peeked::B(next)) => { + b_next = Some(next); + a_next = self.a.next(); + } + None => { + a_next = self.a.next(); + b_next = self.b.next(); + } + } + if let (Some(ref a1), Some(ref b1)) = (&a_next, &b_next) { + match cmp(a1, b1) { + Ordering::Less => self.peeked = b_next.take().map(Peeked::B), + Ordering::Greater => self.peeked = a_next.take().map(Peeked::A), + Ordering::Equal => (), + } + } + (a_next, b_next) + } + + /// Returns a pair of upper bounds for the `size_hint` of the final iterator. + pub fn lens(&self) -> (usize, usize) + where + I: ExactSizeIterator, + { + match self.peeked { + Some(Peeked::A(_)) => (1 + self.a.len(), self.b.len()), + Some(Peeked::B(_)) => (self.a.len(), 1 + self.b.len()), + _ => (self.a.len(), self.b.len()), + } + } +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/btree/mod.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/mod.rs new file mode 100644 index 000000000000..6790bc57e4b4 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/mod.rs @@ -0,0 +1,71 @@ +use crate::gccrs_core_prelude::*; + +mod append; +mod borrow; +pub mod map; +mod mem; +mod merge_iter; +mod navigate; +mod node; +mod remove; +mod search; +pub mod set; +mod split; + +#[doc(hidden)] +trait Recover { + type Key; + + fn get(&self, key: &Q) -> Option<&Self::Key>; + fn take(&mut self, key: &Q) -> Option; + fn replace(&mut self, key: Self::Key) -> Option; +} + +/// Same purpose as `Option::unwrap` but doesn't always guarantee a panic +/// if the option contains no value. +/// SAFETY: the caller must ensure that the option contains a value. +#[inline(always)] +pub unsafe fn unwrap_unchecked(val: Option) -> T { + val.unwrap_or_else(|| { + if cfg!(debug_assertions) { + panic!("'unchecked' unwrap on None in BTreeMap"); + } else { + unsafe { + core::intrinsics::unreachable(); + } + } + }) +} + +#[cfg(test)] +/// XorShiftRng +struct DeterministicRng { + x: u32, + y: u32, + z: u32, + w: u32, +} + +#[cfg(test)] +impl DeterministicRng { + fn new() -> Self { + DeterministicRng { + x: 0x193a6754, + y: 0xa8a7d469, + z: 0x97830e05, + w: 0x113ba7bb, + } + } + + /// Guarantees that the first 70029 results are unique. + fn next(&mut self) -> u32 { + let x = self.x; + let t = x ^ (x << 11); + self.x = self.y; + self.y = self.z; + self.z = self.w; + let w_ = self.w; + self.w = w_ ^ (w_ >> 19) ^ (t ^ (t >> 8)); + self.w + } +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/btree/navigate.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/navigate.rs new file mode 100644 index 000000000000..96389022d01e --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/navigate.rs @@ -0,0 +1,530 @@ +use crate::gccrs_core_prelude::*; + +use core::borrow::Borrow; +use core::cmp::Ordering; +use core::ops::Bound::{Excluded, Included, Unbounded}; +use core::ops::RangeBounds; +use core::ptr; + +use super::node::{marker, ForceResult::*, Handle, NodeRef}; +use super::search::{self, SearchResult}; +use super::unwrap_unchecked; + +/// Finds the leaf edges delimiting a specified range in or underneath a node. +fn range_search( + root1: NodeRef, + root2: NodeRef, + range: R, +) -> ( + Handle, marker::Edge>, + Handle, marker::Edge>, +) +where + Q: ?Sized + Ord, + K: Borrow, + R: RangeBounds, +{ + match (range.start_bound(), range.end_bound()) { + (Excluded(s), Excluded(e)) if s == e => { + panic!("range start and end are equal and excluded in BTreeMap") + } + (Included(s) | Excluded(s), Included(e) | Excluded(e)) if s > e => { + panic!("range start is greater than range end in BTreeMap") + } + _ => {} + }; + + let mut min_node = root1; + let mut max_node = root2; + let mut min_found = false; + let mut max_found = false; + + loop { + let front = match (min_found, range.start_bound()) { + (false, Included(key)) => match search::search_node(min_node, key) { + SearchResult::Found(kv) => { + min_found = true; + kv.left_edge() + } + SearchResult::GoDown(edge) => edge, + }, + (false, Excluded(key)) => match search::search_node(min_node, key) { + SearchResult::Found(kv) => { + min_found = true; + kv.right_edge() + } + SearchResult::GoDown(edge) => edge, + }, + (true, Included(_)) => min_node.last_edge(), + (true, Excluded(_)) => min_node.first_edge(), + (_, Unbounded) => min_node.first_edge(), + }; + + let back = match (max_found, range.end_bound()) { + (false, Included(key)) => match search::search_node(max_node, key) { + SearchResult::Found(kv) => { + max_found = true; + kv.right_edge() + } + SearchResult::GoDown(edge) => edge, + }, + (false, Excluded(key)) => match search::search_node(max_node, key) { + SearchResult::Found(kv) => { + max_found = true; + kv.left_edge() + } + SearchResult::GoDown(edge) => edge, + }, + (true, Included(_)) => max_node.first_edge(), + (true, Excluded(_)) => max_node.last_edge(), + (_, Unbounded) => max_node.last_edge(), + }; + + if front.partial_cmp(&back) == Some(Ordering::Greater) { + panic!("Ord is ill-defined in BTreeMap range"); + } + match (front.force(), back.force()) { + (Leaf(f), Leaf(b)) => { + return (f, b); + } + (Internal(min_int), Internal(max_int)) => { + min_node = min_int.descend(); + max_node = max_int.descend(); + } + _ => unreachable!("BTreeMap has different depths"), + }; + } +} + +/// Equivalent to `range_search(k, v, ..)` but without the `Ord` bound. +fn full_range( + root1: NodeRef, + root2: NodeRef, +) -> ( + Handle, marker::Edge>, + Handle, marker::Edge>, +) { + let mut min_node = root1; + let mut max_node = root2; + loop { + let front = min_node.first_edge(); + let back = max_node.last_edge(); + match (front.force(), back.force()) { + (Leaf(f), Leaf(b)) => { + return (f, b); + } + (Internal(min_int), Internal(max_int)) => { + min_node = min_int.descend(); + max_node = max_int.descend(); + } + _ => unreachable!("BTreeMap has different depths"), + }; + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::LeafOrInternal> { + /// Creates a pair of leaf edges delimiting a specified range in or underneath a node. + pub fn range_search( + self, + range: R, + ) -> ( + Handle, K, V, marker::Leaf>, marker::Edge>, + Handle, K, V, marker::Leaf>, marker::Edge>, + ) + where + Q: ?Sized + Ord, + K: Borrow, + R: RangeBounds, + { + range_search(self, self, range) + } + + /// Returns (self.first_leaf_edge(), self.last_leaf_edge()), but more efficiently. + pub fn full_range( + self, + ) -> ( + Handle, K, V, marker::Leaf>, marker::Edge>, + Handle, K, V, marker::Leaf>, marker::Edge>, + ) { + full_range(self, self) + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::LeafOrInternal> { + /// Splits a unique reference into a pair of leaf edges delimiting a specified range. + /// The result are non-unique references allowing (some) mutation, which must be used + /// carefully. + pub fn range_search( + self, + range: R, + ) -> ( + Handle, K, V, marker::Leaf>, marker::Edge>, + Handle, K, V, marker::Leaf>, marker::Edge>, + ) + where + Q: ?Sized + Ord, + K: Borrow, + R: RangeBounds, + { + // We duplicate the root NodeRef here -- we will never visit the same KV + // twice, and never end up with overlapping value references. + let self2 = unsafe { ptr::read(&self) }; + range_search(self, self2, range) + } + + /// Splits a unique reference into a pair of leaf edges delimiting the full range of the tree. + /// The results are non-unique references allowing mutation (of values only), so must be used + /// with care. + pub fn full_range( + self, + ) -> ( + Handle, K, V, marker::Leaf>, marker::Edge>, + Handle, K, V, marker::Leaf>, marker::Edge>, + ) { + // We duplicate the root NodeRef here -- we will never visit the same KV + // twice, and never end up with overlapping value references. + let self2 = unsafe { ptr::read(&self) }; + full_range(self, self2) + } +} + +impl NodeRef { + /// Splits a unique reference into a pair of leaf edges delimiting the full range of the tree. + /// The results are non-unique references allowing massively destructive mutation, so must be + /// used with the utmost care. + pub fn full_range( + self, + ) -> ( + Handle, marker::Edge>, + Handle, marker::Edge>, + ) { + // We duplicate the root NodeRef here -- we will never access it in a way + // that overlaps references obtained from the root. + let self2 = unsafe { ptr::read(&self) }; + full_range(self, self2) + } +} + +impl Handle, marker::Edge> { + /// Given a leaf edge handle, returns [`Result::Ok`] with a handle to the neighboring KV + /// on the right side, which is either in the same leaf node or in an ancestor node. + /// If the leaf edge is the last one in the tree, returns [`Result::Err`] with the root node. + pub fn next_kv( + self, + ) -> Result< + Handle, marker::KV>, + NodeRef, + > { + let mut edge = self.forget_node_type(); + loop { + edge = match edge.right_kv() { + Ok(kv) => return Ok(kv), + Err(last_edge) => match last_edge.into_node().ascend() { + Ok(parent_edge) => parent_edge.forget_node_type(), + Err(root) => return Err(root), + }, + } + } + } + + /// Given a leaf edge handle, returns [`Result::Ok`] with a handle to the neighboring KV + /// on the left side, which is either in the same leaf node or in an ancestor node. + /// If the leaf edge is the first one in the tree, returns [`Result::Err`] with the root node. + pub fn next_back_kv( + self, + ) -> Result< + Handle, marker::KV>, + NodeRef, + > { + let mut edge = self.forget_node_type(); + loop { + edge = match edge.left_kv() { + Ok(kv) => return Ok(kv), + Err(last_edge) => match last_edge.into_node().ascend() { + Ok(parent_edge) => parent_edge.forget_node_type(), + Err(root) => return Err(root), + }, + } + } + } +} + +impl Handle, marker::Edge> { + /// Given an internal edge handle, returns [`Result::Ok`] with a handle to the neighboring KV + /// on the right side, which is either in the same internal node or in an ancestor node. + /// If the internal edge is the last one in the tree, returns [`Result::Err`] with the root node. + pub fn next_kv( + self, + ) -> Result< + Handle, marker::KV>, + NodeRef, + > { + let mut edge = self; + loop { + edge = match edge.right_kv() { + Ok(internal_kv) => return Ok(internal_kv), + Err(last_edge) => match last_edge.into_node().ascend() { + Ok(parent_edge) => parent_edge, + Err(root) => return Err(root), + }, + } + } + } +} + +macro_rules! def_next_kv_uncheched_dealloc { + { unsafe fn $name:ident : $adjacent_kv:ident } => { + /// Given a leaf edge handle into an owned tree, returns a handle to the next KV, + /// while deallocating any node left behind yet leaving the corresponding edge + /// in its parent node dangling. + /// + /// # Safety + /// - The leaf edge must not be the last one in the direction travelled. + /// - The node carrying the next KV returned must not have been deallocated by a + /// previous call on any handle obtained for this tree. + unsafe fn $name ( + leaf_edge: Handle, marker::Edge>, + ) -> Handle, marker::KV> { + let mut edge = leaf_edge.forget_node_type(); + loop { + edge = match edge.$adjacent_kv() { + Ok(internal_kv) => return internal_kv, + Err(last_edge) => { + unsafe { + let parent_edge = last_edge.into_node().deallocate_and_ascend(); + unwrap_unchecked(parent_edge).forget_node_type() + } + } + } + } + } + }; +} + +def_next_kv_uncheched_dealloc! {unsafe fn next_kv_unchecked_dealloc: right_kv} +def_next_kv_uncheched_dealloc! {unsafe fn next_back_kv_unchecked_dealloc: left_kv} + +impl<'a, K, V> Handle, K, V, marker::Leaf>, marker::Edge> { + /// Moves the leaf edge handle to the next leaf edge and returns references to the + /// key and value in between. + /// + /// # Safety + /// There must be another KV in the direction travelled. + pub unsafe fn next_unchecked(&mut self) -> (&'a K, &'a V) { + super::mem::replace(self, |leaf_edge| { + let kv = leaf_edge.next_kv(); + let kv = unsafe { unwrap_unchecked(kv.ok()) }; + (kv.next_leaf_edge(), kv.into_kv()) + }) + } + + /// Moves the leaf edge handle to the previous leaf edge and returns references to the + /// key and value in between. + /// + /// # Safety + /// There must be another KV in the direction travelled. + pub unsafe fn next_back_unchecked(&mut self) -> (&'a K, &'a V) { + super::mem::replace(self, |leaf_edge| { + let kv = leaf_edge.next_back_kv(); + let kv = unsafe { unwrap_unchecked(kv.ok()) }; + (kv.next_back_leaf_edge(), kv.into_kv()) + }) + } +} + +impl<'a, K, V> Handle, K, V, marker::Leaf>, marker::Edge> { + /// Moves the leaf edge handle to the next leaf edge and returns references to the + /// key and value in between. + /// + /// # Safety + /// There must be another KV in the direction travelled. + pub unsafe fn next_unchecked(&mut self) -> (&'a K, &'a mut V) { + let kv = super::mem::replace(self, |leaf_edge| { + let kv = leaf_edge.next_kv(); + let kv = unsafe { unwrap_unchecked(kv.ok()) }; + (unsafe { ptr::read(&kv) }.next_leaf_edge(), kv) + }); + // Doing this last is faster, according to benchmarks. + kv.into_kv_valmut() + } + + /// Moves the leaf edge handle to the previous leaf and returns references to the + /// key and value in between. + /// + /// # Safety + /// There must be another KV in the direction travelled. + pub unsafe fn next_back_unchecked(&mut self) -> (&'a K, &'a mut V) { + let kv = super::mem::replace(self, |leaf_edge| { + let kv = leaf_edge.next_back_kv(); + let kv = unsafe { unwrap_unchecked(kv.ok()) }; + (unsafe { ptr::read(&kv) }.next_back_leaf_edge(), kv) + }); + // Doing this last is faster, according to benchmarks. + kv.into_kv_valmut() + } +} + +impl<'a, K, V> Handle, K, V, marker::Leaf>, marker::Edge> { + /// Moves the leaf edge handle to the next leaf edge. + /// + /// # Safety + /// There must be another KV in the direction travelled. + pub unsafe fn move_next_unchecked(&mut self) { + super::mem::take_mut(self, |leaf_edge| { + let kv = leaf_edge.next_kv(); + let kv = unsafe { unwrap_unchecked(kv.ok()) }; + kv.next_leaf_edge() + }) + } +} + +impl Handle, marker::Edge> { + /// Moves the leaf edge handle to the next leaf edge and returns the key and value + /// in between, deallocating any node left behind while leaving the corresponding + /// edge in its parent node dangling. + /// + /// # Safety + /// - There must be another KV in the direction travelled. + /// - That KV was not previously returned by counterpart `next_back_unchecked` + /// on any copy of the handles being used to traverse the tree. + /// + /// The only safe way to proceed with the updated handle is to compare it, drop it, + /// call this method again subject to its safety conditions, or call counterpart + /// `next_back_unchecked` subject to its safety conditions. + pub unsafe fn next_unchecked(&mut self) -> (K, V) { + super::mem::replace(self, |leaf_edge| { + let kv = unsafe { next_kv_unchecked_dealloc(leaf_edge) }; + let k = unsafe { ptr::read(kv.reborrow().into_kv().0) }; + let v = unsafe { ptr::read(kv.reborrow().into_kv().1) }; + (kv.next_leaf_edge(), (k, v)) + }) + } + + /// Moves the leaf edge handle to the previous leaf edge and returns the key and value + /// in between, deallocating any node left behind while leaving the corresponding + /// edge in its parent node dangling. + /// + /// # Safety + /// - There must be another KV in the direction travelled. + /// - That leaf edge was not previously returned by counterpart `next_unchecked` + /// on any copy of the handles being used to traverse the tree. + /// + /// The only safe way to proceed with the updated handle is to compare it, drop it, + /// call this method again subject to its safety conditions, or call counterpart + /// `next_unchecked` subject to its safety conditions. + pub unsafe fn next_back_unchecked(&mut self) -> (K, V) { + super::mem::replace(self, |leaf_edge| { + let kv = unsafe { next_back_kv_unchecked_dealloc(leaf_edge) }; + let k = unsafe { ptr::read(kv.reborrow().into_kv().0) }; + let v = unsafe { ptr::read(kv.reborrow().into_kv().1) }; + (kv.next_back_leaf_edge(), (k, v)) + }) + } +} + +impl NodeRef { + /// Returns the leftmost leaf edge in or underneath a node - in other words, the edge + /// you need first when navigating forward (or last when navigating backward). + #[inline] + pub fn first_leaf_edge(self) -> Handle, marker::Edge> { + let mut node = self; + loop { + match node.force() { + Leaf(leaf) => return leaf.first_edge(), + Internal(internal) => node = internal.first_edge().descend(), + } + } + } + + /// Returns the rightmost leaf edge in or underneath a node - in other words, the edge + /// you need last when navigating forward (or first when navigating backward). + #[inline] + pub fn last_leaf_edge(self) -> Handle, marker::Edge> { + let mut node = self; + loop { + match node.force() { + Leaf(leaf) => return leaf.last_edge(), + Internal(internal) => node = internal.last_edge().descend(), + } + } + } +} + +pub enum Position { + Leaf(NodeRef), + Internal(NodeRef), + InternalKV(Handle, marker::KV>), +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::LeafOrInternal> { + /// Visits leaf nodes and internal KVs in order of ascending keys, and also + /// visits internal nodes as a whole in a depth first order, meaning that + /// internal nodes precede their individual KVs and their child nodes. + pub fn visit_nodes_in_order(self, mut visit: F) + where + F: FnMut(Position, K, V>), + { + match self.force() { + Leaf(leaf) => visit(Position::Leaf(leaf)), + Internal(internal) => { + visit(Position::Internal(internal)); + let mut edge = internal.first_edge(); + loop { + edge = match edge.descend().force() { + Leaf(leaf) => { + visit(Position::Leaf(leaf)); + match edge.next_kv() { + Ok(kv) => { + visit(Position::InternalKV(kv)); + kv.right_edge() + } + Err(_) => return, + } + } + Internal(internal) => { + visit(Position::Internal(internal)); + internal.first_edge() + } + } + } + } + } + } + + /// Calculates the number of elements in a (sub)tree. + pub fn calc_length(self) -> usize { + let mut result = 0; + self.visit_nodes_in_order(|pos| match pos { + Position::Leaf(node) => result += node.len(), + Position::Internal(node) => result += node.len(), + Position::InternalKV(_) => (), + }); + result + } +} + +impl Handle, marker::KV> { + /// Returns the leaf edge closest to a KV for forward navigation. + pub fn next_leaf_edge(self) -> Handle, marker::Edge> { + match self.force() { + Leaf(leaf_kv) => leaf_kv.right_edge(), + Internal(internal_kv) => { + let next_internal_edge = internal_kv.right_edge(); + next_internal_edge.descend().first_leaf_edge() + } + } + } + + /// Returns the leaf edge closest to a KV for backward navigation. + pub fn next_back_leaf_edge( + self, + ) -> Handle, marker::Edge> { + match self.force() { + Leaf(leaf_kv) => leaf_kv.left_edge(), + Internal(internal_kv) => { + let next_internal_edge = internal_kv.left_edge(); + next_internal_edge.descend().last_leaf_edge() + } + } + } +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/btree/node.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/node.rs new file mode 100644 index 000000000000..884210e0badb --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/node.rs @@ -0,0 +1,1955 @@ +use crate::gccrs_core_prelude::*; + +// This is an attempt at an implementation following the ideal +// +// ``` +// struct BTreeMap { +// height: usize, +// root: Option>> +// } +// +// struct Node { +// keys: [K; 2 * B - 1], +// vals: [V; 2 * B - 1], +// edges: [if height > 0 { Box> } else { () }; 2 * B], +// parent: Option<(NonNull>, u16)>, +// len: u16, +// } +// ``` +// +// Since Rust doesn't actually have dependent types and polymorphic recursion, +// we make do with lots of unsafety. + +// A major goal of this module is to avoid complexity by treating the tree as a generic (if +// weirdly shaped) container and avoiding dealing with most of the B-Tree invariants. As such, +// this module doesn't care whether the entries are sorted, which nodes can be underfull, or +// even what underfull means. However, we do rely on a few invariants: +// +// - Trees must have uniform depth/height. This means that every path down to a leaf from a +// given node has exactly the same length. +// - A node of length `n` has `n` keys, `n` values, and `n + 1` edges. +// This implies that even an empty node has at least one edge. + +use core::cmp::Ordering; +use core::marker::PhantomData; +use core::mem::{self, MaybeUninit}; +use core::ptr::{self, NonNull, Unique}; + +use crate::alloc::{AllocRef, Global, Layout}; +use crate::boxed::Box; + +const B: usize = 6; +pub const CAPACITY: usize = 2 * B - 1; +pub const MIN_LEN_AFTER_SPLIT: usize = B - 1; +const KV_IDX_CENTER: usize = B - 1; +const EDGE_IDX_LEFT_OF_CENTER: usize = B - 1; +const EDGE_IDX_RIGHT_OF_CENTER: usize = B; + +/// The underlying representation of leaf nodes and part of the representation of internal nodes. +struct LeafNode { + /// We want to be covariant in `K` and `V`. + parent: Option>>, + + /// This node's index into the parent node's `edges` array. + /// `*node.parent.edges[node.parent_idx]` should be the same thing as `node`. + /// This is only guaranteed to be initialized when `parent` is non-null. + parent_idx: MaybeUninit, + + /// The number of keys and values this node stores. + len: u16, + + /// The arrays storing the actual data of the node. Only the first `len` elements of each + /// array are initialized and valid. + keys: [MaybeUninit; CAPACITY], + vals: [MaybeUninit; CAPACITY], +} + +impl LeafNode { + /// Creates a new `LeafNode`. Unsafe because all nodes should really be hidden behind + /// `BoxedNode`, preventing accidental dropping of uninitialized keys and values. + unsafe fn new() -> Self { + LeafNode { + // As a general policy, we leave fields uninitialized if they can be, as this should + // be both slightly faster and easier to track in Valgrind. + keys: MaybeUninit::uninit_array(), + vals: MaybeUninit::uninit_array(), + parent: None, + parent_idx: MaybeUninit::uninit(), + len: 0, + } + } +} + +/// The underlying representation of internal nodes. As with `LeafNode`s, these should be hidden +/// behind `BoxedNode`s to prevent dropping uninitialized keys and values. Any pointer to an +/// `InternalNode` can be directly casted to a pointer to the underlying `LeafNode` portion of the +/// node, allowing code to act on leaf and internal nodes generically without having to even check +/// which of the two a pointer is pointing at. This property is enabled by the use of `repr(C)`. +#[repr(C)] +// gdb_providers.py uses this type name for introspection. +struct InternalNode { + data: LeafNode, + + /// The pointers to the children of this node. `len + 1` of these are considered + /// initialized and valid. Although during the process of `into_iter` or `drop`, + /// some pointers are dangling while others still need to be traversed. + edges: [MaybeUninit>; 2 * B], +} + +impl InternalNode { + /// Creates a new `InternalNode`. + /// + /// This is unsafe for two reasons. First, it returns an `InternalNode` by value, risking + /// dropping of uninitialized fields. Second, an invariant of internal nodes is that `len + 1` + /// edges are initialized and valid, meaning that even when the node is empty (having a + /// `len` of 0), there must be one initialized and valid edge. This function does not set up + /// such an edge. + unsafe fn new() -> Self { + InternalNode { + data: unsafe { LeafNode::new() }, + edges: MaybeUninit::uninit_array(), + } + } +} + +/// A managed, non-null pointer to a node. This is either an owned pointer to +/// `LeafNode` or an owned pointer to `InternalNode`. +/// +/// However, `BoxedNode` contains no information as to which of the two types +/// of nodes it actually contains, and, partially due to this lack of information, +/// has no destructor. +struct BoxedNode { + ptr: Unique>, +} + +impl BoxedNode { + fn from_leaf(node: Box>) -> Self { + BoxedNode { + ptr: Unique::from(Box::leak(node)), + } + } + + fn from_internal(node: Box>) -> Self { + BoxedNode { + ptr: Unique::from(Box::leak(node)).cast(), + } + } + + fn as_ptr(&self) -> NonNull> { + NonNull::from(self.ptr) + } +} + +/// An owned tree. +/// +/// Note that this does not have a destructor, and must be cleaned up manually. +pub struct Root { + node: BoxedNode, + /// The number of levels below the root node. + height: usize, +} + +unsafe impl Sync for Root {} +unsafe impl Send for Root {} + +impl Root { + /// Returns the number of levels below the root. + pub fn height(&self) -> usize { + self.height + } + + /// Returns a new owned tree, with its own root node that is initially empty. + pub fn new_leaf() -> Self { + Root { + node: BoxedNode::from_leaf(Box::new(unsafe { LeafNode::new() })), + height: 0, + } + } + + /// Borrows and returns an immutable reference to the node owned by the root. + pub fn node_as_ref(&self) -> NodeRef, K, V, marker::LeafOrInternal> { + NodeRef { + height: self.height, + node: self.node.as_ptr(), + _marker: PhantomData, + } + } + + /// Borrows and returns a mutable reference to the node owned by the root. + pub fn node_as_mut(&mut self) -> NodeRef, K, V, marker::LeafOrInternal> { + NodeRef { + height: self.height, + node: self.node.as_ptr(), + _marker: PhantomData, + } + } + + /// Borrows and returns a mutable reference to the leaf node owned by the root. + /// # Safety + /// The root node is a leaf. + unsafe fn leaf_node_as_mut(&mut self) -> NodeRef, K, V, marker::Leaf> { + debug_assert!(self.height == 0); + NodeRef { + height: self.height, + node: self.node.as_ptr(), + _marker: PhantomData, + } + } + + /// Borrows and returns a mutable reference to the internal node owned by the root. + /// # Safety + /// The root node is not a leaf. + unsafe fn internal_node_as_mut(&mut self) -> NodeRef, K, V, marker::Internal> { + debug_assert!(self.height > 0); + NodeRef { + height: self.height, + node: self.node.as_ptr(), + _marker: PhantomData, + } + } + + pub fn node_as_valmut(&mut self) -> NodeRef, K, V, marker::LeafOrInternal> { + NodeRef { + height: self.height, + node: self.node.as_ptr(), + _marker: PhantomData, + } + } + + pub fn into_ref(self) -> NodeRef { + NodeRef { + height: self.height, + node: self.node.as_ptr(), + _marker: PhantomData, + } + } + + /// Packs the reference, aware of type and height, into a type-agnostic pointer. + fn into_boxed_node(self) -> BoxedNode { + self.node + } + + /// Adds a new internal node with a single edge pointing to the previous root node, + /// make that new node the root node, and return it. This increases the height by 1 + /// and is the opposite of `pop_internal_level`. + pub fn push_internal_level(&mut self) -> NodeRef, K, V, marker::Internal> { + let mut new_node = Box::new(unsafe { InternalNode::new() }); + new_node.edges[0].write(unsafe { ptr::read(&mut self.node) }); + + self.node = BoxedNode::from_internal(new_node); + self.height += 1; + + unsafe { + let mut ret = self.internal_node_as_mut(); + ret.reborrow_mut().first_edge().correct_parent_link(); + ret + } + } + + /// Removes the internal root node, using its first child as the new root node. + /// As it is intended only to be called when the root node has only one child, + /// no cleanup is done on any of the other children. + /// This decreases the height by 1 and is the opposite of `push_internal_level`. + /// + /// Requires exclusive access to the `Root` object but not to the root node; + /// it will not invalidate existing handles or references to the root node. + /// + /// Panics if there is no internal level, i.e., if the root node is a leaf. + pub fn pop_internal_level(&mut self) { + assert!(self.height > 0); + + let top = BoxedNode::as_ptr(&self.node); + + let mut internal_node = unsafe { self.internal_node_as_mut() }; + let internal_node = NodeRef::as_internal_mut(&mut internal_node); + self.node = unsafe { internal_node.edges[0].assume_init_read() }; + self.height -= 1; + self.node_as_mut().clear_parent_link(); + + unsafe { + Global.dealloc(top.cast(), Layout::new::>()); + } + } +} + +// N.B. `NodeRef` is always covariant in `K` and `V`, even when the `BorrowType` +// is `Mut`. This is technically wrong, but cannot result in any unsafety due to +// internal use of `NodeRef` because we stay completely generic over `K` and `V`. +// However, whenever a public type wraps `NodeRef`, make sure that it has the +// correct variance. +/// +/// A reference to a node. +/// +/// This type has a number of parameters that controls how it acts: +/// - `BorrowType`: A dummy type that describes the kind of borrow and carries a lifetime. +/// - When this is `Immut<'a>`, the `NodeRef` acts roughly like `&'a Node`. +/// - When this is `ValMut<'a>`, the `NodeRef` acts roughly like `&'a Node` +/// with respect to keys and tree structure, but also allows many +/// mutable references to values throughout the tree to coexist. +/// - When this is `Mut<'a>`, the `NodeRef` acts roughly like `&'a mut Node`, +/// although insert methods allow a mutable pointer to a value to coexist. +/// - When this is `Owned`, the `NodeRef` acts roughly like `Box`, +/// but does not have a destructor, and must be cleaned up manually. +/// - `K` and `V`: These are the types of keys and values stored in the nodes. +/// - `Type`: This can be `Leaf`, `Internal`, or `LeafOrInternal`. When this is +/// `Leaf`, the `NodeRef` points to a leaf node, when this is `Internal` the +/// `NodeRef` points to an internal node, and when this is `LeafOrInternal` the +/// `NodeRef` could be pointing to either type of node. +/// `Type` is named `NodeType` when used outside `NodeRef`. +/// +/// Both `BorrowType` and `NodeType` restrict what methods we implement, to +/// exploit static type safety. There are limitations in the way we can apply +/// such restrictions: +/// - For each type parameter, we can only define a method either generically +/// or for one particular type. For example, we cannot define a method like +/// `key_at` generically for all `BorrowType`, because we want to return +/// `&'a K` for most choices of `BorrowType`, but plain `K` for `Owned`. +/// We cannot define `key_at` once for all types that have a lifetime. +/// Therefore, we define it only for the least powerful type `Immut<'a>`. +/// - We cannot get implicit coercion from say `Mut<'a>` to `Immut<'a>`. +/// Therefore, we have to explicitly call `reborrow` on a more powerfull +/// `NodeRef` in order to reach a method like `key_at`. +/// - All methods on `NodeRef` that return some kind of reference, except +/// `reborrow` and `reborrow_mut`, take `self` by value and not by reference. +/// This avoids silently returning a second reference somewhere in the tree. +/// That is irrelevant when `BorrowType` is `Immut<'a>`, but the rule does +/// no harm because we make those `NodeRef` implicitly `Copy`. +/// The rule also avoids implicitly returning the lifetime of `&self`, +/// instead of the lifetime contained in `BorrowType`. +/// An exception to this rule are the insert functions. +/// - Given the above, we need a `reborrow_mut` to explicitly copy a `Mut<'a>` +/// `NodeRef` whenever we want to invoke a method returning an extra reference +/// somewhere in the tree. +pub struct NodeRef { + /// The number of levels below the node, a property of the node that cannot be + /// entirely described by `Type` and that the node does not store itself either. + /// Unconstrained if `Type` is `LeafOrInternal`, must be zero if `Type` is `Leaf`, + /// and must be non-zero if `Type` is `Internal`. + height: usize, + /// The pointer to the leaf or internal node. The definition of `InternalNode` + /// ensures that the pointer is valid either way. + node: NonNull>, + _marker: PhantomData<(BorrowType, Type)>, +} + +impl<'a, K: 'a, V: 'a, Type> Copy for NodeRef, K, V, Type> {} +impl<'a, K: 'a, V: 'a, Type> Clone for NodeRef, K, V, Type> { + fn clone(&self) -> Self { + *self + } +} + +unsafe impl Sync for NodeRef {} + +unsafe impl<'a, K: Sync + 'a, V: Sync + 'a, Type> Send for NodeRef, K, V, Type> {} +unsafe impl<'a, K: Send + 'a, V: Send + 'a, Type> Send for NodeRef, K, V, Type> {} +unsafe impl<'a, K: Send + 'a, V: Send + 'a, Type> Send for NodeRef, K, V, Type> {} +unsafe impl Send for NodeRef {} + +impl NodeRef { + /// Unpack a node reference that was packed by `Root::into_boxed_node`. + fn from_boxed_node(boxed_node: BoxedNode, height: usize) -> Self { + NodeRef { + height, + node: boxed_node.as_ptr(), + _marker: PhantomData, + } + } +} + +impl NodeRef { + /// Unpack a node reference that was packed as `NodeRef::parent`. + fn from_internal(node: NonNull>, height: usize) -> Self { + debug_assert!(height > 0); + NodeRef { + height, + node: node.cast(), + _marker: PhantomData, + } + } +} + +impl NodeRef { + /// Exposes the data of an internal node. + /// + /// Returns a raw ptr to avoid invalidating other references to this node. + fn as_internal_ptr(this: &Self) -> *mut InternalNode { + // SAFETY: the static node type is `Internal`. + this.node.as_ptr() as *mut InternalNode + } +} + +impl<'a, K, V> NodeRef, K, V, marker::Internal> { + /// Exposes the data of an internal node in an immutable tree. + fn as_internal(this: &Self) -> &'a InternalNode { + let ptr = Self::as_internal_ptr(this); + // SAFETY: there can be no mutable references into this tree borrowed as `Immut`. + unsafe { &*ptr } + } +} + +impl<'a, K, V> NodeRef, K, V, marker::Internal> { + /// Offers exclusive access to the data of an internal node. + fn as_internal_mut(this: &mut Self) -> &'a mut InternalNode { + let ptr = Self::as_internal_ptr(this); + unsafe { &mut *ptr } + } +} + +impl NodeRef { + /// Finds the length of the node. This is the number of keys or values. + /// The number of edges is `len() + 1`. + /// Note that, despite being safe, calling this function can have the side effect + /// of invalidating mutable references that unsafe code has created. + pub fn len(&self) -> usize { + // Crucially, we only access the `len` field here. If BorrowType is marker::ValMut, + // there might be outstanding mutable references to values that we must not invalidate. + unsafe { usize::from((*Self::as_leaf_ptr(self)).len) } + } + + /// Returns the height of this node with respect to the leaf level. Zero height means the + /// node is a leaf itself. + pub fn height(&self) -> usize { + self.height + } + + /// Temporarily takes out another, immutable reference to the same node. + pub fn reborrow(&self) -> NodeRef, K, V, Type> { + NodeRef { + height: self.height, + node: self.node, + _marker: PhantomData, + } + } + + /// Exposes the leaf portion of any leaf or internal node. + /// + /// Returns a raw ptr to avoid invalidating other references to this node. + fn as_leaf_ptr(this: &Self) -> *mut LeafNode { + // The node must be valid for at least the LeafNode portion. + // This is not a reference in the NodeRef type because we don't know if + // it should be unique or shared. + this.node.as_ptr() + } +} + +impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { + /// Exposes one of the keys stored in the node. + /// + /// # Safety + /// The node has more than `idx` initialized elements. + pub unsafe fn key_at(self, idx: usize) -> &'a K { + debug_assert!(idx < self.len()); + unsafe { + Self::as_leaf(&self) + .keys + .get_unchecked(idx) + .assume_init_ref() + } + } + + /// Exposes one of the values stored in the node. + /// + /// # Safety + /// The node has more than `idx` initialized elements. + unsafe fn val_at(self, idx: usize) -> &'a V { + debug_assert!(idx < self.len()); + unsafe { + Self::as_leaf(&self) + .vals + .get_unchecked(idx) + .assume_init_ref() + } + } +} + +impl<'a, K, V> NodeRef, K, V, marker::Internal> { + /// Exposes the contents of one of the edges in the node. + /// + /// # Safety + /// The node has more than `idx` initialized elements. + unsafe fn edge_at(self, idx: usize) -> &'a BoxedNode { + debug_assert!(idx <= self.len()); + unsafe { + Self::as_internal(&self) + .edges + .get_unchecked(idx) + .assume_init_ref() + } + } +} + +impl NodeRef { + /// Finds the parent of the current node. Returns `Ok(handle)` if the current + /// node actually has a parent, where `handle` points to the edge of the parent + /// that points to the current node. Returns `Err(self)` if the current node has + /// no parent, giving back the original `NodeRef`. + /// + /// `edge.descend().ascend().unwrap()` and `node.ascend().unwrap().descend()` should + /// both, upon success, do nothing. + pub fn ascend( + self, + ) -> Result, marker::Edge>, Self> { + // We need to use raw pointers to nodes because, if BorrowType is marker::ValMut, + // there might be outstanding mutable references to values that we must not invalidate. + let leaf_ptr: *const _ = Self::as_leaf_ptr(&self); + unsafe { (*leaf_ptr).parent } + .as_ref() + .map(|parent| Handle { + node: NodeRef::from_internal(*parent, self.height + 1), + idx: unsafe { usize::from((*leaf_ptr).parent_idx.assume_init()) }, + _marker: PhantomData, + }) + .ok_or(self) + } + + pub fn first_edge(self) -> Handle { + unsafe { Handle::new_edge(self, 0) } + } + + pub fn last_edge(self) -> Handle { + let len = self.len(); + unsafe { Handle::new_edge(self, len) } + } + + /// Note that `self` must be nonempty. + pub fn first_kv(self) -> Handle { + let len = self.len(); + assert!(len > 0); + unsafe { Handle::new_kv(self, 0) } + } + + /// Note that `self` must be nonempty. + pub fn last_kv(self) -> Handle { + let len = self.len(); + assert!(len > 0); + unsafe { Handle::new_kv(self, len - 1) } + } +} + +impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { + /// Exposes the leaf portion of any leaf or internal node in an immutable tree. + fn as_leaf(this: &Self) -> &'a LeafNode { + let ptr = Self::as_leaf_ptr(this); + // SAFETY: there can be no mutable references into this tree borrowed as `Immut`. + unsafe { &*ptr } + } +} + +impl NodeRef { + /// Similar to `ascend`, gets a reference to a node's parent node, but also + /// deallocate the current node in the process. This is unsafe because the + /// current node will still be accessible despite being deallocated. + pub unsafe fn deallocate_and_ascend( + self, + ) -> Option, marker::Edge>> { + let height = self.height; + let node = self.node; + let ret = self.ascend().ok(); + unsafe { + Global.dealloc( + node.cast(), + if height > 0 { + Layout::new::>() + } else { + Layout::new::>() + }, + ); + } + ret + } +} + +impl<'a, K, V, Type> NodeRef, K, V, Type> { + /// Unsafely asserts to the compiler the static information that this node is an `Internal`. + unsafe fn cast_to_internal_unchecked(self) -> NodeRef, K, V, marker::Internal> { + debug_assert!(self.height > 0); + NodeRef { + height: self.height, + node: self.node, + _marker: PhantomData, + } + } + + /// Temporarily takes out another, mutable reference to the same node. Beware, as + /// this method is very dangerous, doubly so since it may not immediately appear + /// dangerous. + /// + /// Because mutable pointers can roam anywhere around the tree, the returned + /// pointer can easily be used to make the original pointer dangling, out of + /// bounds, or invalid under stacked borrow rules. + // FIXME(@gereeter) consider adding yet another type parameter to `NodeRef` + // that restricts the use of navigation methods on reborrowed pointers, + // preventing this unsafety. + unsafe fn reborrow_mut(&mut self) -> NodeRef, K, V, Type> { + NodeRef { + height: self.height, + node: self.node, + _marker: PhantomData, + } + } + + /// Offers exclusive access to the leaf portion of any leaf or internal node. + fn as_leaf_mut(this: &mut Self) -> &'a mut LeafNode { + let ptr = Self::as_leaf_ptr(this); + // SAFETY: we have exclusive access to the entire node. + unsafe { &mut *ptr } + } +} + +impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { + /// Offers exclusive access to a part of the key storage area. + /// + /// # Safety + /// The node has more than `idx` initialized elements. + unsafe fn into_key_area_mut_at(mut self, idx: usize) -> &'a mut MaybeUninit { + debug_assert!(idx < self.len()); + unsafe { Self::as_leaf_mut(&mut self).keys.get_unchecked_mut(idx) } + } + + /// Offers exclusive access to a part of the value storage area. + /// + /// # Safety + /// The node has more than `idx` initialized elements. + unsafe fn into_val_area_mut_at(mut self, idx: usize) -> &'a mut MaybeUninit { + debug_assert!(idx < self.len()); + unsafe { Self::as_leaf_mut(&mut self).vals.get_unchecked_mut(idx) } + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::Internal> { + /// Offers exclusive access to a part of the storage area for edge contents. + /// + /// # Safety + /// The node has at least `idx` initialized elements. + unsafe fn into_edge_area_mut_at(mut self, idx: usize) -> &'a mut MaybeUninit> { + debug_assert!(idx <= self.len()); + unsafe { + Self::as_internal_mut(&mut self) + .edges + .get_unchecked_mut(idx) + } + } +} + +impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { + /// Exposes the entire key storage area in the node, + /// regardless of the node's current length, + /// having exclusive access to the entire node. + unsafe fn key_area(self) -> &'a [MaybeUninit] { + Self::as_leaf(&self).keys.as_slice() + } + + /// Exposes the entire value storage area in the node, + /// regardless of the node's current length, + /// having exclusive access to the entire node. + unsafe fn val_area(self) -> &'a [MaybeUninit] { + Self::as_leaf(&self).vals.as_slice() + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::Internal> { + /// Exposes the entire storage area for edge contents in the node, + /// regardless of the node's current length, + /// having exclusive access to the entire node. + unsafe fn edge_area(self) -> &'a [MaybeUninit>] { + Self::as_internal(&self).edges.as_slice() + } +} + +impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { + /// Offers exclusive access to a sized slice of key storage area in the node. + unsafe fn into_key_area_slice(mut self) -> &'a mut [MaybeUninit] { + let len = self.len(); + // SAFETY: the caller will not be able to call further methods on self + // until the key slice reference is dropped, as we have unique access + // for the lifetime of the borrow. + unsafe { Self::as_leaf_mut(&mut self).keys.get_unchecked_mut(..len) } + } + + /// Offers exclusive access to a sized slice of value storage area in the node. + unsafe fn into_val_area_slice(mut self) -> &'a mut [MaybeUninit] { + let len = self.len(); + // SAFETY: the caller will not be able to call further methods on self + // until the value slice reference is dropped, as we have unique access + // for the lifetime of the borrow. + unsafe { Self::as_leaf_mut(&mut self).vals.get_unchecked_mut(..len) } + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::Internal> { + /// Offers exclusive access to a sized slice of storage area for edge contents in the node. + unsafe fn into_edge_area_slice(mut self) -> &'a mut [MaybeUninit>] { + let len = self.len(); + // SAFETY: the caller will not be able to call further methods on self + // until the edge slice reference is dropped, as we have unique access + // for the lifetime of the borrow. + unsafe { + Self::as_internal_mut(&mut self) + .edges + .get_unchecked_mut(..len + 1) + } + } +} + +impl<'a, K, V, Type> NodeRef, K, V, Type> { + /// # Safety + /// - The node has more than `idx` initialized elements. + /// - The keys and values of the node must be initialized up to its current length. + unsafe fn into_key_val_mut_at(mut self, idx: usize) -> (&'a K, &'a mut V) { + // We only create a reference to the one element we are interested in, + // to avoid aliasing with outstanding references to other elements, + // in particular, those returned to the caller in earlier iterations. + let leaf = Self::as_leaf_ptr(&mut self); + let keys = unsafe { &raw const (*leaf).keys }; + let vals = unsafe { &raw mut (*leaf).vals }; + // We must coerce to unsized array pointers because of Rust issue #74679. + let keys: *const [_] = keys; + let vals: *mut [_] = vals; + let key = unsafe { (&*keys.get_unchecked(idx)).assume_init_ref() }; + let val = unsafe { (&mut *vals.get_unchecked_mut(idx)).assume_init_mut() }; + (key, val) + } +} + +impl<'a, K: 'a, V: 'a, Type> NodeRef, K, V, Type> { + /// Exposes exclusive access to the length of the node. + pub fn into_len_mut(mut self) -> &'a mut u16 { + &mut (*Self::as_leaf_mut(&mut self)).len + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::LeafOrInternal> { + /// Set or clear the node's link to its parent edge, + /// without invalidating other references to the node. + fn set_parent_link(&mut self, parent: NonNull>, parent_idx: usize) { + let leaf = Self::as_leaf_ptr(self); + unsafe { (*leaf).parent = Some(parent) }; + unsafe { (*leaf).parent_idx.write(parent_idx as u16) }; + } + + /// Clear the node's link to its parent edge, freeing it from its tree. + /// This only makes sense when there are no other references to the node. + fn clear_parent_link(&mut self) { + let leaf = Self::as_leaf_mut(self); + leaf.parent = None; + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::Leaf> { + /// Adds a key/value pair to the end of the node. + pub fn push(&mut self, key: K, val: V) { + let len = unsafe { self.reborrow_mut().into_len_mut() }; + let idx = usize::from(*len); + assert!(idx < CAPACITY); + *len += 1; + unsafe { + self.reborrow_mut().into_key_area_mut_at(idx).write(key); + self.reborrow_mut().into_val_area_mut_at(idx).write(val); + } + } + + /// Adds a key/value pair to the beginning of the node. + fn push_front(&mut self, key: K, val: V) { + assert!(self.len() < CAPACITY); + + unsafe { + *self.reborrow_mut().into_len_mut() += 1; + slice_insert(self.reborrow_mut().into_key_area_slice(), 0, key); + slice_insert(self.reborrow_mut().into_val_area_slice(), 0, val); + } + } +} + +impl<'a, K, V> NodeRef, K, V, marker::Internal> { + /// # Safety + /// Every item returned by `range` is a valid edge index for the node. + unsafe fn correct_childrens_parent_links>(&mut self, range: R) { + for i in range { + debug_assert!(i <= self.len()); + unsafe { Handle::new_edge(self.reborrow_mut(), i) }.correct_parent_link(); + } + } + + fn correct_all_childrens_parent_links(&mut self) { + let len = self.len(); + unsafe { self.correct_childrens_parent_links(0..=len) }; + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::Internal> { + /// Adds a key/value pair, and an edge to go to the right of that pair, + /// to the end of the node. + pub fn push(&mut self, key: K, val: V, edge: Root) { + assert!(edge.height == self.height - 1); + + let len = unsafe { self.reborrow_mut().into_len_mut() }; + let idx = usize::from(*len); + assert!(idx < CAPACITY); + *len += 1; + unsafe { + self.reborrow_mut().into_key_area_mut_at(idx).write(key); + self.reborrow_mut().into_val_area_mut_at(idx).write(val); + self.reborrow_mut() + .into_edge_area_mut_at(idx + 1) + .write(edge.into_boxed_node()); + Handle::new_edge(self.reborrow_mut(), idx + 1).correct_parent_link(); + } + } + + /// Adds a key/value pair, and an edge to go to the left of that pair, + /// to the beginning of the node. + fn push_front(&mut self, key: K, val: V, edge: Root) { + assert!(edge.height == self.height - 1); + assert!(self.len() < CAPACITY); + + unsafe { + *self.reborrow_mut().into_len_mut() += 1; + slice_insert(self.reborrow_mut().into_key_area_slice(), 0, key); + slice_insert(self.reborrow_mut().into_val_area_slice(), 0, val); + slice_insert( + self.reborrow_mut().into_edge_area_slice(), + 0, + edge.into_boxed_node(), + ); + } + + self.correct_all_childrens_parent_links(); + } +} + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::LeafOrInternal> { + /// Removes a key/value pair from the end of the node and returns the pair. + /// Also removes the edge that was to the right of that pair and, if the node + /// is internal, returns the orphaned subtree that this edge owned. + fn pop(&mut self) -> (K, V, Option>) { + debug_assert!(self.len() > 0); + + let idx = self.len() - 1; + + unsafe { + let key = ptr::read(self.reborrow().key_at(idx)); + let val = ptr::read(self.reborrow().val_at(idx)); + let edge = match self.reborrow_mut().force() { + ForceResult::Leaf(_) => None, + ForceResult::Internal(internal) => { + let boxed_node = ptr::read(internal.reborrow().edge_at(idx + 1)); + let mut edge = Root { + node: boxed_node, + height: internal.height - 1, + }; + // In practice, clearing the parent is a waste of time, because we will + // insert the node elsewhere and set its parent link again. + edge.node_as_mut().clear_parent_link(); + Some(edge) + } + }; + + *self.reborrow_mut().into_len_mut() -= 1; + (key, val, edge) + } + } + + /// Removes a key/value pair from the beginning of the node and returns the pair. + /// Also removes the edge that was to the left of that pair and, if the node is + /// internal, returns the orphaned subtree that this edge owned. + fn pop_front(&mut self) -> (K, V, Option>) { + debug_assert!(self.len() > 0); + + let old_len = self.len(); + + unsafe { + let key = slice_remove(self.reborrow_mut().into_key_area_slice(), 0); + let val = slice_remove(self.reborrow_mut().into_val_area_slice(), 0); + let edge = match self.reborrow_mut().force() { + ForceResult::Leaf(_) => None, + ForceResult::Internal(mut internal) => { + let boxed_node = + slice_remove(internal.reborrow_mut().into_edge_area_slice(), 0); + let mut edge = Root { + node: boxed_node, + height: internal.height - 1, + }; + // In practice, clearing the parent is a waste of time, because we will + // insert the node elsewhere and set its parent link again. + edge.node_as_mut().clear_parent_link(); + + internal.correct_childrens_parent_links(0..old_len); + + Some(edge) + } + }; + + *self.reborrow_mut().into_len_mut() -= 1; + + (key, val, edge) + } + } + + fn into_kv_pointers_mut(mut self) -> (*mut K, *mut V) { + let leaf = Self::as_leaf_mut(&mut self); + let keys = MaybeUninit::slice_as_mut_ptr(&mut leaf.keys); + let vals = MaybeUninit::slice_as_mut_ptr(&mut leaf.vals); + (keys, vals) + } +} + +impl NodeRef { + /// Checks whether a node is an `Internal` node or a `Leaf` node. + pub fn force( + self, + ) -> ForceResult< + NodeRef, + NodeRef, + > { + if self.height == 0 { + ForceResult::Leaf(NodeRef { + height: self.height, + node: self.node, + _marker: PhantomData, + }) + } else { + ForceResult::Internal(NodeRef { + height: self.height, + node: self.node, + _marker: PhantomData, + }) + } + } +} + +/// A reference to a specific key/value pair or edge within a node. The `Node` parameter +/// must be a `NodeRef`, while the `Type` can either be `KV` (signifying a handle on a key/value +/// pair) or `Edge` (signifying a handle on an edge). +/// +/// Note that even `Leaf` nodes can have `Edge` handles. Instead of representing a pointer to +/// a child node, these represent the spaces where child pointers would go between the key/value +/// pairs. For example, in a node with length 2, there would be 3 possible edge locations - one +/// to the left of the node, one between the two pairs, and one at the right of the node. +pub struct Handle { + node: Node, + idx: usize, + _marker: PhantomData, +} + +impl Copy for Handle {} +// We don't need the full generality of `#[derive(Clone)]`, as the only time `Node` will be +// `Clone`able is when it is an immutable reference and therefore `Copy`. +impl Clone for Handle { + fn clone(&self) -> Self { + *self + } +} + +impl Handle { + /// Retrieves the node that contains the edge or key/value pair this handle points to. + pub fn into_node(self) -> Node { + self.node + } + + /// Returns the position of this handle in the node. + pub fn idx(&self) -> usize { + self.idx + } +} + +impl Handle, marker::KV> { + /// Creates a new handle to a key/value pair in `node`. + /// Unsafe because the caller must ensure that `idx < node.len()`. + pub unsafe fn new_kv(node: NodeRef, idx: usize) -> Self { + debug_assert!(idx < node.len()); + + Handle { + node, + idx, + _marker: PhantomData, + } + } + + pub fn left_edge(self) -> Handle, marker::Edge> { + unsafe { Handle::new_edge(self.node, self.idx) } + } + + pub fn right_edge(self) -> Handle, marker::Edge> { + unsafe { Handle::new_edge(self.node, self.idx + 1) } + } +} + +impl NodeRef { + /// Could be a public implementation of PartialEq, but only used in this module. + fn eq(&self, other: &Self) -> bool { + let Self { + node, + height, + _marker: _, + } = self; + if node.eq(&other.node) { + debug_assert_eq!(*height, other.height); + true + } else { + false + } + } +} + +impl PartialEq + for Handle, HandleType> +{ + fn eq(&self, other: &Self) -> bool { + let Self { + node, + idx, + _marker: _, + } = self; + node.eq(&other.node) && *idx == other.idx + } +} + +impl PartialOrd + for Handle, HandleType> +{ + fn partial_cmp(&self, other: &Self) -> Option { + let Self { + node, + idx, + _marker: _, + } = self; + if node.eq(&other.node) { + Some(idx.cmp(&other.idx)) + } else { + None + } + } +} + +impl + Handle, HandleType> +{ + /// Temporarily takes out another, immutable handle on the same location. + pub fn reborrow(&self) -> Handle, K, V, NodeType>, HandleType> { + // We can't use Handle::new_kv or Handle::new_edge because we don't know our type + Handle { + node: self.node.reborrow(), + idx: self.idx, + _marker: PhantomData, + } + } +} + +impl<'a, K, V, NodeType, HandleType> Handle, K, V, NodeType>, HandleType> { + /// Temporarily takes out another, mutable handle on the same location. Beware, as + /// this method is very dangerous, doubly so since it may not immediately appear + /// dangerous. + /// + /// For details, see `NodeRef::reborrow_mut`. + pub unsafe fn reborrow_mut( + &mut self, + ) -> Handle, K, V, NodeType>, HandleType> { + // We can't use Handle::new_kv or Handle::new_edge because we don't know our type + Handle { + node: unsafe { self.node.reborrow_mut() }, + idx: self.idx, + _marker: PhantomData, + } + } +} + +impl Handle, marker::Edge> { + /// Creates a new handle to an edge in `node`. + /// Unsafe because the caller must ensure that `idx <= node.len()`. + pub unsafe fn new_edge(node: NodeRef, idx: usize) -> Self { + debug_assert!(idx <= node.len()); + + Handle { + node, + idx, + _marker: PhantomData, + } + } + + pub fn left_kv(self) -> Result, marker::KV>, Self> { + if self.idx > 0 { + Ok(unsafe { Handle::new_kv(self.node, self.idx - 1) }) + } else { + Err(self) + } + } + + pub fn right_kv(self) -> Result, marker::KV>, Self> { + if self.idx < self.node.len() { + Ok(unsafe { Handle::new_kv(self.node, self.idx) }) + } else { + Err(self) + } + } +} + +enum InsertionPlace { + Left(usize), + Right(usize), +} + +/// Given an edge index where we want to insert into a node filled to capacity, +/// computes a sensible KV index of a split point and where to perform the insertion. +/// The goal of the split point is for its key and value to end up in a parent node; +/// the keys, values and edges to the left of the split point become the left child; +/// the keys, values and edges to the right of the split point become the right child. +fn splitpoint(edge_idx: usize) -> (usize, InsertionPlace) { + debug_assert!(edge_idx <= CAPACITY); + // Rust issue #74834 tries to explain these symmetric rules. + match edge_idx { + 0..EDGE_IDX_LEFT_OF_CENTER => (KV_IDX_CENTER - 1, InsertionPlace::Left(edge_idx)), + EDGE_IDX_LEFT_OF_CENTER => (KV_IDX_CENTER, InsertionPlace::Left(edge_idx)), + EDGE_IDX_RIGHT_OF_CENTER => (KV_IDX_CENTER, InsertionPlace::Right(0)), + _ => ( + KV_IDX_CENTER + 1, + InsertionPlace::Right(edge_idx - (KV_IDX_CENTER + 1 + 1)), + ), + } +} + +impl<'a, K: 'a, V: 'a> Handle, K, V, marker::Leaf>, marker::Edge> { + /// Inserts a new key/value pair between the key/value pairs to the right and left of + /// this edge. This method assumes that there is enough space in the node for the new + /// pair to fit. + /// + /// The returned pointer points to the inserted value. + fn insert_fit(&mut self, key: K, val: V) -> *mut V { + debug_assert!(self.node.len() < CAPACITY); + + unsafe { + *self.node.reborrow_mut().into_len_mut() += 1; + slice_insert( + self.node.reborrow_mut().into_key_area_slice(), + self.idx, + key, + ); + slice_insert( + self.node.reborrow_mut().into_val_area_slice(), + self.idx, + val, + ); + + self.node + .reborrow_mut() + .into_val_area_mut_at(self.idx) + .assume_init_mut() + } + } +} + +impl<'a, K: 'a, V: 'a> Handle, K, V, marker::Leaf>, marker::Edge> { + /// Inserts a new key/value pair between the key/value pairs to the right and left of + /// this edge. This method splits the node if there isn't enough room. + /// + /// The returned pointer points to the inserted value. + fn insert(mut self, key: K, val: V) -> (InsertResult<'a, K, V, marker::Leaf>, *mut V) { + if self.node.len() < CAPACITY { + let val_ptr = self.insert_fit(key, val); + let kv = unsafe { Handle::new_kv(self.node, self.idx) }; + (InsertResult::Fit(kv), val_ptr) + } else { + let (middle_kv_idx, insertion) = splitpoint(self.idx); + let middle = unsafe { Handle::new_kv(self.node, middle_kv_idx) }; + let (mut left, k, v, mut right) = middle.split(); + let mut insertion_edge = match insertion { + InsertionPlace::Left(insert_idx) => unsafe { + Handle::new_edge(left.reborrow_mut(), insert_idx) + }, + InsertionPlace::Right(insert_idx) => unsafe { + Handle::new_edge(right.leaf_node_as_mut(), insert_idx) + }, + }; + let val_ptr = insertion_edge.insert_fit(key, val); + ( + InsertResult::Split(SplitResult { + left: left.forget_type(), + k, + v, + right, + }), + val_ptr, + ) + } + } +} + +impl<'a, K, V> Handle, K, V, marker::Internal>, marker::Edge> { + /// Fixes the parent pointer and index in the child node below this edge. This is useful + /// when the ordering of edges has been changed, such as in the various `insert` methods. + fn correct_parent_link(self) { + // Create backpointer without invalidating other references to the node. + let ptr = unsafe { NonNull::new_unchecked(NodeRef::as_internal_ptr(&self.node)) }; + let idx = self.idx; + let mut child = self.descend(); + child.set_parent_link(ptr, idx); + } +} + +impl<'a, K: 'a, V: 'a> Handle, K, V, marker::Internal>, marker::Edge> { + /// Inserts a new key/value pair and an edge that will go to the right of that new pair + /// between this edge and the key/value pair to the right of this edge. This method assumes + /// that there is enough space in the node for the new pair to fit. + fn insert_fit(&mut self, key: K, val: V, edge: Root) { + debug_assert!(self.node.len() < CAPACITY); + debug_assert!(edge.height == self.node.height - 1); + + let boxed_node = edge.into_boxed_node(); + unsafe { + *self.node.reborrow_mut().into_len_mut() += 1; + slice_insert( + self.node.reborrow_mut().into_key_area_slice(), + self.idx, + key, + ); + slice_insert( + self.node.reborrow_mut().into_val_area_slice(), + self.idx, + val, + ); + slice_insert( + self.node.reborrow_mut().into_edge_area_slice(), + self.idx + 1, + boxed_node, + ); + + self.node + .correct_childrens_parent_links((self.idx + 1)..=self.node.len()); + } + } + + /// Inserts a new key/value pair and an edge that will go to the right of that new pair + /// between this edge and the key/value pair to the right of this edge. This method splits + /// the node if there isn't enough room. + fn insert( + mut self, + key: K, + val: V, + edge: Root, + ) -> InsertResult<'a, K, V, marker::Internal> { + assert!(edge.height == self.node.height - 1); + + if self.node.len() < CAPACITY { + self.insert_fit(key, val, edge); + let kv = unsafe { Handle::new_kv(self.node, self.idx) }; + InsertResult::Fit(kv) + } else { + let (middle_kv_idx, insertion) = splitpoint(self.idx); + let middle = unsafe { Handle::new_kv(self.node, middle_kv_idx) }; + let (mut left, k, v, mut right) = middle.split(); + let mut insertion_edge = match insertion { + InsertionPlace::Left(insert_idx) => unsafe { + Handle::new_edge(left.reborrow_mut(), insert_idx) + }, + InsertionPlace::Right(insert_idx) => unsafe { + Handle::new_edge(right.internal_node_as_mut(), insert_idx) + }, + }; + insertion_edge.insert_fit(key, val, edge); + InsertResult::Split(SplitResult { + left: left.forget_type(), + k, + v, + right, + }) + } + } +} + +impl<'a, K: 'a, V: 'a> Handle, K, V, marker::Leaf>, marker::Edge> { + /// Inserts a new key/value pair between the key/value pairs to the right and left of + /// this edge. This method splits the node if there isn't enough room, and tries to + /// insert the split off portion into the parent node recursively, until the root is reached. + /// + /// If the returned result is a `Fit`, its handle's node can be this edge's node or an ancestor. + /// If the returned result is a `Split`, the `left` field will be the root node. + /// The returned pointer points to the inserted value. + pub fn insert_recursing( + self, + key: K, + value: V, + ) -> (InsertResult<'a, K, V, marker::LeafOrInternal>, *mut V) { + let (mut split, val_ptr) = match self.insert(key, value) { + (InsertResult::Fit(handle), ptr) => { + return (InsertResult::Fit(handle.forget_node_type()), ptr); + } + (InsertResult::Split(split), val_ptr) => (split, val_ptr), + }; + + loop { + split = match split.left.ascend() { + Ok(parent) => match parent.insert(split.k, split.v, split.right) { + InsertResult::Fit(handle) => { + return (InsertResult::Fit(handle.forget_node_type()), val_ptr); + } + InsertResult::Split(split) => split, + }, + Err(root) => { + return ( + InsertResult::Split(SplitResult { + left: root, + ..split + }), + val_ptr, + ); + } + }; + } + } +} + +impl Handle, marker::Edge> { + /// Finds the node pointed to by this edge. + /// + /// `edge.descend().ascend().unwrap()` and `node.ascend().unwrap().descend()` should + /// both, upon success, do nothing. + pub fn descend(self) -> NodeRef { + // We need to use raw pointers to nodes because, if BorrowType is + // marker::ValMut, there might be outstanding mutable references to + // values that we must not invalidate. There's no worry accessing the + // height field because that value is copied. Beware that, once the + // node pointer is dereferenced, we access the edges array with a + // reference (Rust issue #73987) and invalidate any other references + // to or inside the array, should any be around. + let parent_ptr = NodeRef::as_internal_ptr(&self.node); + let boxed_node = unsafe { + (*parent_ptr) + .edges + .get_unchecked(self.idx) + .assume_init_read() + }; + NodeRef::from_boxed_node(boxed_node, self.node.height - 1) + } +} + +impl<'a, K: 'a, V: 'a, NodeType> Handle, K, V, NodeType>, marker::KV> { + pub fn into_kv(self) -> (&'a K, &'a V) { + (unsafe { self.node.key_at(self.idx) }, unsafe { + self.node.val_at(self.idx) + }) + } +} + +impl<'a, K: 'a, V: 'a, NodeType> Handle, K, V, NodeType>, marker::KV> { + pub fn into_key_mut(self) -> &'a mut K { + unsafe { self.node.into_key_area_mut_at(self.idx).assume_init_mut() } + } + + pub fn into_val_mut(self) -> &'a mut V { + unsafe { self.node.into_val_area_mut_at(self.idx).assume_init_mut() } + } +} + +impl<'a, K, V, NodeType> Handle, K, V, NodeType>, marker::KV> { + pub fn into_kv_valmut(self) -> (&'a K, &'a mut V) { + unsafe { self.node.into_key_val_mut_at(self.idx) } + } +} + +impl<'a, K: 'a, V: 'a, NodeType> Handle, K, V, NodeType>, marker::KV> { + pub fn kv_mut(&mut self) -> (&mut K, &mut V) { + // We cannot call separate key and value methods, because calling the second one + // invalidates the reference returned by the first. + unsafe { + let leaf = NodeRef::as_leaf_mut(&mut self.node.reborrow_mut()); + let key = leaf.keys.get_unchecked_mut(self.idx).assume_init_mut(); + let val = leaf.vals.get_unchecked_mut(self.idx).assume_init_mut(); + (key, val) + } + } +} + +impl<'a, K: 'a, V: 'a, NodeType> Handle, K, V, NodeType>, marker::KV> { + /// Helps implementations of `split` for a particular `NodeType`, + /// by calculating the length of the new node. + fn split_new_node_len(&self) -> usize { + debug_assert!(self.idx < self.node.len()); + self.node.len() - self.idx - 1 + } + + /// Helps implementations of `split` for a particular `NodeType`, + /// by taking care of leaf data. + fn split_leaf_data(&mut self, new_node: &mut LeafNode) -> (K, V) { + let new_len = self.split_new_node_len(); + new_node.len = new_len as u16; + unsafe { + let k = ptr::read(self.node.reborrow().key_at(self.idx)); + let v = ptr::read(self.node.reborrow().val_at(self.idx)); + + ptr::copy_nonoverlapping( + self.node.reborrow().key_area().as_ptr().add(self.idx + 1), + new_node.keys.as_mut_ptr(), + new_len, + ); + ptr::copy_nonoverlapping( + self.node.reborrow().val_area().as_ptr().add(self.idx + 1), + new_node.vals.as_mut_ptr(), + new_len, + ); + + *self.node.reborrow_mut().into_len_mut() = self.idx as u16; + (k, v) + } + } +} + +impl<'a, K: 'a, V: 'a> Handle, K, V, marker::Leaf>, marker::KV> { + /// Splits the underlying node into three parts: + /// + /// - The node is truncated to only contain the key/value pairs to the left of + /// this handle. + /// - The key and value pointed to by this handle are extracted. + /// - All the key/value pairs to the right of this handle are put into a newly + /// allocated node. + pub fn split( + mut self, + ) -> ( + NodeRef, K, V, marker::Leaf>, + K, + V, + Root, + ) { + unsafe { + let mut new_node = Box::new(LeafNode::new()); + + let (k, v) = self.split_leaf_data(&mut new_node); + + let right = Root { + node: BoxedNode::from_leaf(new_node), + height: 0, + }; + (self.node, k, v, right) + } + } + + /// Removes the key/value pair pointed to by this handle and returns it, along with the edge + /// that the key/value pair collapsed into. + pub fn remove( + mut self, + ) -> ( + (K, V), + Handle, K, V, marker::Leaf>, marker::Edge>, + ) { + unsafe { + let k = slice_remove(self.node.reborrow_mut().into_key_area_slice(), self.idx); + let v = slice_remove(self.node.reborrow_mut().into_val_area_slice(), self.idx); + *self.node.reborrow_mut().into_len_mut() -= 1; + ((k, v), self.left_edge()) + } + } +} + +impl<'a, K, V> Handle, K, V, marker::Internal>, marker::KV> { + /// Returns `true` if it is valid to call `.merge()`, i.e., whether there is enough room in + /// a node to hold the combination of the nodes to the left and right of this handle along + /// with the key/value pair at this handle. + pub fn can_merge(&self) -> bool { + (self.reborrow().left_edge().descend().len() + + self.reborrow().right_edge().descend().len() + + 1) + <= CAPACITY + } +} + +impl<'a, K: 'a, V: 'a> Handle, K, V, marker::Internal>, marker::KV> { + /// Splits the underlying node into three parts: + /// + /// - The node is truncated to only contain the edges and key/value pairs to the + /// left of this handle. + /// - The key and value pointed to by this handle are extracted. + /// - All the edges and key/value pairs to the right of this handle are put into + /// a newly allocated node. + pub fn split( + mut self, + ) -> ( + NodeRef, K, V, marker::Internal>, + K, + V, + Root, + ) { + unsafe { + let mut new_node = Box::new(InternalNode::new()); + let new_len = self.split_new_node_len(); + // Move edges out before reducing length: + ptr::copy_nonoverlapping( + self.node.reborrow().edge_area().as_ptr().add(self.idx + 1), + new_node.edges.as_mut_ptr(), + new_len + 1, + ); + let (k, v) = self.split_leaf_data(&mut new_node.data); + + let height = self.node.height; + let mut right = Root { + node: BoxedNode::from_internal(new_node), + height, + }; + + right + .internal_node_as_mut() + .correct_childrens_parent_links(0..=new_len); + + (self.node, k, v, right) + } + } + + /// Combines the node immediately to the left of this handle, the key/value pair pointed + /// to by this handle, and the node immediately to the right of this handle into one new + /// child of the underlying node, returning an edge referencing that new child. + /// + /// Panics unless this edge `.can_merge()`. + pub fn merge( + mut self, + ) -> Handle, K, V, marker::Internal>, marker::Edge> { + let self1 = unsafe { ptr::read(&self) }; + let self2 = unsafe { ptr::read(&self) }; + let mut left_node = self1.left_edge().descend(); + let left_len = left_node.len(); + let right_node = self2.right_edge().descend(); + let right_len = right_node.len(); + + assert!(left_len + right_len < CAPACITY); + + unsafe { + *left_node.reborrow_mut().into_len_mut() += right_len as u16 + 1; + + let parent_key = slice_remove(self.node.reborrow_mut().into_key_area_slice(), self.idx); + left_node + .reborrow_mut() + .into_key_area_mut_at(left_len) + .write(parent_key); + ptr::copy_nonoverlapping( + right_node.reborrow().key_area().as_ptr(), + left_node + .reborrow_mut() + .into_key_area_slice() + .as_mut_ptr() + .add(left_len + 1), + right_len, + ); + + let parent_val = slice_remove(self.node.reborrow_mut().into_val_area_slice(), self.idx); + left_node + .reborrow_mut() + .into_val_area_mut_at(left_len) + .write(parent_val); + ptr::copy_nonoverlapping( + right_node.reborrow().val_area().as_ptr(), + left_node + .reborrow_mut() + .into_val_area_slice() + .as_mut_ptr() + .add(left_len + 1), + right_len, + ); + + slice_remove( + &mut self.node.reborrow_mut().into_edge_area_slice(), + self.idx + 1, + ); + let self_len = self.node.len(); + self.node + .correct_childrens_parent_links(self.idx + 1..self_len); + *self.node.reborrow_mut().into_len_mut() -= 1; + + if self.node.height > 1 { + // SAFETY: the height of the nodes being merged is one below the height + // of the node of this edge, thus above zero, so they are internal. + let mut left_node = left_node.cast_to_internal_unchecked(); + let right_node = right_node.cast_to_internal_unchecked(); + ptr::copy_nonoverlapping( + right_node.reborrow().edge_area().as_ptr(), + left_node + .reborrow_mut() + .into_edge_area_slice() + .as_mut_ptr() + .add(left_len + 1), + right_len + 1, + ); + + left_node.correct_childrens_parent_links(left_len + 1..=left_len + 1 + right_len); + + Global.dealloc(right_node.node.cast(), Layout::new::>()); + } else { + Global.dealloc(right_node.node.cast(), Layout::new::>()); + } + + Handle::new_edge(self.node, self.idx) + } + } + + /// This removes a key/value pair from the left child and places it in the key/value storage + /// pointed to by this handle while pushing the old key/value pair of this handle into the right + /// child. + pub fn steal_left(&mut self) { + unsafe { + let (k, v, edge) = self.reborrow_mut().left_edge().descend().pop(); + + let k = mem::replace(self.kv_mut().0, k); + let v = mem::replace(self.kv_mut().1, v); + + match self.reborrow_mut().right_edge().descend().force() { + ForceResult::Leaf(mut leaf) => leaf.push_front(k, v), + ForceResult::Internal(mut internal) => internal.push_front(k, v, edge.unwrap()), + } + } + } + + /// This removes a key/value pair from the right child and places it in the key/value storage + /// pointed to by this handle while pushing the old key/value pair of this handle into the left + /// child. + pub fn steal_right(&mut self) { + unsafe { + let (k, v, edge) = self.reborrow_mut().right_edge().descend().pop_front(); + + let k = mem::replace(self.kv_mut().0, k); + let v = mem::replace(self.kv_mut().1, v); + + match self.reborrow_mut().left_edge().descend().force() { + ForceResult::Leaf(mut leaf) => leaf.push(k, v), + ForceResult::Internal(mut internal) => internal.push(k, v, edge.unwrap()), + } + } + } + + /// This does stealing similar to `steal_left` but steals multiple elements at once. + pub fn bulk_steal_left(&mut self, count: usize) { + unsafe { + let mut left_node = ptr::read(self).left_edge().descend(); + let left_len = left_node.len(); + let mut right_node = ptr::read(self).right_edge().descend(); + let right_len = right_node.len(); + + // Make sure that we may steal safely. + assert!(right_len + count <= CAPACITY); + assert!(left_len >= count); + + let new_left_len = left_len - count; + + // Move data. + { + let left_kv = left_node.reborrow_mut().into_kv_pointers_mut(); + let right_kv = right_node.reborrow_mut().into_kv_pointers_mut(); + let parent_kv = { + let kv = self.kv_mut(); + (kv.0 as *mut K, kv.1 as *mut V) + }; + + // Make room for stolen elements in the right child. + ptr::copy(right_kv.0, right_kv.0.add(count), right_len); + ptr::copy(right_kv.1, right_kv.1.add(count), right_len); + + // Move elements from the left child to the right one. + move_kv(left_kv, new_left_len + 1, right_kv, 0, count - 1); + + // Move parent's key/value pair to the right child. + move_kv(parent_kv, 0, right_kv, count - 1, 1); + + // Move the left-most stolen pair to the parent. + move_kv(left_kv, new_left_len, parent_kv, 0, 1); + } + + *left_node.reborrow_mut().into_len_mut() -= count as u16; + *right_node.reborrow_mut().into_len_mut() += count as u16; + + match (left_node.force(), right_node.force()) { + (ForceResult::Internal(left), ForceResult::Internal(mut right)) => { + // Make room for stolen edges. + let left = left.reborrow(); + let right_edges = right.reborrow_mut().into_edge_area_slice().as_mut_ptr(); + ptr::copy(right_edges, right_edges.add(count), right_len + 1); + right.correct_childrens_parent_links(count..count + right_len + 1); + + move_edges(left, new_left_len + 1, right, 0, count); + } + (ForceResult::Leaf(_), ForceResult::Leaf(_)) => {} + _ => unreachable!(), + } + } + } + + /// The symmetric clone of `bulk_steal_left`. + pub fn bulk_steal_right(&mut self, count: usize) { + unsafe { + let mut left_node = ptr::read(self).left_edge().descend(); + let left_len = left_node.len(); + let mut right_node = ptr::read(self).right_edge().descend(); + let right_len = right_node.len(); + + // Make sure that we may steal safely. + assert!(left_len + count <= CAPACITY); + assert!(right_len >= count); + + let new_right_len = right_len - count; + + // Move data. + { + let left_kv = left_node.reborrow_mut().into_kv_pointers_mut(); + let right_kv = right_node.reborrow_mut().into_kv_pointers_mut(); + let parent_kv = { + let kv = self.kv_mut(); + (kv.0 as *mut K, kv.1 as *mut V) + }; + + // Move parent's key/value pair to the left child. + move_kv(parent_kv, 0, left_kv, left_len, 1); + + // Move elements from the right child to the left one. + move_kv(right_kv, 0, left_kv, left_len + 1, count - 1); + + // Move the right-most stolen pair to the parent. + move_kv(right_kv, count - 1, parent_kv, 0, 1); + + // Fix right indexing + ptr::copy(right_kv.0.add(count), right_kv.0, new_right_len); + ptr::copy(right_kv.1.add(count), right_kv.1, new_right_len); + } + + *left_node.reborrow_mut().into_len_mut() += count as u16; + *right_node.reborrow_mut().into_len_mut() -= count as u16; + + match (left_node.force(), right_node.force()) { + (ForceResult::Internal(left), ForceResult::Internal(mut right)) => { + move_edges(right.reborrow(), 0, left, left_len + 1, count); + + // Fix right indexing. + let right_edges = right.reborrow_mut().into_edge_area_slice().as_mut_ptr(); + ptr::copy(right_edges.add(count), right_edges, new_right_len + 1); + right.correct_childrens_parent_links(0..=new_right_len); + } + (ForceResult::Leaf(_), ForceResult::Leaf(_)) => {} + _ => unreachable!(), + } + } + } +} + +unsafe fn move_kv( + source: (*mut K, *mut V), + source_offset: usize, + dest: (*mut K, *mut V), + dest_offset: usize, + count: usize, +) { + unsafe { + ptr::copy_nonoverlapping(source.0.add(source_offset), dest.0.add(dest_offset), count); + ptr::copy_nonoverlapping(source.1.add(source_offset), dest.1.add(dest_offset), count); + } +} + +// Source and destination must have the same height. +unsafe fn move_edges<'a, K: 'a, V: 'a>( + source: NodeRef, K, V, marker::Internal>, + source_offset: usize, + mut dest: NodeRef, K, V, marker::Internal>, + dest_offset: usize, + count: usize, +) { + unsafe { + let source_ptr = source.edge_area().as_ptr(); + let dest_ptr = dest.reborrow_mut().into_edge_area_slice().as_mut_ptr(); + ptr::copy_nonoverlapping( + source_ptr.add(source_offset), + dest_ptr.add(dest_offset), + count, + ); + dest.correct_childrens_parent_links(dest_offset..dest_offset + count); + } +} + +impl NodeRef { + /// Removes any static information asserting that this node is a `Leaf` node. + pub fn forget_type(self) -> NodeRef { + NodeRef { + height: self.height, + node: self.node, + _marker: PhantomData, + } + } +} + +impl NodeRef { + /// Removes any static information asserting that this node is an `Internal` node. + pub fn forget_type(self) -> NodeRef { + NodeRef { + height: self.height, + node: self.node, + _marker: PhantomData, + } + } +} + +impl Handle, marker::Edge> { + pub fn forget_node_type( + self, + ) -> Handle, marker::Edge> { + unsafe { Handle::new_edge(self.node.forget_type(), self.idx) } + } +} + +impl Handle, marker::Edge> { + pub fn forget_node_type( + self, + ) -> Handle, marker::Edge> { + unsafe { Handle::new_edge(self.node.forget_type(), self.idx) } + } +} + +impl Handle, marker::KV> { + pub fn forget_node_type( + self, + ) -> Handle, marker::KV> { + unsafe { Handle::new_kv(self.node.forget_type(), self.idx) } + } +} + +impl Handle, marker::KV> { + pub fn forget_node_type( + self, + ) -> Handle, marker::KV> { + unsafe { Handle::new_kv(self.node.forget_type(), self.idx) } + } +} + +impl + Handle, HandleType> +{ + /// Checks whether the underlying node is an `Internal` node or a `Leaf` node. + pub fn force( + self, + ) -> ForceResult< + Handle, HandleType>, + Handle, HandleType>, + > { + match self.node.force() { + ForceResult::Leaf(node) => ForceResult::Leaf(Handle { + node, + idx: self.idx, + _marker: PhantomData, + }), + ForceResult::Internal(node) => ForceResult::Internal(Handle { + node, + idx: self.idx, + _marker: PhantomData, + }), + } + } +} + +impl<'a, K, V> Handle, K, V, marker::LeafOrInternal>, marker::Edge> { + /// Move the suffix after `self` from one node to another one. `right` must be empty. + /// The first edge of `right` remains unchanged. + pub fn move_suffix( + &mut self, + right: &mut NodeRef, K, V, marker::LeafOrInternal>, + ) { + unsafe { + let left_new_len = self.idx; + let mut left_node = self.reborrow_mut().into_node(); + + let right_new_len = left_node.len() - left_new_len; + let mut right_node = right.reborrow_mut(); + + assert!(right_node.len() == 0); + assert!(left_node.height == right_node.height); + + if right_new_len > 0 { + let left_kv = left_node.reborrow_mut().into_kv_pointers_mut(); + let right_kv = right_node.reborrow_mut().into_kv_pointers_mut(); + + move_kv(left_kv, left_new_len, right_kv, 0, right_new_len); + + *left_node.reborrow_mut().into_len_mut() = left_new_len as u16; + *right_node.reborrow_mut().into_len_mut() = right_new_len as u16; + + match (left_node.force(), right_node.force()) { + (ForceResult::Internal(left), ForceResult::Internal(right)) => { + let left = left.reborrow(); + move_edges(left, left_new_len + 1, right, 1, right_new_len); + } + (ForceResult::Leaf(_), ForceResult::Leaf(_)) => {} + _ => unreachable!(), + } + } + } + } +} + +//gccrs-commented-out because of issue #4687 +// pub enum ForceResult { +// Leaf(Leaf), +// Internal(Internal), +// } +pub enum ForceResult { + Leaf(L), + Internal(I), +} + +/// Result of insertion, when a node needed to expand beyond its capacity. +/// Does not distinguish between `Leaf` and `Internal` because `Root` doesn't. +pub struct SplitResult<'a, K, V> { + // Altered node in existing tree with elements and edges that belong to the left of `k`. + pub left: NodeRef, K, V, marker::LeafOrInternal>, + // Some key and value split off, to be inserted elsewhere. + pub k: K, + pub v: V, + // Owned, unattached, new node with elements and edges that belong to the right of `k`. + pub right: Root, +} + +pub enum InsertResult<'a, K, V, Type> { + Fit(Handle, K, V, Type>, marker::KV>), + Split(SplitResult<'a, K, V>), +} + +pub mod marker { + use crate::core;//gccrs + + use core::marker::PhantomData; + + pub enum Leaf {} + pub enum Internal {} + pub enum LeafOrInternal {} + + pub enum Owned {} + pub struct Immut<'a>(PhantomData<&'a ()>); + pub struct Mut<'a>(PhantomData<&'a mut ()>); + pub struct ValMut<'a>(PhantomData<&'a mut ()>); + + pub enum KV {} + pub enum Edge {} +} + +/// Inserts a value into a slice of initialized elements followed by one uninitialized element. +/// +/// # Safety +/// The slice has more than `idx` elements. +unsafe fn slice_insert(slice: &mut [MaybeUninit], idx: usize, val: T) { + unsafe { + let len = slice.len(); + debug_assert!(len > idx); + let slice_ptr = slice.as_mut_ptr(); + if len > idx + 1 { + ptr::copy(slice_ptr.add(idx), slice_ptr.add(idx + 1), len - idx - 1); + } + (*slice_ptr.add(idx)).write(val); + } +} + +/// Removes and returns a value from a slice of all initialized elements, leaving behind one +/// trailing uninitialized element. +/// +/// # Safety +/// The slice has more than `idx` elements. +unsafe fn slice_remove(slice: &mut [MaybeUninit], idx: usize) -> T { + unsafe { + let len = slice.len(); + debug_assert!(idx < len); + let slice_ptr = slice.as_mut_ptr(); + let ret = (*slice_ptr.add(idx)).assume_init_read(); + ptr::copy(slice_ptr.add(idx + 1), slice_ptr.add(idx), len - idx - 1); + ret + } +} + +#[cfg(test)] +mod tests; diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/btree/node/tests.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/node/tests.rs new file mode 100644 index 000000000000..38c75de34eee --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/node/tests.rs @@ -0,0 +1,111 @@ +use super::super::navigate; +use super::*; +use crate::fmt::Debug; +use crate::string::String; +use core::cmp::Ordering::*; + +impl<'a, K: 'a, V: 'a> NodeRef, K, V, marker::LeafOrInternal> { + /// Asserts that the back pointer in each reachable node points to its parent. + pub fn assert_back_pointers(self) { + if let ForceResult::Internal(node) = self.force() { + for idx in 0..=node.len() { + let edge = unsafe { Handle::new_edge(node, idx) }; + let child = edge.descend(); + assert!(child.ascend().ok() == Some(edge)); + child.assert_back_pointers(); + } + } + } + + pub fn dump_keys(self) -> String + where + K: Debug, + { + let mut result = String::new(); + self.visit_nodes_in_order(|pos| match pos { + navigate::Position::Leaf(leaf) => { + let depth = self.height(); + let indent = " ".repeat(depth); + result += &format!("\n{}", indent); + for idx in 0..leaf.len() { + if idx > 0 { + result += ", "; + } + result += &format!("{:?}", unsafe { leaf.key_at(idx) }); + } + } + navigate::Position::Internal(_) => {} + navigate::Position::InternalKV(kv) => { + let depth = self.height() - kv.into_node().height(); + let indent = " ".repeat(depth); + result += &format!("\n{}{:?}", indent, kv.into_kv().0); + } + }); + result + } +} + +#[test] +fn test_splitpoint() { + for idx in 0..=CAPACITY { + let (middle_kv_idx, insertion) = splitpoint(idx); + + // Simulate performing the split: + let mut left_len = middle_kv_idx; + let mut right_len = CAPACITY - middle_kv_idx - 1; + match insertion { + InsertionPlace::Left(edge_idx) => { + assert!(edge_idx <= left_len); + left_len += 1; + } + InsertionPlace::Right(edge_idx) => { + assert!(edge_idx <= right_len); + right_len += 1; + } + } + assert!(left_len >= MIN_LEN_AFTER_SPLIT); + assert!(right_len >= MIN_LEN_AFTER_SPLIT); + assert!(left_len + right_len == CAPACITY); + } +} + +#[test] +fn test_partial_cmp_eq() { + let mut root1: Root = Root::new_leaf(); + let mut leaf1 = unsafe { root1.leaf_node_as_mut() }; + leaf1.push(1, ()); + root1.push_internal_level(); + let root2: Root = Root::new_leaf(); + + let leaf_edge_1a = root1.node_as_ref().first_leaf_edge().forget_node_type(); + let leaf_edge_1b = root1.node_as_ref().last_leaf_edge().forget_node_type(); + let top_edge_1 = root1.node_as_ref().first_edge(); + let top_edge_2 = root2.node_as_ref().first_edge(); + + assert!(leaf_edge_1a == leaf_edge_1a); + assert!(leaf_edge_1a != leaf_edge_1b); + assert!(leaf_edge_1a != top_edge_1); + assert!(leaf_edge_1a != top_edge_2); + assert!(top_edge_1 == top_edge_1); + assert!(top_edge_1 != top_edge_2); + + assert_eq!(leaf_edge_1a.partial_cmp(&leaf_edge_1a), Some(Equal)); + assert_eq!(leaf_edge_1a.partial_cmp(&leaf_edge_1b), Some(Less)); + assert_eq!(leaf_edge_1a.partial_cmp(&top_edge_1), None); + assert_eq!(leaf_edge_1a.partial_cmp(&top_edge_2), None); + assert_eq!(top_edge_1.partial_cmp(&top_edge_1), Some(Equal)); + assert_eq!(top_edge_1.partial_cmp(&top_edge_2), None); + + root1.pop_internal_level(); + unsafe { root1.into_ref().deallocate_and_ascend() }; + unsafe { root2.into_ref().deallocate_and_ascend() }; +} + +#[test] +#[cfg(target_arch = "x86_64")] +fn test_sizes() { + assert_eq!(core::mem::size_of::>(), 16); + assert_eq!(core::mem::size_of::>(), 16 + CAPACITY * 8 * 2); + assert_eq!(core::mem::size_of::>(), 112); + assert_eq!(core::mem::size_of::>(), 112 + CAPACITY * 8 * 2); +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/btree/remove.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/remove.rs new file mode 100644 index 000000000000..2f424ecf7e8d --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/remove.rs @@ -0,0 +1,135 @@ +use crate::gccrs_core_prelude::*; + +use super::map::MIN_LEN; +use super::node::{marker, ForceResult, Handle, NodeRef}; +use super::unwrap_unchecked; +use core::mem; +use core::ptr; + +impl<'a, K: 'a, V: 'a> Handle, K, V, marker::LeafOrInternal>, marker::KV> { + /// Removes a key/value-pair from the map, and returns that pair, as well as + /// the leaf edge corresponding to that former pair. + pub fn remove_kv_tracking( + self, + handle_emptied_internal_root: F, + ) -> ((K, V), Handle, K, V, marker::Leaf>, marker::Edge>) { + let (old_kv, mut pos, was_internal) = match self.force() { + ForceResult::Leaf(leaf) => { + let (old_kv, pos) = leaf.remove(); + (old_kv, pos, false) + } + ForceResult::Internal(mut internal) => { + // Replace the location freed in the internal node with an + // adjacent KV, and remove that adjacent KV from its leaf. + // Always choose the adjacent KV on the left side because + // it is typically faster to pop an element from the end + // of the KV arrays without needing to shift other elements. + + let key_loc = internal.kv_mut().0 as *mut K; + let val_loc = internal.kv_mut().1 as *mut V; + + let to_remove = internal.left_edge().descend().last_leaf_edge().left_kv().ok(); + let to_remove = unsafe { unwrap_unchecked(to_remove) }; + + let (kv, pos) = to_remove.remove(); + + let old_key = unsafe { mem::replace(&mut *key_loc, kv.0) }; + let old_val = unsafe { mem::replace(&mut *val_loc, kv.1) }; + + ((old_key, old_val), pos, true) + } + }; + + // Handle underflow + let mut cur_node = unsafe { ptr::read(&pos).into_node().forget_type() }; + let mut at_leaf = true; + while cur_node.len() < MIN_LEN { + match handle_underfull_node(cur_node) { + UnderflowResult::AtRoot => break, + UnderflowResult::Merged(edge, merged_with_left, offset) => { + // If we merged with our right sibling then our tracked + // position has not changed. However if we merged with our + // left sibling then our tracked position is now dangling. + if at_leaf && merged_with_left { + let idx = pos.idx() + offset; + let node = match unsafe { ptr::read(&edge).descend().force() } { + ForceResult::Leaf(leaf) => leaf, + ForceResult::Internal(_) => unreachable!(), + }; + pos = unsafe { Handle::new_edge(node, idx) }; + } + + let parent = edge.into_node(); + if parent.len() == 0 { + // The parent that was just emptied must be the root, + // because nodes on a lower level would not have been + // left with a single child. + handle_emptied_internal_root(); + break; + } else { + cur_node = parent.forget_type(); + at_leaf = false; + } + } + UnderflowResult::Stole(stole_from_left) => { + // Adjust the tracked position if we stole from a left sibling + if stole_from_left && at_leaf { + // SAFETY: This is safe since we just added an element to our node. + unsafe { + pos.move_next_unchecked(); + } + } + break; + } + } + } + + // If we deleted from an internal node then we need to compensate for + // the earlier swap and adjust the tracked position to point to the + // next element. + if was_internal { + pos = unsafe { unwrap_unchecked(pos.next_kv().ok()).next_leaf_edge() }; + } + + (old_kv, pos) + } +} + +enum UnderflowResult<'a, K, V> { + AtRoot, + Merged(Handle, K, V, marker::Internal>, marker::Edge>, bool, usize), + Stole(bool), +} + +fn handle_underfull_node<'a, K: 'a, V: 'a>( + node: NodeRef, K, V, marker::LeafOrInternal>, +) -> UnderflowResult<'_, K, V> { + let parent = match node.ascend() { + Ok(parent) => parent, + Err(_) => return UnderflowResult::AtRoot, + }; + + // Prefer the left KV if it exists. Merging with the left side is faster, + // since merging happens towards the left and `node` has fewer elements. + // Stealing from the left side is faster, since we can pop from the end of + // the KV arrays. + let (is_left, mut handle) = match parent.left_kv() { + Ok(left) => (true, left), + Err(parent) => { + let right = unsafe { unwrap_unchecked(parent.right_kv().ok()) }; + (false, right) + } + }; + + if handle.can_merge() { + let offset = if is_left { handle.reborrow().left_edge().descend().len() + 1 } else { 0 }; + UnderflowResult::Merged(handle.merge(), is_left, offset) + } else { + if is_left { + handle.steal_left(); + } else { + handle.steal_right(); + } + UnderflowResult::Stole(is_left) + } +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/btree/search.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/search.rs new file mode 100644 index 000000000000..4b595ab95541 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/search.rs @@ -0,0 +1,85 @@ +use crate::gccrs_core_prelude::*; + +use core::borrow::Borrow; +use core::cmp::Ordering; + +use super::node::{marker, ForceResult::*, Handle, NodeRef}; + +use SearchResult::*; + +pub enum SearchResult { + Found(Handle, marker::KV>), + GoDown(Handle, marker::Edge>), +} + +/// Looks up a given key in a (sub)tree headed by the given node, recursively. +/// Returns a `Found` with the handle of the matching KV, if any. Otherwise, +/// returns a `GoDown` with the handle of the possible leaf edge where the key +/// belongs. +pub fn search_tree( + mut node: NodeRef, + key: &Q, +) -> SearchResult +where + Q: Ord, + K: Borrow, +{ + loop { + match search_node(node, key) { + Found(handle) => return Found(handle), + GoDown(handle) => match handle.force() { + Leaf(leaf) => return GoDown(leaf), + Internal(internal) => { + node = internal.descend(); + continue; + } + }, + } + } +} + +/// Looks up a given key in a given node, without recursion. +/// Returns a `Found` with the handle of the matching KV, if any. Otherwise, +/// returns a `GoDown` with the handle of the edge where the key might be found. +/// If the node is a leaf, a `GoDown` edge is not an actual edge but a possible edge. +pub fn search_node( + node: NodeRef, + key: &Q, +) -> SearchResult +where + Q: Ord, + K: Borrow, +{ + match search_linear(&node, key) { + (idx, true) => Found(unsafe { Handle::new_kv(node, idx) }), + (idx, false) => SearchResult::GoDown(unsafe { Handle::new_edge(node, idx) }), + } +} + +/// Returns the index in the node at which the key (or an equivalent) exists +/// or could exist, and whether it exists in the node itself. If it doesn't +/// exist in the node itself, it may exist in the subtree with that index +/// (if the node has subtrees). If the key doesn't exist in node or subtree, +/// the returned index is the position or subtree where the key belongs. +fn search_linear( + node: &NodeRef, + key: &Q, +) -> (usize, bool) +where + Q: Ord, + K: Borrow, +{ + // This function is defined over all borrow types (immutable, mutable, owned). + // Using `keys_at()` is fine here even if BorrowType is mutable, as all we return + // is an index -- not a reference. + let len = node.len(); + for i in 0..len { + let k = unsafe { node.reborrow().key_at(i) }; + match key.cmp(k.borrow()) { + Ordering::Greater => {} + Ordering::Equal => return (i, true), + Ordering::Less => return (i, false), + } + } + (len, false) +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/btree/set.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/set.rs new file mode 100644 index 000000000000..b507cda78644 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/set.rs @@ -0,0 +1,1511 @@ +use crate::gccrs_core_prelude::*; + +// This is pretty much entirely stolen from TreeSet, since BTreeMap has an identical interface +// to TreeMap + +use core::borrow::Borrow; +use core::cmp::Ordering::{Equal, Greater, Less}; +use core::cmp::{max, min}; +use core::fmt::{self, Debug}; +use core::iter::{FromIterator, FusedIterator, Peekable}; +use core::ops::{BitAnd, BitOr, BitXor, RangeBounds, Sub}; + +use super::map::{BTreeMap, Keys}; +use super::merge_iter::MergeIterInner; +use super::Recover; + +// FIXME(conventions): implement bounded iterators + +/// A set based on a B-Tree. +/// +/// See [`BTreeMap`]'s documentation for a detailed discussion of this collection's performance +/// benefits and drawbacks. +/// +/// It is a logic error for an item to be modified in such a way that the item's ordering relative +/// to any other item, as determined by the [`Ord`] trait, changes while it is in the set. This is +/// normally only possible through [`Cell`], [`RefCell`], global state, I/O, or unsafe code. +/// +/// [`Ord`]: core::cmp::Ord +/// [`Cell`]: core::cell::Cell +/// [`RefCell`]: core::cell::RefCell +/// +/// # Examples +/// +/// ``` +/// use std::collections::BTreeSet; +/// +/// // Type inference lets us omit an explicit type signature (which +/// // would be `BTreeSet<&str>` in this example). +/// let mut books = BTreeSet::new(); +/// +/// // Add some books. +/// books.insert("A Dance With Dragons"); +/// books.insert("To Kill a Mockingbird"); +/// books.insert("The Odyssey"); +/// books.insert("The Great Gatsby"); +/// +/// // Check for a specific one. +/// if !books.contains("The Winds of Winter") { +/// println!("We have {} books, but The Winds of Winter ain't one.", +/// books.len()); +/// } +/// +/// // Remove a book. +/// books.remove("The Odyssey"); +/// +/// // Iterate over everything. +/// for book in &books { +/// println!("{}", book); +/// } +/// ``` +#[derive(Hash, PartialEq, Eq, Ord, PartialOrd)] +#[stable(feature = "rust1", since = "1.0.0")] +pub struct BTreeSet { + map: BTreeMap, +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for BTreeSet { + fn clone(&self) -> Self { + BTreeSet { map: self.map.clone() } + } + + fn clone_from(&mut self, other: &Self) { + self.map.clone_from(&other.map); + } +} + +/// An iterator over the items of a `BTreeSet`. +/// +/// This `struct` is created by the [`iter`] method on [`BTreeSet`]. +/// See its documentation for more. +/// +/// [`iter`]: BTreeSet::iter +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Iter<'a, T: 'a> { + iter: Keys<'a, T, ()>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Iter<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Iter").field(&self.iter.clone()).finish() + } +} + +/// An owning iterator over the items of a `BTreeSet`. +/// +/// This `struct` is created by the [`into_iter`] method on [`BTreeSet`] +/// (provided by the `IntoIterator` trait). See its documentation for more. +/// +/// [`into_iter`]: BTreeSet#method.into_iter +#[stable(feature = "rust1", since = "1.0.0")] +#[derive(Debug)] +pub struct IntoIter { + iter: super::map::IntoIter, +} + +/// An iterator over a sub-range of items in a `BTreeSet`. +/// +/// This `struct` is created by the [`range`] method on [`BTreeSet`]. +/// See its documentation for more. +/// +/// [`range`]: BTreeSet::range +#[derive(Debug)] +#[stable(feature = "btree_range", since = "1.17.0")] +pub struct Range<'a, T: 'a> { + iter: super::map::Range<'a, T, ()>, +} + +/// A lazy iterator producing elements in the difference of `BTreeSet`s. +/// +/// This `struct` is created by the [`difference`] method on [`BTreeSet`]. +/// See its documentation for more. +/// +/// [`difference`]: BTreeSet::difference +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Difference<'a, T: 'a> { + inner: DifferenceInner<'a, T>, +} +#[derive(Debug)] +enum DifferenceInner<'a, T: 'a> { + Stitch { + // iterate all of `self` and some of `other`, spotting matches along the way + self_iter: Iter<'a, T>, + other_iter: Peekable>, + }, + Search { + // iterate `self`, look up in `other` + self_iter: Iter<'a, T>, + other_set: &'a BTreeSet, + }, + Iterate(Iter<'a, T>), // simply produce all values in `self` +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Difference<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Difference").field(&self.inner).finish() + } +} + +/// A lazy iterator producing elements in the symmetric difference of `BTreeSet`s. +/// +/// This `struct` is created by the [`symmetric_difference`] method on +/// [`BTreeSet`]. See its documentation for more. +/// +/// [`symmetric_difference`]: BTreeSet::symmetric_difference +#[stable(feature = "rust1", since = "1.0.0")] +pub struct SymmetricDifference<'a, T: 'a>(MergeIterInner>); + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for SymmetricDifference<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("SymmetricDifference").field(&self.0).finish() + } +} + +/// A lazy iterator producing elements in the intersection of `BTreeSet`s. +/// +/// This `struct` is created by the [`intersection`] method on [`BTreeSet`]. +/// See its documentation for more. +/// +/// [`intersection`]: BTreeSet::intersection +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Intersection<'a, T: 'a> { + inner: IntersectionInner<'a, T>, +} +#[derive(Debug)] +enum IntersectionInner<'a, T: 'a> { + Stitch { + // iterate similarly sized sets jointly, spotting matches along the way + a: Iter<'a, T>, + b: Iter<'a, T>, + }, + Search { + // iterate a small set, look up in the large set + small_iter: Iter<'a, T>, + large_set: &'a BTreeSet, + }, + Answer(Option<&'a T>), // return a specific value or emptiness +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Intersection<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Intersection").field(&self.inner).finish() + } +} + +/// A lazy iterator producing elements in the union of `BTreeSet`s. +/// +/// This `struct` is created by the [`union`] method on [`BTreeSet`]. +/// See its documentation for more. +/// +/// [`union`]: BTreeSet::union +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Union<'a, T: 'a>(MergeIterInner>); + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Union<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Union").field(&self.0).finish() + } +} + +// This constant is used by functions that compare two sets. +// It estimates the relative size at which searching performs better +// than iterating, based on the benchmarks in +// https://github.com/ssomers/rust_bench_btreeset_intersection; +// It's used to divide rather than multiply sizes, to rule out overflow, +// and it's a power of two to make that division cheap. +const ITER_PERFORMANCE_TIPPING_SIZE_DIFF: usize = 16; + +impl BTreeSet { + /// Makes a new `BTreeSet` with a reasonable choice of B. + /// + /// # Examples + /// + /// ``` + /// # #![allow(unused_mut)] + /// use std::collections::BTreeSet; + /// + /// let mut set: BTreeSet = BTreeSet::new(); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_const_unstable(feature = "const_btree_new", issue = "71835")] + pub const fn new() -> BTreeSet { + BTreeSet { map: BTreeMap::new() } + } + + /// Constructs a double-ended iterator over a sub-range of elements in the set. + /// The simplest way is to use the range syntax `min..max`, thus `range(min..max)` will + /// yield elements from min (inclusive) to max (exclusive). + /// The range may also be entered as `(Bound, Bound)`, so for example + /// `range((Excluded(4), Included(10)))` will yield a left-exclusive, right-inclusive + /// range from 4 to 10. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// use std::ops::Bound::Included; + /// + /// let mut set = BTreeSet::new(); + /// set.insert(3); + /// set.insert(5); + /// set.insert(8); + /// for &elem in set.range((Included(&4), Included(&8))) { + /// println!("{}", elem); + /// } + /// assert_eq!(Some(&5), set.range(4..).next()); + /// ``` + #[stable(feature = "btree_range", since = "1.17.0")] + pub fn range(&self, range: R) -> Range<'_, T> + where + K: Ord, + T: Borrow, + R: RangeBounds, + { + Range { iter: self.map.range(range) } + } + + /// Visits the values representing the difference, + /// i.e., the values that are in `self` but not in `other`, + /// in ascending order. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut a = BTreeSet::new(); + /// a.insert(1); + /// a.insert(2); + /// + /// let mut b = BTreeSet::new(); + /// b.insert(2); + /// b.insert(3); + /// + /// let diff: Vec<_> = a.difference(&b).cloned().collect(); + /// assert_eq!(diff, [1]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn difference<'a>(&'a self, other: &'a BTreeSet) -> Difference<'a, T> { + let (self_min, self_max) = + if let (Some(self_min), Some(self_max)) = (self.first(), self.last()) { + (self_min, self_max) + } else { + return Difference { inner: DifferenceInner::Iterate(self.iter()) }; + }; + let (other_min, other_max) = + if let (Some(other_min), Some(other_max)) = (other.first(), other.last()) { + (other_min, other_max) + } else { + return Difference { inner: DifferenceInner::Iterate(self.iter()) }; + }; + Difference { + inner: match (self_min.cmp(other_max), self_max.cmp(other_min)) { + (Greater, _) | (_, Less) => DifferenceInner::Iterate(self.iter()), + (Equal, _) => { + let mut self_iter = self.iter(); + self_iter.next(); + DifferenceInner::Iterate(self_iter) + } + (_, Equal) => { + let mut self_iter = self.iter(); + self_iter.next_back(); + DifferenceInner::Iterate(self_iter) + } + _ if self.len() <= other.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF => { + DifferenceInner::Search { self_iter: self.iter(), other_set: other } + } + _ => DifferenceInner::Stitch { + self_iter: self.iter(), + other_iter: other.iter().peekable(), + }, + }, + } + } + + /// Visits the values representing the symmetric difference, + /// i.e., the values that are in `self` or in `other` but not in both, + /// in ascending order. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut a = BTreeSet::new(); + /// a.insert(1); + /// a.insert(2); + /// + /// let mut b = BTreeSet::new(); + /// b.insert(2); + /// b.insert(3); + /// + /// let sym_diff: Vec<_> = a.symmetric_difference(&b).cloned().collect(); + /// assert_eq!(sym_diff, [1, 3]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn symmetric_difference<'a>( + &'a self, + other: &'a BTreeSet, + ) -> SymmetricDifference<'a, T> { + SymmetricDifference(MergeIterInner::new(self.iter(), other.iter())) + } + + /// Visits the values representing the intersection, + /// i.e., the values that are both in `self` and `other`, + /// in ascending order. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut a = BTreeSet::new(); + /// a.insert(1); + /// a.insert(2); + /// + /// let mut b = BTreeSet::new(); + /// b.insert(2); + /// b.insert(3); + /// + /// let intersection: Vec<_> = a.intersection(&b).cloned().collect(); + /// assert_eq!(intersection, [2]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn intersection<'a>(&'a self, other: &'a BTreeSet) -> Intersection<'a, T> { + let (self_min, self_max) = + if let (Some(self_min), Some(self_max)) = (self.first(), self.last()) { + (self_min, self_max) + } else { + return Intersection { inner: IntersectionInner::Answer(None) }; + }; + let (other_min, other_max) = + if let (Some(other_min), Some(other_max)) = (other.first(), other.last()) { + (other_min, other_max) + } else { + return Intersection { inner: IntersectionInner::Answer(None) }; + }; + Intersection { + inner: match (self_min.cmp(other_max), self_max.cmp(other_min)) { + (Greater, _) | (_, Less) => IntersectionInner::Answer(None), + (Equal, _) => IntersectionInner::Answer(Some(self_min)), + (_, Equal) => IntersectionInner::Answer(Some(self_max)), + _ if self.len() <= other.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF => { + IntersectionInner::Search { small_iter: self.iter(), large_set: other } + } + _ if other.len() <= self.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF => { + IntersectionInner::Search { small_iter: other.iter(), large_set: self } + } + _ => IntersectionInner::Stitch { a: self.iter(), b: other.iter() }, + }, + } + } + + /// Visits the values representing the union, + /// i.e., all the values in `self` or `other`, without duplicates, + /// in ascending order. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut a = BTreeSet::new(); + /// a.insert(1); + /// + /// let mut b = BTreeSet::new(); + /// b.insert(2); + /// + /// let union: Vec<_> = a.union(&b).cloned().collect(); + /// assert_eq!(union, [1, 2]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn union<'a>(&'a self, other: &'a BTreeSet) -> Union<'a, T> { + Union(MergeIterInner::new(self.iter(), other.iter())) + } + + /// Clears the set, removing all values. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut v = BTreeSet::new(); + /// v.insert(1); + /// v.clear(); + /// assert!(v.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn clear(&mut self) { + self.map.clear() + } + + /// Returns `true` if the set contains a value. + /// + /// The value may be any borrowed form of the set's value type, + /// but the ordering on the borrowed form *must* match the + /// ordering on the value type. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect(); + /// assert_eq!(set.contains(&1), true); + /// assert_eq!(set.contains(&4), false); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn contains(&self, value: &Q) -> bool + where + T: Borrow, + Q: Ord, + { + self.map.contains_key(value) + } + + /// Returns a reference to the value in the set, if any, that is equal to the given value. + /// + /// The value may be any borrowed form of the set's value type, + /// but the ordering on the borrowed form *must* match the + /// ordering on the value type. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect(); + /// assert_eq!(set.get(&2), Some(&2)); + /// assert_eq!(set.get(&4), None); + /// ``` + #[stable(feature = "set_recovery", since = "1.9.0")] + pub fn get(&self, value: &Q) -> Option<&T> + where + T: Borrow, + Q: Ord, + { + Recover::get(&self.map, value) + } + + /// Returns `true` if `self` has no elements in common with `other`. + /// This is equivalent to checking for an empty intersection. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let a: BTreeSet<_> = [1, 2, 3].iter().cloned().collect(); + /// let mut b = BTreeSet::new(); + /// + /// assert_eq!(a.is_disjoint(&b), true); + /// b.insert(4); + /// assert_eq!(a.is_disjoint(&b), true); + /// b.insert(1); + /// assert_eq!(a.is_disjoint(&b), false); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn is_disjoint(&self, other: &BTreeSet) -> bool { + self.intersection(other).next().is_none() + } + + /// Returns `true` if the set is a subset of another, + /// i.e., `other` contains at least all the values in `self`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let sup: BTreeSet<_> = [1, 2, 3].iter().cloned().collect(); + /// let mut set = BTreeSet::new(); + /// + /// assert_eq!(set.is_subset(&sup), true); + /// set.insert(2); + /// assert_eq!(set.is_subset(&sup), true); + /// set.insert(4); + /// assert_eq!(set.is_subset(&sup), false); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn is_subset(&self, other: &BTreeSet) -> bool { + // Same result as self.difference(other).next().is_none() + // but the code below is faster (hugely in some cases). + if self.len() > other.len() { + return false; + } + let (self_min, self_max) = + if let (Some(self_min), Some(self_max)) = (self.first(), self.last()) { + (self_min, self_max) + } else { + return true; // self is empty + }; + let (other_min, other_max) = + if let (Some(other_min), Some(other_max)) = (other.first(), other.last()) { + (other_min, other_max) + } else { + return false; // other is empty + }; + let mut self_iter = self.iter(); + match self_min.cmp(other_min) { + Less => return false, + Equal => { + self_iter.next(); + } + Greater => (), + } + match self_max.cmp(other_max) { + Greater => return false, + Equal => { + self_iter.next_back(); + } + Less => (), + } + if self_iter.len() <= other.len() / ITER_PERFORMANCE_TIPPING_SIZE_DIFF { + for next in self_iter { + if !other.contains(next) { + return false; + } + } + } else { + let mut other_iter = other.iter(); + other_iter.next(); + other_iter.next_back(); + let mut self_next = self_iter.next(); + while let Some(self1) = self_next { + match other_iter.next().map_or(Less, |other1| self1.cmp(other1)) { + Less => return false, + Equal => self_next = self_iter.next(), + Greater => (), + } + } + } + true + } + + /// Returns `true` if the set is a superset of another, + /// i.e., `self` contains at least all the values in `other`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let sub: BTreeSet<_> = [1, 2].iter().cloned().collect(); + /// let mut set = BTreeSet::new(); + /// + /// assert_eq!(set.is_superset(&sub), false); + /// + /// set.insert(0); + /// set.insert(1); + /// assert_eq!(set.is_superset(&sub), false); + /// + /// set.insert(2); + /// assert_eq!(set.is_superset(&sub), true); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn is_superset(&self, other: &BTreeSet) -> bool { + other.is_subset(self) + } + + /// Returns a reference to the first value in the set, if any. + /// This value is always the minimum of all values in the set. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeSet; + /// + /// let mut map = BTreeSet::new(); + /// assert_eq!(map.first(), None); + /// map.insert(1); + /// assert_eq!(map.first(), Some(&1)); + /// map.insert(2); + /// assert_eq!(map.first(), Some(&1)); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn first(&self) -> Option<&T> { + self.map.first_key_value().map(|(k, _)| k) + } + + /// Returns a reference to the last value in the set, if any. + /// This value is always the maximum of all values in the set. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeSet; + /// + /// let mut map = BTreeSet::new(); + /// assert_eq!(map.first(), None); + /// map.insert(1); + /// assert_eq!(map.last(), Some(&1)); + /// map.insert(2); + /// assert_eq!(map.last(), Some(&2)); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn last(&self) -> Option<&T> { + self.map.last_key_value().map(|(k, _)| k) + } + + /// Removes the first value from the set and returns it, if any. + /// The first value is always the minimum value in the set. + /// + /// # Examples + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeSet; + /// + /// let mut set = BTreeSet::new(); + /// + /// set.insert(1); + /// while let Some(n) = set.pop_first() { + /// assert_eq!(n, 1); + /// } + /// assert!(set.is_empty()); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn pop_first(&mut self) -> Option { + self.map.first_entry().map(|entry| entry.remove_entry().0) + } + + /// Removes the last value from the set and returns it, if any. + /// The last value is always the maximum value in the set. + /// + /// # Examples + /// + /// ``` + /// #![feature(map_first_last)] + /// use std::collections::BTreeSet; + /// + /// let mut set = BTreeSet::new(); + /// + /// set.insert(1); + /// while let Some(n) = set.pop_last() { + /// assert_eq!(n, 1); + /// } + /// assert!(set.is_empty()); + /// ``` + #[unstable(feature = "map_first_last", issue = "62924")] + pub fn pop_last(&mut self) -> Option { + self.map.last_entry().map(|entry| entry.remove_entry().0) + } + + /// Adds a value to the set. + /// + /// If the set did not have this value present, `true` is returned. + /// + /// If the set did have this value present, `false` is returned, and the + /// entry is not updated. See the [module-level documentation] for more. + /// + /// [module-level documentation]: index.html#insert-and-complex-keys + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut set = BTreeSet::new(); + /// + /// assert_eq!(set.insert(2), true); + /// assert_eq!(set.insert(2), false); + /// assert_eq!(set.len(), 1); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn insert(&mut self, value: T) -> bool { + self.map.insert(value, ()).is_none() + } + + /// Adds a value to the set, replacing the existing value, if any, that is equal to the given + /// one. Returns the replaced value. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut set = BTreeSet::new(); + /// set.insert(Vec::::new()); + /// + /// assert_eq!(set.get(&[][..]).unwrap().capacity(), 0); + /// set.replace(Vec::with_capacity(10)); + /// assert_eq!(set.get(&[][..]).unwrap().capacity(), 10); + /// ``` + #[stable(feature = "set_recovery", since = "1.9.0")] + pub fn replace(&mut self, value: T) -> Option { + Recover::replace(&mut self.map, value) + } + + /// Removes a value from the set. Returns whether the value was + /// present in the set. + /// + /// The value may be any borrowed form of the set's value type, + /// but the ordering on the borrowed form *must* match the + /// ordering on the value type. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut set = BTreeSet::new(); + /// + /// set.insert(2); + /// assert_eq!(set.remove(&2), true); + /// assert_eq!(set.remove(&2), false); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn remove(&mut self, value: &Q) -> bool + where + T: Borrow, + Q: Ord, + { + self.map.remove(value).is_some() + } + + /// Removes and returns the value in the set, if any, that is equal to the given one. + /// + /// The value may be any borrowed form of the set's value type, + /// but the ordering on the borrowed form *must* match the + /// ordering on the value type. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect(); + /// assert_eq!(set.take(&2), Some(2)); + /// assert_eq!(set.take(&2), None); + /// ``` + #[stable(feature = "set_recovery", since = "1.9.0")] + pub fn take(&mut self, value: &Q) -> Option + where + T: Borrow, + Q: Ord, + { + Recover::take(&mut self.map, value) + } + + /// Moves all elements from `other` into `Self`, leaving `other` empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut a = BTreeSet::new(); + /// a.insert(1); + /// a.insert(2); + /// a.insert(3); + /// + /// let mut b = BTreeSet::new(); + /// b.insert(3); + /// b.insert(4); + /// b.insert(5); + /// + /// a.append(&mut b); + /// + /// assert_eq!(a.len(), 5); + /// assert_eq!(b.len(), 0); + /// + /// assert!(a.contains(&1)); + /// assert!(a.contains(&2)); + /// assert!(a.contains(&3)); + /// assert!(a.contains(&4)); + /// assert!(a.contains(&5)); + /// ``` + #[stable(feature = "btree_append", since = "1.11.0")] + pub fn append(&mut self, other: &mut Self) { + self.map.append(&mut other.map); + } + + /// Splits the collection into two at the given key. Returns everything after the given key, + /// including the key. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut a = BTreeSet::new(); + /// a.insert(1); + /// a.insert(2); + /// a.insert(3); + /// a.insert(17); + /// a.insert(41); + /// + /// let b = a.split_off(&3); + /// + /// assert_eq!(a.len(), 2); + /// assert_eq!(b.len(), 3); + /// + /// assert!(a.contains(&1)); + /// assert!(a.contains(&2)); + /// + /// assert!(b.contains(&3)); + /// assert!(b.contains(&17)); + /// assert!(b.contains(&41)); + /// ``` + #[stable(feature = "btree_split_off", since = "1.11.0")] + pub fn split_off(&mut self, key: &Q) -> Self + where + T: Borrow, + { + BTreeSet { map: self.map.split_off(key) } + } + + /// Creates an iterator which uses a closure to determine if a value should be removed. + /// + /// If the closure returns true, then the value is removed and yielded. + /// If the closure returns false, the value will remain in the list and will not be yielded + /// by the iterator. + /// + /// If the iterator is only partially consumed or not consumed at all, each of the remaining + /// values will still be subjected to the closure and removed and dropped if it returns true. + /// + /// It is unspecified how many more values will be subjected to the closure + /// if a panic occurs in the closure, or if a panic occurs while dropping a value, or if the + /// `DrainFilter` itself is leaked. + /// + /// # Examples + /// + /// Splitting a set into even and odd values, reusing the original set: + /// + /// ``` + /// #![feature(btree_drain_filter)] + /// use std::collections::BTreeSet; + /// + /// let mut set: BTreeSet = (0..8).collect(); + /// let evens: BTreeSet<_> = set.drain_filter(|v| v % 2 == 0).collect(); + /// let odds = set; + /// assert_eq!(evens.into_iter().collect::>(), vec![0, 2, 4, 6]); + /// assert_eq!(odds.into_iter().collect::>(), vec![1, 3, 5, 7]); + /// ``` + #[unstable(feature = "btree_drain_filter", issue = "70530")] + pub fn drain_filter<'a, F>(&'a mut self, pred: F) -> DrainFilter<'a, T, F> + where + F: 'a + FnMut(&T) -> bool, + { + DrainFilter { pred, inner: self.map.drain_filter_inner() } + } +} + +impl BTreeSet { + /// Gets an iterator that visits the values in the `BTreeSet` in ascending order. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let set: BTreeSet = [1, 2, 3].iter().cloned().collect(); + /// let mut set_iter = set.iter(); + /// assert_eq!(set_iter.next(), Some(&1)); + /// assert_eq!(set_iter.next(), Some(&2)); + /// assert_eq!(set_iter.next(), Some(&3)); + /// assert_eq!(set_iter.next(), None); + /// ``` + /// + /// Values returned by the iterator are returned in ascending order: + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let set: BTreeSet = [3, 1, 2].iter().cloned().collect(); + /// let mut set_iter = set.iter(); + /// assert_eq!(set_iter.next(), Some(&1)); + /// assert_eq!(set_iter.next(), Some(&2)); + /// assert_eq!(set_iter.next(), Some(&3)); + /// assert_eq!(set_iter.next(), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn iter(&self) -> Iter<'_, T> { + Iter { iter: self.map.keys() } + } + + /// Returns the number of elements in the set. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut v = BTreeSet::new(); + /// assert_eq!(v.len(), 0); + /// v.insert(1); + /// assert_eq!(v.len(), 1); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_const_unstable(feature = "const_btree_new", issue = "71835")] + pub const fn len(&self) -> usize { + self.map.len() + } + + /// Returns `true` if the set contains no elements. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let mut v = BTreeSet::new(); + /// assert!(v.is_empty()); + /// v.insert(1); + /// assert!(!v.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_const_unstable(feature = "const_btree_new", issue = "71835")] + pub const fn is_empty(&self) -> bool { + self.len() == 0 + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl FromIterator for BTreeSet { + fn from_iter>(iter: I) -> BTreeSet { + let mut set = BTreeSet::new(); + set.extend(iter); + set + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl IntoIterator for BTreeSet { + type Item = T; + type IntoIter = IntoIter; + + /// Gets an iterator for moving out the `BTreeSet`'s contents. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let set: BTreeSet = [1, 2, 3, 4].iter().cloned().collect(); + /// + /// let v: Vec<_> = set.into_iter().collect(); + /// assert_eq!(v, [1, 2, 3, 4]); + /// ``` + fn into_iter(self) -> IntoIter { + IntoIter { iter: self.map.into_iter() } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> IntoIterator for &'a BTreeSet { + type Item = &'a T; + type IntoIter = Iter<'a, T>; + + fn into_iter(self) -> Iter<'a, T> { + self.iter() + } +} + +/// An iterator produced by calling `drain_filter` on BTreeSet. +#[unstable(feature = "btree_drain_filter", issue = "70530")] +pub struct DrainFilter<'a, T, F> +where + T: 'a, + F: 'a + FnMut(&T) -> bool, +{ + pred: F, + inner: super::map::DrainFilterInner<'a, T, ()>, +} + +#[unstable(feature = "btree_drain_filter", issue = "70530")] +impl Drop for DrainFilter<'_, T, F> +where + F: FnMut(&T) -> bool, +{ + fn drop(&mut self) { + self.for_each(drop); + } +} + +#[unstable(feature = "btree_drain_filter", issue = "70530")] +impl fmt::Debug for DrainFilter<'_, T, F> +where + T: fmt::Debug, + F: FnMut(&T) -> bool, +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("DrainFilter").field(&self.inner.peek().map(|(k, _)| k)).finish() + } +} + +#[unstable(feature = "btree_drain_filter", issue = "70530")] +impl<'a, T, F> Iterator for DrainFilter<'_, T, F> +where + F: 'a + FnMut(&T) -> bool, +{ + type Item = T; + + fn next(&mut self) -> Option { + let pred = &mut self.pred; + let mut mapped_pred = |k: &T, _v: &mut ()| pred(k); + self.inner.next(&mut mapped_pred).map(|(k, _)| k) + } + + fn size_hint(&self) -> (usize, Option) { + self.inner.size_hint() + } +} + +#[unstable(feature = "btree_drain_filter", issue = "70530")] +impl FusedIterator for DrainFilter<'_, T, F> where F: FnMut(&T) -> bool {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Extend for BTreeSet { + #[inline] + fn extend>(&mut self, iter: Iter) { + iter.into_iter().for_each(move |elem| { + self.insert(elem); + }); + } + + #[inline] + fn extend_one(&mut self, elem: T) { + self.insert(elem); + } +} + +#[stable(feature = "extend_ref", since = "1.2.0")] +impl<'a, T: 'a + Ord + Copy> Extend<&'a T> for BTreeSet { + fn extend>(&mut self, iter: I) { + self.extend(iter.into_iter().cloned()); + } + + #[inline] + fn extend_one(&mut self, &elem: &'a T) { + self.insert(elem); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for BTreeSet { + /// Makes an empty `BTreeSet` with a reasonable choice of B. + fn default() -> BTreeSet { + BTreeSet::new() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Sub<&BTreeSet> for &BTreeSet { + type Output = BTreeSet; + + /// Returns the difference of `self` and `rhs` as a new `BTreeSet`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect(); + /// let b: BTreeSet<_> = vec![3, 4, 5].into_iter().collect(); + /// + /// let result = &a - &b; + /// let result_vec: Vec<_> = result.into_iter().collect(); + /// assert_eq!(result_vec, [1, 2]); + /// ``` + fn sub(self, rhs: &BTreeSet) -> BTreeSet { + self.difference(rhs).cloned().collect() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl BitXor<&BTreeSet> for &BTreeSet { + type Output = BTreeSet; + + /// Returns the symmetric difference of `self` and `rhs` as a new `BTreeSet`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect(); + /// let b: BTreeSet<_> = vec![2, 3, 4].into_iter().collect(); + /// + /// let result = &a ^ &b; + /// let result_vec: Vec<_> = result.into_iter().collect(); + /// assert_eq!(result_vec, [1, 4]); + /// ``` + fn bitxor(self, rhs: &BTreeSet) -> BTreeSet { + self.symmetric_difference(rhs).cloned().collect() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl BitAnd<&BTreeSet> for &BTreeSet { + type Output = BTreeSet; + + /// Returns the intersection of `self` and `rhs` as a new `BTreeSet`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect(); + /// let b: BTreeSet<_> = vec![2, 3, 4].into_iter().collect(); + /// + /// let result = &a & &b; + /// let result_vec: Vec<_> = result.into_iter().collect(); + /// assert_eq!(result_vec, [2, 3]); + /// ``` + fn bitand(self, rhs: &BTreeSet) -> BTreeSet { + self.intersection(rhs).cloned().collect() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl BitOr<&BTreeSet> for &BTreeSet { + type Output = BTreeSet; + + /// Returns the union of `self` and `rhs` as a new `BTreeSet`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::BTreeSet; + /// + /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect(); + /// let b: BTreeSet<_> = vec![3, 4, 5].into_iter().collect(); + /// + /// let result = &a | &b; + /// let result_vec: Vec<_> = result.into_iter().collect(); + /// assert_eq!(result_vec, [1, 2, 3, 4, 5]); + /// ``` + fn bitor(self, rhs: &BTreeSet) -> BTreeSet { + self.union(rhs).cloned().collect() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Debug for BTreeSet { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_set().entries(self.iter()).finish() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Iter<'_, T> { + fn clone(&self) -> Self { + Iter { iter: self.iter.clone() } + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> Iterator for Iter<'a, T> { + type Item = &'a T; + + fn next(&mut self) -> Option<&'a T> { + self.iter.next() + } + + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } + + fn last(mut self) -> Option<&'a T> { + self.next_back() + } + + fn min(mut self) -> Option<&'a T> { + self.next() + } + + fn max(mut self) -> Option<&'a T> { + self.next_back() + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> DoubleEndedIterator for Iter<'a, T> { + fn next_back(&mut self) -> Option<&'a T> { + self.iter.next_back() + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for Iter<'_, T> { + fn len(&self) -> usize { + self.iter.len() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Iter<'_, T> {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Iterator for IntoIter { + type Item = T; + + fn next(&mut self) -> Option { + self.iter.next().map(|(k, _)| k) + } + + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl DoubleEndedIterator for IntoIter { + fn next_back(&mut self) -> Option { + self.iter.next_back().map(|(k, _)| k) + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for IntoIter { + fn len(&self) -> usize { + self.iter.len() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for IntoIter {} + +#[stable(feature = "btree_range", since = "1.17.0")] +impl Clone for Range<'_, T> { + fn clone(&self) -> Self { + Range { iter: self.iter.clone() } + } +} + +#[stable(feature = "btree_range", since = "1.17.0")] +impl<'a, T> Iterator for Range<'a, T> { + type Item = &'a T; + + fn next(&mut self) -> Option<&'a T> { + self.iter.next().map(|(k, _)| k) + } + + fn last(mut self) -> Option<&'a T> { + self.next_back() + } + + fn min(mut self) -> Option<&'a T> { + self.next() + } + + fn max(mut self) -> Option<&'a T> { + self.next_back() + } +} + +#[stable(feature = "btree_range", since = "1.17.0")] +impl<'a, T> DoubleEndedIterator for Range<'a, T> { + fn next_back(&mut self) -> Option<&'a T> { + self.iter.next_back().map(|(k, _)| k) + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Range<'_, T> {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Difference<'_, T> { + fn clone(&self) -> Self { + Difference { + inner: match &self.inner { + DifferenceInner::Stitch { self_iter, other_iter } => DifferenceInner::Stitch { + self_iter: self_iter.clone(), + other_iter: other_iter.clone(), + }, + DifferenceInner::Search { self_iter, other_set } => { + DifferenceInner::Search { self_iter: self_iter.clone(), other_set } + } + DifferenceInner::Iterate(iter) => DifferenceInner::Iterate(iter.clone()), + }, + } + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T: Ord> Iterator for Difference<'a, T> { + type Item = &'a T; + + fn next(&mut self) -> Option<&'a T> { + match &mut self.inner { + DifferenceInner::Stitch { self_iter, other_iter } => { + let mut self_next = self_iter.next()?; + loop { + match other_iter.peek().map_or(Less, |other_next| self_next.cmp(other_next)) { + Less => return Some(self_next), + Equal => { + self_next = self_iter.next()?; + other_iter.next(); + } + Greater => { + other_iter.next(); + } + } + } + } + DifferenceInner::Search { self_iter, other_set } => loop { + let self_next = self_iter.next()?; + if !other_set.contains(&self_next) { + return Some(self_next); + } + }, + DifferenceInner::Iterate(iter) => iter.next(), + } + } + + fn size_hint(&self) -> (usize, Option) { + let (self_len, other_len) = match &self.inner { + DifferenceInner::Stitch { self_iter, other_iter } => { + (self_iter.len(), other_iter.len()) + } + DifferenceInner::Search { self_iter, other_set } => (self_iter.len(), other_set.len()), + DifferenceInner::Iterate(iter) => (iter.len(), 0), + }; + (self_len.saturating_sub(other_len), Some(self_len)) + } + + fn min(mut self) -> Option<&'a T> { + self.next() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Difference<'_, T> {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for SymmetricDifference<'_, T> { + fn clone(&self) -> Self { + SymmetricDifference(self.0.clone()) + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T: Ord> Iterator for SymmetricDifference<'a, T> { + type Item = &'a T; + + fn next(&mut self) -> Option<&'a T> { + loop { + let (a_next, b_next) = self.0.nexts(Self::Item::cmp); + if a_next.and(b_next).is_none() { + return a_next.or(b_next); + } + } + } + + fn size_hint(&self) -> (usize, Option) { + let (a_len, b_len) = self.0.lens(); + // No checked_add, because even if a and b refer to the same set, + // and T is an empty type, the storage overhead of sets limits + // the number of elements to less than half the range of usize. + (0, Some(a_len + b_len)) + } + + fn min(mut self) -> Option<&'a T> { + self.next() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for SymmetricDifference<'_, T> {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Intersection<'_, T> { + fn clone(&self) -> Self { + Intersection { + inner: match &self.inner { + IntersectionInner::Stitch { a, b } => { + IntersectionInner::Stitch { a: a.clone(), b: b.clone() } + } + IntersectionInner::Search { small_iter, large_set } => { + IntersectionInner::Search { small_iter: small_iter.clone(), large_set } + } + IntersectionInner::Answer(answer) => IntersectionInner::Answer(*answer), + }, + } + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T: Ord> Iterator for Intersection<'a, T> { + type Item = &'a T; + + fn next(&mut self) -> Option<&'a T> { + match &mut self.inner { + IntersectionInner::Stitch { a, b } => { + let mut a_next = a.next()?; + let mut b_next = b.next()?; + loop { + match a_next.cmp(b_next) { + Less => a_next = a.next()?, + Greater => b_next = b.next()?, + Equal => return Some(a_next), + } + } + } + IntersectionInner::Search { small_iter, large_set } => loop { + let small_next = small_iter.next()?; + if large_set.contains(&small_next) { + return Some(small_next); + } + }, + IntersectionInner::Answer(answer) => answer.take(), + } + } + + fn size_hint(&self) -> (usize, Option) { + match &self.inner { + IntersectionInner::Stitch { a, b } => (0, Some(min(a.len(), b.len()))), + IntersectionInner::Search { small_iter, .. } => (0, Some(small_iter.len())), + IntersectionInner::Answer(None) => (0, Some(0)), + IntersectionInner::Answer(Some(_)) => (1, Some(1)), + } + } + + fn min(mut self) -> Option<&'a T> { + self.next() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Intersection<'_, T> {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Union<'_, T> { + fn clone(&self) -> Self { + Union(self.0.clone()) + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T: Ord> Iterator for Union<'a, T> { + type Item = &'a T; + + fn next(&mut self) -> Option<&'a T> { + let (a_next, b_next) = self.0.nexts(Self::Item::cmp); + a_next.or(b_next) + } + + fn size_hint(&self) -> (usize, Option) { + let (a_len, b_len) = self.0.lens(); + // No checked_add - see SymmetricDifference::size_hint. + (max(a_len, b_len), Some(a_len + b_len)) + } + + fn min(mut self) -> Option<&'a T> { + self.next() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Union<'_, T> {} + +#[cfg(test)] +mod tests; diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/btree/set/tests.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/set/tests.rs new file mode 100644 index 000000000000..52cde8299e41 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/set/tests.rs @@ -0,0 +1,732 @@ +use super::super::DeterministicRng; +use super::*; +use crate::vec::Vec; +use std::iter::FromIterator; +use std::panic::{catch_unwind, AssertUnwindSafe}; +use std::sync::atomic::{AtomicU32, Ordering}; + +#[test] +fn test_clone_eq() { + let mut m = BTreeSet::new(); + + m.insert(1); + m.insert(2); + + assert_eq!(m.clone(), m); +} + +#[allow(dead_code)] +fn test_const() { + const SET: &'static BTreeSet<()> = &BTreeSet::new(); + const LEN: usize = SET.len(); + const IS_EMPTY: bool = SET.is_empty(); +} + +#[test] +fn test_iter_min_max() { + let mut a = BTreeSet::new(); + assert_eq!(a.iter().min(), None); + assert_eq!(a.iter().max(), None); + assert_eq!(a.range(..).min(), None); + assert_eq!(a.range(..).max(), None); + assert_eq!(a.difference(&BTreeSet::new()).min(), None); + assert_eq!(a.difference(&BTreeSet::new()).max(), None); + assert_eq!(a.intersection(&a).min(), None); + assert_eq!(a.intersection(&a).max(), None); + assert_eq!(a.symmetric_difference(&BTreeSet::new()).min(), None); + assert_eq!(a.symmetric_difference(&BTreeSet::new()).max(), None); + assert_eq!(a.union(&a).min(), None); + assert_eq!(a.union(&a).max(), None); + a.insert(1); + a.insert(2); + assert_eq!(a.iter().min(), Some(&1)); + assert_eq!(a.iter().max(), Some(&2)); + assert_eq!(a.range(..).min(), Some(&1)); + assert_eq!(a.range(..).max(), Some(&2)); + assert_eq!(a.difference(&BTreeSet::new()).min(), Some(&1)); + assert_eq!(a.difference(&BTreeSet::new()).max(), Some(&2)); + assert_eq!(a.intersection(&a).min(), Some(&1)); + assert_eq!(a.intersection(&a).max(), Some(&2)); + assert_eq!(a.symmetric_difference(&BTreeSet::new()).min(), Some(&1)); + assert_eq!(a.symmetric_difference(&BTreeSet::new()).max(), Some(&2)); + assert_eq!(a.union(&a).min(), Some(&1)); + assert_eq!(a.union(&a).max(), Some(&2)); +} + +fn check(a: &[i32], b: &[i32], expected: &[i32], f: F) +where + F: FnOnce(&BTreeSet, &BTreeSet, &mut dyn FnMut(&i32) -> bool) -> bool, +{ + let mut set_a = BTreeSet::new(); + let mut set_b = BTreeSet::new(); + + for x in a { + assert!(set_a.insert(*x)) + } + for y in b { + assert!(set_b.insert(*y)) + } + + let mut i = 0; + f(&set_a, &set_b, &mut |&x| { + if i < expected.len() { + assert_eq!(x, expected[i]); + } + i += 1; + true + }); + assert_eq!(i, expected.len()); +} + +#[test] +fn test_intersection() { + fn check_intersection(a: &[i32], b: &[i32], expected: &[i32]) { + check(a, b, expected, |x, y, f| x.intersection(y).all(f)) + } + + check_intersection(&[], &[], &[]); + check_intersection(&[1, 2, 3], &[], &[]); + check_intersection(&[], &[1, 2, 3], &[]); + check_intersection(&[2], &[1, 2, 3], &[2]); + check_intersection(&[1, 2, 3], &[2], &[2]); + check_intersection(&[11, 1, 3, 77, 103, 5, -5], &[2, 11, 77, -9, -42, 5, 3], &[3, 5, 11, 77]); + + if cfg!(miri) { + // Miri is too slow + return; + } + + let large = (0..100).collect::>(); + check_intersection(&[], &large, &[]); + check_intersection(&large, &[], &[]); + check_intersection(&[-1], &large, &[]); + check_intersection(&large, &[-1], &[]); + check_intersection(&[0], &large, &[0]); + check_intersection(&large, &[0], &[0]); + check_intersection(&[99], &large, &[99]); + check_intersection(&large, &[99], &[99]); + check_intersection(&[100], &large, &[]); + check_intersection(&large, &[100], &[]); + check_intersection(&[11, 5000, 1, 3, 77, 8924], &large, &[1, 3, 11, 77]); +} + +#[test] +fn test_intersection_size_hint() { + let x: BTreeSet = [3, 4].iter().copied().collect(); + let y: BTreeSet = [1, 2, 3].iter().copied().collect(); + let mut iter = x.intersection(&y); + assert_eq!(iter.size_hint(), (1, Some(1))); + assert_eq!(iter.next(), Some(&3)); + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + + iter = y.intersection(&y); + assert_eq!(iter.size_hint(), (0, Some(3))); + assert_eq!(iter.next(), Some(&1)); + assert_eq!(iter.size_hint(), (0, Some(2))); +} + +#[test] +fn test_difference() { + fn check_difference(a: &[i32], b: &[i32], expected: &[i32]) { + check(a, b, expected, |x, y, f| x.difference(y).all(f)) + } + + check_difference(&[], &[], &[]); + check_difference(&[1, 12], &[], &[1, 12]); + check_difference(&[], &[1, 2, 3, 9], &[]); + check_difference(&[1, 3, 5, 9, 11], &[3, 9], &[1, 5, 11]); + check_difference(&[1, 3, 5, 9, 11], &[3, 6, 9], &[1, 5, 11]); + check_difference(&[1, 3, 5, 9, 11], &[0, 1], &[3, 5, 9, 11]); + check_difference(&[1, 3, 5, 9, 11], &[11, 12], &[1, 3, 5, 9]); + check_difference( + &[-5, 11, 22, 33, 40, 42], + &[-12, -5, 14, 23, 34, 38, 39, 50], + &[11, 22, 33, 40, 42], + ); + + if cfg!(miri) { + // Miri is too slow + return; + } + + let large = (0..100).collect::>(); + check_difference(&[], &large, &[]); + check_difference(&[-1], &large, &[-1]); + check_difference(&[0], &large, &[]); + check_difference(&[99], &large, &[]); + check_difference(&[100], &large, &[100]); + check_difference(&[11, 5000, 1, 3, 77, 8924], &large, &[5000, 8924]); + check_difference(&large, &[], &large); + check_difference(&large, &[-1], &large); + check_difference(&large, &[100], &large); +} + +#[test] +fn test_difference_size_hint() { + let s246: BTreeSet = [2, 4, 6].iter().copied().collect(); + let s23456: BTreeSet = (2..=6).collect(); + let mut iter = s246.difference(&s23456); + assert_eq!(iter.size_hint(), (0, Some(3))); + assert_eq!(iter.next(), None); + + let s12345: BTreeSet = (1..=5).collect(); + iter = s246.difference(&s12345); + assert_eq!(iter.size_hint(), (0, Some(3))); + assert_eq!(iter.next(), Some(&6)); + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + + let s34567: BTreeSet = (3..=7).collect(); + iter = s246.difference(&s34567); + assert_eq!(iter.size_hint(), (0, Some(3))); + assert_eq!(iter.next(), Some(&2)); + assert_eq!(iter.size_hint(), (0, Some(2))); + assert_eq!(iter.next(), None); + + let s1: BTreeSet = (-9..=1).collect(); + iter = s246.difference(&s1); + assert_eq!(iter.size_hint(), (3, Some(3))); + + let s2: BTreeSet = (-9..=2).collect(); + iter = s246.difference(&s2); + assert_eq!(iter.size_hint(), (2, Some(2))); + assert_eq!(iter.next(), Some(&4)); + assert_eq!(iter.size_hint(), (1, Some(1))); + + let s23: BTreeSet = (2..=3).collect(); + iter = s246.difference(&s23); + assert_eq!(iter.size_hint(), (1, Some(3))); + assert_eq!(iter.next(), Some(&4)); + assert_eq!(iter.size_hint(), (1, Some(1))); + + let s4: BTreeSet = (4..=4).collect(); + iter = s246.difference(&s4); + assert_eq!(iter.size_hint(), (2, Some(3))); + assert_eq!(iter.next(), Some(&2)); + assert_eq!(iter.size_hint(), (1, Some(2))); + assert_eq!(iter.next(), Some(&6)); + assert_eq!(iter.size_hint(), (0, Some(0))); + assert_eq!(iter.next(), None); + + let s56: BTreeSet = (5..=6).collect(); + iter = s246.difference(&s56); + assert_eq!(iter.size_hint(), (1, Some(3))); + assert_eq!(iter.next(), Some(&2)); + assert_eq!(iter.size_hint(), (0, Some(2))); + + let s6: BTreeSet = (6..=19).collect(); + iter = s246.difference(&s6); + assert_eq!(iter.size_hint(), (2, Some(2))); + assert_eq!(iter.next(), Some(&2)); + assert_eq!(iter.size_hint(), (1, Some(1))); + + let s7: BTreeSet = (7..=19).collect(); + iter = s246.difference(&s7); + assert_eq!(iter.size_hint(), (3, Some(3))); +} + +#[test] +fn test_symmetric_difference() { + fn check_symmetric_difference(a: &[i32], b: &[i32], expected: &[i32]) { + check(a, b, expected, |x, y, f| x.symmetric_difference(y).all(f)) + } + + check_symmetric_difference(&[], &[], &[]); + check_symmetric_difference(&[1, 2, 3], &[2], &[1, 3]); + check_symmetric_difference(&[2], &[1, 2, 3], &[1, 3]); + check_symmetric_difference(&[1, 3, 5, 9, 11], &[-2, 3, 9, 14, 22], &[-2, 1, 5, 11, 14, 22]); +} + +#[test] +fn test_symmetric_difference_size_hint() { + let x: BTreeSet = [2, 4].iter().copied().collect(); + let y: BTreeSet = [1, 2, 3].iter().copied().collect(); + let mut iter = x.symmetric_difference(&y); + assert_eq!(iter.size_hint(), (0, Some(5))); + assert_eq!(iter.next(), Some(&1)); + assert_eq!(iter.size_hint(), (0, Some(4))); + assert_eq!(iter.next(), Some(&3)); + assert_eq!(iter.size_hint(), (0, Some(1))); +} + +#[test] +fn test_union() { + fn check_union(a: &[i32], b: &[i32], expected: &[i32]) { + check(a, b, expected, |x, y, f| x.union(y).all(f)) + } + + check_union(&[], &[], &[]); + check_union(&[1, 2, 3], &[2], &[1, 2, 3]); + check_union(&[2], &[1, 2, 3], &[1, 2, 3]); + check_union( + &[1, 3, 5, 9, 11, 16, 19, 24], + &[-2, 1, 5, 9, 13, 19], + &[-2, 1, 3, 5, 9, 11, 13, 16, 19, 24], + ); +} + +#[test] +fn test_union_size_hint() { + let x: BTreeSet = [2, 4].iter().copied().collect(); + let y: BTreeSet = [1, 2, 3].iter().copied().collect(); + let mut iter = x.union(&y); + assert_eq!(iter.size_hint(), (3, Some(5))); + assert_eq!(iter.next(), Some(&1)); + assert_eq!(iter.size_hint(), (2, Some(4))); + assert_eq!(iter.next(), Some(&2)); + assert_eq!(iter.size_hint(), (1, Some(2))); +} + +#[test] +// Only tests the simple function definition with respect to intersection +fn test_is_disjoint() { + let one = [1].iter().collect::>(); + let two = [2].iter().collect::>(); + assert!(one.is_disjoint(&two)); +} + +#[test] +// Also implicitly tests the trivial function definition of is_superset +fn test_is_subset() { + fn is_subset(a: &[i32], b: &[i32]) -> bool { + let set_a = a.iter().collect::>(); + let set_b = b.iter().collect::>(); + set_a.is_subset(&set_b) + } + + assert_eq!(is_subset(&[], &[]), true); + assert_eq!(is_subset(&[], &[1, 2]), true); + assert_eq!(is_subset(&[0], &[1, 2]), false); + assert_eq!(is_subset(&[1], &[1, 2]), true); + assert_eq!(is_subset(&[2], &[1, 2]), true); + assert_eq!(is_subset(&[3], &[1, 2]), false); + assert_eq!(is_subset(&[1, 2], &[1]), false); + assert_eq!(is_subset(&[1, 2], &[1, 2]), true); + assert_eq!(is_subset(&[1, 2], &[2, 3]), false); + assert_eq!( + is_subset(&[-5, 11, 22, 33, 40, 42], &[-12, -5, 11, 14, 22, 23, 33, 34, 38, 39, 40, 42]), + true + ); + assert_eq!(is_subset(&[-5, 11, 22, 33, 40, 42], &[-12, -5, 11, 14, 22, 23, 34, 38]), false); + + if cfg!(miri) { + // Miri is too slow + return; + } + + let large = (0..100).collect::>(); + assert_eq!(is_subset(&[], &large), true); + assert_eq!(is_subset(&large, &[]), false); + assert_eq!(is_subset(&[-1], &large), false); + assert_eq!(is_subset(&[0], &large), true); + assert_eq!(is_subset(&[1, 2], &large), true); + assert_eq!(is_subset(&[99, 100], &large), false); +} + +#[test] +fn test_drain_filter() { + let mut x: BTreeSet<_> = [1].iter().copied().collect(); + let mut y: BTreeSet<_> = [1].iter().copied().collect(); + + x.drain_filter(|_| true); + y.drain_filter(|_| false); + assert_eq!(x.len(), 0); + assert_eq!(y.len(), 1); +} + +#[test] +fn test_drain_filter_drop_panic_leak() { + static PREDS: AtomicU32 = AtomicU32::new(0); + static DROPS: AtomicU32 = AtomicU32::new(0); + + #[derive(PartialEq, Eq, PartialOrd, Ord)] + struct D(i32); + impl Drop for D { + fn drop(&mut self) { + if DROPS.fetch_add(1, Ordering::SeqCst) == 1 { + panic!("panic in `drop`"); + } + } + } + + let mut set = BTreeSet::new(); + set.insert(D(0)); + set.insert(D(4)); + set.insert(D(8)); + + catch_unwind(move || { + drop(set.drain_filter(|d| { + PREDS.fetch_add(1u32 << d.0, Ordering::SeqCst); + true + })) + }) + .ok(); + + assert_eq!(PREDS.load(Ordering::SeqCst), 0x011); + assert_eq!(DROPS.load(Ordering::SeqCst), 3); +} + +#[test] +fn test_drain_filter_pred_panic_leak() { + static PREDS: AtomicU32 = AtomicU32::new(0); + static DROPS: AtomicU32 = AtomicU32::new(0); + + #[derive(PartialEq, Eq, PartialOrd, Ord)] + struct D(i32); + impl Drop for D { + fn drop(&mut self) { + DROPS.fetch_add(1, Ordering::SeqCst); + } + } + + let mut set = BTreeSet::new(); + set.insert(D(0)); + set.insert(D(4)); + set.insert(D(8)); + + catch_unwind(AssertUnwindSafe(|| { + drop(set.drain_filter(|d| { + PREDS.fetch_add(1u32 << d.0, Ordering::SeqCst); + match d.0 { + 0 => true, + _ => panic!(), + } + })) + })) + .ok(); + + assert_eq!(PREDS.load(Ordering::SeqCst), 0x011); + assert_eq!(DROPS.load(Ordering::SeqCst), 1); + assert_eq!(set.len(), 2); + assert_eq!(set.first().unwrap().0, 4); + assert_eq!(set.last().unwrap().0, 8); +} + +#[test] +fn test_clear() { + let mut x = BTreeSet::new(); + x.insert(1); + + x.clear(); + assert!(x.is_empty()); +} + +#[test] +fn test_zip() { + let mut x = BTreeSet::new(); + x.insert(5); + x.insert(12); + x.insert(11); + + let mut y = BTreeSet::new(); + y.insert("foo"); + y.insert("bar"); + + let x = x; + let y = y; + let mut z = x.iter().zip(&y); + + assert_eq!(z.next().unwrap(), (&5, &("bar"))); + assert_eq!(z.next().unwrap(), (&11, &("foo"))); + assert!(z.next().is_none()); +} + +#[test] +fn test_from_iter() { + let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9]; + + let set: BTreeSet<_> = xs.iter().cloned().collect(); + + for x in &xs { + assert!(set.contains(x)); + } +} + +#[test] +fn test_show() { + let mut set = BTreeSet::new(); + let empty = BTreeSet::::new(); + + set.insert(1); + set.insert(2); + + let set_str = format!("{:?}", set); + + assert_eq!(set_str, "{1, 2}"); + assert_eq!(format!("{:?}", empty), "{}"); +} + +#[test] +fn test_extend_ref() { + let mut a = BTreeSet::new(); + a.insert(1); + + a.extend(&[2, 3, 4]); + + assert_eq!(a.len(), 4); + assert!(a.contains(&1)); + assert!(a.contains(&2)); + assert!(a.contains(&3)); + assert!(a.contains(&4)); + + let mut b = BTreeSet::new(); + b.insert(5); + b.insert(6); + + a.extend(&b); + + assert_eq!(a.len(), 6); + assert!(a.contains(&1)); + assert!(a.contains(&2)); + assert!(a.contains(&3)); + assert!(a.contains(&4)); + assert!(a.contains(&5)); + assert!(a.contains(&6)); +} + +#[test] +fn test_recovery() { + use std::cmp::Ordering; + + #[derive(Debug)] + struct Foo(&'static str, i32); + + impl PartialEq for Foo { + fn eq(&self, other: &Self) -> bool { + self.0 == other.0 + } + } + + impl Eq for Foo {} + + impl PartialOrd for Foo { + fn partial_cmp(&self, other: &Self) -> Option { + self.0.partial_cmp(&other.0) + } + } + + impl Ord for Foo { + fn cmp(&self, other: &Self) -> Ordering { + self.0.cmp(&other.0) + } + } + + let mut s = BTreeSet::new(); + assert_eq!(s.replace(Foo("a", 1)), None); + assert_eq!(s.len(), 1); + assert_eq!(s.replace(Foo("a", 2)), Some(Foo("a", 1))); + assert_eq!(s.len(), 1); + + { + let mut it = s.iter(); + assert_eq!(it.next(), Some(&Foo("a", 2))); + assert_eq!(it.next(), None); + } + + assert_eq!(s.get(&Foo("a", 1)), Some(&Foo("a", 2))); + assert_eq!(s.take(&Foo("a", 1)), Some(Foo("a", 2))); + assert_eq!(s.len(), 0); + + assert_eq!(s.get(&Foo("a", 1)), None); + assert_eq!(s.take(&Foo("a", 1)), None); + + assert_eq!(s.iter().next(), None); +} + +#[allow(dead_code)] +fn test_variance() { + fn set<'new>(v: BTreeSet<&'static str>) -> BTreeSet<&'new str> { + v + } + fn iter<'a, 'new>(v: Iter<'a, &'static str>) -> Iter<'a, &'new str> { + v + } + fn into_iter<'new>(v: IntoIter<&'static str>) -> IntoIter<&'new str> { + v + } + fn range<'a, 'new>(v: Range<'a, &'static str>) -> Range<'a, &'new str> { + v + } + // not applied to Difference, Intersection, SymmetricDifference, Union +} + +#[allow(dead_code)] +fn test_sync() { + fn set(v: &BTreeSet) -> impl Sync + '_ { + v + } + + fn iter(v: &BTreeSet) -> impl Sync + '_ { + v.iter() + } + + fn into_iter(v: BTreeSet) -> impl Sync { + v.into_iter() + } + + fn range(v: &BTreeSet) -> impl Sync + '_ { + v.range(..) + } + + fn drain_filter(v: &mut BTreeSet) -> impl Sync + '_ { + v.drain_filter(|_| false) + } + + fn difference(v: &BTreeSet) -> impl Sync + '_ { + v.difference(&v) + } + + fn intersection(v: &BTreeSet) -> impl Sync + '_ { + v.intersection(&v) + } + + fn symmetric_difference(v: &BTreeSet) -> impl Sync + '_ { + v.symmetric_difference(&v) + } + + fn union(v: &BTreeSet) -> impl Sync + '_ { + v.union(&v) + } +} + +#[allow(dead_code)] +fn test_send() { + fn set(v: BTreeSet) -> impl Send { + v + } + + fn iter(v: &BTreeSet) -> impl Send + '_ { + v.iter() + } + + fn into_iter(v: BTreeSet) -> impl Send { + v.into_iter() + } + + fn range(v: &BTreeSet) -> impl Send + '_ { + v.range(..) + } + + fn drain_filter(v: &mut BTreeSet) -> impl Send + '_ { + v.drain_filter(|_| false) + } + + fn difference(v: &BTreeSet) -> impl Send + '_ { + v.difference(&v) + } + + fn intersection(v: &BTreeSet) -> impl Send + '_ { + v.intersection(&v) + } + + fn symmetric_difference(v: &BTreeSet) -> impl Send + '_ { + v.symmetric_difference(&v) + } + + fn union(v: &BTreeSet) -> impl Send + '_ { + v.union(&v) + } +} + +#[test] +fn test_append() { + let mut a = BTreeSet::new(); + a.insert(1); + a.insert(2); + a.insert(3); + + let mut b = BTreeSet::new(); + b.insert(3); + b.insert(4); + b.insert(5); + + a.append(&mut b); + + assert_eq!(a.len(), 5); + assert_eq!(b.len(), 0); + + assert_eq!(a.contains(&1), true); + assert_eq!(a.contains(&2), true); + assert_eq!(a.contains(&3), true); + assert_eq!(a.contains(&4), true); + assert_eq!(a.contains(&5), true); +} + +#[test] +fn test_first_last() { + let mut a = BTreeSet::new(); + assert_eq!(a.first(), None); + assert_eq!(a.last(), None); + a.insert(1); + assert_eq!(a.first(), Some(&1)); + assert_eq!(a.last(), Some(&1)); + a.insert(2); + assert_eq!(a.first(), Some(&1)); + assert_eq!(a.last(), Some(&2)); + for i in 3..=12 { + a.insert(i); + } + assert_eq!(a.first(), Some(&1)); + assert_eq!(a.last(), Some(&12)); + assert_eq!(a.pop_first(), Some(1)); + assert_eq!(a.pop_last(), Some(12)); + assert_eq!(a.pop_first(), Some(2)); + assert_eq!(a.pop_last(), Some(11)); + assert_eq!(a.pop_first(), Some(3)); + assert_eq!(a.pop_last(), Some(10)); + assert_eq!(a.pop_first(), Some(4)); + assert_eq!(a.pop_first(), Some(5)); + assert_eq!(a.pop_first(), Some(6)); + assert_eq!(a.pop_first(), Some(7)); + assert_eq!(a.pop_first(), Some(8)); + assert_eq!(a.clone().pop_last(), Some(9)); + assert_eq!(a.pop_first(), Some(9)); + assert_eq!(a.pop_first(), None); + assert_eq!(a.pop_last(), None); +} + +fn rand_data(len: usize) -> Vec { + assert!(len <= 70029); // from that point on numbers repeat + let mut rng = DeterministicRng::new(); + Vec::from_iter((0..len).map(|_| rng.next())) +} + +#[test] +fn test_split_off_empty_right() { + let mut data = rand_data(173); + + let mut set = BTreeSet::from_iter(data.clone()); + let right = set.split_off(&(data.iter().max().unwrap() + 1)); + + data.sort(); + assert!(set.into_iter().eq(data)); + assert!(right.into_iter().eq(None)); +} + +#[test] +fn test_split_off_empty_left() { + let mut data = rand_data(314); + + let mut set = BTreeSet::from_iter(data.clone()); + let right = set.split_off(data.iter().min().unwrap()); + + data.sort(); + assert!(set.into_iter().eq(None)); + assert!(right.into_iter().eq(data)); +} + +#[test] +fn test_split_off_large_random_sorted() { + // Miri is too slow + let mut data = if cfg!(miri) { rand_data(529) } else { rand_data(1529) }; + // special case with maximum height. + data.sort(); + + let mut set = BTreeSet::from_iter(data.clone()); + let key = data[data.len() / 2]; + let right = set.split_off(&key); + + assert!(set.into_iter().eq(data.clone().into_iter().filter(|x| *x < key))); + assert!(right.into_iter().eq(data.into_iter().filter(|x| *x >= key))); +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/btree/split.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/split.rs new file mode 100644 index 000000000000..545066216c27 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/btree/split.rs @@ -0,0 +1,108 @@ +use crate::gccrs_core_prelude::*; + +use super::map::MIN_LEN; +use super::node::{ForceResult::*, Root}; +use super::search::{search_node, SearchResult::*}; +use core::borrow::Borrow; + +impl Root { + pub fn split_off(&mut self, right_root: &mut Self, key: &Q) + where + K: Borrow, + { + debug_assert!(right_root.height() == 0); + debug_assert!(right_root.node_as_ref().len() == 0); + + let left_root = self; + for _ in 0..left_root.height() { + right_root.push_internal_level(); + } + + { + let mut left_node = left_root.node_as_mut(); + let mut right_node = right_root.node_as_mut(); + + loop { + let mut split_edge = match search_node(left_node, key) { + // key is going to the right tree + Found(handle) => handle.left_edge(), + GoDown(handle) => handle, + }; + + split_edge.move_suffix(&mut right_node); + + match (split_edge.force(), right_node.force()) { + (Internal(edge), Internal(node)) => { + left_node = edge.descend(); + right_node = node.first_edge().descend(); + } + (Leaf(_), Leaf(_)) => { + break; + } + _ => unreachable!(), + } + } + } + + left_root.fix_right_border(); + right_root.fix_left_border(); + } + + /// Removes empty levels on the top, but keeps an empty leaf if the entire tree is empty. + fn fix_top(&mut self) { + while self.height() > 0 && self.node_as_ref().len() == 0 { + self.pop_internal_level(); + } + } + + fn fix_right_border(&mut self) { + self.fix_top(); + + { + let mut cur_node = self.node_as_mut(); + + while let Internal(node) = cur_node.force() { + let mut last_kv = node.last_kv(); + + if last_kv.can_merge() { + cur_node = last_kv.merge().descend(); + } else { + let right_len = last_kv.reborrow().right_edge().descend().len(); + // `MIN_LEN + 1` to avoid readjust if merge happens on the next level. + if right_len < MIN_LEN + 1 { + last_kv.bulk_steal_left(MIN_LEN + 1 - right_len); + } + cur_node = last_kv.right_edge().descend(); + } + } + } + + self.fix_top(); + } + + /// The symmetric clone of `fix_right_border`. + fn fix_left_border(&mut self) { + self.fix_top(); + + { + let mut cur_node = self.node_as_mut(); + + while let Internal(node) = cur_node.force() { + let mut first_kv = node.first_kv(); + + if first_kv.can_merge() { + cur_node = first_kv.merge().descend(); + } else { + let left_len = first_kv.reborrow().left_edge().descend().len(); + // `MIN_LEN + 1` to avoid readjust if merge happens on the next level. + if left_len < MIN_LEN + 1 { + first_kv.bulk_steal_right(MIN_LEN + 1 - left_len); + } + cur_node = first_kv.left_edge().descend(); + } + } + } + + self.fix_top(); + } +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/linked_list.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/linked_list.rs new file mode 100644 index 000000000000..4056de19742d --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/linked_list.rs @@ -0,0 +1,1874 @@ +//! A doubly-linked list with owned nodes. +//! +//! The `LinkedList` allows pushing and popping elements at either end +//! in constant time. +//! +//! NOTE: It is almost always better to use [`Vec`] or [`VecDeque`] because +//! array-based containers are generally faster, +//! more memory efficient, and make better use of CPU cache. +//! +//! [`Vec`]: crate::vec::Vec +//! [`VecDeque`]: super::vec_deque::VecDeque + +#![stable(feature = "rust1", since = "1.0.0")] + +use crate::gccrs_core_prelude::*; + +use core::cmp::Ordering; +use core::fmt; +use core::hash::{Hash, Hasher}; +use core::iter::{FromIterator, FusedIterator}; +use core::marker::PhantomData; +use core::mem; +use core::ptr::NonNull; + +use super::SpecExtend; +use crate::boxed::Box; + +#[cfg(test)] +mod tests; + +/// A doubly-linked list with owned nodes. +/// +/// The `LinkedList` allows pushing and popping elements at either end +/// in constant time. +/// +/// NOTE: It is almost always better to use `Vec` or `VecDeque` because +/// array-based containers are generally faster, +/// more memory efficient, and make better use of CPU cache. +#[stable(feature = "rust1", since = "1.0.0")] +pub struct LinkedList { + head: Option>>, + tail: Option>>, + len: usize, + marker: PhantomData>>, +} + +struct Node { + next: Option>>, + prev: Option>>, + element: T, +} + +/// An iterator over the elements of a `LinkedList`. +/// +/// This `struct` is created by [`LinkedList::iter()`]. See its +/// documentation for more. +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Iter<'a, T: 'a> { + head: Option>>, + tail: Option>>, + len: usize, + marker: PhantomData<&'a Node>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Iter<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Iter").field(&self.len).finish() + } +} + +// FIXME(#26925) Remove in favor of `#[derive(Clone)]` +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Iter<'_, T> { + fn clone(&self) -> Self { + Iter { ..*self } + } +} + +/// A mutable iterator over the elements of a `LinkedList`. +/// +/// This `struct` is created by [`LinkedList::iter_mut()`]. See its +/// documentation for more. +#[stable(feature = "rust1", since = "1.0.0")] +pub struct IterMut<'a, T: 'a> { + // We do *not* exclusively own the entire list here, references to node's `element` + // have been handed out by the iterator! So be careful when using this; the methods + // called must be aware that there can be aliasing pointers to `element`. + list: &'a mut LinkedList, + head: Option>>, + tail: Option>>, + len: usize, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for IterMut<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("IterMut").field(&self.list).field(&self.len).finish() + } +} + +/// An owning iterator over the elements of a `LinkedList`. +/// +/// This `struct` is created by the [`into_iter`] method on [`LinkedList`] +/// (provided by the `IntoIterator` trait). See its documentation for more. +/// +/// [`into_iter`]: LinkedList::into_iter +#[derive(Clone)] +#[stable(feature = "rust1", since = "1.0.0")] +pub struct IntoIter { + list: LinkedList, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for IntoIter { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("IntoIter").field(&self.list).finish() + } +} + +impl Node { + fn new(element: T) -> Self { + Node { next: None, prev: None, element } + } + + fn into_element(self: Box) -> T { + self.element + } +} + +// private methods +impl LinkedList { + /// Adds the given node to the front of the list. + #[inline] + fn push_front_node(&mut self, mut node: Box>) { + // This method takes care not to create mutable references to whole nodes, + // to maintain validity of aliasing pointers into `element`. + unsafe { + node.next = self.head; + node.prev = None; + let node = Some(Box::leak(node).into()); + + match self.head { + None => self.tail = node, + // Not creating new mutable (unique!) references overlapping `element`. + Some(head) => (*head.as_ptr()).prev = node, + } + + self.head = node; + self.len += 1; + } + } + + /// Removes and returns the node at the front of the list. + #[inline] + fn pop_front_node(&mut self) -> Option>> { + // This method takes care not to create mutable references to whole nodes, + // to maintain validity of aliasing pointers into `element`. + self.head.map(|node| unsafe { + let node = Box::from_raw(node.as_ptr()); + self.head = node.next; + + match self.head { + None => self.tail = None, + // Not creating new mutable (unique!) references overlapping `element`. + Some(head) => (*head.as_ptr()).prev = None, + } + + self.len -= 1; + node + }) + } + + /// Adds the given node to the back of the list. + #[inline] + fn push_back_node(&mut self, mut node: Box>) { + // This method takes care not to create mutable references to whole nodes, + // to maintain validity of aliasing pointers into `element`. + unsafe { + node.next = None; + node.prev = self.tail; + let node = Some(Box::leak(node).into()); + + match self.tail { + None => self.head = node, + // Not creating new mutable (unique!) references overlapping `element`. + Some(tail) => (*tail.as_ptr()).next = node, + } + + self.tail = node; + self.len += 1; + } + } + + /// Removes and returns the node at the back of the list. + #[inline] + fn pop_back_node(&mut self) -> Option>> { + // This method takes care not to create mutable references to whole nodes, + // to maintain validity of aliasing pointers into `element`. + self.tail.map(|node| unsafe { + let node = Box::from_raw(node.as_ptr()); + self.tail = node.prev; + + match self.tail { + None => self.head = None, + // Not creating new mutable (unique!) references overlapping `element`. + Some(tail) => (*tail.as_ptr()).next = None, + } + + self.len -= 1; + node + }) + } + + /// Unlinks the specified node from the current list. + /// + /// Warning: this will not check that the provided node belongs to the current list. + /// + /// This method takes care not to create mutable references to `element`, to + /// maintain validity of aliasing pointers. + #[inline] + unsafe fn unlink_node(&mut self, mut node: NonNull>) { + let node = unsafe { node.as_mut() }; // this one is ours now, we can create an &mut. + + // Not creating new mutable (unique!) references overlapping `element`. + match node.prev { + Some(prev) => unsafe { (*prev.as_ptr()).next = node.next }, + // this node is the head node + None => self.head = node.next, + }; + + match node.next { + Some(next) => unsafe { (*next.as_ptr()).prev = node.prev }, + // this node is the tail node + None => self.tail = node.prev, + }; + + self.len -= 1; + } + + /// Splices a series of nodes between two existing nodes. + /// + /// Warning: this will not check that the provided node belongs to the two existing lists. + #[inline] + unsafe fn splice_nodes( + &mut self, + existing_prev: Option>>, + existing_next: Option>>, + mut splice_start: NonNull>, + mut splice_end: NonNull>, + splice_length: usize, + ) { + // This method takes care not to create multiple mutable references to whole nodes at the same time, + // to maintain validity of aliasing pointers into `element`. + if let Some(mut existing_prev) = existing_prev { + unsafe { + existing_prev.as_mut().next = Some(splice_start); + } + } else { + self.head = Some(splice_start); + } + if let Some(mut existing_next) = existing_next { + unsafe { + existing_next.as_mut().prev = Some(splice_end); + } + } else { + self.tail = Some(splice_end); + } + unsafe { + splice_start.as_mut().prev = existing_prev; + splice_end.as_mut().next = existing_next; + } + + self.len += splice_length; + } + + /// Detaches all nodes from a linked list as a series of nodes. + #[inline] + fn detach_all_nodes(mut self) -> Option<(NonNull>, NonNull>, usize)> { + let head = self.head.take(); + let tail = self.tail.take(); + let len = mem::replace(&mut self.len, 0); + if let Some(head) = head { + let tail = tail.unwrap_or_else(|| unsafe { core::hint::unreachable_unchecked() }); + Some((head, tail, len)) + } else { + None + } + } + + #[inline] + unsafe fn split_off_before_node( + &mut self, + split_node: Option>>, + at: usize, + ) -> Self { + // The split node is the new head node of the second part + if let Some(mut split_node) = split_node { + let first_part_head; + let first_part_tail; + unsafe { + first_part_tail = split_node.as_mut().prev.take(); + } + if let Some(mut tail) = first_part_tail { + unsafe { + tail.as_mut().next = None; + } + first_part_head = self.head; + } else { + first_part_head = None; + } + + let first_part = LinkedList { + head: first_part_head, + tail: first_part_tail, + len: at, + marker: PhantomData, + }; + + // Fix the head ptr of the second part + self.head = Some(split_node); + self.len = self.len - at; + + first_part + } else { + mem::replace(self, LinkedList::new()) + } + } + + #[inline] + unsafe fn split_off_after_node( + &mut self, + split_node: Option>>, + at: usize, + ) -> Self { + // The split node is the new tail node of the first part and owns + // the head of the second part. + if let Some(mut split_node) = split_node { + let second_part_head; + let second_part_tail; + unsafe { + second_part_head = split_node.as_mut().next.take(); + } + if let Some(mut head) = second_part_head { + unsafe { + head.as_mut().prev = None; + } + second_part_tail = self.tail; + } else { + second_part_tail = None; + } + + let second_part = LinkedList { + head: second_part_head, + tail: second_part_tail, + len: self.len - at, + marker: PhantomData, + }; + + // Fix the tail ptr of the first part + self.tail = Some(split_node); + self.len = at; + + second_part + } else { + mem::replace(self, LinkedList::new()) + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for LinkedList { + /// Creates an empty `LinkedList`. + #[inline] + fn default() -> Self { + Self::new() + } +} + +impl LinkedList { + /// Creates an empty `LinkedList`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let list: LinkedList = LinkedList::new(); + /// ``` + #[inline] + #[rustc_const_stable(feature = "const_linked_list_new", since = "1.32.0")] + #[stable(feature = "rust1", since = "1.0.0")] + pub const fn new() -> Self { + LinkedList { head: None, tail: None, len: 0, marker: PhantomData } + } + + /// Moves all elements from `other` to the end of the list. + /// + /// This reuses all the nodes from `other` and moves them into `self`. After + /// this operation, `other` becomes empty. + /// + /// This operation should compute in *O*(1) time and *O*(1) memory. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut list1 = LinkedList::new(); + /// list1.push_back('a'); + /// + /// let mut list2 = LinkedList::new(); + /// list2.push_back('b'); + /// list2.push_back('c'); + /// + /// list1.append(&mut list2); + /// + /// let mut iter = list1.iter(); + /// assert_eq!(iter.next(), Some(&'a')); + /// assert_eq!(iter.next(), Some(&'b')); + /// assert_eq!(iter.next(), Some(&'c')); + /// assert!(iter.next().is_none()); + /// + /// assert!(list2.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn append(&mut self, other: &mut Self) { + match self.tail { + None => mem::swap(self, other), + Some(mut tail) => { + // `as_mut` is okay here because we have exclusive access to the entirety + // of both lists. + if let Some(mut other_head) = other.head.take() { + unsafe { + tail.as_mut().next = Some(other_head); + other_head.as_mut().prev = Some(tail); + } + + self.tail = other.tail.take(); + self.len += mem::replace(&mut other.len, 0); + } + } + } + } + + /// Moves all elements from `other` to the begin of the list. + #[unstable(feature = "linked_list_prepend", issue = "none")] + pub fn prepend(&mut self, other: &mut Self) { + match self.head { + None => mem::swap(self, other), + Some(mut head) => { + // `as_mut` is okay here because we have exclusive access to the entirety + // of both lists. + if let Some(mut other_tail) = other.tail.take() { + unsafe { + head.as_mut().prev = Some(other_tail); + other_tail.as_mut().next = Some(head); + } + + self.head = other.head.take(); + self.len += mem::replace(&mut other.len, 0); + } + } + } + } + + /// Provides a forward iterator. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut list: LinkedList = LinkedList::new(); + /// + /// list.push_back(0); + /// list.push_back(1); + /// list.push_back(2); + /// + /// let mut iter = list.iter(); + /// assert_eq!(iter.next(), Some(&0)); + /// assert_eq!(iter.next(), Some(&1)); + /// assert_eq!(iter.next(), Some(&2)); + /// assert_eq!(iter.next(), None); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn iter(&self) -> Iter<'_, T> { + Iter { head: self.head, tail: self.tail, len: self.len, marker: PhantomData } + } + + /// Provides a forward iterator with mutable references. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut list: LinkedList = LinkedList::new(); + /// + /// list.push_back(0); + /// list.push_back(1); + /// list.push_back(2); + /// + /// for element in list.iter_mut() { + /// *element += 10; + /// } + /// + /// let mut iter = list.iter(); + /// assert_eq!(iter.next(), Some(&10)); + /// assert_eq!(iter.next(), Some(&11)); + /// assert_eq!(iter.next(), Some(&12)); + /// assert_eq!(iter.next(), None); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn iter_mut(&mut self) -> IterMut<'_, T> { + IterMut { head: self.head, tail: self.tail, len: self.len, list: self } + } + + /// Provides a cursor at the front element. + /// + /// The cursor is pointing to the "ghost" non-element if the list is empty. + #[inline] + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn cursor_front(&self) -> Cursor<'_, T> { + Cursor { index: 0, current: self.head, list: self } + } + + /// Provides a cursor with editing operations at the front element. + /// + /// The cursor is pointing to the "ghost" non-element if the list is empty. + #[inline] + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn cursor_front_mut(&mut self) -> CursorMut<'_, T> { + CursorMut { index: 0, current: self.head, list: self } + } + + /// Provides a cursor at the back element. + /// + /// The cursor is pointing to the "ghost" non-element if the list is empty. + #[inline] + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn cursor_back(&self) -> Cursor<'_, T> { + Cursor { index: self.len.checked_sub(1).unwrap_or(0), current: self.tail, list: self } + } + + /// Provides a cursor with editing operations at the back element. + /// + /// The cursor is pointing to the "ghost" non-element if the list is empty. + #[inline] + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn cursor_back_mut(&mut self) -> CursorMut<'_, T> { + CursorMut { index: self.len.checked_sub(1).unwrap_or(0), current: self.tail, list: self } + } + + /// Returns `true` if the `LinkedList` is empty. + /// + /// This operation should compute in *O*(1) time. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut dl = LinkedList::new(); + /// assert!(dl.is_empty()); + /// + /// dl.push_front("foo"); + /// assert!(!dl.is_empty()); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn is_empty(&self) -> bool { + self.head.is_none() + } + + /// Returns the length of the `LinkedList`. + /// + /// This operation should compute in *O*(1) time. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut dl = LinkedList::new(); + /// + /// dl.push_front(2); + /// assert_eq!(dl.len(), 1); + /// + /// dl.push_front(1); + /// assert_eq!(dl.len(), 2); + /// + /// dl.push_back(3); + /// assert_eq!(dl.len(), 3); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn len(&self) -> usize { + self.len + } + + /// Removes all elements from the `LinkedList`. + /// + /// This operation should compute in *O*(*n*) time. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut dl = LinkedList::new(); + /// + /// dl.push_front(2); + /// dl.push_front(1); + /// assert_eq!(dl.len(), 2); + /// assert_eq!(dl.front(), Some(&1)); + /// + /// dl.clear(); + /// assert_eq!(dl.len(), 0); + /// assert_eq!(dl.front(), None); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn clear(&mut self) { + *self = Self::new(); + } + + /// Returns `true` if the `LinkedList` contains an element equal to the + /// given value. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut list: LinkedList = LinkedList::new(); + /// + /// list.push_back(0); + /// list.push_back(1); + /// list.push_back(2); + /// + /// assert_eq!(list.contains(&0), true); + /// assert_eq!(list.contains(&10), false); + /// ``` + #[stable(feature = "linked_list_contains", since = "1.12.0")] + pub fn contains(&self, x: &T) -> bool + where + T: PartialEq, + { + self.iter().any(|e| e == x) + } + + /// Provides a reference to the front element, or `None` if the list is + /// empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut dl = LinkedList::new(); + /// assert_eq!(dl.front(), None); + /// + /// dl.push_front(1); + /// assert_eq!(dl.front(), Some(&1)); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn front(&self) -> Option<&T> { + unsafe { self.head.as_ref().map(|node| &node.as_ref().element) } + } + + /// Provides a mutable reference to the front element, or `None` if the list + /// is empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut dl = LinkedList::new(); + /// assert_eq!(dl.front(), None); + /// + /// dl.push_front(1); + /// assert_eq!(dl.front(), Some(&1)); + /// + /// match dl.front_mut() { + /// None => {}, + /// Some(x) => *x = 5, + /// } + /// assert_eq!(dl.front(), Some(&5)); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn front_mut(&mut self) -> Option<&mut T> { + unsafe { self.head.as_mut().map(|node| &mut node.as_mut().element) } + } + + /// Provides a reference to the back element, or `None` if the list is + /// empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut dl = LinkedList::new(); + /// assert_eq!(dl.back(), None); + /// + /// dl.push_back(1); + /// assert_eq!(dl.back(), Some(&1)); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn back(&self) -> Option<&T> { + unsafe { self.tail.as_ref().map(|node| &node.as_ref().element) } + } + + /// Provides a mutable reference to the back element, or `None` if the list + /// is empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut dl = LinkedList::new(); + /// assert_eq!(dl.back(), None); + /// + /// dl.push_back(1); + /// assert_eq!(dl.back(), Some(&1)); + /// + /// match dl.back_mut() { + /// None => {}, + /// Some(x) => *x = 5, + /// } + /// assert_eq!(dl.back(), Some(&5)); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn back_mut(&mut self) -> Option<&mut T> { + unsafe { self.tail.as_mut().map(|node| &mut node.as_mut().element) } + } + + /// Adds an element first in the list. + /// + /// This operation should compute in *O*(1) time. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut dl = LinkedList::new(); + /// + /// dl.push_front(2); + /// assert_eq!(dl.front().unwrap(), &2); + /// + /// dl.push_front(1); + /// assert_eq!(dl.front().unwrap(), &1); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn push_front(&mut self, elt: T) { + self.push_front_node(box Node::new(elt)); + } + + /// Removes the first element and returns it, or `None` if the list is + /// empty. + /// + /// This operation should compute in *O*(1) time. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut d = LinkedList::new(); + /// assert_eq!(d.pop_front(), None); + /// + /// d.push_front(1); + /// d.push_front(3); + /// assert_eq!(d.pop_front(), Some(3)); + /// assert_eq!(d.pop_front(), Some(1)); + /// assert_eq!(d.pop_front(), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn pop_front(&mut self) -> Option { + self.pop_front_node().map(Node::into_element) + } + + /// Appends an element to the back of a list. + /// + /// This operation should compute in *O*(1) time. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut d = LinkedList::new(); + /// d.push_back(1); + /// d.push_back(3); + /// assert_eq!(3, *d.back().unwrap()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn push_back(&mut self, elt: T) { + self.push_back_node(box Node::new(elt)); + } + + /// Removes the last element from a list and returns it, or `None` if + /// it is empty. + /// + /// This operation should compute in *O*(1) time. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut d = LinkedList::new(); + /// assert_eq!(d.pop_back(), None); + /// d.push_back(1); + /// d.push_back(3); + /// assert_eq!(d.pop_back(), Some(3)); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn pop_back(&mut self) -> Option { + self.pop_back_node().map(Node::into_element) + } + + /// Splits the list into two at the given index. Returns everything after the given index, + /// including the index. + /// + /// This operation should compute in *O*(*n*) time. + /// + /// # Panics + /// + /// Panics if `at > len`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::LinkedList; + /// + /// let mut d = LinkedList::new(); + /// + /// d.push_front(1); + /// d.push_front(2); + /// d.push_front(3); + /// + /// let mut split = d.split_off(2); + /// + /// assert_eq!(split.pop_front(), Some(1)); + /// assert_eq!(split.pop_front(), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn split_off(&mut self, at: usize) -> LinkedList { + let len = self.len(); + assert!(at <= len, "Cannot split off at a nonexistent index"); + if at == 0 { + return mem::take(self); + } else if at == len { + return Self::new(); + } + + // Below, we iterate towards the `i-1`th node, either from the start or the end, + // depending on which would be faster. + let split_node = if at - 1 <= len - 1 - (at - 1) { + let mut iter = self.iter_mut(); + // instead of skipping using .skip() (which creates a new struct), + // we skip manually so we can access the head field without + // depending on implementation details of Skip + for _ in 0..at - 1 { + iter.next(); + } + iter.head + } else { + // better off starting from the end + let mut iter = self.iter_mut(); + for _ in 0..len - 1 - (at - 1) { + iter.next_back(); + } + iter.tail + }; + unsafe { self.split_off_after_node(split_node, at) } + } + + /// Removes the element at the given index and returns it. + /// + /// This operation should compute in *O*(*n*) time. + /// + /// # Panics + /// Panics if at >= len + /// + /// # Examples + /// + /// ``` + /// #![feature(linked_list_remove)] + /// use std::collections::LinkedList; + /// + /// let mut d = LinkedList::new(); + /// + /// d.push_front(1); + /// d.push_front(2); + /// d.push_front(3); + /// + /// assert_eq!(d.remove(1), 2); + /// assert_eq!(d.remove(0), 3); + /// assert_eq!(d.remove(0), 1); + /// ``` + #[unstable(feature = "linked_list_remove", issue = "69210")] + pub fn remove(&mut self, at: usize) -> T { + let len = self.len(); + assert!(at < len, "Cannot remove at an index outside of the list bounds"); + + // Below, we iterate towards the node at the given index, either from + // the start or the end, depending on which would be faster. + let offset_from_end = len - at - 1; + if at <= offset_from_end { + let mut cursor = self.cursor_front_mut(); + for _ in 0..at { + cursor.move_next(); + } + cursor.remove_current().unwrap() + } else { + let mut cursor = self.cursor_back_mut(); + for _ in 0..offset_from_end { + cursor.move_prev(); + } + cursor.remove_current().unwrap() + } + } + + /// Creates an iterator which uses a closure to determine if an element should be removed. + /// + /// If the closure returns true, then the element is removed and yielded. + /// If the closure returns false, the element will remain in the list and will not be yielded + /// by the iterator. + /// + /// Note that `drain_filter` lets you mutate every element in the filter closure, regardless of + /// whether you choose to keep or remove it. + /// + /// # Examples + /// + /// Splitting a list into evens and odds, reusing the original list: + /// + /// ``` + /// #![feature(drain_filter)] + /// use std::collections::LinkedList; + /// + /// let mut numbers: LinkedList = LinkedList::new(); + /// numbers.extend(&[1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15]); + /// + /// let evens = numbers.drain_filter(|x| *x % 2 == 0).collect::>(); + /// let odds = numbers; + /// + /// assert_eq!(evens.into_iter().collect::>(), vec![2, 4, 6, 8, 14]); + /// assert_eq!(odds.into_iter().collect::>(), vec![1, 3, 5, 9, 11, 13, 15]); + /// ``` + #[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] + pub fn drain_filter(&mut self, filter: F) -> DrainFilter<'_, T, F> + where + F: FnMut(&mut T) -> bool, + { + // avoid borrow issues. + let it = self.head; + let old_len = self.len; + + DrainFilter { list: self, it, pred: filter, idx: 0, old_len } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl<#[may_dangle] T> Drop for LinkedList { + fn drop(&mut self) { + struct DropGuard<'a, T>(&'a mut LinkedList); + + impl<'a, T> Drop for DropGuard<'a, T> { + fn drop(&mut self) { + // Continue the same loop we do below. This only runs when a destructor has + // panicked. If another one panics this will abort. + while self.0.pop_front_node().is_some() {} + } + } + + while let Some(node) = self.pop_front_node() { + let guard = DropGuard(self); + drop(node); + mem::forget(guard); + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> Iterator for Iter<'a, T> { + type Item = &'a T; + + #[inline] + fn next(&mut self) -> Option<&'a T> { + if self.len == 0 { + None + } else { + self.head.map(|node| unsafe { + // Need an unbound lifetime to get 'a + let node = &*node.as_ptr(); + self.len -= 1; + self.head = node.next; + &node.element + }) + } + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + (self.len, Some(self.len)) + } + + #[inline] + fn last(mut self) -> Option<&'a T> { + self.next_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> DoubleEndedIterator for Iter<'a, T> { + #[inline] + fn next_back(&mut self) -> Option<&'a T> { + if self.len == 0 { + None + } else { + self.tail.map(|node| unsafe { + // Need an unbound lifetime to get 'a + let node = &*node.as_ptr(); + self.len -= 1; + self.tail = node.prev; + &node.element + }) + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for Iter<'_, T> {} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Iter<'_, T> {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> Iterator for IterMut<'a, T> { + type Item = &'a mut T; + + #[inline] + fn next(&mut self) -> Option<&'a mut T> { + if self.len == 0 { + None + } else { + self.head.map(|node| unsafe { + // Need an unbound lifetime to get 'a + let node = &mut *node.as_ptr(); + self.len -= 1; + self.head = node.next; + &mut node.element + }) + } + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + (self.len, Some(self.len)) + } + + #[inline] + fn last(mut self) -> Option<&'a mut T> { + self.next_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> DoubleEndedIterator for IterMut<'a, T> { + #[inline] + fn next_back(&mut self) -> Option<&'a mut T> { + if self.len == 0 { + None + } else { + self.tail.map(|node| unsafe { + // Need an unbound lifetime to get 'a + let node = &mut *node.as_ptr(); + self.len -= 1; + self.tail = node.prev; + &mut node.element + }) + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for IterMut<'_, T> {} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for IterMut<'_, T> {} + +impl IterMut<'_, T> { + /// Inserts the given element just after the element most recently returned by `.next()`. + /// The inserted element does not appear in the iteration. + /// + /// This method will be removed soon. + #[inline] + #[unstable( + feature = "linked_list_extras", + reason = "this is probably better handled by a cursor type -- we'll see", + issue = "27794" + )] + #[rustc_deprecated( + reason = "Deprecated in favor of CursorMut methods. This method will be removed soon.", + since = "1.47.0" + )] + pub fn insert_next(&mut self, element: T) { + match self.head { + // `push_back` is okay with aliasing `element` references + None => self.list.push_back(element), + Some(head) => unsafe { + let prev = match head.as_ref().prev { + // `push_front` is okay with aliasing nodes + None => return self.list.push_front(element), + Some(prev) => prev, + }; + + let node = Some( + Box::leak(box Node { next: Some(head), prev: Some(prev), element }).into(), + ); + + // Not creating references to entire nodes to not invalidate the + // reference to `element` we handed to the user. + (*prev.as_ptr()).next = node; + (*head.as_ptr()).prev = node; + + self.list.len += 1; + }, + } + } + + /// Provides a reference to the next element, without changing the iterator. + /// + /// This method will be removed soon. + #[inline] + #[unstable( + feature = "linked_list_extras", + reason = "this is probably better handled by a cursor type -- we'll see", + issue = "27794" + )] + #[rustc_deprecated( + reason = "Deprecated in favor of CursorMut methods. This method will be removed soon.", + since = "1.47.0" + )] + pub fn peek_next(&mut self) -> Option<&mut T> { + if self.len == 0 { + None + } else { + unsafe { self.head.as_mut().map(|node| &mut node.as_mut().element) } + } + } +} + +/// A cursor over a `LinkedList`. +/// +/// A `Cursor` is like an iterator, except that it can freely seek back-and-forth. +/// +/// Cursors always rest between two elements in the list, and index in a logically circular way. +/// To accommodate this, there is a "ghost" non-element that yields `None` between the head and +/// tail of the list. +/// +/// When created, cursors start at the front of the list, or the "ghost" non-element if the list is empty. +#[unstable(feature = "linked_list_cursors", issue = "58533")] +pub struct Cursor<'a, T: 'a> { + index: usize, + current: Option>>, + list: &'a LinkedList, +} + +#[unstable(feature = "linked_list_cursors", issue = "58533")] +impl Clone for Cursor<'_, T> { + fn clone(&self) -> Self { + let Cursor { index, current, list } = *self; + Cursor { index, current, list } + } +} + +#[unstable(feature = "linked_list_cursors", issue = "58533")] +impl fmt::Debug for Cursor<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Cursor").field(&self.list).field(&self.index()).finish() + } +} + +/// A cursor over a `LinkedList` with editing operations. +/// +/// A `Cursor` is like an iterator, except that it can freely seek back-and-forth, and can +/// safely mutate the list during iteration. This is because the lifetime of its yielded +/// references is tied to its own lifetime, instead of just the underlying list. This means +/// cursors cannot yield multiple elements at once. +/// +/// Cursors always rest between two elements in the list, and index in a logically circular way. +/// To accommodate this, there is a "ghost" non-element that yields `None` between the head and +/// tail of the list. +#[unstable(feature = "linked_list_cursors", issue = "58533")] +pub struct CursorMut<'a, T: 'a> { + index: usize, + current: Option>>, + list: &'a mut LinkedList, +} + +#[unstable(feature = "linked_list_cursors", issue = "58533")] +impl fmt::Debug for CursorMut<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("CursorMut").field(&self.list).field(&self.index()).finish() + } +} + +impl<'a, T> Cursor<'a, T> { + /// Returns the cursor position index within the `LinkedList`. + /// + /// This returns `None` if the cursor is currently pointing to the + /// "ghost" non-element. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn index(&self) -> Option { + let _ = self.current?; + Some(self.index) + } + + /// Moves the cursor to the next element of the `LinkedList`. + /// + /// If the cursor is pointing to the "ghost" non-element then this will move it to + /// the first element of the `LinkedList`. If it is pointing to the last + /// element of the `LinkedList` then this will move it to the "ghost" non-element. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn move_next(&mut self) { + match self.current.take() { + // We had no current element; the cursor was sitting at the start position + // Next element should be the head of the list + None => { + self.current = self.list.head; + self.index = 0; + } + // We had a previous element, so let's go to its next + Some(current) => unsafe { + self.current = current.as_ref().next; + self.index += 1; + }, + } + } + + /// Moves the cursor to the previous element of the `LinkedList`. + /// + /// If the cursor is pointing to the "ghost" non-element then this will move it to + /// the last element of the `LinkedList`. If it is pointing to the first + /// element of the `LinkedList` then this will move it to the "ghost" non-element. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn move_prev(&mut self) { + match self.current.take() { + // No current. We're at the start of the list. Yield None and jump to the end. + None => { + self.current = self.list.tail; + self.index = self.list.len().checked_sub(1).unwrap_or(0); + } + // Have a prev. Yield it and go to the previous element. + Some(current) => unsafe { + self.current = current.as_ref().prev; + self.index = self.index.checked_sub(1).unwrap_or_else(|| self.list.len()); + }, + } + } + + /// Returns a reference to the element that the cursor is currently + /// pointing to. + /// + /// This returns `None` if the cursor is currently pointing to the + /// "ghost" non-element. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn current(&self) -> Option<&'a T> { + unsafe { self.current.map(|current| &(*current.as_ptr()).element) } + } + + /// Returns a reference to the next element. + /// + /// If the cursor is pointing to the "ghost" non-element then this returns + /// the first element of the `LinkedList`. If it is pointing to the last + /// element of the `LinkedList` then this returns `None`. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn peek_next(&self) -> Option<&'a T> { + unsafe { + let next = match self.current { + None => self.list.head, + Some(current) => current.as_ref().next, + }; + next.map(|next| &(*next.as_ptr()).element) + } + } + + /// Returns a reference to the previous element. + /// + /// If the cursor is pointing to the "ghost" non-element then this returns + /// the last element of the `LinkedList`. If it is pointing to the first + /// element of the `LinkedList` then this returns `None`. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn peek_prev(&self) -> Option<&'a T> { + unsafe { + let prev = match self.current { + None => self.list.tail, + Some(current) => current.as_ref().prev, + }; + prev.map(|prev| &(*prev.as_ptr()).element) + } + } +} + +impl<'a, T> CursorMut<'a, T> { + /// Returns the cursor position index within the `LinkedList`. + /// + /// This returns `None` if the cursor is currently pointing to the + /// "ghost" non-element. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn index(&self) -> Option { + let _ = self.current?; + Some(self.index) + } + + /// Moves the cursor to the next element of the `LinkedList`. + /// + /// If the cursor is pointing to the "ghost" non-element then this will move it to + /// the first element of the `LinkedList`. If it is pointing to the last + /// element of the `LinkedList` then this will move it to the "ghost" non-element. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn move_next(&mut self) { + match self.current.take() { + // We had no current element; the cursor was sitting at the start position + // Next element should be the head of the list + None => { + self.current = self.list.head; + self.index = 0; + } + // We had a previous element, so let's go to its next + Some(current) => unsafe { + self.current = current.as_ref().next; + self.index += 1; + }, + } + } + + /// Moves the cursor to the previous element of the `LinkedList`. + /// + /// If the cursor is pointing to the "ghost" non-element then this will move it to + /// the last element of the `LinkedList`. If it is pointing to the first + /// element of the `LinkedList` then this will move it to the "ghost" non-element. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn move_prev(&mut self) { + match self.current.take() { + // No current. We're at the start of the list. Yield None and jump to the end. + None => { + self.current = self.list.tail; + self.index = self.list.len().checked_sub(1).unwrap_or(0); + } + // Have a prev. Yield it and go to the previous element. + Some(current) => unsafe { + self.current = current.as_ref().prev; + self.index = self.index.checked_sub(1).unwrap_or_else(|| self.list.len()); + }, + } + } + + /// Returns a reference to the element that the cursor is currently + /// pointing to. + /// + /// This returns `None` if the cursor is currently pointing to the + /// "ghost" non-element. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn current(&mut self) -> Option<&mut T> { + unsafe { self.current.map(|current| &mut (*current.as_ptr()).element) } + } + + /// Returns a reference to the next element. + /// + /// If the cursor is pointing to the "ghost" non-element then this returns + /// the first element of the `LinkedList`. If it is pointing to the last + /// element of the `LinkedList` then this returns `None`. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn peek_next(&mut self) -> Option<&mut T> { + unsafe { + let next = match self.current { + None => self.list.head, + Some(current) => current.as_ref().next, + }; + next.map(|next| &mut (*next.as_ptr()).element) + } + } + + /// Returns a reference to the previous element. + /// + /// If the cursor is pointing to the "ghost" non-element then this returns + /// the last element of the `LinkedList`. If it is pointing to the first + /// element of the `LinkedList` then this returns `None`. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn peek_prev(&mut self) -> Option<&mut T> { + unsafe { + let prev = match self.current { + None => self.list.tail, + Some(current) => current.as_ref().prev, + }; + prev.map(|prev| &mut (*prev.as_ptr()).element) + } + } + + /// Returns a read-only cursor pointing to the current element. + /// + /// The lifetime of the returned `Cursor` is bound to that of the + /// `CursorMut`, which means it cannot outlive the `CursorMut` and that the + /// `CursorMut` is frozen for the lifetime of the `Cursor`. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn as_cursor(&self) -> Cursor<'_, T> { + Cursor { list: self.list, current: self.current, index: self.index } + } +} + +// Now the list editing operations + +impl<'a, T> CursorMut<'a, T> { + /// Inserts a new element into the `LinkedList` after the current one. + /// + /// If the cursor is pointing at the "ghost" non-element then the new element is + /// inserted at the front of the `LinkedList`. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn insert_after(&mut self, item: T) { + unsafe { + let spliced_node = Box::leak(Box::new(Node::new(item))).into(); + let node_next = match self.current { + None => self.list.head, + Some(node) => node.as_ref().next, + }; + self.list.splice_nodes(self.current, node_next, spliced_node, spliced_node, 1); + if self.current.is_none() { + // The "ghost" non-element's index has changed. + self.index = self.list.len; + } + } + } + + /// Inserts a new element into the `LinkedList` before the current one. + /// + /// If the cursor is pointing at the "ghost" non-element then the new element is + /// inserted at the end of the `LinkedList`. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn insert_before(&mut self, item: T) { + unsafe { + let spliced_node = Box::leak(Box::new(Node::new(item))).into(); + let node_prev = match self.current { + None => self.list.tail, + Some(node) => node.as_ref().prev, + }; + self.list.splice_nodes(node_prev, self.current, spliced_node, spliced_node, 1); + self.index += 1; + } + } + + /// Removes the current element from the `LinkedList`. + /// + /// The element that was removed is returned, and the cursor is + /// moved to point to the next element in the `LinkedList`. + /// + /// If the cursor is currently pointing to the "ghost" non-element then no element + /// is removed and `None` is returned. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn remove_current(&mut self) -> Option { + let unlinked_node = self.current?; + unsafe { + self.current = unlinked_node.as_ref().next; + self.list.unlink_node(unlinked_node); + let unlinked_node = Box::from_raw(unlinked_node.as_ptr()); + Some(unlinked_node.element) + } + } + + /// Removes the current element from the `LinkedList` without deallocating the list node. + /// + /// The node that was removed is returned as a new `LinkedList` containing only this node. + /// The cursor is moved to point to the next element in the current `LinkedList`. + /// + /// If the cursor is currently pointing to the "ghost" non-element then no element + /// is removed and `None` is returned. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn remove_current_as_list(&mut self) -> Option> { + let mut unlinked_node = self.current?; + unsafe { + self.current = unlinked_node.as_ref().next; + self.list.unlink_node(unlinked_node); + + unlinked_node.as_mut().prev = None; + unlinked_node.as_mut().next = None; + Some(LinkedList { + head: Some(unlinked_node), + tail: Some(unlinked_node), + len: 1, + marker: PhantomData, + }) + } + } + + /// Inserts the elements from the given `LinkedList` after the current one. + /// + /// If the cursor is pointing at the "ghost" non-element then the new elements are + /// inserted at the start of the `LinkedList`. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn splice_after(&mut self, list: LinkedList) { + unsafe { + let (splice_head, splice_tail, splice_len) = match list.detach_all_nodes() { + Some(parts) => parts, + _ => return, + }; + let node_next = match self.current { + None => self.list.head, + Some(node) => node.as_ref().next, + }; + self.list.splice_nodes(self.current, node_next, splice_head, splice_tail, splice_len); + if self.current.is_none() { + // The "ghost" non-element's index has changed. + self.index = self.list.len; + } + } + } + + /// Inserts the elements from the given `LinkedList` before the current one. + /// + /// If the cursor is pointing at the "ghost" non-element then the new elements are + /// inserted at the end of the `LinkedList`. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn splice_before(&mut self, list: LinkedList) { + unsafe { + let (splice_head, splice_tail, splice_len) = match list.detach_all_nodes() { + Some(parts) => parts, + _ => return, + }; + let node_prev = match self.current { + None => self.list.tail, + Some(node) => node.as_ref().prev, + }; + self.list.splice_nodes(node_prev, self.current, splice_head, splice_tail, splice_len); + self.index += splice_len; + } + } + + /// Splits the list into two after the current element. This will return a + /// new list consisting of everything after the cursor, with the original + /// list retaining everything before. + /// + /// If the cursor is pointing at the "ghost" non-element then the entire contents + /// of the `LinkedList` are moved. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn split_after(&mut self) -> LinkedList { + let split_off_idx = if self.index == self.list.len { 0 } else { self.index + 1 }; + if self.index == self.list.len { + // The "ghost" non-element's index has changed to 0. + self.index = 0; + } + unsafe { self.list.split_off_after_node(self.current, split_off_idx) } + } + + /// Splits the list into two before the current element. This will return a + /// new list consisting of everything before the cursor, with the original + /// list retaining everything after. + /// + /// If the cursor is pointing at the "ghost" non-element then the entire contents + /// of the `LinkedList` are moved. + #[unstable(feature = "linked_list_cursors", issue = "58533")] + pub fn split_before(&mut self) -> LinkedList { + let split_off_idx = self.index; + self.index = 0; + unsafe { self.list.split_off_before_node(self.current, split_off_idx) } + } +} + +/// An iterator produced by calling `drain_filter` on LinkedList. +#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] +pub struct DrainFilter<'a, T: 'a, F: 'a> +where + F: FnMut(&mut T) -> bool, +{ + list: &'a mut LinkedList, + it: Option>>, + pred: F, + idx: usize, + old_len: usize, +} + +#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] +impl Iterator for DrainFilter<'_, T, F> +where + F: FnMut(&mut T) -> bool, +{ + type Item = T; + + fn next(&mut self) -> Option { + while let Some(mut node) = self.it { + unsafe { + self.it = node.as_ref().next; + self.idx += 1; + + if (self.pred)(&mut node.as_mut().element) { + // `unlink_node` is okay with aliasing `element` references. + self.list.unlink_node(node); + return Some(Box::from_raw(node.as_ptr()).element); + } + } + } + + None + } + + fn size_hint(&self) -> (usize, Option) { + (0, Some(self.old_len - self.idx)) + } +} + +#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] +impl Drop for DrainFilter<'_, T, F> +where + F: FnMut(&mut T) -> bool, +{ + fn drop(&mut self) { + struct DropGuard<'r, 'a, T, F>(&'r mut DrainFilter<'a, T, F>) + where + F: FnMut(&mut T) -> bool; + + impl<'r, 'a, T, F> Drop for DropGuard<'r, 'a, T, F> + where + F: FnMut(&mut T) -> bool, + { + fn drop(&mut self) { + self.0.for_each(drop); + } + } + + while let Some(item) = self.next() { + let guard = DropGuard(self); + drop(item); + mem::forget(guard); + } + } +} + +#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] +impl fmt::Debug for DrainFilter<'_, T, F> +where + F: FnMut(&mut T) -> bool, +{ + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("DrainFilter").field(&self.list).finish() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Iterator for IntoIter { + type Item = T; + + #[inline] + fn next(&mut self) -> Option { + self.list.pop_front() + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + (self.list.len, Some(self.list.len)) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl DoubleEndedIterator for IntoIter { + #[inline] + fn next_back(&mut self) -> Option { + self.list.pop_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for IntoIter {} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for IntoIter {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl FromIterator for LinkedList { + fn from_iter>(iter: I) -> Self { + let mut list = Self::new(); + list.extend(iter); + list + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl IntoIterator for LinkedList { + type Item = T; + type IntoIter = IntoIter; + + /// Consumes the list into an iterator yielding elements by value. + #[inline] + fn into_iter(self) -> IntoIter { + IntoIter { list: self } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> IntoIterator for &'a LinkedList { + type Item = &'a T; + type IntoIter = Iter<'a, T>; + + fn into_iter(self) -> Iter<'a, T> { + self.iter() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> IntoIterator for &'a mut LinkedList { + type Item = &'a mut T; + type IntoIter = IterMut<'a, T>; + + fn into_iter(self) -> IterMut<'a, T> { + self.iter_mut() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Extend for LinkedList { + fn extend>(&mut self, iter: I) { + >::spec_extend(self, iter); + } + + #[inline] + fn extend_one(&mut self, elem: T) { + self.push_back(elem); + } +} + +impl SpecExtend for LinkedList { + default fn spec_extend(&mut self, iter: I) { + iter.into_iter().for_each(move |elt| self.push_back(elt)); + } +} + +impl SpecExtend> for LinkedList { + fn spec_extend(&mut self, ref mut other: LinkedList) { + self.append(other); + } +} + +#[stable(feature = "extend_ref", since = "1.2.0")] +impl<'a, T: 'a + Copy> Extend<&'a T> for LinkedList { + fn extend>(&mut self, iter: I) { + self.extend(iter.into_iter().cloned()); + } + + #[inline] + fn extend_one(&mut self, &elem: &'a T) { + self.push_back(elem); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialEq for LinkedList { + fn eq(&self, other: &Self) -> bool { + self.len() == other.len() && self.iter().eq(other) + } + + fn ne(&self, other: &Self) -> bool { + self.len() != other.len() || self.iter().ne(other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Eq for LinkedList {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialOrd for LinkedList { + fn partial_cmp(&self, other: &Self) -> Option { + self.iter().partial_cmp(other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Ord for LinkedList { + #[inline] + fn cmp(&self, other: &Self) -> Ordering { + self.iter().cmp(other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for LinkedList { + fn clone(&self) -> Self { + self.iter().cloned().collect() + } + + fn clone_from(&mut self, other: &Self) { + let mut iter_other = other.iter(); + if self.len() > other.len() { + self.split_off(other.len()); + } + for (elem, elem_other) in self.iter_mut().zip(&mut iter_other) { + elem.clone_from(elem_other); + } + if !iter_other.is_empty() { + self.extend(iter_other.cloned()); + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Debug for LinkedList { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self).finish() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Hash for LinkedList { + fn hash(&self, state: &mut H) { + self.len().hash(state); + for elt in self { + elt.hash(state); + } + } +} + +// Ensure that `LinkedList` and its read-only iterators are covariant in their type parameters. +#[allow(dead_code)] +fn assert_covariance() { + fn a<'a>(x: LinkedList<&'static str>) -> LinkedList<&'a str> { + x + } + fn b<'i, 'a>(x: Iter<'i, &'static str>) -> Iter<'i, &'a str> { + x + } + fn c<'a>(x: IntoIter<&'static str>) -> IntoIter<&'a str> { + x + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Send for LinkedList {} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Sync for LinkedList {} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Send for Iter<'_, T> {} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Sync for Iter<'_, T> {} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Send for IterMut<'_, T> {} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Sync for IterMut<'_, T> {} + +#[unstable(feature = "linked_list_cursors", issue = "58533")] +unsafe impl Send for Cursor<'_, T> {} + +#[unstable(feature = "linked_list_cursors", issue = "58533")] +unsafe impl Sync for Cursor<'_, T> {} + +#[unstable(feature = "linked_list_cursors", issue = "58533")] +unsafe impl Send for CursorMut<'_, T> {} + +#[unstable(feature = "linked_list_cursors", issue = "58533")] +unsafe impl Sync for CursorMut<'_, T> {} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/linked_list/tests.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/linked_list/tests.rs new file mode 100644 index 000000000000..ad643a7bdf19 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/linked_list/tests.rs @@ -0,0 +1,430 @@ +use super::*; + +use std::thread; +use std::vec::Vec; + +use rand::{thread_rng, RngCore}; + +fn list_from(v: &[T]) -> LinkedList { + v.iter().cloned().collect() +} + +pub fn check_links(list: &LinkedList) { + unsafe { + let mut len = 0; + let mut last_ptr: Option<&Node> = None; + let mut node_ptr: &Node; + match list.head { + None => { + // tail node should also be None. + assert!(list.tail.is_none()); + assert_eq!(0, list.len); + return; + } + Some(node) => node_ptr = &*node.as_ptr(), + } + loop { + match (last_ptr, node_ptr.prev) { + (None, None) => {} + (None, _) => panic!("prev link for head"), + (Some(p), Some(pptr)) => { + assert_eq!(p as *const Node, pptr.as_ptr() as *const Node); + } + _ => panic!("prev link is none, not good"), + } + match node_ptr.next { + Some(next) => { + last_ptr = Some(node_ptr); + node_ptr = &*next.as_ptr(); + len += 1; + } + None => { + len += 1; + break; + } + } + } + + // verify that the tail node points to the last node. + let tail = list.tail.as_ref().expect("some tail node").as_ref(); + assert_eq!(tail as *const Node, node_ptr as *const Node); + // check that len matches interior links. + assert_eq!(len, list.len); + } +} + +#[test] +fn test_append() { + // Empty to empty + { + let mut m = LinkedList::::new(); + let mut n = LinkedList::new(); + m.append(&mut n); + check_links(&m); + assert_eq!(m.len(), 0); + assert_eq!(n.len(), 0); + } + // Non-empty to empty + { + let mut m = LinkedList::new(); + let mut n = LinkedList::new(); + n.push_back(2); + m.append(&mut n); + check_links(&m); + assert_eq!(m.len(), 1); + assert_eq!(m.pop_back(), Some(2)); + assert_eq!(n.len(), 0); + check_links(&m); + } + // Empty to non-empty + { + let mut m = LinkedList::new(); + let mut n = LinkedList::new(); + m.push_back(2); + m.append(&mut n); + check_links(&m); + assert_eq!(m.len(), 1); + assert_eq!(m.pop_back(), Some(2)); + check_links(&m); + } + + // Non-empty to non-empty + let v = vec![1, 2, 3, 4, 5]; + let u = vec![9, 8, 1, 2, 3, 4, 5]; + let mut m = list_from(&v); + let mut n = list_from(&u); + m.append(&mut n); + check_links(&m); + let mut sum = v; + sum.extend_from_slice(&u); + assert_eq!(sum.len(), m.len()); + for elt in sum { + assert_eq!(m.pop_front(), Some(elt)) + } + assert_eq!(n.len(), 0); + // Let's make sure it's working properly, since we + // did some direct changes to private members. + n.push_back(3); + assert_eq!(n.len(), 1); + assert_eq!(n.pop_front(), Some(3)); + check_links(&n); +} + +#[test] +fn test_clone_from() { + // Short cloned from long + { + let v = vec![1, 2, 3, 4, 5]; + let u = vec![8, 7, 6, 2, 3, 4, 5]; + let mut m = list_from(&v); + let n = list_from(&u); + m.clone_from(&n); + check_links(&m); + assert_eq!(m, n); + for elt in u { + assert_eq!(m.pop_front(), Some(elt)) + } + } + // Long cloned from short + { + let v = vec![1, 2, 3, 4, 5]; + let u = vec![6, 7, 8]; + let mut m = list_from(&v); + let n = list_from(&u); + m.clone_from(&n); + check_links(&m); + assert_eq!(m, n); + for elt in u { + assert_eq!(m.pop_front(), Some(elt)) + } + } + // Two equal length lists + { + let v = vec![1, 2, 3, 4, 5]; + let u = vec![9, 8, 1, 2, 3]; + let mut m = list_from(&v); + let n = list_from(&u); + m.clone_from(&n); + check_links(&m); + assert_eq!(m, n); + for elt in u { + assert_eq!(m.pop_front(), Some(elt)) + } + } +} + +#[test] +#[cfg_attr(target_os = "emscripten", ignore)] +fn test_send() { + let n = list_from(&[1, 2, 3]); + thread::spawn(move || { + check_links(&n); + let a: &[_] = &[&1, &2, &3]; + assert_eq!(a, &*n.iter().collect::>()); + }) + .join() + .ok() + .unwrap(); +} + +#[test] +fn test_fuzz() { + for _ in 0..25 { + fuzz_test(3); + fuzz_test(16); + #[cfg(not(miri))] // Miri is too slow + fuzz_test(189); + } +} + +#[test] +fn test_26021() { + // There was a bug in split_off that failed to null out the RHS's head's prev ptr. + // This caused the RHS's dtor to walk up into the LHS at drop and delete all of + // its nodes. + // + // https://github.com/rust-lang/rust/issues/26021 + let mut v1 = LinkedList::new(); + v1.push_front(1); + v1.push_front(1); + v1.push_front(1); + v1.push_front(1); + let _ = v1.split_off(3); // Dropping this now should not cause laundry consumption + assert_eq!(v1.len(), 3); + + assert_eq!(v1.iter().len(), 3); + assert_eq!(v1.iter().collect::>().len(), 3); +} + +#[test] +fn test_split_off() { + let mut v1 = LinkedList::new(); + v1.push_front(1); + v1.push_front(1); + v1.push_front(1); + v1.push_front(1); + + // test all splits + for ix in 0..1 + v1.len() { + let mut a = v1.clone(); + let b = a.split_off(ix); + check_links(&a); + check_links(&b); + a.extend(b); + assert_eq!(v1, a); + } +} + +fn fuzz_test(sz: i32) { + let mut m: LinkedList<_> = LinkedList::new(); + let mut v = vec![]; + for i in 0..sz { + check_links(&m); + let r: u8 = thread_rng().next_u32() as u8; + match r % 6 { + 0 => { + m.pop_back(); + v.pop(); + } + 1 => { + if !v.is_empty() { + m.pop_front(); + v.remove(0); + } + } + 2 | 4 => { + m.push_front(-i); + v.insert(0, -i); + } + 3 | 5 | _ => { + m.push_back(i); + v.push(i); + } + } + } + + check_links(&m); + + let mut i = 0; + for (a, &b) in m.into_iter().zip(&v) { + i += 1; + assert_eq!(a, b); + } + assert_eq!(i, v.len()); +} + +#[test] +fn drain_filter_test() { + let mut m: LinkedList = LinkedList::new(); + m.extend(&[1, 2, 3, 4, 5, 6]); + let deleted = m.drain_filter(|v| *v < 4).collect::>(); + + check_links(&m); + + assert_eq!(deleted, &[1, 2, 3]); + assert_eq!(m.into_iter().collect::>(), &[4, 5, 6]); +} + +#[test] +fn drain_to_empty_test() { + let mut m: LinkedList = LinkedList::new(); + m.extend(&[1, 2, 3, 4, 5, 6]); + let deleted = m.drain_filter(|_| true).collect::>(); + + check_links(&m); + + assert_eq!(deleted, &[1, 2, 3, 4, 5, 6]); + assert_eq!(m.into_iter().collect::>(), &[]); +} + +#[test] +fn test_cursor_move_peek() { + let mut m: LinkedList = LinkedList::new(); + m.extend(&[1, 2, 3, 4, 5, 6]); + let mut cursor = m.cursor_front(); + assert_eq!(cursor.current(), Some(&1)); + assert_eq!(cursor.peek_next(), Some(&2)); + assert_eq!(cursor.peek_prev(), None); + assert_eq!(cursor.index(), Some(0)); + cursor.move_prev(); + assert_eq!(cursor.current(), None); + assert_eq!(cursor.peek_next(), Some(&1)); + assert_eq!(cursor.peek_prev(), Some(&6)); + assert_eq!(cursor.index(), None); + cursor.move_next(); + cursor.move_next(); + assert_eq!(cursor.current(), Some(&2)); + assert_eq!(cursor.peek_next(), Some(&3)); + assert_eq!(cursor.peek_prev(), Some(&1)); + assert_eq!(cursor.index(), Some(1)); + + let mut cursor = m.cursor_back(); + assert_eq!(cursor.current(), Some(&6)); + assert_eq!(cursor.peek_next(), None); + assert_eq!(cursor.peek_prev(), Some(&5)); + assert_eq!(cursor.index(), Some(5)); + cursor.move_next(); + assert_eq!(cursor.current(), None); + assert_eq!(cursor.peek_next(), Some(&1)); + assert_eq!(cursor.peek_prev(), Some(&6)); + assert_eq!(cursor.index(), None); + cursor.move_prev(); + cursor.move_prev(); + assert_eq!(cursor.current(), Some(&5)); + assert_eq!(cursor.peek_next(), Some(&6)); + assert_eq!(cursor.peek_prev(), Some(&4)); + assert_eq!(cursor.index(), Some(4)); + + let mut m: LinkedList = LinkedList::new(); + m.extend(&[1, 2, 3, 4, 5, 6]); + let mut cursor = m.cursor_front_mut(); + assert_eq!(cursor.current(), Some(&mut 1)); + assert_eq!(cursor.peek_next(), Some(&mut 2)); + assert_eq!(cursor.peek_prev(), None); + assert_eq!(cursor.index(), Some(0)); + cursor.move_prev(); + assert_eq!(cursor.current(), None); + assert_eq!(cursor.peek_next(), Some(&mut 1)); + assert_eq!(cursor.peek_prev(), Some(&mut 6)); + assert_eq!(cursor.index(), None); + cursor.move_next(); + cursor.move_next(); + assert_eq!(cursor.current(), Some(&mut 2)); + assert_eq!(cursor.peek_next(), Some(&mut 3)); + assert_eq!(cursor.peek_prev(), Some(&mut 1)); + assert_eq!(cursor.index(), Some(1)); + let mut cursor2 = cursor.as_cursor(); + assert_eq!(cursor2.current(), Some(&2)); + assert_eq!(cursor2.index(), Some(1)); + cursor2.move_next(); + assert_eq!(cursor2.current(), Some(&3)); + assert_eq!(cursor2.index(), Some(2)); + assert_eq!(cursor.current(), Some(&mut 2)); + assert_eq!(cursor.index(), Some(1)); + + let mut m: LinkedList = LinkedList::new(); + m.extend(&[1, 2, 3, 4, 5, 6]); + let mut cursor = m.cursor_back_mut(); + assert_eq!(cursor.current(), Some(&mut 6)); + assert_eq!(cursor.peek_next(), None); + assert_eq!(cursor.peek_prev(), Some(&mut 5)); + assert_eq!(cursor.index(), Some(5)); + cursor.move_next(); + assert_eq!(cursor.current(), None); + assert_eq!(cursor.peek_next(), Some(&mut 1)); + assert_eq!(cursor.peek_prev(), Some(&mut 6)); + assert_eq!(cursor.index(), None); + cursor.move_prev(); + cursor.move_prev(); + assert_eq!(cursor.current(), Some(&mut 5)); + assert_eq!(cursor.peek_next(), Some(&mut 6)); + assert_eq!(cursor.peek_prev(), Some(&mut 4)); + assert_eq!(cursor.index(), Some(4)); + let mut cursor2 = cursor.as_cursor(); + assert_eq!(cursor2.current(), Some(&5)); + assert_eq!(cursor2.index(), Some(4)); + cursor2.move_prev(); + assert_eq!(cursor2.current(), Some(&4)); + assert_eq!(cursor2.index(), Some(3)); + assert_eq!(cursor.current(), Some(&mut 5)); + assert_eq!(cursor.index(), Some(4)); +} + +#[test] +fn test_cursor_mut_insert() { + let mut m: LinkedList = LinkedList::new(); + m.extend(&[1, 2, 3, 4, 5, 6]); + let mut cursor = m.cursor_front_mut(); + cursor.insert_before(7); + cursor.insert_after(8); + check_links(&m); + assert_eq!(m.iter().cloned().collect::>(), &[7, 1, 8, 2, 3, 4, 5, 6]); + let mut cursor = m.cursor_front_mut(); + cursor.move_prev(); + cursor.insert_before(9); + cursor.insert_after(10); + check_links(&m); + assert_eq!(m.iter().cloned().collect::>(), &[10, 7, 1, 8, 2, 3, 4, 5, 6, 9]); + let mut cursor = m.cursor_front_mut(); + cursor.move_prev(); + assert_eq!(cursor.remove_current(), None); + cursor.move_next(); + cursor.move_next(); + assert_eq!(cursor.remove_current(), Some(7)); + cursor.move_prev(); + cursor.move_prev(); + cursor.move_prev(); + assert_eq!(cursor.remove_current(), Some(9)); + cursor.move_next(); + assert_eq!(cursor.remove_current(), Some(10)); + check_links(&m); + assert_eq!(m.iter().cloned().collect::>(), &[1, 8, 2, 3, 4, 5, 6]); + let mut cursor = m.cursor_front_mut(); + let mut p: LinkedList = LinkedList::new(); + p.extend(&[100, 101, 102, 103]); + let mut q: LinkedList = LinkedList::new(); + q.extend(&[200, 201, 202, 203]); + cursor.splice_after(p); + cursor.splice_before(q); + check_links(&m); + assert_eq!( + m.iter().cloned().collect::>(), + &[200, 201, 202, 203, 1, 100, 101, 102, 103, 8, 2, 3, 4, 5, 6] + ); + let mut cursor = m.cursor_front_mut(); + cursor.move_prev(); + let tmp = cursor.split_before(); + assert_eq!(m.into_iter().collect::>(), &[]); + m = tmp; + let mut cursor = m.cursor_front_mut(); + cursor.move_next(); + cursor.move_next(); + cursor.move_next(); + cursor.move_next(); + cursor.move_next(); + cursor.move_next(); + let tmp = cursor.split_after(); + assert_eq!(tmp.into_iter().collect::>(), &[102, 103, 8, 2, 3, 4, 5, 6]); + check_links(&m); + assert_eq!(m.iter().cloned().collect::>(), &[200, 201, 202, 203, 1, 100, 101]); +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/mod.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/mod.rs new file mode 100644 index 000000000000..c48461b335f6 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/mod.rs @@ -0,0 +1,105 @@ +//! Collection types. + +#![stable(feature = "rust1", since = "1.0.0")] + +use crate::gccrs_core_prelude::*; + +pub mod binary_heap; +mod btree; +pub mod linked_list; +pub mod vec_deque; + +#[stable(feature = "rust1", since = "1.0.0")] +pub mod btree_map { + //! A map based on a B-Tree. + #[stable(feature = "rust1", since = "1.0.0")] + pub use super::btree::map::*; +} + +#[stable(feature = "rust1", since = "1.0.0")] +pub mod btree_set { + //! A set based on a B-Tree. + #[stable(feature = "rust1", since = "1.0.0")] + pub use super::btree::set::*; +} + +#[stable(feature = "rust1", since = "1.0.0")] +#[doc(no_inline)] +pub use binary_heap::BinaryHeap; + +#[stable(feature = "rust1", since = "1.0.0")] +#[doc(no_inline)] +pub use btree_map::BTreeMap; + +#[stable(feature = "rust1", since = "1.0.0")] +#[doc(no_inline)] +pub use btree_set::BTreeSet; + +#[stable(feature = "rust1", since = "1.0.0")] +#[doc(no_inline)] +pub use linked_list::LinkedList; + +#[stable(feature = "rust1", since = "1.0.0")] +#[doc(no_inline)] +pub use vec_deque::VecDeque; + +use crate::alloc::{Layout, LayoutErr}; +use core::fmt::Display; + +/// The error type for `try_reserve` methods. +#[derive(Clone, PartialEq, Eq, Debug)] +#[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] +pub enum TryReserveError { + /// Error due to the computed capacity exceeding the collection's maximum + /// (usually `isize::MAX` bytes). + CapacityOverflow, + + /// The memory allocator returned an error + AllocError { + /// The layout of allocation request that failed + layout: Layout, + + #[doc(hidden)] + #[unstable( + feature = "container_error_extra", + issue = "none", + reason = "\ + Enable exposing the allocator’s custom error value \ + if an associated type is added in the future: \ + https://github.com/rust-lang/wg-allocators/issues/23" + )] + non_exhaustive: (), + }, +} + +#[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] +impl From for TryReserveError { + #[inline] + fn from(_: LayoutErr) -> Self { + TryReserveError::CapacityOverflow + } +} + +#[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] +impl Display for TryReserveError { + fn fmt( + &self, + fmt: &mut core::fmt::Formatter<'_>, + ) -> core::result::Result<(), core::fmt::Error> { + fmt.write_str("memory allocation failed")?; + let reason = match &self { + TryReserveError::CapacityOverflow => { + " because the computed capacity exceeded the collection's maximum" + } + TryReserveError::AllocError { .. } => " because the memory allocator returned a error", + }; + fmt.write_str(reason) + } +} + +/// An intermediate trait for specialization of `Extend`. +#[doc(hidden)] +trait SpecExtend { + /// Extends `self` with the contents of the given iterator. + fn spec_extend(&mut self, iter: I); +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/vec_deque.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/vec_deque.rs new file mode 100644 index 000000000000..05886e4566b4 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/vec_deque.rs @@ -0,0 +1,3350 @@ +//! A double-ended queue implemented with a growable ring buffer. +//! +//! This queue has *O*(1) amortized inserts and removals from both ends of the +//! container. It also has *O*(1) indexing like a vector. The contained elements +//! are not required to be copyable, and the queue will be sendable if the +//! contained type is sendable. + +#![stable(feature = "rust1", since = "1.0.0")] + +use crate::gccrs_core_prelude::*; + +// ignore-tidy-filelength + +use core::array; +use core::cmp::{self, Ordering}; +use core::fmt; +use core::hash::{Hash, Hasher}; +use core::iter::{repeat_with, FromIterator, FusedIterator}; +use core::marker::PhantomData; +use core::mem::{self, replace, ManuallyDrop}; +use core::ops::{Index, IndexMut, Range, RangeBounds, Try}; +use core::ptr::{self, NonNull}; +use core::slice; + +use crate::collections::TryReserveError; +use crate::raw_vec::RawVec; +use crate::vec::Vec; + +#[stable(feature = "drain", since = "1.6.0")] +pub use self::drain::Drain; + +mod drain; + +#[cfg(test)] +mod tests; + +const INITIAL_CAPACITY: usize = 7; // 2^3 - 1 +const MINIMUM_CAPACITY: usize = 1; // 2 - 1 + +const MAXIMUM_ZST_CAPACITY: usize = 1 << (core::mem::size_of::() * 8 - 1); // Largest possible power of two + +/// A double-ended queue implemented with a growable ring buffer. +/// +/// The "default" usage of this type as a queue is to use [`push_back`] to add to +/// the queue, and [`pop_front`] to remove from the queue. [`extend`] and [`append`] +/// push onto the back in this manner, and iterating over `VecDeque` goes front +/// to back. +/// +/// Since `VecDeque` is a ring buffer, its elements are not necessarily contiguous +/// in memory. If you want to access the elements as a single slice, such as for +/// efficient sorting, you can use [`make_contiguous`]. It rotates the `VecDeque` +/// so that its elements do not wrap, and returns a mutable slice to the +/// now-contiguous element sequence. +/// +/// [`push_back`]: VecDeque::push_back +/// [`pop_front`]: VecDeque::pop_front +/// [`extend`]: VecDeque::extend +/// [`append`]: VecDeque::append +/// [`make_contiguous`]: VecDeque::make_contiguous +#[cfg_attr(not(test), rustc_diagnostic_item = "vecdeque_type")] +#[stable(feature = "rust1", since = "1.0.0")] +pub struct VecDeque { + // tail and head are pointers into the buffer. Tail always points + // to the first element that could be read, Head always points + // to where data should be written. + // If tail == head the buffer is empty. The length of the ringbuffer + // is defined as the distance between the two. + tail: usize, + head: usize, + buf: RawVec, +} + +/// PairSlices pairs up equal length slice parts of two deques +/// +/// For example, given deques "A" and "B" with the following division into slices: +/// +/// A: [0 1 2] [3 4 5] +/// B: [a b] [c d e] +/// +/// It produces the following sequence of matching slices: +/// +/// ([0 1], [a b]) +/// (\[2\], \[c\]) +/// ([3 4], [d e]) +/// +/// and the uneven remainder of either A or B is skipped. +struct PairSlices<'a, 'b, T> { + a0: &'a mut [T], + a1: &'a mut [T], + b0: &'b [T], + b1: &'b [T], +} + +impl<'a, 'b, T> PairSlices<'a, 'b, T> { + fn from(to: &'a mut VecDeque, from: &'b VecDeque) -> Self { + let (a0, a1) = to.as_mut_slices(); + let (b0, b1) = from.as_slices(); + PairSlices { a0, a1, b0, b1 } + } + + fn has_remainder(&self) -> bool { + !self.b0.is_empty() + } + + fn remainder(self) -> impl Iterator { + array::IntoIter::new([self.b0, self.b1]) + } +} + +impl<'a, 'b, T> Iterator for PairSlices<'a, 'b, T> { + type Item = (&'a mut [T], &'b [T]); + fn next(&mut self) -> Option { + // Get next part length + let part = cmp::min(self.a0.len(), self.b0.len()); + if part == 0 { + return None; + } + let (p0, p1) = replace(&mut self.a0, &mut []).split_at_mut(part); + let (q0, q1) = self.b0.split_at(part); + + // Move a1 into a0, if it's empty (and b1, b0 the same way). + self.a0 = p1; + self.b0 = q1; + if self.a0.is_empty() { + self.a0 = replace(&mut self.a1, &mut []); + } + if self.b0.is_empty() { + self.b0 = replace(&mut self.b1, &[]); + } + Some((p0, q0)) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for VecDeque { + fn clone(&self) -> VecDeque { + self.iter().cloned().collect() + } + + fn clone_from(&mut self, other: &Self) { + self.truncate(other.len()); + + let mut iter = PairSlices::from(self, other); + while let Some((dst, src)) = iter.next() { + dst.clone_from_slice(&src); + } + + if iter.has_remainder() { + for remainder in iter.remainder() { + self.extend(remainder.iter().cloned()); + } + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl<#[may_dangle] T> Drop for VecDeque { + fn drop(&mut self) { + /// Runs the destructor for all items in the slice when it gets dropped (normally or + /// during unwinding). + struct Dropper<'a, T>(&'a mut [T]); + + impl<'a, T> Drop for Dropper<'a, T> { + fn drop(&mut self) { + unsafe { + ptr::drop_in_place(self.0); + } + } + } + + let (front, back) = self.as_mut_slices(); + unsafe { + let _back_dropper = Dropper(back); + // use drop for [T] + ptr::drop_in_place(front); + } + // RawVec handles deallocation + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for VecDeque { + /// Creates an empty `VecDeque`. + #[inline] + fn default() -> VecDeque { + VecDeque::new() + } +} + +impl VecDeque { + /// Marginally more convenient + #[inline] + fn ptr(&self) -> *mut T { + self.buf.ptr() + } + + /// Marginally more convenient + #[inline] + fn cap(&self) -> usize { + if mem::size_of::() == 0 { + // For zero sized types, we are always at maximum capacity + MAXIMUM_ZST_CAPACITY + } else { + self.buf.capacity() + } + } + + /// Turn ptr into a slice + #[inline] + unsafe fn buffer_as_slice(&self) -> &[T] { + unsafe { slice::from_raw_parts(self.ptr(), self.cap()) } + } + + /// Turn ptr into a mut slice + #[inline] + unsafe fn buffer_as_mut_slice(&mut self) -> &mut [T] { + unsafe { slice::from_raw_parts_mut(self.ptr(), self.cap()) } + } + + /// Moves an element out of the buffer + #[inline] + unsafe fn buffer_read(&mut self, off: usize) -> T { + unsafe { ptr::read(self.ptr().add(off)) } + } + + /// Writes an element into the buffer, moving it. + #[inline] + unsafe fn buffer_write(&mut self, off: usize, value: T) { + unsafe { + ptr::write(self.ptr().add(off), value); + } + } + + /// Returns `true` if the buffer is at full capacity. + #[inline] + fn is_full(&self) -> bool { + self.cap() - self.len() == 1 + } + + /// Returns the index in the underlying buffer for a given logical element + /// index. + #[inline] + fn wrap_index(&self, idx: usize) -> usize { + wrap_index(idx, self.cap()) + } + + /// Returns the index in the underlying buffer for a given logical element + /// index + addend. + #[inline] + fn wrap_add(&self, idx: usize, addend: usize) -> usize { + wrap_index(idx.wrapping_add(addend), self.cap()) + } + + /// Returns the index in the underlying buffer for a given logical element + /// index - subtrahend. + #[inline] + fn wrap_sub(&self, idx: usize, subtrahend: usize) -> usize { + wrap_index(idx.wrapping_sub(subtrahend), self.cap()) + } + + /// Copies a contiguous block of memory len long from src to dst + #[inline] + unsafe fn copy(&self, dst: usize, src: usize, len: usize) { + debug_assert!( + dst + len <= self.cap(), + "cpy dst={} src={} len={} cap={}", + dst, + src, + len, + self.cap() + ); + debug_assert!( + src + len <= self.cap(), + "cpy dst={} src={} len={} cap={}", + dst, + src, + len, + self.cap() + ); + unsafe { + ptr::copy(self.ptr().add(src), self.ptr().add(dst), len); + } + } + + /// Copies a contiguous block of memory len long from src to dst + #[inline] + unsafe fn copy_nonoverlapping(&self, dst: usize, src: usize, len: usize) { + debug_assert!( + dst + len <= self.cap(), + "cno dst={} src={} len={} cap={}", + dst, + src, + len, + self.cap() + ); + debug_assert!( + src + len <= self.cap(), + "cno dst={} src={} len={} cap={}", + dst, + src, + len, + self.cap() + ); + unsafe { + ptr::copy_nonoverlapping(self.ptr().add(src), self.ptr().add(dst), len); + } + } + + /// Copies a potentially wrapping block of memory len long from src to dest. + /// (abs(dst - src) + len) must be no larger than cap() (There must be at + /// most one continuous overlapping region between src and dest). + unsafe fn wrap_copy(&self, dst: usize, src: usize, len: usize) { + #[allow(dead_code)] + fn diff(a: usize, b: usize) -> usize { + if a <= b { + b - a + } else { + a - b + } + } + debug_assert!( + cmp::min(diff(dst, src), self.cap() - diff(dst, src)) + len <= self.cap(), + "wrc dst={} src={} len={} cap={}", + dst, + src, + len, + self.cap() + ); + + if src == dst || len == 0 { + return; + } + + let dst_after_src = self.wrap_sub(dst, src) < len; + + let src_pre_wrap_len = self.cap() - src; + let dst_pre_wrap_len = self.cap() - dst; + let src_wraps = src_pre_wrap_len < len; + let dst_wraps = dst_pre_wrap_len < len; + + match (dst_after_src, src_wraps, dst_wraps) { + (_, false, false) => { + // src doesn't wrap, dst doesn't wrap + // + // S . . . + // 1 [_ _ A A B B C C _] + // 2 [_ _ A A A A B B _] + // D . . . + // + unsafe { + self.copy(dst, src, len); + } + } + (false, false, true) => { + // dst before src, src doesn't wrap, dst wraps + // + // S . . . + // 1 [A A B B _ _ _ C C] + // 2 [A A B B _ _ _ A A] + // 3 [B B B B _ _ _ A A] + // . . D . + // + unsafe { + self.copy(dst, src, dst_pre_wrap_len); + self.copy(0, src + dst_pre_wrap_len, len - dst_pre_wrap_len); + } + } + (true, false, true) => { + // src before dst, src doesn't wrap, dst wraps + // + // S . . . + // 1 [C C _ _ _ A A B B] + // 2 [B B _ _ _ A A B B] + // 3 [B B _ _ _ A A A A] + // . . D . + // + unsafe { + self.copy(0, src + dst_pre_wrap_len, len - dst_pre_wrap_len); + self.copy(dst, src, dst_pre_wrap_len); + } + } + (false, true, false) => { + // dst before src, src wraps, dst doesn't wrap + // + // . . S . + // 1 [C C _ _ _ A A B B] + // 2 [C C _ _ _ B B B B] + // 3 [C C _ _ _ B B C C] + // D . . . + // + unsafe { + self.copy(dst, src, src_pre_wrap_len); + self.copy(dst + src_pre_wrap_len, 0, len - src_pre_wrap_len); + } + } + (true, true, false) => { + // src before dst, src wraps, dst doesn't wrap + // + // . . S . + // 1 [A A B B _ _ _ C C] + // 2 [A A A A _ _ _ C C] + // 3 [C C A A _ _ _ C C] + // D . . . + // + unsafe { + self.copy(dst + src_pre_wrap_len, 0, len - src_pre_wrap_len); + self.copy(dst, src, src_pre_wrap_len); + } + } + (false, true, true) => { + // dst before src, src wraps, dst wraps + // + // . . . S . + // 1 [A B C D _ E F G H] + // 2 [A B C D _ E G H H] + // 3 [A B C D _ E G H A] + // 4 [B C C D _ E G H A] + // . . D . . + // + debug_assert!(dst_pre_wrap_len > src_pre_wrap_len); + let delta = dst_pre_wrap_len - src_pre_wrap_len; + unsafe { + self.copy(dst, src, src_pre_wrap_len); + self.copy(dst + src_pre_wrap_len, 0, delta); + self.copy(0, delta, len - dst_pre_wrap_len); + } + } + (true, true, true) => { + // src before dst, src wraps, dst wraps + // + // . . S . . + // 1 [A B C D _ E F G H] + // 2 [A A B D _ E F G H] + // 3 [H A B D _ E F G H] + // 4 [H A B D _ E F F G] + // . . . D . + // + debug_assert!(src_pre_wrap_len > dst_pre_wrap_len); + let delta = src_pre_wrap_len - dst_pre_wrap_len; + unsafe { + self.copy(delta, 0, len - src_pre_wrap_len); + self.copy(0, self.cap() - delta, delta); + self.copy(dst, src, dst_pre_wrap_len); + } + } + } + } + + /// Frobs the head and tail sections around to handle the fact that we + /// just reallocated. Unsafe because it trusts old_capacity. + #[inline] + unsafe fn handle_capacity_increase(&mut self, old_capacity: usize) { + let new_capacity = self.cap(); + + // Move the shortest contiguous section of the ring buffer + // T H + // [o o o o o o o . ] + // T H + // A [o o o o o o o . . . . . . . . . ] + // H T + // [o o . o o o o o ] + // T H + // B [. . . o o o o o o o . . . . . . ] + // H T + // [o o o o o . o o ] + // H T + // C [o o o o o . . . . . . . . . o o ] + + if self.tail <= self.head { + // A + // Nop + } else if self.head < old_capacity - self.tail { + // B + unsafe { + self.copy_nonoverlapping(old_capacity, 0, self.head); + } + self.head += old_capacity; + debug_assert!(self.head > self.tail); + } else { + // C + let new_tail = new_capacity - (old_capacity - self.tail); + unsafe { + self.copy_nonoverlapping(new_tail, self.tail, old_capacity - self.tail); + } + self.tail = new_tail; + debug_assert!(self.head < self.tail); + } + debug_assert!(self.head < self.cap()); + debug_assert!(self.tail < self.cap()); + debug_assert!(self.cap().count_ones() == 1); + } +} + +impl VecDeque { + /// Creates an empty `VecDeque`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let vector: VecDeque = VecDeque::new(); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn new() -> VecDeque { + VecDeque::with_capacity(INITIAL_CAPACITY) + } + + /// Creates an empty `VecDeque` with space for at least `capacity` elements. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let vector: VecDeque = VecDeque::with_capacity(10); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn with_capacity(capacity: usize) -> VecDeque { + // +1 since the ringbuffer always leaves one space empty + let cap = cmp::max(capacity + 1, MINIMUM_CAPACITY + 1).next_power_of_two(); + assert!(cap > capacity, "capacity overflow"); + + VecDeque { + tail: 0, + head: 0, + buf: RawVec::with_capacity(cap), + } + } + + /// Provides a reference to the element at the given index. + /// + /// Element at index 0 is the front of the queue. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(3); + /// buf.push_back(4); + /// buf.push_back(5); + /// assert_eq!(buf.get(1), Some(&4)); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn get(&self, index: usize) -> Option<&T> { + if index < self.len() { + let idx = self.wrap_add(self.tail, index); + unsafe { Some(&*self.ptr().add(idx)) } + } else { + None + } + } + + /// Provides a mutable reference to the element at the given index. + /// + /// Element at index 0 is the front of the queue. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(3); + /// buf.push_back(4); + /// buf.push_back(5); + /// if let Some(elem) = buf.get_mut(1) { + /// *elem = 7; + /// } + /// + /// assert_eq!(buf[1], 7); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn get_mut(&mut self, index: usize) -> Option<&mut T> { + if index < self.len() { + let idx = self.wrap_add(self.tail, index); + unsafe { Some(&mut *self.ptr().add(idx)) } + } else { + None + } + } + + /// Swaps elements at indices `i` and `j`. + /// + /// `i` and `j` may be equal. + /// + /// Element at index 0 is the front of the queue. + /// + /// # Panics + /// + /// Panics if either index is out of bounds. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(3); + /// buf.push_back(4); + /// buf.push_back(5); + /// assert_eq!(buf, [3, 4, 5]); + /// buf.swap(0, 2); + /// assert_eq!(buf, [5, 4, 3]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn swap(&mut self, i: usize, j: usize) { + assert!(i < self.len()); + assert!(j < self.len()); + let ri = self.wrap_add(self.tail, i); + let rj = self.wrap_add(self.tail, j); + unsafe { ptr::swap(self.ptr().add(ri), self.ptr().add(rj)) } + } + + /// Returns the number of elements the `VecDeque` can hold without + /// reallocating. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let buf: VecDeque = VecDeque::with_capacity(10); + /// assert!(buf.capacity() >= 10); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn capacity(&self) -> usize { + self.cap() - 1 + } + + /// Reserves the minimum capacity for exactly `additional` more elements to be inserted in the + /// given `VecDeque`. Does nothing if the capacity is already sufficient. + /// + /// Note that the allocator may give the collection more space than it requests. Therefore + /// capacity can not be relied upon to be precisely minimal. Prefer [`reserve`] if future + /// insertions are expected. + /// + /// # Panics + /// + /// Panics if the new capacity overflows `usize`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf: VecDeque = vec![1].into_iter().collect(); + /// buf.reserve_exact(10); + /// assert!(buf.capacity() >= 11); + /// ``` + /// + /// [`reserve`]: VecDeque::reserve + #[stable(feature = "rust1", since = "1.0.0")] + pub fn reserve_exact(&mut self, additional: usize) { + self.reserve(additional); + } + + /// Reserves capacity for at least `additional` more elements to be inserted in the given + /// `VecDeque`. The collection may reserve more space to avoid frequent reallocations. + /// + /// # Panics + /// + /// Panics if the new capacity overflows `usize`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf: VecDeque = vec![1].into_iter().collect(); + /// buf.reserve(10); + /// assert!(buf.capacity() >= 11); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn reserve(&mut self, additional: usize) { + let old_cap = self.cap(); + let used_cap = self.len() + 1; + let new_cap = used_cap + .checked_add(additional) + .and_then(|needed_cap| needed_cap.checked_next_power_of_two()) + .expect("capacity overflow"); + + if new_cap > old_cap { + self.buf.reserve_exact(used_cap, new_cap - used_cap); + unsafe { + self.handle_capacity_increase(old_cap); + } + } + } + + /// Tries to reserve the minimum capacity for exactly `additional` more elements to + /// be inserted in the given `VecDeque`. After calling `try_reserve_exact`, + /// capacity will be greater than or equal to `self.len() + additional`. + /// Does nothing if the capacity is already sufficient. + /// + /// Note that the allocator may give the collection more space than it + /// requests. Therefore, capacity can not be relied upon to be precisely + /// minimal. Prefer `reserve` if future insertions are expected. + /// + /// # Errors + /// + /// If the capacity overflows `usize`, or the allocator reports a failure, then an error + /// is returned. + /// + /// # Examples + /// + /// ``` + /// #![feature(try_reserve)] + /// use std::collections::TryReserveError; + /// use std::collections::VecDeque; + /// + /// fn process_data(data: &[u32]) -> Result, TryReserveError> { + /// let mut output = VecDeque::new(); + /// + /// // Pre-reserve the memory, exiting if we can't + /// output.try_reserve_exact(data.len())?; + /// + /// // Now we know this can't OOM(Out-Of-Memory) in the middle of our complex work + /// output.extend(data.iter().map(|&val| { + /// val * 2 + 5 // very complicated + /// })); + /// + /// Ok(output) + /// } + /// # process_data(&[1, 2, 3]).expect("why is the test harness OOMing on 12 bytes?"); + /// ``` + #[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] + pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveError> { + self.try_reserve(additional) + } + + /// Tries to reserve capacity for at least `additional` more elements to be inserted + /// in the given `VecDeque`. The collection may reserve more space to avoid + /// frequent reallocations. After calling `try_reserve`, capacity will be + /// greater than or equal to `self.len() + additional`. Does nothing if + /// capacity is already sufficient. + /// + /// # Errors + /// + /// If the capacity overflows `usize`, or the allocator reports a failure, then an error + /// is returned. + /// + /// # Examples + /// + /// ``` + /// #![feature(try_reserve)] + /// use std::collections::TryReserveError; + /// use std::collections::VecDeque; + /// + /// fn process_data(data: &[u32]) -> Result, TryReserveError> { + /// let mut output = VecDeque::new(); + /// + /// // Pre-reserve the memory, exiting if we can't + /// output.try_reserve(data.len())?; + /// + /// // Now we know this can't OOM in the middle of our complex work + /// output.extend(data.iter().map(|&val| { + /// val * 2 + 5 // very complicated + /// })); + /// + /// Ok(output) + /// } + /// # process_data(&[1, 2, 3]).expect("why is the test harness OOMing on 12 bytes?"); + /// ``` + #[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] + pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> { + let old_cap = self.cap(); + let used_cap = self.len() + 1; + let new_cap = used_cap + .checked_add(additional) + .and_then(|needed_cap| needed_cap.checked_next_power_of_two()) + .ok_or(TryReserveError::CapacityOverflow)?; + + if new_cap > old_cap { + self.buf.try_reserve_exact(used_cap, new_cap - used_cap)?; + unsafe { + self.handle_capacity_increase(old_cap); + } + } + Ok(()) + } + + /// Shrinks the capacity of the `VecDeque` as much as possible. + /// + /// It will drop down as close as possible to the length but the allocator may still inform the + /// `VecDeque` that there is space for a few more elements. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::with_capacity(15); + /// buf.extend(0..4); + /// assert_eq!(buf.capacity(), 15); + /// buf.shrink_to_fit(); + /// assert!(buf.capacity() >= 4); + /// ``` + #[stable(feature = "deque_extras_15", since = "1.5.0")] + pub fn shrink_to_fit(&mut self) { + self.shrink_to(0); + } + + /// Shrinks the capacity of the `VecDeque` with a lower bound. + /// + /// The capacity will remain at least as large as both the length + /// and the supplied value. + /// + /// Panics if the current capacity is smaller than the supplied + /// minimum capacity. + /// + /// # Examples + /// + /// ``` + /// #![feature(shrink_to)] + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::with_capacity(15); + /// buf.extend(0..4); + /// assert_eq!(buf.capacity(), 15); + /// buf.shrink_to(6); + /// assert!(buf.capacity() >= 6); + /// buf.shrink_to(0); + /// assert!(buf.capacity() >= 4); + /// ``` + #[unstable(feature = "shrink_to", reason = "new API", issue = "56431")] + pub fn shrink_to(&mut self, min_capacity: usize) { + assert!( + self.capacity() >= min_capacity, + "Tried to shrink to a larger capacity" + ); + + // +1 since the ringbuffer always leaves one space empty + // len + 1 can't overflow for an existing, well-formed ringbuffer. + let target_cap = cmp::max(cmp::max(min_capacity, self.len()) + 1, MINIMUM_CAPACITY + 1) + .next_power_of_two(); + + if target_cap < self.cap() { + // There are three cases of interest: + // All elements are out of desired bounds + // Elements are contiguous, and head is out of desired bounds + // Elements are discontiguous, and tail is out of desired bounds + // + // At all other times, element positions are unaffected. + // + // Indicates that elements at the head should be moved. + let head_outside = self.head == 0 || self.head >= target_cap; + // Move elements from out of desired bounds (positions after target_cap) + if self.tail >= target_cap && head_outside { + // T H + // [. . . . . . . . o o o o o o o . ] + // T H + // [o o o o o o o . ] + unsafe { + self.copy_nonoverlapping(0, self.tail, self.len()); + } + self.head = self.len(); + self.tail = 0; + } else if self.tail != 0 && self.tail < target_cap && head_outside { + // T H + // [. . . o o o o o o o . . . . . . ] + // H T + // [o o . o o o o o ] + let len = self.wrap_sub(self.head, target_cap); + unsafe { + self.copy_nonoverlapping(0, target_cap, len); + } + self.head = len; + debug_assert!(self.head < self.tail); + } else if self.tail >= target_cap { + // H T + // [o o o o o . . . . . . . . . o o ] + // H T + // [o o o o o . o o ] + debug_assert!(self.wrap_sub(self.head, 1) < target_cap); + let len = self.cap() - self.tail; + let new_tail = target_cap - len; + unsafe { + self.copy_nonoverlapping(new_tail, self.tail, len); + } + self.tail = new_tail; + debug_assert!(self.head < self.tail); + } + + self.buf.shrink_to_fit(target_cap); + + debug_assert!(self.head < self.cap()); + debug_assert!(self.tail < self.cap()); + debug_assert!(self.cap().count_ones() == 1); + } + } + + /// Shortens the `VecDeque`, keeping the first `len` elements and dropping + /// the rest. + /// + /// If `len` is greater than the `VecDeque`'s current length, this has no + /// effect. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(5); + /// buf.push_back(10); + /// buf.push_back(15); + /// assert_eq!(buf, [5, 10, 15]); + /// buf.truncate(1); + /// assert_eq!(buf, [5]); + /// ``` + #[stable(feature = "deque_extras", since = "1.16.0")] + pub fn truncate(&mut self, len: usize) { + /// Runs the destructor for all items in the slice when it gets dropped (normally or + /// during unwinding). + struct Dropper<'a, T>(&'a mut [T]); + + impl<'a, T> Drop for Dropper<'a, T> { + fn drop(&mut self) { + unsafe { + ptr::drop_in_place(self.0); + } + } + } + + // Safe because: + // + // * Any slice passed to `drop_in_place` is valid; the second case has + // `len <= front.len()` and returning on `len > self.len()` ensures + // `begin <= back.len()` in the first case + // * The head of the VecDeque is moved before calling `drop_in_place`, + // so no value is dropped twice if `drop_in_place` panics + unsafe { + if len > self.len() { + return; + } + let num_dropped = self.len() - len; + let (front, back) = self.as_mut_slices(); + if len > front.len() { + let begin = len - front.len(); + let drop_back = back.get_unchecked_mut(begin..) as *mut _; + self.head = self.wrap_sub(self.head, num_dropped); + ptr::drop_in_place(drop_back); + } else { + let drop_back = back as *mut _; + let drop_front = front.get_unchecked_mut(len..) as *mut _; + self.head = self.wrap_sub(self.head, num_dropped); + + // Make sure the second half is dropped even when a destructor + // in the first one panics. + let _back_dropper = Dropper(&mut *drop_back); + ptr::drop_in_place(drop_front); + } + } + } + + /// Returns a front-to-back iterator. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(5); + /// buf.push_back(3); + /// buf.push_back(4); + /// let b: &[_] = &[&5, &3, &4]; + /// let c: Vec<&i32> = buf.iter().collect(); + /// assert_eq!(&c[..], b); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn iter(&self) -> Iter<'_, T> { + Iter { + tail: self.tail, + head: self.head, + ring: unsafe { self.buffer_as_slice() }, + } + } + + /// Returns a front-to-back iterator that returns mutable references. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(5); + /// buf.push_back(3); + /// buf.push_back(4); + /// for num in buf.iter_mut() { + /// *num = *num - 2; + /// } + /// let b: &[_] = &[&mut 3, &mut 1, &mut 2]; + /// assert_eq!(&buf.iter_mut().collect::>()[..], b); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn iter_mut(&mut self) -> IterMut<'_, T> { + // SAFETY: The internal `IterMut` safety invariant is established because the + // `ring` we create is a dereferencable slice for lifetime '_. + IterMut { + tail: self.tail, + head: self.head, + ring: ptr::slice_from_raw_parts_mut(self.ptr(), self.cap()), + phantom: PhantomData, + } + } + + /// Returns a pair of slices which contain, in order, the contents of the + /// `VecDeque`. + /// + /// If [`make_contiguous`] was previously called, all elements of the + /// `VecDeque` will be in the first slice and the second slice will be empty. + /// + /// [`make_contiguous`]: VecDeque::make_contiguous + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut vector = VecDeque::new(); + /// + /// vector.push_back(0); + /// vector.push_back(1); + /// vector.push_back(2); + /// + /// assert_eq!(vector.as_slices(), (&[0, 1, 2][..], &[][..])); + /// + /// vector.push_front(10); + /// vector.push_front(9); + /// + /// assert_eq!(vector.as_slices(), (&[9, 10][..], &[0, 1, 2][..])); + /// ``` + #[inline] + #[stable(feature = "deque_extras_15", since = "1.5.0")] + pub fn as_slices(&self) -> (&[T], &[T]) { + unsafe { + let buf = self.buffer_as_slice(); + RingSlices::ring_slices(buf, self.head, self.tail) + } + } + + /// Returns a pair of slices which contain, in order, the contents of the + /// `VecDeque`. + /// + /// If [`make_contiguous`] was previously called, all elements of the + /// `VecDeque` will be in the first slice and the second slice will be empty. + /// + /// [`make_contiguous`]: VecDeque::make_contiguous + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut vector = VecDeque::new(); + /// + /// vector.push_back(0); + /// vector.push_back(1); + /// + /// vector.push_front(10); + /// vector.push_front(9); + /// + /// vector.as_mut_slices().0[0] = 42; + /// vector.as_mut_slices().1[0] = 24; + /// assert_eq!(vector.as_slices(), (&[42, 10][..], &[24, 1][..])); + /// ``` + #[inline] + #[stable(feature = "deque_extras_15", since = "1.5.0")] + pub fn as_mut_slices(&mut self) -> (&mut [T], &mut [T]) { + unsafe { + let head = self.head; + let tail = self.tail; + let buf = self.buffer_as_mut_slice(); + RingSlices::ring_slices(buf, head, tail) + } + } + + /// Returns the number of elements in the `VecDeque`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut v = VecDeque::new(); + /// assert_eq!(v.len(), 0); + /// v.push_back(1); + /// assert_eq!(v.len(), 1); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn len(&self) -> usize { + count(self.tail, self.head, self.cap()) + } + + /// Returns `true` if the `VecDeque` is empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut v = VecDeque::new(); + /// assert!(v.is_empty()); + /// v.push_front(1); + /// assert!(!v.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn is_empty(&self) -> bool { + self.tail == self.head + } + + fn range_tail_head(&self, range: R) -> (usize, usize) + where + R: RangeBounds, + { + let Range { start, end } = range.assert_len(self.len()); + let tail = self.wrap_add(self.tail, start); + let head = self.wrap_add(self.tail, end); + (tail, head) + } + + /// Creates an iterator that covers the specified range in the `VecDeque`. + /// + /// # Panics + /// + /// Panics if the starting point is greater than the end point or if + /// the end point is greater than the length of the vector. + /// + /// # Examples + /// + /// ``` + /// #![feature(deque_range)] + /// + /// use std::collections::VecDeque; + /// + /// let v: VecDeque<_> = vec![1, 2, 3].into_iter().collect(); + /// let range = v.range(2..).copied().collect::>(); + /// assert_eq!(range, [3]); + /// + /// // A full range covers all contents + /// let all = v.range(..); + /// assert_eq!(all.len(), 3); + /// ``` + #[inline] + #[unstable(feature = "deque_range", issue = "74217")] + pub fn range(&self, range: R) -> Iter<'_, T> + where + R: RangeBounds, + { + let (tail, head) = self.range_tail_head(range); + Iter { + tail, + head, + // The shared reference we have in &self is maintained in the '_ of Iter. + ring: unsafe { self.buffer_as_slice() }, + } + } + + /// Creates an iterator that covers the specified mutable range in the `VecDeque`. + /// + /// # Panics + /// + /// Panics if the starting point is greater than the end point or if + /// the end point is greater than the length of the vector. + /// + /// # Examples + /// + /// ``` + /// #![feature(deque_range)] + /// + /// use std::collections::VecDeque; + /// + /// let mut v: VecDeque<_> = vec![1, 2, 3].into_iter().collect(); + /// for v in v.range_mut(2..) { + /// *v *= 2; + /// } + /// assert_eq!(v, vec![1, 2, 6]); + /// + /// // A full range covers all contents + /// for v in v.range_mut(..) { + /// *v *= 2; + /// } + /// assert_eq!(v, vec![2, 4, 12]); + /// ``` + #[inline] + #[unstable(feature = "deque_range", issue = "74217")] + pub fn range_mut(&mut self, range: R) -> IterMut<'_, T> + where + R: RangeBounds, + { + let (tail, head) = self.range_tail_head(range); + + // SAFETY: The internal `IterMut` safety invariant is established because the + // `ring` we create is a dereferencable slice for lifetime '_. + IterMut { + tail, + head, + ring: ptr::slice_from_raw_parts_mut(self.ptr(), self.cap()), + phantom: PhantomData, + } + } + + /// Creates a draining iterator that removes the specified range in the + /// `VecDeque` and yields the removed items. + /// + /// Note 1: The element range is removed even if the iterator is not + /// consumed until the end. + /// + /// Note 2: It is unspecified how many elements are removed from the deque, + /// if the `Drain` value is not dropped, but the borrow it holds expires + /// (e.g., due to `mem::forget`). + /// + /// # Panics + /// + /// Panics if the starting point is greater than the end point or if + /// the end point is greater than the length of the vector. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut v: VecDeque<_> = vec![1, 2, 3].into_iter().collect(); + /// let drained = v.drain(2..).collect::>(); + /// assert_eq!(drained, [3]); + /// assert_eq!(v, [1, 2]); + /// + /// // A full range clears all contents + /// v.drain(..); + /// assert!(v.is_empty()); + /// ``` + #[inline] + #[stable(feature = "drain", since = "1.6.0")] + pub fn drain(&mut self, range: R) -> Drain<'_, T> + where + R: RangeBounds, + { + // Memory safety + // + // When the Drain is first created, the source deque is shortened to + // make sure no uninitialized or moved-from elements are accessible at + // all if the Drain's destructor never gets to run. + // + // Drain will ptr::read out the values to remove. + // When finished, the remaining data will be copied back to cover the hole, + // and the head/tail values will be restored correctly. + // + let (drain_tail, drain_head) = self.range_tail_head(range); + + // The deque's elements are parted into three segments: + // * self.tail -> drain_tail + // * drain_tail -> drain_head + // * drain_head -> self.head + // + // T = self.tail; H = self.head; t = drain_tail; h = drain_head + // + // We store drain_tail as self.head, and drain_head and self.head as + // after_tail and after_head respectively on the Drain. This also + // truncates the effective array such that if the Drain is leaked, we + // have forgotten about the potentially moved values after the start of + // the drain. + // + // T t h H + // [. . . o o x x o o . . .] + // + let head = self.head; + + // "forget" about the values after the start of the drain until after + // the drain is complete and the Drain destructor is run. + self.head = drain_tail; + + Drain { + deque: NonNull::from(&mut *self), + after_tail: drain_head, + after_head: head, + iter: Iter { + tail: drain_tail, + head: drain_head, + // Crucially, we only create shared references from `self` here and read from + // it. We do not write to `self` nor reborrow to a mutable reference. + // Hence the raw pointer we created above, for `deque`, remains valid. + ring: unsafe { self.buffer_as_slice() }, + }, + } + } + + /// Clears the `VecDeque`, removing all values. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut v = VecDeque::new(); + /// v.push_back(1); + /// v.clear(); + /// assert!(v.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn clear(&mut self) { + self.truncate(0); + } + + /// Returns `true` if the `VecDeque` contains an element equal to the + /// given value. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut vector: VecDeque = VecDeque::new(); + /// + /// vector.push_back(0); + /// vector.push_back(1); + /// + /// assert_eq!(vector.contains(&1), true); + /// assert_eq!(vector.contains(&10), false); + /// ``` + #[stable(feature = "vec_deque_contains", since = "1.12.0")] + pub fn contains(&self, x: &T) -> bool + where + T: PartialEq, + { + let (a, b) = self.as_slices(); + a.contains(x) || b.contains(x) + } + + /// Provides a reference to the front element, or `None` if the `VecDeque` is + /// empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut d = VecDeque::new(); + /// assert_eq!(d.front(), None); + /// + /// d.push_back(1); + /// d.push_back(2); + /// assert_eq!(d.front(), Some(&1)); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn front(&self) -> Option<&T> { + if !self.is_empty() { + Some(&self[0]) + } else { + None + } + } + + /// Provides a mutable reference to the front element, or `None` if the + /// `VecDeque` is empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut d = VecDeque::new(); + /// assert_eq!(d.front_mut(), None); + /// + /// d.push_back(1); + /// d.push_back(2); + /// match d.front_mut() { + /// Some(x) => *x = 9, + /// None => (), + /// } + /// assert_eq!(d.front(), Some(&9)); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn front_mut(&mut self) -> Option<&mut T> { + if !self.is_empty() { + Some(&mut self[0]) + } else { + None + } + } + + /// Provides a reference to the back element, or `None` if the `VecDeque` is + /// empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut d = VecDeque::new(); + /// assert_eq!(d.back(), None); + /// + /// d.push_back(1); + /// d.push_back(2); + /// assert_eq!(d.back(), Some(&2)); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn back(&self) -> Option<&T> { + if !self.is_empty() { + Some(&self[self.len() - 1]) + } else { + None + } + } + + /// Provides a mutable reference to the back element, or `None` if the + /// `VecDeque` is empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut d = VecDeque::new(); + /// assert_eq!(d.back(), None); + /// + /// d.push_back(1); + /// d.push_back(2); + /// match d.back_mut() { + /// Some(x) => *x = 9, + /// None => (), + /// } + /// assert_eq!(d.back(), Some(&9)); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn back_mut(&mut self) -> Option<&mut T> { + let len = self.len(); + if !self.is_empty() { + Some(&mut self[len - 1]) + } else { + None + } + } + + /// Removes the first element and returns it, or `None` if the `VecDeque` is + /// empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut d = VecDeque::new(); + /// d.push_back(1); + /// d.push_back(2); + /// + /// assert_eq!(d.pop_front(), Some(1)); + /// assert_eq!(d.pop_front(), Some(2)); + /// assert_eq!(d.pop_front(), None); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn pop_front(&mut self) -> Option { + if self.is_empty() { + None + } else { + let tail = self.tail; + self.tail = self.wrap_add(self.tail, 1); + unsafe { Some(self.buffer_read(tail)) } + } + } + + /// Removes the last element from the `VecDeque` and returns it, or `None` if + /// it is empty. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// assert_eq!(buf.pop_back(), None); + /// buf.push_back(1); + /// buf.push_back(3); + /// assert_eq!(buf.pop_back(), Some(3)); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn pop_back(&mut self) -> Option { + if self.is_empty() { + None + } else { + self.head = self.wrap_sub(self.head, 1); + let head = self.head; + unsafe { Some(self.buffer_read(head)) } + } + } + + /// Prepends an element to the `VecDeque`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut d = VecDeque::new(); + /// d.push_front(1); + /// d.push_front(2); + /// assert_eq!(d.front(), Some(&2)); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn push_front(&mut self, value: T) { + if self.is_full() { + self.grow(); + } + + self.tail = self.wrap_sub(self.tail, 1); + let tail = self.tail; + unsafe { + self.buffer_write(tail, value); + } + } + + /// Appends an element to the back of the `VecDeque`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(1); + /// buf.push_back(3); + /// assert_eq!(3, *buf.back().unwrap()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn push_back(&mut self, value: T) { + if self.is_full() { + self.grow(); + } + + let head = self.head; + self.head = self.wrap_add(self.head, 1); + unsafe { self.buffer_write(head, value) } + } + + #[inline] + fn is_contiguous(&self) -> bool { + // FIXME: Should we consider `head == 0` to mean + // that `self` is contiguous? + self.tail <= self.head + } + + /// Removes an element from anywhere in the `VecDeque` and returns it, + /// replacing it with the first element. + /// + /// This does not preserve ordering, but is *O*(1). + /// + /// Returns `None` if `index` is out of bounds. + /// + /// Element at index 0 is the front of the queue. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// assert_eq!(buf.swap_remove_front(0), None); + /// buf.push_back(1); + /// buf.push_back(2); + /// buf.push_back(3); + /// assert_eq!(buf, [1, 2, 3]); + /// + /// assert_eq!(buf.swap_remove_front(2), Some(3)); + /// assert_eq!(buf, [2, 1]); + /// ``` + #[stable(feature = "deque_extras_15", since = "1.5.0")] + pub fn swap_remove_front(&mut self, index: usize) -> Option { + let length = self.len(); + if length > 0 && index < length && index != 0 { + self.swap(index, 0); + } else if index >= length { + return None; + } + self.pop_front() + } + + /// Removes an element from anywhere in the `VecDeque` and returns it, replacing it with the + /// last element. + /// + /// This does not preserve ordering, but is *O*(1). + /// + /// Returns `None` if `index` is out of bounds. + /// + /// Element at index 0 is the front of the queue. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// assert_eq!(buf.swap_remove_back(0), None); + /// buf.push_back(1); + /// buf.push_back(2); + /// buf.push_back(3); + /// assert_eq!(buf, [1, 2, 3]); + /// + /// assert_eq!(buf.swap_remove_back(0), Some(1)); + /// assert_eq!(buf, [3, 2]); + /// ``` + #[stable(feature = "deque_extras_15", since = "1.5.0")] + pub fn swap_remove_back(&mut self, index: usize) -> Option { + let length = self.len(); + if length > 0 && index < length - 1 { + self.swap(index, length - 1); + } else if index >= length { + return None; + } + self.pop_back() + } + + /// Inserts an element at `index` within the `VecDeque`, shifting all elements with indices + /// greater than or equal to `index` towards the back. + /// + /// Element at index 0 is the front of the queue. + /// + /// # Panics + /// + /// Panics if `index` is greater than `VecDeque`'s length + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut vec_deque = VecDeque::new(); + /// vec_deque.push_back('a'); + /// vec_deque.push_back('b'); + /// vec_deque.push_back('c'); + /// assert_eq!(vec_deque, &['a', 'b', 'c']); + /// + /// vec_deque.insert(1, 'd'); + /// assert_eq!(vec_deque, &['a', 'd', 'b', 'c']); + /// ``` + #[stable(feature = "deque_extras_15", since = "1.5.0")] + pub fn insert(&mut self, index: usize, value: T) { + assert!(index <= self.len(), "index out of bounds"); + if self.is_full() { + self.grow(); + } + + // Move the least number of elements in the ring buffer and insert + // the given object + // + // At most len/2 - 1 elements will be moved. O(min(n, n-i)) + // + // There are three main cases: + // Elements are contiguous + // - special case when tail is 0 + // Elements are discontiguous and the insert is in the tail section + // Elements are discontiguous and the insert is in the head section + // + // For each of those there are two more cases: + // Insert is closer to tail + // Insert is closer to head + // + // Key: H - self.head + // T - self.tail + // o - Valid element + // I - Insertion element + // A - The element that should be after the insertion point + // M - Indicates element was moved + + let idx = self.wrap_add(self.tail, index); + + let distance_to_tail = index; + let distance_to_head = self.len() - index; + + let contiguous = self.is_contiguous(); + + match ( + contiguous, + distance_to_tail <= distance_to_head, + idx >= self.tail, + ) { + (true, true, _) if index == 0 => { + // push_front + // + // T + // I H + // [A o o o o o o . . . . . . . . .] + // + // H T + // [A o o o o o o o . . . . . I] + // + + self.tail = self.wrap_sub(self.tail, 1); + } + (true, true, _) => { + unsafe { + // contiguous, insert closer to tail: + // + // T I H + // [. . . o o A o o o o . . . . . .] + // + // T H + // [. . o o I A o o o o . . . . . .] + // M M + // + // contiguous, insert closer to tail and tail is 0: + // + // + // T I H + // [o o A o o o o . . . . . . . . .] + // + // H T + // [o I A o o o o o . . . . . . . o] + // M M + + let new_tail = self.wrap_sub(self.tail, 1); + + self.copy(new_tail, self.tail, 1); + // Already moved the tail, so we only copy `index - 1` elements. + self.copy(self.tail, self.tail + 1, index - 1); + + self.tail = new_tail; + } + } + (true, false, _) => { + unsafe { + // contiguous, insert closer to head: + // + // T I H + // [. . . o o o o A o o . . . . . .] + // + // T H + // [. . . o o o o I A o o . . . . .] + // M M M + + self.copy(idx + 1, idx, self.head - idx); + self.head = self.wrap_add(self.head, 1); + } + } + (false, true, true) => { + unsafe { + // discontiguous, insert closer to tail, tail section: + // + // H T I + // [o o o o o o . . . . . o o A o o] + // + // H T + // [o o o o o o . . . . o o I A o o] + // M M + + self.copy(self.tail - 1, self.tail, index); + self.tail -= 1; + } + } + (false, false, true) => { + unsafe { + // discontiguous, insert closer to head, tail section: + // + // H T I + // [o o . . . . . . . o o o o o A o] + // + // H T + // [o o o . . . . . . o o o o o I A] + // M M M M + + // copy elements up to new head + self.copy(1, 0, self.head); + + // copy last element into empty spot at bottom of buffer + self.copy(0, self.cap() - 1, 1); + + // move elements from idx to end forward not including ^ element + self.copy(idx + 1, idx, self.cap() - 1 - idx); + + self.head += 1; + } + } + (false, true, false) if idx == 0 => { + unsafe { + // discontiguous, insert is closer to tail, head section, + // and is at index zero in the internal buffer: + // + // I H T + // [A o o o o o o o o o . . . o o o] + // + // H T + // [A o o o o o o o o o . . o o o I] + // M M M + + // copy elements up to new tail + self.copy(self.tail - 1, self.tail, self.cap() - self.tail); + + // copy last element into empty spot at bottom of buffer + self.copy(self.cap() - 1, 0, 1); + + self.tail -= 1; + } + } + (false, true, false) => { + unsafe { + // discontiguous, insert closer to tail, head section: + // + // I H T + // [o o o A o o o o o o . . . o o o] + // + // H T + // [o o I A o o o o o o . . o o o o] + // M M M M M M + + // copy elements up to new tail + self.copy(self.tail - 1, self.tail, self.cap() - self.tail); + + // copy last element into empty spot at bottom of buffer + self.copy(self.cap() - 1, 0, 1); + + // move elements from idx-1 to end forward not including ^ element + self.copy(0, 1, idx - 1); + + self.tail -= 1; + } + } + (false, false, false) => { + unsafe { + // discontiguous, insert closer to head, head section: + // + // I H T + // [o o o o A o o . . . . . . o o o] + // + // H T + // [o o o o I A o o . . . . . o o o] + // M M M + + self.copy(idx + 1, idx, self.head - idx); + self.head += 1; + } + } + } + + // tail might've been changed so we need to recalculate + let new_idx = self.wrap_add(self.tail, index); + unsafe { + self.buffer_write(new_idx, value); + } + } + + /// Removes and returns the element at `index` from the `VecDeque`. + /// Whichever end is closer to the removal point will be moved to make + /// room, and all the affected elements will be moved to new positions. + /// Returns `None` if `index` is out of bounds. + /// + /// Element at index 0 is the front of the queue. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(1); + /// buf.push_back(2); + /// buf.push_back(3); + /// assert_eq!(buf, [1, 2, 3]); + /// + /// assert_eq!(buf.remove(1), Some(2)); + /// assert_eq!(buf, [1, 3]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn remove(&mut self, index: usize) -> Option { + if self.is_empty() || self.len() <= index { + return None; + } + + // There are three main cases: + // Elements are contiguous + // Elements are discontiguous and the removal is in the tail section + // Elements are discontiguous and the removal is in the head section + // - special case when elements are technically contiguous, + // but self.head = 0 + // + // For each of those there are two more cases: + // Insert is closer to tail + // Insert is closer to head + // + // Key: H - self.head + // T - self.tail + // o - Valid element + // x - Element marked for removal + // R - Indicates element that is being removed + // M - Indicates element was moved + + let idx = self.wrap_add(self.tail, index); + + let elem = unsafe { Some(self.buffer_read(idx)) }; + + let distance_to_tail = index; + let distance_to_head = self.len() - index; + + let contiguous = self.is_contiguous(); + + match ( + contiguous, + distance_to_tail <= distance_to_head, + idx >= self.tail, + ) { + (true, true, _) => { + unsafe { + // contiguous, remove closer to tail: + // + // T R H + // [. . . o o x o o o o . . . . . .] + // + // T H + // [. . . . o o o o o o . . . . . .] + // M M + + self.copy(self.tail + 1, self.tail, index); + self.tail += 1; + } + } + (true, false, _) => { + unsafe { + // contiguous, remove closer to head: + // + // T R H + // [. . . o o o o x o o . . . . . .] + // + // T H + // [. . . o o o o o o . . . . . . .] + // M M + + self.copy(idx, idx + 1, self.head - idx - 1); + self.head -= 1; + } + } + (false, true, true) => { + unsafe { + // discontiguous, remove closer to tail, tail section: + // + // H T R + // [o o o o o o . . . . . o o x o o] + // + // H T + // [o o o o o o . . . . . . o o o o] + // M M + + self.copy(self.tail + 1, self.tail, index); + self.tail = self.wrap_add(self.tail, 1); + } + } + (false, false, false) => { + unsafe { + // discontiguous, remove closer to head, head section: + // + // R H T + // [o o o o x o o . . . . . . o o o] + // + // H T + // [o o o o o o . . . . . . . o o o] + // M M + + self.copy(idx, idx + 1, self.head - idx - 1); + self.head -= 1; + } + } + (false, false, true) => { + unsafe { + // discontiguous, remove closer to head, tail section: + // + // H T R + // [o o o . . . . . . o o o o o x o] + // + // H T + // [o o . . . . . . . o o o o o o o] + // M M M M + // + // or quasi-discontiguous, remove next to head, tail section: + // + // H T R + // [. . . . . . . . . o o o o o x o] + // + // T H + // [. . . . . . . . . o o o o o o .] + // M + + // draw in elements in the tail section + self.copy(idx, idx + 1, self.cap() - idx - 1); + + // Prevents underflow. + if self.head != 0 { + // copy first element into empty spot + self.copy(self.cap() - 1, 0, 1); + + // move elements in the head section backwards + self.copy(0, 1, self.head - 1); + } + + self.head = self.wrap_sub(self.head, 1); + } + } + (false, true, false) => { + unsafe { + // discontiguous, remove closer to tail, head section: + // + // R H T + // [o o x o o o o o o o . . . o o o] + // + // H T + // [o o o o o o o o o o . . . . o o] + // M M M M M + + // draw in elements up to idx + self.copy(1, 0, idx); + + // copy last element into empty spot + self.copy(0, self.cap() - 1, 1); + + // move elements from tail to end forward, excluding the last one + self.copy(self.tail + 1, self.tail, self.cap() - self.tail - 1); + + self.tail = self.wrap_add(self.tail, 1); + } + } + } + + elem + } + + /// Splits the `VecDeque` into two at the given index. + /// + /// Returns a newly allocated `VecDeque`. `self` contains elements `[0, at)`, + /// and the returned `VecDeque` contains elements `[at, len)`. + /// + /// Note that the capacity of `self` does not change. + /// + /// Element at index 0 is the front of the queue. + /// + /// # Panics + /// + /// Panics if `at > len`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf: VecDeque<_> = vec![1,2,3].into_iter().collect(); + /// let buf2 = buf.split_off(1); + /// assert_eq!(buf, [1]); + /// assert_eq!(buf2, [2, 3]); + /// ``` + #[inline] + #[must_use = "use `.truncate()` if you don't need the other half"] + #[stable(feature = "split_off", since = "1.4.0")] + pub fn split_off(&mut self, at: usize) -> Self { + let len = self.len(); + assert!(at <= len, "`at` out of bounds"); + + let other_len = len - at; + let mut other = VecDeque::with_capacity(other_len); + + unsafe { + let (first_half, second_half) = self.as_slices(); + + let first_len = first_half.len(); + let second_len = second_half.len(); + if at < first_len { + // `at` lies in the first half. + let amount_in_first = first_len - at; + + ptr::copy_nonoverlapping(first_half.as_ptr().add(at), other.ptr(), amount_in_first); + + // just take all of the second half. + ptr::copy_nonoverlapping( + second_half.as_ptr(), + other.ptr().add(amount_in_first), + second_len, + ); + } else { + // `at` lies in the second half, need to factor in the elements we skipped + // in the first half. + let offset = at - first_len; + let amount_in_second = second_len - offset; + ptr::copy_nonoverlapping( + second_half.as_ptr().add(offset), + other.ptr(), + amount_in_second, + ); + } + } + + // Cleanup where the ends of the buffers are + self.head = self.wrap_sub(self.head, other_len); + other.head = other.wrap_index(other_len); + + other + } + + /// Moves all the elements of `other` into `self`, leaving `other` empty. + /// + /// # Panics + /// + /// Panics if the new number of elements in self overflows a `usize`. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf: VecDeque<_> = vec![1, 2].into_iter().collect(); + /// let mut buf2: VecDeque<_> = vec![3, 4].into_iter().collect(); + /// buf.append(&mut buf2); + /// assert_eq!(buf, [1, 2, 3, 4]); + /// assert_eq!(buf2, []); + /// ``` + #[inline] + #[stable(feature = "append", since = "1.4.0")] + pub fn append(&mut self, other: &mut Self) { + // naive impl + self.extend(other.drain(..)); + } + + /// Retains only the elements specified by the predicate. + /// + /// In other words, remove all elements `e` such that `f(&e)` returns false. + /// This method operates in place, visiting each element exactly once in the + /// original order, and preserves the order of the retained elements. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.extend(1..5); + /// buf.retain(|&x| x % 2 == 0); + /// assert_eq!(buf, [2, 4]); + /// ``` + /// + /// The exact order may be useful for tracking external state, like an index. + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.extend(1..6); + /// + /// let keep = [false, true, true, false, true]; + /// let mut i = 0; + /// buf.retain(|_| (keep[i], i += 1).0); + /// assert_eq!(buf, [2, 3, 5]); + /// ``` + #[stable(feature = "vec_deque_retain", since = "1.4.0")] + pub fn retain(&mut self, mut f: F) + where + F: FnMut(&T) -> bool, + { + let len = self.len(); + let mut del = 0; + for i in 0..len { + if !f(&self[i]) { + del += 1; + } else if del > 0 { + self.swap(i - del, i); + } + } + if del > 0 { + self.truncate(len - del); + } + } + + // This may panic or abort + #[inline(never)] + fn grow(&mut self) { + if self.is_full() { + let old_cap = self.cap(); + // Double the buffer size. + self.buf.reserve_exact(old_cap, old_cap); + assert!(self.cap() == old_cap * 2); + unsafe { + self.handle_capacity_increase(old_cap); + } + debug_assert!(!self.is_full()); + } + } + + /// Modifies the `VecDeque` in-place so that `len()` is equal to `new_len`, + /// either by removing excess elements from the back or by appending + /// elements generated by calling `generator` to the back. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(5); + /// buf.push_back(10); + /// buf.push_back(15); + /// assert_eq!(buf, [5, 10, 15]); + /// + /// buf.resize_with(5, Default::default); + /// assert_eq!(buf, [5, 10, 15, 0, 0]); + /// + /// buf.resize_with(2, || unreachable!()); + /// assert_eq!(buf, [5, 10]); + /// + /// let mut state = 100; + /// buf.resize_with(5, || { state += 1; state }); + /// assert_eq!(buf, [5, 10, 101, 102, 103]); + /// ``` + #[stable(feature = "vec_resize_with", since = "1.33.0")] + pub fn resize_with(&mut self, new_len: usize, generator: impl FnMut() -> T) { + let len = self.len(); + + if new_len > len { + self.extend(repeat_with(generator).take(new_len - len)) + } else { + self.truncate(new_len); + } + } + + /// Rearranges the internal storage of this deque so it is one contiguous + /// slice, which is then returned. + /// + /// This method does not allocate and does not change the order of the + /// inserted elements. As it returns a mutable slice, this can be used to + /// sort a deque. + /// + /// Once the internal storage is contiguous, the [`as_slices`] and + /// [`as_mut_slices`] methods will return the entire contents of the + /// `VecDeque` in a single slice. + /// + /// [`as_slices`]: VecDeque::as_slices + /// [`as_mut_slices`]: VecDeque::as_mut_slices + /// + /// # Examples + /// + /// Sorting the content of a deque. + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::with_capacity(15); + /// + /// buf.push_back(2); + /// buf.push_back(1); + /// buf.push_front(3); + /// + /// // sorting the deque + /// buf.make_contiguous().sort(); + /// assert_eq!(buf.as_slices(), (&[1, 2, 3] as &[_], &[] as &[_])); + /// + /// // sorting it in reverse order + /// buf.make_contiguous().sort_by(|a, b| b.cmp(a)); + /// assert_eq!(buf.as_slices(), (&[3, 2, 1] as &[_], &[] as &[_])); + /// ``` + /// + /// Getting immutable access to the contiguous slice. + /// + /// ```rust + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// + /// buf.push_back(2); + /// buf.push_back(1); + /// buf.push_front(3); + /// + /// buf.make_contiguous(); + /// if let (slice, &[]) = buf.as_slices() { + /// // we can now be sure that `slice` contains all elements of the deque, + /// // while still having immutable access to `buf`. + /// assert_eq!(buf.len(), slice.len()); + /// assert_eq!(slice, &[3, 2, 1] as &[_]); + /// } + /// ``` + #[stable(feature = "deque_make_contiguous", since = "1.48.0")] + pub fn make_contiguous(&mut self) -> &mut [T] { + if self.is_contiguous() { + let tail = self.tail; + let head = self.head; + return unsafe { RingSlices::ring_slices(self.buffer_as_mut_slice(), head, tail).0 }; + } + + let buf = self.buf.ptr(); + let cap = self.cap(); + let len = self.len(); + + let free = self.tail - self.head; + let tail_len = cap - self.tail; + + if free >= tail_len { + // there is enough free space to copy the tail in one go, + // this means that we first shift the head backwards, and then + // copy the tail to the correct position. + // + // from: DEFGH....ABC + // to: ABCDEFGH.... + unsafe { + ptr::copy(buf, buf.add(tail_len), self.head); + // ...DEFGH.ABC + ptr::copy_nonoverlapping(buf.add(self.tail), buf, tail_len); + // ABCDEFGH.... + + self.tail = 0; + self.head = len; + } + } else if free > self.head { + // FIXME: We currently do not consider ....ABCDEFGH + // to be contiguous because `head` would be `0` in this + // case. While we probably want to change this it + // isn't trivial as a few places expect `is_contiguous` + // to mean that we can just slice using `buf[tail..head]`. + + // there is enough free space to copy the head in one go, + // this means that we first shift the tail forwards, and then + // copy the head to the correct position. + // + // from: FGH....ABCDE + // to: ...ABCDEFGH. + unsafe { + ptr::copy(buf.add(self.tail), buf.add(self.head), tail_len); + // FGHABCDE.... + ptr::copy_nonoverlapping(buf, buf.add(self.head + tail_len), self.head); + // ...ABCDEFGH. + + self.tail = self.head; + self.head = self.wrap_add(self.tail, len); + } + } else { + // free is smaller than both head and tail, + // this means we have to slowly "swap" the tail and the head. + // + // from: EFGHI...ABCD or HIJK.ABCDEFG + // to: ABCDEFGHI... or ABCDEFGHIJK. + let mut left_edge: usize = 0; + let mut right_edge: usize = self.tail; + unsafe { + // The general problem looks like this + // GHIJKLM...ABCDEF - before any swaps + // ABCDEFM...GHIJKL - after 1 pass of swaps + // ABCDEFGHIJM...KL - swap until the left edge reaches the temp store + // - then restart the algorithm with a new (smaller) store + // Sometimes the temp store is reached when the right edge is at the end + // of the buffer - this means we've hit the right order with fewer swaps! + // E.g + // EF..ABCD + // ABCDEF.. - after four only swaps we've finished + while left_edge < len && right_edge != cap { + let mut right_offset = 0; + for i in left_edge..right_edge { + right_offset = (i - left_edge) % (cap - right_edge); + let src: isize = (right_edge + right_offset) as isize; + ptr::swap(buf.add(i), buf.offset(src)); + } + let n_ops = right_edge - left_edge; + left_edge += n_ops; + right_edge += right_offset + 1; + } + + self.tail = 0; + self.head = len; + } + } + + let tail = self.tail; + let head = self.head; + unsafe { RingSlices::ring_slices(self.buffer_as_mut_slice(), head, tail).0 } + } + + /// Rotates the double-ended queue `mid` places to the left. + /// + /// Equivalently, + /// - Rotates item `mid` into the first position. + /// - Pops the first `mid` items and pushes them to the end. + /// - Rotates `len() - mid` places to the right. + /// + /// # Panics + /// + /// If `mid` is greater than `len()`. Note that `mid == len()` + /// does _not_ panic and is a no-op rotation. + /// + /// # Complexity + /// + /// Takes `*O*(min(mid, len() - mid))` time and no extra space. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf: VecDeque<_> = (0..10).collect(); + /// + /// buf.rotate_left(3); + /// assert_eq!(buf, [3, 4, 5, 6, 7, 8, 9, 0, 1, 2]); + /// + /// for i in 1..10 { + /// assert_eq!(i * 3 % 10, buf[0]); + /// buf.rotate_left(3); + /// } + /// assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); + /// ``` + #[stable(feature = "vecdeque_rotate", since = "1.36.0")] + pub fn rotate_left(&mut self, mid: usize) { + assert!(mid <= self.len()); + let k = self.len() - mid; + if mid <= k { + unsafe { self.rotate_left_inner(mid) } + } else { + unsafe { self.rotate_right_inner(k) } + } + } + + /// Rotates the double-ended queue `k` places to the right. + /// + /// Equivalently, + /// - Rotates the first item into position `k`. + /// - Pops the last `k` items and pushes them to the front. + /// - Rotates `len() - k` places to the left. + /// + /// # Panics + /// + /// If `k` is greater than `len()`. Note that `k == len()` + /// does _not_ panic and is a no-op rotation. + /// + /// # Complexity + /// + /// Takes `*O*(min(k, len() - k))` time and no extra space. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf: VecDeque<_> = (0..10).collect(); + /// + /// buf.rotate_right(3); + /// assert_eq!(buf, [7, 8, 9, 0, 1, 2, 3, 4, 5, 6]); + /// + /// for i in 1..10 { + /// assert_eq!(0, buf[i * 3 % 10]); + /// buf.rotate_right(3); + /// } + /// assert_eq!(buf, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); + /// ``` + #[stable(feature = "vecdeque_rotate", since = "1.36.0")] + pub fn rotate_right(&mut self, k: usize) { + assert!(k <= self.len()); + let mid = self.len() - k; + if k <= mid { + unsafe { self.rotate_right_inner(k) } + } else { + unsafe { self.rotate_left_inner(mid) } + } + } + + // SAFETY: the following two methods require that the rotation amount + // be less than half the length of the deque. + // + // `wrap_copy` requires that `min(x, cap() - x) + copy_len <= cap()`, + // but than `min` is never more than half the capacity, regardless of x, + // so it's sound to call here because we're calling with something + // less than half the length, which is never above half the capacity. + + unsafe fn rotate_left_inner(&mut self, mid: usize) { + debug_assert!(mid * 2 <= self.len()); + unsafe { + self.wrap_copy(self.head, self.tail, mid); + } + self.head = self.wrap_add(self.head, mid); + self.tail = self.wrap_add(self.tail, mid); + } + + unsafe fn rotate_right_inner(&mut self, k: usize) { + debug_assert!(k * 2 <= self.len()); + self.head = self.wrap_sub(self.head, k); + self.tail = self.wrap_sub(self.tail, k); + unsafe { + self.wrap_copy(self.tail, self.head, k); + } + } + + /// Binary searches this sorted `VecDeque` for a given element. + /// + /// If the value is found then [`Result::Ok`] is returned, containing the + /// index of the matching element. If there are multiple matches, then any + /// one of the matches could be returned. If the value is not found then + /// [`Result::Err`] is returned, containing the index where a matching + /// element could be inserted while maintaining sorted order. + /// + /// # Examples + /// + /// Looks up a series of four elements. The first is found, with a + /// uniquely determined position; the second and third are not + /// found; the fourth could match any position in `[1, 4]`. + /// + /// ``` + /// #![feature(vecdeque_binary_search)] + /// use std::collections::VecDeque; + /// + /// let deque: VecDeque<_> = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55].into(); + /// + /// assert_eq!(deque.binary_search(&13), Ok(9)); + /// assert_eq!(deque.binary_search(&4), Err(7)); + /// assert_eq!(deque.binary_search(&100), Err(13)); + /// let r = deque.binary_search(&1); + /// assert!(matches!(r, Ok(1..=4))); + /// ``` + /// + /// If you want to insert an item to a sorted `VecDeque`, while maintaining + /// sort order: + /// + /// ``` + /// #![feature(vecdeque_binary_search)] + /// use std::collections::VecDeque; + /// + /// let mut deque: VecDeque<_> = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55].into(); + /// let num = 42; + /// let idx = deque.binary_search(&num).unwrap_or_else(|x| x); + /// deque.insert(idx, num); + /// assert_eq!(deque, &[0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]); + /// ``` + #[unstable(feature = "vecdeque_binary_search", issue = "78021")] + #[inline] + pub fn binary_search(&self, x: &T) -> Result + where + T: Ord, + { + self.binary_search_by(|e| e.cmp(x)) + } + + /// Binary searches this sorted `VecDeque` with a comparator function. + /// + /// The comparator function should implement an order consistent + /// with the sort order of the underlying `VecDeque`, returning an + /// order code that indicates whether its argument is `Less`, + /// `Equal` or `Greater` than the desired target. + /// + /// If the value is found then [`Result::Ok`] is returned, containing the + /// index of the matching element. If there are multiple matches, then any + /// one of the matches could be returned. If the value is not found then + /// [`Result::Err`] is returned, containing the index where a matching + /// element could be inserted while maintaining sorted order. + /// + /// # Examples + /// + /// Looks up a series of four elements. The first is found, with a + /// uniquely determined position; the second and third are not + /// found; the fourth could match any position in `[1, 4]`. + /// + /// ``` + /// #![feature(vecdeque_binary_search)] + /// use std::collections::VecDeque; + /// + /// let deque: VecDeque<_> = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55].into(); + /// + /// assert_eq!(deque.binary_search_by(|x| x.cmp(&13)), Ok(9)); + /// assert_eq!(deque.binary_search_by(|x| x.cmp(&4)), Err(7)); + /// assert_eq!(deque.binary_search_by(|x| x.cmp(&100)), Err(13)); + /// let r = deque.binary_search_by(|x| x.cmp(&1)); + /// assert!(matches!(r, Ok(1..=4))); + /// ``` + #[unstable(feature = "vecdeque_binary_search", issue = "78021")] + pub fn binary_search_by<'a, F>(&'a self, mut f: F) -> Result + where + F: FnMut(&'a T) -> Ordering, + { + let (front, back) = self.as_slices(); + + if let Some(Ordering::Less | Ordering::Equal) = back.first().map(|elem| f(elem)) { + back.binary_search_by(f) + .map(|idx| idx + front.len()) + .map_err(|idx| idx + front.len()) + } else { + front.binary_search_by(f) + } + } + + /// Binary searches this sorted `VecDeque` with a key extraction function. + /// + /// Assumes that the `VecDeque` is sorted by the key, for instance with + /// [`make_contiguous().sort_by_key()`](#method.make_contiguous) using the same + /// key extraction function. + /// + /// If the value is found then [`Result::Ok`] is returned, containing the + /// index of the matching element. If there are multiple matches, then any + /// one of the matches could be returned. If the value is not found then + /// [`Result::Err`] is returned, containing the index where a matching + /// element could be inserted while maintaining sorted order. + /// + /// # Examples + /// + /// Looks up a series of four elements in a slice of pairs sorted by + /// their second elements. The first is found, with a uniquely + /// determined position; the second and third are not found; the + /// fourth could match any position in `[1, 4]`. + /// + /// ``` + /// #![feature(vecdeque_binary_search)] + /// use std::collections::VecDeque; + /// + /// let deque: VecDeque<_> = vec![(0, 0), (2, 1), (4, 1), (5, 1), + /// (3, 1), (1, 2), (2, 3), (4, 5), (5, 8), (3, 13), + /// (1, 21), (2, 34), (4, 55)].into(); + /// + /// assert_eq!(deque.binary_search_by_key(&13, |&(a,b)| b), Ok(9)); + /// assert_eq!(deque.binary_search_by_key(&4, |&(a,b)| b), Err(7)); + /// assert_eq!(deque.binary_search_by_key(&100, |&(a,b)| b), Err(13)); + /// let r = deque.binary_search_by_key(&1, |&(a,b)| b); + /// assert!(matches!(r, Ok(1..=4))); + /// ``` + #[unstable(feature = "vecdeque_binary_search", issue = "78021")] + #[inline] + pub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, mut f: F) -> Result + where + F: FnMut(&'a T) -> B, + B: Ord, + { + self.binary_search_by(|k| f(k).cmp(b)) + } +} + +impl VecDeque { + /// Modifies the `VecDeque` in-place so that `len()` is equal to new_len, + /// either by removing excess elements from the back or by appending clones of `value` + /// to the back. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut buf = VecDeque::new(); + /// buf.push_back(5); + /// buf.push_back(10); + /// buf.push_back(15); + /// assert_eq!(buf, [5, 10, 15]); + /// + /// buf.resize(2, 0); + /// assert_eq!(buf, [5, 10]); + /// + /// buf.resize(5, 20); + /// assert_eq!(buf, [5, 10, 20, 20, 20]); + /// ``` + #[stable(feature = "deque_extras", since = "1.16.0")] + pub fn resize(&mut self, new_len: usize, value: T) { + self.resize_with(new_len, || value.clone()); + } +} + +/// Returns the index in the underlying buffer for a given logical element index. +#[inline] +fn wrap_index(index: usize, size: usize) -> usize { + // size is always a power of 2 + debug_assert!(size.is_power_of_two()); + index & (size - 1) +} + +/// Returns the two slices that cover the `VecDeque`'s valid range +trait RingSlices: Sized { + fn slice(self, from: usize, to: usize) -> Self; + fn split_at(self, i: usize) -> (Self, Self); + + fn ring_slices(buf: Self, head: usize, tail: usize) -> (Self, Self) { + let contiguous = tail <= head; + if contiguous { + let (empty, buf) = buf.split_at(0); + (buf.slice(tail, head), empty) + } else { + let (mid, right) = buf.split_at(tail); + let (left, _) = mid.split_at(head); + (right, left) + } + } +} + +impl RingSlices for &[T] { + fn slice(self, from: usize, to: usize) -> Self { + &self[from..to] + } + fn split_at(self, i: usize) -> (Self, Self) { + (*self).split_at(i) + } +} + +impl RingSlices for &mut [T] { + fn slice(self, from: usize, to: usize) -> Self { + &mut self[from..to] + } + fn split_at(self, i: usize) -> (Self, Self) { + (*self).split_at_mut(i) + } +} + +impl RingSlices for *mut [T] { + fn slice(self, from: usize, to: usize) -> Self { + assert!(from <= to && to < self.len()); + // Not using `get_unchecked_mut` to keep this a safe operation. + let len = to - from; + ptr::slice_from_raw_parts_mut(self.as_mut_ptr().wrapping_add(from), len) + } + + fn split_at(self, mid: usize) -> (Self, Self) { + let len = self.len(); + let ptr = self.as_mut_ptr(); + assert!(mid <= len); + ( + ptr::slice_from_raw_parts_mut(ptr, mid), + ptr::slice_from_raw_parts_mut(ptr.wrapping_add(mid), len - mid), + ) + } +} + +/// Calculate the number of elements left to be read in the buffer +#[inline] +fn count(tail: usize, head: usize, size: usize) -> usize { + // size is always a power of 2 + (head.wrapping_sub(tail)) & (size - 1) +} + +/// An iterator over the elements of a `VecDeque`. +/// +/// This `struct` is created by the [`iter`] method on [`VecDeque`]. See its +/// documentation for more. +/// +/// [`iter`]: VecDeque::iter +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Iter<'a, T: 'a> { + ring: &'a [T], + tail: usize, + head: usize, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Iter<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail); + f.debug_tuple("Iter").field(&front).field(&back).finish() + } +} + +// FIXME(#26925) Remove in favor of `#[derive(Clone)]` +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Iter<'_, T> { + fn clone(&self) -> Self { + Iter { + ring: self.ring, + tail: self.tail, + head: self.head, + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> Iterator for Iter<'a, T> { + type Item = &'a T; + + #[inline] + fn next(&mut self) -> Option<&'a T> { + if self.tail == self.head { + return None; + } + let tail = self.tail; + self.tail = wrap_index(self.tail.wrapping_add(1), self.ring.len()); + unsafe { Some(self.ring.get_unchecked(tail)) } + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + let len = count(self.tail, self.head, self.ring.len()); + (len, Some(len)) + } + + fn fold(self, mut accum: Acc, mut f: F) -> Acc + where + F: FnMut(Acc, Self::Item) -> Acc, + { + let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail); + accum = front.iter().fold(accum, &mut f); + back.iter().fold(accum, &mut f) + } + + fn try_fold(&mut self, init: B, mut f: F) -> R + where + Self: Sized, + F: FnMut(B, Self::Item) -> R, + R: Try, + { + let (mut iter, final_res); + if self.tail <= self.head { + // single slice self.ring[self.tail..self.head] + iter = self.ring[self.tail..self.head].iter(); + final_res = iter.try_fold(init, &mut f); + } else { + // two slices: self.ring[self.tail..], self.ring[..self.head] + let (front, back) = self.ring.split_at(self.tail); + let mut back_iter = back.iter(); + let res = back_iter.try_fold(init, &mut f); + let len = self.ring.len(); + self.tail = (self.ring.len() - back_iter.len()) & (len - 1); + iter = front[..self.head].iter(); + final_res = iter.try_fold(res?, &mut f); + } + self.tail = self.head - iter.len(); + final_res + } + + fn nth(&mut self, n: usize) -> Option { + if n >= count(self.tail, self.head, self.ring.len()) { + self.tail = self.head; + None + } else { + self.tail = wrap_index(self.tail.wrapping_add(n), self.ring.len()); + self.next() + } + } + + #[inline] + fn last(mut self) -> Option<&'a T> { + self.next_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> DoubleEndedIterator for Iter<'a, T> { + #[inline] + fn next_back(&mut self) -> Option<&'a T> { + if self.tail == self.head { + return None; + } + self.head = wrap_index(self.head.wrapping_sub(1), self.ring.len()); + unsafe { Some(self.ring.get_unchecked(self.head)) } + } + + fn rfold(self, mut accum: Acc, mut f: F) -> Acc + where + F: FnMut(Acc, Self::Item) -> Acc, + { + let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail); + accum = back.iter().rfold(accum, &mut f); + front.iter().rfold(accum, &mut f) + } + + fn try_rfold(&mut self, init: B, mut f: F) -> R + where + Self: Sized, + F: FnMut(B, Self::Item) -> R, + R: Try, + { + let (mut iter, final_res); + if self.tail <= self.head { + // single slice self.ring[self.tail..self.head] + iter = self.ring[self.tail..self.head].iter(); + final_res = iter.try_rfold(init, &mut f); + } else { + // two slices: self.ring[self.tail..], self.ring[..self.head] + let (front, back) = self.ring.split_at(self.tail); + let mut front_iter = front[..self.head].iter(); + let res = front_iter.try_rfold(init, &mut f); + self.head = front_iter.len(); + iter = back.iter(); + final_res = iter.try_rfold(res?, &mut f); + } + self.head = self.tail + iter.len(); + final_res + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for Iter<'_, T> { + fn is_empty(&self) -> bool { + self.head == self.tail + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Iter<'_, T> {} + +/// A mutable iterator over the elements of a `VecDeque`. +/// +/// This `struct` is created by the [`iter_mut`] method on [`VecDeque`]. See its +/// documentation for more. +/// +/// [`iter_mut`]: VecDeque::iter_mut +#[stable(feature = "rust1", since = "1.0.0")] +pub struct IterMut<'a, T: 'a> { + // Internal safety invariant: the entire slice is dereferencable. + ring: *mut [T], + tail: usize, + head: usize, + phantom: PhantomData<&'a mut [T]>, +} + +// SAFETY: we do nothing thread-local and there is no interior mutability, +// so the usual structural `Send`/`Sync` apply. +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Send for IterMut<'_, T> {} +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Sync for IterMut<'_, T> {} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for IterMut<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail); + // SAFETY: these are the elements we have not handed out yet, so aliasing is fine. + // The `IterMut` invariant also ensures everything is dereferencable. + let (front, back) = unsafe { (&*front, &*back) }; + f.debug_tuple("IterMut").field(&front).field(&back).finish() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> Iterator for IterMut<'a, T> { + type Item = &'a mut T; + + #[inline] + fn next(&mut self) -> Option<&'a mut T> { + if self.tail == self.head { + return None; + } + let tail = self.tail; + self.tail = wrap_index(self.tail.wrapping_add(1), self.ring.len()); + + unsafe { + let elem = self.ring.get_unchecked_mut(tail); + Some(&mut *elem) + } + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + let len = count(self.tail, self.head, self.ring.len()); + (len, Some(len)) + } + + fn fold(self, mut accum: Acc, mut f: F) -> Acc + where + F: FnMut(Acc, Self::Item) -> Acc, + { + let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail); + // SAFETY: these are the elements we have not handed out yet, so aliasing is fine. + // The `IterMut` invariant also ensures everything is dereferencable. + let (front, back) = unsafe { (&mut *front, &mut *back) }; + accum = front.iter_mut().fold(accum, &mut f); + back.iter_mut().fold(accum, &mut f) + } + + fn nth(&mut self, n: usize) -> Option { + if n >= count(self.tail, self.head, self.ring.len()) { + self.tail = self.head; + None + } else { + self.tail = wrap_index(self.tail.wrapping_add(n), self.ring.len()); + self.next() + } + } + + #[inline] + fn last(mut self) -> Option<&'a mut T> { + self.next_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> DoubleEndedIterator for IterMut<'a, T> { + #[inline] + fn next_back(&mut self) -> Option<&'a mut T> { + if self.tail == self.head { + return None; + } + self.head = wrap_index(self.head.wrapping_sub(1), self.ring.len()); + + unsafe { + let elem = self.ring.get_unchecked_mut(self.head); + Some(&mut *elem) + } + } + + fn rfold(self, mut accum: Acc, mut f: F) -> Acc + where + F: FnMut(Acc, Self::Item) -> Acc, + { + let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail); + // SAFETY: these are the elements we have not handed out yet, so aliasing is fine. + // The `IterMut` invariant also ensures everything is dereferencable. + let (front, back) = unsafe { (&mut *front, &mut *back) }; + accum = back.iter_mut().rfold(accum, &mut f); + front.iter_mut().rfold(accum, &mut f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for IterMut<'_, T> { + fn is_empty(&self) -> bool { + self.head == self.tail + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for IterMut<'_, T> {} + +/// An owning iterator over the elements of a `VecDeque`. +/// +/// This `struct` is created by the [`into_iter`] method on [`VecDeque`] +/// (provided by the `IntoIterator` trait). See its documentation for more. +/// +/// [`into_iter`]: VecDeque::into_iter +#[derive(Clone)] +#[stable(feature = "rust1", since = "1.0.0")] +pub struct IntoIter { + inner: VecDeque, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for IntoIter { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("IntoIter").field(&self.inner).finish() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Iterator for IntoIter { + type Item = T; + + #[inline] + fn next(&mut self) -> Option { + self.inner.pop_front() + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + let len = self.inner.len(); + (len, Some(len)) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl DoubleEndedIterator for IntoIter { + #[inline] + fn next_back(&mut self) -> Option { + self.inner.pop_back() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for IntoIter { + fn is_empty(&self) -> bool { + self.inner.is_empty() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for IntoIter {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialEq for VecDeque { + fn eq(&self, other: &VecDeque) -> bool { + if self.len() != other.len() { + return false; + } + let (sa, sb) = self.as_slices(); + let (oa, ob) = other.as_slices(); + if sa.len() == oa.len() { + sa == oa && sb == ob + } else if sa.len() < oa.len() { + // Always divisible in three sections, for example: + // self: [a b c|d e f] + // other: [0 1 2 3|4 5] + // front = 3, mid = 1, + // [a b c] == [0 1 2] && [d] == [3] && [e f] == [4 5] + let front = sa.len(); + let mid = oa.len() - front; + + let (oa_front, oa_mid) = oa.split_at(front); + let (sb_mid, sb_back) = sb.split_at(mid); + debug_assert_eq!(sa.len(), oa_front.len()); + debug_assert_eq!(sb_mid.len(), oa_mid.len()); + debug_assert_eq!(sb_back.len(), ob.len()); + sa == oa_front && sb_mid == oa_mid && sb_back == ob + } else { + let front = oa.len(); + let mid = sa.len() - front; + + let (sa_front, sa_mid) = sa.split_at(front); + let (ob_mid, ob_back) = ob.split_at(mid); + debug_assert_eq!(sa_front.len(), oa.len()); + debug_assert_eq!(sa_mid.len(), ob_mid.len()); + debug_assert_eq!(sb.len(), ob_back.len()); + sa_front == oa && sa_mid == ob_mid && sb == ob_back + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Eq for VecDeque {} + +macro_rules! __impl_slice_eq1 { + ([$($vars:tt)*] $lhs:ty, $rhs:ty, $($constraints:tt)*) => { + #[stable(feature = "vec_deque_partial_eq_slice", since = "1.17.0")] + impl PartialEq<$rhs> for $lhs + where + A: PartialEq, + $($constraints)* + { + fn eq(&self, other: &$rhs) -> bool { + if self.len() != other.len() { + return false; + } + let (sa, sb) = self.as_slices(); + let (oa, ob) = other[..].split_at(sa.len()); + sa == oa && sb == ob + } + } + } +} + +__impl_slice_eq1! { [] VecDeque, Vec, } +__impl_slice_eq1! { [] VecDeque, &[B], } +__impl_slice_eq1! { [] VecDeque, &mut [B], } +__impl_slice_eq1! { [const N: usize] VecDeque, [B; N], } +__impl_slice_eq1! { [const N: usize] VecDeque, &[B; N], } +__impl_slice_eq1! { [const N: usize] VecDeque, &mut [B; N], } + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialOrd for VecDeque { + fn partial_cmp(&self, other: &VecDeque) -> Option { + self.iter().partial_cmp(other.iter()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Ord for VecDeque { + #[inline] + fn cmp(&self, other: &VecDeque) -> Ordering { + self.iter().cmp(other.iter()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Hash for VecDeque { + fn hash(&self, state: &mut H) { + self.len().hash(state); + let (a, b) = self.as_slices(); + Hash::hash_slice(a, state); + Hash::hash_slice(b, state); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Index for VecDeque { + type Output = A; + + #[inline] + fn index(&self, index: usize) -> &A { + self.get(index).expect("Out of bounds access") + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl IndexMut for VecDeque { + #[inline] + fn index_mut(&mut self, index: usize) -> &mut A { + self.get_mut(index).expect("Out of bounds access") + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl FromIterator for VecDeque { + fn from_iter>(iter: T) -> VecDeque { + let iterator = iter.into_iter(); + let (lower, _) = iterator.size_hint(); + let mut deq = VecDeque::with_capacity(lower); + deq.extend(iterator); + deq + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl IntoIterator for VecDeque { + type Item = T; + type IntoIter = IntoIter; + + /// Consumes the `VecDeque` into a front-to-back iterator yielding elements by + /// value. + fn into_iter(self) -> IntoIter { + IntoIter { inner: self } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> IntoIterator for &'a VecDeque { + type Item = &'a T; + type IntoIter = Iter<'a, T>; + + fn into_iter(self) -> Iter<'a, T> { + self.iter() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> IntoIterator for &'a mut VecDeque { + type Item = &'a mut T; + type IntoIter = IterMut<'a, T>; + + fn into_iter(self) -> IterMut<'a, T> { + self.iter_mut() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Extend for VecDeque { + fn extend>(&mut self, iter: T) { + // This function should be the moral equivalent of: + // + // for item in iter.into_iter() { + // self.push_back(item); + // } + let mut iter = iter.into_iter(); + while let Some(element) = iter.next() { + if self.len() == self.capacity() { + let (lower, _) = iter.size_hint(); + self.reserve(lower.saturating_add(1)); + } + + let head = self.head; + self.head = self.wrap_add(self.head, 1); + unsafe { + self.buffer_write(head, element); + } + } + } + + #[inline] + fn extend_one(&mut self, elem: A) { + self.push_back(elem); + } + + #[inline] + fn extend_reserve(&mut self, additional: usize) { + self.reserve(additional); + } +} + +#[stable(feature = "extend_ref", since = "1.2.0")] +impl<'a, T: 'a + Copy> Extend<&'a T> for VecDeque { + fn extend>(&mut self, iter: I) { + self.extend(iter.into_iter().cloned()); + } + + #[inline] + fn extend_one(&mut self, &elem: &T) { + self.push_back(elem); + } + + #[inline] + fn extend_reserve(&mut self, additional: usize) { + self.reserve(additional); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Debug for VecDeque { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_list().entries(self).finish() + } +} + +#[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")] +impl From> for VecDeque { + /// Turn a [`Vec`] into a [`VecDeque`]. + /// + /// [`Vec`]: crate::vec::Vec + /// [`VecDeque`]: crate::collections::VecDeque + /// + /// This avoids reallocating where possible, but the conditions for that are + /// strict, and subject to change, and so shouldn't be relied upon unless the + /// `Vec` came from `From>` and hasn't been reallocated. + fn from(other: Vec) -> Self { + unsafe { + let mut other = ManuallyDrop::new(other); + let other_buf = other.as_mut_ptr(); + let mut buf = RawVec::from_raw_parts(other_buf, other.capacity()); + let len = other.len(); + + // We need to extend the buf if it's not a power of two, too small + // or doesn't have at least one free space + if !buf.capacity().is_power_of_two() + || (buf.capacity() < (MINIMUM_CAPACITY + 1)) + || (buf.capacity() == len) + { + let cap = cmp::max(buf.capacity() + 1, MINIMUM_CAPACITY + 1).next_power_of_two(); + buf.reserve_exact(len, cap - len); + } + + VecDeque { + tail: 0, + head: len, + buf, + } + } + } +} + +#[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")] +impl From> for Vec { + /// Turn a [`VecDeque`] into a [`Vec`]. + /// + /// [`Vec`]: crate::vec::Vec + /// [`VecDeque`]: crate::collections::VecDeque + /// + /// This never needs to re-allocate, but does need to do *O*(*n*) data movement if + /// the circular buffer doesn't happen to be at the beginning of the allocation. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// // This one is *O*(1). + /// let deque: VecDeque<_> = (1..5).collect(); + /// let ptr = deque.as_slices().0.as_ptr(); + /// let vec = Vec::from(deque); + /// assert_eq!(vec, [1, 2, 3, 4]); + /// assert_eq!(vec.as_ptr(), ptr); + /// + /// // This one needs data rearranging. + /// let mut deque: VecDeque<_> = (1..5).collect(); + /// deque.push_front(9); + /// deque.push_front(8); + /// let ptr = deque.as_slices().1.as_ptr(); + /// let vec = Vec::from(deque); + /// assert_eq!(vec, [8, 9, 1, 2, 3, 4]); + /// assert_eq!(vec.as_ptr(), ptr); + /// ``` + fn from(mut other: VecDeque) -> Self { + other.make_contiguous(); + + unsafe { + let other = ManuallyDrop::new(other); + let buf = other.buf.ptr(); + let len = other.len(); + let cap = other.cap(); + + if other.tail != 0 { + ptr::copy(buf.add(other.tail), buf, len); + } + Vec::from_raw_parts(buf, len, cap) + } + } +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/vec_deque/drain.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/vec_deque/drain.rs new file mode 100644 index 000000000000..fcaee34f69c3 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/vec_deque/drain.rs @@ -0,0 +1,127 @@ +use crate::gccrs_core_prelude::*; + +use core::iter::FusedIterator; +use core::ptr::{self, NonNull}; +use core::{fmt, mem}; + +use super::{count, Iter, VecDeque}; + +/// A draining iterator over the elements of a `VecDeque`. +/// +/// This `struct` is created by the [`drain`] method on [`VecDeque`]. See its +/// documentation for more. +/// +/// [`drain`]: VecDeque::drain +#[stable(feature = "drain", since = "1.6.0")] +pub struct Drain<'a, T: 'a> { + pub(crate) after_tail: usize, + pub(crate) after_head: usize, + pub(crate) iter: Iter<'a, T>, + pub(crate) deque: NonNull>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Drain<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Drain") + .field(&self.after_tail) + .field(&self.after_head) + .field(&self.iter) + .finish() + } +} + +#[stable(feature = "drain", since = "1.6.0")] +unsafe impl Sync for Drain<'_, T> {} +#[stable(feature = "drain", since = "1.6.0")] +unsafe impl Send for Drain<'_, T> {} + +#[stable(feature = "drain", since = "1.6.0")] +impl Drop for Drain<'_, T> { + fn drop(&mut self) { + struct DropGuard<'r, 'a, T>(&'r mut Drain<'a, T>); + + impl<'r, 'a, T> Drop for DropGuard<'r, 'a, T> { + fn drop(&mut self) { + self.0.for_each(drop); + + let source_deque = unsafe { self.0.deque.as_mut() }; + + // T = source_deque_tail; H = source_deque_head; t = drain_tail; h = drain_head + // + // T t h H + // [. . . o o x x o o . . .] + // + let orig_tail = source_deque.tail; + let drain_tail = source_deque.head; + let drain_head = self.0.after_tail; + let orig_head = self.0.after_head; + + let tail_len = count(orig_tail, drain_tail, source_deque.cap()); + let head_len = count(drain_head, orig_head, source_deque.cap()); + + // Restore the original head value + source_deque.head = orig_head; + + match (tail_len, head_len) { + (0, 0) => { + source_deque.head = 0; + source_deque.tail = 0; + } + (0, _) => { + source_deque.tail = drain_head; + } + (_, 0) => { + source_deque.head = drain_tail; + } + _ => unsafe { + if tail_len <= head_len { + source_deque.tail = source_deque.wrap_sub(drain_head, tail_len); + source_deque.wrap_copy(source_deque.tail, orig_tail, tail_len); + } else { + source_deque.head = source_deque.wrap_add(drain_tail, head_len); + source_deque.wrap_copy(drain_tail, drain_head, head_len); + } + }, + } + } + } + + while let Some(item) = self.next() { + let guard = DropGuard(self); + drop(item); + mem::forget(guard); + } + + DropGuard(self); + } +} + +#[stable(feature = "drain", since = "1.6.0")] +impl Iterator for Drain<'_, T> { + type Item = T; + + #[inline] + fn next(&mut self) -> Option { + self.iter.next().map(|elt| unsafe { ptr::read(elt) }) + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } +} + +#[stable(feature = "drain", since = "1.6.0")] +impl DoubleEndedIterator for Drain<'_, T> { + #[inline] + fn next_back(&mut self) -> Option { + self.iter.next_back().map(|elt| unsafe { ptr::read(elt) }) + } +} + +#[stable(feature = "drain", since = "1.6.0")] +impl ExactSizeIterator for Drain<'_, T> {} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Drain<'_, T> {} diff --git a/gcc/testsuite/rust/alloc/alloc/src/collections/vec_deque/tests.rs b/gcc/testsuite/rust/alloc/alloc/src/collections/vec_deque/tests.rs new file mode 100644 index 000000000000..21f52af056b2 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/collections/vec_deque/tests.rs @@ -0,0 +1,586 @@ +use super::*; + +#[bench] +#[cfg_attr(miri, ignore)] // isolated Miri does not support benchmarks +fn bench_push_back_100(b: &mut test::Bencher) { + let mut deq = VecDeque::with_capacity(101); + b.iter(|| { + for i in 0..100 { + deq.push_back(i); + } + deq.head = 0; + deq.tail = 0; + }) +} + +#[bench] +#[cfg_attr(miri, ignore)] // isolated Miri does not support benchmarks +fn bench_push_front_100(b: &mut test::Bencher) { + let mut deq = VecDeque::with_capacity(101); + b.iter(|| { + for i in 0..100 { + deq.push_front(i); + } + deq.head = 0; + deq.tail = 0; + }) +} + +#[bench] +#[cfg_attr(miri, ignore)] // isolated Miri does not support benchmarks +fn bench_pop_back_100(b: &mut test::Bencher) { + let mut deq = VecDeque::::with_capacity(101); + + b.iter(|| { + deq.head = 100; + deq.tail = 0; + while !deq.is_empty() { + test::black_box(deq.pop_back()); + } + }) +} + +#[bench] +#[cfg_attr(miri, ignore)] // isolated Miri does not support benchmarks +fn bench_pop_front_100(b: &mut test::Bencher) { + let mut deq = VecDeque::::with_capacity(101); + + b.iter(|| { + deq.head = 100; + deq.tail = 0; + while !deq.is_empty() { + test::black_box(deq.pop_front()); + } + }) +} + +#[test] +fn test_swap_front_back_remove() { + fn test(back: bool) { + // This test checks that every single combination of tail position and length is tested. + // Capacity 15 should be large enough to cover every case. + let mut tester = VecDeque::with_capacity(15); + let usable_cap = tester.capacity(); + let final_len = usable_cap / 2; + + for len in 0..final_len { + let expected: VecDeque<_> = + if back { (0..len).collect() } else { (0..len).rev().collect() }; + for tail_pos in 0..usable_cap { + tester.tail = tail_pos; + tester.head = tail_pos; + if back { + for i in 0..len * 2 { + tester.push_front(i); + } + for i in 0..len { + assert_eq!(tester.swap_remove_back(i), Some(len * 2 - 1 - i)); + } + } else { + for i in 0..len * 2 { + tester.push_back(i); + } + for i in 0..len { + let idx = tester.len() - 1 - i; + assert_eq!(tester.swap_remove_front(idx), Some(len * 2 - 1 - i)); + } + } + assert!(tester.tail < tester.cap()); + assert!(tester.head < tester.cap()); + assert_eq!(tester, expected); + } + } + } + test(true); + test(false); +} + +#[test] +fn test_insert() { + // This test checks that every single combination of tail position, length, and + // insertion position is tested. Capacity 15 should be large enough to cover every case. + + let mut tester = VecDeque::with_capacity(15); + // can't guarantee we got 15, so have to get what we got. + // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else + // this test isn't covering what it wants to + let cap = tester.capacity(); + + // len is the length *after* insertion + let minlen = if cfg!(miri) { cap - 1 } else { 1 }; // Miri is too slow + for len in minlen..cap { + // 0, 1, 2, .., len - 1 + let expected = (0..).take(len).collect::>(); + for tail_pos in 0..cap { + for to_insert in 0..len { + tester.tail = tail_pos; + tester.head = tail_pos; + for i in 0..len { + if i != to_insert { + tester.push_back(i); + } + } + tester.insert(to_insert, to_insert); + assert!(tester.tail < tester.cap()); + assert!(tester.head < tester.cap()); + assert_eq!(tester, expected); + } + } + } +} + +#[test] +fn make_contiguous_big_tail() { + let mut tester = VecDeque::with_capacity(15); + + for i in 0..3 { + tester.push_back(i); + } + + for i in 3..10 { + tester.push_front(i); + } + + // 012......9876543 + assert_eq!(tester.capacity(), 15); + assert_eq!((&[9, 8, 7, 6, 5, 4, 3] as &[_], &[0, 1, 2] as &[_]), tester.as_slices()); + + let expected_start = tester.head; + tester.make_contiguous(); + assert_eq!(tester.tail, expected_start); + assert_eq!((&[9, 8, 7, 6, 5, 4, 3, 0, 1, 2] as &[_], &[] as &[_]), tester.as_slices()); +} + +#[test] +fn make_contiguous_big_head() { + let mut tester = VecDeque::with_capacity(15); + + for i in 0..8 { + tester.push_back(i); + } + + for i in 8..10 { + tester.push_front(i); + } + + // 01234567......98 + let expected_start = 0; + tester.make_contiguous(); + assert_eq!(tester.tail, expected_start); + assert_eq!((&[9, 8, 0, 1, 2, 3, 4, 5, 6, 7] as &[_], &[] as &[_]), tester.as_slices()); +} + +#[test] +fn make_contiguous_small_free() { + let mut tester = VecDeque::with_capacity(15); + + for i in 'A' as u8..'I' as u8 { + tester.push_back(i as char); + } + + for i in 'I' as u8..'N' as u8 { + tester.push_front(i as char); + } + + // ABCDEFGH...MLKJI + let expected_start = 0; + tester.make_contiguous(); + assert_eq!(tester.tail, expected_start); + assert_eq!( + (&['M', 'L', 'K', 'J', 'I', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] as &[_], &[] as &[_]), + tester.as_slices() + ); + + tester.clear(); + for i in 'I' as u8..'N' as u8 { + tester.push_back(i as char); + } + + for i in 'A' as u8..'I' as u8 { + tester.push_front(i as char); + } + + // IJKLM...HGFEDCBA + let expected_start = 0; + tester.make_contiguous(); + assert_eq!(tester.tail, expected_start); + assert_eq!( + (&['H', 'G', 'F', 'E', 'D', 'C', 'B', 'A', 'I', 'J', 'K', 'L', 'M'] as &[_], &[] as &[_]), + tester.as_slices() + ); +} + +#[test] +fn make_contiguous_head_to_end() { + let mut dq = VecDeque::with_capacity(3); + dq.push_front('B'); + dq.push_front('A'); + dq.push_back('C'); + dq.make_contiguous(); + let expected_tail = 0; + let expected_head = 3; + assert_eq!(expected_tail, dq.tail); + assert_eq!(expected_head, dq.head); + assert_eq!((&['A', 'B', 'C'] as &[_], &[] as &[_]), dq.as_slices()); +} + +#[test] +fn test_remove() { + // This test checks that every single combination of tail position, length, and + // removal position is tested. Capacity 15 should be large enough to cover every case. + + let mut tester = VecDeque::with_capacity(15); + // can't guarantee we got 15, so have to get what we got. + // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else + // this test isn't covering what it wants to + let cap = tester.capacity(); + + // len is the length *after* removal + let minlen = if cfg!(miri) { cap - 2 } else { 0 }; // Miri is too slow + for len in minlen..cap - 1 { + // 0, 1, 2, .., len - 1 + let expected = (0..).take(len).collect::>(); + for tail_pos in 0..cap { + for to_remove in 0..=len { + tester.tail = tail_pos; + tester.head = tail_pos; + for i in 0..len { + if i == to_remove { + tester.push_back(1234); + } + tester.push_back(i); + } + if to_remove == len { + tester.push_back(1234); + } + tester.remove(to_remove); + assert!(tester.tail < tester.cap()); + assert!(tester.head < tester.cap()); + assert_eq!(tester, expected); + } + } + } +} + +#[test] +fn test_range() { + let mut tester: VecDeque = VecDeque::with_capacity(7); + + let cap = tester.capacity(); + let minlen = if cfg!(miri) { cap - 1 } else { 0 }; // Miri is too slow + for len in minlen..=cap { + for tail in 0..=cap { + for start in 0..=len { + for end in start..=len { + tester.tail = tail; + tester.head = tail; + for i in 0..len { + tester.push_back(i); + } + + // Check that we iterate over the correct values + let range: VecDeque<_> = tester.range(start..end).copied().collect(); + let expected: VecDeque<_> = (start..end).collect(); + assert_eq!(range, expected); + } + } + } + } +} + +#[test] +fn test_range_mut() { + let mut tester: VecDeque = VecDeque::with_capacity(7); + + let cap = tester.capacity(); + for len in 0..=cap { + for tail in 0..=cap { + for start in 0..=len { + for end in start..=len { + tester.tail = tail; + tester.head = tail; + for i in 0..len { + tester.push_back(i); + } + + let head_was = tester.head; + let tail_was = tester.tail; + + // Check that we iterate over the correct values + let range: VecDeque<_> = tester.range_mut(start..end).map(|v| *v).collect(); + let expected: VecDeque<_> = (start..end).collect(); + assert_eq!(range, expected); + + // We shouldn't have changed the capacity or made the + // head or tail out of bounds + assert_eq!(tester.capacity(), cap); + assert_eq!(tester.tail, tail_was); + assert_eq!(tester.head, head_was); + } + } + } + } +} + +#[test] +fn test_drain() { + let mut tester: VecDeque = VecDeque::with_capacity(7); + + let cap = tester.capacity(); + for len in 0..=cap { + for tail in 0..=cap { + for drain_start in 0..=len { + for drain_end in drain_start..=len { + tester.tail = tail; + tester.head = tail; + for i in 0..len { + tester.push_back(i); + } + + // Check that we drain the correct values + let drained: VecDeque<_> = tester.drain(drain_start..drain_end).collect(); + let drained_expected: VecDeque<_> = (drain_start..drain_end).collect(); + assert_eq!(drained, drained_expected); + + // We shouldn't have changed the capacity or made the + // head or tail out of bounds + assert_eq!(tester.capacity(), cap); + assert!(tester.tail < tester.cap()); + assert!(tester.head < tester.cap()); + + // We should see the correct values in the VecDeque + let expected: VecDeque<_> = (0..drain_start).chain(drain_end..len).collect(); + assert_eq!(expected, tester); + } + } + } + } +} + +#[test] +fn test_shrink_to_fit() { + // This test checks that every single combination of head and tail position, + // is tested. Capacity 15 should be large enough to cover every case. + + let mut tester = VecDeque::with_capacity(15); + // can't guarantee we got 15, so have to get what we got. + // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else + // this test isn't covering what it wants to + let cap = tester.capacity(); + tester.reserve(63); + let max_cap = tester.capacity(); + + for len in 0..=cap { + // 0, 1, 2, .., len - 1 + let expected = (0..).take(len).collect::>(); + for tail_pos in 0..=max_cap { + tester.tail = tail_pos; + tester.head = tail_pos; + tester.reserve(63); + for i in 0..len { + tester.push_back(i); + } + tester.shrink_to_fit(); + assert!(tester.capacity() <= cap); + assert!(tester.tail < tester.cap()); + assert!(tester.head < tester.cap()); + assert_eq!(tester, expected); + } + } +} + +#[test] +fn test_split_off() { + // This test checks that every single combination of tail position, length, and + // split position is tested. Capacity 15 should be large enough to cover every case. + + let mut tester = VecDeque::with_capacity(15); + // can't guarantee we got 15, so have to get what we got. + // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else + // this test isn't covering what it wants to + let cap = tester.capacity(); + + // len is the length *before* splitting + let minlen = if cfg!(miri) { cap - 1 } else { 0 }; // Miri is too slow + for len in minlen..cap { + // index to split at + for at in 0..=len { + // 0, 1, 2, .., at - 1 (may be empty) + let expected_self = (0..).take(at).collect::>(); + // at, at + 1, .., len - 1 (may be empty) + let expected_other = (at..).take(len - at).collect::>(); + + for tail_pos in 0..cap { + tester.tail = tail_pos; + tester.head = tail_pos; + for i in 0..len { + tester.push_back(i); + } + let result = tester.split_off(at); + assert!(tester.tail < tester.cap()); + assert!(tester.head < tester.cap()); + assert!(result.tail < result.cap()); + assert!(result.head < result.cap()); + assert_eq!(tester, expected_self); + assert_eq!(result, expected_other); + } + } + } +} + +#[test] +fn test_from_vec() { + use crate::vec::Vec; + for cap in 0..35 { + for len in 0..=cap { + let mut vec = Vec::with_capacity(cap); + vec.extend(0..len); + + let vd = VecDeque::from(vec.clone()); + assert!(vd.cap().is_power_of_two()); + assert_eq!(vd.len(), vec.len()); + assert!(vd.into_iter().eq(vec)); + } + } +} + +#[test] +fn test_vec_from_vecdeque() { + use crate::vec::Vec; + + fn create_vec_and_test_convert(capacity: usize, offset: usize, len: usize) { + let mut vd = VecDeque::with_capacity(capacity); + for _ in 0..offset { + vd.push_back(0); + vd.pop_front(); + } + vd.extend(0..len); + + let vec: Vec<_> = Vec::from(vd.clone()); + assert_eq!(vec.len(), vd.len()); + assert!(vec.into_iter().eq(vd)); + } + + // Miri is too slow + let max_pwr = if cfg!(miri) { 5 } else { 7 }; + + for cap_pwr in 0..max_pwr { + // Make capacity as a (2^x)-1, so that the ring size is 2^x + let cap = (2i32.pow(cap_pwr) - 1) as usize; + + // In these cases there is enough free space to solve it with copies + for len in 0..((cap + 1) / 2) { + // Test contiguous cases + for offset in 0..(cap - len) { + create_vec_and_test_convert(cap, offset, len) + } + + // Test cases where block at end of buffer is bigger than block at start + for offset in (cap - len)..(cap - (len / 2)) { + create_vec_and_test_convert(cap, offset, len) + } + + // Test cases where block at start of buffer is bigger than block at end + for offset in (cap - (len / 2))..cap { + create_vec_and_test_convert(cap, offset, len) + } + } + + // Now there's not (necessarily) space to straighten the ring with simple copies, + // the ring will use swapping when: + // (cap + 1 - offset) > (cap + 1 - len) && (len - (cap + 1 - offset)) > (cap + 1 - len)) + // right block size > free space && left block size > free space + for len in ((cap + 1) / 2)..cap { + // Test contiguous cases + for offset in 0..(cap - len) { + create_vec_and_test_convert(cap, offset, len) + } + + // Test cases where block at end of buffer is bigger than block at start + for offset in (cap - len)..(cap - (len / 2)) { + create_vec_and_test_convert(cap, offset, len) + } + + // Test cases where block at start of buffer is bigger than block at end + for offset in (cap - (len / 2))..cap { + create_vec_and_test_convert(cap, offset, len) + } + } + } +} + +#[test] +fn test_clone_from() { + let m = vec![1; 8]; + let n = vec![2; 12]; + let limit = if cfg!(miri) { 4 } else { 8 }; // Miri is too slow + for pfv in 0..limit { + for pfu in 0..limit { + for longer in 0..2 { + let (vr, ur) = if longer == 0 { (&m, &n) } else { (&n, &m) }; + let mut v = VecDeque::from(vr.clone()); + for _ in 0..pfv { + v.push_front(1); + } + let mut u = VecDeque::from(ur.clone()); + for _ in 0..pfu { + u.push_front(2); + } + v.clone_from(&u); + assert_eq!(&v, &u); + } + } + } +} + +#[test] +fn test_vec_deque_truncate_drop() { + static mut DROPS: u32 = 0; + #[derive(Clone)] + struct Elem(i32); + impl Drop for Elem { + fn drop(&mut self) { + unsafe { + DROPS += 1; + } + } + } + + let v = vec![Elem(1), Elem(2), Elem(3), Elem(4), Elem(5)]; + for push_front in 0..=v.len() { + let v = v.clone(); + let mut tester = VecDeque::with_capacity(5); + for (index, elem) in v.into_iter().enumerate() { + if index < push_front { + tester.push_front(elem); + } else { + tester.push_back(elem); + } + } + assert_eq!(unsafe { DROPS }, 0); + tester.truncate(3); + assert_eq!(unsafe { DROPS }, 2); + tester.truncate(0); + assert_eq!(unsafe { DROPS }, 5); + unsafe { + DROPS = 0; + } + } +} + +#[test] +fn issue_53529() { + use crate::boxed::Box; + + let mut dst = VecDeque::new(); + dst.push_front(Box::new(1)); + dst.push_front(Box::new(2)); + assert_eq!(*dst.pop_back().unwrap(), 1); + + let mut src = VecDeque::new(); + src.push_front(Box::new(2)); + dst.append(&mut src); + for a in dst { + assert_eq!(*a, 2); + } +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/fmt.rs b/gcc/testsuite/rust/alloc/alloc/src/fmt.rs new file mode 100644 index 000000000000..53d5ae608af2 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/fmt.rs @@ -0,0 +1,583 @@ +//! Utilities for formatting and printing `String`s. +//! +//! This module contains the runtime support for the [`format!`] syntax extension. +//! This macro is implemented in the compiler to emit calls to this module in +//! order to format arguments at runtime into strings. +//! +//! # Usage +//! +//! The [`format!`] macro is intended to be familiar to those coming from C's +//! `printf`/`fprintf` functions or Python's `str.format` function. +//! +//! Some examples of the [`format!`] extension are: +//! +//! ``` +//! format!("Hello"); // => "Hello" +//! format!("Hello, {}!", "world"); // => "Hello, world!" +//! format!("The number is {}", 1); // => "The number is 1" +//! format!("{:?}", (3, 4)); // => "(3, 4)" +//! format!("{value}", value=4); // => "4" +//! format!("{} {}", 1, 2); // => "1 2" +//! format!("{:04}", 42); // => "0042" with leading zeros +//! ``` +//! +//! From these, you can see that the first argument is a format string. It is +//! required by the compiler for this to be a string literal; it cannot be a +//! variable passed in (in order to perform validity checking). The compiler +//! will then parse the format string and determine if the list of arguments +//! provided is suitable to pass to this format string. +//! +//! To convert a single value to a string, use the [`to_string`] method. This +//! will use the [`Display`] formatting trait. +//! +//! ## Positional parameters +//! +//! Each formatting argument is allowed to specify which value argument it's +//! referencing, and if omitted it is assumed to be "the next argument". For +//! example, the format string `{} {} {}` would take three parameters, and they +//! would be formatted in the same order as they're given. The format string +//! `{2} {1} {0}`, however, would format arguments in reverse order. +//! +//! Things can get a little tricky once you start intermingling the two types of +//! positional specifiers. The "next argument" specifier can be thought of as an +//! iterator over the argument. Each time a "next argument" specifier is seen, +//! the iterator advances. This leads to behavior like this: +//! +//! ``` +//! format!("{1} {} {0} {}", 1, 2); // => "2 1 1 2" +//! ``` +//! +//! The internal iterator over the argument has not been advanced by the time +//! the first `{}` is seen, so it prints the first argument. Then upon reaching +//! the second `{}`, the iterator has advanced forward to the second argument. +//! Essentially, parameters that explicitly name their argument do not affect +//! parameters that do not name an argument in terms of positional specifiers. +//! +//! A format string is required to use all of its arguments, otherwise it is a +//! compile-time error. You may refer to the same argument more than once in the +//! format string. +//! +//! ## Named parameters +//! +//! Rust itself does not have a Python-like equivalent of named parameters to a +//! function, but the [`format!`] macro is a syntax extension that allows it to +//! leverage named parameters. Named parameters are listed at the end of the +//! argument list and have the syntax: +//! +//! ```text +//! identifier '=' expression +//! ``` +//! +//! For example, the following [`format!`] expressions all use named argument: +//! +//! ``` +//! format!("{argument}", argument = "test"); // => "test" +//! format!("{name} {}", 1, name = 2); // => "2 1" +//! format!("{a} {c} {b}", a="a", b='b', c=3); // => "a 3 b" +//! ``` +//! +//! It is not valid to put positional parameters (those without names) after +//! arguments that have names. Like with positional parameters, it is not +//! valid to provide named parameters that are unused by the format string. +//! +//! # Formatting Parameters +//! +//! Each argument being formatted can be transformed by a number of formatting +//! parameters (corresponding to `format_spec` in [the syntax](#syntax)). These +//! parameters affect the string representation of what's being formatted. +//! +//! ## Width +//! +//! ``` +//! // All of these print "Hello x !" +//! println!("Hello {:5}!", "x"); +//! println!("Hello {:1$}!", "x", 5); +//! println!("Hello {1:0$}!", 5, "x"); +//! println!("Hello {:width$}!", "x", width = 5); +//! ``` +//! +//! This is a parameter for the "minimum width" that the format should take up. +//! If the value's string does not fill up this many characters, then the +//! padding specified by fill/alignment will be used to take up the required +//! space (see below). +//! +//! The value for the width can also be provided as a [`usize`] in the list of +//! parameters by adding a postfix `$`, indicating that the second argument is +//! a [`usize`] specifying the width. +//! +//! Referring to an argument with the dollar syntax does not affect the "next +//! argument" counter, so it's usually a good idea to refer to arguments by +//! position, or use named arguments. +//! +//! ## Fill/Alignment +//! +//! ``` +//! assert_eq!(format!("Hello {:<5}!", "x"), "Hello x !"); +//! assert_eq!(format!("Hello {:-<5}!", "x"), "Hello x----!"); +//! assert_eq!(format!("Hello {:^5}!", "x"), "Hello x !"); +//! assert_eq!(format!("Hello {:>5}!", "x"), "Hello x!"); +//! ``` +//! +//! The optional fill character and alignment is provided normally in conjunction with the +//! [`width`](#width) parameter. It must be defined before `width`, right after the `:`. +//! This indicates that if the value being formatted is smaller than +//! `width` some extra characters will be printed around it. +//! Filling comes in the following variants for different alignments: +//! +//! * `[fill]<` - the argument is left-aligned in `width` columns +//! * `[fill]^` - the argument is center-aligned in `width` columns +//! * `[fill]>` - the argument is right-aligned in `width` columns +//! +//! The default [fill/alignment](#fillalignment) for non-numerics is a space and +//! left-aligned. The +//! default for numeric formatters is also a space character but with right-alignment. If +//! the `0` flag (see below) is specified for numerics, then the implicit fill character is +//! `0`. +//! +//! Note that alignment may not be implemented by some types. In particular, it +//! is not generally implemented for the `Debug` trait. A good way to ensure +//! padding is applied is to format your input, then pad this resulting string +//! to obtain your output: +//! +//! ``` +//! println!("Hello {:^15}!", format!("{:?}", Some("hi"))); // => "Hello Some("hi") !" +//! ``` +//! +//! ## Sign/`#`/`0` +//! +//! ``` +//! assert_eq!(format!("Hello {:+}!", 5), "Hello +5!"); +//! assert_eq!(format!("{:#x}!", 27), "0x1b!"); +//! assert_eq!(format!("Hello {:05}!", 5), "Hello 00005!"); +//! assert_eq!(format!("Hello {:05}!", -5), "Hello -0005!"); +//! assert_eq!(format!("{:#010x}!", 27), "0x0000001b!"); +//! ``` +//! +//! These are all flags altering the behavior of the formatter. +//! +//! * `+` - This is intended for numeric types and indicates that the sign +//! should always be printed. Positive signs are never printed by +//! default, and the negative sign is only printed by default for the +//! `Signed` trait. This flag indicates that the correct sign (`+` or `-`) +//! should always be printed. +//! * `-` - Currently not used +//! * `#` - This flag indicates that the "alternate" form of printing should +//! be used. The alternate forms are: +//! * `#?` - pretty-print the [`Debug`] formatting +//! * `#x` - precedes the argument with a `0x` +//! * `#X` - precedes the argument with a `0x` +//! * `#b` - precedes the argument with a `0b` +//! * `#o` - precedes the argument with a `0o` +//! * `0` - This is used to indicate for integer formats that the padding to `width` should +//! both be done with a `0` character as well as be sign-aware. A format +//! like `{:08}` would yield `00000001` for the integer `1`, while the +//! same format would yield `-0000001` for the integer `-1`. Notice that +//! the negative version has one fewer zero than the positive version. +//! Note that padding zeros are always placed after the sign (if any) +//! and before the digits. When used together with the `#` flag, a similar +//! rule applies: padding zeros are inserted after the prefix but before +//! the digits. The prefix is included in the total width. +//! +//! ## Precision +//! +//! For non-numeric types, this can be considered a "maximum width". If the resulting string is +//! longer than this width, then it is truncated down to this many characters and that truncated +//! value is emitted with proper `fill`, `alignment` and `width` if those parameters are set. +//! +//! For integral types, this is ignored. +//! +//! For floating-point types, this indicates how many digits after the decimal point should be +//! printed. +//! +//! There are three possible ways to specify the desired `precision`: +//! +//! 1. An integer `.N`: +//! +//! the integer `N` itself is the precision. +//! +//! 2. An integer or name followed by dollar sign `.N$`: +//! +//! use format *argument* `N` (which must be a `usize`) as the precision. +//! +//! 3. An asterisk `.*`: +//! +//! `.*` means that this `{...}` is associated with *two* format inputs rather than one: the +//! first input holds the `usize` precision, and the second holds the value to print. Note that +//! in this case, if one uses the format string `{:.*}`, then the `` part refers +//! to the *value* to print, and the `precision` must come in the input preceding ``. +//! +//! For example, the following calls all print the same thing `Hello x is 0.01000`: +//! +//! ``` +//! // Hello {arg 0 ("x")} is {arg 1 (0.01) with precision specified inline (5)} +//! println!("Hello {0} is {1:.5}", "x", 0.01); +//! +//! // Hello {arg 1 ("x")} is {arg 2 (0.01) with precision specified in arg 0 (5)} +//! println!("Hello {1} is {2:.0$}", 5, "x", 0.01); +//! +//! // Hello {arg 0 ("x")} is {arg 2 (0.01) with precision specified in arg 1 (5)} +//! println!("Hello {0} is {2:.1$}", "x", 5, 0.01); +//! +//! // Hello {next arg ("x")} is {second of next two args (0.01) with precision +//! // specified in first of next two args (5)} +//! println!("Hello {} is {:.*}", "x", 5, 0.01); +//! +//! // Hello {next arg ("x")} is {arg 2 (0.01) with precision +//! // specified in its predecessor (5)} +//! println!("Hello {} is {2:.*}", "x", 5, 0.01); +//! +//! // Hello {next arg ("x")} is {arg "number" (0.01) with precision specified +//! // in arg "prec" (5)} +//! println!("Hello {} is {number:.prec$}", "x", prec = 5, number = 0.01); +//! ``` +//! +//! While these: +//! +//! ``` +//! println!("{}, `{name:.*}` has 3 fractional digits", "Hello", 3, name=1234.56); +//! println!("{}, `{name:.*}` has 3 characters", "Hello", 3, name="1234.56"); +//! println!("{}, `{name:>8.*}` has 3 right-aligned characters", "Hello", 3, name="1234.56"); +//! ``` +//! +//! print three significantly different things: +//! +//! ```text +//! Hello, `1234.560` has 3 fractional digits +//! Hello, `123` has 3 characters +//! Hello, ` 123` has 3 right-aligned characters +//! ``` +//! +//! ## Localization +//! +//! In some programming languages, the behavior of string formatting functions +//! depends on the operating system's locale setting. The format functions +//! provided by Rust's standard library do not have any concept of locale and +//! will produce the same results on all systems regardless of user +//! configuration. +//! +//! For example, the following code will always print `1.5` even if the system +//! locale uses a decimal separator other than a dot. +//! +//! ``` +//! println!("The value is {}", 1.5); +//! ``` +//! +//! # Escaping +//! +//! The literal characters `{` and `}` may be included in a string by preceding +//! them with the same character. For example, the `{` character is escaped with +//! `{{` and the `}` character is escaped with `}}`. +//! +//! ``` +//! assert_eq!(format!("Hello {{}}"), "Hello {}"); +//! assert_eq!(format!("{{ Hello"), "{ Hello"); +//! ``` +//! +//! # Syntax +//! +//! To summarize, here you can find the full grammar of format strings. +//! The syntax for the formatting language used is drawn from other languages, +//! so it should not be too alien. Arguments are formatted with Python-like +//! syntax, meaning that arguments are surrounded by `{}` instead of the C-like +//! `%`. The actual grammar for the formatting syntax is: +//! +//! ```text +//! format_string := [ maybe-format ] * +//! maybe-format := '{' '{' | '}' '}' | +//! format := '{' [ argument ] [ ':' format_spec ] '}' +//! argument := integer | identifier +//! +//! format_spec := [[fill]align][sign]['#']['0'][width]['.' precision][type] +//! fill := character +//! align := '<' | '^' | '>' +//! sign := '+' | '-' +//! width := count +//! precision := count | '*' +//! type := identifier | '?' | '' +//! count := parameter | integer +//! parameter := argument '$' +//! ``` +//! +//! # Formatting traits +//! +//! When requesting that an argument be formatted with a particular type, you +//! are actually requesting that an argument ascribes to a particular trait. +//! This allows multiple actual types to be formatted via `{:x}` (like [`i8`] as +//! well as [`isize`]). The current mapping of types to traits is: +//! +//! * *nothing* ⇒ [`Display`] +//! * `?` ⇒ [`Debug`] +//! * `x?` ⇒ [`Debug`] with lower-case hexadecimal integers +//! * `X?` ⇒ [`Debug`] with upper-case hexadecimal integers +//! * `o` ⇒ [`Octal`] +//! * `x` ⇒ [`LowerHex`] +//! * `X` ⇒ [`UpperHex`] +//! * `p` ⇒ [`Pointer`] +//! * `b` ⇒ [`Binary`] +//! * `e` ⇒ [`LowerExp`] +//! * `E` ⇒ [`UpperExp`] +//! +//! What this means is that any type of argument which implements the +//! [`fmt::Binary`][`Binary`] trait can then be formatted with `{:b}`. Implementations +//! are provided for these traits for a number of primitive types by the +//! standard library as well. If no format is specified (as in `{}` or `{:6}`), +//! then the format trait used is the [`Display`] trait. +//! +//! When implementing a format trait for your own type, you will have to +//! implement a method of the signature: +//! +//! ``` +//! # #![allow(dead_code)] +//! # use std::fmt; +//! # struct Foo; // our custom type +//! # impl fmt::Display for Foo { +//! fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { +//! # write!(f, "testing, testing") +//! # } } +//! ``` +//! +//! Your type will be passed as `self` by-reference, and then the function +//! should emit output into the `f.buf` stream. It is up to each format trait +//! implementation to correctly adhere to the requested formatting parameters. +//! The values of these parameters will be listed in the fields of the +//! [`Formatter`] struct. In order to help with this, the [`Formatter`] struct also +//! provides some helper methods. +//! +//! Additionally, the return value of this function is [`fmt::Result`] which is a +//! type alias of [`Result`]`<(), `[`std::fmt::Error`]`>`. Formatting implementations +//! should ensure that they propagate errors from the [`Formatter`] (e.g., when +//! calling [`write!`]). However, they should never return errors spuriously. That +//! is, a formatting implementation must and may only return an error if the +//! passed-in [`Formatter`] returns an error. This is because, contrary to what +//! the function signature might suggest, string formatting is an infallible +//! operation. This function only returns a result because writing to the +//! underlying stream might fail and it must provide a way to propagate the fact +//! that an error has occurred back up the stack. +//! +//! An example of implementing the formatting traits would look +//! like: +//! +//! ``` +//! use std::fmt; +//! +//! #[derive(Debug)] +//! struct Vector2D { +//! x: isize, +//! y: isize, +//! } +//! +//! impl fmt::Display for Vector2D { +//! fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { +//! // The `f` value implements the `Write` trait, which is what the +//! // write! macro is expecting. Note that this formatting ignores the +//! // various flags provided to format strings. +//! write!(f, "({}, {})", self.x, self.y) +//! } +//! } +//! +//! // Different traits allow different forms of output of a type. The meaning +//! // of this format is to print the magnitude of a vector. +//! impl fmt::Binary for Vector2D { +//! fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { +//! let magnitude = (self.x * self.x + self.y * self.y) as f64; +//! let magnitude = magnitude.sqrt(); +//! +//! // Respect the formatting flags by using the helper method +//! // `pad_integral` on the Formatter object. See the method +//! // documentation for details, and the function `pad` can be used +//! // to pad strings. +//! let decimals = f.precision().unwrap_or(3); +//! let string = format!("{:.*}", decimals, magnitude); +//! f.pad_integral(true, "", &string) +//! } +//! } +//! +//! fn main() { +//! let myvector = Vector2D { x: 3, y: 4 }; +//! +//! println!("{}", myvector); // => "(3, 4)" +//! println!("{:?}", myvector); // => "Vector2D {x: 3, y:4}" +//! println!("{:10.3b}", myvector); // => " 5.000" +//! } +//! ``` +//! +//! ### `fmt::Display` vs `fmt::Debug` +//! +//! These two formatting traits have distinct purposes: +//! +//! - [`fmt::Display`][`Display`] implementations assert that the type can be faithfully +//! represented as a UTF-8 string at all times. It is **not** expected that +//! all types implement the [`Display`] trait. +//! - [`fmt::Debug`][`Debug`] implementations should be implemented for **all** public types. +//! Output will typically represent the internal state as faithfully as possible. +//! The purpose of the [`Debug`] trait is to facilitate debugging Rust code. In +//! most cases, using `#[derive(Debug)]` is sufficient and recommended. +//! +//! Some examples of the output from both traits: +//! +//! ``` +//! assert_eq!(format!("{} {:?}", 3, 4), "3 4"); +//! assert_eq!(format!("{} {:?}", 'a', 'b'), "a 'b'"); +//! assert_eq!(format!("{} {:?}", "foo\n", "bar\n"), "foo\n \"bar\\n\""); +//! ``` +//! +//! # Related macros +//! +//! There are a number of related macros in the [`format!`] family. The ones that +//! are currently implemented are: +//! +//! ```ignore (only-for-syntax-highlight) +//! format! // described above +//! write! // first argument is a &mut io::Write, the destination +//! writeln! // same as write but appends a newline +//! print! // the format string is printed to the standard output +//! println! // same as print but appends a newline +//! eprint! // the format string is printed to the standard error +//! eprintln! // same as eprint but appends a newline +//! format_args! // described below. +//! ``` +//! +//! ### `write!` +//! +//! This and [`writeln!`] are two macros which are used to emit the format string +//! to a specified stream. This is used to prevent intermediate allocations of +//! format strings and instead directly write the output. Under the hood, this +//! function is actually invoking the [`write_fmt`] function defined on the +//! [`std::io::Write`] trait. Example usage is: +//! +//! ``` +//! # #![allow(unused_must_use)] +//! use std::io::Write; +//! let mut w = Vec::new(); +//! write!(&mut w, "Hello {}!", "world"); +//! ``` +//! +//! ### `print!` +//! +//! This and [`println!`] emit their output to stdout. Similarly to the [`write!`] +//! macro, the goal of these macros is to avoid intermediate allocations when +//! printing output. Example usage is: +//! +//! ``` +//! print!("Hello {}!", "world"); +//! println!("I have a newline {}", "character at the end"); +//! ``` +//! ### `eprint!` +//! +//! The [`eprint!`] and [`eprintln!`] macros are identical to +//! [`print!`] and [`println!`], respectively, except they emit their +//! output to stderr. +//! +//! ### `format_args!` +//! +//! This is a curious macro used to safely pass around +//! an opaque object describing the format string. This object +//! does not require any heap allocations to create, and it only +//! references information on the stack. Under the hood, all of +//! the related macros are implemented in terms of this. First +//! off, some example usage is: +//! +//! ``` +//! # #![allow(unused_must_use)] +//! use std::fmt; +//! use std::io::{self, Write}; +//! +//! let mut some_writer = io::stdout(); +//! write!(&mut some_writer, "{}", format_args!("print with a {}", "macro")); +//! +//! fn my_fmt_fn(args: fmt::Arguments) { +//! write!(&mut io::stdout(), "{}", args); +//! } +//! my_fmt_fn(format_args!(", or a {} too", "function")); +//! ``` +//! +//! The result of the [`format_args!`] macro is a value of type [`fmt::Arguments`]. +//! This structure can then be passed to the [`write`] and [`format`] functions +//! inside this module in order to process the format string. +//! The goal of this macro is to even further prevent intermediate allocations +//! when dealing with formatting strings. +//! +//! For example, a logging library could use the standard formatting syntax, but +//! it would internally pass around this structure until it has been determined +//! where output should go to. +//! +//! [`fmt::Result`]: Result +//! [`Result`]: core::result::Result +//! [`std::fmt::Error`]: Error +//! [`write!`]: core::write +//! [`write`]: core::write +//! [`format!`]: crate::format +//! [`to_string`]: crate::string::ToString +//! [`writeln!`]: core::writeln +//! [`write_fmt`]: ../../std/io/trait.Write.html#method.write_fmt +//! [`std::io::Write`]: ../../std/io/trait.Write.html +//! [`print!`]: ../../std/macro.print.html +//! [`println!`]: ../../std/macro.println.html +//! [`eprint!`]: ../../std/macro.eprint.html +//! [`eprintln!`]: ../../std/macro.eprintln.html +//! [`format_args!`]: core::format_args +//! [`fmt::Arguments`]: Arguments +//! [`format`]: crate::format + +#![stable(feature = "rust1", since = "1.0.0")] + +use crate::gccrs_core_prelude::*; + +#[unstable(feature = "fmt_internals", issue = "none")] +pub use core::fmt::rt; +#[stable(feature = "fmt_flags_align", since = "1.28.0")] +pub use core::fmt::Alignment; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::fmt::Error; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::fmt::{write, ArgumentV1, Arguments}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::fmt::{Binary, Octal}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::fmt::{Debug, Display}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::fmt::{DebugList, DebugMap, DebugSet, DebugStruct, DebugTuple}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::fmt::{Formatter, Result, Write}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::fmt::{LowerExp, UpperExp}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::fmt::{LowerHex, Pointer, UpperHex}; + +use crate::string; + +/// The `format` function takes an [`Arguments`] struct and returns the resulting +/// formatted string. +/// +/// The [`Arguments`] instance can be created with the [`format_args!`] macro. +/// +/// # Examples +/// +/// Basic usage: +/// +/// ``` +/// use std::fmt; +/// +/// let s = fmt::format(format_args!("Hello, {}!", "world")); +/// assert_eq!(s, "Hello, world!"); +/// ``` +/// +/// Please note that using [`format!`] might be preferable. +/// Example: +/// +/// ``` +/// let s = format!("Hello, {}!", "world"); +/// assert_eq!(s, "Hello, world!"); +/// ``` +/// +/// [`format_args!`]: core::format_args +/// [`format!`]: crate::format +#[stable(feature = "rust1", since = "1.0.0")] +pub fn format(args: Arguments<'_>) -> string::String { + let capacity = args.estimated_capacity(); + let mut output = string::String::with_capacity(capacity); + output + .write_fmt(args) + .expect("a formatting trait implementation returned an error"); + output +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/lib.rs b/gcc/testsuite/rust/alloc/alloc/src/lib.rs new file mode 100644 index 000000000000..864fc4e56f40 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/lib.rs @@ -0,0 +1,207 @@ +//! # The Rust core allocation and collections library +//! +//! This library provides smart pointers and collections for managing +//! heap-allocated values. +//! +//! This library, like libcore, normally doesn’t need to be used directly +//! since its contents are re-exported in the [`std` crate](../std/index.html). +//! Crates that use the `#![no_std]` attribute however will typically +//! not depend on `std`, so they’d use this crate instead. +//! +//! ## Boxed values +//! +//! The [`Box`] type is a smart pointer type. There can only be one owner of a +//! [`Box`], and the owner can decide to mutate the contents, which live on the +//! heap. +//! +//! This type can be sent among threads efficiently as the size of a `Box` value +//! is the same as that of a pointer. Tree-like data structures are often built +//! with boxes because each node often has only one owner, the parent. +//! +//! ## Reference counted pointers +//! +//! The [`Rc`] type is a non-threadsafe reference-counted pointer type intended +//! for sharing memory within a thread. An [`Rc`] pointer wraps a type, `T`, and +//! only allows access to `&T`, a shared reference. +//! +//! This type is useful when inherited mutability (such as using [`Box`]) is too +//! constraining for an application, and is often paired with the [`Cell`] or +//! [`RefCell`] types in order to allow mutation. +//! +//! ## Atomically reference counted pointers +//! +//! The [`Arc`] type is the threadsafe equivalent of the [`Rc`] type. It +//! provides all the same functionality of [`Rc`], except it requires that the +//! contained type `T` is shareable. Additionally, [`Arc`][`Arc`] is itself +//! sendable while [`Rc`][`Rc`] is not. +//! +//! This type allows for shared access to the contained data, and is often +//! paired with synchronization primitives such as mutexes to allow mutation of +//! shared resources. +//! +//! ## Collections +//! +//! Implementations of the most common general purpose data structures are +//! defined in this library. They are re-exported through the +//! [standard collections library](../std/collections/index.html). +//! +//! ## Heap interfaces +//! +//! The [`alloc`](alloc/index.html) module defines the low-level interface to the +//! default global allocator. It is not compatible with the libc allocator API. +//! +//! [`Arc`]: sync +//! [`Box`]: boxed +//! [`Cell`]: core::cell +//! [`Rc`]: rc +//! [`RefCell`]: core::cell + +#![feature(no_core, intrinsics)]//gccrs +#![no_core]//gccrs + +//gccrs: core features commented out +#![allow(unused_attributes)] +#![stable(feature = "alloc", since = "1.36.0")] +#![doc( + html_root_url = "https://doc.rust-lang.org/nightly/", + html_playground_url = "https://play.rust-lang.org/", + issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/", + test(no_crate_inject, attr(allow(unused_variables), deny(warnings))) +)] +#![no_std] +#![needs_allocator] +#![warn(deprecated_in_future)] +#![warn(missing_docs)] +#![warn(missing_debug_implementations)] +#![allow(explicit_outlives_requirements)] +#![allow(incomplete_features)] +#![deny(unsafe_op_in_unsafe_fn)] +#![cfg_attr(not(bootstrap), feature(rustc_allow_const_fn_unstable))] +// #![cfg_attr(not(test), feature(generator_trait))] +#![cfg_attr(test, feature(test))] +#![cfg_attr(test, feature(new_uninit))] +// #![feature(allocator_api)] +// #![feature(array_chunks)] +// #![feature(array_methods)] +// #![feature(array_value_iter)] +// #![feature(array_windows)] +#![feature(allow_internal_unstable)] +#![feature(arbitrary_self_types)] +#![feature(box_patterns)] +#![feature(box_syntax)] +#![feature(cfg_sanitize)] +#![feature(cfg_target_has_atomic)] +// #![feature(coerce_unsized)] +// #![feature(const_btree_new)] +#![feature(const_fn)] +#![feature(const_generics)] +#![feature(const_in_array_repeat_expressions)] +// #![feature(cow_is_borrowed)] +// #![feature(const_cow_is_borrowed)] +// #![feature(dispatch_from_dyn)] +// #![feature(core_intrinsics)] +#![feature(dropck_eyepatch)] +// #![feature(exact_size_is_empty)] +#![feature(exclusive_range_pattern)] +// #![feature(extend_one)] +// #![feature(fmt_internals)] +// #![feature(fn_traits)] +#![feature(fundamental)] +// #![feature(inplace_iteration)] +// #![feature(int_bits_const)] +#![feature(lang_items)] +// #![feature(layout_for_ptr)] +// #![feature(maybe_uninit_ref)] +#![feature(negative_impls)] +#![feature(never_type)] +#![feature(nll)] +// #![feature(nonnull_slice_from_raw_parts)] +#![feature(optin_builtin_traits)] +#![feature(or_patterns)] +// #![feature(pattern)] +// #![feature(ptr_internals)] +// #![feature(range_bounds_assert_len)] +#![feature(raw_ref_op)] +#![feature(rustc_attrs)] +// #![feature(receiver_trait)] +#![feature(min_specialization)] +// #![feature(slice_ptr_get)] +// #![feature(slice_ptr_len)] +#![feature(staged_api)] +// #![feature(str_internals)] +// #![feature(trusted_len)] +#![feature(unboxed_closures)] +// #![feature(unicode_internals)] +#![feature(unsafe_block_in_unsafe_fn)] +// #![feature(unsize)] +#![cfg_attr(not(bootstrap), feature(unsized_fn_params))] +#![cfg_attr(bootstrap, feature(unsized_locals))] +#![feature(allocator_internals)] +// #![feature(slice_partition_dedup)] +// #![feature(maybe_uninit_extra, maybe_uninit_slice, maybe_uninit_uninit_array)] +// #![feature(alloc_layout_extra)] +// #![feature(trusted_random_access)] +// #![feature(try_trait)] +#![feature(type_alias_impl_trait)] +#![feature(associated_type_bounds)] +// Allow testing this library + +#[cfg(test)] +#[macro_use] +extern crate std; +#[cfg(test)] +extern crate test; + +#[path = "../../core.rs"]//gccrs +pub mod core;//gccrs +#[path = "../../prelude.rs"]//gccrs +pub mod gccrs_core_prelude;//gccrs + +// Module with internal macros used by other modules (needs to be included before other modules). +#[macro_use] +mod macros; + +// Heaps provided for low-level allocation strategies + +pub mod alloc; + +// Primitive types using the heaps above + +// Need to conditionally define the mod from `boxed.rs` to avoid +// duplicating the lang-items when building in test cfg; but also need +// to allow code to have `use boxed::Box;` declarations. +#[cfg(not(test))] +pub mod boxed; +#[cfg(test)] +mod boxed { + pub use std::boxed::Box; +} +pub mod borrow; +pub mod collections; +pub mod fmt; +pub mod prelude; +pub mod raw_vec; +pub mod rc; +pub mod slice; +pub mod str; +pub mod string; +#[cfg(target_has_atomic = "ptr")] +pub mod sync; +#[cfg(target_has_atomic = "ptr")] +pub mod task; +#[cfg(test)] +mod tests; +pub mod vec; + +#[cfg(not(test))] +mod std { + use crate::core;//gccrs + pub use core::ops; // RangeFull +} + +#[doc(hidden)] +#[unstable(feature = "liballoc_internals", issue = "none", reason = "implementation detail")] +pub mod __export { + use crate::core;//gccrs + pub use core::format_args; +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/macros.rs b/gcc/testsuite/rust/alloc/alloc/src/macros.rs new file mode 100644 index 000000000000..a992d768d631 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/macros.rs @@ -0,0 +1,109 @@ +/// Creates a [`Vec`] containing the arguments. +/// +/// `vec!` allows `Vec`s to be defined with the same syntax as array expressions. +/// There are two forms of this macro: +/// +/// - Create a [`Vec`] containing a given list of elements: +/// +/// ``` +/// let v = vec![1, 2, 3]; +/// assert_eq!(v[0], 1); +/// assert_eq!(v[1], 2); +/// assert_eq!(v[2], 3); +/// ``` +/// +/// - Create a [`Vec`] from a given element and size: +/// +/// ``` +/// let v = vec![1; 3]; +/// assert_eq!(v, [1, 1, 1]); +/// ``` +/// +/// Note that unlike array expressions this syntax supports all elements +/// which implement [`Clone`] and the number of elements doesn't have to be +/// a constant. +/// +/// This will use `clone` to duplicate an expression, so one should be careful +/// using this with types having a nonstandard `Clone` implementation. For +/// example, `vec![Rc::new(1); 5]` will create a vector of five references +/// to the same boxed integer value, not five references pointing to independently +/// boxed integers. +/// +/// [`Vec`]: crate::vec::Vec +#[cfg(not(test))] +#[macro_export] +#[stable(feature = "rust1", since = "1.0.0")] +#[allow_internal_unstable(box_syntax)] +macro_rules! vec { + () => ( + $crate::vec::Vec::new() + ); + ($elem:expr; $n:expr) => ( + $crate::vec::from_elem($elem, $n) + ); + ($($x:expr),+ $(,)?) => ( + <[_]>::into_vec(box [$($x),+]) + ); +} + +// HACK(japaric): with cfg(test) the inherent `[T]::into_vec` method, which is +// required for this macro definition, is not available. Instead use the +// `slice::into_vec` function which is only available with cfg(test) +// NB see the slice::hack module in slice.rs for more information +#[cfg(test)] +macro_rules! vec { + () => ( + $crate::vec::Vec::new() + ); + ($elem:expr; $n:expr) => ( + $crate::vec::from_elem($elem, $n) + ); + ($($x:expr),*) => ( + $crate::slice::into_vec(box [$($x),*]) + ); + ($($x:expr,)*) => (vec![$($x),*]) +} + +/// Creates a `String` using interpolation of runtime expressions. +/// +/// The first argument `format!` receives is a format string. This must be a string +/// literal. The power of the formatting string is in the `{}`s contained. +/// +/// Additional parameters passed to `format!` replace the `{}`s within the +/// formatting string in the order given unless named or positional parameters +/// are used; see [`std::fmt`] for more information. +/// +/// A common use for `format!` is concatenation and interpolation of strings. +/// The same convention is used with [`print!`] and [`write!`] macros, +/// depending on the intended destination of the string. +/// +/// To convert a single value to a string, use the [`to_string`] method. This +/// will use the [`Display`] formatting trait. +/// +/// [`std::fmt`]: ../std/fmt/index.html +/// [`print!`]: ../std/macro.print.html +/// [`write!`]: core::write +/// [`to_string`]: crate::string::ToString +/// [`Display`]: core::fmt::Display +/// +/// # Panics +/// +/// `format!` panics if a formatting trait implementation returns an error. +/// This indicates an incorrect implementation +/// since `fmt::Write for String` never returns an error itself. +/// +/// # Examples +/// +/// ``` +/// format!("test"); +/// format!("hello {}", "world!"); +/// format!("x = {}, y = {y}", 10, y = 30); +/// ``` +#[macro_export] +#[stable(feature = "rust1", since = "1.0.0")] +macro_rules! format { + ($($arg:tt)*) => {{ + let res = $crate::fmt::format($crate::__export::format_args!($($arg)*)); + res + }} +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/prelude/mod.rs b/gcc/testsuite/rust/alloc/alloc/src/prelude/mod.rs new file mode 100644 index 000000000000..0534ad3edc79 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/prelude/mod.rs @@ -0,0 +1,15 @@ +//! The alloc Prelude +//! +//! The purpose of this module is to alleviate imports of commonly-used +//! items of the `alloc` crate by adding a glob import to the top of modules: +//! +//! ``` +//! # #![allow(unused_imports)] +//! #![feature(alloc_prelude)] +//! extern crate alloc; +//! use alloc::prelude::v1::*; +//! ``` + +#![unstable(feature = "alloc_prelude", issue = "58935")] + +pub mod v1; diff --git a/gcc/testsuite/rust/alloc/alloc/src/prelude/v1.rs b/gcc/testsuite/rust/alloc/alloc/src/prelude/v1.rs new file mode 100644 index 000000000000..6a53b4ca1f6c --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/prelude/v1.rs @@ -0,0 +1,14 @@ +//! The first version of the prelude of `alloc` crate. +//! +//! See the [module-level documentation](../index.html) for more. + +#![unstable(feature = "alloc_prelude", issue = "58935")] + +#[unstable(feature = "alloc_prelude", issue = "58935")] +pub use crate::borrow::ToOwned; +#[unstable(feature = "alloc_prelude", issue = "58935")] +pub use crate::boxed::Box; +#[unstable(feature = "alloc_prelude", issue = "58935")] +pub use crate::string::{String, ToString}; +#[unstable(feature = "alloc_prelude", issue = "58935")] +pub use crate::vec::Vec; diff --git a/gcc/testsuite/rust/alloc/alloc/src/raw_vec.rs b/gcc/testsuite/rust/alloc/alloc/src/raw_vec.rs new file mode 100644 index 000000000000..5778834e27c5 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/raw_vec.rs @@ -0,0 +1,578 @@ +#![unstable( + feature = "raw_vec_internals", + reason = "implementation detail", + issue = "none" +)] +#![doc(hidden)] + +use crate::gccrs_core_prelude::*; +use crate::collections::TryReserveError::AllocError; //gccrs + +use core::alloc::LayoutErr; +use core::cmp; +use core::intrinsics; +use core::mem::{self, ManuallyDrop, MaybeUninit}; +use core::ops::Drop; +use core::ptr::{self, NonNull, Unique}; +use core::slice; + +use crate::alloc::{handle_alloc_error, AllocRef, Global, Layout}; +use crate::boxed::Box; +use crate::collections::TryReserveError::{self, *}; + +#[cfg(test)] +mod tests; + +enum AllocInit { + /// The contents of the new memory are uninitialized. + Uninitialized, + /// The new memory is guaranteed to be zeroed. + Zeroed, +} + +/// A low-level utility for more ergonomically allocating, reallocating, and deallocating +/// a buffer of memory on the heap without having to worry about all the corner cases +/// involved. This type is excellent for building your own data structures like Vec and VecDeque. +/// In particular: +/// +/// * Produces `Unique::dangling()` on zero-sized types. +/// * Produces `Unique::dangling()` on zero-length allocations. +/// * Avoids freeing `Unique::dangling()`. +/// * Catches all overflows in capacity computations (promotes them to "capacity overflow" panics). +/// * Guards against 32-bit systems allocating more than isize::MAX bytes. +/// * Guards against overflowing your length. +/// * Calls `handle_alloc_error` for fallible allocations. +/// * Contains a `ptr::Unique` and thus endows the user with all related benefits. +/// * Uses the excess returned from the allocator to use the largest available capacity. +/// +/// This type does not in anyway inspect the memory that it manages. When dropped it *will* +/// free its memory, but it *won't* try to drop its contents. It is up to the user of `RawVec` +/// to handle the actual things *stored* inside of a `RawVec`. +/// +/// Note that the excess of a zero-sized types is always infinite, so `capacity()` always returns +/// `usize::MAX`. This means that you need to be careful when round-tripping this type with a +/// `Box<[T]>`, since `capacity()` won't yield the length. +#[allow(missing_debug_implementations)] +pub struct RawVec { + ptr: Unique, + cap: usize, + alloc: A, +} + +impl RawVec { + /// HACK(Centril): This exists because `#[unstable]` `const fn`s needn't conform + /// to `min_const_fn` and so they cannot be called in `min_const_fn`s either. + /// + /// If you change `RawVec::new` or dependencies, please take care to not + /// introduce anything that would truly violate `min_const_fn`. + /// + /// NOTE: We could avoid this hack and check conformance with some + /// `#[rustc_force_min_const_fn]` attribute which requires conformance + /// with `min_const_fn` but does not necessarily allow calling it in + /// `stable(...) const fn` / user code not enabling `foo` when + /// `#[rustc_const_unstable(feature = "foo", issue = "01234")]` is present. + pub const NEW: Self = Self::new(); + + /// Creates the biggest possible `RawVec` (on the system heap) + /// without allocating. If `T` has positive size, then this makes a + /// `RawVec` with capacity `0`. If `T` is zero-sized, then it makes a + /// `RawVec` with capacity `usize::MAX`. Useful for implementing + /// delayed allocation. + pub const fn new() -> Self { + Self::new_in(Global) + } + + /// Creates a `RawVec` (on the system heap) with exactly the + /// capacity and alignment requirements for a `[T; capacity]`. This is + /// equivalent to calling `RawVec::new` when `capacity` is `0` or `T` is + /// zero-sized. Note that if `T` is zero-sized this means you will + /// *not* get a `RawVec` with the requested capacity. + /// + /// # Panics + /// + /// Panics if the requested capacity exceeds `isize::MAX` bytes. + /// + /// # Aborts + /// + /// Aborts on OOM. + #[inline] + pub fn with_capacity(capacity: usize) -> Self { + Self::with_capacity_in(capacity, Global) + } + + /// Like `with_capacity`, but guarantees the buffer is zeroed. + #[inline] + pub fn with_capacity_zeroed(capacity: usize) -> Self { + Self::with_capacity_zeroed_in(capacity, Global) + } + + /// Reconstitutes a `RawVec` from a pointer and capacity. + /// + /// # Safety + /// + /// The `ptr` must be allocated (on the system heap), and with the given `capacity`. + /// The `capacity` cannot exceed `isize::MAX` for sized types. (only a concern on 32-bit + /// systems). ZST vectors may have a capacity up to `usize::MAX`. + /// If the `ptr` and `capacity` come from a `RawVec`, then this is guaranteed. + #[inline] + pub unsafe fn from_raw_parts(ptr: *mut T, capacity: usize) -> Self { + unsafe { Self::from_raw_parts_in(ptr, capacity, Global) } + } +} + +impl RawVec { + /// Like `new`, but parameterized over the choice of allocator for + /// the returned `RawVec`. + #[cfg_attr(not(bootstrap), rustc_allow_const_fn_unstable(const_fn))] + #[cfg_attr(bootstrap, allow_internal_unstable(const_fn))] + pub const fn new_in(alloc: A) -> Self { + // `cap: 0` means "unallocated". zero-sized types are ignored. + Self { + ptr: Unique::dangling(), + cap: 0, + alloc, + } + } + + /// Like `with_capacity`, but parameterized over the choice of + /// allocator for the returned `RawVec`. + #[inline] + pub fn with_capacity_in(capacity: usize, alloc: A) -> Self { + Self::allocate_in(capacity, AllocInit::Uninitialized, alloc) + } + + /// Like `with_capacity_zeroed`, but parameterized over the choice + /// of allocator for the returned `RawVec`. + #[inline] + pub fn with_capacity_zeroed_in(capacity: usize, alloc: A) -> Self { + Self::allocate_in(capacity, AllocInit::Zeroed, alloc) + } + + /// Converts a `Box<[T]>` into a `RawVec`. + pub fn from_box(slice: Box<[T], A>) -> Self { + unsafe { + let (slice, alloc) = Box::into_raw_with_alloc(slice); + RawVec::from_raw_parts_in(slice.as_mut_ptr(), slice.len(), alloc) + } + } + + /// Converts the entire buffer into `Box<[MaybeUninit]>` with the specified `len`. + /// + /// Note that this will correctly reconstitute any `cap` changes + /// that may have been performed. (See description of type for details.) + /// + /// # Safety + /// + /// * `len` must be greater than or equal to the most recently requested capacity, and + /// * `len` must be less than or equal to `self.capacity()`. + /// + /// Note, that the requested capacity and `self.capacity()` could differ, as + /// an allocator could overallocate and return a greater memory block than requested. + pub unsafe fn into_box(self, len: usize) -> Box<[MaybeUninit], A> { + // Sanity-check one half of the safety requirement (we cannot check the other half). + debug_assert!( + len <= self.capacity(), + "`len` must be smaller than or equal to `self.capacity()`" + ); + + let me = ManuallyDrop::new(self); + unsafe { + let slice = slice::from_raw_parts_mut(me.ptr() as *mut MaybeUninit, len); + Box::from_raw_in(slice, ptr::read(&me.alloc)) + } + } + + fn allocate_in(capacity: usize, init: AllocInit, alloc: A) -> Self { + if mem::size_of::() == 0 { + Self::new_in(alloc) + } else { + // We avoid `unwrap_or_else` here because it bloats the amount of + // LLVM IR generated. + let layout = match Layout::array::(capacity) { + Ok(layout) => layout, + Err(_) => capacity_overflow(), + }; + match alloc_guard(layout.size()) { + Ok(_) => {} + Err(_) => capacity_overflow(), + } + let result = match init { + AllocInit::Uninitialized => alloc.alloc(layout), + AllocInit::Zeroed => alloc.alloc_zeroed(layout), + }; + let ptr = match result { + Ok(ptr) => ptr, + Err(_) => handle_alloc_error(layout), + }; + + Self { + ptr: unsafe { Unique::new_unchecked(ptr.cast().as_ptr()) }, + cap: Self::capacity_from_bytes(ptr.len()), + alloc, + } + } + } + + /// Reconstitutes a `RawVec` from a pointer, capacity, and allocator. + /// + /// # Safety + /// + /// The `ptr` must be allocated (via the given allocator `alloc`), and with the given + /// `capacity`. + /// The `capacity` cannot exceed `isize::MAX` for sized types. (only a concern on 32-bit + /// systems). ZST vectors may have a capacity up to `usize::MAX`. + /// If the `ptr` and `capacity` come from a `RawVec` created via `alloc`, then this is + /// guaranteed. + #[inline] + pub unsafe fn from_raw_parts_in(ptr: *mut T, capacity: usize, alloc: A) -> Self { + Self { + ptr: unsafe { Unique::new_unchecked(ptr) }, + cap: capacity, + alloc, + } + } + + /// Gets a raw pointer to the start of the allocation. Note that this is + /// `Unique::dangling()` if `capacity == 0` or `T` is zero-sized. In the former case, you must + /// be careful. + pub fn ptr(&self) -> *mut T { + self.ptr.as_ptr() + } + + /// Gets the capacity of the allocation. + /// + /// This will always be `usize::MAX` if `T` is zero-sized. + #[inline(always)] + pub fn capacity(&self) -> usize { + if mem::size_of::() == 0 { + usize::MAX + } else { + self.cap + } + } + + /// Returns a shared reference to the allocator backing this `RawVec`. + pub fn alloc(&self) -> &A { + &self.alloc + } + + /// Returns a mutable reference to the allocator backing this `RawVec`. + pub fn alloc_mut(&mut self) -> &mut A { + &mut self.alloc + } + + fn current_memory(&self) -> Option<(NonNull, Layout)> { + if mem::size_of::() == 0 || self.cap == 0 { + None + } else { + // We have an allocated chunk of memory, so we can bypass runtime + // checks to get our current layout. + unsafe { + let align = mem::align_of::(); + let size = mem::size_of::() * self.cap; + let layout = Layout::from_size_align_unchecked(size, align); + Some((self.ptr.cast().into(), layout)) + } + } + } + + /// Ensures that the buffer contains at least enough space to hold `len + + /// additional` elements. If it doesn't already have enough capacity, will + /// reallocate enough space plus comfortable slack space to get amortized + /// *O*(1) behavior. Will limit this behavior if it would needlessly cause + /// itself to panic. + /// + /// If `len` exceeds `self.capacity()`, this may fail to actually allocate + /// the requested space. This is not really unsafe, but the unsafe + /// code *you* write that relies on the behavior of this function may break. + /// + /// This is ideal for implementing a bulk-push operation like `extend`. + /// + /// # Panics + /// + /// Panics if the new capacity exceeds `isize::MAX` bytes. + /// + /// # Aborts + /// + /// Aborts on OOM. + /// + /// # Examples + /// + /// ``` + /// # #![feature(raw_vec_internals)] + /// # extern crate alloc; + /// # use std::ptr; + /// # use alloc::raw_vec::RawVec; + /// struct MyVec { + /// buf: RawVec, + /// len: usize, + /// } + /// + /// impl MyVec { + /// pub fn push_all(&mut self, elems: &[T]) { + /// self.buf.reserve(self.len, elems.len()); + /// // reserve would have aborted or panicked if the len exceeded + /// // `isize::MAX` so this is safe to do unchecked now. + /// for x in elems { + /// unsafe { + /// ptr::write(self.buf.ptr().add(self.len), x.clone()); + /// } + /// self.len += 1; + /// } + /// } + /// } + /// # fn main() { + /// # let mut vector = MyVec { buf: RawVec::new(), len: 0 }; + /// # vector.push_all(&[1, 3, 5, 7, 9]); + /// # } + /// ``` + pub fn reserve(&mut self, len: usize, additional: usize) { + handle_reserve(self.try_reserve(len, additional)); + } + + /// The same as `reserve`, but returns on errors instead of panicking or aborting. + pub fn try_reserve(&mut self, len: usize, additional: usize) -> Result<(), TryReserveError> { + if self.needs_to_grow(len, additional) { + self.grow_amortized(len, additional) + } else { + Ok(()) + } + } + + /// Ensures that the buffer contains at least enough space to hold `len + + /// additional` elements. If it doesn't already, will reallocate the + /// minimum possible amount of memory necessary. Generally this will be + /// exactly the amount of memory necessary, but in principle the allocator + /// is free to give back more than we asked for. + /// + /// If `len` exceeds `self.capacity()`, this may fail to actually allocate + /// the requested space. This is not really unsafe, but the unsafe code + /// *you* write that relies on the behavior of this function may break. + /// + /// # Panics + /// + /// Panics if the new capacity exceeds `isize::MAX` bytes. + /// + /// # Aborts + /// + /// Aborts on OOM. + pub fn reserve_exact(&mut self, len: usize, additional: usize) { + handle_reserve(self.try_reserve_exact(len, additional)); + } + + /// The same as `reserve_exact`, but returns on errors instead of panicking or aborting. + pub fn try_reserve_exact( + &mut self, + len: usize, + additional: usize, + ) -> Result<(), TryReserveError> { + if self.needs_to_grow(len, additional) { + self.grow_exact(len, additional) + } else { + Ok(()) + } + } + + /// Shrinks the allocation down to the specified amount. If the given amount + /// is 0, actually completely deallocates. + /// + /// # Panics + /// + /// Panics if the given amount is *larger* than the current capacity. + /// + /// # Aborts + /// + /// Aborts on OOM. + pub fn shrink_to_fit(&mut self, amount: usize) { + handle_reserve(self.shrink(amount)); + } +} + +impl RawVec { + /// Returns if the buffer needs to grow to fulfill the needed extra capacity. + /// Mainly used to make inlining reserve-calls possible without inlining `grow`. + fn needs_to_grow(&self, len: usize, additional: usize) -> bool { + additional > self.capacity().wrapping_sub(len) + } + + fn capacity_from_bytes(excess: usize) -> usize { + debug_assert_ne!(mem::size_of::(), 0); + excess / mem::size_of::() + } + + fn set_ptr(&mut self, ptr: NonNull<[u8]>) { + self.ptr = unsafe { Unique::new_unchecked(ptr.cast().as_ptr()) }; + self.cap = Self::capacity_from_bytes(ptr.len()); + } + + // This method is usually instantiated many times. So we want it to be as + // small as possible, to improve compile times. But we also want as much of + // its contents to be statically computable as possible, to make the + // generated code run faster. Therefore, this method is carefully written + // so that all of the code that depends on `T` is within it, while as much + // of the code that doesn't depend on `T` as possible is in functions that + // are non-generic over `T`. + fn grow_amortized(&mut self, len: usize, additional: usize) -> Result<(), TryReserveError> { + // This is ensured by the calling contexts. + debug_assert!(additional > 0); + + if mem::size_of::() == 0 { + // Since we return a capacity of `usize::MAX` when `elem_size` is + // 0, getting to here necessarily means the `RawVec` is overfull. + return Err(CapacityOverflow); + } + + // Nothing we can really do about these checks, sadly. + let required_cap = len.checked_add(additional).ok_or(CapacityOverflow)?; + + // This guarantees exponential growth. The doubling cannot overflow + // because `cap <= isize::MAX` and the type of `cap` is `usize`. + let cap = cmp::max(self.cap * 2, required_cap); + + // Tiny Vecs are dumb. Skip to: + // - 8 if the element size is 1, because any heap allocators is likely + // to round up a request of less than 8 bytes to at least 8 bytes. + // - 4 if elements are moderate-sized (<= 1 KiB). + // - 1 otherwise, to avoid wasting too much space for very short Vecs. + // Note that `min_non_zero_cap` is computed statically. + let elem_size = mem::size_of::(); + let min_non_zero_cap = if elem_size == 1 { + 8 + } else if elem_size <= 1024 { + 4 + } else { + 1 + }; + let cap = cmp::max(min_non_zero_cap, cap); + + let new_layout = Layout::array::(cap); + + // `finish_grow` is non-generic over `T`. + let ptr = finish_grow(new_layout, self.current_memory(), &mut self.alloc)?; + self.set_ptr(ptr); + Ok(()) + } + + // The constraints on this method are much the same as those on + // `grow_amortized`, but this method is usually instantiated less often so + // it's less critical. + fn grow_exact(&mut self, len: usize, additional: usize) -> Result<(), TryReserveError> { + if mem::size_of::() == 0 { + // Since we return a capacity of `usize::MAX` when the type size is + // 0, getting to here necessarily means the `RawVec` is overfull. + return Err(CapacityOverflow); + } + + let cap = len.checked_add(additional).ok_or(CapacityOverflow)?; + let new_layout = Layout::array::(cap); + + // `finish_grow` is non-generic over `T`. + let ptr = finish_grow(new_layout, self.current_memory(), &mut self.alloc)?; + self.set_ptr(ptr); + Ok(()) + } + + fn shrink(&mut self, amount: usize) -> Result<(), TryReserveError> { + assert!( + amount <= self.capacity(), + "Tried to shrink to a larger capacity" + ); + + let (ptr, layout) = if let Some(mem) = self.current_memory() { + mem + } else { + return Ok(()); + }; + let new_size = amount * mem::size_of::(); + + let ptr = unsafe { + let new_layout = Layout::from_size_align_unchecked(new_size, layout.align()); + self.alloc + .shrink(ptr, layout, new_layout) + .map_err(|_| TryReserveError::AllocError { + layout: new_layout, + non_exhaustive: (), + })? + }; + self.set_ptr(ptr); + Ok(()) + } +} + +// This function is outside `RawVec` to minimize compile times. See the comment +// above `RawVec::grow_amortized` for details. (The `A` parameter isn't +// significant, because the number of different `A` types seen in practice is +// much smaller than the number of `T` types.) +fn finish_grow( + new_layout: Result, + current_memory: Option<(NonNull, Layout)>, + alloc: &mut A, +) -> Result, TryReserveError> +where + A: AllocRef, +{ + // Check for the error here to minimize the size of `RawVec::grow_*`. + let new_layout = new_layout.map_err(|_| CapacityOverflow)?; + + alloc_guard(new_layout.size())?; + + let memory = if let Some((ptr, old_layout)) = current_memory { + debug_assert_eq!(old_layout.align(), new_layout.align()); + unsafe { + // The allocator checks for alignment equality + intrinsics::assume(old_layout.align() == new_layout.align()); + alloc.grow(ptr, old_layout, new_layout) + } + } else { + alloc.alloc(new_layout) + }; + + memory.map_err(|_| AllocError { + layout: new_layout, + non_exhaustive: (), + }) +} + +unsafe impl<#[may_dangle] T, A: AllocRef> Drop for RawVec { + /// Frees the memory owned by the `RawVec` *without* trying to drop its contents. + fn drop(&mut self) { + if let Some((ptr, layout)) = self.current_memory() { + unsafe { self.alloc.dealloc(ptr, layout) } + } + } +} + +// Central function for reserve error handling. +#[inline] +fn handle_reserve(result: Result<(), TryReserveError>) { + match result { + Err(CapacityOverflow) => capacity_overflow(), + Err(AllocError { layout, .. }) => handle_alloc_error(layout), + Ok(()) => { /* yay */ } + } +} + +// We need to guarantee the following: +// * We don't ever allocate `> isize::MAX` byte-size objects. +// * We don't overflow `usize::MAX` and actually allocate too little. +// +// On 64-bit we just need to check for overflow since trying to allocate +// `> isize::MAX` bytes will surely fail. On 32-bit and 16-bit we need to add +// an extra guard for this in case we're running on a platform which can use +// all 4GB in user-space, e.g., PAE or x32. + +#[inline] +fn alloc_guard(alloc_size: usize) -> Result<(), TryReserveError> { + if usize::BITS < 64 && alloc_size > isize::MAX as usize { + Err(CapacityOverflow) + } else { + Ok(()) + } +} + +// One central function responsible for reporting capacity overflows. This'll +// ensure that the code generation related to these panics is minimal as there's +// only one location which panics rather than a bunch throughout the module. +fn capacity_overflow() -> ! { + panic!("capacity overflow"); +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/raw_vec/tests.rs b/gcc/testsuite/rust/alloc/alloc/src/raw_vec/tests.rs new file mode 100644 index 000000000000..cb4fe1b46cd7 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/raw_vec/tests.rs @@ -0,0 +1,79 @@ +use super::*; +use std::cell::Cell; + +#[test] +fn allocator_param() { + use crate::alloc::AllocError; + + // Writing a test of integration between third-party + // allocators and `RawVec` is a little tricky because the `RawVec` + // API does not expose fallible allocation methods, so we + // cannot check what happens when allocator is exhausted + // (beyond detecting a panic). + // + // Instead, this just checks that the `RawVec` methods do at + // least go through the Allocator API when it reserves + // storage. + + // A dumb allocator that consumes a fixed amount of fuel + // before allocation attempts start failing. + struct BoundedAlloc { + fuel: Cell, + } + unsafe impl AllocRef for BoundedAlloc { + fn alloc(&self, layout: Layout) -> Result, AllocError> { + let size = layout.size(); + if size > self.fuel.get() { + return Err(AllocError); + } + match Global.alloc(layout) { + ok @ Ok(_) => { + self.fuel.set(self.fuel.get() - size); + ok + } + err @ Err(_) => err, + } + } + unsafe fn dealloc(&self, ptr: NonNull, layout: Layout) { + unsafe { Global.dealloc(ptr, layout) } + } + } + + let a = BoundedAlloc { fuel: Cell::new(500) }; + let mut v: RawVec = RawVec::with_capacity_in(50, a); + assert_eq!(v.alloc.fuel.get(), 450); + v.reserve(50, 150); // (causes a realloc, thus using 50 + 150 = 200 units of fuel) + assert_eq!(v.alloc.fuel.get(), 250); +} + +#[test] +fn reserve_does_not_overallocate() { + { + let mut v: RawVec = RawVec::new(); + // First, `reserve` allocates like `reserve_exact`. + v.reserve(0, 9); + assert_eq!(9, v.capacity()); + } + + { + let mut v: RawVec = RawVec::new(); + v.reserve(0, 7); + assert_eq!(7, v.capacity()); + // 97 is more than double of 7, so `reserve` should work + // like `reserve_exact`. + v.reserve(7, 90); + assert_eq!(97, v.capacity()); + } + + { + let mut v: RawVec = RawVec::new(); + v.reserve(0, 12); + assert_eq!(12, v.capacity()); + v.reserve(12, 3); + // 3 is less than half of 12, so `reserve` must grow + // exponentially. At the time of writing this test grow + // factor is 2, so new capacity is 24, however, grow factor + // of 1.5 is OK too. Hence `>= 18` in assert. + assert!(v.capacity() >= 12 + 12 / 2); + } +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/rc.rs b/gcc/testsuite/rust/alloc/alloc/src/rc.rs new file mode 100644 index 000000000000..6dc55e03a08f --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/rc.rs @@ -0,0 +1,2229 @@ +//! Single-threaded reference-counting pointers. 'Rc' stands for 'Reference +//! Counted'. +//! +//! The type [`Rc`][`Rc`] provides shared ownership of a value of type `T`, +//! allocated in the heap. Invoking [`clone`][clone] on [`Rc`] produces a new +//! pointer to the same allocation in the heap. When the last [`Rc`] pointer to a +//! given allocation is destroyed, the value stored in that allocation (often +//! referred to as "inner value") is also dropped. +//! +//! Shared references in Rust disallow mutation by default, and [`Rc`] +//! is no exception: you cannot generally obtain a mutable reference to +//! something inside an [`Rc`]. If you need mutability, put a [`Cell`] +//! or [`RefCell`] inside the [`Rc`]; see [an example of mutability +//! inside an `Rc`][mutability]. +//! +//! [`Rc`] uses non-atomic reference counting. This means that overhead is very +//! low, but an [`Rc`] cannot be sent between threads, and consequently [`Rc`] +//! does not implement [`Send`][send]. As a result, the Rust compiler +//! will check *at compile time* that you are not sending [`Rc`]s between +//! threads. If you need multi-threaded, atomic reference counting, use +//! [`sync::Arc`][arc]. +//! +//! The [`downgrade`][downgrade] method can be used to create a non-owning +//! [`Weak`] pointer. A [`Weak`] pointer can be [`upgrade`][upgrade]d +//! to an [`Rc`], but this will return [`None`] if the value stored in the allocation has +//! already been dropped. In other words, `Weak` pointers do not keep the value +//! inside the allocation alive; however, they *do* keep the allocation +//! (the backing store for the inner value) alive. +//! +//! A cycle between [`Rc`] pointers will never be deallocated. For this reason, +//! [`Weak`] is used to break cycles. For example, a tree could have strong +//! [`Rc`] pointers from parent nodes to children, and [`Weak`] pointers from +//! children back to their parents. +//! +//! `Rc` automatically dereferences to `T` (via the [`Deref`] trait), +//! so you can call `T`'s methods on a value of type [`Rc`][`Rc`]. To avoid name +//! clashes with `T`'s methods, the methods of [`Rc`][`Rc`] itself are associated +//! functions, called using [fully qualified syntax]: +//! +//! ``` +//! use std::rc::Rc; +//! +//! let my_rc = Rc::new(()); +//! Rc::downgrade(&my_rc); +//! ``` +//! +//! `Rc`'s implementations of traits like `Clone` may also be called using +//! fully qualified syntax. Some people prefer to use fully qualified syntax, +//! while others prefer using method-call syntax. +//! +//! ``` +//! use std::rc::Rc; +//! +//! let rc = Rc::new(()); +//! // Method-call syntax +//! let rc2 = rc.clone(); +//! // Fully qualified syntax +//! let rc3 = Rc::clone(&rc); +//! ``` +//! +//! [`Weak`][`Weak`] does not auto-dereference to `T`, because the inner value may have +//! already been dropped. +//! +//! # Cloning references +//! +//! Creating a new reference to the same allocation as an existing reference counted pointer +//! is done using the `Clone` trait implemented for [`Rc`][`Rc`] and [`Weak`][`Weak`]. +//! +//! ``` +//! use std::rc::Rc; +//! +//! let foo = Rc::new(vec![1.0, 2.0, 3.0]); +//! // The two syntaxes below are equivalent. +//! let a = foo.clone(); +//! let b = Rc::clone(&foo); +//! // a and b both point to the same memory location as foo. +//! ``` +//! +//! The `Rc::clone(&from)` syntax is the most idiomatic because it conveys more explicitly +//! the meaning of the code. In the example above, this syntax makes it easier to see that +//! this code is creating a new reference rather than copying the whole content of foo. +//! +//! # Examples +//! +//! Consider a scenario where a set of `Gadget`s are owned by a given `Owner`. +//! We want to have our `Gadget`s point to their `Owner`. We can't do this with +//! unique ownership, because more than one gadget may belong to the same +//! `Owner`. [`Rc`] allows us to share an `Owner` between multiple `Gadget`s, +//! and have the `Owner` remain allocated as long as any `Gadget` points at it. +//! +//! ``` +//! use std::rc::Rc; +//! +//! struct Owner { +//! name: String, +//! // ...other fields +//! } +//! +//! struct Gadget { +//! id: i32, +//! owner: Rc, +//! // ...other fields +//! } +//! +//! fn main() { +//! // Create a reference-counted `Owner`. +//! let gadget_owner: Rc = Rc::new( +//! Owner { +//! name: "Gadget Man".to_string(), +//! } +//! ); +//! +//! // Create `Gadget`s belonging to `gadget_owner`. Cloning the `Rc` +//! // gives us a new pointer to the same `Owner` allocation, incrementing +//! // the reference count in the process. +//! let gadget1 = Gadget { +//! id: 1, +//! owner: Rc::clone(&gadget_owner), +//! }; +//! let gadget2 = Gadget { +//! id: 2, +//! owner: Rc::clone(&gadget_owner), +//! }; +//! +//! // Dispose of our local variable `gadget_owner`. +//! drop(gadget_owner); +//! +//! // Despite dropping `gadget_owner`, we're still able to print out the name +//! // of the `Owner` of the `Gadget`s. This is because we've only dropped a +//! // single `Rc`, not the `Owner` it points to. As long as there are +//! // other `Rc` pointing at the same `Owner` allocation, it will remain +//! // live. The field projection `gadget1.owner.name` works because +//! // `Rc` automatically dereferences to `Owner`. +//! println!("Gadget {} owned by {}", gadget1.id, gadget1.owner.name); +//! println!("Gadget {} owned by {}", gadget2.id, gadget2.owner.name); +//! +//! // At the end of the function, `gadget1` and `gadget2` are destroyed, and +//! // with them the last counted references to our `Owner`. Gadget Man now +//! // gets destroyed as well. +//! } +//! ``` +//! +//! If our requirements change, and we also need to be able to traverse from +//! `Owner` to `Gadget`, we will run into problems. An [`Rc`] pointer from `Owner` +//! to `Gadget` introduces a cycle. This means that their +//! reference counts can never reach 0, and the allocation will never be destroyed: +//! a memory leak. In order to get around this, we can use [`Weak`] +//! pointers. +//! +//! Rust actually makes it somewhat difficult to produce this loop in the first +//! place. In order to end up with two values that point at each other, one of +//! them needs to be mutable. This is difficult because [`Rc`] enforces +//! memory safety by only giving out shared references to the value it wraps, +//! and these don't allow direct mutation. We need to wrap the part of the +//! value we wish to mutate in a [`RefCell`], which provides *interior +//! mutability*: a method to achieve mutability through a shared reference. +//! [`RefCell`] enforces Rust's borrowing rules at runtime. +//! +//! ``` +//! use std::rc::Rc; +//! use std::rc::Weak; +//! use std::cell::RefCell; +//! +//! struct Owner { +//! name: String, +//! gadgets: RefCell>>, +//! // ...other fields +//! } +//! +//! struct Gadget { +//! id: i32, +//! owner: Rc, +//! // ...other fields +//! } +//! +//! fn main() { +//! // Create a reference-counted `Owner`. Note that we've put the `Owner`'s +//! // vector of `Gadget`s inside a `RefCell` so that we can mutate it through +//! // a shared reference. +//! let gadget_owner: Rc = Rc::new( +//! Owner { +//! name: "Gadget Man".to_string(), +//! gadgets: RefCell::new(vec![]), +//! } +//! ); +//! +//! // Create `Gadget`s belonging to `gadget_owner`, as before. +//! let gadget1 = Rc::new( +//! Gadget { +//! id: 1, +//! owner: Rc::clone(&gadget_owner), +//! } +//! ); +//! let gadget2 = Rc::new( +//! Gadget { +//! id: 2, +//! owner: Rc::clone(&gadget_owner), +//! } +//! ); +//! +//! // Add the `Gadget`s to their `Owner`. +//! { +//! let mut gadgets = gadget_owner.gadgets.borrow_mut(); +//! gadgets.push(Rc::downgrade(&gadget1)); +//! gadgets.push(Rc::downgrade(&gadget2)); +//! +//! // `RefCell` dynamic borrow ends here. +//! } +//! +//! // Iterate over our `Gadget`s, printing their details out. +//! for gadget_weak in gadget_owner.gadgets.borrow().iter() { +//! +//! // `gadget_weak` is a `Weak`. Since `Weak` pointers can't +//! // guarantee the allocation still exists, we need to call +//! // `upgrade`, which returns an `Option>`. +//! // +//! // In this case we know the allocation still exists, so we simply +//! // `unwrap` the `Option`. In a more complicated program, you might +//! // need graceful error handling for a `None` result. +//! +//! let gadget = gadget_weak.upgrade().unwrap(); +//! println!("Gadget {} owned by {}", gadget.id, gadget.owner.name); +//! } +//! +//! // At the end of the function, `gadget_owner`, `gadget1`, and `gadget2` +//! // are destroyed. There are now no strong (`Rc`) pointers to the +//! // gadgets, so they are destroyed. This zeroes the reference count on +//! // Gadget Man, so he gets destroyed as well. +//! } +//! ``` +//! +//! [clone]: Clone::clone +//! [`Cell`]: core::cell::Cell +//! [`RefCell`]: core::cell::RefCell +//! [send]: core::marker::Send +//! [arc]: crate::sync::Arc +//! [`Deref`]: core::ops::Deref +//! [downgrade]: Rc::downgrade +//! [upgrade]: Weak::upgrade +//! [mutability]: core::cell#introducing-mutability-inside-of-something-immutable + +#![stable(feature = "rust1", since = "1.0.0")] + +use crate::gccrs_core_prelude::*; + +#[cfg(not(test))] +use crate::boxed::Box; +#[cfg(test)] +use std::boxed::Box; + +use core::any::Any; +use core::borrow; +use core::cell::Cell; +use core::cmp::Ordering; +use core::convert::{From, TryFrom}; +use core::fmt; +use core::hash::{Hash, Hasher}; +use core::intrinsics::abort; +use core::iter; +use core::marker::{self, PhantomData, Unpin, Unsize}; +use core::mem::{self, align_of_val_raw, forget, size_of_val}; +use core::ops::{CoerceUnsized, Deref, DispatchFromDyn, Receiver}; +use core::pin::Pin; +use core::ptr::{self, NonNull}; +use core::slice::from_raw_parts_mut; + +use crate::alloc::{box_free, handle_alloc_error, AllocError, AllocRef, Global, Layout}; +use crate::borrow::{Cow, ToOwned}; +use crate::string::String; +use crate::vec::Vec; + +#[cfg(test)] +mod tests; + +// This is repr(C) to future-proof against possible field-reordering, which +// would interfere with otherwise safe [into|from]_raw() of transmutable +// inner types. +#[repr(C)] +struct RcBox { + strong: Cell, + weak: Cell, + value: T, +} + +/// A single-threaded reference-counting pointer. 'Rc' stands for 'Reference +/// Counted'. +/// +/// See the [module-level documentation](./index.html) for more details. +/// +/// The inherent methods of `Rc` are all associated functions, which means +/// that you have to call them as e.g., [`Rc::get_mut(&mut value)`][get_mut] instead of +/// `value.get_mut()`. This avoids conflicts with methods of the inner type `T`. +/// +/// [get_mut]: Rc::get_mut +#[cfg_attr(not(test), rustc_diagnostic_item = "Rc")] +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Rc { + ptr: NonNull>, + phantom: PhantomData>, +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl !marker::Send for Rc {} +#[stable(feature = "rust1", since = "1.0.0")] +impl !marker::Sync for Rc {} + +#[unstable(feature = "coerce_unsized", issue = "27732")] +impl, U: ?Sized> CoerceUnsized> for Rc {} + +#[unstable(feature = "dispatch_from_dyn", issue = "none")] +impl, U: ?Sized> DispatchFromDyn> for Rc {} + +impl Rc { + #[inline(always)] + fn inner(&self) -> &RcBox { + // This unsafety is ok because while this Rc is alive we're guaranteed + // that the inner pointer is valid. + unsafe { self.ptr.as_ref() } + } + + fn from_inner(ptr: NonNull>) -> Self { + Self { ptr, phantom: PhantomData } + } + + unsafe fn from_ptr(ptr: *mut RcBox) -> Self { + Self::from_inner(unsafe { NonNull::new_unchecked(ptr) }) + } +} + +impl Rc { + /// Constructs a new `Rc`. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn new(value: T) -> Rc { + // There is an implicit weak pointer owned by all the strong + // pointers, which ensures that the weak destructor never frees + // the allocation while the strong destructor is running, even + // if the weak pointer is stored inside the strong one. + Self::from_inner( + Box::leak(box RcBox { strong: Cell::new(1), weak: Cell::new(1), value }).into(), + ) + } + + /// Constructs a new `Rc` using a weak reference to itself. Attempting + /// to upgrade the weak reference before this function returns will result + /// in a `None` value. However, the weak reference may be cloned freely and + /// stored for use at a later time. + #[unstable(feature = "arc_new_cyclic", issue = "75861")] + pub fn new_cyclic(data_fn: impl FnOnce(&Weak) -> T) -> Rc { + // Construct the inner in the "uninitialized" state with a single + // weak reference. + let uninit_ptr: NonNull<_> = Box::leak(box RcBox { + strong: Cell::new(0), + weak: Cell::new(1), + value: mem::MaybeUninit::::uninit(), + }) + .into(); + + let init_ptr: NonNull> = uninit_ptr.cast(); + + let weak = Weak { ptr: init_ptr }; + + // It's important we don't give up ownership of the weak pointer, or + // else the memory might be freed by the time `data_fn` returns. If + // we really wanted to pass ownership, we could create an additional + // weak pointer for ourselves, but this would result in additional + // updates to the weak reference count which might not be necessary + // otherwise. + let data = data_fn(&weak); + + unsafe { + let inner = init_ptr.as_ptr(); + ptr::write(&raw mut (*inner).value, data); + + let prev_value = (*inner).strong.get(); + debug_assert_eq!(prev_value, 0, "No prior strong references should exist"); + (*inner).strong.set(1); + } + + let strong = Rc::from_inner(init_ptr); + + // Strong references should collectively own a shared weak reference, + // so don't run the destructor for our old weak reference. + mem::forget(weak); + strong + } + + /// Constructs a new `Rc` with uninitialized contents. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// #![feature(get_mut_unchecked)] + /// + /// use std::rc::Rc; + /// + /// let mut five = Rc::::new_uninit(); + /// + /// let five = unsafe { + /// // Deferred initialization: + /// Rc::get_mut_unchecked(&mut five).as_mut_ptr().write(5); + /// + /// five.assume_init() + /// }; + /// + /// assert_eq!(*five, 5) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_uninit() -> Rc> { + unsafe { + Rc::from_ptr(Rc::allocate_for_layout( + Layout::new::(), + |layout| Global.alloc(layout), + |mem| mem as *mut RcBox>, + )) + } + } + + /// Constructs a new `Rc` with uninitialized contents, with the memory + /// being filled with `0` bytes. + /// + /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and + /// incorrect usage of this method. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// use std::rc::Rc; + /// + /// let zero = Rc::::new_zeroed(); + /// let zero = unsafe { zero.assume_init() }; + /// + /// assert_eq!(*zero, 0) + /// ``` + /// + /// [zeroed]: mem::MaybeUninit::zeroed + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_zeroed() -> Rc> { + unsafe { + Rc::from_ptr(Rc::allocate_for_layout( + Layout::new::(), + |layout| Global.alloc_zeroed(layout), + |mem| mem as *mut RcBox>, + )) + } + } + + /// Constructs a new `Pin>`. If `T` does not implement `Unpin`, then + /// `value` will be pinned in memory and unable to be moved. + #[stable(feature = "pin", since = "1.33.0")] + pub fn pin(value: T) -> Pin> { + unsafe { Pin::new_unchecked(Rc::new(value)) } + } + + /// Returns the inner value, if the `Rc` has exactly one strong reference. + /// + /// Otherwise, an [`Err`] is returned with the same `Rc` that was + /// passed in. + /// + /// This will succeed even if there are outstanding weak references. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let x = Rc::new(3); + /// assert_eq!(Rc::try_unwrap(x), Ok(3)); + /// + /// let x = Rc::new(4); + /// let _y = Rc::clone(&x); + /// assert_eq!(*Rc::try_unwrap(x).unwrap_err(), 4); + /// ``` + #[inline] + #[stable(feature = "rc_unique", since = "1.4.0")] + pub fn try_unwrap(this: Self) -> Result { + if Rc::strong_count(&this) == 1 { + unsafe { + let val = ptr::read(&*this); // copy the contained object + + // Indicate to Weaks that they can't be promoted by decrementing + // the strong count, and then remove the implicit "strong weak" + // pointer while also handling drop logic by just crafting a + // fake Weak. + this.inner().dec_strong(); + let _weak = Weak { ptr: this.ptr }; + forget(this); + Ok(val) + } + } else { + Err(this) + } + } +} + +impl Rc<[T]> { + /// Constructs a new reference-counted slice with uninitialized contents. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// #![feature(get_mut_unchecked)] + /// + /// use std::rc::Rc; + /// + /// let mut values = Rc::<[u32]>::new_uninit_slice(3); + /// + /// let values = unsafe { + /// // Deferred initialization: + /// Rc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1); + /// Rc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2); + /// Rc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3); + /// + /// values.assume_init() + /// }; + /// + /// assert_eq!(*values, [1, 2, 3]) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_uninit_slice(len: usize) -> Rc<[mem::MaybeUninit]> { + unsafe { Rc::from_ptr(Rc::allocate_for_slice(len)) } + } + + /// Constructs a new reference-counted slice with uninitialized contents, with the memory being + /// filled with `0` bytes. + /// + /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and + /// incorrect usage of this method. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// use std::rc::Rc; + /// + /// let values = Rc::<[u32]>::new_zeroed_slice(3); + /// let values = unsafe { values.assume_init() }; + /// + /// assert_eq!(*values, [0, 0, 0]) + /// ``` + /// + /// [zeroed]: mem::MaybeUninit::zeroed + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_zeroed_slice(len: usize) -> Rc<[mem::MaybeUninit]> { + unsafe { + Rc::from_ptr(Rc::allocate_for_layout( + Layout::array::(len).unwrap(), + |layout| Global.alloc_zeroed(layout), + |mem| { + ptr::slice_from_raw_parts_mut(mem as *mut T, len) + as *mut RcBox<[mem::MaybeUninit]> + }, + )) + } + } +} + +impl Rc> { + /// Converts to `Rc`. + /// + /// # Safety + /// + /// As with [`MaybeUninit::assume_init`], + /// it is up to the caller to guarantee that the inner value + /// really is in an initialized state. + /// Calling this when the content is not yet fully initialized + /// causes immediate undefined behavior. + /// + /// [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// #![feature(get_mut_unchecked)] + /// + /// use std::rc::Rc; + /// + /// let mut five = Rc::::new_uninit(); + /// + /// let five = unsafe { + /// // Deferred initialization: + /// Rc::get_mut_unchecked(&mut five).as_mut_ptr().write(5); + /// + /// five.assume_init() + /// }; + /// + /// assert_eq!(*five, 5) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + #[inline] + pub unsafe fn assume_init(self) -> Rc { + Rc::from_inner(mem::ManuallyDrop::new(self).ptr.cast()) + } +} + +impl Rc<[mem::MaybeUninit]> { + /// Converts to `Rc<[T]>`. + /// + /// # Safety + /// + /// As with [`MaybeUninit::assume_init`], + /// it is up to the caller to guarantee that the inner value + /// really is in an initialized state. + /// Calling this when the content is not yet fully initialized + /// causes immediate undefined behavior. + /// + /// [`MaybeUninit::assume_init`]: mem::MaybeUninit::assume_init + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// #![feature(get_mut_unchecked)] + /// + /// use std::rc::Rc; + /// + /// let mut values = Rc::<[u32]>::new_uninit_slice(3); + /// + /// let values = unsafe { + /// // Deferred initialization: + /// Rc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1); + /// Rc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2); + /// Rc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3); + /// + /// values.assume_init() + /// }; + /// + /// assert_eq!(*values, [1, 2, 3]) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + #[inline] + pub unsafe fn assume_init(self) -> Rc<[T]> { + unsafe { Rc::from_ptr(mem::ManuallyDrop::new(self).ptr.as_ptr() as _) } + } +} + +impl Rc { + /// Consumes the `Rc`, returning the wrapped pointer. + /// + /// To avoid a memory leak the pointer must be converted back to an `Rc` using + /// [`Rc::from_raw`][from_raw]. + /// + /// [from_raw]: Rc::from_raw + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let x = Rc::new("hello".to_owned()); + /// let x_ptr = Rc::into_raw(x); + /// assert_eq!(unsafe { &*x_ptr }, "hello"); + /// ``` + #[stable(feature = "rc_raw", since = "1.17.0")] + pub fn into_raw(this: Self) -> *const T { + let ptr = Self::as_ptr(&this); + mem::forget(this); + ptr + } + + /// Provides a raw pointer to the data. + /// + /// The counts are not affected in any way and the `Rc` is not consumed. The pointer is valid + /// for as long there are strong counts in the `Rc`. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let x = Rc::new("hello".to_owned()); + /// let y = Rc::clone(&x); + /// let x_ptr = Rc::as_ptr(&x); + /// assert_eq!(x_ptr, Rc::as_ptr(&y)); + /// assert_eq!(unsafe { &*x_ptr }, "hello"); + /// ``` + #[stable(feature = "weak_into_raw", since = "1.45.0")] + pub fn as_ptr(this: &Self) -> *const T { + let ptr: *mut RcBox = NonNull::as_ptr(this.ptr); + + // SAFETY: This cannot go through Deref::deref or Rc::inner because + // this is required to retain raw/mut provenance such that e.g. `get_mut` can + // write through the pointer after the Rc is recovered through `from_raw`. + unsafe { &raw const (*ptr).value } + } + + /// Constructs an `Rc` from a raw pointer. + /// + /// The raw pointer must have been previously returned by a call to + /// [`Rc::into_raw`][into_raw] where `U` must have the same size + /// and alignment as `T`. This is trivially true if `U` is `T`. + /// Note that if `U` is not `T` but has the same size and alignment, this is + /// basically like transmuting references of different types. See + /// [`mem::transmute`][transmute] for more information on what + /// restrictions apply in this case. + /// + /// The user of `from_raw` has to make sure a specific value of `T` is only + /// dropped once. + /// + /// This function is unsafe because improper use may lead to memory unsafety, + /// even if the returned `Rc` is never accessed. + /// + /// [into_raw]: Rc::into_raw + /// [transmute]: core::mem::transmute + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let x = Rc::new("hello".to_owned()); + /// let x_ptr = Rc::into_raw(x); + /// + /// unsafe { + /// // Convert back to an `Rc` to prevent leak. + /// let x = Rc::from_raw(x_ptr); + /// assert_eq!(&*x, "hello"); + /// + /// // Further calls to `Rc::from_raw(x_ptr)` would be memory-unsafe. + /// } + /// + /// // The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling! + /// ``` + #[stable(feature = "rc_raw", since = "1.17.0")] + pub unsafe fn from_raw(ptr: *const T) -> Self { + let offset = unsafe { data_offset(ptr) }; + + // Reverse the offset to find the original RcBox. + let fake_ptr = ptr as *mut RcBox; + let rc_ptr = unsafe { set_data_ptr(fake_ptr, (ptr as *mut u8).offset(-offset)) }; + + unsafe { Self::from_ptr(rc_ptr) } + } + + /// Creates a new [`Weak`] pointer to this allocation. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// + /// let weak_five = Rc::downgrade(&five); + /// ``` + #[stable(feature = "rc_weak", since = "1.4.0")] + pub fn downgrade(this: &Self) -> Weak { + this.inner().inc_weak(); + // Make sure we do not create a dangling Weak + debug_assert!(!is_dangling(this.ptr)); + Weak { ptr: this.ptr } + } + + /// Gets the number of [`Weak`] pointers to this allocation. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// let _weak_five = Rc::downgrade(&five); + /// + /// assert_eq!(1, Rc::weak_count(&five)); + /// ``` + #[inline] + #[stable(feature = "rc_counts", since = "1.15.0")] + pub fn weak_count(this: &Self) -> usize { + this.inner().weak() - 1 + } + + /// Gets the number of strong (`Rc`) pointers to this allocation. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// let _also_five = Rc::clone(&five); + /// + /// assert_eq!(2, Rc::strong_count(&five)); + /// ``` + #[inline] + #[stable(feature = "rc_counts", since = "1.15.0")] + pub fn strong_count(this: &Self) -> usize { + this.inner().strong() + } + + /// Returns `true` if there are no other `Rc` or [`Weak`] pointers to + /// this allocation. + #[inline] + fn is_unique(this: &Self) -> bool { + Rc::weak_count(this) == 0 && Rc::strong_count(this) == 1 + } + + /// Returns a mutable reference into the given `Rc`, if there are + /// no other `Rc` or [`Weak`] pointers to the same allocation. + /// + /// Returns [`None`] otherwise, because it is not safe to + /// mutate a shared value. + /// + /// See also [`make_mut`][make_mut], which will [`clone`][clone] + /// the inner value when there are other pointers. + /// + /// [make_mut]: Rc::make_mut + /// [clone]: Clone::clone + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let mut x = Rc::new(3); + /// *Rc::get_mut(&mut x).unwrap() = 4; + /// assert_eq!(*x, 4); + /// + /// let _y = Rc::clone(&x); + /// assert!(Rc::get_mut(&mut x).is_none()); + /// ``` + #[inline] + #[stable(feature = "rc_unique", since = "1.4.0")] + pub fn get_mut(this: &mut Self) -> Option<&mut T> { + if Rc::is_unique(this) { unsafe { Some(Rc::get_mut_unchecked(this)) } } else { None } + } + + /// Returns a mutable reference into the given `Rc`, + /// without any check. + /// + /// See also [`get_mut`], which is safe and does appropriate checks. + /// + /// [`get_mut`]: Rc::get_mut + /// + /// # Safety + /// + /// Any other `Rc` or [`Weak`] pointers to the same allocation must not be dereferenced + /// for the duration of the returned borrow. + /// This is trivially the case if no such pointers exist, + /// for example immediately after `Rc::new`. + /// + /// # Examples + /// + /// ``` + /// #![feature(get_mut_unchecked)] + /// + /// use std::rc::Rc; + /// + /// let mut x = Rc::new(String::new()); + /// unsafe { + /// Rc::get_mut_unchecked(&mut x).push_str("foo") + /// } + /// assert_eq!(*x, "foo"); + /// ``` + #[inline] + #[unstable(feature = "get_mut_unchecked", issue = "63292")] + pub unsafe fn get_mut_unchecked(this: &mut Self) -> &mut T { + // We are careful to *not* create a reference covering the "count" fields, as + // this would conflict with accesses to the reference counts (e.g. by `Weak`). + unsafe { &mut (*this.ptr.as_ptr()).value } + } + + #[inline] + #[stable(feature = "ptr_eq", since = "1.17.0")] + /// Returns `true` if the two `Rc`s point to the same allocation + /// (in a vein similar to [`ptr::eq`]). + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// let same_five = Rc::clone(&five); + /// let other_five = Rc::new(5); + /// + /// assert!(Rc::ptr_eq(&five, &same_five)); + /// assert!(!Rc::ptr_eq(&five, &other_five)); + /// ``` + /// + /// [`ptr::eq`]: core::ptr::eq + pub fn ptr_eq(this: &Self, other: &Self) -> bool { + this.ptr.as_ptr() == other.ptr.as_ptr() + } +} + +impl Rc { + /// Makes a mutable reference into the given `Rc`. + /// + /// If there are other `Rc` pointers to the same allocation, then `make_mut` will + /// [`clone`] the inner value to a new allocation to ensure unique ownership. This is also + /// referred to as clone-on-write. + /// + /// If there are no other `Rc` pointers to this allocation, then [`Weak`] + /// pointers to this allocation will be disassociated. + /// + /// See also [`get_mut`], which will fail rather than cloning. + /// + /// [`clone`]: Clone::clone + /// [`get_mut`]: Rc::get_mut + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let mut data = Rc::new(5); + /// + /// *Rc::make_mut(&mut data) += 1; // Won't clone anything + /// let mut other_data = Rc::clone(&data); // Won't clone inner data + /// *Rc::make_mut(&mut data) += 1; // Clones inner data + /// *Rc::make_mut(&mut data) += 1; // Won't clone anything + /// *Rc::make_mut(&mut other_data) *= 2; // Won't clone anything + /// + /// // Now `data` and `other_data` point to different allocations. + /// assert_eq!(*data, 8); + /// assert_eq!(*other_data, 12); + /// ``` + /// + /// [`Weak`] pointers will be disassociated: + /// + /// ``` + /// use std::rc::Rc; + /// + /// let mut data = Rc::new(75); + /// let weak = Rc::downgrade(&data); + /// + /// assert!(75 == *data); + /// assert!(75 == *weak.upgrade().unwrap()); + /// + /// *Rc::make_mut(&mut data) += 1; + /// + /// assert!(76 == *data); + /// assert!(weak.upgrade().is_none()); + /// ``` + #[inline] + #[stable(feature = "rc_unique", since = "1.4.0")] + pub fn make_mut(this: &mut Self) -> &mut T { + if Rc::strong_count(this) != 1 { + // Gotta clone the data, there are other Rcs + *this = Rc::new((**this).clone()) + } else if Rc::weak_count(this) != 0 { + // Can just steal the data, all that's left is Weaks + unsafe { + let mut swap = Rc::new(ptr::read(&this.ptr.as_ref().value)); + mem::swap(this, &mut swap); + swap.inner().dec_strong(); + // Remove implicit strong-weak ref (no need to craft a fake + // Weak here -- we know other Weaks can clean up for us) + swap.inner().dec_weak(); + forget(swap); + } + } + // This unsafety is ok because we're guaranteed that the pointer + // returned is the *only* pointer that will ever be returned to T. Our + // reference count is guaranteed to be 1 at this point, and we required + // the `Rc` itself to be `mut`, so we're returning the only possible + // reference to the allocation. + unsafe { &mut this.ptr.as_mut().value } + } +} + +impl Rc { + #[inline] + #[stable(feature = "rc_downcast", since = "1.29.0")] + /// Attempt to downcast the `Rc` to a concrete type. + /// + /// # Examples + /// + /// ``` + /// use std::any::Any; + /// use std::rc::Rc; + /// + /// fn print_if_string(value: Rc) { + /// if let Ok(string) = value.downcast::() { + /// println!("String ({}): {}", string.len(), string); + /// } + /// } + /// + /// let my_string = "Hello World".to_string(); + /// print_if_string(Rc::new(my_string)); + /// print_if_string(Rc::new(0i8)); + /// ``` + pub fn downcast(self) -> Result, Rc> { + if (*self).is::() { + let ptr = self.ptr.cast::>(); + forget(self); + Ok(Rc::from_inner(ptr)) + } else { + Err(self) + } + } +} + +impl Rc { + /// Allocates an `RcBox` with sufficient space for + /// a possibly-unsized inner value where the value has the layout provided. + /// + /// The function `mem_to_rcbox` is called with the data pointer + /// and must return back a (potentially fat)-pointer for the `RcBox`. + unsafe fn allocate_for_layout( + value_layout: Layout, + allocate: impl FnOnce(Layout) -> Result, AllocError>, + mem_to_rcbox: impl FnOnce(*mut u8) -> *mut RcBox, + ) -> *mut RcBox { + // Calculate layout using the given value layout. + // Previously, layout was calculated on the expression + // `&*(ptr as *const RcBox)`, but this created a misaligned + // reference (see #54908). + let layout = Layout::new::>().extend(value_layout).unwrap().0.pad_to_align(); + + // Allocate for the layout. + let ptr = allocate(layout).unwrap_or_else(|_| handle_alloc_error(layout)); + + // Initialize the RcBox + let inner = mem_to_rcbox(ptr.as_non_null_ptr().as_ptr()); + unsafe { + debug_assert_eq!(Layout::for_value(&*inner), layout); + + ptr::write(&mut (*inner).strong, Cell::new(1)); + ptr::write(&mut (*inner).weak, Cell::new(1)); + } + + inner + } + + /// Allocates an `RcBox` with sufficient space for an unsized inner value + unsafe fn allocate_for_ptr(ptr: *const T) -> *mut RcBox { + // Allocate for the `RcBox` using the given value. + unsafe { + Self::allocate_for_layout( + Layout::for_value(&*ptr), + |layout| Global.alloc(layout), + |mem| set_data_ptr(ptr as *mut T, mem) as *mut RcBox, + ) + } + } + + fn from_box(v: Box) -> Rc { + unsafe { + let (box_unique, alloc) = Box::into_unique(v); + let bptr = box_unique.as_ptr(); + + let value_size = size_of_val(&*bptr); + let ptr = Self::allocate_for_ptr(bptr); + + // Copy value as bytes + ptr::copy_nonoverlapping( + bptr as *const T as *const u8, + &mut (*ptr).value as *mut _ as *mut u8, + value_size, + ); + + // Free the allocation without dropping its contents + box_free(box_unique, alloc); + + Self::from_ptr(ptr) + } + } +} + +impl Rc<[T]> { + /// Allocates an `RcBox<[T]>` with the given length. + unsafe fn allocate_for_slice(len: usize) -> *mut RcBox<[T]> { + unsafe { + Self::allocate_for_layout( + Layout::array::(len).unwrap(), + |layout| Global.alloc(layout), + |mem| ptr::slice_from_raw_parts_mut(mem as *mut T, len) as *mut RcBox<[T]>, + ) + } + } +} + +/// Sets the data pointer of a `?Sized` raw pointer. +/// +/// For a slice/trait object, this sets the `data` field and leaves the rest +/// unchanged. For a sized raw pointer, this simply sets the pointer. +unsafe fn set_data_ptr(mut ptr: *mut T, data: *mut U) -> *mut T { + unsafe { + ptr::write(&mut ptr as *mut _ as *mut *mut u8, data as *mut u8); + } + ptr +} + +impl Rc<[T]> { + /// Copy elements from slice into newly allocated Rc<\[T\]> + /// + /// Unsafe because the caller must either take ownership or bind `T: Copy` + unsafe fn copy_from_slice(v: &[T]) -> Rc<[T]> { + unsafe { + let ptr = Self::allocate_for_slice(v.len()); + ptr::copy_nonoverlapping(v.as_ptr(), &mut (*ptr).value as *mut [T] as *mut T, v.len()); + Self::from_ptr(ptr) + } + } + + /// Constructs an `Rc<[T]>` from an iterator known to be of a certain size. + /// + /// Behavior is undefined should the size be wrong. + unsafe fn from_iter_exact(iter: impl iter::Iterator, len: usize) -> Rc<[T]> { + // Panic guard while cloning T elements. + // In the event of a panic, elements that have been written + // into the new RcBox will be dropped, then the memory freed. + struct Guard { + mem: NonNull, + elems: *mut T, + layout: Layout, + n_elems: usize, + } + + impl Drop for Guard { + fn drop(&mut self) { + unsafe { + let slice = from_raw_parts_mut(self.elems, self.n_elems); + ptr::drop_in_place(slice); + + Global.dealloc(self.mem, self.layout); + } + } + } + + unsafe { + let ptr = Self::allocate_for_slice(len); + + let mem = ptr as *mut _ as *mut u8; + let layout = Layout::for_value(&*ptr); + + // Pointer to first element + let elems = &mut (*ptr).value as *mut [T] as *mut T; + + let mut guard = Guard { mem: NonNull::new_unchecked(mem), elems, layout, n_elems: 0 }; + + for (i, item) in iter.enumerate() { + ptr::write(elems.add(i), item); + guard.n_elems += 1; + } + + // All clear. Forget the guard so it doesn't free the new RcBox. + forget(guard); + + Self::from_ptr(ptr) + } + } +} + +/// Specialization trait used for `From<&[T]>`. +trait RcFromSlice { + fn from_slice(slice: &[T]) -> Self; +} + +impl RcFromSlice for Rc<[T]> { + #[inline] + default fn from_slice(v: &[T]) -> Self { + unsafe { Self::from_iter_exact(v.iter().cloned(), v.len()) } + } +} + +impl RcFromSlice for Rc<[T]> { + #[inline] + fn from_slice(v: &[T]) -> Self { + unsafe { Rc::copy_from_slice(v) } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Deref for Rc { + type Target = T; + + #[inline(always)] + fn deref(&self) -> &T { + &self.inner().value + } +} + +#[unstable(feature = "receiver_trait", issue = "none")] +impl Receiver for Rc {} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl<#[may_dangle] T: ?Sized> Drop for Rc { + /// Drops the `Rc`. + /// + /// This will decrement the strong reference count. If the strong reference + /// count reaches zero then the only other references (if any) are + /// [`Weak`], so we `drop` the inner value. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// struct Foo; + /// + /// impl Drop for Foo { + /// fn drop(&mut self) { + /// println!("dropped!"); + /// } + /// } + /// + /// let foo = Rc::new(Foo); + /// let foo2 = Rc::clone(&foo); + /// + /// drop(foo); // Doesn't print anything + /// drop(foo2); // Prints "dropped!" + /// ``` + fn drop(&mut self) { + unsafe { + self.inner().dec_strong(); + if self.inner().strong() == 0 { + // destroy the contained object + ptr::drop_in_place(Self::get_mut_unchecked(self)); + + // remove the implicit "strong weak" pointer now that we've + // destroyed the contents. + self.inner().dec_weak(); + + if self.inner().weak() == 0 { + Global.dealloc(self.ptr.cast(), Layout::for_value(self.ptr.as_ref())); + } + } + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Rc { + /// Makes a clone of the `Rc` pointer. + /// + /// This creates another pointer to the same allocation, increasing the + /// strong reference count. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// + /// let _ = Rc::clone(&five); + /// ``` + #[inline] + fn clone(&self) -> Rc { + self.inner().inc_strong(); + Self::from_inner(self.ptr) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for Rc { + /// Creates a new `Rc`, with the `Default` value for `T`. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let x: Rc = Default::default(); + /// assert_eq!(*x, 0); + /// ``` + #[inline] + fn default() -> Rc { + Rc::new(Default::default()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +trait RcEqIdent { + fn eq(&self, other: &Rc) -> bool; + fn ne(&self, other: &Rc) -> bool; +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl RcEqIdent for Rc { + #[inline] + default fn eq(&self, other: &Rc) -> bool { + **self == **other + } + + #[inline] + default fn ne(&self, other: &Rc) -> bool { + **self != **other + } +} + +// Hack to allow specializing on `Eq` even though `Eq` has a method. +#[rustc_unsafe_specialization_marker] +pub(crate) trait MarkerEq: PartialEq {} + +impl MarkerEq for T {} + +/// We're doing this specialization here, and not as a more general optimization on `&T`, because it +/// would otherwise add a cost to all equality checks on refs. We assume that `Rc`s are used to +/// store large values, that are slow to clone, but also heavy to check for equality, causing this +/// cost to pay off more easily. It's also more likely to have two `Rc` clones, that point to +/// the same value, than two `&T`s. +/// +/// We can only do this when `T: Eq` as a `PartialEq` might be deliberately irreflexive. +#[stable(feature = "rust1", since = "1.0.0")] +impl RcEqIdent for Rc { + #[inline] + fn eq(&self, other: &Rc) -> bool { + Rc::ptr_eq(self, other) || **self == **other + } + + #[inline] + fn ne(&self, other: &Rc) -> bool { + !Rc::ptr_eq(self, other) && **self != **other + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialEq for Rc { + /// Equality for two `Rc`s. + /// + /// Two `Rc`s are equal if their inner values are equal, even if they are + /// stored in different allocation. + /// + /// If `T` also implements `Eq` (implying reflexivity of equality), + /// two `Rc`s that point to the same allocation are + /// always equal. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// + /// assert!(five == Rc::new(5)); + /// ``` + #[inline] + fn eq(&self, other: &Rc) -> bool { + RcEqIdent::eq(self, other) + } + + /// Inequality for two `Rc`s. + /// + /// Two `Rc`s are unequal if their inner values are unequal. + /// + /// If `T` also implements `Eq` (implying reflexivity of equality), + /// two `Rc`s that point to the same allocation are + /// never unequal. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// + /// assert!(five != Rc::new(6)); + /// ``` + #[inline] + fn ne(&self, other: &Rc) -> bool { + RcEqIdent::ne(self, other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Eq for Rc {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialOrd for Rc { + /// Partial comparison for two `Rc`s. + /// + /// The two are compared by calling `partial_cmp()` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// use std::cmp::Ordering; + /// + /// let five = Rc::new(5); + /// + /// assert_eq!(Some(Ordering::Less), five.partial_cmp(&Rc::new(6))); + /// ``` + #[inline(always)] + fn partial_cmp(&self, other: &Rc) -> Option { + (**self).partial_cmp(&**other) + } + + /// Less-than comparison for two `Rc`s. + /// + /// The two are compared by calling `<` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// + /// assert!(five < Rc::new(6)); + /// ``` + #[inline(always)] + fn lt(&self, other: &Rc) -> bool { + **self < **other + } + + /// 'Less than or equal to' comparison for two `Rc`s. + /// + /// The two are compared by calling `<=` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// + /// assert!(five <= Rc::new(5)); + /// ``` + #[inline(always)] + fn le(&self, other: &Rc) -> bool { + **self <= **other + } + + /// Greater-than comparison for two `Rc`s. + /// + /// The two are compared by calling `>` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// + /// assert!(five > Rc::new(4)); + /// ``` + #[inline(always)] + fn gt(&self, other: &Rc) -> bool { + **self > **other + } + + /// 'Greater than or equal to' comparison for two `Rc`s. + /// + /// The two are compared by calling `>=` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// + /// assert!(five >= Rc::new(5)); + /// ``` + #[inline(always)] + fn ge(&self, other: &Rc) -> bool { + **self >= **other + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Ord for Rc { + /// Comparison for two `Rc`s. + /// + /// The two are compared by calling `cmp()` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// use std::cmp::Ordering; + /// + /// let five = Rc::new(5); + /// + /// assert_eq!(Ordering::Less, five.cmp(&Rc::new(6))); + /// ``` + #[inline] + fn cmp(&self, other: &Rc) -> Ordering { + (**self).cmp(&**other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Hash for Rc { + fn hash(&self, state: &mut H) { + (**self).hash(state); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Display for Rc { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Display::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Debug for Rc { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Debug::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Pointer for Rc { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Pointer::fmt(&(&**self as *const T), f) + } +} + +#[stable(feature = "from_for_ptrs", since = "1.6.0")] +impl From for Rc { + fn from(t: T) -> Self { + Rc::new(t) + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From<&[T]> for Rc<[T]> { + #[inline] + fn from(v: &[T]) -> Rc<[T]> { + >::from_slice(v) + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From<&str> for Rc { + #[inline] + fn from(v: &str) -> Rc { + let rc = Rc::<[u8]>::from(v.as_bytes()); + unsafe { Rc::from_raw(Rc::into_raw(rc) as *const str) } + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From for Rc { + #[inline] + fn from(v: String) -> Rc { + Rc::from(&v[..]) + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From> for Rc { + #[inline] + fn from(v: Box) -> Rc { + Rc::from_box(v) + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From> for Rc<[T]> { + #[inline] + fn from(mut v: Vec) -> Rc<[T]> { + unsafe { + let rc = Rc::copy_from_slice(&v); + + // Allow the Vec to free its memory, but not destroy its contents + v.set_len(0); + + rc + } + } +} + +#[stable(feature = "shared_from_cow", since = "1.45.0")] +impl<'a, B> From> for Rc +where + B: ToOwned + ?Sized, + Rc: From<&'a B> + From, +{ + #[inline] + fn from(cow: Cow<'a, B>) -> Rc { + match cow { + Cow::Borrowed(s) => Rc::from(s), + Cow::Owned(s) => Rc::from(s), + } + } +} + +#[stable(feature = "boxed_slice_try_from", since = "1.43.0")] +impl TryFrom> for Rc<[T; N]> { + type Error = Rc<[T]>; + + fn try_from(boxed_slice: Rc<[T]>) -> Result { + if boxed_slice.len() == N { + Ok(unsafe { Rc::from_raw(Rc::into_raw(boxed_slice) as *mut [T; N]) }) + } else { + Err(boxed_slice) + } + } +} + +#[stable(feature = "shared_from_iter", since = "1.37.0")] +impl iter::FromIterator for Rc<[T]> { + /// Takes each element in the `Iterator` and collects it into an `Rc<[T]>`. + /// + /// # Performance characteristics + /// + /// ## The general case + /// + /// In the general case, collecting into `Rc<[T]>` is done by first + /// collecting into a `Vec`. That is, when writing the following: + /// + /// ```rust + /// # use std::rc::Rc; + /// let evens: Rc<[u8]> = (0..10).filter(|&x| x % 2 == 0).collect(); + /// # assert_eq!(&*evens, &[0, 2, 4, 6, 8]); + /// ``` + /// + /// this behaves as if we wrote: + /// + /// ```rust + /// # use std::rc::Rc; + /// let evens: Rc<[u8]> = (0..10).filter(|&x| x % 2 == 0) + /// .collect::>() // The first set of allocations happens here. + /// .into(); // A second allocation for `Rc<[T]>` happens here. + /// # assert_eq!(&*evens, &[0, 2, 4, 6, 8]); + /// ``` + /// + /// This will allocate as many times as needed for constructing the `Vec` + /// and then it will allocate once for turning the `Vec` into the `Rc<[T]>`. + /// + /// ## Iterators of known length + /// + /// When your `Iterator` implements `TrustedLen` and is of an exact size, + /// a single allocation will be made for the `Rc<[T]>`. For example: + /// + /// ```rust + /// # use std::rc::Rc; + /// let evens: Rc<[u8]> = (0..10).collect(); // Just a single allocation happens here. + /// # assert_eq!(&*evens, &*(0..10).collect::>()); + /// ``` + fn from_iter>(iter: I) -> Self { + ToRcSlice::to_rc_slice(iter.into_iter()) + } +} + +/// Specialization trait used for collecting into `Rc<[T]>`. +trait ToRcSlice: Iterator + Sized { + fn to_rc_slice(self) -> Rc<[T]>; +} + +impl> ToRcSlice for I { + default fn to_rc_slice(self) -> Rc<[T]> { + self.collect::>().into() + } +} + +impl> ToRcSlice for I { + fn to_rc_slice(self) -> Rc<[T]> { + // This is the case for a `TrustedLen` iterator. + let (low, high) = self.size_hint(); + if let Some(high) = high { + debug_assert_eq!( + low, + high, + "TrustedLen iterator's size hint is not exact: {:?}", + (low, high) + ); + + unsafe { + // SAFETY: We need to ensure that the iterator has an exact length and we have. + Rc::from_iter_exact(self, low) + } + } else { + // Fall back to normal implementation. + self.collect::>().into() + } + } +} + +/// `Weak` is a version of [`Rc`] that holds a non-owning reference to the +/// managed allocation. The allocation is accessed by calling [`upgrade`] on the `Weak` +/// pointer, which returns an [`Option`]`<`[`Rc`]`>`. +/// +/// Since a `Weak` reference does not count towards ownership, it will not +/// prevent the value stored in the allocation from being dropped, and `Weak` itself makes no +/// guarantees about the value still being present. Thus it may return [`None`] +/// when [`upgrade`]d. Note however that a `Weak` reference *does* prevent the allocation +/// itself (the backing store) from being deallocated. +/// +/// A `Weak` pointer is useful for keeping a temporary reference to the allocation +/// managed by [`Rc`] without preventing its inner value from being dropped. It is also used to +/// prevent circular references between [`Rc`] pointers, since mutual owning references +/// would never allow either [`Rc`] to be dropped. For example, a tree could +/// have strong [`Rc`] pointers from parent nodes to children, and `Weak` +/// pointers from children back to their parents. +/// +/// The typical way to obtain a `Weak` pointer is to call [`Rc::downgrade`]. +/// +/// [`upgrade`]: Weak::upgrade +#[stable(feature = "rc_weak", since = "1.4.0")] +pub struct Weak { + // This is a `NonNull` to allow optimizing the size of this type in enums, + // but it is not necessarily a valid pointer. + // `Weak::new` sets this to `usize::MAX` so that it doesn’t need + // to allocate space on the heap. That's not a value a real pointer + // will ever have because RcBox has alignment at least 2. + // This is only possible when `T: Sized`; unsized `T` never dangle. + ptr: NonNull>, +} + +#[stable(feature = "rc_weak", since = "1.4.0")] +impl !marker::Send for Weak {} +#[stable(feature = "rc_weak", since = "1.4.0")] +impl !marker::Sync for Weak {} + +#[unstable(feature = "coerce_unsized", issue = "27732")] +impl, U: ?Sized> CoerceUnsized> for Weak {} + +#[unstable(feature = "dispatch_from_dyn", issue = "none")] +impl, U: ?Sized> DispatchFromDyn> for Weak {} + +impl Weak { + /// Constructs a new `Weak`, without allocating any memory. + /// Calling [`upgrade`] on the return value always gives [`None`]. + /// + /// [`upgrade`]: Weak::upgrade + /// + /// # Examples + /// + /// ``` + /// use std::rc::Weak; + /// + /// let empty: Weak = Weak::new(); + /// assert!(empty.upgrade().is_none()); + /// ``` + #[stable(feature = "downgraded_weak", since = "1.10.0")] + pub fn new() -> Weak { + Weak { ptr: NonNull::new(usize::MAX as *mut RcBox).expect("MAX is not 0") } + } +} + +pub(crate) fn is_dangling(ptr: NonNull) -> bool { + let address = ptr.as_ptr() as *mut () as usize; + address == usize::MAX +} + +/// Helper type to allow accessing the reference counts without +/// making any assertions about the data field. +struct WeakInner<'a> { + weak: &'a Cell, + strong: &'a Cell, +} + +impl Weak { + /// Returns a raw pointer to the object `T` pointed to by this `Weak`. + /// + /// The pointer is valid only if there are some strong references. The pointer may be dangling, + /// unaligned or even [`null`] otherwise. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// use std::ptr; + /// + /// let strong = Rc::new("hello".to_owned()); + /// let weak = Rc::downgrade(&strong); + /// // Both point to the same object + /// assert!(ptr::eq(&*strong, weak.as_ptr())); + /// // The strong here keeps it alive, so we can still access the object. + /// assert_eq!("hello", unsafe { &*weak.as_ptr() }); + /// + /// drop(strong); + /// // But not any more. We can do weak.as_ptr(), but accessing the pointer would lead to + /// // undefined behaviour. + /// // assert_eq!("hello", unsafe { &*weak.as_ptr() }); + /// ``` + /// + /// [`null`]: core::ptr::null + #[stable(feature = "rc_as_ptr", since = "1.45.0")] + pub fn as_ptr(&self) -> *const T { + let ptr: *mut RcBox = NonNull::as_ptr(self.ptr); + + // SAFETY: we must offset the pointer manually, and said pointer may be + // a dangling weak (usize::MAX) if T is sized. data_offset is safe to call, + // because we know that a pointer to unsized T was derived from a real + // unsized T, as dangling weaks are only created for sized T. wrapping_offset + // is used so that we can use the same code path for the non-dangling + // unsized case and the potentially dangling sized case. + unsafe { + let offset = data_offset(ptr as *mut T); + set_data_ptr(ptr as *mut T, (ptr as *mut u8).wrapping_offset(offset)) + } + } + + /// Consumes the `Weak` and turns it into a raw pointer. + /// + /// This converts the weak pointer into a raw pointer, while still preserving the ownership of + /// one weak reference (the weak count is not modified by this operation). It can be turned + /// back into the `Weak` with [`from_raw`]. + /// + /// The same restrictions of accessing the target of the pointer as with + /// [`as_ptr`] apply. + /// + /// # Examples + /// + /// ``` + /// use std::rc::{Rc, Weak}; + /// + /// let strong = Rc::new("hello".to_owned()); + /// let weak = Rc::downgrade(&strong); + /// let raw = weak.into_raw(); + /// + /// assert_eq!(1, Rc::weak_count(&strong)); + /// assert_eq!("hello", unsafe { &*raw }); + /// + /// drop(unsafe { Weak::from_raw(raw) }); + /// assert_eq!(0, Rc::weak_count(&strong)); + /// ``` + /// + /// [`from_raw`]: Weak::from_raw + /// [`as_ptr`]: Weak::as_ptr + #[stable(feature = "weak_into_raw", since = "1.45.0")] + pub fn into_raw(self) -> *const T { + let result = self.as_ptr(); + mem::forget(self); + result + } + + /// Converts a raw pointer previously created by [`into_raw`] back into `Weak`. + /// + /// This can be used to safely get a strong reference (by calling [`upgrade`] + /// later) or to deallocate the weak count by dropping the `Weak`. + /// + /// It takes ownership of one weak reference (with the exception of pointers created by [`new`], + /// as these don't own anything; the method still works on them). + /// + /// # Safety + /// + /// The pointer must have originated from the [`into_raw`] and must still own its potential + /// weak reference. + /// + /// It is allowed for the strong count to be 0 at the time of calling this. Nevertheless, this + /// takes ownership of one weak reference currently represented as a raw pointer (the weak + /// count is not modified by this operation) and therefore it must be paired with a previous + /// call to [`into_raw`]. + /// + /// # Examples + /// + /// ``` + /// use std::rc::{Rc, Weak}; + /// + /// let strong = Rc::new("hello".to_owned()); + /// + /// let raw_1 = Rc::downgrade(&strong).into_raw(); + /// let raw_2 = Rc::downgrade(&strong).into_raw(); + /// + /// assert_eq!(2, Rc::weak_count(&strong)); + /// + /// assert_eq!("hello", &*unsafe { Weak::from_raw(raw_1) }.upgrade().unwrap()); + /// assert_eq!(1, Rc::weak_count(&strong)); + /// + /// drop(strong); + /// + /// // Decrement the last weak count. + /// assert!(unsafe { Weak::from_raw(raw_2) }.upgrade().is_none()); + /// ``` + /// + /// [`into_raw`]: Weak::into_raw + /// [`upgrade`]: Weak::upgrade + /// [`new`]: Weak::new + #[stable(feature = "weak_into_raw", since = "1.45.0")] + pub unsafe fn from_raw(ptr: *const T) -> Self { + // SAFETY: data_offset is safe to call, because this pointer originates from a Weak. + // See Weak::as_ptr for context on how the input pointer is derived. + let offset = unsafe { data_offset(ptr) }; + + // Reverse the offset to find the original RcBox. + // SAFETY: we use wrapping_offset here because the pointer may be dangling (but only if T: Sized). + let ptr = unsafe { + set_data_ptr(ptr as *mut RcBox, (ptr as *mut u8).wrapping_offset(-offset)) + }; + + // SAFETY: we now have recovered the original Weak pointer, so can create the Weak. + Weak { ptr: unsafe { NonNull::new_unchecked(ptr) } } + } +} + +impl Weak { + /// Attempts to upgrade the `Weak` pointer to an [`Rc`], delaying + /// dropping of the inner value if successful. + /// + /// Returns [`None`] if the inner value has since been dropped. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let five = Rc::new(5); + /// + /// let weak_five = Rc::downgrade(&five); + /// + /// let strong_five: Option> = weak_five.upgrade(); + /// assert!(strong_five.is_some()); + /// + /// // Destroy all strong pointers. + /// drop(strong_five); + /// drop(five); + /// + /// assert!(weak_five.upgrade().is_none()); + /// ``` + #[stable(feature = "rc_weak", since = "1.4.0")] + pub fn upgrade(&self) -> Option> { + let inner = self.inner()?; + if inner.strong() == 0 { + None + } else { + inner.inc_strong(); + Some(Rc::from_inner(self.ptr)) + } + } + + /// Gets the number of strong (`Rc`) pointers pointing to this allocation. + /// + /// If `self` was created using [`Weak::new`], this will return 0. + #[stable(feature = "weak_counts", since = "1.41.0")] + pub fn strong_count(&self) -> usize { + if let Some(inner) = self.inner() { inner.strong() } else { 0 } + } + + /// Gets the number of `Weak` pointers pointing to this allocation. + /// + /// If no strong pointers remain, this will return zero. + #[stable(feature = "weak_counts", since = "1.41.0")] + pub fn weak_count(&self) -> usize { + self.inner() + .map(|inner| { + if inner.strong() > 0 { + inner.weak() - 1 // subtract the implicit weak ptr + } else { + 0 + } + }) + .unwrap_or(0) + } + + /// Returns `None` when the pointer is dangling and there is no allocated `RcBox`, + /// (i.e., when this `Weak` was created by `Weak::new`). + #[inline] + fn inner(&self) -> Option> { + if is_dangling(self.ptr) { + None + } else { + // We are careful to *not* create a reference covering the "data" field, as + // the field may be mutated concurrently (for example, if the last `Rc` + // is dropped, the data field will be dropped in-place). + Some(unsafe { + let ptr = self.ptr.as_ptr(); + WeakInner { strong: &(*ptr).strong, weak: &(*ptr).weak } + }) + } + } + + /// Returns `true` if the two `Weak`s point to the same allocation (similar to + /// [`ptr::eq`]), or if both don't point to any allocation + /// (because they were created with `Weak::new()`). + /// + /// # Notes + /// + /// Since this compares pointers it means that `Weak::new()` will equal each + /// other, even though they don't point to any allocation. + /// + /// # Examples + /// + /// ``` + /// use std::rc::Rc; + /// + /// let first_rc = Rc::new(5); + /// let first = Rc::downgrade(&first_rc); + /// let second = Rc::downgrade(&first_rc); + /// + /// assert!(first.ptr_eq(&second)); + /// + /// let third_rc = Rc::new(5); + /// let third = Rc::downgrade(&third_rc); + /// + /// assert!(!first.ptr_eq(&third)); + /// ``` + /// + /// Comparing `Weak::new`. + /// + /// ``` + /// use std::rc::{Rc, Weak}; + /// + /// let first = Weak::new(); + /// let second = Weak::new(); + /// assert!(first.ptr_eq(&second)); + /// + /// let third_rc = Rc::new(()); + /// let third = Rc::downgrade(&third_rc); + /// assert!(!first.ptr_eq(&third)); + /// ``` + /// + /// [`ptr::eq`]: core::ptr::eq + #[inline] + #[stable(feature = "weak_ptr_eq", since = "1.39.0")] + pub fn ptr_eq(&self, other: &Self) -> bool { + self.ptr.as_ptr() == other.ptr.as_ptr() + } +} + +#[stable(feature = "rc_weak", since = "1.4.0")] +impl Drop for Weak { + /// Drops the `Weak` pointer. + /// + /// # Examples + /// + /// ``` + /// use std::rc::{Rc, Weak}; + /// + /// struct Foo; + /// + /// impl Drop for Foo { + /// fn drop(&mut self) { + /// println!("dropped!"); + /// } + /// } + /// + /// let foo = Rc::new(Foo); + /// let weak_foo = Rc::downgrade(&foo); + /// let other_weak_foo = Weak::clone(&weak_foo); + /// + /// drop(weak_foo); // Doesn't print anything + /// drop(foo); // Prints "dropped!" + /// + /// assert!(other_weak_foo.upgrade().is_none()); + /// ``` + fn drop(&mut self) { + let inner = if let Some(inner) = self.inner() { inner } else { return }; + + inner.dec_weak(); + // the weak count starts at 1, and will only go to zero if all + // the strong pointers have disappeared. + if inner.weak() == 0 { + unsafe { + Global.dealloc(self.ptr.cast(), Layout::for_value(self.ptr.as_ref())); + } + } + } +} + +#[stable(feature = "rc_weak", since = "1.4.0")] +impl Clone for Weak { + /// Makes a clone of the `Weak` pointer that points to the same allocation. + /// + /// # Examples + /// + /// ``` + /// use std::rc::{Rc, Weak}; + /// + /// let weak_five = Rc::downgrade(&Rc::new(5)); + /// + /// let _ = Weak::clone(&weak_five); + /// ``` + #[inline] + fn clone(&self) -> Weak { + if let Some(inner) = self.inner() { + inner.inc_weak() + } + Weak { ptr: self.ptr } + } +} + +#[stable(feature = "rc_weak", since = "1.4.0")] +impl fmt::Debug for Weak { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "(Weak)") + } +} + +#[stable(feature = "downgraded_weak", since = "1.10.0")] +impl Default for Weak { + /// Constructs a new `Weak`, allocating memory for `T` without initializing + /// it. Calling [`upgrade`] on the return value always gives [`None`]. + /// + /// [`None`]: Option + /// [`upgrade`]: Weak::upgrade + /// + /// # Examples + /// + /// ``` + /// use std::rc::Weak; + /// + /// let empty: Weak = Default::default(); + /// assert!(empty.upgrade().is_none()); + /// ``` + fn default() -> Weak { + Weak::new() + } +} + +// NOTE: We checked_add here to deal with mem::forget safely. In particular +// if you mem::forget Rcs (or Weaks), the ref-count can overflow, and then +// you can free the allocation while outstanding Rcs (or Weaks) exist. +// We abort because this is such a degenerate scenario that we don't care about +// what happens -- no real program should ever experience this. +// +// This should have negligible overhead since you don't actually need to +// clone these much in Rust thanks to ownership and move-semantics. + +#[doc(hidden)] +trait RcInnerPtr { + fn weak_ref(&self) -> &Cell; + fn strong_ref(&self) -> &Cell; + + #[inline] + fn strong(&self) -> usize { + self.strong_ref().get() + } + + #[inline] + fn inc_strong(&self) { + let strong = self.strong(); + + // We want to abort on overflow instead of dropping the value. + // The reference count will never be zero when this is called; + // nevertheless, we insert an abort here to hint LLVM at + // an otherwise missed optimization. + if strong == 0 || strong == usize::MAX { + abort(); + } + self.strong_ref().set(strong + 1); + } + + #[inline] + fn dec_strong(&self) { + self.strong_ref().set(self.strong() - 1); + } + + #[inline] + fn weak(&self) -> usize { + self.weak_ref().get() + } + + #[inline] + fn inc_weak(&self) { + let weak = self.weak(); + + // We want to abort on overflow instead of dropping the value. + // The reference count will never be zero when this is called; + // nevertheless, we insert an abort here to hint LLVM at + // an otherwise missed optimization. + if weak == 0 || weak == usize::MAX { + abort(); + } + self.weak_ref().set(weak + 1); + } + + #[inline] + fn dec_weak(&self) { + self.weak_ref().set(self.weak() - 1); + } +} + +impl RcInnerPtr for RcBox { + #[inline(always)] + fn weak_ref(&self) -> &Cell { + &self.weak + } + + #[inline(always)] + fn strong_ref(&self) -> &Cell { + &self.strong + } +} + +impl<'a> RcInnerPtr for WeakInner<'a> { + #[inline(always)] + fn weak_ref(&self) -> &Cell { + self.weak + } + + #[inline(always)] + fn strong_ref(&self) -> &Cell { + self.strong + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl borrow::Borrow for Rc { + fn borrow(&self) -> &T { + &**self + } +} + +#[stable(since = "1.5.0", feature = "smart_ptr_as_ref")] +impl AsRef for Rc { + fn as_ref(&self) -> &T { + &**self + } +} + +#[stable(feature = "pin", since = "1.33.0")] +impl Unpin for Rc {} + +/// Get the offset within an `RcBox` for +/// a payload of type described by a pointer. +/// +/// # Safety +/// +/// This has the same safety requirements as `align_of_val_raw`. In effect: +/// +/// - This function is safe for any argument if `T` is sized, and +/// - if `T` is unsized, the pointer must have appropriate pointer metadata +/// acquired from the real instance that you are getting this offset for. +unsafe fn data_offset(ptr: *const T) -> isize { + // Align the unsized value to the end of the `RcBox`. + // Because it is ?Sized, it will always be the last field in memory. + // Note: This is a detail of the current implementation of the compiler, + // and is not a guaranteed language detail. Do not rely on it outside of std. + unsafe { data_offset_align(align_of_val_raw(ptr)) } +} + +#[inline] +fn data_offset_align(align: usize) -> isize { + let layout = Layout::new::>(); + (layout.size() + layout.padding_needed_for(align)) as isize +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/rc/tests.rs b/gcc/testsuite/rust/alloc/alloc/src/rc/tests.rs new file mode 100644 index 000000000000..2d183a8c88c6 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/rc/tests.rs @@ -0,0 +1,520 @@ +use super::*; + +use std::boxed::Box; +use std::cell::RefCell; +use std::clone::Clone; +use std::convert::{From, TryInto}; +use std::mem::drop; +use std::option::Option::{self, None, Some}; +use std::result::Result::{Err, Ok}; + +#[test] +fn test_clone() { + let x = Rc::new(RefCell::new(5)); + let y = x.clone(); + *x.borrow_mut() = 20; + assert_eq!(*y.borrow(), 20); +} + +#[test] +fn test_simple() { + let x = Rc::new(5); + assert_eq!(*x, 5); +} + +#[test] +fn test_simple_clone() { + let x = Rc::new(5); + let y = x.clone(); + assert_eq!(*x, 5); + assert_eq!(*y, 5); +} + +#[test] +fn test_destructor() { + let x: Rc> = Rc::new(box 5); + assert_eq!(**x, 5); +} + +#[test] +fn test_live() { + let x = Rc::new(5); + let y = Rc::downgrade(&x); + assert!(y.upgrade().is_some()); +} + +#[test] +fn test_dead() { + let x = Rc::new(5); + let y = Rc::downgrade(&x); + drop(x); + assert!(y.upgrade().is_none()); +} + +#[test] +fn weak_self_cyclic() { + struct Cycle { + x: RefCell>>, + } + + let a = Rc::new(Cycle { x: RefCell::new(None) }); + let b = Rc::downgrade(&a.clone()); + *a.x.borrow_mut() = Some(b); + + // hopefully we don't double-free (or leak)... +} + +#[test] +fn is_unique() { + let x = Rc::new(3); + assert!(Rc::is_unique(&x)); + let y = x.clone(); + assert!(!Rc::is_unique(&x)); + drop(y); + assert!(Rc::is_unique(&x)); + let w = Rc::downgrade(&x); + assert!(!Rc::is_unique(&x)); + drop(w); + assert!(Rc::is_unique(&x)); +} + +#[test] +fn test_strong_count() { + let a = Rc::new(0); + assert!(Rc::strong_count(&a) == 1); + let w = Rc::downgrade(&a); + assert!(Rc::strong_count(&a) == 1); + let b = w.upgrade().expect("upgrade of live rc failed"); + assert!(Rc::strong_count(&b) == 2); + assert!(Rc::strong_count(&a) == 2); + drop(w); + drop(a); + assert!(Rc::strong_count(&b) == 1); + let c = b.clone(); + assert!(Rc::strong_count(&b) == 2); + assert!(Rc::strong_count(&c) == 2); +} + +#[test] +fn test_weak_count() { + let a = Rc::new(0); + assert!(Rc::strong_count(&a) == 1); + assert!(Rc::weak_count(&a) == 0); + let w = Rc::downgrade(&a); + assert!(Rc::strong_count(&a) == 1); + assert!(Rc::weak_count(&a) == 1); + drop(w); + assert!(Rc::strong_count(&a) == 1); + assert!(Rc::weak_count(&a) == 0); + let c = a.clone(); + assert!(Rc::strong_count(&a) == 2); + assert!(Rc::weak_count(&a) == 0); + drop(c); +} + +#[test] +fn weak_counts() { + assert_eq!(Weak::weak_count(&Weak::::new()), 0); + assert_eq!(Weak::strong_count(&Weak::::new()), 0); + + let a = Rc::new(0); + let w = Rc::downgrade(&a); + assert_eq!(Weak::strong_count(&w), 1); + assert_eq!(Weak::weak_count(&w), 1); + let w2 = w.clone(); + assert_eq!(Weak::strong_count(&w), 1); + assert_eq!(Weak::weak_count(&w), 2); + assert_eq!(Weak::strong_count(&w2), 1); + assert_eq!(Weak::weak_count(&w2), 2); + drop(w); + assert_eq!(Weak::strong_count(&w2), 1); + assert_eq!(Weak::weak_count(&w2), 1); + let a2 = a.clone(); + assert_eq!(Weak::strong_count(&w2), 2); + assert_eq!(Weak::weak_count(&w2), 1); + drop(a2); + drop(a); + assert_eq!(Weak::strong_count(&w2), 0); + assert_eq!(Weak::weak_count(&w2), 0); + drop(w2); +} + +#[test] +fn try_unwrap() { + let x = Rc::new(3); + assert_eq!(Rc::try_unwrap(x), Ok(3)); + let x = Rc::new(4); + let _y = x.clone(); + assert_eq!(Rc::try_unwrap(x), Err(Rc::new(4))); + let x = Rc::new(5); + let _w = Rc::downgrade(&x); + assert_eq!(Rc::try_unwrap(x), Ok(5)); +} + +#[test] +fn into_from_raw() { + let x = Rc::new(box "hello"); + let y = x.clone(); + + let x_ptr = Rc::into_raw(x); + drop(y); + unsafe { + assert_eq!(**x_ptr, "hello"); + + let x = Rc::from_raw(x_ptr); + assert_eq!(**x, "hello"); + + assert_eq!(Rc::try_unwrap(x).map(|x| *x), Ok("hello")); + } +} + +#[test] +fn test_into_from_raw_unsized() { + use std::fmt::Display; + use std::string::ToString; + + let rc: Rc = Rc::from("foo"); + + let ptr = Rc::into_raw(rc.clone()); + let rc2 = unsafe { Rc::from_raw(ptr) }; + + assert_eq!(unsafe { &*ptr }, "foo"); + assert_eq!(rc, rc2); + + let rc: Rc = Rc::new(123); + + let ptr = Rc::into_raw(rc.clone()); + let rc2 = unsafe { Rc::from_raw(ptr) }; + + assert_eq!(unsafe { &*ptr }.to_string(), "123"); + assert_eq!(rc2.to_string(), "123"); +} + +#[test] +fn into_from_weak_raw() { + let x = Rc::new(box "hello"); + let y = Rc::downgrade(&x); + + let y_ptr = Weak::into_raw(y); + unsafe { + assert_eq!(**y_ptr, "hello"); + + let y = Weak::from_raw(y_ptr); + let y_up = Weak::upgrade(&y).unwrap(); + assert_eq!(**y_up, "hello"); + drop(y_up); + + assert_eq!(Rc::try_unwrap(x).map(|x| *x), Ok("hello")); + } +} + +#[test] +fn get_mut() { + let mut x = Rc::new(3); + *Rc::get_mut(&mut x).unwrap() = 4; + assert_eq!(*x, 4); + let y = x.clone(); + assert!(Rc::get_mut(&mut x).is_none()); + drop(y); + assert!(Rc::get_mut(&mut x).is_some()); + let _w = Rc::downgrade(&x); + assert!(Rc::get_mut(&mut x).is_none()); +} + +#[test] +fn test_cowrc_clone_make_unique() { + let mut cow0 = Rc::new(75); + let mut cow1 = cow0.clone(); + let mut cow2 = cow1.clone(); + + assert!(75 == *Rc::make_mut(&mut cow0)); + assert!(75 == *Rc::make_mut(&mut cow1)); + assert!(75 == *Rc::make_mut(&mut cow2)); + + *Rc::make_mut(&mut cow0) += 1; + *Rc::make_mut(&mut cow1) += 2; + *Rc::make_mut(&mut cow2) += 3; + + assert!(76 == *cow0); + assert!(77 == *cow1); + assert!(78 == *cow2); + + // none should point to the same backing memory + assert!(*cow0 != *cow1); + assert!(*cow0 != *cow2); + assert!(*cow1 != *cow2); +} + +#[test] +fn test_cowrc_clone_unique2() { + let mut cow0 = Rc::new(75); + let cow1 = cow0.clone(); + let cow2 = cow1.clone(); + + assert!(75 == *cow0); + assert!(75 == *cow1); + assert!(75 == *cow2); + + *Rc::make_mut(&mut cow0) += 1; + + assert!(76 == *cow0); + assert!(75 == *cow1); + assert!(75 == *cow2); + + // cow1 and cow2 should share the same contents + // cow0 should have a unique reference + assert!(*cow0 != *cow1); + assert!(*cow0 != *cow2); + assert!(*cow1 == *cow2); +} + +#[test] +fn test_cowrc_clone_weak() { + let mut cow0 = Rc::new(75); + let cow1_weak = Rc::downgrade(&cow0); + + assert!(75 == *cow0); + assert!(75 == *cow1_weak.upgrade().unwrap()); + + *Rc::make_mut(&mut cow0) += 1; + + assert!(76 == *cow0); + assert!(cow1_weak.upgrade().is_none()); +} + +#[test] +fn test_show() { + let foo = Rc::new(75); + assert_eq!(format!("{:?}", foo), "75"); +} + +#[test] +fn test_unsized() { + let foo: Rc<[i32]> = Rc::new([1, 2, 3]); + assert_eq!(foo, foo.clone()); +} + +#[test] +fn test_from_owned() { + let foo = 123; + let foo_rc = Rc::from(foo); + assert!(123 == *foo_rc); +} + +#[test] +fn test_new_weak() { + let foo: Weak = Weak::new(); + assert!(foo.upgrade().is_none()); +} + +#[test] +fn test_ptr_eq() { + let five = Rc::new(5); + let same_five = five.clone(); + let other_five = Rc::new(5); + + assert!(Rc::ptr_eq(&five, &same_five)); + assert!(!Rc::ptr_eq(&five, &other_five)); +} + +#[test] +fn test_from_str() { + let r: Rc = Rc::from("foo"); + + assert_eq!(&r[..], "foo"); +} + +#[test] +fn test_copy_from_slice() { + let s: &[u32] = &[1, 2, 3]; + let r: Rc<[u32]> = Rc::from(s); + + assert_eq!(&r[..], [1, 2, 3]); +} + +#[test] +fn test_clone_from_slice() { + #[derive(Clone, Debug, Eq, PartialEq)] + struct X(u32); + + let s: &[X] = &[X(1), X(2), X(3)]; + let r: Rc<[X]> = Rc::from(s); + + assert_eq!(&r[..], s); +} + +#[test] +#[should_panic] +fn test_clone_from_slice_panic() { + use std::string::{String, ToString}; + + struct Fail(u32, String); + + impl Clone for Fail { + fn clone(&self) -> Fail { + if self.0 == 2 { + panic!(); + } + Fail(self.0, self.1.clone()) + } + } + + let s: &[Fail] = + &[Fail(0, "foo".to_string()), Fail(1, "bar".to_string()), Fail(2, "baz".to_string())]; + + // Should panic, but not cause memory corruption + let _r: Rc<[Fail]> = Rc::from(s); +} + +#[test] +fn test_from_box() { + let b: Box = box 123; + let r: Rc = Rc::from(b); + + assert_eq!(*r, 123); +} + +#[test] +fn test_from_box_str() { + use std::string::String; + + let s = String::from("foo").into_boxed_str(); + let r: Rc = Rc::from(s); + + assert_eq!(&r[..], "foo"); +} + +#[test] +fn test_from_box_slice() { + let s = vec![1, 2, 3].into_boxed_slice(); + let r: Rc<[u32]> = Rc::from(s); + + assert_eq!(&r[..], [1, 2, 3]); +} + +#[test] +fn test_from_box_trait() { + use std::fmt::Display; + use std::string::ToString; + + let b: Box = box 123; + let r: Rc = Rc::from(b); + + assert_eq!(r.to_string(), "123"); +} + +#[test] +fn test_from_box_trait_zero_sized() { + use std::fmt::Debug; + + let b: Box = box (); + let r: Rc = Rc::from(b); + + assert_eq!(format!("{:?}", r), "()"); +} + +#[test] +fn test_from_vec() { + let v = vec![1, 2, 3]; + let r: Rc<[u32]> = Rc::from(v); + + assert_eq!(&r[..], [1, 2, 3]); +} + +#[test] +fn test_downcast() { + use std::any::Any; + + let r1: Rc = Rc::new(i32::MAX); + let r2: Rc = Rc::new("abc"); + + assert!(r1.clone().downcast::().is_err()); + + let r1i32 = r1.downcast::(); + assert!(r1i32.is_ok()); + assert_eq!(r1i32.unwrap(), Rc::new(i32::MAX)); + + assert!(r2.clone().downcast::().is_err()); + + let r2str = r2.downcast::<&'static str>(); + assert!(r2str.is_ok()); + assert_eq!(r2str.unwrap(), Rc::new("abc")); +} + +#[test] +fn test_array_from_slice() { + let v = vec![1, 2, 3]; + let r: Rc<[u32]> = Rc::from(v); + + let a: Result, _> = r.clone().try_into(); + assert!(a.is_ok()); + + let a: Result, _> = r.clone().try_into(); + assert!(a.is_err()); +} + +#[test] +fn test_rc_cyclic_with_zero_refs() { + struct ZeroRefs { + inner: Weak, + } + + let zero_refs = Rc::new_cyclic(|inner| { + assert_eq!(inner.strong_count(), 0); + assert!(inner.upgrade().is_none()); + ZeroRefs { inner: Weak::new() } + }); + + assert_eq!(Rc::strong_count(&zero_refs), 1); + assert_eq!(Rc::weak_count(&zero_refs), 0); + assert_eq!(zero_refs.inner.strong_count(), 0); + assert_eq!(zero_refs.inner.weak_count(), 0); +} + +#[test] +fn test_rc_cyclic_with_one_ref() { + struct OneRef { + inner: Weak, + } + + let one_ref = Rc::new_cyclic(|inner| { + assert_eq!(inner.strong_count(), 0); + assert!(inner.upgrade().is_none()); + OneRef { inner: inner.clone() } + }); + + assert_eq!(Rc::strong_count(&one_ref), 1); + assert_eq!(Rc::weak_count(&one_ref), 1); + + let one_ref2 = Weak::upgrade(&one_ref.inner).unwrap(); + assert!(Rc::ptr_eq(&one_ref, &one_ref2)); + + assert_eq!(one_ref.inner.strong_count(), 2); + assert_eq!(one_ref.inner.weak_count(), 1); +} + +#[test] +fn test_rc_cyclic_with_two_ref() { + struct TwoRefs { + inner: Weak, + inner1: Weak, + } + + let two_refs = Rc::new_cyclic(|inner| { + assert_eq!(inner.strong_count(), 0); + assert!(inner.upgrade().is_none()); + TwoRefs { inner: inner.clone(), inner1: inner.clone() } + }); + + assert_eq!(Rc::strong_count(&two_refs), 1); + assert_eq!(Rc::weak_count(&two_refs), 2); + + let two_ref3 = Weak::upgrade(&two_refs.inner).unwrap(); + assert!(Rc::ptr_eq(&two_refs, &two_ref3)); + + let two_ref2 = Weak::upgrade(&two_refs.inner1).unwrap(); + assert!(Rc::ptr_eq(&two_refs, &two_ref2)); + + assert_eq!(Rc::strong_count(&two_refs), 3); + assert_eq!(Rc::weak_count(&two_refs), 2); +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/slice.rs b/gcc/testsuite/rust/alloc/alloc/src/slice.rs new file mode 100644 index 000000000000..672f604b4a8a --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/slice.rs @@ -0,0 +1,1100 @@ +//! A dynamically-sized view into a contiguous sequence, `[T]`. +//! +//! *[See also the slice primitive type](../../std/primitive.slice.html).* +//! +//! Slices are a view into a block of memory represented as a pointer and a +//! length. +//! +//! ``` +//! // slicing a Vec +//! let vec = vec![1, 2, 3]; +//! let int_slice = &vec[..]; +//! // coercing an array to a slice +//! let str_slice: &[&str] = &["one", "two", "three"]; +//! ``` +//! +//! Slices are either mutable or shared. The shared slice type is `&[T]`, +//! while the mutable slice type is `&mut [T]`, where `T` represents the element +//! type. For example, you can mutate the block of memory that a mutable slice +//! points to: +//! +//! ``` +//! let x = &mut [1, 2, 3]; +//! x[1] = 7; +//! assert_eq!(x, &[1, 7, 3]); +//! ``` +//! +//! Here are some of the things this module contains: +//! +//! ## Structs +//! +//! There are several structs that are useful for slices, such as [`Iter`], which +//! represents iteration over a slice. +//! +//! ## Trait Implementations +//! +//! There are several implementations of common traits for slices. Some examples +//! include: +//! +//! * [`Clone`] +//! * [`Eq`], [`Ord`] - for slices whose element type are [`Eq`] or [`Ord`]. +//! * [`Hash`] - for slices whose element type is [`Hash`]. +//! +//! ## Iteration +//! +//! The slices implement `IntoIterator`. The iterator yields references to the +//! slice elements. +//! +//! ``` +//! let numbers = &[0, 1, 2]; +//! for n in numbers { +//! println!("{} is a number!", n); +//! } +//! ``` +//! +//! The mutable slice yields mutable references to the elements: +//! +//! ``` +//! let mut scores = [7, 8, 9]; +//! for score in &mut scores[..] { +//! *score += 1; +//! } +//! ``` +//! +//! This iterator yields mutable references to the slice's elements, so while +//! the element type of the slice is `i32`, the element type of the iterator is +//! `&mut i32`. +//! +//! * [`.iter`] and [`.iter_mut`] are the explicit methods to return the default +//! iterators. +//! * Further methods that return iterators are [`.split`], [`.splitn`], +//! [`.chunks`], [`.windows`] and more. +//! +//! [`Hash`]: core::hash::Hash +//! [`.iter`]: ../../std/primitive.slice.html#method.iter +//! [`.iter_mut`]: ../../std/primitive.slice.html#method.iter_mut +//! [`.split`]: ../../std/primitive.slice.html#method.split +//! [`.splitn`]: ../../std/primitive.slice.html#method.splitn +//! [`.chunks`]: ../../std/primitive.slice.html#method.chunks +//! [`.windows`]: ../../std/primitive.slice.html#method.windows +#![stable(feature = "rust1", since = "1.0.0")] +// Many of the usings in this module are only used in the test configuration. +// It's cleaner to just turn off the unused_imports warning than to fix them. +#![cfg_attr(test, allow(unused_imports, dead_code))] + +use crate::gccrs_core_prelude::*; + +use core::borrow::{Borrow, BorrowMut}; +use core::cmp::Ordering::{self, Less}; +use core::mem::{self, size_of}; +use core::ptr; + +use crate::borrow::ToOwned; +use crate::boxed::Box; +use crate::vec::Vec; + +#[unstable(feature = "array_chunks", issue = "74985")] +pub use core::slice::ArrayChunks; +#[unstable(feature = "array_chunks", issue = "74985")] +pub use core::slice::ArrayChunksMut; +#[unstable(feature = "array_windows", issue = "75027")] +pub use core::slice::ArrayWindows; +#[stable(feature = "slice_get_slice", since = "1.28.0")] +pub use core::slice::SliceIndex; +#[stable(feature = "from_ref", since = "1.28.0")] +pub use core::slice::{from_mut, from_ref}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::slice::{from_raw_parts, from_raw_parts_mut}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::slice::{Chunks, Windows}; +#[stable(feature = "chunks_exact", since = "1.31.0")] +pub use core::slice::{ChunksExact, ChunksExactMut}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::slice::{ChunksMut, Split, SplitMut}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::slice::{Iter, IterMut}; +#[stable(feature = "rchunks", since = "1.31.0")] +pub use core::slice::{RChunks, RChunksExact, RChunksExactMut, RChunksMut}; +#[stable(feature = "slice_rsplit", since = "1.27.0")] +pub use core::slice::{RSplit, RSplitMut}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::slice::{RSplitN, RSplitNMut, SplitN, SplitNMut}; + +//////////////////////////////////////////////////////////////////////////////// +// Basic slice extension methods +//////////////////////////////////////////////////////////////////////////////// + +// HACK(japaric) needed for the implementation of `vec!` macro during testing +// N.B., see the `hack` module in this file for more details. +#[cfg(test)] +pub use hack::into_vec; + +// HACK(japaric) needed for the implementation of `Vec::clone` during testing +// N.B., see the `hack` module in this file for more details. +#[cfg(test)] +pub use hack::to_vec; + +// HACK(japaric): With cfg(test) `impl [T]` is not available, these three +// functions are actually methods that are in `impl [T]` but not in +// `core::slice::SliceExt` - we need to supply these functions for the +// `test_permutations` test +mod hack { + use crate::core::clone::Clone;//gccrs + + use crate::boxed::Box; + use crate::vec::Vec; + + // We shouldn't add inline attribute to this since this is used in + // `vec!` macro mostly and causes perf regression. See #71204 for + // discussion and perf results. + pub fn into_vec(b: Box<[T]>) -> Vec { + unsafe { + let len = b.len(); + let b = Box::into_raw(b); + Vec::from_raw_parts(b as *mut T, len, len) + } + } + + #[inline] + pub fn to_vec(s: &[T]) -> Vec + where + T: Clone, + { + let mut vec = Vec::with_capacity(s.len()); + vec.extend_from_slice(s); + vec + } +} + +#[lang = "slice_alloc"] +#[cfg(not(test))] +impl [T] { + /// Sorts the slice. + /// + /// This sort is stable (i.e., does not reorder equal elements) and *O*(*n* \* log(*n*)) worst-case. + /// + /// When applicable, unstable sorting is preferred because it is generally faster than stable + /// sorting and it doesn't allocate auxiliary memory. + /// See [`sort_unstable`](#method.sort_unstable). + /// + /// # Current implementation + /// + /// The current algorithm is an adaptive, iterative merge sort inspired by + /// [timsort](https://en.wikipedia.org/wiki/Timsort). + /// It is designed to be very fast in cases where the slice is nearly sorted, or consists of + /// two or more sorted sequences concatenated one after another. + /// + /// Also, it allocates temporary storage half the size of `self`, but for short slices a + /// non-allocating insertion sort is used instead. + /// + /// # Examples + /// + /// ``` + /// let mut v = [-5, 4, 1, -3, 2]; + /// + /// v.sort(); + /// assert!(v == [-5, -3, 1, 2, 4]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn sort(&mut self) + where + T: Ord, + { + merge_sort(self, |a, b| a.lt(b)); + } + + /// Sorts the slice with a comparator function. + /// + /// This sort is stable (i.e., does not reorder equal elements) and *O*(*n* \* log(*n*)) worst-case. + /// + /// The comparator function must define a total ordering for the elements in the slice. If + /// the ordering is not total, the order of the elements is unspecified. An order is a + /// total order if it is (for all `a`, `b` and `c`): + /// + /// * total and antisymmetric: exactly one of `a < b`, `a == b` or `a > b` is true, and + /// * transitive, `a < b` and `b < c` implies `a < c`. The same must hold for both `==` and `>`. + /// + /// For example, while [`f64`] doesn't implement [`Ord`] because `NaN != NaN`, we can use + /// `partial_cmp` as our sort function when we know the slice doesn't contain a `NaN`. + /// + /// ``` + /// let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0]; + /// floats.sort_by(|a, b| a.partial_cmp(b).unwrap()); + /// assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]); + /// ``` + /// + /// When applicable, unstable sorting is preferred because it is generally faster than stable + /// sorting and it doesn't allocate auxiliary memory. + /// See [`sort_unstable_by`](#method.sort_unstable_by). + /// + /// # Current implementation + /// + /// The current algorithm is an adaptive, iterative merge sort inspired by + /// [timsort](https://en.wikipedia.org/wiki/Timsort). + /// It is designed to be very fast in cases where the slice is nearly sorted, or consists of + /// two or more sorted sequences concatenated one after another. + /// + /// Also, it allocates temporary storage half the size of `self`, but for short slices a + /// non-allocating insertion sort is used instead. + /// + /// # Examples + /// + /// ``` + /// let mut v = [5, 4, 1, 3, 2]; + /// v.sort_by(|a, b| a.cmp(b)); + /// assert!(v == [1, 2, 3, 4, 5]); + /// + /// // reverse sorting + /// v.sort_by(|a, b| b.cmp(a)); + /// assert!(v == [5, 4, 3, 2, 1]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn sort_by(&mut self, mut compare: F) + where + F: FnMut(&T, &T) -> Ordering, + { + merge_sort(self, |a, b| compare(a, b) == Less); + } + + /// Sorts the slice with a key extraction function. + /// + /// This sort is stable (i.e., does not reorder equal elements) and *O*(*m* \* *n* \* log(*n*)) + /// worst-case, where the key function is *O*(*m*). + /// + /// For expensive key functions (e.g. functions that are not simple property accesses or + /// basic operations), [`sort_by_cached_key`](#method.sort_by_cached_key) is likely to be + /// significantly faster, as it does not recompute element keys. + /// + /// When applicable, unstable sorting is preferred because it is generally faster than stable + /// sorting and it doesn't allocate auxiliary memory. + /// See [`sort_unstable_by_key`](#method.sort_unstable_by_key). + /// + /// # Current implementation + /// + /// The current algorithm is an adaptive, iterative merge sort inspired by + /// [timsort](https://en.wikipedia.org/wiki/Timsort). + /// It is designed to be very fast in cases where the slice is nearly sorted, or consists of + /// two or more sorted sequences concatenated one after another. + /// + /// Also, it allocates temporary storage half the size of `self`, but for short slices a + /// non-allocating insertion sort is used instead. + /// + /// # Examples + /// + /// ``` + /// let mut v = [-5i32, 4, 1, -3, 2]; + /// + /// v.sort_by_key(|k| k.abs()); + /// assert!(v == [1, 2, -3, 4, -5]); + /// ``` + #[stable(feature = "slice_sort_by_key", since = "1.7.0")] + #[inline] + pub fn sort_by_key(&mut self, mut f: F) + where + F: FnMut(&T) -> K, + K: Ord, + { + merge_sort(self, |a, b| f(a).lt(&f(b))); + } + + /// Sorts the slice with a key extraction function. + /// + /// During sorting, the key function is called only once per element. + /// + /// This sort is stable (i.e., does not reorder equal elements) and *O*(*m* \* *n* + *n* \* log(*n*)) + /// worst-case, where the key function is *O*(*m*). + /// + /// For simple key functions (e.g., functions that are property accesses or + /// basic operations), [`sort_by_key`](#method.sort_by_key) is likely to be + /// faster. + /// + /// # Current implementation + /// + /// The current algorithm is based on [pattern-defeating quicksort][pdqsort] by Orson Peters, + /// which combines the fast average case of randomized quicksort with the fast worst case of + /// heapsort, while achieving linear time on slices with certain patterns. It uses some + /// randomization to avoid degenerate cases, but with a fixed seed to always provide + /// deterministic behavior. + /// + /// In the worst case, the algorithm allocates temporary storage in a `Vec<(K, usize)>` the + /// length of the slice. + /// + /// # Examples + /// + /// ``` + /// let mut v = [-5i32, 4, 32, -3, 2]; + /// + /// v.sort_by_cached_key(|k| k.to_string()); + /// assert!(v == [-3, -5, 2, 32, 4]); + /// ``` + /// + /// [pdqsort]: https://github.com/orlp/pdqsort + #[stable(feature = "slice_sort_by_cached_key", since = "1.34.0")] + #[inline] + pub fn sort_by_cached_key(&mut self, f: F) + where + F: FnMut(&T) -> K, + K: Ord, + { + // Helper macro for indexing our vector by the smallest possible type, to reduce allocation. + macro_rules! sort_by_key { + ($t:ty, $slice:ident, $f:ident) => {{ + let mut indices: Vec<_> = $slice + .iter() + .map($f) + .enumerate() + .map(|(i, k)| (k, i as $t)) + .collect(); + // The elements of `indices` are unique, as they are indexed, so any sort will be + // stable with respect to the original slice. We use `sort_unstable` here because + // it requires less memory allocation. + indices.sort_unstable(); + for i in 0..$slice.len() { + let mut index = indices[i].1; + while (index as usize) < i { + index = indices[index as usize].1; + } + indices[i].1 = index; + $slice.swap(i, index as usize); + } + }}; + } + + let sz_u8 = mem::size_of::<(K, u8)>(); + let sz_u16 = mem::size_of::<(K, u16)>(); + let sz_u32 = mem::size_of::<(K, u32)>(); + let sz_usize = mem::size_of::<(K, usize)>(); + + let len = self.len(); + if len < 2 { + return; + } + if sz_u8 < sz_u16 && len <= (u8::MAX as usize) { + return sort_by_key!(u8, self, f); + } + if sz_u16 < sz_u32 && len <= (u16::MAX as usize) { + return sort_by_key!(u16, self, f); + } + if sz_u32 < sz_usize && len <= (u32::MAX as usize) { + return sort_by_key!(u32, self, f); + } + sort_by_key!(usize, self, f) + } + + /// Copies `self` into a new `Vec`. + /// + /// # Examples + /// + /// ``` + /// let s = [10, 40, 30]; + /// let x = s.to_vec(); + /// // Here, `s` and `x` can be modified independently. + /// ``` + #[rustc_conversion_suggestion] + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn to_vec(&self) -> Vec + where + T: Clone, + { + // N.B., see the `hack` module in this file for more details. + hack::to_vec(self) + } + + /// Converts `self` into a vector without clones or allocation. + /// + /// The resulting vector can be converted back into a box via + /// `Vec`'s `into_boxed_slice` method. + /// + /// # Examples + /// + /// ``` + /// let s: Box<[i32]> = Box::new([10, 40, 30]); + /// let x = s.into_vec(); + /// // `s` cannot be used anymore because it has been converted into `x`. + /// + /// assert_eq!(x, vec![10, 40, 30]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn into_vec(self: Box) -> Vec { + // N.B., see the `hack` module in this file for more details. + hack::into_vec(self) + } + + /// Creates a vector by repeating a slice `n` times. + /// + /// # Panics + /// + /// This function will panic if the capacity would overflow. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// assert_eq!([1, 2].repeat(3), vec![1, 2, 1, 2, 1, 2]); + /// ``` + /// + /// A panic upon overflow: + /// + /// ```should_panic + /// // this will panic at runtime + /// b"0123456789abcdef".repeat(usize::MAX); + /// ``` + #[stable(feature = "repeat_generic_slice", since = "1.40.0")] + pub fn repeat(&self, n: usize) -> Vec + where + T: Copy, + { + if n == 0 { + return Vec::new(); + } + + // If `n` is larger than zero, it can be split as + // `n = 2^expn + rem (2^expn > rem, expn >= 0, rem >= 0)`. + // `2^expn` is the number represented by the leftmost '1' bit of `n`, + // and `rem` is the remaining part of `n`. + + // Using `Vec` to access `set_len()`. + let capacity = self.len().checked_mul(n).expect("capacity overflow"); + let mut buf = Vec::with_capacity(capacity); + + // `2^expn` repetition is done by doubling `buf` `expn`-times. + buf.extend(self); + { + let mut m = n >> 1; + // If `m > 0`, there are remaining bits up to the leftmost '1'. + while m > 0 { + // `buf.extend(buf)`: + unsafe { + ptr::copy_nonoverlapping( + buf.as_ptr(), + (buf.as_mut_ptr() as *mut T).add(buf.len()), + buf.len(), + ); + // `buf` has capacity of `self.len() * n`. + let buf_len = buf.len(); + buf.set_len(buf_len * 2); + } + + m >>= 1; + } + } + + // `rem` (`= n - 2^expn`) repetition is done by copying + // first `rem` repetitions from `buf` itself. + let rem_len = capacity - buf.len(); // `self.len() * rem` + if rem_len > 0 { + // `buf.extend(buf[0 .. rem_len])`: + unsafe { + // This is non-overlapping since `2^expn > rem`. + ptr::copy_nonoverlapping( + buf.as_ptr(), + (buf.as_mut_ptr() as *mut T).add(buf.len()), + rem_len, + ); + // `buf.len() + rem_len` equals to `buf.capacity()` (`= self.len() * n`). + buf.set_len(capacity); + } + } + buf + } + + /// Flattens a slice of `T` into a single value `Self::Output`. + /// + /// # Examples + /// + /// ``` + /// assert_eq!(["hello", "world"].concat(), "helloworld"); + /// assert_eq!([[1, 2], [3, 4]].concat(), [1, 2, 3, 4]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn concat(&self) -> >::Output + where + Self: Concat, + { + Concat::concat(self) + } + + /// Flattens a slice of `T` into a single value `Self::Output`, placing a + /// given separator between each. + /// + /// # Examples + /// + /// ``` + /// assert_eq!(["hello", "world"].join(" "), "hello world"); + /// assert_eq!([[1, 2], [3, 4]].join(&0), [1, 2, 0, 3, 4]); + /// assert_eq!([[1, 2], [3, 4]].join(&[0, 0][..]), [1, 2, 0, 0, 3, 4]); + /// ``` + #[stable(feature = "rename_connect_to_join", since = "1.3.0")] + pub fn join(&self, sep: Separator) -> >::Output + where + Self: Join, + { + Join::join(self, sep) + } + + /// Flattens a slice of `T` into a single value `Self::Output`, placing a + /// given separator between each. + /// + /// # Examples + /// + /// ``` + /// # #![allow(deprecated)] + /// assert_eq!(["hello", "world"].connect(" "), "hello world"); + /// assert_eq!([[1, 2], [3, 4]].connect(&0), [1, 2, 0, 3, 4]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[rustc_deprecated(since = "1.3.0", reason = "renamed to join")] + pub fn connect(&self, sep: Separator) -> >::Output + where + Self: Join, + { + Join::join(self, sep) + } +} + +#[lang = "slice_u8_alloc"] +#[cfg(not(test))] +impl [u8] { + /// Returns a vector containing a copy of this slice where each byte + /// is mapped to its ASCII upper case equivalent. + /// + /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z', + /// but non-ASCII letters are unchanged. + /// + /// To uppercase the value in-place, use [`make_ascii_uppercase`]. + /// + /// [`make_ascii_uppercase`]: u8::make_ascii_uppercase + #[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")] + #[inline] + pub fn to_ascii_uppercase(&self) -> Vec { + let mut me = self.to_vec(); + me.make_ascii_uppercase(); + me + } + + /// Returns a vector containing a copy of this slice where each byte + /// is mapped to its ASCII lower case equivalent. + /// + /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z', + /// but non-ASCII letters are unchanged. + /// + /// To lowercase the value in-place, use [`make_ascii_lowercase`]. + /// + /// [`make_ascii_lowercase`]: u8::make_ascii_lowercase + #[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")] + #[inline] + pub fn to_ascii_lowercase(&self) -> Vec { + let mut me = self.to_vec(); + me.make_ascii_lowercase(); + me + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Extension traits for slices over specific kinds of data +//////////////////////////////////////////////////////////////////////////////// + +/// Helper trait for [`[T]::concat`](../../std/primitive.slice.html#method.concat). +/// +/// Note: the `Item` type parameter is not used in this trait, +/// but it allows impls to be more generic. +/// Without it, we get this error: +/// +/// ```error +/// error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predica +/// --> src/liballoc/slice.rs:608:6 +/// | +/// 608 | impl> Concat for [V] { +/// | ^ unconstrained type parameter +/// ``` +/// +/// This is because there could exist `V` types with multiple `Borrow<[_]>` impls, +/// such that multiple `T` types would apply: +/// +/// ``` +/// # #[allow(dead_code)] +/// pub struct Foo(Vec, Vec); +/// +/// impl std::borrow::Borrow<[u32]> for Foo { +/// fn borrow(&self) -> &[u32] { &self.0 } +/// } +/// +/// impl std::borrow::Borrow<[String]> for Foo { +/// fn borrow(&self) -> &[String] { &self.1 } +/// } +/// ``` +#[unstable(feature = "slice_concat_trait", issue = "27747")] +pub trait Concat { + #[unstable(feature = "slice_concat_trait", issue = "27747")] + /// The resulting type after concatenation + type Output; + + /// Implementation of [`[T]::concat`](../../std/primitive.slice.html#method.concat) + #[unstable(feature = "slice_concat_trait", issue = "27747")] + fn concat(slice: &Self) -> Self::Output; +} + +/// Helper trait for [`[T]::join`](../../std/primitive.slice.html#method.join) +#[unstable(feature = "slice_concat_trait", issue = "27747")] +pub trait Join { + #[unstable(feature = "slice_concat_trait", issue = "27747")] + /// The resulting type after concatenation + type Output; + + /// Implementation of [`[T]::join`](../../std/primitive.slice.html#method.join) + #[unstable(feature = "slice_concat_trait", issue = "27747")] + fn join(slice: &Self, sep: Separator) -> Self::Output; +} + +#[unstable(feature = "slice_concat_ext", issue = "27747")] +impl> Concat for [V] { + type Output = Vec; + + fn concat(slice: &Self) -> Vec { + let size = slice.iter().map(|slice| slice.borrow().len()).sum(); + let mut result = Vec::with_capacity(size); + for v in slice { + result.extend_from_slice(v.borrow()) + } + result + } +} + +#[unstable(feature = "slice_concat_ext", issue = "27747")] +impl> Join<&T> for [V] { + type Output = Vec; + + fn join(slice: &Self, sep: &T) -> Vec { + let mut iter = slice.iter(); + let first = match iter.next() { + Some(first) => first, + None => return vec![], + }; + let size = slice.iter().map(|v| v.borrow().len()).sum::() + slice.len() - 1; + let mut result = Vec::with_capacity(size); + result.extend_from_slice(first.borrow()); + + for v in iter { + result.push(sep.clone()); + result.extend_from_slice(v.borrow()) + } + result + } +} + +#[unstable(feature = "slice_concat_ext", issue = "27747")] +impl> Join<&[T]> for [V] { + type Output = Vec; + + fn join(slice: &Self, sep: &[T]) -> Vec { + let mut iter = slice.iter(); + let first = match iter.next() { + Some(first) => first, + None => return vec![], + }; + let size = + slice.iter().map(|v| v.borrow().len()).sum::() + sep.len() * (slice.len() - 1); + let mut result = Vec::with_capacity(size); + result.extend_from_slice(first.borrow()); + + for v in iter { + result.extend_from_slice(sep); + result.extend_from_slice(v.borrow()) + } + result + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Standard trait implementations for slices +//////////////////////////////////////////////////////////////////////////////// + +#[stable(feature = "rust1", since = "1.0.0")] +impl Borrow<[T]> for Vec { + fn borrow(&self) -> &[T] { + &self[..] + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl BorrowMut<[T]> for Vec { + fn borrow_mut(&mut self) -> &mut [T] { + &mut self[..] + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ToOwned for [T] { + type Owned = Vec; + #[cfg(not(test))] + fn to_owned(&self) -> Vec { + self.to_vec() + } + + #[cfg(test)] + fn to_owned(&self) -> Vec { + hack::to_vec(self) + } + + fn clone_into(&self, target: &mut Vec) { + // drop anything in target that will not be overwritten + target.truncate(self.len()); + + // target.len <= self.len due to the truncate above, so the + // slices here are always in-bounds. + let (init, tail) = self.split_at(target.len()); + + // reuse the contained values' allocations/resources. + target.clone_from_slice(init); + target.extend_from_slice(tail); + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Sorting +//////////////////////////////////////////////////////////////////////////////// + +/// Inserts `v[0]` into pre-sorted sequence `v[1..]` so that whole `v[..]` becomes sorted. +/// +/// This is the integral subroutine of insertion sort. +fn insert_head(v: &mut [T], is_less: &mut F) +where + F: FnMut(&T, &T) -> bool, +{ + if v.len() >= 2 && is_less(&v[1], &v[0]) { + unsafe { + // There are three ways to implement insertion here: + // + // 1. Swap adjacent elements until the first one gets to its final destination. + // However, this way we copy data around more than is necessary. If elements are big + // structures (costly to copy), this method will be slow. + // + // 2. Iterate until the right place for the first element is found. Then shift the + // elements succeeding it to make room for it and finally place it into the + // remaining hole. This is a good method. + // + // 3. Copy the first element into a temporary variable. Iterate until the right place + // for it is found. As we go along, copy every traversed element into the slot + // preceding it. Finally, copy data from the temporary variable into the remaining + // hole. This method is very good. Benchmarks demonstrated slightly better + // performance than with the 2nd method. + // + // All methods were benchmarked, and the 3rd showed best results. So we chose that one. + let mut tmp = mem::ManuallyDrop::new(ptr::read(&v[0])); + + // Intermediate state of the insertion process is always tracked by `hole`, which + // serves two purposes: + // 1. Protects integrity of `v` from panics in `is_less`. + // 2. Fills the remaining hole in `v` in the end. + // + // Panic safety: + // + // If `is_less` panics at any point during the process, `hole` will get dropped and + // fill the hole in `v` with `tmp`, thus ensuring that `v` still holds every object it + // initially held exactly once. + let mut hole = InsertionHole { + src: &mut *tmp, + dest: &mut v[1], + }; + ptr::copy_nonoverlapping(&v[1], &mut v[0], 1); + + for i in 2..v.len() { + if !is_less(&v[i], &*tmp) { + break; + } + ptr::copy_nonoverlapping(&v[i], &mut v[i - 1], 1); + hole.dest = &mut v[i]; + } + // `hole` gets dropped and thus copies `tmp` into the remaining hole in `v`. + } + } + + // When dropped, copies from `src` into `dest`. + struct InsertionHole { + src: *mut T, + dest: *mut T, + } + + impl Drop for InsertionHole { + fn drop(&mut self) { + unsafe { + ptr::copy_nonoverlapping(self.src, self.dest, 1); + } + } + } +} + +/// Merges non-decreasing runs `v[..mid]` and `v[mid..]` using `buf` as temporary storage, and +/// stores the result into `v[..]`. +/// +/// # Safety +/// +/// The two slices must be non-empty and `mid` must be in bounds. Buffer `buf` must be long enough +/// to hold a copy of the shorter slice. Also, `T` must not be a zero-sized type. +unsafe fn merge(v: &mut [T], mid: usize, buf: *mut T, is_less: &mut F) +where + F: FnMut(&T, &T) -> bool, +{ + let len = v.len(); + let v = v.as_mut_ptr(); + let (v_mid, v_end) = unsafe { (v.add(mid), v.add(len)) }; + + // The merge process first copies the shorter run into `buf`. Then it traces the newly copied + // run and the longer run forwards (or backwards), comparing their next unconsumed elements and + // copying the lesser (or greater) one into `v`. + // + // As soon as the shorter run is fully consumed, the process is done. If the longer run gets + // consumed first, then we must copy whatever is left of the shorter run into the remaining + // hole in `v`. + // + // Intermediate state of the process is always tracked by `hole`, which serves two purposes: + // 1. Protects integrity of `v` from panics in `is_less`. + // 2. Fills the remaining hole in `v` if the longer run gets consumed first. + // + // Panic safety: + // + // If `is_less` panics at any point during the process, `hole` will get dropped and fill the + // hole in `v` with the unconsumed range in `buf`, thus ensuring that `v` still holds every + // object it initially held exactly once. + let mut hole; + + if mid <= len - mid { + // The left run is shorter. + unsafe { + ptr::copy_nonoverlapping(v, buf, mid); + hole = MergeHole { + start: buf, + end: buf.add(mid), + dest: v, + }; + } + + // Initially, these pointers point to the beginnings of their arrays. + let left = &mut hole.start; + let mut right = v_mid; + let out = &mut hole.dest; + + while *left < hole.end && right < v_end { + // Consume the lesser side. + // If equal, prefer the left run to maintain stability. + unsafe { + let to_copy = if is_less(&*right, &**left) { + get_and_increment(&mut right) + } else { + get_and_increment(left) + }; + ptr::copy_nonoverlapping(to_copy, get_and_increment(out), 1); + } + } + } else { + // The right run is shorter. + unsafe { + ptr::copy_nonoverlapping(v_mid, buf, len - mid); + hole = MergeHole { + start: buf, + end: buf.add(len - mid), + dest: v_mid, + }; + } + + // Initially, these pointers point past the ends of their arrays. + let left = &mut hole.dest; + let right = &mut hole.end; + let mut out = v_end; + + while v < *left && buf < *right { + // Consume the greater side. + // If equal, prefer the right run to maintain stability. + unsafe { + let to_copy = if is_less(&*right.offset(-1), &*left.offset(-1)) { + decrement_and_get(left) + } else { + decrement_and_get(right) + }; + ptr::copy_nonoverlapping(to_copy, decrement_and_get(&mut out), 1); + } + } + } + // Finally, `hole` gets dropped. If the shorter run was not fully consumed, whatever remains of + // it will now be copied into the hole in `v`. + + unsafe fn get_and_increment(ptr: &mut *mut T) -> *mut T { + let old = *ptr; + *ptr = unsafe { ptr.offset(1) }; + old + } + + unsafe fn decrement_and_get(ptr: &mut *mut T) -> *mut T { + *ptr = unsafe { ptr.offset(-1) }; + *ptr + } + + // When dropped, copies the range `start..end` into `dest..`. + struct MergeHole { + start: *mut T, + end: *mut T, + dest: *mut T, + } + + impl Drop for MergeHole { + fn drop(&mut self) { + // `T` is not a zero-sized type, so it's okay to divide by its size. + let len = (self.end as usize - self.start as usize) / mem::size_of::(); + unsafe { + ptr::copy_nonoverlapping(self.start, self.dest, len); + } + } + } +} + +/// This merge sort borrows some (but not all) ideas from TimSort, which is described in detail +/// [here](http://svn.python.org/projects/python/trunk/Objects/listsort.txt). +/// +/// The algorithm identifies strictly descending and non-descending subsequences, which are called +/// natural runs. There is a stack of pending runs yet to be merged. Each newly found run is pushed +/// onto the stack, and then some pairs of adjacent runs are merged until these two invariants are +/// satisfied: +/// +/// 1. for every `i` in `1..runs.len()`: `runs[i - 1].len > runs[i].len` +/// 2. for every `i` in `2..runs.len()`: `runs[i - 2].len > runs[i - 1].len + runs[i].len` +/// +/// The invariants ensure that the total running time is *O*(*n* \* log(*n*)) worst-case. +fn merge_sort(v: &mut [T], mut is_less: F) +where + F: FnMut(&T, &T) -> bool, +{ + // Slices of up to this length get sorted using insertion sort. + const MAX_INSERTION: usize = 20; + // Very short runs are extended using insertion sort to span at least this many elements. + const MIN_RUN: usize = 10; + + // Sorting has no meaningful behavior on zero-sized types. + if size_of::() == 0 { + return; + } + + let len = v.len(); + + // Short arrays get sorted in-place via insertion sort to avoid allocations. + if len <= MAX_INSERTION { + if len >= 2 { + for i in (0..len - 1).rev() { + insert_head(&mut v[i..], &mut is_less); + } + } + return; + } + + // Allocate a buffer to use as scratch memory. We keep the length 0 so we can keep in it + // shallow copies of the contents of `v` without risking the dtors running on copies if + // `is_less` panics. When merging two sorted runs, this buffer holds a copy of the shorter run, + // which will always have length at most `len / 2`. + let mut buf = Vec::with_capacity(len / 2); + + // In order to identify natural runs in `v`, we traverse it backwards. That might seem like a + // strange decision, but consider the fact that merges more often go in the opposite direction + // (forwards). According to benchmarks, merging forwards is slightly faster than merging + // backwards. To conclude, identifying runs by traversing backwards improves performance. + let mut runs = vec![]; + let mut end = len; + while end > 0 { + // Find the next natural run, and reverse it if it's strictly descending. + let mut start = end - 1; + if start > 0 { + start -= 1; + unsafe { + if is_less(v.get_unchecked(start + 1), v.get_unchecked(start)) { + while start > 0 && is_less(v.get_unchecked(start), v.get_unchecked(start - 1)) { + start -= 1; + } + v[start..end].reverse(); + } else { + while start > 0 && !is_less(v.get_unchecked(start), v.get_unchecked(start - 1)) + { + start -= 1; + } + } + } + } + + // Insert some more elements into the run if it's too short. Insertion sort is faster than + // merge sort on short sequences, so this significantly improves performance. + while start > 0 && end - start < MIN_RUN { + start -= 1; + insert_head(&mut v[start..end], &mut is_less); + } + + // Push this run onto the stack. + runs.push(Run { + start, + len: end - start, + }); + end = start; + + // Merge some pairs of adjacent runs to satisfy the invariants. + while let Some(r) = collapse(&runs) { + let left = runs[r + 1]; + let right = runs[r]; + unsafe { + merge( + &mut v[left.start..right.start + right.len], + left.len, + buf.as_mut_ptr(), + &mut is_less, + ); + } + runs[r] = Run { + start: left.start, + len: left.len + right.len, + }; + runs.remove(r + 1); + } + } + + // Finally, exactly one run must remain in the stack. + debug_assert!(runs.len() == 1 && runs[0].start == 0 && runs[0].len == len); + + // Examines the stack of runs and identifies the next pair of runs to merge. More specifically, + // if `Some(r)` is returned, that means `runs[r]` and `runs[r + 1]` must be merged next. If the + // algorithm should continue building a new run instead, `None` is returned. + // + // TimSort is infamous for its buggy implementations, as described here: + // http://envisage-project.eu/timsort-specification-and-verification/ + // + // The gist of the story is: we must enforce the invariants on the top four runs on the stack. + // Enforcing them on just top three is not sufficient to ensure that the invariants will still + // hold for *all* runs in the stack. + // + // This function correctly checks invariants for the top four runs. Additionally, if the top + // run starts at index 0, it will always demand a merge operation until the stack is fully + // collapsed, in order to complete the sort. + #[inline] + fn collapse(runs: &[Run]) -> Option { + let n = runs.len(); + if n >= 2 + && (runs[n - 1].start == 0 + || runs[n - 2].len <= runs[n - 1].len + || (n >= 3 && runs[n - 3].len <= runs[n - 2].len + runs[n - 1].len) + || (n >= 4 && runs[n - 4].len <= runs[n - 3].len + runs[n - 2].len)) + { + if n >= 3 && runs[n - 3].len < runs[n - 1].len { + Some(n - 3) + } else { + Some(n - 2) + } + } else { + None + } + } + + #[derive(Clone, Copy)] + struct Run { + start: usize, + len: usize, + } +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/str.rs b/gcc/testsuite/rust/alloc/alloc/src/str.rs new file mode 100644 index 000000000000..797b73c3a44a --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/str.rs @@ -0,0 +1,578 @@ +//! Unicode string slices. +//! +//! *[See also the `str` primitive type](../../std/primitive.str.html).* +//! +//! The `&str` type is one of the two main string types, the other being `String`. +//! Unlike its `String` counterpart, its contents are borrowed. +//! +//! # Basic Usage +//! +//! A basic string declaration of `&str` type: +//! +//! ``` +//! let hello_world = "Hello, World!"; +//! ``` +//! +//! Here we have declared a string literal, also known as a string slice. +//! String literals have a static lifetime, which means the string `hello_world` +//! is guaranteed to be valid for the duration of the entire program. +//! We can explicitly specify `hello_world`'s lifetime as well: +//! +//! ``` +//! let hello_world: &'static str = "Hello, world!"; +//! ``` + +#![stable(feature = "rust1", since = "1.0.0")] +// Many of the usings in this module are only used in the test configuration. +// It's cleaner to just turn off the unused_imports warning than to fix them. +#![allow(unused_imports)] + +use crate::gccrs_core_prelude::*; + +use core::borrow::{Borrow, BorrowMut}; +use core::iter::FusedIterator; +use core::mem; +use core::ptr; +use core::str::pattern::{DoubleEndedSearcher, Pattern, ReverseSearcher, Searcher}; +use core::unicode::conversions; + +use crate::borrow::ToOwned; +use crate::boxed::Box; +use crate::slice::{Concat, Join, SliceIndex}; +use crate::string::String; +use crate::vec::Vec; + +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::pattern; +#[stable(feature = "encode_utf16", since = "1.8.0")] +pub use core::str::EncodeUtf16; +#[stable(feature = "split_ascii_whitespace", since = "1.34.0")] +pub use core::str::SplitAsciiWhitespace; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::SplitWhitespace; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::{from_utf8, from_utf8_mut, Bytes, CharIndices, Chars}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::{from_utf8_unchecked, from_utf8_unchecked_mut, ParseBoolError}; +#[stable(feature = "str_escape", since = "1.34.0")] +pub use core::str::{EscapeDebug, EscapeDefault, EscapeUnicode}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::{FromStr, Utf8Error}; +#[allow(deprecated)] +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::{Lines, LinesAny}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::{MatchIndices, RMatchIndices}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::{Matches, RMatches}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::{RSplit, Split}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::{RSplitN, SplitN}; +#[stable(feature = "rust1", since = "1.0.0")] +pub use core::str::{RSplitTerminator, SplitTerminator}; + +/// Note: `str` in `Concat` is not meaningful here. +/// This type parameter of the trait only exists to enable another impl. +#[unstable(feature = "slice_concat_ext", issue = "27747")] +impl> Concat for [S] { + type Output = String; + + fn concat(slice: &Self) -> String { + Join::join(slice, "") + } +} + +#[unstable(feature = "slice_concat_ext", issue = "27747")] +impl> Join<&str> for [S] { + type Output = String; + + fn join(slice: &Self, sep: &str) -> String { + unsafe { String::from_utf8_unchecked(join_generic_copy(slice, sep.as_bytes())) } + } +} + +macro_rules! spezialize_for_lengths { + ($separator:expr, $target:expr, $iter:expr; $($num:expr),*) => { + let mut target = $target; + let iter = $iter; + let sep_bytes = $separator; + match $separator.len() { + $( + // loops with hardcoded sizes run much faster + // specialize the cases with small separator lengths + $num => { + for s in iter { + copy_slice_and_advance!(target, sep_bytes); + copy_slice_and_advance!(target, s.borrow().as_ref()); + } + }, + )* + _ => { + // arbitrary non-zero size fallback + for s in iter { + copy_slice_and_advance!(target, sep_bytes); + copy_slice_and_advance!(target, s.borrow().as_ref()); + } + } + } + }; +} + +macro_rules! copy_slice_and_advance { + ($target:expr, $bytes:expr) => { + let len = $bytes.len(); + let (head, tail) = { $target }.split_at_mut(len); + head.copy_from_slice($bytes); + $target = tail; + }; +} + +// Optimized join implementation that works for both Vec (T: Copy) and String's inner vec +// Currently (2018-05-13) there is a bug with type inference and specialization (see issue #36262) +// For this reason SliceConcat is not specialized for T: Copy and SliceConcat is the +// only user of this function. It is left in place for the time when that is fixed. +// +// the bounds for String-join are S: Borrow and for Vec-join Borrow<[T]> +// [T] and str both impl AsRef<[T]> for some T +// => s.borrow().as_ref() and we always have slices +fn join_generic_copy(slice: &[S], sep: &[T]) -> Vec +where + T: Copy, + B: AsRef<[T]> + ?Sized, + S: Borrow, +{ + let sep_len = sep.len(); + let mut iter = slice.iter(); + + // the first slice is the only one without a separator preceding it + let first = match iter.next() { + Some(first) => first, + None => return vec![], + }; + + // compute the exact total length of the joined Vec + // if the `len` calculation overflows, we'll panic + // we would have run out of memory anyway and the rest of the function requires + // the entire Vec pre-allocated for safety + let len = sep_len + .checked_mul(iter.len()) + .and_then(|n| { + slice.iter().map(|s| s.borrow().as_ref().len()).try_fold(n, usize::checked_add) + }) + .expect("attempt to join into collection with len > usize::MAX"); + + // crucial for safety + let mut result = Vec::with_capacity(len); + assert!(result.capacity() >= len); + + result.extend_from_slice(first.borrow().as_ref()); + + unsafe { + { + let pos = result.len(); + let target = result.get_unchecked_mut(pos..len); + + // copy separator and slices over without bounds checks + // generate loops with hardcoded offsets for small separators + // massive improvements possible (~ x2) + spezialize_for_lengths!(sep, target, iter; 0, 1, 2, 3, 4); + } + result.set_len(len); + } + result +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Borrow for String { + #[inline] + fn borrow(&self) -> &str { + &self[..] + } +} + +#[stable(feature = "string_borrow_mut", since = "1.36.0")] +impl BorrowMut for String { + #[inline] + fn borrow_mut(&mut self) -> &mut str { + &mut self[..] + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ToOwned for str { + type Owned = String; + #[inline] + fn to_owned(&self) -> String { + unsafe { String::from_utf8_unchecked(self.as_bytes().to_owned()) } + } + + fn clone_into(&self, target: &mut String) { + let mut b = mem::take(target).into_bytes(); + self.as_bytes().clone_into(&mut b); + *target = unsafe { String::from_utf8_unchecked(b) } + } +} + +/// Methods for string slices. +#[lang = "str_alloc"] +#[cfg(not(test))] +impl str { + /// Converts a `Box` into a `Box<[u8]>` without copying or allocating. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = "this is a string"; + /// let boxed_str = s.to_owned().into_boxed_str(); + /// let boxed_bytes = boxed_str.into_boxed_bytes(); + /// assert_eq!(*boxed_bytes, *s.as_bytes()); + /// ``` + #[stable(feature = "str_box_extras", since = "1.20.0")] + #[inline] + pub fn into_boxed_bytes(self: Box) -> Box<[u8]> { + self.into() + } + + /// Replaces all matches of a pattern with another string. + /// + /// `replace` creates a new [`String`], and copies the data from this string slice into it. + /// While doing so, it attempts to find matches of a pattern. If it finds any, it + /// replaces them with the replacement string slice. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = "this is old"; + /// + /// assert_eq!("this is new", s.replace("old", "new")); + /// ``` + /// + /// When the pattern doesn't match: + /// + /// ``` + /// let s = "this is old"; + /// assert_eq!(s, s.replace("cookie monster", "little lamb")); + /// ``` + #[must_use = "this returns the replaced string as a new allocation, \ + without modifying the original"] + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn replace<'a, P: Pattern<'a>>(&'a self, from: P, to: &str) -> String { + let mut result = String::new(); + let mut last_end = 0; + for (start, part) in self.match_indices(from) { + result.push_str(unsafe { self.get_unchecked(last_end..start) }); + result.push_str(to); + last_end = start + part.len(); + } + result.push_str(unsafe { self.get_unchecked(last_end..self.len()) }); + result + } + + /// Replaces first N matches of a pattern with another string. + /// + /// `replacen` creates a new [`String`], and copies the data from this string slice into it. + /// While doing so, it attempts to find matches of a pattern. If it finds any, it + /// replaces them with the replacement string slice at most `count` times. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = "foo foo 123 foo"; + /// assert_eq!("new new 123 foo", s.replacen("foo", "new", 2)); + /// assert_eq!("faa fao 123 foo", s.replacen('o', "a", 3)); + /// assert_eq!("foo foo new23 foo", s.replacen(char::is_numeric, "new", 1)); + /// ``` + /// + /// When the pattern doesn't match: + /// + /// ``` + /// let s = "this is old"; + /// assert_eq!(s, s.replacen("cookie monster", "little lamb", 10)); + /// ``` + #[must_use = "this returns the replaced string as a new allocation, \ + without modifying the original"] + #[stable(feature = "str_replacen", since = "1.16.0")] + pub fn replacen<'a, P: Pattern<'a>>(&'a self, pat: P, to: &str, count: usize) -> String { + // Hope to reduce the times of re-allocation + let mut result = String::with_capacity(32); + let mut last_end = 0; + for (start, part) in self.match_indices(pat).take(count) { + result.push_str(unsafe { self.get_unchecked(last_end..start) }); + result.push_str(to); + last_end = start + part.len(); + } + result.push_str(unsafe { self.get_unchecked(last_end..self.len()) }); + result + } + + /// Returns the lowercase equivalent of this string slice, as a new [`String`]. + /// + /// 'Lowercase' is defined according to the terms of the Unicode Derived Core Property + /// `Lowercase`. + /// + /// Since some characters can expand into multiple characters when changing + /// the case, this function returns a [`String`] instead of modifying the + /// parameter in-place. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = "HELLO"; + /// + /// assert_eq!("hello", s.to_lowercase()); + /// ``` + /// + /// A tricky example, with sigma: + /// + /// ``` + /// let sigma = "Σ"; + /// + /// assert_eq!("σ", sigma.to_lowercase()); + /// + /// // but at the end of a word, it's ς, not σ: + /// let odysseus = "ὈΔΥΣΣΕΎΣ"; + /// + /// assert_eq!("ὀδυσσεύς", odysseus.to_lowercase()); + /// ``` + /// + /// Languages without case are not changed: + /// + /// ``` + /// let new_year = "农历新年"; + /// + /// assert_eq!(new_year, new_year.to_lowercase()); + /// ``` + #[stable(feature = "unicode_case_mapping", since = "1.2.0")] + pub fn to_lowercase(&self) -> String { + let mut s = String::with_capacity(self.len()); + for (i, c) in self[..].char_indices() { + if c == 'Σ' { + // Σ maps to σ, except at the end of a word where it maps to ς. + // This is the only conditional (contextual) but language-independent mapping + // in `SpecialCasing.txt`, + // so hard-code it rather than have a generic "condition" mechanism. + // See https://github.com/rust-lang/rust/issues/26035 + map_uppercase_sigma(self, i, &mut s) + } else { + match conversions::to_lower(c) { + [a, '\0', _] => s.push(a), + [a, b, '\0'] => { + s.push(a); + s.push(b); + } + [a, b, c] => { + s.push(a); + s.push(b); + s.push(c); + } + } + } + } + return s; + + fn map_uppercase_sigma(from: &str, i: usize, to: &mut String) { + // See http://www.unicode.org/versions/Unicode7.0.0/ch03.pdf#G33992 + // for the definition of `Final_Sigma`. + debug_assert!('Σ'.len_utf8() == 2); + let is_word_final = case_ignoreable_then_cased(from[..i].chars().rev()) + && !case_ignoreable_then_cased(from[i + 2..].chars()); + to.push_str(if is_word_final { "ς" } else { "σ" }); + } + + fn case_ignoreable_then_cased>(iter: I) -> bool { + use core::unicode::derived_property::{Case_Ignorable, Cased}; + match iter.skip_while(|&c| Case_Ignorable(c)).next() { + Some(c) => Cased(c), + None => false, + } + } + } + + /// Returns the uppercase equivalent of this string slice, as a new [`String`]. + /// + /// 'Uppercase' is defined according to the terms of the Unicode Derived Core Property + /// `Uppercase`. + /// + /// Since some characters can expand into multiple characters when changing + /// the case, this function returns a [`String`] instead of modifying the + /// parameter in-place. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = "hello"; + /// + /// assert_eq!("HELLO", s.to_uppercase()); + /// ``` + /// + /// Scripts without case are not changed: + /// + /// ``` + /// let new_year = "农历新年"; + /// + /// assert_eq!(new_year, new_year.to_uppercase()); + /// ``` + /// + /// One character can become multiple: + /// ``` + /// let s = "tschüß"; + /// + /// assert_eq!("TSCHÜSS", s.to_uppercase()); + /// ``` + #[stable(feature = "unicode_case_mapping", since = "1.2.0")] + pub fn to_uppercase(&self) -> String { + let mut s = String::with_capacity(self.len()); + for c in self[..].chars() { + match conversions::to_upper(c) { + [a, '\0', _] => s.push(a), + [a, b, '\0'] => { + s.push(a); + s.push(b); + } + [a, b, c] => { + s.push(a); + s.push(b); + s.push(c); + } + } + } + s + } + + /// Converts a [`Box`] into a [`String`] without copying or allocating. + /// + /// [`Box`]: Box + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let string = String::from("birthday gift"); + /// let boxed_str = string.clone().into_boxed_str(); + /// + /// assert_eq!(boxed_str.into_string(), string); + /// ``` + #[stable(feature = "box_str", since = "1.4.0")] + #[inline] + pub fn into_string(self: Box) -> String { + let slice = Box::<[u8]>::from(self); + unsafe { String::from_utf8_unchecked(slice.into_vec()) } + } + + /// Creates a new [`String`] by repeating a string `n` times. + /// + /// # Panics + /// + /// This function will panic if the capacity would overflow. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// assert_eq!("abc".repeat(4), String::from("abcabcabcabc")); + /// ``` + /// + /// A panic upon overflow: + /// + /// ```should_panic + /// // this will panic at runtime + /// "0123456789abcdef".repeat(usize::MAX); + /// ``` + #[stable(feature = "repeat_str", since = "1.16.0")] + pub fn repeat(&self, n: usize) -> String { + unsafe { String::from_utf8_unchecked(self.as_bytes().repeat(n)) } + } + + /// Returns a copy of this string where each character is mapped to its + /// ASCII upper case equivalent. + /// + /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z', + /// but non-ASCII letters are unchanged. + /// + /// To uppercase the value in-place, use [`make_ascii_uppercase`]. + /// + /// To uppercase ASCII characters in addition to non-ASCII characters, use + /// [`to_uppercase`]. + /// + /// # Examples + /// + /// ``` + /// let s = "Grüße, Jürgen ❤"; + /// + /// assert_eq!("GRüßE, JüRGEN ❤", s.to_ascii_uppercase()); + /// ``` + /// + /// [`make_ascii_uppercase`]: str::make_ascii_uppercase + /// [`to_uppercase`]: #method.to_uppercase + #[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")] + #[inline] + pub fn to_ascii_uppercase(&self) -> String { + let mut bytes = self.as_bytes().to_vec(); + bytes.make_ascii_uppercase(); + // make_ascii_uppercase() preserves the UTF-8 invariant. + unsafe { String::from_utf8_unchecked(bytes) } + } + + /// Returns a copy of this string where each character is mapped to its + /// ASCII lower case equivalent. + /// + /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z', + /// but non-ASCII letters are unchanged. + /// + /// To lowercase the value in-place, use [`make_ascii_lowercase`]. + /// + /// To lowercase ASCII characters in addition to non-ASCII characters, use + /// [`to_lowercase`]. + /// + /// # Examples + /// + /// ``` + /// let s = "Grüße, Jürgen ❤"; + /// + /// assert_eq!("grüße, jürgen ❤", s.to_ascii_lowercase()); + /// ``` + /// + /// [`make_ascii_lowercase`]: str::make_ascii_lowercase + /// [`to_lowercase`]: #method.to_lowercase + #[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")] + #[inline] + pub fn to_ascii_lowercase(&self) -> String { + let mut bytes = self.as_bytes().to_vec(); + bytes.make_ascii_lowercase(); + // make_ascii_lowercase() preserves the UTF-8 invariant. + unsafe { String::from_utf8_unchecked(bytes) } + } +} + +/// Converts a boxed slice of bytes to a boxed string slice without checking +/// that the string contains valid UTF-8. +/// +/// # Examples +/// +/// Basic usage: +/// +/// ``` +/// let smile_utf8 = Box::new([226, 152, 186]); +/// let smile = unsafe { std::str::from_boxed_utf8_unchecked(smile_utf8) }; +/// +/// assert_eq!("☺", &*smile); +/// ``` +#[stable(feature = "str_box_extras", since = "1.20.0")] +#[inline] +pub unsafe fn from_boxed_utf8_unchecked(v: Box<[u8]>) -> Box { + unsafe { Box::from_raw(Box::into_raw(v) as *mut str) } +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/string.rs b/gcc/testsuite/rust/alloc/alloc/src/string.rs new file mode 100644 index 000000000000..d0e0296f5c43 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/string.rs @@ -0,0 +1,2539 @@ +//! A UTF-8–encoded, growable string. +//! +//! This module contains the [`String`] type, the [`ToString`] trait for +//! converting to strings, and several error types that may result from +//! working with [`String`]s. +//! +//! # Examples +//! +//! There are multiple ways to create a new [`String`] from a string literal: +//! +//! ``` +//! let s = "Hello".to_string(); +//! +//! let s = String::from("world"); +//! let s: String = "also this".into(); +//! ``` +//! +//! You can create a new [`String`] from an existing one by concatenating with +//! `+`: +//! +//! ``` +//! let s = "Hello".to_string(); +//! +//! let message = s + " world!"; +//! ``` +//! +//! If you have a vector of valid UTF-8 bytes, you can make a [`String`] out of +//! it. You can do the reverse too. +//! +//! ``` +//! let sparkle_heart = vec![240, 159, 146, 150]; +//! +//! // We know these bytes are valid, so we'll use `unwrap()`. +//! let sparkle_heart = String::from_utf8(sparkle_heart).unwrap(); +//! +//! assert_eq!("💖", sparkle_heart); +//! +//! let bytes = sparkle_heart.into_bytes(); +//! +//! assert_eq!(bytes, [240, 159, 146, 150]); +//! ``` + +#![stable(feature = "rust1", since = "1.0.0")] + +use crate::gccrs_core_prelude::*; + +use core::char::{decode_utf16, REPLACEMENT_CHARACTER}; +use core::fmt; +use core::hash; +use core::iter::{FromIterator, FusedIterator}; +use core::ops::Bound::{Excluded, Included, Unbounded}; +use core::ops::{self, Add, AddAssign, Index, IndexMut, Range, RangeBounds}; +use core::ptr; +use core::str::{lossy, pattern::Pattern}; + +use crate::borrow::{Cow, ToOwned}; +use crate::boxed::Box; +use crate::collections::TryReserveError; +use crate::str::{self, from_boxed_utf8_unchecked, Chars, FromStr, Utf8Error}; +use crate::vec::Vec; + +/// A UTF-8–encoded, growable string. +/// +/// The `String` type is the most common string type that has ownership over the +/// contents of the string. It has a close relationship with its borrowed +/// counterpart, the primitive [`str`]. +/// +/// # Examples +/// +/// You can create a `String` from [a literal string][`str`] with [`String::from`]: +/// +/// [`String::from`]: From::from +/// +/// ``` +/// let hello = String::from("Hello, world!"); +/// ``` +/// +/// You can append a [`char`] to a `String` with the [`push`] method, and +/// append a [`&str`] with the [`push_str`] method: +/// +/// ``` +/// let mut hello = String::from("Hello, "); +/// +/// hello.push('w'); +/// hello.push_str("orld!"); +/// ``` +/// +/// [`push`]: String::push +/// [`push_str`]: String::push_str +/// +/// If you have a vector of UTF-8 bytes, you can create a `String` from it with +/// the [`from_utf8`] method: +/// +/// ``` +/// // some bytes, in a vector +/// let sparkle_heart = vec![240, 159, 146, 150]; +/// +/// // We know these bytes are valid, so we'll use `unwrap()`. +/// let sparkle_heart = String::from_utf8(sparkle_heart).unwrap(); +/// +/// assert_eq!("💖", sparkle_heart); +/// ``` +/// +/// [`from_utf8`]: String::from_utf8 +/// +/// # UTF-8 +/// +/// `String`s are always valid UTF-8. This has a few implications, the first of +/// which is that if you need a non-UTF-8 string, consider [`OsString`]. It is +/// similar, but without the UTF-8 constraint. The second implication is that +/// you cannot index into a `String`: +/// +/// ```compile_fail,E0277 +/// let s = "hello"; +/// +/// println!("The first letter of s is {}", s[0]); // ERROR!!! +/// ``` +/// +/// [`OsString`]: ../../std/ffi/struct.OsString.html +/// +/// Indexing is intended to be a constant-time operation, but UTF-8 encoding +/// does not allow us to do this. Furthermore, it's not clear what sort of +/// thing the index should return: a byte, a codepoint, or a grapheme cluster. +/// The [`bytes`] and [`chars`] methods return iterators over the first +/// two, respectively. +/// +/// [`bytes`]: str::bytes +/// [`chars`]: str::chars +/// +/// # Deref +/// +/// `String`s implement [`Deref`]``, and so inherit all of [`str`]'s +/// methods. In addition, this means that you can pass a `String` to a +/// function which takes a [`&str`] by using an ampersand (`&`): +/// +/// ``` +/// fn takes_str(s: &str) { } +/// +/// let s = String::from("Hello"); +/// +/// takes_str(&s); +/// ``` +/// +/// This will create a [`&str`] from the `String` and pass it in. This +/// conversion is very inexpensive, and so generally, functions will accept +/// [`&str`]s as arguments unless they need a `String` for some specific +/// reason. +/// +/// In certain cases Rust doesn't have enough information to make this +/// conversion, known as [`Deref`] coercion. In the following example a string +/// slice [`&'a str`][`&str`] implements the trait `TraitExample`, and the function +/// `example_func` takes anything that implements the trait. In this case Rust +/// would need to make two implicit conversions, which Rust doesn't have the +/// means to do. For that reason, the following example will not compile. +/// +/// ```compile_fail,E0277 +/// trait TraitExample {} +/// +/// impl<'a> TraitExample for &'a str {} +/// +/// fn example_func(example_arg: A) {} +/// +/// let example_string = String::from("example_string"); +/// example_func(&example_string); +/// ``` +/// +/// There are two options that would work instead. The first would be to +/// change the line `example_func(&example_string);` to +/// `example_func(example_string.as_str());`, using the method [`as_str()`] +/// to explicitly extract the string slice containing the string. The second +/// way changes `example_func(&example_string);` to +/// `example_func(&*example_string);`. In this case we are dereferencing a +/// `String` to a [`str`][`&str`], then referencing the [`str`][`&str`] back to +/// [`&str`]. The second way is more idiomatic, however both work to do the +/// conversion explicitly rather than relying on the implicit conversion. +/// +/// # Representation +/// +/// A `String` is made up of three components: a pointer to some bytes, a +/// length, and a capacity. The pointer points to an internal buffer `String` +/// uses to store its data. The length is the number of bytes currently stored +/// in the buffer, and the capacity is the size of the buffer in bytes. As such, +/// the length will always be less than or equal to the capacity. +/// +/// This buffer is always stored on the heap. +/// +/// You can look at these with the [`as_ptr`], [`len`], and [`capacity`] +/// methods: +/// +/// ``` +/// use std::mem; +/// +/// let story = String::from("Once upon a time..."); +/// +// FIXME Update this when vec_into_raw_parts is stabilized +/// // Prevent automatically dropping the String's data +/// let mut story = mem::ManuallyDrop::new(story); +/// +/// let ptr = story.as_mut_ptr(); +/// let len = story.len(); +/// let capacity = story.capacity(); +/// +/// // story has nineteen bytes +/// assert_eq!(19, len); +/// +/// // We can re-build a String out of ptr, len, and capacity. This is all +/// // unsafe because we are responsible for making sure the components are +/// // valid: +/// let s = unsafe { String::from_raw_parts(ptr, len, capacity) } ; +/// +/// assert_eq!(String::from("Once upon a time..."), s); +/// ``` +/// +/// [`as_ptr`]: str::as_ptr +/// [`len`]: String::len +/// [`capacity`]: String::capacity +/// +/// If a `String` has enough capacity, adding elements to it will not +/// re-allocate. For example, consider this program: +/// +/// ``` +/// let mut s = String::new(); +/// +/// println!("{}", s.capacity()); +/// +/// for _ in 0..5 { +/// s.push_str("hello"); +/// println!("{}", s.capacity()); +/// } +/// ``` +/// +/// This will output the following: +/// +/// ```text +/// 0 +/// 5 +/// 10 +/// 20 +/// 20 +/// 40 +/// ``` +/// +/// At first, we have no memory allocated at all, but as we append to the +/// string, it increases its capacity appropriately. If we instead use the +/// [`with_capacity`] method to allocate the correct capacity initially: +/// +/// ``` +/// let mut s = String::with_capacity(25); +/// +/// println!("{}", s.capacity()); +/// +/// for _ in 0..5 { +/// s.push_str("hello"); +/// println!("{}", s.capacity()); +/// } +/// ``` +/// +/// [`with_capacity`]: String::with_capacity +/// +/// We end up with a different output: +/// +/// ```text +/// 25 +/// 25 +/// 25 +/// 25 +/// 25 +/// 25 +/// ``` +/// +/// Here, there's no need to allocate more memory inside the loop. +/// +/// [`str`]: prim@str +/// [`&str`]: prim@str +/// [`Deref`]: core::ops::Deref +/// [`as_str()`]: String::as_str +#[derive(PartialOrd, Eq, Ord)] +#[cfg_attr(not(test), rustc_diagnostic_item = "string_type")] +#[stable(feature = "rust1", since = "1.0.0")] +pub struct String { + vec: Vec, +} + +/// A possible error value when converting a `String` from a UTF-8 byte vector. +/// +/// This type is the error type for the [`from_utf8`] method on [`String`]. It +/// is designed in such a way to carefully avoid reallocations: the +/// [`into_bytes`] method will give back the byte vector that was used in the +/// conversion attempt. +/// +/// [`from_utf8`]: String::from_utf8 +/// [`into_bytes`]: FromUtf8Error::into_bytes +/// +/// The [`Utf8Error`] type provided by [`std::str`] represents an error that may +/// occur when converting a slice of [`u8`]s to a [`&str`]. In this sense, it's +/// an analogue to `FromUtf8Error`, and you can get one from a `FromUtf8Error` +/// through the [`utf8_error`] method. +/// +/// [`Utf8Error`]: core::str::Utf8Error +/// [`std::str`]: core::str +/// [`&str`]: prim@str +/// [`utf8_error`]: Self::utf8_error +/// +/// # Examples +/// +/// Basic usage: +/// +/// ``` +/// // some invalid bytes, in a vector +/// let bytes = vec![0, 159]; +/// +/// let value = String::from_utf8(bytes); +/// +/// assert!(value.is_err()); +/// assert_eq!(vec![0, 159], value.unwrap_err().into_bytes()); +/// ``` +#[stable(feature = "rust1", since = "1.0.0")] +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct FromUtf8Error { + bytes: Vec, + error: Utf8Error, +} + +/// A possible error value when converting a `String` from a UTF-16 byte slice. +/// +/// This type is the error type for the [`from_utf16`] method on [`String`]. +/// +/// [`from_utf16`]: String::from_utf16 +/// # Examples +/// +/// Basic usage: +/// +/// ``` +/// // 𝄞muic +/// let v = &[0xD834, 0xDD1E, 0x006d, 0x0075, +/// 0xD800, 0x0069, 0x0063]; +/// +/// assert!(String::from_utf16(v).is_err()); +/// ``` +#[stable(feature = "rust1", since = "1.0.0")] +#[derive(Debug)] +pub struct FromUtf16Error(()); + +impl String { + /// Creates a new empty `String`. + /// + /// Given that the `String` is empty, this will not allocate any initial + /// buffer. While that means that this initial operation is very + /// inexpensive, it may cause excessive allocation later when you add + /// data. If you have an idea of how much data the `String` will hold, + /// consider the [`with_capacity`] method to prevent excessive + /// re-allocation. + /// + /// [`with_capacity`]: String::with_capacity + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = String::new(); + /// ``` + #[inline] + #[rustc_const_stable(feature = "const_string_new", since = "1.32.0")] + #[stable(feature = "rust1", since = "1.0.0")] + pub const fn new() -> String { + String { vec: Vec::new() } + } + + /// Creates a new empty `String` with a particular capacity. + /// + /// `String`s have an internal buffer to hold their data. The capacity is + /// the length of that buffer, and can be queried with the [`capacity`] + /// method. This method creates an empty `String`, but one with an initial + /// buffer that can hold `capacity` bytes. This is useful when you may be + /// appending a bunch of data to the `String`, reducing the number of + /// reallocations it needs to do. + /// + /// [`capacity`]: String::capacity + /// + /// If the given capacity is `0`, no allocation will occur, and this method + /// is identical to the [`new`] method. + /// + /// [`new`]: String::new + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::with_capacity(10); + /// + /// // The String contains no chars, even though it has capacity for more + /// assert_eq!(s.len(), 0); + /// + /// // These are all done without reallocating... + /// let cap = s.capacity(); + /// for _ in 0..10 { + /// s.push('a'); + /// } + /// + /// assert_eq!(s.capacity(), cap); + /// + /// // ...but this may make the string reallocate + /// s.push('a'); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn with_capacity(capacity: usize) -> String { + String { vec: Vec::with_capacity(capacity) } + } + + // HACK(japaric): with cfg(test) the inherent `[T]::to_vec` method, which is + // required for this method definition, is not available. Since we don't + // require this method for testing purposes, I'll just stub it + // NB see the slice::hack module in slice.rs for more information + #[inline] + #[cfg(test)] + pub fn from_str(_: &str) -> String { + panic!("not available with cfg(test)"); + } + + /// Converts a vector of bytes to a `String`. + /// + /// A string ([`String`]) is made of bytes ([`u8`]), and a vector of bytes + /// ([`Vec`]) is made of bytes, so this function converts between the + /// two. Not all byte slices are valid `String`s, however: `String` + /// requires that it is valid UTF-8. `from_utf8()` checks to ensure that + /// the bytes are valid UTF-8, and then does the conversion. + /// + /// If you are sure that the byte slice is valid UTF-8, and you don't want + /// to incur the overhead of the validity check, there is an unsafe version + /// of this function, [`from_utf8_unchecked`], which has the same behavior + /// but skips the check. + /// + /// This method will take care to not copy the vector, for efficiency's + /// sake. + /// + /// If you need a [`&str`] instead of a `String`, consider + /// [`str::from_utf8`]. + /// + /// The inverse of this method is [`into_bytes`]. + /// + /// # Errors + /// + /// Returns [`Err`] if the slice is not UTF-8 with a description as to why the + /// provided bytes are not UTF-8. The vector you moved in is also included. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// // some bytes, in a vector + /// let sparkle_heart = vec![240, 159, 146, 150]; + /// + /// // We know these bytes are valid, so we'll use `unwrap()`. + /// let sparkle_heart = String::from_utf8(sparkle_heart).unwrap(); + /// + /// assert_eq!("💖", sparkle_heart); + /// ``` + /// + /// Incorrect bytes: + /// + /// ``` + /// // some invalid bytes, in a vector + /// let sparkle_heart = vec![0, 159, 146, 150]; + /// + /// assert!(String::from_utf8(sparkle_heart).is_err()); + /// ``` + /// + /// See the docs for [`FromUtf8Error`] for more details on what you can do + /// with this error. + /// + /// [`from_utf8_unchecked`]: String::from_utf8_unchecked + /// [`Vec`]: crate::vec::Vec + /// [`&str`]: prim@str + /// [`into_bytes`]: String::into_bytes + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn from_utf8(vec: Vec) -> Result { + match str::from_utf8(&vec) { + Ok(..) => Ok(String { vec }), + Err(e) => Err(FromUtf8Error { bytes: vec, error: e }), + } + } + + /// Converts a slice of bytes to a string, including invalid characters. + /// + /// Strings are made of bytes ([`u8`]), and a slice of bytes + /// ([`&[u8]`][byteslice]) is made of bytes, so this function converts + /// between the two. Not all byte slices are valid strings, however: strings + /// are required to be valid UTF-8. During this conversion, + /// `from_utf8_lossy()` will replace any invalid UTF-8 sequences with + /// [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD], which looks like this: � + /// + /// [byteslice]: ../../std/primitive.slice.html + /// [U+FFFD]: core::char::REPLACEMENT_CHARACTER + /// + /// If you are sure that the byte slice is valid UTF-8, and you don't want + /// to incur the overhead of the conversion, there is an unsafe version + /// of this function, [`from_utf8_unchecked`], which has the same behavior + /// but skips the checks. + /// + /// [`from_utf8_unchecked`]: String::from_utf8_unchecked + /// + /// This function returns a [`Cow<'a, str>`]. If our byte slice is invalid + /// UTF-8, then we need to insert the replacement characters, which will + /// change the size of the string, and hence, require a `String`. But if + /// it's already valid UTF-8, we don't need a new allocation. This return + /// type allows us to handle both cases. + /// + /// [`Cow<'a, str>`]: crate::borrow::Cow + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// // some bytes, in a vector + /// let sparkle_heart = vec![240, 159, 146, 150]; + /// + /// let sparkle_heart = String::from_utf8_lossy(&sparkle_heart); + /// + /// assert_eq!("💖", sparkle_heart); + /// ``` + /// + /// Incorrect bytes: + /// + /// ``` + /// // some invalid bytes + /// let input = b"Hello \xF0\x90\x80World"; + /// let output = String::from_utf8_lossy(input); + /// + /// assert_eq!("Hello �World", output); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn from_utf8_lossy(v: &[u8]) -> Cow<'_, str> { + let mut iter = lossy::Utf8Lossy::from_bytes(v).chunks(); + + let (first_valid, first_broken) = if let Some(chunk) = iter.next() { + let lossy::Utf8LossyChunk { valid, broken } = chunk; + if valid.len() == v.len() { + debug_assert!(broken.is_empty()); + return Cow::Borrowed(valid); + } + (valid, broken) + } else { + return Cow::Borrowed(""); + }; + + const REPLACEMENT: &str = "\u{FFFD}"; + + let mut res = String::with_capacity(v.len()); + res.push_str(first_valid); + if !first_broken.is_empty() { + res.push_str(REPLACEMENT); + } + + for lossy::Utf8LossyChunk { valid, broken } in iter { + res.push_str(valid); + if !broken.is_empty() { + res.push_str(REPLACEMENT); + } + } + + Cow::Owned(res) + } + + /// Decode a UTF-16–encoded vector `v` into a `String`, returning [`Err`] + /// if `v` contains any invalid data. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// // 𝄞music + /// let v = &[0xD834, 0xDD1E, 0x006d, 0x0075, + /// 0x0073, 0x0069, 0x0063]; + /// assert_eq!(String::from("𝄞music"), + /// String::from_utf16(v).unwrap()); + /// + /// // 𝄞muic + /// let v = &[0xD834, 0xDD1E, 0x006d, 0x0075, + /// 0xD800, 0x0069, 0x0063]; + /// assert!(String::from_utf16(v).is_err()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn from_utf16(v: &[u16]) -> Result { + // This isn't done via collect::>() for performance reasons. + // FIXME: the function can be simplified again when #48994 is closed. + let mut ret = String::with_capacity(v.len()); + for c in decode_utf16(v.iter().cloned()) { + if let Ok(c) = c { + ret.push(c); + } else { + return Err(FromUtf16Error(())); + } + } + Ok(ret) + } + + /// Decode a UTF-16–encoded slice `v` into a `String`, replacing + /// invalid data with [the replacement character (`U+FFFD`)][U+FFFD]. + /// + /// Unlike [`from_utf8_lossy`] which returns a [`Cow<'a, str>`], + /// `from_utf16_lossy` returns a `String` since the UTF-16 to UTF-8 + /// conversion requires a memory allocation. + /// + /// [`from_utf8_lossy`]: String::from_utf8_lossy + /// [`Cow<'a, str>`]: crate::borrow::Cow + /// [U+FFFD]: core::char::REPLACEMENT_CHARACTER + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// // 𝄞music + /// let v = &[0xD834, 0xDD1E, 0x006d, 0x0075, + /// 0x0073, 0xDD1E, 0x0069, 0x0063, + /// 0xD834]; + /// + /// assert_eq!(String::from("𝄞mus\u{FFFD}ic\u{FFFD}"), + /// String::from_utf16_lossy(v)); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn from_utf16_lossy(v: &[u16]) -> String { + decode_utf16(v.iter().cloned()).map(|r| r.unwrap_or(REPLACEMENT_CHARACTER)).collect() + } + + /// Decomposes a `String` into its raw components. + /// + /// Returns the raw pointer to the underlying data, the length of + /// the string (in bytes), and the allocated capacity of the data + /// (in bytes). These are the same arguments in the same order as + /// the arguments to [`from_raw_parts`]. + /// + /// After calling this function, the caller is responsible for the + /// memory previously managed by the `String`. The only way to do + /// this is to convert the raw pointer, length, and capacity back + /// into a `String` with the [`from_raw_parts`] function, allowing + /// the destructor to perform the cleanup. + /// + /// [`from_raw_parts`]: String::from_raw_parts + /// + /// # Examples + /// + /// ``` + /// #![feature(vec_into_raw_parts)] + /// let s = String::from("hello"); + /// + /// let (ptr, len, cap) = s.into_raw_parts(); + /// + /// let rebuilt = unsafe { String::from_raw_parts(ptr, len, cap) }; + /// assert_eq!(rebuilt, "hello"); + /// ``` + #[unstable(feature = "vec_into_raw_parts", reason = "new API", issue = "65816")] + pub fn into_raw_parts(self) -> (*mut u8, usize, usize) { + self.vec.into_raw_parts() + } + + /// Creates a new `String` from a length, capacity, and pointer. + /// + /// # Safety + /// + /// This is highly unsafe, due to the number of invariants that aren't + /// checked: + /// + /// * The memory at `buf` needs to have been previously allocated by the + /// same allocator the standard library uses, with a required alignment of exactly 1. + /// * `length` needs to be less than or equal to `capacity`. + /// * `capacity` needs to be the correct value. + /// * The first `length` bytes at `buf` need to be valid UTF-8. + /// + /// Violating these may cause problems like corrupting the allocator's + /// internal data structures. + /// + /// The ownership of `buf` is effectively transferred to the + /// `String` which may then deallocate, reallocate or change the + /// contents of memory pointed to by the pointer at will. Ensure + /// that nothing else uses the pointer after calling this + /// function. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// use std::mem; + /// + /// unsafe { + /// let s = String::from("hello"); + /// + // FIXME Update this when vec_into_raw_parts is stabilized + /// // Prevent automatically dropping the String's data + /// let mut s = mem::ManuallyDrop::new(s); + /// + /// let ptr = s.as_mut_ptr(); + /// let len = s.len(); + /// let capacity = s.capacity(); + /// + /// let s = String::from_raw_parts(ptr, len, capacity); + /// + /// assert_eq!(String::from("hello"), s); + /// } + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub unsafe fn from_raw_parts(buf: *mut u8, length: usize, capacity: usize) -> String { + unsafe { String { vec: Vec::from_raw_parts(buf, length, capacity) } } + } + + /// Converts a vector of bytes to a `String` without checking that the + /// string contains valid UTF-8. + /// + /// See the safe version, [`from_utf8`], for more details. + /// + /// [`from_utf8`]: String::from_utf8 + /// + /// # Safety + /// + /// This function is unsafe because it does not check that the bytes passed + /// to it are valid UTF-8. If this constraint is violated, it may cause + /// memory unsafety issues with future users of the `String`, as the rest of + /// the standard library assumes that `String`s are valid UTF-8. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// // some bytes, in a vector + /// let sparkle_heart = vec![240, 159, 146, 150]; + /// + /// let sparkle_heart = unsafe { + /// String::from_utf8_unchecked(sparkle_heart) + /// }; + /// + /// assert_eq!("💖", sparkle_heart); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub unsafe fn from_utf8_unchecked(bytes: Vec) -> String { + String { vec: bytes } + } + + /// Converts a `String` into a byte vector. + /// + /// This consumes the `String`, so we do not need to copy its contents. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = String::from("hello"); + /// let bytes = s.into_bytes(); + /// + /// assert_eq!(&[104, 101, 108, 108, 111][..], &bytes[..]); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn into_bytes(self) -> Vec { + self.vec + } + + /// Extracts a string slice containing the entire `String`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = String::from("foo"); + /// + /// assert_eq!("foo", s.as_str()); + /// ``` + #[inline] + #[stable(feature = "string_as_str", since = "1.7.0")] + pub fn as_str(&self) -> &str { + self + } + + /// Converts a `String` into a mutable string slice. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("foobar"); + /// let s_mut_str = s.as_mut_str(); + /// + /// s_mut_str.make_ascii_uppercase(); + /// + /// assert_eq!("FOOBAR", s_mut_str); + /// ``` + #[inline] + #[stable(feature = "string_as_str", since = "1.7.0")] + pub fn as_mut_str(&mut self) -> &mut str { + self + } + + /// Appends a given string slice onto the end of this `String`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("foo"); + /// + /// s.push_str("bar"); + /// + /// assert_eq!("foobar", s); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn push_str(&mut self, string: &str) { + self.vec.extend_from_slice(string.as_bytes()) + } + + /// Returns this `String`'s capacity, in bytes. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = String::with_capacity(10); + /// + /// assert!(s.capacity() >= 10); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn capacity(&self) -> usize { + self.vec.capacity() + } + + /// Ensures that this `String`'s capacity is at least `additional` bytes + /// larger than its length. + /// + /// The capacity may be increased by more than `additional` bytes if it + /// chooses, to prevent frequent reallocations. + /// + /// If you do not want this "at least" behavior, see the [`reserve_exact`] + /// method. + /// + /// # Panics + /// + /// Panics if the new capacity overflows [`usize`]. + /// + /// [`reserve_exact`]: String::reserve_exact + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::new(); + /// + /// s.reserve(10); + /// + /// assert!(s.capacity() >= 10); + /// ``` + /// + /// This may not actually increase the capacity: + /// + /// ``` + /// let mut s = String::with_capacity(10); + /// s.push('a'); + /// s.push('b'); + /// + /// // s now has a length of 2 and a capacity of 10 + /// assert_eq!(2, s.len()); + /// assert_eq!(10, s.capacity()); + /// + /// // Since we already have an extra 8 capacity, calling this... + /// s.reserve(8); + /// + /// // ... doesn't actually increase. + /// assert_eq!(10, s.capacity()); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn reserve(&mut self, additional: usize) { + self.vec.reserve(additional) + } + + /// Ensures that this `String`'s capacity is `additional` bytes + /// larger than its length. + /// + /// Consider using the [`reserve`] method unless you absolutely know + /// better than the allocator. + /// + /// [`reserve`]: String::reserve + /// + /// # Panics + /// + /// Panics if the new capacity overflows `usize`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::new(); + /// + /// s.reserve_exact(10); + /// + /// assert!(s.capacity() >= 10); + /// ``` + /// + /// This may not actually increase the capacity: + /// + /// ``` + /// let mut s = String::with_capacity(10); + /// s.push('a'); + /// s.push('b'); + /// + /// // s now has a length of 2 and a capacity of 10 + /// assert_eq!(2, s.len()); + /// assert_eq!(10, s.capacity()); + /// + /// // Since we already have an extra 8 capacity, calling this... + /// s.reserve_exact(8); + /// + /// // ... doesn't actually increase. + /// assert_eq!(10, s.capacity()); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn reserve_exact(&mut self, additional: usize) { + self.vec.reserve_exact(additional) + } + + /// Tries to reserve capacity for at least `additional` more elements to be inserted + /// in the given `String`. The collection may reserve more space to avoid + /// frequent reallocations. After calling `reserve`, capacity will be + /// greater than or equal to `self.len() + additional`. Does nothing if + /// capacity is already sufficient. + /// + /// # Errors + /// + /// If the capacity overflows, or the allocator reports a failure, then an error + /// is returned. + /// + /// # Examples + /// + /// ``` + /// #![feature(try_reserve)] + /// use std::collections::TryReserveError; + /// + /// fn process_data(data: &str) -> Result { + /// let mut output = String::new(); + /// + /// // Pre-reserve the memory, exiting if we can't + /// output.try_reserve(data.len())?; + /// + /// // Now we know this can't OOM in the middle of our complex work + /// output.push_str(data); + /// + /// Ok(output) + /// } + /// # process_data("rust").expect("why is the test harness OOMing on 4 bytes?"); + /// ``` + #[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] + pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> { + self.vec.try_reserve(additional) + } + + /// Tries to reserves the minimum capacity for exactly `additional` more elements to + /// be inserted in the given `String`. After calling `reserve_exact`, + /// capacity will be greater than or equal to `self.len() + additional`. + /// Does nothing if the capacity is already sufficient. + /// + /// Note that the allocator may give the collection more space than it + /// requests. Therefore, capacity can not be relied upon to be precisely + /// minimal. Prefer `reserve` if future insertions are expected. + /// + /// # Errors + /// + /// If the capacity overflows, or the allocator reports a failure, then an error + /// is returned. + /// + /// # Examples + /// + /// ``` + /// #![feature(try_reserve)] + /// use std::collections::TryReserveError; + /// + /// fn process_data(data: &str) -> Result { + /// let mut output = String::new(); + /// + /// // Pre-reserve the memory, exiting if we can't + /// output.try_reserve(data.len())?; + /// + /// // Now we know this can't OOM in the middle of our complex work + /// output.push_str(data); + /// + /// Ok(output) + /// } + /// # process_data("rust").expect("why is the test harness OOMing on 4 bytes?"); + /// ``` + #[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] + pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveError> { + self.vec.try_reserve_exact(additional) + } + + /// Shrinks the capacity of this `String` to match its length. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("foo"); + /// + /// s.reserve(100); + /// assert!(s.capacity() >= 100); + /// + /// s.shrink_to_fit(); + /// assert_eq!(3, s.capacity()); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn shrink_to_fit(&mut self) { + self.vec.shrink_to_fit() + } + + /// Shrinks the capacity of this `String` with a lower bound. + /// + /// The capacity will remain at least as large as both the length + /// and the supplied value. + /// + /// Panics if the current capacity is smaller than the supplied + /// minimum capacity. + /// + /// # Examples + /// + /// ``` + /// #![feature(shrink_to)] + /// let mut s = String::from("foo"); + /// + /// s.reserve(100); + /// assert!(s.capacity() >= 100); + /// + /// s.shrink_to(10); + /// assert!(s.capacity() >= 10); + /// s.shrink_to(0); + /// assert!(s.capacity() >= 3); + /// ``` + #[inline] + #[unstable(feature = "shrink_to", reason = "new API", issue = "56431")] + pub fn shrink_to(&mut self, min_capacity: usize) { + self.vec.shrink_to(min_capacity) + } + + /// Appends the given [`char`] to the end of this `String`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("abc"); + /// + /// s.push('1'); + /// s.push('2'); + /// s.push('3'); + /// + /// assert_eq!("abc123", s); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn push(&mut self, ch: char) { + match ch.len_utf8() { + 1 => self.vec.push(ch as u8), + _ => self.vec.extend_from_slice(ch.encode_utf8(&mut [0; 4]).as_bytes()), + } + } + + /// Returns a byte slice of this `String`'s contents. + /// + /// The inverse of this method is [`from_utf8`]. + /// + /// [`from_utf8`]: String::from_utf8 + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = String::from("hello"); + /// + /// assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes()); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn as_bytes(&self) -> &[u8] { + &self.vec + } + + /// Shortens this `String` to the specified length. + /// + /// If `new_len` is greater than the string's current length, this has no + /// effect. + /// + /// Note that this method has no effect on the allocated capacity + /// of the string + /// + /// # Panics + /// + /// Panics if `new_len` does not lie on a [`char`] boundary. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("hello"); + /// + /// s.truncate(2); + /// + /// assert_eq!("he", s); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn truncate(&mut self, new_len: usize) { + if new_len <= self.len() { + assert!(self.is_char_boundary(new_len)); + self.vec.truncate(new_len) + } + } + + /// Removes the last character from the string buffer and returns it. + /// + /// Returns [`None`] if this `String` is empty. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("foo"); + /// + /// assert_eq!(s.pop(), Some('o')); + /// assert_eq!(s.pop(), Some('o')); + /// assert_eq!(s.pop(), Some('f')); + /// + /// assert_eq!(s.pop(), None); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn pop(&mut self) -> Option { + let ch = self.chars().rev().next()?; + let newlen = self.len() - ch.len_utf8(); + unsafe { + self.vec.set_len(newlen); + } + Some(ch) + } + + /// Removes a [`char`] from this `String` at a byte position and returns it. + /// + /// This is an *O*(*n*) operation, as it requires copying every element in the + /// buffer. + /// + /// # Panics + /// + /// Panics if `idx` is larger than or equal to the `String`'s length, + /// or if it does not lie on a [`char`] boundary. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("foo"); + /// + /// assert_eq!(s.remove(0), 'f'); + /// assert_eq!(s.remove(1), 'o'); + /// assert_eq!(s.remove(0), 'o'); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn remove(&mut self, idx: usize) -> char { + let ch = match self[idx..].chars().next() { + Some(ch) => ch, + None => panic!("cannot remove a char from the end of a string"), + }; + + let next = idx + ch.len_utf8(); + let len = self.len(); + unsafe { + ptr::copy(self.vec.as_ptr().add(next), self.vec.as_mut_ptr().add(idx), len - next); + self.vec.set_len(len - (next - idx)); + } + ch + } + + /// Retains only the characters specified by the predicate. + /// + /// In other words, remove all characters `c` such that `f(c)` returns `false`. + /// This method operates in place, visiting each character exactly once in the + /// original order, and preserves the order of the retained characters. + /// + /// # Examples + /// + /// ``` + /// let mut s = String::from("f_o_ob_ar"); + /// + /// s.retain(|c| c != '_'); + /// + /// assert_eq!(s, "foobar"); + /// ``` + /// + /// The exact order may be useful for tracking external state, like an index. + /// + /// ``` + /// let mut s = String::from("abcde"); + /// let keep = [false, true, true, false, true]; + /// let mut i = 0; + /// s.retain(|_| (keep[i], i += 1).0); + /// assert_eq!(s, "bce"); + /// ``` + #[inline] + #[stable(feature = "string_retain", since = "1.26.0")] + pub fn retain(&mut self, mut f: F) + where + F: FnMut(char) -> bool, + { + let len = self.len(); + let mut del_bytes = 0; + let mut idx = 0; + + unsafe { + self.vec.set_len(0); + } + + while idx < len { + let ch = unsafe { self.get_unchecked(idx..len).chars().next().unwrap() }; + let ch_len = ch.len_utf8(); + + if !f(ch) { + del_bytes += ch_len; + } else if del_bytes > 0 { + unsafe { + ptr::copy( + self.vec.as_ptr().add(idx), + self.vec.as_mut_ptr().add(idx - del_bytes), + ch_len, + ); + } + } + + // Point idx to the next char + idx += ch_len; + } + + unsafe { + self.vec.set_len(len - del_bytes); + } + } + + /// Inserts a character into this `String` at a byte position. + /// + /// This is an *O*(*n*) operation as it requires copying every element in the + /// buffer. + /// + /// # Panics + /// + /// Panics if `idx` is larger than the `String`'s length, or if it does not + /// lie on a [`char`] boundary. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::with_capacity(3); + /// + /// s.insert(0, 'f'); + /// s.insert(1, 'o'); + /// s.insert(2, 'o'); + /// + /// assert_eq!("foo", s); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn insert(&mut self, idx: usize, ch: char) { + assert!(self.is_char_boundary(idx)); + let mut bits = [0; 4]; + let bits = ch.encode_utf8(&mut bits).as_bytes(); + + unsafe { + self.insert_bytes(idx, bits); + } + } + + unsafe fn insert_bytes(&mut self, idx: usize, bytes: &[u8]) { + let len = self.len(); + let amt = bytes.len(); + self.vec.reserve(amt); + + unsafe { + ptr::copy(self.vec.as_ptr().add(idx), self.vec.as_mut_ptr().add(idx + amt), len - idx); + ptr::copy(bytes.as_ptr(), self.vec.as_mut_ptr().add(idx), amt); + self.vec.set_len(len + amt); + } + } + + /// Inserts a string slice into this `String` at a byte position. + /// + /// This is an *O*(*n*) operation as it requires copying every element in the + /// buffer. + /// + /// # Panics + /// + /// Panics if `idx` is larger than the `String`'s length, or if it does not + /// lie on a [`char`] boundary. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("bar"); + /// + /// s.insert_str(0, "foo"); + /// + /// assert_eq!("foobar", s); + /// ``` + #[inline] + #[stable(feature = "insert_str", since = "1.16.0")] + pub fn insert_str(&mut self, idx: usize, string: &str) { + assert!(self.is_char_boundary(idx)); + + unsafe { + self.insert_bytes(idx, string.as_bytes()); + } + } + + /// Returns a mutable reference to the contents of this `String`. + /// + /// # Safety + /// + /// This function is unsafe because it does not check that the bytes passed + /// to it are valid UTF-8. If this constraint is violated, it may cause + /// memory unsafety issues with future users of the `String`, as the rest of + /// the standard library assumes that `String`s are valid UTF-8. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("hello"); + /// + /// unsafe { + /// let vec = s.as_mut_vec(); + /// assert_eq!(&[104, 101, 108, 108, 111][..], &vec[..]); + /// + /// vec.reverse(); + /// } + /// assert_eq!(s, "olleh"); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub unsafe fn as_mut_vec(&mut self) -> &mut Vec { + &mut self.vec + } + + /// Returns the length of this `String`, in bytes, not [`char`]s or + /// graphemes. In other words, it may not be what a human considers the + /// length of the string. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let a = String::from("foo"); + /// assert_eq!(a.len(), 3); + /// + /// let fancy_f = String::from("ƒoo"); + /// assert_eq!(fancy_f.len(), 4); + /// assert_eq!(fancy_f.chars().count(), 3); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn len(&self) -> usize { + self.vec.len() + } + + /// Returns `true` if this `String` has a length of zero, and `false` otherwise. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut v = String::new(); + /// assert!(v.is_empty()); + /// + /// v.push('a'); + /// assert!(!v.is_empty()); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// Splits the string into two at the given index. + /// + /// Returns a newly allocated `String`. `self` contains bytes `[0, at)`, and + /// the returned `String` contains bytes `[at, len)`. `at` must be on the + /// boundary of a UTF-8 code point. + /// + /// Note that the capacity of `self` does not change. + /// + /// # Panics + /// + /// Panics if `at` is not on a `UTF-8` code point boundary, or if it is beyond the last + /// code point of the string. + /// + /// # Examples + /// + /// ``` + /// # fn main() { + /// let mut hello = String::from("Hello, World!"); + /// let world = hello.split_off(7); + /// assert_eq!(hello, "Hello, "); + /// assert_eq!(world, "World!"); + /// # } + /// ``` + #[inline] + #[stable(feature = "string_split_off", since = "1.16.0")] + #[must_use = "use `.truncate()` if you don't need the other half"] + pub fn split_off(&mut self, at: usize) -> String { + assert!(self.is_char_boundary(at)); + let other = self.vec.split_off(at); + unsafe { String::from_utf8_unchecked(other) } + } + + /// Truncates this `String`, removing all contents. + /// + /// While this means the `String` will have a length of zero, it does not + /// touch its capacity. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("foo"); + /// + /// s.clear(); + /// + /// assert!(s.is_empty()); + /// assert_eq!(0, s.len()); + /// assert_eq!(3, s.capacity()); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn clear(&mut self) { + self.vec.clear() + } + + /// Creates a draining iterator that removes the specified range in the `String` + /// and yields the removed `chars`. + /// + /// Note: The element range is removed even if the iterator is not + /// consumed until the end. + /// + /// # Panics + /// + /// Panics if the starting point or end point do not lie on a [`char`] + /// boundary, or if they're out of bounds. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("α is alpha, β is beta"); + /// let beta_offset = s.find('β').unwrap_or(s.len()); + /// + /// // Remove the range up until the β from the string + /// let t: String = s.drain(..beta_offset).collect(); + /// assert_eq!(t, "α is alpha, "); + /// assert_eq!(s, "β is beta"); + /// + /// // A full range clears the string + /// s.drain(..); + /// assert_eq!(s, ""); + /// ``` + #[stable(feature = "drain", since = "1.6.0")] + pub fn drain(&mut self, range: R) -> Drain<'_> + where + R: RangeBounds, + { + // Memory safety + // + // The String version of Drain does not have the memory safety issues + // of the vector version. The data is just plain bytes. + // Because the range removal happens in Drop, if the Drain iterator is leaked, + // the removal will not happen. + let Range { start, end } = range.assert_len(self.len()); + assert!(self.is_char_boundary(start)); + assert!(self.is_char_boundary(end)); + + // Take out two simultaneous borrows. The &mut String won't be accessed + // until iteration is over, in Drop. + let self_ptr = self as *mut _; + // SAFETY: `assert_len` and `is_char_boundary` do the appropriate bounds checks. + let chars_iter = unsafe { self.get_unchecked(start..end) }.chars(); + + Drain { start, end, iter: chars_iter, string: self_ptr } + } + + /// Removes the specified range in the string, + /// and replaces it with the given string. + /// The given string doesn't need to be the same length as the range. + /// + /// # Panics + /// + /// Panics if the starting point or end point do not lie on a [`char`] + /// boundary, or if they're out of bounds. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let mut s = String::from("α is alpha, β is beta"); + /// let beta_offset = s.find('β').unwrap_or(s.len()); + /// + /// // Replace the range up until the β from the string + /// s.replace_range(..beta_offset, "Α is capital alpha; "); + /// assert_eq!(s, "Α is capital alpha; β is beta"); + /// ``` + #[stable(feature = "splice", since = "1.27.0")] + pub fn replace_range(&mut self, range: R, replace_with: &str) + where + R: RangeBounds, + { + // Memory safety + // + // Replace_range does not have the memory safety issues of a vector Splice. + // of the vector version. The data is just plain bytes. + + match range.start_bound() { + Included(&n) => assert!(self.is_char_boundary(n)), + Excluded(&n) => assert!(self.is_char_boundary(n + 1)), + Unbounded => {} + }; + match range.end_bound() { + Included(&n) => assert!(self.is_char_boundary(n + 1)), + Excluded(&n) => assert!(self.is_char_boundary(n)), + Unbounded => {} + }; + + unsafe { self.as_mut_vec() }.splice(range, replace_with.bytes()); + } + + /// Converts this `String` into a [`Box`]`<`[`str`]`>`. + /// + /// This will drop any excess capacity. + /// + /// [`str`]: prim@str + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s = String::from("hello"); + /// + /// let b = s.into_boxed_str(); + /// ``` + #[stable(feature = "box_str", since = "1.4.0")] + #[inline] + pub fn into_boxed_str(self) -> Box { + let slice = self.vec.into_boxed_slice(); + unsafe { from_boxed_utf8_unchecked(slice) } + } +} + +impl FromUtf8Error { + /// Returns a slice of [`u8`]s bytes that were attempted to convert to a `String`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// // some invalid bytes, in a vector + /// let bytes = vec![0, 159]; + /// + /// let value = String::from_utf8(bytes); + /// + /// assert_eq!(&[0, 159], value.unwrap_err().as_bytes()); + /// ``` + #[stable(feature = "from_utf8_error_as_bytes", since = "1.26.0")] + pub fn as_bytes(&self) -> &[u8] { + &self.bytes[..] + } + + /// Returns the bytes that were attempted to convert to a `String`. + /// + /// This method is carefully constructed to avoid allocation. It will + /// consume the error, moving out the bytes, so that a copy of the bytes + /// does not need to be made. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// // some invalid bytes, in a vector + /// let bytes = vec![0, 159]; + /// + /// let value = String::from_utf8(bytes); + /// + /// assert_eq!(vec![0, 159], value.unwrap_err().into_bytes()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn into_bytes(self) -> Vec { + self.bytes + } + + /// Fetch a `Utf8Error` to get more details about the conversion failure. + /// + /// The [`Utf8Error`] type provided by [`std::str`] represents an error that may + /// occur when converting a slice of [`u8`]s to a [`&str`]. In this sense, it's + /// an analogue to `FromUtf8Error`. See its documentation for more details + /// on using it. + /// + /// [`std::str`]: core::str + /// [`&str`]: prim@str + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// // some invalid bytes, in a vector + /// let bytes = vec![0, 159]; + /// + /// let error = String::from_utf8(bytes).unwrap_err().utf8_error(); + /// + /// // the first byte is invalid here + /// assert_eq!(1, error.valid_up_to()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn utf8_error(&self) -> Utf8Error { + self.error + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Display for FromUtf8Error { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Display::fmt(&self.error, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Display for FromUtf16Error { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Display::fmt("invalid utf-16: lone surrogate found", f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for String { + fn clone(&self) -> Self { + String { vec: self.vec.clone() } + } + + fn clone_from(&mut self, source: &Self) { + self.vec.clone_from(&source.vec); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl FromIterator for String { + fn from_iter>(iter: I) -> String { + let mut buf = String::new(); + buf.extend(iter); + buf + } +} + +#[stable(feature = "string_from_iter_by_ref", since = "1.17.0")] +impl<'a> FromIterator<&'a char> for String { + fn from_iter>(iter: I) -> String { + let mut buf = String::new(); + buf.extend(iter); + buf + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a> FromIterator<&'a str> for String { + fn from_iter>(iter: I) -> String { + let mut buf = String::new(); + buf.extend(iter); + buf + } +} + +#[stable(feature = "extend_string", since = "1.4.0")] +impl FromIterator for String { + fn from_iter>(iter: I) -> String { + let mut iterator = iter.into_iter(); + + // Because we're iterating over `String`s, we can avoid at least + // one allocation by getting the first string from the iterator + // and appending to it all the subsequent strings. + match iterator.next() { + None => String::new(), + Some(mut buf) => { + buf.extend(iterator); + buf + } + } + } +} + +#[stable(feature = "box_str2", since = "1.45.0")] +impl FromIterator> for String { + fn from_iter>>(iter: I) -> String { + let mut buf = String::new(); + buf.extend(iter); + buf + } +} + +#[stable(feature = "herd_cows", since = "1.19.0")] +impl<'a> FromIterator> for String { + fn from_iter>>(iter: I) -> String { + let mut iterator = iter.into_iter(); + + // Because we're iterating over CoWs, we can (potentially) avoid at least + // one allocation by getting the first item and appending to it all the + // subsequent items. + match iterator.next() { + None => String::new(), + Some(cow) => { + let mut buf = cow.into_owned(); + buf.extend(iterator); + buf + } + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Extend for String { + fn extend>(&mut self, iter: I) { + let iterator = iter.into_iter(); + let (lower_bound, _) = iterator.size_hint(); + self.reserve(lower_bound); + iterator.for_each(move |c| self.push(c)); + } + + #[inline] + fn extend_one(&mut self, c: char) { + self.push(c); + } + + #[inline] + fn extend_reserve(&mut self, additional: usize) { + self.reserve(additional); + } +} + +#[stable(feature = "extend_ref", since = "1.2.0")] +impl<'a> Extend<&'a char> for String { + fn extend>(&mut self, iter: I) { + self.extend(iter.into_iter().cloned()); + } + + #[inline] + fn extend_one(&mut self, &c: &'a char) { + self.push(c); + } + + #[inline] + fn extend_reserve(&mut self, additional: usize) { + self.reserve(additional); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a> Extend<&'a str> for String { + fn extend>(&mut self, iter: I) { + iter.into_iter().for_each(move |s| self.push_str(s)); + } + + #[inline] + fn extend_one(&mut self, s: &'a str) { + self.push_str(s); + } +} + +#[stable(feature = "box_str2", since = "1.45.0")] +impl Extend> for String { + fn extend>>(&mut self, iter: I) { + iter.into_iter().for_each(move |s| self.push_str(&s)); + } +} + +#[stable(feature = "extend_string", since = "1.4.0")] +impl Extend for String { + fn extend>(&mut self, iter: I) { + iter.into_iter().for_each(move |s| self.push_str(&s)); + } + + #[inline] + fn extend_one(&mut self, s: String) { + self.push_str(&s); + } +} + +#[stable(feature = "herd_cows", since = "1.19.0")] +impl<'a> Extend> for String { + fn extend>>(&mut self, iter: I) { + iter.into_iter().for_each(move |s| self.push_str(&s)); + } + + #[inline] + fn extend_one(&mut self, s: Cow<'a, str>) { + self.push_str(&s); + } +} + +/// A convenience impl that delegates to the impl for `&str`. +/// +/// # Examples +/// +/// ``` +/// assert_eq!(String::from("Hello world").find("world"), Some(6)); +/// ``` +#[unstable( + feature = "pattern", + reason = "API not fully fleshed out and ready to be stabilized", + issue = "27721" +)] +impl<'a, 'b> Pattern<'a> for &'b String { + type Searcher = <&'b str as Pattern<'a>>::Searcher; + + fn into_searcher(self, haystack: &'a str) -> <&'b str as Pattern<'a>>::Searcher { + self[..].into_searcher(haystack) + } + + #[inline] + fn is_contained_in(self, haystack: &'a str) -> bool { + self[..].is_contained_in(haystack) + } + + #[inline] + fn is_prefix_of(self, haystack: &'a str) -> bool { + self[..].is_prefix_of(haystack) + } + + #[inline] + fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str> { + self[..].strip_prefix_of(haystack) + } + + #[inline] + fn is_suffix_of(self, haystack: &'a str) -> bool { + self[..].is_suffix_of(haystack) + } + + #[inline] + fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> { + self[..].strip_suffix_of(haystack) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialEq for String { + #[inline] + fn eq(&self, other: &String) -> bool { + PartialEq::eq(&self[..], &other[..]) + } + #[inline] + fn ne(&self, other: &String) -> bool { + PartialEq::ne(&self[..], &other[..]) + } +} + +macro_rules! impl_eq { + ($lhs:ty, $rhs: ty) => { + #[stable(feature = "rust1", since = "1.0.0")] + #[allow(unused_lifetimes)] + impl<'a, 'b> PartialEq<$rhs> for $lhs { + #[inline] + fn eq(&self, other: &$rhs) -> bool { + PartialEq::eq(&self[..], &other[..]) + } + #[inline] + fn ne(&self, other: &$rhs) -> bool { + PartialEq::ne(&self[..], &other[..]) + } + } + + #[stable(feature = "rust1", since = "1.0.0")] + #[allow(unused_lifetimes)] + impl<'a, 'b> PartialEq<$lhs> for $rhs { + #[inline] + fn eq(&self, other: &$lhs) -> bool { + PartialEq::eq(&self[..], &other[..]) + } + #[inline] + fn ne(&self, other: &$lhs) -> bool { + PartialEq::ne(&self[..], &other[..]) + } + } + }; +} + +impl_eq! { String, str } +impl_eq! { String, &'a str } +impl_eq! { Cow<'a, str>, str } +impl_eq! { Cow<'a, str>, &'b str } +impl_eq! { Cow<'a, str>, String } + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for String { + /// Creates an empty `String`. + #[inline] + fn default() -> String { + String::new() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Display for String { + #[inline] + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Display::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Debug for String { + #[inline] + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Debug::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl hash::Hash for String { + #[inline] + fn hash(&self, hasher: &mut H) { + (**self).hash(hasher) + } +} + +/// Implements the `+` operator for concatenating two strings. +/// +/// This consumes the `String` on the left-hand side and re-uses its buffer (growing it if +/// necessary). This is done to avoid allocating a new `String` and copying the entire contents on +/// every operation, which would lead to *O*(*n*^2) running time when building an *n*-byte string by +/// repeated concatenation. +/// +/// The string on the right-hand side is only borrowed; its contents are copied into the returned +/// `String`. +/// +/// # Examples +/// +/// Concatenating two `String`s takes the first by value and borrows the second: +/// +/// ``` +/// let a = String::from("hello"); +/// let b = String::from(" world"); +/// let c = a + &b; +/// // `a` is moved and can no longer be used here. +/// ``` +/// +/// If you want to keep using the first `String`, you can clone it and append to the clone instead: +/// +/// ``` +/// let a = String::from("hello"); +/// let b = String::from(" world"); +/// let c = a.clone() + &b; +/// // `a` is still valid here. +/// ``` +/// +/// Concatenating `&str` slices can be done by converting the first to a `String`: +/// +/// ``` +/// let a = "hello"; +/// let b = " world"; +/// let c = a.to_string() + b; +/// ``` +#[stable(feature = "rust1", since = "1.0.0")] +impl Add<&str> for String { + type Output = String; + + #[inline] + fn add(mut self, other: &str) -> String { + self.push_str(other); + self + } +} + +/// Implements the `+=` operator for appending to a `String`. +/// +/// This has the same behavior as the [`push_str`][String::push_str] method. +#[stable(feature = "stringaddassign", since = "1.12.0")] +impl AddAssign<&str> for String { + #[inline] + fn add_assign(&mut self, other: &str) { + self.push_str(other); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ops::Index> for String { + type Output = str; + + #[inline] + fn index(&self, index: ops::Range) -> &str { + &self[..][index] + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl ops::Index> for String { + type Output = str; + + #[inline] + fn index(&self, index: ops::RangeTo) -> &str { + &self[..][index] + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl ops::Index> for String { + type Output = str; + + #[inline] + fn index(&self, index: ops::RangeFrom) -> &str { + &self[..][index] + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl ops::Index for String { + type Output = str; + + #[inline] + fn index(&self, _index: ops::RangeFull) -> &str { + unsafe { str::from_utf8_unchecked(&self.vec) } + } +} +#[stable(feature = "inclusive_range", since = "1.26.0")] +impl ops::Index> for String { + type Output = str; + + #[inline] + fn index(&self, index: ops::RangeInclusive) -> &str { + Index::index(&**self, index) + } +} +#[stable(feature = "inclusive_range", since = "1.26.0")] +impl ops::Index> for String { + type Output = str; + + #[inline] + fn index(&self, index: ops::RangeToInclusive) -> &str { + Index::index(&**self, index) + } +} + +#[stable(feature = "derefmut_for_string", since = "1.3.0")] +impl ops::IndexMut> for String { + #[inline] + fn index_mut(&mut self, index: ops::Range) -> &mut str { + &mut self[..][index] + } +} +#[stable(feature = "derefmut_for_string", since = "1.3.0")] +impl ops::IndexMut> for String { + #[inline] + fn index_mut(&mut self, index: ops::RangeTo) -> &mut str { + &mut self[..][index] + } +} +#[stable(feature = "derefmut_for_string", since = "1.3.0")] +impl ops::IndexMut> for String { + #[inline] + fn index_mut(&mut self, index: ops::RangeFrom) -> &mut str { + &mut self[..][index] + } +} +#[stable(feature = "derefmut_for_string", since = "1.3.0")] +impl ops::IndexMut for String { + #[inline] + fn index_mut(&mut self, _index: ops::RangeFull) -> &mut str { + unsafe { str::from_utf8_unchecked_mut(&mut *self.vec) } + } +} +#[stable(feature = "inclusive_range", since = "1.26.0")] +impl ops::IndexMut> for String { + #[inline] + fn index_mut(&mut self, index: ops::RangeInclusive) -> &mut str { + IndexMut::index_mut(&mut **self, index) + } +} +#[stable(feature = "inclusive_range", since = "1.26.0")] +impl ops::IndexMut> for String { + #[inline] + fn index_mut(&mut self, index: ops::RangeToInclusive) -> &mut str { + IndexMut::index_mut(&mut **self, index) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ops::Deref for String { + type Target = str; + + #[inline] + fn deref(&self) -> &str { + unsafe { str::from_utf8_unchecked(&self.vec) } + } +} + +#[stable(feature = "derefmut_for_string", since = "1.3.0")] +impl ops::DerefMut for String { + #[inline] + fn deref_mut(&mut self) -> &mut str { + unsafe { str::from_utf8_unchecked_mut(&mut *self.vec) } + } +} + +/// A type alias for [`Infallible`]. +/// +/// This alias exists for backwards compatibility, and may be eventually deprecated. +/// +/// [`Infallible`]: core::convert::Infallible +#[stable(feature = "str_parse_error", since = "1.5.0")] +pub type ParseError = core::convert::Infallible; + +#[stable(feature = "rust1", since = "1.0.0")] +impl FromStr for String { + type Err = core::convert::Infallible; + #[inline] + fn from_str(s: &str) -> Result { + Ok(String::from(s)) + } +} + +/// A trait for converting a value to a `String`. +/// +/// This trait is automatically implemented for any type which implements the +/// [`Display`] trait. As such, `ToString` shouldn't be implemented directly: +/// [`Display`] should be implemented instead, and you get the `ToString` +/// implementation for free. +/// +/// [`Display`]: fmt::Display +#[stable(feature = "rust1", since = "1.0.0")] +pub trait ToString { + /// Converts the given value to a `String`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let i = 5; + /// let five = String::from("5"); + /// + /// assert_eq!(five, i.to_string()); + /// ``` + #[rustc_conversion_suggestion] + #[stable(feature = "rust1", since = "1.0.0")] + fn to_string(&self) -> String; +} + +/// # Panics +/// +/// In this implementation, the `to_string` method panics +/// if the `Display` implementation returns an error. +/// This indicates an incorrect `Display` implementation +/// since `fmt::Write for String` never returns an error itself. +#[stable(feature = "rust1", since = "1.0.0")] +impl ToString for T { + // A common guideline is to not inline generic functions. However, + // removing `#[inline]` from this method causes non-negligible regressions. + // See , the last attempt + // to try to remove it. + #[inline] + default fn to_string(&self) -> String { + use fmt::Write; + let mut buf = String::new(); + buf.write_fmt(format_args!("{}", self)) + .expect("a Display implementation returned an error unexpectedly"); + buf + } +} + +#[stable(feature = "char_to_string_specialization", since = "1.46.0")] +impl ToString for char { + #[inline] + fn to_string(&self) -> String { + String::from(self.encode_utf8(&mut [0; 4])) + } +} + +#[stable(feature = "str_to_string_specialization", since = "1.9.0")] +impl ToString for str { + #[inline] + fn to_string(&self) -> String { + String::from(self) + } +} + +#[stable(feature = "cow_str_to_string_specialization", since = "1.17.0")] +impl ToString for Cow<'_, str> { + #[inline] + fn to_string(&self) -> String { + self[..].to_owned() + } +} + +#[stable(feature = "string_to_string_specialization", since = "1.17.0")] +impl ToString for String { + #[inline] + fn to_string(&self) -> String { + self.to_owned() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl AsRef for String { + #[inline] + fn as_ref(&self) -> &str { + self + } +} + +#[stable(feature = "string_as_mut", since = "1.43.0")] +impl AsMut for String { + #[inline] + fn as_mut(&mut self) -> &mut str { + self + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl AsRef<[u8]> for String { + #[inline] + fn as_ref(&self) -> &[u8] { + self.as_bytes() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl From<&str> for String { + #[inline] + fn from(s: &str) -> String { + s.to_owned() + } +} + +#[stable(feature = "from_mut_str_for_string", since = "1.44.0")] +impl From<&mut str> for String { + /// Converts a `&mut str` into a `String`. + /// + /// The result is allocated on the heap. + #[inline] + fn from(s: &mut str) -> String { + s.to_owned() + } +} + +#[stable(feature = "from_ref_string", since = "1.35.0")] +impl From<&String> for String { + #[inline] + fn from(s: &String) -> String { + s.clone() + } +} + +// note: test pulls in libstd, which causes errors here +#[cfg(not(test))] +#[stable(feature = "string_from_box", since = "1.18.0")] +impl From> for String { + /// Converts the given boxed `str` slice to a `String`. + /// It is notable that the `str` slice is owned. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s1: String = String::from("hello world"); + /// let s2: Box = s1.into_boxed_str(); + /// let s3: String = String::from(s2); + /// + /// assert_eq!("hello world", s3) + /// ``` + fn from(s: Box) -> String { + s.into_string() + } +} + +#[stable(feature = "box_from_str", since = "1.20.0")] +impl From for Box { + /// Converts the given `String` to a boxed `str` slice that is owned. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s1: String = String::from("hello world"); + /// let s2: Box = Box::from(s1); + /// let s3: String = String::from(s2); + /// + /// assert_eq!("hello world", s3) + /// ``` + fn from(s: String) -> Box { + s.into_boxed_str() + } +} + +#[stable(feature = "string_from_cow_str", since = "1.14.0")] +impl<'a> From> for String { + fn from(s: Cow<'a, str>) -> String { + s.into_owned() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a> From<&'a str> for Cow<'a, str> { + #[inline] + fn from(s: &'a str) -> Cow<'a, str> { + Cow::Borrowed(s) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a> From for Cow<'a, str> { + #[inline] + fn from(s: String) -> Cow<'a, str> { + Cow::Owned(s) + } +} + +#[stable(feature = "cow_from_string_ref", since = "1.28.0")] +impl<'a> From<&'a String> for Cow<'a, str> { + #[inline] + fn from(s: &'a String) -> Cow<'a, str> { + Cow::Borrowed(s.as_str()) + } +} + +#[stable(feature = "cow_str_from_iter", since = "1.12.0")] +impl<'a> FromIterator for Cow<'a, str> { + fn from_iter>(it: I) -> Cow<'a, str> { + Cow::Owned(FromIterator::from_iter(it)) + } +} + +#[stable(feature = "cow_str_from_iter", since = "1.12.0")] +impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str> { + fn from_iter>(it: I) -> Cow<'a, str> { + Cow::Owned(FromIterator::from_iter(it)) + } +} + +#[stable(feature = "cow_str_from_iter", since = "1.12.0")] +impl<'a> FromIterator for Cow<'a, str> { + fn from_iter>(it: I) -> Cow<'a, str> { + Cow::Owned(FromIterator::from_iter(it)) + } +} + +#[stable(feature = "from_string_for_vec_u8", since = "1.14.0")] +impl From for Vec { + /// Converts the given `String` to a vector `Vec` that holds values of type `u8`. + /// + /// # Examples + /// + /// Basic usage: + /// + /// ``` + /// let s1 = String::from("hello world"); + /// let v1 = Vec::from(s1); + /// + /// for b in v1 { + /// println!("{}", b); + /// } + /// ``` + fn from(string: String) -> Vec { + string.into_bytes() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Write for String { + #[inline] + fn write_str(&mut self, s: &str) -> fmt::Result { + self.push_str(s); + Ok(()) + } + + #[inline] + fn write_char(&mut self, c: char) -> fmt::Result { + self.push(c); + Ok(()) + } +} + +/// A draining iterator for `String`. +/// +/// This struct is created by the [`drain`] method on [`String`]. See its +/// documentation for more. +/// +/// [`drain`]: String::drain +#[stable(feature = "drain", since = "1.6.0")] +pub struct Drain<'a> { + /// Will be used as &'a mut String in the destructor + string: *mut String, + /// Start of part to remove + start: usize, + /// End of part to remove + end: usize, + /// Current remaining range to remove + iter: Chars<'a>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Drain<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Drain").field(&self.as_str()).finish() + } +} + +#[stable(feature = "drain", since = "1.6.0")] +unsafe impl Sync for Drain<'_> {} +#[stable(feature = "drain", since = "1.6.0")] +unsafe impl Send for Drain<'_> {} + +#[stable(feature = "drain", since = "1.6.0")] +impl Drop for Drain<'_> { + fn drop(&mut self) { + unsafe { + // Use Vec::drain. "Reaffirm" the bounds checks to avoid + // panic code being inserted again. + let self_vec = (*self.string).as_mut_vec(); + if self.start <= self.end && self.end <= self_vec.len() { + self_vec.drain(self.start..self.end); + } + } + } +} + +impl<'a> Drain<'a> { + /// Returns the remaining (sub)string of this iterator as a slice. + /// + /// # Examples + /// + /// ``` + /// #![feature(string_drain_as_str)] + /// let mut s = String::from("abc"); + /// let mut drain = s.drain(..); + /// assert_eq!(drain.as_str(), "abc"); + /// let _ = drain.next().unwrap(); + /// assert_eq!(drain.as_str(), "bc"); + /// ``` + #[unstable(feature = "string_drain_as_str", issue = "76905")] // Note: uncomment AsRef impls below when stabilizing. + pub fn as_str(&self) -> &str { + self.iter.as_str() + } +} + +// Uncomment when stabilizing `string_drain_as_str`. +// #[unstable(feature = "string_drain_as_str", issue = "76905")] +// impl<'a> AsRef for Drain<'a> { +// fn as_ref(&self) -> &str { +// self.as_str() +// } +// } +// +// #[unstable(feature = "string_drain_as_str", issue = "76905")] +// impl<'a> AsRef<[u8]> for Drain<'a> { +// fn as_ref(&self) -> &[u8] { +// self.as_str().as_bytes() +// } +// } + +#[stable(feature = "drain", since = "1.6.0")] +impl Iterator for Drain<'_> { + type Item = char; + + #[inline] + fn next(&mut self) -> Option { + self.iter.next() + } + + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } + + #[inline] + fn last(mut self) -> Option { + self.next_back() + } +} + +#[stable(feature = "drain", since = "1.6.0")] +impl DoubleEndedIterator for Drain<'_> { + #[inline] + fn next_back(&mut self) -> Option { + self.iter.next_back() + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Drain<'_> {} + +#[stable(feature = "from_char_for_string", since = "1.46.0")] +impl From for String { + #[inline] + fn from(c: char) -> Self { + c.to_string() + } +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/sync.rs b/gcc/testsuite/rust/alloc/alloc/src/sync.rs new file mode 100644 index 000000000000..e0d54534da77 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/sync.rs @@ -0,0 +1,2378 @@ +#![stable(feature = "rust1", since = "1.0.0")] + +//! Thread-safe reference-counting pointers. +//! +//! See the [`Arc`][Arc] documentation for more details. + +use crate::gccrs_core_prelude::*; + +use core::any::Any; +use core::borrow; +use core::cmp::Ordering; +use core::convert::{From, TryFrom}; +use core::fmt; +use core::hash::{Hash, Hasher}; +use core::hint; +use core::intrinsics::abort; +use core::iter; +use core::marker::{PhantomData, Unpin, Unsize}; +use core::mem::{self, align_of_val, size_of_val}; +use core::ops::{CoerceUnsized, Deref, DispatchFromDyn, Receiver}; +use core::pin::Pin; +use core::ptr::{self, NonNull}; +use core::slice::from_raw_parts_mut; +use core::sync::atomic; +use core::sync::atomic::Ordering::{Acquire, Relaxed, Release, SeqCst}; + +use crate::alloc::{box_free, handle_alloc_error, AllocError, AllocRef, Global, Layout}; +use crate::borrow::{Cow, ToOwned}; +use crate::boxed::Box; +use crate::rc::is_dangling; +use crate::string::String; +use crate::vec::Vec; + +#[cfg(test)] +mod tests; + +/// A soft limit on the amount of references that may be made to an `Arc`. +/// +/// Going above this limit will abort your program (although not +/// necessarily) at _exactly_ `MAX_REFCOUNT + 1` references. +const MAX_REFCOUNT: usize = (isize::MAX) as usize; + +#[cfg(not(sanitize = "thread"))] +macro_rules! acquire { + ($x:expr) => { + atomic::fence(Acquire) + }; +} + +// ThreadSanitizer does not support memory fences. To avoid false positive +// reports in Arc / Weak implementation use atomic loads for synchronization +// instead. +#[cfg(sanitize = "thread")] +macro_rules! acquire { + ($x:expr) => { + $x.load(Acquire) + }; +} + +/// A thread-safe reference-counting pointer. 'Arc' stands for 'Atomically +/// Reference Counted'. +/// +/// The type `Arc` provides shared ownership of a value of type `T`, +/// allocated in the heap. Invoking [`clone`][clone] on `Arc` produces +/// a new `Arc` instance, which points to the same allocation on the heap as the +/// source `Arc`, while increasing a reference count. When the last `Arc` +/// pointer to a given allocation is destroyed, the value stored in that allocation (often +/// referred to as "inner value") is also dropped. +/// +/// Shared references in Rust disallow mutation by default, and `Arc` is no +/// exception: you cannot generally obtain a mutable reference to something +/// inside an `Arc`. If you need to mutate through an `Arc`, use +/// [`Mutex`][mutex], [`RwLock`][rwlock], or one of the [`Atomic`][atomic] +/// types. +/// +/// ## Thread Safety +/// +/// Unlike [`Rc`], `Arc` uses atomic operations for its reference +/// counting. This means that it is thread-safe. The disadvantage is that +/// atomic operations are more expensive than ordinary memory accesses. If you +/// are not sharing reference-counted allocations between threads, consider using +/// [`Rc`] for lower overhead. [`Rc`] is a safe default, because the +/// compiler will catch any attempt to send an [`Rc`] between threads. +/// However, a library might choose `Arc` in order to give library consumers +/// more flexibility. +/// +/// `Arc` will implement [`Send`] and [`Sync`] as long as the `T` implements +/// [`Send`] and [`Sync`]. Why can't you put a non-thread-safe type `T` in an +/// `Arc` to make it thread-safe? This may be a bit counter-intuitive at +/// first: after all, isn't the point of `Arc` thread safety? The key is +/// this: `Arc` makes it thread safe to have multiple ownership of the same +/// data, but it doesn't add thread safety to its data. Consider +/// `Arc<`[`RefCell`]`>`. [`RefCell`] isn't [`Sync`], and if `Arc` was always +/// [`Send`], `Arc<`[`RefCell`]`>` would be as well. But then we'd have a problem: +/// [`RefCell`] is not thread safe; it keeps track of the borrowing count using +/// non-atomic operations. +/// +/// In the end, this means that you may need to pair `Arc` with some sort of +/// [`std::sync`] type, usually [`Mutex`][mutex]. +/// +/// ## Breaking cycles with `Weak` +/// +/// The [`downgrade`][downgrade] method can be used to create a non-owning +/// [`Weak`] pointer. A [`Weak`] pointer can be [`upgrade`][upgrade]d +/// to an `Arc`, but this will return [`None`] if the value stored in the allocation has +/// already been dropped. In other words, `Weak` pointers do not keep the value +/// inside the allocation alive; however, they *do* keep the allocation +/// (the backing store for the value) alive. +/// +/// A cycle between `Arc` pointers will never be deallocated. For this reason, +/// [`Weak`] is used to break cycles. For example, a tree could have +/// strong `Arc` pointers from parent nodes to children, and [`Weak`] +/// pointers from children back to their parents. +/// +/// # Cloning references +/// +/// Creating a new reference from an existing reference-counted pointer is done using the +/// `Clone` trait implemented for [`Arc`][Arc] and [`Weak`][Weak]. +/// +/// ``` +/// use std::sync::Arc; +/// let foo = Arc::new(vec![1.0, 2.0, 3.0]); +/// // The two syntaxes below are equivalent. +/// let a = foo.clone(); +/// let b = Arc::clone(&foo); +/// // a, b, and foo are all Arcs that point to the same memory location +/// ``` +/// +/// ## `Deref` behavior +/// +/// `Arc` automatically dereferences to `T` (via the [`Deref`][deref] trait), +/// so you can call `T`'s methods on a value of type `Arc`. To avoid name +/// clashes with `T`'s methods, the methods of `Arc` itself are associated +/// functions, called using [fully qualified syntax]: +/// +/// ``` +/// use std::sync::Arc; +/// +/// let my_arc = Arc::new(()); +/// Arc::downgrade(&my_arc); +/// ``` +/// +/// `Arc`'s implementations of traits like `Clone` may also be called using +/// fully qualified syntax. Some people prefer to use fully qualified syntax, +/// while others prefer using method-call syntax. +/// +/// ``` +/// use std::sync::Arc; +/// +/// let arc = Arc::new(()); +/// // Method-call syntax +/// let arc2 = arc.clone(); +/// // Fully qualified syntax +/// let arc3 = Arc::clone(&arc); +/// ``` +/// +/// [`Weak`][Weak] does not auto-dereference to `T`, because the inner value may have +/// already been dropped. +/// +/// [`Rc`]: crate::rc::Rc +/// [clone]: Clone::clone +/// [mutex]: ../../std/sync/struct.Mutex.html +/// [rwlock]: ../../std/sync/struct.RwLock.html +/// [atomic]: core::sync::atomic +/// [`Send`]: core::marker::Send +/// [`Sync`]: core::marker::Sync +/// [deref]: core::ops::Deref +/// [downgrade]: Arc::downgrade +/// [upgrade]: Weak::upgrade +/// [`RefCell`]: core::cell::RefCell +/// [`std::sync`]: ../../std/sync/index.html +/// [`Arc::clone(&from)`]: Arc::clone +/// [fully qualified syntax]: https://doc.rust-lang.org/book/ch19-03-advanced-traits.html#fully-qualified-syntax-for-disambiguation-calling-methods-with-the-same-name +/// +/// # Examples +/// +/// Sharing some immutable data between threads: +/// +// Note that we **do not** run these tests here. The windows builders get super +// unhappy if a thread outlives the main thread and then exits at the same time +// (something deadlocks) so we just avoid this entirely by not running these +// tests. +/// ```no_run +/// use std::sync::Arc; +/// use std::thread; +/// +/// let five = Arc::new(5); +/// +/// for _ in 0..10 { +/// let five = Arc::clone(&five); +/// +/// thread::spawn(move || { +/// println!("{:?}", five); +/// }); +/// } +/// ``` +/// +/// Sharing a mutable [`AtomicUsize`]: +/// +/// [`AtomicUsize`]: core::sync::atomic::AtomicUsize +/// +/// ```no_run +/// use std::sync::Arc; +/// use std::sync::atomic::{AtomicUsize, Ordering}; +/// use std::thread; +/// +/// let val = Arc::new(AtomicUsize::new(5)); +/// +/// for _ in 0..10 { +/// let val = Arc::clone(&val); +/// +/// thread::spawn(move || { +/// let v = val.fetch_add(1, Ordering::SeqCst); +/// println!("{:?}", v); +/// }); +/// } +/// ``` +/// +/// See the [`rc` documentation][rc_examples] for more examples of reference +/// counting in general. +/// +/// [rc_examples]: crate::rc#examples +#[cfg_attr(not(test), rustc_diagnostic_item = "Arc")] +#[stable(feature = "rust1", since = "1.0.0")] +pub struct Arc { + ptr: NonNull>, + phantom: PhantomData>, +} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Send for Arc {} +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Sync for Arc {} + +#[unstable(feature = "coerce_unsized", issue = "27732")] +impl, U: ?Sized> CoerceUnsized> for Arc {} + +#[unstable(feature = "dispatch_from_dyn", issue = "none")] +impl, U: ?Sized> DispatchFromDyn> for Arc {} + +impl Arc { + fn from_inner(ptr: NonNull>) -> Self { + Self { ptr, phantom: PhantomData } + } + + unsafe fn from_ptr(ptr: *mut ArcInner) -> Self { + unsafe { Self::from_inner(NonNull::new_unchecked(ptr)) } + } +} + +/// `Weak` is a version of [`Arc`] that holds a non-owning reference to the +/// managed allocation. The allocation is accessed by calling [`upgrade`] on the `Weak` +/// pointer, which returns an [`Option`]`<`[`Arc`]`>`. +/// +/// Since a `Weak` reference does not count towards ownership, it will not +/// prevent the value stored in the allocation from being dropped, and `Weak` itself makes no +/// guarantees about the value still being present. Thus it may return [`None`] +/// when [`upgrade`]d. Note however that a `Weak` reference *does* prevent the allocation +/// itself (the backing store) from being deallocated. +/// +/// A `Weak` pointer is useful for keeping a temporary reference to the allocation +/// managed by [`Arc`] without preventing its inner value from being dropped. It is also used to +/// prevent circular references between [`Arc`] pointers, since mutual owning references +/// would never allow either [`Arc`] to be dropped. For example, a tree could +/// have strong [`Arc`] pointers from parent nodes to children, and `Weak` +/// pointers from children back to their parents. +/// +/// The typical way to obtain a `Weak` pointer is to call [`Arc::downgrade`]. +/// +/// [`upgrade`]: Weak::upgrade +#[stable(feature = "arc_weak", since = "1.4.0")] +pub struct Weak { + // This is a `NonNull` to allow optimizing the size of this type in enums, + // but it is not necessarily a valid pointer. + // `Weak::new` sets this to `usize::MAX` so that it doesn’t need + // to allocate space on the heap. That's not a value a real pointer + // will ever have because RcBox has alignment at least 2. + // This is only possible when `T: Sized`; unsized `T` never dangle. + ptr: NonNull>, +} + +#[stable(feature = "arc_weak", since = "1.4.0")] +unsafe impl Send for Weak {} +#[stable(feature = "arc_weak", since = "1.4.0")] +unsafe impl Sync for Weak {} + +#[unstable(feature = "coerce_unsized", issue = "27732")] +impl, U: ?Sized> CoerceUnsized> for Weak {} +#[unstable(feature = "dispatch_from_dyn", issue = "none")] +impl, U: ?Sized> DispatchFromDyn> for Weak {} + +#[stable(feature = "arc_weak", since = "1.4.0")] +impl fmt::Debug for Weak { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "(Weak)") + } +} + +// This is repr(C) to future-proof against possible field-reordering, which +// would interfere with otherwise safe [into|from]_raw() of transmutable +// inner types. +#[repr(C)] +struct ArcInner { + strong: atomic::AtomicUsize, + + // the value usize::MAX acts as a sentinel for temporarily "locking" the + // ability to upgrade weak pointers or downgrade strong ones; this is used + // to avoid races in `make_mut` and `get_mut`. + weak: atomic::AtomicUsize, + + data: T, +} + +unsafe impl Send for ArcInner {} +unsafe impl Sync for ArcInner {} + +impl Arc { + /// Constructs a new `Arc`. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn new(data: T) -> Arc { + // Start the weak pointer count as 1 which is the weak pointer that's + // held by all the strong pointers (kinda), see std/rc.rs for more info + let x: Box<_> = box ArcInner { + strong: atomic::AtomicUsize::new(1), + weak: atomic::AtomicUsize::new(1), + data, + }; + Self::from_inner(Box::leak(x).into()) + } + + /// Constructs a new `Arc` using a weak reference to itself. Attempting + /// to upgrade the weak reference before this function returns will result + /// in a `None` value. However, the weak reference may be cloned freely and + /// stored for use at a later time. + /// + /// # Examples + /// ``` + /// #![feature(arc_new_cyclic)] + /// #![allow(dead_code)] + /// + /// use std::sync::{Arc, Weak}; + /// + /// struct Foo { + /// me: Weak, + /// } + /// + /// let foo = Arc::new_cyclic(|me| Foo { + /// me: me.clone(), + /// }); + /// ``` + #[inline] + #[unstable(feature = "arc_new_cyclic", issue = "75861")] + pub fn new_cyclic(data_fn: impl FnOnce(&Weak) -> T) -> Arc { + // Construct the inner in the "uninitialized" state with a single + // weak reference. + let uninit_ptr: NonNull<_> = Box::leak(box ArcInner { + strong: atomic::AtomicUsize::new(0), + weak: atomic::AtomicUsize::new(1), + data: mem::MaybeUninit::::uninit(), + }) + .into(); + let init_ptr: NonNull> = uninit_ptr.cast(); + + let weak = Weak { ptr: init_ptr }; + + // It's important we don't give up ownership of the weak pointer, or + // else the memory might be freed by the time `data_fn` returns. If + // we really wanted to pass ownership, we could create an additional + // weak pointer for ourselves, but this would result in additional + // updates to the weak reference count which might not be necessary + // otherwise. + let data = data_fn(&weak); + + // Now we can properly initialize the inner value and turn our weak + // reference into a strong reference. + unsafe { + let inner = init_ptr.as_ptr(); + ptr::write(&raw mut (*inner).data, data); + + // The above write to the data field must be visible to any threads which + // observe a non-zero strong count. Therefore we need at least "Release" ordering + // in order to synchronize with the `compare_exchange_weak` in `Weak::upgrade`. + // + // "Acquire" ordering is not required. When considering the possible behaviours + // of `data_fn` we only need to look at what it could do with a reference to a + // non-upgradeable `Weak`: + // - It can *clone* the `Weak`, increasing the weak reference count. + // - It can drop those clones, decreasing the weak reference count (but never to zero). + // + // These side effects do not impact us in any way, and no other side effects are + // possible with safe code alone. + let prev_value = (*inner).strong.fetch_add(1, Release); + debug_assert_eq!(prev_value, 0, "No prior strong references should exist"); + } + + let strong = Arc::from_inner(init_ptr); + + // Strong references should collectively own a shared weak reference, + // so don't run the destructor for our old weak reference. + mem::forget(weak); + strong + } + + /// Constructs a new `Arc` with uninitialized contents. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// #![feature(get_mut_unchecked)] + /// + /// use std::sync::Arc; + /// + /// let mut five = Arc::::new_uninit(); + /// + /// let five = unsafe { + /// // Deferred initialization: + /// Arc::get_mut_unchecked(&mut five).as_mut_ptr().write(5); + /// + /// five.assume_init() + /// }; + /// + /// assert_eq!(*five, 5) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_uninit() -> Arc> { + unsafe { + Arc::from_ptr(Arc::allocate_for_layout( + Layout::new::(), + |layout| Global.alloc(layout), + |mem| mem as *mut ArcInner>, + )) + } + } + + /// Constructs a new `Arc` with uninitialized contents, with the memory + /// being filled with `0` bytes. + /// + /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and incorrect usage + /// of this method. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// use std::sync::Arc; + /// + /// let zero = Arc::::new_zeroed(); + /// let zero = unsafe { zero.assume_init() }; + /// + /// assert_eq!(*zero, 0) + /// ``` + /// + /// [zeroed]: ../../std/mem/union.MaybeUninit.html#method.zeroed + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_zeroed() -> Arc> { + unsafe { + Arc::from_ptr(Arc::allocate_for_layout( + Layout::new::(), + |layout| Global.alloc_zeroed(layout), + |mem| mem as *mut ArcInner>, + )) + } + } + + /// Constructs a new `Pin>`. If `T` does not implement `Unpin`, then + /// `data` will be pinned in memory and unable to be moved. + #[stable(feature = "pin", since = "1.33.0")] + pub fn pin(data: T) -> Pin> { + unsafe { Pin::new_unchecked(Arc::new(data)) } + } + + /// Returns the inner value, if the `Arc` has exactly one strong reference. + /// + /// Otherwise, an [`Err`] is returned with the same `Arc` that was + /// passed in. + /// + /// This will succeed even if there are outstanding weak references. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let x = Arc::new(3); + /// assert_eq!(Arc::try_unwrap(x), Ok(3)); + /// + /// let x = Arc::new(4); + /// let _y = Arc::clone(&x); + /// assert_eq!(*Arc::try_unwrap(x).unwrap_err(), 4); + /// ``` + #[inline] + #[stable(feature = "arc_unique", since = "1.4.0")] + pub fn try_unwrap(this: Self) -> Result { + if this.inner().strong.compare_exchange(1, 0, Relaxed, Relaxed).is_err() { + return Err(this); + } + + acquire!(this.inner().strong); + + unsafe { + let elem = ptr::read(&this.ptr.as_ref().data); + + // Make a weak pointer to clean up the implicit strong-weak reference + let _weak = Weak { ptr: this.ptr }; + mem::forget(this); + + Ok(elem) + } + } +} + +impl Arc<[T]> { + /// Constructs a new atomically reference-counted slice with uninitialized contents. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// #![feature(get_mut_unchecked)] + /// + /// use std::sync::Arc; + /// + /// let mut values = Arc::<[u32]>::new_uninit_slice(3); + /// + /// let values = unsafe { + /// // Deferred initialization: + /// Arc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1); + /// Arc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2); + /// Arc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3); + /// + /// values.assume_init() + /// }; + /// + /// assert_eq!(*values, [1, 2, 3]) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_uninit_slice(len: usize) -> Arc<[mem::MaybeUninit]> { + unsafe { Arc::from_ptr(Arc::allocate_for_slice(len)) } + } + + /// Constructs a new atomically reference-counted slice with uninitialized contents, with the memory being + /// filled with `0` bytes. + /// + /// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and + /// incorrect usage of this method. + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// + /// use std::sync::Arc; + /// + /// let values = Arc::<[u32]>::new_zeroed_slice(3); + /// let values = unsafe { values.assume_init() }; + /// + /// assert_eq!(*values, [0, 0, 0]) + /// ``` + /// + /// [zeroed]: ../../std/mem/union.MaybeUninit.html#method.zeroed + #[unstable(feature = "new_uninit", issue = "63291")] + pub fn new_zeroed_slice(len: usize) -> Arc<[mem::MaybeUninit]> { + unsafe { + Arc::from_ptr(Arc::allocate_for_layout( + Layout::array::(len).unwrap(), + |layout| Global.alloc_zeroed(layout), + |mem| { + ptr::slice_from_raw_parts_mut(mem as *mut T, len) + as *mut ArcInner<[mem::MaybeUninit]> + }, + )) + } + } +} + +impl Arc> { + /// Converts to `Arc`. + /// + /// # Safety + /// + /// As with [`MaybeUninit::assume_init`], + /// it is up to the caller to guarantee that the inner value + /// really is in an initialized state. + /// Calling this when the content is not yet fully initialized + /// causes immediate undefined behavior. + /// + /// [`MaybeUninit::assume_init`]: ../../std/mem/union.MaybeUninit.html#method.assume_init + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// #![feature(get_mut_unchecked)] + /// + /// use std::sync::Arc; + /// + /// let mut five = Arc::::new_uninit(); + /// + /// let five = unsafe { + /// // Deferred initialization: + /// Arc::get_mut_unchecked(&mut five).as_mut_ptr().write(5); + /// + /// five.assume_init() + /// }; + /// + /// assert_eq!(*five, 5) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + #[inline] + pub unsafe fn assume_init(self) -> Arc { + Arc::from_inner(mem::ManuallyDrop::new(self).ptr.cast()) + } +} + +impl Arc<[mem::MaybeUninit]> { + /// Converts to `Arc<[T]>`. + /// + /// # Safety + /// + /// As with [`MaybeUninit::assume_init`], + /// it is up to the caller to guarantee that the inner value + /// really is in an initialized state. + /// Calling this when the content is not yet fully initialized + /// causes immediate undefined behavior. + /// + /// [`MaybeUninit::assume_init`]: ../../std/mem/union.MaybeUninit.html#method.assume_init + /// + /// # Examples + /// + /// ``` + /// #![feature(new_uninit)] + /// #![feature(get_mut_unchecked)] + /// + /// use std::sync::Arc; + /// + /// let mut values = Arc::<[u32]>::new_uninit_slice(3); + /// + /// let values = unsafe { + /// // Deferred initialization: + /// Arc::get_mut_unchecked(&mut values)[0].as_mut_ptr().write(1); + /// Arc::get_mut_unchecked(&mut values)[1].as_mut_ptr().write(2); + /// Arc::get_mut_unchecked(&mut values)[2].as_mut_ptr().write(3); + /// + /// values.assume_init() + /// }; + /// + /// assert_eq!(*values, [1, 2, 3]) + /// ``` + #[unstable(feature = "new_uninit", issue = "63291")] + #[inline] + pub unsafe fn assume_init(self) -> Arc<[T]> { + unsafe { Arc::from_ptr(mem::ManuallyDrop::new(self).ptr.as_ptr() as _) } + } +} + +impl Arc { + /// Consumes the `Arc`, returning the wrapped pointer. + /// + /// To avoid a memory leak the pointer must be converted back to an `Arc` using + /// [`Arc::from_raw`]. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let x = Arc::new("hello".to_owned()); + /// let x_ptr = Arc::into_raw(x); + /// assert_eq!(unsafe { &*x_ptr }, "hello"); + /// ``` + #[stable(feature = "rc_raw", since = "1.17.0")] + pub fn into_raw(this: Self) -> *const T { + let ptr = Self::as_ptr(&this); + mem::forget(this); + ptr + } + + /// Provides a raw pointer to the data. + /// + /// The counts are not affected in any way and the `Arc` is not consumed. The pointer is valid for + /// as long as there are strong counts in the `Arc`. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let x = Arc::new("hello".to_owned()); + /// let y = Arc::clone(&x); + /// let x_ptr = Arc::as_ptr(&x); + /// assert_eq!(x_ptr, Arc::as_ptr(&y)); + /// assert_eq!(unsafe { &*x_ptr }, "hello"); + /// ``` + #[stable(feature = "rc_as_ptr", since = "1.45.0")] + pub fn as_ptr(this: &Self) -> *const T { + let ptr: *mut ArcInner = NonNull::as_ptr(this.ptr); + + // SAFETY: This cannot go through Deref::deref or RcBoxPtr::inner because + // this is required to retain raw/mut provenance such that e.g. `get_mut` can + // write through the pointer after the Rc is recovered through `from_raw`. + unsafe { &raw const (*ptr).data } + } + + /// Constructs an `Arc` from a raw pointer. + /// + /// The raw pointer must have been previously returned by a call to + /// [`Arc::into_raw`][into_raw] where `U` must have the same size and + /// alignment as `T`. This is trivially true if `U` is `T`. + /// Note that if `U` is not `T` but has the same size and alignment, this is + /// basically like transmuting references of different types. See + /// [`mem::transmute`][transmute] for more information on what + /// restrictions apply in this case. + /// + /// The user of `from_raw` has to make sure a specific value of `T` is only + /// dropped once. + /// + /// This function is unsafe because improper use may lead to memory unsafety, + /// even if the returned `Arc` is never accessed. + /// + /// [into_raw]: Arc::into_raw + /// [transmute]: core::mem::transmute + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let x = Arc::new("hello".to_owned()); + /// let x_ptr = Arc::into_raw(x); + /// + /// unsafe { + /// // Convert back to an `Arc` to prevent leak. + /// let x = Arc::from_raw(x_ptr); + /// assert_eq!(&*x, "hello"); + /// + /// // Further calls to `Arc::from_raw(x_ptr)` would be memory-unsafe. + /// } + /// + /// // The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling! + /// ``` + #[stable(feature = "rc_raw", since = "1.17.0")] + pub unsafe fn from_raw(ptr: *const T) -> Self { + unsafe { + let offset = data_offset(ptr); + + // Reverse the offset to find the original ArcInner. + let fake_ptr = ptr as *mut ArcInner; + let arc_ptr = set_data_ptr(fake_ptr, (ptr as *mut u8).offset(-offset)); + + Self::from_ptr(arc_ptr) + } + } + + /// Creates a new [`Weak`] pointer to this allocation. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// let weak_five = Arc::downgrade(&five); + /// ``` + #[stable(feature = "arc_weak", since = "1.4.0")] + pub fn downgrade(this: &Self) -> Weak { + // This Relaxed is OK because we're checking the value in the CAS + // below. + let mut cur = this.inner().weak.load(Relaxed); + + loop { + // check if the weak counter is currently "locked"; if so, spin. + if cur == usize::MAX { + hint::spin_loop(); + cur = this.inner().weak.load(Relaxed); + continue; + } + + // NOTE: this code currently ignores the possibility of overflow + // into usize::MAX; in general both Rc and Arc need to be adjusted + // to deal with overflow. + + // Unlike with Clone(), we need this to be an Acquire read to + // synchronize with the write coming from `is_unique`, so that the + // events prior to that write happen before this read. + match this.inner().weak.compare_exchange_weak(cur, cur + 1, Acquire, Relaxed) { + Ok(_) => { + // Make sure we do not create a dangling Weak + debug_assert!(!is_dangling(this.ptr)); + return Weak { ptr: this.ptr }; + } + Err(old) => cur = old, + } + } + } + + /// Gets the number of [`Weak`] pointers to this allocation. + /// + /// # Safety + /// + /// This method by itself is safe, but using it correctly requires extra care. + /// Another thread can change the weak count at any time, + /// including potentially between calling this method and acting on the result. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// let _weak_five = Arc::downgrade(&five); + /// + /// // This assertion is deterministic because we haven't shared + /// // the `Arc` or `Weak` between threads. + /// assert_eq!(1, Arc::weak_count(&five)); + /// ``` + #[inline] + #[stable(feature = "arc_counts", since = "1.15.0")] + pub fn weak_count(this: &Self) -> usize { + let cnt = this.inner().weak.load(SeqCst); + // If the weak count is currently locked, the value of the + // count was 0 just before taking the lock. + if cnt == usize::MAX { 0 } else { cnt - 1 } + } + + /// Gets the number of strong (`Arc`) pointers to this allocation. + /// + /// # Safety + /// + /// This method by itself is safe, but using it correctly requires extra care. + /// Another thread can change the strong count at any time, + /// including potentially between calling this method and acting on the result. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// let _also_five = Arc::clone(&five); + /// + /// // This assertion is deterministic because we haven't shared + /// // the `Arc` between threads. + /// assert_eq!(2, Arc::strong_count(&five)); + /// ``` + #[inline] + #[stable(feature = "arc_counts", since = "1.15.0")] + pub fn strong_count(this: &Self) -> usize { + this.inner().strong.load(SeqCst) + } + + /// Increments the strong reference count on the `Arc` associated with the + /// provided pointer by one. + /// + /// # Safety + /// + /// The pointer must have been obtained through `Arc::into_raw`, and the + /// associated `Arc` instance must be valid (i.e. the strong count must be at + /// least 1) for the duration of this method. + /// + /// # Examples + /// + /// ``` + /// #![feature(arc_mutate_strong_count)] + /// + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// unsafe { + /// let ptr = Arc::into_raw(five); + /// Arc::incr_strong_count(ptr); + /// + /// // This assertion is deterministic because we haven't shared + /// // the `Arc` between threads. + /// let five = Arc::from_raw(ptr); + /// assert_eq!(2, Arc::strong_count(&five)); + /// } + /// ``` + #[inline] + #[unstable(feature = "arc_mutate_strong_count", issue = "71983")] + pub unsafe fn incr_strong_count(ptr: *const T) { + // Retain Arc, but don't touch refcount by wrapping in ManuallyDrop + let arc = unsafe { mem::ManuallyDrop::new(Arc::::from_raw(ptr)) }; + // Now increase refcount, but don't drop new refcount either + let _arc_clone: mem::ManuallyDrop<_> = arc.clone(); + } + + /// Decrements the strong reference count on the `Arc` associated with the + /// provided pointer by one. + /// + /// # Safety + /// + /// The pointer must have been obtained through `Arc::into_raw`, and the + /// associated `Arc` instance must be valid (i.e. the strong count must be at + /// least 1) when invoking this method. This method can be used to release the final + /// `Arc` and backing storage, but **should not** be called after the final `Arc` has been + /// released. + /// + /// # Examples + /// + /// ``` + /// #![feature(arc_mutate_strong_count)] + /// + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// unsafe { + /// let ptr = Arc::into_raw(five); + /// Arc::incr_strong_count(ptr); + /// + /// // Those assertions are deterministic because we haven't shared + /// // the `Arc` between threads. + /// let five = Arc::from_raw(ptr); + /// assert_eq!(2, Arc::strong_count(&five)); + /// Arc::decr_strong_count(ptr); + /// assert_eq!(1, Arc::strong_count(&five)); + /// } + /// ``` + #[inline] + #[unstable(feature = "arc_mutate_strong_count", issue = "71983")] + pub unsafe fn decr_strong_count(ptr: *const T) { + unsafe { mem::drop(Arc::from_raw(ptr)) }; + } + + #[inline] + fn inner(&self) -> &ArcInner { + // This unsafety is ok because while this arc is alive we're guaranteed + // that the inner pointer is valid. Furthermore, we know that the + // `ArcInner` structure itself is `Sync` because the inner data is + // `Sync` as well, so we're ok loaning out an immutable pointer to these + // contents. + unsafe { self.ptr.as_ref() } + } + + // Non-inlined part of `drop`. + #[inline(never)] + unsafe fn drop_slow(&mut self) { + // Destroy the data at this time, even though we may not free the box + // allocation itself (there may still be weak pointers lying around). + unsafe { ptr::drop_in_place(Self::get_mut_unchecked(self)) }; + + // Drop the weak ref collectively held by all strong references + drop(Weak { ptr: self.ptr }); + } + + #[inline] + #[stable(feature = "ptr_eq", since = "1.17.0")] + /// Returns `true` if the two `Arc`s point to the same allocation + /// (in a vein similar to [`ptr::eq`]). + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// let same_five = Arc::clone(&five); + /// let other_five = Arc::new(5); + /// + /// assert!(Arc::ptr_eq(&five, &same_five)); + /// assert!(!Arc::ptr_eq(&five, &other_five)); + /// ``` + /// + /// [`ptr::eq`]: core::ptr::eq + pub fn ptr_eq(this: &Self, other: &Self) -> bool { + this.ptr.as_ptr() == other.ptr.as_ptr() + } +} + +impl Arc { + /// Allocates an `ArcInner` with sufficient space for + /// a possibly-unsized inner value where the value has the layout provided. + /// + /// The function `mem_to_arcinner` is called with the data pointer + /// and must return back a (potentially fat)-pointer for the `ArcInner`. + unsafe fn allocate_for_layout( + value_layout: Layout, + allocate: impl FnOnce(Layout) -> Result, AllocError>, + mem_to_arcinner: impl FnOnce(*mut u8) -> *mut ArcInner, + ) -> *mut ArcInner { + // Calculate layout using the given value layout. + // Previously, layout was calculated on the expression + // `&*(ptr as *const ArcInner)`, but this created a misaligned + // reference (see #54908). + let layout = Layout::new::>().extend(value_layout).unwrap().0.pad_to_align(); + + let ptr = allocate(layout).unwrap_or_else(|_| handle_alloc_error(layout)); + + // Initialize the ArcInner + let inner = mem_to_arcinner(ptr.as_non_null_ptr().as_ptr()); + debug_assert_eq!(unsafe { Layout::for_value(&*inner) }, layout); + + unsafe { + ptr::write(&mut (*inner).strong, atomic::AtomicUsize::new(1)); + ptr::write(&mut (*inner).weak, atomic::AtomicUsize::new(1)); + } + + inner + } + + /// Allocates an `ArcInner` with sufficient space for an unsized inner value. + unsafe fn allocate_for_ptr(ptr: *const T) -> *mut ArcInner { + // Allocate for the `ArcInner` using the given value. + unsafe { + Self::allocate_for_layout( + Layout::for_value(&*ptr), + |layout| Global.alloc(layout), + |mem| set_data_ptr(ptr as *mut T, mem) as *mut ArcInner, + ) + } + } + + fn from_box(v: Box) -> Arc { + unsafe { + let (box_unique, alloc) = Box::into_unique(v); + let bptr = box_unique.as_ptr(); + + let value_size = size_of_val(&*bptr); + let ptr = Self::allocate_for_ptr(bptr); + + // Copy value as bytes + ptr::copy_nonoverlapping( + bptr as *const T as *const u8, + &mut (*ptr).data as *mut _ as *mut u8, + value_size, + ); + + // Free the allocation without dropping its contents + box_free(box_unique, alloc); + + Self::from_ptr(ptr) + } + } +} + +impl Arc<[T]> { + /// Allocates an `ArcInner<[T]>` with the given length. + unsafe fn allocate_for_slice(len: usize) -> *mut ArcInner<[T]> { + unsafe { + Self::allocate_for_layout( + Layout::array::(len).unwrap(), + |layout| Global.alloc(layout), + |mem| ptr::slice_from_raw_parts_mut(mem as *mut T, len) as *mut ArcInner<[T]>, + ) + } + } +} + +/// Sets the data pointer of a `?Sized` raw pointer. +/// +/// For a slice/trait object, this sets the `data` field and leaves the rest +/// unchanged. For a sized raw pointer, this simply sets the pointer. +unsafe fn set_data_ptr(mut ptr: *mut T, data: *mut U) -> *mut T { + unsafe { + ptr::write(&mut ptr as *mut _ as *mut *mut u8, data as *mut u8); + } + ptr +} + +impl Arc<[T]> { + /// Copy elements from slice into newly allocated Arc<\[T\]> + /// + /// Unsafe because the caller must either take ownership or bind `T: Copy`. + unsafe fn copy_from_slice(v: &[T]) -> Arc<[T]> { + unsafe { + let ptr = Self::allocate_for_slice(v.len()); + + ptr::copy_nonoverlapping(v.as_ptr(), &mut (*ptr).data as *mut [T] as *mut T, v.len()); + + Self::from_ptr(ptr) + } + } + + /// Constructs an `Arc<[T]>` from an iterator known to be of a certain size. + /// + /// Behavior is undefined should the size be wrong. + unsafe fn from_iter_exact(iter: impl iter::Iterator, len: usize) -> Arc<[T]> { + // Panic guard while cloning T elements. + // In the event of a panic, elements that have been written + // into the new ArcInner will be dropped, then the memory freed. + struct Guard { + mem: NonNull, + elems: *mut T, + layout: Layout, + n_elems: usize, + } + + impl Drop for Guard { + fn drop(&mut self) { + unsafe { + let slice = from_raw_parts_mut(self.elems, self.n_elems); + ptr::drop_in_place(slice); + + Global.dealloc(self.mem, self.layout); + } + } + } + + unsafe { + let ptr = Self::allocate_for_slice(len); + + let mem = ptr as *mut _ as *mut u8; + let layout = Layout::for_value(&*ptr); + + // Pointer to first element + let elems = &mut (*ptr).data as *mut [T] as *mut T; + + let mut guard = Guard { mem: NonNull::new_unchecked(mem), elems, layout, n_elems: 0 }; + + for (i, item) in iter.enumerate() { + ptr::write(elems.add(i), item); + guard.n_elems += 1; + } + + // All clear. Forget the guard so it doesn't free the new ArcInner. + mem::forget(guard); + + Self::from_ptr(ptr) + } + } +} + +/// Specialization trait used for `From<&[T]>`. +trait ArcFromSlice { + fn from_slice(slice: &[T]) -> Self; +} + +impl ArcFromSlice for Arc<[T]> { + #[inline] + default fn from_slice(v: &[T]) -> Self { + unsafe { Self::from_iter_exact(v.iter().cloned(), v.len()) } + } +} + +impl ArcFromSlice for Arc<[T]> { + #[inline] + fn from_slice(v: &[T]) -> Self { + unsafe { Arc::copy_from_slice(v) } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Arc { + /// Makes a clone of the `Arc` pointer. + /// + /// This creates another pointer to the same allocation, increasing the + /// strong reference count. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// let _ = Arc::clone(&five); + /// ``` + #[inline] + fn clone(&self) -> Arc { + // Using a relaxed ordering is alright here, as knowledge of the + // original reference prevents other threads from erroneously deleting + // the object. + // + // As explained in the [Boost documentation][1], Increasing the + // reference counter can always be done with memory_order_relaxed: New + // references to an object can only be formed from an existing + // reference, and passing an existing reference from one thread to + // another must already provide any required synchronization. + // + // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html) + let old_size = self.inner().strong.fetch_add(1, Relaxed); + + // However we need to guard against massive refcounts in case someone + // is `mem::forget`ing Arcs. If we don't do this the count can overflow + // and users will use-after free. We racily saturate to `isize::MAX` on + // the assumption that there aren't ~2 billion threads incrementing + // the reference count at once. This branch will never be taken in + // any realistic program. + // + // We abort because such a program is incredibly degenerate, and we + // don't care to support it. + if old_size > MAX_REFCOUNT { + abort(); + } + + Self::from_inner(self.ptr) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Deref for Arc { + type Target = T; + + #[inline] + fn deref(&self) -> &T { + &self.inner().data + } +} + +#[unstable(feature = "receiver_trait", issue = "none")] +impl Receiver for Arc {} + +impl Arc { + /// Makes a mutable reference into the given `Arc`. + /// + /// If there are other `Arc` or [`Weak`] pointers to the same allocation, + /// then `make_mut` will create a new allocation and invoke [`clone`][clone] on the inner value + /// to ensure unique ownership. This is also referred to as clone-on-write. + /// + /// Note that this differs from the behavior of [`Rc::make_mut`] which disassociates + /// any remaining `Weak` pointers. + /// + /// See also [`get_mut`][get_mut], which will fail rather than cloning. + /// + /// [clone]: Clone::clone + /// [get_mut]: Arc::get_mut + /// [`Rc::make_mut`]: super::rc::Rc::make_mut + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let mut data = Arc::new(5); + /// + /// *Arc::make_mut(&mut data) += 1; // Won't clone anything + /// let mut other_data = Arc::clone(&data); // Won't clone inner data + /// *Arc::make_mut(&mut data) += 1; // Clones inner data + /// *Arc::make_mut(&mut data) += 1; // Won't clone anything + /// *Arc::make_mut(&mut other_data) *= 2; // Won't clone anything + /// + /// // Now `data` and `other_data` point to different allocations. + /// assert_eq!(*data, 8); + /// assert_eq!(*other_data, 12); + /// ``` + #[inline] + #[stable(feature = "arc_unique", since = "1.4.0")] + pub fn make_mut(this: &mut Self) -> &mut T { + // Note that we hold both a strong reference and a weak reference. + // Thus, releasing our strong reference only will not, by itself, cause + // the memory to be deallocated. + // + // Use Acquire to ensure that we see any writes to `weak` that happen + // before release writes (i.e., decrements) to `strong`. Since we hold a + // weak count, there's no chance the ArcInner itself could be + // deallocated. + if this.inner().strong.compare_exchange(1, 0, Acquire, Relaxed).is_err() { + // Another strong pointer exists; clone + *this = Arc::new((**this).clone()); + } else if this.inner().weak.load(Relaxed) != 1 { + // Relaxed suffices in the above because this is fundamentally an + // optimization: we are always racing with weak pointers being + // dropped. Worst case, we end up allocated a new Arc unnecessarily. + + // We removed the last strong ref, but there are additional weak + // refs remaining. We'll move the contents to a new Arc, and + // invalidate the other weak refs. + + // Note that it is not possible for the read of `weak` to yield + // usize::MAX (i.e., locked), since the weak count can only be + // locked by a thread with a strong reference. + + // Materialize our own implicit weak pointer, so that it can clean + // up the ArcInner as needed. + let weak = Weak { ptr: this.ptr }; + + // mark the data itself as already deallocated + unsafe { + // there is no data race in the implicit write caused by `read` + // here (due to zeroing) because data is no longer accessed by + // other threads (due to there being no more strong refs at this + // point). + let mut swap = Arc::new(ptr::read(&weak.ptr.as_ref().data)); + mem::swap(this, &mut swap); + mem::forget(swap); + } + } else { + // We were the sole reference of either kind; bump back up the + // strong ref count. + this.inner().strong.store(1, Release); + } + + // As with `get_mut()`, the unsafety is ok because our reference was + // either unique to begin with, or became one upon cloning the contents. + unsafe { Self::get_mut_unchecked(this) } + } +} + +impl Arc { + /// Returns a mutable reference into the given `Arc`, if there are + /// no other `Arc` or [`Weak`] pointers to the same allocation. + /// + /// Returns [`None`] otherwise, because it is not safe to + /// mutate a shared value. + /// + /// See also [`make_mut`][make_mut], which will [`clone`][clone] + /// the inner value when there are other pointers. + /// + /// [make_mut]: Arc::make_mut + /// [clone]: Clone::clone + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let mut x = Arc::new(3); + /// *Arc::get_mut(&mut x).unwrap() = 4; + /// assert_eq!(*x, 4); + /// + /// let _y = Arc::clone(&x); + /// assert!(Arc::get_mut(&mut x).is_none()); + /// ``` + #[inline] + #[stable(feature = "arc_unique", since = "1.4.0")] + pub fn get_mut(this: &mut Self) -> Option<&mut T> { + if this.is_unique() { + // This unsafety is ok because we're guaranteed that the pointer + // returned is the *only* pointer that will ever be returned to T. Our + // reference count is guaranteed to be 1 at this point, and we required + // the Arc itself to be `mut`, so we're returning the only possible + // reference to the inner data. + unsafe { Some(Arc::get_mut_unchecked(this)) } + } else { + None + } + } + + /// Returns a mutable reference into the given `Arc`, + /// without any check. + /// + /// See also [`get_mut`], which is safe and does appropriate checks. + /// + /// [`get_mut`]: Arc::get_mut + /// + /// # Safety + /// + /// Any other `Arc` or [`Weak`] pointers to the same allocation must not be dereferenced + /// for the duration of the returned borrow. + /// This is trivially the case if no such pointers exist, + /// for example immediately after `Arc::new`. + /// + /// # Examples + /// + /// ``` + /// #![feature(get_mut_unchecked)] + /// + /// use std::sync::Arc; + /// + /// let mut x = Arc::new(String::new()); + /// unsafe { + /// Arc::get_mut_unchecked(&mut x).push_str("foo") + /// } + /// assert_eq!(*x, "foo"); + /// ``` + #[inline] + #[unstable(feature = "get_mut_unchecked", issue = "63292")] + pub unsafe fn get_mut_unchecked(this: &mut Self) -> &mut T { + // We are careful to *not* create a reference covering the "count" fields, as + // this would alias with concurrent access to the reference counts (e.g. by `Weak`). + unsafe { &mut (*this.ptr.as_ptr()).data } + } + + /// Determine whether this is the unique reference (including weak refs) to + /// the underlying data. + /// + /// Note that this requires locking the weak ref count. + fn is_unique(&mut self) -> bool { + // lock the weak pointer count if we appear to be the sole weak pointer + // holder. + // + // The acquire label here ensures a happens-before relationship with any + // writes to `strong` (in particular in `Weak::upgrade`) prior to decrements + // of the `weak` count (via `Weak::drop`, which uses release). If the upgraded + // weak ref was never dropped, the CAS here will fail so we do not care to synchronize. + if self.inner().weak.compare_exchange(1, usize::MAX, Acquire, Relaxed).is_ok() { + // This needs to be an `Acquire` to synchronize with the decrement of the `strong` + // counter in `drop` -- the only access that happens when any but the last reference + // is being dropped. + let unique = self.inner().strong.load(Acquire) == 1; + + // The release write here synchronizes with a read in `downgrade`, + // effectively preventing the above read of `strong` from happening + // after the write. + self.inner().weak.store(1, Release); // release the lock + unique + } else { + false + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl<#[may_dangle] T: ?Sized> Drop for Arc { + /// Drops the `Arc`. + /// + /// This will decrement the strong reference count. If the strong reference + /// count reaches zero then the only other references (if any) are + /// [`Weak`], so we `drop` the inner value. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// struct Foo; + /// + /// impl Drop for Foo { + /// fn drop(&mut self) { + /// println!("dropped!"); + /// } + /// } + /// + /// let foo = Arc::new(Foo); + /// let foo2 = Arc::clone(&foo); + /// + /// drop(foo); // Doesn't print anything + /// drop(foo2); // Prints "dropped!" + /// ``` + #[inline] + fn drop(&mut self) { + // Because `fetch_sub` is already atomic, we do not need to synchronize + // with other threads unless we are going to delete the object. This + // same logic applies to the below `fetch_sub` to the `weak` count. + if self.inner().strong.fetch_sub(1, Release) != 1 { + return; + } + + // This fence is needed to prevent reordering of use of the data and + // deletion of the data. Because it is marked `Release`, the decreasing + // of the reference count synchronizes with this `Acquire` fence. This + // means that use of the data happens before decreasing the reference + // count, which happens before this fence, which happens before the + // deletion of the data. + // + // As explained in the [Boost documentation][1], + // + // > It is important to enforce any possible access to the object in one + // > thread (through an existing reference) to *happen before* deleting + // > the object in a different thread. This is achieved by a "release" + // > operation after dropping a reference (any access to the object + // > through this reference must obviously happened before), and an + // > "acquire" operation before deleting the object. + // + // In particular, while the contents of an Arc are usually immutable, it's + // possible to have interior writes to something like a Mutex. Since a + // Mutex is not acquired when it is deleted, we can't rely on its + // synchronization logic to make writes in thread A visible to a destructor + // running in thread B. + // + // Also note that the Acquire fence here could probably be replaced with an + // Acquire load, which could improve performance in highly-contended + // situations. See [2]. + // + // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html) + // [2]: (https://github.com/rust-lang/rust/pull/41714) + acquire!(self.inner().strong); + + unsafe { + self.drop_slow(); + } + } +} + +impl Arc { + #[inline] + #[stable(feature = "rc_downcast", since = "1.29.0")] + /// Attempt to downcast the `Arc` to a concrete type. + /// + /// # Examples + /// + /// ``` + /// use std::any::Any; + /// use std::sync::Arc; + /// + /// fn print_if_string(value: Arc) { + /// if let Ok(string) = value.downcast::() { + /// println!("String ({}): {}", string.len(), string); + /// } + /// } + /// + /// let my_string = "Hello World".to_string(); + /// print_if_string(Arc::new(my_string)); + /// print_if_string(Arc::new(0i8)); + /// ``` + pub fn downcast(self) -> Result, Self> + where + T: Any + Send + Sync + 'static, + { + if (*self).is::() { + let ptr = self.ptr.cast::>(); + mem::forget(self); + Ok(Arc::from_inner(ptr)) + } else { + Err(self) + } + } +} + +impl Weak { + /// Constructs a new `Weak`, without allocating any memory. + /// Calling [`upgrade`] on the return value always gives [`None`]. + /// + /// [`upgrade`]: Weak::upgrade + /// + /// # Examples + /// + /// ``` + /// use std::sync::Weak; + /// + /// let empty: Weak = Weak::new(); + /// assert!(empty.upgrade().is_none()); + /// ``` + #[stable(feature = "downgraded_weak", since = "1.10.0")] + pub fn new() -> Weak { + Weak { ptr: NonNull::new(usize::MAX as *mut ArcInner).expect("MAX is not 0") } + } +} + +/// Helper type to allow accessing the reference counts without +/// making any assertions about the data field. +struct WeakInner<'a> { + weak: &'a atomic::AtomicUsize, + strong: &'a atomic::AtomicUsize, +} + +impl Weak { + /// Returns a raw pointer to the object `T` pointed to by this `Weak`. + /// + /// The pointer is valid only if there are some strong references. The pointer may be dangling, + /// unaligned or even [`null`] otherwise. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// use std::ptr; + /// + /// let strong = Arc::new("hello".to_owned()); + /// let weak = Arc::downgrade(&strong); + /// // Both point to the same object + /// assert!(ptr::eq(&*strong, weak.as_ptr())); + /// // The strong here keeps it alive, so we can still access the object. + /// assert_eq!("hello", unsafe { &*weak.as_ptr() }); + /// + /// drop(strong); + /// // But not any more. We can do weak.as_ptr(), but accessing the pointer would lead to + /// // undefined behaviour. + /// // assert_eq!("hello", unsafe { &*weak.as_ptr() }); + /// ``` + /// + /// [`null`]: core::ptr::null + #[stable(feature = "weak_into_raw", since = "1.45.0")] + pub fn as_ptr(&self) -> *const T { + let ptr: *mut ArcInner = NonNull::as_ptr(self.ptr); + + // SAFETY: we must offset the pointer manually, and said pointer may be + // a dangling weak (usize::MAX) if T is sized. data_offset is safe to call, + // because we know that a pointer to unsized T was derived from a real + // unsized T, as dangling weaks are only created for sized T. wrapping_offset + // is used so that we can use the same code path for the non-dangling + // unsized case and the potentially dangling sized case. + unsafe { + let offset = data_offset(ptr as *mut T); + set_data_ptr(ptr as *mut T, (ptr as *mut u8).wrapping_offset(offset)) + } + } + + /// Consumes the `Weak` and turns it into a raw pointer. + /// + /// This converts the weak pointer into a raw pointer, while still preserving the ownership of + /// one weak reference (the weak count is not modified by this operation). It can be turned + /// back into the `Weak` with [`from_raw`]. + /// + /// The same restrictions of accessing the target of the pointer as with + /// [`as_ptr`] apply. + /// + /// # Examples + /// + /// ``` + /// use std::sync::{Arc, Weak}; + /// + /// let strong = Arc::new("hello".to_owned()); + /// let weak = Arc::downgrade(&strong); + /// let raw = weak.into_raw(); + /// + /// assert_eq!(1, Arc::weak_count(&strong)); + /// assert_eq!("hello", unsafe { &*raw }); + /// + /// drop(unsafe { Weak::from_raw(raw) }); + /// assert_eq!(0, Arc::weak_count(&strong)); + /// ``` + /// + /// [`from_raw`]: Weak::from_raw + /// [`as_ptr`]: Weak::as_ptr + #[stable(feature = "weak_into_raw", since = "1.45.0")] + pub fn into_raw(self) -> *const T { + let result = self.as_ptr(); + mem::forget(self); + result + } + + /// Converts a raw pointer previously created by [`into_raw`] back into `Weak`. + /// + /// This can be used to safely get a strong reference (by calling [`upgrade`] + /// later) or to deallocate the weak count by dropping the `Weak`. + /// + /// It takes ownership of one weak reference (with the exception of pointers created by [`new`], + /// as these don't own anything; the method still works on them). + /// + /// # Safety + /// + /// The pointer must have originated from the [`into_raw`] and must still own its potential + /// weak reference. + /// + /// It is allowed for the strong count to be 0 at the time of calling this. Nevertheless, this + /// takes ownership of one weak reference currently represented as a raw pointer (the weak + /// count is not modified by this operation) and therefore it must be paired with a previous + /// call to [`into_raw`]. + /// # Examples + /// + /// ``` + /// use std::sync::{Arc, Weak}; + /// + /// let strong = Arc::new("hello".to_owned()); + /// + /// let raw_1 = Arc::downgrade(&strong).into_raw(); + /// let raw_2 = Arc::downgrade(&strong).into_raw(); + /// + /// assert_eq!(2, Arc::weak_count(&strong)); + /// + /// assert_eq!("hello", &*unsafe { Weak::from_raw(raw_1) }.upgrade().unwrap()); + /// assert_eq!(1, Arc::weak_count(&strong)); + /// + /// drop(strong); + /// + /// // Decrement the last weak count. + /// assert!(unsafe { Weak::from_raw(raw_2) }.upgrade().is_none()); + /// ``` + /// + /// [`new`]: Weak::new + /// [`into_raw`]: Weak::into_raw + /// [`upgrade`]: Weak::upgrade + /// [`forget`]: std::mem::forget + #[stable(feature = "weak_into_raw", since = "1.45.0")] + pub unsafe fn from_raw(ptr: *const T) -> Self { + // SAFETY: data_offset is safe to call, because this pointer originates from a Weak. + // See Weak::as_ptr for context on how the input pointer is derived. + let offset = unsafe { data_offset(ptr) }; + + // Reverse the offset to find the original ArcInner. + // SAFETY: we use wrapping_offset here because the pointer may be dangling (but only if T: Sized) + let ptr = unsafe { + set_data_ptr(ptr as *mut ArcInner, (ptr as *mut u8).wrapping_offset(-offset)) + }; + + // SAFETY: we now have recovered the original Weak pointer, so can create the Weak. + unsafe { Weak { ptr: NonNull::new_unchecked(ptr) } } + } +} + +impl Weak { + /// Attempts to upgrade the `Weak` pointer to an [`Arc`], delaying + /// dropping of the inner value if successful. + /// + /// Returns [`None`] if the inner value has since been dropped. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// let weak_five = Arc::downgrade(&five); + /// + /// let strong_five: Option> = weak_five.upgrade(); + /// assert!(strong_five.is_some()); + /// + /// // Destroy all strong pointers. + /// drop(strong_five); + /// drop(five); + /// + /// assert!(weak_five.upgrade().is_none()); + /// ``` + #[stable(feature = "arc_weak", since = "1.4.0")] + pub fn upgrade(&self) -> Option> { + // We use a CAS loop to increment the strong count instead of a + // fetch_add as this function should never take the reference count + // from zero to one. + let inner = self.inner()?; + + // Relaxed load because any write of 0 that we can observe + // leaves the field in a permanently zero state (so a + // "stale" read of 0 is fine), and any other value is + // confirmed via the CAS below. + let mut n = inner.strong.load(Relaxed); + + loop { + if n == 0 { + return None; + } + + // See comments in `Arc::clone` for why we do this (for `mem::forget`). + if n > MAX_REFCOUNT { + abort(); + } + + // Relaxed is fine for the failure case because we don't have any expectations about the new state. + // Acquire is necessary for the success case to synchronise with `Arc::new_cyclic`, when the inner + // value can be initialized after `Weak` references have already been created. In that case, we + // expect to observe the fully initialized value. + match inner.strong.compare_exchange_weak(n, n + 1, Acquire, Relaxed) { + Ok(_) => return Some(Arc::from_inner(self.ptr)), // null checked above + Err(old) => n = old, + } + } + } + + /// Gets the number of strong (`Arc`) pointers pointing to this allocation. + /// + /// If `self` was created using [`Weak::new`], this will return 0. + #[stable(feature = "weak_counts", since = "1.41.0")] + pub fn strong_count(&self) -> usize { + if let Some(inner) = self.inner() { inner.strong.load(SeqCst) } else { 0 } + } + + /// Gets an approximation of the number of `Weak` pointers pointing to this + /// allocation. + /// + /// If `self` was created using [`Weak::new`], or if there are no remaining + /// strong pointers, this will return 0. + /// + /// # Accuracy + /// + /// Due to implementation details, the returned value can be off by 1 in + /// either direction when other threads are manipulating any `Arc`s or + /// `Weak`s pointing to the same allocation. + #[stable(feature = "weak_counts", since = "1.41.0")] + pub fn weak_count(&self) -> usize { + self.inner() + .map(|inner| { + let weak = inner.weak.load(SeqCst); + let strong = inner.strong.load(SeqCst); + if strong == 0 { + 0 + } else { + // Since we observed that there was at least one strong pointer + // after reading the weak count, we know that the implicit weak + // reference (present whenever any strong references are alive) + // was still around when we observed the weak count, and can + // therefore safely subtract it. + weak - 1 + } + }) + .unwrap_or(0) + } + + /// Returns `None` when the pointer is dangling and there is no allocated `ArcInner`, + /// (i.e., when this `Weak` was created by `Weak::new`). + #[inline] + fn inner(&self) -> Option> { + if is_dangling(self.ptr) { + None + } else { + // We are careful to *not* create a reference covering the "data" field, as + // the field may be mutated concurrently (for example, if the last `Arc` + // is dropped, the data field will be dropped in-place). + Some(unsafe { + let ptr = self.ptr.as_ptr(); + WeakInner { strong: &(*ptr).strong, weak: &(*ptr).weak } + }) + } + } + + /// Returns `true` if the two `Weak`s point to the same allocation (similar to + /// [`ptr::eq`]), or if both don't point to any allocation + /// (because they were created with `Weak::new()`). + /// + /// # Notes + /// + /// Since this compares pointers it means that `Weak::new()` will equal each + /// other, even though they don't point to any allocation. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let first_rc = Arc::new(5); + /// let first = Arc::downgrade(&first_rc); + /// let second = Arc::downgrade(&first_rc); + /// + /// assert!(first.ptr_eq(&second)); + /// + /// let third_rc = Arc::new(5); + /// let third = Arc::downgrade(&third_rc); + /// + /// assert!(!first.ptr_eq(&third)); + /// ``` + /// + /// Comparing `Weak::new`. + /// + /// ``` + /// use std::sync::{Arc, Weak}; + /// + /// let first = Weak::new(); + /// let second = Weak::new(); + /// assert!(first.ptr_eq(&second)); + /// + /// let third_rc = Arc::new(()); + /// let third = Arc::downgrade(&third_rc); + /// assert!(!first.ptr_eq(&third)); + /// ``` + /// + /// [`ptr::eq`]: core::ptr::eq + #[inline] + #[stable(feature = "weak_ptr_eq", since = "1.39.0")] + pub fn ptr_eq(&self, other: &Self) -> bool { + self.ptr.as_ptr() == other.ptr.as_ptr() + } +} + +#[stable(feature = "arc_weak", since = "1.4.0")] +impl Clone for Weak { + /// Makes a clone of the `Weak` pointer that points to the same allocation. + /// + /// # Examples + /// + /// ``` + /// use std::sync::{Arc, Weak}; + /// + /// let weak_five = Arc::downgrade(&Arc::new(5)); + /// + /// let _ = Weak::clone(&weak_five); + /// ``` + #[inline] + fn clone(&self) -> Weak { + let inner = if let Some(inner) = self.inner() { + inner + } else { + return Weak { ptr: self.ptr }; + }; + // See comments in Arc::clone() for why this is relaxed. This can use a + // fetch_add (ignoring the lock) because the weak count is only locked + // where are *no other* weak pointers in existence. (So we can't be + // running this code in that case). + let old_size = inner.weak.fetch_add(1, Relaxed); + + // See comments in Arc::clone() for why we do this (for mem::forget). + if old_size > MAX_REFCOUNT { + abort(); + } + + Weak { ptr: self.ptr } + } +} + +#[stable(feature = "downgraded_weak", since = "1.10.0")] +impl Default for Weak { + /// Constructs a new `Weak`, without allocating memory. + /// Calling [`upgrade`] on the return value always + /// gives [`None`]. + /// + /// [`upgrade`]: Weak::upgrade + /// + /// # Examples + /// + /// ``` + /// use std::sync::Weak; + /// + /// let empty: Weak = Default::default(); + /// assert!(empty.upgrade().is_none()); + /// ``` + fn default() -> Weak { + Weak::new() + } +} + +#[stable(feature = "arc_weak", since = "1.4.0")] +impl Drop for Weak { + /// Drops the `Weak` pointer. + /// + /// # Examples + /// + /// ``` + /// use std::sync::{Arc, Weak}; + /// + /// struct Foo; + /// + /// impl Drop for Foo { + /// fn drop(&mut self) { + /// println!("dropped!"); + /// } + /// } + /// + /// let foo = Arc::new(Foo); + /// let weak_foo = Arc::downgrade(&foo); + /// let other_weak_foo = Weak::clone(&weak_foo); + /// + /// drop(weak_foo); // Doesn't print anything + /// drop(foo); // Prints "dropped!" + /// + /// assert!(other_weak_foo.upgrade().is_none()); + /// ``` + fn drop(&mut self) { + // If we find out that we were the last weak pointer, then its time to + // deallocate the data entirely. See the discussion in Arc::drop() about + // the memory orderings + // + // It's not necessary to check for the locked state here, because the + // weak count can only be locked if there was precisely one weak ref, + // meaning that drop could only subsequently run ON that remaining weak + // ref, which can only happen after the lock is released. + let inner = if let Some(inner) = self.inner() { inner } else { return }; + + if inner.weak.fetch_sub(1, Release) == 1 { + acquire!(inner.weak); + unsafe { Global.dealloc(self.ptr.cast(), Layout::for_value(self.ptr.as_ref())) } + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +trait ArcEqIdent { + fn eq(&self, other: &Arc) -> bool; + fn ne(&self, other: &Arc) -> bool; +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ArcEqIdent for Arc { + #[inline] + default fn eq(&self, other: &Arc) -> bool { + **self == **other + } + #[inline] + default fn ne(&self, other: &Arc) -> bool { + **self != **other + } +} + +/// We're doing this specialization here, and not as a more general optimization on `&T`, because it +/// would otherwise add a cost to all equality checks on refs. We assume that `Arc`s are used to +/// store large values, that are slow to clone, but also heavy to check for equality, causing this +/// cost to pay off more easily. It's also more likely to have two `Arc` clones, that point to +/// the same value, than two `&T`s. +/// +/// We can only do this when `T: Eq` as a `PartialEq` might be deliberately irreflexive. +#[stable(feature = "rust1", since = "1.0.0")] +impl ArcEqIdent for Arc { + #[inline] + fn eq(&self, other: &Arc) -> bool { + Arc::ptr_eq(self, other) || **self == **other + } + + #[inline] + fn ne(&self, other: &Arc) -> bool { + !Arc::ptr_eq(self, other) && **self != **other + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialEq for Arc { + /// Equality for two `Arc`s. + /// + /// Two `Arc`s are equal if their inner values are equal, even if they are + /// stored in different allocation. + /// + /// If `T` also implements `Eq` (implying reflexivity of equality), + /// two `Arc`s that point to the same allocation are always equal. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// assert!(five == Arc::new(5)); + /// ``` + #[inline] + fn eq(&self, other: &Arc) -> bool { + ArcEqIdent::eq(self, other) + } + + /// Inequality for two `Arc`s. + /// + /// Two `Arc`s are unequal if their inner values are unequal. + /// + /// If `T` also implements `Eq` (implying reflexivity of equality), + /// two `Arc`s that point to the same value are never unequal. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// assert!(five != Arc::new(6)); + /// ``` + #[inline] + fn ne(&self, other: &Arc) -> bool { + ArcEqIdent::ne(self, other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialOrd for Arc { + /// Partial comparison for two `Arc`s. + /// + /// The two are compared by calling `partial_cmp()` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// use std::cmp::Ordering; + /// + /// let five = Arc::new(5); + /// + /// assert_eq!(Some(Ordering::Less), five.partial_cmp(&Arc::new(6))); + /// ``` + fn partial_cmp(&self, other: &Arc) -> Option { + (**self).partial_cmp(&**other) + } + + /// Less-than comparison for two `Arc`s. + /// + /// The two are compared by calling `<` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// assert!(five < Arc::new(6)); + /// ``` + fn lt(&self, other: &Arc) -> bool { + *(*self) < *(*other) + } + + /// 'Less than or equal to' comparison for two `Arc`s. + /// + /// The two are compared by calling `<=` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// assert!(five <= Arc::new(5)); + /// ``` + fn le(&self, other: &Arc) -> bool { + *(*self) <= *(*other) + } + + /// Greater-than comparison for two `Arc`s. + /// + /// The two are compared by calling `>` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// assert!(five > Arc::new(4)); + /// ``` + fn gt(&self, other: &Arc) -> bool { + *(*self) > *(*other) + } + + /// 'Greater than or equal to' comparison for two `Arc`s. + /// + /// The two are compared by calling `>=` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let five = Arc::new(5); + /// + /// assert!(five >= Arc::new(5)); + /// ``` + fn ge(&self, other: &Arc) -> bool { + *(*self) >= *(*other) + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl Ord for Arc { + /// Comparison for two `Arc`s. + /// + /// The two are compared by calling `cmp()` on their inner values. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// use std::cmp::Ordering; + /// + /// let five = Arc::new(5); + /// + /// assert_eq!(Ordering::Less, five.cmp(&Arc::new(6))); + /// ``` + fn cmp(&self, other: &Arc) -> Ordering { + (**self).cmp(&**other) + } +} +#[stable(feature = "rust1", since = "1.0.0")] +impl Eq for Arc {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Display for Arc { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Display::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Debug for Arc { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Debug::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Pointer for Arc { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Pointer::fmt(&(&**self as *const T), f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for Arc { + /// Creates a new `Arc`, with the `Default` value for `T`. + /// + /// # Examples + /// + /// ``` + /// use std::sync::Arc; + /// + /// let x: Arc = Default::default(); + /// assert_eq!(*x, 0); + /// ``` + fn default() -> Arc { + Arc::new(Default::default()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Hash for Arc { + fn hash(&self, state: &mut H) { + (**self).hash(state) + } +} + +#[stable(feature = "from_for_ptrs", since = "1.6.0")] +impl From for Arc { + fn from(t: T) -> Self { + Arc::new(t) + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From<&[T]> for Arc<[T]> { + #[inline] + fn from(v: &[T]) -> Arc<[T]> { + >::from_slice(v) + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From<&str> for Arc { + #[inline] + fn from(v: &str) -> Arc { + let arc = Arc::<[u8]>::from(v.as_bytes()); + unsafe { Arc::from_raw(Arc::into_raw(arc) as *const str) } + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From for Arc { + #[inline] + fn from(v: String) -> Arc { + Arc::from(&v[..]) + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From> for Arc { + #[inline] + fn from(v: Box) -> Arc { + Arc::from_box(v) + } +} + +#[stable(feature = "shared_from_slice", since = "1.21.0")] +impl From> for Arc<[T]> { + #[inline] + fn from(mut v: Vec) -> Arc<[T]> { + unsafe { + let arc = Arc::copy_from_slice(&v); + + // Allow the Vec to free its memory, but not destroy its contents + v.set_len(0); + + arc + } + } +} + +#[stable(feature = "shared_from_cow", since = "1.45.0")] +impl<'a, B> From> for Arc +where + B: ToOwned + ?Sized, + Arc: From<&'a B> + From, +{ + #[inline] + fn from(cow: Cow<'a, B>) -> Arc { + match cow { + Cow::Borrowed(s) => Arc::from(s), + Cow::Owned(s) => Arc::from(s), + } + } +} + +#[stable(feature = "boxed_slice_try_from", since = "1.43.0")] +impl TryFrom> for Arc<[T; N]> { + type Error = Arc<[T]>; + + fn try_from(boxed_slice: Arc<[T]>) -> Result { + if boxed_slice.len() == N { + Ok(unsafe { Arc::from_raw(Arc::into_raw(boxed_slice) as *mut [T; N]) }) + } else { + Err(boxed_slice) + } + } +} + +#[stable(feature = "shared_from_iter", since = "1.37.0")] +impl iter::FromIterator for Arc<[T]> { + /// Takes each element in the `Iterator` and collects it into an `Arc<[T]>`. + /// + /// # Performance characteristics + /// + /// ## The general case + /// + /// In the general case, collecting into `Arc<[T]>` is done by first + /// collecting into a `Vec`. That is, when writing the following: + /// + /// ```rust + /// # use std::sync::Arc; + /// let evens: Arc<[u8]> = (0..10).filter(|&x| x % 2 == 0).collect(); + /// # assert_eq!(&*evens, &[0, 2, 4, 6, 8]); + /// ``` + /// + /// this behaves as if we wrote: + /// + /// ```rust + /// # use std::sync::Arc; + /// let evens: Arc<[u8]> = (0..10).filter(|&x| x % 2 == 0) + /// .collect::>() // The first set of allocations happens here. + /// .into(); // A second allocation for `Arc<[T]>` happens here. + /// # assert_eq!(&*evens, &[0, 2, 4, 6, 8]); + /// ``` + /// + /// This will allocate as many times as needed for constructing the `Vec` + /// and then it will allocate once for turning the `Vec` into the `Arc<[T]>`. + /// + /// ## Iterators of known length + /// + /// When your `Iterator` implements `TrustedLen` and is of an exact size, + /// a single allocation will be made for the `Arc<[T]>`. For example: + /// + /// ```rust + /// # use std::sync::Arc; + /// let evens: Arc<[u8]> = (0..10).collect(); // Just a single allocation happens here. + /// # assert_eq!(&*evens, &*(0..10).collect::>()); + /// ``` + fn from_iter>(iter: I) -> Self { + ToArcSlice::to_arc_slice(iter.into_iter()) + } +} + +/// Specialization trait used for collecting into `Arc<[T]>`. +trait ToArcSlice: Iterator + Sized { + fn to_arc_slice(self) -> Arc<[T]>; +} + +impl> ToArcSlice for I { + default fn to_arc_slice(self) -> Arc<[T]> { + self.collect::>().into() + } +} + +impl> ToArcSlice for I { + fn to_arc_slice(self) -> Arc<[T]> { + // This is the case for a `TrustedLen` iterator. + let (low, high) = self.size_hint(); + if let Some(high) = high { + debug_assert_eq!( + low, + high, + "TrustedLen iterator's size hint is not exact: {:?}", + (low, high) + ); + + unsafe { + // SAFETY: We need to ensure that the iterator has an exact length and we have. + Arc::from_iter_exact(self, low) + } + } else { + // Fall back to normal implementation. + self.collect::>().into() + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl borrow::Borrow for Arc { + fn borrow(&self) -> &T { + &**self + } +} + +#[stable(since = "1.5.0", feature = "smart_ptr_as_ref")] +impl AsRef for Arc { + fn as_ref(&self) -> &T { + &**self + } +} + +#[stable(feature = "pin", since = "1.33.0")] +impl Unpin for Arc {} + +/// Get the offset within an `ArcInner` for +/// a payload of type described by a pointer. +/// +/// # Safety +/// +/// This has the same safety requirements as `align_of_val_raw`. In effect: +/// +/// - This function is safe for any argument if `T` is sized, and +/// - if `T` is unsized, the pointer must have appropriate pointer metadata +/// acquired from the real instance that you are getting this offset for. +unsafe fn data_offset(ptr: *const T) -> isize { + // Align the unsized value to the end of the `ArcInner`. + // Because it is `?Sized`, it will always be the last field in memory. + // Note: This is a detail of the current implementation of the compiler, + // and is not a guaranteed language detail. Do not rely on it outside of std. + unsafe { data_offset_align(align_of_val(&*ptr)) } +} + +#[inline] +fn data_offset_align(align: usize) -> isize { + let layout = Layout::new::>(); + (layout.size() + layout.padding_needed_for(align)) as isize +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/sync/tests.rs b/gcc/testsuite/rust/alloc/alloc/src/sync/tests.rs new file mode 100644 index 000000000000..e8e1e66da5ed --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/sync/tests.rs @@ -0,0 +1,579 @@ +use super::*; + +use std::boxed::Box; +use std::clone::Clone; +use std::convert::{From, TryInto}; +use std::mem::drop; +use std::ops::Drop; +use std::option::Option::{self, None, Some}; +use std::sync::atomic::{ + self, + Ordering::{Acquire, SeqCst}, +}; +use std::sync::mpsc::channel; +use std::sync::Mutex; +use std::thread; + +use crate::vec::Vec; + +struct Canary(*mut atomic::AtomicUsize); + +impl Drop for Canary { + fn drop(&mut self) { + unsafe { + match *self { + Canary(c) => { + (*c).fetch_add(1, SeqCst); + } + } + } + } +} + +#[test] +#[cfg_attr(target_os = "emscripten", ignore)] +fn manually_share_arc() { + let v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; + let arc_v = Arc::new(v); + + let (tx, rx) = channel(); + + let _t = thread::spawn(move || { + let arc_v: Arc> = rx.recv().unwrap(); + assert_eq!((*arc_v)[3], 4); + }); + + tx.send(arc_v.clone()).unwrap(); + + assert_eq!((*arc_v)[2], 3); + assert_eq!((*arc_v)[4], 5); +} + +#[test] +fn test_arc_get_mut() { + let mut x = Arc::new(3); + *Arc::get_mut(&mut x).unwrap() = 4; + assert_eq!(*x, 4); + let y = x.clone(); + assert!(Arc::get_mut(&mut x).is_none()); + drop(y); + assert!(Arc::get_mut(&mut x).is_some()); + let _w = Arc::downgrade(&x); + assert!(Arc::get_mut(&mut x).is_none()); +} + +#[test] +fn weak_counts() { + assert_eq!(Weak::weak_count(&Weak::::new()), 0); + assert_eq!(Weak::strong_count(&Weak::::new()), 0); + + let a = Arc::new(0); + let w = Arc::downgrade(&a); + assert_eq!(Weak::strong_count(&w), 1); + assert_eq!(Weak::weak_count(&w), 1); + let w2 = w.clone(); + assert_eq!(Weak::strong_count(&w), 1); + assert_eq!(Weak::weak_count(&w), 2); + assert_eq!(Weak::strong_count(&w2), 1); + assert_eq!(Weak::weak_count(&w2), 2); + drop(w); + assert_eq!(Weak::strong_count(&w2), 1); + assert_eq!(Weak::weak_count(&w2), 1); + let a2 = a.clone(); + assert_eq!(Weak::strong_count(&w2), 2); + assert_eq!(Weak::weak_count(&w2), 1); + drop(a2); + drop(a); + assert_eq!(Weak::strong_count(&w2), 0); + assert_eq!(Weak::weak_count(&w2), 0); + drop(w2); +} + +#[test] +fn try_unwrap() { + let x = Arc::new(3); + assert_eq!(Arc::try_unwrap(x), Ok(3)); + let x = Arc::new(4); + let _y = x.clone(); + assert_eq!(Arc::try_unwrap(x), Err(Arc::new(4))); + let x = Arc::new(5); + let _w = Arc::downgrade(&x); + assert_eq!(Arc::try_unwrap(x), Ok(5)); +} + +#[test] +fn into_from_raw() { + let x = Arc::new(box "hello"); + let y = x.clone(); + + let x_ptr = Arc::into_raw(x); + drop(y); + unsafe { + assert_eq!(**x_ptr, "hello"); + + let x = Arc::from_raw(x_ptr); + assert_eq!(**x, "hello"); + + assert_eq!(Arc::try_unwrap(x).map(|x| *x), Ok("hello")); + } +} + +#[test] +fn test_into_from_raw_unsized() { + use std::fmt::Display; + use std::string::ToString; + + let arc: Arc = Arc::from("foo"); + + let ptr = Arc::into_raw(arc.clone()); + let arc2 = unsafe { Arc::from_raw(ptr) }; + + assert_eq!(unsafe { &*ptr }, "foo"); + assert_eq!(arc, arc2); + + let arc: Arc = Arc::new(123); + + let ptr = Arc::into_raw(arc.clone()); + let arc2 = unsafe { Arc::from_raw(ptr) }; + + assert_eq!(unsafe { &*ptr }.to_string(), "123"); + assert_eq!(arc2.to_string(), "123"); +} + +#[test] +fn into_from_weak_raw() { + let x = Arc::new(box "hello"); + let y = Arc::downgrade(&x); + + let y_ptr = Weak::into_raw(y); + unsafe { + assert_eq!(**y_ptr, "hello"); + + let y = Weak::from_raw(y_ptr); + let y_up = Weak::upgrade(&y).unwrap(); + assert_eq!(**y_up, "hello"); + drop(y_up); + + assert_eq!(Arc::try_unwrap(x).map(|x| *x), Ok("hello")); + } +} + +#[test] +fn test_cowarc_clone_make_mut() { + let mut cow0 = Arc::new(75); + let mut cow1 = cow0.clone(); + let mut cow2 = cow1.clone(); + + assert!(75 == *Arc::make_mut(&mut cow0)); + assert!(75 == *Arc::make_mut(&mut cow1)); + assert!(75 == *Arc::make_mut(&mut cow2)); + + *Arc::make_mut(&mut cow0) += 1; + *Arc::make_mut(&mut cow1) += 2; + *Arc::make_mut(&mut cow2) += 3; + + assert!(76 == *cow0); + assert!(77 == *cow1); + assert!(78 == *cow2); + + // none should point to the same backing memory + assert!(*cow0 != *cow1); + assert!(*cow0 != *cow2); + assert!(*cow1 != *cow2); +} + +#[test] +fn test_cowarc_clone_unique2() { + let mut cow0 = Arc::new(75); + let cow1 = cow0.clone(); + let cow2 = cow1.clone(); + + assert!(75 == *cow0); + assert!(75 == *cow1); + assert!(75 == *cow2); + + *Arc::make_mut(&mut cow0) += 1; + assert!(76 == *cow0); + assert!(75 == *cow1); + assert!(75 == *cow2); + + // cow1 and cow2 should share the same contents + // cow0 should have a unique reference + assert!(*cow0 != *cow1); + assert!(*cow0 != *cow2); + assert!(*cow1 == *cow2); +} + +#[test] +fn test_cowarc_clone_weak() { + let mut cow0 = Arc::new(75); + let cow1_weak = Arc::downgrade(&cow0); + + assert!(75 == *cow0); + assert!(75 == *cow1_weak.upgrade().unwrap()); + + *Arc::make_mut(&mut cow0) += 1; + + assert!(76 == *cow0); + assert!(cow1_weak.upgrade().is_none()); +} + +#[test] +fn test_live() { + let x = Arc::new(5); + let y = Arc::downgrade(&x); + assert!(y.upgrade().is_some()); +} + +#[test] +fn test_dead() { + let x = Arc::new(5); + let y = Arc::downgrade(&x); + drop(x); + assert!(y.upgrade().is_none()); +} + +#[test] +fn weak_self_cyclic() { + struct Cycle { + x: Mutex>>, + } + + let a = Arc::new(Cycle { x: Mutex::new(None) }); + let b = Arc::downgrade(&a.clone()); + *a.x.lock().unwrap() = Some(b); + + // hopefully we don't double-free (or leak)... +} + +#[test] +fn drop_arc() { + let mut canary = atomic::AtomicUsize::new(0); + let x = Arc::new(Canary(&mut canary as *mut atomic::AtomicUsize)); + drop(x); + assert!(canary.load(Acquire) == 1); +} + +#[test] +fn drop_arc_weak() { + let mut canary = atomic::AtomicUsize::new(0); + let arc = Arc::new(Canary(&mut canary as *mut atomic::AtomicUsize)); + let arc_weak = Arc::downgrade(&arc); + assert!(canary.load(Acquire) == 0); + drop(arc); + assert!(canary.load(Acquire) == 1); + drop(arc_weak); +} + +#[test] +fn test_strong_count() { + let a = Arc::new(0); + assert!(Arc::strong_count(&a) == 1); + let w = Arc::downgrade(&a); + assert!(Arc::strong_count(&a) == 1); + let b = w.upgrade().expect(""); + assert!(Arc::strong_count(&b) == 2); + assert!(Arc::strong_count(&a) == 2); + drop(w); + drop(a); + assert!(Arc::strong_count(&b) == 1); + let c = b.clone(); + assert!(Arc::strong_count(&b) == 2); + assert!(Arc::strong_count(&c) == 2); +} + +#[test] +fn test_weak_count() { + let a = Arc::new(0); + assert!(Arc::strong_count(&a) == 1); + assert!(Arc::weak_count(&a) == 0); + let w = Arc::downgrade(&a); + assert!(Arc::strong_count(&a) == 1); + assert!(Arc::weak_count(&a) == 1); + let x = w.clone(); + assert!(Arc::weak_count(&a) == 2); + drop(w); + drop(x); + assert!(Arc::strong_count(&a) == 1); + assert!(Arc::weak_count(&a) == 0); + let c = a.clone(); + assert!(Arc::strong_count(&a) == 2); + assert!(Arc::weak_count(&a) == 0); + let d = Arc::downgrade(&c); + assert!(Arc::weak_count(&c) == 1); + assert!(Arc::strong_count(&c) == 2); + + drop(a); + drop(c); + drop(d); +} + +#[test] +fn show_arc() { + let a = Arc::new(5); + assert_eq!(format!("{:?}", a), "5"); +} + +// Make sure deriving works with Arc +#[derive(Eq, Ord, PartialEq, PartialOrd, Clone, Debug, Default)] +struct Foo { + inner: Arc, +} + +#[test] +fn test_unsized() { + let x: Arc<[i32]> = Arc::new([1, 2, 3]); + assert_eq!(format!("{:?}", x), "[1, 2, 3]"); + let y = Arc::downgrade(&x.clone()); + drop(x); + assert!(y.upgrade().is_none()); +} + +#[test] +fn test_from_owned() { + let foo = 123; + let foo_arc = Arc::from(foo); + assert!(123 == *foo_arc); +} + +#[test] +fn test_new_weak() { + let foo: Weak = Weak::new(); + assert!(foo.upgrade().is_none()); +} + +#[test] +fn test_ptr_eq() { + let five = Arc::new(5); + let same_five = five.clone(); + let other_five = Arc::new(5); + + assert!(Arc::ptr_eq(&five, &same_five)); + assert!(!Arc::ptr_eq(&five, &other_five)); +} + +#[test] +#[cfg_attr(target_os = "emscripten", ignore)] +fn test_weak_count_locked() { + let mut a = Arc::new(atomic::AtomicBool::new(false)); + let a2 = a.clone(); + let t = thread::spawn(move || { + // Miri is too slow + let count = if cfg!(miri) { 1000 } else { 1000000 }; + for _i in 0..count { + Arc::get_mut(&mut a); + } + a.store(true, SeqCst); + }); + + while !a2.load(SeqCst) { + let n = Arc::weak_count(&a2); + assert!(n < 2, "bad weak count: {}", n); + #[cfg(miri)] // Miri's scheduler does not guarantee liveness, and thus needs this hint. + atomic::spin_loop_hint(); + } + t.join().unwrap(); +} + +#[test] +fn test_from_str() { + let r: Arc = Arc::from("foo"); + + assert_eq!(&r[..], "foo"); +} + +#[test] +fn test_copy_from_slice() { + let s: &[u32] = &[1, 2, 3]; + let r: Arc<[u32]> = Arc::from(s); + + assert_eq!(&r[..], [1, 2, 3]); +} + +#[test] +fn test_clone_from_slice() { + #[derive(Clone, Debug, Eq, PartialEq)] + struct X(u32); + + let s: &[X] = &[X(1), X(2), X(3)]; + let r: Arc<[X]> = Arc::from(s); + + assert_eq!(&r[..], s); +} + +#[test] +#[should_panic] +fn test_clone_from_slice_panic() { + use std::string::{String, ToString}; + + struct Fail(u32, String); + + impl Clone for Fail { + fn clone(&self) -> Fail { + if self.0 == 2 { + panic!(); + } + Fail(self.0, self.1.clone()) + } + } + + let s: &[Fail] = + &[Fail(0, "foo".to_string()), Fail(1, "bar".to_string()), Fail(2, "baz".to_string())]; + + // Should panic, but not cause memory corruption + let _r: Arc<[Fail]> = Arc::from(s); +} + +#[test] +fn test_from_box() { + let b: Box = box 123; + let r: Arc = Arc::from(b); + + assert_eq!(*r, 123); +} + +#[test] +fn test_from_box_str() { + use std::string::String; + + let s = String::from("foo").into_boxed_str(); + let r: Arc = Arc::from(s); + + assert_eq!(&r[..], "foo"); +} + +#[test] +fn test_from_box_slice() { + let s = vec![1, 2, 3].into_boxed_slice(); + let r: Arc<[u32]> = Arc::from(s); + + assert_eq!(&r[..], [1, 2, 3]); +} + +#[test] +fn test_from_box_trait() { + use std::fmt::Display; + use std::string::ToString; + + let b: Box = box 123; + let r: Arc = Arc::from(b); + + assert_eq!(r.to_string(), "123"); +} + +#[test] +fn test_from_box_trait_zero_sized() { + use std::fmt::Debug; + + let b: Box = box (); + let r: Arc = Arc::from(b); + + assert_eq!(format!("{:?}", r), "()"); +} + +#[test] +fn test_from_vec() { + let v = vec![1, 2, 3]; + let r: Arc<[u32]> = Arc::from(v); + + assert_eq!(&r[..], [1, 2, 3]); +} + +#[test] +fn test_downcast() { + use std::any::Any; + + let r1: Arc = Arc::new(i32::MAX); + let r2: Arc = Arc::new("abc"); + + assert!(r1.clone().downcast::().is_err()); + + let r1i32 = r1.downcast::(); + assert!(r1i32.is_ok()); + assert_eq!(r1i32.unwrap(), Arc::new(i32::MAX)); + + assert!(r2.clone().downcast::().is_err()); + + let r2str = r2.downcast::<&'static str>(); + assert!(r2str.is_ok()); + assert_eq!(r2str.unwrap(), Arc::new("abc")); +} + +#[test] +fn test_array_from_slice() { + let v = vec![1, 2, 3]; + let r: Arc<[u32]> = Arc::from(v); + + let a: Result, _> = r.clone().try_into(); + assert!(a.is_ok()); + + let a: Result, _> = r.clone().try_into(); + assert!(a.is_err()); +} + +#[test] +fn test_arc_cyclic_with_zero_refs() { + struct ZeroRefs { + inner: Weak, + } + let zero_refs = Arc::new_cyclic(|inner| { + assert_eq!(inner.strong_count(), 0); + assert!(inner.upgrade().is_none()); + ZeroRefs { inner: Weak::new() } + }); + + assert_eq!(Arc::strong_count(&zero_refs), 1); + assert_eq!(Arc::weak_count(&zero_refs), 0); + assert_eq!(zero_refs.inner.strong_count(), 0); + assert_eq!(zero_refs.inner.weak_count(), 0); +} + +#[test] +fn test_arc_new_cyclic_one_ref() { + struct OneRef { + inner: Weak, + } + let one_ref = Arc::new_cyclic(|inner| { + assert_eq!(inner.strong_count(), 0); + assert!(inner.upgrade().is_none()); + OneRef { inner: inner.clone() } + }); + + assert_eq!(Arc::strong_count(&one_ref), 1); + assert_eq!(Arc::weak_count(&one_ref), 1); + + let one_ref2 = Weak::upgrade(&one_ref.inner).unwrap(); + assert!(Arc::ptr_eq(&one_ref, &one_ref2)); + + assert_eq!(Arc::strong_count(&one_ref), 2); + assert_eq!(Arc::weak_count(&one_ref), 1); +} + +#[test] +fn test_arc_cyclic_two_refs() { + struct TwoRefs { + inner1: Weak, + inner2: Weak, + } + let two_refs = Arc::new_cyclic(|inner| { + assert_eq!(inner.strong_count(), 0); + assert!(inner.upgrade().is_none()); + + let inner1 = inner.clone(); + let inner2 = inner1.clone(); + + TwoRefs { inner1, inner2 } + }); + + assert_eq!(Arc::strong_count(&two_refs), 1); + assert_eq!(Arc::weak_count(&two_refs), 2); + + let two_refs1 = Weak::upgrade(&two_refs.inner1).unwrap(); + assert!(Arc::ptr_eq(&two_refs, &two_refs1)); + + let two_refs2 = Weak::upgrade(&two_refs.inner2).unwrap(); + assert!(Arc::ptr_eq(&two_refs, &two_refs2)); + + assert_eq!(Arc::strong_count(&two_refs), 3); + assert_eq!(Arc::weak_count(&two_refs), 2); +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/task.rs b/gcc/testsuite/rust/alloc/alloc/src/task.rs new file mode 100644 index 000000000000..a89290bae028 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/task.rs @@ -0,0 +1,94 @@ +#![unstable(feature = "wake_trait", issue = "69912")] +//! Types and Traits for working with asynchronous tasks. + +use crate::gccrs_core_prelude::*; + +use core::mem::ManuallyDrop; +use core::task::{RawWaker, RawWakerVTable, Waker}; + +use crate::sync::Arc; + +/// The implementation of waking a task on an executor. +/// +/// This trait can be used to create a [`Waker`]. An executor can define an +/// implementation of this trait, and use that to construct a Waker to pass +/// to the tasks that are executed on that executor. +/// +/// This trait is a memory-safe and ergonomic alternative to constructing a +/// [`RawWaker`]. It supports the common executor design in which the data used +/// to wake up a task is stored in an [`Arc`]. Some executors (especially +/// those for embedded systems) cannot use this API, which is why [`RawWaker`] +/// exists as an alternative for those systems. +#[unstable(feature = "wake_trait", issue = "69912")] +pub trait Wake { + /// Wake this task. + #[unstable(feature = "wake_trait", issue = "69912")] + fn wake(self: Arc); + + /// Wake this task without consuming the waker. + /// + /// If an executor supports a cheaper way to wake without consuming the + /// waker, it should override this method. By default, it clones the + /// [`Arc`] and calls `wake` on the clone. + #[unstable(feature = "wake_trait", issue = "69912")] + fn wake_by_ref(self: &Arc) { + self.clone().wake(); + } +} + +#[allow(rustc::ineffective_unstable_trait_impl)] +#[unstable(feature = "wake_trait", issue = "69912")] +impl From> for Waker { + fn from(waker: Arc) -> Waker { + // SAFETY: This is safe because raw_waker safely constructs + // a RawWaker from Arc. + unsafe { Waker::from_raw(raw_waker(waker)) } + } +} + +#[allow(rustc::ineffective_unstable_trait_impl)] +#[unstable(feature = "wake_trait", issue = "69912")] +impl From> for RawWaker { + fn from(waker: Arc) -> RawWaker { + raw_waker(waker) + } +} + +// NB: This private function for constructing a RawWaker is used, rather than +// inlining this into the `From> for RawWaker` impl, to ensure that +// the safety of `From> for Waker` does not depend on the correct +// trait dispatch - instead both impls call this function directly and +// explicitly. +#[inline(always)] +fn raw_waker(waker: Arc) -> RawWaker { + // Increment the reference count of the arc to clone it. + unsafe fn clone_waker(waker: *const ()) -> RawWaker { + unsafe { Arc::incr_strong_count(waker as *const W) }; + RawWaker::new( + waker as *const (), + &RawWakerVTable::new(clone_waker::, wake::, wake_by_ref::, drop_waker::), + ) + } + + // Wake by value, moving the Arc into the Wake::wake function + unsafe fn wake(waker: *const ()) { + let waker = unsafe { Arc::from_raw(waker as *const W) }; + ::wake(waker); + } + + // Wake by reference, wrap the waker in ManuallyDrop to avoid dropping it + unsafe fn wake_by_ref(waker: *const ()) { + let waker = unsafe { ManuallyDrop::new(Arc::from_raw(waker as *const W)) }; + ::wake_by_ref(&waker); + } + + // Decrement the reference count of the Arc on drop + unsafe fn drop_waker(waker: *const ()) { + unsafe { Arc::decr_strong_count(waker as *const W) }; + } + + RawWaker::new( + Arc::into_raw(waker) as *const (), + &RawWakerVTable::new(clone_waker::, wake::, wake_by_ref::, drop_waker::), + ) +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/tests.rs b/gcc/testsuite/rust/alloc/alloc/src/tests.rs new file mode 100644 index 000000000000..bddaab0c7618 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/tests.rs @@ -0,0 +1,151 @@ +//! Test for `boxed` mod. + +use core::any::Any; +use core::clone::Clone; +use core::convert::TryInto; +use core::ops::Deref; +use core::result::Result::{Err, Ok}; + +use std::boxed::Box; + +#[test] +fn test_owned_clone() { + let a = Box::new(5); + let b: Box = a.clone(); + assert!(a == b); +} + +#[derive(PartialEq, Eq)] +struct Test; + +#[test] +fn any_move() { + let a = Box::new(8) as Box; + let b = Box::new(Test) as Box; + + match a.downcast::() { + Ok(a) => { + assert!(a == Box::new(8)); + } + Err(..) => panic!(), + } + match b.downcast::() { + Ok(a) => { + assert!(a == Box::new(Test)); + } + Err(..) => panic!(), + } + + let a = Box::new(8) as Box; + let b = Box::new(Test) as Box; + + assert!(a.downcast::>().is_err()); + assert!(b.downcast::>().is_err()); +} + +#[test] +fn test_show() { + let a = Box::new(8) as Box; + let b = Box::new(Test) as Box; + let a_str = format!("{:?}", a); + let b_str = format!("{:?}", b); + assert_eq!(a_str, "Any"); + assert_eq!(b_str, "Any"); + + static EIGHT: usize = 8; + static TEST: Test = Test; + let a = &EIGHT as &dyn Any; + let b = &TEST as &dyn Any; + let s = format!("{:?}", a); + assert_eq!(s, "Any"); + let s = format!("{:?}", b); + assert_eq!(s, "Any"); +} + +#[test] +fn deref() { + fn homura>(_: T) {} + homura(Box::new(765)); +} + +#[test] +fn raw_sized() { + let x = Box::new(17); + let p = Box::into_raw(x); + unsafe { + assert_eq!(17, *p); + *p = 19; + let y = Box::from_raw(p); + assert_eq!(19, *y); + } +} + +#[test] +fn raw_trait() { + trait Foo { + fn get(&self) -> u32; + fn set(&mut self, value: u32); + } + + struct Bar(u32); + + impl Foo for Bar { + fn get(&self) -> u32 { + self.0 + } + + fn set(&mut self, value: u32) { + self.0 = value; + } + } + + let x: Box = Box::new(Bar(17)); + let p = Box::into_raw(x); + unsafe { + assert_eq!(17, (*p).get()); + (*p).set(19); + let y: Box = Box::from_raw(p); + assert_eq!(19, y.get()); + } +} + +#[test] +fn f64_slice() { + let slice: &[f64] = &[-1.0, 0.0, 1.0, f64::INFINITY]; + let boxed: Box<[f64]> = Box::from(slice); + assert_eq!(&*boxed, slice) +} + +#[test] +fn i64_slice() { + let slice: &[i64] = &[i64::MIN, -2, -1, 0, 1, 2, i64::MAX]; + let boxed: Box<[i64]> = Box::from(slice); + assert_eq!(&*boxed, slice) +} + +#[test] +fn str_slice() { + let s = "Hello, world!"; + let boxed: Box = Box::from(s); + assert_eq!(&*boxed, s) +} + +#[test] +fn boxed_slice_from_iter() { + let iter = 0..100; + let boxed: Box<[u32]> = iter.collect(); + assert_eq!(boxed.len(), 100); + assert_eq!(boxed[7], 7); +} + +#[test] +fn test_array_from_slice() { + let v = vec![1, 2, 3]; + let r: Box<[u32]> = v.into_boxed_slice(); + + let a: Result, _> = r.clone().try_into(); + assert!(a.is_ok()); + + let a: Result, _> = r.clone().try_into(); + assert!(a.is_err()); +} diff --git a/gcc/testsuite/rust/alloc/alloc/src/vec.rs b/gcc/testsuite/rust/alloc/alloc/src/vec.rs new file mode 100644 index 000000000000..2ef4d2fd5712 --- /dev/null +++ b/gcc/testsuite/rust/alloc/alloc/src/vec.rs @@ -0,0 +1,3441 @@ +// ignore-tidy-filelength +//! A contiguous growable array type with heap-allocated contents, written +//! `Vec`. +//! +//! Vectors have `O(1)` indexing, amortized `O(1)` push (to the end) and +//! `O(1)` pop (from the end). +//! +//! Vectors ensure they never allocate more than `isize::MAX` bytes. +//! +//! # Examples +//! +//! You can explicitly create a [`Vec`] with [`Vec::new`]: +//! +//! ``` +//! let v: Vec = Vec::new(); +//! ``` +//! +//! ...or by using the [`vec!`] macro: +//! +//! ``` +//! let v: Vec = vec![]; +//! +//! let v = vec![1, 2, 3, 4, 5]; +//! +//! let v = vec![0; 10]; // ten zeroes +//! ``` +//! +//! You can [`push`] values onto the end of a vector (which will grow the vector +//! as needed): +//! +//! ``` +//! let mut v = vec![1, 2]; +//! +//! v.push(3); +//! ``` +//! +//! Popping values works in much the same way: +//! +//! ``` +//! let mut v = vec![1, 2]; +//! +//! let two = v.pop(); +//! ``` +//! +//! Vectors also support indexing (through the [`Index`] and [`IndexMut`] traits): +//! +//! ``` +//! let mut v = vec![1, 2, 3]; +//! let three = v[2]; +//! v[1] = v[1] + 5; +//! ``` +//! +//! [`push`]: Vec::push + +#![stable(feature = "rust1", since = "1.0.0")] + +use crate::gccrs_core_prelude::*; + +use core::cmp::{self, Ordering}; +use core::convert::TryFrom; +use core::fmt; +use core::hash::{Hash, Hasher}; +use core::intrinsics::{arith_offset, assume}; +use core::iter::{ + FromIterator, FusedIterator, InPlaceIterable, SourceIter, TrustedLen, TrustedRandomAccess, +}; +use core::marker::PhantomData; +use core::mem::{self, ManuallyDrop, MaybeUninit}; +use core::ops::{self, Index, IndexMut, Range, RangeBounds}; +use core::ptr::{self, NonNull}; +use core::slice::{self, SliceIndex}; + +use crate::borrow::{Cow, ToOwned}; +use crate::boxed::Box; +use crate::collections::TryReserveError; +use crate::raw_vec::RawVec; + +/// A contiguous growable array type, written `Vec` but pronounced 'vector'. +/// +/// # Examples +/// +/// ``` +/// let mut vec = Vec::new(); +/// vec.push(1); +/// vec.push(2); +/// +/// assert_eq!(vec.len(), 2); +/// assert_eq!(vec[0], 1); +/// +/// assert_eq!(vec.pop(), Some(2)); +/// assert_eq!(vec.len(), 1); +/// +/// vec[0] = 7; +/// assert_eq!(vec[0], 7); +/// +/// vec.extend([1, 2, 3].iter().copied()); +/// +/// for x in &vec { +/// println!("{}", x); +/// } +/// assert_eq!(vec, [7, 1, 2, 3]); +/// ``` +/// +/// The [`vec!`] macro is provided to make initialization more convenient: +/// +/// ``` +/// let mut vec = vec![1, 2, 3]; +/// vec.push(4); +/// assert_eq!(vec, [1, 2, 3, 4]); +/// ``` +/// +/// It can also initialize each element of a `Vec` with a given value. +/// This may be more efficient than performing allocation and initialization +/// in separate steps, especially when initializing a vector of zeros: +/// +/// ``` +/// let vec = vec![0; 5]; +/// assert_eq!(vec, [0, 0, 0, 0, 0]); +/// +/// // The following is equivalent, but potentially slower: +/// let mut vec = Vec::with_capacity(5); +/// vec.resize(5, 0); +/// assert_eq!(vec, [0, 0, 0, 0, 0]); +/// ``` +/// +/// For more information, see +/// [Capacity and Reallocation](#capacity-and-reallocation). +/// +/// Use a `Vec` as an efficient stack: +/// +/// ``` +/// let mut stack = Vec::new(); +/// +/// stack.push(1); +/// stack.push(2); +/// stack.push(3); +/// +/// while let Some(top) = stack.pop() { +/// // Prints 3, 2, 1 +/// println!("{}", top); +/// } +/// ``` +/// +/// # Indexing +/// +/// The `Vec` type allows to access values by index, because it implements the +/// [`Index`] trait. An example will be more explicit: +/// +/// ``` +/// let v = vec![0, 2, 4, 6]; +/// println!("{}", v[1]); // it will display '2' +/// ``` +/// +/// However be careful: if you try to access an index which isn't in the `Vec`, +/// your software will panic! You cannot do this: +/// +/// ```should_panic +/// let v = vec![0, 2, 4, 6]; +/// println!("{}", v[6]); // it will panic! +/// ``` +/// +/// Use [`get`] and [`get_mut`] if you want to check whether the index is in +/// the `Vec`. +/// +/// # Slicing +/// +/// A `Vec` can be mutable. Slices, on the other hand, are read-only objects. +/// To get a [slice], use [`&`]. Example: +/// +/// ``` +/// fn read_slice(slice: &[usize]) { +/// // ... +/// } +/// +/// let v = vec![0, 1]; +/// read_slice(&v); +/// +/// // ... and that's all! +/// // you can also do it like this: +/// let u: &[usize] = &v; +/// // or like this: +/// let u: &[_] = &v; +/// ``` +/// +/// In Rust, it's more common to pass slices as arguments rather than vectors +/// when you just want to provide read access. The same goes for [`String`] and +/// [`&str`]. +/// +/// # Capacity and reallocation +/// +/// The capacity of a vector is the amount of space allocated for any future +/// elements that will be added onto the vector. This is not to be confused with +/// the *length* of a vector, which specifies the number of actual elements +/// within the vector. If a vector's length exceeds its capacity, its capacity +/// will automatically be increased, but its elements will have to be +/// reallocated. +/// +/// For example, a vector with capacity 10 and length 0 would be an empty vector +/// with space for 10 more elements. Pushing 10 or fewer elements onto the +/// vector will not change its capacity or cause reallocation to occur. However, +/// if the vector's length is increased to 11, it will have to reallocate, which +/// can be slow. For this reason, it is recommended to use [`Vec::with_capacity`] +/// whenever possible to specify how big the vector is expected to get. +/// +/// # Guarantees +/// +/// Due to its incredibly fundamental nature, `Vec` makes a lot of guarantees +/// about its design. This ensures that it's as low-overhead as possible in +/// the general case, and can be correctly manipulated in primitive ways +/// by unsafe code. Note that these guarantees refer to an unqualified `Vec`. +/// If additional type parameters are added (e.g., to support custom allocators), +/// overriding their defaults may change the behavior. +/// +/// Most fundamentally, `Vec` is and always will be a (pointer, capacity, length) +/// triplet. No more, no less. The order of these fields is completely +/// unspecified, and you should use the appropriate methods to modify these. +/// The pointer will never be null, so this type is null-pointer-optimized. +/// +/// However, the pointer may not actually point to allocated memory. In particular, +/// if you construct a `Vec` with capacity 0 via [`Vec::new`], [`vec![]`][`vec!`], +/// [`Vec::with_capacity(0)`][`Vec::with_capacity`], or by calling [`shrink_to_fit`] +/// on an empty Vec, it will not allocate memory. Similarly, if you store zero-sized +/// types inside a `Vec`, it will not allocate space for them. *Note that in this case +/// the `Vec` may not report a [`capacity`] of 0*. `Vec` will allocate if and only +/// if [`mem::size_of::`]`() * capacity() > 0`. In general, `Vec`'s allocation +/// details are very subtle — if you intend to allocate memory using a `Vec` +/// and use it for something else (either to pass to unsafe code, or to build your +/// own memory-backed collection), be sure to deallocate this memory by using +/// `from_raw_parts` to recover the `Vec` and then dropping it. +/// +/// If a `Vec` *has* allocated memory, then the memory it points to is on the heap +/// (as defined by the allocator Rust is configured to use by default), and its +/// pointer points to [`len`] initialized, contiguous elements in order (what +/// you would see if you coerced it to a slice), followed by [`capacity`]` - +/// `[`len`] logically uninitialized, contiguous elements. +/// +/// `Vec` will never perform a "small optimization" where elements are actually +/// stored on the stack for two reasons: +/// +/// * It would make it more difficult for unsafe code to correctly manipulate +/// a `Vec`. The contents of a `Vec` wouldn't have a stable address if it were +/// only moved, and it would be more difficult to determine if a `Vec` had +/// actually allocated memory. +/// +/// * It would penalize the general case, incurring an additional branch +/// on every access. +/// +/// `Vec` will never automatically shrink itself, even if completely empty. This +/// ensures no unnecessary allocations or deallocations occur. Emptying a `Vec` +/// and then filling it back up to the same [`len`] should incur no calls to +/// the allocator. If you wish to free up unused memory, use +/// [`shrink_to_fit`]. +/// +/// [`push`] and [`insert`] will never (re)allocate if the reported capacity is +/// sufficient. [`push`] and [`insert`] *will* (re)allocate if +/// [`len`]` == `[`capacity`]. That is, the reported capacity is completely +/// accurate, and can be relied on. It can even be used to manually free the memory +/// allocated by a `Vec` if desired. Bulk insertion methods *may* reallocate, even +/// when not necessary. +/// +/// `Vec` does not guarantee any particular growth strategy when reallocating +/// when full, nor when [`reserve`] is called. The current strategy is basic +/// and it may prove desirable to use a non-constant growth factor. Whatever +/// strategy is used will of course guarantee *O*(1) amortized [`push`]. +/// +/// `vec![x; n]`, `vec![a, b, c, d]`, and +/// [`Vec::with_capacity(n)`][`Vec::with_capacity`], will all produce a `Vec` +/// with exactly the requested capacity. If [`len`]` == `[`capacity`], +/// (as is the case for the [`vec!`] macro), then a `Vec` can be converted to +/// and from a [`Box<[T]>`][owned slice] without reallocating or moving the elements. +/// +/// `Vec` will not specifically overwrite any data that is removed from it, +/// but also won't specifically preserve it. Its uninitialized memory is +/// scratch space that it may use however it wants. It will generally just do +/// whatever is most efficient or otherwise easy to implement. Do not rely on +/// removed data to be erased for security purposes. Even if you drop a `Vec`, its +/// buffer may simply be reused by another `Vec`. Even if you zero a `Vec`'s memory +/// first, that may not actually happen because the optimizer does not consider +/// this a side-effect that must be preserved. There is one case which we will +/// not break, however: using `unsafe` code to write to the excess capacity, +/// and then increasing the length to match, is always valid. +/// +/// `Vec` does not currently guarantee the order in which elements are dropped. +/// The order has changed in the past and may change again. +/// +/// [`get`]: ../../std/vec/struct.Vec.html#method.get +/// [`get_mut`]: ../../std/vec/struct.Vec.html#method.get_mut +/// [`String`]: crate::string::String +/// [`&str`]: type@str +/// [`shrink_to_fit`]: Vec::shrink_to_fit +/// [`capacity`]: Vec::capacity +/// [`mem::size_of::`]: core::mem::size_of +/// [`len`]: Vec::len +/// [`push`]: Vec::push +/// [`insert`]: Vec::insert +/// [`reserve`]: Vec::reserve +/// [owned slice]: Box +/// [slice]: ../../std/primitive.slice.html +/// [`&`]: ../../std/primitive.reference.html +#[stable(feature = "rust1", since = "1.0.0")] +#[cfg_attr(not(test), rustc_diagnostic_item = "vec_type")] +pub struct Vec { + buf: RawVec, + len: usize, +} + +//////////////////////////////////////////////////////////////////////////////// +// Inherent methods +//////////////////////////////////////////////////////////////////////////////// + +impl Vec { + /// Constructs a new, empty `Vec`. + /// + /// The vector will not allocate until elements are pushed onto it. + /// + /// # Examples + /// + /// ``` + /// # #![allow(unused_mut)] + /// let mut vec: Vec = Vec::new(); + /// ``` + #[inline] + #[rustc_const_stable(feature = "const_vec_new", since = "1.39.0")] + #[stable(feature = "rust1", since = "1.0.0")] + pub const fn new() -> Vec { + Vec { buf: RawVec::NEW, len: 0 } + } + + /// Constructs a new, empty `Vec` with the specified capacity. + /// + /// The vector will be able to hold exactly `capacity` elements without + /// reallocating. If `capacity` is 0, the vector will not allocate. + /// + /// It is important to note that although the returned vector has the + /// *capacity* specified, the vector will have a zero *length*. For an + /// explanation of the difference between length and capacity, see + /// *[Capacity and reallocation]*. + /// + /// [Capacity and reallocation]: #capacity-and-reallocation + /// + /// # Examples + /// + /// ``` + /// let mut vec = Vec::with_capacity(10); + /// + /// // The vector contains no items, even though it has capacity for more + /// assert_eq!(vec.len(), 0); + /// assert_eq!(vec.capacity(), 10); + /// + /// // These are all done without reallocating... + /// for i in 0..10 { + /// vec.push(i); + /// } + /// assert_eq!(vec.len(), 10); + /// assert_eq!(vec.capacity(), 10); + /// + /// // ...but this may make the vector reallocate + /// vec.push(11); + /// assert_eq!(vec.len(), 11); + /// assert!(vec.capacity() >= 11); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn with_capacity(capacity: usize) -> Vec { + Vec { buf: RawVec::with_capacity(capacity), len: 0 } + } + + /// Decomposes a `Vec` into its raw components. + /// + /// Returns the raw pointer to the underlying data, the length of + /// the vector (in elements), and the allocated capacity of the + /// data (in elements). These are the same arguments in the same + /// order as the arguments to [`from_raw_parts`]. + /// + /// After calling this function, the caller is responsible for the + /// memory previously managed by the `Vec`. The only way to do + /// this is to convert the raw pointer, length, and capacity back + /// into a `Vec` with the [`from_raw_parts`] function, allowing + /// the destructor to perform the cleanup. + /// + /// [`from_raw_parts`]: Vec::from_raw_parts + /// + /// # Examples + /// + /// ``` + /// #![feature(vec_into_raw_parts)] + /// let v: Vec = vec![-1, 0, 1]; + /// + /// let (ptr, len, cap) = v.into_raw_parts(); + /// + /// let rebuilt = unsafe { + /// // We can now make changes to the components, such as + /// // transmuting the raw pointer to a compatible type. + /// let ptr = ptr as *mut u32; + /// + /// Vec::from_raw_parts(ptr, len, cap) + /// }; + /// assert_eq!(rebuilt, [4294967295, 0, 1]); + /// ``` + #[unstable(feature = "vec_into_raw_parts", reason = "new API", issue = "65816")] + pub fn into_raw_parts(self) -> (*mut T, usize, usize) { + let mut me = ManuallyDrop::new(self); + (me.as_mut_ptr(), me.len(), me.capacity()) + } + + /// Creates a `Vec` directly from the raw components of another vector. + /// + /// # Safety + /// + /// This is highly unsafe, due to the number of invariants that aren't + /// checked: + /// + /// * `ptr` needs to have been previously allocated via [`String`]/`Vec` + /// (at least, it's highly likely to be incorrect if it wasn't). + /// * `T` needs to have the same size and alignment as what `ptr` was allocated with. + /// (`T` having a less strict alignment is not sufficient, the alignment really + /// needs to be equal to satisfy the [`dealloc`] requirement that memory must be + /// allocated and deallocated with the same layout.) + /// * `length` needs to be less than or equal to `capacity`. + /// * `capacity` needs to be the capacity that the pointer was allocated with. + /// + /// Violating these may cause problems like corrupting the allocator's + /// internal data structures. For example it is **not** safe + /// to build a `Vec` from a pointer to a C `char` array with length `size_t`. + /// It's also not safe to build one from a `Vec` and its length, because + /// the allocator cares about the alignment, and these two types have different + /// alignments. The buffer was allocated with alignment 2 (for `u16`), but after + /// turning it into a `Vec` it'll be deallocated with alignment 1. + /// + /// The ownership of `ptr` is effectively transferred to the + /// `Vec` which may then deallocate, reallocate or change the + /// contents of memory pointed to by the pointer at will. Ensure + /// that nothing else uses the pointer after calling this + /// function. + /// + /// [`String`]: crate::string::String + /// [`dealloc`]: crate::alloc::GlobalAlloc::dealloc + /// + /// # Examples + /// + /// ``` + /// use std::ptr; + /// use std::mem; + /// + /// let v = vec![1, 2, 3]; + /// + // FIXME Update this when vec_into_raw_parts is stabilized + /// // Prevent running `v`'s destructor so we are in complete control + /// // of the allocation. + /// let mut v = mem::ManuallyDrop::new(v); + /// + /// // Pull out the various important pieces of information about `v` + /// let p = v.as_mut_ptr(); + /// let len = v.len(); + /// let cap = v.capacity(); + /// + /// unsafe { + /// // Overwrite memory with 4, 5, 6 + /// for i in 0..len as isize { + /// ptr::write(p.offset(i), 4 + i); + /// } + /// + /// // Put everything back together into a Vec + /// let rebuilt = Vec::from_raw_parts(p, len, cap); + /// assert_eq!(rebuilt, [4, 5, 6]); + /// } + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub unsafe fn from_raw_parts(ptr: *mut T, length: usize, capacity: usize) -> Vec { + unsafe { Vec { buf: RawVec::from_raw_parts(ptr, capacity), len: length } } + } + + /// Returns the number of elements the vector can hold without + /// reallocating. + /// + /// # Examples + /// + /// ``` + /// let vec: Vec = Vec::with_capacity(10); + /// assert_eq!(vec.capacity(), 10); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn capacity(&self) -> usize { + self.buf.capacity() + } + + /// Reserves capacity for at least `additional` more elements to be inserted + /// in the given `Vec`. The collection may reserve more space to avoid + /// frequent reallocations. After calling `reserve`, capacity will be + /// greater than or equal to `self.len() + additional`. Does nothing if + /// capacity is already sufficient. + /// + /// # Panics + /// + /// Panics if the new capacity exceeds `isize::MAX` bytes. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1]; + /// vec.reserve(10); + /// assert!(vec.capacity() >= 11); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn reserve(&mut self, additional: usize) { + self.buf.reserve(self.len, additional); + } + + /// Reserves the minimum capacity for exactly `additional` more elements to + /// be inserted in the given `Vec`. After calling `reserve_exact`, + /// capacity will be greater than or equal to `self.len() + additional`. + /// Does nothing if the capacity is already sufficient. + /// + /// Note that the allocator may give the collection more space than it + /// requests. Therefore, capacity can not be relied upon to be precisely + /// minimal. Prefer `reserve` if future insertions are expected. + /// + /// # Panics + /// + /// Panics if the new capacity overflows `usize`. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1]; + /// vec.reserve_exact(10); + /// assert!(vec.capacity() >= 11); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn reserve_exact(&mut self, additional: usize) { + self.buf.reserve_exact(self.len, additional); + } + + /// Tries to reserve capacity for at least `additional` more elements to be inserted + /// in the given `Vec`. The collection may reserve more space to avoid + /// frequent reallocations. After calling `try_reserve`, capacity will be + /// greater than or equal to `self.len() + additional`. Does nothing if + /// capacity is already sufficient. + /// + /// # Errors + /// + /// If the capacity overflows, or the allocator reports a failure, then an error + /// is returned. + /// + /// # Examples + /// + /// ``` + /// #![feature(try_reserve)] + /// use std::collections::TryReserveError; + /// + /// fn process_data(data: &[u32]) -> Result, TryReserveError> { + /// let mut output = Vec::new(); + /// + /// // Pre-reserve the memory, exiting if we can't + /// output.try_reserve(data.len())?; + /// + /// // Now we know this can't OOM in the middle of our complex work + /// output.extend(data.iter().map(|&val| { + /// val * 2 + 5 // very complicated + /// })); + /// + /// Ok(output) + /// } + /// # process_data(&[1, 2, 3]).expect("why is the test harness OOMing on 12 bytes?"); + /// ``` + #[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] + pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> { + self.buf.try_reserve(self.len, additional) + } + + /// Tries to reserve the minimum capacity for exactly `additional` + /// elements to be inserted in the given `Vec`. After calling + /// `try_reserve_exact`, capacity will be greater than or equal to + /// `self.len() + additional` if it returns `Ok(())`. + /// Does nothing if the capacity is already sufficient. + /// + /// Note that the allocator may give the collection more space than it + /// requests. Therefore, capacity can not be relied upon to be precisely + /// minimal. Prefer `reserve` if future insertions are expected. + /// + /// # Errors + /// + /// If the capacity overflows, or the allocator reports a failure, then an error + /// is returned. + /// + /// # Examples + /// + /// ``` + /// #![feature(try_reserve)] + /// use std::collections::TryReserveError; + /// + /// fn process_data(data: &[u32]) -> Result, TryReserveError> { + /// let mut output = Vec::new(); + /// + /// // Pre-reserve the memory, exiting if we can't + /// output.try_reserve_exact(data.len())?; + /// + /// // Now we know this can't OOM in the middle of our complex work + /// output.extend(data.iter().map(|&val| { + /// val * 2 + 5 // very complicated + /// })); + /// + /// Ok(output) + /// } + /// # process_data(&[1, 2, 3]).expect("why is the test harness OOMing on 12 bytes?"); + /// ``` + #[unstable(feature = "try_reserve", reason = "new API", issue = "48043")] + pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveError> { + self.buf.try_reserve_exact(self.len, additional) + } + + /// Shrinks the capacity of the vector as much as possible. + /// + /// It will drop down as close as possible to the length but the allocator + /// may still inform the vector that there is space for a few more elements. + /// + /// # Examples + /// + /// ``` + /// let mut vec = Vec::with_capacity(10); + /// vec.extend([1, 2, 3].iter().cloned()); + /// assert_eq!(vec.capacity(), 10); + /// vec.shrink_to_fit(); + /// assert!(vec.capacity() >= 3); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn shrink_to_fit(&mut self) { + // The capacity is never less than the length, and there's nothing to do when + // they are equal, so we can avoid the panic case in `RawVec::shrink_to_fit` + // by only calling it with a greater capacity. + if self.capacity() > self.len { + self.buf.shrink_to_fit(self.len); + } + } + + /// Shrinks the capacity of the vector with a lower bound. + /// + /// The capacity will remain at least as large as both the length + /// and the supplied value. + /// + /// # Panics + /// + /// Panics if the current capacity is smaller than the supplied + /// minimum capacity. + /// + /// # Examples + /// + /// ``` + /// #![feature(shrink_to)] + /// let mut vec = Vec::with_capacity(10); + /// vec.extend([1, 2, 3].iter().cloned()); + /// assert_eq!(vec.capacity(), 10); + /// vec.shrink_to(4); + /// assert!(vec.capacity() >= 4); + /// vec.shrink_to(0); + /// assert!(vec.capacity() >= 3); + /// ``` + #[unstable(feature = "shrink_to", reason = "new API", issue = "56431")] + pub fn shrink_to(&mut self, min_capacity: usize) { + self.buf.shrink_to_fit(cmp::max(self.len, min_capacity)); + } + + /// Converts the vector into [`Box<[T]>`][owned slice]. + /// + /// Note that this will drop any excess capacity. + /// + /// [owned slice]: Box + /// + /// # Examples + /// + /// ``` + /// let v = vec![1, 2, 3]; + /// + /// let slice = v.into_boxed_slice(); + /// ``` + /// + /// Any excess capacity is removed: + /// + /// ``` + /// let mut vec = Vec::with_capacity(10); + /// vec.extend([1, 2, 3].iter().cloned()); + /// + /// assert_eq!(vec.capacity(), 10); + /// let slice = vec.into_boxed_slice(); + /// assert_eq!(slice.into_vec().capacity(), 3); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn into_boxed_slice(mut self) -> Box<[T]> { + unsafe { + self.shrink_to_fit(); + let me = ManuallyDrop::new(self); + let buf = ptr::read(&me.buf); + let len = me.len(); + buf.into_box(len).assume_init() + } + } + + /// Shortens the vector, keeping the first `len` elements and dropping + /// the rest. + /// + /// If `len` is greater than the vector's current length, this has no + /// effect. + /// + /// The [`drain`] method can emulate `truncate`, but causes the excess + /// elements to be returned instead of dropped. + /// + /// Note that this method has no effect on the allocated capacity + /// of the vector. + /// + /// # Examples + /// + /// Truncating a five element vector to two elements: + /// + /// ``` + /// let mut vec = vec![1, 2, 3, 4, 5]; + /// vec.truncate(2); + /// assert_eq!(vec, [1, 2]); + /// ``` + /// + /// No truncation occurs when `len` is greater than the vector's current + /// length: + /// + /// ``` + /// let mut vec = vec![1, 2, 3]; + /// vec.truncate(8); + /// assert_eq!(vec, [1, 2, 3]); + /// ``` + /// + /// Truncating when `len == 0` is equivalent to calling the [`clear`] + /// method. + /// + /// ``` + /// let mut vec = vec![1, 2, 3]; + /// vec.truncate(0); + /// assert_eq!(vec, []); + /// ``` + /// + /// [`clear`]: Vec::clear + /// [`drain`]: Vec::drain + #[stable(feature = "rust1", since = "1.0.0")] + pub fn truncate(&mut self, len: usize) { + // This is safe because: + // + // * the slice passed to `drop_in_place` is valid; the `len > self.len` + // case avoids creating an invalid slice, and + // * the `len` of the vector is shrunk before calling `drop_in_place`, + // such that no value will be dropped twice in case `drop_in_place` + // were to panic once (if it panics twice, the program aborts). + unsafe { + if len > self.len { + return; + } + let remaining_len = self.len - len; + let s = ptr::slice_from_raw_parts_mut(self.as_mut_ptr().add(len), remaining_len); + self.len = len; + ptr::drop_in_place(s); + } + } + + /// Extracts a slice containing the entire vector. + /// + /// Equivalent to `&s[..]`. + /// + /// # Examples + /// + /// ``` + /// use std::io::{self, Write}; + /// let buffer = vec![1, 2, 3, 5, 8]; + /// io::sink().write(buffer.as_slice()).unwrap(); + /// ``` + #[inline] + #[stable(feature = "vec_as_slice", since = "1.7.0")] + pub fn as_slice(&self) -> &[T] { + self + } + + /// Extracts a mutable slice of the entire vector. + /// + /// Equivalent to `&mut s[..]`. + /// + /// # Examples + /// + /// ``` + /// use std::io::{self, Read}; + /// let mut buffer = vec![0; 3]; + /// io::repeat(0b101).read_exact(buffer.as_mut_slice()).unwrap(); + /// ``` + #[inline] + #[stable(feature = "vec_as_slice", since = "1.7.0")] + pub fn as_mut_slice(&mut self) -> &mut [T] { + self + } + + /// Returns a raw pointer to the vector's buffer. + /// + /// The caller must ensure that the vector outlives the pointer this + /// function returns, or else it will end up pointing to garbage. + /// Modifying the vector may cause its buffer to be reallocated, + /// which would also make any pointers to it invalid. + /// + /// The caller must also ensure that the memory the pointer (non-transitively) points to + /// is never written to (except inside an `UnsafeCell`) using this pointer or any pointer + /// derived from it. If you need to mutate the contents of the slice, use [`as_mut_ptr`]. + /// + /// # Examples + /// + /// ``` + /// let x = vec![1, 2, 4]; + /// let x_ptr = x.as_ptr(); + /// + /// unsafe { + /// for i in 0..x.len() { + /// assert_eq!(*x_ptr.add(i), 1 << i); + /// } + /// } + /// ``` + /// + /// [`as_mut_ptr`]: Vec::as_mut_ptr + #[stable(feature = "vec_as_ptr", since = "1.37.0")] + #[inline] + pub fn as_ptr(&self) -> *const T { + // We shadow the slice method of the same name to avoid going through + // `deref`, which creates an intermediate reference. + let ptr = self.buf.ptr(); + unsafe { + assume(!ptr.is_null()); + } + ptr + } + + /// Returns an unsafe mutable pointer to the vector's buffer. + /// + /// The caller must ensure that the vector outlives the pointer this + /// function returns, or else it will end up pointing to garbage. + /// Modifying the vector may cause its buffer to be reallocated, + /// which would also make any pointers to it invalid. + /// + /// # Examples + /// + /// ``` + /// // Allocate vector big enough for 4 elements. + /// let size = 4; + /// let mut x: Vec = Vec::with_capacity(size); + /// let x_ptr = x.as_mut_ptr(); + /// + /// // Initialize elements via raw pointer writes, then set length. + /// unsafe { + /// for i in 0..size { + /// *x_ptr.add(i) = i as i32; + /// } + /// x.set_len(size); + /// } + /// assert_eq!(&*x, &[0,1,2,3]); + /// ``` + #[stable(feature = "vec_as_ptr", since = "1.37.0")] + #[inline] + pub fn as_mut_ptr(&mut self) -> *mut T { + // We shadow the slice method of the same name to avoid going through + // `deref_mut`, which creates an intermediate reference. + let ptr = self.buf.ptr(); + unsafe { + assume(!ptr.is_null()); + } + ptr + } + + /// Forces the length of the vector to `new_len`. + /// + /// This is a low-level operation that maintains none of the normal + /// invariants of the type. Normally changing the length of a vector + /// is done using one of the safe operations instead, such as + /// [`truncate`], [`resize`], [`extend`], or [`clear`]. + /// + /// [`truncate`]: Vec::truncate + /// [`resize`]: Vec::resize + /// [`extend`]: Extend::extend + /// [`clear`]: Vec::clear + /// + /// # Safety + /// + /// - `new_len` must be less than or equal to [`capacity()`]. + /// - The elements at `old_len..new_len` must be initialized. + /// + /// [`capacity()`]: Vec::capacity + /// + /// # Examples + /// + /// This method can be useful for situations in which the vector + /// is serving as a buffer for other code, particularly over FFI: + /// + /// ```no_run + /// # #![allow(dead_code)] + /// # // This is just a minimal skeleton for the doc example; + /// # // don't use this as a starting point for a real library. + /// # pub struct StreamWrapper { strm: *mut std::ffi::c_void } + /// # const Z_OK: i32 = 0; + /// # extern "C" { + /// # fn deflateGetDictionary( + /// # strm: *mut std::ffi::c_void, + /// # dictionary: *mut u8, + /// # dictLength: *mut usize, + /// # ) -> i32; + /// # } + /// # impl StreamWrapper { + /// pub fn get_dictionary(&self) -> Option> { + /// // Per the FFI method's docs, "32768 bytes is always enough". + /// let mut dict = Vec::with_capacity(32_768); + /// let mut dict_length = 0; + /// // SAFETY: When `deflateGetDictionary` returns `Z_OK`, it holds that: + /// // 1. `dict_length` elements were initialized. + /// // 2. `dict_length` <= the capacity (32_768) + /// // which makes `set_len` safe to call. + /// unsafe { + /// // Make the FFI call... + /// let r = deflateGetDictionary(self.strm, dict.as_mut_ptr(), &mut dict_length); + /// if r == Z_OK { + /// // ...and update the length to what was initialized. + /// dict.set_len(dict_length); + /// Some(dict) + /// } else { + /// None + /// } + /// } + /// } + /// # } + /// ``` + /// + /// While the following example is sound, there is a memory leak since + /// the inner vectors were not freed prior to the `set_len` call: + /// + /// ``` + /// let mut vec = vec![vec![1, 0, 0], + /// vec![0, 1, 0], + /// vec![0, 0, 1]]; + /// // SAFETY: + /// // 1. `old_len..0` is empty so no elements need to be initialized. + /// // 2. `0 <= capacity` always holds whatever `capacity` is. + /// unsafe { + /// vec.set_len(0); + /// } + /// ``` + /// + /// Normally, here, one would use [`clear`] instead to correctly drop + /// the contents and thus not leak memory. + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub unsafe fn set_len(&mut self, new_len: usize) { + debug_assert!(new_len <= self.capacity()); + + self.len = new_len; + } + + /// Removes an element from the vector and returns it. + /// + /// The removed element is replaced by the last element of the vector. + /// + /// This does not preserve ordering, but is O(1). + /// + /// # Panics + /// + /// Panics if `index` is out of bounds. + /// + /// # Examples + /// + /// ``` + /// let mut v = vec!["foo", "bar", "baz", "qux"]; + /// + /// assert_eq!(v.swap_remove(1), "bar"); + /// assert_eq!(v, ["foo", "qux", "baz"]); + /// + /// assert_eq!(v.swap_remove(0), "foo"); + /// assert_eq!(v, ["baz", "qux"]); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn swap_remove(&mut self, index: usize) -> T { + #[cold] + #[inline(never)] + fn assert_failed(index: usize, len: usize) -> ! { + panic!("swap_remove index (is {}) should be < len (is {})", index, len); + } + + let len = self.len(); + if index >= len { + assert_failed(index, len); + } + unsafe { + // We replace self[index] with the last element. Note that if the + // bounds check above succeeds there must be a last element (which + // can be self[index] itself). + let last = ptr::read(self.as_ptr().add(len - 1)); + let hole = self.as_mut_ptr().add(index); + self.set_len(len - 1); + ptr::replace(hole, last) + } + } + + /// Inserts an element at position `index` within the vector, shifting all + /// elements after it to the right. + /// + /// # Panics + /// + /// Panics if `index > len`. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1, 2, 3]; + /// vec.insert(1, 4); + /// assert_eq!(vec, [1, 4, 2, 3]); + /// vec.insert(4, 5); + /// assert_eq!(vec, [1, 4, 2, 3, 5]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn insert(&mut self, index: usize, element: T) { + #[cold] + #[inline(never)] + fn assert_failed(index: usize, len: usize) -> ! { + panic!("insertion index (is {}) should be <= len (is {})", index, len); + } + + let len = self.len(); + if index > len { + assert_failed(index, len); + } + + // space for the new element + if len == self.buf.capacity() { + self.reserve(1); + } + + unsafe { + // infallible + // The spot to put the new value + { + let p = self.as_mut_ptr().add(index); + // Shift everything over to make space. (Duplicating the + // `index`th element into two consecutive places.) + ptr::copy(p, p.offset(1), len - index); + // Write it in, overwriting the first copy of the `index`th + // element. + ptr::write(p, element); + } + self.set_len(len + 1); + } + } + + /// Removes and returns the element at position `index` within the vector, + /// shifting all elements after it to the left. + /// + /// # Panics + /// + /// Panics if `index` is out of bounds. + /// + /// # Examples + /// + /// ``` + /// let mut v = vec![1, 2, 3]; + /// assert_eq!(v.remove(1), 2); + /// assert_eq!(v, [1, 3]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn remove(&mut self, index: usize) -> T { + #[cold] + #[inline(never)] + fn assert_failed(index: usize, len: usize) -> ! { + panic!("removal index (is {}) should be < len (is {})", index, len); + } + + let len = self.len(); + if index >= len { + assert_failed(index, len); + } + unsafe { + // infallible + let ret; + { + // the place we are taking from. + let ptr = self.as_mut_ptr().add(index); + // copy it out, unsafely having a copy of the value on + // the stack and in the vector at the same time. + ret = ptr::read(ptr); + + // Shift everything down to fill in that spot. + ptr::copy(ptr.offset(1), ptr, len - index - 1); + } + self.set_len(len - 1); + ret + } + } + + /// Retains only the elements specified by the predicate. + /// + /// In other words, remove all elements `e` such that `f(&e)` returns `false`. + /// This method operates in place, visiting each element exactly once in the + /// original order, and preserves the order of the retained elements. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1, 2, 3, 4]; + /// vec.retain(|&x| x % 2 == 0); + /// assert_eq!(vec, [2, 4]); + /// ``` + /// + /// The exact order may be useful for tracking external state, like an index. + /// + /// ``` + /// let mut vec = vec![1, 2, 3, 4, 5]; + /// let keep = [false, true, true, false, true]; + /// let mut i = 0; + /// vec.retain(|_| (keep[i], i += 1).0); + /// assert_eq!(vec, [2, 3, 5]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn retain(&mut self, mut f: F) + where + F: FnMut(&T) -> bool, + { + let len = self.len(); + let mut del = 0; + { + let v = &mut **self; + + for i in 0..len { + if !f(&v[i]) { + del += 1; + } else if del > 0 { + v.swap(i - del, i); + } + } + } + if del > 0 { + self.truncate(len - del); + } + } + + /// Removes all but the first of consecutive elements in the vector that resolve to the same + /// key. + /// + /// If the vector is sorted, this removes all duplicates. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![10, 20, 21, 30, 20]; + /// + /// vec.dedup_by_key(|i| *i / 10); + /// + /// assert_eq!(vec, [10, 20, 30, 20]); + /// ``` + #[stable(feature = "dedup_by", since = "1.16.0")] + #[inline] + pub fn dedup_by_key(&mut self, mut key: F) + where + F: FnMut(&mut T) -> K, + K: PartialEq, + { + self.dedup_by(|a, b| key(a) == key(b)) + } + + /// Removes all but the first of consecutive elements in the vector satisfying a given equality + /// relation. + /// + /// The `same_bucket` function is passed references to two elements from the vector and + /// must determine if the elements compare equal. The elements are passed in opposite order + /// from their order in the slice, so if `same_bucket(a, b)` returns `true`, `a` is removed. + /// + /// If the vector is sorted, this removes all duplicates. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"]; + /// + /// vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b)); + /// + /// assert_eq!(vec, ["foo", "bar", "baz", "bar"]); + /// ``` + #[stable(feature = "dedup_by", since = "1.16.0")] + pub fn dedup_by(&mut self, same_bucket: F) + where + F: FnMut(&mut T, &mut T) -> bool, + { + let len = { + let (dedup, _) = self.as_mut_slice().partition_dedup_by(same_bucket); + dedup.len() + }; + self.truncate(len); + } + + /// Appends an element to the back of a collection. + /// + /// # Panics + /// + /// Panics if the new capacity exceeds `isize::MAX` bytes. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1, 2]; + /// vec.push(3); + /// assert_eq!(vec, [1, 2, 3]); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn push(&mut self, value: T) { + // This will panic or abort if we would allocate > isize::MAX bytes + // or if the length increment would overflow for zero-sized types. + if self.len == self.buf.capacity() { + self.reserve(1); + } + unsafe { + let end = self.as_mut_ptr().add(self.len); + ptr::write(end, value); + self.len += 1; + } + } + + /// Removes the last element from a vector and returns it, or [`None`] if it + /// is empty. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1, 2, 3]; + /// assert_eq!(vec.pop(), Some(3)); + /// assert_eq!(vec, [1, 2]); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn pop(&mut self) -> Option { + if self.len == 0 { + None + } else { + unsafe { + self.len -= 1; + Some(ptr::read(self.as_ptr().add(self.len()))) + } + } + } + + /// Moves all the elements of `other` into `Self`, leaving `other` empty. + /// + /// # Panics + /// + /// Panics if the number of elements in the vector overflows a `usize`. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1, 2, 3]; + /// let mut vec2 = vec![4, 5, 6]; + /// vec.append(&mut vec2); + /// assert_eq!(vec, [1, 2, 3, 4, 5, 6]); + /// assert_eq!(vec2, []); + /// ``` + #[inline] + #[stable(feature = "append", since = "1.4.0")] + pub fn append(&mut self, other: &mut Self) { + unsafe { + self.append_elements(other.as_slice() as _); + other.set_len(0); + } + } + + /// Appends elements to `Self` from other buffer. + #[inline] + unsafe fn append_elements(&mut self, other: *const [T]) { + let count = unsafe { (*other).len() }; + self.reserve(count); + let len = self.len(); + unsafe { ptr::copy_nonoverlapping(other as *const T, self.as_mut_ptr().add(len), count) }; + self.len += count; + } + + /// Creates a draining iterator that removes the specified range in the vector + /// and yields the removed items. + /// + /// When the iterator **is** dropped, all elements in the range are removed + /// from the vector, even if the iterator was not fully consumed. If the + /// iterator **is not** dropped (with [`mem::forget`] for example), it is + /// unspecified how many elements are removed. + /// + /// # Panics + /// + /// Panics if the starting point is greater than the end point or if + /// the end point is greater than the length of the vector. + /// + /// # Examples + /// + /// ``` + /// let mut v = vec![1, 2, 3]; + /// let u: Vec<_> = v.drain(1..).collect(); + /// assert_eq!(v, &[1]); + /// assert_eq!(u, &[2, 3]); + /// + /// // A full range clears the vector + /// v.drain(..); + /// assert_eq!(v, &[]); + /// ``` + #[stable(feature = "drain", since = "1.6.0")] + pub fn drain(&mut self, range: R) -> Drain<'_, T> + where + R: RangeBounds, + { + // Memory safety + // + // When the Drain is first created, it shortens the length of + // the source vector to make sure no uninitialized or moved-from elements + // are accessible at all if the Drain's destructor never gets to run. + // + // Drain will ptr::read out the values to remove. + // When finished, remaining tail of the vec is copied back to cover + // the hole, and the vector length is restored to the new length. + // + let len = self.len(); + let Range { start, end } = range.assert_len(len); + + unsafe { + // set self.vec length's to start, to be safe in case Drain is leaked + self.set_len(start); + // Use the borrow in the IterMut to indicate borrowing behavior of the + // whole Drain iterator (like &mut T). + let range_slice = slice::from_raw_parts_mut(self.as_mut_ptr().add(start), end - start); + Drain { + tail_start: end, + tail_len: len - end, + iter: range_slice.iter(), + vec: NonNull::from(self), + } + } + } + + /// Clears the vector, removing all values. + /// + /// Note that this method has no effect on the allocated capacity + /// of the vector. + /// + /// # Examples + /// + /// ``` + /// let mut v = vec![1, 2, 3]; + /// + /// v.clear(); + /// + /// assert!(v.is_empty()); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn clear(&mut self) { + self.truncate(0) + } + + /// Returns the number of elements in the vector, also referred to + /// as its 'length'. + /// + /// # Examples + /// + /// ``` + /// let a = vec![1, 2, 3]; + /// assert_eq!(a.len(), 3); + /// ``` + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn len(&self) -> usize { + self.len + } + + /// Returns `true` if the vector contains no elements. + /// + /// # Examples + /// + /// ``` + /// let mut v = Vec::new(); + /// assert!(v.is_empty()); + /// + /// v.push(1); + /// assert!(!v.is_empty()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// Splits the collection into two at the given index. + /// + /// Returns a newly allocated vector containing the elements in the range + /// `[at, len)`. After the call, the original vector will be left containing + /// the elements `[0, at)` with its previous capacity unchanged. + /// + /// # Panics + /// + /// Panics if `at > len`. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1,2,3]; + /// let vec2 = vec.split_off(1); + /// assert_eq!(vec, [1]); + /// assert_eq!(vec2, [2, 3]); + /// ``` + #[inline] + #[must_use = "use `.truncate()` if you don't need the other half"] + #[stable(feature = "split_off", since = "1.4.0")] + pub fn split_off(&mut self, at: usize) -> Self { + #[cold] + #[inline(never)] + fn assert_failed(at: usize, len: usize) -> ! { + panic!("`at` split index (is {}) should be <= len (is {})", at, len); + } + + if at > self.len() { + assert_failed(at, self.len()); + } + + if at == 0 { + // the new vector can take over the original buffer and avoid the copy + return mem::replace(self, Vec::with_capacity(self.capacity())); + } + + let other_len = self.len - at; + let mut other = Vec::with_capacity(other_len); + + // Unsafely `set_len` and copy items to `other`. + unsafe { + self.set_len(at); + other.set_len(other_len); + + ptr::copy_nonoverlapping(self.as_ptr().add(at), other.as_mut_ptr(), other.len()); + } + other + } + + /// Resizes the `Vec` in-place so that `len` is equal to `new_len`. + /// + /// If `new_len` is greater than `len`, the `Vec` is extended by the + /// difference, with each additional slot filled with the result of + /// calling the closure `f`. The return values from `f` will end up + /// in the `Vec` in the order they have been generated. + /// + /// If `new_len` is less than `len`, the `Vec` is simply truncated. + /// + /// This method uses a closure to create new values on every push. If + /// you'd rather [`Clone`] a given value, use [`Vec::resize`]. If you + /// want to use the [`Default`] trait to generate values, you can + /// pass [`Default::default`] as the second argument. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1, 2, 3]; + /// vec.resize_with(5, Default::default); + /// assert_eq!(vec, [1, 2, 3, 0, 0]); + /// + /// let mut vec = vec![]; + /// let mut p = 1; + /// vec.resize_with(4, || { p *= 2; p }); + /// assert_eq!(vec, [2, 4, 8, 16]); + /// ``` + #[stable(feature = "vec_resize_with", since = "1.33.0")] + pub fn resize_with(&mut self, new_len: usize, f: F) + where + F: FnMut() -> T, + { + let len = self.len(); + if new_len > len { + self.extend_with(new_len - len, ExtendFunc(f)); + } else { + self.truncate(new_len); + } + } + + /// Consumes and leaks the `Vec`, returning a mutable reference to the contents, + /// `&'a mut [T]`. Note that the type `T` must outlive the chosen lifetime + /// `'a`. If the type has only static references, or none at all, then this + /// may be chosen to be `'static`. + /// + /// This function is similar to the [`leak`][Box::leak] function on [`Box`] + /// except that there is no way to recover the leaked memory. + /// + /// This function is mainly useful for data that lives for the remainder of + /// the program's life. Dropping the returned reference will cause a memory + /// leak. + /// + /// # Examples + /// + /// Simple usage: + /// + /// ``` + /// let x = vec![1, 2, 3]; + /// let static_ref: &'static mut [usize] = x.leak(); + /// static_ref[0] += 1; + /// assert_eq!(static_ref, &[2, 2, 3]); + /// ``` + #[stable(feature = "vec_leak", since = "1.47.0")] + #[inline] + pub fn leak<'a>(self) -> &'a mut [T] + where + T: 'a, // Technically not needed, but kept to be explicit. + { + Box::leak(self.into_boxed_slice()) + } + + /// Returns the remaining spare capacity of the vector as a slice of + /// `MaybeUninit`. + /// + /// The returned slice can be used to fill the vector with data (e.g. by + /// reading from a file) before marking the data as initialized using the + /// [`set_len`] method. + /// + /// [`set_len`]: Vec::set_len + /// + /// # Examples + /// + /// ``` + /// #![feature(vec_spare_capacity, maybe_uninit_extra)] + /// + /// // Allocate vector big enough for 10 elements. + /// let mut v = Vec::with_capacity(10); + /// + /// // Fill in the first 3 elements. + /// let uninit = v.spare_capacity_mut(); + /// uninit[0].write(0); + /// uninit[1].write(1); + /// uninit[2].write(2); + /// + /// // Mark the first 3 elements of the vector as being initialized. + /// unsafe { + /// v.set_len(3); + /// } + /// + /// assert_eq!(&v, &[0, 1, 2]); + /// ``` + #[unstable(feature = "vec_spare_capacity", issue = "75017")] + #[inline] + pub fn spare_capacity_mut(&mut self) -> &mut [MaybeUninit] { + unsafe { + slice::from_raw_parts_mut( + self.as_mut_ptr().add(self.len) as *mut MaybeUninit, + self.buf.capacity() - self.len, + ) + } + } +} + +impl Vec { + /// Resizes the `Vec` in-place so that `len` is equal to `new_len`. + /// + /// If `new_len` is greater than `len`, the `Vec` is extended by the + /// difference, with each additional slot filled with `value`. + /// If `new_len` is less than `len`, the `Vec` is simply truncated. + /// + /// This method requires `T` to implement [`Clone`], + /// in order to be able to clone the passed value. + /// If you need more flexibility (or want to rely on [`Default`] instead of + /// [`Clone`]), use [`Vec::resize_with`]. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec!["hello"]; + /// vec.resize(3, "world"); + /// assert_eq!(vec, ["hello", "world", "world"]); + /// + /// let mut vec = vec![1, 2, 3, 4]; + /// vec.resize(2, 0); + /// assert_eq!(vec, [1, 2]); + /// ``` + #[stable(feature = "vec_resize", since = "1.5.0")] + pub fn resize(&mut self, new_len: usize, value: T) { + let len = self.len(); + + if new_len > len { + self.extend_with(new_len - len, ExtendElement(value)) + } else { + self.truncate(new_len); + } + } + + /// Clones and appends all elements in a slice to the `Vec`. + /// + /// Iterates over the slice `other`, clones each element, and then appends + /// it to this `Vec`. The `other` vector is traversed in-order. + /// + /// Note that this function is same as [`extend`] except that it is + /// specialized to work with slices instead. If and when Rust gets + /// specialization this function will likely be deprecated (but still + /// available). + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1]; + /// vec.extend_from_slice(&[2, 3, 4]); + /// assert_eq!(vec, [1, 2, 3, 4]); + /// ``` + /// + /// [`extend`]: Vec::extend + #[stable(feature = "vec_extend_from_slice", since = "1.6.0")] + pub fn extend_from_slice(&mut self, other: &[T]) { + self.spec_extend(other.iter()) + } +} + +// This code generalizes `extend_with_{element,default}`. +trait ExtendWith { + fn next(&mut self) -> T; + fn last(self) -> T; +} + +struct ExtendElement(T); +impl ExtendWith for ExtendElement { + fn next(&mut self) -> T { + self.0.clone() + } + fn last(self) -> T { + self.0 + } +} + +struct ExtendDefault; +impl ExtendWith for ExtendDefault { + fn next(&mut self) -> T { + Default::default() + } + fn last(self) -> T { + Default::default() + } +} + +struct ExtendFunc(F); +impl T> ExtendWith for ExtendFunc { + fn next(&mut self) -> T { + (self.0)() + } + fn last(mut self) -> T { + (self.0)() + } +} + +impl Vec { + /// Extend the vector by `n` values, using the given generator. + fn extend_with>(&mut self, n: usize, mut value: E) { + self.reserve(n); + + unsafe { + let mut ptr = self.as_mut_ptr().add(self.len()); + // Use SetLenOnDrop to work around bug where compiler + // may not realize the store through `ptr` through self.set_len() + // don't alias. + let mut local_len = SetLenOnDrop::new(&mut self.len); + + // Write all elements except the last one + for _ in 1..n { + ptr::write(ptr, value.next()); + ptr = ptr.offset(1); + // Increment the length in every step in case next() panics + local_len.increment_len(1); + } + + if n > 0 { + // We can write the last element directly without cloning needlessly + ptr::write(ptr, value.last()); + local_len.increment_len(1); + } + + // len set by scope guard + } + } +} + +// Set the length of the vec when the `SetLenOnDrop` value goes out of scope. +// +// The idea is: The length field in SetLenOnDrop is a local variable +// that the optimizer will see does not alias with any stores through the Vec's data +// pointer. This is a workaround for alias analysis issue #32155 +struct SetLenOnDrop<'a> { + len: &'a mut usize, + local_len: usize, +} + +impl<'a> SetLenOnDrop<'a> { + #[inline] + fn new(len: &'a mut usize) -> Self { + SetLenOnDrop { local_len: *len, len } + } + + #[inline] + fn increment_len(&mut self, increment: usize) { + self.local_len += increment; + } +} + +impl Drop for SetLenOnDrop<'_> { + #[inline] + fn drop(&mut self) { + *self.len = self.local_len; + } +} + +impl Vec { + /// Removes consecutive repeated elements in the vector according to the + /// [`PartialEq`] trait implementation. + /// + /// If the vector is sorted, this removes all duplicates. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec![1, 2, 2, 3, 2]; + /// + /// vec.dedup(); + /// + /// assert_eq!(vec, [1, 2, 3, 2]); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + #[inline] + pub fn dedup(&mut self) { + self.dedup_by(|a, b| a == b) + } +} + +impl Vec { + /// Removes the first instance of `item` from the vector if the item exists. + /// + /// This method will be removed soon. + #[unstable(feature = "vec_remove_item", reason = "recently added", issue = "40062")] + #[rustc_deprecated( + reason = "Removing the first item equal to a needle is already easily possible \ + with iterators and the current Vec methods. Furthermore, having a method for \ + one particular case of removal (linear search, only the first item, no swap remove) \ + but not for others is inconsistent. This method will be removed soon.", + since = "1.46.0" + )] + pub fn remove_item(&mut self, item: &V) -> Option + where + T: PartialEq, + { + let pos = self.iter().position(|x| *x == *item)?; + Some(self.remove(pos)) + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Internal methods and functions +//////////////////////////////////////////////////////////////////////////////// + +#[doc(hidden)] +#[stable(feature = "rust1", since = "1.0.0")] +pub fn from_elem(elem: T, n: usize) -> Vec { + ::from_elem(elem, n) +} + +// Specialization trait used for Vec::from_elem +trait SpecFromElem: Sized { + fn from_elem(elem: Self, n: usize) -> Vec; +} + +impl SpecFromElem for T { + default fn from_elem(elem: Self, n: usize) -> Vec { + let mut v = Vec::with_capacity(n); + v.extend_with(n, ExtendElement(elem)); + v + } +} + +impl SpecFromElem for i8 { + #[inline] + fn from_elem(elem: i8, n: usize) -> Vec { + if elem == 0 { + return Vec { buf: RawVec::with_capacity_zeroed(n), len: n }; + } + unsafe { + let mut v = Vec::with_capacity(n); + ptr::write_bytes(v.as_mut_ptr(), elem as u8, n); + v.set_len(n); + v + } + } +} + +impl SpecFromElem for u8 { + #[inline] + fn from_elem(elem: u8, n: usize) -> Vec { + if elem == 0 { + return Vec { buf: RawVec::with_capacity_zeroed(n), len: n }; + } + unsafe { + let mut v = Vec::with_capacity(n); + ptr::write_bytes(v.as_mut_ptr(), elem, n); + v.set_len(n); + v + } + } +} + +impl SpecFromElem for T { + #[inline] + fn from_elem(elem: T, n: usize) -> Vec { + if elem.is_zero() { + return Vec { buf: RawVec::with_capacity_zeroed(n), len: n }; + } + let mut v = Vec::with_capacity(n); + v.extend_with(n, ExtendElement(elem)); + v + } +} + +#[rustc_specialization_trait] +unsafe trait IsZero { + /// Whether this value is zero + fn is_zero(&self) -> bool; +} + +macro_rules! impl_is_zero { + ($t:ty, $is_zero:expr) => { + unsafe impl IsZero for $t { + #[inline] + fn is_zero(&self) -> bool { + $is_zero(*self) + } + } + }; +} + +impl_is_zero!(i16, |x| x == 0); +impl_is_zero!(i32, |x| x == 0); +impl_is_zero!(i64, |x| x == 0); +impl_is_zero!(i128, |x| x == 0); +impl_is_zero!(isize, |x| x == 0); + +impl_is_zero!(u16, |x| x == 0); +impl_is_zero!(u32, |x| x == 0); +impl_is_zero!(u64, |x| x == 0); +impl_is_zero!(u128, |x| x == 0); +impl_is_zero!(usize, |x| x == 0); + +impl_is_zero!(bool, |x| x == false); +impl_is_zero!(char, |x| x == '\0'); + +impl_is_zero!(f32, |x: f32| x.to_bits() == 0); +impl_is_zero!(f64, |x: f64| x.to_bits() == 0); + +unsafe impl IsZero for *const T { + #[inline] + fn is_zero(&self) -> bool { + (*self).is_null() + } +} + +unsafe impl IsZero for *mut T { + #[inline] + fn is_zero(&self) -> bool { + (*self).is_null() + } +} + +// `Option<&T>` and `Option>` are guaranteed to represent `None` as null. +// For fat pointers, the bytes that would be the pointer metadata in the `Some` +// variant are padding in the `None` variant, so ignoring them and +// zero-initializing instead is ok. +// `Option<&mut T>` never implements `Clone`, so there's no need for an impl of +// `SpecFromElem`. + +unsafe impl IsZero for Option<&T> { + #[inline] + fn is_zero(&self) -> bool { + self.is_none() + } +} + +unsafe impl IsZero for Option> { + #[inline] + fn is_zero(&self) -> bool { + self.is_none() + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Common trait implementations for Vec +//////////////////////////////////////////////////////////////////////////////// + +#[stable(feature = "rust1", since = "1.0.0")] +impl ops::Deref for Vec { + type Target = [T]; + + fn deref(&self) -> &[T] { + unsafe { slice::from_raw_parts(self.as_ptr(), self.len) } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ops::DerefMut for Vec { + fn deref_mut(&mut self) -> &mut [T] { + unsafe { slice::from_raw_parts_mut(self.as_mut_ptr(), self.len) } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Clone for Vec { + #[cfg(not(test))] + fn clone(&self) -> Vec { + <[T]>::to_vec(&**self) + } + + // HACK(japaric): with cfg(test) the inherent `[T]::to_vec` method, which is + // required for this method definition, is not available. Instead use the + // `slice::to_vec` function which is only available with cfg(test) + // NB see the slice::hack module in slice.rs for more information + #[cfg(test)] + fn clone(&self) -> Vec { + crate::slice::to_vec(&**self) + } + + fn clone_from(&mut self, other: &Vec) { + other.as_slice().clone_into(self); + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Hash for Vec { + #[inline] + fn hash(&self, state: &mut H) { + Hash::hash(&**self, state) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +#[rustc_on_unimplemented( + message = "vector indices are of type `usize` or ranges of `usize`", + label = "vector indices are of type `usize` or ranges of `usize`" +)] +impl> Index for Vec { + type Output = I::Output; + + #[inline] + fn index(&self, index: I) -> &Self::Output { + Index::index(&**self, index) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +#[rustc_on_unimplemented( + message = "vector indices are of type `usize` or ranges of `usize`", + label = "vector indices are of type `usize` or ranges of `usize`" +)] +impl> IndexMut for Vec { + #[inline] + fn index_mut(&mut self, index: I) -> &mut Self::Output { + IndexMut::index_mut(&mut **self, index) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl FromIterator for Vec { + #[inline] + fn from_iter>(iter: I) -> Vec { + >::from_iter(iter.into_iter()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl IntoIterator for Vec { + type Item = T; + type IntoIter = IntoIter; + + /// Creates a consuming iterator, that is, one that moves each value out of + /// the vector (from start to end). The vector cannot be used after calling + /// this. + /// + /// # Examples + /// + /// ``` + /// let v = vec!["a".to_string(), "b".to_string()]; + /// for s in v.into_iter() { + /// // s has type String, not &String + /// println!("{}", s); + /// } + /// ``` + #[inline] + fn into_iter(self) -> IntoIter { + unsafe { + let mut me = ManuallyDrop::new(self); + let begin = me.as_mut_ptr(); + let end = if mem::size_of::() == 0 { + arith_offset(begin as *const i8, me.len() as isize) as *const T + } else { + begin.add(me.len()) as *const T + }; + let cap = me.buf.capacity(); + IntoIter { + buf: NonNull::new_unchecked(begin), + phantom: PhantomData, + cap, + ptr: begin, + end, + } + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> IntoIterator for &'a Vec { + type Item = &'a T; + type IntoIter = slice::Iter<'a, T>; + + fn into_iter(self) -> slice::Iter<'a, T> { + self.iter() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> IntoIterator for &'a mut Vec { + type Item = &'a mut T; + type IntoIter = slice::IterMut<'a, T>; + + fn into_iter(self) -> slice::IterMut<'a, T> { + self.iter_mut() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Extend for Vec { + #[inline] + fn extend>(&mut self, iter: I) { + >::spec_extend(self, iter.into_iter()) + } + + #[inline] + fn extend_one(&mut self, item: T) { + self.push(item); + } + + #[inline] + fn extend_reserve(&mut self, additional: usize) { + self.reserve(additional); + } +} + +/// Specialization trait used for Vec::from_iter +/// +/// ## The delegation graph: +/// +/// ```text +/// +-------------+ +/// |FromIterator | +/// +-+-----------+ +/// | +/// v +/// +-+-------------------------------+ +---------------------+ +/// |SpecFromIter +---->+SpecFromIterNested | +/// |where I: | | |where I: | +/// | Iterator (default)----------+ | | Iterator (default) | +/// | vec::IntoIter | | | TrustedLen | +/// | SourceIterMarker---fallback-+ | | | +/// | slice::Iter | | | +/// | Iterator | +---------------------+ +/// +---------------------------------+ +/// ``` +trait SpecFromIter { + fn from_iter(iter: I) -> Self; +} + +/// Another specialization trait for Vec::from_iter +/// necessary to manually prioritize overlapping specializations +/// see [`SpecFromIter`] for details. +trait SpecFromIterNested { + fn from_iter(iter: I) -> Self; +} + +impl SpecFromIterNested for Vec +where + I: Iterator, +{ + default fn from_iter(mut iterator: I) -> Self { + // Unroll the first iteration, as the vector is going to be + // expanded on this iteration in every case when the iterable is not + // empty, but the loop in extend_desugared() is not going to see the + // vector being full in the few subsequent loop iterations. + // So we get better branch prediction. + let mut vector = match iterator.next() { + None => return Vec::new(), + Some(element) => { + let (lower, _) = iterator.size_hint(); + let mut vector = Vec::with_capacity(lower.saturating_add(1)); + unsafe { + ptr::write(vector.as_mut_ptr(), element); + vector.set_len(1); + } + vector + } + }; + // must delegate to spec_extend() since extend() itself delegates + // to spec_from for empty Vecs + as SpecExtend>::spec_extend(&mut vector, iterator); + vector + } +} + +impl SpecFromIterNested for Vec +where + I: TrustedLen, +{ + fn from_iter(iterator: I) -> Self { + let mut vector = Vec::new(); + // must delegate to spec_extend() since extend() itself delegates + // to spec_from for empty Vecs + vector.spec_extend(iterator); + vector + } +} + +impl SpecFromIter for Vec +where + I: Iterator, +{ + default fn from_iter(iterator: I) -> Self { + SpecFromIterNested::from_iter(iterator) + } +} + +// A helper struct for in-place iteration that drops the destination slice of iteration, +// i.e. the head. The source slice (the tail) is dropped by IntoIter. +struct InPlaceDrop { + inner: *mut T, + dst: *mut T, +} + +impl InPlaceDrop { + fn len(&self) -> usize { + unsafe { self.dst.offset_from(self.inner) as usize } + } +} + +impl Drop for InPlaceDrop { + #[inline] + fn drop(&mut self) { + unsafe { + ptr::drop_in_place(slice::from_raw_parts_mut(self.inner, self.len())); + } + } +} + +impl SpecFromIter> for Vec { + fn from_iter(iterator: IntoIter) -> Self { + // A common case is passing a vector into a function which immediately + // re-collects into a vector. We can short circuit this if the IntoIter + // has not been advanced at all. + // When it has been advanced We can also reuse the memory and move the data to the front. + // But we only do so when the resulting Vec wouldn't have more unused capacity + // than creating it through the generic FromIterator implementation would. That limitation + // is not strictly necessary as Vec's allocation behavior is intentionally unspecified. + // But it is a conservative choice. + let has_advanced = iterator.buf.as_ptr() as *const _ != iterator.ptr; + if !has_advanced || iterator.len() >= iterator.cap / 2 { + unsafe { + let it = ManuallyDrop::new(iterator); + if has_advanced { + ptr::copy(it.ptr, it.buf.as_ptr(), it.len()); + } + return Vec::from_raw_parts(it.buf.as_ptr(), it.len(), it.cap); + } + } + + let mut vec = Vec::new(); + // must delegate to spec_extend() since extend() itself delegates + // to spec_from for empty Vecs + vec.spec_extend(iterator); + vec + } +} + +fn write_in_place_with_drop( + src_end: *const T, +) -> impl FnMut(InPlaceDrop, T) -> Result, !> { + move |mut sink, item| { + unsafe { + // the InPlaceIterable contract cannot be verified precisely here since + // try_fold has an exclusive reference to the source pointer + // all we can do is check if it's still in range + debug_assert!(sink.dst as *const _ <= src_end, "InPlaceIterable contract violation"); + ptr::write(sink.dst, item); + sink.dst = sink.dst.add(1); + } + Ok(sink) + } +} + +/// Specialization marker for collecting an iterator pipeline into a Vec while reusing the +/// source allocation, i.e. executing the pipeline in place. +/// +/// The SourceIter parent trait is necessary for the specializing function to access the allocation +/// which is to be reused. But it is not sufficient for the specialization to be valid. See +/// additional bounds on the impl. +#[rustc_unsafe_specialization_marker] +trait SourceIterMarker: SourceIter {} + +// The std-internal SourceIter/InPlaceIterable traits are only implemented by chains of +// Adapter>> (all owned by core/std). Additional bounds +// on the adapter implementations (beyond `impl Trait for Adapter`) only depend on other +// traits already marked as specialization traits (Copy, TrustedRandomAccess, FusedIterator). +// I.e. the marker does not depend on lifetimes of user-supplied types. Modulo the Copy hole, which +// several other specializations already depend on. +impl SourceIterMarker for T where T: SourceIter + InPlaceIterable {} + +impl SpecFromIter for Vec +where + I: Iterator + SourceIterMarker, +{ + default fn from_iter(mut iterator: I) -> Self { + // Additional requirements which cannot expressed via trait bounds. We rely on const eval + // instead: + // a) no ZSTs as there would be no allocation to reuse and pointer arithmetic would panic + // b) size match as required by Alloc contract + // c) alignments match as required by Alloc contract + if mem::size_of::() == 0 + || mem::size_of::() + != mem::size_of::<<::Source as AsIntoIter>::Item>() + || mem::align_of::() + != mem::align_of::<<::Source as AsIntoIter>::Item>() + { + // fallback to more generic implementations + return SpecFromIterNested::from_iter(iterator); + } + + let (src_buf, src_ptr, dst_buf, dst_end, cap) = unsafe { + let inner = iterator.as_inner().as_into_iter(); + ( + inner.buf.as_ptr(), + inner.ptr, + inner.buf.as_ptr() as *mut T, + inner.end as *const T, + inner.cap, + ) + }; + + // use try-fold since + // - it vectorizes better for some iterator adapters + // - unlike most internal iteration methods, it only takes a &mut self + // - it lets us thread the write pointer through its innards and get it back in the end + let sink = InPlaceDrop { inner: dst_buf, dst: dst_buf }; + let sink = iterator + .try_fold::<_, _, Result<_, !>>(sink, write_in_place_with_drop(dst_end)) + .unwrap(); + // iteration succeeded, don't drop head + let dst = ManuallyDrop::new(sink).dst; + + let src = unsafe { iterator.as_inner().as_into_iter() }; + // check if SourceIter contract was upheld + // caveat: if they weren't we may not even make it to this point + debug_assert_eq!(src_buf, src.buf.as_ptr()); + // check InPlaceIterable contract. This is only possible if the iterator advanced the + // source pointer at all. If it uses unchecked access via TrustedRandomAccess + // then the source pointer will stay in its initial position and we can't use it as reference + if src.ptr != src_ptr { + debug_assert!( + dst as *const _ <= src.ptr, + "InPlaceIterable contract violation, write pointer advanced beyond read pointer" + ); + } + + // drop any remaining values at the tail of the source + src.drop_remaining(); + // but prevent drop of the allocation itself once IntoIter goes out of scope + src.forget_allocation(); + + let vec = unsafe { + let len = dst.offset_from(dst_buf) as usize; + Vec::from_raw_parts(dst_buf, len, cap) + }; + + vec + } +} + +impl<'a, T: 'a, I> SpecFromIter<&'a T, I> for Vec +where + I: Iterator, + T: Clone, +{ + default fn from_iter(iterator: I) -> Self { + SpecFromIter::from_iter(iterator.cloned()) + } +} + +impl<'a, T: 'a> SpecFromIter<&'a T, slice::Iter<'a, T>> for Vec +where + T: Copy, +{ + // reuses the extend specialization for T: Copy + fn from_iter(iterator: slice::Iter<'a, T>) -> Self { + let mut vec = Vec::new(); + // must delegate to spec_extend() since extend() itself delegates + // to spec_from for empty Vecs + vec.spec_extend(iterator); + vec + } +} + +// Specialization trait used for Vec::extend +trait SpecExtend { + fn spec_extend(&mut self, iter: I); +} + +impl SpecExtend for Vec +where + I: Iterator, +{ + default fn spec_extend(&mut self, iter: I) { + self.extend_desugared(iter) + } +} + +impl SpecExtend for Vec +where + I: TrustedLen, +{ + default fn spec_extend(&mut self, iterator: I) { + // This is the case for a TrustedLen iterator. + let (low, high) = iterator.size_hint(); + if let Some(high_value) = high { + debug_assert_eq!( + low, + high_value, + "TrustedLen iterator's size hint is not exact: {:?}", + (low, high) + ); + } + if let Some(additional) = high { + self.reserve(additional); + unsafe { + let mut ptr = self.as_mut_ptr().add(self.len()); + let mut local_len = SetLenOnDrop::new(&mut self.len); + iterator.for_each(move |element| { + ptr::write(ptr, element); + ptr = ptr.offset(1); + // NB can't overflow since we would have had to alloc the address space + local_len.increment_len(1); + }); + } + } else { + self.extend_desugared(iterator) + } + } +} + +impl SpecExtend> for Vec { + fn spec_extend(&mut self, mut iterator: IntoIter) { + unsafe { + self.append_elements(iterator.as_slice() as _); + } + iterator.ptr = iterator.end; + } +} + +impl<'a, T: 'a, I> SpecExtend<&'a T, I> for Vec +where + I: Iterator, + T: Clone, +{ + default fn spec_extend(&mut self, iterator: I) { + self.spec_extend(iterator.cloned()) + } +} + +impl<'a, T: 'a> SpecExtend<&'a T, slice::Iter<'a, T>> for Vec +where + T: Copy, +{ + fn spec_extend(&mut self, iterator: slice::Iter<'a, T>) { + let slice = iterator.as_slice(); + unsafe { self.append_elements(slice) }; + } +} + +impl Vec { + // leaf method to which various SpecFrom/SpecExtend implementations delegate when + // they have no further optimizations to apply + fn extend_desugared>(&mut self, mut iterator: I) { + // This is the case for a general iterator. + // + // This function should be the moral equivalent of: + // + // for item in iterator { + // self.push(item); + // } + while let Some(element) = iterator.next() { + let len = self.len(); + if len == self.capacity() { + let (lower, _) = iterator.size_hint(); + self.reserve(lower.saturating_add(1)); + } + unsafe { + ptr::write(self.as_mut_ptr().add(len), element); + // NB can't overflow since we would have had to alloc the address space + self.set_len(len + 1); + } + } + } + + /// Creates a splicing iterator that replaces the specified range in the vector + /// with the given `replace_with` iterator and yields the removed items. + /// `replace_with` does not need to be the same length as `range`. + /// + /// `range` is removed even if the iterator is not consumed until the end. + /// + /// It is unspecified how many elements are removed from the vector + /// if the `Splice` value is leaked. + /// + /// The input iterator `replace_with` is only consumed when the `Splice` value is dropped. + /// + /// This is optimal if: + /// + /// * The tail (elements in the vector after `range`) is empty, + /// * or `replace_with` yields fewer elements than `range`’s length + /// * or the lower bound of its `size_hint()` is exact. + /// + /// Otherwise, a temporary vector is allocated and the tail is moved twice. + /// + /// # Panics + /// + /// Panics if the starting point is greater than the end point or if + /// the end point is greater than the length of the vector. + /// + /// # Examples + /// + /// ``` + /// let mut v = vec![1, 2, 3]; + /// let new = [7, 8]; + /// let u: Vec<_> = v.splice(..2, new.iter().cloned()).collect(); + /// assert_eq!(v, &[7, 8, 3]); + /// assert_eq!(u, &[1, 2]); + /// ``` + #[inline] + #[stable(feature = "vec_splice", since = "1.21.0")] + pub fn splice(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter> + where + R: RangeBounds, + I: IntoIterator, + { + Splice { drain: self.drain(range), replace_with: replace_with.into_iter() } + } + + /// Creates an iterator which uses a closure to determine if an element should be removed. + /// + /// If the closure returns true, then the element is removed and yielded. + /// If the closure returns false, the element will remain in the vector and will not be yielded + /// by the iterator. + /// + /// Using this method is equivalent to the following code: + /// + /// ``` + /// # let some_predicate = |x: &mut i32| { *x == 2 || *x == 3 || *x == 6 }; + /// # let mut vec = vec![1, 2, 3, 4, 5, 6]; + /// let mut i = 0; + /// while i != vec.len() { + /// if some_predicate(&mut vec[i]) { + /// let val = vec.remove(i); + /// // your code here + /// } else { + /// i += 1; + /// } + /// } + /// + /// # assert_eq!(vec, vec![1, 4, 5]); + /// ``` + /// + /// But `drain_filter` is easier to use. `drain_filter` is also more efficient, + /// because it can backshift the elements of the array in bulk. + /// + /// Note that `drain_filter` also lets you mutate every element in the filter closure, + /// regardless of whether you choose to keep or remove it. + /// + /// # Examples + /// + /// Splitting an array into evens and odds, reusing the original allocation: + /// + /// ``` + /// #![feature(drain_filter)] + /// let mut numbers = vec![1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15]; + /// + /// let evens = numbers.drain_filter(|x| *x % 2 == 0).collect::>(); + /// let odds = numbers; + /// + /// assert_eq!(evens, vec![2, 4, 6, 8, 14]); + /// assert_eq!(odds, vec![1, 3, 5, 9, 11, 13, 15]); + /// ``` + #[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] + pub fn drain_filter(&mut self, filter: F) -> DrainFilter<'_, T, F> + where + F: FnMut(&mut T) -> bool, + { + let old_len = self.len(); + + // Guard against us getting leaked (leak amplification) + unsafe { + self.set_len(0); + } + + DrainFilter { vec: self, idx: 0, del: 0, old_len, pred: filter, panic_flag: false } + } +} + +/// Extend implementation that copies elements out of references before pushing them onto the Vec. +/// +/// This implementation is specialized for slice iterators, where it uses [`copy_from_slice`] to +/// append the entire slice at once. +/// +/// [`copy_from_slice`]: ../../std/primitive.slice.html#method.copy_from_slice +#[stable(feature = "extend_ref", since = "1.2.0")] +impl<'a, T: 'a + Copy> Extend<&'a T> for Vec { + fn extend>(&mut self, iter: I) { + self.spec_extend(iter.into_iter()) + } + + #[inline] + fn extend_one(&mut self, &item: &'a T) { + self.push(item); + } + + #[inline] + fn extend_reserve(&mut self, additional: usize) { + self.reserve(additional); + } +} + +macro_rules! __impl_slice_eq1 { + ([$($vars:tt)*] $lhs:ty, $rhs:ty $(where $ty:ty: $bound:ident)?, #[$stability:meta]) => { + #[$stability] + impl PartialEq<$rhs> for $lhs + where + A: PartialEq, + $($ty: $bound)? + { + #[inline] + fn eq(&self, other: &$rhs) -> bool { self[..] == other[..] } + #[inline] + fn ne(&self, other: &$rhs) -> bool { self[..] != other[..] } + } + } +} + +__impl_slice_eq1! { [] Vec, Vec, #[stable(feature = "rust1", since = "1.0.0")] } +__impl_slice_eq1! { [] Vec, &[B], #[stable(feature = "rust1", since = "1.0.0")] } +__impl_slice_eq1! { [] Vec, &mut [B], #[stable(feature = "rust1", since = "1.0.0")] } +__impl_slice_eq1! { [] &[A], Vec, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")] } +__impl_slice_eq1! { [] &mut [A], Vec, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")] } +__impl_slice_eq1! { [] Vec, [B], #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")] } +__impl_slice_eq1! { [] [A], Vec, #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")] } +__impl_slice_eq1! { [] Cow<'_, [A]>, Vec where A: Clone, #[stable(feature = "rust1", since = "1.0.0")] } +__impl_slice_eq1! { [] Cow<'_, [A]>, &[B] where A: Clone, #[stable(feature = "rust1", since = "1.0.0")] } +__impl_slice_eq1! { [] Cow<'_, [A]>, &mut [B] where A: Clone, #[stable(feature = "rust1", since = "1.0.0")] } +__impl_slice_eq1! { [const N: usize] Vec, [B; N], #[stable(feature = "rust1", since = "1.0.0")] } +__impl_slice_eq1! { [const N: usize] Vec, &[B; N], #[stable(feature = "rust1", since = "1.0.0")] } + +// NOTE: some less important impls are omitted to reduce code bloat +// FIXME(Centril): Reconsider this? +//__impl_slice_eq1! { [const N: usize] Vec, &mut [B; N], } +//__impl_slice_eq1! { [const N: usize] [A; N], Vec, } +//__impl_slice_eq1! { [const N: usize] &[A; N], Vec, } +//__impl_slice_eq1! { [const N: usize] &mut [A; N], Vec, } +//__impl_slice_eq1! { [const N: usize] Cow<'a, [A]>, [B; N], } +//__impl_slice_eq1! { [const N: usize] Cow<'a, [A]>, &[B; N], } +//__impl_slice_eq1! { [const N: usize] Cow<'a, [A]>, &mut [B; N], } + +/// Implements comparison of vectors, [lexicographically](core::cmp::Ord#lexicographical-comparison). +#[stable(feature = "rust1", since = "1.0.0")] +impl PartialOrd for Vec { + #[inline] + fn partial_cmp(&self, other: &Vec) -> Option { + PartialOrd::partial_cmp(&**self, &**other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Eq for Vec {} + +/// Implements ordering of vectors, [lexicographically](core::cmp::Ord#lexicographical-comparison). +#[stable(feature = "rust1", since = "1.0.0")] +impl Ord for Vec { + #[inline] + fn cmp(&self, other: &Vec) -> Ordering { + Ord::cmp(&**self, &**other) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl<#[may_dangle] T> Drop for Vec { + fn drop(&mut self) { + unsafe { + // use drop for [T] + // use a raw slice to refer to the elements of the vector as weakest necessary type; + // could avoid questions of validity in certain cases + ptr::drop_in_place(ptr::slice_from_raw_parts_mut(self.as_mut_ptr(), self.len)) + } + // RawVec handles deallocation + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Default for Vec { + /// Creates an empty `Vec`. + fn default() -> Vec { + Vec::new() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl fmt::Debug for Vec { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fmt::Debug::fmt(&**self, f) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl AsRef> for Vec { + fn as_ref(&self) -> &Vec { + self + } +} + +#[stable(feature = "vec_as_mut", since = "1.5.0")] +impl AsMut> for Vec { + fn as_mut(&mut self) -> &mut Vec { + self + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl AsRef<[T]> for Vec { + fn as_ref(&self) -> &[T] { + self + } +} + +#[stable(feature = "vec_as_mut", since = "1.5.0")] +impl AsMut<[T]> for Vec { + fn as_mut(&mut self) -> &mut [T] { + self + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl From<&[T]> for Vec { + #[cfg(not(test))] + fn from(s: &[T]) -> Vec { + s.to_vec() + } + #[cfg(test)] + fn from(s: &[T]) -> Vec { + crate::slice::to_vec(s) + } +} + +#[stable(feature = "vec_from_mut", since = "1.19.0")] +impl From<&mut [T]> for Vec { + #[cfg(not(test))] + fn from(s: &mut [T]) -> Vec { + s.to_vec() + } + #[cfg(test)] + fn from(s: &mut [T]) -> Vec { + crate::slice::to_vec(s) + } +} + +#[stable(feature = "vec_from_array", since = "1.44.0")] +impl From<[T; N]> for Vec { + #[cfg(not(test))] + fn from(s: [T; N]) -> Vec { + <[T]>::into_vec(box s) + } + #[cfg(test)] + fn from(s: [T; N]) -> Vec { + crate::slice::into_vec(box s) + } +} + +#[stable(feature = "vec_from_cow_slice", since = "1.14.0")] +impl<'a, T> From> for Vec +where + [T]: ToOwned>, +{ + fn from(s: Cow<'a, [T]>) -> Vec { + s.into_owned() + } +} + +// note: test pulls in libstd, which causes errors here +#[cfg(not(test))] +#[stable(feature = "vec_from_box", since = "1.18.0")] +impl From> for Vec { + fn from(s: Box<[T]>) -> Vec { + s.into_vec() + } +} + +// note: test pulls in libstd, which causes errors here +#[cfg(not(test))] +#[stable(feature = "box_from_vec", since = "1.20.0")] +impl From> for Box<[T]> { + fn from(v: Vec) -> Box<[T]> { + v.into_boxed_slice() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl From<&str> for Vec { + fn from(s: &str) -> Vec { + From::from(s.as_bytes()) + } +} + +#[stable(feature = "array_try_from_vec", since = "1.48.0")] +impl TryFrom> for [T; N] { + type Error = Vec; + + /// Gets the entire contents of the `Vec` as an array, + /// if its size exactly matches that of the requested array. + /// + /// # Examples + /// + /// ``` + /// use std::convert::TryInto; + /// assert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3])); + /// assert_eq!(>::new().try_into(), Ok([])); + /// ``` + /// + /// If the length doesn't match, the input comes back in `Err`: + /// ``` + /// use std::convert::TryInto; + /// let r: Result<[i32; 4], _> = (0..10).collect::>().try_into(); + /// assert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9])); + /// ``` + /// + /// If you're fine with just getting a prefix of the `Vec`, + /// you can call [`.truncate(N)`](Vec::truncate) first. + /// ``` + /// use std::convert::TryInto; + /// let mut v = String::from("hello world").into_bytes(); + /// v.sort(); + /// v.truncate(2); + /// let [a, b]: [_; 2] = v.try_into().unwrap(); + /// assert_eq!(a, b' '); + /// assert_eq!(b, b'd'); + /// ``` + fn try_from(mut vec: Vec) -> Result<[T; N], Vec> { + if vec.len() != N { + return Err(vec); + } + + // SAFETY: `.set_len(0)` is always sound. + unsafe { vec.set_len(0) }; + + // SAFETY: A `Vec`'s pointer is always aligned properly, and + // the alignment the array needs is the same as the items. + // We checked earlier that we have sufficient items. + // The items will not double-drop as the `set_len` + // tells the `Vec` not to also drop them. + let array = unsafe { ptr::read(vec.as_ptr() as *const [T; N]) }; + Ok(array) + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Clone-on-write +//////////////////////////////////////////////////////////////////////////////// + +#[stable(feature = "cow_from_vec", since = "1.8.0")] +impl<'a, T: Clone> From<&'a [T]> for Cow<'a, [T]> { + fn from(s: &'a [T]) -> Cow<'a, [T]> { + Cow::Borrowed(s) + } +} + +#[stable(feature = "cow_from_vec", since = "1.8.0")] +impl<'a, T: Clone> From> for Cow<'a, [T]> { + fn from(v: Vec) -> Cow<'a, [T]> { + Cow::Owned(v) + } +} + +#[stable(feature = "cow_from_vec_ref", since = "1.28.0")] +impl<'a, T: Clone> From<&'a Vec> for Cow<'a, [T]> { + fn from(v: &'a Vec) -> Cow<'a, [T]> { + Cow::Borrowed(v.as_slice()) + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl<'a, T> FromIterator for Cow<'a, [T]> +where + T: Clone, +{ + fn from_iter>(it: I) -> Cow<'a, [T]> { + Cow::Owned(FromIterator::from_iter(it)) + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Iterators +//////////////////////////////////////////////////////////////////////////////// + +/// An iterator that moves out of a vector. +/// +/// This `struct` is created by the `into_iter` method on [`Vec`] (provided +/// by the [`IntoIterator`] trait). +/// +/// # Example +/// +/// ``` +/// let v = vec![0, 1, 2]; +/// let iter: std::vec::IntoIter<_> = v.into_iter(); +/// ``` +#[stable(feature = "rust1", since = "1.0.0")] +pub struct IntoIter { + buf: NonNull, + phantom: PhantomData, + cap: usize, + ptr: *const T, + end: *const T, +} + +#[stable(feature = "vec_intoiter_debug", since = "1.13.0")] +impl fmt::Debug for IntoIter { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("IntoIter").field(&self.as_slice()).finish() + } +} + +impl IntoIter { + /// Returns the remaining items of this iterator as a slice. + /// + /// # Examples + /// + /// ``` + /// let vec = vec!['a', 'b', 'c']; + /// let mut into_iter = vec.into_iter(); + /// assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']); + /// let _ = into_iter.next().unwrap(); + /// assert_eq!(into_iter.as_slice(), &['b', 'c']); + /// ``` + #[stable(feature = "vec_into_iter_as_slice", since = "1.15.0")] + pub fn as_slice(&self) -> &[T] { + unsafe { slice::from_raw_parts(self.ptr, self.len()) } + } + + /// Returns the remaining items of this iterator as a mutable slice. + /// + /// # Examples + /// + /// ``` + /// let vec = vec!['a', 'b', 'c']; + /// let mut into_iter = vec.into_iter(); + /// assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']); + /// into_iter.as_mut_slice()[2] = 'z'; + /// assert_eq!(into_iter.next().unwrap(), 'a'); + /// assert_eq!(into_iter.next().unwrap(), 'b'); + /// assert_eq!(into_iter.next().unwrap(), 'z'); + /// ``` + #[stable(feature = "vec_into_iter_as_slice", since = "1.15.0")] + pub fn as_mut_slice(&mut self) -> &mut [T] { + unsafe { &mut *self.as_raw_mut_slice() } + } + + fn as_raw_mut_slice(&mut self) -> *mut [T] { + ptr::slice_from_raw_parts_mut(self.ptr as *mut T, self.len()) + } + + fn drop_remaining(&mut self) { + unsafe { + ptr::drop_in_place(self.as_mut_slice()); + } + self.ptr = self.end; + } + + /// Relinquishes the backing allocation, equivalent to + /// `ptr::write(&mut self, Vec::new().into_iter())` + fn forget_allocation(&mut self) { + self.cap = 0; + self.buf = unsafe { NonNull::new_unchecked(RawVec::NEW.ptr()) }; + self.ptr = self.buf.as_ptr(); + self.end = self.buf.as_ptr(); + } +} + +#[stable(feature = "vec_intoiter_as_ref", since = "1.46.0")] +impl AsRef<[T]> for IntoIter { + fn as_ref(&self) -> &[T] { + self.as_slice() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Send for IntoIter {} +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl Sync for IntoIter {} + +#[stable(feature = "rust1", since = "1.0.0")] +impl Iterator for IntoIter { + type Item = T; + + #[inline] + fn next(&mut self) -> Option { + if self.ptr as *const _ == self.end { + None + } else if mem::size_of::() == 0 { + // purposefully don't use 'ptr.offset' because for + // vectors with 0-size elements this would return the + // same pointer. + self.ptr = unsafe { arith_offset(self.ptr as *const i8, 1) as *mut T }; + + // Make up a value of this ZST. + Some(unsafe { mem::zeroed() }) + } else { + let old = self.ptr; + self.ptr = unsafe { self.ptr.offset(1) }; + + Some(unsafe { ptr::read(old) }) + } + } + + #[inline] + fn size_hint(&self) -> (usize, Option) { + let exact = if mem::size_of::() == 0 { + (self.end as usize).wrapping_sub(self.ptr as usize) + } else { + unsafe { self.end.offset_from(self.ptr) as usize } + }; + (exact, Some(exact)) + } + + #[inline] + fn count(self) -> usize { + self.len() + } + + unsafe fn __iterator_get_unchecked(&mut self, i: usize) -> Self::Item + where + Self: TrustedRandomAccess, + { + // SAFETY: the caller must guarantee that `i` is in bounds of the + // `Vec`, so `i` cannot overflow an `isize`, and the `self.ptr.add(i)` + // is guaranteed to pointer to an element of the `Vec` and + // thus guaranteed to be valid to dereference. + // + // Also note the implementation of `Self: TrustedRandomAccess` requires + // that `T: Copy` so reading elements from the buffer doesn't invalidate + // them for `Drop`. + unsafe { + if mem::size_of::() == 0 { mem::zeroed() } else { ptr::read(self.ptr.add(i)) } + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl DoubleEndedIterator for IntoIter { + #[inline] + fn next_back(&mut self) -> Option { + if self.end == self.ptr { + None + } else if mem::size_of::() == 0 { + // See above for why 'ptr.offset' isn't used + self.end = unsafe { arith_offset(self.end as *const i8, -1) as *mut T }; + + // Make up a value of this ZST. + Some(unsafe { mem::zeroed() }) + } else { + self.end = unsafe { self.end.offset(-1) }; + + Some(unsafe { ptr::read(self.end) }) + } + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +impl ExactSizeIterator for IntoIter { + fn is_empty(&self) -> bool { + self.ptr == self.end + } +} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for IntoIter {} + +#[unstable(feature = "trusted_len", issue = "37572")] +unsafe impl TrustedLen for IntoIter {} + +#[doc(hidden)] +#[unstable(issue = "none", feature = "std_internals")] +// T: Copy as approximation for !Drop since get_unchecked does not advance self.ptr +// and thus we can't implement drop-handling +unsafe impl TrustedRandomAccess for IntoIter +where + T: Copy, +{ + fn may_have_side_effect() -> bool { + false + } +} + +#[stable(feature = "vec_into_iter_clone", since = "1.8.0")] +impl Clone for IntoIter { + fn clone(&self) -> IntoIter { + self.as_slice().to_owned().into_iter() + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +unsafe impl<#[may_dangle] T> Drop for IntoIter { + fn drop(&mut self) { + struct DropGuard<'a, T>(&'a mut IntoIter); + + impl Drop for DropGuard<'_, T> { + fn drop(&mut self) { + // RawVec handles deallocation + let _ = unsafe { RawVec::from_raw_parts(self.0.buf.as_ptr(), self.0.cap) }; + } + } + + let guard = DropGuard(self); + // destroy the remaining elements + unsafe { + ptr::drop_in_place(guard.0.as_raw_mut_slice()); + } + // now `guard` will be dropped and do the rest + } +} + +#[unstable(issue = "none", feature = "inplace_iteration")] +unsafe impl InPlaceIterable for IntoIter {} + +#[unstable(issue = "none", feature = "inplace_iteration")] +unsafe impl SourceIter for IntoIter { + type Source = IntoIter; + + #[inline] + unsafe fn as_inner(&mut self) -> &mut Self::Source { + self + } +} + +// internal helper trait for in-place iteration specialization. +#[rustc_specialization_trait] +pub(crate) trait AsIntoIter { + type Item; + fn as_into_iter(&mut self) -> &mut IntoIter; +} + +impl AsIntoIter for IntoIter { + type Item = T; + + fn as_into_iter(&mut self) -> &mut IntoIter { + self + } +} + +/// A draining iterator for `Vec`. +/// +/// This `struct` is created by [`Vec::drain`]. +/// See its documentation for more. +/// +/// # Example +/// +/// ``` +/// let mut v = vec![0, 1, 2]; +/// let iter: std::vec::Drain<_> = v.drain(..); +/// ``` +#[stable(feature = "drain", since = "1.6.0")] +pub struct Drain<'a, T: 'a> { + /// Index of tail to preserve + tail_start: usize, + /// Length of tail + tail_len: usize, + /// Current remaining range to remove + iter: slice::Iter<'a, T>, + vec: NonNull>, +} + +#[stable(feature = "collection_debug", since = "1.17.0")] +impl fmt::Debug for Drain<'_, T> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_tuple("Drain").field(&self.iter.as_slice()).finish() + } +} + +impl<'a, T> Drain<'a, T> { + /// Returns the remaining items of this iterator as a slice. + /// + /// # Examples + /// + /// ``` + /// let mut vec = vec!['a', 'b', 'c']; + /// let mut drain = vec.drain(..); + /// assert_eq!(drain.as_slice(), &['a', 'b', 'c']); + /// let _ = drain.next().unwrap(); + /// assert_eq!(drain.as_slice(), &['b', 'c']); + /// ``` + #[stable(feature = "vec_drain_as_slice", since = "1.46.0")] + pub fn as_slice(&self) -> &[T] { + self.iter.as_slice() + } +} + +#[stable(feature = "vec_drain_as_slice", since = "1.46.0")] +impl<'a, T> AsRef<[T]> for Drain<'a, T> { + fn as_ref(&self) -> &[T] { + self.as_slice() + } +} + +#[stable(feature = "drain", since = "1.6.0")] +unsafe impl Sync for Drain<'_, T> {} +#[stable(feature = "drain", since = "1.6.0")] +unsafe impl Send for Drain<'_, T> {} + +#[stable(feature = "drain", since = "1.6.0")] +impl Iterator for Drain<'_, T> { + type Item = T; + + #[inline] + fn next(&mut self) -> Option { + self.iter.next().map(|elt| unsafe { ptr::read(elt as *const _) }) + } + + fn size_hint(&self) -> (usize, Option) { + self.iter.size_hint() + } +} + +#[stable(feature = "drain", since = "1.6.0")] +impl DoubleEndedIterator for Drain<'_, T> { + #[inline] + fn next_back(&mut self) -> Option { + self.iter.next_back().map(|elt| unsafe { ptr::read(elt as *const _) }) + } +} + +#[stable(feature = "drain", since = "1.6.0")] +impl Drop for Drain<'_, T> { + fn drop(&mut self) { + /// Continues dropping the remaining elements in the `Drain`, then moves back the + /// un-`Drain`ed elements to restore the original `Vec`. + struct DropGuard<'r, 'a, T>(&'r mut Drain<'a, T>); + + impl<'r, 'a, T> Drop for DropGuard<'r, 'a, T> { + fn drop(&mut self) { + // Continue the same loop we have below. If the loop already finished, this does + // nothing. + self.0.for_each(drop); + + if self.0.tail_len > 0 { + unsafe { + let source_vec = self.0.vec.as_mut(); + // memmove back untouched tail, update to new length + let start = source_vec.len(); + let tail = self.0.tail_start; + if tail != start { + let src = source_vec.as_ptr().add(tail); + let dst = source_vec.as_mut_ptr().add(start); + ptr::copy(src, dst, self.0.tail_len); + } + source_vec.set_len(start + self.0.tail_len); + } + } + } + } + + // exhaust self first + while let Some(item) = self.next() { + let guard = DropGuard(self); + drop(item); + mem::forget(guard); + } + + // Drop a `DropGuard` to move back the non-drained tail of `self`. + DropGuard(self); + } +} + +#[stable(feature = "drain", since = "1.6.0")] +impl ExactSizeIterator for Drain<'_, T> { + fn is_empty(&self) -> bool { + self.iter.is_empty() + } +} + +#[unstable(feature = "trusted_len", issue = "37572")] +unsafe impl TrustedLen for Drain<'_, T> {} + +#[stable(feature = "fused", since = "1.26.0")] +impl FusedIterator for Drain<'_, T> {} + +/// A splicing iterator for `Vec`. +/// +/// This struct is created by [`Vec::splice()`]. +/// See its documentation for more. +/// +/// # Example +/// +/// ``` +/// let mut v = vec![0, 1, 2]; +/// let new = [7, 8]; +/// let iter: std::vec::Splice<_> = v.splice(1.., new.iter().cloned()); +/// ``` +#[derive(Debug)] +#[stable(feature = "vec_splice", since = "1.21.0")] +pub struct Splice<'a, I: Iterator + 'a> { + drain: Drain<'a, I::Item>, + replace_with: I, +} + +#[stable(feature = "vec_splice", since = "1.21.0")] +impl Iterator for Splice<'_, I> { + type Item = I::Item; + + fn next(&mut self) -> Option { + self.drain.next() + } + + fn size_hint(&self) -> (usize, Option) { + self.drain.size_hint() + } +} + +#[stable(feature = "vec_splice", since = "1.21.0")] +impl DoubleEndedIterator for Splice<'_, I> { + fn next_back(&mut self) -> Option { + self.drain.next_back() + } +} + +#[stable(feature = "vec_splice", since = "1.21.0")] +impl ExactSizeIterator for Splice<'_, I> {} + +#[stable(feature = "vec_splice", since = "1.21.0")] +impl Drop for Splice<'_, I> { + fn drop(&mut self) { + self.drain.by_ref().for_each(drop); + + unsafe { + if self.drain.tail_len == 0 { + self.drain.vec.as_mut().extend(self.replace_with.by_ref()); + return; + } + + // First fill the range left by drain(). + if !self.drain.fill(&mut self.replace_with) { + return; + } + + // There may be more elements. Use the lower bound as an estimate. + // FIXME: Is the upper bound a better guess? Or something else? + let (lower_bound, _upper_bound) = self.replace_with.size_hint(); + if lower_bound > 0 { + self.drain.move_tail(lower_bound); + if !self.drain.fill(&mut self.replace_with) { + return; + } + } + + // Collect any remaining elements. + // This is a zero-length vector which does not allocate if `lower_bound` was exact. + let mut collected = self.replace_with.by_ref().collect::>().into_iter(); + // Now we have an exact count. + if collected.len() > 0 { + self.drain.move_tail(collected.len()); + let filled = self.drain.fill(&mut collected); + debug_assert!(filled); + debug_assert_eq!(collected.len(), 0); + } + } + // Let `Drain::drop` move the tail back if necessary and restore `vec.len`. + } +} + +/// Private helper methods for `Splice::drop` +impl Drain<'_, T> { + /// The range from `self.vec.len` to `self.tail_start` contains elements + /// that have been moved out. + /// Fill that range as much as possible with new elements from the `replace_with` iterator. + /// Returns `true` if we filled the entire range. (`replace_with.next()` didn’t return `None`.) + unsafe fn fill>(&mut self, replace_with: &mut I) -> bool { + let vec = unsafe { self.vec.as_mut() }; + let range_start = vec.len; + let range_end = self.tail_start; + let range_slice = unsafe { + slice::from_raw_parts_mut(vec.as_mut_ptr().add(range_start), range_end - range_start) + }; + + for place in range_slice { + if let Some(new_item) = replace_with.next() { + unsafe { ptr::write(place, new_item) }; + vec.len += 1; + } else { + return false; + } + } + true + } + + /// Makes room for inserting more elements before the tail. + unsafe fn move_tail(&mut self, additional: usize) { + let vec = unsafe { self.vec.as_mut() }; + let len = self.tail_start + self.tail_len; + vec.buf.reserve(len, additional); + + let new_tail_start = self.tail_start + additional; + unsafe { + let src = vec.as_ptr().add(self.tail_start); + let dst = vec.as_mut_ptr().add(new_tail_start); + ptr::copy(src, dst, self.tail_len); + } + self.tail_start = new_tail_start; + } +} + +/// An iterator which uses a closure to determine if an element should be removed. +/// +/// This struct is created by [`Vec::drain_filter`]. +/// See its documentation for more. +/// +/// # Example +/// +/// ``` +/// #![feature(drain_filter)] +/// +/// let mut v = vec![0, 1, 2]; +/// let iter: std::vec::DrainFilter<_, _> = v.drain_filter(|x| *x % 2 == 0); +/// ``` +#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] +#[derive(Debug)] +pub struct DrainFilter<'a, T, F> +where + F: FnMut(&mut T) -> bool, +{ + vec: &'a mut Vec, + /// The index of the item that will be inspected by the next call to `next`. + idx: usize, + /// The number of items that have been drained (removed) thus far. + del: usize, + /// The original length of `vec` prior to draining. + old_len: usize, + /// The filter test predicate. + pred: F, + /// A flag that indicates a panic has occurred in the filter test predicate. + /// This is used as a hint in the drop implementation to prevent consumption + /// of the remainder of the `DrainFilter`. Any unprocessed items will be + /// backshifted in the `vec`, but no further items will be dropped or + /// tested by the filter predicate. + panic_flag: bool, +} + +#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] +impl Iterator for DrainFilter<'_, T, F> +where + F: FnMut(&mut T) -> bool, +{ + type Item = T; + + fn next(&mut self) -> Option { + unsafe { + while self.idx < self.old_len { + let i = self.idx; + let v = slice::from_raw_parts_mut(self.vec.as_mut_ptr(), self.old_len); + self.panic_flag = true; + let drained = (self.pred)(&mut v[i]); + self.panic_flag = false; + // Update the index *after* the predicate is called. If the index + // is updated prior and the predicate panics, the element at this + // index would be leaked. + self.idx += 1; + if drained { + self.del += 1; + return Some(ptr::read(&v[i])); + } else if self.del > 0 { + let del = self.del; + let src: *const T = &v[i]; + let dst: *mut T = &mut v[i - del]; + ptr::copy_nonoverlapping(src, dst, 1); + } + } + None + } + } + + fn size_hint(&self) -> (usize, Option) { + (0, Some(self.old_len - self.idx)) + } +} + +#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] +impl Drop for DrainFilter<'_, T, F> +where + F: FnMut(&mut T) -> bool, +{ + fn drop(&mut self) { + struct BackshiftOnDrop<'a, 'b, T, F> + where + F: FnMut(&mut T) -> bool, + { + drain: &'b mut DrainFilter<'a, T, F>, + } + + impl<'a, 'b, T, F> Drop for BackshiftOnDrop<'a, 'b, T, F> + where + F: FnMut(&mut T) -> bool, + { + fn drop(&mut self) { + unsafe { + if self.drain.idx < self.drain.old_len && self.drain.del > 0 { + // This is a pretty messed up state, and there isn't really an + // obviously right thing to do. We don't want to keep trying + // to execute `pred`, so we just backshift all the unprocessed + // elements and tell the vec that they still exist. The backshift + // is required to prevent a double-drop of the last successfully + // drained item prior to a panic in the predicate. + let ptr = self.drain.vec.as_mut_ptr(); + let src = ptr.add(self.drain.idx); + let dst = src.sub(self.drain.del); + let tail_len = self.drain.old_len - self.drain.idx; + src.copy_to(dst, tail_len); + } + self.drain.vec.set_len(self.drain.old_len - self.drain.del); + } + } + } + + let backshift = BackshiftOnDrop { drain: self }; + + // Attempt to consume any remaining elements if the filter predicate + // has not yet panicked. We'll backshift any remaining elements + // whether we've already panicked or if the consumption here panics. + if !backshift.drain.panic_flag { + backshift.drain.for_each(drop); + } + } +} diff --git a/gcc/testsuite/rust/alloc/core.rs b/gcc/testsuite/rust/alloc/core.rs new file mode 100644 index 000000000000..8362e3473fcd --- /dev/null +++ b/gcc/testsuite/rust/alloc/core.rs @@ -0,0 +1,1902 @@ +/* + * ========== GCCRS MOCK-CORE ========== + */ + +// #![feature(no_core, lang_items, intrinsics, rustc_attrs, optin_builtin_traits)] +// #![no_core] + +// ---------- MACROS START ---------- + +#[macro_export] +macro_rules! format_args { + ($($arg:tt)*) => { + loop {} + }; +} +#[macro_export] +macro_rules! assert { + ($($arg:tt)*) => { + loop {} + }; +} +#[macro_export] +macro_rules! assert_eq { + ($($arg:tt)*) => { + loop {} + }; +} +#[macro_export] +macro_rules! debug_assert { + ($($arg:tt)*) => { + loop {} + }; +} +#[macro_export] +macro_rules! debug_assert_eq { + ($($arg:tt)*) => { + loop {} + }; +} +#[macro_export] +macro_rules! debug_assert_ne { + ($($arg:tt)*) => { + loop {} + }; +} +#[macro_export] +macro_rules! cfg { + ($($arg:tt)*) => { + loop {} + }; +} +#[macro_export] +macro_rules! write { + ($dst:expr, $($arg:tt)*) => { + loop {} + }; +} +#[macro_export] +macro_rules! panic { + ($($arg:tt)*) => { + loop {} + }; +} +#[macro_export] +macro_rules! unreachable { + ($($arg:tt)*) => { + loop {} + }; +} + +pub use crate::{ + assert, assert_eq, cfg, debug_assert, debug_assert_eq, debug_assert_ne, format_args, panic, + unreachable, write, +}; + +// ---------- MACROS END ---------- + +// ---------- INTRINSICS START ---------- + +pub mod intrinsics { + extern "rust-intrinsic" { + pub fn abort() -> !; + pub fn assume(b: bool); + pub fn copy_nonoverlapping(src: *const T, dst: *mut T, count: usize); + pub fn min_align_of_val(_: *const T) -> usize; + pub fn size_of_val(_: *const T) -> usize; + pub fn size_of() -> usize; + pub fn min_align_of() -> usize; + pub fn copy(src: *const T, dst: *mut T, count: usize); + pub fn arith_offset(dst: *const T, offset: isize) -> *const T; + pub fn write_bytes(dst: *mut T, val: u8, count: usize); + } + pub fn assert_zero_valid() {} +} + +// ---------- INTRINSICS END ---------- + +// ---------- USES START ---------- + +// ---------- USES END ---------- + +// ---------- MODULES START ---------- + +pub mod ops { + // ^^^ <- core::ops + + pub use self::arith::{Add, AddAssign, Sub}; + pub use self::deref::{Deref, DerefMut, Receiver}; + pub use bit::{BitAnd, BitOr, BitXor}; + pub use drop::Drop; + pub use function::{Fn, FnMut, FnOnce}; + pub use generator::{Generator, GeneratorState}; + pub use index::{Index, IndexMut}; + pub use range::{Bound, Range, RangeBounds}; + pub use try::Try; + pub use unsize::{CoerceUnsized, DispatchFromDyn}; + + use super::marker::Sized; + + pub mod range { + use crate::core::clone::Clone; + use crate::core::cmp::PartialOrd; + use crate::core::marker::Sized; + + #[lang = "RangeFull"] + #[derive(Copy, Clone, Default, PartialEq, Eq, Hash)] + pub struct RangeFull; + + #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)] + pub enum Bound { + Included(T), + Excluded(T), + Unbounded, + } + #[lang = "Range"] + #[derive(Clone, Default, PartialEq, Eq, Hash)] // not Copy -- see #27186 + pub struct Range { + pub start: Idx, + pub end: Idx, + } + #[lang = "RangeFrom"] + #[derive(Clone, PartialEq, Eq, Hash)] // not Copy -- see #27186 + pub struct RangeFrom { + pub start: Idx, + } + #[lang = "RangeTo"] + #[derive(Copy, Clone, PartialEq, Eq, Hash)] + pub struct RangeTo { + pub end: Idx, + } + #[lang = "RangeInclusive"] + #[derive(Clone, PartialEq, Eq, Hash)] // not Copy -- see #27186 + pub struct RangeInclusive { + pub start: Idx, + pub end: Idx, + pub exhausted: bool, + } + impl RangeInclusive { + #[lang = "range_inclusive_new"] + #[rustc_promotable] + pub const fn new(start: Idx, end: Idx) -> Self { + Self { + start, + end, + exhausted: false, + } + } + pub const fn start(&self) -> &Idx { + &self.start + } + pub const fn end(&self) -> &Idx { + &self.end + } + pub fn into_inner(self) -> (Idx, Idx) { + (self.start, self.end) + } + } + + #[lang = "RangeToInclusive"] + #[derive(Copy, Clone, PartialEq, Eq, Hash)] + pub struct RangeToInclusive { + pub end: Idx, + } + + pub trait RangeBounds { + fn start_bound(&self) -> Bound<&T>; + + fn end_bound(&self) -> Bound<&T>; + + #[track_caller] + fn assert_len(self, len: usize) -> Range + where + Self: RangeBounds, + { + let start: Bound<&usize> = self.start_bound(); + let end: Bound<&usize> = self.end_bound(); + Range { start, end } + } + + fn contains(&self, item: &U) -> bool + where + T: PartialOrd, + U: ?Sized + PartialOrd, + { + false + } + } + } + pub mod index { + use crate::core::marker::Sized; + + #[lang = "index"] + pub trait Index { + type Output: ?Sized; + + #[track_caller] + fn index(&self, index: Idx) -> &Self::Output; + } + #[lang = "index_mut"] + pub trait IndexMut: Index { + #[track_caller] + fn index_mut(&mut self, index: Idx) -> &mut Self::Output; + } + } + pub mod try { + use crate::core::result::Result; + + #[lang = "try"] + pub trait Try { + type Ok; + type Error; + + #[lang = "into_result"] + fn into_result(self) -> Result; + + #[lang = "from_error"] + fn from_error(v: Self::Error) -> Self; + + #[lang = "from_ok"] + fn from_ok(v: Self::Ok) -> Self; + } + } + pub mod arith { + #[lang = "add"] + pub trait Add { + type Output; + fn add(self, rhs: Rhs) -> Self::Output; + } + #[lang = "add_assign"] + pub trait AddAssign { + fn add_assign(&mut self, rhs: Rhs); + } + #[lang = "sub"] + pub trait Sub { + type Output; + fn sub(self, rhs: Rhs) -> Self::Output; + } + } + pub mod deref { + #[lang = "deref"] + pub trait Deref { + type Target: ?crate::core::marker::Sized; + fn deref(&self) -> &Self::Target; + } + + #[lang = "deref_mut"] + pub trait DerefMut: Deref { + fn deref_mut(&mut self) -> &mut Self::Target; + } + + #[lang = "receiver"] + pub trait Receiver { + // Empty. + } + } + pub mod unsize { + #[lang = "coerce_unsized"] + pub trait CoerceUnsized { + // Empty. + } + + #[lang = "dispatch_from_dyn"] + pub trait DispatchFromDyn { + // Empty. + } + } + pub mod generator { + use crate::core::clone::Clone; + use crate::core::pin::Pin; + + #[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)] + #[lang = "generator_state"] + pub enum GeneratorState { + Yielded(Y), + Complete(R), + } + + #[lang = "generator"] + #[fundamental] + pub trait Generator { + type Yield; + + type Return; + + fn resume(self: Pin<&mut Self>, arg: R) -> GeneratorState; + } + } + pub mod function { + #[lang = "fn_mut"] + #[rustc_paren_sugar] + #[fundamental] + pub trait FnMut: FnOnce { + extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output; + } + #[lang = "fn_once"] + #[rustc_paren_sugar] + #[fundamental] + pub trait FnOnce { + #[lang = "fn_once_output"] + type Output; + + extern "rust-call" fn call_once(self, args: Args) -> Self::Output; + } + #[lang = "fn"] + #[rustc_paren_sugar] + #[fundamental] // so that regex can rely that `&str: !FnMut` + pub trait Fn: FnMut { + extern "rust-call" fn call(&self, args: Args) -> Self::Output; + } + } + pub mod drop { + #[lang = "drop"] + pub trait Drop { + fn drop(&mut self); + } + } + pub mod bit { + #[lang = "bitand"] + pub trait BitAnd { + type Output; + + fn bitand(self, rhs: Rhs) -> Self::Output; + } + #[lang = "bitor"] + pub trait BitOr { + type Output; + + fn bitor(self, rhs: Rhs) -> Self::Output; + } + #[lang = "bitxor"] + pub trait BitXor { + type Output; + + fn bitxor(self, rhs: Rhs) -> Self::Output; + } + } +} + +pub mod mem { + // ^^^ <- core::mem + use super::clone::Clone; + use super::marker::Sized; + + #[lang = "manually_drop"] + #[derive(Copy, Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)] + #[repr(transparent)] + pub struct ManuallyDrop { + value: T, + } + + #[inline] + pub fn forget(t: T) { + let _ = ManuallyDrop { value: t }; + } + + #[lang = "maybe_uninit"] + #[derive(Copy)] + pub union MaybeUninit { + uninit: (), + value: ManuallyDrop, + } + + #[rustc_promotable] + pub const fn size_of() -> usize { + 0 + } + #[rustc_promotable] + pub const fn align_of() -> usize { + 0 + } + pub const fn align_of_val(val: &T) -> usize { + 0 + } + + pub fn drop(_x: T) {} + pub fn take(dest: &mut T) -> T { + replace(dest, T::default()) + } + pub fn replace(dest: &mut T, mut src: T) -> T { + swap(dest, &mut src); + src + } + pub fn swap(x: &mut T, y: &mut T) {} + + pub unsafe fn zeroed() -> T { + unsafe { T } + } + + pub const fn size_of_val(val: &T) -> usize { + 0 + } + pub unsafe fn align_of_val_raw(val: *const T) -> usize { + 0 + } +} + +pub mod ptr { + // ^^^ <- core::ptr + + #[repr(transparent)] + pub struct NonNull { + pointer: *const T, + } + #[repr(transparent)] + pub struct Unique { + pointer: *const T, + _marker: super::marker::PhantomData, + } + #[inline] + pub unsafe fn read(src: *const T) -> T { + loop {} + } + #[inline] + pub unsafe fn write(dst: *mut T, src: T) { + let _ = (dst, src); + } + + #[repr(C)] + pub union Repr { + pub(crate) rust: *const [T], + rust_mut: *mut [T], + pub(crate) raw: FatPtr, + } + #[repr(C)] + pub struct FatPtr { + data: *const T, + pub(crate) len: usize, + } + + pub const fn slice_from_raw_parts(data: *const T, len: usize) -> *const [T] { + unsafe { + Repr { + raw: FatPtr { data, len }, + } + .rust + } + } + pub const fn slice_from_raw_parts_mut(data: *mut T, len: usize) -> *mut [T] { + unsafe { + Repr { + raw: FatPtr { data, len }, + } + .rust_mut + } + } + + pub unsafe fn drop_in_place(to_drop: *mut T) {} + + pub unsafe fn copy(src: *const T, dst: *mut T, count: usize) {} + pub unsafe fn replace(dst: *mut T, mut src: T) -> T { + src + } +} + +pub mod marker { + // ^^^^^^ <- core::marker + + #[lang = "phantom_data"] + pub struct PhantomData; + + #[lang = "copy"] + pub trait Copy: super::clone::Clone { + // ^^^^ <- derive(Copy) + } + #[rustc_builtin_macro] + #[allow_internal_unstable(core_intrinsics, derive_clone_copy)] + pub macro Copy($item:item) { + /* compiler built-in */ + } + + #[lang = "structural_teq"] + pub trait StructuralEq { + // Empty. + } + #[lang = "structural_peq"] + pub trait StructuralPartialEq { + // Empty. + } + + #[lang = "sized"] + #[fundamental] + #[rustc_specialization_trait] + pub trait Sized { + // Empty. + } + + #[lang = "unpin"] + pub auto trait Unpin {} + + #[lang = "unsize"] + pub trait Unsize { + // Empty. + } + + pub unsafe auto trait Send { + // empty. + } + #[lang = "sync"] + pub unsafe auto trait Sync { + // Empty + } +} + +pub mod cmp { + // ^^^ <- core::cmp + + #[derive(Clone, Copy, PartialEq, Debug, Hash)] + pub enum Ordering { + Less = -1, + Equal = 0, + Greater = 1, + } + + #[lang = "eq"] + pub trait PartialEq { + // ^^^^^^^^^ <- derive(PartialEq) + fn eq(&self, other: &Rhs) -> bool; + + #[inline] + fn ne(&self, other: &Rhs) -> bool { + !self.eq(other) + } + } + #[rustc_builtin_macro] + #[allow_internal_unstable(core_intrinsics, structural_match)] + pub macro PartialEq($item:item) { + /* compiler built-in */ + } + + pub trait Eq: PartialEq { + // ^^ <- derive(Eq) + #[inline] + fn assert_receiver_is_total_eq(&self) {} + } + #[rustc_builtin_macro] + #[allow_internal_unstable(core_intrinsics, derive_eq, structural_match)] + pub macro Eq($item:item) { + /* compiler built-in */ + } + + #[lang = "partial_ord"] + pub trait PartialOrd: PartialEq { + // ^^^^^^^^^^ <- derive(PartialOrd) + fn partial_cmp(&self, other: &Rhs) -> super::option::Option; + + #[inline] + fn lt(&self, other: &Rhs) -> bool { + false + } + + #[inline] + fn le(&self, other: &Rhs) -> bool { + false + } + + #[inline] + fn gt(&self, other: &Rhs) -> bool { + false + } + + #[inline] + fn ge(&self, other: &Rhs) -> bool { + false + } + } + #[rustc_builtin_macro] + #[allow_internal_unstable(core_intrinsics)] + pub macro PartialOrd($item:item) { + /* compiler built-in */ + } + + pub trait Ord: Eq + PartialOrd { + // ^^^ <- derive(Ord) + fn cmp(&self, other: &Self) -> Ordering; + + #[inline] + fn max(self, other: Self) -> Self + where + Self: super::marker::Sized, + { + self + } + + #[inline] + fn min(self, other: Self) -> Self + where + Self: super::marker::Sized, + { + self + } + fn clamp(self, min: Self, max: Self) -> Self + where + Self: super::marker::Sized, + { + self + } + } + + #[rustc_builtin_macro] + #[allow_internal_unstable(core_intrinsics)] + pub macro Ord($item:item) { + /* compiler built-in */ + } + + pub fn max(v1: T, v2: T) -> T { + v1.max(v2) + } + pub fn min(v1: T, v2: T) -> T { + v1.min(v2) + } +} + +pub mod fmt { + // ^^^ <- core::fmt + + pub use builders::{DebugList, DebugMap, DebugSet, DebugStruct, DebugTuple}; + pub use num::{LowerHex, UpperHex}; + + use super::clone::Clone; + use super::option::Option; + + pub struct Formatter<'a> { + _marker: super::marker::PhantomData<&'a ()>, + } + + pub type Result = super::result::Result<(), Error>; + + #[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)] + pub struct Error; + + pub trait Debug { + // ^^^^^ <- derive(Debug) + fn fmt(&self, f: &mut Formatter<'_>) -> Result; + } + pub(crate) mod macros { + #[rustc_builtin_macro] + #[allow_internal_unstable(core_intrinsics)] + pub macro Debug($item:item) { + /* compiler built-in */ + } + } + pub use macros::Debug; + + pub trait Display { + fn fmt(&self, f: &mut Formatter<'_>) -> Result; + } + + pub trait Pointer { + fn fmt(&self, f: &mut Formatter<'_>) -> Result; + } + + #[derive(Debug)] + pub enum Alignment { + Left, + Right, + Center, + } + + pub fn write(output: &mut dyn Write, args: Arguments<'_>) -> Result { + Result::Ok(()) + } + + pub trait Write { + fn write_str(&mut self, s: &str) -> Result; + + fn write_char(&mut self, c: char) -> Result { + self.write_str(c.encode_utf8(&mut [0; 4])) + } + + fn write_fmt(mut self: &mut Self, args: Arguments<'_>) -> Result { + write(&mut self, args) + } + } + + type Opaque = usize; + + #[derive(Copy, Clone)] + #[allow(missing_debug_implementations)] + pub struct ArgumentV1<'a> { + value: &'a Opaque, + formatter: fn(&Opaque, &mut Formatter<'_>) -> Result, + } + + #[derive(Copy, Clone)] + pub struct Arguments<'a> { + pieces: &'a [&'static str], + fmt: Option<&'a [rt::v1::Argument]>, + args: &'a [ArgumentV1<'a>], + } + + pub trait Binary { + fn fmt(&self, f: &mut Formatter<'_>) -> Result; + } + pub trait Octal { + fn fmt(&self, f: &mut Formatter<'_>) -> Result; + } + pub trait LowerExp { + fn fmt(&self, f: &mut Formatter<'_>) -> Result; + } + pub trait UpperExp { + fn fmt(&self, f: &mut Formatter<'_>) -> Result; + } + + pub mod num { + #[derive(Clone, PartialEq)] + struct Binary; + #[derive(Clone, PartialEq)] + struct Octal; + #[derive(Clone, PartialEq)] + struct LowerHex; + #[derive(Clone, PartialEq)] + struct UpperHex; + } + + pub mod rt { + pub mod v1 { + #![allow(missing_debug_implementations)] + + use crate::core::clone::Clone; + + #[derive(Copy, Clone)] + pub struct Argument { + pub position: usize, + pub format: FormatSpec, + } + #[derive(Copy, Clone)] + pub struct FormatSpec { + pub fill: char, + pub align: Alignment, + pub flags: u32, + pub precision: Count, + pub width: Count, + } + #[derive(Copy, Clone, PartialEq, Eq)] + pub enum Alignment { + Left, + Right, + Center, + Unknown, + } + #[derive(Copy, Clone)] + pub enum Count { + Is(usize), + Param(usize), + Implied, + } + } + } + + pub mod builders { + use super::Formatter; + + struct PadAdapter<'buf, 'state> { + buf: &'buf mut (dyn super::Write + 'buf), + state: &'state mut PadAdapterState, + } + struct PadAdapterState { + on_newline: bool, + } + #[allow(missing_debug_implementations)] + pub struct DebugList<'a, 'b: 'a> { + inner: DebugInner<'a, 'b>, + } + struct DebugInner<'a, 'b: 'a> { + fmt: &'a mut Formatter<'b>, + result: super::Result, + has_fields: bool, + } + #[allow(missing_debug_implementations)] + pub struct DebugMap<'a, 'b: 'a> { + fmt: &'a mut Formatter<'b>, + result: super::Result, + has_fields: bool, + has_key: bool, + state: PadAdapterState, + } + #[allow(missing_debug_implementations)] + pub struct DebugSet<'a, 'b: 'a> { + inner: DebugInner<'a, 'b>, + } + #[allow(missing_debug_implementations)] + pub struct DebugStruct<'a, 'b: 'a> { + fmt: &'a mut Formatter<'b>, + result: super::Result, + has_fields: bool, + } + #[allow(missing_debug_implementations)] + pub struct DebugTuple<'a, 'b: 'a> { + fmt: &'a mut Formatter<'b>, + result: super::Result, + fields: usize, + empty_name: bool, + } + } +} + +pub mod clone { + // ^^^^^ <- core::clone + + #[lang = "clone"] + pub trait Clone: super::marker::Sized { + // ^^^^^ <- derive(Clone) + fn clone(&self) -> Self; + + #[inline] + fn clone_from(&mut self, source: &Self) { + *self = source.clone() + } + } + #[rustc_builtin_macro] + #[allow_internal_unstable(core_intrinsics, derive_clone_copy)] + pub macro Clone($item:item) { + /* compiler built-in */ + } +} + +pub mod iter { + // ^^^^ <- core::iter + + pub use adapters::{zip::TrustedRandomAccess, Peekable, SourceIter}; + pub use sources::{repeat_with, RepeatWith}; + pub use traits::marker::{InPlaceIterable, TrustedLen}; + pub use traits::{ + DoubleEndedIterator, ExactSizeIterator, Extend, FromIterator, IntoIterator, Iterator, + }; + + use super::clone::Clone; + use super::marker::Sized; + use super::option::Option; + use super::result::Result; + + pub trait FusedIterator {} + pub mod traits { + use super::Option; + use super::Result; + use super::Sized; + use crate::core::ops::function::FnMut; + use crate::core::ops::try::Try; + pub trait IntoIterator { + type Item; + type IntoIter: Iterator; + #[lang = "into_iter"] + fn into_iter(self) -> Self::IntoIter; + } + + pub trait Iterator { + type Item; + #[lang = "next"] + fn next(&mut self) -> super::option::Option; + } + + pub trait FromIterator: crate::core::marker::Sized { + fn from_iter>(iter: T) -> Self; + } + pub mod marker { + #[rustc_unsafe_specialization_marker] + pub unsafe trait TrustedLen: super::Iterator {} + pub unsafe trait InPlaceIterable: super::Iterator {} + } + pub trait DoubleEndedIterator: Iterator { + fn next_back(&mut self) -> super::Option; + fn advance_back_by(&mut self, n: usize) -> Result<(), usize> { + super::Result::Ok(()) + } + fn nth_back(&mut self, n: usize) -> super::Option { + self.next_back() + } + fn try_rfold(&mut self, init: B, mut f: F) -> R + where + Self: Sized, + F: FnMut(B, Self::Item) -> R, + R: Try, + { + loop {} + } + fn rfold(mut self, init: B, mut f: F) -> B + where + Self: Sized, + F: FnMut(B, Self::Item) -> B, + { + let mut accum = init; + accum + } + fn rfind

(&mut self, predicate: P) -> Option + where + Self: Sized, + P: FnMut(&Self::Item) -> bool, + { + false + } + } + pub trait ExactSizeIterator: Iterator { + fn len(&self) -> usize { + 0 + } + fn is_empty(&self) -> bool { + false + } + } + pub trait Extend { + fn extend>(&mut self, iter: T); + fn extend_one(&mut self, item: A) {} + fn extend_reserve(&mut self, additional: usize) { + let _ = additional; + } + } + } + pub mod adapters { + use super::traits::Iterator; + use super::Clone; + use crate::core::option::Option; + + #[derive(Clone)] + pub struct Map { + iter: I, + f: F, + } + #[derive(Clone)] + pub struct Filter { + iter: I, + predicate: P, + } + #[derive(Clone, Debug)] + pub struct Copied { + it: I, + } + pub unsafe trait SourceIter { + type Source: Iterator; + + unsafe fn as_inner(&mut self) -> &mut Self::Source; + } + #[derive(Clone, Debug)] + pub struct Peekable { + iter: I, + peeked: Option>, + } + pub mod flatten { + use super::fuse::Fuse; + use super::Clone; + use super::Map; + use crate::core::iter::traits::{IntoIterator, Iterator}; + use crate::core::option::Option; + + pub struct Flatten> { + inner: FlattenCompat::IntoIter>, + } + pub struct FlatMap { + inner: FlattenCompat, ::IntoIter>, + } + #[derive(Clone, Debug)] + struct FlattenCompat { + iter: Fuse, + frontiter: Option, + backiter: Option, + } + } + pub mod fuse { + use super::Clone; + use crate::core::option::Option; + + #[derive(Clone, Debug)] + pub struct Fuse { + iter: Option, + } + } + pub mod chain { + use super::Clone; + use crate::core::option::Option; + + #[derive(Clone, Debug)] + pub struct Chain { + a: Option, + b: Option, + } + } + pub mod zip { + pub unsafe trait TrustedRandomAccess: crate::core::marker::Sized { + fn size(&self) -> usize + where + Self: super::Iterator, + { + 0 + } + fn may_have_side_effect() -> bool; + } + } + } + pub mod sources { + use super::Clone; + use crate::core::ops::function::FnMut; + + #[derive(Copy, Clone, Debug)] + pub struct RepeatWith { + repeater: F, + } + pub fn repeat_with A>(repeater: F) -> RepeatWith { + RepeatWith { repeater } + } + } +} + +pub mod alloc { + // ^^^^^ <- core::alloc + + use super::clone::Clone; + use super::ptr::NonNull; + use super::result::Result; + + #[derive(Copy, Clone, Debug, PartialEq, Eq)] + // GCCRS: commented out because this lang item not supported yet + #[lang = "alloc_layout"] + pub struct Layout { + size_: usize, + align_: usize, // NonZeroUsize, + } + #[derive(Copy, Clone, PartialEq, Eq, Debug)] + pub struct AllocError {} + + pub unsafe trait AllocRef { + fn alloc(&self, layout: Layout) -> Result, AllocError>; + + fn alloc_zeroed(&self, layout: Layout) -> Result, AllocError> { + self.alloc(layout) + } + + unsafe fn dealloc(&self, ptr: NonNull, layout: Layout); + + unsafe fn grow( + &self, + ptr: NonNull, + old_layout: Layout, + new_layout: Layout, + ) -> Result, AllocError> { + self.alloc(new_layout) + } + + unsafe fn grow_zeroed( + &self, + ptr: NonNull, + old_layout: Layout, + new_layout: Layout, + ) -> Result, AllocError> { + self.alloc_zeroed(new_layout) + } + + unsafe fn shrink( + &self, + ptr: NonNull, + old_layout: Layout, + new_layout: Layout, + ) -> Result, AllocError> { + self.alloc(new_layout) + } + + fn by_ref(&self) -> &Self { + self + } + } + + // mod layout + #[derive(Clone, PartialEq, Eq, Debug)] + pub struct LayoutErr { + private: (), + } +} + +pub mod result { + // ^^^^^^ <- core::result + + #[derive(Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)] + pub enum Result { + #[lang = "Ok"] + Ok(T), + + #[lang = "Err"] + Err(E), + } +} + +pub mod default { + // ^^^^^^^ <- core::default + + pub trait Default: super::marker::Sized { + // ^^^^^^^ <- derive(Default) + fn default() -> Self; + } + + #[inline] + pub fn default() -> T { + Default::default() + } + + #[rustc_builtin_macro] + #[allow_internal_unstable(core_intrinsics)] + pub macro Default($item:item) { + /* compiler built-in */ + } +} + +pub mod hash { + // ^^^^ <- core::hash + + pub trait Hash { + // ^^^^ <- derive(Hash) + fn hash(&self, state: &mut H); + + fn hash_slice(data: &[Self], state: &mut H) + where + Self: super::marker::Sized, + { + } + } + pub(crate) mod macros { + #[rustc_builtin_macro] + #[allow_internal_unstable(core_intrinsics)] + pub macro Hash($item:item) { + /* compiler built-in */ + } + } + pub use macros::Hash; + + pub trait Hasher { + fn finish(&self) -> u64; + fn write(&mut self, bytes: &[u8]); + #[inline] + fn write_u8(&mut self, i: u8) { + // self.write(&[i]) + } + #[inline] + fn write_u16(&mut self, i: u16) { + // self.write(&i.to_ne_bytes()) + } + #[inline] + fn write_u32(&mut self, i: u32) { + // self.write(&i.to_ne_bytes()) + } + #[inline] + fn write_u64(&mut self, i: u64) { + // self.write(&i.to_ne_bytes()) + } + #[inline] + fn write_u128(&mut self, i: u128) { + // self.write(&i.to_ne_bytes()) + } + #[inline] + fn write_usize(&mut self, i: usize) { + // self.write(&i.to_ne_bytes()) + } + #[inline] + fn write_i8(&mut self, i: i8) { + // self.write_u8(i as u8) + } + #[inline] + fn write_i16(&mut self, i: i16) { + // self.write_u16(i as u16) + } + #[inline] + fn write_i32(&mut self, i: i32) { + // self.write_u32(i as u32) + } + #[inline] + fn write_i64(&mut self, i: i64) { + // self.write_u64(i as u64) + } + #[inline] + fn write_i128(&mut self, i: i128) { + // self.write_u128(i as u128) + } + #[inline] + fn write_isize(&mut self, i: isize) { + // self.write_usize(i as usize) + } + } +} + +pub mod option { + // ^^^^^^ <- core::option + + use super::clone::Clone; + + #[derive(Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)] + pub enum Option { + #[lang = "None"] + None, + #[lang = "Some"] + Some(T), + } + #[derive(Clone, Debug)] + pub struct IntoIter { + inner: Item, + } + #[derive(Clone, Debug)] + struct Item { + opt: Option, + } +} + +pub mod convert { + // ^^^^^^^ <- core::convert; + use super::marker::Sized; + use super::result::Result; + + pub trait From: Sized { + #[lang = "from"] + fn from(_: T) -> Self; + } + pub trait TryFrom: Sized { + type Error; + + fn try_from(value: T) -> Result; + } + pub trait AsRef { + fn as_ref(&self) -> &T; + } + pub trait AsMut { + fn as_mut(&mut self) -> &mut T; + } + #[derive(Copy)] + pub enum Infallible {} + impl crate::core::clone::Clone for Infallible { + fn clone(&self) -> Infallible { + match *self {} + } + } +} + +pub mod borrow { + // ^^^^^^ <- core::borrow + + use super::marker::Sized; + + pub trait Borrow { + fn borrow(&self) -> &Borrowed; + } + pub trait BorrowMut: Borrow { + fn borrow_mut(&mut self) -> &mut Borrowed; + } +} + +pub mod any { + // ^^^ <- core::any + use super::clone::Clone; + + #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)] + pub struct TypeId { + t: u64, + } + + pub trait Any: 'static { + fn type_id(&self) -> TypeId; + } +} + +pub mod future { + // ^^^^^^ <- core::future + use super::pin::Pin; + use super::task::{Context, Poll}; + + #[lang = "future_trait"] + pub trait Future { + type Output; + + #[lang = "poll"] + fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll; + } +} + +pub mod pin { + // ^^^ <- core::pin + use super::clone::Clone; + + #[lang = "pin"] + #[fundamental] + #[derive(Copy, Clone)] + pub struct Pin

{ + pointer: P, + } +} + +pub mod task { + // ^^^^ <- core::pin + pub use self::poll::Poll; + pub use self::wake::{Context, RawWaker, RawWakerVTable, Waker}; + + use super::clone::Clone; + + pub mod wake { + use super::Clone; + #[derive(PartialEq, Copy, Clone, Debug)] + pub struct RawWakerVTable { + clone: unsafe fn(*const ()) -> RawWaker, + wake: unsafe fn(*const ()), + wake_by_ref: unsafe fn(*const ()), + drop: unsafe fn(*const ()), + } + #[derive(PartialEq, Debug)] + pub struct RawWaker { + data: *const (), + vtable: &'static RawWakerVTable, + } + pub struct Waker { + waker: RawWaker, + } + pub struct Context<'a> { + waker: &'a Waker, + _marker: crate::core::marker::PhantomData &'a ()>, + } + } + + pub mod poll { + use crate::core::clone::Clone; + + #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] + pub enum Poll { + #[lang = "Ready"] + Ready(T), + + #[lang = "Pending"] + Pending, + } + } +} + +pub mod slice { + // ^^^^^ <- core::slice + pub use index::SliceIndex; + pub use iter::*; + pub use raw::*; + + pub mod raw { + use crate::core::array; + use crate::core::ptr; + + pub unsafe fn from_raw_parts<'a, T>(data: *const T, len: usize) -> &'a [T] { + unsafe { &*ptr::slice_from_raw_parts(data, len) } + } + pub unsafe fn from_raw_parts_mut<'a, T>(data: *mut T, len: usize) -> &'a mut [T] { + unsafe { &mut *ptr::slice_from_raw_parts_mut(data, len) } + } + pub fn from_ref(s: &T) -> &[T] { + array::from_ref(s) + } + pub fn from_mut(s: &mut T) -> &mut [T] { + array::from_mut(s) + } + } + pub mod iter { + use crate::core::clone::Clone; + use crate::core::marker::PhantomData; + use crate::core::num::NonZeroUsize; + use crate::core::ops::function::FnMut; + use crate::core::ptr::NonNull; + + pub struct Iter<'a, T: 'a> { + ptr: NonNull, + end: *const T, + _marker: PhantomData<&'a T>, + } + pub struct IterMut<'a, T: 'a> { + ptr: NonNull, + end: *mut T, + _marker: PhantomData<&'a mut T>, + } + // #[derive(Debug)] + pub struct Windows<'a, T: 'a> { + v: &'a [T], + size: NonZeroUsize, + } + // #[derive(Debug)] + pub struct Chunks<'a, T: 'a> { + v: &'a [T], + chunk_size: usize, + } + // #[derive(Debug)] + pub struct ChunksMut<'a, T: 'a> { + v: &'a mut [T], + chunk_size: usize, + } + // #[derive(Debug)] + pub struct ChunksExact<'a, T: 'a> { + v: &'a [T], + rem: &'a [T], + chunk_size: usize, + } + // #[derive(Debug)] + pub struct ChunksExactMut<'a, T: 'a> { + v: &'a mut [T], + rem: &'a mut [T], + chunk_size: usize, + } + // #[derive(Debug)] + pub struct ArrayChunks<'a, T: 'a, const N: usize> { + iter: Iter<'a, [T; N]>, + rem: &'a [T], + } + // #[derive(Debug)] + pub struct ArrayChunksMut<'a, T: 'a, const N: usize> { + iter: IterMut<'a, [T; N]>, + rem: &'a mut [T], + } + // #[derive(Debug, Clone, Copy)] + pub struct ArrayWindows<'a, T: 'a, const N: usize> { + slice_head: *const T, + num: usize, + marker: PhantomData<&'a [T; N]>, + } + pub struct Split<'a, T: 'a, P> + where + P: FnMut(&T) -> bool, + { + v: &'a [T], + pred: P, + finished: bool, + } + pub struct SplitMut<'a, T: 'a, P> + where + P: FnMut(&T) -> bool, + { + v: &'a mut [T], + pred: P, + finished: bool, + } + // #[derive(Debug)] + pub struct RChunks<'a, T: 'a> { + v: &'a [T], + chunk_size: usize, + } + // #[derive(Debug)] + pub struct RChunksExact<'a, T: 'a> { + v: &'a [T], + rem: &'a [T], + chunk_size: usize, + } + // #[derive(Debug)] + pub struct RChunksExactMut<'a, T: 'a> { + v: &'a mut [T], + rem: &'a mut [T], + chunk_size: usize, + } + // #[derive(Debug)] + pub struct RChunksMut<'a, T: 'a> { + v: &'a mut [T], + chunk_size: usize, + } + pub struct RSplit<'a, T: 'a, P> + where + P: FnMut(&T) -> bool, + { + inner: Split<'a, T, P>, + } + pub struct RSplitMut<'a, T: 'a, P> + where + P: FnMut(&T) -> bool, + { + inner: SplitMut<'a, T, P>, + } + pub struct RSplitN<'a, T: 'a, P> + where + P: FnMut(&T) -> bool, + { + inner: GenericSplitN>, + } + pub struct RSplitNMut<'a, T: 'a, P> + where + P: FnMut(&T) -> bool, + { + inner: GenericSplitN>, + } + pub struct SplitN<'a, T: 'a, P> + where + P: FnMut(&T) -> bool, + { + inner: GenericSplitN>, + } + pub struct SplitNMut<'a, T: 'a, P> + where + P: FnMut(&T) -> bool, + { + inner: GenericSplitN>, + } + // #[derive(Debug)] + struct GenericSplitN { + iter: I, + count: usize, + } + } + pub mod index { + use crate::core::marker::Sized; + use crate::core::option::Option; + + pub unsafe trait SliceIndex: private_slice_index::Sealed { + type Output: ?Sized; + + fn get(self, slice: &T) -> Option<&Self::Output>; + + fn get_mut(self, slice: &mut T) -> Option<&mut Self::Output>; + + unsafe fn get_unchecked(self, slice: *const T) -> *const Self::Output; + + unsafe fn get_unchecked_mut(self, slice: *mut T) -> *mut Self::Output; + + #[track_caller] + fn index(self, slice: &T) -> &Self::Output; + + #[track_caller] + fn index_mut(self, slice: &mut T) -> &mut Self::Output; + } + mod private_slice_index { + // use crate::core::ops; + pub trait Sealed {} + + // impl Sealed for usize {} + // impl Sealed for ops::Range {} + // impl Sealed for ops::RangeTo {} + // impl Sealed for ops::RangeFrom {} + // impl Sealed for ops::RangeFull {} + // impl Sealed for ops::RangeInclusive {} + // impl Sealed for ops::RangeToInclusive {} + } + } +} + +pub mod array { + // ^^^^^ <- core::array + pub fn from_ref(s: &T) -> &[T; 1] { + unsafe { &*(s as *const T).cast::<[T; 1]>() } + } + + pub fn from_mut(s: &mut T) -> &mut [T; 1] { + unsafe { &mut *(s as *mut T).cast::<[T; 1]>() } + } + pub mod iter { + use crate::core::mem::MaybeUninit; + use crate::core::ops::range::Range; + pub struct IntoIter { + data: [MaybeUninit; N], + alive: Range, + } + } +} + +pub mod num { + // ^^^ <- core::num + pub use nonzero::NonZeroUsize; + + pub mod nonzero { + pub type NonZeroUsize = usize; + } +} + +pub mod unicode { + // ^^^^^^^ <- core::unicode; + pub use unicode_data::conversions; + + pub mod derived_property { + pub fn Case_Ignorable(c: char) -> bool { + false + } + pub fn Cased(c: char) -> bool { + false + } + } + + pub mod unicode_data { + pub mod conversions { + pub fn to_lower(c: char) -> [char; 3] { + [c, '\0', '\0'] + } + pub fn to_upper(c: char) -> [char; 3] { + [c, '\0', '\0'] + } + } + pub mod case_ignorable { + pub fn lookup(c: char) -> bool { + false + } + } + pub mod cased { + pub fn lookup(c: char) -> bool { + false + } + } + } +} + +pub mod str { + // ^^^ <- core::str; + pub use convert::*; + pub use error::*; + pub use iter::*; + pub use traits::FromStr; + + pub use iter::Chars; + + use super::option::Option; + use super::result::Result; + use crate::core::clone::Clone; + + #[derive(Clone)] + struct LinesAnyMap; + struct CharEscapeDebugContinue; + #[derive(Clone)] + struct CharEscapeUnicode; + #[derive(Clone)] + struct CharEscapeDefault; + #[derive(Clone)] + struct IsWhitespace; + #[derive(Clone)] + struct IsAsciiWhitespace; + #[derive(Clone)] + struct IsNotEmpty; + #[derive(Clone)] + struct BytesIsNotEmpty; + #[derive(Clone)] + struct UnsafeBytesToStr; + + pub mod pattern { + use super::Clone; + use super::Option; + + #[derive(Copy, Clone, Eq, PartialEq, Debug)] + pub enum SearchStep { + Match(usize, usize), + Reject(usize, usize), + Done, + } + + pub unsafe trait Searcher<'a> { + fn haystack(&self) -> &'a str; + + fn next(&mut self) -> SearchStep; + + fn next_match(&mut self) -> Option<(usize, usize)> { + Option::None + } + + fn next_reject(&mut self) -> Option<(usize, usize)> { + Option::None + } + } + pub unsafe trait ReverseSearcher<'a>: Searcher<'a> { + fn next_back(&mut self) -> SearchStep; + + fn next_match_back(&mut self) -> Option<(usize, usize)> { + Option::None + } + + fn next_reject_back(&mut self) -> Option<(usize, usize)> { + Option::None + } + } + pub trait Pattern<'a>: crate::core::marker::Sized { + type Searcher: Searcher<'a>; + + fn into_searcher(self, haystack: &'a str) -> Self::Searcher; + + fn is_contained_in(self, haystack: &'a str) -> bool { + false + } + + fn is_prefix_of(self, haystack: &'a str) -> bool { + false + } + + fn is_suffix_of(self, haystack: &'a str) -> bool + where + Self::Searcher: ReverseSearcher<'a>, + { + false + } + + fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str> { + Option::None + } + + fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> + where + Self::Searcher: ReverseSearcher<'a>, + { + Option::None + } + } + pub trait DoubleEndedSearcher<'a>: ReverseSearcher<'a> {} + } + pub mod iter { + use super::Clone; + use super::{ + BytesIsNotEmpty, CharEscapeDebugContinue, CharEscapeDefault, CharEscapeUnicode, + IsAsciiWhitespace, IsNotEmpty, IsWhitespace, LinesAnyMap, UnsafeBytesToStr, + }; + use crate::core::iter::adapters::chain::Chain; + use crate::core::iter::adapters::flatten::{FlatMap, Flatten}; + use crate::core::iter::adapters::fuse::Fuse; + use crate::core::iter::adapters::{Copied, Filter, Map}; + use crate::core::slice::iter::Split as SliceSplit; + + #[derive(Clone, Debug)] + pub struct SplitAsciiWhitespace<'a> { + pub inner: Map< + Filter, BytesIsNotEmpty>, + UnsafeBytesToStr, + >, + } + #[derive(Clone)] + pub struct Chars<'a> { + pub iter: crate::core::slice::Iter<'a, u8>, + } + #[derive(Clone, Debug)] + pub struct CharIndices<'a> { + pub front_offset: usize, + pub iter: Chars<'a>, + } + #[derive(Clone)] + pub struct EncodeUtf16<'a> { + pub chars: Chars<'a>, + pub extra: u16, + } + #[derive(Clone, Debug)] + pub struct SplitWhitespace<'a> { + pub inner: Filter, IsNotEmpty>, + } + #[derive(Clone, Debug)] + pub struct Bytes<'a>(pub Copied>); + #[derive(Clone, Debug)] + pub struct EscapeDebug<'a> { + pub inner: Chain< + Flatten>, + FlatMap, char::EscapeDebug, CharEscapeDebugContinue>, + >, + } + #[derive(Clone, Debug)] + pub struct EscapeDefault<'a> { + pub(super) inner: FlatMap, char::EscapeDefault, CharEscapeDefault>, + } + #[derive(Clone, Debug)] + pub struct EscapeUnicode<'a> { + pub(super) inner: FlatMap, char::EscapeUnicode, CharEscapeUnicode>, + } + #[derive(Clone, Debug)] + pub struct Lines<'a>(pub Map, LinesAnyMap>); + #[derive(Clone, Debug)] + pub struct LinesAny<'a>(pub Lines<'a>); + // generator_pattern_iterators! + pub struct MatchIndices; + pub struct RMatchIndices; + pub struct Matches; + pub struct RMatches; + pub struct Split; + pub struct RSplit; + pub struct RSplitN; + pub struct SplitN; + pub struct SplitTerminator; + pub struct RSplitTerminator; + // generate_pattern_iterators! + } + pub mod error { + use super::Clone; + + #[derive(Copy, Eq, PartialEq, Clone, Debug)] + pub struct Utf8Error { + pub valid_up_to: usize, + pub error_len: super::option::Option, + } + #[derive(Debug, Clone, PartialEq, Eq)] + pub struct ParseBoolError { + pub _priv: (), + } + } + pub mod convert { + use super::error::Utf8Error; + use super::Option; + use super::Result; + + pub fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error> { + Result::Err(Utf8Error { + valid_up_to: 0, + error_len: Option::None, + }) + } + pub fn from_utf8_mut(v: &mut [u8]) -> Result<&mut str, Utf8Error> { + Result::Err(Utf8Error { + valid_up_to: 0, + error_len: Option::None, + }) + } + pub const unsafe fn from_utf8_unchecked(v: &[u8]) -> &str { + unsafe { &*(v as *mut [u8] as *mut str) } + } + pub unsafe fn from_utf8_unchecked_mut(v: &mut [u8]) -> &mut str { + unsafe { &mut *(v as *mut [u8] as *mut str) } + } + } + pub mod traits { + use super::Result; + pub trait FromStr: crate::core::marker::Sized { + type Err; + + fn from_str(s: &str) -> Result; + } + } + pub mod lossy { + pub struct Utf8Lossy { + bytes: [u8], + } + #[derive(PartialEq, Eq, Debug)] + pub struct Utf8LossyChunk<'a> { + pub valid: &'a str, + pub broken: &'a [u8], + } + } +} + +pub mod char { + // ^^^^ <- core::char + pub use decode::{decode_utf16, REPLACEMENT_CHARACTER}; + + pub mod decode { + use crate::core::clone::Clone; + use crate::core::iter::traits::{IntoIterator, Iterator}; + use crate::core::option::Option; + + pub const REPLACEMENT_CHARACTER: char = '\u{FFFD}'; + + #[derive(Clone, Debug)] + pub struct DecodeUtf16 + where + I: Iterator, + { + iter: I, + buf: Option, + } + + pub fn decode_utf16>(iter: I) -> DecodeUtf16 { + DecodeUtf16 { + iter: iter.into_iter(), + buf: Option::None, + } + } + } +} + +pub mod hint { + // ^^^^ core::hint + pub const unsafe fn unreachable_unchecked() -> ! { + loop {} + } + pub fn spin_loop() {} +} + +pub mod cell { + use super::marker::Sized; + + #[repr(transparent)] + pub struct Cell { + value: UnsafeCell, + } + + #[lang = "unsafe_cell"] + #[repr(transparent)] + #[repr(no_niche)] // rust-lang/rust#68303. + pub struct UnsafeCell { + value: T, + } +} + +pub mod sync { + pub mod atomic { + use crate::core::clone::Clone; + #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)] + #[non_exhaustive] + pub enum Ordering { + Relaxed, + Release, + Acquire, + AcqRel, + SeqCst, + } + pub fn fence(order: Ordering) {} + } +} + +// ---------- MODULES END ---------- diff --git a/gcc/testsuite/rust/alloc/prelude.rs b/gcc/testsuite/rust/alloc/prelude.rs new file mode 100644 index 000000000000..96f69cd72ae7 --- /dev/null +++ b/gcc/testsuite/rust/alloc/prelude.rs @@ -0,0 +1,19 @@ +pub use crate::core; +use crate::{ + assert, assert_eq, cfg, debug_assert, debug_assert_eq, debug_assert_ne, format_args, panic, + unreachable, write, +}; +use core::alloc::AllocError; +use core::clone::Clone; +use core::cmp::{Eq, Ord, PartialEq, PartialOrd}; +use core::convert::{AsMut, AsRef, From}; +use core::default::Default; +use core::fmt::Debug; +use core::hash::Hash; +use core::iter::{DoubleEndedIterator, ExactSizeIterator, Extend, IntoIterator, Iterator}; +use core::marker::{Copy, Send, Sized, Sync}; +use core::mem::drop; +use core::ops::{Drop, Fn, FnMut, FnOnce}; +use core::option::Option::{self, None, Some}; +use core::result::Result::{self, Err, Ok}; +use core::str::Chars; From a7064fee10914f73161eed4a7a099f13cb992a0f Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Sun, 23 Aug 2026 16:28:04 +0100 Subject: [PATCH 054/584] gccrs: when binding we need to distingish between generics/const-generics Fixes Rust-GCC/gccrs#4812 gcc/rust/ChangeLog: * typecheck/rust-hir-trait-resolve.cc (AssociatedImplTrait::bind_impl_for_projection): switch between generics (AssociatedImplTrait::bind_impl_for_bound): likewise gcc/testsuite/ChangeLog: * rust/compile/issue-4812.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-trait-resolve.cc | 50 +++++++++++++++----- gcc/testsuite/rust/compile/issue-4812.rs | 23 +++++++++ 2 files changed, 61 insertions(+), 12 deletions(-) create mode 100644 gcc/testsuite/rust/compile/issue-4812.rs diff --git a/gcc/rust/typecheck/rust-hir-trait-resolve.cc b/gcc/rust/typecheck/rust-hir-trait-resolve.cc index 3ed46e0f0cce..be71f6fabacb 100644 --- a/gcc/rust/typecheck/rust-hir-trait-resolve.cc +++ b/gcc/rust/typecheck/rust-hir-trait-resolve.cc @@ -561,17 +561,26 @@ AssociatedImplTrait::bind_impl_for_projection (TyTy::ProjectionType &proj, std::vector impl_substitutions; for (auto &generic_param : impl->get_generic_params ()) { - if (generic_param->get_kind () != HIR::GenericParam::GenericKind::TYPE) + if (generic_param->get_kind () != HIR::GenericParam::GenericKind::TYPE + && generic_param->get_kind () + != HIR::GenericParam::GenericKind::CONST) continue; TyTy::BaseType *l = nullptr; bool ok = context->lookup_type (generic_param->get_mappings ().get_hirid (), &l); - if (!ok || l->get_kind () != TyTy::TypeKind::PARAM) + if (!ok) continue; - impl_substitutions.emplace_back (static_cast ( - *generic_param), - static_cast (l)); + + TyTy::BaseGeneric *param = nullptr; + if (l->get_kind () == TyTy::TypeKind::PARAM) + param = static_cast (l); + else if (l->get_kind () == TyTy::TypeKind::CONST + && l->as_const_type ()->const_kind () + == TyTy::BaseConstType::ConstKind::Decl) + param = static_cast (l); + if (param != nullptr) + impl_substitutions.emplace_back (*generic_param, param); } // Build infer args for each impl param so we dont mutate the impls own @@ -583,7 +592,11 @@ AssociatedImplTrait::bind_impl_for_projection (TyTy::ProjectionType &proj, for (auto &p : impl_substitutions) { const std::string &symbol = p.get_param_ty ()->get_symbol (); - TyTy::TyVar infer_var = TyTy::TyVar::get_implicit_infer_var (locus); + TyTy::TyVar infer_var + = p.get_generic_param ().get_kind () + == HIR::GenericParam::GenericKind::CONST + ? TyTy::TyVar::get_implicit_const_infer_var (locus) + : TyTy::TyVar::get_implicit_infer_var (locus); TyTy::BaseType *resolved = infer_var.get_tyty (); infer_arg_vec.emplace_back (&p, resolved); param_mappings[symbol] = resolved->get_ref (); @@ -703,17 +716,26 @@ AssociatedImplTrait::bind_impl_for_bound (TyTy::BaseType *receiver, std::vector impl_substitutions; for (auto &generic_param : impl->get_generic_params ()) { - if (generic_param->get_kind () != HIR::GenericParam::GenericKind::TYPE) + if (generic_param->get_kind () != HIR::GenericParam::GenericKind::TYPE + && generic_param->get_kind () + != HIR::GenericParam::GenericKind::CONST) continue; TyTy::BaseType *l = nullptr; bool ok = context->lookup_type (generic_param->get_mappings ().get_hirid (), &l); - if (!ok || l->get_kind () != TyTy::TypeKind::PARAM) + if (!ok) continue; - impl_substitutions.emplace_back (static_cast ( - *generic_param), - static_cast (l)); + + TyTy::BaseGeneric *param = nullptr; + if (l->get_kind () == TyTy::TypeKind::PARAM) + param = static_cast (l); + else if (l->get_kind () == TyTy::TypeKind::CONST + && l->as_const_type ()->const_kind () + == TyTy::BaseConstType::ConstKind::Decl) + param = static_cast (l); + if (param != nullptr) + impl_substitutions.emplace_back (*generic_param, param); } std::vector infer_arg_vec; @@ -721,7 +743,11 @@ AssociatedImplTrait::bind_impl_for_bound (TyTy::BaseType *receiver, for (auto &p : impl_substitutions) { const std::string &symbol = p.get_param_ty ()->get_symbol (); - TyTy::TyVar infer_var = TyTy::TyVar::get_implicit_infer_var (locus); + TyTy::TyVar infer_var + = p.get_generic_param ().get_kind () + == HIR::GenericParam::GenericKind::CONST + ? TyTy::TyVar::get_implicit_const_infer_var (locus) + : TyTy::TyVar::get_implicit_infer_var (locus); TyTy::BaseType *resolved = infer_var.get_tyty (); infer_arg_vec.emplace_back (&p, resolved); param_mappings[symbol] = resolved->get_ref (); diff --git a/gcc/testsuite/rust/compile/issue-4812.rs b/gcc/testsuite/rust/compile/issue-4812.rs new file mode 100644 index 000000000000..8fdb5c09bbe1 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4812.rs @@ -0,0 +1,23 @@ +#![no_core] +#![feature(no_core)] +#![feature(lang_items)] +#![feature(min_const_generics)] + +#[lang = "sized"] +trait Sized {} + +trait Array { + type Element; +} + +impl Array for [T; N] { + type Element = T; +} + +fn require_byte_array>() {} + +fn main() { + require_byte_array::<[u8; 0]>(); + require_byte_array::<[u8; 32]>(); + require_byte_array::<[u8; 1024]>(); +} From 7bc7c6ef5e9c840e6e24a1e714dc48051d93f002 Mon Sep 17 00:00:00 2001 From: Lishin Date: Sun, 9 Aug 2026 17:54:54 +0000 Subject: [PATCH 055/584] gccrs: Handle conditional moves in BIR drop analysis Track whole-local initialization across BIR control-flow branches. When a local is moved on only some paths, mark its Drop as conditional. Keep the existing backend handling for straight-line CFGs and add tests for static, dead and conditional Drops. gcc/rust/ChangeLog: * checks/errors/borrowck/rust-bir-drop-analysis.cc (struct BlockInitializationState): New struct. (is_straight_line): New function. (set_initialized): Likewise. (set_uninitialized): Likewise. (merge_state): Likewise. (update_state_for_statement): Likewise. (classify_drop): Likewise. (compute_entry_states): Likewise. (record_drop_for_straight_line_backend): Likewise. (annotate_drop_statements): Likewise. (DropAnalysis::analyze): Propagate initialization state across the CFG and classify Drop statements. * checks/errors/borrowck/rust-bir-drop-analysis.h: Update class comment. gcc/testsuite/ChangeLog: * rust/borrowck/drop_analysis_conditional_move.rs: New test. Signed-off-by: Lishin --- .../errors/borrowck/rust-bir-drop-analysis.cc | 391 +++++++++++++----- .../errors/borrowck/rust-bir-drop-analysis.h | 2 +- .../drop_analysis_conditional_move.rs | 46 +++ 3 files changed, 340 insertions(+), 99 deletions(-) create mode 100644 gcc/testsuite/rust/borrowck/drop_analysis_conditional_move.rs diff --git a/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.cc b/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.cc index 09301d86eb62..2bdf5e5e4dd6 100644 --- a/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.cc +++ b/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.cc @@ -20,145 +20,340 @@ #include "rust-bir.h" #include "rust-hir-map.h" -#include - namespace Rust { namespace BIR { - namespace { -struct BasicBlockIdHash +struct BlockInitializationState { - size_t operator() (BasicBlockId id) const - { - return std::hash () (id.value); - } -}; + explicit BlockInitializationState (size_t place_count) + : maybe_initialized (place_count, false), + maybe_uninitialized (place_count, false), reachable (false) + {} -} // namespace + std::vector maybe_initialized; + std::vector maybe_uninitialized; -DropAnalysis & -DropAnalysis::get () + // Whether this block is reached or not. + bool reachable; +}; + +static bool +is_straight_line (const Function &function) { - static DropAnalysis instance; - return instance; + std::set visited; + BasicBlockId current = ENTRY_BASIC_BLOCK; + + while (current != INVALID_BB) + { + // Revisiting a block means that the CFG contains a cycle. + if (!visited.insert (current).second) + return false; + + const BasicBlock &block = function.basic_blocks[current]; + + if (block.successors.empty ()) + return true; + + if (block.successors.size () != 1) + return false; + + current = block.successors.front (); + } + + return true; } -void -DropAnalysis::clear () +static void +set_initialized (BlockInitializationState &state, PlaceId place) { - definitely_dead.clear (); + state.maybe_initialized[place.value] = true; + state.maybe_uninitialized[place.value] = false; } -bool -DropAnalysis::is_definitely_dead (HirId id) const +static void +set_uninitialized (BlockInitializationState &state, PlaceId place) { - return definitely_dead.find (id) != definitely_dead.end (); + state.maybe_initialized[place.value] = false; + state.maybe_uninitialized[place.value] = true; } -void -DropAnalysis::analyze (Function &function) +// This function combines states from incoming blocks. +// Take conditional move as example, +// +// BB0 +// initialize x +// / | +// v v +// BB1 BB2 +// move x no change +// \ / +// v v +// BB3 +// Drop(x) +// BB1 -> BB3 +// (BB1): maybe_initialized(x) = false +// (BB1): maybe_uninitialized(x) = true +// +// (BB3): maybe_initialized(x) = true || (BB1): maybe_initialized(x) -> true +// (BB3): maybe_uninitialized(x) = false || (BB1): maybe_uninitialized(x) -> +// true +static bool +merge_state (BlockInitializationState &into, + const BlockInitializationState &from) { - std::vector block_order; - std::unordered_set visited; + bool changed = false; - BasicBlockId current = ENTRY_BASIC_BLOCK; + if (!into.reachable) + { + into = from; + return !changed; + } - while (current != INVALID_BB) + for (size_t i = 0; i < into.maybe_initialized.size (); i++) { - // A repeated block indicates a cycle in straight-line control flow. - if (!visited.insert (current).second) - return; + bool maybe_initialized + = into.maybe_initialized[i] || from.maybe_initialized[i]; - block_order.push_back (current); + bool maybe_uninitialized + = into.maybe_uninitialized[i] || from.maybe_uninitialized[i]; - const BasicBlock &block = function.basic_blocks[current]; + changed |= maybe_initialized != into.maybe_initialized[i]; + changed |= maybe_uninitialized != into.maybe_uninitialized[i]; - if (block.successors.empty ()) - break; + into.maybe_initialized[i] = maybe_initialized; + into.maybe_uninitialized[i] = maybe_uninitialized; + } - if (block.successors.size () != 1) - return; + return changed; +} - current = block.successors.front (); +static void +update_state_for_statement (Function &function, Statement &statement, + BlockInitializationState &state) +{ + PlaceId place = statement.get_place (); + + switch (statement.get_kind ()) + { + case Statement::Kind::STORAGE_LIVE: + set_uninitialized (state, place); + break; + + case Statement::Kind::ASSIGNMENT: + { + PlaceId lhs = place; + AbstractExpr &expr = statement.get_expr (); + + if (expr.get_kind () == ExprKind::ASSIGNMENT) + { + PlaceId rhs = static_cast (expr).get_rhs (); + const Place &rhs_place = function.place_db[rhs]; + + if (rhs_place.kind == Place::VARIABLE + && rhs_place.should_be_moved ()) + set_uninitialized (state, rhs); + } + + set_initialized (state, lhs); + break; + } + + case Statement::Kind::DROP: + case Statement::Kind::STORAGE_DEAD: + set_uninitialized (state, place); + break; + + case Statement::Kind::SWITCH: + case Statement::Kind::RETURN: + case Statement::Kind::GOTO: + case Statement::Kind::USER_TYPE_ASCRIPTION: + case Statement::Kind::FAKE_READ: + break; } +} + +static Statement::DropStyle +classify_drop (const BlockInitializationState &state, PlaceId place) +{ + bool maybe_initialized = state.maybe_initialized[place.value]; + bool maybe_uninitialized = state.maybe_uninitialized[place.value]; + + if (!maybe_initialized) + return Statement::DropStyle::DEAD; + + if (!maybe_uninitialized) + return Statement::DropStyle::STATIC; + + return Statement::DropStyle::CONDITIONAL; +} + +// Compute the initialization state at the entry of every reachable block. +static std::vector +compute_entry_states (Function &function) +{ + size_t place_count = function.place_db.size (); + size_t block_count = function.basic_blocks.size (); + + std::vector entry_states; + entry_states.reserve (block_count); + + for (size_t i = 0; i < block_count; i++) + entry_states.emplace_back (place_count); + + BlockInitializationState &entry_state = entry_states[ENTRY_BASIC_BLOCK.value]; - std::vector initialized (function.place_db.size (), false); + entry_state.reachable = true; + + // All places start uninitialized, except function arguments. + for (size_t i = 0; i < place_count; i++) + entry_state.maybe_uninitialized[i] = true; for (PlaceId argument : function.arguments) - initialized[argument.value] = true; + set_initialized (entry_state, argument); + + std::vector worklist; + std::vector queued (block_count, false); - for (BasicBlockId block_id : block_order) + worklist.push_back (ENTRY_BASIC_BLOCK); + queued[ENTRY_BASIC_BLOCK.value] = true; + + // Propagate block states until the last block. + while (!worklist.empty ()) { + BasicBlockId block_id = worklist.back (); + worklist.pop_back (); + queued[block_id.value] = false; + + BlockInitializationState state = entry_states[block_id.value]; BasicBlock &block = function.basic_blocks[block_id]; for (Statement &statement : block.statements) + update_state_for_statement (function, statement, state); + + for (BasicBlockId successor : block.successors) { - PlaceId place = statement.get_place (); + bool state_changed + = merge_state (entry_states[successor.value], state); + + if (state_changed && !queued[successor.value]) + { + worklist.push_back (successor); + queued[successor.value] = true; + } + } + } + return entry_states; +} + +static void +record_drop_for_straight_line_backend (const Function &function, PlaceId place, + Statement::DropStyle drop_style, + std::set &dead_drop_hir_ids, + std::set &non_dead_drop_hir_ids) +{ + const Place &dropped_place = function.place_db[place]; + + if (dropped_place.kind != Place::VARIABLE) + return; + + auto hir_id = Analysis::Mappings::get ().lookup_node_to_hir ( + static_cast (dropped_place.variable_or_field_index)); - switch (statement.get_kind ()) + if (!hir_id.has_value ()) + return; + + if (drop_style == Statement::DropStyle::DEAD) + dead_drop_hir_ids.insert (hir_id.value ()); + else + non_dead_drop_hir_ids.insert (hir_id.value ()); +} + +// Walk each reachable block forward from its stable entry state and classify +// its Drop statements. +static void +annotate_drop_statements ( + Function &function, const std::vector &entry_states, + bool record_straight_line_backend_drops, std::set &dead_drop_hir_ids, + std::set &non_dead_drop_hir_ids) +{ + const size_t block_count = function.basic_blocks.size (); + + for (size_t i = 0; i < block_count; i++) + { + BlockInitializationState state = entry_states[i]; + + if (!state.reachable) + continue; + + BasicBlockId block_id = {static_cast (i)}; + BasicBlock &block = function.basic_blocks[block_id]; + + for (Statement &statement : block.statements) + { + // A Drop is classified using the state before it executes. + if (statement.get_kind () == Statement::Kind::DROP) { - case Statement::Kind::STORAGE_LIVE: - initialized[place.value] = false; - break; - - case Statement::Kind::ASSIGNMENT: - { - PlaceId lhs = place; - AbstractExpr &expr = statement.get_expr (); - - if (expr.get_kind () == ExprKind::ASSIGNMENT) - { - PlaceId rhs = static_cast (expr).get_rhs (); - const Place &rhs_place = function.place_db[rhs]; - - if (rhs_place.kind == Place::VARIABLE - && rhs_place.should_be_moved ()) - initialized[rhs.value] = false; - } - - initialized[lhs.value] = true; - break; - } - - case Statement::Kind::DROP: - statement.set_drop_style (initialized[place.value] - ? Statement::DropStyle::STATIC - : Statement::DropStyle::DEAD); - - if (statement.get_drop_style () == Statement::DropStyle::DEAD) - { - const Place &dropped_place = function.place_db[place]; - - if (dropped_place.kind == Place::VARIABLE) - { - auto hir_id - = Analysis::Mappings::get ().lookup_node_to_hir ( - static_cast ( - dropped_place.variable_or_field_index)); - - if (hir_id.has_value ()) - definitely_dead.insert (hir_id.value ()); - } - } - - initialized[place.value] = false; - break; - - case Statement::Kind::STORAGE_DEAD: - initialized[place.value] = false; - break; - - case Statement::Kind::SWITCH: - case Statement::Kind::RETURN: - case Statement::Kind::GOTO: - case Statement::Kind::USER_TYPE_ASCRIPTION: - case Statement::Kind::FAKE_READ: - break; + PlaceId place = statement.get_place (); + Statement::DropStyle drop_style = classify_drop (state, place); + + statement.set_drop_style (drop_style); + + if (record_straight_line_backend_drops) + record_drop_for_straight_line_backend (function, place, + drop_style, + dead_drop_hir_ids, + non_dead_drop_hir_ids); } + + // Update the state for the following statement. + update_state_for_statement (function, statement, state); } } } +} // namespace + +DropAnalysis & +DropAnalysis::get () +{ + static DropAnalysis instance; + return instance; +} + +void +DropAnalysis::clear () +{ + definitely_dead.clear (); +} + +bool +DropAnalysis::is_definitely_dead (HirId id) const +{ + return definitely_dead.find (id) != definitely_dead.end (); +} + +void +DropAnalysis::analyze (Function &function) +{ + std::vector entry_states + = compute_entry_states (function); + + // Keep the existing backend handling for straight-line CFGs. + const bool record_straight_line_backend_drops = is_straight_line (function); + + std::set dead_drop_hir_ids; + std::set non_dead_drop_hir_ids; + + annotate_drop_statements (function, entry_states, + record_straight_line_backend_drops, + dead_drop_hir_ids, non_dead_drop_hir_ids); + + // A local is definitely dead only when all of its Drops are dead. + for (HirId hir_id : dead_drop_hir_ids) + if (non_dead_drop_hir_ids.find (hir_id) == non_dead_drop_hir_ids.end ()) + definitely_dead.insert (hir_id); +} + } // namespace BIR } // namespace Rust diff --git a/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.h b/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.h index 2a52c13550e6..17a175e08d6f 100644 --- a/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.h +++ b/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.h @@ -28,7 +28,7 @@ namespace BIR { Classifies scheduled whole-local BIR Drop statements according to whether their place is initialized at the drop point. - This initial implementation only handles straight-line control flow. + This analysis tracks initialization state across the BIR control-flow graph. */ class DropAnalysis { diff --git a/gcc/testsuite/rust/borrowck/drop_analysis_conditional_move.rs b/gcc/testsuite/rust/borrowck/drop_analysis_conditional_move.rs new file mode 100644 index 000000000000..0f58de44c1bb --- /dev/null +++ b/gcc/testsuite/rust/borrowck/drop_analysis_conditional_move.rs @@ -0,0 +1,46 @@ +// { dg-additional-options "-frust-compile-until=compilation -frust-borrowcheck -frust-dump-bir" } +// { dg-final { scan-file bir_dump/drop_analysis_conditional_move.conditional_move.bir.dump "Drop\\(_3\\): Conditional" } } +// { dg-final { scan-file bir_dump/drop_analysis_conditional_move.static_after_join.bir.dump "Drop\\(_3\\): Static" } } +// { dg-final { scan-file bir_dump/drop_analysis_conditional_move.dead_after_join.bir.dump "Drop\\(_3\\): Dead" } } + +#![feature(no_core)] +#![no_core] + +fn conditional_move(condition: bool) { + struct A { + i: i32, + } + + let x = A { i: 1 }; + + if condition { + let y = x; + } +} + + +fn static_after_join(condition: bool) { + struct A { + i: i32, + } + + let x = A { i: 1 }; + + if condition { + let y = 1; + } +} + +fn dead_after_join(condition: bool) { + struct A { + i: i32, + } + + let x = A { i: 1 }; + + if condition { + let y = x; + } else { + let z = x; + } +} \ No newline at end of file From 625c60a9a032274cd1bc0dd8f01e094f1c454f04 Mon Sep 17 00:00:00 2001 From: Yap Zhi Heng Date: Sat, 8 Aug 2026 22:58:45 +0800 Subject: [PATCH 056/584] gccrs: Compile `let ` gcc/rust/ChangeLog: * backend/rust-compile-var-decl.h (CompileVarDecl::visit (StructPattern)): Compile variable declarations for use within CompilePatternLet::visit(StructPattern). * backend/rust-compile-pattern.h (CompilePatternLet::visit (StructPattern)): Remove rust_sorry_at. * backend/rust-compile-pattern.cc (CompilePatternLet::visit (StructPattern)): Compile bindings for struct fields. Signed-off-by: Yap Zhi Heng --- gcc/rust/backend/rust-compile-pattern.cc | 167 ++++++++++++++++++ gcc/rust/backend/rust-compile-pattern.h | 7 +- gcc/rust/backend/rust-compile-var-decl.h | 117 +++++++++++- .../rust/compile/let-structpattern.rs | 19 ++ .../rust/execute/torture/let-structpattern.rs | 19 ++ 5 files changed, 322 insertions(+), 7 deletions(-) create mode 100644 gcc/testsuite/rust/compile/let-structpattern.rs create mode 100644 gcc/testsuite/rust/execute/torture/let-structpattern.rs diff --git a/gcc/rust/backend/rust-compile-pattern.cc b/gcc/rust/backend/rust-compile-pattern.cc index 19f5bc4ed887..9d722358bb2c 100644 --- a/gcc/rust/backend/rust-compile-pattern.cc +++ b/gcc/rust/backend/rust-compile-pattern.cc @@ -1522,5 +1522,172 @@ CompilePatternLet::visit (HIR::TuplePattern &pattern) } } +void +CompilePatternLet::visit (HIR::StructPattern &pattern) +{ + // lookup the type + TyTy::BaseType *lookup = nullptr; + bool ok = ctx->get_tyctx ()->lookup_type ( + pattern.get_path ().get_mappings ().get_hirid (), &lookup); + rust_assert (ok); + + rust_assert (lookup->get_kind () == TyTy::TypeKind::ADT); + TyTy::ADTType *adt = static_cast (lookup); + + // only structs and single-variant enums are irrefutable, this check should + // already be handled by type check + rust_assert (adt->number_of_variants () == 1); + + int variant_index = 0; + TyTy::VariantDef *variant = nullptr; + if (adt->is_enum ()) + { + // lookup the variant + HirId variant_id = UNKNOWN_HIRID; + bool ok = ctx->get_tyctx ()->lookup_variant_definition ( + pattern.get_path ().get_mappings ().get_hirid (), &variant_id); + rust_assert (ok); + + ok = adt->lookup_variant_by_id (variant_id, &variant, &variant_index); + rust_assert (ok); + } + else + { + variant = adt->get_variants ().at (0); + } + + bool has_by_ref = false; + auto &struct_pattern_elems = pattern.get_struct_pattern_elems (); + for (auto &field : struct_pattern_elems.get_struct_pattern_fields ()) + { + if (field->get_item_type () == HIR::StructPatternField::ItemType::IDENT) + { + HIR::StructPatternFieldIdent &ident + = static_cast (*field); + if (ident.get_has_ref ()) + has_by_ref = true; + } + } + + tree rhs_type = TYPE_MAIN_VARIANT (TREE_TYPE (init_expr)); + tree init_stmt; + Bvariable *tmp_var + = Backend::temporary_variable (ctx->peek_fn ().fndecl, NULL_TREE, rhs_type, + init_expr, has_by_ref, pattern.get_locus (), + &init_stmt); + ctx->add_statement (init_stmt); + tree access_expr = Backend::var_expression (tmp_var, pattern.get_locus ()); + + auto make_ident_field_access = [&] (const Identifier &ident, location_t loc) { + size_t offs = 0; + bool ok = variant->lookup_field (ident.as_string (), nullptr, &offs); + rust_assert (ok); + + if (adt->is_enum ()) + { + tree payload_accessor_union + = Backend::struct_field_expression (access_expr, 1, loc); + tree variant_accessor + = Backend::struct_field_expression (payload_accessor_union, + variant_index, loc); + return Backend::struct_field_expression (variant_accessor, offs, loc); + } + else + { + return Backend::struct_field_expression (access_expr, offs, loc); + } + }; + + for (auto &field : struct_pattern_elems.get_struct_pattern_fields ()) + { + switch (field->get_item_type ()) + { + case HIR::StructPatternField::ItemType::TUPLE_PAT: + { + HIR::StructPatternFieldTuplePat &tuple_pat + = static_cast (*field); + + size_t tuple_pat_index = tuple_pat.get_index (); + tree field_expr = NULL_TREE; + if (adt->is_enum ()) + { + tree payload_accessor_union + = Backend::struct_field_expression (access_expr, 1, + tuple_pat.get_locus ()); + tree variant_accessor + = Backend::struct_field_expression (payload_accessor_union, + variant_index, + tuple_pat.get_locus ()); + field_expr + = Backend::struct_field_expression (variant_accessor, + tuple_pat_index, + tuple_pat.get_locus ()); + } + else + { + field_expr + = Backend::struct_field_expression (access_expr, + tuple_pat_index, + tuple_pat.get_locus ()); + } + + TyTy::BaseType *ty_sub = nullptr; + HirId sub_id + = tuple_pat.get_tuple_pattern ().get_mappings ().get_hirid (); + bool ok = ctx->get_tyctx ()->lookup_type (sub_id, &ty_sub); + rust_assert (ok); + + CompilePatternLet::Compile (&tuple_pat.get_tuple_pattern (), + field_expr, ty_sub, rval_locus, ctx); + } + break; + case HIR::StructPatternField::ItemType::IDENT_PAT: + { + HIR::StructPatternFieldIdentPat &ident_pat + = static_cast (*field); + + tree field_expr + = make_ident_field_access (ident_pat.get_identifier (), + ident_pat.get_locus ()); + + TyTy::BaseType *ty_sub = nullptr; + HirId sub_id + = ident_pat.get_pattern ().get_mappings ().get_hirid (); + bool ok = ctx->get_tyctx ()->lookup_type (sub_id, &ty_sub); + rust_assert (ok); + + CompilePatternLet::Compile (&ident_pat.get_pattern (), field_expr, + ty_sub, rval_locus, ctx); + } + break; + + case HIR::StructPatternField::ItemType::IDENT: + { + HIR::StructPatternFieldIdent &ident + = static_cast (*field); + + tree field_expr = make_ident_field_access (ident.get_identifier (), + ident.get_locus ()); + + Bvariable *var = nullptr; + ok + = ctx->lookup_var_decl (ident.get_mappings ().get_hirid (), &var); + rust_assert (ok); + + if (ident.get_has_ref ()) + { + field_expr + = address_expression (field_expr, EXPR_LOCATION (field_expr)); + } + + auto fnctx = ctx->peek_fn (); + auto s = Backend::init_statement (fnctx.fndecl, var, field_expr); + ctx->add_statement (s); + } + break; + } + } +} + } // namespace Compile } // namespace Rust diff --git a/gcc/rust/backend/rust-compile-pattern.h b/gcc/rust/backend/rust-compile-pattern.h index 35e152fe3b18..9fa89897093e 100644 --- a/gcc/rust/backend/rust-compile-pattern.h +++ b/gcc/rust/backend/rust-compile-pattern.h @@ -129,6 +129,7 @@ class CompilePatternLet : public HIRCompileBase, public HIR::HIRPatternVisitor void visit (HIR::IdentifierPattern &) override; void visit (HIR::WildcardPattern &) override; void visit (HIR::TuplePattern &) override; + void visit (HIR::StructPattern &) override; // check for unimplemented Pattern HIR nodes. void visit (HIR::AltPattern &pattern) override @@ -174,12 +175,6 @@ class CompilePatternLet : public HIRCompileBase, public HIR::HIRPatternVisitor "slice pattern let statements not supported"); } - void visit (HIR::StructPattern &pattern) override - { - rust_sorry_at (pattern.get_locus (), - "struct pattern let statements not supported"); - } - void visit (HIR::TupleStructPattern &pattern) override { rust_sorry_at (pattern.get_locus (), diff --git a/gcc/rust/backend/rust-compile-var-decl.h b/gcc/rust/backend/rust-compile-var-decl.h index 92108aea0ad9..c7a358aa181b 100644 --- a/gcc/rust/backend/rust-compile-var-decl.h +++ b/gcc/rust/backend/rust-compile-var-decl.h @@ -20,6 +20,7 @@ #define RUST_COMPILE_VAR_DECL #include "rust-compile-base.h" +#include "rust-compile-type.h" #include "rust-hir-visitor.h" namespace Rust { @@ -146,6 +147,121 @@ class CompileVarDecl : public HIRCompileBase, public HIR::HIRPatternVisitor } } + void visit (HIR::StructPattern &pattern) override + { + // lookup the type + TyTy::BaseType *lookup = nullptr; + bool ok = ctx->get_tyctx ()->lookup_type ( + pattern.get_path ().get_mappings ().get_hirid (), &lookup); + rust_assert (ok); + + rust_assert (lookup->get_kind () == TyTy::TypeKind::ADT); + TyTy::ADTType *adt = static_cast (lookup); + + // only structs and single-variant enums are irrefutable, this check should + // already be handled by type check + rust_assert (adt->number_of_variants () == 1); + + int variant_index = 0; + TyTy::VariantDef *variant = nullptr; + if (adt->is_enum ()) + { + // lookup the variant + HirId variant_id = UNKNOWN_HIRID; + bool ok = ctx->get_tyctx ()->lookup_variant_definition ( + pattern.get_path ().get_mappings ().get_hirid (), &variant_id); + rust_assert (ok); + + ok = adt->lookup_variant_by_id (variant_id, &variant, &variant_index); + rust_assert (ok); + } + else + { + variant = adt->get_variants ().at (0); + } + + auto &struct_pattern_elems = pattern.get_struct_pattern_elems (); + for (auto &field : struct_pattern_elems.get_struct_pattern_fields ()) + { + switch (field->get_item_type ()) + { + case HIR::StructPatternField::ItemType::TUPLE_PAT: + { + HIR::StructPatternFieldTuplePat &tuple_pat + = static_cast (*field); + TyTy::StructFieldType *field_ty = nullptr; + ok = variant->lookup_field (std::to_string ( + tuple_pat.get_index ()), + &field_ty, nullptr); + rust_assert (ok); + tree sub_ty + = TyTyResolveCompile::compile (ctx, + field_ty->get_field_type ()); + auto sub_vars + = CompileVarDecl::compile (fndecl, sub_ty, + &tuple_pat.get_tuple_pattern (), + ctx); + vars.insert (vars.end (), sub_vars.begin (), sub_vars.end ()); + } + break; + case HIR::StructPatternField::ItemType::IDENT_PAT: + { + HIR::StructPatternFieldIdentPat &ident_pat + = static_cast (*field); + TyTy::StructFieldType *field_ty = nullptr; + ok = variant->lookup_field ( + ident_pat.get_identifier ().as_string (), &field_ty, nullptr); + rust_assert (ok); + tree sub_ty + = TyTyResolveCompile::compile (ctx, + field_ty->get_field_type ()); + auto sub_vars + = CompileVarDecl::compile (fndecl, sub_ty, + &ident_pat.get_pattern (), ctx); + vars.insert (vars.end (), sub_vars.begin (), sub_vars.end ()); + } + break; + case HIR::StructPatternField::ItemType::IDENT: + { + HIR::StructPatternFieldIdent &ident + = static_cast (*field); + TyTy::StructFieldType *field_ty = nullptr; + ok = variant->lookup_field (ident.get_identifier ().as_string (), + &field_ty, nullptr); + rust_assert (ok); + tree sub_ty + = TyTyResolveCompile::compile (ctx, + field_ty->get_field_type ()); + + // code below is pretty much copied from + // visit(IdentifierPattern) above + if (!ident.is_mut ()) + sub_ty = Backend::immutable_type (sub_ty); + + tree bind_tree = ctx->peek_enclosing_scope (); + std::string identifier = ident.get_identifier ().as_string (); + tree decl = build_decl (ident.get_locus (), VAR_DECL, + Backend::get_identifier_node (identifier), + sub_ty); + DECL_CONTEXT (decl) = fndecl; + gcc_assert (TREE_CODE (bind_tree) == BIND_EXPR); + tree block_tree = BIND_EXPR_BLOCK (bind_tree); + gcc_assert (TREE_CODE (block_tree) == BLOCK); + DECL_CHAIN (decl) = BLOCK_VARS (block_tree); + BLOCK_VARS (block_tree) = decl; + BIND_EXPR_VARS (bind_tree) = BLOCK_VARS (block_tree); + rust_preserve_from_gc (decl); + Bvariable *var = new Bvariable (decl); + + HirId stmt_id = ident.get_mappings ().get_hirid (); + ctx->insert_var_decl (stmt_id, var); + vars.push_back (var); + } + break; + } + } + } + // Empty visit for unused Pattern HIR nodes. void visit (HIR::AltPattern &) override {} void visit (HIR::LiteralPattern &) override {} @@ -154,7 +270,6 @@ class CompileVarDecl : public HIRCompileBase, public HIR::HIRPatternVisitor void visit (HIR::RangePattern &) override {} void visit (HIR::ReferencePattern &) override {} void visit (HIR::SlicePattern &) override {} - void visit (HIR::StructPattern &) override {} void visit (HIR::TupleStructPattern &) override {} void visit (HIR::WildcardPattern &) override {} diff --git a/gcc/testsuite/rust/compile/let-structpattern.rs b/gcc/testsuite/rust/compile/let-structpattern.rs new file mode 100644 index 000000000000..07cf55009aef --- /dev/null +++ b/gcc/testsuite/rust/compile/let-structpattern.rs @@ -0,0 +1,19 @@ +#![feature(no_core)] +#![no_core] + +// TODO the warnings below shouldn't be emitted...? +struct Foo { + x: i32, // { dg-bogus "field is never read: .x." TODO { xfail *-*-* } } + y: i32 // { dg-bogus "field is never read: .y." TODO { xfail *-*-* } } +} + +struct Bar (i32, i32); + +fn main() { + let mut my_foo = Foo{x: 32, y: 64}; + let Foo {x, y: _renamed_y} = my_foo; // { dg-warning "unused name .x." } + let Foo {x: _another_x, ..} = my_foo; + let Foo {y: _yet_another_y, ..} = my_foo; + let my_bar = Bar(32, 64); + let Bar{1: _w, ..} = my_bar; +} diff --git a/gcc/testsuite/rust/execute/torture/let-structpattern.rs b/gcc/testsuite/rust/execute/torture/let-structpattern.rs new file mode 100644 index 000000000000..2352e9fb560c --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/let-structpattern.rs @@ -0,0 +1,19 @@ +#![feature(no_core)] +#![no_core] + +struct Foo { + x: i32 +} + +struct Bar (i32, i32); + +fn main() -> i32 { + let mut my_foo = Foo{x: 32}; + let mut my_bar = Bar(32, 64); + let Foo {x} = my_foo; + let Foo {x: _x @ test} = my_foo; + my_foo.x = 16; + let Foo {x: yet_another_x } = my_foo; + let Bar {0: w, ..} = my_bar; + (x - test) | (x - w) | (yet_another_x - 16) +} From ccb10aee3377495616b04aa6b004291f05f2ddf2 Mon Sep 17 00:00:00 2001 From: Arthur Cohen Date: Sat, 29 Aug 2026 06:42:12 +0200 Subject: [PATCH 057/584] gccrs: tyty: Fix FN_VARIADIC flag typo gcc/rust/ChangeLog: * typecheck/rust-tyty.h: Rename FN_VARADIC_FLAG -> FN_VARIADIC_FLAG. * typecheck/rust-hir-type-check-implitem.cc (TypeCheckTopLevelExternItem::visit): Use the new name. --- gcc/rust/typecheck/rust-hir-type-check-implitem.cc | 2 +- gcc/rust/typecheck/rust-tyty.h | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/gcc/rust/typecheck/rust-hir-type-check-implitem.cc b/gcc/rust/typecheck/rust-hir-type-check-implitem.cc index 9ac226d26698..a29793c832f9 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-implitem.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-implitem.cc @@ -134,7 +134,7 @@ TypeCheckTopLevelExternItem::visit (HIR::ExternalFunctionItem &function) uint8_t flags = TyTy::FnType::FNTYPE_IS_EXTERN_FLAG; if (function.is_variadic ()) { - flags |= TyTy::FnType::FNTYPE_IS_VARADIC_FLAG; + flags |= TyTy::FnType::FNTYPE_IS_VARIADIC_FLAG; if (parent.get_abi () != Rust::ABI::C) { rust_error_at ( diff --git a/gcc/rust/typecheck/rust-tyty.h b/gcc/rust/typecheck/rust-tyty.h index 3d910212ab76..45888e48fd38 100644 --- a/gcc/rust/typecheck/rust-tyty.h +++ b/gcc/rust/typecheck/rust-tyty.h @@ -1099,7 +1099,7 @@ class FnType : public CallableTypeInterface, public SubstitutionRef static const uint8_t FNTYPE_DEFAULT_FLAGS = 0x00; static const uint8_t FNTYPE_IS_METHOD_FLAG = 0x01; static const uint8_t FNTYPE_IS_EXTERN_FLAG = 0x02; - static const uint8_t FNTYPE_IS_VARADIC_FLAG = 0X04; + static const uint8_t FNTYPE_IS_VARIADIC_FLAG = 0X04; static const uint8_t FNTYPE_IS_SYN_CONST_FLAG = 0X08; FnType (HirId ref, DefId id, std::string identifier, RustIdent ident, @@ -1160,7 +1160,7 @@ class FnType : public CallableTypeInterface, public SubstitutionRef bool is_extern () const { return (flags & FNTYPE_IS_EXTERN_FLAG) != 0; } - bool is_variadic () const { return (flags & FNTYPE_IS_VARADIC_FLAG) != 0; } + bool is_variadic () const { return (flags & FNTYPE_IS_VARIADIC_FLAG) != 0; } bool is_syn_constant () const { From dd4f1071fae28e66f6eb342d77a7842ba835bd56 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Sun, 23 Aug 2026 18:10:34 +0100 Subject: [PATCH 058/584] gccrs: Fix ICE when its an optional return type Fixes Rust-GCC/gccrs#4814 gcc/rust/ChangeLog: * hir/rust-hir-dump.cc (Dump::do_typepathfunction): add guard Signed-off-by: Philip Herron --- gcc/rust/hir/rust-hir-dump.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/gcc/rust/hir/rust-hir-dump.cc b/gcc/rust/hir/rust-hir-dump.cc index f21522b4d486..e1c2cfa8e433 100644 --- a/gcc/rust/hir/rust-hir-dump.cc +++ b/gcc/rust/hir/rust-hir-dump.cc @@ -406,7 +406,8 @@ void Dump::do_typepathfunction (TypePathFunction &e) { visit_collection ("params", e.get_params ()); - visit_field ("return_type", e.get_return_type ()); + if (e.has_return_type ()) + visit_field ("return_type", e.get_return_type ()); } void From 6e2b28a550307e7cfb4b4d9a60cdb4e760c9fdff Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Sun, 23 Aug 2026 20:01:00 +0100 Subject: [PATCH 059/584] gccrs: Add indexing ImplTrait Blocks to Trait map for improved filtering This is just a general improvement so we can filter trait probing to not look at the whole crate. gcc/rust/ChangeLog: * hir/rust-ast-lower-item.cc (ASTLoweringItem::visit): add mapping * rust-session-manager.cc (Session::compile_crate): make sure nr context is ready * typecheck/rust-hir-path-probe.cc (PathProbeImplTrait::process_trait_impl_items_for_candidates): use the new filter * util/rust-hir-map.cc (Mappings::insert_trait_impl_mapping): new helper * util/rust-hir-map.h: likewise Signed-off-by: Philip Herron --- gcc/rust/hir/rust-ast-lower-item.cc | 8 ++++++++ gcc/rust/rust-session-manager.cc | 7 ++++--- gcc/rust/typecheck/rust-hir-path-probe.cc | 13 +++--------- gcc/rust/util/rust-hir-map.cc | 25 +++++++++++++++++++++++ gcc/rust/util/rust-hir-map.h | 7 +++++++ 5 files changed, 47 insertions(+), 13 deletions(-) diff --git a/gcc/rust/hir/rust-ast-lower-item.cc b/gcc/rust/hir/rust-ast-lower-item.cc index 84ed9c90d3ca..19adb04a5ba6 100644 --- a/gcc/rust/hir/rust-ast-lower-item.cc +++ b/gcc/rust/hir/rust-ast-lower-item.cc @@ -27,6 +27,7 @@ #include "rust-ast-lower-pattern.h" #include "rust-ast-lower-block.h" #include "rust-item.h" +#include "rust-finalized-name-resolution-context.h" namespace Rust { namespace HIR { @@ -765,6 +766,13 @@ ASTLoweringItem::visit (AST::TraitImpl &impl_block) translated = hir_impl_block; mappings.insert_hir_impl_block (hir_impl_block); + + auto &nr_ctx = Resolver2_0::FinalizedNameResolutionContext::get (); + auto trait_node_id = nr_ctx.lookup (trait_ref->get_mappings ().get_nodeid (), + Resolver2_0::Namespace::Types); + rust_assert (trait_node_id.has_value ()); + mappings.insert_trait_impl_mapping (trait_node_id.value (), hir_impl_block); + for (auto &impl_item_id : impl_item_ids) { mappings.insert_impl_item_mapping (impl_item_id, hir_impl_block); diff --git a/gcc/rust/rust-session-manager.cc b/gcc/rust/rust-session-manager.cc index f6fabb3bff58..29b12bb13b84 100644 --- a/gcc/rust/rust-session-manager.cc +++ b/gcc/rust/rust-session-manager.cc @@ -780,6 +780,10 @@ Session::compile_crate (const char *filename) if (last_step == CompileOptions::CompileStep::Lowering) return; + // Name resolution is complete. Freeze its context before lowering so HIR + // construction can register information keyed by resolved definitions. + Resolver2_0::FinalizedNameResolutionContext::init (name_resolution_ctx); + // lower AST to HIR std::unique_ptr lowered = HIR::ASTLowering::Resolve (parsed_crate); @@ -800,9 +804,6 @@ Session::compile_crate (const char *filename) if (last_step == CompileOptions::CompileStep::TypeCheck) return; - // name resolution is done, we now freeze the name resolver for type checking - Resolver2_0::FinalizedNameResolutionContext::init (name_resolution_ctx); - // type resolve Compile::Context *ctx = Compile::Context::get (); Resolver::TypeResolution::Resolve (hir); diff --git a/gcc/rust/typecheck/rust-hir-path-probe.cc b/gcc/rust/typecheck/rust-hir-path-probe.cc index 4c37762b6925..d8ff6ff62c2c 100644 --- a/gcc/rust/typecheck/rust-hir-path-probe.cc +++ b/gcc/rust/typecheck/rust-hir-path-probe.cc @@ -464,17 +464,10 @@ PathProbeImplTrait::Probe (TyTy::BaseType *receiver, void PathProbeImplTrait::process_trait_impl_items_for_candidates () { - mappings.iterate_impl_items ( + NodeId trait_node_id = trait_reference->get_mappings ().get_nodeid (); + mappings.iterate_trait_impl_items ( + trait_node_id, [&] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) mutable -> bool { - // just need to check if this is an impl block for this trait the next - // function checks the receiver - if (!impl->has_trait_ref ()) - return true; - - TraitReference *resolved = TraitResolver::Lookup (impl->get_trait_ref ()); - if (!trait_reference->is_equal (*resolved)) - return true; - process_impl_item_candidate (id, item, impl); return true; }); diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index 58427b98631d..d7d0cc87c2a1 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -829,6 +829,31 @@ Mappings::iterate_impl_items ( } } +void +Mappings::insert_trait_impl_mapping (NodeId trait_node_id, HIR::ImplBlock *impl) +{ + hirTraitImplMappings[trait_node_id].push_back (impl); +} + +void +Mappings::iterate_trait_impl_items ( + NodeId trait_node_id, + std::function cb) +{ + auto trait_impls = hirTraitImplMappings.find (trait_node_id); + if (trait_impls == hirTraitImplMappings.end ()) + return; + + for (auto *impl : trait_impls->second) + for (auto &item : impl->get_impl_items ()) + { + HIR::ImplItem *impl_item = item.get (); + HirId id = impl_item->get_impl_mappings ().get_hirid (); + if (!cb (id, impl_item, impl)) + return; + } +} + void Mappings::iterate_impl_blocks (std::function cb) { diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index dfbec3c88a70..2f7431a00c88 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -208,6 +208,12 @@ class Mappings void iterate_impl_items ( std::function cb); + void insert_trait_impl_mapping (NodeId trait_node_id, HIR::ImplBlock *impl); + + void iterate_trait_impl_items ( + NodeId trait_node_id, + std::function cb); + void iterate_impl_blocks (std::function cb); void iterate_trait_items ( @@ -396,6 +402,7 @@ class Mappings std::map hirImplItemsToImplMappings; std::map hirImplBlockMappings; std::map hirImplBlockTypeMappings; + std::map> hirTraitImplMappings; std::map hirTraitItemMappings; std::map hirExternBlockMappings; std::map> hirExternItemMappings; From dc6454fa5506e7315e6d863857291ad74ae50103 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Sun, 23 Aug 2026 20:18:02 +0100 Subject: [PATCH 060/584] gccrs: Add method resolution probe support to take a trait to filter This means we can do some pre filtering instead of scanning the crate. gcc/rust/ChangeLog: * typecheck/rust-hir-dot-operator.cc (MethodResolver::MethodResolver): new optional filter (MethodResolver::Probe): likewise (MethodResolver::try_select_predicate_candidates): likewise (MethodResolver::select): likewise * typecheck/rust-hir-dot-operator.h: likewise * typecheck/rust-hir-type-check-expr.cc: pass lang item trait * util/rust-hir-map.cc: new helper to scan implblocks * util/rust-hir-map.h: likewise Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-dot-operator.cc | 34 ++++++++++++++----- gcc/rust/typecheck/rust-hir-dot-operator.h | 7 ++-- .../typecheck/rust-hir-type-check-expr.cc | 2 +- gcc/rust/util/rust-hir-map.cc | 13 +++++++ gcc/rust/util/rust-hir-map.h | 4 +++ 5 files changed, 48 insertions(+), 12 deletions(-) diff --git a/gcc/rust/typecheck/rust-hir-dot-operator.cc b/gcc/rust/typecheck/rust-hir-dot-operator.cc index d1095d553630..f74005e1ed83 100644 --- a/gcc/rust/typecheck/rust-hir-dot-operator.cc +++ b/gcc/rust/typecheck/rust-hir-dot-operator.cc @@ -27,16 +27,18 @@ namespace Rust { namespace Resolver { MethodResolver::MethodResolver (bool autoderef_flag, - const HIR::PathIdentSegment &segment_name) - : AutoderefCycle (autoderef_flag), segment_name (segment_name), result () + const HIR::PathIdentSegment &segment_name, + const HIR::Trait *specified_trait) + : AutoderefCycle (autoderef_flag), segment_name (segment_name), + specified_trait (specified_trait), result () {} std::set MethodResolver::Probe (TyTy::BaseType *receiver, const HIR::PathIdentSegment &segment_name, - bool autoderef_flag) + bool autoderef_flag, const HIR::Trait *specified_trait) { - MethodResolver resolver (autoderef_flag, segment_name); + MethodResolver resolver (autoderef_flag, segment_name, specified_trait); resolver.cycle (receiver); return resolver.result; } @@ -203,8 +205,7 @@ MethodResolver::assemble_trait_impl_candidates ( bool receiver_is_raw_ptr = raw->get_kind () == TyTy::TypeKind::POINTER; bool receiver_is_ref = raw->get_kind () == TyTy::TypeKind::REF; - mappings.iterate_impl_blocks ([&] (HirId id, - HIR::ImplBlock *impl) mutable -> bool { + auto process_impl = [&] (HirId id, HIR::ImplBlock *impl) mutable -> bool { bool is_trait_impl = impl->has_trait_ref (); if (!is_trait_impl) return true; @@ -300,7 +301,13 @@ MethodResolver::assemble_trait_impl_candidates ( trait_candidates.emplace_back (func, trait, fnty, trait_ref, item_ref); return true; - }); + }; + + if (specified_trait == nullptr) + mappings.iterate_impl_blocks (process_impl); + else + mappings.iterate_trait_impl_blocks ( + specified_trait->get_mappings ().get_nodeid (), process_impl); } bool @@ -309,6 +316,14 @@ MethodResolver::try_select_predicate_candidates (TyTy::BaseType &receiver) bool found_possible_candidate = false; for (const auto &predicate : predicate_items) { + if (specified_trait != nullptr) + { + const TraitReference *parent = predicate.lookup.get_parent ()->get (); + if (parent->get_mappings ().get_nodeid () + != specified_trait->get_mappings ().get_nodeid ()) + continue; + } + const TyTy::FnType *fn = predicate.fntype; if (!fn->is_method ()) continue; @@ -434,8 +449,9 @@ MethodResolver::select (TyTy::BaseType &receiver) segment_name.to_string ().c_str ()); // Assemble candidates - std::vector inherent_impl_fns - = assemble_inherent_impl_candidates (receiver); + std::vector inherent_impl_fns; + if (specified_trait == nullptr) + inherent_impl_fns = assemble_inherent_impl_candidates (receiver); std::vector trait_impl_fns; std::vector trait_fns; assemble_trait_impl_candidates (receiver, trait_impl_fns, trait_fns); diff --git a/gcc/rust/typecheck/rust-hir-dot-operator.h b/gcc/rust/typecheck/rust-hir-dot-operator.h index 31160ed9082a..79c5db1c079f 100644 --- a/gcc/rust/typecheck/rust-hir-dot-operator.h +++ b/gcc/rust/typecheck/rust-hir-dot-operator.h @@ -59,7 +59,8 @@ class MethodResolver : private TypeCheckBase, protected AutoderefCycle static std::set Probe (TyTy::BaseType *receiver, const HIR::PathIdentSegment &segment_name, - bool autoderef_flag = false); + bool autoderef_flag = false, + const HIR::Trait *specified_trait = nullptr); static std::set Select (std::set &candidates, TyTy::BaseType *receiver, @@ -99,7 +100,8 @@ class MethodResolver : private TypeCheckBase, protected AutoderefCycle protected: MethodResolver (bool autoderef_flag, - const HIR::PathIdentSegment &segment_name); + const HIR::PathIdentSegment &segment_name, + const HIR::Trait *specified_trait); void try_hook (const TyTy::BaseType &r) override; @@ -131,6 +133,7 @@ class MethodResolver : private TypeCheckBase, protected AutoderefCycle private: // search const HIR::PathIdentSegment &segment_name; + const HIR::Trait *specified_trait; std::vector predicate_items; // mutable fields diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc index 8ba1df7d260d..1c24c7c936bb 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc @@ -2046,7 +2046,7 @@ TypeCheckExpr::resolve_operator_overload ( auto segment = specified_segment.is_error () ? HIR::PathIdentSegment (associated_item_name) : specified_segment; - auto candidates = MethodResolver::Probe (lhs, segment); + auto candidates = MethodResolver::Probe (lhs, segment, false, &trait); // remove any recursive candidates std::set resolved_candidates; diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index d7d0cc87c2a1..fc6a643077ef 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -854,6 +854,19 @@ Mappings::iterate_trait_impl_items ( } } +void +Mappings::iterate_trait_impl_blocks ( + NodeId trait_node_id, std::function cb) +{ + auto trait_impls = hirTraitImplMappings.find (trait_node_id); + if (trait_impls == hirTraitImplMappings.end ()) + return; + + for (auto *impl : trait_impls->second) + if (!cb (impl->get_mappings ().get_hirid (), impl)) + return; +} + void Mappings::iterate_impl_blocks (std::function cb) { diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index 2f7431a00c88..bfe04f0bc7a5 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -214,6 +214,10 @@ class Mappings NodeId trait_node_id, std::function cb); + void + iterate_trait_impl_blocks (NodeId trait_node_id, + std::function cb); + void iterate_impl_blocks (std::function cb); void iterate_trait_items ( From df155b8713d879168e9bd39dd12a5dc3ff76a6e5 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Sun, 23 Aug 2026 21:15:55 +0100 Subject: [PATCH 061/584] gccrs: Add explicitly filtering for is bound satisified gcc/rust/ChangeLog: * typecheck/rust-hir-type-bounds.h: optional trait arg * typecheck/rust-tyty-bounds.cc (TypeBoundsProbe::TypeBoundsProbe): likewise (TypeBoundsProbe::Probe): likewise (TypeBoundsProbe::is_bound_satisfied_for_type): use specified trait (TypeBoundsProbe::scan): try to scan for indexed traits Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-type-bounds.h | 5 +++-- gcc/rust/typecheck/rust-tyty-bounds.cc | 25 +++++++++++++++-------- 2 files changed, 19 insertions(+), 11 deletions(-) diff --git a/gcc/rust/typecheck/rust-hir-type-bounds.h b/gcc/rust/typecheck/rust-hir-type-bounds.h index bede694061d3..3dbc47ec78fa 100644 --- a/gcc/rust/typecheck/rust-hir-type-bounds.h +++ b/gcc/rust/typecheck/rust-hir-type-bounds.h @@ -30,7 +30,7 @@ class TypeBoundsProbe : public TypeCheckBase { public: static std::vector> - Probe (TyTy::BaseType *receiver); + Probe (TyTy::BaseType *receiver, const HIR::Trait *specified_trait = nullptr); static bool is_bound_satisfied_for_type (TyTy::BaseType *receiver, TraitReference *ref); @@ -46,9 +46,10 @@ class TypeBoundsProbe : public TypeCheckBase void assemble_builtin_candidate (LangItem::Kind item); private: - TypeBoundsProbe (TyTy::BaseType *receiver); + TypeBoundsProbe (TyTy::BaseType *receiver, const HIR::Trait *specified_trait); TyTy::BaseType *receiver; + const HIR::Trait *specified_trait; std::vector> trait_references; }; diff --git a/gcc/rust/typecheck/rust-tyty-bounds.cc b/gcc/rust/typecheck/rust-tyty-bounds.cc index 21a55ac6c488..86aa06d2706d 100644 --- a/gcc/rust/typecheck/rust-tyty-bounds.cc +++ b/gcc/rust/typecheck/rust-tyty-bounds.cc @@ -26,14 +26,16 @@ namespace Rust { namespace Resolver { -TypeBoundsProbe::TypeBoundsProbe (TyTy::BaseType *receiver) - : TypeCheckBase (), receiver (receiver) +TypeBoundsProbe::TypeBoundsProbe (TyTy::BaseType *receiver, + const HIR::Trait *specified_trait) + : TypeCheckBase (), receiver (receiver), specified_trait (specified_trait) {} std::vector> -TypeBoundsProbe::Probe (TyTy::BaseType *receiver) +TypeBoundsProbe::Probe (TyTy::BaseType *receiver, + const HIR::Trait *specified_trait) { - TypeBoundsProbe probe (receiver); + TypeBoundsProbe probe (receiver, specified_trait); probe.scan (); return probe.trait_references; } @@ -50,7 +52,7 @@ TypeBoundsProbe::is_bound_satisfied_for_type (TyTy::BaseType *receiver, } std::vector> bounds - = Probe (receiver); + = Probe (receiver, ref->get_hir_trait_ref ()); for (auto &bound : bounds) { const TraitReference *b = bound.first; @@ -95,10 +97,15 @@ TypeBoundsProbe::scan () { std::vector> possible_trait_paths; - mappings.iterate_impl_blocks ( - [&] (HirId id, HIR::ImplBlock *impl) mutable -> bool { - return process_impl_block (id, impl, possible_trait_paths); - }); + auto process_impl = [&] (HirId id, HIR::ImplBlock *impl) mutable -> bool { + return process_impl_block (id, impl, possible_trait_paths); + }; + + if (specified_trait == nullptr) + mappings.iterate_impl_blocks (process_impl); + else + mappings.iterate_trait_impl_blocks ( + specified_trait->get_mappings ().get_nodeid (), process_impl); for (auto &path : possible_trait_paths) { From 1de1b6197d80c9f901928fa8333bae052113e904 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Sun, 23 Aug 2026 21:19:29 +0100 Subject: [PATCH 062/584] gccrs: Add another trait filter to bounds probe gcc/rust/ChangeLog: * typecheck/rust-tyty-bounds.cc (TypeBoundPredicate::validate_type_implements_this): filter Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-tyty-bounds.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/gcc/rust/typecheck/rust-tyty-bounds.cc b/gcc/rust/typecheck/rust-tyty-bounds.cc index 86aa06d2706d..8760eb1a0a84 100644 --- a/gcc/rust/typecheck/rust-tyty-bounds.cc +++ b/gcc/rust/typecheck/rust-tyty-bounds.cc @@ -940,7 +940,8 @@ TypeBoundPredicate::validate_type_implements_this (TyTy::BaseType &self, HIR::Type &trait) const { const auto &ptref = *get (); - auto probed_bounds = Resolver::TypeBoundsProbe::Probe (&self); + auto probed_bounds + = Resolver::TypeBoundsProbe::Probe (&self, ptref.get_hir_trait_ref ()); for (auto &elem : probed_bounds) { auto &tref = *(elem.first); From 31aaed7018cc0734d51a945fc03ac8365e641cac Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Sun, 23 Aug 2026 21:45:24 +0100 Subject: [PATCH 063/584] gccrs: improve type path resolution to do the trait lookup directly The code used to work by accident that the type bounds probe already setup the type checked trait before hand so the lookup's just worked by accident. gcc/rust/ChangeLog: * typecheck/rust-hir-type-check-path.cc (TypeCheckExpr::visit): dp trait lookup * typecheck/rust-tyty.cc (BaseType::satisfies_bound): add filter Signed-off-by: Philip Herron --- .../typecheck/rust-hir-type-check-path.cc | 25 ++++++++++++++++--- gcc/rust/typecheck/rust-tyty.cc | 4 ++- 2 files changed, 24 insertions(+), 5 deletions(-) diff --git a/gcc/rust/typecheck/rust-hir-type-check-path.cc b/gcc/rust/typecheck/rust-hir-type-check-path.cc index 2e13ae4dd494..9a44fcebcc13 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-path.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-path.cc @@ -208,11 +208,28 @@ TypeCheckExpr::visit (HIR::PathInExpression &expr) else { TyTy::BaseType *resolved = nullptr; - context->lookup_type (*hir_id, &resolved); - - rust_assert (resolved); + auto trait_item = mappings.lookup_hir_trait_item (*hir_id); + if (trait_item.has_value ()) + { + HIR::Trait *trait = mappings.lookup_trait_item_mapping (*hir_id); + rust_assert (trait != nullptr); + + TraitReference *trait_ref = TraitResolver::Resolve (*trait); + if (trait_ref->is_error ()) + return; + + TraitItemReference *trait_item_ref = nullptr; + bool ok = trait_ref->lookup_hir_trait_item (**trait_item, + &trait_item_ref); + rust_assert (ok); + resolved = trait_item_ref->get_tyty (); + } + else if (!query_type (*hir_id, &resolved)) + return; - query_type (*hir_id, &infered); + if (resolved == nullptr + || resolved->get_kind () == TyTy::TypeKind::ERROR) + return; infered = SubstMapper::InferSubst (resolved, expr.get_locus ()); } diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc index ad487208ce4a..7e27343cd112 100644 --- a/gcc/rust/typecheck/rust-tyty.cc +++ b/gcc/rust/typecheck/rust-tyty.cc @@ -395,7 +395,9 @@ BaseType::satisfies_bound (const TypeBoundPredicate &predicate, bool emit_error) return true; bool satisfied = false; - auto probed = Resolver::TypeBoundsProbe::Probe (this); + auto tref = predicate.get (); + auto probed + = Resolver::TypeBoundsProbe::Probe (this, tref->get_hir_trait_ref ()); for (const auto &b : probed) { const Resolver::TraitReference *bound = b.first; From aaa386a063ba602c8caca52d71321e3fd8304bba Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Sun, 23 Aug 2026 22:02:34 +0100 Subject: [PATCH 064/584] gccrs: add more bound filtering gcc/rust/ChangeLog: * typecheck/rust-type-util.cc (lookup_associated_impl_block): add filter (normalize_projection): likewise Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-type-util.cc | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/gcc/rust/typecheck/rust-type-util.cc b/gcc/rust/typecheck/rust-type-util.cc index 4a6f444beeda..97ff25d43685 100644 --- a/gcc/rust/typecheck/rust-type-util.cc +++ b/gcc/rust/typecheck/rust-type-util.cc @@ -382,7 +382,8 @@ lookup_associated_impl_block (const TyTy::TypeBoundPredicate &bound, // setup any associated type mappings for the specified bonds and this // type - auto candidates = TypeBoundsProbe::Probe (binding); + auto candidates + = TypeBoundsProbe::Probe (binding, bound.get ()->get_hir_trait_ref ()); std::vector associated_impl_traits; for (auto &probed_bound : candidates) { @@ -669,7 +670,8 @@ normalize_projection (TyTy::ProjectionType *proj, location_t locus, && self->get_kind () != TyTy::TypeKind::INFER && self->get_kind () != TyTy::TypeKind::PROJECTION) { - auto candidates = TypeBoundsProbe::Probe (self); + auto candidates = TypeBoundsProbe::Probe ( + self, proj->get_trait_ref ()->get_hir_trait_ref ()); for (auto &probed : candidates) { HIR::ImplBlock *impl_block = probed.second; From 395886db5e3b1b5ca54aaa73af94bc2e198ce5e3 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Sun, 23 Aug 2026 22:07:54 +0100 Subject: [PATCH 065/584] gccrs: add more filtering gcc/rust/ChangeLog: * typecheck/rust-hir-path-probe.cc (PathProbeType::Probe): filter Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-path-probe.cc | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-) diff --git a/gcc/rust/typecheck/rust-hir-path-probe.cc b/gcc/rust/typecheck/rust-hir-path-probe.cc index d8ff6ff62c2c..4245e8a38b9a 100644 --- a/gcc/rust/typecheck/rust-hir-path-probe.cc +++ b/gcc/rust/typecheck/rust-hir-path-probe.cc @@ -17,6 +17,7 @@ // . #include "rust-hir-path-probe.h" +#include "rust-hir-item.h" #include "rust-hir-trait-resolve.h" #include "rust-type-util.h" #include "rust-hir-type-bounds.h" @@ -151,6 +152,8 @@ PathProbeType::Probe (TyTy::BaseType *receiver, bool ignore_mandatory_trait_items, DefId specific_trait_id) { + Analysis::Mappings &mappings = Analysis::Mappings::get (); + PathProbeType probe (receiver, segment_name, specific_trait_id); if (probe_impls) { @@ -170,8 +173,20 @@ PathProbeType::Probe (TyTy::BaseType *receiver, if (!probe.is_receiver_generic ()) { - std::vector> probed_bounds - = TypeBoundsProbe::Probe (receiver); + HIR::Trait *associated_trait = nullptr; + if (specific_trait_id != UNKNOWN_DEFID) + { + auto item_lookup = mappings.lookup_defid (specific_trait_id); + if (item_lookup.has_value ()) + { + HIR::Item *item = item_lookup.value (); + rust_assert (item->get_item_kind () + == HIR::Item::ItemKind::Trait); + associated_trait = static_cast (item); + } + } + + auto probed_bounds = TypeBoundsProbe::Probe (receiver, associated_trait); for (auto &candidate : probed_bounds) { const TraitReference *trait_ref = candidate.first; From 14ba81cbbee5aa02c4f7d9f9c21e18941677075a Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Tue, 25 Aug 2026 22:17:46 +0100 Subject: [PATCH 066/584] gccrs: Register ADT mappings util helpers gcc/rust/ChangeLog: * hir/rust-ast-lower-item.cc (register_adt_impl): new mappings (ASTLoweringItem::visit): tracker function * typecheck/rust-hir-path-probe.cc (PathProbeType::process_impl_items_for_candidates): iterator * util/rust-hir-map.cc (Mappings::insert_adt_impl_mapping): helper * util/rust-hir-map.h: likewise Signed-off-by: Philip Herron --- gcc/rust/hir/rust-ast-lower-item.cc | 23 +++++++++++++ gcc/rust/typecheck/rust-hir-path-probe.cc | 17 ++++++++++ gcc/rust/util/rust-hir-map.cc | 41 +++++++++++++++++++++++ gcc/rust/util/rust-hir-map.h | 8 +++++ 4 files changed, 89 insertions(+) diff --git a/gcc/rust/hir/rust-ast-lower-item.cc b/gcc/rust/hir/rust-ast-lower-item.cc index 19adb04a5ba6..f7cbcf1ac285 100644 --- a/gcc/rust/hir/rust-ast-lower-item.cc +++ b/gcc/rust/hir/rust-ast-lower-item.cc @@ -32,6 +32,26 @@ namespace Rust { namespace HIR { +static void +register_adt_impl (Analysis::Mappings &mappings, HIR::Type *impl_type, + HIR::ImplBlock *impl) +{ + auto &nr_ctx = Resolver2_0::FinalizedNameResolutionContext::get (); + auto resolved = nr_ctx.lookup (impl_type->get_mappings ().get_nodeid (), + Resolver2_0::Namespace::Types); + if (!resolved.has_value ()) + return; + + auto ast_item = mappings.lookup_ast_item (resolved.value ()); + if (!ast_item.has_value ()) + return; + + auto kind = ast_item.value ()->get_item_kind (); + if (kind == AST::Item::Kind::Struct || kind == AST::Item::Kind::Enum + || kind == AST::Item::Kind::Union) + mappings.insert_adt_impl_mapping (resolved.value (), impl); +} + HIR::Item * ASTLoweringItem::translate (AST::Item &item) { @@ -594,6 +614,7 @@ ASTLoweringItem::visit (AST::InherentImpl &impl_block) translated = hir_impl_block; mappings.insert_hir_impl_block (hir_impl_block); + register_adt_impl (mappings, impl_type, hir_impl_block); for (auto &impl_item_id : impl_item_ids) { mappings.insert_impl_item_mapping (impl_item_id, hir_impl_block); @@ -767,6 +788,8 @@ ASTLoweringItem::visit (AST::TraitImpl &impl_block) mappings.insert_hir_impl_block (hir_impl_block); + register_adt_impl (mappings, impl_type, hir_impl_block); + auto &nr_ctx = Resolver2_0::FinalizedNameResolutionContext::get (); auto trait_node_id = nr_ctx.lookup (trait_ref->get_mappings ().get_nodeid (), Resolver2_0::Namespace::Types); diff --git a/gcc/rust/typecheck/rust-hir-path-probe.cc b/gcc/rust/typecheck/rust-hir-path-probe.cc index 4245e8a38b9a..a6c378f25644 100644 --- a/gcc/rust/typecheck/rust-hir-path-probe.cc +++ b/gcc/rust/typecheck/rust-hir-path-probe.cc @@ -300,6 +300,23 @@ PathProbeType::process_enum_item_for_candiates (const TyTy::ADTType *adt) void PathProbeType::process_impl_items_for_candidates () { + if (auto *adt = receiver->try_as ()) + { + auto adt_item = mappings.lookup_defid (adt->get_id ()); + if (adt_item.has_value ()) + { + NodeId adt_node_id = adt_item.value ()->get_mappings ().get_nodeid (); + mappings.iterate_adt_impl_items ( + adt_node_id, + [&] (HirId id, HIR::ImplItem *item, + HIR::ImplBlock *impl) mutable -> bool { + process_impl_item_candidate (id, item, impl); + return true; + }); + return; + } + } + mappings.iterate_impl_items ( [&] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) mutable -> bool { process_impl_item_candidate (id, item, impl); diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index fc6a643077ef..87fca310e026 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -829,6 +829,47 @@ Mappings::iterate_impl_items ( } } +void +Mappings::insert_adt_impl_mapping (NodeId adt_node_id, HIR::ImplBlock *impl) +{ + hirAdtImplMappings[adt_node_id].push_back (impl); + hirIndexedAdtImpls.insert (impl); +} + +void +Mappings::iterate_adt_impl_items ( + NodeId adt_node_id, + std::function cb) +{ + auto iterate_impl = [&] (HIR::ImplBlock *impl) { + for (auto &item : impl->get_impl_items ()) + { + HIR::ImplItem *impl_item = item.get (); + HirId id = impl_item->get_impl_mappings ().get_hirid (); + if (!cb (id, impl_item, impl)) + return false; + } + return true; + }; + + auto adt_impls = hirAdtImplMappings.find (adt_node_id); + if (adt_impls != hirAdtImplMappings.end ()) + for (auto *impl : adt_impls->second) + if (!iterate_impl (impl)) + return; + + // Impl self types which cannot be classified as a concrete ADT include + // blanket implementations such as `impl Trait for T`. They must remain + // candidates for every ADT receiver. + for (auto &mapping : hirImplBlockMappings) + { + HIR::ImplBlock *impl = mapping.second; + if (hirIndexedAdtImpls.find (impl) == hirIndexedAdtImpls.end ()) + if (!iterate_impl (impl)) + return; + } +} + void Mappings::insert_trait_impl_mapping (NodeId trait_node_id, HIR::ImplBlock *impl) { diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index bfe04f0bc7a5..7595c49d6b09 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -208,6 +208,12 @@ class Mappings void iterate_impl_items ( std::function cb); + void insert_adt_impl_mapping (NodeId adt_node_id, HIR::ImplBlock *impl); + + void iterate_adt_impl_items ( + NodeId adt_node_id, + std::function cb); + void insert_trait_impl_mapping (NodeId trait_node_id, HIR::ImplBlock *impl); void iterate_trait_impl_items ( @@ -406,6 +412,8 @@ class Mappings std::map hirImplItemsToImplMappings; std::map hirImplBlockMappings; std::map hirImplBlockTypeMappings; + std::map> hirAdtImplMappings; + std::set hirIndexedAdtImpls; std::map> hirTraitImplMappings; std::map hirTraitItemMappings; std::map hirExternBlockMappings; From c15916235ba51159bebf1d4a88a3b44d5d5a632c Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Tue, 25 Aug 2026 22:19:58 +0100 Subject: [PATCH 067/584] gccrs: add new type path prob mechanism gcc/rust/ChangeLog: * Make-lang.in: new object * typecheck/rust-hir-type-check-type.cc (TypeCheckType::resolve_associated_type): helper * typecheck/rust-hir-type-check-type.h: new interface * typecheck/rust-hir-path-probe-type.cc: New file. * typecheck/rust-hir-path-probe-type.h: New file. gcc/testsuite/ChangeLog: * rust/compile/issue-4166.rs: Signed-off-by: Philip Herron --- gcc/rust/Make-lang.in | 1 + .../typecheck/rust-hir-path-probe-type.cc | 232 ++++++++++++++++++ gcc/rust/typecheck/rust-hir-path-probe-type.h | 81 ++++++ .../typecheck/rust-hir-type-check-type.cc | 120 ++++----- gcc/rust/typecheck/rust-hir-type-check-type.h | 4 + gcc/testsuite/rust/compile/issue-4166.rs | 4 +- 6 files changed, 382 insertions(+), 60 deletions(-) create mode 100644 gcc/rust/typecheck/rust-hir-path-probe-type.cc create mode 100644 gcc/rust/typecheck/rust-hir-path-probe-type.h diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in index f50e7d0c0184..3f79477b79c0 100644 --- a/gcc/rust/Make-lang.in +++ b/gcc/rust/Make-lang.in @@ -187,6 +187,7 @@ GRS_OBJS = \ rust/rust-polonius.o\ rust/rust-hir-dot-operator.o \ rust/rust-hir-path-probe.o \ + rust/rust-hir-path-probe-type.o \ rust/rust-hir-path.o \ rust/rust-hir-type.o \ rust/rust-hir-expr.o \ diff --git a/gcc/rust/typecheck/rust-hir-path-probe-type.cc b/gcc/rust/typecheck/rust-hir-path-probe-type.cc new file mode 100644 index 000000000000..98cd7adc431c --- /dev/null +++ b/gcc/rust/typecheck/rust-hir-path-probe-type.cc @@ -0,0 +1,232 @@ +// Copyright (C) 2020-2026 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 +// . + +#include "rust-hir-path-probe-type.h" +#include "rust-hir-map.h" +#include "rust-hir-trait-resolve.h" +#include "rust-hir.h" +#include "rust-type-util.h" +#include "rust-tyty.h" + +namespace Rust { +namespace Resolver { + +TypePathProbeResult +TypePathProbe::Probe (TyTy::BaseType *receiver, + const HIR::PathIdentSegment &segment_name) +{ + TypePathProbe probe (receiver, segment_name); + return probe.probe (); +} + +TypePathProbeResult +TypePathProbe::probe () +{ + switch (receiver->get_kind ()) + { + case TyTy::TypeKind::PARAM: + case TyTy::TypeKind::DYNAMIC: + probe_generic (); + break; + + case TyTy::TypeKind::ADT: + probe_adt (static_cast (receiver)); + break; + + default: + probe_fallback (); + break; + } + + return std::move (result); +} + +void +TypePathProbe::probe_generic () +{ + for (const TyTy::TypeBoundPredicate &predicate : + receiver->get_specified_bounds ()) + { + auto candidate = process_predicate_for_candidates (predicate); + insert_candidate (std::move (candidate)); + } +} + +void +TypePathProbe::probe_adt (TyTy::ADTType *adt) +{ + auto adt_item = mappings.lookup_defid (adt->get_id ()); + if (!adt_item.has_value ()) + { + probe_fallback (); + return; + } + + NodeId adt_node_id = adt_item.value ()->get_mappings ().get_nodeid (); + mappings.iterate_adt_impl_items (adt_node_id, + [this] (HirId id, HIR::ImplItem *item, + HIR::ImplBlock *impl) -> bool { + return process_impl_item (id, item, impl); + }); +} + +void +TypePathProbe::probe_fallback () +{ + mappings.iterate_impl_items ( + [&] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) mutable -> bool { + return process_impl_item (id, item, impl); + }); +} + +bool +TypePathProbe::process_impl_item (HirId id, HIR::ImplItem *item, + HIR::ImplBlock *impl) +{ + auto item_name = item->get_impl_item_name (); + if (search.to_string () != item_name) + return true; + + HirId impl_ty_id = impl->get_type ().get_mappings ().get_hirid (); + TyTy::BaseType *impl_block_ty = nullptr; + if (!query_type (impl_ty_id, &impl_block_ty)) + return true; + + if (!types_compatable (TyTy::TyWithLocation (receiver), + TyTy::TyWithLocation (impl_block_ty), + impl->get_locus (), false)) + return true; + + // Keep trait impl items at trait position. In particular, do not query the + // type of an impl associated-type alias here: projection normalization will + // select and evaluate the concrete alias later. + if (impl->has_trait_ref ()) + { + process_trait_impl_item (impl); + return true; + } + + TyTy::BaseType *item_ty = nullptr; + if (!query_type (id, &item_ty)) + return true; + + PathProbeCandidate::CandidateType candidate_type; + switch (item->get_impl_item_type ()) + { + case HIR::ImplItem::FUNCTION: + candidate_type = PathProbeCandidate::IMPL_FUNC; + break; + + case HIR::ImplItem::TYPE_ALIAS: + candidate_type = PathProbeCandidate::IMPL_TYPE_ALIAS; + break; + + case HIR::ImplItem::CONSTANT: + candidate_type = PathProbeCandidate::IMPL_CONST; + break; + + default: + return true; + } + + PathProbeCandidate::ImplItemCandidate impl_candidate{item, impl}; + + insert_candidate ( + {candidate_type, item_ty, item->get_locus (), impl_candidate}); + + return true; +} + +void +TypePathProbe::process_trait_impl_item (HIR::ImplBlock *impl) +{ + HIR::TypePath &trait_path = impl->get_trait_ref (); + TraitReference *trait_ref = TraitResolver::Lookup (trait_path); + if (trait_ref->is_error ()) + trait_ref = TraitResolver::Resolve (trait_path); + if (trait_ref->is_error ()) + return; + + TyTy::TypeBoundPredicate predicate (*trait_ref, BoundPolarity::RegularBound, + impl->get_locus ()); + auto candidate = process_predicate_for_candidates (predicate); + if (candidate.is_error ()) + return; + + rust_assert (candidate.is_trait_candidate ()); + candidate.item.trait.impl = impl; + insert_candidate (std::move (candidate)); +} + +PathProbeCandidate +TypePathProbe::process_predicate_for_candidates ( + const TyTy::TypeBoundPredicate &predicate) +{ + tl::optional item + = predicate.lookup_associated_item (search.to_string ()); + if (!item.has_value ()) + return PathProbeCandidate::get_error (); + + const TraitReference *trait_ref = item->get_parent ()->get (); + const TraitItemReference *trait_item_ref = item->get_raw_item (); + PathProbeCandidate::CandidateType candidate_type; + switch (trait_item_ref->get_trait_item_type ()) + { + case TraitItemReference::TraitItemType::FN: + candidate_type = PathProbeCandidate::CandidateType::TRAIT_FUNC; + break; + case TraitItemReference::TraitItemType::CONST: + candidate_type = PathProbeCandidate::CandidateType::TRAIT_ITEM_CONST; + break; + case TraitItemReference::TraitItemType::TYPE: + candidate_type = PathProbeCandidate::CandidateType::TRAIT_TYPE_ALIAS; + break; + + case TraitItemReference::TraitItemType::ERROR: + default: + return PathProbeCandidate::get_error (); + } + + TyTy::BaseType *trait_item_tyty = item->get_raw_item ()->get_tyty (); + if (receiver->get_kind () != TyTy::DYNAMIC) + trait_item_tyty = item->get_tyty_for_receiver (receiver); + + PathProbeCandidate::TraitItemCandidate trait_item_candidate{trait_ref, + trait_item_ref, + nullptr}; + return {candidate_type, trait_item_tyty, trait_item_ref->get_locus (), + trait_item_candidate}; +} + +void +TypePathProbe::insert_candidate (PathProbeCandidate candidate) +{ + if (candidate.is_error ()) + return; + + bool is_type + = candidate.type == PathProbeCandidate::CandidateType::IMPL_TYPE_ALIAS + || candidate.type == PathProbeCandidate::CandidateType::TRAIT_TYPE_ALIAS; + if (is_type) + result.type_candidates.insert (std::move (candidate)); + else + result.non_type_matches.insert (std::move (candidate)); +} + +} // namespace Resolver +} // namespace Rust diff --git a/gcc/rust/typecheck/rust-hir-path-probe-type.h b/gcc/rust/typecheck/rust-hir-path-probe-type.h new file mode 100644 index 000000000000..ece23030b64c --- /dev/null +++ b/gcc/rust/typecheck/rust-hir-path-probe-type.h @@ -0,0 +1,81 @@ +// Copyright (C) 2020-2026 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 RUST_HIR_PATH_PROBE_TYPE_H +#define RUST_HIR_PATH_PROBE_TYPE_H + +#include "rust-hir-map.h" +#include "rust-hir-path-probe.h" +#include "rust-tyty.h" + +namespace Rust { +namespace Resolver { + +struct TypePathProbeResult +{ + std::set type_candidates; + std::set non_type_matches; + + bool has_type_candidates () const { return !type_candidates.empty (); } + + bool has_non_type_matches () const { return !non_type_matches.empty (); } + + bool is_empty () const + { + return type_candidates.empty () && non_type_matches.empty (); + } +}; + +class TypePathProbe +{ +public: + static TypePathProbeResult Probe (TyTy::BaseType *receiver, + const HIR::PathIdentSegment &segment_name); + +private: + TypePathProbe (TyTy::BaseType *receiver, + const HIR::PathIdentSegment &segment_name) + : mappings (Analysis::Mappings::get ()), receiver (receiver), + search (segment_name) + {} + + TypePathProbeResult probe (); + + void probe_generic (); + void probe_adt (TyTy::ADTType *adt); + void probe_fallback (); + + bool process_impl_item (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl); + + void process_trait_impl_item (HIR::ImplBlock *impl); + + PathProbeCandidate + process_predicate_for_candidates (const TyTy::TypeBoundPredicate &predicate); + + void insert_candidate (PathProbeCandidate candidate); + + Analysis::Mappings &mappings; + TyTy::BaseType *receiver; + const HIR::PathIdentSegment &search; + TypePathProbeResult result; +}; + +} // namespace Resolver +} // namespace Rust + +#endif // RUST_HIR_PATH_PROBE_TYPE_H diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.cc b/gcc/rust/typecheck/rust-hir-type-check-type.cc index c6fbb2ae1bd7..112aba4c00f6 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-type.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-type.cc @@ -19,11 +19,11 @@ #include "rust-hir-type-check-type.h" #include "options.h" #include "optional.h" +#include "rich-location.h" #include "rust-hir-map.h" #include "rust-hir-trait-resolve.h" #include "rust-hir-type-check-expr.h" -#include "rust-hir-path-probe.h" -#include "rust-hir-type-bounds.h" +#include "rust-hir-path-probe-type.h" #include "rust-finalized-name-resolution-context.h" #include "rust-mapping-common.h" #include "rust-rib.h" @@ -32,6 +32,8 @@ #include "rust-system.h" #include "rust-compile-base.h" #include "rust-resolve-builtins.h" +#include "rust-tyty.h" +#include "text-range-label.h" namespace Rust { namespace Resolver { @@ -507,6 +509,19 @@ TypeCheckType::resolve_associated_type (const std::string &search, return false; } +bool +TypeCheckType::try_resolve_contextual_self_associated_type ( + const HIR::TypePathSegment &segment, bool first_segment, + bool ty_seg_is_big_self, TyTy::BaseType **result) +{ + if (!first_segment || !ty_seg_is_big_self + || !context->block_context ().is_in_context ()) + return false; + + TypeCheckBlockContextItem ctx = context->block_context ().peek (); + return resolve_associated_type (segment.to_string (), ctx, result); +} + TyTy::BaseType * TypeCheckType::resolve_segments ( HirId expr_id, std::vector> &segments, @@ -514,82 +529,71 @@ TypeCheckType::resolve_segments ( const Analysis::NodeMapping &expr_mappings, location_t expr_locus, bool tySegIsBigSelf) { - TyTy::BaseType *prev_segment = tyseg; for (size_t i = offset; i < segments.size (); i++) { - std::unique_ptr &seg = segments.at (i); - - bool reciever_is_generic - = prev_segment->get_kind () == TyTy::TypeKind::PARAM; - bool probe_bounds = true; - bool probe_impls = !reciever_is_generic; - bool ignore_mandatory_trait_items = !reciever_is_generic; + auto &seg = segments.at (i); + const auto &ident_segment = seg->get_ident_segment (); bool first_segment = i == offset; - bool selfResolveOk = false; + TyTy::BaseType *associated_type = nullptr; - if (first_segment && tySegIsBigSelf - && context->block_context ().is_in_context ()) + bool selfResolveOk + = try_resolve_contextual_self_associated_type (*seg, first_segment, + tySegIsBigSelf, + &associated_type); + if (selfResolveOk) { - TypeCheckBlockContextItem ctx = context->block_context ().peek (); - TyTy::BaseType *lookup = nullptr; - selfResolveOk - = resolve_associated_type (seg->to_string (), ctx, &lookup); - if (selfResolveOk) - { - prev_segment = tyseg; - tyseg = lookup; - } + tyseg = associated_type; } - if (!selfResolveOk) + else { - // probe the path is done in two parts one where we search impls if no - // candidate is found then we search extensions from traits - auto candidates - = PathProbeType::Probe (prev_segment, seg->get_ident_segment (), - probe_impls, false, - ignore_mandatory_trait_items); - if (candidates.size () == 0) + if (auto adt = tyseg->try_as ()) { - candidates - = PathProbeType::Probe (prev_segment, seg->get_ident_segment (), - false, probe_bounds, - ignore_mandatory_trait_items); - if (candidates.size () == 0) + if (adt->is_enum ()) { - rust_error_at ( - seg->get_locus (), - "failed to resolve path segment using an impl Probe"); - return new TyTy::ErrorType (expr_id); + rich_location r (line_table, seg->get_locus ()); + text_range_label label ("enum declared here"); + + auto item_lookup = mappings.lookup_defid (adt->get_id ()); + if (item_lookup.has_value ()) + { + auto &item = item_lookup.value (); + r.add_range (item->get_locus (), SHOW_RANGE_WITHOUT_CARET, + &label); + } + + TyTy::VariantDef *v; + if (adt->lookup_variant (ident_segment.to_string (), &v)) + { + rust_error_at ( + r, ErrorCode::E0573, + "expected type, found variant of %<%s::%s%>", + adt->get_name ().c_str (), + v->get_identifier ().c_str ()); + return new TyTy::ErrorType (expr_id); + } } } + auto result = TypePathProbe::Probe (tyseg, ident_segment); + auto &candidates = result.type_candidates; + + if (candidates.empty ()) + { + rust_error_at (seg->get_locus (), + "failed to resolve path segment %<%s%> as a type", + ident_segment.to_string ().c_str ()); + return new TyTy::ErrorType (expr_id); + } + if (candidates.size () > 1) { - ReportMultipleCandidateError::Report (candidates, - seg->get_ident_segment (), + ReportMultipleCandidateError::Report (candidates, ident_segment, seg->get_locus ()); return new TyTy::ErrorType (expr_id); } auto &candidate = *candidates.begin (); - prev_segment = tyseg; tyseg = candidate.ty; - - if (candidate.is_enum_candidate ()) - { - TyTy::ADTType *adt = static_cast (tyseg); - auto last_variant = adt->get_variants (); - TyTy::VariantDef *variant = last_variant.back (); - - rich_location richloc (line_table, seg->get_locus ()); - richloc.add_fixit_replace ("not a type"); - - rust_error_at (richloc, ErrorCode::E0573, - "expected type, found variant of %<%s::%s%>", - adt->get_name ().c_str (), - variant->get_identifier ().c_str ()); - return new TyTy::ErrorType (expr_id); - } } if (seg->is_generic_segment ()) diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.h b/gcc/rust/typecheck/rust-hir-type-check-type.h index 7683d5bda0df..27d2ae40af0c 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-type.h +++ b/gcc/rust/typecheck/rust-hir-type-check-type.h @@ -84,6 +84,10 @@ class TypeCheckType : public TypeCheckBase, public HIR::HIRTypeVisitor TypeCheckBlockContextItem &ctx, TyTy::BaseType **result); + bool try_resolve_contextual_self_associated_type ( + const HIR::TypePathSegment &segment, bool first_segment, + bool ty_seg_is_big_self, TyTy::BaseType **result); + TyTy::BaseType *translated; }; diff --git a/gcc/testsuite/rust/compile/issue-4166.rs b/gcc/testsuite/rust/compile/issue-4166.rs index d9f87909b0e0..3a28dc50174f 100644 --- a/gcc/testsuite/rust/compile/issue-4166.rs +++ b/gcc/testsuite/rust/compile/issue-4166.rs @@ -4,7 +4,7 @@ pub trait Foo { type Bar; - fn foo(bar: Self::bar); // { dg-error "failed to resolve path segment using an impl Probe" } + fn foo(bar: Self::bar); // { dg-error "failed to resolve path segment .bar. as a type" } } pub struct FooImpl; @@ -19,4 +19,4 @@ const foo_impl: () = { } }; -fn main() {} \ No newline at end of file +fn main() {} From 7aa86077d8cfae5413ccbfc0e8f7862d93294ac0 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 28 Aug 2026 17:45:55 +0100 Subject: [PATCH 068/584] gccrs: refactor out pathprobeimpltrait into its own class gcc/rust/ChangeLog: * Make-lang.in: new object * backend/rust-compile-base.cc: refactor * backend/rust-compile-drop.cc: likewise * backend/rust-compile-resolve-path.cc: likewise * typecheck/rust-hir-path-probe.cc (PathProbeImplTrait::PathProbeImplTrait): likewise (PathProbeImplTrait::Probe): likewise (PathProbeImplTrait::process_trait_impl_items_for_candidates): likewise * typecheck/rust-hir-path-probe.h (class PathProbeImplTrait): likewise * typecheck/rust-hir-path-probe-impl-trait.cc: New file. * typecheck/rust-hir-path-probe-impl-trait.h: New file. Signed-off-by: Philip Herron --- gcc/rust/Make-lang.in | 1 + gcc/rust/backend/rust-compile-base.cc | 2 +- gcc/rust/backend/rust-compile-drop.cc | 2 +- gcc/rust/backend/rust-compile-resolve-path.cc | 2 +- .../rust-hir-path-probe-impl-trait.cc | 121 ++++++++++++++++++ .../rust-hir-path-probe-impl-trait.h | 58 +++++++++ gcc/rust/typecheck/rust-hir-path-probe.cc | 33 ----- gcc/rust/typecheck/rust-hir-path-probe.h | 17 --- 8 files changed, 183 insertions(+), 53 deletions(-) create mode 100644 gcc/rust/typecheck/rust-hir-path-probe-impl-trait.cc create mode 100644 gcc/rust/typecheck/rust-hir-path-probe-impl-trait.h diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in index 3f79477b79c0..91caebbee85e 100644 --- a/gcc/rust/Make-lang.in +++ b/gcc/rust/Make-lang.in @@ -187,6 +187,7 @@ GRS_OBJS = \ rust/rust-polonius.o\ rust/rust-hir-dot-operator.o \ rust/rust-hir-path-probe.o \ + rust/rust-hir-path-probe-impl-trait.o \ rust/rust-hir-path-probe-type.o \ rust/rust-hir-path.o \ rust/rust-hir-type.o \ diff --git a/gcc/rust/backend/rust-compile-base.cc b/gcc/rust/backend/rust-compile-base.cc index 3c7cb71d283d..d4161a96f1f2 100644 --- a/gcc/rust/backend/rust-compile-base.cc +++ b/gcc/rust/backend/rust-compile-base.cc @@ -30,7 +30,7 @@ #include "rust-expr.h" // for AST::AttrInputLiteral #include "rust-hir-map.h" #include "rust-macro.h" // for AST::MetaNameValueStr -#include "rust-hir-path-probe.h" +#include "rust-hir-path-probe-impl-trait.h" #include "rust-type-util.h" #include "rust-compile-implitem.h" #include "rust-attribute-values.h" diff --git a/gcc/rust/backend/rust-compile-drop.cc b/gcc/rust/backend/rust-compile-drop.cc index d6bf79c07198..ca4e63f88274 100644 --- a/gcc/rust/backend/rust-compile-drop.cc +++ b/gcc/rust/backend/rust-compile-drop.cc @@ -22,7 +22,7 @@ #include "rust-compile-context.h" #include "rust-compile-implitem.h" #include "rust-bir-drop-analysis.h" -#include "rust-hir-path-probe.h" +#include "rust-hir-path-probe-impl-trait.h" #include "rust-hir-trait-reference.h" #include "rust-hir-type-bounds.h" #include "rust-lang-item.h" diff --git a/gcc/rust/backend/rust-compile-resolve-path.cc b/gcc/rust/backend/rust-compile-resolve-path.cc index d9225718b136..db984bee3393 100644 --- a/gcc/rust/backend/rust-compile-resolve-path.cc +++ b/gcc/rust/backend/rust-compile-resolve-path.cc @@ -24,7 +24,7 @@ #include "rust-compile-expr.h" #include "rust-hir-map.h" #include "rust-hir-trait-resolve.h" -#include "rust-hir-path-probe.h" +#include "rust-hir-path-probe-impl-trait.h" #include "rust-compile-extern.h" #include "rust-constexpr.h" #include "rust-rib.h" diff --git a/gcc/rust/typecheck/rust-hir-path-probe-impl-trait.cc b/gcc/rust/typecheck/rust-hir-path-probe-impl-trait.cc new file mode 100644 index 000000000000..7b6871fb69d2 --- /dev/null +++ b/gcc/rust/typecheck/rust-hir-path-probe-impl-trait.cc @@ -0,0 +1,121 @@ +// Copyright (C) 2026 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 +// . + +#include "rust-hir-path-probe-impl-trait.h" +#include "rust-hir-item.h" +#include "rust-type-util.h" + +namespace Rust { +namespace Resolver { + +PathProbeImplTrait::PathProbeImplTrait (TyTy::BaseType *receiver, + const HIR::PathIdentSegment &query, + const TraitReference *trait_reference) + : TypeCheckBase (), mappings (Analysis::Mappings::get ()), + receiver (receiver), search (query), trait_reference (trait_reference), + current_impl (nullptr) +{} + +std::set +PathProbeImplTrait::Probe (TyTy::BaseType *receiver, + const HIR::PathIdentSegment &segment_name, + const TraitReference *trait_reference) +{ + PathProbeImplTrait probe (receiver, segment_name, trait_reference); + probe.process_trait_impl_items_for_candidates (); + return probe.candidates; +} + +void +PathProbeImplTrait::process_trait_impl_items_for_candidates () +{ + NodeId trait_node_id = trait_reference->get_mappings ().get_nodeid (); + mappings.iterate_trait_impl_items (trait_node_id, + [this] (HirId id, HIR::ImplItem *item, + HIR::ImplBlock *impl) -> bool { + process_impl_item_candidate (id, item, + impl); + return true; + }); +} + +void +PathProbeImplTrait::process_impl_item_candidate (HirId id, HIR::ImplItem *item, + HIR::ImplBlock *impl) +{ + current_impl = impl; + HirId impl_ty_id = impl->get_type ().get_mappings ().get_hirid (); + TyTy::BaseType *impl_block_ty = nullptr; + if (!query_type (impl_ty_id, &impl_block_ty)) + return; + + if (!types_compatable (TyTy::TyWithLocation (receiver), + TyTy::TyWithLocation (impl_block_ty), + impl->get_locus (), false)) + return; + + item->accept_vis (*this); +} + +void +PathProbeImplTrait::visit (HIR::TypeAlias &alias) +{ + if (search.to_string () != alias.get_new_type_name ().as_string ()) + return; + + TyTy::BaseType *ty = nullptr; + if (!query_type (alias.get_mappings ().get_hirid (), &ty)) + return; + + PathProbeCandidate::ImplItemCandidate item{&alias, current_impl}; + candidates.insert ( + {PathProbeCandidate::IMPL_TYPE_ALIAS, ty, alias.get_locus (), item}); +} + +void +PathProbeImplTrait::visit (HIR::ConstantItem &constant) +{ + if (search.to_string () != constant.get_identifier ().as_string ()) + return; + + TyTy::BaseType *ty = nullptr; + if (!query_type (constant.get_mappings ().get_hirid (), &ty)) + return; + + PathProbeCandidate::ImplItemCandidate item{&constant, current_impl}; + candidates.insert ( + {PathProbeCandidate::IMPL_CONST, ty, constant.get_locus (), item}); +} + +void +PathProbeImplTrait::visit (HIR::Function &function) +{ + if (search.to_string () != function.get_function_name ().as_string ()) + return; + + TyTy::BaseType *ty = nullptr; + if (!query_type (function.get_mappings ().get_hirid (), &ty)) + return; + + PathProbeCandidate::ImplItemCandidate item{&function, current_impl}; + candidates.insert ( + {PathProbeCandidate::IMPL_FUNC, ty, function.get_locus (), item}); +} + +} // namespace Resolver +} // namespace Rust diff --git a/gcc/rust/typecheck/rust-hir-path-probe-impl-trait.h b/gcc/rust/typecheck/rust-hir-path-probe-impl-trait.h new file mode 100644 index 000000000000..d61019748230 --- /dev/null +++ b/gcc/rust/typecheck/rust-hir-path-probe-impl-trait.h @@ -0,0 +1,58 @@ +// Copyright (C) 2026 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 RUST_HIR_PATH_PROBE_IMPL_TRAIT_H +#define RUST_HIR_PATH_PROBE_IMPL_TRAIT_H + +#include "rust-hir-path-probe.h" + +namespace Rust { +namespace Resolver { + +class PathProbeImplTrait : public TypeCheckBase, public HIR::HIRImplVisitor +{ +public: + static std::set + Probe (TyTy::BaseType *receiver, const HIR::PathIdentSegment &segment_name, + const TraitReference *trait_reference); + + void visit (HIR::TypeAlias &alias) override; + void visit (HIR::ConstantItem &constant) override; + void visit (HIR::Function &function) override; + +private: + PathProbeImplTrait (TyTy::BaseType *receiver, + const HIR::PathIdentSegment &query, + const TraitReference *trait_reference); + + void process_trait_impl_items_for_candidates (); + void process_impl_item_candidate (HirId id, HIR::ImplItem *item, + HIR::ImplBlock *impl); + + Analysis::Mappings &mappings; + TyTy::BaseType *receiver; + const HIR::PathIdentSegment &search; + const TraitReference *trait_reference; + std::set candidates; + HIR::ImplBlock *current_impl; +}; + +} // namespace Resolver +} // namespace Rust + +#endif // RUST_HIR_PATH_PROBE_IMPL_TRAIT_H diff --git a/gcc/rust/typecheck/rust-hir-path-probe.cc b/gcc/rust/typecheck/rust-hir-path-probe.cc index a6c378f25644..2a6f93797447 100644 --- a/gcc/rust/typecheck/rust-hir-path-probe.cc +++ b/gcc/rust/typecheck/rust-hir-path-probe.cc @@ -472,38 +472,5 @@ PathProbeType::is_receiver_generic () const return receiver_is_type_param || receiver_is_dyn; } -// PathProbImplTrait - -PathProbeImplTrait::PathProbeImplTrait (TyTy::BaseType *receiver, - const HIR::PathIdentSegment &query, - const TraitReference *trait_reference) - : PathProbeType (receiver, query, UNKNOWN_DEFID), - trait_reference (trait_reference) -{} - -std::set -PathProbeImplTrait::Probe (TyTy::BaseType *receiver, - const HIR::PathIdentSegment &segment_name, - const TraitReference *trait_reference) -{ - PathProbeImplTrait probe (receiver, segment_name, trait_reference); - // iterate all impls for this trait and receiver - // then search for possible candidates using base class behaviours - probe.process_trait_impl_items_for_candidates (); - return probe.candidates; -} - -void -PathProbeImplTrait::process_trait_impl_items_for_candidates () -{ - NodeId trait_node_id = trait_reference->get_mappings ().get_nodeid (); - mappings.iterate_trait_impl_items ( - trait_node_id, - [&] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) mutable -> bool { - process_impl_item_candidate (id, item, impl); - return true; - }); -} - } // namespace Resolver } // namespace Rust diff --git a/gcc/rust/typecheck/rust-hir-path-probe.h b/gcc/rust/typecheck/rust-hir-path-probe.h index ad83ddf95289..d9800e1c696f 100644 --- a/gcc/rust/typecheck/rust-hir-path-probe.h +++ b/gcc/rust/typecheck/rust-hir-path-probe.h @@ -173,23 +173,6 @@ class ReportMultipleCandidateError : private TypeCheckBase } }; -class PathProbeImplTrait : public PathProbeType -{ -public: - static std::set - Probe (TyTy::BaseType *receiver, const HIR::PathIdentSegment &segment_name, - const TraitReference *trait_reference); - -private: - PathProbeImplTrait (TyTy::BaseType *receiver, - const HIR::PathIdentSegment &query, - const TraitReference *trait_reference); - - void process_trait_impl_items_for_candidates (); - - const TraitReference *trait_reference; -}; - } // namespace Resolver } // namespace Rust From accc27eef36899c116fa82c0c456fa8c15373e06 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 28 Aug 2026 17:52:32 +0100 Subject: [PATCH 069/584] gccrs: Refactor PathProbeType into its own file and call it PathProbeExpr gcc/rust/ChangeLog: * Make-lang.in: new object * typecheck/rust-hir-path-probe.cc (PathProbeType::PathProbeType): refactor (PathProbeType::Probe): likewise (PathProbeType::visit): likewise (PathProbeType::process_enum_item_for_candiates): likewise (PathProbeType::process_impl_items_for_candidates): likewise (PathProbeType::process_impl_item_candidate): likewise (PathProbeType::is_receiver_generic): likewise * typecheck/rust-hir-path-probe.h (class PathProbeType): likewise * typecheck/rust-hir-type-check-path.cc (TypeCheckExpr::resolve_segments): likewise * typecheck/rust-hir-path-probe-expr.cc: New file. * typecheck/rust-hir-path-probe-expr.h: New file. Signed-off-by: Philip Herron --- gcc/rust/Make-lang.in | 1 + .../typecheck/rust-hir-path-probe-expr.cc | 364 ++++++++++++++++++ gcc/rust/typecheck/rust-hir-path-probe-expr.h | 79 ++++ gcc/rust/typecheck/rust-hir-path-probe.cc | 336 ---------------- gcc/rust/typecheck/rust-hir-path-probe.h | 49 --- .../typecheck/rust-hir-type-check-path.cc | 6 +- 6 files changed, 447 insertions(+), 388 deletions(-) create mode 100644 gcc/rust/typecheck/rust-hir-path-probe-expr.cc create mode 100644 gcc/rust/typecheck/rust-hir-path-probe-expr.h diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in index 91caebbee85e..e4e5704528cf 100644 --- a/gcc/rust/Make-lang.in +++ b/gcc/rust/Make-lang.in @@ -187,6 +187,7 @@ GRS_OBJS = \ rust/rust-polonius.o\ rust/rust-hir-dot-operator.o \ rust/rust-hir-path-probe.o \ + rust/rust-hir-path-probe-expr.o \ rust/rust-hir-path-probe-impl-trait.o \ rust/rust-hir-path-probe-type.o \ rust/rust-hir-path.o \ diff --git a/gcc/rust/typecheck/rust-hir-path-probe-expr.cc b/gcc/rust/typecheck/rust-hir-path-probe-expr.cc new file mode 100644 index 000000000000..690e3e35c876 --- /dev/null +++ b/gcc/rust/typecheck/rust-hir-path-probe-expr.cc @@ -0,0 +1,364 @@ +// Copyright (C) 2020-2026 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 +// . + +#include "rust-hir-path-probe-expr.h" +#include "rust-hir-item.h" +#include "rust-type-util.h" +#include "rust-hir-type-bounds.h" + +namespace Rust { +namespace Resolver { + +// PathProbeExpr + +PathProbeExpr::PathProbeExpr (TyTy::BaseType *receiver, + const HIR::PathIdentSegment &query, + DefId specific_trait_id) + : TypeCheckBase (), receiver (receiver), search (query), + current_impl (nullptr), specific_trait_id (specific_trait_id) +{} + +std::set +PathProbeExpr::Probe (TyTy::BaseType *receiver, + const HIR::PathIdentSegment &segment_name, + bool probe_impls, bool probe_bounds, + bool ignore_mandatory_trait_items, + DefId specific_trait_id) +{ + Analysis::Mappings &mappings = Analysis::Mappings::get (); + + PathProbeExpr probe (receiver, segment_name, specific_trait_id); + if (probe_impls) + { + if (receiver->get_kind () == TyTy::TypeKind::ADT) + { + const TyTy::ADTType *adt + = static_cast (receiver); + if (adt->is_enum ()) + probe.process_enum_item_for_candiates (adt); + } + + probe.process_impl_items_for_candidates (); + } + + if (!probe_bounds) + return probe.candidates; + + if (!probe.is_receiver_generic ()) + { + HIR::Trait *associated_trait = nullptr; + if (specific_trait_id != UNKNOWN_DEFID) + { + auto item_lookup = mappings.lookup_defid (specific_trait_id); + if (item_lookup.has_value ()) + { + HIR::Item *item = item_lookup.value (); + rust_assert (item->get_item_kind () + == HIR::Item::ItemKind::Trait); + associated_trait = static_cast (item); + } + } + + auto probed_bounds = TypeBoundsProbe::Probe (receiver, associated_trait); + for (auto &candidate : probed_bounds) + { + const TraitReference *trait_ref = candidate.first; + if (specific_trait_id != UNKNOWN_DEFID) + { + if (trait_ref->get_mappings ().get_defid () != specific_trait_id) + continue; + } + + HIR::ImplBlock *impl = candidate.second; + probe.process_associated_trait_for_candidates ( + trait_ref, impl, ignore_mandatory_trait_items); + } + } + + for (const TyTy::TypeBoundPredicate &predicate : + receiver->get_specified_bounds ()) + { + const TraitReference *trait_ref = predicate.get (); + if (specific_trait_id != UNKNOWN_DEFID) + { + if (trait_ref->get_mappings ().get_defid () != specific_trait_id) + continue; + } + + probe.process_predicate_for_candidates (predicate, + ignore_mandatory_trait_items); + } + + return probe.candidates; +} + +void +PathProbeExpr::visit (HIR::TypeAlias &alias) +{ + Identifier name = alias.get_new_type_name (); + if (search.to_string ().compare (name.as_string ()) == 0) + { + HirId tyid = alias.get_mappings ().get_hirid (); + TyTy::BaseType *ty = nullptr; + if (!query_type (tyid, &ty)) + return; + + PathProbeCandidate::ImplItemCandidate impl_item_candidate{&alias, + current_impl}; + PathProbeCandidate candidate{ + PathProbeCandidate::CandidateType::IMPL_TYPE_ALIAS, ty, + alias.get_locus (), impl_item_candidate}; + candidates.insert (std::move (candidate)); + } +} + +void +PathProbeExpr::visit (HIR::ConstantItem &constant) +{ + Identifier name = constant.get_identifier (); + if (search.to_string ().compare (name.as_string ()) == 0) + { + HirId tyid = constant.get_mappings ().get_hirid (); + TyTy::BaseType *ty = nullptr; + if (!query_type (tyid, &ty)) + return; + + PathProbeCandidate::ImplItemCandidate impl_item_candidate{&constant, + current_impl}; + PathProbeCandidate candidate{ + PathProbeCandidate::CandidateType::IMPL_CONST, ty, + constant.get_locus (), impl_item_candidate}; + candidates.insert (std::move (candidate)); + } +} + +void +PathProbeExpr::visit (HIR::Function &function) +{ + Identifier name = function.get_function_name (); + if (search.to_string ().compare (name.as_string ()) == 0) + { + HirId tyid = function.get_mappings ().get_hirid (); + TyTy::BaseType *ty = nullptr; + if (!query_type (tyid, &ty)) + return; + + PathProbeCandidate::ImplItemCandidate impl_item_candidate{&function, + current_impl}; + PathProbeCandidate candidate{PathProbeCandidate::CandidateType::IMPL_FUNC, + ty, function.get_locus (), + impl_item_candidate}; + candidates.insert (std::move (candidate)); + } +} + +void +PathProbeExpr::process_enum_item_for_candiates (const TyTy::ADTType *adt) +{ + if (specific_trait_id != UNKNOWN_DEFID) + return; + + TyTy::VariantDef *v; + if (!adt->lookup_variant (search.to_string (), &v)) + return; + + PathProbeCandidate::EnumItemCandidate enum_item_candidate{adt, v}; + PathProbeCandidate candidate{PathProbeCandidate::CandidateType::ENUM_VARIANT, + receiver->clone (), + mappings.lookup_location (adt->get_ty_ref ()), + enum_item_candidate}; + candidates.insert (std::move (candidate)); +} + +void +PathProbeExpr::process_impl_items_for_candidates () +{ + if (auto *adt = receiver->try_as ()) + { + auto adt_item = mappings.lookup_defid (adt->get_id ()); + if (adt_item.has_value ()) + { + NodeId adt_node_id = adt_item.value ()->get_mappings ().get_nodeid (); + mappings.iterate_adt_impl_items ( + adt_node_id, + [&] (HirId id, HIR::ImplItem *item, + HIR::ImplBlock *impl) mutable -> bool { + process_impl_item_candidate (id, item, impl); + return true; + }); + return; + } + } + + mappings.iterate_impl_items ( + [&] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) mutable -> bool { + process_impl_item_candidate (id, item, impl); + return true; + }); +} + +void +PathProbeExpr::process_impl_item_candidate (HirId id, HIR::ImplItem *item, + HIR::ImplBlock *impl) +{ + current_impl = impl; + HirId impl_ty_id = impl->get_type ().get_mappings ().get_hirid (); + TyTy::BaseType *impl_block_ty = nullptr; + if (!query_type (impl_ty_id, &impl_block_ty)) + return; + + if (!types_compatable (TyTy::TyWithLocation (receiver), + TyTy::TyWithLocation (impl_block_ty), + impl->get_locus (), false)) + return; + + // lets visit the impl_item + item->accept_vis (*this); +} + +void +PathProbeExpr::process_associated_trait_for_candidates ( + const TraitReference *trait_ref, HIR::ImplBlock *impl, + bool ignore_mandatory_trait_items) +{ + const TraitItemReference *trait_item_ref = nullptr; + if (!trait_ref->lookup_trait_item (search.to_string (), &trait_item_ref)) + return; + + bool trait_item_needs_implementation = !trait_item_ref->is_optional (); + if (ignore_mandatory_trait_items && trait_item_needs_implementation) + return; + + PathProbeCandidate::CandidateType candidate_type; + switch (trait_item_ref->get_trait_item_type ()) + { + case TraitItemReference::TraitItemType::FN: + candidate_type = PathProbeCandidate::CandidateType::TRAIT_FUNC; + break; + case TraitItemReference::TraitItemType::CONST: + candidate_type = PathProbeCandidate::CandidateType::TRAIT_ITEM_CONST; + break; + case TraitItemReference::TraitItemType::TYPE: + candidate_type = PathProbeCandidate::CandidateType::TRAIT_TYPE_ALIAS; + break; + + case TraitItemReference::TraitItemType::ERROR: + default: + rust_unreachable (); + break; + } + + const TyTy::TypeBoundPredicate p (*trait_ref, BoundPolarity::RegularBound, + UNDEF_LOCATION); + TyTy::TypeBoundPredicateItem item (p, trait_item_ref); + + TyTy::BaseType *trait_item_tyty = item.get_raw_item ()->get_tyty (); + if (receiver->get_kind () != TyTy::DYNAMIC) + trait_item_tyty = item.get_tyty_for_receiver (receiver); + + PathProbeCandidate::TraitItemCandidate trait_item_candidate{trait_ref, + trait_item_ref, + impl}; + PathProbeCandidate candidate{candidate_type, trait_item_tyty, + trait_item_ref->get_locus (), + trait_item_candidate}; + candidates.insert (std::move (candidate)); +} + +void +PathProbeExpr::process_predicate_for_candidates ( + const TyTy::TypeBoundPredicate &predicate, bool ignore_mandatory_trait_items) +{ + const TraitReference *trait_ref = predicate.get (); + + tl::optional item + = predicate.lookup_associated_item (search.to_string ()); + if (!item.has_value ()) + return; + + if (ignore_mandatory_trait_items && item->needs_implementation ()) + return; + + const TraitItemReference *trait_item_ref = item->get_raw_item (); + PathProbeCandidate::CandidateType candidate_type; + switch (trait_item_ref->get_trait_item_type ()) + { + case TraitItemReference::TraitItemType::FN: + candidate_type = PathProbeCandidate::CandidateType::TRAIT_FUNC; + break; + case TraitItemReference::TraitItemType::CONST: + candidate_type = PathProbeCandidate::CandidateType::TRAIT_ITEM_CONST; + break; + case TraitItemReference::TraitItemType::TYPE: + candidate_type = PathProbeCandidate::CandidateType::TRAIT_TYPE_ALIAS; + break; + + case TraitItemReference::TraitItemType::ERROR: + default: + rust_unreachable (); + break; + } + + TyTy::BaseType *trait_item_tyty = item->get_raw_item ()->get_tyty (); + if (receiver->get_kind () != TyTy::DYNAMIC) + trait_item_tyty = item->get_tyty_for_receiver (receiver); + + PathProbeCandidate::TraitItemCandidate trait_item_candidate{trait_ref, + trait_item_ref, + nullptr}; + PathProbeCandidate candidate{candidate_type, trait_item_tyty, + trait_item_ref->get_locus (), + trait_item_candidate}; + candidates.insert (std::move (candidate)); +} + +std::vector> +PathProbeExpr::union_bounds ( + const std::vector> a, + const std::vector> b) + const +{ + std::map> mapper; + for (auto &ref : a) + { + mapper.insert ({ref.first->get_mappings ().get_defid (), ref}); + } + for (auto &ref : b) + { + mapper.insert ({ref.first->get_mappings ().get_defid (), ref}); + } + + std::vector> union_set; + + for (auto it = mapper.begin (); it != mapper.end (); it++) + union_set.emplace_back (it->second.first, it->second.second); + + return union_set; +} + +bool +PathProbeExpr::is_receiver_generic () const +{ + const TyTy::BaseType *root = receiver->get_root (); + bool receiver_is_type_param = root->get_kind () == TyTy::TypeKind::PARAM; + bool receiver_is_dyn = root->get_kind () == TyTy::TypeKind::DYNAMIC; + return receiver_is_type_param || receiver_is_dyn; +} + +} // namespace Resolver +} // namespace Rust diff --git a/gcc/rust/typecheck/rust-hir-path-probe-expr.h b/gcc/rust/typecheck/rust-hir-path-probe-expr.h new file mode 100644 index 000000000000..e824da667850 --- /dev/null +++ b/gcc/rust/typecheck/rust-hir-path-probe-expr.h @@ -0,0 +1,79 @@ +// Copyright (C) 2020-2026 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 RUST_HIR_PATH_PROBE_EXPR_H +#define RUST_HIR_PATH_PROBE_EXPR_H + +#include "rust-hir-path-probe.h" + +namespace Rust { +namespace Resolver { + +class PathProbeExpr : public TypeCheckBase, public HIR::HIRImplVisitor +{ +public: + static std::set + Probe (TyTy::BaseType *receiver, const HIR::PathIdentSegment &segment_name, + bool probe_impls, bool probe_bounds, bool ignore_mandatory_trait_items, + DefId specific_trait_id = UNKNOWN_DEFID); + + void visit (HIR::TypeAlias &alias) override; + void visit (HIR::ConstantItem &constant) override; + void visit (HIR::Function &function) override; + +protected: + void process_enum_item_for_candiates (const TyTy::ADTType *adt); + + void process_impl_items_for_candidates (); + + void process_impl_item_candidate (HirId id, HIR::ImplItem *item, + HIR::ImplBlock *impl); + + void + process_associated_trait_for_candidates (const TraitReference *trait_ref, + HIR::ImplBlock *impl, + bool ignore_mandatory_trait_items); + + void + process_predicate_for_candidates (const TyTy::TypeBoundPredicate &predicate, + bool ignore_mandatory_trait_items); + +protected: + PathProbeExpr (TyTy::BaseType *receiver, const HIR::PathIdentSegment &query, + DefId specific_trait_id); + + std::vector> + union_bounds ( + const std::vector> + a, + const std::vector> b) + const; + + bool is_receiver_generic () const; + + TyTy::BaseType *receiver; + const HIR::PathIdentSegment &search; + std::set candidates; + HIR::ImplBlock *current_impl; + DefId specific_trait_id; +}; + +} // namespace Resolver +} // namespace Rust + +#endif // RUST_HIR_PATH_PROBE_EXPR_H diff --git a/gcc/rust/typecheck/rust-hir-path-probe.cc b/gcc/rust/typecheck/rust-hir-path-probe.cc index 2a6f93797447..ca8c1468be86 100644 --- a/gcc/rust/typecheck/rust-hir-path-probe.cc +++ b/gcc/rust/typecheck/rust-hir-path-probe.cc @@ -136,341 +136,5 @@ PathProbeCandidate::operator< (const PathProbeCandidate &c) const return get_defid () < c.get_defid (); } -// PathProbeType - -PathProbeType::PathProbeType (TyTy::BaseType *receiver, - const HIR::PathIdentSegment &query, - DefId specific_trait_id) - : TypeCheckBase (), receiver (receiver), search (query), - current_impl (nullptr), specific_trait_id (specific_trait_id) -{} - -std::set -PathProbeType::Probe (TyTy::BaseType *receiver, - const HIR::PathIdentSegment &segment_name, - bool probe_impls, bool probe_bounds, - bool ignore_mandatory_trait_items, - DefId specific_trait_id) -{ - Analysis::Mappings &mappings = Analysis::Mappings::get (); - - PathProbeType probe (receiver, segment_name, specific_trait_id); - if (probe_impls) - { - if (receiver->get_kind () == TyTy::TypeKind::ADT) - { - const TyTy::ADTType *adt - = static_cast (receiver); - if (adt->is_enum ()) - probe.process_enum_item_for_candiates (adt); - } - - probe.process_impl_items_for_candidates (); - } - - if (!probe_bounds) - return probe.candidates; - - if (!probe.is_receiver_generic ()) - { - HIR::Trait *associated_trait = nullptr; - if (specific_trait_id != UNKNOWN_DEFID) - { - auto item_lookup = mappings.lookup_defid (specific_trait_id); - if (item_lookup.has_value ()) - { - HIR::Item *item = item_lookup.value (); - rust_assert (item->get_item_kind () - == HIR::Item::ItemKind::Trait); - associated_trait = static_cast (item); - } - } - - auto probed_bounds = TypeBoundsProbe::Probe (receiver, associated_trait); - for (auto &candidate : probed_bounds) - { - const TraitReference *trait_ref = candidate.first; - if (specific_trait_id != UNKNOWN_DEFID) - { - if (trait_ref->get_mappings ().get_defid () != specific_trait_id) - continue; - } - - HIR::ImplBlock *impl = candidate.second; - probe.process_associated_trait_for_candidates ( - trait_ref, impl, ignore_mandatory_trait_items); - } - } - - for (const TyTy::TypeBoundPredicate &predicate : - receiver->get_specified_bounds ()) - { - const TraitReference *trait_ref = predicate.get (); - if (specific_trait_id != UNKNOWN_DEFID) - { - if (trait_ref->get_mappings ().get_defid () != specific_trait_id) - continue; - } - - probe.process_predicate_for_candidates (predicate, - ignore_mandatory_trait_items); - } - - return probe.candidates; -} - -void -PathProbeType::visit (HIR::TypeAlias &alias) -{ - Identifier name = alias.get_new_type_name (); - if (search.to_string ().compare (name.as_string ()) == 0) - { - HirId tyid = alias.get_mappings ().get_hirid (); - TyTy::BaseType *ty = nullptr; - if (!query_type (tyid, &ty)) - return; - - PathProbeCandidate::ImplItemCandidate impl_item_candidate{&alias, - current_impl}; - PathProbeCandidate candidate{ - PathProbeCandidate::CandidateType::IMPL_TYPE_ALIAS, ty, - alias.get_locus (), impl_item_candidate}; - candidates.insert (std::move (candidate)); - } -} - -void -PathProbeType::visit (HIR::ConstantItem &constant) -{ - Identifier name = constant.get_identifier (); - if (search.to_string ().compare (name.as_string ()) == 0) - { - HirId tyid = constant.get_mappings ().get_hirid (); - TyTy::BaseType *ty = nullptr; - if (!query_type (tyid, &ty)) - return; - - PathProbeCandidate::ImplItemCandidate impl_item_candidate{&constant, - current_impl}; - PathProbeCandidate candidate{ - PathProbeCandidate::CandidateType::IMPL_CONST, ty, - constant.get_locus (), impl_item_candidate}; - candidates.insert (std::move (candidate)); - } -} - -void -PathProbeType::visit (HIR::Function &function) -{ - Identifier name = function.get_function_name (); - if (search.to_string ().compare (name.as_string ()) == 0) - { - HirId tyid = function.get_mappings ().get_hirid (); - TyTy::BaseType *ty = nullptr; - if (!query_type (tyid, &ty)) - return; - - PathProbeCandidate::ImplItemCandidate impl_item_candidate{&function, - current_impl}; - PathProbeCandidate candidate{PathProbeCandidate::CandidateType::IMPL_FUNC, - ty, function.get_locus (), - impl_item_candidate}; - candidates.insert (std::move (candidate)); - } -} - -void -PathProbeType::process_enum_item_for_candiates (const TyTy::ADTType *adt) -{ - if (specific_trait_id != UNKNOWN_DEFID) - return; - - TyTy::VariantDef *v; - if (!adt->lookup_variant (search.to_string (), &v)) - return; - - PathProbeCandidate::EnumItemCandidate enum_item_candidate{adt, v}; - PathProbeCandidate candidate{PathProbeCandidate::CandidateType::ENUM_VARIANT, - receiver->clone (), - mappings.lookup_location (adt->get_ty_ref ()), - enum_item_candidate}; - candidates.insert (std::move (candidate)); -} - -void -PathProbeType::process_impl_items_for_candidates () -{ - if (auto *adt = receiver->try_as ()) - { - auto adt_item = mappings.lookup_defid (adt->get_id ()); - if (adt_item.has_value ()) - { - NodeId adt_node_id = adt_item.value ()->get_mappings ().get_nodeid (); - mappings.iterate_adt_impl_items ( - adt_node_id, - [&] (HirId id, HIR::ImplItem *item, - HIR::ImplBlock *impl) mutable -> bool { - process_impl_item_candidate (id, item, impl); - return true; - }); - return; - } - } - - mappings.iterate_impl_items ( - [&] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) mutable -> bool { - process_impl_item_candidate (id, item, impl); - return true; - }); -} - -void -PathProbeType::process_impl_item_candidate (HirId id, HIR::ImplItem *item, - HIR::ImplBlock *impl) -{ - current_impl = impl; - HirId impl_ty_id = impl->get_type ().get_mappings ().get_hirid (); - TyTy::BaseType *impl_block_ty = nullptr; - if (!query_type (impl_ty_id, &impl_block_ty)) - return; - - if (!types_compatable (TyTy::TyWithLocation (receiver), - TyTy::TyWithLocation (impl_block_ty), - impl->get_locus (), false)) - return; - - // lets visit the impl_item - item->accept_vis (*this); -} - -void -PathProbeType::process_associated_trait_for_candidates ( - const TraitReference *trait_ref, HIR::ImplBlock *impl, - bool ignore_mandatory_trait_items) -{ - const TraitItemReference *trait_item_ref = nullptr; - if (!trait_ref->lookup_trait_item (search.to_string (), &trait_item_ref)) - return; - - bool trait_item_needs_implementation = !trait_item_ref->is_optional (); - if (ignore_mandatory_trait_items && trait_item_needs_implementation) - return; - - PathProbeCandidate::CandidateType candidate_type; - switch (trait_item_ref->get_trait_item_type ()) - { - case TraitItemReference::TraitItemType::FN: - candidate_type = PathProbeCandidate::CandidateType::TRAIT_FUNC; - break; - case TraitItemReference::TraitItemType::CONST: - candidate_type = PathProbeCandidate::CandidateType::TRAIT_ITEM_CONST; - break; - case TraitItemReference::TraitItemType::TYPE: - candidate_type = PathProbeCandidate::CandidateType::TRAIT_TYPE_ALIAS; - break; - - case TraitItemReference::TraitItemType::ERROR: - default: - rust_unreachable (); - break; - } - - const TyTy::TypeBoundPredicate p (*trait_ref, BoundPolarity::RegularBound, - UNDEF_LOCATION); - TyTy::TypeBoundPredicateItem item (p, trait_item_ref); - - TyTy::BaseType *trait_item_tyty = item.get_raw_item ()->get_tyty (); - if (receiver->get_kind () != TyTy::DYNAMIC) - trait_item_tyty = item.get_tyty_for_receiver (receiver); - - PathProbeCandidate::TraitItemCandidate trait_item_candidate{trait_ref, - trait_item_ref, - impl}; - PathProbeCandidate candidate{candidate_type, trait_item_tyty, - trait_item_ref->get_locus (), - trait_item_candidate}; - candidates.insert (std::move (candidate)); -} - -void -PathProbeType::process_predicate_for_candidates ( - const TyTy::TypeBoundPredicate &predicate, bool ignore_mandatory_trait_items) -{ - const TraitReference *trait_ref = predicate.get (); - - tl::optional item - = predicate.lookup_associated_item (search.to_string ()); - if (!item.has_value ()) - return; - - if (ignore_mandatory_trait_items && item->needs_implementation ()) - return; - - const TraitItemReference *trait_item_ref = item->get_raw_item (); - PathProbeCandidate::CandidateType candidate_type; - switch (trait_item_ref->get_trait_item_type ()) - { - case TraitItemReference::TraitItemType::FN: - candidate_type = PathProbeCandidate::CandidateType::TRAIT_FUNC; - break; - case TraitItemReference::TraitItemType::CONST: - candidate_type = PathProbeCandidate::CandidateType::TRAIT_ITEM_CONST; - break; - case TraitItemReference::TraitItemType::TYPE: - candidate_type = PathProbeCandidate::CandidateType::TRAIT_TYPE_ALIAS; - break; - - case TraitItemReference::TraitItemType::ERROR: - default: - rust_unreachable (); - break; - } - - TyTy::BaseType *trait_item_tyty = item->get_raw_item ()->get_tyty (); - if (receiver->get_kind () != TyTy::DYNAMIC) - trait_item_tyty = item->get_tyty_for_receiver (receiver); - - PathProbeCandidate::TraitItemCandidate trait_item_candidate{trait_ref, - trait_item_ref, - nullptr}; - PathProbeCandidate candidate{candidate_type, trait_item_tyty, - trait_item_ref->get_locus (), - trait_item_candidate}; - candidates.insert (std::move (candidate)); -} - -std::vector> -PathProbeType::union_bounds ( - const std::vector> a, - const std::vector> b) - const -{ - std::map> mapper; - for (auto &ref : a) - { - mapper.insert ({ref.first->get_mappings ().get_defid (), ref}); - } - for (auto &ref : b) - { - mapper.insert ({ref.first->get_mappings ().get_defid (), ref}); - } - - std::vector> union_set; - - for (auto it = mapper.begin (); it != mapper.end (); it++) - union_set.emplace_back (it->second.first, it->second.second); - - return union_set; -} - -bool -PathProbeType::is_receiver_generic () const -{ - const TyTy::BaseType *root = receiver->get_root (); - bool receiver_is_type_param = root->get_kind () == TyTy::TypeKind::PARAM; - bool receiver_is_dyn = root->get_kind () == TyTy::TypeKind::DYNAMIC; - return receiver_is_type_param || receiver_is_dyn; -} - } // namespace Resolver } // namespace Rust diff --git a/gcc/rust/typecheck/rust-hir-path-probe.h b/gcc/rust/typecheck/rust-hir-path-probe.h index d9800e1c696f..87bf1768970c 100644 --- a/gcc/rust/typecheck/rust-hir-path-probe.h +++ b/gcc/rust/typecheck/rust-hir-path-probe.h @@ -104,55 +104,6 @@ struct PathProbeCandidate bool operator< (const PathProbeCandidate &c) const; }; -class PathProbeType : public TypeCheckBase, public HIR::HIRImplVisitor -{ -public: - static std::set - Probe (TyTy::BaseType *receiver, const HIR::PathIdentSegment &segment_name, - bool probe_impls, bool probe_bounds, bool ignore_mandatory_trait_items, - DefId specific_trait_id = UNKNOWN_DEFID); - - void visit (HIR::TypeAlias &alias) override; - void visit (HIR::ConstantItem &constant) override; - void visit (HIR::Function &function) override; - -protected: - void process_enum_item_for_candiates (const TyTy::ADTType *adt); - - void process_impl_items_for_candidates (); - - void process_impl_item_candidate (HirId id, HIR::ImplItem *item, - HIR::ImplBlock *impl); - - void - process_associated_trait_for_candidates (const TraitReference *trait_ref, - HIR::ImplBlock *impl, - bool ignore_mandatory_trait_items); - - void - process_predicate_for_candidates (const TyTy::TypeBoundPredicate &predicate, - bool ignore_mandatory_trait_items); - -protected: - PathProbeType (TyTy::BaseType *receiver, const HIR::PathIdentSegment &query, - DefId specific_trait_id); - - std::vector> - union_bounds ( - const std::vector> - a, - const std::vector> b) - const; - - bool is_receiver_generic () const; - - TyTy::BaseType *receiver; - const HIR::PathIdentSegment &search; - std::set candidates; - HIR::ImplBlock *current_impl; - DefId specific_trait_id; -}; - class ReportMultipleCandidateError : private TypeCheckBase { public: diff --git a/gcc/rust/typecheck/rust-hir-type-check-path.cc b/gcc/rust/typecheck/rust-hir-type-check-path.cc index 9a44fcebcc13..4c7a796d77dc 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-path.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-path.cc @@ -25,7 +25,7 @@ #include "rust-hir-trait-resolve.h" #include "rust-rib.h" #include "rust-substitution-mapper.h" -#include "rust-hir-path-probe.h" +#include "rust-hir-path-probe-expr.h" #include "rust-type-util.h" #include "rust-hir-type-bounds.h" #include "rust-hir-item.h" @@ -423,13 +423,13 @@ TypeCheckExpr::resolve_segments (NodeId root_resolved_node_id, // probe the path is done in two parts one where we search impls if no // candidate is found then we search extensions from traits auto candidates - = PathProbeType::Probe (prev_segment, seg.get_segment (), probe_impls, + = PathProbeExpr::Probe (prev_segment, seg.get_segment (), probe_impls, false /*probe_bounds*/, true /*ignore_mandatory_trait_items*/); if (candidates.size () == 0) { candidates - = PathProbeType::Probe (prev_segment, seg.get_segment (), false, + = PathProbeExpr::Probe (prev_segment, seg.get_segment (), false, true /*probe_bounds*/, false /*ignore_mandatory_trait_items*/); From 9ea600d2cd3e203f86eff54559f564e6bc542751 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 28 Aug 2026 18:07:12 +0100 Subject: [PATCH 070/584] gccrs: New PathProbExpr to simplify path in expression to be more targeted The logic is much like PathProbeType but we are looking for fns/const exprs since we dont care about types in that path. We should really prefer trait position items where we can but there was regressions there which we can revisit later. gcc/rust/ChangeLog: * typecheck/rust-hir-path-probe-expr.cc (PathProbeExpr::Probe): simpler interface (PathProbeExpr::probe): based of the receiver (PathProbeExpr::visit): no longer needed (PathProbeExpr::probe_adt_impls): new probe (PathProbeExpr::probe_fallback_impls): fallback to iterate impls (PathProbeExpr::process_enum_item_for_candiates): removed (PathProbeExpr::process_enum_item_for_candidates): likewise (PathProbeExpr::process_impl_items_for_candidates): likewise (PathProbeExpr::process_impl_item_candidate): likewise (PathProbeExpr::probe_bounds): fall back to the impl iter (PathProbeExpr::insert_candidate): acumulate * typecheck/rust-hir-path-probe-expr.h (class PathProbeExpr): new interface * typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::TypeCheckExpr): likewise * typecheck/rust-hir-type-check-path.cc (TypeCheckExpr::resolve_segments): likewise Signed-off-by: Philip Herron --- .../typecheck/rust-hir-path-probe-expr.cc | 299 +++++++----------- gcc/rust/typecheck/rust-hir-path-probe-expr.h | 45 +-- .../typecheck/rust-hir-type-check-expr.cc | 2 - .../typecheck/rust-hir-type-check-path.cc | 24 +- 4 files changed, 126 insertions(+), 244 deletions(-) diff --git a/gcc/rust/typecheck/rust-hir-path-probe-expr.cc b/gcc/rust/typecheck/rust-hir-path-probe-expr.cc index 690e3e35c876..4177e3760386 100644 --- a/gcc/rust/typecheck/rust-hir-path-probe-expr.cc +++ b/gcc/rust/typecheck/rust-hir-path-probe-expr.cc @@ -24,155 +24,78 @@ namespace Rust { namespace Resolver { -// PathProbeExpr - PathProbeExpr::PathProbeExpr (TyTy::BaseType *receiver, - const HIR::PathIdentSegment &query, - DefId specific_trait_id) - : TypeCheckBase (), receiver (receiver), search (query), - current_impl (nullptr), specific_trait_id (specific_trait_id) + const HIR::PathIdentSegment &query) + : TypeCheckBase (), receiver (receiver), search (query) {} std::set PathProbeExpr::Probe (TyTy::BaseType *receiver, - const HIR::PathIdentSegment &segment_name, - bool probe_impls, bool probe_bounds, - bool ignore_mandatory_trait_items, - DefId specific_trait_id) + const HIR::PathIdentSegment &segment_name) { - Analysis::Mappings &mappings = Analysis::Mappings::get (); - - PathProbeExpr probe (receiver, segment_name, specific_trait_id); - if (probe_impls) - { - if (receiver->get_kind () == TyTy::TypeKind::ADT) - { - const TyTy::ADTType *adt - = static_cast (receiver); - if (adt->is_enum ()) - probe.process_enum_item_for_candiates (adt); - } - - probe.process_impl_items_for_candidates (); - } - - if (!probe_bounds) - return probe.candidates; + PathProbeExpr probe (receiver, segment_name); + return probe.probe (); +} - if (!probe.is_receiver_generic ()) +std::set +PathProbeExpr::probe () +{ + switch (receiver->get_kind ()) { - HIR::Trait *associated_trait = nullptr; - if (specific_trait_id != UNKNOWN_DEFID) - { - auto item_lookup = mappings.lookup_defid (specific_trait_id); - if (item_lookup.has_value ()) - { - HIR::Item *item = item_lookup.value (); - rust_assert (item->get_item_kind () - == HIR::Item::ItemKind::Trait); - associated_trait = static_cast (item); - } - } + case TyTy::TypeKind::PARAM: + probe_bounds (); + return std::move (candidates); + + case TyTy::TypeKind::ADT: + { + auto *adt = static_cast (receiver); + if (adt->is_enum ()) + process_enum_item_for_candidates (adt); + probe_adt_impls (adt); + break; + } - auto probed_bounds = TypeBoundsProbe::Probe (receiver, associated_trait); - for (auto &candidate : probed_bounds) - { - const TraitReference *trait_ref = candidate.first; - if (specific_trait_id != UNKNOWN_DEFID) - { - if (trait_ref->get_mappings ().get_defid () != specific_trait_id) - continue; - } - - HIR::ImplBlock *impl = candidate.second; - probe.process_associated_trait_for_candidates ( - trait_ref, impl, ignore_mandatory_trait_items); - } + default: + probe_fallback_impls (); + break; } - for (const TyTy::TypeBoundPredicate &predicate : - receiver->get_specified_bounds ()) - { - const TraitReference *trait_ref = predicate.get (); - if (specific_trait_id != UNKNOWN_DEFID) - { - if (trait_ref->get_mappings ().get_defid () != specific_trait_id) - continue; - } - - probe.process_predicate_for_candidates (predicate, - ignore_mandatory_trait_items); - } + if (candidates.empty ()) + probe_bounds (); - return probe.candidates; + return std::move (candidates); } void -PathProbeExpr::visit (HIR::TypeAlias &alias) +PathProbeExpr::probe_adt_impls (TyTy::ADTType *adt) { - Identifier name = alias.get_new_type_name (); - if (search.to_string ().compare (name.as_string ()) == 0) + auto adt_item = mappings.lookup_defid (adt->get_id ()); + if (!adt_item.has_value ()) { - HirId tyid = alias.get_mappings ().get_hirid (); - TyTy::BaseType *ty = nullptr; - if (!query_type (tyid, &ty)) - return; - - PathProbeCandidate::ImplItemCandidate impl_item_candidate{&alias, - current_impl}; - PathProbeCandidate candidate{ - PathProbeCandidate::CandidateType::IMPL_TYPE_ALIAS, ty, - alias.get_locus (), impl_item_candidate}; - candidates.insert (std::move (candidate)); + probe_fallback_impls (); + return; } -} -void -PathProbeExpr::visit (HIR::ConstantItem &constant) -{ - Identifier name = constant.get_identifier (); - if (search.to_string ().compare (name.as_string ()) == 0) - { - HirId tyid = constant.get_mappings ().get_hirid (); - TyTy::BaseType *ty = nullptr; - if (!query_type (tyid, &ty)) - return; - - PathProbeCandidate::ImplItemCandidate impl_item_candidate{&constant, - current_impl}; - PathProbeCandidate candidate{ - PathProbeCandidate::CandidateType::IMPL_CONST, ty, - constant.get_locus (), impl_item_candidate}; - candidates.insert (std::move (candidate)); - } + NodeId adt_node_id = adt_item.value ()->get_mappings ().get_nodeid (); + mappings.iterate_adt_impl_items ( + adt_node_id, + [this] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) -> bool { + return process_impl_item_candidate (id, item, impl); + }); } void -PathProbeExpr::visit (HIR::Function &function) +PathProbeExpr::probe_fallback_impls () { - Identifier name = function.get_function_name (); - if (search.to_string ().compare (name.as_string ()) == 0) - { - HirId tyid = function.get_mappings ().get_hirid (); - TyTy::BaseType *ty = nullptr; - if (!query_type (tyid, &ty)) - return; - - PathProbeCandidate::ImplItemCandidate impl_item_candidate{&function, - current_impl}; - PathProbeCandidate candidate{PathProbeCandidate::CandidateType::IMPL_FUNC, - ty, function.get_locus (), - impl_item_candidate}; - candidates.insert (std::move (candidate)); - } + mappings.iterate_impl_items ( + [this] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) -> bool { + return process_impl_item_candidate (id, item, impl); + }); } void -PathProbeExpr::process_enum_item_for_candiates (const TyTy::ADTType *adt) +PathProbeExpr::process_enum_item_for_candidates (const TyTy::ADTType *adt) { - if (specific_trait_id != UNKNOWN_DEFID) - return; - TyTy::VariantDef *v; if (!adt->lookup_variant (search.to_string (), &v)) return; @@ -185,65 +108,76 @@ PathProbeExpr::process_enum_item_for_candiates (const TyTy::ADTType *adt) candidates.insert (std::move (candidate)); } -void -PathProbeExpr::process_impl_items_for_candidates () -{ - if (auto *adt = receiver->try_as ()) - { - auto adt_item = mappings.lookup_defid (adt->get_id ()); - if (adt_item.has_value ()) - { - NodeId adt_node_id = adt_item.value ()->get_mappings ().get_nodeid (); - mappings.iterate_adt_impl_items ( - adt_node_id, - [&] (HirId id, HIR::ImplItem *item, - HIR::ImplBlock *impl) mutable -> bool { - process_impl_item_candidate (id, item, impl); - return true; - }); - return; - } - } - - mappings.iterate_impl_items ( - [&] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) mutable -> bool { - process_impl_item_candidate (id, item, impl); - return true; - }); -} - -void +bool PathProbeExpr::process_impl_item_candidate (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) { - current_impl = impl; + if (search.to_string () != item->get_impl_item_name ()) + return true; + HirId impl_ty_id = impl->get_type ().get_mappings ().get_hirid (); TyTy::BaseType *impl_block_ty = nullptr; if (!query_type (impl_ty_id, &impl_block_ty)) - return; + return true; if (!types_compatable (TyTy::TyWithLocation (receiver), TyTy::TyWithLocation (impl_block_ty), impl->get_locus (), false)) - return; + return true; + + PathProbeCandidate::CandidateType candidate_type; + switch (item->get_impl_item_type ()) + { + case HIR::ImplItem::FUNCTION: + candidate_type = PathProbeCandidate::CandidateType::IMPL_FUNC; + break; + case HIR::ImplItem::CONSTANT: + candidate_type = PathProbeCandidate::CandidateType::IMPL_CONST; + break; + case HIR::ImplItem::TYPE_ALIAS: + default: + return true; + } + + TyTy::BaseType *item_ty = nullptr; + if (!query_type (id, &item_ty)) + return true; + + PathProbeCandidate::ImplItemCandidate impl_candidate{item, impl}; + insert_candidate ( + {candidate_type, item_ty, item->get_locus (), impl_candidate}); + + return true; +} + +void +PathProbeExpr::probe_bounds () +{ + if (!is_receiver_generic ()) + { + auto probed_bounds = TypeBoundsProbe::Probe (receiver); + for (auto &candidate : probed_bounds) + { + const TraitReference *trait_ref = candidate.first; + process_associated_trait_for_candidates (trait_ref, candidate.second); + } + } - // lets visit the impl_item - item->accept_vis (*this); + for (const TyTy::TypeBoundPredicate &predicate : + receiver->get_specified_bounds ()) + { + process_predicate_for_candidates (predicate); + } } void PathProbeExpr::process_associated_trait_for_candidates ( - const TraitReference *trait_ref, HIR::ImplBlock *impl, - bool ignore_mandatory_trait_items) + const TraitReference *trait_ref, HIR::ImplBlock *impl) { const TraitItemReference *trait_item_ref = nullptr; if (!trait_ref->lookup_trait_item (search.to_string (), &trait_item_ref)) return; - bool trait_item_needs_implementation = !trait_item_ref->is_optional (); - if (ignore_mandatory_trait_items && trait_item_needs_implementation) - return; - PathProbeCandidate::CandidateType candidate_type; switch (trait_item_ref->get_trait_item_type ()) { @@ -254,8 +188,7 @@ PathProbeExpr::process_associated_trait_for_candidates ( candidate_type = PathProbeCandidate::CandidateType::TRAIT_ITEM_CONST; break; case TraitItemReference::TraitItemType::TYPE: - candidate_type = PathProbeCandidate::CandidateType::TRAIT_TYPE_ALIAS; - break; + return; case TraitItemReference::TraitItemType::ERROR: default: @@ -277,12 +210,12 @@ PathProbeExpr::process_associated_trait_for_candidates ( PathProbeCandidate candidate{candidate_type, trait_item_tyty, trait_item_ref->get_locus (), trait_item_candidate}; - candidates.insert (std::move (candidate)); + insert_candidate (std::move (candidate)); } void PathProbeExpr::process_predicate_for_candidates ( - const TyTy::TypeBoundPredicate &predicate, bool ignore_mandatory_trait_items) + const TyTy::TypeBoundPredicate &predicate) { const TraitReference *trait_ref = predicate.get (); @@ -291,9 +224,6 @@ PathProbeExpr::process_predicate_for_candidates ( if (!item.has_value ()) return; - if (ignore_mandatory_trait_items && item->needs_implementation ()) - return; - const TraitItemReference *trait_item_ref = item->get_raw_item (); PathProbeCandidate::CandidateType candidate_type; switch (trait_item_ref->get_trait_item_type ()) @@ -305,8 +235,7 @@ PathProbeExpr::process_predicate_for_candidates ( candidate_type = PathProbeCandidate::CandidateType::TRAIT_ITEM_CONST; break; case TraitItemReference::TraitItemType::TYPE: - candidate_type = PathProbeCandidate::CandidateType::TRAIT_TYPE_ALIAS; - break; + return; case TraitItemReference::TraitItemType::ERROR: default: @@ -324,31 +253,17 @@ PathProbeExpr::process_predicate_for_candidates ( PathProbeCandidate candidate{candidate_type, trait_item_tyty, trait_item_ref->get_locus (), trait_item_candidate}; - candidates.insert (std::move (candidate)); + insert_candidate (std::move (candidate)); } -std::vector> -PathProbeExpr::union_bounds ( - const std::vector> a, - const std::vector> b) - const +void +PathProbeExpr::insert_candidate (PathProbeCandidate candidate) { - std::map> mapper; - for (auto &ref : a) - { - mapper.insert ({ref.first->get_mappings ().get_defid (), ref}); - } - for (auto &ref : b) - { - mapper.insert ({ref.first->get_mappings ().get_defid (), ref}); - } - - std::vector> union_set; - - for (auto it = mapper.begin (); it != mapper.end (); it++) - union_set.emplace_back (it->second.first, it->second.second); - - return union_set; + bool is_type + = candidate.type == PathProbeCandidate::CandidateType::IMPL_TYPE_ALIAS + || candidate.type == PathProbeCandidate::CandidateType::TRAIT_TYPE_ALIAS; + if (!candidate.is_error () && !is_type) + candidates.insert (std::move (candidate)); } bool diff --git a/gcc/rust/typecheck/rust-hir-path-probe-expr.h b/gcc/rust/typecheck/rust-hir-path-probe-expr.h index e824da667850..2b843a258138 100644 --- a/gcc/rust/typecheck/rust-hir-path-probe-expr.h +++ b/gcc/rust/typecheck/rust-hir-path-probe-expr.h @@ -24,53 +24,38 @@ namespace Rust { namespace Resolver { -class PathProbeExpr : public TypeCheckBase, public HIR::HIRImplVisitor +class PathProbeExpr : public TypeCheckBase { public: static std::set - Probe (TyTy::BaseType *receiver, const HIR::PathIdentSegment &segment_name, - bool probe_impls, bool probe_bounds, bool ignore_mandatory_trait_items, - DefId specific_trait_id = UNKNOWN_DEFID); + Probe (TyTy::BaseType *receiver, const HIR::PathIdentSegment &segment_name); - void visit (HIR::TypeAlias &alias) override; - void visit (HIR::ConstantItem &constant) override; - void visit (HIR::Function &function) override; +private: + std::set probe (); + void probe_adt_impls (TyTy::ADTType *adt); + void probe_fallback_impls (); + void probe_bounds (); -protected: - void process_enum_item_for_candiates (const TyTy::ADTType *adt); + void process_enum_item_for_candidates (const TyTy::ADTType *adt); - void process_impl_items_for_candidates (); - - void process_impl_item_candidate (HirId id, HIR::ImplItem *item, + bool process_impl_item_candidate (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl); - void - process_associated_trait_for_candidates (const TraitReference *trait_ref, - HIR::ImplBlock *impl, - bool ignore_mandatory_trait_items); + void process_associated_trait_for_candidates (const TraitReference *trait_ref, + HIR::ImplBlock *impl); void - process_predicate_for_candidates (const TyTy::TypeBoundPredicate &predicate, - bool ignore_mandatory_trait_items); + process_predicate_for_candidates (const TyTy::TypeBoundPredicate &predicate); -protected: - PathProbeExpr (TyTy::BaseType *receiver, const HIR::PathIdentSegment &query, - DefId specific_trait_id); - - std::vector> - union_bounds ( - const std::vector> - a, - const std::vector> b) - const; + PathProbeExpr (TyTy::BaseType *receiver, const HIR::PathIdentSegment &query); bool is_receiver_generic () const; + void insert_candidate (PathProbeCandidate candidate); + TyTy::BaseType *receiver; const HIR::PathIdentSegment &search; std::set candidates; - HIR::ImplBlock *current_impl; - DefId specific_trait_id; }; } // namespace Resolver diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc index 1c24c7c936bb..48145c8df73a 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc @@ -44,8 +44,6 @@ namespace Resolver { TypeCheckExpr::TypeCheckExpr () : TypeCheckBase (), infered (nullptr) {} -// Perform type checking on expr. Also runs type unification algorithm. -// Returns the unified type of expr TyTy::BaseType * TypeCheckExpr::Resolve (HIR::Expr &expr) { diff --git a/gcc/rust/typecheck/rust-hir-type-check-path.cc b/gcc/rust/typecheck/rust-hir-type-check-path.cc index 4c7a796d77dc..52c6e66b2bfe 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-path.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-path.cc @@ -418,28 +418,12 @@ TypeCheckExpr::resolve_segments (NodeId root_resolved_node_id, for (size_t i = offset; i < segments.size (); i++) { HIR::PathExprSegment &seg = segments.at (i); - bool probe_impls = !receiver_is_generic; - - // probe the path is done in two parts one where we search impls if no - // candidate is found then we search extensions from traits - auto candidates - = PathProbeExpr::Probe (prev_segment, seg.get_segment (), probe_impls, - false /*probe_bounds*/, - true /*ignore_mandatory_trait_items*/); + auto candidates = PathProbeExpr::Probe (prev_segment, seg.get_segment ()); if (candidates.size () == 0) { - candidates - = PathProbeExpr::Probe (prev_segment, seg.get_segment (), false, - true /*probe_bounds*/, - false /*ignore_mandatory_trait_items*/); - - if (candidates.size () == 0) - { - rust_error_at ( - seg.get_locus (), - "failed to resolve path segment using an impl Probe"); - return; - } + rust_error_at (seg.get_locus (), + "failed to resolve path segment using an impl Probe"); + return; } if (candidates.size () > 1) From a2c4b073025328d4973b8f2942840d40bcc451a1 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 28 Aug 2026 19:54:17 +0100 Subject: [PATCH 071/584] gccrs: minor select method improvement We can do a defid check and possibly early return for mismatches on adt's. gcc/rust/ChangeLog: * typecheck/rust-hir-dot-operator.cc: Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-dot-operator.cc | 162 ++++++++++++-------- 1 file changed, 95 insertions(+), 67 deletions(-) diff --git a/gcc/rust/typecheck/rust-hir-dot-operator.cc b/gcc/rust/typecheck/rust-hir-dot-operator.cc index f74005e1ed83..227e5dce1de6 100644 --- a/gcc/rust/typecheck/rust-hir-dot-operator.cc +++ b/gcc/rust/typecheck/rust-hir-dot-operator.cc @@ -124,73 +124,86 @@ MethodResolver::assemble_inherent_impl_candidates ( bool receiver_is_ref = raw->get_kind () == TyTy::TypeKind::REF; // Assemble inherent impl items (non-trait impl blocks) - mappings.iterate_impl_items ( - [&] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) mutable -> bool { - bool is_trait_impl = impl->has_trait_ref (); - if (is_trait_impl) - return true; + mappings.iterate_impl_items ([&] (HirId id, HIR::ImplItem *item, + HIR::ImplBlock *impl) mutable -> bool { + bool is_trait_impl = impl->has_trait_ref (); + if (is_trait_impl) + return true; - bool is_fn - = item->get_impl_item_type () == HIR::ImplItem::ImplItemType::FUNCTION; - if (!is_fn) - return true; + bool is_fn + = item->get_impl_item_type () == HIR::ImplItem::ImplItemType::FUNCTION; + if (!is_fn) + return true; - HIR::Function *func = static_cast (item); - if (!func->is_method ()) - return true; + HIR::Function *func = static_cast (item); + if (!func->is_method ()) + return true; - bool name_matches = func->get_function_name ().as_string ().compare ( - segment_name.to_string ()) - == 0; - if (!name_matches) - return true; + bool name_matches = func->get_function_name ().as_string ().compare ( + segment_name.to_string ()) + == 0; + if (!name_matches) + return true; - TyTy::BaseType *ty = nullptr; - if (!query_type (func->get_mappings ().get_hirid (), &ty)) - return true; - if (ty == nullptr || ty->get_kind () == TyTy::TypeKind::ERROR) - return true; - if (ty->get_kind () != TyTy::TypeKind::FNDEF) - return true; + TyTy::BaseType *impl_self = TypeCheckItem::ResolveImplBlockSelf (*impl); - TyTy::FnType *fnty = static_cast (ty); - const TyTy::BaseType *impl_self - = TypeCheckItem::ResolveImplBlockSelf (*impl); + if (impl_self == nullptr || impl_self->get_kind () == TyTy::TypeKind::ERROR) + return true; - // see: - // https://gcc-rust.zulipchat.com/#narrow/stream/266897-general/topic/Method.20Resolution/near/338646280 - // https://github.com/rust-lang/rust/blob/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/compiler/rustc_typeck/src/check/method/probe.rs#L650-L660 - bool impl_self_is_ptr = impl_self->get_kind () == TyTy::TypeKind::POINTER; - bool impl_self_is_ref = impl_self->get_kind () == TyTy::TypeKind::REF; - if (receiver_is_raw_ptr && impl_self_is_ptr) - { - const TyTy::PointerType &sptr - = *static_cast (impl_self); - const TyTy::PointerType &ptr - = *static_cast (raw); - - // we could do this via lang-item assemblies if we refactor this - bool mut_match = sptr.mutability () == ptr.mutability (); - if (!mut_match) - return true; - } - else if (receiver_is_ref && impl_self_is_ref) - { - const TyTy::ReferenceType &sptr - = *static_cast (impl_self); - const TyTy::ReferenceType &ptr - = *static_cast (raw); - - // we could do this via lang-item assemblies if we refactor this - bool mut_match = sptr.mutability () == ptr.mutability (); - if (!mut_match) - return true; - } + if (receiver.get_kind () == TyTy::TypeKind::ADT + && impl_self->get_kind () == TyTy::TypeKind::ADT) + { + const auto &receiver_adt + = static_cast (receiver); + const auto &impl_adt = static_cast (*impl_self); + if (receiver_adt.get_id () != impl_adt.get_id ()) + return true; + } - inherent_impl_fns.emplace_back (func, impl, fnty); + // see: + // https://gcc-rust.zulipchat.com/#narrow/stream/266897-general/topic/Method.20Resolution/near/338646280 + // https://github.com/rust-lang/rust/blob/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/compiler/rustc_typeck/src/check/method/probe.rs#L650-L660 + bool impl_self_is_ptr = impl_self->get_kind () == TyTy::TypeKind::POINTER; + bool impl_self_is_ref = impl_self->get_kind () == TyTy::TypeKind::REF; + if (receiver_is_raw_ptr && impl_self_is_ptr) + { + const TyTy::PointerType &sptr + = *static_cast (impl_self); + const TyTy::PointerType &ptr + = *static_cast (raw); + + // we could do this via lang-item assemblies if we refactor this + bool mut_match = sptr.mutability () == ptr.mutability (); + if (!mut_match) + return true; + } + else if (receiver_is_ref && impl_self_is_ref) + { + const TyTy::ReferenceType &sptr + = *static_cast (impl_self); + const TyTy::ReferenceType &ptr + = *static_cast (raw); + + // we could do this via lang-item assemblies if we refactor this + bool mut_match = sptr.mutability () == ptr.mutability (); + if (!mut_match) + return true; + } + TyTy::BaseType *ty = nullptr; + if (!query_type (func->get_mappings ().get_hirid (), &ty)) + return true; + if (ty == nullptr || ty->get_kind () == TyTy::TypeKind::ERROR) + return true; + if (ty->get_kind () != TyTy::TypeKind::FNDEF) return true; - }); + + TyTy::FnType *fnty = static_cast (ty); + + inherent_impl_fns.emplace_back (func, impl, fnty); + + return true; + }); return inherent_impl_fns; } @@ -228,17 +241,22 @@ MethodResolver::assemble_trait_impl_candidates ( if (!name_matches) continue; - TyTy::BaseType *ty = nullptr; - if (!query_type (func->get_mappings ().get_hirid (), &ty)) - continue; - if (ty == nullptr || ty->get_kind () == TyTy::TypeKind::ERROR) - continue; - if (ty->get_kind () != TyTy::TypeKind::FNDEF) + TyTy::BaseType *impl_self = TypeCheckItem::ResolveImplBlockSelf (*impl); + + if (impl_self == nullptr + || impl_self->get_kind () == TyTy::TypeKind::ERROR) continue; - TyTy::FnType *fnty = static_cast (ty); - const TyTy::BaseType *impl_self - = TypeCheckItem::ResolveImplBlockSelf (*impl); + if (receiver.get_kind () == TyTy::TypeKind::ADT + && impl_self->get_kind () == TyTy::TypeKind::ADT) + { + const auto &receiver_adt + = static_cast (receiver); + const auto &impl_adt + = static_cast (*impl_self); + if (receiver_adt.get_id () != impl_adt.get_id ()) + continue; + } // see: // https://gcc-rust.zulipchat.com/#narrow/stream/266897-general/topic/Method.20Resolution/near/338646280 @@ -271,6 +289,16 @@ MethodResolver::assemble_trait_impl_candidates ( continue; } + TyTy::BaseType *ty = nullptr; + if (!query_type (func->get_mappings ().get_hirid (), &ty)) + continue; + if (ty == nullptr || ty->get_kind () == TyTy::TypeKind::ERROR) + continue; + if (ty->get_kind () != TyTy::TypeKind::FNDEF) + continue; + + TyTy::FnType *fnty = static_cast (ty); + impl_candidates.emplace_back (func, impl, fnty); return true; } From a21095e3a405ac202d76427c74060c89c81274f2 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 28 Aug 2026 20:03:28 +0100 Subject: [PATCH 072/584] gccrs: refactor fntype resolution to seperate signiture from block We currently alawys resolve function body and signiture together this seperates the two concepts so we can change query type if a fn is not resolved to only query the signiture and not start the cascade of resolving body calling others etc. gcc/rust/ChangeLog: * typecheck/rust-hir-type-check-implitem.cc (TypeCheckImplItem::visit): seperate (TypeCheckImplItem::resolve_function_signature): likewise * typecheck/rust-hir-type-check-implitem.h: seperate * typecheck/rust-hir-type-check-item.cc (TypeCheckItem::visit): likewise (TypeCheckItem::resolve_function_signature): likewise * typecheck/rust-hir-type-check-item.h: likewise Signed-off-by: Philip Herron --- .../typecheck/rust-hir-type-check-implitem.cc | 38 ++++++++++++++----- .../typecheck/rust-hir-type-check-implitem.h | 2 + .../typecheck/rust-hir-type-check-item.cc | 34 +++++++++++++---- gcc/rust/typecheck/rust-hir-type-check-item.h | 2 + 4 files changed, 60 insertions(+), 16 deletions(-) diff --git a/gcc/rust/typecheck/rust-hir-type-check-implitem.cc b/gcc/rust/typecheck/rust-hir-type-check-implitem.cc index a29793c832f9..f8808351e10c 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-implitem.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-implitem.cc @@ -203,11 +203,9 @@ TypeCheckImplItem::Resolve ( return resolver.result; } -void -TypeCheckImplItem::visit (HIR::Function &function) +TyTy::FnType * +TypeCheckImplItem::resolve_function_signature (HIR::Function &function) { - auto binder_pin = context->push_lifetime_binder (); - if (function.has_generics ()) resolve_generic_params (HIR::Item::ItemKind::Function, function.get_locus (), @@ -230,7 +228,7 @@ TypeCheckImplItem::visit (HIR::Function &function) { rust_error_at (function.get_locus (), "failed to resolve return type"); - return; + return nullptr; } ret_type = resolved->clone (); @@ -285,7 +283,7 @@ TypeCheckImplItem::visit (HIR::Function &function) { rust_inform (self_param.get_locus (), "failed to resolve lifetime"); - return; + return nullptr; } } else @@ -310,7 +308,7 @@ TypeCheckImplItem::visit (HIR::Function &function) { rust_error_at (self_param.get_locus (), "failed to resolve lifetime"); - return; + return nullptr; } } else @@ -326,7 +324,7 @@ TypeCheckImplItem::visit (HIR::Function &function) default: rust_unreachable (); - return; + return nullptr; } } @@ -367,8 +365,30 @@ TypeCheckImplItem::visit (HIR::Function &function) context->insert_type (function.get_mappings (), fnType); result = fnType; + return fnType; +} + +void +TypeCheckImplItem::visit (HIR::Function &function) +{ + auto binder_pin = context->push_lifetime_binder (); + + TyTy::BaseType *resolved = nullptr; + TyTy::FnType *resolve_fn_type = nullptr; + if (context->lookup_type (function.get_mappings ().get_hirid (), &resolved)) + { + if (resolved->get_kind () != TyTy::TypeKind::FNDEF) + return; + resolve_fn_type = static_cast (resolved); + result = resolve_fn_type; + } + else + resolve_fn_type = resolve_function_signature (function); + + if (resolve_fn_type == nullptr) + return; + // need to get the return type from this - TyTy::FnType *resolve_fn_type = fnType; auto expected_ret_tyty = resolve_fn_type->get_return_type (); context->push_return_type (TypeCheckContextItem (parent, &function), expected_ret_tyty); diff --git a/gcc/rust/typecheck/rust-hir-type-check-implitem.h b/gcc/rust/typecheck/rust-hir-type-check-implitem.h index eb0a0f985d1d..cba105434c9e 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-implitem.h +++ b/gcc/rust/typecheck/rust-hir-type-check-implitem.h @@ -58,6 +58,8 @@ class TypeCheckImplItem : public TypeCheckBase, public HIR::HIRImplVisitor TypeCheckImplItem (HIR::ImplBlock &parent, TyTy::BaseType *self, std::vector substitutions); + TyTy::FnType *resolve_function_signature (HIR::Function &function); + HIR::ImplBlock &parent; TyTy::BaseType *self; std::vector substitutions; diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.cc b/gcc/rust/typecheck/rust-hir-type-check-item.cc index 1b8b929bdb81..25fa97a368b3 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-item.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-item.cc @@ -794,10 +794,9 @@ TypeCheckItem::resolve_impl_item (HIR::ImplBlock &impl_block, return TypeCheckImplItem::Resolve (impl_block, item, self, substitutions); } -void -TypeCheckItem::visit (HIR::Function &function) +TyTy::FnType * +TypeCheckItem::resolve_function_signature (HIR::Function &function) { - auto lifetime_pin = context->push_clean_lifetime_resolver (); std::vector substitutions; if (function.has_generics ()) resolve_generic_params (HIR::Item::ItemKind::Function, @@ -817,7 +816,7 @@ TypeCheckItem::visit (HIR::Function &function) { auto resolved = TypeCheckType::Resolve (function.get_return_type ()); if (resolved->get_kind () == TyTy::TypeKind::ERROR) - return; + return nullptr; ret_type = resolved->clone (); ret_type->set_ref ( @@ -855,8 +854,29 @@ TypeCheckItem::visit (HIR::Function &function) context->insert_type (function.get_mappings (), fn_type); + return fn_type; +} + +void +TypeCheckItem::visit (HIR::Function &function) +{ + auto lifetime_pin = context->push_clean_lifetime_resolver (); + + TyTy::BaseType *resolved = nullptr; + TyTy::FnType *resolved_fn_type = nullptr; + if (context->lookup_type (function.get_mappings ().get_hirid (), &resolved)) + { + if (resolved->get_kind () != TyTy::TypeKind::FNDEF) + return; + resolved_fn_type = static_cast (resolved); + } + else + resolved_fn_type = resolve_function_signature (function); + + if (resolved_fn_type == nullptr) + return; + // need to get the return type from this - TyTy::FnType *resolved_fn_type = fn_type; auto expected_ret_tyty = resolved_fn_type->get_return_type (); context->push_return_type (TypeCheckContextItem (&function), expected_ret_tyty); @@ -866,7 +886,7 @@ TypeCheckItem::visit (HIR::Function &function) // emit check for // error[E0121]: the type placeholder `_` is not allowed within types on item - const auto placeholder = ret_type->contains_infer (); + const auto placeholder = expected_ret_tyty->contains_infer (); if (placeholder != nullptr && function.has_return_type ()) { // FIXME @@ -906,7 +926,7 @@ TypeCheckItem::visit (HIR::Function &function) context->pop_return_type (); - infered = fn_type; + infered = resolved_fn_type; } void diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.h b/gcc/rust/typecheck/rust-hir-type-check-item.h index 52be8e2f680a..389b0fd9af5f 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-item.h +++ b/gcc/rust/typecheck/rust-hir-type-check-item.h @@ -88,6 +88,8 @@ class TypeCheckItem : private TypeCheckBase, private HIR::HIRVisItemVisitor TyTy::BaseType *resolve_impl_block_self (HIR::ImplBlock &impl_block); + TyTy::FnType *resolve_function_signature (HIR::Function &function); + bool validate_repr_simd (const std::vector &fields, location_t locus); From b6b3a48249b3269dcaa9bf96d0eb69b9eb396ee6 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 28 Aug 2026 22:20:21 +0100 Subject: [PATCH 073/584] gccrs: seperate implitem fntype and body resolution This builds upon the previous patch to seperate fn hir item body and signiture resolution to stop crate cascades. gcc/rust/ChangeLog: * typecheck/rust-hir-type-check-implitem.cc (TypeCheckImplItem::visit): check need to resolve body * typecheck/rust-hir-type-check-implitem.h: new resolve sig * typecheck/rust-hir-type-check-item.cc (TypeCheckItem::Resolve): check recursion (TypeCheckItem::ResolveFunctionSignature): new helper (TypeCheckItem::ResolveImplBlockSelf): missing lifetime pin (TypeCheckItem::visit): likewise * typecheck/rust-hir-type-check-item.h: new helper * typecheck/rust-hir-type-check.h: track function body pending * typecheck/rust-type-util.cc (query_type): track associated self (normalize_projection): check compatable * typecheck/rust-typecheck-context.cc (TypeCheckContext::mark_function_body_pending): marker to make sure body gets resolved later (TypeCheckContext::clear_function_body_pending): clear market (TypeCheckContext::function_body_pending): new set Signed-off-by: Philip Herron --- .../typecheck/rust-hir-type-check-implitem.cc | 29 ++++++- .../typecheck/rust-hir-type-check-implitem.h | 4 + .../typecheck/rust-hir-type-check-item.cc | 26 ++++++- gcc/rust/typecheck/rust-hir-type-check-item.h | 2 + gcc/rust/typecheck/rust-hir-type-check.h | 6 ++ gcc/rust/typecheck/rust-type-util.cc | 77 +++++++++++++------ gcc/rust/typecheck/rust-typecheck-context.cc | 42 +++++++++- 7 files changed, 159 insertions(+), 27 deletions(-) diff --git a/gcc/rust/typecheck/rust-hir-type-check-implitem.cc b/gcc/rust/typecheck/rust-hir-type-check-implitem.cc index f8808351e10c..57f1718e9500 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-implitem.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-implitem.cc @@ -191,7 +191,14 @@ TypeCheckImplItem::Resolve ( bool already_resolved = context->lookup_type (item.get_impl_mappings ().get_hirid (), &resolved); if (already_resolved) - return resolved; + { + bool function_body_pending = false; + if (auto fn = resolved->try_as ()) + function_body_pending = context->function_body_pending (fn->get_id ()); + + if (!function_body_pending) + return resolved; + } // resolve TypeCheckImplItem resolver (parent, self, substitutions); @@ -203,6 +210,22 @@ TypeCheckImplItem::Resolve ( return resolver.result; } +TyTy::FnType * +TypeCheckImplItem::ResolveFunctionSignature ( + HIR::ImplBlock &parent, HIR::Function &function, TyTy::BaseType *self, + std::vector substitutions) +{ + TypeCheckImplItem resolver (parent, self, std::move (substitutions)); + auto binder_pin = resolver.context->push_lifetime_binder (); + resolver.context->block_context ().enter ( + TypeCheckBlockContextItem (&parent)); + TyTy::FnType *result = resolver.resolve_function_signature (function); + resolver.context->block_context ().exit (); + if (result != nullptr) + resolver.context->mark_function_body_pending (result->get_id ()); + return result; +} + TyTy::FnType * TypeCheckImplItem::resolve_function_signature (HIR::Function &function) { @@ -388,6 +411,10 @@ TypeCheckImplItem::visit (HIR::Function &function) if (resolve_fn_type == nullptr) return; + // Mark the body as claimed before resolving it. Recursive queries from the + // body must reuse the cached signature rather than re-entering this body. + context->clear_function_body_pending (resolve_fn_type->get_id ()); + // need to get the return type from this auto expected_ret_tyty = resolve_fn_type->get_return_type (); context->push_return_type (TypeCheckContextItem (parent, &function), diff --git a/gcc/rust/typecheck/rust-hir-type-check-implitem.h b/gcc/rust/typecheck/rust-hir-type-check-implitem.h index cba105434c9e..6cef0353fd1b 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-implitem.h +++ b/gcc/rust/typecheck/rust-hir-type-check-implitem.h @@ -50,6 +50,10 @@ class TypeCheckImplItem : public TypeCheckBase, public HIR::HIRImplVisitor Resolve (HIR::ImplBlock &parent, HIR::ImplItem &item, TyTy::BaseType *self, std::vector substitutions); + static TyTy::FnType *ResolveFunctionSignature ( + HIR::ImplBlock &parent, HIR::Function &function, TyTy::BaseType *self, + std::vector substitutions); + void visit (HIR::Function &function) override; void visit (HIR::ConstantItem &const_item) override; void visit (HIR::TypeAlias &type_alias) override; diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.cc b/gcc/rust/typecheck/rust-hir-type-check-item.cc index 25fa97a368b3..ba4017adc1a3 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-item.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-item.cc @@ -93,7 +93,14 @@ TypeCheckItem::Resolve (HIR::Item &item) bool already_resolved = context->lookup_type (item.get_mappings ().get_hirid (), &resolved); if (already_resolved) - return resolved; + { + bool function_body_pending = false; + if (auto fn = resolved->try_as ()) + function_body_pending = context->function_body_pending (fn->get_id ()); + + if (!function_body_pending) + return resolved; + } rust_assert (item.get_hir_kind () == HIR::Node::BaseKind::VIS_ITEM); HIR::VisItem &vis_item = static_cast (item); @@ -103,6 +110,17 @@ TypeCheckItem::Resolve (HIR::Item &item) return resolver.infered; } +TyTy::FnType * +TypeCheckItem::ResolveFunctionSignature (HIR::Function &function) +{ + TypeCheckItem resolver; + auto lifetime_pin = resolver.context->push_clean_lifetime_resolver (); + TyTy::FnType *result = resolver.resolve_function_signature (function); + if (result != nullptr) + resolver.context->mark_function_body_pending (result->get_id ()); + return result; +} + TyTy::BaseType * TypeCheckItem::ResolveImplItem (HIR::ImplBlock &impl_block, HIR::ImplItem &item) { @@ -114,6 +132,7 @@ TyTy::BaseType * TypeCheckItem::ResolveImplBlockSelf (HIR::ImplBlock &impl_block) { TypeCheckItem resolver; + auto lifetime_pin = resolver.context->push_clean_lifetime_resolver (true); bool failed_flag = false; auto result @@ -135,6 +154,7 @@ TypeCheckItem::ResolveImplBlockSelfWithInference ( TyTy::SubstitutionArgumentMappings *infer_arguments) { TypeCheckItem resolver; + auto lifetime_pin = resolver.context->push_clean_lifetime_resolver (true); bool failed_flag = false; auto result = resolver.resolve_impl_block_substitutions (impl, failed_flag); @@ -876,6 +896,10 @@ TypeCheckItem::visit (HIR::Function &function) if (resolved_fn_type == nullptr) return; + // Mark the body as claimed before resolving it. Recursive queries from the + // body must reuse the cached signature rather than re-entering this body. + context->clear_function_body_pending (resolved_fn_type->get_id ()); + // need to get the return type from this auto expected_ret_tyty = resolved_fn_type->get_return_type (); context->push_return_type (TypeCheckContextItem (&function), diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.h b/gcc/rust/typecheck/rust-hir-type-check-item.h index 389b0fd9af5f..9b223f291ac8 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-item.h +++ b/gcc/rust/typecheck/rust-hir-type-check-item.h @@ -30,6 +30,8 @@ class TypeCheckItem : private TypeCheckBase, private HIR::HIRVisItemVisitor public: static TyTy::BaseType *Resolve (HIR::Item &item); + static TyTy::FnType *ResolveFunctionSignature (HIR::Function &function); + static TyTy::BaseType *ResolveImplItem (HIR::ImplBlock &impl_block, HIR::ImplItem &item); diff --git a/gcc/rust/typecheck/rust-hir-type-check.h b/gcc/rust/typecheck/rust-hir-type-check.h index 916ee2f2d9b6..1e830713ee84 100644 --- a/gcc/rust/typecheck/rust-hir-type-check.h +++ b/gcc/rust/typecheck/rust-hir-type-check.h @@ -209,6 +209,10 @@ class TypeCheckContext bool lookup_type (HirId id, TyTy::BaseType **type) const; void clear_type (TyTy::BaseType *ty); + void mark_function_body_pending (DefId id); + void clear_function_body_pending (DefId id); + bool function_body_pending (DefId id) const; + void insert_implicit_type (HirId id, TyTy::BaseType *type); void insert_type_by_node_id (NodeId ref, HirId id); @@ -239,6 +243,7 @@ class TypeCheckContext bool find_matching_impl_trait_frame (const TraitReference &tref, + TyTy::BaseType &self, struct ImplTraitContextFrame *find) const; bool have_impl_trait_context () const; void push_impl_trait_context (struct ImplTraitContextFrame frame); @@ -329,6 +334,7 @@ class TypeCheckContext std::map node_id_refs; std::map resolved; + std::set function_bodies_pending; std::vector> builtins; std::vector> return_type_stack; diff --git a/gcc/rust/typecheck/rust-type-util.cc b/gcc/rust/typecheck/rust-type-util.cc index 97ff25d43685..1ba486626786 100644 --- a/gcc/rust/typecheck/rust-type-util.cc +++ b/gcc/rust/typecheck/rust-type-util.cc @@ -16,6 +16,7 @@ // along with GCC; see the file COPYING3. If not see // . +#include "rust-hir-item.h" #include "rust-system.h" #include "rust-type-util.h" #include "rust-diagnostics.h" @@ -73,7 +74,21 @@ query_type (HirId reference, TyTy::BaseType **result) { rust_debug_loc (item.value ()->get_locus (), "resolved item {%u} to", reference); - *result = TypeCheckItem::Resolve (*item.value ()); + + DefId item_defid = item.value ()->get_mappings ().get_defid (); + bool is_local = item_defid.crateNum == mappings.get_current_crate (); + bool is_fn + = item.value ()->get_item_kind () == HIR::Item::ItemKind::Function; + if (is_fn && is_local) + { + HIR::Function &fn = *static_cast (item.value ()); + *result = TypeCheckItem::ResolveFunctionSignature (fn); + } + else + { + *result = TypeCheckItem::Resolve (*item.value ()); + } + context->query_completed (reference); return true; } @@ -82,30 +97,33 @@ query_type (HirId reference, TyTy::BaseType **result) { auto impl_block = mappings.lookup_hir_impl_block (impl_item->second).value (); + auto lifetime_pin = context->push_clean_lifetime_resolver (true); - tl::optional guard; - if (impl_block->has_trait_ref ()) + bool failure_flag = false; + auto substitutions + = TypeCheckItem::ResolveImplBlockSubstitutions (*impl_block, + failure_flag); + if (failure_flag) { - bool failure_flag = false; - auto substitutions - = TypeCheckItem::ResolveImplBlockSubstitutions (*impl_block, - failure_flag); - if (failure_flag) - { - context->query_completed (reference); - return false; - } + *result + = TypeCheckItem::ResolveImplItem (*impl_block, *impl_item->first); + context->query_completed (reference); + return true; + } - TyTy::BaseType *self = nullptr; - bool ok - = query_type (impl_block->get_type ().get_mappings ().get_hirid (), - &self); - if (!ok) - { - context->query_completed (reference); - return false; - } + TyTy::BaseType *self = nullptr; + bool ok + = query_type (impl_block->get_type ().get_mappings ().get_hirid (), + &self); + if (!ok) + { + context->query_completed (reference); + return false; + } + tl::optional guard; + if (impl_block->has_trait_ref ()) + { HIR::TypePath &ref = impl_block->get_trait_ref (); auto trait_reference = TraitResolver::Resolve (ref); if (trait_reference->is_error ()) @@ -132,7 +150,19 @@ query_type (HirId reference, TyTy::BaseType **result) rust_debug_loc (impl_item->first->get_locus (), "resolved impl-item {%u} to", reference); - *result = TypeCheckItem::ResolveImplItem (*impl_block, *impl_item->first); + DefId item_defid = impl_item->first->get_impl_mappings ().get_defid (); + bool is_local = item_defid.crateNum == mappings.get_current_crate (); + if (impl_item->first->get_impl_item_type () == HIR::ImplItem::FUNCTION + && is_local) + { + HIR::Function &fn = *static_cast (impl_item->first); + *result = TypeCheckImplItem::ResolveFunctionSignature ( + *impl_block, fn, self, std::move (substitutions)); + } + else + *result = TypeCheckImplItem::Resolve (*impl_block, *impl_item->first, + self, std::move (substitutions)); + context->query_completed (reference); return true; } @@ -606,7 +636,8 @@ normalize_projection (TyTy::ProjectionType *proj, location_t locus, } ImplTraitContextFrame frame; - if (!ctx->find_matching_impl_trait_frame (*proj->get_trait_ref (), &frame)) + if (!ctx->find_matching_impl_trait_frame (*proj->get_trait_ref (), + *proj->get_self (), &frame)) { // No concrete impl frame check WHERE clause bindings on the self type // diff --git a/gcc/rust/typecheck/rust-typecheck-context.cc b/gcc/rust/typecheck/rust-typecheck-context.cc index 5b482dd9f3bb..44744730b53f 100644 --- a/gcc/rust/typecheck/rust-typecheck-context.cc +++ b/gcc/rust/typecheck/rust-typecheck-context.cc @@ -109,6 +109,24 @@ TypeCheckContext::lookup_type (HirId id, TyTy::BaseType **type) const return true; } +void +TypeCheckContext::mark_function_body_pending (DefId id) +{ + function_bodies_pending.insert (id); +} + +void +TypeCheckContext::clear_function_body_pending (DefId id) +{ + function_bodies_pending.erase (id); +} + +bool +TypeCheckContext::function_body_pending (DefId id) const +{ + return function_bodies_pending.find (id) != function_bodies_pending.end (); +} + void TypeCheckContext::clear_type (TyTy::BaseType *ty) { @@ -253,7 +271,8 @@ TypeCheckContext::swap_head_loop_context (TyTy::BaseType *val) bool TypeCheckContext::find_matching_impl_trait_frame ( - const TraitReference &tref, struct ImplTraitContextFrame *find) const + const TraitReference &tref, TyTy::BaseType &self, + struct ImplTraitContextFrame *find) const { if (!have_impl_trait_context ()) return false; @@ -262,7 +281,26 @@ TypeCheckContext::find_matching_impl_trait_frame ( it != impl_trait_frame_stack.rend (); ++it) { const auto &i = *it; - if (i.trait->is_equal (tref)) + if (!i.trait->is_equal (tref)) + continue; + + TyTy::BaseType *resolved_self = &self; + bool unresolved_trait_self = false; + if (auto param = self.try_as ()) + { + if (param->can_resolve ()) + resolved_self = param->resolve (); + else + unresolved_trait_self = param->is_implicit_self_trait (); + } + + bool compatible_self + = unresolved_trait_self + || types_compatable (TyTy::TyWithLocation (i.self), + TyTy::TyWithLocation (resolved_self), + UNDEF_LOCATION, false /* emit_errors */, + false /* check_bounds */); + if (compatible_self) { *find = i; return true; From a348ac46239553e7ede82753faf05449279e1886 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 28 Aug 2026 23:42:09 +0100 Subject: [PATCH 074/584] gccrs: Seperate trait fn signiture resolution from body gcc/rust/ChangeLog: * typecheck/rust-hir-trait-reference.cc (TraitItemReference::get_tyty): early guard (TraitReference::resolve_default_function_bodies): new body resolver * typecheck/rust-hir-trait-reference.h: new prototypes * typecheck/rust-hir-trait-resolve.cc (TraitItemReference::on_resolved): resolve body (TraitItemReference::resolve_default_function_body): likewise (TraitItemReference::resolve_item): clearing pending * typecheck/rust-hir-type-check-item.cc (TypeCheckItem::ResolveTraitSignature): new (TypeCheckItem::resolve_trait): likewise (TypeCheckItem::visit): likewise * typecheck/rust-hir-type-check-item.h: likewise * typecheck/rust-type-util.cc (query_type): get signiture Signed-off-by: Philip Herron --- .../typecheck/rust-hir-trait-reference.cc | 12 +++++++++ gcc/rust/typecheck/rust-hir-trait-reference.h | 4 +++ gcc/rust/typecheck/rust-hir-trait-resolve.cc | 26 ++++++++++++++++++- .../typecheck/rust-hir-type-check-item.cc | 20 ++++++++++++-- gcc/rust/typecheck/rust-hir-type-check-item.h | 4 +++ gcc/rust/typecheck/rust-type-util.cc | 6 +++++ 6 files changed, 69 insertions(+), 3 deletions(-) diff --git a/gcc/rust/typecheck/rust-hir-trait-reference.cc b/gcc/rust/typecheck/rust-hir-trait-reference.cc index 1753988ea52f..9305defc0088 100644 --- a/gcc/rust/typecheck/rust-hir-trait-reference.cc +++ b/gcc/rust/typecheck/rust-hir-trait-reference.cc @@ -75,6 +75,11 @@ TraitItemReference::get_tyty () const { rust_assert (hir_trait_item != nullptr); + TyTy::BaseType *resolved = nullptr; + if (type == FN + && context->lookup_type (get_mappings ().get_hirid (), &resolved)) + return resolved; + switch (type) { case CONST: @@ -355,6 +360,13 @@ TraitReference::on_resolved () } } +void +TraitReference::resolve_default_function_bodies () +{ + for (auto &item : item_refs) + item.resolve_default_function_body (this); +} + bool TraitReference::is_equal (const TraitReference &other) const { diff --git a/gcc/rust/typecheck/rust-hir-trait-reference.h b/gcc/rust/typecheck/rust-hir-trait-reference.h index b26ba0ad547a..b2c62904a8e2 100644 --- a/gcc/rust/typecheck/rust-hir-trait-reference.h +++ b/gcc/rust/typecheck/rust-hir-trait-reference.h @@ -104,6 +104,8 @@ class TraitItemReference // the trait will not be stored in its own map yet void on_resolved (const TraitReference *tref); + void resolve_default_function_body (const TraitReference *tref); + bool is_object_safe () const; private: @@ -209,6 +211,8 @@ class TraitReference void on_resolved (); + void resolve_default_function_bodies (); + bool is_equal (const TraitReference &other) const; std::vector get_super_traits () const; diff --git a/gcc/rust/typecheck/rust-hir-trait-resolve.cc b/gcc/rust/typecheck/rust-hir-trait-resolve.cc index be71f6fabacb..5be1989c55a4 100644 --- a/gcc/rust/typecheck/rust-hir-trait-resolve.cc +++ b/gcc/rust/typecheck/rust-hir-trait-resolve.cc @@ -437,7 +437,12 @@ TraitItemReference::on_resolved (const TraitReference *tref) break; case FN: - resolve_item (tref, static_cast (*hir_trait_item)); + { + TyTy::BaseType *fn_type = get_tyty (); + if (is_optional () && fn_type->get_kind () == TyTy::TypeKind::FNDEF) + context->mark_function_body_pending ( + static_cast (fn_type)->get_id ()); + } break; default: @@ -445,6 +450,24 @@ TraitItemReference::on_resolved (const TraitReference *tref) } } +void +TraitItemReference::resolve_default_function_body (const TraitReference *tref) +{ + if (type != FN || !is_optional ()) + return; + + auto &func = static_cast (*hir_trait_item); + TyTy::BaseType *item_tyty = get_tyty (); + if (item_tyty->get_kind () != TyTy::TypeKind::FNDEF) + return; + + auto fn_type = static_cast (item_tyty); + if (!context->function_body_pending (fn_type->get_id ())) + return; + + resolve_item (tref, func); +} + void TraitItemReference::resolve_item (const TraitReference *tref, HIR::TraitItemType &type) @@ -537,6 +560,7 @@ TraitItemReference::resolve_item (const TraitReference *tref, // need to get the return type from this TyTy::FnType *resolved_fn_type = static_cast (item_tyty); + context->clear_function_body_pending (resolved_fn_type->get_id ()); auto expected_ret_tyty = resolved_fn_type->get_return_type (); context->push_return_type (TypeCheckContextItem (&func), expected_ret_tyty); diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.cc b/gcc/rust/typecheck/rust-hir-type-check-item.cc index ba4017adc1a3..bff50778d86e 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-item.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-item.cc @@ -121,6 +121,13 @@ TypeCheckItem::ResolveFunctionSignature (HIR::Function &function) return result; } +TyTy::BaseType * +TypeCheckItem::ResolveTraitSignature (HIR::Trait &trait) +{ + TypeCheckItem resolver; + return resolver.resolve_trait (trait, false); +} + TyTy::BaseType * TypeCheckItem::ResolveImplItem (HIR::ImplBlock &impl_block, HIR::ImplItem &item) { @@ -962,6 +969,12 @@ TypeCheckItem::visit (HIR::Module &module) void TypeCheckItem::visit (HIR::Trait &trait) +{ + infered = resolve_trait (trait, true); +} + +TyTy::BaseType * +TypeCheckItem::resolve_trait (HIR::Trait &trait, bool resolve_bodies) { auto lifetime_pin = context->push_clean_lifetime_resolver (); @@ -987,11 +1000,14 @@ TypeCheckItem::visit (HIR::Trait &trait) if (trait_ref->is_error ()) { infered = new TyTy::ErrorType (trait.get_mappings ().get_hirid ()); - return; + return infered; } + if (resolve_bodies) + trait_ref->resolve_default_function_bodies (); + RustIdent ident{CanonicalPath::create_empty (), trait.get_locus ()}; - infered = new TyTy::DynamicObjectType ( + return new TyTy::DynamicObjectType ( trait.get_mappings ().get_hirid (), ident, {TyTy::TypeBoundPredicate (*trait_ref, BoundPolarity::RegularBound, trait.get_locus ())}); diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.h b/gcc/rust/typecheck/rust-hir-type-check-item.h index 9b223f291ac8..ed9a4fd0cee8 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-item.h +++ b/gcc/rust/typecheck/rust-hir-type-check-item.h @@ -32,6 +32,8 @@ class TypeCheckItem : private TypeCheckBase, private HIR::HIRVisItemVisitor static TyTy::FnType *ResolveFunctionSignature (HIR::Function &function); + static TyTy::BaseType *ResolveTraitSignature (HIR::Trait &trait); + static TyTy::BaseType *ResolveImplItem (HIR::ImplBlock &impl_block, HIR::ImplItem &item); @@ -92,6 +94,8 @@ class TypeCheckItem : private TypeCheckBase, private HIR::HIRVisItemVisitor TyTy::FnType *resolve_function_signature (HIR::Function &function); + TyTy::BaseType *resolve_trait (HIR::Trait &trait, bool resolve_bodies); + bool validate_repr_simd (const std::vector &fields, location_t locus); diff --git a/gcc/rust/typecheck/rust-type-util.cc b/gcc/rust/typecheck/rust-type-util.cc index 1ba486626786..21559cb2a8df 100644 --- a/gcc/rust/typecheck/rust-type-util.cc +++ b/gcc/rust/typecheck/rust-type-util.cc @@ -84,6 +84,12 @@ query_type (HirId reference, TyTy::BaseType **result) HIR::Function &fn = *static_cast (item.value ()); *result = TypeCheckItem::ResolveFunctionSignature (fn); } + else if (item.value ()->get_item_kind () == HIR::Item::ItemKind::Trait + && is_local) + { + HIR::Trait &trait = *static_cast (item.value ()); + *result = TypeCheckItem::ResolveTraitSignature (trait); + } else { *result = TypeCheckItem::Resolve (*item.value ()); From a0c4d677b3c00d5cbb42d783983fbe927106134f Mon Sep 17 00:00:00 2001 From: Yap Zhi Heng Date: Sun, 23 Aug 2026 15:34:47 +0800 Subject: [PATCH 075/584] gccrs: Make gcc targetm builtins available to the Rust front end This is part of making LLVM builtins work for gccrs. gcc/rust/ChangeLog: * backend/rust-builtins.h (BuiltinsContext::SetupState): New enum. * backend/rust-builtins.cc (BuiltinsContext::get): Ensure that BuiltinsContext is only initialized once. (BuiltinsContext::BuiltinsContext): Likewise. (BuiltinsContext::setup): Call targetm.init_builtins to make GCC builtins available to the frontend. * rust-gcc.cc (init): Eagerly initialize BuiltinsContext. Signed-Off-By: Yap Zhi Heng --- gcc/rust/backend/rust-builtins.cc | 13 ++++++++++++- gcc/rust/backend/rust-builtins.h | 9 +++++++++ gcc/rust/rust-gcc.cc | 3 +++ 3 files changed, 24 insertions(+), 1 deletion(-) diff --git a/gcc/rust/backend/rust-builtins.cc b/gcc/rust/backend/rust-builtins.cc index d4b072a03e7c..9914b6badbb5 100644 --- a/gcc/rust/backend/rust-builtins.cc +++ b/gcc/rust/backend/rust-builtins.cc @@ -29,6 +29,10 @@ BuiltinsContext & BuiltinsContext::get () { static BuiltinsContext instance; + + if (instance.setup_state == SetupState::UNINITIALIZED) + instance.setup (); + return instance; } @@ -44,7 +48,7 @@ BuiltinsContext::lookup_simple_builtin (const std::string &name, tree *builtin) return lookup_gcc_builtin (*to_search, builtin); } -BuiltinsContext::BuiltinsContext () { setup (); } +BuiltinsContext::BuiltinsContext () : setup_state (SetupState::UNINITIALIZED) {} /** * Define a function type according to `builtin-types.def` @@ -358,11 +362,18 @@ BuiltinsContext::register_rust_mappings () void BuiltinsContext::setup () { + rust_assert (setup_state == SetupState::UNINITIALIZED); + setup_state = SetupState::INITIALIZING; + define_builtin_types (); define_builtin_attributes (); define_builtins (); + targetm.init_builtins (); + register_rust_mappings (); + + setup_state = SetupState::READY; } bool diff --git a/gcc/rust/backend/rust-builtins.h b/gcc/rust/backend/rust-builtins.h index 22250fa8905a..7819a7c03491 100644 --- a/gcc/rust/backend/rust-builtins.h +++ b/gcc/rust/backend/rust-builtins.h @@ -166,6 +166,15 @@ class BuiltinsContext ATTR_LAST, }; + enum class SetupState + { + UNINITIALIZED, + INITIALIZING, + READY, + }; + + SetupState setup_state; + /** * All builtin types, as defined in `builtin-types.def` * diff --git a/gcc/rust/rust-gcc.cc b/gcc/rust/rust-gcc.cc index ada66a2c7c6b..c1f6002e8163 100644 --- a/gcc/rust/rust-gcc.cc +++ b/gcc/rust/rust-gcc.cc @@ -333,6 +333,9 @@ init () // this->define_builtin (BUILT_IN_ATOMIC_FETCH_OR_1, "__atomic_fetch_or_1", // NULL, // t, 0); + + // eagerly initialize BuiltinsContext + (void) Rust::Compile::BuiltinsContext::get (); } void From 1ed514a029dc071a60713e480cc0d980c0293faf Mon Sep 17 00:00:00 2001 From: Yap Zhi Heng Date: Sun, 23 Aug 2026 15:46:45 +0800 Subject: [PATCH 076/584] gccrs: Initial implementation of LLVM builtin to GCC adapter Only works for rdseed, rdrand, addcarry and subborrow for now. Compiled 006t.original output from compiling llvm_builtins.rs: ``` struct (u16, i32) x86_rdrand16_step () { u16 RUSTTMP.0; i32 RUSTTMP.1; RUSTTMP.1 = __builtin_ia32_rdrand16_step (&RUSTTMP.0); return {.__0=RUSTTMP.0, .__1=RUSTTMP.1}; } struct (u32, i32) x86_rdrand32_step () { u32 RUSTTMP.2; i32 RUSTTMP.3; RUSTTMP.3 = __builtin_ia32_rdrand32_step (&RUSTTMP.2); return {.__0=RUSTTMP.2, .__1=RUSTTMP.3}; } struct (u64, i32) x86_rdrand64_step () { u64 RUSTTMP.4; i32 RUSTTMP.5; RUSTTMP.5 = __builtin_ia32_rdrand64_step ((unsigned long *) &RUSTTMP.4); return {.__0=RUSTTMP.4, .__1=RUSTTMP.5}; } struct (u16, i32) x86_rdseed16_step () { u16 RUSTTMP.6; i32 RUSTTMP.7; RUSTTMP.7 = __builtin_ia32_rdseed_hi_step (&RUSTTMP.6); return {.__0=RUSTTMP.6, .__1=RUSTTMP.7}; } struct (u32, i32) x86_rdseed32_step () { u32 RUSTTMP.8; i32 RUSTTMP.9; RUSTTMP.9 = __builtin_ia32_rdseed_si_step (&RUSTTMP.8); return {.__0=RUSTTMP.8, .__1=RUSTTMP.9}; } struct (u64, i32) x86_rdseed64_step () { u64 RUSTTMP.10; i32 RUSTTMP.11; RUSTTMP.11 = __builtin_ia32_rdseed_di_step ((unsigned long *) &RUSTTMP.10); return {.__0=RUSTTMP.10, .__1=RUSTTMP.11}; } struct (u8, u32) llvm_addcarry_u32 (const u8 a, const u32 b, const u32 c) { u32 RUSTTMP.12; u8 RUSTTMP.13; RUSTTMP.13 = (u8) __builtin_ia32_addcarryx_u32 ((unsigned char) a, (u32) b, (u32) c, &RUSTTMP.12); return {.__0=RUSTTMP.13, .__1=RUSTTMP.12}; } struct (u8, u32) llvm_subborrow_u32 (const u8 a, const u32 b, const u32 c) { u32 RUSTTMP.14; u8 RUSTTMP.15; RUSTTMP.15 = (u8) __builtin_ia32_sbb_u32 ((unsigned char) a, (u32) b, (u32) c, &RUSTTMP.14); return {.__0=RUSTTMP.15, .__1=RUSTTMP.14}; } struct (u8, u64) llvm_addcarry_u64 (const u8 a, const u64 b, const u64 c) { u64 RUSTTMP.16; u8 RUSTTMP.17; RUSTTMP.17 = (u8) __builtin_ia32_addcarryx_u64 ((unsigned char) a, (unsigned long) b, (unsigned long) c, (unsigned long *) &RUSTTMP.16); return {.__0=RUSTTMP.17, .__1=RUSTTMP.16}; } struct (u8, u64) llvm_subborrow_u64 (const u8 a, const u64 b, const u64 c) { u64 RUSTTMP.18; u8 RUSTTMP.19; RUSTTMP.19 = (u8) __builtin_ia32_sbb_u64 ((unsigned char) a, (unsigned long) b, (unsigned long) c, (unsigned long *) &RUSTTMP.18); return {.__0=RUSTTMP.19, .__1=RUSTTMP.18}; } ``` gcc/rust/ChangeLog: * backend/rust-builtins.h (LlvmBuiltinMappingResult): New enum. (LlvmBuiltinAdapter): New enum. (LlvmBuiltinMapping): New enum. (BuiltinsContext::map_llvm_to_gcc_builtin): New function for LLVM built-in mapping. (BuiltinsContext::register_builtin): New function for registering built-ins. (BuiltinsContext::register_llvm_to_gcc_builtin): New function. (BuiltinsContext::llvm_to_gcc_builtin): New map to translate function names. * backend/rust-builtins.cc (BuiltinsContext::map_llvm_to_gcc_builtin): Implementation. (BuiltinsContext::register_llvm_to_gcc_builtin): Implementation. (BuiltinsContext::register_builtin): Implementation. (BuiltinsContext::setup): Call register_llvm_to_gcc_builtin during setup. * rust-lang.cc (grs_langhook_builtin_function): Register GCC built-in functions. * backend/rust-compile-extern.h (CompileExternItem::OutputTupleOrder): New enum to denote the tuple field order of the LLVM built-in's return type. (CompileExternItem::compile_x86_output_pointer_adapter): New function to adapt LLVM's rdseed, rdrand, addcarry, subborrow function signatures to GCC's equivalents. (CompileExternItem::visit (HIR::ExternalFunctionItem)): Handle UNADJUSTED ABI case by properly resolving LLVM intrinsic function names. Signed-off-by: Yap Zhi Heng --- gcc/rust/backend/rust-builtins.cc | 71 +++++++ gcc/rust/backend/rust-builtins.h | 28 +++ gcc/rust/backend/rust-compile-extern.h | 213 ++++++++++++++++++++ gcc/rust/rust-lang.cc | 6 +- gcc/testsuite/rust/compile/llvm_builtins.rs | 50 +++++ 5 files changed, 366 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/rust/compile/llvm_builtins.rs diff --git a/gcc/rust/backend/rust-builtins.cc b/gcc/rust/backend/rust-builtins.cc index 9914b6badbb5..569c42576e03 100644 --- a/gcc/rust/backend/rust-builtins.cc +++ b/gcc/rust/backend/rust-builtins.cc @@ -48,6 +48,25 @@ BuiltinsContext::lookup_simple_builtin (const std::string &name, tree *builtin) return lookup_gcc_builtin (*to_search, builtin); } +LlvmBuiltinMappingResult +BuiltinsContext::map_llvm_to_gcc_builtin (const std::string &name, + tree *resolved, + LlvmBuiltinAdapter *adapter) +{ + rust_assert (resolved != nullptr); + + auto mapping = llvm_to_gcc_builtin.find (name); + if (mapping == llvm_to_gcc_builtin.end ()) + return LlvmBuiltinMappingResult::NOT_MAPPED; + + *resolved = NULL_TREE; + if (!lookup_gcc_builtin (mapping->second.gcc_name, resolved)) + return LlvmBuiltinMappingResult::TARGET_UNAVAILABLE; + + *adapter = mapping->second.adapter; + return LlvmBuiltinMappingResult::RESOLVED; +} + BuiltinsContext::BuiltinsContext () : setup_state (SetupState::UNINITIALIZED) {} /** @@ -359,6 +378,57 @@ BuiltinsContext::register_rust_mappings () }; } +void +BuiltinsContext::register_llvm_to_gcc_builtin () +{ + llvm_to_gcc_builtin = { + {"llvm.x86.rdrand.16", + {"__builtin_ia32_rdrand16_step", + LlvmBuiltinAdapter::OUTPUT_POINTER_VALUE_STATUS}}, + {"llvm.x86.rdrand.32", + {"__builtin_ia32_rdrand32_step", + LlvmBuiltinAdapter::OUTPUT_POINTER_VALUE_STATUS}}, + {"llvm.x86.rdrand.64", + {"__builtin_ia32_rdrand64_step", + LlvmBuiltinAdapter::OUTPUT_POINTER_VALUE_STATUS}}, + {"llvm.x86.rdseed.16", + {"__builtin_ia32_rdseed_hi_step", + LlvmBuiltinAdapter::OUTPUT_POINTER_VALUE_STATUS}}, + {"llvm.x86.rdseed.32", + {"__builtin_ia32_rdseed_si_step", + LlvmBuiltinAdapter::OUTPUT_POINTER_VALUE_STATUS}}, + {"llvm.x86.rdseed.64", + {"__builtin_ia32_rdseed_di_step", + LlvmBuiltinAdapter::OUTPUT_POINTER_VALUE_STATUS}}, + + {"llvm.x86.addcarry.32", + {"__builtin_ia32_addcarryx_u32", + LlvmBuiltinAdapter::OUTPUT_POINTER_STATUS_VALUE}}, + {"llvm.x86.addcarryx.u32", + {"__builtin_ia32_addcarryx_u32", LlvmBuiltinAdapter::FORWARD_ARGUMENTS}}, + {"llvm.x86.subborrow.32", + {"__builtin_ia32_sbb_u32", + LlvmBuiltinAdapter::OUTPUT_POINTER_STATUS_VALUE}}, + {"llvm.x86.addcarry.64", + {"__builtin_ia32_addcarryx_u64", + LlvmBuiltinAdapter::OUTPUT_POINTER_STATUS_VALUE}}, + {"llvm.x86.addcarryx.u64", + {"__builtin_ia32_addcarryx_u64", LlvmBuiltinAdapter::FORWARD_ARGUMENTS}}, + {"llvm.x86.subborrow.64", + {"__builtin_ia32_sbb_u64", + LlvmBuiltinAdapter::OUTPUT_POINTER_STATUS_VALUE}}}; +} + +void +BuiltinsContext::register_builtin (tree decl) +{ + rust_assert (TREE_CODE (decl) == FUNCTION_DECL); + rust_assert (DECL_NAME (decl)); + + const char *name = IDENTIFIER_POINTER (DECL_NAME (decl)); + builtin_functions.insert ({std::string (name), decl}); +} + void BuiltinsContext::setup () { @@ -372,6 +442,7 @@ BuiltinsContext::setup () targetm.init_builtins (); register_rust_mappings (); + register_llvm_to_gcc_builtin (); setup_state = SetupState::READY; } diff --git a/gcc/rust/backend/rust-builtins.h b/gcc/rust/backend/rust-builtins.h index 7819a7c03491..e2c7f9816f9a 100644 --- a/gcc/rust/backend/rust-builtins.h +++ b/gcc/rust/backend/rust-builtins.h @@ -79,6 +79,26 @@ namespace Compile { // }; // Some(cx.get_intrinsic(&llvm_name)) +enum class LlvmBuiltinMappingResult +{ + NOT_MAPPED, + TARGET_UNAVAILABLE, + RESOLVED, +}; + +enum class LlvmBuiltinAdapter +{ + OUTPUT_POINTER_VALUE_STATUS, + OUTPUT_POINTER_STATUS_VALUE, + FORWARD_ARGUMENTS, +}; + +struct LlvmBuiltinMapping +{ + std::string gcc_name; + LlvmBuiltinAdapter adapter; +}; + class BuiltinsContext { public: @@ -86,6 +106,12 @@ class BuiltinsContext bool lookup_simple_builtin (const std::string &name, tree *builtin); + LlvmBuiltinMappingResult + map_llvm_to_gcc_builtin (const std::string &name, tree *resolved, + LlvmBuiltinAdapter *adapter); + + void register_builtin (tree decl); + private: enum Type { @@ -199,6 +225,7 @@ class BuiltinsContext void define_builtins (); void register_rust_mappings (); + void register_llvm_to_gcc_builtin (); BuiltinsContext (); @@ -213,6 +240,7 @@ class BuiltinsContext // A mapping of the GCC built-ins exposed to GCC Rust. std::map builtin_functions; std::map rust_intrinsic_to_gcc_builtin; + std::map llvm_to_gcc_builtin; }; } // namespace Compile diff --git a/gcc/rust/backend/rust-compile-extern.h b/gcc/rust/backend/rust-compile-extern.h index 4eabf0ddb853..f9aecef5b873 100644 --- a/gcc/rust/backend/rust-compile-extern.h +++ b/gcc/rust/backend/rust-compile-extern.h @@ -26,6 +26,9 @@ #include "rust-hir-full-decls.h" #include "rust-attributes.h" #include "rust-attribute-values.h" +#include "rust-builtins.h" +#include "rust-compile-fnparam.h" +#include "fold-const.h" namespace Rust { namespace Compile { @@ -127,6 +130,68 @@ class CompileExternItem : public HIRCompileBase, std::string ir_symbol_name = function.get_item_name ().as_string (); GGC::Ident asm_name = get_link_name (function); + if (fntype->get_abi () == ABI::UNADJUSTED) + { + tree resolved; + LlvmBuiltinAdapter adapter; + auto mapping_res = BuiltinsContext::get ().map_llvm_to_gcc_builtin ( + asm_name.as_string (), &resolved, &adapter); + + switch (mapping_res) + { + case LlvmBuiltinMappingResult::NOT_MAPPED: + rust_error_at (function.get_locus (), + "LLVM intrinsic %qs is not supported at the moment", + asm_name.c_str ()); + reference = error_mark_node; + return; + case LlvmBuiltinMappingResult::TARGET_UNAVAILABLE: + rust_error_at ( + function.get_locus (), + "LLVM intrinsic %qs is not available for this target", + asm_name.c_str ()); + reference = error_mark_node; + return; + case LlvmBuiltinMappingResult::RESOLVED: + break; + } + + tree adapter_tree = error_mark_node; + + switch (adapter) + { + case LlvmBuiltinAdapter::OUTPUT_POINTER_VALUE_STATUS: + adapter_tree = compile_x86_output_pointer_adapter ( + ctx, fntype, resolved, OutputTupleOrder::VALUE_STATUS, + function.get_locus ()); + break; + case LlvmBuiltinAdapter::OUTPUT_POINTER_STATUS_VALUE: + adapter_tree = compile_x86_output_pointer_adapter ( + ctx, fntype, resolved, OutputTupleOrder::STATUS_VALUE, + function.get_locus ()); + break; + case LlvmBuiltinAdapter::FORWARD_ARGUMENTS: + // TODO placeholder + adapter_tree = compile_x86_output_pointer_adapter ( + ctx, fntype, resolved, OutputTupleOrder::STATUS_VALUE, + function.get_locus ()); + break; + } + + if (adapter_tree == error_mark_node) + { + rust_error_at (function.get_locus (), + "Invalid signature for LLVM intrinsic %qs", + asm_name.c_str ()); + reference = error_mark_node; + return; + } + + ctx->insert_function_decl (fntype, adapter_tree); + reference = address_expression (adapter_tree, ref_locus); + return; + } + const unsigned int flags = Backend::function_is_declaration; tree fndecl = Backend::function (compiled_fn_type, ir_symbol_name, asm_name, flags, function.get_locus ()); @@ -144,6 +209,12 @@ class CompileExternItem : public HIRCompileBase, } private: + enum class OutputTupleOrder + { + VALUE_STATUS, + STATUS_VALUE, + }; + CompileExternItem (Context *ctx, TyTy::BaseType *concrete, location_t ref_locus) : HIRCompileBase (ctx), concrete (concrete), reference (error_mark_node), @@ -180,6 +251,148 @@ class CompileExternItem : public HIRCompileBase, return obj.get_item_name (); } + /** + * Compiles a wrapper that wraps around GCC built-ins for compatibility + * with LLVM built-ins function signatures returning a tuple with value + + * status. + * + * @param ctx + * @param fntype the LLVM built-in function type + * @param gcc_builtin the GCC built-in function + * @param order whether the LLVM built-in returns (value, status) or (status, + * value) + * @param locus + * @return tree + */ + static tree compile_x86_output_pointer_adapter (Context *ctx, + TyTy::FnType *fntype, + tree gcc_builtin, + OutputTupleOrder order, + location_t locus) + { + // expect to be a 2-field tuple return type + TyTy::TupleType *tuple + = fntype->get_return_type ()->try_as (); + + if (tuple == nullptr || tuple->num_fields () != 2) + // TODO probably add error here + return error_mark_node; + + tree compiled_fn_type = TyTyResolveCompile::compile (ctx, fntype); + + const auto &path = fntype->get_ident ().path; + std::string ir_name = path.get () + fntype->subst_as_string (); + std::string asm_name = ctx->mangle_item (fntype, path); + + // start building the wrapper function + tree fndecl + = Backend::function (compiled_fn_type, ir_name, asm_name, 0, locus); + + TREE_PUBLIC (fndecl) = 0; + DECL_ARTIFICIAL (fndecl) = 1; + DECL_EXTERNAL (fndecl) = 0; + DECL_DECLARED_INLINE_P (fndecl) = 1; + + // compile params for the rust wrapper + std::vector param_vars; + param_vars.reserve (fntype->get_params ().size ()); + for (auto ¶m : fntype->get_params ()) + { + auto &pattern = param.get_pattern (); + tree type = TyTyResolveCompile::compile (ctx, param.get_type ()); + Bvariable *variable + = CompileFnParam::compile (ctx, fndecl, pattern, type, + pattern.get_locus ()); + param_vars.emplace_back (variable); + } + + if (!Backend::function_set_parameters (fndecl, param_vars)) + return error_mark_node; + + // forward the rust params, convert each into the corresponding gcc + // built-in param type + std::vector call_arguments; + // +1 here because gcc built-in expects output pointer as param + call_arguments.reserve (param_vars.size () + 1); + tree gcc_argument_types = TYPE_ARG_TYPES (TREE_TYPE (gcc_builtin)); + for (Bvariable *param : param_vars) + { + tree argument = param->get_tree (locus); + tree expected_type = TREE_VALUE (gcc_argument_types); + argument = Backend::convert_expression (expected_type, argument, locus); + call_arguments.emplace_back (argument); + gcc_argument_types = TREE_CHAIN (gcc_argument_types); + } + + // the order of llvm built-ins' tuple return types' fields is not + // consistent, some are (value, status) and others are (status, value), so + // we need to reorder it... + tree tuple_type = TREE_TYPE (DECL_RESULT (fndecl)); + tree first_field = TYPE_FIELDS (tuple_type); + tree second_field = DECL_CHAIN (first_field); + + tree value_field + = order == OutputTupleOrder::VALUE_STATUS ? first_field : second_field; + tree status_field + = order == OutputTupleOrder::VALUE_STATUS ? second_field : first_field; + + tree value_type = TREE_TYPE (value_field); + tree status_type = TREE_TYPE (status_field); + + tree temporary_stmt = NULL_TREE; + Bvariable *value + = Backend::temporary_variable (fndecl, NULL_TREE, value_type, NULL_TREE, + true, locus, &temporary_stmt); + Bvariable *status + = Backend::temporary_variable (fndecl, NULL_TREE, status_type, NULL_TREE, + false, locus, &temporary_stmt); + + // compile the final gcc built-in param which is the output value pointer, + // which llvm returns as part of the tuple return type + tree gcc_pointer_type = TREE_VALUE (gcc_argument_types); + tree block + = Backend::block (fndecl, NULL_TREE, {value, status}, locus, locus); + ctx->push_block (block); + + tree value_decl = value->get_tree (locus); + tree status_decl = status->get_tree (locus); + + tree value_address = build_fold_addr_expr_loc (locus, value_decl); + value_address + = Backend::convert_expression (gcc_pointer_type, value_address, locus); + call_arguments.emplace_back (value_address); + + // call the gcc built-in with the params that were built and assign the + // returned val to the status temp var + tree builtin_call + = build_call_expr_loc_array (locus, gcc_builtin, + static_cast (call_arguments.size ()), + call_arguments.data ()); + builtin_call + = Backend::convert_expression (status_type, builtin_call, locus); + ctx->add_statement ( + Backend::assignment_statement (status_decl, builtin_call, locus)); + + // finally compile and add the return statement + std::vector tuple_values; + if (order == OutputTupleOrder::VALUE_STATUS) + tuple_values = {value_decl, status_decl}; + else + tuple_values = {status_decl, value_decl}; + + tree tuple_result + = Backend::constructor_expression (tuple_type, false, tuple_values, -1, + locus); + ctx->add_statement ( + Backend::return_statement (fndecl, tuple_result, locus)); + + tree body = ctx->pop_block (); + DECL_SAVED_TREE (fndecl) = body; + + ctx->push_function (fndecl); + return fndecl; + } + TyTy::BaseType *concrete; tree reference; location_t ref_locus; diff --git a/gcc/rust/rust-lang.cc b/gcc/rust/rust-lang.cc index dc39bc053d0e..52f6e5a5b12a 100644 --- a/gcc/rust/rust-lang.cc +++ b/gcc/rust/rust-lang.cc @@ -38,6 +38,7 @@ #include "optional.h" #include "rust-unicode.h" #include "rust-punycode.h" +#include "rust-builtins.h" #include // note: header files must be in this order or else forward declarations don't @@ -226,10 +227,11 @@ grs_langhook_type_for_mode (machine_mode mode, int unsignedp) return NULL; } -// Record a builtin function. We just ignore builtin functions. +// Record a builtin function. static tree -grs_langhook_builtin_function (tree decl ATTRIBUTE_UNUSED) +grs_langhook_builtin_function (tree decl) { + Rust::Compile::BuiltinsContext::get ().register_builtin (decl); return decl; } diff --git a/gcc/testsuite/rust/compile/llvm_builtins.rs b/gcc/testsuite/rust/compile/llvm_builtins.rs new file mode 100644 index 000000000000..6503c0be2bde --- /dev/null +++ b/gcc/testsuite/rust/compile/llvm_builtins.rs @@ -0,0 +1,50 @@ +// { dg-options "-mrdrnd" } +#![feature(no_core, abi_unadjusted)] +#![no_core] + +#[allow(improper_ctypes)] +extern "unadjusted" { + #[link_name = "llvm.x86.rdrand.16"] + fn x86_rdrand16_step() -> (u16, i32); + #[link_name = "llvm.x86.rdrand.32"] + fn x86_rdrand32_step() -> (u32, i32); + #[link_name = "llvm.x86.rdrand.64"] + fn x86_rdrand64_step() -> (u64, i32); + #[link_name = "llvm.x86.rdseed.16"] + fn x86_rdseed16_step() -> (u16, i32); + #[link_name = "llvm.x86.rdseed.32"] + fn x86_rdseed32_step() -> (u32, i32); + #[link_name = "llvm.x86.rdseed.64"] + fn x86_rdseed64_step() -> (u64, i32); + + #[link_name = "llvm.x86.addcarry.32"] + fn llvm_addcarry_u32(a: u8, b: u32, c: u32) -> (u8, u32); + // #[link_name = "llvm.x86.addcarryx.u32"] + // fn llvm_addcarryx_u32(a: u8, b: u32, c: u32, d: *mut u8) -> u8; + #[link_name = "llvm.x86.subborrow.32"] + fn llvm_subborrow_u32(a: u8, b: u32, c: u32) -> (u8, u32); + #[link_name = "llvm.x86.addcarry.64"] + fn llvm_addcarry_u64(a: u8, b: u64, c: u64) -> (u8, u64); + // #[link_name = "llvm.x86.addcarryx.u64"] + // fn llvm_addcarryx_u64(a: u8, b: u64, c: u64, d: *mut u8) -> u8; + #[link_name = "llvm.x86.subborrow.64"] + fn llvm_subborrow_u64(a: u8, b: u64, c: u64) -> (u8, u64); + + // #[link_name = "llvm.x86.vcvtph2ps.128"] + // fn llvm_vcvtph2ps_128(a: i16x8) -> f32x4; + // #[link_name = "llvm.x86.vcvtph2ps.256"] + // fn llvm_vcvtph2ps_256(a: i16x8) -> f32x8; + // #[link_name = "llvm.x86.vcvtps2ph.128"] + // fn llvm_vcvtps2ph_128(a: f32x4, rounding: i32) -> i16x8; + // #[link_name = "llvm.x86.vcvtps2ph.256"] + // fn llvm_vcvtps2ph_256(a: f32x8, rounding: i32) -> i16x8; +} + +fn main() { + let (_status2, _v1) = unsafe { + llvm_addcarry_u32(0, 1, 2) + }; + let (_v2, _status2) = unsafe { + x86_rdrand16_step() + }; +} From 29605ae6596503a587700d854e2dbdd994cbaa61 Mon Sep 17 00:00:00 2001 From: Yap Zhi Heng Date: Sat, 29 Aug 2026 16:11:37 +0800 Subject: [PATCH 077/584] gccrs: Implement 1-to-1 adapters for compiling LLVM built-ins signatures with GCC built-ins Similar to the previous commit, but for FORWARD_ARGUMENTS cases in CompileExternItem::visit (ExternalFunctionItem). Compiled 006t.original output from compiling llvm_builtins.rs for only the enabled FORWARD_ARGUMENT cases (): ``` u8 llvm_addcarryx_u32 (const u8 a, const u32 b, const u32 c, u8 * const {ref-all} d) { return (u8) __builtin_ia32_addcarryx_u32 ((unsigned char) a, (u32) b, (u32) c, (u32 *) d); } u8 llvm_addcarryx_u64 (const u8 a, const u64 b, const u64 c, u8 * const {ref-all} d) { return (u8) __builtin_ia32_addcarryx_u64 ((unsigned char) a, (unsigned long) b, (unsigned long) c, (unsigned long *) d); } ``` vcvtph2ps and vcvtps2ph functions are not supported yet as gccrs doesn't support SIMD types yet. gcc/rust/ChangeLog: * backend/rust-builtins.cc (BuiltinsContext::register_llvm_to_gcc_builtin): Add entries for vcvtph2ps & vcvtps2ph cases (currently unused due to the reason mentioned above). * backend/rust-compile-extern.h (CompileExternItem::visit(HIR::ExternalFunctionItem)): Remove placeholder function in the FORWARD_ARGUMENTS case under compilation of UNADJUSTED ABI. (CompileExternItem::compile_x86_forwarding_adapter): New function to adapt LLVM's addcarryx function signatures by simply forwarding the parameters and return var without changes. gcc/testsuite/ChangeLog: * rust/compile/llvm_builtins.rs: Enable addcarryx cases, add TODO comment for vcvtph2ps & vcvtps2ph cases. Signed-off-by: Yap Zhi Heng --- gcc/rust/backend/rust-builtins.cc | 12 ++- gcc/rust/backend/rust-compile-extern.h | 88 +++++++++++++++++++-- gcc/testsuite/rust/compile/llvm_builtins.rs | 10 ++- 3 files changed, 100 insertions(+), 10 deletions(-) diff --git a/gcc/rust/backend/rust-builtins.cc b/gcc/rust/backend/rust-builtins.cc index 569c42576e03..de2d97eb1de5 100644 --- a/gcc/rust/backend/rust-builtins.cc +++ b/gcc/rust/backend/rust-builtins.cc @@ -416,7 +416,17 @@ BuiltinsContext::register_llvm_to_gcc_builtin () {"__builtin_ia32_addcarryx_u64", LlvmBuiltinAdapter::FORWARD_ARGUMENTS}}, {"llvm.x86.subborrow.64", {"__builtin_ia32_sbb_u64", - LlvmBuiltinAdapter::OUTPUT_POINTER_STATUS_VALUE}}}; + LlvmBuiltinAdapter::OUTPUT_POINTER_STATUS_VALUE}}, + + {"llvm.x86.vcvtph2ps.128", + {"__builtin_ia32_vcvtph2ps", LlvmBuiltinAdapter::FORWARD_ARGUMENTS}}, + {"llvm.x86.vcvtph2ps.256", + {"__builtin_ia32_vcvtph2ps256", LlvmBuiltinAdapter::FORWARD_ARGUMENTS}}, + {"llvm.x86.vcvtps2ph.128", + {"__builtin_ia32_vcvtps2ph", LlvmBuiltinAdapter::FORWARD_ARGUMENTS}}, + {"llvm.x86.vcvtps2ph.256", + {"__builtin_ia32_vcvtps2ph256", LlvmBuiltinAdapter::FORWARD_ARGUMENTS}}, + }; } void diff --git a/gcc/rust/backend/rust-compile-extern.h b/gcc/rust/backend/rust-compile-extern.h index f9aecef5b873..b2237b77c246 100644 --- a/gcc/rust/backend/rust-compile-extern.h +++ b/gcc/rust/backend/rust-compile-extern.h @@ -171,10 +171,9 @@ class CompileExternItem : public HIRCompileBase, function.get_locus ()); break; case LlvmBuiltinAdapter::FORWARD_ARGUMENTS: - // TODO placeholder - adapter_tree = compile_x86_output_pointer_adapter ( - ctx, fntype, resolved, OutputTupleOrder::STATUS_VALUE, - function.get_locus ()); + adapter_tree + = compile_x86_forwarding_adapter (ctx, fntype, resolved, + function.get_locus ()); break; } @@ -262,7 +261,7 @@ class CompileExternItem : public HIRCompileBase, * @param order whether the LLVM built-in returns (value, status) or (status, * value) * @param locus - * @return tree + * @return tree the resultant wrapper function */ static tree compile_x86_output_pointer_adapter (Context *ctx, TyTy::FnType *fntype, @@ -393,6 +392,85 @@ class CompileExternItem : public HIRCompileBase, return fndecl; } + /** + * Compiles a 1-to-1 wrapper for LLVM built-ins that wraps around GCC + * built-ins. + * + * @param ctx + * @param fntype the LLVM built-in function type + * @param gcc_builtin the GCC built-in function + * @param locus + * @return tree the resultant wrapper function + */ + static tree compile_x86_forwarding_adapter (Context *ctx, + TyTy::FnType *fntype, + tree gcc_builtin, + location_t locus) + { + tree compiled_fn_type = TyTyResolveCompile::compile (ctx, fntype); + + const auto &path = fntype->get_ident ().path; + std::string ir_name = path.get () + fntype->subst_as_string (); + std::string asm_name = ctx->mangle_item (fntype, path); + + // start building the wrapper function + tree fndecl + = Backend::function (compiled_fn_type, ir_name, asm_name, 0, locus); + + TREE_PUBLIC (fndecl) = 0; + DECL_ARTIFICIAL (fndecl) = 1; + DECL_EXTERNAL (fndecl) = 0; + DECL_DECLARED_INLINE_P (fndecl) = 1; + + // compile params for the rust wrapper + std::vector param_vars; + param_vars.reserve (fntype->get_params ().size ()); + for (auto ¶m : fntype->get_params ()) + { + auto &pattern = param.get_pattern (); + tree type = TyTyResolveCompile::compile (ctx, param.get_type ()); + Bvariable *variable + = CompileFnParam::compile (ctx, fndecl, pattern, type, + pattern.get_locus ()); + param_vars.emplace_back (variable); + } + + if (!Backend::function_set_parameters (fndecl, param_vars)) + return error_mark_node; + + // forward the rust params, convert each into the corresponding gcc + // built-in param type + std::vector call_arguments; + call_arguments.reserve (param_vars.size ()); + tree gcc_argument_types = TYPE_ARG_TYPES (TREE_TYPE (gcc_builtin)); + for (Bvariable *param : param_vars) + { + tree argument = param->get_tree (locus); + tree expected_type = TREE_VALUE (gcc_argument_types); + argument = Backend::convert_expression (expected_type, argument, locus); + call_arguments.emplace_back (argument); + gcc_argument_types = TREE_CHAIN (gcc_argument_types); + } + + tree builtin_call + = build_call_expr_loc_array (locus, gcc_builtin, + static_cast (call_arguments.size ()), + call_arguments.data ()); + tree wrapper_ret_type = TREE_TYPE (DECL_RESULT (fndecl)); + + builtin_call + = Backend::convert_expression (wrapper_ret_type, builtin_call, locus); + tree block = Backend::block (fndecl, NULL_TREE, {}, locus, locus); + ctx->push_block (block); + ctx->add_statement ( + Backend::return_statement (fndecl, builtin_call, locus)); + tree body = ctx->pop_block (); + DECL_SAVED_TREE (fndecl) = body; + + ctx->push_function (fndecl); + return fndecl; + } + TyTy::BaseType *concrete; tree reference; location_t ref_locus; diff --git a/gcc/testsuite/rust/compile/llvm_builtins.rs b/gcc/testsuite/rust/compile/llvm_builtins.rs index 6503c0be2bde..7f44eb02fa9d 100644 --- a/gcc/testsuite/rust/compile/llvm_builtins.rs +++ b/gcc/testsuite/rust/compile/llvm_builtins.rs @@ -19,17 +19,19 @@ extern "unadjusted" { #[link_name = "llvm.x86.addcarry.32"] fn llvm_addcarry_u32(a: u8, b: u32, c: u32) -> (u8, u32); - // #[link_name = "llvm.x86.addcarryx.u32"] - // fn llvm_addcarryx_u32(a: u8, b: u32, c: u32, d: *mut u8) -> u8; + #[link_name = "llvm.x86.addcarryx.u32"] + fn llvm_addcarryx_u32(a: u8, b: u32, c: u32, d: *mut u8) -> u8; #[link_name = "llvm.x86.subborrow.32"] fn llvm_subborrow_u32(a: u8, b: u32, c: u32) -> (u8, u32); #[link_name = "llvm.x86.addcarry.64"] fn llvm_addcarry_u64(a: u8, b: u64, c: u64) -> (u8, u64); - // #[link_name = "llvm.x86.addcarryx.u64"] - // fn llvm_addcarryx_u64(a: u8, b: u64, c: u64, d: *mut u8) -> u8; + #[link_name = "llvm.x86.addcarryx.u64"] + fn llvm_addcarryx_u64(a: u8, b: u64, c: u64, d: *mut u8) -> u8; #[link_name = "llvm.x86.subborrow.64"] fn llvm_subborrow_u64(a: u8, b: u64, c: u64) -> (u8, u64); + // TODO implement the SIMD types (i16x8, f32x4, f32x8) before + // enabling these tests // #[link_name = "llvm.x86.vcvtph2ps.128"] // fn llvm_vcvtph2ps_128(a: i16x8) -> f32x4; // #[link_name = "llvm.x86.vcvtph2ps.256"] From 4b35be3f34849bc6c58d030154b898dd0e5fcec1 Mon Sep 17 00:00:00 2001 From: Yap Zhi Heng Date: Sat, 29 Aug 2026 23:47:06 +0800 Subject: [PATCH 078/584] gccrs: Update llvm_builtins test cases gcc/testsuite/ChangeLog: * rust/compile/llvm_builtins.rs: Removed 64-bit functions, ensure main calls all llvm built-ins, add dg-final directives to check the generated tree dump, ensure the test only gets compiled on x86 targets. * rust/compile/llvm_builtins_64_bit.rs: New test derived from llvm_builtins.rs, but for 64-bit functions. Signed-off-by: Yap Zhi Heng --- gcc/testsuite/rust/compile/llvm_builtins.rs | 38 ++++++++++------- .../rust/compile/llvm_builtins_64_bit.rs | 42 +++++++++++++++++++ 2 files changed, 66 insertions(+), 14 deletions(-) create mode 100644 gcc/testsuite/rust/compile/llvm_builtins_64_bit.rs diff --git a/gcc/testsuite/rust/compile/llvm_builtins.rs b/gcc/testsuite/rust/compile/llvm_builtins.rs index 7f44eb02fa9d..066c9d1a7181 100644 --- a/gcc/testsuite/rust/compile/llvm_builtins.rs +++ b/gcc/testsuite/rust/compile/llvm_builtins.rs @@ -1,4 +1,5 @@ -// { dg-options "-mrdrnd" } +// { dg-do compile { target { { i?86-*-* x86_64-*-* } && ia32 } } } +// { dg-options "-mrdrnd -mrdseed -fdump-tree-gimple" } #![feature(no_core, abi_unadjusted)] #![no_core] @@ -8,14 +9,10 @@ extern "unadjusted" { fn x86_rdrand16_step() -> (u16, i32); #[link_name = "llvm.x86.rdrand.32"] fn x86_rdrand32_step() -> (u32, i32); - #[link_name = "llvm.x86.rdrand.64"] - fn x86_rdrand64_step() -> (u64, i32); #[link_name = "llvm.x86.rdseed.16"] fn x86_rdseed16_step() -> (u16, i32); #[link_name = "llvm.x86.rdseed.32"] fn x86_rdseed32_step() -> (u32, i32); - #[link_name = "llvm.x86.rdseed.64"] - fn x86_rdseed64_step() -> (u64, i32); #[link_name = "llvm.x86.addcarry.32"] fn llvm_addcarry_u32(a: u8, b: u32, c: u32) -> (u8, u32); @@ -23,12 +20,6 @@ extern "unadjusted" { fn llvm_addcarryx_u32(a: u8, b: u32, c: u32, d: *mut u8) -> u8; #[link_name = "llvm.x86.subborrow.32"] fn llvm_subborrow_u32(a: u8, b: u32, c: u32) -> (u8, u32); - #[link_name = "llvm.x86.addcarry.64"] - fn llvm_addcarry_u64(a: u8, b: u64, c: u64) -> (u8, u64); - #[link_name = "llvm.x86.addcarryx.u64"] - fn llvm_addcarryx_u64(a: u8, b: u64, c: u64, d: *mut u8) -> u8; - #[link_name = "llvm.x86.subborrow.64"] - fn llvm_subborrow_u64(a: u8, b: u64, c: u64) -> (u8, u64); // TODO implement the SIMD types (i16x8, f32x4, f32x8) before // enabling these tests @@ -43,10 +34,29 @@ extern "unadjusted" { } fn main() { - let (_status2, _v1) = unsafe { + let (_v1, _s1) = unsafe { + x86_rdrand16_step() // { dg-final { scan-tree-dump-times {__builtin_ia32_rdrand16_step} 1 gimple } } + }; + let (_v2, _s2) = unsafe { + x86_rdrand32_step() // { dg-final { scan-tree-dump-times {__builtin_ia32_rdrand32_step} 1 gimple } } + }; + let (_v3, _s3) = unsafe { + x86_rdseed16_step() // { dg-final { scan-tree-dump-times {__builtin_ia32_rdseed_hi_step} 1 gimple } } + }; + let (_v4, _s4) = unsafe { + x86_rdseed32_step() // { dg-final { scan-tree-dump-times {__builtin_ia32_rdseed_si_step} 1 gimple } } + }; + + // { dg-final { scan-tree-dump-times {__builtin_ia32_addcarryx_u32} 2 gimple } } + let (_v5, _s5) = unsafe { llvm_addcarry_u32(0, 1, 2) }; - let (_v2, _status2) = unsafe { - x86_rdrand16_step() + let _s6 = unsafe { + let _temp_ptr: *mut u8; + llvm_addcarryx_u32(0, 1, 2, _temp_ptr) + }; + + let (_v7, _s7) = unsafe { + llvm_subborrow_u32(0, 1, 2) // { dg-final { scan-tree-dump-times {__builtin_ia32_sbb_u32} 1 gimple } } }; } diff --git a/gcc/testsuite/rust/compile/llvm_builtins_64_bit.rs b/gcc/testsuite/rust/compile/llvm_builtins_64_bit.rs new file mode 100644 index 000000000000..c3ba93b069c1 --- /dev/null +++ b/gcc/testsuite/rust/compile/llvm_builtins_64_bit.rs @@ -0,0 +1,42 @@ +// { dg-do compile { target { { i?86-*-* x86_64-*-* } && { ! ia32 } } } } +// { dg-options "-mrdrnd -m64 -mrdseed -fdump-tree-gimple" } +#![feature(no_core, abi_unadjusted)] +#![no_core] + +#[allow(improper_ctypes)] +extern "unadjusted" { + #[link_name = "llvm.x86.rdrand.64"] + fn x86_rdrand64_step() -> (u64, i32); + #[link_name = "llvm.x86.rdseed.64"] + fn x86_rdseed64_step() -> (u64, i32); + + #[link_name = "llvm.x86.addcarry.64"] + fn llvm_addcarry_u64(a: u8, b: u64, c: u64) -> (u8, u64); + #[link_name = "llvm.x86.addcarryx.u64"] + fn llvm_addcarryx_u64(a: u8, b: u64, c: u64, d: *mut u8) -> u8; + #[link_name = "llvm.x86.subborrow.64"] + fn llvm_subborrow_u64(a: u8, b: u64, c: u64) -> (u8, u64); +} + +fn main() { + let (_v1, _s1) = unsafe { + x86_rdrand64_step() // { dg-final { scan-tree-dump-times {__builtin_ia32_rdrand64_step} 1 gimple } } + }; + let (_v2, _s2) = unsafe { + x86_rdseed64_step() // { dg-final { scan-tree-dump-times {__builtin_ia32_rdseed_di_step} 1 gimple } } + }; + + // { dg-final { scan-tree-dump-times {__builtin_ia32_addcarryx_u64} 2 gimple } } + let (_s3, _v3) = unsafe { + llvm_addcarry_u64(0, 1, 2) + }; + let _s4 = unsafe { + let _temp_ptr: *mut u8; + llvm_addcarryx_u64(0, 1, 2, _temp_ptr) + }; + + // { dg-final { scan-tree-dump-times {__builtin_ia32_sbb_u64} 1 gimple } } + let (_s5, _v5) = unsafe { + llvm_subborrow_u64(0, 1, 2) + }; +} From 85e795910cf794ea9b32f94f2d987861285685f8 Mon Sep 17 00:00:00 2001 From: Lishin Date: Thu, 13 Aug 2026 17:40:31 +0000 Subject: [PATCH 079/584] gccrs: Generate backend drop flags for conditional moves Generate runtime Drop flags for Conditional Drops. Use BIR analysis results to identify locals that need Drop flags and the moves that clear those flags. The HIR backend sets a flag when initialization, clears it after a move, and checks it before cleanup. gcc/rust/ChangeLog: * backend/rust-compile-context.h (Context::insert_drop_flag): New function. (Context::lookup_drop_flag): Likewise. (Context::drop_flags): New member. * backend/rust-compile-drop-builder.cc (DropBuilder::maybe_create_drop_flag): New function. (DropBuilder::drop_flag_assignment): Likewise. * backend/rust-compile-drop-builder.h (DropBuilder::maybe_create_drop_flag): New declaration. (DropBuilder::drop_flag_assignment): Likewise. * backend/rust-compile-drop.cc (CompileDrop::build_current_scope_drop_cleanup): Check Drop flags before running conditional Drops. * backend/rust-compile-pattern.cc (CompilePatternLet::visit): Set the Drop flag after initialization. * backend/rust-compile-stmt.cc (CompileStmt::visit): Create Drop flags and clear them after moves. * checks/errors/borrowck/rust-bir-builder-expr-stmt.cc (ExprStmtBuilder::visit): Pass expression HirIds to BIR. * checks/errors/borrowck/rust-bir-builder-internal.h (AbstractBuilder::push_assignment): Pass move-site HirIds. (AbstractExprBuilder::return_place): Likewise. * checks/errors/borrowck/rust-bir-drop-analysis.cc (is_straight_line): Remove. (record_drop_for_backend): Rename from record_drop_for_straight_line_backend. (annotate_drop_statements): Record conditional Drops and move sources. (DropAnalysis::clear): Clear the new analysis results. (DropAnalysis::needs_drop_flag): New function. (DropAnalysis::lookup_move_source): Likewise. (DropAnalysis::analyze): Record results for the backend. * checks/errors/borrowck/rust-bir-drop-analysis.h (DropAnalysis::needs_drop_flag): New declaration. (DropAnalysis::lookup_move_source): Likewise. (DropAnalysis::conditionally_dropped): New member. (DropAnalysis::move_sources): Likewise. * checks/errors/borrowck/rust-bir.h (Statement::make_assignment): Accept a move-site HirId. (Statement::Statement): Likewise. (Statement::get_move_site): New function. (Statement::move_site): New member. gcc/testsuite/ChangeLog: * rust/execute/drop-conditional-move.rs: New test. --- gcc/rust/backend/rust-compile-context.h | 16 +++ gcc/rust/backend/rust-compile-drop-builder.cc | 36 ++++- gcc/rust/backend/rust-compile-drop-builder.h | 4 +- gcc/rust/backend/rust-compile-drop.cc | 16 ++- gcc/rust/backend/rust-compile-pattern.cc | 8 +- gcc/rust/backend/rust-compile-stmt.cc | 18 +++ .../borrowck/rust-bir-builder-expr-stmt.cc | 3 +- .../borrowck/rust-bir-builder-internal.h | 15 +- .../errors/borrowck/rust-bir-drop-analysis.cc | 132 +++++++++++------- .../errors/borrowck/rust-bir-drop-analysis.h | 10 +- gcc/rust/checks/errors/borrowck/rust-bir.h | 20 ++- .../rust/execute/drop-conditional-move.rs | 100 +++++++++++++ 12 files changed, 312 insertions(+), 66 deletions(-) create mode 100644 gcc/testsuite/rust/execute/drop-conditional-move.rs diff --git a/gcc/rust/backend/rust-compile-context.h b/gcc/rust/backend/rust-compile-context.h index 2c71f7778a55..d3d4ec744929 100644 --- a/gcc/rust/backend/rust-compile-context.h +++ b/gcc/rust/backend/rust-compile-context.h @@ -145,6 +145,21 @@ class Context return true; } + void insert_drop_flag (HirId id, ::Bvariable *flag) + { + drop_flags[{peek_fn ().fndecl, id}] = flag; + } + + bool lookup_drop_flag (HirId id, ::Bvariable **flag) + { + auto it = drop_flags.find ({peek_fn ().fndecl, id}); + if (it == drop_flags.end ()) + return false; + + *flag = it->second; + return true; + } + void insert_function_decl (const TyTy::FnType *ref, tree fn) { auto id = ref->get_ty_ref (); @@ -504,6 +519,7 @@ class Context // state std::vector fn_stack; std::map compiled_var_decls; + std::map, ::Bvariable *> drop_flags; std::map compiled_type_map; std::map compiled_fn_map; std::map compiled_consts; diff --git a/gcc/rust/backend/rust-compile-drop-builder.cc b/gcc/rust/backend/rust-compile-drop-builder.cc index e0947a787ca4..8cd2bb9f2ac8 100644 --- a/gcc/rust/backend/rust-compile-drop-builder.cc +++ b/gcc/rust/backend/rust-compile-drop-builder.cc @@ -18,6 +18,7 @@ #include "rust-compile-drop-builder.h" #include "rust-compile-context.h" +#include "rust-bir-drop-analysis.h" namespace Rust { namespace Compile { @@ -31,6 +32,39 @@ DropBuilder::note_simple_drop_candidate (HirId hirid, location_t locus) ctx.block_drop_candidates.back ().emplace_back (hirid, locus); } +void +DropBuilder::maybe_create_drop_flag (HirId hirid, location_t locus, + bool initialized) +{ + if (!BIR::DropAnalysis::get ().needs_drop_flag (hirid)) + return; + + Bvariable *existing = nullptr; + if (ctx.lookup_drop_flag (hirid, &existing)) + return; + + tree declaration = nullptr; + Bvariable *flag = Backend::temporary_variable ( + ctx.peek_fn ().fndecl, nullptr, boolean_type_node, + Backend::boolean_constant_expression (initialized), false, locus, + &declaration); + ctx.add_statement (declaration); + ctx.insert_drop_flag (hirid, flag); +} + +tree +DropBuilder::drop_flag_assignment (HirId hirid, bool value, location_t locus) +{ + Bvariable *flag = nullptr; + if (!ctx.lookup_drop_flag (hirid, &flag)) + return nullptr; + + return Backend::assignment_statement (Backend::var_expression (flag, locus), + Backend::boolean_constant_expression ( + value), + locus); +} + std::vector & DropBuilder::peek_block_drop_candidates () { @@ -39,4 +73,4 @@ DropBuilder::peek_block_drop_candidates () } } // namespace Compile -} // namespace Rust \ No newline at end of file +} // namespace Rust diff --git a/gcc/rust/backend/rust-compile-drop-builder.h b/gcc/rust/backend/rust-compile-drop-builder.h index 36e3cdc1e356..6d91d3124f66 100644 --- a/gcc/rust/backend/rust-compile-drop-builder.h +++ b/gcc/rust/backend/rust-compile-drop-builder.h @@ -32,6 +32,8 @@ class DropBuilder DropBuilder (Context &ctx); void note_simple_drop_candidate (HirId hirid, location_t locus); + void maybe_create_drop_flag (HirId hirid, location_t locus, bool initialized); + tree drop_flag_assignment (HirId hirid, bool value, location_t locus); std::vector &peek_block_drop_candidates (); private: @@ -41,4 +43,4 @@ class DropBuilder } // namespace Compile } // namespace Rust -#endif // RUST_COMPILE_DROP_BUILDER_H \ No newline at end of file +#endif // RUST_COMPILE_DROP_BUILDER_H diff --git a/gcc/rust/backend/rust-compile-drop.cc b/gcc/rust/backend/rust-compile-drop.cc index ca4e63f88274..7e54b4cf9d35 100644 --- a/gcc/rust/backend/rust-compile-drop.cc +++ b/gcc/rust/backend/rust-compile-drop.cc @@ -115,7 +115,21 @@ CompileDrop::build_current_scope_drop_cleanup () tree drop_call = compile_drop_call (var, ty, it->locus); if (drop_call != NULL_TREE) - drop_stmts.push_back (convert_to_void (drop_call, ICV_STATEMENT)); + { + tree drop_stmt = convert_to_void (drop_call, ICV_STATEMENT); + Bvariable *flag = nullptr; + if (ctx->lookup_drop_flag (it->hirid, &flag)) + { + tree condition = Backend::var_expression (flag, it->locus); + tree clear = drop_builder.drop_flag_assignment (it->hirid, false, + it->locus); + tree guarded_drop = Backend::statement_list ({clear, drop_stmt}); + drop_stmt + = Backend::if_statement (ctx->peek_fn ().fndecl, condition, + guarded_drop, NULL_TREE, it->locus); + } + drop_stmts.push_back (drop_stmt); + } } if (drop_stmts.empty ()) diff --git a/gcc/rust/backend/rust-compile-pattern.cc b/gcc/rust/backend/rust-compile-pattern.cc index 9d722358bb2c..82cabef784b0 100644 --- a/gcc/rust/backend/rust-compile-pattern.cc +++ b/gcc/rust/backend/rust-compile-pattern.cc @@ -1353,6 +1353,13 @@ CompilePatternLet::visit (HIR::IdentifierPattern &pattern) ctx->add_statement (s); } + DropBuilder drop_builder (*ctx); + tree set_drop_flag + = drop_builder.drop_flag_assignment (pattern.get_mappings ().get_hirid (), + true, pattern.get_locus ()); + if (set_drop_flag != nullptr) + ctx->add_statement (set_drop_flag); + TyTy::BaseType *drop_ty = ty; if (pattern.get_is_ref ()) { @@ -1366,7 +1373,6 @@ CompilePatternLet::visit (HIR::IdentifierPattern &pattern) if (!pattern.has_subpattern () && !pattern.get_is_ref ()) { - DropBuilder drop_builder (*ctx); drop_builder.note_simple_drop_candidate ( pattern.get_mappings ().get_hirid (), pattern.get_locus ()); } diff --git a/gcc/rust/backend/rust-compile-stmt.cc b/gcc/rust/backend/rust-compile-stmt.cc index 7f6e81ff803d..78b87b5b4dc2 100644 --- a/gcc/rust/backend/rust-compile-stmt.cc +++ b/gcc/rust/backend/rust-compile-stmt.cc @@ -21,6 +21,9 @@ #include "rust-compile-expr.h" #include "rust-compile-type.h" #include "rust-compile-var-decl.h" +#include "rust-compile-drop.h" +#include "rust-compile-drop-builder.h" +#include "rust-bir-drop-analysis.h" namespace Rust { namespace Compile { @@ -67,6 +70,11 @@ CompileStmt::visit (HIR::LetStmt &stmt) tree translated_type = TyTyResolveCompile::compile (ctx, ty); CompileVarDecl::compile (fndecl, translated_type, &stmt_pattern, ctx); + if (stmt_pattern.get_pattern_type () == HIR::Pattern::IDENTIFIER + && CompileDrop (ctx).type_has_drop_impl (ty)) + DropBuilder (*ctx).maybe_create_drop_flag (stmt_id, stmt.get_locus (), + false); + // nothing to do if (!stmt.has_init_expr ()) return; @@ -89,6 +97,16 @@ CompileStmt::visit (HIR::LetStmt &stmt) expected, lvalue_locus, rvalue_locus); CompilePatternLet::Compile (&stmt_pattern, init, ty, rvalue_locus, ctx); + + HirId source = UNKNOWN_HIRID; + if (BIR::DropAnalysis::get ().lookup_move_source ( + stmt.get_init_expr ().get_mappings ().get_hirid (), &source)) + { + tree clear + = DropBuilder (*ctx).drop_flag_assignment (source, false, rvalue_locus); + if (clear != nullptr) + ctx->add_statement (clear); + } } } // namespace Compile diff --git a/gcc/rust/checks/errors/borrowck/rust-bir-builder-expr-stmt.cc b/gcc/rust/checks/errors/borrowck/rust-bir-builder-expr-stmt.cc index b58f2cfe919b..889e4611eca0 100644 --- a/gcc/rust/checks/errors/borrowck/rust-bir-builder-expr-stmt.cc +++ b/gcc/rust/checks/errors/borrowck/rust-bir-builder-expr-stmt.cc @@ -703,7 +703,8 @@ ExprStmtBuilder::visit (HIR::PathInExpression &expr) { // Note: Type is only stored for the expr, not the segment. PlaceId result = resolve_variable_or_fn (expr, lookup_type (expr)); - return_place (result, expr.get_locus ()); + return_place (result, expr.get_locus (), false, + expr.get_mappings ().get_hirid ()); } void diff --git a/gcc/rust/checks/errors/borrowck/rust-bir-builder-internal.h b/gcc/rust/checks/errors/borrowck/rust-bir-builder-internal.h index eabfdc6af4cb..b5644741d9eb 100644 --- a/gcc/rust/checks/errors/borrowck/rust-bir-builder-internal.h +++ b/gcc/rust/checks/errors/borrowck/rust-bir-builder-internal.h @@ -265,16 +265,18 @@ class AbstractBuilder } protected: // Helpers to add BIR statements - void push_assignment (PlaceId lhs, AbstractExpr *rhs, location_t location) + void push_assignment (PlaceId lhs, AbstractExpr *rhs, location_t location, + tl::optional move_site = tl::nullopt) { ctx.get_current_bb ().statements.push_back ( - Statement::make_assignment (lhs, rhs, location)); + Statement::make_assignment (lhs, rhs, location, move_site)); translated = lhs; } - void push_assignment (PlaceId lhs, PlaceId rhs, location_t location) + void push_assignment (PlaceId lhs, PlaceId rhs, location_t location, + tl::optional move_site = tl::nullopt) { - push_assignment (lhs, new Assignment (rhs), location); + push_assignment (lhs, new Assignment (rhs), location, move_site); } void push_tmp_assignment (AbstractExpr *rhs, TyTy::BaseType *tyty, @@ -600,12 +602,13 @@ class AbstractExprBuilder : public AbstractBuilder, } /** Mark place to be a result of processed subexpression. */ - void return_place (PlaceId place, location_t location, bool can_panic = false) + void return_place (PlaceId place, location_t location, bool can_panic = false, + tl::optional move_site = tl::nullopt) { if (expr_return_place != INVALID_PLACE) { // Return place is already allocated, no need to defer assignment. - push_assignment (expr_return_place, place, location); + push_assignment (expr_return_place, place, location, move_site); } else { diff --git a/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.cc b/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.cc index 2bdf5e5e4dd6..22be1553eee5 100644 --- a/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.cc +++ b/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.cc @@ -38,31 +38,13 @@ struct BlockInitializationState bool reachable; }; -static bool -is_straight_line (const Function &function) +struct DropAnalysisResults { - std::set visited; - BasicBlockId current = ENTRY_BASIC_BLOCK; - - while (current != INVALID_BB) - { - // Revisiting a block means that the CFG contains a cycle. - if (!visited.insert (current).second) - return false; - - const BasicBlock &block = function.basic_blocks[current]; - - if (block.successors.empty ()) - return true; - - if (block.successors.size () != 1) - return false; - - current = block.successors.front (); - } - - return true; -} + std::unordered_set dead_drop_hir_ids; + std::unordered_set static_drop_hir_ids; + std::unordered_set conditional_drop_hir_ids; + std::unordered_map move_sources; +}; static void set_initialized (BlockInitializationState &state, PlaceId place) @@ -247,10 +229,9 @@ compute_entry_states (Function &function) } static void -record_drop_for_straight_line_backend (const Function &function, PlaceId place, - Statement::DropStyle drop_style, - std::set &dead_drop_hir_ids, - std::set &non_dead_drop_hir_ids) +record_drop_for_backend (const Function &function, PlaceId place, + Statement::DropStyle drop_style, + DropAnalysisResults &results) { const Place &dropped_place = function.place_db[place]; @@ -263,10 +244,23 @@ record_drop_for_straight_line_backend (const Function &function, PlaceId place, if (!hir_id.has_value ()) return; - if (drop_style == Statement::DropStyle::DEAD) - dead_drop_hir_ids.insert (hir_id.value ()); - else - non_dead_drop_hir_ids.insert (hir_id.value ()); + switch (drop_style) + { + case Statement::DropStyle::UNCLASSIFIED: + break; + + case Statement::DropStyle::DEAD: + results.dead_drop_hir_ids.insert (hir_id.value ()); + break; + + case Statement::DropStyle::STATIC: + results.static_drop_hir_ids.insert (hir_id.value ()); + break; + + case Statement::DropStyle::CONDITIONAL: + results.conditional_drop_hir_ids.insert (hir_id.value ()); + break; + } } // Walk each reachable block forward from its stable entry state and classify @@ -274,8 +268,7 @@ record_drop_for_straight_line_backend (const Function &function, PlaceId place, static void annotate_drop_statements ( Function &function, const std::vector &entry_states, - bool record_straight_line_backend_drops, std::set &dead_drop_hir_ids, - std::set &non_dead_drop_hir_ids) + DropAnalysisResults &results) { const size_t block_count = function.basic_blocks.size (); @@ -291,6 +284,29 @@ annotate_drop_statements ( for (Statement &statement : block.statements) { + const auto &move_site = statement.get_move_site (); + if (statement.get_kind () == Statement::Kind::ASSIGNMENT + && move_site.has_value ()) + { + AbstractExpr &expr = statement.get_expr (); + if (expr.get_kind () == ExprKind::ASSIGNMENT) + { + PlaceId rhs = static_cast (expr).get_rhs (); + const Place &rhs_place = function.place_db[rhs]; + if (rhs_place.kind == Place::VARIABLE + && rhs_place.should_be_moved ()) + { + auto hirid + = Analysis::Mappings::get ().lookup_node_to_hir ( + static_cast ( + rhs_place.variable_or_field_index)); + if (hirid.has_value ()) + results.move_sources[move_site.value ()] + = hirid.value (); + } + } + } + // A Drop is classified using the state before it executes. if (statement.get_kind () == Statement::Kind::DROP) { @@ -299,11 +315,7 @@ annotate_drop_statements ( statement.set_drop_style (drop_style); - if (record_straight_line_backend_drops) - record_drop_for_straight_line_backend (function, place, - drop_style, - dead_drop_hir_ids, - non_dead_drop_hir_ids); + record_drop_for_backend (function, place, drop_style, results); } // Update the state for the following statement. @@ -325,6 +337,8 @@ void DropAnalysis::clear () { definitely_dead.clear (); + conditionally_dropped.clear (); + move_sources.clear (); } bool @@ -333,26 +347,44 @@ DropAnalysis::is_definitely_dead (HirId id) const return definitely_dead.find (id) != definitely_dead.end (); } +bool +DropAnalysis::needs_drop_flag (HirId id) const +{ + return conditionally_dropped.find (id) != conditionally_dropped.end (); +} + +bool +DropAnalysis::lookup_move_source (HirId move_site, HirId *source) const +{ + auto it = move_sources.find (move_site); + if (it == move_sources.end ()) + return false; + + *source = it->second; + return true; +} + void DropAnalysis::analyze (Function &function) { std::vector entry_states = compute_entry_states (function); - // Keep the existing backend handling for straight-line CFGs. - const bool record_straight_line_backend_drops = is_straight_line (function); - - std::set dead_drop_hir_ids; - std::set non_dead_drop_hir_ids; - - annotate_drop_statements (function, entry_states, - record_straight_line_backend_drops, - dead_drop_hir_ids, non_dead_drop_hir_ids); + DropAnalysisResults results; + annotate_drop_statements (function, entry_states, results); // A local is definitely dead only when all of its Drops are dead. - for (HirId hir_id : dead_drop_hir_ids) - if (non_dead_drop_hir_ids.find (hir_id) == non_dead_drop_hir_ids.end ()) + for (HirId hir_id : results.dead_drop_hir_ids) + if (results.static_drop_hir_ids.find (hir_id) + == results.static_drop_hir_ids.end () + && results.conditional_drop_hir_ids.find (hir_id) + == results.conditional_drop_hir_ids.end ()) definitely_dead.insert (hir_id); + + conditionally_dropped.insert (results.conditional_drop_hir_ids.begin (), + results.conditional_drop_hir_ids.end ()); + move_sources.insert (results.move_sources.begin (), + results.move_sources.end ()); } } // namespace BIR diff --git a/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.h b/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.h index 17a175e08d6f..45cb1e2f8714 100644 --- a/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.h +++ b/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.h @@ -19,6 +19,7 @@ #ifndef RUST_BIR_DROP_ANALYSIS_H #define RUST_BIR_DROP_ANALYSIS_H +#include "rust-system.h" #include "rust-bir.h" namespace Rust { @@ -39,9 +40,16 @@ class DropAnalysis void analyze (Function &function); bool is_definitely_dead (HirId id) const; + bool needs_drop_flag (HirId id) const; + bool lookup_move_source (HirId move_site, HirId *source) const; private: - std::set definitely_dead; + std::unordered_set definitely_dead; + std::unordered_set conditionally_dropped; + // This may need to be extended to + // std::unordered_map> + // to support product moves in the future. + std::unordered_map move_sources; }; } // namespace BIR diff --git a/gcc/rust/checks/errors/borrowck/rust-bir.h b/gcc/rust/checks/errors/borrowck/rust-bir.h index 581f661655dc..f03cdcc14239 100644 --- a/gcc/rust/checks/errors/borrowck/rust-bir.h +++ b/gcc/rust/checks/errors/borrowck/rust-bir.h @@ -21,6 +21,7 @@ #include "rust-bir-place.h" #include "rust-bir-visitor.h" +#include "optional.h" #include "polonius/rust-polonius-ffi.h" #include "rust-tyty-variance-analysis.h" @@ -113,12 +114,17 @@ class Statement // currently only available when kind is ASSIGNMENT | RETURN // FIXME: Add location for other statement kinds location_t location; + // HIR expression which consumes the RHS of an assignment. This is used to + // attach backend drop-flag updates to the corresponding expression. + tl::optional move_site; public: static Statement make_assignment (PlaceId place, AbstractExpr *rhs, - location_t location) + location_t location, + tl::optional move_site = tl::nullopt) { - return Statement (Kind::ASSIGNMENT, place, rhs, nullptr, location); + return Statement (Kind::ASSIGNMENT, place, rhs, nullptr, location, + move_site); } static Statement make_switch (PlaceId place) { @@ -155,8 +161,10 @@ class Statement // compelete constructor, used by make_* functions Statement (Kind kind, PlaceId place = INVALID_PLACE, AbstractExpr *rhs = nullptr, TyTy::BaseType *type = nullptr, - location_t location = UNKNOWN_LOCATION) - : kind (kind), place (place), expr (rhs), type (type), location (location) + location_t location = UNKNOWN_LOCATION, + tl::optional move_site = tl::nullopt) + : kind (kind), place (place), expr (rhs), type (type), location (location), + move_site (move_site) {} public: @@ -167,6 +175,10 @@ class Statement WARN_UNUSED_RESULT AbstractExpr &get_expr () const { return *expr; } WARN_UNUSED_RESULT TyTy::BaseType *get_type () const { return type; } WARN_UNUSED_RESULT location_t get_location () const { return location; } + WARN_UNUSED_RESULT const tl::optional &get_move_site () const + { + return move_site; + } }; struct BasicBlock diff --git a/gcc/testsuite/rust/execute/drop-conditional-move.rs b/gcc/testsuite/rust/execute/drop-conditional-move.rs new file mode 100644 index 000000000000..cb28625f976b --- /dev/null +++ b/gcc/testsuite/rust/execute/drop-conditional-move.rs @@ -0,0 +1,100 @@ +// { dg-output "^drop\r*\nafter conditional\r*\nafter conditional\r*\ndrop\r*\nafter static\r*\ndrop\r*\nafter static\r*\ndrop\r*\ndrop\r*\ndrop\r*\n$" } +// { dg-additional-options "-frust-borrowcheck -w" } + +#![feature(no_core)] +#![feature(lang_items)] +#![no_core] + +extern "C" { + fn printf(s: *const i8, ...); +} + +#[lang = "sized"] +pub trait Sized {} + +#[lang = "drop"] +pub trait Drop { + fn drop(&mut self); +} + +struct Droppable { + value: i32, +} + +struct AfterConditional { + value: i32, +} + +struct AfterStatic { + value: i32, +} + +impl Drop for Droppable { + fn drop(&mut self) { + let msg = "drop\n\0" as *const str as *const i8; + unsafe { + printf(msg); + } + } +} + +impl Drop for AfterConditional { + fn drop(&mut self) { + let msg = "after conditional\n\0" as *const str as *const i8; + unsafe { + printf(msg); + } + } +} + +impl Drop for AfterStatic { + fn drop(&mut self) { + let msg = "after static\n\0" as *const str as *const i8; + unsafe { + printf(msg); + } + } +} + +fn conditional_move(condition: bool) { + let x = Droppable { value: 1 }; + + if condition { + let _y = x; + } + + let _after = AfterConditional { value: 0 }; +} + +fn static_after_join(condition: bool) { + let _x = Droppable { value: 2 }; + + if condition { + let _n = 1; + } + + let _after = AfterStatic { value: 0 }; +} + +fn move_on_both_branches(condition: bool) { + let x = Droppable { value: 3 }; + + if condition { + let _y = x; + } else { + let _z = x; + } +} + +fn main() -> i32 { + conditional_move(true); + conditional_move(false); + + static_after_join(true); + static_after_join(false); + + move_on_both_branches(true); + move_on_both_branches(false); + + 0 +} \ No newline at end of file From 7f6e3f37c5049a5a397e0d9acab119d30bf89407 Mon Sep 17 00:00:00 2001 From: Lishin Date: Fri, 28 Aug 2026 17:28:27 +0000 Subject: [PATCH 080/584] gccrs: Reject multiple move sources in product-type expressions Pass the struct expression HIR ID through BIR so moves from the same expression can be identified. For now, report the case as unsupported when an expression moves more than one value. gcc/rust/ChangeLog: * checks/errors/borrowck/rust-bir-builder-expr-stmt.cc (ExprStmtBuilder::visit): Pass the struct expression HIR ID. * checks/errors/borrowck/rust-bir-builder-internal.h (AbstractBuilder::push_tmp_assignment): Propagate move sites. (AbstractBuilder::move_place): Likewise. (AbstractBuilder::move_all): Likewise. * checks/errors/borrowck/rust-bir-drop-analysis.cc (annotate_drop_statements): Reject multiple move sources. gcc/testsuite/ChangeLog: * rust/compile/drop-conditional-product-move.rs: New test. Signed-off-by: Lishin --- .../borrowck/rust-bir-builder-expr-stmt.cc | 2 +- .../borrowck/rust-bir-builder-internal.h | 25 ++++++---- .../errors/borrowck/rust-bir-drop-analysis.cc | 16 +++++- .../compile/drop-conditional-product-move.rs | 49 +++++++++++++++++++ 4 files changed, 79 insertions(+), 13 deletions(-) create mode 100644 gcc/testsuite/rust/compile/drop-conditional-product-move.rs diff --git a/gcc/rust/checks/errors/borrowck/rust-bir-builder-expr-stmt.cc b/gcc/rust/checks/errors/borrowck/rust-bir-builder-expr-stmt.cc index 889e4611eca0..6586e9521bec 100644 --- a/gcc/rust/checks/errors/borrowck/rust-bir-builder-expr-stmt.cc +++ b/gcc/rust/checks/errors/borrowck/rust-bir-builder-expr-stmt.cc @@ -111,7 +111,7 @@ ExprStmtBuilder::visit (HIR::StructExprStructFields &fields) { field_locations.push_back (field->get_locus ()); } - move_all (init_values, field_locations); + move_all (init_values, field_locations, fields.get_mappings ().get_hirid ()); return_expr (new InitializerExpr (std::move (init_values)), lookup_type (fields), fields.get_locus ()); } diff --git a/gcc/rust/checks/errors/borrowck/rust-bir-builder-internal.h b/gcc/rust/checks/errors/borrowck/rust-bir-builder-internal.h index b5644741d9eb..b1ced93ebd65 100644 --- a/gcc/rust/checks/errors/borrowck/rust-bir-builder-internal.h +++ b/gcc/rust/checks/errors/borrowck/rust-bir-builder-internal.h @@ -280,17 +280,19 @@ class AbstractBuilder } void push_tmp_assignment (AbstractExpr *rhs, TyTy::BaseType *tyty, - location_t location) + location_t location, + tl::optional move_site = tl::nullopt) { PlaceId tmp = ctx.place_db.add_temporary (tyty); push_storage_live (tmp); - push_assignment (tmp, rhs, location); + push_assignment (tmp, rhs, location, move_site); } - void push_tmp_assignment (PlaceId rhs, location_t location) + void push_tmp_assignment (PlaceId rhs, location_t location, + tl::optional move_site = tl::nullopt) { - push_tmp_assignment (new Assignment (rhs), ctx.place_db[rhs].tyty, - location); + push_tmp_assignment (new Assignment (rhs), ctx.place_db[rhs].tyty, location, + move_site); } void push_switch (PlaceId switch_val, location_t location, @@ -353,7 +355,8 @@ class AbstractBuilder return translated; } - PlaceId move_place (PlaceId arg, location_t location) + PlaceId move_place (PlaceId arg, location_t location, + tl::optional move_site = tl::nullopt) { auto &place = ctx.place_db[arg]; @@ -366,7 +369,7 @@ class AbstractBuilder if (place.is_rvalue ()) return arg; - push_tmp_assignment (arg, location); + push_tmp_assignment (arg, location, move_site); return translated; } @@ -379,12 +382,14 @@ class AbstractBuilder } template - void move_all (T &args, std::vector locations) + void move_all (T &args, std::vector locations, + tl::optional move_site = tl::nullopt) { rust_assert (args.size () == locations.size ()); std::transform (args.begin (), args.end (), locations.begin (), - args.begin (), [this] (PlaceId arg, location_t location) { - return move_place (arg, location); + args.begin (), + [this, move_site] (PlaceId arg, location_t location) { + return move_place (arg, location, move_site); }); } diff --git a/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.cc b/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.cc index 22be1553eee5..8a52d78f1b7b 100644 --- a/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.cc +++ b/gcc/rust/checks/errors/borrowck/rust-bir-drop-analysis.cc @@ -18,6 +18,7 @@ #include "rust-bir-drop-analysis.h" #include "rust-bir.h" +#include "rust-diagnostics.h" #include "rust-hir-map.h" namespace Rust { @@ -301,8 +302,19 @@ annotate_drop_statements ( static_cast ( rhs_place.variable_or_field_index)); if (hirid.has_value ()) - results.move_sources[move_site.value ()] - = hirid.value (); + { + auto move_source + = results.move_sources.find (move_site.value ()); + if (move_source != results.move_sources.end () + && move_source->second != hirid.value ()) + rust_sorry_at (statement.get_location (), + "moving multiple IDs within the " + "same location is not " + "yet supported"); + else + results.move_sources.emplace (move_site.value (), + hirid.value ()); + } } } } diff --git a/gcc/testsuite/rust/compile/drop-conditional-product-move.rs b/gcc/testsuite/rust/compile/drop-conditional-product-move.rs new file mode 100644 index 000000000000..a221a030809e --- /dev/null +++ b/gcc/testsuite/rust/compile/drop-conditional-product-move.rs @@ -0,0 +1,49 @@ +// { dg-additional-options "-frust-borrowcheck -w" } + +#![feature(no_core)] +#![feature(lang_items)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +#[lang = "drop"] +pub trait Drop { + fn drop(&mut self); +} + +struct Droppable { + value: i32, +} + +impl Drop for Droppable { + fn drop(&mut self) {} +} + +struct Pair { + first: Droppable, + second: Droppable, +} + +fn unconditional_product_move() { + let first = Droppable { value: 1 }; + let second = Droppable { value: 2 }; + let _pair = Pair { first, second }; // { dg-message "sorry, unimplemented: moving multiple IDs within the same location is not yet supported" } +} + +fn conditional_product_move(condition: bool) { + let first = Droppable { value: 1 }; + let second = Droppable { value: 2 }; + + if condition { + let _pair = Pair { + first, + second, // { dg-message "sorry, unimplemented: moving multiple IDs within the same location is not yet supported" } + }; + } +} + +fn main() { + unconditional_product_move(); + conditional_product_move(true); +} From 559ead62d2fa5215df1de9577736cb1ae3b429d8 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 31 Aug 2026 13:27:08 +0100 Subject: [PATCH 081/584] gccrs: Fix self referencial assocated type Fixes Rust-GCC/gccrs#4821 gcc/rust/ChangeLog: * typecheck/rust-hir-trait-resolve.cc (TraitItemReference::resolve_item): can be recusive Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-trait-resolve.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/gcc/rust/typecheck/rust-hir-trait-resolve.cc b/gcc/rust/typecheck/rust-hir-trait-resolve.cc index 5be1989c55a4..502d0e8f7d8d 100644 --- a/gcc/rust/typecheck/rust-hir-trait-resolve.cc +++ b/gcc/rust/typecheck/rust-hir-trait-resolve.cc @@ -490,6 +490,8 @@ TraitItemReference::resolve_item (const TraitReference *tref, TyTy::SubstitutionArgumentMappings::error (), {}, {}, inherited_count); + context->insert_type (type.get_mappings (), projection); + // Attach the bounds declared on the associated type itself: // // type IntoIter: Iterator @@ -514,8 +516,6 @@ TraitItemReference::resolve_item (const TraitReference *tref, if (!trait_item_bounds.empty ()) projection->inherit_bounds (trait_item_bounds); } - - context->insert_type (type.get_mappings (), projection); } void From 13be1e80194088730f09dc546f2d0e89322ef878 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Sun, 30 Aug 2026 23:32:32 +0100 Subject: [PATCH 082/584] gccrs: Implement extern types by reusing ADT with an extern kind This reused out ADTType to capture these extern opaque types with a new ADTKind of extern. gcc/rust/ChangeLog: * backend/rust-compile-extern.h: compile it down * backend/rust-compile-type.cc (TyTyResolveCompile::visit): make empty struct * checks/errors/rust-hir-pattern-analysis.cc (PlaceInfo::specialize): add missng case * typecheck/rust-hir-type-check-implitem.cc (TypeCheckTopLevelExternItem::visit): create adt * typecheck/rust-tyty-bounds.cc (TypeBoundsProbe::assemble_marker_builtins): not sized * typecheck/rust-tyty.h: new kind gcc/testsuite/ChangeLog: * rust/compile/extern_type_item_resolve.rs: it works * rust/compile/extern-type-unsized.rs: New test. * rust/compile/extern-type.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/backend/rust-compile-extern.h | 10 +++++++- gcc/rust/backend/rust-compile-type.cc | 4 ++++ .../errors/rust-hir-pattern-analysis.cc | 2 ++ .../typecheck/rust-hir-type-check-implitem.cc | 23 +++++++++++++++++-- gcc/rust/typecheck/rust-tyty-bounds.cc | 10 +++++++- gcc/rust/typecheck/rust-tyty.h | 3 ++- .../rust/compile/extern-type-unsized.rs | 16 +++++++++++++ gcc/testsuite/rust/compile/extern-type.rs | 13 +++++++++++ .../rust/compile/extern_type_item_resolve.rs | 1 - 9 files changed, 76 insertions(+), 6 deletions(-) create mode 100644 gcc/testsuite/rust/compile/extern-type-unsized.rs create mode 100644 gcc/testsuite/rust/compile/extern-type.rs diff --git a/gcc/rust/backend/rust-compile-extern.h b/gcc/rust/backend/rust-compile-extern.h index b2237b77c246..824d312143c5 100644 --- a/gcc/rust/backend/rust-compile-extern.h +++ b/gcc/rust/backend/rust-compile-extern.h @@ -204,7 +204,15 @@ class CompileExternItem : public HIRCompileBase, void visit (HIR::ExternalTypeItem &type) override { - rust_sorry_at (type.get_locus (), "extern types are not supported yet"); + TyTy::BaseType *lookup = nullptr; + if (!ctx->get_tyctx ()->lookup_type (type.get_mappings ().get_hirid (), + &lookup)) + { + rust_error_at (type.get_locus (), "failed to resolve type"); + return; + } + + TyTyResolveCompile::compile (ctx, lookup); } private: diff --git a/gcc/rust/backend/rust-compile-type.cc b/gcc/rust/backend/rust-compile-type.cc index 1a815b9ffebf..56f9e9424342 100644 --- a/gcc/rust/backend/rust-compile-type.cc +++ b/gcc/rust/backend/rust-compile-type.cc @@ -342,6 +342,10 @@ TyTyResolveCompile::visit (const TyTy::ADTType &type) type_record = build_vector_type (inner_type, variant.num_fields ()); } + else if (type.get_adt_kind () == TyTy::ADTType::ADTKind::EXTERN) + { + type_record = Backend::struct_type ({}); + } else if (!type.is_enum ()) { rust_assert (type.number_of_variants () == 1); diff --git a/gcc/rust/checks/errors/rust-hir-pattern-analysis.cc b/gcc/rust/checks/errors/rust-hir-pattern-analysis.cc index ef5ae34d3cbf..33461d918141 100644 --- a/gcc/rust/checks/errors/rust-hir-pattern-analysis.cc +++ b/gcc/rust/checks/errors/rust-hir-pattern-analysis.cc @@ -978,6 +978,8 @@ PlaceInfo::specialize (const Constructor &c) const // TODO: support unions rust_unreachable (); } + case TyTy::ADTType::ADTKind::EXTERN: + return {}; } } break; diff --git a/gcc/rust/typecheck/rust-hir-type-check-implitem.cc b/gcc/rust/typecheck/rust-hir-type-check-implitem.cc index 57f1718e9500..9d8f8385ecac 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-implitem.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-implitem.cc @@ -17,6 +17,7 @@ // . #include "rust-hir-type-check-implitem.h" +#include "rust-canonical-path.h" #include "rust-diagnostics.h" #include "rust-hir-full-decls.h" #include "rust-hir-pattern.h" @@ -169,8 +170,26 @@ TypeCheckTopLevelExternItem::visit (HIR::ExternalFunctionItem &function) void TypeCheckTopLevelExternItem::visit (HIR::ExternalTypeItem &type) { - rust_sorry_at (type.get_locus (), "extern types are not supported yet"); - // TODO + CanonicalPath path + = CanonicalPath::new_seg (type.get_mappings ().get_nodeid (), + type.get_item_name ().as_string ()); + + RustIdent ident{path, type.get_locus ()}; + + TyTy::ADTType::ReprOptions repr; + std::vector variants; + TyTy::RegionConstraints region_constraints; + std::vector substitutions; + + auto *extern_type = new TyTy::ADTType ( + type.get_mappings ().get_defid (), type.get_mappings ().get_hirid (), + type.get_mappings ().get_hirid (), type.get_item_name ().as_string (), + ident, TyTy::ADTType::ADTKind::EXTERN, std::move (variants), + std::move (substitutions), repr, + TyTy::SubstitutionArgumentMappings::empty (0), region_constraints); + + context->insert_type (type.get_mappings (), extern_type); + resolved = extern_type; } TypeCheckImplItem::TypeCheckImplItem ( diff --git a/gcc/rust/typecheck/rust-tyty-bounds.cc b/gcc/rust/typecheck/rust-tyty-bounds.cc index 8760eb1a0a84..f72ee57f93a5 100644 --- a/gcc/rust/typecheck/rust-tyty-bounds.cc +++ b/gcc/rust/typecheck/rust-tyty-bounds.cc @@ -22,6 +22,7 @@ #include "rust-substitution-mapper.h" #include "rust-hir-trait-resolve.h" #include "rust-type-util.h" +#include "rust-tyty.h" namespace Rust { namespace Resolver { @@ -170,12 +171,19 @@ TypeBoundsProbe::assemble_marker_builtins () // FIXME str and slice need to be moved and test cases updated case TyTy::SLICE: case TyTy::STR: - case TyTy::ADT: case TyTy::TUPLE: // FIXME add extra checks assemble_builtin_candidate (LangItem::Kind::SIZED); break; + case TyTy::ADT: + { + const auto &adt = *static_cast (raw); + if (adt.get_adt_kind () != TyTy::ADTType::ADTKind::EXTERN) + assemble_builtin_candidate (LangItem::Kind::SIZED); + } + break; + case TyTy::CONST: case TyTy::DYNAMIC: case TyTy::ERROR: diff --git a/gcc/rust/typecheck/rust-tyty.h b/gcc/rust/typecheck/rust-tyty.h index 45888e48fd38..4e1cd301edfa 100644 --- a/gcc/rust/typecheck/rust-tyty.h +++ b/gcc/rust/typecheck/rust-tyty.h @@ -917,7 +917,8 @@ class ADTType : public BaseType, public SubstitutionRef STRUCT_STRUCT, TUPLE_STRUCT, UNION, - ENUM + ENUM, + EXTERN }; enum ReprKind diff --git a/gcc/testsuite/rust/compile/extern-type-unsized.rs b/gcc/testsuite/rust/compile/extern-type-unsized.rs new file mode 100644 index 000000000000..271c3ee902bd --- /dev/null +++ b/gcc/testsuite/rust/compile/extern-type-unsized.rs @@ -0,0 +1,16 @@ +#![feature(extern_types, lang_items, no_core)] +#![no_core] + +#[lang = "sized"] +trait Sized {} + +extern "C" { + type Opaque; +} + +fn require_sized() {} + +fn main() { + require_sized::(); + // { dg-error "bounds not satisfied for Opaque .Sized. is not satisfied" "" { target *-*-* } .-1 } +} diff --git a/gcc/testsuite/rust/compile/extern-type.rs b/gcc/testsuite/rust/compile/extern-type.rs new file mode 100644 index 000000000000..256af5b95d2c --- /dev/null +++ b/gcc/testsuite/rust/compile/extern-type.rs @@ -0,0 +1,13 @@ +#![feature(no_core, extern_types)] +#![no_core] + +extern "C" { + type Opaque; +} + +fn takes_ptr(_ptr: *const Opaque) {} + +fn main() { + let ptr = 0 as *const Opaque; + takes_ptr(ptr); +} diff --git a/gcc/testsuite/rust/compile/extern_type_item_resolve.rs b/gcc/testsuite/rust/compile/extern_type_item_resolve.rs index 0313d9dbade4..e2b354478afc 100644 --- a/gcc/testsuite/rust/compile/extern_type_item_resolve.rs +++ b/gcc/testsuite/rust/compile/extern_type_item_resolve.rs @@ -1,4 +1,3 @@ -// { dg-additional-options "-frust-compile-until=typecheck" } #![feature(no_core, extern_types)] #![no_core] From e5382827c529a356b33b53a7e7f3695d34ee7b4f Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 31 Aug 2026 19:48:48 +0100 Subject: [PATCH 083/584] gccrs: Fix ambigious path resolution Rust checks regular impls first then only when candidates are empty it should iterate trait impls. Fixes Rust-GCC/gccrs#4823 gcc/rust/ChangeLog: * typecheck/rust-hir-path-probe-expr.cc (PathProbeExpr::probe_adt_impls): check impls first (PathProbeExpr::probe_fallback_impls): likewise gcc/testsuite/ChangeLog: * rust/compile/issue-4823.rs: New test. Signed-off-by: Philip Herron --- .../typecheck/rust-hir-path-probe-expr.cc | 29 +++++++++++++++++++ gcc/testsuite/rust/compile/issue-4823.rs | 23 +++++++++++++++ 2 files changed, 52 insertions(+) create mode 100644 gcc/testsuite/rust/compile/issue-4823.rs diff --git a/gcc/rust/typecheck/rust-hir-path-probe-expr.cc b/gcc/rust/typecheck/rust-hir-path-probe-expr.cc index 4177e3760386..8307082af973 100644 --- a/gcc/rust/typecheck/rust-hir-path-probe-expr.cc +++ b/gcc/rust/typecheck/rust-hir-path-probe-expr.cc @@ -80,6 +80,21 @@ PathProbeExpr::probe_adt_impls (TyTy::ADTType *adt) mappings.iterate_adt_impl_items ( adt_node_id, [this] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) -> bool { + if (impl->has_trait_ref ()) + return true; + + return process_impl_item_candidate (id, item, impl); + }); + + if (!candidates.empty ()) + return; + + mappings.iterate_adt_impl_items ( + adt_node_id, + [this] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) -> bool { + if (!impl->has_trait_ref ()) + return true; + return process_impl_item_candidate (id, item, impl); }); } @@ -89,6 +104,20 @@ PathProbeExpr::probe_fallback_impls () { mappings.iterate_impl_items ( [this] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) -> bool { + if (impl->has_trait_ref ()) + return true; + + return process_impl_item_candidate (id, item, impl); + }); + + if (!candidates.empty ()) + return; + + mappings.iterate_impl_items ( + [this] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) -> bool { + if (!impl->has_trait_ref ()) + return true; + return process_impl_item_candidate (id, item, impl); }); } diff --git a/gcc/testsuite/rust/compile/issue-4823.rs b/gcc/testsuite/rust/compile/issue-4823.rs new file mode 100644 index 000000000000..5a0edd385428 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4823.rs @@ -0,0 +1,23 @@ +#![feature(no_core)] +#![no_core] + +pub struct S; + +trait T { + const VALUE: i32; +} + +impl T for S { + const VALUE: i32 = 1; + // { dg-warning "unused name" "" { target *-*-* } .-1 } +} + +impl S { + const VALUE: i32 = 2; +} + +const RESULT: i32 = S::VALUE; + +pub fn test() -> i32 { + RESULT +} From 6655c7d8b09b84ed863b1b63d5ecd4bc91d928a5 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 31 Aug 2026 20:07:14 +0100 Subject: [PATCH 084/584] gccrs: Fix missing unconstrained check to look at the full argument Fixes Rust-GCC/gccrs#4822 gcc/rust/ChangeLog: * typecheck/rust-hir-type-check-base.cc (walk_type_to_constrain): prototype (walk_types_to_constrain): make sure to walk the argument too gcc/testsuite/ChangeLog: * rust/compile/issue-4822.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-type-check-base.cc | 5 ++++- gcc/testsuite/rust/compile/issue-4822.rs | 11 +++++++++++ 2 files changed, 15 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/rust/compile/issue-4822.rs diff --git a/gcc/rust/typecheck/rust-hir-type-check-base.cc b/gcc/rust/typecheck/rust-hir-type-check-base.cc index 97ff55400c3d..b53232a57e52 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-base.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-base.cc @@ -26,7 +26,6 @@ #include "rust-type-util.h" #include "rust-attribute-values.h" #include "rust-tyty.h" -#include "tree.h" namespace Rust { namespace Resolver { @@ -58,6 +57,9 @@ TypeCheckBase::ResolvePredicateFromBound ( is_qualified_type, is_super_trait); } +static void walk_type_to_constrain (std::set &constrained_symbols, + TyTy::BaseType &r); + static void walk_types_to_constrain (std::set &constrained_symbols, const TyTy::SubstitutionArgumentMappings &constraints) @@ -70,6 +72,7 @@ walk_types_to_constrain (std::set &constrained_symbols, const auto p = arg->get_root (); constrained_symbols.insert (p->get_ref ()); constrained_symbols.insert (p->get_ty_ref ()); + walk_type_to_constrain (constrained_symbols, *arg); if (p->has_substitutions_defined ()) { diff --git a/gcc/testsuite/rust/compile/issue-4822.rs b/gcc/testsuite/rust/compile/issue-4822.rs new file mode 100644 index 000000000000..45641ad3c5dc --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4822.rs @@ -0,0 +1,11 @@ +#![feature(lang_items, no_core)] +#![no_core] + +#[lang = "sized"] +trait Sized {} + +trait PartialEq {} + +impl PartialEq<[B; N]> for [A; N] {} + +fn main() {} From ea11d029071188caeb0cc575d1b41ffeb8a19bd1 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 31 Aug 2026 21:43:06 +0100 Subject: [PATCH 085/584] gccrs: Add hir lowering to trait item where clauses Fixes Rust-GCC/gccrs#4828 gcc/rust/ChangeLog: * hir/rust-ast-lower-implitem.cc (ASTLowerTraitItem::visit): lower where clauses gcc/testsuite/ChangeLog: * rust/compile/issue-4828.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/hir/rust-ast-lower-implitem.cc | 5 +++++ gcc/testsuite/rust/compile/issue-4828.rs | 18 ++++++++++++++++++ 2 files changed, 23 insertions(+) create mode 100644 gcc/testsuite/rust/compile/issue-4828.rs diff --git a/gcc/rust/hir/rust-ast-lower-implitem.cc b/gcc/rust/hir/rust-ast-lower-implitem.cc index bb08c3c36fab..16a7c3b4368c 100644 --- a/gcc/rust/hir/rust-ast-lower-implitem.cc +++ b/gcc/rust/hir/rust-ast-lower-implitem.cc @@ -234,6 +234,11 @@ void ASTLowerTraitItem::visit (AST::Function &func) { std::vector> where_clause_items; + where_clause_items.reserve (func.get_where_clause ().get_items ().size ()); + for (auto &item : func.get_where_clause ().get_items ()) + where_clause_items.emplace_back ( + ASTLowerWhereClauseItem::translate (*item.get ())); + HIR::WhereClause where_clause (std::move (where_clause_items)); HIR::FunctionQualifiers qualifiers = lower_qualifiers (func.get_qualifiers ()); diff --git a/gcc/testsuite/rust/compile/issue-4828.rs b/gcc/testsuite/rust/compile/issue-4828.rs new file mode 100644 index 000000000000..3dba752356be --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4828.rs @@ -0,0 +1,18 @@ +#![feature(lang_items, no_core)] +#![no_core] + +#[lang = "sized"] +trait Sized {} + +trait IntoIterator { + type IntoIter; +} + +pub struct Chain(A, B); + +trait Iterator { + fn chain(self, other: U) -> Chain + where + Self: Sized, + U: IntoIterator; +} From 4fec26e049607b7bd78134c7ef20126d355f1576 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 31 Aug 2026 22:31:38 +0100 Subject: [PATCH 086/584] gccrs: Add missing handling to variance analysis gcc/rust/ChangeLog: * typecheck/rust-tyty-variance-analysis.cc (GenericTyVisitorCtx::lookup_or_add_type): handle the other tyty types Signed-off-by: Philip Herron --- .../typecheck/rust-tyty-variance-analysis.cc | 24 +++++++++++++++---- 1 file changed, 19 insertions(+), 5 deletions(-) diff --git a/gcc/rust/typecheck/rust-tyty-variance-analysis.cc b/gcc/rust/typecheck/rust-tyty-variance-analysis.cc index ca8e9f6b1a82..6c6877ef9ecb 100644 --- a/gcc/rust/typecheck/rust-tyty-variance-analysis.cc +++ b/gcc/rust/typecheck/rust-tyty-variance-analysis.cc @@ -366,15 +366,29 @@ GenericTyVisitorCtx::lookup_or_add_type (HirId hir_id) } SubstitutionRef *subst = nullptr; - if (auto adt = ty->try_as ()) - { - subst = adt; - } - else + switch (ty->get_kind ()) { + case TypeKind::ADT: + subst = static_cast (ty); + break; + + case TypeKind::FNDEF: + subst = static_cast (ty); + break; + + case TypeKind::CLOSURE: + subst = static_cast (ty); + break; + + case TypeKind::PROJECTION: + subst = static_cast (ty); + break; + + default: rust_sorry_at ( ty->get_locus (), "This is a compiler bug: Unhandled type in variance analysis"); + break; } rust_assert (subst != nullptr); From 98e07649f16a314bcbf9d6c7a3e3fe64a236b9a8 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 31 Aug 2026 22:24:53 +0100 Subject: [PATCH 087/584] gccrs: make fn trait return optional This is just a basic patch to get past a crash in libcore we probably need to default to unit-type somewhere later on. gcc/rust/ChangeLog: * typecheck/rust-tyty-bounds.cc: handle assertion Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-tyty-bounds.cc | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/gcc/rust/typecheck/rust-tyty-bounds.cc b/gcc/rust/typecheck/rust-tyty-bounds.cc index f72ee57f93a5..fca42d61ad31 100644 --- a/gcc/rust/typecheck/rust-tyty-bounds.cc +++ b/gcc/rust/typecheck/rust-tyty-bounds.cc @@ -332,11 +332,6 @@ TypeCheckBase::get_predicate_from_bound ( std::make_unique (mapping, std::move (params_copy), final_seg.get_locus ())); - // resolve the fn_once_output type which assumes there must be an output - // set - rust_assert (fn.has_return_type ()); - TypeCheckType::Resolve (fn.get_return_type ()); - HIR::TraitItem *trait_item = mappings .lookup_trait_item_lang_item (LangItem::Kind::FN_ONCE_OUTPUT, @@ -344,10 +339,16 @@ TypeCheckBase::get_predicate_from_bound ( .value (); std::vector bindings; - location_t output_locus = fn.get_return_type ().get_locus (); - bindings.emplace_back (Identifier (trait_item->trait_identifier ()), - fn.get_return_type ().clone_type (), - output_locus); + + if (fn.has_return_type ()) + { + TypeCheckType::Resolve (fn.get_return_type ()); + + location_t output_locus = fn.get_return_type ().get_locus (); + bindings.emplace_back (Identifier (trait_item->trait_identifier ()), + fn.get_return_type ().clone_type (), + output_locus); + } args = HIR::GenericArgs ({} /* lifetimes */, std::move (inputs) /* type_args*/, From 83d9ebd601c11c3f976944f2f21037ae9e9e2081 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 31 Aug 2026 22:47:37 +0100 Subject: [PATCH 088/584] gccrs: Fix debug output of variance analysis to switch to substitutionref gcc/rust/ChangeLog: * typecheck/rust-tyty-variance-analysis.cc (GenericTyPerCrateCtx::debug_print_solutions): we can switch into a substitutionref base class to make this generic Signed-off-by: Philip Herron --- .../typecheck/rust-tyty-variance-analysis.cc | 62 +++++++++++-------- 1 file changed, 36 insertions(+), 26 deletions(-) diff --git a/gcc/rust/typecheck/rust-tyty-variance-analysis.cc b/gcc/rust/typecheck/rust-tyty-variance-analysis.cc index 6c6877ef9ecb..2b1a8b7db6f8 100644 --- a/gcc/rust/typecheck/rust-tyty-variance-analysis.cc +++ b/gcc/rust/typecheck/rust-tyty-variance-analysis.cc @@ -180,39 +180,49 @@ GenericTyPerCrateCtx::debug_print_solutions () BaseType *ty = lookup_type (ref); std::string result = "\t"; + SubstitutionRef *subst = nullptr; - if (auto adt = ty->try_as ()) + switch (ty->get_kind ()) { - result += adt->get_identifier (); - result += "<"; + case TypeKind::ADT: + subst = static_cast (ty); + break; + case TypeKind::FNDEF: + subst = static_cast (ty); + break; + case TypeKind::CLOSURE: + subst = static_cast (ty); + break; + case TypeKind::PROJECTION: + subst = static_cast (ty); + break; + default: + rust_unreachable (); + } - size_t i = solution_index; - for (auto ®ion : adt->get_used_arguments ().get_regions ()) - { - (void) region; - if (i > solution_index) - result += ", "; - result += solutions[i].as_string (); - i++; - } - for (auto ¶m : adt->get_substs ()) - { - if (i > solution_index) - result += ", "; - result += param.get_type_representation ().as_string (); - result += "="; - result += solutions[i].as_string (); - i++; - } + result += ty->get_name (); + result += "<"; - result += ">"; + size_t i = solution_index; + for (auto ®ion : subst->get_used_arguments ().get_regions ()) + { + (void) region; + if (i > solution_index) + result += ", "; + result += solutions[i].as_string (); + i++; } - else + for (auto ¶m : subst->get_substs ()) { - rust_sorry_at ( - ty->get_ref (), - "This is a compiler bug: Unhandled type in variance analysis"); + if (i > solution_index) + result += ", "; + result += param.get_type_representation ().as_string (); + result += "="; + result += solutions[i].as_string (); + i++; } + + result += ">"; rust_debug ("%s", result.c_str ()); } } From 41e36f5f9e1920b6ad5479e6d46c6f8548797be1 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Thu, 3 Sep 2026 11:14:20 +0100 Subject: [PATCH 089/584] gccrs: Add new resolution mode CANONICAL/REFERNECE to type-check-type When handling where clause items such as: fn check

() where P: Deref, P::Target: Marker What happens is the first 'P' used to get resolved to a reference hir-id item which meant that adding the bound to this position had no effect what needed to occur was bind it to the parent which meant i used name resolution to reverse lookup as a hack. This new mode for canonical gives us that parent in the first place so we can just add the bound directly now so no need for name resolution here Fixes Rust-GCC/gccrs#4829 gcc/rust/ChangeLog: * typecheck/rust-hir-type-check-type.cc (TypeCheckType::Resolve): new mode (TypeCheckType::visit): likewise (ResolveWhereClauseItem::visit): remove nr usage * typecheck/rust-hir-type-check-type.h: new mode gcc/testsuite/ChangeLog: * rust/compile/issue-4829-1.rs: New test. * rust/compile/issue-4829-2.rs: New test. Signed-off-by: Philip Herron --- .../typecheck/rust-hir-type-check-type.cc | 64 ++++--------------- gcc/rust/typecheck/rust-hir-type-check-type.h | 14 +++- gcc/testsuite/rust/compile/issue-4829-1.rs | 23 +++++++ gcc/testsuite/rust/compile/issue-4829-2.rs | 18 ++++++ 4 files changed, 66 insertions(+), 53 deletions(-) create mode 100644 gcc/testsuite/rust/compile/issue-4829-1.rs create mode 100644 gcc/testsuite/rust/compile/issue-4829-2.rs diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.cc b/gcc/rust/typecheck/rust-hir-type-check-type.cc index 112aba4c00f6..e44221a7e983 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-type.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-type.cc @@ -61,17 +61,17 @@ TypeCheckResolveGenericArguments::visit (HIR::TypePathSegmentGeneric &generic) } TyTy::BaseType * -TypeCheckType::Resolve (HIR::Type &type) +TypeCheckType::Resolve (HIR::Type &type, ResolutionMode mode) { // is it already resolved? auto context = TypeCheckContext::get (); TyTy::BaseType *resolved = nullptr; bool already_resolved = context->lookup_type (type.get_mappings ().get_hirid (), &resolved); - if (already_resolved) + if (already_resolved && mode == ResolutionMode::REFERENCE) return resolved; - TypeCheckType resolver (type.get_mappings ().get_hirid ()); + TypeCheckType resolver (type.get_mappings ().get_hirid (), mode); type.accept_vis (resolver); rust_assert (resolver.translated != nullptr); resolver.context->insert_type (type.get_mappings (), resolver.translated); @@ -153,9 +153,14 @@ TypeCheckType::visit (HIR::TypePath &path) return; } - TyTy::BaseType *path_type = root->clone (); - path_type->set_ref (path.get_mappings ().get_hirid ()); - context->insert_implicit_type (path.get_mappings ().get_hirid (), path_type); + TyTy::BaseType *path_type = root; + if (mode == ResolutionMode::REFERENCE) + { + path_type = root->clone (); + path_type->set_ref (path.get_mappings ().get_hirid ()); + context->insert_implicit_type (path.get_mappings ().get_hirid (), + path_type); + } bool fully_resolved = offset >= path.get_segments ().size (); if (fully_resolved) @@ -1048,7 +1053,9 @@ ResolveWhereClauseItem::visit (HIR::TypeBoundWhereClauseItem &item) } auto &binding_type_path = item.get_bound_type (); - TyTy::BaseType *binding = TypeCheckType::Resolve (binding_type_path); + TyTy::BaseType *binding + = TypeCheckType::Resolve (binding_type_path, + TypeCheckType::ResolutionMode::CANONICAL); // FIXME double check there might be a trait cycle here see TypeParam handling @@ -1089,49 +1096,6 @@ ResolveWhereClauseItem::visit (HIR::TypeBoundWhereClauseItem &item) } } binding->inherit_bounds (specified_bounds); - - // When we apply these bounds we must lookup which type this binding - // resolves to, as this is the type which will be used during resolution - // of the block. - NodeId ast_node_id = binding_type_path.get_mappings ().get_nodeid (); - - // then lookup the reference_node_id - NodeId ref_node_id = UNKNOWN_NODEID; - - auto &nr_ctx = Resolver2_0::FinalizedNameResolutionContext::get (); - - if (auto id = nr_ctx.lookup (ast_node_id, Resolver2_0::Namespace::Types)) - { - ref_node_id = *id; - } - else - { - // FIXME - rust_error_at (UNDEF_LOCATION, - "Failed to lookup type reference for node: %s", - binding_type_path.to_string ().c_str ()); - return; - } - - // node back to HIR - if (auto hid = mappings.lookup_node_to_hir (ref_node_id)) - { - // the base reference for this name _must_ have a type set - TyTy::BaseType *lookup; - if (!context->lookup_type (*hid, &lookup)) - { - rust_error_at (mappings.lookup_location (*hid), - "Failed to resolve where-clause binding type: %s", - binding_type_path.to_string ().c_str ()); - return; - } - - // FIXME - // rust_assert (binding->is_equal (*lookup)); - lookup->inherit_bounds (specified_bounds); - return; - } - rust_error_at (UNDEF_LOCATION, "where-clause reverse lookup failure"); } } // namespace Resolver diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.h b/gcc/rust/typecheck/rust-hir-type-check-type.h index 27d2ae40af0c..9cc0fdbc3e97 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-type.h +++ b/gcc/rust/typecheck/rust-hir-type-check-type.h @@ -46,7 +46,14 @@ class TypeCheckResolveGenericArguments : public TypeCheckBase class TypeCheckType : public TypeCheckBase, public HIR::HIRTypeVisitor { public: - static TyTy::BaseType *Resolve (HIR::Type &type); + enum class ResolutionMode + { + REFERENCE, + CANONICAL + }; + + static TyTy::BaseType *Resolve (HIR::Type &type, ResolutionMode mode + = ResolutionMode::REFERENCE); void visit (HIR::BareFunctionType &fntype) override; void visit (HIR::TupleType &tuple) override; @@ -67,8 +74,8 @@ class TypeCheckType : public TypeCheckBase, public HIR::HIRTypeVisitor void visit (HIR::TraitBound &bound) override {} private: - TypeCheckType (HirId id) - : TypeCheckBase (), translated (new TyTy::ErrorType (id)) + TypeCheckType (HirId id, ResolutionMode mode) + : TypeCheckBase (), translated (new TyTy::ErrorType (id)), mode (mode) {} TyTy::BaseType *resolve_root_path (HIR::TypePath &path, size_t *offset, @@ -89,6 +96,7 @@ class TypeCheckType : public TypeCheckBase, public HIR::HIRTypeVisitor bool ty_seg_is_big_self, TyTy::BaseType **result); TyTy::BaseType *translated; + ResolutionMode mode; }; class TypeResolveGenericParam : public TypeCheckBase diff --git a/gcc/testsuite/rust/compile/issue-4829-1.rs b/gcc/testsuite/rust/compile/issue-4829-1.rs new file mode 100644 index 000000000000..906beb596de7 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4829-1.rs @@ -0,0 +1,23 @@ +#![feature(lang_items, no_core)] +#![no_core] + +#[lang = "sized"] +trait Sized {} + +trait Iterator { + type Item; +} + +trait IntoIterator { + type IntoIter; +} + +pub struct FlattenCompat(I, U); + +pub struct Flatten +where + I: Iterator, + I::Item: IntoIterator, +{ + pub inner: FlattenCompat::IntoIter>, +} diff --git a/gcc/testsuite/rust/compile/issue-4829-2.rs b/gcc/testsuite/rust/compile/issue-4829-2.rs new file mode 100644 index 000000000000..fa3643ad85b0 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4829-2.rs @@ -0,0 +1,18 @@ +#![feature(lang_items, no_core)] +#![no_core] + +#[lang = "sized"] +trait Sized {} + +trait Deref { + type Target; +} + +trait Marker {} + +pub fn check

() +where + P: Deref, + P::Target: Marker, +{ +} From 50507b79c724fff0ce53e61b93bb34b97cecb07a Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Thu, 3 Sep 2026 19:59:49 +0100 Subject: [PATCH 090/584] gccrs: Fix parser handling for Foo The parser only recognized Foo for the generic type bindings syntax. This parses both flavours now into update generic args type. Fixes Rust-GCC/gccrs#1726 gcc/rust/ChangeLog: * ast/rust-path.cc (GenericArgsBinding::as_string): new format * ast/rust-path.h (struct GenericArgsBinding): new kinds for bindings * hir/rust-ast-lower-base.cc (ASTLoweringBase::lower_binding): new * hir/tree/rust-hir-path.cc (GenericArgsBinding::GenericArgsBinding): likewise (GenericArgsBinding::operator=): likewise * hir/tree/rust-hir-path.h (class GenericArgsBinding): likewise * hir/tree/rust-hir.cc (GenericArgsBinding::to_string): likewise * parse/rust-parse-impl.hxx: peek for both types * typecheck/rust-type-util.cc (normalize_projection): track constrains * typecheck/rust-tyty-bounds.cc (TypeBoundPredicate::TypeBoundPredicate): new ctor (TypeBoundPredicate::operator=): likewise * typecheck/rust-tyty-subst.cc (SubstitutionArgumentMappings::get_constraint_args): new * typecheck/rust-tyty-subst.h: new * typecheck/rust-unify.cc (UnifyRules::expect_projection): fix loop gcc/testsuite/ChangeLog: * rust/compile/associated-type-bound.rs: New test. * rust/compile/issue-1726-1.rs: New test. * rust/compile/issue-1726-2.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/ast/rust-path.cc | 5 +- gcc/rust/ast/rust-path.h | 20 ++++++-- gcc/rust/hir/rust-ast-lower-base.cc | 13 ++++- gcc/rust/hir/tree/rust-hir-path.cc | 8 +-- gcc/rust/hir/tree/rust-hir-path.h | 13 ++++- gcc/rust/hir/tree/rust-hir.cc | 4 +- gcc/rust/parse/rust-parse-impl.hxx | 18 +++++-- gcc/rust/typecheck/rust-type-util.cc | 18 +++++++ gcc/rust/typecheck/rust-tyty-bounds.cc | 18 +++---- gcc/rust/typecheck/rust-tyty-subst.cc | 49 ++++++++++++------ gcc/rust/typecheck/rust-tyty-subst.h | 15 +++--- gcc/rust/typecheck/rust-unify.cc | 6 +++ .../rust/compile/associated-type-bound.rs | 50 +++++++++++++++++++ gcc/testsuite/rust/compile/issue-1726-1.rs | 17 +++++++ gcc/testsuite/rust/compile/issue-1726-2.rs | 42 ++++++++++++++++ 15 files changed, 248 insertions(+), 48 deletions(-) create mode 100644 gcc/testsuite/rust/compile/associated-type-bound.rs create mode 100644 gcc/testsuite/rust/compile/issue-1726-1.rs create mode 100644 gcc/testsuite/rust/compile/issue-1726-2.rs diff --git a/gcc/rust/ast/rust-path.cc b/gcc/rust/ast/rust-path.cc index 5260adc8aed8..e8b885cbcd34 100644 --- a/gcc/rust/ast/rust-path.cc +++ b/gcc/rust/ast/rust-path.cc @@ -108,8 +108,9 @@ GenericArg::disambiguate_to_type () const std::string GenericArgsBinding::as_string () const { - // TODO: rewrite to work with non-literalisable types - return identifier.as_string () + " = " + type->as_string (); + auto type_string = type->as_string (); + auto separator = kind == Kind::Constraint ? " : " : " = "; + return identifier.as_string () + separator + type_string; } std::string diff --git a/gcc/rust/ast/rust-path.h b/gcc/rust/ast/rust-path.h index 3ce7ed7ef347..ecb156e907cc 100644 --- a/gcc/rust/ast/rust-path.h +++ b/gcc/rust/ast/rust-path.h @@ -71,10 +71,18 @@ class PathIdentSegment // A binding of an identifier to a type used in generic arguments in paths struct GenericArgsBinding { +public: + enum class Kind + { + Equality, + Constraint + }; + private: Identifier identifier; std::unique_ptr type; location_t locus; + Kind kind; public: // Returns whether binding is in an error state. @@ -90,7 +98,7 @@ struct GenericArgsBinding if (type) new_type = type->reconstruct (); - return GenericArgsBinding (identifier, std::move (new_type), locus); + return GenericArgsBinding (identifier, std::move (new_type), locus, kind); } // Creates an error state generic args binding. @@ -101,13 +109,15 @@ struct GenericArgsBinding // Pointer type for type in constructor to enable polymorphism GenericArgsBinding (Identifier ident, std::unique_ptr type_ptr, - location_t locus = UNDEF_LOCATION) - : identifier (std::move (ident)), type (std::move (type_ptr)), locus (locus) + location_t locus = UNDEF_LOCATION, + Kind kind = Kind::Equality) + : identifier (std::move (ident)), type (std::move (type_ptr)), + locus (locus), kind (kind) {} // Copy constructor has to deep copy the type as it is a unique pointer GenericArgsBinding (GenericArgsBinding const &other) - : identifier (other.identifier), locus (other.locus) + : identifier (other.identifier), locus (other.locus), kind (other.kind) { // guard to protect from null pointer dereference if (other.type != nullptr) @@ -122,6 +132,7 @@ struct GenericArgsBinding { identifier = other.identifier; locus = other.locus; + kind = other.kind; // guard to protect from null pointer dereference if (other.type != nullptr) @@ -154,6 +165,7 @@ struct GenericArgsBinding location_t get_locus () const { return locus; } Identifier get_identifier () const { return identifier; } + Kind get_kind () const { return kind; } }; /* Class representing a const generic application */ diff --git a/gcc/rust/hir/rust-ast-lower-base.cc b/gcc/rust/hir/rust-ast-lower-base.cc index a4ab5d5edbc8..33b1c2f51ad4 100644 --- a/gcc/rust/hir/rust-ast-lower-base.cc +++ b/gcc/rust/hir/rust-ast-lower-base.cc @@ -651,10 +651,19 @@ ASTLoweringBase::lower_path_expr_seg (AST::PathExprSegment &s) HIR::GenericArgsBinding ASTLoweringBase::lower_binding (AST::GenericArgsBinding &binding) { - HIR::Type *lowered_type = ASTLoweringType::translate (binding.get_type ()); + auto impl_trait_allowed + = binding.get_kind () == AST::GenericArgsBinding::Kind::Constraint + ? ASTLoweringType::ImplTrait::Allow + : ASTLoweringType::ImplTrait::Forbid; + HIR::Type *lowered_type + = ASTLoweringType::translate (binding.get_type (), false, + impl_trait_allowed); + auto kind = binding.get_kind () == AST::GenericArgsBinding::Kind::Constraint + ? HIR::GenericArgsBinding::Kind::Constraint + : HIR::GenericArgsBinding::Kind::Equality; return HIR::GenericArgsBinding (binding.get_identifier (), std::unique_ptr (lowered_type), - binding.get_locus ()); + binding.get_locus (), kind); } HIR::GenericArgs diff --git a/gcc/rust/hir/tree/rust-hir-path.cc b/gcc/rust/hir/tree/rust-hir-path.cc index b887d0e07b2b..1c1117f93004 100644 --- a/gcc/rust/hir/tree/rust-hir-path.cc +++ b/gcc/rust/hir/tree/rust-hir-path.cc @@ -25,13 +25,14 @@ namespace HIR { GenericArgsBinding::GenericArgsBinding (Identifier ident, std::unique_ptr type_ptr, - location_t locus) - : identifier (std::move (ident)), type (std::move (type_ptr)), locus (locus) + location_t locus, Kind kind) + : identifier (std::move (ident)), type (std::move (type_ptr)), locus (locus), + kind (kind) {} GenericArgsBinding::GenericArgsBinding (GenericArgsBinding const &other) : identifier (other.identifier), type (other.type->clone_type ()), - locus (other.locus) + locus (other.locus), kind (other.kind) {} GenericArgsBinding & @@ -40,6 +41,7 @@ GenericArgsBinding::operator= (GenericArgsBinding const &other) identifier = other.identifier; type = other.type->clone_type (); locus = other.locus; + kind = other.kind; return *this; } diff --git a/gcc/rust/hir/tree/rust-hir-path.h b/gcc/rust/hir/tree/rust-hir-path.h index c6b3cbfab376..b9de6b90b909 100644 --- a/gcc/rust/hir/tree/rust-hir-path.h +++ b/gcc/rust/hir/tree/rust-hir-path.h @@ -63,10 +63,19 @@ class PathIdentSegment // A binding of an identifier to a type used in generic arguments in paths class GenericArgsBinding { +public: + enum class Kind + { + Equality, + Constraint + }; + +private: Identifier identifier; std::unique_ptr type; location_t locus; + Kind kind; public: // Returns whether binding is in an error state. @@ -84,7 +93,8 @@ class GenericArgsBinding // Pointer type for type in constructor to enable polymorphism GenericArgsBinding (Identifier ident, std::unique_ptr type_ptr, - location_t locus = UNDEF_LOCATION); + location_t locus = UNDEF_LOCATION, + Kind kind = Kind::Equality); // Copy constructor has to deep copy the type as it is a unique pointer GenericArgsBinding (GenericArgsBinding const &other); @@ -116,6 +126,7 @@ class GenericArgsBinding } location_t get_locus () const { return locus; } + Kind get_kind () const { return kind; } }; class ConstGenericArg diff --git a/gcc/rust/hir/tree/rust-hir.cc b/gcc/rust/hir/tree/rust-hir.cc index 7d611ed5c76b..00db9fc64557 100644 --- a/gcc/rust/hir/tree/rust-hir.cc +++ b/gcc/rust/hir/tree/rust-hir.cc @@ -2387,7 +2387,9 @@ GenericArgs::to_string () const std::string GenericArgsBinding::to_string () const { - return identifier.as_string () + " = " + type->to_string (); + auto type_string = type->to_string (); + auto separator = kind == Kind::Constraint ? " : " : " = "; + return identifier.as_string () + separator + type_string; } std::string diff --git a/gcc/rust/parse/rust-parse-impl.hxx b/gcc/rust/parse/rust-parse-impl.hxx index b5f41768541c..652f128c6ce1 100644 --- a/gcc/rust/parse/rust-parse-impl.hxx +++ b/gcc/rust/parse/rust-parse-impl.hxx @@ -5247,7 +5247,8 @@ Parser::parse_path_generic_args () // ensure not binding being parsed as type accidently if (t->get_id () == IDENTIFIER - && lexer.peek_token (1)->get_id () == EQUAL) + && (lexer.peek_token (1)->get_id () == EQUAL + || lexer.peek_token (1)->get_id () == COLON)) break; auto arg = parse_generic_arg (); @@ -5324,12 +5325,21 @@ Parser::parse_generic_args_binding () lexer.skip_token (); Identifier ident{ident_tok}; - if (!skip_token (EQUAL)) + if (lexer.peek_token ()->get_id () == COLON) { - // skip after somewhere? - return AST::GenericArgsBinding::create_error (); + lexer.skip_token (); + auto bounds_locus = lexer.peek_token ()->get_locus (); + auto bounds = parse_type_param_bounds (); + auto type = std::unique_ptr ( + new AST::ImplTraitType (std::move (bounds), bounds_locus)); + return AST::GenericArgsBinding ( + std::move (ident), std::move (type), ident_tok->get_locus (), + AST::GenericArgsBinding::Kind::Constraint); } + if (!skip_token (EQUAL)) + return AST::GenericArgsBinding::create_error (); + // parse type (required) std::unique_ptr type = parse_type (); if (type == nullptr) diff --git a/gcc/rust/typecheck/rust-type-util.cc b/gcc/rust/typecheck/rust-type-util.cc index 21559cb2a8df..005defb50a6b 100644 --- a/gcc/rust/typecheck/rust-type-util.cc +++ b/gcc/rust/typecheck/rust-type-util.cc @@ -679,6 +679,24 @@ normalize_projection (TyTy::ProjectionType *proj, location_t locus, auto it = binding.find (assoc_name); if (it != binding.end ()) return it->second; + + const auto &constraints + = bound.get_substitution_arguments ().get_constraint_args (); + auto constraint = constraints.find (assoc_name); + if (constraint != constraints.end ()) + { + TyTy::BaseType *constrained = proj->clone (); + constrained->inherit_bounds (*constraint->second); + + // Keep the constrained projection distinct from the canonical + // associated-type declaration. + auto &mappings = Analysis::Mappings::get (); + HirId fresh = mappings.get_next_hir_id (); + constrained->set_ref (fresh); + constrained->set_ty_ref (fresh); + ctx->insert_implicit_type (fresh, constrained); + return constrained; + } } } diff --git a/gcc/rust/typecheck/rust-tyty-bounds.cc b/gcc/rust/typecheck/rust-tyty-bounds.cc index fca42d61ad31..5a1e02fe8944 100644 --- a/gcc/rust/typecheck/rust-tyty-bounds.cc +++ b/gcc/rust/typecheck/rust-tyty-bounds.cc @@ -469,11 +469,10 @@ TypeBoundPredicate::TypeBoundPredicate (const TypeBoundPredicate &other) copied_arg_mappings.push_back (std::move (c)); } - used_arguments - = SubstitutionArgumentMappings (copied_arg_mappings, - other.used_arguments.get_binding_args (), - other.used_arguments.get_regions (), - other.used_arguments.get_locus ()); + used_arguments = SubstitutionArgumentMappings ( + copied_arg_mappings, other.used_arguments.get_binding_args (), + other.used_arguments.get_regions (), other.used_arguments.get_locus (), + nullptr, false, false, other.used_arguments.get_constraint_args ()); } TypeBoundPredicate & @@ -511,11 +510,10 @@ TypeBoundPredicate::operator= (const TypeBoundPredicate &other) copied_arg_mappings.emplace_back (&substitutions.at (i++), argument); } - used_arguments - = SubstitutionArgumentMappings (copied_arg_mappings, - other.used_arguments.get_binding_args (), - other.used_arguments.get_regions (), - other.used_arguments.get_locus ()); + used_arguments = SubstitutionArgumentMappings ( + copied_arg_mappings, other.used_arguments.get_binding_args (), + other.used_arguments.get_regions (), other.used_arguments.get_locus (), + nullptr, false, false, other.used_arguments.get_constraint_args ()); super_traits = other.super_traits; return *this; diff --git a/gcc/rust/typecheck/rust-tyty-subst.cc b/gcc/rust/typecheck/rust-tyty-subst.cc index 46e22288c2bc..bed285eeeebe 100644 --- a/gcc/rust/typecheck/rust-tyty-subst.cc +++ b/gcc/rust/typecheck/rust-tyty-subst.cc @@ -336,16 +336,18 @@ SubstitutionArgumentMappings::SubstitutionArgumentMappings ( std::vector mappings, std::map binding_args, RegionParamList regions, location_t locus, ParamSubstCb param_subst_cb, bool trait_item_flag, - bool error_flag) + bool error_flag, std::map constraint_args) : mappings (std::move (mappings)), binding_args (binding_args), - regions (regions), locus (locus), param_subst_cb (param_subst_cb), - trait_item_flag (trait_item_flag), error_flag (error_flag) + constraint_args (constraint_args), regions (regions), locus (locus), + param_subst_cb (param_subst_cb), trait_item_flag (trait_item_flag), + error_flag (error_flag) {} SubstitutionArgumentMappings::SubstitutionArgumentMappings ( const SubstitutionArgumentMappings &other) : mappings (other.mappings), binding_args (other.binding_args), - regions (other.regions), locus (other.locus), param_subst_cb (nullptr), + constraint_args (other.constraint_args), regions (other.regions), + locus (other.locus), param_subst_cb (nullptr), trait_item_flag (other.trait_item_flag), error_flag (other.error_flag) {} @@ -355,6 +357,7 @@ SubstitutionArgumentMappings::operator= ( { mappings = other.mappings; binding_args = other.binding_args; + constraint_args = other.constraint_args; regions = other.regions; locus = other.locus; param_subst_cb = nullptr; @@ -476,6 +479,12 @@ SubstitutionArgumentMappings::get_binding_args () const return binding_args; } +const std::map & +SubstitutionArgumentMappings::get_constraint_args () const +{ + return constraint_args; +} + std::string SubstitutionArgumentMappings::as_string () const { @@ -685,6 +694,7 @@ SubstitutionRef::get_mappings_from_generic_args ( HIR::GenericArgs &args, const std::vector ®ions) { std::map binding_arguments; + std::map constraint_arguments; if (args.get_binding_args ().size () > 0) { if (supports_associated_bindings ()) @@ -721,8 +731,13 @@ SubstitutionRef::get_mappings_from_generic_args ( return SubstitutionArgumentMappings::error (); } - binding_arguments[binding.get_identifier ().as_string ()] - = resolved; + if (binding.get_kind () + == HIR::GenericArgsBinding::Kind::Constraint) + constraint_arguments[binding.get_identifier ().as_string ()] + = resolved; + else + binding_arguments[binding.get_identifier ().as_string ()] + = resolved; } } else @@ -945,10 +960,15 @@ SubstitutionRef::get_mappings_from_generic_args ( } } - return {mappings, binding_arguments, + return {mappings, + binding_arguments, RegionParamList::from_subst (used_arguments.get_regions ().size (), regions), - args.get_locus ()}; + args.get_locus (), + nullptr, + false, + false, + constraint_arguments}; } BaseType * @@ -1036,12 +1056,10 @@ SubstitutionRef::adjust_mappings_for_this ( if (resolved_mappings.empty ()) return SubstitutionArgumentMappings::error (); - return SubstitutionArgumentMappings (resolved_mappings, - mappings.get_binding_args (), - mappings.get_regions (), - mappings.get_locus (), - mappings.get_subst_cb (), - mappings.trait_item_mode ()); + return SubstitutionArgumentMappings ( + resolved_mappings, mappings.get_binding_args (), mappings.get_regions (), + mappings.get_locus (), mappings.get_subst_cb (), + mappings.trait_item_mode (), false, mappings.get_constraint_args ()); } bool @@ -1101,7 +1119,8 @@ SubstitutionRef::solve_mappings_from_receiver_for_self ( return SubstitutionArgumentMappings (resolved_mappings, mappings.get_binding_args (), mappings.get_regions (), - mappings.get_locus ()); + mappings.get_locus (), nullptr, false, + false, mappings.get_constraint_args ()); } bool diff --git a/gcc/rust/typecheck/rust-tyty-subst.h b/gcc/rust/typecheck/rust-tyty-subst.h index 8a71f8907ff2..947488afbfa9 100644 --- a/gcc/rust/typecheck/rust-tyty-subst.h +++ b/gcc/rust/typecheck/rust-tyty-subst.h @@ -175,12 +175,12 @@ typedef std::function class SubstitutionArgumentMappings { public: - SubstitutionArgumentMappings (std::vector mappings, - std::map binding_args, - RegionParamList regions, location_t locus, - ParamSubstCb param_subst_cb = nullptr, - bool trait_item_flag = false, - bool error_flag = false); + SubstitutionArgumentMappings ( + std::vector mappings, + std::map binding_args, RegionParamList regions, + location_t locus, ParamSubstCb param_subst_cb = nullptr, + bool trait_item_flag = false, bool error_flag = false, + std::map constraint_args = {}); SubstitutionArgumentMappings (const SubstitutionArgumentMappings &other); SubstitutionArgumentMappings & @@ -233,6 +233,8 @@ class SubstitutionArgumentMappings const std::map &get_binding_args () const; + const std::map &get_constraint_args () const; + const RegionParamList &get_regions () const; RegionParamList &get_mut_regions (); @@ -247,6 +249,7 @@ class SubstitutionArgumentMappings private: std::vector mappings; std::map binding_args; + std::map constraint_args; RegionParamList regions; location_t locus; ParamSubstCb param_subst_cb; diff --git a/gcc/rust/typecheck/rust-unify.cc b/gcc/rust/typecheck/rust-unify.cc index 32aebff52593..e6a863a5bd0f 100644 --- a/gcc/rust/typecheck/rust-unify.cc +++ b/gcc/rust/typecheck/rust-unify.cc @@ -1989,6 +1989,12 @@ UnifyRules::expect_projection (TyTy::ProjectionType *ltype, { if (ltype->is_trait_position ()) { + // A trait-position projection whose Self is still generic cannot be + // normalized against a concrete impl candidate. + auto dself = ltype->get_self ()->destructure (); + if (dself->is ()) + return ltype; + TyTy::BaseType *ln = normalize_projection (ltype, locus, false, false); if (ln != nullptr && ln != ltype) diff --git a/gcc/testsuite/rust/compile/associated-type-bound.rs b/gcc/testsuite/rust/compile/associated-type-bound.rs new file mode 100644 index 000000000000..43cc57533322 --- /dev/null +++ b/gcc/testsuite/rust/compile/associated-type-bound.rs @@ -0,0 +1,50 @@ +#![feature(lang_items, no_core)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +pub trait Iterator { + type Item; +} + +pub trait IntoIterator { + type IntoIter; +} + +pub struct FlattenCompat(I, U); + +pub struct Flatten> { + pub inner: FlattenCompat::IntoIter>, +} + +pub trait Foo { + type Bar; + + fn foo(&self); +} + +pub trait Copy {} + +pub trait Container { + type Item; +} + +pub fn c>(value: &F::Bar) +where + F::Bar: Copy, +{ + value.foo(); +} + +pub fn nested>() { + let _: *const ::Bar; +} + +pub fn multiple_bounds>() { + let _: *const ::Bar; +} + +pub fn positional_and_bound>() { + let _: *const ::Bar; +} diff --git a/gcc/testsuite/rust/compile/issue-1726-1.rs b/gcc/testsuite/rust/compile/issue-1726-1.rs new file mode 100644 index 000000000000..0e78fff3ced7 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-1726-1.rs @@ -0,0 +1,17 @@ +#![feature(lang_items, no_core)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +pub trait Foo { + type Bar; +} + +pub trait Copy {} + +pub fn c>() +where + F::Bar: Copy, +{ +} diff --git a/gcc/testsuite/rust/compile/issue-1726-2.rs b/gcc/testsuite/rust/compile/issue-1726-2.rs new file mode 100644 index 000000000000..4808b5709f3b --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-1726-2.rs @@ -0,0 +1,42 @@ +#![feature(lang_items, no_core)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +pub trait Foo { + type Bar; + + fn foo(&self); +} + +pub trait Copy {} + +pub fn c>(value: &F::Bar) +where + F::Bar: Copy, +{ + value.foo(); +} + +pub struct Outer; +pub struct Inner; + +impl Foo for Outer { + type Bar = Inner; + + fn foo(&self) {} +} + +impl Foo for Inner { + type Bar = Inner; + + fn foo(&self) {} +} + +impl Copy for Inner {} + +pub fn main() { + let inner = Inner; + c::(&inner); +} From 2feace205d944c382b9fccc64ca56e6885e16d0d Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Thu, 3 Sep 2026 22:19:25 +0100 Subject: [PATCH 091/584] gccrs: Remove bad unify in operator overload breaking partial eq in core gcc/rust/ChangeLog: * typecheck/rust-hir-type-check-expr.cc: remove old hack Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-type-check-expr.cc | 5 ----- 1 file changed, 5 deletions(-) diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc index 48145c8df73a..4824209aecbb 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc @@ -2110,11 +2110,6 @@ TypeCheckExpr::resolve_operator_overload ( lang_item_type, specified_segment, pred, expr); context->insert_deferred_operator_overload (std::move (defer)); - if (rhs != nullptr) - lhs = unify_site (expr.get_mappings ().get_hirid (), - TyTy::TyWithLocation (lhs), - TyTy::TyWithLocation (rhs), expr.get_locus ()); - infered = unify_site (expr.get_mappings ().get_hirid (), TyTy::TyWithLocation (lhs), TyTy::TyWithLocation (infer), expr.get_locus ()); From 75d28dc91e230553cb433239681a2e142936d210 Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Wed, 2 Sep 2026 12:03:54 +0200 Subject: [PATCH 092/584] gccrs: Simplify crate number lookup Uses the hir mapping getter instead of directly using the set. gcc/rust/ChangeLog: * util/rust-hir-map.cc (Mappings::get_ast_crate_by_node_id_raw): Use appropriate getter. Signed-off-by: Pierre-Emmanuel Patry --- gcc/rust/util/rust-hir-map.cc | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index 87fca310e026..3d8da522eb18 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -258,10 +258,7 @@ Mappings::get_ast_crate_by_node_id (NodeId id) AST::Crate * Mappings::get_ast_crate_by_node_id_raw (NodeId id) { - auto i = crate_node_to_crate_num.find (id); - rust_assert (i != crate_node_to_crate_num.end ()); - - CrateNum crateNum = i->second; + CrateNum crateNum = lookup_crate_num (id).value (); auto it = ast_crate_mappings.find (crateNum); rust_assert (it != ast_crate_mappings.end ()); return it->second; From 681fb2543a44c895c989d6a68d5ac6d01ae49bc9 Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Thu, 3 Sep 2026 19:26:12 +0200 Subject: [PATCH 093/584] gccrs: Replace indexing with reverse iterator This change makes the code a bit simpler, it comes from a series of patch that got deleted and was iterating backward on the self segments. gcc/rust/ChangeLog: * resolve/rust-early-name-resolver-2.0.cc (Early::finalize_rebind_import): Use a reverse iterator instead of an index. Signed-off-by: Pierre-Emmanuel Patry --- gcc/rust/resolve/rust-early-name-resolver-2.0.cc | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/gcc/rust/resolve/rust-early-name-resolver-2.0.cc b/gcc/rust/resolve/rust-early-name-resolver-2.0.cc index 28e1d90a5348..cb67af3e9b3d 100644 --- a/gcc/rust/resolve/rust-early-name-resolver-2.0.cc +++ b/gcc/rust/resolve/rust-early-name-resolver-2.0.cc @@ -540,8 +540,11 @@ Early::finalize_rebind_import (const Early::ImportPair &mapping) // Erroneous `self` or `{self}` use declaration if (segments.size () == 1) return; - declared_name = segments[segments.size () - 2].as_string (); - import_id = segments[segments.size () - 2].get_node_id (); + + auto pre_self_segment = segments.rbegin () + 1; + + declared_name = pre_self_segment->as_string (); + import_id = pre_self_segment->get_node_id (); } else { From 9c1da61f610c11febcc880ee1dc65aaec5e03847 Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Thu, 3 Sep 2026 21:37:33 +0200 Subject: [PATCH 094/584] gccrs: Do not continue when self is malformed If a self segment is malformed we do not want to continue as the node id retrieved during import finalization may crash the compiler. Fixes Rust-GCC/gccrs#4735 gcc/rust/ChangeLog: * resolve/rust-early-name-resolver-2.0.cc (Early::visit): Return on error. Signed-off-by: Pierre-Emmanuel Patry --- gcc/rust/resolve/rust-early-name-resolver-2.0.cc | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/gcc/rust/resolve/rust-early-name-resolver-2.0.cc b/gcc/rust/resolve/rust-early-name-resolver-2.0.cc index cb67af3e9b3d..aae601e92465 100644 --- a/gcc/rust/resolve/rust-early-name-resolver-2.0.cc +++ b/gcc/rust/resolve/rust-early-name-resolver-2.0.cc @@ -594,8 +594,12 @@ Early::visit (AST::UseDeclaration &decl) if (rebind.get_path ().get_final_segment ().is_lower_self_seg ()) { collect_error ( - Error (decl.get_locus (), ErrorCode::E0429, + Error (rebind.get_path ().get_final_segment ().get_locus (), + ErrorCode::E0429, "% imports are only allowed within a { } list")); + // We must not continue, malformed use declaration must not be + // finalized. + return; } } From fc24ed206c4b6dd0c9c44182df1ebd8b147a6e84 Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Thu, 3 Sep 2026 23:12:00 +0200 Subject: [PATCH 095/584] gccrs: Add test to highlight issue Rust-GCC/gccrs#4735 gcc/testsuite/ChangeLog: * rust/compile/issue-4735.rs: New test. Signed-off-by: Pierre-Emmanuel Patry --- gcc/testsuite/rust/compile/issue-4735.rs | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 gcc/testsuite/rust/compile/issue-4735.rs diff --git a/gcc/testsuite/rust/compile/issue-4735.rs b/gcc/testsuite/rust/compile/issue-4735.rs new file mode 100644 index 000000000000..53e56e1803db --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4735.rs @@ -0,0 +1,4 @@ +#![feature(no_core)] +#![no_core] +use self::self; +// { dg-error ".self. imports are only allowed within a" {} { target *-*-* } .-1 } From 171c78338e14be092263edd243bb78b77a01ab76 Mon Sep 17 00:00:00 2001 From: Yap Zhi Heng Date: Sat, 5 Sep 2026 13:31:13 +0800 Subject: [PATCH 096/584] gccrs: Remove rust_unreachable from grs_langhook_pushdecl grs_langhook_pushdecl was being called after adding targetm.init_builtins() call to gccrs's setup, which caused ICE on aarch64 build targets. gcc/rust/ChangeLog: * rust-lang.cc (grs_langhook_pushdecl): Remove rust_unreachable(). Signed-off-by: Yap Zhi Heng --- gcc/rust/rust-lang.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/rust/rust-lang.cc b/gcc/rust/rust-lang.cc index 52f6e5a5b12a..44b8daa110d6 100644 --- a/gcc/rust/rust-lang.cc +++ b/gcc/rust/rust-lang.cc @@ -255,7 +255,7 @@ grs_langhook_global_bindings_p (void) static tree grs_langhook_pushdecl (tree decl ATTRIBUTE_UNUSED) { - rust_unreachable (); + // rust_unreachable (); return NULL; } From db08240a8dddc9e89d382db12196449617548715 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Thu, 3 Sep 2026 21:19:01 +0100 Subject: [PATCH 097/584] gccrs: method resolution try predicate items first This is part 1 of more series of patches to improve method resolution perf because its incredibly expensive operation. This changes it so that we try predicates up front before looking up anything. gcc/rust/ChangeLog: * typecheck/rust-hir-dot-operator.cc (MethodResolver::select): look at predicates first Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-dot-operator.cc | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/gcc/rust/typecheck/rust-hir-dot-operator.cc b/gcc/rust/typecheck/rust-hir-dot-operator.cc index 227e5dce1de6..e42c4b90a2e6 100644 --- a/gcc/rust/typecheck/rust-hir-dot-operator.cc +++ b/gcc/rust/typecheck/rust-hir-dot-operator.cc @@ -476,6 +476,11 @@ MethodResolver::select (TyTy::BaseType &receiver) receiver.debug_str ().c_str (), segment_name.to_string ().c_str ()); + // Predicate candidates have the highest priority. Try them before + // assembling impl candidates, which can trigger expensive trait resolution. + if (try_select_predicate_candidates (receiver)) + return true; + // Assemble candidates std::vector inherent_impl_fns; if (specified_trait == nullptr) @@ -498,19 +503,15 @@ MethodResolver::select (TyTy::BaseType &receiver) // Try selection in the priority order defined by Rust's method resolution: - // 1. Try predicate candidates first (highest priority) - if (try_select_predicate_candidates (receiver)) - return true; - - // 2. Try inherent impl functions (non-trait impl blocks) + // 1. Try inherent impl functions (non-trait impl blocks) if (try_select_inherent_impl_candidates (receiver, inherent_impl_fns, false)) return true; - // 3. Try inherent impl functions from trait impl blocks + // 2. Try inherent impl functions from trait impl blocks if (try_select_inherent_impl_candidates (receiver, inherent_impl_fns, true)) return true; - // 4. Try trait functions (lowest priority) + // 3. Try trait functions (lowest priority) return try_select_trait_impl_candidates (receiver, trait_fns); } From d005e9e6ec4eae673431b4346632dca77f439e86 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Thu, 3 Sep 2026 21:29:30 +0100 Subject: [PATCH 098/584] gccrs: Improve method resolution to use seperate indexes for impl's gcc/rust/ChangeLog: * typecheck/rust-hir-dot-operator.cc (MethodResolver::select): use sperate index * util/rust-hir-map.cc (Mappings::insert_hir_impl_block): new indexes * util/rust-hir-map.h: likewise Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-dot-operator.cc | 169 ++++++++++---------- gcc/rust/util/rust-hir-map.cc | 4 + gcc/rust/util/rust-hir-map.h | 18 +++ 3 files changed, 106 insertions(+), 85 deletions(-) diff --git a/gcc/rust/typecheck/rust-hir-dot-operator.cc b/gcc/rust/typecheck/rust-hir-dot-operator.cc index e42c4b90a2e6..a2ecb26498a1 100644 --- a/gcc/rust/typecheck/rust-hir-dot-operator.cc +++ b/gcc/rust/typecheck/rust-hir-dot-operator.cc @@ -123,87 +123,88 @@ MethodResolver::assemble_inherent_impl_candidates ( bool receiver_is_raw_ptr = raw->get_kind () == TyTy::TypeKind::POINTER; bool receiver_is_ref = raw->get_kind () == TyTy::TypeKind::REF; - // Assemble inherent impl items (non-trait impl blocks) - mappings.iterate_impl_items ([&] (HirId id, HIR::ImplItem *item, - HIR::ImplBlock *impl) mutable -> bool { - bool is_trait_impl = impl->has_trait_ref (); - if (is_trait_impl) - return true; + mappings.iterate_inherent_impl_blocks ( + [&] (HirId, HIR::ImplBlock *impl) mutable -> bool { + for (auto &impl_item : impl->get_impl_items ()) + { + HIR::ImplItem *item = impl_item.get (); + bool is_fn = item->get_impl_item_type () + == HIR::ImplItem::ImplItemType::FUNCTION; + if (!is_fn) + continue; - bool is_fn - = item->get_impl_item_type () == HIR::ImplItem::ImplItemType::FUNCTION; - if (!is_fn) - return true; + HIR::Function *func = static_cast (item); + if (!func->is_method ()) + continue; - HIR::Function *func = static_cast (item); - if (!func->is_method ()) - return true; + bool name_matches = func->get_function_name ().as_string ().compare ( + segment_name.to_string ()) + == 0; + if (!name_matches) + continue; - bool name_matches = func->get_function_name ().as_string ().compare ( - segment_name.to_string ()) - == 0; - if (!name_matches) - return true; + TyTy::BaseType *impl_self + = TypeCheckItem::ResolveImplBlockSelf (*impl); - TyTy::BaseType *impl_self = TypeCheckItem::ResolveImplBlockSelf (*impl); + if (impl_self == nullptr + || impl_self->get_kind () == TyTy::TypeKind::ERROR) + continue; - if (impl_self == nullptr || impl_self->get_kind () == TyTy::TypeKind::ERROR) - return true; + if (receiver.get_kind () == TyTy::TypeKind::ADT + && impl_self->get_kind () == TyTy::TypeKind::ADT) + { + const auto &receiver_adt + = static_cast (receiver); + const auto &impl_adt + = static_cast (*impl_self); + if (receiver_adt.get_id () != impl_adt.get_id ()) + continue; + } - if (receiver.get_kind () == TyTy::TypeKind::ADT - && impl_self->get_kind () == TyTy::TypeKind::ADT) - { - const auto &receiver_adt - = static_cast (receiver); - const auto &impl_adt = static_cast (*impl_self); - if (receiver_adt.get_id () != impl_adt.get_id ()) - return true; - } + // see: + // https://gcc-rust.zulipchat.com/#narrow/stream/266897-general/topic/Method.20Resolution/near/338646280 + // https://github.com/rust-lang/rust/blob/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/compiler/rustc_typeck/src/check/method/probe.rs#L650-L660 + bool impl_self_is_ptr + = impl_self->get_kind () == TyTy::TypeKind::POINTER; + bool impl_self_is_ref = impl_self->get_kind () == TyTy::TypeKind::REF; + if (receiver_is_raw_ptr && impl_self_is_ptr) + { + const TyTy::PointerType &sptr + = *static_cast (impl_self); + const TyTy::PointerType &ptr + = *static_cast (raw); + + // we could do this via lang-item assemblies if we refactor this + bool mut_match = sptr.mutability () == ptr.mutability (); + if (!mut_match) + continue; + } + else if (receiver_is_ref && impl_self_is_ref) + { + const TyTy::ReferenceType &sptr + = *static_cast (impl_self); + const TyTy::ReferenceType &ptr + = *static_cast (raw); + + // we could do this via lang-item assemblies if we refactor this + bool mut_match = sptr.mutability () == ptr.mutability (); + if (!mut_match) + continue; + } - // see: - // https://gcc-rust.zulipchat.com/#narrow/stream/266897-general/topic/Method.20Resolution/near/338646280 - // https://github.com/rust-lang/rust/blob/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/compiler/rustc_typeck/src/check/method/probe.rs#L650-L660 - bool impl_self_is_ptr = impl_self->get_kind () == TyTy::TypeKind::POINTER; - bool impl_self_is_ref = impl_self->get_kind () == TyTy::TypeKind::REF; - if (receiver_is_raw_ptr && impl_self_is_ptr) - { - const TyTy::PointerType &sptr - = *static_cast (impl_self); - const TyTy::PointerType &ptr - = *static_cast (raw); - - // we could do this via lang-item assemblies if we refactor this - bool mut_match = sptr.mutability () == ptr.mutability (); - if (!mut_match) - return true; - } - else if (receiver_is_ref && impl_self_is_ref) - { - const TyTy::ReferenceType &sptr - = *static_cast (impl_self); - const TyTy::ReferenceType &ptr - = *static_cast (raw); - - // we could do this via lang-item assemblies if we refactor this - bool mut_match = sptr.mutability () == ptr.mutability (); - if (!mut_match) - return true; - } + TyTy::BaseType *ty = nullptr; + if (!query_type (func->get_mappings ().get_hirid (), &ty)) + continue; + if (ty == nullptr || ty->get_kind () == TyTy::TypeKind::ERROR) + continue; + if (ty->get_kind () != TyTy::TypeKind::FNDEF) + continue; - TyTy::BaseType *ty = nullptr; - if (!query_type (func->get_mappings ().get_hirid (), &ty)) - return true; - if (ty == nullptr || ty->get_kind () == TyTy::TypeKind::ERROR) - return true; - if (ty->get_kind () != TyTy::TypeKind::FNDEF) + TyTy::FnType *fnty = static_cast (ty); + inherent_impl_fns.emplace_back (func, impl, fnty); + } return true; - - TyTy::FnType *fnty = static_cast (ty); - - inherent_impl_fns.emplace_back (func, impl, fnty); - - return true; - }); + }); return inherent_impl_fns; } @@ -332,7 +333,7 @@ MethodResolver::assemble_trait_impl_candidates ( }; if (specified_trait == nullptr) - mappings.iterate_impl_blocks (process_impl); + mappings.iterate_trait_impl_blocks (process_impl); else mappings.iterate_trait_impl_blocks ( specified_trait->get_mappings ().get_nodeid (), process_impl); @@ -484,15 +485,17 @@ MethodResolver::select (TyTy::BaseType &receiver) // Assemble candidates std::vector inherent_impl_fns; if (specified_trait == nullptr) - inherent_impl_fns = assemble_inherent_impl_candidates (receiver); + { + inherent_impl_fns = assemble_inherent_impl_candidates (receiver); + if (try_select_inherent_impl_candidates (receiver, inherent_impl_fns, + false)) + return true; + } + std::vector trait_impl_fns; std::vector trait_fns; assemble_trait_impl_candidates (receiver, trait_impl_fns, trait_fns); - // Combine inherent and trait impl functions - inherent_impl_fns.insert (inherent_impl_fns.end (), trait_impl_fns.begin (), - trait_impl_fns.end ()); - // https://github.com/rust-lang/rust/blob/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/compiler/rustc_typeck/src/check/method/probe.rs#L580-L694 rust_debug ("inherent_impl_fns found {%lu}, trait_fns found {%lu}, " @@ -503,15 +506,11 @@ MethodResolver::select (TyTy::BaseType &receiver) // Try selection in the priority order defined by Rust's method resolution: - // 1. Try inherent impl functions (non-trait impl blocks) - if (try_select_inherent_impl_candidates (receiver, inherent_impl_fns, false)) - return true; - - // 2. Try inherent impl functions from trait impl blocks - if (try_select_inherent_impl_candidates (receiver, inherent_impl_fns, true)) + // 1. Try inherent impl functions from trait impl blocks + if (try_select_inherent_impl_candidates (receiver, trait_impl_fns, true)) return true; - // 3. Try trait functions (lowest priority) + // 2. Try trait functions (lowest priority) return try_select_trait_impl_candidates (receiver, trait_fns); } diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index 3d8da522eb18..74496c00d144 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -472,6 +472,10 @@ Mappings::insert_hir_impl_block (HIR::ImplBlock *item) HirId impl_type_id = item->get_type ().get_mappings ().get_hirid (); hirImplBlockMappings[id] = item; + if (item->has_trait_ref ()) + hirTraitImplBlockMappings[id] = item; + else + hirInherentImplBlockMappings[id] = item; hirImplBlockTypeMappings[impl_type_id] = item; insert_node_to_hir (item->get_mappings ().get_nodeid (), id); } diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index 7595c49d6b09..b30c412fa681 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -224,6 +224,22 @@ class Mappings iterate_trait_impl_blocks (NodeId trait_node_id, std::function cb); + template void iterate_trait_impl_blocks (Callback &&cb) + { + for (auto it = hirTraitImplBlockMappings.begin (); + it != hirTraitImplBlockMappings.end (); ++it) + if (!cb (it->first, it->second)) + return; + } + + template void iterate_inherent_impl_blocks (Callback &&cb) + { + for (auto it = hirInherentImplBlockMappings.begin (); + it != hirInherentImplBlockMappings.end (); ++it) + if (!cb (it->first, it->second)) + return; + } + void iterate_impl_blocks (std::function cb); void iterate_trait_items ( @@ -411,6 +427,8 @@ class Mappings std::map hirSelfParamMappings; std::map hirImplItemsToImplMappings; std::map hirImplBlockMappings; + std::map hirInherentImplBlockMappings; + std::map hirTraitImplBlockMappings; std::map hirImplBlockTypeMappings; std::map> hirAdtImplMappings; std::set hirIndexedAdtImpls; From 4d678291347dfb6991973eabdcfc21b9716f2ed7 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 4 Sep 2026 21:26:03 +0100 Subject: [PATCH 099/584] gccrs: update type-bounds-probe to scan trait-impls only gcc/rust/ChangeLog: * typecheck/rust-tyty-bounds.cc (TypeBoundsProbe::scan): use trait index Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-tyty-bounds.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/rust/typecheck/rust-tyty-bounds.cc b/gcc/rust/typecheck/rust-tyty-bounds.cc index 5a1e02fe8944..ab5ce2a04cf3 100644 --- a/gcc/rust/typecheck/rust-tyty-bounds.cc +++ b/gcc/rust/typecheck/rust-tyty-bounds.cc @@ -103,7 +103,7 @@ TypeBoundsProbe::scan () }; if (specified_trait == nullptr) - mappings.iterate_impl_blocks (process_impl); + mappings.iterate_trait_impl_blocks (process_impl); else mappings.iterate_trait_impl_blocks ( specified_trait->get_mappings ().get_nodeid (), process_impl); From 9917d9e60cbe9346c4eba5e5dc653c57f79d9c7e Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 4 Sep 2026 21:33:43 +0100 Subject: [PATCH 100/584] gccrs: Add impl-item-name indexes for method resolution gcc/rust/ChangeLog: * typecheck/rust-hir-dot-operator.cc: use item name indexes * util/rust-hir-map.cc (Mappings::insert_hir_impl_block): new index (Mappings::insert_trait_item_mapping): likewise * util/rust-hir-map.h: likewise Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-dot-operator.cc | 135 +++++++++----------- gcc/rust/util/rust-hir-map.cc | 59 ++++++++- gcc/rust/util/rust-hir-map.h | 34 +++-- 3 files changed, 138 insertions(+), 90 deletions(-) diff --git a/gcc/rust/typecheck/rust-hir-dot-operator.cc b/gcc/rust/typecheck/rust-hir-dot-operator.cc index a2ecb26498a1..a680a4aaaf99 100644 --- a/gcc/rust/typecheck/rust-hir-dot-operator.cc +++ b/gcc/rust/typecheck/rust-hir-dot-operator.cc @@ -123,86 +123,70 @@ MethodResolver::assemble_inherent_impl_candidates ( bool receiver_is_raw_ptr = raw->get_kind () == TyTy::TypeKind::POINTER; bool receiver_is_ref = raw->get_kind () == TyTy::TypeKind::REF; - mappings.iterate_inherent_impl_blocks ( - [&] (HirId, HIR::ImplBlock *impl) mutable -> bool { - for (auto &impl_item : impl->get_impl_items ()) - { - HIR::ImplItem *item = impl_item.get (); - bool is_fn = item->get_impl_item_type () - == HIR::ImplItem::ImplItemType::FUNCTION; - if (!is_fn) - continue; + // Assemble inherent impl items (non-trait impl blocks). + mappings.iterate_inherent_impl_items ( + segment_name.to_string (), + [&] (HIR::ImplItem *item, HIR::ImplBlock *impl) mutable -> bool { + HIR::Function *func = static_cast (item); - HIR::Function *func = static_cast (item); - if (!func->is_method ()) - continue; + TyTy::BaseType *impl_self = TypeCheckItem::ResolveImplBlockSelf (*impl); - bool name_matches = func->get_function_name ().as_string ().compare ( - segment_name.to_string ()) - == 0; - if (!name_matches) - continue; - - TyTy::BaseType *impl_self - = TypeCheckItem::ResolveImplBlockSelf (*impl); - - if (impl_self == nullptr - || impl_self->get_kind () == TyTy::TypeKind::ERROR) - continue; + if (impl_self == nullptr + || impl_self->get_kind () == TyTy::TypeKind::ERROR) + return true; - if (receiver.get_kind () == TyTy::TypeKind::ADT - && impl_self->get_kind () == TyTy::TypeKind::ADT) - { - const auto &receiver_adt - = static_cast (receiver); - const auto &impl_adt - = static_cast (*impl_self); - if (receiver_adt.get_id () != impl_adt.get_id ()) - continue; - } + if (receiver.get_kind () == TyTy::TypeKind::ADT + && impl_self->get_kind () == TyTy::TypeKind::ADT) + { + const auto &receiver_adt + = static_cast (receiver); + const auto &impl_adt + = static_cast (*impl_self); + if (receiver_adt.get_id () != impl_adt.get_id ()) + return true; + } - // see: - // https://gcc-rust.zulipchat.com/#narrow/stream/266897-general/topic/Method.20Resolution/near/338646280 - // https://github.com/rust-lang/rust/blob/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/compiler/rustc_typeck/src/check/method/probe.rs#L650-L660 - bool impl_self_is_ptr - = impl_self->get_kind () == TyTy::TypeKind::POINTER; - bool impl_self_is_ref = impl_self->get_kind () == TyTy::TypeKind::REF; - if (receiver_is_raw_ptr && impl_self_is_ptr) - { - const TyTy::PointerType &sptr - = *static_cast (impl_self); - const TyTy::PointerType &ptr - = *static_cast (raw); - - // we could do this via lang-item assemblies if we refactor this - bool mut_match = sptr.mutability () == ptr.mutability (); - if (!mut_match) - continue; - } - else if (receiver_is_ref && impl_self_is_ref) - { - const TyTy::ReferenceType &sptr - = *static_cast (impl_self); - const TyTy::ReferenceType &ptr - = *static_cast (raw); - - // we could do this via lang-item assemblies if we refactor this - bool mut_match = sptr.mutability () == ptr.mutability (); - if (!mut_match) - continue; - } + // see: + // https://gcc-rust.zulipchat.com/#narrow/stream/266897-general/topic/Method.20Resolution/near/338646280 + // https://github.com/rust-lang/rust/blob/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/compiler/rustc_typeck/src/check/method/probe.rs#L650-L660 + bool impl_self_is_ptr + = impl_self->get_kind () == TyTy::TypeKind::POINTER; + bool impl_self_is_ref = impl_self->get_kind () == TyTy::TypeKind::REF; + if (receiver_is_raw_ptr && impl_self_is_ptr) + { + const TyTy::PointerType &sptr + = *static_cast (impl_self); + const TyTy::PointerType &ptr + = *static_cast (raw); + + // we could do this via lang-item assemblies if we refactor this + bool mut_match = sptr.mutability () == ptr.mutability (); + if (!mut_match) + return true; + } + else if (receiver_is_ref && impl_self_is_ref) + { + const TyTy::ReferenceType &sptr + = *static_cast (impl_self); + const TyTy::ReferenceType &ptr + = *static_cast (raw); + + // we could do this via lang-item assemblies if we refactor this + bool mut_match = sptr.mutability () == ptr.mutability (); + if (!mut_match) + return true; + } - TyTy::BaseType *ty = nullptr; - if (!query_type (func->get_mappings ().get_hirid (), &ty)) - continue; - if (ty == nullptr || ty->get_kind () == TyTy::TypeKind::ERROR) - continue; - if (ty->get_kind () != TyTy::TypeKind::FNDEF) - continue; + TyTy::BaseType *ty = nullptr; + if (!query_type (func->get_mappings ().get_hirid (), &ty)) + return true; + if (ty == nullptr || ty->get_kind () == TyTy::TypeKind::ERROR) + return true; + if (ty->get_kind () != TyTy::TypeKind::FNDEF) + return true; - TyTy::FnType *fnty = static_cast (ty); - inherent_impl_fns.emplace_back (func, impl, fnty); - } + TyTy::FnType *fnty = static_cast (ty); + inherent_impl_fns.emplace_back (func, impl, fnty); return true; }); @@ -333,7 +317,8 @@ MethodResolver::assemble_trait_impl_candidates ( }; if (specified_trait == nullptr) - mappings.iterate_trait_impl_blocks (process_impl); + mappings.iterate_trait_impl_blocks_for_item (segment_name.to_string (), + process_impl); else mappings.iterate_trait_impl_blocks ( specified_trait->get_mappings ().get_nodeid (), process_impl); diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index 74496c00d144..22cfba5eea3d 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -475,7 +475,21 @@ Mappings::insert_hir_impl_block (HIR::ImplBlock *item) if (item->has_trait_ref ()) hirTraitImplBlockMappings[id] = item; else - hirInherentImplBlockMappings[id] = item; + { + for (auto &impl_item : item->get_impl_items ()) + { + if (impl_item->get_impl_item_type () + != HIR::ImplItem::ImplItemType::FUNCTION) + continue; + + auto *function = static_cast (impl_item.get ()); + if (!function->is_method ()) + continue; + + auto name = function->get_function_name ().as_string (); + hirInherentImplItemMappings[name].emplace_back (impl_item.get (), item); + } + } hirImplBlockTypeMappings[impl_type_id] = item; insert_node_to_hir (item->get_mappings ().get_nodeid (), id); } @@ -877,6 +891,49 @@ Mappings::insert_trait_impl_mapping (NodeId trait_node_id, HIR::ImplBlock *impl) hirTraitImplMappings[trait_node_id].push_back (impl); } +void +Mappings::iterate_trait_impl_blocks_for_item ( + const std::string &name, + std::function cb) +{ + auto traits = hirTraitItemNameMappings.find (name); + if (traits == hirTraitItemNameMappings.end ()) + return; + + for (auto trait_node_id : traits->second) + { + auto impls = hirTraitImplMappings.find (trait_node_id); + if (impls == hirTraitImplMappings.end ()) + continue; + + for (auto *impl : impls->second) + if (!cb (impl->get_mappings ().get_hirid (), impl)) + return; + } +} + +void +Mappings::insert_trait_item_mapping (HirId trait_item_id, HIR::Trait *trait) +{ + rust_assert (hirTraitItemsToTraitMappings.find (trait_item_id) + == hirTraitItemsToTraitMappings.end ()); + hirTraitItemsToTraitMappings[trait_item_id] = trait; + + auto item = lookup_hir_trait_item (trait_item_id); + rust_assert (item.has_value ()); + if (item.value ()->get_item_kind () + != HIR::TraitItem::TraitItemKind::FUNC) + return; + + auto *function = static_cast (item.value ()); + if (!function->get_decl ().is_method ()) + return; + + auto name = function->get_decl ().get_function_name ().as_string (); + hirTraitItemNameMappings[name].push_back ( + trait->get_mappings ().get_nodeid ()); +} + void Mappings::iterate_trait_impl_items ( NodeId trait_node_id, diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index b30c412fa681..4a2a1a8fbad4 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -208,6 +208,18 @@ class Mappings void iterate_impl_items ( std::function cb); + template + void iterate_inherent_impl_items (const std::string &name, Callback &&cb) + { + auto items = hirInherentImplItemMappings.find (name); + if (items == hirInherentImplItemMappings.end ()) + return; + + for (auto &item : items->second) + if (!cb (item.first, item.second)) + return; + } + void insert_adt_impl_mapping (NodeId adt_node_id, HIR::ImplBlock *impl); void iterate_adt_impl_items ( @@ -232,13 +244,9 @@ class Mappings return; } - template void iterate_inherent_impl_blocks (Callback &&cb) - { - for (auto it = hirInherentImplBlockMappings.begin (); - it != hirInherentImplBlockMappings.end (); ++it) - if (!cb (it->first, it->second)) - return; - } + void iterate_trait_impl_blocks_for_item (const std::string &name, + std::function cb); void iterate_impl_blocks (std::function cb); @@ -247,12 +255,7 @@ class Mappings bool is_impl_item (HirId id) { return lookup_hir_implitem (id).has_value (); } - void insert_trait_item_mapping (HirId trait_item_id, HIR::Trait *trait) - { - rust_assert (hirTraitItemsToTraitMappings.find (trait_item_id) - == hirTraitItemsToTraitMappings.end ()); - hirTraitItemsToTraitMappings[trait_item_id] = trait; - } + void insert_trait_item_mapping (HirId trait_item_id, HIR::Trait *trait); HIR::Trait *lookup_trait_item_mapping (HirId trait_item_id) { @@ -427,12 +430,15 @@ class Mappings std::map hirSelfParamMappings; std::map hirImplItemsToImplMappings; std::map hirImplBlockMappings; - std::map hirInherentImplBlockMappings; std::map hirTraitImplBlockMappings; + std::map>> + hirInherentImplItemMappings; std::map hirImplBlockTypeMappings; std::map> hirAdtImplMappings; std::set hirIndexedAdtImpls; std::map> hirTraitImplMappings; + std::map> hirTraitItemNameMappings; std::map hirTraitItemMappings; std::map hirExternBlockMappings; std::map> hirExternItemMappings; From 7702d38b476a21c3f5603a48334bacb65e30db3f Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 4 Sep 2026 22:46:02 +0100 Subject: [PATCH 101/584] gccrs: Cleanup bad usage of using ast node-ids instead of DefId for indexes I used a node-id mapping just out of handyness because the trait-impls or impls to defid's uses the name resolver to NodeIds but to use DefId we need to do an indexing pass at the end of hir lowering then to get the DefId mappings. gcc/rust/ChangeLog: * hir/rust-ast-lower-item.cc (register_adt_impl): remove (ASTLoweringItem::visit): likewise * rust-session-manager.cc (Session::compile_crate): call new indexer * typecheck/rust-hir-dot-operator.cc (MethodResolver::try_select_predicate_candidates): use indexes * typecheck/rust-hir-path-probe-expr.cc (PathProbeExpr::probe_adt_impls): likewise * typecheck/rust-hir-path-probe-impl-trait.cc (PathProbeImplTrait::process_trait_impl_items_for_candidates): likewise * typecheck/rust-hir-path-probe-type.cc (TypePathProbe::probe_adt): likewise * typecheck/rust-tyty-bounds.cc (TypeBoundsProbe::scan): likewise * util/rust-hir-map.cc (Mappings::Mappings): new indexer (Mappings::insert_hir_impl_block): likewise (Mappings::insert_adt_impl_mapping): likewise (Mappings::build_impl_indexes): likewise (Mappings::insert_trait_impl_mapping): likewise (Mappings::insert_trait_item_mapping): likewise * util/rust-hir-map.h: likewise Signed-off-by: Philip Herron --- gcc/rust/hir/rust-ast-lower-item.cc | 30 ------- gcc/rust/rust-session-manager.cc | 1 + gcc/rust/typecheck/rust-hir-dot-operator.cc | 9 +- .../typecheck/rust-hir-path-probe-expr.cc | 6 +- .../rust-hir-path-probe-impl-trait.cc | 4 +- .../typecheck/rust-hir-path-probe-type.cc | 4 +- gcc/rust/typecheck/rust-tyty-bounds.cc | 2 +- gcc/rust/util/rust-hir-map.cc | 87 +++++++++++++++---- gcc/rust/util/rust-hir-map.h | 24 ++--- 9 files changed, 94 insertions(+), 73 deletions(-) diff --git a/gcc/rust/hir/rust-ast-lower-item.cc b/gcc/rust/hir/rust-ast-lower-item.cc index f7cbcf1ac285..2ae5242357f2 100644 --- a/gcc/rust/hir/rust-ast-lower-item.cc +++ b/gcc/rust/hir/rust-ast-lower-item.cc @@ -27,31 +27,10 @@ #include "rust-ast-lower-pattern.h" #include "rust-ast-lower-block.h" #include "rust-item.h" -#include "rust-finalized-name-resolution-context.h" namespace Rust { namespace HIR { -static void -register_adt_impl (Analysis::Mappings &mappings, HIR::Type *impl_type, - HIR::ImplBlock *impl) -{ - auto &nr_ctx = Resolver2_0::FinalizedNameResolutionContext::get (); - auto resolved = nr_ctx.lookup (impl_type->get_mappings ().get_nodeid (), - Resolver2_0::Namespace::Types); - if (!resolved.has_value ()) - return; - - auto ast_item = mappings.lookup_ast_item (resolved.value ()); - if (!ast_item.has_value ()) - return; - - auto kind = ast_item.value ()->get_item_kind (); - if (kind == AST::Item::Kind::Struct || kind == AST::Item::Kind::Enum - || kind == AST::Item::Kind::Union) - mappings.insert_adt_impl_mapping (resolved.value (), impl); -} - HIR::Item * ASTLoweringItem::translate (AST::Item &item) { @@ -614,7 +593,6 @@ ASTLoweringItem::visit (AST::InherentImpl &impl_block) translated = hir_impl_block; mappings.insert_hir_impl_block (hir_impl_block); - register_adt_impl (mappings, impl_type, hir_impl_block); for (auto &impl_item_id : impl_item_ids) { mappings.insert_impl_item_mapping (impl_item_id, hir_impl_block); @@ -788,14 +766,6 @@ ASTLoweringItem::visit (AST::TraitImpl &impl_block) mappings.insert_hir_impl_block (hir_impl_block); - register_adt_impl (mappings, impl_type, hir_impl_block); - - auto &nr_ctx = Resolver2_0::FinalizedNameResolutionContext::get (); - auto trait_node_id = nr_ctx.lookup (trait_ref->get_mappings ().get_nodeid (), - Resolver2_0::Namespace::Types); - rust_assert (trait_node_id.has_value ()); - mappings.insert_trait_impl_mapping (trait_node_id.value (), hir_impl_block); - for (auto &impl_item_id : impl_item_ids) { mappings.insert_impl_item_mapping (impl_item_id, hir_impl_block); diff --git a/gcc/rust/rust-session-manager.cc b/gcc/rust/rust-session-manager.cc index 29b12bb13b84..45fe3ede70cc 100644 --- a/gcc/rust/rust-session-manager.cc +++ b/gcc/rust/rust-session-manager.cc @@ -792,6 +792,7 @@ Session::compile_crate (const char *filename) // add the mappings to it HIR::Crate &hir = mappings.insert_hir_crate (std::move (lowered)); + mappings.build_impl_indexes (); if (options.dump_option_enabled (CompileOptions::HIR_DUMP)) { dump_hir (hir); diff --git a/gcc/rust/typecheck/rust-hir-dot-operator.cc b/gcc/rust/typecheck/rust-hir-dot-operator.cc index a680a4aaaf99..89a596a28274 100644 --- a/gcc/rust/typecheck/rust-hir-dot-operator.cc +++ b/gcc/rust/typecheck/rust-hir-dot-operator.cc @@ -149,8 +149,7 @@ MethodResolver::assemble_inherent_impl_candidates ( // see: // https://gcc-rust.zulipchat.com/#narrow/stream/266897-general/topic/Method.20Resolution/near/338646280 // https://github.com/rust-lang/rust/blob/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/compiler/rustc_typeck/src/check/method/probe.rs#L650-L660 - bool impl_self_is_ptr - = impl_self->get_kind () == TyTy::TypeKind::POINTER; + bool impl_self_is_ptr = impl_self->get_kind () == TyTy::TypeKind::POINTER; bool impl_self_is_ref = impl_self->get_kind () == TyTy::TypeKind::REF; if (receiver_is_raw_ptr && impl_self_is_ptr) { @@ -321,7 +320,7 @@ MethodResolver::assemble_trait_impl_candidates ( process_impl); else mappings.iterate_trait_impl_blocks ( - specified_trait->get_mappings ().get_nodeid (), process_impl); + specified_trait->get_mappings ().get_defid (), process_impl); } bool @@ -333,8 +332,8 @@ MethodResolver::try_select_predicate_candidates (TyTy::BaseType &receiver) if (specified_trait != nullptr) { const TraitReference *parent = predicate.lookup.get_parent ()->get (); - if (parent->get_mappings ().get_nodeid () - != specified_trait->get_mappings ().get_nodeid ()) + if (parent->get_mappings ().get_defid () + != specified_trait->get_mappings ().get_defid ()) continue; } diff --git a/gcc/rust/typecheck/rust-hir-path-probe-expr.cc b/gcc/rust/typecheck/rust-hir-path-probe-expr.cc index 8307082af973..d95c931b1aa8 100644 --- a/gcc/rust/typecheck/rust-hir-path-probe-expr.cc +++ b/gcc/rust/typecheck/rust-hir-path-probe-expr.cc @@ -76,9 +76,9 @@ PathProbeExpr::probe_adt_impls (TyTy::ADTType *adt) return; } - NodeId adt_node_id = adt_item.value ()->get_mappings ().get_nodeid (); + DefId adt_id = adt_item.value ()->get_mappings ().get_defid (); mappings.iterate_adt_impl_items ( - adt_node_id, + adt_id, [this] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) -> bool { if (impl->has_trait_ref ()) return true; @@ -90,7 +90,7 @@ PathProbeExpr::probe_adt_impls (TyTy::ADTType *adt) return; mappings.iterate_adt_impl_items ( - adt_node_id, + adt_id, [this] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) -> bool { if (!impl->has_trait_ref ()) return true; diff --git a/gcc/rust/typecheck/rust-hir-path-probe-impl-trait.cc b/gcc/rust/typecheck/rust-hir-path-probe-impl-trait.cc index 7b6871fb69d2..bd1edba2f046 100644 --- a/gcc/rust/typecheck/rust-hir-path-probe-impl-trait.cc +++ b/gcc/rust/typecheck/rust-hir-path-probe-impl-trait.cc @@ -44,8 +44,8 @@ PathProbeImplTrait::Probe (TyTy::BaseType *receiver, void PathProbeImplTrait::process_trait_impl_items_for_candidates () { - NodeId trait_node_id = trait_reference->get_mappings ().get_nodeid (); - mappings.iterate_trait_impl_items (trait_node_id, + DefId trait_id = trait_reference->get_mappings ().get_defid (); + mappings.iterate_trait_impl_items (trait_id, [this] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) -> bool { process_impl_item_candidate (id, item, diff --git a/gcc/rust/typecheck/rust-hir-path-probe-type.cc b/gcc/rust/typecheck/rust-hir-path-probe-type.cc index 98cd7adc431c..79179627daed 100644 --- a/gcc/rust/typecheck/rust-hir-path-probe-type.cc +++ b/gcc/rust/typecheck/rust-hir-path-probe-type.cc @@ -77,8 +77,8 @@ TypePathProbe::probe_adt (TyTy::ADTType *adt) return; } - NodeId adt_node_id = adt_item.value ()->get_mappings ().get_nodeid (); - mappings.iterate_adt_impl_items (adt_node_id, + DefId adt_id = adt_item.value ()->get_mappings ().get_defid (); + mappings.iterate_adt_impl_items (adt_id, [this] (HirId id, HIR::ImplItem *item, HIR::ImplBlock *impl) -> bool { return process_impl_item (id, item, impl); diff --git a/gcc/rust/typecheck/rust-tyty-bounds.cc b/gcc/rust/typecheck/rust-tyty-bounds.cc index ab5ce2a04cf3..b4e30f162656 100644 --- a/gcc/rust/typecheck/rust-tyty-bounds.cc +++ b/gcc/rust/typecheck/rust-tyty-bounds.cc @@ -106,7 +106,7 @@ TypeBoundsProbe::scan () mappings.iterate_trait_impl_blocks (process_impl); else mappings.iterate_trait_impl_blocks ( - specified_trait->get_mappings ().get_nodeid (), process_impl); + specified_trait->get_mappings ().get_defid (), process_impl); for (auto &path : possible_trait_paths) { diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index 22cfba5eea3d..1151c5cae19c 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -26,6 +26,7 @@ #include "rust-macro-builtins.h" #include "rust-mapping-common.h" #include "rust-attribute-values.h" +#include "rust-finalized-name-resolution-context.h" namespace Rust { namespace Analysis { @@ -99,7 +100,8 @@ static const HirId kDefaultCrateNumBegin = 0; Mappings::Mappings () : crateNumItr (kDefaultCrateNumBegin), currentCrateNum (UNKNOWN_CRATENUM), - hirIdIter (kDefaultHirIdBegin), nodeIdIter (kDefaultNodeIdBegin) + hirIdIter (kDefaultHirIdBegin), nodeIdIter (kDefaultNodeIdBegin), + hirImplIndexesBuilt (false) { Analysis::NodeMapping node (0, 0, 0, 0); builtinMarker @@ -487,7 +489,8 @@ Mappings::insert_hir_impl_block (HIR::ImplBlock *item) continue; auto name = function->get_function_name ().as_string (); - hirInherentImplItemMappings[name].emplace_back (impl_item.get (), item); + hirInherentImplItemMappings[name].emplace_back (impl_item.get (), + item); } } hirImplBlockTypeMappings[impl_type_id] = item; @@ -845,15 +848,63 @@ Mappings::iterate_impl_items ( } void -Mappings::insert_adt_impl_mapping (NodeId adt_node_id, HIR::ImplBlock *impl) +Mappings::insert_adt_impl_mapping (DefId adt_id, HIR::ImplBlock *impl) { - hirAdtImplMappings[adt_node_id].push_back (impl); + hirAdtImplMappings[adt_id].push_back (impl); hirIndexedAdtImpls.insert (impl); } +void +Mappings::build_impl_indexes () +{ + gcc_checking_assert (!hirImplIndexesBuilt); + if (hirImplIndexesBuilt) + return; + hirImplIndexesBuilt = true; + + auto &nr_ctx = Resolver2_0::FinalizedNameResolutionContext::get (); + auto resolve_item = [&] (const HIR::Type &type) -> HIR::Item * { + auto node_id = nr_ctx.lookup (type.get_mappings ().get_nodeid (), + Resolver2_0::Namespace::Types); + if (!node_id.has_value ()) + return nullptr; + + auto hir_id = lookup_node_to_hir (node_id.value ()); + gcc_checking_assert (hir_id.has_value ()); + if (!hir_id.has_value ()) + return nullptr; + + auto item = lookup_hir_item (hir_id.value ()); + return item.has_value () ? item.value () : nullptr; + }; + + iterate_impl_blocks ([&] (HirId, HIR::ImplBlock *impl) -> bool { + HIR::Item *self_item = resolve_item (impl->get_type ()); + if (self_item != nullptr) + { + auto kind = self_item->get_item_kind (); + if (kind == HIR::Item::ItemKind::Struct + || kind == HIR::Item::ItemKind::Enum + || kind == HIR::Item::ItemKind::Union) + insert_adt_impl_mapping (self_item->get_mappings ().get_defid (), + impl); + } + + if (impl->has_trait_ref ()) + { + HIR::Item *trait_item = resolve_item (impl->get_trait_ref ()); + if (trait_item != nullptr + && trait_item->get_item_kind () == HIR::Item::ItemKind::Trait) + insert_trait_impl_mapping (trait_item->get_mappings ().get_defid (), + impl); + } + return true; + }); +} + void Mappings::iterate_adt_impl_items ( - NodeId adt_node_id, + DefId adt_id, std::function cb) { auto iterate_impl = [&] (HIR::ImplBlock *impl) { @@ -867,7 +918,7 @@ Mappings::iterate_adt_impl_items ( return true; }; - auto adt_impls = hirAdtImplMappings.find (adt_node_id); + auto adt_impls = hirAdtImplMappings.find (adt_id); if (adt_impls != hirAdtImplMappings.end ()) for (auto *impl : adt_impls->second) if (!iterate_impl (impl)) @@ -886,23 +937,22 @@ Mappings::iterate_adt_impl_items ( } void -Mappings::insert_trait_impl_mapping (NodeId trait_node_id, HIR::ImplBlock *impl) +Mappings::insert_trait_impl_mapping (DefId trait_id, HIR::ImplBlock *impl) { - hirTraitImplMappings[trait_node_id].push_back (impl); + hirTraitImplMappings[trait_id].push_back (impl); } void Mappings::iterate_trait_impl_blocks_for_item ( - const std::string &name, - std::function cb) + const std::string &name, std::function cb) { auto traits = hirTraitItemNameMappings.find (name); if (traits == hirTraitItemNameMappings.end ()) return; - for (auto trait_node_id : traits->second) + for (auto trait_id : traits->second) { - auto impls = hirTraitImplMappings.find (trait_node_id); + auto impls = hirTraitImplMappings.find (trait_id); if (impls == hirTraitImplMappings.end ()) continue; @@ -921,8 +971,7 @@ Mappings::insert_trait_item_mapping (HirId trait_item_id, HIR::Trait *trait) auto item = lookup_hir_trait_item (trait_item_id); rust_assert (item.has_value ()); - if (item.value ()->get_item_kind () - != HIR::TraitItem::TraitItemKind::FUNC) + if (item.value ()->get_item_kind () != HIR::TraitItem::TraitItemKind::FUNC) return; auto *function = static_cast (item.value ()); @@ -931,15 +980,15 @@ Mappings::insert_trait_item_mapping (HirId trait_item_id, HIR::Trait *trait) auto name = function->get_decl ().get_function_name ().as_string (); hirTraitItemNameMappings[name].push_back ( - trait->get_mappings ().get_nodeid ()); + trait->get_mappings ().get_defid ()); } void Mappings::iterate_trait_impl_items ( - NodeId trait_node_id, + DefId trait_id, std::function cb) { - auto trait_impls = hirTraitImplMappings.find (trait_node_id); + auto trait_impls = hirTraitImplMappings.find (trait_id); if (trait_impls == hirTraitImplMappings.end ()) return; @@ -955,9 +1004,9 @@ Mappings::iterate_trait_impl_items ( void Mappings::iterate_trait_impl_blocks ( - NodeId trait_node_id, std::function cb) + DefId trait_id, std::function cb) { - auto trait_impls = hirTraitImplMappings.find (trait_node_id); + auto trait_impls = hirTraitImplMappings.find (trait_id); if (trait_impls == hirTraitImplMappings.end ()) return; diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index 4a2a1a8fbad4..344e13414fef 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -220,20 +220,22 @@ class Mappings return; } - void insert_adt_impl_mapping (NodeId adt_node_id, HIR::ImplBlock *impl); + void insert_adt_impl_mapping (DefId adt_id, HIR::ImplBlock *impl); + + void build_impl_indexes (); void iterate_adt_impl_items ( - NodeId adt_node_id, + DefId adt_id, std::function cb); - void insert_trait_impl_mapping (NodeId trait_node_id, HIR::ImplBlock *impl); + void insert_trait_impl_mapping (DefId trait_id, HIR::ImplBlock *impl); void iterate_trait_impl_items ( - NodeId trait_node_id, + DefId trait_id, std::function cb); void - iterate_trait_impl_blocks (NodeId trait_node_id, + iterate_trait_impl_blocks (DefId trait_id, std::function cb); template void iterate_trait_impl_blocks (Callback &&cb) @@ -244,9 +246,8 @@ class Mappings return; } - void iterate_trait_impl_blocks_for_item (const std::string &name, - std::function cb); + void iterate_trait_impl_blocks_for_item ( + const std::string &name, std::function cb); void iterate_impl_blocks (std::function cb); @@ -435,10 +436,11 @@ class Mappings std::vector>> hirInherentImplItemMappings; std::map hirImplBlockTypeMappings; - std::map> hirAdtImplMappings; + std::map> hirAdtImplMappings; std::set hirIndexedAdtImpls; - std::map> hirTraitImplMappings; - std::map> hirTraitItemNameMappings; + std::map> hirTraitImplMappings; + std::map> hirTraitItemNameMappings; + bool hirImplIndexesBuilt; std::map hirTraitItemMappings; std::map hirExternBlockMappings; std::map> hirExternItemMappings; From 20347e8075b1341bff8e8da2e56103339db48d02 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 4 Sep 2026 20:09:59 +0100 Subject: [PATCH 102/584] gccrs: improve handling of defered operator overload handling When we are compiling libcore each operation +-/* etc all resolve to libcore implementations of these that define the semantics but what can happen is because of infer vars its ambigious what implementation this should specialize to untill more type hints are applied so we return an infer variable result so type checking can continue and we try to resolve at the end. gcc/rust/ChangeLog: * typecheck/rust-hir-dot-operator.cc (MethodResolver::Select): optional result type * typecheck/rust-hir-dot-operator.h: likewise * typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::ResolveOpOverload): defer flag (TypeCheckExpr::visit): pass throw the borrow * typecheck/rust-hir-type-check-expr.h: likewise * typecheck/rust-hir-type-check.h (struct DeferredOpOverload): new * typecheck/rust-type-util.cc (unify_site): like parameter ordering (unify_site_and): likewise * typecheck/rust-typecheck-context.cc (TypeCheckContext::compute_ambigious_op_overload): new (TypeCheckContext::compute_inference_variables): likewise (TypeCheckContext::compute_infer_var): likewise * typecheck/rust-unify.cc (UnifyRules::Resolve): fix arguments (UnifyRules::resolve_subtype):likewise * typecheck/rust-unify.h: likewise gcc/testsuite/ChangeLog: * rust/execute/torture/deferred-add-partial-ord.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-dot-operator.cc | 18 ++++- gcc/rust/typecheck/rust-hir-dot-operator.h | 3 +- .../typecheck/rust-hir-type-check-expr.cc | 77 +++++++++---------- gcc/rust/typecheck/rust-hir-type-check-expr.h | 8 +- gcc/rust/typecheck/rust-hir-type-check.h | 12 +-- gcc/rust/typecheck/rust-type-util.cc | 6 +- gcc/rust/typecheck/rust-typecheck-context.cc | 67 +++++++++++++--- gcc/rust/typecheck/rust-unify.cc | 7 +- gcc/rust/typecheck/rust-unify.h | 4 +- .../torture/deferred-add-partial-ord.rs | 58 ++++++++++++++ 10 files changed, 189 insertions(+), 71 deletions(-) create mode 100644 gcc/testsuite/rust/execute/torture/deferred-add-partial-ord.rs diff --git a/gcc/rust/typecheck/rust-hir-dot-operator.cc b/gcc/rust/typecheck/rust-hir-dot-operator.cc index 89a596a28274..8fd7f1d0093d 100644 --- a/gcc/rust/typecheck/rust-hir-dot-operator.cc +++ b/gcc/rust/typecheck/rust-hir-dot-operator.cc @@ -46,7 +46,8 @@ MethodResolver::Probe (TyTy::BaseType *receiver, std::set MethodResolver::Select (std::set &candidates, TyTy::BaseType *receiver, - std::vector arguments) + std::vector arguments, + TyTy::BaseType *result_type) { std::set selected; for (auto &candidate : candidates) @@ -78,6 +79,21 @@ MethodResolver::Select (std::set &candidates, } } + if (!failed && result_type != nullptr) + { + TyTy::BaseType *return_type = fn.get_return_type (); + rust_debug ("method candidate output check fn=%s expected=%s " + "return=%s", + fn.debug_str ().c_str (), + result_type->debug_str ().c_str (), + return_type->debug_str ().c_str ()); + failed = !types_compatable (TyTy::TyWithLocation (result_type), + TyTy::TyWithLocation (return_type), + UNDEF_LOCATION, false /* emit_errors */); + rust_debug ("method candidate output check result=%s", + failed ? "rejected" : "accepted"); + } + if (!failed) selected.insert (candidate); } diff --git a/gcc/rust/typecheck/rust-hir-dot-operator.h b/gcc/rust/typecheck/rust-hir-dot-operator.h index 79c5db1c079f..78c33217bc41 100644 --- a/gcc/rust/typecheck/rust-hir-dot-operator.h +++ b/gcc/rust/typecheck/rust-hir-dot-operator.h @@ -64,7 +64,8 @@ class MethodResolver : private TypeCheckBase, protected AutoderefCycle static std::set Select (std::set &candidates, TyTy::BaseType *receiver, - std::vector arguments); + std::vector arguments, + TyTy::BaseType *result_type = nullptr); static std::vector get_predicate_items ( const HIR::PathIdentSegment &segment_name, const TyTy::BaseType &receiver, diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc index 4824209aecbb..cc967d4b301a 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc @@ -73,12 +73,13 @@ TyTy::BaseType * TypeCheckExpr::ResolveOpOverload (LangItem::Kind lang_item_type, HIR::OperatorExprMeta expr, TyTy::BaseType *lhs, TyTy::BaseType *rhs, - HIR::PathIdentSegment specified_segment) + HIR::PathIdentSegment specified_segment, + TyTy::BaseType *result_type) { TypeCheckExpr resolver; resolver.resolve_operator_overload (lang_item_type, expr, lhs, rhs, - specified_segment); + specified_segment, false, result_type); return resolver.infered; } @@ -505,6 +506,11 @@ TypeCheckExpr::visit (HIR::ComparisonExpr &expr) auto lhs = TypeCheckExpr::Resolve (expr.get_lhs ()); auto rhs = TypeCheckExpr::Resolve (expr.get_rhs ()); + auto borrowed_lhs + = new TyTy::ReferenceType (mappings.get_next_hir_id (), + TyTy::TyVar (lhs->get_ref ()), Mutability::Imm); + context->insert_implicit_type (borrowed_lhs->get_ref (), borrowed_lhs); + auto borrowed_rhs = new TyTy::ReferenceType (mappings.get_next_hir_id (), TyTy::TyVar (rhs->get_ref ()), Mutability::Imm); @@ -516,7 +522,7 @@ TypeCheckExpr::visit (HIR::ComparisonExpr &expr) bool operator_overloaded = resolve_operator_overload (lang_item_type, expr, lhs, borrowed_rhs, - segment); + segment, true, nullptr, borrowed_lhs); if (operator_overloaded) return; @@ -2014,7 +2020,8 @@ bool TypeCheckExpr::resolve_operator_overload ( LangItem::Kind lang_item_type, HIR::OperatorExprMeta expr, TyTy::BaseType *lhs, TyTy::BaseType *rhs, - HIR::PathIdentSegment specified_segment) + HIR::PathIdentSegment specified_segment, bool allow_defer, + TyTy::BaseType *result_type, TyTy::BaseType *probe_lhs) { // look up lang item for arithmetic type std::string associated_item_name = LangItem::ToString (lang_item_type); @@ -2031,8 +2038,6 @@ TypeCheckExpr::resolve_operator_overload ( HIR::Item *def_item = def_lookup.value (); rust_assert (def_item->get_item_kind () == HIR::Item::ItemKind::Trait); HIR::Trait &trait = *static_cast (def_item); - TraitReference *defid_trait_reference = TraitResolver::Resolve (trait); - rust_assert (!defid_trait_reference->is_error ()); // we might be in a static or const context and unknown is fine TypeCheckContextItem current_context = TypeCheckContextItem::get_error (); @@ -2044,7 +2049,9 @@ TypeCheckExpr::resolve_operator_overload ( auto segment = specified_segment.is_error () ? HIR::PathIdentSegment (associated_item_name) : specified_segment; - auto candidates = MethodResolver::Probe (lhs, segment, false, &trait); + TyTy::BaseType *method_receiver = probe_lhs == nullptr ? lhs : probe_lhs; + auto candidates + = MethodResolver::Probe (method_receiver, segment, false, &trait); // remove any recursive candidates std::set resolved_candidates; @@ -2068,7 +2075,8 @@ TypeCheckExpr::resolve_operator_overload ( if (rhs != nullptr) select_args = {rhs}; auto selected_candidates - = MethodResolver::Select (resolved_candidates, lhs, select_args); + = MethodResolver::Select (resolved_candidates, method_receiver, select_args, + result_type); bool have_implementation_for_lang_item = selected_candidates.size () > 0; if (!have_implementation_for_lang_item) @@ -2076,48 +2084,33 @@ TypeCheckExpr::resolve_operator_overload ( if (selected_candidates.size () > 1) { - auto infer - = TyTy::TyVar::get_implicit_infer_var (expr.get_locus ()).get_tyty (); - auto trait_subst = defid_trait_reference->get_trait_substs (); - rust_assert (trait_subst.size () > 0); - - TyTy::TypeBoundPredicate pred (respective_lang_item_id, trait_subst, - BoundPolarity::RegularBound, - expr.get_locus ()); - - std::vector mappings; - auto &self_param_mapping = trait_subst[0]; - mappings.emplace_back (&self_param_mapping, lhs); - - if (rhs != nullptr) - { - rust_assert (trait_subst.size () == 2); - auto &rhs_param_mapping = trait_subst[1]; - mappings.emplace_back (&rhs_param_mapping, lhs); - } - - std::map binding_args; - binding_args["Output"] = infer; - - TyTy::SubstitutionArgumentMappings arg_mappings (mappings, binding_args, - TyTy::RegionParamList ( - trait_subst.size ()), - expr.get_locus ()); - pred.apply_argument_mappings (arg_mappings, false); - - infer->inherit_bounds ({pred}); + if (!allow_defer) + return false; + + TyTy::TyVar result_type + = TyTy::TyVar::get_implicit_infer_var (expr.get_locus ()); + TyTy::BaseType *result_tyty = result_type.get_tyty (); + rust_assert (result_tyty != nullptr); + rust_debug ("deferring operator expr=%u result-ref=%u result-ty-ref=%u " + "lhs-ref=%u rhs-ref=%u", + expr.get_mappings ().get_hirid (), result_type.get_ref (), + result_tyty->get_ty_ref (), lhs->get_ref (), + rhs == nullptr ? UNKNOWN_HIRID : rhs->get_ref ()); DeferredOpOverload defer (expr.get_mappings ().get_hirid (), - lang_item_type, specified_segment, pred, expr); + lang_item_type, specified_segment, expr, + result_type); context->insert_deferred_operator_overload (std::move (defer)); - infered = unify_site (expr.get_mappings ().get_hirid (), - TyTy::TyWithLocation (lhs), - TyTy::TyWithLocation (infer), expr.get_locus ()); + infered = result_tyty; return true; } // Get the adjusted self MethodCandidate candidate = *selected_candidates.begin (); + if (probe_lhs != nullptr) + candidate.adjustments.insert ( + candidate.adjustments.begin (), + Adjustment (Adjustment::AdjustmentType::IMM_REF, lhs, probe_lhs)); Adjuster adj (lhs); TyTy::BaseType *adjusted_self = adj.adjust_type (candidate.adjustments); diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.h b/gcc/rust/typecheck/rust-hir-type-check-expr.h index 100dc0ccf35f..f7a97086c68d 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.h +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.h @@ -35,7 +35,8 @@ class TypeCheckExpr : private TypeCheckBase, private HIR::HIRExpressionVisitor static TyTy::BaseType * ResolveOpOverload (LangItem::Kind lang_item_type, HIR::OperatorExprMeta expr, TyTy::BaseType *lhs, TyTy::BaseType *rhs, - HIR::PathIdentSegment specified_segment); + HIR::PathIdentSegment specified_segment, + TyTy::BaseType *result_type); void visit (HIR::TupleIndexExpr &expr) override; void visit (HIR::TupleExpr &expr) override; @@ -109,7 +110,10 @@ class TypeCheckExpr : private TypeCheckBase, private HIR::HIRExpressionVisitor HIR::OperatorExprMeta expr, TyTy::BaseType *lhs, TyTy::BaseType *rhs, HIR::PathIdentSegment specified_segment - = HIR::PathIdentSegment::create_error ()); + = HIR::PathIdentSegment::create_error (), + bool allow_defer = true, + TyTy::BaseType *result_type = nullptr, + TyTy::BaseType *probe_lhs = nullptr); bool resolve_fn_trait_call (HIR::CallExpr &expr, TyTy::BaseType *function_tyty, diff --git a/gcc/rust/typecheck/rust-hir-type-check.h b/gcc/rust/typecheck/rust-hir-type-check.h index 1e830713ee84..f1db16c5f18a 100644 --- a/gcc/rust/typecheck/rust-hir-type-check.h +++ b/gcc/rust/typecheck/rust-hir-type-check.h @@ -164,21 +164,20 @@ struct DeferredOpOverload HirId expr_id; LangItem::Kind lang_item_type; HIR::PathIdentSegment specified_segment; - TyTy::TypeBoundPredicate predicate; HIR::OperatorExprMeta op; + TyTy::TyVar result_type; DeferredOpOverload (HirId expr_id, LangItem::Kind lang_item_type, HIR::PathIdentSegment specified_segment, - TyTy::TypeBoundPredicate &predicate, - HIR::OperatorExprMeta op) + HIR::OperatorExprMeta op, TyTy::TyVar result_type) : expr_id (expr_id), lang_item_type (lang_item_type), - specified_segment (specified_segment), predicate (predicate), op (op) + specified_segment (specified_segment), op (op), result_type (result_type) {} DeferredOpOverload (const struct DeferredOpOverload &other) : expr_id (other.expr_id), lang_item_type (other.lang_item_type), - specified_segment (other.specified_segment), predicate (other.predicate), - op (other.op) + specified_segment (other.specified_segment), op (other.op), + result_type (other.result_type) {} DeferredOpOverload &operator= (struct DeferredOpOverload const &other) @@ -187,6 +186,7 @@ struct DeferredOpOverload lang_item_type = other.lang_item_type; specified_segment = other.specified_segment; op = other.op; + result_type = other.result_type; return *this; } diff --git a/gcc/rust/typecheck/rust-type-util.cc b/gcc/rust/typecheck/rust-type-util.cc index 005defb50a6b..f90c959532d2 100644 --- a/gcc/rust/typecheck/rust-type-util.cc +++ b/gcc/rust/typecheck/rust-type-util.cc @@ -257,8 +257,8 @@ unify_site (HirId id, TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs, std::vector commits; std::vector infers; return UnifyRules::Resolve (lhs, rhs, unify_locus, true /*commit*/, - true /*emit_error*/, false /*infer*/, - true /*check_bounds*/, commits, infers); + true /*emit_error*/, true /*check_bounds*/, + false /*infer*/, commits, infers); } TyTy::BaseType * @@ -283,7 +283,7 @@ unify_site_and (HirId id, TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs, std::vector infers; TyTy::BaseType *result = UnifyRules::Resolve (lhs, rhs, unify_locus, false /*commit inline*/, - emit_errors, implicit_infer_vars, check_bounds, + emit_errors, check_bounds, implicit_infer_vars, commits, infers); bool ok = result->get_kind () != TyTy::TypeKind::ERROR; diff --git a/gcc/rust/typecheck/rust-typecheck-context.cc b/gcc/rust/typecheck/rust-typecheck-context.cc index 44744730b53f..57fc768cb62f 100644 --- a/gcc/rust/typecheck/rust-typecheck-context.cc +++ b/gcc/rust/typecheck/rust-typecheck-context.cc @@ -725,8 +725,7 @@ bool TypeCheckContext::compute_ambigious_op_overload (HirId id, DeferredOpOverload &op) { - rust_debug ("attempting resolution of op overload: %s", - op.predicate.as_string ().c_str ()); + rust_debug ("attempting resolution of deferred operator overload"); TyTy::BaseType *lhs = nullptr; bool ok = lookup_type (op.op.get_lvalue_mappings ().get_hirid (), &lhs); @@ -739,8 +738,28 @@ TypeCheckContext::compute_ambigious_op_overload (HirId id, rust_assert (ok); } - TypeCheckExpr::ResolveOpOverload (op.lang_item_type, op.op, lhs, rhs, - op.specified_segment); + TyTy::BaseType *current_result = op.result_type.get_tyty (); + rust_assert (current_result != nullptr); + + rust_debug ("deferred operator expr=%u lhs=%s rhs=%s " + "stored-result=%s current-result=%s result-ref=%u ty-ref=%u", + id, lhs->debug_str ().c_str (), + rhs == nullptr ? "" : rhs->debug_str ().c_str (), + current_result->debug_str ().c_str (), + current_result->debug_str ().c_str (), op.result_type.get_ref (), + current_result->get_ty_ref ()); + + TyTy::BaseType *resolved + = TypeCheckExpr::ResolveOpOverload (op.lang_item_type, op.op, lhs, rhs, + op.specified_segment, current_result); + if (resolved == nullptr) + return false; + + TyTy::BaseType *result + = unify_site (id, TyTy::TyWithLocation (current_result), + TyTy::TyWithLocation (resolved), op.op.get_locus ()); + rust_assert (result != nullptr); + rust_assert (result->get_kind () != TyTy::TypeKind::ERROR); return true; } @@ -748,14 +767,33 @@ TypeCheckContext::compute_ambigious_op_overload (HirId id, void TypeCheckContext::compute_inference_variables (bool emit_error) { - iterate_deferred_operator_overloads ( - [&] (HirId id, DeferredOpOverload &op) mutable -> bool { - return compute_ambigious_op_overload (id, op); - }); + auto resolve_deferred_operator_overloads = [this] () { + bool progress; + do + { + progress = false; + for (auto it = deferred_operator_overloads.begin (); + it != deferred_operator_overloads.end ();) + { + if (compute_ambigious_op_overload (it->first, it->second)) + { + it = deferred_operator_overloads.erase (it); + progress = true; + } + else + ++it; + } + } + while (progress); + }; + + resolve_deferred_operator_overloads (); iterate ([&] (HirId id, TyTy::BaseType *ty) mutable -> bool { return compute_infer_var (id, ty, emit_error); }); + + resolve_deferred_operator_overloads (); } bool @@ -771,9 +809,15 @@ TypeCheckContext::compute_infer_var (HirId id, TyTy::BaseType *ty, TyTy::InferType *infer_var = static_cast (ty); TyTy::BaseType *default_type; + TyTy::BaseType *current = TyTy::TyVar (ty->get_ref ()).get_tyty (); + rust_assert (current != nullptr); + rust_debug_loc (mappings.lookup_location (id), - "trying to default infer-var: %s", - infer_var->as_string ().c_str ()); + "trying to default infer-var id=%u ref=%u ty-ref=%u " + "stored=%s current=%s", + id, ty->get_ref (), ty->get_ty_ref (), + infer_var->debug_str ().c_str (), + current->debug_str ().c_str ()); bool ok = infer_var->default_type (&default_type); if (!ok) { @@ -783,6 +827,9 @@ TypeCheckContext::compute_infer_var (HirId id, TyTy::BaseType *ty, return true; } + rust_debug_loc (mappings.lookup_location (id), "default type selected: %s", + default_type->debug_str ().c_str ()); + auto result = unify_site (id, TyTy::TyWithLocation (ty), TyTy::TyWithLocation (default_type), UNDEF_LOCATION); diff --git a/gcc/rust/typecheck/rust-unify.cc b/gcc/rust/typecheck/rust-unify.cc index e6a863a5bd0f..c8dee621452d 100644 --- a/gcc/rust/typecheck/rust-unify.cc +++ b/gcc/rust/typecheck/rust-unify.cc @@ -18,7 +18,6 @@ #include "rust-unify.h" #include "fold-const.h" -#include "rust-substitution-mapper.h" #include "rust-tyty-util.h" #include "rust-tyty.h" #include "rust-type-util.h" @@ -53,7 +52,7 @@ UnifyRules::Resolve (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs, std::vector &commits, std::vector &infers) { - UnifyRules r (lhs, rhs, locus, commit_flag, emit_error, infer, check_bounds, + UnifyRules r (lhs, rhs, locus, commit_flag, emit_error, check_bounds, infer, commits, infers); TyTy::BaseType *result = r.go (); @@ -76,8 +75,8 @@ TyTy::BaseType * UnifyRules::resolve_subtype (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs) { TyTy::BaseType *result - = UnifyRules::Resolve (lhs, rhs, locus, commit_flag, emit_error, infer_flag, - check_bounds_flag, commits, infers); + = UnifyRules::Resolve (lhs, rhs, locus, commit_flag, emit_error, + check_bounds_flag, infer_flag, commits, infers); // If the recursive call resulted in an error and would have emitted an error // message, disable error emission for the current level to avoid duplicate diff --git a/gcc/rust/typecheck/rust-unify.h b/gcc/rust/typecheck/rust-unify.h index c812cfb2f13d..f57914032d4a 100644 --- a/gcc/rust/typecheck/rust-unify.h +++ b/gcc/rust/typecheck/rust-unify.h @@ -54,8 +54,8 @@ class UnifyRules static TyTy::BaseType *Resolve (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs, location_t locus, - bool commit_flag, bool emit_error, bool infer, - bool check_bounds, + bool commit_flag, bool emit_error, + bool check_bounds, bool infer, std::vector &commits, std::vector &infers); diff --git a/gcc/testsuite/rust/execute/torture/deferred-add-partial-ord.rs b/gcc/testsuite/rust/execute/torture/deferred-add-partial-ord.rs new file mode 100644 index 000000000000..6d23dd5f5393 --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/deferred-add-partial-ord.rs @@ -0,0 +1,58 @@ +// { dg-additional-options "-w" } +#![feature(no_core)] +#![no_core] + +#![feature(rustc_attrs, lang_items)] + +#[lang = "sized"] +trait Sized {} + +#[lang = "add"] +trait Add { + type Output; + + fn add(self, rhs: Rhs) -> Self::Output; +} + +#[lang = "partial_ord"] +trait PartialOrd { + fn lt(&self, other: &Rhs) -> bool; +} + +macro_rules! add_impl { + ($($t:ty)*) => ($( + impl Add for $t { + type Output = $t; + + #[inline] + #[rustc_inherit_overflow_checks] + fn add(self, other: $t) -> $t { self + other } + } + )*) +} + +macro_rules! partial_ord_impl { + ($($t:ty)*) => ($( + impl PartialOrd for $t { + fn lt(&self, other: &$t) -> bool { *self < *other } + } + )*) +} + +add_impl! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 isize } +partial_ord_impl! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 isize } + +fn test(len: usize) -> u64 { + let mut i = 0; + let mut out = 0; + if i + 3 < len { + out = 123; + } else { + out = 456; + } + out +} + +fn main() -> i32 { + test(4) as i32 - 123 + test(3) as i32 - 456 +} From 2d06661660f19fc9a17e9f9e01271e0b4f6eee97 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Sun, 6 Sep 2026 21:04:46 +0100 Subject: [PATCH 103/584] gccrs: Fix handling of constants in paths Fixes Rust-GCC/gccrs#4851 gcc/rust/ChangeLog: * backend/rust-compile-pattern.cc (CompilePatternCheckExpr::visit): handle non ADT * typecheck/rust-hir-type-check-pattern.cc (TypeCheckPattern::visit): likewise gcc/testsuite/ChangeLog: * rust/compile/issue-4851.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/backend/rust-compile-pattern.cc | 13 ++++++++-- .../typecheck/rust-hir-type-check-pattern.cc | 8 +++++- gcc/testsuite/rust/compile/issue-4851.rs | 26 +++++++++++++++++++ 3 files changed, 44 insertions(+), 3 deletions(-) create mode 100644 gcc/testsuite/rust/compile/issue-4851.rs diff --git a/gcc/rust/backend/rust-compile-pattern.cc b/gcc/rust/backend/rust-compile-pattern.cc index 82cabef784b0..309d8f1953ee 100644 --- a/gcc/rust/backend/rust-compile-pattern.cc +++ b/gcc/rust/backend/rust-compile-pattern.cc @@ -47,8 +47,17 @@ CompilePatternCheckExpr::visit (HIR::PathInExpression &pattern) &lookup); rust_assert (ok); - // must be an ADT (?) - rust_assert (lookup->get_kind () == TyTy::TypeKind::ADT); + if (lookup->get_kind () != TyTy::TypeKind::ADT) + { + tree constant_expr = ResolvePathRef::Compile (pattern, ctx); + + check_expr + = Backend::comparison_expression (ComparisonOperator::EQUAL, + match_scrutinee_expr, constant_expr, + pattern.get_locus ()); + return; + } + TyTy::ADTType *adt = static_cast (lookup); // if this isn't an enum, always succeed diff --git a/gcc/rust/typecheck/rust-hir-type-check-pattern.cc b/gcc/rust/typecheck/rust-hir-type-check-pattern.cc index 83104833dbea..b5f336b42a65 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-pattern.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-pattern.cc @@ -111,8 +111,14 @@ TypeCheckPattern::visit (HIR::PathInExpression &pattern) } } + if (path_is_const_item) + { + infered = pattern_ty; + return; + } + // If the path is a constructor, it must be a unit struct or unit variants. - if (!path_is_const_item && pattern_ty->get_kind () == TyTy::TypeKind::ADT) + if (pattern_ty->get_kind () == TyTy::TypeKind::ADT) { TyTy::ADTType *adt = static_cast (pattern_ty); rust_assert (adt->get_variants ().size () > 0); diff --git a/gcc/testsuite/rust/compile/issue-4851.rs b/gcc/testsuite/rust/compile/issue-4851.rs new file mode 100644 index 000000000000..c76a4cb66524 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4851.rs @@ -0,0 +1,26 @@ +#![feature(lang_items, no_core)] +#![no_core] + +#[lang = "sized"] +trait Sized {} + +enum FpCategory { + Zero, + Subnormal, + Infinite, + Nan, + Normal, +} + +pub fn classify(bits: u32) -> FpCategory { + const EXP_MASK: u32 = 0x7f800000; + const MAN_MASK: u32 = 0x007fffff; + + match (bits & MAN_MASK, bits & EXP_MASK) { + (0, 0) => FpCategory::Zero, + (_, 0) => FpCategory::Subnormal, + (0, EXP_MASK) => FpCategory::Infinite, + (_, EXP_MASK) => FpCategory::Nan, + _ => FpCategory::Normal, + } +} From ff51c40ed910394c622d971e0cd97d26b3a55d14 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Sun, 6 Sep 2026 22:00:56 +0100 Subject: [PATCH 104/584] gccrs: Handle generic args to traits in paths Fixes Rust-GCC/gccrs#4853 gcc/rust/ChangeLog: * typecheck/rust-substitution-mapper.cc (SubstMapper::valid_type): check for dyn object (SubstMapper::visit): substitution on it * typecheck/rust-substitution-mapper.h: add impl gcc/testsuite/ChangeLog: * rust/compile/issue-4853.rs: New test. Signed-off-by: Philip Herron --- .../typecheck/rust-substitution-mapper.cc | 24 ++++++++++++++++++ gcc/rust/typecheck/rust-substitution-mapper.h | 2 +- gcc/testsuite/rust/compile/issue-4853.rs | 25 +++++++++++++++++++ 3 files changed, 50 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/rust/compile/issue-4853.rs diff --git a/gcc/rust/typecheck/rust-substitution-mapper.cc b/gcc/rust/typecheck/rust-substitution-mapper.cc index 579c88c4dae7..e08356c2b653 100644 --- a/gcc/rust/typecheck/rust-substitution-mapper.cc +++ b/gcc/rust/typecheck/rust-substitution-mapper.cc @@ -63,6 +63,14 @@ SubstMapper::valid_type (TyTy::BaseType *base) bool is_placeholder = base->is (); bool is_projection = base->is (); + // see gcc/testsuite/rust/compile/issue-4853.rs + if (auto *dyn = base->try_as ()) + { + auto &bounds = dyn->get_specified_bounds (); + if (bounds.size () == 1) + return bounds.at (0).requires_generic_args (); + } + return is_fn || is_adt || is_placeholder || is_projection; } @@ -120,6 +128,22 @@ SubstMapper::visit (TyTy::ADTType &type) resolved = concrete; } +void +SubstMapper::visit (TyTy::DynamicObjectType &type) +{ + rust_assert (have_generic_args ()); + rust_assert (type.get_specified_bounds ().size () == 1); + rust_assert (type.get_specified_bounds ().at (0).requires_generic_args ()); + + TyTy::TypeBoundPredicate predicate = type.get_specified_bounds ().at (0); + predicate.apply_generic_arguments (generics, false, false); + if (predicate.is_error ()) + return; + + resolved = new TyTy::DynamicObjectType (type.get_ref (), type.get_ident (), + {predicate}); +} + void SubstMapper::visit (TyTy::PlaceholderType &type) { diff --git a/gcc/rust/typecheck/rust-substitution-mapper.h b/gcc/rust/typecheck/rust-substitution-mapper.h index 73632ddf2b5d..fefab0c578a0 100644 --- a/gcc/rust/typecheck/rust-substitution-mapper.h +++ b/gcc/rust/typecheck/rust-substitution-mapper.h @@ -43,6 +43,7 @@ class SubstMapper : public TyTy::TyVisitor void visit (TyTy::ADTType &type) override; void visit (TyTy::PlaceholderType &type) override; void visit (TyTy::ProjectionType &type) override; + void visit (TyTy::DynamicObjectType &type) override; // nothing to do for these void visit (TyTy::InferType &) override { rust_unreachable (); } @@ -67,7 +68,6 @@ class SubstMapper : public TyTy::TyVisitor void visit (TyTy::ConstErrorType &) override { rust_unreachable (); } void visit (TyTy::StrType &) override { rust_unreachable (); } void visit (TyTy::NeverType &) override { rust_unreachable (); } - void visit (TyTy::DynamicObjectType &) override { rust_unreachable (); } void visit (TyTy::ClosureType &) override { rust_unreachable (); } void visit (TyTy::OpaqueType &) override { rust_unreachable (); } diff --git a/gcc/testsuite/rust/compile/issue-4853.rs b/gcc/testsuite/rust/compile/issue-4853.rs new file mode 100644 index 000000000000..45de755edda7 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4853.rs @@ -0,0 +1,25 @@ +// { dg-additional-options "-frust-edition=2018" } +#![feature(lang_items, no_core)] +#![no_core] + +#[lang = "sized"] +trait Sized {} + +trait FloatToInt: Sized { + unsafe fn to_int_unchecked(self) -> Int; +} + +impl FloatToInt for f32 { + unsafe fn to_int_unchecked(self) -> u32 { + 0 + } +} + +impl f32 { + pub unsafe fn to_int_unchecked(self) -> Int + where + Self: FloatToInt, + { + unsafe { FloatToInt::::to_int_unchecked(self) } + } +} From f71f2f5947b8935d1ba4934831482bb3c9b4d9ff Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 7 Sep 2026 11:58:01 +0100 Subject: [PATCH 105/584] gccrs: Fix bug when compiling const position intrinsic calls Since the changes to improve query_type to resolve function signitures seperate to the bodies we can end up with the case where we resolve just to a signiture which needs to call another function which is not yet type checked so when we do const-eval during typechecking it fails because its not ready. This patch adds a new const context stack so we can override that behaviour for const eval to make sure we dont have unresolved chunks for this case. Fixes Rust-GCC/gccrs#4855 gcc/rust/ChangeLog: * checks/errors/privacy/rust-reachability.cc: dont need to assert * typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit): push const ctx * typecheck/rust-hir-type-check-implitem.cc (TypeCheckImplItem::visit): likewise * typecheck/rust-hir-type-check-item.cc (TypeCheckItem::visit): likewise * typecheck/rust-hir-type-check-type.cc (TypeCheckType::visit): likewse * typecheck/rust-hir-type-check.h: likewise * typecheck/rust-type-util.cc (query_type): check const_context_p gcc/testsuite/ChangeLog: * rust/compile/issue-4855.rs: New test. Signed-off-by: Philip Herron --- .../errors/privacy/rust-reachability.cc | 10 ++-- .../typecheck/rust-hir-type-check-expr.cc | 9 +++- .../typecheck/rust-hir-type-check-implitem.cc | 2 + .../typecheck/rust-hir-type-check-item.cc | 2 + .../typecheck/rust-hir-type-check-type.cc | 3 ++ gcc/rust/typecheck/rust-hir-type-check.h | 10 ++++ gcc/rust/typecheck/rust-type-util.cc | 25 ++++++---- gcc/testsuite/rust/compile/issue-4855.rs | 46 +++++++++++++++++++ 8 files changed, 89 insertions(+), 18 deletions(-) create mode 100644 gcc/testsuite/rust/compile/issue-4855.rs diff --git a/gcc/rust/checks/errors/privacy/rust-reachability.cc b/gcc/rust/checks/errors/privacy/rust-reachability.cc index 8fee0e88dd43..1e07e091eeca 100644 --- a/gcc/rust/checks/errors/privacy/rust-reachability.cc +++ b/gcc/rust/checks/errors/privacy/rust-reachability.cc @@ -50,14 +50,12 @@ ReachabilityVisitor::visit_generic_predicates ( { if (generic->get_kind () == HIR::GenericParam::GenericKind::TYPE) { - TyTy::BaseType *generic_ty = nullptr; - auto ok = ty_ctx.lookup_type (generic->get_mappings ().get_hirid (), - &generic_ty); + TyTy::BaseType *ty = nullptr; + auto ok + = ty_ctx.lookup_type (generic->get_mappings ().get_hirid (), &ty); rust_assert (ok); - rust_assert (generic_ty->get_kind () == TyTy::PARAM); - auto generic_param = static_cast (generic_ty); - for (const auto &bound : generic_param->get_specified_bounds ()) + for (const auto &bound : ty->get_specified_bounds ()) { const auto trait = bound.get ()->get_hir_trait_ref (); ctx.update_reachability (trait->get_mappings (), item_reach); diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc index cc967d4b301a..a77b4de81df4 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc @@ -1150,13 +1150,16 @@ TypeCheckExpr::visit (HIR::ArrayExpr &expr) HIR::Expr *capacity_expr = nullptr; TyTy::BaseType *element_type = nullptr; TyTy::BaseType *capacity_type = nullptr; + switch (elements.get_array_expr_type ()) { case HIR::ArrayElems::ArrayExprType::COPIED: { HIR::ArrayElemsCopied &elems = static_cast (elements); + context->push_const_context (); element_type = TypeCheckExpr::Resolve (elems.get_elem_to_copy ()); + context->pop_const_context (); auto capacity_expr_ty = TypeCheckExpr::Resolve (elems.get_num_copies_expr ()); @@ -1183,12 +1186,14 @@ TypeCheckExpr::visit (HIR::ArrayExpr &expr) { HIR::ArrayElemsValues &elems = static_cast (elements); - + context->push_const_context (); std::vector types; for (auto &elem : elems.get_values ()) { - types.push_back (TypeCheckExpr::Resolve (*elem)); + auto elem_ty = TypeCheckExpr::Resolve (*elem); + types.push_back (elem_ty); } + context->pop_const_context (); // this is a LUB element_type diff --git a/gcc/rust/typecheck/rust-hir-type-check-implitem.cc b/gcc/rust/typecheck/rust-hir-type-check-implitem.cc index 9d8f8385ecac..9fb0d70a3401 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-implitem.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-implitem.cc @@ -457,7 +457,9 @@ void TypeCheckImplItem::visit (HIR::ConstantItem &constant) { TyTy::BaseType *type = TypeCheckType::Resolve (constant.get_type ()); + context->push_const_context (); TyTy::BaseType *expr_type = TypeCheckExpr::Resolve (constant.get_expr ()); + context->pop_const_context (); TyTy::BaseType *unified = unify_site ( constant.get_mappings ().get_hirid (), diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.cc b/gcc/rust/typecheck/rust-hir-type-check-item.cc index bff50778d86e..7cee908b403c 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-item.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-item.cc @@ -648,7 +648,9 @@ void TypeCheckItem::visit (HIR::ConstantItem &constant) { TyTy::BaseType *type = TypeCheckType::Resolve (constant.get_type ()); + context->push_const_context (); TyTy::BaseType *expr_type = TypeCheckExpr::Resolve (constant.get_expr ()); + context->pop_const_context (); TyTy::BaseType *unified = unify_site ( constant.get_mappings ().get_hirid (), diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.cc b/gcc/rust/typecheck/rust-hir-type-check-type.cc index e44221a7e983..55468516a786 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-type.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-type.cc @@ -692,7 +692,10 @@ void TypeCheckType::visit (HIR::ArrayType &type) { auto element_type = TypeCheckType::Resolve (type.get_element_type ()); + context->push_const_context (); auto capacity_type = TypeCheckExpr::Resolve (type.get_size_expr ()); + context->pop_const_context (); + if (capacity_type->get_kind () == TyTy::TypeKind::ERROR) return; diff --git a/gcc/rust/typecheck/rust-hir-type-check.h b/gcc/rust/typecheck/rust-hir-type-check.h index f1db16c5f18a..3fdd08b4d414 100644 --- a/gcc/rust/typecheck/rust-hir-type-check.h +++ b/gcc/rust/typecheck/rust-hir-type-check.h @@ -326,6 +326,14 @@ class TypeCheckContext TyTy::VarianceAnalysis::CrateCtx &get_variance_analysis_ctx (); + void push_const_context (void) { const_context++; } + void pop_const_context (void) + { + if (const_context > 0) + const_context--; + } + bool const_context_p (void) { return (const_context > 0); } + private: TypeCheckContext (); @@ -377,6 +385,8 @@ class TypeCheckContext // variance analysis TyTy::VarianceAnalysis::CrateCtx variance_analysis_ctx; + unsigned int const_context = 0; + /** Used to resolve (interned) lifetime names to their bounding scope. */ class LifetimeResolver { diff --git a/gcc/rust/typecheck/rust-type-util.cc b/gcc/rust/typecheck/rust-type-util.cc index f90c959532d2..226ea747b029 100644 --- a/gcc/rust/typecheck/rust-type-util.cc +++ b/gcc/rust/typecheck/rust-type-util.cc @@ -79,16 +79,21 @@ query_type (HirId reference, TyTy::BaseType **result) bool is_local = item_defid.crateNum == mappings.get_current_crate (); bool is_fn = item.value ()->get_item_kind () == HIR::Item::ItemKind::Function; - if (is_fn && is_local) + if (!context->const_context_p ()) { - HIR::Function &fn = *static_cast (item.value ()); - *result = TypeCheckItem::ResolveFunctionSignature (fn); - } - else if (item.value ()->get_item_kind () == HIR::Item::ItemKind::Trait - && is_local) - { - HIR::Trait &trait = *static_cast (item.value ()); - *result = TypeCheckItem::ResolveTraitSignature (trait); + if (is_fn && is_local) + { + HIR::Function &fn = *static_cast (item.value ()); + *result = TypeCheckItem::ResolveFunctionSignature (fn); + } + else if (item.value ()->get_item_kind () == HIR::Item::ItemKind::Trait + && is_local) + { + HIR::Trait &trait = *static_cast (item.value ()); + *result = TypeCheckItem::ResolveTraitSignature (trait); + } + else + *result = TypeCheckItem::Resolve (*item.value ()); } else { @@ -159,7 +164,7 @@ query_type (HirId reference, TyTy::BaseType **result) DefId item_defid = impl_item->first->get_impl_mappings ().get_defid (); bool is_local = item_defid.crateNum == mappings.get_current_crate (); if (impl_item->first->get_impl_item_type () == HIR::ImplItem::FUNCTION - && is_local) + && is_local && !context->const_context_p ()) { HIR::Function &fn = *static_cast (impl_item->first); *result = TypeCheckImplItem::ResolveFunctionSignature ( diff --git a/gcc/testsuite/rust/compile/issue-4855.rs b/gcc/testsuite/rust/compile/issue-4855.rs new file mode 100644 index 000000000000..5c5b47b9025d --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4855.rs @@ -0,0 +1,46 @@ +#![feature(no_core, intrinsics, lang_items, staged_api)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +mod my_u32 { + impl u32 { + pub const fn to_be_bytes(self) -> [u8; crate::mem::size_of::()] { + [0; crate::mem::size_of::()] + } + + pub fn other_method(self) -> u32 { + self + } + } +} + +mod my_f32 { + impl f32 { + pub fn to_bits(self) -> u32 { + 0 + } + + pub fn do_something(self) -> u32 { + self.to_bits().other_method() + } + } +} + +extern "rust-intrinsic" { + #[rustc_const_stable(feature = "const_size_of", since = "1.40.0")] + pub fn size_of() -> usize; +} + +mod mem { + pub const fn size_of() -> usize { + crate::size_of::() + } +} + +fn main() -> i32 { + let x: f32 = 0.0; + let _ = x.do_something(); + 0 +} From 8dab655e395088f889069af3e92f03e87639f38b Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 7 Sep 2026 14:20:51 +0100 Subject: [PATCH 106/584] gccrs: use std::move to reduce copy ctor usage on type-bound-predicate gcc/rust/ChangeLog: * typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit): update * typecheck/rust-hir-type-check-item.cc (TypeCheckItem::resolve_impl_block_substitutions): likewise * typecheck/rust-hir-type-check-path.cc (TypeCheckExpr::visit): likewise * typecheck/rust-hir-type-check-type.cc (TypeCheckType::visit): likewise * typecheck/rust-hir-type-check.h: likewise * typecheck/rust-typecheck-context.cc (TypeCheckContext::insert_resolved_predicate): likewise * typecheck/rust-tyty-bounds.cc (TypeBoundPredicate::TypeBoundPredicate): likewise (TypeBoundPredicate::operator=): remove deadcode (TypeBoundsMappings::add_bound): use ref * typecheck/rust-tyty-call.cc (validate_call_argument_associated_impl_bounds): use ref * typecheck/rust-tyty.cc (BaseType::BaseType): likewise (BaseType::inherit_bound): likewise (ParamType::ParamType): likewiase * typecheck/rust-tyty.h: likewise Signed-off-by: Philip Herron --- .../typecheck/rust-hir-type-check-expr.cc | 2 +- .../typecheck/rust-hir-type-check-item.cc | 2 +- .../typecheck/rust-hir-type-check-path.cc | 2 +- .../typecheck/rust-hir-type-check-type.cc | 2 +- gcc/rust/typecheck/rust-hir-type-check.h | 3 ++- gcc/rust/typecheck/rust-typecheck-context.cc | 6 +++--- gcc/rust/typecheck/rust-tyty-bounds.cc | 20 ++----------------- gcc/rust/typecheck/rust-tyty-call.cc | 2 +- gcc/rust/typecheck/rust-tyty.cc | 12 ++++++++--- gcc/rust/typecheck/rust-tyty.h | 6 ++++-- 10 files changed, 25 insertions(+), 32 deletions(-) diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc index a77b4de81df4..7f8547f53ee0 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc @@ -2018,7 +2018,7 @@ TypeCheckExpr::visit (HIR::ClosureExpr &expr) predicate.apply_generic_arguments (&args, false, false); // finally inherit the trait bound - infered->inherit_bounds ({predicate}); + infered->inherit_bound (predicate); } bool diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.cc b/gcc/rust/typecheck/rust-hir-type-check-item.cc index 7cee908b403c..2f2005b71bf7 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-item.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-item.cc @@ -1086,7 +1086,7 @@ TypeCheckItem::resolve_impl_block_substitutions (HIR::ImplBlock &impl_block, // inherit the bounds if (!specified_bound.is_error ()) - self->inherit_bounds ({specified_bound}); + self->inherit_bound (specified_bound); // check for any unconstrained type-params const TyTy::SubstitutionArgumentMappings trait_constraints diff --git a/gcc/rust/typecheck/rust-hir-type-check-path.cc b/gcc/rust/typecheck/rust-hir-type-check-path.cc index 52c6e66b2bfe..2e1731ac1db3 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-path.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-path.cc @@ -73,7 +73,7 @@ TypeCheckExpr::visit (HIR::QualifiedPathInExpression &expr) return; // inherit the bound - root->inherit_bounds ({specified_bound}); + root->inherit_bound (specified_bound); // lookup the associated item from the specified bound HIR::PathExprSegment &item_seg = expr.get_segments ().at (0); diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.cc b/gcc/rust/typecheck/rust-hir-type-check-type.cc index 55468516a786..84baab6ffa76 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-type.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-type.cc @@ -221,7 +221,7 @@ TypeCheckType::visit (HIR::QualifiedPathInType &path) return; // inherit the bound - root->inherit_bounds ({specified_bound}); + root->inherit_bound (specified_bound); // lookup the associated item from the specified bound HIR::TypePathSegment &item_seg = path.get_associated_segment (); diff --git a/gcc/rust/typecheck/rust-hir-type-check.h b/gcc/rust/typecheck/rust-hir-type-check.h index 3fdd08b4d414..4efbaa8936b2 100644 --- a/gcc/rust/typecheck/rust-hir-type-check.h +++ b/gcc/rust/typecheck/rust-hir-type-check.h @@ -299,7 +299,8 @@ class TypeCheckContext void insert_unconstrained_check_marker (HirId id, bool status); bool have_checked_for_unconstrained (HirId id, bool *result); - void insert_resolved_predicate (HirId id, TyTy::TypeBoundPredicate predicate); + void insert_resolved_predicate (HirId id, + const TyTy::TypeBoundPredicate &predicate); bool lookup_predicate (HirId id, TyTy::TypeBoundPredicate *result); void insert_query (HirId id); diff --git a/gcc/rust/typecheck/rust-typecheck-context.cc b/gcc/rust/typecheck/rust-typecheck-context.cc index 57fc768cb62f..404f83443311 100644 --- a/gcc/rust/typecheck/rust-typecheck-context.cc +++ b/gcc/rust/typecheck/rust-typecheck-context.cc @@ -574,13 +574,13 @@ TypeCheckContext::have_checked_for_unconstrained (HirId id, bool *result) } void -TypeCheckContext::insert_resolved_predicate (HirId id, - TyTy::TypeBoundPredicate predicate) +TypeCheckContext::insert_resolved_predicate ( + HirId id, const TyTy::TypeBoundPredicate &predicate) { // auto it = predicates.find (id); // rust_assert (it == predicates.end ()); - predicates.insert ({id, predicate}); + predicates.emplace (id, predicate); } bool diff --git a/gcc/rust/typecheck/rust-tyty-bounds.cc b/gcc/rust/typecheck/rust-tyty-bounds.cc index b4e30f162656..0240a635ca71 100644 --- a/gcc/rust/typecheck/rust-tyty-bounds.cc +++ b/gcc/rust/typecheck/rust-tyty-bounds.cc @@ -450,14 +450,6 @@ TypeBoundPredicate::TypeBoundPredicate (const TypeBoundPredicate &other) for (const auto &p : other.get_substs ()) substitutions.push_back (p.clone ()); - std::vector mappings; - for (size_t i = 0; i < other.used_arguments.get_mappings ().size (); i++) - { - const SubstitutionArg &oa = other.used_arguments.get_mappings ().at (i); - SubstitutionArg arg (oa); - mappings.push_back (std::move (arg)); - } - // we need to remap the argument mappings based on this copied constructor std::vector copied_arg_mappings; size_t i = 0; @@ -491,14 +483,6 @@ TypeBoundPredicate::operator= (const TypeBoundPredicate &other) if (other.is_error ()) return *this; - std::vector mappings; - for (size_t i = 0; i < other.used_arguments.get_mappings ().size (); i++) - { - const SubstitutionArg &oa = other.used_arguments.get_mappings ().at (i); - SubstitutionArg arg (oa); - mappings.push_back (std::move (arg)); - } - // we need to remap the argument mappings based on this copied constructor std::vector copied_arg_mappings; size_t i = 0; @@ -983,7 +967,7 @@ TypeBoundPredicateItem::get_locus () const TypeBoundsMappings::TypeBoundsMappings ( std::vector specified_bounds) - : specified_bounds (specified_bounds) + : specified_bounds (std::move (specified_bounds)) {} std::vector & @@ -1049,7 +1033,7 @@ TypeBoundsMappings::raw_bounds_as_name () const } void -TypeBoundsMappings::add_bound (TypeBoundPredicate predicate) +TypeBoundsMappings::add_bound (const TypeBoundPredicate &predicate) { for (auto &bound : specified_bounds) { diff --git a/gcc/rust/typecheck/rust-tyty-call.cc b/gcc/rust/typecheck/rust-tyty-call.cc index 7ec23281a913..f87b160f8485 100644 --- a/gcc/rust/typecheck/rust-tyty-call.cc +++ b/gcc/rust/typecheck/rust-tyty-call.cc @@ -73,7 +73,7 @@ validate_call_argument_associated_impl_bounds (BaseType *param_ty, || resolved_argument_ty->get_kind () == TypeKind::PROJECTION) return true; - for (auto bound : param_ty->get_specified_bounds ()) + for (const auto &bound : param_ty->get_specified_bounds ()) { bool ambigious = false; auto associated diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc index 7e27343cd112..bb7aae7a17f0 100644 --- a/gcc/rust/typecheck/rust-tyty.cc +++ b/gcc/rust/typecheck/rust-tyty.cc @@ -156,7 +156,7 @@ BaseType::BaseType (HirId ref, HirId ty_ref, TypeKind kind, RustIdent ident, BaseType::BaseType (HirId ref, HirId ty_ref, TypeKind kind, RustIdent ident, std::vector specified_bounds, std::set refs) - : TypeBoundsMappings (specified_bounds), kind (kind), ref (ref), + : TypeBoundsMappings (std::move (specified_bounds)), kind (kind), ref (ref), ty_ref (ty_ref), orig_ref (ref), combined (refs), ident (ident), mappings (Analysis::Mappings::get ()) {} @@ -533,6 +533,12 @@ BaseType::inherit_bounds (const BaseType &other) inherit_bounds (other.get_specified_bounds ()); } +void +BaseType::inherit_bound (const TypeBoundPredicate &bound) +{ + add_bound (bound); +} + void BaseType::inherit_bounds ( const std::vector &specified_bounds) @@ -3701,7 +3707,7 @@ ParamType::ParamType (std::string symbol, location_t locus, HirId ref, : BaseGeneric (ref, ref, KIND, {Resolver::CanonicalPath::new_seg (UNKNOWN_NODEID, symbol), locus}, - specified_bounds, refs), + std::move (specified_bounds), refs), is_trait_self (false), symbol (symbol) {} @@ -3712,7 +3718,7 @@ ParamType::ParamType (bool is_trait_self, std::string symbol, location_t locus, : BaseGeneric (ref, ty_ref, KIND, {Resolver::CanonicalPath::new_seg (UNKNOWN_NODEID, symbol), locus}, - specified_bounds, refs), + std::move (specified_bounds), refs), is_trait_self (is_trait_self), symbol (symbol) {} diff --git a/gcc/rust/typecheck/rust-tyty.h b/gcc/rust/typecheck/rust-tyty.h index 4e1cd301edfa..7ecea5759148 100644 --- a/gcc/rust/typecheck/rust-tyty.h +++ b/gcc/rust/typecheck/rust-tyty.h @@ -207,7 +207,7 @@ class TypeBoundsMappings std::string raw_bounds_as_name () const; protected: - void add_bound (TypeBoundPredicate predicate); + void add_bound (const TypeBoundPredicate &predicate); std::vector specified_bounds; }; @@ -245,6 +245,8 @@ class BaseType : public TypeBoundsMappings void inherit_bounds (const BaseType &other); + void inherit_bound (const TypeBoundPredicate &bound); + void inherit_bounds ( const std::vector &specified_bounds); @@ -500,7 +502,7 @@ class BaseGeneric : public BaseType BaseGeneric (HirId ref, HirId ty_ref, TypeKind kind, RustIdent ident, std::vector specified_bounds, std::set refs = std::set ()) - : BaseType (ref, ty_ref, kind, ident, specified_bounds, refs) + : BaseType (ref, ty_ref, kind, ident, std::move (specified_bounds), refs) {} }; From e494d53547e81b3761c1cf2f8ed215be787fa25b Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 7 Sep 2026 21:39:13 +0100 Subject: [PATCH 107/584] gccrs: Fix return type leaking into other function contexts We use this expected types to help with type unification hints in awkward cases iirc it was for Try. But then when we have cases of return expressions which are const position and end up needing to resolve into other blocks which then bleeds these expected types into those chains. Fixes Rust-GCC/gccrs#4860 gcc/rust/ChangeLog: * typecheck/rust-typecheck-context.cc (TypeCheckContext::pop_return_type): push expected null gcc/testsuite/ChangeLog: * rust/compile/issue-4860.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-typecheck-context.cc | 4 +++ gcc/testsuite/rust/compile/issue-4860.rs | 29 ++++++++++++++++++++ 2 files changed, 33 insertions(+) create mode 100644 gcc/testsuite/rust/compile/issue-4860.rs diff --git a/gcc/rust/typecheck/rust-typecheck-context.cc b/gcc/rust/typecheck/rust-typecheck-context.cc index 404f83443311..a1f10ea29a1c 100644 --- a/gcc/rust/typecheck/rust-typecheck-context.cc +++ b/gcc/rust/typecheck/rust-typecheck-context.cc @@ -173,12 +173,16 @@ TypeCheckContext::push_return_type (TypeCheckContextItem item, TyTy::BaseType *return_type) { return_type_stack.emplace_back (std::move (item), return_type); + // a query can check another function body while an expression in the + // caller has an expected type + push_expected_type (nullptr); } void TypeCheckContext::pop_return_type () { rust_assert (!return_type_stack.empty ()); + pop_expected_type (); return_type_stack.pop_back (); } diff --git a/gcc/testsuite/rust/compile/issue-4860.rs b/gcc/testsuite/rust/compile/issue-4860.rs new file mode 100644 index 000000000000..0d054dc78b2e --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4860.rs @@ -0,0 +1,29 @@ +// { dg-options "-w" } +#![feature(no_core, lang_items, intrinsics, staged_api)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +pub const FLAG: bool = check(); + +pub const fn check() -> bool { + return 8i8.wrapping_shr(1) == 4; +} + +extern "rust-intrinsic" { + #[rustc_const_stable(feature = "const_int_unchecked", since = "1.40.0")] + fn unchecked_shr(x: T, y: T) -> T; +} + +impl i8 { + pub const fn wrapping_shr(self, rhs: u32) -> Self { + unsafe { unchecked_shr(self, (rhs & 7) as i8) } + } +} + +impl i16 { + pub const fn wrapping_shr(self, rhs: u32) -> Self { + unsafe { unchecked_shr(self, (rhs & 15) as i16) } + } +} From bf37e8d84699096e9d184f14adfbf6ecf372577a Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 7 Sep 2026 22:08:32 +0100 Subject: [PATCH 108/584] gccrs: Stop method selection when we hit generic params Generics like this need to match directly via their associated type bound predicates which will already be checked. Otherwise the unify machinery for types_compatable will wrongly match by injecting infer_vars. Fixes Rust-GCC/gccrs#4859 gcc/rust/ChangeLog: * typecheck/rust-hir-dot-operator.cc (MethodResolver::select): stop on ParamTypes gcc/testsuite/ChangeLog: * rust/compile/issue-4859.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-dot-operator.cc | 5 +++ gcc/testsuite/rust/compile/issue-4859.rs | 35 +++++++++++++++++++++ 2 files changed, 40 insertions(+) create mode 100644 gcc/testsuite/rust/compile/issue-4859.rs diff --git a/gcc/rust/typecheck/rust-hir-dot-operator.cc b/gcc/rust/typecheck/rust-hir-dot-operator.cc index 8fd7f1d0093d..06d9aa88ecb5 100644 --- a/gcc/rust/typecheck/rust-hir-dot-operator.cc +++ b/gcc/rust/typecheck/rust-hir-dot-operator.cc @@ -482,6 +482,11 @@ MethodResolver::select (TyTy::BaseType &receiver) if (try_select_predicate_candidates (receiver)) return true; + // A receiver that is still a bare unresolved generic type parameter can only + // ever satisfy a method through its own trait bounds + if (receiver.destructure ()->get_kind () == TyTy::TypeKind::PARAM) + return false; + // Assemble candidates std::vector inherent_impl_fns; if (specified_trait == nullptr) diff --git a/gcc/testsuite/rust/compile/issue-4859.rs b/gcc/testsuite/rust/compile/issue-4859.rs new file mode 100644 index 000000000000..0be1db8e915a --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4859.rs @@ -0,0 +1,35 @@ +#![feature(no_core, lang_items)] +#![no_core] +#[lang = "sized"] +pub trait Sized {} +#[lang = "deref"] +pub trait Deref { + type Target: ?Sized; + fn deref(&self) -> &Self::Target; +} +pub struct VaList { + pub inner: i32, +} +impl Deref for VaList { + type Target = i32; + fn deref(&self) -> &i32 { + &self.inner + } +} +pub struct Pin

{ + pub pointer: P, +} +impl Pin

{ + pub const unsafe fn new_unchecked(pointer: P) -> Pin

{ + Pin { pointer } + } + pub fn as_ref(&self) -> Pin<&P::Target> { + unsafe { Pin::new_unchecked(&*self.pointer) } + } +} +impl Deref for &T { + type Target = T; + fn deref(&self) -> &T { + *self + } +} From 2f11d2d7503283c1cdf79cd873868e581711e8d0 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Tue, 8 Sep 2026 10:19:17 +0100 Subject: [PATCH 109/584] gccrs: Add missing isize and usize as valid options here Fixes Rust-GCC/gccrs#4858 gcc/rust/ChangeLog: * typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit): add missing checks gcc/testsuite/ChangeLog: * rust/compile/issue-4858.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-type-check-expr.cc | 2 ++ gcc/testsuite/rust/compile/issue-4858.rs | 10 ++++++++++ 2 files changed, 12 insertions(+) create mode 100644 gcc/testsuite/rust/compile/issue-4858.rs diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc index 7f8547f53ee0..a1e4fb5d8f63 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc @@ -612,6 +612,8 @@ TypeCheckExpr::visit (HIR::NegationExpr &expr) = (negated_expr_ty->get_kind () == TyTy::TypeKind::BOOL) || (negated_expr_ty->get_kind () == TyTy::TypeKind::INT) || (negated_expr_ty->get_kind () == TyTy::TypeKind::UINT) + || (negated_expr_ty->get_kind () == TyTy::TypeKind::ISIZE) + || (negated_expr_ty->get_kind () == TyTy::TypeKind::USIZE) || (negated_expr_ty->get_kind () == TyTy::TypeKind::INFER && (((TyTy::InferType *) negated_expr_ty)->get_infer_kind () == TyTy::InferType::INTEGRAL)); diff --git a/gcc/testsuite/rust/compile/issue-4858.rs b/gcc/testsuite/rust/compile/issue-4858.rs new file mode 100644 index 000000000000..aab574287b47 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4858.rs @@ -0,0 +1,10 @@ +#![feature(no_core)] +#![no_core] + +pub fn signed(x: isize) -> isize { + !x +} + +pub fn unsigned(x: usize) -> usize { + !x +} From 17216afdd239f104a71f511de1fb2834c791f6db Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Tue, 8 Sep 2026 10:34:08 +0100 Subject: [PATCH 110/584] gccrs: Track lifetimes per trait item Fixes Rust-GCC/gccrs#4861 gcc/rust/ChangeLog: * typecheck/rust-hir-type-check.cc (TraitItemReference::get_type_from_fn): grab lifetimes gcc/testsuite/ChangeLog: * rust/compile/issue-4861.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-type-check.cc | 11 +++++++++++ gcc/testsuite/rust/compile/issue-4861.rs | 17 +++++++++++++++++ 2 files changed, 28 insertions(+) create mode 100644 gcc/testsuite/rust/compile/issue-4861.rs diff --git a/gcc/rust/typecheck/rust-hir-type-check.cc b/gcc/rust/typecheck/rust-hir-type-check.cc index e0f819ea1760..d111207b7294 100644 --- a/gcc/rust/typecheck/rust-hir-type-check.cc +++ b/gcc/rust/typecheck/rust-hir-type-check.cc @@ -155,6 +155,17 @@ TraitItemReference::get_type_from_fn (/*const*/ HIR::TraitItemFunc &fn) const { auto binder_pin = context->push_clean_lifetime_resolver (); + auto &mappings = Analysis::Mappings::get (); + auto *trait + = mappings.lookup_trait_item_mapping (get_mappings ().get_hirid ()); + rust_assert (trait != nullptr); + for (auto ¶m : trait->get_generic_params ()) + if (param->get_kind () == HIR::GenericParam::GenericKind::LIFETIME) + { + auto &lifetime_param = static_cast (*param); + context->intern_and_insert_lifetime (lifetime_param.get_lifetime ()); + } + std::vector substitutions = inherited_substitutions; diff --git a/gcc/testsuite/rust/compile/issue-4861.rs b/gcc/testsuite/rust/compile/issue-4861.rs new file mode 100644 index 000000000000..513f09f6f2dc --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4861.rs @@ -0,0 +1,17 @@ +#![feature(no_core, lang_items)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +trait Searcher<'a> { + fn haystack(&self) -> &'a str; + fn with_lifetime<'b>(&self, value: &'b str) -> &'a str; + fn borrow(&'a self) -> &'a str; +} + +trait Other<'a, 'b> { + fn first(&self) -> &'a str; + fn second(&self) -> &'b str; + fn method<'c>(&self, value: &'c str) -> &'c str; +} From 35f841b5a84fafb934550d964a258f626d19d013 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Tue, 8 Sep 2026 11:22:27 +0100 Subject: [PATCH 111/584] gccrs: walk the binding generic arguments for unconstrained checks Fixes Rust-GCC/gccrs#4862 Fixes Rust-GCC/gccrs#4863 gcc/rust/ChangeLog: * typecheck/rust-hir-type-check-base.cc: walk type bindings gcc/testsuite/ChangeLog: * rust/compile/issue-4862.rs: New test. * rust/compile/issue-4863.rs: New test. Signed-off-by: Philip Herron --- .../typecheck/rust-hir-type-check-base.cc | 11 +++++++++++ gcc/testsuite/rust/compile/issue-4862.rs | 11 +++++++++++ gcc/testsuite/rust/compile/issue-4863.rs | 19 +++++++++++++++++++ 3 files changed, 41 insertions(+) create mode 100644 gcc/testsuite/rust/compile/issue-4862.rs create mode 100644 gcc/testsuite/rust/compile/issue-4863.rs diff --git a/gcc/rust/typecheck/rust-hir-type-check-base.cc b/gcc/rust/typecheck/rust-hir-type-check-base.cc index b53232a57e52..faa6d5ea98ee 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-base.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-base.cc @@ -197,6 +197,17 @@ TypeCheckBase::check_for_unconstrained ( walk_types_to_constrain (constrained_symbols, constraint_b); walk_type_to_constrain (constrained_symbols, *reference); + for (const auto ¶m : params_to_constrain) + { + auto *ty = param.get_param_ty (); + for (const auto &bound : ty->get_specified_bounds ()) + { + const auto &args = bound.get_substitution_arguments (); + for (const auto &binding : args.get_binding_args ()) + walk_type_to_constrain (constrained_symbols, *binding.second); + } + } + // check for unconstrained bool unconstrained = false; for (auto &sym : symbols_to_constrain) diff --git a/gcc/testsuite/rust/compile/issue-4862.rs b/gcc/testsuite/rust/compile/issue-4862.rs new file mode 100644 index 000000000000..17d9c3ca9775 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4862.rs @@ -0,0 +1,11 @@ +#![feature(no_core, lang_items)] +#![no_core] +#[lang = "sized"] +pub trait Sized {} +trait Iterator { + type Item; +} +pub struct Wrapper(I); +impl> Iterator for Wrapper { + type Item = T; +} diff --git a/gcc/testsuite/rust/compile/issue-4863.rs b/gcc/testsuite/rust/compile/issue-4863.rs new file mode 100644 index 000000000000..2c7592790c43 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4863.rs @@ -0,0 +1,19 @@ +#![feature(no_core, lang_items)] +#![no_core] +#[lang = "sized"] +pub trait Sized {} +#[lang = "fn_once"] +trait FnOnce { + #[lang = "fn_once_output"] + type Output; + extern "rust-call" fn call_once(self, args: Args) -> Self::Output; +} +trait Iterator { + type Item; +} +pub struct OnceWith { + pub f: F, +} +impl A> Iterator for OnceWith { + type Item = A; +} From 491fddc08dddf2d1ab28ff17799ad83dd280ffc0 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Tue, 8 Sep 2026 11:57:15 +0100 Subject: [PATCH 112/584] gccrs: filter out candidates by checking if self is compatable We have PartialOrd for &i8 and a reference &&A so we need to filter out the double reference one early on. Fixes Rust-GCC/gccrs#4866 gcc/rust/ChangeLog: * typecheck/rust-hir-type-check-expr.cc: check candidate self gcc/testsuite/ChangeLog: * rust/execute/torture/issue-4866.rs: New test. Signed-off-by: Philip Herron --- .../typecheck/rust-hir-type-check-expr.cc | 6 ++++ .../rust/execute/torture/issue-4866.rs | 33 +++++++++++++++++++ 2 files changed, 39 insertions(+) create mode 100644 gcc/testsuite/rust/execute/torture/issue-4866.rs diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc index a1e4fb5d8f63..c4cca34ca697 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc @@ -2070,6 +2070,12 @@ TypeCheckExpr::resolve_operator_overload ( const TyTy::FnType &fn = *static_cast (candidate_type); + if (probe_lhs != nullptr + && !types_compatable (TyTy::TyWithLocation (fn.get_self_type ()), + TyTy::TyWithLocation (probe_lhs), + UNDEF_LOCATION, false /* emit_errors */)) + continue; + DefId current_fn_defid = current_context.get_defid (); bool recursive_candidated = fn.get_id () == current_fn_defid; if (!recursive_candidated) diff --git a/gcc/testsuite/rust/execute/torture/issue-4866.rs b/gcc/testsuite/rust/execute/torture/issue-4866.rs new file mode 100644 index 000000000000..2935febd6da7 --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/issue-4866.rs @@ -0,0 +1,33 @@ +#![feature(no_core, lang_items)] +#![no_core] +#[lang = "sized"] +pub trait Sized {} +#[lang = "partial_ord"] +trait PartialOrd { + fn lt(&self, rhs: &Rhs) -> bool; +} +impl PartialOrd for i8 { + fn lt(&self, other: &i8) -> bool { + *self < *other + } +} +impl PartialOrd<&B> for &A +where + A: PartialOrd, +{ + fn lt(&self, other: &&B) -> bool { + PartialOrd::lt(*self, *other) + } +} + +fn main() -> i32 { + let a = 1i8; + let b = 2i8; + if !(a < b) || b < a { + return 1; + } + if !(&a < &b) || &b < &a { + return 2; + } + 0 +} From de23057dd6e82889d69c7cdeaee3073fa78a9078 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Tue, 8 Sep 2026 12:26:51 +0100 Subject: [PATCH 113/584] gccrs: Fix handling where clauses into two passes Where constraints are annoying so we need to do it in two passes. 1. Register bounds on the regular single segment TypePaths so like P: Deref 2. Then register regular type bindings like I::Item or Item = U::Item As they can be order dependant as the initial predicate needs added to then param decls then onto whatever projections after. Fixes Rust-GCC/gccrs#4864 gcc/rust/ChangeLog: * hir/tree/rust-hir-item.h: missing non const helper. * typecheck/rust-hir-type-check-base.h: new defer_bindings. * typecheck/rust-hir-type-check-implitem.cc (TypeCheckTopLevelExternItem::visit): new helper (TypeCheckImplItem::resolve_function_signature): Likewise. (TypeCheckImplItem::visit): Likewise. * typecheck/rust-hir-type-check-item.cc (TypeCheckItem::visit): Likewise. (TypeCheckItem::resolve_function_signature): Likewise. (TypeCheckItem::resolve_impl_block_substitutions): Likewise. * typecheck/rust-hir-type-check-type.cc (ResolveWhereClauseItem::Resolve): new helper (ResolveWhereClauseItem::visit): support defer. * typecheck/rust-hir-type-check-type.h: update header. * typecheck/rust-hir-type-check.cc (TraitItemReference::get_type_from_fn): call new helper * typecheck/rust-tyty-bounds.cc: defer flag gcc/testsuite/ChangeLog: * rust/compile/issue-4864.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/hir/tree/rust-hir-item.h | 2 + gcc/rust/typecheck/rust-hir-type-check-base.h | 3 +- .../typecheck/rust-hir-type-check-implitem.cc | 24 ++--- .../typecheck/rust-hir-type-check-item.cc | 36 +++----- .../typecheck/rust-hir-type-check-type.cc | 89 ++++++++++++++++++- gcc/rust/typecheck/rust-hir-type-check-type.h | 8 +- gcc/rust/typecheck/rust-hir-type-check.cc | 10 +-- gcc/rust/typecheck/rust-tyty-bounds.cc | 13 ++- gcc/testsuite/rust/compile/issue-4864.rs | 22 +++++ 9 files changed, 150 insertions(+), 57 deletions(-) create mode 100644 gcc/testsuite/rust/compile/issue-4864.rs diff --git a/gcc/rust/hir/tree/rust-hir-item.h b/gcc/rust/hir/tree/rust-hir-item.h index a956e0b530f4..9a572bf92c65 100644 --- a/gcc/rust/hir/tree/rust-hir-item.h +++ b/gcc/rust/hir/tree/rust-hir-item.h @@ -2559,6 +2559,8 @@ class ExternalFunctionItem : public ExternalItem return where_clause; } + WARN_UNUSED_RESULT WhereClause &get_where_clause () { return where_clause; } + ExternalFunctionItem ( Analysis::NodeMapping mappings, Identifier item_name, std::vector> generic_params, diff --git a/gcc/rust/typecheck/rust-hir-type-check-base.h b/gcc/rust/typecheck/rust-hir-type-check-base.h index 3a9df89a5826..61e545149cf4 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-base.h +++ b/gcc/rust/typecheck/rust-hir-type-check-base.h @@ -53,7 +53,8 @@ class TypeCheckBase HIR::TypePath &path, tl::optional> associated_self, BoundPolarity polarity = BoundPolarity::RegularBound, - bool is_qualified_type = false, bool is_super_trait = false); + bool is_qualified_type = false, bool is_super_trait = false, + bool defer_bindings = false); bool check_for_unconstrained ( const std::vector ¶ms_to_constrain, diff --git a/gcc/rust/typecheck/rust-hir-type-check-implitem.cc b/gcc/rust/typecheck/rust-hir-type-check-implitem.cc index 9fb0d70a3401..8c65390f781c 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-implitem.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-implitem.cc @@ -80,14 +80,8 @@ TypeCheckTopLevelExternItem::visit (HIR::ExternalFunctionItem &function) } TyTy::RegionConstraints region_constraints; - if (function.has_where_clause ()) - { - for (auto &where_clause_item : function.get_where_clause ().get_items ()) - { - ResolveWhereClauseItem::Resolve (*where_clause_item, - region_constraints); - } - } + ResolveWhereClauseItem::Resolve (function.get_where_clause (), + region_constraints); TyTy::BaseType *ret_type = nullptr; if (!function.has_return_type ()) @@ -254,11 +248,8 @@ TypeCheckImplItem::resolve_function_signature (HIR::Function &function) function.get_generic_params (), substitutions); TyTy::RegionConstraints region_constraints; - for (auto &where_clause_item : function.get_where_clause ().get_items ()) - { - ResolveWhereClauseItem::Resolve (*where_clause_item.get (), - region_constraints); - } + ResolveWhereClauseItem::Resolve (function.get_where_clause (), + region_constraints); TyTy::BaseType *ret_type = nullptr; if (!function.has_function_return_type ()) @@ -510,11 +501,8 @@ TypeCheckImplItem::visit (HIR::TypeAlias &alias) context->insert_type (alias.get_mappings (), actual_type); result = actual_type; TyTy::RegionConstraints region_constraints; - for (auto &where_clause_item : alias.get_where_clause ().get_items ()) - { - ResolveWhereClauseItem::Resolve (*where_clause_item.get (), - region_constraints); - } + ResolveWhereClauseItem::Resolve (alias.get_where_clause (), + region_constraints); } TypeCheckImplItemWithTrait::TypeCheckImplItemWithTrait ( diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.cc b/gcc/rust/typecheck/rust-hir-type-check-item.cc index 2f2005b71bf7..4d02e3b5c52d 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-item.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-item.cc @@ -310,10 +310,8 @@ TypeCheckItem::visit (HIR::TypeAlias &alias) context->insert_type (alias.get_mappings (), actual_type); TyTy::RegionConstraints region_constraints; - for (auto &where_clause_item : alias.get_where_clause ().get_items ()) - { - ResolveWhereClauseItem::Resolve (*where_clause_item, region_constraints); - } + ResolveWhereClauseItem::Resolve (alias.get_where_clause (), + region_constraints); infered = actual_type; } @@ -329,10 +327,8 @@ TypeCheckItem::visit (HIR::TupleStruct &struct_decl) struct_decl.get_generic_params (), substitutions); TyTy::RegionConstraints region_constraints; - for (auto &where_clause_item : struct_decl.get_where_clause ().get_items ()) - { - ResolveWhereClauseItem::Resolve (*where_clause_item, region_constraints); - } + ResolveWhereClauseItem::Resolve (struct_decl.get_where_clause (), + region_constraints); // Process #[repr(X)] attribute, if any const AST::AttrVec &attrs = struct_decl.get_outer_attrs (); @@ -410,10 +406,8 @@ TypeCheckItem::visit (HIR::StructStruct &struct_decl) struct_decl.get_generic_params (), substitutions); TyTy::RegionConstraints region_constraints; - for (auto &where_clause_item : struct_decl.get_where_clause ().get_items ()) - { - ResolveWhereClauseItem::Resolve (*where_clause_item, region_constraints); - } + ResolveWhereClauseItem::Resolve (struct_decl.get_where_clause (), + region_constraints); // Process #[repr(X)] attribute, if any const AST::AttrVec &attrs = struct_decl.get_outer_attrs (); @@ -577,10 +571,8 @@ TypeCheckItem::visit (HIR::Union &union_decl) union_decl.get_generic_params (), substitutions); TyTy::RegionConstraints region_constraints; - for (auto &where_clause_item : union_decl.get_where_clause ().get_items ()) - { - ResolveWhereClauseItem::Resolve (*where_clause_item, region_constraints); - } + ResolveWhereClauseItem::Resolve (union_decl.get_where_clause (), + region_constraints); std::vector fields; for (auto &variant : union_decl.get_variants ()) @@ -833,10 +825,8 @@ TypeCheckItem::resolve_function_signature (HIR::Function &function) function.get_generic_params (), substitutions); TyTy::RegionConstraints region_constraints; - for (auto &where_clause_item : function.get_where_clause ().get_items ()) - { - ResolveWhereClauseItem::Resolve (*where_clause_item, region_constraints); - } + ResolveWhereClauseItem::Resolve (function.get_where_clause (), + region_constraints); TyTy::BaseType *ret_type = nullptr; if (!function.has_function_return_type ()) @@ -1053,10 +1043,8 @@ TypeCheckItem::resolve_impl_block_substitutions (HIR::ImplBlock &impl_block, impl_block.get_generic_params (), substitutions); TyTy::RegionConstraints region_constraints; - for (auto &where_clause_item : impl_block.get_where_clause ().get_items ()) - { - ResolveWhereClauseItem::Resolve (*where_clause_item, region_constraints); - } + ResolveWhereClauseItem::Resolve (impl_block.get_where_clause (), + region_constraints); auto specified_bound = TyTy::TypeBoundPredicate::error (); TraitReference *trait_reference = &TraitReference::error_node (); diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.cc b/gcc/rust/typecheck/rust-hir-type-check-type.cc index 84baab6ffa76..5fe75cf487b8 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-type.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-type.cc @@ -1023,6 +1023,64 @@ ResolveWhereClauseItem::Resolve (HIR::WhereClauseItem &item, } } +void +ResolveWhereClauseItem::Resolve (HIR::WhereClause &clause, + TyTy::RegionConstraints ®ion_constraints) +{ + ResolveWhereClauseItem resolver (region_constraints); + + class PlainTypePath : public HIR::HIRTypeVisitor + { + public: + bool matches = false; + + void visit (HIR::TypePathSegmentFunction &segment) override {} + void visit (HIR::QualifiedPathInType &path) override {} + void visit (HIR::TraitBound &bound) override {} + void visit (HIR::ImplTraitType &type) override {} + void visit (HIR::TraitObjectType &type) override {} + void visit (HIR::ParenthesisedType &type) override {} + void visit (HIR::TupleType &type) override {} + void visit (HIR::NeverType &type) override {} + void visit (HIR::RawPointerType &type) override {} + void visit (HIR::ReferenceType &type) override {} + void visit (HIR::ArrayType &type) override {} + void visit (HIR::SliceType &type) override {} + void visit (HIR::InferredType &type) override {} + void visit (HIR::BareFunctionType &type) override {} + + void visit (HIR::TypePath &path) override + { + bool is_single = path.get_segments ().size () == 1; + bool final_seg_is_reg + = path.get_final_segment ().get_type () == HIR::TypePathSegment::REG; + + matches = is_single && final_seg_is_reg; + } + }; + + resolver.defer_bindings = true; + for (auto &item : clause.get_items ()) + if (item->get_item_type () == HIR::WhereClauseItem::TYPE_BOUND) + { + auto &bound = static_cast (*item); + PlainTypePath plain; + bound.get_bound_type ().accept_vis (plain); + if (plain.matches) + resolver.visit (bound); + } + + resolver.defer_bindings = false; + resolver.complete_bindings = true; + for (auto &item : clause.get_items ()) + { + if (item->get_item_type () == HIR::WhereClauseItem::TYPE_BOUND) + resolver.visit (static_cast (*item)); + else + Resolve (*item, region_constraints); + } +} + void ResolveWhereClauseItem::visit (HIR::LifetimeWhereClauseItem &item) { @@ -1060,6 +1118,9 @@ ResolveWhereClauseItem::visit (HIR::TypeBoundWhereClauseItem &item) = TypeCheckType::Resolve (binding_type_path, TypeCheckType::ResolutionMode::CANONICAL); + if (defer_bindings && binding->get_kind () != TyTy::TypeKind::PARAM) + return; + // FIXME double check there might be a trait cycle here see TypeParam handling std::vector specified_bounds; @@ -1072,13 +1133,17 @@ ResolveWhereClauseItem::visit (HIR::TypeBoundWhereClauseItem &item) auto *b = static_cast (bound.get ()); TyTy::TypeBoundPredicate predicate - = get_predicate_from_bound (b->get_path (), binding_type_path); + = get_predicate_from_bound (b->get_path (), binding_type_path, + BoundPolarity::RegularBound, false, + false, defer_bindings); if (!predicate.is_error ()) specified_bounds.push_back (std::move (predicate)); } break; case HIR::TypeParamBound::BoundType::LIFETIME: { + if (defer_bindings) + break; if (auto param = binding->try_as ()) { auto *b = static_cast (bound.get ()); @@ -1098,7 +1163,27 @@ ResolveWhereClauseItem::visit (HIR::TypeBoundWhereClauseItem &item) break; } } - binding->inherit_bounds (specified_bounds); + + for (const auto &predicate : specified_bounds) + { + bool replaced = false; + if (complete_bindings) + { + for (auto &bound : binding->get_specified_bounds ()) + { + if (bound.get_id () == predicate.get_id () + && bound.get_locus () == predicate.get_locus ()) + { + bound = predicate; + replaced = true; + break; + } + } + } + + if (!replaced) + binding->inherit_bound (predicate); + } } } // namespace Resolver diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.h b/gcc/rust/typecheck/rust-hir-type-check-type.h index 9cc0fdbc3e97..ee1d0c97d971 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-type.h +++ b/gcc/rust/typecheck/rust-hir-type-check-type.h @@ -132,7 +132,7 @@ class ResolveWhereClauseItem : public TypeCheckBase TyTy::RegionConstraints ®ion_constraints; public: - static void Resolve (HIR::WhereClauseItem &item, + static void Resolve (HIR::WhereClause &clause, TyTy::RegionConstraints ®ion_constraints); protected: @@ -140,6 +140,12 @@ class ResolveWhereClauseItem : public TypeCheckBase void visit (HIR::TypeBoundWhereClauseItem &item); private: + static void Resolve (HIR::WhereClauseItem &item, + TyTy::RegionConstraints ®ion_constraints); + + bool defer_bindings = false; + bool complete_bindings = false; + ResolveWhereClauseItem (TyTy::RegionConstraints ®ion_constraints) : region_constraints (region_constraints) {} diff --git a/gcc/rust/typecheck/rust-hir-type-check.cc b/gcc/rust/typecheck/rust-hir-type-check.cc index d111207b7294..d4c21d09ca84 100644 --- a/gcc/rust/typecheck/rust-hir-type-check.cc +++ b/gcc/rust/typecheck/rust-hir-type-check.cc @@ -169,7 +169,6 @@ TraitItemReference::get_type_from_fn (/*const*/ HIR::TraitItemFunc &fn) const std::vector substitutions = inherited_substitutions; - TyTy::RegionConstraints region_constraints; HIR::TraitFunctionDecl &function = fn.get_decl (); if (function.has_generics ()) { @@ -180,12 +179,9 @@ TraitItemReference::get_type_from_fn (/*const*/ HIR::TraitItemFunc &fn) const ABI::RUST); } - if (function.has_where_clause ()) - { - for (auto &where_clause_item : function.get_where_clause ().get_items ()) - ResolveWhereClauseItem::Resolve (*where_clause_item, - region_constraints); - } + TyTy::RegionConstraints region_constraints; + ResolveWhereClauseItem::Resolve (function.get_where_clause (), + region_constraints); TyTy::BaseType *ret_type = nullptr; if (!function.has_return_type ()) diff --git a/gcc/rust/typecheck/rust-tyty-bounds.cc b/gcc/rust/typecheck/rust-tyty-bounds.cc index 0240a635ca71..bb2c5ed14f15 100644 --- a/gcc/rust/typecheck/rust-tyty-bounds.cc +++ b/gcc/rust/typecheck/rust-tyty-bounds.cc @@ -261,7 +261,8 @@ TyTy::TypeBoundPredicate TypeCheckBase::get_predicate_from_bound ( HIR::TypePath &type_path, tl::optional> associated_self, - BoundPolarity polarity, bool is_qualified_type_path, bool is_super_trait) + BoundPolarity polarity, bool is_qualified_type_path, bool is_super_trait, + bool defer_bindings) { TyTy::TypeBoundPredicate lookup = TyTy::TypeBoundPredicate::error (); bool already_resolved @@ -340,7 +341,7 @@ TypeCheckBase::get_predicate_from_bound ( std::vector bindings; - if (fn.has_return_type ()) + if (fn.has_return_type () && !defer_bindings) { TypeCheckType::Resolve (fn.get_return_type ()); @@ -377,6 +378,9 @@ TypeCheckBase::get_predicate_from_bound ( args.get_locus ()); } + if (defer_bindings) + args.get_binding_args ().clear (); + // we try to apply generic arguments when they are non empty and or when the // predicate requires them so that we get the relevant Foo expects x number // arguments but got zero see test case rust/compile/traits12.rs @@ -387,8 +391,9 @@ TypeCheckBase::get_predicate_from_bound ( is_super_trait); } - context->insert_resolved_predicate (type_path.get_mappings ().get_hirid (), - predicate); + if (!defer_bindings) + context->insert_resolved_predicate (type_path.get_mappings ().get_hirid (), + predicate); return predicate; } diff --git a/gcc/testsuite/rust/compile/issue-4864.rs b/gcc/testsuite/rust/compile/issue-4864.rs new file mode 100644 index 000000000000..c05000a3cadd --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4864.rs @@ -0,0 +1,22 @@ +#![feature(no_core, lang_items)] +#![no_core] +#[lang = "sized"] +pub trait Sized {} +trait Iterator { + type Item; +} +trait IntoIterator { + type Item; + type IntoIter: Iterator; +} +pub struct Flatten { + pub inner: I, + pub extra: U, +} +impl Iterator for Flatten +where + I: Iterator>, + U: Iterator, +{ + type Item = U::Item; +} From 40e543b940e012b43217b6776c166f4970aa75c8 Mon Sep 17 00:00:00 2001 From: Arthur Cohen Date: Wed, 2 Sep 2026 17:47:21 +0200 Subject: [PATCH 114/584] gccrs: codegen: Compile extern types as C void Per Rust's RFC 1861 (https://rust-lang.github.io/rfcs/1861-extern-types.html), extern types are FFI-safe types that are dynamically sized, and should thus compile down to regular empty types like C's void type. They are to always be used with an indirection, which means they are effectively always a regular pointer (not a pointer + metadata like a lot of pointers in Rust) to C's void type. Closes Rust-GCC/gccrs#1922. We eventually need to work on adding checks to external types, but as they are currently implemented as types not implementing `Sized`, a lot of their typechecking behavior is covered. gcc/rust/ChangeLog: * backend/rust-compile-type.cc (TyTyResolveCompile::visit): Change extern type codegen from empty struct to the void type node. --- gcc/rust/backend/rust-compile-type.cc | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/gcc/rust/backend/rust-compile-type.cc b/gcc/rust/backend/rust-compile-type.cc index 56f9e9424342..4b39a44f11cf 100644 --- a/gcc/rust/backend/rust-compile-type.cc +++ b/gcc/rust/backend/rust-compile-type.cc @@ -344,7 +344,10 @@ TyTyResolveCompile::visit (const TyTy::ADTType &type) } else if (type.get_adt_kind () == TyTy::ADTType::ADTKind::EXTERN) { - type_record = Backend::struct_type ({}); + // Extern types are codegen'd as C's void type. They can only be used + // through indirection, so they're effectively always codegen'd as + // `void *` types. + type_record = void_type_node; } else if (!type.is_enum ()) { From d9de08d4cf6e8cb940015656da5a30ccbdb895b5 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Thu, 10 Sep 2026 17:54:44 +0100 Subject: [PATCH 115/584] gccrs: constructors that get borrowed need to be addressable When we have const expr dealing with slices we end up taking a pointer of an array as the data pointer. This is a cosntructor expr ususally but const eval expects these to be addressable objects like tmps holding onto the data but we get away with this in regular compilation because gcc optimizes it. Fixes Rust-GCC/gccrs#4867 Fixes Rust-GCC/gccrs#4868 gcc/rust/ChangeLog: * backend/rust-compile-expr.cc (CompileExpr::visit): make addressable * backend/rust-constexpr.cc (eval_store_expression): port over missing cp/constexpr.cc gcc/testsuite/ChangeLog: * rust/compile/issue-4867.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/backend/rust-compile-expr.cc | 15 +++++++++++++ gcc/rust/backend/rust-constexpr.cc | 9 +++++++- gcc/testsuite/rust/compile/issue-4867.rs | 28 ++++++++++++++++++++++++ 3 files changed, 51 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/rust/compile/issue-4867.rs diff --git a/gcc/rust/backend/rust-compile-expr.cc b/gcc/rust/backend/rust-compile-expr.cc index 3229dea3646d..6480e946b155 100644 --- a/gcc/rust/backend/rust-compile-expr.cc +++ b/gcc/rust/backend/rust-compile-expr.cc @@ -1204,6 +1204,21 @@ CompileExpr::visit (HIR::BorrowExpr &expr) return; } + // const expr needs these to be addressable temps otherwise it cant cope. We + // get away with this during regular compilation because gcc middle end + // optimizes it + if (TREE_CODE (main_expr) == CONSTRUCTOR && !TREE_CONSTANT (main_expr)) + { + tree init_stmt = NULL_TREE; + Bvariable *tmp + = Backend::temporary_variable (ctx->peek_fn ().fndecl, + ctx->peek_enclosing_scope (), + TREE_TYPE (main_expr), main_expr, true, + expr.get_locus (), &init_stmt); + ctx->add_statement (init_stmt); + main_expr = Backend::var_expression (tmp, expr.get_locus ()); + } + TyTy::BaseType *tyty = nullptr; if (!ctx->get_tyctx ()->lookup_type (expr.get_mappings ().get_hirid (), &tyty)) diff --git a/gcc/rust/backend/rust-constexpr.cc b/gcc/rust/backend/rust-constexpr.cc index 22d0ed3bd292..44fd235b925b 100644 --- a/gcc/rust/backend/rust-constexpr.cc +++ b/gcc/rust/backend/rust-constexpr.cc @@ -2763,7 +2763,14 @@ eval_store_expression (const constexpr_ctx *ctx, tree t, bool lval, /* Evaluate the value to be stored without knowing what object it will be stored in, so that any side-effects happen first. */ if (!SCALAR_TYPE_P (type)) - new_ctx.ctor = new_ctx.object = NULL_TREE; + { + new_ctx.ctor = new_ctx.object = NULL_TREE; + if (TREE_CODE (init) == CONSTRUCTOR) + { + new_ctx.ctor = build_constructor (TREE_TYPE (init), NULL); + CONSTRUCTOR_NO_CLEARING (new_ctx.ctor) = true; + } + } init = eval_constant_expression (&new_ctx, init, false, non_constant_p, overflow_p, jump_target); if (*non_constant_p) diff --git a/gcc/testsuite/rust/compile/issue-4867.rs b/gcc/testsuite/rust/compile/issue-4867.rs new file mode 100644 index 000000000000..7e6852347c74 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4867.rs @@ -0,0 +1,28 @@ +// { dg-options "-w" } +#![feature(intrinsics, staged_api)] +#![feature(no_core, lang_items)] +#![no_core] +#[lang = "sized"] +pub trait Sized {} +const X: () = trigger(); +extern "rust-intrinsic" { + #[rustc_const_stable(feature = "const_transmute", since = "1.0.0")] + fn transmute(x: T) -> U; +} +struct Arg { + formatter: fn(&i8), + value: &'static i8, +} +const fn new(x: &'static T, f: fn(&T)) -> Arg { + unsafe { + Arg { + formatter: transmute(f), + value: transmute(x), + } + } +} +const fn consume(x: &[Arg]) {} +const fn trigger() { + consume({ &[new(&1i8, display)] }); +} +fn display(x: &i8) {} From 29bb862bcd7b9276d33d93d9d1e48dca544f9831 Mon Sep 17 00:00:00 2001 From: Owen Avery Date: Thu, 10 Sep 2026 22:19:03 -0400 Subject: [PATCH 116/584] gccrs: Fix HIR::ClosureExpr copying gcc/rust/ChangeLog: * hir/tree/rust-hir-expr.cc (ClosureParam::ClosureParam): Set locus. (ClosureParam::operator=): Likewise. (ClosureExpr::ClosureExpr): Likewise. (ClosureExpr::operator=): Likewise. * typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit (ClosureExpr)): Use Mappings::get_lang_item. gcc/testsuite/ChangeLog: * rust/compile/issue-4740.rs: New test. Signed-off-by: Owen Avery --- gcc/rust/hir/tree/rust-hir-expr.cc | 6 +++++- gcc/rust/typecheck/rust-hir-type-check-expr.cc | 12 ++---------- gcc/testsuite/rust/compile/issue-4740.rs | 10 ++++++++++ 3 files changed, 17 insertions(+), 11 deletions(-) create mode 100644 gcc/testsuite/rust/compile/issue-4740.rs diff --git a/gcc/rust/hir/tree/rust-hir-expr.cc b/gcc/rust/hir/tree/rust-hir-expr.cc index e45178af4156..c4ccad1497bf 100644 --- a/gcc/rust/hir/tree/rust-hir-expr.cc +++ b/gcc/rust/hir/tree/rust-hir-expr.cc @@ -668,7 +668,7 @@ ClosureParam::ClosureParam (std::unique_ptr param_pattern, {} ClosureParam::ClosureParam (ClosureParam const &other) - : pattern (other.pattern->clone_pattern ()) + : pattern (other.pattern->clone_pattern ()), locus (other.locus) { // guard to protect from null pointer dereference if (other.pattern != nullptr) @@ -692,6 +692,8 @@ ClosureParam::operator= (ClosureParam const &other) else type = nullptr; + locus = other.locus; + return *this; } @@ -714,6 +716,7 @@ ClosureExpr::ClosureExpr (ClosureExpr const &other) expr = other.expr->clone_expr (); params = other.params; has_move = other.has_move; + locus = other.locus; } ClosureExpr & @@ -725,6 +728,7 @@ ClosureExpr::operator= (ClosureExpr const &other) expr = other.expr->clone_expr (); params = other.params; has_move = other.has_move; + locus = other.locus; return *this; } diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc index c4cca34ca697..fdc17fe44e25 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc @@ -1978,16 +1978,8 @@ TypeCheckExpr::visit (HIR::ClosureExpr &expr) LangItem::Kind lang_item_type = LangItem::Kind::FN_ONCE; - auto lang_item_defined = mappings.lookup_lang_item (lang_item_type); - if (!lang_item_defined) - { - // FIXME - // we need to have a unified way or error'ing when we are missing lang - // items that is useful - rust_fatal_error (expr.get_locus (), "unable to find lang item: %qs", - LangItem::ToString (lang_item_type).c_str ()); - } - DefId &respective_lang_item_id = lang_item_defined.value (); + DefId respective_lang_item_id + = mappings.get_lang_item (lang_item_type, expr.get_locus ()); // these lang items are always traits HIR::Item *item = mappings.lookup_defid (respective_lang_item_id).value (); diff --git a/gcc/testsuite/rust/compile/issue-4740.rs b/gcc/testsuite/rust/compile/issue-4740.rs new file mode 100644 index 000000000000..3c0969dba8dd --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4740.rs @@ -0,0 +1,10 @@ +#![feature(no_core)] +#![no_core] + +trait A { + fn foo(); +} + +// { dg-error "failed to find lang item" "" { target *-*-* } .+1 } +impl A for [(); (|| 1) ()] {} +// { dg-message "terminated" "" { target *-*-* } 0 } From 3637e78565247d85ca890ef2c2cb2ce815d914ca Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Thu, 10 Sep 2026 21:23:23 +0100 Subject: [PATCH 117/584] gccrs: Only the last segment should resolve to an expr item This doesnt fix that linked issue but its part of the fix thats needed. Addresses Rust-GCC/gccrs#4865 gcc/rust/ChangeLog: * typecheck/rust-hir-type-check-path.cc (TypeCheckExpr::resolve_segments): use probe expr on last seg Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-type-check-path.cc | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/gcc/rust/typecheck/rust-hir-type-check-path.cc b/gcc/rust/typecheck/rust-hir-type-check-path.cc index 2e1731ac1db3..27d7d55e5951 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-path.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-path.cc @@ -26,10 +26,10 @@ #include "rust-rib.h" #include "rust-substitution-mapper.h" #include "rust-hir-path-probe-expr.h" +#include "rust-hir-path-probe-type.h" #include "rust-type-util.h" #include "rust-hir-type-bounds.h" #include "rust-hir-item.h" -#include "rust-session-manager.h" #include "rust-finalized-name-resolution-context.h" namespace Rust { @@ -417,8 +417,19 @@ TypeCheckExpr::resolve_segments (NodeId root_resolved_node_id, for (size_t i = offset; i < segments.size (); i++) { + bool last_seg = i == segments.size () - 1; HIR::PathExprSegment &seg = segments.at (i); - auto candidates = PathProbeExpr::Probe (prev_segment, seg.get_segment ()); + + std::set candidates; + if (last_seg) + candidates = PathProbeExpr::Probe (tyseg, seg.get_segment ()); + else + { + auto type_candidates + = TypePathProbe::Probe (tyseg, seg.get_segment ()); + candidates = type_candidates.type_candidates; + } + if (candidates.size () == 0) { rust_error_at (seg.get_locus (), From 3bbb6932842f1126c9e1ef5fd9e3e4e6188d3dde Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Thu, 10 Sep 2026 21:16:18 +0100 Subject: [PATCH 118/584] gccrs: Refactor query_type to only fully-const resolve const fns When we are in a const context what can happen is we start to query all non const types during method resolution for example which means its going to query fn signitures and fully resolve their blocks for non const candidates. gcc/rust/ChangeLog: * typecheck/rust-type-util.cc (query_type): dont query non const candidates Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-type-util.cc | 48 +++++++++++++++++----------- 1 file changed, 30 insertions(+), 18 deletions(-) diff --git a/gcc/rust/typecheck/rust-type-util.cc b/gcc/rust/typecheck/rust-type-util.cc index 226ea747b029..8f97d60e3a3f 100644 --- a/gcc/rust/typecheck/rust-type-util.cc +++ b/gcc/rust/typecheck/rust-type-util.cc @@ -79,26 +79,28 @@ query_type (HirId reference, TyTy::BaseType **result) bool is_local = item_defid.crateNum == mappings.get_current_crate (); bool is_fn = item.value ()->get_item_kind () == HIR::Item::ItemKind::Function; - if (!context->const_context_p ()) + bool is_const_fn = false; + if (is_fn) { - if (is_fn && is_local) - { - HIR::Function &fn = *static_cast (item.value ()); - *result = TypeCheckItem::ResolveFunctionSignature (fn); - } - else if (item.value ()->get_item_kind () == HIR::Item::ItemKind::Trait - && is_local) - { - HIR::Trait &trait = *static_cast (item.value ()); - *result = TypeCheckItem::ResolveTraitSignature (trait); - } - else - *result = TypeCheckItem::Resolve (*item.value ()); + auto &fn = *static_cast (item.value ()); + is_const_fn = fn.get_qualifiers ().is_const (); } - else + + bool needs_full_resolve_for_const + = is_fn && context->const_context_p () && is_const_fn; + if (is_fn && is_local && !needs_full_resolve_for_const) { - *result = TypeCheckItem::Resolve (*item.value ()); + HIR::Function &fn = *static_cast (item.value ()); + *result = TypeCheckItem::ResolveFunctionSignature (fn); } + else if (item.value ()->get_item_kind () == HIR::Item::ItemKind::Trait + && is_local && !context->const_context_p ()) + { + HIR::Trait &trait = *static_cast (item.value ()); + *result = TypeCheckItem::ResolveTraitSignature (trait); + } + else + *result = TypeCheckItem::Resolve (*item.value ()); context->query_completed (reference); return true; @@ -163,8 +165,18 @@ query_type (HirId reference, TyTy::BaseType **result) DefId item_defid = impl_item->first->get_impl_mappings ().get_defid (); bool is_local = item_defid.crateNum == mappings.get_current_crate (); - if (impl_item->first->get_impl_item_type () == HIR::ImplItem::FUNCTION - && is_local && !context->const_context_p ()) + bool is_fn + = impl_item->first->get_impl_item_type () == HIR::ImplItem::FUNCTION; + bool is_const_fn = false; + if (is_fn) + { + auto &fn = *static_cast (impl_item->first); + is_const_fn = fn.get_qualifiers ().is_const (); + } + + bool needs_full_resolve_for_const + = is_fn && context->const_context_p () && is_const_fn; + if (is_fn && is_local && !needs_full_resolve_for_const) { HIR::Function &fn = *static_cast (impl_item->first); *result = TypeCheckImplItem::ResolveFunctionSignature ( From 18ad6345e6df72ca010952d972dfadef3195a64b Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Thu, 10 Sep 2026 21:02:28 +0100 Subject: [PATCH 119/584] gccrs: Fix bad derive of Ord to use Self instead of raw type-name The raw type name doesnt capture the generic state of the impl but Self does. Fixes Rust-GCC/gccrs#4879 gcc/rust/ChangeLog: * expand/rust-derive-ord.cc (DeriveOrd::cmp_fn): use Self gcc/testsuite/ChangeLog: * rust/compile/issue-4879.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/expand/rust-derive-ord.cc | 13 +++-- gcc/testsuite/rust/compile/issue-4879.rs | 65 ++++++++++++++++++++++++ 2 files changed, 73 insertions(+), 5 deletions(-) create mode 100644 gcc/testsuite/rust/compile/issue-4879.rs diff --git a/gcc/rust/expand/rust-derive-ord.cc b/gcc/rust/expand/rust-derive-ord.cc index aae7f8414814..7960d2978dab 100644 --- a/gcc/rust/expand/rust-derive-ord.cc +++ b/gcc/rust/expand/rust-derive-ord.cc @@ -100,11 +100,14 @@ DeriveOrd::cmp_fn (std::unique_ptr &&block, Identifier type_name) } // &self, other: &Self - auto params = vec ( - builder.self_ref_param (), - builder.function_param (builder.identifier_pattern ("other"), - builder.reference_type (ptrify ( - builder.type_path (type_name.as_string ()))))); + // + // this must be Self for a generic type Wrapping the bare struct name has + // no type arguments + auto params + = vec (builder.self_ref_param (), + builder.function_param (builder.identifier_pattern ("other"), + builder.reference_type ( + ptrify (builder.type_path ("Self"))))); auto function_name = fn (ordering); diff --git a/gcc/testsuite/rust/compile/issue-4879.rs b/gcc/testsuite/rust/compile/issue-4879.rs new file mode 100644 index 000000000000..e2e8ac1078bc --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-4879.rs @@ -0,0 +1,65 @@ +#![feature(no_core, lang_items)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +#[lang = "structural_peq"] +pub trait StructuralPartialEq {} + +#[lang = "structural_teq"] +pub trait StructuralEq {} + +#[lang = "phantom_data"] +pub struct PhantomData; + +pub mod option { + pub enum Option { + #[lang = "None"] + None, + #[lang = "Some"] + Some(T), + } +} + +pub use option::Option; + +pub mod cmp { + use crate::Sized; + + #[lang = "eq"] + pub trait PartialEq { + fn eq(&self, other: &Rhs) -> bool; + fn ne(&self, other: &Rhs) -> bool { + !self.eq(other) + } + } + + pub trait Eq: PartialEq { + fn assert_receiver_is_total_eq(&self) {} + } + + pub enum Ordering { + Less = -1, + Equal = 0, + Greater = 1, + } + + #[lang = "partial_ord"] + pub trait PartialOrd: PartialEq { + fn partial_cmp(&self, other: &Rhs) -> crate::Option; + } + + pub trait Ord: Eq + PartialOrd { + fn cmp(&self, other: &Self) -> Ordering; + } +} + +use cmp::{Eq, Ord, PartialEq, PartialOrd}; + +#[derive(PartialEq, PartialOrd, Eq, Ord)] +pub struct Wrapping(pub T); + +fn main() -> i32 { + 0 +} From abb45626e1a3dfe8d9fb67e280e5136f626b7c98 Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Fri, 11 Sep 2026 14:08:58 +0200 Subject: [PATCH 120/584] gccrs: Move issue related tests to their own directory gcc/testsuite/ChangeLog: * rust/compile/issue-1005.rs: Move to... * rust/compile/issues/1005.rs: ...here. * rust/compile/issue-1006.rs: Move to... * rust/compile/issues/1006.rs: ...here. * rust/compile/issue-1019.rs: Move to... * rust/compile/issues/1019.rs: ...here. * rust/compile/issue-1023.rs: Move to... * rust/compile/issues/1023.rs: ...here. * rust/compile/issue-1031.rs: Move to... * rust/compile/issues/1031.rs: ...here. * rust/compile/issue-1034.rs: Move to... * rust/compile/issues/1034.rs: ...here. * rust/compile/issue-1048.rs: Move to... * rust/compile/issues/1048.rs: ...here. * rust/compile/issue-1073.rs: Move to... * rust/compile/issues/1073.rs: ...here. * rust/compile/issue-1081.rs: Move to... * rust/compile/issues/1081.rs: ...here. * rust/compile/issue-1089.rs: Move to... * rust/compile/issues/1089.rs: ...here. * rust/compile/issue-1089/test_mod.rs: Move to... * rust/compile/issues/1089/test_mod.rs: ...here. * rust/compile/issue-1128.rs: Move to... * rust/compile/issues/1128.rs: ...here. * rust/compile/issue-1129-1.rs: Move to... * rust/compile/issues/1129-1.rs: ...here. * rust/compile/issue-1129-2.rs: Move to... * rust/compile/issues/1129-2.rs: ...here. * rust/compile/issue-1130.rs: Move to... * rust/compile/issues/1130.rs: ...here. * rust/compile/issue-1131.rs: Move to... * rust/compile/issues/1131.rs: ...here. * rust/compile/issue-1152.rs: Move to... * rust/compile/issues/1152.rs: ...here. * rust/compile/issue-1165.rs: Move to... * rust/compile/issues/1165.rs: ...here. * rust/compile/issue-1173.rs: Move to... * rust/compile/issues/1173.rs: ...here. * rust/compile/issue-1210.rs: Move to... * rust/compile/issues/1210.rs: ...here. * rust/compile/issue-1226.rs: Move to... * rust/compile/issues/1226.rs: ...here. * rust/compile/issue-1234.rs: Move to... * rust/compile/issues/1234.rs: ...here. * rust/compile/issue-1235.rs: Move to... * rust/compile/issues/1235.rs: ...here. * rust/compile/issue-1237.rs: Move to... * rust/compile/issues/1237.rs: ...here. * rust/compile/issue-1251.rs: Move to... * rust/compile/issues/1251.rs: ...here. * rust/compile/issue-1271.rs: Move to... * rust/compile/issues/1271.rs: ...here. * rust/compile/issue-1272.rs: Move to... * rust/compile/issues/1272.rs: ...here. * rust/compile/issue-1289.rs: Move to... * rust/compile/issues/1289.rs: ...here. * rust/compile/issue-1323-1.rs: Move to... * rust/compile/issues/1323-1.rs: ...here. * rust/compile/issue-1323-2.rs: Move to... * rust/compile/issues/1323-2.rs: ...here. * rust/compile/issue-1361.rs: Move to... * rust/compile/issues/1361.rs: ...here. * rust/compile/issue-1383.rs: Move to... * rust/compile/issues/1383.rs: ...here. * rust/compile/issue-1393.rs: Move to... * rust/compile/issues/1393.rs: ...here. * rust/compile/issue-1422.rs: Move to... * rust/compile/issues/1422.rs: ...here. * rust/compile/issue-1446.rs: Move to... * rust/compile/issues/1446.rs: ...here. * rust/compile/issue-1447.rs: Move to... * rust/compile/issues/1447.rs: ...here. * rust/compile/issue-1483.rs: Move to... * rust/compile/issues/1483.rs: ...here. * rust/compile/issue-1485.rs: Move to... * rust/compile/issues/1485.rs: ...here. * rust/compile/issue-1487.rs: Move to... * rust/compile/issues/1487.rs: ...here. * rust/compile/issue-1524.rs: Move to... * rust/compile/issues/1524.rs: ...here. * rust/compile/issue-1525.rs: Move to... * rust/compile/issues/1525.rs: ...here. * rust/compile/issue-1553.rs: Move to... * rust/compile/issues/1553.rs: ...here. * rust/compile/issue-1589.rs: Move to... * rust/compile/issues/1589.rs: ...here. * rust/compile/issue-1725-1.rs: Move to... * rust/compile/issues/1725-1.rs: ...here. * rust/compile/issue-1725-2.rs: Move to... * rust/compile/issues/1725-2.rs: ...here. * rust/compile/issue-1726-1.rs: Move to... * rust/compile/issues/1726-1.rs: ...here. * rust/compile/issue-1726-2.rs: Move to... * rust/compile/issues/1726-2.rs: ...here. * rust/compile/issue-1773.rs: Move to... * rust/compile/issues/1773.rs: ...here. * rust/compile/issue-1786.rs: Move to... * rust/compile/issues/1786.rs: ...here. * rust/compile/issue-1807.rs: Move to... * rust/compile/issues/1807.rs: ...here. * rust/compile/issue-1813.rs: Move to... * rust/compile/issues/1813.rs: ...here. * rust/compile/issue-1830_bytes.rs: Move to... * rust/compile/issues/1830_bytes.rs: ...here. * rust/compile/issue-1830_str.rs: Move to... * rust/compile/issues/1830_str.rs: ...here. * rust/compile/issue-1893.rs: Move to... * rust/compile/issues/1893.rs: ...here. * rust/compile/issue-1901.rs: Move to... * rust/compile/issues/1901.rs: ...here. * rust/compile/issue-1930.rs: Move to... * rust/compile/issues/1930.rs: ...here. * rust/compile/issue-1981.rs: Move to... * rust/compile/issues/1981.rs: ...here. * rust/compile/issue-2015.rs: Move to... * rust/compile/issues/2015.rs: ...here. * rust/compile/issue-2019-1.rs: Move to... * rust/compile/issues/2019-1.rs: ...here. * rust/compile/issue-2019-2.rs: Move to... * rust/compile/issues/2019-2.rs: ...here. * rust/compile/issue-2019-3.rs: Move to... * rust/compile/issues/2019-3.rs: ...here. * rust/compile/issue-2029.rs: Move to... * rust/compile/issues/2029.rs: ...here. * rust/compile/issue-2035.rs: Move to... * rust/compile/issues/2035.rs: ...here. * rust/compile/issue-2036.rs: Move to... * rust/compile/issues/2036.rs: ...here. * rust/compile/issue-2037.rs: Move to... * rust/compile/issues/2037.rs: ...here. * rust/compile/issue-2039.rs: Move to... * rust/compile/issues/2039.rs: ...here. * rust/compile/issue-2040.rs: Move to... * rust/compile/issues/2040.rs: ...here. * rust/compile/issue-2042.rs: Move to... * rust/compile/issues/2042.rs: ...here. * rust/compile/issue-2043.rs: Move to... * rust/compile/issues/2043.rs: ...here. * rust/compile/issue-2070.rs: Move to... * rust/compile/issues/2070.rs: ...here. * rust/compile/issue-2105.rs: Move to... * rust/compile/issues/2105.rs: ...here. * rust/compile/issue-2106.rs: Move to... * rust/compile/issues/2106.rs: ...here. * rust/compile/issue-2125.rs: Move to... * rust/compile/issues/2125.rs: ...here. * rust/compile/issue-2135.rs: Move to... * rust/compile/issues/2135.rs: ...here. * rust/compile/issue-2136-1.rs: Move to... * rust/compile/issues/2136-1.rs: ...here. * rust/compile/issue-2136-2.rs: Move to... * rust/compile/issues/2136-2.rs: ...here. * rust/compile/issue-2139.rs: Move to... * rust/compile/issues/2139.rs: ...here. * rust/compile/issue-2142.rs: Move to... * rust/compile/issues/2142.rs: ...here. * rust/compile/issue-2165.rs: Move to... * rust/compile/issues/2165.rs: ...here. * rust/compile/issue-2166.rs: Move to... * rust/compile/issues/2166.rs: ...here. * rust/compile/issue-2178.rs: Move to... * rust/compile/issues/2178.rs: ...here. * rust/compile/issue-2187.rs: Move to... * rust/compile/issues/2187.rs: ...here. * rust/compile/issue-2188.rs: Move to... * rust/compile/issues/2188.rs: ...here. * rust/compile/issue-2189.rs: Move to... * rust/compile/issues/2189.rs: ...here. * rust/compile/issue-2190-1.rs: Move to... * rust/compile/issues/2190-1.rs: ...here. * rust/compile/issue-2190-2.rs: Move to... * rust/compile/issues/2190-2.rs: ...here. * rust/compile/issue-2195.rs: Move to... * rust/compile/issues/2195.rs: ...here. * rust/compile/issue-2203.rs: Move to... * rust/compile/issues/2203.rs: ...here. * rust/compile/issue-2207.rs: Move to... * rust/compile/issues/2207.rs: ...here. * rust/compile/issue-2225.rs: Move to... * rust/compile/issues/2225.rs: ...here. * rust/compile/issue-2238.rs: Move to... * rust/compile/issues/2238.rs: ...here. * rust/compile/issue-2304.rs: Move to... * rust/compile/issues/2304.rs: ...here. * rust/compile/issue-2323.rs: Move to... * rust/compile/issues/2323.rs: ...here. * rust/compile/issue-2324-1.rs: Move to... * rust/compile/issues/2324-1.rs: ...here. * rust/compile/issue-2324-2.rs: Move to... * rust/compile/issues/2324-2.rs: ...here. * rust/compile/issue-2330.rs: Move to... * rust/compile/issues/2330.rs: ...here. * rust/compile/issue-2369.rs: Move to... * rust/compile/issues/2369.rs: ...here. * rust/compile/issue-2375.rs: Move to... * rust/compile/issues/2375.rs: ...here. * rust/compile/issue-2391.rs: Move to... * rust/compile/issues/2391.rs: ...here. * rust/compile/issue-2394.rs: Move to... * rust/compile/issues/2394.rs: ...here. * rust/compile/issue-2421_str.rs: Move to... * rust/compile/issues/2421_str.rs: ...here. * rust/compile/issue-2423.rs: Move to... * rust/compile/issues/2423.rs: ...here. * rust/compile/issue-2431.rs: Move to... * rust/compile/issues/2431.rs: ...here. * rust/compile/issue-2477.rs: Move to... * rust/compile/issues/2477.rs: ...here. * rust/compile/issue-2478.rs: Move to... * rust/compile/issues/2478.rs: ...here. * rust/compile/issue-2479.rs: Move to... * rust/compile/issues/2479.rs: ...here. * rust/compile/issue-2499.rs: Move to... * rust/compile/issues/2499.rs: ...here. * rust/compile/issue-2514.rs: Move to... * rust/compile/issues/2514.rs: ...here. * rust/compile/issue-2567-1.rs: Move to... * rust/compile/issues/2567-1.rs: ...here. * rust/compile/issue-2567-2.rs: Move to... * rust/compile/issues/2567-2.rs: ...here. * rust/compile/issue-2567-3.rs: Move to... * rust/compile/issues/2567-3.rs: ...here. * rust/compile/issue-2645.rs: Move to... * rust/compile/issues/2645.rs: ...here. * rust/compile/issue-2650-1.rs: Move to... * rust/compile/issues/2650-1.rs: ...here. * rust/compile/issue-2650-2.rs: Move to... * rust/compile/issues/2650-2.rs: ...here. * rust/compile/issue-266.rs: Move to... * rust/compile/issues/266.rs: ...here. * rust/compile/issue-2665.rs: Move to... * rust/compile/issues/2665.rs: ...here. * rust/compile/issue-2680.rs: Move to... * rust/compile/issues/2680.rs: ...here. * rust/compile/issue-2709.rs: Move to... * rust/compile/issues/2709.rs: ...here. * rust/compile/issue-2723-1.rs: Move to... * rust/compile/issues/2723-1.rs: ...here. * rust/compile/issue-2723-2.rs: Move to... * rust/compile/issues/2723-2.rs: ...here. * rust/compile/issue-2725.rs: Move to... * rust/compile/issues/2725.rs: ...here. * rust/compile/issue-2747.rs: Move to... * rust/compile/issues/2747.rs: ...here. * rust/compile/issue-2767.rs: Move to... * rust/compile/issues/2767.rs: ...here. * rust/compile/issue-2772-1.rs: Move to... * rust/compile/issues/2772-1.rs: ...here. * rust/compile/issue-2772-2.rs: Move to... * rust/compile/issues/2772-2.rs: ...here. * rust/compile/issue-2775.rs: Move to... * rust/compile/issues/2775.rs: ...here. * rust/compile/issue-2782.rs: Move to... * rust/compile/issues/2782.rs: ...here. * rust/compile/issue-2785.rs: Move to... * rust/compile/issues/2785.rs: ...here. * rust/compile/issue-2788.rs: Move to... * rust/compile/issues/2788.rs: ...here. * rust/compile/issue-2812.rs: Move to... * rust/compile/issues/2812.rs: ...here. * rust/compile/issue-2847-b.rs: Move to... * rust/compile/issues/2847-b.rs: ...here. * rust/compile/issue-2847.rs: Move to... * rust/compile/issues/2847.rs: ...here. * rust/compile/issue-2850.rs: Move to... * rust/compile/issues/2850.rs: ...here. * rust/compile/issue-2905-1.rs: Move to... * rust/compile/issues/2905-1.rs: ...here. * rust/compile/issue-2905-2.rs: Move to... * rust/compile/issues/2905-2.rs: ...here. * rust/compile/issue-2906.rs: Move to... * rust/compile/issues/2906.rs: ...here. * rust/compile/issue-2907.rs: Move to... * rust/compile/issues/2907.rs: ...here. * rust/compile/issue-2951.rs: Move to... * rust/compile/issues/2951.rs: ...here. * rust/compile/issue-2953-1.rs: Move to... * rust/compile/issues/2953-1.rs: ...here. * rust/compile/issue-2953-2.rs: Move to... * rust/compile/issues/2953-2.rs: ...here. * rust/compile/issue-2954.rs: Move to... * rust/compile/issues/2954.rs: ...here. * rust/compile/issue-2987.rs: Move to... * rust/compile/issues/2987.rs: ...here. * rust/compile/issue-3009.rs: Move to... * rust/compile/issues/3009.rs: ...here. * rust/compile/issue-3022.rs: Move to... * rust/compile/issues/3022.rs: ...here. * rust/compile/issue-3030.rs: Move to... * rust/compile/issues/3030.rs: ...here. * rust/compile/issue-3031.rs: Move to... * rust/compile/issues/3031.rs: ...here. * rust/compile/issue-3032-1.rs: Move to... * rust/compile/issues/3032-1.rs: ...here. * rust/compile/issue-3032-2.rs: Move to... * rust/compile/issues/3032-2.rs: ...here. * rust/compile/issue-3033.rs: Move to... * rust/compile/issues/3033.rs: ...here. * rust/compile/issue-3035.rs: Move to... * rust/compile/issues/3035.rs: ...here. * rust/compile/issue-3036.rs: Move to... * rust/compile/issues/3036.rs: ...here. * rust/compile/issue-3045-1.rs: Move to... * rust/compile/issues/3045-1.rs: ...here. * rust/compile/issue-3045-2.rs: Move to... * rust/compile/issues/3045-2.rs: ...here. * rust/compile/issue-3046.rs: Move to... * rust/compile/issues/3046.rs: ...here. * rust/compile/issue-3082.rs: Move to... * rust/compile/issues/3082.rs: ...here. * rust/compile/issue-3139-1.rs: Move to... * rust/compile/issues/3139-1.rs: ...here. * rust/compile/issue-3139-2.rs: Move to... * rust/compile/issues/3139-2.rs: ...here. * rust/compile/issue-3139-3.rs: Move to... * rust/compile/issues/3139-3.rs: ...here. * rust/compile/issue-3140.rs: Move to... * rust/compile/issues/3140.rs: ...here. * rust/compile/issue-3141.rs: Move to... * rust/compile/issues/3141.rs: ...here. * rust/compile/issue-3144.rs: Move to... * rust/compile/issues/3144.rs: ...here. * rust/compile/issue-3174.rs: Move to... * rust/compile/issues/3174.rs: ...here. * rust/compile/issue-3231.rs: Move to... * rust/compile/issues/3231.rs: ...here. * rust/compile/issue-3242.rs: Move to... * rust/compile/issues/3242.rs: ...here. * rust/compile/issue-3261.rs: Move to... * rust/compile/issues/3261.rs: ...here. * rust/compile/issue-3304.rs: Move to... * rust/compile/issues/3304.rs: ...here. * rust/compile/issue-3315-1.rs: Move to... * rust/compile/issues/3315-1.rs: ...here. * rust/compile/issue-3315-2.rs: Move to... * rust/compile/issues/3315-2.rs: ...here. * rust/compile/issue-3350.rs: Move to... * rust/compile/issues/3350.rs: ...here. * rust/compile/issue-3382.rs: Move to... * rust/compile/issues/3382.rs: ...here. * rust/compile/issue-3402-1.rs: Move to... * rust/compile/issues/3402-1.rs: ...here. * rust/compile/issue-3402-2.rs: Move to... * rust/compile/issues/3402-2.rs: ...here. * rust/compile/issue-3403.rs: Move to... * rust/compile/issues/3403.rs: ...here. * rust/compile/issue-3454.rs: Move to... * rust/compile/issues/3454.rs: ...here. * rust/compile/issue-3524.rs: Move to... * rust/compile/issues/3524.rs: ...here. * rust/compile/issue-3525.rs: Move to... * rust/compile/issues/3525.rs: ...here. * rust/compile/issue-3530-1.rs: Move to... * rust/compile/issues/3530-1.rs: ...here. * rust/compile/issue-3530-2.rs: Move to... * rust/compile/issues/3530-2.rs: ...here. * rust/compile/issue-3537.rs: Move to... * rust/compile/issues/3537.rs: ...here. * rust/compile/issue-3538.rs: Move to... * rust/compile/issues/3538.rs: ...here. * rust/compile/issue-3541-1.rs: Move to... * rust/compile/issues/3541-1.rs: ...here. * rust/compile/issue-3541-2.rs: Move to... * rust/compile/issues/3541-2.rs: ...here. * rust/compile/issue-3546.rs: Move to... * rust/compile/issues/3546.rs: ...here. * rust/compile/issue-3549.rs: Move to... * rust/compile/issues/3549.rs: ...here. * rust/compile/issue-3550.rs: Move to... * rust/compile/issues/3550.rs: ...here. * rust/compile/issue-3551.rs: Move to... * rust/compile/issues/3551.rs: ...here. * rust/compile/issue-3552.rs: Move to... * rust/compile/issues/3552.rs: ...here. * rust/compile/issue-3553.rs: Move to... * rust/compile/issues/3553.rs: ...here. * rust/compile/issue-3554-1.rs: Move to... * rust/compile/issues/3554-1.rs: ...here. * rust/compile/issue-3554-2.rs: Move to... * rust/compile/issues/3554-2.rs: ...here. * rust/compile/issue-3555.rs: Move to... * rust/compile/issues/3555.rs: ...here. * rust/compile/issue-3556.rs: Move to... * rust/compile/issues/3556.rs: ...here. * rust/compile/issue-3563.rs: Move to... * rust/compile/issues/3563.rs: ...here. * rust/compile/issue-3566-1.rs: Move to... * rust/compile/issues/3566-1.rs: ...here. * rust/compile/issue-3566-2.rs: Move to... * rust/compile/issues/3566-2.rs: ...here. * rust/compile/issue-3567.rs: Move to... * rust/compile/issues/3567.rs: ...here. * rust/compile/issue-3568.rs: Move to... * rust/compile/issues/3568.rs: ...here. * rust/compile/issue-3581-1.rs: Move to... * rust/compile/issues/3581-1.rs: ...here. * rust/compile/issue-3581-2.rs: Move to... * rust/compile/issues/3581-2.rs: ...here. * rust/compile/issue-3585-1.rs: Move to... * rust/compile/issues/3585-1.rs: ...here. * rust/compile/issue-3585-2.rs: Move to... * rust/compile/issues/3585-2.rs: ...here. * rust/compile/issue-3588.rs: Move to... * rust/compile/issues/3588.rs: ...here. * rust/compile/issue-3591.rs: Move to... * rust/compile/issues/3591.rs: ...here. * rust/compile/issue-3592.rs: Move to... * rust/compile/issues/3592.rs: ...here. * rust/compile/issue-3597.rs: Move to... * rust/compile/issues/3597.rs: ...here. * rust/compile/issue-3599.rs: Move to... * rust/compile/issues/3599.rs: ...here. * rust/compile/issue-3605.rs: Move to... * rust/compile/issues/3605.rs: ...here. * rust/compile/issue-3606.rs: Move to... * rust/compile/issues/3606.rs: ...here. * rust/compile/issue-3612.rs: Move to... * rust/compile/issues/3612.rs: ...here. * rust/compile/issue-3613.rs: Move to... * rust/compile/issues/3613.rs: ...here. * rust/compile/issue-3614.rs: Move to... * rust/compile/issues/3614.rs: ...here. * rust/compile/issue-3615.rs: Move to... * rust/compile/issues/3615.rs: ...here. * rust/compile/issue-3617.rs: Move to... * rust/compile/issues/3617.rs: ...here. * rust/compile/issue-3618.rs: Move to... * rust/compile/issues/3618.rs: ...here. * rust/compile/issue-3625.rs: Move to... * rust/compile/issues/3625.rs: ...here. * rust/compile/issue-3628.rs: Move to... * rust/compile/issues/3628.rs: ...here. * rust/compile/issue-3642.rs: Move to... * rust/compile/issues/3642.rs: ...here. * rust/compile/issue-3643.rs: Move to... * rust/compile/issues/3643.rs: ...here. * rust/compile/issue-3645.rs: Move to... * rust/compile/issues/3645.rs: ...here. * rust/compile/issue-3646.rs: Move to... * rust/compile/issues/3646.rs: ...here. * rust/compile/issue-3647.rs: Move to... * rust/compile/issues/3647.rs: ...here. * rust/compile/issue-3648.rs: Move to... * rust/compile/issues/3648.rs: ...here. * rust/compile/issue-3649.rs: Move to... * rust/compile/issues/3649.rs: ...here. * rust/compile/issue-3651.rs: Move to... * rust/compile/issues/3651.rs: ...here. * rust/compile/issue-3652.rs: Move to... * rust/compile/issues/3652.rs: ...here. * rust/compile/issue-3654.rs: Move to... * rust/compile/issues/3654.rs: ...here. * rust/compile/issue-3656.rs: Move to... * rust/compile/issues/3656.rs: ...here. * rust/compile/issue-3657.rs: Move to... * rust/compile/issues/3657.rs: ...here. * rust/compile/issue-3659.rs: Move to... * rust/compile/issues/3659.rs: ...here. * rust/compile/issue-3660.rs: Move to... * rust/compile/issues/3660.rs: ...here. * rust/compile/issue-3661.rs: Move to... * rust/compile/issues/3661.rs: ...here. * rust/compile/issue-3662.rs: Move to... * rust/compile/issues/3662.rs: ...here. * rust/compile/issue-3663.rs: Move to... * rust/compile/issues/3663.rs: ...here. * rust/compile/issue-3664.rs: Move to... * rust/compile/issues/3664.rs: ...here. * rust/compile/issue-3665.rs: Move to... * rust/compile/issues/3665.rs: ...here. * rust/compile/issue-3667.rs: Move to... * rust/compile/issues/3667.rs: ...here. * rust/compile/issue-3670.rs: Move to... * rust/compile/issues/3670.rs: ...here. * rust/compile/issue-3671.rs: Move to... * rust/compile/issues/3671.rs: ...here. * rust/compile/issue-3672.rs: Move to... * rust/compile/issues/3672.rs: ...here. * rust/compile/issue-3711.rs: Move to... * rust/compile/issues/3711.rs: ...here. * rust/compile/issue-3726.rs: Move to... * rust/compile/issues/3726.rs: ...here. * rust/compile/issue-3836.rs: Move to... * rust/compile/issues/3836.rs: ...here. * rust/compile/issue-3874.rs: Move to... * rust/compile/issues/3874.rs: ...here. * rust/compile/issue-3875.rs: Move to... * rust/compile/issues/3875.rs: ...here. * rust/compile/issue-3876.rs: Move to... * rust/compile/issues/3876.rs: ...here. * rust/compile/issue-3885.rs: Move to... * rust/compile/issues/3885.rs: ...here. * rust/compile/issue-3898.rs: Move to... * rust/compile/issues/3898.rs: ...here. * rust/compile/issue-3904.rs: Move to... * rust/compile/issues/3904.rs: ...here. * rust/compile/issue-3910.rs: Move to... * rust/compile/issues/3910.rs: ...here. * rust/compile/issue-3915.rs: Move to... * rust/compile/issues/3915.rs: ...here. * rust/compile/issue-3916.rs: Move to... * rust/compile/issues/3916.rs: ...here. * rust/compile/issue-3919-ice-func-parms.rs: Move to... * rust/compile/issues/3919-ice-func-parms.rs: ...here. * rust/compile/issue-3922.rs: Move to... * rust/compile/issues/3922.rs: ...here. * rust/compile/issue-3924.rs: Move to... * rust/compile/issues/3924.rs: ...here. * rust/compile/issue-3928.rs: Move to... * rust/compile/issues/3928.rs: ...here. * rust/compile/issue-3929-1.rs: Move to... * rust/compile/issues/3929-1.rs: ...here. * rust/compile/issue-3929-2.rs: Move to... * rust/compile/issues/3929-2.rs: ...here. * rust/compile/issue-3930.rs: Move to... * rust/compile/issues/3930.rs: ...here. * rust/compile/issue-3931.rs: Move to... * rust/compile/issues/3931.rs: ...here. * rust/compile/issue-3947.rs: Move to... * rust/compile/issues/3947.rs: ...here. * rust/compile/issue-3951.rs: Move to... * rust/compile/issues/3951.rs: ...here. * rust/compile/issue-3958.rs: Move to... * rust/compile/issues/3958.rs: ...here. * rust/compile/issue-3960.rs: Move to... * rust/compile/issues/3960.rs: ...here. * rust/compile/issue-3965-1.rs: Move to... * rust/compile/issues/3965-1.rs: ...here. * rust/compile/issue-3965-2.rs: Move to... * rust/compile/issues/3965-2.rs: ...here. * rust/compile/issue-3966.rs: Move to... * rust/compile/issues/3966.rs: ...here. * rust/compile/issue-3969.rs: Move to... * rust/compile/issues/3969.rs: ...here. * rust/compile/issue-3971.rs: Move to... * rust/compile/issues/3971.rs: ...here. * rust/compile/issue-3972.rs: Move to... * rust/compile/issues/3972.rs: ...here. * rust/compile/issue-3974.rs: Move to... * rust/compile/issues/3974.rs: ...here. * rust/compile/issue-3977.rs: Move to... * rust/compile/issues/3977.rs: ...here. * rust/compile/issue-3978.rs: Move to... * rust/compile/issues/3978.rs: ...here. * rust/compile/issue-4006.rs: Move to... * rust/compile/issues/4006.rs: ...here. * rust/compile/issue-402.rs: Move to... * rust/compile/issues/402.rs: ...here. * rust/compile/issue-407-2.rs: Move to... * rust/compile/issues/407-2.rs: ...here. * rust/compile/issue-407.rs: Move to... * rust/compile/issues/407.rs: ...here. * rust/compile/issue-4090-1.rs: Move to... * rust/compile/issues/4090-1.rs: ...here. * rust/compile/issue-4090-2.rs: Move to... * rust/compile/issues/4090-2.rs: ...here. * rust/compile/issue-4116.rs: Move to... * rust/compile/issues/4116.rs: ...here. * rust/compile/issue-4139.rs: Move to... * rust/compile/issues/4139.rs: ...here. * rust/compile/issue-4140-1.rs: Move to... * rust/compile/issues/4140-1.rs: ...here. * rust/compile/issue-4140-2.rs: Move to... * rust/compile/issues/4140-2.rs: ...here. * rust/compile/issue-4145.rs: Move to... * rust/compile/issues/4145.rs: ...here. * rust/compile/issue-4146.rs: Move to... * rust/compile/issues/4146.rs: ...here. * rust/compile/issue-4148.rs: Move to... * rust/compile/issues/4148.rs: ...here. * rust/compile/issue-4155.rs: Move to... * rust/compile/issues/4155.rs: ...here. * rust/compile/issue-4157-1.rs: Move to... * rust/compile/issues/4157-1.rs: ...here. * rust/compile/issue-4157-2.rs: Move to... * rust/compile/issues/4157-2.rs: ...here. * rust/compile/issue-4158.rs: Move to... * rust/compile/issues/4158.rs: ...here. * rust/compile/issue-4159.rs: Move to... * rust/compile/issues/4159.rs: ...here. * rust/compile/issue-4162.rs: Move to... * rust/compile/issues/4162.rs: ...here. * rust/compile/issue-4163-2.rs: Move to... * rust/compile/issues/4163-2.rs: ...here. * rust/compile/issue-4163.rs: Move to... * rust/compile/issues/4163.rs: ...here. * rust/compile/issue-4165.rs: Move to... * rust/compile/issues/4165.rs: ...here. * rust/compile/issue-4166.rs: Move to... * rust/compile/issues/4166.rs: ...here. * rust/compile/issue-4167.rs: Move to... * rust/compile/issues/4167.rs: ...here. * rust/compile/issue-4168.rs: Move to... * rust/compile/issues/4168.rs: ...here. * rust/compile/issue-4173-1.rs: Move to... * rust/compile/issues/4173-1.rs: ...here. * rust/compile/issue-4173-2.rs: Move to... * rust/compile/issues/4173-2.rs: ...here. * rust/compile/issue-4173-3.rs: Move to... * rust/compile/issues/4173-3.rs: ...here. * rust/compile/issue-4188.rs: Move to... * rust/compile/issues/4188.rs: ...here. * rust/compile/issue-4212.rs: Move to... * rust/compile/issues/4212.rs: ...here. * rust/compile/issue-4213.rs: Move to... * rust/compile/issues/4213.rs: ...here. * rust/compile/issue-4219.rs: Move to... * rust/compile/issues/4219.rs: ...here. * rust/compile/issue-4222.rs: Move to... * rust/compile/issues/4222.rs: ...here. * rust/compile/issue-4225.rs: Move to... * rust/compile/issues/4225.rs: ...here. * rust/compile/issue-4226.rs: Move to... * rust/compile/issues/4226.rs: ...here. * rust/compile/issue-4231.rs: Move to... * rust/compile/issues/4231.rs: ...here. * rust/compile/issue-4232.rs: Move to... * rust/compile/issues/4232.rs: ...here. * rust/compile/issue-4234.rs: Move to... * rust/compile/issues/4234.rs: ...here. * rust/compile/issue-4235.rs: Move to... * rust/compile/issues/4235.rs: ...here. * rust/compile/issue-4242.rs: Move to... * rust/compile/issues/4242.rs: ...here. * rust/compile/issue-4245.rs: Move to... * rust/compile/issues/4245.rs: ...here. * rust/compile/issue-4260_0.rs: Move to... * rust/compile/issues/4260_0.rs: ...here. * rust/compile/issue-4261.rs: Move to... * rust/compile/issues/4261.rs: ...here. * rust/compile/issue-4262.rs: Move to... * rust/compile/issues/4262.rs: ...here. * rust/compile/issue-4267.rs: Move to... * rust/compile/issues/4267.rs: ...here. * rust/compile/issue-4293.rs: Move to... * rust/compile/issues/4293.rs: ...here. * rust/compile/issue-4301.rs: Move to... * rust/compile/issues/4301.rs: ...here. * rust/compile/issue-4302.rs: Move to... * rust/compile/issues/4302.rs: ...here. * rust/compile/issue-4375-ice-regression.rs: Move to... * rust/compile/issues/4375-ice-regression.rs: ...here. * rust/compile/issue-4375-multiple-errors.rs: Move to... * rust/compile/issues/4375-multiple-errors.rs: ...here. * rust/compile/issue-4375-tuple-pattern.rs: Move to... * rust/compile/issues/4375-tuple-pattern.rs: ...here. * rust/compile/issue-4387.rs: Move to... * rust/compile/issues/4387.rs: ...here. * rust/compile/issue-4388.rs: Move to... * rust/compile/issues/4388.rs: ...here. * rust/compile/issue-4402.rs: Move to... * rust/compile/issues/4402.rs: ...here. * rust/compile/issue-4410.rs: Move to... * rust/compile/issues/4410.rs: ...here. * rust/compile/issue-4411.rs: Move to... * rust/compile/issues/4411.rs: ...here. * rust/compile/issue-4412.rs: Move to... * rust/compile/issues/4412.rs: ...here. * rust/compile/issue-4413.rs: Move to... * rust/compile/issues/4413.rs: ...here. * rust/compile/issue-4414.rs: Move to... * rust/compile/issues/4414.rs: ...here. * rust/compile/issue-4433.rs: Move to... * rust/compile/issues/4433.rs: ...here. * rust/compile/issue-4471-1.rs: Move to... * rust/compile/issues/4471-1.rs: ...here. * rust/compile/issue-4471-2.rs: Move to... * rust/compile/issues/4471-2.rs: ...here. * rust/compile/issue-4476.rs: Move to... * rust/compile/issues/4476.rs: ...here. * rust/compile/issue-4481.rs: Move to... * rust/compile/issues/4481.rs: ...here. * rust/compile/issue-4486-1.rs: Move to... * rust/compile/issues/4486-1.rs: ...here. * rust/compile/issue-4486-2.rs: Move to... * rust/compile/issues/4486-2.rs: ...here. * rust/compile/issue-4517.rs: Move to... * rust/compile/issues/4517.rs: ...here. * rust/compile/issue-4538.rs: Move to... * rust/compile/issues/4538.rs: ...here. * rust/compile/issue-4563.rs: Move to... * rust/compile/issues/4563.rs: ...here. * rust/compile/issue-4592.rs: Move to... * rust/compile/issues/4592.rs: ...here. * rust/compile/issue-4617.rs: Move to... * rust/compile/issues/4617.rs: ...here. * rust/compile/issue-4631.rs: Move to... * rust/compile/issues/4631.rs: ...here. * rust/compile/issue-4674.rs: Move to... * rust/compile/issues/4674.rs: ...here. * rust/compile/issue-4678.rs: Move to... * rust/compile/issues/4678.rs: ...here. * rust/compile/issue-4689-1.rs: Move to... * rust/compile/issues/4689-1.rs: ...here. * rust/compile/issue-4689-2.rs: Move to... * rust/compile/issues/4689-2.rs: ...here. * rust/compile/issue-4735.rs: Move to... * rust/compile/issues/4735.rs: ...here. * rust/compile/issue-4740.rs: Move to... * rust/compile/issues/4740.rs: ...here. * rust/compile/issue-4747.rs: Move to... * rust/compile/issues/4747.rs: ...here. * rust/compile/issue-4794.rs: Move to... * rust/compile/issues/4794.rs: ...here. * rust/compile/issue-4805.rs: Move to... * rust/compile/issues/4805.rs: ...here. * rust/compile/issue-4812.rs: Move to... * rust/compile/issues/4812.rs: ...here. * rust/compile/issue-4822.rs: Move to... * rust/compile/issues/4822.rs: ...here. * rust/compile/issue-4823.rs: Move to... * rust/compile/issues/4823.rs: ...here. * rust/compile/issue-4828.rs: Move to... * rust/compile/issues/4828.rs: ...here. * rust/compile/issue-4829-1.rs: Move to... * rust/compile/issues/4829-1.rs: ...here. * rust/compile/issue-4829-2.rs: Move to... * rust/compile/issues/4829-2.rs: ...here. * rust/compile/issue-4851.rs: Move to... * rust/compile/issues/4851.rs: ...here. * rust/compile/issue-4853.rs: Move to... * rust/compile/issues/4853.rs: ...here. * rust/compile/issue-4855.rs: Move to... * rust/compile/issues/4855.rs: ...here. * rust/compile/issue-4858.rs: Move to... * rust/compile/issues/4858.rs: ...here. * rust/compile/issue-4859.rs: Move to... * rust/compile/issues/4859.rs: ...here. * rust/compile/issue-4860.rs: Move to... * rust/compile/issues/4860.rs: ...here. * rust/compile/issue-4861.rs: Move to... * rust/compile/issues/4861.rs: ...here. * rust/compile/issue-4862.rs: Move to... * rust/compile/issues/4862.rs: ...here. * rust/compile/issue-4863.rs: Move to... * rust/compile/issues/4863.rs: ...here. * rust/compile/issue-4864.rs: Move to... * rust/compile/issues/4864.rs: ...here. * rust/compile/issue-4867.rs: Move to... * rust/compile/issues/4867.rs: ...here. * rust/compile/issue-4879.rs: Move to... * rust/compile/issues/4879.rs: ...here. * rust/compile/issue-557.rs: Move to... * rust/compile/issues/557.rs: ...here. * rust/compile/issue-635-1.rs: Move to... * rust/compile/issues/635-1.rs: ...here. * rust/compile/issue-635-2.rs: Move to... * rust/compile/issues/635-2.rs: ...here. * rust/compile/issue-850.rs: Move to... * rust/compile/issues/850.rs: ...here. * rust/compile/issue-852.rs: Move to... * rust/compile/issues/852.rs: ...here. * rust/compile/issue-855.rs: Move to... * rust/compile/issues/855.rs: ...here. * rust/compile/issue-867.rs: Move to... * rust/compile/issues/867.rs: ...here. * rust/compile/issue-925.rs: Move to... * rust/compile/issues/925.rs: ...here. * rust/compile/empty_file: Move to... * rust/compile/issues/empty_file: ...here. * rust/compile/issue_4402_foo.rs: Move to... * rust/compile/issues/issue_4402_foo.rs: ...here. * rust/compile/issues/issues.exp: Copy DG execution from parent directory. Signed-off-by: Pierre-Emmanuel Patry --- .../compile/{issue-1005.rs => issues/1005.rs} | 0 .../compile/{issue-1006.rs => issues/1006.rs} | 0 .../compile/{issue-1019.rs => issues/1019.rs} | 0 .../compile/{issue-1023.rs => issues/1023.rs} | 0 .../compile/{issue-1031.rs => issues/1031.rs} | 0 .../compile/{issue-1034.rs => issues/1034.rs} | 0 .../compile/{issue-1048.rs => issues/1048.rs} | 0 .../compile/{issue-1073.rs => issues/1073.rs} | 0 .../compile/{issue-1081.rs => issues/1081.rs} | 0 .../compile/{issue-1089.rs => issues/1089.rs} | 0 .../{issue-1089 => issues/1089}/test_mod.rs | 0 .../compile/{issue-1128.rs => issues/1128.rs} | 0 .../{issue-1129-1.rs => issues/1129-1.rs} | 0 .../{issue-1129-2.rs => issues/1129-2.rs} | 0 .../compile/{issue-1130.rs => issues/1130.rs} | 0 .../compile/{issue-1131.rs => issues/1131.rs} | 0 .../compile/{issue-1152.rs => issues/1152.rs} | 0 .../compile/{issue-1165.rs => issues/1165.rs} | 0 .../compile/{issue-1173.rs => issues/1173.rs} | 0 .../compile/{issue-1210.rs => issues/1210.rs} | 0 .../compile/{issue-1226.rs => issues/1226.rs} | 0 .../compile/{issue-1234.rs => issues/1234.rs} | 0 .../compile/{issue-1235.rs => issues/1235.rs} | 0 .../compile/{issue-1237.rs => issues/1237.rs} | 0 .../compile/{issue-1251.rs => issues/1251.rs} | 0 .../compile/{issue-1271.rs => issues/1271.rs} | 0 .../compile/{issue-1272.rs => issues/1272.rs} | 0 .../compile/{issue-1289.rs => issues/1289.rs} | 0 .../{issue-1323-1.rs => issues/1323-1.rs} | 0 .../{issue-1323-2.rs => issues/1323-2.rs} | 0 .../compile/{issue-1361.rs => issues/1361.rs} | 0 .../compile/{issue-1383.rs => issues/1383.rs} | 0 .../compile/{issue-1393.rs => issues/1393.rs} | 0 .../compile/{issue-1422.rs => issues/1422.rs} | 0 .../compile/{issue-1446.rs => issues/1446.rs} | 0 .../compile/{issue-1447.rs => issues/1447.rs} | 0 .../compile/{issue-1483.rs => issues/1483.rs} | 0 .../compile/{issue-1485.rs => issues/1485.rs} | 0 .../compile/{issue-1487.rs => issues/1487.rs} | 0 .../compile/{issue-1524.rs => issues/1524.rs} | 0 .../compile/{issue-1525.rs => issues/1525.rs} | 0 .../compile/{issue-1553.rs => issues/1553.rs} | 0 .../compile/{issue-1589.rs => issues/1589.rs} | 0 .../{issue-1725-1.rs => issues/1725-1.rs} | 0 .../{issue-1725-2.rs => issues/1725-2.rs} | 0 .../{issue-1726-1.rs => issues/1726-1.rs} | 0 .../{issue-1726-2.rs => issues/1726-2.rs} | 0 .../compile/{issue-1773.rs => issues/1773.rs} | 0 .../compile/{issue-1786.rs => issues/1786.rs} | 0 .../compile/{issue-1807.rs => issues/1807.rs} | 0 .../compile/{issue-1813.rs => issues/1813.rs} | 0 .../1830_bytes.rs} | 0 .../{issue-1830_str.rs => issues/1830_str.rs} | 0 .../compile/{issue-1893.rs => issues/1893.rs} | 0 .../compile/{issue-1901.rs => issues/1901.rs} | 0 .../compile/{issue-1930.rs => issues/1930.rs} | 0 .../compile/{issue-1981.rs => issues/1981.rs} | 0 .../compile/{issue-2015.rs => issues/2015.rs} | 0 .../{issue-2019-1.rs => issues/2019-1.rs} | 0 .../{issue-2019-2.rs => issues/2019-2.rs} | 0 .../{issue-2019-3.rs => issues/2019-3.rs} | 0 .../compile/{issue-2029.rs => issues/2029.rs} | 0 .../compile/{issue-2035.rs => issues/2035.rs} | 0 .../compile/{issue-2036.rs => issues/2036.rs} | 0 .../compile/{issue-2037.rs => issues/2037.rs} | 0 .../compile/{issue-2039.rs => issues/2039.rs} | 0 .../compile/{issue-2040.rs => issues/2040.rs} | 0 .../compile/{issue-2042.rs => issues/2042.rs} | 0 .../compile/{issue-2043.rs => issues/2043.rs} | 0 .../compile/{issue-2070.rs => issues/2070.rs} | 0 .../compile/{issue-2105.rs => issues/2105.rs} | 0 .../compile/{issue-2106.rs => issues/2106.rs} | 0 .../compile/{issue-2125.rs => issues/2125.rs} | 0 .../compile/{issue-2135.rs => issues/2135.rs} | 0 .../{issue-2136-1.rs => issues/2136-1.rs} | 0 .../{issue-2136-2.rs => issues/2136-2.rs} | 0 .../compile/{issue-2139.rs => issues/2139.rs} | 0 .../compile/{issue-2142.rs => issues/2142.rs} | 0 .../compile/{issue-2165.rs => issues/2165.rs} | 0 .../compile/{issue-2166.rs => issues/2166.rs} | 0 .../compile/{issue-2178.rs => issues/2178.rs} | 0 .../compile/{issue-2187.rs => issues/2187.rs} | 0 .../compile/{issue-2188.rs => issues/2188.rs} | 0 .../compile/{issue-2189.rs => issues/2189.rs} | 0 .../{issue-2190-1.rs => issues/2190-1.rs} | 0 .../{issue-2190-2.rs => issues/2190-2.rs} | 0 .../compile/{issue-2195.rs => issues/2195.rs} | 0 .../compile/{issue-2203.rs => issues/2203.rs} | 0 .../compile/{issue-2207.rs => issues/2207.rs} | 0 .../compile/{issue-2225.rs => issues/2225.rs} | 0 .../compile/{issue-2238.rs => issues/2238.rs} | 0 .../compile/{issue-2304.rs => issues/2304.rs} | 0 .../compile/{issue-2323.rs => issues/2323.rs} | 0 .../{issue-2324-1.rs => issues/2324-1.rs} | 0 .../{issue-2324-2.rs => issues/2324-2.rs} | 0 .../compile/{issue-2330.rs => issues/2330.rs} | 0 .../compile/{issue-2369.rs => issues/2369.rs} | 0 .../compile/{issue-2375.rs => issues/2375.rs} | 0 .../compile/{issue-2391.rs => issues/2391.rs} | 0 .../compile/{issue-2394.rs => issues/2394.rs} | 0 .../{issue-2421_str.rs => issues/2421_str.rs} | 0 .../compile/{issue-2423.rs => issues/2423.rs} | 0 .../compile/{issue-2431.rs => issues/2431.rs} | 0 .../compile/{issue-2477.rs => issues/2477.rs} | 0 .../compile/{issue-2478.rs => issues/2478.rs} | 0 .../compile/{issue-2479.rs => issues/2479.rs} | 0 .../compile/{issue-2499.rs => issues/2499.rs} | 0 .../compile/{issue-2514.rs => issues/2514.rs} | 0 .../{issue-2567-1.rs => issues/2567-1.rs} | 0 .../{issue-2567-2.rs => issues/2567-2.rs} | 0 .../{issue-2567-3.rs => issues/2567-3.rs} | 0 .../compile/{issue-2645.rs => issues/2645.rs} | 0 .../{issue-2650-1.rs => issues/2650-1.rs} | 0 .../{issue-2650-2.rs => issues/2650-2.rs} | 0 .../compile/{issue-266.rs => issues/266.rs} | 0 .../compile/{issue-2665.rs => issues/2665.rs} | 0 .../compile/{issue-2680.rs => issues/2680.rs} | 0 .../compile/{issue-2709.rs => issues/2709.rs} | 0 .../{issue-2723-1.rs => issues/2723-1.rs} | 0 .../{issue-2723-2.rs => issues/2723-2.rs} | 0 .../compile/{issue-2725.rs => issues/2725.rs} | 0 .../compile/{issue-2747.rs => issues/2747.rs} | 0 .../compile/{issue-2767.rs => issues/2767.rs} | 0 .../{issue-2772-1.rs => issues/2772-1.rs} | 0 .../{issue-2772-2.rs => issues/2772-2.rs} | 0 .../compile/{issue-2775.rs => issues/2775.rs} | 0 .../compile/{issue-2782.rs => issues/2782.rs} | 0 .../compile/{issue-2785.rs => issues/2785.rs} | 0 .../compile/{issue-2788.rs => issues/2788.rs} | 0 .../compile/{issue-2812.rs => issues/2812.rs} | 0 .../{issue-2847-b.rs => issues/2847-b.rs} | 0 .../compile/{issue-2847.rs => issues/2847.rs} | 0 .../compile/{issue-2850.rs => issues/2850.rs} | 0 .../{issue-2905-1.rs => issues/2905-1.rs} | 0 .../{issue-2905-2.rs => issues/2905-2.rs} | 0 .../compile/{issue-2906.rs => issues/2906.rs} | 0 .../compile/{issue-2907.rs => issues/2907.rs} | 0 .../compile/{issue-2951.rs => issues/2951.rs} | 0 .../{issue-2953-1.rs => issues/2953-1.rs} | 0 .../{issue-2953-2.rs => issues/2953-2.rs} | 0 .../compile/{issue-2954.rs => issues/2954.rs} | 0 .../compile/{issue-2987.rs => issues/2987.rs} | 0 .../compile/{issue-3009.rs => issues/3009.rs} | 0 .../compile/{issue-3022.rs => issues/3022.rs} | 0 .../compile/{issue-3030.rs => issues/3030.rs} | 0 .../compile/{issue-3031.rs => issues/3031.rs} | 0 .../{issue-3032-1.rs => issues/3032-1.rs} | 0 .../{issue-3032-2.rs => issues/3032-2.rs} | 0 .../compile/{issue-3033.rs => issues/3033.rs} | 0 .../compile/{issue-3035.rs => issues/3035.rs} | 0 .../compile/{issue-3036.rs => issues/3036.rs} | 0 .../{issue-3045-1.rs => issues/3045-1.rs} | 0 .../{issue-3045-2.rs => issues/3045-2.rs} | 0 .../compile/{issue-3046.rs => issues/3046.rs} | 0 .../compile/{issue-3082.rs => issues/3082.rs} | 0 .../{issue-3139-1.rs => issues/3139-1.rs} | 0 .../{issue-3139-2.rs => issues/3139-2.rs} | 0 .../{issue-3139-3.rs => issues/3139-3.rs} | 0 .../compile/{issue-3140.rs => issues/3140.rs} | 0 .../compile/{issue-3141.rs => issues/3141.rs} | 0 .../compile/{issue-3144.rs => issues/3144.rs} | 0 .../compile/{issue-3174.rs => issues/3174.rs} | 0 .../compile/{issue-3231.rs => issues/3231.rs} | 0 .../compile/{issue-3242.rs => issues/3242.rs} | 0 .../compile/{issue-3261.rs => issues/3261.rs} | 0 .../compile/{issue-3304.rs => issues/3304.rs} | 0 .../{issue-3315-1.rs => issues/3315-1.rs} | 0 .../{issue-3315-2.rs => issues/3315-2.rs} | 0 .../compile/{issue-3350.rs => issues/3350.rs} | 0 .../compile/{issue-3382.rs => issues/3382.rs} | 0 .../{issue-3402-1.rs => issues/3402-1.rs} | 0 .../{issue-3402-2.rs => issues/3402-2.rs} | 0 .../compile/{issue-3403.rs => issues/3403.rs} | 0 .../compile/{issue-3454.rs => issues/3454.rs} | 0 .../compile/{issue-3524.rs => issues/3524.rs} | 0 .../compile/{issue-3525.rs => issues/3525.rs} | 0 .../{issue-3530-1.rs => issues/3530-1.rs} | 0 .../{issue-3530-2.rs => issues/3530-2.rs} | 0 .../compile/{issue-3537.rs => issues/3537.rs} | 0 .../compile/{issue-3538.rs => issues/3538.rs} | 0 .../{issue-3541-1.rs => issues/3541-1.rs} | 0 .../{issue-3541-2.rs => issues/3541-2.rs} | 0 .../compile/{issue-3546.rs => issues/3546.rs} | 0 .../compile/{issue-3549.rs => issues/3549.rs} | 0 .../compile/{issue-3550.rs => issues/3550.rs} | 0 .../compile/{issue-3551.rs => issues/3551.rs} | 0 .../compile/{issue-3552.rs => issues/3552.rs} | 0 .../compile/{issue-3553.rs => issues/3553.rs} | 0 .../{issue-3554-1.rs => issues/3554-1.rs} | 0 .../{issue-3554-2.rs => issues/3554-2.rs} | 0 .../compile/{issue-3555.rs => issues/3555.rs} | 0 .../compile/{issue-3556.rs => issues/3556.rs} | 0 .../compile/{issue-3563.rs => issues/3563.rs} | 0 .../{issue-3566-1.rs => issues/3566-1.rs} | 0 .../{issue-3566-2.rs => issues/3566-2.rs} | 0 .../compile/{issue-3567.rs => issues/3567.rs} | 0 .../compile/{issue-3568.rs => issues/3568.rs} | 0 .../{issue-3581-1.rs => issues/3581-1.rs} | 0 .../{issue-3581-2.rs => issues/3581-2.rs} | 0 .../{issue-3585-1.rs => issues/3585-1.rs} | 0 .../{issue-3585-2.rs => issues/3585-2.rs} | 0 .../compile/{issue-3588.rs => issues/3588.rs} | 0 .../compile/{issue-3591.rs => issues/3591.rs} | 0 .../compile/{issue-3592.rs => issues/3592.rs} | 0 .../compile/{issue-3597.rs => issues/3597.rs} | 0 .../compile/{issue-3599.rs => issues/3599.rs} | 0 .../compile/{issue-3605.rs => issues/3605.rs} | 0 .../compile/{issue-3606.rs => issues/3606.rs} | 0 .../compile/{issue-3612.rs => issues/3612.rs} | 0 .../compile/{issue-3613.rs => issues/3613.rs} | 0 .../compile/{issue-3614.rs => issues/3614.rs} | 0 .../compile/{issue-3615.rs => issues/3615.rs} | 0 .../compile/{issue-3617.rs => issues/3617.rs} | 0 .../compile/{issue-3618.rs => issues/3618.rs} | 0 .../compile/{issue-3625.rs => issues/3625.rs} | 0 .../compile/{issue-3628.rs => issues/3628.rs} | 0 .../compile/{issue-3642.rs => issues/3642.rs} | 0 .../compile/{issue-3643.rs => issues/3643.rs} | 0 .../compile/{issue-3645.rs => issues/3645.rs} | 0 .../compile/{issue-3646.rs => issues/3646.rs} | 0 .../compile/{issue-3647.rs => issues/3647.rs} | 0 .../compile/{issue-3648.rs => issues/3648.rs} | 0 .../compile/{issue-3649.rs => issues/3649.rs} | 0 .../compile/{issue-3651.rs => issues/3651.rs} | 0 .../compile/{issue-3652.rs => issues/3652.rs} | 0 .../compile/{issue-3654.rs => issues/3654.rs} | 0 .../compile/{issue-3656.rs => issues/3656.rs} | 0 .../compile/{issue-3657.rs => issues/3657.rs} | 0 .../compile/{issue-3659.rs => issues/3659.rs} | 0 .../compile/{issue-3660.rs => issues/3660.rs} | 0 .../compile/{issue-3661.rs => issues/3661.rs} | 0 .../compile/{issue-3662.rs => issues/3662.rs} | 0 .../compile/{issue-3663.rs => issues/3663.rs} | 0 .../compile/{issue-3664.rs => issues/3664.rs} | 0 .../compile/{issue-3665.rs => issues/3665.rs} | 0 .../compile/{issue-3667.rs => issues/3667.rs} | 0 .../compile/{issue-3670.rs => issues/3670.rs} | 0 .../compile/{issue-3671.rs => issues/3671.rs} | 0 .../compile/{issue-3672.rs => issues/3672.rs} | 0 .../compile/{issue-3711.rs => issues/3711.rs} | 0 .../compile/{issue-3726.rs => issues/3726.rs} | 0 .../compile/{issue-3836.rs => issues/3836.rs} | 0 .../compile/{issue-3874.rs => issues/3874.rs} | 0 .../compile/{issue-3875.rs => issues/3875.rs} | 0 .../compile/{issue-3876.rs => issues/3876.rs} | 0 .../compile/{issue-3885.rs => issues/3885.rs} | 0 .../compile/{issue-3898.rs => issues/3898.rs} | 0 .../compile/{issue-3904.rs => issues/3904.rs} | 0 .../compile/{issue-3910.rs => issues/3910.rs} | 0 .../compile/{issue-3915.rs => issues/3915.rs} | 0 .../compile/{issue-3916.rs => issues/3916.rs} | 0 .../3919-ice-func-parms.rs} | 0 .../compile/{issue-3922.rs => issues/3922.rs} | 0 .../compile/{issue-3924.rs => issues/3924.rs} | 0 .../compile/{issue-3928.rs => issues/3928.rs} | 0 .../{issue-3929-1.rs => issues/3929-1.rs} | 0 .../{issue-3929-2.rs => issues/3929-2.rs} | 0 .../compile/{issue-3930.rs => issues/3930.rs} | 0 .../compile/{issue-3931.rs => issues/3931.rs} | 0 .../compile/{issue-3947.rs => issues/3947.rs} | 0 .../compile/{issue-3951.rs => issues/3951.rs} | 0 .../compile/{issue-3958.rs => issues/3958.rs} | 0 .../compile/{issue-3960.rs => issues/3960.rs} | 0 .../{issue-3965-1.rs => issues/3965-1.rs} | 0 .../{issue-3965-2.rs => issues/3965-2.rs} | 0 .../compile/{issue-3966.rs => issues/3966.rs} | 0 .../compile/{issue-3969.rs => issues/3969.rs} | 0 .../compile/{issue-3971.rs => issues/3971.rs} | 0 .../compile/{issue-3972.rs => issues/3972.rs} | 0 .../compile/{issue-3974.rs => issues/3974.rs} | 0 .../compile/{issue-3977.rs => issues/3977.rs} | 0 .../compile/{issue-3978.rs => issues/3978.rs} | 0 .../compile/{issue-4006.rs => issues/4006.rs} | 0 .../compile/{issue-402.rs => issues/402.rs} | 0 .../{issue-407-2.rs => issues/407-2.rs} | 0 .../compile/{issue-407.rs => issues/407.rs} | 0 .../{issue-4090-1.rs => issues/4090-1.rs} | 0 .../{issue-4090-2.rs => issues/4090-2.rs} | 0 .../compile/{issue-4116.rs => issues/4116.rs} | 0 .../compile/{issue-4139.rs => issues/4139.rs} | 0 .../{issue-4140-1.rs => issues/4140-1.rs} | 0 .../{issue-4140-2.rs => issues/4140-2.rs} | 0 .../compile/{issue-4145.rs => issues/4145.rs} | 0 .../compile/{issue-4146.rs => issues/4146.rs} | 0 .../compile/{issue-4148.rs => issues/4148.rs} | 0 .../compile/{issue-4155.rs => issues/4155.rs} | 0 .../{issue-4157-1.rs => issues/4157-1.rs} | 0 .../{issue-4157-2.rs => issues/4157-2.rs} | 0 .../compile/{issue-4158.rs => issues/4158.rs} | 0 .../compile/{issue-4159.rs => issues/4159.rs} | 0 .../compile/{issue-4162.rs => issues/4162.rs} | 0 .../{issue-4163-2.rs => issues/4163-2.rs} | 0 .../compile/{issue-4163.rs => issues/4163.rs} | 0 .../compile/{issue-4165.rs => issues/4165.rs} | 0 .../compile/{issue-4166.rs => issues/4166.rs} | 0 .../compile/{issue-4167.rs => issues/4167.rs} | 0 .../compile/{issue-4168.rs => issues/4168.rs} | 0 .../{issue-4173-1.rs => issues/4173-1.rs} | 0 .../{issue-4173-2.rs => issues/4173-2.rs} | 0 .../{issue-4173-3.rs => issues/4173-3.rs} | 0 .../compile/{issue-4188.rs => issues/4188.rs} | 0 .../compile/{issue-4212.rs => issues/4212.rs} | 0 .../compile/{issue-4213.rs => issues/4213.rs} | 0 .../compile/{issue-4219.rs => issues/4219.rs} | 0 .../compile/{issue-4222.rs => issues/4222.rs} | 0 .../compile/{issue-4225.rs => issues/4225.rs} | 0 .../compile/{issue-4226.rs => issues/4226.rs} | 0 .../compile/{issue-4231.rs => issues/4231.rs} | 0 .../compile/{issue-4232.rs => issues/4232.rs} | 0 .../compile/{issue-4234.rs => issues/4234.rs} | 0 .../compile/{issue-4235.rs => issues/4235.rs} | 0 .../compile/{issue-4242.rs => issues/4242.rs} | 0 .../compile/{issue-4245.rs => issues/4245.rs} | 0 .../{issue-4260_0.rs => issues/4260_0.rs} | 0 .../compile/{issue-4261.rs => issues/4261.rs} | 0 .../compile/{issue-4262.rs => issues/4262.rs} | 0 .../compile/{issue-4267.rs => issues/4267.rs} | 0 .../compile/{issue-4293.rs => issues/4293.rs} | 0 .../compile/{issue-4301.rs => issues/4301.rs} | 0 .../compile/{issue-4302.rs => issues/4302.rs} | 0 .../4375-ice-regression.rs} | 0 .../4375-multiple-errors.rs} | 0 .../4375-tuple-pattern.rs} | 0 .../compile/{issue-4387.rs => issues/4387.rs} | 0 .../compile/{issue-4388.rs => issues/4388.rs} | 0 .../compile/{issue-4402.rs => issues/4402.rs} | 0 .../compile/{issue-4410.rs => issues/4410.rs} | 0 .../compile/{issue-4411.rs => issues/4411.rs} | 0 .../compile/{issue-4412.rs => issues/4412.rs} | 0 .../compile/{issue-4413.rs => issues/4413.rs} | 0 .../compile/{issue-4414.rs => issues/4414.rs} | 0 .../compile/{issue-4433.rs => issues/4433.rs} | 0 .../{issue-4471-1.rs => issues/4471-1.rs} | 0 .../{issue-4471-2.rs => issues/4471-2.rs} | 0 .../compile/{issue-4476.rs => issues/4476.rs} | 0 .../compile/{issue-4481.rs => issues/4481.rs} | 0 .../{issue-4486-1.rs => issues/4486-1.rs} | 0 .../{issue-4486-2.rs => issues/4486-2.rs} | 0 .../compile/{issue-4517.rs => issues/4517.rs} | 0 .../compile/{issue-4538.rs => issues/4538.rs} | 0 .../compile/{issue-4563.rs => issues/4563.rs} | 0 .../compile/{issue-4592.rs => issues/4592.rs} | 0 .../compile/{issue-4617.rs => issues/4617.rs} | 0 .../compile/{issue-4631.rs => issues/4631.rs} | 0 .../compile/{issue-4674.rs => issues/4674.rs} | 0 .../compile/{issue-4678.rs => issues/4678.rs} | 0 .../{issue-4689-1.rs => issues/4689-1.rs} | 0 .../{issue-4689-2.rs => issues/4689-2.rs} | 0 .../compile/{issue-4735.rs => issues/4735.rs} | 0 .../compile/{issue-4740.rs => issues/4740.rs} | 0 .../compile/{issue-4747.rs => issues/4747.rs} | 0 .../compile/{issue-4794.rs => issues/4794.rs} | 0 .../compile/{issue-4805.rs => issues/4805.rs} | 0 .../compile/{issue-4812.rs => issues/4812.rs} | 0 .../compile/{issue-4822.rs => issues/4822.rs} | 0 .../compile/{issue-4823.rs => issues/4823.rs} | 0 .../compile/{issue-4828.rs => issues/4828.rs} | 0 .../{issue-4829-1.rs => issues/4829-1.rs} | 0 .../{issue-4829-2.rs => issues/4829-2.rs} | 0 .../compile/{issue-4851.rs => issues/4851.rs} | 0 .../compile/{issue-4853.rs => issues/4853.rs} | 0 .../compile/{issue-4855.rs => issues/4855.rs} | 0 .../compile/{issue-4858.rs => issues/4858.rs} | 0 .../compile/{issue-4859.rs => issues/4859.rs} | 0 .../compile/{issue-4860.rs => issues/4860.rs} | 0 .../compile/{issue-4861.rs => issues/4861.rs} | 0 .../compile/{issue-4862.rs => issues/4862.rs} | 0 .../compile/{issue-4863.rs => issues/4863.rs} | 0 .../compile/{issue-4864.rs => issues/4864.rs} | 0 .../compile/{issue-4867.rs => issues/4867.rs} | 0 .../compile/{issue-4879.rs => issues/4879.rs} | 0 .../compile/{issue-557.rs => issues/557.rs} | 0 .../{issue-635-1.rs => issues/635-1.rs} | 0 .../{issue-635-2.rs => issues/635-2.rs} | 0 .../compile/{issue-850.rs => issues/850.rs} | 0 .../compile/{issue-852.rs => issues/852.rs} | 0 .../compile/{issue-855.rs => issues/855.rs} | 0 .../compile/{issue-867.rs => issues/867.rs} | 0 .../compile/{issue-925.rs => issues/925.rs} | 0 .../rust/compile/{ => issues}/empty_file | 0 .../compile/{ => issues}/issue_4402_foo.rs | 0 gcc/testsuite/rust/compile/issues/issues.exp | 35 +++++++++++++++++++ 382 files changed, 35 insertions(+) rename gcc/testsuite/rust/compile/{issue-1005.rs => issues/1005.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1006.rs => issues/1006.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1019.rs => issues/1019.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1023.rs => issues/1023.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1031.rs => issues/1031.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1034.rs => issues/1034.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1048.rs => issues/1048.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1073.rs => issues/1073.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1081.rs => issues/1081.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1089.rs => issues/1089.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1089 => issues/1089}/test_mod.rs (100%) rename gcc/testsuite/rust/compile/{issue-1128.rs => issues/1128.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1129-1.rs => issues/1129-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1129-2.rs => issues/1129-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1130.rs => issues/1130.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1131.rs => issues/1131.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1152.rs => issues/1152.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1165.rs => issues/1165.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1173.rs => issues/1173.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1210.rs => issues/1210.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1226.rs => issues/1226.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1234.rs => issues/1234.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1235.rs => issues/1235.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1237.rs => issues/1237.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1251.rs => issues/1251.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1271.rs => issues/1271.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1272.rs => issues/1272.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1289.rs => issues/1289.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1323-1.rs => issues/1323-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1323-2.rs => issues/1323-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1361.rs => issues/1361.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1383.rs => issues/1383.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1393.rs => issues/1393.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1422.rs => issues/1422.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1446.rs => issues/1446.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1447.rs => issues/1447.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1483.rs => issues/1483.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1485.rs => issues/1485.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1487.rs => issues/1487.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1524.rs => issues/1524.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1525.rs => issues/1525.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1553.rs => issues/1553.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1589.rs => issues/1589.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1725-1.rs => issues/1725-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1725-2.rs => issues/1725-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1726-1.rs => issues/1726-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1726-2.rs => issues/1726-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1773.rs => issues/1773.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1786.rs => issues/1786.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1807.rs => issues/1807.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1813.rs => issues/1813.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1830_bytes.rs => issues/1830_bytes.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1830_str.rs => issues/1830_str.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1893.rs => issues/1893.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1901.rs => issues/1901.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1930.rs => issues/1930.rs} (100%) rename gcc/testsuite/rust/compile/{issue-1981.rs => issues/1981.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2015.rs => issues/2015.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2019-1.rs => issues/2019-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2019-2.rs => issues/2019-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2019-3.rs => issues/2019-3.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2029.rs => issues/2029.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2035.rs => issues/2035.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2036.rs => issues/2036.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2037.rs => issues/2037.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2039.rs => issues/2039.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2040.rs => issues/2040.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2042.rs => issues/2042.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2043.rs => issues/2043.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2070.rs => issues/2070.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2105.rs => issues/2105.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2106.rs => issues/2106.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2125.rs => issues/2125.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2135.rs => issues/2135.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2136-1.rs => issues/2136-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2136-2.rs => issues/2136-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2139.rs => issues/2139.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2142.rs => issues/2142.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2165.rs => issues/2165.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2166.rs => issues/2166.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2178.rs => issues/2178.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2187.rs => issues/2187.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2188.rs => issues/2188.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2189.rs => issues/2189.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2190-1.rs => issues/2190-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2190-2.rs => issues/2190-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2195.rs => issues/2195.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2203.rs => issues/2203.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2207.rs => issues/2207.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2225.rs => issues/2225.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2238.rs => issues/2238.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2304.rs => issues/2304.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2323.rs => issues/2323.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2324-1.rs => issues/2324-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2324-2.rs => issues/2324-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2330.rs => issues/2330.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2369.rs => issues/2369.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2375.rs => issues/2375.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2391.rs => issues/2391.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2394.rs => issues/2394.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2421_str.rs => issues/2421_str.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2423.rs => issues/2423.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2431.rs => issues/2431.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2477.rs => issues/2477.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2478.rs => issues/2478.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2479.rs => issues/2479.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2499.rs => issues/2499.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2514.rs => issues/2514.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2567-1.rs => issues/2567-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2567-2.rs => issues/2567-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2567-3.rs => issues/2567-3.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2645.rs => issues/2645.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2650-1.rs => issues/2650-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2650-2.rs => issues/2650-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-266.rs => issues/266.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2665.rs => issues/2665.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2680.rs => issues/2680.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2709.rs => issues/2709.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2723-1.rs => issues/2723-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2723-2.rs => issues/2723-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2725.rs => issues/2725.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2747.rs => issues/2747.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2767.rs => issues/2767.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2772-1.rs => issues/2772-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2772-2.rs => issues/2772-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2775.rs => issues/2775.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2782.rs => issues/2782.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2785.rs => issues/2785.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2788.rs => issues/2788.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2812.rs => issues/2812.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2847-b.rs => issues/2847-b.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2847.rs => issues/2847.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2850.rs => issues/2850.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2905-1.rs => issues/2905-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2905-2.rs => issues/2905-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2906.rs => issues/2906.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2907.rs => issues/2907.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2951.rs => issues/2951.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2953-1.rs => issues/2953-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2953-2.rs => issues/2953-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2954.rs => issues/2954.rs} (100%) rename gcc/testsuite/rust/compile/{issue-2987.rs => issues/2987.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3009.rs => issues/3009.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3022.rs => issues/3022.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3030.rs => issues/3030.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3031.rs => issues/3031.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3032-1.rs => issues/3032-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3032-2.rs => issues/3032-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3033.rs => issues/3033.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3035.rs => issues/3035.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3036.rs => issues/3036.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3045-1.rs => issues/3045-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3045-2.rs => issues/3045-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3046.rs => issues/3046.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3082.rs => issues/3082.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3139-1.rs => issues/3139-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3139-2.rs => issues/3139-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3139-3.rs => issues/3139-3.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3140.rs => issues/3140.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3141.rs => issues/3141.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3144.rs => issues/3144.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3174.rs => issues/3174.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3231.rs => issues/3231.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3242.rs => issues/3242.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3261.rs => issues/3261.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3304.rs => issues/3304.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3315-1.rs => issues/3315-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3315-2.rs => issues/3315-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3350.rs => issues/3350.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3382.rs => issues/3382.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3402-1.rs => issues/3402-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3402-2.rs => issues/3402-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3403.rs => issues/3403.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3454.rs => issues/3454.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3524.rs => issues/3524.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3525.rs => issues/3525.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3530-1.rs => issues/3530-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3530-2.rs => issues/3530-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3537.rs => issues/3537.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3538.rs => issues/3538.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3541-1.rs => issues/3541-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3541-2.rs => issues/3541-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3546.rs => issues/3546.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3549.rs => issues/3549.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3550.rs => issues/3550.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3551.rs => issues/3551.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3552.rs => issues/3552.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3553.rs => issues/3553.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3554-1.rs => issues/3554-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3554-2.rs => issues/3554-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3555.rs => issues/3555.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3556.rs => issues/3556.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3563.rs => issues/3563.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3566-1.rs => issues/3566-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3566-2.rs => issues/3566-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3567.rs => issues/3567.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3568.rs => issues/3568.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3581-1.rs => issues/3581-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3581-2.rs => issues/3581-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3585-1.rs => issues/3585-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3585-2.rs => issues/3585-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3588.rs => issues/3588.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3591.rs => issues/3591.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3592.rs => issues/3592.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3597.rs => issues/3597.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3599.rs => issues/3599.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3605.rs => issues/3605.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3606.rs => issues/3606.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3612.rs => issues/3612.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3613.rs => issues/3613.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3614.rs => issues/3614.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3615.rs => issues/3615.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3617.rs => issues/3617.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3618.rs => issues/3618.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3625.rs => issues/3625.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3628.rs => issues/3628.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3642.rs => issues/3642.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3643.rs => issues/3643.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3645.rs => issues/3645.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3646.rs => issues/3646.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3647.rs => issues/3647.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3648.rs => issues/3648.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3649.rs => issues/3649.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3651.rs => issues/3651.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3652.rs => issues/3652.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3654.rs => issues/3654.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3656.rs => issues/3656.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3657.rs => issues/3657.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3659.rs => issues/3659.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3660.rs => issues/3660.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3661.rs => issues/3661.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3662.rs => issues/3662.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3663.rs => issues/3663.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3664.rs => issues/3664.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3665.rs => issues/3665.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3667.rs => issues/3667.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3670.rs => issues/3670.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3671.rs => issues/3671.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3672.rs => issues/3672.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3711.rs => issues/3711.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3726.rs => issues/3726.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3836.rs => issues/3836.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3874.rs => issues/3874.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3875.rs => issues/3875.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3876.rs => issues/3876.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3885.rs => issues/3885.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3898.rs => issues/3898.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3904.rs => issues/3904.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3910.rs => issues/3910.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3915.rs => issues/3915.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3916.rs => issues/3916.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3919-ice-func-parms.rs => issues/3919-ice-func-parms.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3922.rs => issues/3922.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3924.rs => issues/3924.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3928.rs => issues/3928.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3929-1.rs => issues/3929-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3929-2.rs => issues/3929-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3930.rs => issues/3930.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3931.rs => issues/3931.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3947.rs => issues/3947.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3951.rs => issues/3951.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3958.rs => issues/3958.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3960.rs => issues/3960.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3965-1.rs => issues/3965-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3965-2.rs => issues/3965-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3966.rs => issues/3966.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3969.rs => issues/3969.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3971.rs => issues/3971.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3972.rs => issues/3972.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3974.rs => issues/3974.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3977.rs => issues/3977.rs} (100%) rename gcc/testsuite/rust/compile/{issue-3978.rs => issues/3978.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4006.rs => issues/4006.rs} (100%) rename gcc/testsuite/rust/compile/{issue-402.rs => issues/402.rs} (100%) rename gcc/testsuite/rust/compile/{issue-407-2.rs => issues/407-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-407.rs => issues/407.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4090-1.rs => issues/4090-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4090-2.rs => issues/4090-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4116.rs => issues/4116.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4139.rs => issues/4139.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4140-1.rs => issues/4140-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4140-2.rs => issues/4140-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4145.rs => issues/4145.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4146.rs => issues/4146.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4148.rs => issues/4148.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4155.rs => issues/4155.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4157-1.rs => issues/4157-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4157-2.rs => issues/4157-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4158.rs => issues/4158.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4159.rs => issues/4159.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4162.rs => issues/4162.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4163-2.rs => issues/4163-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4163.rs => issues/4163.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4165.rs => issues/4165.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4166.rs => issues/4166.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4167.rs => issues/4167.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4168.rs => issues/4168.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4173-1.rs => issues/4173-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4173-2.rs => issues/4173-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4173-3.rs => issues/4173-3.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4188.rs => issues/4188.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4212.rs => issues/4212.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4213.rs => issues/4213.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4219.rs => issues/4219.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4222.rs => issues/4222.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4225.rs => issues/4225.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4226.rs => issues/4226.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4231.rs => issues/4231.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4232.rs => issues/4232.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4234.rs => issues/4234.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4235.rs => issues/4235.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4242.rs => issues/4242.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4245.rs => issues/4245.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4260_0.rs => issues/4260_0.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4261.rs => issues/4261.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4262.rs => issues/4262.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4267.rs => issues/4267.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4293.rs => issues/4293.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4301.rs => issues/4301.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4302.rs => issues/4302.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4375-ice-regression.rs => issues/4375-ice-regression.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4375-multiple-errors.rs => issues/4375-multiple-errors.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4375-tuple-pattern.rs => issues/4375-tuple-pattern.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4387.rs => issues/4387.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4388.rs => issues/4388.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4402.rs => issues/4402.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4410.rs => issues/4410.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4411.rs => issues/4411.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4412.rs => issues/4412.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4413.rs => issues/4413.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4414.rs => issues/4414.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4433.rs => issues/4433.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4471-1.rs => issues/4471-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4471-2.rs => issues/4471-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4476.rs => issues/4476.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4481.rs => issues/4481.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4486-1.rs => issues/4486-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4486-2.rs => issues/4486-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4517.rs => issues/4517.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4538.rs => issues/4538.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4563.rs => issues/4563.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4592.rs => issues/4592.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4617.rs => issues/4617.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4631.rs => issues/4631.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4674.rs => issues/4674.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4678.rs => issues/4678.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4689-1.rs => issues/4689-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4689-2.rs => issues/4689-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4735.rs => issues/4735.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4740.rs => issues/4740.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4747.rs => issues/4747.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4794.rs => issues/4794.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4805.rs => issues/4805.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4812.rs => issues/4812.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4822.rs => issues/4822.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4823.rs => issues/4823.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4828.rs => issues/4828.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4829-1.rs => issues/4829-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4829-2.rs => issues/4829-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4851.rs => issues/4851.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4853.rs => issues/4853.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4855.rs => issues/4855.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4858.rs => issues/4858.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4859.rs => issues/4859.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4860.rs => issues/4860.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4861.rs => issues/4861.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4862.rs => issues/4862.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4863.rs => issues/4863.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4864.rs => issues/4864.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4867.rs => issues/4867.rs} (100%) rename gcc/testsuite/rust/compile/{issue-4879.rs => issues/4879.rs} (100%) rename gcc/testsuite/rust/compile/{issue-557.rs => issues/557.rs} (100%) rename gcc/testsuite/rust/compile/{issue-635-1.rs => issues/635-1.rs} (100%) rename gcc/testsuite/rust/compile/{issue-635-2.rs => issues/635-2.rs} (100%) rename gcc/testsuite/rust/compile/{issue-850.rs => issues/850.rs} (100%) rename gcc/testsuite/rust/compile/{issue-852.rs => issues/852.rs} (100%) rename gcc/testsuite/rust/compile/{issue-855.rs => issues/855.rs} (100%) rename gcc/testsuite/rust/compile/{issue-867.rs => issues/867.rs} (100%) rename gcc/testsuite/rust/compile/{issue-925.rs => issues/925.rs} (100%) rename gcc/testsuite/rust/compile/{ => issues}/empty_file (100%) rename gcc/testsuite/rust/compile/{ => issues}/issue_4402_foo.rs (100%) create mode 100644 gcc/testsuite/rust/compile/issues/issues.exp diff --git a/gcc/testsuite/rust/compile/issue-1005.rs b/gcc/testsuite/rust/compile/issues/1005.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1005.rs rename to gcc/testsuite/rust/compile/issues/1005.rs diff --git a/gcc/testsuite/rust/compile/issue-1006.rs b/gcc/testsuite/rust/compile/issues/1006.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1006.rs rename to gcc/testsuite/rust/compile/issues/1006.rs diff --git a/gcc/testsuite/rust/compile/issue-1019.rs b/gcc/testsuite/rust/compile/issues/1019.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1019.rs rename to gcc/testsuite/rust/compile/issues/1019.rs diff --git a/gcc/testsuite/rust/compile/issue-1023.rs b/gcc/testsuite/rust/compile/issues/1023.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1023.rs rename to gcc/testsuite/rust/compile/issues/1023.rs diff --git a/gcc/testsuite/rust/compile/issue-1031.rs b/gcc/testsuite/rust/compile/issues/1031.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1031.rs rename to gcc/testsuite/rust/compile/issues/1031.rs diff --git a/gcc/testsuite/rust/compile/issue-1034.rs b/gcc/testsuite/rust/compile/issues/1034.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1034.rs rename to gcc/testsuite/rust/compile/issues/1034.rs diff --git a/gcc/testsuite/rust/compile/issue-1048.rs b/gcc/testsuite/rust/compile/issues/1048.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1048.rs rename to gcc/testsuite/rust/compile/issues/1048.rs diff --git a/gcc/testsuite/rust/compile/issue-1073.rs b/gcc/testsuite/rust/compile/issues/1073.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1073.rs rename to gcc/testsuite/rust/compile/issues/1073.rs diff --git a/gcc/testsuite/rust/compile/issue-1081.rs b/gcc/testsuite/rust/compile/issues/1081.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1081.rs rename to gcc/testsuite/rust/compile/issues/1081.rs diff --git a/gcc/testsuite/rust/compile/issue-1089.rs b/gcc/testsuite/rust/compile/issues/1089.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1089.rs rename to gcc/testsuite/rust/compile/issues/1089.rs diff --git a/gcc/testsuite/rust/compile/issue-1089/test_mod.rs b/gcc/testsuite/rust/compile/issues/1089/test_mod.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1089/test_mod.rs rename to gcc/testsuite/rust/compile/issues/1089/test_mod.rs diff --git a/gcc/testsuite/rust/compile/issue-1128.rs b/gcc/testsuite/rust/compile/issues/1128.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1128.rs rename to gcc/testsuite/rust/compile/issues/1128.rs diff --git a/gcc/testsuite/rust/compile/issue-1129-1.rs b/gcc/testsuite/rust/compile/issues/1129-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1129-1.rs rename to gcc/testsuite/rust/compile/issues/1129-1.rs diff --git a/gcc/testsuite/rust/compile/issue-1129-2.rs b/gcc/testsuite/rust/compile/issues/1129-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1129-2.rs rename to gcc/testsuite/rust/compile/issues/1129-2.rs diff --git a/gcc/testsuite/rust/compile/issue-1130.rs b/gcc/testsuite/rust/compile/issues/1130.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1130.rs rename to gcc/testsuite/rust/compile/issues/1130.rs diff --git a/gcc/testsuite/rust/compile/issue-1131.rs b/gcc/testsuite/rust/compile/issues/1131.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1131.rs rename to gcc/testsuite/rust/compile/issues/1131.rs diff --git a/gcc/testsuite/rust/compile/issue-1152.rs b/gcc/testsuite/rust/compile/issues/1152.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1152.rs rename to gcc/testsuite/rust/compile/issues/1152.rs diff --git a/gcc/testsuite/rust/compile/issue-1165.rs b/gcc/testsuite/rust/compile/issues/1165.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1165.rs rename to gcc/testsuite/rust/compile/issues/1165.rs diff --git a/gcc/testsuite/rust/compile/issue-1173.rs b/gcc/testsuite/rust/compile/issues/1173.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1173.rs rename to gcc/testsuite/rust/compile/issues/1173.rs diff --git a/gcc/testsuite/rust/compile/issue-1210.rs b/gcc/testsuite/rust/compile/issues/1210.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1210.rs rename to gcc/testsuite/rust/compile/issues/1210.rs diff --git a/gcc/testsuite/rust/compile/issue-1226.rs b/gcc/testsuite/rust/compile/issues/1226.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1226.rs rename to gcc/testsuite/rust/compile/issues/1226.rs diff --git a/gcc/testsuite/rust/compile/issue-1234.rs b/gcc/testsuite/rust/compile/issues/1234.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1234.rs rename to gcc/testsuite/rust/compile/issues/1234.rs diff --git a/gcc/testsuite/rust/compile/issue-1235.rs b/gcc/testsuite/rust/compile/issues/1235.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1235.rs rename to gcc/testsuite/rust/compile/issues/1235.rs diff --git a/gcc/testsuite/rust/compile/issue-1237.rs b/gcc/testsuite/rust/compile/issues/1237.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1237.rs rename to gcc/testsuite/rust/compile/issues/1237.rs diff --git a/gcc/testsuite/rust/compile/issue-1251.rs b/gcc/testsuite/rust/compile/issues/1251.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1251.rs rename to gcc/testsuite/rust/compile/issues/1251.rs diff --git a/gcc/testsuite/rust/compile/issue-1271.rs b/gcc/testsuite/rust/compile/issues/1271.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1271.rs rename to gcc/testsuite/rust/compile/issues/1271.rs diff --git a/gcc/testsuite/rust/compile/issue-1272.rs b/gcc/testsuite/rust/compile/issues/1272.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1272.rs rename to gcc/testsuite/rust/compile/issues/1272.rs diff --git a/gcc/testsuite/rust/compile/issue-1289.rs b/gcc/testsuite/rust/compile/issues/1289.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1289.rs rename to gcc/testsuite/rust/compile/issues/1289.rs diff --git a/gcc/testsuite/rust/compile/issue-1323-1.rs b/gcc/testsuite/rust/compile/issues/1323-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1323-1.rs rename to gcc/testsuite/rust/compile/issues/1323-1.rs diff --git a/gcc/testsuite/rust/compile/issue-1323-2.rs b/gcc/testsuite/rust/compile/issues/1323-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1323-2.rs rename to gcc/testsuite/rust/compile/issues/1323-2.rs diff --git a/gcc/testsuite/rust/compile/issue-1361.rs b/gcc/testsuite/rust/compile/issues/1361.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1361.rs rename to gcc/testsuite/rust/compile/issues/1361.rs diff --git a/gcc/testsuite/rust/compile/issue-1383.rs b/gcc/testsuite/rust/compile/issues/1383.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1383.rs rename to gcc/testsuite/rust/compile/issues/1383.rs diff --git a/gcc/testsuite/rust/compile/issue-1393.rs b/gcc/testsuite/rust/compile/issues/1393.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1393.rs rename to gcc/testsuite/rust/compile/issues/1393.rs diff --git a/gcc/testsuite/rust/compile/issue-1422.rs b/gcc/testsuite/rust/compile/issues/1422.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1422.rs rename to gcc/testsuite/rust/compile/issues/1422.rs diff --git a/gcc/testsuite/rust/compile/issue-1446.rs b/gcc/testsuite/rust/compile/issues/1446.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1446.rs rename to gcc/testsuite/rust/compile/issues/1446.rs diff --git a/gcc/testsuite/rust/compile/issue-1447.rs b/gcc/testsuite/rust/compile/issues/1447.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1447.rs rename to gcc/testsuite/rust/compile/issues/1447.rs diff --git a/gcc/testsuite/rust/compile/issue-1483.rs b/gcc/testsuite/rust/compile/issues/1483.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1483.rs rename to gcc/testsuite/rust/compile/issues/1483.rs diff --git a/gcc/testsuite/rust/compile/issue-1485.rs b/gcc/testsuite/rust/compile/issues/1485.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1485.rs rename to gcc/testsuite/rust/compile/issues/1485.rs diff --git a/gcc/testsuite/rust/compile/issue-1487.rs b/gcc/testsuite/rust/compile/issues/1487.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1487.rs rename to gcc/testsuite/rust/compile/issues/1487.rs diff --git a/gcc/testsuite/rust/compile/issue-1524.rs b/gcc/testsuite/rust/compile/issues/1524.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1524.rs rename to gcc/testsuite/rust/compile/issues/1524.rs diff --git a/gcc/testsuite/rust/compile/issue-1525.rs b/gcc/testsuite/rust/compile/issues/1525.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1525.rs rename to gcc/testsuite/rust/compile/issues/1525.rs diff --git a/gcc/testsuite/rust/compile/issue-1553.rs b/gcc/testsuite/rust/compile/issues/1553.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1553.rs rename to gcc/testsuite/rust/compile/issues/1553.rs diff --git a/gcc/testsuite/rust/compile/issue-1589.rs b/gcc/testsuite/rust/compile/issues/1589.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1589.rs rename to gcc/testsuite/rust/compile/issues/1589.rs diff --git a/gcc/testsuite/rust/compile/issue-1725-1.rs b/gcc/testsuite/rust/compile/issues/1725-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1725-1.rs rename to gcc/testsuite/rust/compile/issues/1725-1.rs diff --git a/gcc/testsuite/rust/compile/issue-1725-2.rs b/gcc/testsuite/rust/compile/issues/1725-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1725-2.rs rename to gcc/testsuite/rust/compile/issues/1725-2.rs diff --git a/gcc/testsuite/rust/compile/issue-1726-1.rs b/gcc/testsuite/rust/compile/issues/1726-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1726-1.rs rename to gcc/testsuite/rust/compile/issues/1726-1.rs diff --git a/gcc/testsuite/rust/compile/issue-1726-2.rs b/gcc/testsuite/rust/compile/issues/1726-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1726-2.rs rename to gcc/testsuite/rust/compile/issues/1726-2.rs diff --git a/gcc/testsuite/rust/compile/issue-1773.rs b/gcc/testsuite/rust/compile/issues/1773.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1773.rs rename to gcc/testsuite/rust/compile/issues/1773.rs diff --git a/gcc/testsuite/rust/compile/issue-1786.rs b/gcc/testsuite/rust/compile/issues/1786.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1786.rs rename to gcc/testsuite/rust/compile/issues/1786.rs diff --git a/gcc/testsuite/rust/compile/issue-1807.rs b/gcc/testsuite/rust/compile/issues/1807.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1807.rs rename to gcc/testsuite/rust/compile/issues/1807.rs diff --git a/gcc/testsuite/rust/compile/issue-1813.rs b/gcc/testsuite/rust/compile/issues/1813.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1813.rs rename to gcc/testsuite/rust/compile/issues/1813.rs diff --git a/gcc/testsuite/rust/compile/issue-1830_bytes.rs b/gcc/testsuite/rust/compile/issues/1830_bytes.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1830_bytes.rs rename to gcc/testsuite/rust/compile/issues/1830_bytes.rs diff --git a/gcc/testsuite/rust/compile/issue-1830_str.rs b/gcc/testsuite/rust/compile/issues/1830_str.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1830_str.rs rename to gcc/testsuite/rust/compile/issues/1830_str.rs diff --git a/gcc/testsuite/rust/compile/issue-1893.rs b/gcc/testsuite/rust/compile/issues/1893.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1893.rs rename to gcc/testsuite/rust/compile/issues/1893.rs diff --git a/gcc/testsuite/rust/compile/issue-1901.rs b/gcc/testsuite/rust/compile/issues/1901.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1901.rs rename to gcc/testsuite/rust/compile/issues/1901.rs diff --git a/gcc/testsuite/rust/compile/issue-1930.rs b/gcc/testsuite/rust/compile/issues/1930.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1930.rs rename to gcc/testsuite/rust/compile/issues/1930.rs diff --git a/gcc/testsuite/rust/compile/issue-1981.rs b/gcc/testsuite/rust/compile/issues/1981.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-1981.rs rename to gcc/testsuite/rust/compile/issues/1981.rs diff --git a/gcc/testsuite/rust/compile/issue-2015.rs b/gcc/testsuite/rust/compile/issues/2015.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2015.rs rename to gcc/testsuite/rust/compile/issues/2015.rs diff --git a/gcc/testsuite/rust/compile/issue-2019-1.rs b/gcc/testsuite/rust/compile/issues/2019-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2019-1.rs rename to gcc/testsuite/rust/compile/issues/2019-1.rs diff --git a/gcc/testsuite/rust/compile/issue-2019-2.rs b/gcc/testsuite/rust/compile/issues/2019-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2019-2.rs rename to gcc/testsuite/rust/compile/issues/2019-2.rs diff --git a/gcc/testsuite/rust/compile/issue-2019-3.rs b/gcc/testsuite/rust/compile/issues/2019-3.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2019-3.rs rename to gcc/testsuite/rust/compile/issues/2019-3.rs diff --git a/gcc/testsuite/rust/compile/issue-2029.rs b/gcc/testsuite/rust/compile/issues/2029.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2029.rs rename to gcc/testsuite/rust/compile/issues/2029.rs diff --git a/gcc/testsuite/rust/compile/issue-2035.rs b/gcc/testsuite/rust/compile/issues/2035.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2035.rs rename to gcc/testsuite/rust/compile/issues/2035.rs diff --git a/gcc/testsuite/rust/compile/issue-2036.rs b/gcc/testsuite/rust/compile/issues/2036.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2036.rs rename to gcc/testsuite/rust/compile/issues/2036.rs diff --git a/gcc/testsuite/rust/compile/issue-2037.rs b/gcc/testsuite/rust/compile/issues/2037.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2037.rs rename to gcc/testsuite/rust/compile/issues/2037.rs diff --git a/gcc/testsuite/rust/compile/issue-2039.rs b/gcc/testsuite/rust/compile/issues/2039.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2039.rs rename to gcc/testsuite/rust/compile/issues/2039.rs diff --git a/gcc/testsuite/rust/compile/issue-2040.rs b/gcc/testsuite/rust/compile/issues/2040.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2040.rs rename to gcc/testsuite/rust/compile/issues/2040.rs diff --git a/gcc/testsuite/rust/compile/issue-2042.rs b/gcc/testsuite/rust/compile/issues/2042.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2042.rs rename to gcc/testsuite/rust/compile/issues/2042.rs diff --git a/gcc/testsuite/rust/compile/issue-2043.rs b/gcc/testsuite/rust/compile/issues/2043.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2043.rs rename to gcc/testsuite/rust/compile/issues/2043.rs diff --git a/gcc/testsuite/rust/compile/issue-2070.rs b/gcc/testsuite/rust/compile/issues/2070.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2070.rs rename to gcc/testsuite/rust/compile/issues/2070.rs diff --git a/gcc/testsuite/rust/compile/issue-2105.rs b/gcc/testsuite/rust/compile/issues/2105.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2105.rs rename to gcc/testsuite/rust/compile/issues/2105.rs diff --git a/gcc/testsuite/rust/compile/issue-2106.rs b/gcc/testsuite/rust/compile/issues/2106.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2106.rs rename to gcc/testsuite/rust/compile/issues/2106.rs diff --git a/gcc/testsuite/rust/compile/issue-2125.rs b/gcc/testsuite/rust/compile/issues/2125.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2125.rs rename to gcc/testsuite/rust/compile/issues/2125.rs diff --git a/gcc/testsuite/rust/compile/issue-2135.rs b/gcc/testsuite/rust/compile/issues/2135.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2135.rs rename to gcc/testsuite/rust/compile/issues/2135.rs diff --git a/gcc/testsuite/rust/compile/issue-2136-1.rs b/gcc/testsuite/rust/compile/issues/2136-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2136-1.rs rename to gcc/testsuite/rust/compile/issues/2136-1.rs diff --git a/gcc/testsuite/rust/compile/issue-2136-2.rs b/gcc/testsuite/rust/compile/issues/2136-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2136-2.rs rename to gcc/testsuite/rust/compile/issues/2136-2.rs diff --git a/gcc/testsuite/rust/compile/issue-2139.rs b/gcc/testsuite/rust/compile/issues/2139.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2139.rs rename to gcc/testsuite/rust/compile/issues/2139.rs diff --git a/gcc/testsuite/rust/compile/issue-2142.rs b/gcc/testsuite/rust/compile/issues/2142.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2142.rs rename to gcc/testsuite/rust/compile/issues/2142.rs diff --git a/gcc/testsuite/rust/compile/issue-2165.rs b/gcc/testsuite/rust/compile/issues/2165.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2165.rs rename to gcc/testsuite/rust/compile/issues/2165.rs diff --git a/gcc/testsuite/rust/compile/issue-2166.rs b/gcc/testsuite/rust/compile/issues/2166.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2166.rs rename to gcc/testsuite/rust/compile/issues/2166.rs diff --git a/gcc/testsuite/rust/compile/issue-2178.rs b/gcc/testsuite/rust/compile/issues/2178.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2178.rs rename to gcc/testsuite/rust/compile/issues/2178.rs diff --git a/gcc/testsuite/rust/compile/issue-2187.rs b/gcc/testsuite/rust/compile/issues/2187.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2187.rs rename to gcc/testsuite/rust/compile/issues/2187.rs diff --git a/gcc/testsuite/rust/compile/issue-2188.rs b/gcc/testsuite/rust/compile/issues/2188.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2188.rs rename to gcc/testsuite/rust/compile/issues/2188.rs diff --git a/gcc/testsuite/rust/compile/issue-2189.rs b/gcc/testsuite/rust/compile/issues/2189.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2189.rs rename to gcc/testsuite/rust/compile/issues/2189.rs diff --git a/gcc/testsuite/rust/compile/issue-2190-1.rs b/gcc/testsuite/rust/compile/issues/2190-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2190-1.rs rename to gcc/testsuite/rust/compile/issues/2190-1.rs diff --git a/gcc/testsuite/rust/compile/issue-2190-2.rs b/gcc/testsuite/rust/compile/issues/2190-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2190-2.rs rename to gcc/testsuite/rust/compile/issues/2190-2.rs diff --git a/gcc/testsuite/rust/compile/issue-2195.rs b/gcc/testsuite/rust/compile/issues/2195.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2195.rs rename to gcc/testsuite/rust/compile/issues/2195.rs diff --git a/gcc/testsuite/rust/compile/issue-2203.rs b/gcc/testsuite/rust/compile/issues/2203.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2203.rs rename to gcc/testsuite/rust/compile/issues/2203.rs diff --git a/gcc/testsuite/rust/compile/issue-2207.rs b/gcc/testsuite/rust/compile/issues/2207.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2207.rs rename to gcc/testsuite/rust/compile/issues/2207.rs diff --git a/gcc/testsuite/rust/compile/issue-2225.rs b/gcc/testsuite/rust/compile/issues/2225.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2225.rs rename to gcc/testsuite/rust/compile/issues/2225.rs diff --git a/gcc/testsuite/rust/compile/issue-2238.rs b/gcc/testsuite/rust/compile/issues/2238.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2238.rs rename to gcc/testsuite/rust/compile/issues/2238.rs diff --git a/gcc/testsuite/rust/compile/issue-2304.rs b/gcc/testsuite/rust/compile/issues/2304.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2304.rs rename to gcc/testsuite/rust/compile/issues/2304.rs diff --git a/gcc/testsuite/rust/compile/issue-2323.rs b/gcc/testsuite/rust/compile/issues/2323.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2323.rs rename to gcc/testsuite/rust/compile/issues/2323.rs diff --git a/gcc/testsuite/rust/compile/issue-2324-1.rs b/gcc/testsuite/rust/compile/issues/2324-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2324-1.rs rename to gcc/testsuite/rust/compile/issues/2324-1.rs diff --git a/gcc/testsuite/rust/compile/issue-2324-2.rs b/gcc/testsuite/rust/compile/issues/2324-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2324-2.rs rename to gcc/testsuite/rust/compile/issues/2324-2.rs diff --git a/gcc/testsuite/rust/compile/issue-2330.rs b/gcc/testsuite/rust/compile/issues/2330.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2330.rs rename to gcc/testsuite/rust/compile/issues/2330.rs diff --git a/gcc/testsuite/rust/compile/issue-2369.rs b/gcc/testsuite/rust/compile/issues/2369.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2369.rs rename to gcc/testsuite/rust/compile/issues/2369.rs diff --git a/gcc/testsuite/rust/compile/issue-2375.rs b/gcc/testsuite/rust/compile/issues/2375.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2375.rs rename to gcc/testsuite/rust/compile/issues/2375.rs diff --git a/gcc/testsuite/rust/compile/issue-2391.rs b/gcc/testsuite/rust/compile/issues/2391.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2391.rs rename to gcc/testsuite/rust/compile/issues/2391.rs diff --git a/gcc/testsuite/rust/compile/issue-2394.rs b/gcc/testsuite/rust/compile/issues/2394.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2394.rs rename to gcc/testsuite/rust/compile/issues/2394.rs diff --git a/gcc/testsuite/rust/compile/issue-2421_str.rs b/gcc/testsuite/rust/compile/issues/2421_str.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2421_str.rs rename to gcc/testsuite/rust/compile/issues/2421_str.rs diff --git a/gcc/testsuite/rust/compile/issue-2423.rs b/gcc/testsuite/rust/compile/issues/2423.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2423.rs rename to gcc/testsuite/rust/compile/issues/2423.rs diff --git a/gcc/testsuite/rust/compile/issue-2431.rs b/gcc/testsuite/rust/compile/issues/2431.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2431.rs rename to gcc/testsuite/rust/compile/issues/2431.rs diff --git a/gcc/testsuite/rust/compile/issue-2477.rs b/gcc/testsuite/rust/compile/issues/2477.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2477.rs rename to gcc/testsuite/rust/compile/issues/2477.rs diff --git a/gcc/testsuite/rust/compile/issue-2478.rs b/gcc/testsuite/rust/compile/issues/2478.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2478.rs rename to gcc/testsuite/rust/compile/issues/2478.rs diff --git a/gcc/testsuite/rust/compile/issue-2479.rs b/gcc/testsuite/rust/compile/issues/2479.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2479.rs rename to gcc/testsuite/rust/compile/issues/2479.rs diff --git a/gcc/testsuite/rust/compile/issue-2499.rs b/gcc/testsuite/rust/compile/issues/2499.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2499.rs rename to gcc/testsuite/rust/compile/issues/2499.rs diff --git a/gcc/testsuite/rust/compile/issue-2514.rs b/gcc/testsuite/rust/compile/issues/2514.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2514.rs rename to gcc/testsuite/rust/compile/issues/2514.rs diff --git a/gcc/testsuite/rust/compile/issue-2567-1.rs b/gcc/testsuite/rust/compile/issues/2567-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2567-1.rs rename to gcc/testsuite/rust/compile/issues/2567-1.rs diff --git a/gcc/testsuite/rust/compile/issue-2567-2.rs b/gcc/testsuite/rust/compile/issues/2567-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2567-2.rs rename to gcc/testsuite/rust/compile/issues/2567-2.rs diff --git a/gcc/testsuite/rust/compile/issue-2567-3.rs b/gcc/testsuite/rust/compile/issues/2567-3.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2567-3.rs rename to gcc/testsuite/rust/compile/issues/2567-3.rs diff --git a/gcc/testsuite/rust/compile/issue-2645.rs b/gcc/testsuite/rust/compile/issues/2645.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2645.rs rename to gcc/testsuite/rust/compile/issues/2645.rs diff --git a/gcc/testsuite/rust/compile/issue-2650-1.rs b/gcc/testsuite/rust/compile/issues/2650-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2650-1.rs rename to gcc/testsuite/rust/compile/issues/2650-1.rs diff --git a/gcc/testsuite/rust/compile/issue-2650-2.rs b/gcc/testsuite/rust/compile/issues/2650-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2650-2.rs rename to gcc/testsuite/rust/compile/issues/2650-2.rs diff --git a/gcc/testsuite/rust/compile/issue-266.rs b/gcc/testsuite/rust/compile/issues/266.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-266.rs rename to gcc/testsuite/rust/compile/issues/266.rs diff --git a/gcc/testsuite/rust/compile/issue-2665.rs b/gcc/testsuite/rust/compile/issues/2665.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2665.rs rename to gcc/testsuite/rust/compile/issues/2665.rs diff --git a/gcc/testsuite/rust/compile/issue-2680.rs b/gcc/testsuite/rust/compile/issues/2680.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2680.rs rename to gcc/testsuite/rust/compile/issues/2680.rs diff --git a/gcc/testsuite/rust/compile/issue-2709.rs b/gcc/testsuite/rust/compile/issues/2709.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2709.rs rename to gcc/testsuite/rust/compile/issues/2709.rs diff --git a/gcc/testsuite/rust/compile/issue-2723-1.rs b/gcc/testsuite/rust/compile/issues/2723-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2723-1.rs rename to gcc/testsuite/rust/compile/issues/2723-1.rs diff --git a/gcc/testsuite/rust/compile/issue-2723-2.rs b/gcc/testsuite/rust/compile/issues/2723-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2723-2.rs rename to gcc/testsuite/rust/compile/issues/2723-2.rs diff --git a/gcc/testsuite/rust/compile/issue-2725.rs b/gcc/testsuite/rust/compile/issues/2725.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2725.rs rename to gcc/testsuite/rust/compile/issues/2725.rs diff --git a/gcc/testsuite/rust/compile/issue-2747.rs b/gcc/testsuite/rust/compile/issues/2747.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2747.rs rename to gcc/testsuite/rust/compile/issues/2747.rs diff --git a/gcc/testsuite/rust/compile/issue-2767.rs b/gcc/testsuite/rust/compile/issues/2767.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2767.rs rename to gcc/testsuite/rust/compile/issues/2767.rs diff --git a/gcc/testsuite/rust/compile/issue-2772-1.rs b/gcc/testsuite/rust/compile/issues/2772-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2772-1.rs rename to gcc/testsuite/rust/compile/issues/2772-1.rs diff --git a/gcc/testsuite/rust/compile/issue-2772-2.rs b/gcc/testsuite/rust/compile/issues/2772-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2772-2.rs rename to gcc/testsuite/rust/compile/issues/2772-2.rs diff --git a/gcc/testsuite/rust/compile/issue-2775.rs b/gcc/testsuite/rust/compile/issues/2775.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2775.rs rename to gcc/testsuite/rust/compile/issues/2775.rs diff --git a/gcc/testsuite/rust/compile/issue-2782.rs b/gcc/testsuite/rust/compile/issues/2782.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2782.rs rename to gcc/testsuite/rust/compile/issues/2782.rs diff --git a/gcc/testsuite/rust/compile/issue-2785.rs b/gcc/testsuite/rust/compile/issues/2785.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2785.rs rename to gcc/testsuite/rust/compile/issues/2785.rs diff --git a/gcc/testsuite/rust/compile/issue-2788.rs b/gcc/testsuite/rust/compile/issues/2788.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2788.rs rename to gcc/testsuite/rust/compile/issues/2788.rs diff --git a/gcc/testsuite/rust/compile/issue-2812.rs b/gcc/testsuite/rust/compile/issues/2812.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2812.rs rename to gcc/testsuite/rust/compile/issues/2812.rs diff --git a/gcc/testsuite/rust/compile/issue-2847-b.rs b/gcc/testsuite/rust/compile/issues/2847-b.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2847-b.rs rename to gcc/testsuite/rust/compile/issues/2847-b.rs diff --git a/gcc/testsuite/rust/compile/issue-2847.rs b/gcc/testsuite/rust/compile/issues/2847.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2847.rs rename to gcc/testsuite/rust/compile/issues/2847.rs diff --git a/gcc/testsuite/rust/compile/issue-2850.rs b/gcc/testsuite/rust/compile/issues/2850.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2850.rs rename to gcc/testsuite/rust/compile/issues/2850.rs diff --git a/gcc/testsuite/rust/compile/issue-2905-1.rs b/gcc/testsuite/rust/compile/issues/2905-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2905-1.rs rename to gcc/testsuite/rust/compile/issues/2905-1.rs diff --git a/gcc/testsuite/rust/compile/issue-2905-2.rs b/gcc/testsuite/rust/compile/issues/2905-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2905-2.rs rename to gcc/testsuite/rust/compile/issues/2905-2.rs diff --git a/gcc/testsuite/rust/compile/issue-2906.rs b/gcc/testsuite/rust/compile/issues/2906.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2906.rs rename to gcc/testsuite/rust/compile/issues/2906.rs diff --git a/gcc/testsuite/rust/compile/issue-2907.rs b/gcc/testsuite/rust/compile/issues/2907.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2907.rs rename to gcc/testsuite/rust/compile/issues/2907.rs diff --git a/gcc/testsuite/rust/compile/issue-2951.rs b/gcc/testsuite/rust/compile/issues/2951.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2951.rs rename to gcc/testsuite/rust/compile/issues/2951.rs diff --git a/gcc/testsuite/rust/compile/issue-2953-1.rs b/gcc/testsuite/rust/compile/issues/2953-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2953-1.rs rename to gcc/testsuite/rust/compile/issues/2953-1.rs diff --git a/gcc/testsuite/rust/compile/issue-2953-2.rs b/gcc/testsuite/rust/compile/issues/2953-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2953-2.rs rename to gcc/testsuite/rust/compile/issues/2953-2.rs diff --git a/gcc/testsuite/rust/compile/issue-2954.rs b/gcc/testsuite/rust/compile/issues/2954.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2954.rs rename to gcc/testsuite/rust/compile/issues/2954.rs diff --git a/gcc/testsuite/rust/compile/issue-2987.rs b/gcc/testsuite/rust/compile/issues/2987.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-2987.rs rename to gcc/testsuite/rust/compile/issues/2987.rs diff --git a/gcc/testsuite/rust/compile/issue-3009.rs b/gcc/testsuite/rust/compile/issues/3009.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3009.rs rename to gcc/testsuite/rust/compile/issues/3009.rs diff --git a/gcc/testsuite/rust/compile/issue-3022.rs b/gcc/testsuite/rust/compile/issues/3022.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3022.rs rename to gcc/testsuite/rust/compile/issues/3022.rs diff --git a/gcc/testsuite/rust/compile/issue-3030.rs b/gcc/testsuite/rust/compile/issues/3030.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3030.rs rename to gcc/testsuite/rust/compile/issues/3030.rs diff --git a/gcc/testsuite/rust/compile/issue-3031.rs b/gcc/testsuite/rust/compile/issues/3031.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3031.rs rename to gcc/testsuite/rust/compile/issues/3031.rs diff --git a/gcc/testsuite/rust/compile/issue-3032-1.rs b/gcc/testsuite/rust/compile/issues/3032-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3032-1.rs rename to gcc/testsuite/rust/compile/issues/3032-1.rs diff --git a/gcc/testsuite/rust/compile/issue-3032-2.rs b/gcc/testsuite/rust/compile/issues/3032-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3032-2.rs rename to gcc/testsuite/rust/compile/issues/3032-2.rs diff --git a/gcc/testsuite/rust/compile/issue-3033.rs b/gcc/testsuite/rust/compile/issues/3033.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3033.rs rename to gcc/testsuite/rust/compile/issues/3033.rs diff --git a/gcc/testsuite/rust/compile/issue-3035.rs b/gcc/testsuite/rust/compile/issues/3035.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3035.rs rename to gcc/testsuite/rust/compile/issues/3035.rs diff --git a/gcc/testsuite/rust/compile/issue-3036.rs b/gcc/testsuite/rust/compile/issues/3036.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3036.rs rename to gcc/testsuite/rust/compile/issues/3036.rs diff --git a/gcc/testsuite/rust/compile/issue-3045-1.rs b/gcc/testsuite/rust/compile/issues/3045-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3045-1.rs rename to gcc/testsuite/rust/compile/issues/3045-1.rs diff --git a/gcc/testsuite/rust/compile/issue-3045-2.rs b/gcc/testsuite/rust/compile/issues/3045-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3045-2.rs rename to gcc/testsuite/rust/compile/issues/3045-2.rs diff --git a/gcc/testsuite/rust/compile/issue-3046.rs b/gcc/testsuite/rust/compile/issues/3046.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3046.rs rename to gcc/testsuite/rust/compile/issues/3046.rs diff --git a/gcc/testsuite/rust/compile/issue-3082.rs b/gcc/testsuite/rust/compile/issues/3082.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3082.rs rename to gcc/testsuite/rust/compile/issues/3082.rs diff --git a/gcc/testsuite/rust/compile/issue-3139-1.rs b/gcc/testsuite/rust/compile/issues/3139-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3139-1.rs rename to gcc/testsuite/rust/compile/issues/3139-1.rs diff --git a/gcc/testsuite/rust/compile/issue-3139-2.rs b/gcc/testsuite/rust/compile/issues/3139-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3139-2.rs rename to gcc/testsuite/rust/compile/issues/3139-2.rs diff --git a/gcc/testsuite/rust/compile/issue-3139-3.rs b/gcc/testsuite/rust/compile/issues/3139-3.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3139-3.rs rename to gcc/testsuite/rust/compile/issues/3139-3.rs diff --git a/gcc/testsuite/rust/compile/issue-3140.rs b/gcc/testsuite/rust/compile/issues/3140.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3140.rs rename to gcc/testsuite/rust/compile/issues/3140.rs diff --git a/gcc/testsuite/rust/compile/issue-3141.rs b/gcc/testsuite/rust/compile/issues/3141.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3141.rs rename to gcc/testsuite/rust/compile/issues/3141.rs diff --git a/gcc/testsuite/rust/compile/issue-3144.rs b/gcc/testsuite/rust/compile/issues/3144.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3144.rs rename to gcc/testsuite/rust/compile/issues/3144.rs diff --git a/gcc/testsuite/rust/compile/issue-3174.rs b/gcc/testsuite/rust/compile/issues/3174.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3174.rs rename to gcc/testsuite/rust/compile/issues/3174.rs diff --git a/gcc/testsuite/rust/compile/issue-3231.rs b/gcc/testsuite/rust/compile/issues/3231.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3231.rs rename to gcc/testsuite/rust/compile/issues/3231.rs diff --git a/gcc/testsuite/rust/compile/issue-3242.rs b/gcc/testsuite/rust/compile/issues/3242.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3242.rs rename to gcc/testsuite/rust/compile/issues/3242.rs diff --git a/gcc/testsuite/rust/compile/issue-3261.rs b/gcc/testsuite/rust/compile/issues/3261.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3261.rs rename to gcc/testsuite/rust/compile/issues/3261.rs diff --git a/gcc/testsuite/rust/compile/issue-3304.rs b/gcc/testsuite/rust/compile/issues/3304.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3304.rs rename to gcc/testsuite/rust/compile/issues/3304.rs diff --git a/gcc/testsuite/rust/compile/issue-3315-1.rs b/gcc/testsuite/rust/compile/issues/3315-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3315-1.rs rename to gcc/testsuite/rust/compile/issues/3315-1.rs diff --git a/gcc/testsuite/rust/compile/issue-3315-2.rs b/gcc/testsuite/rust/compile/issues/3315-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3315-2.rs rename to gcc/testsuite/rust/compile/issues/3315-2.rs diff --git a/gcc/testsuite/rust/compile/issue-3350.rs b/gcc/testsuite/rust/compile/issues/3350.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3350.rs rename to gcc/testsuite/rust/compile/issues/3350.rs diff --git a/gcc/testsuite/rust/compile/issue-3382.rs b/gcc/testsuite/rust/compile/issues/3382.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3382.rs rename to gcc/testsuite/rust/compile/issues/3382.rs diff --git a/gcc/testsuite/rust/compile/issue-3402-1.rs b/gcc/testsuite/rust/compile/issues/3402-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3402-1.rs rename to gcc/testsuite/rust/compile/issues/3402-1.rs diff --git a/gcc/testsuite/rust/compile/issue-3402-2.rs b/gcc/testsuite/rust/compile/issues/3402-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3402-2.rs rename to gcc/testsuite/rust/compile/issues/3402-2.rs diff --git a/gcc/testsuite/rust/compile/issue-3403.rs b/gcc/testsuite/rust/compile/issues/3403.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3403.rs rename to gcc/testsuite/rust/compile/issues/3403.rs diff --git a/gcc/testsuite/rust/compile/issue-3454.rs b/gcc/testsuite/rust/compile/issues/3454.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3454.rs rename to gcc/testsuite/rust/compile/issues/3454.rs diff --git a/gcc/testsuite/rust/compile/issue-3524.rs b/gcc/testsuite/rust/compile/issues/3524.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3524.rs rename to gcc/testsuite/rust/compile/issues/3524.rs diff --git a/gcc/testsuite/rust/compile/issue-3525.rs b/gcc/testsuite/rust/compile/issues/3525.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3525.rs rename to gcc/testsuite/rust/compile/issues/3525.rs diff --git a/gcc/testsuite/rust/compile/issue-3530-1.rs b/gcc/testsuite/rust/compile/issues/3530-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3530-1.rs rename to gcc/testsuite/rust/compile/issues/3530-1.rs diff --git a/gcc/testsuite/rust/compile/issue-3530-2.rs b/gcc/testsuite/rust/compile/issues/3530-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3530-2.rs rename to gcc/testsuite/rust/compile/issues/3530-2.rs diff --git a/gcc/testsuite/rust/compile/issue-3537.rs b/gcc/testsuite/rust/compile/issues/3537.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3537.rs rename to gcc/testsuite/rust/compile/issues/3537.rs diff --git a/gcc/testsuite/rust/compile/issue-3538.rs b/gcc/testsuite/rust/compile/issues/3538.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3538.rs rename to gcc/testsuite/rust/compile/issues/3538.rs diff --git a/gcc/testsuite/rust/compile/issue-3541-1.rs b/gcc/testsuite/rust/compile/issues/3541-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3541-1.rs rename to gcc/testsuite/rust/compile/issues/3541-1.rs diff --git a/gcc/testsuite/rust/compile/issue-3541-2.rs b/gcc/testsuite/rust/compile/issues/3541-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3541-2.rs rename to gcc/testsuite/rust/compile/issues/3541-2.rs diff --git a/gcc/testsuite/rust/compile/issue-3546.rs b/gcc/testsuite/rust/compile/issues/3546.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3546.rs rename to gcc/testsuite/rust/compile/issues/3546.rs diff --git a/gcc/testsuite/rust/compile/issue-3549.rs b/gcc/testsuite/rust/compile/issues/3549.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3549.rs rename to gcc/testsuite/rust/compile/issues/3549.rs diff --git a/gcc/testsuite/rust/compile/issue-3550.rs b/gcc/testsuite/rust/compile/issues/3550.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3550.rs rename to gcc/testsuite/rust/compile/issues/3550.rs diff --git a/gcc/testsuite/rust/compile/issue-3551.rs b/gcc/testsuite/rust/compile/issues/3551.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3551.rs rename to gcc/testsuite/rust/compile/issues/3551.rs diff --git a/gcc/testsuite/rust/compile/issue-3552.rs b/gcc/testsuite/rust/compile/issues/3552.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3552.rs rename to gcc/testsuite/rust/compile/issues/3552.rs diff --git a/gcc/testsuite/rust/compile/issue-3553.rs b/gcc/testsuite/rust/compile/issues/3553.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3553.rs rename to gcc/testsuite/rust/compile/issues/3553.rs diff --git a/gcc/testsuite/rust/compile/issue-3554-1.rs b/gcc/testsuite/rust/compile/issues/3554-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3554-1.rs rename to gcc/testsuite/rust/compile/issues/3554-1.rs diff --git a/gcc/testsuite/rust/compile/issue-3554-2.rs b/gcc/testsuite/rust/compile/issues/3554-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3554-2.rs rename to gcc/testsuite/rust/compile/issues/3554-2.rs diff --git a/gcc/testsuite/rust/compile/issue-3555.rs b/gcc/testsuite/rust/compile/issues/3555.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3555.rs rename to gcc/testsuite/rust/compile/issues/3555.rs diff --git a/gcc/testsuite/rust/compile/issue-3556.rs b/gcc/testsuite/rust/compile/issues/3556.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3556.rs rename to gcc/testsuite/rust/compile/issues/3556.rs diff --git a/gcc/testsuite/rust/compile/issue-3563.rs b/gcc/testsuite/rust/compile/issues/3563.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3563.rs rename to gcc/testsuite/rust/compile/issues/3563.rs diff --git a/gcc/testsuite/rust/compile/issue-3566-1.rs b/gcc/testsuite/rust/compile/issues/3566-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3566-1.rs rename to gcc/testsuite/rust/compile/issues/3566-1.rs diff --git a/gcc/testsuite/rust/compile/issue-3566-2.rs b/gcc/testsuite/rust/compile/issues/3566-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3566-2.rs rename to gcc/testsuite/rust/compile/issues/3566-2.rs diff --git a/gcc/testsuite/rust/compile/issue-3567.rs b/gcc/testsuite/rust/compile/issues/3567.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3567.rs rename to gcc/testsuite/rust/compile/issues/3567.rs diff --git a/gcc/testsuite/rust/compile/issue-3568.rs b/gcc/testsuite/rust/compile/issues/3568.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3568.rs rename to gcc/testsuite/rust/compile/issues/3568.rs diff --git a/gcc/testsuite/rust/compile/issue-3581-1.rs b/gcc/testsuite/rust/compile/issues/3581-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3581-1.rs rename to gcc/testsuite/rust/compile/issues/3581-1.rs diff --git a/gcc/testsuite/rust/compile/issue-3581-2.rs b/gcc/testsuite/rust/compile/issues/3581-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3581-2.rs rename to gcc/testsuite/rust/compile/issues/3581-2.rs diff --git a/gcc/testsuite/rust/compile/issue-3585-1.rs b/gcc/testsuite/rust/compile/issues/3585-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3585-1.rs rename to gcc/testsuite/rust/compile/issues/3585-1.rs diff --git a/gcc/testsuite/rust/compile/issue-3585-2.rs b/gcc/testsuite/rust/compile/issues/3585-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3585-2.rs rename to gcc/testsuite/rust/compile/issues/3585-2.rs diff --git a/gcc/testsuite/rust/compile/issue-3588.rs b/gcc/testsuite/rust/compile/issues/3588.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3588.rs rename to gcc/testsuite/rust/compile/issues/3588.rs diff --git a/gcc/testsuite/rust/compile/issue-3591.rs b/gcc/testsuite/rust/compile/issues/3591.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3591.rs rename to gcc/testsuite/rust/compile/issues/3591.rs diff --git a/gcc/testsuite/rust/compile/issue-3592.rs b/gcc/testsuite/rust/compile/issues/3592.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3592.rs rename to gcc/testsuite/rust/compile/issues/3592.rs diff --git a/gcc/testsuite/rust/compile/issue-3597.rs b/gcc/testsuite/rust/compile/issues/3597.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3597.rs rename to gcc/testsuite/rust/compile/issues/3597.rs diff --git a/gcc/testsuite/rust/compile/issue-3599.rs b/gcc/testsuite/rust/compile/issues/3599.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3599.rs rename to gcc/testsuite/rust/compile/issues/3599.rs diff --git a/gcc/testsuite/rust/compile/issue-3605.rs b/gcc/testsuite/rust/compile/issues/3605.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3605.rs rename to gcc/testsuite/rust/compile/issues/3605.rs diff --git a/gcc/testsuite/rust/compile/issue-3606.rs b/gcc/testsuite/rust/compile/issues/3606.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3606.rs rename to gcc/testsuite/rust/compile/issues/3606.rs diff --git a/gcc/testsuite/rust/compile/issue-3612.rs b/gcc/testsuite/rust/compile/issues/3612.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3612.rs rename to gcc/testsuite/rust/compile/issues/3612.rs diff --git a/gcc/testsuite/rust/compile/issue-3613.rs b/gcc/testsuite/rust/compile/issues/3613.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3613.rs rename to gcc/testsuite/rust/compile/issues/3613.rs diff --git a/gcc/testsuite/rust/compile/issue-3614.rs b/gcc/testsuite/rust/compile/issues/3614.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3614.rs rename to gcc/testsuite/rust/compile/issues/3614.rs diff --git a/gcc/testsuite/rust/compile/issue-3615.rs b/gcc/testsuite/rust/compile/issues/3615.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3615.rs rename to gcc/testsuite/rust/compile/issues/3615.rs diff --git a/gcc/testsuite/rust/compile/issue-3617.rs b/gcc/testsuite/rust/compile/issues/3617.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3617.rs rename to gcc/testsuite/rust/compile/issues/3617.rs diff --git a/gcc/testsuite/rust/compile/issue-3618.rs b/gcc/testsuite/rust/compile/issues/3618.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3618.rs rename to gcc/testsuite/rust/compile/issues/3618.rs diff --git a/gcc/testsuite/rust/compile/issue-3625.rs b/gcc/testsuite/rust/compile/issues/3625.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3625.rs rename to gcc/testsuite/rust/compile/issues/3625.rs diff --git a/gcc/testsuite/rust/compile/issue-3628.rs b/gcc/testsuite/rust/compile/issues/3628.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3628.rs rename to gcc/testsuite/rust/compile/issues/3628.rs diff --git a/gcc/testsuite/rust/compile/issue-3642.rs b/gcc/testsuite/rust/compile/issues/3642.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3642.rs rename to gcc/testsuite/rust/compile/issues/3642.rs diff --git a/gcc/testsuite/rust/compile/issue-3643.rs b/gcc/testsuite/rust/compile/issues/3643.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3643.rs rename to gcc/testsuite/rust/compile/issues/3643.rs diff --git a/gcc/testsuite/rust/compile/issue-3645.rs b/gcc/testsuite/rust/compile/issues/3645.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3645.rs rename to gcc/testsuite/rust/compile/issues/3645.rs diff --git a/gcc/testsuite/rust/compile/issue-3646.rs b/gcc/testsuite/rust/compile/issues/3646.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3646.rs rename to gcc/testsuite/rust/compile/issues/3646.rs diff --git a/gcc/testsuite/rust/compile/issue-3647.rs b/gcc/testsuite/rust/compile/issues/3647.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3647.rs rename to gcc/testsuite/rust/compile/issues/3647.rs diff --git a/gcc/testsuite/rust/compile/issue-3648.rs b/gcc/testsuite/rust/compile/issues/3648.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3648.rs rename to gcc/testsuite/rust/compile/issues/3648.rs diff --git a/gcc/testsuite/rust/compile/issue-3649.rs b/gcc/testsuite/rust/compile/issues/3649.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3649.rs rename to gcc/testsuite/rust/compile/issues/3649.rs diff --git a/gcc/testsuite/rust/compile/issue-3651.rs b/gcc/testsuite/rust/compile/issues/3651.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3651.rs rename to gcc/testsuite/rust/compile/issues/3651.rs diff --git a/gcc/testsuite/rust/compile/issue-3652.rs b/gcc/testsuite/rust/compile/issues/3652.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3652.rs rename to gcc/testsuite/rust/compile/issues/3652.rs diff --git a/gcc/testsuite/rust/compile/issue-3654.rs b/gcc/testsuite/rust/compile/issues/3654.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3654.rs rename to gcc/testsuite/rust/compile/issues/3654.rs diff --git a/gcc/testsuite/rust/compile/issue-3656.rs b/gcc/testsuite/rust/compile/issues/3656.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3656.rs rename to gcc/testsuite/rust/compile/issues/3656.rs diff --git a/gcc/testsuite/rust/compile/issue-3657.rs b/gcc/testsuite/rust/compile/issues/3657.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3657.rs rename to gcc/testsuite/rust/compile/issues/3657.rs diff --git a/gcc/testsuite/rust/compile/issue-3659.rs b/gcc/testsuite/rust/compile/issues/3659.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3659.rs rename to gcc/testsuite/rust/compile/issues/3659.rs diff --git a/gcc/testsuite/rust/compile/issue-3660.rs b/gcc/testsuite/rust/compile/issues/3660.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3660.rs rename to gcc/testsuite/rust/compile/issues/3660.rs diff --git a/gcc/testsuite/rust/compile/issue-3661.rs b/gcc/testsuite/rust/compile/issues/3661.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3661.rs rename to gcc/testsuite/rust/compile/issues/3661.rs diff --git a/gcc/testsuite/rust/compile/issue-3662.rs b/gcc/testsuite/rust/compile/issues/3662.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3662.rs rename to gcc/testsuite/rust/compile/issues/3662.rs diff --git a/gcc/testsuite/rust/compile/issue-3663.rs b/gcc/testsuite/rust/compile/issues/3663.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3663.rs rename to gcc/testsuite/rust/compile/issues/3663.rs diff --git a/gcc/testsuite/rust/compile/issue-3664.rs b/gcc/testsuite/rust/compile/issues/3664.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3664.rs rename to gcc/testsuite/rust/compile/issues/3664.rs diff --git a/gcc/testsuite/rust/compile/issue-3665.rs b/gcc/testsuite/rust/compile/issues/3665.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3665.rs rename to gcc/testsuite/rust/compile/issues/3665.rs diff --git a/gcc/testsuite/rust/compile/issue-3667.rs b/gcc/testsuite/rust/compile/issues/3667.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3667.rs rename to gcc/testsuite/rust/compile/issues/3667.rs diff --git a/gcc/testsuite/rust/compile/issue-3670.rs b/gcc/testsuite/rust/compile/issues/3670.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3670.rs rename to gcc/testsuite/rust/compile/issues/3670.rs diff --git a/gcc/testsuite/rust/compile/issue-3671.rs b/gcc/testsuite/rust/compile/issues/3671.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3671.rs rename to gcc/testsuite/rust/compile/issues/3671.rs diff --git a/gcc/testsuite/rust/compile/issue-3672.rs b/gcc/testsuite/rust/compile/issues/3672.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3672.rs rename to gcc/testsuite/rust/compile/issues/3672.rs diff --git a/gcc/testsuite/rust/compile/issue-3711.rs b/gcc/testsuite/rust/compile/issues/3711.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3711.rs rename to gcc/testsuite/rust/compile/issues/3711.rs diff --git a/gcc/testsuite/rust/compile/issue-3726.rs b/gcc/testsuite/rust/compile/issues/3726.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3726.rs rename to gcc/testsuite/rust/compile/issues/3726.rs diff --git a/gcc/testsuite/rust/compile/issue-3836.rs b/gcc/testsuite/rust/compile/issues/3836.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3836.rs rename to gcc/testsuite/rust/compile/issues/3836.rs diff --git a/gcc/testsuite/rust/compile/issue-3874.rs b/gcc/testsuite/rust/compile/issues/3874.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3874.rs rename to gcc/testsuite/rust/compile/issues/3874.rs diff --git a/gcc/testsuite/rust/compile/issue-3875.rs b/gcc/testsuite/rust/compile/issues/3875.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3875.rs rename to gcc/testsuite/rust/compile/issues/3875.rs diff --git a/gcc/testsuite/rust/compile/issue-3876.rs b/gcc/testsuite/rust/compile/issues/3876.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3876.rs rename to gcc/testsuite/rust/compile/issues/3876.rs diff --git a/gcc/testsuite/rust/compile/issue-3885.rs b/gcc/testsuite/rust/compile/issues/3885.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3885.rs rename to gcc/testsuite/rust/compile/issues/3885.rs diff --git a/gcc/testsuite/rust/compile/issue-3898.rs b/gcc/testsuite/rust/compile/issues/3898.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3898.rs rename to gcc/testsuite/rust/compile/issues/3898.rs diff --git a/gcc/testsuite/rust/compile/issue-3904.rs b/gcc/testsuite/rust/compile/issues/3904.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3904.rs rename to gcc/testsuite/rust/compile/issues/3904.rs diff --git a/gcc/testsuite/rust/compile/issue-3910.rs b/gcc/testsuite/rust/compile/issues/3910.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3910.rs rename to gcc/testsuite/rust/compile/issues/3910.rs diff --git a/gcc/testsuite/rust/compile/issue-3915.rs b/gcc/testsuite/rust/compile/issues/3915.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3915.rs rename to gcc/testsuite/rust/compile/issues/3915.rs diff --git a/gcc/testsuite/rust/compile/issue-3916.rs b/gcc/testsuite/rust/compile/issues/3916.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3916.rs rename to gcc/testsuite/rust/compile/issues/3916.rs diff --git a/gcc/testsuite/rust/compile/issue-3919-ice-func-parms.rs b/gcc/testsuite/rust/compile/issues/3919-ice-func-parms.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3919-ice-func-parms.rs rename to gcc/testsuite/rust/compile/issues/3919-ice-func-parms.rs diff --git a/gcc/testsuite/rust/compile/issue-3922.rs b/gcc/testsuite/rust/compile/issues/3922.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3922.rs rename to gcc/testsuite/rust/compile/issues/3922.rs diff --git a/gcc/testsuite/rust/compile/issue-3924.rs b/gcc/testsuite/rust/compile/issues/3924.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3924.rs rename to gcc/testsuite/rust/compile/issues/3924.rs diff --git a/gcc/testsuite/rust/compile/issue-3928.rs b/gcc/testsuite/rust/compile/issues/3928.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3928.rs rename to gcc/testsuite/rust/compile/issues/3928.rs diff --git a/gcc/testsuite/rust/compile/issue-3929-1.rs b/gcc/testsuite/rust/compile/issues/3929-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3929-1.rs rename to gcc/testsuite/rust/compile/issues/3929-1.rs diff --git a/gcc/testsuite/rust/compile/issue-3929-2.rs b/gcc/testsuite/rust/compile/issues/3929-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3929-2.rs rename to gcc/testsuite/rust/compile/issues/3929-2.rs diff --git a/gcc/testsuite/rust/compile/issue-3930.rs b/gcc/testsuite/rust/compile/issues/3930.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3930.rs rename to gcc/testsuite/rust/compile/issues/3930.rs diff --git a/gcc/testsuite/rust/compile/issue-3931.rs b/gcc/testsuite/rust/compile/issues/3931.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3931.rs rename to gcc/testsuite/rust/compile/issues/3931.rs diff --git a/gcc/testsuite/rust/compile/issue-3947.rs b/gcc/testsuite/rust/compile/issues/3947.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3947.rs rename to gcc/testsuite/rust/compile/issues/3947.rs diff --git a/gcc/testsuite/rust/compile/issue-3951.rs b/gcc/testsuite/rust/compile/issues/3951.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3951.rs rename to gcc/testsuite/rust/compile/issues/3951.rs diff --git a/gcc/testsuite/rust/compile/issue-3958.rs b/gcc/testsuite/rust/compile/issues/3958.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3958.rs rename to gcc/testsuite/rust/compile/issues/3958.rs diff --git a/gcc/testsuite/rust/compile/issue-3960.rs b/gcc/testsuite/rust/compile/issues/3960.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3960.rs rename to gcc/testsuite/rust/compile/issues/3960.rs diff --git a/gcc/testsuite/rust/compile/issue-3965-1.rs b/gcc/testsuite/rust/compile/issues/3965-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3965-1.rs rename to gcc/testsuite/rust/compile/issues/3965-1.rs diff --git a/gcc/testsuite/rust/compile/issue-3965-2.rs b/gcc/testsuite/rust/compile/issues/3965-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3965-2.rs rename to gcc/testsuite/rust/compile/issues/3965-2.rs diff --git a/gcc/testsuite/rust/compile/issue-3966.rs b/gcc/testsuite/rust/compile/issues/3966.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3966.rs rename to gcc/testsuite/rust/compile/issues/3966.rs diff --git a/gcc/testsuite/rust/compile/issue-3969.rs b/gcc/testsuite/rust/compile/issues/3969.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3969.rs rename to gcc/testsuite/rust/compile/issues/3969.rs diff --git a/gcc/testsuite/rust/compile/issue-3971.rs b/gcc/testsuite/rust/compile/issues/3971.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3971.rs rename to gcc/testsuite/rust/compile/issues/3971.rs diff --git a/gcc/testsuite/rust/compile/issue-3972.rs b/gcc/testsuite/rust/compile/issues/3972.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3972.rs rename to gcc/testsuite/rust/compile/issues/3972.rs diff --git a/gcc/testsuite/rust/compile/issue-3974.rs b/gcc/testsuite/rust/compile/issues/3974.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3974.rs rename to gcc/testsuite/rust/compile/issues/3974.rs diff --git a/gcc/testsuite/rust/compile/issue-3977.rs b/gcc/testsuite/rust/compile/issues/3977.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3977.rs rename to gcc/testsuite/rust/compile/issues/3977.rs diff --git a/gcc/testsuite/rust/compile/issue-3978.rs b/gcc/testsuite/rust/compile/issues/3978.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-3978.rs rename to gcc/testsuite/rust/compile/issues/3978.rs diff --git a/gcc/testsuite/rust/compile/issue-4006.rs b/gcc/testsuite/rust/compile/issues/4006.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4006.rs rename to gcc/testsuite/rust/compile/issues/4006.rs diff --git a/gcc/testsuite/rust/compile/issue-402.rs b/gcc/testsuite/rust/compile/issues/402.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-402.rs rename to gcc/testsuite/rust/compile/issues/402.rs diff --git a/gcc/testsuite/rust/compile/issue-407-2.rs b/gcc/testsuite/rust/compile/issues/407-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-407-2.rs rename to gcc/testsuite/rust/compile/issues/407-2.rs diff --git a/gcc/testsuite/rust/compile/issue-407.rs b/gcc/testsuite/rust/compile/issues/407.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-407.rs rename to gcc/testsuite/rust/compile/issues/407.rs diff --git a/gcc/testsuite/rust/compile/issue-4090-1.rs b/gcc/testsuite/rust/compile/issues/4090-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4090-1.rs rename to gcc/testsuite/rust/compile/issues/4090-1.rs diff --git a/gcc/testsuite/rust/compile/issue-4090-2.rs b/gcc/testsuite/rust/compile/issues/4090-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4090-2.rs rename to gcc/testsuite/rust/compile/issues/4090-2.rs diff --git a/gcc/testsuite/rust/compile/issue-4116.rs b/gcc/testsuite/rust/compile/issues/4116.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4116.rs rename to gcc/testsuite/rust/compile/issues/4116.rs diff --git a/gcc/testsuite/rust/compile/issue-4139.rs b/gcc/testsuite/rust/compile/issues/4139.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4139.rs rename to gcc/testsuite/rust/compile/issues/4139.rs diff --git a/gcc/testsuite/rust/compile/issue-4140-1.rs b/gcc/testsuite/rust/compile/issues/4140-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4140-1.rs rename to gcc/testsuite/rust/compile/issues/4140-1.rs diff --git a/gcc/testsuite/rust/compile/issue-4140-2.rs b/gcc/testsuite/rust/compile/issues/4140-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4140-2.rs rename to gcc/testsuite/rust/compile/issues/4140-2.rs diff --git a/gcc/testsuite/rust/compile/issue-4145.rs b/gcc/testsuite/rust/compile/issues/4145.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4145.rs rename to gcc/testsuite/rust/compile/issues/4145.rs diff --git a/gcc/testsuite/rust/compile/issue-4146.rs b/gcc/testsuite/rust/compile/issues/4146.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4146.rs rename to gcc/testsuite/rust/compile/issues/4146.rs diff --git a/gcc/testsuite/rust/compile/issue-4148.rs b/gcc/testsuite/rust/compile/issues/4148.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4148.rs rename to gcc/testsuite/rust/compile/issues/4148.rs diff --git a/gcc/testsuite/rust/compile/issue-4155.rs b/gcc/testsuite/rust/compile/issues/4155.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4155.rs rename to gcc/testsuite/rust/compile/issues/4155.rs diff --git a/gcc/testsuite/rust/compile/issue-4157-1.rs b/gcc/testsuite/rust/compile/issues/4157-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4157-1.rs rename to gcc/testsuite/rust/compile/issues/4157-1.rs diff --git a/gcc/testsuite/rust/compile/issue-4157-2.rs b/gcc/testsuite/rust/compile/issues/4157-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4157-2.rs rename to gcc/testsuite/rust/compile/issues/4157-2.rs diff --git a/gcc/testsuite/rust/compile/issue-4158.rs b/gcc/testsuite/rust/compile/issues/4158.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4158.rs rename to gcc/testsuite/rust/compile/issues/4158.rs diff --git a/gcc/testsuite/rust/compile/issue-4159.rs b/gcc/testsuite/rust/compile/issues/4159.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4159.rs rename to gcc/testsuite/rust/compile/issues/4159.rs diff --git a/gcc/testsuite/rust/compile/issue-4162.rs b/gcc/testsuite/rust/compile/issues/4162.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4162.rs rename to gcc/testsuite/rust/compile/issues/4162.rs diff --git a/gcc/testsuite/rust/compile/issue-4163-2.rs b/gcc/testsuite/rust/compile/issues/4163-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4163-2.rs rename to gcc/testsuite/rust/compile/issues/4163-2.rs diff --git a/gcc/testsuite/rust/compile/issue-4163.rs b/gcc/testsuite/rust/compile/issues/4163.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4163.rs rename to gcc/testsuite/rust/compile/issues/4163.rs diff --git a/gcc/testsuite/rust/compile/issue-4165.rs b/gcc/testsuite/rust/compile/issues/4165.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4165.rs rename to gcc/testsuite/rust/compile/issues/4165.rs diff --git a/gcc/testsuite/rust/compile/issue-4166.rs b/gcc/testsuite/rust/compile/issues/4166.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4166.rs rename to gcc/testsuite/rust/compile/issues/4166.rs diff --git a/gcc/testsuite/rust/compile/issue-4167.rs b/gcc/testsuite/rust/compile/issues/4167.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4167.rs rename to gcc/testsuite/rust/compile/issues/4167.rs diff --git a/gcc/testsuite/rust/compile/issue-4168.rs b/gcc/testsuite/rust/compile/issues/4168.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4168.rs rename to gcc/testsuite/rust/compile/issues/4168.rs diff --git a/gcc/testsuite/rust/compile/issue-4173-1.rs b/gcc/testsuite/rust/compile/issues/4173-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4173-1.rs rename to gcc/testsuite/rust/compile/issues/4173-1.rs diff --git a/gcc/testsuite/rust/compile/issue-4173-2.rs b/gcc/testsuite/rust/compile/issues/4173-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4173-2.rs rename to gcc/testsuite/rust/compile/issues/4173-2.rs diff --git a/gcc/testsuite/rust/compile/issue-4173-3.rs b/gcc/testsuite/rust/compile/issues/4173-3.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4173-3.rs rename to gcc/testsuite/rust/compile/issues/4173-3.rs diff --git a/gcc/testsuite/rust/compile/issue-4188.rs b/gcc/testsuite/rust/compile/issues/4188.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4188.rs rename to gcc/testsuite/rust/compile/issues/4188.rs diff --git a/gcc/testsuite/rust/compile/issue-4212.rs b/gcc/testsuite/rust/compile/issues/4212.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4212.rs rename to gcc/testsuite/rust/compile/issues/4212.rs diff --git a/gcc/testsuite/rust/compile/issue-4213.rs b/gcc/testsuite/rust/compile/issues/4213.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4213.rs rename to gcc/testsuite/rust/compile/issues/4213.rs diff --git a/gcc/testsuite/rust/compile/issue-4219.rs b/gcc/testsuite/rust/compile/issues/4219.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4219.rs rename to gcc/testsuite/rust/compile/issues/4219.rs diff --git a/gcc/testsuite/rust/compile/issue-4222.rs b/gcc/testsuite/rust/compile/issues/4222.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4222.rs rename to gcc/testsuite/rust/compile/issues/4222.rs diff --git a/gcc/testsuite/rust/compile/issue-4225.rs b/gcc/testsuite/rust/compile/issues/4225.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4225.rs rename to gcc/testsuite/rust/compile/issues/4225.rs diff --git a/gcc/testsuite/rust/compile/issue-4226.rs b/gcc/testsuite/rust/compile/issues/4226.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4226.rs rename to gcc/testsuite/rust/compile/issues/4226.rs diff --git a/gcc/testsuite/rust/compile/issue-4231.rs b/gcc/testsuite/rust/compile/issues/4231.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4231.rs rename to gcc/testsuite/rust/compile/issues/4231.rs diff --git a/gcc/testsuite/rust/compile/issue-4232.rs b/gcc/testsuite/rust/compile/issues/4232.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4232.rs rename to gcc/testsuite/rust/compile/issues/4232.rs diff --git a/gcc/testsuite/rust/compile/issue-4234.rs b/gcc/testsuite/rust/compile/issues/4234.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4234.rs rename to gcc/testsuite/rust/compile/issues/4234.rs diff --git a/gcc/testsuite/rust/compile/issue-4235.rs b/gcc/testsuite/rust/compile/issues/4235.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4235.rs rename to gcc/testsuite/rust/compile/issues/4235.rs diff --git a/gcc/testsuite/rust/compile/issue-4242.rs b/gcc/testsuite/rust/compile/issues/4242.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4242.rs rename to gcc/testsuite/rust/compile/issues/4242.rs diff --git a/gcc/testsuite/rust/compile/issue-4245.rs b/gcc/testsuite/rust/compile/issues/4245.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4245.rs rename to gcc/testsuite/rust/compile/issues/4245.rs diff --git a/gcc/testsuite/rust/compile/issue-4260_0.rs b/gcc/testsuite/rust/compile/issues/4260_0.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4260_0.rs rename to gcc/testsuite/rust/compile/issues/4260_0.rs diff --git a/gcc/testsuite/rust/compile/issue-4261.rs b/gcc/testsuite/rust/compile/issues/4261.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4261.rs rename to gcc/testsuite/rust/compile/issues/4261.rs diff --git a/gcc/testsuite/rust/compile/issue-4262.rs b/gcc/testsuite/rust/compile/issues/4262.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4262.rs rename to gcc/testsuite/rust/compile/issues/4262.rs diff --git a/gcc/testsuite/rust/compile/issue-4267.rs b/gcc/testsuite/rust/compile/issues/4267.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4267.rs rename to gcc/testsuite/rust/compile/issues/4267.rs diff --git a/gcc/testsuite/rust/compile/issue-4293.rs b/gcc/testsuite/rust/compile/issues/4293.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4293.rs rename to gcc/testsuite/rust/compile/issues/4293.rs diff --git a/gcc/testsuite/rust/compile/issue-4301.rs b/gcc/testsuite/rust/compile/issues/4301.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4301.rs rename to gcc/testsuite/rust/compile/issues/4301.rs diff --git a/gcc/testsuite/rust/compile/issue-4302.rs b/gcc/testsuite/rust/compile/issues/4302.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4302.rs rename to gcc/testsuite/rust/compile/issues/4302.rs diff --git a/gcc/testsuite/rust/compile/issue-4375-ice-regression.rs b/gcc/testsuite/rust/compile/issues/4375-ice-regression.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4375-ice-regression.rs rename to gcc/testsuite/rust/compile/issues/4375-ice-regression.rs diff --git a/gcc/testsuite/rust/compile/issue-4375-multiple-errors.rs b/gcc/testsuite/rust/compile/issues/4375-multiple-errors.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4375-multiple-errors.rs rename to gcc/testsuite/rust/compile/issues/4375-multiple-errors.rs diff --git a/gcc/testsuite/rust/compile/issue-4375-tuple-pattern.rs b/gcc/testsuite/rust/compile/issues/4375-tuple-pattern.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4375-tuple-pattern.rs rename to gcc/testsuite/rust/compile/issues/4375-tuple-pattern.rs diff --git a/gcc/testsuite/rust/compile/issue-4387.rs b/gcc/testsuite/rust/compile/issues/4387.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4387.rs rename to gcc/testsuite/rust/compile/issues/4387.rs diff --git a/gcc/testsuite/rust/compile/issue-4388.rs b/gcc/testsuite/rust/compile/issues/4388.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4388.rs rename to gcc/testsuite/rust/compile/issues/4388.rs diff --git a/gcc/testsuite/rust/compile/issue-4402.rs b/gcc/testsuite/rust/compile/issues/4402.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4402.rs rename to gcc/testsuite/rust/compile/issues/4402.rs diff --git a/gcc/testsuite/rust/compile/issue-4410.rs b/gcc/testsuite/rust/compile/issues/4410.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4410.rs rename to gcc/testsuite/rust/compile/issues/4410.rs diff --git a/gcc/testsuite/rust/compile/issue-4411.rs b/gcc/testsuite/rust/compile/issues/4411.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4411.rs rename to gcc/testsuite/rust/compile/issues/4411.rs diff --git a/gcc/testsuite/rust/compile/issue-4412.rs b/gcc/testsuite/rust/compile/issues/4412.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4412.rs rename to gcc/testsuite/rust/compile/issues/4412.rs diff --git a/gcc/testsuite/rust/compile/issue-4413.rs b/gcc/testsuite/rust/compile/issues/4413.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4413.rs rename to gcc/testsuite/rust/compile/issues/4413.rs diff --git a/gcc/testsuite/rust/compile/issue-4414.rs b/gcc/testsuite/rust/compile/issues/4414.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4414.rs rename to gcc/testsuite/rust/compile/issues/4414.rs diff --git a/gcc/testsuite/rust/compile/issue-4433.rs b/gcc/testsuite/rust/compile/issues/4433.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4433.rs rename to gcc/testsuite/rust/compile/issues/4433.rs diff --git a/gcc/testsuite/rust/compile/issue-4471-1.rs b/gcc/testsuite/rust/compile/issues/4471-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4471-1.rs rename to gcc/testsuite/rust/compile/issues/4471-1.rs diff --git a/gcc/testsuite/rust/compile/issue-4471-2.rs b/gcc/testsuite/rust/compile/issues/4471-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4471-2.rs rename to gcc/testsuite/rust/compile/issues/4471-2.rs diff --git a/gcc/testsuite/rust/compile/issue-4476.rs b/gcc/testsuite/rust/compile/issues/4476.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4476.rs rename to gcc/testsuite/rust/compile/issues/4476.rs diff --git a/gcc/testsuite/rust/compile/issue-4481.rs b/gcc/testsuite/rust/compile/issues/4481.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4481.rs rename to gcc/testsuite/rust/compile/issues/4481.rs diff --git a/gcc/testsuite/rust/compile/issue-4486-1.rs b/gcc/testsuite/rust/compile/issues/4486-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4486-1.rs rename to gcc/testsuite/rust/compile/issues/4486-1.rs diff --git a/gcc/testsuite/rust/compile/issue-4486-2.rs b/gcc/testsuite/rust/compile/issues/4486-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4486-2.rs rename to gcc/testsuite/rust/compile/issues/4486-2.rs diff --git a/gcc/testsuite/rust/compile/issue-4517.rs b/gcc/testsuite/rust/compile/issues/4517.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4517.rs rename to gcc/testsuite/rust/compile/issues/4517.rs diff --git a/gcc/testsuite/rust/compile/issue-4538.rs b/gcc/testsuite/rust/compile/issues/4538.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4538.rs rename to gcc/testsuite/rust/compile/issues/4538.rs diff --git a/gcc/testsuite/rust/compile/issue-4563.rs b/gcc/testsuite/rust/compile/issues/4563.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4563.rs rename to gcc/testsuite/rust/compile/issues/4563.rs diff --git a/gcc/testsuite/rust/compile/issue-4592.rs b/gcc/testsuite/rust/compile/issues/4592.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4592.rs rename to gcc/testsuite/rust/compile/issues/4592.rs diff --git a/gcc/testsuite/rust/compile/issue-4617.rs b/gcc/testsuite/rust/compile/issues/4617.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4617.rs rename to gcc/testsuite/rust/compile/issues/4617.rs diff --git a/gcc/testsuite/rust/compile/issue-4631.rs b/gcc/testsuite/rust/compile/issues/4631.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4631.rs rename to gcc/testsuite/rust/compile/issues/4631.rs diff --git a/gcc/testsuite/rust/compile/issue-4674.rs b/gcc/testsuite/rust/compile/issues/4674.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4674.rs rename to gcc/testsuite/rust/compile/issues/4674.rs diff --git a/gcc/testsuite/rust/compile/issue-4678.rs b/gcc/testsuite/rust/compile/issues/4678.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4678.rs rename to gcc/testsuite/rust/compile/issues/4678.rs diff --git a/gcc/testsuite/rust/compile/issue-4689-1.rs b/gcc/testsuite/rust/compile/issues/4689-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4689-1.rs rename to gcc/testsuite/rust/compile/issues/4689-1.rs diff --git a/gcc/testsuite/rust/compile/issue-4689-2.rs b/gcc/testsuite/rust/compile/issues/4689-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4689-2.rs rename to gcc/testsuite/rust/compile/issues/4689-2.rs diff --git a/gcc/testsuite/rust/compile/issue-4735.rs b/gcc/testsuite/rust/compile/issues/4735.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4735.rs rename to gcc/testsuite/rust/compile/issues/4735.rs diff --git a/gcc/testsuite/rust/compile/issue-4740.rs b/gcc/testsuite/rust/compile/issues/4740.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4740.rs rename to gcc/testsuite/rust/compile/issues/4740.rs diff --git a/gcc/testsuite/rust/compile/issue-4747.rs b/gcc/testsuite/rust/compile/issues/4747.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4747.rs rename to gcc/testsuite/rust/compile/issues/4747.rs diff --git a/gcc/testsuite/rust/compile/issue-4794.rs b/gcc/testsuite/rust/compile/issues/4794.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4794.rs rename to gcc/testsuite/rust/compile/issues/4794.rs diff --git a/gcc/testsuite/rust/compile/issue-4805.rs b/gcc/testsuite/rust/compile/issues/4805.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4805.rs rename to gcc/testsuite/rust/compile/issues/4805.rs diff --git a/gcc/testsuite/rust/compile/issue-4812.rs b/gcc/testsuite/rust/compile/issues/4812.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4812.rs rename to gcc/testsuite/rust/compile/issues/4812.rs diff --git a/gcc/testsuite/rust/compile/issue-4822.rs b/gcc/testsuite/rust/compile/issues/4822.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4822.rs rename to gcc/testsuite/rust/compile/issues/4822.rs diff --git a/gcc/testsuite/rust/compile/issue-4823.rs b/gcc/testsuite/rust/compile/issues/4823.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4823.rs rename to gcc/testsuite/rust/compile/issues/4823.rs diff --git a/gcc/testsuite/rust/compile/issue-4828.rs b/gcc/testsuite/rust/compile/issues/4828.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4828.rs rename to gcc/testsuite/rust/compile/issues/4828.rs diff --git a/gcc/testsuite/rust/compile/issue-4829-1.rs b/gcc/testsuite/rust/compile/issues/4829-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4829-1.rs rename to gcc/testsuite/rust/compile/issues/4829-1.rs diff --git a/gcc/testsuite/rust/compile/issue-4829-2.rs b/gcc/testsuite/rust/compile/issues/4829-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4829-2.rs rename to gcc/testsuite/rust/compile/issues/4829-2.rs diff --git a/gcc/testsuite/rust/compile/issue-4851.rs b/gcc/testsuite/rust/compile/issues/4851.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4851.rs rename to gcc/testsuite/rust/compile/issues/4851.rs diff --git a/gcc/testsuite/rust/compile/issue-4853.rs b/gcc/testsuite/rust/compile/issues/4853.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4853.rs rename to gcc/testsuite/rust/compile/issues/4853.rs diff --git a/gcc/testsuite/rust/compile/issue-4855.rs b/gcc/testsuite/rust/compile/issues/4855.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4855.rs rename to gcc/testsuite/rust/compile/issues/4855.rs diff --git a/gcc/testsuite/rust/compile/issue-4858.rs b/gcc/testsuite/rust/compile/issues/4858.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4858.rs rename to gcc/testsuite/rust/compile/issues/4858.rs diff --git a/gcc/testsuite/rust/compile/issue-4859.rs b/gcc/testsuite/rust/compile/issues/4859.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4859.rs rename to gcc/testsuite/rust/compile/issues/4859.rs diff --git a/gcc/testsuite/rust/compile/issue-4860.rs b/gcc/testsuite/rust/compile/issues/4860.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4860.rs rename to gcc/testsuite/rust/compile/issues/4860.rs diff --git a/gcc/testsuite/rust/compile/issue-4861.rs b/gcc/testsuite/rust/compile/issues/4861.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4861.rs rename to gcc/testsuite/rust/compile/issues/4861.rs diff --git a/gcc/testsuite/rust/compile/issue-4862.rs b/gcc/testsuite/rust/compile/issues/4862.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4862.rs rename to gcc/testsuite/rust/compile/issues/4862.rs diff --git a/gcc/testsuite/rust/compile/issue-4863.rs b/gcc/testsuite/rust/compile/issues/4863.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4863.rs rename to gcc/testsuite/rust/compile/issues/4863.rs diff --git a/gcc/testsuite/rust/compile/issue-4864.rs b/gcc/testsuite/rust/compile/issues/4864.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4864.rs rename to gcc/testsuite/rust/compile/issues/4864.rs diff --git a/gcc/testsuite/rust/compile/issue-4867.rs b/gcc/testsuite/rust/compile/issues/4867.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4867.rs rename to gcc/testsuite/rust/compile/issues/4867.rs diff --git a/gcc/testsuite/rust/compile/issue-4879.rs b/gcc/testsuite/rust/compile/issues/4879.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-4879.rs rename to gcc/testsuite/rust/compile/issues/4879.rs diff --git a/gcc/testsuite/rust/compile/issue-557.rs b/gcc/testsuite/rust/compile/issues/557.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-557.rs rename to gcc/testsuite/rust/compile/issues/557.rs diff --git a/gcc/testsuite/rust/compile/issue-635-1.rs b/gcc/testsuite/rust/compile/issues/635-1.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-635-1.rs rename to gcc/testsuite/rust/compile/issues/635-1.rs diff --git a/gcc/testsuite/rust/compile/issue-635-2.rs b/gcc/testsuite/rust/compile/issues/635-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-635-2.rs rename to gcc/testsuite/rust/compile/issues/635-2.rs diff --git a/gcc/testsuite/rust/compile/issue-850.rs b/gcc/testsuite/rust/compile/issues/850.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-850.rs rename to gcc/testsuite/rust/compile/issues/850.rs diff --git a/gcc/testsuite/rust/compile/issue-852.rs b/gcc/testsuite/rust/compile/issues/852.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-852.rs rename to gcc/testsuite/rust/compile/issues/852.rs diff --git a/gcc/testsuite/rust/compile/issue-855.rs b/gcc/testsuite/rust/compile/issues/855.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-855.rs rename to gcc/testsuite/rust/compile/issues/855.rs diff --git a/gcc/testsuite/rust/compile/issue-867.rs b/gcc/testsuite/rust/compile/issues/867.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-867.rs rename to gcc/testsuite/rust/compile/issues/867.rs diff --git a/gcc/testsuite/rust/compile/issue-925.rs b/gcc/testsuite/rust/compile/issues/925.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue-925.rs rename to gcc/testsuite/rust/compile/issues/925.rs diff --git a/gcc/testsuite/rust/compile/empty_file b/gcc/testsuite/rust/compile/issues/empty_file similarity index 100% rename from gcc/testsuite/rust/compile/empty_file rename to gcc/testsuite/rust/compile/issues/empty_file diff --git a/gcc/testsuite/rust/compile/issue_4402_foo.rs b/gcc/testsuite/rust/compile/issues/issue_4402_foo.rs similarity index 100% rename from gcc/testsuite/rust/compile/issue_4402_foo.rs rename to gcc/testsuite/rust/compile/issues/issue_4402_foo.rs diff --git a/gcc/testsuite/rust/compile/issues/issues.exp b/gcc/testsuite/rust/compile/issues/issues.exp new file mode 100644 index 000000000000..ed5c8ea451d8 --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/issues.exp @@ -0,0 +1,35 @@ +# Copyright (C) 2026 Free Software Foundation, Inc. + +# This program 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 of the License, or +# (at your option) any later version. +# +# This program 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 +# . + +# Compile tests, no torture testing. +# +# These tests raise errors in the front end; torture testing doesn't apply. + +# Load support procs. +load_lib rust-dg.exp + +# Initialize `dg'. +dg-init + +# Main loop. +set saved-dg-do-what-default ${dg-do-what-default} + +set dg-do-what-default "compile" +dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.rs]] "" "" +set dg-do-what-default ${saved-dg-do-what-default} + +# All done. +dg-finish From dadc82640aac0a050552932255c359e1d969b6b7 Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Fri, 11 Sep 2026 14:21:29 +0200 Subject: [PATCH 121/584] gccrs: Move torture issue tests to their own directory gcc/testsuite/ChangeLog: * rust/compile/torture/issue-1024.rs: Move to... * rust/compile/torture/issues/1024.rs: ...here. * rust/compile/torture/issue-1075.rs: Move to... * rust/compile/torture/issues/1075.rs: ...here. * rust/compile/torture/issue-1432.rs: Move to... * rust/compile/torture/issues/1432.rs: ...here. * rust/compile/torture/issue-1434.rs: Move to... * rust/compile/torture/issues/1434.rs: ...here. * rust/compile/torture/issue-1506.rs: Move to... * rust/compile/torture/issues/1506.rs: ...here. * rust/compile/torture/issue-1555.rs: Move to... * rust/compile/torture/issues/1555.rs: ...here. * rust/compile/torture/issue-368.rs: Move to... * rust/compile/torture/issues/368.rs: ...here. * rust/compile/torture/issue-808.rs: Move to... * rust/compile/torture/issues/808.rs: ...here. * rust/compile/torture/issue-862.rs: Move to... * rust/compile/torture/issues/862.rs: ...here. * rust/compile/torture/issue-893-2.rs: Move to... * rust/compile/torture/issues/893-2.rs: ...here. * rust/compile/torture/issue-893.rs: Move to... * rust/compile/torture/issues/893.rs: ...here. * rust/compile/torture/issues/issues.exp: Copy DG testsuite file from parent directory. Signed-off-by: Pierre-Emmanuel Patry --- .../torture/{issue-1024.rs => issues/1024.rs} | 0 .../torture/{issue-1075.rs => issues/1075.rs} | 0 .../torture/{issue-1432.rs => issues/1432.rs} | 0 .../torture/{issue-1434.rs => issues/1434.rs} | 0 .../torture/{issue-1506.rs => issues/1506.rs} | 0 .../torture/{issue-1555.rs => issues/1555.rs} | 0 .../torture/{issue-368.rs => issues/368.rs} | 0 .../torture/{issue-808.rs => issues/808.rs} | 0 .../torture/{issue-862.rs => issues/862.rs} | 0 .../{issue-893-2.rs => issues/893-2.rs} | 0 .../torture/{issue-893.rs => issues/893.rs} | 0 .../rust/compile/torture/issues/issues.exp | 33 +++++++++++++++++++ 12 files changed, 33 insertions(+) rename gcc/testsuite/rust/compile/torture/{issue-1024.rs => issues/1024.rs} (100%) rename gcc/testsuite/rust/compile/torture/{issue-1075.rs => issues/1075.rs} (100%) rename gcc/testsuite/rust/compile/torture/{issue-1432.rs => issues/1432.rs} (100%) rename gcc/testsuite/rust/compile/torture/{issue-1434.rs => issues/1434.rs} (100%) rename gcc/testsuite/rust/compile/torture/{issue-1506.rs => issues/1506.rs} (100%) rename gcc/testsuite/rust/compile/torture/{issue-1555.rs => issues/1555.rs} (100%) rename gcc/testsuite/rust/compile/torture/{issue-368.rs => issues/368.rs} (100%) rename gcc/testsuite/rust/compile/torture/{issue-808.rs => issues/808.rs} (100%) rename gcc/testsuite/rust/compile/torture/{issue-862.rs => issues/862.rs} (100%) rename gcc/testsuite/rust/compile/torture/{issue-893-2.rs => issues/893-2.rs} (100%) rename gcc/testsuite/rust/compile/torture/{issue-893.rs => issues/893.rs} (100%) create mode 100644 gcc/testsuite/rust/compile/torture/issues/issues.exp diff --git a/gcc/testsuite/rust/compile/torture/issue-1024.rs b/gcc/testsuite/rust/compile/torture/issues/1024.rs similarity index 100% rename from gcc/testsuite/rust/compile/torture/issue-1024.rs rename to gcc/testsuite/rust/compile/torture/issues/1024.rs diff --git a/gcc/testsuite/rust/compile/torture/issue-1075.rs b/gcc/testsuite/rust/compile/torture/issues/1075.rs similarity index 100% rename from gcc/testsuite/rust/compile/torture/issue-1075.rs rename to gcc/testsuite/rust/compile/torture/issues/1075.rs diff --git a/gcc/testsuite/rust/compile/torture/issue-1432.rs b/gcc/testsuite/rust/compile/torture/issues/1432.rs similarity index 100% rename from gcc/testsuite/rust/compile/torture/issue-1432.rs rename to gcc/testsuite/rust/compile/torture/issues/1432.rs diff --git a/gcc/testsuite/rust/compile/torture/issue-1434.rs b/gcc/testsuite/rust/compile/torture/issues/1434.rs similarity index 100% rename from gcc/testsuite/rust/compile/torture/issue-1434.rs rename to gcc/testsuite/rust/compile/torture/issues/1434.rs diff --git a/gcc/testsuite/rust/compile/torture/issue-1506.rs b/gcc/testsuite/rust/compile/torture/issues/1506.rs similarity index 100% rename from gcc/testsuite/rust/compile/torture/issue-1506.rs rename to gcc/testsuite/rust/compile/torture/issues/1506.rs diff --git a/gcc/testsuite/rust/compile/torture/issue-1555.rs b/gcc/testsuite/rust/compile/torture/issues/1555.rs similarity index 100% rename from gcc/testsuite/rust/compile/torture/issue-1555.rs rename to gcc/testsuite/rust/compile/torture/issues/1555.rs diff --git a/gcc/testsuite/rust/compile/torture/issue-368.rs b/gcc/testsuite/rust/compile/torture/issues/368.rs similarity index 100% rename from gcc/testsuite/rust/compile/torture/issue-368.rs rename to gcc/testsuite/rust/compile/torture/issues/368.rs diff --git a/gcc/testsuite/rust/compile/torture/issue-808.rs b/gcc/testsuite/rust/compile/torture/issues/808.rs similarity index 100% rename from gcc/testsuite/rust/compile/torture/issue-808.rs rename to gcc/testsuite/rust/compile/torture/issues/808.rs diff --git a/gcc/testsuite/rust/compile/torture/issue-862.rs b/gcc/testsuite/rust/compile/torture/issues/862.rs similarity index 100% rename from gcc/testsuite/rust/compile/torture/issue-862.rs rename to gcc/testsuite/rust/compile/torture/issues/862.rs diff --git a/gcc/testsuite/rust/compile/torture/issue-893-2.rs b/gcc/testsuite/rust/compile/torture/issues/893-2.rs similarity index 100% rename from gcc/testsuite/rust/compile/torture/issue-893-2.rs rename to gcc/testsuite/rust/compile/torture/issues/893-2.rs diff --git a/gcc/testsuite/rust/compile/torture/issue-893.rs b/gcc/testsuite/rust/compile/torture/issues/893.rs similarity index 100% rename from gcc/testsuite/rust/compile/torture/issue-893.rs rename to gcc/testsuite/rust/compile/torture/issues/893.rs diff --git a/gcc/testsuite/rust/compile/torture/issues/issues.exp b/gcc/testsuite/rust/compile/torture/issues/issues.exp new file mode 100644 index 000000000000..c6fb3a4e37bb --- /dev/null +++ b/gcc/testsuite/rust/compile/torture/issues/issues.exp @@ -0,0 +1,33 @@ +# Copyright (C) 2026 Free Software Foundation, Inc. + +# This program 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 of the License, or +# (at your option) any later version. +# +# This program 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 +# . + +# Compile tests, torture testing. + +# Load support procs. +load_lib rust-dg.exp + +# Initialize `dg'. +dg-init + +# Main loop. +set saved-dg-do-what-default ${dg-do-what-default} + +set dg-do-what-default "compile" +gcc-dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/*.rs]] "" "" +set dg-do-what-default ${saved-dg-do-what-default} + +# All done. +dg-finish From 5e3c8d672e1d634235f4454a7d61589f91476d97 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 11 Sep 2026 11:47:42 +0100 Subject: [PATCH 122/584] gccrs: remove unused callback substitution system This was old code i used to badly figure out the generics on Index and Iterator traits gcc/rust/ChangeLog: * typecheck/rust-tyty-bounds.cc (TypeBoundPredicate::TypeBoundPredicate): remove. (TypeBoundPredicate::operator=): Likewise. (TypeBoundPredicateItem::get_tyty_for_receiver): Likewise. * typecheck/rust-tyty-subst.cc (SubstitutionArgumentMappings::error): Likewise. (SubstitutionArgumentMappings::empty): Likewise. (SubstitutionArgumentMappings::on_param_subst): Likewise. (SubstitutionArgumentMappings::get_subst_cb): Likewise. * typecheck/rust-tyty-subst.h (std::function --- gcc/rust/typecheck/rust-tyty-bounds.cc | 5 ++- gcc/rust/typecheck/rust-tyty-subst.cc | 49 ++++++++------------------ gcc/rust/typecheck/rust-tyty-subst.h | 10 +----- gcc/rust/typecheck/rust-tyty.cc | 2 -- 4 files changed, 18 insertions(+), 48 deletions(-) diff --git a/gcc/rust/typecheck/rust-tyty-bounds.cc b/gcc/rust/typecheck/rust-tyty-bounds.cc index bb2c5ed14f15..0d762c8c09c1 100644 --- a/gcc/rust/typecheck/rust-tyty-bounds.cc +++ b/gcc/rust/typecheck/rust-tyty-bounds.cc @@ -469,7 +469,7 @@ TypeBoundPredicate::TypeBoundPredicate (const TypeBoundPredicate &other) used_arguments = SubstitutionArgumentMappings ( copied_arg_mappings, other.used_arguments.get_binding_args (), other.used_arguments.get_regions (), other.used_arguments.get_locus (), - nullptr, false, false, other.used_arguments.get_constraint_args ()); + false, false, other.used_arguments.get_constraint_args ()); } TypeBoundPredicate & @@ -502,7 +502,7 @@ TypeBoundPredicate::operator= (const TypeBoundPredicate &other) used_arguments = SubstitutionArgumentMappings ( copied_arg_mappings, other.used_arguments.get_binding_args (), other.used_arguments.get_regions (), other.used_arguments.get_locus (), - nullptr, false, false, other.used_arguments.get_constraint_args ()); + false, false, other.used_arguments.get_constraint_args ()); super_traits = other.super_traits; return *this; @@ -724,7 +724,6 @@ TypeBoundPredicateItem::get_tyty_for_receiver (const TyTy::BaseType *receiver) SubstitutionArgumentMappings adjusted (adjusted_mappings, {}, gargs.get_regions (), gargs.get_locus (), - gargs.get_subst_cb (), true /* trait-mode-flag */); TyTy::BaseType *res = Resolver::SubstMapperInternal::Resolve (trait_item_tyty, adjusted); diff --git a/gcc/rust/typecheck/rust-tyty-subst.cc b/gcc/rust/typecheck/rust-tyty-subst.cc index bed285eeeebe..73e4479fe273 100644 --- a/gcc/rust/typecheck/rust-tyty-subst.cc +++ b/gcc/rust/typecheck/rust-tyty-subst.cc @@ -224,7 +224,6 @@ SubstitutionParamMapping::fill_param_ty ( bound.handle_substitions (subst_mappings); param->set_ty_ref (type.get_ref ()); - subst_mappings.on_param_subst (p, arg); } return true; @@ -335,20 +334,19 @@ SubstitutionArgumentMappings::get_mut_regions () SubstitutionArgumentMappings::SubstitutionArgumentMappings ( std::vector mappings, std::map binding_args, RegionParamList regions, - location_t locus, ParamSubstCb param_subst_cb, bool trait_item_flag, - bool error_flag, std::map constraint_args) + location_t locus, bool trait_item_flag, bool error_flag, + std::map constraint_args) : mappings (std::move (mappings)), binding_args (binding_args), constraint_args (constraint_args), regions (regions), locus (locus), - param_subst_cb (param_subst_cb), trait_item_flag (trait_item_flag), - error_flag (error_flag) + trait_item_flag (trait_item_flag), error_flag (error_flag) {} SubstitutionArgumentMappings::SubstitutionArgumentMappings ( const SubstitutionArgumentMappings &other) : mappings (other.mappings), binding_args (other.binding_args), constraint_args (other.constraint_args), regions (other.regions), - locus (other.locus), param_subst_cb (nullptr), - trait_item_flag (other.trait_item_flag), error_flag (other.error_flag) + locus (other.locus), trait_item_flag (other.trait_item_flag), + error_flag (other.error_flag) {} SubstitutionArgumentMappings & @@ -360,7 +358,6 @@ SubstitutionArgumentMappings::operator= ( constraint_args = other.constraint_args; regions = other.regions; locus = other.locus; - param_subst_cb = nullptr; trait_item_flag = other.trait_item_flag; error_flag = other.error_flag; @@ -370,15 +367,14 @@ SubstitutionArgumentMappings::operator= ( SubstitutionArgumentMappings SubstitutionArgumentMappings::error () { - return SubstitutionArgumentMappings ({}, {}, 0, UNDEF_LOCATION, nullptr, - false, true); + return SubstitutionArgumentMappings ({}, {}, 0, UNDEF_LOCATION, false, true); } SubstitutionArgumentMappings SubstitutionArgumentMappings::empty (size_t num_regions) { return SubstitutionArgumentMappings ({}, {}, num_regions, UNDEF_LOCATION, - nullptr, false, false); + false, false); } bool @@ -496,22 +492,6 @@ SubstitutionArgumentMappings::as_string () const return "<" + buffer + ">"; } -void -SubstitutionArgumentMappings::on_param_subst (const ParamType &p, - const SubstitutionArg &a) const -{ - if (param_subst_cb == nullptr) - return; - - param_subst_cb (p, a); -} - -ParamSubstCb -SubstitutionArgumentMappings::get_subst_cb () const -{ - return param_subst_cb; -} - bool SubstitutionArgumentMappings::trait_item_mode () const { @@ -965,7 +945,6 @@ SubstitutionRef::get_mappings_from_generic_args ( RegionParamList::from_subst (used_arguments.get_regions ().size (), regions), args.get_locus (), - nullptr, false, false, constraint_arguments}; @@ -1056,10 +1035,12 @@ SubstitutionRef::adjust_mappings_for_this ( if (resolved_mappings.empty ()) return SubstitutionArgumentMappings::error (); - return SubstitutionArgumentMappings ( - resolved_mappings, mappings.get_binding_args (), mappings.get_regions (), - mappings.get_locus (), mappings.get_subst_cb (), - mappings.trait_item_mode (), false, mappings.get_constraint_args ()); + return SubstitutionArgumentMappings (resolved_mappings, + mappings.get_binding_args (), + mappings.get_regions (), + mappings.get_locus (), + mappings.trait_item_mode (), false, + mappings.get_constraint_args ()); } bool @@ -1119,8 +1100,8 @@ SubstitutionRef::solve_mappings_from_receiver_for_self ( return SubstitutionArgumentMappings (resolved_mappings, mappings.get_binding_args (), mappings.get_regions (), - mappings.get_locus (), nullptr, false, - false, mappings.get_constraint_args ()); + mappings.get_locus (), false, false, + mappings.get_constraint_args ()); } bool diff --git a/gcc/rust/typecheck/rust-tyty-subst.h b/gcc/rust/typecheck/rust-tyty-subst.h index 947488afbfa9..623593b9acc5 100644 --- a/gcc/rust/typecheck/rust-tyty-subst.h +++ b/gcc/rust/typecheck/rust-tyty-subst.h @@ -170,16 +170,13 @@ class SubstitutionArg BaseType *argument; }; -typedef std::function - ParamSubstCb; class SubstitutionArgumentMappings { public: SubstitutionArgumentMappings ( std::vector mappings, std::map binding_args, RegionParamList regions, - location_t locus, ParamSubstCb param_subst_cb = nullptr, - bool trait_item_flag = false, bool error_flag = false, + location_t locus, bool trait_item_flag = false, bool error_flag = false, std::map constraint_args = {}); SubstitutionArgumentMappings (const SubstitutionArgumentMappings &other); @@ -240,10 +237,6 @@ class SubstitutionArgumentMappings std::string as_string () const; - void on_param_subst (const ParamType &p, const SubstitutionArg &a) const; - - ParamSubstCb get_subst_cb () const; - bool trait_item_mode () const; private: @@ -252,7 +245,6 @@ class SubstitutionArgumentMappings std::map constraint_args; RegionParamList regions; location_t locus; - ParamSubstCb param_subst_cb; bool trait_item_flag; bool error_flag; }; diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc index bb7aae7a17f0..bc6844595fc8 100644 --- a/gcc/rust/typecheck/rust-tyty.cc +++ b/gcc/rust/typecheck/rust-tyty.cc @@ -3841,8 +3841,6 @@ ParamType::handle_substitions (SubstitutionArgumentMappings &subst_mappings) return this; ParamType *p = static_cast (clone ()); - subst_mappings.on_param_subst (*p, arg); - const BaseType *resolved = arg.get_tyty (); if (resolved->get_kind () == TyTy::TypeKind::PARAM) { From 16f795c742cd1c1bc6fa77099d5c1aae85e5cda9 Mon Sep 17 00:00:00 2001 From: Owen Avery Date: Thu, 10 Sep 2026 22:37:27 -0400 Subject: [PATCH 123/584] gccrs: Change alloc crate test edition to 2018 The alloc crate should be tested with edition 2018, not 2015. However, the included mock core crate did not support edition 2018. gcc/testsuite/ChangeLog: * rust/alloc/alloc.exp: Test with edition 2018. * rust/alloc/core.rs: Fix some use declaration paths and use raw identifiers for "try". Signed-off-by: Owen Avery --- gcc/testsuite/rust/alloc/alloc.exp | 2 +- gcc/testsuite/rust/alloc/core.rs | 20 ++++++++++---------- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/gcc/testsuite/rust/alloc/alloc.exp b/gcc/testsuite/rust/alloc/alloc.exp index d412b50cf22e..7e6331cab90d 100644 --- a/gcc/testsuite/rust/alloc/alloc.exp +++ b/gcc/testsuite/rust/alloc/alloc.exp @@ -37,7 +37,7 @@ if { [check_effective_target_lp64] } { $srcdir/$subdir/alloc/* \ ]] - dg-runtest $srcdir/$subdir/alloc/src/lib.rs "-frust-edition=2015 -frust-crate=alloc -frust-compile-until=nameresolution -frust-cfg=target_has_atomic=\"ptr\" -w" "" + dg-runtest $srcdir/$subdir/alloc/src/lib.rs "-frust-edition=2018 -frust-crate=alloc -frust-compile-until=nameresolution -frust-cfg=target_has_atomic=\"ptr\" -w" "" set dg-do-what-default ${saved-dg-do-what-default} } else { unsupported "alloc crate tests require a 64-bit target " diff --git a/gcc/testsuite/rust/alloc/core.rs b/gcc/testsuite/rust/alloc/core.rs index 8362e3473fcd..e74ed9e4db8e 100644 --- a/gcc/testsuite/rust/alloc/core.rs +++ b/gcc/testsuite/rust/alloc/core.rs @@ -106,14 +106,14 @@ pub mod ops { pub use self::arith::{Add, AddAssign, Sub}; pub use self::deref::{Deref, DerefMut, Receiver}; - pub use bit::{BitAnd, BitOr, BitXor}; - pub use drop::Drop; - pub use function::{Fn, FnMut, FnOnce}; - pub use generator::{Generator, GeneratorState}; - pub use index::{Index, IndexMut}; - pub use range::{Bound, Range, RangeBounds}; - pub use try::Try; - pub use unsize::{CoerceUnsized, DispatchFromDyn}; + pub use self::bit::{BitAnd, BitOr, BitXor}; + pub use self::drop::Drop; + pub use self::function::{Fn, FnMut, FnOnce}; + pub use self::generator::{Generator, GeneratorState}; + pub use self::index::{Index, IndexMut}; + pub use self::range::{Bound, Range, RangeBounds}; + pub use self::r#try::Try; + pub use self::unsize::{CoerceUnsized, DispatchFromDyn}; use super::marker::Sized; @@ -222,7 +222,7 @@ pub mod ops { fn index_mut(&mut self, index: Idx) -> &mut Self::Output; } } - pub mod try { + pub mod r#try { use crate::core::result::Result; #[lang = "try"] @@ -855,7 +855,7 @@ pub mod iter { use super::Result; use super::Sized; use crate::core::ops::function::FnMut; - use crate::core::ops::try::Try; + use crate::core::ops::r#try::Try; pub trait IntoIterator { type Item; type IntoIter: Iterator; From a54310bd17730fd589568941962610bc85dd251b Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 11 Sep 2026 12:33:20 +0100 Subject: [PATCH 124/584] gccrs: This is an utterly insane rustc shim needed for stdarch This doesnt fully implement the legacy const generics attribute but its the starting point. What we actually need to do is understand: #[rustc_legacy_const_generics(1)] fn foo(x: i32) -> i32 { x + N as i32 } fn main() { let a = foo(10, 3); } So you can see the call to foo has a 2nd param but its not a real 2nd param its meant to be turned into: foo::<3>(10) Honestly this is just silly they probably implemented a bit of const generics wanted to use it in core and put this work around in to get away with it. Dumb. Addresses Rust-GCC/gccrs#3868 gcc/rust/ChangeLog: * typecheck/rust-casts.cc (TypeCastRules::cast_rules): fix bad const cast * util/rust-attribute-values.h: add attribute * util/rust-attributes.cc: likewise Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-casts.cc | 3 +++ gcc/rust/util/rust-attribute-values.h | 3 +++ gcc/rust/util/rust-attributes.cc | 1 + 3 files changed, 7 insertions(+) diff --git a/gcc/rust/typecheck/rust-casts.cc b/gcc/rust/typecheck/rust-casts.cc index fdc569ee26a9..6837e3f5fb74 100644 --- a/gcc/rust/typecheck/rust-casts.cc +++ b/gcc/rust/typecheck/rust-casts.cc @@ -18,6 +18,7 @@ #include "rust-casts.h" #include "rust-tyty-util.h" +#include "rust-tyty.h" namespace Rust { namespace Resolver { @@ -70,6 +71,8 @@ TypeCastRules::cast_rules () // https://github.com/rust-lang/rust/blob/7eac88abb2e57e752f3302f02be5f3ce3d7adfb4/compiler/rustc_typeck/src/check/cast.rs#L654 TyTy::BaseType *from_type = from.get_ty ()->destructure (); + if (auto c = from_type->try_as ()) + from_type = c->get_specified_type (); rust_debug ("cast_rules from={%s} to={%s}", from_type->debug_str ().c_str (), to.get_ty ()->debug_str ().c_str ()); diff --git a/gcc/rust/util/rust-attribute-values.h b/gcc/rust/util/rust-attribute-values.h index e2718ca4a55f..99c549ea9211 100644 --- a/gcc/rust/util/rust-attribute-values.h +++ b/gcc/rust/util/rust-attribute-values.h @@ -115,6 +115,9 @@ class Attributes static constexpr auto &RUSTC_ARGS_REQUIRED_CONST = "rustc_args_required_const"; + static constexpr auto &RUSTC_LEGACY_CONST_GENERICS + = "rustc_legacy_const_generics"; + static constexpr auto &NEEDS_ALLOCATOR = "needs_allocator"; static constexpr auto &RUSTC_ALLOCATOR = "rustc_allocator"; diff --git a/gcc/rust/util/rust-attributes.cc b/gcc/rust/util/rust-attributes.cc index 8ab4bc608b85..33be02a43473 100644 --- a/gcc/rust/util/rust-attributes.cc +++ b/gcc/rust/util/rust-attributes.cc @@ -86,6 +86,7 @@ static const BuiltinAttrDefinition __definitions[] {Attrs::RUSTC_LAYOUT_SCALAR_VALID_RANGE_START, CODE_GENERATION}, // TODO: be careful about calling functions marked with this? {Attrs::RUSTC_ARGS_REQUIRED_CONST, CODE_GENERATION}, + {Attrs::RUSTC_LEGACY_CONST_GENERICS, TYPE_CHECK}, {Attrs::COMPILER_BUILTINS, CODE_GENERATION}, {Attrs::NO_BUILTINS, CODE_GENERATION}, {Attrs::PRELUDE_IMPORT, NAME_RESOLUTION}, From a3172f00f7948b21fdf0861811d07713709856c8 Mon Sep 17 00:00:00 2001 From: Arthur Cohen Date: Fri, 4 Sep 2026 14:14:19 +0200 Subject: [PATCH 125/584] gccrs: feature-gate: Return a value to indicate the result of gating Create a new enum class to indicate whether a feature was gated or not to the FeatureGate checker. As well as moving `gate` into a public function since the aim is to make it available to other passes. gcc/rust/ChangeLog: * checks/errors/feature/rust-feature-gate.cc (FeatureGate::gate): Move into public methods, use GateResult enum. * checks/errors/feature/rust-feature-gate.h: Add new GateResult enum. --- gcc/rust/checks/errors/feature/rust-feature-gate.cc | 6 +++++- gcc/rust/checks/errors/feature/rust-feature-gate.h | 10 +++++++++- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/gcc/rust/checks/errors/feature/rust-feature-gate.cc b/gcc/rust/checks/errors/feature/rust-feature-gate.cc index 775df43791ae..3d43d736ecee 100644 --- a/gcc/rust/checks/errors/feature/rust-feature-gate.cc +++ b/gcc/rust/checks/errors/feature/rust-feature-gate.cc @@ -76,7 +76,7 @@ FeatureGate::visit (AST::Crate &crate) } } -void +FeatureGate::GateResult FeatureGate::gate (Feature::Name name, location_t loc, const std::string &error_msg) { @@ -102,7 +102,11 @@ FeatureGate::gate (Feature::Name name, location_t loc, rust_error_at (loc, ErrorCode::E0658, fmt_str, error_msg.c_str (), feature.as_string ().c_str ()); } + + return GateResult::Gated; } + + return GateResult::Allowed; } void diff --git a/gcc/rust/checks/errors/feature/rust-feature-gate.h b/gcc/rust/checks/errors/feature/rust-feature-gate.h index e8bb61b1f610..74d81a5e1ae0 100644 --- a/gcc/rust/checks/errors/feature/rust-feature-gate.h +++ b/gcc/rust/checks/errors/feature/rust-feature-gate.h @@ -52,8 +52,16 @@ class FeatureGate : public AST::DefaultASTVisitor void visit (AST::Enum &enum_item) override; void visit (AST::EnumItem &enum_variant) override; + enum class GateResult + { + Gated, + Allowed, + }; + + GateResult gate (Feature::Name name, location_t loc, + const std::string &error_msg); + private: - void gate (Feature::Name name, location_t loc, const std::string &error_msg); void check_no_core_attribute (const AST::Attribute &attribute); void check_rustc_attri (const std::vector &attributes); void From f29c99b3ae00c82b8fab444b5314b25e7a648d63 Mon Sep 17 00:00:00 2001 From: Arthur Cohen Date: Fri, 4 Sep 2026 14:25:03 +0200 Subject: [PATCH 126/584] gccrs: cfi_encoding: Recognize the attribute And warn that it currently does not do anything, and depends on a patchset upstream that is currently being reviewed. gcc/rust/ChangeLog: * checks/errors/feature/rust-feature-defs-rfl.h: Add cfi_encoding RfL feature. * checks/errors/feature/rust-feature-gate.cc (FeatureGate::visit): Add visitor for attributes in general, and warn on cfi_encoding being used. * checks/errors/feature/rust-feature-gate.h: Declare the attribute visitor. * util/rust-attribute-values.h: Add #[cfi_encoding]. * util/rust-attributes.cc: Likewise. gcc/testsuite/ChangeLog: * rust/compile/cfi-encoding1.rs: New test. * rust/compile/cfi-encoding2.rs: New test. --- .../errors/feature/rust-feature-defs-rfl.h | 2 ++ .../checks/errors/feature/rust-feature-gate.cc | 16 ++++++++++++++++ .../checks/errors/feature/rust-feature-gate.h | 2 ++ gcc/rust/util/rust-attribute-values.h | 2 ++ gcc/rust/util/rust-attributes.cc | 3 ++- gcc/testsuite/rust/compile/cfi-encoding1.rs | 5 +++++ gcc/testsuite/rust/compile/cfi-encoding2.rs | 6 ++++++ 7 files changed, 35 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/rust/compile/cfi-encoding1.rs create mode 100644 gcc/testsuite/rust/compile/cfi-encoding2.rs diff --git a/gcc/rust/checks/errors/feature/rust-feature-defs-rfl.h b/gcc/rust/checks/errors/feature/rust-feature-defs-rfl.h index 8d5cc32e57a4..288ffc862929 100644 --- a/gcc/rust/checks/errors/feature/rust-feature-defs-rfl.h +++ b/gcc/rust/checks/errors/feature/rust-feature-defs-rfl.h @@ -24,3 +24,5 @@ FEATURE_ACTIVE ("extended_key_value_attributes", EXTENDED_KEY_VALUE_ATTRIBUTES, "1.50.0", ISSUE_SOME (78835), EDITION_NONE) +FEATURE_ACTIVE ("cfi_encoding", CFI_ENCODING, "1.71.0", ISSUE_SOME (89653), + EDITION_NONE) diff --git a/gcc/rust/checks/errors/feature/rust-feature-gate.cc b/gcc/rust/checks/errors/feature/rust-feature-gate.cc index 3d43d736ecee..4cb4583f713f 100644 --- a/gcc/rust/checks/errors/feature/rust-feature-gate.cc +++ b/gcc/rust/checks/errors/feature/rust-feature-gate.cc @@ -366,4 +366,20 @@ FeatureGate::visit (AST::EnumItem &enum_variant) AST::DefaultASTVisitor::visit (enum_variant); } +void +FeatureGate::visit (AST::Attribute &attr) +{ + if (attr.get_path ().as_string () == "cfi_encoding") + if (gate (Feature::Name::CFI_ENCODING, attr.get_locus (), + "#[cfi_encoding] is an experimental feature") + == GateResult::Allowed) + rust_warning_at ( + attr.get_locus (), 0, + "the %<#[cfi_encoding]%> attribute is currently ignored and " + "does nothing - we are waiting on a patchset to land " + "into GCC as the KCFI functionality is not present yet"); + + AST::DefaultASTVisitor::visit (attr); +} + } // namespace Rust diff --git a/gcc/rust/checks/errors/feature/rust-feature-gate.h b/gcc/rust/checks/errors/feature/rust-feature-gate.h index 74d81a5e1ae0..e74a98605acf 100644 --- a/gcc/rust/checks/errors/feature/rust-feature-gate.h +++ b/gcc/rust/checks/errors/feature/rust-feature-gate.h @@ -52,6 +52,8 @@ class FeatureGate : public AST::DefaultASTVisitor void visit (AST::Enum &enum_item) override; void visit (AST::EnumItem &enum_variant) override; + void visit (AST::Attribute &attr) override; + enum class GateResult { Gated, diff --git a/gcc/rust/util/rust-attribute-values.h b/gcc/rust/util/rust-attribute-values.h index 99c549ea9211..f4409e1fa06b 100644 --- a/gcc/rust/util/rust-attribute-values.h +++ b/gcc/rust/util/rust-attribute-values.h @@ -125,6 +125,8 @@ class Attributes static constexpr auto &RUSTC_CONVERSION_SUGGESTION = "rustc_conversion_suggestion"; + + static constexpr auto &CFI_ENCODING = "cfi_encoding"; }; } // namespace Values } // namespace Rust diff --git a/gcc/rust/util/rust-attributes.cc b/gcc/rust/util/rust-attributes.cc index 33be02a43473..58c789fd1592 100644 --- a/gcc/rust/util/rust-attributes.cc +++ b/gcc/rust/util/rust-attributes.cc @@ -104,7 +104,8 @@ static const BuiltinAttrDefinition __definitions[] {Attrs::RUSTC_ALLOCATOR, CODE_GENERATION}, {Attrs::RUSTC_ALLOCATOR_NOUNWIND, CODE_GENERATION}, {Attrs::GLOBAL_ALLOCATOR, CODE_GENERATION}, - {Attrs::RUSTC_CONVERSION_SUGGESTION, TYPE_CHECK}}; + {Attrs::RUSTC_CONVERSION_SUGGESTION, TYPE_CHECK}, + {Attrs::CFI_ENCODING, CODE_GENERATION}}; static const std::set __outer_attributes = {Attrs::INLINE, diff --git a/gcc/testsuite/rust/compile/cfi-encoding1.rs b/gcc/testsuite/rust/compile/cfi-encoding1.rs new file mode 100644 index 000000000000..643ab565afda --- /dev/null +++ b/gcc/testsuite/rust/compile/cfi-encoding1.rs @@ -0,0 +1,5 @@ +#![feature(no_core)] +#![no_core] + +#[cfi_encoding = "4Bleh"] // { dg-error "experimental feature" } +pub struct Bleh(i32); diff --git a/gcc/testsuite/rust/compile/cfi-encoding2.rs b/gcc/testsuite/rust/compile/cfi-encoding2.rs new file mode 100644 index 000000000000..9d56700979af --- /dev/null +++ b/gcc/testsuite/rust/compile/cfi-encoding2.rs @@ -0,0 +1,6 @@ +#![feature(no_core)] +#![feature(cfi_encoding)] +#![no_core] + +#[cfi_encoding = "4Bleh"] // { dg-warning "does nothing" } +pub struct Bleh(i32); From fffe5e21229c9cefc072f911ae7aa1e12fe001c1 Mon Sep 17 00:00:00 2001 From: Yap Zhi Heng Date: Mon, 14 Sep 2026 20:17:50 +0800 Subject: [PATCH 127/584] gccrs: Implement some platform-intrinsic simd function support Generated 007t.gimple code from compiling platform_intrinsics.rs: _1 = x == y; _eq = VEC_COND_EXPR <_1, { -1, -1 }, { 0, 0 }>; _2 = x != y; _ne = VEC_COND_EXPR <_2, { -1, -1 }, { 0, 0 }>; _3 = x < y; _lt = VEC_COND_EXPR <_3, { -1, -1 }, { 0, 0 }>; _4 = x <= y; _le = VEC_COND_EXPR <_4, { -1, -1 }, { 0, 0 }>; _5 = x > y; _gt = VEC_COND_EXPR <_5, { -1, -1 }, { 0, 0 }>; _6 = x >= y; _ge = VEC_COND_EXPR <_6, { -1, -1 }, { 0, 0 }>; _add = x + y; _sub = x - y; _mul = x * y; _div = x / y; _shl = x << y; _shr = x >> y; _and = x & y; _or = x | y; _xor = x ^ y; gcc/rust/ChangeLog: * Make-lang.in: Compile the new rust-compile-platform-intrinsic files. * backend/rust-compile-base.cc (HIRCompileBase::setup_abi_options): Make the PLATFORM_INTRINSIC case use the `cdecl` ABI. * backend/rust-compile-platform-intrinsic.cc: New file to handle compilation of 'platform-intrinsic' extern functions. * backend/rust-compile-platform-intrinsic.h: Header file for the formentioned file. * backend/rust-compile-expr.cc (CompileExpr::visit (HIR::CallExpr)): Add new conditions to compile platform-intrinsic extern functions. * typecheck/rust-hir-type-check-base.cc (TypeCheckBase::resolve_generic_params): Check 'platform-intrinsic' extern functions for const parameters. * typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit (HIR::TupleIndexExpr)): Fix resolved tuple expression not destructuring. Signed-off-by: Yap Zhi Heng --- gcc/rust/Make-lang.in | 1 + gcc/rust/backend/rust-compile-base.cc | 1 + gcc/rust/backend/rust-compile-expr.cc | 25 ++++ .../rust-compile-platform-intrinsic.cc | 117 ++++++++++++++++++ .../backend/rust-compile-platform-intrinsic.h | 51 ++++++++ .../typecheck/rust-hir-type-check-base.cc | 6 +- .../typecheck/rust-hir-type-check-expr.cc | 3 +- .../rust/compile/platform_intrinsics.rs | 117 ++++++++++++++++++ 8 files changed, 318 insertions(+), 3 deletions(-) create mode 100644 gcc/rust/backend/rust-compile-platform-intrinsic.cc create mode 100644 gcc/rust/backend/rust-compile-platform-intrinsic.h create mode 100644 gcc/testsuite/rust/compile/platform_intrinsics.rs diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in index e4e5704528cf..552de0153d66 100644 --- a/gcc/rust/Make-lang.in +++ b/gcc/rust/Make-lang.in @@ -229,6 +229,7 @@ GRS_OBJS = \ rust/rust-compile-type.o \ rust/rust-compile-block.o \ rust/rust-compile-struct-field-expr.o \ + rust/rust-compile-platform-intrinsic.o \ rust/rust-constexpr.o \ rust/rust-compile-base.o \ rust/rust-compile-drop-builder.o \ diff --git a/gcc/rust/backend/rust-compile-base.cc b/gcc/rust/backend/rust-compile-base.cc index d4161a96f1f2..65ec002fca46 100644 --- a/gcc/rust/backend/rust-compile-base.cc +++ b/gcc/rust/backend/rust-compile-base.cc @@ -509,6 +509,7 @@ HIRCompileBase::setup_abi_options (tree fndecl, ABI abi) { case Rust::ABI::RUST: case Rust::ABI::INTRINSIC: + case Rust::ABI::PLATFORM_INTRINSIC: case Rust::ABI::C: case Rust::ABI::CDECL: // `decl_attributes` function (not the macro) has the side-effect of diff --git a/gcc/rust/backend/rust-compile-expr.cc b/gcc/rust/backend/rust-compile-expr.cc index 6480e946b155..815f53cb0878 100644 --- a/gcc/rust/backend/rust-compile-expr.cc +++ b/gcc/rust/backend/rust-compile-expr.cc @@ -28,6 +28,7 @@ #include "rust-compile-block.h" #include "rust-compile-drop.h" #include "rust-compile-implitem.h" +#include "rust-compile-platform-intrinsic.h" #include "rust-constexpr.h" #include "rust-compile-type.h" #include "rust-finalized-name-resolution-context.h" @@ -1696,6 +1697,23 @@ CompileExpr::visit (HIR::CallExpr &expr) return true; }; + // special check for platform-intrinsic functions + TyTy::FnType *platform_intrinsic = nullptr; + if (tyty->get_kind () == TyTy::TypeKind::FNDEF) + { + auto *fn_ty = static_cast (tyty); + if (fn_ty->get_abi () == ABI::PLATFORM_INTRINSIC) + platform_intrinsic = fn_ty; + } + + if (ctx->const_context_p () && platform_intrinsic != nullptr) + { + rust_sorry_at ( + expr.get_locus (), + "platform intrinsic calls in consts are not supported yet"); + return; + } + auto fn_address = CompileExpr::Compile (expr.get_fnexpr (), ctx); if (ctx->const_context_p ()) { @@ -1776,6 +1794,13 @@ CompileExpr::visit (HIR::CallExpr &expr) args.push_back (rvalue); } + if (platform_intrinsic != nullptr) + { + translated = PlatformIntrinsic::compile_call (ctx, platform_intrinsic, + args, expr.get_locus ()); + return; + } + // must be a regular call to a function translated = Backend::call_expression (fn_address, args, nullptr, expr.get_locus ()); diff --git a/gcc/rust/backend/rust-compile-platform-intrinsic.cc b/gcc/rust/backend/rust-compile-platform-intrinsic.cc new file mode 100644 index 000000000000..3580143de355 --- /dev/null +++ b/gcc/rust/backend/rust-compile-platform-intrinsic.cc @@ -0,0 +1,117 @@ +// Copyright (C) 2026 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 +// . + +#include "rust-system.h" +#include "rust-compile-context.h" +#include "rust-compile-type.h" +#include "rust-tyty.h" +#include "rust-abi.h" +#include "rust-tree.h" +#include "tree.h" +#include "fold-const.h" +#include "rust-compile-platform-intrinsic.h" + +namespace Rust { +namespace Compile { + +const std::map + PlatformIntrinsic::platform_intrinsics = { + {"simd_add", {OpKind::BINARY, PLUS_EXPR}}, + {"simd_sub", {OpKind::BINARY, MINUS_EXPR}}, + {"simd_mul", {OpKind::BINARY, MULT_EXPR}}, + {"simd_div", + {OpKind::BINARY, + TRUNC_DIV_EXPR}}, // uses RDIV_EXPR if operands are real type + {"simd_shl", {OpKind::BINARY, LSHIFT_EXPR}}, + {"simd_shr", {OpKind::BINARY, RSHIFT_EXPR}}, + {"simd_and", {OpKind::BINARY, BIT_AND_EXPR}}, + {"simd_or", {OpKind::BINARY, BIT_IOR_EXPR}}, + {"simd_xor", {OpKind::BINARY, BIT_XOR_EXPR}}, + {"simd_eq", {OpKind::COMPARISON, EQ_EXPR}}, + {"simd_ne", {OpKind::COMPARISON, NE_EXPR}}, + {"simd_lt", {OpKind::COMPARISON, LT_EXPR}}, + {"simd_le", {OpKind::COMPARISON, LE_EXPR}}, + {"simd_gt", {OpKind::COMPARISON, GT_EXPR}}, + {"simd_ge", {OpKind::COMPARISON, GE_EXPR}}, +}; + +tree +compile_comparison_op (const TyTy::FnType *fntype, + const std::vector &arguments, location_t locus, + const tree &result_type, const tree_code op_code) +{ + tree input_type = TREE_TYPE (arguments[0]); + tree predicate_type = truth_type_for (input_type); + + tree predicate = fold_build2_loc (locus, op_code, predicate_type, + arguments[0], arguments[1]); + return fold_build3_loc (locus, VEC_COND_EXPR, result_type, predicate, + build_minus_one_cst (result_type), + build_zero_cst (result_type)); +} + +tree +compile_binary_op (const TyTy::FnType *fntype, + const std::vector &arguments, location_t locus, + const tree &result_type, const tree_code op_code) +{ + tree_code final_op_code = op_code; + + // idk any more elegant way to do this + if (final_op_code == TRUNC_DIV_EXPR + && TREE_CODE (TREE_TYPE (result_type)) == REAL_TYPE) + final_op_code = RDIV_EXPR; + + return fold_build2_loc (locus, final_op_code, result_type, arguments[0], + arguments[1]); +} + +tree +PlatformIntrinsic::compile_call (Context *ctx, TyTy::FnType *fntype, + const std::vector &arguments, + location_t locus) +{ + rust_assert (fntype != nullptr); + rust_assert (fntype->get_abi () == ABI::PLATFORM_INTRINSIC); + auto *result_ty = fntype->get_return_type ()->destructure (); + tree result_type = TyTyResolveCompile::compile (ctx, result_ty); + + auto it = platform_intrinsics.find (fntype->get_identifier ()); + if (it == platform_intrinsics.end ()) + { + // TODO add an error here + return error_mark_node; + } + + const auto &mapping = it->second; + + switch (mapping.kind) + { + case OpKind::BINARY: + return compile_binary_op (fntype, arguments, locus, result_type, + mapping.code); + case OpKind::COMPARISON: + return compile_comparison_op (fntype, arguments, locus, result_type, + mapping.code); + default: + return error_mark_node; + } +} + +} // namespace Compile +} // namespace Rust diff --git a/gcc/rust/backend/rust-compile-platform-intrinsic.h b/gcc/rust/backend/rust-compile-platform-intrinsic.h new file mode 100644 index 000000000000..c568a627e8dd --- /dev/null +++ b/gcc/rust/backend/rust-compile-platform-intrinsic.h @@ -0,0 +1,51 @@ +// Copyright (C) 2026 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 RUST_COMPILE_PLATFORM_INTRINSIC_H +#define RUST_COMPILE_PLATFORM_INTRINSIC_H + +namespace Rust { +namespace Compile { + +class PlatformIntrinsic +{ +public: + static tree compile_call (Context *ctx, TyTy::FnType *fntype, + const std::vector &arguments, + location_t locus); + +private: + enum class OpKind + { + BINARY, + COMPARISON, + }; + + struct PlatformIntrinsicMapping + { + OpKind kind; + tree_code code; + }; + static const std::map + platform_intrinsics; +}; + +} // namespace Compile +} // namespace Rust + +#endif // RUST_COMPILE_PLATFORM_INTRINSIC_H diff --git a/gcc/rust/typecheck/rust-hir-type-check-base.cc b/gcc/rust/typecheck/rust-hir-type-check-base.cc index faa6d5ea98ee..c9e392039a3c 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-base.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-base.cc @@ -669,7 +669,8 @@ TypeCheckBase::resolve_generic_params ( case HIR::GenericParam::GenericKind::CONST: { - if (is_foreign && abi != Rust::ABI::INTRINSIC) + if (is_foreign && abi != Rust::ABI::INTRINSIC + && abi != Rust::ABI::PLATFORM_INTRINSIC) { rust_error_at (generic_param->get_locus (), ErrorCode::E0044, "foreign items may not have const parameters"); @@ -747,7 +748,8 @@ TypeCheckBase::resolve_generic_params ( case HIR::GenericParam::GenericKind::TYPE: { - if (is_foreign && abi != Rust::ABI::INTRINSIC) + if (is_foreign && abi != Rust::ABI::INTRINSIC + && abi != Rust::ABI::PLATFORM_INTRINSIC) { rust_error_at (generic_param->get_locus (), ErrorCode::E0044, "foreign items may not have type parameters"); diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc index fdc17fe44e25..b2e10c6225bd 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc @@ -86,7 +86,8 @@ TypeCheckExpr::ResolveOpOverload (LangItem::Kind lang_item_type, void TypeCheckExpr::visit (HIR::TupleIndexExpr &expr) { - auto resolved = TypeCheckExpr::Resolve (expr.get_tuple_expr ()); + auto resolved + = TypeCheckExpr::Resolve (expr.get_tuple_expr ())->destructure (); if (resolved->get_kind () == TyTy::TypeKind::ERROR) { rust_error_at (expr.get_tuple_expr ().get_locus (), diff --git a/gcc/testsuite/rust/compile/platform_intrinsics.rs b/gcc/testsuite/rust/compile/platform_intrinsics.rs new file mode 100644 index 000000000000..c93df7c4a20b --- /dev/null +++ b/gcc/testsuite/rust/compile/platform_intrinsics.rs @@ -0,0 +1,117 @@ +// { dg-do compile { target { { i?86-*-* x86_64-*-* } && ia32 } } } +// { dg-options "-mrdrnd -mrdseed -fdump-tree-gimple" } +#![feature(no_core, abi_unadjusted, repr_simd, lang_items)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +#[repr(simd)] +pub struct __m128i(i64, i64); + +extern "platform-intrinsic" { + //pub fn simd_select_bitmask + pub fn simd_eq(x: T, y: T) -> U; + pub fn simd_ne(x: T, y: T) -> U; + pub fn simd_lt(x: T, y: T) -> U; + pub fn simd_le(x: T, y: T) -> U; + pub fn simd_gt(x: T, y: T) -> U; + pub fn simd_ge(x: T, y: T) -> U; + + // #[rustc_args_required_const(2)] + // pub fn simd_shuffle2(x: T, y: T, idx: [u32; 2]) -> U; + // #[rustc_args_required_const(2)] + // pub fn simd_shuffle4(x: T, y: T, idx: [u32; 4]) -> U; + // #[rustc_args_required_const(2)] + // pub fn simd_shuffle8(x: T, y: T, idx: [u32; 8]) -> U; + // #[rustc_args_required_const(2)] + // pub fn simd_shuffle16(x: T, y: T, idx: [u32; 16]) -> U; + // #[rustc_args_required_const(2)] + // pub fn simd_shuffle32(x: T, y: T, idx: [u32; 32]) -> U; + // #[rustc_args_required_const(2)] + // pub fn simd_shuffle64(x: T, y: T, idx: [u32; 64]) -> U; + // #[rustc_args_required_const(2)] + // pub fn simd_shuffle128(x: T, y: T, idx: [u32; 128]) -> U; + + // #[rustc_const_unstable(feature = "const_simd_insert", issue = "none")] + // pub fn simd_insert(x: T, idx: u32, val: U) -> T; + // #[rustc_const_unstable(feature = "const_simd_extract", issue = "none")] + // pub fn simd_extract(x: T, idx: u32) -> U; + // //pub fn simd_select + // pub fn simd_bitmask(x: T) -> U; + + // pub fn simd_cast(x: T) -> U; + + pub fn simd_add(x: T, y: T) -> T; + pub fn simd_sub(x: T, y: T) -> T; + pub fn simd_mul(x: T, y: T) -> T; + pub fn simd_div(x: T, y: T) -> T; + pub fn simd_shl(x: T, y: T) -> T; + pub fn simd_shr(x: T, y: T) -> T; + pub fn simd_and(x: T, y: T) -> T; + pub fn simd_or(x: T, y: T) -> T; + pub fn simd_xor(x: T, y: T) -> T; + + // pub fn simd_saturating_add(x: T, y: T) -> T; + // pub fn simd_saturating_sub(x: T, y: T) -> T; + + // pub fn simd_gather(values: T, pointers: U, mask: V) -> T; + // pub fn simd_scatter(values: T, pointers: U, mask: V); + + // pub fn simd_reduce_add_unordered(x: T) -> U; + // pub fn simd_reduce_mul_unordered(x: T) -> U; + // pub fn simd_reduce_add_ordered(x: T, acc: U) -> U; + // pub fn simd_reduce_mul_ordered(x: T, acc: U) -> U; + // pub fn simd_reduce_min(x: T) -> U; + // pub fn simd_reduce_max(x: T) -> U; + // pub fn simd_reduce_min_nanless(x: T) -> U; + // pub fn simd_reduce_max_nanless(x: T) -> U; + // pub fn simd_reduce_and(x: T) -> U; + // pub fn simd_reduce_or(x: T) -> U; + // pub fn simd_reduce_xor(x: T) -> U; + // pub fn simd_reduce_all(x: T) -> bool; + // pub fn simd_reduce_any(x: T) -> bool; + + // pub fn simd_select(m: M, a: T, b: T) -> T; + // pub fn simd_select_bitmask(m: M, a: T, b: T) -> T; + + // pub fn simd_fmin(a: T, b: T) -> T; + // pub fn simd_fmax(a: T, b: T) -> T; + + // pub fn simd_fsqrt(a: T) -> T; + // pub fn simd_fsin(a: T) -> T; + // pub fn simd_fcos(a: T) -> T; + // pub fn simd_fabs(a: T) -> T; + // pub fn simd_floor(a: T) -> T; + // pub fn simd_ceil(a: T) -> T; + // pub fn simd_fexp(a: T) -> T; + // pub fn simd_fexp2(a: T) -> T; + // pub fn simd_flog10(a: T) -> T; + // pub fn simd_flog2(a: T) -> T; + // pub fn simd_flog(a: T) -> T; + // //pub fn simd_fpowi + // //pub fn simd_fpow + // pub fn simd_fma(a: T, b: T, c: T) -> T; +} + +fn main(){ + let x: __m128i = __m128i(0, 2); + let y: __m128i = __m128i(2, 2); + unsafe { + let _eq = simd_eq::<__m128i, __m128i>(x, y); + let _ne = simd_ne::<__m128i, __m128i>(x, y); + let _lt = simd_lt::<__m128i, __m128i>(x, y); + let _le = simd_le::<__m128i, __m128i>(x, y); + let _gt = simd_gt::<__m128i, __m128i>(x, y); + let _ge = simd_ge::<__m128i, __m128i>(x, y); + let _add = simd_add(x, y); + let _sub = simd_sub(x, y); + let _mul = simd_mul(x, y); + let _div = simd_div(x, y); + let _shl = simd_shl(x, y); + let _shr = simd_shr(x, y); + let _and = simd_and(x, y); + let _or = simd_or(x, y); + let _xor = simd_xor(x, y); + }; +} From ce6480029c2bcc78e051a02e557bcfca2ec75477 Mon Sep 17 00:00:00 2001 From: Gaius Mulley Date: Wed, 16 Sep 2026 13:50:18 +0100 Subject: [PATCH 128/584] PR modula2/127359: Bugfix ensure makeSystem is posix compliant This patch ensures that echo is replaced by equivalent printf posix commands. The invocation of makeSystem from the Makefiles under libgm2 are achieved through $(SHELL). gcc/m2/ChangeLog: PR modula2/127359 * tools-src/makeSystem: Replace echo with printf equivalent. libgm2/ChangeLog: PR modula2/127359 * libm2cor/Makefile.am: Use $(SHELL) to invoke makeSystem. * libm2iso/Makefile.am: Ditto. * libm2min/Makefile.am: Ditto. * libm2pim/Makefile.am: Ditto. * libm2pim/Makefile.in: Rebuild. * libm2cor/Makefile.in: Ditto. * libm2iso/Makefile.in: Ditto. * libm2min/Makefile.in: Ditto. Signed-off-by: Gaius Mulley --- gcc/m2/tools-src/makeSystem | 10 +++++----- libgm2/libm2cor/Makefile.am | 2 +- libgm2/libm2cor/Makefile.in | 2 +- libgm2/libm2iso/Makefile.am | 2 +- libgm2/libm2iso/Makefile.in | 2 +- libgm2/libm2min/Makefile.am | 2 +- libgm2/libm2min/Makefile.in | 2 +- libgm2/libm2pim/Makefile.am | 2 +- libgm2/libm2pim/Makefile.in | 2 +- 9 files changed, 13 insertions(+), 13 deletions(-) diff --git a/gcc/m2/tools-src/makeSystem b/gcc/m2/tools-src/makeSystem index 8adebd700ed6..b07656768860 100644 --- a/gcc/m2/tools-src/makeSystem +++ b/gcc/m2/tools-src/makeSystem @@ -70,22 +70,22 @@ displayExportedTypes () { for i in ${types} ; do if [ $n -eq 1 ] ; then n=0 - echo -n " " >> ${OUTPUTFILE} + printf " " >> ${OUTPUTFILE} fi - echo -n "$i, " >> ${OUTPUTFILE} + printf "$i, " >> ${OUTPUTFILE} if [ $c -eq 4 ] ; then - echo " " >> ${OUTPUTFILE} + printf "\n" >> ${OUTPUTFILE} n=1 c=0 fi c=`expr $c + 1` done - echo " " >> ${OUTPUTFILE} + printf "\n" >> ${OUTPUTFILE} } displayBuiltinTypes () { for i in ${types} ; do - echo " $i ; " >> ${OUTPUTFILE} + printf " $i ; " >> ${OUTPUTFILE} done } diff --git a/libgm2/libm2cor/Makefile.am b/libgm2/libm2cor/Makefile.am index 26d38dc7f4d6..d324055257e5 100644 --- a/libgm2/libm2cor/Makefile.am +++ b/libgm2/libm2cor/Makefile.am @@ -143,7 +143,7 @@ CLEANFILES = SYSTEM.def M2LIBDIR = /m2/m2cor/ SYSTEM.def: Makefile - sh $(GM2_SRC)/tools-src/makeSystem -fpim \ + $(SHELL) $(GM2_SRC)/tools-src/makeSystem -fpim \ $(GM2_SRC)/gm2-libs-cor-common/SYSTEM.def \ $(GM2_SRC)/gm2-libs-cor-common/SYSTEM.mod \ -I$(GM2_SRC)/gm2-libs-cor-common \ diff --git a/libgm2/libm2cor/Makefile.in b/libgm2/libm2cor/Makefile.in index 8287896cbc4f..9781e1f436a3 100644 --- a/libgm2/libm2cor/Makefile.in +++ b/libgm2/libm2cor/Makefile.in @@ -824,7 +824,7 @@ uninstall-am: uninstall-toolexeclibLTLIBRARIES @BUILD_CORLIB_TRUE@SYSTEM.def: Makefile -@BUILD_CORLIB_TRUE@ sh $(GM2_SRC)/tools-src/makeSystem -fpim \ +@BUILD_CORLIB_TRUE@ $(SHELL) $(GM2_SRC)/tools-src/makeSystem -fpim \ @BUILD_CORLIB_TRUE@ $(GM2_SRC)/gm2-libs-cor-common/SYSTEM.def \ @BUILD_CORLIB_TRUE@ $(GM2_SRC)/gm2-libs-cor-common/SYSTEM.mod \ @BUILD_CORLIB_TRUE@ -I$(GM2_SRC)/gm2-libs-cor-common \ diff --git a/libgm2/libm2iso/Makefile.am b/libgm2/libm2iso/Makefile.am index a73d35d1c0b5..45b3c4ab9659 100644 --- a/libgm2/libm2iso/Makefile.am +++ b/libgm2/libm2iso/Makefile.am @@ -253,7 +253,7 @@ SYSTEM.def: Makefile -C="$(GM2_FOR_TARGET)" -o $@ else SYSTEM.def: Makefile - sh $(GM2_SRC)/tools-src/makeSystem -fiso \ + $(SHELL) $(GM2_SRC)/tools-src/makeSystem -fiso \ $(GM2_SRC)/gm2-libs-iso-common/SYSTEM.def \ $(GM2_SRC)/gm2-libs-iso-common/SYSTEM.mod \ -I$(GM2_SRC)/gm2-libs-iso \ diff --git a/libgm2/libm2iso/Makefile.in b/libgm2/libm2iso/Makefile.in index a58928a0cf7a..73bead4999cf 100644 --- a/libgm2/libm2iso/Makefile.in +++ b/libgm2/libm2iso/Makefile.in @@ -965,7 +965,7 @@ uninstall-am: uninstall-toolexeclibLTLIBRARIES @BUILD_ISOLIB_TRUE@@HAVE_PYTHON_INTERPRETER_TRUE@ -I=$(GM2_SRC)/gm2-libs-iso-common \ @BUILD_ISOLIB_TRUE@@HAVE_PYTHON_INTERPRETER_TRUE@ -C="$(GM2_FOR_TARGET)" -o $@ @BUILD_ISOLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@SYSTEM.def: Makefile -@BUILD_ISOLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ sh $(GM2_SRC)/tools-src/makeSystem -fiso \ +@BUILD_ISOLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ $(SHELL) $(GM2_SRC)/tools-src/makeSystem -fiso \ @BUILD_ISOLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ $(GM2_SRC)/gm2-libs-iso-common/SYSTEM.def \ @BUILD_ISOLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ $(GM2_SRC)/gm2-libs-iso-common/SYSTEM.mod \ @BUILD_ISOLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ -I$(GM2_SRC)/gm2-libs-iso \ diff --git a/libgm2/libm2min/Makefile.am b/libgm2/libm2min/Makefile.am index 47fa41644783..bd64fff97fa6 100644 --- a/libgm2/libm2min/Makefile.am +++ b/libgm2/libm2min/Makefile.am @@ -141,7 +141,7 @@ SYSTEM.def: Makefile -C="$(GM2_FOR_TARGET) -fno-exceptions" -o $@ else SYSTEM.def: Makefile - sh $(GM2_SRC)/tools-src/makeSystem -fpim \ + $(SHELL) $(GM2_SRC)/tools-src/makeSystem -fpim \ $(GM2_SRC)/gm2-libs-min/SYSTEM.def \ $(GM2_SRC)/gm2-libs-min/SYSTEM.mod \ -I$(GM2_SRC)/gm2-libs-min -I$(GM2_SRC)/gm2-libs \ diff --git a/libgm2/libm2min/Makefile.in b/libgm2/libm2min/Makefile.in index 12fe0322649f..f664754f18ea 100644 --- a/libgm2/libm2min/Makefile.in +++ b/libgm2/libm2min/Makefile.in @@ -781,7 +781,7 @@ libc.o: $(GM2_SRC)/gm2-libs-min/libc.c @HAVE_PYTHON_INTERPRETER_TRUE@ -I=$(GM2_SRC)/gm2-libs-min -I=$(GM2_SRC)/gm2-libs \ @HAVE_PYTHON_INTERPRETER_TRUE@ -C="$(GM2_FOR_TARGET) -fno-exceptions" -o $@ @HAVE_PYTHON_INTERPRETER_FALSE@SYSTEM.def: Makefile -@HAVE_PYTHON_INTERPRETER_FALSE@ sh $(GM2_SRC)/tools-src/makeSystem -fpim \ +@HAVE_PYTHON_INTERPRETER_FALSE@ $(SHELL) $(GM2_SRC)/tools-src/makeSystem -fpim \ @HAVE_PYTHON_INTERPRETER_FALSE@ $(GM2_SRC)/gm2-libs-min/SYSTEM.def \ @HAVE_PYTHON_INTERPRETER_FALSE@ $(GM2_SRC)/gm2-libs-min/SYSTEM.mod \ @HAVE_PYTHON_INTERPRETER_FALSE@ -I$(GM2_SRC)/gm2-libs-min -I$(GM2_SRC)/gm2-libs \ diff --git a/libgm2/libm2pim/Makefile.am b/libgm2/libm2pim/Makefile.am index 4bf52343a21b..2f92672558f3 100644 --- a/libgm2/libm2pim/Makefile.am +++ b/libgm2/libm2pim/Makefile.am @@ -228,7 +228,7 @@ SYSTEM.def: Makefile -C="$(GM2_FOR_TARGET)" -o $@ else SYSTEM.def: Makefile - sh $(GM2_SRC)/tools-src/makeSystem -fpim \ + $(SHELL) $(GM2_SRC)/tools-src/makeSystem -fpim \ $(GM2_SRC)/gm2-libs-pim-common/SYSTEM.def \ $(GM2_SRC)/gm2-libs-pim-common/SYSTEM.mod \ -I$(GM2_SRC)/gm2-libs-pim-common \ diff --git a/libgm2/libm2pim/Makefile.in b/libgm2/libm2pim/Makefile.in index b985eec1084f..04e60277e71f 100644 --- a/libgm2/libm2pim/Makefile.in +++ b/libgm2/libm2pim/Makefile.in @@ -940,7 +940,7 @@ uninstall-am: uninstall-toolexeclibLTLIBRARIES @BUILD_PIMLIB_TRUE@@HAVE_PYTHON_INTERPRETER_TRUE@ -I=$(GM2_SRC)/gm2-libs \ @BUILD_PIMLIB_TRUE@@HAVE_PYTHON_INTERPRETER_TRUE@ -C="$(GM2_FOR_TARGET)" -o $@ @BUILD_PIMLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@SYSTEM.def: Makefile -@BUILD_PIMLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ sh $(GM2_SRC)/tools-src/makeSystem -fpim \ +@BUILD_PIMLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ $(SHELL) $(GM2_SRC)/tools-src/makeSystem -fpim \ @BUILD_PIMLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ $(GM2_SRC)/gm2-libs-pim-common/SYSTEM.def \ @BUILD_PIMLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ $(GM2_SRC)/gm2-libs-pim-common/SYSTEM.mod \ @BUILD_PIMLIB_TRUE@@HAVE_PYTHON_INTERPRETER_FALSE@ -I$(GM2_SRC)/gm2-libs-pim-common \ From 49501df986031258cc961b054ee0c3dd2c14f999 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A9o=20Hardt?= Date: Mon, 14 Sep 2026 10:27:41 -0300 Subject: [PATCH 129/584] clean(includes): Remove duplicate stringpool includes. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Removed instances in which headers were included twice (always the second one). This happened because, when some functions were moved to attribs.h (314e6352), including stringpool+attribs was done in bulk, without checking whether stringpool was already included. Notice include-guards in stringpool.h. Including it twice has no effect. You can check the validity of this commit by running: find . -maxdepth 1 -type f -name "*.cc" \ | xargs grep '#include "stringpool.h"' \ | sed 's/\(.*\):.*/\1/' \ | sort \ | uniq -c -d \ | sort \ | sed 's/\(.*\)/'' \1 /' inside ./gcc on the current trunk. Best regards, gcc/ChangeLog: * asan.cc: Remove duplicate stringpool includes. * builtins.cc: Likewise. * calls.cc: Likewise. * cgraphunit.cc: Likewise. * dwarf2out.cc: Likewise. * fold-const.cc: Likewise. * function.cc: Likewise. * gimple-expr.cc: Likewise. * internal-fn.cc: Likewise. * ipa.cc: Likewise. * lto-cgraph.cc: Likewise. * pointer-query.cc: Likewise. * tree-streamer-in.cc: Likewise. * varasm.cc: Likewise. Signed-off-by: Léo Hardt --- gcc/asan.cc | 1 - gcc/builtins.cc | 1 - gcc/calls.cc | 1 - gcc/cgraphunit.cc | 1 - gcc/dwarf2out.cc | 1 - gcc/fold-const.cc | 1 - gcc/function.cc | 1 - gcc/gimple-expr.cc | 1 - gcc/internal-fn.cc | 1 - gcc/ipa.cc | 1 - gcc/lto-cgraph.cc | 1 - gcc/pointer-query.cc | 1 - gcc/tree-streamer-in.cc | 1 - gcc/varasm.cc | 1 - 14 files changed, 14 deletions(-) diff --git a/gcc/asan.cc b/gcc/asan.cc index 7f625fdcfa09..6feeae30e35b 100644 --- a/gcc/asan.cc +++ b/gcc/asan.cc @@ -47,7 +47,6 @@ along with GCC; see the file COPYING3. If not see #include "varasm.h" #include "stor-layout.h" #include "tree-iterator.h" -#include "stringpool.h" #include "attribs.h" #include "asan.h" #include "dojump.h" diff --git a/gcc/builtins.cc b/gcc/builtins.cc index f2e21a57a59d..ae414d6ea178 100644 --- a/gcc/builtins.cc +++ b/gcc/builtins.cc @@ -63,7 +63,6 @@ along with GCC; see the file COPYING3. If not see #include "langhooks.h" #include "value-prof.h" #include "builtins.h" -#include "stringpool.h" #include "attribs.h" #include "asan.h" #include "internal-fn.h" diff --git a/gcc/calls.cc b/gcc/calls.cc index e5d67b6c97a5..d4f66bc47f28 100644 --- a/gcc/calls.cc +++ b/gcc/calls.cc @@ -50,7 +50,6 @@ along with GCC; see the file COPYING3. If not see #include "tree-vrp.h" #include "tree-ssanames.h" #include "intl.h" -#include "stringpool.h" #include "hash-map.h" #include "hash-traits.h" #include "attribs.h" diff --git a/gcc/cgraphunit.cc b/gcc/cgraphunit.cc index d397c9ae4cc0..7a7278ace5ac 100644 --- a/gcc/cgraphunit.cc +++ b/gcc/cgraphunit.cc @@ -205,7 +205,6 @@ along with GCC; see the file COPYING3. If not see #include "tree-nested.h" #include "dbgcnt.h" #include "lto-section-names.h" -#include "stringpool.h" #include "attribs.h" #include "ipa-inline.h" #include "omp-offload.h" diff --git a/gcc/dwarf2out.cc b/gcc/dwarf2out.cc index 0b974d63c805..d170e18c7409 100644 --- a/gcc/dwarf2out.cc +++ b/gcc/dwarf2out.cc @@ -95,7 +95,6 @@ along with GCC; see the file COPYING3. If not see #include "tree-dfa.h" #include "gdb/gdb-index.h" #include "rtl-iter.h" -#include "stringpool.h" #include "attribs.h" #include "file-prefix-map.h" /* remap_debug_filename() */ diff --git a/gcc/fold-const.cc b/gcc/fold-const.cc index 4c4b535d4404..b9262b34f766 100644 --- a/gcc/fold-const.cc +++ b/gcc/fold-const.cc @@ -80,7 +80,6 @@ along with GCC; see the file COPYING3. If not see #include "tree-vrp.h" #include "tree-ssanames.h" #include "selftest.h" -#include "stringpool.h" #include "attribs.h" #include "tree-vector-builder.h" #include "vec-perm-indices.h" diff --git a/gcc/function.cc b/gcc/function.cc index 9358787b262c..fd9da3003cdb 100644 --- a/gcc/function.cc +++ b/gcc/function.cc @@ -77,7 +77,6 @@ along with GCC; see the file COPYING3. If not see #include "rtl-iter.h" #include "tree-dfa.h" #include "tree-ssa.h" -#include "stringpool.h" #include "attribs.h" #include "gimple.h" #include "options.h" diff --git a/gcc/gimple-expr.cc b/gcc/gimple-expr.cc index 3b8726ded4d3..fcc31b993906 100644 --- a/gcc/gimple-expr.cc +++ b/gcc/gimple-expr.cc @@ -35,7 +35,6 @@ along with GCC; see the file COPYING3. If not see #include "hash-set.h" #include "rtl.h" #include "tree-pass.h" -#include "stringpool.h" #include "attribs.h" #include "target.h" diff --git a/gcc/internal-fn.cc b/gcc/internal-fn.cc index 3fdf89e0e6e1..9bfca87588b3 100644 --- a/gcc/internal-fn.cc +++ b/gcc/internal-fn.cc @@ -41,7 +41,6 @@ along with GCC; see the file COPYING3. If not see #include "stor-layout.h" #include "dojump.h" #include "expr.h" -#include "stringpool.h" #include "attribs.h" #include "asan.h" #include "ubsan.h" diff --git a/gcc/ipa.cc b/gcc/ipa.cc index 908fb301cd02..0a5f031c6399 100644 --- a/gcc/ipa.cc +++ b/gcc/ipa.cc @@ -39,7 +39,6 @@ along with GCC; see the file COPYING3. If not see #include "ipa-fnsummary.h" #include "dbgcnt.h" #include "debug.h" -#include "stringpool.h" #include "attribs.h" /* Return true when NODE has ADDR reference. */ diff --git a/gcc/lto-cgraph.cc b/gcc/lto-cgraph.cc index adbf59ca821f..bffe35f2353d 100644 --- a/gcc/lto-cgraph.cc +++ b/gcc/lto-cgraph.cc @@ -38,7 +38,6 @@ along with GCC; see the file COPYING3. If not see #include "ipa-utils.h" #include "omp-offload.h" #include "omp-general.h" -#include "stringpool.h" #include "attribs.h" #include "alloc-pool.h" #include "symbol-summary.h" diff --git a/gcc/pointer-query.cc b/gcc/pointer-query.cc index b5ab5cbd1ab2..e230d5f23c51 100644 --- a/gcc/pointer-query.cc +++ b/gcc/pointer-query.cc @@ -31,7 +31,6 @@ #include "tree-object-size.h" #include "tree-ssa-strlen.h" #include "langhooks.h" -#include "stringpool.h" #include "attribs.h" #include "gimple-iterator.h" #include "gimple-fold.h" diff --git a/gcc/tree-streamer-in.cc b/gcc/tree-streamer-in.cc index 595206e0beee..45ba2732d3a3 100644 --- a/gcc/tree-streamer-in.cc +++ b/gcc/tree-streamer-in.cc @@ -31,7 +31,6 @@ along with GCC; see the file COPYING3. If not see #include "cgraph.h" #include "builtins.h" #include "gomp-constants.h" -#include "stringpool.h" #include "attribs.h" #include "asan.h" #include "opts.h" diff --git a/gcc/varasm.cc b/gcc/varasm.cc index ad39bdddcfc4..bcaf80749517 100644 --- a/gcc/varasm.cc +++ b/gcc/varasm.cc @@ -53,7 +53,6 @@ along with GCC; see the file COPYING3. If not see #include "langhooks.h" #include "debug.h" #include "common/common-target.h" -#include "stringpool.h" #include "attribs.h" #include "asan.h" #include "rtl-iter.h" From 89b2fa7a74ef1f7b8f0f8f1abc3bbc412d59302a Mon Sep 17 00:00:00 2001 From: Tobias Burnus Date: Wed, 16 Sep 2026 15:34:34 +0200 Subject: [PATCH 130/584] lto.cc: OpenMP's offload_handle_link_vars - fix for global variables (2/2) [PR127273] Commit r12-7776-g1002a7ace111d7 LTO: Fixes for renaming issues with offload/OpenMP [PR104285] moved the call to offload_handle_link_vars after the renaming of same-named static variables happened. However, it missed to remove the original call - such that the function is always called twice, walking the same node twice. In offload_handle_link_vars, the call to varpool_node::finalize_decl should be be after FOR_EACH_VARIABLE avoid modifying the varpool while walking it. (Albeit new items get appended to the front such that '->next' walks are not affected by added items in the current implementation.) [See r17-4073-ga6310d58aac505 for (1/2).] gcc/lto/ChangeLog: PR middle-end/127273 * lto.cc (offload_handle_link_vars): Remove has-value-expr check; store link vars and processing them after walking the varpool. (lto_main): Remove duplicated offload_handle_link_vars call. --- gcc/lto/lto.cc | 34 +++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/gcc/lto/lto.cc b/gcc/lto/lto.cc index d22827bbcc0a..3a6fe0a961d9 100644 --- a/gcc/lto/lto.cc +++ b/gcc/lto/lto.cc @@ -482,27 +482,29 @@ static void offload_handle_link_vars (void) { #ifdef ACCEL_COMPILER + size_t i; varpool_node *var; + auto_vec temp_link_vars; FOR_EACH_VARIABLE (var) if (lookup_attribute ("omp declare target link", DECL_ATTRIBUTES (var->decl))) - { - if (DECL_HAS_VALUE_EXPR_P (var->decl)) - continue; - tree type = build_pointer_type (TREE_TYPE (var->decl)); - tree link_ptr_var = build_decl (UNKNOWN_LOCATION, VAR_DECL, + temp_link_vars.safe_push (var); + FOR_EACH_VEC_ELT (temp_link_vars, i, var) + { + tree type = build_pointer_type (TREE_TYPE (var->decl)); + tree link_ptr_var = build_decl (UNKNOWN_LOCATION, VAR_DECL, clone_function_name (var->decl, "linkptr"), type); - TREE_USED (link_ptr_var) = 1; - TREE_STATIC (link_ptr_var) = 1; - TREE_PUBLIC (link_ptr_var) = TREE_PUBLIC (var->decl); - DECL_ARTIFICIAL (link_ptr_var) = 1; - SET_DECL_ASSEMBLER_NAME (link_ptr_var, DECL_NAME (link_ptr_var)); - SET_DECL_VALUE_EXPR (var->decl, build_simple_mem_ref (link_ptr_var)); - DECL_HAS_VALUE_EXPR_P (var->decl) = 1; - varpool_node::finalize_decl (link_ptr_var); - varpool_node::get (link_ptr_var)->force_output = var->force_output; - } + TREE_USED (link_ptr_var) = 1; + TREE_STATIC (link_ptr_var) = 1; + TREE_PUBLIC (link_ptr_var) = TREE_PUBLIC (var->decl); + DECL_ARTIFICIAL (link_ptr_var) = 1; + SET_DECL_ASSEMBLER_NAME (link_ptr_var, DECL_NAME (link_ptr_var)); + SET_DECL_VALUE_EXPR (var->decl, build_simple_mem_ref (link_ptr_var)); + DECL_HAS_VALUE_EXPR_P (var->decl) = 1; + varpool_node::finalize_decl (link_ptr_var); + varpool_node::get (link_ptr_var)->force_output = var->force_output; + } #endif } @@ -694,8 +696,6 @@ lto_main (void) if (!seen_error ()) { - offload_handle_link_vars (); - /* If WPA is enabled analyze the whole call graph and create an optimization plan. Otherwise, read in all the function bodies and continue with optimization. */ From c227d573fc26f4dc9c08eff3f5591fc75cdebb82 Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Wed, 16 Sep 2026 11:32:08 +0100 Subject: [PATCH 131/584] libstdc++: Fix typo in preprocessor condition for cstdio=pure [PR127430] libstdc++-v3/ChangeLog: PR libstdc++/127430 * config/io/basic_file_stdio.cc (__basic_file::fd) Fix typo in preprocessor condition. --- libstdc++-v3/config/io/basic_file_stdio.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libstdc++-v3/config/io/basic_file_stdio.cc b/libstdc++-v3/config/io/basic_file_stdio.cc index 669215e81f47..49389ff5c905 100644 --- a/libstdc++-v3/config/io/basic_file_stdio.cc +++ b/libstdc++-v3/config/io/basic_file_stdio.cc @@ -303,7 +303,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __basic_file::is_open() const throw () { return _M_cfile != 0; } -#ifndef _GLIBCCXX_USE_STDIO_PURE +#ifndef _GLIBCXX_USE_STDIO_PURE int __basic_file::fd() throw () { return fileno(_M_cfile); } From fffdaf05ca485db7c2aceed4f9defd66a107c71b Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Wed, 16 Sep 2026 11:35:02 +0100 Subject: [PATCH 132/584] libstdc++: Fix typo in comment in libstdc++-v3/ChangeLog: * include/bits/atomic_wait.h: Fix typo in comment. --- libstdc++-v3/include/bits/atomic_wait.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libstdc++-v3/include/bits/atomic_wait.h b/libstdc++-v3/include/bits/atomic_wait.h index 5224e69817de..22fda6d1b2d3 100644 --- a/libstdc++-v3/include/bits/atomic_wait.h +++ b/libstdc++-v3/include/bits/atomic_wait.h @@ -102,7 +102,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION && ((sizeof(_Tp) == 4 && alignof(_Tp) >= 4) || (sizeof(_Tp) == 8 && alignof(_Tp) >= 8)); #else -// define _GLIBCX_HAVE_PLATFORM_WAIT and implement __platform_wait() +// define _GLIBCXX_HAVE_PLATFORM_WAIT and implement __platform_wait() // and __platform_notify() if there is a more efficient primitive supported // by the platform (e.g. __ulock_wait()/__ulock_wake()) which is better than // a mutex/condvar based wait. From 1d8b0cfa3474c0a9854b8d8340792eaff62b70e7 Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Wed, 16 Sep 2026 11:35:57 +0100 Subject: [PATCH 133/584] libstdc++: Fix typo in comment in 27_io/basic_filebuf/close/char/4879.cc libstdc++-v3/ChangeLog: * testsuite/27_io/basic_filebuf/close/char/4879.cc: Fix typo in comment. --- libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/4879.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/4879.cc b/libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/4879.cc index 3ea586ada7c9..3e0b134edb95 100644 --- a/libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/4879.cc +++ b/libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/4879.cc @@ -76,7 +76,7 @@ test_04() ofs.put('t'); /* - * ISO/IED 14882:1998(E) 27.8.1.10.4 + * ISO/IEC 14882:1998(E) 27.8.1.10.4 * * void close(); * From 2044697b763f133f5e5cffe49b09e4609ce4968f Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Wed, 16 Sep 2026 15:01:07 +0100 Subject: [PATCH 134/584] libstdc++: Fix typo in 20_util/function_objects/dr660.cc libstdc++-v3/ChangeLog: * testsuite/20_util/function_objects/dr660.cc: Include the testsuite_hooks.h header not testsuite_hooks.cc. --- libstdc++-v3/testsuite/20_util/function_objects/dr660.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libstdc++-v3/testsuite/20_util/function_objects/dr660.cc b/libstdc++-v3/testsuite/20_util/function_objects/dr660.cc index b4223b6b66bc..e4725f23aaed 100644 --- a/libstdc++-v3/testsuite/20_util/function_objects/dr660.cc +++ b/libstdc++-v3/testsuite/20_util/function_objects/dr660.cc @@ -18,7 +18,7 @@ // . #include -#include +#include // DR 660. Missing Bitwise Operations. void test01() From 05c3df2b98e66011ba4c5b070d2d755d4d548297 Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Wed, 16 Sep 2026 15:05:05 +0100 Subject: [PATCH 135/584] libstdc++: Regenerate HTML docs libstdc++-v3/ChangeLog: * doc/html/manual/status.html: Regenerate. --- libstdc++-v3/doc/html/manual/status.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libstdc++-v3/doc/html/manual/status.html b/libstdc++-v3/doc/html/manual/status.html index 5df1b8daac32..88ba3405de0b 100644 --- a/libstdc++-v3/doc/html/manual/status.html +++ b/libstdc++-v3/doc/html/manual/status.html @@ -1815,7 +1815,7 @@ 25 Algorithms library - 25.1General  25.2Algorithms requirementsY 25.3Parallel algorithms Uses code from oneDPL25.4Header <algorithm> synopsisY 25.5Algorithm result typesY 25.6Non-modifying sequence operations  25.6.1All ofY 25.6.2Any ofY 25.6.3None ofY 25.6.4For eachY 25.6.5FindY 25.6.6Find endY 25.6.7Find firstY 25.6.8Adjacent findY 25.6.9CountY 25.6.10MismatchY 25.6.11EqualY 25.6.12Is permutationY 25.6.13SearchY 25.7Mutating sequence operations  25.7.1CopyY 25.7.2MoveY 25.7.3SwapY 25.7.4TransformY 25.7.5ReplaceY 25.7.6FillY 25.7.7GenerateY 25.7.8RemoveY 25.7.9UniqueY 25.7.10ReverseY 25.7.11RotateY 25.7.12SampleY 25.7.13ShuffleY 25.7.14ShiftY 25.8Sorting and related operations  25.8.1GeneralY 25.8.2SortingY 25.8.3Nth elementY 25.8.4Binary searchY 25.8.5PartitionsY 25.8.6MergeY 25.8.7Set operations on sorted structuresY 25.8.8Heap operationsY 25.8.9Minimum and maximumY 25.8.10Bounded valueY 25.8.11Lexicographical comparisonY 25.8.12Three-way comparison algorithmsY 25.8.13Permutation generatorsY 25.9Header <numeric> synopsisY 25.10Generalized numeric operations  25.10.1General  25.10.2Definitions  25.10.3AccumulateY 25.10.4ReduceY 25.10.5Inner productY 25.10.6Transform reduceY 25.10.7Partial sumY 25.10.8Exclusive scanY 25.10.9Inclusive scanY 25.10.10Transform exclusive scanY 25.10.11Transform inclusive scanY 25.10.12Adjacent differenceY 25.10.13IotaY 25.10.14Greatest common divisorY 25.10.15Least common multipleY 25.10.16MidpointY 25.11Specialized <memory> algorithms  25.11.1General  25.11.2Special memory conceptsY 25.11.3uninitialized_default_constructY 25.11.4uninitialized_value_constructY 25.11.5uninitialized_copyY 25.11.6uninitialized_moveY 25.11.7uninitialized_fillY 25.11.8construct_atY 25.11.9destroyY 25.12C library algorithmsY  + 25.1General  25.2Algorithms requirementsY 25.3Parallel algorithms Uses code from oneDPL25.4Header <algorithm> synopsisY 25.5Algorithm result typesY 25.6Non-modifying sequence operations  25.6.1All ofY 25.6.2Any ofY 25.6.3None ofY 25.6.4For eachY 25.6.5FindY 25.6.6Find endY 25.6.7Find firstY 25.6.8Adjacent findY 25.6.9CountY 25.6.10MismatchY 25.6.11EqualY 25.6.12Is permutationY 25.6.13SearchY 25.7Mutating sequence operations  25.7.1CopyY 25.7.2MoveY 25.7.3SwapY 25.7.4TransformY 25.7.5ReplaceY 25.7.6FillY 25.7.7GenerateY 25.7.8RemoveY 25.7.9UniqueY 25.7.10ReverseY 25.7.11RotateY 25.7.12SampleY 25.7.13ShuffleY 25.7.14ShiftY 25.8Sorting and related operations  25.8.1GeneralY 25.8.2SortingY 25.8.3Nth elementY 25.8.4Binary searchY 25.8.5PartitionsY 25.8.6MergeY 25.8.7Set operations on sorted structuresY 25.8.8Heap operationsY 25.8.9Minimum and maximumY 25.8.10Bounded valueY 25.8.11Lexicographical comparisonY 25.8.12Three-way comparison algorithmsY 25.8.13Permutation generatorsY 25.9Header <numeric> synopsisY 25.10Generalized numeric operations  25.10.1General  25.10.2Definitions  25.10.3AccumulateY 25.10.4ReduceY 25.10.5Inner productY 25.10.6Transform reduceY 25.10.7Partial sumY 25.10.8Exclusive scanY 25.10.9Inclusive scanY 25.10.10Transform exclusive scanY 25.10.11Transform inclusive scanY 25.10.12Adjacent differenceY 25.10.13IotaY 25.10.14Greatest common divisorY 25.10.15Least common multipleY 25.10.16MidpointY 25.11Specialized <memory> algorithms  25.11.1General  25.11.2Special memory conceptsY 25.11.3uninitialized_default_constructY 25.11.4uninitialized_value_constructY 25.11.5uninitialized_copyY 25.11.6uninitialized_moveY 25.11.7uninitialized_fillY 25.11.8construct_atY 25.11.9destroyY 25.12C library algorithmsY  26 Numerics library From aefe058f869906315a7ba9c2638e258f13d65931 Mon Sep 17 00:00:00 2001 From: Senthil Kumar Selvaraj Date: Wed, 16 Sep 2026 20:18:44 +0530 Subject: [PATCH 136/584] ipa: Fix segfault ICE with fdump-tree-einline on TARGET_OPTION_MISMATCH If a target rejects inlining via the TARGET_CAN_INLINE_P hook for reasons other than optimization options, the compiler currently crashes with a segfault. The MIPS target (mips.cc:mips_can_inline_p), for e.g., rejects inlining on conflicting target attributes, and compiling gcc.target/mips/mips16-attributes-5.c with -fdump-tree-einline segfaults - report_inline_failed_reason passes target_opts_for_fn's result to cl_target_option_print_diff even if NULL. Fix by checking for NULL for before calling cl_target_option_print_diff. gcc/ChangeLog: * ipa-inline.cc (report_inline_failed_reason): Check for NULL before calling cl_target_option_print_diff. --- gcc/ipa-inline.cc | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/gcc/ipa-inline.cc b/gcc/ipa-inline.cc index 5a7615666cc1..ba8bf11b66ee 100644 --- a/gcc/ipa-inline.cc +++ b/gcc/ipa-inline.cc @@ -293,11 +293,16 @@ report_inline_failed_reason (struct cgraph_edge *e) e->caller->lto_file_data->file_name, e->callee->ultimate_alias_target ()->lto_file_data->file_name); } - if (e->inline_failed == CIF_TARGET_OPTION_MISMATCH) - if (dump_file) - cl_target_option_print_diff - (dump_file, 2, target_opts_for_fn (e->caller->decl), - target_opts_for_fn (e->callee->ultimate_alias_target ()->decl)); + if (e->inline_failed == CIF_TARGET_OPTION_MISMATCH + && dump_file) + { + struct cl_target_option *opt_caller + = target_opts_for_fn (e->caller->decl); + struct cl_target_option *opt_callee + = target_opts_for_fn (e->callee->ultimate_alias_target ()->decl); + if (opt_caller != NULL && opt_callee != NULL) + cl_target_option_print_diff (dump_file, 2, opt_caller, opt_callee); + } if (e->inline_failed == CIF_OPTIMIZATION_MISMATCH) if (dump_file) cl_optimization_print_diff From 6ef69b644ea98da590e3830a97a9fed3c3044ca3 Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Thu, 27 Aug 2026 18:46:45 +0200 Subject: [PATCH 137/584] lto: Rebuild saved parallel LTRANS outputs Parallel LTRANS emits make targets without prerequisites. With -save-temps, a later link can select the same output name. Make then accepts the old object as current. Profile generation followed by profile use can therefore link an instrumented LTRANS object without libgcov. Mark each persistent non-cache LTRANS output as phony in the generated makefile. Make then runs its recipe for the current link. Temporary outputs and LTRANS cache entries keep their current behavior. Add a tree-profile test that forces parallel LTRANS with -flto=2 and reuses the saved output name between profile generation and profile use. The test reproduced the stale object failure on x86_64 before the change and passed after it. On AArch64, this test and the six affected LTO profile tests passed in both PGO and AutoFDO modes. Bootstrapped and tested on aarch64-none-linux-gnu. gcc/ChangeLog: * lto-wrapper.cc (run_gcc): Make saved parallel LTRANS outputs phony. gcc/testsuite/ChangeLog: * gcc.dg/tree-prof/lto-save-temps-profile-use.c: New test. Signed-off-by: Kyrylo Tkachov --- gcc/lto-wrapper.cc | 3 +++ .../tree-prof/lto-save-temps-profile-use.c | 27 +++++++++++++++++++ 2 files changed, 30 insertions(+) create mode 100644 gcc/testsuite/gcc.dg/tree-prof/lto-save-temps-profile-use.c diff --git a/gcc/lto-wrapper.cc b/gcc/lto-wrapper.cc index bd25185c218e..333f0ad1d1dd 100644 --- a/gcc/lto-wrapper.cc +++ b/gcc/lto-wrapper.cc @@ -2149,6 +2149,9 @@ run_gcc (unsigned argc, char *argv[]) argv_ptr[6] = NULL; if (parallel) { + /* Saved LTRANS outputs can exist from an earlier link. */ + if (save_temps && !ltrans_cache) + fprintf (mstream, ".PHONY: %s\n", output_name); fprintf (mstream, "%s:\n\t@%s ", output_name, new_argv[0]); for (j = 1; new_argv[j] != NULL; ++j) fprintf (mstream, " '%s'", new_argv[j]); diff --git a/gcc/testsuite/gcc.dg/tree-prof/lto-save-temps-profile-use.c b/gcc/testsuite/gcc.dg/tree-prof/lto-save-temps-profile-use.c new file mode 100644 index 000000000000..760dd7cfe739 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-prof/lto-save-temps-profile-use.c @@ -0,0 +1,27 @@ +/* { dg-require-effective-target lto } */ +/* { dg-options "-O2 -flto=2 -flto-partition=one -save-temps" } */ + +static int __attribute__ ((noinline, noipa)) +identity (int value) +{ + return value; +} + +static int (*volatile indirect_call) (int) = identity; + +int +main (void) +{ + int result = 0; + +#ifdef FOR_AUTOFDO_TESTING + const int iterations = 1000000; +#else + const int iterations = 1; +#endif + + for (int i = 0; i < iterations; ++i) + result |= indirect_call (0); + + return result; +} From 7e9b16ff30b30bc37a584ade0e8900b518a73a11 Mon Sep 17 00:00:00 2001 From: Pietro Monteiro Date: Wed, 16 Sep 2026 14:09:00 -0400 Subject: [PATCH 138/584] algol68: Skip backslash at the end of lines on the scanner The scanner builds a list of lines from the source code. Then it iterates over the list concatenating the lines that end with backslashes with the following line. Instead of iterating over all lines skip a backslash if it preceeds a newline. gcc/algol68/ChangeLog: * a68-parser-scanner.cc (concatenate_lines): Delete. (read_source_file): Stop calling concatenate_lines. (next_char): Skip backslash at the end of lines. (include_files): Stop calling concatenate_lines. gcc/testsuite/ChangeLog: * algol68/execute/backslash-1.a68: New test. Signed-off-by: Pietro Monteiro --- gcc/algol68/a68-parser-scanner.cc | 43 +++---------------- gcc/testsuite/algol68/execute/backslash-1.a68 | 6 +++ 2 files changed, 13 insertions(+), 36 deletions(-) create mode 100644 gcc/testsuite/algol68/execute/backslash-1.a68 diff --git a/gcc/algol68/a68-parser-scanner.cc b/gcc/algol68/a68-parser-scanner.cc index 30c23996dcd8..5ddf25894a24 100644 --- a/gcc/algol68/a68-parser-scanner.cc +++ b/gcc/algol68/a68-parser-scanner.cc @@ -285,38 +285,6 @@ unworthy (LINE_T *u, char *v, char ch) a68_scan_error (u, v, A68 (edit_line)); } -/* Concatenate lines that terminate in '\' with next line. */ - -static void -concatenate_lines (LINE_T * top) -{ - LINE_T *q; - /* Work from bottom backwards. */ - for (q = top; q != NO_LINE && NEXT (q) != NO_LINE; FORWARD (q)) - ; - - for (; q != NO_LINE; BACKWARD (q)) - { - char *z = STRING (q); - size_t len = strlen (z); - - if (len >= 2 - && z[len - 2] == BACKSLASH_CHAR - && z[len - 1] == NEWLINE_CHAR - && NEXT (q) != NO_LINE - && STRING (NEXT (q)) != NO_TEXT) - { - z[len - 2] = '\0'; - len += (int) strlen (STRING (NEXT (q))); - z = (char *) xmalloc (len + 1); - a68_bufcpy (z, STRING (q), len + 1); - a68_bufcat (z, STRING (NEXT (q)), len + 1); - STRING (NEXT (q))[0] = '\0'; - STRING (q) = z; - } - } -} - /* Read source file FILENAME and make internal copy. */ static bool @@ -400,9 +368,6 @@ read_source_file (const char *filename) ? upper_postlude : supper_postlude, &ref_l, &line_num, "postlude"); - /* Concatenate lines that end with \. */ - concatenate_lines (TOP_LINE (&A68_JOB)); - /* Include files. */ include_files (TOP_LINE (&A68_JOB)); @@ -439,6 +404,13 @@ next_char (LINE_T **ref_l, char **ref_s, bool allow_typo, else (*ref_s)++; + /* Skip backslash at the end of lines. */ + if ((*ref_s)[0] == BACKSLASH_CHAR && (*ref_s)[1] == NEWLINE_CHAR) + { + (*ref_s)++; + return next_char (ref_l, ref_s, allow_typo, allow_one_under, found_under); + } + /* Deliver next char. */ ch = (*ref_s)[0]; if ((allow_typo && (ISSPACE (ch) || ch == FORMFEED_CHAR)) @@ -1133,7 +1105,6 @@ include_files (LINE_T *top) /* Conclude and go find another include directive, if any. */ NEXT (t) = s; PREVIOUS (s) = t; - concatenate_lines (top); if (fclose (fp) != 0) gcc_unreachable (); make_pass = true; diff --git a/gcc/testsuite/algol68/execute/backslash-1.a68 b/gcc/testsuite/algol68/execute/backslash-1.a68 new file mode 100644 index 000000000000..120fc2188909 --- /dev/null +++ b/gcc/testsuite/algol68/execute/backslash-1.a68 @@ -0,0 +1,6 @@ +begin + string foobar = "foo bar"; + string fubar = "foo \ +bar"; + assert (foobar = fubar) +end From e4fce8081ecdab50ebf9b88bb7b3015990aa6d42 Mon Sep 17 00:00:00 2001 From: Pietro Monteiro Date: Wed, 16 Sep 2026 14:09:00 -0400 Subject: [PATCH 139/584] algol68: Add location_t to LINE_T Use a location_t to track the position of LINE_T's. Use the linemap associated with the location to track the file name the line belongs to. gcc/algol68/ChangeLog: * a68-low-bits.cc (a68_bits_elem): Use LINE_NUMBER (p) instead of NUMBER (LINE (INFO (p))). * a68-low-chars.cc (a68_char_repr): Likewise. * a68-low-coercions.cc (a68_lower_uniting): Likewise. * a68-low-misc.cc (a68_lower_assertion): Likewise. * a68-low-multiples.cc (a68_multiple_slice): Likewise. (a68_multiple_single_bound_check): Likewise. (a68_boundable_dim_check): Likewise. (a68_multiple_bounds_check): Likewise. (a68_multiple_bounds_check_equal): Likewise. * a68-low.cc (a68_checked_indirect_ref): Likewise. * a68-parser-scanner.cc (new_source_line): Adjust the fields when creating a LINE_T. (append_source_line): Add a location_t to the new line. (append_environ): Track the locations of pre/post-lude. (read_source_file): Create a linemap for the source file. (include_files): Create a linemap for included source files. * a68-parser-top-down.cc (a68_phrase_to_text): Use unsigned for line numbers. * a68-parser.cc (a68_get_node_location): Return the location of the node info line. (a68_get_line_location): Return the location of the line. * a68-pretty-print.h (a68_line_format_token): Use the line's filename to check if it's part of the standard environment. * a68-types.h (struct LINE_T): Remove filename and number fields from LINE_T and add location. (FILENAME): Delete macro. (LOCATION): New macro. (LINE_NUMBER): Adjust to use LINE_NO (line). * a68.h (FILENAME): New function. (LINE_NO): Likewise. Signed-off-by: Pietro Monteiro --- gcc/algol68/a68-low-bits.cc | 2 +- gcc/algol68/a68-low-chars.cc | 2 +- gcc/algol68/a68-low-coercions.cc | 2 +- gcc/algol68/a68-low-misc.cc | 2 +- gcc/algol68/a68-low-multiples.cc | 10 +++---- gcc/algol68/a68-low.cc | 2 +- gcc/algol68/a68-parser-scanner.cc | 45 +++++++++++++++++++----------- gcc/algol68/a68-parser-top-down.cc | 3 +- gcc/algol68/a68-parser.cc | 25 +++++------------ gcc/algol68/a68-pretty-print.h | 7 +++-- gcc/algol68/a68-types.h | 7 ++--- gcc/algol68/a68.h | 24 ++++++++++++++++ 12 files changed, 78 insertions(+), 53 deletions(-) diff --git a/gcc/algol68/a68-low-bits.cc b/gcc/algol68/a68-low-bits.cc index 1857b830cb16..2a4cd8b5adad 100644 --- a/gcc/algol68/a68-low-bits.cc +++ b/gcc/algol68/a68-low-bits.cc @@ -216,7 +216,7 @@ a68_bits_elem (NODE_T *p, tree pos, tree bits) /* Do bounds checking if requested. */ if (OPTION_BOUNDS_CHECKING (&A68_JOB)) { - unsigned int lineno = NUMBER (LINE (INFO (p))); + unsigned int lineno = LINE_NUMBER (p); const char *filename_str = FILENAME (LINE (INFO (p))); tree filename = build_string_literal (strlen (filename_str) + 1, filename_str); diff --git a/gcc/algol68/a68-low-chars.cc b/gcc/algol68/a68-low-chars.cc index 90aa6f547ecd..381e455b7f1f 100644 --- a/gcc/algol68/a68-low-chars.cc +++ b/gcc/algol68/a68-low-chars.cc @@ -89,7 +89,7 @@ a68_char_repr (NODE_T *p, tree val) range1, range2)); /* Call to the runtime run-time error handler. */ - unsigned int lineno = NUMBER (LINE (INFO (p))); + unsigned int lineno = LINE_NUMBER (p); const char *filename_str = FILENAME (LINE (INFO (p))); tree filename = build_string_literal (strlen (filename_str) + 1, filename_str); diff --git a/gcc/algol68/a68-low-coercions.cc b/gcc/algol68/a68-low-coercions.cc index 3941917223f0..54079122880d 100644 --- a/gcc/algol68/a68-low-coercions.cc +++ b/gcc/algol68/a68-low-coercions.cc @@ -117,7 +117,7 @@ a68_lower_uniting (NODE_T *p, LOW_CTX_T ctx) /* This should not be reached. Emit run-time error. */ { - unsigned int lineno = NUMBER (LINE (INFO (p))); + unsigned int lineno = LINE_NUMBER (p); const char *filename_str = FILENAME (LINE (INFO (p))); tree filename = build_string_literal (strlen (filename_str) + 1, filename_str); diff --git a/gcc/algol68/a68-low-misc.cc b/gcc/algol68/a68-low-misc.cc index b1048b6b8ca8..8d0d157e5b38 100644 --- a/gcc/algol68/a68-low-misc.cc +++ b/gcc/algol68/a68-low-misc.cc @@ -54,7 +54,7 @@ a68_lower_assertion (NODE_T *p, LOW_CTX_T ctx) return a68_get_empty(); /* Build the call to the assert run-time function. */ - unsigned int lineno = NUMBER (LINE (INFO (p))); + unsigned int lineno = LINE_NUMBER (p); const char *filename_str = FILENAME (LINE (INFO (p))); tree filename = build_string_literal (strlen (filename_str) + 1, filename_str); diff --git a/gcc/algol68/a68-low-multiples.cc b/gcc/algol68/a68-low-multiples.cc index b72f8bbb89a2..3f63d7d93b2d 100644 --- a/gcc/algol68/a68-low-multiples.cc +++ b/gcc/algol68/a68-low-multiples.cc @@ -525,7 +525,7 @@ a68_multiple_slice (NODE_T *p, if (OPTION_BOUNDS_CHECKING (&A68_JOB)) { tree upper_bound = a68_multiple_upper_bound (multiple, size_int (idx)); - unsigned int lineno = NUMBER (LINE (INFO (p))); + unsigned int lineno = LINE_NUMBER (p); const char *filename_str = FILENAME (LINE (INFO (p))); tree filename = build_string_literal (strlen (filename_str) + 1, filename_str); @@ -858,7 +858,7 @@ a68_multiple_single_bound_check (NODE_T *p, tree dim, : A68_LIBCALL_ARRAYLOWERBOUND); /* Build the call to ARRAY*BOUNDS. */ - unsigned int lineno = NUMBER (LINE (INFO (p))); + unsigned int lineno = LINE_NUMBER (p); const char *filename_str = FILENAME (LINE (INFO (p))); tree filename = build_string_literal (strlen (filename_str) + 1, filename_str); @@ -897,7 +897,7 @@ a68_boundable_dim_check (NODE_T *p, tree boundable_dim, tree dim) dim = save_expr (dim); /* Build the call to ARRAYDIM. */ - unsigned int lineno = NUMBER (LINE (INFO (p))); + unsigned int lineno = LINE_NUMBER (p); const char *filename_str = FILENAME (LINE (INFO (p))); tree filename = build_string_literal (strlen (filename_str) + 1, filename_str); @@ -965,7 +965,7 @@ a68_multiple_bounds_check (NODE_T *p, tree dim, tree lower_bound = a68_multiple_lower_bound (multiple, dim); /* Build the call to ARRAYBOUNDS. */ - unsigned int lineno = NUMBER (LINE (INFO (p))); + unsigned int lineno = LINE_NUMBER (p); const char *filename_str = FILENAME (LINE (INFO (p))); tree filename = build_string_literal (strlen (filename_str) + 1, filename_str); @@ -1043,7 +1043,7 @@ a68_multiple_bounds_check_equal (NODE_T *p, tree m1, tree m2) fold_build2 (EQ_EXPR, boolean_type_node, ub1, ub2)); - unsigned int lineno = NUMBER (LINE (INFO (p))); + unsigned int lineno = LINE_NUMBER (p); const char *filename_str = FILENAME (LINE (INFO (p))); tree filename = build_string_literal (strlen (filename_str) + 1, filename_str); diff --git a/gcc/algol68/a68-low.cc b/gcc/algol68/a68-low.cc index 40636601c036..ea69206c5cc1 100644 --- a/gcc/algol68/a68-low.cc +++ b/gcc/algol68/a68-low.cc @@ -673,7 +673,7 @@ a68_checked_indirect_ref (NODE_T *p, tree exp, MOID_T *exp_mode) tree consolidated_exp = a68_consolidate_ref (exp_mode, exp); /* Check whether we are dereferencing NIL. */ - unsigned int lineno = NUMBER (LINE (INFO (p))); + unsigned int lineno = LINE_NUMBER (p); const char *filename_str = FILENAME (LINE (INFO (p))); tree filename = build_string_literal (strlen (filename_str) + 1, filename_str); diff --git a/gcc/algol68/a68-parser-scanner.cc b/gcc/algol68/a68-parser-scanner.cc index 5ddf25894a24..ce8df69d1119 100644 --- a/gcc/algol68/a68-parser-scanner.cc +++ b/gcc/algol68/a68-parser-scanner.cc @@ -219,8 +219,7 @@ new_source_line (void) MARKER (z)[0] = '\0'; STRING (z) = NO_TEXT; - FILENAME (z) = NO_TEXT; - NUMBER (z) = 0; + LOCATION (z) = UNKNOWN_LOCATION; NEXT (z) = NO_LINE; PREVIOUS (z) = NO_LINE; return z; @@ -229,15 +228,15 @@ new_source_line (void) /* Append a source line to the internal source file. */ static void -append_source_line (const char *str, LINE_T **ref_l, int *line_num, - const char *filename) +append_source_line (const char *str, LINE_T **ref_l, int *line_num) { LINE_T *z = new_source_line (); /* Link line into the chain. */ STRING (z) = xstrdup (str); - FILENAME (z) = ggc_strdup (filename); - NUMBER (z) = (*line_num)++; + LOCATION (z) = linemap_line_start (line_table, + (*line_num)++, + 80 /* max_column_hint */); NEXT (z) = NO_LINE; PREVIOUS (z) = *ref_l; if (TOP_LINE (&A68_JOB) == NO_LINE) @@ -250,14 +249,15 @@ append_source_line (const char *str, LINE_T **ref_l, int *line_num, /* Append environment source lines. */ static void -append_environ (const char *str[], LINE_T **ref_l, int *line_num, const char *name) +append_environ (const char *str[], LINE_T **ref_l, const char *name) { + linemap_add (line_table, LC_ENTER, 1 /* sys_p */, name, 0 /* to_line */); for (int k = 0; str[k] != NO_TEXT; k++) { - int zero_line_num = 0; - (*line_num)++; - append_source_line (str[k], ref_l, &zero_line_num, name); + int line_num = 1; + append_source_line (str[k], ref_l, &line_num); } + linemap_add (line_table, LC_LEAVE, 0, NULL, 0); } /* @@ -292,7 +292,7 @@ read_source_file (const char *filename) { struct stat statbuf; LINE_T *ref_l = NO_LINE; - int line_num = 0; + int line_num; size_t k; size_t bytes_read; ssize_t l; @@ -328,13 +328,14 @@ read_source_file (const char *filename) /* Prelude. */ append_environ (OPTION_STROPPING (&A68_JOB) == UPPER_STROPPING ? upper_prelude_start : supper_prelude_start, - &ref_l, &line_num, "prelude"); + &ref_l, "prelude"); /* Read the file into a single buffer, so we save on system calls. */ line_num = 1; buffer = (char *) xmalloc (8 + source_file_size); bytes_read = a68_file_read (fileno (f), buffer, source_file_size); gcc_assert (bytes_read == source_file_size); + linemap_add (line_table, LC_ENTER, 0 /* sys_p */, filename, 0 /* to_line */); /* Link all lines into the list. */ k = 0; @@ -357,20 +358,27 @@ read_source_file (const char *filename) A68_PARSER (scan_buf)[l] = '\0'; if (k < source_file_size) k++; - append_source_line (A68_PARSER (scan_buf), &ref_l, &line_num, - FILE_SOURCE_NAME (&A68_JOB)); + append_source_line (A68_PARSER (scan_buf), &ref_l, &line_num); SCAN_ERROR (l != (ssize_t) strlen (A68_PARSER (scan_buf)), NO_LINE, NO_TEXT, "invalid characters in source file"); } + /* Extra line before adding postlude. */ + linemap_line_start (line_table, + line_num, + 80 /* max_column_hint */); + /* Postlude. */ append_environ (OPTION_STROPPING (&A68_JOB) == UPPER_STROPPING ? upper_postlude : supper_postlude, - &ref_l, &line_num, "postlude"); + &ref_l, "postlude"); /* Include files. */ include_files (TOP_LINE (&A68_JOB)); + linemap_add (line_table, LC_LEAVE, 0, NULL, 0); + linemap_check_files_exited (line_table); + if (fclose (FILE_SOURCE_FD (&A68_JOB)) != 0) gcc_unreachable (); return ret; @@ -1060,6 +1068,8 @@ include_files (LINE_T *top) SCAN_ERROR ((size_t) bytes_read != fsize, start_l, start_c, "error while reading file"); + linemap_add (line_table, LC_ENTER, 0 /* sys_p */, fn, + 0 /* to_line */); /* Buffer still usable?. */ if (fsize > A68_PARSER (max_scan_buf_length)) { @@ -1077,7 +1087,7 @@ include_files (LINE_T *top) /* If file is empty, insert single empty line. */ A68_PARSER (scan_buf)[0] = NEWLINE_CHAR; A68_PARSER (scan_buf)[1] = NULL_CHAR; - append_source_line (A68_PARSER (scan_buf), &t, &linum, fn); + append_source_line (A68_PARSER (scan_buf), &t, &linum); } else { @@ -1098,11 +1108,12 @@ include_files (LINE_T *top) A68_PARSER (scan_buf)[n] = NULL_CHAR; if (k < fsize) k++; - append_source_line (A68_PARSER (scan_buf), &t, &linum, fn); + append_source_line (A68_PARSER (scan_buf), &t, &linum); } } /* Conclude and go find another include directive, if any. */ + linemap_add (line_table, LC_LEAVE, 0, NULL, 0); NEXT (t) = s; PREVIOUS (s) = t; if (fclose (fp) != 0) diff --git a/gcc/algol68/a68-parser-top-down.cc b/gcc/algol68/a68-parser-top-down.cc index 238749fcb66d..b3f332101b8e 100644 --- a/gcc/algol68/a68-parser-top-down.cc +++ b/gcc/algol68/a68-parser-top-down.cc @@ -64,7 +64,8 @@ const char * a68_phrase_to_text (NODE_T * p, NODE_T ** w) { #define MAX_TERMINALS 8 - int count = 0, line = -1; + int count = 0; + unsigned int line = 0; static BUFFER buffer; for (buffer[0] = '\0'; p != NO_NODE && count < MAX_TERMINALS; FORWARD (p)) diff --git a/gcc/algol68/a68-parser.cc b/gcc/algol68/a68-parser.cc index 4303d5297e85..878d9d6cd9b1 100644 --- a/gcc/algol68/a68-parser.cc +++ b/gcc/algol68/a68-parser.cc @@ -1153,18 +1153,9 @@ a68_get_node_location (NODE_T *p) if (line == NO_LINE) return UNKNOWN_LOCATION; - unsigned line_number = NUMBER (line); - unsigned column_number = CHAR_IN_LINE (INFO (p)) - STRING (line) + 1; - const char *filename = FILENAME (line); - - location_t gcc_location; - - linemap_add (line_table, LC_ENTER, 0, filename, line_number); - linemap_line_start (line_table, line_number, 0); - gcc_location = linemap_position_for_column (line_table, column_number); - linemap_add (line_table, LC_LEAVE, 0, NULL, 0); - - return gcc_location; + const char *start_pos = CHAR_IN_LINE (INFO (p)); + location_t start_loc = a68_get_line_location (line, start_pos); + return start_loc; } /* Get the location of POS inside LINE as a GCC location. */ @@ -1172,11 +1163,9 @@ a68_get_node_location (NODE_T *p) location_t a68_get_line_location (LINE_T *line, const char *pos) { - location_t loc; - - linemap_add (line_table, LC_ENTER, 0, FILENAME (line), NUMBER (line)); - linemap_line_start (line_table, NUMBER (line), 0); - loc = linemap_position_for_column (line_table, pos - STRING (line) + 1); - linemap_add (line_table, LC_LEAVE, 0, NULL, 0); + unsigned column_number = pos - STRING (line) + 1; + location_t loc = linemap_position_for_loc_and_offset (line_table, + LOCATION(line), + column_number); return loc; } diff --git a/gcc/algol68/a68-pretty-print.h b/gcc/algol68/a68-pretty-print.h index 16dbb415b861..0b78599876f7 100644 --- a/gcc/algol68/a68-pretty-print.h +++ b/gcc/algol68/a68-pretty-print.h @@ -223,14 +223,15 @@ struct a68_line_format_token : public a68_format_token a68_line_format_token (LINE_T *l, NODE_T *n) { gcc_assert (l != NO_LINE); - if (NUMBER (l) == 0) + const char *fname = FILENAME (l); + if (strcmp (fname, "prelude") == 0 || strcmp (fname, "postlude") == 0) m_str = xstrdup ("in standard environment"); - else if (n != NO_NODE && NUMBER (l) == LINE_NUMBER (n)) + else if (n != NO_NODE && LINE_NO (l) == LINE_NUMBER (n)) m_str = xstrdup ("in this line"); else { m_str = (char *) xmalloc (18); - if (snprintf (m_str, 18, "in line %d", NUMBER (l)) < 0) + if (snprintf (m_str, 18, "in line %d", LINE_NO (l)) < 0) gcc_unreachable (); } } diff --git a/gcc/algol68/a68-types.h b/gcc/algol68/a68-types.h index 5bf348890f77..472a8bb29ef1 100644 --- a/gcc/algol68/a68-types.h +++ b/gcc/algol68/a68-types.h @@ -537,8 +537,7 @@ struct GTY((chain_next ("%h.next"))) LINE_T { char marker[6]; char * GTY((skip)) string; - const char *filename; - int number; + location_t location; LINE_T *next, *previous; }; #define NO_LINE ((LINE_T *) 0) @@ -949,7 +948,6 @@ struct GTY(()) A68_T #define EXTRACT_VARIABLE(p) ((p)->variable) #define WARNING_COUNT(p) ((p)->warning_count) #define F(p) ((p)->f) -#define FILENAME(p) ((p)->filename) #define FILE_SOURCE_FD(p) ((p)->file_source_fd) #define FILE_SOURCE_NAME(p) ((p)->file_source_name) #define FLEXO(p) ((p).flexo) @@ -996,10 +994,11 @@ struct GTY(()) A68_T #define LEX_LEVEL(p) (LEVEL (TABLE (p))) #define LINBUF(p) ((p)->linbuf) #define LINE(p) ((p)->line) +#define LOCATION(p) ((p)->location) #define LINE_APPLIED(p) ((p)->line_applied) #define LINE_DEFINED(p) ((p)->line_defined) #define LINE_END_MENDED(p) ((p)->line_end_mended) -#define LINE_NUMBER(p) (NUMBER (LINE (INFO (p)))) +#define LINE_NUMBER(p) (LINE_NO (LINE (INFO (p)))) #define LINSIZ(p) ((p)->linsiz) #define LIST(p) ((p)->list) #define ln(x) (log (x)) diff --git a/gcc/algol68/a68.h b/gcc/algol68/a68.h index 13603061290c..bf0e00e6d84d 100644 --- a/gcc/algol68/a68.h +++ b/gcc/algol68/a68.h @@ -107,6 +107,30 @@ enum #include "a68-types.h" +/* Location-tracking functions. */ + +/* Get the file name that LINE belongs to. */ + +inline const char * +FILENAME (LINE_T *line) +{ + const line_map_ordinary * ord_map; + ord_map = (const line_map_ordinary *)(linemap_lookup (line_table, + LOCATION (line))); + return LINEMAP_FILE (ord_map); +} + +/* Get the 1-based line number of LINE. */ + +inline unsigned int +LINE_NO (LINE_T *line) +{ + location_t loc = LOCATION (line); + const line_map_ordinary * ord_map; + ord_map = (const line_map_ordinary *)(linemap_lookup (line_table, loc)); + return SOURCE_LINE (ord_map, loc); +} + /* Front-end global state. */ extern GTY(()) A68_T a68_common; From d9128914a30615902befa37be7aacab28696d06a Mon Sep 17 00:00:00 2001 From: Pietro Monteiro Date: Wed, 16 Sep 2026 14:09:00 -0400 Subject: [PATCH 140/584] algol68: Improve location tracking Create a location that covers the node text and has the caret pointing to the start of the text. gcc/algol68/ChangeLog: * a68-parser.cc (a68_get_node_location): Return a location that covers the whole span of the node. Signed-off-by: Pietro Monteiro --- gcc/algol68/a68-parser.cc | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/gcc/algol68/a68-parser.cc b/gcc/algol68/a68-parser.cc index 878d9d6cd9b1..40ebe507492a 100644 --- a/gcc/algol68/a68-parser.cc +++ b/gcc/algol68/a68-parser.cc @@ -1155,7 +1155,14 @@ a68_get_node_location (NODE_T *p) const char *start_pos = CHAR_IN_LINE (INFO (p)); location_t start_loc = a68_get_line_location (line, start_pos); - return start_loc; + + if (NSYMBOL (p) == NO_TEXT) + return start_loc; + + const char *end_pos = start_pos + strlen (NSYMBOL (p)) - 1; + location_t end_loc = a68_get_line_location (line, end_pos); + + return make_location (start_loc, start_loc, end_loc); } /* Get the location of POS inside LINE as a GCC location. */ From d7fa48a8500bcfaa1cf4ae3f917c22aa6ec7c75f Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Wed, 16 Sep 2026 22:22:20 +0200 Subject: [PATCH 141/584] c: Fix up integer promotion of bit-precise bit-fields [PR127383] The following testcases are miscompiled when a bit-precise integer bit-field is explicitly cast to a non-cv-qualified bit-precise integer (of the same signedness) with precision of the bit-field width. We can then incorrectly apply an integer promotion of the bit-field to the corresponding bit-precise integer, even when it shouldn't be applied (because it is a cast rather than the bit-field itself). Regardless of the cv-qualifications, the TREE_TYPE of the FIELD_DECLs (and COMPONENT_REFs) is a cv-unqualified BITINT_TYPE. We first call convert to that type in convert_lvalue_to_rvalue and that doesn't change anything. If there is an explicit cast to the same type as the TREE_TYPE of the COMPONENT_REF has, we usually wrap it into a NON_LVALUE_EXPR, because the COMPONENT_REF is usually an lvalue (but as can be seen in the testcases, not always). So the second hunk makes sure to add NON_LVALUE_EXPR around the COMPONENT_REF even in the (cast) foo ().a cases to distinguish it from foo ().a. The second change is in default_conversion, for the promotion of bit-fields of bit-precise integer type we don't promote them if they are wrapped in some cast or NON_LVALUE_EXPR (the function normally uses STRIP_TYPE_NOPS). 2026-09-16 Jakub Jelinek PR c/127383 * c-typeck.cc (default_conversion): If orig_expr is different from exp and exp is a bit-field of bit-precise integer type, call perform_integral_promotions on orig_exp rather than exp. (build_c_cast): Wrap in NON_LVALUE_EXPR not just lvalues, but also non-lvalue bit-fields of bit-precise integer type. * gcc.dg/torture/bitint-108.c: New test. * gcc.dg/bitint-143.c: New test. * gcc.dg/bitint-144.c: New test. Reviewed-by: Joseph Myers --- gcc/c/c-typeck.cc | 19 ++++++++- gcc/testsuite/gcc.dg/bitint-143.c | 45 ++++++++++++++++++++++ gcc/testsuite/gcc.dg/bitint-144.c | 47 +++++++++++++++++++++++ gcc/testsuite/gcc.dg/torture/bitint-108.c | 16 ++++++++ 4 files changed, 125 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/bitint-143.c create mode 100644 gcc/testsuite/gcc.dg/bitint-144.c create mode 100644 gcc/testsuite/gcc.dg/torture/bitint-108.c diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc index ed234f075ca8..ed755ff0e50b 100644 --- a/gcc/c/c-typeck.cc +++ b/gcc/c/c-typeck.cc @@ -2907,7 +2907,17 @@ default_conversion (tree exp) return convert (promoted_type, exp); if (INTEGRAL_TYPE_P (type)) - return perform_integral_promotions (exp); + { + /* Avoid performing integral promotion of bit-precise integer + type bit-field to its corresponding bit-precise integer if + orig_exp is a cast to it to its underlying type. */ + if (orig_exp != exp + && TREE_CODE (exp) == COMPONENT_REF + && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1)) + && BITINT_TYPE_P (DECL_BIT_FIELD_TYPE (TREE_OPERAND (exp, 1)))) + return perform_integral_promotions (orig_exp); + return perform_integral_promotions (exp); + } return exp; } @@ -7673,7 +7683,12 @@ build_c_cast (location_t loc, tree type, tree expr) } /* Don't let a cast be an lvalue. */ - if (lvalue_p (value)) + if (lvalue_p (value) + /* Also, don't let a cast be a bit-field of a bit-precise integer type, + otherwise it could be incorrectly subject of integer promotions. */ + || (TREE_CODE (value) == COMPONENT_REF + && DECL_C_BIT_FIELD (TREE_OPERAND (value, 1)) + && BITINT_TYPE_P (DECL_BIT_FIELD_TYPE (TREE_OPERAND (value, 1))))) value = non_lvalue_loc (loc, value); /* Don't allow the results of casting to floating-point or complex diff --git a/gcc/testsuite/gcc.dg/bitint-143.c b/gcc/testsuite/gcc.dg/bitint-143.c new file mode 100644 index 000000000000..eedddce2b221 --- /dev/null +++ b/gcc/testsuite/gcc.dg/bitint-143.c @@ -0,0 +1,45 @@ +/* PR c/127383 */ +/* { dg-do compile { target bitint } } */ +/* { dg-options "-std=c23" } */ + +#define expr_has_type(e, t) _Generic (e, default : 0, t : 1) + +struct S { _BitInt(195) a : 193; const unsigned _BitInt(195) b : 193; volatile _BitInt(195) c : 193; const volatile unsigned _BitInt(195) d : 193; }; +struct S s; +struct S foo (); +static_assert (expr_has_type (+s.a, _BitInt(195))); +static_assert (expr_has_type (+s.b, unsigned _BitInt(195))); +static_assert (expr_has_type (+s.c, _BitInt(195))); +static_assert (expr_has_type (+s.d, unsigned _BitInt(195))); +static_assert (expr_has_type ((_BitInt(193)) s.a, _BitInt(193))); +static_assert (expr_has_type ((unsigned _BitInt(193)) s.b, unsigned _BitInt(193))); +static_assert (expr_has_type ((_BitInt(193)) s.c, _BitInt(193))); +static_assert (expr_has_type ((unsigned _BitInt(193)) s.d, unsigned _BitInt(193))); +static_assert (expr_has_type (+(_BitInt(193)) s.a, _BitInt(193))); +static_assert (expr_has_type (+(unsigned _BitInt(193)) s.b, unsigned _BitInt(193))); +static_assert (expr_has_type (+(_BitInt(193)) s.c, _BitInt(193))); +static_assert (expr_has_type (+(unsigned _BitInt(193)) s.d, unsigned _BitInt(193))); +static_assert (expr_has_type ((const _BitInt(193)) s.a, _BitInt(193))); +static_assert (expr_has_type ((volatile unsigned _BitInt(193)) s.b, unsigned _BitInt(193))); +static_assert (expr_has_type ((const volatile _BitInt(193)) s.c, _BitInt(193))); +static_assert (expr_has_type ((const unsigned _BitInt(193)) s.d, unsigned _BitInt(193))); +static_assert (expr_has_type (+(_BitInt(193)) s.a, _BitInt(193))); +static_assert (expr_has_type (+(unsigned _BitInt(193)) s.b, unsigned _BitInt(193))); +static_assert (expr_has_type (+(_BitInt(193)) s.c, _BitInt(193))); +static_assert (expr_has_type (+(unsigned _BitInt(193)) s.d, unsigned _BitInt(193))); +static_assert (expr_has_type (+foo ().a, _BitInt(195))); +static_assert (expr_has_type (+foo ().b, unsigned _BitInt(195))); +static_assert (expr_has_type (+foo ().c, _BitInt(195))); +static_assert (expr_has_type (+foo ().d, unsigned _BitInt(195))); +static_assert (expr_has_type ((_BitInt(193)) foo ().a, _BitInt(193))); +static_assert (expr_has_type ((unsigned _BitInt(193)) foo ().b, unsigned _BitInt(193))); +static_assert (expr_has_type ((_BitInt(193)) foo ().c, _BitInt(193))); +static_assert (expr_has_type ((unsigned _BitInt(193)) foo ().d, unsigned _BitInt(193))); +static_assert (expr_has_type (+(_BitInt(193)) foo ().a, _BitInt(193))); +static_assert (expr_has_type (+(unsigned _BitInt(193)) foo ().b, unsigned _BitInt(193))); +static_assert (expr_has_type (+(_BitInt(193)) foo ().c, _BitInt(193))); +static_assert (expr_has_type (+(unsigned _BitInt(193)) foo ().d, unsigned _BitInt(193))); +static_assert (expr_has_type ((const _BitInt(193)) foo ().a, _BitInt(193))); +static_assert (expr_has_type ((volatile unsigned _BitInt(193)) foo ().b, unsigned _BitInt(193))); +static_assert (expr_has_type ((const volatile _BitInt(193)) foo ().c, _BitInt(193))); +static_assert (expr_has_type ((const unsigned _BitInt(193)) foo ().d, unsigned _BitInt(193))); diff --git a/gcc/testsuite/gcc.dg/bitint-144.c b/gcc/testsuite/gcc.dg/bitint-144.c new file mode 100644 index 000000000000..83114ba84eb0 --- /dev/null +++ b/gcc/testsuite/gcc.dg/bitint-144.c @@ -0,0 +1,47 @@ +/* PR c/127383 */ +/* { dg-do compile { target bitint } } */ +/* { dg-options "-std=c2y" } */ + +#define expr_has_type(e, t) _Generic (e, default : 0, t : 1) +enum E : _BitInt(195) { E0 = 0, E1 = 1, EM1 = -1 }; +enum F : unsigned _BitInt(195) { F0 = 0, F1 = 1 }; + +struct S { enum E a : 193; const enum F b : 193; volatile enum E c : 193; const volatile enum F d : 193; }; +struct S s; +struct S foo (); +static_assert (expr_has_type (+s.a, _BitInt(195))); +static_assert (expr_has_type (+s.b, unsigned _BitInt(195))); +static_assert (expr_has_type (+s.c, _BitInt(195))); +static_assert (expr_has_type (+s.d, unsigned _BitInt(195))); +static_assert (expr_has_type ((_BitInt(193)) s.a, _BitInt(193))); +static_assert (expr_has_type ((unsigned _BitInt(193)) s.b, unsigned _BitInt(193))); +static_assert (expr_has_type ((_BitInt(193)) s.c, _BitInt(193))); +static_assert (expr_has_type ((unsigned _BitInt(193)) s.d, unsigned _BitInt(193))); +static_assert (expr_has_type (+(_BitInt(193)) s.a, _BitInt(193))); +static_assert (expr_has_type (+(unsigned _BitInt(193)) s.b, unsigned _BitInt(193))); +static_assert (expr_has_type (+(_BitInt(193)) s.c, _BitInt(193))); +static_assert (expr_has_type (+(unsigned _BitInt(193)) s.d, unsigned _BitInt(193))); +static_assert (expr_has_type ((const _BitInt(193)) s.a, _BitInt(193))); +static_assert (expr_has_type ((volatile unsigned _BitInt(193)) s.b, unsigned _BitInt(193))); +static_assert (expr_has_type ((const volatile _BitInt(193)) s.c, _BitInt(193))); +static_assert (expr_has_type ((const unsigned _BitInt(193)) s.d, unsigned _BitInt(193))); +static_assert (expr_has_type (+(_BitInt(193)) s.a, _BitInt(193))); +static_assert (expr_has_type (+(unsigned _BitInt(193)) s.b, unsigned _BitInt(193))); +static_assert (expr_has_type (+(_BitInt(193)) s.c, _BitInt(193))); +static_assert (expr_has_type (+(unsigned _BitInt(193)) s.d, unsigned _BitInt(193))); +static_assert (expr_has_type (+foo ().a, _BitInt(195))); +static_assert (expr_has_type (+foo ().b, unsigned _BitInt(195))); +static_assert (expr_has_type (+foo ().c, _BitInt(195))); +static_assert (expr_has_type (+foo ().d, unsigned _BitInt(195))); +static_assert (expr_has_type ((_BitInt(193)) foo ().a, _BitInt(193))); +static_assert (expr_has_type ((unsigned _BitInt(193)) foo ().b, unsigned _BitInt(193))); +static_assert (expr_has_type ((_BitInt(193)) foo ().c, _BitInt(193))); +static_assert (expr_has_type ((unsigned _BitInt(193)) foo ().d, unsigned _BitInt(193))); +static_assert (expr_has_type (+(_BitInt(193)) foo ().a, _BitInt(193))); +static_assert (expr_has_type (+(unsigned _BitInt(193)) foo ().b, unsigned _BitInt(193))); +static_assert (expr_has_type (+(_BitInt(193)) foo ().c, _BitInt(193))); +static_assert (expr_has_type (+(unsigned _BitInt(193)) foo ().d, unsigned _BitInt(193))); +static_assert (expr_has_type ((const _BitInt(193)) foo ().a, _BitInt(193))); +static_assert (expr_has_type ((volatile unsigned _BitInt(193)) foo ().b, unsigned _BitInt(193))); +static_assert (expr_has_type ((const volatile _BitInt(193)) foo ().c, _BitInt(193))); +static_assert (expr_has_type ((const unsigned _BitInt(193)) foo ().d, unsigned _BitInt(193))); diff --git a/gcc/testsuite/gcc.dg/torture/bitint-108.c b/gcc/testsuite/gcc.dg/torture/bitint-108.c new file mode 100644 index 000000000000..19c9b3e046fc --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/bitint-108.c @@ -0,0 +1,16 @@ +/* PR c/127383 */ +/* { dg-do run { target bitint } } */ + +#if __BITINT_MAXWIDTH__ >= 65 +struct { unsigned _BitInt(65) f : 63; } s; +#endif + +int +main () +{ +#if __SIZEOF_LONG_LONG__ * __CHAR_BIT__ == 64 && __BITINT_MAXWIDTH__ >= 65 + unsigned long long w = ~(unsigned _BitInt(63)) s.f; + if (w != (-1ULL >> 1)) + __builtin_abort (); +#endif +} From 1de71ffb0cdf8262bfab81917d390291a18da879 Mon Sep 17 00:00:00 2001 From: GCC Administrator Date: Thu, 17 Sep 2026 00:17:06 +0000 Subject: [PATCH 142/584] Daily bump. --- gcc/ChangeLog | 52 ++ gcc/DATESTAMP | 2 +- gcc/algol68/ChangeLog | 46 ++ gcc/c/ChangeLog | 9 + gcc/lto/ChangeLog | 7 + gcc/m2/ChangeLog | 5 + gcc/rust/ChangeLog | 649 ++++++++++++++++++++++++ gcc/testsuite/ChangeLog | 1042 +++++++++++++++++++++++++++++++++++++++ libgm2/ChangeLog | 12 + libgrust/ChangeLog | 78 +++ libstdc++-v3/ChangeLog | 24 + 11 files changed, 1925 insertions(+), 1 deletion(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 37e385eecf74..137c6d21d062 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,55 @@ +2026-09-16 Kyrylo Tkachov + + * lto-wrapper.cc (run_gcc): Make saved parallel LTRANS outputs phony. + +2026-09-16 Senthil Kumar Selvaraj + + * ipa-inline.cc (report_inline_failed_reason): Check for NULL + before calling cl_target_option_print_diff. + +2026-09-16 Léo Hardt + + * asan.cc: Remove duplicate stringpool includes. + * builtins.cc: Likewise. + * calls.cc: Likewise. + * cgraphunit.cc: Likewise. + * dwarf2out.cc: Likewise. + * fold-const.cc: Likewise. + * function.cc: Likewise. + * gimple-expr.cc: Likewise. + * internal-fn.cc: Likewise. + * ipa.cc: Likewise. + * lto-cgraph.cc: Likewise. + * pointer-query.cc: Likewise. + * tree-streamer-in.cc: Likewise. + * varasm.cc: Likewise. + +2026-09-16 Richard Biener + + * tree-vect-stmts.cc (vectorizable_conversion): Prevent + conversions from non-mode-precision _BitInt. + +2026-09-16 Tamar Christina + + * config/aarch64/aarch64-sve-builtins-sme.def (DEF_SME_FUNCTION_GS): Undef + at end. + +2026-09-16 Stefan Schulze Frielinghaus + + * ira-lives.cc (single_reg_class): Compute regno in case of + single reg class constraint or hard register constraint, and + rename to ... + (single_reg_class_regno): ... this. + (single_reg_operand_class): Similarly as before and rename + to ... + (single_reg_operand_class_regno): ... this. + (process_single_reg_class_operands): Utilize + single_reg_operand_class_regno() and deal with regnos directly + instead of single reg classes. + (process_single_reg_class_operands): Rename to ... + (process_single_reg_constrained_operands): ... this. + (process_bb_node_lives): Refer to renamed function. + 2026-09-15 Gerald Pfeifer * doc/libgdiagnostics/topics/sarif.rst: Update SARIF website URL. diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index ad5c2ea5d68f..66bb3a1b7dd6 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20260916 +20260917 diff --git a/gcc/algol68/ChangeLog b/gcc/algol68/ChangeLog index dc603e8c0908..25b7607febdb 100644 --- a/gcc/algol68/ChangeLog +++ b/gcc/algol68/ChangeLog @@ -1,3 +1,49 @@ +2026-09-16 Pietro Monteiro + + * a68-parser.cc (a68_get_node_location): Return a location + that covers the whole span of the node. + +2026-09-16 Pietro Monteiro + + * a68-low-bits.cc (a68_bits_elem): Use LINE_NUMBER (p) instead + of NUMBER (LINE (INFO (p))). + * a68-low-chars.cc (a68_char_repr): Likewise. + * a68-low-coercions.cc (a68_lower_uniting): Likewise. + * a68-low-misc.cc (a68_lower_assertion): Likewise. + * a68-low-multiples.cc (a68_multiple_slice): Likewise. + (a68_multiple_single_bound_check): Likewise. + (a68_boundable_dim_check): Likewise. + (a68_multiple_bounds_check): Likewise. + (a68_multiple_bounds_check_equal): Likewise. + * a68-low.cc (a68_checked_indirect_ref): Likewise. + * a68-parser-scanner.cc (new_source_line): Adjust the fields + when creating a LINE_T. + (append_source_line): Add a location_t to the new line. + (append_environ): Track the locations of pre/post-lude. + (read_source_file): Create a linemap for the source file. + (include_files): Create a linemap for included source files. + * a68-parser-top-down.cc (a68_phrase_to_text): Use unsigned + for line numbers. + * a68-parser.cc (a68_get_node_location): Return the location of + the node info line. + (a68_get_line_location): Return the location of the line. + * a68-pretty-print.h (a68_line_format_token): Use the line's + filename to check if it's part of the standard environment. + * a68-types.h (struct LINE_T): Remove filename and number + fields from LINE_T and add location. + (FILENAME): Delete macro. + (LOCATION): New macro. + (LINE_NUMBER): Adjust to use LINE_NO (line). + * a68.h (FILENAME): New function. + (LINE_NO): Likewise. + +2026-09-16 Pietro Monteiro + + * a68-parser-scanner.cc (concatenate_lines): Delete. + (read_source_file): Stop calling concatenate_lines. + (next_char): Skip backslash at the end of lines. + (include_files): Stop calling concatenate_lines. + 2026-09-10 Jose E. Marchesi * a68-low-ranges.cc (a68_pop_range): Do not consolidate refs in diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog index b2fabc3fdb23..4df87ae981e9 100644 --- a/gcc/c/ChangeLog +++ b/gcc/c/ChangeLog @@ -1,3 +1,12 @@ +2026-09-16 Jakub Jelinek + + PR c/127383 + * c-typeck.cc (default_conversion): If orig_expr is different + from exp and exp is a bit-field of bit-precise integer type, call + perform_integral_promotions on orig_exp rather than exp. + (build_c_cast): Wrap in NON_LVALUE_EXPR not just lvalues, but + also non-lvalue bit-fields of bit-precise integer type. + 2026-09-11 Richard Biener * gimple-parser.cc (c_parser_gimple_statement): Parse diff --git a/gcc/lto/ChangeLog b/gcc/lto/ChangeLog index c974a9aa084e..1f0dcfb0c4b9 100644 --- a/gcc/lto/ChangeLog +++ b/gcc/lto/ChangeLog @@ -1,3 +1,10 @@ +2026-09-16 Tobias Burnus + + PR middle-end/127273 + * lto.cc (offload_handle_link_vars): Remove has-value-expr check; + store link vars and processing them after walking the varpool. + (lto_main): Remove duplicated offload_handle_link_vars call. + 2026-09-10 Tobias Burnus PR middle-end/127273 diff --git a/gcc/m2/ChangeLog b/gcc/m2/ChangeLog index d88adb058e09..b2a49007b8dc 100644 --- a/gcc/m2/ChangeLog +++ b/gcc/m2/ChangeLog @@ -1,3 +1,8 @@ +2026-09-16 Gaius Mulley + + PR modula2/127359 + * tools-src/makeSystem: Replace echo with printf equivalent. + 2026-09-11 Gaius Mulley * gm2-gcc/m2builtins.cc (define_builtin): Reimplement. diff --git a/gcc/rust/ChangeLog b/gcc/rust/ChangeLog index c75fcadcc136..4ca5e80821c7 100644 --- a/gcc/rust/ChangeLog +++ b/gcc/rust/ChangeLog @@ -1,3 +1,652 @@ +2026-09-16 Yap Zhi Heng + + * Make-lang.in: Compile the new rust-compile-platform-intrinsic files. + * backend/rust-compile-base.cc (HIRCompileBase::setup_abi_options): Make the + PLATFORM_INTRINSIC case use the `cdecl` ABI. + * backend/rust-compile-platform-intrinsic.cc: New file to handle compilation of + 'platform-intrinsic' extern functions. + * backend/rust-compile-platform-intrinsic.h: Header file for the formentioned file. + * backend/rust-compile-expr.cc (CompileExpr::visit (HIR::CallExpr)): Add new + conditions to compile platform-intrinsic extern functions. + * typecheck/rust-hir-type-check-base.cc (TypeCheckBase::resolve_generic_params): + Check 'platform-intrinsic' extern functions for const parameters. + * typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit (HIR::TupleIndexExpr)): + Fix resolved tuple expression not destructuring. + +2026-09-16 Arthur Cohen + + * checks/errors/feature/rust-feature-defs-rfl.h: Add cfi_encoding RfL feature. + * checks/errors/feature/rust-feature-gate.cc (FeatureGate::visit): Add visitor + for attributes in general, and warn on cfi_encoding being used. + * checks/errors/feature/rust-feature-gate.h: Declare the attribute visitor. + * util/rust-attribute-values.h: Add #[cfi_encoding]. + * util/rust-attributes.cc: Likewise. + +2026-09-16 Arthur Cohen + + * checks/errors/feature/rust-feature-gate.cc (FeatureGate::gate): Move into public + methods, use GateResult enum. + * checks/errors/feature/rust-feature-gate.h: Add new GateResult enum. + +2026-09-16 Philip Herron + + * typecheck/rust-casts.cc (TypeCastRules::cast_rules): fix bad const cast + * util/rust-attribute-values.h: add attribute + * util/rust-attributes.cc: likewise + +2026-09-16 Philip Herron + + * typecheck/rust-tyty-bounds.cc (TypeBoundPredicate::TypeBoundPredicate): remove. + (TypeBoundPredicate::operator=): Likewise. + (TypeBoundPredicateItem::get_tyty_for_receiver): Likewise. + * typecheck/rust-tyty-subst.cc (SubstitutionArgumentMappings::error): Likewise. + (SubstitutionArgumentMappings::empty): Likewise. + (SubstitutionArgumentMappings::on_param_subst): Likewise. + (SubstitutionArgumentMappings::get_subst_cb): Likewise. + * typecheck/rust-tyty-subst.h (std::function + + * expand/rust-derive-ord.cc (DeriveOrd::cmp_fn): use Self + +2026-09-16 Philip Herron + + * typecheck/rust-type-util.cc (query_type): dont query non const candidates + +2026-09-16 Philip Herron + + * typecheck/rust-hir-type-check-path.cc (TypeCheckExpr::resolve_segments): + use probe expr on last seg + +2026-09-16 Owen Avery + + * hir/tree/rust-hir-expr.cc + (ClosureParam::ClosureParam): Set locus. + (ClosureParam::operator=): Likewise. + (ClosureExpr::ClosureExpr): Likewise. + (ClosureExpr::operator=): Likewise. + * typecheck/rust-hir-type-check-expr.cc + (TypeCheckExpr::visit (ClosureExpr)): Use + Mappings::get_lang_item. + +2026-09-16 Philip Herron + + * backend/rust-compile-expr.cc (CompileExpr::visit): make addressable + * backend/rust-constexpr.cc (eval_store_expression): port over missing cp/constexpr.cc + +2026-09-16 Arthur Cohen + + * backend/rust-compile-type.cc (TyTyResolveCompile::visit): Change extern type codegen from + empty struct to the void type node. + +2026-09-16 Philip Herron + + * hir/tree/rust-hir-item.h: missing non const helper. + * typecheck/rust-hir-type-check-base.h: new defer_bindings. + * typecheck/rust-hir-type-check-implitem.cc (TypeCheckTopLevelExternItem::visit): new helper + (TypeCheckImplItem::resolve_function_signature): Likewise. + (TypeCheckImplItem::visit): Likewise. + * typecheck/rust-hir-type-check-item.cc (TypeCheckItem::visit): Likewise. + (TypeCheckItem::resolve_function_signature): Likewise. + (TypeCheckItem::resolve_impl_block_substitutions): Likewise. + * typecheck/rust-hir-type-check-type.cc (ResolveWhereClauseItem::Resolve): new helper + (ResolveWhereClauseItem::visit): support defer. + * typecheck/rust-hir-type-check-type.h: update header. + * typecheck/rust-hir-type-check.cc (TraitItemReference::get_type_from_fn): call new helper + * typecheck/rust-tyty-bounds.cc: defer flag + +2026-09-16 Philip Herron + + * typecheck/rust-hir-type-check-expr.cc: check candidate self + +2026-09-16 Philip Herron + + * typecheck/rust-hir-type-check-base.cc: walk type bindings + +2026-09-16 Philip Herron + + * typecheck/rust-hir-type-check.cc (TraitItemReference::get_type_from_fn): grab lifetimes + +2026-09-16 Philip Herron + + * typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit): add missing checks + +2026-09-16 Philip Herron + + * typecheck/rust-hir-dot-operator.cc (MethodResolver::select): stop on ParamTypes + +2026-09-16 Philip Herron + + * typecheck/rust-typecheck-context.cc (TypeCheckContext::pop_return_type): + push expected null + +2026-09-16 Philip Herron + + * typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit): update + * typecheck/rust-hir-type-check-item.cc (TypeCheckItem::resolve_impl_block_substitutions): + likewise + * typecheck/rust-hir-type-check-path.cc (TypeCheckExpr::visit): likewise + * typecheck/rust-hir-type-check-type.cc (TypeCheckType::visit): likewise + * typecheck/rust-hir-type-check.h: likewise + * typecheck/rust-typecheck-context.cc (TypeCheckContext::insert_resolved_predicate): + likewise + * typecheck/rust-tyty-bounds.cc (TypeBoundPredicate::TypeBoundPredicate): likewise + (TypeBoundPredicate::operator=): remove deadcode + (TypeBoundsMappings::add_bound): use ref + * typecheck/rust-tyty-call.cc (validate_call_argument_associated_impl_bounds): use ref + * typecheck/rust-tyty.cc (BaseType::BaseType): likewise + (BaseType::inherit_bound): likewise + (ParamType::ParamType): likewiase + * typecheck/rust-tyty.h: likewise + +2026-09-16 Philip Herron + + * checks/errors/privacy/rust-reachability.cc: dont need to assert + * typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit): push const ctx + * typecheck/rust-hir-type-check-implitem.cc (TypeCheckImplItem::visit): likewise + * typecheck/rust-hir-type-check-item.cc (TypeCheckItem::visit): likewise + * typecheck/rust-hir-type-check-type.cc (TypeCheckType::visit): likewse + * typecheck/rust-hir-type-check.h: likewise + * typecheck/rust-type-util.cc (query_type): check const_context_p + +2026-09-16 Philip Herron + + * typecheck/rust-substitution-mapper.cc (SubstMapper::valid_type): check for dyn object + (SubstMapper::visit): substitution on it + * typecheck/rust-substitution-mapper.h: add impl + +2026-09-16 Philip Herron + + * backend/rust-compile-pattern.cc (CompilePatternCheckExpr::visit): handle non ADT + * typecheck/rust-hir-type-check-pattern.cc (TypeCheckPattern::visit): likewise + +2026-09-16 Philip Herron + + * typecheck/rust-hir-dot-operator.cc (MethodResolver::Select): optional result type + * typecheck/rust-hir-dot-operator.h: likewise + * typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::ResolveOpOverload): defer flag + (TypeCheckExpr::visit): pass throw the borrow + * typecheck/rust-hir-type-check-expr.h: likewise + * typecheck/rust-hir-type-check.h (struct DeferredOpOverload): new + * typecheck/rust-type-util.cc (unify_site): like parameter ordering + (unify_site_and): likewise + * typecheck/rust-typecheck-context.cc (TypeCheckContext::compute_ambigious_op_overload): new + (TypeCheckContext::compute_inference_variables): likewise + (TypeCheckContext::compute_infer_var): likewise + * typecheck/rust-unify.cc (UnifyRules::Resolve): fix arguments + (UnifyRules::resolve_subtype):likewise + * typecheck/rust-unify.h: likewise + +2026-09-16 Philip Herron + + * hir/rust-ast-lower-item.cc (register_adt_impl): remove + (ASTLoweringItem::visit): likewise + * rust-session-manager.cc (Session::compile_crate): call new indexer + * typecheck/rust-hir-dot-operator.cc + (MethodResolver::try_select_predicate_candidates): use indexes + * typecheck/rust-hir-path-probe-expr.cc (PathProbeExpr::probe_adt_impls): likewise + * typecheck/rust-hir-path-probe-impl-trait.cc + (PathProbeImplTrait::process_trait_impl_items_for_candidates): likewise + * typecheck/rust-hir-path-probe-type.cc (TypePathProbe::probe_adt): likewise + * typecheck/rust-tyty-bounds.cc (TypeBoundsProbe::scan): likewise + * util/rust-hir-map.cc (Mappings::Mappings): new indexer + (Mappings::insert_hir_impl_block): likewise + (Mappings::insert_adt_impl_mapping): likewise + (Mappings::build_impl_indexes): likewise + (Mappings::insert_trait_impl_mapping): likewise + (Mappings::insert_trait_item_mapping): likewise + * util/rust-hir-map.h: likewise + +2026-09-16 Philip Herron + + * typecheck/rust-hir-dot-operator.cc: use item name indexes + * util/rust-hir-map.cc (Mappings::insert_hir_impl_block): new index + (Mappings::insert_trait_item_mapping): likewise + * util/rust-hir-map.h: likewise + +2026-09-16 Philip Herron + + * typecheck/rust-tyty-bounds.cc (TypeBoundsProbe::scan): use trait index + +2026-09-16 Philip Herron + + * typecheck/rust-hir-dot-operator.cc (MethodResolver::select): use sperate index + * util/rust-hir-map.cc (Mappings::insert_hir_impl_block): new indexes + * util/rust-hir-map.h: likewise + +2026-09-16 Philip Herron + + * typecheck/rust-hir-dot-operator.cc (MethodResolver::select): look at predicates first + +2026-09-16 Yap Zhi Heng + + * rust-lang.cc (grs_langhook_pushdecl): Remove rust_unreachable(). + +2026-09-16 Pierre-Emmanuel Patry + + * resolve/rust-early-name-resolver-2.0.cc (Early::visit): Return on + error. + +2026-09-16 Pierre-Emmanuel Patry + + * resolve/rust-early-name-resolver-2.0.cc (Early::finalize_rebind_import): + Use a reverse iterator instead of an index. + +2026-09-16 Pierre-Emmanuel Patry + + * util/rust-hir-map.cc (Mappings::get_ast_crate_by_node_id_raw): Use + appropriate getter. + +2026-09-16 Philip Herron + + * typecheck/rust-hir-type-check-expr.cc: remove old hack + +2026-09-16 Philip Herron + + * ast/rust-path.cc (GenericArgsBinding::as_string): new format + * ast/rust-path.h (struct GenericArgsBinding): new kinds for bindings + * hir/rust-ast-lower-base.cc (ASTLoweringBase::lower_binding): new + * hir/tree/rust-hir-path.cc (GenericArgsBinding::GenericArgsBinding): likewise + (GenericArgsBinding::operator=): likewise + * hir/tree/rust-hir-path.h (class GenericArgsBinding): likewise + * hir/tree/rust-hir.cc (GenericArgsBinding::to_string): likewise + * parse/rust-parse-impl.hxx: peek for both types + * typecheck/rust-type-util.cc (normalize_projection): track constrains + * typecheck/rust-tyty-bounds.cc (TypeBoundPredicate::TypeBoundPredicate): new ctor + (TypeBoundPredicate::operator=): likewise + * typecheck/rust-tyty-subst.cc (SubstitutionArgumentMappings::get_constraint_args): new + * typecheck/rust-tyty-subst.h: new + * typecheck/rust-unify.cc (UnifyRules::expect_projection): fix loop + +2026-09-16 Philip Herron + + * typecheck/rust-hir-type-check-type.cc (TypeCheckType::Resolve): new mode + (TypeCheckType::visit): likewise + (ResolveWhereClauseItem::visit): remove nr usage + * typecheck/rust-hir-type-check-type.h: new mode + +2026-09-16 Philip Herron + + * typecheck/rust-tyty-variance-analysis.cc (GenericTyPerCrateCtx::debug_print_solutions): + we can switch into a substitutionref base class to make this generic + +2026-09-16 Philip Herron + + * typecheck/rust-tyty-bounds.cc: handle assertion + +2026-09-16 Philip Herron + + * typecheck/rust-tyty-variance-analysis.cc (GenericTyVisitorCtx::lookup_or_add_type): + handle the other tyty types + +2026-09-16 Philip Herron + + * hir/rust-ast-lower-implitem.cc (ASTLowerTraitItem::visit): lower where clauses + +2026-09-16 Philip Herron + + * typecheck/rust-hir-type-check-base.cc (walk_type_to_constrain): prototype + (walk_types_to_constrain): make sure to walk the argument too + +2026-09-16 Philip Herron + + * typecheck/rust-hir-path-probe-expr.cc (PathProbeExpr::probe_adt_impls): check impls first + (PathProbeExpr::probe_fallback_impls): likewise + +2026-09-16 Philip Herron + + * backend/rust-compile-extern.h: compile it down + * backend/rust-compile-type.cc (TyTyResolveCompile::visit): make empty struct + * checks/errors/rust-hir-pattern-analysis.cc (PlaceInfo::specialize): add missng case + * typecheck/rust-hir-type-check-implitem.cc (TypeCheckTopLevelExternItem::visit): create adt + * typecheck/rust-tyty-bounds.cc (TypeBoundsProbe::assemble_marker_builtins): not sized + * typecheck/rust-tyty.h: new kind + +2026-09-16 Philip Herron + + * typecheck/rust-hir-trait-resolve.cc (TraitItemReference::resolve_item): can be recusive + +2026-09-16 Lishin + + * checks/errors/borrowck/rust-bir-builder-expr-stmt.cc + (ExprStmtBuilder::visit): Pass the struct expression HIR ID. + * checks/errors/borrowck/rust-bir-builder-internal.h + (AbstractBuilder::push_tmp_assignment): Propagate move sites. + (AbstractBuilder::move_place): Likewise. + (AbstractBuilder::move_all): Likewise. + * checks/errors/borrowck/rust-bir-drop-analysis.cc + (annotate_drop_statements): Reject multiple move sources. + +2026-09-16 Lishin + + * backend/rust-compile-context.h + (Context::insert_drop_flag): New function. + (Context::lookup_drop_flag): Likewise. + (Context::drop_flags): New member. + * backend/rust-compile-drop-builder.cc + (DropBuilder::maybe_create_drop_flag): New function. + (DropBuilder::drop_flag_assignment): Likewise. + * backend/rust-compile-drop-builder.h + (DropBuilder::maybe_create_drop_flag): New declaration. + (DropBuilder::drop_flag_assignment): Likewise. + * backend/rust-compile-drop.cc + (CompileDrop::build_current_scope_drop_cleanup): Check Drop flags before + running conditional Drops. + * backend/rust-compile-pattern.cc + (CompilePatternLet::visit): Set the Drop flag after initialization. + * backend/rust-compile-stmt.cc + (CompileStmt::visit): Create Drop flags and clear them after moves. + * checks/errors/borrowck/rust-bir-builder-expr-stmt.cc + (ExprStmtBuilder::visit): Pass expression HirIds to BIR. + * checks/errors/borrowck/rust-bir-builder-internal.h + (AbstractBuilder::push_assignment): Pass move-site HirIds. + (AbstractExprBuilder::return_place): Likewise. + * checks/errors/borrowck/rust-bir-drop-analysis.cc + (is_straight_line): Remove. + (record_drop_for_backend): Rename from + record_drop_for_straight_line_backend. + (annotate_drop_statements): Record conditional Drops and move + sources. + (DropAnalysis::clear): Clear the new analysis results. + (DropAnalysis::needs_drop_flag): New function. + (DropAnalysis::lookup_move_source): Likewise. + (DropAnalysis::analyze): Record results for the backend. + * checks/errors/borrowck/rust-bir-drop-analysis.h + (DropAnalysis::needs_drop_flag): New declaration. + (DropAnalysis::lookup_move_source): Likewise. + (DropAnalysis::conditionally_dropped): New member. + (DropAnalysis::move_sources): Likewise. + * checks/errors/borrowck/rust-bir.h + (Statement::make_assignment): Accept a move-site HirId. + (Statement::Statement): Likewise. + (Statement::get_move_site): New function. + (Statement::move_site): New member. + +2026-09-16 Yap Zhi Heng + + * backend/rust-builtins.cc (BuiltinsContext::register_llvm_to_gcc_builtin): Add entries + for vcvtph2ps & vcvtps2ph cases (currently unused due to the reason mentioned above). + * backend/rust-compile-extern.h (CompileExternItem::visit(HIR::ExternalFunctionItem)): + Remove placeholder function in the FORWARD_ARGUMENTS case under compilation of UNADJUSTED + ABI. + (CompileExternItem::compile_x86_forwarding_adapter): New function to adapt LLVM's addcarryx + function signatures by simply forwarding the parameters and return var without changes. + +2026-09-16 Yap Zhi Heng + + * backend/rust-builtins.h (LlvmBuiltinMappingResult): New enum. + (LlvmBuiltinAdapter): New enum. + (LlvmBuiltinMapping): New enum. + (BuiltinsContext::map_llvm_to_gcc_builtin): New function for LLVM built-in mapping. + (BuiltinsContext::register_builtin): New function for registering built-ins. + (BuiltinsContext::register_llvm_to_gcc_builtin): New function. + (BuiltinsContext::llvm_to_gcc_builtin): New map to translate function names. + * backend/rust-builtins.cc (BuiltinsContext::map_llvm_to_gcc_builtin): Implementation. + (BuiltinsContext::register_llvm_to_gcc_builtin): Implementation. + (BuiltinsContext::register_builtin): Implementation. + (BuiltinsContext::setup): Call register_llvm_to_gcc_builtin during setup. + * rust-lang.cc (grs_langhook_builtin_function): Register GCC built-in functions. + * backend/rust-compile-extern.h (CompileExternItem::OutputTupleOrder): New enum to denote + the tuple field order of the LLVM built-in's return type. + (CompileExternItem::compile_x86_output_pointer_adapter): New function to adapt LLVM's + rdseed, rdrand, addcarry, subborrow function signatures to GCC's equivalents. + (CompileExternItem::visit (HIR::ExternalFunctionItem)): Handle UNADJUSTED ABI case by + properly resolving LLVM intrinsic function names. + +2026-09-16 Yap Zhi Heng + + * backend/rust-builtins.h (BuiltinsContext::SetupState): New enum. + * backend/rust-builtins.cc (BuiltinsContext::get): Ensure that BuiltinsContext is only + initialized once. + (BuiltinsContext::BuiltinsContext): Likewise. + (BuiltinsContext::setup): Call targetm.init_builtins to make GCC builtins available + to the frontend. + * rust-gcc.cc (init): Eagerly initialize BuiltinsContext. + +2026-09-16 Philip Herron + + * typecheck/rust-hir-trait-reference.cc (TraitItemReference::get_tyty): early guard + (TraitReference::resolve_default_function_bodies): new body resolver + * typecheck/rust-hir-trait-reference.h: new prototypes + * typecheck/rust-hir-trait-resolve.cc (TraitItemReference::on_resolved): resolve body + (TraitItemReference::resolve_default_function_body): likewise + (TraitItemReference::resolve_item): clearing pending + * typecheck/rust-hir-type-check-item.cc (TypeCheckItem::ResolveTraitSignature): new + (TypeCheckItem::resolve_trait): likewise + (TypeCheckItem::visit): likewise + * typecheck/rust-hir-type-check-item.h: likewise + * typecheck/rust-type-util.cc (query_type): get signiture + +2026-09-16 Philip Herron + + * typecheck/rust-hir-type-check-implitem.cc (TypeCheckImplItem::visit): + check need to resolve body + * typecheck/rust-hir-type-check-implitem.h: new resolve sig + * typecheck/rust-hir-type-check-item.cc (TypeCheckItem::Resolve): check recursion + (TypeCheckItem::ResolveFunctionSignature): new helper + (TypeCheckItem::ResolveImplBlockSelf): missing lifetime pin + (TypeCheckItem::visit): likewise + * typecheck/rust-hir-type-check-item.h: new helper + * typecheck/rust-hir-type-check.h: track function body pending + * typecheck/rust-type-util.cc (query_type): track associated self + (normalize_projection): check compatable + * typecheck/rust-typecheck-context.cc (TypeCheckContext::mark_function_body_pending): + marker to make sure body gets resolved later + (TypeCheckContext::clear_function_body_pending): clear market + (TypeCheckContext::function_body_pending): new set + +2026-09-16 Philip Herron + + * typecheck/rust-hir-type-check-implitem.cc (TypeCheckImplItem::visit): seperate + (TypeCheckImplItem::resolve_function_signature): likewise + * typecheck/rust-hir-type-check-implitem.h: seperate + * typecheck/rust-hir-type-check-item.cc (TypeCheckItem::visit): likewise + (TypeCheckItem::resolve_function_signature): likewise + * typecheck/rust-hir-type-check-item.h: likewise + +2026-09-16 Philip Herron + + * typecheck/rust-hir-dot-operator.cc: + +2026-09-16 Philip Herron + + * typecheck/rust-hir-path-probe-expr.cc (PathProbeExpr::Probe): simpler interface + (PathProbeExpr::probe): based of the receiver + (PathProbeExpr::visit): no longer needed + (PathProbeExpr::probe_adt_impls): new probe + (PathProbeExpr::probe_fallback_impls): fallback to iterate impls + (PathProbeExpr::process_enum_item_for_candiates): removed + (PathProbeExpr::process_enum_item_for_candidates): likewise + (PathProbeExpr::process_impl_items_for_candidates): likewise + (PathProbeExpr::process_impl_item_candidate): likewise + (PathProbeExpr::probe_bounds): fall back to the impl iter + (PathProbeExpr::insert_candidate): acumulate + * typecheck/rust-hir-path-probe-expr.h (class PathProbeExpr): new interface + * typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::TypeCheckExpr): likewise + * typecheck/rust-hir-type-check-path.cc (TypeCheckExpr::resolve_segments): likewise + +2026-09-16 Philip Herron + + * Make-lang.in: new object + * typecheck/rust-hir-path-probe.cc (PathProbeType::PathProbeType): refactor + (PathProbeType::Probe): likewise + (PathProbeType::visit): likewise + (PathProbeType::process_enum_item_for_candiates): likewise + (PathProbeType::process_impl_items_for_candidates): likewise + (PathProbeType::process_impl_item_candidate): likewise + (PathProbeType::is_receiver_generic): likewise + * typecheck/rust-hir-path-probe.h (class PathProbeType): likewise + * typecheck/rust-hir-type-check-path.cc (TypeCheckExpr::resolve_segments): likewise + * typecheck/rust-hir-path-probe-expr.cc: New file. + * typecheck/rust-hir-path-probe-expr.h: New file. + +2026-09-16 Philip Herron + + * Make-lang.in: new object + * backend/rust-compile-base.cc: refactor + * backend/rust-compile-drop.cc: likewise + * backend/rust-compile-resolve-path.cc: likewise + * typecheck/rust-hir-path-probe.cc (PathProbeImplTrait::PathProbeImplTrait): likewise + (PathProbeImplTrait::Probe): likewise + (PathProbeImplTrait::process_trait_impl_items_for_candidates): likewise + * typecheck/rust-hir-path-probe.h (class PathProbeImplTrait): likewise + * typecheck/rust-hir-path-probe-impl-trait.cc: New file. + * typecheck/rust-hir-path-probe-impl-trait.h: New file. + +2026-09-16 Philip Herron + + * Make-lang.in: new object + * typecheck/rust-hir-type-check-type.cc (TypeCheckType::resolve_associated_type): helper + * typecheck/rust-hir-type-check-type.h: new interface + * typecheck/rust-hir-path-probe-type.cc: New file. + * typecheck/rust-hir-path-probe-type.h: New file. + +2026-09-16 Philip Herron + + * hir/rust-ast-lower-item.cc (register_adt_impl): new mappings + (ASTLoweringItem::visit): tracker function + * typecheck/rust-hir-path-probe.cc (PathProbeType::process_impl_items_for_candidates): + iterator + * util/rust-hir-map.cc (Mappings::insert_adt_impl_mapping): helper + * util/rust-hir-map.h: likewise + +2026-09-16 Philip Herron + + * typecheck/rust-hir-path-probe.cc (PathProbeType::Probe): filter + +2026-09-16 Philip Herron + + * typecheck/rust-type-util.cc (lookup_associated_impl_block): add filter + (normalize_projection): likewise + +2026-09-16 Philip Herron + + * typecheck/rust-hir-type-check-path.cc (TypeCheckExpr::visit): dp trait lookup + * typecheck/rust-tyty.cc (BaseType::satisfies_bound): add filter + +2026-09-16 Philip Herron + + * typecheck/rust-tyty-bounds.cc (TypeBoundPredicate::validate_type_implements_this): filter + +2026-09-16 Philip Herron + + * typecheck/rust-hir-type-bounds.h: optional trait arg + * typecheck/rust-tyty-bounds.cc (TypeBoundsProbe::TypeBoundsProbe): likewise + (TypeBoundsProbe::Probe): likewise + (TypeBoundsProbe::is_bound_satisfied_for_type): use specified trait + (TypeBoundsProbe::scan): try to scan for indexed traits + +2026-09-16 Philip Herron + + * typecheck/rust-hir-dot-operator.cc (MethodResolver::MethodResolver): new optional filter + (MethodResolver::Probe): likewise + (MethodResolver::try_select_predicate_candidates): likewise + (MethodResolver::select): likewise + * typecheck/rust-hir-dot-operator.h: likewise + * typecheck/rust-hir-type-check-expr.cc: pass lang item trait + * util/rust-hir-map.cc: new helper to scan implblocks + * util/rust-hir-map.h: likewise + +2026-09-16 Philip Herron + + * hir/rust-ast-lower-item.cc (ASTLoweringItem::visit): add mapping + * rust-session-manager.cc (Session::compile_crate): make sure nr context is ready + * typecheck/rust-hir-path-probe.cc + (PathProbeImplTrait::process_trait_impl_items_for_candidates): use the new filter + * util/rust-hir-map.cc (Mappings::insert_trait_impl_mapping): new helper + * util/rust-hir-map.h: likewise + +2026-09-16 Philip Herron + + * hir/rust-hir-dump.cc (Dump::do_typepathfunction): add guard + +2026-09-16 Arthur Cohen + + * typecheck/rust-tyty.h: Rename FN_VARADIC_FLAG -> FN_VARIADIC_FLAG. + * typecheck/rust-hir-type-check-implitem.cc (TypeCheckTopLevelExternItem::visit): Use + the new name. + +2026-09-16 Yap Zhi Heng + + * backend/rust-compile-var-decl.h (CompileVarDecl::visit (StructPattern)): Compile + variable declarations for use within CompilePatternLet::visit(StructPattern). + * backend/rust-compile-pattern.h (CompilePatternLet::visit (StructPattern)): + Remove rust_sorry_at. + * backend/rust-compile-pattern.cc (CompilePatternLet::visit (StructPattern)): + Compile bindings for struct fields. + +2026-09-16 Lishin + + * checks/errors/borrowck/rust-bir-drop-analysis.cc + (struct BlockInitializationState): New struct. + (is_straight_line): New function. + (set_initialized): Likewise. + (set_uninitialized): Likewise. + (merge_state): Likewise. + (update_state_for_statement): Likewise. + (classify_drop): Likewise. + (compute_entry_states): Likewise. + (record_drop_for_straight_line_backend): Likewise. + (annotate_drop_statements): Likewise. + (DropAnalysis::analyze): Propagate initialization state across the + CFG and classify Drop statements. + * checks/errors/borrowck/rust-bir-drop-analysis.h: Update class + comment. + +2026-09-16 Philip Herron + + * typecheck/rust-hir-trait-resolve.cc (AssociatedImplTrait::bind_impl_for_projection): + switch between generics + (AssociatedImplTrait::bind_impl_for_bound): likewise + +2026-09-16 Philip Herron + + * rust-diagnostics.cc (rust_debug_loc): rename + (rust_debug_loc_internal): no longer check if debug is enabled + * rust-diagnostics.h (rust_debug): new wrapper + (rust_debug_loc): likewise + (rust_debug_loc_internal): likewise + +2026-09-16 Philip Herron + + * typecheck/rust-hir-type-check-base.cc (walk_type_to_constrain): walk const generics + +2026-09-16 Philip Herron + + * typecheck/rust-type-util.cc (normalize_projection): add check + +2026-09-16 Owen Avery + + * resolve/rust-default-resolver.cc + (DefaultResolver::visit (Function)): Don't pass a path parameter + to function NameResolutionContext::scoped. + +2026-09-16 Utkarsh Bahuguna + + * parse/rust-parse-impl-path.hxx (Parser::parse_path_in_expression): + Report an error when the initial segment of a scoped path fails to + parse. + * parse/rust-parse-impl.hxx (Parser::parse_stmt_or_expr): Remove the + redundant expected-identifier error guard. + +2026-09-16 Owen Avery + + * typecheck/rust-hir-type-check-expr.cc + (TypeCheckExpr::visit (BoxExpr)): Attempt to resolve lang item, + instead of just looking it up. + (TypeCheckExpr::visit (RangeFromToExpr)): Likewise. + (TypeCheckExpr::visit (RangeFromExpr)): Likewise. + (TypeCheckExpr::visit (RangeToExpr)): Likewise. + (TypeCheckExpr::visit (RangeFullExpr)): Likewise. + +2026-09-16 Yap Zhi Heng + + * util/rust-abi.h (ABI): Add PLATFORM_INTRINSIC and UNADJUSTED variants. + * util/rust-abi.cc (ABI::get_abi_from_string): Implement cases for PLATFORM_INTRINSIC & + UNADJUSTED. + (ABI::get_string_from_abi): Ditto. + 2026-09-10 Philip Herron * backend/rust-compile-type.cc (TyTyResolveCompile::visit): make vector diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index d09847cb0055..e7648b8c3b64 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,1045 @@ +2026-09-16 Jakub Jelinek + + PR c/127383 + * gcc.dg/torture/bitint-108.c: New test. + * gcc.dg/bitint-143.c: New test. + * gcc.dg/bitint-144.c: New test. + +2026-09-16 Pietro Monteiro + + * algol68/execute/backslash-1.a68: New test. + +2026-09-16 Kyrylo Tkachov + + * gcc.dg/tree-prof/lto-save-temps-profile-use.c: New test. + +2026-09-16 Yap Zhi Heng + + * rust/compile/platform_intrinsics.rs: New file. + +2026-09-16 Arthur Cohen + + * rust/compile/cfi-encoding1.rs: New test. + * rust/compile/cfi-encoding2.rs: New test. + +2026-09-16 Owen Avery + + * rust/alloc/alloc.exp: Test with edition 2018. + * rust/alloc/core.rs: Fix some use declaration paths and use raw + identifiers for "try". + +2026-09-16 Pierre-Emmanuel Patry + + * rust/compile/torture/issue-1024.rs: Move to... + * rust/compile/torture/issues/1024.rs: ...here. + * rust/compile/torture/issue-1075.rs: Move to... + * rust/compile/torture/issues/1075.rs: ...here. + * rust/compile/torture/issue-1432.rs: Move to... + * rust/compile/torture/issues/1432.rs: ...here. + * rust/compile/torture/issue-1434.rs: Move to... + * rust/compile/torture/issues/1434.rs: ...here. + * rust/compile/torture/issue-1506.rs: Move to... + * rust/compile/torture/issues/1506.rs: ...here. + * rust/compile/torture/issue-1555.rs: Move to... + * rust/compile/torture/issues/1555.rs: ...here. + * rust/compile/torture/issue-368.rs: Move to... + * rust/compile/torture/issues/368.rs: ...here. + * rust/compile/torture/issue-808.rs: Move to... + * rust/compile/torture/issues/808.rs: ...here. + * rust/compile/torture/issue-862.rs: Move to... + * rust/compile/torture/issues/862.rs: ...here. + * rust/compile/torture/issue-893-2.rs: Move to... + * rust/compile/torture/issues/893-2.rs: ...here. + * rust/compile/torture/issue-893.rs: Move to... + * rust/compile/torture/issues/893.rs: ...here. + * rust/compile/torture/issues/issues.exp: Copy DG testsuite file from + parent directory. + +2026-09-16 Pierre-Emmanuel Patry + + * rust/compile/issue-1005.rs: Move to... + * rust/compile/issues/1005.rs: ...here. + * rust/compile/issue-1006.rs: Move to... + * rust/compile/issues/1006.rs: ...here. + * rust/compile/issue-1019.rs: Move to... + * rust/compile/issues/1019.rs: ...here. + * rust/compile/issue-1023.rs: Move to... + * rust/compile/issues/1023.rs: ...here. + * rust/compile/issue-1031.rs: Move to... + * rust/compile/issues/1031.rs: ...here. + * rust/compile/issue-1034.rs: Move to... + * rust/compile/issues/1034.rs: ...here. + * rust/compile/issue-1048.rs: Move to... + * rust/compile/issues/1048.rs: ...here. + * rust/compile/issue-1073.rs: Move to... + * rust/compile/issues/1073.rs: ...here. + * rust/compile/issue-1081.rs: Move to... + * rust/compile/issues/1081.rs: ...here. + * rust/compile/issue-1089.rs: Move to... + * rust/compile/issues/1089.rs: ...here. + * rust/compile/issue-1089/test_mod.rs: Move to... + * rust/compile/issues/1089/test_mod.rs: ...here. + * rust/compile/issue-1128.rs: Move to... + * rust/compile/issues/1128.rs: ...here. + * rust/compile/issue-1129-1.rs: Move to... + * rust/compile/issues/1129-1.rs: ...here. + * rust/compile/issue-1129-2.rs: Move to... + * rust/compile/issues/1129-2.rs: ...here. + * rust/compile/issue-1130.rs: Move to... + * rust/compile/issues/1130.rs: ...here. + * rust/compile/issue-1131.rs: Move to... + * rust/compile/issues/1131.rs: ...here. + * rust/compile/issue-1152.rs: Move to... + * rust/compile/issues/1152.rs: ...here. + * rust/compile/issue-1165.rs: Move to... + * rust/compile/issues/1165.rs: ...here. + * rust/compile/issue-1173.rs: Move to... + * rust/compile/issues/1173.rs: ...here. + * rust/compile/issue-1210.rs: Move to... + * rust/compile/issues/1210.rs: ...here. + * rust/compile/issue-1226.rs: Move to... + * rust/compile/issues/1226.rs: ...here. + * rust/compile/issue-1234.rs: Move to... + * rust/compile/issues/1234.rs: ...here. + * rust/compile/issue-1235.rs: Move to... + * rust/compile/issues/1235.rs: ...here. + * rust/compile/issue-1237.rs: Move to... + * rust/compile/issues/1237.rs: ...here. + * rust/compile/issue-1251.rs: Move to... + * rust/compile/issues/1251.rs: ...here. + * rust/compile/issue-1271.rs: Move to... + * rust/compile/issues/1271.rs: ...here. + * rust/compile/issue-1272.rs: Move to... + * rust/compile/issues/1272.rs: ...here. + * rust/compile/issue-1289.rs: Move to... + * rust/compile/issues/1289.rs: ...here. + * rust/compile/issue-1323-1.rs: Move to... + * rust/compile/issues/1323-1.rs: ...here. + * rust/compile/issue-1323-2.rs: Move to... + * rust/compile/issues/1323-2.rs: ...here. + * rust/compile/issue-1361.rs: Move to... + * rust/compile/issues/1361.rs: ...here. + * rust/compile/issue-1383.rs: Move to... + * rust/compile/issues/1383.rs: ...here. + * rust/compile/issue-1393.rs: Move to... + * rust/compile/issues/1393.rs: ...here. + * rust/compile/issue-1422.rs: Move to... + * rust/compile/issues/1422.rs: ...here. + * rust/compile/issue-1446.rs: Move to... + * rust/compile/issues/1446.rs: ...here. + * rust/compile/issue-1447.rs: Move to... + * rust/compile/issues/1447.rs: ...here. + * rust/compile/issue-1483.rs: Move to... + * rust/compile/issues/1483.rs: ...here. + * rust/compile/issue-1485.rs: Move to... + * rust/compile/issues/1485.rs: ...here. + * rust/compile/issue-1487.rs: Move to... + * rust/compile/issues/1487.rs: ...here. + * rust/compile/issue-1524.rs: Move to... + * rust/compile/issues/1524.rs: ...here. + * rust/compile/issue-1525.rs: Move to... + * rust/compile/issues/1525.rs: ...here. + * rust/compile/issue-1553.rs: Move to... + * rust/compile/issues/1553.rs: ...here. + * rust/compile/issue-1589.rs: Move to... + * rust/compile/issues/1589.rs: ...here. + * rust/compile/issue-1725-1.rs: Move to... + * rust/compile/issues/1725-1.rs: ...here. + * rust/compile/issue-1725-2.rs: Move to... + * rust/compile/issues/1725-2.rs: ...here. + * rust/compile/issue-1726-1.rs: Move to... + * rust/compile/issues/1726-1.rs: ...here. + * rust/compile/issue-1726-2.rs: Move to... + * rust/compile/issues/1726-2.rs: ...here. + * rust/compile/issue-1773.rs: Move to... + * rust/compile/issues/1773.rs: ...here. + * rust/compile/issue-1786.rs: Move to... + * rust/compile/issues/1786.rs: ...here. + * rust/compile/issue-1807.rs: Move to... + * rust/compile/issues/1807.rs: ...here. + * rust/compile/issue-1813.rs: Move to... + * rust/compile/issues/1813.rs: ...here. + * rust/compile/issue-1830_bytes.rs: Move to... + * rust/compile/issues/1830_bytes.rs: ...here. + * rust/compile/issue-1830_str.rs: Move to... + * rust/compile/issues/1830_str.rs: ...here. + * rust/compile/issue-1893.rs: Move to... + * rust/compile/issues/1893.rs: ...here. + * rust/compile/issue-1901.rs: Move to... + * rust/compile/issues/1901.rs: ...here. + * rust/compile/issue-1930.rs: Move to... + * rust/compile/issues/1930.rs: ...here. + * rust/compile/issue-1981.rs: Move to... + * rust/compile/issues/1981.rs: ...here. + * rust/compile/issue-2015.rs: Move to... + * rust/compile/issues/2015.rs: ...here. + * rust/compile/issue-2019-1.rs: Move to... + * rust/compile/issues/2019-1.rs: ...here. + * rust/compile/issue-2019-2.rs: Move to... + * rust/compile/issues/2019-2.rs: ...here. + * rust/compile/issue-2019-3.rs: Move to... + * rust/compile/issues/2019-3.rs: ...here. + * rust/compile/issue-2029.rs: Move to... + * rust/compile/issues/2029.rs: ...here. + * rust/compile/issue-2035.rs: Move to... + * rust/compile/issues/2035.rs: ...here. + * rust/compile/issue-2036.rs: Move to... + * rust/compile/issues/2036.rs: ...here. + * rust/compile/issue-2037.rs: Move to... + * rust/compile/issues/2037.rs: ...here. + * rust/compile/issue-2039.rs: Move to... + * rust/compile/issues/2039.rs: ...here. + * rust/compile/issue-2040.rs: Move to... + * rust/compile/issues/2040.rs: ...here. + * rust/compile/issue-2042.rs: Move to... + * rust/compile/issues/2042.rs: ...here. + * rust/compile/issue-2043.rs: Move to... + * rust/compile/issues/2043.rs: ...here. + * rust/compile/issue-2070.rs: Move to... + * rust/compile/issues/2070.rs: ...here. + * rust/compile/issue-2105.rs: Move to... + * rust/compile/issues/2105.rs: ...here. + * rust/compile/issue-2106.rs: Move to... + * rust/compile/issues/2106.rs: ...here. + * rust/compile/issue-2125.rs: Move to... + * rust/compile/issues/2125.rs: ...here. + * rust/compile/issue-2135.rs: Move to... + * rust/compile/issues/2135.rs: ...here. + * rust/compile/issue-2136-1.rs: Move to... + * rust/compile/issues/2136-1.rs: ...here. + * rust/compile/issue-2136-2.rs: Move to... + * rust/compile/issues/2136-2.rs: ...here. + * rust/compile/issue-2139.rs: Move to... + * rust/compile/issues/2139.rs: ...here. + * rust/compile/issue-2142.rs: Move to... + * rust/compile/issues/2142.rs: ...here. + * rust/compile/issue-2165.rs: Move to... + * rust/compile/issues/2165.rs: ...here. + * rust/compile/issue-2166.rs: Move to... + * rust/compile/issues/2166.rs: ...here. + * rust/compile/issue-2178.rs: Move to... + * rust/compile/issues/2178.rs: ...here. + * rust/compile/issue-2187.rs: Move to... + * rust/compile/issues/2187.rs: ...here. + * rust/compile/issue-2188.rs: Move to... + * rust/compile/issues/2188.rs: ...here. + * rust/compile/issue-2189.rs: Move to... + * rust/compile/issues/2189.rs: ...here. + * rust/compile/issue-2190-1.rs: Move to... + * rust/compile/issues/2190-1.rs: ...here. + * rust/compile/issue-2190-2.rs: Move to... + * rust/compile/issues/2190-2.rs: ...here. + * rust/compile/issue-2195.rs: Move to... + * rust/compile/issues/2195.rs: ...here. + * rust/compile/issue-2203.rs: Move to... + * rust/compile/issues/2203.rs: ...here. + * rust/compile/issue-2207.rs: Move to... + * rust/compile/issues/2207.rs: ...here. + * rust/compile/issue-2225.rs: Move to... + * rust/compile/issues/2225.rs: ...here. + * rust/compile/issue-2238.rs: Move to... + * rust/compile/issues/2238.rs: ...here. + * rust/compile/issue-2304.rs: Move to... + * rust/compile/issues/2304.rs: ...here. + * rust/compile/issue-2323.rs: Move to... + * rust/compile/issues/2323.rs: ...here. + * rust/compile/issue-2324-1.rs: Move to... + * rust/compile/issues/2324-1.rs: ...here. + * rust/compile/issue-2324-2.rs: Move to... + * rust/compile/issues/2324-2.rs: ...here. + * rust/compile/issue-2330.rs: Move to... + * rust/compile/issues/2330.rs: ...here. + * rust/compile/issue-2369.rs: Move to... + * rust/compile/issues/2369.rs: ...here. + * rust/compile/issue-2375.rs: Move to... + * rust/compile/issues/2375.rs: ...here. + * rust/compile/issue-2391.rs: Move to... + * rust/compile/issues/2391.rs: ...here. + * rust/compile/issue-2394.rs: Move to... + * rust/compile/issues/2394.rs: ...here. + * rust/compile/issue-2421_str.rs: Move to... + * rust/compile/issues/2421_str.rs: ...here. + * rust/compile/issue-2423.rs: Move to... + * rust/compile/issues/2423.rs: ...here. + * rust/compile/issue-2431.rs: Move to... + * rust/compile/issues/2431.rs: ...here. + * rust/compile/issue-2477.rs: Move to... + * rust/compile/issues/2477.rs: ...here. + * rust/compile/issue-2478.rs: Move to... + * rust/compile/issues/2478.rs: ...here. + * rust/compile/issue-2479.rs: Move to... + * rust/compile/issues/2479.rs: ...here. + * rust/compile/issue-2499.rs: Move to... + * rust/compile/issues/2499.rs: ...here. + * rust/compile/issue-2514.rs: Move to... + * rust/compile/issues/2514.rs: ...here. + * rust/compile/issue-2567-1.rs: Move to... + * rust/compile/issues/2567-1.rs: ...here. + * rust/compile/issue-2567-2.rs: Move to... + * rust/compile/issues/2567-2.rs: ...here. + * rust/compile/issue-2567-3.rs: Move to... + * rust/compile/issues/2567-3.rs: ...here. + * rust/compile/issue-2645.rs: Move to... + * rust/compile/issues/2645.rs: ...here. + * rust/compile/issue-2650-1.rs: Move to... + * rust/compile/issues/2650-1.rs: ...here. + * rust/compile/issue-2650-2.rs: Move to... + * rust/compile/issues/2650-2.rs: ...here. + * rust/compile/issue-266.rs: Move to... + * rust/compile/issues/266.rs: ...here. + * rust/compile/issue-2665.rs: Move to... + * rust/compile/issues/2665.rs: ...here. + * rust/compile/issue-2680.rs: Move to... + * rust/compile/issues/2680.rs: ...here. + * rust/compile/issue-2709.rs: Move to... + * rust/compile/issues/2709.rs: ...here. + * rust/compile/issue-2723-1.rs: Move to... + * rust/compile/issues/2723-1.rs: ...here. + * rust/compile/issue-2723-2.rs: Move to... + * rust/compile/issues/2723-2.rs: ...here. + * rust/compile/issue-2725.rs: Move to... + * rust/compile/issues/2725.rs: ...here. + * rust/compile/issue-2747.rs: Move to... + * rust/compile/issues/2747.rs: ...here. + * rust/compile/issue-2767.rs: Move to... + * rust/compile/issues/2767.rs: ...here. + * rust/compile/issue-2772-1.rs: Move to... + * rust/compile/issues/2772-1.rs: ...here. + * rust/compile/issue-2772-2.rs: Move to... + * rust/compile/issues/2772-2.rs: ...here. + * rust/compile/issue-2775.rs: Move to... + * rust/compile/issues/2775.rs: ...here. + * rust/compile/issue-2782.rs: Move to... + * rust/compile/issues/2782.rs: ...here. + * rust/compile/issue-2785.rs: Move to... + * rust/compile/issues/2785.rs: ...here. + * rust/compile/issue-2788.rs: Move to... + * rust/compile/issues/2788.rs: ...here. + * rust/compile/issue-2812.rs: Move to... + * rust/compile/issues/2812.rs: ...here. + * rust/compile/issue-2847-b.rs: Move to... + * rust/compile/issues/2847-b.rs: ...here. + * rust/compile/issue-2847.rs: Move to... + * rust/compile/issues/2847.rs: ...here. + * rust/compile/issue-2850.rs: Move to... + * rust/compile/issues/2850.rs: ...here. + * rust/compile/issue-2905-1.rs: Move to... + * rust/compile/issues/2905-1.rs: ...here. + * rust/compile/issue-2905-2.rs: Move to... + * rust/compile/issues/2905-2.rs: ...here. + * rust/compile/issue-2906.rs: Move to... + * rust/compile/issues/2906.rs: ...here. + * rust/compile/issue-2907.rs: Move to... + * rust/compile/issues/2907.rs: ...here. + * rust/compile/issue-2951.rs: Move to... + * rust/compile/issues/2951.rs: ...here. + * rust/compile/issue-2953-1.rs: Move to... + * rust/compile/issues/2953-1.rs: ...here. + * rust/compile/issue-2953-2.rs: Move to... + * rust/compile/issues/2953-2.rs: ...here. + * rust/compile/issue-2954.rs: Move to... + * rust/compile/issues/2954.rs: ...here. + * rust/compile/issue-2987.rs: Move to... + * rust/compile/issues/2987.rs: ...here. + * rust/compile/issue-3009.rs: Move to... + * rust/compile/issues/3009.rs: ...here. + * rust/compile/issue-3022.rs: Move to... + * rust/compile/issues/3022.rs: ...here. + * rust/compile/issue-3030.rs: Move to... + * rust/compile/issues/3030.rs: ...here. + * rust/compile/issue-3031.rs: Move to... + * rust/compile/issues/3031.rs: ...here. + * rust/compile/issue-3032-1.rs: Move to... + * rust/compile/issues/3032-1.rs: ...here. + * rust/compile/issue-3032-2.rs: Move to... + * rust/compile/issues/3032-2.rs: ...here. + * rust/compile/issue-3033.rs: Move to... + * rust/compile/issues/3033.rs: ...here. + * rust/compile/issue-3035.rs: Move to... + * rust/compile/issues/3035.rs: ...here. + * rust/compile/issue-3036.rs: Move to... + * rust/compile/issues/3036.rs: ...here. + * rust/compile/issue-3045-1.rs: Move to... + * rust/compile/issues/3045-1.rs: ...here. + * rust/compile/issue-3045-2.rs: Move to... + * rust/compile/issues/3045-2.rs: ...here. + * rust/compile/issue-3046.rs: Move to... + * rust/compile/issues/3046.rs: ...here. + * rust/compile/issue-3082.rs: Move to... + * rust/compile/issues/3082.rs: ...here. + * rust/compile/issue-3139-1.rs: Move to... + * rust/compile/issues/3139-1.rs: ...here. + * rust/compile/issue-3139-2.rs: Move to... + * rust/compile/issues/3139-2.rs: ...here. + * rust/compile/issue-3139-3.rs: Move to... + * rust/compile/issues/3139-3.rs: ...here. + * rust/compile/issue-3140.rs: Move to... + * rust/compile/issues/3140.rs: ...here. + * rust/compile/issue-3141.rs: Move to... + * rust/compile/issues/3141.rs: ...here. + * rust/compile/issue-3144.rs: Move to... + * rust/compile/issues/3144.rs: ...here. + * rust/compile/issue-3174.rs: Move to... + * rust/compile/issues/3174.rs: ...here. + * rust/compile/issue-3231.rs: Move to... + * rust/compile/issues/3231.rs: ...here. + * rust/compile/issue-3242.rs: Move to... + * rust/compile/issues/3242.rs: ...here. + * rust/compile/issue-3261.rs: Move to... + * rust/compile/issues/3261.rs: ...here. + * rust/compile/issue-3304.rs: Move to... + * rust/compile/issues/3304.rs: ...here. + * rust/compile/issue-3315-1.rs: Move to... + * rust/compile/issues/3315-1.rs: ...here. + * rust/compile/issue-3315-2.rs: Move to... + * rust/compile/issues/3315-2.rs: ...here. + * rust/compile/issue-3350.rs: Move to... + * rust/compile/issues/3350.rs: ...here. + * rust/compile/issue-3382.rs: Move to... + * rust/compile/issues/3382.rs: ...here. + * rust/compile/issue-3402-1.rs: Move to... + * rust/compile/issues/3402-1.rs: ...here. + * rust/compile/issue-3402-2.rs: Move to... + * rust/compile/issues/3402-2.rs: ...here. + * rust/compile/issue-3403.rs: Move to... + * rust/compile/issues/3403.rs: ...here. + * rust/compile/issue-3454.rs: Move to... + * rust/compile/issues/3454.rs: ...here. + * rust/compile/issue-3524.rs: Move to... + * rust/compile/issues/3524.rs: ...here. + * rust/compile/issue-3525.rs: Move to... + * rust/compile/issues/3525.rs: ...here. + * rust/compile/issue-3530-1.rs: Move to... + * rust/compile/issues/3530-1.rs: ...here. + * rust/compile/issue-3530-2.rs: Move to... + * rust/compile/issues/3530-2.rs: ...here. + * rust/compile/issue-3537.rs: Move to... + * rust/compile/issues/3537.rs: ...here. + * rust/compile/issue-3538.rs: Move to... + * rust/compile/issues/3538.rs: ...here. + * rust/compile/issue-3541-1.rs: Move to... + * rust/compile/issues/3541-1.rs: ...here. + * rust/compile/issue-3541-2.rs: Move to... + * rust/compile/issues/3541-2.rs: ...here. + * rust/compile/issue-3546.rs: Move to... + * rust/compile/issues/3546.rs: ...here. + * rust/compile/issue-3549.rs: Move to... + * rust/compile/issues/3549.rs: ...here. + * rust/compile/issue-3550.rs: Move to... + * rust/compile/issues/3550.rs: ...here. + * rust/compile/issue-3551.rs: Move to... + * rust/compile/issues/3551.rs: ...here. + * rust/compile/issue-3552.rs: Move to... + * rust/compile/issues/3552.rs: ...here. + * rust/compile/issue-3553.rs: Move to... + * rust/compile/issues/3553.rs: ...here. + * rust/compile/issue-3554-1.rs: Move to... + * rust/compile/issues/3554-1.rs: ...here. + * rust/compile/issue-3554-2.rs: Move to... + * rust/compile/issues/3554-2.rs: ...here. + * rust/compile/issue-3555.rs: Move to... + * rust/compile/issues/3555.rs: ...here. + * rust/compile/issue-3556.rs: Move to... + * rust/compile/issues/3556.rs: ...here. + * rust/compile/issue-3563.rs: Move to... + * rust/compile/issues/3563.rs: ...here. + * rust/compile/issue-3566-1.rs: Move to... + * rust/compile/issues/3566-1.rs: ...here. + * rust/compile/issue-3566-2.rs: Move to... + * rust/compile/issues/3566-2.rs: ...here. + * rust/compile/issue-3567.rs: Move to... + * rust/compile/issues/3567.rs: ...here. + * rust/compile/issue-3568.rs: Move to... + * rust/compile/issues/3568.rs: ...here. + * rust/compile/issue-3581-1.rs: Move to... + * rust/compile/issues/3581-1.rs: ...here. + * rust/compile/issue-3581-2.rs: Move to... + * rust/compile/issues/3581-2.rs: ...here. + * rust/compile/issue-3585-1.rs: Move to... + * rust/compile/issues/3585-1.rs: ...here. + * rust/compile/issue-3585-2.rs: Move to... + * rust/compile/issues/3585-2.rs: ...here. + * rust/compile/issue-3588.rs: Move to... + * rust/compile/issues/3588.rs: ...here. + * rust/compile/issue-3591.rs: Move to... + * rust/compile/issues/3591.rs: ...here. + * rust/compile/issue-3592.rs: Move to... + * rust/compile/issues/3592.rs: ...here. + * rust/compile/issue-3597.rs: Move to... + * rust/compile/issues/3597.rs: ...here. + * rust/compile/issue-3599.rs: Move to... + * rust/compile/issues/3599.rs: ...here. + * rust/compile/issue-3605.rs: Move to... + * rust/compile/issues/3605.rs: ...here. + * rust/compile/issue-3606.rs: Move to... + * rust/compile/issues/3606.rs: ...here. + * rust/compile/issue-3612.rs: Move to... + * rust/compile/issues/3612.rs: ...here. + * rust/compile/issue-3613.rs: Move to... + * rust/compile/issues/3613.rs: ...here. + * rust/compile/issue-3614.rs: Move to... + * rust/compile/issues/3614.rs: ...here. + * rust/compile/issue-3615.rs: Move to... + * rust/compile/issues/3615.rs: ...here. + * rust/compile/issue-3617.rs: Move to... + * rust/compile/issues/3617.rs: ...here. + * rust/compile/issue-3618.rs: Move to... + * rust/compile/issues/3618.rs: ...here. + * rust/compile/issue-3625.rs: Move to... + * rust/compile/issues/3625.rs: ...here. + * rust/compile/issue-3628.rs: Move to... + * rust/compile/issues/3628.rs: ...here. + * rust/compile/issue-3642.rs: Move to... + * rust/compile/issues/3642.rs: ...here. + * rust/compile/issue-3643.rs: Move to... + * rust/compile/issues/3643.rs: ...here. + * rust/compile/issue-3645.rs: Move to... + * rust/compile/issues/3645.rs: ...here. + * rust/compile/issue-3646.rs: Move to... + * rust/compile/issues/3646.rs: ...here. + * rust/compile/issue-3647.rs: Move to... + * rust/compile/issues/3647.rs: ...here. + * rust/compile/issue-3648.rs: Move to... + * rust/compile/issues/3648.rs: ...here. + * rust/compile/issue-3649.rs: Move to... + * rust/compile/issues/3649.rs: ...here. + * rust/compile/issue-3651.rs: Move to... + * rust/compile/issues/3651.rs: ...here. + * rust/compile/issue-3652.rs: Move to... + * rust/compile/issues/3652.rs: ...here. + * rust/compile/issue-3654.rs: Move to... + * rust/compile/issues/3654.rs: ...here. + * rust/compile/issue-3656.rs: Move to... + * rust/compile/issues/3656.rs: ...here. + * rust/compile/issue-3657.rs: Move to... + * rust/compile/issues/3657.rs: ...here. + * rust/compile/issue-3659.rs: Move to... + * rust/compile/issues/3659.rs: ...here. + * rust/compile/issue-3660.rs: Move to... + * rust/compile/issues/3660.rs: ...here. + * rust/compile/issue-3661.rs: Move to... + * rust/compile/issues/3661.rs: ...here. + * rust/compile/issue-3662.rs: Move to... + * rust/compile/issues/3662.rs: ...here. + * rust/compile/issue-3663.rs: Move to... + * rust/compile/issues/3663.rs: ...here. + * rust/compile/issue-3664.rs: Move to... + * rust/compile/issues/3664.rs: ...here. + * rust/compile/issue-3665.rs: Move to... + * rust/compile/issues/3665.rs: ...here. + * rust/compile/issue-3667.rs: Move to... + * rust/compile/issues/3667.rs: ...here. + * rust/compile/issue-3670.rs: Move to... + * rust/compile/issues/3670.rs: ...here. + * rust/compile/issue-3671.rs: Move to... + * rust/compile/issues/3671.rs: ...here. + * rust/compile/issue-3672.rs: Move to... + * rust/compile/issues/3672.rs: ...here. + * rust/compile/issue-3711.rs: Move to... + * rust/compile/issues/3711.rs: ...here. + * rust/compile/issue-3726.rs: Move to... + * rust/compile/issues/3726.rs: ...here. + * rust/compile/issue-3836.rs: Move to... + * rust/compile/issues/3836.rs: ...here. + * rust/compile/issue-3874.rs: Move to... + * rust/compile/issues/3874.rs: ...here. + * rust/compile/issue-3875.rs: Move to... + * rust/compile/issues/3875.rs: ...here. + * rust/compile/issue-3876.rs: Move to... + * rust/compile/issues/3876.rs: ...here. + * rust/compile/issue-3885.rs: Move to... + * rust/compile/issues/3885.rs: ...here. + * rust/compile/issue-3898.rs: Move to... + * rust/compile/issues/3898.rs: ...here. + * rust/compile/issue-3904.rs: Move to... + * rust/compile/issues/3904.rs: ...here. + * rust/compile/issue-3910.rs: Move to... + * rust/compile/issues/3910.rs: ...here. + * rust/compile/issue-3915.rs: Move to... + * rust/compile/issues/3915.rs: ...here. + * rust/compile/issue-3916.rs: Move to... + * rust/compile/issues/3916.rs: ...here. + * rust/compile/issue-3919-ice-func-parms.rs: Move to... + * rust/compile/issues/3919-ice-func-parms.rs: ...here. + * rust/compile/issue-3922.rs: Move to... + * rust/compile/issues/3922.rs: ...here. + * rust/compile/issue-3924.rs: Move to... + * rust/compile/issues/3924.rs: ...here. + * rust/compile/issue-3928.rs: Move to... + * rust/compile/issues/3928.rs: ...here. + * rust/compile/issue-3929-1.rs: Move to... + * rust/compile/issues/3929-1.rs: ...here. + * rust/compile/issue-3929-2.rs: Move to... + * rust/compile/issues/3929-2.rs: ...here. + * rust/compile/issue-3930.rs: Move to... + * rust/compile/issues/3930.rs: ...here. + * rust/compile/issue-3931.rs: Move to... + * rust/compile/issues/3931.rs: ...here. + * rust/compile/issue-3947.rs: Move to... + * rust/compile/issues/3947.rs: ...here. + * rust/compile/issue-3951.rs: Move to... + * rust/compile/issues/3951.rs: ...here. + * rust/compile/issue-3958.rs: Move to... + * rust/compile/issues/3958.rs: ...here. + * rust/compile/issue-3960.rs: Move to... + * rust/compile/issues/3960.rs: ...here. + * rust/compile/issue-3965-1.rs: Move to... + * rust/compile/issues/3965-1.rs: ...here. + * rust/compile/issue-3965-2.rs: Move to... + * rust/compile/issues/3965-2.rs: ...here. + * rust/compile/issue-3966.rs: Move to... + * rust/compile/issues/3966.rs: ...here. + * rust/compile/issue-3969.rs: Move to... + * rust/compile/issues/3969.rs: ...here. + * rust/compile/issue-3971.rs: Move to... + * rust/compile/issues/3971.rs: ...here. + * rust/compile/issue-3972.rs: Move to... + * rust/compile/issues/3972.rs: ...here. + * rust/compile/issue-3974.rs: Move to... + * rust/compile/issues/3974.rs: ...here. + * rust/compile/issue-3977.rs: Move to... + * rust/compile/issues/3977.rs: ...here. + * rust/compile/issue-3978.rs: Move to... + * rust/compile/issues/3978.rs: ...here. + * rust/compile/issue-4006.rs: Move to... + * rust/compile/issues/4006.rs: ...here. + * rust/compile/issue-402.rs: Move to... + * rust/compile/issues/402.rs: ...here. + * rust/compile/issue-407-2.rs: Move to... + * rust/compile/issues/407-2.rs: ...here. + * rust/compile/issue-407.rs: Move to... + * rust/compile/issues/407.rs: ...here. + * rust/compile/issue-4090-1.rs: Move to... + * rust/compile/issues/4090-1.rs: ...here. + * rust/compile/issue-4090-2.rs: Move to... + * rust/compile/issues/4090-2.rs: ...here. + * rust/compile/issue-4116.rs: Move to... + * rust/compile/issues/4116.rs: ...here. + * rust/compile/issue-4139.rs: Move to... + * rust/compile/issues/4139.rs: ...here. + * rust/compile/issue-4140-1.rs: Move to... + * rust/compile/issues/4140-1.rs: ...here. + * rust/compile/issue-4140-2.rs: Move to... + * rust/compile/issues/4140-2.rs: ...here. + * rust/compile/issue-4145.rs: Move to... + * rust/compile/issues/4145.rs: ...here. + * rust/compile/issue-4146.rs: Move to... + * rust/compile/issues/4146.rs: ...here. + * rust/compile/issue-4148.rs: Move to... + * rust/compile/issues/4148.rs: ...here. + * rust/compile/issue-4155.rs: Move to... + * rust/compile/issues/4155.rs: ...here. + * rust/compile/issue-4157-1.rs: Move to... + * rust/compile/issues/4157-1.rs: ...here. + * rust/compile/issue-4157-2.rs: Move to... + * rust/compile/issues/4157-2.rs: ...here. + * rust/compile/issue-4158.rs: Move to... + * rust/compile/issues/4158.rs: ...here. + * rust/compile/issue-4159.rs: Move to... + * rust/compile/issues/4159.rs: ...here. + * rust/compile/issue-4162.rs: Move to... + * rust/compile/issues/4162.rs: ...here. + * rust/compile/issue-4163-2.rs: Move to... + * rust/compile/issues/4163-2.rs: ...here. + * rust/compile/issue-4163.rs: Move to... + * rust/compile/issues/4163.rs: ...here. + * rust/compile/issue-4165.rs: Move to... + * rust/compile/issues/4165.rs: ...here. + * rust/compile/issue-4166.rs: Move to... + * rust/compile/issues/4166.rs: ...here. + * rust/compile/issue-4167.rs: Move to... + * rust/compile/issues/4167.rs: ...here. + * rust/compile/issue-4168.rs: Move to... + * rust/compile/issues/4168.rs: ...here. + * rust/compile/issue-4173-1.rs: Move to... + * rust/compile/issues/4173-1.rs: ...here. + * rust/compile/issue-4173-2.rs: Move to... + * rust/compile/issues/4173-2.rs: ...here. + * rust/compile/issue-4173-3.rs: Move to... + * rust/compile/issues/4173-3.rs: ...here. + * rust/compile/issue-4188.rs: Move to... + * rust/compile/issues/4188.rs: ...here. + * rust/compile/issue-4212.rs: Move to... + * rust/compile/issues/4212.rs: ...here. + * rust/compile/issue-4213.rs: Move to... + * rust/compile/issues/4213.rs: ...here. + * rust/compile/issue-4219.rs: Move to... + * rust/compile/issues/4219.rs: ...here. + * rust/compile/issue-4222.rs: Move to... + * rust/compile/issues/4222.rs: ...here. + * rust/compile/issue-4225.rs: Move to... + * rust/compile/issues/4225.rs: ...here. + * rust/compile/issue-4226.rs: Move to... + * rust/compile/issues/4226.rs: ...here. + * rust/compile/issue-4231.rs: Move to... + * rust/compile/issues/4231.rs: ...here. + * rust/compile/issue-4232.rs: Move to... + * rust/compile/issues/4232.rs: ...here. + * rust/compile/issue-4234.rs: Move to... + * rust/compile/issues/4234.rs: ...here. + * rust/compile/issue-4235.rs: Move to... + * rust/compile/issues/4235.rs: ...here. + * rust/compile/issue-4242.rs: Move to... + * rust/compile/issues/4242.rs: ...here. + * rust/compile/issue-4245.rs: Move to... + * rust/compile/issues/4245.rs: ...here. + * rust/compile/issue-4260_0.rs: Move to... + * rust/compile/issues/4260_0.rs: ...here. + * rust/compile/issue-4261.rs: Move to... + * rust/compile/issues/4261.rs: ...here. + * rust/compile/issue-4262.rs: Move to... + * rust/compile/issues/4262.rs: ...here. + * rust/compile/issue-4267.rs: Move to... + * rust/compile/issues/4267.rs: ...here. + * rust/compile/issue-4293.rs: Move to... + * rust/compile/issues/4293.rs: ...here. + * rust/compile/issue-4301.rs: Move to... + * rust/compile/issues/4301.rs: ...here. + * rust/compile/issue-4302.rs: Move to... + * rust/compile/issues/4302.rs: ...here. + * rust/compile/issue-4375-ice-regression.rs: Move to... + * rust/compile/issues/4375-ice-regression.rs: ...here. + * rust/compile/issue-4375-multiple-errors.rs: Move to... + * rust/compile/issues/4375-multiple-errors.rs: ...here. + * rust/compile/issue-4375-tuple-pattern.rs: Move to... + * rust/compile/issues/4375-tuple-pattern.rs: ...here. + * rust/compile/issue-4387.rs: Move to... + * rust/compile/issues/4387.rs: ...here. + * rust/compile/issue-4388.rs: Move to... + * rust/compile/issues/4388.rs: ...here. + * rust/compile/issue-4402.rs: Move to... + * rust/compile/issues/4402.rs: ...here. + * rust/compile/issue-4410.rs: Move to... + * rust/compile/issues/4410.rs: ...here. + * rust/compile/issue-4411.rs: Move to... + * rust/compile/issues/4411.rs: ...here. + * rust/compile/issue-4412.rs: Move to... + * rust/compile/issues/4412.rs: ...here. + * rust/compile/issue-4413.rs: Move to... + * rust/compile/issues/4413.rs: ...here. + * rust/compile/issue-4414.rs: Move to... + * rust/compile/issues/4414.rs: ...here. + * rust/compile/issue-4433.rs: Move to... + * rust/compile/issues/4433.rs: ...here. + * rust/compile/issue-4471-1.rs: Move to... + * rust/compile/issues/4471-1.rs: ...here. + * rust/compile/issue-4471-2.rs: Move to... + * rust/compile/issues/4471-2.rs: ...here. + * rust/compile/issue-4476.rs: Move to... + * rust/compile/issues/4476.rs: ...here. + * rust/compile/issue-4481.rs: Move to... + * rust/compile/issues/4481.rs: ...here. + * rust/compile/issue-4486-1.rs: Move to... + * rust/compile/issues/4486-1.rs: ...here. + * rust/compile/issue-4486-2.rs: Move to... + * rust/compile/issues/4486-2.rs: ...here. + * rust/compile/issue-4517.rs: Move to... + * rust/compile/issues/4517.rs: ...here. + * rust/compile/issue-4538.rs: Move to... + * rust/compile/issues/4538.rs: ...here. + * rust/compile/issue-4563.rs: Move to... + * rust/compile/issues/4563.rs: ...here. + * rust/compile/issue-4592.rs: Move to... + * rust/compile/issues/4592.rs: ...here. + * rust/compile/issue-4617.rs: Move to... + * rust/compile/issues/4617.rs: ...here. + * rust/compile/issue-4631.rs: Move to... + * rust/compile/issues/4631.rs: ...here. + * rust/compile/issue-4674.rs: Move to... + * rust/compile/issues/4674.rs: ...here. + * rust/compile/issue-4678.rs: Move to... + * rust/compile/issues/4678.rs: ...here. + * rust/compile/issue-4689-1.rs: Move to... + * rust/compile/issues/4689-1.rs: ...here. + * rust/compile/issue-4689-2.rs: Move to... + * rust/compile/issues/4689-2.rs: ...here. + * rust/compile/issue-4735.rs: Move to... + * rust/compile/issues/4735.rs: ...here. + * rust/compile/issue-4740.rs: Move to... + * rust/compile/issues/4740.rs: ...here. + * rust/compile/issue-4747.rs: Move to... + * rust/compile/issues/4747.rs: ...here. + * rust/compile/issue-4794.rs: Move to... + * rust/compile/issues/4794.rs: ...here. + * rust/compile/issue-4805.rs: Move to... + * rust/compile/issues/4805.rs: ...here. + * rust/compile/issue-4812.rs: Move to... + * rust/compile/issues/4812.rs: ...here. + * rust/compile/issue-4822.rs: Move to... + * rust/compile/issues/4822.rs: ...here. + * rust/compile/issue-4823.rs: Move to... + * rust/compile/issues/4823.rs: ...here. + * rust/compile/issue-4828.rs: Move to... + * rust/compile/issues/4828.rs: ...here. + * rust/compile/issue-4829-1.rs: Move to... + * rust/compile/issues/4829-1.rs: ...here. + * rust/compile/issue-4829-2.rs: Move to... + * rust/compile/issues/4829-2.rs: ...here. + * rust/compile/issue-4851.rs: Move to... + * rust/compile/issues/4851.rs: ...here. + * rust/compile/issue-4853.rs: Move to... + * rust/compile/issues/4853.rs: ...here. + * rust/compile/issue-4855.rs: Move to... + * rust/compile/issues/4855.rs: ...here. + * rust/compile/issue-4858.rs: Move to... + * rust/compile/issues/4858.rs: ...here. + * rust/compile/issue-4859.rs: Move to... + * rust/compile/issues/4859.rs: ...here. + * rust/compile/issue-4860.rs: Move to... + * rust/compile/issues/4860.rs: ...here. + * rust/compile/issue-4861.rs: Move to... + * rust/compile/issues/4861.rs: ...here. + * rust/compile/issue-4862.rs: Move to... + * rust/compile/issues/4862.rs: ...here. + * rust/compile/issue-4863.rs: Move to... + * rust/compile/issues/4863.rs: ...here. + * rust/compile/issue-4864.rs: Move to... + * rust/compile/issues/4864.rs: ...here. + * rust/compile/issue-4867.rs: Move to... + * rust/compile/issues/4867.rs: ...here. + * rust/compile/issue-4879.rs: Move to... + * rust/compile/issues/4879.rs: ...here. + * rust/compile/issue-557.rs: Move to... + * rust/compile/issues/557.rs: ...here. + * rust/compile/issue-635-1.rs: Move to... + * rust/compile/issues/635-1.rs: ...here. + * rust/compile/issue-635-2.rs: Move to... + * rust/compile/issues/635-2.rs: ...here. + * rust/compile/issue-850.rs: Move to... + * rust/compile/issues/850.rs: ...here. + * rust/compile/issue-852.rs: Move to... + * rust/compile/issues/852.rs: ...here. + * rust/compile/issue-855.rs: Move to... + * rust/compile/issues/855.rs: ...here. + * rust/compile/issue-867.rs: Move to... + * rust/compile/issues/867.rs: ...here. + * rust/compile/issue-925.rs: Move to... + * rust/compile/issues/925.rs: ...here. + * rust/compile/empty_file: Move to... + * rust/compile/issues/empty_file: ...here. + * rust/compile/issue_4402_foo.rs: Move to... + * rust/compile/issues/issue_4402_foo.rs: ...here. + * rust/compile/issues/issues.exp: Copy DG execution from parent directory. + +2026-09-16 Philip Herron + + * rust/compile/issue-4879.rs: New test. + +2026-09-16 Owen Avery + + * rust/compile/issue-4740.rs: New test. + +2026-09-16 Philip Herron + + * rust/compile/issue-4867.rs: New test. + +2026-09-16 Philip Herron + + * rust/compile/issue-4864.rs: New test. + +2026-09-16 Philip Herron + + * rust/execute/torture/issue-4866.rs: New test. + +2026-09-16 Philip Herron + + * rust/compile/issue-4862.rs: New test. + * rust/compile/issue-4863.rs: New test. + +2026-09-16 Philip Herron + + * rust/compile/issue-4861.rs: New test. + +2026-09-16 Philip Herron + + * rust/compile/issue-4858.rs: New test. + +2026-09-16 Philip Herron + + * rust/compile/issue-4859.rs: New test. + +2026-09-16 Philip Herron + + * rust/compile/issue-4860.rs: New test. + +2026-09-16 Philip Herron + + * rust/compile/issue-4855.rs: New test. + +2026-09-16 Philip Herron + + * rust/compile/issue-4853.rs: New test. + +2026-09-16 Philip Herron + + * rust/compile/issue-4851.rs: New test. + +2026-09-16 Philip Herron + + * rust/execute/torture/deferred-add-partial-ord.rs: New test. + +2026-09-16 Pierre-Emmanuel Patry + + * rust/compile/issue-4735.rs: New test. + +2026-09-16 Philip Herron + + * rust/compile/associated-type-bound.rs: New test. + * rust/compile/issue-1726-1.rs: New test. + * rust/compile/issue-1726-2.rs: New test. + +2026-09-16 Philip Herron + + * rust/compile/issue-4829-1.rs: New test. + * rust/compile/issue-4829-2.rs: New test. + +2026-09-16 Philip Herron + + * rust/compile/issue-4828.rs: New test. + +2026-09-16 Philip Herron + + * rust/compile/issue-4822.rs: New test. + +2026-09-16 Philip Herron + + * rust/compile/issue-4823.rs: New test. + +2026-09-16 Philip Herron + + * rust/compile/extern_type_item_resolve.rs: it works + * rust/compile/extern-type-unsized.rs: New test. + * rust/compile/extern-type.rs: New test. + +2026-09-16 Lishin + + * rust/compile/drop-conditional-product-move.rs: New test. + +2026-09-16 Lishin + + * rust/execute/drop-conditional-move.rs: New test. + +2026-09-16 Yap Zhi Heng + + * rust/compile/llvm_builtins.rs: Removed 64-bit functions, ensure main calls all llvm + built-ins, add dg-final directives to check the generated tree dump, ensure the test + only gets compiled on x86 targets. + * rust/compile/llvm_builtins_64_bit.rs: New test derived from llvm_builtins.rs, but + for 64-bit functions. + +2026-09-16 Yap Zhi Heng + + * rust/compile/llvm_builtins.rs: Enable addcarryx cases, add TODO comment for vcvtph2ps & + vcvtps2ph cases. + +2026-09-16 Yap Zhi Heng + + * rust/compile/llvm_builtins.rs: New file. + +2026-09-16 Philip Herron + + * rust/compile/issue-4166.rs: + +2026-09-16 Yap Zhi Heng + + * rust/compile/let-structpattern.rs: New file. + * rust/execute/torture/let-structpattern.rs: New file. + +2026-09-16 Lishin + + * rust/borrowck/drop_analysis_conditional_move.rs: New test. + +2026-09-16 Philip Herron + + * rust/compile/issue-4812.rs: New test. + +2026-09-16 Enes Cevik + + * rust/alloc/alloc.exp: New test. + * rust/alloc/alloc/src/alloc.rs: New test. + * rust/alloc/alloc/src/alloc/tests.rs: New test. + * rust/alloc/alloc/src/borrow.rs: New test. + * rust/alloc/alloc/src/boxed.rs: New test. + * rust/alloc/alloc/src/collections/binary_heap.rs: New test. + * rust/alloc/alloc/src/collections/btree/append.rs: New test. + * rust/alloc/alloc/src/collections/btree/borrow.rs: New test. + * rust/alloc/alloc/src/collections/btree/borrow/tests.rs: New test. + * rust/alloc/alloc/src/collections/btree/map.rs: New test. + * rust/alloc/alloc/src/collections/btree/map/entry.rs: New test. + * rust/alloc/alloc/src/collections/btree/map/tests.rs: New test. + * rust/alloc/alloc/src/collections/btree/mem.rs: New test. + * rust/alloc/alloc/src/collections/btree/merge_iter.rs: New test. + * rust/alloc/alloc/src/collections/btree/mod.rs: New test. + * rust/alloc/alloc/src/collections/btree/navigate.rs: New test. + * rust/alloc/alloc/src/collections/btree/node.rs: New test. + * rust/alloc/alloc/src/collections/btree/node/tests.rs: New test. + * rust/alloc/alloc/src/collections/btree/remove.rs: New test. + * rust/alloc/alloc/src/collections/btree/search.rs: New test. + * rust/alloc/alloc/src/collections/btree/set.rs: New test. + * rust/alloc/alloc/src/collections/btree/set/tests.rs: New test. + * rust/alloc/alloc/src/collections/btree/split.rs: New test. + * rust/alloc/alloc/src/collections/linked_list.rs: New test. + * rust/alloc/alloc/src/collections/linked_list/tests.rs: New test. + * rust/alloc/alloc/src/collections/mod.rs: New test. + * rust/alloc/alloc/src/collections/vec_deque.rs: New test. + * rust/alloc/alloc/src/collections/vec_deque/drain.rs: New test. + * rust/alloc/alloc/src/collections/vec_deque/tests.rs: New test. + * rust/alloc/alloc/src/fmt.rs: New test. + * rust/alloc/alloc/src/lib.rs: New test. + * rust/alloc/alloc/src/macros.rs: New test. + * rust/alloc/alloc/src/prelude/mod.rs: New test. + * rust/alloc/alloc/src/prelude/v1.rs: New test. + * rust/alloc/alloc/src/raw_vec.rs: New test. + * rust/alloc/alloc/src/raw_vec/tests.rs: New test. + * rust/alloc/alloc/src/rc.rs: New test. + * rust/alloc/alloc/src/rc/tests.rs: New test. + * rust/alloc/alloc/src/slice.rs: New test. + * rust/alloc/alloc/src/str.rs: New test. + * rust/alloc/alloc/src/string.rs: New test. + * rust/alloc/alloc/src/sync.rs: New test. + * rust/alloc/alloc/src/sync/tests.rs: New test. + * rust/alloc/alloc/src/task.rs: New test. + * rust/alloc/alloc/src/tests.rs: New test. + * rust/alloc/alloc/src/vec.rs: New test. + * rust/alloc/core.rs: New test. + * rust/alloc/prelude.rs: New test. + +2026-09-16 Philip Herron + + * rust/compile/issue-4805.rs: New test. + +2026-09-16 Philip Herron + + * rust/execute/torture/issue-4804.rs: New test. + +2026-09-16 Owen Avery + + * rust/compile/mod_fn_conflict.rs: New test. + +2026-09-16 Utkarsh Bahuguna + + * rust/compile/empty_path2.rs: New test. + * rust/compile/empty_path3.rs: New test. + +2026-09-16 Owen Avery + + * rust/compile/for-loop3.rs: New test. + +2026-09-16 Richard Biener + + * gcc.dg/vect/vect-bitint-1.c: New testcase. + +2026-09-16 Stefan Schulze Frielinghaus + + * gcc.dg/asm-hard-reg-6.c: This patch would result in only one + reload for alternative 1 in test_reg_reg which changes costing + which in turn leads to choosing alternative 1 for which we + didn't test. Restore the old behaviour by choosing for GPR3 r4 + which results in two reloads in each alternative. + * gcc.target/s390/asm-hard-reg-1.c: Similarly here we also + compute a more precise conflicting register set which leads to + choosing a different insn alternative for test_out_2. + 2026-09-15 Takayuki 'January June' Suwa * gcc.target/xtensa/MOVSP.c: New test. diff --git a/libgm2/ChangeLog b/libgm2/ChangeLog index 644d85759708..d90e1a97ff96 100644 --- a/libgm2/ChangeLog +++ b/libgm2/ChangeLog @@ -1,3 +1,15 @@ +2026-09-16 Gaius Mulley + + PR modula2/127359 + * libm2cor/Makefile.am: Use $(SHELL) to invoke makeSystem. + * libm2iso/Makefile.am: Ditto. + * libm2min/Makefile.am: Ditto. + * libm2pim/Makefile.am: Ditto. + * libm2pim/Makefile.in: Rebuild. + * libm2cor/Makefile.in: Ditto. + * libm2iso/Makefile.in: Ditto. + * libm2min/Makefile.in: Ditto. + 2026-09-15 Gaius Mulley PR modula2/127359 diff --git a/libgrust/ChangeLog b/libgrust/ChangeLog index 60e12fad40fe..9cc01b2da161 100644 --- a/libgrust/ChangeLog +++ b/libgrust/ChangeLog @@ -1,3 +1,81 @@ +2026-09-16 Enes Cevik + + * rustc-lib/version-info: + * rustc-lib/alloc/Cargo.toml: New file. + * rustc-lib/alloc/benches/binary_heap.rs: New file. + * rustc-lib/alloc/benches/btree/map.rs: New file. + * rustc-lib/alloc/benches/btree/mod.rs: New file. + * rustc-lib/alloc/benches/btree/set.rs: New file. + * rustc-lib/alloc/benches/lib.rs: New file. + * rustc-lib/alloc/benches/linked_list.rs: New file. + * rustc-lib/alloc/benches/slice.rs: New file. + * rustc-lib/alloc/benches/str.rs: New file. + * rustc-lib/alloc/benches/string.rs: New file. + * rustc-lib/alloc/benches/vec.rs: New file. + * rustc-lib/alloc/benches/vec_deque.rs: New file. + * rustc-lib/alloc/benches/vec_deque_append.rs: New file. + * rustc-lib/alloc/src/alloc.rs: New file. + * rustc-lib/alloc/src/alloc/tests.rs: New file. + * rustc-lib/alloc/src/borrow.rs: New file. + * rustc-lib/alloc/src/boxed.rs: New file. + * rustc-lib/alloc/src/collections/binary_heap.rs: New file. + * rustc-lib/alloc/src/collections/btree/append.rs: New file. + * rustc-lib/alloc/src/collections/btree/borrow.rs: New file. + * rustc-lib/alloc/src/collections/btree/borrow/tests.rs: New file. + * rustc-lib/alloc/src/collections/btree/map.rs: New file. + * rustc-lib/alloc/src/collections/btree/map/entry.rs: New file. + * rustc-lib/alloc/src/collections/btree/map/tests.rs: New file. + * rustc-lib/alloc/src/collections/btree/mem.rs: New file. + * rustc-lib/alloc/src/collections/btree/merge_iter.rs: New file. + * rustc-lib/alloc/src/collections/btree/mod.rs: New file. + * rustc-lib/alloc/src/collections/btree/navigate.rs: New file. + * rustc-lib/alloc/src/collections/btree/node.rs: New file. + * rustc-lib/alloc/src/collections/btree/node/tests.rs: New file. + * rustc-lib/alloc/src/collections/btree/remove.rs: New file. + * rustc-lib/alloc/src/collections/btree/search.rs: New file. + * rustc-lib/alloc/src/collections/btree/set.rs: New file. + * rustc-lib/alloc/src/collections/btree/set/tests.rs: New file. + * rustc-lib/alloc/src/collections/btree/split.rs: New file. + * rustc-lib/alloc/src/collections/linked_list.rs: New file. + * rustc-lib/alloc/src/collections/linked_list/tests.rs: New file. + * rustc-lib/alloc/src/collections/mod.rs: New file. + * rustc-lib/alloc/src/collections/vec_deque.rs: New file. + * rustc-lib/alloc/src/collections/vec_deque/drain.rs: New file. + * rustc-lib/alloc/src/collections/vec_deque/tests.rs: New file. + * rustc-lib/alloc/src/fmt.rs: New file. + * rustc-lib/alloc/src/lib.rs: New file. + * rustc-lib/alloc/src/macros.rs: New file. + * rustc-lib/alloc/src/prelude/mod.rs: New file. + * rustc-lib/alloc/src/prelude/v1.rs: New file. + * rustc-lib/alloc/src/raw_vec.rs: New file. + * rustc-lib/alloc/src/raw_vec/tests.rs: New file. + * rustc-lib/alloc/src/rc.rs: New file. + * rustc-lib/alloc/src/rc/tests.rs: New file. + * rustc-lib/alloc/src/slice.rs: New file. + * rustc-lib/alloc/src/str.rs: New file. + * rustc-lib/alloc/src/string.rs: New file. + * rustc-lib/alloc/src/sync.rs: New file. + * rustc-lib/alloc/src/sync/tests.rs: New file. + * rustc-lib/alloc/src/task.rs: New file. + * rustc-lib/alloc/src/tests.rs: New file. + * rustc-lib/alloc/src/vec.rs: New file. + * rustc-lib/alloc/tests/arc.rs: New file. + * rustc-lib/alloc/tests/binary_heap.rs: New file. + * rustc-lib/alloc/tests/borrow.rs: New file. + * rustc-lib/alloc/tests/boxed.rs: New file. + * rustc-lib/alloc/tests/btree_set_hash.rs: New file. + * rustc-lib/alloc/tests/cow_str.rs: New file. + * rustc-lib/alloc/tests/fmt.rs: New file. + * rustc-lib/alloc/tests/heap.rs: New file. + * rustc-lib/alloc/tests/lib.rs: New file. + * rustc-lib/alloc/tests/linked_list.rs: New file. + * rustc-lib/alloc/tests/rc.rs: New file. + * rustc-lib/alloc/tests/slice.rs: New file. + * rustc-lib/alloc/tests/str.rs: New file. + * rustc-lib/alloc/tests/string.rs: New file. + * rustc-lib/alloc/tests/vec.rs: New file. + * rustc-lib/alloc/tests/vec_deque.rs: New file. + 2026-06-29 Pietro Monteiro PR bootstrap/103459 diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 5890a97467f7..42bd1bfe5f5b 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,27 @@ +2026-09-16 Jonathan Wakely + + * doc/html/manual/status.html: Regenerate. + +2026-09-16 Jonathan Wakely + + * testsuite/20_util/function_objects/dr660.cc: Include the + testsuite_hooks.h header not testsuite_hooks.cc. + +2026-09-16 Jonathan Wakely + + * testsuite/27_io/basic_filebuf/close/char/4879.cc: Fix typo in + comment. + +2026-09-16 Jonathan Wakely + + * include/bits/atomic_wait.h: Fix typo in comment. + +2026-09-16 Jonathan Wakely + + PR libstdc++/127430 + * config/io/basic_file_stdio.cc (__basic_file::fd) Fix typo in + preprocessor condition. + 2026-09-15 Patrick Palka * include/bits/stl_iterator.h From 3ba687c78ac7e26cf2f26c01f4ab8439e439269f Mon Sep 17 00:00:00 2001 From: Gaius Mulley Date: Thu, 17 Sep 2026 01:23:57 +0100 Subject: [PATCH 143/584] PR modula2/126174: Documentation generation produces warnings when generating gm2.info This patch corrects navigation node ordering in the menu. The patch also introduces README.texi files for the gm2-libs-{cor,iso,pim}-common/README.texi. gcc/ChangeLog: PR modula2/126174 * doc/gm2.texi (Using GNU Modula-2): Move Unbounded by reference after Exception handling in the menu. gcc/m2/ChangeLog: PR modula2/126174 * Make-lang.in (m2/gm2-libs.texi): Add test for m2/gm2-libs-pim-common and create if necessary. Add test for m2/gm2-libs-iso-common and create if necessary. Add test for m2/gm2-libs-cor-common and create if necessary. * tools-src/def2doc.py (Base_Libs): Change section heading name. (library_classifications): Add PIM_Common, ISO_Common and COR_Common. (PIM_Common): New list. (ISO_Common): New list. (COR_Common): New list. * gm2-libs-cor-common/README.texi: New file. * gm2-libs-iso-common/README.texi: New file. * gm2-libs-pim-common/README.texi: New file. Signed-off-by: Gaius Mulley --- gcc/doc/gm2.texi | 4 ++-- gcc/m2/Make-lang.in | 3 +++ gcc/m2/gm2-libs-cor-common/README.texi | 2 ++ gcc/m2/gm2-libs-iso-common/README.texi | 5 +++++ gcc/m2/gm2-libs-pim-common/README.texi | 6 ++++++ gcc/m2/tools-src/def2doc.py | 9 +++++++-- 6 files changed, 25 insertions(+), 4 deletions(-) create mode 100644 gcc/m2/gm2-libs-cor-common/README.texi create mode 100644 gcc/m2/gm2-libs-iso-common/README.texi create mode 100644 gcc/m2/gm2-libs-pim-common/README.texi diff --git a/gcc/doc/gm2.texi b/gcc/doc/gm2.texi index b4ecef2c5a01..e99789e53d1e 100644 --- a/gcc/doc/gm2.texi +++ b/gcc/doc/gm2.texi @@ -230,8 +230,8 @@ such as the AVR and the ARM). * Semantic checking:: How to detect run time problems at compile time. * Extensions:: GNU Modula-2 language extensions. * Type compatibility:: Data type compatibility. -* Unbounded by reference::Explanation of a language optimization. * Exception handling:: Example of exception handling. +* Unbounded by reference::Explanation of a language optimization. * Building a shared library:: How to build a shared library. * Interface for Python:: How to produce swig interface files. * Producing a Python module:: How to produce a Python module. @@ -1497,7 +1497,7 @@ the following pairs of options: The option @samp{-fsources} will show the source module, path and pathname for each module parsed. -@node Exceptions, Semantic checking, Dialect, Using +@node Exceptions, Semantic checking, Module Search Path, Using @section Exception implementation This section describes how exceptions are implemented in GNU Modula-2 diff --git a/gcc/m2/Make-lang.in b/gcc/m2/Make-lang.in index d7a27d3422c9..d7c46ec1a190 100644 --- a/gcc/m2/Make-lang.in +++ b/gcc/m2/Make-lang.in @@ -238,6 +238,9 @@ m2/gm2-libs.texi: gm2-libs.texi-check; @true ifeq ($(HAVE_PYTHON),yes) gm2-libs.texi-check: m2/SYSTEM-pim.texi m2/SYSTEM-iso.texi m2/Builtins.texi \ m2/gm2-libs-coroutines/SYSTEM.def + -test -d m2/gm2-libs-pim-common || $(mkinstalldirs) m2/gm2-libs-pim-common + -test -d m2/gm2-libs-iso-common || $(mkinstalldirs) m2/gm2-libs-iso-common + -test -d m2/gm2-libs-cor-common || $(mkinstalldirs) m2/gm2-libs-cor-common -test -d m2/gm2-libs-log || $(mkinstalldirs) m2/gm2-libs-log -test -d m2/gm2-libs-iso || $(mkinstalldirs) m2/gm2-libs-iso -test -d m2/gm2-libs || $(mkinstalldirs) m2/gm2-libs diff --git a/gcc/m2/gm2-libs-cor-common/README.texi b/gcc/m2/gm2-libs-cor-common/README.texi new file mode 100644 index 000000000000..5842b74023b9 --- /dev/null +++ b/gcc/m2/gm2-libs-cor-common/README.texi @@ -0,0 +1,2 @@ +The @code{SYSTEM} module will have additional size based data types if +they are supported by the target. diff --git a/gcc/m2/gm2-libs-iso-common/README.texi b/gcc/m2/gm2-libs-iso-common/README.texi new file mode 100644 index 000000000000..94b683a7f1d0 --- /dev/null +++ b/gcc/m2/gm2-libs-iso-common/README.texi @@ -0,0 +1,5 @@ +The modules @code{ComplexMath}, @code{LongComplexMath} and +@code{ShortComplexMath} will have instrinic procedure functions +enabled if the target supports the required GCC builtins. The +@code{SYSTEM} module will have additional size based data types if +they are supported by the target. diff --git a/gcc/m2/gm2-libs-pim-common/README.texi b/gcc/m2/gm2-libs-pim-common/README.texi new file mode 100644 index 000000000000..25e6f21ded79 --- /dev/null +++ b/gcc/m2/gm2-libs-pim-common/README.texi @@ -0,0 +1,6 @@ +These library modules contain access to functionality which is enabled +if there is support in the GCC builtins. The module +@code{Builtins} contains access to many of the instrinsic +procedure functions supported by GCC. The @code{SYSTEM} module +has been extended to include target supported data types (for example +fixed sized @code{CARDINAL}, @code{INTEGER} and @code{REAL} types). diff --git a/gcc/m2/tools-src/def2doc.py b/gcc/m2/tools-src/def2doc.py index a953d9596997..e6e79884d9e6 100644 --- a/gcc/m2/tools-src/def2doc.py +++ b/gcc/m2/tools-src/def2doc.py @@ -25,7 +25,7 @@ import os import sys -Base_Libs = ['gm2-libs', 'Base libraries', 'Basic M2F compatible libraries'] +Base_Libs = ['gm2-libs', 'Base libraries', 'Basic PIM style compatible libraries'] PIM_Log_Desc = 'PIM and Logitech 3.0 compatible libraries' PIM_Log = ['gm2-libs-log', 'PIM and Logitech 3.0 Compatible', PIM_Log_Desc] @@ -33,7 +33,12 @@ PIM_Cor = ['gm2-libs-coroutines', 'PIM coroutine support', PIM_Cor_Desc] ISO_Libs = ['gm2-libs-iso', 'M2 ISO Libraries', 'ISO defined libraries'] -library_classifications = [Base_Libs, PIM_Log, PIM_Cor, ISO_Libs] +PIM_Common = ['gm2-libs-pim-common', 'PIM target', 'PIM target'] +ISO_Common = ['gm2-libs-iso-common', 'ISO target', 'ISO target'] +COR_Common = ['gm2-libs-cor-common', 'Coroutine target', 'Coroutine target'] + +library_classifications = [Base_Libs, PIM_Log, PIM_Cor, ISO_Libs, + PIM_Common, ISO_Common, COR_Common] # state_states state_none, state_var, state_type, state_const = range(4) From e548eb628c689e2836e570aef98b9547aff97a02 Mon Sep 17 00:00:00 2001 From: Andrea Pinski Date: Fri, 11 Sep 2026 13:32:39 -0700 Subject: [PATCH 144/584] match: x+umax(x,1) -> umax(x*2, 1) [PR127103] This adds a simplification for `x+umax(x,1)` to `umax(x*2, 1)` when `x*2` is known not to overflow. This shows up with std::vector::push_back after the patch which adds `x+minmax(a,b)` simplification; it is also a special case of that patch for `umax and 1`. This gives a small code generation improvement with std::vector::push_back because we trade an add after the umax with a shift beforehand. Bootstrapped and tested on x86_64-linux-gnu. PR tree-optimization/127103 gcc/ChangeLog: * match.pd (`x+umax(x,1)`): New pattern. gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/max1-plus-1.c: New test. Signed-off-by: Andrea Pinski --- gcc/match.pd | 12 +++++++++++ gcc/testsuite/gcc.dg/tree-ssa/max1-plus-1.c | 22 +++++++++++++++++++++ 2 files changed, 34 insertions(+) create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/max1-plus-1.c diff --git a/gcc/match.pd b/gcc/match.pd index 4059ed787f05..82cf6ae0a3c6 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -522,6 +522,18 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) (if (ANY_INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_UNDEFINED (type)) (abs @0))) +#if GIMPLE +/* x + uMax(x, 1) -> uMax(x+x, 1) + if x+x is known not to wrap/overflow. */ +(simplify + (plus:c @0 (max:s@2 @0 integer_onep@1)) + (if (TYPE_UNSIGNED (type)) + (with { int_range_max vr0; } + (if (gimple_match_range_of_expr (vr0, @0, @2) + && range_op_handler (PLUS_EXPR).overflow_free_p (vr0, vr0)) + (max (plus @0 @0) @1))))) +#endif + /* X * 1, X / 1 -> X. */ (for op (mult trunc_div ceil_div floor_div round_div exact_div) (simplify diff --git a/gcc/testsuite/gcc.dg/tree-ssa/max1-plus-1.c b/gcc/testsuite/gcc.dg/tree-ssa/max1-plus-1.c new file mode 100644 index 000000000000..9fdf0a40cc48 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/max1-plus-1.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-optimized-raw" } */ +/* x + uMax(x, 1) -> uMax(x+x, 1) */ +/* PR tree-optimization/127103 */ + +__attribute__((always_inline)) +static inline unsigned +max(unsigned a, unsigned b) +{ + if (a < b) + return b; + return a; +} + +unsigned f1(unsigned a, unsigned t1) +{ + if (a > __INT_MAX__) + return 0; + return a + max(1, a); +} + +/* { dg-final { scan-tree-dump "gimple_assign Date: Fri, 11 Sep 2026 17:58:42 -0700 Subject: [PATCH 145/584] match: `minmax (a - c, b) + c -> minmax (a, b + c)` in some cases [PR127103] This adds a pattern to optimize `minmax (a - c, b) + c` into `minmax (a, b + c)` when `b + c` is known not to overflow. This is a simplified version from previous one where we only handle the `a - c` case rather than the generic This shows up in std::vector::push_back : ``` # RANGE [irange] const size_type [0, 2147483647] MASK 0x7fffffff VALUE 0x0 __room_33 = 2147483647 - _32; ... # RANGE [irange] long unsigned int [1, 2147483646] MASK 0x7fffffff VALUE 0x0 _35 = MIN_EXPR <__room_33, _34>; # RANGE [irange] long unsigned int [1, 4294967292] _36 = _32 + _35; ``` _32 has a range of `[0, 2147483647]`, _34 has a range of `[1, 2147483646]`. This is transformed into: _t = _32 + _34; _36 = MIN_EXPR<_t, 2147483647> This then allows to remove a condition that was never could be executed too. This is currently limited to unsigned types as overflow_free_p does not tell me if we are going to introduce new undefined overflow; it will return true for all TYPE_OVERFLOW_UNDEFINED types. I filed PR 127356 to add a modified version of overflow_free_p. But since the types in push_back is unsigned this is enough for now. When that goes in; I will combine r17-4210-g9d734bb468e714 with this pattern and remove the special case of 0. Changes since v1: * v2: Only handle the case where we have `a - c` as the operand to minmax. Bootstrapped and tested on x86_64-linux-gnu. PR tree-optimization/127103 gcc/ChangeLog: * match.pd (`minmax (a - c, b) + c`): New pattern. gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/minmax-plus-1.c: New test. Signed-off-by: Andrea Pinski --- gcc/match.pd | 11 ++++++ gcc/testsuite/gcc.dg/tree-ssa/minmax-plus-1.c | 39 +++++++++++++++++++ 2 files changed, 50 insertions(+) create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/minmax-plus-1.c diff --git a/gcc/match.pd b/gcc/match.pd index 82cf6ae0a3c6..1c0393d11cde 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -532,6 +532,17 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) (if (gimple_match_range_of_expr (vr0, @0, @2) && range_op_handler (PLUS_EXPR).overflow_free_p (vr0, vr0)) (max (plus @0 @0) @1))))) +/* minmax (a - c, b) + c -> minmax (a, b + c) if b+c don't overflow. */ +(for minmax (min max) + (simplify + (plus:c @0 (minmax:cs@3 (minus @1 @0) @2)) + (with { int_range_max vr0, vr2; } + (if (TYPE_UNSIGNED (type) + && gimple_match_range_of_expr (vr0, @0) + && gimple_match_range_of_expr (vr2, @2, @3) + && range_op_handler (PLUS_EXPR).overflow_free_p (vr0, vr2)) + (minmax @1 (plus @2 @0)))))) + #endif /* X * 1, X / 1 -> X. */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/minmax-plus-1.c b/gcc/testsuite/gcc.dg/tree-ssa/minmax-plus-1.c new file mode 100644 index 000000000000..75067fdb962d --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/minmax-plus-1.c @@ -0,0 +1,39 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-optimized-raw" } */ +/* minmax (a, b) + c -> minmax (a + c, b + c) */ +/* PR tree-optimization/127103 */ + +__attribute__((always_inline)) +static inline unsigned +min(unsigned a, unsigned b) +{ + if (a > b) + return b; + return a; +} +__attribute__((always_inline)) +static inline unsigned +max(unsigned a, unsigned b) +{ + if (a < b) + return b; + return a; +} + +unsigned f(unsigned a, unsigned t1) +{ + if (a > __INT_MAX__) + return 0; + unsigned t = __INT_MAX__ - a; + return a + min(t, a); +} + +unsigned f1(unsigned a, unsigned t1) +{ + if (a > __INT_MAX__) + return 0; + unsigned t = __INT_MAX__ - a; + return a + max(t, a); +} + +/* { dg-final { scan-tree-dump-times "gimple_assign Date: Wed, 16 Sep 2026 22:01:46 -0400 Subject: [PATCH 146/584] cobol: Refactor numeric-editing formatting for speed. Upon noticing that the routine that formats a string of digits in accordance with a numeric-edited PICTURE string has been running very slowly, I have broken out a specific routine for handling ASCII strings, which eliminates the costly conversion to an arbitrary encoding. I have also refactored the underlying conversion so that it is running about eight times faster than before. gcc/cobol/ChangeLog: * genapi.cc (actually_create_the_static_field): Use expanded PICTURE string. * lang-specs.h: Updated cc1_options formatting string. * move.cc (mh_source_is_literalN): Use new numeric-edited routine. (mh_to_numeric_edited): Likewise. (move_helper): Likewise. * parse.y: Formatting. * symbols.cc (symbol_file): Mollify cppcheck. (expand_picture): Modified for numeric-editing. * symbols.h (cbl_dialect_str): Formatting. (enum dspc_t): Formatting. (MAXIMUM_ALPHA_LENGTH): Formatting. (is_elementary): Formatting. (struct cbl_field_t): Formatting. (struct cbl_refer_t): Formatting. (struct parameter_t): Formatting. (struct cbl_label_t): Formatting. (class temporaries_t): Formatting. (struct cbl_locale_t): Formatting. (hex2numstr): Formatting. (struct cbl_file_key_t): Formatting. (struct cbl_file_t): Formatting. (struct symbol_elem_t): Formatting. (redefine_field): Formatting. (is_prototypical): Formatting. (struct cbl_prog_hier_t): Formatting. (keyword_alias_add): Formatting. (class current_tokens_t): Formatting. (expand_picture): Formatting. * util.cc (cbl_prototype_ok): Formatting. (cdf_file): Formatting. (repeat_count): Formatting. (cbl_field_t::encode_numeric): Formatting; use new numeric-edited routine. (cbl_field_t::report_invalid_initial_value): Formatting. (valid_move): Formatting. (cobol_filename): Formatting. (gcc_location_set): Formatting. (parse_file): Formatting. libgcobol/ChangeLog: * gmath.cc (__gg__int128_to_int128_rounded): Change error handling. * libgcobol.cc (int128_to_field): Likewise. (__gg__int128_to_ascii_numeric_display): New routine for increased speed. * valconv.cc (TOUPPER): Remove. (expand_picture): Remove; it's being done in another routine. (Lindex): Remove. (Rindex): Remove. (__gg__string_to_numeric_edited): Refactor for speed. (__gg__string_to_alpha_edited): Eliminate call to expand_picture(). (__gg__currency_sign_init): Formatting. * valconv.h: Change __gg__string_to_numeric_edited() return type. gcc/testsuite/ChangeLog: * cobol.dg/group2/PR126612_-_Ignore_TRACE_-_gnu.cob: New test. * cobol.dg/group2/PR126612_-_Ignore_TRACE_-_ibm.cob: New test. * cobol.dg/group2/PR126612_-_Ignore_TRACE_-_iso.cob: New test. * cobol.dg/group2/PR126612_-_Ignore_TRACE_-_mf.cob: New test. * cobol.dg/group2/RT3611_-_BY_CONTENT_LENGTH_OF.cob: New test. * cobol.dg/group2/__define__text_.cob: New test. * cobol.dg/group2/__define__text_.out: New test. * cobol.dg/group2/customer_bug_Heuristic_Fail.cob: New test. * cobol.dg/group2/customer_bug_Heuristic_Fail.out: New test. --- gcc/cobol/genapi.cc | 4 +- gcc/cobol/lang-specs.h | 2 +- gcc/cobol/move.cc | 117 +- gcc/cobol/parse.y | 1 - gcc/cobol/symbols.cc | 169 +- gcc/cobol/symbols.h | 175 +-- gcc/cobol/util.cc | 93 +- .../group2/PR126612_-_Ignore_TRACE_-_gnu.cob | 15 + .../group2/PR126612_-_Ignore_TRACE_-_ibm.cob | 15 + .../group2/PR126612_-_Ignore_TRACE_-_iso.cob | 15 + .../group2/PR126612_-_Ignore_TRACE_-_mf.cob | 15 + .../group2/RT3611_-_BY_CONTENT_LENGTH_OF.cob | 23 + .../cobol.dg/group2/__define__text_.cob | 23 + .../cobol.dg/group2/__define__text_.out | 3 + .../group2/customer_bug_Heuristic_Fail.cob | 10 + .../group2/customer_bug_Heuristic_Fail.out | 1 + libgcobol/gmath.cc | 2 +- libgcobol/libgcobol.cc | 43 +- libgcobol/valconv.cc | 1371 +++++------------ libgcobol/valconv.h | 2 +- 20 files changed, 883 insertions(+), 1216 deletions(-) create mode 100644 gcc/testsuite/cobol.dg/group2/PR126612_-_Ignore_TRACE_-_gnu.cob create mode 100644 gcc/testsuite/cobol.dg/group2/PR126612_-_Ignore_TRACE_-_ibm.cob create mode 100644 gcc/testsuite/cobol.dg/group2/PR126612_-_Ignore_TRACE_-_iso.cob create mode 100644 gcc/testsuite/cobol.dg/group2/PR126612_-_Ignore_TRACE_-_mf.cob create mode 100644 gcc/testsuite/cobol.dg/group2/RT3611_-_BY_CONTENT_LENGTH_OF.cob create mode 100644 gcc/testsuite/cobol.dg/group2/__define__text_.cob create mode 100644 gcc/testsuite/cobol.dg/group2/__define__text_.out create mode 100644 gcc/testsuite/cobol.dg/group2/customer_bug_Heuristic_Fail.cob create mode 100644 gcc/testsuite/cobol.dg/group2/customer_bug_Heuristic_Fail.out diff --git a/gcc/cobol/genapi.cc b/gcc/cobol/genapi.cc index 71fc31852c36..5d7d553b9d8b 100644 --- a/gcc/cobol/genapi.cc +++ b/gcc/cobol/genapi.cc @@ -14431,7 +14431,9 @@ actually_create_the_static_field( cbl_field_t *new_var, } tree offset = build_int_cst_type(SIZE_T, new_var->offset); tree name = gg_string_literal(new_var->name); - tree picture = gg_string_literal(new_var->data.picture); + char *expanded = expand_picture(new_var->data.picture); + tree picture = gg_string_literal(expanded); + free(expanded); tree initial; if( length_of_initial_string == 0 || !new_var->data.has_initial_value() ) { diff --git a/gcc/cobol/lang-specs.h b/gcc/cobol/lang-specs.h index ace1dfa06801..ea9a144c2a8b 100644 --- a/gcc/cobol/lang-specs.h +++ b/gcc/cobol/lang-specs.h @@ -34,7 +34,7 @@ {".CBL", "@cobol", 0, 0, 0}, {"@cobol", "cobol1 %i %(cc1_options) " - "%{B*} %{D*} %{E} %{I*} %{M} %{fmax-errors*} %{fsyntax-only*} " + "%{I*} %{B*} %{D*} %{E} %{M} %{fmax-errors*} %{fsyntax-only*} " "%{idirafter}" "%{fcobol-exceptions*} " "%{copyext} " diff --git a/gcc/cobol/move.cc b/gcc/cobol/move.cc index 6c7f8e0c11a7..44df3e4f2405 100644 --- a/gcc/cobol/move.cc +++ b/gcc/cobol/move.cc @@ -15,7 +15,7 @@ * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORSdf * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT @@ -201,7 +201,8 @@ mh_source_is_literalN(cbl_refer_t &destref, tree size_error) { bool moved = false; - if( sourceref.field->type == FldLiteralN ) + if( sourceref.field->type == FldLiteralN + && destref.field->type != FldNumericEdited ) { Analyze(); switch( destref.field->type ) @@ -348,7 +349,6 @@ mh_source_is_literalN(cbl_refer_t &destref, case FldNumericDisplay: case FldNumericBinary: - case FldNumericEdited: case FldPacked: { SHOW_PARSE1 @@ -1656,6 +1656,109 @@ mh_binary_to_packed(const cbl_refer_t &destref, return moved; } +static bool +mh_to_numeric_edited(const cbl_refer_t &destref, + const cbl_refer_t &sourceref, + cbl_round_t rounded, + tree size_error) + { + bool moved = false; + + if( destref.field->type == FldNumericEdited + && destref.field->codeset.stride() == 1 + && !(destref.field->attr & scaled_e) + && (!(sourceref.field->attr & intermediate_e) || sourceref.field->type == FldLiteralN) + + && ( sourceref.field->type == FldNumericBinary + || sourceref.field->type == FldNumericBin5 + || sourceref.field->type == FldNumericDisplay + || sourceref.field->type == FldLiteralN + || sourceref.field->type == FldIndex + || sourceref.field->type == FldPointer ) ) + { + const charmap_t *charmap = __gg__get_charmap(destref.field->codeset.encoding); + if( !charmap->is_like_ebcdic() ) + { + tree value = get_binary_value(sourceref, INT128); + + int scaler = 0; + int rdigits = sourceref.field->data.rdigits; + if( sourceref.field->attr & scaled_e) + { + if( sourceref.field->data.rdigits < 0 ) + { + // This is like 9999PPP, where rdigits = -3 + scaler = sourceref.field->data.rdigits; + rdigits = 0; + } + else + { + // This is like PPP9999, where rdigits=3 and digits=4 + rdigits = sourceref.field->data.digits + + sourceref.field->data.rdigits; + } + } + // We have to make the source decimal point position line up with that of + // the destination. + scaler = destref.field->data.rdigits - rdigits - scaler; + + // To line up the decimal points we multiply value by 10**scaler + if( scaler > 0 ) + { + FIXED_WIDE_INT(128) power_of_ten = get_power_of_ten( scaler ); + tree pot = wide_int_to_tree(INT128, power_of_ten); + value = gg_multiply(value, pot); + } + else if( scaler < 0 ) + { + FIXED_WIDE_INT(128) power_of_ten = get_power_of_ten( -scaler ); + tree pot = wide_int_to_tree(INT128, power_of_ten); + value = gg_call_expr(INT128, + "__gg__int128_to_int128_rounded", + build_int_cst_type(INT, rounded), + value, + pot, + NULL_TREE); + } + // The decimal points are lined up. + if( size_error ) + { + FIXED_WIDE_INT(128) power_of_ten = + get_power_of_ten( destref.field->data.digits ); + tree mask = wide_int_to_tree(INT128, power_of_ten); + IF( gg_abs(value), ge_op, mask ) + { + gg_assign(gg_indirect(size_error), + gg_bitwise_or(gg_indirect(size_error), + integer_one_node)); + } + ELSE + { + gg_call(INT, + "__gg__int128_to_ascii_numeric_display", + gg_get_address_of(destref.field->var_decl_node), + get_location(destref), + value, + NULL_TREE); + } + ENDIF + } + else + { + gg_call(INT, + "__gg__int128_to_ascii_numeric_display", + gg_get_address_of(destref.field->var_decl_node), + get_location(destref), + value, + NULL_TREE); + } + moved = true; + } + } + + return moved; + } + static void copy_native_into_place(cbl_field_t *dest, tree dest_offset, @@ -3634,6 +3737,14 @@ move_helper(tree size_error, // This is an INT size_error); } + if( !moved ) + { + moved = mh_to_numeric_edited(destref, + sourceref, + rounded, + size_error); + } + if( !moved ) { SHOW_PARSE1 diff --git a/gcc/cobol/parse.y b/gcc/cobol/parse.y index 37f4ab6358f6..aa53e5f259f9 100644 --- a/gcc/cobol/parse.y +++ b/gcc/cobol/parse.y @@ -15090,7 +15090,6 @@ dialect_words_set( cbl_dialect_t dialect ) { typedef bool (current_tokens_t::*wordop_func_t)(const cbl_loc_t& loc, const cbl_name_t keyword, const cbl_name_t alias); - struct wordop_t { cbl_dialect_t dialect; wordop_func_t op; diff --git a/gcc/cobol/symbols.cc b/gcc/cobol/symbols.cc index f732a67287bb..5f6752ef7461 100644 --- a/gcc/cobol/symbols.cc +++ b/gcc/cobol/symbols.cc @@ -3093,7 +3093,8 @@ symbol_file( size_t program, const char name[] ) { key.program = symbol_at(key.program)->program; p = symbols.files.find(key); if( p != symbols.files.end() ) { - const cbl_file_t *f = cbl_file_of(symbol_at(p->second)); + // cppcheck-suppress constVariablePointer + auto f = cbl_file_of(symbol_at(p->second)); if( f->attr & global_e ) break; } } @@ -4793,88 +4794,120 @@ floating_char_in_string(const char *expanded_picture) { char * expand_picture(const char *picture) + { + // The caller should free() the return value. + assert(strlen(picture) < PICTURE_MAX); // guaranteed by picset() in scanner + size_t retval_length = PICTURE_MAX; + char *retval = static_cast(xmalloc(retval_length)); + + int ch; + int prior_ch = NULLCH; + char *d = retval; + const char *p = picture; + long repeat; + int currency_symbol = NULLCH; + + while( (ch = (*p++ & 0xFF) ) ) { - assert(strlen(picture) < PICTURE_MAX); // guaranteed by picset() in scanner - size_t retval_length = PICTURE_MAX; - char *retval = static_cast(xmalloc(retval_length)); - size_t index = 0; - - int ch; - int prior_ch = '\0'; - const char *p = picture; - - long repeat; + if( ch == ascii_oparen ) + { + // Pick up the number after the left parenthesis + char *endchar; + repeat = strtol(p, &endchar, 10); - int currency_symbol = currency_char_in_string(picture); + // We subtract one because we know that the character just before + // the parenthesis was already placed in retval + repeat -= 1; - while( (ch = (*p++ & 0xFF) ) ) + // Update p to the character after the right parenthesis + p = endchar + 1; + while(repeat--) { - if( ch == '(' ) - { - // Pick up the number after the left parenthesis - char *endchar; - repeat = strtol(p, &endchar, 10); + *d++ = prior_ch; + } + } + else + { + prior_ch = ch; + *d++ = ch; + } - // We subtract one because we know that the character just before - // the parenthesis was already placed in dest - repeat -= 1; + if( ! __gg__currency_signs[ch].empty() ) + { + // We are going to be mapping ch to a string in the final result: + prior_ch = ch; + currency_symbol = ch; + } + } - // Update p to the character after the right parenthesis - p = endchar + 1; + size_t dest_length = d-retval; - if( index + repeat >= retval_length ) - { - retval_length <<= 1; - retval = static_cast(xrealloc(retval, retval_length)); - } + // We have to take into account the possibility that the currency symbol + // mapping might be to a string of more than one character: - while(repeat--) - { - retval[index++] = prior_ch; - } - } - else - { - if( index >= retval_length ) - { - retval_length <<= 1; - retval = static_cast(xrealloc(retval, retval_length)); - } - retval[index++] = ch; - } - prior_ch = ch; - } - if( index >= retval_length ) + if( currency_symbol ) + { + size_t sign_length = __gg__currency_signs[currency_symbol].size(); + assert(0 < sign_length); + if( --sign_length ) + { + char *pcurrency = strchr(retval, currency_symbol); + assert(pcurrency); + memmove( pcurrency + sign_length, + pcurrency, + dest_length - (pcurrency-retval)); + for(size_t i=0; i(xrealloc(retval, retval_length)); + pcurrency[i] = ascii_B; } - retval[index++] = '\0'; - - size_t dest_length = strlen(retval); - - // We have to take into account the possibility that the currency symbol - // mapping might be to a string of more than one character: + dest_length += sign_length; + } + } + retval[dest_length++] = NULLCH; + + // To ease the workload on interpreting the PICTURE string at run time, we + // are going to convert everything we can to upper case. We also convert + // V to decimal point, for the same reason. Characters that might be + // currency symbols have to be left in their uppercase or lowercase original + // state. + for(size_t i=0; i int64_of() const { if( etc_type == value_e ) { auto r = TREE_REAL_CST_PTR( value_of() ); @@ -515,7 +515,7 @@ class cbl_field_data_t { double d; int n; int erc = sscanf(input.c_str(), "%lf%n", &d, &n); - + if( erc < 0 || size_t(n) != input.size() ) { dbgmsg("%s: error: could not interpret '%s' of '%s' as a number", __func__, initial + n, initial); @@ -546,7 +546,7 @@ class cbl_field_data_t { this->orig = orig_t( orig, all ); return this->orig.data; } - // Set the computed cce value. Do not impute capacity. + // Set the computed cce value. Do not impute capacity. void original( REAL_VALUE_TYPE value ) { orig = orig_t(value); } @@ -572,7 +572,7 @@ class cbl_field_data_t { case upsi_e: etc.upsi_mask = that.etc.upsi_mask; break; - } + } return *this; } }; @@ -673,7 +673,7 @@ bool __gg__encoding_iconv_valid( cbl_encoding_t encoding ); bool is_elementary( enum cbl_field_type_t type ); -// These were introduced to discourage the use of +// These were introduced to discourage the use of // current_encoding('A') and current_encoding('N') enum { @@ -705,7 +705,7 @@ struct cbl_field_t { friend bool cobol_national_encoding( const char name[] ); encodings_t alpha, national; const encodings_t possible_sources[2] = {}, *source = 0; - + default_encodings_t( const encodings_t& alpha, const std::vector& possible_sources ) : alpha(alpha) @@ -782,10 +782,10 @@ struct cbl_field_t { std::vector frag(len); std::transform(picture_fragment, picture_fragment + len, frag.begin(), ftoupper); - switch(frag[0]) { + switch(frag[0]) { case 'A': case 'X': case '9': return set(current_encoding(display_encoding_e)); - case 'N': case 'U': + case 'N': case 'U': if( std::all_of(frag.begin(), frag.end(), [first = frag[0]]( char ch ) { return first == ch; @@ -795,7 +795,7 @@ struct cbl_field_t { : UTF8_e; return set(enc); } - return false; // They all must be the same. + return false; // They all must be the same. } gcc_unreachable(); } @@ -842,7 +842,7 @@ struct cbl_field_t { cbl_field_t( cbl_field_type_t type, uint64_t attr, const cbl_field_data_t& data, - uint32_t level, const cbl_name_t name, + uint32_t level, const cbl_name_t name, const cbl_field_t::codeset_t& codeset ) : offset(0), type(type), usage(FldInvalid), attr(attr) , parent(0), our_index(0), level(level), codeset(codeset) @@ -911,7 +911,7 @@ struct cbl_field_t { data = that.data; codeset = that.codeset; - + if( ! (is_typedef || that.type == FldClass) ) { data.initial = NULL; data = build_zero_cst (float128_type_node); @@ -1071,8 +1071,8 @@ struct cbl_refer_t { refmod = that.refmod; return *this; } - - + + cbl_refer_t duplicate() const { return cbl_refer_t( field, subscripts, refmod ); } @@ -1111,7 +1111,7 @@ struct cbl_refer_t { /* * An element in the RPN stack for expression evaluation, either an operation - * or an operand. A NUL operator indicates an operand. + * or an operand. A NUL operator indicates an operand. */ struct rpn_t { char op; @@ -1398,7 +1398,7 @@ struct parameter_t { /* * Map symbol table index of procedure/function to formal parameters. - * Index may refer to definition or prototype. + * Index may refer to definition or prototype. */ typedef std::map> parameter_map; @@ -1562,7 +1562,7 @@ struct cbl_label_t { // for parser_op/parser_assign error tracking struct cbl_compute_error_t *compute_error; - + // for parse_xml processing: struct cbl_xml_parse_t *xml_parse; @@ -1650,7 +1650,7 @@ void symbol_temporary_location( const cbl_field_t *field, cbl_loc_t symbol_temporary_location( const cbl_field_t *field ); class temporaries_t { - friend void symbol_temporaries_free(); + friend void symbol_temporaries_free(); friend void symbol_temporary_location( const cbl_field_t *field, const cbl_loc_t& loc); friend cbl_loc_t symbol_temporary_location( const cbl_field_t *field ); @@ -1690,7 +1690,7 @@ class temporaries_t { return value < that.value; } bool terminated() const { - // Z strings include the NUL terminator. + // Z strings include the NUL terminator. return !is_verbatim && is_quoted && !value.empty() && '\0' == value.back(); } }; @@ -1702,7 +1702,7 @@ class temporaries_t { fieldmap_t used, freed; public: - cbl_field_t * literal( uint32_t len, const char value[], + cbl_field_t * literal( uint32_t len, const char value[], cbl_field_attr_t attr, cbl_encoding_t encoding ); cbl_field_t * reuse( cbl_field_type_t type ); cbl_field_t * acquire( cbl_field_type_t type, const cbl_name_t name = nullptr ); @@ -1851,7 +1851,7 @@ struct cbl_locale_t { /* * If SELECT name ASSIGN TO DEVICE is used, the index of the special name is - * assigned to cbl_file_t::device. The device itself never changes. + * assigned to cbl_file_t::device. The device itself never changes. */ struct cbl_special_name_t { int token; @@ -1868,7 +1868,7 @@ char * hex2numstr( const char text[] ); * * An alphabet may reference a Special-Names LOCALE, which defines an encoding * and a collation (perhaps by default). - * + * * During Special-Names parsing, an Alphabet may reference an as-yet undefined * LOCALE with an as-yet unknown encoding. As a placeholder it inserts a named, * undefined cbl_locale_t symbol, which the Alphabet references. If that @@ -1876,8 +1876,8 @@ char * hex2numstr( const char text[] ); * diagnostic at the end of Special-Names. * * For a custom alphabet of single-byte encoding, cbl_alphabet_t::collation_sequence - * holds the collation position of each encoded value. - * If 'A' sorts first (after LOW-VALUE), then collation_sequence['A'] == 1. + * holds the collation position of each encoded value. + * If 'A' sorts first (after LOW-VALUE), then collation_sequence['A'] == 1. * If the encoding is ASCII, then 'A' is 65 and collation_sequence[ 65] == 1. * If the encoding is EBCDIC CP1140, then 'A' is 193 and collation_sequence[193] == 1. */ @@ -2063,7 +2063,7 @@ struct cbl_file_key_t { memset(name, '\0', sizeof(name)); } - // Construct a key of length 1 having a single field. + // Construct a key of length 1 having a single field. explicit cbl_file_key_t( size_t field, bool unique = true ) : unique(unique) , leftmost(0) @@ -2151,7 +2151,7 @@ struct cbl_file_t { cbl_refer_t *nline, *footing, *top, *bottom; linage_t() : nline(nullptr), footing(nullptr), top(nullptr), bottom(nullptr) - {} + {} } linage; int line; cbl_name_t name; @@ -2177,7 +2177,7 @@ struct cbl_file_t { { memset(name, '\0', sizeof(name)); } - + bool varies() const { return varying_size.min != varying_size.max; } void assign( special_name_t device ) { this->device = special_index(device); } bool validate() const; @@ -2235,7 +2235,7 @@ struct symbol_elem_t { cbl_section_t section; symbol_elem_u() : field() {} } elem; - + symbol_elem_t() : type(SymField), program(0) {} explicit symbol_elem_t( symbol_type_t type, size_t program = 0 ) : type(type), program(program) @@ -2271,7 +2271,7 @@ struct symbol_elem_t { { elem.section = section; } - + protected: symbol_elem_t& copy_by_type( const symbol_elem_t& that ) { switch(type) { @@ -2430,7 +2430,7 @@ const cbl_label_t * symbol_program_local( const char called[] ); bool redefine_field( cbl_field_t *field ); -const cbl_field_t * +const cbl_field_t * symbol_unresolved_file_key( const cbl_file_t * file, const cbl_name_t key_field_name ); @@ -2507,7 +2507,7 @@ cbl_file_of( const symbol_elem_t *e ) { } // does the element part of a prototype ? -bool is_prototypical( size_t isym ); +bool is_prototypical( size_t isym ); static inline bool is_program( const symbol_elem_t& e ) { @@ -2647,15 +2647,15 @@ struct cbl_prog_hier_t { cbl_label_t label; program_label_t() : ordinal(0), label() {} // because std::copy_if: - // cppcheck-suppress noExplicitConstructor - program_label_t( const symbol_elem_t& e ) { + // cppcheck-suppress noExplicitConstructor + program_label_t( const symbol_elem_t& e ) { assert(is_program(e)); ordinal = symbol_index(&e); label = e.elem.label; } }; std::vector labels; - + cbl_prog_hier_t(); }; @@ -2864,7 +2864,7 @@ std::pair keyword_alias_add( const std::string& keyword, const std::string& alias ); int binary_integer_usage_of( const char name[] ); - + void tee_up_empty(); void tee_up_name( const cbl_loc_t& loc, const char name[] ); cbl_namelist_t teed_up_names(); @@ -3024,7 +3024,7 @@ int redefined_token( const cbl_name_t name, int token ); namespace cdf { extern bool any_cobol_words; } class current_tokens_t { class tokenset_t { - // token_names is initialized from a generated header file. + // token_names is initialized from a generated header file. std::vectortoken_names; // position indicates token value std::map tokens; // aliases std::set cobol_words; // COBOL-WORDS may affect a word only once. @@ -3091,7 +3091,7 @@ class current_tokens_t { dbgmsg("%s:%d: removed as a valid token name: %s", __func__, __LINE__, name); return fOK; } - + bool substitute( const cbl_loc_t& loc, const cbl_name_t extant, int token, const cbl_name_t name ) { return @@ -3164,7 +3164,7 @@ class current_tokens_t { error_msg(loc, "EQUATE: %qs is already an alias for %qs", alias, result.first.c_str()); return false; - } + } return tokens.equate(loc, token, alias); } bool undefine( const cbl_loc_t& loc, const cbl_name_t keyword ) { @@ -3184,7 +3184,7 @@ class current_tokens_t { error_msg(loc, "SUBSTITUTE: %qs is already an alias for %qs", alias, result.first.c_str()); return false; - } + } dbgmsg("%s:%d: %s (%d) will have alias %s", __func__, __LINE__, keyword, token, alias); return tokens.substitute(loc, keyword, token, alias); @@ -3298,9 +3298,12 @@ bool validate_numeric_edited(cbl_field_t *field); cbl_field_t *new_alphanumeric(const cbl_name_t name=nullptr, cbl_encoding_t encoding=no_encoding_e ); +char *expand_picture(const char *picture); + // ENABLE_HIJACKING allows for code generation to be "hijacked" when the // program-id is "dubner_h" or "hijack_h". See the mainline code in genapi.cc. + #define ENABLE_HIJACKING #endif diff --git a/gcc/cobol/util.cc b/gcc/cobol/util.cc index 6abd9091f75d..70122334090c 100644 --- a/gcc/cobol/util.cc +++ b/gcc/cobol/util.cc @@ -235,33 +235,33 @@ cdf_dictionary() { // elements permitted in a program or function prototype static const std::set prototype_elements { dspc_identification_div_e, - dspc_options_para_e, + dspc_options_para_e, ////_arithmetic_clause_e, disallowed - dspc_default_rounded_clause_e, - dspc_entry_convention_clause_e, - dspc_float_binary_clause_e, - dspc_float_decimal_clause_e, - dspc_initialize_clause_e, - dspc_intermediate_rounding_clause_e, + dspc_default_rounded_clause_e, + dspc_entry_convention_clause_e, + dspc_float_binary_clause_e, + dspc_float_decimal_clause_e, + dspc_initialize_clause_e, + dspc_intermediate_rounding_clause_e, dspc_environment_div_e, - dspc_configuration_section_e, - dspc_source_computer_paragraph_e, + dspc_configuration_section_e, + dspc_source_computer_paragraph_e, ////_object_computer_paragraph_e, disallowed - + // permitted special names clauses - dspc_special_names_paragraph_e, - dspc_alphabet_name_clause_e, - dspc_currency_sign_clause_e, - dspc_decimal_point_is_comma_clause_e, - dspc_locale_clause_e, - dspc_symbolic_characters_clause_e, + dspc_special_names_paragraph_e, + dspc_alphabet_name_clause_e, + dspc_currency_sign_clause_e, + dspc_decimal_point_is_comma_clause_e, + dspc_locale_clause_e, + dspc_symbolic_characters_clause_e, // no i-o section, and we assume no repository paragraph dspc_data_div_e, dspc_linkage_section_e, - + dspc_procedure_div_e, // only header is allowed dspc_procedure_header_e, }; @@ -270,7 +270,7 @@ bool cbl_prototype_ok( const cbl_loc_t& loc, size_t iprog, dspc_t clause ) { bool prototyping = cbl_label_of(symbol_at(iprog))->prototype; if( prototyping && 0 == prototype_elements.count(clause) ) { - error_msg( loc, "syntax not allowed for PROTOTYPE" ); + error_msg( loc, "syntax not allowed for PROTOTYPE" ); return false; } return true; @@ -333,7 +333,7 @@ cdf_file( size_t program, const cbl_name_t name ) { return cbl_file_of(e); } return nullptr; -} +} size_t cdf_file_index( const cbl_file_t *file ) { @@ -545,7 +545,7 @@ static char regexmsg[80]; static int named_constant( const cbl_name_t name ) { int output = -1; - + auto e = symbol_field( current_program_index(), 0, name ); if( e && e->type == SymField ) { auto f = cbl_field_of(e); @@ -583,7 +583,7 @@ repeat_count(const char picture[]) if( (count = named_constant(name)) < 0 ) { error_msg(yylloc, "not a positive integer constant: %qs: %d", name, count); } - } + } } if( n == 2 && 0 <= count ) { @@ -1620,7 +1620,7 @@ cbl_field_t::encode_numeric( const char input[], cbl_loc_t loc ) { // The final value will have data.digits + l_rdigits decimal // places. Let's scale rvalue to that range, taking into // account that we already have l_rdigits of those places. - tester *= + tester *= get_power_of_ten(data.digits + data.rdigits - l_rdigits); // In the case of PPP9999, tester needs to be between 1 and @@ -1925,14 +1925,23 @@ cbl_field_t::encode_numeric( const char input[], cbl_loc_t loc ) { } else { - digits_from_int128(ach, this, char_capacity(), value, l_rdigits); + digits_from_int128(ach, + this, + data.digits, + value, + l_rdigits); // __gg__string_to_numeric_edited operates in ASCII space: + char *expanded = expand_picture(data.picture); + // By the time you read this, this next statement ought to be + // obsolete. See RT issue 3682. + expanded[char_capacity()] = '\0'; __gg__string_to_numeric_edited( reinterpret_cast(retval), ach, data.rdigits, negative, - data.picture); + expanded); + free(expanded); // So now we convert it to the target encoding: size_t nbytes; const char *converted = __gg__iconverter(DEFAULT_SOURCE_ENCODING, @@ -2099,17 +2108,17 @@ cbl_field_t::report_invalid_initial_value(const cbl_loc_t& loc) const { /* * This is overspecific: It catches numeric literal VALUE for all_alpha_e\ * only. - * The general error is: + * The general error is: * - alphanumeric type * - data.initial is all spaces (based on PICTURE) * - data.original() is numeric or data.etc_type == value_e * - quoted_e clear, of course - * + * * This happens because VALUE was captured as a cce and stored in * data.original for encode_numeric. But encode_numeric was never called * because it's not a numeric field. * - * It is also insufficient. It does not deal with VALUE LENGTH OF. + * It is also insufficient. It does not deal with VALUE LENGTH OF. */ if( is_alpha_only ) { charmap_t *charmap = __gg__get_charmap(codeset.encoding); @@ -2124,13 +2133,13 @@ cbl_field_t::report_invalid_initial_value(const cbl_loc_t& loc) const { } } } - + if( ! is_alpha_only ) { error_msg(loc, "alpha-only %s VALUE '%s' contains non-alphabetic data", name, fig == zero_value_e? cbl_figconst_str(fig) : orig); - + auto pend = orig + strlen(orig); - auto p = std::find_if( orig, pend, + auto p = std::find_if( orig, pend, []( char ch ) { return ! ISALPHA(ch); } ); dbgmsg("%zu nonalpha '%.*s'", pend - p, int(pend - p), p); } @@ -2329,10 +2338,10 @@ valid_move( const cbl_refer_t& tgt_ref, const cbl_refer_t& src_ref ) /* * 8.4.3.3.3 Syntax rules - * A refmod may apply to: + * A refmod may apply to: * "a numeric data item of usage display or national that is not subordinate * to a strongly-typed group item," - * + * * 8.4.3.3.4 General rules * * "If the data item referenced by identifier-1 is explicitly or implicitly @@ -2662,12 +2671,12 @@ namespace match_proc { }; void error(const cbl_loc_t& loc, const tgt_t&tgt, - const found_t& found) const + const found_t& found) const { const char *clause = tgt == tgts.first? "" : "THRU "; assert( 1 != found.n ); const char *status = found.n == 0? "procedure not found" : "ambiguous reference"; - + error_msg(loc, "%s: PERFORM %s%s", status, clause, tgt.name.c_str()); } }; @@ -2818,7 +2827,7 @@ namespace match_proc { if( yydebug && 1 < n ) { for( const auto& para : matched ) { fprintf(stderr, "procedures_t::find:%d: ambig: %s of #%lu, %s\n", __LINE__, - para.name.c_str(), (unsigned long)para.parent, + para.name.c_str(), (unsigned long)para.parent, para.parent_name().c_str()); } } @@ -2836,7 +2845,7 @@ namespace match_proc { static bool match_any_paragraph( const para_t& para, const stmt_t::tgt_t& tgt ) { - assert( tgt.qual.empty() ); + assert( tgt.qual.empty() ); return para.name == tgt.name; } static bool match( const para_t& para, @@ -2845,7 +2854,7 @@ namespace match_proc { if( tgt.qual.empty() ) { return para.parent_name() == tgt.name || para.name == tgt.name; - } + } return para.name == tgt.name && para.parent_name() == tgt.qual; } @@ -2920,7 +2929,7 @@ namespace match_proc { } return nerr == 0; } - + void statement_add() { stmts.push_back(prototype); prototype = stmt_t(); @@ -3456,7 +3465,7 @@ bool cobol_filename( const char *name, ino_t inode ) { assert(inode != 0); } } - + linemap_add(line_table, LC_ENTER, sysp, name, 1); input_filename_vestige = name; bool pushed = input_filenames.push( input_file_t(name, inode, 1) ); @@ -3559,7 +3568,7 @@ gcc_location_set( const cbl_loc_t& loc ) { finish_line = linemap_line_start( line_table, loc.last_line, 80 ), token_finish = linemap_position_for_column( line_table, loc.last_column); token_location = make_location (token_start, token_start, token_finish); - + if( loc.first_line > first_line_minus_1 ) { // In order for GDB-COBOL to be able to step through COBOL code properly, // it is sometimes necessary for the code at the beginning of a COBOL @@ -3572,7 +3581,7 @@ gcc_location_set( const cbl_loc_t& loc ) { token_location_minus_1 = loc_m_1; loc_m_1 = token_location; } - + location_dump(__func__, __LINE__, "parser", loc); } @@ -3863,7 +3872,7 @@ parse_file( const char filename[] ) #endif parser_leave_file(); - + fclose (yyin); if( erc ) { diff --git a/gcc/testsuite/cobol.dg/group2/PR126612_-_Ignore_TRACE_-_gnu.cob b/gcc/testsuite/cobol.dg/group2/PR126612_-_Ignore_TRACE_-_gnu.cob new file mode 100644 index 000000000000..55130367fa9c --- /dev/null +++ b/gcc/testsuite/cobol.dg/group2/PR126612_-_Ignore_TRACE_-_gnu.cob @@ -0,0 +1,15 @@ + *> Do not edit this generated file. See README.txt + *> { dg-do run } + *> { dg-options "-dialect gnu" } + + identification division. + program-id. prog. + procedure division. + READY TRACE. + para-1. + DISPLAY "OK" NO ADVANCING. + RESET TRACE. + para-2. + DISPLAY "OK" NO ADVANCING. + GOBACK. + diff --git a/gcc/testsuite/cobol.dg/group2/PR126612_-_Ignore_TRACE_-_ibm.cob b/gcc/testsuite/cobol.dg/group2/PR126612_-_Ignore_TRACE_-_ibm.cob new file mode 100644 index 000000000000..d7e25d2c2565 --- /dev/null +++ b/gcc/testsuite/cobol.dg/group2/PR126612_-_Ignore_TRACE_-_ibm.cob @@ -0,0 +1,15 @@ + *> Do not edit this generated file. See README.txt + *> { dg-do run } + *> { dg-options "-dialect ibm" } + + identification division. + program-id. prog. + procedure division. + READY TRACE. + para-1. + DISPLAY "OK" NO ADVANCING. + RESET TRACE. + para-2. + DISPLAY "OK" NO ADVANCING. + GOBACK. + diff --git a/gcc/testsuite/cobol.dg/group2/PR126612_-_Ignore_TRACE_-_iso.cob b/gcc/testsuite/cobol.dg/group2/PR126612_-_Ignore_TRACE_-_iso.cob new file mode 100644 index 000000000000..298566180ff6 --- /dev/null +++ b/gcc/testsuite/cobol.dg/group2/PR126612_-_Ignore_TRACE_-_iso.cob @@ -0,0 +1,15 @@ + *> Do not edit this generated file. See README.txt + *> { dg-do run } + *> { dg-options "-dialect iso" } + + identification division. + program-id. prog. + procedure division. + READY TRACE. + para-1. + DISPLAY "OK" NO ADVANCING. + RESET TRACE. + para-2. + DISPLAY "OK" NO ADVANCING. + GOBACK. + diff --git a/gcc/testsuite/cobol.dg/group2/PR126612_-_Ignore_TRACE_-_mf.cob b/gcc/testsuite/cobol.dg/group2/PR126612_-_Ignore_TRACE_-_mf.cob new file mode 100644 index 000000000000..2f88d39f1bc7 --- /dev/null +++ b/gcc/testsuite/cobol.dg/group2/PR126612_-_Ignore_TRACE_-_mf.cob @@ -0,0 +1,15 @@ + *> Do not edit this generated file. See README.txt + *> { dg-do run } + *> { dg-options "-dialect mf" } + + identification division. + program-id. prog. + procedure division. + READY TRACE. + para-1. + DISPLAY "OK" NO ADVANCING. + RESET TRACE. + para-2. + DISPLAY "OK" NO ADVANCING. + GOBACK. + diff --git a/gcc/testsuite/cobol.dg/group2/RT3611_-_BY_CONTENT_LENGTH_OF.cob b/gcc/testsuite/cobol.dg/group2/RT3611_-_BY_CONTENT_LENGTH_OF.cob new file mode 100644 index 000000000000..3aec619f30e8 --- /dev/null +++ b/gcc/testsuite/cobol.dg/group2/RT3611_-_BY_CONTENT_LENGTH_OF.cob @@ -0,0 +1,23 @@ + *> Do not edit this generated file. See README.txt + *> { dg-do compile } + *> { dg-options "-dialect ibm" } +[ + IDENTIFICATION DIVISION. + PROGRAM-ID. prog. + + DATA DIVISION. + WORKING-STORAGE SECTION. + 01 WS-NAME PIC X(30). + + PROCEDURE DIVISION. + CALL "TEST01" + USING BY CONTENT LENGTH OF WS-NAME + GOBACK. + END PROGRAM prog. + IDENTIFICATION DIVISION. + PROGRAM-ID. TEST01. + PROCEDURE DIVISION. + DISPLAY "OK" NO ADVANCING. + GOBACK. + END PROGRAM TEST01. +] diff --git a/gcc/testsuite/cobol.dg/group2/__define__text_.cob b/gcc/testsuite/cobol.dg/group2/__define__text_.cob new file mode 100644 index 000000000000..230af5a531df --- /dev/null +++ b/gcc/testsuite/cobol.dg/group2/__define__text_.cob @@ -0,0 +1,23 @@ + *> Do not edit this generated file. See README.txt + *> { dg-do run } + *> { dg-options "-dialect mf" } + *> { dg-output-file "group2/__define__text_.out" } + identification division. + program-id. prog1. + >> define defined_text as "Defined text" + procedure division. + display defined_text + call "prog2" using defined_text + goback. + end program prog1. + + identification division. + program-id. prog2. + data division. + linkage section. + 01 display_text pic X ANY LENGTH. + procedure division using display_text. + display display_text + goback. + end program prog2. + diff --git a/gcc/testsuite/cobol.dg/group2/__define__text_.out b/gcc/testsuite/cobol.dg/group2/__define__text_.out new file mode 100644 index 000000000000..1b11a3706044 --- /dev/null +++ b/gcc/testsuite/cobol.dg/group2/__define__text_.out @@ -0,0 +1,3 @@ +Defined text +Defined text + diff --git a/gcc/testsuite/cobol.dg/group2/customer_bug_Heuristic_Fail.cob b/gcc/testsuite/cobol.dg/group2/customer_bug_Heuristic_Fail.cob new file mode 100644 index 000000000000..6e66c69be2d5 --- /dev/null +++ b/gcc/testsuite/cobol.dg/group2/customer_bug_Heuristic_Fail.cob @@ -0,0 +1,10 @@ + *> Do not edit this generated file. See README.txt + *> { dg-do run } + *> { dg-output-file "group2/customer_bug_Heuristic_Fail.out" } +00001 *TITLE 'MRS FIELDS ROLLUP DATA PROGRAM.' 06/07/23 +00002 IDENTIFICATION DIVISION. GD25000A +00003 PROGRAM-ID. prog. LV246 +00005 PROCEDURE DIVISION. +00006 DISPLAY "OK" NO ADVANCING. +00007 STOP RUN. + diff --git a/gcc/testsuite/cobol.dg/group2/customer_bug_Heuristic_Fail.out b/gcc/testsuite/cobol.dg/group2/customer_bug_Heuristic_Fail.out new file mode 100644 index 000000000000..d86bac9de59a --- /dev/null +++ b/gcc/testsuite/cobol.dg/group2/customer_bug_Heuristic_Fail.out @@ -0,0 +1 @@ +OK diff --git a/libgcobol/gmath.cc b/libgcobol/gmath.cc index baa1214bb842..218d527735a5 100644 --- a/libgcobol/gmath.cc +++ b/libgcobol/gmath.cc @@ -2167,7 +2167,7 @@ __gg__int128_to_int128_rounded( cbl_round_t rounded, case prohibited_e: { __int128 fpart = value % factor; - if( fpart != 0 ) + if( fpart != 0 && compute_error) { *compute_error |= compute_error_truncate; } diff --git a/libgcobol/libgcobol.cc b/libgcobol/libgcobol.cc index d6a84efee2a0..7291c8fa296b 100644 --- a/libgcobol/libgcobol.cc +++ b/libgcobol/libgcobol.cc @@ -2138,12 +2138,11 @@ int128_to_field(cblc_field_t *var, ach[var->digits] = NULLCH; // Convert that string according to the PICTURE clause - size_error |= __gg__string_to_numeric_edited( - as_chars( location), - ach, - target_rdigits, - is_negative, - var->picture); + __gg__string_to_numeric_edited(as_chars(location), + ach, + target_rdigits, + is_negative, + var->picture); size_t outlength; const char *converted = __gg__iconverter( DEFAULT_SOURCE_ENCODING, @@ -2286,6 +2285,38 @@ int128_to_field(cblc_field_t *var, } } +extern "C" +int +__gg__int128_to_ascii_numeric_display(const cblc_field_t *var, + unsigned char *location, + __int128 value) + { + bool size_error = false; + if( value == 0 && (var->attr & blank_zero_e) ) + { + memset(location, ascii_space, var->capacity); + } + else + { + char ach[512]; + bool is_negative = value < 0; + + // At this point, value is scaled to the target's rdigits + size_error |= __gg__binary_to_string_ascii(ach, + var->digits, + value); + ach[var->digits] = NULLCH; + + // Convert that string according to the PICTURE clause + __gg__string_to_numeric_edited(as_chars(location), + ach, + var->rdigits, + is_negative, + var->picture); + } + return size_error; + } + #pragma GCC diagnostic ignored "-Wformat-overflow" static time_t diff --git a/libgcobol/valconv.cc b/libgcobol/valconv.cc index c601bbcc9b9b..21e89f437ddb 100644 --- a/libgcobol/valconv.cc +++ b/libgcobol/valconv.cc @@ -18,6 +18,7 @@ * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, @@ -59,15 +60,15 @@ #include "cobol-endian.h" #include "charmaps.h" #include "exceptl.h" -static char -TOUPPER(char ch) - { - if(ch >= 'a' && ch <= 'z' ) - { - return 'A' + ch - 'a'; - } - return ch; - } +////static char +////TOUPPER(char ch) +//// { +//// if(ch >= 'a' && ch <= 'z' ) +//// { +//// return 'A' + ch - 'a'; +//// } +//// return ch; +//// } #endif std::unordered_map __gg__alphabet_states; @@ -135,117 +136,11 @@ __gg__alphabet_create( cbl_encoding_t encoding, return; } -static int -expand_picture(char *dest, const char *picture) - { - // 'dest' must be of adequate length to hold the expanded picture string, - // including any extra characters due to a CURRENCY SIGN expansion. - - int ch; - int prior_ch = NULLCH; - char *d = dest; - const char *p = picture; - - long repeat; - - int currency_symbol = NULLCH; - - while( (ch = (*p++ & 0xFF) ) ) - { - if( ch == ascii_oparen ) - { - // Pick up the number after the left parenthesis - char *endchar; - repeat = strtol(p, &endchar, 10); - - // We subtract one because we know that the character just before - // the parenthesis was already placed in dest - repeat -= 1; - - // Update p to the character after the right parenthesis - p = endchar + 1; - while(repeat--) - { - *d++ = prior_ch; - } - } - else - { - prior_ch = ch; - *d++ = ch; - } - - if( ! __gg__currency_signs[ch].empty() ) - { - // We are going to be mapping ch to a string in the final result: - prior_ch = ch; - currency_symbol = ch; - } - } - - size_t dest_length = d-dest; - - // We have to take into account the possibility that the currency symbol - // mapping might be to a string of more than one character: - - if( currency_symbol ) - { - size_t sign_length = __gg__currency_signs[currency_symbol].size(); - assert(0 < sign_length); - if( --sign_length ) - { - char *pcurrency = strchr(dest, currency_symbol); - assert(pcurrency); - memmove( pcurrency + sign_length, - pcurrency, - dest_length - (pcurrency-dest)); - for(size_t i=0; i= 2 ) - { - // It's a positive number, so we might have to get rid of a CR or DB: - char ch1 = TOUPPER((unsigned char)dest[dlength-2]); - char ch2 = TOUPPER((unsigned char)dest[dlength-1]); - if( (ch1 == ascii_D && ch2 == ascii_B) - || (ch1 == ascii_C && ch2 == ascii_R) ) - { - if( !is_negative ) - { - // Per the spec, because the number is positive, those two - // characters become blank: - dest[dlength-2] = ascii_space; - dest[dlength-1] = ascii_space; - } - // Trim the dlength by two to reflect those two positions at the - // right edge, and from here on out we can ignore them. - dlength -= 2; - } - } + We accomplish through two passes of the data. The first pass scans the + 'dest' and replaces any possible digit position with the actual data from + the 'source'. While doing that, it finds the left/right limits for + possible floating insertion and possible zero suppression. + + During a second pass, the limits of floating insertion and zero + suppression are applied. */ // We need to know if we have a currency picture symbol in this string: // This is the currency character in the PICTURE - unsigned char currency_picture = NULLCH; - const char *currency_sign = NULL; // This is the text we output when + unsigned char currency_char = NULLCH; + const char *currency_text = NULL; // This is the text we output when // // encountering the currency_picture // // character - // Note that the currency_picture can be upper- or lower-case, which is why - // we can't treat dest[] to toupper. That makes me sad, because I have - // to do some tests for upper- and lower-case Z, and so on. - for(int i=0; i non_native_zeros ) - { - non_native_zeros = nines; - nonzero_index = slength - non_native_zeros; - if( nonzero_index < 0 ) - { - nonzero_index = 0; - } - } - // nonzero_index is now the location of the leftmost digit that we will - // output as a digit. Everything to its left is a leading zero, and might - // get replaced with a floating replacement. + int leftmost_asterisk = -1; + int rightmost_asterisk = -1; + int zeroed_asterisk = 0; - // We are now in a position to address specific situations: + int leftmost_z = -1; + int rightmost_z = -1; + int zeroed_z = 0; - // This is the case of leading zero suppression - if( (strchr(picture, ascii_Z)) || (strchr(picture, ascii_z)) ) - { - int leftmost_indexA = Lindex(dest, dlength, ascii_Z); - int leftmost_indexB = Lindex(dest, dlength, ascii_z); - if( leftmost_indexA == -1 ) - { - leftmost_indexA = leftmost_indexB; - } - if( leftmost_indexB == -1 ) - { - leftmost_indexB = leftmost_indexA; - } + int leftmost_nonzero = -1; - int rightmost_indexA = Lindex(dest, dlength, ascii_Z); - int rightmost_indexB = Lindex(dest, dlength, ascii_z); - if( rightmost_indexA == -1 ) - { - rightmost_indexA = leftmost_indexB; - } - if( rightmost_indexB == -1 ) + int decimal_position = -1; + + // This is the first pass. Because the currency + int index_s = 0; + for(int i=0; i=0) + case ascii_minus: + case ascii_plus: { - // Pick up the destination character that we will replace: - char ch_d = dest[index_d]; - - if( ch_d == currency_picture ) + if( is_negative ) { - // We are going to lay down the currency string. Keep - // in mind that our caller nicely left room for it - size_t sign_len = strlen(currency_sign); - while(sign_len > 0) - { - dest[index_d--] = currency_sign[--sign_len]; - } - continue; - } - - char ch_s; - if( index_s < 0 ) - { - // I don't think this can happen, but just in case: - ch_s = ascii_zero; + sign_char = ascii_minus; } else { - ch_s = source[index_s]; - } - - if( index_s <= nonzero_index && !reworked_string) - { - reworked_string = true; - // index_s is the location of the leftmost non-zero - // digit. - - // So, we are about to enter the world of leading - // zeroes. - - // The specification says, at this point, that - // all B 0 / , and . inside the floating string - // are to be considered part of the floating string: - - // So, we edit dest[] to make that true: - int rlim = rightmost_index > index_d ? index_d : rightmost_index; - - for(int i=leftmost_index; i= decimal_point_index ) + if( leftmost_sign == -1 ) { - // We are to the right of the decimal point, and so we - // don't do any replacement. We either insert a character, - // or we replace with a digit: - switch(ch_d) - { - // We are to the right of the decimal point, so Z is - // a character position - case ascii_z: - case ascii_Z: - case ascii_nine: - index_s -= 1; - break; - case ascii_b: - case ascii_B: - ch_s = ascii_space; - break; - case ascii_plus: - if( !is_negative ) - { - ch_s = ascii_plus; - } - else - { - ch_s = ascii_minus; - } - break; - case ascii_minus: - if( !is_negative ) - { - ch_s = ascii_space; - } - else - { - ch_s = ascii_minus; - } - break; - case ascii_P: - case ascii_p: - // P-scaling has been handled by changing the value - // and the number of rdigits, so these characters - // are ignored here: - break; - default: - // Valid possibilities are 0 / , - // Just leave them be - ch_s = ch_d; - break; - } - dest[index_d] = ch_s; + leftmost_sign = i; } else { - // We are to the left of the decimal point: - if( ch_d == __gg__decimal_point ) + // This is not the leftmost sign character, so it is where a digit + // goes. + dest[i] = source[index_s++]; + if( leftmost_nonzero == -1 && dest[i] != ascii_zero ) { - // Do this assignment to handle the situation where - // period and comma have been swapped. It's necessary - // because the case statement can't take a variable - ch_s = __gg__decimal_point; + leftmost_nonzero = i; } - else - { - switch(ch_d) - { - case ascii_nine: - index_s -= 1; - break; - case ascii_v: - case ascii_V: - ch_s = __gg__decimal_point; - break; - case ascii_plus: - if( !is_negative ) - { - ch_s = ascii_plus; - } - else - { - ch_s = ascii_minus; - } - break; - case ascii_minus: - if( !is_negative ) - { - ch_s = ascii_space; - } - else - { - ch_s = ascii_minus; - } - break; - - case ascii_z: - case ascii_Z: - if( index_s < nonzero_index) - { - // We are in the leading zeroes, so they are - // replaced with a space - ch_s = ascii_space; - } - index_s -= 1; - break; - - case ascii_b: - case ascii_B: - ch_s = ascii_space; - break; - - default: - // Valid possibilities are 0 / , which - // at this point all get replaced with spaces: - if( index_s < nonzero_index) - { - // We are in the leading zeroes, so they are - // replaced with a space - ch_s = ascii_space; - } - else - { - // We still have digits to send out, so the output - // is a copy of the PICTURE string - ch_s = ch_d; - } - } - } - dest[index_d] = ch_s; } - - index_d -= 1; + rightmost_sign = i+1; + break; } - } - } - - // This is the case of leading zero replacement: - else if( strchr(picture, ascii_asterisk) ) - { - int leftmost_index = Lindex(dest, dlength, ascii_asterisk); - int rightmost_index = Rindex(dest, dlength, ascii_asterisk); - // We are doing replacement editing: leading zeroes get replaced with - // asterisks, except that any decimal point is put into place: - if( is_zero && nines == 0 ) - { - // We need to re-initialize dest, because of the possibility - // of a CR/DB at the end of the line - dlength = expand_picture(dest, picture); - for(int i=0; i=0) - { - // Pick up the destination character that we will replace: - char ch_d = dest[index_d]; + case ascii_slash: + case ascii_d: + case ascii_D: + case ascii_b: + case ascii_c: + case ascii_C: + case ascii_r: + case ascii_R: + case ascii_0: + // These are left where they are + break; - if( ch_d == currency_picture ) + case ascii_B: + // This needs some special attention, because a DB at the end is not + // the same as a B on its own at the end. + if( i < length_d-1 ) { - // We are going to lay down the currency string. Keep - // in mind that our caller nicely left room for it - size_t sign_len = strlen(currency_sign); - while(sign_len > 0) + dest[i] = ascii_space; + } + else if( length_d >= 1 ) + { + if( dest[i-1] != ascii_D && dest[i-1] != ascii_d ) { - dest[index_d--] = currency_sign[--sign_len]; + // This is an isolated B at the very end of the string + dest[i] = ascii_space; } - continue; + // Otherwise, that final B is part of a DB, and is left alone. } + break; - char ch_s; - if( index_s < 0 ) + case ascii_9: + // These are positions that hold digits + dest[i] = source[index_s++]; + if( leftmost_nonzero == -1 && dest[i] != ascii_zero ) { - // I don't think this can happen, but just in case: - ch_s = ascii_zero; + leftmost_nonzero = i; } - else + break; + + case ascii_asterisk: + // These are positions that hold digits + if( leftmost_asterisk == -1 ) { - ch_s = source[index_s]; + leftmost_asterisk = i; } + rightmost_asterisk = i+1; - if( index_s <= nonzero_index && !reworked_string) + dest[i] = source[index_s++]; + if( dest[i] == ascii_zero ) { - reworked_string = true; - // index_s is the location of the leftmost non-zero - // digit. - - // So, we are about to enter the world of leading - // zeroes. - - // The specification says, at this point, that - // all B 0 / , and . inside the floating string - // are to be considered part of the floating string: - - // So, we edit dest[] to make that true: - int rlim = rightmost_index > index_d ? index_d : rightmost_index; - - for(int i=leftmost_index; i= decimal_point_index ) + dest[i] = source[index_s++]; + if( dest[i] == ascii_zero ) { - // We are to the right of the decimal point, and so we - // don't do any replacement. We either insert a character, - // or we replace with a digit: - switch(ch_d) - { - // We are to the right of the decimal point, so asterisk - // is a a character position - case ascii_asterisk: - case ascii_nine: - index_s -= 1; - break; - case ascii_b: - case ascii_B: - ch_s = ascii_space; - break; - case ascii_plus: - if( !is_negative ) - { - ch_s = ascii_plus; - } - else - { - ch_s = ascii_minus; - } - break; - case ascii_minus: - if( !is_negative ) - { - ch_s = ascii_space; - } - else - { - ch_s = ascii_minus; - } - break; - default: - // Valid possibilities are 0 / , - // Just leave them be - ch_s = ch_d; - break; - } - dest[index_d] = ch_s; + zeroed_z += 1; } else { - // We are to the left of the decimal point: - if( ch_d == __gg__decimal_point ) - { - ch_s = __gg__decimal_point; - } - else + if( leftmost_nonzero == -1 ) { - switch(ch_d) - { - case ascii_nine: - index_s -= 1; - break; - case ascii_v: - case ascii_V: - ch_s = __gg__decimal_point; - break; - case ascii_plus: - if( !is_negative ) - { - ch_s = ascii_plus; - } - else - { - ch_s = ascii_minus; - } - break; - case ascii_minus: - if( !is_negative ) - { - ch_s = ascii_space; - } - else - { - ch_s = ascii_minus; - } - break; - - case ascii_asterisk: - if( index_s < nonzero_index) - { - // We are in the leading zeroes, so they are - // replaced with an asterisk - ch_s = ascii_asterisk; - } - index_s -= 1; - break; - - case ascii_b: - case ascii_B: - ch_s = ascii_space; - break; - - default: - // Valid possibilities are 0 / , which - // at this point all get replaced with spaces: - if( index_s < nonzero_index) - { - // We are in the leading zeroes, so they are - // replaced with our suppression character - ch_s = ascii_asterisk; - } - else - { - // We still have digits to send out, so the output - // is a copy of the PICTURE string - ch_s = ch_d; - } - } + leftmost_nonzero = i; } - dest[index_d] = ch_s; } + break; - index_d -= 1; - } + default: + abort(); } } - else - { - // At this point, we check for a floating $$, ++, or -- - unsigned char floating_character = 0; - int leftmost_index; - int rightmost_index; - - leftmost_index = Lindex(dest, dlength, ascii_plus); - rightmost_index = Rindex(dest, dlength, ascii_plus); - if( rightmost_index > leftmost_index) + // Do currency replacement + if( leftmost_currency >= 0 ) + { + if( leftmost_currency == rightmost_currency-1 ) { - floating_character = ascii_plus; - goto got_float; + // This is a solo currency symbol + memcpy(dest + leftmost_currency - (strlen(currency_text)-1), + currency_text, + strlen(currency_text)); } - - leftmost_index = Lindex(dest, dlength, ascii_minus); - rightmost_index = Rindex(dest, dlength, ascii_minus); - if( rightmost_index > leftmost_index) + else { - floating_character = ascii_minus; - goto got_float; + // This is a floating currency symbol. We need to start at + // leftmost_currency, and walk to the lesser of rightmost_currency and + // leftmost_nonzero. We blank every character we encounter. + int left = leftmost_currency; + int right; + if( leftmost_nonzero >= 0 ) + { + right = std::min(leftmost_nonzero, rightmost_currency); + if( decimal_position >= 0 ) + { + right = std::min(right, decimal_position); + } + } + else + { + right = rightmost_currency; + } + // blank out that range + memset(dest+left, ascii_space, right-left); + + // To handle situations like PIC $$$,999, where the currency sign has to + // overwrite the comma, we walk from here until we hit the column just to + // the left of a digit + while( right < length_d ) + { + if( (dest[right] >= ascii_zero && dest[right] <= ascii_nine) + || right == decimal_position ) + { + break; + } + dest[right] = ascii_space; + right += 1; + } + if( right < length_d ) + { + right -= 1; + memcpy(dest + right - (strlen(currency_text)-1), + currency_text, + strlen(currency_text)); + } } + } - leftmost_index = Lindex(dest, dlength, currency_picture); - rightmost_index = Rindex(dest, dlength, currency_picture); - if( rightmost_index > leftmost_index) + // Do sign replacement + if( leftmost_sign >= 0 ) + { + if( leftmost_sign == rightmost_sign-1 ) { - floating_character = currency_picture; - goto got_float; + // This is a solo sign symbol + dest[leftmost_sign] = sign_char; } -got_float: - - if( floating_character ) + else { - if( is_zero && nines == 0 ) + // This is a floating sign symbol. We need to start at + // leftmost_sign, and walk to the lesser of rightmost_sign and + // leftmost_nonzero. We blank every character we encounter. + int left = leftmost_sign; + int right; + if( leftmost_nonzero >= 0 ) { - // Special case: - memset(dest, ascii_space, dlength); + right = std::min(leftmost_nonzero, rightmost_sign); + if( decimal_position >= 0 ) + { + right = std::min(right, decimal_position); + } } else { - const char *decimal_location = strchr(dest, __gg__decimal_point); - if( !decimal_location ) - { - decimal_location = strchr(dest, ascii_v); - } - if( !decimal_location ) - { - decimal_location = strchr(dest, ascii_V); - } - if( !decimal_location ) - { - decimal_location = dest + dlength; - } - int decimal_index = (int)(decimal_location - dest); + right = rightmost_sign; + } + // blank out that range + memset(dest+left, ascii_space, right-left); - if( rightmost_index > decimal_index ) + // To handle situations like PIC $$$,999, where the sign char has to + // overwrite the comma, we walk from here until we hit the column just to + // the left of a digit + while( right < length_d ) + { + if( (dest[right] >= ascii_zero && dest[right] <= ascii_nine) + || right == decimal_position ) { - rightmost_index = decimal_index -1; + break; } + dest[right] = ascii_space; + right += 1; + } + if( right < length_d ) + { + right -= 1; + dest[right] = sign_char; + } + } + } - int index_s = slength-1; // Index into source string of digits - int index_d = dlength-1; // Index into the destination - bool in_float_string = false; - bool reworked_string = false; - - while(index_d >=0) - { - // Pick up the destination character that we will replace: - unsigned char ch_d = dest[index_d]; - char ch_s = ascii_caret; // Flag this as being replaced + // Do '*' zero suppression + if( leftmost_asterisk >= 0 ) + { + // This is a floating zero suppression. - if( index_d == leftmost_index ) - { - // At this point ch_d is the leftmost floating_character, - // which means it *must* go into the output stream, - // and that means we are truncating any remaining input. - - // Setting nonzero_index to be one character to the right - // means that the following logic will think that any - // source characters from here on out are zeroes - nonzero_index = index_s+1; - } + int left = leftmost_asterisk; + int right; + if( leftmost_nonzero >= 0 ) + { + // The value being formatted is non-zero, so make sure 'right' is no more + // than the decimal position. + right = std::min(leftmost_nonzero, rightmost_asterisk); + if( decimal_position >= 0 && decimal_position > leftmost_asterisk ) + { + right = std::min(right, decimal_position); + } + } + else + { + // The value being formatted is zero + if( zeroed_asterisk == length_s ) + { + // Every numeric position was a zero on asterisk, so the whole thing + // is starred. + left = 0; + right = length_d; + } + else + { + right = rightmost_asterisk; + } + } + // blank out that range + memset(dest+left, ascii_asterisk, right-left); - if( ch_d != floating_character && ch_d == currency_picture ) - { - // This is a non-floating currency_picture characger - // We are going to lay down the currency string. Keep - // in mind that our caller nicely left room for it - size_t sign_len = strlen(currency_sign); - while(sign_len > 0) - { - dest[index_d--] = currency_sign[--sign_len]; - } - continue; - } - if( ch_d != floating_character && ch_d == ascii_plus ) - { - // This is a non-floating plus sign - if( !is_negative ) - { - ch_s = ascii_plus; - } - else - { - ch_s = ascii_minus; - } - dest[index_d--] = ch_s; - continue; - } - if( ch_d != floating_character && ch_d == ascii_minus ) - { - // This is a non-floating minus sign - if( !is_negative ) - { - ch_s = ascii_space; - } - else - { - ch_s = ascii_minus; - } - dest[index_d--] = ch_s; - continue; - } + // To handle situations like PIC ZZZ,999, where the suppression char has to + // overwrite the comma, we walk from here until we hit the column just to + // the left of a digit + while( right < length_d ) + { + if( (dest[right] >= ascii_zero && dest[right] <= ascii_nine) + || right == decimal_position ) + { + break; + } + dest[right] = ascii_asterisk; + right += 1; + } + // One final fillip: The nature of '*' zero suppression is that the + // decimal point is always visible. Sending zero to ***,***.** results in + // "*******.***" + if( decimal_position >= 0 ) + { + dest[decimal_position] = __gg__decimal_point; + } + } - if( index_s < 0 ) - { - // I don't think this can happen, but just in case: - ch_s = ascii_zero; - } - else - { - ch_s = source[index_s]; - if( index_s <= nonzero_index && !reworked_string) - { - reworked_string = true; - // index_s is the location of the leftmost non-zero - // digit. - - // So, we are about to enter the world of leading - // zeroes. - - // The specification says, at this point, that - // all B 0 / , and . inside the floating string - // are to be considered part of the floating string: - - // So, we edit dest[] to make that true: - int rlim = rightmost_index > index_d ? index_d : rightmost_index; - - for(int i=leftmost_index; i= decimal_point_index ) - { - // We are to the right of the decimal point, and so we - // don't do any replacement. We either insert a character, - // or we replace with a digit: - switch(ch_d) - { - case ascii_nine: - index_s -= 1; - break; - case ascii_b: - case ascii_B: - ch_s = ascii_space; - break; - default: - if( ch_d == floating_character ) - { - // We are laying down a digit - index_s -= 1; - } - else - { - // Valid possibilities are 0 / , - // Just leave them be - ch_s = ch_d; - } - break; - } - dest[index_d] = ch_s; - } - else - { - // We are to the left of the decimal point: - - if( ch_d == __gg__decimal_point ) - { - ch_s = __gg__decimal_point; - } - else if (ch_d == floating_character) - { - if( index_s < nonzero_index ) - { - // We are in the leading zeroes. - if( !in_float_string ) - { - in_float_string = true; - // We have arrived at the rightmost floating - // character in the leading zeroes - - if( floating_character == currency_picture ) - { - size_t sign_len = strlen(currency_sign); - while(sign_len > 0) - { - dest[index_d--] = currency_sign[--sign_len]; - } - continue; - } - if( floating_character == ascii_plus ) - { - if( !is_negative ) - { - ch_s = ascii_plus; - } - else - { - ch_s = ascii_minus; - } - dest[index_d--] = ch_s; - continue; - } - if( floating_character == ascii_minus ) - { - if( !is_negative ) - { - ch_s = ascii_space; - } - else - { - ch_s = ascii_minus; - } - dest[index_d--] = ch_s; - continue; - } - } - else - { - // We are in the leading zeros and the - // floating character location is to our - // right. So, we put down a space: - dest[index_d--] = ascii_space; - continue; - } - } - else - { - // We hit a floating character, but we aren't - // yet in the leading zeroes - index_s -= 1; - dest[index_d--] = ch_s; - continue; - } - } - - if( ch_d == __gg__decimal_point) - { - ch_s = __gg__decimal_point; - } - else - { - switch(ch_d) - { - case ascii_nine: - index_s -= 1; - break; - case ascii_v: - case ascii_V: - ch_s = __gg__decimal_point; - break; - case ascii_b: - case ascii_B: - ch_s = ascii_space; - break; - - default: - // Valid possibilities are 0 / , which - // at this point all get replaced with spaces: - if( index_s < nonzero_index) - { - // We are in the leading zeroes, so they are - // replaced with our suppression character - ch_s = ascii_space; - } - else - { - // We still have digits to send out, so the output - // is a copy of the PICTURE string - ch_s = ch_d; - } - } - } - dest[index_d] = ch_s; - } + // Do 'Z' zero suppression + if( leftmost_z >= 0 ) + { + // This is a floating zero suppression. - index_d -= 1; - } + int left = leftmost_z; + int right; + if( leftmost_nonzero >= 0 ) + { + // The value being formatted is non-zero, so make sure 'right' is no more + // than the decimal position. + right = std::min(leftmost_nonzero, rightmost_z); + if( decimal_position >= 0 && decimal_position > leftmost_asterisk ) + { + right = std::min(right, decimal_position); } } else { - // Simple replacement editing - int index_s = slength-1; // Index into source string of digits - int index_d = dlength-1; // Index into the destination - - while(index_d >=0) + if( zeroed_z == length_s ) { - // Pick up the destination character that we will replace: - char ch_d = dest[index_d]; - - if( ch_d == currency_picture ) - { - // We are going to lay down the currency string. Keep - // in mind that our caller nicely left room for it - size_t sign_len = strlen(currency_sign); - while(sign_len > 0) - { - dest[index_d--] = currency_sign[--sign_len]; - } - continue; - } + // Every numeric position was a zero on asterisk, so the whole thing + // is blanked. + left = 0; + right = length_d; + } + else + { + right = rightmost_z; + } + } + // blank out that range + memset(dest+left, ascii_space, right-left); - char ch_s; - if( index_s < 0 ) - { - // I don't think this can happen, but just in case: - ch_s = ascii_zero; - } - else - { - ch_s = source[index_s]; - } - switch(ch_d) - { - // We are to the right of the decimal point, so Z is - // a character position - case ascii_nine: - index_s -= 1; - break; - case ascii_b: - case ascii_B: - ch_s = ascii_space; - break; - case ascii_plus: - if( !is_negative ) - { - ch_s = ascii_plus; - } - else - { - ch_s = ascii_minus; - } - break; - case ascii_minus: - if( !is_negative ) - { - ch_s = ascii_space; - } - else - { - ch_s = ascii_minus; - } - break; - default: - // Valid possibilities are 0 / , - // Just leave whatever is here alone - ch_s = ch_d; - break; - } - dest[index_d--] = ch_s; + // To handle situations like PIC ZZZ,999, where the suppression char has to + // overwrite the comma, we walk from here until we hit the column just to + // the left of a digit + while( right < length_d ) + { + if( (dest[right] >= ascii_zero && dest[right] <= ascii_nine) + || right == decimal_position ) + { + break; } + dest[right] = ascii_space; + right += 1; } } - bool retval = false; - return retval; + // Any final DB/CR needs to be addressed: + if( !is_negative + && length_d >= 2 + && ( dest[length_d-2] == ascii_D + || dest[length_d-2] == ascii_d + || dest[length_d-2] == ascii_C + || dest[length_d-2] == ascii_c ) ) + { + dest[length_d-2] = dest[length_d-1] = ascii_space; + } + + return; } extern "C" @@ -1266,7 +624,8 @@ __gg__string_to_alpha_edited( char *dest, charmap_t *charmap_dest = __gg__get_charmap(dest_encoding); - int destlength = expand_picture(dest, picture); + int destlength = strlen(picture); + memcpy(dest, picture, destlength); int dindex = 0; int sindex = 0; @@ -1307,10 +666,10 @@ __gg__string_to_alpha_edited( char *dest, dindex += 1; } } - + extern "C" void -__gg__currency_sign_init() // This duplicates the constructor. +__gg__currency_sign_init() // This duplicates the constructor. { for( auto str : __gg__currency_signs ) { str.clear(); diff --git a/libgcobol/valconv.h b/libgcobol/valconv.h index d9c4b11a44a5..62ee342c2b0b 100644 --- a/libgcobol/valconv.h +++ b/libgcobol/valconv.h @@ -53,7 +53,7 @@ extern "C" const unsigned char *alphabet, int low_char, int high_char ); - bool __gg__string_to_numeric_edited(char * const dest, + void __gg__string_to_numeric_edited(char * const dest, const char *source, // ASCII int rdigits, int is_negative, From 543617c93595e0cb45ff7ee52c635ca30a2fe361 Mon Sep 17 00:00:00 2001 From: Longjun Luo Date: Thu, 17 Sep 2026 03:02:05 +0000 Subject: [PATCH 147/584] middle-end: Defer section resolution for GIMPLE wrappers [PR126841] Since r167795, cfgexpand has resolved a function's section before RTL expansion. r168624 added resolve_unique_section to the direct thunk emission path, when thunks were still emitted directly as assembly. When r202592 added a GIMPLE thunk path, the call was retained in both paths. The direct assembler path still needs it, but the GIMPLE path later reaches cfgexpand, so its call is redundant. It can also be too early. IPA ICF can turn equivalent functions whose addresses matter into GIMPLE wrappers during WPA, before LTO privatizes their assembler names. The early call records a section based on the old name, and that stale section is streamed into LTRANS. IPA strub has the same problem in the GIMPLE wrapper code added in r14-6201. Remove the early calls for GIMPLE wrappers and let cfgexpand resolve their sections from the final assembler names. Keep the call for directly emitted assembler thunks; during LTO output it is reached only after privatization. Explicit and deliberately inherited section names remain unchanged. This fixes the stale name at its source instead of discarding an already-resolved section only when LTO privatizes a symbol. PR lto/126841 gcc/ChangeLog: * doc/invoke.texi (-ffunction-sections): Document implicit function section names under LTO. * ipa-strub.cc (pass_ipa_strub::execute): Let cfgexpand resolve the GIMPLE wrapper section. * symtab-thunks.cc (expand_thunk): Likewise for generic GIMPLE thunks. Clarify the direct-assembler case. gcc/testsuite/ChangeLog: * gcc.dg/lto/pr126841-strub_0.c: New test. * gcc.dg/lto/pr126841-strub_1.c: New test. * gcc.dg/lto/pr126841_0.c: New test. * gcc.dg/lto/pr126841_1.c: New test. * gcc.dg/lto/pr126841_2.c: New test. * gcc.dg/lto/pr126841_3.c: New test. Signed-off-by: Longjun Luo --- gcc/doc/invoke.texi | 6 ++++++ gcc/ipa-strub.cc | 4 ---- gcc/symtab-thunks.cc | 7 ++----- gcc/testsuite/gcc.dg/lto/pr126841-strub_0.c | 21 ++++++++++++++++++++ gcc/testsuite/gcc.dg/lto/pr126841-strub_1.c | 7 +++++++ gcc/testsuite/gcc.dg/lto/pr126841_0.c | 22 +++++++++++++++++++++ gcc/testsuite/gcc.dg/lto/pr126841_1.c | 7 +++++++ gcc/testsuite/gcc.dg/lto/pr126841_2.c | 7 +++++++ gcc/testsuite/gcc.dg/lto/pr126841_3.c | 5 +++++ 9 files changed, 77 insertions(+), 9 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/lto/pr126841-strub_0.c create mode 100644 gcc/testsuite/gcc.dg/lto/pr126841-strub_1.c create mode 100644 gcc/testsuite/gcc.dg/lto/pr126841_0.c create mode 100644 gcc/testsuite/gcc.dg/lto/pr126841_1.c create mode 100644 gcc/testsuite/gcc.dg/lto/pr126841_2.c create mode 100644 gcc/testsuite/gcc.dg/lto/pr126841_3.c diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 3311ff946198..498a3608151e 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -16946,6 +16946,12 @@ file if the target supports arbitrary sections. The name of the function or the name of the data item determines the section's name in the output file. +With link-time optimization, an implicitly generated function section name is +derived from the final assembler name unless the compiler deliberately places +related functions, such as a thunk and its target, in the same section. The +final assembler name may include a compiler-generated suffix that distinguishes +identically named internal-linkage items from different translation units. + Use these options on systems where the linker can perform optimizations to improve locality of reference in the instruction space. Most systems using the ELF object format have linkers with such optimizations. On AIX, the linker diff --git a/gcc/ipa-strub.cc b/gcc/ipa-strub.cc index b0156fe46f66..118c4a080824 100644 --- a/gcc/ipa-strub.cc +++ b/gcc/ipa-strub.cc @@ -3124,10 +3124,6 @@ pass_ipa_strub::execute (function *) current_function_decl = thunk_fndecl; - /* Ensure thunks are emitted in their correct sections. */ - resolve_unique_section (thunk_fndecl, 0, - flag_function_sections); - bitmap_obstack_initialize (NULL); /* Build the return declaration for the function. */ diff --git a/gcc/symtab-thunks.cc b/gcc/symtab-thunks.cc index fb4ff87c9883..e0a8d5e93573 100644 --- a/gcc/symtab-thunks.cc +++ b/gcc/symtab-thunks.cc @@ -363,7 +363,8 @@ expand_thunk (cgraph_node *node, bool output_asm_thunks, current_function_decl = thunk_fndecl; - /* Ensure thunks are emitted in their correct sections. */ + /* This thunk is emitted directly and bypasses cfgexpand, so resolve + its section here. */ resolve_unique_section (thunk_fndecl, 0, flag_function_sections); @@ -432,10 +433,6 @@ expand_thunk (cgraph_node *node, bool output_asm_thunks, current_function_decl = thunk_fndecl; - /* Ensure thunks are emitted in their correct sections. */ - resolve_unique_section (thunk_fndecl, 0, - flag_function_sections); - bitmap_obstack_initialize (NULL); if (info->virtual_offset_p) diff --git a/gcc/testsuite/gcc.dg/lto/pr126841-strub_0.c b/gcc/testsuite/gcc.dg/lto/pr126841-strub_0.c new file mode 100644 index 000000000000..bd8e628ade50 --- /dev/null +++ b/gcc/testsuite/gcc.dg/lto/pr126841-strub_0.c @@ -0,0 +1,21 @@ +/* { dg-lto-do link } */ +/* { dg-require-effective-target elf } */ +/* { dg-require-effective-target named_sections } */ +/* { dg-require-effective-target fpic } */ +/* { dg-require-effective-target shared } */ +/* { dg-require-effective-target strub } */ +/* { dg-require-linker-plugin "" } */ +/* { dg-lto-options { { -O2 -flto -fPIC -shared -ffunction-sections -save-temps -fstrub=all -fno-ipa-icf } } } */ + +static int +same_fn (int x) +{ + return x * 33 + 7; +} + +int (*a_callback) (int) = same_fn; + +/* The strub wrappers must use sections derived from their privatized + assembler names. */ +/* { dg-final { scan-lto-assembler {\.section[ \t]+\.text\.same_fn\.lto_priv\.0[, \t"]} } } */ +/* { dg-final { scan-lto-assembler {\.section[ \t]+\.text\.same_fn\.lto_priv\.1[, \t"]} } } */ diff --git a/gcc/testsuite/gcc.dg/lto/pr126841-strub_1.c b/gcc/testsuite/gcc.dg/lto/pr126841-strub_1.c new file mode 100644 index 000000000000..39356acba71a --- /dev/null +++ b/gcc/testsuite/gcc.dg/lto/pr126841-strub_1.c @@ -0,0 +1,7 @@ +static int +same_fn (int x) +{ + return x * 33 + 7; +} + +int (*b_callback) (int) = same_fn; diff --git a/gcc/testsuite/gcc.dg/lto/pr126841_0.c b/gcc/testsuite/gcc.dg/lto/pr126841_0.c new file mode 100644 index 000000000000..a0222d3336f4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/lto/pr126841_0.c @@ -0,0 +1,22 @@ +/* { dg-lto-do link } */ +/* { dg-require-effective-target elf } */ +/* { dg-require-effective-target named_sections } */ +/* { dg-require-effective-target fpic } */ +/* { dg-require-effective-target shared } */ +/* { dg-require-linker-plugin "" } */ +/* { dg-lto-options { { -O2 -flto -fPIC -shared -ffunction-sections -save-temps } } } */ + +static int +same_fn (int x) +{ + return x * 33 + 7; +} + +int (*a_callback) (int) = same_fn; + +/* The exported function keeps the unsuffixed section, and each privatized + function must have its own section. */ +/* { dg-final { scan-lto-assembler {\.section[ \t]+\.text\.same_fn[, \t"]} } } */ +/* { dg-final { scan-lto-assembler {\.section[ \t]+\.text\.same_fn\.lto_priv\.0[, \t"]} } } */ +/* { dg-final { scan-lto-assembler {\.section[ \t]+\.text\.same_fn\.lto_priv\.1[, \t"]} } } */ +/* { dg-final { scan-lto-assembler {\.section[ \t]+\.text\.same_fn\.lto_priv\.2[, \t"]} } } */ diff --git a/gcc/testsuite/gcc.dg/lto/pr126841_1.c b/gcc/testsuite/gcc.dg/lto/pr126841_1.c new file mode 100644 index 000000000000..39356acba71a --- /dev/null +++ b/gcc/testsuite/gcc.dg/lto/pr126841_1.c @@ -0,0 +1,7 @@ +static int +same_fn (int x) +{ + return x * 33 + 7; +} + +int (*b_callback) (int) = same_fn; diff --git a/gcc/testsuite/gcc.dg/lto/pr126841_2.c b/gcc/testsuite/gcc.dg/lto/pr126841_2.c new file mode 100644 index 000000000000..369eb1836a6c --- /dev/null +++ b/gcc/testsuite/gcc.dg/lto/pr126841_2.c @@ -0,0 +1,7 @@ +static int +same_fn (int x) +{ + return x * 33 + 7; +} + +int (*c_callback) (int) = same_fn; diff --git a/gcc/testsuite/gcc.dg/lto/pr126841_3.c b/gcc/testsuite/gcc.dg/lto/pr126841_3.c new file mode 100644 index 000000000000..567eb29cda0e --- /dev/null +++ b/gcc/testsuite/gcc.dg/lto/pr126841_3.c @@ -0,0 +1,5 @@ +int +same_fn (int x) +{ + return x - 1; +} From 1f54efacc155831aebc13f17f036adec2b56e2ec Mon Sep 17 00:00:00 2001 From: Claudiu Zissulescu Date: Thu, 17 Sep 2026 10:54:43 +0300 Subject: [PATCH 148/584] arc: Remove the unused "cond" attribute The "cond" attribute describes how each instruction uses or sets the condition codes, but nothing reads it anymore: no code in the compiler calls get_attr_cond, and genattr does not even emit a declaration for it, so the attribute table genattrtab computes for it is dead code. Remove the attribute definition, all the (set_attr "cond" ...) specifications, and the comments which describe the attribute. No functional change. gcc/ChangeLog: * config/arc/arc.md: Remove the "cond" attribute definition, all its uses and the comments describing it. * config/arc/fpu.md: Likewise. * config/arc/fpx.md: Likewise. * config/arc/simdext.md: Likewise. Signed-off-by: Claudiu Zissulescu --- gcc/config/arc/arc.md | 341 +++++++--------------------------- gcc/config/arc/fpu.md | 18 -- gcc/config/arc/fpx.md | 28 +-- gcc/config/arc/simdext.md | 381 +++++++++++++------------------------- 4 files changed, 206 insertions(+), 562 deletions(-) diff --git a/gcc/config/arc/arc.md b/gcc/config/arc/arc.md index 54b65fefe6ac..e0f132118997 100644 --- a/gcc/config/arc/arc.md +++ b/gcc/config/arc/arc.md @@ -335,88 +335,6 @@ (const_string "yes"))) (define_attr "predicable" "no,yes" (const_string "no")) -;; if 'predicable' were not so brain-dead, we would specify: -;; (cond [(eq_attr "cond" "!canuse") (const_string "no") -;; (eq_attr "iscompact" "maybe") (const_string "no")] -;; (const_string "yes")) -;; and then for everything but calls, we could just set the cond attribute. - -;; Condition codes: this one is used by final_prescan_insn to speed up -;; conditionalizing instructions. It saves having to scan the rtl to see if -;; it uses or alters the condition codes. - -;; USE: This insn uses the condition codes (eg: a conditional branch). -;; CANUSE: This insn can use the condition codes (for conditional execution). -;; SET: All condition codes are set by this insn. -;; SET_ZN: the Z and N flags are set by this insn. -;; SET_ZNC: the Z, N, and C flags are set by this insn. -;; CLOB: The condition codes are set to unknown values by this insn. -;; NOCOND: This insn can't use and doesn't affect the condition codes. - -(define_attr "cond" "use,canuse,canuse_limm,canuse_limm_add,set,set_zn,clob,nocond" - (cond - [(and (eq_attr "predicable" "yes") - (eq_attr "is_sfunc" "no") - (eq_attr "delay_slot_filled" "no")) - (const_string "canuse") - - (eq_attr "type" "call") - (cond [(eq_attr "delay_slot_filled" "yes") (const_string "nocond") - (match_test "!flag_pic") (const_string "canuse_limm")] - (const_string "nocond")) - - (eq_attr "iscompact" "maybe,false") - (cond [ (and (eq_attr "type" "move") - (match_operand 1 "immediate_operand" "")) - (if_then_else - (ior (match_operand 1 "u6_immediate_operand" "") - (match_operand 1 "long_immediate_operand" "")) - (const_string "canuse") - (const_string "canuse_limm")) - - (eq_attr "type" "binary") - (cond [(ne (symbol_ref "REGNO (operands[0])") - (symbol_ref "REGNO (operands[1])")) - (const_string "nocond") - (match_operand 2 "register_operand" "") - (const_string "canuse") - (match_operand 2 "u6_immediate_operand" "") - (const_string "canuse") - (match_operand 2 "long_immediate_operand" "") - (const_string "canuse") - (match_operand 2 "const_int_operand" "") - (const_string "canuse_limm")] - (const_string "nocond")) - - (eq_attr "type" "compare") - (const_string "set") - - (eq_attr "type" "cmove,branch") - (const_string "use") - - (eq_attr "is_sfunc" "yes") - (cond [(match_test "(TARGET_MEDIUM_CALLS - && !TARGET_LONG_CALLS_SET - && flag_pic)") - (const_string "canuse_limm_add") - (match_test "(TARGET_MEDIUM_CALLS - && !TARGET_LONG_CALLS_SET)") - (const_string "canuse_limm")] - (const_string "canuse")) - - ] - - (const_string "nocond"))] - - (cond [(eq_attr "type" "compare") - (const_string "set") - - (eq_attr "type" "cmove,branch") - (const_string "use") - - ] - - (const_string "nocond")))) /* ??? Having all these patterns gives ifcvt more freedom to generate inefficient code. It seem to operate on the premise that @@ -502,8 +420,7 @@ ;; (define_asm_attributes [(set_attr "length" "8") - (set_attr "type" "multi") - (set_attr "cond" "clob") ]) + (set_attr "type" "multi") ]) ;; Delay slots. ;; The first two cond clauses and the default are necessary for correctness; @@ -851,8 +768,7 @@ archs4x, archs4xd" (const_int 0)))] "" ".f\\t0,%1" - [(set_attr "type" "compare") - (set_attr "cond" "set_zn")]) + [(set_attr "type" "compare") ]) (define_insn "*xt_cmp0" [(set (match_operand 0 "cc_set_register" "") @@ -862,8 +778,7 @@ archs4x, archs4xd" (SEZ:SI (match_dup 1)))] "" ".f\\t%2,%1" - [(set_attr "type" "compare") - (set_attr "cond" "set_zn")]) + [(set_attr "type" "compare") ]) (define_insn "*xbfu_cmp0_noout" [(set (match_operand 0 "cc_set_register" "") @@ -882,8 +797,7 @@ archs4x, archs4xd" [(set_attr "type" "shift") (set_attr "iscompact" "false") (set_attr "length" "4,8") - (set_attr "predicable" "no") - (set_attr "cond" "set_zn")]) + (set_attr "predicable" "no") ]) (define_insn "*xbfu_cmp0" [(set (match_operand 4 "cc_set_register" "") @@ -904,8 +818,7 @@ archs4x, archs4xd" [(set_attr "type" "shift") (set_attr "iscompact" "false") (set_attr "length" "4,8,8") - (set_attr "predicable" "yes,no,yes") - (set_attr "cond" "set_zn")]) + (set_attr "predicable" "yes,no,yes") ]) ; splitting to 'tst' allows short insns and combination into brcc. (define_insn_and_split "*movsi_set_cc_insn" @@ -922,7 +835,6 @@ archs4x, archs4xd" "" [(set_attr "type" "compare") (set_attr "predicable" "yes,no,yes") - (set_attr "cond" "set_zn") (set_attr "length" "4,4,8")]) (define_insn "unary_comparison" @@ -933,8 +845,7 @@ archs4x, archs4xd" (const_int 0)]))] "" "%O2.f 0,%1" - [(set_attr "type" "compare") - (set_attr "cond" "set_zn")]) + [(set_attr "type" "compare") ]) ; this pattern is needed by combiner for cases like if (c=(~b)) { ... } @@ -949,7 +860,6 @@ archs4x, archs4xd" "" "%O3.f\\t%0,%1" [(set_attr "type" "compare") - (set_attr "cond" "set_zn") (set_attr "length" "4")]) ; reload is too stingy with reloads for Rrq/Cbf/Rrq when it sees @@ -1006,8 +916,7 @@ archs4x, archs4xd" [(set_attr "iscompact" "maybe,maybe,false,false,false,false,false,false") (set_attr "type" "compare,compare,compare,compare,compare,compare,binary,compare") (set_attr "length" "*,*,4,4,4,4,4,8") - (set_attr "predicable" "no,yes,no,yes,no,no,no,yes") - (set_attr "cond" "set_zn")]) + (set_attr "predicable" "no,yes,no,yes,no,no,no,yes") ]) ; ??? Sometimes, if an AND with a constant can be expressed as a zero_extract, ; combine will do that and not try the AND. @@ -1031,7 +940,6 @@ archs4x, archs4xd" && INTVAL (operands[3]) + INTVAL (operands[2]) == 32))" "tst\\t%1,((1<<%2)-1)<<%3" [(set_attr "type" "compare") - (set_attr "cond" "set_zn") (set_attr "length" "4")]) ; Likewise for asr.f. @@ -1047,7 +955,6 @@ archs4x, archs4xd" && INTVAL (operands[3]) + INTVAL (operands[2]) == 32" "asr.f 0,%1,%3" [(set_attr "type" "shift") - (set_attr "cond" "set_zn") (set_attr "length" "4")]) (define_insn "*tst_bitfield" @@ -1068,7 +975,6 @@ archs4x, archs4xd" and.f\\t0,%1,((1<<%2)-1)<<%3" [(set_attr "iscompact" "maybe,false,false,false,false") (set_attr "type" "compare,compare,compare,shift,compare") - (set_attr "cond" "set_zn") (set_attr "length" "*,4,4,4,8")]) (define_expand "mulvsi4" @@ -1138,7 +1044,6 @@ archs4x, archs4xd" "" "%O3.f\\t0,%1,%2" [(set_attr "type" "compare") - (set_attr "cond" "set_zn") (set_attr "length" "4,8")]) (define_insn "*commutative_binary_cmp0" @@ -1153,7 +1058,6 @@ archs4x, archs4xd" "" "%O4.f\\t%0,%1,%2" [(set_attr "type" "compare") - (set_attr "cond" "set_zn") (set_attr "predicable" "yes,yes,no,no") (set_attr "length" "4,4,4,8")]) @@ -1166,8 +1070,7 @@ archs4x, archs4xd" (match_operand:SI 1 "register_operand" "r")))] "" "add.f\\t0,%0,%1" - [(set_attr "cond" "set") - (set_attr "type" "compare") + [(set_attr "type" "compare") (set_attr "length" "4")]) (define_insn "addsi_compare_2" @@ -1177,8 +1080,7 @@ archs4x, archs4xd" (match_dup 0)))] "" "add.f\\t0,%0,%1" - [(set_attr "cond" "set") - (set_attr "type" "compare") + [(set_attr "type" "compare") (set_attr "length" "4,8")]) (define_insn "*addsi_compare_3" @@ -1188,8 +1090,7 @@ archs4x, archs4xd" (match_dup 1)))] "" "add.f\\t0,%0,%1" - [(set_attr "cond" "set") - (set_attr "type" "compare") + [(set_attr "type" "compare") (set_attr "length" "4")]) ; this pattern is needed by combiner for cases like if (c=a+b) { ... } @@ -1207,7 +1108,6 @@ archs4x, archs4xd" "" "%O4.f\\t%0,%1,%2 ; non-mult commutative" [(set_attr "type" "compare,compare,compare") - (set_attr "cond" "set_zn,set_zn,set_zn") (set_attr "length" "4,4,8")]) ; a MULT-specific version of this pattern to avoid touching the @@ -1225,7 +1125,6 @@ archs4x, archs4xd" "!TARGET_ARC600_FAMILY" "%O4.f\\t%0,%1,%2 ; mult commutative" [(set_attr "type" "compare,compare,compare") - (set_attr "cond" "set_zn,set_zn,set_zn") (set_attr "length" "4,4,8")]) (define_insn "*noncommutative_binary_cmp0" @@ -1240,7 +1139,6 @@ archs4x, archs4xd" "" "%O4%?.f\\t%0,%1,%2" [(set_attr "type" "compare") - (set_attr "cond" "set_zn") (set_attr "predicable" "yes,no,no,yes,no") (set_attr "length" "4,4,4,8,8")]) @@ -1254,7 +1152,6 @@ archs4x, archs4xd" "" "%O4.f\\t0,%1,%2" [(set_attr "type" "compare") - (set_attr "cond" "set_zn") (set_attr "length" "4,8")]) ;;rsub variants @@ -1270,7 +1167,6 @@ archs4x, archs4xd" "" "rsub.f\\t%0,%2,%1" [(set_attr "type" "compare") - (set_attr "cond" "set_zn") (set_attr "length" "4,8")]) (define_insn "*rsub_cmp0_noout" @@ -1283,7 +1179,6 @@ archs4x, archs4xd" "" "rsub.f\\t0,%2,%1" [(set_attr "type" "compare") - (set_attr "cond" "set_zn") (set_attr "length" "4,8")]) (define_expand "bic_f_zn" @@ -1309,7 +1204,6 @@ archs4x, archs4xd" "" "bic.f\\t%0,%1,%2" [(set_attr "type" "compare,compare,compare") - (set_attr "cond" "set_zn,set_zn,set_zn") (set_attr "length" "4,4,8")]) (define_insn "*bic_cmp0_noout" @@ -1322,7 +1216,6 @@ archs4x, archs4xd" || register_operand (operands[2], SImode)" "bic.f\\t0,%2,%1" [(set_attr "type" "unary") - (set_attr "cond" "set_zn") (set_attr "length" "4,8,8")]) (define_insn "*bic_cmp0" @@ -1337,7 +1230,6 @@ archs4x, archs4xd" || register_operand (operands[2], SImode)" "bic.f\\t%3,%2,%1" [(set_attr "type" "unary") - (set_attr "cond" "set_zn") (set_attr "length" "4,8,8")]) (define_expand "movdi" @@ -2094,7 +1986,6 @@ archs4x, archs4xd" (set_attr "iscompact" "false") (set_attr "type" "mul16_em") (set_attr "predicable" "yes,no,no,yes,no") - (set_attr "cond" "canuse,nocond,nocond,canuse_limm,nocond") ]) (define_insn "mulhisi3_reg" @@ -2107,7 +1998,6 @@ archs4x, archs4xd" (set_attr "iscompact" "maybe,false,false") (set_attr "type" "mul16_em") (set_attr "predicable" "yes,yes,no") - (set_attr "cond" "canuse,canuse,nocond") ]) (define_expand "umulhisi3" @@ -2134,7 +2024,6 @@ archs4x, archs4xd" (set_attr "iscompact" "false") (set_attr "type" "mul16_em") (set_attr "predicable" "yes,no,no,yes,no") - (set_attr "cond" "canuse,nocond,nocond,canuse_limm,nocond") ]) (define_insn "umulhisi3_reg" @@ -2147,7 +2036,6 @@ archs4x, archs4xd" (set_attr "iscompact" "maybe,false,false") (set_attr "type" "mul16_em") (set_attr "predicable" "yes,yes,no") - (set_attr "cond" "canuse,canuse,nocond") ]) ;; ARC700/ARC600/V2 multiply @@ -2216,8 +2104,7 @@ archs4x, archs4xd" "mululw\\t0,%0,%1" [(set_attr "length" "4,4,8") (set_attr "type" "mulmac_600") - (set_attr "predicable" "no") - (set_attr "cond" "nocond")]) + (set_attr "predicable" "no") ]) (define_insn "mac_600" [(set (match_operand:SI 2 "acc2_operand" "") @@ -2234,8 +2121,7 @@ archs4x, archs4xd" "machlw%?\\t0,%0,%1" [(set_attr "length" "4,4,8") (set_attr "type" "mulmac_600, mulmac_600, mulmac_600") - (set_attr "predicable" "no, no, yes") - (set_attr "cond" "nocond, canuse_limm, canuse")]) + (set_attr "predicable" "no, no, yes") ]) ; The gcc-internal representation may differ from the hardware ; register number in order to allow the generic code to correctly @@ -2269,8 +2155,7 @@ archs4x, archs4xd" [(set_attr "length" "*,4,4,8") (set_attr "iscompact" "maybe,false,false,false") (set_attr "type" "multi,multi,multi,multi") - (set_attr "predicable" "yes,yes,no,yes") - (set_attr "cond" "canuse,canuse,canuse_limm,canuse")]) + (set_attr "predicable" "yes,yes,no,yes") ]) (define_insn_and_split "mulsidi_600" [(set (match_operand:DI 0 "register_operand" "=r,r, r") @@ -2304,8 +2189,7 @@ archs4x, archs4xd" [(set_attr "length" "*,4,4,8") (set_attr "iscompact" "maybe,false,false,false") (set_attr "type" "multi,multi,multi,multi") - (set_attr "predicable" "yes,yes,no,yes") - (set_attr "cond" "canuse,canuse,canuse_limm,canuse")]) + (set_attr "predicable" "yes,yes,no,yes") ]) (define_insn_and_split "umulsidi_600" [(set (match_operand:DI 0 "register_operand" "=r,r, r") @@ -2339,8 +2223,7 @@ archs4x, archs4xd" [(set_attr "length" "4,4,8") (set_attr "iscompact" "false") (set_attr "type" "umulti") - (set_attr "predicable" "yes,no,yes") - (set_attr "cond" "canuse,canuse_limm,canuse")]) + (set_attr "predicable" "yes,no,yes") ]) ; ARC700 mpy* instructions: This is a multi-cycle extension, and thus 'w' ; may not be used as destination constraint. @@ -2358,8 +2241,7 @@ archs4x, archs4xd" "mpyu%?\\t%0,%1,%2" [(set_attr "length" "4,4,4,8,8") (set_attr "type" "umulti") - (set_attr "predicable" "yes,no,no,yes,no") - (set_attr "cond" "canuse,nocond,canuse_limm,canuse,nocond")]) + (set_attr "predicable" "yes,no,no,yes,no") ]) ; ARCv2 has no penalties between mpy and mpyu. So, we use mpy because of its ; short variant. LP_COUNT constraints are still valid. @@ -2379,8 +2261,7 @@ archs4x, archs4xd" [(set_attr "length" "*,*,4,4,4,8,8") (set_attr "iscompact" "maybe,maybe,false,false,false,false,false") (set_attr "type" "umulti") - (set_attr "predicable" "no,no,yes,no,no,yes,no") - (set_attr "cond" "nocond,nocond,canuse,nocond,canuse_limm,canuse,nocond")]) + (set_attr "predicable" "no,no,yes,no,no,yes,no") ]) (define_expand "mulsidi3" [(set (match_operand:DI 0 "register_operand" "") @@ -2462,8 +2343,7 @@ archs4x, archs4xd" "mullw%?\\t0,%0,%1" [(set_attr "length" "4,4,8") (set_attr "type" "mulmac_600") - (set_attr "predicable" "no,no,yes") - (set_attr "cond" "nocond, canuse_limm, canuse")]) + (set_attr "predicable" "no,no,yes") ]) ;; ??? check if this is canonical rtl @@ -2490,8 +2370,7 @@ archs4x, archs4xd" "machlw%?\\t%0,%1,%2" [(set_attr "length" "4,4,8") (set_attr "type" "mulmac_600") - (set_attr "predicable" "no,no,yes") - (set_attr "cond" "nocond, canuse_limm, canuse")]) + (set_attr "predicable" "no,no,yes") ]) ;; DI <- DI(signed SI) * DI(signed SI) @@ -2527,8 +2406,7 @@ archs4x, archs4xd" "mpy%+%?\\t%0,%1,%2" [(set_attr "length" "4,4,8,8") (set_attr "type" "multi") - (set_attr "predicable" "yes,no,yes,no") - (set_attr "cond" "canuse,nocond,canuse,nocond")]) + (set_attr "predicable" "yes,no,yes,no") ]) ; Note that mpyhu has the same latency as mpy / mpyh, ; thus we use the type multi. @@ -2544,8 +2422,7 @@ archs4x, archs4xd" "mpy%+u%?\\t%0,%1,%2" [(set_attr "length" "4,4,8,8") (set_attr "type" "multi") - (set_attr "predicable" "yes,no,yes,no") - (set_attr "cond" "canuse,nocond,canuse,nocond")]) + (set_attr "predicable" "yes,no,yes,no") ]) ;; (zero_extend:DI (const_int)) leads to internal errors in combine, so we ;; need a separate pattern for immediates @@ -2562,8 +2439,7 @@ archs4x, archs4xd" "mpy%+u%?\\t%0,%1,%2" [(set_attr "length" "4,4,4,8,8") (set_attr "type" "multi") - (set_attr "predicable" "yes,no,no,yes,no") - (set_attr "cond" "canuse,nocond,canuse_limm,canuse,nocond")]) + (set_attr "predicable" "yes,no,no,yes,no") ]) (define_expand "umulsi3_highpart" [(set (match_operand:SI 0 "general_operand" "") @@ -2677,8 +2553,7 @@ archs4x, archs4xd" "mululw\\t0,%0,%1" [(set_attr "length" "4,4,8") (set_attr "type" "mulmac_600") - (set_attr "predicable" "no") - (set_attr "cond" "nocond")]) + (set_attr "predicable" "no") ]) (define_insn "umac64_600" @@ -2704,8 +2579,7 @@ archs4x, archs4xd" "machulw%?\\t%0,%1,%2" [(set_attr "length" "4,4,8") (set_attr "type" "mulmac_600") - (set_attr "predicable" "no,no,yes") - (set_attr "cond" "nocond, canuse_limm, canuse")]) + (set_attr "predicable" "no,no,yes") ]) ;; DI <- DI(unsigned SI) * DI(unsigned SI) (define_insn_and_split "umulsidi3_700" @@ -2804,8 +2678,7 @@ archs4x, archs4xd" (sign_extend:DI (match_dup 2)))))] "" "add.f\\t%0,%1,%2" - [(set_attr "cond" "set") - (set_attr "type" "compare") + [(set_attr "type" "compare") (set_attr "length" "4,4,4,8")]) (define_expand "addvsi4" @@ -2828,8 +2701,7 @@ archs4x, archs4xd" (match_dup 1)))] "" "add.f\\t%0,%1,%2" - [(set_attr "cond" "set") - (set_attr "type" "compare") + [(set_attr "type" "compare") (set_attr "length" "4,4,4,8")]) (define_expand "uaddvsi4" @@ -2860,8 +2732,7 @@ archs4x, archs4xd" add.f\\t%0,%2,%1 add.f\\t%0,%2,%1 add.f\\t%0,%1,%2" - [(set_attr "cond" "set") - (set_attr "type" "compare") + [(set_attr "type" "compare") (set_attr "length" "4,4,4,4,8,8")]) (define_insn "*add_f_2" @@ -2874,8 +2745,7 @@ archs4x, archs4xd" (plus:SI (match_dup 1) (match_dup 2)))] "" "add.f\\t%0,%1,%2" - [(set_attr "cond" "set") - (set_attr "type" "compare") + [(set_attr "type" "compare") (set_attr "length" "4,4,8")]) (define_insn "adc" @@ -2894,8 +2764,7 @@ archs4x, archs4xd" adc\\t%0,%1,%2 adc\\t%0,%1,%2 adc\\t%0,%1,%2" - [(set_attr "cond" "use") - (set_attr "type" "cc_arith") + [(set_attr "type" "cc_arith") (set_attr "length" "4,4,4,4,8,8")]) (define_insn "adc_f" @@ -2918,8 +2787,7 @@ archs4x, archs4xd" (match_dup 2)))] "" "adc.f\\t%0,%1,%2" - [(set_attr "cond" "set") - (set_attr "predicable" "no") + [(set_attr "predicable" "no") (set_attr "type" "cc_arith") (set_attr "length" "4")]) @@ -2958,7 +2826,6 @@ archs4x, archs4xd" ; (match_operand:SI 1 "register_operand" "c")))] ; "" ; "adc\\t%0,%1,0" -; [(set_attr "cond" "use") ; (set_attr "type" "cc_arith") ; (set_attr "length" "4")]) ; @@ -3019,7 +2886,6 @@ archs4x, archs4xd" [(set_attr "iscompact" "maybe,maybe,false,false,false,false,false,false,false, false") (set_attr "length" "*,*,4,4,4,4,4,8,8,8") (set_attr "predicable" "yes,no,yes,yes,no,no,no,yes,no,no") - (set_attr "cond" "canuse,nocond,canuse,canuse,nocond,nocond,canuse_limm,canuse,nocond,nocond") (set_attr "cpu_facility" "*,cd,*,*,*,*,*,*,*,*") ]) @@ -3034,8 +2900,7 @@ archs4x, archs4xd" (sign_extend:DI (match_dup 2)))))] "" "sub.f\\t%0,%1,%2" - [(set_attr "cond" "set") - (set_attr "type" "compare") + [(set_attr "type" "compare") (set_attr "length" "4,4,4,8")]) (define_expand "subvsi4" @@ -3057,8 +2922,7 @@ archs4x, archs4xd" (match_dup 2)))] "" "sub.f\\t%0,%1,%2" - [(set_attr "cond" "set") - (set_attr "type" "compare") + [(set_attr "type" "compare") (set_attr "length" "4,4,4,8")]) (define_expand "usubvsi4" @@ -3112,8 +2976,7 @@ archs4x, archs4xd" (const_int 0))))] "" "sbc\\t%0,%1,0" - [(set_attr "cond" "use") - (set_attr "type" "cc_arith") + [(set_attr "type" "cc_arith") (set_attr "length" "4")]) (define_insn "sbc" @@ -3132,8 +2995,7 @@ archs4x, archs4xd" sbc\\t%0,%1,%2 sbc\\t%0,%1,%2 sbc\\t%0,%1,%2" - [(set_attr "cond" "use") - (set_attr "type" "cc_arith") + [(set_attr "type" "cc_arith") (set_attr "length" "4,4,4,4,8,8")]) (define_insn "sub_f" @@ -3193,7 +3055,6 @@ archs4x, archs4xd" [(set_attr "type" "shift") (set_attr "length" "*,4,8") (set_attr "predicable" "yes,no,no") - (set_attr "cond" "canuse,nocond,nocond") (set_attr "iscompact" "maybe,false,false")]) ;; N.B. sub[123] has the operands of the MINUS in the opposite order from @@ -3208,7 +3069,6 @@ archs4x, archs4xd" [(set_attr "type" "shift") (set_attr "length" "4,4,8") (set_attr "predicable" "yes,no,no") - (set_attr "cond" "canuse,nocond,nocond") (set_attr "iscompact" "false")]) (define_insn "*sub_n" @@ -3221,7 +3081,6 @@ archs4x, archs4xd" [(set_attr "type" "shift") (set_attr "length" "4,4,8") (set_attr "predicable" "yes,no,no") - (set_attr "cond" "canuse,nocond,nocond") (set_attr "iscompact" "false")]) ; ??? check if combine matches this. @@ -3233,8 +3092,7 @@ archs4x, archs4xd" "" "bset%?\\t%0,%2,%1" [(set_attr "length" "4,4,8") - (set_attr "predicable" "yes,no,no") - (set_attr "cond" "canuse,nocond,nocond")] + (set_attr "predicable" "yes,no,no") ] ) ; ??? check if combine matches this. @@ -3246,8 +3104,7 @@ archs4x, archs4xd" "" "bxor%?\\t%0,%2,%1" [(set_attr "length" "4,4,8") - (set_attr "predicable" "yes,no,no") - (set_attr "cond" "canuse,nocond,nocond")] + (set_attr "predicable" "yes,no,no") ] ) ; ??? check if combine matches this. @@ -3259,8 +3116,7 @@ archs4x, archs4xd" "" "bclr%?\\t%0,%2,%1" [(set_attr "length" "4,4,8") - (set_attr "predicable" "yes,no,no") - (set_attr "cond" "canuse,nocond,nocond")] + (set_attr "predicable" "yes,no,no") ] ) ; ??? FIXME: find combine patterns for bmsk. @@ -3279,8 +3135,7 @@ archs4x, archs4xd" bset\\t%0,%1,%2 ;;peep2, constr 2 bset\\t%0,%1,%2 ;;peep2, constr 3" [(set_attr "length" "4,4,8") - (set_attr "predicable" "yes,no,no") - (set_attr "cond" "canuse,nocond,nocond")] + (set_attr "predicable" "yes,no,no") ] ) ; see also xorsi3 for use with constant bit number. @@ -3295,8 +3150,7 @@ archs4x, archs4xd" bxor\\t%0,%1,%2 bxor\\t%0,%1,%2" [(set_attr "length" "4,4,8") - (set_attr "predicable" "yes,no,no") - (set_attr "cond" "canuse,nocond,nocond")] + (set_attr "predicable" "yes,no,no") ] ) ; see also andsi3 for use with constant bit number. @@ -3311,8 +3165,7 @@ archs4x, archs4xd" bclr\\t%0,%1,%2 bclr\\t%0,%1,%2" [(set_attr "length" "4,4,8") - (set_attr "predicable" "yes,no,no") - (set_attr "cond" "canuse,nocond,nocond")] + (set_attr "predicable" "yes,no,no") ] ) ; see also andsi3 for use with constant bit number. @@ -3329,8 +3182,7 @@ archs4x, archs4xd" bmsk\\t%0,%1,%2 bmsk\\t%0,%1,%2" [(set_attr "length" "4,4,8") - (set_attr "predicable" "yes,no,no") - (set_attr "cond" "canuse,nocond,nocond")] + (set_attr "predicable" "yes,no,no") ] ) ;;Instructions added for peephole2s end @@ -3409,8 +3261,7 @@ archs4x, archs4xd" [(set_attr "iscompact" "maybe,maybe,maybe,maybe,true,false,false,false,false,false,false,false,false,false,false,false,false,false,false,false") (set_attr "type" "binary,binary,binary,binary,binary,binary,binary,binary,binary,binary,binary,binary,binary,binary,binary,shift,binary,binary,binary,load") (set_attr "length" "*,*,*,*,*,4,4,4,4,4,4,4,4,4,4,4,4,8,8,*") - (set_attr "predicable" "no,no,no,no,no,yes,yes,yes,yes,yes,no,no,no,no,no,no,no,yes,no,no") - (set_attr "cond" "canuse,canuse,canuse,canuse,nocond,canuse,canuse,canuse,canuse,canuse,canuse_limm,nocond,nocond,nocond,nocond,nocond,canuse_limm,canuse,nocond,nocond")]) + (set_attr "predicable" "no,no,no,no,no,yes,yes,yes,yes,yes,no,no,no,no,no,no,no,yes,no,no") ]) ; combiner splitter, pattern found in ldtoa.c . ; and op3,op0,op1 / cmp op3,op2 -> add op3,op0,op4 / bmsk.f 0,op3,op1 @@ -3444,8 +3295,7 @@ archs4x, archs4xd" bic\\t%0,%2,%1 ;;constraint 6" [(set_attr "length" "*,4,4,8,4,8,8") (set_attr "iscompact" "maybe, false, false, false, false, false, false") - (set_attr "predicable" "no,yes,no,yes,no,no,no") - (set_attr "cond" "canuse,canuse,canuse_limm,canuse,nocond,nocond,nocond")]) + (set_attr "predicable" "no,yes,no,yes,no,no,no") ]) (define_insn_and_split "iorsi3" [(set (match_operand:SI 0 "dest_reg_operand" "=q,q, q, r,r, r,r, r, r,r, q, r, r") @@ -3478,8 +3328,7 @@ archs4x, archs4xd" " [(set_attr "iscompact" "maybe,maybe,maybe,false,false,false,false,false,false,false,false,false,false") (set_attr "length" "*,*,*,4,4,4,4,4,4,4,*,8,8") - (set_attr "predicable" "no,no,no,yes,yes,yes,no,no,no,no,no,yes,no") - (set_attr "cond" "canuse,canuse,canuse,canuse,canuse,canuse,canuse_limm,nocond,nocond,canuse_limm,nocond,canuse,nocond")]) + (set_attr "predicable" "no,no,no,yes,yes,yes,no,no,no,no,no,yes,no") ]) (define_insn "xorsi3" [(set (match_operand:SI 0 "dest_reg_operand" "=q,q, r,r, r,r, r, r,r, r, r") @@ -3502,8 +3351,7 @@ archs4x, archs4xd" [(set_attr "iscompact" "maybe,maybe,false,false,false,false,false,false,false,false,false") (set_attr "type" "binary") (set_attr "length" "*,*,4,4,4,4,4,4,4,8,8") - (set_attr "predicable" "no,no,yes,yes,yes,no,no,no,no,yes,no") - (set_attr "cond" "canuse,canuse,canuse,canuse,canuse,canuse_limm,nocond,nocond,canuse_limm,canuse,nocond")]) + (set_attr "predicable" "no,no,yes,yes,yes,no,no,no,no,yes,no") ]) (define_insn "negsi2" [(set (match_operand:SI 0 "dest_reg_operand" "=q,q,r,r") @@ -3539,7 +3387,6 @@ archs4x, archs4xd" operands[5] = operand_subword (operands[1], 1-swap, 0, DImode); } [(set_attr "type" "unary,unary") - (set_attr "cond" "nocond,nocond") (set_attr "length" "4,8")]) ;; Shift instructions. @@ -3580,8 +3427,7 @@ archs4x, archs4xd" "asl%?\\t%0,%1,%2" [(set_attr "type" "shift") (set_attr "iscompact" "maybe,maybe,maybe,false,false,false") - (set_attr "predicable" "no,no,no,yes,no,no") - (set_attr "cond" "canuse,nocond,canuse,canuse,nocond,nocond")]) + (set_attr "predicable" "no,no,no,yes,no,no") ]) (define_insn "*ashrsi3_insn" [(set (match_operand:SI 0 "dest_reg_operand" "=q,q, q, r, r, r") @@ -3593,8 +3439,7 @@ archs4x, archs4xd" "asr%?\\t%0,%1,%2" [(set_attr "type" "shift") (set_attr "iscompact" "maybe,maybe,maybe,false,false,false") - (set_attr "predicable" "no,no,no,yes,no,no") - (set_attr "cond" "canuse,nocond,canuse,canuse,nocond,nocond")]) + (set_attr "predicable" "no,no,no,yes,no,no") ]) (define_insn "*lshrsi3_insn" [(set (match_operand:SI 0 "dest_reg_operand" "=q, q, r, r, r") @@ -3611,8 +3456,7 @@ archs4x, archs4xd" lsr%?\\t%0,%1,%2" [(set_attr "type" "shift") (set_attr "iscompact" "maybe,maybe,false,false,false") - (set_attr "predicable" "no,no,yes,no,no") - (set_attr "cond" "nocond,canuse,canuse,nocond,nocond")]) + (set_attr "predicable" "no,no,yes,no,no") ]) (define_insn "si2_cnt16" [(set (match_operand:SI 0 "register_operand" "=r") @@ -3938,7 +3782,6 @@ archs4x, archs4xd" [(set_attr "type" "compare") (set_attr "iscompact" "true,true,true,false,false,true_limm,false") (set_attr "predicable" "no,no,no,no,yes,no,yes") - (set_attr "cond" "set") (set_attr "length" "*,*,*,4,4,*,8") (set_attr "cpu_facility" "av1,av2,*,*,*,*,*")]) @@ -3951,7 +3794,6 @@ archs4x, archs4xd" [(set_attr "type" "compare,compare") (set_attr "iscompact" "true,false") (set_attr "predicable" "no,yes") - (set_attr "cond" "set_zn") (set_attr "length" "*,4")]) ; combiner pattern observed for unwind-dw2-fde.c:linear_search_fdes. @@ -3966,7 +3808,6 @@ archs4x, archs4xd" "btst%?\\t%0,%1" [(set_attr "iscompact" "true,false") (set_attr "predicable" "no,yes") - (set_attr "cond" "set") (set_attr "type" "compare") (set_attr "length" "*,4")]) @@ -3980,7 +3821,6 @@ archs4x, archs4xd" bxor.f\\t0,%0,%z1" [(set_attr "type" "compare,compare") (set_attr "iscompact" "true,false") - (set_attr "cond" "set,set_zn") (set_attr "length" "*,4")]) (define_insn "*cmpsi_cc_c_insn" @@ -3991,7 +3831,6 @@ archs4x, archs4xd" "cmp%?\\t%0,%1" [(set_attr "type" "compare") (set_attr "iscompact" "true,true,true,false,true_limm,false") - (set_attr "cond" "set") (set_attr "length" "*,*,*,4,*,8") (set_attr "cpu_facility" "av1,av2,*,*,*,*")]) @@ -4115,8 +3954,7 @@ archs4x, archs4xd" arc_output_commutative_cond_exec (operands, true); return ""; } - [(set_attr "cond" "use") - (set_attr "type" "cmove") + [(set_attr "type" "cmove") (set_attr_alternative "length" [(const_int 4) (cond @@ -4137,8 +3975,7 @@ archs4x, archs4xd" sub.%d4\\t%0,%1,%2 rsub.%d4\\t%0,%2,%1 rsub.%d4\\t%0,%2,%1" - [(set_attr "cond" "use") - (set_attr "type" "cmove") + [(set_attr "type" "cmove") (set_attr "length" "4,4,8")]) (define_insn "*noncommutative_cond_exec" @@ -4151,8 +3988,7 @@ archs4x, archs4xd" (match_operand:SI 2 "nonmemory_operand" "cL,Cal")])))] "" "%O3.%d5\\t%0,%1,%2" - [(set_attr "cond" "use") - (set_attr "type" "cmove") + [(set_attr "type" "cmove") (set_attr "length" "4,8")]) ;; These control RTL generation for conditional jump insns @@ -4265,7 +4101,6 @@ archs4x, archs4xd" (set (attr "iscompact") (if_then_else (match_test "get_attr_length (insn) == 2") (const_string "true") (const_string "false"))) - (set_attr "cond" "canuse") (set (attr "length") (cond [ ; In arc_reorg we just guesstimate; might be more or less than 4. @@ -4295,8 +4130,7 @@ archs4x, archs4xd" j%!%*\\t[%0] j%!%*\\t[%0]" [(set_attr "type" "jump") - (set_attr "iscompact" "false,false,false,maybe,false") - (set_attr "cond" "canuse,canuse_limm,canuse,canuse,canuse")]) + (set_attr "iscompact" "false,false,false,maybe,false") ]) ;; Implement a switch statement. (define_expand "casesi" @@ -4423,8 +4257,7 @@ archs4x, archs4xd" "" "j%!%* [%0]" [(set_attr "type" "jump") - (set_attr "iscompact" "false,maybe,false") - (set_attr "cond" "canuse")]) + (set_attr "iscompact" "false,maybe,false") ]) (define_expand "call" ;; operands[1] is stack_size_rtx @@ -4532,7 +4365,6 @@ archs4x, archs4xd" "nop%?" [(set_attr "type" "misc") (set_attr "iscompact" "true") - (set_attr "cond" "canuse") (set_attr "length" "2")]) (define_insn "nopv" @@ -4848,8 +4680,7 @@ archs4x, archs4xd" flag%?\\t%0" [(set_attr "length" "4,4,8") (set_attr "type" "misc,misc,misc") - (set_attr "predicable" "yes,no,yes") - (set_attr "cond" "clob,clob,clob")]) + (set_attr "predicable" "yes,no,yes") ]) (define_insn "brk" [(unspec_volatile [(match_operand:SI 0 "immediate_operand" "N")] @@ -4865,8 +4696,7 @@ archs4x, archs4xd" "!TARGET_ARC600_FAMILY" "rtie" [(set_attr "length" "4") - (set_attr "type" "rtie") - (set_attr "cond" "clob")]) + (set_attr "type" "rtie") ]) (define_insn "sync" [(unspec_volatile [(match_operand:SI 0 "immediate_operand" "N")] @@ -5148,7 +4978,6 @@ archs4x, archs4xd" "" "j%!%*\\t[blink]" [(set_attr "type" "return") - (set_attr "cond" "canuse") (set_attr "iscompact" "maybe") (set_attr "length" "*")]) @@ -5159,8 +4988,7 @@ archs4x, archs4xd" "TARGET_ARC600_FAMILY" "j.f\\t[%0]" [(set_attr "length" "4") - (set_attr "type" "rtie") - (set_attr "cond" "clob")]) + (set_attr "type" "rtie") ]) (define_insn "p_return_i" [(set (pc) @@ -5170,7 +4998,6 @@ archs4x, archs4xd" "reload_completed" "j%d0%!%*\\t[blink]" [(set_attr "type" "return") - (set_attr "cond" "use") (set_attr "iscompact" "maybe" ) (set (attr "length") (cond [(not (match_operand 0 "equality_comparison_operator" "")) @@ -5217,8 +5044,7 @@ archs4x, archs4xd" default: fprintf (stderr, \"unexpected length %d\\n\", get_attr_length (insn)); fflush (stderr); gcc_unreachable (); } " - [(set_attr "cond" "clob, clob, clob") - (set (attr "type") + [(set (attr "type") (if_then_else (match_test "valid_brcc_with_delay_p (operands)") (const_string "brcc") @@ -5282,7 +5108,6 @@ archs4x, archs4xd" } } [(set_attr "type" "brcc") - (set_attr "cond" "clob") (set (attr "length") (cond [(and (ge (minus (match_dup 0) (pc)) (const_int -254)) (le (minus (match_dup 0) (pc)) @@ -5374,7 +5199,6 @@ archs4x, archs4xd" "sub.f%?\\tlp_count,lp_count,1" [(set_attr "iscompact" "false") (set_attr "type" "compare") - (set_attr "cond" "set_zn") (set_attr "length" "4") (set_attr "predicable" "yes")]) @@ -5557,7 +5381,6 @@ archs4x, archs4xd" ;; [(set_attr "type" "unary,unary,dpfp_addsub,dpfp_addsub") ;; (set_attr "iscompact" "false,false,false,false") ;; (set_attr "length" "4,4,8,12") -;; (set_attr "cond" "canuse,nocond,nocond,nocond")]) ;; and this suffers from always requiring a long immediate when using ;; the floating point hardware. ;; We then want the sub[sd]f patterns to be used, so that we can load the @@ -5639,7 +5462,6 @@ archs4x, archs4xd" (set_attr "iscompact" "false") (set_attr "type" "div_rem") (set_attr "predicable" "yes,no,no,yes,no,no,yes,no") - (set_attr "cond" "canuse,nocond,nocond,canuse,nocond,nocond,canuse,nocond") ]) (define_insn "udivsi3" @@ -5652,7 +5474,6 @@ archs4x, archs4xd" (set_attr "iscompact" "false") (set_attr "type" "div_rem") (set_attr "predicable" "yes,no,no,yes,no,no,yes,no") - (set_attr "cond" "canuse,nocond,nocond,canuse,nocond,nocond,canuse,nocond") ]) (define_insn "modsi3" @@ -5665,7 +5486,6 @@ archs4x, archs4xd" (set_attr "iscompact" "false") (set_attr "type" "div_rem") (set_attr "predicable" "yes,no,no,yes,no,no,yes,no") - (set_attr "cond" "canuse,nocond,nocond,canuse,nocond,nocond,canuse,nocond") ]) (define_insn "umodsi3" @@ -5678,7 +5498,6 @@ archs4x, archs4xd" (set_attr "iscompact" "false") (set_attr "type" "div_rem") (set_attr "predicable" "yes,no,no,yes,no,no,yes,no") - (set_attr "cond" "canuse,nocond,nocond,canuse,nocond,nocond,canuse,nocond") ]) ;; SETcc instructions @@ -5694,7 +5513,6 @@ archs4x, archs4xd" (set_attr "iscompact" "false") (set_attr "type" "compare") (set_attr "predicable" "yes,no,yes,no,no,yes,no") - (set_attr "cond" "canuse,nocond,canuse,nocond,nocond,canuse,nocond") ]) (define_insn "arcsetltu" @@ -5707,7 +5525,6 @@ archs4x, archs4xd" (set_attr "iscompact" "false") (set_attr "type" "compare") (set_attr "predicable" "yes,no,yes,no,no,yes,no") - (set_attr "cond" "canuse,nocond,canuse,nocond,nocond,canuse,nocond") ]) (define_insn "arcsetgeu" @@ -5720,7 +5537,6 @@ archs4x, archs4xd" (set_attr "iscompact" "false") (set_attr "type" "compare") (set_attr "predicable" "yes,no,yes,no,no,yes,no") - (set_attr "cond" "canuse,nocond,canuse,nocond,nocond,canuse,nocond") ]) ;; Special cases of SETCC @@ -5743,8 +5559,7 @@ archs4x, archs4xd" [(set_attr "length" "4,4,4,8") (set_attr "iscompact" "false") (set_attr "type" "compare") - (set_attr "predicable" "yes,no,no,no") - (set_attr "cond" "canuse,nocond,nocond,nocond")] + (set_attr "predicable" "yes,no,no,no") ] ) (define_insn_and_split "arcsetls" @@ -5766,8 +5581,7 @@ archs4x, archs4xd" [(set_attr "length" "4,4,4,8") (set_attr "iscompact" "false") (set_attr "type" "compare") - (set_attr "predicable" "yes,no,no,no") - (set_attr "cond" "canuse,nocond,nocond,nocond")] + (set_attr "predicable" "yes,no,no,no") ] ) ; Any mode that needs to be solved by secondary reload @@ -5807,8 +5621,7 @@ archs4x, archs4xd" [(set_attr "type" "shift") (set_attr "iscompact" "false") (set_attr "length" "4,4,8,8") - (set_attr "predicable" "yes,no,no,yes") - (set_attr "cond" "canuse,nocond,nocond,canuse_limm")]) + (set_attr "predicable" "yes,no,no,yes") ]) (define_insn "kflag" [(unspec_volatile [(match_operand:SI 0 "nonmemory_operand" "rL,I,Cal")] @@ -5820,8 +5633,7 @@ archs4x, archs4xd" kflag%?\\t%0" [(set_attr "length" "4,4,8") (set_attr "type" "misc,misc,misc") - (set_attr "predicable" "yes,no,yes") - (set_attr "cond" "clob,clob,clob")]) + (set_attr "predicable" "yes,no,yes") ]) (define_insn "clri" [(set (match_operand:SI 0 "dest_reg_operand" "=r") @@ -6474,8 +6286,7 @@ archs4x, archs4xd" "dmach\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "no") - (set_attr "cond" "nocond")]) + (set_attr "predicable" "no") ]) ; The same for the unsigned variant, but using VMAC2HU instruction. (define_expand "umaddhisi4" @@ -6503,8 +6314,7 @@ archs4x, archs4xd" "dmachu\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "no") - (set_attr "cond" "nocond")]) + (set_attr "predicable" "no") ]) (define_expand "maddsidi4" [(match_operand:DI 0 "register_operand" "") @@ -6562,8 +6372,7 @@ archs4x, archs4xd" "macd\\t%0,%1,%2" [(set_attr "length" "4,4,8") (set_attr "type" "multi") - (set_attr "predicable" "yes,no,no") - (set_attr "cond" "canuse,nocond,nocond")]) + (set_attr "predicable" "yes,no,no") ]) (define_insn "mac" [(set (reg:DI ARCV2_ACC) @@ -6575,8 +6384,7 @@ archs4x, archs4xd" "mac 0,%0,%1" [(set_attr "length" "4,8") (set_attr "type" "multi") - (set_attr "predicable" "no") - (set_attr "cond" "nocond")]) + (set_attr "predicable" "no") ]) (define_peephole2 [(set (reg:DI ARCV2_ACC) @@ -6605,8 +6413,7 @@ archs4x, archs4xd" "mac\\t%0,%1,%2" [(set_attr "length" "4,8") (set_attr "type" "multi") - (set_attr "predicable" "no") - (set_attr "cond" "nocond")]) + (set_attr "predicable" "no") ]) (define_expand "umaddsidi4" [(match_operand:DI 0 "register_operand" "") @@ -6664,8 +6471,7 @@ archs4x, archs4xd" "macdu\\t%0,%1,%2" [(set_attr "length" "4,4,8") (set_attr "type" "multi") - (set_attr "predicable" "yes,no,no") - (set_attr "cond" "canuse,nocond,nocond")]) + (set_attr "predicable" "yes,no,no") ]) (define_insn "macu" [(set (reg:DI ARCV2_ACC) @@ -6677,8 +6483,7 @@ archs4x, archs4xd" "macu 0,%0,%1" [(set_attr "length" "4,8") (set_attr "type" "multi") - (set_attr "predicable" "no") - (set_attr "cond" "nocond")]) + (set_attr "predicable" "no") ]) (define_peephole2 [(set (reg:DI ARCV2_ACC) @@ -6707,8 +6512,7 @@ archs4x, archs4xd" "macu\\t%0,%1,%2" [(set_attr "length" "4,8") (set_attr "type" "multi") - (set_attr "predicable" "no") - (set_attr "cond" "nocond")]) + (set_attr "predicable" "no") ]) (define_insn "mpyd_arcv2hs" [(set (match_operand:DI 0 "even_register_operand" "=r") @@ -6779,8 +6583,7 @@ archs4x, archs4xd" "add%2%?\\t%0,%3,%1" [(set_attr "length" "*,4,8") (set_attr "predicable" "yes,no,no") - (set_attr "iscompact" "maybe,false,false") - (set_attr "cond" "canuse,nocond,nocond")]) + (set_attr "iscompact" "maybe,false,false") ]) (define_insn "*add_shift2" [(set (match_operand:SI 0 "register_operand" "=q,r,r") @@ -6791,8 +6594,7 @@ archs4x, archs4xd" "add%3%?\\t%0,%1,%2" [(set_attr "length" "*,4,8") (set_attr "predicable" "yes,no,no") - (set_attr "iscompact" "maybe,false,false") - (set_attr "cond" "canuse,nocond,nocond")]) + (set_attr "iscompact" "maybe,false,false") ]) (define_insn "*sub_shift" [(set (match_operand:SI 0"register_operand" "=r,r,r") @@ -6802,7 +6604,6 @@ archs4x, archs4xd" "" "sub%3\\t%0,%1,%2" [(set_attr "length" "4,4,8") - (set_attr "cond" "canuse,nocond,nocond") (set_attr "predicable" "yes,no,no")]) (define_insn "*sub_shift_cmp0_noout" diff --git a/gcc/config/arc/fpu.md b/gcc/config/arc/fpu.md index 14ebd865206e..c3fe1d0fd807 100644 --- a/gcc/config/arc/fpu.md +++ b/gcc/config/arc/fpu.md @@ -17,7 +17,6 @@ (set_attr "iscompact" "false") (set_attr "type" "fpu") (set_attr "predicable" "yes,no,no,yes,no,no") - (set_attr "cond" "canuse,nocond,nocond,canuse_limm,nocond,nocond") ]) ;; Subtraction @@ -33,7 +32,6 @@ (set_attr "iscompact" "false") (set_attr "type" "fpu") (set_attr "predicable" "yes,no,no,yes,no,no") - (set_attr "cond" "canuse,nocond,nocond,canuse_limm,nocond,nocond") ]) ;; Multiplication @@ -49,7 +47,6 @@ (set_attr "iscompact" "false") (set_attr "type" "fpu") (set_attr "predicable" "yes,no,yes,no,no") - (set_attr "cond" "canuse,nocond,canuse_limm,nocond,nocond") ]) ;; Multiplication with addition/subtraction @@ -96,7 +93,6 @@ "fsmadd%? %0,%1,%2" [(set_attr "length" "4,4,8,8,8") (set_attr "predicable" "yes,no,yes,no,no") - (set_attr "cond" "canuse,nocond,canuse_limm,nocond,nocond") (set_attr "iscompact" "false") (set_attr "type" "fpu_fuse")]) @@ -111,7 +107,6 @@ "fsmsub%?\\t%0,%1,%2" [(set_attr "length" "4,4,8,8,8") (set_attr "predicable" "yes,no,yes,no,no") - (set_attr "cond" "canuse,nocond,canuse_limm,nocond,nocond") (set_attr "iscompact" "false") (set_attr "type" "fpu_fuse")]) @@ -181,7 +176,6 @@ "fdmadd%?\\t%0,%1,%2" [(set_attr "length" "4,4") (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond") (set_attr "iscompact" "false") (set_attr "type" "fpu_fuse")]) @@ -194,7 +188,6 @@ "fdmsub%?\\t%0,%1,%2" [(set_attr "length" "4,4") (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond") (set_attr "iscompact" "false") (set_attr "type" "fpu_fuse")]) @@ -211,7 +204,6 @@ (set_attr "iscompact" "false") (set_attr "type" "fpu_sdiv") (set_attr "predicable" "yes,no,yes,no,no") - (set_attr "cond" "canuse,nocond,canuse_limm,nocond,nocond") ]) ;; Negation @@ -238,7 +230,6 @@ "fscmp%?\\t%0,%1" [(set_attr "length" "4,4,8") (set_attr "iscompact" "false") - (set_attr "cond" "set") (set_attr "type" "fpu") (set_attr "predicable" "yes")]) @@ -250,7 +241,6 @@ "fscmpf%?\\t%0,%1" [(set_attr "length" "4,4,8") (set_attr "iscompact" "false") - (set_attr "cond" "set") (set_attr "type" "fpu") (set_attr "predicable" "yes")]) @@ -263,7 +253,6 @@ "fscmp\\t%0,%1\\n\\tmov.v.f\\t0,0\\t;set Z flag" [(set_attr "length" "8,8,12") (set_attr "iscompact" "false") - (set_attr "cond" "set") (set_attr "type" "fpu")]) ;; :::::::::::::::::::: @@ -283,7 +272,6 @@ (set_attr "iscompact" "false") (set_attr "type" "fpu") (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond") ]) ;; Subtraction @@ -297,7 +285,6 @@ (set_attr "iscompact" "false") (set_attr "type" "fpu") (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond") ]) ;; Multiplication @@ -311,7 +298,6 @@ (set_attr "iscompact" "false") (set_attr "type" "fpu") (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond") ]) ;; Division @@ -325,7 +311,6 @@ (set_attr "iscompact" "false") (set_attr "type" "fpu_ddiv") (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond") ]) ;; Square root @@ -346,7 +331,6 @@ "fdcmp%? %0, %1" [(set_attr "length" "4") (set_attr "iscompact" "false") - (set_attr "cond" "set") (set_attr "type" "fpu") (set_attr "predicable" "yes")]) @@ -358,7 +342,6 @@ "fdcmpf%? %0, %1" [(set_attr "length" "4") (set_attr "iscompact" "false") - (set_attr "cond" "set") (set_attr "type" "fpu") (set_attr "predicable" "yes")]) @@ -371,7 +354,6 @@ "fdcmp %0, %1\\n\\tmov.v.f 0,0\\t;set Z flag" [(set_attr "length" "8") (set_attr "iscompact" "false") - (set_attr "cond" "set") (set_attr "type" "fpu")]) ;; :::::::::::::::::::: diff --git a/gcc/config/arc/fpx.md b/gcc/config/arc/fpx.md index 29c70e6a715e..dabff8f92c5b 100644 --- a/gcc/config/arc/fpx.md +++ b/gcc/config/arc/fpx.md @@ -634,9 +634,7 @@ "TARGET_FPX_QUARK" "dsp_fp_cmp\\t%2,%0,%1\\n\\trsub.f\\t0,%2,7\\n\\tcmp.nc\\t%2,1\\n\\tcmp.hi\\t%2,3" [(set_attr "length" "16") - (set_attr "cond" "set") - (set_attr "predicable" "no") - (set_attr "cond" "nocond")]) + (set_attr "predicable" "no") ]) (define_insn "*cmpsf_quark_ord" [(set (reg:CC_FP_ORD CC_REG) @@ -646,9 +644,7 @@ "TARGET_FPX_QUARK" "dsp_fp_cmp\\t%2,%0,%1\\n\\tadd.f\\t%2,%2,-8" [(set_attr "length" "8") - (set_attr "cond" "set") - (set_attr "predicable" "no") - (set_attr "cond" "nocond")]) + (set_attr "predicable" "no") ]) (define_insn "*cmpsf_quark_uneq" [(set (reg:CC_FP_UNEQ CC_REG) @@ -658,9 +654,7 @@ "TARGET_FPX_QUARK" "dsp_fp_cmp\\t%2,%0,%1\\n\\ttst\\t%2,6" [(set_attr "length" "8") - (set_attr "cond" "set") - (set_attr "predicable" "no") - (set_attr "cond" "nocond")]) + (set_attr "predicable" "no") ]) (define_insn "*cmpsf_quark_eq" [(set (reg:CC_Z CC_REG) @@ -670,9 +664,7 @@ "TARGET_FPX_QUARK" "dsp_fp_cmp\\t%2,%0,%1\\n\\ttst\\t%2,0x0E" [(set_attr "length" "8") - (set_attr "cond" "set") - (set_attr "predicable" "no") - (set_attr "cond" "nocond")]) + (set_attr "predicable" "no") ]) (define_insn "*divsf3_quark" [(set (match_operand:SF 0 "register_operand" "=r") @@ -681,8 +673,7 @@ "TARGET_FPX_QUARK" "dsp_fp_div\\t%0,%1,%2" [(set_attr "length" "4") - (set_attr "predicable" "no") - (set_attr "cond" "nocond")]) + (set_attr "predicable" "no") ]) (define_insn "*sqrtsf2_quark" [(set (match_operand:SF 0 "register_operand" "=r") @@ -690,8 +681,7 @@ "TARGET_FPX_QUARK" "dsp_fp_sqrt\\t%0,%1" [(set_attr "length" "4") - (set_attr "predicable" "no") - (set_attr "cond" "nocond")]) + (set_attr "predicable" "no") ]) ;; SF->SI (using rounding towards zero) (define_insn "*fix_truncsfsi2_quark" @@ -700,8 +690,7 @@ "TARGET_FPX_QUARK" "dsp_fp_flt2i\\t%0,%1" [(set_attr "length" "4") - (set_attr "predicable" "no") - (set_attr "cond" "nocond")]) + (set_attr "predicable" "no") ]) ;; SI->SF (define_insn "*floatsisf2_quark" @@ -710,6 +699,5 @@ "TARGET_FPX_QUARK" "dsp_fp_i2flt\\t%0,%1" [(set_attr "length" "4") - (set_attr "predicable" "no") - (set_attr "cond" "nocond")]) + (set_attr "predicable" "no") ]) diff --git a/gcc/config/arc/simdext.md b/gcc/config/arc/simdext.md index 003f2c4e6e60..15996a1d9712 100644 --- a/gcc/config/arc/simdext.md +++ b/gcc/config/arc/simdext.md @@ -176,8 +176,7 @@ "TARGET_SIMD_SET" "vld128\\t%0,[i%2,%3]" [(set_attr "type" "simd_vload128") - (set_attr "length" "4") - (set_attr "cond" "nocond")] + (set_attr "length" "4") ] ) (define_insn "vst128_insn" @@ -188,8 +187,7 @@ "TARGET_SIMD_SET" "vst128\\t%3,[i%1,%2]" [(set_attr "type" "simd_vstore") - (set_attr "length" "4") - (set_attr "cond" "nocond")] + (set_attr "length" "4") ] ) (define_insn "vst64_insn" @@ -206,8 +204,7 @@ "TARGET_SIMD_SET" "vst64\\t%3,[i%1,%2]" [(set_attr "type" "simd_vstore") - (set_attr "length" "4") - (set_attr "cond" "nocond")] + (set_attr "length" "4") ] ) (define_insn "movv8hi_insn" @@ -219,8 +216,7 @@ vst128r\\t%1,%0 vmvzw\\t%0,%1,0xffff" [(set_attr "type" "simd_vload128,simd_vstore,simd_vmove_else_zero") - (set_attr "length" "8,8,4") - (set_attr "cond" "nocond, nocond, nocond")]) + (set_attr "length" "8,8,4") ]) (define_insn "movti_insn" [(set (match_operand:TI 0 "vector_register_or_memory_operand" "=v,m,v") @@ -231,8 +227,7 @@ vst128r\\t%1,%0 vmvzw\\t%0,%1,0xffff" [(set_attr "type" "simd_vload128,simd_vstore,simd_vmove_else_zero") - (set_attr "length" "8,8,4") - (set_attr "cond" "nocond, nocond, nocond")]) + (set_attr "length" "8,8,4") ]) ;; V V V Insns (define_insn "vaddaw_insn" @@ -243,8 +238,7 @@ "TARGET_SIMD_SET" "vaddaw\\t%0,%1,%2" [(set_attr "type" "simd_varith_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vaddw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -254,8 +248,7 @@ "TARGET_SIMD_SET" "vaddw\\t%0,%1,2" [(set_attr "type" "simd_varith_1cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vavb_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -265,8 +258,7 @@ "TARGET_SIMD_SET" "vavb\\t%0,%1,%2" [(set_attr "type" "simd_varith_1cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vavrb_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -276,8 +268,7 @@ "TARGET_SIMD_SET" "vavrb\\t%0,%1,%2" [(set_attr "type" "simd_varith_1cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vdifaw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -287,8 +278,7 @@ "TARGET_SIMD_SET" "vdifaw\\t%0,%1,%2" [(set_attr "type" "simd_varith_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vdifw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -298,8 +288,7 @@ "TARGET_SIMD_SET" "vdifw\\t%0,%1,%2" [(set_attr "type" "simd_varith_1cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmaxaw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -309,8 +298,7 @@ "TARGET_SIMD_SET" "vmaxaw\\t%0,%1,2" [(set_attr "type" "simd_varith_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmaxw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -320,8 +308,7 @@ "TARGET_SIMD_SET" "vmaxw\\t%0,%1,%2" [(set_attr "type" "simd_varith_1cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vminaw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -331,8 +318,7 @@ "TARGET_SIMD_SET" "vminaw\\t%0,%1,%2" [(set_attr "type" "simd_varith_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vminw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -342,8 +328,7 @@ "TARGET_SIMD_SET" "vminw\\t%0,%1,%2" [(set_attr "type" "simd_varith_1cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmulaw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -353,8 +338,7 @@ "TARGET_SIMD_SET" "vmulaw\\t%0,%1,%2" [(set_attr "type" "simd_varith_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmulfaw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -364,8 +348,7 @@ "TARGET_SIMD_SET" "vmulfaw\\t%0,%1,%2" [(set_attr "type" "simd_varith_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmulfw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -375,8 +358,7 @@ "TARGET_SIMD_SET" "vmulfw\\t%0,%1,%2" [(set_attr "type" "simd_varith_2cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmulw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -386,8 +368,7 @@ "TARGET_SIMD_SET" "vmulw\\t%0,%1,%2" [(set_attr "type" "simd_varith_2cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vsubaw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -397,8 +378,7 @@ "TARGET_SIMD_SET" "vsubaw\\t%0,%1,%2" [(set_attr "type" "simd_varith_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vsubw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -408,8 +388,7 @@ "TARGET_SIMD_SET" "vsubw\\t%0,%1,%2" [(set_attr "type" "simd_varith_1cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vsummw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -419,8 +398,7 @@ "TARGET_SIMD_SET" "vsummw\\t%0,%1,%2" [(set_attr "type" "simd_varith_2cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vand_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -430,8 +408,7 @@ "TARGET_SIMD_SET" "vand\\t%0,%1,%2" [(set_attr "type" "simd_vlogic") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vandaw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -441,8 +418,7 @@ "TARGET_SIMD_SET" "vandaw\\t%0,%1,%2" [(set_attr "type" "simd_vlogic_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vbic_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -452,8 +428,7 @@ "TARGET_SIMD_SET" "vbic\\t%0,%1,%2" [(set_attr "type" "simd_vlogic") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vbicaw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -463,8 +438,7 @@ "TARGET_SIMD_SET" "vbicaw\\t%0,%1,%2" [(set_attr "type" "simd_vlogic_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vor_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -474,8 +448,7 @@ "TARGET_SIMD_SET" "vor\\t%0,%1,%2" [(set_attr "type" "simd_vlogic") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vxor_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -485,8 +458,7 @@ "TARGET_SIMD_SET" "vxor\\t%0,%1,%2" [(set_attr "type" "simd_vlogic") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vxoraw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -496,8 +468,7 @@ "TARGET_SIMD_SET" "vxoraw\\t%0,%1,%2" [(set_attr "type" "simd_vlogic_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "veqw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -507,8 +478,7 @@ "TARGET_SIMD_SET" "veqw\\t%0,%1,%2" [(set_attr "type" "simd_vcompare") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vlew_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -518,8 +488,7 @@ "TARGET_SIMD_SET" "vlew\\t%0,%1,%2" [(set_attr "type" "simd_vcompare") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vltw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -529,8 +498,7 @@ "TARGET_SIMD_SET" "vltw\\t%0,%1,%2" [(set_attr "type" "simd_vcompare") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vnew_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -540,8 +508,7 @@ "TARGET_SIMD_SET" "vnew\\t%0,%1,%2" [(set_attr "type" "simd_vcompare") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmr1aw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -551,8 +518,7 @@ "TARGET_SIMD_SET" "vmr1aw\\t%0,%1,%2" [(set_attr "type" "simd_valign_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmr1w_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -562,8 +528,7 @@ "TARGET_SIMD_SET" "vmr1w\\t%0,%1,%2" [(set_attr "type" "simd_valign") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmr2aw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -573,8 +538,7 @@ "TARGET_SIMD_SET" "vmr2aw\\t%0,%1,%2" [(set_attr "type" "simd_valign_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmr2w_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -584,8 +548,7 @@ "TARGET_SIMD_SET" "vmr2w\\t%0,%1,%2" [(set_attr "type" "simd_valign") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmr3aw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -595,8 +558,7 @@ "TARGET_SIMD_SET" "vmr3aw\\t%0,%1,%2" [(set_attr "type" "simd_valign_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmr3w_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -606,8 +568,7 @@ "TARGET_SIMD_SET" "vmr3w\\t%0,%1,%2" [(set_attr "type" "simd_valign") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmr4aw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -617,8 +578,7 @@ "TARGET_SIMD_SET" "vmr4aw\\t%0,%1,%2" [(set_attr "type" "simd_valign_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmr4w_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -628,8 +588,7 @@ "TARGET_SIMD_SET" "vmr4w\\t%0,%1,%2" [(set_attr "type" "simd_valign") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmr5aw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -639,8 +598,7 @@ "TARGET_SIMD_SET" "vmr5aw\\t%0,%1,%2" [(set_attr "type" "simd_valign_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmr5w_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -650,8 +608,7 @@ "TARGET_SIMD_SET" "vmr5w\\t%0,%1,%2" [(set_attr "type" "simd_valign") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmr6aw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -661,8 +618,7 @@ "TARGET_SIMD_SET" "vmr6aw\\t%0,%1,%2" [(set_attr "type" "simd_valign_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmr6w_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -672,8 +628,7 @@ "TARGET_SIMD_SET" "vmr6w\\t%0,%1,%2" [(set_attr "type" "simd_valign") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmr7aw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -683,8 +638,7 @@ "TARGET_SIMD_SET" "vmr7aw\\t%0,%1,%2" [(set_attr "type" "simd_valign_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmr7w_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -694,8 +648,7 @@ "TARGET_SIMD_SET" "vmr7w\\t%0,%1,%2" [(set_attr "type" "simd_valign") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmrb_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -705,8 +658,7 @@ "TARGET_SIMD_SET" "vmrb\\t%0,%1,%2" [(set_attr "type" "simd_valign") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vh264f_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -716,8 +668,7 @@ "TARGET_SIMD_SET" "vh264f\\t%0,%1,%2" [(set_attr "type" "simd_vspecial_3cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vh264ft_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -727,8 +678,7 @@ "TARGET_SIMD_SET" "vh264ft\\t%0,%1,%2" [(set_attr "type" "simd_vspecial_3cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vh264fw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -738,8 +688,7 @@ "TARGET_SIMD_SET" "vh264fw\\t%0,%1,%2" [(set_attr "type" "simd_vspecial_3cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vvc1f_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -749,8 +698,7 @@ "TARGET_SIMD_SET" "vvc1f\\t%0,%1,%2" [(set_attr "type" "simd_vspecial_3cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vvc1ft_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -760,8 +708,7 @@ "TARGET_SIMD_SET" "vvc1ft\\t%0,%1,%2" [(set_attr "type" "simd_vspecial_3cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) @@ -775,8 +722,7 @@ "TARGET_SIMD_SET" "vbaddw\\t%0,%1,%2" [(set_attr "type" "simd_varith_1cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vbmaxw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -786,8 +732,7 @@ "TARGET_SIMD_SET" "vbmaxw\\t%0,%1,%2" [(set_attr "type" "simd_varith_1cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vbminw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -797,8 +742,7 @@ "TARGET_SIMD_SET" "vbminw\\t%0,%1,%2" [(set_attr "type" "simd_varith_1cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vbmulaw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -808,8 +752,7 @@ "TARGET_SIMD_SET" "vbmulaw\\t%0,%1,%2" [(set_attr "type" "simd_varith_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vbmulfw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -819,8 +762,7 @@ "TARGET_SIMD_SET" "vbmulfw\\t%0,%1,%2" [(set_attr "type" "simd_varith_2cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vbmulw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -830,8 +772,7 @@ "TARGET_SIMD_SET" "vbmulw\\t%0,%1,%2" [(set_attr "type" "simd_varith_2cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vbrsubw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -841,8 +782,7 @@ "TARGET_SIMD_SET" "vbrsubw\\t%0,%1,%2" [(set_attr "type" "simd_varith_1cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vbsubw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -852,8 +792,7 @@ "TARGET_SIMD_SET" "vbsubw\\t%0,%1,%2" [(set_attr "type" "simd_varith_1cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) ; Va, Vb, Ic instructions ; Va, Vb, u6 instructions @@ -865,8 +804,7 @@ "TARGET_SIMD_SET" "vasrrwi\\t%0,%1,%2" [(set_attr "type" "simd_varith_2cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vasrsrwi_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -876,8 +814,7 @@ "TARGET_SIMD_SET" "vasrsrwi\\t%0,%1,%2" [(set_attr "type" "simd_varith_2cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vasrwi_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -887,8 +824,7 @@ "TARGET_SIMD_SET" "vasrwi\\t%0,%1,%2" [(set_attr "type" "simd_varith_1cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vasrpwbi_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -898,8 +834,7 @@ "TARGET_SIMD_SET" "vasrpwbi\\t%0,%1,%2" [(set_attr "type" "simd_vpack") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vasrrpwbi_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -909,8 +844,7 @@ "TARGET_SIMD_SET" "vasrrpwbi\\t%0,%1,%2" [(set_attr "type" "simd_vpack") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vsr8awi_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -920,8 +854,7 @@ "TARGET_SIMD_SET" "vsr8awi\\t%0,%1,%2" [(set_attr "type" "simd_valign_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vsr8i_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -931,8 +864,7 @@ "TARGET_SIMD_SET" "vsr8i\\t%0,%1,%2" [(set_attr "type" "simd_valign") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) ;; Va, Vb, u8 (simm) insns @@ -944,8 +876,7 @@ "TARGET_SIMD_SET" "vmvaw\\t%0,%1,%2" [(set_attr "type" "simd_vmove_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmvw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -955,8 +886,7 @@ "TARGET_SIMD_SET" "vmvw\\t%0,%1,%2" [(set_attr "type" "simd_vmove") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmvzw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -966,8 +896,7 @@ "TARGET_SIMD_SET" "vmvzw\\t%0,%1,%2" [(set_attr "type" "simd_vmove_else_zero") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vd6tapf_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -977,8 +906,7 @@ "TARGET_SIMD_SET" "vd6tapf\\t%0,%1,%2" [(set_attr "type" "simd_vspecial_4cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) ;; Va, rlimm, u8 (simm) insns (define_insn "vmovaw_insn" @@ -989,8 +917,7 @@ "TARGET_SIMD_SET" "vmovaw\\t%0,%1,%2" [(set_attr "type" "simd_vmove_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmovw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -1000,8 +927,7 @@ "TARGET_SIMD_SET" "vmovw\\t%0,%1,%2" [(set_attr "type" "simd_vmove") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vmovzw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -1011,8 +937,7 @@ "TARGET_SIMD_SET" "vmovzw\\t%0,%1,%2" [(set_attr "type" "simd_vmove_else_zero") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) ;; Va, rlimm, Ic insns (define_insn "vsr8_insn" @@ -1024,8 +949,7 @@ "TARGET_SIMD_SET" "vsr8\\t%0,%1,i%2" [(set_attr "type" "simd_valign") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vasrw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -1036,8 +960,7 @@ "TARGET_SIMD_SET" "vasrw\\t%0,%1,i%2" [(set_attr "type" "simd_varith_1cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vsr8aw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -1048,8 +971,7 @@ "TARGET_SIMD_SET" "vsr8aw\\t%0,%1,i%2" [(set_attr "type" "simd_valign_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) ;; Va, Vb insns (define_insn "vabsaw_insn" @@ -1059,8 +981,7 @@ "TARGET_SIMD_SET" "vabsaw\\t%0,%1" [(set_attr "type" "simd_varith_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vabsw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -1069,8 +990,7 @@ "TARGET_SIMD_SET" "vabsw\\t%0,%1" [(set_attr "type" "simd_varith_1cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vaddsuw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -1079,8 +999,7 @@ "TARGET_SIMD_SET" "vaddsuw\\t%0,%1" [(set_attr "type" "simd_varith_1cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vsignw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -1089,8 +1008,7 @@ "TARGET_SIMD_SET" "vsignw\\t%0,%1" [(set_attr "type" "simd_varith_1cycle") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vexch1_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -1099,8 +1017,7 @@ "TARGET_SIMD_SET" "vexch1\\t%0,%1" [(set_attr "type" "simd_vpermute") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vexch2_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -1109,8 +1026,7 @@ "TARGET_SIMD_SET" "vexch2\\t%0,%1" [(set_attr "type" "simd_vpermute") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vexch4_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -1119,8 +1035,7 @@ "TARGET_SIMD_SET" "vexch4\\t%0,%1" [(set_attr "type" "simd_vpermute") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vupbaw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -1129,8 +1044,7 @@ "TARGET_SIMD_SET" "vupbaw\\t%0,%1" [(set_attr "type" "simd_vpack_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vupbw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -1139,8 +1053,7 @@ "TARGET_SIMD_SET" "vupbw\\t%0,%1" [(set_attr "type" "simd_vpack") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vupsbaw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -1149,8 +1062,7 @@ "TARGET_SIMD_SET" "vupsbaw\\t%0,%1" [(set_attr "type" "simd_vpack_with_acc") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vupsbw_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -1159,8 +1071,7 @@ "TARGET_SIMD_SET" "vupsbw\\t%0,%1" [(set_attr "type" "simd_vpack") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) ; DMA setup instructions (define_insn "vdirun_insn" @@ -1171,8 +1082,7 @@ "TARGET_SIMD_SET" "vdirun\\t%1,%2" [(set_attr "type" "simd_dma") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vdorun_insn" [(set (match_operand:SI 0 "arc_simd_dma_register_operand" "=d") @@ -1182,8 +1092,7 @@ "TARGET_SIMD_SET" "vdorun\\t%1,%2" [(set_attr "type" "simd_dma") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vdiwr_insn" [(set (match_operand:SI 0 "arc_simd_dma_register_operand" "=d,d") @@ -1192,8 +1101,7 @@ "TARGET_SIMD_SET" "vdiwr\\t%0,%1" [(set_attr "type" "simd_dma") - (set_attr "length" "4,8") - (set_attr "cond" "nocond,nocond")]) + (set_attr "length" "4,8") ]) (define_insn "vdowr_insn" [(set (match_operand:SI 0 "arc_simd_dma_register_operand" "=d,d") @@ -1202,8 +1110,7 @@ "TARGET_SIMD_SET" "vdowr\\t%0,%1" [(set_attr "type" "simd_dma") - (set_attr "length" "4,8") - (set_attr "cond" "nocond,nocond")]) + (set_attr "length" "4,8") ]) ;; vector record and run instructions (define_insn "vrec_insn" @@ -1212,8 +1119,7 @@ "TARGET_SIMD_SET" "vrec\\t%0" [(set_attr "type" "simd_vcontrol") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vrun_insn" [(unspec_volatile [(match_operand:SI 0 "nonmemory_operand" "r")] @@ -1221,8 +1127,7 @@ "TARGET_SIMD_SET" "vrun\\t%0" [(set_attr "type" "simd_vcontrol") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vrecrun_insn" [(unspec_volatile [(match_operand:SI 0 "nonmemory_operand" "r")] @@ -1230,8 +1135,7 @@ "TARGET_SIMD_SET" "vrecrun\\t%0" [(set_attr "type" "simd_vcontrol") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vendrec_insn" [(unspec_volatile [(match_operand:SI 0 "nonmemory_operand" "r")] @@ -1239,8 +1143,7 @@ "TARGET_SIMD_SET" "vendrec\\t%0" [(set_attr "type" "simd_vcontrol") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vld32wh_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -1260,8 +1163,7 @@ "TARGET_SIMD_SET" "vld32wh\\t%0,[i%3,%1]" [(set_attr "type" "simd_vload") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vld32wl_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -1281,8 +1183,7 @@ "TARGET_SIMD_SET" "vld32wl\\t%0,[i%3,%1]" [(set_attr "type" "simd_vload") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vld64w_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -1296,8 +1197,7 @@ "TARGET_SIMD_SET" "vld64w\\t%0,[i%2,%3]" [(set_attr "type" "simd_vload") - (set_attr "length" "4") - (set_attr "cond" "nocond")] + (set_attr "length" "4") ] ) (define_insn "vld64_insn" @@ -1317,8 +1217,7 @@ "TARGET_SIMD_SET" "vld64\\t%0,[i%3,%1]" [(set_attr "type" "simd_vload") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vld32_insn" [(set (match_operand:V8HI 0 "vector_register_operand" "=v") @@ -1340,8 +1239,7 @@ "TARGET_SIMD_SET" "vld32\\t%0,[i%3,%1]" [(set_attr "type" "simd_vload") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vst16_n_insn" [(set (mem:HI @@ -1355,8 +1253,7 @@ "TARGET_SIMD_SET" "vst16_%4\\t%3,[i%2,%0]" [(set_attr "type" "simd_vstore") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) (define_insn "vst32_n_insn" [(set (mem:SI @@ -1371,8 +1268,7 @@ "TARGET_SIMD_SET" "vst32_%4\\t%3,[i%2,%0]" [(set_attr "type" "simd_vstore") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) ;; SIMD unit interrupt (define_insn "vinti_insn" @@ -1381,8 +1277,7 @@ "TARGET_SIMD_SET" "vinti\\t%0" [(set_attr "type" "simd_vcontrol") - (set_attr "length" "4") - (set_attr "cond" "nocond")]) + (set_attr "length" "4") ]) ;; New ARCv2 SIMD extensions @@ -1516,8 +1411,7 @@ "vadd%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) (define_insn "sub3" [(set (match_operand:VCT 0 "register_operand" "=r,r") @@ -1527,8 +1421,7 @@ "vsub%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) ;; Combined arithmetic ops (define_insn "addsub3" @@ -1546,8 +1439,7 @@ "vaddsub%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) (define_insn "subadd3" [(set (match_operand:VDV 0 "register_operand" "=r,r") @@ -1564,8 +1456,7 @@ "vsubadd%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) (define_insn "addsubv4hi3" [(set (match_operand:V4HI 0 "even_register_operand" "=r,r") @@ -1588,8 +1479,7 @@ "vaddsub4h%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) (define_insn "subaddv4hi3" [(set (match_operand:V4HI 0 "even_register_operand" "=r,r") @@ -1612,8 +1502,7 @@ "vsubadd4h%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) ;; Multiplication (define_insn "dmpyh" @@ -1642,8 +1531,7 @@ "dmpyh%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) ;; We can use dmac as well here. To be investigated which version ;; brings more. @@ -1731,8 +1619,7 @@ "vmpy2h%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) (define_insn "arc_vec_multacc_lo_v4hi" [(set (reg:V2SI ARCV2_ACC) @@ -1747,8 +1634,7 @@ "vmpy2h%?\\t0,%0,%1" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "no") - (set_attr "cond" "nocond")]) + (set_attr "predicable" "no") ]) (define_expand "vec_widen_mult_lo_v4hi" [(set (match_operand:V2SI 0 "even_register_operand" "") @@ -1787,8 +1673,7 @@ "vmpy2h%?\\t%0,%R1,%R2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) (define_expand "vec_widen_mult_hi_v4hi" [(set (match_operand:V2SI 0 "even_register_operand") @@ -1852,8 +1737,7 @@ "dmach%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) (define_insn "dmachu" [(set (match_operand:SI 0 "register_operand" "=r,r") @@ -1866,8 +1750,7 @@ "dmachu%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) (define_insn "dmacwh" [(set (match_operand:DI 0 "even_register_operand" "=r,r") @@ -1880,8 +1763,7 @@ "dmacwh%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) (define_insn "dmacwhu" [(set (match_operand:DI 0 "register_operand" "=r,r") @@ -1894,8 +1776,7 @@ "dmacwhu%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) (define_insn "vmac2h" [(set (match_operand:V2SI 0 "even_register_operand" "=r,r") @@ -1908,8 +1789,7 @@ "vmac2h%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) (define_insn "vmac2hu" [(set (match_operand:V2SI 0 "even_register_operand" "=r,r") @@ -1922,8 +1802,7 @@ "vmac2hu%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) (define_insn "vmpy2h" [(set (match_operand:V2SI 0 "even_register_operand" "=r,r") @@ -1935,8 +1814,7 @@ "vmpy2h%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) (define_insn "vmpy2hu" [(set (match_operand:V2SI 0 "even_register_operand" "=r,r") @@ -1948,8 +1826,7 @@ "vmpy2hu%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) (define_insn "qmach" [(set (match_operand:DI 0 "even_register_operand" "=r,r") @@ -1962,8 +1839,7 @@ "qmach%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) (define_insn "qmachu" [(set (match_operand:DI 0 "even_register_operand" "=r,r") @@ -1976,8 +1852,7 @@ "qmachu%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) (define_insn "qmpyh" [(set (match_operand:DI 0 "even_register_operand" "=r,r") @@ -1989,8 +1864,7 @@ "qmpyh%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) (define_insn "qmpyhu" [(set (match_operand:DI 0 "even_register_operand" "=r,r") @@ -2002,8 +1876,7 @@ "qmpyhu%?\\t%0,%1,%2" [(set_attr "length" "4") (set_attr "type" "multi") - (set_attr "predicable" "yes,no") - (set_attr "cond" "canuse,nocond")]) + (set_attr "predicable" "yes,no") ]) ;; Emulated vector instructions. (define_insn_and_split "v2si3" From 6da0b1468bfc4fbf4e8029b9dd634c31cb8261d8 Mon Sep 17 00:00:00 2001 From: Michiel Derhaeg Date: Thu, 17 Sep 2026 11:38:06 +0300 Subject: [PATCH 149/584] arc: Don't advertise optab for unsupported vector modes [PR126243] v2si3 advertised V2SImode optabs (mul/div/smin/smax) whenever the scalar op existed, but V2SImode is only a supported vector mode under TARGET_PLUS_QMACW. Since r15-5493-g485ab50c204ddb ("Add helpers to test whether an optab can be implemented") the middle-end keeps the operation vectorized on such cores. The operands degrade to DImode and it is expanded as a double-word scalar op: mul and div silently compute on the packed pair, min and max ICE in expand_expr_real_2 for lack of a DImode expansion. Require TARGET_PLUS_QMACW so the optab matches arc_vector_mode_supported_p. No tests added because this is already covered by existing tests. PR target/126243 gcc/ChangeLog: * config/arc/simdext.md (v2si3): Require TARGET_PLUS_QMACW. Signed-off-by: Michiel Derhaeg --- gcc/config/arc/simdext.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/config/arc/simdext.md b/gcc/config/arc/simdext.md index 15996a1d9712..4f9bed795ab5 100644 --- a/gcc/config/arc/simdext.md +++ b/gcc/config/arc/simdext.md @@ -1883,7 +1883,7 @@ [(set (match_operand:V2SI 0 "register_operand" "=r") (EMUVEC:V2SI (match_operand:V2SI 1 "register_operand" "r") (match_operand:V2SI 2 "nonmemory_operand" "ri")))] - "" + "TARGET_PLUS_QMACW" "#" "reload_completed" [(const_int 0)] From 3772a8419cabd9ed514818afbc0ba3dc03390d51 Mon Sep 17 00:00:00 2001 From: Michiel Derhaeg Date: Thu, 17 Sep 2026 11:41:52 +0300 Subject: [PATCH 150/584] arc: Initialize missing CC mode The change was supposed to be part of r16-1685-g467fa6d257efde, but somehow it was not included when that patch was applied upstream. It is the only difference with the downstream version of that patch. This fixes gcc.c-torture/execute/pr64006.c. gcc/ChangeLog: * config/arc/arc.cc (arc_init_reg_tables): Set the mode class of CC_Vmode to C_MODE. Signed-off-by: Michiel Derhaeg --- gcc/config/arc/arc.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/config/arc/arc.cc b/gcc/config/arc/arc.cc index 32e358d2fd44..28e6f0b97296 100644 --- a/gcc/config/arc/arc.cc +++ b/gcc/config/arc/arc.cc @@ -1794,7 +1794,7 @@ arc_init_reg_tables (void) /* mode_class hasn't been initialized yet for EXTRA_CC_MODES, so we must explicitly check for them here. */ if (i == (int) CCmode || i == (int) CC_ZNmode || i == (int) CC_Zmode - || i == (int) CC_Cmode + || i == (int) CC_Cmode || i == (int) CC_Vmode || i == CC_FP_GTmode || i == CC_FP_GEmode || i == CC_FP_ORDmode || i == CC_FPUmode || i == CC_FPUEmode || i == CC_FPU_UNEQmode) arc_mode_class[i] = 1 << (int) C_MODE; From 76dad9582058739e3e5f6d4db10c3c2e4de27a32 Mon Sep 17 00:00:00 2001 From: Michiel Derhaeg Date: Thu, 17 Sep 2026 11:45:25 +0300 Subject: [PATCH 151/584] arc: Add missing CC clobbers [PR127191] This is a similar issue as PR120375. doloop_end, loop_end, dbnz, flag, and kflag all write the condition codes without declaring it. Since r16-3301-g724d88900b7a moved aarch64-cc-fusion into late-combine, GCC exploits that and keeps condition codes live across these insns, producing wrong code. If a loop fails to resolve to a hardware loop, doloop_end and loop_end fall back to instructions that clobber CC. This needs to be declared on the pattern itself or it will not be taken into account. This fixes gcc.c-torture/execute/pr68185.c for ARC60x and ARC700. dbnz is wrong in the same way as (do)loop_end but I didn't succeed in creating a reproducer for it. flag and kflag write STATUS32, which holds the condition codes. Since the cc-fusion move they can cause unintended clobbers too. PR target/127191 gcc/ChangeLog: * config/arc/arc.md (doloop_end): Clobber CC. (loop_end): Likewise. (dbnz): Likewise. (flag): Likewise. (kflag): Likewise. gcc/testsuite/ChangeLog: * gcc.target/arc/pr127191-1.c: New test. * gcc.target/arc/pr127191-2.c: New test. Signed-off-by: Michiel Derhaeg --- gcc/config/arc/arc.md | 15 ++++--- gcc/testsuite/gcc.target/arc/pr127191-1.c | 30 ++++++++++++++ gcc/testsuite/gcc.target/arc/pr127191-2.c | 50 +++++++++++++++++++++++ 3 files changed, 90 insertions(+), 5 deletions(-) create mode 100644 gcc/testsuite/gcc.target/arc/pr127191-1.c create mode 100644 gcc/testsuite/gcc.target/arc/pr127191-2.c diff --git a/gcc/config/arc/arc.md b/gcc/config/arc/arc.md index e0f132118997..fb905cfef058 100644 --- a/gcc/config/arc/arc.md +++ b/gcc/config/arc/arc.md @@ -4672,7 +4672,8 @@ archs4x, archs4xd" (define_insn "flag" [(unspec_volatile [(match_operand:SI 0 "nonmemory_operand" "rL,I,Cal")] - VUNSPEC_ARC_FLAG)] + VUNSPEC_ARC_FLAG) + (clobber (reg:CC CC_REG))] "" "@ flag%?\\t%0 @@ -5136,7 +5137,8 @@ archs4x, archs4xd" (pc))) (set (match_dup 0) (plus:SI (match_dup 0) (const_int -1))) (unspec:SI [(const_int 0)] UNSPEC_ARC_LP) - (clobber (match_dup 2))])] + (clobber (match_dup 2)) + (clobber (reg:CC CC_REG))])] "" { if (GET_MODE (operands[0]) != SImode) @@ -5166,7 +5168,8 @@ archs4x, archs4xd" (pc))) (set (match_dup 0) (plus:SI (match_dup 0) (const_int -1))) (unspec:SI [(const_int 0)] UNSPEC_ARC_LP) - (clobber (match_scratch:SI 2 "=X,&r"))] + (clobber (match_scratch:SI 2 "=X,&r")) + (clobber (reg:CC CC_REG))] "" "@ ; ZOL_END, begins @%l1 @@ -5213,7 +5216,8 @@ archs4x, archs4xd" (set (match_dup 0) (plus:SI (match_dup 0) (const_int -1))) - (clobber (match_scratch:SI 2 "=X,r"))] + (clobber (match_scratch:SI 2 "=X,r")) + (clobber (reg:CC CC_REG))] "TARGET_DBNZ" "@ dbnz%*\\t%0,%l1 @@ -5625,7 +5629,8 @@ archs4x, archs4xd" (define_insn "kflag" [(unspec_volatile [(match_operand:SI 0 "nonmemory_operand" "rL,I,Cal")] - VUNSPEC_ARC_KFLAG)] + VUNSPEC_ARC_KFLAG) + (clobber (reg:CC CC_REG))] "TARGET_V2" "@ kflag%?\\t%0 diff --git a/gcc/testsuite/gcc.target/arc/pr127191-1.c b/gcc/testsuite/gcc.target/arc/pr127191-1.c new file mode 100644 index 000000000000..b79ad2ae3fbe --- /dev/null +++ b/gcc/testsuite/gcc.target/arc/pr127191-1.c @@ -0,0 +1,30 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +/* Verifies that the potential CC clobber is taken into account when expanding + doloop_end but this fails to resolve into a hardware loop. */ + +int d = 1, e, f, o, w = 1, q, t; + +int +main (void) +{ + int g = 0; + + for (; d; d--) + { + while (o) + while (e) + ; + + g = t ? g : w; + f = g; + if (g) + q = 1; + } + + if (q != 1) + __builtin_abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/arc/pr127191-2.c b/gcc/testsuite/gcc.target/arc/pr127191-2.c new file mode 100644 index 000000000000..d5137af14508 --- /dev/null +++ b/gcc/testsuite/gcc.target/arc/pr127191-2.c @@ -0,0 +1,50 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +int q, sink; + +int __attribute__ ((noipa)) +flag_clobbers_cc (int a, int b, int *p) +{ + int s = a | b; + + *p = s; + __builtin_arc_flag (0); + if (s == 0) + q = 1; + + return s; +} + +#if defined (__ARCEM__) || defined (__ARCHS__) +int r; + +int __attribute__ ((noipa)) +kflag_clobbers_cc (int a, int b, int *p) +{ + int s = a | b; + + *p = s; + __builtin_arc_kflag (0); + if (s == 0) + r = 1; + + return s; +} +#endif + +int +main (void) +{ + flag_clobbers_cc (0, 0, &sink); + if (q != 1) + __builtin_abort (); + +#if defined (__ARCEM__) || defined (__ARCHS__) + kflag_clobbers_cc (0, 0, &sink); + if (r != 1) + __builtin_abort (); +#endif + + return 0; +} From c638dae26f3134951e11aafe696787f83121571c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tomasz=20Kami=C5=84ski?= Date: Wed, 16 Sep 2026 10:10:00 +0200 Subject: [PATCH 152/584] libstdc++: Update underlying gamma_distribution in param() [PR123409] This updates the underlying gamma distribution in the param function by invoking the param function on the corresponding member: * _M_gd for negative_binomial_distribution, student_t_distribution; * _M_gd_x, _M_gd_y for fisher_f_distribution. The distribution_param.cc test, validates that for all distributions, constructing from or setting params results in equal distribution that produces same values. The test uses -ffloat-store for -m32, following chi_squared_distribution test for PR83833 - that is removed, as all cases are covered in new test. libstdc++-v3/ChangeLog: PR libstdc++/123409 * include/bits/random.h (negative_binomial_distribution::param) (fisher_f_distribution::param, student_t_distribution::param): Updated underlying gamma distributions, by calling param. (chi_squared_distribution::param): Use type alias and parenthesis for consistency. * testsuite/26_numerics/random/distribution_param.cc: New test. * testsuite/26_numerics/random/chi_squared_distribution/83833.cc: Removed, covered by above. Reviewed-by: Jonathan Wakely --- libstdc++-v3/include/bits/random.h | 32 ++++++++-- .../random/chi_squared_distribution/83833.cc | 41 ------------- .../26_numerics/random/distribution_param.cc | 60 +++++++++++++++++++ 3 files changed, 86 insertions(+), 47 deletions(-) delete mode 100644 libstdc++-v3/testsuite/26_numerics/random/chi_squared_distribution/83833.cc create mode 100644 libstdc++-v3/testsuite/26_numerics/random/distribution_param.cc diff --git a/libstdc++-v3/include/bits/random.h b/libstdc++-v3/include/bits/random.h index cfec087f0cd2..1a2900e2b9d8 100644 --- a/libstdc++-v3/include/bits/random.h +++ b/libstdc++-v3/include/bits/random.h @@ -3559,9 +3559,10 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) param(const param_type& __param) { _M_param = __param; - typedef typename std::gamma_distribution::param_type - param_type; - _M_gd.param(param_type{__param.n() / 2}); + + using param_type + = typename std::gamma_distribution::param_type; + _M_gd.param(param_type(__param.n() / 2)); } /** @@ -4015,7 +4016,14 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) */ void param(const param_type& __param) - { _M_param = __param; } + { + _M_param = __param; + + using param_type + = typename std::gamma_distribution::param_type; + _M_gd_x.param(param_type(__param.m() / 2)); + _M_gd_y.param(param_type(__param.n() / 2)); + } /** * @brief Returns the greatest lower bound value of the distribution. @@ -4244,7 +4252,13 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) */ void param(const param_type& __param) - { _M_param = __param; } + { + _M_param = __param; + + using param_type + = typename std::gamma_distribution::param_type; + _M_gd.param(param_type(__param.n() / 2, 2)); + } /** * @brief Returns the greatest lower bound value of the distribution. @@ -5175,7 +5189,13 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) */ void param(const param_type& __param) - { _M_param = __param; } + { + _M_param = __param; + + using param_type + = typename std::gamma_distribution::param_type; + _M_gd.param(param_type(__param.k(), (1.0 - __param.p()) / __param.p())); + } /** * @brief Returns the greatest lower bound value of the distribution. diff --git a/libstdc++-v3/testsuite/26_numerics/random/chi_squared_distribution/83833.cc b/libstdc++-v3/testsuite/26_numerics/random/chi_squared_distribution/83833.cc deleted file mode 100644 index 4008f7db89c9..000000000000 --- a/libstdc++-v3/testsuite/26_numerics/random/chi_squared_distribution/83833.cc +++ /dev/null @@ -1,41 +0,0 @@ -// Copyright (C) 2018-2026 Free Software Foundation, Inc. -// -// This file is part of the GNU ISO C++ Library. This library 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. - -// This library 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 this library; see the file COPYING3. If not see -// . - -// { dg-do run { target c++11 } } -// { dg-additional-options "-ffloat-store" { target { m68*-*-* || ia32 } } } -// { dg-require-cstdint "" } - -#include -#include - -void -test01() -{ - std::default_random_engine r1, r2; - using chi = std::chi_squared_distribution; - chi::param_type p(5); - chi d1(p); - chi d2; - d2.param(p); - VERIFY( d1(r1) == d2(r2) ); // PR libstdc++/83833 -} - -int -main() -{ - test01(); -} diff --git a/libstdc++-v3/testsuite/26_numerics/random/distribution_param.cc b/libstdc++-v3/testsuite/26_numerics/random/distribution_param.cc new file mode 100644 index 000000000000..d6c067662336 --- /dev/null +++ b/libstdc++-v3/testsuite/26_numerics/random/distribution_param.cc @@ -0,0 +1,60 @@ +// { dg-do run { target c++11 } } +// { dg-additional-options "-ffloat-store" { target { m68*-*-* || ia32 } } } +// { dg-require-cstdint "" } + +#include +#include + +template +void +validate(Distribution&& source) +{ + const auto& params = source.param(); + + Distribution constr(params); + VERIFY( constr == source ); + + Distribution setter; + setter.param(params); + VERIFY( setter == source ); + + std::mt19937_64 e1(0x19650809ull), e2 = e1, e3 = e1; + for (int i = 0; i < 10; ++i) + { + const auto expected = source(e1); + VERIFY( constr(e2) == expected ); + VERIFY( setter(e3) == expected ); + } +} + +int main() +{ + // PR83833, PR123409 + validate(std::uniform_int_distribution<>(13, 22)); + validate(std::uniform_real_distribution<>(1.0, 9.0)); + + validate(std::bernoulli_distribution(0.478)); + validate(std::binomial_distribution<>(7, 0.334)); + validate(std::negative_binomial_distribution<>(726, 0.65)); + validate(std::geometric_distribution<>(0.545)); + + validate(std::poisson_distribution<>(6)); + validate(std::exponential_distribution<>(3)); + validate(std::gamma_distribution<>(1.1, 2.2)); + validate(std::weibull_distribution<>(1.7, 3.0)); + validate(std::extreme_value_distribution<>(-1.628, 1.628)); + + validate(std::normal_distribution<>(5.0, 2.0)); + validate(std::lognormal_distribution<>(1.67, 0.25)); + validate(std::chi_squared_distribution<>(5)); + validate(std::cauchy_distribution<>(-3, 0.25)); + validate(std::fisher_f_distribution<>(26.0, 7.0)); + validate(std::student_t_distribution<>(65.0)); + + const auto wf = [](double x) { return 1 + x; }; + validate(std::discrete_distribution<>(4, 1.2, 4.5, wf)); + validate(std::piecewise_constant_distribution<>(5, 0.5, 9, wf)); + validate(std::piecewise_linear_distribution<>(3, 1.2, 3.4, wf)); + + return 0; +} From d373724d1ddeef9b322b6b6078fc1de8dbe27791 Mon Sep 17 00:00:00 2001 From: Andrew Stubbs Date: Tue, 15 Sep 2026 15:05:04 +0000 Subject: [PATCH 153/584] amdgcn: Spill scalars to both SGPRs and AVGPRs The previous patch switched from spilling all VGPRs into AVGPRs to spilling VGPRs containing scalars into SGPRs. That helps some cases, but had an unexpected impact on other benchmarks in which the SPGRs were under pressure. This patch allows scalars in VGPRs to spill into either register file, and fixes (and sometimes improves) the performance issues in all cases. gcc/ChangeLog: * config/gcn/gcn.cc (gcn_spill_class): Spill scalars in VGPRs to SCALAR_SPILL_REGS. (gcn_memory_move_cost): Handle SCALAR_SPILL_REGS. * config/gcn/gcn.h (enum reg_class): Add SCALAR_SPILL_REGS. (REG_CLASS_NAMES): Likewise. (REG_CLASS_CONTENTS): Likewise. gcc/testsuite/ChangeLog: * gcc.target/gcn/avgpr-spill-int.c: Increase register pressure. * gcc.target/gcn/sgpr-spill-double.c: Allow some AVGPR spills. * gcc.target/gcn/sgpr-spill-int.c: Likewise. * gcc.target/gcn/sgpr-spill-long.c: Likewise. * gcc.target/gcn/sgpr-spill-short.c: Likewise. --- gcc/config/gcn/gcn.cc | 3 +- gcc/config/gcn/gcn.h | 8 ++ .../gcc.target/gcn/avgpr-spill-int.c | 102 +++++++++++++++++- .../gcc.target/gcn/sgpr-spill-double.c | 6 +- gcc/testsuite/gcc.target/gcn/sgpr-spill-int.c | 6 +- .../gcc.target/gcn/sgpr-spill-long.c | 6 +- .../gcc.target/gcn/sgpr-spill-short.c | 6 +- 7 files changed, 131 insertions(+), 6 deletions(-) diff --git a/gcc/config/gcn/gcn.cc b/gcc/config/gcn/gcn.cc index e2a1e5d0e744..866df02bf90c 100644 --- a/gcc/config/gcn/gcn.cc +++ b/gcc/config/gcn/gcn.cc @@ -860,7 +860,7 @@ gcn_spill_class (reg_class_t c, machine_mode mode) || c == VCC_CONDITIONAL_REG || c == EXEC_MASK_REG) return SGPR_REGS; else if (c == VGPR_REGS && !VECTOR_MODE_P (mode)) - return SGPR_REGS; + return SCALAR_SPILL_REGS; else if (c == VGPR_REGS && TARGET_AVGPRS) return AVGPR_REGS; else @@ -4075,6 +4075,7 @@ gcn_memory_move_cost (machine_mode mode, reg_class_t regclass, bool in) return (STORE_COST + (TARGET_CDNA2_MEM_COSTS ? 0 : 2)) * nregs; case ALL_REGS: case ALL_GPR_REGS: + case SCALAR_SPILL_REGS: case SRCDST_REGS: if (in) return (LOAD_COST + 2) * nregs; diff --git a/gcc/config/gcn/gcn.h b/gcc/config/gcn/gcn.h index 87605edd79cd..73580da098b4 100644 --- a/gcc/config/gcn/gcn.h +++ b/gcc/config/gcn/gcn.h @@ -415,6 +415,7 @@ enum reg_class AVGPR_REGS, ALL_VGPR_REGS, ALL_GPR_REGS, + SCALAR_SPILL_REGS, SRCDST_REGS, AFP_REGS, ALL_REGS, @@ -443,6 +444,7 @@ enum reg_class "AVGPR_REGS", \ "ALL_VGPR_REGS", \ "ALL_GPR_REGS", \ + "SCALAR_SPILL_REGS", \ "SRCDST_REGS", \ "AFP_REGS", \ "ALL_REGS" \ @@ -579,6 +581,12 @@ enum reg_class 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, \ 0xffffffff, 0, 0, 0, \ 0, 0, 0, 0, 0, 0}, \ + /* SCALAR_SPILL_REGS. */ \ + {0xffffffff, 0xffffffff, 0xffffffff, 0xf1, \ + 0, 0, 0, 0, \ + 0, 0, 0, 0, \ + 0, 0xffffffff, 0xffffffff, 0xffffffff, \ + 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0}, \ /* SRCDST_REGS. */ \ {0xffffffff, 0xffffffff, 0xffffffff, \ 0xffffffff-NAMED_REG_MASK (VCCZ_REG), \ diff --git a/gcc/testsuite/gcc.target/gcn/avgpr-spill-int.c b/gcc/testsuite/gcc.target/gcn/avgpr-spill-int.c index 462d67417c37..887ed4daf959 100644 --- a/gcc/testsuite/gcc.target/gcn/avgpr-spill-int.c +++ b/gcc/testsuite/gcc.target/gcn/avgpr-spill-int.c @@ -7,7 +7,7 @@ typedef int v32si __attribute__ ((__vector_size__ (sizeof(int)*32))); #define TYPE v32si #endif -TYPE a[50]; +TYPE a[100]; int f() { @@ -61,6 +61,56 @@ int f() __asm__ volatile ("; fake <- %0" : "=v"(a[47])); __asm__ volatile ("; fake <- %0" : "=v"(a[48])); __asm__ volatile ("; fake <- %0" : "=v"(a[49])); + __asm__ volatile ("; fake <- %0" : "=v"(a[50])); + __asm__ volatile ("; fake <- %0" : "=v"(a[51])); + __asm__ volatile ("; fake <- %0" : "=v"(a[52])); + __asm__ volatile ("; fake <- %0" : "=v"(a[53])); + __asm__ volatile ("; fake <- %0" : "=v"(a[54])); + __asm__ volatile ("; fake <- %0" : "=v"(a[55])); + __asm__ volatile ("; fake <- %0" : "=v"(a[56])); + __asm__ volatile ("; fake <- %0" : "=v"(a[57])); + __asm__ volatile ("; fake <- %0" : "=v"(a[58])); + __asm__ volatile ("; fake <- %0" : "=v"(a[59])); + __asm__ volatile ("; fake <- %0" : "=v"(a[60])); + __asm__ volatile ("; fake <- %0" : "=v"(a[61])); + __asm__ volatile ("; fake <- %0" : "=v"(a[62])); + __asm__ volatile ("; fake <- %0" : "=v"(a[63])); + __asm__ volatile ("; fake <- %0" : "=v"(a[64])); + __asm__ volatile ("; fake <- %0" : "=v"(a[65])); + __asm__ volatile ("; fake <- %0" : "=v"(a[66])); + __asm__ volatile ("; fake <- %0" : "=v"(a[67])); + __asm__ volatile ("; fake <- %0" : "=v"(a[68])); + __asm__ volatile ("; fake <- %0" : "=v"(a[69])); + __asm__ volatile ("; fake <- %0" : "=v"(a[70])); + __asm__ volatile ("; fake <- %0" : "=v"(a[71])); + __asm__ volatile ("; fake <- %0" : "=v"(a[72])); + __asm__ volatile ("; fake <- %0" : "=v"(a[73])); + __asm__ volatile ("; fake <- %0" : "=v"(a[74])); + __asm__ volatile ("; fake <- %0" : "=v"(a[75])); + __asm__ volatile ("; fake <- %0" : "=v"(a[76])); + __asm__ volatile ("; fake <- %0" : "=v"(a[77])); + __asm__ volatile ("; fake <- %0" : "=v"(a[78])); + __asm__ volatile ("; fake <- %0" : "=v"(a[79])); + __asm__ volatile ("; fake <- %0" : "=v"(a[80])); + __asm__ volatile ("; fake <- %0" : "=v"(a[81])); + __asm__ volatile ("; fake <- %0" : "=v"(a[82])); + __asm__ volatile ("; fake <- %0" : "=v"(a[83])); + __asm__ volatile ("; fake <- %0" : "=v"(a[84])); + __asm__ volatile ("; fake <- %0" : "=v"(a[85])); + __asm__ volatile ("; fake <- %0" : "=v"(a[86])); + __asm__ volatile ("; fake <- %0" : "=v"(a[87])); + __asm__ volatile ("; fake <- %0" : "=v"(a[88])); + __asm__ volatile ("; fake <- %0" : "=v"(a[89])); + __asm__ volatile ("; fake <- %0" : "=v"(a[90])); + __asm__ volatile ("; fake <- %0" : "=v"(a[91])); + __asm__ volatile ("; fake <- %0" : "=v"(a[92])); + __asm__ volatile ("; fake <- %0" : "=v"(a[93])); + __asm__ volatile ("; fake <- %0" : "=v"(a[94])); + __asm__ volatile ("; fake <- %0" : "=v"(a[95])); + __asm__ volatile ("; fake <- %0" : "=v"(a[96])); + __asm__ volatile ("; fake <- %0" : "=v"(a[97])); + __asm__ volatile ("; fake <- %0" : "=v"(a[98])); + __asm__ volatile ("; fake <- %0" : "=v"(a[99])); __asm__ volatile ("; fake -> %0" :: "v"(a[0])); __asm__ volatile ("; fake -> %0" :: "v"(a[1])); @@ -112,4 +162,54 @@ int f() __asm__ volatile ("; fake -> %0" :: "v"(a[47])); __asm__ volatile ("; fake -> %0" :: "v"(a[48])); __asm__ volatile ("; fake -> %0" :: "v"(a[49])); + __asm__ volatile ("; fake -> %0" :: "v"(a[50])); + __asm__ volatile ("; fake -> %0" :: "v"(a[51])); + __asm__ volatile ("; fake -> %0" :: "v"(a[52])); + __asm__ volatile ("; fake -> %0" :: "v"(a[53])); + __asm__ volatile ("; fake -> %0" :: "v"(a[54])); + __asm__ volatile ("; fake -> %0" :: "v"(a[55])); + __asm__ volatile ("; fake -> %0" :: "v"(a[56])); + __asm__ volatile ("; fake -> %0" :: "v"(a[57])); + __asm__ volatile ("; fake -> %0" :: "v"(a[58])); + __asm__ volatile ("; fake -> %0" :: "v"(a[59])); + __asm__ volatile ("; fake -> %0" :: "v"(a[60])); + __asm__ volatile ("; fake -> %0" :: "v"(a[61])); + __asm__ volatile ("; fake -> %0" :: "v"(a[62])); + __asm__ volatile ("; fake -> %0" :: "v"(a[63])); + __asm__ volatile ("; fake -> %0" :: "v"(a[64])); + __asm__ volatile ("; fake -> %0" :: "v"(a[65])); + __asm__ volatile ("; fake -> %0" :: "v"(a[66])); + __asm__ volatile ("; fake -> %0" :: "v"(a[67])); + __asm__ volatile ("; fake -> %0" :: "v"(a[68])); + __asm__ volatile ("; fake -> %0" :: "v"(a[69])); + __asm__ volatile ("; fake -> %0" :: "v"(a[70])); + __asm__ volatile ("; fake -> %0" :: "v"(a[71])); + __asm__ volatile ("; fake -> %0" :: "v"(a[72])); + __asm__ volatile ("; fake -> %0" :: "v"(a[73])); + __asm__ volatile ("; fake -> %0" :: "v"(a[74])); + __asm__ volatile ("; fake -> %0" :: "v"(a[75])); + __asm__ volatile ("; fake -> %0" :: "v"(a[76])); + __asm__ volatile ("; fake -> %0" :: "v"(a[77])); + __asm__ volatile ("; fake -> %0" :: "v"(a[78])); + __asm__ volatile ("; fake -> %0" :: "v"(a[79])); + __asm__ volatile ("; fake -> %0" :: "v"(a[80])); + __asm__ volatile ("; fake -> %0" :: "v"(a[81])); + __asm__ volatile ("; fake -> %0" :: "v"(a[82])); + __asm__ volatile ("; fake -> %0" :: "v"(a[83])); + __asm__ volatile ("; fake -> %0" :: "v"(a[84])); + __asm__ volatile ("; fake -> %0" :: "v"(a[85])); + __asm__ volatile ("; fake -> %0" :: "v"(a[86])); + __asm__ volatile ("; fake -> %0" :: "v"(a[87])); + __asm__ volatile ("; fake -> %0" :: "v"(a[88])); + __asm__ volatile ("; fake -> %0" :: "v"(a[89])); + __asm__ volatile ("; fake -> %0" :: "v"(a[90])); + __asm__ volatile ("; fake -> %0" :: "v"(a[91])); + __asm__ volatile ("; fake -> %0" :: "v"(a[92])); + __asm__ volatile ("; fake -> %0" :: "v"(a[93])); + __asm__ volatile ("; fake -> %0" :: "v"(a[94])); + __asm__ volatile ("; fake -> %0" :: "v"(a[95])); + __asm__ volatile ("; fake -> %0" :: "v"(a[96])); + __asm__ volatile ("; fake -> %0" :: "v"(a[97])); + __asm__ volatile ("; fake -> %0" :: "v"(a[98])); + __asm__ volatile ("; fake -> %0" :: "v"(a[99])); } diff --git a/gcc/testsuite/gcc.target/gcn/sgpr-spill-double.c b/gcc/testsuite/gcc.target/gcn/sgpr-spill-double.c index 6757a19d8c9c..910b4e650135 100644 --- a/gcc/testsuite/gcc.target/gcn/sgpr-spill-double.c +++ b/gcc/testsuite/gcc.target/gcn/sgpr-spill-double.c @@ -1,6 +1,10 @@ /* { dg-do compile } */ /* { dg-additional-options "-march=gfx908 -O1" } */ -/* { dg-final { scan-assembler-not "accvgpr" } } */ + +/* Scalar values spilled out of VGPRs can be placed in either SGPRs or + AVGPRs, so both may appear here; the array is large enough that both + register files fill up and get used. */ +/* { dg-final { scan-assembler "accvgpr" } } */ /* Function epilogues use v6, but other registers may be a spill. */ /* { dg-final { scan-assembler "v_readlane.+, v\[12345789]" } } */ diff --git a/gcc/testsuite/gcc.target/gcn/sgpr-spill-int.c b/gcc/testsuite/gcc.target/gcn/sgpr-spill-int.c index aed29442ce2c..536dba2544d5 100644 --- a/gcc/testsuite/gcc.target/gcn/sgpr-spill-int.c +++ b/gcc/testsuite/gcc.target/gcn/sgpr-spill-int.c @@ -1,6 +1,10 @@ /* { dg-do compile } */ /* { dg-additional-options "-march=gfx908 -O1" } */ -/* { dg-final { scan-assembler-not "accvgpr" } } */ + +/* Scalar values spilled out of VGPRs can be placed in either SGPRs or + AVGPRs, so both may appear here; the array is large enough that both + register files fill up and get used. */ +/* { dg-final { scan-assembler "accvgpr" } } */ /* Function epilogues use v6, but other registers may be a spill. */ /* { dg-final { scan-assembler "v_readlane.+, v\[12345789]" } } */ diff --git a/gcc/testsuite/gcc.target/gcn/sgpr-spill-long.c b/gcc/testsuite/gcc.target/gcn/sgpr-spill-long.c index 248624381b8d..57f6a7444ede 100644 --- a/gcc/testsuite/gcc.target/gcn/sgpr-spill-long.c +++ b/gcc/testsuite/gcc.target/gcn/sgpr-spill-long.c @@ -1,6 +1,10 @@ /* { dg-do compile } */ /* { dg-additional-options "-march=gfx908 -O1" } */ -/* { dg-final { scan-assembler-not "accvgpr" } } */ + +/* Scalar values spilled out of VGPRs can be placed in either SGPRs or + AVGPRs, so both may appear here; the array is large enough that both + register files fill up and get used. */ +/* { dg-final { scan-assembler "accvgpr" } } */ /* Function epilogues use v6, but other registers may be a spill. */ /* { dg-final { scan-assembler "v_readlane.+, v\[12345789]" } } */ diff --git a/gcc/testsuite/gcc.target/gcn/sgpr-spill-short.c b/gcc/testsuite/gcc.target/gcn/sgpr-spill-short.c index 35bd0d560895..f61a8eb58f98 100644 --- a/gcc/testsuite/gcc.target/gcn/sgpr-spill-short.c +++ b/gcc/testsuite/gcc.target/gcn/sgpr-spill-short.c @@ -1,6 +1,10 @@ /* { dg-do compile } */ /* { dg-additional-options "-march=gfx908 -O1" } */ -/* { dg-final { scan-assembler-not "accvgpr" } } */ + +/* Scalar values spilled out of VGPRs can be placed in either SGPRs or + AVGPRs, so both may appear here; the array is large enough that both + register files fill up and get used. */ +/* { dg-final { scan-assembler "accvgpr" } } */ /* Function epilogues use v6, but other registers may be a spill. */ /* { dg-final { scan-assembler "v_readlane.+, v\[12345789]" } } */ From 9dcfbe9c5beb2738d329811d72f18011d13428a5 Mon Sep 17 00:00:00 2001 From: Uros Bizjak Date: Wed, 16 Sep 2026 10:41:08 +0200 Subject: [PATCH 154/584] i386: Set default for MD generator partitions to 6:6:1 Set the i386 default for MD generator partitions to 6:6:1. The longest objects in the bootstrap are gimple-match-[1..10].o, with per-file user times of: user 0m12,114s user 0m6,214s user 0m6,737s user 0m8,234s user 0m5,765s user 0m5,221s user 0m5,732s user 0m5,221s user 0m5,645s user 0m7,951s while generic-match-[1..10].o compile in: user 0m5,875s user 0m5,186s user 0m4,132s user 0m4,367s user 0m4,464s user 0m4,705s user 0m4,340s user 0m5,942s user 0m4,469s user 0m4,236s With the default set to 6:6:1, compile times become: insn-emit-[1..6].o: user 0m4,766s user 0m4,799s user 0m4,829s user 0m4,825s user 0m4,766s user 0m4,781s insn-recog-[1..6].o: user 0m4,782s user 0m4,741s user 0m4,988s user 0m4,814s user 0m4,918s user 0m4,898s insn-attrtab-1.o: user 0m3,076s which are all comparable to the generic-match-[1..10].o compile times. Raising the partition counts further would shorten objects that are already off the critical path, while each additional partition repeats the per-file preamble, adding to overall bootstrap CPU time. gcc/ChangeLog: * config.gcc (i[34567]86-*-* | x86_64-*-*): Set default_md_generator_partitions target default to 6:6:1. --- gcc/config.gcc | 1 + 1 file changed, 1 insertion(+) diff --git a/gcc/config.gcc b/gcc/config.gcc index ef117b293dfa..d651c3aae37e 100644 --- a/gcc/config.gcc +++ b/gcc/config.gcc @@ -443,6 +443,7 @@ fido-*-*) ;; i[34567]86-*-* | x86_64-*-*) cpu_type=i386 + default_md_generator_partitions=6:6:1 c_target_objs="i386-c.o" cxx_target_objs="i386-c.o" d_target_objs="i386-d.o" From b0fcf6cab6b44d916992f17297d7c248d64469dc Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Thu, 17 Sep 2026 11:24:41 +0200 Subject: [PATCH 155/584] tree-optimization/127407 - negative step dependence of grouped stores The following adds a missed check for preserving scalar oder of stores to the negative distance case in the vectorizers dependence analysis. PR tree-optimization/127407 * tree-vect-data-refs.cc (vect_analyze_data_ref_dependence): Also call vect_preserves_scalar_order_p for negative dependence distance. * gcc.dg/vect/vect-pr127407.c: New testcase. --- gcc/testsuite/gcc.dg/vect/vect-pr127407.c | 29 +++++++++++++++++++++++ gcc/tree-vect-data-refs.cc | 3 +++ 2 files changed, 32 insertions(+) create mode 100644 gcc/testsuite/gcc.dg/vect/vect-pr127407.c diff --git a/gcc/testsuite/gcc.dg/vect/vect-pr127407.c b/gcc/testsuite/gcc.dg/vect/vect-pr127407.c new file mode 100644 index 000000000000..704a631be8b4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-pr127407.c @@ -0,0 +1,29 @@ +#include "tree-vect.h" + +__attribute__ ((noipa)) void +f (int *px, int n) +{ + int i; + for (i = 0; i < n; i++, px += 2) + { + px[0] = i; + px[-2] = i + 100; + px[1] = 7; + } +} + +int a[256]; + +int +main (void) +{ + check_vect (); + + f (a + 2, 64); + + for (int k = 1; k < 64; k++) + if (a[2 * k] != k + 100) + __builtin_abort (); + + return 0; +} diff --git a/gcc/tree-vect-data-refs.cc b/gcc/tree-vect-data-refs.cc index 827e0965d9c7..23235875fa21 100644 --- a/gcc/tree-vect-data-refs.cc +++ b/gcc/tree-vect-data-refs.cc @@ -465,6 +465,9 @@ vect_analyze_data_ref_dependence (struct data_dependence_relation *ddr, "between data-refs %T and %T\n", DR_REF (dra), DR_REF (drb)); } + if (!vect_preserves_scalar_order_p (dr_info_a, dr_info_b)) + return opt_result::failure_at (stmtinfo_a->stmt, + "dependence in interleaving.\n"); /* Record a negative dependence distance to later limit the amount of stmt copying / unrolling we can perform. Only need to handle read-after-write dependence. */ From bef869c1b9b818d4ad27063e539b3c95c1691c67 Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Thu, 17 Sep 2026 14:11:17 +0200 Subject: [PATCH 156/584] maintainer-scripts: Fix up installation of onlinedocs On Sat, Sep 12, 2026 at 06:36:11PM +0200, Gerald Pfeifer wrote: > maintainer-scripts: > * update_web_docs_git: Stop generating .pdf.gz copies of > .pdf files. This change broke the installation of the web docs. We don't compress *.pdf files anymore (good), but then there is in the # And copy the resulting files to the web server section if cmp -s file1 file2; then : else cp $file $DOCSDIR/$file cp $file.gz $DOCSDIR/$file.gz fi and that fails if the *.pdf.gz file isn't there, see https://gcc.gnu.org/pipermail/gccadmin/2026q3/024564.html ... Renaming ./gcc/Target_002dSpecific-Options.html to ./gcc/Target-Specific-Options.html Renaming ./gcc/Objective_002dC-and-Objective_002dC_002b_002b-Dialect-Options.html to ./gcc/Objective-C-and-Objective-C_002b_002b-Dialect-Options.html cp: cannot stat 'cppinternals.pdf.gz': No such file or directory So, all we got there was cppinternals.pdf but not other pdf files, nor *.tar.gz etc. The following patch fixes it, tested by running the script patched with this patch by hand as gccadmin - the onlinedocs seem to be ok again. 2026-09-17 Jakub Jelinek * update_web_docs_git: Ignore installation of $file.gz files which don't exist. Reviewed-by: Gerald Pfeifer --- maintainer-scripts/update_web_docs_git | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/maintainer-scripts/update_web_docs_git b/maintainer-scripts/update_web_docs_git index 7bb46fb2378a..8875f71c30db 100755 --- a/maintainer-scripts/update_web_docs_git +++ b/maintainer-scripts/update_web_docs_git @@ -297,7 +297,7 @@ for file in */*.html *.ps *.pdf *.tar; do : else cp $file $DOCSDIR/$file - cp $file.gz $DOCSDIR/$file.gz + [ -f $file.gz ] && cp $file.gz $DOCSDIR/$file.gz fi done From d528b3e5314fde594080406c95ac39c77881c770 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Thu, 23 Jul 2026 15:51:31 +0200 Subject: [PATCH 157/584] Make vect_build_slp_tree_1 compute a set of matches[] The following re-wires vect_build_slp_tree_1 to compute more than one set of matching stmts from the candidate set by changing how matches[] operates, making elements a structure type encapsulating an int rather than a bool and indicating the lane it is matching with. Special values -1 denote "not matching/matched with another lane" and -2 "not vectorizable lane". The latter is fully computed by the first sweep while further match sets are computed by re-trying for -1 valued lanes from the first sweep and starting with the first one. What was formerly if (matches[i]) is now if (matches[i] == 0), vect_build_slp_tree_1 will still indicate failure (not fully isomorphic) when there is more than one isomorphic group. So the extra knowledge is mostly useful to guide operand swapping and splitting of groups. *two_operators is an indicator only for the first isomorphic group, the state for further groups is not retained. Failure due to BB SLP unrolling is noted as problem in PR126306 and also predicated tail vectorization will touch that. I'd like to get rid of this entirely, but for now we do at least retain the knowledge that the tail is isomorphic. With this representation we can get rid of the inability to distinguish a fatal failure (-1 at lane zero) from an unvectorizable statement at lane zero (now -2). This should allow some more cases of BB vectorization by swapping lane zero with another operand to move all unvectorizable stmts to one of the operands. * tree-vectorizer.h (match_elt_t): New. (_slp_tree::failed): Make a match_elt_t *. * tree-vect-slp.cc (vect_build_slp_tree_3): Make re-startable at start_i, change representation of matches[] to match_elt_t[]. (vect_build_slp_tree_1): Iteratively resolve not matched lanes. Retain isomorphism of BB unrolling failed tail. (vect_build_slp_tree_2): Adjust for s/bool/match_elt_t/ (vect_build_slp_tree): Likewise. (optimize_load_redistribution_1): Likewise. (vect_build_slp_instance): Likewise. (vect_analyze_slp_reduc_chain): Likewise. (vect_analyze_slp_reduction): Likewise. (vect_analyze_slp_reduction_group): Likewise. (vect_analyze_slp_reductions): Likewise. (vect_analyze_slp_instance): Likewise. (vect_lower_load_permutations): Likewise. --- gcc/tree-vect-slp.cc | 354 ++++++++++++++++++++++++++---------------- gcc/tree-vectorizer.h | 14 +- 2 files changed, 233 insertions(+), 135 deletions(-) diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc index eee02124d5ba..f88646879b7b 100644 --- a/gcc/tree-vect-slp.cc +++ b/gcc/tree-vect-slp.cc @@ -1099,12 +1099,34 @@ compatible_calls_p (gcall *call1, gcall *call2, bool allow_two_operators) /* Verify if the scalar stmts STMTS are isomorphic, require data permutation or are of unsupported types of operation. - Return false if at least one stmt is unvectorizable or the comparison - could not be carried out. - Return true if they all are and indicate in *MATCHES which stmts are - not isomorphic to the first one. - - Note COND_EXPR is possibly isomorphic to another one after swapping its + Return false if at least one (or all in case of BB vectorization) + stmt is unvectorizable or the comparison could not be carried out. + Return true if they all (or at least one in case of BB vectorization) + are and indicate in MATCHES[] which stmts are not isomorphic to the + stmt at *START_I. + + This function is designed to be invoked repeatedly on the same + set of STMTS with increasing *START_I. + + When *START_I is zero and the function returns true MATCHES[] will be + initialized with, in case of BB vectorization, unvectorizable stmts + marked with -2, stmts isomorphic to *START_I as *START_I and + other vectorizable stmts with -1 (not isomorphic to *START_I). + *START_I, when initially zero, is updated to the first vectorizable + statement, so MATCHES[] can have a prefix with entries valued -2. + + When *START_I is not zero MATCHES[] is expected to be pre-initialized + by a former call with *START_I zero and MATCHES[*START_I] should be -1. + The function will return true and have the stmts isomorphic to + MATCHES[*START_I] marked with *START_I. + + *TWO_OPERATORS indicates whether the group of isomorphic statements + uses two related operations like PLUS_EXPR and MINUS_EXPR. If + TWO_OPERATORS is NULL such case is not considered isomorphic. + + SWAP[] indicates whether for a stmt to be isomorphic to its group + leader, has to have its operands swapped (1) or its predicate inverted (2). + COND_EXPR is possibly isomorphic to another one after swapping its operands. Set SWAP[i] to 1 if stmt I is COND_EXPR and isomorphic to the first stmt by swapping the two operands of comparison; set SWAP[i] to 2 if stmt I is isormorphic to the first stmt by inverting the code @@ -1112,12 +1134,11 @@ compatible_calls_p (gcall *call1, gcall *call2, bool allow_two_operators) to (B1 <= A1 ? X1 : Y1); or be inverted to (A1 < B1) ? Y1 : X1. */ static bool -vect_build_slp_tree_3 (vec_info *vinfo, unsigned char *swap, - vec stmts, bool *matches, - bool *two_operators, tree vectype) +vect_build_slp_tree_3 (vec_info *vinfo, vec stmts, + match_elt_t *matches, unsigned char *swap, + bool *two_operators, tree vectype, unsigned *start_i) { - unsigned int i; - stmt_vec_info first_stmt_info = stmts[0]; + stmt_vec_info first_stmt_info = NULL; code_helper first_stmt_code = ERROR_MARK; code_helper alt_stmt_code = ERROR_MARK; code_helper first_cond_code = ERROR_MARK; @@ -1129,22 +1150,31 @@ vect_build_slp_tree_3 (vec_info *vinfo, unsigned char *swap, bool first_stmt_phi_p = false; int first_reduc_idx = -1; - basic_block common_bb = gimple_bb (first_stmt_info->stmt); + basic_block common_bb = NULL; gimple *trapping_stmt = NULL; + int first_match = -1; - stmt_vec_info stmt_info; - FOR_EACH_VEC_ELT (stmts, i, stmt_info) + for (unsigned i = *start_i; i < stmts.length (); ++i) { + stmt_vec_info stmt_info = stmts[i]; bool ldst_p = false; bool ldst_masklen_p = false; bool phi_p = false; code_helper rhs_code = ERROR_MARK; - swap[i] = 0; - matches[i] = false; + if (*start_i == 0) + { + swap[i] = 0; + matches[i] = -1; + } + else if (matches[i] != -1) + continue; + if (!stmt_info) { - matches[i] = true; + /* ??? We shouldn't run into this. */ + gcc_assert (first_match != -1); + matches[i] = first_match; continue; } @@ -1162,12 +1192,11 @@ vect_build_slp_tree_3 (vec_info *vinfo, unsigned char *swap, dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, "Build SLP failed: unvectorizable statement %G", stmt); - /* ??? For BB vectorization we want to commutate operands in a way - to shuffle all unvectorizable defs into one operand and have - the other still vectorized. The following doesn't reliably - work for this though but it's the easiest we can do here. */ - if (is_a (vinfo) && i != 0) - continue; + if (is_a (vinfo)) + { + matches[i] = -2; + continue; + } return false; } @@ -1179,8 +1208,11 @@ vect_build_slp_tree_3 (vec_info *vinfo, unsigned char *swap, dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, "Build SLP failed: not GIMPLE_ASSIGN nor " "GIMPLE_CALL %G", stmt); - if (is_a (vinfo) && i != 0) - continue; + if (is_a (vinfo)) + { + matches[i] = -2; + continue; + } return false; } @@ -1224,8 +1256,11 @@ vect_build_slp_tree_3 (vec_info *vinfo, unsigned char *swap, dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, "Build SLP failed: unsupported call type %G", (gimple *) call_stmt); - if (is_a (vinfo) && i != 0) - continue; + if (is_a (vinfo)) + { + matches[i] = -2; + continue; + } return false; } } @@ -1256,8 +1291,11 @@ vect_build_slp_tree_3 (vec_info *vinfo, unsigned char *swap, dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, "Build SLP failed: operation unsupported %G", stmt); - if (is_a (vinfo) && i != 0) - continue; + if (is_a (vinfo)) + { + matches[i] = -2; + continue; + } return false; } @@ -1278,15 +1316,21 @@ vect_build_slp_tree_3 (vec_info *vinfo, unsigned char *swap, dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, "Build SLP failed: " "BIT_FIELD_REF not supported\n"); - if (i != 0) - continue; + if (is_a (vinfo)) + { + matches[i] = -2; + continue; + } return false; } } /* Check the operation. */ - if (i == 0) + if (first_match == -1) { + first_match = i; + first_stmt_info = stmt_info; + common_bb = gimple_bb (stmt_info->stmt); first_lhs = lhs; first_stmt_code = rhs_code; first_stmt_ldst_p = ldst_p; @@ -1354,6 +1398,7 @@ vect_build_slp_tree_3 (vec_info *vinfo, unsigned char *swap, continue; } if (!ldst_p + && two_operators && first_stmt_code != rhs_code && alt_stmt_code == ERROR_MARK) alt_stmt_code = rhs_code; @@ -1471,6 +1516,22 @@ vect_build_slp_tree_3 (vec_info *vinfo, unsigned char *swap, /* Mismatch. */ continue; } + + /* We need to ensure all stmts are in the same BB when one stmt could + trap. */ + if (trapping_stmt || gimple_could_trap_p (stmt)) + { + gcc_assert (!trapping_stmt || common_bb); + if (gimple_bb (stmt) != common_bb) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "Build SLP failed: not all stmts in same " + "BB but possibly trapping operation in %G", + trapping_stmt); + continue; + } + } } /* Grouped store or load. */ @@ -1534,9 +1595,9 @@ vect_build_slp_tree_3 (vec_info *vinfo, unsigned char *swap, dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, "Build SLP failed: not grouped load %G", stmt); - if (i != 0) - continue; - return false; + if (is_a (vinfo)) + matches[i] = -2; + continue; } } /* Not memory operation. */ @@ -1549,7 +1610,7 @@ vect_build_slp_tree_3 (vec_info *vinfo, unsigned char *swap, enum tree_code swap_code = ERROR_MARK; enum tree_code invert_code = ERROR_MARK; - if (i == 0) + if (i == (unsigned)first_match) first_cond_code = TREE_CODE (cond_expr); else if (TREE_CODE_CLASS (cond_code) == tcc_comparison) { @@ -1577,7 +1638,7 @@ vect_build_slp_tree_3 (vec_info *vinfo, unsigned char *swap, } } - if (i != 0 + if (i != (unsigned) first_match && first_stmt_code != rhs_code && first_stmt_code.is_tree_code () && rhs_code.is_tree_code () @@ -1586,7 +1647,7 @@ vect_build_slp_tree_3 (vec_info *vinfo, unsigned char *swap, == (tree_code)rhs_code)) swap[i] = 1; - if (i != 0 + if (i != (unsigned) first_match && first_reduc_idx != STMT_VINFO_REDUC_IDX (stmt_info) && first_reduc_idx != -1 && STMT_VINFO_REDUC_IDX (stmt_info) != -1 @@ -1601,50 +1662,49 @@ vect_build_slp_tree_3 (vec_info *vinfo, unsigned char *swap, if (!trapping_stmt && gimple_could_trap_p (stmt)) trapping_stmt = stmt; if (common_bb != gimple_bb (stmt)) - common_bb = NULL; + { + common_bb = NULL; + gcc_assert (!trapping_stmt); + } - matches[i] = true; + matches[i] = first_match; } - if (trapping_stmt && common_bb == NULL) - { - if (dump_enabled_p ()) - dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, - "Build SLP failed: not all stmts in same BB but " - "possibly trapping operation in %G", trapping_stmt); - return false; - } + /* Record if we allowed two distinct operations for the SLP node. */ + if (((first_stmt_code == PLUS_EXPR + || first_stmt_code == MINUS_EXPR) + && (alt_stmt_code == PLUS_EXPR + || alt_stmt_code == MINUS_EXPR)) + || ((first_stmt_code == CFN_FMA + || first_stmt_code == CFN_FMS) + && (alt_stmt_code == CFN_FMA + || alt_stmt_code == CFN_FMS))) + *two_operators = true; - /* If we allowed a two-operation SLP node verify the target can cope - with the permute we are going to use. */ - if (alt_stmt_code != ERROR_MARK - && (!alt_stmt_code.is_tree_code () - || (TREE_CODE_CLASS (tree_code (alt_stmt_code)) != tcc_reference - && TREE_CODE_CLASS (tree_code (alt_stmt_code)) != tcc_comparison))) + if (first_match == -1) { - *two_operators = true; + /* If there was no useful stmt, fail. Can only happen during + the first sweep. */ + gcc_assert (*start_i == 0); + *start_i = stmts.length () - 1; + return false; } + *start_i = first_match; return true; } /* Verify if the scalar stmts STMTS are isomorphic, require data permutation or are of unsupported types of operation. Return true if they are, otherwise return false and indicate in *MATCHES - which stmts are not isomorphic to the first one. If MATCHES[0] - is false then this indicates the comparison could not be - carried out or the stmts will never be vectorized by SLP. - - Note COND_EXPR is possibly isomorphic to another one after swapping its - operands. Set SWAP[i] to 1 if stmt I is COND_EXPR and isomorphic to - the first stmt by swapping the two operands of comparison; set SWAP[i] - to 2 if stmt I is isormorphic to the first stmt by inverting the code - of comparison. Take A1 >= B1 ? X1 : Y1 as an example, it can be swapped - to (B1 <= A1 ? X1 : Y1); or be inverted to (A1 < B1) ? Y1 : X1. */ + the groups of isomorphic stmts. See vect_build_slp_tree_3 for + details. *TWO_OPERATORS is for the first isomorphic group, + knowledge whether following isomorphic groups have one or two operators + is not retained. */ static bool vect_build_slp_tree_1 (vec_info *vinfo, unsigned char *swap, - vec stmts, bool *matches, + vec stmts, match_elt_t *matches, bool *two_operators, tree *node_vectype) { stmt_vec_info first_stmt_info = stmts[0]; @@ -1654,7 +1714,7 @@ vect_build_slp_tree_1 (vec_info *vinfo, unsigned char *swap, group_size)) { /* Fatal mismatch. */ - matches[0] = false; + matches[0] = -1; return false; } if (is_a (vinfo) @@ -1664,7 +1724,7 @@ vect_build_slp_tree_1 (vec_info *vinfo, unsigned char *swap, dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, "Build SLP failed: not using single lane " "vector type %T\n", vectype); - matches[0] = false; + matches[0] = -1; return false; } /* Check nunits required but continue analysis, producing matches[] @@ -1684,7 +1744,7 @@ vect_build_slp_tree_1 (vec_info *vinfo, unsigned char *swap, || const_nunits > group_size) { /* Fatal mismatch. */ - matches[0] = false; + matches[0] = -1; return false; } maybe_soft_fail = true; @@ -1693,24 +1753,41 @@ vect_build_slp_tree_1 (vec_info *vinfo, unsigned char *swap, gcc_assert (vectype || !gimple_get_lhs (first_stmt_info->stmt)); *node_vectype = vectype; - if (!vect_build_slp_tree_3 (vinfo, swap, stmts, matches, two_operators, - vectype)) + unsigned start_i = 0; + if (!vect_build_slp_tree_3 (vinfo, stmts, matches, swap, two_operators, + vectype, &start_i)) { /* Fatal mismatch. */ - matches[0] = false; + matches[0] = -1; return false; } + gcc_assert (matches[start_i] == (int)start_i); + /* Discover further isomorphic groups. */ + for (start_i = start_i + 1; start_i < group_size; ++start_i) + if (matches[start_i] == -1) + { + unsigned prev_start_i = start_i; + bool tem_two_operators; + bool res = vect_build_slp_tree_3 (vinfo, stmts, matches, swap, + &tem_two_operators, + vectype, &start_i); + gcc_assert (res && matches[start_i] == (int)prev_start_i); + } + bool res = true; for (unsigned i = 0; i < group_size; ++i) - if (!matches[i]) - return false; + if (matches[i] != 0) + res = false; + if (!res) + return false; if (maybe_soft_fail) { /* With constant vector elements simulate a mismatch at the - point we need to split. */ + point we need to split. But indicate the tail is isomorphic. */ unsigned tail = group_size & (const_nunits - 1); - memset (&matches[group_size - tail], 0, sizeof (bool) * tail); + for (unsigned i = group_size - tail; i < group_size; ++i) + matches[i] = (int)(group_size - tail); return false; } @@ -1879,13 +1956,14 @@ static unsigned least_upthread_swappable_op_distance = -1U; static slp_tree vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, vec stmts, - bool *matches, unsigned *limit, unsigned *tree_size, + match_elt_t *matches, unsigned *limit, + unsigned *tree_size, scalar_stmts_to_slp_tree_map_t *bst_map); static slp_tree vect_build_slp_tree (vec_info *vinfo, vec stmts, - bool *matches, unsigned *limit, unsigned *tree_size, + match_elt_t *matches, unsigned *limit, unsigned *tree_size, scalar_stmts_to_slp_tree_map_t *bst_map) { unsigned int group_size = stmts.length (); @@ -1901,7 +1979,7 @@ vect_build_slp_tree (vec_info *vinfo, stmts.release (); return *leader; } - memcpy (matches, (*leader)->failed, sizeof (bool) * group_size); + memcpy (matches, (*leader)->failed, sizeof (match_elt_t) * group_size); return NULL; } @@ -1914,7 +1992,7 @@ vect_build_slp_tree (vec_info *vinfo, if (dump_enabled_p ()) dump_printf_loc (MSG_NOTE, vect_location, "SLP discovery limit exceeded\n"); - memset (matches, 0, sizeof (bool) * group_size); + memset (matches, -1, sizeof (match_elt_t) * group_size); return NULL; } --*limit; @@ -1942,16 +2020,16 @@ vect_build_slp_tree (vec_info *vinfo, as backedge destinations. */ SLP_TREE_SCALAR_STMTS (res) = vNULL; SLP_TREE_DEF_TYPE (res) = vect_uninitialized_def; - res->failed = XNEWVEC (bool, group_size); + res->failed = XNEWVEC (match_elt_t, group_size); if (flag_checking) { unsigned i; for (i = 0; i < group_size; ++i) - if (!matches[i]) + if (matches[i] != 0) break; gcc_assert (i < group_size); } - memcpy (res->failed, matches, sizeof (bool) * group_size); + memcpy (res->failed, matches, sizeof (match_elt_t) * group_size); } else { @@ -2016,13 +2094,14 @@ vect_slp_build_two_operator_nodes (slp_tree perm, tree vectype, static slp_tree vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, vec stmts, - bool *matches, unsigned *limit, unsigned *tree_size, + match_elt_t *matches, unsigned *limit, + unsigned *tree_size, scalar_stmts_to_slp_tree_map_t *bst_map) { unsigned int group_size = stmts.length (); unsigned nops, i, this_tree_size = 0; - matches[0] = false; + matches[0] = -1; stmt_vec_info stmt_info = stmts[0]; if (!is_a (stmt_info->stmt) @@ -2170,7 +2249,7 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, || STMT_VINFO_STRIDED_P (stmt_info)) { load_permutation.release (); - matches[0] = false; + matches[0] = -1; return NULL; } @@ -2195,7 +2274,8 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, stmts2[i++] = NULL; stmts2[i++] = si; } - bool *matches2 = XALLOCAVEC (bool, dr_group_size); + match_elt_t *matches2 + = XALLOCAVEC (match_elt_t, dr_group_size); slp_tree unperm_load = vect_build_slp_tree (vinfo, stmts2, matches2, limit, &this_tree_size, bst_map); @@ -2219,7 +2299,7 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, } stmts2.release (); load_permutation.release (); - matches[0] = false; + matches[0] = -1; return NULL; } load_permutation.release (); @@ -2255,7 +2335,7 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, bit_field_size (bfref), &lane)) { lperm.release (); - matches[0] = false; + matches[0] = -1; return NULL; } lperm.safe_push (std::make_pair (0, (unsigned)lane)); @@ -2367,9 +2447,9 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, { /* ??? Here we could slip in magic to compensate with neutral operands. */ - matches[lane] = false; + matches[lane] = -1; if (lane != group_size - 1) - matches[0] = false; + matches[0] = -1; break; } chains.quick_push (chain.copy ()); @@ -2430,9 +2510,9 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, dump_printf_loc (MSG_NOTE, vect_location, "giving up on chain due to mismatched " "def types\n"); - matches[lane] = false; + matches[lane] = -1; if (lane != group_size - 1) - matches[0] = false; + matches[0] = -1; goto out; } dts[n] = dt; @@ -2447,7 +2527,7 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, || !can_duplicate_and_interleave_p (vinfo, group_size, type))) { - matches[0] = false; + matches[0] = -1; goto out; } } @@ -2507,7 +2587,8 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, /* ??? We're likely getting too many fatal mismatches here so maybe we want to ignore them (but then we have no idea which lanes fatally mismatched). */ - if (child || !matches[0]) + /* ??? Revisit this with matches[] improvements. */ + if (child || matches[0] != 0) break; /* Swap another lane we have not yet matched up into lanes that did not match. If we run out of @@ -2515,7 +2596,7 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, search. */ bool term = false; for (lane = 1; lane < group_size; ++lane) - if (!matches[lane]) + if (matches[lane] != 0) { if (n + perms[lane] + 1 == chain_len) { @@ -2542,9 +2623,9 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, "failed to match up op %d\n", n); op_stmts.release (); if (lane != group_size - 1) - matches[0] = false; + matches[0] = -1; else - matches[lane] = false; + matches[lane] = -1; goto out; } if (dump_enabled_p ()) @@ -2687,12 +2768,13 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, swap[i], skip_args, stmts, i, &oprnds_info); if (res != 0) - matches[(res == -1) ? 0 : i] = false; - if (!matches[0]) + /* ??? This puts -1 back into matches[] and the cache. */ + matches[(res == -1) ? 0 : i] = -1; + if (matches[0] == -1) break; } for (i = 0; i < group_size; ++i) - if (!matches[i]) + if (matches[i] != 0) { vect_free_oprnd_info (oprnds_info); return NULL; @@ -2884,7 +2966,7 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, oprnd_info->ops.length (), TREE_TYPE (op0))) { - matches[j] = false; + matches[j] = -1; if (dump_enabled_p ()) dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, "Build SLP failed: invalid type of def " @@ -3024,7 +3106,7 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, and one can be commuted try that for the scalar stmts that failed the match. */ if (/* A first scalar stmt mismatch signals a fatal mismatch. */ - matches[0] + matches[0] == 0 && can_swap) { /* See whether we can swap the matching or the non-matching @@ -3034,7 +3116,7 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, { for (j = 0; j < group_size; ++j) { - if (matches[j] != !swap_not_matching) + if ((matches[j] == 0) != !swap_not_matching) continue; /* Verify if we can swap operands of this stmt. */ if (!stmt_can_swap[j]) @@ -3053,7 +3135,7 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, dump_printf_loc (MSG_NOTE, vect_location, "Re-trying with swapped operands of stmts "); for (j = 0; j < group_size; ++j) - if (matches[j] == !swap_not_matching) + if ((matches[j] == 0) == !swap_not_matching) { std::swap (oprnds_info[0]->def_stmts[j], oprnds_info[1]->def_stmts[j]); @@ -3069,7 +3151,7 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, if (oprnds_info[0]->any_pattern || oprnds_info[1]->any_pattern) oprnds_info[0]->any_pattern = oprnds_info[1]->any_pattern = true; /* And try again with scratch 'matches' ... */ - bool *tem = XALLOCAVEC (bool, group_size); + match_elt_t *tem = XALLOCAVEC (match_elt_t, group_size); if ((child = vect_build_slp_tree (vinfo, oprnd_info->def_stmts, tem, limit, &this_tree_size, bst_map)) != NULL) @@ -3097,8 +3179,10 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, discovery may still be fixed by retrying with swapped operands. */ && (least_upthread_swappable_op_distance != 1 /* A first scalar stmt mismatch signals a fatal mismatch - that the parent commutative retry cannot recover. */ - || !matches[0]) + that the parent commutative retry cannot recover. + ??? Possibly revisit this with the matches[] improvements + as we can have matches[0] == -2 here. */ + || matches[0] != 0) && !is_pattern_stmt_p (stmt_info) && !oprnd_info->any_pattern) { @@ -3108,7 +3192,7 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, /* ??? We might want to split here and combine the results to support multiple vector sizes better. */ for (j = 0; j < group_size; ++j) - if (!matches[j]) + if (matches[j] != 0) break; if (!known_ge (j, TYPE_VECTOR_SUBPARTS (vectype)) && vect_slp_can_convert_to_external (oprnd_info->def_stmts)) @@ -3168,7 +3252,7 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, && is_a (stmt_info->stmt))) { /* Roll back. */ - matches[0] = false; + matches[0] = -1; FOR_EACH_VEC_ELT (children, j, child) if (child) vect_free_slp_tree (child); @@ -3793,7 +3877,7 @@ optimize_load_redistribution_1 (scalar_stmts_to_slp_tree_map_t *bst_map, "converting stmts on permute node %p\n", (void *) root); - bool *matches = XALLOCAVEC (bool, group_size); + match_elt_t *matches = XALLOCAVEC (match_elt_t, group_size); unsigned tree_size = 0, limit = 1; node = vect_build_slp_tree (vinfo, stmts, matches, &limit, &tree_size, bst_map); @@ -4206,14 +4290,14 @@ vect_build_slp_instance (vec_info *vinfo, /* Build the tree for the SLP instance. */ unsigned int group_size = scalar_stmts.length (); - bool *matches = XALLOCAVEC (bool, group_size); + match_elt_t *matches = XALLOCAVEC (match_elt_t, group_size); unsigned tree_size = 0; slp_tree node = NULL; if (group_size > 1 && force_single_lane) { - matches[0] = true; - matches[1] = false; + matches[0] = 0; + matches[1] = -1; } else node = vect_build_slp_tree (vinfo, scalar_stmts, matches, limit, @@ -4272,11 +4356,11 @@ vect_build_slp_instance (vec_info *vinfo, otherwise we get the non-power-of-two tail of the lanes failed. For BB reductions we mainly want to catch the first case so we pick a more useful subset of lanes to reduce. */ - if (kind == slp_inst_kind_bb_reduc && matches[0]) + if (kind == slp_inst_kind_bb_reduc && matches[0] == 0) { unsigned n_matching = 0; for (unsigned i = 0; i < group_size; ++i) - if (matches[i]) + if (matches[i] == 0) n_matching++; vec scalar_stmts2 = vNULL; /* Try matched parts and put the rest to remain. */ @@ -4288,7 +4372,7 @@ vect_build_slp_instance (vec_info *vinfo, finish discovery. */ scalar_stmts2.create (n_matching); for (unsigned i = 0; i < group_size; ++i) - if (matches[i]) + if (matches[i] == 0) scalar_stmts2.quick_push (scalar_stmts[i]); else remain.safe_push @@ -4303,7 +4387,7 @@ vect_build_slp_instance (vec_info *vinfo, time prefering the matching[] part. */ scalar_stmts2.create (scalar_stmts.length () - n_matching); for (unsigned i = 0; i < group_size; ++i) - if (!matches[i]) + if (matches[i] != 0) scalar_stmts2.quick_push (scalar_stmts[i]); else remain.safe_push @@ -4500,7 +4584,7 @@ vect_analyze_slp_reduc_chain (loop_vec_info vinfo, } unsigned int group_size = scalar_stmts.length (); - bool *matches = XALLOCAVEC (bool, group_size); + match_elt_t *matches = XALLOCAVEC (match_elt_t, group_size); unsigned tree_size = 0; slp_tree node = vect_build_slp_tree (vinfo, scalar_stmts, matches, limit, &tree_size, bst_map); @@ -4641,7 +4725,7 @@ vect_analyze_slp_reduc_chain (loop_vec_info vinfo, /* Build the tree for the SLP instance. */ unsigned int group_size = scalar_stmts.length (); - bool *matches = XALLOCAVEC (bool, group_size); + match_elt_t *matches = XALLOCAVEC (match_elt_t, group_size); unsigned tree_size = 0; /* ??? We need this only for SLP discovery. */ @@ -4787,7 +4871,7 @@ vect_analyze_slp_reduction (loop_vec_info vinfo, /* Build the tree for the SLP instance. */ unsigned int group_size = scalar_stmts.length (); - bool *matches = XALLOCAVEC (bool, group_size); + match_elt_t *matches = XALLOCAVEC (match_elt_t, group_size); unsigned tree_size = 0; slp_tree node = vect_build_slp_tree (vinfo, scalar_stmts, matches, limit, @@ -4849,7 +4933,7 @@ vect_analyze_slp_reduction_group (loop_vec_info loop_vinfo, vec scalar_stmts, scalar_stmts_to_slp_tree_map_t *bst_map, unsigned max_tree_size, unsigned *limit, - bool *matches) + match_elt_t *matches) { /* Try to form a reduction group. Size-1 groups are not suitable for SLP reduction and should fall back to single-lane reduction. */ @@ -4857,7 +4941,7 @@ vect_analyze_slp_reduction_group (loop_vec_info loop_vinfo, if (group_size <= 1) return false; if (!matches) - matches = XALLOCAVEC (bool, group_size); + matches = XALLOCAVEC (match_elt_t, group_size); unsigned tree_size = 0; slp_tree node = vect_build_slp_tree (loop_vinfo, scalar_stmts, matches, limit, &tree_size, bst_map); @@ -4953,7 +5037,7 @@ vect_analyze_slp_reductions (loop_vec_info loop_vinfo, { /* Try to form a reduction group. */ unsigned int group_size = scalar_stmts.length (); - bool *matches = XALLOCAVEC (bool, group_size); + match_elt_t *matches = XALLOCAVEC (match_elt_t, group_size); if (vect_analyze_slp_reduction_group (loop_vinfo, scalar_stmts, bst_map, max_tree_size, limit, matches)) return true; @@ -4963,13 +5047,14 @@ vect_analyze_slp_reductions (loop_vec_info loop_vinfo, that on failure (to limit compile-time costs), but recurse for the initial non-matching parts. Everything not covered by a sub-group gets single-reduction treatment. */ + /* ??? Improve this with the matches[] improvements. */ vec cands = vNULL; - while (matches[0]) + while (matches[0] == 0) { cands.truncate (0); cands.reserve (group_size, true); for (unsigned i = 0; i < group_size; ++i) - if (matches[i]) + if (matches[i] == 0) cands.quick_push (scalar_stmts[i]); /* Try to form a reduction group. */ @@ -4995,7 +5080,7 @@ vect_analyze_slp_reductions (loop_vec_info loop_vinfo, possibly repeating the above with updated matches[]. */ unsigned j = 0; for (unsigned i = 0; i < group_size; ++i) - if (!matches[i]) + if (matches[i] != 0) { scalar_stmts[j] = scalar_stmts[i]; ++j; @@ -5073,15 +5158,15 @@ vect_analyze_slp_instance (vec_info *vinfo, /* Build the tree for the SLP instance. */ unsigned int group_size = scalar_stmts.length (); - bool *matches = XALLOCAVEC (bool, group_size); + match_elt_t *matches = XALLOCAVEC (match_elt_t, group_size); unsigned tree_size = 0; unsigned i; slp_tree node = NULL; if (group_size > 1 && force_single_lane) { - matches[0] = true; - matches[1] = false; + matches[0] = 0; + matches[1] = -1; } else node = vect_build_slp_tree (vinfo, scalar_stmts, matches, limit, @@ -5125,13 +5210,14 @@ vect_analyze_slp_instance (vec_info *vinfo, /* Failed to SLP. */ /* Try to break the group up into pieces. */ + /* ??? Improve this with the matches[] improvements. */ if (*limit > 0 && kind == slp_inst_kind_store) { /* ??? We could delay all the actual splitting of store-groups until after SLP discovery of the original group completed. Then we can recurse to vect_build_slp_instance directly. */ for (i = 0; i < group_size; i++) - if (!matches[i]) + if (matches[i] != 0) break; /* For basic block SLP, try to break the group up into multiples of @@ -5272,11 +5358,11 @@ vect_analyze_slp_instance (vec_info *vinfo, build at a mismatch but the matching part hard-fails later. As we know we arrived here with a group larger than one try a group of size one! */ - if (!matches[0]) + if (matches[0] != 0) end = start + 1; else for (unsigned j = start; j < end; j++) - if (!matches[j - start]) + if (matches[j - start] != 0) { end = j; break; @@ -5602,7 +5688,7 @@ vect_lower_load_permutations (loop_vec_info loop_vinfo, } for (unsigned i = 0; i < DR_GROUP_GAP (first); ++i) stmts.quick_push (NULL); - bool *matches = XALLOCAVEC (bool, group_lanes); + match_elt_t *matches = XALLOCAVEC (match_elt_t, group_lanes); unsigned limit = 1; unsigned tree_size = 0; slp_tree l0 = vect_build_slp_tree (loop_vinfo, stmts, matches, &limit, diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h index 7ce13828c0a2..abd9edc27431 100644 --- a/gcc/tree-vectorizer.h +++ b/gcc/tree-vectorizer.h @@ -316,6 +316,18 @@ struct vect_load_store_data : vect_data { bool subchain_p; // VMAT_STRIDED_SLP and VMAT_GATHER_SCATTER }; +struct match_elt_t { + int v; + operator bool () const = delete; + match_elt_t& operator= (bool) = delete; + match_elt_t& operator= (int v_) { v = v_; return *this; } +}; + +inline bool operator!= (const match_elt_t &m, const match_elt_t &m2) { return m.v != m2.v; } +inline bool operator== (const match_elt_t &m, const match_elt_t &m2) { return m.v == m2.v; } +inline bool operator== (const match_elt_t &m, int v) { return m.v == v; } +inline bool operator!= (const match_elt_t &m, int v) { return m.v != v; } + /* A computation tree of an SLP instance. Each node corresponds to a group of stmts to be packed in a SIMD stmt. */ struct _slp_tree { @@ -400,7 +412,7 @@ struct _slp_tree { /* If not NULL this is a cached failed SLP discovery attempt with the lanes that failed during SLP discovery as 'false'. This is a copy of the matches array. */ - bool *failed; + match_elt_t *failed; /* Allocate from slp_tree_pool. */ static void *operator new (size_t); From 194d91912cb3fc86dcce7d13d2239f46ab988b03 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Fri, 28 Aug 2026 12:24:57 +0200 Subject: [PATCH 158/584] Simplify BB reduction group splitting With the matches[] improvement we can now readily pick the largest isomorphic group to vectorize directly. * tree-vect-slp.cc (vect_build_slp_instance): Pick the largest isomorphic subset when vectorizing a BB reduction. --- gcc/tree-vect-slp.cc | 45 +++++++++++++++++--------------------------- 1 file changed, 17 insertions(+), 28 deletions(-) diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc index f88646879b7b..06c241a75624 100644 --- a/gcc/tree-vect-slp.cc +++ b/gcc/tree-vect-slp.cc @@ -4355,46 +4355,35 @@ vect_build_slp_instance (vec_info *vinfo, Iff there is any mismatches in the toplevel stmts those will prevail, otherwise we get the non-power-of-two tail of the lanes failed. For BB reductions we mainly want to catch the first case so we pick - a more useful subset of lanes to reduce. */ - if (kind == slp_inst_kind_bb_reduc && matches[0] == 0) + a more useful subset of lanes to reduce. Pick the largest matching + subset of that covers half of the group or more. */ + if (kind == slp_inst_kind_bb_reduc && matches[0] != -1) { - unsigned n_matching = 0; + unsigned *n_matching = XALLOCAVEC (unsigned, group_size); + memset (n_matching, 0, sizeof (unsigned) * group_size); for (unsigned i = 0; i < group_size; ++i) - if (matches[i] == 0) - n_matching++; - vec scalar_stmts2 = vNULL; - /* Try matched parts and put the rest to remain. */ - if (n_matching >= 2 && n_matching >= group_size / 2) + if (matches[i] != -2 && matches[i] != -1) + n_matching[matches[i].v]++; + unsigned largest_i = 0; + for (unsigned i = 1; i < group_size; ++i) + if (n_matching[i] > n_matching[largest_i]) + largest_i = i; + /* Pick the largest matching part and put the rest to remain. */ + if (n_matching[largest_i] >= 2 + && n_matching[largest_i] >= group_size / 2) { /* As we know the matches[] stmts match up, recursing for non-power-of-two sizes will just force-fail the tail for us at hopefully optimal vector size and succesfully finish discovery. */ - scalar_stmts2.create (n_matching); - for (unsigned i = 0; i < group_size; ++i) - if (matches[i] == 0) - scalar_stmts2.quick_push (scalar_stmts[i]); - else - remain.safe_push - (gimple_get_lhs (vect_orig_stmt (scalar_stmts[i])->stmt)); - } - /* Try the non-matching part. */ - else if (group_size - n_matching >= 2) - { - /* We do not know whether the !matches[] part matches, so avoid - cutting to a multiple of the vector size too early. We should - make progress by means of remain only growing and most of the - time prefering the matching[] part. */ - scalar_stmts2.create (scalar_stmts.length () - n_matching); + vec scalar_stmts2; + scalar_stmts2.create (n_matching[largest_i]); for (unsigned i = 0; i < group_size; ++i) - if (matches[i] != 0) + if (matches[i] == (int)largest_i) scalar_stmts2.quick_push (scalar_stmts[i]); else remain.safe_push (gimple_get_lhs (vect_orig_stmt (scalar_stmts[i])->stmt)); - } - if (scalar_stmts2.exists ()) - { if (dump_enabled_p ()) dump_printf_loc (MSG_NOTE, vect_location, "Splitting %d " "non-matching lanes to scalar remains\n", From 9f6eb7d2993046e5720275f590098db0ac0188d4 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Thu, 17 Sep 2026 13:14:04 +0200 Subject: [PATCH 159/584] tree-optimization/127405 fix epilogue iteration bound when the control IV wraps tree_transform_and_unroll_loop records an upper bound of FACTOR - 1 latch iterations on the epilogue loop it creates. That is justified by the main unrolled loop consuming all but less than FACTOR iterations, i.e. by ENTER_MAIN_COND being false implying that less than FACTOR iterations are left. determine_exit_conditions however builds ENTER_MAIN_COND by rewriting a NE_EXPR exit test into a LT_EXPR/GT_EXPR comparison of the control IV, which is only valid when that IV does not wrap. For void test (unsigned long n, int *a, int *b) { for (unsigned long i = n - 2; i + 2 != 0; --i) a[i+2] = b[i+2] - a[i+3] - a[i+5] + (int)(i + 2); } the control IV runs from n - 3 downwards to (unsigned long) -2, so with FACTOR 3 the guard that BOUND - DELTA does not overflow is constant false and ENTER_MAIN_COND folds to false. Predictive commoning then unrolls, the main loop is removed as unreachable and the epilogue - which performs all n iterations - is left claiming an upper bound of 2. Loop peeling subsequently peeled three iterations and dropped the loop, so at -O3 the testcase was miscompiled. Only set the epilogue bound (and scale its profile accordingly) when the exit test is not a NE_EXPR one or the control IV is known not to wrap. In the remaining case the epilogue keeps the bound inherited from the original loop, which is correct whether or not the main loop is entered. PR tree-optimization/127405 * tree-ssa-loop-manip.cc (tree_transform_and_unroll_loop): Only set nb_iterations_upper_bound of the epilogue loop and scale its profile when the control IV is known not to wrap. * gcc.dg/tree-ssa/predcom-10.c: New test. --- gcc/testsuite/gcc.dg/tree-ssa/predcom-10.c | 42 ++++++++++++++++++++++ gcc/tree-ssa-loop-manip.cc | 31 +++++++++++----- 2 files changed, 64 insertions(+), 9 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/predcom-10.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/predcom-10.c b/gcc/testsuite/gcc.dg/tree-ssa/predcom-10.c new file mode 100644 index 000000000000..b6d87a62c34f --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/predcom-10.c @@ -0,0 +1,42 @@ +/* PR/127405 */ +/* Predictive commoning used to unroll the loop below and wrongly record an + upper bound of UNROLL_FACTOR - 1 iterations on the epilogue loop, even + though the main unrolled loop is never entered because the control IV + wraps. Later loop peeling then dropped all but the first three + iterations. */ + +/* { dg-do run } */ +/* { dg-options "-O2 -fpredictive-commoning -fpeel-loops" } */ + +extern void abort (void); + +int a[12], b[12]; + +void __attribute__((noipa)) +test (unsigned long n, int *a, int *b) +{ + /* I wraps around zero, the exit test is I + 2 != 0. */ + for (unsigned long i = n - 2; i + 2 != 0; --i) + a[i + 2] = b[i + 2] - a[i + 3] - a[i + 5] + (int) (i + 2); +} + +int +main (int argc, char **argv) +{ + /* N is 6, but not known to the compiler. */ + unsigned long n = argc + 5; + + for (int i = 0; i < 12; i++) + { + a[i] = 0; + b[i] = i + 1; + } + + test (n, a, b); + + if (a[6] != 13 || a[5] != -2 || a[4] != 11 + || a[3] != -17 || a[2] != 24 || a[1] != -32) + abort (); + + return 0; +} diff --git a/gcc/tree-ssa-loop-manip.cc b/gcc/tree-ssa-loop-manip.cc index 486667bd937a..7e1a183a1785 100644 --- a/gcc/tree-ssa-loop-manip.cc +++ b/gcc/tree-ssa-loop-manip.cc @@ -1243,16 +1243,29 @@ tree_transform_and_unroll_loop (class loop *loop, unsigned factor, /* The epilog loop latch executes at most factor - 1 times. Since the epilog is entered unconditionally it will need to handle - up to factor executions of its body. */ - new_loop->any_upper_bound = true; - new_loop->nb_iterations_upper_bound = factor - 1; - /* We do not really know estimate on number of iterations, since we do not - track any estimates modulo unroll factor. - Drop estimate from loop_info and scale loop profile. - It may be more realistic to scale loop profile to factor / 2 - 1, - but vectorizer also uses factor - 1. */ + up to factor executions of its body. + + That however relies on ENTER_MAIN_COND being false implying that + less than factor iterations are left. determine_exit_conditions + derives ENTER_MAIN_COND from a LT_EXPR/GT_EXPR comparison of the + control IV, which for a NE_EXPR exit test is only valid if that IV + does not wrap. When it may wrap the main loop can be skipped (the + condition may even be constant false) while the epilog still runs + all iterations of the original loop, so keep the bound we inherited + from it. */ + if (desc->cmp != NE_EXPR || desc->control.no_overflow) + { + new_loop->any_upper_bound = true; + new_loop->nb_iterations_upper_bound = factor - 1; + /* We do not really know estimate on number of iterations, since we + do not track any estimates modulo unroll factor. + Scale loop profile. It may be more realistic to scale loop + profile to factor / 2 - 1, but vectorizer also uses factor - 1. */ + scale_loop_profile (new_loop, profile_probability::always (), + factor - 1); + } + /* Drop estimate from loop_info, see above. */ new_loop->any_estimate = false; - scale_loop_profile (new_loop, profile_probability::always (), factor - 1); } else new_exit = single_dom_exit (loop); From d2c10df0920856a3ccf62900e2c8736fb0ada736 Mon Sep 17 00:00:00 2001 From: Paul Thomas Date: Sun, 13 Sep 2026 12:32:22 +0100 Subject: [PATCH 160/584] Fortran: Parameterized derived type component initialization [PR104776] 2026-09-17 Paul Thomas gcc/fortran PR fortran/104776 * decl.cc (gfc_get_pdt_instance): Simplify the initializers of KIND components in PDT templates since they must be integer constants. Catch any remaining component initializers for parameter substitution, if necessary, and simplification. gcc/testsuite PR fortran/104776 * gfortran.dg/pdt_94.f03: New test. --- gcc/fortran/decl.cc | 17 ++++++++++ gcc/testsuite/gfortran.dg/pdt_94.f03 | 49 ++++++++++++++++++++++++++++ 2 files changed, 66 insertions(+) create mode 100644 gcc/testsuite/gfortran.dg/pdt_94.f03 diff --git a/gcc/fortran/decl.cc b/gcc/fortran/decl.cc index 4871737458ef..3eb660a93d47 100644 --- a/gcc/fortran/decl.cc +++ b/gcc/fortran/decl.cc @@ -4503,6 +4503,11 @@ gfc_get_pdt_instance (gfc_actual_arglist *param_list, gfc_symbol **sym, c2->param_list->next = NULL; } + /* Initializer expressions in PDT templates, such as character_kinds(1), + can end up being mutilated when use associated. Simplify now. */ + if (c1->initializer && c1->initializer->expr_type != EXPR_CONSTANT) + gfc_simplify_expr (c1->initializer, 1); + if (!c2->initializer && c1->initializer) c2->initializer = gfc_copy_expr (c1->initializer); @@ -4655,6 +4660,18 @@ gfc_get_pdt_instance (gfc_actual_arglist *param_list, gfc_symbol **sym, } gfc_simplify_expr (c2->initializer, 1); } + + /* Pick up any remaining initializers that could be simplified. */ + if (c1->initializer) + { + if (!c2->initializer) + c2->initializer = gfc_copy_expr (c1->initializer); + if (gfc_derived_parameter_expr (c2->initializer)) + gfc_insert_parameter_exprs (c2->initializer, type_param_spec_list); + c2->initializer->ts = c2->ts; + if (!!gfc_is_constant_expr (c2->initializer)) + gfc_simplify_expr (c2->initializer, 1); + } } if (alloc_seen) diff --git a/gcc/testsuite/gfortran.dg/pdt_94.f03 b/gcc/testsuite/gfortran.dg/pdt_94.f03 new file mode 100644 index 000000000000..ab0d65e3bc9a --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pdt_94.f03 @@ -0,0 +1,49 @@ +! { dg-do run } +! +! Test the fix for PR104776. +! +! Contributed by Amir Shahmoradi +! +module pdt_mod + + use iso_fortran_env, only: character_kinds + + integer, parameter :: def_kind = selected_char_kind('ascii') + integer, parameter :: unicode_kind = selected_char_kind('ISO_10646') + character(kind=unicode_kind,len=*), parameter :: str = 'abcde' + + type :: BG_type(kind_p) +! This is still failing. + integer , kind :: kind_p = character_kinds(1) +! integer , kind :: kind_p = def_kind + character(5 , kind_p) :: str = achar(97,kind_p)//achar(98,kind_p)// & + achar(99,kind_p)//achar(100,kind_p)//achar(101,kind_p) + end type + +! These declarations worked as expected +! type (BG_type) :: a_m = BG_type (def_kind)("abcde") +! type (BG_type(selected_char_kind('ISO_10646'))) :: b_m = BG_type (selected_char_kind('ISO_10646'))(str) +! Now so do these + type (BG_type) :: a_m + type (BG_type(unicode_kind)) :: b_m + +contains + subroutine print_mod_vars () + if (a_m%str /= 'abcde') stop 1 + if (b_m%str /= str) stop 2 + end +end module + + use pdt_mod + type (BG_type) :: a ! Caused an ICE + type (BG_type(unicode_kind)) :: b + a_m = BG_type (def_kind)("abcde") + b_m = BG_type (unicode_kind)(str) + if (a%str%kind /= def_kind) stop 3 + if (b%str%kind /= unicode_kind) stop 4 + if (a%str /= 'abcde') stop 5 + if (b%str /= str) stop 6 + if (a_m%str /= 'abcde') stop 7 + if (b_m%str /= str) stop 8 + call print_mod_vars () +end From 9713ce4f550fdbc3bf23132bc208831a8d71d862 Mon Sep 17 00:00:00 2001 From: Paul Thomas Date: Wed, 16 Sep 2026 16:50:27 +0100 Subject: [PATCH 161/584] Fortran: Fix a number of issues with parameterized strings [PR125690] 2026-09-16 Paul Thomas gcc/fortran PR fortran/125690 * decl.cc (gfc_get_pdt_instance): PDT strings with explicit array specifications are also PDT arrays. If the component is allocatable, the typespec must be marked deferred. * resolve.cc (resolve_structure_cons): Skip the string length check for PDT types. (resolve_allocate_expr): Initialize cmp to 0. Do not emit error if cmp = -3 since different variable could have the same value. * trans-array.cc (gfc_conv_scalarized_array_ref): Force pointer arithmetic by setting 'decl' for PDT strings. (gfc_conv_array_ref): Likewise. (structure_alloc_comps ): Move the declaraion of 'strlen' up. Evaluate the bounds and offset for pdt_strings as well as pdt arrays. If non-null, use strlen to obtain the size for malloc. Set the span to strlen. If the component type is a descriptor, rather than just a PDT array, use its data forboth the non-null condition and setting to null. * trans-io.cc (gfc_trans_transfer): PDT string arrays must be scalarized. gcc/testsuite PR fortran/125690 * gfortran.dg/pdt_95.f03: New test. --- gcc/fortran/decl.cc | 4 + gcc/fortran/resolve.cc | 8 +- gcc/fortran/trans-array.cc | 41 ++++--- gcc/fortran/trans-io.cc | 3 + gcc/testsuite/gfortran.dg/pdt_95.f03 | 170 +++++++++++++++++++++++++++ 5 files changed, 206 insertions(+), 20 deletions(-) create mode 100644 gcc/testsuite/gfortran.dg/pdt_95.f03 diff --git a/gcc/fortran/decl.cc b/gcc/fortran/decl.cc index 3eb660a93d47..01b6109940c5 100644 --- a/gcc/fortran/decl.cc +++ b/gcc/fortran/decl.cc @@ -4591,6 +4591,10 @@ gfc_get_pdt_instance (gfc_actual_arglist *param_list, gfc_symbol **sym, gfc_free_expr (e); if (c2->ts.u.cl->length->expr_type != EXPR_CONSTANT) c2->attr.pdt_string = 1; + if (c1->as && c1->as->type == AS_EXPLICIT) + c2->attr.pdt_array = 1; + else if (c1->attr.allocatable) + c2->ts.deferred = 1; } /* Recurse into this function for PDT components. */ diff --git a/gcc/fortran/resolve.cc b/gcc/fortran/resolve.cc index 3a747aa5512b..60c5610bba45 100644 --- a/gcc/fortran/resolve.cc +++ b/gcc/fortran/resolve.cc @@ -1435,8 +1435,8 @@ resolve_structure_cons (gfc_expr *expr, int init) /* For strings, the length of the constructor should be the same as the one of the structure, ensure this if the lengths are known at compile time and when we are dealing with PARAMETER or structure - constructors. */ - if (cons->expr->ts.type == BT_CHARACTER + constructors. Skip for PDT types which have type parameters. */ + if (!IS_PDT (expr) && cons->expr->ts.type == BT_CHARACTER && comp->ts.type == BT_CHARACTER && comp->ts.u.cl && comp->ts.u.cl->length && comp->ts.u.cl->length->expr_type == EXPR_CONSTANT @@ -9531,14 +9531,14 @@ resolve_allocate_expr (gfc_expr *e, gfc_code *code, bool *array_alloc_wo_spec) if (code->ext.alloc.ts.type == BT_CHARACTER && !e->ts.deferred && !UNLIMITED_POLY (e)) { - int cmp; + int cmp = 0; if (!e->ts.u.cl->length) goto failure; cmp = gfc_dep_compare_expr (e->ts.u.cl->length, code->ext.alloc.ts.u.cl->length); - if (cmp == 1 || cmp == -1 || cmp == -3) + if (cmp == 1 || cmp == -1) { gfc_error ("Allocating %s at %L with type-spec requires the same " "character-length parameter as in the declaration", diff --git a/gcc/fortran/trans-array.cc b/gcc/fortran/trans-array.cc index 3e3e88012efd..bbd50aa2ab47 100644 --- a/gcc/fortran/trans-array.cc +++ b/gcc/fortran/trans-array.cc @@ -4064,8 +4064,9 @@ gfc_conv_scalarized_array_ref (gfc_se * se, gfc_array_ref * ar, the descriptor, mark the resulting variable decl and pass it to gfc_build_array_ref. */ if (span_addressed_array (info->descriptor) - || (expr && expr->ts.deferred && info->descriptor - && GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (info->descriptor)))) + || (expr && ((expr->ts.deferred && info->descriptor + && GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (info->descriptor))) + || (expr && gfc_expr_attr (expr).pdt_string)))) { if (TREE_CODE (info->descriptor) == COMPONENT_REF) decl = info->descriptor; @@ -4325,16 +4326,14 @@ gfc_conv_array_ref (gfc_se * se, gfc_array_ref * ar, gfc_expr *expr, } else if (expr->ts.deferred || (sym->ts.type == BT_CHARACTER - && sym->attr.select_type_temporary)) + && sym->attr.select_type_temporary) + || (expr->ts.type == BT_CHARACTER + && GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (se->expr)) + && gfc_expr_attr (expr).pdt_string)) { - if (GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (se->expr))) - { - decl = se->expr; - if (INDIRECT_REF_P (decl)) - decl = TREE_OPERAND (decl, 0); - } - else - decl = sym->backend_decl; + decl = se->expr; + if (INDIRECT_REF_P (decl)) + decl = TREE_OPERAND (decl, 0); } else if (sym->ts.type == BT_CLASS) { @@ -10276,6 +10275,7 @@ structure_alloc_comps (gfc_symbol * der_type, tree decl, tree dest, bool inside_wrapper = generating_copy_helper; bool is_pdt_type = IS_PDT (c); + tree strlen = NULL_TREE; cdecl = c->backend_decl; ctype = TREE_TYPE (cdecl); @@ -10699,7 +10699,7 @@ structure_alloc_comps (gfc_symbol * der_type, tree decl, tree dest, else gfc_add_modify (&fnblock, comp, build_int_cst (TREE_TYPE (comp), 0)); - if (gfc_deferred_strlen (c, &comp)) + if (!c->attr.pdt_string && gfc_deferred_strlen (c, &comp)) { comp = fold_build3_loc (input_location, COMPONENT_REF, TREE_TYPE (comp), @@ -11106,7 +11106,6 @@ structure_alloc_comps (gfc_symbol * der_type, tree decl, tree dest, { gfc_se tse; gfc_init_se (&tse, NULL); - tree strlen = NULL_TREE; gfc_expr *e = gfc_copy_expr (c->ts.u.cl->length); /* Convert the parameterized string length to its value. The string length is stored in a hidden field in the same way as @@ -11145,7 +11144,9 @@ structure_alloc_comps (gfc_symbol * der_type, tree decl, tree dest, if (c->ts.type == BT_CLASS) comp = gfc_class_data_get (comp); - if (c->attr.pdt_array) + if (c->attr.pdt_array + || (c->attr.pdt_string + && GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (comp)))) { gfc_se tse; int i; @@ -11208,6 +11209,8 @@ structure_alloc_comps (gfc_symbol * der_type, tree decl, tree dest, tmp = build_fold_indirect_ref_loc (input_location, tmp); tmp = gfc_vptr_size_get (tmp); } + else if (strlen != NULL_TREE) + tmp = strlen; else tmp = TYPE_SIZE_UNIT (gfc_get_element_type (ctype)); tmp = fold_convert (gfc_array_index_type, tmp); @@ -11218,6 +11221,12 @@ structure_alloc_comps (gfc_symbol * der_type, tree decl, tree dest, gfc_conv_descriptor_data_set (&fnblock, comp, tmp); gfc_conv_descriptor_dtype_set (&fnblock, comp, gfc_get_dtype (ctype)); + if (strlen != NULL_TREE) + { + tmp = gfc_conv_descriptor_elem_len_get (comp); + gfc_add_modify (&fnblock, tmp, fold_convert (TREE_TYPE (tmp), strlen)); + gfc_conv_descriptor_span_set (&fnblock, comp, strlen); + } if (c->initializer && c->initializer->rank) { @@ -11280,7 +11289,7 @@ structure_alloc_comps (gfc_symbol * der_type, tree decl, tree dest, if (c->attr.pdt_array || c->attr.pdt_string) { tmp = comp; - if (c->attr.pdt_array) + if (GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (comp))) tmp = gfc_conv_descriptor_data_get (comp); null_cond = fold_build2_loc (input_location, NE_EXPR, logical_type_node, tmp, @@ -11316,7 +11325,7 @@ structure_alloc_comps (gfc_symbol * der_type, tree decl, tree dest, build_empty_stmt (input_location)); gfc_add_expr_to_block (&fnblock, tmp); - if (c->attr.pdt_array) + if (GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (comp))) gfc_conv_descriptor_data_set (&fnblock, comp, null_pointer_node); else { diff --git a/gcc/fortran/trans-io.cc b/gcc/fortran/trans-io.cc index 94a782f3af76..48fdaa5e7335 100644 --- a/gcc/fortran/trans-io.cc +++ b/gcc/fortran/trans-io.cc @@ -2655,6 +2655,9 @@ gfc_trans_transfer (gfc_code * code) && gfc_expr_attr (expr).target))) goto scalarize; + if (gfc_expr_attr (expr).pdt_string) + goto scalarize; + /* With array-bounds checking enabled, force scalarization in some situations, e.g., when an array index depends on a function evaluation or an expression and possibly has side-effects. */ diff --git a/gcc/testsuite/gfortran.dg/pdt_95.f03 b/gcc/testsuite/gfortran.dg/pdt_95.f03 new file mode 100644 index 000000000000..da3b2f128043 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pdt_95.f03 @@ -0,0 +1,170 @@ +! { dg-do run } +! +! Test the fix for PR125690, where an ICE occurred on deallocating the +! PDT string components. +! +! Contributed by David Binderman +! and Paul Thomas for tests in comment #5. +! +module m + integer, parameter :: def_kind = selected_char_kind('ascii') + integer, parameter :: unicode_kind = selected_char_kind('ISO_10646') + character(kind = unicode_kind,len = 7) :: cc1(5) = ['a','b','c','d','e'] + character(kind = def_kind, len = 5) :: str(3) = ['abcde','fghij','klmno'] +end module + +module m5 +! Declarations for comment #5 + type ux(l,m) + integer, len :: l,m + character(len=l) :: x(m) + integer :: tag + end type + type uy(l) + integer, len :: l + character(len=l) :: x(3) + integer :: tag + end type + type uz(l) + integer, len :: l + character(len=l), allocatable :: x(:) + integer :: tag + end type + integer :: n = 5 +end module + +program p + use m + use m5 + call sub1(cc1) ! Check ascii kind + call sub2(cc1) ! Check unicode kind +! Tests from comment #5 + block + type(uy(n)) :: obj + obj%tag = 42 + obj%x(1) = 'aaaaa' + obj%x(2) = 'bbbbb' + obj%x(3) = 'ccccc' + if (len(obj%x) /= 5) stop 101 + if (size(obj%x) /= 3) stop 102 + if (obj%x(1) /= 'aaaaa') stop 103 + if (obj%x(2) /= 'bbbbb') stop 104 + if (obj%x(3) /= 'ccccc') stop 105 + if (obj%tag /= 42) stop 106 + end block + call foo(n) + call bar(n,3) + call foobar(n) +contains + subroutine sub1(cc1) + character(kind = 4,len = 7)::cc1(5) + Type ty(k1) + Integer,kind :: k1 + character(kind= k1,len = len(cc1)+k1) :: ch(len(cc1)-5) + character(kind= k1,len = 2+len(cc1)+k1) :: c(len(cc1)*5) + character(kind= k1,len = kind(cc1)+k1) :: ch1(len(cc1)) + character(kind= k1,len = kind(cc1)+2) :: c2(kind(cc1)) + character(kind= k1,len = len(cc1)+2) :: ch2(kind(cc1)) + End type + Type(ty(def_kind)) :: obj + if(len(obj%ch) .ne. len(cc1) + def_kind) stop 1 + if(len(obj%c) .ne. 2 + len(cc1) + def_kind) stop 2 + if(len(obj%ch1) .ne. kind(cc1) + def_kind) stop 3 + if(len(obj%c2) .ne. 6) stop 4 + if(len(obj%ch2) .ne. 9) stop 5 + if(ubound(obj%ch,1) .ne. 2) stop 6 + if(ubound(obj%ch1,1) .ne. 7) stop 7 + if(ubound(obj%c,1) .ne. 35) stop 8 + if(ubound(obj%ch2,1) .ne. 4) stop 9 + if(ubound(obj%c2,1) .ne. 4) stop 10 + end subroutine + subroutine sub2(cc1) + character(kind = 4,len = 7)::cc1(5) + Type ty(k1) + Integer,kind :: k1 + character(kind= k1,len = len(cc1)+k1) :: ch(len(cc1)-5) + character(kind= k1,len = 2+len(cc1)+k1) :: c(len(cc1)*5) + character(kind= k1,len = kind(cc1)+k1) :: ch1(len(cc1)) + character(kind= k1,len = kind(cc1)+2) :: c2(kind(cc1)) + character(kind= k1,len = len(cc1)+2) :: ch2(kind(cc1)) + End type + Type(ty(unicode_kind)) :: obj + if(len(obj%ch) .ne. len(cc1) + unicode_kind) stop 11 + if(len(obj%c) .ne. 2 + len(cc1) + unicode_kind) stop 12 + if(len(obj%ch1) .ne. kind(cc1) + unicode_kind) stop 13 + if(len(obj%c2) .ne. 6) stop 14 + if(len(obj%ch2) .ne. 9) stop 15 + if(ubound(obj%ch,1) .ne. 2) stop 16 + if(ubound(obj%ch1,1) .ne. 7) stop 17 + if(ubound(obj%c,1) .ne. 35) stop 18 + if(ubound(obj%ch2,1) .ne. 4) stop 19 + if(ubound(obj%c2,1) .ne. 4) stop 20 + end subroutine + +! Comment #5 tests + subroutine foo(i) + integer :: i + character(kind = def_kind, len = 3 * i) :: buffer + type(uy(i)) :: obj + obj%tag = 42 + obj%x(1) = 'aaaaa' + obj%x(2) = 'bbbbb' + obj%x(3) = 'ccccc' + if (len(obj%x) /= 5) stop 111 + if (size(obj%x) /= 3) stop 112 + if (obj%x(1) /= 'aaaaa') stop 113 + if (obj%x(2) /= 'bbbbb') stop 114 + if (obj%x(3) /= 'ccccc') stop 115 + if (obj%tag /= 42) stop 116 +! It was noticed, while verifying the patch for this PR, that these PDT string +! components were not scalarizing correctly nor were they transferring to IO. + obj%x = str + if (any (obj%x /= str)) stop 117 + write (buffer, '(3a5)') obj%x + if (buffer /= 'abcdefghijklmno') stop 118 + end + subroutine bar(i,j) + integer :: i, j + character(kind = def_kind, len = j * i) :: buffer + type(ux(i, j)) :: obj + obj%tag = 42 + obj%x(1) = 'aaaaa' + obj%x(2) = 'bbbbb' + obj%x(3) = 'ccccc' + if (len(obj%x) /= 5) stop 121 + if (size(obj%x) /= 3) stop 122 + if (obj%x(1) /= 'aaaaa') stop 123 + if (obj%x(2) /= 'bbbbb') stop 124 + if (obj%x(3) /= 'ccccc') stop 125 + if (obj%tag /= 42) stop 126 +! It was noticed, while verifying the patch for this PR, that these PDT string +! components were not scalarizing correctly nor were they transferring to IO. + obj%x = str + if (any (obj%x /= str)) stop 127 + write (buffer, '(3a5)') obj%x + if (buffer /= 'abcdefghijklmno') stop 128 + end + subroutine foobar(i) + integer :: i + character(kind = def_kind, len = 3 * i) :: buffer +! Note that, with the present patch, the declaration produces +! obj.x.data = 0B; twice because it is allocatable and a PDT string. + type(uz(i)) :: obj + allocate (character(len=i) :: obj%x(3)) + obj%tag = 42 + obj%x(1) = 'aaaaa' + obj%x(2) = 'bbbbb' + obj%x(3) = 'ccccc' + if (len(obj%x) /= 5) stop 131 + if (size(obj%x) /= 3) stop 132 + if (obj%x(1) /= 'aaaaa') stop 133 + if (obj%x(2) /= 'bbbbb') stop 134 + if (obj%x(3) /= 'ccccc') stop 135 + if (obj%tag /= 42) stop 136 + obj%x = str +! Allocatable pdt_string components were OK for scalariztion and IO. + if (any (obj%x /= str)) stop 137 + write (buffer, '(3a5)') obj%x + if (buffer /= 'abcdefghijklmno') stop 138 + end +End From 409e74cc30b03afda59fc0d5711be71cd2e1bb59 Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Wed, 16 Sep 2026 10:56:07 +0100 Subject: [PATCH 162/584] libstdc++: Make __gnu_test::semaphore work without SysV semget [PR127425] MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Port the testsuite's simple semaphore type to use POSIX semaphores when System V semaphores are not supported, as the latter are part of the XSI option and not mandated by POSIX. For the POSIX semaphore path we need to use mmap to create the semaphore in shared memory and also need to handle ancient systems without MAP_ANONYMOUS support. We use unnamed semaphores because using sem_open to create a named semaphore requires creating two or more unique names per test that work even when the tests are run in parallel, which would get awkward. Although it might appear better to prefer the new path and use POSIX semaphores by default, that wouldn't work because macOS defines _POSIX_SEMAPHORES to a positive value but its sem_init always returns ENOSYS at runtime. Instead of trying sem_init and then switching to shmget as a runtime fallback, we might as well just continue using the code that we know works fine - i.e. the SysV semaphore implementation. The new sem_init path is only used for systems where the existing code doesn't work, which currently just PASS the tests incorrectly as described in Bug 127425. For the case where neither SysV nor POSIX semaphores are available, make the __gnu_test::semaphore constructor abort, so the tests FAIL loudly instead of a silent PASS. This fixes the main points raised in the bug report. Move the definition of the semaphore to a new header, so that it's only defined in the handful of tests that actually use it, and move the definitions of the member functions to a new .cc file. In passing, fix a resource leak in the existing code for the case where semget creates a new semaphore set but semctl fails to initialize it. Because SysV semaphores are kernel objects, the set would not be destroyed when the process exits. Use semctl with IPC_RMID before throwing an exception, so that the kernel removes the semaphore set. Also make the __gnu_test::semaphore class non-copyable to prevent misuse and double-frees. Also add a dejagnu dg-require-sysv-or-posix-semaphore directive so that tests which don't support either type of semaphore will be UNSUPPORTED instead of PASS (or FAIL with the new aborting constructor). This test uses _XOPEN_UNIX rather than the three autoconf macros that are checked in testsuite_semaphore.cc but that is a reasonable proxy for SysV semaphore support. It might mean that some very old systems mark those tests as UNSUPPORTED when they do actually support the SysV semaphores without defining the _XOPEN_UNIX macro. I can live with that. It would be nice to use std::unique_ptr with a custom deleter to manage the SysV semaphore set or the mmap region and POSIX semaphore. That could only be done as local variables in testsuite_semaphore.cc not as a non-static data member of __gnu_test::semaphore, because the tests which use __gnu_test::semaphore need to run as C++98 and so they can't use std::unique_ptr in the header. The additional logic to define and use a custom deleter doesn't seem worth it if it wouldn't actually remove the __gnu_test::semaphore destructor. libstdc++-v3/ChangeLog: PR libstdc++/127425 * doc/xml/manual/test.xml: Document new testsuite header. * doc/html/manual/test.html: Regenerate. * testsuite/27_io/basic_filebuf/close/char/4879.cc: Use new dg-require-sysv-or-posix-semaphore directive. * testsuite/27_io/basic_filebuf/close/char/9964.cc: Likewise. * testsuite/27_io/basic_filebuf/imbue/char/13171-2.cc: Likewise. * testsuite/27_io/basic_filebuf/imbue/wchar_t/14975-2.cc: Likewise. * testsuite/27_io/basic_filebuf/seekoff/char/26777.cc: Likewise. * testsuite/27_io/basic_filebuf/underflow/char/10097.cc: Likewise. * testsuite/27_io/objects/char/7.cc: Likewise. * testsuite/27_io/objects/char/9661-1.cc: Likewise. * testsuite/27_io/objects/wchar_t/7.cc: Likewise. * testsuite/27_io/objects/wchar_t/9661-1.cc: Likewise. * testsuite/lib/dg-options.exp (dg-require-sysv-or-posix-semaphore): New proc. * testsuite/lib/libstdc++.exp (v3-build_support): Add new file to list of testsuite source files. (check_v3_target_posix_or_sysv_semaphore): New proc. * testsuite/util/testsuite_hooks.cc (semaphore): Move to new file. * testsuite/util/testsuite_hooks.h (semaphore): Likewise. * testsuite/util/testsuite_semaphore.cc: Move definition of semaphore member functions here. Fix resource leak in constructor if semctl fails. Add fallback using mmap+sem_init instead of semget+semctl. * testsuite/util/testsuite_semaphore.h: Move definition of semaphore to here. Replace sem_set_ data member with anonymous union. Add deleted copy operations. Reviewed-by: Tomasz Kamiński --- libstdc++-v3/doc/html/manual/test.html | 6 +- libstdc++-v3/doc/xml/manual/test.xml | 8 + .../27_io/basic_filebuf/close/char/4879.cc | 2 + .../27_io/basic_filebuf/close/char/9964.cc | 2 + .../27_io/basic_filebuf/imbue/char/13171-2.cc | 2 + .../basic_filebuf/imbue/wchar_t/14975-2.cc | 2 + .../27_io/basic_filebuf/seekoff/char/26777.cc | 2 + .../basic_filebuf/underflow/char/10097.cc | 2 + .../testsuite/27_io/objects/char/7.cc | 2 + .../testsuite/27_io/objects/char/9661-1.cc | 2 + .../testsuite/27_io/objects/wchar_t/7.cc | 2 + .../testsuite/27_io/objects/wchar_t/9661-1.cc | 2 + libstdc++-v3/testsuite/lib/dg-options.exp | 9 + libstdc++-v3/testsuite/lib/libstdc++.exp | 11 ++ .../testsuite/util/testsuite_hooks.cc | 96 ---------- libstdc++-v3/testsuite/util/testsuite_hooks.h | 24 --- .../testsuite/util/testsuite_semaphore.cc | 170 ++++++++++++++++++ .../testsuite/util/testsuite_semaphore.h | 68 +++++++ 18 files changed, 291 insertions(+), 121 deletions(-) create mode 100644 libstdc++-v3/testsuite/util/testsuite_semaphore.cc create mode 100644 libstdc++-v3/testsuite/util/testsuite_semaphore.h diff --git a/libstdc++-v3/doc/html/manual/test.html b/libstdc++-v3/doc/html/manual/test.html index 404d7ddbf879..1db7dd5bcae7 100644 --- a/libstdc++-v3/doc/html/manual/test.html +++ b/libstdc++-v3/doc/html/manual/test.html @@ -647,7 +647,11 @@

A number of class abstractions for performance counters, and reporting functions including: -

  • time_counter

  • resource_counter

  • report_performance

Special Topics

+

  • time_counter

  • resource_counter

  • report_performance

  • + testsuite_semaphore.h +

    + A simple binary semaphore used for some multi-process I/O tests. +

    • Special Topics

    Qualifying Exception Safety Guarantees

    Overview

    diff --git a/libstdc++-v3/doc/xml/manual/test.xml b/libstdc++-v3/doc/xml/manual/test.xml index 68b5f8aedb41..f5c441bd9413 100644 --- a/libstdc++-v3/doc/xml/manual/test.xml +++ b/libstdc++-v3/doc/xml/manual/test.xml @@ -1081,6 +1081,14 @@ only default variables. report_performance + + + testsuite_semaphore.h + + + A simple binary semaphore used for some multi-process I/O tests. + + diff --git a/libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/4879.cc b/libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/4879.cc index 3e0b134edb95..5246a33e8493 100644 --- a/libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/4879.cc +++ b/libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/4879.cc @@ -1,5 +1,6 @@ // { dg-require-fork "" } // { dg-require-mkfifo "" } +// { dg-require-sysv-or-posix-semaphore "" } // Copyright (C) 2001-2026 Free Software Foundation, Inc. // @@ -33,6 +34,7 @@ #include #include +#include // libstdc++/2913, libstdc++/4879 // John Fardo , Brad Garcia diff --git a/libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/9964.cc b/libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/9964.cc index ba864fa7e9e8..84b406ac0727 100644 --- a/libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/9964.cc +++ b/libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/9964.cc @@ -1,5 +1,6 @@ // { dg-require-fork "" } // { dg-require-mkfifo "" } +// { dg-require-sysv-or-posix-semaphore "" } // Copyright (C) 2001-2026 Free Software Foundation, Inc. // @@ -32,6 +33,7 @@ #include #include +#include // libstdc++/9964 bool test_07() diff --git a/libstdc++-v3/testsuite/27_io/basic_filebuf/imbue/char/13171-2.cc b/libstdc++-v3/testsuite/27_io/basic_filebuf/imbue/char/13171-2.cc index 5a42e18834b0..210efae9a98a 100644 --- a/libstdc++-v3/testsuite/27_io/basic_filebuf/imbue/char/13171-2.cc +++ b/libstdc++-v3/testsuite/27_io/basic_filebuf/imbue/char/13171-2.cc @@ -2,6 +2,7 @@ // { dg-require-namedlocale "en_US.ISO8859-1" } // { dg-require-fork "" } // { dg-require-mkfifo "" } +// { dg-require-sysv-or-posix-semaphore "" } // Copyright (C) 2003-2026 Free Software Foundation, Inc. // @@ -30,6 +31,7 @@ #include #include +#include // libstdc++/13171 bool test01() diff --git a/libstdc++-v3/testsuite/27_io/basic_filebuf/imbue/wchar_t/14975-2.cc b/libstdc++-v3/testsuite/27_io/basic_filebuf/imbue/wchar_t/14975-2.cc index f4dadd917ee9..886b7d66053b 100644 --- a/libstdc++-v3/testsuite/27_io/basic_filebuf/imbue/wchar_t/14975-2.cc +++ b/libstdc++-v3/testsuite/27_io/basic_filebuf/imbue/wchar_t/14975-2.cc @@ -1,6 +1,7 @@ // { dg-require-namedlocale "en_US.ISO8859-1" } // { dg-require-fork "" } // { dg-require-mkfifo "" } +// { dg-require-sysv-or-posix-semaphore "" } // 2004-04-16 Petur Runolfsson @@ -31,6 +32,7 @@ #include #include +#include // libstdc++/14975 bool test01() diff --git a/libstdc++-v3/testsuite/27_io/basic_filebuf/seekoff/char/26777.cc b/libstdc++-v3/testsuite/27_io/basic_filebuf/seekoff/char/26777.cc index b003090f920c..1931db09ad04 100644 --- a/libstdc++-v3/testsuite/27_io/basic_filebuf/seekoff/char/26777.cc +++ b/libstdc++-v3/testsuite/27_io/basic_filebuf/seekoff/char/26777.cc @@ -1,5 +1,6 @@ // { dg-require-fork "" } // { dg-require-mkfifo "" } +// { dg-require-sysv-or-posix-semaphore "" } // 2006-03-22 Paolo Carlini @@ -21,6 +22,7 @@ // . #include +#include #include #include #include diff --git a/libstdc++-v3/testsuite/27_io/basic_filebuf/underflow/char/10097.cc b/libstdc++-v3/testsuite/27_io/basic_filebuf/underflow/char/10097.cc index e7c9a91aca04..c320b99920bd 100644 --- a/libstdc++-v3/testsuite/27_io/basic_filebuf/underflow/char/10097.cc +++ b/libstdc++-v3/testsuite/27_io/basic_filebuf/underflow/char/10097.cc @@ -1,5 +1,6 @@ // { dg-require-fork "" } // { dg-require-mkfifo "" } +// { dg-require-sysv-or-posix-semaphore "" } // 2001-05-21 Benjamin Kosnik @@ -31,6 +32,7 @@ #include #include +#include class UnderBuf : public std::filebuf { diff --git a/libstdc++-v3/testsuite/27_io/objects/char/7.cc b/libstdc++-v3/testsuite/27_io/objects/char/7.cc index b5e6fe5b6d7b..2edcf56f7889 100644 --- a/libstdc++-v3/testsuite/27_io/objects/char/7.cc +++ b/libstdc++-v3/testsuite/27_io/objects/char/7.cc @@ -1,5 +1,6 @@ // { dg-require-fork "" } // { dg-require-mkfifo "" } +// { dg-require-sysv-or-posix-semaphore "" } // 2003-04-26 Petur Runolfsson @@ -31,6 +32,7 @@ #include #include #include +#include // Check that cout.flush() is called when last ios_base::Init is destroyed. bool test07() diff --git a/libstdc++-v3/testsuite/27_io/objects/char/9661-1.cc b/libstdc++-v3/testsuite/27_io/objects/char/9661-1.cc index d9e39cd80c83..9374685969db 100644 --- a/libstdc++-v3/testsuite/27_io/objects/char/9661-1.cc +++ b/libstdc++-v3/testsuite/27_io/objects/char/9661-1.cc @@ -1,5 +1,6 @@ // { dg-require-fork "" } // { dg-require-mkfifo "" } +// { dg-require-sysv-or-posix-semaphore "" } // 2003-04-30 Petur Runolfsson @@ -21,6 +22,7 @@ // . #include +#include #include #include #include diff --git a/libstdc++-v3/testsuite/27_io/objects/wchar_t/7.cc b/libstdc++-v3/testsuite/27_io/objects/wchar_t/7.cc index 2c03fa1791b9..cc6a2fa3e7d0 100644 --- a/libstdc++-v3/testsuite/27_io/objects/wchar_t/7.cc +++ b/libstdc++-v3/testsuite/27_io/objects/wchar_t/7.cc @@ -1,5 +1,6 @@ // { dg-require-fork "" } // { dg-require-mkfifo "" } +// { dg-require-sysv-or-posix-semaphore "" } // 2003-05-01 Petur Runolfsson @@ -32,6 +33,7 @@ #include #include +#include // Check that wcout.flush() is called when last ios_base::Init is destroyed. bool test07() diff --git a/libstdc++-v3/testsuite/27_io/objects/wchar_t/9661-1.cc b/libstdc++-v3/testsuite/27_io/objects/wchar_t/9661-1.cc index f49d010fbf91..f8194aef3eec 100644 --- a/libstdc++-v3/testsuite/27_io/objects/wchar_t/9661-1.cc +++ b/libstdc++-v3/testsuite/27_io/objects/wchar_t/9661-1.cc @@ -1,5 +1,6 @@ // { dg-require-fork "" } // { dg-require-mkfifo "" } +// { dg-require-sysv-or-posix-semaphore "" } // 2003-04-30 Petur Runolfsson @@ -21,6 +22,7 @@ // . #include +#include #include #include #include diff --git a/libstdc++-v3/testsuite/lib/dg-options.exp b/libstdc++-v3/testsuite/lib/dg-options.exp index 615a57992602..a9563026174d 100644 --- a/libstdc++-v3/testsuite/lib/dg-options.exp +++ b/libstdc++-v3/testsuite/lib/dg-options.exp @@ -286,6 +286,15 @@ proc dg-require-cpp-feature-test { n args } { return } +proc dg-require-sysv-or-posix-semaphore { args } { + if { ![ check_v3_target_posix_or_sysv_semaphore ] } { + upvar dg-do-what dg-do-what + set dg-do-what [list [lindex ${dg-do-what} 0] "N" "P"] + return + } + return +} + proc add_options_for_no_pch { flags } { # Remove any inclusion of bits/stdc++.h from the options. regsub -all -- "-include bits/stdc...h" $flags "" flags diff --git a/libstdc++-v3/testsuite/lib/libstdc++.exp b/libstdc++-v3/testsuite/lib/libstdc++.exp index cda231246cb0..a7b66fe9784b 100644 --- a/libstdc++-v3/testsuite/lib/libstdc++.exp +++ b/libstdc++-v3/testsuite/lib/libstdc++.exp @@ -835,6 +835,7 @@ proc v3-build_support { } { # Build the support objects. set source_files [list testsuite_abi.cc testsuite_allocator.cc \ testsuite_character.cc testsuite_hooks.cc \ + testsuite_semaphore.cc \ io/verified_cmd_line_input.cc \ io/prog_bar.cc performance/time/elapsed_timer.cc ] foreach f $source_files { @@ -1440,6 +1441,16 @@ proc check_v3_target_nprocs { } { }] } +# Return 1 if the POSIX Semaphores option or the XSI option is supported +# for the current target, 0 otherwise. +proc check_v3_target_posix_or_sysv_semaphore { } { + set name "posix_or_sysv_semaphore" + set inc "#include " + set cond "_POSIX_SEMAPHORES > 0 || _XOPEN_UNIX > 0" + set result [v3_check_preprocessor_condition $name $cond $inc] + return $result +} + # Return 1 if linking with -static-libstdc++ works, 0 otherwise. proc check_v3_target_static_libstdcxx { } { return [check_v3_target_prop_cached et_static_libstdcxx { diff --git a/libstdc++-v3/testsuite/util/testsuite_hooks.cc b/libstdc++-v3/testsuite/util/testsuite_hooks.cc index 946bd4a3847a..33ce7112701a 100644 --- a/libstdc++-v3/testsuite/util/testsuite_hooks.cc +++ b/libstdc++-v3/testsuite/util/testsuite_hooks.cc @@ -36,20 +36,6 @@ #include #include -// If we have , , and , then assume -// that System V semaphores are available. -#if defined(_GLIBCXX_HAVE_SYS_TYPES_H) \ - && defined(_GLIBCXX_HAVE_SYS_IPC_H) \ - && defined(_GLIBCXX_HAVE_SYS_SEM_H) -#define _GLIBCXX_SYSV_SEM -#endif - -#ifdef _GLIBCXX_SYSV_SEM -#include -#include -#include -#endif - namespace __gnu_test { #ifdef _GLIBCXX_RES_LIMITS @@ -227,88 +213,6 @@ namespace __gnu_test unsigned int destructor::_M_count = 0; int copy_tracker::next_id_ = 0; -#ifdef _GLIBCXX_SYSV_SEM - // This union is not declared in system headers. Instead, it must - // be defined by user programs. - union semun - { - int val; - struct semid_ds *buf; - unsigned short *array; - }; -#endif - - semaphore::semaphore() - { -#ifdef _GLIBCXX_SYSV_SEM - // Remember the PID for the process that created the semaphore set - // so that only one process will destroy the set. - pid_ = getpid(); - - // GLIBC does not define SEM_R and SEM_A. -#ifndef SEM_R -#define SEM_R 0400 -#endif - -#ifndef SEM_A -#define SEM_A 0200 -#endif - - // Get a semaphore set with one semaphore. - sem_set_ = semget(IPC_PRIVATE, 1, SEM_R | SEM_A); - if (sem_set_ == -1) - std::__throw_runtime_error("could not obtain semaphore set"); - - // Initialize the semaphore. - union semun val; - val.val = 0; - if (semctl(sem_set_, 0, SETVAL, val) == -1) - std::__throw_runtime_error("could not initialize semaphore"); -#else - // There are no semaphores on this system. We have no way to mark - // a test as "unsupported" at runtime, so we just exit, pretending - // that the test passed. - exit(0); -#endif - } - - semaphore::~semaphore() - { -#ifdef _GLIBCXX_SYSV_SEM - union semun val; - val.val = 0; // Avoid uninitialized variable warning. - // Destroy the semaphore set only in the process that created it. - if (pid_ == getpid()) - semctl(sem_set_, 0, IPC_RMID, val); -#endif - } - - void - semaphore::signal() - { -#ifdef _GLIBCXX_SYSV_SEM - struct sembuf op[1] = - { - { 0, 1, 0 } - }; - if (semop(sem_set_, op, 1) == -1) - std::__throw_runtime_error("could not signal semaphore"); -#endif - } - - void - semaphore::wait() - { -#ifdef _GLIBCXX_SYSV_SEM - struct sembuf op[1] = - { - { 0, -1, SEM_UNDO } - }; - if (semop(sem_set_, op, 1) == -1) - std::__throw_runtime_error("could not wait for semaphore"); -#endif - } - // For use in 22_locale/time_get and time_put. std::tm test_tm(int sec, int min, int hour, int mday, int mon, diff --git a/libstdc++-v3/testsuite/util/testsuite_hooks.h b/libstdc++-v3/testsuite/util/testsuite_hooks.h index 49e8f0fe30bf..9d7bec18aa6f 100644 --- a/libstdc++-v3/testsuite/util/testsuite_hooks.h +++ b/libstdc++-v3/testsuite/util/testsuite_hooks.h @@ -335,30 +335,6 @@ namespace __gnu_test } }; - // A binary semaphore for use across multiple processes. - class semaphore - { - public: - // Creates a binary semaphore. The semaphore is initially in the - // unsignaled state. - semaphore(); - - // Destroy the semaphore. - ~semaphore(); - - // Signal the semaphore. If there are processes blocked in - // "wait", exactly one will be permitted to proceed. - void signal(); - - // Wait until the semaphore is signaled. - void wait(); - - private: - int sem_set_; - - pid_t pid_; - }; - // For use in 22_locale/time_get and time_put. std::tm test_tm(int sec, int min, int hour, int mday, int mon, int year, int wday, int yday, int isdst); diff --git a/libstdc++-v3/testsuite/util/testsuite_semaphore.cc b/libstdc++-v3/testsuite/util/testsuite_semaphore.cc new file mode 100644 index 000000000000..208ec09ad289 --- /dev/null +++ b/libstdc++-v3/testsuite/util/testsuite_semaphore.cc @@ -0,0 +1,170 @@ +// -*- C++ -*- + +// Semaphore type for the C++ library testsuite. +// +// Copyright (C) 2005-2026 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library 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. +// +// This library 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 this library; see the file COPYING3. If not see +// . +// + +#include "testsuite_semaphore.h" +#include + +#if defined(_GLIBCXX_HAVE_SYS_TYPES_H) \ + && defined(_GLIBCXX_HAVE_SYS_IPC_H) \ + && defined(_GLIBCXX_HAVE_SYS_SEM_H) +// If we have , , and , then assume +// that System V semaphores are available. +# include +# include +# include +# define _GLIBCXX_SYSV_SEM +#elif defined(_POSIX_SEMAPHORES) && _POSIX_SEMAPHORES > 0 +# include // sem_init, sem_post etc. +# include // mmap, MAP_SHARED etc. +# include // EINTR +# include // open, O_RDWR +# define _GLIBCXX_POSIX_SEM +#else +# include // abort +#endif + +namespace __gnu_test +{ +#ifdef _GLIBCXX_SYSV_SEM + // This union is not declared in system headers. Instead, it must + // be defined by user programs. + union semun + { + int val = 0; + struct semid_ds *buf; + unsigned short *array; + }; + + static void + destroy_semset(int set) + { + semctl(set, 0, IPC_RMID, semun{}); + } +#endif + +#ifdef _GLIBCXX_POSIX_SEM + // Create a new anonymous memory mapping that will be shared after fork(). + static void* + mmap_anon(size_t len) + { + int flags = MAP_SHARED; + int fd = -1; +#ifdef MAP_ANONYMOUS + flags |= MAP_ANONYMOUS; +#elif defined MAP_ANON + flags |= MAP_ANON; +#else + // Use the older idiom of mapping pages from /dev/zero + fd = open("/dev/zero", O_RDWR); + if (fd == -1) + std::__throw_runtime_error("could not open /dev/zero for mmap"); +#endif + + void* p = mmap(nullptr, len, PROT_READ | PROT_WRITE, flags, fd, 0); + if (fd != -1) + close(fd); + if (p == MAP_FAILED) + std::__throw_runtime_error("could not create mmap mapping for semaphore"); + return p; + } +#endif + + semaphore::semaphore() + { +#ifdef _GLIBCXX_SYSV_SEM + // Get a System V semaphore set with one semaphore. + sem_set_ = semget(IPC_PRIVATE, 1, 0600); + if (sem_set_ == -1) + std::__throw_runtime_error("could not obtain semaphore set"); + + // Initialize the semaphore. + if (semctl(sem_set_, 0, SETVAL, semun{}) == -1) + { + destroy_semset(sem_set_); + std::__throw_runtime_error("could not initialize semaphore"); + } +#elif defined _GLIBCXX_POSIX_SEM + // Map some shared memory and initialize a POSIX semaphore there. + sem_ = mmap_anon(sizeof(sem_t)); + if (sem_init((sem_t*)sem_, 1, 0)) + { + munmap(sem_, sizeof(sem_t)); + std::__throw_runtime_error("could not init semaphore in mmap mapping"); + } +#else + // There are no semaphores on this system so make the test FAIL at runtime. + // Use { dg-require-sysv-or-posix-semaphore "" } to make it UNSUPPORTED. + abort(); +#endif + + // Remember the PID for the process that created the semaphore + // so that only one process will destroy it. + pid_ = getpid(); + } + + semaphore::~semaphore() + { + // Destroy the semaphore set only in the process that created it. +#ifdef _GLIBCXX_SYSV_SEM + if (pid_ == getpid()) + destroy_semset(sem_set_); +#elif defined _GLIBCXX_POSIX_SEM + if (pid_ == getpid()) + sem_destroy((sem_t*)sem_); + munmap(sem_, sizeof(sem_t)); +#endif + } + + void + semaphore::signal() + { +#ifdef _GLIBCXX_SYSV_SEM + struct sembuf op[1] = { }; + op[0].sem_op = 1; + if (semop(sem_set_, op, 1) == -1) + std::__throw_runtime_error("could not signal semaphore"); +#elif defined _GLIBCXX_POSIX_SEM + if (sem_post((sem_t*)sem_)) + std::__throw_runtime_error("could not signal semaphore"); +#endif + } + + void + semaphore::wait() + { +#ifdef _GLIBCXX_SYSV_SEM + struct sembuf op[1] = { }; + op[0].sem_op = -1; + op[0].sem_flg = SEM_UNDO; + if (semop(sem_set_, op, 1) == -1) + std::__throw_runtime_error("could not wait for semaphore"); +#elif defined _GLIBCXX_POSIX_SEM + while (true) + { + if (sem_wait((sem_t*)sem_) == 0) + return; + if (errno != EINTR) + std::__throw_runtime_error("could not wait for semaphore"); + } +#endif + } +} // namespace __gnu_test diff --git a/libstdc++-v3/testsuite/util/testsuite_semaphore.h b/libstdc++-v3/testsuite/util/testsuite_semaphore.h new file mode 100644 index 000000000000..1394dc8d180c --- /dev/null +++ b/libstdc++-v3/testsuite/util/testsuite_semaphore.h @@ -0,0 +1,68 @@ +// -*- C++ -*- +// Semaphore type for the C++ library testsuite. +// +// Copyright (C) 2005-2026 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library 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. +// +// This library 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 this library; see the file COPYING3. If not see +// . +// + +#ifndef _GLIBCXX_TESTSUITE_SEMAPHORE_H +#define _GLIBCXX_TESTSUITE_SEMAPHORE_H + +#include + +#ifdef _GLIBCXX_HAVE_UNISTD_H +# include +#endif + +namespace __gnu_test +{ + // A binary semaphore for use across multiple processes. + class semaphore + { + public: + // Creates a binary semaphore. The semaphore is initially in the + // unsignaled state. + semaphore(); + + // Destroy the semaphore. + ~semaphore(); + + // Signal the semaphore. If there are processes blocked in + // "wait", exactly one will be permitted to proceed. + void signal(); + + // Wait until the semaphore is signaled. + void wait(); + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++11-extensions" + semaphore(const semaphore&) = delete; + semaphore& operator=(const semaphore&) = delete; +#pragma GCC diagnostic pop + + private: + union { + int sem_set_; + void* sem_; + }; + pid_t pid_; + }; + +} // namespace __gnu_test + +#endif // _GLIBCXX_TESTSUITE_SEMAPHORE_H + From 819afc442bd1e1b38f60fad174d80f677ab86bf0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?G=C3=B6kbey=20Keskin?= Date: Wed, 16 Sep 2026 17:47:08 +0100 Subject: [PATCH 163/584] libstdc++: Fix tests that open FIFOs with O_RDWR [PR127424] Several tests under 27_io open a FIFO with ios_base::in|ios_base::out, which fopen_mode() maps to "r+", i.e. O_RDWR. POSIX leaves this undefined: O_RDWR Open for reading and writing. The result is undefined if this flag is applied to a FIFO. Linux permits it, so the problem is invisible there, but it is not required. On a target where opening a FIFO O_RDWR fails, the affected tests deadlock: the process that issues the O_RDWR open fails to open the FIFO, so its peer blocks forever in a blocking open() for the opposite direction, because the FIFO never acquires a second endpoint. None of these tests needs read-write access. In every case the process opening in|out only ever writes. Opening write-only replaces the O_RDWR open with the ordinary FIFO rendezvous (child O_WRONLY, parent O_RDONLY, or vice versa), which is fully specified and introduces no ordering hazard. Second, separate issue: close/char/9964.cc has not tested PR 9964 since 2004. PR libstdc++/9964 was fixed by Petur Runolfsson in r0-48647-g0c45b8e0733816 so that basic_filebuf::close() always closes the file even if it returns null to indicate an error. The test as originally committed opened the parent end write-only and asserted exactly that: filebuf* ret = fb.open(name, ios_base::out | ios_base::trunc); ... ret = fb.close(); VERIFY( ret == NULL ); VERIFY( !fb.is_open() ); The write-only open is what makes the flush fail: the child closes the sole read end, the parent's buffered 'a' meets a FIFO with no readers, SIGPIPE is ignored, and write() fails with EPIPE. r0-56237-g6a734d618f8 (2004-02-04, "Correct flags to filebuf::open calls", the commit that introduced fopen_mode) changed both the mode and the expectation: - filebuf* ret = fb.open(name, ios_base::out | ios_base::trunc); + filebuf* ret = fb.open(name, ios_base::in | ios_base::out); ... - VERIFY( ret == NULL ); + VERIFY( ret != NULL ); With O_RDWR the parent holds its own read end, so the write at close succeeds and the failure path is never entered. The test now passes whether or not the PR 9964 fix is present, i.e. it is a dead regression test. So the fix for this file is to restore the original write-only open and the original close() expectation, which also removes its O_RDWR dependency. libstdc++-v3/ChangeLog: PR libstdc++/127424 * testsuite/27_io/basic_filebuf/close/char/9964.cc: Only open filebuf for output and expect close() to return null. * testsuite/27_io/basic_filebuf/seekoff/char/26777.cc: Only open filebuf for output. * testsuite/27_io/basic_filebuf/showmanyc/char/9533-1.cc: Likewise. * testsuite/27_io/basic_filebuf/underflow/char/10097.cc: Likewise. * testsuite/27_io/objects/char/7.cc: Likewise. * testsuite/27_io/objects/char/9661-1.cc: Only open FILE for output. --- .../testsuite/27_io/basic_filebuf/close/char/9964.cc | 7 +++++-- .../testsuite/27_io/basic_filebuf/seekoff/char/26777.cc | 2 +- .../testsuite/27_io/basic_filebuf/showmanyc/char/9533-1.cc | 2 +- .../testsuite/27_io/basic_filebuf/underflow/char/10097.cc | 2 +- libstdc++-v3/testsuite/27_io/objects/char/7.cc | 2 +- libstdc++-v3/testsuite/27_io/objects/char/9661-1.cc | 2 +- 6 files changed, 10 insertions(+), 7 deletions(-) diff --git a/libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/9964.cc b/libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/9964.cc index 84b406ac0727..e34eea5923b8 100644 --- a/libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/9964.cc +++ b/libstdc++-v3/testsuite/27_io/basic_filebuf/close/char/9964.cc @@ -64,15 +64,18 @@ bool test_07() } filebuf fb; - filebuf* ret = fb.open(name, ios_base::in | ios_base::out); + filebuf* ret = fb.open(name, ios_base::out); test &= bool( ret != 0 ); test &= bool( fb.is_open() ); s1.signal(); s2.wait(); fb.sputc('a'); + // The child has closed the only read end of the fifo, so flushing the + // pending 'a' fails with EPIPE. close() must report that failure by + // returning null, but must close the file all the same. ret = fb.close(); - test &= bool( ret != 0 ); + test &= bool( ret == 0 ); test &= bool( !fb.is_open() ); return test; diff --git a/libstdc++-v3/testsuite/27_io/basic_filebuf/seekoff/char/26777.cc b/libstdc++-v3/testsuite/27_io/basic_filebuf/seekoff/char/26777.cc index 1931db09ad04..c7c091e4999e 100644 --- a/libstdc++-v3/testsuite/27_io/basic_filebuf/seekoff/char/26777.cc +++ b/libstdc++-v3/testsuite/27_io/basic_filebuf/seekoff/char/26777.cc @@ -54,7 +54,7 @@ bool test01() if (child == 0) { filebuf fbout; - fbout.open(name, ios_base::in | ios_base::out); + fbout.open(name, ios_base::out); test &= bool( fbout.is_open() ); fbout.sputn("Whatever", 8); fbout.pubsync(); diff --git a/libstdc++-v3/testsuite/27_io/basic_filebuf/showmanyc/char/9533-1.cc b/libstdc++-v3/testsuite/27_io/basic_filebuf/showmanyc/char/9533-1.cc index 57b234515f09..9a42cadacc11 100644 --- a/libstdc++-v3/testsuite/27_io/basic_filebuf/showmanyc/char/9533-1.cc +++ b/libstdc++-v3/testsuite/27_io/basic_filebuf/showmanyc/char/9533-1.cc @@ -55,7 +55,7 @@ void test_01() else if (fval == 0) { filebuf ofbuf; - ofbuf.open(name, ios_base::in|ios_base::out); + ofbuf.open(name, ios_base::out); VERIFY( ofbuf.is_open() ); sleep(1); diff --git a/libstdc++-v3/testsuite/27_io/basic_filebuf/underflow/char/10097.cc b/libstdc++-v3/testsuite/27_io/basic_filebuf/underflow/char/10097.cc index c320b99920bd..eb117bf736ed 100644 --- a/libstdc++-v3/testsuite/27_io/basic_filebuf/underflow/char/10097.cc +++ b/libstdc++-v3/testsuite/27_io/basic_filebuf/underflow/char/10097.cc @@ -74,7 +74,7 @@ bool test16() else if (fval == 0) { filebuf fbout; - fbout.open(name, ios_base::in|ios_base::out); + fbout.open(name, ios_base::out); test &= bool( fbout.is_open() ); fbout.sputn("0123456789", 10); fbout.pubsync(); diff --git a/libstdc++-v3/testsuite/27_io/objects/char/7.cc b/libstdc++-v3/testsuite/27_io/objects/char/7.cc index 2edcf56f7889..5a60e1df2b21 100644 --- a/libstdc++-v3/testsuite/27_io/objects/char/7.cc +++ b/libstdc++-v3/testsuite/27_io/objects/char/7.cc @@ -55,7 +55,7 @@ bool test07() if (child == 0) { filebuf fbout; - fbout.open(name, ios_base::in|ios_base::out); + fbout.open(name, ios_base::out); test &= bool( fbout.is_open() ); s1.wait(); cout.rdbuf(&fbout); diff --git a/libstdc++-v3/testsuite/27_io/objects/char/9661-1.cc b/libstdc++-v3/testsuite/27_io/objects/char/9661-1.cc index 9374685969db..ba7f55c3bf33 100644 --- a/libstdc++-v3/testsuite/27_io/objects/char/9661-1.cc +++ b/libstdc++-v3/testsuite/27_io/objects/char/9661-1.cc @@ -55,7 +55,7 @@ bool test01() if (child == 0) { - FILE* file = fopen(name, "r+"); + FILE* file = fopen(name, "w"); test &= bool( file != 0 ); fputs("Whatever\n", file); fflush(file); From 89271387b915d3947817510d248bb48f129e9ef4 Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Thu, 17 Sep 2026 18:46:41 +0100 Subject: [PATCH 164/584] libstdc++: Avoid hardcoded -std=gnu++26 in testsuite helper proc This proc should use -std=gnu++29 but I forgot to update it in r17-1905-g70e630b6d29b75 so it's now out of date. Replace the hardcoded option by reusing the existing $v3_max_std variable defined earlier. libstdc++-v3/ChangeLog: * testsuite/lib/libstdc++.exp (check_v3_target_cpp_feature_test): Use $v3_max_std variable instead of hardcoding the latest -std option. --- libstdc++-v3/testsuite/lib/libstdc++.exp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libstdc++-v3/testsuite/lib/libstdc++.exp b/libstdc++-v3/testsuite/lib/libstdc++.exp index a7b66fe9784b..4cdf90d3864b 100644 --- a/libstdc++-v3/testsuite/lib/libstdc++.exp +++ b/libstdc++-v3/testsuite/lib/libstdc++.exp @@ -1181,13 +1181,13 @@ proc v3_check_preprocessor_condition { name cond { inc "" } } { # Return 1 if libstdc++ defines macro for the current target, 0 otherwise. proc check_v3_target_cpp_feature_test { cond } { + global v3_max_std global cxxflags set cxxflags_saved $cxxflags # Use the latest standard, so that all feature test macros are defined. # We need to do it here, because this check happens before v3-dg-runtest # runs its loop to test multiple times with different -std options. - # This should be updated when a new -std is added. - set cxxflags "$cxxflags -std=gnu++26" + set cxxflags "$cxxflags -std=gnu++$v3_max_std" set inc "#include " set result [v3_check_preprocessor_condition cpp_feature_test "$cond" $inc] set cxxflags $cxxflags_saved From 6e53e027e587600b914793d79618b61131681862 Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Thu, 17 Sep 2026 19:05:00 +0100 Subject: [PATCH 165/584] libstdc++: Fix name of temporary source used by dejagnu checks The v3_check_preprocessor_condition proc takes an argument to use as the filename, but was then passing it to v3_try_preprocess as the literal string 'name' instead of using the variable, $name. libstdc++-v3/ChangeLog: * testsuite/lib/libstdc++.exp (v3_check_preprocessor_condition): Use argument as filename for preprocessing. --- libstdc++-v3/testsuite/lib/libstdc++.exp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libstdc++-v3/testsuite/lib/libstdc++.exp b/libstdc++-v3/testsuite/lib/libstdc++.exp index 4cdf90d3864b..b2b1934a5240 100644 --- a/libstdc++-v3/testsuite/lib/libstdc++.exp +++ b/libstdc++-v3/testsuite/lib/libstdc++.exp @@ -1176,7 +1176,7 @@ proc v3_check_preprocessor_condition { name cond { inc "" } } { " set flags "$cxxflags $DEFAULT_CXXFLAGS -Werror" - return [v3_try_preprocess name $code $flags] + return [v3_try_preprocess $name $code $flags] } # Return 1 if libstdc++ defines macro for the current target, 0 otherwise. From 5502ee6ed442795c0cac7214bc534c9bd8f16049 Mon Sep 17 00:00:00 2001 From: Andrew MacLeod Date: Mon, 14 Sep 2026 21:55:36 -0400 Subject: [PATCH 166/584] Fill in the partial equivalence entries of the relation tables. When Partial Equivalencies were added, the expectation was they would not interact with the other relations. The tables were not updated leaving the default VARYING which is conservatively correct. Most of those entries genuinely are VARYING but not all of them are. A partial equivalence swaps to itself, intersecting two of them keeps the wider one, VREL_EQ implies every partial equivalence, and the VARYING and UNDEFINED identities have to hold for every kind. Those answers were being lost. Assisted-By: Claude Opus 5. gcc/ * value-relation.cc (rr_negate_table): Fill PE slots. (rr_swap_table): Likewise. (rr_intersect_table): Likewise. (rr_union_table): Likewise. (rr_transitive_table): Likewise. (relation_tests): Also confirm partial equivalency entries. --- gcc/value-relation.cc | 174 ++++++++++++++++++++++++++++++++++-------- 1 file changed, 141 insertions(+), 33 deletions(-) diff --git a/gcc/value-relation.cc b/gcc/value-relation.cc index afe78ed50b71..69b4364b59ad 100644 --- a/gcc/value-relation.cc +++ b/gcc/value-relation.cc @@ -45,9 +45,10 @@ print_relation (FILE *f, relation_kind rel) } // This table is used to negate the operands. op1 REL op2 -> !(op1 REL op2). +// Partial equivalence can't be negated, so VARYING is correct. static const unsigned char rr_negate_table[VREL_LAST] = { VREL_VARYING, VREL_UNDEFINED, VREL_GE, VREL_GT, VREL_LE, VREL_LT, VREL_NE, - VREL_EQ }; + VREL_EQ, VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }; // Negate the relation, as in logical negation. @@ -58,9 +59,10 @@ relation_negate (relation_kind r) } // This table is used to swap the operands. op1 REL op2 -> op2 REL op1. +// Partial equivalences swap to themselves as the low N bits are equal. static const unsigned char rr_swap_table[VREL_LAST] = { VREL_VARYING, VREL_UNDEFINED, VREL_GT, VREL_GE, VREL_LT, VREL_LE, VREL_EQ, - VREL_NE }; + VREL_NE, VREL_PE8, VREL_PE16, VREL_PE32, VREL_PE64 }; // Return the relation as if the operands were swapped. @@ -71,32 +73,58 @@ relation_swap (relation_kind r) } // This table is used to perform an intersection between 2 relations. +// EQ is a full equivalency, and thus replaces any partial equivalence. +// Likewise, the higher bit PE is more "equivalent" than the lower bit version +// and thus more restrictive. static const unsigned char rr_intersect_table[VREL_LAST][VREL_LAST] = { // VREL_VARYING { VREL_VARYING, VREL_UNDEFINED, VREL_LT, VREL_LE, VREL_GT, VREL_GE, VREL_EQ, - VREL_NE }, + VREL_NE, VREL_PE8, VREL_PE16, VREL_PE32, VREL_PE64 }, // VREL_UNDEFINED { VREL_UNDEFINED, VREL_UNDEFINED, VREL_UNDEFINED, VREL_UNDEFINED, + VREL_UNDEFINED, VREL_UNDEFINED, VREL_UNDEFINED, VREL_UNDEFINED, VREL_UNDEFINED, VREL_UNDEFINED, VREL_UNDEFINED, VREL_UNDEFINED }, // VREL_LT { VREL_LT, VREL_UNDEFINED, VREL_LT, VREL_LT, VREL_UNDEFINED, VREL_UNDEFINED, - VREL_UNDEFINED, VREL_LT }, + VREL_UNDEFINED, VREL_LT, + VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }, // VREL_LE { VREL_LE, VREL_UNDEFINED, VREL_LT, VREL_LE, VREL_UNDEFINED, VREL_EQ, - VREL_EQ, VREL_LT }, + VREL_EQ, VREL_LT, + VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }, // VREL_GT { VREL_GT, VREL_UNDEFINED, VREL_UNDEFINED, VREL_UNDEFINED, VREL_GT, VREL_GT, - VREL_UNDEFINED, VREL_GT }, + VREL_UNDEFINED, VREL_GT, + VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }, // VREL_GE { VREL_GE, VREL_UNDEFINED, VREL_UNDEFINED, VREL_EQ, VREL_GT, VREL_GE, - VREL_EQ, VREL_GT }, + VREL_EQ, VREL_GT, + VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }, // VREL_EQ { VREL_EQ, VREL_UNDEFINED, VREL_UNDEFINED, VREL_EQ, VREL_UNDEFINED, VREL_EQ, - VREL_EQ, VREL_UNDEFINED }, + VREL_EQ, VREL_UNDEFINED, + VREL_EQ, VREL_EQ, VREL_EQ, VREL_EQ }, // VREL_NE { VREL_NE, VREL_UNDEFINED, VREL_LT, VREL_LT, VREL_GT, VREL_GT, - VREL_UNDEFINED, VREL_NE } }; + VREL_UNDEFINED, VREL_NE, + VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }, +// VREL_PE8 + { VREL_PE8, VREL_UNDEFINED, VREL_VARYING, VREL_VARYING, VREL_VARYING, + VREL_VARYING, VREL_EQ, VREL_VARYING, + VREL_PE8, VREL_PE16, VREL_PE32, VREL_PE64 }, +// VREL_PE16 + { VREL_PE16, VREL_UNDEFINED, VREL_VARYING, VREL_VARYING, VREL_VARYING, + VREL_VARYING, VREL_EQ, VREL_VARYING, + VREL_PE16, VREL_PE16, VREL_PE32, VREL_PE64 }, +// VREL_PE32 + { VREL_PE32, VREL_UNDEFINED, VREL_VARYING, VREL_VARYING, VREL_VARYING, + VREL_VARYING, VREL_EQ, VREL_VARYING, + VREL_PE32, VREL_PE32, VREL_PE32, VREL_PE64 }, +// VREL_PE64 + { VREL_PE64, VREL_UNDEFINED, VREL_VARYING, VREL_VARYING, VREL_VARYING, + VREL_VARYING, VREL_EQ, VREL_VARYING, + VREL_PE64, VREL_PE64, VREL_PE64, VREL_PE64 } }; // Intersect relation R1 with relation R2 and return the resulting relation. @@ -109,32 +137,54 @@ relation_intersect (relation_kind r1, relation_kind r2) // This table is used to perform a union between 2 relations. +// EQ unions with a PE to produce the same PE, and likewise whichever PE +// has the least common bits forms the union. static const unsigned char rr_union_table[VREL_LAST][VREL_LAST] = { // VREL_VARYING { VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, - VREL_VARYING, VREL_VARYING, VREL_VARYING }, + VREL_VARYING, VREL_VARYING, VREL_VARYING, + VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }, // VREL_UNDEFINED { VREL_VARYING, VREL_UNDEFINED, VREL_LT, VREL_LE, VREL_GT, VREL_GE, - VREL_EQ, VREL_NE }, + VREL_EQ, VREL_NE, VREL_PE8, VREL_PE16, VREL_PE32, VREL_PE64 }, // VREL_LT { VREL_VARYING, VREL_LT, VREL_LT, VREL_LE, VREL_NE, VREL_VARYING, VREL_LE, - VREL_NE }, + VREL_NE, VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }, // VREL_LE { VREL_VARYING, VREL_LE, VREL_LE, VREL_LE, VREL_VARYING, VREL_VARYING, - VREL_LE, VREL_VARYING }, + VREL_LE, VREL_VARYING, + VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }, // VREL_GT { VREL_VARYING, VREL_GT, VREL_NE, VREL_VARYING, VREL_GT, VREL_GE, VREL_GE, - VREL_NE }, + VREL_NE, VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }, // VREL_GE { VREL_VARYING, VREL_GE, VREL_VARYING, VREL_VARYING, VREL_GE, VREL_GE, - VREL_GE, VREL_VARYING }, + VREL_GE, VREL_VARYING, + VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }, // VREL_EQ { VREL_VARYING, VREL_EQ, VREL_LE, VREL_LE, VREL_GE, VREL_GE, VREL_EQ, - VREL_VARYING }, + VREL_VARYING, VREL_PE8, VREL_PE16, VREL_PE32, VREL_PE64 }, // VREL_NE { VREL_VARYING, VREL_NE, VREL_NE, VREL_VARYING, VREL_NE, VREL_VARYING, - VREL_VARYING, VREL_NE } }; + VREL_VARYING, VREL_NE, + VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }, +// VREL_PE8 + { VREL_VARYING, VREL_PE8, VREL_VARYING, VREL_VARYING, VREL_VARYING, + VREL_VARYING, VREL_PE8, VREL_VARYING, + VREL_PE8, VREL_PE8, VREL_PE8, VREL_PE8 }, +// VREL_PE16 + { VREL_VARYING, VREL_PE16, VREL_VARYING, VREL_VARYING, VREL_VARYING, + VREL_VARYING, VREL_PE16, VREL_VARYING, + VREL_PE8, VREL_PE16, VREL_PE16, VREL_PE16 }, +// VREL_PE32 + { VREL_VARYING, VREL_PE32, VREL_VARYING, VREL_VARYING, VREL_VARYING, + VREL_VARYING, VREL_PE32, VREL_VARYING, + VREL_PE8, VREL_PE16, VREL_PE32, VREL_PE32 }, +// VREL_PE64 + { VREL_VARYING, VREL_PE64, VREL_VARYING, VREL_VARYING, VREL_VARYING, + VREL_VARYING, VREL_PE64, VREL_VARYING, + VREL_PE8, VREL_PE16, VREL_PE32, VREL_PE64 } }; // Union relation R1 with relation R2 and return the result. @@ -147,32 +197,57 @@ relation_union (relation_kind r1, relation_kind r2) // This table is used to determine transitivity between 2 relations. // (A relation0 B) and (B relation1 C) implies (A result C) +// Chaining two partial equivalences leaves only the bits both agree on, ie +// the narrower of the two. static const unsigned char rr_transitive_table[VREL_LAST][VREL_LAST] = { // VREL_VARYING { VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, - VREL_VARYING, VREL_VARYING, VREL_VARYING }, + VREL_VARYING, VREL_VARYING, VREL_VARYING, + VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }, // VREL_UNDEFINED { VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, - VREL_VARYING, VREL_VARYING, VREL_VARYING }, + VREL_VARYING, VREL_VARYING, VREL_VARYING, + VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }, // VREL_LT { VREL_VARYING, VREL_VARYING, VREL_LT, VREL_LT, VREL_VARYING, VREL_VARYING, - VREL_LT, VREL_VARYING }, + VREL_LT, VREL_VARYING, + VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }, // VREL_LE { VREL_VARYING, VREL_VARYING, VREL_LT, VREL_LE, VREL_VARYING, VREL_VARYING, - VREL_LE, VREL_VARYING }, + VREL_LE, VREL_VARYING, + VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }, // VREL_GT { VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_GT, VREL_GT, - VREL_GT, VREL_VARYING }, + VREL_GT, VREL_VARYING, + VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }, // VREL_GE { VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_GT, VREL_GE, - VREL_GE, VREL_VARYING }, + VREL_GE, VREL_VARYING, + VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }, // VREL_EQ { VREL_VARYING, VREL_VARYING, VREL_LT, VREL_LE, VREL_GT, VREL_GE, VREL_EQ, - VREL_NE }, + VREL_NE, VREL_PE8, VREL_PE16, VREL_PE32, VREL_PE64 }, // VREL_NE { VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, - VREL_VARYING, VREL_NE, VREL_VARYING } }; + VREL_VARYING, VREL_NE, VREL_VARYING, + VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING }, +// VREL_PE8 + { VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, + VREL_VARYING, VREL_PE8, VREL_VARYING, + VREL_PE8, VREL_PE8, VREL_PE8, VREL_PE8 }, +// VREL_PE16 + { VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, + VREL_VARYING, VREL_PE16, VREL_VARYING, + VREL_PE8, VREL_PE16, VREL_PE16, VREL_PE16 }, +// VREL_PE32 + { VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, + VREL_VARYING, VREL_PE32, VREL_VARYING, + VREL_PE8, VREL_PE16, VREL_PE32, VREL_PE32 }, +// VREL_PE64 + { VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, VREL_VARYING, + VREL_VARYING, VREL_PE64, VREL_VARYING, + VREL_PE8, VREL_PE16, VREL_PE32, VREL_PE64 } }; // Apply transitive operation between relation R1 and relation R2, and // return the resulting relation, if any. @@ -2201,15 +2276,48 @@ relation_tests () { // rr_*_table tables use unsigned char rather than relation_kind. ASSERT_LT (VREL_LAST, UCHAR_MAX); - // Verify commutativity of relation_intersect and relation_union. - for (relation_kind r1 = VREL_VARYING; r1 < VREL_PE8; + for (relation_kind r1 = VREL_VARYING; r1 < VREL_LAST; r1 = relation_kind (r1 + 1)) - for (relation_kind r2 = VREL_VARYING; r2 < VREL_PE8; - r2 = relation_kind (r2 + 1)) - { - ASSERT_EQ (relation_intersect (r1, r2), relation_intersect (r2, r1)); - ASSERT_EQ (relation_union (r1, r2), relation_union (r2, r1)); - } + { + // Swapping the operands twice is a no-op. + ASSERT_EQ (relation_swap (relation_swap (r1)), r1); + + // VARYING intersect X is X. + // UNDEFINED intersect X is UNDEFINED. + ASSERT_EQ (relation_intersect (VREL_VARYING, r1), r1); + ASSERT_EQ (relation_intersect (VREL_UNDEFINED, r1), VREL_UNDEFINED); + + // UNDEFINED union X is X. + // VARYING union X is VARYING. + ASSERT_EQ (relation_union (VREL_UNDEFINED, r1), r1); + ASSERT_EQ (relation_union (VREL_VARYING, r1), VREL_VARYING); + + // Verify commutativity of relation_intersect and relation_union. + for (relation_kind r2 = VREL_VARYING; r2 < VREL_LAST; + r2 = relation_kind (r2 + 1)) + { + ASSERT_EQ (relation_intersect (r1, r2), relation_intersect (r2, r1)); + ASSERT_EQ (relation_union (r1, r2), relation_union (r2, r1)); + } + } + + // Verify partial equivalence properties. + for (relation_kind r1 = VREL_PE8; r1 <= VREL_PE64; + r1 = relation_kind (r1 + 1)) + { + ASSERT_EQ (relation_swap (r1), r1); + ASSERT_EQ (relation_intersect (VREL_EQ, r1), VREL_EQ); + ASSERT_EQ (relation_union (VREL_EQ, r1), r1); + ASSERT_EQ (relation_transitive (VREL_EQ, r1), r1); + ASSERT_EQ (relation_transitive (r1, VREL_EQ), r1); + for (relation_kind r2 = VREL_PE8; r2 <= VREL_PE64; + r2 = relation_kind (r2 + 1)) + { + ASSERT_EQ (relation_intersect (r1, r2), MAX (r1, r2)); + ASSERT_EQ (relation_union (r1, r2), pe_min (r1, r2)); + ASSERT_EQ (relation_transitive (r1, r2), pe_min (r1, r2)); + } + } } } // namespace selftest From ef5d3579596127f21ee50500427dfef11db79bcf Mon Sep 17 00:00:00 2001 From: Andrew MacLeod Date: Wed, 16 Sep 2026 06:48:31 -0400 Subject: [PATCH 167/584] Never record VREL_UNDEFINED in a relation chain. VREL_UNDEFINED should never be entered into a relation chain. Any attempt to do so indicates an unreachable block, and may affect further searches. Assisted-By: Claude Opus 5 gcc/ * value-relation.cc (dom_oracle::record): Do not record VREL_UNDEFINED. (dom_oracle::search_and_merge_relation): Likewise. (path_oracle::record): Likewise. --- gcc/value-relation.cc | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/gcc/value-relation.cc b/gcc/value-relation.cc index 69b4364b59ad..0eb6bdec75fa 100644 --- a/gcc/value-relation.cc +++ b/gcc/value-relation.cc @@ -1369,6 +1369,10 @@ dom_oracle::record (basic_block bb, relation_kind k, tree op1, tree op2) if (op1 == op2) return false; + // Do not register an impossible relation. + if (k == VREL_UNDEFINED) + return false; + // Equivalencies are handled by the equivalence oracle. if (relation_equiv_p (k)) return equiv_oracle::record (bb, k, op1, op2); @@ -1456,7 +1460,9 @@ relation_chain * dom_oracle::search_and_merge_relation (basic_block bb, relation_kind k, tree op1, tree op2) { - gcc_checking_assert (k != VREL_VARYING && k != VREL_EQ); + // Check for invalid relations to register. + gcc_checking_assert (k != VREL_VARYING && k != VREL_UNDEFINED + && k != VREL_EQ); relation_chain *ptr; relation_kind curr = find_relation_block (bb->index, op1, op2, &ptr); @@ -1464,6 +1470,11 @@ dom_oracle::search_and_merge_relation (basic_block bb, relation_kind k, // If there is an existing relation in this block, just intersect with it. if (curr != VREL_VARYING) { + // If K contradicts what is already recorded, the block is unreachable. + // Leave the existing relation alone rather than replacing it with + // UNDEFINED, matching what the dominator merge below does. + if (relation_intersect (curr, k) == VREL_UNDEFINED) + return NULL; // If there was no change, return no record. value_relation vr (k, op1, op2); if (!ptr->intersect (vr)) @@ -2071,6 +2082,10 @@ path_oracle::record (basic_block bb, relation_kind k, tree ssa1, tree ssa2) if (curr != VREL_VARYING) k = relation_intersect (curr, k); + // Do not register an impossible relation. + if (k == VREL_UNDEFINED) + return false; + bool ret; if (k == VREL_EQ) ret = register_equiv (bb, ssa1, ssa2); From fea8a2b9bf26f654ec0b97d43259dad5b0275c00 Mon Sep 17 00:00:00 2001 From: Andrew MacLeod Date: Wed, 16 Sep 2026 07:15:42 -0400 Subject: [PATCH 168/584] Keep partial equivalences out of ordering relations. If a partial equivalence and a normal relation both exist, prefer the normal relation. Also, partial equivalences should not be entered into the path oracle, nor should they be combined with normal relations when recording a relation. Assisted-By: Claude Opus 5 gcc/ * value-relation.cc (dom_oracle::query): Prefer a normal relation over a partial equivalency. (path_oracle::record): Do not record partial equivalences, nor intersect one with the relation being recorded. gcc/testsuite/ * gcc.dg/tree-ssa/vrp-rel3.c: New. --- gcc/testsuite/gcc.dg/tree-ssa/vrp-rel3.c | 42 ++++++++++++++++++++++++ gcc/value-relation.cc | 28 ++++++++++------ 2 files changed, 60 insertions(+), 10 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/vrp-rel3.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/vrp-rel3.c b/gcc/testsuite/gcc.dg/tree-ssa/vrp-rel3.c new file mode 100644 index 000000000000..6a0a32fee01c --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp-rel3.c @@ -0,0 +1,42 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-evrp" } */ + +/* Masking with 0xff makes C a partial equivalence of A, and unlike the cast + case both names have the same type, so an ordinary comparison can relate + the pair as well. A partial equivalence and an ordering relation do not + combine, but the partial equivalence must not hide the ordering either. */ + +void keep (void); +void kill (void); + +void +f1 (int a, int b) +{ + int c = a & 0xff; + if (c > b) + if (b > a) + { + if (c > a) + keep (); + else + kill (); + } +} + +/* Same shape with a mask which is not a partial equivalence, as a control. */ +void +f2 (int a, int b) +{ + int c = a & 0xfe; + if (c > b) + if (b > a) + { + if (c > a) + keep (); + else + kill (); + } +} + +/* { dg-final { scan-tree-dump-not "kill" "evrp" } } */ +/* { dg-final { scan-tree-dump-times "keep" 2 "evrp" } } */ diff --git a/gcc/value-relation.cc b/gcc/value-relation.cc index 0eb6bdec75fa..f5b286128353 100644 --- a/gcc/value-relation.cc +++ b/gcc/value-relation.cc @@ -1880,17 +1880,17 @@ dom_oracle::query (basic_block bb, tree ssa1, tree ssa2) if (bitmap_bit_p (equiv1, v2) && bitmap_bit_p (equiv2, v1)) return VREL_EQ; - kind = partial_equiv (ssa1, ssa2); - if (kind != VREL_VARYING) - return kind; - - // Initially look for a direct relationship and just return that. + // A statement such as c = a & 0xff makes a partial equivalence between + // c and a, and an ordinary comparison can then relate the same pair. + // If both exist, prefer the relation, so look for that first. kind = find_relation_dom (bb, ssa1, ssa2); - if (kind != VREL_VARYING) - return kind; + // If no direct relation exists, try the query using the equivalence sets. + if (kind == VREL_VARYING) + kind = query (bb, equiv1, equiv2); - // Query using the equivalence sets. - kind = query (bb, equiv1, equiv2); + // Finally look for partial equivalences. + if (kind == VREL_VARYING) + kind = partial_equiv (ssa1, ssa2); return kind; } @@ -2078,8 +2078,16 @@ path_oracle::record (basic_block bb, relation_kind k, tree ssa1, tree ssa2) if (ssa1 == ssa2) return false; + // Partial equivalences are tracked in the root equivalence oracle rather + // than on the path. Registering a partial equivalence in the path would + // cause normal relations to collapse to VARYING. + if (relation_partial_equiv_p (k)) + return false; + relation_kind curr = query (bb, ssa1, ssa2); - if (curr != VREL_VARYING) + // Likewise, a partial equivalency result should not be combined with K + // or the result drops to VARYING. + if (curr != VREL_VARYING && !relation_partial_equiv_p (curr)) k = relation_intersect (curr, k); // Do not register an impossible relation. From d41fe8e6b0b5ad225cfa2400e71f2cc56c6daec5 Mon Sep 17 00:00:00 2001 From: GCC Administrator Date: Fri, 18 Sep 2026 00:16:34 +0000 Subject: [PATCH 169/584] Daily bump. --- gcc/ChangeLog | 129 +++++++++++++++++++++++++++++++++++ gcc/DATESTAMP | 2 +- gcc/cobol/ChangeLog | 42 ++++++++++++ gcc/fortran/ChangeLog | 31 +++++++++ gcc/m2/ChangeLog | 17 +++++ gcc/testsuite/ChangeLog | 70 +++++++++++++++++++ libgcobol/ChangeLog | 15 ++++ libstdc++-v3/ChangeLog | 72 +++++++++++++++++++ maintainer-scripts/ChangeLog | 5 ++ 9 files changed, 382 insertions(+), 1 deletion(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 137c6d21d062..2c1213ac1723 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,132 @@ +2026-09-17 Andrew MacLeod + + * value-relation.cc (dom_oracle::query): Prefer a normal + relation over a partial equivalency. + (path_oracle::record): Do not record partial equivalences, nor + intersect one with the relation being recorded. + +2026-09-17 Andrew MacLeod + + * value-relation.cc (dom_oracle::record): Do not record + VREL_UNDEFINED. + (dom_oracle::search_and_merge_relation): Likewise. + (path_oracle::record): Likewise. + +2026-09-17 Andrew MacLeod + + * value-relation.cc (rr_negate_table): Fill PE slots. + (rr_swap_table): Likewise. + (rr_intersect_table): Likewise. + (rr_union_table): Likewise. + (rr_transitive_table): Likewise. + (relation_tests): Also confirm partial equivalency entries. + +2026-09-17 Richard Biener + + PR tree-optimization/127405 + * tree-ssa-loop-manip.cc (tree_transform_and_unroll_loop): Only + set nb_iterations_upper_bound of the epilogue loop and scale its + profile when the control IV is known not to wrap. + +2026-09-17 Richard Biener + + * tree-vect-slp.cc (vect_build_slp_instance): Pick the + largest isomorphic subset when vectorizing a BB reduction. + +2026-09-17 Richard Biener + + * tree-vectorizer.h (match_elt_t): New. + (_slp_tree::failed): Make a match_elt_t *. + * tree-vect-slp.cc (vect_build_slp_tree_3): Make + re-startable at start_i, change representation of + matches[] to match_elt_t[]. + (vect_build_slp_tree_1): Iteratively resolve not matched lanes. + Retain isomorphism of BB unrolling failed tail. + (vect_build_slp_tree_2): Adjust for s/bool/match_elt_t/ + (vect_build_slp_tree): Likewise. + (optimize_load_redistribution_1): Likewise. + (vect_build_slp_instance): Likewise. + (vect_analyze_slp_reduc_chain): Likewise. + (vect_analyze_slp_reduction): Likewise. + (vect_analyze_slp_reduction_group): Likewise. + (vect_analyze_slp_reductions): Likewise. + (vect_analyze_slp_instance): Likewise. + (vect_lower_load_permutations): Likewise. + +2026-09-17 Richard Biener + + PR tree-optimization/127407 + * tree-vect-data-refs.cc (vect_analyze_data_ref_dependence): + Also call vect_preserves_scalar_order_p for negative dependence + distance. + +2026-09-17 Uros Bizjak + + * config.gcc (i[34567]86-*-* | x86_64-*-*): Set + default_md_generator_partitions target default to 6:6:1. + +2026-09-17 Andrew Stubbs + + * config/gcn/gcn.cc (gcn_spill_class): Spill scalars in VGPRs to + SCALAR_SPILL_REGS. + (gcn_memory_move_cost): Handle SCALAR_SPILL_REGS. + * config/gcn/gcn.h (enum reg_class): Add SCALAR_SPILL_REGS. + (REG_CLASS_NAMES): Likewise. + (REG_CLASS_CONTENTS): Likewise. + +2026-09-17 Michiel Derhaeg + + PR target/127191 + * config/arc/arc.md (doloop_end): Clobber CC. + (loop_end): Likewise. + (dbnz): Likewise. + (flag): Likewise. + (kflag): Likewise. + +2026-09-17 Michiel Derhaeg + + * config/arc/arc.cc (arc_init_reg_tables): Set the mode class of + CC_Vmode to C_MODE. + +2026-09-17 Michiel Derhaeg + + PR target/126243 + * config/arc/simdext.md (v2si3): Require TARGET_PLUS_QMACW. + +2026-09-17 Claudiu Zissulescu + + * config/arc/arc.md: Remove the "cond" attribute definition, all + its uses and the comments describing it. + * config/arc/fpu.md: Likewise. + * config/arc/fpx.md: Likewise. + * config/arc/simdext.md: Likewise. + +2026-09-17 Longjun Luo + + PR lto/126841 + * doc/invoke.texi (-ffunction-sections): Document implicit function + section names under LTO. + * ipa-strub.cc (pass_ipa_strub::execute): Let cfgexpand resolve the + GIMPLE wrapper section. + * symtab-thunks.cc (expand_thunk): Likewise for generic GIMPLE thunks. + Clarify the direct-assembler case. + +2026-09-17 Andrea Pinski + + PR tree-optimization/127103 + * match.pd (`minmax (a - c, b) + c`): New pattern. + +2026-09-17 Andrea Pinski + + PR tree-optimization/127103 + * match.pd (`x+umax(x,1)`): New pattern. + +2026-09-17 Gaius Mulley + + PR modula2/126174 + * doc/gm2.texi (Using GNU Modula-2): Move Unbounded by reference after + Exception handling in the menu. + 2026-09-16 Kyrylo Tkachov * lto-wrapper.cc (run_gcc): Make saved parallel LTRANS outputs phony. diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index 66bb3a1b7dd6..215e40c73af3 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20260917 +20260918 diff --git a/gcc/cobol/ChangeLog b/gcc/cobol/ChangeLog index 12839ea39976..fbaacaa14a55 100644 --- a/gcc/cobol/ChangeLog +++ b/gcc/cobol/ChangeLog @@ -1,3 +1,45 @@ +2026-09-17 Robert Dubner + + * genapi.cc (actually_create_the_static_field): Use expanded PICTURE + string. + * lang-specs.h: Updated cc1_options formatting string. + * move.cc (mh_source_is_literalN): Use new numeric-edited routine. + (mh_to_numeric_edited): Likewise. + (move_helper): Likewise. + * parse.y: Formatting. + * symbols.cc (symbol_file): Mollify cppcheck. + (expand_picture): Modified for numeric-editing. + * symbols.h (cbl_dialect_str): Formatting. + (enum dspc_t): Formatting. + (MAXIMUM_ALPHA_LENGTH): Formatting. + (is_elementary): Formatting. + (struct cbl_field_t): Formatting. + (struct cbl_refer_t): Formatting. + (struct parameter_t): Formatting. + (struct cbl_label_t): Formatting. + (class temporaries_t): Formatting. + (struct cbl_locale_t): Formatting. + (hex2numstr): Formatting. + (struct cbl_file_key_t): Formatting. + (struct cbl_file_t): Formatting. + (struct symbol_elem_t): Formatting. + (redefine_field): Formatting. + (is_prototypical): Formatting. + (struct cbl_prog_hier_t): Formatting. + (keyword_alias_add): Formatting. + (class current_tokens_t): Formatting. + (expand_picture): Formatting. + * util.cc (cbl_prototype_ok): Formatting. + (cdf_file): Formatting. + (repeat_count): Formatting. + (cbl_field_t::encode_numeric): Formatting; use new numeric-edited + routine. + (cbl_field_t::report_invalid_initial_value): Formatting. + (valid_move): Formatting. + (cobol_filename): Formatting. + (gcc_location_set): Formatting. + (parse_file): Formatting. + 2026-09-14 James K. Lowden * parse.y: Emit diagnostic if symbol_currency_add fails. diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog index 8d1a55002283..6414556af7c2 100644 --- a/gcc/fortran/ChangeLog +++ b/gcc/fortran/ChangeLog @@ -1,3 +1,34 @@ +2026-09-17 Paul Thomas + + PR fortran/125690 + * decl.cc (gfc_get_pdt_instance): PDT strings with explicit + array specifications are also PDT arrays. If the component is + allocatable, the typespec must be marked deferred. + * resolve.cc (resolve_structure_cons): Skip the string length + check for PDT types. + (resolve_allocate_expr): Initialize cmp to 0. Do not emit error + if cmp = -3 since different variable could have the same value. + * trans-array.cc (gfc_conv_scalarized_array_ref): Force pointer + arithmetic by setting 'decl' for PDT strings. + (gfc_conv_array_ref): Likewise. + (structure_alloc_comps ): Move the declaraion of 'strlen' up. + Evaluate the bounds and offset for pdt_strings as well as pdt + arrays. If non-null, use strlen to obtain the size for malloc. + Set the span to strlen. + If the component type is a descriptor, rather than just a PDT + array, use its data forboth the non-null condition and setting + to null. + * trans-io.cc (gfc_trans_transfer): PDT string arrays must be + scalarized. + +2026-09-17 Paul Thomas + + PR fortran/104776 + * decl.cc (gfc_get_pdt_instance): Simplify the initializers of + KIND components in PDT templates since they must be integer + constants. Catch any remaining component initializers for + parameter substitution, if necessary, and simplification. + 2026-09-15 Mikael Morin PR fortran/122521 diff --git a/gcc/m2/ChangeLog b/gcc/m2/ChangeLog index b2a49007b8dc..40ec0b6be7cc 100644 --- a/gcc/m2/ChangeLog +++ b/gcc/m2/ChangeLog @@ -1,3 +1,20 @@ +2026-09-17 Gaius Mulley + + PR modula2/126174 + * Make-lang.in (m2/gm2-libs.texi): Add test for + m2/gm2-libs-pim-common and create if necessary. + Add test for m2/gm2-libs-iso-common and create if necessary. + Add test for m2/gm2-libs-cor-common and create if necessary. + * tools-src/def2doc.py (Base_Libs): Change section heading name. + (library_classifications): Add PIM_Common, ISO_Common and + COR_Common. + (PIM_Common): New list. + (ISO_Common): New list. + (COR_Common): New list. + * gm2-libs-cor-common/README.texi: New file. + * gm2-libs-iso-common/README.texi: New file. + * gm2-libs-pim-common/README.texi: New file. + 2026-09-16 Gaius Mulley PR modula2/127359 diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index e7648b8c3b64..1905d5e6eb0e 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,73 @@ +2026-09-17 Andrew MacLeod + + * gcc.dg/tree-ssa/vrp-rel3.c: New. + +2026-09-17 Paul Thomas + + PR fortran/125690 + * gfortran.dg/pdt_95.f03: New test. + +2026-09-17 Paul Thomas + + PR fortran/104776 + * gfortran.dg/pdt_94.f03: New test. + +2026-09-17 Richard Biener + + PR tree-optimization/127405 + * gcc.dg/tree-ssa/predcom-10.c: New test. + +2026-09-17 Richard Biener + + PR tree-optimization/127407 + * gcc.dg/vect/vect-pr127407.c: New testcase. + +2026-09-17 Andrew Stubbs + + * gcc.target/gcn/avgpr-spill-int.c: Increase register pressure. + * gcc.target/gcn/sgpr-spill-double.c: Allow some AVGPR spills. + * gcc.target/gcn/sgpr-spill-int.c: Likewise. + * gcc.target/gcn/sgpr-spill-long.c: Likewise. + * gcc.target/gcn/sgpr-spill-short.c: Likewise. + +2026-09-17 Michiel Derhaeg + + PR target/127191 + * gcc.target/arc/pr127191-1.c: New test. + * gcc.target/arc/pr127191-2.c: New test. + +2026-09-17 Longjun Luo + + PR lto/126841 + * gcc.dg/lto/pr126841-strub_0.c: New test. + * gcc.dg/lto/pr126841-strub_1.c: New test. + * gcc.dg/lto/pr126841_0.c: New test. + * gcc.dg/lto/pr126841_1.c: New test. + * gcc.dg/lto/pr126841_2.c: New test. + * gcc.dg/lto/pr126841_3.c: New test. + +2026-09-17 Robert Dubner + + * cobol.dg/group2/PR126612_-_Ignore_TRACE_-_gnu.cob: New test. + * cobol.dg/group2/PR126612_-_Ignore_TRACE_-_ibm.cob: New test. + * cobol.dg/group2/PR126612_-_Ignore_TRACE_-_iso.cob: New test. + * cobol.dg/group2/PR126612_-_Ignore_TRACE_-_mf.cob: New test. + * cobol.dg/group2/RT3611_-_BY_CONTENT_LENGTH_OF.cob: New test. + * cobol.dg/group2/__define__text_.cob: New test. + * cobol.dg/group2/__define__text_.out: New test. + * cobol.dg/group2/customer_bug_Heuristic_Fail.cob: New test. + * cobol.dg/group2/customer_bug_Heuristic_Fail.out: New test. + +2026-09-17 Andrea Pinski + + PR tree-optimization/127103 + * gcc.dg/tree-ssa/minmax-plus-1.c: New test. + +2026-09-17 Andrea Pinski + + PR tree-optimization/127103 + * gcc.dg/tree-ssa/max1-plus-1.c: New test. + 2026-09-16 Jakub Jelinek PR c/127383 diff --git a/libgcobol/ChangeLog b/libgcobol/ChangeLog index a9e352533ee7..7f448d0b60fb 100644 --- a/libgcobol/ChangeLog +++ b/libgcobol/ChangeLog @@ -1,3 +1,18 @@ +2026-09-17 Robert Dubner + + * gmath.cc (__gg__int128_to_int128_rounded): Change error handling. + * libgcobol.cc (int128_to_field): Likewise. + (__gg__int128_to_ascii_numeric_display): New routine for increased + speed. + * valconv.cc (TOUPPER): Remove. + (expand_picture): Remove; it's being done in another routine. + (Lindex): Remove. + (Rindex): Remove. + (__gg__string_to_numeric_edited): Refactor for speed. + (__gg__string_to_alpha_edited): Eliminate call to expand_picture(). + (__gg__currency_sign_init): Formatting. + * valconv.h: Change __gg__string_to_numeric_edited() return type. + 2026-09-10 Robert Dubner * gmath.cc (__gg__conditional_stash_float): New routine supporting diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 42bd1bfe5f5b..edc243d51f8b 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,75 @@ +2026-09-17 Jonathan Wakely + + * testsuite/lib/libstdc++.exp (v3_check_preprocessor_condition): + Use argument as filename for preprocessing. + +2026-09-17 Jonathan Wakely + + * testsuite/lib/libstdc++.exp (check_v3_target_cpp_feature_test): + Use $v3_max_std variable instead of hardcoding the latest -std + option. + +2026-09-17 Gökbey Keskin + + PR libstdc++/127424 + * testsuite/27_io/basic_filebuf/close/char/9964.cc: Only open + filebuf for output and expect close() to return null. + * testsuite/27_io/basic_filebuf/seekoff/char/26777.cc: Only open + filebuf for output. + * testsuite/27_io/basic_filebuf/showmanyc/char/9533-1.cc: + Likewise. + * testsuite/27_io/basic_filebuf/underflow/char/10097.cc: + Likewise. + * testsuite/27_io/objects/char/7.cc: Likewise. + * testsuite/27_io/objects/char/9661-1.cc: Only open FILE for + output. + +2026-09-17 Jonathan Wakely + + PR libstdc++/127425 + * doc/xml/manual/test.xml: Document new testsuite header. + * doc/html/manual/test.html: Regenerate. + * testsuite/27_io/basic_filebuf/close/char/4879.cc: Use new + dg-require-sysv-or-posix-semaphore directive. + * testsuite/27_io/basic_filebuf/close/char/9964.cc: Likewise. + * testsuite/27_io/basic_filebuf/imbue/char/13171-2.cc: Likewise. + * testsuite/27_io/basic_filebuf/imbue/wchar_t/14975-2.cc: + Likewise. + * testsuite/27_io/basic_filebuf/seekoff/char/26777.cc: Likewise. + * testsuite/27_io/basic_filebuf/underflow/char/10097.cc: + Likewise. + * testsuite/27_io/objects/char/7.cc: Likewise. + * testsuite/27_io/objects/char/9661-1.cc: Likewise. + * testsuite/27_io/objects/wchar_t/7.cc: Likewise. + * testsuite/27_io/objects/wchar_t/9661-1.cc: Likewise. + * testsuite/lib/dg-options.exp + (dg-require-sysv-or-posix-semaphore): New proc. + * testsuite/lib/libstdc++.exp (v3-build_support): Add new file + to list of testsuite source files. + (check_v3_target_posix_or_sysv_semaphore): New proc. + * testsuite/util/testsuite_hooks.cc (semaphore): Move to new + file. + * testsuite/util/testsuite_hooks.h (semaphore): Likewise. + * testsuite/util/testsuite_semaphore.cc: Move definition of + semaphore member functions here. Fix resource leak in + constructor if semctl fails. Add fallback using mmap+sem_init + instead of semget+semctl. + * testsuite/util/testsuite_semaphore.h: Move definition of + semaphore to here. Replace sem_set_ data member with anonymous + union. Add deleted copy operations. + +2026-09-17 Tomasz Kamiński + + PR libstdc++/123409 + * include/bits/random.h (negative_binomial_distribution::param) + (fisher_f_distribution::param, student_t_distribution::param): + Updated underlying gamma distributions, by calling param. + (chi_squared_distribution::param): Use type alias and parenthesis + for consistency. + * testsuite/26_numerics/random/distribution_param.cc: New test. + * testsuite/26_numerics/random/chi_squared_distribution/83833.cc: + Removed, covered by above. + 2026-09-16 Jonathan Wakely * doc/html/manual/status.html: Regenerate. diff --git a/maintainer-scripts/ChangeLog b/maintainer-scripts/ChangeLog index 446c28b47f38..8d3800e02b6b 100644 --- a/maintainer-scripts/ChangeLog +++ b/maintainer-scripts/ChangeLog @@ -1,3 +1,8 @@ +2026-09-17 Jakub Jelinek + + * update_web_docs_git: Ignore installation of $file.gz files + which don't exist. + 2026-09-12 Gerald Pfeifer * update_web_docs_git: Stop generating .pdf.gz copies of From 11ae0ce305601ebf85b1a09b130cb3e7b46157f9 Mon Sep 17 00:00:00 2001 From: Xi Ruoyao Date: Thu, 3 Sep 2026 17:55:51 +0800 Subject: [PATCH 170/584] LoongArch: fix __builtin_bitreverse16 ICE on LA32R gcc/ * config/loongarch/loongarch.md (bitreverseqi2): Disable on LA32R. gcc/testsuite/ * gcc.target/loongarch/bitreverse-la32r.c: New test. --- gcc/config/loongarch/loongarch.md | 2 +- gcc/testsuite/gcc.target/loongarch/bitreverse-la32r.c | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.target/loongarch/bitreverse-la32r.c diff --git a/gcc/config/loongarch/loongarch.md b/gcc/config/loongarch/loongarch.md index ecf1563270f5..cccb0ed8612f 100644 --- a/gcc/config/loongarch/loongarch.md +++ b/gcc/config/loongarch/loongarch.md @@ -4771,7 +4771,7 @@ (define_expand "bitreversehi2" [(set (match_operand:HI 0 "register_operand" "=r") (bitreverse:HI (match_operand:HI 1 "register_operand" "r")))] - "" + "TARGET_64BIT || TARGET_32BIT_S" { rtx t = gen_reg_rtx (word_mode); diff --git a/gcc/testsuite/gcc.target/loongarch/bitreverse-la32r.c b/gcc/testsuite/gcc.target/loongarch/bitreverse-la32r.c new file mode 100644 index 000000000000..72180176d685 --- /dev/null +++ b/gcc/testsuite/gcc.target/loongarch/bitreverse-la32r.c @@ -0,0 +1,4 @@ +/* Verify that bitreverse builtins do not ICE on LA32R. */ +/* { dg-do compile } */ +/* { dg-options "-mabi=ilp32s -march=la32rv1.0" } */ +#include "la64/bitreverse.c" From 55e9aef65b2d3705089c2de601867aa6e7cc261d Mon Sep 17 00:00:00 2001 From: Yongqiang Tian Date: Wed, 16 Sep 2026 22:17:21 +1000 Subject: [PATCH 171/584] combine: Ignore debug insns in volatile checks [PR127422] A DEBUG_INSN can retain a volatile MEM after the corresponding ordinary instruction has been deleted. Do not treat that non-executing payload as an intervening volatile access in can_combine_p. Assisted-by: OpenAI Codex 5.6 Sol, co-reviewed by Claude and Yongqiang Tian. PR rtl-optimization/127422 gcc/ChangeLog: * combine.cc (can_combine_p): Ignore debug instructions when scanning for intervening volatile references. gcc/testsuite/ChangeLog: * gcc.dg/pr127422.c: New test. Signed-off-by: Yongqiang Tian --- gcc/combine.cc | 5 ++++- gcc/testsuite/gcc.dg/pr127422.c | 35 +++++++++++++++++++++++++++++++++ 2 files changed, 39 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.dg/pr127422.c diff --git a/gcc/combine.cc b/gcc/combine.cc index 35c6a5299507..11427f5a9204 100644 --- a/gcc/combine.cc +++ b/gcc/combine.cc @@ -2024,7 +2024,10 @@ can_combine_p (rtx_insn *insn, rtx_insn *i3, rtx_insn *pred ATTRIBUTE_UNUSED, : volatile_insn_p; for (p = NEXT_INSN (insn); p != i3; p = NEXT_INSN (p)) - if (INSN_P (p) && p != succ && p != succ2 && is_volatile_p (PATTERN (p))) + if (NONDEBUG_INSN_P (p) + && p != succ + && p != succ2 + && is_volatile_p (PATTERN (p))) return false; /* If INSN contains an autoincrement or autodecrement, make sure that diff --git a/gcc/testsuite/gcc.dg/pr127422.c b/gcc/testsuite/gcc.dg/pr127422.c new file mode 100644 index 000000000000..bba30ad78449 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr127422.c @@ -0,0 +1,35 @@ +/* PR rtl-optimization/127422 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -fcompare-debug" } */ + +static int ordinary_0 = 3; +static int ordinary_1 = 22; +static volatile int effect_0 = 6; +static volatile int effect_1 = 23; +static int ordinary_2 = 41; +__attribute__ ((used)) int *ordinary_escape[] + = { &ordinary_0, &ordinary_1, &ordinary_2 }; + +static inline __attribute__ ((always_inline)) +unsigned long long +accumulate (unsigned long long acc, unsigned long long val) +{ + return acc + val; +} + +unsigned long long +foo (void) +{ + int staged_ordinary_0 = ordinary_0; + int staged_ordinary_1 = ordinary_1; + int staged_effect_0 = effect_0; + int staged_effect_1 = effect_1; + int staged_ordinary_2 = ordinary_2; + unsigned long long sum = 0; + sum = accumulate (sum, staged_ordinary_0); + sum = accumulate (sum, staged_ordinary_1); + sum = accumulate (sum, staged_effect_0); + sum = accumulate (sum, staged_effect_1); + sum = accumulate (sum, staged_ordinary_2); + return sum; +} From be7393903c28328a6d2dfd5bbd6347fcbf767bec Mon Sep 17 00:00:00 2001 From: Yongqiang Tian Date: Wed, 16 Sep 2026 22:17:42 +1000 Subject: [PATCH 172/584] reorg: Do not charge debug insns against search budget [PR127421] Skip DEBUG_INSNs before decrementing the bounded redundant_insn search budget. Debug instructions do not execute and should not hide an otherwise reachable ordinary redundancy witness. Assisted-by: OpenAI Codex 5.6 Sol, co-reviewed by Claude and Yongqiang Tian. PR rtl-optimization/127421 gcc/ChangeLog: * reorg.cc (redundant_insn): Use NONDEBUG_INSN_P in both bounded backward walks. Remove redundant debug-instruction checks. gcc/testsuite/ChangeLog: * gcc.target/sparc/pr127421.c: New test. Signed-off-by: Yongqiang Tian --- gcc/reorg.cc | 10 +-- gcc/testsuite/gcc.target/sparc/pr127421.c | 75 +++++++++++++++++++++++ 2 files changed, 77 insertions(+), 8 deletions(-) create mode 100644 gcc/testsuite/gcc.target/sparc/pr127421.c diff --git a/gcc/reorg.cc b/gcc/reorg.cc index 02fa19a118a9..76b3e1438f0c 100644 --- a/gcc/reorg.cc +++ b/gcc/reorg.cc @@ -1417,7 +1417,7 @@ redundant_insn (rtx insn, rtx_insn *target, const vec &delay_list) if (LABEL_P (trial) || BARRIER_P (trial)) return 0; - if (!INSN_P (trial)) + if (!NONDEBUG_INSN_P (trial)) continue; --insns_to_search; @@ -1425,9 +1425,6 @@ redundant_insn (rtx insn, rtx_insn *target, const vec &delay_list) if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER) continue; - if (GET_CODE (trial) == DEBUG_INSN) - continue; - if (rtx_sequence *seq = dyn_cast (pat)) { /* Stop for a CALL and its delay slots because it is difficult to @@ -1514,7 +1511,7 @@ redundant_insn (rtx insn, rtx_insn *target, const vec &delay_list) trial && !LABEL_P (trial) && insns_to_search > 0; trial = PREV_INSN (trial)) { - if (!INSN_P (trial)) + if (!NONDEBUG_INSN_P (trial)) continue; --insns_to_search; @@ -1522,9 +1519,6 @@ redundant_insn (rtx insn, rtx_insn *target, const vec &delay_list) if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER) continue; - if (GET_CODE (trial) == DEBUG_INSN) - continue; - if (rtx_sequence *seq = dyn_cast (pat)) { bool annul_p = false; diff --git a/gcc/testsuite/gcc.target/sparc/pr127421.c b/gcc/testsuite/gcc.target/sparc/pr127421.c new file mode 100644 index 000000000000..6a19eb87350b --- /dev/null +++ b/gcc/testsuite/gcc.target/sparc/pr127421.c @@ -0,0 +1,75 @@ +/* PR rtl-optimization/127421 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -mcpu=v8 -fno-var-tracking -fno-var-tracking-assignments -fno-asynchronous-unwind-tables --param=max-delay-slot-insn-search=8 -fcompare-debug" } */ + +typedef unsigned int uint32_t; +typedef unsigned long long uint64_t; + +extern int printf (const char *, ...); +extern int putchar (int); +extern int strcmp (const char *, const char *); + +static uint64_t checksum; +static uint32_t values[3] = + { 4294967295U, 4294967295U, 4294967295U }; + +static void +put_string (const char *s) +{ + int i = 0; + while (s[i]) + putchar (s[i++]); +} + +static void +put_hex_digit (int x) +{ + switch (x) + { + case 0: putchar ('0'); break; + case 1: putchar ('1'); break; + case 2: putchar ('2'); break; + case 3: putchar ('3'); break; + case 4: putchar ('4'); break; + case 5: putchar ('5'); break; + case 6: putchar ('6'); break; + case 7: putchar ('7'); break; + case 8: putchar ('8'); break; + case 9: putchar ('9'); break; + case 10: putchar ('a'); break; + case 11: putchar ('b'); break; + case 12: putchar ('c'); break; + case 13: putchar ('d'); break; + case 14: putchar ('e'); break; + case 15: putchar ('f'); break; + } +} + +static void +print_checksum (uint64_t x) +{ + int i; + put_string ("checksum = "); + for (i = 0; i < 16; i++) + { + put_hex_digit (x & 15); + x >>= 4; + } + putchar ('\n'); +} + +int +main (int argc, char **argv) +{ + int i; + int verbose = argc == 2 && strcmp (argv[1], "1") == 0; + + for (i = 0; i < 3; i++) + { + checksum += values[i]; + if (verbose) + printf ("index = [%d]\n", i); + } + print_checksum (checksum ^ 0xffffffffU); + return 0; +} From 6924bcee14bdcecf0fcb6764f546dd7ca8ca8f9a Mon Sep 17 00:00:00 2001 From: Pan Li Date: Sat, 12 Sep 2026 16:00:30 +0800 Subject: [PATCH 173/584] RISC-V: Fix reg overlap for vs1 of the widening integer reduction The vs1 of the widening reduction (aka vwredsum[u].vs) is read with EEW = 2 * SEW while the vs2 is read with EEW = SEW. The section 5.2 of the vector spec reserves any encoding in which one vector register supplies source operands with two or more different EEWs. Thus, the vs1 must not fall inside the vs2 register group, but we may have below asm dump when the vs1 comes from the vs2 register group. vwredsum.vs v2,v2,v3 Add one new constraint Wn3 which indicates the register of the operand doesn't overlap the register group of the operand 3 (aka vs2), and then take it for the operand 4 (aka vs1) of the widening integer reduction. See below issue of the riscv-isa-manual for more details. https://github.com/riscv/riscv-isa-manual/issues/2350 gcc/ChangeLog: * config/riscv/constraints.md (Wn3): New constraint for the vector register which doesn't overlap the register group of the operand 3. * config/riscv/riscv-protos.h (riscv_v_widen_non_overlap_constraint_ok): New function declaration. * config/riscv/riscv-v.cc (riscv_v_reg_group_overlap_p): New function to tell if two vector register groups overlap. (riscv_v_widen_constraint_ok): Leverage the above function for the register group overlap check. (riscv_v_widen_non_overlap_constraint_ok): New function to tell if the register doesn't overlap the reference register group. * config/riscv/vector.md: Take the Wn3 constraint for the operand 4 of the widening integer reduction. Signed-off-by: Pan Li --- gcc/config/riscv/constraints.md | 11 ++++++++ gcc/config/riscv/riscv-protos.h | 2 ++ gcc/config/riscv/riscv-v.cc | 45 ++++++++++++++++++++++++++++++++- gcc/config/riscv/vector.md | 2 +- 4 files changed, 58 insertions(+), 2 deletions(-) diff --git a/gcc/config/riscv/constraints.md b/gcc/config/riscv/constraints.md index d9fc9704ef57..38f46d8fec5c 100644 --- a/gcc/config/riscv/constraints.md +++ b/gcc/config/riscv/constraints.md @@ -243,6 +243,17 @@ "riscv_vector::riscv_v_widen_constraint_ok (regno, mode, ref_regno, ref_mode)" "0") +;; The scalar operand vs1 of a widening reduction (vwredsum[u].vs, +;; vfwred[o|u]sum.vs) is read with EEW = 2 * SEW while the vector operand vs2 +;; (operand 3) is read with EEW = SEW. A vector register may not supply +;; source operands with two different EEWs, so vs1 must not fall inside the +;; vs2 register group. +;; Therefore, we take Wn3 indicates widen non-overlap to operand 3. +(define_register_constraint "Wn3" "TARGET_VECTOR ? V_REGS : NO_REGS" + "Vector reg not overlapping the operand 3 register group" + "riscv_vector::riscv_v_widen_non_overlap_constraint_ok (regno, mode, ref_regno, ref_mode)" + "3") + ;; This constraint is used to match instruction "csrr %0, vlenb" which is generated in "mov". ;; VLENB is a run-time constant which represent the vector register length in bytes. ;; BYTES_PER_RISCV_VECTOR represent runtime invariant of vector register length in bytes. diff --git a/gcc/config/riscv/riscv-protos.h b/gcc/config/riscv/riscv-protos.h index 72b7b4823399..c0fb28397809 100644 --- a/gcc/config/riscv/riscv-protos.h +++ b/gcc/config/riscv/riscv-protos.h @@ -828,6 +828,8 @@ bool splat_to_scalar_move_p (rtx *); rtx get_fp_rounding_coefficient (machine_mode); bool riscv_v_widen_constraint_ok (unsigned int, machine_mode, unsigned int, machine_mode); +bool riscv_v_widen_non_overlap_constraint_ok (unsigned int, machine_mode, + unsigned int, machine_mode); } /* We classify builtin types into two classes: diff --git a/gcc/config/riscv/riscv-v.cc b/gcc/config/riscv/riscv-v.cc index e50ebdee1637..398a1003a1d1 100644 --- a/gcc/config/riscv/riscv-v.cc +++ b/gcc/config/riscv/riscv-v.cc @@ -6521,6 +6521,22 @@ splat_to_scalar_move_p (rtx *ops) && known_ge (GET_MODE_SIZE (Pmode), GET_MODE_SIZE (GET_MODE (ops[3]))); } +static inline bool +riscv_v_reg_group_overlap_p (unsigned int regno, machine_mode mode, + unsigned int ref_regno, machine_mode ref_mode) +{ + gcc_checking_assert (V_REG_P (regno)); + gcc_checking_assert (V_REG_P (ref_regno)); + + gcc_checking_assert (riscv_vector_mode_p (mode)); + gcc_checking_assert (riscv_vector_mode_p (ref_mode)); + + unsigned int nregs = riscv_hard_regno_nregs (regno, mode); + unsigned int ref_nregs = riscv_hard_regno_nregs (ref_regno, ref_mode); + + return !(regno + nregs <= ref_regno || ref_regno + ref_nregs <= regno); +} + /* Return true if REGNO in MODE can be used as source in a widening instruction with destination WIDE_REGNO in WIDE_MODE. This is true if either there is no overlap at all, or the overlap @@ -6560,7 +6576,7 @@ riscv_v_widen_constraint_ok (unsigned int regno, machine_mode mode, gcc_checking_assert ((wide_nregs % nregs) == 0); /* No overlap. */ - if (regno + nregs <= wide_regno || wide_regno + wide_nregs <= regno) + if (!riscv_v_reg_group_overlap_p (regno, mode, wide_regno, wide_mode)) return true; if (is_frac_vlmul_p (mode)) /* Source LMUL < 1. */ @@ -6571,4 +6587,31 @@ riscv_v_widen_constraint_ok (unsigned int regno, machine_mode mode, return (regno % wide_nregs) == highest_num; } +/* Return true if REGNO in MODE does not overlap the vector register group + starting at REF_REGNO in REF_MODE. + + The widening reductions vwredsum[u].vs / vfwred[o|u]sum.vs read vs1 with + EEW = 2 * SEW (EMUL = 1) and vs2 with EEW = SEW (EMUL = LMUL). Section 5.2 + of the vector spec reserves any encoding in which one vector register + supplies source operands with two or more different EEWs, so vs1 must not + fall inside the vs2 group. See + https://github.com/riscv/riscv-isa-manual/issues/2350. */ + +bool +riscv_v_widen_non_overlap_constraint_ok (unsigned int regno, machine_mode mode, + unsigned int ref_regno, + machine_mode ref_mode) +{ + if (ref_regno == INVALID_REGNUM) + return true; + + if (!V_REG_P (regno) || !V_REG_P (ref_regno)) + return false; + + if (riscv_tuple_mode_p (mode) || ref_mode == mode) + return false; + + return !riscv_v_reg_group_overlap_p (regno, mode, ref_regno, ref_mode); +} + } // namespace riscv_vector diff --git a/gcc/config/riscv/vector.md b/gcc/config/riscv/vector.md index e760f708faf2..83a2c8f346d7 100644 --- a/gcc/config/riscv/vector.md +++ b/gcc/config/riscv/vector.md @@ -8093,7 +8093,7 @@ (reg:SI VTYPE_REGNUM)] UNSPEC_VPREDICATE) (unspec: [ (match_operand:VI_QHS 3 "register_operand" " vr, vr") - (match_operand: 4 "register_operand" " vr, vr") + (match_operand: 4 "register_operand" " Wn3, Wn3") ] ANY_WREDUC) (match_operand: 2 "vector_merge_operand" " vu, 0")] UNSPEC_REDUC))] "TARGET_VECTOR" From c26ada64060ebe19995d1937ebfde5082f0a3442 Mon Sep 17 00:00:00 2001 From: Pan Li Date: Sat, 12 Sep 2026 16:00:53 +0800 Subject: [PATCH 174/584] RISC-V: Add test cases for vwredsum.vs reg overlap Add test cases to ensure the vs1 of the vwredsum.vs doesn't overlap the register group of the vs2. gcc/testsuite/ChangeLog: * gcc.target/riscv/rvv/autovec/group_overlap/group_overlap.h: Add test helper macros. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m1.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m2.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m4.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m8.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m1.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m2.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m4.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m8.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m1.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m2.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m4.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m8.c: New test. Signed-off-by: Pan Li --- .../rvv/autovec/group_overlap/group_overlap.h | 79 +++++++++++++++++++ .../group_overlap/vwredsum_vs-i16-m1.c | 20 +++++ .../group_overlap/vwredsum_vs-i16-m2.c | 23 ++++++ .../group_overlap/vwredsum_vs-i16-m4.c | 23 ++++++ .../group_overlap/vwredsum_vs-i16-m8.c | 23 ++++++ .../group_overlap/vwredsum_vs-i32-m1.c | 20 +++++ .../group_overlap/vwredsum_vs-i32-m2.c | 23 ++++++ .../group_overlap/vwredsum_vs-i32-m4.c | 23 ++++++ .../group_overlap/vwredsum_vs-i32-m8.c | 23 ++++++ .../autovec/group_overlap/vwredsum_vs-i8-m1.c | 20 +++++ .../autovec/group_overlap/vwredsum_vs-i8-m2.c | 23 ++++++ .../autovec/group_overlap/vwredsum_vs-i8-m4.c | 23 ++++++ .../autovec/group_overlap/vwredsum_vs-i8-m8.c | 23 ++++++ 13 files changed, 346 insertions(+) create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m1.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m2.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m4.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m8.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m1.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m2.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m4.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m8.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m1.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m2.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m4.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m8.c diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/group_overlap.h b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/group_overlap.h index 0eb77eb931b7..8e3792adcf96 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/group_overlap.h +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/group_overlap.h @@ -1240,6 +1240,54 @@ ST_F ((void *)out, vd0, VL); OUT += VL; \ ST_F ((void *)out, vd1, VL); OUT += VL; \ +/* A widening reduction reads vs1 with EEW = 2 * SEW while vs2 is read with + EEW = SEW, thus vs1 must not fall inside the vs2 register group. Taking vs1 + out of the vs2 register group itself is the only way the two can be asked to + overlap: RI_F reinterprets the narrowed vector as the widened element type + and GET_F extracts its IDX-th LMUL1 piece, which lives in the vs2 register + group. */ +#define LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2(NT, WT, WNT, LD_NF, RI_F, GET_F, \ + IDX, OUT_F, ST_F, OUT, START, VL) \ + NT vs0 = LD_NF ((void *)START, VL); START += VL; \ + NT vs1 = LD_NF ((void *)START, VL); START += VL; \ + \ + asm volatile("nop" ::: "memory"); \ + \ + WNT vr0 = RI_F (vs0); \ + WNT vr1 = RI_F (vs1); \ + \ + WT vt0 = GET_F (vr0, IDX); \ + WT vt1 = GET_F (vr1, IDX); \ + \ + WT vd0 = OUT_F (vs0, vt0, VL); \ + WT vd1 = OUT_F (vs1, vt1, VL); \ + \ + asm volatile("nop" ::: "memory"); \ + \ + ST_F ((void *)out, vd0, VL); OUT += VL; \ + ST_F ((void *)out, vd1, VL); OUT += VL; \ + +/* Like LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2 but vs2 is a LMUL1 register group + already, thus reinterpreting it as the widened element type is enough to ask + for vs1 and vs2 to be the very same register. */ +#define LOOP_WIDEN_REDUCE_BODY_OVERLAP_LMUL1_X2(NT, WT, LD_NF, RI_F, OUT_F, \ + ST_F, OUT, START, VL) \ + NT vs0 = LD_NF ((void *)START, VL); START += VL; \ + NT vs1 = LD_NF ((void *)START, VL); START += VL; \ + \ + asm volatile("nop" ::: "memory"); \ + \ + WT vt0 = RI_F (vs0); \ + WT vt1 = RI_F (vs1); \ + \ + WT vd0 = OUT_F (vs0, vt0, VL); \ + WT vd1 = OUT_F (vs1, vt1, VL); \ + \ + asm volatile("nop" ::: "memory"); \ + \ + ST_F ((void *)out, vd0, VL); OUT += VL; \ + ST_F ((void *)out, vd1, VL); OUT += VL; \ + #define DEF_GROUP_OVERLAP_UNARY_0(VL_F, NT, WT, LD_F, OUT_F, ST_F, NAME, \ LOOP_BODY) \ void test_group_overlap_##NAME##_##NT##_unary_0(uint8_t *data, \ @@ -1433,4 +1481,35 @@ } \ } +#define DEF_GROUP_OVERLAP_REDUCE_0(VL_F, NT, WT, WNT, LD_NF, RI_F, GET_F, \ + IDX, OUT_F, ST_F, NAME, LOOP_BODY) \ + void test_group_overlap_##NAME##_##NT##_reduce_0(uint8_t *data, \ + uint8_t *out, \ + size_t limit) \ + { \ + uint8_t *start = data; \ + uint8_t *end = data + limit; \ + size_t vl = VL_F (); \ + \ + while (start < end) { \ + LOOP_BODY (NT, WT, WNT, LD_NF, RI_F, GET_F, IDX, OUT_F, ST_F, out, \ + start, vl); \ + } \ + } + +#define DEF_GROUP_OVERLAP_REDUCE_1(VL_F, NT, WT, LD_NF, RI_F, OUT_F, ST_F, \ + NAME, LOOP_BODY) \ + void test_group_overlap_##NAME##_##NT##_reduce_1(uint8_t *data, \ + uint8_t *out, \ + size_t limit) \ + { \ + uint8_t *start = data; \ + uint8_t *end = data + limit; \ + size_t vl = VL_F (); \ + \ + while (start < end) { \ + LOOP_BODY (NT, WT, LD_NF, RI_F, OUT_F, ST_F, out, start, vl); \ + } \ + } + #endif diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m1.c new file mode 100644 index 000000000000..80a938b43006 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m1.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_1( + __riscv_vsetvlmax_e16m1, + vint16m1_t, + vint32m1_t, + __riscv_vle16_v_i16m1, + __riscv_vreinterpret_v_i16m1_i32m1, + __riscv_vwredsum_vs_i16m1_i32m1, + __riscv_vse32_v_i32m1, + vwredsum_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_LMUL1_X2) + +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v0,v2,v3([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v5,v1,v4([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v1,v1([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v2,v2([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m2.c new file mode 100644 index 000000000000..874c04cce898 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m2.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_0( + __riscv_vsetvlmax_e16m2, + vint16m2_t, + vint32m1_t, + vint32m2_t, + __riscv_vle16_v_i16m2, + __riscv_vreinterpret_v_i16m2_i32m2, + __riscv_vget_v_i32m2_i32m1, + 1, + __riscv_vwredsum_vs_i16m2_i32m1, + __riscv_vse32_v_i32m1, + vwredsum_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2) + +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v4,v4,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v2,v2,v0([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v2,v(2|3)([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v4,v(4|5)([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m4.c new file mode 100644 index 000000000000..37c1bf81970b --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m4.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_0( + __riscv_vsetvlmax_e16m4, + vint16m4_t, + vint32m1_t, + vint32m4_t, + __riscv_vle16_v_i16m4, + __riscv_vreinterpret_v_i16m4_i32m4, + __riscv_vget_v_i32m4_i32m1, + 3, + __riscv_vwredsum_vs_i16m4_i32m1, + __riscv_vse32_v_i32m1, + vwredsum_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2) + +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v8,v8,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v4,v4,v0([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v4,v(4|5|6|7)([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v8,v(8|9|10|11)([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m8.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m8.c new file mode 100644 index 000000000000..fada697634b0 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m8.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_0( + __riscv_vsetvlmax_e16m8, + vint16m8_t, + vint32m1_t, + vint32m8_t, + __riscv_vle16_v_i16m8, + __riscv_vreinterpret_v_i16m8_i32m8, + __riscv_vget_v_i32m8_i32m1, + 7, + __riscv_vwredsum_vs_i16m8_i32m1, + __riscv_vse32_v_i32m1, + vwredsum_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2) + +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v16,v16,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v8,v8,v0([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v8,v(8|9|10|11|12|13|14|15)([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v16,v(16|17|18|19|20|21|22|23)([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m1.c new file mode 100644 index 000000000000..b23dd7f37a8c --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m1.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_1( + __riscv_vsetvlmax_e32m1, + vint32m1_t, + vint64m1_t, + __riscv_vle32_v_i32m1, + __riscv_vreinterpret_v_i32m1_i64m1, + __riscv_vwredsum_vs_i32m1_i64m1, + __riscv_vse64_v_i64m1, + vwredsum_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_LMUL1_X2) + +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v0,v2,v3([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v5,v1,v4([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v1,v1([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v2,v2([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m2.c new file mode 100644 index 000000000000..1d431d68370a --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m2.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_0( + __riscv_vsetvlmax_e32m2, + vint32m2_t, + vint64m1_t, + vint64m2_t, + __riscv_vle32_v_i32m2, + __riscv_vreinterpret_v_i32m2_i64m2, + __riscv_vget_v_i64m2_i64m1, + 1, + __riscv_vwredsum_vs_i32m2_i64m1, + __riscv_vse64_v_i64m1, + vwredsum_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2) + +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v4,v4,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v2,v2,v0([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v2,v(2|3)([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v4,v(4|5)([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m4.c new file mode 100644 index 000000000000..7a7e37e8784d --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m4.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_0( + __riscv_vsetvlmax_e32m4, + vint32m4_t, + vint64m1_t, + vint64m4_t, + __riscv_vle32_v_i32m4, + __riscv_vreinterpret_v_i32m4_i64m4, + __riscv_vget_v_i64m4_i64m1, + 3, + __riscv_vwredsum_vs_i32m4_i64m1, + __riscv_vse64_v_i64m1, + vwredsum_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2) + +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v8,v8,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v4,v4,v0([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v4,v(4|5|6|7)([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v8,v(8|9|10|11)([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m8.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m8.c new file mode 100644 index 000000000000..8c969122b9bd --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m8.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_0( + __riscv_vsetvlmax_e32m8, + vint32m8_t, + vint64m1_t, + vint64m8_t, + __riscv_vle32_v_i32m8, + __riscv_vreinterpret_v_i32m8_i64m8, + __riscv_vget_v_i64m8_i64m1, + 7, + __riscv_vwredsum_vs_i32m8_i64m1, + __riscv_vse64_v_i64m1, + vwredsum_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2) + +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v16,v16,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v8,v8,v0([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v8,v(8|9|10|11|12|13|14|15)([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v16,v(16|17|18|19|20|21|22|23)([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m1.c new file mode 100644 index 000000000000..581f60d87da3 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m1.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_1( + __riscv_vsetvlmax_e8m1, + vint8m1_t, + vint16m1_t, + __riscv_vle8_v_i8m1, + __riscv_vreinterpret_v_i8m1_i16m1, + __riscv_vwredsum_vs_i8m1_i16m1, + __riscv_vse16_v_i16m1, + vwredsum_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_LMUL1_X2) + +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v0,v2,v3([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v5,v1,v4([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v1,v1([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v2,v2([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m2.c new file mode 100644 index 000000000000..204f6567d7bd --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m2.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_0( + __riscv_vsetvlmax_e8m2, + vint8m2_t, + vint16m1_t, + vint16m2_t, + __riscv_vle8_v_i8m2, + __riscv_vreinterpret_v_i8m2_i16m2, + __riscv_vget_v_i16m2_i16m1, + 1, + __riscv_vwredsum_vs_i8m2_i16m1, + __riscv_vse16_v_i16m1, + vwredsum_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2) + +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v4,v4,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v2,v2,v0([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v2,v(2|3)([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v4,v(4|5)([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m4.c new file mode 100644 index 000000000000..107af1359bf0 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m4.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_0( + __riscv_vsetvlmax_e8m4, + vint8m4_t, + vint16m1_t, + vint16m4_t, + __riscv_vle8_v_i8m4, + __riscv_vreinterpret_v_i8m4_i16m4, + __riscv_vget_v_i16m4_i16m1, + 3, + __riscv_vwredsum_vs_i8m4_i16m1, + __riscv_vse16_v_i16m1, + vwredsum_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2) + +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v8,v8,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v4,v4,v0([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v4,v(4|5|6|7)([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v8,v(8|9|10|11)([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m8.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m8.c new file mode 100644 index 000000000000..c08e4ce1b039 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m8.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_0( + __riscv_vsetvlmax_e8m8, + vint8m8_t, + vint16m1_t, + vint16m8_t, + __riscv_vle8_v_i8m8, + __riscv_vreinterpret_v_i8m8_i16m8, + __riscv_vget_v_i16m8_i16m1, + 7, + __riscv_vwredsum_vs_i8m8_i16m1, + __riscv_vse16_v_i16m1, + vwredsum_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2) + +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v16,v16,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsum\.vs\s+v8,v8,v0([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v8,v(8|9|10|11|12|13|14|15)([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsum\.vs\s+v[0-9]+,v16,v(16|17|18|19|20|21|22|23)([^0-9]|$)} } } */ From 42deb9a3bfe42d22412c416a82ccc713e84ed3d1 Mon Sep 17 00:00:00 2001 From: Pan Li Date: Sat, 5 Sep 2026 20:33:00 +0800 Subject: [PATCH 175/584] RISC-V: Add test cases for vwredsumu.vs reg overlap Add test cases for the register group overlap of the widening reduction vwredsumu.vs, to ensure the scalar operand vs1 will not fall inside the vs2 register group. gcc/testsuite/ChangeLog: * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m1.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m2.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m4.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m8.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m1.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m2.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m4.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m8.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m1.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m2.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m4.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m8.c: New test. Signed-off-by: Pan Li --- .../group_overlap/vwredsumu_vs-u16-m1.c | 20 ++++++++++++++++ .../group_overlap/vwredsumu_vs-u16-m2.c | 23 +++++++++++++++++++ .../group_overlap/vwredsumu_vs-u16-m4.c | 23 +++++++++++++++++++ .../group_overlap/vwredsumu_vs-u16-m8.c | 23 +++++++++++++++++++ .../group_overlap/vwredsumu_vs-u32-m1.c | 20 ++++++++++++++++ .../group_overlap/vwredsumu_vs-u32-m2.c | 23 +++++++++++++++++++ .../group_overlap/vwredsumu_vs-u32-m4.c | 23 +++++++++++++++++++ .../group_overlap/vwredsumu_vs-u32-m8.c | 23 +++++++++++++++++++ .../group_overlap/vwredsumu_vs-u8-m1.c | 20 ++++++++++++++++ .../group_overlap/vwredsumu_vs-u8-m2.c | 23 +++++++++++++++++++ .../group_overlap/vwredsumu_vs-u8-m4.c | 23 +++++++++++++++++++ .../group_overlap/vwredsumu_vs-u8-m8.c | 23 +++++++++++++++++++ 12 files changed, 267 insertions(+) create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m1.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m2.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m4.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m8.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m1.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m2.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m4.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m8.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m1.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m2.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m4.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m8.c diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m1.c new file mode 100644 index 000000000000..b77a079293e1 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m1.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_1( + __riscv_vsetvlmax_e16m1, + vuint16m1_t, + vuint32m1_t, + __riscv_vle16_v_u16m1, + __riscv_vreinterpret_v_u16m1_u32m1, + __riscv_vwredsumu_vs_u16m1_u32m1, + __riscv_vse32_v_u32m1, + vwredsumu_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_LMUL1_X2) + +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v0,v2,v3([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v5,v1,v4([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v1,v1([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v2,v2([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m2.c new file mode 100644 index 000000000000..338216a12190 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m2.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_0( + __riscv_vsetvlmax_e16m2, + vuint16m2_t, + vuint32m1_t, + vuint32m2_t, + __riscv_vle16_v_u16m2, + __riscv_vreinterpret_v_u16m2_u32m2, + __riscv_vget_v_u32m2_u32m1, + 1, + __riscv_vwredsumu_vs_u16m2_u32m1, + __riscv_vse32_v_u32m1, + vwredsumu_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2) + +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v4,v4,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v2,v2,v0([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v2,v(2|3)([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v4,v(4|5)([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m4.c new file mode 100644 index 000000000000..7751133654e3 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m4.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_0( + __riscv_vsetvlmax_e16m4, + vuint16m4_t, + vuint32m1_t, + vuint32m4_t, + __riscv_vle16_v_u16m4, + __riscv_vreinterpret_v_u16m4_u32m4, + __riscv_vget_v_u32m4_u32m1, + 3, + __riscv_vwredsumu_vs_u16m4_u32m1, + __riscv_vse32_v_u32m1, + vwredsumu_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2) + +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v8,v8,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v4,v4,v0([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v4,v(4|5|6|7)([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v8,v(8|9|10|11)([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m8.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m8.c new file mode 100644 index 000000000000..447692000fa3 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m8.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_0( + __riscv_vsetvlmax_e16m8, + vuint16m8_t, + vuint32m1_t, + vuint32m8_t, + __riscv_vle16_v_u16m8, + __riscv_vreinterpret_v_u16m8_u32m8, + __riscv_vget_v_u32m8_u32m1, + 7, + __riscv_vwredsumu_vs_u16m8_u32m1, + __riscv_vse32_v_u32m1, + vwredsumu_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2) + +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v16,v16,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v8,v8,v0([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v8,v(8|9|10|11|12|13|14|15)([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v16,v(16|17|18|19|20|21|22|23)([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m1.c new file mode 100644 index 000000000000..a5c660892414 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m1.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_1( + __riscv_vsetvlmax_e32m1, + vuint32m1_t, + vuint64m1_t, + __riscv_vle32_v_u32m1, + __riscv_vreinterpret_v_u32m1_u64m1, + __riscv_vwredsumu_vs_u32m1_u64m1, + __riscv_vse64_v_u64m1, + vwredsumu_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_LMUL1_X2) + +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v0,v2,v3([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v5,v1,v4([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v1,v1([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v2,v2([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m2.c new file mode 100644 index 000000000000..056a2ddb27d5 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m2.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_0( + __riscv_vsetvlmax_e32m2, + vuint32m2_t, + vuint64m1_t, + vuint64m2_t, + __riscv_vle32_v_u32m2, + __riscv_vreinterpret_v_u32m2_u64m2, + __riscv_vget_v_u64m2_u64m1, + 1, + __riscv_vwredsumu_vs_u32m2_u64m1, + __riscv_vse64_v_u64m1, + vwredsumu_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2) + +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v4,v4,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v2,v2,v0([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v2,v(2|3)([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v4,v(4|5)([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m4.c new file mode 100644 index 000000000000..733d96bd40f4 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m4.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_0( + __riscv_vsetvlmax_e32m4, + vuint32m4_t, + vuint64m1_t, + vuint64m4_t, + __riscv_vle32_v_u32m4, + __riscv_vreinterpret_v_u32m4_u64m4, + __riscv_vget_v_u64m4_u64m1, + 3, + __riscv_vwredsumu_vs_u32m4_u64m1, + __riscv_vse64_v_u64m1, + vwredsumu_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2) + +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v8,v8,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v4,v4,v0([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v4,v(4|5|6|7)([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v8,v(8|9|10|11)([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m8.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m8.c new file mode 100644 index 000000000000..a5445c040337 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m8.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_0( + __riscv_vsetvlmax_e32m8, + vuint32m8_t, + vuint64m1_t, + vuint64m8_t, + __riscv_vle32_v_u32m8, + __riscv_vreinterpret_v_u32m8_u64m8, + __riscv_vget_v_u64m8_u64m1, + 7, + __riscv_vwredsumu_vs_u32m8_u64m1, + __riscv_vse64_v_u64m1, + vwredsumu_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2) + +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v16,v16,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v8,v8,v0([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v8,v(8|9|10|11|12|13|14|15)([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v16,v(16|17|18|19|20|21|22|23)([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m1.c new file mode 100644 index 000000000000..8b98931f32cc --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m1.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_1( + __riscv_vsetvlmax_e8m1, + vuint8m1_t, + vuint16m1_t, + __riscv_vle8_v_u8m1, + __riscv_vreinterpret_v_u8m1_u16m1, + __riscv_vwredsumu_vs_u8m1_u16m1, + __riscv_vse16_v_u16m1, + vwredsumu_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_LMUL1_X2) + +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v0,v2,v3([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v5,v1,v4([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v1,v1([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v2,v2([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m2.c new file mode 100644 index 000000000000..665e9e7d5354 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m2.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_0( + __riscv_vsetvlmax_e8m2, + vuint8m2_t, + vuint16m1_t, + vuint16m2_t, + __riscv_vle8_v_u8m2, + __riscv_vreinterpret_v_u8m2_u16m2, + __riscv_vget_v_u16m2_u16m1, + 1, + __riscv_vwredsumu_vs_u8m2_u16m1, + __riscv_vse16_v_u16m1, + vwredsumu_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2) + +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v4,v4,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v2,v2,v0([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v2,v(2|3)([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v4,v(4|5)([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m4.c new file mode 100644 index 000000000000..2b79c970e451 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m4.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_0( + __riscv_vsetvlmax_e8m4, + vuint8m4_t, + vuint16m1_t, + vuint16m4_t, + __riscv_vle8_v_u8m4, + __riscv_vreinterpret_v_u8m4_u16m4, + __riscv_vget_v_u16m4_u16m1, + 3, + __riscv_vwredsumu_vs_u8m4_u16m1, + __riscv_vse16_v_u16m1, + vwredsumu_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2) + +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v8,v8,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v4,v4,v0([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v4,v(4|5|6|7)([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v8,v(8|9|10|11)([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m8.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m8.c new file mode 100644 index 000000000000..87a8b619ed62 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m8.c @@ -0,0 +1,23 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_REDUCE_0( + __riscv_vsetvlmax_e8m8, + vuint8m8_t, + vuint16m1_t, + vuint16m8_t, + __riscv_vle8_v_u8m8, + __riscv_vreinterpret_v_u8m8_u16m8, + __riscv_vget_v_u16m8_u16m1, + 7, + __riscv_vwredsumu_vs_u8m8_u16m1, + __riscv_vse16_v_u16m1, + vwredsumu_vs, + LOOP_WIDEN_REDUCE_BODY_OVERLAP_X2) + +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v16,v16,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vwredsumu\.vs\s+v8,v8,v0([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v8,v(8|9|10|11|12|13|14|15)([^0-9]|$)} } } */ +/* { dg-final { scan-assembler-not {vwredsumu\.vs\s+v[0-9]+,v16,v(16|17|18|19|20|21|22|23)([^0-9]|$)} } } */ From 20a1e5b5c5addc4378f5e9d711649c9e5ab82d81 Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Fri, 18 Sep 2026 09:02:34 +0200 Subject: [PATCH 176/584] contrib, libcpp, libstdc++: Update to Unicode 18.0.0 Unicode 18.0.0 has been released on September, 16th. The following patch follows the unicode/README and updates whatever is needed in gcc to that Unicode version. In glibc there weren't any changes to the from_glibc files. Note, apparently I forgot last year to bump in libstdc++ the inline namespace and 160000 code to 170000, this bumps it right to 180000. As for tests, I've added some new characters to named-universal-char-escape-1.c and made sure to test boundaries of generated ranges where it changed and test new generated ranges. In libstdc++ testsuite/ext/unicode/properties.cc test I had to tweak one static assert because EastAsianWidth.txt changed for the character being tested (and there is no character right above U+1FAFA). 2026-09-18 Jakub Jelinek contrib/ * unicode/README: Replace Unicode 17 version with 18. * unicode/gen_libstdcxx_unicode_data.py: Use 180000 instead of 160000 in _GLIBCXX_GET_UNICODE_DATA test. * unicode/DerivedCoreProperties.txt: Updated from Unicode 18.0. * unicode/emoji-data.txt: Likewise. * unicode/PropList.txt: Likewise. * unicode/HangulSyllableType.txt: Likewise. * unicode/DerivedNormalizationProps.txt: Likewise. * unicode/NameAliases.txt: Likewise. * unicode/UnicodeData.txt: Likewise. * unicode/EastAsianWidth.txt: Likewise. gcc/testsuite/ * c-c++-common/cpp/named-universal-char-escape-1.c: Add tests for some Unicode 18.0 characters, both normal and generated. libcpp/ * makeucnid.cc (write_copyright): Update Unicode Copyright years. * makeuname2c.cc (generated_ranges): Adjust Unicode version from 17.0 to 18.0. Add JURCHEN CHARACTER- and SMALL SEAL CHARACTER- generated ranges, adjust indexes in following entries. (write_copyright): Update Unicode Copyright years. * generated_cpp_wcwidth.h: Regenerated. * ucnid.h: Regenerated. * uname2c.h: Regenerated. libstdc++-v3/ * include/bits/unicode.h (std::__unicode::__v16_0_0): Rename inline namespace to ... (std::__unicode::__v18_0_0): ... this. (_GLIBCXX_GET_UNICODE_DATA): Change from 160000 to 180000. * testsuite/ext/unicode/properties.cc: Expect 2 rather than 1 for uc::__field_width(U'\U0001FAF9'). * include/bits/unicode-data.h: Regenerated. Reviewed-by: Jonathan Wakely Reviewed-by: Joseph Myers --- contrib/unicode/DerivedCoreProperties.txt | 584 +- contrib/unicode/DerivedNormalizationProps.txt | 254 +- contrib/unicode/EastAsianWidth.txt | 97 +- contrib/unicode/HangulSyllableType.txt | 6 +- contrib/unicode/NameAliases.txt | 6 +- contrib/unicode/PropList.txt | 101 +- contrib/unicode/README | 6 +- contrib/unicode/UnicodeData.txt | 784 +- contrib/unicode/emoji-data.txt | 49 +- contrib/unicode/gen_libstdcxx_unicode_data.py | 2 +- .../cpp/named-universal-char-escape-1.c | 10 + libcpp/generated_cpp_wcwidth.h | 171 +- libcpp/makeucnid.cc | 2 +- libcpp/makeuname2c.cc | 20 +- libcpp/ucnid.h | 91 +- libcpp/uname2c.h | 37266 ++++++++-------- libstdc++-v3/include/bits/unicode-data.h | 149 +- libstdc++-v3/include/bits/unicode.h | 6 +- .../testsuite/ext/unicode/properties.cc | 2 +- 19 files changed, 20710 insertions(+), 18896 deletions(-) diff --git a/contrib/unicode/DerivedCoreProperties.txt b/contrib/unicode/DerivedCoreProperties.txt index f327784bf395..a41de001b7e2 100644 --- a/contrib/unicode/DerivedCoreProperties.txt +++ b/contrib/unicode/DerivedCoreProperties.txt @@ -1,6 +1,6 @@ -# DerivedCoreProperties-17.0.0.txt -# Date: 2025-07-30, 23:55:08 GMT -# © 2025 Unicode®, Inc. +# DerivedCoreProperties-18.0.0.txt +# Date: 2026-08-07, 16:19:42 GMT +# © 2026 Unicode®, Inc. # Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries. # For terms of use and license, see https://www.unicode.org/terms_of_use.html # @@ -178,7 +178,8 @@ FF5E ; Math # Sm FULLWIDTH TILDE FFE2 ; Math # Sm FULLWIDTH NOT SIGN FFE9..FFEC ; Math # Sm [4] HALFWIDTH LEFTWARDS ARROW..HALFWIDTH DOWNWARDS ARROW 10D8E..10D8F ; Math # Sm [2] GARAY PLUS SIGN..GARAY MINUS SIGN -1CEF0 ; Math # Sm MEDIUM SMALL WHITE CIRCLE WITH HORIZONTAL BAR +1CEDD..1CEDF ; Math # Sm [3] SQUARE ROOT OF SQUARE ROOT..SQUARE ROOT OF SQUARE ROOT OF SQUARE ROOT OF SQUARE ROOT +1CEF0..1CEFD ; Math # Sm [14] MEDIUM SMALL WHITE CIRCLE WITH HORIZONTAL BAR..HYPERBOLA 1D400..1D454 ; Math # L& [85] MATHEMATICAL BOLD CAPITAL A..MATHEMATICAL ITALIC SMALL G 1D456..1D49C ; Math # L& [71] MATHEMATICAL ITALIC SMALL I..MATHEMATICAL SCRIPT CAPITAL A 1D49E..1D49F ; Math # L& [2] MATHEMATICAL SCRIPT CAPITAL C..MATHEMATICAL SCRIPT CAPITAL D @@ -197,7 +198,7 @@ FFE9..FFEC ; Math # Sm [4] HALFWIDTH LEFTWARDS ARROW..HALFWIDTH DOWNWARDS A 1D540..1D544 ; Math # L& [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M 1D546 ; Math # L& MATHEMATICAL DOUBLE-STRUCK CAPITAL O 1D54A..1D550 ; Math # L& [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y -1D552..1D6A5 ; Math # L& [340] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J +1D552..1D6A6 ; Math # L& [341] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL LIGATURE LONG S WITH DESCENDER S 1D6A8..1D6C0 ; Math # L& [25] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL BOLD CAPITAL OMEGA 1D6C1 ; Math # Sm MATHEMATICAL BOLD NABLA 1D6C2..1D6DA ; Math # L& [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA @@ -220,6 +221,7 @@ FFE9..FFEC ; Math # Sm [4] HALFWIDTH LEFTWARDS ARROW..HALFWIDTH DOWNWARDS A 1D7C3 ; Math # Sm MATHEMATICAL SANS-SERIF BOLD ITALIC PARTIAL DIFFERENTIAL 1D7C4..1D7CB ; Math # L& [8] MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD SMALL DIGAMMA 1D7CE..1D7FF ; Math # Nd [50] MATHEMATICAL BOLD DIGIT ZERO..MATHEMATICAL MONOSPACE DIGIT NINE +1DB00..1DB1C ; Math # Sm [29] LEIBNIZIAN EQUALS SIGN..FACIT SYMBOL 1EE00..1EE03 ; Math # Lo [4] ARABIC MATHEMATICAL ALEF..ARABIC MATHEMATICAL DAL 1EE05..1EE1F ; Math # Lo [27] ARABIC MATHEMATICAL WAW..ARABIC MATHEMATICAL DOTLESS QAF 1EE21..1EE22 ; Math # Lo [2] ARABIC MATHEMATICAL INITIAL BEH..ARABIC MATHEMATICAL INITIAL JEEM @@ -254,9 +256,11 @@ FFE9..FFEC ; Math # Sm [4] HALFWIDTH LEFTWARDS ARROW..HALFWIDTH DOWNWARDS A 1EEA5..1EEA9 ; Math # Lo [5] ARABIC MATHEMATICAL DOUBLE-STRUCK WAW..ARABIC MATHEMATICAL DOUBLE-STRUCK YEH 1EEAB..1EEBB ; Math # Lo [17] ARABIC MATHEMATICAL DOUBLE-STRUCK LAM..ARABIC MATHEMATICAL DOUBLE-STRUCK GHAIN 1EEF0..1EEF1 ; Math # Sm [2] ARABIC MATHEMATICAL OPERATOR MEEM WITH HAH WITH TATWEEL..ARABIC MATHEMATICAL OPERATOR HAH WITH DAL +1F7DB ; Math # So BULLET IN DOUBLE CIRCLE +1F7F1..1F7FF ; Math # So [15] CIRCLE WITH DOUBLE VERTICAL AND HORIZONTAL LINE..RHOMBUS 1F8D0..1F8D8 ; Math # Sm [9] LONG RIGHTWARDS ARROW OVER LONG LEFTWARDS ARROW..LONG LEFT RIGHT ARROW WITH DEPENDENT LOBE -# Total code points: 2322 +# Total code points: 2384 # ================================================ @@ -298,13 +302,14 @@ FFE9..FFEC ; Math # Sm [4] HALFWIDTH LEFTWARDS ARROW..HALFWIDTH DOWNWARDS A 03F7..0481 ; Alphabetic # L& [139] GREEK CAPITAL LETTER SHO..CYRILLIC SMALL LETTER KOPPA 048A..052F ; Alphabetic # L& [166] CYRILLIC CAPITAL LETTER SHORT I WITH TAIL..CYRILLIC SMALL LETTER EL WITH DESCENDER 0531..0556 ; Alphabetic # L& [38] ARMENIAN CAPITAL LETTER AYB..ARMENIAN CAPITAL LETTER FEH -0559 ; Alphabetic # Lm ARMENIAN MODIFIER LETTER LEFT HALF RING +0558..0559 ; Alphabetic # Lm [2] MODIFIER LETTER ARMENIAN SMALL EH..ARMENIAN MODIFIER LETTER LEFT HALF RING 0560..0588 ; Alphabetic # L& [41] ARMENIAN SMALL LETTER TURNED AYB..ARMENIAN SMALL LETTER YI WITH STROKE +058B..058C ; Alphabetic # Lm [2] MODIFIER LETTER ARMENIAN SMALL INI..MODIFIER LETTER ARMENIAN SMALL YI 05B0..05BD ; Alphabetic # Mn [14] HEBREW POINT SHEVA..HEBREW POINT METEG 05BF ; Alphabetic # Mn HEBREW POINT RAFE 05C1..05C2 ; Alphabetic # Mn [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT 05C4..05C5 ; Alphabetic # Mn [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT -05C7 ; Alphabetic # Mn HEBREW POINT QAMATS QATAN +05C7..05C9 ; Alphabetic # Mn [3] HEBREW POINT QAMATS QATAN..HEBREW POINT DAGESH HAZAQ MUDGASH 05D0..05EA ; Alphabetic # Lo [27] HEBREW LETTER ALEF..HEBREW LETTER TAV 05EF..05F2 ; Alphabetic # Lo [4] HEBREW YOD TRIANGLE..HEBREW LIGATURE YIDDISH DOUBLE YOD 0610..061A ; Alphabetic # Mn [11] ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM..ARABIC SMALL KASRA @@ -750,7 +755,7 @@ FFE9..FFEC ; Math # Sm [4] HALFWIDTH LEFTWARDS ARROW..HALFWIDTH DOWNWARDS A 1FF6..1FFC ; Alphabetic # L& [7] GREEK SMALL LETTER OMEGA WITH PERISPOMENI..GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI 2071 ; Alphabetic # Lm SUPERSCRIPT LATIN SMALL LETTER I 207F ; Alphabetic # Lm SUPERSCRIPT LATIN SMALL LETTER N -2090..209C ; Alphabetic # Lm [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T +208F..209F ; Alphabetic # Lm [17] MODIFIER LETTER HIGH AND LOW VERTICAL LINE..LATIN SUBSCRIPT SMALL LETTER Z 2102 ; Alphabetic # L& DOUBLE-STRUCK CAPITAL C 2107 ; Alphabetic # L& EULER CONSTANT 210A..2113 ; Alphabetic # L& [10] SCRIPT SMALL G..SCRIPT SMALL L @@ -835,7 +840,8 @@ A771..A787 ; Alphabetic # L& [23] LATIN SMALL LETTER DUM..LATIN SMALL LETTER A788 ; Alphabetic # Lm MODIFIER LETTER LOW CIRCUMFLEX ACCENT A78B..A78E ; Alphabetic # L& [4] LATIN CAPITAL LETTER SALTILLO..LATIN SMALL LETTER L WITH RETROFLEX HOOK AND BELT A78F ; Alphabetic # Lo LATIN LETTER SINOLOGICAL DOT -A790..A7DC ; Alphabetic # L& [77] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN CAPITAL LETTER LAMBDA WITH STROKE +A790..A7DD ; Alphabetic # L& [78] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN CAPITAL LETTER CLOSED OMEGA +A7E2 ; Alphabetic # L& LATIN CAPITAL LETTER R WITH LONG LEG A7F1..A7F4 ; Alphabetic # Lm [4] MODIFIER LETTER CAPITAL S..MODIFIER LETTER CAPITAL Q A7F5..A7F6 ; Alphabetic # L& [2] LATIN CAPITAL LETTER REVERSED HALF H..LATIN SMALL LETTER REVERSED HALF H A7F7 ; Alphabetic # Lo LATIN EPIGRAPHIC LETTER SIDEWAYS I @@ -925,6 +931,7 @@ AB30..AB5A ; Alphabetic # L& [43] LATIN SMALL LETTER BARRED ALPHA..LATIN SMA AB5C..AB5F ; Alphabetic # Lm [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK AB60..AB68 ; Alphabetic # L& [9] LATIN SMALL LETTER SAKHA YAT..LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE AB69 ; Alphabetic # Lm MODIFIER LETTER SMALL TURNED W +AB6C..AB6D ; Alphabetic # L& [2] LATIN CAPITAL LETTER SCRIPT R..LATIN CAPITAL LETTER SCRIPT R WITH RING AB70..ABBF ; Alphabetic # L& [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA ABC0..ABE2 ; Alphabetic # Lo [35] MEETEI MAYEK LETTER KOK..MEETEI MAYEK LETTER I LONSUM ABE3..ABE4 ; Alphabetic # Mc [2] MEETEI MAYEK VOWEL SIGN ONAP..MEETEI MAYEK VOWEL SIGN INAP @@ -1006,7 +1013,7 @@ FFDA..FFDC ; Alphabetic # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANG 10760..10767 ; Alphabetic # Lo [8] LINEAR A SIGN A800..LINEAR A SIGN A807 10780..10785 ; Alphabetic # Lm [6] MODIFIER LETTER SMALL CAPITAL AA..MODIFIER LETTER SMALL B WITH HOOK 10787..107B0 ; Alphabetic # Lm [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK -107B2..107BA ; Alphabetic # Lm [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL +107B2..107BF ; Alphabetic # Lm [14] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL ESH WITH DOUBLE BAR 10800..10805 ; Alphabetic # Lo [6] CYPRIOT SYLLABLE A..CYPRIOT SYLLABLE JA 10808 ; Alphabetic # Lo CYPRIOT SYLLABLE JO 1080A..10835 ; Alphabetic # Lo [44] CYPRIOT SYLLABLE KA..CYPRIOT SYLLABLE WO @@ -1055,6 +1062,11 @@ FFDA..FFDC ; Alphabetic # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANG 10EC2..10EC4 ; Alphabetic # Lo [3] ARABIC LETTER DAL WITH TWO DOTS VERTICALLY BELOW..ARABIC LETTER KAF WITH TWO DOTS VERTICALLY BELOW 10EC5 ; Alphabetic # Lm ARABIC SMALL YEH BARREE WITH TWO DOTS BELOW 10EC6..10EC7 ; Alphabetic # Lo [2] ARABIC LETTER THIN NOON..ARABIC LETTER YEH WITH FOUR DOTS BELOW +10ECB..10ECD ; Alphabetic # Mn [3] ARABIC NORTHEAST POINTING ARROWHEAD ABOVE..ARABIC SOUTHWEST POINTING ARROWHEAD BELOW +10ED9..10EEE ; Alphabetic # Lo [22] ARABIC CROWN LETTER BEH..ARABIC CROWN LETTER YEH +10EF3 ; Alphabetic # Mn ARABIC SMALL HIGH NOON WITH FATHA +10EF5 ; Alphabetic # Mn ARABIC SMALL HIGH NOON WITH DAMMA +10EF7..10EF8 ; Alphabetic # Mn [2] ARABIC SMALL HIGH HEH INITIAL FORM..ARABIC SMALL HIGH WORD KABBIR 10EFA..10EFC ; Alphabetic # Mn [3] ARABIC DOUBLE VERTICAL BAR BELOW..ARABIC COMBINING ALEF OVERLAY 10F00..10F1C ; Alphabetic # Lo [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL 10F27 ; Alphabetic # Lo OLD SOGDIAN LIGATURE AYIN-DALETH @@ -1241,6 +1253,7 @@ FFDA..FFDC ; Alphabetic # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANG 11A97 ; Alphabetic # Mc SOYOMBO SIGN VISARGA 11A9D ; Alphabetic # Lo SOYOMBO MARK PLUTA 11AB0..11AF8 ; Alphabetic # Lo [73] CANADIAN SYLLABICS NATTILIK HI..PAU CIN HAU GLOTTAL STOP FINAL +11B0A ; Alphabetic # Lo DEVANAGARI LETTER ALTERNATE DDDA 11B60 ; Alphabetic # Mn SHARADA VOWEL SIGN OE 11B61 ; Alphabetic # Mc SHARADA VOWEL SIGN OOE 11B62..11B64 ; Alphabetic # Mn [3] SHARADA VOWEL SIGN UE..SHARADA VOWEL SIGN SHORT E @@ -1285,6 +1298,8 @@ FFDA..FFDC ; Alphabetic # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANG 11DB0..11DD8 ; Alphabetic # Lo [41] TOLONG SIKI LETTER I..TOLONG SIKI LETTER RRH 11DD9 ; Alphabetic # Lm TOLONG SIKI SIGN SELA 11DDA..11DDB ; Alphabetic # Lo [2] TOLONG SIKI SIGN HECAKA..TOLONG SIKI UNGGA +11DF0 ; Alphabetic # Mn BENGALI SIGN COMBINING ANUSVARA ABOVE +11DF1 ; Alphabetic # Lo BENGALI LETTER ALTERNATE BARGIYA BA 11EE0..11EF2 ; Alphabetic # Lo [19] MAKASAR LETTER KA..MAKASAR ANGKA 11EF3..11EF4 ; Alphabetic # Mn [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U 11EF5..11EF6 ; Alphabetic # Mc [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O @@ -1299,8 +1314,10 @@ FFDA..FFDC ; Alphabetic # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANG 11F40 ; Alphabetic # Mn KAWI VOWEL SIGN EU 11FB0 ; Alphabetic # Lo LISU LETTER YHA 12000..12399 ; Alphabetic # Lo [922] CUNEIFORM SIGN A..CUNEIFORM SIGN U U -12400..1246E ; Alphabetic # Nl [111] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM +12400..1246F ; Alphabetic # Nl [112] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN SEVEN ASH TENU +12475..1247F ; Alphabetic # Nl [11] CUNEIFORM NUMERIC SIGN EIGHT ASH TENU..CUNEIFORM NUMERIC SIGN ASH TIMES NINE DISH TENU 12480..12543 ; Alphabetic # Lo [196] CUNEIFORM SIGN AB TIMES NUN TENU..CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU +12550..12686 ; Alphabetic # Nl [311] CUNEIFORM NUMERIC SIGN ONE N01..CUNEIFORM NUMERIC SIGN ONE N36 FLAT 12F90..12FF0 ; Alphabetic # Lo [97] CYPRO-MINOAN SIGN CM001..CYPRO-MINOAN SIGN CM114 13000..1342F ; Alphabetic # Lo [1072] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH V011D 13441..13446 ; Alphabetic # Lo [6] EGYPTIAN HIEROGLYPH FULL BLANK..EGYPTIAN HIEROGLYPH WIDE LOST SIGN @@ -1335,17 +1352,19 @@ FFDA..FFDC ; Alphabetic # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANG 16FF0..16FF1 ; Alphabetic # Mc [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY 16FF2..16FF3 ; Alphabetic # Lm [2] CHINESE SMALL SIMPLIFIED ER..CHINESE SMALL TRADITIONAL ER 16FF4..16FF6 ; Alphabetic # Nl [3] YANGQIN SIGN SLOW ONE BEAT..YANGQIN SIGN SLOW TWO BEATS -17000..18CD5 ; Alphabetic # Lo [7382] TANGUT IDEOGRAPH-17000..KHITAN SMALL SCRIPT CHARACTER-18CD5 -18CFF..18D1E ; Alphabetic # Lo [32] KHITAN SMALL SCRIPT CHARACTER-18CFF..TANGUT IDEOGRAPH-18D1E +17000..18CDA ; Alphabetic # Lo [7387] TANGUT IDEOGRAPH-17000..KHITAN SMALL SCRIPT CHARACTER-18CDA +18CFF..18D20 ; Alphabetic # Lo [34] KHITAN SMALL SCRIPT CHARACTER-18CFF..TANGUT IDEOGRAPH-18D20 18D80..18DF2 ; Alphabetic # Lo [115] TANGUT COMPONENT-769..TANGUT COMPONENT-883 +18E00..19191 ; Alphabetic # Lo [914] JURCHEN CHARACTER-18E00..JURCHEN CHARACTER-19191 +191A0..191D2 ; Alphabetic # Lo [51] JURCHEN RADICAL-01..JURCHEN RADICAL-51 1AFF0..1AFF3 ; Alphabetic # Lm [4] KATAKANA LETTER MINNAN TONE-2..KATAKANA LETTER MINNAN TONE-5 1AFF5..1AFFB ; Alphabetic # Lm [7] KATAKANA LETTER MINNAN TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-5 1AFFD..1AFFE ; Alphabetic # Lm [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8 -1B000..1B122 ; Alphabetic # Lo [291] KATAKANA LETTER ARCHAIC E..KATAKANA LETTER ARCHAIC WU +1B000..1B128 ; Alphabetic # Lo [297] KATAKANA LETTER ARCHAIC E..KATAKANA LETTER ALTERNATE WI 1B132 ; Alphabetic # Lo HIRAGANA LETTER SMALL KO 1B150..1B152 ; Alphabetic # Lo [3] HIRAGANA LETTER SMALL WI..HIRAGANA LETTER SMALL WO 1B155 ; Alphabetic # Lo KATAKANA LETTER SMALL KO -1B164..1B167 ; Alphabetic # Lo [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N +1B164..1B168 ; Alphabetic # Lo [5] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL ARCHAIC YE 1B170..1B2FB ; Alphabetic # Lo [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB 1BC00..1BC6A ; Alphabetic # Lo [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M 1BC70..1BC7C ; Alphabetic # Lo [13] DUPLOYAN AFFIX LEFT HORIZONTAL SECANT..DUPLOYAN AFFIX ATTACHED TANGENT HOOK @@ -1370,7 +1389,7 @@ FFDA..FFDC ; Alphabetic # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANG 1D540..1D544 ; Alphabetic # L& [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M 1D546 ; Alphabetic # L& MATHEMATICAL DOUBLE-STRUCK CAPITAL O 1D54A..1D550 ; Alphabetic # L& [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y -1D552..1D6A5 ; Alphabetic # L& [340] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J +1D552..1D6A6 ; Alphabetic # L& [341] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL LIGATURE LONG S WITH DESCENDER S 1D6A8..1D6C0 ; Alphabetic # L& [25] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL BOLD CAPITAL OMEGA 1D6C2..1D6DA ; Alphabetic # L& [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA 1D6DC..1D6FA ; Alphabetic # L& [31] MATHEMATICAL BOLD EPSILON SYMBOL..MATHEMATICAL ITALIC CAPITAL OMEGA @@ -1384,8 +1403,10 @@ FFDA..FFDC ; Alphabetic # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANG 1D7C4..1D7CB ; Alphabetic # L& [8] MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD SMALL DIGAMMA 1DF00..1DF09 ; Alphabetic # L& [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK 1DF0A ; Alphabetic # Lo LATIN LETTER RETROFLEX CLICK WITH RETROFLEX HOOK -1DF0B..1DF1E ; Alphabetic # L& [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL -1DF25..1DF2A ; Alphabetic # L& [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK +1DF0B..1DF7F ; Alphabetic # L& [117] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER REVERSED U +1DF80..1DF81 ; Alphabetic # Lo [2] LATIN CAPITAL LETTER A WITH TOPBAR..LATIN CAPITAL LETTER E WITH BENT TOPBAR +1DF90..1DF96 ; Alphabetic # L& [7] LATIN SMALL LETTER C WITH LOW SLASH..LATIN SMALL LETTER LONG S WITH TOP LOOP +1DFCD..1DFFF ; Alphabetic # Lm [51] MODIFIER LETTER SMALL TURNED R WITH MID-HEIGHT LEFT HOOK..MODIFIER LETTER SMALL T WITH HOOK AND RETROFLEX HOOK 1E000..1E006 ; Alphabetic # Mn [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE 1E008..1E018 ; Alphabetic # Mn [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU 1E01B..1E021 ; Alphabetic # Mn [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI @@ -1458,15 +1479,16 @@ FFDA..FFDC ; Alphabetic # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANG 1F150..1F169 ; Alphabetic # So [26] NEGATIVE CIRCLED LATIN CAPITAL LETTER A..NEGATIVE CIRCLED LATIN CAPITAL LETTER Z 1F170..1F189 ; Alphabetic # So [26] NEGATIVE SQUARED LATIN CAPITAL LETTER A..NEGATIVE SQUARED LATIN CAPITAL LETTER Z 20000..2A6DF ; Alphabetic # Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF -2A700..2B81D ; Alphabetic # Lo [4382] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81D +2A700..2B81E ; Alphabetic # Lo [4383] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81E 2B820..2CEAD ; Alphabetic # Lo [5774] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEAD 2CEB0..2EBE0 ; Alphabetic # Lo [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0 2EBF0..2EE5D ; Alphabetic # Lo [622] CJK UNIFIED IDEOGRAPH-2EBF0..CJK UNIFIED IDEOGRAPH-2EE5D 2F800..2FA1D ; Alphabetic # Lo [542] CJK COMPATIBILITY IDEOGRAPH-2F800..CJK COMPATIBILITY IDEOGRAPH-2FA1D 30000..3134A ; Alphabetic # Lo [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A 31350..33479 ; Alphabetic # Lo [8490] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-33479 +3D000..3FC3F ; Alphabetic # Lo [11328] SMALL SEAL CHARACTER-3D000..SMALL SEAL CHARACTER-3FC3F -# Total code points: 147421 +# Total code points: 160254 # ================================================ @@ -1749,7 +1771,9 @@ FFDA..FFDC ; Alphabetic # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANG 052B ; Lowercase # L& CYRILLIC SMALL LETTER DZZHE 052D ; Lowercase # L& CYRILLIC SMALL LETTER DCHE 052F ; Lowercase # L& CYRILLIC SMALL LETTER EL WITH DESCENDER +0558 ; Lowercase # Lm MODIFIER LETTER ARMENIAN SMALL EH 0560..0588 ; Lowercase # L& [41] ARMENIAN SMALL LETTER TURNED AYB..ARMENIAN SMALL LETTER YI WITH STROKE +058B..058C ; Lowercase # Lm [2] MODIFIER LETTER ARMENIAN SMALL INI..MODIFIER LETTER ARMENIAN SMALL YI 10D0..10FA ; Lowercase # L& [43] GEORGIAN LETTER AN..GEORGIAN LETTER AIN 10FC ; Lowercase # Lm MODIFIER LETTER GEORGIAN NAR 10FD..10FF ; Lowercase # L& [3] GEORGIAN LETTER AEN..GEORGIAN LETTER LABIAL SIGN @@ -1908,7 +1932,7 @@ FFDA..FFDC ; Alphabetic # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANG 1FF6..1FF7 ; Lowercase # L& [2] GREEK SMALL LETTER OMEGA WITH PERISPOMENI..GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI 2071 ; Lowercase # Lm SUPERSCRIPT LATIN SMALL LETTER I 207F ; Lowercase # Lm SUPERSCRIPT LATIN SMALL LETTER N -2090..209C ; Lowercase # Lm [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T +2090..209F ; Lowercase # Lm [16] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER Z 210A ; Lowercase # L& SCRIPT SMALL G 210E..210F ; Lowercase # L& [2] PLANCK CONSTANT..PLANCK CONSTANT OVER TWO PI 2113 ; Lowercase # L& SCRIPT SMALL L @@ -2126,7 +2150,7 @@ FF41..FF5A ; Lowercase # L& [26] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH L 10780 ; Lowercase # Lm MODIFIER LETTER SMALL CAPITAL AA 10783..10785 ; Lowercase # Lm [3] MODIFIER LETTER SMALL AE..MODIFIER LETTER SMALL B WITH HOOK 10787..107B0 ; Lowercase # Lm [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK -107B2..107BA ; Lowercase # Lm [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL +107B2..107BF ; Lowercase # Lm [14] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL ESH WITH DOUBLE BAR 10CC0..10CF2 ; Lowercase # L& [51] OLD HUNGARIAN SMALL LETTER A..OLD HUNGARIAN SMALL LETTER US 10D70..10D85 ; Lowercase # L& [22] GARAY SMALL LETTER A..GARAY SMALL LETTER OLD NA 118C0..118DF ; Lowercase # L& [32] WARANG CITI SMALL LETTER NGAA..WARANG CITI SMALL LETTER VIYO @@ -2148,7 +2172,7 @@ FF41..FF5A ; Lowercase # L& [26] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH L 1D5EE..1D607 ; Lowercase # L& [26] MATHEMATICAL SANS-SERIF BOLD SMALL A..MATHEMATICAL SANS-SERIF BOLD SMALL Z 1D622..1D63B ; Lowercase # L& [26] MATHEMATICAL SANS-SERIF ITALIC SMALL A..MATHEMATICAL SANS-SERIF ITALIC SMALL Z 1D656..1D66F ; Lowercase # L& [26] MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL A..MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL Z -1D68A..1D6A5 ; Lowercase # L& [28] MATHEMATICAL MONOSPACE SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J +1D68A..1D6A6 ; Lowercase # L& [29] MATHEMATICAL MONOSPACE SMALL A..MATHEMATICAL ITALIC SMALL LIGATURE LONG S WITH DESCENDER S 1D6C2..1D6DA ; Lowercase # L& [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA 1D6DC..1D6E1 ; Lowercase # L& [6] MATHEMATICAL BOLD EPSILON SYMBOL..MATHEMATICAL BOLD PI SYMBOL 1D6FC..1D714 ; Lowercase # L& [25] MATHEMATICAL ITALIC SMALL ALPHA..MATHEMATICAL ITALIC SMALL OMEGA @@ -2161,12 +2185,29 @@ FF41..FF5A ; Lowercase # L& [26] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH L 1D7C4..1D7C9 ; Lowercase # L& [6] MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD ITALIC PI SYMBOL 1D7CB ; Lowercase # L& MATHEMATICAL BOLD SMALL DIGAMMA 1DF00..1DF09 ; Lowercase # L& [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK -1DF0B..1DF1E ; Lowercase # L& [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL -1DF25..1DF2A ; Lowercase # L& [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK +1DF0B..1DF3F ; Lowercase # L& [53] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER BARRED W +1DF41..1DF47 ; Lowercase # L& [7] LATIN SMALL LETTER BARRED A..LATIN SMALL LETTER BARRED H WITH HOOK +1DF49 ; Lowercase # L& LATIN SMALL LETTER BARRED K +1DF4B..1DF4C ; Lowercase # L& [2] LATIN SMALL LETTER BARRED M..LATIN SMALL LETTER BARRED M WITH HOOK +1DF4E..1DF50 ; Lowercase # L& [3] LATIN SMALL LETTER BARRED N..LATIN SMALL LETTER TURNED R WITH STROKE +1DF52..1DF67 ; Lowercase # L& [22] LATIN SMALL LETTER BARRED V..LATIN SMALL LETTER LEZH WITH CURL +1DF69 ; Lowercase # L& LATIN SMALL LETTER PHONOTYPIC A WITH SWASH +1DF6B ; Lowercase # L& LATIN SMALL LETTER PHONOTYPIC ROUNDTOP A +1DF6D ; Lowercase # L& LATIN SMALL LETTER REVERSED SCRUPLE +1DF6F..1DF71 ; Lowercase # L& [3] LATIN SMALL LETTER PHONOTYPIC DIPHTHONG AI..LATIN SMALL LETTER STRETCHED I +1DF73 ; Lowercase # L& LATIN SMALL LETTER O WITH CURL +1DF75 ; Lowercase # L& LATIN SMALL LETTER CLOSED OMEGA WITH LONG STEM +1DF77 ; Lowercase # L& LATIN SMALL LETTER TURNED CLOSED OMEGA +1DF79 ; Lowercase # L& LATIN SMALL LETTER PHONOTYPIC TH +1DF7B ; Lowercase # L& LATIN SMALL LETTER U WITH HOOK TAIL +1DF7D ; Lowercase # L& LATIN SMALL LETTER U WITH NOTCH AT BOTTOM +1DF7F ; Lowercase # L& LATIN SMALL LETTER REVERSED U +1DF90..1DF96 ; Lowercase # L& [7] LATIN SMALL LETTER C WITH LOW SLASH..LATIN SMALL LETTER LONG S WITH TOP LOOP +1DFCD..1DFFF ; Lowercase # Lm [51] MODIFIER LETTER SMALL TURNED R WITH MID-HEIGHT LEFT HOOK..MODIFIER LETTER SMALL T WITH HOOK AND RETROFLEX HOOK 1E030..1E06D ; Lowercase # Lm [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE 1E922..1E943 ; Lowercase # L& [34] ADLAM SMALL LETTER ALIF..ADLAM SMALL LETTER SHA -# Total code points: 2595 +# Total code points: 2740 # ================================================ @@ -2784,8 +2825,10 @@ A7D4 ; Uppercase # L& LATIN CAPITAL LETTER DOUBLE WYNN A7D6 ; Uppercase # L& LATIN CAPITAL LETTER MIDDLE SCOTS S A7D8 ; Uppercase # L& LATIN CAPITAL LETTER SIGMOID S A7DA ; Uppercase # L& LATIN CAPITAL LETTER LAMBDA -A7DC ; Uppercase # L& LATIN CAPITAL LETTER LAMBDA WITH STROKE +A7DC..A7DD ; Uppercase # L& [2] LATIN CAPITAL LETTER LAMBDA WITH STROKE..LATIN CAPITAL LETTER CLOSED OMEGA +A7E2 ; Uppercase # L& LATIN CAPITAL LETTER R WITH LONG LEG A7F5 ; Uppercase # L& LATIN CAPITAL LETTER REVERSED HALF H +AB6C..AB6D ; Uppercase # L& [2] LATIN CAPITAL LETTER SCRIPT R..LATIN CAPITAL LETTER SCRIPT R WITH RING FF21..FF3A ; Uppercase # L& [26] FULLWIDTH LATIN CAPITAL LETTER A..FULLWIDTH LATIN CAPITAL LETTER Z 10400..10427 ; Uppercase # L& [40] DESERET CAPITAL LETTER LONG I..DESERET CAPITAL LETTER EW 104B0..104D3 ; Uppercase # L& [36] OSAGE CAPITAL LETTER A..OSAGE CAPITAL LETTER ZHA @@ -2829,12 +2872,28 @@ FF21..FF3A ; Uppercase # L& [26] FULLWIDTH LATIN CAPITAL LETTER A..FULLWIDTH 1D756..1D76E ; Uppercase # L& [25] MATHEMATICAL SANS-SERIF BOLD CAPITAL ALPHA..MATHEMATICAL SANS-SERIF BOLD CAPITAL OMEGA 1D790..1D7A8 ; Uppercase # L& [25] MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL ALPHA..MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMEGA 1D7CA ; Uppercase # L& MATHEMATICAL BOLD CAPITAL DIGAMMA +1DF40 ; Uppercase # L& LATIN CAPITAL LETTER BARRED A +1DF48 ; Uppercase # L& LATIN CAPITAL LETTER BARRED K +1DF4A ; Uppercase # L& LATIN CAPITAL LETTER BARRED M +1DF4D ; Uppercase # L& LATIN CAPITAL LETTER BARRED N +1DF51 ; Uppercase # L& LATIN CAPITAL LETTER BARRED V +1DF68 ; Uppercase # L& LATIN CAPITAL LETTER PHONOTYPIC A WITH SWASH +1DF6A ; Uppercase # L& LATIN CAPITAL LETTER PHONOTYPIC ROUNDTOP A +1DF6C ; Uppercase # L& LATIN CAPITAL LETTER REVERSED SCRUPLE +1DF6E ; Uppercase # L& LATIN CAPITAL LETTER PHONOTYPIC DIPHTHONG AI +1DF72 ; Uppercase # L& LATIN CAPITAL LETTER O WITH CURL +1DF74 ; Uppercase # L& LATIN CAPITAL LETTER CLOSED OMEGA WITH LONG STEM +1DF76 ; Uppercase # L& LATIN CAPITAL LETTER TURNED CLOSED OMEGA +1DF78 ; Uppercase # L& LATIN CAPITAL LETTER PHONOTYPIC TH +1DF7A ; Uppercase # L& LATIN CAPITAL LETTER U WITH HOOK TAIL +1DF7C ; Uppercase # L& LATIN CAPITAL LETTER U WITH NOTCH AT BOTTOM +1DF7E ; Uppercase # L& LATIN CAPITAL LETTER REVERSED U 1E900..1E921 ; Uppercase # L& [34] ADLAM CAPITAL LETTER ALIF..ADLAM CAPITAL LETTER SHA 1F130..1F149 ; Uppercase # So [26] SQUARED LATIN CAPITAL LETTER A..SQUARED LATIN CAPITAL LETTER Z 1F150..1F169 ; Uppercase # So [26] NEGATIVE CIRCLED LATIN CAPITAL LETTER A..NEGATIVE CIRCLED LATIN CAPITAL LETTER Z 1F170..1F189 ; Uppercase # So [26] NEGATIVE SQUARED LATIN CAPITAL LETTER A..NEGATIVE SQUARED LATIN CAPITAL LETTER Z -# Total code points: 2006 +# Total code points: 2026 # ================================================ @@ -2870,7 +2929,9 @@ FF21..FF3A ; Uppercase # L& [26] FULLWIDTH LATIN CAPITAL LETTER A..FULLWIDTH 03F7..0481 ; Cased # L& [139] GREEK CAPITAL LETTER SHO..CYRILLIC SMALL LETTER KOPPA 048A..052F ; Cased # L& [166] CYRILLIC CAPITAL LETTER SHORT I WITH TAIL..CYRILLIC SMALL LETTER EL WITH DESCENDER 0531..0556 ; Cased # L& [38] ARMENIAN CAPITAL LETTER AYB..ARMENIAN CAPITAL LETTER FEH +0558 ; Cased # Lm MODIFIER LETTER ARMENIAN SMALL EH 0560..0588 ; Cased # L& [41] ARMENIAN SMALL LETTER TURNED AYB..ARMENIAN SMALL LETTER YI WITH STROKE +058B..058C ; Cased # Lm [2] MODIFIER LETTER ARMENIAN SMALL INI..MODIFIER LETTER ARMENIAN SMALL YI 10A0..10C5 ; Cased # L& [38] GEORGIAN CAPITAL LETTER AN..GEORGIAN CAPITAL LETTER HOE 10C7 ; Cased # L& GEORGIAN CAPITAL LETTER YN 10CD ; Cased # L& GEORGIAN CAPITAL LETTER AEN @@ -2909,7 +2970,7 @@ FF21..FF3A ; Uppercase # L& [26] FULLWIDTH LATIN CAPITAL LETTER A..FULLWIDTH 1FF6..1FFC ; Cased # L& [7] GREEK SMALL LETTER OMEGA WITH PERISPOMENI..GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI 2071 ; Cased # Lm SUPERSCRIPT LATIN SMALL LETTER I 207F ; Cased # Lm SUPERSCRIPT LATIN SMALL LETTER N -2090..209C ; Cased # Lm [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T +2090..209F ; Cased # Lm [16] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER Z 2102 ; Cased # L& DOUBLE-STRUCK CAPITAL C 2107 ; Cased # L& EULER CONSTANT 210A..2113 ; Cased # L& [10] SCRIPT SMALL G..SCRIPT SMALL L @@ -2942,7 +3003,8 @@ A722..A76F ; Cased # L& [78] LATIN CAPITAL LETTER EGYPTOLOGICAL ALEF..LATIN A770 ; Cased # Lm MODIFIER LETTER US A771..A787 ; Cased # L& [23] LATIN SMALL LETTER DUM..LATIN SMALL LETTER INSULAR T A78B..A78E ; Cased # L& [4] LATIN CAPITAL LETTER SALTILLO..LATIN SMALL LETTER L WITH RETROFLEX HOOK AND BELT -A790..A7DC ; Cased # L& [77] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN CAPITAL LETTER LAMBDA WITH STROKE +A790..A7DD ; Cased # L& [78] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN CAPITAL LETTER CLOSED OMEGA +A7E2 ; Cased # L& LATIN CAPITAL LETTER R WITH LONG LEG A7F1..A7F4 ; Cased # Lm [4] MODIFIER LETTER CAPITAL S..MODIFIER LETTER CAPITAL Q A7F5..A7F6 ; Cased # L& [2] LATIN CAPITAL LETTER REVERSED HALF H..LATIN SMALL LETTER REVERSED HALF H A7F8..A7F9 ; Cased # Lm [2] MODIFIER LETTER CAPITAL H WITH STROKE..MODIFIER LETTER SMALL LIGATURE OE @@ -2951,6 +3013,7 @@ AB30..AB5A ; Cased # L& [43] LATIN SMALL LETTER BARRED ALPHA..LATIN SMALL LE AB5C..AB5F ; Cased # Lm [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK AB60..AB68 ; Cased # L& [9] LATIN SMALL LETTER SAKHA YAT..LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE AB69 ; Cased # Lm MODIFIER LETTER SMALL TURNED W +AB6C..AB6D ; Cased # L& [2] LATIN CAPITAL LETTER SCRIPT R..LATIN CAPITAL LETTER SCRIPT R WITH RING AB70..ABBF ; Cased # L& [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA FB00..FB06 ; Cased # L& [7] LATIN SMALL LIGATURE FF..LATIN SMALL LIGATURE ST FB13..FB17 ; Cased # L& [5] ARMENIAN SMALL LIGATURE MEN NOW..ARMENIAN SMALL LIGATURE MEN XEH @@ -2970,7 +3033,7 @@ FF41..FF5A ; Cased # L& [26] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH LATIN 10780 ; Cased # Lm MODIFIER LETTER SMALL CAPITAL AA 10783..10785 ; Cased # Lm [3] MODIFIER LETTER SMALL AE..MODIFIER LETTER SMALL B WITH HOOK 10787..107B0 ; Cased # Lm [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK -107B2..107BA ; Cased # Lm [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL +107B2..107BF ; Cased # Lm [14] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL ESH WITH DOUBLE BAR 10C80..10CB2 ; Cased # L& [51] OLD HUNGARIAN CAPITAL LETTER A..OLD HUNGARIAN CAPITAL LETTER US 10CC0..10CF2 ; Cased # L& [51] OLD HUNGARIAN SMALL LETTER A..OLD HUNGARIAN SMALL LETTER US 10D50..10D65 ; Cased # L& [22] GARAY CAPITAL LETTER A..GARAY CAPITAL LETTER OLD NA @@ -2997,7 +3060,7 @@ FF41..FF5A ; Cased # L& [26] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH LATIN 1D540..1D544 ; Cased # L& [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M 1D546 ; Cased # L& MATHEMATICAL DOUBLE-STRUCK CAPITAL O 1D54A..1D550 ; Cased # L& [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y -1D552..1D6A5 ; Cased # L& [340] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J +1D552..1D6A6 ; Cased # L& [341] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL LIGATURE LONG S WITH DESCENDER S 1D6A8..1D6C0 ; Cased # L& [25] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL BOLD CAPITAL OMEGA 1D6C2..1D6DA ; Cased # L& [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA 1D6DC..1D6FA ; Cased # L& [31] MATHEMATICAL BOLD EPSILON SYMBOL..MATHEMATICAL ITALIC CAPITAL OMEGA @@ -3010,15 +3073,16 @@ FF41..FF5A ; Cased # L& [26] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH LATIN 1D7AA..1D7C2 ; Cased # L& [25] MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMEGA 1D7C4..1D7CB ; Cased # L& [8] MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD SMALL DIGAMMA 1DF00..1DF09 ; Cased # L& [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK -1DF0B..1DF1E ; Cased # L& [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL -1DF25..1DF2A ; Cased # L& [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK +1DF0B..1DF7F ; Cased # L& [117] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER REVERSED U +1DF90..1DF96 ; Cased # L& [7] LATIN SMALL LETTER C WITH LOW SLASH..LATIN SMALL LETTER LONG S WITH TOP LOOP +1DFCD..1DFFF ; Cased # Lm [51] MODIFIER LETTER SMALL TURNED R WITH MID-HEIGHT LEFT HOOK..MODIFIER LETTER SMALL T WITH HOOK AND RETROFLEX HOOK 1E030..1E06D ; Cased # Lm [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE 1E900..1E943 ; Cased # L& [68] ADLAM CAPITAL LETTER ALIF..ADLAM SMALL LETTER SHA 1F130..1F149 ; Cased # So [26] SQUARED LATIN CAPITAL LETTER A..SQUARED LATIN CAPITAL LETTER Z 1F150..1F169 ; Cased # So [26] NEGATIVE CIRCLED LATIN CAPITAL LETTER A..NEGATIVE CIRCLED LATIN CAPITAL LETTER Z 1F170..1F189 ; Cased # So [26] NEGATIVE SQUARED LATIN CAPITAL LETTER A..NEGATIVE SQUARED LATIN CAPITAL LETTER Z -# Total code points: 4632 +# Total code points: 4797 # ================================================ @@ -3057,13 +3121,14 @@ FF41..FF5A ; Cased # L& [26] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH LATIN 0387 ; Case_Ignorable # Po GREEK ANO TELEIA 0483..0487 ; Case_Ignorable # Mn [5] COMBINING CYRILLIC TITLO..COMBINING CYRILLIC POKRYTIE 0488..0489 ; Case_Ignorable # Me [2] COMBINING CYRILLIC HUNDRED THOUSANDS SIGN..COMBINING CYRILLIC MILLIONS SIGN -0559 ; Case_Ignorable # Lm ARMENIAN MODIFIER LETTER LEFT HALF RING +0558..0559 ; Case_Ignorable # Lm [2] MODIFIER LETTER ARMENIAN SMALL EH..ARMENIAN MODIFIER LETTER LEFT HALF RING 055F ; Case_Ignorable # Po ARMENIAN ABBREVIATION MARK +058B..058C ; Case_Ignorable # Lm [2] MODIFIER LETTER ARMENIAN SMALL INI..MODIFIER LETTER ARMENIAN SMALL YI 0591..05BD ; Case_Ignorable # Mn [45] HEBREW ACCENT ETNAHTA..HEBREW POINT METEG 05BF ; Case_Ignorable # Mn HEBREW POINT RAFE 05C1..05C2 ; Case_Ignorable # Mn [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT 05C4..05C5 ; Case_Ignorable # Mn [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT -05C7 ; Case_Ignorable # Mn HEBREW POINT QAMATS QATAN +05C7..05C9 ; Case_Ignorable # Mn [3] HEBREW POINT QAMATS QATAN..HEBREW POINT DAGESH HAZAQ MUDGASH 05F4 ; Case_Ignorable # Po HEBREW PUNCTUATION GERSHAYIM 0600..0605 ; Case_Ignorable # Cf [6] ARABIC NUMBER SIGN..ARABIC NUMBER MARK ABOVE 0610..061A ; Case_Ignorable # Mn [11] ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM..ARABIC SMALL KASRA @@ -3133,7 +3198,7 @@ FF41..FF5A ; Cased # L& [26] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH LATIN 0B3F ; Case_Ignorable # Mn ORIYA VOWEL SIGN I 0B41..0B44 ; Case_Ignorable # Mn [4] ORIYA VOWEL SIGN U..ORIYA VOWEL SIGN VOCALIC RR 0B4D ; Case_Ignorable # Mn ORIYA SIGN VIRAMA -0B55..0B56 ; Case_Ignorable # Mn [2] ORIYA SIGN OVERLINE..ORIYA AI LENGTH MARK +0B53..0B56 ; Case_Ignorable # Mn [4] ORIYA SIGN DOT ABOVE..ORIYA AI LENGTH MARK 0B62..0B63 ; Case_Ignorable # Mn [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA VOWEL SIGN VOCALIC LL 0B82 ; Case_Ignorable # Mn TAMIL SIGN ANUSVARA 0BC0 ; Case_Ignorable # Mn TAMIL VOWEL SIGN II @@ -3224,8 +3289,7 @@ FF41..FF5A ; Cased # L& [26] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH LATIN 1AA7 ; Case_Ignorable # Lm TAI THAM SIGN MAI YAMOK 1AB0..1ABD ; Case_Ignorable # Mn [14] COMBINING DOUBLED CIRCUMFLEX ACCENT..COMBINING PARENTHESES BELOW 1ABE ; Case_Ignorable # Me COMBINING PARENTHESES OVERLAY -1ABF..1ADD ; Case_Ignorable # Mn [31] COMBINING LATIN SMALL LETTER W BELOW..COMBINING DOT-AND-RING BELOW -1AE0..1AEB ; Case_Ignorable # Mn [12] COMBINING LEFT TACK ABOVE..COMBINING DOUBLE RIGHTWARDS ARROW ABOVE +1ABF..1AF0 ; Case_Ignorable # Mn [50] COMBINING LATIN SMALL LETTER W BELOW..COMBINING DOUBLE COMMA ABOVE 1B00..1B03 ; Case_Ignorable # Mn [4] BALINESE SIGN ULU RICEM..BALINESE SIGN SURANG 1B34 ; Case_Ignorable # Mn BALINESE SIGN REREKAN 1B36..1B3A ; Case_Ignorable # Mn [5] BALINESE VOWEL SIGN ULU..BALINESE VOWEL SIGN RA REPA @@ -3269,7 +3333,7 @@ FF41..FF5A ; Cased # L& [26] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH LATIN 2066..206F ; Case_Ignorable # Cf [10] LEFT-TO-RIGHT ISOLATE..NOMINAL DIGIT SHAPES 2071 ; Case_Ignorable # Lm SUPERSCRIPT LATIN SMALL LETTER I 207F ; Case_Ignorable # Lm SUPERSCRIPT LATIN SMALL LETTER N -2090..209C ; Case_Ignorable # Lm [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T +208F..209F ; Case_Ignorable # Lm [17] MODIFIER LETTER HIGH AND LOW VERTICAL LINE..LATIN SUBSCRIPT SMALL LETTER Z 20D0..20DC ; Case_Ignorable # Mn [13] COMBINING LEFT HARPOON ABOVE..COMBINING FOUR DOTS ABOVE 20DD..20E0 ; Case_Ignorable # Me [4] COMBINING ENCLOSING CIRCLE..COMBINING ENCLOSING CIRCLE BACKSLASH 20E1 ; Case_Ignorable # Mn COMBINING LEFT RIGHT ARROW ABOVE @@ -3369,7 +3433,7 @@ FFF9..FFFB ; Case_Ignorable # Cf [3] INTERLINEAR ANNOTATION ANCHOR..INTERLI 10376..1037A ; Case_Ignorable # Mn [5] COMBINING OLD PERMIC LETTER AN..COMBINING OLD PERMIC LETTER SII 10780..10785 ; Case_Ignorable # Lm [6] MODIFIER LETTER SMALL CAPITAL AA..MODIFIER LETTER SMALL B WITH HOOK 10787..107B0 ; Case_Ignorable # Lm [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK -107B2..107BA ; Case_Ignorable # Lm [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL +107B2..107BF ; Case_Ignorable # Lm [14] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL ESH WITH DOUBLE BAR 10A01..10A03 ; Case_Ignorable # Mn [3] KHAROSHTHI VOWEL SIGN I..KHAROSHTHI VOWEL SIGN VOCALIC R 10A05..10A06 ; Case_Ignorable # Mn [2] KHAROSHTHI VOWEL SIGN E..KHAROSHTHI VOWEL SIGN O 10A0C..10A0F ; Case_Ignorable # Mn [4] KHAROSHTHI VOWEL LENGTH MARK..KHAROSHTHI SIGN VISARGA @@ -3382,7 +3446,9 @@ FFF9..FFFB ; Case_Ignorable # Cf [3] INTERLINEAR ANNOTATION ANCHOR..INTERLI 10D6F ; Case_Ignorable # Lm GARAY REDUPLICATION MARK 10EAB..10EAC ; Case_Ignorable # Mn [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK 10EC5 ; Case_Ignorable # Lm ARABIC SMALL YEH BARREE WITH TWO DOTS BELOW -10EFA..10EFF ; Case_Ignorable # Mn [6] ARABIC DOUBLE VERTICAL BAR BELOW..ARABIC SMALL LOW WORD MADDA +10EC9..10ECA ; Case_Ignorable # Sk [2] ARABIC SMALL BASELINE FATHA..ARABIC SMALL BASELINE DOTLESS HEAD OF KHAH +10ECB..10ECF ; Case_Ignorable # Mn [5] ARABIC NORTHEAST POINTING ARROWHEAD ABOVE..ARABIC LARGE CIRCLE ABOVE +10EF0..10EFF ; Case_Ignorable # Mn [16] ARABIC SMALL LOW UPRIGHT RECTANGULAR ZERO..ARABIC SMALL LOW WORD MADDA 10F46..10F50 ; Case_Ignorable # Mn [11] SOGDIAN COMBINING DOT BELOW..SOGDIAN COMBINING STROKE BELOW 10F82..10F85 ; Case_Ignorable # Mn [4] OLD UYGHUR COMBINING DOT ABOVE..OLD UYGHUR COMBINING TWO DOTS BELOW 11001 ; Case_Ignorable # Mn BRAHMI SIGN ANUSVARA @@ -3478,6 +3544,7 @@ FFF9..FFFB ; Case_Ignorable # Cf [3] INTERLINEAR ANNOTATION ANCHOR..INTERLI 11D95 ; Case_Ignorable # Mn GUNJALA GONDI SIGN ANUSVARA 11D97 ; Case_Ignorable # Mn GUNJALA GONDI VIRAMA 11DD9 ; Case_Ignorable # Lm TOLONG SIKI SIGN SELA +11DF0 ; Case_Ignorable # Mn BENGALI SIGN COMBINING ANUSVARA ABOVE 11EF3..11EF4 ; Case_Ignorable # Mn [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U 11F00..11F01 ; Case_Ignorable # Mn [2] KAWI SIGN CANDRABINDU..KAWI SIGN ANUSVARA 11F36..11F3A ; Case_Ignorable # Mn [5] KAWI VOWEL SIGN I..KAWI VOWEL SIGN VOCALIC R @@ -3508,18 +3575,21 @@ FFF9..FFFB ; Case_Ignorable # Cf [3] INTERLINEAR ANNOTATION ANCHOR..INTERLI 1BCA0..1BCA3 ; Case_Ignorable # Cf [4] SHORTHAND FORMAT LETTER OVERLAP..SHORTHAND FORMAT UP STEP 1CF00..1CF2D ; Case_Ignorable # Mn [46] ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON LEFT..ZNAMENNY COMBINING MARK KRYZH ON LEFT 1CF30..1CF46 ; Case_Ignorable # Mn [23] ZNAMENNY COMBINING TONAL RANGE MARK MRACHNO..ZNAMENNY PRIZNAK MODIFIER ROG +1D127..1D128 ; Case_Ignorable # Mn [2] MUSICAL SYMBOL COMBINING STRESS..MUSICAL SYMBOL COMBINING UNSTRESS 1D167..1D169 ; Case_Ignorable # Mn [3] MUSICAL SYMBOL COMBINING TREMOLO-1..MUSICAL SYMBOL COMBINING TREMOLO-3 1D173..1D17A ; Case_Ignorable # Cf [8] MUSICAL SYMBOL BEGIN BEAM..MUSICAL SYMBOL END PHRASE 1D17B..1D182 ; Case_Ignorable # Mn [8] MUSICAL SYMBOL COMBINING ACCENT..MUSICAL SYMBOL COMBINING LOURE 1D185..1D18B ; Case_Ignorable # Mn [7] MUSICAL SYMBOL COMBINING DOIT..MUSICAL SYMBOL COMBINING TRIPLE TONGUE 1D1AA..1D1AD ; Case_Ignorable # Mn [4] MUSICAL SYMBOL COMBINING DOWN BOW..MUSICAL SYMBOL COMBINING SNAP PIZZICATO 1D242..1D244 ; Case_Ignorable # Mn [3] COMBINING GREEK MUSICAL TRISEME..COMBINING GREEK MUSICAL PENTASEME +1D25B..1D25C ; Case_Ignorable # Mn [2] MUSICAL SYMBOL COMBINING TREMOLO-4..MUSICAL SYMBOL COMBINING TREMOLO-5 1DA00..1DA36 ; Case_Ignorable # Mn [55] SIGNWRITING HEAD RIM..SIGNWRITING AIR SUCKING IN 1DA3B..1DA6C ; Case_Ignorable # Mn [50] SIGNWRITING MOUTH CLOSED NEUTRAL..SIGNWRITING EXCITEMENT 1DA75 ; Case_Ignorable # Mn SIGNWRITING UPPER BODY TILTING FROM HIP JOINTS 1DA84 ; Case_Ignorable # Mn SIGNWRITING LOCATION HEAD NECK 1DA9B..1DA9F ; Case_Ignorable # Mn [5] SIGNWRITING FILL MODIFIER-2..SIGNWRITING FILL MODIFIER-6 1DAA1..1DAAF ; Case_Ignorable # Mn [15] SIGNWRITING ROTATION MODIFIER-2..SIGNWRITING ROTATION MODIFIER-16 +1DFCD..1DFFF ; Case_Ignorable # Lm [51] MODIFIER LETTER SMALL TURNED R WITH MID-HEIGHT LEFT HOOK..MODIFIER LETTER SMALL T WITH HOOK AND RETROFLEX HOOK 1E000..1E006 ; Case_Ignorable # Mn [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE 1E008..1E018 ; Case_Ignorable # Mn [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU 1E01B..1E021 ; Case_Ignorable # Mn [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI @@ -3547,7 +3617,7 @@ E0001 ; Case_Ignorable # Cf LANGUAGE TAG E0020..E007F ; Case_Ignorable # Cf [96] TAG SPACE..CANCEL TAG E0100..E01EF ; Case_Ignorable # Mn [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256 -# Total code points: 2794 +# Total code points: 2890 # ================================================ @@ -4160,8 +4230,10 @@ A7D4 ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER DOUBLE W A7D6 ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER MIDDLE SCOTS S A7D8 ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER SIGMOID S A7DA ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER LAMBDA -A7DC ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER LAMBDA WITH STROKE +A7DC..A7DD ; Changes_When_Lowercased # L& [2] LATIN CAPITAL LETTER LAMBDA WITH STROKE..LATIN CAPITAL LETTER CLOSED OMEGA +A7E2 ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER R WITH LONG LEG A7F5 ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER REVERSED HALF H +AB6C..AB6D ; Changes_When_Lowercased # L& [2] LATIN CAPITAL LETTER SCRIPT R..LATIN CAPITAL LETTER SCRIPT R WITH RING FF21..FF3A ; Changes_When_Lowercased # L& [26] FULLWIDTH LATIN CAPITAL LETTER A..FULLWIDTH LATIN CAPITAL LETTER Z 10400..10427 ; Changes_When_Lowercased # L& [40] DESERET CAPITAL LETTER LONG I..DESERET CAPITAL LETTER EW 104B0..104D3 ; Changes_When_Lowercased # L& [36] OSAGE CAPITAL LETTER A..OSAGE CAPITAL LETTER ZHA @@ -4174,9 +4246,25 @@ FF21..FF3A ; Changes_When_Lowercased # L& [26] FULLWIDTH LATIN CAPITAL LETTE 118A0..118BF ; Changes_When_Lowercased # L& [32] WARANG CITI CAPITAL LETTER NGAA..WARANG CITI CAPITAL LETTER VIYO 16E40..16E5F ; Changes_When_Lowercased # L& [32] MEDEFAIDRIN CAPITAL LETTER M..MEDEFAIDRIN CAPITAL LETTER Y 16EA0..16EB8 ; Changes_When_Lowercased # L& [25] BERIA ERFE CAPITAL LETTER ARKAB..BERIA ERFE CAPITAL LETTER AY +1DF40 ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER BARRED A +1DF48 ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER BARRED K +1DF4A ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER BARRED M +1DF4D ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER BARRED N +1DF51 ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER BARRED V +1DF68 ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER PHONOTYPIC A WITH SWASH +1DF6A ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER PHONOTYPIC ROUNDTOP A +1DF6C ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER REVERSED SCRUPLE +1DF6E ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER PHONOTYPIC DIPHTHONG AI +1DF72 ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER O WITH CURL +1DF74 ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER CLOSED OMEGA WITH LONG STEM +1DF76 ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER TURNED CLOSED OMEGA +1DF78 ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER PHONOTYPIC TH +1DF7A ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER U WITH HOOK TAIL +1DF7C ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER U WITH NOTCH AT BOTTOM +1DF7E ; Changes_When_Lowercased # L& LATIN CAPITAL LETTER REVERSED U 1E900..1E921 ; Changes_When_Lowercased # L& [34] ADLAM CAPITAL LETTER ALIF..ADLAM CAPITAL LETTER SHA -# Total code points: 1488 +# Total code points: 1508 # ================================================ @@ -4339,7 +4427,8 @@ FF21..FF3A ; Changes_When_Lowercased # L& [26] FULLWIDTH LATIN CAPITAL LETTE 026F ; Changes_When_Uppercased # L& LATIN SMALL LETTER TURNED M 0271..0272 ; Changes_When_Uppercased # L& [2] LATIN SMALL LETTER M WITH HOOK..LATIN SMALL LETTER N WITH LEFT HOOK 0275 ; Changes_When_Uppercased # L& LATIN SMALL LETTER BARRED O -027D ; Changes_When_Uppercased # L& LATIN SMALL LETTER R WITH TAIL +0277 ; Changes_When_Uppercased # L& LATIN SMALL LETTER CLOSED OMEGA +027C..027D ; Changes_When_Uppercased # L& [2] LATIN SMALL LETTER R WITH LONG LEG..LATIN SMALL LETTER R WITH TAIL 0280 ; Changes_When_Uppercased # L& LATIN LETTER SMALL CAPITAL R 0282..0283 ; Changes_When_Uppercased # L& [2] LATIN SMALL LETTER S WITH HOOK..LATIN SMALL LETTER ESH 0287..028C ; Changes_When_Uppercased # L& [6] LATIN SMALL LETTER TURNED T..LATIN SMALL LETTER TURNED V @@ -4803,6 +4892,7 @@ A7D7 ; Changes_When_Uppercased # L& LATIN SMALL LETTER MIDDLE SCO A7D9 ; Changes_When_Uppercased # L& LATIN SMALL LETTER SIGMOID S A7DB ; Changes_When_Uppercased # L& LATIN SMALL LETTER LAMBDA A7F6 ; Changes_When_Uppercased # L& LATIN SMALL LETTER REVERSED HALF H +AB4B..AB4C ; Changes_When_Uppercased # L& [2] LATIN SMALL LETTER SCRIPT R..LATIN SMALL LETTER SCRIPT R WITH RING AB53 ; Changes_When_Uppercased # L& LATIN SMALL LETTER CHI AB70..ABBF ; Changes_When_Uppercased # L& [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA FB00..FB06 ; Changes_When_Uppercased # L& [7] LATIN SMALL LIGATURE FF..LATIN SMALL LIGATURE ST @@ -4819,9 +4909,26 @@ FF41..FF5A ; Changes_When_Uppercased # L& [26] FULLWIDTH LATIN SMALL LETTER 118C0..118DF ; Changes_When_Uppercased # L& [32] WARANG CITI SMALL LETTER NGAA..WARANG CITI SMALL LETTER VIYO 16E60..16E7F ; Changes_When_Uppercased # L& [32] MEDEFAIDRIN SMALL LETTER M..MEDEFAIDRIN SMALL LETTER Y 16EBB..16ED3 ; Changes_When_Uppercased # L& [25] BERIA ERFE SMALL LETTER ARKAB..BERIA ERFE SMALL LETTER AY +1DF41 ; Changes_When_Uppercased # L& LATIN SMALL LETTER BARRED A +1DF49 ; Changes_When_Uppercased # L& LATIN SMALL LETTER BARRED K +1DF4B ; Changes_When_Uppercased # L& LATIN SMALL LETTER BARRED M +1DF4E ; Changes_When_Uppercased # L& LATIN SMALL LETTER BARRED N +1DF52 ; Changes_When_Uppercased # L& LATIN SMALL LETTER BARRED V +1DF69 ; Changes_When_Uppercased # L& LATIN SMALL LETTER PHONOTYPIC A WITH SWASH +1DF6B ; Changes_When_Uppercased # L& LATIN SMALL LETTER PHONOTYPIC ROUNDTOP A +1DF6D ; Changes_When_Uppercased # L& LATIN SMALL LETTER REVERSED SCRUPLE +1DF6F ; Changes_When_Uppercased # L& LATIN SMALL LETTER PHONOTYPIC DIPHTHONG AI +1DF73 ; Changes_When_Uppercased # L& LATIN SMALL LETTER O WITH CURL +1DF75 ; Changes_When_Uppercased # L& LATIN SMALL LETTER CLOSED OMEGA WITH LONG STEM +1DF77 ; Changes_When_Uppercased # L& LATIN SMALL LETTER TURNED CLOSED OMEGA +1DF79 ; Changes_When_Uppercased # L& LATIN SMALL LETTER PHONOTYPIC TH +1DF7B ; Changes_When_Uppercased # L& LATIN SMALL LETTER U WITH HOOK TAIL +1DF7D ; Changes_When_Uppercased # L& LATIN SMALL LETTER U WITH NOTCH AT BOTTOM +1DF7F ; Changes_When_Uppercased # L& LATIN SMALL LETTER REVERSED U +1DF95 ; Changes_When_Uppercased # L& LATIN SMALL LIGATURE LONG S WITH DESCENDER S 1E922..1E943 ; Changes_When_Uppercased # L& [34] ADLAM SMALL LETTER ALIF..ADLAM SMALL LETTER SHA -# Total code points: 1580 +# Total code points: 1601 # ================================================ @@ -4985,7 +5092,8 @@ FF41..FF5A ; Changes_When_Uppercased # L& [26] FULLWIDTH LATIN SMALL LETTER 026F ; Changes_When_Titlecased # L& LATIN SMALL LETTER TURNED M 0271..0272 ; Changes_When_Titlecased # L& [2] LATIN SMALL LETTER M WITH HOOK..LATIN SMALL LETTER N WITH LEFT HOOK 0275 ; Changes_When_Titlecased # L& LATIN SMALL LETTER BARRED O -027D ; Changes_When_Titlecased # L& LATIN SMALL LETTER R WITH TAIL +0277 ; Changes_When_Titlecased # L& LATIN SMALL LETTER CLOSED OMEGA +027C..027D ; Changes_When_Titlecased # L& [2] LATIN SMALL LETTER R WITH LONG LEG..LATIN SMALL LETTER R WITH TAIL 0280 ; Changes_When_Titlecased # L& LATIN LETTER SMALL CAPITAL R 0282..0283 ; Changes_When_Titlecased # L& [2] LATIN SMALL LETTER S WITH HOOK..LATIN SMALL LETTER ESH 0287..028C ; Changes_When_Titlecased # L& [6] LATIN SMALL LETTER TURNED T..LATIN SMALL LETTER TURNED V @@ -5447,6 +5555,7 @@ A7D7 ; Changes_When_Titlecased # L& LATIN SMALL LETTER MIDDLE SCO A7D9 ; Changes_When_Titlecased # L& LATIN SMALL LETTER SIGMOID S A7DB ; Changes_When_Titlecased # L& LATIN SMALL LETTER LAMBDA A7F6 ; Changes_When_Titlecased # L& LATIN SMALL LETTER REVERSED HALF H +AB4B..AB4C ; Changes_When_Titlecased # L& [2] LATIN SMALL LETTER SCRIPT R..LATIN SMALL LETTER SCRIPT R WITH RING AB53 ; Changes_When_Titlecased # L& LATIN SMALL LETTER CHI AB70..ABBF ; Changes_When_Titlecased # L& [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA FB00..FB06 ; Changes_When_Titlecased # L& [7] LATIN SMALL LIGATURE FF..LATIN SMALL LIGATURE ST @@ -5463,9 +5572,26 @@ FF41..FF5A ; Changes_When_Titlecased # L& [26] FULLWIDTH LATIN SMALL LETTER 118C0..118DF ; Changes_When_Titlecased # L& [32] WARANG CITI SMALL LETTER NGAA..WARANG CITI SMALL LETTER VIYO 16E60..16E7F ; Changes_When_Titlecased # L& [32] MEDEFAIDRIN SMALL LETTER M..MEDEFAIDRIN SMALL LETTER Y 16EBB..16ED3 ; Changes_When_Titlecased # L& [25] BERIA ERFE SMALL LETTER ARKAB..BERIA ERFE SMALL LETTER AY +1DF41 ; Changes_When_Titlecased # L& LATIN SMALL LETTER BARRED A +1DF49 ; Changes_When_Titlecased # L& LATIN SMALL LETTER BARRED K +1DF4B ; Changes_When_Titlecased # L& LATIN SMALL LETTER BARRED M +1DF4E ; Changes_When_Titlecased # L& LATIN SMALL LETTER BARRED N +1DF52 ; Changes_When_Titlecased # L& LATIN SMALL LETTER BARRED V +1DF69 ; Changes_When_Titlecased # L& LATIN SMALL LETTER PHONOTYPIC A WITH SWASH +1DF6B ; Changes_When_Titlecased # L& LATIN SMALL LETTER PHONOTYPIC ROUNDTOP A +1DF6D ; Changes_When_Titlecased # L& LATIN SMALL LETTER REVERSED SCRUPLE +1DF6F ; Changes_When_Titlecased # L& LATIN SMALL LETTER PHONOTYPIC DIPHTHONG AI +1DF73 ; Changes_When_Titlecased # L& LATIN SMALL LETTER O WITH CURL +1DF75 ; Changes_When_Titlecased # L& LATIN SMALL LETTER CLOSED OMEGA WITH LONG STEM +1DF77 ; Changes_When_Titlecased # L& LATIN SMALL LETTER TURNED CLOSED OMEGA +1DF79 ; Changes_When_Titlecased # L& LATIN SMALL LETTER PHONOTYPIC TH +1DF7B ; Changes_When_Titlecased # L& LATIN SMALL LETTER U WITH HOOK TAIL +1DF7D ; Changes_When_Titlecased # L& LATIN SMALL LETTER U WITH NOTCH AT BOTTOM +1DF7F ; Changes_When_Titlecased # L& LATIN SMALL LETTER REVERSED U +1DF95 ; Changes_When_Titlecased # L& LATIN SMALL LIGATURE LONG S WITH DESCENDER S 1E922..1E943 ; Changes_When_Titlecased # L& [34] ADLAM SMALL LETTER ALIF..ADLAM SMALL LETTER SHA -# Total code points: 1507 +# Total code points: 1528 # ================================================ @@ -6087,8 +6213,10 @@ A7D4 ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER DOUBLE W A7D6 ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER MIDDLE SCOTS S A7D8 ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER SIGMOID S A7DA ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER LAMBDA -A7DC ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER LAMBDA WITH STROKE +A7DC..A7DD ; Changes_When_Casefolded # L& [2] LATIN CAPITAL LETTER LAMBDA WITH STROKE..LATIN CAPITAL LETTER CLOSED OMEGA +A7E2 ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER R WITH LONG LEG A7F5 ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER REVERSED HALF H +AB6C..AB6D ; Changes_When_Casefolded # L& [2] LATIN CAPITAL LETTER SCRIPT R..LATIN CAPITAL LETTER SCRIPT R WITH RING AB70..ABBF ; Changes_When_Casefolded # L& [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA FB00..FB06 ; Changes_When_Casefolded # L& [7] LATIN SMALL LIGATURE FF..LATIN SMALL LIGATURE ST FB13..FB17 ; Changes_When_Casefolded # L& [5] ARMENIAN SMALL LIGATURE MEN NOW..ARMENIAN SMALL LIGATURE MEN XEH @@ -6104,9 +6232,26 @@ FF21..FF3A ; Changes_When_Casefolded # L& [26] FULLWIDTH LATIN CAPITAL LETTE 118A0..118BF ; Changes_When_Casefolded # L& [32] WARANG CITI CAPITAL LETTER NGAA..WARANG CITI CAPITAL LETTER VIYO 16E40..16E5F ; Changes_When_Casefolded # L& [32] MEDEFAIDRIN CAPITAL LETTER M..MEDEFAIDRIN CAPITAL LETTER Y 16EA0..16EB8 ; Changes_When_Casefolded # L& [25] BERIA ERFE CAPITAL LETTER ARKAB..BERIA ERFE CAPITAL LETTER AY +1DF40 ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER BARRED A +1DF48 ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER BARRED K +1DF4A ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER BARRED M +1DF4D ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER BARRED N +1DF51 ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER BARRED V +1DF68 ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER PHONOTYPIC A WITH SWASH +1DF6A ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER PHONOTYPIC ROUNDTOP A +1DF6C ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER REVERSED SCRUPLE +1DF6E ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER PHONOTYPIC DIPHTHONG AI +1DF72 ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER O WITH CURL +1DF74 ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER CLOSED OMEGA WITH LONG STEM +1DF76 ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER TURNED CLOSED OMEGA +1DF78 ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER PHONOTYPIC TH +1DF7A ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER U WITH HOOK TAIL +1DF7C ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER U WITH NOTCH AT BOTTOM +1DF7E ; Changes_When_Casefolded # L& LATIN CAPITAL LETTER REVERSED U +1DF95 ; Changes_When_Casefolded # L& LATIN SMALL LIGATURE LONG S WITH DESCENDER S 1E900..1E921 ; Changes_When_Casefolded # L& [34] ADLAM CAPITAL LETTER ALIF..ADLAM CAPITAL LETTER SHA -# Total code points: 1561 +# Total code points: 1582 # ================================================ @@ -6139,7 +6284,8 @@ FF21..FF3A ; Changes_When_Casefolded # L& [26] FULLWIDTH LATIN CAPITAL LETTE 026F ; Changes_When_Casemapped # L& LATIN SMALL LETTER TURNED M 0271..0272 ; Changes_When_Casemapped # L& [2] LATIN SMALL LETTER M WITH HOOK..LATIN SMALL LETTER N WITH LEFT HOOK 0275 ; Changes_When_Casemapped # L& LATIN SMALL LETTER BARRED O -027D ; Changes_When_Casemapped # L& LATIN SMALL LETTER R WITH TAIL +0277 ; Changes_When_Casemapped # L& LATIN SMALL LETTER CLOSED OMEGA +027C..027D ; Changes_When_Casemapped # L& [2] LATIN SMALL LETTER R WITH LONG LEG..LATIN SMALL LETTER R WITH TAIL 0280 ; Changes_When_Casemapped # L& LATIN LETTER SMALL CAPITAL R 0282..0283 ; Changes_When_Casemapped # L& [2] LATIN SMALL LETTER S WITH HOOK..LATIN SMALL LETTER ESH 0287..028C ; Changes_When_Casemapped # L& [6] LATIN SMALL LETTER TURNED T..LATIN SMALL LETTER TURNED V @@ -6219,9 +6365,12 @@ A779..A787 ; Changes_When_Casemapped # L& [15] LATIN CAPITAL LETTER INSULAR A78B..A78D ; Changes_When_Casemapped # L& [3] LATIN CAPITAL LETTER SALTILLO..LATIN CAPITAL LETTER TURNED H A790..A794 ; Changes_When_Casemapped # L& [5] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN SMALL LETTER C WITH PALATAL HOOK A796..A7AE ; Changes_When_Casemapped # L& [25] LATIN CAPITAL LETTER B WITH FLOURISH..LATIN CAPITAL LETTER SMALL CAPITAL I -A7B0..A7DC ; Changes_When_Casemapped # L& [45] LATIN CAPITAL LETTER TURNED K..LATIN CAPITAL LETTER LAMBDA WITH STROKE +A7B0..A7DD ; Changes_When_Casemapped # L& [46] LATIN CAPITAL LETTER TURNED K..LATIN CAPITAL LETTER CLOSED OMEGA +A7E2 ; Changes_When_Casemapped # L& LATIN CAPITAL LETTER R WITH LONG LEG A7F5..A7F6 ; Changes_When_Casemapped # L& [2] LATIN CAPITAL LETTER REVERSED HALF H..LATIN SMALL LETTER REVERSED HALF H +AB4B..AB4C ; Changes_When_Casemapped # L& [2] LATIN SMALL LETTER SCRIPT R..LATIN SMALL LETTER SCRIPT R WITH RING AB53 ; Changes_When_Casemapped # L& LATIN SMALL LETTER CHI +AB6C..AB6D ; Changes_When_Casemapped # L& [2] LATIN CAPITAL LETTER SCRIPT R..LATIN CAPITAL LETTER SCRIPT R WITH RING AB70..ABBF ; Changes_When_Casemapped # L& [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA FB00..FB06 ; Changes_When_Casemapped # L& [7] LATIN SMALL LIGATURE FF..LATIN SMALL LIGATURE ST FB13..FB17 ; Changes_When_Casemapped # L& [5] ARMENIAN SMALL LIGATURE MEN NOW..ARMENIAN SMALL LIGATURE MEN XEH @@ -6246,9 +6395,16 @@ FF41..FF5A ; Changes_When_Casemapped # L& [26] FULLWIDTH LATIN SMALL LETTER 16E40..16E7F ; Changes_When_Casemapped # L& [64] MEDEFAIDRIN CAPITAL LETTER M..MEDEFAIDRIN SMALL LETTER Y 16EA0..16EB8 ; Changes_When_Casemapped # L& [25] BERIA ERFE CAPITAL LETTER ARKAB..BERIA ERFE CAPITAL LETTER AY 16EBB..16ED3 ; Changes_When_Casemapped # L& [25] BERIA ERFE SMALL LETTER ARKAB..BERIA ERFE SMALL LETTER AY +1DF40..1DF41 ; Changes_When_Casemapped # L& [2] LATIN CAPITAL LETTER BARRED A..LATIN SMALL LETTER BARRED A +1DF48..1DF4B ; Changes_When_Casemapped # L& [4] LATIN CAPITAL LETTER BARRED K..LATIN SMALL LETTER BARRED M +1DF4D..1DF4E ; Changes_When_Casemapped # L& [2] LATIN CAPITAL LETTER BARRED N..LATIN SMALL LETTER BARRED N +1DF51..1DF52 ; Changes_When_Casemapped # L& [2] LATIN CAPITAL LETTER BARRED V..LATIN SMALL LETTER BARRED V +1DF68..1DF6F ; Changes_When_Casemapped # L& [8] LATIN CAPITAL LETTER PHONOTYPIC A WITH SWASH..LATIN SMALL LETTER PHONOTYPIC DIPHTHONG AI +1DF72..1DF7F ; Changes_When_Casemapped # L& [14] LATIN CAPITAL LETTER O WITH CURL..LATIN SMALL LETTER REVERSED U +1DF95 ; Changes_When_Casemapped # L& LATIN SMALL LIGATURE LONG S WITH DESCENDER S 1E900..1E943 ; Changes_When_Casemapped # L& [68] ADLAM CAPITAL LETTER ALIF..ADLAM SMALL LETTER SHA -# Total code points: 3037 +# Total code points: 3078 # ================================================ @@ -6294,8 +6450,9 @@ FF41..FF5A ; Changes_When_Casemapped # L& [26] FULLWIDTH LATIN SMALL LETTER 03F7..0481 ; ID_Start # L& [139] GREEK CAPITAL LETTER SHO..CYRILLIC SMALL LETTER KOPPA 048A..052F ; ID_Start # L& [166] CYRILLIC CAPITAL LETTER SHORT I WITH TAIL..CYRILLIC SMALL LETTER EL WITH DESCENDER 0531..0556 ; ID_Start # L& [38] ARMENIAN CAPITAL LETTER AYB..ARMENIAN CAPITAL LETTER FEH -0559 ; ID_Start # Lm ARMENIAN MODIFIER LETTER LEFT HALF RING +0558..0559 ; ID_Start # Lm [2] MODIFIER LETTER ARMENIAN SMALL EH..ARMENIAN MODIFIER LETTER LEFT HALF RING 0560..0588 ; ID_Start # L& [41] ARMENIAN SMALL LETTER TURNED AYB..ARMENIAN SMALL LETTER YI WITH STROKE +058B..058C ; ID_Start # Lm [2] MODIFIER LETTER ARMENIAN SMALL INI..MODIFIER LETTER ARMENIAN SMALL YI 05D0..05EA ; ID_Start # Lo [27] HEBREW LETTER ALEF..HEBREW LETTER TAV 05EF..05F2 ; ID_Start # Lo [4] HEBREW YOD TRIANGLE..HEBREW LIGATURE YIDDISH DOUBLE YOD 0620..063F ; ID_Start # Lo [32] ARABIC LETTER KASHMIRI YEH..ARABIC LETTER FARSI YEH WITH THREE DOTS ABOVE @@ -6541,7 +6698,7 @@ FF41..FF5A ; Changes_When_Casemapped # L& [26] FULLWIDTH LATIN SMALL LETTER 1FF6..1FFC ; ID_Start # L& [7] GREEK SMALL LETTER OMEGA WITH PERISPOMENI..GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI 2071 ; ID_Start # Lm SUPERSCRIPT LATIN SMALL LETTER I 207F ; ID_Start # Lm SUPERSCRIPT LATIN SMALL LETTER N -2090..209C ; ID_Start # Lm [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T +208F..209F ; ID_Start # Lm [17] MODIFIER LETTER HIGH AND LOW VERTICAL LINE..LATIN SUBSCRIPT SMALL LETTER Z 2102 ; ID_Start # L& DOUBLE-STRUCK CAPITAL C 2107 ; ID_Start # L& EULER CONSTANT 210A..2113 ; ID_Start # L& [10] SCRIPT SMALL G..SCRIPT SMALL L @@ -6624,7 +6781,8 @@ A771..A787 ; ID_Start # L& [23] LATIN SMALL LETTER DUM..LATIN SMALL LETTER I A788 ; ID_Start # Lm MODIFIER LETTER LOW CIRCUMFLEX ACCENT A78B..A78E ; ID_Start # L& [4] LATIN CAPITAL LETTER SALTILLO..LATIN SMALL LETTER L WITH RETROFLEX HOOK AND BELT A78F ; ID_Start # Lo LATIN LETTER SINOLOGICAL DOT -A790..A7DC ; ID_Start # L& [77] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN CAPITAL LETTER LAMBDA WITH STROKE +A790..A7DD ; ID_Start # L& [78] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN CAPITAL LETTER CLOSED OMEGA +A7E2 ; ID_Start # L& LATIN CAPITAL LETTER R WITH LONG LEG A7F1..A7F4 ; ID_Start # Lm [4] MODIFIER LETTER CAPITAL S..MODIFIER LETTER CAPITAL Q A7F5..A7F6 ; ID_Start # L& [2] LATIN CAPITAL LETTER REVERSED HALF H..LATIN SMALL LETTER REVERSED HALF H A7F7 ; ID_Start # Lo LATIN EPIGRAPHIC LETTER SIDEWAYS I @@ -6675,6 +6833,7 @@ AB30..AB5A ; ID_Start # L& [43] LATIN SMALL LETTER BARRED ALPHA..LATIN SMALL AB5C..AB5F ; ID_Start # Lm [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK AB60..AB68 ; ID_Start # L& [9] LATIN SMALL LETTER SAKHA YAT..LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE AB69 ; ID_Start # Lm MODIFIER LETTER SMALL TURNED W +AB6C..AB6D ; ID_Start # L& [2] LATIN CAPITAL LETTER SCRIPT R..LATIN CAPITAL LETTER SCRIPT R WITH RING AB70..ABBF ; ID_Start # L& [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA ABC0..ABE2 ; ID_Start # Lo [35] MEETEI MAYEK LETTER KOK..MEETEI MAYEK LETTER I LONSUM AC00..D7A3 ; ID_Start # Lo [11172] HANGUL SYLLABLE GA..HANGUL SYLLABLE HIH @@ -6749,7 +6908,7 @@ FFDA..FFDC ; ID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL 10760..10767 ; ID_Start # Lo [8] LINEAR A SIGN A800..LINEAR A SIGN A807 10780..10785 ; ID_Start # Lm [6] MODIFIER LETTER SMALL CAPITAL AA..MODIFIER LETTER SMALL B WITH HOOK 10787..107B0 ; ID_Start # Lm [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK -107B2..107BA ; ID_Start # Lm [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL +107B2..107BF ; ID_Start # Lm [14] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL ESH WITH DOUBLE BAR 10800..10805 ; ID_Start # Lo [6] CYPRIOT SYLLABLE A..CYPRIOT SYLLABLE JA 10808 ; ID_Start # Lo CYPRIOT SYLLABLE JO 1080A..10835 ; ID_Start # Lo [44] CYPRIOT SYLLABLE KA..CYPRIOT SYLLABLE WO @@ -6792,6 +6951,7 @@ FFDA..FFDC ; ID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL 10EC2..10EC4 ; ID_Start # Lo [3] ARABIC LETTER DAL WITH TWO DOTS VERTICALLY BELOW..ARABIC LETTER KAF WITH TWO DOTS VERTICALLY BELOW 10EC5 ; ID_Start # Lm ARABIC SMALL YEH BARREE WITH TWO DOTS BELOW 10EC6..10EC7 ; ID_Start # Lo [2] ARABIC LETTER THIN NOON..ARABIC LETTER YEH WITH FOUR DOTS BELOW +10ED9..10EEE ; ID_Start # Lo [22] ARABIC CROWN LETTER BEH..ARABIC CROWN LETTER YEH 10F00..10F1C ; ID_Start # Lo [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL 10F27 ; ID_Start # Lo OLD SOGDIAN LIGATURE AYIN-DALETH 10F30..10F45 ; ID_Start # Lo [22] SOGDIAN LETTER ALEPH..SOGDIAN INDEPENDENT SHIN @@ -6871,6 +7031,7 @@ FFDA..FFDC ; ID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL 11A5C..11A89 ; ID_Start # Lo [46] SOYOMBO LETTER KA..SOYOMBO CLUSTER-INITIAL LETTER SA 11A9D ; ID_Start # Lo SOYOMBO MARK PLUTA 11AB0..11AF8 ; ID_Start # Lo [73] CANADIAN SYLLABICS NATTILIK HI..PAU CIN HAU GLOTTAL STOP FINAL +11B0A ; ID_Start # Lo DEVANAGARI LETTER ALTERNATE DDDA 11BC0..11BE0 ; ID_Start # Lo [33] SUNUWAR LETTER DEVI..SUNUWAR LETTER KLOKO 11C00..11C08 ; ID_Start # Lo [9] BHAIKSUKI LETTER A..BHAIKSUKI LETTER VOCALIC L 11C0A..11C2E ; ID_Start # Lo [37] BHAIKSUKI LETTER E..BHAIKSUKI LETTER HA @@ -6887,14 +7048,17 @@ FFDA..FFDC ; ID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL 11DB0..11DD8 ; ID_Start # Lo [41] TOLONG SIKI LETTER I..TOLONG SIKI LETTER RRH 11DD9 ; ID_Start # Lm TOLONG SIKI SIGN SELA 11DDA..11DDB ; ID_Start # Lo [2] TOLONG SIKI SIGN HECAKA..TOLONG SIKI UNGGA +11DF1 ; ID_Start # Lo BENGALI LETTER ALTERNATE BARGIYA BA 11EE0..11EF2 ; ID_Start # Lo [19] MAKASAR LETTER KA..MAKASAR ANGKA 11F02 ; ID_Start # Lo KAWI SIGN REPHA 11F04..11F10 ; ID_Start # Lo [13] KAWI LETTER A..KAWI LETTER O 11F12..11F33 ; ID_Start # Lo [34] KAWI LETTER KA..KAWI LETTER JNYA 11FB0 ; ID_Start # Lo LISU LETTER YHA 12000..12399 ; ID_Start # Lo [922] CUNEIFORM SIGN A..CUNEIFORM SIGN U U -12400..1246E ; ID_Start # Nl [111] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM +12400..1246F ; ID_Start # Nl [112] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN SEVEN ASH TENU +12475..1247F ; ID_Start # Nl [11] CUNEIFORM NUMERIC SIGN EIGHT ASH TENU..CUNEIFORM NUMERIC SIGN ASH TIMES NINE DISH TENU 12480..12543 ; ID_Start # Lo [196] CUNEIFORM SIGN AB TIMES NUN TENU..CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU +12550..12686 ; ID_Start # Nl [311] CUNEIFORM NUMERIC SIGN ONE N01..CUNEIFORM NUMERIC SIGN ONE N36 FLAT 12F90..12FF0 ; ID_Start # Lo [97] CYPRO-MINOAN SIGN CM001..CYPRO-MINOAN SIGN CM114 13000..1342F ; ID_Start # Lo [1072] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH V011D 13441..13446 ; ID_Start # Lo [6] EGYPTIAN HIEROGLYPH FULL BLANK..EGYPTIAN HIEROGLYPH WIDE LOST SIGN @@ -6922,17 +7086,19 @@ FFDA..FFDC ; ID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL 16FE3 ; ID_Start # Lm OLD CHINESE ITERATION MARK 16FF2..16FF3 ; ID_Start # Lm [2] CHINESE SMALL SIMPLIFIED ER..CHINESE SMALL TRADITIONAL ER 16FF4..16FF6 ; ID_Start # Nl [3] YANGQIN SIGN SLOW ONE BEAT..YANGQIN SIGN SLOW TWO BEATS -17000..18CD5 ; ID_Start # Lo [7382] TANGUT IDEOGRAPH-17000..KHITAN SMALL SCRIPT CHARACTER-18CD5 -18CFF..18D1E ; ID_Start # Lo [32] KHITAN SMALL SCRIPT CHARACTER-18CFF..TANGUT IDEOGRAPH-18D1E +17000..18CDA ; ID_Start # Lo [7387] TANGUT IDEOGRAPH-17000..KHITAN SMALL SCRIPT CHARACTER-18CDA +18CFF..18D20 ; ID_Start # Lo [34] KHITAN SMALL SCRIPT CHARACTER-18CFF..TANGUT IDEOGRAPH-18D20 18D80..18DF2 ; ID_Start # Lo [115] TANGUT COMPONENT-769..TANGUT COMPONENT-883 +18E00..19191 ; ID_Start # Lo [914] JURCHEN CHARACTER-18E00..JURCHEN CHARACTER-19191 +191A0..191D2 ; ID_Start # Lo [51] JURCHEN RADICAL-01..JURCHEN RADICAL-51 1AFF0..1AFF3 ; ID_Start # Lm [4] KATAKANA LETTER MINNAN TONE-2..KATAKANA LETTER MINNAN TONE-5 1AFF5..1AFFB ; ID_Start # Lm [7] KATAKANA LETTER MINNAN TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-5 1AFFD..1AFFE ; ID_Start # Lm [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8 -1B000..1B122 ; ID_Start # Lo [291] KATAKANA LETTER ARCHAIC E..KATAKANA LETTER ARCHAIC WU +1B000..1B128 ; ID_Start # Lo [297] KATAKANA LETTER ARCHAIC E..KATAKANA LETTER ALTERNATE WI 1B132 ; ID_Start # Lo HIRAGANA LETTER SMALL KO 1B150..1B152 ; ID_Start # Lo [3] HIRAGANA LETTER SMALL WI..HIRAGANA LETTER SMALL WO 1B155 ; ID_Start # Lo KATAKANA LETTER SMALL KO -1B164..1B167 ; ID_Start # Lo [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N +1B164..1B168 ; ID_Start # Lo [5] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL ARCHAIC YE 1B170..1B2FB ; ID_Start # Lo [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB 1BC00..1BC6A ; ID_Start # Lo [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M 1BC70..1BC7C ; ID_Start # Lo [13] DUPLOYAN AFFIX LEFT HORIZONTAL SECANT..DUPLOYAN AFFIX ATTACHED TANGENT HOOK @@ -6956,7 +7122,7 @@ FFDA..FFDC ; ID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL 1D540..1D544 ; ID_Start # L& [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M 1D546 ; ID_Start # L& MATHEMATICAL DOUBLE-STRUCK CAPITAL O 1D54A..1D550 ; ID_Start # L& [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y -1D552..1D6A5 ; ID_Start # L& [340] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J +1D552..1D6A6 ; ID_Start # L& [341] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL LIGATURE LONG S WITH DESCENDER S 1D6A8..1D6C0 ; ID_Start # L& [25] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL BOLD CAPITAL OMEGA 1D6C2..1D6DA ; ID_Start # L& [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA 1D6DC..1D6FA ; ID_Start # L& [31] MATHEMATICAL BOLD EPSILON SYMBOL..MATHEMATICAL ITALIC CAPITAL OMEGA @@ -6970,8 +7136,10 @@ FFDA..FFDC ; ID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL 1D7C4..1D7CB ; ID_Start # L& [8] MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD SMALL DIGAMMA 1DF00..1DF09 ; ID_Start # L& [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK 1DF0A ; ID_Start # Lo LATIN LETTER RETROFLEX CLICK WITH RETROFLEX HOOK -1DF0B..1DF1E ; ID_Start # L& [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL -1DF25..1DF2A ; ID_Start # L& [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK +1DF0B..1DF7F ; ID_Start # L& [117] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER REVERSED U +1DF80..1DF81 ; ID_Start # Lo [2] LATIN CAPITAL LETTER A WITH TOPBAR..LATIN CAPITAL LETTER E WITH BENT TOPBAR +1DF90..1DF96 ; ID_Start # L& [7] LATIN SMALL LETTER C WITH LOW SLASH..LATIN SMALL LETTER LONG S WITH TOP LOOP +1DFCD..1DFFF ; ID_Start # Lm [51] MODIFIER LETTER SMALL TURNED R WITH MID-HEIGHT LEFT HOOK..MODIFIER LETTER SMALL T WITH HOOK AND RETROFLEX HOOK 1E030..1E06D ; ID_Start # Lm [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE 1E100..1E12C ; ID_Start # Lo [45] NYIAKENG PUACHUE HMONG LETTER MA..NYIAKENG PUACHUE HMONG LETTER W 1E137..1E13D ; ID_Start # Lm [7] NYIAKENG PUACHUE HMONG SIGN FOR PERSON..NYIAKENG PUACHUE HMONG SYLLABLE LENGTHENER @@ -7030,15 +7198,16 @@ FFDA..FFDC ; ID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL 1EEA5..1EEA9 ; ID_Start # Lo [5] ARABIC MATHEMATICAL DOUBLE-STRUCK WAW..ARABIC MATHEMATICAL DOUBLE-STRUCK YEH 1EEAB..1EEBB ; ID_Start # Lo [17] ARABIC MATHEMATICAL DOUBLE-STRUCK LAM..ARABIC MATHEMATICAL DOUBLE-STRUCK GHAIN 20000..2A6DF ; ID_Start # Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF -2A700..2B81D ; ID_Start # Lo [4382] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81D +2A700..2B81E ; ID_Start # Lo [4383] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81E 2B820..2CEAD ; ID_Start # Lo [5774] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEAD 2CEB0..2EBE0 ; ID_Start # Lo [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0 2EBF0..2EE5D ; ID_Start # Lo [622] CJK UNIFIED IDEOGRAPH-2EBF0..CJK UNIFIED IDEOGRAPH-2EE5D 2F800..2FA1D ; ID_Start # Lo [542] CJK COMPATIBILITY IDEOGRAPH-2F800..CJK COMPATIBILITY IDEOGRAPH-2FA1D 30000..3134A ; ID_Start # Lo [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A 31350..33479 ; ID_Start # Lo [8490] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-33479 +3D000..3FC3F ; ID_Start # Lo [11328] SMALL SEAL CHARACTER-3D000..SMALL SEAL CHARACTER-3FC3F -# Total code points: 145916 +# Total code points: 158739 # ================================================ @@ -7091,13 +7260,14 @@ FFDA..FFDC ; ID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL 0483..0487 ; ID_Continue # Mn [5] COMBINING CYRILLIC TITLO..COMBINING CYRILLIC POKRYTIE 048A..052F ; ID_Continue # L& [166] CYRILLIC CAPITAL LETTER SHORT I WITH TAIL..CYRILLIC SMALL LETTER EL WITH DESCENDER 0531..0556 ; ID_Continue # L& [38] ARMENIAN CAPITAL LETTER AYB..ARMENIAN CAPITAL LETTER FEH -0559 ; ID_Continue # Lm ARMENIAN MODIFIER LETTER LEFT HALF RING +0558..0559 ; ID_Continue # Lm [2] MODIFIER LETTER ARMENIAN SMALL EH..ARMENIAN MODIFIER LETTER LEFT HALF RING 0560..0588 ; ID_Continue # L& [41] ARMENIAN SMALL LETTER TURNED AYB..ARMENIAN SMALL LETTER YI WITH STROKE +058B..058C ; ID_Continue # Lm [2] MODIFIER LETTER ARMENIAN SMALL INI..MODIFIER LETTER ARMENIAN SMALL YI 0591..05BD ; ID_Continue # Mn [45] HEBREW ACCENT ETNAHTA..HEBREW POINT METEG 05BF ; ID_Continue # Mn HEBREW POINT RAFE 05C1..05C2 ; ID_Continue # Mn [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT 05C4..05C5 ; ID_Continue # Mn [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT -05C7 ; ID_Continue # Mn HEBREW POINT QAMATS QATAN +05C7..05C9 ; ID_Continue # Mn [3] HEBREW POINT QAMATS QATAN..HEBREW POINT DAGESH HAZAQ MUDGASH 05D0..05EA ; ID_Continue # Lo [27] HEBREW LETTER ALEF..HEBREW LETTER TAV 05EF..05F2 ; ID_Continue # Lo [4] HEBREW YOD TRIANGLE..HEBREW LIGATURE YIDDISH DOUBLE YOD 0610..061A ; ID_Continue # Mn [11] ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM..ARABIC SMALL KASRA @@ -7252,7 +7422,7 @@ FFDA..FFDC ; ID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL 0B47..0B48 ; ID_Continue # Mc [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SIGN AI 0B4B..0B4C ; ID_Continue # Mc [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SIGN AU 0B4D ; ID_Continue # Mn ORIYA SIGN VIRAMA -0B55..0B56 ; ID_Continue # Mn [2] ORIYA SIGN OVERLINE..ORIYA AI LENGTH MARK +0B53..0B56 ; ID_Continue # Mn [4] ORIYA SIGN DOT ABOVE..ORIYA AI LENGTH MARK 0B57 ; ID_Continue # Mc ORIYA AU LENGTH MARK 0B5C..0B5D ; ID_Continue # Lo [2] ORIYA LETTER RRA..ORIYA LETTER RHA 0B5F..0B61 ; ID_Continue # Lo [3] ORIYA LETTER YYA..ORIYA LETTER VOCALIC LL @@ -7533,8 +7703,7 @@ FFDA..FFDC ; ID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL 1A90..1A99 ; ID_Continue # Nd [10] TAI THAM THAM DIGIT ZERO..TAI THAM THAM DIGIT NINE 1AA7 ; ID_Continue # Lm TAI THAM SIGN MAI YAMOK 1AB0..1ABD ; ID_Continue # Mn [14] COMBINING DOUBLED CIRCUMFLEX ACCENT..COMBINING PARENTHESES BELOW -1ABF..1ADD ; ID_Continue # Mn [31] COMBINING LATIN SMALL LETTER W BELOW..COMBINING DOT-AND-RING BELOW -1AE0..1AEB ; ID_Continue # Mn [12] COMBINING LEFT TACK ABOVE..COMBINING DOUBLE RIGHTWARDS ARROW ABOVE +1ABF..1AF0 ; ID_Continue # Mn [50] COMBINING LATIN SMALL LETTER W BELOW..COMBINING DOUBLE COMMA ABOVE 1B00..1B03 ; ID_Continue # Mn [4] BALINESE SIGN ULU RICEM..BALINESE SIGN SURANG 1B04 ; ID_Continue # Mc BALINESE SIGN BISAH 1B05..1B33 ; ID_Continue # Lo [47] BALINESE LETTER AKARA..BALINESE LETTER HA @@ -7625,7 +7794,7 @@ FFDA..FFDC ; ID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL 2054 ; ID_Continue # Pc INVERTED UNDERTIE 2071 ; ID_Continue # Lm SUPERSCRIPT LATIN SMALL LETTER I 207F ; ID_Continue # Lm SUPERSCRIPT LATIN SMALL LETTER N -2090..209C ; ID_Continue # Lm [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T +208F..209F ; ID_Continue # Lm [17] MODIFIER LETTER HIGH AND LOW VERTICAL LINE..LATIN SUBSCRIPT SMALL LETTER Z 20D0..20DC ; ID_Continue # Mn [13] COMBINING LEFT HARPOON ABOVE..COMBINING FOUR DOTS ABOVE 20E1 ; ID_Continue # Mn COMBINING LEFT RIGHT ARROW ABOVE 20E5..20F0 ; ID_Continue # Mn [12] COMBINING REVERSE SOLIDUS OVERLAY..COMBINING ASTERISK ABOVE @@ -7723,7 +7892,8 @@ A771..A787 ; ID_Continue # L& [23] LATIN SMALL LETTER DUM..LATIN SMALL LETTE A788 ; ID_Continue # Lm MODIFIER LETTER LOW CIRCUMFLEX ACCENT A78B..A78E ; ID_Continue # L& [4] LATIN CAPITAL LETTER SALTILLO..LATIN SMALL LETTER L WITH RETROFLEX HOOK AND BELT A78F ; ID_Continue # Lo LATIN LETTER SINOLOGICAL DOT -A790..A7DC ; ID_Continue # L& [77] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN CAPITAL LETTER LAMBDA WITH STROKE +A790..A7DD ; ID_Continue # L& [78] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN CAPITAL LETTER CLOSED OMEGA +A7E2 ; ID_Continue # L& LATIN CAPITAL LETTER R WITH LONG LEG A7F1..A7F4 ; ID_Continue # Lm [4] MODIFIER LETTER CAPITAL S..MODIFIER LETTER CAPITAL Q A7F5..A7F6 ; ID_Continue # L& [2] LATIN CAPITAL LETTER REVERSED HALF H..LATIN SMALL LETTER REVERSED HALF H A7F7 ; ID_Continue # Lo LATIN EPIGRAPHIC LETTER SIDEWAYS I @@ -7824,6 +7994,7 @@ AB30..AB5A ; ID_Continue # L& [43] LATIN SMALL LETTER BARRED ALPHA..LATIN SM AB5C..AB5F ; ID_Continue # Lm [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK AB60..AB68 ; ID_Continue # L& [9] LATIN SMALL LETTER SAKHA YAT..LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE AB69 ; ID_Continue # Lm MODIFIER LETTER SMALL TURNED W +AB6C..AB6D ; ID_Continue # L& [2] LATIN CAPITAL LETTER SCRIPT R..LATIN CAPITAL LETTER SCRIPT R WITH RING AB70..ABBF ; ID_Continue # L& [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA ABC0..ABE2 ; ID_Continue # Lo [35] MEETEI MAYEK LETTER KOK..MEETEI MAYEK LETTER I LONSUM ABE3..ABE4 ; ID_Continue # Mc [2] MEETEI MAYEK VOWEL SIGN ONAP..MEETEI MAYEK VOWEL SIGN INAP @@ -7918,7 +8089,7 @@ FFDA..FFDC ; ID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HAN 10760..10767 ; ID_Continue # Lo [8] LINEAR A SIGN A800..LINEAR A SIGN A807 10780..10785 ; ID_Continue # Lm [6] MODIFIER LETTER SMALL CAPITAL AA..MODIFIER LETTER SMALL B WITH HOOK 10787..107B0 ; ID_Continue # Lm [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK -107B2..107BA ; ID_Continue # Lm [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL +107B2..107BF ; ID_Continue # Lm [14] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL ESH WITH DOUBLE BAR 10800..10805 ; ID_Continue # Lo [6] CYPRIOT SYLLABLE A..CYPRIOT SYLLABLE JA 10808 ; ID_Continue # Lo CYPRIOT SYLLABLE JO 1080A..10835 ; ID_Continue # Lo [44] CYPRIOT SYLLABLE KA..CYPRIOT SYLLABLE WO @@ -7972,7 +8143,9 @@ FFDA..FFDC ; ID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HAN 10EC2..10EC4 ; ID_Continue # Lo [3] ARABIC LETTER DAL WITH TWO DOTS VERTICALLY BELOW..ARABIC LETTER KAF WITH TWO DOTS VERTICALLY BELOW 10EC5 ; ID_Continue # Lm ARABIC SMALL YEH BARREE WITH TWO DOTS BELOW 10EC6..10EC7 ; ID_Continue # Lo [2] ARABIC LETTER THIN NOON..ARABIC LETTER YEH WITH FOUR DOTS BELOW -10EFA..10EFF ; ID_Continue # Mn [6] ARABIC DOUBLE VERTICAL BAR BELOW..ARABIC SMALL LOW WORD MADDA +10ECB..10ECF ; ID_Continue # Mn [5] ARABIC NORTHEAST POINTING ARROWHEAD ABOVE..ARABIC LARGE CIRCLE ABOVE +10ED9..10EEE ; ID_Continue # Lo [22] ARABIC CROWN LETTER BEH..ARABIC CROWN LETTER YEH +10EF0..10EFF ; ID_Continue # Mn [16] ARABIC SMALL LOW UPRIGHT RECTANGULAR ZERO..ARABIC SMALL LOW WORD MADDA 10F00..10F1C ; ID_Continue # Lo [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL 10F27 ; ID_Continue # Lo OLD SOGDIAN LIGATURE AYIN-DALETH 10F30..10F45 ; ID_Continue # Lo [22] SOGDIAN LETTER ALEPH..SOGDIAN INDEPENDENT SHIN @@ -8199,6 +8372,7 @@ FFDA..FFDC ; ID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HAN 11A98..11A99 ; ID_Continue # Mn [2] SOYOMBO GEMINATION MARK..SOYOMBO SUBJOINER 11A9D ; ID_Continue # Lo SOYOMBO MARK PLUTA 11AB0..11AF8 ; ID_Continue # Lo [73] CANADIAN SYLLABICS NATTILIK HI..PAU CIN HAU GLOTTAL STOP FINAL +11B0A ; ID_Continue # Lo DEVANAGARI LETTER ALTERNATE DDDA 11B60 ; ID_Continue # Mn SHARADA VOWEL SIGN OE 11B61 ; ID_Continue # Mc SHARADA VOWEL SIGN OOE 11B62..11B64 ; ID_Continue # Mn [3] SHARADA VOWEL SIGN UE..SHARADA VOWEL SIGN SHORT E @@ -8249,6 +8423,8 @@ FFDA..FFDC ; ID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HAN 11DD9 ; ID_Continue # Lm TOLONG SIKI SIGN SELA 11DDA..11DDB ; ID_Continue # Lo [2] TOLONG SIKI SIGN HECAKA..TOLONG SIKI UNGGA 11DE0..11DE9 ; ID_Continue # Nd [10] TOLONG SIKI DIGIT ZERO..TOLONG SIKI DIGIT NINE +11DF0 ; ID_Continue # Mn BENGALI SIGN COMBINING ANUSVARA ABOVE +11DF1 ; ID_Continue # Lo BENGALI LETTER ALTERNATE BARGIYA BA 11EE0..11EF2 ; ID_Continue # Lo [19] MAKASAR LETTER KA..MAKASAR ANGKA 11EF3..11EF4 ; ID_Continue # Mn [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U 11EF5..11EF6 ; ID_Continue # Mc [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O @@ -8267,8 +8443,10 @@ FFDA..FFDC ; ID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HAN 11F5A ; ID_Continue # Mn KAWI SIGN NUKTA 11FB0 ; ID_Continue # Lo LISU LETTER YHA 12000..12399 ; ID_Continue # Lo [922] CUNEIFORM SIGN A..CUNEIFORM SIGN U U -12400..1246E ; ID_Continue # Nl [111] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM +12400..1246F ; ID_Continue # Nl [112] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN SEVEN ASH TENU +12475..1247F ; ID_Continue # Nl [11] CUNEIFORM NUMERIC SIGN EIGHT ASH TENU..CUNEIFORM NUMERIC SIGN ASH TIMES NINE DISH TENU 12480..12543 ; ID_Continue # Lo [196] CUNEIFORM SIGN AB TIMES NUN TENU..CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU +12550..12686 ; ID_Continue # Nl [311] CUNEIFORM NUMERIC SIGN ONE N01..CUNEIFORM NUMERIC SIGN ONE N36 FLAT 12F90..12FF0 ; ID_Continue # Lo [97] CYPRO-MINOAN SIGN CM001..CYPRO-MINOAN SIGN CM114 13000..1342F ; ID_Continue # Lo [1072] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH V011D 13440 ; ID_Continue # Mn EGYPTIAN HIEROGLYPH MIRROR HORIZONTALLY @@ -8313,17 +8491,19 @@ FFDA..FFDC ; ID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HAN 16FF0..16FF1 ; ID_Continue # Mc [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY 16FF2..16FF3 ; ID_Continue # Lm [2] CHINESE SMALL SIMPLIFIED ER..CHINESE SMALL TRADITIONAL ER 16FF4..16FF6 ; ID_Continue # Nl [3] YANGQIN SIGN SLOW ONE BEAT..YANGQIN SIGN SLOW TWO BEATS -17000..18CD5 ; ID_Continue # Lo [7382] TANGUT IDEOGRAPH-17000..KHITAN SMALL SCRIPT CHARACTER-18CD5 -18CFF..18D1E ; ID_Continue # Lo [32] KHITAN SMALL SCRIPT CHARACTER-18CFF..TANGUT IDEOGRAPH-18D1E +17000..18CDA ; ID_Continue # Lo [7387] TANGUT IDEOGRAPH-17000..KHITAN SMALL SCRIPT CHARACTER-18CDA +18CFF..18D20 ; ID_Continue # Lo [34] KHITAN SMALL SCRIPT CHARACTER-18CFF..TANGUT IDEOGRAPH-18D20 18D80..18DF2 ; ID_Continue # Lo [115] TANGUT COMPONENT-769..TANGUT COMPONENT-883 +18E00..19191 ; ID_Continue # Lo [914] JURCHEN CHARACTER-18E00..JURCHEN CHARACTER-19191 +191A0..191D2 ; ID_Continue # Lo [51] JURCHEN RADICAL-01..JURCHEN RADICAL-51 1AFF0..1AFF3 ; ID_Continue # Lm [4] KATAKANA LETTER MINNAN TONE-2..KATAKANA LETTER MINNAN TONE-5 1AFF5..1AFFB ; ID_Continue # Lm [7] KATAKANA LETTER MINNAN TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-5 1AFFD..1AFFE ; ID_Continue # Lm [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8 -1B000..1B122 ; ID_Continue # Lo [291] KATAKANA LETTER ARCHAIC E..KATAKANA LETTER ARCHAIC WU +1B000..1B128 ; ID_Continue # Lo [297] KATAKANA LETTER ARCHAIC E..KATAKANA LETTER ALTERNATE WI 1B132 ; ID_Continue # Lo HIRAGANA LETTER SMALL KO 1B150..1B152 ; ID_Continue # Lo [3] HIRAGANA LETTER SMALL WI..HIRAGANA LETTER SMALL WO 1B155 ; ID_Continue # Lo KATAKANA LETTER SMALL KO -1B164..1B167 ; ID_Continue # Lo [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N +1B164..1B168 ; ID_Continue # Lo [5] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL ARCHAIC YE 1B170..1B2FB ; ID_Continue # Lo [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB 1BC00..1BC6A ; ID_Continue # Lo [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M 1BC70..1BC7C ; ID_Continue # Lo [13] DUPLOYAN AFFIX LEFT HORIZONTAL SECANT..DUPLOYAN AFFIX ATTACHED TANGENT HOOK @@ -8333,6 +8513,7 @@ FFDA..FFDC ; ID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HAN 1CCF0..1CCF9 ; ID_Continue # Nd [10] OUTLINED DIGIT ZERO..OUTLINED DIGIT NINE 1CF00..1CF2D ; ID_Continue # Mn [46] ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON LEFT..ZNAMENNY COMBINING MARK KRYZH ON LEFT 1CF30..1CF46 ; ID_Continue # Mn [23] ZNAMENNY COMBINING TONAL RANGE MARK MRACHNO..ZNAMENNY PRIZNAK MODIFIER ROG +1D127..1D128 ; ID_Continue # Mn [2] MUSICAL SYMBOL COMBINING STRESS..MUSICAL SYMBOL COMBINING UNSTRESS 1D165..1D166 ; ID_Continue # Mc [2] MUSICAL SYMBOL COMBINING STEM..MUSICAL SYMBOL COMBINING SPRECHGESANG STEM 1D167..1D169 ; ID_Continue # Mn [3] MUSICAL SYMBOL COMBINING TREMOLO-1..MUSICAL SYMBOL COMBINING TREMOLO-3 1D16D..1D172 ; ID_Continue # Mc [6] MUSICAL SYMBOL COMBINING AUGMENTATION DOT..MUSICAL SYMBOL COMBINING FLAG-5 @@ -8340,6 +8521,10 @@ FFDA..FFDC ; ID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HAN 1D185..1D18B ; ID_Continue # Mn [7] MUSICAL SYMBOL COMBINING DOIT..MUSICAL SYMBOL COMBINING TRIPLE TONGUE 1D1AA..1D1AD ; ID_Continue # Mn [4] MUSICAL SYMBOL COMBINING DOWN BOW..MUSICAL SYMBOL COMBINING SNAP PIZZICATO 1D242..1D244 ; ID_Continue # Mn [3] COMBINING GREEK MUSICAL TRISEME..COMBINING GREEK MUSICAL PENTASEME +1D250..1D252 ; ID_Continue # Mc [3] MUSICAL SYMBOL COMBINING FLAG-6..MUSICAL SYMBOL COMBINING FLAG-8 +1D25B..1D25C ; ID_Continue # Mn [2] MUSICAL SYMBOL COMBINING TREMOLO-4..MUSICAL SYMBOL COMBINING TREMOLO-5 +1D25F ; ID_Continue # Mc MUSICAL SYMBOL COMBINING BUZZ ROLL STEM +1D280..1D281 ; ID_Continue # Mc [2] MUSICAL SYMBOL COMBINING STEM BOW BEHIND BRIDGE..MUSICAL SYMBOL COMBINING STEM BOW ON TOP OF BRIDGE 1D400..1D454 ; ID_Continue # L& [85] MATHEMATICAL BOLD CAPITAL A..MATHEMATICAL ITALIC SMALL G 1D456..1D49C ; ID_Continue # L& [71] MATHEMATICAL ITALIC SMALL I..MATHEMATICAL SCRIPT CAPITAL A 1D49E..1D49F ; ID_Continue # L& [2] MATHEMATICAL SCRIPT CAPITAL C..MATHEMATICAL SCRIPT CAPITAL D @@ -8358,7 +8543,7 @@ FFDA..FFDC ; ID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HAN 1D540..1D544 ; ID_Continue # L& [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M 1D546 ; ID_Continue # L& MATHEMATICAL DOUBLE-STRUCK CAPITAL O 1D54A..1D550 ; ID_Continue # L& [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y -1D552..1D6A5 ; ID_Continue # L& [340] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J +1D552..1D6A6 ; ID_Continue # L& [341] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL LIGATURE LONG S WITH DESCENDER S 1D6A8..1D6C0 ; ID_Continue # L& [25] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL BOLD CAPITAL OMEGA 1D6C2..1D6DA ; ID_Continue # L& [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA 1D6DC..1D6FA ; ID_Continue # L& [31] MATHEMATICAL BOLD EPSILON SYMBOL..MATHEMATICAL ITALIC CAPITAL OMEGA @@ -8379,8 +8564,10 @@ FFDA..FFDC ; ID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HAN 1DAA1..1DAAF ; ID_Continue # Mn [15] SIGNWRITING ROTATION MODIFIER-2..SIGNWRITING ROTATION MODIFIER-16 1DF00..1DF09 ; ID_Continue # L& [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK 1DF0A ; ID_Continue # Lo LATIN LETTER RETROFLEX CLICK WITH RETROFLEX HOOK -1DF0B..1DF1E ; ID_Continue # L& [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL -1DF25..1DF2A ; ID_Continue # L& [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK +1DF0B..1DF7F ; ID_Continue # L& [117] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER REVERSED U +1DF80..1DF81 ; ID_Continue # Lo [2] LATIN CAPITAL LETTER A WITH TOPBAR..LATIN CAPITAL LETTER E WITH BENT TOPBAR +1DF90..1DF96 ; ID_Continue # L& [7] LATIN SMALL LETTER C WITH LOW SLASH..LATIN SMALL LETTER LONG S WITH TOP LOOP +1DFCD..1DFFF ; ID_Continue # Lm [51] MODIFIER LETTER SMALL TURNED R WITH MID-HEIGHT LEFT HOOK..MODIFIER LETTER SMALL T WITH HOOK AND RETROFLEX HOOK 1E000..1E006 ; ID_Continue # Mn [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE 1E008..1E018 ; ID_Continue # Mn [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU 1E01B..1E021 ; ID_Continue # Mn [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI @@ -8462,16 +8649,17 @@ FFDA..FFDC ; ID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HAN 1EEAB..1EEBB ; ID_Continue # Lo [17] ARABIC MATHEMATICAL DOUBLE-STRUCK LAM..ARABIC MATHEMATICAL DOUBLE-STRUCK GHAIN 1FBF0..1FBF9 ; ID_Continue # Nd [10] SEGMENTED DIGIT ZERO..SEGMENTED DIGIT NINE 20000..2A6DF ; ID_Continue # Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF -2A700..2B81D ; ID_Continue # Lo [4382] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81D +2A700..2B81E ; ID_Continue # Lo [4383] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81E 2B820..2CEAD ; ID_Continue # Lo [5774] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEAD 2CEB0..2EBE0 ; ID_Continue # Lo [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0 2EBF0..2EE5D ; ID_Continue # Lo [622] CJK UNIFIED IDEOGRAPH-2EBF0..CJK UNIFIED IDEOGRAPH-2EE5D 2F800..2FA1D ; ID_Continue # Lo [542] CJK COMPATIBILITY IDEOGRAPH-2F800..CJK COMPATIBILITY IDEOGRAPH-2FA1D 30000..3134A ; ID_Continue # Lo [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A 31350..33479 ; ID_Continue # Lo [8490] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-33479 +3D000..3FC3F ; ID_Continue # Lo [11328] SMALL SEAL CHARACTER-3D000..SMALL SEAL CHARACTER-3FC3F E0100..E01EF ; ID_Continue # Mn [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256 -# Total code points: 149240 +# Total code points: 162100 # ================================================ @@ -8514,8 +8702,9 @@ E0100..E01EF ; ID_Continue # Mn [240] VARIATION SELECTOR-17..VARIATION SELECTOR 03F7..0481 ; XID_Start # L& [139] GREEK CAPITAL LETTER SHO..CYRILLIC SMALL LETTER KOPPA 048A..052F ; XID_Start # L& [166] CYRILLIC CAPITAL LETTER SHORT I WITH TAIL..CYRILLIC SMALL LETTER EL WITH DESCENDER 0531..0556 ; XID_Start # L& [38] ARMENIAN CAPITAL LETTER AYB..ARMENIAN CAPITAL LETTER FEH -0559 ; XID_Start # Lm ARMENIAN MODIFIER LETTER LEFT HALF RING +0558..0559 ; XID_Start # Lm [2] MODIFIER LETTER ARMENIAN SMALL EH..ARMENIAN MODIFIER LETTER LEFT HALF RING 0560..0588 ; XID_Start # L& [41] ARMENIAN SMALL LETTER TURNED AYB..ARMENIAN SMALL LETTER YI WITH STROKE +058B..058C ; XID_Start # Lm [2] MODIFIER LETTER ARMENIAN SMALL INI..MODIFIER LETTER ARMENIAN SMALL YI 05D0..05EA ; XID_Start # Lo [27] HEBREW LETTER ALEF..HEBREW LETTER TAV 05EF..05F2 ; XID_Start # Lo [4] HEBREW YOD TRIANGLE..HEBREW LIGATURE YIDDISH DOUBLE YOD 0620..063F ; XID_Start # Lo [32] ARABIC LETTER KASHMIRI YEH..ARABIC LETTER FARSI YEH WITH THREE DOTS ABOVE @@ -8761,7 +8950,7 @@ E0100..E01EF ; ID_Continue # Mn [240] VARIATION SELECTOR-17..VARIATION SELECTOR 1FF6..1FFC ; XID_Start # L& [7] GREEK SMALL LETTER OMEGA WITH PERISPOMENI..GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI 2071 ; XID_Start # Lm SUPERSCRIPT LATIN SMALL LETTER I 207F ; XID_Start # Lm SUPERSCRIPT LATIN SMALL LETTER N -2090..209C ; XID_Start # Lm [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T +208F..209F ; XID_Start # Lm [17] MODIFIER LETTER HIGH AND LOW VERTICAL LINE..LATIN SUBSCRIPT SMALL LETTER Z 2102 ; XID_Start # L& DOUBLE-STRUCK CAPITAL C 2107 ; XID_Start # L& EULER CONSTANT 210A..2113 ; XID_Start # L& [10] SCRIPT SMALL G..SCRIPT SMALL L @@ -8843,7 +9032,8 @@ A771..A787 ; XID_Start # L& [23] LATIN SMALL LETTER DUM..LATIN SMALL LETTER A788 ; XID_Start # Lm MODIFIER LETTER LOW CIRCUMFLEX ACCENT A78B..A78E ; XID_Start # L& [4] LATIN CAPITAL LETTER SALTILLO..LATIN SMALL LETTER L WITH RETROFLEX HOOK AND BELT A78F ; XID_Start # Lo LATIN LETTER SINOLOGICAL DOT -A790..A7DC ; XID_Start # L& [77] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN CAPITAL LETTER LAMBDA WITH STROKE +A790..A7DD ; XID_Start # L& [78] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN CAPITAL LETTER CLOSED OMEGA +A7E2 ; XID_Start # L& LATIN CAPITAL LETTER R WITH LONG LEG A7F1..A7F4 ; XID_Start # Lm [4] MODIFIER LETTER CAPITAL S..MODIFIER LETTER CAPITAL Q A7F5..A7F6 ; XID_Start # L& [2] LATIN CAPITAL LETTER REVERSED HALF H..LATIN SMALL LETTER REVERSED HALF H A7F7 ; XID_Start # Lo LATIN EPIGRAPHIC LETTER SIDEWAYS I @@ -8894,6 +9084,7 @@ AB30..AB5A ; XID_Start # L& [43] LATIN SMALL LETTER BARRED ALPHA..LATIN SMAL AB5C..AB5F ; XID_Start # Lm [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK AB60..AB68 ; XID_Start # L& [9] LATIN SMALL LETTER SAKHA YAT..LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE AB69 ; XID_Start # Lm MODIFIER LETTER SMALL TURNED W +AB6C..AB6D ; XID_Start # L& [2] LATIN CAPITAL LETTER SCRIPT R..LATIN CAPITAL LETTER SCRIPT R WITH RING AB70..ABBF ; XID_Start # L& [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA ABC0..ABE2 ; XID_Start # Lo [35] MEETEI MAYEK LETTER KOK..MEETEI MAYEK LETTER I LONSUM AC00..D7A3 ; XID_Start # Lo [11172] HANGUL SYLLABLE GA..HANGUL SYLLABLE HIH @@ -8973,7 +9164,7 @@ FFDA..FFDC ; XID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGU 10760..10767 ; XID_Start # Lo [8] LINEAR A SIGN A800..LINEAR A SIGN A807 10780..10785 ; XID_Start # Lm [6] MODIFIER LETTER SMALL CAPITAL AA..MODIFIER LETTER SMALL B WITH HOOK 10787..107B0 ; XID_Start # Lm [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK -107B2..107BA ; XID_Start # Lm [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL +107B2..107BF ; XID_Start # Lm [14] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL ESH WITH DOUBLE BAR 10800..10805 ; XID_Start # Lo [6] CYPRIOT SYLLABLE A..CYPRIOT SYLLABLE JA 10808 ; XID_Start # Lo CYPRIOT SYLLABLE JO 1080A..10835 ; XID_Start # Lo [44] CYPRIOT SYLLABLE KA..CYPRIOT SYLLABLE WO @@ -9016,6 +9207,7 @@ FFDA..FFDC ; XID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGU 10EC2..10EC4 ; XID_Start # Lo [3] ARABIC LETTER DAL WITH TWO DOTS VERTICALLY BELOW..ARABIC LETTER KAF WITH TWO DOTS VERTICALLY BELOW 10EC5 ; XID_Start # Lm ARABIC SMALL YEH BARREE WITH TWO DOTS BELOW 10EC6..10EC7 ; XID_Start # Lo [2] ARABIC LETTER THIN NOON..ARABIC LETTER YEH WITH FOUR DOTS BELOW +10ED9..10EEE ; XID_Start # Lo [22] ARABIC CROWN LETTER BEH..ARABIC CROWN LETTER YEH 10F00..10F1C ; XID_Start # Lo [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL 10F27 ; XID_Start # Lo OLD SOGDIAN LIGATURE AYIN-DALETH 10F30..10F45 ; XID_Start # Lo [22] SOGDIAN LETTER ALEPH..SOGDIAN INDEPENDENT SHIN @@ -9095,6 +9287,7 @@ FFDA..FFDC ; XID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGU 11A5C..11A89 ; XID_Start # Lo [46] SOYOMBO LETTER KA..SOYOMBO CLUSTER-INITIAL LETTER SA 11A9D ; XID_Start # Lo SOYOMBO MARK PLUTA 11AB0..11AF8 ; XID_Start # Lo [73] CANADIAN SYLLABICS NATTILIK HI..PAU CIN HAU GLOTTAL STOP FINAL +11B0A ; XID_Start # Lo DEVANAGARI LETTER ALTERNATE DDDA 11BC0..11BE0 ; XID_Start # Lo [33] SUNUWAR LETTER DEVI..SUNUWAR LETTER KLOKO 11C00..11C08 ; XID_Start # Lo [9] BHAIKSUKI LETTER A..BHAIKSUKI LETTER VOCALIC L 11C0A..11C2E ; XID_Start # Lo [37] BHAIKSUKI LETTER E..BHAIKSUKI LETTER HA @@ -9111,14 +9304,17 @@ FFDA..FFDC ; XID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGU 11DB0..11DD8 ; XID_Start # Lo [41] TOLONG SIKI LETTER I..TOLONG SIKI LETTER RRH 11DD9 ; XID_Start # Lm TOLONG SIKI SIGN SELA 11DDA..11DDB ; XID_Start # Lo [2] TOLONG SIKI SIGN HECAKA..TOLONG SIKI UNGGA +11DF1 ; XID_Start # Lo BENGALI LETTER ALTERNATE BARGIYA BA 11EE0..11EF2 ; XID_Start # Lo [19] MAKASAR LETTER KA..MAKASAR ANGKA 11F02 ; XID_Start # Lo KAWI SIGN REPHA 11F04..11F10 ; XID_Start # Lo [13] KAWI LETTER A..KAWI LETTER O 11F12..11F33 ; XID_Start # Lo [34] KAWI LETTER KA..KAWI LETTER JNYA 11FB0 ; XID_Start # Lo LISU LETTER YHA 12000..12399 ; XID_Start # Lo [922] CUNEIFORM SIGN A..CUNEIFORM SIGN U U -12400..1246E ; XID_Start # Nl [111] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM +12400..1246F ; XID_Start # Nl [112] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN SEVEN ASH TENU +12475..1247F ; XID_Start # Nl [11] CUNEIFORM NUMERIC SIGN EIGHT ASH TENU..CUNEIFORM NUMERIC SIGN ASH TIMES NINE DISH TENU 12480..12543 ; XID_Start # Lo [196] CUNEIFORM SIGN AB TIMES NUN TENU..CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU +12550..12686 ; XID_Start # Nl [311] CUNEIFORM NUMERIC SIGN ONE N01..CUNEIFORM NUMERIC SIGN ONE N36 FLAT 12F90..12FF0 ; XID_Start # Lo [97] CYPRO-MINOAN SIGN CM001..CYPRO-MINOAN SIGN CM114 13000..1342F ; XID_Start # Lo [1072] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH V011D 13441..13446 ; XID_Start # Lo [6] EGYPTIAN HIEROGLYPH FULL BLANK..EGYPTIAN HIEROGLYPH WIDE LOST SIGN @@ -9146,17 +9342,19 @@ FFDA..FFDC ; XID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGU 16FE3 ; XID_Start # Lm OLD CHINESE ITERATION MARK 16FF2..16FF3 ; XID_Start # Lm [2] CHINESE SMALL SIMPLIFIED ER..CHINESE SMALL TRADITIONAL ER 16FF4..16FF6 ; XID_Start # Nl [3] YANGQIN SIGN SLOW ONE BEAT..YANGQIN SIGN SLOW TWO BEATS -17000..18CD5 ; XID_Start # Lo [7382] TANGUT IDEOGRAPH-17000..KHITAN SMALL SCRIPT CHARACTER-18CD5 -18CFF..18D1E ; XID_Start # Lo [32] KHITAN SMALL SCRIPT CHARACTER-18CFF..TANGUT IDEOGRAPH-18D1E +17000..18CDA ; XID_Start # Lo [7387] TANGUT IDEOGRAPH-17000..KHITAN SMALL SCRIPT CHARACTER-18CDA +18CFF..18D20 ; XID_Start # Lo [34] KHITAN SMALL SCRIPT CHARACTER-18CFF..TANGUT IDEOGRAPH-18D20 18D80..18DF2 ; XID_Start # Lo [115] TANGUT COMPONENT-769..TANGUT COMPONENT-883 +18E00..19191 ; XID_Start # Lo [914] JURCHEN CHARACTER-18E00..JURCHEN CHARACTER-19191 +191A0..191D2 ; XID_Start # Lo [51] JURCHEN RADICAL-01..JURCHEN RADICAL-51 1AFF0..1AFF3 ; XID_Start # Lm [4] KATAKANA LETTER MINNAN TONE-2..KATAKANA LETTER MINNAN TONE-5 1AFF5..1AFFB ; XID_Start # Lm [7] KATAKANA LETTER MINNAN TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-5 1AFFD..1AFFE ; XID_Start # Lm [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8 -1B000..1B122 ; XID_Start # Lo [291] KATAKANA LETTER ARCHAIC E..KATAKANA LETTER ARCHAIC WU +1B000..1B128 ; XID_Start # Lo [297] KATAKANA LETTER ARCHAIC E..KATAKANA LETTER ALTERNATE WI 1B132 ; XID_Start # Lo HIRAGANA LETTER SMALL KO 1B150..1B152 ; XID_Start # Lo [3] HIRAGANA LETTER SMALL WI..HIRAGANA LETTER SMALL WO 1B155 ; XID_Start # Lo KATAKANA LETTER SMALL KO -1B164..1B167 ; XID_Start # Lo [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N +1B164..1B168 ; XID_Start # Lo [5] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL ARCHAIC YE 1B170..1B2FB ; XID_Start # Lo [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB 1BC00..1BC6A ; XID_Start # Lo [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M 1BC70..1BC7C ; XID_Start # Lo [13] DUPLOYAN AFFIX LEFT HORIZONTAL SECANT..DUPLOYAN AFFIX ATTACHED TANGENT HOOK @@ -9180,7 +9378,7 @@ FFDA..FFDC ; XID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGU 1D540..1D544 ; XID_Start # L& [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M 1D546 ; XID_Start # L& MATHEMATICAL DOUBLE-STRUCK CAPITAL O 1D54A..1D550 ; XID_Start # L& [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y -1D552..1D6A5 ; XID_Start # L& [340] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J +1D552..1D6A6 ; XID_Start # L& [341] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL LIGATURE LONG S WITH DESCENDER S 1D6A8..1D6C0 ; XID_Start # L& [25] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL BOLD CAPITAL OMEGA 1D6C2..1D6DA ; XID_Start # L& [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA 1D6DC..1D6FA ; XID_Start # L& [31] MATHEMATICAL BOLD EPSILON SYMBOL..MATHEMATICAL ITALIC CAPITAL OMEGA @@ -9194,8 +9392,10 @@ FFDA..FFDC ; XID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGU 1D7C4..1D7CB ; XID_Start # L& [8] MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD SMALL DIGAMMA 1DF00..1DF09 ; XID_Start # L& [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK 1DF0A ; XID_Start # Lo LATIN LETTER RETROFLEX CLICK WITH RETROFLEX HOOK -1DF0B..1DF1E ; XID_Start # L& [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL -1DF25..1DF2A ; XID_Start # L& [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK +1DF0B..1DF7F ; XID_Start # L& [117] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER REVERSED U +1DF80..1DF81 ; XID_Start # Lo [2] LATIN CAPITAL LETTER A WITH TOPBAR..LATIN CAPITAL LETTER E WITH BENT TOPBAR +1DF90..1DF96 ; XID_Start # L& [7] LATIN SMALL LETTER C WITH LOW SLASH..LATIN SMALL LETTER LONG S WITH TOP LOOP +1DFCD..1DFFF ; XID_Start # Lm [51] MODIFIER LETTER SMALL TURNED R WITH MID-HEIGHT LEFT HOOK..MODIFIER LETTER SMALL T WITH HOOK AND RETROFLEX HOOK 1E030..1E06D ; XID_Start # Lm [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE 1E100..1E12C ; XID_Start # Lo [45] NYIAKENG PUACHUE HMONG LETTER MA..NYIAKENG PUACHUE HMONG LETTER W 1E137..1E13D ; XID_Start # Lm [7] NYIAKENG PUACHUE HMONG SIGN FOR PERSON..NYIAKENG PUACHUE HMONG SYLLABLE LENGTHENER @@ -9254,15 +9454,16 @@ FFDA..FFDC ; XID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGU 1EEA5..1EEA9 ; XID_Start # Lo [5] ARABIC MATHEMATICAL DOUBLE-STRUCK WAW..ARABIC MATHEMATICAL DOUBLE-STRUCK YEH 1EEAB..1EEBB ; XID_Start # Lo [17] ARABIC MATHEMATICAL DOUBLE-STRUCK LAM..ARABIC MATHEMATICAL DOUBLE-STRUCK GHAIN 20000..2A6DF ; XID_Start # Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF -2A700..2B81D ; XID_Start # Lo [4382] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81D +2A700..2B81E ; XID_Start # Lo [4383] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81E 2B820..2CEAD ; XID_Start # Lo [5774] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEAD 2CEB0..2EBE0 ; XID_Start # Lo [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0 2EBF0..2EE5D ; XID_Start # Lo [622] CJK UNIFIED IDEOGRAPH-2EBF0..CJK UNIFIED IDEOGRAPH-2EE5D 2F800..2FA1D ; XID_Start # Lo [542] CJK COMPATIBILITY IDEOGRAPH-2F800..CJK COMPATIBILITY IDEOGRAPH-2FA1D 30000..3134A ; XID_Start # Lo [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A 31350..33479 ; XID_Start # Lo [8490] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-33479 +3D000..3FC3F ; XID_Start # Lo [11328] SMALL SEAL CHARACTER-3D000..SMALL SEAL CHARACTER-3FC3F -# Total code points: 145893 +# Total code points: 158716 # ================================================ @@ -9311,13 +9512,14 @@ FFDA..FFDC ; XID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGU 0483..0487 ; XID_Continue # Mn [5] COMBINING CYRILLIC TITLO..COMBINING CYRILLIC POKRYTIE 048A..052F ; XID_Continue # L& [166] CYRILLIC CAPITAL LETTER SHORT I WITH TAIL..CYRILLIC SMALL LETTER EL WITH DESCENDER 0531..0556 ; XID_Continue # L& [38] ARMENIAN CAPITAL LETTER AYB..ARMENIAN CAPITAL LETTER FEH -0559 ; XID_Continue # Lm ARMENIAN MODIFIER LETTER LEFT HALF RING +0558..0559 ; XID_Continue # Lm [2] MODIFIER LETTER ARMENIAN SMALL EH..ARMENIAN MODIFIER LETTER LEFT HALF RING 0560..0588 ; XID_Continue # L& [41] ARMENIAN SMALL LETTER TURNED AYB..ARMENIAN SMALL LETTER YI WITH STROKE +058B..058C ; XID_Continue # Lm [2] MODIFIER LETTER ARMENIAN SMALL INI..MODIFIER LETTER ARMENIAN SMALL YI 0591..05BD ; XID_Continue # Mn [45] HEBREW ACCENT ETNAHTA..HEBREW POINT METEG 05BF ; XID_Continue # Mn HEBREW POINT RAFE 05C1..05C2 ; XID_Continue # Mn [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT 05C4..05C5 ; XID_Continue # Mn [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT -05C7 ; XID_Continue # Mn HEBREW POINT QAMATS QATAN +05C7..05C9 ; XID_Continue # Mn [3] HEBREW POINT QAMATS QATAN..HEBREW POINT DAGESH HAZAQ MUDGASH 05D0..05EA ; XID_Continue # Lo [27] HEBREW LETTER ALEF..HEBREW LETTER TAV 05EF..05F2 ; XID_Continue # Lo [4] HEBREW YOD TRIANGLE..HEBREW LIGATURE YIDDISH DOUBLE YOD 0610..061A ; XID_Continue # Mn [11] ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM..ARABIC SMALL KASRA @@ -9472,7 +9674,7 @@ FFDA..FFDC ; XID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGU 0B47..0B48 ; XID_Continue # Mc [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SIGN AI 0B4B..0B4C ; XID_Continue # Mc [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SIGN AU 0B4D ; XID_Continue # Mn ORIYA SIGN VIRAMA -0B55..0B56 ; XID_Continue # Mn [2] ORIYA SIGN OVERLINE..ORIYA AI LENGTH MARK +0B53..0B56 ; XID_Continue # Mn [4] ORIYA SIGN DOT ABOVE..ORIYA AI LENGTH MARK 0B57 ; XID_Continue # Mc ORIYA AU LENGTH MARK 0B5C..0B5D ; XID_Continue # Lo [2] ORIYA LETTER RRA..ORIYA LETTER RHA 0B5F..0B61 ; XID_Continue # Lo [3] ORIYA LETTER YYA..ORIYA LETTER VOCALIC LL @@ -9753,8 +9955,7 @@ FFDA..FFDC ; XID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGU 1A90..1A99 ; XID_Continue # Nd [10] TAI THAM THAM DIGIT ZERO..TAI THAM THAM DIGIT NINE 1AA7 ; XID_Continue # Lm TAI THAM SIGN MAI YAMOK 1AB0..1ABD ; XID_Continue # Mn [14] COMBINING DOUBLED CIRCUMFLEX ACCENT..COMBINING PARENTHESES BELOW -1ABF..1ADD ; XID_Continue # Mn [31] COMBINING LATIN SMALL LETTER W BELOW..COMBINING DOT-AND-RING BELOW -1AE0..1AEB ; XID_Continue # Mn [12] COMBINING LEFT TACK ABOVE..COMBINING DOUBLE RIGHTWARDS ARROW ABOVE +1ABF..1AF0 ; XID_Continue # Mn [50] COMBINING LATIN SMALL LETTER W BELOW..COMBINING DOUBLE COMMA ABOVE 1B00..1B03 ; XID_Continue # Mn [4] BALINESE SIGN ULU RICEM..BALINESE SIGN SURANG 1B04 ; XID_Continue # Mc BALINESE SIGN BISAH 1B05..1B33 ; XID_Continue # Lo [47] BALINESE LETTER AKARA..BALINESE LETTER HA @@ -9845,7 +10046,7 @@ FFDA..FFDC ; XID_Start # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGU 2054 ; XID_Continue # Pc INVERTED UNDERTIE 2071 ; XID_Continue # Lm SUPERSCRIPT LATIN SMALL LETTER I 207F ; XID_Continue # Lm SUPERSCRIPT LATIN SMALL LETTER N -2090..209C ; XID_Continue # Lm [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T +208F..209F ; XID_Continue # Lm [17] MODIFIER LETTER HIGH AND LOW VERTICAL LINE..LATIN SUBSCRIPT SMALL LETTER Z 20D0..20DC ; XID_Continue # Mn [13] COMBINING LEFT HARPOON ABOVE..COMBINING FOUR DOTS ABOVE 20E1 ; XID_Continue # Mn COMBINING LEFT RIGHT ARROW ABOVE 20E5..20F0 ; XID_Continue # Mn [12] COMBINING REVERSE SOLIDUS OVERLAY..COMBINING ASTERISK ABOVE @@ -9942,7 +10143,8 @@ A771..A787 ; XID_Continue # L& [23] LATIN SMALL LETTER DUM..LATIN SMALL LETT A788 ; XID_Continue # Lm MODIFIER LETTER LOW CIRCUMFLEX ACCENT A78B..A78E ; XID_Continue # L& [4] LATIN CAPITAL LETTER SALTILLO..LATIN SMALL LETTER L WITH RETROFLEX HOOK AND BELT A78F ; XID_Continue # Lo LATIN LETTER SINOLOGICAL DOT -A790..A7DC ; XID_Continue # L& [77] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN CAPITAL LETTER LAMBDA WITH STROKE +A790..A7DD ; XID_Continue # L& [78] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN CAPITAL LETTER CLOSED OMEGA +A7E2 ; XID_Continue # L& LATIN CAPITAL LETTER R WITH LONG LEG A7F1..A7F4 ; XID_Continue # Lm [4] MODIFIER LETTER CAPITAL S..MODIFIER LETTER CAPITAL Q A7F5..A7F6 ; XID_Continue # L& [2] LATIN CAPITAL LETTER REVERSED HALF H..LATIN SMALL LETTER REVERSED HALF H A7F7 ; XID_Continue # Lo LATIN EPIGRAPHIC LETTER SIDEWAYS I @@ -10043,6 +10245,7 @@ AB30..AB5A ; XID_Continue # L& [43] LATIN SMALL LETTER BARRED ALPHA..LATIN S AB5C..AB5F ; XID_Continue # Lm [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK AB60..AB68 ; XID_Continue # L& [9] LATIN SMALL LETTER SAKHA YAT..LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE AB69 ; XID_Continue # Lm MODIFIER LETTER SMALL TURNED W +AB6C..AB6D ; XID_Continue # L& [2] LATIN CAPITAL LETTER SCRIPT R..LATIN CAPITAL LETTER SCRIPT R WITH RING AB70..ABBF ; XID_Continue # L& [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA ABC0..ABE2 ; XID_Continue # Lo [35] MEETEI MAYEK LETTER KOK..MEETEI MAYEK LETTER I LONSUM ABE3..ABE4 ; XID_Continue # Mc [2] MEETEI MAYEK VOWEL SIGN ONAP..MEETEI MAYEK VOWEL SIGN INAP @@ -10143,7 +10346,7 @@ FFDA..FFDC ; XID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HA 10760..10767 ; XID_Continue # Lo [8] LINEAR A SIGN A800..LINEAR A SIGN A807 10780..10785 ; XID_Continue # Lm [6] MODIFIER LETTER SMALL CAPITAL AA..MODIFIER LETTER SMALL B WITH HOOK 10787..107B0 ; XID_Continue # Lm [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK -107B2..107BA ; XID_Continue # Lm [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL +107B2..107BF ; XID_Continue # Lm [14] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL ESH WITH DOUBLE BAR 10800..10805 ; XID_Continue # Lo [6] CYPRIOT SYLLABLE A..CYPRIOT SYLLABLE JA 10808 ; XID_Continue # Lo CYPRIOT SYLLABLE JO 1080A..10835 ; XID_Continue # Lo [44] CYPRIOT SYLLABLE KA..CYPRIOT SYLLABLE WO @@ -10197,7 +10400,9 @@ FFDA..FFDC ; XID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HA 10EC2..10EC4 ; XID_Continue # Lo [3] ARABIC LETTER DAL WITH TWO DOTS VERTICALLY BELOW..ARABIC LETTER KAF WITH TWO DOTS VERTICALLY BELOW 10EC5 ; XID_Continue # Lm ARABIC SMALL YEH BARREE WITH TWO DOTS BELOW 10EC6..10EC7 ; XID_Continue # Lo [2] ARABIC LETTER THIN NOON..ARABIC LETTER YEH WITH FOUR DOTS BELOW -10EFA..10EFF ; XID_Continue # Mn [6] ARABIC DOUBLE VERTICAL BAR BELOW..ARABIC SMALL LOW WORD MADDA +10ECB..10ECF ; XID_Continue # Mn [5] ARABIC NORTHEAST POINTING ARROWHEAD ABOVE..ARABIC LARGE CIRCLE ABOVE +10ED9..10EEE ; XID_Continue # Lo [22] ARABIC CROWN LETTER BEH..ARABIC CROWN LETTER YEH +10EF0..10EFF ; XID_Continue # Mn [16] ARABIC SMALL LOW UPRIGHT RECTANGULAR ZERO..ARABIC SMALL LOW WORD MADDA 10F00..10F1C ; XID_Continue # Lo [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL 10F27 ; XID_Continue # Lo OLD SOGDIAN LIGATURE AYIN-DALETH 10F30..10F45 ; XID_Continue # Lo [22] SOGDIAN LETTER ALEPH..SOGDIAN INDEPENDENT SHIN @@ -10424,6 +10629,7 @@ FFDA..FFDC ; XID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HA 11A98..11A99 ; XID_Continue # Mn [2] SOYOMBO GEMINATION MARK..SOYOMBO SUBJOINER 11A9D ; XID_Continue # Lo SOYOMBO MARK PLUTA 11AB0..11AF8 ; XID_Continue # Lo [73] CANADIAN SYLLABICS NATTILIK HI..PAU CIN HAU GLOTTAL STOP FINAL +11B0A ; XID_Continue # Lo DEVANAGARI LETTER ALTERNATE DDDA 11B60 ; XID_Continue # Mn SHARADA VOWEL SIGN OE 11B61 ; XID_Continue # Mc SHARADA VOWEL SIGN OOE 11B62..11B64 ; XID_Continue # Mn [3] SHARADA VOWEL SIGN UE..SHARADA VOWEL SIGN SHORT E @@ -10474,6 +10680,8 @@ FFDA..FFDC ; XID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HA 11DD9 ; XID_Continue # Lm TOLONG SIKI SIGN SELA 11DDA..11DDB ; XID_Continue # Lo [2] TOLONG SIKI SIGN HECAKA..TOLONG SIKI UNGGA 11DE0..11DE9 ; XID_Continue # Nd [10] TOLONG SIKI DIGIT ZERO..TOLONG SIKI DIGIT NINE +11DF0 ; XID_Continue # Mn BENGALI SIGN COMBINING ANUSVARA ABOVE +11DF1 ; XID_Continue # Lo BENGALI LETTER ALTERNATE BARGIYA BA 11EE0..11EF2 ; XID_Continue # Lo [19] MAKASAR LETTER KA..MAKASAR ANGKA 11EF3..11EF4 ; XID_Continue # Mn [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U 11EF5..11EF6 ; XID_Continue # Mc [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O @@ -10492,8 +10700,10 @@ FFDA..FFDC ; XID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HA 11F5A ; XID_Continue # Mn KAWI SIGN NUKTA 11FB0 ; XID_Continue # Lo LISU LETTER YHA 12000..12399 ; XID_Continue # Lo [922] CUNEIFORM SIGN A..CUNEIFORM SIGN U U -12400..1246E ; XID_Continue # Nl [111] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM +12400..1246F ; XID_Continue # Nl [112] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN SEVEN ASH TENU +12475..1247F ; XID_Continue # Nl [11] CUNEIFORM NUMERIC SIGN EIGHT ASH TENU..CUNEIFORM NUMERIC SIGN ASH TIMES NINE DISH TENU 12480..12543 ; XID_Continue # Lo [196] CUNEIFORM SIGN AB TIMES NUN TENU..CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU +12550..12686 ; XID_Continue # Nl [311] CUNEIFORM NUMERIC SIGN ONE N01..CUNEIFORM NUMERIC SIGN ONE N36 FLAT 12F90..12FF0 ; XID_Continue # Lo [97] CYPRO-MINOAN SIGN CM001..CYPRO-MINOAN SIGN CM114 13000..1342F ; XID_Continue # Lo [1072] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH V011D 13440 ; XID_Continue # Mn EGYPTIAN HIEROGLYPH MIRROR HORIZONTALLY @@ -10538,17 +10748,19 @@ FFDA..FFDC ; XID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HA 16FF0..16FF1 ; XID_Continue # Mc [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY 16FF2..16FF3 ; XID_Continue # Lm [2] CHINESE SMALL SIMPLIFIED ER..CHINESE SMALL TRADITIONAL ER 16FF4..16FF6 ; XID_Continue # Nl [3] YANGQIN SIGN SLOW ONE BEAT..YANGQIN SIGN SLOW TWO BEATS -17000..18CD5 ; XID_Continue # Lo [7382] TANGUT IDEOGRAPH-17000..KHITAN SMALL SCRIPT CHARACTER-18CD5 -18CFF..18D1E ; XID_Continue # Lo [32] KHITAN SMALL SCRIPT CHARACTER-18CFF..TANGUT IDEOGRAPH-18D1E +17000..18CDA ; XID_Continue # Lo [7387] TANGUT IDEOGRAPH-17000..KHITAN SMALL SCRIPT CHARACTER-18CDA +18CFF..18D20 ; XID_Continue # Lo [34] KHITAN SMALL SCRIPT CHARACTER-18CFF..TANGUT IDEOGRAPH-18D20 18D80..18DF2 ; XID_Continue # Lo [115] TANGUT COMPONENT-769..TANGUT COMPONENT-883 +18E00..19191 ; XID_Continue # Lo [914] JURCHEN CHARACTER-18E00..JURCHEN CHARACTER-19191 +191A0..191D2 ; XID_Continue # Lo [51] JURCHEN RADICAL-01..JURCHEN RADICAL-51 1AFF0..1AFF3 ; XID_Continue # Lm [4] KATAKANA LETTER MINNAN TONE-2..KATAKANA LETTER MINNAN TONE-5 1AFF5..1AFFB ; XID_Continue # Lm [7] KATAKANA LETTER MINNAN TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-5 1AFFD..1AFFE ; XID_Continue # Lm [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8 -1B000..1B122 ; XID_Continue # Lo [291] KATAKANA LETTER ARCHAIC E..KATAKANA LETTER ARCHAIC WU +1B000..1B128 ; XID_Continue # Lo [297] KATAKANA LETTER ARCHAIC E..KATAKANA LETTER ALTERNATE WI 1B132 ; XID_Continue # Lo HIRAGANA LETTER SMALL KO 1B150..1B152 ; XID_Continue # Lo [3] HIRAGANA LETTER SMALL WI..HIRAGANA LETTER SMALL WO 1B155 ; XID_Continue # Lo KATAKANA LETTER SMALL KO -1B164..1B167 ; XID_Continue # Lo [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N +1B164..1B168 ; XID_Continue # Lo [5] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL ARCHAIC YE 1B170..1B2FB ; XID_Continue # Lo [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB 1BC00..1BC6A ; XID_Continue # Lo [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M 1BC70..1BC7C ; XID_Continue # Lo [13] DUPLOYAN AFFIX LEFT HORIZONTAL SECANT..DUPLOYAN AFFIX ATTACHED TANGENT HOOK @@ -10558,6 +10770,7 @@ FFDA..FFDC ; XID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HA 1CCF0..1CCF9 ; XID_Continue # Nd [10] OUTLINED DIGIT ZERO..OUTLINED DIGIT NINE 1CF00..1CF2D ; XID_Continue # Mn [46] ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON LEFT..ZNAMENNY COMBINING MARK KRYZH ON LEFT 1CF30..1CF46 ; XID_Continue # Mn [23] ZNAMENNY COMBINING TONAL RANGE MARK MRACHNO..ZNAMENNY PRIZNAK MODIFIER ROG +1D127..1D128 ; XID_Continue # Mn [2] MUSICAL SYMBOL COMBINING STRESS..MUSICAL SYMBOL COMBINING UNSTRESS 1D165..1D166 ; XID_Continue # Mc [2] MUSICAL SYMBOL COMBINING STEM..MUSICAL SYMBOL COMBINING SPRECHGESANG STEM 1D167..1D169 ; XID_Continue # Mn [3] MUSICAL SYMBOL COMBINING TREMOLO-1..MUSICAL SYMBOL COMBINING TREMOLO-3 1D16D..1D172 ; XID_Continue # Mc [6] MUSICAL SYMBOL COMBINING AUGMENTATION DOT..MUSICAL SYMBOL COMBINING FLAG-5 @@ -10565,6 +10778,10 @@ FFDA..FFDC ; XID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HA 1D185..1D18B ; XID_Continue # Mn [7] MUSICAL SYMBOL COMBINING DOIT..MUSICAL SYMBOL COMBINING TRIPLE TONGUE 1D1AA..1D1AD ; XID_Continue # Mn [4] MUSICAL SYMBOL COMBINING DOWN BOW..MUSICAL SYMBOL COMBINING SNAP PIZZICATO 1D242..1D244 ; XID_Continue # Mn [3] COMBINING GREEK MUSICAL TRISEME..COMBINING GREEK MUSICAL PENTASEME +1D250..1D252 ; XID_Continue # Mc [3] MUSICAL SYMBOL COMBINING FLAG-6..MUSICAL SYMBOL COMBINING FLAG-8 +1D25B..1D25C ; XID_Continue # Mn [2] MUSICAL SYMBOL COMBINING TREMOLO-4..MUSICAL SYMBOL COMBINING TREMOLO-5 +1D25F ; XID_Continue # Mc MUSICAL SYMBOL COMBINING BUZZ ROLL STEM +1D280..1D281 ; XID_Continue # Mc [2] MUSICAL SYMBOL COMBINING STEM BOW BEHIND BRIDGE..MUSICAL SYMBOL COMBINING STEM BOW ON TOP OF BRIDGE 1D400..1D454 ; XID_Continue # L& [85] MATHEMATICAL BOLD CAPITAL A..MATHEMATICAL ITALIC SMALL G 1D456..1D49C ; XID_Continue # L& [71] MATHEMATICAL ITALIC SMALL I..MATHEMATICAL SCRIPT CAPITAL A 1D49E..1D49F ; XID_Continue # L& [2] MATHEMATICAL SCRIPT CAPITAL C..MATHEMATICAL SCRIPT CAPITAL D @@ -10583,7 +10800,7 @@ FFDA..FFDC ; XID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HA 1D540..1D544 ; XID_Continue # L& [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M 1D546 ; XID_Continue # L& MATHEMATICAL DOUBLE-STRUCK CAPITAL O 1D54A..1D550 ; XID_Continue # L& [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y -1D552..1D6A5 ; XID_Continue # L& [340] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J +1D552..1D6A6 ; XID_Continue # L& [341] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL LIGATURE LONG S WITH DESCENDER S 1D6A8..1D6C0 ; XID_Continue # L& [25] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL BOLD CAPITAL OMEGA 1D6C2..1D6DA ; XID_Continue # L& [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA 1D6DC..1D6FA ; XID_Continue # L& [31] MATHEMATICAL BOLD EPSILON SYMBOL..MATHEMATICAL ITALIC CAPITAL OMEGA @@ -10604,8 +10821,10 @@ FFDA..FFDC ; XID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HA 1DAA1..1DAAF ; XID_Continue # Mn [15] SIGNWRITING ROTATION MODIFIER-2..SIGNWRITING ROTATION MODIFIER-16 1DF00..1DF09 ; XID_Continue # L& [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK 1DF0A ; XID_Continue # Lo LATIN LETTER RETROFLEX CLICK WITH RETROFLEX HOOK -1DF0B..1DF1E ; XID_Continue # L& [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL -1DF25..1DF2A ; XID_Continue # L& [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK +1DF0B..1DF7F ; XID_Continue # L& [117] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER REVERSED U +1DF80..1DF81 ; XID_Continue # Lo [2] LATIN CAPITAL LETTER A WITH TOPBAR..LATIN CAPITAL LETTER E WITH BENT TOPBAR +1DF90..1DF96 ; XID_Continue # L& [7] LATIN SMALL LETTER C WITH LOW SLASH..LATIN SMALL LETTER LONG S WITH TOP LOOP +1DFCD..1DFFF ; XID_Continue # Lm [51] MODIFIER LETTER SMALL TURNED R WITH MID-HEIGHT LEFT HOOK..MODIFIER LETTER SMALL T WITH HOOK AND RETROFLEX HOOK 1E000..1E006 ; XID_Continue # Mn [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE 1E008..1E018 ; XID_Continue # Mn [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU 1E01B..1E021 ; XID_Continue # Mn [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI @@ -10687,16 +10906,17 @@ FFDA..FFDC ; XID_Continue # Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HA 1EEAB..1EEBB ; XID_Continue # Lo [17] ARABIC MATHEMATICAL DOUBLE-STRUCK LAM..ARABIC MATHEMATICAL DOUBLE-STRUCK GHAIN 1FBF0..1FBF9 ; XID_Continue # Nd [10] SEGMENTED DIGIT ZERO..SEGMENTED DIGIT NINE 20000..2A6DF ; XID_Continue # Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF -2A700..2B81D ; XID_Continue # Lo [4382] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81D +2A700..2B81E ; XID_Continue # Lo [4383] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81E 2B820..2CEAD ; XID_Continue # Lo [5774] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEAD 2CEB0..2EBE0 ; XID_Continue # Lo [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0 2EBF0..2EE5D ; XID_Continue # Lo [622] CJK UNIFIED IDEOGRAPH-2EBF0..CJK UNIFIED IDEOGRAPH-2EE5D 2F800..2FA1D ; XID_Continue # Lo [542] CJK COMPATIBILITY IDEOGRAPH-2F800..CJK COMPATIBILITY IDEOGRAPH-2FA1D 30000..3134A ; XID_Continue # Lo [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A 31350..33479 ; XID_Continue # Lo [8490] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-33479 +3D000..3FC3F ; XID_Continue # Lo [11328] SMALL SEAL CHARACTER-3D000..SMALL SEAL CHARACTER-3FC3F E0100..E01EF ; XID_Continue # Mn [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256 -# Total code points: 149221 +# Total code points: 162081 # ================================================ @@ -10763,7 +10983,7 @@ E01F0..E0FFF ; Default_Ignorable_Code_Point # Cn [3600] .................. -# Total code points: 10583 +# Total code points: 10671 # ================================================ @@ -9720,7 +9821,10 @@ E01F0..E0FFF ; NFKC_CF; # Cn [3600] ................ -# Total code points: 10545 +# Total code points: 10633 # ================================================ @@ -15640,7 +15829,9 @@ E01F0..E0FFF ; NFKC_SCF; # Cn [3600] .............. -# Total code points: 10583 +# Total code points: 10671 # EOF diff --git a/contrib/unicode/EastAsianWidth.txt b/contrib/unicode/EastAsianWidth.txt index 3e46eb65df2e..cfb34b1f09cc 100644 --- a/contrib/unicode/EastAsianWidth.txt +++ b/contrib/unicode/EastAsianWidth.txt @@ -1,6 +1,6 @@ -# EastAsianWidth-17.0.0.txt -# Date: 2025-07-24, 00:12:54 GMT -# © 2025 Unicode®, Inc. +# EastAsianWidth-18.0.0.txt +# Date: 2026-06-29, 15:25:05 GMT +# © 2026 Unicode®, Inc. # Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries. # For terms of use and license, see https://www.unicode.org/terms_of_use.html # @@ -244,11 +244,12 @@ 048A..04FF ; N # L& [118] CYRILLIC CAPITAL LETTER SHORT I WITH TAIL..CYRILLIC SMALL LETTER HA WITH STROKE 0500..052F ; N # L& [48] CYRILLIC CAPITAL LETTER KOMI DE..CYRILLIC SMALL LETTER EL WITH DESCENDER 0531..0556 ; N # Lu [38] ARMENIAN CAPITAL LETTER AYB..ARMENIAN CAPITAL LETTER FEH -0559 ; N # Lm ARMENIAN MODIFIER LETTER LEFT HALF RING +0558..0559 ; N # Lm [2] MODIFIER LETTER ARMENIAN SMALL EH..ARMENIAN MODIFIER LETTER LEFT HALF RING 055A..055F ; N # Po [6] ARMENIAN APOSTROPHE..ARMENIAN ABBREVIATION MARK 0560..0588 ; N # Ll [41] ARMENIAN SMALL LETTER TURNED AYB..ARMENIAN SMALL LETTER YI WITH STROKE 0589 ; N # Po ARMENIAN FULL STOP 058A ; N # Pd ARMENIAN HYPHEN +058B..058C ; N # Lm [2] MODIFIER LETTER ARMENIAN SMALL INI..MODIFIER LETTER ARMENIAN SMALL YI 058D..058E ; N # So [2] RIGHT-FACING ARMENIAN ETERNITY SIGN..LEFT-FACING ARMENIAN ETERNITY SIGN 058F ; N # Sc ARMENIAN DRAM SIGN 0591..05BD ; N # Mn [45] HEBREW ACCENT ETNAHTA..HEBREW POINT METEG @@ -259,7 +260,7 @@ 05C3 ; N # Po HEBREW PUNCTUATION SOF PASUQ 05C4..05C5 ; N # Mn [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT 05C6 ; N # Po HEBREW PUNCTUATION NUN HAFUKHA -05C7 ; N # Mn HEBREW POINT QAMATS QATAN +05C7..05C9 ; N # Mn [3] HEBREW POINT QAMATS QATAN..HEBREW POINT DAGESH HAZAQ MUDGASH 05D0..05EA ; N # Lo [27] HEBREW LETTER ALEF..HEBREW LETTER TAV 05EF..05F2 ; N # Lo [4] HEBREW YOD TRIANGLE..HEBREW LIGATURE YIDDISH DOUBLE YOD 05F3..05F4 ; N # Po [2] HEBREW PUNCTUATION GERESH..HEBREW PUNCTUATION GERSHAYIM @@ -454,7 +455,7 @@ 0B47..0B48 ; N # Mc [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SIGN AI 0B4B..0B4C ; N # Mc [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SIGN AU 0B4D ; N # Mn ORIYA SIGN VIRAMA -0B55..0B56 ; N # Mn [2] ORIYA SIGN OVERLINE..ORIYA AI LENGTH MARK +0B53..0B56 ; N # Mn [4] ORIYA SIGN DOT ABOVE..ORIYA AI LENGTH MARK 0B57 ; N # Mc ORIYA AU LENGTH MARK 0B5C..0B5D ; N # Lo [2] ORIYA LETTER RRA..ORIYA LETTER RHA 0B5F..0B61 ; N # Lo [3] ORIYA LETTER YYA..ORIYA LETTER VOCALIC LL @@ -806,8 +807,7 @@ 1AA8..1AAD ; N # Po [6] TAI THAM SIGN KAAN..TAI THAM SIGN CAANG 1AB0..1ABD ; N # Mn [14] COMBINING DOUBLED CIRCUMFLEX ACCENT..COMBINING PARENTHESES BELOW 1ABE ; N # Me COMBINING PARENTHESES OVERLAY -1ABF..1ADD ; N # Mn [31] COMBINING LATIN SMALL LETTER W BELOW..COMBINING DOT-AND-RING BELOW -1AE0..1AEB ; N # Mn [12] COMBINING LEFT TACK ABOVE..COMBINING DOUBLE RIGHTWARDS ARROW ABOVE +1ABF..1AF0 ; N # Mn [50] COMBINING LATIN SMALL LETTER W BELOW..COMBINING DOUBLE COMMA ABOVE 1B00..1B03 ; N # Mn [4] BALINESE SIGN ULU RICEM..BALINESE SIGN SURANG 1B04 ; N # Mc BALINESE SIGN BISAH 1B05..1B33 ; N # Lo [47] BALINESE LETTER AKARA..BALINESE LETTER HA @@ -972,12 +972,12 @@ 208A..208C ; N # Sm [3] SUBSCRIPT PLUS SIGN..SUBSCRIPT EQUALS SIGN 208D ; N # Ps SUBSCRIPT LEFT PARENTHESIS 208E ; N # Pe SUBSCRIPT RIGHT PARENTHESIS -2090..209C ; N # Lm [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T +208F..209F ; N # Lm [17] MODIFIER LETTER HIGH AND LOW VERTICAL LINE..LATIN SUBSCRIPT SMALL LETTER Z 20A0..20A8 ; N # Sc [9] EURO-CURRENCY SIGN..RUPEE SIGN 20A9 ; H # Sc WON SIGN 20AA..20AB ; N # Sc [2] NEW SHEQEL SIGN..DONG SIGN 20AC ; A # Sc EURO SIGN -20AD..20C1 ; N # Sc [21] KIP SIGN..SAUDI RIYAL SIGN +20AD..20C4 ; N # Sc [24] KIP SIGN..OMANI RIAL SIGN 20D0..20DC ; N # Mn [13] COMBINING LEFT HARPOON ABOVE..COMBINING FOUR DOTS ABOVE 20DD..20E0 ; N # Me [4] COMBINING ENCLOSING CIRCLE..COMBINING ENCLOSING CIRCLE BACKSLASH 20E1 ; N # Mn COMBINING LEFT RIGHT ARROW ABOVE @@ -1431,6 +1431,9 @@ 2E5B ; N # Ps BOTTOM HALF LEFT PARENTHESIS 2E5C ; N # Pe BOTTOM HALF RIGHT PARENTHESIS 2E5D ; N # Pd OBLIQUE HYPHEN +2E60..2E61 ; N # Po [2] WIGGLY EXCLAMATION MARK..INVERTED WIGGLY EXCLAMATION MARK +2E62 ; N # Ps LEFT PARENTHESIS WITH MIDDLE RING +2E63 ; N # Pe RIGHT PARENTHESIS WITH MIDDLE RING 2E80..2E99 ; W # So [26] CJK RADICAL REPEAT..CJK RADICAL RAP 2E9B..2EF3 ; W # So [89] CJK RADICAL CHOKE..CJK RADICAL C-SIMPLIFIED TURTLE 2F00..2FD5 ; W # So [214] KANGXI RADICAL ONE..KANGXI RADICAL FLUTE @@ -1548,7 +1551,8 @@ A788 ; N # Lm MODIFIER LETTER LOW CIRCUMFLEX ACCENT A789..A78A ; N # Sk [2] MODIFIER LETTER COLON..MODIFIER LETTER SHORT EQUALS SIGN A78B..A78E ; N # L& [4] LATIN CAPITAL LETTER SALTILLO..LATIN SMALL LETTER L WITH RETROFLEX HOOK AND BELT A78F ; N # Lo LATIN LETTER SINOLOGICAL DOT -A790..A7DC ; N # L& [77] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN CAPITAL LETTER LAMBDA WITH STROKE +A790..A7DD ; N # L& [78] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN CAPITAL LETTER CLOSED OMEGA +A7E2 ; N # Lu LATIN CAPITAL LETTER R WITH LONG LEG A7F1..A7F4 ; N # Lm [4] MODIFIER LETTER CAPITAL S..MODIFIER LETTER CAPITAL Q A7F5..A7F6 ; N # L& [2] LATIN CAPITAL LETTER REVERSED HALF H..LATIN SMALL LETTER REVERSED HALF H A7F7 ; N # Lo LATIN EPIGRAPHIC LETTER SIDEWAYS I @@ -1670,6 +1674,7 @@ AB5C..AB5F ; N # Lm [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMA AB60..AB68 ; N # Ll [9] LATIN SMALL LETTER SAKHA YAT..LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE AB69 ; N # Lm MODIFIER LETTER SMALL TURNED W AB6A..AB6B ; N # Sk [2] MODIFIER LETTER LEFT TACK..MODIFIER LETTER RIGHT TACK +AB6C..AB6D ; N # Lu [2] LATIN CAPITAL LETTER SCRIPT R..LATIN CAPITAL LETTER SCRIPT R WITH RING AB70..ABBF ; N # Ll [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA ABC0..ABE2 ; N # Lo [35] MEETEI MAYEK LETTER KOK..MEETEI MAYEK LETTER I LONSUM ABE3..ABE4 ; N # Mc [2] MEETEI MAYEK VOWEL SIGN ONAP..MEETEI MAYEK VOWEL SIGN INAP @@ -1880,7 +1885,7 @@ FFFD ; A # So REPLACEMENT CHARACTER 10760..10767 ; N # Lo [8] LINEAR A SIGN A800..LINEAR A SIGN A807 10780..10785 ; N # Lm [6] MODIFIER LETTER SMALL CAPITAL AA..MODIFIER LETTER SMALL B WITH HOOK 10787..107B0 ; N # Lm [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK -107B2..107BA ; N # Lm [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL +107B2..107BF ; N # Lm [14] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL ESH WITH DOUBLE BAR 10800..10805 ; N # Lo [6] CYPRIOT SYLLABLE A..CYPRIOT SYLLABLE JA 10808 ; N # Lo CYPRIOT SYLLABLE JO 1080A..10835 ; N # Lo [44] CYPRIOT SYLLABLE KA..CYPRIOT SYLLABLE WO @@ -1966,9 +1971,12 @@ FFFD ; A # So REPLACEMENT CHARACTER 10EC2..10EC4 ; N # Lo [3] ARABIC LETTER DAL WITH TWO DOTS VERTICALLY BELOW..ARABIC LETTER KAF WITH TWO DOTS VERTICALLY BELOW 10EC5 ; N # Lm ARABIC SMALL YEH BARREE WITH TWO DOTS BELOW 10EC6..10EC7 ; N # Lo [2] ARABIC LETTER THIN NOON..ARABIC LETTER YEH WITH FOUR DOTS BELOW +10EC9..10ECA ; N # Sk [2] ARABIC SMALL BASELINE FATHA..ARABIC SMALL BASELINE DOTLESS HEAD OF KHAH +10ECB..10ECF ; N # Mn [5] ARABIC NORTHEAST POINTING ARROWHEAD ABOVE..ARABIC LARGE CIRCLE ABOVE 10ED0 ; N # Po ARABIC BIBLICAL END OF VERSE 10ED1..10ED8 ; N # So [8] ARABIC LIGATURE ALAYHAA AS-SALAATU WAS-SALAAM..ARABIC LIGATURE NAWWARA ALLAAHU MARQADAH -10EFA..10EFF ; N # Mn [6] ARABIC DOUBLE VERTICAL BAR BELOW..ARABIC SMALL LOW WORD MADDA +10ED9..10EEE ; N # Lo [22] ARABIC CROWN LETTER BEH..ARABIC CROWN LETTER YEH +10EF0..10EFF ; N # Mn [16] ARABIC SMALL LOW UPRIGHT RECTANGULAR ZERO..ARABIC SMALL LOW WORD MADDA 10F00..10F1C ; N # Lo [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL 10F1D..10F26 ; N # No [10] OLD SOGDIAN NUMBER ONE..OLD SOGDIAN FRACTION ONE HALF 10F27 ; N # Lo OLD SOGDIAN LIGATURE AYIN-DALETH @@ -2239,6 +2247,7 @@ FFFD ; A # So REPLACEMENT CHARACTER 11AB0..11ABF ; N # Lo [16] CANADIAN SYLLABICS NATTILIK HI..CANADIAN SYLLABICS SPA 11AC0..11AF8 ; N # Lo [57] PAU CIN HAU LETTER PA..PAU CIN HAU GLOTTAL STOP FINAL 11B00..11B09 ; N # Po [10] DEVANAGARI HEAD MARK..DEVANAGARI SIGN MINDU +11B0A ; N # Lo DEVANAGARI LETTER ALTERNATE DDDA 11B60 ; N # Mn SHARADA VOWEL SIGN OE 11B61 ; N # Mc SHARADA VOWEL SIGN OOE 11B62..11B64 ; N # Mn [3] SHARADA VOWEL SIGN UE..SHARADA VOWEL SIGN SHORT E @@ -2293,6 +2302,8 @@ FFFD ; A # So REPLACEMENT CHARACTER 11DD9 ; N # Lm TOLONG SIKI SIGN SELA 11DDA..11DDB ; N # Lo [2] TOLONG SIKI SIGN HECAKA..TOLONG SIKI UNGGA 11DE0..11DE9 ; N # Nd [10] TOLONG SIKI DIGIT ZERO..TOLONG SIKI DIGIT NINE +11DF0 ; N # Mn BENGALI SIGN COMBINING ANUSVARA ABOVE +11DF1 ; N # Lo BENGALI LETTER ALTERNATE BARGIYA BA 11EE0..11EF2 ; N # Lo [19] MAKASAR LETTER KA..MAKASAR ANGKA 11EF3..11EF4 ; N # Mn [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U 11EF5..11EF6 ; N # Mc [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O @@ -2318,9 +2329,11 @@ FFFD ; A # So REPLACEMENT CHARACTER 11FE1..11FF1 ; N # So [17] TAMIL SIGN PAARAM..TAMIL SIGN VAKAIYARAA 11FFF ; N # Po TAMIL PUNCTUATION END OF TEXT 12000..12399 ; N # Lo [922] CUNEIFORM SIGN A..CUNEIFORM SIGN U U -12400..1246E ; N # Nl [111] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM +12400..1246F ; N # Nl [112] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN SEVEN ASH TENU 12470..12474 ; N # Po [5] CUNEIFORM PUNCTUATION SIGN OLD ASSYRIAN WORD DIVIDER..CUNEIFORM PUNCTUATION SIGN DIAGONAL QUADCOLON +12475..1247F ; N # Nl [11] CUNEIFORM NUMERIC SIGN EIGHT ASH TENU..CUNEIFORM NUMERIC SIGN ASH TIMES NINE DISH TENU 12480..12543 ; N # Lo [196] CUNEIFORM SIGN AB TIMES NUN TENU..CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU +12550..12686 ; N # Nl [311] CUNEIFORM NUMERIC SIGN ONE N01..CUNEIFORM NUMERIC SIGN ONE N36 FLAT 12F90..12FF0 ; N # Lo [97] CYPRO-MINOAN SIGN CM001..CYPRO-MINOAN SIGN CM114 12FF1..12FF2 ; N # Po [2] CYPRO-MINOAN SIGN CM301..CYPRO-MINOAN SIGN CM302 13000..1342F ; N # Lo [1072] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH V011D @@ -2380,19 +2393,21 @@ FFFD ; A # So REPLACEMENT CHARACTER 16FF4..16FF6 ; W # Nl [3] YANGQIN SIGN SLOW ONE BEAT..YANGQIN SIGN SLOW TWO BEATS 17000..187FF ; W # Lo [6144] TANGUT IDEOGRAPH-17000..TANGUT IDEOGRAPH-187FF 18800..18AFF ; W # Lo [768] TANGUT COMPONENT-001..TANGUT COMPONENT-768 -18B00..18CD5 ; W # Lo [470] KHITAN SMALL SCRIPT CHARACTER-18B00..KHITAN SMALL SCRIPT CHARACTER-18CD5 +18B00..18CDA ; W # Lo [475] KHITAN SMALL SCRIPT CHARACTER-18B00..KHITAN SMALL SCRIPT CHARACTER-18CDA 18CFF ; W # Lo KHITAN SMALL SCRIPT CHARACTER-18CFF -18D00..18D1E ; W # Lo [31] TANGUT IDEOGRAPH-18D00..TANGUT IDEOGRAPH-18D1E +18D00..18D20 ; W # Lo [33] TANGUT IDEOGRAPH-18D00..TANGUT IDEOGRAPH-18D20 18D80..18DF2 ; W # Lo [115] TANGUT COMPONENT-769..TANGUT COMPONENT-883 +18E00..19191 ; W # Lo [914] JURCHEN CHARACTER-18E00..JURCHEN CHARACTER-19191 +191A0..191D2 ; W # Lo [51] JURCHEN RADICAL-01..JURCHEN RADICAL-51 1AFF0..1AFF3 ; W # Lm [4] KATAKANA LETTER MINNAN TONE-2..KATAKANA LETTER MINNAN TONE-5 1AFF5..1AFFB ; W # Lm [7] KATAKANA LETTER MINNAN TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-5 1AFFD..1AFFE ; W # Lm [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8 1B000..1B0FF ; W # Lo [256] KATAKANA LETTER ARCHAIC E..HENTAIGANA LETTER RE-2 -1B100..1B122 ; W # Lo [35] HENTAIGANA LETTER RE-3..KATAKANA LETTER ARCHAIC WU +1B100..1B128 ; W # Lo [41] HENTAIGANA LETTER RE-3..KATAKANA LETTER ALTERNATE WI 1B132 ; W # Lo HIRAGANA LETTER SMALL KO 1B150..1B152 ; W # Lo [3] HIRAGANA LETTER SMALL WI..HIRAGANA LETTER SMALL WO 1B155 ; W # Lo KATAKANA LETTER SMALL KO -1B164..1B167 ; W # Lo [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N +1B164..1B168 ; W # Lo [5] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL ARCHAIC YE 1B170..1B2FB ; W # Lo [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB 1BC00..1BC6A ; N # Lo [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M 1BC70..1BC7C ; N # Lo [13] DUPLOYAN AFFIX LEFT HORIZONTAL SECANT..DUPLOYAN AFFIX ATTACHED TANGENT HOOK @@ -2408,13 +2423,16 @@ FFFD ; A # So REPLACEMENT CHARACTER 1CD00..1CEB3 ; N # So [436] BLOCK OCTANT-3..BLACK RIGHT TRIANGLE CARET 1CEBA..1CEBF ; N # So [6] FRAGILE SYMBOL..STRAWBERRY SYMBOL 1CEC0..1CED0 ; N # So [17] HEBE..LEUKOTHEA +1CED2..1CED4 ; N # So [3] ALCHEMICAL SYMBOL FOR OIL INVERTED..ALCHEMICAL SYMBOL FOR SALT OF TARTAR +1CEDD..1CEDF ; N # Sm [3] SQUARE ROOT OF SQUARE ROOT..SQUARE ROOT OF SQUARE ROOT OF SQUARE ROOT OF SQUARE ROOT 1CEE0..1CEEF ; N # So [16] GEOMANTIC FIGURE POPULUS..GEOMANTIC FIGURE VIA -1CEF0 ; N # Sm MEDIUM SMALL WHITE CIRCLE WITH HORIZONTAL BAR +1CEF0..1CEFD ; N # Sm [14] MEDIUM SMALL WHITE CIRCLE WITH HORIZONTAL BAR..HYPERBOLA 1CF00..1CF2D ; N # Mn [46] ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON LEFT..ZNAMENNY COMBINING MARK KRYZH ON LEFT 1CF30..1CF46 ; N # Mn [23] ZNAMENNY COMBINING TONAL RANGE MARK MRACHNO..ZNAMENNY PRIZNAK MODIFIER ROG 1CF50..1CFC3 ; N # So [116] ZNAMENNY NEUME KRYUK..ZNAMENNY NEUME PAUK 1D000..1D0F5 ; N # So [246] BYZANTINE MUSICAL SYMBOL PSILI..BYZANTINE MUSICAL SYMBOL GORGON NEO KATO 1D100..1D126 ; N # So [39] MUSICAL SYMBOL SINGLE BARLINE..MUSICAL SYMBOL DRUM CLEF-2 +1D127..1D128 ; N # Mn [2] MUSICAL SYMBOL COMBINING STRESS..MUSICAL SYMBOL COMBINING UNSTRESS 1D129..1D164 ; N # So [60] MUSICAL SYMBOL MULTIPLE MEASURE REST..MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH NOTE 1D165..1D166 ; N # Mc [2] MUSICAL SYMBOL COMBINING STEM..MUSICAL SYMBOL COMBINING SPRECHGESANG STEM 1D167..1D169 ; N # Mn [3] MUSICAL SYMBOL COMBINING TREMOLO-1..MUSICAL SYMBOL COMBINING TREMOLO-3 @@ -2426,10 +2444,17 @@ FFFD ; A # So REPLACEMENT CHARACTER 1D185..1D18B ; N # Mn [7] MUSICAL SYMBOL COMBINING DOIT..MUSICAL SYMBOL COMBINING TRIPLE TONGUE 1D18C..1D1A9 ; N # So [30] MUSICAL SYMBOL RINFORZANDO..MUSICAL SYMBOL DEGREE SLASH 1D1AA..1D1AD ; N # Mn [4] MUSICAL SYMBOL COMBINING DOWN BOW..MUSICAL SYMBOL COMBINING SNAP PIZZICATO -1D1AE..1D1EA ; N # So [61] MUSICAL SYMBOL PEDAL MARK..MUSICAL SYMBOL KORON +1D1AE..1D1FF ; N # So [82] MUSICAL SYMBOL PEDAL MARK..MUSICAL SYMBOL LONGA REST 1D200..1D241 ; N # So [66] GREEK VOCAL NOTATION SYMBOL-1..GREEK INSTRUMENTAL NOTATION SYMBOL-54 1D242..1D244 ; N # Mn [3] COMBINING GREEK MUSICAL TRISEME..COMBINING GREEK MUSICAL PENTASEME 1D245 ; N # So GREEK MUSICAL LEIMMA +1D250..1D252 ; N # Mc [3] MUSICAL SYMBOL COMBINING FLAG-6..MUSICAL SYMBOL COMBINING FLAG-8 +1D253..1D25A ; N # So [8] MUSICAL SYMBOL TWO HUNDRED FIFTY-SIXTH REST..MUSICAL SYMBOL SHARP WITH STROKE +1D25B..1D25C ; N # Mn [2] MUSICAL SYMBOL COMBINING TREMOLO-4..MUSICAL SYMBOL COMBINING TREMOLO-5 +1D25D..1D25E ; N # So [2] MUSICAL SYMBOL FINGERED TREMOLO-4..MUSICAL SYMBOL FINGERED TREMOLO-5 +1D25F ; N # Mc MUSICAL SYMBOL COMBINING BUZZ ROLL STEM +1D260..1D27F ; N # So [32] MUSICAL SYMBOL TRIPLE FLAT..MUSICAL SYMBOL ARPEGGIATO UP WITH ARROW +1D280..1D281 ; N # Mc [2] MUSICAL SYMBOL COMBINING STEM BOW BEHIND BRIDGE..MUSICAL SYMBOL COMBINING STEM BOW ON TOP OF BRIDGE 1D2C0..1D2D3 ; N # No [20] KAKTOVIK NUMERAL ZERO..KAKTOVIK NUMERAL NINETEEN 1D2E0..1D2F3 ; N # No [20] MAYAN NUMERAL ZERO..MAYAN NUMERAL NINETEEN 1D300..1D356 ; W # So [87] MONOGRAM FOR EARTH..TETRAGRAM FOR FOSTERING @@ -2453,7 +2478,7 @@ FFFD ; A # So REPLACEMENT CHARACTER 1D540..1D544 ; N # Lu [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M 1D546 ; N # Lu MATHEMATICAL DOUBLE-STRUCK CAPITAL O 1D54A..1D550 ; N # Lu [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y -1D552..1D6A5 ; N # L& [340] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J +1D552..1D6A6 ; N # L& [341] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL LIGATURE LONG S WITH DESCENDER S 1D6A8..1D6C0 ; N # Lu [25] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL BOLD CAPITAL OMEGA 1D6C1 ; N # Sm MATHEMATICAL BOLD NABLA 1D6C2..1D6DA ; N # Ll [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA @@ -2488,10 +2513,13 @@ FFFD ; A # So REPLACEMENT CHARACTER 1DA87..1DA8B ; N # Po [5] SIGNWRITING COMMA..SIGNWRITING PARENTHESIS 1DA9B..1DA9F ; N # Mn [5] SIGNWRITING FILL MODIFIER-2..SIGNWRITING FILL MODIFIER-6 1DAA1..1DAAF ; N # Mn [15] SIGNWRITING ROTATION MODIFIER-2..SIGNWRITING ROTATION MODIFIER-16 +1DB00..1DB1C ; N # Sm [29] LEIBNIZIAN EQUALS SIGN..FACIT SYMBOL 1DF00..1DF09 ; N # Ll [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK 1DF0A ; N # Lo LATIN LETTER RETROFLEX CLICK WITH RETROFLEX HOOK -1DF0B..1DF1E ; N # Ll [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL -1DF25..1DF2A ; N # Ll [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK +1DF0B..1DF7F ; N # L& [117] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER REVERSED U +1DF80..1DF81 ; N # Lo [2] LATIN CAPITAL LETTER A WITH TOPBAR..LATIN CAPITAL LETTER E WITH BENT TOPBAR +1DF90..1DF96 ; N # Ll [7] LATIN SMALL LETTER C WITH LOW SLASH..LATIN SMALL LETTER LONG S WITH TOP LOOP +1DFCD..1DFFF ; N # Lm [51] MODIFIER LETTER SMALL TURNED R WITH MID-HEIGHT LEFT HOOK..MODIFIER LETTER SMALL T WITH HOOK AND RETROFLEX HOOK 1E000..1E006 ; N # Mn [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE 1E008..1E018 ; N # Mn [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU 1E01B..1E021 ; N # Mn [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI @@ -2607,6 +2635,7 @@ FFFD ; A # So REPLACEMENT CHARACTER 1F191..1F19A ; W # So [10] SQUARED CL..SQUARED VS 1F19B..1F1AC ; A # So [18] SQUARED THREE D..SQUARED VOD 1F1AD ; N # So MASK WORK SYMBOL +1F1AE ; W # So TOMOBIKI SYMBOL 1F1E6..1F1FF ; N # So [26] REGIONAL INDICATOR SYMBOL LETTER A..REGIONAL INDICATOR SYMBOL LETTER Z 1F200..1F202 ; W # So [3] SQUARE HIRAGANA HOKA..SQUARED KATAKANA SA 1F210..1F23B ; W # So [44] SQUARED CJK UNIFIED IDEOGRAPH-624B..SQUARED CJK UNIFIED IDEOGRAPH-914D @@ -2658,7 +2687,7 @@ FFFD ; A # So REPLACEMENT CHARACTER 1F6CD..1F6CF ; N # So [3] SHOPPING BAGS..BED 1F6D0..1F6D2 ; W # So [3] PLACE OF WORSHIP..SHOPPING TROLLEY 1F6D3..1F6D4 ; N # So [2] STUPA..PAGODA -1F6D5..1F6D8 ; W # So [4] HINDU TEMPLE..LANDSLIDE +1F6D5..1F6D9 ; W # So [5] HINDU TEMPLE..LIGHTHOUSE 1F6DC..1F6DF ; W # So [4] WIRELESS..RING BUOY 1F6E0..1F6EA ; N # So [11] HAMMER AND WRENCH..NORTHEAST-POINTING AIRPLANE 1F6EB..1F6EC ; W # So [2] AIRPLANE DEPARTURE..AIRPLANE ARRIVING @@ -2666,8 +2695,11 @@ FFFD ; A # So REPLACEMENT CHARACTER 1F6F4..1F6FC ; W # So [9] SCOOTER..ROLLER SKATE 1F700..1F77F ; N # So [128] ALCHEMICAL SYMBOL FOR QUINTESSENCE..ORCUS 1F780..1F7D9 ; N # So [90] BLACK LEFT-POINTING ISOSCELES RIGHT TRIANGLE..NINE POINTED WHITE STAR +1F7DA ; W # So BLACK CIRCLE WITH WHITE VERTICAL BAR +1F7DB ; N # So BULLET IN DOUBLE CIRCLE 1F7E0..1F7EB ; W # So [12] LARGE ORANGE CIRCLE..LARGE BROWN SQUARE 1F7F0 ; W # So HEAVY EQUALS SIGN +1F7F1..1F7FF ; N # So [15] CIRCLE WITH DOUBLE VERTICAL AND HORIZONTAL LINE..RHOMBUS 1F800..1F80B ; N # So [12] LEFTWARDS ARROW WITH SMALL TRIANGLE ARROWHEAD..DOWNWARDS ARROW WITH LARGE TRIANGLE ARROWHEAD 1F810..1F847 ; N # So [56] LEFTWARDS ARROW WITH SMALL EQUILATERAL ARROWHEAD..DOWNWARDS HEAVY ARROW 1F850..1F859 ; N # So [10] LEFTWARDS SANS-SERIF ARROW..UP DOWN SANS-SERIF ARROW @@ -2685,20 +2717,19 @@ FFFD ; A # So REPLACEMENT CHARACTER 1FA00..1FA57 ; N # So [88] NEUTRAL CHESS KING..BLACK CHESS ALFIL 1FA60..1FA6D ; N # So [14] XIANGQI RED GENERAL..XIANGQI BLACK SOLDIER 1FA70..1FA7C ; W # So [13] BALLET SHOES..CRUTCH -1FA80..1FA8A ; W # So [11] YO-YO..TROMBONE -1FA8E..1FAC6 ; W # So [57] TREASURE CHEST..FINGERPRINT +1FA80..1FAC6 ; W # So [71] YO-YO..FINGERPRINT 1FAC8 ; W # So HAIRY CREATURE -1FACD..1FADC ; W # So [16] ORCA..ROOT VEGETABLE -1FADF..1FAEA ; W # So [12] SPLATTER..DISTORTED FACE -1FAEF..1FAF8 ; W # So [10] FIGHT CLOUD..RIGHTWARDS PUSHING HAND +1FACC..1FADD ; W # So [18] MONARCH BUTTERFLY..PICKLE +1FADF..1FAEB ; W # So [13] SPLATTER..CRACKING FACE +1FAEF..1FAFA ; W # So [12] FIGHT CLOUD..RIGHTWARDS THUMB SIGN 1FB00..1FB92 ; N # So [147] BLOCK SEXTANT-1..UPPER HALF INVERSE MEDIUM SHADE AND LOWER HALF BLOCK 1FB94..1FBEF ; N # So [92] LEFT HALF INVERSE MEDIUM SHADE AND RIGHT HALF BLOCK..TOP LEFT JUSTIFIED LOWER RIGHT QUARTER BLACK CIRCLE 1FBF0..1FBF9 ; N # Nd [10] SEGMENTED DIGIT ZERO..SEGMENTED DIGIT NINE 1FBFA ; N # So ALARM BELL SYMBOL 20000..2A6DF ; W # Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF 2A6E0..2A6FF ; W # Cn [32] .. -2A700..2B81D ; W # Lo [4382] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81D -2B81E..2B81F ; W # Cn [2] .. +2A700..2B81E ; W # Lo [4383] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81E +2B81F ; W # Cn 2B820..2CEAD ; W # Lo [5774] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEAD 2CEAE..2CEAF ; W # Cn [2] .. 2CEB0..2EBE0 ; W # Lo [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0 @@ -2711,7 +2742,9 @@ FFFD ; A # So REPLACEMENT CHARACTER 30000..3134A ; W # Lo [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A 3134B..3134F ; W # Cn [5] .. 31350..33479 ; W # Lo [8490] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-33479 -3347A..3FFFD ; W # Cn [52100] .. +3347A..3CFFF ; W # Cn [39814] .. +3D000..3FC3F ; W # Lo [11328] SMALL SEAL CHARACTER-3D000..SMALL SEAL CHARACTER-3FC3F +3FC40..3FFFD ; W # Cn [958] .. E0001 ; N # Cf LANGUAGE TAG E0020..E007F ; N # Cf [96] TAG SPACE..CANCEL TAG E0100..E01EF ; A # Mn [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256 diff --git a/contrib/unicode/HangulSyllableType.txt b/contrib/unicode/HangulSyllableType.txt index 8c3cf4a73672..f04f49d2550b 100644 --- a/contrib/unicode/HangulSyllableType.txt +++ b/contrib/unicode/HangulSyllableType.txt @@ -1,6 +1,6 @@ -# HangulSyllableType-17.0.0.txt -# Date: 2025-01-27, 18:09:16 GMT -# © 2025 Unicode®, Inc. +# HangulSyllableType-18.0.0.txt +# Date: 2026-02-03, 23:09:57 GMT +# © 2026 Unicode®, Inc. # Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries. # For terms of use and license, see https://www.unicode.org/terms_of_use.html # diff --git a/contrib/unicode/NameAliases.txt b/contrib/unicode/NameAliases.txt index 09df7d666f12..dcbdcac4a66a 100644 --- a/contrib/unicode/NameAliases.txt +++ b/contrib/unicode/NameAliases.txt @@ -1,6 +1,6 @@ -# NameAliases-17.0.0.txt -# Date: 2025-04-23 -# © 2025 Unicode®, Inc. +# NameAliases-18.0.0.txt +# Date: 2026-02-03 +# © 2026 Unicode®, Inc. # Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries. # For terms of use and license, see https://www.unicode.org/terms_of_use.html # diff --git a/contrib/unicode/PropList.txt b/contrib/unicode/PropList.txt index e64b4224d727..3f1b6ec294fe 100644 --- a/contrib/unicode/PropList.txt +++ b/contrib/unicode/PropList.txt @@ -1,6 +1,6 @@ -# PropList-17.0.0.txt -# Date: 2025-06-30, 06:19:01 GMT -# © 2025 Unicode®, Inc. +# PropList-18.0.0.txt +# Date: 2026-08-07, 16:20:14 GMT +# © 2026 Unicode®, Inc. # Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries. # For terms of use and license, see https://www.unicode.org/terms_of_use.html # @@ -167,6 +167,7 @@ FF63 ; Quotation_Mark # Pe HALFWIDTH RIGHT CORNER BRACKET 2E4C ; Terminal_Punctuation # Po MEDIEVAL COMMA 2E4E..2E4F ; Terminal_Punctuation # Po [2] PUNCTUS ELEVATUS MARK..CORNISH VERSE DIVIDER 2E53..2E54 ; Terminal_Punctuation # Po [2] MEDIEVAL EXCLAMATION MARK..MEDIEVAL QUESTION MARK +2E60..2E61 ; Terminal_Punctuation # Po [2] WIGGLY EXCLAMATION MARK..INVERTED WIGGLY EXCLAMATION MARK 3001..3002 ; Terminal_Punctuation # Po [2] IDEOGRAPHIC COMMA..IDEOGRAPHIC FULL STOP A4FE..A4FF ; Terminal_Punctuation # Po [2] LISU PUNCTUATION COMMA..LISU PUNCTUATION FULL STOP A60D..A60F ; Terminal_Punctuation # Po [3] VAI COMMA..VAI QUESTION MARK @@ -234,7 +235,7 @@ FF64 ; Terminal_Punctuation # Po HALFWIDTH IDEOGRAPHIC COMMA 1BC9F ; Terminal_Punctuation # Po DUPLOYAN PUNCTUATION CHINOOK FULL STOP 1DA87..1DA8A ; Terminal_Punctuation # Po [4] SIGNWRITING COMMA..SIGNWRITING COLON -# Total code points: 291 +# Total code points: 293 # ================================================ @@ -368,7 +369,7 @@ FF3E ; Other_Math # Sk FULLWIDTH CIRCUMFLEX ACCENT 1D540..1D544 ; Other_Math # L& [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M 1D546 ; Other_Math # L& MATHEMATICAL DOUBLE-STRUCK CAPITAL O 1D54A..1D550 ; Other_Math # L& [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y -1D552..1D6A5 ; Other_Math # L& [340] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J +1D552..1D6A6 ; Other_Math # L& [341] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL LIGATURE LONG S WITH DESCENDER S 1D6A8..1D6C0 ; Other_Math # L& [25] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL BOLD CAPITAL OMEGA 1D6C2..1D6DA ; Other_Math # L& [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA 1D6DC..1D6FA ; Other_Math # L& [31] MATHEMATICAL BOLD EPSILON SYMBOL..MATHEMATICAL ITALIC CAPITAL OMEGA @@ -414,8 +415,10 @@ FF3E ; Other_Math # Sk FULLWIDTH CIRCUMFLEX ACCENT 1EEA1..1EEA3 ; Other_Math # Lo [3] ARABIC MATHEMATICAL DOUBLE-STRUCK BEH..ARABIC MATHEMATICAL DOUBLE-STRUCK DAL 1EEA5..1EEA9 ; Other_Math # Lo [5] ARABIC MATHEMATICAL DOUBLE-STRUCK WAW..ARABIC MATHEMATICAL DOUBLE-STRUCK YEH 1EEAB..1EEBB ; Other_Math # Lo [17] ARABIC MATHEMATICAL DOUBLE-STRUCK LAM..ARABIC MATHEMATICAL DOUBLE-STRUCK GHAIN +1F7DB ; Other_Math # So BULLET IN DOUBLE CIRCLE +1F7F1..1F7FF ; Other_Math # So [15] CIRCLE WITH DOUBLE VERTICAL AND HORIZONTAL LINE..RHOMBUS -# Total code points: 1362 +# Total code points: 1379 # ================================================ @@ -444,7 +447,7 @@ FF41..FF46 ; Hex_Digit # L& [6] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH L 05BF ; Other_Alphabetic # Mn HEBREW POINT RAFE 05C1..05C2 ; Other_Alphabetic # Mn [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT 05C4..05C5 ; Other_Alphabetic # Mn [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT -05C7 ; Other_Alphabetic # Mn HEBREW POINT QAMATS QATAN +05C7..05C9 ; Other_Alphabetic # Mn [3] HEBREW POINT QAMATS QATAN..HEBREW POINT DAGESH HAZAQ MUDGASH 0610..061A ; Other_Alphabetic # Mn [11] ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM..ARABIC SMALL KASRA 064B..0657 ; Other_Alphabetic # Mn [13] ARABIC FATHATAN..ARABIC INVERTED DAMMA 0659..065F ; Other_Alphabetic # Mn [7] ARABIC ZWARAKAY..ARABIC WAVY HAMZA BELOW @@ -702,6 +705,10 @@ FB1E ; Other_Alphabetic # Mn HEBREW POINT JUDEO-SPANISH VARIKA 10D24..10D27 ; Other_Alphabetic # Mn [4] HANIFI ROHINGYA SIGN HARBAHAY..HANIFI ROHINGYA SIGN TASSI 10D69 ; Other_Alphabetic # Mn GARAY VOWEL SIGN E 10EAB..10EAC ; Other_Alphabetic # Mn [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK +10ECB..10ECD ; Other_Alphabetic # Mn [3] ARABIC NORTHEAST POINTING ARROWHEAD ABOVE..ARABIC SOUTHWEST POINTING ARROWHEAD BELOW +10EF3 ; Other_Alphabetic # Mn ARABIC SMALL HIGH NOON WITH FATHA +10EF5 ; Other_Alphabetic # Mn ARABIC SMALL HIGH NOON WITH DAMMA +10EF7..10EF8 ; Other_Alphabetic # Mn [2] ARABIC SMALL HIGH HEH INITIAL FORM..ARABIC SMALL HIGH WORD KABBIR 10EFA..10EFC ; Other_Alphabetic # Mn [3] ARABIC DOUBLE VERTICAL BAR BELOW..ARABIC COMBINING ALEF OVERLAY 11000 ; Other_Alphabetic # Mc BRAHMI SIGN CANDRABINDU 11001 ; Other_Alphabetic # Mn BRAHMI SIGN ANUSVARA @@ -837,6 +844,7 @@ FB1E ; Other_Alphabetic # Mn HEBREW POINT JUDEO-SPANISH VARIKA 11D93..11D94 ; Other_Alphabetic # Mc [2] GUNJALA GONDI VOWEL SIGN OO..GUNJALA GONDI VOWEL SIGN AU 11D95 ; Other_Alphabetic # Mn GUNJALA GONDI SIGN ANUSVARA 11D96 ; Other_Alphabetic # Mc GUNJALA GONDI SIGN VISARGA +11DF0 ; Other_Alphabetic # Mn BENGALI SIGN COMBINING ANUSVARA ABOVE 11EF3..11EF4 ; Other_Alphabetic # Mn [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U 11EF5..11EF6 ; Other_Alphabetic # Mc [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O 11F00..11F01 ; Other_Alphabetic # Mn [2] KAWI SIGN CANDRABINDU..KAWI SIGN ANUSVARA @@ -868,7 +876,7 @@ FB1E ; Other_Alphabetic # Mn HEBREW POINT JUDEO-SPANISH VARIKA 1F150..1F169 ; Other_Alphabetic # So [26] NEGATIVE CIRCLED LATIN CAPITAL LETTER A..NEGATIVE CIRCLED LATIN CAPITAL LETTER Z 1F170..1F189 ; Other_Alphabetic # So [26] NEGATIVE SQUARED LATIN CAPITAL LETTER A..NEGATIVE SQUARED LATIN CAPITAL LETTER Z -# Total code points: 1510 +# Total code points: 1520 # ================================================ @@ -883,20 +891,23 @@ FA70..FAD9 ; Ideographic # Lo [106] CJK COMPATIBILITY IDEOGRAPH-FA70..CJK COM 16FE4 ; Ideographic # Mn KHITAN SMALL SCRIPT FILLER 16FF2..16FF3 ; Ideographic # Lm [2] CHINESE SMALL SIMPLIFIED ER..CHINESE SMALL TRADITIONAL ER 16FF4..16FF6 ; Ideographic # Nl [3] YANGQIN SIGN SLOW ONE BEAT..YANGQIN SIGN SLOW TWO BEATS -17000..18CD5 ; Ideographic # Lo [7382] TANGUT IDEOGRAPH-17000..KHITAN SMALL SCRIPT CHARACTER-18CD5 -18CFF..18D1E ; Ideographic # Lo [32] KHITAN SMALL SCRIPT CHARACTER-18CFF..TANGUT IDEOGRAPH-18D1E +17000..18CDA ; Ideographic # Lo [7387] TANGUT IDEOGRAPH-17000..KHITAN SMALL SCRIPT CHARACTER-18CDA +18CFF..18D20 ; Ideographic # Lo [34] KHITAN SMALL SCRIPT CHARACTER-18CFF..TANGUT IDEOGRAPH-18D20 18D80..18DF2 ; Ideographic # Lo [115] TANGUT COMPONENT-769..TANGUT COMPONENT-883 +18E00..19191 ; Ideographic # Lo [914] JURCHEN CHARACTER-18E00..JURCHEN CHARACTER-19191 +191A0..191D2 ; Ideographic # Lo [51] JURCHEN RADICAL-01..JURCHEN RADICAL-51 1B170..1B2FB ; Ideographic # Lo [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB 20000..2A6DF ; Ideographic # Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF -2A700..2B81D ; Ideographic # Lo [4382] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81D +2A700..2B81E ; Ideographic # Lo [4383] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81E 2B820..2CEAD ; Ideographic # Lo [5774] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEAD 2CEB0..2EBE0 ; Ideographic # Lo [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0 2EBF0..2EE5D ; Ideographic # Lo [622] CJK UNIFIED IDEOGRAPH-2EBF0..CJK UNIFIED IDEOGRAPH-2EE5D 2F800..2FA1D ; Ideographic # Lo [542] CJK COMPATIBILITY IDEOGRAPH-2F800..CJK COMPATIBILITY IDEOGRAPH-2FA1D 30000..3134A ; Ideographic # Lo [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A 31350..33479 ; Ideographic # Lo [8490] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-33479 +3D000..3FC3F ; Ideographic # Lo [11328] SMALL SEAL CHARACTER-3D000..SMALL SEAL CHARACTER-3FC3F -# Total code points: 110943 +# Total code points: 123244 # ================================================ @@ -925,15 +936,17 @@ FA70..FAD9 ; Ideographic # Lo [106] CJK COMPATIBILITY IDEOGRAPH-FA70..CJK COM 037A ; Diacritic # Lm GREEK YPOGEGRAMMENI 0384..0385 ; Diacritic # Sk [2] GREEK TONOS..GREEK DIALYTIKA TONOS 0483..0487 ; Diacritic # Mn [5] COMBINING CYRILLIC TITLO..COMBINING CYRILLIC POKRYTIE -0559 ; Diacritic # Lm ARMENIAN MODIFIER LETTER LEFT HALF RING +0558..0559 ; Diacritic # Lm [2] MODIFIER LETTER ARMENIAN SMALL EH..ARMENIAN MODIFIER LETTER LEFT HALF RING +058B..058C ; Diacritic # Lm [2] MODIFIER LETTER ARMENIAN SMALL INI..MODIFIER LETTER ARMENIAN SMALL YI 0591..05BD ; Diacritic # Mn [45] HEBREW ACCENT ETNAHTA..HEBREW POINT METEG 05BF ; Diacritic # Mn HEBREW POINT RAFE 05C1..05C2 ; Diacritic # Mn [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT 05C4..05C5 ; Diacritic # Mn [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT -05C7 ; Diacritic # Mn HEBREW POINT QAMATS QATAN +05C7..05C9 ; Diacritic # Mn [3] HEBREW POINT QAMATS QATAN..HEBREW POINT DAGESH HAZAQ MUDGASH 064B..0652 ; Diacritic # Mn [8] ARABIC FATHATAN..ARABIC SUKUN -0657..0658 ; Diacritic # Mn [2] ARABIC INVERTED DAMMA..ARABIC MARK NOON GHUNNA +0656..0658 ; Diacritic # Mn [3] ARABIC SUBSCRIPT ALEF..ARABIC MARK NOON GHUNNA 06DF..06E0 ; Diacritic # Mn [2] ARABIC SMALL HIGH ROUNDED ZERO..ARABIC SMALL HIGH UPRIGHT RECTANGULAR ZERO +06E2 ; Diacritic # Mn ARABIC SMALL HIGH MEEM ISOLATED FORM 06E5..06E6 ; Diacritic # Lm [2] ARABIC SMALL WAW..ARABIC SMALL YEH 06EA..06EC ; Diacritic # Mn [3] ARABIC EMPTY CENTRE LOW STOP..ARABIC ROUNDED HIGH STOP WITH FILLED CENTRE 0730..074A ; Diacritic # Mn [27] SYRIAC PTHAHA ABOVE..SYRIAC BARREKH @@ -943,7 +956,7 @@ FA70..FAD9 ; Ideographic # Lo [106] CJK COMPATIBILITY IDEOGRAPH-FA70..CJK COM 0818..0819 ; Diacritic # Mn [2] SAMARITAN MARK OCCLUSION..SAMARITAN MARK DAGESH 0898..089F ; Diacritic # Mn [8] ARABIC SMALL HIGH WORD AL-JUZ..ARABIC HALF MADDA OVER MADDA 08C9 ; Diacritic # Lm ARABIC SMALL FARSI YEH -08CA..08D2 ; Diacritic # Mn [9] ARABIC SMALL HIGH FARSI YEH..ARABIC LARGE ROUND DOT INSIDE CIRCLE BELOW +08CA..08D3 ; Diacritic # Mn [10] ARABIC SMALL HIGH FARSI YEH..ARABIC SMALL LOW WAW 08E3..08FE ; Diacritic # Mn [28] ARABIC TURNED DAMMA BELOW..ARABIC DAMMA WITH DOT 093C ; Diacritic # Mn DEVANAGARI SIGN NUKTA 094D ; Diacritic # Mn DEVANAGARI SIGN VIRAMA @@ -958,7 +971,7 @@ FA70..FAD9 ; Ideographic # Lo [106] CJK COMPATIBILITY IDEOGRAPH-FA70..CJK COM 0AFD..0AFF ; Diacritic # Mn [3] GUJARATI SIGN THREE-DOT NUKTA ABOVE..GUJARATI SIGN TWO-CIRCLE NUKTA ABOVE 0B3C ; Diacritic # Mn ORIYA SIGN NUKTA 0B4D ; Diacritic # Mn ORIYA SIGN VIRAMA -0B55 ; Diacritic # Mn ORIYA SIGN OVERLINE +0B53..0B55 ; Diacritic # Mn [3] ORIYA SIGN DOT ABOVE..ORIYA SIGN OVERLINE 0BCD ; Diacritic # Mn TAMIL SIGN VIRAMA 0C3C ; Diacritic # Mn TELUGU SIGN NUKTA 0C4D ; Diacritic # Mn TELUGU SIGN VIRAMA @@ -1001,8 +1014,7 @@ FA70..FAD9 ; Ideographic # Lo [106] CJK COMPATIBILITY IDEOGRAPH-FA70..CJK COM 1AB0..1ABD ; Diacritic # Mn [14] COMBINING DOUBLED CIRCUMFLEX ACCENT..COMBINING PARENTHESES BELOW 1ABE ; Diacritic # Me COMBINING PARENTHESES OVERLAY 1AC1..1ACB ; Diacritic # Mn [11] COMBINING LEFT PARENTHESIS ABOVE LEFT..COMBINING TRIPLE ACUTE ACCENT -1ACF..1ADD ; Diacritic # Mn [15] COMBINING DOUBLE CARON..COMBINING DOT-AND-RING BELOW -1AE0..1AEB ; Diacritic # Mn [12] COMBINING LEFT TACK ABOVE..COMBINING DOUBLE RIGHTWARDS ARROW ABOVE +1ACF..1AF0 ; Diacritic # Mn [34] COMBINING DOUBLE CARON..COMBINING DOUBLE COMMA ABOVE 1B34 ; Diacritic # Mn BALINESE SIGN REREKAN 1B44 ; Diacritic # Mc BALINESE ADEG ADEG 1B6B..1B73 ; Diacritic # Mn [9] BALINESE MUSICAL SYMBOL COMBINING TEGEH..BALINESE MUSICAL SYMBOL COMBINING GONG @@ -1031,6 +1043,7 @@ FA70..FAD9 ; Ideographic # Lo [106] CJK COMPATIBILITY IDEOGRAPH-FA70..CJK COM 1FDD..1FDF ; Diacritic # Sk [3] GREEK DASIA AND VARIA..GREEK DASIA AND PERISPOMENI 1FED..1FEF ; Diacritic # Sk [3] GREEK DIALYTIKA AND VARIA..GREEK VARIA 1FFD..1FFE ; Diacritic # Sk [2] GREEK OXIA..GREEK DASIA +208F ; Diacritic # Lm MODIFIER LETTER HIGH AND LOW VERTICAL LINE 2CEF..2CF1 ; Diacritic # Mn [3] COPTIC COMBINING NI ABOVE..COPTIC COMBINING SPIRITUS LENIS 2E2F ; Diacritic # Lm VERTICAL TILDE 302A..302D ; Diacritic # Mn [4] IDEOGRAPHIC LEVEL TONE MARK..IDEOGRAPHIC ENTERING TONE MARK @@ -1092,7 +1105,9 @@ FFE3 ; Diacritic # Sk FULLWIDTH MACRON 10D24..10D27 ; Diacritic # Mn [4] HANIFI ROHINGYA SIGN HARBAHAY..HANIFI ROHINGYA SIGN TASSI 10D4E ; Diacritic # Lm GARAY VOWEL LENGTH MARK 10D69..10D6D ; Diacritic # Mn [5] GARAY VOWEL SIGN E..GARAY CONSONANT NASALIZATION MARK -10EFA ; Diacritic # Mn ARABIC DOUBLE VERTICAL BAR BELOW +10ECB..10ECF ; Diacritic # Mn [5] ARABIC NORTHEAST POINTING ARROWHEAD ABOVE..ARABIC LARGE CIRCLE ABOVE +10EF0..10EF7 ; Diacritic # Mn [8] ARABIC SMALL LOW UPRIGHT RECTANGULAR ZERO..ARABIC SMALL HIGH HEH INITIAL FORM +10EF9..10EFA ; Diacritic # Mn [2] ARABIC MARK CROWN..ARABIC DOUBLE VERTICAL BAR BELOW 10EFD..10EFF ; Diacritic # Mn [3] ARABIC SMALL LOW WORD SAKTA..ARABIC SMALL LOW WORD MADDA 10F46..10F50 ; Diacritic # Mn [11] SOGDIAN COMBINING DOT BELOW..SOGDIAN COMBINING STROKE BELOW 10F82..10F85 ; Diacritic # Mn [4] OLD UYGHUR COMBINING DOT ABOVE..OLD UYGHUR COMBINING TWO DOTS BELOW @@ -1158,6 +1173,10 @@ FFE3 ; Diacritic # Sk FULLWIDTH MACRON 1D17B..1D182 ; Diacritic # Mn [8] MUSICAL SYMBOL COMBINING ACCENT..MUSICAL SYMBOL COMBINING LOURE 1D185..1D18B ; Diacritic # Mn [7] MUSICAL SYMBOL COMBINING DOIT..MUSICAL SYMBOL COMBINING TRIPLE TONGUE 1D1AA..1D1AD ; Diacritic # Mn [4] MUSICAL SYMBOL COMBINING DOWN BOW..MUSICAL SYMBOL COMBINING SNAP PIZZICATO +1D250..1D252 ; Diacritic # Mc [3] MUSICAL SYMBOL COMBINING FLAG-6..MUSICAL SYMBOL COMBINING FLAG-8 +1D25B..1D25C ; Diacritic # Mn [2] MUSICAL SYMBOL COMBINING TREMOLO-4..MUSICAL SYMBOL COMBINING TREMOLO-5 +1DFCD..1DFCF ; Diacritic # Lm [3] MODIFIER LETTER SMALL TURNED R WITH MID-HEIGHT LEFT HOOK..MODIFIER LETTER SMALL SPLIT U +1DFD1..1DFFF ; Diacritic # Lm [47] MODIFIER LETTER SMALL CAPITAL P..MODIFIER LETTER SMALL T WITH HOOK AND RETROFLEX HOOK 1E030..1E06D ; Diacritic # Lm [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE 1E130..1E136 ; Diacritic # Mn [7] NYIAKENG PUACHUE HMONG TONE-B..NYIAKENG PUACHUE HMONG TONE-D 1E2AE ; Diacritic # Mn TOTO SIGN RISING TONE @@ -1167,7 +1186,7 @@ FFE3 ; Diacritic # Sk FULLWIDTH MACRON 1E944..1E946 ; Diacritic # Mn [3] ADLAM ALIF LENGTHENER..ADLAM GEMINATION MARK 1E948..1E94A ; Diacritic # Mn [3] ADLAM CONSONANT MODIFIER..ADLAM NUKTA -# Total code points: 1247 +# Total code points: 1334 # ================================================ @@ -1177,7 +1196,7 @@ FFE3 ; Diacritic # Sk FULLWIDTH MACRON 07FA ; Extender # Lm NKO LAJANYALAN 0A71 ; Extender # Mn GURMUKHI ADDAK 0AFB ; Extender # Mn GUJARATI SIGN SHADDA -0B55 ; Extender # Mn ORIYA SIGN OVERLINE +0B54..0B55 ; Extender # Mn [2] ORIYA SIGN DOUBLE DOT ABOVE..ORIYA SIGN OVERLINE 0E46 ; Extender # Lm THAI CHARACTER MAIYAMOK 0EC6 ; Extender # Lm LAO KO LA 180A ; Extender # Po MONGOLIAN NIRUGU @@ -1216,7 +1235,7 @@ FF70 ; Extender # Lm HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND 1E5EF ; Extender # Mn OL ONAL SIGN IKIR 1E944..1E946 ; Extender # Mn [3] ADLAM ALIF LENGTHENER..ADLAM GEMINATION MARK -# Total code points: 62 +# Total code points: 63 # ================================================ @@ -1227,13 +1246,15 @@ FF70 ; Extender # Lm HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND 02E0..02E4 ; Other_Lowercase # Lm [5] MODIFIER LETTER SMALL GAMMA..MODIFIER LETTER SMALL REVERSED GLOTTAL STOP 0345 ; Other_Lowercase # Mn COMBINING GREEK YPOGEGRAMMENI 037A ; Other_Lowercase # Lm GREEK YPOGEGRAMMENI +0558 ; Other_Lowercase # Lm MODIFIER LETTER ARMENIAN SMALL EH +058B..058C ; Other_Lowercase # Lm [2] MODIFIER LETTER ARMENIAN SMALL INI..MODIFIER LETTER ARMENIAN SMALL YI 10FC ; Other_Lowercase # Lm MODIFIER LETTER GEORGIAN NAR 1D2C..1D6A ; Other_Lowercase # Lm [63] MODIFIER LETTER CAPITAL A..GREEK SUBSCRIPT SMALL LETTER CHI 1D78 ; Other_Lowercase # Lm MODIFIER LETTER CYRILLIC EN 1D9B..1DBF ; Other_Lowercase # Lm [37] MODIFIER LETTER SMALL TURNED ALPHA..MODIFIER LETTER SMALL THETA 2071 ; Other_Lowercase # Lm SUPERSCRIPT LATIN SMALL LETTER I 207F ; Other_Lowercase # Lm SUPERSCRIPT LATIN SMALL LETTER N -2090..209C ; Other_Lowercase # Lm [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T +2090..209F ; Other_Lowercase # Lm [16] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER Z 2170..217F ; Other_Lowercase # Nl [16] SMALL ROMAN NUMERAL ONE..SMALL ROMAN NUMERAL ONE THOUSAND 24D0..24E9 ; Other_Lowercase # So [26] CIRCLED LATIN SMALL LETTER A..CIRCLED LATIN SMALL LETTER Z 2C7C..2C7D ; Other_Lowercase # Lm [2] LATIN SUBSCRIPT SMALL LETTER J..MODIFIER LETTER CAPITAL V @@ -1246,10 +1267,11 @@ AB69 ; Other_Lowercase # Lm MODIFIER LETTER SMALL TURNED W 10780 ; Other_Lowercase # Lm MODIFIER LETTER SMALL CAPITAL AA 10783..10785 ; Other_Lowercase # Lm [3] MODIFIER LETTER SMALL AE..MODIFIER LETTER SMALL B WITH HOOK 10787..107B0 ; Other_Lowercase # Lm [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK -107B2..107BA ; Other_Lowercase # Lm [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL +107B2..107BF ; Other_Lowercase # Lm [14] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL ESH WITH DOUBLE BAR +1DFCD..1DFFF ; Other_Lowercase # Lm [51] MODIFIER LETTER SMALL TURNED R WITH MID-HEIGHT LEFT HOOK..MODIFIER LETTER SMALL T WITH HOOK AND RETROFLEX HOOK 1E030..1E06D ; Other_Lowercase # Lm [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE -# Total code points: 312 +# Total code points: 374 # ================================================ @@ -1334,9 +1356,12 @@ FF9E..FF9F ; Other_Grapheme_Extend # Lm [2] HALFWIDTH KATAKANA VOICED SOUND 16FF0..16FF1 ; Other_Grapheme_Extend # Mc [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY 1D165..1D166 ; Other_Grapheme_Extend # Mc [2] MUSICAL SYMBOL COMBINING STEM..MUSICAL SYMBOL COMBINING SPRECHGESANG STEM 1D16D..1D172 ; Other_Grapheme_Extend # Mc [6] MUSICAL SYMBOL COMBINING AUGMENTATION DOT..MUSICAL SYMBOL COMBINING FLAG-5 +1D250..1D252 ; Other_Grapheme_Extend # Mc [3] MUSICAL SYMBOL COMBINING FLAG-6..MUSICAL SYMBOL COMBINING FLAG-8 +1D25F ; Other_Grapheme_Extend # Mc MUSICAL SYMBOL COMBINING BUZZ ROLL STEM +1D280..1D281 ; Other_Grapheme_Extend # Mc [2] MUSICAL SYMBOL COMBINING STEM BOW BEHIND BRIDGE..MUSICAL SYMBOL COMBINING STEM BOW ON TOP OF BRIDGE E0020..E007F ; Other_Grapheme_Extend # Cf [96] TAG SPACE..CANCEL TAG -# Total code points: 160 +# Total code points: 166 # ================================================ @@ -1378,14 +1403,14 @@ FA21 ; Unified_Ideograph # Lo CJK COMPATIBILITY IDEOGRAPH-FA21 FA23..FA24 ; Unified_Ideograph # Lo [2] CJK COMPATIBILITY IDEOGRAPH-FA23..CJK COMPATIBILITY IDEOGRAPH-FA24 FA27..FA29 ; Unified_Ideograph # Lo [3] CJK COMPATIBILITY IDEOGRAPH-FA27..CJK COMPATIBILITY IDEOGRAPH-FA29 20000..2A6DF ; Unified_Ideograph # Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF -2A700..2B81D ; Unified_Ideograph # Lo [4382] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81D +2A700..2B81E ; Unified_Ideograph # Lo [4383] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B81E 2B820..2CEAD ; Unified_Ideograph # Lo [5774] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEAD 2CEB0..2EBE0 ; Unified_Ideograph # Lo [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0 2EBF0..2EE5D ; Unified_Ideograph # Lo [622] CJK UNIFIED IDEOGRAPH-2EBF0..CJK UNIFIED IDEOGRAPH-2EE5D 30000..3134A ; Unified_Ideograph # Lo [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A 31350..33479 ; Unified_Ideograph # Lo [8490] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-33479 -# Total code points: 101996 +# Total code points: 101997 # ================================================ @@ -1451,10 +1476,12 @@ E0001 ; Deprecated # Cf LANGUAGE TAG 1D65E..1D65F ; Soft_Dotted # L& [2] MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL I..MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL J 1D692..1D693 ; Soft_Dotted # L& [2] MATHEMATICAL MONOSPACE SMALL I..MATHEMATICAL MONOSPACE SMALL J 1DF1A ; Soft_Dotted # L& LATIN SMALL LETTER I WITH STROKE AND RETROFLEX HOOK +1DF6F..1DF71 ; Soft_Dotted # L& [3] LATIN SMALL LETTER PHONOTYPIC DIPHTHONG AI..LATIN SMALL LETTER STRETCHED I +1DFD9 ; Soft_Dotted # Lm MODIFIER LETTER SMALL J WITH STROKE 1E04C..1E04D ; Soft_Dotted # Lm [2] MODIFIER LETTER CYRILLIC SMALL BYELORUSSIAN-UKRAINIAN I..MODIFIER LETTER CYRILLIC SMALL JE 1E068 ; Soft_Dotted # Lm CYRILLIC SUBSCRIPT SMALL LETTER BYELORUSSIAN-UKRAINIAN I -# Total code points: 50 +# Total code points: 54 # ================================================ @@ -1573,6 +1600,7 @@ FF65 ; Other_ID_Continue # Po HALFWIDTH KATAKANA MIDDLE DOT 2E2E ; Sentence_Terminal # Po REVERSED QUESTION MARK 2E3C ; Sentence_Terminal # Po STENOGRAPHIC FULL STOP 2E53..2E54 ; Sentence_Terminal # Po [2] MEDIEVAL EXCLAMATION MARK..MEDIEVAL QUESTION MARK +2E60..2E61 ; Sentence_Terminal # Po [2] WIGGLY EXCLAMATION MARK..INVERTED WIGGLY EXCLAMATION MARK 3002 ; Sentence_Terminal # Po IDEOGRAPHIC FULL STOP A4FF ; Sentence_Terminal # Po LISU PUNCTUATION FULL STOP A60E..A60F ; Sentence_Terminal # Po [2] VAI FULL STOP..VAI QUESTION MARK @@ -1627,7 +1655,7 @@ FF61 ; Sentence_Terminal # Po HALFWIDTH IDEOGRAPHIC FULL STOP 1BC9F ; Sentence_Terminal # Po DUPLOYAN PUNCTUATION CHINOOK FULL STOP 1DA88 ; Sentence_Terminal # Po SIGNWRITING FULL STOP -# Total code points: 170 +# Total code points: 172 # ================================================ @@ -1877,7 +1905,11 @@ E0100..E01EF ; Variation_Selector # Mn [240] VARIATION SELECTOR-17..VARIATION S 2E5B ; Pattern_Syntax # Ps BOTTOM HALF LEFT PARENTHESIS 2E5C ; Pattern_Syntax # Pe BOTTOM HALF RIGHT PARENTHESIS 2E5D ; Pattern_Syntax # Pd OBLIQUE HYPHEN -2E5E..2E7F ; Pattern_Syntax # Cn [34] .. +2E5E..2E5F ; Pattern_Syntax # Cn [2] .. +2E60..2E61 ; Pattern_Syntax # Po [2] WIGGLY EXCLAMATION MARK..INVERTED WIGGLY EXCLAMATION MARK +2E62 ; Pattern_Syntax # Ps LEFT PARENTHESIS WITH MIDDLE RING +2E63 ; Pattern_Syntax # Pe RIGHT PARENTHESIS WITH MIDDLE RING +2E64..2E7F ; Pattern_Syntax # Cn [28] .. 3001..3003 ; Pattern_Syntax # Po [3] IDEOGRAPHIC COMMA..DITTO MARK 3008 ; Pattern_Syntax # Ps LEFT ANGLE BRACKET 3009 ; Pattern_Syntax # Pe RIGHT ANGLE BRACKET @@ -1938,7 +1970,10 @@ FE45..FE46 ; Pattern_Syntax # Po [2] SESAME DOT..WHITE SESAME DOT 08CD..08CF ; Modifier_Combining_Mark # Mn [3] ARABIC SMALL HIGH ZAH..ARABIC LARGE ROUND DOT BELOW 08D3 ; Modifier_Combining_Mark # Mn ARABIC SMALL LOW WAW 08F3 ; Modifier_Combining_Mark # Mn ARABIC SMALL HIGH WAW +10EF4 ; Modifier_Combining_Mark # Mn ARABIC SMALL LOW NOON WITH FATHA +10EF6 ; Modifier_Combining_Mark # Mn ARABIC SMALL LOW NOON WITH DAMMA +10EF9 ; Modifier_Combining_Mark # Mn ARABIC MARK CROWN -# Total code points: 14 +# Total code points: 17 # EOF diff --git a/contrib/unicode/README b/contrib/unicode/README index dbcbb481f495..40eb51b0c43e 100644 --- a/contrib/unicode/README +++ b/contrib/unicode/README @@ -47,14 +47,14 @@ produce ucnid.h. The procedure to update GCC's Unicode support is the following: -1. Update the six Unicode data files from the above URLs. +1. Update the ten Unicode data files from the above URLs. 2. Update the two glibc files in from_glibc/ from glibc's git. Update the commit number above in this README. 3. Run ./gen_wcwidth.py X.Y > ../../libcpp/generated_cpp_wcwidth.h (where X.Y is the version of the Unicode standard corresponding to the - Unicode data files being used, most recently, 17.0.0). + Unicode data files being used, most recently, 18.0.0). 4. Update Unicode Copyright years in libcpp/makeucnid.cc and in libcpp/makeuname2c.cc up to the year in which the Unicode @@ -69,7 +69,7 @@ The procedure to update GCC's Unicode support is the following: PropList.txt > ../../libcpp/ucnid.h 7. Read the corresponding Unicode's standard and update correspondingly - generated_ranges table in libcpp/makeuname2c.cc (in Unicode 17 all + generated_ranges table in libcpp/makeuname2c.cc (in Unicode 18 all the needed information was in Table 4-8). 8. Compile makeuname2c, e.g. with: diff --git a/contrib/unicode/UnicodeData.txt b/contrib/unicode/UnicodeData.txt index fca68e3e154e..ebccf021c4fc 100644 --- a/contrib/unicode/UnicodeData.txt +++ b/contrib/unicode/UnicodeData.txt @@ -629,12 +629,12 @@ 0274;LATIN LETTER SMALL CAPITAL N;Ll;0;L;;;;;N;;;;; 0275;LATIN SMALL LETTER BARRED O;Ll;0;L;;;;;N;;;019F;;019F 0276;LATIN LETTER SMALL CAPITAL OE;Ll;0;L;;;;;N;LATIN LETTER SMALL CAPITAL O E;;;; -0277;LATIN SMALL LETTER CLOSED OMEGA;Ll;0;L;;;;;N;;;;; +0277;LATIN SMALL LETTER CLOSED OMEGA;Ll;0;L;;;;;N;;;A7DD;;A7DD 0278;LATIN SMALL LETTER PHI;Ll;0;L;;;;;N;;;;; 0279;LATIN SMALL LETTER TURNED R;Ll;0;L;;;;;N;;;;; 027A;LATIN SMALL LETTER TURNED R WITH LONG LEG;Ll;0;L;;;;;N;;;;; 027B;LATIN SMALL LETTER TURNED R WITH HOOK;Ll;0;L;;;;;N;LATIN SMALL LETTER TURNED R HOOK;;;; -027C;LATIN SMALL LETTER R WITH LONG LEG;Ll;0;L;;;;;N;;;;; +027C;LATIN SMALL LETTER R WITH LONG LEG;Ll;0;L;;;;;N;;;A7E2;;A7E2 027D;LATIN SMALL LETTER R WITH TAIL;Ll;0;L;;;;;N;LATIN SMALL LETTER R HOOK;;2C64;;2C64 027E;LATIN SMALL LETTER R WITH FISHHOOK;Ll;0;L;;;;;N;LATIN SMALL LETTER FISHHOOK R;;;; 027F;LATIN SMALL LETTER REVERSED R WITH FISHHOOK;Ll;0;L;;;;;N;LATIN SMALL LETTER REVERSED FISHHOOK R;;;; @@ -1355,6 +1355,7 @@ 0554;ARMENIAN CAPITAL LETTER KEH;Lu;0;L;;;;;N;;;;0584; 0555;ARMENIAN CAPITAL LETTER OH;Lu;0;L;;;;;N;;;;0585; 0556;ARMENIAN CAPITAL LETTER FEH;Lu;0;L;;;;;N;;;;0586; +0558;MODIFIER LETTER ARMENIAN SMALL EH;Lm;0;L; 0567;;;;N;;;;; 0559;ARMENIAN MODIFIER LETTER LEFT HALF RING;Lm;0;L;;;;;N;;;;; 055A;ARMENIAN APOSTROPHE;Po;0;L;;;;;N;ARMENIAN MODIFIER LETTER RIGHT HALF RING;;;; 055B;ARMENIAN EMPHASIS MARK;Po;0;L;;;;;N;;;;; @@ -1405,6 +1406,8 @@ 0588;ARMENIAN SMALL LETTER YI WITH STROKE;Ll;0;L;;;;;N;;;;; 0589;ARMENIAN FULL STOP;Po;0;L;;;;;N;ARMENIAN PERIOD;;;; 058A;ARMENIAN HYPHEN;Pd;0;ON;;;;;N;;;;; +058B;MODIFIER LETTER ARMENIAN SMALL INI;Lm;0;L; 056B;;;;N;;;;; +058C;MODIFIER LETTER ARMENIAN SMALL YI;Lm;0;L; 0575;;;;N;;;;; 058D;RIGHT-FACING ARMENIAN ETERNITY SIGN;So;0;ON;;;;;N;;;;; 058E;LEFT-FACING ARMENIAN ETERNITY SIGN;So;0;ON;;;;;N;;;;; 058F;ARMENIAN DRAM SIGN;Sc;0;ET;;;;;N;;;;; @@ -1463,6 +1466,8 @@ 05C5;HEBREW MARK LOWER DOT;Mn;220;NSM;;;;;N;;;;; 05C6;HEBREW PUNCTUATION NUN HAFUKHA;Po;0;R;;;;;N;;;;; 05C7;HEBREW POINT QAMATS QATAN;Mn;18;NSM;;;;;N;;;;; +05C8;HEBREW POINT SHEVA NA MUDGASH;Mn;10;NSM;;;;;N;;;;; +05C9;HEBREW POINT DAGESH HAZAQ MUDGASH;Mn;21;NSM;;;;;N;;;;; 05D0;HEBREW LETTER ALEF;Lo;0;R;;;;;N;;;;; 05D1;HEBREW LETTER BET;Lo;0;R;;;;;N;;;;; 05D2;HEBREW LETTER GIMEL;Lo;0;R;;;;;N;;;;; @@ -2687,6 +2692,8 @@ 0B4B;ORIYA VOWEL SIGN O;Mc;0;L;0B47 0B3E;;;;N;;;;; 0B4C;ORIYA VOWEL SIGN AU;Mc;0;L;0B47 0B57;;;;N;;;;; 0B4D;ORIYA SIGN VIRAMA;Mn;9;NSM;;;;;N;;;;; +0B53;ORIYA SIGN DOT ABOVE;Mn;0;NSM;;;;;N;;;;; +0B54;ORIYA SIGN DOUBLE DOT ABOVE;Mn;0;NSM;;;;;N;;;;; 0B55;ORIYA SIGN OVERLINE;Mn;0;NSM;;;;;N;;;;; 0B56;ORIYA AI LENGTH MARK;Mn;0;NSM;;;;;N;;;;; 0B57;ORIYA AU LENGTH MARK;Mc;0;L;;;;;N;;;;; @@ -6155,6 +6162,8 @@ 1ADB;COMBINING DOWN TACK ABOVE;Mn;230;NSM;;;;;N;;;;; 1ADC;COMBINING DIAERESIS WITH RAISED LEFT DOT;Mn;230;NSM;;;;;N;;;;; 1ADD;COMBINING DOT-AND-RING BELOW;Mn;220;NSM;;;;;N;;;;; +1ADE;COMBINING GRAVE-DOT;Mn;230;NSM;;;;;N;;;;; +1ADF;COMBINING DOT-ACUTE;Mn;230;NSM;;;;;N;;;;; 1AE0;COMBINING LEFT TACK ABOVE;Mn;230;NSM;;;;;N;;;;; 1AE1;COMBINING RIGHT TACK ABOVE;Mn;230;NSM;;;;;N;;;;; 1AE2;COMBINING MINUS SIGN ABOVE;Mn;230;NSM;;;;;N;;;;; @@ -6167,6 +6176,11 @@ 1AE9;COMBINING LEFT ANGLE CENTRED ABOVE;Mn;230;NSM;;;;;N;;;;; 1AEA;COMBINING UPWARDS ARROW ABOVE;Mn;230;NSM;;;;;N;;;;; 1AEB;COMBINING DOUBLE RIGHTWARDS ARROW ABOVE;Mn;234;NSM;;;;;N;;;;; +1AEC;COMBINING CARON-ACUTE;Mn;230;NSM;;;;;N;;;;; +1AED;COMBINING VERTICAL-LINE-DOUBLE-ACUTE;Mn;230;NSM;;;;;N;;;;; +1AEE;COMBINING DOUBLE GRAVE ACCENT BELOW;Mn;220;NSM;;;;;N;;;;; +1AEF;COMBINING DOUBLE ACUTE ACCENT BELOW;Mn;220;NSM;;;;;N;;;;; +1AF0;COMBINING DOUBLE COMMA ABOVE;Mn;230;NSM;;;;;N;;;;; 1B00;BALINESE SIGN ULU RICEM;Mn;0;NSM;;;;;N;;;;; 1B01;BALINESE SIGN ULU CANDRA;Mn;0;NSM;;;;;N;;;;; 1B02;BALINESE SIGN CECEK;Mn;0;NSM;;;;;N;;;;; @@ -6225,15 +6239,15 @@ 1B37;BALINESE VOWEL SIGN ULU SARI;Mn;0;NSM;;;;;N;;;;; 1B38;BALINESE VOWEL SIGN SUKU;Mn;0;NSM;;;;;N;;;;; 1B39;BALINESE VOWEL SIGN SUKU ILUT;Mn;0;NSM;;;;;N;;;;; -1B3A;BALINESE VOWEL SIGN RA REPA;Mn;0;NSM;;;;;N;;;;; +1B3A;BALINESE VOWEL SIGN RA REPA;Mn;0;L;;;;;N;;;;; 1B3B;BALINESE VOWEL SIGN RA REPA TEDUNG;Mc;0;L;1B3A 1B35;;;;N;;;;; -1B3C;BALINESE VOWEL SIGN LA LENGA;Mn;0;NSM;;;;;N;;;;; +1B3C;BALINESE VOWEL SIGN LA LENGA;Mn;0;L;;;;;N;;;;; 1B3D;BALINESE VOWEL SIGN LA LENGA TEDUNG;Mc;0;L;1B3C 1B35;;;;N;;;;; 1B3E;BALINESE VOWEL SIGN TALING;Mc;0;L;;;;;N;;;;; 1B3F;BALINESE VOWEL SIGN TALING REPA;Mc;0;L;;;;;N;;;;; 1B40;BALINESE VOWEL SIGN TALING TEDUNG;Mc;0;L;1B3E 1B35;;;;N;;;;; 1B41;BALINESE VOWEL SIGN TALING REPA TEDUNG;Mc;0;L;1B3F 1B35;;;;N;;;;; -1B42;BALINESE VOWEL SIGN PEPET;Mn;0;NSM;;;;;N;;;;; +1B42;BALINESE VOWEL SIGN PEPET;Mn;0;L;;;;;N;;;;; 1B43;BALINESE VOWEL SIGN PEPET TEDUNG;Mc;0;L;1B42 1B35;;;;N;;;;; 1B44;BALINESE ADEG ADEG;Mc;9;L;;;;;N;;;;; 1B45;BALINESE LETTER KAF SASAK;Lo;0;L;;;;;N;;;;; @@ -7529,6 +7543,7 @@ 208C;SUBSCRIPT EQUALS SIGN;Sm;0;ON; 003D;;;;N;;;;; 208D;SUBSCRIPT LEFT PARENTHESIS;Ps;0;ON; 0028;;;;Y;SUBSCRIPT OPENING PARENTHESIS;;;; 208E;SUBSCRIPT RIGHT PARENTHESIS;Pe;0;ON; 0029;;;;Y;SUBSCRIPT CLOSING PARENTHESIS;;;; +208F;MODIFIER LETTER HIGH AND LOW VERTICAL LINE;Lm;0;ON;;;;;N;;;;; 2090;LATIN SUBSCRIPT SMALL LETTER A;Lm;0;L; 0061;;;;N;;;;; 2091;LATIN SUBSCRIPT SMALL LETTER E;Lm;0;L; 0065;;;;N;;;;; 2092;LATIN SUBSCRIPT SMALL LETTER O;Lm;0;L; 006F;;;;N;;;;; @@ -7542,6 +7557,9 @@ 209A;LATIN SUBSCRIPT SMALL LETTER P;Lm;0;L; 0070;;;;N;;;;; 209B;LATIN SUBSCRIPT SMALL LETTER S;Lm;0;L; 0073;;;;N;;;;; 209C;LATIN SUBSCRIPT SMALL LETTER T;Lm;0;L; 0074;;;;N;;;;; +209D;LATIN SUBSCRIPT SMALL LETTER W;Lm;0;L; 0077;;;;N;;;;; +209E;LATIN SUBSCRIPT SMALL LETTER Y;Lm;0;L; 0079;;;;N;;;;; +209F;LATIN SUBSCRIPT SMALL LETTER Z;Lm;0;L; 007A;;;;N;;;;; 20A0;EURO-CURRENCY SIGN;Sc;0;ET;;;;;N;;;;; 20A1;COLON SIGN;Sc;0;ET;;;;;N;;;;; 20A2;CRUZEIRO SIGN;Sc;0;ET;;;;;N;;;;; @@ -7576,6 +7594,9 @@ 20BF;BITCOIN SIGN;Sc;0;ET;;;;;N;;;;; 20C0;SOM SIGN;Sc;0;ET;;;;;N;;;;; 20C1;SAUDI RIYAL SIGN;Sc;0;ET;;;;;N;;;;; +20C2;RUFIYAA SIGN;Sc;0;ET;;;;;N;;;;; +20C3;UAE DIRHAM SIGN;Sc;0;ET;;;;;N;;;;; +20C4;OMANI RIAL SIGN;Sc;0;ET;;;;;N;;;;; 20D0;COMBINING LEFT HARPOON ABOVE;Mn;230;NSM;;;;;N;NON-SPACING LEFT HARPOON ABOVE;;;; 20D1;COMBINING RIGHT HARPOON ABOVE;Mn;230;NSM;;;;;N;NON-SPACING RIGHT HARPOON ABOVE;;;; 20D2;COMBINING LONG VERTICAL LINE OVERLAY;Mn;1;NSM;;;;;N;NON-SPACING LONG VERTICAL BAR OVERLAY;;;; @@ -10931,6 +10952,10 @@ 2E5B;BOTTOM HALF LEFT PARENTHESIS;Ps;0;ON;;;;;Y;;;;; 2E5C;BOTTOM HALF RIGHT PARENTHESIS;Pe;0;ON;;;;;Y;;;;; 2E5D;OBLIQUE HYPHEN;Pd;0;ON;;;;;N;;;;; +2E60;WIGGLY EXCLAMATION MARK;Po;0;ON;;;;;N;;;;; +2E61;INVERTED WIGGLY EXCLAMATION MARK;Po;0;ON;;;;;N;;;;; +2E62;LEFT PARENTHESIS WITH MIDDLE RING;Ps;0;ON;;;;;Y;;;;; +2E63;RIGHT PARENTHESIS WITH MIDDLE RING;Pe;0;ON;;;;;Y;;;;; 2E80;CJK RADICAL REPEAT;So;0;ON;;;;;N;;;;; 2E81;CJK RADICAL CLIFF;So;0;ON;;;;;N;;;;; 2E82;CJK RADICAL SECOND ONE;So;0;ON;;;;;N;;;;; @@ -14321,6 +14346,8 @@ A7D9;LATIN SMALL LETTER SIGMOID S;Ll;0;L;;;;;N;;;A7D8;;A7D8 A7DA;LATIN CAPITAL LETTER LAMBDA;Lu;0;L;;;;;N;;;;A7DB; A7DB;LATIN SMALL LETTER LAMBDA;Ll;0;L;;;;;N;;;A7DA;;A7DA A7DC;LATIN CAPITAL LETTER LAMBDA WITH STROKE;Lu;0;L;;;;;N;;;;019B; +A7DD;LATIN CAPITAL LETTER CLOSED OMEGA;Lu;0;L;;;;;N;;;;0277; +A7E2;LATIN CAPITAL LETTER R WITH LONG LEG;Lu;0;L;;;;;N;;;;027C; A7F1;MODIFIER LETTER CAPITAL S;Lm;0;L; 0053;;;;N;;;;; A7F2;MODIFIER LETTER CAPITAL C;Lm;0;L; 0043;;;;N;;;;; A7F3;MODIFIER LETTER CAPITAL F;Lm;0;L; 0046;;;;N;;;;; @@ -15066,8 +15093,8 @@ AB47;LATIN SMALL LETTER R WITHOUT HANDLE;Ll;0;L;;;;;N;;;;; AB48;LATIN SMALL LETTER DOUBLE R;Ll;0;L;;;;;N;;;;; AB49;LATIN SMALL LETTER R WITH CROSSED-TAIL;Ll;0;L;;;;;N;;;;; AB4A;LATIN SMALL LETTER DOUBLE R WITH CROSSED-TAIL;Ll;0;L;;;;;N;;;;; -AB4B;LATIN SMALL LETTER SCRIPT R;Ll;0;L;;;;;N;;;;; -AB4C;LATIN SMALL LETTER SCRIPT R WITH RING;Ll;0;L;;;;;N;;;;; +AB4B;LATIN SMALL LETTER SCRIPT R;Ll;0;L;;;;;N;;;AB6C;;AB6C +AB4C;LATIN SMALL LETTER SCRIPT R WITH RING;Ll;0;L;;;;;N;;;AB6D;;AB6D AB4D;LATIN SMALL LETTER BASELINE ESH;Ll;0;L;;;;;N;;;;; AB4E;LATIN SMALL LETTER U WITH SHORT RIGHT LEG;Ll;0;L;;;;;N;;;;; AB4F;LATIN SMALL LETTER U BAR WITH SHORT RIGHT LEG;Ll;0;L;;;;;N;;;;; @@ -15099,6 +15126,8 @@ AB68;LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE;Ll;0;L;;;;;N;;;;; AB69;MODIFIER LETTER SMALL TURNED W;Lm;0;L; 028D;;;;N;;;;; AB6A;MODIFIER LETTER LEFT TACK;Sk;0;ON;;;;;N;;;;; AB6B;MODIFIER LETTER RIGHT TACK;Sk;0;ON;;;;;N;;;;; +AB6C;LATIN CAPITAL LETTER SCRIPT R;Lu;0;L;;;;;N;;;;AB4B; +AB6D;LATIN CAPITAL LETTER SCRIPT R WITH RING;Lu;0;L;;;;;N;;;;AB4C; AB70;CHEROKEE SMALL LETTER A;Ll;0;L;;;;;N;;;13A0;;13A0 AB71;CHEROKEE SMALL LETTER E;Ll;0;L;;;;;N;;;13A1;;13A1 AB72;CHEROKEE SMALL LETTER I;Ll;0;L;;;;;N;;;13A2;;13A2 @@ -18530,6 +18559,11 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 107B8;MODIFIER LETTER ALVEOLAR CLICK;Lm;0;L; 01C2;;;;N;;;;; 107B9;MODIFIER LETTER RETROFLEX CLICK WITH RETROFLEX HOOK;Lm;0;L; 1DF0A;;;;N;;;;; 107BA;MODIFIER LETTER SMALL S WITH CURL;Lm;0;L; 1DF1E;;;;N;;;;; +107BB;MODIFIER LETTER SMALL TURNED T;Lm;0;L; 0287;;;;N;;;;; +107BC;MODIFIER LETTER INVERTED GLOTTAL STOP;Lm;0;L; 0296;;;;N;;;;; +107BD;MODIFIER LETTER STRETCHED C;Lm;0;L; 0297;;;;N;;;;; +107BE;MODIFIER LETTER SMALL TURNED K;Lm;0;L; 029E;;;;N;;;;; +107BF;MODIFIER LETTER SMALL ESH WITH DOUBLE BAR;Lm;0;L; 1DF0B;;;;N;;;;; 10800;CYPRIOT SYLLABLE A;Lo;0;R;;;;;N;;;;; 10801;CYPRIOT SYLLABLE E;Lo;0;R;;;;;N;;;;; 10802;CYPRIOT SYLLABLE I;Lo;0;R;;;;;N;;;;; @@ -19632,6 +19666,13 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 10EC5;ARABIC SMALL YEH BARREE WITH TWO DOTS BELOW;Lm;0;AL;;;;;N;;;;; 10EC6;ARABIC LETTER THIN NOON;Lo;0;AL;;;;;N;;;;; 10EC7;ARABIC LETTER YEH WITH FOUR DOTS BELOW;Lo;0;AL;;;;;N;;;;; +10EC9;ARABIC SMALL BASELINE FATHA;Sk;0;AL;;;;;N;;;;; +10ECA;ARABIC SMALL BASELINE DOTLESS HEAD OF KHAH;Sk;0;AL;;;;;N;;;;; +10ECB;ARABIC NORTHEAST POINTING ARROWHEAD ABOVE;Mn;230;NSM;;;;;N;;;;; +10ECC;ARABIC NORTHEAST POINTING ARROWHEAD BELOW;Mn;220;NSM;;;;;N;;;;; +10ECD;ARABIC SOUTHWEST POINTING ARROWHEAD BELOW;Mn;220;NSM;;;;;N;;;;; +10ECE;ARABIC SMALL CIRCLE ABOVE;Mn;230;NSM;;;;;N;;;;; +10ECF;ARABIC LARGE CIRCLE ABOVE;Mn;230;NSM;;;;;N;;;;; 10ED0;ARABIC BIBLICAL END OF VERSE;Po;0;ON;;;;;N;;;;; 10ED1;ARABIC LIGATURE ALAYHAA AS-SALAATU WAS-SALAAM;So;0;ON;;;;;N;;;;; 10ED2;ARABIC LIGATURE ALAYHIM AS-SALAATU WAS-SALAAM;So;0;ON;;;;;N;;;;; @@ -19641,6 +19682,38 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 10ED6;ARABIC LIGATURE QUDDISA SIRRUHUMAA;So;0;ON;;;;;N;;;;; 10ED7;ARABIC LIGATURE QUDDISAT ASRAARUHUM;So;0;ON;;;;;N;;;;; 10ED8;ARABIC LIGATURE NAWWARA ALLAAHU MARQADAH;So;0;ON;;;;;N;;;;; +10ED9;ARABIC CROWN LETTER BEH;Lo;0;AL;;;;;N;;;;; +10EDA;ARABIC CROWN LETTER PEH;Lo;0;AL;;;;;N;;;;; +10EDB;ARABIC CROWN LETTER TEH;Lo;0;AL;;;;;N;;;;; +10EDC;ARABIC CROWN LETTER THEH;Lo;0;AL;;;;;N;;;;; +10EDD;ARABIC CROWN LETTER JEEM;Lo;0;AL;;;;;N;;;;; +10EDE;ARABIC CROWN LETTER HAH;Lo;0;AL;;;;;N;;;;; +10EDF;ARABIC CROWN LETTER KHAH;Lo;0;AL;;;;;N;;;;; +10EE0;ARABIC CROWN LETTER SEEN;Lo;0;AL;;;;;N;;;;; +10EE1;ARABIC CROWN LETTER SHEEN;Lo;0;AL;;;;;N;;;;; +10EE2;ARABIC CROWN LETTER SAD;Lo;0;AL;;;;;N;;;;; +10EE3;ARABIC CROWN LETTER DAD;Lo;0;AL;;;;;N;;;;; +10EE4;ARABIC CROWN LETTER TAH;Lo;0;AL;;;;;N;;;;; +10EE5;ARABIC CROWN LETTER ZAH;Lo;0;AL;;;;;N;;;;; +10EE6;ARABIC CROWN LETTER AIN;Lo;0;AL;;;;;N;;;;; +10EE7;ARABIC CROWN LETTER GHAIN;Lo;0;AL;;;;;N;;;;; +10EE8;ARABIC CROWN LETTER FEH;Lo;0;AL;;;;;N;;;;; +10EE9;ARABIC CROWN LETTER QAF;Lo;0;AL;;;;;N;;;;; +10EEA;ARABIC CROWN LETTER KAF;Lo;0;AL;;;;;N;;;;; +10EEB;ARABIC CROWN LETTER MEEM;Lo;0;AL;;;;;N;;;;; +10EEC;ARABIC CROWN LETTER NOON;Lo;0;AL;;;;;N;;;;; +10EED;ARABIC CROWN LETTER HEH;Lo;0;AL;;;;;N;;;;; +10EEE;ARABIC CROWN LETTER YEH;Lo;0;AL;;;;;N;;;;; +10EF0;ARABIC SMALL LOW UPRIGHT RECTANGULAR ZERO;Mn;220;NSM;;;;;N;;;;; +10EF1;ARABIC SQUARE BELOW;Mn;220;NSM;;;;;N;;;;; +10EF2;ARABIC FILLED SQUARE BELOW;Mn;220;NSM;;;;;N;;;;; +10EF3;ARABIC SMALL HIGH NOON WITH FATHA;Mn;230;NSM;;;;;N;;;;; +10EF4;ARABIC SMALL LOW NOON WITH FATHA;Mn;220;NSM;;;;;N;;;;; +10EF5;ARABIC SMALL HIGH NOON WITH DAMMA;Mn;230;NSM;;;;;N;;;;; +10EF6;ARABIC SMALL LOW NOON WITH DAMMA;Mn;220;NSM;;;;;N;;;;; +10EF7;ARABIC SMALL HIGH HEH INITIAL FORM;Mn;230;NSM;;;;;N;;;;; +10EF8;ARABIC SMALL HIGH WORD KABBIR;Mn;230;NSM;;;;;N;;;;; +10EF9;ARABIC MARK CROWN;Mn;230;NSM;;;;;N;;;;; 10EFA;ARABIC DOUBLE VERTICAL BAR BELOW;Mn;220;NSM;;;;;N;;;;; 10EFB;ARABIC SMALL LOW NOON;Mn;220;NSM;;;;;N;;;;; 10EFC;ARABIC COMBINING ALEF OVERLAY;Mn;0;NSM;;;;;N;;;;; @@ -21623,6 +21696,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 11B07;DEVANAGARI SIGN WESTERN NINE-LIKE BHALE;Po;0;L;;;;;N;;;;; 11B08;DEVANAGARI SIGN REVERSED NINE-LIKE BHALE;Po;0;L;;;;;N;;;;; 11B09;DEVANAGARI SIGN MINDU;Po;0;L;;;;;N;;;;; +11B0A;DEVANAGARI LETTER ALTERNATE DDDA;Lo;0;L;;;;;N;;;;; 11B60;SHARADA VOWEL SIGN OE;Mn;0;NSM;;;;;N;;;;; 11B61;SHARADA VOWEL SIGN OOE;Mc;0;L;;;;;N;;;;; 11B62;SHARADA VOWEL SIGN UE;Mn;0;NSM;;;;;N;;;;; @@ -22032,6 +22106,8 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 11DE7;TOLONG SIKI DIGIT SEVEN;Nd;0;L;;7;7;7;N;;;;; 11DE8;TOLONG SIKI DIGIT EIGHT;Nd;0;L;;8;8;8;N;;;;; 11DE9;TOLONG SIKI DIGIT NINE;Nd;0;L;;9;9;9;N;;;;; +11DF0;BENGALI SIGN COMBINING ANUSVARA ABOVE;Mn;0;NSM;;;;;N;;;;; +11DF1;BENGALI LETTER ALTERNATE BARGIYA BA;Lo;0;L;;;;;N;;;;; 11EE0;MAKASAR LETTER KA;Lo;0;L;;;;;N;;;;; 11EE1;MAKASAR LETTER GA;Lo;0;L;;;;;N;;;;; 11EE2;MAKASAR LETTER NGA;Lo;0;L;;;;;N;;;;; @@ -23229,11 +23305,23 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1246C;CUNEIFORM NUMERIC SIGN SEVEN U VARIANT FORM;Nl;0;L;;;;7;N;;;;; 1246D;CUNEIFORM NUMERIC SIGN EIGHT U VARIANT FORM;Nl;0;L;;;;8;N;;;;; 1246E;CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM;Nl;0;L;;;;9;N;;;;; +1246F;CUNEIFORM NUMERIC SIGN SEVEN ASH TENU;Nl;0;L;;;;7;N;;;;; 12470;CUNEIFORM PUNCTUATION SIGN OLD ASSYRIAN WORD DIVIDER;Po;0;L;;;;;N;;;;; 12471;CUNEIFORM PUNCTUATION SIGN VERTICAL COLON;Po;0;L;;;;;N;;;;; 12472;CUNEIFORM PUNCTUATION SIGN DIAGONAL COLON;Po;0;L;;;;;N;;;;; 12473;CUNEIFORM PUNCTUATION SIGN DIAGONAL TRICOLON;Po;0;L;;;;;N;;;;; 12474;CUNEIFORM PUNCTUATION SIGN DIAGONAL QUADCOLON;Po;0;L;;;;;N;;;;; +12475;CUNEIFORM NUMERIC SIGN EIGHT ASH TENU;Nl;0;L;;;;8;N;;;;; +12476;CUNEIFORM NUMERIC SIGN NINE ASH TENU;Nl;0;L;;;;9;N;;;;; +12477;CUNEIFORM NUMERIC SIGN ASH TIMES ONE DISH TENU;Nl;0;L;;;;1;N;;;;; +12478;CUNEIFORM NUMERIC SIGN ASH TIMES TWO DISH TENU;Nl;0;L;;;;2;N;;;;; +12479;CUNEIFORM NUMERIC SIGN ASH TIMES THREE DISH TENU;Nl;0;L;;;;3;N;;;;; +1247A;CUNEIFORM NUMERIC SIGN ASH TIMES FOUR DISH TENU;Nl;0;L;;;;4;N;;;;; +1247B;CUNEIFORM NUMERIC SIGN ASH TIMES FIVE DISH TENU;Nl;0;L;;;;5;N;;;;; +1247C;CUNEIFORM NUMERIC SIGN ASH TIMES SIX DISH TENU;Nl;0;L;;;;6;N;;;;; +1247D;CUNEIFORM NUMERIC SIGN ASH TIMES SEVEN DISH TENU;Nl;0;L;;;;7;N;;;;; +1247E;CUNEIFORM NUMERIC SIGN ASH TIMES EIGHT DISH TENU;Nl;0;L;;;;8;N;;;;; +1247F;CUNEIFORM NUMERIC SIGN ASH TIMES NINE DISH TENU;Nl;0;L;;;;9;N;;;;; 12480;CUNEIFORM SIGN AB TIMES NUN TENU;Lo;0;L;;;;;N;;;;; 12481;CUNEIFORM SIGN AB TIMES SHU2;Lo;0;L;;;;;N;;;;; 12482;CUNEIFORM SIGN AD TIMES ESH2;Lo;0;L;;;;;N;;;;; @@ -23430,6 +23518,317 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 12541;CUNEIFORM SIGN ZA7;Lo;0;L;;;;;N;;;;; 12542;CUNEIFORM SIGN ZU OVER ZU PLUS SAR;Lo;0;L;;;;;N;;;;; 12543;CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU;Lo;0;L;;;;;N;;;;; +12550;CUNEIFORM NUMERIC SIGN ONE N01;Nl;0;L;;;;1;N;;;;; +12551;CUNEIFORM NUMERIC SIGN TWO N01;Nl;0;L;;;;2;N;;;;; +12552;CUNEIFORM NUMERIC SIGN THREE N01;Nl;0;L;;;;3;N;;;;; +12553;CUNEIFORM NUMERIC SIGN FOUR N01;Nl;0;L;;;;4;N;;;;; +12554;CUNEIFORM NUMERIC SIGN FIVE N01;Nl;0;L;;;;5;N;;;;; +12555;CUNEIFORM NUMERIC SIGN SIX N01;Nl;0;L;;;;6;N;;;;; +12556;CUNEIFORM NUMERIC SIGN SEVEN N01;Nl;0;L;;;;7;N;;;;; +12557;CUNEIFORM NUMERIC SIGN EIGHT N01;Nl;0;L;;;;8;N;;;;; +12558;CUNEIFORM NUMERIC SIGN NINE N01;Nl;0;L;;;;9;N;;;;; +12559;CUNEIFORM NUMERIC SIGN ONE N08;Nl;0;L;;;;1;N;;;;; +1255A;CUNEIFORM NUMERIC SIGN TWO N08;Nl;0;L;;;;2;N;;;;; +1255B;CUNEIFORM NUMERIC SIGN THREE N08;Nl;0;L;;;;3;N;;;;; +1255C;CUNEIFORM NUMERIC SIGN FOUR N08;Nl;0;L;;;;4;N;;;;; +1255D;CUNEIFORM NUMERIC SIGN FIVE N08;Nl;0;L;;;;5;N;;;;; +1255E;CUNEIFORM NUMERIC SIGN SIX N08;Nl;0;L;;;;6;N;;;;; +1255F;CUNEIFORM NUMERIC SIGN SEVEN N08;Nl;0;L;;;;7;N;;;;; +12560;CUNEIFORM NUMERIC SIGN EIGHT N08;Nl;0;L;;;;8;N;;;;; +12561;CUNEIFORM NUMERIC SIGN NINE N08;Nl;0;L;;;;9;N;;;;; +12562;CUNEIFORM NUMERIC SIGN ONE N14;Nl;0;L;;;;1;N;;;;; +12563;CUNEIFORM NUMERIC SIGN TWO N14;Nl;0;L;;;;2;N;;;;; +12564;CUNEIFORM NUMERIC SIGN THREE N14;Nl;0;L;;;;3;N;;;;; +12565;CUNEIFORM NUMERIC SIGN FOUR N14;Nl;0;L;;;;4;N;;;;; +12566;CUNEIFORM NUMERIC SIGN FIVE N14;Nl;0;L;;;;5;N;;;;; +12567;CUNEIFORM NUMERIC SIGN SIX N14;Nl;0;L;;;;6;N;;;;; +12568;CUNEIFORM NUMERIC SIGN SEVEN N14;Nl;0;L;;;;7;N;;;;; +12569;CUNEIFORM NUMERIC SIGN EIGHT N14;Nl;0;L;;;;8;N;;;;; +1256A;CUNEIFORM NUMERIC SIGN NINE N14;Nl;0;L;;;;9;N;;;;; +1256B;CUNEIFORM NUMERIC SIGN ONE N34;Nl;0;L;;;;1;N;;;;; +1256C;CUNEIFORM NUMERIC SIGN TWO N34;Nl;0;L;;;;2;N;;;;; +1256D;CUNEIFORM NUMERIC SIGN THREE N34;Nl;0;L;;;;3;N;;;;; +1256E;CUNEIFORM NUMERIC SIGN FOUR N34;Nl;0;L;;;;4;N;;;;; +1256F;CUNEIFORM NUMERIC SIGN FIVE N34;Nl;0;L;;;;5;N;;;;; +12570;CUNEIFORM NUMERIC SIGN SIX N34;Nl;0;L;;;;6;N;;;;; +12571;CUNEIFORM NUMERIC SIGN SEVEN N34;Nl;0;L;;;;7;N;;;;; +12572;CUNEIFORM NUMERIC SIGN EIGHT N34;Nl;0;L;;;;8;N;;;;; +12573;CUNEIFORM NUMERIC SIGN NINE N34;Nl;0;L;;;;9;N;;;;; +12574;CUNEIFORM NUMERIC SIGN ONE N48;Nl;0;L;;;;1;N;;;;; +12575;CUNEIFORM NUMERIC SIGN TWO N48;Nl;0;L;;;;2;N;;;;; +12576;CUNEIFORM NUMERIC SIGN THREE N48;Nl;0;L;;;;3;N;;;;; +12577;CUNEIFORM NUMERIC SIGN FOUR N48;Nl;0;L;;;;4;N;;;;; +12578;CUNEIFORM NUMERIC SIGN FIVE N48;Nl;0;L;;;;5;N;;;;; +12579;CUNEIFORM NUMERIC SIGN ONE N45;Nl;0;L;;;;1;N;;;;; +1257A;CUNEIFORM NUMERIC SIGN TWO N45;Nl;0;L;;;;2;N;;;;; +1257B;CUNEIFORM NUMERIC SIGN THREE N45;Nl;0;L;;;;3;N;;;;; +1257C;CUNEIFORM NUMERIC SIGN FOUR N45;Nl;0;L;;;;4;N;;;;; +1257D;CUNEIFORM NUMERIC SIGN FIVE N45;Nl;0;L;;;;5;N;;;;; +1257E;CUNEIFORM NUMERIC SIGN SIX N45;Nl;0;L;;;;6;N;;;;; +1257F;CUNEIFORM NUMERIC SIGN SEVEN N45;Nl;0;L;;;;7;N;;;;; +12580;CUNEIFORM NUMERIC SIGN EIGHT N45;Nl;0;L;;;;8;N;;;;; +12581;CUNEIFORM NUMERIC SIGN NINE N45;Nl;0;L;;;;9;N;;;;; +12582;CUNEIFORM NUMERIC SIGN ONE N50;Nl;0;L;;;;1;N;;;;; +12583;CUNEIFORM NUMERIC SIGN TWO N50;Nl;0;L;;;;2;N;;;;; +12584;CUNEIFORM NUMERIC SIGN THREE N50;Nl;0;L;;;;3;N;;;;; +12585;CUNEIFORM NUMERIC SIGN FOUR N50;Nl;0;L;;;;4;N;;;;; +12586;CUNEIFORM NUMERIC SIGN FIVE N50;Nl;0;L;;;;5;N;;;;; +12587;CUNEIFORM NUMERIC SIGN ONE EIGHTH IKU CURVED;Nl;0;L;;;;1/8;N;;;;; +12588;CUNEIFORM NUMERIC SIGN ONE EIGHTH IKU CURVED VARIANT FORM;Nl;0;L;;;;1/8;N;;;;; +12589;CUNEIFORM NUMERIC SIGN ONE N01 REVERSED;Nl;0;L;;;;1/4;N;;;;; +1258A;CUNEIFORM NUMERIC SIGN ONE QUARTER IKU CURVED VARIANT FORM;Nl;0;L;;;;1/4;N;;;;; +1258B;CUNEIFORM NUMERIC SIGN ONE HALF IKU CURVED VARIANT FORM;Nl;0;L;;;;1/2;N;;;;; +1258C;CUNEIFORM NUMERIC SIGN ONE N22;Nl;0;L;;;;1;N;;;;; +1258D;CUNEIFORM NUMERIC SIGN TWO N22;Nl;0;L;;;;2;N;;;;; +1258E;CUNEIFORM NUMERIC SIGN ONE BURU CURVED;Nl;0;L;;;;1;N;;;;; +1258F;CUNEIFORM NUMERIC SIGN TWO BURU CURVED;Nl;0;L;;;;2;N;;;;; +12590;CUNEIFORM NUMERIC SIGN THREE BURU CURVED;Nl;0;L;;;;3;N;;;;; +12591;CUNEIFORM NUMERIC SIGN FOUR BURU CURVED;Nl;0;L;;;;4;N;;;;; +12592;CUNEIFORM NUMERIC SIGN FIVE BURU CURVED;Nl;0;L;;;;5;N;;;;; +12593;CUNEIFORM NUMERIC SIGN ONE BAN2 CURVED;Nl;0;L;;;;1;N;;;;; +12594;CUNEIFORM NUMERIC SIGN TWO BAN2 CURVED;Nl;0;L;;;;2;N;;;;; +12595;CUNEIFORM NUMERIC SIGN THREE BAN2 CURVED;Nl;0;L;;;;3;N;;;;; +12596;CUNEIFORM NUMERIC SIGN FOUR BAN2 CURVED;Nl;0;L;;;;4;N;;;;; +12597;CUNEIFORM NUMERIC SIGN FIVE BAN2 CURVED;Nl;0;L;;;;5;N;;;;; +12598;CUNEIFORM NUMERIC SIGN NINDA2 TIMES SHE PLUS ONE ASH CURVED;Nl;0;L;;;;1/3;N;;;;; +12599;CUNEIFORM NUMERIC SIGN NINDA2 TIMES SHE PLUS TWO ASH CURVED;Nl;0;L;;;;2/3;N;;;;; +1259A;CUNEIFORM NUMERIC SIGN ONE N51;Nl;0;L;;;;1;N;;;;; +1259B;CUNEIFORM NUMERIC SIGN TWO N51;Nl;0;L;;;;2;N;;;;; +1259C;CUNEIFORM NUMERIC SIGN THREE N51;Nl;0;L;;;;3;N;;;;; +1259D;CUNEIFORM NUMERIC SIGN FOUR N51;Nl;0;L;;;;4;N;;;;; +1259E;CUNEIFORM NUMERIC SIGN FIVE N51;Nl;0;L;;;;5;N;;;;; +1259F;CUNEIFORM NUMERIC SIGN SIX N51;Nl;0;L;;;;6;N;;;;; +125A0;CUNEIFORM NUMERIC SIGN SEVEN N51;Nl;0;L;;;;7;N;;;;; +125A1;CUNEIFORM NUMERIC SIGN EIGHT N51;Nl;0;L;;;;8;N;;;;; +125A2;CUNEIFORM NUMERIC SIGN NINE N51;Nl;0;L;;;;9;N;;;;; +125A3;CUNEIFORM NUMERIC SIGN ONE N54;Nl;0;L;;;;1;N;;;;; +125A4;CUNEIFORM NUMERIC SIGN TWO N54;Nl;0;L;;;;2;N;;;;; +125A5;CUNEIFORM NUMERIC SIGN THREE N54;Nl;0;L;;;;3;N;;;;; +125A6;CUNEIFORM NUMERIC SIGN FOUR N54;Nl;0;L;;;;4;N;;;;; +125A7;CUNEIFORM NUMERIC SIGN FIVE N54;Nl;0;L;;;;5;N;;;;; +125A8;CUNEIFORM NUMERIC SIGN ONE N56;Nl;0;L;;;;1;N;;;;; +125A9;CUNEIFORM NUMERIC SIGN TWO N56;Nl;0;L;;;;2;N;;;;; +125AA;CUNEIFORM NUMERIC SIGN ONE N24;Nl;0;L;;;;1;N;;;;; +125AB;CUNEIFORM NUMERIC SIGN ONE N26;Nl;0;L;;;;1;N;;;;; +125AC;CUNEIFORM NUMERIC SIGN ONE N28;Nl;0;L;;;;1;N;;;;; +125AD;CUNEIFORM NUMERIC SIGN ONE N29A;Nl;0;L;;;;1;N;;;;; +125AE;CUNEIFORM NUMERIC SIGN ONE N29B;Nl;0;L;;;;1;N;;;;; +125AF;CUNEIFORM NUMERIC SIGN ONE N30A;Nl;0;L;;;;1;N;;;;; +125B0;CUNEIFORM NUMERIC SIGN ONE N30C;Nl;0;L;;;;1;N;;;;; +125B1;CUNEIFORM NUMERIC SIGN ONE N30D;Nl;0;L;;;;1;N;;;;; +125B2;CUNEIFORM NUMERIC SIGN ONE N30E;Nl;0;L;;;;1;N;;;;; +125B3;CUNEIFORM NUMERIC SIGN ONE N31;Nl;0;L;;;;1;N;;;;; +125B4;CUNEIFORM NUMERIC SIGN ONE N32;Nl;0;L;;;;1;N;;;;; +125B5;CUNEIFORM NUMERIC SIGN ONE N33;Nl;0;L;;;;1;N;;;;; +125B6;CUNEIFORM NUMERIC SIGN ONE N39A;Nl;0;L;;;;1;N;;;;; +125B7;CUNEIFORM NUMERIC SIGN TWO N39A;Nl;0;L;;;;2;N;;;;; +125B8;CUNEIFORM NUMERIC SIGN THREE N39A;Nl;0;L;;;;3;N;;;;; +125B9;CUNEIFORM NUMERIC SIGN FOUR N39A;Nl;0;L;;;;4;N;;;;; +125BA;CUNEIFORM NUMERIC SIGN ONE N39B;Nl;0;L;;;;1;N;;;;; +125BB;CUNEIFORM NUMERIC SIGN TWO N39B;Nl;0;L;;;;2;N;;;;; +125BC;CUNEIFORM NUMERIC SIGN THREE N39B;Nl;0;L;;;;3;N;;;;; +125BD;CUNEIFORM NUMERIC SIGN FOUR N39B;Nl;0;L;;;;4;N;;;;; +125BE;CUNEIFORM NUMERIC SIGN ONE N02;Nl;0;L;;;;1;N;;;;; +125BF;CUNEIFORM NUMERIC SIGN TWO N02;Nl;0;L;;;;2;N;;;;; +125C0;CUNEIFORM NUMERIC SIGN THREE N02;Nl;0;L;;;;3;N;;;;; +125C1;CUNEIFORM NUMERIC SIGN FOUR N02;Nl;0;L;;;;4;N;;;;; +125C2;CUNEIFORM NUMERIC SIGN FIVE N02;Nl;0;L;;;;5;N;;;;; +125C3;CUNEIFORM NUMERIC SIGN SIX N02;Nl;0;L;;;;6;N;;;;; +125C4;CUNEIFORM NUMERIC SIGN SEVEN N02;Nl;0;L;;;;7;N;;;;; +125C5;CUNEIFORM NUMERIC SIGN EIGHT N02;Nl;0;L;;;;8;N;;;;; +125C6;CUNEIFORM NUMERIC SIGN NINE N02;Nl;0;L;;;;9;N;;;;; +125C7;CUNEIFORM NUMERIC SIGN ONE N15;Nl;0;L;;;;1;N;;;;; +125C8;CUNEIFORM NUMERIC SIGN TWO N15;Nl;0;L;;;;2;N;;;;; +125C9;CUNEIFORM NUMERIC SIGN THREE N15;Nl;0;L;;;;3;N;;;;; +125CA;CUNEIFORM NUMERIC SIGN FOUR N15;Nl;0;L;;;;4;N;;;;; +125CB;CUNEIFORM NUMERIC SIGN FIVE N15;Nl;0;L;;;;5;N;;;;; +125CC;CUNEIFORM NUMERIC SIGN ONE N35;Nl;0;L;;;;1;N;;;;; +125CD;CUNEIFORM NUMERIC SIGN TWO N35;Nl;0;L;;;;2;N;;;;; +125CE;CUNEIFORM NUMERIC SIGN THREE N35;Nl;0;L;;;;3;N;;;;; +125CF;CUNEIFORM NUMERIC SIGN FOUR N35;Nl;0;L;;;;4;N;;;;; +125D0;CUNEIFORM NUMERIC SIGN FIVE N35;Nl;0;L;;;;5;N;;;;; +125D1;CUNEIFORM NUMERIC SIGN ONE N06;Nl;0;L;;;;1;N;;;;; +125D2;CUNEIFORM NUMERIC SIGN TWO N06;Nl;0;L;;;;2;N;;;;; +125D3;CUNEIFORM NUMERIC SIGN THREE N06;Nl;0;L;;;;3;N;;;;; +125D4;CUNEIFORM NUMERIC SIGN FOUR N06;Nl;0;L;;;;4;N;;;;; +125D5;CUNEIFORM NUMERIC SIGN FIVE N06;Nl;0;L;;;;5;N;;;;; +125D6;CUNEIFORM NUMERIC SIGN SIX N06;Nl;0;L;;;;6;N;;;;; +125D7;CUNEIFORM NUMERIC SIGN SEVEN N06;Nl;0;L;;;;7;N;;;;; +125D8;CUNEIFORM NUMERIC SIGN EIGHT N06;Nl;0;L;;;;8;N;;;;; +125D9;CUNEIFORM NUMERIC SIGN NINE N06;Nl;0;L;;;;9;N;;;;; +125DA;CUNEIFORM NUMERIC SIGN ONE N21;Nl;0;L;;;;1;N;;;;; +125DB;CUNEIFORM NUMERIC SIGN TWO N21;Nl;0;L;;;;2;N;;;;; +125DC;CUNEIFORM NUMERIC SIGN THREE N21;Nl;0;L;;;;3;N;;;;; +125DD;CUNEIFORM NUMERIC SIGN FOUR N21;Nl;0;L;;;;4;N;;;;; +125DE;CUNEIFORM NUMERIC SIGN FIVE N21;Nl;0;L;;;;5;N;;;;; +125DF;CUNEIFORM NUMERIC SIGN ONE N38;Nl;0;L;;;;1;N;;;;; +125E0;CUNEIFORM NUMERIC SIGN ONE N52;Nl;0;L;;;;1;N;;;;; +125E1;CUNEIFORM NUMERIC SIGN TWO N52;Nl;0;L;;;;2;N;;;;; +125E2;CUNEIFORM NUMERIC SIGN THREE N52;Nl;0;L;;;;3;N;;;;; +125E3;CUNEIFORM NUMERIC SIGN FOUR N52;Nl;0;L;;;;4;N;;;;; +125E4;CUNEIFORM NUMERIC SIGN FIVE N52;Nl;0;L;;;;5;N;;;;; +125E5;CUNEIFORM NUMERIC SIGN SIX N52;Nl;0;L;;;;6;N;;;;; +125E6;CUNEIFORM NUMERIC SIGN SEVEN N52;Nl;0;L;;;;7;N;;;;; +125E7;CUNEIFORM NUMERIC SIGN EIGHT N52;Nl;0;L;;;;8;N;;;;; +125E8;CUNEIFORM NUMERIC SIGN NINE N52;Nl;0;L;;;;9;N;;;;; +125E9;CUNEIFORM NUMERIC SIGN ONE N60;Nl;0;L;;;;1;N;;;;; +125EA;CUNEIFORM NUMERIC SIGN ONE N24A;Nl;0;L;;;;1;N;;;;; +125EB;CUNEIFORM NUMERIC SIGN ONE N40;Nl;0;L;;;;1;N;;;;; +125EC;CUNEIFORM NUMERIC SIGN TWO N40;Nl;0;L;;;;2;N;;;;; +125ED;CUNEIFORM NUMERIC SIGN THREE N40;Nl;0;L;;;;3;N;;;;; +125EE;CUNEIFORM NUMERIC SIGN FOUR N40;Nl;0;L;;;;4;N;;;;; +125EF;CUNEIFORM NUMERIC SIGN ONE N03;Nl;0;L;;;;1;N;;;;; +125F0;CUNEIFORM NUMERIC SIGN TWO N03;Nl;0;L;;;;2;N;;;;; +125F1;CUNEIFORM NUMERIC SIGN THREE N03;Nl;0;L;;;;3;N;;;;; +125F2;CUNEIFORM NUMERIC SIGN FOUR N03;Nl;0;L;;;;4;N;;;;; +125F3;CUNEIFORM NUMERIC SIGN FIVE N03;Nl;0;L;;;;5;N;;;;; +125F4;CUNEIFORM NUMERIC SIGN ONE N18;Nl;0;L;;;;1;N;;;;; +125F5;CUNEIFORM NUMERIC SIGN TWO N18;Nl;0;L;;;;2;N;;;;; +125F6;CUNEIFORM NUMERIC SIGN THREE N18;Nl;0;L;;;;3;N;;;;; +125F7;CUNEIFORM NUMERIC SIGN FOUR N18;Nl;0;L;;;;4;N;;;;; +125F8;CUNEIFORM NUMERIC SIGN FIVE N18;Nl;0;L;;;;5;N;;;;; +125F9;CUNEIFORM NUMERIC SIGN SIX N18;Nl;0;L;;;;6;N;;;;; +125FA;CUNEIFORM NUMERIC SIGN SEVEN N18;Nl;0;L;;;;7;N;;;;; +125FB;CUNEIFORM NUMERIC SIGN EIGHT N18;Nl;0;L;;;;8;N;;;;; +125FC;CUNEIFORM NUMERIC SIGN NINE N18;Nl;0;L;;;;9;N;;;;; +125FD;CUNEIFORM NUMERIC SIGN ONE N45A;Nl;0;L;;;;1;N;;;;; +125FE;CUNEIFORM NUMERIC SIGN ONE N24B;Nl;0;L;;;;1;N;;;;; +125FF;CUNEIFORM NUMERIC SIGN ONE N26B;Nl;0;L;;;;1;N;;;;; +12600;CUNEIFORM NUMERIC SIGN ONE N28B;Nl;0;L;;;;1;N;;;;; +12601;CUNEIFORM NUMERIC SIGN ONE N29AB;Nl;0;L;;;;1;N;;;;; +12602;CUNEIFORM NUMERIC SIGN ONE N41;Nl;0;L;;;;1;N;;;;; +12603;CUNEIFORM NUMERIC SIGN TWO N41;Nl;0;L;;;;2;N;;;;; +12604;CUNEIFORM NUMERIC SIGN THREE N41;Nl;0;L;;;;3;N;;;;; +12605;CUNEIFORM NUMERIC SIGN FOUR N41;Nl;0;L;;;;4;N;;;;; +12606;CUNEIFORM NUMERIC SIGN ONE N04;Nl;0;L;;;;1;N;;;;; +12607;CUNEIFORM NUMERIC SIGN TWO N04;Nl;0;L;;;;2;N;;;;; +12608;CUNEIFORM NUMERIC SIGN THREE N04;Nl;0;L;;;;3;N;;;;; +12609;CUNEIFORM NUMERIC SIGN FOUR N04;Nl;0;L;;;;4;N;;;;; +1260A;CUNEIFORM NUMERIC SIGN FIVE N04;Nl;0;L;;;;5;N;;;;; +1260B;CUNEIFORM NUMERIC SIGN ONE N19;Nl;0;L;;;;1;N;;;;; +1260C;CUNEIFORM NUMERIC SIGN TWO N19;Nl;0;L;;;;2;N;;;;; +1260D;CUNEIFORM NUMERIC SIGN THREE N19;Nl;0;L;;;;3;N;;;;; +1260E;CUNEIFORM NUMERIC SIGN FOUR N19;Nl;0;L;;;;4;N;;;;; +1260F;CUNEIFORM NUMERIC SIGN FIVE N19;Nl;0;L;;;;5;N;;;;; +12610;CUNEIFORM NUMERIC SIGN SIX N19;Nl;0;L;;;;6;N;;;;; +12611;CUNEIFORM NUMERIC SIGN SEVEN N19;Nl;0;L;;;;7;N;;;;; +12612;CUNEIFORM NUMERIC SIGN EIGHT N19;Nl;0;L;;;;8;N;;;;; +12613;CUNEIFORM NUMERIC SIGN NINE N19;Nl;0;L;;;;9;N;;;;; +12614;CUNEIFORM NUMERIC SIGN ONE N46;Nl;0;L;;;;1;N;;;;; +12615;CUNEIFORM NUMERIC SIGN TWO N46;Nl;0;L;;;;2;N;;;;; +12616;CUNEIFORM NUMERIC SIGN ONE N36;Nl;0;L;;;;1;N;;;;; +12617;CUNEIFORM NUMERIC SIGN TWO N36;Nl;0;L;;;;2;N;;;;; +12618;CUNEIFORM NUMERIC SIGN THREE N36;Nl;0;L;;;;3;N;;;;; +12619;CUNEIFORM NUMERIC SIGN FOUR N36;Nl;0;L;;;;4;N;;;;; +1261A;CUNEIFORM NUMERIC SIGN FIVE N36;Nl;0;L;;;;5;N;;;;; +1261B;CUNEIFORM NUMERIC SIGN SIX N36;Nl;0;L;;;;6;N;;;;; +1261C;CUNEIFORM NUMERIC SIGN SEVEN N36;Nl;0;L;;;;7;N;;;;; +1261D;CUNEIFORM NUMERIC SIGN EIGHT N36;Nl;0;L;;;;8;N;;;;; +1261E;CUNEIFORM NUMERIC SIGN NINE N36;Nl;0;L;;;;9;N;;;;; +1261F;CUNEIFORM NUMERIC SIGN ONE N49;Nl;0;L;;;;1;N;;;;; +12620;CUNEIFORM NUMERIC SIGN TWO N49;Nl;0;L;;;;2;N;;;;; +12621;CUNEIFORM NUMERIC SIGN THREE N49;Nl;0;L;;;;3;N;;;;; +12622;CUNEIFORM NUMERIC SIGN FOUR N49;Nl;0;L;;;;4;N;;;;; +12623;CUNEIFORM NUMERIC SIGN ONE N25;Nl;0;L;;;;1;N;;;;; +12624;CUNEIFORM NUMERIC SIGN ONE N27;Nl;0;L;;;;1;N;;;;; +12625;CUNEIFORM NUMERIC SIGN ONE N28C;Nl;0;L;;;;1;N;;;;; +12626;CUNEIFORM NUMERIC SIGN ONE N29AC;Nl;0;L;;;;1;N;;;;; +12627;CUNEIFORM NUMERIC SIGN ONE N30AC;Nl;0;L;;;;1;N;;;;; +12628;CUNEIFORM NUMERIC SIGN ONE N30CC;Nl;0;L;;;;1;N;;;;; +12629;CUNEIFORM NUMERIC SIGN ONE N42A;Nl;0;L;;;;1;N;;;;; +1262A;CUNEIFORM NUMERIC SIGN TWO N42A;Nl;0;L;;;;2;N;;;;; +1262B;CUNEIFORM NUMERIC SIGN THREE N42A;Nl;0;L;;;;3;N;;;;; +1262C;CUNEIFORM NUMERIC SIGN FOUR N42A;Nl;0;L;;;;4;N;;;;; +1262D;CUNEIFORM NUMERIC SIGN ONE N42B;Nl;0;L;;;;1;N;;;;; +1262E;CUNEIFORM NUMERIC SIGN TWO N42B;Nl;0;L;;;;2;N;;;;; +1262F;CUNEIFORM NUMERIC SIGN THREE N42B;Nl;0;L;;;;3;N;;;;; +12630;CUNEIFORM NUMERIC SIGN FOUR N42B;Nl;0;L;;;;4;N;;;;; +12631;CUNEIFORM NUMERIC SIGN ONE N05;Nl;0;L;;;;1;N;;;;; +12632;CUNEIFORM NUMERIC SIGN TWO N05;Nl;0;L;;;;2;N;;;;; +12633;CUNEIFORM NUMERIC SIGN THREE N05;Nl;0;L;;;;3;N;;;;; +12634;CUNEIFORM NUMERIC SIGN FOUR N05;Nl;0;L;;;;4;N;;;;; +12635;CUNEIFORM NUMERIC SIGN FIVE N05;Nl;0;L;;;;5;N;;;;; +12636;CUNEIFORM NUMERIC SIGN ONE N20;Nl;0;L;;;;1;N;;;;; +12637;CUNEIFORM NUMERIC SIGN TWO N20;Nl;0;L;;;;2;N;;;;; +12638;CUNEIFORM NUMERIC SIGN THREE N20;Nl;0;L;;;;3;N;;;;; +12639;CUNEIFORM NUMERIC SIGN FOUR N20;Nl;0;L;;;;4;N;;;;; +1263A;CUNEIFORM NUMERIC SIGN FIVE N20;Nl;0;L;;;;5;N;;;;; +1263B;CUNEIFORM NUMERIC SIGN SIX N20;Nl;0;L;;;;6;N;;;;; +1263C;CUNEIFORM NUMERIC SIGN SEVEN N20;Nl;0;L;;;;7;N;;;;; +1263D;CUNEIFORM NUMERIC SIGN EIGHT N20;Nl;0;L;;;;8;N;;;;; +1263E;CUNEIFORM NUMERIC SIGN NINE N20;Nl;0;L;;;;9;N;;;;; +1263F;CUNEIFORM NUMERIC SIGN ONE N47;Nl;0;L;;;;1;N;;;;; +12640;CUNEIFORM NUMERIC SIGN TWO N47;Nl;0;L;;;;2;N;;;;; +12641;CUNEIFORM NUMERIC SIGN ONE N37;Nl;0;L;;;;1;N;;;;; +12642;CUNEIFORM NUMERIC SIGN TWO N37;Nl;0;L;;;;2;N;;;;; +12643;CUNEIFORM NUMERIC SIGN ONE N09;Nl;0;L;;;;1;N;;;;; +12644;CUNEIFORM NUMERIC SIGN ONE N11;Nl;0;L;;;;1;N;;;;; +12645;CUNEIFORM NUMERIC SIGN ONE N12;Nl;0;L;;;;1;N;;;;; +12646;CUNEIFORM NUMERIC SIGN ONE N07A;Nl;0;L;;;;1;N;;;;; +12647;CUNEIFORM NUMERIC SIGN TWO N07A;Nl;0;L;;;;2;N;;;;; +12648;CUNEIFORM NUMERIC SIGN THREE N07A;Nl;0;L;;;;3;N;;;;; +12649;CUNEIFORM NUMERIC SIGN ONE N07B;Nl;0;L;;;;1;N;;;;; +1264A;CUNEIFORM NUMERIC SIGN TWO N07B;Nl;0;L;;;;2;N;;;;; +1264B;CUNEIFORM NUMERIC SIGN THREE N07B;Nl;0;L;;;;3;N;;;;; +1264C;CUNEIFORM NUMERIC SIGN ONE N01 FLAT;Nl;0;L;;;;1;N;;;;; +1264D;CUNEIFORM NUMERIC SIGN TWO N01 FLAT;Nl;0;L;;;;2;N;;;;; +1264E;CUNEIFORM NUMERIC SIGN THREE N01 FLAT;Nl;0;L;;;;3;N;;;;; +1264F;CUNEIFORM NUMERIC SIGN FOUR N01 FLAT;Nl;0;L;;;;4;N;;;;; +12650;CUNEIFORM NUMERIC SIGN FIVE N01 FLAT;Nl;0;L;;;;5;N;;;;; +12651;CUNEIFORM NUMERIC SIGN SIX N01 FLAT;Nl;0;L;;;;6;N;;;;; +12652;CUNEIFORM NUMERIC SIGN SEVEN N01 FLAT;Nl;0;L;;;;7;N;;;;; +12653;CUNEIFORM NUMERIC SIGN EIGHT N01 FLAT;Nl;0;L;;;;8;N;;;;; +12654;CUNEIFORM NUMERIC SIGN NINE N01 FLAT;Nl;0;L;;;;9;N;;;;; +12655;CUNEIFORM NUMERIC SIGN ONE N08 FLAT;Nl;0;L;;;;1;N;;;;; +12656;CUNEIFORM NUMERIC SIGN ONE N14 FLAT;Nl;0;L;;;;1;N;;;;; +12657;CUNEIFORM NUMERIC SIGN TWO N14 FLAT;Nl;0;L;;;;2;N;;;;; +12658;CUNEIFORM NUMERIC SIGN THREE N14 FLAT;Nl;0;L;;;;3;N;;;;; +12659;CUNEIFORM NUMERIC SIGN FOUR N14 FLAT;Nl;0;L;;;;4;N;;;;; +1265A;CUNEIFORM NUMERIC SIGN FIVE N14 FLAT;Nl;0;L;;;;5;N;;;;; +1265B;CUNEIFORM NUMERIC SIGN SIX N14 FLAT;Nl;0;L;;;;6;N;;;;; +1265C;CUNEIFORM NUMERIC SIGN SEVEN N14 FLAT;Nl;0;L;;;;7;N;;;;; +1265D;CUNEIFORM NUMERIC SIGN EIGHT N14 FLAT;Nl;0;L;;;;8;N;;;;; +1265E;CUNEIFORM NUMERIC SIGN NINE N14 FLAT;Nl;0;L;;;;9;N;;;;; +1265F;CUNEIFORM NUMERIC SIGN ONE N34 FLAT;Nl;0;L;;;;1;N;;;;; +12660;CUNEIFORM NUMERIC SIGN TWO N34 FLAT;Nl;0;L;;;;2;N;;;;; +12661;CUNEIFORM NUMERIC SIGN THREE N34 FLAT;Nl;0;L;;;;3;N;;;;; +12662;CUNEIFORM NUMERIC SIGN FOUR N34 FLAT;Nl;0;L;;;;4;N;;;;; +12663;CUNEIFORM NUMERIC SIGN FIVE N34 FLAT;Nl;0;L;;;;5;N;;;;; +12664;CUNEIFORM NUMERIC SIGN SIX N34 FLAT;Nl;0;L;;;;6;N;;;;; +12665;CUNEIFORM NUMERIC SIGN SEVEN N34 FLAT;Nl;0;L;;;;7;N;;;;; +12666;CUNEIFORM NUMERIC SIGN EIGHT N34 FLAT;Nl;0;L;;;;8;N;;;;; +12667;CUNEIFORM NUMERIC SIGN NINE N34 FLAT;Nl;0;L;;;;9;N;;;;; +12668;CUNEIFORM NUMERIC SIGN ONE N45 FLAT;Nl;0;L;;;;1;N;;;;; +12669;CUNEIFORM NUMERIC SIGN TWO N45 FLAT;Nl;0;L;;;;2;N;;;;; +1266A;CUNEIFORM NUMERIC SIGN ONE N22 FLAT;Nl;0;L;;;;1;N;;;;; +1266B;CUNEIFORM NUMERIC SIGN TWO N22 FLAT;Nl;0;L;;;;2;N;;;;; +1266C;CUNEIFORM NUMERIC SIGN ONE N51 FLAT;Nl;0;L;;;;1;N;;;;; +1266D;CUNEIFORM NUMERIC SIGN TWO N51 FLAT;Nl;0;L;;;;2;N;;;;; +1266E;CUNEIFORM NUMERIC SIGN THREE N51 FLAT;Nl;0;L;;;;3;N;;;;; +1266F;CUNEIFORM NUMERIC SIGN FOUR N51 FLAT;Nl;0;L;;;;4;N;;;;; +12670;CUNEIFORM NUMERIC SIGN FIVE N51 FLAT;Nl;0;L;;;;5;N;;;;; +12671;CUNEIFORM NUMERIC SIGN SIX N51 FLAT;Nl;0;L;;;;6;N;;;;; +12672;CUNEIFORM NUMERIC SIGN SEVEN N51 FLAT;Nl;0;L;;;;7;N;;;;; +12673;CUNEIFORM NUMERIC SIGN EIGHT N51 FLAT;Nl;0;L;;;;8;N;;;;; +12674;CUNEIFORM NUMERIC SIGN NINE N51 FLAT;Nl;0;L;;;;9;N;;;;; +12675;CUNEIFORM NUMERIC SIGN ONE N34 FLAT TENU;Nl;0;L;;;;1;N;;;;; +12676;CUNEIFORM NUMERIC SIGN ONE N04 FLAT;Nl;0;L;;;;1;N;;;;; +12677;CUNEIFORM NUMERIC SIGN TWO N04 FLAT;Nl;0;L;;;;2;N;;;;; +12678;CUNEIFORM NUMERIC SIGN THREE N04 FLAT;Nl;0;L;;;;3;N;;;;; +12679;CUNEIFORM NUMERIC SIGN FOUR N04 FLAT;Nl;0;L;;;;4;N;;;;; +1267A;CUNEIFORM NUMERIC SIGN FIVE N04 FLAT;Nl;0;L;;;;5;N;;;;; +1267B;CUNEIFORM NUMERIC SIGN ONE N19 FLAT;Nl;0;L;;;;1;N;;;;; +1267C;CUNEIFORM NUMERIC SIGN TWO N19 FLAT;Nl;0;L;;;;2;N;;;;; +1267D;CUNEIFORM NUMERIC SIGN THREE N19 FLAT;Nl;0;L;;;;3;N;;;;; +1267E;CUNEIFORM NUMERIC SIGN FOUR N19 FLAT;Nl;0;L;;;;4;N;;;;; +1267F;CUNEIFORM NUMERIC SIGN FIVE N19 FLAT;Nl;0;L;;;;5;N;;;;; +12680;CUNEIFORM NUMERIC SIGN SIX N19 FLAT;Nl;0;L;;;;6;N;;;;; +12681;CUNEIFORM NUMERIC SIGN SEVEN N19 FLAT;Nl;0;L;;;;7;N;;;;; +12682;CUNEIFORM NUMERIC SIGN EIGHT N19 FLAT;Nl;0;L;;;;8;N;;;;; +12683;CUNEIFORM NUMERIC SIGN NINE N19 FLAT;Nl;0;L;;;;9;N;;;;; +12684;CUNEIFORM NUMERIC SIGN ONE N46 FLAT;Nl;0;L;;;;1;N;;;;; +12685;CUNEIFORM NUMERIC SIGN TWO N46 FLAT;Nl;0;L;;;;2;N;;;;; +12686;CUNEIFORM NUMERIC SIGN ONE N36 FLAT;Nl;0;L;;;;1;N;;;;; 12F90;CYPRO-MINOAN SIGN CM001;Lo;0;L;;;;;N;;;;; 12F91;CYPRO-MINOAN SIGN CM002;Lo;0;L;;;;;N;;;;; 12F92;CYPRO-MINOAN SIGN CM004;Lo;0;L;;;;;N;;;;; @@ -31739,9 +32138,14 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 18CD3;KHITAN SMALL SCRIPT CHARACTER-18CD3;Lo;0;L;;;;;N;;;;; 18CD4;KHITAN SMALL SCRIPT CHARACTER-18CD4;Lo;0;L;;;;;N;;;;; 18CD5;KHITAN SMALL SCRIPT CHARACTER-18CD5;Lo;0;L;;;;;N;;;;; +18CD6;KHITAN SMALL SCRIPT CHARACTER-18CD6;Lo;0;L;;;;;N;;;;; +18CD7;KHITAN SMALL SCRIPT CHARACTER-18CD7;Lo;0;L;;;;;N;;;;; +18CD8;KHITAN SMALL SCRIPT CHARACTER-18CD8;Lo;0;L;;;;;N;;;;; +18CD9;KHITAN SMALL SCRIPT CHARACTER-18CD9;Lo;0;L;;;;;N;;;;; +18CDA;KHITAN SMALL SCRIPT CHARACTER-18CDA;Lo;0;L;;;;;N;;;;; 18CFF;KHITAN SMALL SCRIPT CHARACTER-18CFF;Lo;0;L;;;;;N;;;;; 18D00;;Lo;0;L;;;;;N;;;;; -18D1E;;Lo;0;L;;;;;N;;;;; +18D20;;Lo;0;L;;;;;N;;;;; 18D80;TANGUT COMPONENT-769;Lo;0;L;;;;;N;;;;; 18D81;TANGUT COMPONENT-770;Lo;0;L;;;;;N;;;;; 18D82;TANGUT COMPONENT-771;Lo;0;L;;;;;N;;;;; @@ -31857,6 +32261,59 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 18DF0;TANGUT COMPONENT-881;Lo;0;L;;;;;N;;;;; 18DF1;TANGUT COMPONENT-882;Lo;0;L;;;;;N;;;;; 18DF2;TANGUT COMPONENT-883;Lo;0;L;;;;;N;;;;; +18E00;;Lo;0;L;;;;;N;;;;; +19191;;Lo;0;L;;;;;N;;;;; +191A0;JURCHEN RADICAL-01;Lo;0;L;;;;;N;;;;; +191A1;JURCHEN RADICAL-02;Lo;0;L;;;;;N;;;;; +191A2;JURCHEN RADICAL-03;Lo;0;L;;;;;N;;;;; +191A3;JURCHEN RADICAL-04;Lo;0;L;;;;;N;;;;; +191A4;JURCHEN RADICAL-05;Lo;0;L;;;;;N;;;;; +191A5;JURCHEN RADICAL-06;Lo;0;L;;;;;N;;;;; +191A6;JURCHEN RADICAL-07;Lo;0;L;;;;;N;;;;; +191A7;JURCHEN RADICAL-08;Lo;0;L;;;;;N;;;;; +191A8;JURCHEN RADICAL-09;Lo;0;L;;;;;N;;;;; +191A9;JURCHEN RADICAL-10;Lo;0;L;;;;;N;;;;; +191AA;JURCHEN RADICAL-11;Lo;0;L;;;;;N;;;;; +191AB;JURCHEN RADICAL-12;Lo;0;L;;;;;N;;;;; +191AC;JURCHEN RADICAL-13;Lo;0;L;;;;;N;;;;; +191AD;JURCHEN RADICAL-14;Lo;0;L;;;;;N;;;;; +191AE;JURCHEN RADICAL-15;Lo;0;L;;;;;N;;;;; +191AF;JURCHEN RADICAL-16;Lo;0;L;;;;;N;;;;; +191B0;JURCHEN RADICAL-17;Lo;0;L;;;;;N;;;;; +191B1;JURCHEN RADICAL-18;Lo;0;L;;;;;N;;;;; +191B2;JURCHEN RADICAL-19;Lo;0;L;;;;;N;;;;; +191B3;JURCHEN RADICAL-20;Lo;0;L;;;;;N;;;;; +191B4;JURCHEN RADICAL-21;Lo;0;L;;;;;N;;;;; +191B5;JURCHEN RADICAL-22;Lo;0;L;;;;;N;;;;; +191B6;JURCHEN RADICAL-23;Lo;0;L;;;;;N;;;;; +191B7;JURCHEN RADICAL-24;Lo;0;L;;;;;N;;;;; +191B8;JURCHEN RADICAL-25;Lo;0;L;;;;;N;;;;; +191B9;JURCHEN RADICAL-26;Lo;0;L;;;;;N;;;;; +191BA;JURCHEN RADICAL-27;Lo;0;L;;;;;N;;;;; +191BB;JURCHEN RADICAL-28;Lo;0;L;;;;;N;;;;; +191BC;JURCHEN RADICAL-29;Lo;0;L;;;;;N;;;;; +191BD;JURCHEN RADICAL-30;Lo;0;L;;;;;N;;;;; +191BE;JURCHEN RADICAL-31;Lo;0;L;;;;;N;;;;; +191BF;JURCHEN RADICAL-32;Lo;0;L;;;;;N;;;;; +191C0;JURCHEN RADICAL-33;Lo;0;L;;;;;N;;;;; +191C1;JURCHEN RADICAL-34;Lo;0;L;;;;;N;;;;; +191C2;JURCHEN RADICAL-35;Lo;0;L;;;;;N;;;;; +191C3;JURCHEN RADICAL-36;Lo;0;L;;;;;N;;;;; +191C4;JURCHEN RADICAL-37;Lo;0;L;;;;;N;;;;; +191C5;JURCHEN RADICAL-38;Lo;0;L;;;;;N;;;;; +191C6;JURCHEN RADICAL-39;Lo;0;L;;;;;N;;;;; +191C7;JURCHEN RADICAL-40;Lo;0;L;;;;;N;;;;; +191C8;JURCHEN RADICAL-41;Lo;0;L;;;;;N;;;;; +191C9;JURCHEN RADICAL-42;Lo;0;L;;;;;N;;;;; +191CA;JURCHEN RADICAL-43;Lo;0;L;;;;;N;;;;; +191CB;JURCHEN RADICAL-44;Lo;0;L;;;;;N;;;;; +191CC;JURCHEN RADICAL-45;Lo;0;L;;;;;N;;;;; +191CD;JURCHEN RADICAL-46;Lo;0;L;;;;;N;;;;; +191CE;JURCHEN RADICAL-47;Lo;0;L;;;;;N;;;;; +191CF;JURCHEN RADICAL-48;Lo;0;L;;;;;N;;;;; +191D0;JURCHEN RADICAL-49;Lo;0;L;;;;;N;;;;; +191D1;JURCHEN RADICAL-50;Lo;0;L;;;;;N;;;;; +191D2;JURCHEN RADICAL-51;Lo;0;L;;;;;N;;;;; 1AFF0;KATAKANA LETTER MINNAN TONE-2;Lm;0;L;;;;;N;;;;; 1AFF1;KATAKANA LETTER MINNAN TONE-3;Lm;0;L;;;;;N;;;;; 1AFF2;KATAKANA LETTER MINNAN TONE-4;Lm;0;L;;;;;N;;;;; @@ -32161,6 +32618,12 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1B120;KATAKANA LETTER ARCHAIC YI;Lo;0;L;;;;;N;;;;; 1B121;KATAKANA LETTER ARCHAIC YE;Lo;0;L;;;;;N;;;;; 1B122;KATAKANA LETTER ARCHAIC WU;Lo;0;L;;;;;N;;;;; +1B123;HIRAGANA DIGRAPH KOTO;Lo;0;L; 3053 3068;;;;N;;;;; +1B124;KATAKANA DIGRAPH TOKI;Lo;0;L; 30C8 30AD;;;;N;;;;; +1B125;KATAKANA DIGRAPH TOTE;Lo;0;L; 30C8 30C6;;;;N;;;;; +1B126;KATAKANA DIGRAPH YORI;Lo;0;L; 30E8 30EA;;;;N;;;;; +1B127;KATAKANA LETTER ALTERNATE NE;Lo;0;L;;;;;N;;;;; +1B128;KATAKANA LETTER ALTERNATE WI;Lo;0;L;;;;;N;;;;; 1B132;HIRAGANA LETTER SMALL KO;Lo;0;L;;;;;N;;;;; 1B150;HIRAGANA LETTER SMALL WI;Lo;0;L;;;;;N;;;;; 1B151;HIRAGANA LETTER SMALL WE;Lo;0;L;;;;;N;;;;; @@ -32170,6 +32633,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1B165;KATAKANA LETTER SMALL WE;Lo;0;L;;;;;N;;;;; 1B166;KATAKANA LETTER SMALL WO;Lo;0;L;;;;;N;;;;; 1B167;KATAKANA LETTER SMALL N;Lo;0;L;;;;;N;;;;; +1B168;KATAKANA LETTER SMALL ARCHAIC YE;Lo;0;L;;;;;N;;;;; 1B170;NUSHU CHARACTER-1B170;Lo;0;L;;;;;N;;;;; 1B171;NUSHU CHARACTER-1B171;Lo;0;L;;;;;N;;;;; 1B172;NUSHU CHARACTER-1B172;Lo;0;L;;;;;N;;;;; @@ -33425,6 +33889,12 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1CECE;BELLONA;So;0;ON;;;;;N;;;;; 1CECF;AMPHITRITE;So;0;ON;;;;;N;;;;; 1CED0;LEUKOTHEA;So;0;ON;;;;;N;;;;; +1CED2;ALCHEMICAL SYMBOL FOR OIL INVERTED;So;0;ON;;;;;N;;;;; +1CED3;ALCHEMICAL SYMBOL FOR MOON-JUPITER;So;0;ON;;;;;N;;;;; +1CED4;ALCHEMICAL SYMBOL FOR SALT OF TARTAR;So;0;ON;;;;;N;;;;; +1CEDD;SQUARE ROOT OF SQUARE ROOT;Sm;0;ON;;;;;Y;;;;; +1CEDE;SQUARE ROOT OF SQUARE ROOT OF SQUARE ROOT;Sm;0;ON;;;;;Y;;;;; +1CEDF;SQUARE ROOT OF SQUARE ROOT OF SQUARE ROOT OF SQUARE ROOT;Sm;0;ON;;;;;Y;;;;; 1CEE0;GEOMANTIC FIGURE POPULUS;So;0;ON;;;;;N;;;;; 1CEE1;GEOMANTIC FIGURE TRISTITIA;So;0;ON;;;;;N;;;;; 1CEE2;GEOMANTIC FIGURE ALBUS;So;0;ON;;;;;N;;;;; @@ -33442,6 +33912,19 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1CEEE;GEOMANTIC FIGURE CAUDA DRACONIS;So;0;ON;;;;;N;;;;; 1CEEF;GEOMANTIC FIGURE VIA;So;0;ON;;;;;N;;;;; 1CEF0;MEDIUM SMALL WHITE CIRCLE WITH HORIZONTAL BAR;Sm;0;ON;;;;;N;;;;; +1CEF1;LEIBNIZIAN DIVISION SIGN;Sm;0;ON;;;;;N;;;;; +1CEF2;LEIBNIZIAN MULTIPLICATION SIGN;Sm;0;ON;;;;;N;;;;; +1CEF3;LEIBNIZIAN MULTIPLICATION-DIVISION SIGN;Sm;0;ON;;;;;N;;;;; +1CEF4;LEIBNIZIAN FRACTION REDUCTION SIGN-1;Sm;0;ON;;;;;N;;;;; +1CEF5;LEIBNIZIAN FRACTION REDUCTION SIGN-2;Sm;0;ON;;;;;N;;;;; +1CEF6;SECTOR WITH CHORD;Sm;0;ON;;;;;N;;;;; +1CEF7;SECTOR WITH DOUBLE ARC;Sm;0;ON;;;;;N;;;;; +1CEF8;SECTOR WITH CHORD AND DOTTED ARC;Sm;0;ON;;;;;N;;;;; +1CEF9;MEASURED ANGLE WITH DOUBLE ARC;Sm;0;ON;;;;;N;;;;; +1CEFA;MEASURED ANGLE WITH CONCAVE ARC;Sm;0;ON;;;;;N;;;;; +1CEFB;MEASURED ANGLE WITH DOUBLE CONCAVE ARC;Sm;0;ON;;;;;N;;;;; +1CEFC;ANGLE OPENING UP;Sm;0;ON;;;;;N;;;;; +1CEFD;HYPERBOLA;Sm;0;ON;;;;;N;;;;; 1CF00;ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON LEFT;Mn;0;NSM;;;;;N;;;;; 1CF01;ZNAMENNY COMBINING MARK NIZKO S KRYZHEM ON LEFT;Mn;0;NSM;;;;;N;;;;; 1CF02;ZNAMENNY COMBINING MARK TSATA ON LEFT;Mn;0;NSM;;;;;N;;;;; @@ -33912,6 +34395,8 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1D124;MUSICAL SYMBOL F CLEF OTTAVA BASSA;So;0;L;;;;;N;;;;; 1D125;MUSICAL SYMBOL DRUM CLEF-1;So;0;L;;;;;N;;;;; 1D126;MUSICAL SYMBOL DRUM CLEF-2;So;0;L;;;;;N;;;;; +1D127;MUSICAL SYMBOL COMBINING STRESS;Mn;220;NSM;;;;;N;;;;; +1D128;MUSICAL SYMBOL COMBINING UNSTRESS;Mn;220;NSM;;;;;N;;;;; 1D129;MUSICAL SYMBOL MULTIPLE MEASURE REST;So;0;L;;;;;N;;;;; 1D12A;MUSICAL SYMBOL DOUBLE SHARP;So;0;L;;;;;N;;;;; 1D12B;MUSICAL SYMBOL DOUBLE FLAT;So;0;L;;;;;N;;;;; @@ -34106,6 +34591,27 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1D1E8;MUSICAL SYMBOL KIEVAN FLAT SIGN;So;0;L;;;;;N;;;;; 1D1E9;MUSICAL SYMBOL SORI;So;0;ON;;;;;N;;;;; 1D1EA;MUSICAL SYMBOL KORON;So;0;ON;;;;;N;;;;; +1D1EB;MUSICAL SYMBOL HALF SHARP;So;0;L;;;;;N;;;;; +1D1EC;MUSICAL SYMBOL ONE AND A HALF SHARP;So;0;L;;;;;N;;;;; +1D1ED;MUSICAL SYMBOL REVERSED FLAT;So;0;L;;;;;N;;;;; +1D1EE;MUSICAL SYMBOL REVERSED FLAT AND FLAT;So;0;L;;;;;N;;;;; +1D1EF;MUSICAL SYMBOL HALF SHARP UP;So;0;L;;;;;N;;;;; +1D1F0;MUSICAL SYMBOL HALF SHARP DOWN;So;0;L;;;;;N;;;;; +1D1F1;MUSICAL SYMBOL ONE AND A HALF SHARP UP;So;0;L;;;;;N;;;;; +1D1F2;MUSICAL SYMBOL ONE AND A HALF SHARP DOWN;So;0;L;;;;;N;;;;; +1D1F3;MUSICAL SYMBOL REVERSED FLAT UP;So;0;L;;;;;N;;;;; +1D1F4;MUSICAL SYMBOL REVERSED FLAT DOWN;So;0;L;;;;;N;;;;; +1D1F5;MUSICAL SYMBOL REVERSED FLAT AND FLAT UP;So;0;L;;;;;N;;;;; +1D1F6;MUSICAL SYMBOL REVERSED FLAT AND FLAT DOWN;So;0;L;;;;;N;;;;; +1D1F7;MUSICAL SYMBOL DIGIT TWO WITH STROKE;So;0;L;;;;;N;;;;; +1D1F8;MUSICAL SYMBOL DIGIT FOUR WITH STROKE;So;0;L;;;;;N;;;;; +1D1F9;MUSICAL SYMBOL DIGIT FIVE WITH STROKE;So;0;L;;;;;N;;;;; +1D1FA;MUSICAL SYMBOL DIGIT SIX WITH STROKE;So;0;L;;;;;N;;;;; +1D1FB;MUSICAL SYMBOL DIGIT SEVEN WITH STROKE;So;0;L;;;;;N;;;;; +1D1FC;MUSICAL SYMBOL DIGIT NINE WITH STROKE;So;0;L;;;;;N;;;;; +1D1FD;MUSICAL SYMBOL DIGIT FIVE WITH LOW STROKE;So;0;L;;;;;N;;;;; +1D1FE;MUSICAL SYMBOL DIGIT SEVEN WITH LOW STROKE;So;0;L;;;;;N;;;;; +1D1FF;MUSICAL SYMBOL LONGA REST;So;0;L;;;;;N;;;;; 1D200;GREEK VOCAL NOTATION SYMBOL-1;So;0;ON;;;;;N;;;;; 1D201;GREEK VOCAL NOTATION SYMBOL-2;So;0;ON;;;;;N;;;;; 1D202;GREEK VOCAL NOTATION SYMBOL-3;So;0;ON;;;;;N;;;;; @@ -34176,6 +34682,56 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1D243;COMBINING GREEK MUSICAL TETRASEME;Mn;230;NSM;;;;;N;;;;; 1D244;COMBINING GREEK MUSICAL PENTASEME;Mn;230;NSM;;;;;N;;;;; 1D245;GREEK MUSICAL LEIMMA;So;0;ON;;;;;N;;;;; +1D250;MUSICAL SYMBOL COMBINING FLAG-6;Mc;216;L;;;;;N;;;;; +1D251;MUSICAL SYMBOL COMBINING FLAG-7;Mc;216;L;;;;;N;;;;; +1D252;MUSICAL SYMBOL COMBINING FLAG-8;Mc;216;L;;;;;N;;;;; +1D253;MUSICAL SYMBOL TWO HUNDRED FIFTY-SIXTH REST;So;0;L;;;;;N;;;;; +1D254;MUSICAL SYMBOL FIVE HUNDRED TWELFTH REST;So;0;L;;;;;N;;;;; +1D255;MUSICAL SYMBOL ONE THOUSAND TWENTY-FOURTH REST;So;0;L;;;;;N;;;;; +1D256;MUSICAL SYMBOL FLAT WITH STROKE;So;0;L;;;;;N;;;;; +1D257;MUSICAL SYMBOL FLAT WITH DOUBLE STROKE;So;0;L;;;;;N;;;;; +1D258;MUSICAL SYMBOL FLAT WITH DOUBLE STEM;So;0;L;;;;;N;;;;; +1D259;MUSICAL SYMBOL HALF SHARP WITH STROKE;So;0;L;;;;;N;;;;; +1D25A;MUSICAL SYMBOL SHARP WITH STROKE;So;0;L;;;;;N;;;;; +1D25B;MUSICAL SYMBOL COMBINING TREMOLO-4;Mn;1;NSM;;;;;N;;;;; +1D25C;MUSICAL SYMBOL COMBINING TREMOLO-5;Mn;1;NSM;;;;;N;;;;; +1D25D;MUSICAL SYMBOL FINGERED TREMOLO-4;So;0;L;;;;;N;;;;; +1D25E;MUSICAL SYMBOL FINGERED TREMOLO-5;So;0;L;;;;;N;;;;; +1D25F;MUSICAL SYMBOL COMBINING BUZZ ROLL STEM;Mc;216;L;;;;;N;;;;; +1D260;MUSICAL SYMBOL TRIPLE FLAT;So;0;L;;;;;N;;;;; +1D261;MUSICAL SYMBOL SUSPENSION;So;0;L;;;;;N;;;;; +1D262;MUSICAL SYMBOL HEAVY DOUBLE BARLINE;So;0;L;;;;;N;;;;; +1D263;MUSICAL SYMBOL SYSTEM DIVIDER;So;0;L;;;;;N;;;;; +1D264;MUSICAL SYMBOL NIENTE;So;0;L;;;;;N;;;;; +1D265;MUSICAL SYMBOL CRESCENDO WITH RING;So;0;L;;;;;N;;;;; +1D266;MUSICAL SYMBOL DECRESCENDO WITH RING;So;0;L;;;;;N;;;;; +1D267;MUSICAL SYMBOL DIAMOND NOTEHEAD WHOLE;So;0;L;;;;;N;;;;; +1D268;MUSICAL SYMBOL DIAMOND NOTEHEAD WHITE;So;0;L;;;;;N;;;;; +1D269;MUSICAL SYMBOL DIAMOND NOTEHEAD BLACK;So;0;L;;;;;N;;;;; +1D26A;MUSICAL SYMBOL DIAMOND NOTEHEAD HALF-FILLED;So;0;L;;;;;N;;;;; +1D26B;MUSICAL SYMBOL TRIANGULAR FERMATA;So;0;L;;;;;N;;;;; +1D26C;MUSICAL SYMBOL DOUBLE TRIANGULAR FERMATA;So;0;L;;;;;N;;;;; +1D26D;MUSICAL SYMBOL SQUARE FERMATA;So;0;L;;;;;N;;;;; +1D26E;MUSICAL SYMBOL DOUBLE SQUARE FERMATA;So;0;L;;;;;N;;;;; +1D26F;MUSICAL SYMBOL HENZE LONG FERMATA;So;0;L;;;;;N;;;;; +1D270;MUSICAL SYMBOL HENZE SHORT FERMATA;So;0;L;;;;;N;;;;; +1D271;MUSICAL SYMBOL CURLEW;So;0;L;;;;;N;;;;; +1D272;MUSICAL SYMBOL SALZEDO BREATH MARK;So;0;L;;;;;N;;;;; +1D273;MUSICAL SYMBOL ORGAN PEDAL HEEL;So;0;L;;;;;N;;;;; +1D274;MUSICAL SYMBOL ORGAN PEDAL TOE;So;0;L;;;;;N;;;;; +1D275;MUSICAL SYMBOL G CLEF OPTIONALLY OTTAVA BASSA;So;0;L;;;;;N;;;;; +1D276;MUSICAL SYMBOL DOUBLE G CLEF;So;0;L;;;;;N;;;;; +1D277;MUSICAL SYMBOL G CLEF OTTAVA BASSA WITH C CLEF;So;0;L;;;;;N;;;;; +1D278;MUSICAL SYMBOL C CLEF OTTAVA BASSA;So;0;L;;;;;N;;;;; +1D279;MUSICAL SYMBOL G CLEF QUINDICESIMA ALTA;So;0;L;;;;;N;;;;; +1D27A;MUSICAL SYMBOL G CLEF QUINDICESIMA BASSA;So;0;L;;;;;N;;;;; +1D27B;MUSICAL SYMBOL F CLEF QUINDICESIMA ALTA;So;0;L;;;;;N;;;;; +1D27C;MUSICAL SYMBOL F CLEF QUINDICESIMA BASSA;So;0;L;;;;;N;;;;; +1D27D;MUSICAL SYMBOL C CLEF QUINDICESIMA BASSA;So;0;L;;;;;N;;;;; +1D27E;MUSICAL SYMBOL TABLATURE CLEF;So;0;L;;;;;N;;;;; +1D27F;MUSICAL SYMBOL ARPEGGIATO UP WITH ARROW;So;0;L;;;;;N;;;;; +1D280;MUSICAL SYMBOL COMBINING STEM BOW BEHIND BRIDGE;Mc;216;L;;;;;N;;;;; +1D281;MUSICAL SYMBOL COMBINING STEM BOW ON TOP OF BRIDGE;Mc;216;L;;;;;N;;;;; 1D2C0;KAKTOVIK NUMERAL ZERO;No;0;L;;;;0;N;;;;; 1D2C1;KAKTOVIK NUMERAL ONE;No;0;L;;;;1;N;;;;; 1D2C2;KAKTOVIK NUMERAL TWO;No;0;L;;;;2;N;;;;; @@ -34982,6 +35538,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1D6A3;MATHEMATICAL MONOSPACE SMALL Z;Ll;0;L; 007A;;;;N;;;;; 1D6A4;MATHEMATICAL ITALIC SMALL DOTLESS I;Ll;0;L; 0131;;;;N;;;;; 1D6A5;MATHEMATICAL ITALIC SMALL DOTLESS J;Ll;0;L; 0237;;;;N;;;;; +1D6A6;MATHEMATICAL ITALIC SMALL LIGATURE LONG S WITH DESCENDER S;Ll;0;L; 1DF95;;;;N;;;;; 1D6A8;MATHEMATICAL BOLD CAPITAL ALPHA;Lu;0;L; 0391;;;;N;;;;; 1D6A9;MATHEMATICAL BOLD CAPITAL BETA;Lu;0;L; 0392;;;;N;;;;; 1D6AA;MATHEMATICAL BOLD CAPITAL GAMMA;Lu;0;L; 0393;;;;N;;;;; @@ -35996,6 +36553,35 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1DAAD;SIGNWRITING ROTATION MODIFIER-14;Mn;0;NSM;;;;;N;;;;; 1DAAE;SIGNWRITING ROTATION MODIFIER-15;Mn;0;NSM;;;;;N;;;;; 1DAAF;SIGNWRITING ROTATION MODIFIER-16;Mn;0;NSM;;;;;N;;;;; +1DB00;LEIBNIZIAN EQUALS SIGN;Sm;0;ON;;;;;N;;;;; +1DB01;LEIBNIZIAN EQUALS SIGN WITH DOUBLE VERTICALS;Sm;0;ON;;;;;N;;;;; +1DB02;LEIBNIZIAN EQUALS SIGN WITH SMALL S;Sm;0;ON;;;;;N;;;;; +1DB03;LEIBNIZIAN GREATER-THAN;Sm;0;ON;;;;;Y;;;;; +1DB04;LEIBNIZIAN LESS-THAN;Sm;0;ON;;;;;Y;;;;; +1DB05;LEIBNIZIAN GREATER-THAN WITH SMALL P;Sm;0;ON;;;;;Y;;;;; +1DB06;LEIBNIZIAN LESS-THAN WITH SMALL P;Sm;0;ON;;;;;Y;;;;; +1DB07;LEIBNIZIAN GREATER-THAN OR LESS-THAN;Sm;0;ON;;;;;Y;;;;; +1DB08;INVERTED SQUARE LEFT OPEN BOX OPERATOR;Sm;0;ON;;;;;Y;;;;; +1DB09;INVERTED SQUARE RIGHT OPEN BOX OPERATOR;Sm;0;ON;;;;;Y;;;;; +1DB0A;TWO-LINE GREATER-THAN;Sm;0;ON;;;;;N;;;;; +1DB0B;TWO-LINE LESS-THAN;Sm;0;ON;;;;;N;;;;; +1DB0C;COMMENSURABILITY;Sm;0;ON;;;;;N;;;;; +1DB0D;INCOMMENSURABILITY;Sm;0;ON;;;;;N;;;;; +1DB0E;COMMENSURABILITY IN SQUARE;Sm;0;ON;;;;;N;;;;; +1DB0F;INCOMMENSURABILITY IN SQUARE;Sm;0;ON;;;;;N;;;;; +1DB10;CARTESIAN EQUALS SIGN;Sm;0;ON;;;;;Y;;;;; +1DB11;LEIBNIZIAN CONGRUENCE;Sm;0;ON;;;;;N;;;;; +1DB12;LEIBNIZIAN CONGRUENCE WITH VERTICAL BAR;Sm;0;ON;;;;;N;;;;; +1DB13;LEIBNIZIAN CONGRUENCE-2;Sm;0;ON;;;;;N;;;;; +1DB14;LEIBNIZIAN CONGRUENCE-2 INVERTED;Sm;0;ON;;;;;N;;;;; +1DB15;LEIBNIZIAN CONGRUENCE-2 WITH HORIZONTAL BAR;Sm;0;ON;;;;;N;;;;; +1DB16;LEIBNIZIAN CONGRUENCE-2 WITH HORIZONTAL AND VERTICAL BAR;Sm;0;ON;;;;;N;;;;; +1DB17;LEIBNIZIAN COINCIDENCE;Sm;0;ON;;;;;Y;;;;; +1DB18;INVERTED LAZY S OVER LAZY S;Sm;0;ON;;;;;Y;;;;; +1DB19;LEIBNIZIAN SIMILARITY;Sm;0;ON;;;;;N;;;;; +1DB1A;LEIBNIZIAN SIMILARITY-2;Sm;0;ON;;;;;N;;;;; +1DB1B;LEIBNIZIAN DISSIMILARITY;Sm;0;ON;;;;;Y;;;;; +1DB1C;FACIT SYMBOL;Sm;0;ON;;;;;N;;;;; 1DF00;LATIN SMALL LETTER FENG DIGRAPH WITH TRILL;Ll;0;L;;;;;N;;;;; 1DF01;LATIN SMALL LETTER REVERSED SCRIPT G;Ll;0;L;;;;;N;;;;; 1DF02;LATIN LETTER SMALL CAPITAL TURNED G;Ll;0;L;;;;;N;;;;; @@ -36027,12 +36613,163 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1DF1C;LATIN SMALL LETTER TESH DIGRAPH WITH RETROFLEX HOOK;Ll;0;L;;;;;N;;;;; 1DF1D;LATIN SMALL LETTER C WITH RETROFLEX HOOK;Ll;0;L;;;;;N;;;;; 1DF1E;LATIN SMALL LETTER S WITH CURL;Ll;0;L;;;;;N;;;;; +1DF1F;LATIN SMALL LETTER D-ETH DIGRAPH;Ll;0;L;;;;;N;;;;; +1DF20;LATIN SMALL LETTER D-LEZH DIGRAPH;Ll;0;L;;;;;N;;;;; +1DF21;LATIN SMALL LETTER D-LEZH DIGRAPH WITH RETROFLEX HOOK;Ll;0;L;;;;;N;;;;; +1DF22;LATIN SMALL LETTER TL DIGRAPH WITH BELT;Ll;0;L;;;;;N;;;;; +1DF23;LATIN SMALL LETTER TL DIGRAPH WITH RETROFLEX HOOK AND BELT;Ll;0;L;;;;;N;;;;; +1DF24;LATIN SMALL LETTER T-THETA DIGRAPH;Ll;0;L;;;;;N;;;;; 1DF25;LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK;Ll;0;L;;;;;N;;;;; 1DF26;LATIN SMALL LETTER L WITH MID-HEIGHT LEFT HOOK;Ll;0;L;;;;;N;;;;; 1DF27;LATIN SMALL LETTER N WITH MID-HEIGHT LEFT HOOK;Ll;0;L;;;;;N;;;;; 1DF28;LATIN SMALL LETTER R WITH MID-HEIGHT LEFT HOOK;Ll;0;L;;;;;N;;;;; 1DF29;LATIN SMALL LETTER S WITH MID-HEIGHT LEFT HOOK;Ll;0;L;;;;;N;;;;; 1DF2A;LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK;Ll;0;L;;;;;N;;;;; +1DF2B;LATIN SMALL LETTER DEZH DIGRAPH WITH CURL;Ll;0;L;;;;;N;;;;; +1DF2C;LATIN SMALL LETTER TESH DIGRAPH WITH CURL;Ll;0;L;;;;;N;;;;; +1DF2D;LATIN SMALL LETTER D WITH HOOK AND PALATAL HOOK;Ll;0;L;;;;;N;;;;; +1DF2E;LATIN SMALL LETTER DZ DIGRAPH WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;; +1DF2F;LATIN SMALL LETTER ETH WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;; +1DF30;LATIN LETTER SMALL CAPITAL G WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;; +1DF31;LATIN SMALL LETTER GAMMA WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;; +1DF32;LATIN SMALL LETTER H WITH STROKE AND PALATAL HOOK;Ll;0;L;;;;;N;;;;; +1DF33;LATIN SMALL LETTER PHI WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;; +1DF34;LATIN SMALL LETTER Q WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;; +1DF35;LATIN LETTER SMALL CAPITAL R WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;; +1DF36;LATIN LETTER SMALL CAPITAL INVERTED R WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;; +1DF37;LATIN SMALL LETTER R WITH TAIL AND PALATAL HOOK;Ll;0;L;;;;;N;;;;; +1DF38;LATIN SMALL LETTER TS DIGRAPH WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;; +1DF39;LATIN SMALL LETTER V WITH HOOK AND PALATAL HOOK;Ll;0;L;;;;;N;;;;; +1DF3A;LATIN LETTER PHARYNGEAL VOICED FRICATIVE WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;; +1DF3B;LATIN SMALL LETTER BETA WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;; +1DF3C;LATIN SMALL LETTER THETA WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;; +1DF3D;LATIN SMALL LETTER CHI WITH PALATAL HOOK;Ll;0;L;;;;;N;;;;; +1DF3E;LATIN SMALL LETTER BARRED TURNED H;Ll;0;L;;;;;N;;;;; +1DF3F;LATIN SMALL LETTER BARRED W;Ll;0;L;;;;;N;;;;; +1DF40;LATIN CAPITAL LETTER BARRED A;Lu;0;L;;;;;N;;;;1DF41; +1DF41;LATIN SMALL LETTER BARRED A;Ll;0;L;;;;;N;;;1DF40;;1DF40 +1DF42;LATIN SMALL LETTER BARRED OPEN O;Ll;0;L;;;;;N;;;;; +1DF43;LATIN LETTER SMALL CAPITAL BARRED E;Ll;0;L;;;;;N;;;;; +1DF44;LATIN SMALL LETTER BARRED OPEN E;Ll;0;L;;;;;N;;;;; +1DF45;LATIN SMALL LETTER G WITH STROKE AND PALATAL HOOK;Ll;0;L;;;;;N;;;;; +1DF46;LATIN SMALL LETTER BARRED H;Ll;0;L;;;;;N;;;;; +1DF47;LATIN SMALL LETTER BARRED H WITH HOOK;Ll;0;L;;;;;N;;;;; +1DF48;LATIN CAPITAL LETTER BARRED K;Lu;0;L;;;;;N;;;;1DF49; +1DF49;LATIN SMALL LETTER BARRED K;Ll;0;L;;;;;N;;;1DF48;;1DF48 +1DF4A;LATIN CAPITAL LETTER BARRED M;Lu;0;L;;;;;N;;;;1DF4B; +1DF4B;LATIN SMALL LETTER BARRED M;Ll;0;L;;;;;N;;;1DF4A;;1DF4A +1DF4C;LATIN SMALL LETTER BARRED M WITH HOOK;Ll;0;L;;;;;N;;;;; +1DF4D;LATIN CAPITAL LETTER BARRED N;Lu;0;L;;;;;N;;;;1DF4E; +1DF4E;LATIN SMALL LETTER BARRED N;Ll;0;L;;;;;N;;;1DF4D;;1DF4D +1DF4F;LATIN SMALL LETTER BARRED ENG;Ll;0;L;;;;;N;;;;; +1DF50;LATIN SMALL LETTER TURNED R WITH STROKE;Ll;0;L;;;;;N;;;;; +1DF51;LATIN CAPITAL LETTER BARRED V;Lu;0;L;;;;;N;;;;1DF52; +1DF52;LATIN SMALL LETTER BARRED V;Ll;0;L;;;;;N;;;1DF51;;1DF51 +1DF53;LATIN SMALL LETTER BARRED CLOSED OMEGA;Ll;0;L;;;;;N;;;;; +1DF54;LATIN SMALL LETTER BARRED CHI;Ll;0;L;;;;;N;;;;; +1DF55;LATIN SMALL LETTER Y WITH LOW STROKE;Ll;0;L;;;;;N;;;;; +1DF56;LATIN LETTER GLOTTAL STOP WITH DOUBLE STROKE;Ll;0;L;;;;;N;;;;; +1DF57;LATIN SMALL LETTER TURNED R WITH MID-HEIGHT LEFT HOOK;Ll;0;L;;;;;N;;;;; +1DF58;LATIN SMALL LETTER SPLIT O;Ll;0;L;;;;;N;;;;; +1DF59;LATIN SMALL LETTER SPLIT U;Ll;0;L;;;;;N;;;;; +1DF5A;LATIN SMALL LETTER HALF A;Ll;0;L;;;;;N;;;;; +1DF5B;LATIN SMALL LETTER STRETCHED C-H DIGRAPH;Ll;0;L;;;;;N;;;;; +1DF5C;LATIN SMALL LETTER LUNATE EE;Ll;0;L;;;;;N;;;;; +1DF5D;LATIN SMALL LETTER IE;Ll;0;L;;;;;N;;;;; +1DF5E;LATIN SMALL LETTER OI DIGRAPH;Ll;0;L;;;;;N;;;;; +1DF5F;LATIN SMALL LETTER OU DIGRAPH;Ll;0;L;;;;;N;;;;; +1DF60;LATIN SMALL LETTER OMEGA WITH LOOP;Ll;0;L;;;;;N;;;;; +1DF61;LATIN SMALL LETTER R WITH LEFT TIE;Ll;0;L;;;;;N;;;;; +1DF62;LATIN SMALL LETTER ESH-H DIGRAPH;Ll;0;L;;;;;N;;;;; +1DF63;LATIN SMALL LETTER STRETCHED T-H DIGRAPH;Ll;0;L;;;;;N;;;;; +1DF64;LATIN SMALL LETTER REVERSED T-H DIGRAPH;Ll;0;L;;;;;N;;;;; +1DF65;LATIN SMALL LETTER WH DIGRAPH;Ll;0;L;;;;;N;;;;; +1DF66;LATIN SMALL LETTER REVERSED Z;Ll;0;L;;;;;N;;;;; +1DF67;LATIN SMALL LETTER LEZH WITH CURL;Ll;0;L;;;;;N;;;;; +1DF68;LATIN CAPITAL LETTER PHONOTYPIC A WITH SWASH;Lu;0;L;;;;;N;;;;1DF69; +1DF69;LATIN SMALL LETTER PHONOTYPIC A WITH SWASH;Ll;0;L;;;;;N;;;1DF68;;1DF68 +1DF6A;LATIN CAPITAL LETTER PHONOTYPIC ROUNDTOP A;Lu;0;L;;;;;N;;;;1DF6B; +1DF6B;LATIN SMALL LETTER PHONOTYPIC ROUNDTOP A;Ll;0;L;;;;;N;;;1DF6A;;1DF6A +1DF6C;LATIN CAPITAL LETTER REVERSED SCRUPLE;Lu;0;L;;;;;N;;;;1DF6D; +1DF6D;LATIN SMALL LETTER REVERSED SCRUPLE;Ll;0;L;;;;;N;;;1DF6C;;1DF6C +1DF6E;LATIN CAPITAL LETTER PHONOTYPIC DIPHTHONG AI;Lu;0;L;;;;;N;;;;1DF6F; +1DF6F;LATIN SMALL LETTER PHONOTYPIC DIPHTHONG AI;Ll;0;L;;;;;N;;;1DF6E;;1DF6E +1DF70;LATIN SMALL LETTER I WITH PIGTAIL AT BOTTOM;Ll;0;L;;;;;N;;;;; +1DF71;LATIN SMALL LETTER STRETCHED I;Ll;0;L;;;;;N;;;;; +1DF72;LATIN CAPITAL LETTER O WITH CURL;Lu;0;L;;;;;N;;;;1DF73; +1DF73;LATIN SMALL LETTER O WITH CURL;Ll;0;L;;;;;N;;;1DF72;;1DF72 +1DF74;LATIN CAPITAL LETTER CLOSED OMEGA WITH LONG STEM;Lu;0;L;;;;;N;;;;1DF75; +1DF75;LATIN SMALL LETTER CLOSED OMEGA WITH LONG STEM;Ll;0;L;;;;;N;;;1DF74;;1DF74 +1DF76;LATIN CAPITAL LETTER TURNED CLOSED OMEGA;Lu;0;L;;;;;N;;;;1DF77; +1DF77;LATIN SMALL LETTER TURNED CLOSED OMEGA;Ll;0;L;;;;;N;;;1DF76;;1DF76 +1DF78;LATIN CAPITAL LETTER PHONOTYPIC TH;Lu;0;L;;;;;N;;;;1DF79; +1DF79;LATIN SMALL LETTER PHONOTYPIC TH;Ll;0;L;;;;;N;;;1DF78;;1DF78 +1DF7A;LATIN CAPITAL LETTER U WITH HOOK TAIL;Lu;0;L;;;;;N;;;;1DF7B; +1DF7B;LATIN SMALL LETTER U WITH HOOK TAIL;Ll;0;L;;;;;N;;;1DF7A;;1DF7A +1DF7C;LATIN CAPITAL LETTER U WITH NOTCH AT BOTTOM;Lu;0;L;;;;;N;;;;1DF7D; +1DF7D;LATIN SMALL LETTER U WITH NOTCH AT BOTTOM;Ll;0;L;;;;;N;;;1DF7C;;1DF7C +1DF7E;LATIN CAPITAL LETTER REVERSED U;Lu;0;L;;;;;N;;;;1DF7F; +1DF7F;LATIN SMALL LETTER REVERSED U;Ll;0;L;;;;;N;;;1DF7E;;1DF7E +1DF80;LATIN CAPITAL LETTER A WITH TOPBAR;Lo;0;L;;;;;N;;;;; +1DF81;LATIN CAPITAL LETTER E WITH BENT TOPBAR;Lo;0;L;;;;;N;;;;; +1DF90;LATIN SMALL LETTER C WITH LOW SLASH;Ll;0;L;;;;;N;;;;; +1DF91;LATIN SMALL LETTER C WITH LOOPED CEDILLA;Ll;0;L;;;;;N;;;;; +1DF92;LATIN SMALL LETTER C WITH RIGHT LOOP;Ll;0;L;;;;;N;;;;; +1DF93;LATIN SMALL LETTER D ROTUNDA WITH DESCENDING CROSSING LOOP;Ll;0;L;;;;;N;;;;; +1DF94;LATIN SMALL LETTER R ROTUNDA WITH LOOP;Ll;0;L;;;;;N;;;;; +1DF95;LATIN SMALL LIGATURE LONG S WITH DESCENDER S;Ll;0;L; 00DF;;;;N;;;;; +1DF96;LATIN SMALL LETTER LONG S WITH TOP LOOP;Ll;0;L;;;;;N;;;;; +1DFCD;MODIFIER LETTER SMALL TURNED R WITH MID-HEIGHT LEFT HOOK;Lm;0;L; 1DF57;;;;N;;;;; +1DFCE;MODIFIER LETTER SMALL SPLIT O;Lm;0;L; 1DF58;;;;N;;;;; +1DFCF;MODIFIER LETTER SMALL SPLIT U;Lm;0;L; 1DF59;;;;N;;;;; +1DFD0;LATIN SUBSCRIPT SMALL LETTER GAMMA;Lm;0;L; 0263;;;;N;;;;; +1DFD1;MODIFIER LETTER SMALL CAPITAL P;Lm;0;L; 1D18;;;;N;;;;; +1DFD2;MODIFIER LETTER SMALL B WITH STROKE;Lm;0;L; 0180;;;;N;;;;; +1DFD3;MODIFIER LETTER SMALL D WITH STROKE;Lm;0;L; 0111;;;;N;;;;; +1DFD4;MODIFIER LETTER SMALL G WITH STROKE;Lm;0;L; 01E5;;;;N;;;;; +1DFD5;MODIFIER LETTER SMALL L WITH STROKE;Lm;0;L; 0142;;;;N;;;;; +1DFD6;MODIFIER LETTER SMALL L WITH BAR;Lm;0;L; 019A;;;;N;;;;; +1DFD7;MODIFIER LETTER SMALL TURNED R WITH STROKE;Lm;0;L; 1DF50;;;;N;;;;; +1DFD8;MODIFIER LETTER SMALL BARRED TURNED H;Lm;0;L; 1DF3E;;;;N;;;;; +1DFD9;MODIFIER LETTER SMALL J WITH STROKE;Lm;0;L; 0249;;;;N;;;;; +1DFDA;MODIFIER LETTER SMALL UPSILON WITH STROKE;Lm;0;L; 1D7F;;;;N;;;;; +1DFDB;MODIFIER LETTER SMALL BARRED W;Lm;0;L; 1DF3F;;;;N;;;;; +1DFDC;MODIFIER LETTER SMALL N WITH LONG RIGHT LEG;Lm;0;L; 019E;;;;N;;;;; +1DFDD;MODIFIER LETTER SMALL R WITH LONG LEG;Lm;0;L; 027C;;;;N;;;;; +1DFDE;MODIFIER LETTER SMALL DB DIGRAPH;Lm;0;L; 0238;;;;N;;;;; +1DFDF;MODIFIER LETTER SMALL QP DIGRAPH;Lm;0;L; 0239;;;;N;;;;; +1DFE0;MODIFIER LETTER SMALL DEZH DIGRAPH WITH CURL;Lm;0;L; 1DF2B;;;;N;;;;; +1DFE1;MODIFIER LETTER SMALL DEZH DIGRAPH WITH RETROFLEX HOOK;Lm;0;L; 1DF19;;;;N;;;;; +1DFE2;MODIFIER LETTER SMALL ESH WITH CURL;Lm;0;L; 0286;;;;N;;;;; +1DFE3;MODIFIER LETTER SMALL ESH WITH RETROFLEX HOOK;Lm;0;L; 1D98;;;;N;;;;; +1DFE4;MODIFIER LETTER SMALL TESH DIGRAPH WITH CURL;Lm;0;L; 1DF2C;;;;N;;;;; +1DFE5;MODIFIER LETTER SMALL TESH DIGRAPH WITH RETROFLEX HOOK;Lm;0;L; 1DF1C;;;;N;;;;; +1DFE6;MODIFIER LETTER SMALL EZH WITH CURL;Lm;0;L; 0293;;;;N;;;;; +1DFE7;MODIFIER LETTER SMALL EZH WITH RETROFLEX HOOK;Lm;0;L; 1D9A;;;;N;;;;; +1DFE8;MODIFIER LETTER SMALL CAPITAL D;Lm;0;L; 1D05;;;;N;;;;; +1DFE9;MODIFIER LETTER SMALL CAPITAL A;Lm;0;L; 1D00;;;;N;;;;; +1DFEA;MODIFIER LETTER SMALL CAPITAL E;Lm;0;L; 1D07;;;;N;;;;; +1DFEB;MODIFIER LETTER SMALL REVERSED R WITH FISHHOOK;Lm;0;L; 027F;;;;N;;;;; +1DFEC;MODIFIER LETTER SMALL SQUAT REVERSED ESH;Lm;0;L; 0285;;;;N;;;;; +1DFED;MODIFIER LETTER SMALL TURNED H WITH FISHHOOK;Lm;0;L; 02AE;;;;N;;;;; +1DFEE;MODIFIER LETTER SMALL TURNED H WITH FISHHOOK AND TAIL;Lm;0;L; 02AF;;;;N;;;;; +1DFEF;MODIFIER LETTER SMALL D WITH CURL;Lm;0;L; 0221;;;;N;;;;; +1DFF0;MODIFIER LETTER SMALL L WITH CURL;Lm;0;L; 0234;;;;N;;;;; +1DFF1;MODIFIER LETTER SMALL N WITH CURL;Lm;0;L; 0235;;;;N;;;;; +1DFF2;MODIFIER LETTER SMALL T WITH CURL;Lm;0;L; 0236;;;;N;;;;; +1DFF3;MODIFIER LETTER SMALL GREEK PSI;Lm;0;L; 03C8;;;;N;;;;; +1DFF4;MODIFIER LETTER SMALL GREEK OMEGA;Lm;0;L; 03C9;;;;N;;;;; +1DFF5;MODIFIER LETTER SMALL D WITH PALATAL HOOK;Lm;0;L; 1D81;;;;N;;;;; +1DFF6;MODIFIER LETTER SMALL H WITH PALATAL HOOK;Lm;0;L; A795;;;;N;;;;; +1DFF7;MODIFIER LETTER SMALL N WITH PALATAL HOOK;Lm;0;L; 1D87;;;;N;;;;; +1DFF8;MODIFIER LETTER SMALL S WITH PALATAL HOOK;Lm;0;L; 1D8A;;;;N;;;;; +1DFF9;MODIFIER LETTER SMALL Z WITH PALATAL HOOK;Lm;0;L; 1D8E;;;;N;;;;; +1DFFA;MODIFIER LETTER SMALL C WITH HOOK;Lm;0;L; 0188;;;;N;;;;; +1DFFB;MODIFIER LETTER SMALL K WITH HOOK;Lm;0;L; 0199;;;;N;;;;; +1DFFC;MODIFIER LETTER SMALL P WITH HOOK;Lm;0;L; 01A5;;;;N;;;;; +1DFFD;MODIFIER LETTER SMALL Q WITH HOOK;Lm;0;L; 02A0;;;;N;;;;; +1DFFE;MODIFIER LETTER SMALL T WITH HOOK;Lm;0;L; 01AD;;;;N;;;;; +1DFFF;MODIFIER LETTER SMALL T WITH HOOK AND RETROFLEX HOOK;Lm;0;L; 1DF09;;;;N;;;;; 1E000;COMBINING GLAGOLITIC LETTER AZU;Mn;230;NSM;;;;;N;;;;; 1E001;COMBINING GLAGOLITIC LETTER BUKY;Mn;230;NSM;;;;;N;;;;; 1E002;COMBINING GLAGOLITIC LETTER VEDE;Mn;230;NSM;;;;;N;;;;; @@ -37437,6 +38174,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1F1AB;SQUARED UHD;So;0;L;;;;;N;;;;; 1F1AC;SQUARED VOD;So;0;L;;;;;N;;;;; 1F1AD;MASK WORK SYMBOL;So;0;ON;;;;;N;;;;; +1F1AE;TOMOBIKI SYMBOL;So;0;L;;;;;N;;;;; 1F1E6;REGIONAL INDICATOR SYMBOL LETTER A;So;0;L;;;;;N;;;;; 1F1E7;REGIONAL INDICATOR SYMBOL LETTER B;So;0;L;;;;;N;;;;; 1F1E8;REGIONAL INDICATOR SYMBOL LETTER C;So;0;L;;;;;N;;;;; @@ -38512,6 +39250,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1F6D6;HUT;So;0;ON;;;;;N;;;;; 1F6D7;ELEVATOR;So;0;ON;;;;;N;;;;; 1F6D8;LANDSLIDE;So;0;ON;;;;;N;;;;; +1F6D9;LIGHTHOUSE;So;0;ON;;;;;N;;;;; 1F6DC;WIRELESS;So;0;ON;;;;;N;;;;; 1F6DD;PLAYGROUND SLIDE;So;0;ON;;;;;N;;;;; 1F6DE;WHEEL;So;0;ON;;;;;N;;;;; @@ -38760,6 +39499,8 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1F7D7;CIRCLED SQUARE;So;0;ON;;;;;N;;;;; 1F7D8;NEGATIVE CIRCLED SQUARE;So;0;ON;;;;;N;;;;; 1F7D9;NINE POINTED WHITE STAR;So;0;ON;;;;;N;;;;; +1F7DA;BLACK CIRCLE WITH WHITE VERTICAL BAR;So;0;L;;;;;N;;;;; +1F7DB;BULLET IN DOUBLE CIRCLE;So;0;ON;;;;;N;;;;; 1F7E0;LARGE ORANGE CIRCLE;So;0;ON;;;;;N;;;;; 1F7E1;LARGE YELLOW CIRCLE;So;0;ON;;;;;N;;;;; 1F7E2;LARGE GREEN CIRCLE;So;0;ON;;;;;N;;;;; @@ -38773,6 +39514,21 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1F7EA;LARGE PURPLE SQUARE;So;0;ON;;;;;N;;;;; 1F7EB;LARGE BROWN SQUARE;So;0;ON;;;;;N;;;;; 1F7F0;HEAVY EQUALS SIGN;So;0;ON;;;;;N;;;;; +1F7F1;CIRCLE WITH DOUBLE VERTICAL AND HORIZONTAL LINE;So;0;ON;;;;;N;;;;; +1F7F2;DOUBLE CIRCLE WITH DOUBLE HORIZONTAL LINE;So;0;ON;;;;;N;;;;; +1F7F3;CIRCLED BOTTOM RIGHT OBLIQUE HALF BLACK CIRCLE;So;0;ON;;;;;N;;;;; +1F7F4;LEFT HALF WHITE CIRCLE;So;0;ON;;;;;N;;;;; +1F7F5;RIGHT HALF WHITE CIRCLE;So;0;ON;;;;;N;;;;; +1F7F6;TRANSPARENT CUBE;So;0;ON;;;;;N;;;;; +1F7F7;WHITE CUBE;So;0;ON;;;;;N;;;;; +1F7F8;HORIZONTAL DOUBLE WHITE SMALL SQUARE;So;0;ON;;;;;N;;;;; +1F7F9;VERTICAL DOUBLE WHITE SMALL SQUARE;So;0;ON;;;;;N;;;;; +1F7FA;WHITE SQUARE WITH BOTTOM HALF BISECTED;So;0;ON;;;;;N;;;;; +1F7FB;WHITE SQUARE WITH TOP HALF BISECTED;So;0;ON;;;;;N;;;;; +1F7FC;WHITE SQUARE WITH HORIZONTAL AND VERTICAL BISECTING LINES;So;0;ON;;;;;N;;;;; +1F7FD;LOWER LEFT FLATTENED RIGHT TRIANGLE;So;0;ON;;;;;N;;;;; +1F7FE;LOWER RIGHT FLATTENED RIGHT TRIANGLE;So;0;ON;;;;;N;;;;; +1F7FF;RHOMBUS;So;0;ON;;;;;N;;;;; 1F800;LEFTWARDS ARROW WITH SMALL TRIANGLE ARROWHEAD;So;0;ON;;;;;N;;;;; 1F801;UPWARDS ARROW WITH SMALL TRIANGLE ARROWHEAD;So;0;ON;;;;;N;;;;; 1F802;RIGHTWARDS ARROW WITH SMALL TRIANGLE ARROWHEAD;So;0;ON;;;;;N;;;;; @@ -39326,6 +40082,9 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1FA88;FLUTE;So;0;ON;;;;;N;;;;; 1FA89;HARP;So;0;ON;;;;;N;;;;; 1FA8A;TROMBONE;So;0;ON;;;;;N;;;;; +1FA8B;METEOR;So;0;ON;;;;;N;;;;; +1FA8C;ERASER;So;0;ON;;;;;N;;;;; +1FA8D;NET WITH HANDLE;So;0;ON;;;;;N;;;;; 1FA8E;TREASURE CHEST;So;0;ON;;;;;N;;;;; 1FA8F;SHOVEL;So;0;ON;;;;;N;;;;; 1FA90;RINGED PLANET;So;0;ON;;;;;N;;;;; @@ -39384,6 +40143,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1FAC5;PERSON WITH CROWN;So;0;ON;;;;;N;;;;; 1FAC6;FINGERPRINT;So;0;ON;;;;;N;;;;; 1FAC8;HAIRY CREATURE;So;0;ON;;;;;N;;;;; +1FACC;MONARCH BUTTERFLY;So;0;ON;;;;;N;;;;; 1FACD;ORCA;So;0;ON;;;;;N;;;;; 1FACE;MOOSE;So;0;ON;;;;;N;;;;; 1FACF;DONKEY;So;0;ON;;;;;N;;;;; @@ -39400,6 +40160,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1FADA;GINGER ROOT;So;0;ON;;;;;N;;;;; 1FADB;PEA POD;So;0;ON;;;;;N;;;;; 1FADC;ROOT VEGETABLE;So;0;ON;;;;;N;;;;; +1FADD;PICKLE;So;0;ON;;;;;N;;;;; 1FADF;SPLATTER;So;0;ON;;;;;N;;;;; 1FAE0;MELTING FACE;So;0;ON;;;;;N;;;;; 1FAE1;SALUTING FACE;So;0;ON;;;;;N;;;;; @@ -39412,6 +40173,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1FAE8;SHAKING FACE;So;0;ON;;;;;N;;;;; 1FAE9;FACE WITH BAGS UNDER EYES;So;0;ON;;;;;N;;;;; 1FAEA;DISTORTED FACE;So;0;ON;;;;;N;;;;; +1FAEB;CRACKING FACE;So;0;ON;;;;;N;;;;; 1FAEF;FIGHT CLOUD;So;0;ON;;;;;N;;;;; 1FAF0;HAND WITH INDEX FINGER AND THUMB CROSSED;So;0;ON;;;;;N;;;;; 1FAF1;RIGHTWARDS HAND;So;0;ON;;;;;N;;;;; @@ -39422,6 +40184,8 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 1FAF6;HEART HANDS;So;0;ON;;;;;N;;;;; 1FAF7;LEFTWARDS PUSHING HAND;So;0;ON;;;;;N;;;;; 1FAF8;RIGHTWARDS PUSHING HAND;So;0;ON;;;;;N;;;;; +1FAF9;LEFTWARDS THUMB SIGN;So;0;ON;;;;;N;;;;; +1FAFA;RIGHTWARDS THUMB SIGN;So;0;ON;;;;;N;;;;; 1FB00;BLOCK SEXTANT-1;So;0;ON;;;;;N;;;;; 1FB01;BLOCK SEXTANT-2;So;0;ON;;;;;N;;;;; 1FB02;BLOCK SEXTANT-12;So;0;ON;;;;;N;;;;; @@ -39677,7 +40441,7 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 2A700;;Lo;0;L;;;;;N;;;;; 2B73F;;Lo;0;L;;;;;N;;;;; 2B740;;Lo;0;L;;;;;N;;;;; -2B81D;;Lo;0;L;;;;;N;;;;; +2B81E;;Lo;0;L;;;;;N;;;;; 2B820;;Lo;0;L;;;;;N;;;;; 2CEAD;;Lo;0;L;;;;;N;;;;; 2CEB0;;Lo;0;L;;;;;N;;;;; @@ -40232,6 +40996,8 @@ FFFD;REPLACEMENT CHARACTER;So;0;ON;;;;;N;;;;; 323AF;;Lo;0;L;;;;;N;;;;; 323B0;;Lo;0;L;;;;;N;;;;; 33479;;Lo;0;L;;;;;N;;;;; +3D000;;Lo;0;L;;;;;N;;;;; +3FC3F;;Lo;0;L;;;;;N;;;;; E0001;LANGUAGE TAG;Cf;0;BN;;;;;N;;;;; E0020;TAG SPACE;Cf;0;BN;;;;;N;;;;; E0021;TAG EXCLAMATION MARK;Cf;0;BN;;;;;N;;;;; diff --git a/contrib/unicode/emoji-data.txt b/contrib/unicode/emoji-data.txt index 450252c4df3f..7a383f0dcfd6 100644 --- a/contrib/unicode/emoji-data.txt +++ b/contrib/unicode/emoji-data.txt @@ -1,11 +1,11 @@ # emoji-data.txt -# Date: 2025-07-25, 17:54:31 GMT -# © 2025 Unicode®, Inc. +# Date: 2026-01-30, 22:30:17 GMT +# © 2026 Unicode®, Inc. # Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries. # For terms of use and license, see https://www.unicode.org/terms_of_use.html # # Emoji Data for UTS #51 -# Version: 17.0 +# Version: 18.0.0 # # For documentation and usage, see https://www.unicode.org/reports/tr51 # @@ -341,6 +341,7 @@ 1F6D5 ; Emoji # E12.0 [1] (🛕) hindu temple 1F6D6..1F6D7 ; Emoji # E13.0 [2] (🛖..🛗) hut..elevator 1F6D8 ; Emoji # E17.0 [1] (🛘) landslide +1F6D9 ; Emoji # E18.0 [1] (🛙) lighthouse 1F6DC ; Emoji # E15.0 [1] (🛜) wireless 1F6DD..1F6DF ; Emoji # E14.0 [3] (🛝..🛟) playground slide..ring buoy 1F6E0..1F6E5 ; Emoji # E0.7 [6] (🛠️..🛥️) hammer and wrench..motor boat @@ -410,6 +411,7 @@ 1FA87..1FA88 ; Emoji # E15.0 [2] (🪇..🪈) maracas..flute 1FA89 ; Emoji # E16.0 [1] (🪉) harp 1FA8A ; Emoji # E17.0 [1] (🪊) trombone +1FA8B..1FA8D ; Emoji # E18.0 [3] (🪋..🪍) meteor..net with handle 1FA8E ; Emoji # E17.0 [1] (🪎) treasure chest 1FA8F ; Emoji # E16.0 [1] (🪏) shovel 1FA90..1FA95 ; Emoji # E12.0 [6] (🪐..🪕) ringed planet..banjo @@ -425,22 +427,26 @@ 1FAC3..1FAC5 ; Emoji # E14.0 [3] (🫃..🫅) pregnant man..person with crown 1FAC6 ; Emoji # E16.0 [1] (🫆) fingerprint 1FAC8 ; Emoji # E17.0 [1] (🫈) hairy creature +1FACC ; Emoji # E18.0 [1] (🫌) monarch butterfly 1FACD ; Emoji # E17.0 [1] (🫍) orca 1FACE..1FACF ; Emoji # E15.0 [2] (🫎..🫏) moose..donkey 1FAD0..1FAD6 ; Emoji # E13.0 [7] (🫐..🫖) blueberries..teapot 1FAD7..1FAD9 ; Emoji # E14.0 [3] (🫗..🫙) pouring liquid..jar 1FADA..1FADB ; Emoji # E15.0 [2] (🫚..🫛) ginger root..pea pod 1FADC ; Emoji # E16.0 [1] (🫜) root vegetable +1FADD ; Emoji # E18.0 [1] (🫝) pickle 1FADF ; Emoji # E16.0 [1] (🫟) splatter 1FAE0..1FAE7 ; Emoji # E14.0 [8] (🫠..🫧) melting face..bubbles 1FAE8 ; Emoji # E15.0 [1] (🫨) shaking face 1FAE9 ; Emoji # E16.0 [1] (🫩) face with bags under eyes 1FAEA ; Emoji # E17.0 [1] (🫪) distorted face +1FAEB ; Emoji # E18.0 [1] (🫫) cracking face 1FAEF ; Emoji # E17.0 [1] (🫯) fight cloud 1FAF0..1FAF6 ; Emoji # E14.0 [7] (🫰..🫶) hand with index finger and thumb crossed..heart hands 1FAF7..1FAF8 ; Emoji # E15.0 [2] (🫷..🫸) leftwards pushing hand..rightwards pushing hand +1FAF9..1FAFA ; Emoji # E18.0 [2] (🫹..🫺) leftwards thumb sign..rightwards thumb sign -# Total elements: 1438 +# Total elements: 1447 # ================================================ @@ -648,6 +654,7 @@ 1F6D5 ; Emoji_Presentation # E12.0 [1] (🛕) hindu temple 1F6D6..1F6D7 ; Emoji_Presentation # E13.0 [2] (🛖..🛗) hut..elevator 1F6D8 ; Emoji_Presentation # E17.0 [1] (🛘) landslide +1F6D9 ; Emoji_Presentation # E18.0 [1] (🛙) lighthouse 1F6DC ; Emoji_Presentation # E15.0 [1] (🛜) wireless 1F6DD..1F6DF ; Emoji_Presentation # E14.0 [3] (🛝..🛟) playground slide..ring buoy 1F6EB..1F6EC ; Emoji_Presentation # E1.0 [2] (🛫..🛬) airplane departure..airplane arrival @@ -713,6 +720,7 @@ 1FA87..1FA88 ; Emoji_Presentation # E15.0 [2] (🪇..🪈) maracas..flute 1FA89 ; Emoji_Presentation # E16.0 [1] (🪉) harp 1FA8A ; Emoji_Presentation # E17.0 [1] (🪊) trombone +1FA8B..1FA8D ; Emoji_Presentation # E18.0 [3] (🪋..🪍) meteor..net with handle 1FA8E ; Emoji_Presentation # E17.0 [1] (🪎) treasure chest 1FA8F ; Emoji_Presentation # E16.0 [1] (🪏) shovel 1FA90..1FA95 ; Emoji_Presentation # E12.0 [6] (🪐..🪕) ringed planet..banjo @@ -728,22 +736,26 @@ 1FAC3..1FAC5 ; Emoji_Presentation # E14.0 [3] (🫃..🫅) pregnant man..person with crown 1FAC6 ; Emoji_Presentation # E16.0 [1] (🫆) fingerprint 1FAC8 ; Emoji_Presentation # E17.0 [1] (🫈) hairy creature +1FACC ; Emoji_Presentation # E18.0 [1] (🫌) monarch butterfly 1FACD ; Emoji_Presentation # E17.0 [1] (🫍) orca 1FACE..1FACF ; Emoji_Presentation # E15.0 [2] (🫎..🫏) moose..donkey 1FAD0..1FAD6 ; Emoji_Presentation # E13.0 [7] (🫐..🫖) blueberries..teapot 1FAD7..1FAD9 ; Emoji_Presentation # E14.0 [3] (🫗..🫙) pouring liquid..jar 1FADA..1FADB ; Emoji_Presentation # E15.0 [2] (🫚..🫛) ginger root..pea pod 1FADC ; Emoji_Presentation # E16.0 [1] (🫜) root vegetable +1FADD ; Emoji_Presentation # E18.0 [1] (🫝) pickle 1FADF ; Emoji_Presentation # E16.0 [1] (🫟) splatter 1FAE0..1FAE7 ; Emoji_Presentation # E14.0 [8] (🫠..🫧) melting face..bubbles 1FAE8 ; Emoji_Presentation # E15.0 [1] (🫨) shaking face 1FAE9 ; Emoji_Presentation # E16.0 [1] (🫩) face with bags under eyes 1FAEA ; Emoji_Presentation # E17.0 [1] (🫪) distorted face +1FAEB ; Emoji_Presentation # E18.0 [1] (🫫) cracking face 1FAEF ; Emoji_Presentation # E17.0 [1] (🫯) fight cloud 1FAF0..1FAF6 ; Emoji_Presentation # E14.0 [7] (🫰..🫶) hand with index finger and thumb crossed..heart hands 1FAF7..1FAF8 ; Emoji_Presentation # E15.0 [2] (🫷..🫸) leftwards pushing hand..rightwards pushing hand +1FAF9..1FAFA ; Emoji_Presentation # E18.0 [2] (🫹..🫺) leftwards thumb sign..rightwards thumb sign -# Total elements: 1219 +# Total elements: 1228 # ================================================ @@ -807,8 +819,9 @@ 1FAC3..1FAC5 ; Emoji_Modifier_Base # E14.0 [3] (🫃..🫅) pregnant man..person with crown 1FAF0..1FAF6 ; Emoji_Modifier_Base # E14.0 [7] (🫰..🫶) hand with index finger and thumb crossed..heart hands 1FAF7..1FAF8 ; Emoji_Modifier_Base # E15.0 [2] (🫷..🫸) leftwards pushing hand..rightwards pushing hand +1FAF9..1FAFA ; Emoji_Modifier_Base # E18.0 [2] (🫹..🫺) leftwards thumb sign..rightwards thumb sign -# Total elements: 134 +# Total elements: 136 # ================================================ @@ -954,7 +967,7 @@ E0020..E007F ; Emoji_Component # E0.0 [96] (󠀠..󠁿) tag space..c 1F17E..1F17F ; Extended_Pictographic# E0.6 [2] (🅾️..🅿️) O button (blood type)..P button 1F18E ; Extended_Pictographic# E0.6 [1] (🆎) AB button (blood type) 1F191..1F19A ; Extended_Pictographic# E0.6 [10] (🆑..🆚) CL button..VS button -1F1AE..1F1E5 ; Extended_Pictographic# E0.0 [56] (🆮..🇥) .. +1F1AF..1F1E5 ; Extended_Pictographic# E0.0 [55] (🆯..🇥) .. 1F201..1F202 ; Extended_Pictographic# E0.6 [2] (🈁..🈂️) Japanese “here” button..Japanese “service charge” button 1F203..1F20F ; Extended_Pictographic# E0.0 [13] (🈃..🈏) .. 1F21A ; Extended_Pictographic# E0.6 [1] (🈚) Japanese “free of charge” button @@ -1160,7 +1173,8 @@ E0020..E007F ; Emoji_Component # E0.0 [96] (󠀠..󠁿) tag space..c 1F6D5 ; Extended_Pictographic# E12.0 [1] (🛕) hindu temple 1F6D6..1F6D7 ; Extended_Pictographic# E13.0 [2] (🛖..🛗) hut..elevator 1F6D8 ; Extended_Pictographic# E17.0 [1] (🛘) landslide -1F6D9..1F6DB ; Extended_Pictographic# E0.0 [3] (🛙..🛛) .. +1F6D9 ; Extended_Pictographic# E18.0 [1] (🛙) lighthouse +1F6DA..1F6DB ; Extended_Pictographic# E0.0 [2] (🛚..🛛) .. 1F6DC ; Extended_Pictographic# E15.0 [1] (🛜) wireless 1F6DD..1F6DF ; Extended_Pictographic# E14.0 [3] (🛝..🛟) playground slide..ring buoy 1F6E0..1F6E5 ; Extended_Pictographic# E0.7 [6] (🛠️..🛥️) hammer and wrench..motor boat @@ -1175,11 +1189,10 @@ E0020..E007F ; Emoji_Component # E0.0 [96] (󠀠..󠁿) tag space..c 1F6FA ; Extended_Pictographic# E12.0 [1] (🛺) auto rickshaw 1F6FB..1F6FC ; Extended_Pictographic# E13.0 [2] (🛻..🛼) pickup truck..roller skate 1F6FD..1F6FF ; Extended_Pictographic# E0.0 [3] (🛽..🛿) .. -1F7DA..1F7DF ; Extended_Pictographic# E0.0 [6] (🟚..🟟) .. +1F7DC..1F7DF ; Extended_Pictographic# E0.0 [4] (🟜..🟟) .. 1F7E0..1F7EB ; Extended_Pictographic# E12.0 [12] (🟠..🟫) orange circle..brown square 1F7EC..1F7EF ; Extended_Pictographic# E0.0 [4] (🟬..🟯) .. 1F7F0 ; Extended_Pictographic# E14.0 [1] (🟰) heavy equals sign -1F7F1..1F7FF ; Extended_Pictographic# E0.0 [15] (🟱..🟿) .. 1F80C..1F80F ; Extended_Pictographic# E0.0 [4] (🠌..🠏) .. 1F848..1F84F ; Extended_Pictographic# E0.0 [8] (🡈..🡏) .. 1F85A..1F85F ; Extended_Pictographic# E0.0 [6] (🡚..🡟) .. @@ -1246,7 +1259,7 @@ E0020..E007F ; Emoji_Component # E0.0 [96] (󠀠..󠁿) tag space..c 1FA87..1FA88 ; Extended_Pictographic# E15.0 [2] (🪇..🪈) maracas..flute 1FA89 ; Extended_Pictographic# E16.0 [1] (🪉) harp 1FA8A ; Extended_Pictographic# E17.0 [1] (🪊) trombone -1FA8B..1FA8D ; Extended_Pictographic# E0.0 [3] (🪋..🪍) .. +1FA8B..1FA8D ; Extended_Pictographic# E18.0 [3] (🪋..🪍) meteor..net with handle 1FA8E ; Extended_Pictographic# E17.0 [1] (🪎) treasure chest 1FA8F ; Extended_Pictographic# E16.0 [1] (🪏) shovel 1FA90..1FA95 ; Extended_Pictographic# E12.0 [6] (🪐..🪕) ringed planet..banjo @@ -1263,26 +1276,30 @@ E0020..E007F ; Emoji_Component # E0.0 [96] (󠀠..󠁿) tag space..c 1FAC6 ; Extended_Pictographic# E16.0 [1] (🫆) fingerprint 1FAC7 ; Extended_Pictographic# E0.0 [1] (🫇) 1FAC8 ; Extended_Pictographic# E17.0 [1] (🫈) hairy creature -1FAC9..1FACC ; Extended_Pictographic# E0.0 [4] (🫉..🫌) .. +1FAC9..1FACB ; Extended_Pictographic# E0.0 [3] (🫉..🫋) .. +1FACC ; Extended_Pictographic# E18.0 [1] (🫌) monarch butterfly 1FACD ; Extended_Pictographic# E17.0 [1] (🫍) orca 1FACE..1FACF ; Extended_Pictographic# E15.0 [2] (🫎..🫏) moose..donkey 1FAD0..1FAD6 ; Extended_Pictographic# E13.0 [7] (🫐..🫖) blueberries..teapot 1FAD7..1FAD9 ; Extended_Pictographic# E14.0 [3] (🫗..🫙) pouring liquid..jar 1FADA..1FADB ; Extended_Pictographic# E15.0 [2] (🫚..🫛) ginger root..pea pod 1FADC ; Extended_Pictographic# E16.0 [1] (🫜) root vegetable -1FADD..1FADE ; Extended_Pictographic# E0.0 [2] (🫝..🫞) .. +1FADD ; Extended_Pictographic# E18.0 [1] (🫝) pickle +1FADE ; Extended_Pictographic# E0.0 [1] (🫞) 1FADF ; Extended_Pictographic# E16.0 [1] (🫟) splatter 1FAE0..1FAE7 ; Extended_Pictographic# E14.0 [8] (🫠..🫧) melting face..bubbles 1FAE8 ; Extended_Pictographic# E15.0 [1] (🫨) shaking face 1FAE9 ; Extended_Pictographic# E16.0 [1] (🫩) face with bags under eyes 1FAEA ; Extended_Pictographic# E17.0 [1] (🫪) distorted face -1FAEB..1FAEE ; Extended_Pictographic# E0.0 [4] (🫫..🫮) .. +1FAEB ; Extended_Pictographic# E18.0 [1] (🫫) cracking face +1FAEC..1FAEE ; Extended_Pictographic# E0.0 [3] (🫬..🫮) .. 1FAEF ; Extended_Pictographic# E17.0 [1] (🫯) fight cloud 1FAF0..1FAF6 ; Extended_Pictographic# E14.0 [7] (🫰..🫶) hand with index finger and thumb crossed..heart hands 1FAF7..1FAF8 ; Extended_Pictographic# E15.0 [2] (🫷..🫸) leftwards pushing hand..rightwards pushing hand -1FAF9..1FAFF ; Extended_Pictographic# E0.0 [7] (🫹..🫿) .. +1FAF9..1FAFA ; Extended_Pictographic# E18.0 [2] (🫹..🫺) leftwards thumb sign..rightwards thumb sign +1FAFB..1FAFF ; Extended_Pictographic# E0.0 [5] (🫻..🫿) .. 1FC00..1FFFD ; Extended_Pictographic# E0.0[1022] (🰀..🿽) .. -# Total elements: 2848 +# Total elements: 2830 #EOF diff --git a/contrib/unicode/gen_libstdcxx_unicode_data.py b/contrib/unicode/gen_libstdcxx_unicode_data.py index f5f3ab282481..91cb201e1ff6 100755 --- a/contrib/unicode/gen_libstdcxx_unicode_data.py +++ b/contrib/unicode/gen_libstdcxx_unicode_data.py @@ -64,7 +64,7 @@ """) print("#ifndef _GLIBCXX_GET_UNICODE_DATA") print('# error "This is not a public header, do not include it directly"') -print("#elif _GLIBCXX_GET_UNICODE_DATA != 160000") +print("#elif _GLIBCXX_GET_UNICODE_DATA != 180000") print('# error "Version mismatch for Unicode static data"') print("#endif\n") diff --git a/gcc/testsuite/c-c++-common/cpp/named-universal-char-escape-1.c b/gcc/testsuite/c-c++-common/cpp/named-universal-char-escape-1.c index 9ff93f92129a..689561e85402 100644 --- a/gcc/testsuite/c-c++-common/cpp/named-universal-char-escape-1.c +++ b/gcc/testsuite/c-c++-common/cpp/named-universal-char-escape-1.c @@ -119,6 +119,9 @@ typedef __CHAR32_TYPE__ char32_t; || U'\uFE18' != U'\N{PRESENTATION FORM FOR VERTICAL RIGHT WHITE LENTICULAR BRACKET}' \ || U'\u0CF3' != U'\N{KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT}' \ || U'\u0ECE' != U'\N{LAO YAMAKKAN}' \ + || U'\u05C9' != U'\N{HEBREW POINT DAGESH HAZAQ MUDGASH}' \ + || U'\u20C3' != U'\N{UAE DIRHAM SIGN}' \ + || U'\U00010EE1' != U'\N{ARABIC CROWN LETTER SHEEN}' \ || U'\U00010EFE' != U'\N{ARABIC SMALL LOW WORD QASR}' \ || U'\U00011241' != U'\N{KHOJKI VOWEL SIGN VOCALIC R}' \ || U'\U00011B06' != U'\N{DEVANAGARI SIGN WESTERN FIVE-LIKE BHALE}' \ @@ -160,6 +163,7 @@ typedef __CHAR32_TYPE__ char32_t; || U'\U0002B739' != U'\N{CJK UNIFIED IDEOGRAPH-2B739}' \ || U'\U0002B740' != U'\N{CJK UNIFIED IDEOGRAPH-2B740}' \ || U'\U0002B81D' != U'\N{CJK UNIFIED IDEOGRAPH-2B81D}' \ + || U'\U0002B81E' != U'\N{CJK UNIFIED IDEOGRAPH-2B81E}' \ || U'\U0002B820' != U'\N{CJK UNIFIED IDEOGRAPH-2B820}' \ || U'\U0002CEA1' != U'\N{CJK UNIFIED IDEOGRAPH-2CEA1}' \ || U'\U0002CEB0' != U'\N{CJK UNIFIED IDEOGRAPH-2CEB0}' \ @@ -175,10 +179,16 @@ typedef __CHAR32_TYPE__ char32_t; || U'\U000187F7' != U'\N{TANGUT IDEOGRAPH-187F7}' \ || U'\U00018D00' != U'\N{TANGUT IDEOGRAPH-18D00}' \ || U'\U00018D08' != U'\N{TANGUT IDEOGRAPH-18D08}' \ + || U'\U00018D20' != U'\N{TANGUT IDEOGRAPH-18D20}' \ || U'\U00018B00' != U'\N{KHITAN SMALL SCRIPT CHARACTER-18B00}' \ || U'\U00018CD5' != U'\N{KHITAN SMALL SCRIPT CHARACTER-18CD5}' \ + || U'\U00018CDA' != U'\N{KHITAN SMALL SCRIPT CHARACTER-18CDA}' \ + || U'\U00018E00' != U'\N{JURCHEN CHARACTER-18E00}' \ + || U'\U00019191' != U'\N{JURCHEN CHARACTER-19191}' \ || U'\U0001B170' != U'\N{NUSHU CHARACTER-1B170}' \ || U'\U0001B2FB' != U'\N{NUSHU CHARACTER-1B2FB}' \ + || U'\U0003D000' != U'\N{SMALL SEAL CHARACTER-3D000}' \ + || U'\U0003FC3F' != U'\N{SMALL SEAL CHARACTER-3FC3F}' \ || U'\uF900' != U'\N{CJK COMPATIBILITY IDEOGRAPH-F900}' \ || U'\uFA6D' != U'\N{CJK COMPATIBILITY IDEOGRAPH-FA6D}' \ || U'\uFA70' != U'\N{CJK COMPATIBILITY IDEOGRAPH-FA70}' \ diff --git a/libcpp/generated_cpp_wcwidth.h b/libcpp/generated_cpp_wcwidth.h index b2ca8deb4a53..a93536f4e291 100644 --- a/libcpp/generated_cpp_wcwidth.h +++ b/libcpp/generated_cpp_wcwidth.h @@ -1,9 +1,9 @@ /* Generated by contrib/unicode/gen_wcwidth.py, with the help of glibc's - utf8_gen.py, using version 17.0 of the Unicode standard. */ + utf8_gen.py, using version 18.0 of the Unicode standard. */ static const cppchar_t wcwidth_range_ends[] = { 0x2ff, 0x36f, 0x482, 0x489, 0x590, 0x5bd, 0x5be, 0x5bf, - 0x5c0, 0x5c2, 0x5c3, 0x5c5, 0x5c6, 0x5c7, 0x60f, 0x61a, + 0x5c0, 0x5c2, 0x5c3, 0x5c5, 0x5c6, 0x5c9, 0x60f, 0x61a, 0x61b, 0x61c, 0x64a, 0x65f, 0x66f, 0x670, 0x6d5, 0x6dc, 0x6de, 0x6e4, 0x6e6, 0x6e8, 0x6e9, 0x6ed, 0x710, 0x711, 0x72f, 0x74a, 0x7a5, 0x7b0, 0x7ea, 0x7f3, 0x7fc, 0x7fd, @@ -17,7 +17,7 @@ static const cppchar_t wcwidth_range_ends[] = { 0xa80, 0xa82, 0xabb, 0xabc, 0xac0, 0xac5, 0xac6, 0xac8, 0xacc, 0xacd, 0xae1, 0xae3, 0xaf9, 0xaff, 0xb00, 0xb01, 0xb3b, 0xb3c, 0xb3e, 0xb3f, 0xb40, 0xb44, 0xb4c, 0xb4d, - 0xb54, 0xb56, 0xb61, 0xb63, 0xb81, 0xb82, 0xbbf, 0xbc0, + 0xb52, 0xb56, 0xb61, 0xb63, 0xb81, 0xb82, 0xbbf, 0xbc0, 0xbcc, 0xbcd, 0xbff, 0xc00, 0xc03, 0xc04, 0xc3b, 0xc3c, 0xc3d, 0xc40, 0xc45, 0xc48, 0xc49, 0xc4d, 0xc54, 0xc56, 0xc61, 0xc63, 0xc80, 0xc81, 0xcbb, 0xcbc, 0xcbe, 0xcbf, @@ -37,44 +37,44 @@ static const cppchar_t wcwidth_range_ends[] = { 0x1886, 0x18a8, 0x18a9, 0x191f, 0x1922, 0x1926, 0x1928, 0x1931, 0x1932, 0x1938, 0x193b, 0x1a16, 0x1a18, 0x1a1a, 0x1a1b, 0x1a55, 0x1a56, 0x1a57, 0x1a5e, 0x1a5f, 0x1a60, 0x1a61, 0x1a62, 0x1a64, - 0x1a6c, 0x1a72, 0x1a7c, 0x1a7e, 0x1a7f, 0x1aaf, 0x1add, 0x1adf, - 0x1aeb, 0x1aff, 0x1b03, 0x1b33, 0x1b34, 0x1b35, 0x1b3a, 0x1b3b, - 0x1b3c, 0x1b41, 0x1b42, 0x1b6a, 0x1b73, 0x1b7f, 0x1b81, 0x1ba1, - 0x1ba5, 0x1ba7, 0x1ba9, 0x1baa, 0x1bad, 0x1be5, 0x1be6, 0x1be7, - 0x1be9, 0x1bec, 0x1bed, 0x1bee, 0x1bf1, 0x1c2b, 0x1c33, 0x1c35, - 0x1c37, 0x1ccf, 0x1cd2, 0x1cd3, 0x1ce0, 0x1ce1, 0x1ce8, 0x1cec, - 0x1ced, 0x1cf3, 0x1cf4, 0x1cf7, 0x1cf9, 0x1dbf, 0x1dff, 0x200a, - 0x200f, 0x2029, 0x202e, 0x205f, 0x2064, 0x2065, 0x206f, 0x20cf, - 0x20f0, 0x2319, 0x231b, 0x2328, 0x232a, 0x23e8, 0x23ec, 0x23ef, - 0x23f0, 0x23f2, 0x23f3, 0x25fc, 0x25fe, 0x2613, 0x2615, 0x262f, - 0x2637, 0x2647, 0x2653, 0x267e, 0x267f, 0x2689, 0x268f, 0x2692, - 0x2693, 0x26a0, 0x26a1, 0x26a9, 0x26ab, 0x26bc, 0x26be, 0x26c3, - 0x26c5, 0x26cd, 0x26ce, 0x26d3, 0x26d4, 0x26e9, 0x26ea, 0x26f1, - 0x26f3, 0x26f4, 0x26f5, 0x26f9, 0x26fa, 0x26fc, 0x26fd, 0x2704, - 0x2705, 0x2709, 0x270b, 0x2727, 0x2728, 0x274b, 0x274c, 0x274d, - 0x274e, 0x2752, 0x2755, 0x2756, 0x2757, 0x2794, 0x2797, 0x27af, - 0x27b0, 0x27be, 0x27bf, 0x2b1a, 0x2b1c, 0x2b4f, 0x2b50, 0x2b54, - 0x2b55, 0x2cee, 0x2cf1, 0x2d7e, 0x2d7f, 0x2ddf, 0x2dff, 0x2e7f, - 0x2e99, 0x2e9a, 0x2ef3, 0x2eff, 0x2fd5, 0x2fef, 0x3029, 0x302d, - 0x303e, 0x3040, 0x3096, 0x3098, 0x309a, 0x30ff, 0x3104, 0x312f, - 0x3130, 0x3163, 0x3164, 0x318e, 0x318f, 0x31e5, 0x31ee, 0x321e, - 0x321f, 0xa48c, 0xa48f, 0xa4c6, 0xa66e, 0xa672, 0xa673, 0xa67d, - 0xa69d, 0xa69f, 0xa6ef, 0xa6f1, 0xa801, 0xa802, 0xa805, 0xa806, - 0xa80a, 0xa80b, 0xa824, 0xa826, 0xa82b, 0xa82c, 0xa8c3, 0xa8c5, - 0xa8df, 0xa8f1, 0xa8fe, 0xa8ff, 0xa925, 0xa92d, 0xa946, 0xa951, - 0xa95f, 0xa97c, 0xa97f, 0xa982, 0xa9b2, 0xa9b3, 0xa9b5, 0xa9b9, - 0xa9bb, 0xa9bd, 0xa9e4, 0xa9e5, 0xaa28, 0xaa2e, 0xaa30, 0xaa32, - 0xaa34, 0xaa36, 0xaa42, 0xaa43, 0xaa4b, 0xaa4c, 0xaa7b, 0xaa7c, - 0xaaaf, 0xaab0, 0xaab1, 0xaab4, 0xaab6, 0xaab8, 0xaabd, 0xaabf, - 0xaac0, 0xaac1, 0xaaeb, 0xaaed, 0xaaf5, 0xaaf6, 0xabe4, 0xabe5, - 0xabe7, 0xabe8, 0xabec, 0xabed, 0xabff, 0xd7a3, 0xd7af, 0xd7c6, - 0xd7ca, 0xd7fb, 0xf8ff, 0xfa6d, 0xfa6f, 0xfad9, 0xfb1d, 0xfb1e, - 0xfdff, 0xfe0f, 0xfe19, 0xfe1f, 0xfe2f, 0xfe52, 0xfe53, 0xfe66, - 0xfe67, 0xfe6b, 0xfefe, 0xfeff, 0xff00, 0xff60, 0xff9f, 0xffa0, - 0xffdf, 0xffe6, 0x101fc, 0x101fd, 0x102df, 0x102e0, 0x10375, 0x1037a, - 0x10a00, 0x10a03, 0x10a04, 0x10a06, 0x10a0b, 0x10a0f, 0x10a37, 0x10a3a, - 0x10a3e, 0x10a3f, 0x10ae4, 0x10ae6, 0x10d23, 0x10d27, 0x10d68, 0x10d6d, - 0x10eaa, 0x10eac, 0x10ef9, 0x10eff, 0x10f45, 0x10f50, 0x10f81, 0x10f85, + 0x1a6c, 0x1a72, 0x1a7c, 0x1a7e, 0x1a7f, 0x1aaf, 0x1af0, 0x1aff, + 0x1b03, 0x1b33, 0x1b34, 0x1b35, 0x1b3a, 0x1b3b, 0x1b3c, 0x1b41, + 0x1b42, 0x1b6a, 0x1b73, 0x1b7f, 0x1b81, 0x1ba1, 0x1ba5, 0x1ba7, + 0x1ba9, 0x1baa, 0x1bad, 0x1be5, 0x1be6, 0x1be7, 0x1be9, 0x1bec, + 0x1bed, 0x1bee, 0x1bf1, 0x1c2b, 0x1c33, 0x1c35, 0x1c37, 0x1ccf, + 0x1cd2, 0x1cd3, 0x1ce0, 0x1ce1, 0x1ce8, 0x1cec, 0x1ced, 0x1cf3, + 0x1cf4, 0x1cf7, 0x1cf9, 0x1dbf, 0x1dff, 0x200a, 0x200f, 0x2029, + 0x202e, 0x205f, 0x2064, 0x2065, 0x206f, 0x20cf, 0x20f0, 0x2319, + 0x231b, 0x2328, 0x232a, 0x23e8, 0x23ec, 0x23ef, 0x23f0, 0x23f2, + 0x23f3, 0x25fc, 0x25fe, 0x2613, 0x2615, 0x262f, 0x2637, 0x2647, + 0x2653, 0x267e, 0x267f, 0x2689, 0x268f, 0x2692, 0x2693, 0x26a0, + 0x26a1, 0x26a9, 0x26ab, 0x26bc, 0x26be, 0x26c3, 0x26c5, 0x26cd, + 0x26ce, 0x26d3, 0x26d4, 0x26e9, 0x26ea, 0x26f1, 0x26f3, 0x26f4, + 0x26f5, 0x26f9, 0x26fa, 0x26fc, 0x26fd, 0x2704, 0x2705, 0x2709, + 0x270b, 0x2727, 0x2728, 0x274b, 0x274c, 0x274d, 0x274e, 0x2752, + 0x2755, 0x2756, 0x2757, 0x2794, 0x2797, 0x27af, 0x27b0, 0x27be, + 0x27bf, 0x2b1a, 0x2b1c, 0x2b4f, 0x2b50, 0x2b54, 0x2b55, 0x2cee, + 0x2cf1, 0x2d7e, 0x2d7f, 0x2ddf, 0x2dff, 0x2e7f, 0x2e99, 0x2e9a, + 0x2ef3, 0x2eff, 0x2fd5, 0x2fef, 0x3029, 0x302d, 0x303e, 0x3040, + 0x3096, 0x3098, 0x309a, 0x30ff, 0x3104, 0x312f, 0x3130, 0x3163, + 0x3164, 0x318e, 0x318f, 0x31e5, 0x31ee, 0x321e, 0x321f, 0xa48c, + 0xa48f, 0xa4c6, 0xa66e, 0xa672, 0xa673, 0xa67d, 0xa69d, 0xa69f, + 0xa6ef, 0xa6f1, 0xa801, 0xa802, 0xa805, 0xa806, 0xa80a, 0xa80b, + 0xa824, 0xa826, 0xa82b, 0xa82c, 0xa8c3, 0xa8c5, 0xa8df, 0xa8f1, + 0xa8fe, 0xa8ff, 0xa925, 0xa92d, 0xa946, 0xa951, 0xa95f, 0xa97c, + 0xa97f, 0xa982, 0xa9b2, 0xa9b3, 0xa9b5, 0xa9b9, 0xa9bb, 0xa9bd, + 0xa9e4, 0xa9e5, 0xaa28, 0xaa2e, 0xaa30, 0xaa32, 0xaa34, 0xaa36, + 0xaa42, 0xaa43, 0xaa4b, 0xaa4c, 0xaa7b, 0xaa7c, 0xaaaf, 0xaab0, + 0xaab1, 0xaab4, 0xaab6, 0xaab8, 0xaabd, 0xaabf, 0xaac0, 0xaac1, + 0xaaeb, 0xaaed, 0xaaf5, 0xaaf6, 0xabe4, 0xabe5, 0xabe7, 0xabe8, + 0xabec, 0xabed, 0xabff, 0xd7a3, 0xd7af, 0xd7c6, 0xd7ca, 0xd7fb, + 0xf8ff, 0xfa6d, 0xfa6f, 0xfad9, 0xfb1d, 0xfb1e, 0xfdff, 0xfe0f, + 0xfe19, 0xfe1f, 0xfe2f, 0xfe52, 0xfe53, 0xfe66, 0xfe67, 0xfe6b, + 0xfefe, 0xfeff, 0xff00, 0xff60, 0xff9f, 0xffa0, 0xffdf, 0xffe6, + 0x101fc, 0x101fd, 0x102df, 0x102e0, 0x10375, 0x1037a, 0x10a00, 0x10a03, + 0x10a04, 0x10a06, 0x10a0b, 0x10a0f, 0x10a37, 0x10a3a, 0x10a3e, 0x10a3f, + 0x10ae4, 0x10ae6, 0x10d23, 0x10d27, 0x10d68, 0x10d6d, 0x10eaa, 0x10eac, + 0x10eca, 0x10ecf, 0x10eef, 0x10eff, 0x10f45, 0x10f50, 0x10f81, 0x10f85, 0x11000, 0x11001, 0x11037, 0x11046, 0x1106f, 0x11070, 0x11072, 0x11074, 0x1107e, 0x11081, 0x110b2, 0x110b6, 0x110b8, 0x110ba, 0x110c1, 0x110c2, 0x110ff, 0x11102, 0x11126, 0x1112b, 0x1112c, 0x11134, 0x11172, 0x11173, @@ -97,37 +97,39 @@ static const cppchar_t wcwidth_range_ends[] = { 0x11c37, 0x11c3d, 0x11c3e, 0x11c3f, 0x11c91, 0x11ca7, 0x11ca9, 0x11cb0, 0x11cb1, 0x11cb3, 0x11cb4, 0x11cb6, 0x11d30, 0x11d36, 0x11d39, 0x11d3a, 0x11d3b, 0x11d3d, 0x11d3e, 0x11d45, 0x11d46, 0x11d47, 0x11d8f, 0x11d91, - 0x11d94, 0x11d95, 0x11d96, 0x11d97, 0x11ef2, 0x11ef4, 0x11eff, 0x11f01, - 0x11f35, 0x11f3a, 0x11f3f, 0x11f40, 0x11f41, 0x11f42, 0x11f59, 0x11f5a, - 0x1343f, 0x13440, 0x13446, 0x13455, 0x1611d, 0x16129, 0x1612c, 0x1612f, - 0x16aef, 0x16af4, 0x16b2f, 0x16b36, 0x16f4e, 0x16f4f, 0x16f8e, 0x16f92, - 0x16fdf, 0x16fe3, 0x16fe4, 0x16fef, 0x16ff6, 0x16fff, 0x18cd5, 0x18cfe, - 0x18d1e, 0x18d7f, 0x18df2, 0x1afef, 0x1aff3, 0x1aff4, 0x1affb, 0x1affc, - 0x1affe, 0x1afff, 0x1b122, 0x1b131, 0x1b132, 0x1b14f, 0x1b152, 0x1b154, - 0x1b155, 0x1b163, 0x1b167, 0x1b16f, 0x1b2fb, 0x1bc9c, 0x1bc9e, 0x1bc9f, - 0x1bca3, 0x1ceff, 0x1cf2d, 0x1cf2f, 0x1cf46, 0x1d166, 0x1d169, 0x1d172, - 0x1d182, 0x1d184, 0x1d18b, 0x1d1a9, 0x1d1ad, 0x1d241, 0x1d244, 0x1d2ff, - 0x1d356, 0x1d35f, 0x1d376, 0x1d9ff, 0x1da36, 0x1da3a, 0x1da6c, 0x1da74, - 0x1da75, 0x1da83, 0x1da84, 0x1da9a, 0x1da9f, 0x1daa0, 0x1daaf, 0x1dfff, - 0x1e006, 0x1e007, 0x1e018, 0x1e01a, 0x1e021, 0x1e022, 0x1e024, 0x1e025, - 0x1e02a, 0x1e08e, 0x1e08f, 0x1e12f, 0x1e136, 0x1e2ad, 0x1e2ae, 0x1e2eb, - 0x1e2ef, 0x1e4eb, 0x1e4ef, 0x1e5ed, 0x1e5ef, 0x1e6e2, 0x1e6e3, 0x1e6e5, - 0x1e6e6, 0x1e6ed, 0x1e6ef, 0x1e6f4, 0x1e6f5, 0x1e8cf, 0x1e8d6, 0x1e943, - 0x1e94a, 0x1f003, 0x1f004, 0x1f0ce, 0x1f0cf, 0x1f18d, 0x1f18e, 0x1f190, - 0x1f19a, 0x1f1ff, 0x1f202, 0x1f20f, 0x1f23b, 0x1f23f, 0x1f248, 0x1f24f, - 0x1f251, 0x1f25f, 0x1f265, 0x1f2ff, 0x1f320, 0x1f32c, 0x1f335, 0x1f336, - 0x1f37c, 0x1f37d, 0x1f393, 0x1f39f, 0x1f3ca, 0x1f3ce, 0x1f3d3, 0x1f3df, - 0x1f3f0, 0x1f3f3, 0x1f3f4, 0x1f3f7, 0x1f43e, 0x1f43f, 0x1f440, 0x1f441, - 0x1f4fc, 0x1f4fe, 0x1f53d, 0x1f54a, 0x1f54e, 0x1f54f, 0x1f567, 0x1f579, - 0x1f57a, 0x1f594, 0x1f596, 0x1f5a3, 0x1f5a4, 0x1f5fa, 0x1f64f, 0x1f67f, - 0x1f6c5, 0x1f6cb, 0x1f6cc, 0x1f6cf, 0x1f6d2, 0x1f6d4, 0x1f6d8, 0x1f6db, - 0x1f6df, 0x1f6ea, 0x1f6ec, 0x1f6f3, 0x1f6fc, 0x1f7df, 0x1f7eb, 0x1f7ef, - 0x1f7f0, 0x1f90b, 0x1f93a, 0x1f93b, 0x1f945, 0x1f946, 0x1f9ff, 0x1fa6f, - 0x1fa7c, 0x1fa7f, 0x1fa8a, 0x1fa8d, 0x1fac6, 0x1fac7, 0x1fac8, 0x1facc, - 0x1fadc, 0x1fade, 0x1faea, 0x1faee, 0x1faf8, 0x1ffff, 0x2a6df, 0x2a6ff, - 0x2b81d, 0x2b81f, 0x2cead, 0x2ceaf, 0x2ebe0, 0x2ebef, 0x2ee5d, 0x2f7ff, - 0x2fa1d, 0x2ffff, 0x3134a, 0x3134f, 0x33479, 0xe0000, 0xe0001, 0xe001f, - 0xe007f, 0xe00ff, 0xe01ef, + 0x11d94, 0x11d95, 0x11d96, 0x11d97, 0x11def, 0x11df0, 0x11ef2, 0x11ef4, + 0x11eff, 0x11f01, 0x11f35, 0x11f3a, 0x11f3f, 0x11f40, 0x11f41, 0x11f42, + 0x11f59, 0x11f5a, 0x1343f, 0x13440, 0x13446, 0x13455, 0x1611d, 0x16129, + 0x1612c, 0x1612f, 0x16aef, 0x16af4, 0x16b2f, 0x16b36, 0x16f4e, 0x16f4f, + 0x16f8e, 0x16f92, 0x16fdf, 0x16fe3, 0x16fe4, 0x16fef, 0x16ff6, 0x16fff, + 0x18cda, 0x18cfe, 0x18d20, 0x18d7f, 0x18df2, 0x18dff, 0x19191, 0x1919f, + 0x191d2, 0x1afef, 0x1aff3, 0x1aff4, 0x1affb, 0x1affc, 0x1affe, 0x1afff, + 0x1b128, 0x1b131, 0x1b132, 0x1b14f, 0x1b152, 0x1b154, 0x1b155, 0x1b163, + 0x1b168, 0x1b16f, 0x1b2fb, 0x1bc9c, 0x1bc9e, 0x1bc9f, 0x1bca3, 0x1ceff, + 0x1cf2d, 0x1cf2f, 0x1cf46, 0x1d126, 0x1d128, 0x1d166, 0x1d169, 0x1d172, + 0x1d182, 0x1d184, 0x1d18b, 0x1d1a9, 0x1d1ad, 0x1d241, 0x1d244, 0x1d25a, + 0x1d25c, 0x1d2ff, 0x1d356, 0x1d35f, 0x1d376, 0x1d9ff, 0x1da36, 0x1da3a, + 0x1da6c, 0x1da74, 0x1da75, 0x1da83, 0x1da84, 0x1da9a, 0x1da9f, 0x1daa0, + 0x1daaf, 0x1dfff, 0x1e006, 0x1e007, 0x1e018, 0x1e01a, 0x1e021, 0x1e022, + 0x1e024, 0x1e025, 0x1e02a, 0x1e08e, 0x1e08f, 0x1e12f, 0x1e136, 0x1e2ad, + 0x1e2ae, 0x1e2eb, 0x1e2ef, 0x1e4eb, 0x1e4ef, 0x1e5ed, 0x1e5ef, 0x1e6e2, + 0x1e6e3, 0x1e6e5, 0x1e6e6, 0x1e6ed, 0x1e6ef, 0x1e6f4, 0x1e6f5, 0x1e8cf, + 0x1e8d6, 0x1e943, 0x1e94a, 0x1f003, 0x1f004, 0x1f0ce, 0x1f0cf, 0x1f18d, + 0x1f18e, 0x1f190, 0x1f19a, 0x1f1ad, 0x1f1ae, 0x1f1ff, 0x1f202, 0x1f20f, + 0x1f23b, 0x1f23f, 0x1f248, 0x1f24f, 0x1f251, 0x1f25f, 0x1f265, 0x1f2ff, + 0x1f320, 0x1f32c, 0x1f335, 0x1f336, 0x1f37c, 0x1f37d, 0x1f393, 0x1f39f, + 0x1f3ca, 0x1f3ce, 0x1f3d3, 0x1f3df, 0x1f3f0, 0x1f3f3, 0x1f3f4, 0x1f3f7, + 0x1f43e, 0x1f43f, 0x1f440, 0x1f441, 0x1f4fc, 0x1f4fe, 0x1f53d, 0x1f54a, + 0x1f54e, 0x1f54f, 0x1f567, 0x1f579, 0x1f57a, 0x1f594, 0x1f596, 0x1f5a3, + 0x1f5a4, 0x1f5fa, 0x1f64f, 0x1f67f, 0x1f6c5, 0x1f6cb, 0x1f6cc, 0x1f6cf, + 0x1f6d2, 0x1f6d4, 0x1f6d9, 0x1f6db, 0x1f6df, 0x1f6ea, 0x1f6ec, 0x1f6f3, + 0x1f6fc, 0x1f7d9, 0x1f7da, 0x1f7df, 0x1f7eb, 0x1f7ef, 0x1f7f0, 0x1f90b, + 0x1f93a, 0x1f93b, 0x1f945, 0x1f946, 0x1f9ff, 0x1fa6f, 0x1fa7c, 0x1fa7f, + 0x1fac6, 0x1fac7, 0x1fac8, 0x1facb, 0x1fadd, 0x1fade, 0x1faeb, 0x1faee, + 0x1fafa, 0x1ffff, 0x2a6df, 0x2a6ff, 0x2b81e, 0x2b81f, 0x2cead, 0x2ceaf, + 0x2ebe0, 0x2ebef, 0x2ee5d, 0x2f7ff, 0x2fa1d, 0x2ffff, 0x3134a, 0x3134f, + 0x33479, 0x3cfff, 0x3fc3f, 0xe0000, 0xe0001, 0xe001f, 0xe007f, 0xe00ff, + 0xe01ef, }; static const unsigned char wcwidth_widths[] = { @@ -145,16 +147,15 @@ static const unsigned char wcwidth_widths[] = { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, - 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, - 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 0, 1, 0, 1, 0, 1, 2, 1, 2, 1, 2, 1, 2, 0, - 2, 1, 2, 1, 0, 2, 1, 2, 1, 2, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 0, 1, 0, + 2, 1, 2, 1, 2, 1, 2, 1, 0, 1, 0, 1, 0, 1, 2, 1, 2, 1, 2, 1, 2, 0, 2, 1, + 2, 1, 0, 2, 1, 2, 1, 2, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, - 1, 2, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, - 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 1, 0, - 1, 0, 1, 2, 1, 2, 1, 0, 1, 0, 2, 1, 0, 2, 1, 2, 1, 2, 1, 0, 1, 2, 1, 0, - 1, 2, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, + 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 1, 0, 1, 0, + 1, 2, 1, 2, 1, 0, 1, 0, 2, 1, 0, 2, 1, 2, 1, 2, 1, 0, 1, 2, 1, 0, 1, 2, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, @@ -164,13 +165,15 @@ static const unsigned char wcwidth_widths[] = { 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, - 1, 2, 0, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, - 2, 1, 2, 1, 2, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, - 2, 1, 2, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, + 1, 0, 1, 2, 0, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, + 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 1, 2, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, - 0, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, + 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, + 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, - 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 0, 1, 0, 1, 0, + 2, 1, 2, 1, 0, 1, 0, 1, 0, }; diff --git a/libcpp/makeucnid.cc b/libcpp/makeucnid.cc index bfecceaef7fe..16208d112ed5 100644 --- a/libcpp/makeucnid.cc +++ b/libcpp/makeucnid.cc @@ -538,7 +538,7 @@ write_copyright (void) .\n\ \n\ \n\ - Copyright (C) 1991-2025 Unicode, Inc. All rights reserved.\n\ + Copyright (C) 1991-2026 Unicode, Inc. All rights reserved.\n\ Distributed under the Terms of Use in\n\ http://www.unicode.org/copyright.html.\n\ \n\ diff --git a/libcpp/makeuname2c.cc b/libcpp/makeuname2c.cc index f266bef954a1..b073581cf556 100644 --- a/libcpp/makeuname2c.cc +++ b/libcpp/makeuname2c.cc @@ -69,7 +69,7 @@ struct entry { const char *name; unsigned long codepoint; }; static struct entry *entries; static unsigned long num_allocated, num_entries; -/* Unicode 16.0 Table 4-8. */ +/* Unicode 18.0 Table 4-8. */ struct generated { const char *prefix; /* max_high is a workaround for UnicodeData.txt inconsistencies @@ -84,7 +84,7 @@ static struct generated generated_ranges[] = { "CJK UNIFIED IDEOGRAPH-", 0x4e00, 0x9fff, 0, 1, 0 }, { "CJK UNIFIED IDEOGRAPH-", 0x20000, 0x2a6df, 0, 1, 0 }, { "CJK UNIFIED IDEOGRAPH-", 0x2a700, 0x2b73f, 0, 1, 0 }, - { "CJK UNIFIED IDEOGRAPH-", 0x2b740, 0x2b81d, 0, 1, 0 }, + { "CJK UNIFIED IDEOGRAPH-", 0x2b740, 0x2b81e, 0, 1, 0 }, { "CJK UNIFIED IDEOGRAPH-", 0x2b820, 0x2cead, 0, 1, 0 }, { "CJK UNIFIED IDEOGRAPH-", 0x2ceb0, 0x2ebe0, 0, 1, 0 }, { "CJK UNIFIED IDEOGRAPH-", 0x2ebf0, 0x2ee5d, 0, 1, 0 }, @@ -93,12 +93,14 @@ static struct generated generated_ranges[] = { "CJK UNIFIED IDEOGRAPH-", 0x323b0, 0x33479, 0, 1, 0 }, { "EGYPTIAN HIEROGLYPH-", 0x13460, 0x143fa, 0, 2, 0 }, { "TANGUT IDEOGRAPH-", 0x17000, 0x187ff, 0, 3, 0 }, - { "TANGUT IDEOGRAPH-", 0x18d00, 0x18d1e, 0, 3, 0 }, - { "KHITAN SMALL SCRIPT CHARACTER-", 0x18b00, 0x18cd5, 0, 4, 0 }, - { "NUSHU CHARACTER-", 0x1b170, 0x1b2fb, 0, 5, 0 }, - { "CJK COMPATIBILITY IDEOGRAPH-", 0xf900, 0xfa6d, 0, 6, 0 }, - { "CJK COMPATIBILITY IDEOGRAPH-", 0xfa70, 0xfad9, 0, 6, 0 }, - { "CJK COMPATIBILITY IDEOGRAPH-", 0x2f800, 0x2fa1d, 0, 6, 0 } + { "TANGUT IDEOGRAPH-", 0x18d00, 0x18d20, 0, 3, 0 }, + { "KHITAN SMALL SCRIPT CHARACTER-", 0x18b00, 0x18cda, 0, 4, 0 }, + { "JURCHEN CHARACTER-", 0x18e00, 0x19191, 0, 5, 0 }, + { "NUSHU CHARACTER-", 0x1b170, 0x1b2fb, 0, 6, 0 }, + { "SMALL SEAL CHARACTER-", 0x3d000, 0x3fc3f, 0, 7, 0 }, + { "CJK COMPATIBILITY IDEOGRAPH-", 0xf900, 0xfa6d, 0, 8, 0 }, + { "CJK COMPATIBILITY IDEOGRAPH-", 0xfa70, 0xfad9, 0, 8, 0 }, + { "CJK COMPATIBILITY IDEOGRAPH-", 0x2f800, 0x2fa1d, 0, 8, 0 } }; struct node { @@ -665,7 +667,7 @@ write_copyright (void) .\n\ \n\ \n\ - Copyright (C) 1991-2025 Unicode, Inc. All rights reserved.\n\ + Copyright (C) 1991-2026 Unicode, Inc. All rights reserved.\n\ Distributed under the Terms of Use in\n\ http://www.unicode.org/copyright.html.\n\ \n\ diff --git a/libcpp/ucnid.h b/libcpp/ucnid.h index 29aa67c224f2..e86098c95cac 100644 --- a/libcpp/ucnid.h +++ b/libcpp/ucnid.h @@ -16,7 +16,7 @@ . - Copyright (C) 1991-2025 Unicode, Inc. All rights reserved. + Copyright (C) 1991-2026 Unicode, Inc. All rights reserved. Distributed under the Terms of Use in http://www.unicode.org/copyright.html. @@ -272,13 +272,16 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x052f }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x0530 }, { C99| 0|CXX|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x0556 }, -{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x0558 }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x0557 }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0x0558 }, { C99| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x0559 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x055f }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x0560 }, { C99| 0|CXX|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x0586 }, { C99| 0|CXX|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0x0587 }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x0588 }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x058a }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0x058c }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x0590 }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 220, 0x0591 }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 230, 0x0595 }, @@ -318,6 +321,8 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 220, 0x05c5 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x05c6 }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 18, 0x05c7 }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 10, 0x05c8 }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 21, 0x05c9 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x05cf }, { C99| 0|CXX|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x05ea }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x05ee }, @@ -640,7 +645,7 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x0b4a }, { C99| 0| 0|C11| 0|CXX23|NXX23| 0|NFC|NKC| 0| 0, 0, 0x0b4c }, { C99| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 9, 0x0b4d }, -{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x0b54 }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x0b52 }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 0, 0x0b55 }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC|CTX| 0, 0, 0x0b57 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x0b5b }, @@ -1164,11 +1169,13 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 220, 0x1aca }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 230, 0x1adc }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 220, 0x1add }, -{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1adf }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 230, 0x1ae5 }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 220, 0x1ae6 }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 230, 0x1aea }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 234, 0x1aeb }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 230, 0x1aed }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 220, 0x1aef }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 230, 0x1af0 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1aff }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 0, 0x1b04 }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x1b05 }, @@ -1403,8 +1410,8 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC| 0| 0|NONC, 0, 0x207e }, { C99| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0x207f }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC| 0| 0|NONC, 0, 0x208e }, -{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x208f }, -{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0x209c }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x208f }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0x209f }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x20a7 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC| 0| 0| 0, 0, 0x20a8 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x20cf }, @@ -1692,7 +1699,9 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0xa770 }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0xa788 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0xa78a }, -{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0xa7dc }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0xa7dd }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0xa7e1 }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0xa7e2 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0xa7f0 }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0xa7f4 }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0xa7f7 }, @@ -1801,6 +1810,8 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0xab5f }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0xab68 }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0xab69 }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0xab6b }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0xab6d }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0xab6f }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0xabe2 }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 0, 0xabea }, @@ -2018,7 +2029,7 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x10786 }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0x107b0 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x107b1 }, -{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0x107ba }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0x107bf }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x107ff }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x10805 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x10807 }, @@ -2114,7 +2125,19 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x10eb1 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x10ec1 }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x10ec7 }, -{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x10ef9 }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x10eca }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 230, 0x10ecb }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 220, 0x10ecd }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 230, 0x10ecf }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x10ed8 }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x10eee }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x10eef }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 220, 0x10ef2 }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 230, 0x10ef3 }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 220, 0x10ef4 }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 230, 0x10ef5 }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 220, 0x10ef6 }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 230, 0x10ef9 }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 220, 0x10efb }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 0, 0x10efc }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 220, 0x10eff }, @@ -2437,6 +2460,8 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x11a9d }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x11aaf }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x11af8 }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x11b09 }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x11b0a }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x11b5f }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 0, 0x11b67 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x11bbf }, @@ -2499,6 +2524,9 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x11ddb }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x11ddf }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 0, 0x11de9 }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x11def }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 0, 0x11df0 }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x11df1 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x11edf }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x11ef2 }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 0, 0x11ef6 }, @@ -2520,9 +2548,11 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x11fff }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x12399 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x123ff }, -{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x1246e }, -{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1247f }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x1246f }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x12474 }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x12543 }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1254f }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x12686 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x12f8f }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x12ff0 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x12fff }, @@ -2600,11 +2630,15 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 6, 0x16ff1 }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x16ff6 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x16fff }, -{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x18cd5 }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x18cda }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x18cfe }, -{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x18d1e }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x18d20 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x18d7f }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x18df2 }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x18dff }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x19191 }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1919f }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x191d2 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1afef }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x1aff3 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1aff4 }, @@ -2613,6 +2647,8 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x1affe }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1afff }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x1b122 }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0x1b126 }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x1b128 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1b131 }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x1b132 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1b14f }, @@ -2620,7 +2656,7 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1b154 }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x1b155 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1b163 }, -{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x1b167 }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x1b168 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1b16f }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x1b2fb }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1bbff }, @@ -2641,6 +2677,8 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 0, 0x1cf2d }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1cf2f }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 0, 0x1cf46 }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1d126 }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 220, 0x1d128 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1d15d }, { 0| 0| 0|C11| 0| 0| 0| 0| 0| 0| 0| 0, 0, 0x1d164 }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 216, 0x1d166 }, @@ -2659,6 +2697,14 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0| 0| 0| 0| 0| 0| 0| 0, 0, 0x1d1c0 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1d241 }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 230, 0x1d244 }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1d24f }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 216, 0x1d252 }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1d25a }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 1, 0x1d25c }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1d25e }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 216, 0x1d25f }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1d27f }, +{ 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 216, 0x1d281 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1d3ff }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0x1d454 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1d455 }, @@ -2696,7 +2742,7 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1d549 }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0x1d550 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1d551 }, -{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0x1d6a5 }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0x1d6a6 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1d6a7 }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0x1d6c0 }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0|NONC, 0, 0x1d6c1 }, @@ -2734,10 +2780,13 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1daa0 }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 0, 0x1daaf }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1deff }, -{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x1df1e }, -{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1df24 }, -{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x1df2a }, -{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1dfff }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x1df81 }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1df8f }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x1df94 }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0x1df95 }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x1df96 }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1dfcc }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC| 0| 0| 0, 0, 0x1dfff }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 230, 0x1e006 }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1e007 }, { 0| 0| 0|C11| 0|CXX23|NXX23|CID|NFC|NKC| 0| 0, 230, 0x1e018 }, @@ -2901,7 +2950,7 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0| 0| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x1ffff }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x2a6df }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x2a6ff }, -{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x2b81d }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x2b81e }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x2b81f }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x2cead }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x2ceaf }, @@ -2915,6 +2964,8 @@ static const struct ucnrange ucnranges[] = { { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x3134a }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x3134f }, { 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x33479 }, +{ 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x3cfff }, +{ 0| 0| 0|C11| 0|CXX23| 0|CID|NFC|NKC| 0| 0, 0, 0x3fc3f }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x3fffd }, { 0| 0| 0| 0| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x3ffff }, { 0| 0| 0|C11| 0| 0| 0|CID|NFC|NKC| 0| 0, 0, 0x4fffd }, diff --git a/libcpp/uname2c.h b/libcpp/uname2c.h index a00d5506f150..4d8e1b73f48c 100644 --- a/libcpp/uname2c.h +++ b/libcpp/uname2c.h @@ -16,7 +16,7 @@ . - Copyright (C) 1991-2025 Unicode, Inc. All rights reserved. + Copyright (C) 1991-2026 Unicode, Inc. All rights reserved. Distributed under the Terms of Use in http://www.unicode.org/copyright.html. @@ -52,7 +52,7 @@ use or other dealings in these Data Files or Software without prior written authorization of the copyright holder. */ -static const char uname2c_dict[62796] = +static const char uname2c_dict[64292] = "DIVIDED BY HORIZONTAL BAR AND TOP HALF DIVIDED BY VERTICAL BARUIGHUR KIRGHIZ " "YEH WITH HAMZA ABOVE WITH ALEF MAKSURA LANTED EQUAL ABOVE GREATER-THAN ABOVE " "SLANTED EQUAL WITH EXCLAMATION MARK WITH LEFT RIGHT ARROW ABOVELANTED EQUAL A" @@ -72,8 +72,8 @@ static const char uname2c_dict[62796] = "IRCUMFLEX ACCENTDOWNWARDS AND UPWARDS OPEN CIRCLE ARROWSLOW DOUBLE COMMA QUOT" "ATION MARK ORNAMENTVERTICAL BAR AT END OF HORIZONTAL STROKE-TILTED SHADOWED W" "HITE RIGHTWARDS ARROWABOVE RIGHTWARDS HARPOON WITH BARB DOWNASH FROM LEFT MEM" -"BER OF DOUBLE VERTICALNEGATIVE SQUARED LATIN CAPITAL LETTER PWITH OPEN ARM EN" -"DING IN ARROW POINTING -HEADED ARROW WITH TRIANGLE ARROWHEADSABOVE LEFTWARDS " +"BER OF DOUBLE VERTICALHORIZONTAL AND VERTICAL BISECTING LINESNEGATIVE SQUARED" +" LATIN CAPITAL LETTER P-HEADED ARROW WITH TRIANGLE ARROWHEADSABOVE LEFTWARDS " "HARPOON WITH BARB DOWNAL WITH SUPERSCRIPT ALEF ISOLATED FORMASHED TRIANGLE-HE" "ADED RIGHTWARDS ARROWEH WITH SUPERSCRIPT ALEF ISOLATED FORMEXTENDED ARABIC-IN" "DIC DIGIT FOUR ABOVEEXTENDED ARABIC-INDIC DIGIT FOUR BELOWHARPOON ABOVE SHORT" @@ -81,955 +81,974 @@ static const char uname2c_dict[62796] = "TH DOUBLE ORNAMENTWARDS AND LEFTWARDS OPEN CIRCLE ARROWS WITH MONITOR IN PORT" "RAIT ORIENTATIONHORIZONTAL LINE WITH THREE TICK MARKSIOUS FACE WITH SYMBOLS C" "OVERING MOUTHONCAVE-POINTED BLACK RIGHTWARDS ARROWOVER RIGHTWARDS TRIANGLE-HE" -"ADED ARROWSMALL LETTER BYELORUSSIAN-UKRAINIAN I AND LOWER HALF INVERSE MEDIUM" -" SHADE WITH HORIZONTAL MIDDLE BLACK STRIPEDOUBLE-LINE EQUAL ABOVE GREATER-THA" -"NGREATER-THAN ABOVE DOUBLE-LINE EQUALHARPOON ABOVE LONG LEFTWARDS HARPOONIGHT" -" TORTOISE SHELL BRACKET ORNAMENTLEFT TORTOISE SHELL BRACKET ORNAMENTOVER LEFT" -"WARDS TRIANGLE-HEADED ARROWPART BETWEEN MIDDLE AND RING FINGERSSINGLE COMMA Q" -"UOTATION MARK ORNAMENTSMALL ARABIC LETTER TAH AND TWO DOTSTURNED COMMA QUOTAT" -"ION MARK ORNAMENTZENGE CONTAINING BLACK SMALL LOZENGE CONTAINING BLACK VERY S" -"MALL SQUAREBESIDE AND JOINED WITH INTERSECTIONBOTTOM-LIGHTED RIGHTWARDS ARROW" -"HEADGVEDIC KASHMIRI INDEPENDENT SVARITAND UPPER AND LOWER ONE EIGHTH BLOCKORN" -"ER ARROWS CIRCLING ANTICLOCKWISEOUNDED HIGH STOP WITH FILLED CENTRER LOWER RI" -"GHT CURLY BRACKET SECTIONRIGHT-POINTING ANGLE QUOTATION MARKTWO HORIZONTAL ST" -"ROKES TO THE RIGHTVERTICAL LINE WITH THREE TICK MARKS TWO DOTS OVER ONE DOT P" -"UNCTUATIONBLACK LEFT-POINTING SMALL TRIANGLEDOWNWARDS ARROW WITH TIP LEFTWARD" -"SIGHUR KAZAKH KIRGHIZ ALEF MAKSURA MODIFIER LETTER LABIALIZATION MARKOVER IGI" -" SHIR OVER SHIR UD OVER UDOVER TAB NI OVER NI DISH OVER DISHPPROXIMATELY NOR " -"ACTUALLY EQUAL TOR LOWER LEFT CURLY BRACKET SECTIONTEARDROP-SPOKED PROPELLER " -"ASTERISKUPPER BODY TILTING FROM HIP JOINTSALL BUT UPPER LEFT QUADRANT BLACKDI" -"RECT PRODUCT WITH BOTTOM CLOSEDDOUBLE-LINE EQUAL ABOVE LESS-THANDOWNWARDS HAR" -"POON WITH BARB RIGHTEFT-POINTING ANGLE QUOTATION MARKLESS-THAN ABOVE DOUBLE-L" -"INE EQUALLLAR SIGN WITH OVERLAID BACKSLASHMEDIUM SHADE AND LOWER HALF BLOCKRA" -"ISING BOTH HANDS IN CELEBRATIONTROFLEX CLICK WITH RETROFLEX HOOKTRONG CENTRAL" -"IZATION STROKE BELOWTUG2 OVER TUG2 TUG2 OVER TUG2 PAPTWO DOTS ABOVE AND TWO D" -"OTS BELOWWARDS HARPOON WITH BARB DOWNWARDS-POINTING ANGLE BRACKET ORNAMENTAND" -" MIDDLE RIGHT TO LOWER CENTREATHARVAVEDIC INDEPENDENT SVARITAETALLED BLACK AN" -"D WHITE FLORETTEHAND WITH MIDDLE FINGER EXTENDEDNORMAL FACTOR SEMIDIRECT PROD" -"UCTRIANGLE-HEADED OPEN CIRCLE ARROWRIGHT SEMICIRCLE WITH THREE DOTSRONT-TILTE" -"D SHADOWED WHITE ARROWSEMICIRCULAR ANTICLOCKWISE ARROWVED STEM PARAGRAPH SIGN" -" ORNAMENT CROSSING ASH OVER ASH OVER ASHACK-TILTED SHADOWED WHITE ARROWAISED " -"HAND WITH FINGERS SPLAYEDAND MIDDLE LEFT TO LOWER CENTREETALLED OUTLINED BLAC" -"K FLORETTEIN WHITE CIRCLE IN BLACK SQUARELEFTWARDS EQUILATERAL ARROWHEADONE H" -"UNDRED THIRTY-FIVE DEGREESRIGHTWARDS HARPOON WITH BARB UPRING OVER TWO RINGS " -"PUNCTUATIONRINGS OVER ONE RING PUNCTUATIONTNAMESE ALTERNATE READING MARK UPWA" -"RDS HARPOON WITH BARB RIGHT CONTAINING BLACK SMALL SQUARE-HIRAGANA PROLONGED " -"SOUND MARKAGGRAVATED INDEPENDENT SVARITAAND JOINED BY DASH WITH SUBSETDOT BEL" -"OW AND THREE DOTS ABOVEDOWNWARDS AND RIGHTWARDS ARROWEART EXCLAMATION MARK OR" -"NAMENTEFT SEMICIRCLE WITH THREE DOTSGHT FOUR POINTED PINWHEEL STARGREATER-THA" -"N ABOVE EQUALS SIGNHIGH-REVERSED-9 QUOTATION MARKHT CENTRALIZATION STROKE BEL" -"OWINDEX THUMB CURVE THUMB INSIDEMAKSURA WITH SUPERSCRIPT ALEF MINTON RACQUET " -"AND SHUTTLECOCKMODIFIER LETTER LEFT HALF RINGON WITH RIGHTWARDS ARROW ABOVEOP" -"EN CENTRE EIGHT POINTED STARQAF WITH LAM WITH ALEF MAKSURARECTANGULAR CHECKER" -" BOARD FORMSAD WITH LAM WITH ALEF MAKSURA DOWN INDEX THUMB HOOK MIDDLE OVER R" -"IGHTWARDS ARROW TO BAR WITH REVERSED NEGATION SLASHABOVE SHORT LEFTWARDS HARP" -"OONCKED FACE WITH EXPLODING HEADCONTAINING BLACK SMALL CIRCLEDOT OVER TWO DOT" -"S PUNCTUATIONDOWN HEAVY AND RIGHT UP LIGHTDOWN MIDDLE THUMB INDEX CROSSEFTWAR" -"DS HARPOON WITH BARB UPEVERSED LUNATE EPSILON SYMBOLEXTENDED ARABIC-INDIC DIG" -"IT TLIGHT FOUR POINTED BLACK CUSPNS-SERIF INTERROBANG ORNAMENTOMBINING ANUSVA" -"RA ABOVE RIGHTONAL INDICATOR SYMBOL LETTER PUNCTUATION CHINOOK FULL STOPSEMIC" -"IRCULAR PATH AROUND POLESUPERSCRIPT ALEF INITIAL FORMUP HEAVY AND RIGHT DOWN " -"LIGHTWITH RIGHTWARDS ARROW AT LEFTACE DIRECTION POSITION NOSE ASTERISKS ALIGN" -"ED VERTICALLYBESIDE AND JOINED WITH UNIONDOUBLE ANUSVARA ANTARGOMUKHADOWN HEA" -"VY AND LEFT UP LIGHTEDGE-TAILED RIGHTWARDS ARROWEFT ARC GREATER-THAN BRACKETF" -"TING POINT RIGHTWARDS ARROWGRAPHIC CHARACTER INTRODUCERHADED WHITE RIGHTWARDS" -" ARROWHREE HUNDRED FIFTEEN DEGREESIBE SYLLABLE BOUNDARY MARKERISMILLAH AR-RAH" -"MAN AR-RAHEEMLEFTWARDS OF DOWNWARDS ARROWLIQUID MEASURE FIRST SUBUNITMIDDLE C" -"ENTRE TO UPPER RIGHTMIDDLE RING LITTLE CONJOINEDMONOGRAMMOS TESSERA DODEKATAO" -"UND-TIPPED RIGHTWARDS ARROWRECTANGULAR PATH AROUND POLESALTIRE WITH ROUNDED C" -"ORNERST LITTER IN ITS PLACE SYMBOLTAAALAA FARAJAHU ASH-SHAREEFUP HEAVY AND LE" -"FT DOWN LIGHTUPPER CENTRE TO MIDDLE RIGHTUPWARDS AND RIGHTWARDS ARROW AND LEF" -"T SEMICIRCLE ARROWS BARREE WITH TWO DOTS BELOW DIVIDED BY HORIZONTAL RULE-FEA" -"THERED RIGHTWARDS ARROWAND UPPER HALF WHITE CIRCLEARROW ABOVE LEFTWARDS ARROW" -"BETWEEN TWO HORIZONTAL BARSBRDA RNYING YIG MGO MDUN MABRDA RNYING YIG MGO SGA" -"B MACIRCLE WITH NORTHWEST ARROWCONTINUOUS UNDERLINE SYMBOLDOUBLE PRIME QUOTAT" -"ION MARKEAVY WHITE RIGHTWARDS ARROWEMICIRCULAR CLOCKWISE ARROWENTATION FORM F" -"OR VERTICAL FINGER COVERING CLOSED LIPSFOUR FINGERS CONJOINED BENTHANDED INTE" -"RLACED PENTAGRAMHEAD MARK WITH MOON AND SUNIDE ARC ANTICLOCKWISE ARROWIDE-HEA" -"DED RIGHTWARDS ARROWIMPERFECTUM CUM PROLATIONE KATHAKA INDEPENDENT SVARITALAR" -"GE EQUILATERAL ARROWHEADLESS-THAN ABOVE EQUALS SIGNLIGHT CENTRALIZATION STROK" -"ELOWER MIDDLE LEFT TO LOWER LOWER TONAL RANGE INDICATORONE LARGE AND ONE SMAL" -"L EYEOUR BALLOON-SPOKED ASTERISKOVER LONG LEFTWARDS HARPOONPHARYNGEAL VOICED " -"FRICATIVEPPY PERSON RAISING ONE HANDRIANGULAR ONE QUARTER BLOCKRIGHT ARC LESS" -"-THAN BRACKETRIPLE VERTICAL BAR OPERATORSTRUMENTAL NOTATION SYMBOL-TALIC LATI" -"N CAPITAL LETTER TWO HUNDRED SEVENTY DEGREESUPPER CENTRE TO LOWER RIGHTUPPER " -"MIDDLE LEFT TO UPPER WALLPLANE SHOULDER HIP MOVEWO DOTS BELOW AND DOT ABOVEZE" -"RO FOR ODD POWERS OF FOUR GAD OVER GAD GAR OVER GAR LESS THAN THE DENOMINATOR" -" NEGATED WITH VERTICAL BAR OR APPROXIMATELY EQUAL TO WITHIN TRIANGLE ARROWHEA" -"DALEF MAKSURA ISOLATED FORMAND LEFT HALF WHITE CIRCLEAND MIDDLE FINGERS CROSS" -"EDAND RIGHT ONE EIGHTH BLOCKCAT FACE WITH SMILING EYESCLOCKWISE ARROW WITH MI" -"NUSCRIPT LIGATURE ET ORNAMENTDOTTED LUNATE SIGMA SYMBOLDOTTED SUBSTITUTION MA" -"RKERDROP-SHADOWED WHITE SQUAREE ONE-WAY LEFT WAY TRAFFICERSTRASS ELLIPTIC FUN" -"CTIONHTORA SKLIRON CHROMA VASISIDEOGRAPHIC ITERATION MARKINDUSTRIAL STANDARD " -"SYMBOLJECT REPLACEMENT CHARACTERLANTED SOUTH ARROW WITH HOLEFTWARDS OF UPWARD" -"S ARROWLINE FEED SEPARATOR SYMBOLLLALLAHOU ALAYHE WASSALLAMMARRIED PARTNERSHI" -"P SYMBOLMEEM WITH HAH WITH TATWEELMODIFIER FITZPATRICK TYPE-OCKED FEMALE AND " -"MALE SIGNOORPLANE SHOULDER HIP MOVEORTHOGONAL CROSSHATCH FILLOTATED FLORAL HE" -"ART BULLETOUBLE ANGLE QUOTATION MARKRIGHT PARENTHESIS ORNAMENTRINGS ALIGNED H" -"ORIZONTALLYRIPLE DOT PUNCTUATION MARKSSIAN ASTROLOGICAL SYMBOL THREE DOTS ABO" -"VE DOWNWARDSU REVERSED OVER U REVERSEDUNEVEN EYES AND WAVY MOUTHWHITE RIGHT P" -"OINTING INDEXWITH LEFTWARDS ARROW ABOVEYAJURVEDIC MIDLINE SVARITA OVER NUN LA" -"GAR TIMES SAL WITH CIRCLED ONE OVERLAY WITH DOUBLE GRAVE ACCENT WITH DOUBLE M" -"IDDLE TILDE WITH DOUBLE VERTICAL BARBREVE WITH INVERTED BREVEBUT NOT ACTUALLY" -" EQUAL TOCAT FACE WITH CLOSED EYESCROSSING NORTH EAST ARROWDIAERESIS AND HOOK" -" SYMBOLDOUBLE CANDRABINDU VIRAMADRY MEASURE FIRST SUBUNITELD HOCKEY STICK AND" -" BALLFECTIVENESS OR DISTORTIONFFICULTY AT THE BEGINNINGING ON THE FLOOR LAUGH" -"INGINVERTED EXCLAMATION MARKLE TENNIS PADDLE AND BALLLEFT PARENTHESIS ORNAMEN" -"TLEFTWARDS ARROW WITH HOOKLOW QUILT SQUARE ORNAMENTMBINING CRYPTOGRAMMIC DOTM" -"EDIUM TRIANGLE ARROWHEADMULTIPLICATION SIGN BELOWNIVERSAL RECYCLING SYMBOLOLD" -" ASSYRIAN WORD DIVIDERONE UNDER EIGHTEEN SYMBOLOUBLE BIRGA WITH ORNAMENTOUTLI" -"NED RIGHTWARDS ARROWOVER LONG LEFTWARDS ARROWRANCH BANK IDENTIFICATIONREE-HUN" -"DRED-AND-TWENTIETHRIGHT DIAGONAL HALF BLACKRIGHT ONE SIXTEENTH BLOCKRIPLE BIR" -"GA WITH ORNAMENTRIST CIRCLE HITTING WALL SQUARE CHECKER BOARD FORMSTROKE AND " -"TWO DOTS ABOVETAB OVER TAB GAR OVER GARTERNION INTEGRAL OPERATORTTED SUBSTITU" -"TION BRACKET OVER TOP SQUARE BRACKET POINTING BACKHAND INDEXALTERNATE SECTION" -" MARKERAND MALE AND FEMALE SIGNARM CIRCLE HITTING WALL ARROW POINTING DIRECTL" -"Y BERKANAN BEORC BJARKAN BBLACK LENTICULAR BRACKETBLIC ADDRESS LOUDSPEAKERBUS" -"INESS SUIT LEVITATINGCOMPATIBILITY IDEOGRAPH-CONSECUTIVE EQUALS SIGNSCULINE O" -"RDINAL INDICATORDESCENDING MUSICAL NOTESDIAGONAL CROSSHATCH FILLDOUBLE HORIZO" -"NTAL STROKEDOWNSCALING FACTOR KIIZHE PLUS A PLUS SU PLUS NAEASTERN PWO KAREN " -"DIGIT EQUAL TO OR GREATER-THANEYES AND HAND OVER MOUTHFINGER AND THUMB CROSSE" -"DGLOTTAL STOP WITH STROKEGREATER-THAN OR EQUAL TOHEAVY BLACK HEART BULLETIGAT" -"URE OPEN ET ORNAMENTING FACE WITH OPEN MOUTHINTERSECTION WITH SERIFSISOSCELES" -" RIGHT TRIANGLELARGE TRIANGLE ARROWHEADLEFT DIAGONAL HALF BLACKLEFT ONE SIXTE" -"ENTH BLOCKLINE HORIZONTAL ELLIPSISLY-RECYCLED PAPER SYMBOLMALL CIRCLE TO THE " -"RIGHTMALL LEFT SQUARE BRACKETMTAVRULI CAPITAL LETTER ONE-HUNDRED-AND-SIXTIETH" -"ORIZONTAL BAR WITH NOTCHOTTOM SHADED WHITE ARROWOTTOM-SHADED WHITE ARROWPERSC" -"RIPT ALEF MOKHASSASPOINTING DOWNWARDS ABOVEREVERSED NINE-LIKE BHALERIGHTWARDS" -" THEN CURVING SINGLE-LINE NOT EQUAL TOSTROKE THROUGH DESCENDERSYLLABLE REPETI" -"TION MARKT BLACK RIGHTWARDS ARROWTAAALAA ALAYHI WA-SALLAMTEARDROP-SPOKED ASTE" -"RISKTED INTERPOLATION MARKERUPRIGHT RECTANGULAR ZEROUPWARD POINTING TRIANGLEV" -"OICED LARYNGEAL SPIRANTWELVE POINTED BLACK STARWITH CANCELLATION STROKEWITH U" -"PWARDS ARROW ABOVEWO DOTS VERTICALLY ABOVEWO DOTS VERTICALLY BELOW CAKE WITH " -"SWIRL DESIGN HUNDRED TWENTY-EIGHTH POINTING AT THE VIEWER ROTATED NINETY DEG" -"REES WITH HALF-CIRCLE BELOW-ALAA AALIHEE WA-SALLAMALEF MAKSURA FINAL FORMALGA" -"MATION OR COPRODUCTAND WOMAN HOLDING HANDSANG DEPARTING TONE MARKARABIC LETTE" -"R TAH ABOVEARTY HORN AND PARTY HATASCENDING MUSICAL NOTESATTACHING VERTICAL O" -"METAVOURING DELICIOUS FOODAWWARA ALLAAHU MARQADAHBARBED RIGHTWARDS ARROWCIRCU" -"MFLEX ACCENT ABOVECLUSTER-INITIAL LETTER CURRENT SYMBOL FORM TWODOT BELOW AND" -" DOT ABOVEDOWNWARDS THEN CURVING ESS OUTLINED WHITE STARFACING SNAKE HEAD WIT" -"H GREEK SMALL LETTER IOTAHANKED RIGHTWARDS ARROWHREE POINTED BLACK STARHT TRI" -"FOLIATE SNOWFLAKEICATION PROGRAM COMMANDIDE ARC CLOCKWISE ARROWIGHT-SHADED WH" -"ITE ARROWININE ORDINAL INDICATORISTED RIGHTWARDS ARROWSIVE FINGERS SPREAD OPE" -"NLEFT-SHADED WHITE ARROWLOWER ONE QUARTER BLOCKLSCHREIBER PAUSE SYMBOLMITIAN " -"CONJUGATE MATRIXORAH WITH NINE BRANCHESORIGINAL OF OR EQUAL TOORIZONTAL RULER" -" SEGMENTOVER RIGHTWARDS HARPOONOVERLAPPING LOGICAL ANDP WITH EXCLAMATION MARK" -"PA OVER PA GAR OVER GARPUNCTUATION END OF TEXTRAISED OMISSION BRACKETREE VARI" -"ATION SELECTOR RIGHT DIAGONAL ELLIPSISRIGHT HORIZONTAL SECANTRIGHT ONE QUARTE" -"R BLOCKRIGHT-POINTING TRIANGLERTOISE SHELL BRACKETED SHAPE WITH A DOT INSIDES" -"ING DIAGONAL CROSSING SOLIDUS BINARY RELATIONUBLE VERTICAL BAR BELOWUP SPREAD" -" THUMB FORWARDUPPER ONE QUARTER BLOCKUPWARDS THEN NORTH WESTVERTICAL BISECTIN" -"G LINEWESTERN PWO KAREN TONE-WHITE FOUR POINTED CUSPWO-WAY LEFT WAY TRAFFICZA" -"NTINE MUSICAL SYMBOL OVER STAMPED ENVELOPE SYMBOL FOR LIGHTHOUSE WITH CIRCUM" -"FLEX ABOVE WITH DECORATIVE COVER WITH SINGLE ZAPYATAYA WITH THREE DOTS ABOVE-" -"ROTATED DIVISION SIGNACKSLANTED SOUTH ARROWARMENIAN ETERNITY SIGNBAR ABOVE IN" -"TERSECTIONCJK UNIFIED IDEOGRAPH-CONSONANT MODIFIER BARCONSONANT SIGN MEDIAL C" -"URLY BRACKET ORNAMENTDOMAIN ANTIRESTRICTIONDOUBLE SOLIDUS OVERLAYDOUBLE VERTI" -"CAL STROKEDOUBLE-LINED HEAD MARKDOWN-POINTING TRIANGLEDOWNWARDS ZIGZAG ARROWD" -"RESSED TO THE SUBJECTEAST-POINTING AIRPLANEGREATER-THAN DIAERESISHEXIFORM LON" -"G ANUSVARAHORT HORIZONTAL STROKEI YFESIS TETARTIMORIONIGEL LONG-BRANCH-SOL SI" -"N DEPARTING TONE MARKINDIRECT QUESTION MARKING HEAD IN SILHOUETTEINVERTED SMA" -"LL V ABOVEINVERTED SMALL V BELOWKEEPING STILL MOUNTAINLATIN CAPITAL LETTER SL" -"E BESIDE VERTICAL BARLEFT ONE QUARTER BLOCKLEFT TRIANGLE OPERATORLEFT-POINTIN" -"G TRIANGLELONG HORIZONTAL STROKELOW PARAPHRASE BRACKETMNYAM YIG GI MGO RGYANN" -"D RECORDING COPYRIGHTNOT INCLUDING THE POLEOVER LEFTWARDS HARPOONOVER NU11 BU" -"R OVER BUROVER SHIR BUR OVER BURPERSET OF NOR EQUAL TOPOINTING UPWARDS BELOWP" -"RECEDED BY APOSTROPHEPUNCTUATION KUNDDALIYAQUESTION MARK ORNAMENTREASE FONT S" -"IZE SYMBOLRECTILINEAR BLACK STARREE-CIRCLE ALTERNATE IRIGHT-POINTING FLEURONR" -"OUND A POINT OPERATORRROW WITH ROUNDED HEADSEMI-VOICED SOUND MARKSHORT RIGHTW" -"ARDS ARROWSHORT VERTICAL STROKESSYMPTOTICALLY EQUAL TOTRIPLE DASH HORIZONTALT" -"RIPLE RIGHT TURNSTILETRIPLE VERTICAL STROKEUBSCRIPT SMALL LETTER UPPER ONE EI" -"GHTH BLOCKUPPER RIGHT AND LOWER USTOMER ACCOUNT NUMBERWASALLAM ISOLATED FORMW" -"ITH HORIZONTAL STROKEWITH JEEM INITIAL FORMWITH VOICED SOUND MARKYIAKENG PUAC" -"HUE HMONG AND SLANTED PARALLEL WITH SHORT RIGHT LEG WITH VERTICAL STROKE-ROU" -"ND NOTEHEAD DOWN -SHAPED BAG DELIMITERABOVE SHORT DOWN TACKACUTE AND HOOK SYM" -"BOLAKIA TELOUS ICHIMATOSALLING DIAGONAL SLASHAND VOWEL LENGTH MARKARD SHELL F" -"LOPPY DISKARKENING OF THE LIGHTARYSTIAN FIVE HUNDREDBESIDE RIGHT TRIANGLEBOTT" -"OM AND LOWER LEFTBOTTOM U-SHAPED ARROWBUT NOT EQUIVALENT TOCROSSE STICK AND B" -"ALLCRUCIFORM NUMBER FOURCTOR OR CROSS PRODUCTDELIMITER TSHEG BSTARDIGRAMMOS E" -"X DODEKATADOUBLE LEFT TURNSTILEDOWN HORIZONTAL HEAVYDOWN HORIZONTAL LIGHTDOWN" -"WARDS ARROW ABOVEEFT HORIZONTAL SECANTEFT OPEN BOX OPERATOREIGHT SPOKED ASTER" -"ISKELATIONAL COMPOSITIONEQUAL TO OR LESS-THANER RIGHT CORNER ANGLEFINAL CONSO" -"NANT SIGN FLATTENED PARENTHESISGHT OPEN BOX OPERATORGRAMMOS OKTO DODEKATAGRUE" -"NT WITH DOT ABOVEHALF TRIANGULAR COLONHAND INTERIOR PRODUCTHOCKEY STICK AND P" -"UCKHORIZONTAL REFLECTIONHORIZONTAL TABULATIONHOUSAND MILLIONS SIGNINTERSECTIN" -"G LOGICAL INTERSECTION OPERATORINVERTED BRIDGE BELOWINVERTED GLOTTAL STOPJUST" -"IFIED LOWER HALF JUSTIFIED RIGHT HALF JUSTIFIED UPPER HALF LATTENED OPEN A AB" -"OVELESS-THAN OR EQUAL TOLETTER SMALL CAPITAL MALE WITH STROKE SIGNMIDDLE RING" -" LITTLE ONMORPHOLOGICAL DIVIDERND TELEPHONE RECEIVEROCAL NOTATION SYMBOL-OHAM" -"MAD ISOLATED FORMOP SHADED WHITE ARROWOPPOSING AN PLUS NAGAPAP PLUS PAP PLUS " -"LU3RATING SYSTEM COMMANDRELICT HOUSE BUILDINGREVERSED FEATHER MARKRIGHT ARROW" -"HEAD ABOVERIGHT QUARTER SECTIONRISING DIAGONAL SLASHSH AMPERSAND ORNAMENTSHOR" -"T LEFTWARDS ARROWSIDE TO SIDE SCISSORSTEEN POINTED ASTERISKTHICK LETTER SELEC" -"TORTILDE OPERATOR ABOVE TOUCHING INSIDE MOUTHTRIANGULAR HALF BLOCKUPPER QUART" -"ER SECTIONVERTICAL LINE OVERLAYVERY HEAVY BARB ARROWVOICED ITERATION MARKWITH" -" INVERTED V ABOVEWO-CIRCLE ALTERNATE IWO-CIRCLE NUKTA ABOVEXTRA SHORT VOWEL M" -"ARKYIG MGO TSHEG SHAD MA ABOVE LEFT TRIANGLE AND DIAGONAL STROKE BEGIN LOGOGR" -"AM MARK OVER LAGAR GUNU SHE OVER TUR ZA OVER ZA WITH DEPENDENT LOBE WITH HORI" -"ZONTAL BAR WITH INVERTED INPUT79 OVER LAK-079 GUNUA- SHOG GI MGO RGYANAISED U" -"PPER LEFT ARCAND NORTH EAST ARROWAND NORTH WEST ARROWAND SOUTH EAST ARROWAND " -"SOUTH WEST ARROWANGE ANTIRESTRICTIONARXIS KAI FTHORA VOUBETWEEN PALM FACINGSB" -"SET OF NOR EQUAL TOCENTRE VERTICAL LINECHEMICAL SYMBOL FOR CONSONANT SIGN HAA" -"RUCRESCENT MOON SYMBOLCURRENCY SYMBOL RIELCURVED ANGLE BRACKETDDASA ALLAAHU S" -"IRRAHDOTLESS HEAD OF KHAHDOUBLE ANGLE BRACKETDOUBLE DOT TONE MARKDOWN ARROWHE" -"AD BELOWE CONSONANT MODIFIERE POINTED WHITE STAREMESTVENNY ZADERZHKAENARMONIO" -"S ANTIFONIAEVERSED ROTATED RANAFINAL CONSONANT MARKFIVE SPOKED ASTERISKFORMS " -"LIGHT VERTICALFOUR RAISED KNUCKLESGRA GCAN -CHAR RTAGSHALF CIRCLE WITH DOTHAR" -"2 TIMES GAL PLUS HIGH RATHA OR LOW PAHIGH TONE APOSTROPHEHREE-DOT NUKTA ABOVE" -"IBLICAL END OF VERSEIMAGE OF OR EQUAL TOINDEX RING LITTLE ONINING OBLIQUE STR" -"OKEINSIDE MOUTH RELAXEDINVERSE WHITE CIRCLEINVERTED CANDRABINDUIRCLES HITTING" -" WALL JUDEO-SPANISH VARIKAJUSTIFIED LEFT HALF KHAMTI REDUPLICATIONL FUNCTIONA" -"L SYMBOL LAILING ROBOT FRAME-LATALIZED HOOK BELOWLE WITH POPPING CORKLEFT AND" -" LOWER RIGHTLEFT-TO-RIGHT SECANTMULTIPLE PUNCTUATIONNIS RACQUET AND BALLONCAV" -"E-SIDED DIAMONDONE MARK SGAW KAREN ONOMICAL SYMBOL FOR OTLESS J WITH STROKEOV" -"ER LEFTWARDS ARROWOWER QUARTER SECTIONPLUS GISH TIMES TAK4POTABLE WATER SYMBO" -"LREAN STANDARD SYMBOLREVERSED ONE HUNDREDRIGHT ANGLE WITH DOTRIGHT QUADRANT B" -"LACKRIGHT U-SHAPED ARROWRRAMA ALLAAHU WAJHAHRUMAI PALAUNG TONE-5SCRIPTION CHA" -"RACTER SEPARATOR KEY SYMBOLSEPARATOR MIDDLE DOTSIDEWAYS NOON GHUNNASTAR WITH " -"MIDDLE DOTTHROUGH SMALL CIRCLETISTRY SYMBOL LIGHT TRANSPOSITION MARKERUBHAANA" -"HU WA TAAALAAUP-POINTING AIRPLANEUP-POINTING TRIANGLEVAL WITH OVAL INSIDEWARE" -"-FUNCTION SYMBOLWET CULTIVATION SIGNWITH FOUR DOTS ABOVEWITH RAISED LEFT DOTW" -"ITH SOROCHYA NOZHKAWORD REPETITION MARKYIG MGO PHUR SHAD MAYRENAIC TWO DRACHM" -"AS AND PROSGEGRAMMENI AND RETROFLEX HOOK FLUTTERING IN WIND IN A RECTANGLE BO" -"X KASKAL U GUNU DISH LOVE YOU HAND SIGN WITH STRIKETHROUGH WITH VERTICAL TAIL" -"A END LOGOGRAM MARKALTERNATE LAKH MARKANS-SERIF CAPITAL LANSPOSITION BRACKETA" -"RABIC FORM SHAPINGARENTHESIS NOTEHEADARTIAL DIFFERENTIALASTEROID PROSERPINAAT" -"ED TELLER MACHINEBETWEEN MIDDLE RINGBINING ALEF OVERLAYC DIGRAPH WITH CURLCIR" -"CLED SANS-SERIF CIRCLED WHITE ARROWD CIRCUMFLEX ACCENTDENOMINATOR SIXTEENDOWN" -" AND HORIZONTALDOWN POINTING INDEXEFT QUARTER SECTIONET WITH WHITE CROSSEVEN " -"POWERS OF FOURFIVE FINGERS SPREADFLOORPLANE TWISTINGFT-POINTING FLEURONGAPPED" -" CIRCLE ARROWGIBBOUS MOON SYMBOLHAND COVERING MOUTHHEAD-SHAPED POINTERHORT ST" -"ROKE OVERLAYHURISAZ THURS THORNIGATURE AYIN-DALETHILDING CONSTRUCTIONIMIDIA S" -"EXTULA SIGNIN CHEN SPUNGS SHADING SHIRT WITH SASHINGLE DOT TONE MARKINSIDE CI" -"RCLE BELOWISPUTED END OF AYAHITED LIABILITY SIGNKULL AND CROSSBONESLEADING MC" -"HAN RTAGSLEFT POINTING INDEXLEFT U-SHAPED ARROWLF MADDA OVER MADDALUB-SPOKED " -"ASTERISKMOVES AGAINST CHEEKMSHELL MOBILE PHONENAXIAN FIVE HUNDREDNDRED POINTS" -" SYMBOLNE HUNDRED TWENTY PNETWORKED COMPUTERSNOGRAPHIC FULL STOPNORTH ARROW W" -"ITH HOOP SEMICIRCLE ARROWOTATED ARDHAVISARGAOVER E NUN OVER NUNOW-9 QUOTATION" -" MARKPARAGRAPH SEPARATORPREFIXED NASAL SIGNQUADRUPLE CRESCENTSQUESTION MARK A" -"BOVERAILING MCHAN RTAGSRATUM SUPER STRATUMREE-QUARTER CIRCLE RIGHT MIDDLE STR" -"OKERIGHT TO LOWER LEFTRROW NO-BREAK SPACERY CULTIVATION SIGNSEQUENCE INTRODUC" -"ERSEVEN EIGHTHS BLOCKSH PLUS HU PLUS ASHSLANTED NORTH ARROWSTRAIGHT THUMB BEN" -"TSTRATIAN FIFTY MNASSYMBOL FOR BEGINNERTART OF RUB EL HIZBTHANG LONG ANUSVARA" -"TIGHTLY-CLOSED EYESTO LOWER RIGHT FILLTRANNO MALO POVYSHETURNED PADA PISELEHT" -"URNED SECTION MARKTWENTY-FIVE DEGREESUBLE DOT WITHIN DOTUP HORIZONTAL HEAVYUP" -" HORIZONTAL LIGHTUP-POINTING CHEVRONURRENCY SYMBOL BAHTVARIANT FORM ILIMMUVAR" -"IANT WITH SQUAREVARIATION INDICATORVASTNESS OR WASTINGVERSAL INTERSECTIONVERS" -"E FINAL BARLINEVERTICAL TABULATIONWITH YEH FINAL FORMWOMEN HOLDING HANDS AND " -"NO DOTS ABOVE AND SMASH PRODUCT AND YPOGEGRAMMENI FOR SIMALUNGUN SA NOT LITTE" -"R SYMBOL OVER INVERTED SHU SPREAD THUMB SIDE THUMB INDEX THUMB WITH CIRCLE AB" -"OVE WITH CIRCLE BELOW WITH CROSSED-TAIL WITH FLOWING SAND WITH KAVYKA ABOVEAA" -" ALLAAHU TAAALAAABBREVIATION MARK AND LOW RIGHT RINGARROW SHAFT WIDTH ASTED S" -"WEET POTATOASTROLOGICAL SIGN ATERRESTRIAL ALIENATIN SMALL LETTER BAARAKA WA-T" -"AAALAABOTTOM RIGHT KASRACANTILLATION SIGN CONTINUING OVERLAPCOPPER ANTIMONIAT" -"ECTLY EQUIVALENT TOCUP WITHOUT HANDLEDOUBLE PUNCTUATIONDOWN-OUTPUT SYMBOLEAST" -" POINTING LEAFENTERING TONE MARKENTY-TWO POINT TWOEPIGRAPHIC LETTER ERTICAL B" -"AR VIRAMAEVENTEEN FULL STOPEVERSED CHELYUSTKAFIVE EIGHTHS BLOCKFORKED PARAGRA" -"PHOSFORTY-FIVE DEGREESGATIVE ACKNOWLEDGEGGLY VERTICAL LINEGISH CROSSING GISHH" -"AIS LUS NTOG NTOGHEAVY WHITE SQUAREHILOSOPHERS SULFURHOLDING BACK TEARSHORIZO" -"NTALLY BELOWHOUSANDS SEPARATORHUNDREDS UNIT MARKIGATURE ZAYIN-YODHIGSAW PUZZL" -"E PIECEIN POSSESSION SIGNINDEPENDENT VOWEL IRROR HORIZONTALLYITAN SMALL SCRIP" -"T IX SPOKED ASTERISKJEEM ISOLATED FORMKANTAJA NAASIKYAYAKBAR ISOLATED FORMKOR" -"EAN CHARACTER OLEFT MIDDLE STROKELEFT-STEM TONE BARLOSED CIRCLE ARROWLOWER MI" -"DDLE RIGHTMATHEMATICAL SPACEND UPPER RIGHT ARCNINETEEN FULL STOPNISH VERSE DI" -"VIDERNORMAL SUBGROUP OFNYET THYOOM TA-ROLNYOOGA NAAKSIKYAYAORK ON THE DECAYED" -"OTLESS DALATH RISHOU ALAYHE WASALLAMOUCHTONE TELEPHONEOW TONE APOSTROPHEPACIN" -"G CANDRABINDUPERFIXED LETTER RAPUNCTUATION BINDU QUARTER NOTE STEM REDUPLICAT" -"ION MARKRIST CIRCLE FRONT RYUKOVAYA SVETLAYAS INSIDE AND ABOVES PRESSED TOGET" -"HERSEPTUPLE CRESCENTSSET OVER BUILDINGSSHAN REDUPLICATIONSHING SWEAT SYMBOLSI" -"NGLE PUNCTUATIONSMALL CIRCLE ABOVESOUL ISOLATED FORMSYMMETRIC SWAPPINGTILTING" -" FROM WAISTTO LOWER LEFT FILLTOP U-SHAPED ARROWTROFLEX HOOK BELOWTYPE A ELECT" -"RONICSU-SHAPED ORNAMENTSUM WITH DRUMSTICKSUP ARROWHEAD BELOWUPPER MIDDLE RIGH" -"TUTLINED BLACK STARVARIANT FORM LIMMUVERY SMALL DIAMONDWEST POINTING LEAFWHIT" -"E VERTICAL BARWITH JUSTIFICATIONWITH STROKE SYMBOLYLLABLE LENGTHENER ALTERNAT" -"ION MARK AND PALATAL HOOK GRAVEYARD SYMBOL LAGAB TIMES ASH2 LAGAR OVER LAGAR " -"OVER ZU PLUS SAR PLUS SHA3 PLUS A TO BLACK DIAMOND WITH BULLET NOSE WITH SOUN" -"D WAVES WITH TILDE ABOVE-GAAHLAA TTUDDAAG-HEIGHT LEFT HOOK0 WHEELED CHARIOTA " -"PLUS HA PLUS DAABBREVIATION SIGNAEUM ONE PLETHRONALTERNATE NUMBER AMAT BARAKA" -"ATUHUMAMPHYLIAN DIGAMMAAND BLACK SQUARESAPLI DYO DODEKATAASELINE ROUND DOTATH" -"ERING TOGETHERAUKAZ LAGU LOGR LBE WITH MERIDIANSBERBER ACADEMY YABOTTOM HALF " -"BLACKBRACKET EXTENSIONBRIGHTNESS SYMBOLBUT RELIEVED FACECAL SYMBOL BOTTOMCANC" -"ELLATION MARKCANDRABINDU ABOVECIRCLES WITH DOTSCLOSED LITTLE YUSCOMBINING NUM" -"BER CONSONANT SIGN PACONTINUATION SIGNCONTOURED OUTLINECROSS PUNCTUATIONCTION" -" APPLICATIONDELPHIC FIVE MNASDENTAL PERCUSSIVEEAR SCREEN SYMBOLEMICOLON UNDER" -"BARFACING BABY CHICKFINGER-POST ARROWFLICK ALTERNATINGFRACTION ONE HALFFROM S" -"MALL CIRCLEGENERIC MATERIALSGREATER-THAN NOR GREATER-THAN SIGNHAH ISOLATED FO" -"RMHEART-SHAPED EYESHIRTEEN FULL STOPHORIZONTAL DOUBLEHORIZONTAL SINGLEIASTRE " -"MARK ABOVEICTED LEFT ENTRY-IDEOGRAPHIC COMMAIGHTEEN FULL STOPINEAR ANNOTATION" -" ING POLE AND FISHINITIAL LETTER RAINVERTED MCHU CANITE PART INTEGRALKE BOTTL" -"E AND CUPKHAH INITIAL FORMLAGOLITIC LETTER LAH ISOLATED FORMLAPPING LESS-THAN" -"LD PERMIC LETTER LHOUETTE OF JAPANLIAN HIEROGLYPH AMALL RED TRIANGLEMALL WHIT" -"E CIRCLEMANENT PAPER SIGNMEDIUM BARB ARROWMEDIUM SHADE FORMMEEM INITIAL FORMM" -"ILITARY AIRPLANENASALIZATION MARKNAUDIZ NYD NAUD NND UPPER LEFT ARCNE EYEBROW" -" RAISEDNEGATIVE CIRCLED NFORMATION SOURCENG STROKE OVERLAYONE EIGHTH BLOCK-OP" -" AND UPPER LEFTOPEN-HEADED ARROWOURTEEN FULL STOPOWER NUMERAL SIGNPINWHEEL AS" -"TERISKPRECEDING SOLIDUSPRIZNAK MODIFIER PUNCTUATION SIGN QUAT REVERSED ESHREA" -"TIONAL VEHICLERIATION SELECTOR-RIGHT HALF CIRCLERYBLION BASE SIGNS REVOLVING " -"LIGHTSERVER EYE SYMBOLSIGN O WITH CROSSSQUARED TIMES KURSTRAIGHT MOVEMENTTAN " -"ISOLATED FORMTARTING FROM SIGNTEN THOUSAND SIGNTERSYLLABIC TSHEGTHREE SOUND W" -"AVESTIAL ARTS UNIFORMTONAL RANGE MARK TRIPLE DASH ARROWULAR MEDIUM SHADEUP AN" -"D HORIZONTALUP POINTING INDEXURNED COMMA ABOVEURNED DAMMA BELOWVARIANT FORM A" -"SH9VARIANT FORM IMINVARIANT FORM USSUVEE WITH UNDERBARVERAGE WITH SLASHVOCALI" -"ZATION MARKVRE TOURNOIS SIGNWHITE PARENTHESISWHITE SHOGI PIECEWITH DOUBLE SLA" -"SHWITH NOT EQUAL TOWO VERTICAL DOTS Y ON BLACK SQUAREYEH ISOLATED FORMYPTIAN " -"HIEROGLYPH AND HEAVY RIGHT AND LIGHT RIGHT CAPPED MOUNTAIN INSERTION POINT LI" -"GHT MOON ARTA OR THE IMAGE OF PLUS KAK PLUS A SMALL ROTATIONS TIMES DISH TENU" -" TIMES GAN2 TENU WITH BUNNY EARS WITH DOT INSIDE WITH HEADSTROKEADIAN SYLLABI" -"CS AFFRICATION MARKANABAZAR SQUARE ARENTHESES ABOVEB2 TENU PLUS TABBOLD GREEK" -" CROSSBOTTOM HALF RINGCANDRA ANUNASIKACASIAN ALBANIAN CH WITH UMBRELLACKLE FI" -"LL FRAME-CLOSED TENTACLESCOMPRESSED ARROWCONSONANT JOINERCORNER DOWNWARDSCORN" -"ER LEFTWARDSCREAMING IN FEARDEWAYS U BRACKETDITORIAL CORONISDOTTED CRESCENTSD" -"OUBLE CRESCENTSDOUBLE DOT ABOVEDOUBLE HEAD MARKDOUBLE TURNSTILEDOUBLE ZAPYATA" -"YADOWN RIGHT BARB DVUMYA ZAPYATYMIE PLUS GAN2 TENUECIMAL SEPARATOREFORE COMPL" -"ETIONEN MILLIONS SIGNEND OF TEXT MARKENTRE WHITE STARENUMERATION SIGNEPSILON " -"UNDERBARERCURY SUBLIMATEEVERSED VISARGA EVERY OTHER TIMEFALLING DIAGONALFFERE" -"NCE BETWEENFLOORPLANE SPACEFORWARD-FACING RHIGH SPACING DOTHMATULLAH ALAYHEHO" -"LDING TOGETHERHYPHENATION MARKIDED GREEK CROSSIFTEEN FULL STOPIGHTH NOTE STEM" -" IMENSIONAL ANGLEINDEPENDENT SHININDEX THUMB SIDEINES CONVERGING IPPER-MOUTH " -"FACEIRCLE X NOTEHEADISTOS DISC SIGN IVE POINTED STARK PERMITTED HERELD ASSYRI" -"AN ONE LEFT ARROW ABOVELEFT HALF CIRCLELIGHT AND RIGHT LIGHT BARB ARROWLLER C" -"OASTER CARLLOW PAN OF FOODLOWER OVER UPPERLTERNATE HASANTAMAGNIFYING GLASSMES" -"TVENNY KLYUCHMIDDLE AND BELOWMIDDLE AND RIGHTNAL DIGIT SHAPESNGQIN SIGN SLOW " -"NION WITH SERIFSNTAIGANA LETTER O-MINOAN SIGN CMOLD TAMIL VIRAMAOLD WHITE CIR" -"CLEORIZONTAL JOINERPEN CENTRE CROSSPLACEHOLDER MARKPLE MEASURE RESTPOSTPOSITI" -"ON MENPRECEDING SUBSETPRECHGESANG STEMQ WITH HOOK TAILR PLUS GAN2 TENURAIDO R" -"AD REID RRAYS AND DOTTED RECORD SEPARATORREPETITION MARK-RESH-AYIN-DALETHRESS" -"IONLESS FACERIGHT DOWN BARB RIGHT HALF BELOWRIGHT HALF BLACKRISING TONE MARKR" -"IZONTAL ELLIPSESANS-SERIF ARROWSERIFS AT BOTTOMSHU2 PLUS KASKALSIGN RISING TO" -"NESITION INDICATORSLANTED EQUAL TOSMALL CAPITAL ELSMALL NOON ABOVESTERISK OPE" -"RATORSTICKING OUT FARSTRAIGHT STRETCHSTRING FRETBOARDSTUCK-OUT TONGUETAKANA-H" -"IRAGANA TRIPLE CRESCENTSUBJOINED LETTER UDLY CRYING FACEULDERED OPEN BOXUMBER" -" SIGN ABOVEUP MIDDLE HINGEDUP-OUTPUT SYMBOLUPERSCRIPT ALAPHUPPER OVER LOWERVA" -"RIANT FORM ESHVERY HEAVY SHAFTVIEWING CEREMONYVOWEL LENGTHENERWALLED ENCLOSUR" -"EWAVY HAMZA BELOWWITH CENTRED DOTWITH HEARING AIDWITH LEFT UPTURNYATHOS BASE " -"SIGNYIR MKPARAQ MEUN ALTERNATE FORM AND BOTTOM END CLOUD AND RAIN CORNER BRAC" -"KET DEYTEROU ICHOU NEPOSTOYANNAYA OPERATOR WITH OVER MOUNTAINS OVER SIG4 SHU" -"2 PARESTIGMENON PLUS HI PLUS A THROUGH CIRCLE THUMB STRAIGHT TIMES IGI GUNU " -"TOUCHING INDEX WITH DESCENDER WITH DIAERESIS WITH RIGHT LEG-AND-RING BELOW-CA" -"RRIER LETTER-NO-EVIL MONKEY-PIECE SWIMSUIT2 CHARIOT FRAMEACHES THE LIMITAI LA" -"ING DIGIT ALAYHE ASSALLAMALAYHI WA-AALIHALIF LENGTHENERALMOST EQUAL TOAMARITA" -"N SOURCEAMOUNT OF CHECKAND PARALLEL TOATA LINK ESCAPEATINATE MYSLITEBAGS UNDE" -"R EYESBAR ABOVE UNIONBELGTHOR SYMBOLBELOW LONG DASHBENT OVER INDEXBINDING BRA" -"CKETBLACK TRIANGLESBLOCK DIAGONAL BREAKING HYPHENBROWS STRAIGHT CAPITAL LETTE" -"RSCIRCUIT-OUTPUT CKET CALCULATORCLOSED BY CURVECORNER WITH DOTDAGESH OR MAPIQ" -"DESCENDING TONEDI ALLAHOU ANHUDIALYTIKA TONOSDIGA AELA-PILLADOING CARTWHEELDO" -"UBLE TRIANGLEDOWN SEQUENTIALDOWNWARDS TRENDE ISOLATED FORME MUSICAL NOTESE OV" -"ER INFINITYEFT REPEAT SIGNEH INITIAL FORMERICAN FOOTBALLESIDE LESS-THANESISTO" -"R SEGMENTESSARON CHRONONETIC VERSE SIGNEXPONENT SYMBOLFIVE-LIKE BHALEFORWARD " -"TILTINGFOUR DOTS BELOWFOUR DOTS WITH FOUR ENCLOSURESFOUR TICK MARKSFRACTION D" -"IGIT FTER COMPLETIONGEMINATION MARKGGLY LINE BELOWGHT REPEAT SIGNGROUP SEPARA" -"TORHAKING PARALLELHALF FILL SPACEHALF VERTEX OF HEH MEDIAL FORMHOOKED INDEX U" -"PHORIZONTAL DASHHORIZONTAL FILLHOUSAND STATERSHREE DOTS BELOWHREE HALF BEATSI" -"AMOND UNDERBARIDING ENCLOSUREIGN PALI VIRAMAIMISEOS CHRONOUIMPERFECTA RESTING" -" SYMBOL FOR INGLE HEAD MARKINVERTED CARIK INVERTED LAZY SINVERTED STROKEIRCUM" -"FLEX BELOWITH FINGERNAILSIZED WHEELCHAIRKISIM5 TIMES BIKTOVIK NUMERAL LATION " -"FUNCTIONLD TAMIL SHORT LEFT DOWN BARB LEFT HALF BELOWLEFT HALF BLACKLEFT HAND" -" INDEXLETTER CAPITAL LEVEL TONE MARKLEVEN FULL STOPLIGHT AND LEFT LMOST EQUAL" -" TO LONG HOOK BELOWLONG VOWEL SIGNLOOK OF TRIUMPHLOSED INSULAR GMALAKON CHROM" -"A MARRYING MAIDENMEEM FINAL FORMMIDDLE DIAGONALMURDA MAHAPRANAN-ARY SUMMATION" -"NA DOUBLE HELIXNASALIZED TONE-ND OF PARAGRAPHNJOINING MACRONNO GOOD GESTURENO" -"ON FINAL FORMNOT APPROXIMATENVERTED UBADAMAODIFIER DAMAGEDODO SOFT HYPHENOGOG" -"RAM KHAMTI OLIDUS OPERATORON TOP OF MODEMOND PLACE MEDALONJOINED HINGEDONTOUR" -" INTEGRALORIZONTAL COLONORT EQUALS SIGNOUBLE BACKSLASHOW-FALLING TONEOWER HAL" -"F BLACKPEN SQUARED DOTPENSION RAILWAYPERTHO PEORTH PPLUS SIGN BELOWPRISHTHAMA" -"TRA EPUT SYMBOL FOR QUADRUPLE ARROWQUADRUPLE DASH R WITH FISHHOOKREAMY EYEBRO" -"WS RECEPTIVE EARTHRECITATIVE MARKREVERSE SOLIDUSREVERSED OPEN ERIGHT HALF RIN" -"GRIGHT RERENGGANRIGHTWARDS AND RIGHTWARDS TICKRMAN PENNY SIGNRNAMENT STROKE-S" -" ELEVATUS MARKS IN SILHOUETTESHITA PLUS GISHSHORT OVER LONGSIXTEENTH NOTESSSI" -"CAL BUILDINGST QUARTER MOONST SYRIAC CROSSSTANDING KNIGHTSTANDING PERSONSTERE" -"SIS SYMBOLSTROKE NOT SIGNTAI LAING TONE-THREE DISH TENUTHROWING A KISSTILDE D" -"IAERESISTIP ON THE LEFTTOP RIGHT FATHATRIANGULAR MARKTVIMADUR SYMBOLTWO WITH " -"STROKEU PLUS U PLUS UUBLE RING BELOWUGMENTATION DOTULTIPLICATION XUMAI PALAUN" -"G FAUR POINTED STARUSTER NOTEHEAD VERTICAL SECANTVOWEL SEPARATORVOWEL SHORTEN" -"ERWALLPLANE SPACEWHITE DOT RIGHTWITH DOWN ARROWWITH RAIN DROPSWO THIRDS BLOCK" -"XTEEN FULL STOPYNCHRONOUS IDLEZ WITH CROSSBARZAIN FINAL FORMZERO WITH SLASH A" -"ND DIAERESIS AND SMALL TAH CROSSING ESH2 HASER FOR VAV WITH BACK YER WITH LON" -"G LEG-CURRENCY SIGN1 OVER LAK-081AFETY SCISSORSALF TREE TRUNKALTER PAHLAVI AM" -"NUC PII KUUHAND COLD SWEATANGLE OPENING AROUND-PROFILEAU LENGTH MARKBAG MEMBE" -"RSHIPBHATTIPROLU AABLADE SCISSORSCENTURIAL SIGNCEPTER OF JOVECERTAINTY SIGNCO" -"LON OPERATORCRAB STEPPING CRIFICIAL WINED-UP NEWSPAPERDASIA PNEUMATADEYTEROS " -"ICHOSDIAGONAL MOUTHDIAGONAL PATH DING CHARACTERDIO MICROPHONEDIRECTION FLIPDO" -"ES NOT EXISTDOUBLE-STRUCK DUN3 GUNU GUNUED SYMBOL FOR EMIVOWEL SIGN END OF SE" -"CTIONENDED MULTIMAPEPENTHETIC YUTERIAL ARAMAIC ERIC INDICATORERTICAL JOINEREX" -"CLAMATION OHEXTENDED BHALEFATHATAN ABOVEFFED FLATBREADFFICE BUILDINGFINAL ANU" -"SVARAFORWARD INDEX GERED TREMOLO-GHT WITH STARSGUNU TIMES ASHGYPTOLOGICAL AHE" -"SIVE BANDAGEHIRD-STAGE HLIHREE-LEGGED TEIGHTWARDS VANEIKHAYA PUTNAYAING HANDS" -" SIGNINOLOGICAL DOTINSERTION SIGNINVERTED BIRGAINVERTED DAMMAIRCULAR VIRAMAIS" -"ED ROUND DOTISSION TICKETSITA PLUS GISH IVE KEY SYMBOLIVE OBOLS SIGNIWAZ TIR " -"TYR TJOINED SQUARESLACE OF SAJDAHLEFTWARDS AND LEFTWARDS TICKLESS-THAN NOR LE" -"TTER OVERLAPLEVEN TWELFTHSLIGHTLY SMALL LITTLE SECTIONLOTUS POSITIONLOWER DIA" -"GONALLOWER TERMINALMEDIUM DIAMONDMENSION ORIGINMID-LEVEL TONEMOTHETIC ABOVEMR" -"ACHNOTIKHAYANORTH ARABIAN NYI ZLA NAA DAOBLIQUE HYPHENOLD RESOLUTIONONE SOUND" -" WAVEOOTNOTE MARKEROPEN TENTACLESOPPOSING PIRIGORANGE DIAMONDORD SEPARATOR OS" -"ITION SYMBOLOT TILDE ABOVEOTHERS CIRCLEDOUR OBOLS SIGNOUSING THUNDEROVER GUD " -"LUGALPAO KAREN TONEPARTMENT STOREPEN MARK BELOWPLE WITH HEARTPLETE INFINITYPL" -"ITTING APARTPPED MIDDLE UPPROTECTED AREAQUINARIUS SIGNRD PLACE MEDALREATIVE H" -"EAVENREE-LINE STAFFREH FINAL FORMREVERSED-SCHWARIGHT CROSSBARRING MEGAPHONERO" -"SS ON SHIELDSECOND SUBUNITSEL LOCOMOTIVESEPARATOR MARKSHAN MEDIAL WASHESHIG T" -"IMES SHRII PUSHPIKASIDE-DOWN FACESMALL LETTER DSMALL LETTER JSMOKING SYMBOLSP" -"EECH BUBBLESSQUIGGLE ARROWSTRONG ISOLATETELPIECE CLOCKTERMINAL MARK-TETARTOS " -"ICHOSTHAKA ANUDATTATHALAN ETHEL OTHER CHRISTMASTHOUSANDS MARKTHOUSANDS SIGNTH" -"REE POINTED TIMES OPERATORTIMES SHU TENUTOP HALF BLACKTRADITIONAL ERTRANSMIT " -"STATETRIANGLE CARETTRIANGLE WITH TURKIC LETTER TWELFTH CIRCLETWO DOT LEADERTW" -"O ENCLOSURESTWO WHITE DOTSUAL WHEELCHAIRUBHAYATO MUKHAUND MARK ABOVEUNDER REL" -"ATIONUNION OPERATORUNIT SEPARATORUP RIGHT BARB UPPED INDEX UPUPPER TERMINALUS" -"PENSION MARKVENIENCE STOREVERTICAL ABOVEVERTICAL COLONVERTICAL HEAVYVERTICAL " -"LIGHTVONIC ASTERISKVRON SNOWFLAKEWITH DOT BELOWWITH FATHATAN WITH LEFT HOOKWO" -"RD SEPARATORXO EKFONITIKONYOUTHFUL FOLLYZAH WITH MEEM ZAKAYA LANTERN AND SKI " -"BOOT AND YEN SIGN B BAR SYMBOL BAT AND BALL BZHI MIG CAN CROSSING KA2 DIMINUT" -"ION-1 DIRECTIONAL HEADED ARROW OF THE HORNS OPPOSING KUR TIMES KASKAL VARIAN" -"T FORM WITH INK PEN WITH JEGOGAN WITH OVERBAR WITH TEE TOP WITHOUT SNOW-ESASA" -" DOTTED-OFF CALENDAR-OR-PLUS SIGN-PER-EM SPACEACCOMMODATIONALL LOST SIGNAMUHU" -" ALAYNAAAN RUPEE SIGNANNED LEATHERANTIC FIGURE APPED PRESENTAR WITH QUILLARCH" -"AIC KOPPAARGOSYNTHETONARLAUG SYMBOLARRED TRIDENTARROW OVERLAYAUDATE CHRIVIAWE" -"LLEMET YAZBACKSLASH BARBALL AND HOOPBASAN LETTER BOHAIRIC KHEIBOTTOM CORNERBO" -"WING DEEPLYBY DEFINITIONCENTRED ABOVECHRYSANTHEMUMCIRCLE INSIDECITATION MARKC" -"RIPTION TAKECRIPTIONAL PACROSSING GABACROSSING GAN2CROSSING MUSHCULATED LORRY" -"DI RIYAL SIGNDIAERESIZED UDIC MARK SIGNDOTTED ZLAMA DOUBLE CIRCLEDOUBLE HYPHE" -"NDOUBLE MUCAADDOUBLE STROKEDVOECHELNAYA EAVENLY EARTHED PAPERCLIPSEDIC ANUSVA" -"RAEELING PERSONEHU FEOH FE FEMPHATIC TONEER BOARD FILLERTION SYMBOLEUROPE-AFR" -"ICAEVERSED DAMMAFICATION CARDFINAL LETTER FINAL SEMKATHFIXED-FORM RAFOREMENTI" -"ONEDFROWNING FACEFT ARROWHEAD FULL SURROUNDGAR FRACTION GAW KAREN SHAGIFT ENV" -"ELOPEGTER TSHEG MAGYA GRAM SHADH-TYPE SYMBOLHAKASSIAN CHEHAM DIGIT ONEHERICAL" -" ANGLEHIEROGLYPHIC HINESE TONE YHREE TWELFTHSI LENGTH MARKI WITH STROKEIDE LO" -"ST SIGNIFI ROHINGYA IGHT TWELFTHSILABIAL CLICKILE SEPARATORIMAGE BRACKETINTER" -"EST SIGNINVERTED FORKINVERTED TURNIOT SYLLABLE IRCLED INDEX ISH LIRA SIGNITIN" -"G THROUGHIVE POINT ONEIVE SLOW SIGNJES SU NGA ROJJAL ALLAAHU K WORK SYMBOLKAP" -"YEOUNPIEUPL-TYPE SYMBOLLATERAL CLICKLEFT CROSSBARLEGETOS ICHOSLISION SYMBOLLO" -"CATION SIGNLOCK WITH KEYLOOPED VIRAMALOSING SPIRALLVE FULL STOPLVEOLAR CLICKM" -"AILBOX WITH MALL LETTER ZMALO POVYSHE MARKS CHAPTERMASORA CIRCLEMATU ALLAAHI " -"MEDIUM SQUAREMELODIC QITSAMESSENIAN TENMICROCOMPUTERMINDER RIBBONMINUS SIMILA" -"RMINUS WHITE XMOBILE PHONESMODIFIER MARKMULTIOCULAR ONAP PIZZICATONG TERMINAT" -"ORNINE TWELFTHSNING MOVEMENTNP TRANSISTORNTY FULL STOPNUMERATOR ONENUMERIC SI" -"GN OBLIQUE LINE OGOTYPE SIGN OLVING HEARTSOMAN NUMERAL ONAL COMPUTERONG RIGHT" -" LEGONG-LEGGED DEONGRATULATIONOON NOTEHEAD OPPOSING NAGAOTEHEAD BLACKOURTH SU" -"BUNITOUT MIDDLE UPPA NJI PIPAEMPAIRED ARROWSPLUS OPERATORPN TRANSISTORPPOSING" -" LUGALPREPONDERANCEQUARTERS SIGNRACKETS ABOVERANKS CASKET RIGHT HARPOONRIGHT " -"POINTERRIPLE SVARITARIZONTAL TAILRN PENTATHLONROTATED BIRGARPENTRY PLANERRIAG" -"E RETURNRTABLE STEREOS KAI APOTHESS KRYZHEM ON S UP TOGETHERSAL PLUS TUG2SAMY" -"OK SANNYASELECTED AREASHESH PLUS KISIA-AUSTRALIASIGN AVAGRAHASIGN PAMUDPODSIL" -"I PNEUMATASIMPLIFIED ERSMALL LETTERSSSAGE WAITINGSTABLE SYMBOLSTERTIUS SIGNSY" -"NDESMOS NEOTE ORDER MARKTED HAND SIGNTHIRD SUBUNITTIRTA TUMETESTOP HALF RINGT" -"U WAS-SALAAMU WITH STROKEUE OF LIBERTYUFFLE PRODUCTUPERIMPOSED XUPONDIUS SIGN" -"UPSILON WITH UPWARDS TRENDURNED W BELOWUSHING UPWARDUSICAL LEIMMAVE-LINE STAF" -"FVEN POINT ONEVERGREEN TREEVERLAY MIDDLEVERTICAL BARSVERTICAL FILLVERTICAL-LI" -"NEVICE CONTROL VOWEL SIGN PAW RING INSIDEWAVY LOW LINEWAVY OVERLINEWAW-AYIN-R" -"ESHWHITE ELLIPSEWITH ASTERISKWITH INTEGRALWO-LINE STAFFYMBOL TAU RHOYOD YOD P" -"ATAHYUUKALEAPINTUZHOU NUMERAL AND PICTURE AND TOP END CROSSING GU IN TRIANGL" -"E KLYUCHEVAYA LINE SYMBOL OF ANTIMONY ON PEDESTAL OVER KISIM5 OVER MIDDLE OVE" -"R TWO PI SKEWED LEFT WITH DAGESH WITH INDEX WITH UPTURN-DZUD RTAGS -MAIL SYM" -"BOL-SHAPED SIGN-SIMPLIFIED 6 LONG NGGOOACE INTEGRALACUTE ACCENTAFU LEERAEWAAL" -"LPOINT PENALT PAN SIGNALTERNATING AND CRESCENTAND OPERATORANG KHANG GYAR DIAE" -"RESISARALLELOGRAMATNAH HAFUKHATTOOED HEADBACK OF HANDBAHIRGOMUKHABEHIND CLOUD" -"BETWEEN LIPSBINING MARK BLOWING FACEBLUE DIAMONDBRATION MODEBRIDGE ABOVEBSCRI" -"PT ALEFBUTTON MOUSEBYSMAL WATERCABBAGE-TREECALENDAR PADCENDING NODECHAIR SYMB" -"OLCIAN LETTER CIRCLED PLUSCIRCLES AND CK-O-LANTERNCLOSED MOUTHCRESCENT BARCRO" -"SSING GI4CROSSING KALCROSSING LU2CROSSING NUNDASHED ARROWDE MARK SIGNDENTAL C" -"LICKDHRI LETTER DICTION SIGNDIGRAPH KOTODIGRAPH YORIDOT OPERATORDOUBLE ARCH D" -"OUBLE ARROWDOWN HARPOONDOWN NEUTRALDUG TIMES NIEEPING SMALLEIGHTH NOTESEMELY " -"HEAVY EMISOFT SIGNENARIUS SIGNENOS CHRONOUERPENDICULARETRETES SIGNEVERING FAC" -"EFALLING DOTSFEMININE DOTFERENCE MARKFLAG ON POSTFOLDED HANDSFORMING ARTSFOUN" -"TAIN PENFT RERENGGANGAW KAREN EUGBY FOOTBALLGEBA KAREN IGREEN DRAGONGROUND SL" -"IDEGUARDED AREAHAH WITH DALHALF BRACKETHAND FORMAT HASIS SYMBOLHEAD-BANDAGEHI" -"BITED SIGNHREE FINGERSHYPHEN-MINUSIDENTICAL TOIGATURE SHRIILLED CIRCLEIN MIDD" -"LE UPINDEX MIDDLEING ENVELOPEING HAND FANING HITTING ING OPERATORINTEGRATION " -"INUSOID SIGNINVERTEBRATEIRAGANA HOKAIRTY-SECOND IVE TWELFTHSKANA REPEAT KAPPA" -" SYMBOLKHAMTI TONE-KHMIMIC KHEILAM WITH YEHLARGE DOUBLELARGE TRIPLELATALIZATI" -"ONLAYING CARDSLEADING EYESLEFT HARPOONLEFT POINTERLER CONSTANTLICKING LIPSLIM" -"BS DIGITSLINGING FIRELINKING MARKLL MODIFIER-LLE PATTERN LOWER CORNERLOWERED " -"FLAGLU PLUS ESH2LUS NOTEHEADLYING SAUCERM NSHUT NYAMMADDA ABOVE MALL SECTIONM" -"ANNAZ MAN MMBELLISHMENTMEDARY CAMELMEDIUM SHAFTMETA STAVROUMIDDLE PIECEMING T" -"O MEETMONOGRAPH UKMPHASIS MARKMPTY CENTRE MUM TIMES PAN ELEMENT OFNARROW SHAF" -"TNATURAL SIGNNCK CONSTANTNEPOSTOYANNYNERSHIP SIGNNEUTRAL FACENGLE BARLINENJAL" -"A GONDI NORTHERN TSENOTCHED HOOKNOTCHED TAILNUITY SYMBOLOCTET PRESETOGOGRAM N" -"YAJOHAZARD SIGNOID NOTEHEADOING TO MEETOK HAND SIGNON US SYMBOLONISHED FACEOP" +"ADED ARROWROTUNDA WITH DESCENDING CROSSING LOOPSMALL LETTER BYELORUSSIAN-UKRA" +"INIAN I AND LOWER HALF INVERSE MEDIUM SHADE WITH HORIZONTAL MIDDLE BLACK STRI" +"PEDOUBLE-LINE EQUAL ABOVE GREATER-THANGREATER-THAN ABOVE DOUBLE-LINE EQUALHAR" +"POON ABOVE LONG LEFTWARDS HARPOONIGHT TORTOISE SHELL BRACKET ORNAMENTLEFT TOR" +"TOISE SHELL BRACKET ORNAMENTOVER LEFTWARDS TRIANGLE-HEADED ARROWPART BETWEEN " +"MIDDLE AND RING FINGERSSINGLE COMMA QUOTATION MARK ORNAMENTSMALL ARABIC LETTE" +"R TAH AND TWO DOTSTTOM RIGHT OBLIQUE HALF BLACK CIRCLETURNED COMMA QUOTATION " +"MARK ORNAMENTZENGE CONTAINING BLACK SMALL LOZENGE CONTAINING BLACK VERY SMALL" +" SQUAREBESIDE AND JOINED WITH INTERSECTIONBOTTOM-LIGHTED RIGHTWARDS ARROWHEAD" +"DOUBLE VERTICAL AND HORIZONTAL LINEGVEDIC KASHMIRI INDEPENDENT SVARITAND UPPE" +"R AND LOWER ONE EIGHTH BLOCKORNER ARROWS CIRCLING ANTICLOCKWISEOUNDED HIGH ST" +"OP WITH FILLED CENTRER LOWER RIGHT CURLY BRACKET SECTIONRIGHT-POINTING ANGLE " +"QUOTATION MARKTWO HORIZONTAL STROKES TO THE RIGHTVERTICAL LINE WITH THREE TIC" +"K MARKS TWO DOTS OVER ONE DOT PUNCTUATIONBLACK LEFT-POINTING SMALL TRIANGLEDO" +"WNWARDS ARROW WITH TIP LEFTWARDSIGHUR KAZAKH KIRGHIZ ALEF MAKSURA MODIFIER LE" +"TTER LABIALIZATION MARKOPEN ARM ENDING IN ARROW POINTING OVER IGI SHIR OVER S" +"HIR UD OVER UDOVER TAB NI OVER NI DISH OVER DISHPPROXIMATELY NOR ACTUALLY EQU" +"AL TOR LOWER LEFT CURLY BRACKET SECTIONTEARDROP-SPOKED PROPELLER ASTERISKUPPE" +"R BODY TILTING FROM HIP JOINTSALL BUT UPPER LEFT QUADRANT BLACKDIRECT PRODUCT" +" WITH BOTTOM CLOSEDDOUBLE-LINE EQUAL ABOVE LESS-THANDOWNWARDS HARPOON WITH BA" +"RB RIGHTEFT-POINTING ANGLE QUOTATION MARKLESS-THAN ABOVE DOUBLE-LINE EQUALLLA" +"R SIGN WITH OVERLAID BACKSLASHMEDIUM SHADE AND LOWER HALF BLOCKOUTHWEST POINT" +"ING ARROWHEAD BELOWRAISING BOTH HANDS IN CELEBRATIONTROFLEX CLICK WITH RETROF" +"LEX HOOKTRONG CENTRALIZATION STROKE BELOWTUG2 OVER TUG2 TUG2 OVER TUG2 PAPTWO" +" DOTS ABOVE AND TWO DOTS BELOWWARDS HARPOON WITH BARB DOWNWARDS-POINTING ANGL" +"E BRACKET ORNAMENTAND MIDDLE RIGHT TO LOWER CENTREATHARVAVEDIC INDEPENDENT SV" +"ARITAETALLED BLACK AND WHITE FLORETTEHAND WITH MIDDLE FINGER EXTENDEDNORMAL F" +"ACTOR SEMIDIRECT PRODUCTRIANGLE-HEADED OPEN CIRCLE ARROWRIGHT SEMICIRCLE WITH" +" THREE DOTSRONT-TILTED SHADOWED WHITE ARROWSEMICIRCULAR ANTICLOCKWISE ARROWVE" +"D STEM PARAGRAPH SIGN ORNAMENT CROSSING ASH OVER ASH OVER ASHACK-TILTED SHADO" +"WED WHITE ARROWAISED HAND WITH FINGERS SPLAYEDAND MIDDLE LEFT TO LOWER CENTRE" +"ETALLED OUTLINED BLACK FLORETTEIGATURE LONG S WITH DESCENDER SIN WHITE CIRCLE" +" IN BLACK SQUARELEFTWARDS EQUILATERAL ARROWHEADONE HUNDRED THIRTY-FIVE DEGREE" +"SRIGHTWARDS HARPOON WITH BARB UPRING OVER TWO RINGS PUNCTUATIONRINGS OVER ONE" +" RING PUNCTUATIONTNAMESE ALTERNATE READING MARK UPWARDS HARPOON WITH BARB RIG" +"HT CONTAINING BLACK SMALL SQUARE-HIRAGANA PROLONGED SOUND MARKAGGRAVATED INDE" +"PENDENT SVARITAAND JOINED BY DASH WITH SUBSETDOT BELOW AND THREE DOTS ABOVEDO" +"WNWARDS AND RIGHTWARDS ARROWEART EXCLAMATION MARK ORNAMENTEFT SEMICIRCLE WITH" +" THREE DOTSGHT FOUR POINTED PINWHEEL STARGREATER-THAN ABOVE EQUALS SIGNHIGH-R" +"EVERSED-9 QUOTATION MARKHT CENTRALIZATION STROKE BELOWINDEX THUMB CURVE THUMB" +" INSIDEMAKSURA WITH SUPERSCRIPT ALEF MINTON RACQUET AND SHUTTLECOCKMODIFIER L" +"ETTER LEFT HALF RINGON WITH RIGHTWARDS ARROW ABOVEOPEN CENTRE EIGHT POINTED S" +"TARQAF WITH LAM WITH ALEF MAKSURARECTANGULAR CHECKER BOARD FORMSAD WITH LAM W" +"ITH ALEF MAKSURA DOWN INDEX THUMB HOOK MIDDLE OVER RIGHTWARDS ARROW TO BAR WI" +"TH REVERSED NEGATION SLASHABOVE SHORT LEFTWARDS HARPOONCKED FACE WITH EXPLODI" +"NG HEADCONTAINING BLACK SMALL CIRCLEDOT OVER TWO DOTS PUNCTUATIONDOWN HEAVY A" +"ND RIGHT UP LIGHTDOWN MIDDLE THUMB INDEX CROSSEFTWARDS HARPOON WITH BARB UPEV" +"ERSED LUNATE EPSILON SYMBOLEXTENDED ARABIC-INDIC DIGIT TLIGHT FOUR POINTED BL" +"ACK CUSPNS-SERIF INTERROBANG ORNAMENTOMBINING ANUSVARA ABOVE RIGHTONAL INDICA" +"TOR SYMBOL LETTER PUNCTUATION CHINOOK FULL STOPSEMICIRCULAR PATH AROUND POLES" +"UPERSCRIPT ALEF INITIAL FORMUP HEAVY AND RIGHT DOWN LIGHTWITH RIGHTWARDS ARRO" +"W AT LEFT WITH DOUBLE HORIZONTAL LINEACE DIRECTION POSITION NOSE ASTERISKS AL" +"IGNED VERTICALLYBESIDE AND JOINED WITH UNIONDOUBLE ANUSVARA ANTARGOMUKHADOWN " +"HEAVY AND LEFT UP LIGHTEDGE-TAILED RIGHTWARDS ARROWEFT ARC GREATER-THAN BRACK" +"ETFTING POINT RIGHTWARDS ARROWGRAPHIC CHARACTER INTRODUCERHADED WHITE RIGHTWA" +"RDS ARROWHREE HUNDRED FIFTEEN DEGREESIBE SYLLABLE BOUNDARY MARKERISMILLAH AR-" +"RAHMAN AR-RAHEEMLEFTWARDS OF DOWNWARDS ARROWLIQUID MEASURE FIRST SUBUNITMIDDL" +"E CENTRE TO UPPER RIGHTMIDDLE RING LITTLE CONJOINEDMONOGRAMMOS TESSERA DODEKA" +"TAORTHEAST POINTING ARROWHEAD OUND-TIPPED RIGHTWARDS ARROWRECTANGULAR PATH AR" +"OUND POLESALTIRE WITH ROUNDED CORNERST LITTER IN ITS PLACE SYMBOLTAAALAA FARA" +"JAHU ASH-SHAREEFUP HEAVY AND LEFT DOWN LIGHTUPPER CENTRE TO MIDDLE RIGHTUPWAR" +"DS AND RIGHTWARDS ARROW AND LEFT SEMICIRCLE ARROWS BARREE WITH TWO DOTS BELOW" +" DIVIDED BY HORIZONTAL RULE-FEATHERED RIGHTWARDS ARROWAND UPPER HALF WHITE CI" +"RCLEARROW ABOVE LEFTWARDS ARROWBETWEEN TWO HORIZONTAL BARSBRDA RNYING YIG MGO" +" MDUN MABRDA RNYING YIG MGO SGAB MACIRCLE WITH NORTHWEST ARROWCONTINUOUS UNDE" +"RLINE SYMBOLDOUBLE PRIME QUOTATION MARKEAVY WHITE RIGHTWARDS ARROWEMICIRCULAR" +" CLOCKWISE ARROWENTATION FORM FOR VERTICAL FINGER COVERING CLOSED LIPSFOUR FI" +"NGERS CONJOINED BENTHANDED INTERLACED PENTAGRAMHEAD MARK WITH MOON AND SUNIDE" +" ARC ANTICLOCKWISE ARROWIDE-HEADED RIGHTWARDS ARROWIMPERFECTUM CUM PROLATIONE" +" KATHAKA INDEPENDENT SVARITALARGE EQUILATERAL ARROWHEADLESS-THAN ABOVE EQUALS" +" SIGNLIGHT CENTRALIZATION STROKELOWER MIDDLE LEFT TO LOWER LOWER TONAL RANGE " +"INDICATORONE LARGE AND ONE SMALL EYEOUR BALLOON-SPOKED ASTERISKOVER LONG LEFT" +"WARDS HARPOONPHARYNGEAL VOICED FRICATIVEPPY PERSON RAISING ONE HANDRIANGULAR " +"ONE QUARTER BLOCKRIGHT ARC LESS-THAN BRACKETRIPLE VERTICAL BAR OPERATORSTRUME" +"NTAL NOTATION SYMBOL-TALIC LATIN CAPITAL LETTER THOUSAND TWENTY-FOURTH RESTTW" +"O HUNDRED SEVENTY DEGREESUPPER CENTRE TO LOWER RIGHTUPPER MIDDLE LEFT TO UPPE" +"R WALLPLANE SHOULDER HIP MOVEWO DOTS BELOW AND DOT ABOVEZERO FOR ODD POWERS O" +"F FOUR GAD OVER GAD GAR OVER GAR LESS THAN THE DENOMINATOR NEGATED WITH VERTI" +"CAL BAR OR APPROXIMATELY EQUAL TO WITHIN TRIANGLE ARROWHEADALEF MAKSURA ISOLA" +"TED FORMAND LEFT HALF WHITE CIRCLEAND MIDDLE FINGERS CROSSEDAND RIGHT ONE EIG" +"HTH BLOCKCAT FACE WITH SMILING EYESCLOCKWISE ARROW WITH MINUSCRIPT LIGATURE E" +"T ORNAMENTDOTTED LUNATE SIGMA SYMBOLDOTTED SUBSTITUTION MARKERDROP-SHADOWED W" +"HITE SQUAREE ONE-WAY LEFT WAY TRAFFICERSTRASS ELLIPTIC FUNCTIONHTORA SKLIRON " +"CHROMA VASISIDEOGRAPHIC ITERATION MARKINDUSTRIAL STANDARD SYMBOLJECT REPLACEM" +"ENT CHARACTERLANTED SOUTH ARROW WITH HOLEFTWARDS OF UPWARDS ARROWLINE FEED SE" +"PARATOR SYMBOLLLALLAHOU ALAYHE WASSALLAMMARRIED PARTNERSHIP SYMBOLMEEM WITH H" +"AH WITH TATWEELMODIFIER FITZPATRICK TYPE-OCKED FEMALE AND MALE SIGNOORPLANE S" +"HOULDER HIP MOVEORTHOGONAL CROSSHATCH FILLOTATED FLORAL HEART BULLETOUBLE ANG" +"LE QUOTATION MARKRIGHT PARENTHESIS ORNAMENTRINGS ALIGNED HORIZONTALLYRIPLE DO" +"T PUNCTUATION MARKSSIAN ASTROLOGICAL SYMBOL THREE DOTS ABOVE DOWNWARDSU REVER" +"SED OVER U REVERSEDUNEVEN EYES AND WAVY MOUTHWHITE RIGHT POINTING INDEXWITH L" +"EFTWARDS ARROW ABOVEYAJURVEDIC MIDLINE SVARITA HUNDRED FIFTY-SIXTH REST OVER " +"NUN LAGAR TIMES SAL WITH CIRCLED ONE OVERLAY WITH DOUBLE GRAVE ACCENT WITH DO" +"UBLE MIDDLE TILDE WITH DOUBLE VERTICAL BARBREVE WITH INVERTED BREVEBUT NOT AC" +"TUALLY EQUAL TOCAT FACE WITH CLOSED EYESCROSSING NORTH EAST ARROWDIAERESIS AN" +"D HOOK SYMBOLDOUBLE CANDRABINDU VIRAMADOUBLE WHITE SMALL SQUAREDRY MEASURE FI" +"RST SUBUNITELD HOCKEY STICK AND BALLFECTIVENESS OR DISTORTIONFFICULTY AT THE " +"BEGINNINGING ON THE FLOOR LAUGHINGINVERTED EXCLAMATION MARKLE TENNIS PADDLE A" +"ND BALLLEFT PARENTHESIS ORNAMENTLEFTWARDS ARROW WITH HOOKLOW QUILT SQUARE ORN" +"AMENTMBINING CRYPTOGRAMMIC DOTMEDIUM TRIANGLE ARROWHEADMULTIPLICATION SIGN BE" +"LOWNIVERSAL RECYCLING SYMBOLOLD ASSYRIAN WORD DIVIDERONE UNDER EIGHTEEN SYMBO" +"LOUBLE BIRGA WITH ORNAMENTOUTLINED RIGHTWARDS ARROWOVER LONG LEFTWARDS ARROWR" +"ANCH BANK IDENTIFICATIONREE-HUNDRED-AND-TWENTIETHRIGHT DIAGONAL HALF BLACKRIG" +"HT ONE SIXTEENTH BLOCKRIPLE BIRGA WITH ORNAMENTRIST CIRCLE HITTING WALL SQUAR" +"E CHECKER BOARD FORMSTROKE AND TWO DOTS ABOVETAB OVER TAB GAR OVER GARTERNION" +" INTEGRAL OPERATORTTED SUBSTITUTION BRACKET OVER TOP SQUARE BRACKET POINTING " +"BACKHAND INDEXALTERNATE SECTION MARKERAND MALE AND FEMALE SIGNARM CIRCLE HITT" +"ING WALL ARROW POINTING DIRECTLY BERKANAN BEORC BJARKAN BBLACK LENTICULAR BRA" +"CKETBLIC ADDRESS LOUDSPEAKERBUSINESS SUIT LEVITATINGCOMPATIBILITY IDEOGRAPH-C" +"ONSECUTIVE EQUALS SIGNSCULINE ORDINAL INDICATORDESCENDING MUSICAL NOTESDIAGON" +"AL CROSSHATCH FILLDOUBLE HORIZONTAL STROKEDOWNSCALING FACTOR KIIZHE PLUS A PL" +"US SU PLUS NAEASTERN PWO KAREN DIGIT EQUAL TO OR GREATER-THANEYES AND HAND OV" +"ER MOUTHFINGER AND THUMB CROSSEDFLATTENED RIGHT TRIANGLEFRACTION REDUCTION SI" +"GN-GLOTTAL STOP WITH STROKEGREATER-THAN OR EQUAL TOHEAVY BLACK HEART BULLETIG" +"ATURE OPEN ET ORNAMENTING FACE WITH OPEN MOUTHINTERSECTION WITH SERIFSISOSCEL" +"ES RIGHT TRIANGLELARGE TRIANGLE ARROWHEADLEFT DIAGONAL HALF BLACKLEFT ONE SIX" +"TEENTH BLOCKLINE HORIZONTAL ELLIPSISLY-RECYCLED PAPER SYMBOLMALL CIRCLE TO TH" +"E RIGHTMALL LEFT SQUARE BRACKETMTAVRULI CAPITAL LETTER ONE-HUNDRED-AND-SIXTIE" +"THORIZONTAL BAR WITH NOTCHOTTOM SHADED WHITE ARROWOTTOM-SHADED WHITE ARROWPER" +"SCRIPT ALEF MOKHASSASPOINTING DOWNWARDS ABOVEREVERSED NINE-LIKE BHALERIGHTWAR" +"DS THEN CURVING SINGLE-LINE NOT EQUAL TOSTROKE THROUGH DESCENDERSYLLABLE REPE" +"TITION MARKT BLACK RIGHTWARDS ARROWTAAALAA ALAYHI WA-SALLAMTEARDROP-SPOKED AS" +"TERISKTED INTERPOLATION MARKERUPRIGHT RECTANGULAR ZEROUPWARD POINTING TRIANGL" +"EVOICED LARYNGEAL SPIRANTWELVE POINTED BLACK STARWITH CANCELLATION STROKEWITH" +" UPWARDS ARROW ABOVEWO DOTS VERTICALLY ABOVEWO DOTS VERTICALLY BELOW CAKE WIT" +"H SWIRL DESIGN POINTING AT THE VIEWER ROTATED NINETY DEGREES WITH HALF-CIRCLE" +" BELOW-ALAA AALIHEE WA-SALLAMALEF MAKSURA FINAL FORMALGAMATION OR COPRODUCTAN" +"D WOMAN HOLDING HANDSANG DEPARTING TONE MARKARABIC LETTER TAH ABOVEARTY HORN " +"AND PARTY HATASCENDING MUSICAL NOTESATTACHING VERTICAL OMETAVOURING DELICIOUS" +" FOODAWWARA ALLAAHU MARQADAHBARBED RIGHTWARDS ARROWCIRCUMFLEX ACCENT ABOVECLU" +"STER-INITIAL LETTER CURRENT SYMBOL FORM TWODOT BELOW AND DOT ABOVEDOWNWARDS T" +"HEN CURVING ESS OUTLINED WHITE STARFACING SNAKE HEAD WITH GREEK SMALL LETTER " +"IOTAHANKED RIGHTWARDS ARROWHREE POINTED BLACK STARHT TRIFOLIATE SNOWFLAKEICAT" +"ION PROGRAM COMMANDIDE ARC CLOCKWISE ARROWIGHT-SHADED WHITE ARROWIKU CURVED V" +"ARIANT FORMININE ORDINAL INDICATORISTED RIGHTWARDS ARROWSIVE FINGERS SPREAD O" +"PENLEFT-SHADED WHITE ARROWLOWER ONE QUARTER BLOCKLSCHREIBER PAUSE SYMBOLMITIA" +"N CONJUGATE MATRIXORAH WITH NINE BRANCHESORIGINAL OF OR EQUAL TOORIZONTAL RUL" +"ER SEGMENTOVER RIGHTWARDS HARPOONOVERLAPPING LOGICAL ANDP WITH EXCLAMATION MA" +"RKPA OVER PA GAR OVER GARPUNCTUATION END OF TEXTRAISED OMISSION BRACKETREE VA" +"RIATION SELECTOR RETROFLEX HOOK AND BELTRIGHT DIAGONAL ELLIPSISRIGHT HORIZONT" +"AL SECANTRIGHT ONE QUARTER BLOCKRIGHT OPEN BOX OPERATORRIGHT-POINTING TRIANGL" +"ERTOISE SHELL BRACKETED SHAPE WITH A DOT INSIDESING DIAGONAL CROSSING SOLIDUS" +" BINARY RELATIONUBLE VERTICAL BAR BELOWUP SPREAD THUMB FORWARDUPPER ONE QUART" +"ER BLOCKUPWARDS THEN NORTH WESTWESTERN PWO KAREN TONE-WHITE FOUR POINTED CUSP" +"WIGGLY EXCLAMATION MARKWO-WAY LEFT WAY TRAFFICZANTINE MUSICAL SYMBOL OVER ST" +"AMPED ENVELOPE SYMBOL FOR LIGHTHOUSE WITH CIRCUMFLEX ABOVE WITH DECORATIVE CO" +"VER WITH SINGLE ZAPYATAYA WITH THREE DOTS ABOVE-ROTATED DIVISION SIGNACKSLANT" +"ED SOUTH ARROWARMENIAN ETERNITY SIGNBAR ABOVE INTERSECTIONCJK UNIFIED IDEOGRA" +"PH-CONSONANT MODIFIER BARCONSONANT SIGN MEDIAL CURLY BRACKET ORNAMENTDOMAIN A" +"NTIRESTRICTIONDOUBLE SOLIDUS OVERLAYDOUBLE VERTICAL STROKEDOUBLE-LINED HEAD M" +"ARKDOWN-POINTING TRIANGLEDOWNWARDS ZIGZAG ARROWDRESSED TO THE SUBJECTEAST-POI" +"NTING AIRPLANEGREATER-THAN DIAERESISHEXIFORM LONG ANUSVARAHORT HORIZONTAL STR" +"OKEHUNDRED TWENTY-EIGHTH I YFESIS TETARTIMORIONIGEL LONG-BRANCH-SOL SIN DEPAR" +"TING TONE MARKINDIRECT QUESTION MARKING HEAD IN SILHOUETTEINVERTED SMALL V AB" +"OVEINVERTED SMALL V BELOWKEEPING STILL MOUNTAINLATIN CAPITAL LETTER SLE BESID" +"E VERTICAL BARLEFT ONE QUARTER BLOCKLEFT OPEN BOX OPERATORLEFT TRIANGLE OPERA" +"TORLEFT-POINTING TRIANGLELONG HORIZONTAL STROKELOW PARAPHRASE BRACKETMNYAM YI" +"G GI MGO RGYANND RECORDING COPYRIGHTNOT INCLUDING THE POLEOVER LEFTWARDS HARP" +"OONOVER NU11 BUR OVER BUROVER SHIR BUR OVER BURPERSET OF NOR EQUAL TOPOINTING" +" UPWARDS BELOWPRECEDED BY APOSTROPHEPTIONALLY OTTAVA BASSAPUNCTUATION KUNDDAL" +"IYAQUESTION MARK ORNAMENTREASE FONT SIZE SYMBOLRECTILINEAR BLACK STARREE-CIRC" +"LE ALTERNATE IRIGHT-POINTING FLEURONROUND A POINT OPERATORRROW WITH ROUNDED H" +"EADSEMI-VOICED SOUND MARKSHORT RIGHTWARDS ARROWSHORT VERTICAL STROKESSYMPTOTI" +"CALLY EQUAL TOTRIPLE DASH HORIZONTALTRIPLE RIGHT TURNSTILETRIPLE VERTICAL STR" +"OKEUBSCRIPT SMALL LETTER UPPER ONE EIGHTH BLOCKUPPER RIGHT AND LOWER USTOMER " +"ACCOUNT NUMBERWASALLAM ISOLATED FORMWITH HORIZONTAL STROKEWITH JEEM INITIAL F" +"ORMWITH VOICED SOUND MARKYIAKENG PUACHUE HMONG AND SLANTED PARALLEL HUNDRED " +"TWELFTH REST WITH SHORT RIGHT LEG WITH VERTICAL STROKE-ROUND NOTEHEAD DOWN -S" +"HAPED BAG DELIMITERABOVE SHORT DOWN TACKACUTE AND HOOK SYMBOLAKIA TELOUS ICHI" +"MATOSALLING DIAGONAL SLASHAND LOW VERTICAL LINEAND VOWEL LENGTH MARKARD SHELL" +" FLOPPY DISKARKENING OF THE LIGHTARYSTIAN FIVE HUNDREDBESIDE RIGHT TRIANGLEBO" +"TTOM AND LOWER LEFTBOTTOM U-SHAPED ARROWBUT NOT EQUIVALENT TOCROSSE STICK AND" +" BALLCRUCIFORM NUMBER FOURCTOR OR CROSS PRODUCTDELIMITER TSHEG BSTARDIGRAMMOS" +" EX DODEKATADOUBLE LEFT TURNSTILEDOWN HORIZONTAL HEAVYDOWN HORIZONTAL LIGHTDO" +"WNWARDS ARROW ABOVEEFT HORIZONTAL SECANTEIGHT SPOKED ASTERISKELATIONAL COMPOS" +"ITIONEQUAL TO OR LESS-THANER RIGHT CORNER ANGLEETA WITH PALATAL HOOKFINAL CON" +"SONANT SIGN FLATTENED PARENTHESISGRAMMOS OKTO DODEKATAGRUENT WITH DOT ABOVEHA" +"LF TRIANGULAR COLONHAND INTERIOR PRODUCTHOCKEY STICK AND PUCKHORIZONTAL REFLE" +"CTIONHORIZONTAL TABULATIONHOUSAND MILLIONS SIGNINTERSECTING LOGICAL INTERSECT" +"ION OPERATORINVERTED BRIDGE BELOWINVERTED GLOTTAL STOPJUSTIFIED LOWER HALF JU" +"STIFIED RIGHT HALF JUSTIFIED UPPER HALF LATTENED OPEN A ABOVELESS-THAN OR EQU" +"AL TOLETTER SMALL CAPITAL MALE WITH STROKE SIGNMIDDLE RING LITTLE ONMORPHOLOG" +"ICAL DIVIDERND TELEPHONE RECEIVEROCAL NOTATION SYMBOL-OHAMMAD ISOLATED FORMOP" +" SHADED WHITE ARROWOPPOSING AN PLUS NAGAPAP PLUS PAP PLUS LU3RATING SYSTEM CO" +"MMANDRELICT HOUSE BUILDINGREVERSED FEATHER MARKRIGHT ARROWHEAD ABOVERIGHT QUA" +"RTER SECTIONRISING DIAGONAL SLASHSH AMPERSAND ORNAMENTSHORT LEFTWARDS ARROWSI" +"DE TO SIDE SCISSORSTEEN POINTED ASTERISKTHICK LETTER SELECTORTILDE OPERATOR A" +"BOVE TOUCHING INSIDE MOUTHTRIANGULAR HALF BLOCKUPPER QUARTER SECTIONVERTICAL " +"LINE OVERLAYVERY HEAVY BARB ARROWVOICED ITERATION MARKWITH INVERTED V ABOVEWO" +"-CIRCLE ALTERNATE IWO-CIRCLE NUKTA ABOVEXTRA SHORT VOWEL MARKYIG MGO TSHEG SH" +"AD MA ABOVE LEFT TRIANGLE AND DIAGONAL STROKE BEGIN LOGOGRAM MARK OVER LAGAR " +"GUNU SHE OVER TUR ZA OVER ZA WITH DEPENDENT LOBE WITH HORIZONTAL BAR WITH INV" +"ERTED INPUT79 OVER LAK-079 GUNUA- SHOG GI MGO RGYANAISED UPPER LEFT ARCAND NO" +"RTH EAST ARROWAND NORTH WEST ARROWAND SOUTH EAST ARROWAND SOUTH WEST ARROWANG" +"E ANTIRESTRICTIONARXIS KAI FTHORA VOUBETWEEN PALM FACINGSBOTTOM HALF BISECTED" +"BSET OF NOR EQUAL TOCENTRE VERTICAL LINECHEMICAL SYMBOL FOR CONSONANT SIGN HA" +"ARUCRESCENT MOON SYMBOLCURRENCY SYMBOL RIELCURVED ANGLE BRACKETDDASA ALLAAHU " +"SIRRAHDOTLESS HEAD OF KHAHDOUBLE ANGLE BRACKETDOUBLE DOT TONE MARKDOWN ARROWH" +"EAD BELOWE CONSONANT MODIFIERE POINTED WHITE STAREMESTVENNY ZADERZHKAENARMONI" +"OS ANTIFONIAEVERSED ROTATED RANAFINAL CONSONANT MARKFIVE SPOKED ASTERISKFORMS" +" LIGHT VERTICALFOUR RAISED KNUCKLESGRA GCAN -CHAR RTAGSHALF CIRCLE WITH DOTHA" +"R2 TIMES GAL PLUS HIGH RATHA OR LOW PAHIGH TONE APOSTROPHEHREE-DOT NUKTA ABOV" +"EIBLICAL END OF VERSEIMAGE OF OR EQUAL TOINDEX RING LITTLE ONINING OBLIQUE ST" +"ROKEINSIDE MOUTH RELAXEDINVERSE WHITE CIRCLEINVERTED CANDRABINDUIRCLES HITTIN" +"G WALL JUDEO-SPANISH VARIKAJUSTIFIED LEFT HALF KHAMTI REDUPLICATIONL FUNCTION" +"AL SYMBOL LAILING ROBOT FRAME-LATALIZED HOOK BELOWLE WITH POPPING CORKLEFT AN" +"D LOWER RIGHTLEFT-TO-RIGHT SECANTMID-HEIGHT LEFT HOOKMULTIPLE PUNCTUATIONNIS " +"RACQUET AND BALLONCAVE-SIDED DIAMONDONE MARK SGAW KAREN ONOMICAL SYMBOL FOR O" +"TLESS J WITH STROKEOVER LEFTWARDS ARROWOWER QUARTER SECTIONPLUS GISH TIMES TA" +"K4POTABLE WATER SYMBOLREAN STANDARD SYMBOLREVERSED ONE HUNDREDRIGHT ANGLE WIT" +"H DOTRIGHT QUADRANT BLACKRIGHT U-SHAPED ARROWRRAMA ALLAAHU WAJHAHRUMAI PALAUN" +"G TONE-5SCRIPTION CHARACTER SEPARATOR KEY SYMBOLSEPARATOR MIDDLE DOTSIDEWAYS " +"NOON GHUNNASTAR WITH MIDDLE DOTTHROUGH SMALL CIRCLETISTRY SYMBOL LIGHT TRANSP" +"OSITION MARKERUBHAANAHU WA TAAALAAUP-POINTING AIRPLANEUP-POINTING TRIANGLEVAL" +" WITH OVAL INSIDEWARE-FUNCTION SYMBOLWET CULTIVATION SIGNWITH FOUR DOTS ABOVE" +"WITH RAISED LEFT DOTWITH SOROCHYA NOZHKAWORD REPETITION MARKYIG MGO PHUR SHAD" +" MAYRENAIC TWO DRACHMAS AND PROSGEGRAMMENI AND RETROFLEX HOOK FLUTTERING IN W" +"IND IN A RECTANGLE BOX KASKAL U GUNU DISH LOVE YOU HAND SIGN WITH STRIKETHROU" +"GH WITH VERTICAL TAILA END LOGOGRAM MARKALTERNATE LAKH MARKANS-SERIF CAPITAL " +"LANSPOSITION BRACKETARABIC FORM SHAPINGARENTHESIS NOTEHEADARTIAL DIFFERENTIAL" +"ASTEROID PROSERPINAATED TELLER MACHINEBETWEEN MIDDLE RINGBINING ALEF OVERLAYC" +" DIGRAPH WITH CURLCIRCLED SANS-SERIF CIRCLED WHITE ARROWD CIRCUMFLEX ACCENTDA" +"2 TIMES SHE PLUS DENOMINATOR SIXTEENDOWN AND HORIZONTALDOWN POINTING INDEXEFT" +" QUARTER SECTIONET WITH WHITE CROSSEVEN POWERS OF FOURFIVE FINGERS SPREADFLOO" +"RPLANE TWISTINGFT-POINTING FLEURONGAPPED CIRCLE ARROWGIBBOUS MOON SYMBOLHAND " +"COVERING MOUTHHEAD-SHAPED POINTERHORT STROKE OVERLAYHURISAZ THURS THORNIGATUR" +"E AYIN-DALETHILDING CONSTRUCTIONIMIDIA SEXTULA SIGNIN CHEN SPUNGS SHADING SHI" +"RT WITH SASHINGLE DOT TONE MARKINSIDE CIRCLE BELOWISPUTED END OF AYAHITED LIA" +"BILITY SIGNKULL AND CROSSBONESLEADING MCHAN RTAGSLEFT POINTING INDEXLEFT U-SH" +"APED ARROWLF MADDA OVER MADDALTERNATE BARGIYA BALUB-SPOKED ASTERISKMOVES AGAI" +"NST CHEEKMSHELL MOBILE PHONENAXIAN FIVE HUNDREDNDRED POINTS SYMBOLNE HUNDRED " +"TWENTY PNETWORKED COMPUTERSNOGRAPHIC FULL STOPNORTH ARROW WITH HOOP SEMICIRCL" +"E ARROWOTATED ARDHAVISARGAOVER E NUN OVER NUNOW-9 QUOTATION MARKPARAGRAPH SEP" +"ARATORPREFIXED NASAL SIGNQUADRUPLE CRESCENTSQUESTION MARK ABOVERAILING MCHAN " +"RTAGSRATUM SUPER STRATUMREE-QUARTER CIRCLE RIGHT MIDDLE STROKERIGHT TO LOWER " +"LEFTRROW NO-BREAK SPACERY CULTIVATION SIGNSEQUENCE INTRODUCERSEVEN EIGHTHS BL" +"OCKSH PLUS HU PLUS ASHSLANTED NORTH ARROWSTRAIGHT THUMB BENTSTRATIAN FIFTY MN" +"ASSYMBOL FOR BEGINNERTART OF RUB EL HIZBTHANG LONG ANUSVARATIGHTLY-CLOSED EYE" +"STO LOWER RIGHT FILLTRANNO MALO POVYSHETURNED PADA PISELEHTURNED SECTION MARK" +"TWENTY-FIVE DEGREESUBLE DOT WITHIN DOTUP HORIZONTAL HEAVYUP HORIZONTAL LIGHTU" +"P-POINTING CHEVRONURRENCY SYMBOL BAHTVARIANT FORM ILIMMUVARIANT WITH SQUAREVA" +"RIATION INDICATORVASTNESS OR WASTINGVERSAL INTERSECTIONVERTICAL TABULATIONWIT" +"H YEH FINAL FORMWOMEN HOLDING HANDS AND NO DOTS ABOVE AND SMASH PRODUCT AND Y" +"POGEGRAMMENI FOR SIMALUNGUN SA NOT LITTER SYMBOL OVER INVERTED SHU SPREAD THU" +"MB SIDE THUMB INDEX THUMB WITH CIRCLE ABOVE WITH CIRCLE BELOW WITH CROSSED-TA" +"IL WITH FLOWING SAND WITH KAVYKA ABOVEAA ALLAAHU TAAALAAABBREVIATION MARK ALZ" +"EDO BREATH MARKAND LOW RIGHT RINGARROW SHAFT WIDTH ASTED SWEET POTATOASTROLOG" +"ICAL SIGN ATERRESTRIAL ALIENATIN SMALL LETTER AVY DOUBLE BARLINEBAARAKA WA-TA" +"AALAABOTTOM RIGHT KASRACANTILLATION SIGN CONTINUING OVERLAPCOPPER ANTIMONIATE" +"CTLY EQUIVALENT TOCUP WITHOUT HANDLEDOUBLE PUNCTUATIONDOWN-OUTPUT SYMBOLEAST " +"POINTING LEAFENTERING TONE MARKENTY-TWO POINT TWOEPIGRAPHIC LETTER ERTICAL BA" +"R VIRAMAEVENTEEN FULL STOPEVERSED CHELYUSTKAFIVE EIGHTHS BLOCKFORKED PARAGRAP" +"HOSFORTY-FIVE DEGREESGATIVE ACKNOWLEDGEGISH CROSSING GISHHAIS LUS NTOG NTOGHE" +"AVY WHITE SQUAREHILOSOPHERS SULFURHOLDING BACK TEARSHORIZONTALLY BELOWHOUSAND" +"S SEPARATORHUNDREDS UNIT MARKIGATURE ZAYIN-YODHIGSAW PUZZLE PIECEIN POSSESSIO" +"N SIGNINDEPENDENT VOWEL IRROR HORIZONTALLYITAN SMALL SCRIPT IX SPOKED ASTERIS" +"KJEEM ISOLATED FORMKANTAJA NAASIKYAYAKBAR ISOLATED FORMKOREAN CHARACTER OLEFT" +" MIDDLE STROKELEFT-STEM TONE BARLOSED CIRCLE ARROWLOWER MIDDLE RIGHTMATHEMATI" +"CAL SPACEND UPPER RIGHT ARCNINETEEN FULL STOPNISH VERSE DIVIDERNORMAL SUBGROU" +"P OFNYET THYOOM TA-ROLNYOOGA NAAKSIKYAYAORK ON THE DECAYEDOTLESS DALATH RISHO" +"U ALAYHE WASALLAMOUCHTONE TELEPHONEOW TONE APOSTROPHEPACING CANDRABINDUPERFIX" +"ED LETTER RAPUNCTUATION BINDU QUARTER NOTE STEM QUINDICESIMA BASSAREDUPLICATI" +"ON MARKRIST CIRCLE FRONT RYUKOVAYA SVETLAYAS INSIDE AND ABOVES PRESSED TOGETH" +"ERSEPTUPLE CRESCENTSSET OVER BUILDINGSSHAN REDUPLICATIONSHING SWEAT SYMBOLSIN" +"GLE PUNCTUATIONSMALL CIRCLE ABOVESOUL ISOLATED FORMSYMMETRIC SWAPPINGTESIAN E" +"QUALS SIGNTILTING FROM WAISTTO LOWER LEFT FILLTOP U-SHAPED ARROWTRIANGULAR FE" +"RMATATROFLEX HOOK BELOWTYPE A ELECTRONICSU-SHAPED ORNAMENTSUM WITH DRUMSTICKS" +"UP ARROWHEAD BELOWUPPER MIDDLE RIGHTUTLINED BLACK STARVARIANT FORM LIMMUVERY " +"SMALL DIAMONDWEST POINTING LEAFWHITE VERTICAL BARWITH JUSTIFICATIONWITH STROK" +"E SYMBOLYLLABLE LENGTHENER ALTERNATION MARK AND PALATAL HOOK GRAVEYARD SYMBOL" +" LAGAB TIMES ASH2 LAGAR OVER LAGAR OVER ZU PLUS SAR PLUS SHA3 PLUS A TO BLACK" +" DIAMOND WITH BULLET NOSE WITH SOUND WAVES WITH TILDE ABOVE-GAAHLAA TTUDDAAG0" +" WHEELED CHARIOTA PLUS HA PLUS DAABBREVIATION SIGNAEUM ONE PLETHRONALTERNATE " +"NUMBER AMAT BARAKAATUHUMAMPHYLIAN DIGAMMAAND BLACK SQUARESAPLI DYO DODEKATAAS" +"ELINE ROUND DOTATHERING TOGETHERAUKAZ LAGU LOGR LBE WITH MERIDIANSBERBER ACAD" +"EMY YABOTTOM HALF BLACKBRACKET EXTENSIONBRIGHTNESS SYMBOLBUT RELIEVED FACECAL" +" SYMBOL BOTTOMCANCELLATION MARKCANDRABINDU ABOVECIRCLES WITH DOTSCLOSED LITTL" +"E YUSCOMBINING NUMBER CONSONANT SIGN PACONTINUATION SIGNCONTOURED OUTLINECROS" +"S PUNCTUATIONCTION APPLICATIONDELPHIC FIVE MNASDENTAL PERCUSSIVEEAR SCREEN SY" +"MBOLEMICOLON UNDERBARFACING BABY CHICKFINGER-POST ARROWFLICK ALTERNATINGFRACT" +"ION ONE HALFFROM SMALL CIRCLEGENERIC MATERIALSGREATER-THAN NOR GREATER-THAN S" +"IGNHAH ISOLATED FORMHEART-SHAPED EYESHIRTEEN FULL STOPHORIZONTAL DOUBLEHORIZO" +"NTAL SINGLEIASTRE MARK ABOVEICTED LEFT ENTRY-IDEOGRAPHIC COMMAIGHTEEN FULL ST" +"OPINEAR ANNOTATION ING POLE AND FISHINITIAL LETTER RAINVERTED MCHU CANITE PAR" +"T INTEGRALKE BOTTLE AND CUPKHAH INITIAL FORMLAGOLITIC LETTER LAH ISOLATED FOR" +"MLAPPING LESS-THANLD PERMIC LETTER LHOUETTE OF JAPANLIAN HIEROGLYPH ALLED SQU" +"ARE BELOWMALL RED TRIANGLEMALL WHITE CIRCLEMANENT PAPER SIGNMEDIUM BARB ARROW" +"MEDIUM SHADE FORMMEEM INITIAL FORMMILITARY AIRPLANENASALIZATION MARKNAUDIZ NY" +"D NAUD NND UPPER LEFT ARCNE EYEBROW RAISEDNEGATIVE CIRCLED NFORMATION SOURCEN" +"G STROKE OVERLAYONE EIGHTH BLOCK-OP AND UPPER LEFTOPEN-HEADED ARROWOURTEEN FU" +"LL STOPOWER NUMERAL SIGNPIGTAIL AT BOTTOMPINWHEEL ASTERISKPRECEDING SOLIDUSPR" +"IZNAK MODIFIER PUNCTUATION SIGN QUAT REVERSED ESHREATIONAL VEHICLERIATION SEL" +"ECTOR-RIGHT HALF CIRCLERYBLION BASE SIGNS REVOLVING LIGHTSERVER EYE SYMBOLSIG" +"N O WITH CROSSSQUARED TIMES KURSTRAIGHT MOVEMENTTAN ISOLATED FORMTARTING FROM" +" SIGNTEN THOUSAND SIGNTERSYLLABIC TSHEGTHREE SOUND WAVESTIAL ARTS UNIFORMTONA" +"L RANGE MARK TOP HALF BISECTEDTRIPLE DASH ARROWULAR MEDIUM SHADEUP AND HORIZO" +"NTALUP POINTING INDEXURNED COMMA ABOVEURNED DAMMA BELOWVARIANT FORM ASH9VARIA" +"NT FORM IMINVARIANT FORM USSUVEE WITH UNDERBARVERAGE WITH SLASHVOCALIZATION M" +"ARKVRE TOURNOIS SIGNWHITE PARENTHESISWHITE SHOGI PIECEWITH DOUBLE SLASHWITH N" +"OT EQUAL TOWO VERTICAL DOTS Y ON BLACK SQUAREYEH ISOLATED FORMYPTIAN HIEROGLY" +"PH AND HEAVY RIGHT AND LIGHT RIGHT CAPPED MOUNTAIN INSERTION POINT LIGHT MOON" +" ARTA OR THE IMAGE OF PLUS KAK PLUS A SMALL ROTATIONS TIMES DISH TENU TIMES G" +"AN2 TENU WITH BUNNY EARS WITH DOT INSIDE WITH HEADSTROKEADIAN SYLLABICS AFFRI" +"CATION MARKANABAZAR SQUARE AND A HALF SHARPAND VERTICAL BARARENTHESES ABOVEB2" +" TENU PLUS TABBOLD GREEK CROSSBOTTOM HALF RINGCANDRA ANUNASIKACASIAN ALBANIAN" +" CH WITH UMBRELLACKLE FILL FRAME-CLOSED TENTACLESCOMPRESSED ARROWCONSONANT JO" +"INERCORNER DOWNWARDSCORNER LEFTWARDSCREAMING IN FEARDEWAYS U BRACKETDITORIAL " +"CORONISDOTTED CRESCENTSDOUBLE CRESCENTSDOUBLE DOT ABOVEDOUBLE HEAD MARKDOUBLE" +" TURNSTILEDOUBLE VERTICALSDOUBLE ZAPYATAYADOWN RIGHT BARB DVUMYA ZAPYATYMIE P" +"LUS GAN2 TENUECIMAL SEPARATOREFORE COMPLETIONEN MILLIONS SIGNEND OF TEXT MARK" +"ENTRE WHITE STARENUMERATION SIGNEPSILON UNDERBARERCURY SUBLIMATEEVERSED VISAR" +"GA EVERY OTHER TIMEFALLING DIAGONALFFERENCE BETWEENFLOORPLANE SPACEFORWARD-FA" +"CING RHEH INITIAL FORMHIGH SPACING DOTHMATULLAH ALAYHEHOLDING TOGETHERHYPHENA" +"TION MARKIDED GREEK CROSSIFTEEN FULL STOPIGHTH NOTE STEM IMENSIONAL ANGLEIN D" +"OUBLE CIRCLEINDEPENDENT SHININDEX THUMB SIDEINES CONVERGING IPPER-MOUTH FACEI" +"RCLE X NOTEHEADISTOS DISC SIGN K PERMITTED HERELD ASSYRIAN ONE LEFT ARROW ABO" +"VELEFT HALF CIRCLELIGHT AND RIGHT LIGHT BARB ARROWLLER COASTER CARLLOW PAN OF" +" FOODLOWER OVER UPPERLTERNATE HASANTAMAGNIFYING GLASSMESTVENNY KLYUCHMIDDLE A" +"ND BELOWMIDDLE AND RIGHTNAL DIGIT SHAPESNGQIN SIGN SLOW NINE WITH STROKENION " +"WITH SERIFSNTAIGANA LETTER O-MINOAN SIGN CMOLD TAMIL VIRAMAOLD WHITE CIRCLEON" +" TOP OF BRIDGEORIZONTAL JOINERPEN CENTRE CROSSPLACEHOLDER MARKPLE MEASURE RES" +"TPOSTPOSITION MENPRECEDING SUBSETPRECHGESANG STEMQ WITH HOOK TAILR PLUS GAN2 " +"TENURAIDO RAD REID RRAYS AND DOTTED RECORD SEPARATORREPETITION MARK-RESH-AYIN" +"-DALETHRESSIONLESS FACERIGHT DOWN BARB RIGHT HALF BELOWRIGHT HALF BLACKRISING" +" TONE MARKRIZONTAL ELLIPSESANS-SERIF ARROWSERIFS AT BOTTOMSHU2 PLUS KASKALSIG" +"N RISING TONESITION INDICATORSLANTED EQUAL TOSMALL CAPITAL ELSMALL NOON ABOVE" +"STERISK OPERATORSTICKING OUT FARSTRAIGHT STRETCHSTRING FRETBOARDSTUCK-OUT TON" +"GUETAKANA-HIRAGANA TRIPLE CRESCENTSUBJOINED LETTER UDLY CRYING FACEULDERED OP" +"EN BOXUMBER SIGN ABOVEUP MIDDLE HINGEDUP-OUTPUT SYMBOLUPERSCRIPT ALAPHUPPER O" +"VER LOWERVARIANT FORM ESHVERY HEAVY SHAFTVIEWING CEREMONYVOWEL LENGTHENERWALL" +"ED ENCLOSUREWAVY HAMZA BELOWWITH CENTRED DOTWITH HEARING AIDWITH LEFT UPTURNW" +"ITH MIDDLE RINGYATHOS BASE SIGNYIR MKPARAQ MEUN ALTERNATE FORM AND BOTTOM END" +" AND DOTTED ARC CLOUD AND RAIN CORNER BRACKET DEYTEROU ICHOU NEPOSTOYANNAYA O" +"F SQUARE ROOT OPERATOR WITH OVER MOUNTAINS OVER SIG4 SHU2 PARESTIGMENON PLU" +"S HI PLUS A THROUGH CIRCLE THUMB STRAIGHT TIMES IGI GUNU TOUCHING INDEX WITH " +"DIAERESIS WITH LONG STEM-CARRIER LETTER-NO-EVIL MONKEY-PIECE SWIMSUIT2 CHARIO" +"T FRAMEACHES THE LIMITAI LAING DIGIT ALAYHE ASSALLAMALAYHI WA-AALIHALIF LENGT" +"HENERALMOST EQUAL TOAMARITAN SOURCEAMOND NOTEHEAD AMOUNT OF CHECKAND PARALLEL" +" TOATA LINK ESCAPEATINATE MYSLITEBAGS UNDER EYESBAR ABOVE UNIONBELGTHOR SYMBO" +"LBELOW LONG DASHBENT OVER INDEXBINDING BRACKETBLACK TRIANGLESBLOCK DIAGONAL B" +"REAKING HYPHENBROWS STRAIGHT CAPITAL LETTERSCIRCUIT-OUTPUT CKET CALCULATORCLO" +"SED BY CURVECORNER WITH DOTDESCENDING TONEDI ALLAHOU ANHUDIALYTIKA TONOSDIGA " +"AELA-PILLADOING CARTWHEELDOUBLE TRIANGLEDOWN SEQUENTIALDOWNWARDS TRENDE ISOLA" +"TED FORME MUSICAL NOTESE OVER INFINITYEFT REPEAT SIGNEIGHT DISH TENUERICAN FO" +"OTBALLESIDE LESS-THANESISTOR SEGMENTESSARON CHRONONETIC VERSE SIGNEXPONENT SY" +"MBOLFIVE-LIKE BHALEFORWARD TILTINGFOUR DOTS BELOWFOUR DOTS WITH FOUR ENCLOSUR" +"ESFOUR TICK MARKSFRACTION DIGIT FTER COMPLETIONGEMINATION MARKGGLY LINE BELOW" +"GHT REPEAT SIGNGROUP SEPARATORHAKING PARALLELHALF FILL SPACEHALF VERTEX OF HE" +"H MEDIAL FORMHOOKED INDEX UPHORIZONTAL DASHHORIZONTAL FILLHOUSAND STATERSHREE" +" DOTS BELOWHREE HALF BEATSIAMOND UNDERBARIDING ENCLOSUREIGN PALI VIRAMAIMISEO" +"S CHRONOUIMPERFECTA RESTING SYMBOL FOR INGLE HEAD MARKINVERTED CARIK INVERTED" +" LAZY SINVERTED STROKEIRCUMFLEX BELOWITH FINGERNAILSIZED WHEELCHAIRKISIM5 TIM" +"ES BIKTOVIK NUMERAL L DIGRAPH WITH LATION FUNCTIONLD TAMIL SHORT LEFT DOWN BA" +"RB LEFT HALF BELOWLEFT HALF BLACKLEFT HAND INDEXLETTER CAPITAL LEVEL TONE MAR" +"KLEVEN FULL STOPLIGHT AND LEFT LMOST EQUAL TO LONG HOOK BELOWLONG VOWEL SIGNL" +"OOK OF TRIUMPHMALAKON CHROMA MARRYING MAIDENMEEM FINAL FORMMIDDLE DIAGONALMUR" +"DA MAHAPRANAN-ARY SUMMATIONNA DOUBLE HELIXNASALIZED TONE-ND OF PARAGRAPHNJOIN" +"ING MACRONNO GOOD GESTURENOON FINAL FORMNOT APPROXIMATENOTCH AT BOTTOMNVERTED" +" UBADAMAODIFIER DAMAGEDODO SOFT HYPHENOGOGRAM KHAMTI OLIDUS OPERATORON TOP OF" +" MODEMOND PLACE MEDALONJOINED HINGEDONTOUR INTEGRALORIZONTAL COLONORT EQUALS " +"SIGNOUBLE BACKSLASHOUR WITH STROKEOW-FALLING TONEOWER HALF BLACKPEN SQUARED D" +"OTPENSION RAILWAYPERTHO PEORTH PPLUS SIGN BELOWPRISHTHAMATRA EPUT SYMBOL FOR " +"QUADRUPLE ARROWQUADRUPLE DASH R WITH FISHHOOKREAMY EYEBROWS RECEPTIVE EARTHRE" +"CITATIVE MARKREVERSE SOLIDUSREVERSED OPEN ERIGHT HALF RINGRIGHT RERENGGANRIGH" +"TWARDS AND RIGHTWARDS TICKRMAN PENNY SIGNS ELEVATUS MARKS IN SILHOUETTESHITA " +"PLUS GISHSHORT OVER LONGSIXTEENTH NOTESSSICAL BUILDINGST QUARTER MOONST SYRIA" +"C CROSSSTANDING KNIGHTSTANDING PERSONSTERESIS SYMBOLSTROKE NOT SIGNTAI LAING " +"TONE-THREE DISH TENUTHROWING A KISSTILDE DIAERESISTIP ON THE LEFTTOP RIGHT FA" +"THATRIANGULAR MARKTVIMADUR SYMBOLTWO WITH STROKEU PLUS U PLUS UUBLE RING BELO" +"WUGMENTATION DOTULTIPLICATION XUMAI PALAUNG FAUR POINTED STARUSTER NOTEHEAD V" +"E POINTED STARVERTICAL SECANTVOWEL SEPARATORVOWEL SHORTENERWALLPLANE SPACEWIT" +"H DOWN ARROWWITH RAIN DROPSWO THIRDS BLOCKXTEEN FULL STOPYNCHRONOUS IDLEZ WIT" +"H CROSSBARZAIN FINAL FORMZERO WITH SLASH AND DIAERESIS AND SMALL TAH CROSSING" +" ESH2 FINAL BARLINE HASER FOR VAV WITH BACK YER WITH LONG LEG-CURRENCY SIGN-D" +"IVISION SIGN-THETA DIGRAPH1 OVER LAK-081AE DIRHAM SIGNAFETY SCISSORSALF TREE " +"TRUNKALTER PAHLAVI AMNUC PII KUUHAND COLD SWEATANGLE OPENING ARCH BUTTERFLYAR" +"OUND-PROFILEAU LENGTH MARKBAG MEMBERSHIPBHATTIPROLU AABLADE SCISSORSCENTURIAL" +" SIGNCEPTER OF JOVECERTAINTY SIGNCOLON OPERATORCRAB STEPPING CRIFICIAL WINED-" +"UP NEWSPAPERDASIA PNEUMATADEYTEROS ICHOSDIAGONAL MOUTHDIAGONAL PATH DING CHAR" +"ACTERDIO MICROPHONEDIRECTION FLIPDOES NOT EXISTDOUBLE-STRUCK DUN3 GUNU GUNUED" +" SYMBOL FOR EMIVOWEL SIGN END OF SECTIONENDED MULTIMAPEPENTHETIC YUTERIAL ARA" +"MAIC ERIC INDICATORERTICAL JOINEREVEN DISH TENUEXCLAMATION OHEXTENDED BHALEFA" +"THATAN ABOVEFFED FLATBREADFFICE BUILDINGFINAL ANUSVARAFORWARD INDEX GERED TRE" +"MOLO-GHT WITH STARSGUNU TIMES ASHGYPTOLOGICAL AHESIVE BANDAGEHIRD-STAGE HLIHR" +"EE-LEGGED TEIGHTWARDS VANEIKHAYA PUTNAYAING HANDS SIGNINOLOGICAL DOTINSERTION" +" SIGNINVERTED BIRGAINVERTED DAMMAIRCULAR VIRAMAISED ROUND DOTISSION TICKETSIT" +"A PLUS GISH IVE KEY SYMBOLIVE OBOLS SIGNIWAZ TIR TYR TIX WITH STROKEJOINED SQ" +"UARESLACE OF SAJDAHLEFTWARDS AND LEFTWARDS TICKLESS-THAN NOR LETTER OVERLAPLE" +"VEN TWELFTHSLIGHTLY SMALL LITTLE SECTIONLOTUS POSITIONLOWER DIAGONALLOWER TER" +"MINALMEDIUM DIAMONDMENSION ORIGINMID-LEVEL TONEMOTHETIC ABOVEMRACHNOTIKHAYANA" +"MENT STROKE-NINE DISH TENUNORTH ARABIAN NYI ZLA NAA DAOBLIQUE HYPHENOLD RESOL" +"UTIONONE ASH CURVEDONE SOUND WAVEOOTNOTE MARKEROPEN TENTACLESOPPOSING PIRIGOR" +"ANGE DIAMONDORD SEPARATOR OSITION SYMBOLOT TILDE ABOVEOTHERS CIRCLEDOUR OBOLS" +" SIGNOUSING THUNDEROVER GUD LUGALPAO KAREN TONEPARTMENT STOREPEN MARK BELOWPL" +"E WITH HEARTPLETE INFINITYPLITTING APARTPPED MIDDLE UPPROTECTED AREAQUINARIUS" +" SIGNRD PLACE MEDALREATIVE HEAVENREE-LINE STAFFREH FINAL FORMREVERSED-SCHWARI" +"GHT CROSSBARRING MEGAPHONERMENIAN SMALL ROSS ON SHIELDSECOND SUBUNITSEL LOCOM" +"OTIVESEPARATOR MARKSHAN MEDIAL WASHESHIG TIMES SHRII PUSHPIKASIDE-DOWN FACESM" +"ALL LETTER DSMALL LETTER JSMOKING SYMBOLSPEECH BUBBLESSQUIGGLE ARROWSTRONG IS" +"OLATETELPIECE CLOCKTERMINAL MARK-TETARTOS ICHOSTHAKA ANUDATTATHALAN ETHEL OTH" +"ER CHRISTMASTHOUSANDS MARKTHOUSANDS SIGNTHREE POINTED TIMES OPERATORTIMES SHU" +" TENUTOP HALF BLACKTRADITIONAL ERTRANSMIT STATETRIANGLE CARETTRIANGLE WITH TU" +"RKIC LETTER TWELFTH CIRCLETWO ASH CURVEDTWO DOT LEADERTWO ENCLOSURESTWO WHITE" +" DOTSUAL WHEELCHAIRUBHAYATO MUKHAUND MARK ABOVEUNDER RELATIONUNION OPERATORUN" +"IT SEPARATORUP RIGHT BARB UPPED INDEX UPUPPER TERMINALUSPENSION MARKVENIENCE " +"STOREVERTICAL ABOVEVERTICAL COLONVERTICAL HEAVYVERTICAL LIGHTVONIC ASTERISKVR" +"ON SNOWFLAKEWITH DOT BELOWWITH FATHATAN WITH LEFT HOOKWORD SEPARATORXO EKFONI" +"TIKONYOUTHFUL FOLLYZAH WITH MEEM ZAKAYA LANTERN AND SKI BOOT AND YEN SIGN B B" +"AR SYMBOL BAT AND BALL BZHI MIG CAN CROSSING KA2 DIMINUTION-1 DIRECTIONAL HE" +"ADED ARROW OF THE HORNS OPPOSING KUR TIMES KASKAL WITH INK PEN WITH JEGOGAN W" +"ITH OVERBAR WITH SMALL P WITH TEE TOP WITHOUT SNOW-ESASA DOTTED-OFF CALENDAR-" +"OR-PLUS SIGN-PER-EM SPACEABLATURE CLEFACCOMMODATIONAL CHARACTER-ALL LOST SIGN" +"AMUHU ALAYNAAAN RUPEE SIGNANI RIAL SIGNANNED LEATHERANTIC FIGURE APPED PRESEN" +"TAR WITH QUILLARCHAIC KOPPAARGOSYNTHETONARLAUG SYMBOLARRED TRIDENTARROW OVERL" +"AYAUDATE CHRIVIAWELLEMET YAZBACKSLASH BARBALL AND HOOPBASAN LETTER BEHIND BRI" +"DGEBOHAIRIC KHEIBOTTOM CORNERBOWING DEEPLYBY DEFINITIONCENTRED ABOVECHRYSANTH" +"EMUMCIRCLE INSIDECITATION MARKCRIPTION TAKECRIPTIONAL PACROSSING GABACROSSING" +" GAN2CROSSING MUSHCULATED LORRYDI RIYAL SIGNDIAERESIZED UDIC MARK SIGNDOTTED " +"ZLAMA DOUBLE HYPHENDOUBLE MUCAADDOUBLE STROKEDVOECHELNAYA EAVENLY EARTHED PAP" +"ERCLIPSEDIC ANUSVARAEELING PERSONEHU FEOH FE FEMPHATIC TONEER BOARD FILLERTIO" +"N SYMBOLEUROPE-AFRICAEVERSED DAMMAFICATION CARDFINAL LETTER FINAL SEMKATHFIXE" +"D-FORM RAFOREMENTIONEDFROWNING FACEFT ARROWHEAD FULL SURROUNDGAR FRACTION GAW" +" KAREN SHAGIFT ENVELOPEGTER TSHEG MAGYA GRAM SHADH-TYPE SYMBOLHAKASSIAN CHEHA" +"M DIGIT ONEHAZAQ MUDGASHHERICAL ANGLEHIEROGLYPHIC HINESE TONE YHREE TWELFTHSI" +" LENGTH MARKI WITH STROKEIDE LOST SIGNIFI ROHINGYA IGHT TWELFTHSILABIAL CLICK" +"ILE SEPARATORIMAGE BRACKETINTEREST SIGNINVERTED FORKINVERTED TURNIOT SYLLABLE" +" IRCLED INDEX ISH LIRA SIGNITING THROUGHIVE DISH TENUIVE POINT ONEIVE SLOW SI" +"GNJES SU NGA ROJJAL ALLAAHU K WORK SYMBOLKAPYEOUNPIEUPL-TYPE SYMBOLLATERAL CL" +"ICKLEFT CROSSBARLEGETOS ICHOSLISION SYMBOLLOCATION SIGNLOCK WITH KEYLOOPED VI" +"RAMALOSING SPIRALLTERNATE DDDALVE FULL STOPLVEOLAR CLICKMAILBOX WITH MALL LET" +"TER ZMALO POVYSHE MARKS CHAPTERMASORA CIRCLEMATU ALLAAHI MEDIUM SQUAREMELODIC" +" QITSAMENSURABILITYMESSENIAN TENMICROCOMPUTERMINDER RIBBONMINUS SIMILARMINUS " +"WHITE XMOBILE PHONESMODIFIER MARKMULTIOCULAR ONAP PIZZICATOND-RING BELOWNG TE" +"RMINATORNINE TWELFTHSNING MOVEMENTNP TRANSISTORNTY FULL STOPNUMERATOR ONENUME" +"RIC SIGN OBLIQUE LINE OGOTYPE SIGN OLVING HEARTSOMAN NUMERAL ONAL COMPUTERONE" +" DISH TENUONG RIGHT LEGONG-LEGGED DEONGRATULATIONOON NOTEHEAD OPPOSING NAGAOT" +"EHEAD BLACKOUR DISH TENUOURTH SUBUNITOUT MIDDLE UPPA NJI PIPAEMPAIRED ARROWSP" +"LUS OPERATORPN TRANSISTORPPOSING LUGALPREPONDERANCEQUARE FERMATAQUARTERS SIGN" +"RACKETS ABOVERANKS CASKET RIGHT HARPOONRIGHT POINTERRIPLE SVARITARIZONTAL TAI" +"LRN PENTATHLONROTATED BIRGARPENTRY PLANERRIAGE RETURNRTABLE STEREOS KAI APOTH" +"ESS KRYZHEM ON S UP TOGETHERSAL PLUS TUG2SAMYOK SANNYASELECTED AREASHESH PLUS" +" KISHORT FERMATASIA-AUSTRALIASIGN AVAGRAHASIGN PAMUDPODSILI PNEUMATASIMPLIFIE" +"D ERSMALL LETTERSSSAGE WAITINGSTABLE SYMBOLSTERTIUS SIGNSYNDESMOS NEOT WITH H" +"ANDLETE ORDER MARKTED HAND SIGNTHIRD SUBUNITTIRTA TUMETESTOP HALF RINGTU WAS-" +"SALAAMU WITH STROKEUE OF LIBERTYUFFLE PRODUCTUPERIMPOSED XUPONDIUS SIGNUPSILO" +"N WITH UPWARDS TRENDURNED W BELOWUSHING UPWARDUSICAL LEIMMAUZZ ROLL STEMVEN P" +"OINT ONEVERGREEN TREEVERLAY MIDDLEVERTICAL BARSVERTICAL FILLVERTICAL-LINEVICE" +" CONTROL VOWEL SIGN PAW RING INSIDEWAVY LOW LINEWAVY OVERLINEWAW-AYIN-RESHWIT" +"H ASTERISKWITH INTEGRALYMBOL TAU RHOYOD YOD PATAHYSTEM DIVIDERYUUKALEAPINTUZH" +"OU NUMERAL AND PICTURE AND TOP END CROSSING GU IN TRIANGLE KLYUCHEVAYA LINE " +"SYMBOL OF ANTIMONY ON PEDESTAL OVER KISIM5 OVER LAZY S OVER MIDDLE OVER TWO P" +"I SKEWED LEFT WITH C CLEF WITH DAGESH WITH INDEX WITH UPTURN-DZUD RTAGS -MAI" +"L SYMBOL-SHAPED SIGN-SIMPLIFIED 6 LONG NGGOOA WITH SWASHACE INTEGRALACUTE ACC" +"ENTAFU LEERAEWAALLPOINT PENALT PAN SIGNALTERNATING AND CRESCENTAND OPERATORAN" +"G KHANG GYAR DIAERESISARALLELOGRAMATNAH HAFUKHATTOOED HEADBACK OF HANDBAHIRGO" +"MUKHABEHIND CLOUDBETWEEN LIPSBINING MARK BLOWING FACEBLUE DIAMONDBRATION MODE" +"BRIDGE ABOVEBSCRIPT ALEFBUTTON MOUSEBYSMAL WATERCABBAGE-TREECALENDAR PADCENDI" +"NG NODECHAIR SYMBOLCIAN LETTER CIRCLED PLUSCIRCLES AND CK-O-LANTERNCLOSED MOU" +"THCLOSED OMEGACRESCENT BARCROSSING GI4CROSSING KALCROSSING LU2CROSSING NUNDAS" +"HED ARROWDE MARK SIGNDENTAL CLICKDHRI LETTER DICTION SIGNDIPHTHONG AIDOT OPER" +"ATORDOUBLE ARCH DOUBLE ARROWDOUBLE-ACUTEDOWN HARPOONDOWN NEUTRALDUG TIMES NIE" +"EPING SMALLEIGHTH NOTESEMELY HEAVY EMISOFT SIGNENARIUS SIGNENOS CHRONOUERPEND" +"ICULARETRETES SIGNEVERING FACEFALLING DOTSFEMININE DOTFERENCE MARKFLAG ON POS" +"TFOLDED HANDSFORMING ARTSFT RERENGGANGAW KAREN EUGBY FOOTBALLGEBA KAREN IGREE" +"N DRAGONGROUND SLIDEGUARDED AREAHAH WITH DALHALF BRACKETHAND FORMAT HASIS SYM" +"BOLHEAD-BANDAGEHIBITED SIGNHREE FINGERSHYPHEN-MINUSIDENTICAL TOIGATURE SHRIIL" +"LED CIRCLEIN MIDDLE UPINDEX MIDDLEING ENVELOPEING HAND FANING HITTING ING OPE" +"RATORINTEGRATION INUSOID SIGNINVERTEBRATEIRAGANA HOKAIRTY-SECOND IVE TWELFTHS" +"IX DISH TENUKANA REPEAT KAPPA SYMBOLKHAMTI TONE-KHMIMIC KHEILAM WITH YEHLARGE" +" DOUBLELARGE TRIPLELATALIZATIONLAYING CARDSLEADING EYESLEFT HARPOONLEFT POINT" +"ERLER CONSTANTLEZH DIGRAPHLICKING LIPSLIMBS DIGITSLINGING FIRELINKING MARKLL " +"MODIFIER-LLE PATTERN LONG FERMATALOWER CORNERLOWERED FLAGLU PLUS ESH2LUS NOTE" +"HEADLYING SAUCERM NSHUT NYAMMADDA ABOVE MALL SECTIONMANNAZ MAN MMBELLISHMENTM" +"EDARY CAMELMEDIUM SHAFTMETA STAVROUMIDDLE PIECEMING TO MEETMONOGRAPH UKMPHASI" +"S MARKMPTY CENTRE MUM TIMES PAN ELEMENT OFNARROW SHAFTNATURAL SIGNNCK CONSTAN" +"TNEPOSTOYANNYNERSHIP SIGNNEUTRAL FACENGLE BARLINENJALA GONDI NORTHERN TSENOTC" +"HED HOOKNOTCHED TAILNUITY SYMBOLOBIKI SYMBOLOCTET PRESETOGOGRAM NYAJOHAZARD S" +"IGNOID NOTEHEADOING TO MEETOK HAND SIGNON US SYMBOLONISHED FACEOPED CEDILLAOP" "ENING LEFTOPLE HUGGINGOPPOSING LU2OQ NSHUT YUMOTTOM HALF OOUCHES THUMBOUGHT B" "UBBLEOUR TWELFTHSPHEME JOINERPOETRY MARK-PORT CONTROLPOUTING FACEPROTOS ICHOS" "PUT DRACONISQUARED ARROWQUARTER SIGNQUIRREL TAILRAFFIC LIGHTRAH BEN YOMORANCH" "ING OUTRCHAIC SAMPIRCHAIC SHRIIREFACE COLONREN CROSSINGREVERSE MARKRIAGE SYMB" "OLRIAL TRAMWAYRIGHT DOUBLERIGHT SINGLERING OVERLAYRION CHRONONRISTMAS TREERNA" -"M BCAD MAROLLING EYESROUNDED ZERORROUND FROM S ABOVE SIGNS SUBPUNCTISSAZ IS I" -"SS ISECTION SIGNSH ZIDA TENUSHED BARLINESHORT RIKRIKSMALL DOUBLESMALL TRIPLES" -"MILING FACESS-THAN SIGNSTICK FIGURESUR OVER SURT ASRAARUHUMT MONGKEUAEQTE SEP" -"ARATORTEARS OF JOYTERNATE AYINTHETA SYMBOLTHIC LETTER THREE HEARTSTIC LETTER " -"NTOP-LIGHTED TRAGRAM FOR TRIPLE DANDATRIPLE FLAMEUBSCRIPT TWOUDA DRACONISUGHT" -" BALLOONUH PLUS GISHULL NOTEHEADUME INTEGRALUN WITH RAYSUNNER FRAME-UPPER COR" -"NERUSEATED FACEUTH ARABIAN UTH-SLAVEY KVAKRAHASANYAVER EQUAL TOVICTORY HANDVO" -"LTAGE SIGNWDATA SQUAREWIGGLY FENCEWITH SMALL VXIRON KLASMAYAN NUMERAL YMBOL B" -"INDU YMBOL MUEANGYOD TRIANGLEYOUTHFULNESS AND MACRON DECORATION I ZAPYATOY OF" -" FLOWERS OF FORTUNE OVER BULUG OVER IDIM PLUS MASH2 PLUS NUNUZ PROPORTION S " -"ZAPYATOY SHOE STILE TIMES ESH2 WITH CARON WITH COMMA WITH DASIA WITH FLASH WI" -"TH JACKS WITH KASRA WITH MAPIQ WITH PLATE WITH TITLO WITH TRILL WRIST FLEX-CO" -"PPER ORE-MINUS SIGN-OFF SYMBOL0 FOOTSTOOL3 LONG NGGO5 LONG MBOO6 LONG NGGEAA " -"AS-SALAAACKED COMMAACTIVE SIGNACUTE-GRAVEAESCULAPIUSAESHAE NYAMAGAZ DAEG DAGO" -"NAL SIGNAILLESS PHIAMUSED FACEARAM GONDI ARM SPIRAL ARMS RAISEDARPEGGIATO ASE" -" TO THE ASURE CHESTATH PRODUCTATION POINTATION SPACEBANK SYMBOLBELL SYMBOLBEL" -"OW RIGHTBETA SYMBOLBLACK ARROWBOTTOM MARKBREVE BELOWBUMPY ABOVEBZHI -KHYILCAN" -" RGYINGSCARET TILDECCUMULATIONCE OF PIZZACELANDIC-YRCH AND LAMPCHING CHICKCLO" -"SED JAWSCOMBINATIONCOND SCREENCONTAIN AS CREDIT SIGNCROSSING BUCROSSING ENCRO" -"SSING IMCROSSING PICROSSING URCTION MARK CTION MARK-CURVED BENDDALETH-RESHDAS" -"H SYMBOLDE KIKAKUI DENT EMBLEMDESK PERSONDI ALLAAHU DIATONON DIDOACHASHMEEDOL" -"LAR SIGNDONG TSHUGSDOUBLE AND DOUBLE MARKDOUBLE RINGDOUBLE SHADDUATION CAPDYO" -" CHRONONE WITH VEILE2 TIMES ANEAVER DENE EDICAL MASKEEZING FACEEN STRAIGHTENE" -"RGY WAVEENG DIGRAPHENTHESIZED EORGIAN NAREPIDAUREAN ERCENT SIGNESH DIGRAPHETE" -"I MAYEK EUNJOMNDEUQFGHANI SIGNFINAL SIGMAFIRE ENGINEFOURTH ROOTGAP FILLER-GAY" -"ANUKITTAGE AT NIGHTGENTLE WINDGHAIN WITH GILE SYMBOLGRAMMA SIGNGRAVE-ACUTEGSU" -"M -KHYILGUISED FACEHAGGAR YAZHHANG KHUDAMHAWH HMONG HEATED FACEHEAVEN MARKHEE" -"LED SHOEHIGH STROKEHITE DRAGONHLETIC SHOEHOKHLOM ON HORA DIGIT HREE BALUDAI T" -"IMES BADI TIMES NUNIBLE-CREE YIL FRAGMENTILCROW SIGNILIQUA SIGNIMULTANEOUSIN " -"EQUAL TOINDERGARTENINDICESIMA IPLE TONGUEIRCLED TEXTIRCULAR ARCISIGOTHIC ZIVE" -"RY TRUCKIX TWELFTHSJECT SYMBOLJIHVAMULIYAJOYOUS LAKEKAARA POLLUKRAINIAN IEKTI" -"ESELSKABL OF THREADL TIMES LALLACK SULFURLACKLETTER LATIN CROSSLCE TSA CANLD " -"POLISH OLD SCRIPT XLEAF CLOVERLEEP SYMBOLLEFT DOUBLELEFT SINGLELEFT SYMBOLLET" -"ION MARKLEU SATANGALINE FILLERLON SKEWED LOSED ENTRYLOSING MARKLOTI NAGRI LT " -"OF CLOTHLTED FLOWERLTERNATE AALTERNATE YALU PLUS IGILUPOVODNAYAMACING FACEMBA" -" BAYANNAMBLER GLASSME LONG CANMED RGYINGSMFON PIPAEMMICAL HEARTMIDDLE BENTMID" -"DLE HOOKMIDDLE STEMMONOCULAR OMOVED BELOWMUNCIA SIGNMUUSIKATOANN THE VERGENBL" -"ENDED UKND ODD SIGNND OF PIECENESE SMALL NG LEFT LEGNIKOLSBURG NITIAL IZHENSE" -" CHEEKS NTIMONY ORENUMBER SIGNNUMBER ZERONUN HAFUKHANUSVARA ONENYIS -KHYILOF " -"ENVELOPEOF MASHFAATOHINGYA YEHOLD NUBIAN OM PUSHPIKAOMAN SIYAQ ONIAN SIGN OPP" -"OSING ENOPPOSING IMOR OPERATORORCE SYMBOLORT BARLINEOUBLE ACUTEOUBLE DANDAOUN" -"DED FACEOUTHERN TSEOVERSTRUCK PARAKALESMAPERISPOMENIPHNAEK MUANPIRAL FROM POD" -"CHASHIEMPOST OFFICEPUT MORTUUMQUALS SIGN QUERED FLAGQUIQUADRATERA SOMPENG RAC" -"HMA SIGNRAISED FLAGRANSMISSIONRCHAIC JNYAREAKTHROUGHRESPONDS TORIGHT GUARDRIG" -"HT HEAVYRIGHT-HAND RING LIQUIDRIPLE PRIMERISING DOTSRITING HANDROKUTASTI ARON" -"THISMATAROR-BARRED ROSS ACCENTRUNNING MANRYVNIA SIGNSECOND MARKSHAAYATHIYASHE" -"QEL SIGNSIMILE SIGNSINGLE AND SMALL CLOUDSPEED TRAINSPIRATED FASSANGKIYEOKSTE" -"AMY ROOMSTERED SIGNSTORIC SITESYMBOL VIDJSYURA SASAKT VEGETABLETA EQUAL TOTAA" -"ALAA ANHTENS DIGIT TETRAFONIASTH-THALATHATHAM DIGIT THIRD BLOCKTHIRDS SIGNTHR" -"EE TIMESTIEE SHEUOQTIGHT ACUTETONAL MARK TORTED FACETRAIGHT WAWTRESS SIGN TRE" -"SVETLAYATRIAN CAMELTRUNCATED ATWO FINGERSTY THOUSANDU ALAYHI WAU-TIGALARI UBL" -"E TONGUEUETTE BREADUG RTAGS GYUISHED FACEULO TWO SUMUMAN FIGUREUNIT DIGIT UNJ" -"O WYNN WUPADHMANIYAURRENT SIGNUSHING HANDUTH CORNERSUTING WHALEVA V CHELNUVAM" -"AGOMUKHAVARYS ICHOSVE OF PEACEVERTEX OF VVISARGA ONEVYKA ABOVE WASLA ABOVEWE " -"PALAUNG WHITE JOKERWING NEEDLEWINKING EYEWITH GARDENWO TWELFTHSXAGRAM FOR XES" -"TES SIGNXI RADICAL XTINGUISHERYEORINHIEUHZERO THIRDSZIGZAG LINEZZA WA JALL AN" -"D ACUTE AND ARROW AND BREVE AND KNIFE AND MOUSE DRAWINGS KABA TENU LATE FORM" -" OF DHARMA OVER KAD5 PLUS SHU2 POVODNAYA RESUPINUS RGYA GRAM SCHROEDER THOUSA" -"NDS TIMES SHE WITH BARS WITH BASE WITH BELT WITH EGGS WITH LOW WITH PAGE WIT" -"H PLUS WITH RAIN WITH RING WITH TAIL WITH TICK-LUE KARAN-SHAPED HA1 LONG MBE1" -" PLASTICS2 LONG MBO2 PLASTICS2 PLUS ASH3 PLASTICS4 PLASTICS5 PLASTICS6 PLASTI" -"CS7 PLASTICSA PLUS IGIA PLUS KURA TANG LAIAB2 TIMES ABATA TREEACE FILLERADAK " -"BINDIADDA WITH AEDA-PILLAAILED BIRDAKKHANGYAOALEF LAMEDALEF WITH ALENT SIGNAL" -"LY MARK ANDHI MARKANGKHANKHUANGULAR TOAR ECLIPSEASPIRATIONASTERISCUSAT HORIZO" -"NATRICHISMAATTY WITH AUTOMOBILEAYER BEADSBA SATANGABELOW LEFTBLACK FLAGBLUE H" -"EARTBOLD SHAFTBROKEN BARBSTRUCTIONC WITH DOTCAPITAL ETCH BALLOONCHAD RTAGSCHA" -"RACTER-CHECK MARKCIRCLED CACISIVENESSCOLATE BARCOMPONENT COMPONENT-CROPHONIC " -"CROSS MARKCURLED WAWCURLY HAIRCY MESSAGED KEYBOARDD WITH DOTDA PLUS HADA SATA" -"NGADED PERSONDIATONIKI DIGIT ZERODIRGA MUREDOUBLE BARDUOUS TREEE PLUS SUMEARL" -"Y FORMEARTH MARKEBENSTIMMEED FIGURE-ED FINGERSEDESTRIANSEDIC TONE EEKING EYEE" -"ICH STARKEIGHTIETHSELT BUCKLEENETRATIONENS SYMBOLENTHUSIASMEONGCHIEUMEQUIHOPP" -"ERETTA-PILLAEUTRAL YEREVERSED PEF SHE-GOATFAHRENHEITFFICULTIESFINAL HETHFOR R" -"ECORDFORMATTINGFRONT WALLFTOGGOS OUG MUNDARI GAGE CLAIMGANDA MARKGAS BZUNG GB" -"AKURUNENGGING FACEGGRAVATIONGHT LIFTERGIMEL-HETHGOLUBCHIK GREE SLASHGUA PI MA" -"OHAAPRAANA HAMZA MARKHAN DIGIT HEAVY BEATHERMOMETERHOOK ABOVEHOTIC HOOKHREE A" -"BOVEHUNGARIAN I ARCHAIONICAL TAPERIDDLE MARKIDEOGRAPH IED SHRIMPIGATING RAIGA" -"TURE OEIKRON ISONILE FOLDERINDEX BENTINDU BELOWING LARGE ING-SHIFT INHERENT A" -"INITIAL RAINUS SIGN ION BOTTLEISMUTH OREIT MBAAKETITH DIGIT IXTHS DISHJALALOU" -"HOUJONG TILE K2 PLUS BUKA SATANGAKAI SYMBOLKINDI MVOPKRYZHEVAYALACK JOKERLANE" -" MERGELE LETTER LE-DELAYEDLEFT GUARDLEFT HEAVYLEFT LIGHTLEFT SERIFLEFT-HAND L" -"EK ATTAK LENDED YUSLET SYMBOLLGIZ EOLHXLHAG RTAGSLIGHT BEATLIGHT BULBLIMITATI" -"ONLINDRICITYLLOW HEARTLOGICAL ORLONG FINALLONG OVER LONG SIKI LONG TSHEGLOWER" -" HOOKLOWER STEMLPAPRAANA LTERNATE ULTIC CROSSM STALLIONMADDA MARKMALL ALEPHMB" -"INING DOME PLUS ENMEEM ABOVEMEL SYMBOLMILLE SIGNMINO TILE MONOFONIASMONOGRAM " -"BMONOSPACE MONTH SIGNMOTORCYCLEN NGGEUAETNAKE BELOWNANGMONTHONASPIRATEDNDA PA" -" NJINDU TEMPLENGLICANA WNOTE WITH NTITY MARKNTO SHRINENUMBER TENOANDAKHIATOCK" -"ET SHIPOF HYGIEIAOLING FACEOLON EQUALOMMA BELOWON MEDIAL OON LILITHOON SELENA" -"OP NKAARAEOPEN SHELFOROME SIGNORTHERN TAOSSED SHEIOSTAL MARKOTING STAROUND OM" -"EGAOUR FIFTHSOUT INDEX OUTER JOINOUTHERN TAPAO DIGIT PASSIMBANGPEDAL MARKPLUS" -" BELOWPLUS ERIN2PLUS NAGA POLICE CARPOUND SIGNPPING BIRDPPOPOTAMUSPRALINEAR Q" -"UISH QUADR2 PLUS SURAGGISMATARCHAIC KHARDHACANDRARECIPITATERED DRAGONRESH BEL" -"OWREVERSED IRGE CIRCLERGE SQUARERHO SYMBOLRIGHT HOOKRIGHT SIGNRING ABOVERING " -"THUMBRKING FACEROAD OMEGAROEZENIAN ROUND DOT ROUNDED ERRSI SYMBOLRUDIMENTA RU" -"PEE MARKSBUB -CHALSCAN LINE-SE-CREE SKSELINE ESHSGOR RTAGSSHARP SIGNSHMIRI YE" -"HSIDEWAYS ISIXTEENTHSSMILO SIGNSPACE MARKSS OF MILKSSANGARAEASSANGPIEUPST PAL" -"ETTEST-FEEDINGSTRAL SIGNSTROM SIGNSTRUCTION SYLLABLE MT AND BOLTTAIL GLASSTAM" -"AN SIGNTELEVISIONTEMPLATIONTERNATIVE TESE CROSSTHAPASCAN THDAY CAKETHMIKON N " -"TIMES SIGNTING HEARTTOMIC BOMBTOP CORNERTREFACTIONTRESS AND TRETCHED CTRIPLE " -"DOTTWENTIETHSTWO SHORTSTWO THIRDSTYPE COLONU CIN HAU U2 PLUS BAUAM TSHOOJUARD" -"EDNESSUBLE DASH UM ROTUNDAUMAN EARTHUNG KHEMA UNKIA SIGNUP HARPOONUP NEUTRALU" -"P OR DOWNUPPER HOOKUPPER STEMUR HUNDREDUR YIG MGOURIPIGMENTURVED OMETUSEL HOR" -"SEUTH OR SPYVASTI SIGNVEL SLIDERVERAGE BOXVIE CAMERAVIOUS PAGEW OR MODELWHITE" -" FLAGWHITE HAIRWHOLE NOTEWING HEARTWITH SPOONWITH STRAWWITH WINGSWO SHORTS XE" -"D BICEPSXHEEJ CEEVY AND RICEY CREATUREYEH BARREEYMBOL AIVAYPE PIECE ZAR AMULE" -"TZEIRO SIGNZH DIGRAPHZU OVER ZU AND BELT AND CURL AND TAIL APODEXIA DIVIDERS " -"FROM BAR GARSHUNI OF BLOOD OF PAPER OVER BAL OVER LUM PLUS GAL PLUS GUD PLUS " -"KU3 PLUS LAL PLUS SAG PLUS TUR PLUS ZA7 RA OR RI RICKSHAW SPARKLER STREAMER T" -"IMES HA TIMES UD TROMIKON-AMMONIAC-KHYUD PA-LOW TONE-MID TONE-STACCATO0 LONG " -"LE1 CHARIOT2 GARMENT247 DIPTE3 PLUS AN5 BATHTUB5 CYPERUS5 LONG JOA PLUS NAABO" -"VE TO ACE NOTE ACING CARADEG ADEGADMA GDANAF PERSONAFFE FACEAINTBRUSHAISED DO" -"TAJANYALANAL RUNOUTALAYALAM ALI GALI ALPAPRANAANEROSIS ANG CITI ANGGEUAETANSK" -"RIT SANTAYALANANTHAKHATAOS ICHOSARCHAIC MARISTERA AS MEMBERATHAMASATATTACHED " -"AVE ARROWB DIGRAPHBASE UNITBEER MUGSBIAL SIGNBICYCLISTBING CANEBITE LIPSBKHAS" -"IAN BO BAIMAIBO GYFU GBOTH BENTBRUL SHADBTRACTIONCANG TE-UCAPACITORCAPITAL DC" -"APITAL ICAPITAL QCARTRIDGECHANICAL CHAVIYANICHOSEONG CLOSED PLCOIN SIGNCOMPLE" -"TEDCONJOINERCORN FACECQUISITIOCRESCENDOCROUCHINGCUBE ROOTCULTATIOND SALTIREDE" -"NT AND DEPARTUREDIAGONALSDOWN HANDDOWN SIGNDOWN STEPDOX CROSSDRAM SIGNDUS RTA" -"GSE AT LEFTEAVY DOWNEBIT SIGNED DIGIT ED PLANETEEN WITH EFAIDRIN EFORMED TEIG" -"HT OF ELEGRAPH ELLOWSHIPEMBEDDINGEMPTY SETENTRE OF ENTRY SAWER BUBBLEERCIAL A" -"TERTY LINEES AKURU ESAME DOTETER SIGNETRASIMOUETTI BALLEURO SIGNFACING UPFEH " -"WITH FINAL MEMFINAL NGAFINAL NUNFISH TAILFLAT SIGNFORTUNA MFOUR BENTFROM WALL" -"G IN HOLEGITTARIUSGREATER YGRIK SIGNGUAGE TAGHAIKSUKI HALF NOTEHALF SIGNHALSH" -"ELETHARACTERSHARD SIGNHEADSCARFHI SYMBOLHIMA SIMAHINOCEROSHIYYAALAAHOOK MARKH" -"OT SASAKHREE FOR HWAZ EH EI PLUS LIIA SYMBOLIALECT-P ICE CREAMIDEOGRAM IDEWAY" -"S UIGH HAMZAIGHTH ASHIGN NUKTAIGN SAFHAIGN TOMPIILE TILDEILIPPINE IN SQUAREIN" -"AL NOTEINARBORASINFINITY ING CARD ING DOLLSING GLOVEING LANESING STONEINISHME" -"NTINNYIIYHEIRST MARKISEN-ISENITRA SIGNIVE-PULL-IVINATIONJERUSALEMK GESTUREKA-" -" SHOG KAMEYTSA KEMPHRENGKING BOOTKSTREPTONKU RU KHAKYO TOWERL ME HANDLACKFOOT" -" LAN SIGN LARGEMENTLEFT RINGLESS TREELIGHTNINGLINE FACELISSANDO LITTLE UPLIVE" -"RANCELLABLE B0LLABLE OMLOND HAIRLONG TIP LOWER DOTLVIN SIGNM HE-GOATMAEMGBIEE" -"MALL RINGMARK CIM MARK SHADMBROIDERYMETOBELUSMHANCHOLLMRACHNAYAMUKPHRENGNA KH" -"ONNANCLOSING NDAILING NFORZANDONG SANDALNGER ROOTNGER SHIPNGUN SIGNNIGGAHITAN" -"IGHT OF NIHSHVASANING SIGNNO TELEIANSERT AT NTERPRISENTESSENCENTRACTIONNUSVAR" -"AYANVERTED ROCCLUSIONODIASTOLEOF STIMMEOKED HEADOKED TAILOKOUFISMAOM SYMBOLON" -" GROUNDON TEUAEQONE MARK-ONE THIRDONG GRAVEONGSEONG ONJUNCTIOOO DENNENOP HALF" -" OOPEN EYESOPEN JAWSORT-TWIG-ORTH WINDOTAL SIGNOURA SIGNOUT BEAMSOUT MOUTHOUT" -"H WINDOVER GAN2OVER MUSHOW KAVYKAP DIGRAPHP ELAMITEPAA-PILLAPADE SUITPANYANGG" -"APENT SIGNPENTASEMEPIDERY HAPLE HEARTPOSITIONSPPOINTED PPOSITIONPROJECTORQUAD" -"COLONQUADRANT-QUEEN OF QUSHSHAYAR PLUS RARCHAIC IIRCHAIC RARDEL DKARREAK HERE" -"RED JOKERREDNE ON REFORMED RFUL FACERIA ERFE RIED FACERNEY PARARO WIDTH ROJEC" -"TIONROTATION-RPORATIONRTER MARKRTS MEDALRUM CLEF-RWARI DDAS DIGRAPHSEMICOLONS" -"EPTEMBERSHAB CEEBSIVE FACESMALL YUSSOF PASUQSPIRITUS SSANGSIOSSTAL BALLSTEBAS" -"KETSTRELNAYAT OF MEATT ON BONETABE SIGNTAKHALLUSTANDSTILLTED PLANTTEH ABOVETH" -"ROUGH XTIMES NA2TIMES PAPTO CORNERTONE MAI TRAIGHT UTREDECILETRESVETLOTRISTIT" -"IATTED STEMTUKWENTISTUTEYASATUBSTITUTEUE MAEMBAULL BLANKUMED HEADUNGLASSESUNG" -"SEONG UPPER DOTUPTSTIMMEUR CORNERUR-DE-LISURAMAZDAAURLY LOOPURNED AYBURNED GA" -"NURUZ UR UUTRA MARKUURDHAJA UVUZHAKKUVANAGARI VELOPMENTVER LUGALVERLONG AVEUA" -"ENGAMVICE MARKVIGINTILEVINE LEAFVISARGAYAVOCALIC RVOETOCHIEVRAKHIYA WASH TAIL" -"WING STARWITH FACEWORDSPACEWRINKLES WRY SMILEXCITEMENTXHAUSTIONY-FOURTH Y-FOU" -"RTHSYEAR SIGNYEH ABOVEYRANISMA Z DIGRAPHZAKRYTAYAZAL SASAKZENE RINGZERO SIGNZ" -"IR SASAK ANTENNA AT DUSK CEDILLA FACING HANDLES KEMBANG LANTANG NUTILLU OF Y" -"ARN ON LEFT OTTAVA OVER KG OVER MU OVER ZI PLUS DI PLUS DU PLUS RU POLNAYA R" -"ASWADI SATCHEL SCOTS S SLIDING TALENTS TTUDDAG WA-ALAA YUQ NAE-CREE TH-EM DAS" -"H-KHIEUKH-PHIEUPH-X BELOW0 BRONZE1 BARLEY1 HELMET3 ARMOUR56 TURO28 KANAKOA SI" -"GN AABAAFILIABOAFILIACKSPACEAEN NYAMAIYANNOIALLIANCEAMS HORNANC SIGNANE TREEA" -"NS SIGNAPITAL FAR TSHESARCASITEARKLEAN ARRIVINGARSI YEHARTYRIA AST WINDASTERN" -" WATAKANA ATE MARKATEBOARDATH MARKAVY BANDAY-NIGHTAZHAAKKUBACKWARDBASSINETBAT" -"BEIT BER POLEBEVERAGEBIEE FONBILLIONSBINOVILEBLE SIGNBLED CARBLINEAR BOL SIGN" -"BOT FACEBOX TRAYBRA FACEBUNDANCEC SIYAQ CABLEWAYCAL DISCCANDICUSCASSETTECEILI" -"NG CER BALLCHATTAWACHINESE CK CHARTCLIMBINGCOMBINEDCOUNCIL COUNTERSCURLICUECU" -"RSIVE D BUBBLED CROSS DAMMATANDANTAJA DDY BEARDIAMONDSDIFONIASDIM GUNUDIT CAR" -"DDOCUMENTDS-CREE DUSHENNADVANTAGEDVISVARAE COOKIEE OF POOEBEEFILIECH YIWNED B" -"RICKEGORIAN EK ONKARELEPHANTEN NTEUMENICIAN EOUT BOXER TRUTHERAL URNERDIGRISE" -"REVODKAESH LOOPEST WINDET SHOESETA SIGNETRASEMEEUFEUAETEVEN OF EVERANCEEXCHAN" -"GEFEBRUARYFILE BOXFINAL THFLOURISHFOR STOPFRAKTUR FRICAN DGARITIC GBASINNAGEN" -"ITIVEGERPRINTGLASNAYAGORAZDO GREAT SAHAGALL HHALF GURHAN-AKATHARBAHAYHARMONIC" -"HESPIAN HIRDEABOHOP BELLHREE OF HT CLOUDI SHAKTIICHAEAN IGHT ARMIGMOID SIMANS" -"IS INAGARI INDUCTORING BELLING BOWLING ROD IRD MARKIS FORM IS WHEELIS-PILLAIT" -"A MFONJACK OF JAVIYANIJUNCTIONKAIYARAAKASRATANKATAKANAL POLISHL-LAKUNALA LENG" -"ALAETITIALATION XLEANING LESS SHALESSER YLF RING LFWIDTH LKULIZMYLOCATIVELONG" -" BARLONG S TLORRAINELOW STOPLOZHITIELTRY LEGLUB SUITMALL AXEMANDARINMANGALAMM" -"ARRATANME BADGEME WITH MEM-QOPHMIONIAN MMATION MON TIMEMY HOUSEN-JOINERNA MET" -"EKNAMENNY NAVIYANINCE SIGNNED FOODNEIFORM NG RTAGSNI ABOVENINE OF NITIAL ZNO " -"SLASHNO THUMBNOTE PADNOVEMBERNRES TOSOBOOFILIOCALIC MOCK SALTOCUS OF ODESTONE" -"OHM SIGNOLLOWINGOM NTEUMOMANIAN OMMA BARON CROSSONE BEATONE FOR OO TYPE OREHE" -"AD ORM FEEDOT MBUAEOTIFIED OVER BU OVER GA2OVER GI4OVER SAGOVER SHEOVER TIROV" -"ERRIDEPAIRTHRAPAKPAK EPALOCHKAPARATED PAVIYANIPENTAGONPRECEDESPROSTAYAPUB DAW" -"BPUN IYEKQAIRTHRAQUINTILER-RAHMAHRAMMA GGRASMIAN RAT RAI RAUGHTS RDEL NAGREAT" -"NESSRED HAIRREE MARKRESVETLYRILLIONSRIYOOSANROSHTHI ROSSED ORSE DUNGS OCHKOMS" -"ALT OF SALTIRESSANYAKA SCRIPT GSE WEDGESENTAGONSEXTANT-SHKIR KASHOE JOTSHORT " -"ERSIFISTONSIGN LAESIGN PVOSIX DOTSSMA SIGNSNA LDANSOFTNESSSPERSIONSQUEEZEDSUC" -"CEEDSSUPERSETSWIMMINGT NGGEETTAALUJA TAI LUE TAR EYESTATASOUETER FACETHOLHOMA" -"THOSCOPETICK IN TIRRUP RTISMOS ETO-LEFT TOWARDS TRI DISHTRICOLONTTENTIONTTO M" -"ARKTURNED MUAREG YAUATRILLOUBJOINERUDAWADI UKEUTNDAULLS LEGUNDERDOTUNDERTIEUN" -"G DASHUP TRUCKV OVER MVE SASAKVERGENCEVESSEL BVOLUTIONVOMITINGW PRINTSWASH KA" -"FWBOY HATWN HEARTWO ABOVEWO BEATSWON SIGNWRINKLEDWRITING XCELLENTY BEETLEY PO" -"PPERYAMAKKANYBEYFILIYENISEI YER YAGHYESIEUNGYIDDISH YPORROONYRILLIC ZAKRYTOEZ" -"WARAKAYZWJ THAJ APLOUN BUTTON CER-WA FLEXUS ISLAND KEFULA LONSUM MAELEE MENDU" -"T MINUS MUOMAE MUQDAM OCLOCK OPEN-O PLOPHU RAMBAT SHAKER SLOWLY STRIDE TAMUR" -"A TEDUNG WAAJIB WOLOSO-CREE R-KIYEOK-MACRON-MU-MO--SHIFT--THIRTY-TIKEUT-WELSH" -" 0 SPEAR0 WHEAT1 ARROW2 OLIVE2 WOMAN26 EYYY3 AREPA3 EIGHT3 MONTH3 OMEGA3 SPIC" -"E3 SWORD3 WHEEL5 NGGEE6 NGGOO7 NGGUA7 NGUAN9 CLOTH9 NGGAAA -PHRUA NAME ACTER " -"TAD NECKAELAENGAETMEUNAHAPAKHALESMA ALLOT XALTILLOAM ALEFAN MARKAND ENDANDERE" -"RANGKUOQANGLED ANGLONGANGOLATAPEZIUMARDNESSARRED BARRED OAS SIGNASHTRA ASUTOR" -"UATAEAN ATH OF AU MARKAULDRONAUNTLETAXIMATAAY SIGNBAIRKANBAMBOOSBARREKHBASIGN" -"ABERGINEBERRIESBIG YUSBLACHKOBLOSSOMBOARDERBOOSTERBORZAYABOURINGBREVIS BUFFAL" -"OBULANCECABINETCAP TENCAYANNACELSIUSCHEINAPCHIEUCHCK LIMECLEAVERCLOSE ECLOTHE" -"SCOMING CONTACTCOPTIC CRACKERD MADDADA FACEDANCINGDANESE DAYANNADEAVOURDHALAT" -"HDIARGONDIPLOUNDISIMOUDOFONONDRIL BUDU NJAADYNAMICE DRINKE GLASSEAD OREEAGULL" -" EAVY YAECEMBERED RICEEFT ARMEIGHT KEL PUMPEN LEAFENSHUETER THANERNIN AESTIVA" -"LETNAHTAEULEUNGF DAVIDF SASAKFATIGUEFAYANNAFINAGH FINAL YFLUENCEFORKINGGAYANN" -"AGENERALGHEUGHEGLAGOLIGO-KARTGOLIAN GRADUALHAARKAAHALANTAHANGUL HAYANNAHEADIN" -"GHEXAGONHI SIGNHIOPIC HIUCHUSHODDONDHYAAUSHI NTEUMI RTAGSIANGQI IBIFILIIC WAN" -"DICOPTERICYCLESIKHAHITIL DRUMILLEANNIMILAR INNABARISIBLE ITALIC ITON RAIVE OF" -" JAIN OMJARATI JAYANNAJECTIVEJERAN JJIBWAY KARO BAKAYANNAKEUAERIKHA YATKKURUN" -"IKOMBUVAKOQNDONKORONISKPAK WAKUTAARUKYLISMAL SEGNOLAGIOS LAK-050LAMITE LASHES" -" LAYANNALE LEAFLEK TOOLENGTH-LEUT KALEYBALLLF FACELIGHT XLJUDIJELLYFISHLOSION" -" LYGISMAMAAYYAAMAI SATMANCHU MARCATOMASSAGEMBOL B0MEETORUMERICASMINGKALMINIMA" -" MONSTERMRACHNYMUNGKAHNANCIALNAYANNANEQUDAANESTED NG MASKNIKAHITNJAEMLINUMBER" -"SOCTAGONOCTANT-OCTOBEROF SOAPOFFICEROGDIAN OKRYTIEOLAPUK OMERANGON FACEONG UE" -"XONGONANONTIEENOP MARKORCULUSOREVMA ORKHON ORTIETHOT NGOMOT REPHOUR OF OUT HU" -"BOUTWARDOVER ANOVER DUOW ALEFOWILO SOX BACKOX LINEP PIEETPALLAWAPANESE PANSIO" -"SPARERENPAYANNAPAYEROKPECTIVEPEGERMAPENGKALPERVISEPHUTHAOPLOYAN POMOFO POVODN" -"YPPROACHPRENKHAPSTICKSPTHAHA PURPLE PUSHPINQUARIUSQUEEZE R2 GUNURA REPARAKHAN" -"GRANGKEPRARIETYRAYANNARD FACERDO RJEREATHY REREKANRESILLORIPPLE RISIMOUROGRES" -"SROKEN LRRECTUSRTHIAN RY FACES-SAJDASA VAH SAMPHAOSANDHI SANGAN SAYANNASCOOTE" -"RSEXTILESHAKINGSHIFT TSHORT ASIDDHAMSIGN UDSOLDIERSOV ROGSPRINGSST TUBESTERIN" -"GSUKUUDOSYNAGMAT ASHESTA MARKTAISYOUTALL AATASHEELTAYANNATCHFORKTHALIYATHESEO" -"STHIEUTHTHKUQI TIKRAMATIVATE TORNADOTRAINERTROLLEYTRYASKATSECHKATTHACANTTILIK" -" TYSCAPEUBUFILIUKKAKHAUKOTHEAUM IYEKUN MEUTUP HANDUP MARKUP SIGNUP STEPUP TAC" -"KURATIONURFACE URGLASSUSSYERUUT TIMEUYGHUR VANESE VAPOURSVAV YODVAYANNAVE DOT" -" VEMENT-VEW NOWVILIK BVILLAINVOICINGVOWEL KVYSOKO WAZ EOHWDRIVERWIFRUITWIGNYA" -"NWO FOR WO MARKWO WAENWORSHIPXAM LAIXOPHONEY GREENY HEARTYA LAMPYAH LI YANMAR" -" YAYANNAYELLOW YMAIC LYNAMIC ZQAPHA AGUNG DIPLI EPOCH EQUID FACE- GATE KAPA" -"L LELET LONGA MELIK MURDA QATAN SPLIT TACK TIKHY-HIDET-HIEUH-IEUNG-LINE--PIE" -"UP0 NGGI0 NGGO0 NYON0 NYUN00-1021 GBOO1 GOLD1 HORN1 NDEE1 WINE2 KPOO2 NGGU3 G" -"BEE3 HEEI3 NGGA4 DART4 DEER4 KPEE4 MUAN4 NGEN4 NJOO4 NYIN5 MERI5 WOOL6 GUEI6 " -"HUAN6 NGGE6 TREE7 GUAN7 KAPO7 MBEE7 MBUU7 NDOO7 NGON8 HOOU8 MBEE8 NYAN8 NYEN9" -" MUEN9 NJEEA HAAMA-KARAAASHAEACINTHAEMMAEAESURAAFFIX AGOGUEAGRANTAILUREAJANI " -"AK-668AKABATANCHORANGKATANIMALANUARYAPISMAAPLI MAPYRUSARADDOARBUTAARSEOSASHGA" -"BASSINGATTERYATTIC AUTUMNBAFILIBANWA BEFILIBETAN BGBIEEBISCUSBISHOPBLINK BOFI" -"LIBOWTIEBUFFERBURGERC CLEFCALATECASTLECATAWACEVITUCHADINCHAMKOCHEIKHCHEMA CHE" -"SS CHIKI CHIRETCHO CHCHURCHCKNESSCLOSETCODILECRAYONCREASECUMBERCUPPEDD DISKDA" -"GGERDE DOGDERMA DGEHOGDICINEDIESISDOKMAIDSLIDEDUCEUSDVANCEE WAVEEAHMUKED CAPE" -"D ICEEENTH-EIGHTYELLITEEMASTIEMPUS EN GHEENIKI ENTIMAEPACT ERMATAERTUREESTAN " -"ET KUTEU MBUEUAENAEUNYAMEUREUTEVENTHEXHALEEXISTSEYANNAF CLEFF MAREFAMILYFATHA" -" FF OF FIZAHUFORMEEFORTISFRAMESGANGIAGBASAQGEADALGEDOLAGGLINGGHAMALGHETTIGHEU" -"AEGLAZ HGNANT GO NGUGOBLINGORGONGRASP GS-PA GURAMUHALF HHAM AIHAMEDHHAMILOHAS" -"HKAHE MGOHECAKAHEISEIHENOPEHERMESHEUAEPHIBIT HINGE HIVETEHO HOIHORT IHUMBS HU" -"R PAI HOOKI MAIMIASMA IB YAMIDE ESIEVAN IGGLESILBOATILLAGEINAGMAINCUNXINDHI I" -"NGAATINHALEINPUTSINSHIPINWARDIRINGUISSANTISSHARISSIMOITABLEITHER ITRITEITULUM" -"IX OF IXTY PIYANNAKAYAH KE PHOKEYCAPKILLERKLITONKRISISKTIKO KUSHU2KY WAYLAFRO" -"NLAMADHLAMEDHLANDERLASTONLD MAPLEVEL-LIGIONLIGON LISHA LITIKILLIPOPLOACHALONG" -" EM BOARM BULLMADDAHMADR MMALL FMANYA ME DIEMECHIKMPLINGMUKHI N DASHN YANGN-N" -"ISFNACLESNCH FRNDA TANEUME NGBAT NGGONGNIRUGUNISTERNIZKO NKNOWNNOKHUKNOR BUNO" -"WMANNOZHEKNSANAQNSUZ ANTEVMANTIIMUNTOGENOBELOSOCENCEOCIETYODHADHOFOUNDOGONEKO" -"ITIC ON KEYONOCLEOOMUUTOPEN DOPEN POPITSAOPULUSOSETTEOW TIEPALUTAPBOARDPEAKS " -"PECIALPENCILPEPPERPICKETPIDER PIRIT POKOJIPOMENEPOMMEEPTACLEPUFFEDPWATCHQAMAT" -"SQETANARAAKANRACINGRAKLITRAVEL-RBITSAREMEDYRENGTHRICORNRIISAPRISEMERKAANUROCK" -"ETRSENICRSHANARSIAN RUBEUSS SHOES TENTSAADIYSHAYIMSHMAAMSICKLESIXTHSSKAPI SOU" -"NAPSPADESSPATHISPITALSSLESSSTANCESTANCYSTLERSSTOLI STROFOSUCKEDSURANGSURED SW" -"ORDSSYNAFISYOUWAT NJAQTAIKHUTAMINGTARGETTAU ROTAUROSTE TSETE USETERON TEUWENT" -"HAKKUTIKENOTIMATETIRYAKTOPBARTRAPLITRIKE TURBANTUXEDOU MBITUAEQTUUANGXIUBLE X" -"UCIBLEUDARKAUDDISAUGGAGEUP BOWUPNAYAURANUSURNAMAUUMISHUYANNAUZEIROVERTKAVILIA" -"NVIRIAMWBERRYWEORTHWINDOWWN BOWWN BOXWO OF WORKERWRENCHX FACEXIMIZEXO NEOYAKA" -"SHYIN-DOYOMBO YRENE YSTICKZHITSA AMPS CAPO CHWV COAT DEKA FUJI GORA HAA ICON" -" ILUT JERA KAWI LACA MOOD SARI TABS TELU-ALAF-BEAM-SIOS0 BEE0 DOO0 DWO0 GBO0 " -"GEE0 HAN0 HEE0 JOO0 MAN0 OIL0-VAS1 DWE1 FAN1 PEE1 TEE1 TWO1 WVI1 YOO1-VAS18CF" -"F2 HEN2 HOO2 KPA2 KPI2 MBA2 MBE2 MBO2 MBU2 NJA2 NJU2 POO2 PTE2 SEE2-VAS3 BOO3" -" FOO3 HIN3 HON3 NDI3 RA33 VEE3 WEI3-VAS32 JE4 ABB4 GBI4 KPU4 LEE4 LOO4 MBO4 M" -"ON4 NDO4 TOO4 VOO4 WOO4 WUI4-VAS5 KEE5 MBI5 NDU5-VAS6 GBA6 KOO6 RA26 SIA6 SOO" -"6 TA26 WEE6-VAS7 FUA7 GBE7 HUN7 JEE7 MIN7 NEN7 NIN7 TWE7-VAS8 FEE8 GBU8 KPE8 " -"KPO8 MAN8 NAN8 NWA8 RO28-VAS9 DEE9 KUA9 MEN9 MUN9 NDA9 NDE9 NON9 NUN9 PU29 WV" -"A9 WVE9 YEE9-VASA UNAA YUEAADHUAAMAEACHKAADDERADULTAEMAEAEPENAEREEAGMA ALFILA" -"LGARALLEYALLI ALOG ALPHAAMBDAAMEKHANGELANNONAPPLEAR AEARBAIARERUARTARASAR ASE" -"IAASPERATAF ATIYAAUTHSAVROSAWAY BAARUBACUSBALAGBASA BASSABAWAKBEITHBENDEBHADH" -"BHETHBISAHBLAKOBOOTSBORZYBSTERCAANGCAKESCAKRACALYACANUSCAUDACAUSECCEPTCCOLICE" -"CAKCECEKCEREKCHADACHERYCHIMECHOOICHOOLCHULACHUTECIEUCCKAGECKTIECLIFFCLONECLUB" -"SCROWNCTRICCUBEDDAIC DATUSDBOATDELTADENCEDEPTHDESTYDHAM DKAR DLINGDOTS-DSMAND" -"WICHE GEEEAGLEEATH EBALLEESHIEGALIEGIONEGL HEIDONEISMAEKEETEMAKEEMBICEMLJAENA" -"NOENDEPENENGENJETEO-EUEOPLEERINEERKHAESHE3ESO EET TUETFONEUAEMEURAEEYBUSEYYAL" -"F COWF EWEF SOWFAAFUFAIHUFEARNFITKOFLAGSFLICTFLUTEFORCEFSAAQGADOLGALGAGAMALGA" -"MANGAZE-GEAN GESH2GHNUTGHULUGOGI GORGIGULUSGVANGHAALUHADDAHAINUHALA HALQAHAMS" -"OHANNAHASE-HATHIHAYINHELAPHETHEHIMELHIRIQHISTIHIUTHHOLAMHOLARHOTELHROOMHUMP H" -"UTA I KOII-RESIARDSIAUDAICHONICRONIHVUSIKARAIKURUILVERIMAHUIMGBAIMMA IMMERING" -"SAINNA INTHUIPEHAIPINGIRACYISTLEITHI ITUALJANG JERVIJUDGEJUDULJUEUIK-020KAROR" -"KBALLKERETKESH2KHAPHKNOBSKO LAKTOP KURONKUSMAKWAENL NETL-JUZLABATLABORLAGUSLA" -"KKOLAMDALATIKLAYARLEASELENISLOAN LOMKALOOP LOURELURALLWAY M RAMMAAEHMAALAMACU" -"SMADYAMAI KMAIZEMALONMAQAFMBONEMEEMUMEIZIMELONMENOEMEPETMETEGMETRYMI ROMIEUMM" -"INDUMINGOMISRAMMOTHMPAREMPIREMROCKMSHAEMUCH MUHORMUOY NA PONABLANADA NASHINCO" -"RANEGARNEMKANENOENGENTNGMANNGUE NIEUNNINTHNIS FNNAN NOMIANSIEENSUAENSYONNTHA " -"NTXIVNUENGNZEUMO ANGO BOXO KAIO PLAO RUAOBYLAOCADOOJKI OKARAOKEE OLD XOMBIEOM" -"MAEOPLETOQPENORUTOOTERIOTHALOTTHIOUNCEPASEQPATAKPCHA PEAN PEITHPEN OPEN-PPEPE" -"TPI ROPITERPLHAUPLUTAPLUTOPMUNKPOLI PONSEPPAGEPSILIPTUNEQAAFUQUIRYR-RUBRACHYR" -"AIDARASHARCHIDRDIONREGIAREIWARELA RELAAREPHARICEMRIEENRIEULRILLARITSIROGOMRON" -"OSROTCHROWN RRITORUDAARUHUARULAIRUMP-RUSH RYASOSADHESAKINSAKTASALADSATA SAUIL" -"SEGOLSENTOSHANGSHAR2SHARASHARUSHIMASHOOKSHTINSICLESILA3SKATESOLVESPINESTARTST" -"EP-STNUTSTORMSUKUNSURYASUTUHTEGEHTENSETHINGTIGMATINNETIPPITKAANTMAAUTON ATONP" -"ITORCHTORSOTOYORTRACKTRAIFTRIOLTSADITSEEBTSERETTOCKTTORUTUEUMTURN TUUMUU U UU" -"BITOUBURUUBUTSUDAATUGUSTUKARAUMMERUNGBAUNGGAUNITYUNOO UQUETURINEURITYURTLEUTE" -"UXUTIESUTTHIUWAR VAAVUVARCAVATORVIET VITAEVRIDOVZMETWAAVUWAQFAWASSEWATTOWBOAT" -"WFISHWIANGWIDE WINDUWINJAWISADWU318WUAETXING XTRA-XW XWXYOOJYAMOKYECEKYENAPYI" -"ZETYSTERYURIIZHAINZIDI ZILDEZSEKAZYGOS C D OHM R S WEB-RAY-UM 0 BI0 HO0 JU0 K" -"O0 NI0 PU0 RA0 SA0 WI0 YE0 ZO028B1 DA1 DO1 DU1 GA1 HA1 IN1 KI1 KU1 PO1 QI1 RA" -"1 SA1 SI1 SU1 VU1 YI13582 BU2 KA2 L22 NO2 PE2 QO2 RO2 SO2 VI2 YA3 A33 EE3 JE3" -" JO3 KU3 L33 LE3 ME3 MI3 MU3 PA3 RI3 TA3 YU4 DO4 FI4 KE4 L44 NE4 TE4 TU4 WA4 " -"WI4 ZE5 A25 AN5 AU5 BB5 DE5 FA5 FE5 GI5 IN5 JU5 LI5 MO5 NU5 OO5 TE5 TO5 VA5 V" -"E5 WA5 WE6 DI6 FU6 HE6 HI6 JE6 JO6 L66 LA6 NA6 PO6 QA6 RU6 SE6 WU7 BE7 DA7 DD" -"7 EI7 JA7 KI7 LU7 RE7 TI7 VO7 ZA8 BO8 DU8 EN8 FO8 GU8 JI8 KO8 PI8 QE8 SU8 WE9" -" JA9 PA9 PI9 SE9 SI9 SO9 TA9 TO9 TUA IEA-HAAACUAFELAHADAILMAJORALAIALDAALTAAM" -"LAAN XANAEAPAQAPONARA3ARGIAROOARUMATIMATYAAULABALDBASHBAYIBBITBERDBETHBOOKBOR" -"EBUNGBUOYCANOCASECAYNCHAUCOONCORECRETCWAADAGSDAIRDDAKDDHIDEADDGERDIM2DZHAEAAE" -"EEEEEENUEHEHEIRTEIWSEZZOFAIBFASTFEEMFERZFETHFEUQFFINFIRIFITAFROGFWAAGAAMGAMEG" -"AMLGEDEGGWSGHOMGHWAGIBAGIDAGIEAGIR2GOALGORTGROMGRU GUINHAVEHAYNHEEPHEROHERUHE" -"YNHEYSHEYTHHWAHID HIINHMI HOM HOPHHSDAHSHUHUB2HUENHUVAHWAAIANOIARAIEN IFATIGE" -"RIITOIK HIKIRILUYIMARINORINY IODEIPODIQAAISI JEONJIIMJOT JYAHKAAFKAD3KAKOKALI" -"KAPHKCETKEUPKICKKINIKMA KOBAKOETKOKEKOKOKWAALBUSLFERLFIELIFULIUMLIWNLOLLLOVOL" -"UISLUMNMARUMARYMESOMFAAMIIMMIINMLYAMMU2MPETMUASMUINMVATMWAANAAUNAG NAM2NANANB" -"SPNCERNDAPNDUENEMANEO NGA2NHAYNJAMNNNANOWCNPEANRUANSHENSUBNTAANTOCNUNGNUUNNWA" -"AO-YOOBATOBROODLEOFUMOJI OJODONA ONUTOONEOOTHOPODOPUSORAXORIIOUBTOWAYOXIAPARD" -"PAWNPEEIPEEPPEUXPHABPHINPLUGPLUMPOLOPPHOPRILQASRQEF QHAUQOPARAFERCERREIAREW R" -"GU2RIFYRKABROA ROARROOKROUTRPSERROIRSO-RT TRUISRUKURUNARUSISA-ISAATSEENSEEVSE" -"LASELFSEYESHTASHYASHYESINKSLURSOKASONGSUABTUKITURUTZELUGU UHURULU UNAVUON URU" -"SUSA UTAEUTANUTTYVEDEVEUMVEUXVEYZVIDAVIYOVOS VUEQWAAKWAETWAHAWAIRWAW WDERWULU" -"XEIAXEYNYAWNYCHEYEUXYUDHYUKUYUPIYWAAZATAZAYNZELOZETAZIETZIZ2ZZY 0 E0 U0-004A0" -"B91 X1-01-212114D15518D2-020B2532DD3 D3 I3-030531C4 E4-05 U5-05505575B66-0620" -"6D77 O72C8 A8 I8F09819E3A7AAEFAL2AUJAWXAZUB57B89BIBBXGCA9CAHCAICIGCWICYAD42D7" -"0DA2DE6DIBDJADUBDZEE80EEGEIEEYKEZHF14F8CFAJFLYFOMFUEHAQHOJHOXI-IIMNIWRJEUK00K" -"AQKUEKUGLFALK LULMSPNIIOAYOIXPOQPUQQ00QARQIFQIGQOFQOTQUFSIISUUTJETUJUDYUEZUMX" -"UOPUQAVAUVNOVOKVOYVUUWOQX00XAUXEHXWVY00YOTZJEZOOZORZUPZZE16171D1F343638394048" -"494B4E647890929599C0D0G0G3G9GJLXR7VDVWZ0"; +"M BCAD MAROLLING EYESROUNDED ZEROROWN LETTER RROUND FROM S ABOVE SIGNS SUBPUN" +"CTISSAZ IS ISS ISECTION SIGNSH ZIDA TENUSHED BARLINESHORT RIKRIKSMALL DOUBLES" +"MALL TRIPLESMILING FACESS-THAN SIGNSTICK FIGURESUR OVER SURT ASRAARUHUMT MONG" +"KEUAEQTE SEPARATORTEARS OF JOYTERNATE AYINTHETA SYMBOLTHIC LETTER THREE HEART" +"STIC LETTER NTOP-LIGHTED TRAGRAM FOR TRIPLE DANDATRIPLE FLAMEUBSCRIPT TWOUDA " +"DRACONISUGHT BALLOONUH PLUS GISHULL NOTEHEADUME INTEGRALUN WITH RAYSUNNER FRA" +"ME-UPPER CORNERUSEATED FACEUTH ARABIAN UTH-SLAVEY KVAKRAHASANYAVER EQUAL TOVI" +"CTORY HANDVOLTAGE SIGNWDATA SQUAREWIGGLY FENCEWITH SMALL VWO DISH TENUXIRON K" +"LASMAYAN NUMERAL YMBOL BINDU YMBOL MUEANGYOD TRIANGLEYOUTHFULNESS AND MACRON " +"DECORATION I ZAPYATOY NA MUDGASH OF FLOWERS OF FORTUNE OVER BULUG OVER IDIM " +"PLUS MASH2 PLUS NUNUZ PROPORTION S ZAPYATOY SHOE STILE TIMES ESH2 WITH ARROW " +"WITH CARON WITH COMMA WITH DASIA WITH FLASH WITH JACKS WITH MAPIQ WITH PLATE " +"WITH TITLO WITH TRILL WRIST FLEX-COPPER ORE-MINUS SIGN-OFF SYMBOL0 FOOTSTOOL3" +" LONG NGGO5 LONG MBOO6 LONG NGGEAA AS-SALAAACKED COMMAACTIVE SIGNACUTE-GRAVEA" +"ESCULAPIUSAESHAE NYAMAGAZ DAEG DAGONAL SIGNAILLESS PHIAMUSED FACEARAM GONDI A" +"RM SPIRAL ARMS RAISEDARPEGGIATO ASURE CHESTATH PRODUCTATION POINTATION SPACEB" +"ANK SYMBOLBELL SYMBOLBELOW RIGHTBETA SYMBOLBLACK ARROWBOTTOM MARKBREVE BELOWB" +"UMPY ABOVEBZHI -KHYILC-H DIGRAPHCAN RGYINGSCARET TILDECCUMULATIONCE OF PIZZAC" +"ELANDIC-YRCH AND LAMPCHING CHICKCLOSED JAWSCOMBINATIONCONCAVE ARCCOND SCREENC" +"ONTAIN AS CREDIT SIGNCROSSING BUCROSSING ENCROSSING IMCROSSING PICROSSING URC" +"TION MARK CTION MARK-CURVED BENDDALETH-RESHDASH SYMBOLDE KIKAKUI DENT EMBLEMD" +"ESK PERSONDI ALLAAHU DIATONON DIDOACHASHMEEDOLLAR SIGNDONG TSHUGSDOUBLE AND D" +"OUBLE MARKDOUBLE RINGDOUBLE SHADDUATION CAPDYO CHRONONE WITH VEILE2 TIMES ANE" +"AVER DENE EDICAL MASKEEZING FACEEN STRAIGHTENERGY WAVEENG DIGRAPHENTHESIZED E" +"ORGIAN NAREPIDAUREAN ERCENT SIGNESH DIGRAPHETEI MAYEK ETH DIGRAPHEUNJOMNDEUQF" +"GHANI SIGNFINAL SIGMAFIRE ENGINEFOURTH ROOTGAP FILLER-GAYANUKITTAGE AT NIGHTG" +"ENTLE WINDGHAIN WITH GILE SYMBOLGRAMMA SIGNGRAVE-ACUTEGSUM -KHYILGUISED FACEH" +"AGGAR YAZHHALF-FILLEDHANG KHUDAMHAWH HMONG HEATED FACEHEAVEN MARKHEELED SHOEH" +"IGH STROKEHITE DRAGONHLETIC SHOEHOKHLOM ON HORA DIGIT HREE BALUDAI TIMES BADI" +" TIMES NUNIBLE-CREE YIL FRAGMENTILCROW SIGNILIQUA SIGNIMULTANEOUSIN EQUAL TOI" +"NDERGARTENIPLE TONGUEIRCLED TEXTIRCULAR ARCISIGOTHIC ZIVERY TRUCKIX TWELFTHSJ" +"ECT SYMBOLJIHVAMULIYAJOYOUS LAKEKAARA POLLUKRAINIAN IEKTIESELSKABL OF THREADL" +" TIMES LALLACK SULFURLACKLETTER LATIN CROSSLCE TSA CANLD POLISH OLD SCRIPT XL" +"EAF CLOVERLEEP SYMBOLLEFT DOUBLELEFT SINGLELEFT SYMBOLLETION MARKLEU SATANGAL" +"INE FILLERLON SKEWED LOSED ENTRYLOSING MARKLOTI NAGRI LT OF CLOTHLTED FLOWERL" +"TERNATE AALTERNATE YALU PLUS IGILUPOVODNAYAMACING FACEMBA BAYANNAMBLER GLASSM" +"E LONG CANMED RGYINGSMFON PIPAEMMICAL HEARTMIDDLE BENTMIDDLE HOOKMIDDLE STEMM" +"ONOCULAR OMOVED BELOWMUNCIA SIGNMUUSIKATOANN THE VERGENBLENDED UKND ODD SIGNN" +"D OF PIECENESE SMALL NG LEFT LEGNIKOLSBURG NITIAL IZHENSE CHEEKS NTIMONY OREN" +"UMBER SIGNNUMBER ZERONUN HAFUKHANUSVARA ONENYIS -KHYILOF ENVELOPEOF MASHFAATO" +"HINGYA YEHOLD NUBIAN OM PUSHPIKAOMAN SIYAQ ONIAN SIGN OPPOSING ENOPPOSING IMO" +"R OPERATORORCE SYMBOLORT BARLINEOUBLE ACUTEOUBLE DANDAOUNDED FACEOUNTAIN PENO" +"UTHERN TSEOVERSTRUCK PARAKALESMAPERISPOMENIPHNAEK MUANPIRAL FROM PODCHASHIEMP" +"OST OFFICEPUT MORTUUMQUALS SIGN QUERED FLAGQUIQUADRATERA SOMPENG RACHMA SIGNR" +"AISED FLAGRANSMISSIONRCHAIC JNYAREAKTHROUGHRESPONDS TORIGHT GUARDRIGHT HEAVYR" +"IGHT-HAND RING LIQUIDRIPLE PRIMERISING DOTSRITING HANDROKUTASTI ARONTHISMATAR" +"OR-BARRED ROSS ACCENTRUNNING MANRYVNIA SIGNSECOND MARKSHAAYATHIYASHEQEL SIGNS" +"IMILE SIGNSINGLE AND SMALL CLOUDSPEED TRAINSPIRATED FASSANGKIYEOKSSIMILARITYS" +"TEAMY ROOMSTERED SIGNSTORIC SITESYMBOL VIDJSYURA SASAKT VEGETABLET-H DIGRAPHT" +"A EQUAL TOTAAALAA ANHTENS DIGIT TETRAFONIASTH-THALATHATHAM DIGIT THIRD BLOCKT" +"HIRDS SIGNTHREE TIMESTIEE SHEUOQTIGHT ACUTETONAL MARK TORTED FACETRAIGHT WAWT" +"RESS SIGN TRESVETLAYATRIAN CAMELTRUNCATED ATWO FINGERSTY THOUSANDU ALAYHI WAU" +"-TIGALARI UBLE TONGUEUETTE BREADUG RTAGS GYUISHED FACEULO TWO SUMUMAN FIGUREU" +"NIT DIGIT UNJO WYNN WUPADHMANIYAURRENT SIGNUSHING HANDUTH CORNERSUTING WHALEV" +"A V CHELNUVAMAGOMUKHAVARYS ICHOSVE OF PEACEVERTEX OF VVISARGA ONEVYKA ABOVE W" +"ASLA ABOVEWE PALAUNG WHITE JOKERWING NEEDLEWINKING EYEWITH GARDENWO TWELFTHSX" +"AGRAM FOR XESTES SIGNXI RADICAL XTINGUISHERYEORINHIEUHZERO THIRDSZIGZAG LINEZ" +"ZA WA JALL AND ACUTE AND ARROW AND BREVE AND KNIFE AND MOUSE DRAWINGS IN SQU" +"ARE KABA TENU LATE FORM OF DHARMA OVER KAD5 PLUS SHU2 POVODNAYA RESUPINUS RGY" +"A GRAM SCHROEDER THOUSANDS WITH BARS WITH BASE WITH BELT WITH EGGS WITH LOOP " +"WITH PAGE WITH PLUS WITH RAIN WITH RING WITH TAIL WITH TICK-LUE KARAN-SHAPED " +"HA1 LONG MBE1 PLASTICS2 LONG MBO2 PLASTICS2 PLUS ASH3 PLASTICS4 PLASTICS5 PLA" +"STICS6 PLASTICS7 PLASTICSA PLUS IGIA PLUS KURA TANG LAIAB2 TIMES ABATA TREEAC" +"E FILLERADAK BINDIADDA WITH AEDA-PILLAAILED BIRDAKKHANGYAOALEF LAMEDALEF WITH" +" ALENT SIGNALLY MARK ANDHI MARKANGKHANKHUANGULAR TOAR ECLIPSEARENT CUBEASH TI" +"MES ASPIRATIONASTERISCUSAT HORIZONATRICHISMAATTY WITH AUTOMOBILEAYER BEADSBA " +"SATANGABELOW LEFTBLACK FLAGBLUE HEARTBOLD SHAFTBROKEN BARBSTRUCTIONC WITH DOT" +"CAPITAL ETCH BALLOONCHAD RTAGSCHECK MARKCIRCLED CACISIVENESSCKING FACECOLATE " +"BARCOMPONENT COMPONENT-CROPHONIC CROSS MARKCURLED WAWCURLY HAIRCY MESSAGED KE" +"YBOARDD WITH DOTDA PLUS HADA SATANGADED PERSONDIATONIKI DIGIT ZERODIRGA MURED" +"UOUS TREEE PLUS SUMEARLY FORMEARTH MARKEBENSTIMMEED FIGURE-ED FINGERSEDESTRIA" +"NSEDIC TONE EEKING EYEEICH STARKEIGHTIETHSELT BUCKLEENETRATIONENS SYMBOLENT T" +"OPBARENTHUSIASMEONGCHIEUMEQUIHOPPERETTA-PILLAEUTRAL YEREVEN WITH EVERSED PEF " +"SHE-GOATFAHRENHEITFFICULTIESFINAL HETHFIYAA SIGNFOR RECORDFORMATTINGFRONT WAL" +"LFTOGGOS OUG MUNDARI GAGE CLAIMGAN PEDAL GANDA MARKGAS BZUNG GBAKURUNENGGING " +"FACEGGRAVATIONGHT LIFTERGIMEL-HETHGOLUBCHIK GREE SLASHGUA PI MAOHAAPRAANA HAM" +"ZA MARKHAN DIGIT HEAVY BEATHERMOMETERHOOK ABOVEHOTIC HOOKHREE ABOVEHUNGARIAN " +"I ARCHAIONICAL TAPERIDDLE MARKIDEOGRAPH IED SHRIMPIGATING RAIGATURE OEIKRON I" +"SONILE FOLDERINDEX BENTINDU BELOWING LARGE ING-SHIFT INHERENT AINITIAL RAINUS" +" SIGN ION BOTTLEISMUTH OREIT MBAAKETITH DIGIT IXTHS DISHJALALOUHOUJONG TILE K" +"2 PLUS BUKA SATANGAKAI SYMBOLKINDI MVOPKRYZHEVAYALACK JOKERLANE MERGELE LETTE" +"R LE-DELAYEDLEFT GUARDLEFT HEAVYLEFT LIGHTLEFT SERIFLEFT-HAND LEK ATTAK LENDE" +"D YUSLET SYMBOLLGIZ EOLHXLHAG RTAGSLIGHT BEATLIGHT BULBLIMITATIONLINDRICITYLL" +"OW HEARTLOGICAL ORLONG FINALLONG OVER LONG SIKI LONG TSHEGLOW STROKELOWER HOO" +"KLOWER STEMLPAPRAANA LTERNATE ULTIC CROSSM STALLIONMADDA MARKMALL ALEPHMBININ" +"G DOME PLUS ENMEEM ABOVEMEL SYMBOLMILLE SIGNMINO TILE MONOFONIASMONOGRAM BMON" +"OSPACE MONTH SIGNMOTORCYCLEN NGGEUAETNAKE BELOWNANGMONTHONASPIRATEDNDA PA NJI" +"NDU TEMPLENGLICANA WNOTE WITH NTITY MARKNTO SHRINENUMBER TENOANDAKHIATOCKET S" +"HIPOF HYGIEIAOLING FACEOLON EQUALOMMA BELOWON MEDIAL ON-JUPITEROON LILITHOON " +"SELENAOP NKAARAEOPEN SHELFOPENING UPOROME SIGNORTHERN TAOSSED SHEIOSTAL MARKO" +"TING STAROUND OMEGAOUR FIFTHSOUT INDEX OUTER JOINOUTHERN TAPAO DIGIT PASSIMBA" +"NGPEDAL MARKPLUS BELOWPLUS ERIN2PLUS NAGA POLICE CARPOUND SIGNPPING BIRDPPOPO" +"TAMUSPRALINEAR QUISH QUADR2 PLUS SURAGGISMATARCHAIC KHARDHACANDRARECIPITATERE" +"D DRAGONRESH BELOWREVERSED IRGE CIRCLERGE SQUARERHO SYMBOLRIGHT HOOKRIGHT SIG" +"NRING ABOVERING THUMBRKING FACEROAD OMEGAROEZENIAN ROUND DOT ROUNDED ERROUNDT" +"OP ARSI SYMBOLRUDIMENTA RUPEE MARKSBUB -CHALSCAN LINE-SE-CREE SKSELINE ESHSGO" +"R RTAGSSHARP SIGNSHMIRI YEHSIDEWAYS ISIXTEENTHSSMILO SIGNSPACE MARKSS OF MILK" +"SSANGARAEASSANGPIEUPST PALETTEST-FEEDINGSTRAL SIGNSTROM SIGNSTRUCTION SYLLABL" +"E MT AND BOLTTAIL GLASSTAMAN SIGNTELEVISIONTEMPLATIONTERNATIVE TESE CROSSTHAP" +"ASCAN THDAY CAKETHMIKON N TIMES SIGNTING HEARTTOMIC BOMBTOP CORNERTREFACTIONT" +"RETCHED CTRIPLE DOTTWENTIETHSTWO SHORTSTWO THIRDSTYPE COLONU CIN HAU U2 PLUS " +"BAUAM TSHOOJUARDEDNESSUBLE DASH UM ROTUNDAUMAN EARTHUNG KHEMA UNKIA SIGNUP HA" +"RPOONUP NEUTRALUP OR DOWNUPPER HOOKUPPER STEMUR HUNDREDUR YIG MGOURIPIGMENTUR" +"VED OMETUSEL HORSEUTH OR SPYVASTI SIGNVEL SLIDERVERAGE BOXVIE CAMERAVIOUS PAG" +"EW OR MODELWHITE FLAGWHITE HAIRWHOLE NOTEWING HEARTWITH SPOONWITH STRAWWITH W" +"INGSWO SHORTS XED BICEPSXHEEJ CEEVY AND RICEY CREATUREYEH BARREEYMBOL AIVAYPE" +" PIECE ZAR AMULETZEIRO SIGNZU OVER ZU AND CURL AND TAIL APODEXIA DIVIDERS FRO" +"M BAR GARSHUNI OF BLOOD OF PAPER OVER BAL OVER LUM PLUS GAL PLUS GUD PLUS KU3" +" PLUS LAL PLUS SAG PLUS TUR PLUS ZA7 RA OR RI RICKSHAW SPARKLER STREAMER TIME" +"S HA TIMES UD TROMIKON-AMMONIAC-KHYUD PA-LOW TONE-MID TONE-STACCATO0 LONG LE1" +" CHARIOT2 GARMENT247 DIPTE3 PLUS AN5 BATHTUB5 CYPERUS5 LONG JOA PLUS NAABOVE " +"TO ACE NOTE ACING CARADEG ADEGADMA GDANAF PERSONAFFE FACEAINTBRUSHAISED DOTAJ" +"ANYALANAL RUNOUTALAYALAM ALI GALI ALPAPRANAANEROSIS ANG CITI ANGGEUAETANSKRIT" +" SANTAYALANANTHAKHATAOS ICHOSARCHAIC MARISTERA AS MEMBERATHAMASATATTACHED AVE" +" ARROWB DIGRAPHBASE UNITBASELINE BEER MUGSBIAL SIGNBICYCLISTBING CANEBITE LIP" +"SBKHASIAN BO BAIMAIBO GYFU GBOTH BENTBRUL SHADBTRACTIONCANG TE-UCAPACITORCAPI" +"TAL DCAPITAL ICAPITAL QCARTRIDGECHANICAL CHAVIYANICHOSEONG CLOSED PLCOIN SIGN" +"COMPLETEDCONJOINERCORN FACECQUISITIOCRESCENDOCROUCHINGCUBE ROOTCULTATIOND SAL" +"TIREDENT AND DEPARTUREDIAGONALSDOT RIGHTDOWN HANDDOWN SIGNDOWN STEPDOX CROSSD" +"RAM SIGNDUS RTAGSE AT LEFTEAVY DOWNEBIT SIGNED DIGIT ED PLANETEEN WITH EFAIDR" +"IN EFORMED TEIGHT OF ELEGRAPH ELLOWSHIPEMBEDDINGEMPTY SETENTRE OF ENTRY SAWER" +" BUBBLEERCIAL ATERTY LINEES AKURU ESAME DOTETER SIGNETRASIMOUETTI BALLEURO SI" +"GNFACING UPFEH WITH FINAL MEMFINAL NGAFINAL NUNFISH TAILFLAT SIGNFORTUNA MFOU" +"R BENTFROM WALLG IN HOLEGITTARIUSGREATER YGRIK SIGNGUAGE TAGHAIKSUKI HALF NOT" +"EHALF SIGNHALSHELETHARACTERSHARD SIGNHEADSCARFHI SYMBOLHIMA SIMAHIYYAALAAHOOK" +" MARKHOT SASAKHREE FOR HUMB SIGNHWAZ EH EI PLUS LIIA SYMBOLIALECT-P IBNIZIAN " +"ICE CREAMIDEOGRAM IDEWAYS UIGH HAMZAIGHT LOOPIGN NUKTAIGN SAFHAIGN TOMPIILE T" +"ILDEILIPPINE INAL NOTEINARBORASINCIDENCEINFINITY ING CARD ING DOLLSING GLOVEI" +"NG LANESING STONEINISHMENTINNYIIYHEINSULAR GIRST MARKISEN-ISENIT SYMBOLITRA S" +"IGNIVE WITH IVE-PULL-IVINATIONJERUSALEMK GESTUREKA- SHOG KAMEYTSA KEMPHRENGKI" +"NG BOOTKSTREPTONKU RU KHAKYO TOWERL ME HANDLACKFOOT LAN SIGN LARGEMENTLEFT RI" +"NGLESS TREELIGHTNINGLINE FACELISSANDO LITTLE UPLIVERANCELLABLE B0LLABLE OMLON" +"D HAIRLONG TIP LOWER DOTLVIN SIGNM HE-GOATMAEMGBIEEMALL RINGMARK CIM MARK SHA" +"DMBROIDERYMETOBELUSMHANCHOLLMRACHNAYAMUKPHRENGNA KHONNANCLOSING NDAILING NFOR" +"ZANDONG SANDALNGER ROOTNGER SHIPNGUN SIGNNIGGAHITANIGHT OF NIHSHVASANING SIGN" +"NO TELEIANSERT AT NTERPRISENTESSENCENTRACTIONNUSVARAYANVERTED ROCCLUSIONODIAS" +"TOLEOF STIMMEOKED HEADOKED TAILOKOUFISMAOM SYMBOLON GROUNDON TEUAEQONE MARK-O" +"NE THIRDONG GRAVEONGSEONG ONJUNCTIOONOTYPIC OO DENNENOP HALF OOPEN EYESOPEN J" +"AWSORT-TWIG-ORTH WINDOTAL SIGNOURA SIGNOUT BEAMSOUT MOUTHOUTH WINDOVER GAN2OV" +"ER MUSHOW KAVYKAP DIGRAPHP ELAMITEPAA-PILLAPADE SUITPANYANGGAPENT SIGNPENTASE" +"MEPIDERY HAPLE HEARTPOSITIONSPPOINTED PPOSITIONPROJECTORQUADCOLONQUADRANT-QUE" +"EN OF QUSHSHAYAR PLUS RARCHAIC IIRCHAIC RARCHAIC YERDEL DKARREAK HERERED JOKE" +"RREDNE ON REFORMED RFUL FACERIA ERFE RIED FACERNEY PARARO WIDTH ROJECTIONROTA" +"TION-RPORATIONRTER MARKRTS MEDALRUM CLEF-RWARI DDAS DIGRAPHSEMICOLONSEPTEMBER" +"SHAB CEEBSIVE FACESMALL YUSSOF PASUQSPIRITUS SSANGSIOSSTAL BALLSTEBASKETSTREL" +"NAYAT OF MEATT ON BONETABE SIGNTAKHALLUSTANDSTILLTED PLANTTEH ABOVETHROUGH XT" +"IMES NA2TIMES PAPTO CORNERTONE MAI TRAIGHT UTREDECILETRESVETLOTRISTITIATTED S" +"TEMTUKWENTISTUTEYASATUBSTITUTEUE MAEMBAULL BLANKUMED HEADUNGLASSESUNGSEONG UP" +"PER DOTUPTSTIMMEUR CORNERUR-DE-LISURAMAZDAAURLY LOOPURNED AYBURNED GANURUZ UR" +" UUTRA MARKUURDHAJA UVUZHAKKUVANAGARI VELOPMENTVER LUGALVERLONG AVEUAENGAMVIC" +"E MARKVIGINTILEVINE LEAFVISARGAYAVOCALIC RVOETOCHIEVRAKHIYA WASH TAILWING STA" +"RWITH FACEWORDSPACEWRINKLES WRY SMILEXCITEMENTXHAUSTIONY-FOURTHSYEAR SIGNYEH " +"ABOVEYRANISMA Z DIGRAPHZAKRYTAYAZAL SASAKZENE RINGZERO SIGNZIR SASAK ANTENNA " +"AT DUSK FACING HANDLES KEMBANG LANTANG NUTILLU OF YARN ON LEFT OVER KG OVER " +"MU OVER ZI PLUS DI PLUS DU PLUS RU POLNAYA RASWADI SATCHEL SCOTS S SLIDING TA" +"LENTS TTUDDAG WA-ALAA YUQ NAE-CREE TH-KHIEUKH-PHIEUPH-X BELOW0 BRONZE1 BARLEY" +"1 HELMET3 ARMOUR56 TURO28 KANAKOA SIGN AABAAFILIABOAFILIACKSPACEAEN NYAMAIYAN" +"NOIALLIANCEAMS HORNANC SIGNAND FLATANE TREEANS SIGNAPITAL FAR TSHESARCASITEAR" +"KLEAN ARRIVINGARSI YEHARTYRIA AST WINDASTERN WATAKANA ATE MARKATEBOARDAVY BAN" +"DAY-NIGHTAZHAAKKUBACKWARDBASSINETBATBEIT BER POLEBEVERAGEBIEE FONBILLIONSBINO" +"VILEBLE SIGNBLED CARBLINEAR BOL SIGNBOT FACEBOX TRAYBRA FACEBUNDANCEC SIYAQ C" +"ABLEWAYCAL DISCCANDICUSCASSETTECEILING CER BALLCHATTAWACHINESE CK CHARTCLIMBI" +"NGCOMBINEDCOUNCIL COUNTERSCURLICUECURSIVE D BUBBLED CROSS DAMMATANDANTAJA DDY" +" BEARDIAMONDSDIFONIASDIM GUNUDIT CARDDOCUMENTDS-CREE DUSHENNADVANTAGEDVISVARA" +"E COOKIEE OF POOEBEEFILIECH YIWNED BRICKEGORIAN EK ONKARELEPHANTEN NTEUMENICI" +"AN EOUT BOXER TRUTHERAL URNERDIGRISEREVODKAESH LOOPEST WINDET SHOESETA SIGNET" +"RASEMEEUFEUAETEVEN OF EVERANCEEXCHANGEFEBRUARYFILE BOXFINAL THFLOURISHFOR STO" +"PFRAKTUR FRICAN DGARITIC GBASINNAGENITIVEGERPRINTGLASNAYAGORAZDO GREAT SAHAGA" +"LL HHAN-AKATHARBAHAYHARMONICHESPIAN HIRDEABOHOP BELLHREE OF HT CLOUDI SHAKTII" +"CHAEAN IGHT ARMIGMOID SIMANSIS INAGARI INDUCTORING BELLING BOWLING ROD INOCER" +"OSIRD MARKIS FORM IS WHEELIS-PILLAITA MFONJACK OF JAVIYANIJUNCTIONKAIYARAAKAS" +"RATANKATAKANAL POLISHL-LAKUNALA LENGALAETITIALATION XLEANING LESS SHALESSER Y" +"LF RING LFWIDTH LKULIZMYLOCATIVELONG BARLORRAINELOW STOPLOZHITIELTRY LEGLUB S" +"UITMALL AXEMANDARINMANGALAMMARRATANME BADGEME WITH MEM-QOPHMIONIAN MMATION MO" +"N TIMEMY HOUSEN-JOINERNA METEKNAMENNY NAVIYANINCE SIGNNED FOODNEIFORM NG RTAG" +"SNGRUENCENI ABOVENINE OF NITIAL ZNO SLASHNO THUMBNOTE PADNOVEMBERNRES TOSOBOO" +"FILIOCALIC MOCK SALTOCUS OF ODESTONEOHM SIGNOLLOWINGOM NTEUMOMANIAN OMMA BARO" +"N CROSSONE BEATONE FOR OO TYPE OR MAPIQOREHEAD ORM FEEDOT MBUAEOTIFIED OVER B" +"U OVER GA2OVER GI4OVER SAGOVER SHEOVER TIROVERRIDEPAIRTHRAPAKPAK EPALOCHKAPAR" +"ATED PAVIYANIPENTAGONPLE FLATPRECEDESPROSTAYAPUB DAWBPUN IYEKQAIRTHRAQUINTILE" +"R-RAHMAHRADICAL-RAMMA GGRASMIAN RAT RAI RAUGHTS RDEL NAGREATNESSRED HAIRREE M" +"ARKRESVETLYRILLIONSRIYOOSANROSHTHI ROSSED ORSE DUNGS OCHKOMSALT OF SALTIRESSA" +"NYAKA SE WEDGESENTAGONSEXTANT-SHKIR KASHOE JOTSHORT ERSIFISTONSIGN LAESIGN PV" +"OSIX DOTSSMA SIGNSNA LDANSOFTNESSSPERSIONSQUEEZEDSUCCEEDSSUPERSETSWIMMINGT NG" +"GEETTAALUJA TAI LUE TAR EYESTATASOUETER FACETHOLHOMATHOSCOPETICK IN TISMOS ET" +"O-LEFT TOP LOOPTOWARDS TRI DISHTRICOLONTTENTIONTTO MARKTURNED HTURNED MUAREG " +"YAUATRILLOUBJOINERUDAWADI UKEUTNDAULLS LEGUNDERDOTUNDERTIEUNG DASHUP TRUCKV O" +"VER MVE SASAKVERGENCEVESSEL BVOLUTIONVOMITINGW PRINTSWASH KAFWBOY HATWN HEART" +"WO ABOVEWO BEATSWON SIGNWRINKLEDWRITING XCELLENTY BEETLEY POPPERYAMAKKANYBEYF" +"ILIYENISEI YER YAGHYESIEUNGYIDDISH YPORROONYRILLIC ZAKRYTOEZWARAKAYZWJ THAJ A" +"PLOUN BUTTON CER-WA FLEXUS ISLAND KEFULA LONSUM MAELEE MENDUT MINUS MUOMAE M" +"UQDAM OCLOCK OPEN-O PLOPHU RAMBAT SHAKER SLOWLY STRIDE TAMURA TEDUNG WAAJIB W" +"OLOSO-CREE R-KIYEOK-MACRON-MU-MO--SHIFT--THIRTY-TIKEUT-WELSH 0 SPEAR0 WHEAT1 " +"ARROW2 OLIVE2 WOMAN26 EYYY3 AREPA3 EIGHT3 MONTH3 OMEGA3 SPICE3 SWORD3 WHEEL5 " +"NGGEE6 NGGOO7 NGGUA7 NGUAN9 CLOTH9 NGGAAA -PHRUA NAME ACTER TAD NECKAELAENGAE" +"TMEUNAHAPAKHALESMA ALLOT XALTILLOAM ALEFAN MARKAND ENDANDERERANGKUOQANGLED AN" +"GLONGANGOLATAPEZIUMARDNESSARRED BARRED OAS SIGNASHTRA ASUTORUATAEAN ATH OF AU" +" MARKAULDRONAUNTLETAXIMATAAY SIGNBAIRKANBAMBOOSBARREKHBASIGNABERGINEBERRIESBI" +"G YUSBLACHKOBLOSSOMBOARDERBOOSTERBORZAYABOURINGBREVIS BUFFALOBULANCECABINETCA" +"P TENCAYANNACELSIUSCHEINAPCHIEUCHCK LIMECLEAVERCLOSE ECLOTHESCOMING CONTACTCO" +"PTIC CRACKERD MADDADA FACEDANCINGDANESE DAYANNADEAVOURDHALATHDIARGONDIPLOUNDI" +"SIMOUDOFONONDRIL BUDU NJAADYNAMICE DRINKE GLASSEAD OREEAGULL EAVY YAECEMBERED" +" RICEEFT ARMEFT TIEEIGHT KEL PUMPEM DASHEN LEAFENSHUETER THANERNIN AESTIVALET" +"NAHTAEULEUNGF DAVIDF SASAKFATIGUEFAYANNAFINAGH FINAL YFLUENCEFORKINGGAYANNAGE" +"NERALGHEUGHEGLAGOLIGO-KARTGOLIAN GRADUALHAARKAAHALANTAHANGUL HAYANNAHEADINGHE" +"XAGONHI SIGNHIOPIC HIUCHUSHODDONDHYAAUSHI NTEUMI RTAGSIANGQI IBIFILIIC WANDIC" +"OPTERICYCLESIKHAHITIL DRUMILLEANNIMILAR INNABARIRRUP RISIBLE ITALIC ITON RAIV" +"E OF JAIN OMJARATI JAYANNAJECTIVEJERAN JJIBWAY KARO BAKAYANNAKEUAERIKHA YATKK" +"URUNIKOMBUVAKOQNDONKORONISKPAK WAKUTAARUKYLISMAL SEGNOLAGIOS LAK-050LAMITE LA" +"SHES LAYANNALE LEAFLEK TOOLENGTH-LEUT KALEYBALLLF FACELIGHT XLJUDIJELLYFISHLO" +"SION LYGISMAMAAYYAAMAI SATMANCHU MARCATOMASSAGEMBOL B0MEETORUMERICASMINGKALMI" +"NIMA MONSTERMRACHNYMUNGKAHNANCIALNATE EENAYANNANEQUDAANESTED NG MASKNIKAHITNJ" +"AEMLINSTRESSNUMBERSOCTAGONOCTANT-OCTOBEROF SOAPOFFICEROGDIAN OKRYTIEOLAPUK OM" +"ERANGON FACEONG UEXONGONANONTIEENOP MARKORCULUSOREVMA ORKHON ORTIETHOT NGOMOT" +" REPHOUR OF OUT HUBOUTWARDOVER ANOVER DUOW ALEFOWILO SOX BACKOX LINEP PIEETPA" +"LLAWAPANESE PANSIOSPARERENPAYANNAPAYEROKPECTIVEPEGERMAPENGKALPERVISEPHUTHAOPL" +"OYAN POMOFO POVODNYPPROACHPRENKHAPSTICKSPTHAHA PURPLE PUSHPINQUARIUSQUEEZE R2" +" GUNURA REPARAKHANGRANGKEPRARIETYRAYANNARD FACERDO RJEREATHY REREKANRESILLORI" +"PPLE RISIMOUROGRESSROKEN LRRECTUSRTHIAN RY FACES-SAJDASA VAH SAMPHAOSANDHI SA" +"NGAN SAYANNASCOOTERSCRUPLESEXTILESHAKINGSHIFT TSHORT ASIDDHAMSIGN UDSOLDIERSO" +"V ROGSPRINGSST TUBESTERINGSUKUUDOSYNAGMAT ASHESTA MARKTAISYOUTALL AATASHEELTA" +"YANNATCHFORKTHALIYATHESEOSTHIEUTHTHKUQI TIKRAMATIVATE TORNADOTRAINERTROLLEYTR" +"YASKATSECHKATTHACANTTILIK TYSCAPEUBUFILIUKKAKHAUKOTHEAUM IYEKUN MEUTUP HANDUP" +" MARKUP SIGNUP STEPUP TACKURATIONURFACE URGLASSUSSYERUUYGHUR VANESE VAPOURSVA" +"V YODVAYANNAVE DOT VEMENT-VEW NOWVILIK BVILLAINVOICINGVOWEL KVYSOKO W SLASHWA" +"Z EOHWDRIVERWIFRUITWIGNYANWO FOR WO MARKWO WAENWORSHIPXAM LAIXOPHONEY GREENY " +"HEARTYA LAMPYAH LI YANMAR YAYANNAYELLOW YMAIC LYNAMIC ZQAPHA AGUNG DIPLI EPO" +"CH EQUID FACE- GATE KAPAL LELET LONGA MELIK MURDA QATAN SPLIT TACK TIKHY-HI" +"DET-HIEUH-IEUNG-LINE--PIEUP0 NGGI0 NGGO0 NYON0 NYUN00-1021 GBOO1 GOLD1 HORN1 " +"NDEE1 WINE2 KPOO2 NGGU3 GBEE3 HEEI3 NGGA4 DART4 DEER4 KPEE4 MUAN4 NGEN4 NJOO4" +" NYIN5 MERI5 WOOL6 GUEI6 HUAN6 NGGE6 TREE7 GUAN7 KAPO7 MBEE7 MBUU7 NDOO7 NGON" +"8 HOOU8 MBEE8 NYAN8 NYEN9 MUEN9 NJEEA HAAMA-KARAAASHAEACINTHAEMMAEAESURAAFFIX" +" AGOGUEAGRANTAILUREAJANI AK-668AKABATANCHORANGKATANIMALANUARYAPISMAAPLI MAPYR" +"USARADDOARBUTAARSEOSASHGABASSINGATTERYATTIC AUTUMNBAFILIBANWA BEFILIBETAN BGB" +"IEEBISCUSBISHOPBLINK BOFILIBOWTIEBUFFERBURGERCALATECASTLECATAWACEVITUCHADINCH" +"AMKOCHEIKHCHEMA CHESS CHIKI CHIRETCHO CHCHURCHCKNESSCLOSETCODILECRAYONCREASEC" +"UMBERCUPPEDD DISKDAGGERDE DOGDERMA DGEHOGDICINEDIESISDOKMAIDSLIDEDUCEUSDVANCE" +"E WAVEEAHMUKED CAPED ICEEENTH-EIGHTYELLITEEMASTIEMPUS EN GHEENIKI ENTIMAEPACT" +" ERBOLAERTUREESTAN ET KUTEU MBUEUAENAEUNYAMEUREUTEVENTHEXHALEEXISTSEYANNAF CL" +"EFF MAREFAMILYFATHA FF OF FIZAHUFORMEEFORTISFRAMESG CLEFGANGIAGBASAQGEADALGED" +"OLAGGLINGGHAMALGHETTIGHEUAEGLAZ HGNANT GO NGUGOBLINGORGONGRASP GS-PA GURAMUHA" +"LF HHAM AIHAMEDHHAMILOHASHKAHE MGOHECAKAHEISEIHENOPEHERMESHEUAEPHIBIT HINGE H" +"IVETEHO HOIHORT IHUMBS HUR PAI HOOKI MAIMIASMA IB YAMIDE ESIEVAN IGGLESILBOAT" +"ILLAGEINAGMAINCUNXINDHI INGAATINHALEINPUTSINSHIPINWARDIRINGUISSANTISSHARISSIM" +"OITABLEITHER ITRITEITULUMIX OF IXTY PIYANNAKABBIRKAYAH KE PHOKEYCAPKILLERKLIT" +"ONKRISISKTIKO KUSHU2KY WAYLAFRONLAMADHLAMEDHLANDERLASTONLD MAPLEVEL-LIGIONLIG" +"ON LISHA LITIKILLIPOPLOACHALONG EM BOARM BULLMADDAHMADR MMALL FMANYA ME DIEME" +"CHIKMPLINGMUKHI N DASHN YANGN-NISFNACLESNCH FRNDA TANEUME NGBAT NGGONGNIRUGUN" +"ISTERNIZKO NKNOWNNOKHUKNOR BUNOWMANNOZHEKNSANAQNSUZ ANTEVMANTIIMUNTOGENOBELOS" +"OCENCEOCIETYODHADHOFOUNDOGONEKOITIC ON KEYONOCLEOOMUUTOPEN DOPEN POPITSAOPULU" +"SOSETTEOW TIEPALUTAPBOARDPEAKS PECIALPENCILPEPPERPICKETPIDER PIRIT POKOJIPOME" +"NEPOMMEEPTACLEPUFFEDPWATCHQAMATSQETANARAAKANRACINGRAKLITRAVEL-RBITSARCHEN REM" +"EDYRENGTHRICORNRIISAPRIPT GRISEMERKAANUROCKETRSENICRSHANARSIAN RUBEUSS SHOES " +"TENTSAADIYSHAYIMSHMAAMSICKLESIXTHSSKAPI SOUNAPSPADESSPATHISPITALSSLESSSTANCES" +"TANCYSTLERSSTOLI STROFOSUCKEDSURANGSURED SWORDSSYNAFISYOUWAT NJAQTAIKHUTAMING" +"TARGETTARTARTAU ROTAUROSTE TSETE USETERON TEUWENTHAKKUTIKENOTIMATETIRYAKTRAPL" +"ITRIKE TURBANTUXEDOU MBITUAEQTUUANGXIUBLE XUCIBLEUDARKAUDDISAUGGAGEUPNAYAURAN" +"USURNAMAUUMISHUYANNAUZEIROVERTKAVILIANVIRIAMWBERRYWEORTHWINDOWWN BOWWN BOXWO " +"OF WORKERWRENCHX FACEXIMIZEXO NEOYAKASHYIN-DOYOMBO YRENE YSTICKZHITSA AMPS BO" +"W CAPO CHWV COAT DEKA FUJI GORA HAA ICON ILUT JERA KAWI LACA MOOD SARI TABS" +" TELU-ALAF-BEAM-SIOS0 BEE0 DOO0 DWO0 GBO0 GEE0 HAN0 HEE0 JOO0 MAN0 OIL0-VAS1 " +"DWE1 FAN1 PEE1 TEE1 TWO1 WVI1 YOO1-VAS18CFF2 HEN2 HOO2 KPA2 KPI2 MBA2 MBE2 MB" +"O2 MBU2 NJA2 NJU2 POO2 PTE2 SEE2-VAS3 BOO3 FOO3 HIN3 HON3 NDI3 RA33 VEE3 WEI3" +"-VAS32 JE4 ABB4 GBI4 KPU4 LEE4 LOO4 MBO4 MON4 NDO4 TOO4 VOO4 WOO4 WUI4-VAS5 K" +"EE5 MBI5 NDU5-VAS6 GBA6 KOO6 RA26 SIA6 SOO6 TA26 WEE6-VAS7 FUA7 GBE7 HUN7 JEE" +"7 MIN7 NEN7 NIN7 TWE7-VAS8 FEE8 GBU8 KPE8 KPO8 MAN8 NAN8 NWA8 RO28-VAS9 DEE9 " +"KUA9 MEN9 MUN9 NDA9 NDE9 NON9 NUN9 PU29 WVA9 WVE9 YEE9-VASA UNAA YUEAADHUAAMA" +"EACHKAADDERADULTAEMAEAEPENAEREEAGMA ALFILALGARALLEYALLI ALOG ALPHAAMBDAAMEKHA" +"NGELANNONAPPLEAR AEARBAIARERUASAR ASEIAASPERATAF ATIYAAUTHSAVROSAWAY BAARUBAC" +"USBALAGBASA BAWAKBEITHBENDEBHADHBHETHBISAHBLAKOBOOTSBORZYBSTERCAANGCAKESCAKRA" +"CALYACANUSCAUDACAUSECCEPTCCOLICECAKCECEKCEREKCHADACHERYCHIMECHOOICHOOLCHORDCH" +"ULACHUTECIEUCCKAGECKTIECLIFFCLONECLUBSCROWNCTRICCUBEDDAIC DATUSDBOATDELTADEPT" +"HDESTYDHAM DKAR DLINGDOTS-DSMANDWICHE GEEEAGLEEBALLEESHIEGALIEGIONEGL HEIDONE" +"ISMAEKEETEMAKEEMBICEMLJAENANOENDEPENENGENJETEO-EUEOPLEERINEERKHAESHE3ESO EET " +"TUETFONEUAEMEURAEEYBUSEYYALF COWF EWEF SOWFAAFUFAIHUFEARNFITKOFLAGSFLICTFLUTE" +"FORCEFSAAQGADOLGALGAGAMALGAMANGAZE-GEAN GESH2GHNUTGHULUGOGI GORGIGULUSGVANGHA" +"ALUHADDAHAINUHALA HALQAHAMSOHANNAHASE-HATHIHAYINHELAPHETHEHIMELHIRIQHISTIHIUT" +"HHOLAMHOLARHOTELHROOMHUMP HUTA I KOII-RESIARDSIAUDAICHONICRONIENTEIHVUSIKARAI" +"KURUILVERIMAHUIMGBAIMMA IMMERINGSAINNA INTHUIPEHAIPINGIRACYISTLEITHI ITUALJAN" +"G JERVIJUDGEJUDULJUEUIK-020KARORKBALLKERETKESH2KHAPHKNOBSKO LAKTOP KURONKUSMA" +"KWAENL NETL-JUZLABATLABORLAGUSLAKKOLAMDALATIKLAYARLEASELENISLOAN LOMKALOURELU" +"RALLWAY M RAMMAAEHMAALAMACUSMADYAMAI KMAIZEMALONMAQAFMBONEMEEMUMEIZIMELONMENO" +"EMEPETMETEGMETRYMI ROMIEUMMINDUMINGOMISRAMMOTHMPAREMPIREMROCKMSHAEMUCH MUHORM" +"UOY NA PONABLANADA NASHINCORANEGARNEMKANENOENGENTNGMANNGUE NIEUNNINTHNIS FNNA" +"N NOMIANSIEENSUAENSYONNTHA NTXIVNUENGNZEUMO ANGO BOXO KAIO PLAO RUAOBYLAOCADO" +"OJKI OKARAOKEE OMBIEOMBUSOMMAEOPLETOQPENORUTOOTERIOTHALOTTHIOUNCEP BOWPASEQPA" +"TAKPCHA PEAN PEITHPEN OPEN-PPEPETPI ROPLHAUPLUTAPMUNKPOLI PONSEPPAGEPSILIPTUN" +"EQAAFUQUIRYR-RUBRACHYRAIDARASHARCHIDRDIONREGIAREIWARELA RELAAREPHARICEMRIEENR" +"IEULRILLARITSIROGOMRONOSROTCHRRITORUDAARUHUARULAIRUMP-RUSH RYASOSADHESAKINSAK" +"TASALADSATA SAUILSEGOLSENTOSHANGSHAR2SHARASHARUSHIMASHOOKSHTINSICLESILA3SKATE" +"SOLVESPINESTARTSTEP-STNUTSTORMSUKUNSURYASUTUHTEGEHTENSETHINGTIGMATINNETIPPITK" +"AANTMAAUTON ATONPITORCHTORSOTOYORTRACKTRAIFTRIOLTSADITSEEBTSERETTOCKTTORUTUEU" +"MTURN TUUMUU U UUBURUUBUTSUDAATUGUSTUKARAUMMERUNGBAUNGGAUNITYUNOO UQUETURINEU" +"RITYURTLEUTEUXUTIESUTTHIUWAR VAAVUVARCAVATORVIET VITAEVRIDOVZMETWAAVUWAQFAWAS" +"SEWATTOWBOATWFISHWIANGWIDE WINDUWINJAWISADWU318WUAETXING XTRA-XW XWXYOOJYAMOK" +"YECEKYENAPYIZETYSTERYURIIZHAINZIDI ZILDEZSEKAZYGOS C D OHM R S WEB-RAY-UM 0 B" +"I0 HO0 JU0 KO0 NI0 PU0 RA0 SA0 WI0 YE0 ZO028B1 DA1 DO1 DU1 GA1 HA1 IN1 KI1 KU" +"1 PO1 QI1 RA1 SA1 SI1 SU1 VU1 YI13582 BU2 KA2 L22 NO2 PE2 QO2 RO2 SO2 VI2 YA3" +" A33 EE3 JE3 JO3 KU3 L33 LE3 ME3 MI3 MU3 PA3 RI3 TA3 YU4 DO4 FI4 KE4 L44 NE4 " +"TE4 TU4 WA4 WI4 ZE5 A25 AN5 AU5 BB5 DE5 FA5 FE5 GI5 IN5 JU5 LI5 MO5 NU5 OO5 T" +"E5 TO5 VA5 VE5 WA5 WE6 DI6 FU6 HE6 HI6 JE6 JO6 L66 LA6 NA6 PO6 QA6 RU6 SE6 WU" +"7 BE7 DA7 DD7 EI7 JA7 KI7 LU7 RE7 TI7 VO7 ZA8 BO8 DU8 EN8 FO8 GU8 JI8 KO8 PI8" +" QE8 SU8 WE9 JA9 PA9 PI9 SE9 SI9 SO9 TA9 TO9 TUA IEA-HAAACUAFELAHADAILMAJORAL" +"AIALDAALTAAMLAAN XANAEAPAQAPONARA3AROOARUMATIMATYAAULABALDBASHBAYIBBITBERDBET" +"HBITOBOOKBOREBUNGBUOYCANOCASECAYNCHAUCOONCORECRETCWAADAGSDAIRDDAKDDHIDEADDGER" +"DIM2DZHAEAAEEEEEEENUEHEHEIRTEIWSEZZOFAIBFASTFEEMFERZFETHFEUQFFINFIRIFITAFROGF" +"WAAGAAMGAMEGAMLGEDEGGWSGHOMGHWAGIBAGIDAGIEAGIR2GOALGORTGROMGRU GUINHAVEHAYNHE" +"EPHEROHERUHEYNHEYSHEYTHHWAHID HIINHMI HOM HOPHHSDAHSHUHUB2HUENHUVAHWAAIANOIAR" +"AIEN IFATIGERIITOIK HIKIRILUYIMARINORINY IODEIPODIQAAISI JEONJIIMJOT JYAHKAAF" +"KAD3KAKOKALIKAPHKCETKEUPKICKKINIKMA KOBAKOETKOKEKOKOKOTOKWAALBUSLD XLFERLFIEL" +"IFULIUMLIWNLOLLLOVOLUISLUMNLUTOMARUMARYMESOMFAAMIIMMIINMLYAMMU2MPETMUASMUINMV" +"ATMWAANAAUNAG NAM2NANANBSPNCERNDAPNDUENEMANEO NGA2NHAYNJAMNNNANOWCNPEANRUANSH" +"ENSUBNTAANTOCNUNGNUUNNWAANZE O-YOOBATOBROODLEOFUMOJI OJODONA ONUTOONEOOTHOPOD" +"OPUSORAXORIIOUBTOWAYOXIAPARDPAWNPEEIPEEPPEUXPHABPHINPLUGPLUMPOLOPPHOPRILQASRQ" +"EF QHAUQOPARAFERCERREIAREW RGU2RIFYRKABRLEWROA ROARROOKROUTRPSERROIRSO-RT TRU" +"ISRUKURUNARUSISA-ISAATSEENSEEVSELASELFSEYESHTASHYASHYESINKSLURSOKASONGSUABTUK" +"ITURUTZELUGU UHURULU UNAVUON URUSUSA UTAEUTANUTTYVEDEVEUMVEUXVEYZVIDAVIYOVOS " +"VUEQWAAKWAETWAHAWAIRWAW WDERWULUXEIAXEYNYAWNYCHEYEUXYORIYUDHYUKUYUPIYWAAZATAZ" +"AYNZELOZETAZIETZIZ2ZZY 0 E0 U0-004A0B91 X1-01-212114D15518D2-020B2532DD3 D3 I" +"3-030531C4 E4-05 U5-05505575B66-06206D77 O72C8 A8 I8F09819E3A7AAEFAG-AL2AUJAW" +"XAZUB57B89BIBBXGCA9CAHCAICIGCWICYAD42D70DE6DIBDJADUBDZEE80EEGEIEEYKF14F8CFAJF" +"OMFUEHAQHOJHOXI-IIMNIWRJEUK00KAQKUEKUGLFALK LULMSPNIIOAYOIXPOQPUQQ00QARQIFQIG" +"QOFQOTQUFREXSIISUUTJETUJUDYUEZUMXUOPUQAVAUVNOVOKVOYVUUWOQX00XAUXEHXWVY00YOTZJ" +"EZOOZORZUPZZE16171D1F34363839404548494B4E60647890929599C0D0G3G9GJLXR7VDZ0"; -static const unsigned char uname2c_tree[222744] = { - 0xa1, 0xa8, 0xbe, 0x0c, 0xa2, 0x81, 0xb5, 0x0b, 0xa3, 0xc7, 0xe2, 0x09, - 0xa4, 0xec, 0xaf, 0x09, 0xa5, 0x9d, 0xe6, 0x08, 0xa6, 0x88, 0xd8, 0x08, - 0xa7, 0xd7, 0x90, 0x08, 0xa8, 0x90, 0xc6, 0x07, 0xa9, 0xff, 0xb0, 0x07, - 0xaa, 0x84, 0xab, 0x07, 0xab, 0xaa, 0xf4, 0x06, 0xac, 0x9d, 0xe7, 0x05, - 0xad, 0x9c, 0xbe, 0x04, 0xae, 0xa1, 0x98, 0x04, 0xaf, 0xb2, 0xe9, 0x03, - 0xb0, 0xb0, 0xbc, 0x03, 0x02, 0x7c, 0x00, 0x83, 0xbb, 0x03, 0xb2, 0x86, - 0x98, 0x03, 0xb3, 0xfd, 0x89, 0x02, 0xb4, 0xef, 0x8d, 0x01, 0xb5, 0xc5, - 0x7e, 0xb6, 0xfe, 0x56, 0xb7, 0x94, 0x40, 0xb8, 0x9a, 0x3f, 0xb9, 0xec, - 0x10, 0xba, 0x01, 0xff, 0x0a, 0xac, 0x1d, 0x82, 0x10, 0x10, 0xed, 0x60, - 0x99, 0x0c, 0xa5, 0xea, 0x0b, 0x50, 0x1d, 0x64, 0x10, 0xf9, 0x01, 0x08, - 0xa1, 0xc8, 0x1f, 0x45, 0xae, 0xe9, 0xdf, 0xf9, 0x01, 0xb7, 0x01, 0xff, - 0xea, 0x0d, 0x20, 0x00, 0xae, 0x06, 0x42, 0x2b, 0x0d, 0x0b, 0x20, 0x40, - 0x43, 0x86, 0xf1, 0xff, 0xfe, 0x00, 0xea, 0x0c, 0x20, 0x40, 0x0a, 0x48, - 0x59, 0xaa, 0x07, 0x06, 0x5c, 0xde, 0x23, 0x11, 0x55, 0x5d, 0x01, 0xff, - 0x4e, 0x0c, 0x77, 0x44, 0xcf, 0x01, 0x45, 0x65, 0x88, 0x45, 0xcf, 0x01, - 0x06, 0xcc, 0xdd, 0x06, 0x43, 0x06, 0x2f, 0x46, 0xcf, 0x41, 0xd2, 0x42, - 0xcf, 0x01, 0xd3, 0x43, 0xcf, 0x41, 0x02, 0x6d, 0x14, 0xf2, 0x06, 0xa4, - 0xcf, 0x06, 0x44, 0xf1, 0xef, 0x83, 0xcf, 0x01, 0x0a, 0x08, 0xab, 0xa3, - 0x06, 0xab, 0xf1, 0x05, 0x46, 0x26, 0xde, 0xa7, 0xcf, 0x81, 0xca, 0x05, - 0x45, 0x22, 0xe9, 0xc2, 0xcf, 0x01, 0xaf, 0x8d, 0x05, 0xb0, 0xda, 0x04, - 0xb2, 0xcb, 0x04, 0xb3, 0x4f, 0x09, 0x55, 0xc1, 0x17, 0xba, 0x01, 0xff, - 0xa1, 0x06, 0x46, 0x1e, 0xbb, 0x85, 0xcf, 0x41, 0x46, 0x98, 0xde, 0x55, - 0xcf, 0x01, 0x47, 0xb7, 0x32, 0x5d, 0xcf, 0x41, 0x0c, 0x45, 0x8b, 0x18, - 0x49, 0x33, 0xbc, 0x64, 0xcf, 0x01, 0x48, 0x11, 0xca, 0x63, 0xcf, 0x01, - 0x48, 0xf6, 0x54, 0x65, 0xcf, 0x01, 0x4b, 0xea, 0xa3, 0x66, 0xcf, 0x41, - 0x49, 0x33, 0xbc, 0x68, 0xcf, 0x01, 0x48, 0x11, 0xca, 0x67, 0xcf, 0x01, - 0x48, 0xf6, 0x54, 0x69, 0xcf, 0x01, 0x4b, 0xea, 0xa3, 0x6a, 0xcf, 0x41, - 0x09, 0x1c, 0xbb, 0xa3, 0x03, 0x48, 0x21, 0xc8, 0x7d, 0xcf, 0x81, 0x82, - 0x03, 0xb4, 0x01, 0xff, 0x44, 0x45, 0xef, 0x86, 0xcf, 0x81, 0xac, 0x02, - 0x46, 0x04, 0xdf, 0x56, 0xcf, 0x81, 0x95, 0x02, 0x05, 0x6c, 0xea, 0x01, - 0xff, 0x09, 0x58, 0x82, 0xe8, 0x01, 0x04, 0x31, 0xf0, 0xae, 0x01, 0xab, - 0x42, 0x4e, 0x1c, 0x7a, 0x93, 0xcf, 0x01, 0x4e, 0x59, 0x69, 0x97, 0xcf, - 0x01, 0xb0, 0x20, 0xb4, 0x01, 0xff, 0x4e, 0x86, 0x78, 0x9a, 0xcf, 0x01, - 0x05, 0xc6, 0xea, 0x01, 0xff, 0x48, 0x91, 0xc6, 0xac, 0xcf, 0x01, 0x49, - 0x53, 0x9f, 0xad, 0xcf, 0x01, 0x49, 0x9c, 0xbf, 0xae, 0xcf, 0x41, 0xaf, - 0x06, 0x47, 0x12, 0xca, 0x92, 0xcf, 0x41, 0x4b, 0x51, 0x9f, 0x95, 0xcf, - 0x01, 0x47, 0x55, 0x9f, 0x96, 0xcf, 0x41, 0x06, 0x46, 0x8b, 0x5a, 0x02, - 0x83, 0x0a, 0x01, 0xff, 0x47, 0xee, 0x54, 0xb5, 0xcf, 0x81, 0x06, 0x47, - 0x91, 0xac, 0x94, 0xcf, 0x41, 0x80, 0x01, 0xff, 0x04, 0x31, 0xf0, 0x0c, - 0x49, 0x53, 0x9f, 0xb6, 0xcf, 0x01, 0x47, 0xa7, 0xd6, 0xbe, 0xcf, 0x41, - 0x44, 0x63, 0x69, 0xb9, 0xcf, 0x81, 0x28, 0xaf, 0x01, 0xff, 0x4a, 0x8e, - 0xac, 0xbc, 0xcf, 0x81, 0x18, 0x49, 0x53, 0x9f, 0xba, 0xcf, 0xc1, 0x00, - 0x06, 0x50, 0x00, 0x01, 0xff, 0x50, 0x4d, 0x62, 0xbb, 0xcf, 0x01, 0x50, - 0xae, 0x32, 0xb8, 0xcf, 0x41, 0x4a, 0x26, 0xa6, 0xbd, 0xcf, 0x41, 0x56, - 0xa8, 0x32, 0xb7, 0xcf, 0x41, 0x4e, 0x59, 0x69, 0x99, 0xcf, 0x01, 0x49, - 0x53, 0x9f, 0x98, 0xcf, 0x41, 0x44, 0x63, 0x69, 0xa2, 0xcf, 0x81, 0x28, - 0xaf, 0x01, 0xff, 0x4a, 0x8e, 0xac, 0xa5, 0xcf, 0x81, 0x18, 0x49, 0x53, - 0x9f, 0xa3, 0xcf, 0xc1, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x50, 0x4d, - 0x62, 0xa4, 0xcf, 0x01, 0x50, 0xae, 0x32, 0xa1, 0xcf, 0x41, 0x4a, 0x26, - 0xa6, 0xa6, 0xcf, 0x41, 0x56, 0xa8, 0x32, 0xa0, 0xcf, 0x41, 0x43, 0xbb, - 0x32, 0x9b, 0xcf, 0x81, 0x16, 0xaf, 0x01, 0xff, 0x4a, 0x8e, 0xac, 0x9c, - 0xcf, 0x01, 0x49, 0x53, 0x9f, 0x9d, 0xcf, 0xc1, 0x00, 0x4c, 0x44, 0x8b, - 0x9f, 0xcf, 0x41, 0x4c, 0x44, 0x8b, 0x9e, 0xcf, 0x41, 0x80, 0x01, 0xff, - 0x48, 0xb1, 0xca, 0x57, 0xcf, 0x01, 0x54, 0xfb, 0x46, 0x5a, 0xcf, 0x41, - 0x80, 0x01, 0xff, 0x4e, 0x59, 0x69, 0x91, 0xcf, 0x01, 0x02, 0x31, 0x01, - 0x0d, 0x49, 0xdc, 0xc1, 0x8b, 0xcf, 0xc1, 0x00, 0x4b, 0xe2, 0x97, 0x8c, - 0xcf, 0x41, 0x50, 0x6d, 0x62, 0x8e, 0xcf, 0x01, 0x47, 0x65, 0x88, 0x88, - 0xcf, 0x81, 0x1e, 0x45, 0x94, 0xea, 0x8d, 0xcf, 0x01, 0x48, 0x8d, 0x97, - 0x87, 0xcf, 0xc1, 0x00, 0x03, 0x99, 0x08, 0x01, 0xff, 0x47, 0x65, 0x88, - 0x89, 0xcf, 0x01, 0x4b, 0x82, 0xa1, 0x8f, 0xcf, 0x41, 0x4b, 0x8a, 0x97, - 0x8a, 0xcf, 0x41, 0x80, 0x01, 0xff, 0x02, 0x31, 0x01, 0x06, 0x48, 0x19, - 0xcd, 0x7f, 0xcf, 0x41, 0x47, 0x65, 0x88, 0x80, 0xcf, 0x01, 0x48, 0x8d, - 0x97, 0x7e, 0xcf, 0x41, 0x0d, 0x58, 0x82, 0x36, 0x07, 0x45, 0x8b, 0x1b, - 0x49, 0x33, 0xbc, 0x71, 0xcf, 0x01, 0x48, 0xf6, 0x54, 0x72, 0xcf, 0x01, - 0xb4, 0x01, 0xff, 0x46, 0x86, 0x78, 0x74, 0xcf, 0x01, 0x4a, 0xeb, 0xa3, - 0x73, 0xcf, 0x41, 0x4e, 0x59, 0x69, 0x77, 0xcf, 0x01, 0x05, 0xf1, 0x54, - 0x01, 0xff, 0x48, 0xf6, 0x54, 0x76, 0xcf, 0x01, 0x47, 0x23, 0x7a, 0x78, - 0xcf, 0x41, 0x4b, 0x45, 0x8b, 0x7c, 0xcf, 0x01, 0x4e, 0x59, 0x69, 0x7b, - 0xcf, 0x01, 0x48, 0x11, 0xca, 0x79, 0xcf, 0x01, 0x48, 0xf6, 0x54, 0x7a, - 0xcf, 0x41, 0x52, 0x9e, 0x51, 0x6c, 0xcf, 0x01, 0x42, 0xdd, 0x18, 0x82, - 0xcf, 0x41, 0xa1, 0x1c, 0x48, 0xe9, 0xc5, 0x58, 0xcf, 0x81, 0x0f, 0xaf, - 0x01, 0xff, 0x48, 0x84, 0xa1, 0x70, 0xcf, 0x01, 0x48, 0xf1, 0xc7, 0x90, - 0xcf, 0x41, 0x4f, 0x58, 0x69, 0x59, 0xcf, 0x41, 0x43, 0xee, 0x84, 0x5c, - 0xcf, 0x01, 0x46, 0x8e, 0xdf, 0x52, 0xcf, 0x01, 0x42, 0x90, 0x08, 0xc3, - 0xcf, 0x41, 0x45, 0xef, 0xe4, 0xc0, 0xcf, 0x01, 0x44, 0xd9, 0xf2, 0xaf, - 0xcf, 0xc1, 0x00, 0x80, 0x01, 0xff, 0xab, 0x0c, 0x48, 0xf6, 0x54, 0xb0, - 0xcf, 0x01, 0x4b, 0xea, 0xa3, 0xb1, 0xcf, 0x41, 0x0b, 0x46, 0x8b, 0x06, - 0x52, 0xec, 0x54, 0xb2, 0xcf, 0x41, 0x4e, 0x59, 0x69, 0xb4, 0xcf, 0x01, - 0x48, 0xf6, 0x54, 0xb3, 0xcf, 0x41, 0x80, 0x01, 0xff, 0x07, 0x45, 0x8b, - 0x06, 0x47, 0xee, 0xd4, 0xa8, 0xcf, 0x41, 0x4c, 0x94, 0x92, 0xab, 0xcf, - 0x01, 0x47, 0xee, 0xd4, 0xaa, 0xcf, 0x01, 0x43, 0xe5, 0xf4, 0xa9, 0xcf, - 0x41, 0x46, 0x70, 0xdc, 0x6e, 0xcf, 0x01, 0x45, 0x18, 0x65, 0x54, 0xcf, - 0x01, 0x45, 0x90, 0xe9, 0x84, 0xcf, 0x01, 0x02, 0x83, 0x0a, 0x06, 0x46, - 0x20, 0xbd, 0xbf, 0xcf, 0x41, 0x42, 0x90, 0x08, 0x50, 0xcf, 0x81, 0x06, - 0x42, 0x6f, 0x28, 0x81, 0xcf, 0x41, 0x46, 0x6e, 0xd8, 0x51, 0xcf, 0x41, - 0x45, 0xf9, 0xe4, 0x5e, 0xcf, 0x01, 0x47, 0x7b, 0xd3, 0x60, 0xcf, 0x01, - 0x46, 0x83, 0xca, 0x61, 0xcf, 0x01, 0xb4, 0x01, 0xff, 0x44, 0x70, 0xd8, - 0x5f, 0xcf, 0x01, 0x48, 0x81, 0xca, 0x62, 0xcf, 0x41, 0xa5, 0x12, 0x4f, - 0x4e, 0x62, 0x6b, 0xcf, 0x01, 0x43, 0xe0, 0x7c, 0xc1, 0xcf, 0x01, 0x4b, - 0xc6, 0xa4, 0x53, 0xcf, 0x41, 0x50, 0x0d, 0x65, 0x75, 0xcf, 0x01, 0x46, - 0x9a, 0xdf, 0x6d, 0xcf, 0x41, 0x45, 0x77, 0xdc, 0x6f, 0xcf, 0x01, 0x48, - 0xa8, 0x51, 0x5b, 0xcf, 0x41, 0x57, 0xa4, 0x2d, 0x3e, 0xcf, 0x01, 0x5b, - 0xaf, 0x1c, 0x41, 0xcf, 0x01, 0x05, 0xb9, 0x00, 0x17, 0x11, 0x87, 0x5e, - 0x01, 0xff, 0x47, 0x1c, 0x7a, 0x30, 0xcf, 0x01, 0x46, 0x26, 0xc0, 0x31, - 0xcf, 0x01, 0x49, 0x23, 0xc0, 0x32, 0xcf, 0x41, 0x47, 0xbc, 0xcf, 0x24, - 0xcf, 0x01, 0xa3, 0xcf, 0x03, 0xa4, 0xc0, 0x03, 0x08, 0x99, 0xc6, 0x90, - 0x03, 0xab, 0xf4, 0x02, 0x45, 0x55, 0xe8, 0x27, 0xcf, 0x01, 0x0d, 0xa5, - 0x85, 0xb6, 0x02, 0x06, 0x7a, 0xde, 0x90, 0x02, 0xaf, 0xfd, 0x01, 0x02, +static const unsigned char uname2c_tree[227573] = { + 0xa1, 0xd1, 0xe1, 0x0c, 0xa2, 0x86, 0xd8, 0x0b, 0xa3, 0xf9, 0xf6, 0x09, + 0xa4, 0x8d, 0xc4, 0x09, 0xa5, 0xb6, 0xfa, 0x08, 0xa6, 0x9b, 0xec, 0x08, + 0xa7, 0xea, 0xa4, 0x08, 0xa8, 0xfa, 0xd9, 0x07, 0xa9, 0xbf, 0xc4, 0x07, + 0xaa, 0xd6, 0xbc, 0x07, 0xab, 0xc9, 0x85, 0x07, 0xac, 0xf0, 0xf0, 0x05, + 0xad, 0xf4, 0xbf, 0x04, 0xae, 0xf3, 0x99, 0x04, 0xaf, 0xea, 0xea, 0x03, + 0xb0, 0xe2, 0xbd, 0x03, 0x02, 0x7c, 0x00, 0xb5, 0xbc, 0x03, 0xb2, 0x92, + 0x99, 0x03, 0xb3, 0xd0, 0x8a, 0x02, 0xb4, 0x9d, 0x8e, 0x01, 0xb5, 0xed, + 0x7e, 0xb6, 0xa0, 0x57, 0xb7, 0x94, 0x40, 0xb8, 0x9a, 0x3f, 0xb9, 0xec, + 0x10, 0xba, 0x01, 0xff, 0x0a, 0xb2, 0x1e, 0x82, 0x10, 0x10, 0x9a, 0x63, + 0x99, 0x0c, 0xa5, 0xea, 0x0b, 0x50, 0x1a, 0x67, 0x10, 0xf9, 0x01, 0x08, + 0x27, 0xce, 0x1f, 0x45, 0x7b, 0xef, 0xdf, 0xf9, 0x01, 0xb7, 0x01, 0xff, + 0xea, 0x0d, 0x20, 0x00, 0xae, 0x06, 0x42, 0xb9, 0x0d, 0x0b, 0x20, 0x40, + 0x43, 0x55, 0xf7, 0xff, 0xfe, 0x00, 0xea, 0x0c, 0x20, 0x40, 0x0a, 0xc2, + 0x5b, 0xaa, 0x07, 0x06, 0x32, 0xe4, 0x23, 0x11, 0xf1, 0x5f, 0x01, 0xff, + 0x4e, 0x7e, 0x7a, 0x44, 0xcf, 0x01, 0x45, 0xc8, 0x8c, 0x45, 0xcf, 0x01, + 0x06, 0xa2, 0xe3, 0x06, 0x43, 0x72, 0x30, 0x46, 0xcf, 0x41, 0xd2, 0x42, + 0xcf, 0x01, 0xd3, 0x43, 0xcf, 0x41, 0x02, 0x3b, 0x15, 0xf2, 0x06, 0xa4, + 0xcf, 0x06, 0x44, 0xb4, 0xf5, 0x83, 0xcf, 0x01, 0x0a, 0x64, 0xb0, 0xa3, + 0x06, 0xab, 0xf1, 0x05, 0x46, 0xfc, 0xe3, 0xa7, 0xcf, 0x81, 0xca, 0x05, + 0x45, 0xf4, 0xee, 0xc2, 0xcf, 0x01, 0xaf, 0x8d, 0x05, 0xb0, 0xda, 0x04, + 0xb2, 0xcb, 0x04, 0xb3, 0x4f, 0x09, 0x04, 0xc7, 0x17, 0xba, 0x01, 0xff, + 0xa1, 0x06, 0x46, 0xbb, 0xc0, 0x85, 0xcf, 0x41, 0x46, 0x6e, 0xe4, 0x55, + 0xcf, 0x01, 0x47, 0x68, 0x34, 0x5d, 0xcf, 0x41, 0x0c, 0xb5, 0x8f, 0x18, + 0x49, 0xd0, 0xc1, 0x64, 0xcf, 0x01, 0x48, 0xaf, 0xcf, 0x63, 0xcf, 0x01, + 0x48, 0x5d, 0x57, 0x65, 0xcf, 0x01, 0x4b, 0x14, 0xa9, 0x66, 0xcf, 0x41, + 0x49, 0xd0, 0xc1, 0x68, 0xcf, 0x01, 0x48, 0xaf, 0xcf, 0x67, 0xcf, 0x01, + 0x48, 0x5d, 0x57, 0x69, 0xcf, 0x01, 0x4b, 0x14, 0xa9, 0x6a, 0xcf, 0x41, + 0x09, 0xb9, 0xc0, 0xa3, 0x03, 0x48, 0xa7, 0xcd, 0x7d, 0xcf, 0x81, 0x82, + 0x03, 0xb4, 0x01, 0xff, 0x44, 0x04, 0xf5, 0x86, 0xcf, 0x81, 0xac, 0x02, + 0x46, 0xda, 0xe4, 0x56, 0xcf, 0x81, 0x95, 0x02, 0x05, 0x39, 0xf0, 0x01, + 0xff, 0x09, 0x53, 0x86, 0xe8, 0x01, 0x04, 0xf4, 0xf5, 0xae, 0x01, 0xab, + 0x42, 0x4e, 0xaa, 0x7d, 0x93, 0xcf, 0x01, 0x4e, 0x85, 0x6c, 0x97, 0xcf, + 0x01, 0xb0, 0x20, 0xb4, 0x01, 0xff, 0x4e, 0x06, 0x7c, 0x9a, 0xcf, 0x01, + 0x05, 0x8e, 0xf0, 0x01, 0xff, 0x48, 0x1f, 0xcc, 0xac, 0xcf, 0x01, 0x49, + 0x5c, 0xa4, 0xad, 0xcf, 0x01, 0x49, 0x4b, 0xc5, 0xae, 0xcf, 0x41, 0xaf, + 0x06, 0x47, 0xb0, 0xcf, 0x92, 0xcf, 0x41, 0x4b, 0x5a, 0xa4, 0x95, 0xcf, + 0x01, 0x47, 0x5e, 0xa4, 0x96, 0xcf, 0x41, 0x06, 0xb6, 0x8f, 0x5a, 0x02, + 0xcc, 0x0a, 0x01, 0xff, 0x47, 0x55, 0x57, 0xb5, 0xcf, 0x81, 0x06, 0x47, + 0xed, 0xb1, 0x94, 0xcf, 0x41, 0x80, 0x01, 0xff, 0x04, 0xf4, 0xf5, 0x0c, + 0x49, 0x5c, 0xa4, 0xb6, 0xcf, 0x01, 0x47, 0x77, 0xdc, 0xbe, 0xcf, 0x41, + 0x44, 0x8f, 0x6c, 0xb9, 0xcf, 0x81, 0x28, 0xaf, 0x01, 0xff, 0x4a, 0xea, + 0xb1, 0xbc, 0xcf, 0x81, 0x18, 0x49, 0x5c, 0xa4, 0xba, 0xcf, 0xc1, 0x00, + 0x06, 0x50, 0x00, 0x01, 0xff, 0x50, 0x2a, 0x65, 0xbb, 0xcf, 0x01, 0x50, + 0x5f, 0x34, 0xb8, 0xcf, 0x41, 0x4a, 0x5a, 0xab, 0xbd, 0xcf, 0x41, 0x56, + 0x59, 0x34, 0xb7, 0xcf, 0x41, 0x4e, 0x85, 0x6c, 0x99, 0xcf, 0x01, 0x49, + 0x5c, 0xa4, 0x98, 0xcf, 0x41, 0x44, 0x8f, 0x6c, 0xa2, 0xcf, 0x81, 0x28, + 0xaf, 0x01, 0xff, 0x4a, 0xea, 0xb1, 0xa5, 0xcf, 0x81, 0x18, 0x49, 0x5c, + 0xa4, 0xa3, 0xcf, 0xc1, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x50, 0x2a, + 0x65, 0xa4, 0xcf, 0x01, 0x50, 0x5f, 0x34, 0xa1, 0xcf, 0x41, 0x4a, 0x5a, + 0xab, 0xa6, 0xcf, 0x41, 0x56, 0x59, 0x34, 0xa0, 0xcf, 0x41, 0x43, 0x6c, + 0x34, 0x9b, 0xcf, 0x81, 0x16, 0xaf, 0x01, 0xff, 0x4a, 0xea, 0xb1, 0x9c, + 0xcf, 0x01, 0x49, 0x5c, 0xa4, 0x9d, 0xcf, 0xc1, 0x00, 0x4c, 0xb4, 0x8f, + 0x9f, 0xcf, 0x41, 0x4c, 0xb4, 0x8f, 0x9e, 0xcf, 0x41, 0x80, 0x01, 0xff, + 0x48, 0x57, 0xd0, 0x57, 0xcf, 0x01, 0x54, 0x2b, 0x49, 0x5a, 0xcf, 0x41, + 0x80, 0x01, 0xff, 0x4e, 0x85, 0x6c, 0x91, 0xcf, 0x01, 0x02, 0x31, 0x01, + 0x0d, 0x49, 0x82, 0xc7, 0x8b, 0xcf, 0xc1, 0x00, 0x4b, 0xd5, 0x9c, 0x8c, + 0xcf, 0x41, 0x50, 0x4a, 0x65, 0x8e, 0xcf, 0x01, 0x47, 0xc8, 0x8c, 0x88, + 0xcf, 0x81, 0x1e, 0x45, 0x61, 0xf0, 0x8d, 0xcf, 0x01, 0x48, 0x75, 0x9c, + 0x87, 0xcf, 0xc1, 0x00, 0x03, 0xbe, 0x08, 0x01, 0xff, 0x47, 0xc8, 0x8c, + 0x89, 0xcf, 0x01, 0x4b, 0x96, 0xa6, 0x8f, 0xcf, 0x41, 0x4b, 0x72, 0x9c, + 0x8a, 0xcf, 0x41, 0x80, 0x01, 0xff, 0x02, 0x31, 0x01, 0x06, 0x48, 0xbf, + 0xd2, 0x7f, 0xcf, 0x41, 0x47, 0xc8, 0x8c, 0x80, 0xcf, 0x01, 0x48, 0x75, + 0x9c, 0x7e, 0xcf, 0x41, 0x0d, 0x53, 0x86, 0x36, 0x07, 0xb5, 0x8f, 0x1b, + 0x49, 0xd0, 0xc1, 0x71, 0xcf, 0x01, 0x48, 0x5d, 0x57, 0x72, 0xcf, 0x01, + 0xb4, 0x01, 0xff, 0x46, 0x06, 0x7c, 0x74, 0xcf, 0x01, 0x4a, 0x15, 0xa9, + 0x73, 0xcf, 0x41, 0x4e, 0x85, 0x6c, 0x77, 0xcf, 0x01, 0x05, 0x58, 0x57, + 0x01, 0xff, 0x48, 0x5d, 0x57, 0x76, 0xcf, 0x01, 0x47, 0xb1, 0x7d, 0x78, + 0xcf, 0x41, 0x4b, 0xb5, 0x8f, 0x7c, 0xcf, 0x01, 0x4e, 0x85, 0x6c, 0x7b, + 0xcf, 0x01, 0x48, 0xaf, 0xcf, 0x79, 0xcf, 0x01, 0x48, 0x5d, 0x57, 0x7a, + 0xcf, 0x41, 0x52, 0x05, 0x54, 0x6c, 0xcf, 0x01, 0x42, 0xc7, 0x19, 0x82, + 0xcf, 0x41, 0xa1, 0x1c, 0x48, 0x77, 0xcb, 0x58, 0xcf, 0x81, 0x0f, 0xaf, + 0x01, 0xff, 0x48, 0x98, 0xa6, 0x70, 0xcf, 0x01, 0x48, 0x7f, 0xcd, 0x90, + 0xcf, 0x41, 0x4f, 0x84, 0x6c, 0x59, 0xcf, 0x41, 0x43, 0x03, 0x89, 0x5c, + 0xcf, 0x01, 0x46, 0x64, 0xe5, 0x52, 0xcf, 0x01, 0x42, 0xb5, 0x08, 0xc3, + 0xcf, 0x41, 0x45, 0xc6, 0xea, 0xc0, 0xcf, 0x01, 0x44, 0xb0, 0xf8, 0xaf, + 0xcf, 0xc1, 0x00, 0x80, 0x01, 0xff, 0xab, 0x0c, 0x48, 0x5d, 0x57, 0xb0, + 0xcf, 0x01, 0x4b, 0x14, 0xa9, 0xb1, 0xcf, 0x41, 0x0b, 0xb6, 0x8f, 0x06, + 0x52, 0x53, 0x57, 0xb2, 0xcf, 0x41, 0x4e, 0x85, 0x6c, 0xb4, 0xcf, 0x01, + 0x48, 0x5d, 0x57, 0xb3, 0xcf, 0x41, 0x80, 0x01, 0xff, 0x07, 0xb5, 0x8f, + 0x06, 0x47, 0xb7, 0xda, 0xa8, 0xcf, 0x41, 0x4c, 0x4c, 0x97, 0xab, 0xcf, + 0x01, 0x47, 0xb7, 0xda, 0xaa, 0xcf, 0x01, 0x43, 0xbd, 0xfa, 0xa9, 0xcf, + 0x41, 0x46, 0x40, 0xe2, 0x6e, 0xcf, 0x01, 0x45, 0x05, 0x68, 0x54, 0xcf, + 0x01, 0x45, 0x62, 0xef, 0x84, 0xcf, 0x01, 0x02, 0xcc, 0x0a, 0x06, 0x46, + 0xbd, 0xc2, 0xbf, 0xcf, 0x41, 0x42, 0xb5, 0x08, 0x50, 0xcf, 0x81, 0x06, + 0x42, 0xc2, 0x29, 0x81, 0xcf, 0x41, 0x46, 0x3e, 0xde, 0x51, 0xcf, 0x41, + 0x45, 0xd0, 0xea, 0x5e, 0xcf, 0x01, 0x47, 0x36, 0xd9, 0x60, 0xcf, 0x01, + 0x46, 0x29, 0xd0, 0x61, 0xcf, 0x01, 0xb4, 0x01, 0xff, 0x44, 0x40, 0xde, + 0x5f, 0xcf, 0x01, 0x48, 0x27, 0xd0, 0x62, 0xcf, 0x41, 0xa5, 0x12, 0x4f, + 0x2b, 0x65, 0x6b, 0xcf, 0x01, 0x43, 0xa6, 0x80, 0xc1, 0xcf, 0x01, 0x4b, + 0xf0, 0xa9, 0x53, 0xcf, 0x41, 0x50, 0xfa, 0x67, 0x75, 0xcf, 0x01, 0x46, + 0x70, 0xe5, 0x6d, 0xcf, 0x41, 0x45, 0x47, 0xe2, 0x6f, 0xcf, 0x01, 0x48, + 0x0f, 0x54, 0x5b, 0xcf, 0x41, 0x57, 0x10, 0x2f, 0x3e, 0xcf, 0x01, 0x5b, + 0xb5, 0x1d, 0x41, 0xcf, 0x01, 0x05, 0xb9, 0x00, 0x17, 0x11, 0x23, 0x61, + 0x01, 0xff, 0x47, 0xaa, 0x7d, 0x30, 0xcf, 0x01, 0x46, 0xd5, 0xc5, 0x31, + 0xcf, 0x01, 0x49, 0xd2, 0xc5, 0x32, 0xcf, 0x41, 0x47, 0x62, 0xd5, 0x24, + 0xcf, 0x01, 0xa3, 0xcf, 0x03, 0xa4, 0xc0, 0x03, 0x08, 0x27, 0xcc, 0x90, + 0x03, 0xab, 0xf4, 0x02, 0x45, 0x2c, 0xee, 0x27, 0xcf, 0x01, 0x0d, 0xc7, + 0x89, 0xb6, 0x02, 0x06, 0x50, 0xe4, 0x90, 0x02, 0xaf, 0xfd, 0x01, 0x02, 0x9c, 0x01, 0xab, 0x01, 0x02, 0x71, 0x00, 0x9a, 0x01, 0xb3, 0x76, 0xb4, - 0x4d, 0x46, 0x02, 0xe1, 0x25, 0xcf, 0x01, 0x07, 0x87, 0xd7, 0x18, 0xba, - 0x01, 0xff, 0x48, 0x1b, 0x42, 0x33, 0xcf, 0x01, 0xa5, 0x01, 0xff, 0x42, - 0x13, 0x01, 0x20, 0xcf, 0x01, 0x43, 0xe2, 0xf4, 0x2a, 0xcf, 0x41, 0x03, - 0xb6, 0x00, 0x1b, 0x03, 0x4b, 0x03, 0x01, 0xff, 0x0b, 0x2b, 0x9d, 0x06, - 0x46, 0x66, 0x88, 0x1d, 0xcf, 0x41, 0x44, 0xc3, 0x00, 0x0b, 0xcf, 0x01, + 0x4d, 0x46, 0xe4, 0xe6, 0x25, 0xcf, 0x01, 0x07, 0x50, 0xdd, 0x18, 0xba, + 0x01, 0xff, 0x48, 0x37, 0x44, 0x33, 0xcf, 0x01, 0xa5, 0x01, 0xff, 0x42, + 0x13, 0x01, 0x20, 0xcf, 0x01, 0x43, 0xba, 0xfa, 0x2a, 0xcf, 0x41, 0x03, + 0xb6, 0x00, 0x1b, 0x03, 0x4b, 0x03, 0x01, 0xff, 0x0b, 0x3f, 0xa2, 0x06, + 0x46, 0xc9, 0x8c, 0x1d, 0xcf, 0x41, 0x44, 0xc3, 0x00, 0x0b, 0xcf, 0x01, 0x45, 0xc8, 0x00, 0x17, 0xcf, 0x41, 0x44, 0xc3, 0x00, 0x08, 0xcf, 0x01, - 0x45, 0xc8, 0x00, 0x14, 0xcf, 0x41, 0x46, 0x86, 0x78, 0x23, 0xcf, 0x01, - 0x45, 0xec, 0xc9, 0x3c, 0xcf, 0x01, 0x05, 0xdf, 0xea, 0x01, 0xff, 0x03, - 0xb6, 0x00, 0x06, 0x49, 0x63, 0x88, 0x18, 0xcf, 0x41, 0x44, 0xc3, 0x00, - 0x02, 0xcf, 0x01, 0x45, 0xc8, 0x00, 0x0e, 0xcf, 0x41, 0x44, 0x05, 0xf1, - 0x2b, 0xcf, 0x01, 0x4e, 0x01, 0x47, 0x3b, 0xcf, 0x01, 0x09, 0xbb, 0xbe, - 0x06, 0x53, 0xc0, 0x4d, 0x1a, 0xcf, 0x41, 0x44, 0xc3, 0x00, 0x05, 0xcf, - 0x01, 0x45, 0xc8, 0x00, 0x11, 0xcf, 0x41, 0x43, 0xdf, 0xf4, 0x22, 0xcf, - 0x01, 0x45, 0xd3, 0xec, 0x2c, 0xcf, 0x41, 0xa4, 0x38, 0x06, 0xac, 0x85, + 0x45, 0xc8, 0x00, 0x14, 0xcf, 0x41, 0x46, 0x06, 0x7c, 0x23, 0xcf, 0x01, + 0x45, 0x82, 0xcf, 0x3c, 0xcf, 0x01, 0x05, 0xa7, 0xf0, 0x01, 0xff, 0x03, + 0xb6, 0x00, 0x06, 0x49, 0xc6, 0x8c, 0x18, 0xcf, 0x41, 0x44, 0xc3, 0x00, + 0x02, 0xcf, 0x01, 0x45, 0xc8, 0x00, 0x0e, 0xcf, 0x41, 0x44, 0xc8, 0xf6, + 0x2b, 0xcf, 0x01, 0x4e, 0x31, 0x49, 0x3b, 0xcf, 0x01, 0x09, 0x6a, 0xc4, + 0x06, 0x53, 0x16, 0x50, 0x1a, 0xcf, 0x41, 0x44, 0xc3, 0x00, 0x05, 0xcf, + 0x01, 0x45, 0xc8, 0x00, 0x11, 0xcf, 0x41, 0x43, 0xb7, 0xfa, 0x22, 0xcf, + 0x01, 0x45, 0x96, 0xf2, 0x2c, 0xcf, 0x41, 0xa4, 0x38, 0x06, 0xce, 0x89, 0x01, 0xff, 0x03, 0xb6, 0x00, 0x23, 0xb3, 0x01, 0xff, 0x02, 0x44, 0x00, - 0x06, 0x46, 0xc0, 0x4d, 0x1c, 0xcf, 0x41, 0x0b, 0x2b, 0x9d, 0x06, 0x46, - 0x66, 0x88, 0x1b, 0xcf, 0x41, 0x44, 0xc3, 0x00, 0x0a, 0xcf, 0x01, 0x45, + 0x06, 0x46, 0x16, 0x50, 0x1c, 0xcf, 0x41, 0x0b, 0x3f, 0xa2, 0x06, 0x46, + 0xc9, 0x8c, 0x1b, 0xcf, 0x41, 0x44, 0xc3, 0x00, 0x0a, 0xcf, 0x01, 0x45, 0xc8, 0x00, 0x16, 0xcf, 0x41, 0x44, 0xc3, 0x00, 0x07, 0xcf, 0x01, 0x45, - 0xc8, 0x00, 0x13, 0xcf, 0x41, 0x47, 0x85, 0xa1, 0x36, 0xcf, 0x81, 0x06, - 0x46, 0x3e, 0xe1, 0x26, 0xcf, 0x41, 0x55, 0xc0, 0x38, 0x37, 0xcf, 0x41, - 0x47, 0xa0, 0xcf, 0x3a, 0xcf, 0x01, 0xee, 0x21, 0xcf, 0x01, 0x47, 0xae, - 0xd6, 0x35, 0xcf, 0x41, 0x03, 0xb6, 0x00, 0x11, 0x0d, 0x63, 0x88, 0x01, + 0xc8, 0x00, 0x13, 0xcf, 0x41, 0x47, 0x99, 0xa6, 0x36, 0xcf, 0x81, 0x06, + 0x46, 0x1a, 0xe7, 0x26, 0xcf, 0x41, 0x55, 0xc8, 0x3a, 0x37, 0xcf, 0x41, + 0x47, 0x46, 0xd5, 0x3a, 0xcf, 0x01, 0xee, 0x21, 0xcf, 0x01, 0x47, 0x7e, + 0xdc, 0x35, 0xcf, 0x41, 0x03, 0xb6, 0x00, 0x11, 0x0d, 0xc6, 0x8c, 0x01, 0xff, 0x44, 0xc3, 0x00, 0x01, 0xcf, 0x01, 0x45, 0xc8, 0x00, 0x0d, 0xcf, 0x41, 0x44, 0xc3, 0x00, 0x04, 0xcf, 0x01, 0x45, 0xc8, 0x00, 0x10, 0xcf, 0x41, 0x03, 0xb6, 0x00, 0x23, 0xb3, 0x01, 0xff, 0x02, 0x44, 0x00, 0x06, - 0x46, 0xc0, 0x4d, 0x1e, 0xcf, 0x41, 0x0b, 0x2b, 0x9d, 0x06, 0x46, 0x66, - 0x88, 0x19, 0xcf, 0x41, 0x44, 0xc3, 0x00, 0x09, 0xcf, 0x01, 0x45, 0xc8, + 0x46, 0x16, 0x50, 0x1e, 0xcf, 0x41, 0x0b, 0x3f, 0xa2, 0x06, 0x46, 0xc9, + 0x8c, 0x19, 0xcf, 0x41, 0x44, 0xc3, 0x00, 0x09, 0xcf, 0x01, 0x45, 0xc8, 0x00, 0x15, 0xcf, 0x41, 0x44, 0xc3, 0x00, 0x06, 0xcf, 0x01, 0x45, 0xc8, - 0x00, 0x12, 0xcf, 0x41, 0x45, 0x22, 0xe4, 0x29, 0xcf, 0x01, 0x44, 0x66, - 0x88, 0x40, 0xcf, 0x81, 0x06, 0x46, 0x1a, 0xe1, 0x28, 0xcf, 0x41, 0x48, - 0x51, 0xc2, 0x2d, 0xcf, 0x41, 0x06, 0x7a, 0xde, 0x06, 0x46, 0x87, 0xd7, - 0x1f, 0xcf, 0x41, 0x03, 0xb6, 0x00, 0x11, 0x0d, 0x63, 0x88, 0x01, 0xff, + 0x00, 0x12, 0xcf, 0x41, 0x45, 0x03, 0xea, 0x29, 0xcf, 0x01, 0x44, 0xc9, + 0x8c, 0x40, 0xcf, 0x81, 0x06, 0x46, 0xf6, 0xe6, 0x28, 0xcf, 0x41, 0x48, + 0xef, 0xc7, 0x2d, 0xcf, 0x41, 0x06, 0x50, 0xe4, 0x06, 0x46, 0x50, 0xdd, + 0x1f, 0xcf, 0x41, 0x03, 0xb6, 0x00, 0x11, 0x0d, 0xc6, 0x8c, 0x01, 0xff, 0x44, 0xc3, 0x00, 0x00, 0xcf, 0x01, 0x45, 0xc8, 0x00, 0x0c, 0xcf, 0x41, 0x44, 0xc3, 0x00, 0x03, 0xcf, 0x01, 0x45, 0xc8, 0x00, 0x0f, 0xcf, 0x41, - 0x54, 0x0f, 0x42, 0x34, 0xcf, 0x01, 0x49, 0x4c, 0xc1, 0x3d, 0xcf, 0x41, - 0x46, 0x76, 0xdc, 0x38, 0xcf, 0x81, 0x06, 0x4a, 0x32, 0xb3, 0x3f, 0xcf, - 0x41, 0x48, 0x91, 0xc2, 0x39, 0xcf, 0x41, 0x48, 0x79, 0xc4, 0x93, 0xf9, - 0x01, 0x09, 0xf1, 0xbe, 0x06, 0x42, 0xef, 0x02, 0xe2, 0x2b, 0x40, 0x46, - 0xa7, 0x61, 0x0d, 0x20, 0x00, 0x02, 0xb4, 0x01, 0x06, 0x45, 0xd7, 0x4c, - 0x0b, 0x20, 0x40, 0x4c, 0xd0, 0x4c, 0xff, 0xfe, 0x00, 0x48, 0x91, 0xc8, - 0x0c, 0x20, 0x40, 0x02, 0xaf, 0x00, 0xa8, 0x03, 0x54, 0x4b, 0x42, 0x33, - 0x1a, 0x01, 0x08, 0xb8, 0x16, 0x91, 0x03, 0x07, 0xec, 0x05, 0x90, 0x01, - 0x05, 0xb9, 0x00, 0x74, 0xb3, 0x3a, 0x06, 0x57, 0x39, 0x01, 0xff, 0x4b, - 0x5d, 0x39, 0x0a, 0x1a, 0x01, 0x05, 0x5a, 0x03, 0x01, 0xff, 0xa1, 0x20, + 0x54, 0x2b, 0x44, 0x34, 0xcf, 0x01, 0x49, 0xfb, 0xc6, 0x3d, 0xcf, 0x41, + 0x46, 0x46, 0xe2, 0x38, 0xcf, 0x81, 0x06, 0x4a, 0xac, 0xb8, 0x3f, 0xcf, + 0x41, 0x48, 0x27, 0xc8, 0x39, 0xcf, 0x41, 0x48, 0x07, 0xca, 0x93, 0xf9, + 0x01, 0x09, 0xa0, 0xc4, 0x06, 0x42, 0xef, 0x02, 0xe2, 0x2b, 0x40, 0x46, + 0x74, 0x64, 0x0d, 0x20, 0x00, 0x02, 0xb4, 0x01, 0x06, 0x45, 0x2d, 0x4f, + 0x0b, 0x20, 0x40, 0x4c, 0x26, 0x4f, 0xff, 0xfe, 0x00, 0x48, 0x17, 0xce, + 0x0c, 0x20, 0x40, 0x02, 0xaf, 0x00, 0xa8, 0x03, 0x54, 0x67, 0x44, 0x33, + 0x1a, 0x01, 0x08, 0x86, 0x17, 0x91, 0x03, 0x07, 0x13, 0x06, 0x90, 0x01, + 0x05, 0xb9, 0x00, 0x74, 0xb3, 0x3a, 0x06, 0x74, 0x3b, 0x01, 0xff, 0x4b, + 0x7a, 0x3b, 0x0a, 0x1a, 0x01, 0x05, 0x5a, 0x03, 0x01, 0xff, 0xa1, 0x20, 0xe5, 0x04, 0x1a, 0x01, 0xe9, 0x01, 0x1a, 0x01, 0xef, 0x06, 0x1a, 0x81, - 0x0f, 0x4a, 0x44, 0xb0, 0x09, 0x1a, 0x01, 0xf5, 0x03, 0x1a, 0xc1, 0x00, + 0x0f, 0x4a, 0xbe, 0xb5, 0x09, 0x1a, 0x01, 0xf5, 0x03, 0x1a, 0xc1, 0x00, 0xe5, 0x02, 0x1a, 0x41, 0xe5, 0x05, 0x1a, 0x41, 0xe9, 0x07, 0x1a, 0x01, - 0xf5, 0x08, 0x1a, 0x41, 0x04, 0x5b, 0x03, 0x06, 0x48, 0x09, 0xcc, 0x47, - 0x1a, 0x41, 0x48, 0x3c, 0x16, 0x38, 0x1a, 0x01, 0x06, 0xd9, 0x23, 0x11, - 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0xe7, 0x23, 0x34, 0x1a, 0x01, 0x45, - 0xf3, 0x4b, 0x39, 0x1a, 0x41, 0x4e, 0x86, 0x25, 0x37, 0x1a, 0x01, 0x45, - 0xdf, 0x23, 0x35, 0x1a, 0xc1, 0x00, 0x4e, 0x86, 0x25, 0x36, 0x1a, 0x41, - 0x4b, 0x68, 0x9b, 0x43, 0x1a, 0x01, 0x4a, 0x7e, 0xad, 0x44, 0x1a, 0x01, - 0x44, 0xa4, 0x02, 0x42, 0x1a, 0x01, 0x45, 0x44, 0x3a, 0x41, 0x1a, 0x41, - 0x42, 0xea, 0x25, 0x29, 0x1a, 0x01, 0xe1, 0x00, 0x1a, 0x01, 0xa2, 0xe5, + 0xf5, 0x08, 0x1a, 0x41, 0x04, 0x5b, 0x03, 0x06, 0x48, 0xaf, 0xd1, 0x47, + 0x1a, 0x41, 0x48, 0x0a, 0x17, 0x38, 0x1a, 0x01, 0x06, 0x13, 0x25, 0x11, + 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0x21, 0x25, 0x34, 0x1a, 0x01, 0x45, + 0x49, 0x4e, 0x39, 0x1a, 0x41, 0x4e, 0xd9, 0x26, 0x37, 0x1a, 0x01, 0x45, + 0x19, 0x25, 0x35, 0x1a, 0xc1, 0x00, 0x4e, 0xd9, 0x26, 0x36, 0x1a, 0x41, + 0x4b, 0x66, 0xa0, 0x43, 0x1a, 0x01, 0x4a, 0xda, 0xb2, 0x44, 0x1a, 0x01, + 0x44, 0xa4, 0x02, 0x42, 0x1a, 0x01, 0x45, 0x61, 0x3c, 0x41, 0x1a, 0x41, + 0x42, 0x3d, 0x27, 0x29, 0x1a, 0x01, 0xe1, 0x00, 0x1a, 0x01, 0xa2, 0xe5, 0x01, 0xa3, 0xd8, 0x01, 0xa4, 0xb2, 0x01, 0xa7, 0xa5, 0x01, 0x42, 0x22, - 0x00, 0x31, 0x1a, 0x01, 0x42, 0x72, 0x19, 0x12, 0x1a, 0x01, 0xab, 0x86, + 0x00, 0x31, 0x1a, 0x01, 0x42, 0x78, 0x1a, 0x12, 0x1a, 0x01, 0xab, 0x86, 0x01, 0x42, 0x74, 0x00, 0x2c, 0x1a, 0x01, 0x42, 0x6c, 0x00, 0x22, 0x1a, 0x01, 0xae, 0x62, 0xb0, 0x56, 0x42, 0x71, 0x00, 0x2b, 0x1a, 0x01, 0xb3, - 0x3e, 0xb4, 0x19, 0x42, 0xf5, 0x0a, 0x2d, 0x1a, 0x01, 0x42, 0xbe, 0x22, + 0x3e, 0xb4, 0x19, 0x42, 0x61, 0x0b, 0x2d, 0x1a, 0x01, 0x42, 0xdf, 0x23, 0x2a, 0x1a, 0x01, 0xba, 0x01, 0xff, 0xe1, 0x28, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x27, 0x1a, 0x41, 0xe1, 0x19, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x1a, 0x1a, 0x01, 0xb3, 0x0d, 0xb4, 0x01, 0xff, 0xe1, 0x14, 0x1a, 0x01, 0x42, @@ -1037,31 +1056,31 @@ static const unsigned char uname2c_tree[222744] = { 0x24, 0x1a, 0x41, 0xe1, 0x30, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x2e, 0x1a, 0x01, 0x42, 0x40, 0x06, 0x2f, 0x1a, 0x41, 0xe1, 0x1e, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x1f, 0x1a, 0x41, 0xe1, 0x1d, 0x1a, 0x01, 0x42, 0x24, 0x02, - 0x0f, 0x1a, 0x01, 0x42, 0x2a, 0x05, 0x18, 0x1a, 0x01, 0x42, 0xbe, 0x22, + 0x0f, 0x1a, 0x01, 0x42, 0x2a, 0x05, 0x18, 0x1a, 0x01, 0x42, 0xdf, 0x23, 0x13, 0x1a, 0x41, 0xe1, 0x0b, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x0c, 0x1a, - 0x01, 0x43, 0xfd, 0x20, 0x32, 0x1a, 0x41, 0xe1, 0x0d, 0x1a, 0x01, 0x42, + 0x01, 0x43, 0x1e, 0x22, 0x32, 0x1a, 0x41, 0xe1, 0x0d, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x0e, 0x1a, 0x41, 0xe1, 0x1b, 0x1a, 0x01, 0xa4, 0x13, 0x42, 0x22, 0x00, 0x1c, 0x1a, 0x01, 0xba, 0x01, 0xff, 0xe1, 0x25, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x26, 0x1a, 0x41, 0xe1, 0x16, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x17, 0x1a, 0x41, 0xe1, 0x10, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x11, 0x1a, 0x41, 0xe1, 0x20, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x21, 0x1a, 0x41, - 0x56, 0xc6, 0x33, 0x45, 0x1a, 0x01, 0x49, 0xbc, 0x1b, 0x3f, 0x1a, 0x41, - 0x06, 0x85, 0x3d, 0x27, 0x06, 0x19, 0x2e, 0x01, 0xff, 0x0d, 0xf4, 0x82, - 0x06, 0x51, 0x35, 0x5b, 0x3a, 0x1a, 0x41, 0x42, 0x74, 0x00, 0x3d, 0x1a, - 0x01, 0x42, 0x71, 0x00, 0x3c, 0x1a, 0x01, 0x42, 0xf5, 0x0a, 0x3e, 0x1a, - 0x01, 0x42, 0xbe, 0x22, 0x3b, 0x1a, 0x41, 0x56, 0xc6, 0x33, 0x46, 0x1a, - 0x01, 0x49, 0xbc, 0x1b, 0x40, 0x1a, 0x41, 0x4e, 0x2c, 0x76, 0xff, 0x22, - 0x00, 0x56, 0x84, 0x33, 0x64, 0x2a, 0x00, 0x05, 0xc3, 0x00, 0x46, 0xb2, - 0x27, 0xb3, 0x06, 0x4a, 0x7e, 0xb2, 0x82, 0x29, 0x40, 0x06, 0xa2, 0xda, - 0x06, 0x43, 0x1b, 0x45, 0x81, 0x29, 0x40, 0x4b, 0x01, 0x3b, 0x1f, 0x2a, - 0x00, 0xb0, 0x01, 0xff, 0x45, 0xab, 0xe7, 0x20, 0x2a, 0x00, 0x49, 0xfa, - 0xbe, 0x21, 0x2a, 0x40, 0x54, 0xbb, 0x40, 0x65, 0x2a, 0x00, 0x55, 0xf7, - 0x3a, 0x3e, 0x2a, 0x00, 0x05, 0xc9, 0x00, 0x01, 0xff, 0x4f, 0x56, 0x6b, - 0x8a, 0x29, 0x00, 0x4d, 0x46, 0x84, 0x88, 0x29, 0x40, 0x4f, 0x56, 0x6b, - 0x89, 0x29, 0x00, 0x4d, 0x46, 0x84, 0x87, 0x29, 0x40, 0xa1, 0x89, 0x2e, - 0xa5, 0xc4, 0x2b, 0xa9, 0x06, 0x44, 0xd5, 0xf1, 0x80, 0xfa, 0x41, 0x80, - 0x06, 0x46, 0x3e, 0xde, 0x2f, 0x26, 0x40, 0x08, 0x79, 0xa5, 0xcd, 0x28, - 0x09, 0x36, 0x18, 0x01, 0xff, 0xe1, 0x0a, 0xa0, 0x80, 0xb6, 0x28, 0xa2, + 0x56, 0x77, 0x35, 0x45, 0x1a, 0x01, 0x49, 0xc2, 0x1c, 0x3f, 0x1a, 0x41, + 0x06, 0x8d, 0x3f, 0x27, 0x06, 0x85, 0x2f, 0x01, 0xff, 0x0d, 0xef, 0x86, + 0x06, 0x51, 0xaf, 0x5d, 0x3a, 0x1a, 0x41, 0x42, 0x74, 0x00, 0x3d, 0x1a, + 0x01, 0x42, 0x71, 0x00, 0x3c, 0x1a, 0x01, 0x42, 0x61, 0x0b, 0x3e, 0x1a, + 0x01, 0x42, 0xdf, 0x23, 0x3b, 0x1a, 0x41, 0x56, 0x77, 0x35, 0x46, 0x1a, + 0x01, 0x49, 0xc2, 0x1c, 0x40, 0x1a, 0x41, 0x4e, 0x9e, 0x79, 0xff, 0x22, + 0x00, 0x56, 0x35, 0x35, 0x64, 0x2a, 0x00, 0x05, 0xc3, 0x00, 0x46, 0xb2, + 0x27, 0xb3, 0x06, 0x4a, 0xf8, 0xb7, 0x82, 0x29, 0x40, 0x06, 0x6c, 0xe0, + 0x06, 0x43, 0x4b, 0x47, 0x81, 0x29, 0x40, 0x4b, 0x09, 0x3d, 0x1f, 0x2a, + 0x00, 0xb0, 0x01, 0xff, 0x45, 0x82, 0xed, 0x20, 0x2a, 0x00, 0x49, 0xa9, + 0xc4, 0x21, 0x2a, 0x40, 0x54, 0xc3, 0x42, 0x65, 0x2a, 0x00, 0x55, 0xff, + 0x3c, 0x3e, 0x2a, 0x00, 0x05, 0xc9, 0x00, 0x01, 0xff, 0x4f, 0x82, 0x6e, + 0x8a, 0x29, 0x00, 0x4d, 0x4e, 0x88, 0x88, 0x29, 0x40, 0x4f, 0x82, 0x6e, + 0x89, 0x29, 0x00, 0x4d, 0x4e, 0x88, 0x87, 0x29, 0x40, 0xa1, 0x89, 0x2e, + 0xa5, 0xc4, 0x2b, 0xa9, 0x06, 0x44, 0xa8, 0xf7, 0x80, 0xfa, 0x41, 0x80, + 0x06, 0x46, 0x14, 0xe4, 0x2f, 0x26, 0x40, 0x08, 0xa3, 0xaa, 0xcd, 0x28, + 0x09, 0x20, 0x19, 0x01, 0xff, 0xe1, 0x0a, 0xa0, 0x80, 0xb6, 0x28, 0xa2, 0x94, 0x26, 0xa3, 0x87, 0x24, 0xa4, 0x9d, 0x22, 0xe5, 0x14, 0xa0, 0x80, 0x93, 0x22, 0xa6, 0xb6, 0x21, 0xa7, 0xb7, 0x1f, 0xa8, 0x8b, 0x1b, 0xe9, 0x02, 0xa0, 0x80, 0xe1, 0x1a, 0xaa, 0xf8, 0x18, 0xab, 0xfd, 0x17, 0xac, @@ -1351,7 +1370,7 @@ static const unsigned char uname2c_tree[222744] = { 0xa3, 0x00, 0xf4, 0xe0, 0xa3, 0x00, 0xf8, 0xe1, 0xa3, 0x40, 0xf0, 0xe7, 0xa3, 0x00, 0xf4, 0xe4, 0xa3, 0x00, 0xf8, 0xe5, 0xa3, 0x40, 0xe5, 0x06, 0xa0, 0x80, 0x13, 0xf0, 0x03, 0xa0, 0x00, 0xf4, 0x00, 0xa0, 0x80, 0x04, - 0xf8, 0x01, 0xa0, 0x40, 0x4c, 0x5c, 0x20, 0x15, 0xa0, 0x40, 0xf0, 0x07, + 0xf8, 0x01, 0xa0, 0x40, 0x4c, 0x7d, 0x21, 0x15, 0xa0, 0x40, 0xf0, 0x07, 0xa0, 0x00, 0xf4, 0x04, 0xa0, 0x00, 0xf8, 0x05, 0xa0, 0x40, 0xe1, 0x73, 0xa2, 0x80, 0x97, 0x04, 0xe5, 0x7e, 0xa2, 0x80, 0x89, 0x04, 0xa9, 0xf9, 0x03, 0xac, 0xec, 0x02, 0xad, 0xec, 0x01, 0xae, 0x8b, 0x01, 0xef, 0x7b, @@ -1497,525 +1516,334 @@ static const unsigned char uname2c_tree[222744] = { 0x40, 0xa2, 0xd3, 0x02, 0xa3, 0xb1, 0x02, 0xa4, 0xa4, 0x02, 0xa7, 0x83, 0x02, 0xa8, 0xe5, 0x01, 0xaa, 0xcc, 0x01, 0xab, 0xbf, 0x01, 0xac, 0xad, 0x01, 0xad, 0xa0, 0x01, 0xae, 0x83, 0x01, 0x42, 0x1f, 0x00, 0xa9, 0xa4, - 0x00, 0xb0, 0x6f, 0x43, 0xbb, 0xf4, 0x90, 0xa4, 0x00, 0xb3, 0x49, 0xb4, + 0x00, 0xb0, 0x6f, 0x43, 0x90, 0xfa, 0x90, 0xa4, 0x00, 0xb3, 0x49, 0xb4, 0x3d, 0xb6, 0x2f, 0x42, 0x15, 0x02, 0xb8, 0xa4, 0x00, 0xb9, 0x1d, 0xba, 0x01, 0xff, 0xe1, 0xb2, 0xa4, 0x00, 0x42, 0x1b, 0x05, 0xab, 0xa4, 0x00, - 0xb5, 0x06, 0x44, 0x89, 0xf3, 0xc4, 0xa4, 0x40, 0xf0, 0xa2, 0xa4, 0x00, + 0xb5, 0x06, 0x44, 0x64, 0xf9, 0xc4, 0xa4, 0x40, 0xf0, 0xa2, 0xa4, 0x00, 0xf2, 0xc1, 0xa4, 0x40, 0x42, 0x52, 0x00, 0xae, 0xa4, 0x00, 0xef, 0x9d, - 0xa4, 0x40, 0x42, 0xeb, 0x0a, 0xb1, 0xa4, 0x00, 0x42, 0x42, 0x00, 0xaf, + 0xa4, 0x40, 0x42, 0x57, 0x0b, 0xb1, 0xa4, 0x00, 0x42, 0x42, 0x00, 0xaf, 0xa4, 0x40, 0x42, 0x8a, 0x00, 0xa0, 0xa4, 0x00, 0xf5, 0xa8, 0xa4, 0x40, 0xa8, 0x06, 0x42, 0x5a, 0x03, 0x95, 0xa4, 0x40, 0x42, 0x8a, 0x00, 0xc0, 0xa4, 0x00, 0x42, 0x1f, 0x00, 0xc2, 0xa4, 0x00, 0x42, 0x42, 0x00, 0xba, 0xa4, 0x00, 0xf9, 0xb0, 0xa4, 0x40, 0x42, 0x29, 0x08, 0x9e, 0xa4, 0x00, - 0x42, 0x4c, 0x69, 0xac, 0xa4, 0x40, 0x43, 0xf9, 0xbb, 0xc5, 0xa4, 0x00, - 0xb9, 0x06, 0x43, 0x09, 0xf5, 0xb4, 0xa4, 0x40, 0x42, 0xba, 0x04, 0x93, + 0x42, 0x78, 0x6c, 0xac, 0xa4, 0x40, 0x43, 0x96, 0xc1, 0xc5, 0xa4, 0x00, + 0xb9, 0x06, 0x43, 0xe1, 0xfa, 0xb4, 0xa4, 0x40, 0x42, 0xba, 0x04, 0x93, 0xa4, 0x00, 0x42, 0x1f, 0x00, 0xa7, 0xa4, 0x40, 0xe9, 0x98, 0xa4, 0x00, 0x42, 0x1f, 0x00, 0x9c, 0xa4, 0x40, 0xe9, 0x91, 0xa4, 0x80, 0x06, 0x42, - 0x07, 0x22, 0x9a, 0xa4, 0x40, 0xe5, 0xbb, 0xa4, 0x40, 0xe5, 0xc6, 0xa4, + 0x28, 0x23, 0x9a, 0xa4, 0x40, 0xe5, 0xbb, 0xa4, 0x40, 0xe5, 0xc6, 0xa4, 0x00, 0x42, 0x52, 0x00, 0x92, 0xa4, 0x40, 0xaa, 0x04, 0xef, 0xb3, 0xa4, 0x40, 0x42, 0xf4, 0x02, 0xb7, 0xa4, 0x00, 0x42, 0x29, 0x08, 0xaa, 0xa4, 0x00, 0xf9, 0xb5, 0xa4, 0x40, 0x42, 0xc3, 0x07, 0xad, 0xa4, 0x00, 0xb8, 0x01, 0xff, 0x42, 0x52, 0x00, 0x99, 0xa4, 0x00, 0x42, 0x1f, 0x00, 0xbf, 0xa4, 0x00, 0x42, 0x1a, 0x05, 0x9f, 0xa4, 0x40, 0xe1, 0xa1, 0xa4, 0x00, - 0x42, 0xeb, 0x0a, 0x97, 0xa4, 0x00, 0xa7, 0x06, 0x42, 0x1b, 0x05, 0xb6, + 0x42, 0x57, 0x0b, 0x97, 0xa4, 0x00, 0xa7, 0x06, 0x42, 0x1b, 0x05, 0xb6, 0xa4, 0x40, 0x42, 0x1f, 0x00, 0x96, 0xa4, 0x00, 0x42, 0x1a, 0x05, 0xa6, - 0xa4, 0x40, 0x43, 0x07, 0x74, 0xa4, 0xa4, 0x00, 0xf5, 0xb9, 0xa4, 0x40, + 0xa4, 0x40, 0x43, 0x33, 0x77, 0xa4, 0xa4, 0x00, 0xf5, 0xb9, 0xa4, 0x40, 0x42, 0xb0, 0x01, 0xc3, 0xa4, 0x00, 0x42, 0xba, 0x04, 0xbe, 0xa4, 0x00, - 0x43, 0xd6, 0xf4, 0xbd, 0xa4, 0x00, 0xf9, 0xbc, 0xa4, 0xc0, 0x00, 0xf0, - 0x94, 0xa4, 0x00, 0xf4, 0xa3, 0xa4, 0x40, 0x43, 0x6a, 0x0d, 0x9b, 0xa4, - 0x00, 0x42, 0x42, 0x00, 0xa5, 0xa4, 0x40, 0x4a, 0x4c, 0xad, 0x9b, 0xf4, - 0x01, 0x46, 0xc3, 0x04, 0xa5, 0x00, 0x00, 0x05, 0xc9, 0xec, 0x01, 0xff, - 0x0a, 0x48, 0x59, 0xa0, 0x02, 0x50, 0x9d, 0x63, 0xad, 0x0e, 0x01, 0x07, - 0xec, 0x05, 0x01, 0xff, 0x42, 0xb7, 0x05, 0x81, 0x0e, 0x01, 0xa3, 0xf8, - 0x01, 0x02, 0xf0, 0x10, 0xeb, 0x01, 0xa5, 0xd4, 0x01, 0x42, 0x0c, 0x08, - 0x99, 0x0e, 0x01, 0x43, 0x10, 0xb9, 0x9f, 0x0e, 0x01, 0xa8, 0xb9, 0x01, - 0x42, 0x72, 0x19, 0x90, 0x0e, 0x01, 0xab, 0xa4, 0x01, 0x43, 0xb0, 0x00, - 0xa0, 0x0e, 0x81, 0x96, 0x01, 0x43, 0xc2, 0x90, 0xa1, 0x0e, 0x01, 0x43, - 0xde, 0x22, 0xa2, 0x0e, 0x01, 0x42, 0xd1, 0x00, 0xa5, 0x0e, 0x01, 0xb0, - 0x78, 0x43, 0x43, 0x14, 0x9c, 0x0e, 0x01, 0xb2, 0x66, 0xb3, 0x4e, 0xb4, - 0x42, 0x42, 0x48, 0x04, 0xa3, 0x0e, 0x01, 0x42, 0xf5, 0x0a, 0x9a, 0x0e, - 0x81, 0x2f, 0x43, 0x9f, 0x8a, 0xa4, 0x0e, 0x01, 0xb8, 0x1d, 0x43, 0xfd, - 0xf4, 0xa8, 0x0e, 0x81, 0x10, 0xba, 0x01, 0xff, 0xe1, 0x8f, 0x0e, 0x81, - 0x04, 0xe5, 0x96, 0x0e, 0x41, 0xec, 0x8c, 0x0e, 0x41, 0x56, 0x7c, 0x32, - 0xb1, 0x0e, 0x41, 0xe1, 0x8a, 0x0e, 0x01, 0x44, 0x51, 0xf0, 0x98, 0x0e, - 0x41, 0x4f, 0x0d, 0x69, 0x9b, 0x0e, 0x41, 0xe1, 0x95, 0x0e, 0x01, 0x42, + 0x43, 0xae, 0xfa, 0xbd, 0xa4, 0x00, 0xf9, 0xbc, 0xa4, 0xc0, 0x00, 0xf0, + 0x94, 0xa4, 0x00, 0xf4, 0xa3, 0xa4, 0x40, 0x43, 0xf8, 0x0d, 0x9b, 0xa4, + 0x00, 0x42, 0x42, 0x00, 0xa5, 0xa4, 0x40, 0x4a, 0xa8, 0xb2, 0x9b, 0xf4, + 0x01, 0x46, 0xc3, 0x04, 0xa5, 0x00, 0x00, 0x05, 0x8c, 0xf2, 0x01, 0xff, + 0x0a, 0xc2, 0x5b, 0xa0, 0x02, 0x50, 0x8a, 0x66, 0xad, 0x0e, 0x01, 0x07, + 0x13, 0x06, 0x01, 0xff, 0x42, 0xb7, 0x05, 0x81, 0x0e, 0x01, 0xa3, 0xf8, + 0x01, 0x02, 0x7b, 0x08, 0xeb, 0x01, 0xa5, 0xd4, 0x01, 0x42, 0x0c, 0x08, + 0x99, 0x0e, 0x01, 0x43, 0x89, 0xbe, 0x9f, 0x0e, 0x01, 0xa8, 0xb9, 0x01, + 0x42, 0x78, 0x1a, 0x90, 0x0e, 0x01, 0xab, 0xa4, 0x01, 0x43, 0xb0, 0x00, + 0xa0, 0x0e, 0x81, 0x96, 0x01, 0x43, 0x62, 0x95, 0xa1, 0x0e, 0x01, 0x43, + 0x18, 0x24, 0xa2, 0x0e, 0x01, 0x42, 0xd1, 0x00, 0xa5, 0x0e, 0x01, 0xb0, + 0x78, 0x43, 0x11, 0x15, 0x9c, 0x0e, 0x01, 0xb2, 0x66, 0xb3, 0x4e, 0xb4, + 0x42, 0x42, 0x48, 0x04, 0xa3, 0x0e, 0x01, 0x42, 0x61, 0x0b, 0x9a, 0x0e, + 0x81, 0x2f, 0x43, 0x1c, 0x8f, 0xa4, 0x0e, 0x01, 0xb8, 0x1d, 0x43, 0xd5, + 0xfa, 0xa8, 0x0e, 0x81, 0x10, 0xba, 0x01, 0xff, 0xe1, 0x8f, 0x0e, 0x81, + 0x04, 0xe5, 0x96, 0x0e, 0x41, 0xec, 0x8c, 0x0e, 0x41, 0x56, 0x2d, 0x34, + 0xb1, 0x0e, 0x41, 0xe1, 0x8a, 0x0e, 0x01, 0x44, 0x14, 0xf6, 0x98, 0x0e, + 0x41, 0x4f, 0x2a, 0x6c, 0x9b, 0x0e, 0x41, 0xe1, 0x95, 0x0e, 0x01, 0x42, 0xb0, 0x01, 0x84, 0x0e, 0x41, 0x42, 0xe8, 0x01, 0x93, 0x0e, 0x01, 0xe5, - 0x85, 0x0e, 0x01, 0x43, 0x7a, 0x16, 0x92, 0x0e, 0x01, 0x42, 0x9e, 0x01, + 0x85, 0x0e, 0x01, 0x43, 0x48, 0x17, 0x92, 0x0e, 0x01, 0x42, 0x9e, 0x01, 0x91, 0x0e, 0x41, 0xe1, 0x8d, 0x0e, 0x01, 0x42, 0x22, 0x00, 0x8e, 0x0e, 0x41, 0xe5, 0x82, 0x0e, 0x01, 0x42, 0xb0, 0x01, 0x83, 0x0e, 0x41, 0x4f, - 0x90, 0x3b, 0xb0, 0x0e, 0x41, 0x42, 0x44, 0x14, 0x9d, 0x0e, 0x01, 0x43, - 0x3d, 0x50, 0x9e, 0x0e, 0x41, 0x42, 0xed, 0x10, 0xa7, 0x0e, 0x01, 0x42, - 0x22, 0x00, 0x89, 0x0e, 0x41, 0x43, 0xa3, 0x6a, 0x80, 0x0e, 0x01, 0xf4, - 0xa9, 0x0e, 0x01, 0xf7, 0xa6, 0x0e, 0x01, 0x42, 0x1f, 0x1d, 0x97, 0x0e, + 0x98, 0x3d, 0xb0, 0x0e, 0x41, 0x42, 0x12, 0x15, 0x9d, 0x0e, 0x01, 0x43, + 0x92, 0x52, 0x9e, 0x0e, 0x41, 0x42, 0x9c, 0x11, 0xa7, 0x0e, 0x01, 0x42, + 0x22, 0x00, 0x89, 0x0e, 0x41, 0x43, 0xc0, 0x6d, 0x80, 0x0e, 0x01, 0xf4, + 0xa9, 0x0e, 0x01, 0xf7, 0xa6, 0x0e, 0x01, 0x42, 0x25, 0x1e, 0x97, 0x0e, 0x41, 0xe4, 0x94, 0x0e, 0x01, 0xec, 0x8b, 0x0e, 0x41, 0xa8, 0x06, 0x42, - 0x29, 0x02, 0x86, 0x0e, 0x41, 0x43, 0x37, 0x39, 0x88, 0x0e, 0x01, 0x42, - 0x29, 0x02, 0x87, 0x0e, 0x41, 0x4a, 0x30, 0xab, 0xab, 0x0e, 0x01, 0x4a, - 0xc4, 0xad, 0xac, 0x0e, 0x41, 0x10, 0x4d, 0x65, 0x06, 0x4a, 0x2b, 0x83, - 0x71, 0xf9, 0x41, 0x48, 0x69, 0xc9, 0xf4, 0x6f, 0x01, 0xb4, 0x01, 0xff, - 0x4f, 0x53, 0x6e, 0xf5, 0x6f, 0x01, 0x48, 0xa1, 0xcc, 0xf6, 0x6f, 0x41, - 0x53, 0x84, 0x47, 0x27, 0x23, 0x00, 0x44, 0xed, 0xec, 0x7b, 0xfa, 0x01, - 0x07, 0xde, 0xd1, 0x06, 0x42, 0x0c, 0x00, 0xbb, 0x22, 0x40, 0x06, 0x0c, - 0x03, 0x31, 0x04, 0xda, 0x05, 0x01, 0xff, 0xa3, 0x1e, 0x48, 0xb1, 0xc5, - 0x62, 0xfa, 0x01, 0x47, 0x59, 0xd1, 0x60, 0xfa, 0x01, 0x45, 0x41, 0xb3, - 0x63, 0xfa, 0x01, 0x48, 0x41, 0xc8, 0x61, 0xfa, 0x01, 0x47, 0x06, 0xd6, - 0x66, 0xfa, 0x41, 0x45, 0x72, 0xe4, 0x65, 0xfa, 0x01, 0x46, 0xcc, 0x57, - 0x64, 0xfa, 0x41, 0xa3, 0x1e, 0x48, 0xb1, 0xc5, 0x69, 0xfa, 0x01, 0x47, - 0x59, 0xd1, 0x67, 0xfa, 0x01, 0x45, 0x41, 0xb3, 0x6a, 0xfa, 0x01, 0x48, - 0x41, 0xc8, 0x68, 0xfa, 0x01, 0x47, 0x06, 0xd6, 0x6d, 0xfa, 0x41, 0x45, - 0x72, 0xe4, 0x6c, 0xfa, 0x01, 0x46, 0xcc, 0x57, 0x6b, 0xfa, 0x41, 0xa1, - 0xa4, 0x0e, 0xa5, 0xef, 0x0d, 0xa8, 0xfa, 0x03, 0xa9, 0x90, 0x01, 0xea, - 0x60, 0x20, 0x00, 0xaf, 0x23, 0xb2, 0x01, 0xff, 0x4d, 0x9e, 0x80, 0x81, - 0xf3, 0x01, 0xa5, 0x06, 0x4a, 0x54, 0xa2, 0x0d, 0x27, 0x40, 0x4b, 0x79, - 0x99, 0x40, 0x22, 0x00, 0x43, 0xc8, 0x25, 0x27, 0xf5, 0x01, 0x46, 0x3c, - 0xe0, 0x3c, 0xf9, 0x41, 0x47, 0x04, 0xd3, 0x3a, 0xf4, 0x01, 0xad, 0x2f, - 0x46, 0xc3, 0x04, 0xa9, 0x20, 0x00, 0x42, 0x79, 0x0c, 0xb5, 0xfa, 0x01, - 0xb2, 0x01, 0xff, 0x02, 0x06, 0x00, 0x10, 0x46, 0xc6, 0xdd, 0xfa, 0xf5, - 0x01, 0xed, 0xb1, 0xfa, 0x01, 0x49, 0xdf, 0xbe, 0x1f, 0xf6, 0x41, 0x46, - 0xa7, 0x61, 0x60, 0x20, 0x00, 0x54, 0xe3, 0x45, 0x31, 0x2e, 0x40, 0x42, - 0x1a, 0x00, 0x69, 0xf4, 0x81, 0x06, 0x4a, 0x18, 0xaa, 0xba, 0xf6, 0x41, - 0x50, 0x9d, 0x60, 0x6f, 0xf4, 0x01, 0x02, 0x31, 0x01, 0x01, 0xff, 0x45, - 0xf4, 0xe4, 0x62, 0xf4, 0x01, 0x47, 0x1e, 0xd0, 0x5a, 0xf4, 0x01, 0x43, - 0x96, 0x21, 0x52, 0xf4, 0x01, 0x46, 0x6c, 0xbc, 0x61, 0xf4, 0x41, 0x0a, - 0xf3, 0x1b, 0x45, 0x52, 0xf8, 0x51, 0x3e, 0x2e, 0x00, 0x4b, 0x25, 0x9f, - 0x40, 0xf9, 0x01, 0xae, 0x11, 0x02, 0x88, 0x00, 0x01, 0xff, 0x4a, 0x32, - 0xa9, 0xae, 0xf5, 0x01, 0x44, 0xec, 0x00, 0xdc, 0xf6, 0x41, 0xa4, 0x10, - 0x47, 0xaa, 0xd0, 0x77, 0xf3, 0x01, 0xe7, 0xbd, 0xfa, 0x01, 0x49, 0x95, - 0xb0, 0x09, 0xf6, 0x41, 0x80, 0x06, 0x42, 0xd1, 0x00, 0x9f, 0xfa, 0x41, - 0x4c, 0xdc, 0x8c, 0x2c, 0xf3, 0x01, 0x45, 0x49, 0xe5, 0x90, 0xf3, 0x41, - 0x0a, 0xa5, 0x01, 0xfb, 0x01, 0x0a, 0xea, 0x01, 0xd8, 0x01, 0x06, 0xb4, - 0x01, 0x8e, 0x01, 0x0b, 0xb3, 0x02, 0x6c, 0x06, 0xa3, 0x20, 0x23, 0x08, - 0x50, 0x02, 0x01, 0xff, 0x4a, 0x07, 0x3f, 0x69, 0xf8, 0x01, 0x50, 0x01, - 0x3f, 0x79, 0xf8, 0x01, 0x50, 0xad, 0x64, 0x61, 0xf8, 0x01, 0x51, 0x23, - 0x5c, 0x71, 0xf8, 0x01, 0x55, 0xfc, 0x3e, 0x81, 0xf8, 0x41, 0x05, 0xaf, - 0x23, 0x23, 0x05, 0xda, 0x1a, 0x01, 0xff, 0x4a, 0x07, 0x3f, 0x6f, 0xf8, - 0x01, 0x50, 0x01, 0x3f, 0x7f, 0xf8, 0x01, 0x50, 0xad, 0x64, 0x67, 0xf8, - 0x01, 0x51, 0x23, 0x5c, 0x77, 0xf8, 0x01, 0x55, 0xfc, 0x3e, 0x87, 0xf8, - 0x41, 0x4a, 0x07, 0x3f, 0x6e, 0xf8, 0x01, 0x50, 0x01, 0x3f, 0x7e, 0xf8, - 0x01, 0x50, 0xad, 0x64, 0x66, 0xf8, 0x01, 0x51, 0x23, 0x5c, 0x76, 0xf8, - 0x01, 0x55, 0xfc, 0x3e, 0x86, 0xf8, 0x41, 0x4a, 0x07, 0x3f, 0x6a, 0xf8, - 0x01, 0x50, 0x01, 0x3f, 0x7a, 0xf8, 0x01, 0x50, 0xad, 0x64, 0x62, 0xf8, - 0x01, 0x51, 0x23, 0x5c, 0x72, 0xf8, 0x01, 0x55, 0xfc, 0x3e, 0x82, 0xf8, - 0x41, 0x05, 0xaf, 0x23, 0x23, 0x05, 0xda, 0x1a, 0x01, 0xff, 0x4a, 0x07, - 0x3f, 0x6c, 0xf8, 0x01, 0x50, 0x01, 0x3f, 0x7c, 0xf8, 0x01, 0x50, 0xad, - 0x64, 0x64, 0xf8, 0x01, 0x51, 0x23, 0x5c, 0x74, 0xf8, 0x01, 0x55, 0xfc, - 0x3e, 0x84, 0xf8, 0x41, 0x4a, 0x07, 0x3f, 0x6d, 0xf8, 0x01, 0x50, 0x01, - 0x3f, 0x7d, 0xf8, 0x01, 0x50, 0xad, 0x64, 0x65, 0xf8, 0x01, 0x51, 0x23, - 0x5c, 0x75, 0xf8, 0x01, 0x55, 0xfc, 0x3e, 0x85, 0xf8, 0x41, 0x4a, 0x07, - 0x3f, 0x68, 0xf8, 0x01, 0x50, 0x01, 0x3f, 0x78, 0xf8, 0x01, 0x50, 0xad, - 0x64, 0x60, 0xf8, 0x01, 0x51, 0x23, 0x5c, 0x70, 0xf8, 0x01, 0x55, 0xfc, - 0x3e, 0x80, 0xf8, 0x41, 0x4a, 0x07, 0x3f, 0x6b, 0xf8, 0x01, 0x50, 0x01, - 0x3f, 0x7b, 0xf8, 0x01, 0x50, 0xad, 0x64, 0x63, 0xf8, 0x01, 0x51, 0x23, - 0x5c, 0x73, 0xf8, 0x01, 0x55, 0xfc, 0x3e, 0x83, 0xf8, 0x41, 0x43, 0x67, - 0x00, 0x0b, 0xf4, 0x01, 0x43, 0x2d, 0x13, 0xde, 0xf6, 0x81, 0xd8, 0x09, - 0x03, 0xaf, 0x02, 0x01, 0xff, 0x80, 0x06, 0x5b, 0x27, 0x1a, 0xb3, 0x27, - 0x40, 0x12, 0x36, 0x50, 0xba, 0x09, 0x46, 0xb4, 0x21, 0xe6, 0x25, 0x00, - 0xa3, 0xb1, 0x06, 0xa4, 0xc0, 0x05, 0x59, 0xe0, 0x12, 0x55, 0x27, 0x00, - 0xa6, 0x83, 0x05, 0xa8, 0xc3, 0x04, 0xac, 0xe5, 0x03, 0xad, 0xb7, 0x03, - 0x43, 0x61, 0x9d, 0x11, 0x27, 0x00, 0xb0, 0x97, 0x03, 0x56, 0x9c, 0x36, - 0x54, 0x27, 0x00, 0xb2, 0xd4, 0x02, 0xb3, 0x7c, 0xb4, 0x5a, 0x02, 0x50, - 0x02, 0x28, 0x03, 0x32, 0x00, 0x01, 0xff, 0x06, 0x35, 0x00, 0x06, 0x4e, - 0x84, 0x0a, 0x1e, 0x2b, 0x40, 0x43, 0x16, 0x00, 0xfe, 0x2a, 0x00, 0x47, - 0xe6, 0x66, 0x2f, 0x2b, 0x00, 0x49, 0x8a, 0x47, 0xaf, 0x25, 0xc0, 0x00, - 0x54, 0x07, 0x40, 0x06, 0xce, 0x41, 0x0a, 0x9b, 0x01, 0x1e, 0x0a, 0x8c, - 0x0b, 0x01, 0xff, 0x47, 0x51, 0x4e, 0xca, 0xfb, 0x01, 0x4e, 0x26, 0x0c, - 0xb5, 0x25, 0x00, 0x48, 0x01, 0x02, 0xb3, 0x25, 0xc0, 0x00, 0x49, 0x90, - 0x3b, 0xec, 0x25, 0x40, 0x4e, 0xfb, 0x26, 0x46, 0xf4, 0x01, 0x45, 0x8f, - 0x13, 0x1d, 0x26, 0x40, 0x48, 0x32, 0x3d, 0x0f, 0x26, 0x00, 0x52, 0x5c, - 0x54, 0x7e, 0xf5, 0x01, 0xb2, 0x06, 0x57, 0x22, 0x32, 0xd7, 0x26, 0x40, - 0x47, 0x0d, 0xcf, 0xe2, 0x23, 0x00, 0x66, 0x4b, 0x07, 0xc1, 0x27, 0x40, - 0x47, 0x62, 0x3e, 0x04, 0x27, 0x00, 0x49, 0xc1, 0xb8, 0x46, 0xfe, 0x00, - 0x4a, 0x8d, 0x5f, 0x16, 0x26, 0x00, 0xad, 0xa2, 0x01, 0x49, 0x07, 0xbe, - 0x64, 0x26, 0x00, 0x45, 0xd7, 0x05, 0xa1, 0x25, 0x80, 0x2e, 0x43, 0x32, - 0x13, 0x06, 0x26, 0x00, 0x42, 0x42, 0x0b, 0x23, 0xf3, 0xc1, 0x00, 0x80, - 0x01, 0xff, 0x4c, 0xb8, 0x8c, 0x25, 0xf3, 0x81, 0x11, 0x05, 0x51, 0x00, - 0x01, 0xff, 0x44, 0x4d, 0x66, 0x3c, 0x26, 0x00, 0x4b, 0xd7, 0xa2, 0x24, - 0xf3, 0x41, 0x4a, 0xa8, 0xa6, 0x26, 0xf3, 0x41, 0x80, 0x01, 0xff, 0x46, - 0x18, 0x8d, 0x33, 0xf5, 0x01, 0x11, 0x51, 0x0a, 0x48, 0x05, 0x51, 0x00, - 0x01, 0xff, 0x54, 0x0b, 0x41, 0x85, 0x23, 0x00, 0xac, 0x24, 0xb2, 0x16, - 0x06, 0x6d, 0x02, 0x06, 0x57, 0xdd, 0x31, 0xeb, 0x25, 0x40, 0x4d, 0x74, - 0x0d, 0xf0, 0x25, 0x00, 0x4e, 0x6b, 0x45, 0xf3, 0x25, 0x40, 0x4e, 0xb9, - 0x72, 0xe5, 0x27, 0x00, 0x4e, 0x3c, 0x19, 0xa2, 0x25, 0x40, 0x4d, 0x67, - 0x79, 0xe4, 0x27, 0x00, 0x05, 0x14, 0x01, 0x01, 0xff, 0x4d, 0x74, 0x0d, - 0xf1, 0x25, 0x00, 0x4e, 0x6b, 0x45, 0xf2, 0x25, 0x40, 0x4d, 0xd9, 0x85, - 0x95, 0xf7, 0x01, 0x4c, 0x86, 0x0a, 0xa3, 0x25, 0x00, 0x51, 0x81, 0x0a, - 0x94, 0xf7, 0x41, 0x04, 0x5f, 0x07, 0x06, 0x4a, 0x7e, 0x95, 0x3a, 0x26, - 0x40, 0x47, 0x68, 0x0a, 0x2b, 0x2b, 0x00, 0xb3, 0x01, 0xff, 0x45, 0xd7, - 0x05, 0xab, 0x25, 0x00, 0x43, 0x32, 0x13, 0x52, 0x2b, 0x40, 0x48, 0x8b, - 0x47, 0xad, 0x25, 0x00, 0x04, 0xc9, 0x00, 0x01, 0xff, 0x0a, 0x9b, 0x01, - 0x1f, 0x0a, 0x8c, 0x0b, 0x01, 0xff, 0xb0, 0x0c, 0x4e, 0x26, 0x0c, 0xb9, - 0x25, 0x00, 0x48, 0x01, 0x02, 0xb7, 0x25, 0x40, 0x47, 0x02, 0xca, 0x54, - 0x2b, 0x00, 0x46, 0xf1, 0x49, 0xbb, 0x25, 0x40, 0x4e, 0xfb, 0x26, 0x49, - 0xf4, 0x01, 0x45, 0x8f, 0x13, 0x1e, 0x26, 0x40, 0x4c, 0x7c, 0x8c, 0xb1, - 0x25, 0x00, 0x02, 0x92, 0x01, 0x01, 0xff, 0x44, 0x47, 0x33, 0xf1, 0xf3, - 0x01, 0x45, 0x04, 0xca, 0x20, 0x2b, 0x40, 0x06, 0x45, 0x04, 0x06, 0x4a, - 0x04, 0xaf, 0xdd, 0x2b, 0x40, 0x47, 0x9c, 0x44, 0x26, 0x2b, 0x00, 0x47, - 0x68, 0x0a, 0x28, 0x2b, 0x00, 0xb3, 0x01, 0xff, 0x4b, 0x87, 0x0a, 0xfd, - 0x25, 0x00, 0x45, 0xd7, 0x05, 0xfb, 0x25, 0x00, 0x43, 0x32, 0x13, 0x50, - 0x2b, 0x40, 0xa1, 0x4d, 0x03, 0xc4, 0x00, 0x19, 0xaf, 0x01, 0xff, 0x04, - 0x15, 0x01, 0x06, 0x64, 0x4b, 0x0a, 0xa0, 0xf7, 0x41, 0x4c, 0x20, 0x91, - 0x86, 0xcc, 0x01, 0x4d, 0xee, 0x87, 0x87, 0xcc, 0x41, 0x80, 0x17, 0x0a, - 0x8c, 0x0b, 0x01, 0xff, 0x47, 0xf0, 0x49, 0xc5, 0x25, 0x00, 0x4e, 0x26, - 0x0c, 0xc3, 0x25, 0x00, 0x48, 0x01, 0x02, 0xc1, 0x25, 0x40, 0x4a, 0xa2, - 0xac, 0xd9, 0x26, 0x00, 0x09, 0x9c, 0x01, 0x01, 0xff, 0x4e, 0xfb, 0x26, - 0x48, 0xf4, 0x01, 0x45, 0x8f, 0x13, 0x1c, 0x26, 0x40, 0x4a, 0x58, 0xb0, - 0x1c, 0x2b, 0x00, 0x49, 0x6c, 0x9e, 0x46, 0xf5, 0x41, 0x55, 0x68, 0x39, - 0xab, 0xf5, 0x01, 0xa5, 0x0f, 0xaf, 0x01, 0xff, 0x50, 0xdd, 0x66, 0x2d, - 0x2b, 0x00, 0x47, 0x1e, 0xd7, 0xd6, 0x29, 0x40, 0xa1, 0x06, 0x45, 0xa8, - 0xd1, 0x21, 0x2b, 0x40, 0x42, 0x34, 0x00, 0x0d, 0xf9, 0x81, 0x11, 0x03, - 0x70, 0x15, 0x01, 0xff, 0x4a, 0xc4, 0xa8, 0x05, 0x27, 0x00, 0x5c, 0x2e, - 0x19, 0xc0, 0xfb, 0x41, 0x45, 0xb9, 0x27, 0x61, 0x26, 0x40, 0xac, 0x16, - 0x0c, 0x1c, 0x13, 0x06, 0x4c, 0x29, 0x83, 0x39, 0x26, 0x40, 0x44, 0x12, - 0x16, 0xce, 0x2b, 0x00, 0x44, 0x31, 0x13, 0x27, 0x27, 0x40, 0x42, 0x23, - 0x02, 0x90, 0x26, 0x80, 0x0f, 0xaf, 0x01, 0xff, 0x45, 0xaf, 0x0f, 0x40, - 0x27, 0x00, 0x43, 0x15, 0x01, 0xae, 0xf4, 0x41, 0x64, 0xbf, 0x08, 0xff, - 0x26, 0x40, 0x46, 0x9d, 0x44, 0xc7, 0x25, 0x80, 0x3c, 0x03, 0xa6, 0x01, - 0x11, 0x08, 0x59, 0xca, 0x01, 0xff, 0x44, 0xcd, 0x34, 0xc1, 0x26, 0x00, - 0x43, 0x5d, 0x18, 0xc0, 0x26, 0x40, 0x0a, 0x9b, 0x01, 0x11, 0x0a, 0x8c, - 0x0b, 0x01, 0xff, 0x4e, 0x26, 0x0c, 0xbf, 0x25, 0x00, 0x48, 0x01, 0x02, - 0xbd, 0x25, 0x40, 0x4e, 0xfb, 0x26, 0x47, 0xf4, 0x01, 0x45, 0x8f, 0x13, - 0x1f, 0x26, 0x00, 0x4f, 0x8e, 0x6f, 0x97, 0xf5, 0x41, 0x80, 0x01, 0xff, - 0x11, 0x51, 0x0a, 0x12, 0x49, 0x71, 0xba, 0xcb, 0x26, 0x00, 0x44, 0xba, - 0x27, 0x62, 0x26, 0x00, 0x50, 0xbd, 0x68, 0xd0, 0x27, 0x40, 0x4e, 0xe4, - 0x79, 0x9b, 0xf7, 0x01, 0x4d, 0x7d, 0x56, 0xc8, 0x25, 0x00, 0x52, 0x78, - 0x56, 0x9a, 0xf7, 0x41, 0x05, 0x60, 0x88, 0x70, 0x45, 0x13, 0x03, 0xcb, - 0x25, 0x80, 0x24, 0x48, 0x31, 0xc8, 0x67, 0x26, 0x00, 0x54, 0x8f, 0x44, - 0xe1, 0x27, 0x80, 0x06, 0x49, 0x0b, 0xa9, 0xcb, 0xfb, 0x41, 0x06, 0x50, - 0x00, 0x01, 0xff, 0x4e, 0x66, 0x79, 0xe2, 0x27, 0x00, 0x4f, 0xb8, 0x72, - 0xe3, 0x27, 0x40, 0x80, 0x01, 0xff, 0x5d, 0x2e, 0x15, 0x8a, 0xf7, 0x01, - 0x05, 0x51, 0x00, 0x01, 0xff, 0x02, 0x3b, 0x01, 0x27, 0x06, 0x13, 0x01, - 0x17, 0x48, 0x1f, 0x0a, 0x87, 0x26, 0x00, 0x06, 0x6d, 0x02, 0x01, 0xff, - 0x4d, 0x74, 0x0d, 0xf4, 0x25, 0x00, 0x4e, 0x6b, 0x45, 0xf7, 0x25, 0x40, - 0x4d, 0x74, 0x0d, 0xf5, 0x25, 0x00, 0x4e, 0x6b, 0x45, 0xf6, 0x25, 0x40, - 0x47, 0xc6, 0x00, 0x86, 0x26, 0x00, 0x48, 0xd5, 0x41, 0xec, 0x29, 0x40, - 0x45, 0x45, 0xe4, 0x55, 0xfa, 0x01, 0x46, 0x4e, 0xda, 0x57, 0x26, 0x80, - 0xed, 0x01, 0x4a, 0x36, 0xaa, 0x48, 0xfa, 0x81, 0xdf, 0x01, 0x44, 0xdd, - 0xef, 0x54, 0xfa, 0x01, 0xab, 0x73, 0x44, 0x21, 0xf2, 0x59, 0x26, 0x80, - 0x5b, 0x45, 0x73, 0xbe, 0x55, 0x26, 0x80, 0x43, 0x44, 0x81, 0xf2, 0x56, - 0x26, 0x80, 0x2b, 0x07, 0x27, 0x0a, 0x01, 0xff, 0x46, 0x4e, 0xda, 0x21, - 0xfa, 0x01, 0xab, 0x12, 0x44, 0x21, 0xf2, 0x23, 0xfa, 0x01, 0x45, 0x73, - 0xbe, 0x1f, 0xfa, 0x01, 0x44, 0x81, 0xf2, 0x20, 0xfa, 0x41, 0x43, 0xa1, - 0x01, 0x1e, 0xfa, 0x01, 0x45, 0x4e, 0x09, 0x22, 0xfa, 0x41, 0x09, 0xbe, - 0x2c, 0x01, 0xff, 0x4e, 0xc7, 0x2c, 0x0b, 0xfa, 0x01, 0x5b, 0xd8, 0x1d, - 0x35, 0xfa, 0x41, 0x09, 0xbe, 0x2c, 0x01, 0xff, 0x4e, 0xc7, 0x2c, 0x0a, - 0xfa, 0x01, 0x5b, 0xd8, 0x1d, 0x34, 0xfa, 0x41, 0x09, 0xbe, 0x2c, 0x01, - 0xff, 0x4e, 0xc7, 0x2c, 0x0e, 0xfa, 0x01, 0x5b, 0xd8, 0x1d, 0x38, 0xfa, - 0x41, 0x43, 0xa1, 0x01, 0x54, 0x26, 0x80, 0x4c, 0x45, 0x4e, 0x09, 0x58, - 0x26, 0xc0, 0x00, 0x09, 0xbe, 0x2c, 0x15, 0x8d, 0x01, 0xff, 0x46, 0x4e, - 0xda, 0x50, 0xfa, 0x01, 0x45, 0x73, 0xbe, 0x4e, 0xfa, 0x01, 0x44, 0x81, - 0xf2, 0x4f, 0xfa, 0x41, 0x52, 0xd4, 0x51, 0x06, 0xfa, 0x01, 0x4e, 0xc7, - 0x2c, 0x0d, 0xfa, 0x01, 0x5f, 0x6d, 0x11, 0x1b, 0xfa, 0x01, 0xb4, 0x01, - 0xff, 0x5c, 0x16, 0x18, 0x45, 0xfa, 0x01, 0x0b, 0xd9, 0x1d, 0x01, 0xff, - 0x4f, 0xe4, 0x1d, 0x37, 0xfa, 0x01, 0x53, 0xf9, 0x4d, 0x30, 0xfa, 0x41, - 0x09, 0xbe, 0x2c, 0x01, 0xff, 0x4e, 0xc7, 0x2c, 0x09, 0xfa, 0x01, 0x5b, - 0xd8, 0x1d, 0x33, 0xfa, 0x41, 0x57, 0xbe, 0x2c, 0x4b, 0xfa, 0x41, 0x09, - 0xbe, 0x2c, 0x01, 0xff, 0x4e, 0xc7, 0x2c, 0x0c, 0xfa, 0x01, 0x5b, 0xd8, - 0x1d, 0x36, 0xfa, 0x41, 0x43, 0x0e, 0x0b, 0xac, 0xf8, 0x01, 0x4a, 0x74, - 0xb2, 0xad, 0xf8, 0x41, 0x4a, 0x08, 0xa6, 0x38, 0x26, 0x00, 0x4c, 0x54, - 0x8d, 0x7f, 0x26, 0x40, 0x04, 0x44, 0x18, 0x22, 0xa4, 0x14, 0xa9, 0x06, - 0x4f, 0x4e, 0x73, 0x70, 0x26, 0x40, 0x5a, 0x1a, 0x20, 0x18, 0x21, 0x00, - 0x4a, 0xf4, 0xaa, 0xcb, 0xf3, 0x41, 0x44, 0x04, 0x06, 0x92, 0xf4, 0x01, - 0x5a, 0x8c, 0x17, 0xbc, 0x27, 0x40, 0x48, 0x64, 0x1f, 0x40, 0xf6, 0x01, - 0x44, 0x0c, 0x08, 0x29, 0xf6, 0x41, 0x44, 0x9c, 0x89, 0xc7, 0xf9, 0x01, - 0xae, 0xb5, 0x05, 0xb2, 0x95, 0x01, 0x49, 0x93, 0xbf, 0xd1, 0xf5, 0x01, - 0xb4, 0x62, 0xb6, 0x11, 0x05, 0x92, 0xec, 0x01, 0xff, 0x54, 0x47, 0x41, - 0x12, 0xf3, 0x01, 0x53, 0xbe, 0x49, 0x14, 0xf3, 0x41, 0x02, 0x60, 0x00, - 0x35, 0x04, 0xa1, 0x01, 0x1f, 0x02, 0x09, 0x00, 0x01, 0xff, 0x44, 0x8f, - 0x12, 0x30, 0x30, 0x00, 0xac, 0x06, 0x48, 0x97, 0x8a, 0x4b, 0xfe, 0x40, - 0x43, 0xee, 0x07, 0x07, 0x23, 0x00, 0x47, 0x8b, 0x8a, 0x4f, 0xfe, 0x40, - 0x4a, 0x60, 0xa8, 0xf4, 0xf3, 0x01, 0x49, 0xb4, 0x47, 0x4b, 0xf4, 0x01, - 0x4a, 0x8c, 0xb3, 0xf3, 0xf3, 0x41, 0x18, 0x51, 0x27, 0x06, 0x44, 0x8f, - 0x12, 0x1c, 0x30, 0x40, 0x44, 0xc3, 0x00, 0x3f, 0x2b, 0x00, 0x45, 0xc8, - 0x00, 0x33, 0x29, 0x40, 0x42, 0x6d, 0x14, 0x1a, 0x23, 0x00, 0x02, 0x33, - 0x00, 0x01, 0xff, 0x80, 0x06, 0x45, 0xaa, 0xe8, 0x49, 0xf3, 0x41, 0x47, - 0xd1, 0xcf, 0x03, 0xf4, 0x01, 0x46, 0xcc, 0xda, 0xbe, 0xf6, 0x01, 0x44, - 0x41, 0xf2, 0x3d, 0xf9, 0x01, 0x44, 0x89, 0x57, 0x0a, 0xf3, 0x41, 0x09, - 0x30, 0xb6, 0x06, 0x49, 0xa8, 0xbc, 0xa0, 0x26, 0x40, 0x0f, 0xe4, 0x05, - 0xd1, 0x02, 0x06, 0xef, 0x06, 0x8a, 0x02, 0x07, 0x1a, 0x3a, 0xc8, 0x01, - 0x42, 0x14, 0x05, 0xff, 0x18, 0x01, 0x0d, 0x76, 0x08, 0x01, 0xff, 0xe1, - 0xc1, 0x18, 0x81, 0xa9, 0x01, 0x42, 0x6a, 0x0d, 0xd7, 0x18, 0x01, 0x42, - 0xf0, 0x10, 0xd4, 0x18, 0x01, 0xe5, 0xc8, 0x18, 0x81, 0x8c, 0x01, 0x42, - 0x24, 0x02, 0xcb, 0x18, 0x01, 0xa8, 0x69, 0x42, 0x6d, 0x28, 0xc6, 0x18, - 0x01, 0x42, 0x4d, 0x03, 0xcc, 0x18, 0x01, 0xae, 0x4f, 0xef, 0xc9, 0x18, - 0x81, 0x44, 0x42, 0x07, 0x0c, 0xd8, 0x18, 0x01, 0xb3, 0x30, 0x43, 0xee, - 0x05, 0xd2, 0x18, 0x01, 0xb5, 0x20, 0x44, 0x2d, 0xf3, 0xdf, 0x18, 0x01, - 0x42, 0x51, 0x00, 0xc2, 0x18, 0x01, 0xb9, 0x01, 0xff, 0xe1, 0xc4, 0x18, - 0x01, 0xef, 0xc5, 0x18, 0x01, 0xf5, 0xc3, 0x18, 0xc1, 0x00, 0xea, 0xce, - 0x18, 0x41, 0xe3, 0xcf, 0x18, 0x01, 0xf5, 0xc7, 0x18, 0x41, 0x42, 0x6d, - 0x28, 0xde, 0x18, 0x01, 0x43, 0xc4, 0xf4, 0xdd, 0x18, 0x41, 0x42, 0x7f, - 0x02, 0xd1, 0x18, 0x41, 0x43, 0xa0, 0x57, 0xc0, 0x18, 0x01, 0x43, 0xb1, - 0x45, 0xd3, 0x18, 0x41, 0x42, 0x17, 0x00, 0xdc, 0x18, 0x01, 0x43, 0x92, - 0xca, 0xd9, 0x18, 0x01, 0xaf, 0x01, 0xff, 0x42, 0x13, 0x01, 0xda, 0x18, - 0x01, 0x42, 0xcf, 0x00, 0xdb, 0x18, 0x41, 0xae, 0x01, 0xff, 0xee, 0xd0, - 0x18, 0x01, 0xf9, 0xcd, 0x18, 0x41, 0xed, 0xd6, 0x18, 0x01, 0x42, 0x1d, - 0x01, 0xca, 0x18, 0x01, 0xf4, 0xd5, 0x18, 0x41, 0x46, 0x50, 0xdb, 0xf1, - 0x18, 0x01, 0xa6, 0x29, 0x46, 0xc7, 0x2c, 0xf2, 0x18, 0x01, 0xb3, 0x15, - 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0xea, 0x18, 0x01, 0x45, 0x7a, 0x11, - 0xec, 0x18, 0x01, 0x45, 0x9a, 0x2c, 0xeb, 0x18, 0x41, 0x46, 0xe5, 0x1d, - 0xf0, 0x18, 0x01, 0x44, 0x66, 0xdd, 0xef, 0x18, 0x41, 0x44, 0x58, 0x4d, - 0xee, 0x18, 0x01, 0x44, 0xd5, 0x51, 0xed, 0x18, 0x41, 0x45, 0x12, 0x0b, - 0xe8, 0x18, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0xe9, 0x18, 0x01, 0x43, - 0x0e, 0x0b, 0xe1, 0x18, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, - 0xe0, 0x18, 0x41, 0x44, 0x25, 0x01, 0xe3, 0x18, 0x01, 0x42, 0x15, 0x02, - 0xe2, 0x18, 0x41, 0x44, 0xe5, 0x1d, 0xe7, 0x18, 0x01, 0x42, 0x1c, 0x26, - 0xe6, 0x18, 0x41, 0x43, 0xd2, 0x05, 0xe5, 0x18, 0x01, 0x43, 0xf6, 0x06, - 0xe4, 0x18, 0x41, 0xe1, 0xa1, 0x18, 0x81, 0xa9, 0x01, 0x42, 0x6a, 0x0d, - 0xb7, 0x18, 0x01, 0x42, 0xf0, 0x10, 0xb4, 0x18, 0x01, 0xe5, 0xa8, 0x18, - 0x81, 0x8c, 0x01, 0x42, 0x24, 0x02, 0xab, 0x18, 0x01, 0xa8, 0x69, 0x42, - 0x6d, 0x28, 0xa6, 0x18, 0x01, 0x42, 0x4d, 0x03, 0xac, 0x18, 0x01, 0xae, - 0x4f, 0xef, 0xa9, 0x18, 0x81, 0x44, 0x42, 0x07, 0x0c, 0xb8, 0x18, 0x01, - 0xb3, 0x30, 0x43, 0xee, 0x05, 0xb2, 0x18, 0x01, 0xb5, 0x20, 0x44, 0x2d, - 0xf3, 0xbf, 0x18, 0x01, 0x42, 0x51, 0x00, 0xa2, 0x18, 0x01, 0xb9, 0x01, - 0xff, 0xe1, 0xa4, 0x18, 0x01, 0xef, 0xa5, 0x18, 0x01, 0xf5, 0xa3, 0x18, - 0xc1, 0x00, 0xea, 0xae, 0x18, 0x41, 0xe3, 0xaf, 0x18, 0x01, 0xf5, 0xa7, - 0x18, 0x41, 0x42, 0x6d, 0x28, 0xbe, 0x18, 0x01, 0x43, 0xc4, 0xf4, 0xbd, - 0x18, 0x41, 0x42, 0x7f, 0x02, 0xb1, 0x18, 0x41, 0x43, 0xa0, 0x57, 0xa0, - 0x18, 0x01, 0x43, 0xb1, 0x45, 0xb3, 0x18, 0x41, 0x42, 0x17, 0x00, 0xbc, - 0x18, 0x01, 0x43, 0x92, 0xca, 0xb9, 0x18, 0x01, 0xaf, 0x01, 0xff, 0x42, - 0x13, 0x01, 0xba, 0x18, 0x01, 0x42, 0xcf, 0x00, 0xbb, 0x18, 0x41, 0xae, - 0x01, 0xff, 0xee, 0xb0, 0x18, 0x01, 0xf9, 0xad, 0x18, 0x41, 0xed, 0xb6, - 0x18, 0x01, 0x42, 0x1d, 0x01, 0xaa, 0x18, 0x01, 0xf4, 0xb5, 0x18, 0x41, - 0x04, 0xba, 0xda, 0x11, 0x04, 0xa1, 0x01, 0x01, 0xff, 0x54, 0x47, 0x41, - 0x18, 0xf3, 0x01, 0x53, 0xbe, 0x49, 0x16, 0xf3, 0x41, 0x06, 0xef, 0x06, - 0xa6, 0x02, 0x07, 0xec, 0x05, 0x25, 0x49, 0x84, 0xbc, 0xff, 0xe2, 0x01, - 0x05, 0x56, 0x2d, 0x01, 0xff, 0x43, 0xdf, 0xde, 0xee, 0xe2, 0x81, 0x0d, - 0x43, 0x9d, 0x19, 0xec, 0xe2, 0xc1, 0x00, 0x42, 0x51, 0x03, 0xed, 0xe2, - 0x41, 0x42, 0x51, 0x03, 0xef, 0xe2, 0x41, 0xe1, 0xc1, 0xe2, 0x81, 0xdf, - 0x01, 0x42, 0x16, 0x00, 0xc2, 0xe2, 0x01, 0x42, 0x37, 0x00, 0xc3, 0xe2, - 0x01, 0x42, 0xf0, 0x10, 0xc4, 0xe2, 0x01, 0xe5, 0xdb, 0xe2, 0x81, 0xc3, - 0x01, 0x42, 0x0c, 0x08, 0xcd, 0xe2, 0x01, 0x42, 0x24, 0x02, 0xc5, 0xe2, - 0x01, 0x42, 0x22, 0x00, 0xda, 0xe2, 0x01, 0xe9, 0xdc, 0xe2, 0x81, 0xa5, - 0x01, 0x42, 0x72, 0x19, 0xd0, 0xe2, 0x01, 0xab, 0x92, 0x01, 0xac, 0x85, - 0x01, 0x42, 0x6c, 0x00, 0xd8, 0xe2, 0x01, 0xae, 0x6d, 0xef, 0xd5, 0xe2, - 0x81, 0x5f, 0xb0, 0x53, 0x42, 0x71, 0x00, 0xd7, 0xe2, 0x01, 0xb3, 0x41, - 0xb4, 0x29, 0xf5, 0xde, 0xe2, 0x81, 0x1e, 0x42, 0xf5, 0x0a, 0xd3, 0xe2, - 0x01, 0x42, 0xa9, 0x01, 0xd2, 0xe2, 0x01, 0xb9, 0x06, 0x42, 0x59, 0x00, - 0xd1, 0xe2, 0x41, 0xe1, 0xc6, 0xe2, 0x01, 0x42, 0xf5, 0x2c, 0xeb, 0xe2, - 0x41, 0x42, 0x92, 0x01, 0xea, 0xe2, 0x41, 0xe1, 0xcb, 0xe2, 0x01, 0x42, - 0x22, 0x00, 0xcc, 0xe2, 0x01, 0x42, 0x71, 0x00, 0xe1, 0xe2, 0x01, 0x42, - 0x40, 0x06, 0xe0, 0xe2, 0x41, 0xe1, 0xce, 0xe2, 0x01, 0x42, 0x22, 0x00, - 0xcf, 0xe2, 0x41, 0xe1, 0xca, 0xe2, 0x01, 0x42, 0x22, 0x00, 0xc7, 0xe2, - 0x41, 0xee, 0xe6, 0xe2, 0xc1, 0x00, 0xe7, 0xe2, 0xe2, 0x41, 0xe1, 0xc9, - 0xe2, 0x01, 0x42, 0x24, 0x02, 0xdd, 0xe2, 0x01, 0x42, 0xbe, 0x22, 0xe9, - 0xe2, 0x41, 0xe1, 0xc8, 0xe2, 0x01, 0x43, 0x2a, 0x09, 0xdf, 0xe2, 0x41, - 0xe1, 0xd4, 0xe2, 0x01, 0x42, 0x22, 0x00, 0xd9, 0xe2, 0x41, 0x42, 0x1d, - 0x01, 0xe5, 0xe2, 0x41, 0xee, 0xe7, 0xe2, 0x41, 0xe1, 0xc0, 0xe2, 0x81, - 0x0a, 0x42, 0x1d, 0x01, 0xe4, 0xe2, 0x01, 0xf5, 0xd6, 0xe2, 0x41, 0xee, - 0xe8, 0xe2, 0xc1, 0x00, 0xe7, 0xe3, 0xe2, 0x41, 0x45, 0x12, 0x0b, 0xf8, - 0xe2, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0xf9, 0xe2, 0x01, 0x43, 0x0e, - 0x0b, 0xf1, 0xe2, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xf0, - 0xe2, 0x41, 0x44, 0x25, 0x01, 0xf3, 0xe2, 0x01, 0x42, 0x15, 0x02, 0xf2, - 0xe2, 0x41, 0x44, 0xe5, 0x1d, 0xf7, 0xe2, 0x01, 0x42, 0x1c, 0x26, 0xf6, - 0xe2, 0x41, 0x43, 0xd2, 0x05, 0xf5, 0xe2, 0x01, 0x43, 0xf6, 0x06, 0xf4, - 0xe2, 0x41, 0xa1, 0xb8, 0x13, 0xa5, 0xeb, 0x0d, 0xa9, 0xf0, 0x09, 0xaf, - 0xd2, 0x09, 0xb3, 0xa6, 0x01, 0xf4, 0x0b, 0x00, 0x80, 0x9c, 0x01, 0x02, - 0x1f, 0x01, 0x01, 0xff, 0x45, 0x17, 0xe5, 0xe6, 0x2b, 0x00, 0x0d, 0x4f, - 0x83, 0x01, 0xff, 0xa6, 0x74, 0x04, 0x0e, 0x0b, 0x35, 0x4d, 0x02, 0x4d, - 0x5e, 0x21, 0x00, 0xb4, 0x06, 0x4b, 0x97, 0xa5, 0x89, 0x21, 0x40, 0x05, - 0x25, 0x01, 0x11, 0x03, 0x20, 0x0a, 0x01, 0xff, 0x46, 0x62, 0xaf, 0x56, - 0x21, 0x00, 0x46, 0xf5, 0x74, 0x54, 0x21, 0x40, 0x47, 0x08, 0x4d, 0x5c, - 0x21, 0x00, 0x46, 0x62, 0xaf, 0x57, 0x21, 0x00, 0x48, 0x2a, 0x01, 0xbe, - 0x00, 0x40, 0x46, 0x12, 0x0b, 0x5b, 0x21, 0x00, 0x45, 0x62, 0xaf, 0x55, - 0x21, 0x00, 0x44, 0x22, 0x00, 0xbd, 0x00, 0x00, 0x45, 0x40, 0xe9, 0x51, - 0x21, 0x00, 0x47, 0x2a, 0x01, 0xbc, 0x00, 0x00, 0xb3, 0x0f, 0xb4, 0x01, - 0xff, 0x44, 0x9e, 0x1b, 0x52, 0x21, 0x00, 0x44, 0xf6, 0x74, 0x53, 0x21, - 0x40, 0x46, 0xb0, 0xdb, 0x50, 0x21, 0x00, 0x44, 0x48, 0xac, 0x59, 0x21, - 0x40, 0x04, 0xd2, 0x05, 0x06, 0x4a, 0x5e, 0xaf, 0x58, 0x21, 0x40, 0x47, - 0x08, 0x4d, 0x5d, 0x21, 0x00, 0x46, 0x06, 0xe0, 0x5a, 0x21, 0x40, 0xf3, - 0x8a, 0x00, 0x40, 0xd1, 0x00, 0xfe, 0x80, 0xda, 0x04, 0xd2, 0x01, 0xfe, - 0x80, 0xbf, 0x02, 0xd3, 0x02, 0xfe, 0x80, 0x91, 0x02, 0xd4, 0x03, 0xfe, - 0x80, 0xe3, 0x01, 0xd5, 0x04, 0xfe, 0x80, 0xb5, 0x01, 0xd6, 0x05, 0xfe, - 0x80, 0x87, 0x01, 0xd7, 0x06, 0xfe, 0x80, 0x5a, 0xd8, 0x07, 0xfe, 0x80, - 0x2d, 0xd9, 0x08, 0xfe, 0xc0, 0x00, 0xd0, 0x49, 0x01, 0x0e, 0xd1, 0x4a, - 0x01, 0x0e, 0xd2, 0x4b, 0x01, 0x0e, 0xd3, 0x4c, 0x01, 0x0e, 0xd4, 0x4d, - 0x01, 0x0e, 0xd5, 0x4e, 0x01, 0x0e, 0xd6, 0x4f, 0x01, 0x0e, 0xd7, 0x50, - 0x01, 0x0e, 0xd8, 0x51, 0x01, 0x0e, 0xd9, 0x52, 0x01, 0x4e, 0xd0, 0x3f, - 0x01, 0x0e, 0xd1, 0x40, 0x01, 0x0e, 0xd2, 0x41, 0x01, 0x0e, 0xd3, 0x42, - 0x01, 0x0e, 0xd4, 0x43, 0x01, 0x0e, 0xd5, 0x44, 0x01, 0x0e, 0xd6, 0x45, - 0x01, 0x0e, 0xd7, 0x46, 0x01, 0x0e, 0xd8, 0x47, 0x01, 0x0e, 0xd9, 0x48, - 0x01, 0x4e, 0xd0, 0x35, 0x01, 0x0e, 0xd1, 0x36, 0x01, 0x0e, 0xd2, 0x37, - 0x01, 0x0e, 0xd3, 0x38, 0x01, 0x0e, 0xd4, 0x39, 0x01, 0x0e, 0xd5, 0x3a, - 0x01, 0x0e, 0xd6, 0x3b, 0x01, 0x0e, 0xd7, 0x3c, 0x01, 0x0e, 0xd8, 0x3d, - 0x01, 0x0e, 0xd9, 0x3e, 0x01, 0x4e, 0xd0, 0x2b, 0x01, 0x0e, 0xd1, 0x2c, - 0x01, 0x0e, 0xd2, 0x2d, 0x01, 0x0e, 0xd3, 0x2e, 0x01, 0x0e, 0xd4, 0x2f, - 0x01, 0x0e, 0xd5, 0x30, 0x01, 0x0e, 0xd6, 0x31, 0x01, 0x0e, 0xd7, 0x32, - 0x01, 0x0e, 0xd8, 0x33, 0x01, 0x0e, 0xd9, 0x34, 0x01, 0x4e, 0xd0, 0x21, - 0x01, 0x0e, 0xd1, 0x22, 0x01, 0x0e, 0xd2, 0x23, 0x01, 0x0e, 0xd3, 0x24, - 0x01, 0x0e, 0xd4, 0x25, 0x01, 0x0e, 0xd5, 0x26, 0x01, 0x0e, 0xd6, 0x27, - 0x01, 0x0e, 0xd7, 0x28, 0x01, 0x0e, 0xd8, 0x29, 0x01, 0x0e, 0xd9, 0x2a, - 0x01, 0x4e, 0xd0, 0x17, 0x01, 0x0e, 0xd1, 0x18, 0x01, 0x0e, 0xd2, 0x19, - 0x01, 0x0e, 0xd3, 0x1a, 0x01, 0x0e, 0xd4, 0x1b, 0x01, 0x0e, 0xd5, 0x1c, - 0x01, 0x0e, 0xd6, 0x1d, 0x01, 0x0e, 0xd7, 0x1e, 0x01, 0x0e, 0xd8, 0x1f, - 0x01, 0x0e, 0xd9, 0x20, 0x01, 0x4e, 0xd0, 0x0d, 0x01, 0x0e, 0xd1, 0x0e, - 0x01, 0x0e, 0xd2, 0x0f, 0x01, 0x0e, 0xd3, 0x10, 0x01, 0x0e, 0xd4, 0x11, - 0x01, 0x0e, 0xd5, 0x12, 0x01, 0x0e, 0xd6, 0x13, 0x01, 0x0e, 0xd7, 0x14, - 0x01, 0x0e, 0xd8, 0x15, 0x01, 0x0e, 0xd9, 0x16, 0x01, 0x4e, 0xd0, 0x03, - 0x01, 0x8e, 0xe7, 0x01, 0xd1, 0x04, 0x01, 0x8e, 0xb9, 0x01, 0xd2, 0x05, - 0x01, 0x8e, 0x8b, 0x01, 0xd3, 0x06, 0x01, 0x8e, 0x5e, 0xd4, 0x07, 0x01, - 0x8e, 0x31, 0xd5, 0x08, 0x01, 0x8e, 0x10, 0xd6, 0x09, 0x01, 0x0e, 0xd7, - 0x0a, 0x01, 0x0e, 0xd8, 0x0b, 0x01, 0x0e, 0xd9, 0x0c, 0x01, 0x4e, 0xd0, - 0xe9, 0x01, 0x0e, 0xd1, 0xea, 0x01, 0x0e, 0xd2, 0xeb, 0x01, 0x0e, 0xd3, - 0xec, 0x01, 0x0e, 0xd4, 0xed, 0x01, 0x0e, 0xd5, 0xee, 0x01, 0x0e, 0xd6, - 0xef, 0x01, 0x4e, 0xd0, 0xdf, 0x01, 0x0e, 0xd1, 0xe0, 0x01, 0x0e, 0xd2, - 0xe1, 0x01, 0x0e, 0xd3, 0xe2, 0x01, 0x0e, 0xd4, 0xe3, 0x01, 0x0e, 0xd5, - 0xe4, 0x01, 0x0e, 0xd6, 0xe5, 0x01, 0x0e, 0xd7, 0xe6, 0x01, 0x0e, 0xd8, - 0xe7, 0x01, 0x0e, 0xd9, 0xe8, 0x01, 0x4e, 0xd0, 0xd5, 0x01, 0x0e, 0xd1, - 0xd6, 0x01, 0x0e, 0xd2, 0xd7, 0x01, 0x0e, 0xd3, 0xd8, 0x01, 0x0e, 0xd4, - 0xd9, 0x01, 0x0e, 0xd5, 0xda, 0x01, 0x0e, 0xd6, 0xdb, 0x01, 0x0e, 0xd7, - 0xdc, 0x01, 0x0e, 0xd8, 0xdd, 0x01, 0x0e, 0xd9, 0xde, 0x01, 0x4e, 0xd0, - 0xcb, 0x01, 0x0e, 0xd1, 0xcc, 0x01, 0x0e, 0xd2, 0xcd, 0x01, 0x0e, 0xd3, - 0xce, 0x01, 0x0e, 0xd4, 0xcf, 0x01, 0x0e, 0xd5, 0xd0, 0x01, 0x0e, 0xd6, - 0xd1, 0x01, 0x0e, 0xd7, 0xd2, 0x01, 0x0e, 0xd8, 0xd3, 0x01, 0x0e, 0xd9, - 0xd4, 0x01, 0x4e, 0xd0, 0xc1, 0x01, 0x0e, 0xd1, 0xc2, 0x01, 0x0e, 0xd2, - 0xc3, 0x01, 0x0e, 0xd3, 0xc4, 0x01, 0x0e, 0xd4, 0xc5, 0x01, 0x0e, 0xd5, - 0xc6, 0x01, 0x0e, 0xd6, 0xc7, 0x01, 0x0e, 0xd7, 0xc8, 0x01, 0x0e, 0xd8, - 0xc9, 0x01, 0x0e, 0xd9, 0xca, 0x01, 0x4e, 0xd0, 0xb7, 0x01, 0x0e, 0xd1, - 0xb8, 0x01, 0x0e, 0xd2, 0xb9, 0x01, 0x0e, 0xd3, 0xba, 0x01, 0x0e, 0xd4, - 0xbb, 0x01, 0x0e, 0xd5, 0xbc, 0x01, 0x0e, 0xd6, 0xbd, 0x01, 0x0e, 0xd7, - 0xbe, 0x01, 0x0e, 0xd8, 0xbf, 0x01, 0x0e, 0xd9, 0xc0, 0x01, 0x4e, 0xd0, - 0x09, 0xfe, 0x80, 0x9b, 0x03, 0xd1, 0x0a, 0xfe, 0x80, 0xed, 0x02, 0xd2, - 0x0b, 0xfe, 0x80, 0xbf, 0x02, 0xd3, 0x0c, 0xfe, 0x80, 0x91, 0x02, 0xd4, - 0x0d, 0xfe, 0x80, 0xe3, 0x01, 0xd5, 0x0e, 0xfe, 0x80, 0xb5, 0x01, 0xd6, - 0x0f, 0xfe, 0x80, 0x87, 0x01, 0xd7, 0x00, 0x01, 0x8e, 0x5a, 0xd8, 0x01, - 0x01, 0x8e, 0x2d, 0xd9, 0x02, 0x01, 0xce, 0x00, 0xd0, 0xad, 0x01, 0x0e, - 0xd1, 0xae, 0x01, 0x0e, 0xd2, 0xaf, 0x01, 0x0e, 0xd3, 0xb0, 0x01, 0x0e, - 0xd4, 0xb1, 0x01, 0x0e, 0xd5, 0xb2, 0x01, 0x0e, 0xd6, 0xb3, 0x01, 0x0e, - 0xd7, 0xb4, 0x01, 0x0e, 0xd8, 0xb5, 0x01, 0x0e, 0xd9, 0xb6, 0x01, 0x4e, - 0xd0, 0xa3, 0x01, 0x0e, 0xd1, 0xa4, 0x01, 0x0e, 0xd2, 0xa5, 0x01, 0x0e, - 0xd3, 0xa6, 0x01, 0x0e, 0xd4, 0xa7, 0x01, 0x0e, 0xd5, 0xa8, 0x01, 0x0e, - 0xd6, 0xa9, 0x01, 0x0e, 0xd7, 0xaa, 0x01, 0x0e, 0xd8, 0xab, 0x01, 0x0e, - 0xd9, 0xac, 0x01, 0x4e, 0xd0, 0x99, 0x01, 0x0e, 0xd1, 0x9a, 0x01, 0x0e, - 0xd2, 0x9b, 0x01, 0x0e, 0xd3, 0x9c, 0x01, 0x0e, 0xd4, 0x9d, 0x01, 0x0e, - 0xd5, 0x9e, 0x01, 0x0e, 0xd6, 0x9f, 0x01, 0x0e, 0xd7, 0xa0, 0x01, 0x0e, - 0xd8, 0xa1, 0x01, 0x0e, 0xd9, 0xa2, 0x01, 0x4e, 0xd0, 0x8f, 0x01, 0x0e, - 0xd1, 0x90, 0x01, 0x0e, 0xd2, 0x91, 0x01, 0x0e, 0xd3, 0x92, 0x01, 0x0e, - 0xd4, 0x93, 0x01, 0x0e, 0xd5, 0x94, 0x01, 0x0e, 0xd6, 0x95, 0x01, 0x0e, - 0xd7, 0x96, 0x01, 0x0e, 0xd8, 0x97, 0x01, 0x0e, 0xd9, 0x98, 0x01, 0x4e, - 0xd0, 0x85, 0x01, 0x0e, 0xd1, 0x86, 0x01, 0x0e, 0xd2, 0x87, 0x01, 0x0e, - 0xd3, 0x88, 0x01, 0x0e, 0xd4, 0x89, 0x01, 0x0e, 0xd5, 0x8a, 0x01, 0x0e, - 0xd6, 0x8b, 0x01, 0x0e, 0xd7, 0x8c, 0x01, 0x0e, 0xd8, 0x8d, 0x01, 0x0e, - 0xd9, 0x8e, 0x01, 0x4e, 0xd0, 0x7b, 0x01, 0x0e, 0xd1, 0x7c, 0x01, 0x0e, - 0xd2, 0x7d, 0x01, 0x0e, 0xd3, 0x7e, 0x01, 0x0e, 0xd4, 0x7f, 0x01, 0x0e, - 0xd5, 0x80, 0x01, 0x0e, 0xd6, 0x81, 0x01, 0x0e, 0xd7, 0x82, 0x01, 0x0e, - 0xd8, 0x83, 0x01, 0x0e, 0xd9, 0x84, 0x01, 0x4e, 0xd0, 0x71, 0x01, 0x0e, - 0xd1, 0x72, 0x01, 0x0e, 0xd2, 0x73, 0x01, 0x0e, 0xd3, 0x74, 0x01, 0x0e, - 0xd4, 0x75, 0x01, 0x0e, 0xd5, 0x76, 0x01, 0x0e, 0xd6, 0x77, 0x01, 0x0e, - 0xd7, 0x78, 0x01, 0x0e, 0xd8, 0x79, 0x01, 0x0e, 0xd9, 0x7a, 0x01, 0x4e, - 0xd0, 0x67, 0x01, 0x0e, 0xd1, 0x68, 0x01, 0x0e, 0xd2, 0x69, 0x01, 0x0e, - 0xd3, 0x6a, 0x01, 0x0e, 0xd4, 0x6b, 0x01, 0x0e, 0xd5, 0x6c, 0x01, 0x0e, - 0xd6, 0x6d, 0x01, 0x0e, 0xd7, 0x6e, 0x01, 0x0e, 0xd8, 0x6f, 0x01, 0x0e, - 0xd9, 0x70, 0x01, 0x4e, 0xd0, 0x5d, 0x01, 0x0e, 0xd1, 0x5e, 0x01, 0x0e, - 0xd2, 0x5f, 0x01, 0x0e, 0xd3, 0x60, 0x01, 0x0e, 0xd4, 0x61, 0x01, 0x0e, - 0xd5, 0x62, 0x01, 0x0e, 0xd6, 0x63, 0x01, 0x0e, 0xd7, 0x64, 0x01, 0x0e, - 0xd8, 0x65, 0x01, 0x0e, 0xd9, 0x66, 0x01, 0x4e, 0xd0, 0x53, 0x01, 0x0e, - 0xd1, 0x54, 0x01, 0x0e, 0xd2, 0x55, 0x01, 0x0e, 0xd3, 0x56, 0x01, 0x0e, - 0xd4, 0x57, 0x01, 0x0e, 0xd5, 0x58, 0x01, 0x0e, 0xd6, 0x59, 0x01, 0x0e, - 0xd7, 0x5a, 0x01, 0x0e, 0xd8, 0x5b, 0x01, 0x0e, 0xd9, 0x5c, 0x01, 0x4e, - 0x50, 0xad, 0x63, 0xbb, 0xfb, 0x01, 0xac, 0x01, 0xff, 0x44, 0x75, 0xef, - 0x0b, 0xf3, 0x01, 0x47, 0xfd, 0xd2, 0xd0, 0xf3, 0x01, 0x4c, 0x84, 0x96, - 0x30, 0x22, 0x40, 0x4c, 0xf4, 0x8c, 0xf3, 0xf4, 0x01, 0x04, 0xdd, 0x0f, - 0xe1, 0x03, 0x03, 0x4f, 0x20, 0xc8, 0x03, 0xa5, 0xaf, 0x03, 0x44, 0xd2, - 0xae, 0xbb, 0xf3, 0x01, 0x43, 0x66, 0x17, 0x4d, 0x26, 0x00, 0x07, 0x7d, - 0xd6, 0x01, 0xff, 0x0f, 0xe4, 0x05, 0xcf, 0x01, 0x0d, 0x76, 0x08, 0x01, - 0xff, 0xe1, 0x97, 0x05, 0x01, 0xa2, 0xb9, 0x01, 0xa3, 0xac, 0x01, 0xa4, - 0x9f, 0x01, 0xe5, 0x9f, 0x05, 0x81, 0x95, 0x01, 0x42, 0x28, 0x1a, 0xa0, - 0x05, 0x01, 0x42, 0x24, 0x02, 0xa1, 0x05, 0x01, 0xa8, 0x7d, 0xe9, 0xa5, - 0x05, 0x81, 0x72, 0x42, 0x82, 0x20, 0xa7, 0x05, 0x01, 0x42, 0x1b, 0x02, - 0xa8, 0x05, 0x01, 0xac, 0x5a, 0x42, 0x2a, 0x02, 0xab, 0x05, 0x01, 0xae, - 0x48, 0xef, 0xae, 0x05, 0x01, 0x42, 0x6f, 0x02, 0xaf, 0x05, 0x01, 0x42, - 0x43, 0x14, 0xb0, 0x05, 0x01, 0x42, 0x88, 0x00, 0xb1, 0x05, 0x01, 0xb3, - 0x26, 0xb4, 0x1a, 0xf5, 0xb7, 0x05, 0x01, 0x42, 0x32, 0x00, 0xb8, 0x05, - 0x01, 0x42, 0x74, 0x43, 0xb9, 0x05, 0x01, 0xf9, 0xbb, 0x05, 0x01, 0x42, - 0x4b, 0x0a, 0xbc, 0x05, 0x41, 0xe5, 0xb5, 0x05, 0x01, 0x42, 0xb0, 0x01, - 0xb6, 0x05, 0x41, 0xe5, 0xb3, 0x05, 0x01, 0x42, 0xb0, 0x01, 0xb4, 0x05, - 0x41, 0xe5, 0xac, 0x05, 0x01, 0x42, 0x82, 0x20, 0xad, 0x05, 0x41, 0xe1, - 0xa9, 0x05, 0x01, 0x42, 0x74, 0x00, 0xaa, 0x05, 0x41, 0x42, 0x82, 0x20, - 0xa6, 0x05, 0x41, 0xe1, 0xa3, 0x05, 0x01, 0x42, 0x22, 0x00, 0xa4, 0x05, - 0x41, 0xe9, 0x9e, 0x05, 0x41, 0xe5, 0x9c, 0x05, 0x01, 0x42, 0xb0, 0x01, - 0x9d, 0x05, 0x41, 0xe5, 0x9a, 0x05, 0x01, 0x42, 0xb0, 0x01, 0x9b, 0x05, - 0x41, 0x42, 0xb7, 0x05, 0x98, 0x05, 0x01, 0xe5, 0x99, 0x05, 0x41, 0xe1, - 0x70, 0x05, 0x01, 0xa2, 0xb9, 0x01, 0xa3, 0xac, 0x01, 0xa4, 0x9f, 0x01, - 0xe5, 0x78, 0x05, 0x81, 0x95, 0x01, 0x42, 0x28, 0x1a, 0x79, 0x05, 0x01, - 0x42, 0x24, 0x02, 0x7a, 0x05, 0x01, 0xa8, 0x7d, 0xe9, 0x7e, 0x05, 0x81, - 0x72, 0x42, 0x82, 0x20, 0x80, 0x05, 0x01, 0x42, 0x1b, 0x02, 0x81, 0x05, - 0x01, 0xac, 0x5a, 0x42, 0x2a, 0x02, 0x84, 0x05, 0x01, 0xae, 0x48, 0xef, - 0x87, 0x05, 0x01, 0x42, 0x6f, 0x02, 0x88, 0x05, 0x01, 0x42, 0x43, 0x14, - 0x89, 0x05, 0x01, 0x42, 0x88, 0x00, 0x8a, 0x05, 0x01, 0xb3, 0x26, 0xb4, - 0x1a, 0xf5, 0x90, 0x05, 0x01, 0x42, 0x32, 0x00, 0x91, 0x05, 0x01, 0x42, - 0x74, 0x43, 0x92, 0x05, 0x01, 0xf9, 0x94, 0x05, 0x01, 0x42, 0x4b, 0x0a, - 0x95, 0x05, 0x41, 0xe5, 0x8e, 0x05, 0x01, 0x42, 0xb0, 0x01, 0x8f, 0x05, - 0x41, 0xe5, 0x8c, 0x05, 0x01, 0x42, 0xb0, 0x01, 0x8d, 0x05, 0x41, 0xe5, - 0x85, 0x05, 0x01, 0x42, 0x82, 0x20, 0x86, 0x05, 0x41, 0xe1, 0x82, 0x05, - 0x01, 0x42, 0x74, 0x00, 0x83, 0x05, 0x41, 0x42, 0x82, 0x20, 0x7f, 0x05, - 0x41, 0xe1, 0x7c, 0x05, 0x01, 0x42, 0x22, 0x00, 0x7d, 0x05, 0x41, 0xe9, - 0x77, 0x05, 0x41, 0xe5, 0x75, 0x05, 0x01, 0x42, 0xb0, 0x01, 0x76, 0x05, - 0x41, 0xe5, 0x73, 0x05, 0x01, 0x42, 0xb0, 0x01, 0x74, 0x05, 0x41, 0x42, - 0xb7, 0x05, 0x71, 0x05, 0x01, 0xe5, 0x72, 0x05, 0x41, 0x1f, 0xe9, 0x11, - 0x06, 0x4c, 0x08, 0x97, 0x17, 0x23, 0x40, 0x42, 0x37, 0x00, 0xf0, 0x6f, - 0x01, 0x44, 0xa1, 0xf1, 0xf1, 0x6f, 0x41, 0x80, 0x06, 0x48, 0xa9, 0xc4, - 0xfc, 0xf4, 0x41, 0x46, 0x72, 0xb3, 0xf9, 0xf4, 0x01, 0x44, 0x01, 0xf0, - 0xae, 0xf3, 0x41, 0x42, 0x1b, 0x01, 0xc5, 0xce, 0x01, 0x46, 0xf6, 0x96, - 0x0c, 0x27, 0x40, 0x55, 0x25, 0x3a, 0x2f, 0x2a, 0x00, 0x04, 0xeb, 0x06, - 0x83, 0x03, 0xb2, 0x0d, 0x43, 0x31, 0x13, 0xb6, 0x26, 0xc0, 0x00, 0x49, - 0x3c, 0x2e, 0x77, 0xf7, 0x41, 0x45, 0x16, 0xeb, 0x23, 0x21, 0x00, 0x06, - 0x35, 0x00, 0x67, 0x02, 0x09, 0x00, 0x01, 0xff, 0x50, 0x1d, 0x61, 0xa5, - 0xf7, 0x01, 0x06, 0x6d, 0x15, 0x11, 0x05, 0xf5, 0xe8, 0x01, 0xff, 0x4c, - 0x87, 0x00, 0xd9, 0x22, 0x00, 0x49, 0xec, 0x00, 0xd8, 0x22, 0x40, 0x06, - 0x31, 0x14, 0x37, 0x54, 0x5f, 0x42, 0xb3, 0xf7, 0x01, 0x4b, 0x22, 0x61, - 0xa6, 0xf7, 0x01, 0x4f, 0x6d, 0x72, 0x7d, 0xf6, 0x01, 0xb3, 0x11, 0x06, - 0xad, 0x02, 0x01, 0xff, 0x46, 0x12, 0x03, 0x88, 0xf7, 0x01, 0x46, 0xd6, - 0x05, 0x92, 0xf7, 0x41, 0x46, 0x2f, 0x19, 0xad, 0xf7, 0x01, 0x52, 0x06, - 0x53, 0xb9, 0xf7, 0x01, 0x46, 0x6b, 0x31, 0x7c, 0xf6, 0x41, 0x52, 0x07, - 0x2c, 0xd0, 0xf7, 0x01, 0x4f, 0xf1, 0x1c, 0xbf, 0xf7, 0x41, 0x04, 0x16, - 0x00, 0xe6, 0x01, 0x49, 0x1a, 0xb7, 0x14, 0xcc, 0x01, 0x48, 0xe9, 0x29, - 0xee, 0x22, 0x00, 0x49, 0xd8, 0x46, 0x5e, 0x20, 0x00, 0x47, 0x6e, 0xd1, - 0x9d, 0xcc, 0x01, 0x5a, 0x4e, 0x20, 0x3b, 0x30, 0x00, 0x0c, 0x9c, 0x90, - 0xa0, 0x01, 0xac, 0x61, 0x55, 0xef, 0x3c, 0xa8, 0x26, 0x00, 0x11, 0xde, - 0x5c, 0x3f, 0xb2, 0x31, 0x48, 0x21, 0xcb, 0x3d, 0x2e, 0x00, 0xb4, 0x06, - 0x4b, 0xa2, 0xa5, 0x9a, 0x29, 0x40, 0x02, 0x5c, 0x00, 0x0c, 0x44, 0x38, - 0x23, 0x2f, 0x2e, 0x00, 0x4c, 0x2c, 0x94, 0xa6, 0xf6, 0x41, 0x44, 0xd8, - 0x45, 0x7f, 0x2b, 0x00, 0x47, 0x01, 0x3c, 0x0b, 0x00, 0xc0, 0x00, 0x44, - 0x87, 0xb8, 0x8a, 0x00, 0x40, 0x49, 0xbb, 0xb5, 0x9c, 0xcc, 0x01, 0x4f, - 0xdc, 0x6c, 0x0a, 0xcc, 0x41, 0xd2, 0x70, 0xfb, 0x01, 0xd3, 0x71, 0xfb, - 0x01, 0xd4, 0x72, 0xfb, 0x01, 0xd5, 0x73, 0xfb, 0x01, 0xd6, 0x74, 0xfb, - 0x01, 0xd7, 0x75, 0xfb, 0x41, 0x45, 0x27, 0xe4, 0x84, 0xcc, 0x01, 0x43, - 0xee, 0x07, 0x7c, 0x00, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x49, 0xc8, 0x58, - 0xd0, 0x23, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x07, 0xfb, 0x04, 0x12, - 0x4f, 0x63, 0x6d, 0x90, 0xcc, 0x01, 0x4a, 0xed, 0x45, 0x7f, 0x23, 0x00, - 0x50, 0xf7, 0x07, 0x15, 0xce, 0x41, 0x45, 0x5c, 0x00, 0xef, 0x2a, 0x00, - 0x45, 0x20, 0x07, 0xf0, 0x2a, 0x40, 0x44, 0xb9, 0x00, 0x31, 0x30, 0x80, - 0x0d, 0x56, 0x6a, 0x38, 0x32, 0x30, 0xc0, 0x00, 0x4b, 0x45, 0x1a, 0x34, - 0x30, 0x40, 0x80, 0x01, 0xff, 0x4a, 0xa0, 0x08, 0x35, 0x30, 0x00, 0x4a, - 0x46, 0x1a, 0x33, 0x30, 0x40, 0x55, 0xa7, 0x39, 0xd0, 0x29, 0x00, 0x55, - 0x64, 0x3a, 0xe4, 0x2a, 0x00, 0x56, 0xa4, 0x37, 0xe2, 0x2a, 0x00, 0x56, - 0x3e, 0x38, 0xca, 0x27, 0x40, 0x05, 0x5a, 0x03, 0x94, 0x01, 0x05, 0x56, - 0x2d, 0x01, 0xff, 0x60, 0x74, 0x0f, 0xe1, 0x1c, 0x00, 0x07, 0x3d, 0x61, - 0x79, 0x02, 0x3b, 0x01, 0x5e, 0x02, 0x1b, 0x02, 0x4e, 0x47, 0xfc, 0xd4, - 0xd2, 0x1c, 0x00, 0x02, 0x0d, 0x00, 0x38, 0x45, 0xfd, 0xea, 0xd1, 0x1c, - 0x00, 0xb4, 0x1e, 0x0b, 0xbe, 0x22, 0x01, 0xff, 0x5e, 0x63, 0x12, 0xd5, - 0x1c, 0x00, 0x53, 0xe8, 0x0a, 0xd6, 0x1c, 0x00, 0x5b, 0x28, 0x1c, 0xd7, - 0x1c, 0xc0, 0x00, 0x4a, 0x44, 0xa6, 0xd9, 0x1c, 0x40, 0x4f, 0x44, 0x6e, - 0xdf, 0x1c, 0x00, 0x4d, 0xfb, 0x87, 0xdb, 0x1c, 0x00, 0x4d, 0x06, 0x0f, - 0xde, 0x1c, 0x40, 0x63, 0xd8, 0x0a, 0xe0, 0x1c, 0x00, 0x48, 0x82, 0xb0, - 0xf8, 0x1c, 0x40, 0x46, 0xd0, 0xdf, 0xd0, 0x1c, 0x00, 0x4e, 0xd8, 0x7c, - 0xdc, 0x1c, 0x40, 0x47, 0xa1, 0x12, 0xdd, 0x1c, 0x00, 0x05, 0x3d, 0x01, - 0x01, 0xff, 0x4a, 0x80, 0xb0, 0xf9, 0x1c, 0x00, 0x47, 0xf4, 0x0a, 0xda, - 0x1c, 0x40, 0x45, 0x5c, 0x00, 0xf4, 0x1c, 0x00, 0x45, 0x20, 0x07, 0xd8, - 0x1c, 0x40, 0xa1, 0x72, 0x5c, 0x52, 0x17, 0xfa, 0x1c, 0x00, 0x56, 0x4a, - 0x34, 0xee, 0x1c, 0x00, 0x4b, 0x07, 0x9e, 0xf5, 0x1c, 0x00, 0x4d, 0x53, - 0x34, 0xef, 0x1c, 0x00, 0x49, 0x9f, 0xbc, 0xd3, 0x1c, 0x00, 0xb2, 0x36, - 0x46, 0xc0, 0xe0, 0xed, 0x1c, 0x00, 0x4b, 0x8f, 0xa4, 0xf6, 0x1c, 0x00, - 0x08, 0x15, 0x63, 0x06, 0x5a, 0xbe, 0x22, 0xd4, 0x1c, 0x40, 0x48, 0xde, - 0x7c, 0xe5, 0x1c, 0x80, 0x13, 0x47, 0xf4, 0x0a, 0xe2, 0x1c, 0x00, 0x46, - 0xe0, 0x7c, 0xe3, 0x1c, 0xc0, 0x00, 0x4a, 0xbc, 0xa6, 0xe7, 0x1c, 0x40, - 0x4a, 0xbc, 0xa6, 0xe8, 0x1c, 0x40, 0x10, 0x0d, 0x63, 0x0c, 0x53, 0xe5, - 0x4b, 0xf3, 0x1c, 0x00, 0x53, 0x87, 0x4d, 0xf0, 0x1c, 0x40, 0x48, 0xde, - 0x7c, 0xe6, 0x1c, 0x00, 0x46, 0xe0, 0x7c, 0xe4, 0x1c, 0x40, 0x08, 0x3d, - 0x16, 0x0c, 0x4b, 0xed, 0x4b, 0xf2, 0x1c, 0x00, 0x47, 0x84, 0xd6, 0xf7, - 0x1c, 0x40, 0x4c, 0x62, 0x17, 0xe9, 0x1c, 0x00, 0x4c, 0xac, 0x8c, 0xea, - 0x1c, 0x00, 0x4e, 0xe2, 0x7d, 0xf1, 0x1c, 0x00, 0x4b, 0xd1, 0xa4, 0xeb, - 0x1c, 0xc0, 0x00, 0x4a, 0xbc, 0xa6, 0xec, 0x1c, 0x40, 0x02, 0xf1, 0x03, - 0xb4, 0x08, 0x45, 0xe6, 0xe8, 0xdb, 0xf9, 0x01, 0x11, 0x99, 0x5d, 0x01, - 0xff, 0xd1, 0x00, 0xfe, 0x80, 0xda, 0x04, 0xd2, 0x01, 0xfe, 0x80, 0xbf, + 0x29, 0x02, 0x86, 0x0e, 0x41, 0x43, 0x3f, 0x3b, 0x88, 0x0e, 0x01, 0x42, + 0x29, 0x02, 0x87, 0x0e, 0x41, 0x4a, 0x8c, 0xb0, 0xab, 0x0e, 0x01, 0x4a, + 0x2a, 0xb3, 0xac, 0x0e, 0x41, 0x10, 0x3a, 0x68, 0x06, 0x4a, 0x26, 0x87, + 0x71, 0xf9, 0x41, 0x48, 0xf7, 0xce, 0xf4, 0x6f, 0x01, 0xb4, 0x01, 0xff, + 0x4f, 0x70, 0x71, 0xf5, 0x6f, 0x01, 0x48, 0x47, 0xd2, 0xf6, 0x6f, 0x41, + 0x53, 0xb4, 0x49, 0x27, 0x23, 0x00, 0x44, 0xb0, 0xf2, 0x7b, 0xfa, 0x01, + 0x07, 0x92, 0xd7, 0x06, 0x42, 0x0c, 0x00, 0xbb, 0x22, 0x40, 0x06, 0x0c, + 0x03, 0x31, 0x04, 0x01, 0x06, 0x01, 0xff, 0xa3, 0x1e, 0x48, 0x3f, 0xcb, + 0x62, 0xfa, 0x01, 0x47, 0x0d, 0xd7, 0x60, 0xfa, 0x01, 0x45, 0xbb, 0xb8, + 0x63, 0xfa, 0x01, 0x48, 0xc7, 0xcd, 0x61, 0xfa, 0x01, 0x47, 0xd6, 0xdb, + 0x66, 0xfa, 0x41, 0x45, 0x53, 0xea, 0x65, 0xfa, 0x01, 0x46, 0x46, 0x5a, + 0x64, 0xfa, 0x41, 0xa3, 0x1e, 0x48, 0x3f, 0xcb, 0x69, 0xfa, 0x01, 0x47, + 0x0d, 0xd7, 0x67, 0xfa, 0x01, 0x45, 0xbb, 0xb8, 0x6a, 0xfa, 0x01, 0x48, + 0xc7, 0xcd, 0x68, 0xfa, 0x01, 0x47, 0xd6, 0xdb, 0x6d, 0xfa, 0x41, 0x45, + 0x53, 0xea, 0x6c, 0xfa, 0x01, 0x46, 0x46, 0x5a, 0x6b, 0xfa, 0x41, 0xa1, + 0xc6, 0x0e, 0xa5, 0x91, 0x0e, 0xa8, 0x84, 0x04, 0xa9, 0x90, 0x01, 0xea, + 0x60, 0x20, 0x00, 0xaf, 0x23, 0xb2, 0x01, 0xff, 0x4d, 0x99, 0x84, 0x81, + 0xf3, 0x01, 0xa5, 0x06, 0x4a, 0x68, 0xa7, 0x0d, 0x27, 0x40, 0x4b, 0x61, + 0x9e, 0x40, 0x22, 0x00, 0x43, 0x1b, 0x27, 0x27, 0xf5, 0x01, 0x46, 0x1e, + 0xe6, 0x3c, 0xf9, 0x41, 0x47, 0xbf, 0xd8, 0x3a, 0xf4, 0x01, 0xad, 0x2f, + 0x46, 0xc3, 0x04, 0xa9, 0x20, 0x00, 0x42, 0xe5, 0x0c, 0xb5, 0xfa, 0x01, + 0xb2, 0x01, 0xff, 0x02, 0x06, 0x00, 0x10, 0x46, 0x9c, 0xe3, 0xfa, 0xf5, + 0x01, 0xed, 0xb1, 0xfa, 0x01, 0x49, 0x8e, 0xc4, 0x1f, 0xf6, 0x41, 0x46, + 0x74, 0x64, 0x60, 0x20, 0x00, 0x54, 0x13, 0x48, 0x31, 0x2e, 0x40, 0x42, + 0x1a, 0x00, 0x69, 0xf4, 0x81, 0x06, 0x4a, 0x4c, 0xaf, 0xba, 0xf6, 0x41, + 0x50, 0x4a, 0x63, 0x6f, 0xf4, 0x01, 0x02, 0x31, 0x01, 0x01, 0xff, 0x45, + 0xcb, 0xea, 0x62, 0xf4, 0x01, 0x47, 0xc4, 0xd5, 0x5a, 0xf4, 0x01, 0x43, + 0xb7, 0x22, 0x52, 0xf4, 0x01, 0x46, 0x09, 0xc2, 0x61, 0xf4, 0x41, 0x0a, + 0xf9, 0x1c, 0x4f, 0x05, 0xbe, 0x33, 0x3f, 0x4b, 0x2e, 0xa4, 0x40, 0xf9, + 0x01, 0xae, 0x11, 0x02, 0x88, 0x00, 0x01, 0xff, 0x4a, 0x70, 0xae, 0xae, + 0xf5, 0x01, 0x44, 0xec, 0x00, 0xdc, 0xf6, 0x41, 0xa4, 0x10, 0x47, 0x50, + 0xd6, 0x77, 0xf3, 0x01, 0xe7, 0xbd, 0xfa, 0x01, 0x49, 0x17, 0xae, 0x09, + 0xf6, 0x41, 0x80, 0x06, 0x42, 0xd1, 0x00, 0x9f, 0xfa, 0x41, 0x4c, 0x70, + 0x91, 0x2c, 0xf3, 0x01, 0x45, 0x20, 0xeb, 0x90, 0xf3, 0x41, 0x50, 0xad, + 0x00, 0x60, 0x2e, 0x00, 0x4d, 0x39, 0x0c, 0x3e, 0x2e, 0x40, 0x0a, 0xa5, + 0x01, 0xfb, 0x01, 0x0a, 0xea, 0x01, 0xd8, 0x01, 0x06, 0xb4, 0x01, 0x8e, + 0x01, 0x0b, 0xb3, 0x02, 0x6c, 0x06, 0xc4, 0x21, 0x23, 0x08, 0x50, 0x02, + 0x01, 0xff, 0x4a, 0x0f, 0x41, 0x69, 0xf8, 0x01, 0x50, 0x09, 0x41, 0x79, + 0xf8, 0x01, 0x50, 0x9a, 0x67, 0x61, 0xf8, 0x01, 0x51, 0xae, 0x5e, 0x71, + 0xf8, 0x01, 0x55, 0x04, 0x41, 0x81, 0xf8, 0x41, 0x05, 0xe4, 0x19, 0x23, + 0x05, 0x00, 0x0f, 0x01, 0xff, 0x4a, 0x0f, 0x41, 0x6f, 0xf8, 0x01, 0x50, + 0x09, 0x41, 0x7f, 0xf8, 0x01, 0x50, 0x9a, 0x67, 0x67, 0xf8, 0x01, 0x51, + 0xae, 0x5e, 0x77, 0xf8, 0x01, 0x55, 0x04, 0x41, 0x87, 0xf8, 0x41, 0x4a, + 0x0f, 0x41, 0x6e, 0xf8, 0x01, 0x50, 0x09, 0x41, 0x7e, 0xf8, 0x01, 0x50, + 0x9a, 0x67, 0x66, 0xf8, 0x01, 0x51, 0xae, 0x5e, 0x76, 0xf8, 0x01, 0x55, + 0x04, 0x41, 0x86, 0xf8, 0x41, 0x4a, 0x0f, 0x41, 0x6a, 0xf8, 0x01, 0x50, + 0x09, 0x41, 0x7a, 0xf8, 0x01, 0x50, 0x9a, 0x67, 0x62, 0xf8, 0x01, 0x51, + 0xae, 0x5e, 0x72, 0xf8, 0x01, 0x55, 0x04, 0x41, 0x82, 0xf8, 0x41, 0x05, + 0xe4, 0x19, 0x23, 0x05, 0x00, 0x0f, 0x01, 0xff, 0x4a, 0x0f, 0x41, 0x6c, + 0xf8, 0x01, 0x50, 0x09, 0x41, 0x7c, 0xf8, 0x01, 0x50, 0x9a, 0x67, 0x64, + 0xf8, 0x01, 0x51, 0xae, 0x5e, 0x74, 0xf8, 0x01, 0x55, 0x04, 0x41, 0x84, + 0xf8, 0x41, 0x4a, 0x0f, 0x41, 0x6d, 0xf8, 0x01, 0x50, 0x09, 0x41, 0x7d, + 0xf8, 0x01, 0x50, 0x9a, 0x67, 0x65, 0xf8, 0x01, 0x51, 0xae, 0x5e, 0x75, + 0xf8, 0x01, 0x55, 0x04, 0x41, 0x85, 0xf8, 0x41, 0x4a, 0x0f, 0x41, 0x68, + 0xf8, 0x01, 0x50, 0x09, 0x41, 0x78, 0xf8, 0x01, 0x50, 0x9a, 0x67, 0x60, + 0xf8, 0x01, 0x51, 0xae, 0x5e, 0x70, 0xf8, 0x01, 0x55, 0x04, 0x41, 0x80, + 0xf8, 0x41, 0x4a, 0x0f, 0x41, 0x6b, 0xf8, 0x01, 0x50, 0x09, 0x41, 0x7b, + 0xf8, 0x01, 0x50, 0x9a, 0x67, 0x63, 0xf8, 0x01, 0x51, 0xae, 0x5e, 0x73, + 0xf8, 0x01, 0x55, 0x04, 0x41, 0x83, 0xf8, 0x41, 0x43, 0x67, 0x00, 0x0b, + 0xf4, 0x01, 0x43, 0xfb, 0x13, 0xde, 0xf6, 0x81, 0xf0, 0x09, 0x03, 0xaf, + 0x02, 0x01, 0xff, 0x80, 0x06, 0x5b, 0x2d, 0x1b, 0xb3, 0x27, 0x40, 0x12, + 0x8b, 0x52, 0xd2, 0x09, 0x46, 0xd5, 0x22, 0xe6, 0x25, 0x00, 0xa3, 0xc3, + 0x06, 0xa4, 0xd2, 0x05, 0x59, 0xae, 0x13, 0x55, 0x27, 0x00, 0xa6, 0x95, + 0x05, 0xa8, 0xd5, 0x04, 0xac, 0xf7, 0x03, 0xad, 0xc9, 0x03, 0x43, 0x75, + 0xa2, 0x11, 0x27, 0x00, 0xb0, 0xa9, 0x03, 0x56, 0x8f, 0x38, 0x54, 0x27, + 0x00, 0xb2, 0xe6, 0x02, 0xb3, 0x7c, 0xb4, 0x5a, 0x02, 0x50, 0x02, 0x28, + 0x03, 0x32, 0x00, 0x01, 0xff, 0x06, 0x35, 0x00, 0x06, 0x4e, 0xcd, 0x0a, + 0x1e, 0x2b, 0x40, 0x43, 0x16, 0x00, 0xfe, 0x2a, 0x00, 0x47, 0xf3, 0x69, + 0x2f, 0x2b, 0x00, 0x49, 0xba, 0x49, 0xaf, 0x25, 0xc0, 0x00, 0x54, 0x0f, + 0x42, 0x06, 0xce, 0x41, 0x0a, 0x9b, 0x01, 0x1e, 0x0a, 0xf8, 0x0b, 0x01, + 0xff, 0x47, 0xa7, 0x50, 0xca, 0xfb, 0x01, 0x4e, 0x92, 0x0c, 0xb5, 0x25, + 0x00, 0x48, 0x01, 0x02, 0xb3, 0x25, 0xc0, 0x00, 0x49, 0x98, 0x3d, 0xec, + 0x25, 0x40, 0x4e, 0x4e, 0x28, 0x46, 0xf4, 0x01, 0x45, 0x5d, 0x14, 0x1d, + 0x26, 0x40, 0x48, 0x3a, 0x3f, 0x0f, 0x26, 0x00, 0x52, 0xb1, 0x56, 0x7e, + 0xf5, 0x01, 0xb2, 0x06, 0x57, 0xd3, 0x33, 0xd7, 0x26, 0x40, 0x47, 0xb3, + 0xd4, 0xe2, 0x23, 0x00, 0x66, 0x4b, 0x07, 0xc1, 0x27, 0x40, 0x47, 0x6a, + 0x40, 0x04, 0x27, 0x00, 0x49, 0x3a, 0xbe, 0x46, 0xfe, 0x00, 0x4a, 0x3a, + 0x62, 0x16, 0x26, 0x00, 0xad, 0xb4, 0x01, 0x49, 0xad, 0xc3, 0x64, 0x26, + 0x00, 0x45, 0xfe, 0x05, 0xa1, 0x25, 0x80, 0x2e, 0x43, 0x00, 0x14, 0x06, + 0x26, 0x00, 0x42, 0x79, 0x08, 0x23, 0xf3, 0xc1, 0x00, 0x80, 0x01, 0xff, + 0x4c, 0x4c, 0x91, 0x25, 0xf3, 0x81, 0x11, 0x05, 0x51, 0x00, 0x01, 0xff, + 0x44, 0x5a, 0x69, 0x3c, 0x26, 0x00, 0x4b, 0xeb, 0xa7, 0x24, 0xf3, 0x41, + 0x4a, 0xd2, 0xab, 0x26, 0xf3, 0x41, 0x80, 0x01, 0xff, 0x46, 0xac, 0x91, + 0x33, 0xf5, 0x01, 0x11, 0x9a, 0x0a, 0x5a, 0x05, 0x51, 0x00, 0x01, 0xff, + 0x54, 0xff, 0x42, 0xfa, 0xf7, 0x01, 0x54, 0x27, 0x43, 0x85, 0x23, 0x00, + 0x67, 0xcd, 0x05, 0xfc, 0xf7, 0x01, 0xac, 0x2a, 0xb2, 0x1c, 0x51, 0x34, + 0x61, 0xfb, 0xf7, 0x01, 0x06, 0x6d, 0x02, 0x06, 0x57, 0xdc, 0x05, 0xeb, + 0x25, 0x40, 0x4d, 0x02, 0x0e, 0xf0, 0x25, 0x00, 0x4e, 0x9b, 0x47, 0xf3, + 0x25, 0x40, 0x4e, 0xf4, 0x75, 0xe5, 0x27, 0x00, 0x4e, 0x42, 0x1a, 0xa2, + 0x25, 0x40, 0x4d, 0xf5, 0x7c, 0xe4, 0x27, 0x00, 0x05, 0x14, 0x01, 0x01, + 0xff, 0x4d, 0x02, 0x0e, 0xf1, 0x25, 0x00, 0x4e, 0x9b, 0x47, 0xf2, 0x25, + 0x40, 0x4d, 0xfb, 0x89, 0x95, 0xf7, 0x01, 0x4c, 0xcf, 0x0a, 0xa3, 0x25, + 0x00, 0x51, 0xca, 0x0a, 0x94, 0xf7, 0x41, 0x04, 0x5f, 0x07, 0x06, 0x4a, + 0x5a, 0x9a, 0x3a, 0x26, 0x40, 0x47, 0xb1, 0x0a, 0x2b, 0x2b, 0x00, 0xb3, + 0x01, 0xff, 0x45, 0xfe, 0x05, 0xab, 0x25, 0x00, 0x43, 0x00, 0x14, 0x52, + 0x2b, 0x40, 0x48, 0xbb, 0x49, 0xad, 0x25, 0x00, 0x04, 0xc9, 0x00, 0x01, + 0xff, 0x0a, 0x9b, 0x01, 0x1f, 0x0a, 0xf8, 0x0b, 0x01, 0xff, 0xb0, 0x0c, + 0x4e, 0x92, 0x0c, 0xb9, 0x25, 0x00, 0x48, 0x01, 0x02, 0xb7, 0x25, 0x40, + 0x47, 0x98, 0xcf, 0x54, 0x2b, 0x00, 0x46, 0x34, 0x4c, 0xbb, 0x25, 0x40, + 0x4e, 0x4e, 0x28, 0x49, 0xf4, 0x01, 0x45, 0x5d, 0x14, 0x1e, 0x26, 0x40, + 0x4c, 0x10, 0x91, 0xb1, 0x25, 0x00, 0x02, 0x92, 0x01, 0x01, 0xff, 0x44, + 0xf8, 0x34, 0xf1, 0xf3, 0x01, 0x45, 0x9a, 0xcf, 0x20, 0x2b, 0x40, 0x06, + 0x45, 0x04, 0x06, 0x4a, 0x74, 0xb4, 0xdd, 0x2b, 0x40, 0x47, 0xcc, 0x46, + 0x26, 0x2b, 0x00, 0x47, 0xb1, 0x0a, 0x28, 0x2b, 0x00, 0xb3, 0x01, 0xff, + 0x4b, 0xd0, 0x0a, 0xfd, 0x25, 0x00, 0x45, 0xfe, 0x05, 0xfb, 0x25, 0x00, + 0x43, 0x00, 0x14, 0x50, 0x2b, 0x40, 0xa1, 0x4d, 0x03, 0xc4, 0x00, 0x19, + 0xaf, 0x01, 0xff, 0x04, 0x15, 0x01, 0x06, 0x64, 0x94, 0x0a, 0xa0, 0xf7, + 0x41, 0x4c, 0xc0, 0x95, 0x86, 0xcc, 0x01, 0x4d, 0x51, 0x8c, 0x87, 0xcc, + 0x41, 0x80, 0x17, 0x0a, 0xf8, 0x0b, 0x01, 0xff, 0x47, 0x33, 0x4c, 0xc5, + 0x25, 0x00, 0x4e, 0x92, 0x0c, 0xc3, 0x25, 0x00, 0x48, 0x01, 0x02, 0xc1, + 0x25, 0x40, 0x4a, 0xfe, 0xb1, 0xd9, 0x26, 0x00, 0x09, 0x9c, 0x01, 0x01, + 0xff, 0x4e, 0x4e, 0x28, 0x48, 0xf4, 0x01, 0x45, 0x5d, 0x14, 0x1c, 0x26, + 0x40, 0x4a, 0xd2, 0xb5, 0x1c, 0x2b, 0x00, 0x49, 0x75, 0xa3, 0x46, 0xf5, + 0x41, 0x55, 0x85, 0x3b, 0xab, 0xf5, 0x01, 0xa5, 0x0f, 0xaf, 0x01, 0xff, + 0x50, 0xea, 0x69, 0x2d, 0x2b, 0x00, 0x47, 0xee, 0xdc, 0xd6, 0x29, 0x40, + 0xa1, 0x06, 0x45, 0x5c, 0xd7, 0x21, 0x2b, 0x40, 0x42, 0x34, 0x00, 0x0d, + 0xf9, 0x81, 0x11, 0x03, 0x3e, 0x16, 0x01, 0xff, 0x4a, 0xf8, 0xad, 0x05, + 0x27, 0x00, 0x5c, 0x34, 0x1a, 0xc0, 0xfb, 0x41, 0x45, 0x0c, 0x29, 0x61, + 0x26, 0x40, 0xac, 0x16, 0x0c, 0xea, 0x13, 0x06, 0x4c, 0x24, 0x87, 0x39, + 0x26, 0x40, 0x44, 0xe0, 0x16, 0xce, 0x2b, 0x00, 0x44, 0xff, 0x13, 0x27, + 0x27, 0x40, 0x42, 0x23, 0x02, 0x90, 0x26, 0x80, 0x0f, 0xaf, 0x01, 0xff, + 0x45, 0x5e, 0x10, 0x40, 0x27, 0x00, 0x43, 0x15, 0x01, 0xae, 0xf4, 0x41, + 0x64, 0xe4, 0x08, 0xff, 0x26, 0x40, 0x46, 0xcd, 0x46, 0xc7, 0x25, 0x80, + 0x3c, 0x03, 0xa6, 0x01, 0x11, 0x08, 0xff, 0xcf, 0x01, 0xff, 0x44, 0x94, + 0x36, 0xc1, 0x26, 0x00, 0x43, 0x47, 0x19, 0xc0, 0x26, 0x40, 0x0a, 0x9b, + 0x01, 0x11, 0x0a, 0xf8, 0x0b, 0x01, 0xff, 0x4e, 0x92, 0x0c, 0xbf, 0x25, + 0x00, 0x48, 0x01, 0x02, 0xbd, 0x25, 0x40, 0x4e, 0x4e, 0x28, 0x47, 0xf4, + 0x01, 0x45, 0x5d, 0x14, 0x1f, 0x26, 0x00, 0x4f, 0xba, 0x72, 0x97, 0xf5, + 0x41, 0x80, 0x01, 0xff, 0x11, 0x9a, 0x0a, 0x12, 0x49, 0x1f, 0xab, 0xcb, + 0x26, 0x00, 0x44, 0x0d, 0x29, 0x62, 0x26, 0x00, 0x50, 0xca, 0x6b, 0xd0, + 0x27, 0x40, 0x4e, 0x72, 0x7d, 0x9b, 0xf7, 0x01, 0x4d, 0x08, 0x59, 0xc8, + 0x25, 0x00, 0x52, 0x03, 0x59, 0x9a, 0xf7, 0x41, 0x05, 0xc3, 0x8c, 0x76, + 0x45, 0x13, 0x03, 0xcb, 0x25, 0x80, 0x2a, 0x48, 0xb7, 0xcd, 0x67, 0x26, + 0x00, 0x54, 0xbf, 0x46, 0xe1, 0x27, 0x80, 0x0c, 0x49, 0x49, 0xae, 0xcb, + 0xfb, 0x01, 0x43, 0xea, 0x42, 0xf7, 0xf7, 0x41, 0x06, 0x50, 0x00, 0x01, + 0xff, 0x4e, 0xf4, 0x7c, 0xe2, 0x27, 0x00, 0x4f, 0xf3, 0x75, 0xe3, 0x27, + 0x40, 0x80, 0x01, 0xff, 0x5d, 0xfc, 0x15, 0x8a, 0xf7, 0x01, 0x05, 0x51, + 0x00, 0x01, 0xff, 0x02, 0x3b, 0x01, 0x27, 0x06, 0x13, 0x01, 0x17, 0x48, + 0x44, 0x0a, 0x87, 0x26, 0x00, 0x06, 0x6d, 0x02, 0x01, 0xff, 0x4d, 0x02, + 0x0e, 0xf4, 0x25, 0x00, 0x4e, 0x9b, 0x47, 0xf7, 0x25, 0x40, 0x4d, 0x02, + 0x0e, 0xf5, 0x25, 0x00, 0x4e, 0x9b, 0x47, 0xf6, 0x25, 0x40, 0x47, 0xc6, + 0x00, 0x86, 0x26, 0x00, 0x48, 0xf1, 0x43, 0xec, 0x29, 0x40, 0x45, 0x26, + 0xea, 0x55, 0xfa, 0x01, 0x46, 0x1e, 0xe0, 0x57, 0x26, 0x80, 0xed, 0x01, + 0x4a, 0x74, 0xaf, 0x48, 0xfa, 0x81, 0xdf, 0x01, 0x44, 0xa0, 0xf5, 0x54, + 0xfa, 0x01, 0xab, 0x73, 0x44, 0xf4, 0xf7, 0x59, 0x26, 0x80, 0x5b, 0x45, + 0x19, 0xc4, 0x55, 0x26, 0x80, 0x43, 0x44, 0x58, 0xf8, 0x56, 0x26, 0x80, + 0x2b, 0x07, 0x70, 0x0a, 0x01, 0xff, 0x46, 0x1e, 0xe0, 0x21, 0xfa, 0x01, + 0xab, 0x12, 0x44, 0xf4, 0xf7, 0x23, 0xfa, 0x01, 0x45, 0x19, 0xc4, 0x1f, + 0xfa, 0x01, 0x44, 0x58, 0xf8, 0x20, 0xfa, 0x41, 0x43, 0xa1, 0x01, 0x1e, + 0xfa, 0x01, 0x45, 0x73, 0x09, 0x22, 0xfa, 0x41, 0x09, 0x2a, 0x2e, 0x01, + 0xff, 0x4e, 0x33, 0x2e, 0x0b, 0xfa, 0x01, 0x5b, 0xf9, 0x1e, 0x35, 0xfa, + 0x41, 0x09, 0x2a, 0x2e, 0x01, 0xff, 0x4e, 0x33, 0x2e, 0x0a, 0xfa, 0x01, + 0x5b, 0xf9, 0x1e, 0x34, 0xfa, 0x41, 0x09, 0x2a, 0x2e, 0x01, 0xff, 0x4e, + 0x33, 0x2e, 0x0e, 0xfa, 0x01, 0x5b, 0xf9, 0x1e, 0x38, 0xfa, 0x41, 0x43, + 0xa1, 0x01, 0x54, 0x26, 0x80, 0x4c, 0x45, 0x73, 0x09, 0x58, 0x26, 0xc0, + 0x00, 0x09, 0x2a, 0x2e, 0x15, 0x8d, 0x01, 0xff, 0x46, 0x1e, 0xe0, 0x50, + 0xfa, 0x01, 0x45, 0x19, 0xc4, 0x4e, 0xfa, 0x01, 0x44, 0x58, 0xf8, 0x4f, + 0xfa, 0x41, 0x52, 0x3b, 0x54, 0x06, 0xfa, 0x01, 0x4e, 0x33, 0x2e, 0x0d, + 0xfa, 0x01, 0x5f, 0x3b, 0x12, 0x1b, 0xfa, 0x01, 0xb4, 0x01, 0xff, 0x5c, + 0x00, 0x19, 0x45, 0xfa, 0x01, 0x0b, 0xfa, 0x1e, 0x01, 0xff, 0x4f, 0x05, + 0x1f, 0x37, 0xfa, 0x01, 0x53, 0x4f, 0x50, 0x30, 0xfa, 0x41, 0x09, 0x2a, + 0x2e, 0x01, 0xff, 0x4e, 0x33, 0x2e, 0x09, 0xfa, 0x01, 0x5b, 0xf9, 0x1e, + 0x33, 0xfa, 0x41, 0x57, 0x2a, 0x2e, 0x4b, 0xfa, 0x41, 0x09, 0x2a, 0x2e, + 0x01, 0xff, 0x4e, 0x33, 0x2e, 0x0c, 0xfa, 0x01, 0x5b, 0xf9, 0x1e, 0x36, + 0xfa, 0x41, 0x43, 0x7a, 0x0b, 0xac, 0xf8, 0x01, 0x4a, 0xee, 0xb7, 0xad, + 0xf8, 0x41, 0x4a, 0x3c, 0xab, 0x38, 0x26, 0x00, 0x4c, 0xe8, 0x91, 0x7f, + 0x26, 0x40, 0x04, 0x2e, 0x19, 0x22, 0xa4, 0x14, 0xa9, 0x06, 0x4f, 0x7a, + 0x76, 0x70, 0x26, 0x40, 0x5a, 0x3b, 0x21, 0x18, 0x21, 0x00, 0x4a, 0x50, + 0xb0, 0xcb, 0xf3, 0x41, 0x44, 0x89, 0x08, 0x92, 0xf4, 0x01, 0x5a, 0x76, + 0x18, 0xbc, 0x27, 0x40, 0x48, 0x85, 0x20, 0x40, 0xf6, 0x01, 0x44, 0x0c, + 0x08, 0x29, 0xf6, 0x41, 0x44, 0x19, 0x8e, 0xc7, 0xf9, 0x01, 0xae, 0xb5, + 0x05, 0xb2, 0x95, 0x01, 0x49, 0x42, 0xc5, 0xd1, 0xf5, 0x01, 0xb4, 0x62, + 0xb6, 0x11, 0x05, 0x55, 0xf2, 0x01, 0xff, 0x54, 0x63, 0x43, 0x12, 0xf3, + 0x01, 0x53, 0x01, 0x4c, 0x14, 0xf3, 0x41, 0x02, 0x60, 0x00, 0x35, 0x04, + 0xa1, 0x01, 0x1f, 0x02, 0x09, 0x00, 0x01, 0xff, 0x44, 0x5d, 0x13, 0x30, + 0x30, 0x00, 0xac, 0x06, 0x48, 0x14, 0x8f, 0x4b, 0xfe, 0x40, 0x43, 0xf0, + 0x05, 0x07, 0x23, 0x00, 0x47, 0x08, 0x8f, 0x4f, 0xfe, 0x40, 0x4a, 0x9e, + 0xad, 0xf4, 0xf3, 0x01, 0x49, 0xe4, 0x49, 0x4b, 0xf4, 0x01, 0x4a, 0x06, + 0xb9, 0xf3, 0xf3, 0x41, 0x18, 0xa4, 0x28, 0x06, 0x44, 0x5d, 0x13, 0x1c, + 0x30, 0x40, 0x44, 0xc3, 0x00, 0x3f, 0x2b, 0x00, 0x45, 0xc8, 0x00, 0x33, + 0x29, 0x40, 0x42, 0x3b, 0x15, 0x1a, 0x23, 0x00, 0x02, 0x33, 0x00, 0x01, + 0xff, 0x80, 0x06, 0x45, 0x7c, 0xee, 0x49, 0xf3, 0x41, 0x47, 0x77, 0xd5, + 0x03, 0xf4, 0x01, 0x46, 0x96, 0xe0, 0xbe, 0xf6, 0x01, 0x44, 0x14, 0xf8, + 0x3d, 0xf9, 0x01, 0x44, 0x14, 0x5a, 0x0a, 0xf3, 0x41, 0x09, 0x97, 0xbb, + 0x06, 0x49, 0x45, 0xc2, 0xa0, 0x26, 0x40, 0x0f, 0x0b, 0x06, 0xd1, 0x02, + 0x06, 0xef, 0x06, 0x8a, 0x02, 0x07, 0x37, 0x3c, 0xc8, 0x01, 0x42, 0x14, + 0x05, 0xff, 0x18, 0x01, 0x0d, 0x9b, 0x08, 0x01, 0xff, 0xe1, 0xc1, 0x18, + 0x81, 0xa9, 0x01, 0x42, 0xf8, 0x0d, 0xd7, 0x18, 0x01, 0x42, 0x7b, 0x08, + 0xd4, 0x18, 0x01, 0xe5, 0xc8, 0x18, 0x81, 0x8c, 0x01, 0x42, 0x24, 0x02, + 0xcb, 0x18, 0x01, 0xa8, 0x69, 0x42, 0xc0, 0x29, 0xc6, 0x18, 0x01, 0x42, + 0x4d, 0x03, 0xcc, 0x18, 0x01, 0xae, 0x4f, 0xef, 0xc9, 0x18, 0x81, 0x44, + 0x42, 0x73, 0x0c, 0xd8, 0x18, 0x01, 0xb3, 0x30, 0x43, 0x15, 0x06, 0xd2, + 0x18, 0x01, 0xb5, 0x20, 0x44, 0x04, 0xf9, 0xdf, 0x18, 0x01, 0x42, 0x51, + 0x00, 0xc2, 0x18, 0x01, 0xb9, 0x01, 0xff, 0xe1, 0xc4, 0x18, 0x01, 0xef, + 0xc5, 0x18, 0x01, 0xf5, 0xc3, 0x18, 0xc1, 0x00, 0xea, 0xce, 0x18, 0x41, + 0xe3, 0xcf, 0x18, 0x01, 0xf5, 0xc7, 0x18, 0x41, 0x42, 0xc0, 0x29, 0xde, + 0x18, 0x01, 0x43, 0x9c, 0xfa, 0xdd, 0x18, 0x41, 0x42, 0x7f, 0x02, 0xd1, + 0x18, 0x41, 0x43, 0x2b, 0x5a, 0xc0, 0x18, 0x01, 0x43, 0xe1, 0x47, 0xd3, + 0x18, 0x41, 0x42, 0x17, 0x00, 0xdc, 0x18, 0x01, 0x43, 0x38, 0xd0, 0xd9, + 0x18, 0x01, 0xaf, 0x01, 0xff, 0x42, 0x13, 0x01, 0xda, 0x18, 0x01, 0x42, + 0xcf, 0x00, 0xdb, 0x18, 0x41, 0xae, 0x01, 0xff, 0xee, 0xd0, 0x18, 0x01, + 0xf9, 0xcd, 0x18, 0x41, 0xed, 0xd6, 0x18, 0x01, 0x42, 0x1d, 0x01, 0xca, + 0x18, 0x01, 0xf4, 0xd5, 0x18, 0x41, 0x46, 0x1a, 0xe1, 0xf1, 0x18, 0x01, + 0xa6, 0x29, 0x46, 0x33, 0x2e, 0xf2, 0x18, 0x01, 0xb3, 0x15, 0xb4, 0x01, + 0xff, 0x42, 0x92, 0x01, 0xea, 0x18, 0x01, 0x45, 0x48, 0x12, 0xec, 0x18, + 0x01, 0x45, 0xe8, 0x1e, 0xeb, 0x18, 0x41, 0x46, 0x06, 0x1f, 0xf0, 0x18, + 0x01, 0x44, 0x36, 0xe3, 0xef, 0x18, 0x41, 0x44, 0x03, 0x24, 0xee, 0x18, + 0x01, 0x44, 0x3c, 0x54, 0xed, 0x18, 0x41, 0x45, 0x7e, 0x0b, 0xe8, 0x18, + 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xe9, 0x18, 0x01, 0x43, 0x7a, 0x0b, + 0xe1, 0x18, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xe0, 0x18, + 0x41, 0x44, 0x25, 0x01, 0xe3, 0x18, 0x01, 0x42, 0x15, 0x02, 0xe2, 0x18, + 0x41, 0x44, 0x06, 0x1f, 0xe7, 0x18, 0x01, 0x42, 0x09, 0x24, 0xe6, 0x18, + 0x41, 0x43, 0xf9, 0x05, 0xe5, 0x18, 0x01, 0x43, 0xf6, 0x06, 0xe4, 0x18, + 0x41, 0xe1, 0xa1, 0x18, 0x81, 0xa9, 0x01, 0x42, 0xf8, 0x0d, 0xb7, 0x18, + 0x01, 0x42, 0x7b, 0x08, 0xb4, 0x18, 0x01, 0xe5, 0xa8, 0x18, 0x81, 0x8c, + 0x01, 0x42, 0x24, 0x02, 0xab, 0x18, 0x01, 0xa8, 0x69, 0x42, 0xc0, 0x29, + 0xa6, 0x18, 0x01, 0x42, 0x4d, 0x03, 0xac, 0x18, 0x01, 0xae, 0x4f, 0xef, + 0xa9, 0x18, 0x81, 0x44, 0x42, 0x73, 0x0c, 0xb8, 0x18, 0x01, 0xb3, 0x30, + 0x43, 0x15, 0x06, 0xb2, 0x18, 0x01, 0xb5, 0x20, 0x44, 0x04, 0xf9, 0xbf, + 0x18, 0x01, 0x42, 0x51, 0x00, 0xa2, 0x18, 0x01, 0xb9, 0x01, 0xff, 0xe1, + 0xa4, 0x18, 0x01, 0xef, 0xa5, 0x18, 0x01, 0xf5, 0xa3, 0x18, 0xc1, 0x00, + 0xea, 0xae, 0x18, 0x41, 0xe3, 0xaf, 0x18, 0x01, 0xf5, 0xa7, 0x18, 0x41, + 0x42, 0xc0, 0x29, 0xbe, 0x18, 0x01, 0x43, 0x9c, 0xfa, 0xbd, 0x18, 0x41, + 0x42, 0x7f, 0x02, 0xb1, 0x18, 0x41, 0x43, 0x2b, 0x5a, 0xa0, 0x18, 0x01, + 0x43, 0xe1, 0x47, 0xb3, 0x18, 0x41, 0x42, 0x17, 0x00, 0xbc, 0x18, 0x01, + 0x43, 0x38, 0xd0, 0xb9, 0x18, 0x01, 0xaf, 0x01, 0xff, 0x42, 0x13, 0x01, + 0xba, 0x18, 0x01, 0x42, 0xcf, 0x00, 0xbb, 0x18, 0x41, 0xae, 0x01, 0xff, + 0xee, 0xb0, 0x18, 0x01, 0xf9, 0xad, 0x18, 0x41, 0xed, 0xb6, 0x18, 0x01, + 0x42, 0x1d, 0x01, 0xaa, 0x18, 0x01, 0xf4, 0xb5, 0x18, 0x41, 0x04, 0x84, + 0xe0, 0x11, 0x04, 0xa1, 0x01, 0x01, 0xff, 0x54, 0x63, 0x43, 0x18, 0xf3, + 0x01, 0x53, 0x01, 0x4c, 0x16, 0xf3, 0x41, 0x06, 0xef, 0x06, 0xa6, 0x02, + 0x07, 0x13, 0x06, 0x25, 0x49, 0x21, 0xc2, 0xff, 0xe2, 0x01, 0x05, 0xc2, + 0x2e, 0x01, 0xff, 0x43, 0xb5, 0xe4, 0xee, 0xe2, 0x81, 0x0d, 0x43, 0xa3, + 0x1a, 0xec, 0xe2, 0xc1, 0x00, 0x42, 0x51, 0x03, 0xed, 0xe2, 0x41, 0x42, + 0x51, 0x03, 0xef, 0xe2, 0x41, 0xe1, 0xc1, 0xe2, 0x81, 0xdf, 0x01, 0x42, + 0x16, 0x00, 0xc2, 0xe2, 0x01, 0x42, 0x37, 0x00, 0xc3, 0xe2, 0x01, 0x42, + 0x7b, 0x08, 0xc4, 0xe2, 0x01, 0xe5, 0xdb, 0xe2, 0x81, 0xc3, 0x01, 0x42, + 0x0c, 0x08, 0xcd, 0xe2, 0x01, 0x42, 0x24, 0x02, 0xc5, 0xe2, 0x01, 0x42, + 0x22, 0x00, 0xda, 0xe2, 0x01, 0xe9, 0xdc, 0xe2, 0x81, 0xa5, 0x01, 0x42, + 0x78, 0x1a, 0xd0, 0xe2, 0x01, 0xab, 0x92, 0x01, 0xac, 0x85, 0x01, 0x42, + 0x6c, 0x00, 0xd8, 0xe2, 0x01, 0xae, 0x6d, 0xef, 0xd5, 0xe2, 0x81, 0x5f, + 0xb0, 0x53, 0x42, 0x71, 0x00, 0xd7, 0xe2, 0x01, 0xb3, 0x41, 0xb4, 0x29, + 0xf5, 0xde, 0xe2, 0x81, 0x1e, 0x42, 0x61, 0x0b, 0xd3, 0xe2, 0x01, 0x42, + 0xa9, 0x01, 0xd2, 0xe2, 0x01, 0xb9, 0x06, 0x42, 0x59, 0x00, 0xd1, 0xe2, + 0x41, 0xe1, 0xc6, 0xe2, 0x01, 0x42, 0x61, 0x2e, 0xeb, 0xe2, 0x41, 0x42, + 0x92, 0x01, 0xea, 0xe2, 0x41, 0xe1, 0xcb, 0xe2, 0x01, 0x42, 0x22, 0x00, + 0xcc, 0xe2, 0x01, 0x42, 0x71, 0x00, 0xe1, 0xe2, 0x01, 0x42, 0x40, 0x06, + 0xe0, 0xe2, 0x41, 0xe1, 0xce, 0xe2, 0x01, 0x42, 0x22, 0x00, 0xcf, 0xe2, + 0x41, 0xe1, 0xca, 0xe2, 0x01, 0x42, 0x22, 0x00, 0xc7, 0xe2, 0x41, 0xee, + 0xe6, 0xe2, 0xc1, 0x00, 0xe7, 0xe2, 0xe2, 0x41, 0xe1, 0xc9, 0xe2, 0x01, + 0x42, 0x24, 0x02, 0xdd, 0xe2, 0x01, 0x42, 0xdf, 0x23, 0xe9, 0xe2, 0x41, + 0xe1, 0xc8, 0xe2, 0x01, 0x43, 0x4f, 0x09, 0xdf, 0xe2, 0x41, 0xe1, 0xd4, + 0xe2, 0x01, 0x42, 0x22, 0x00, 0xd9, 0xe2, 0x41, 0x42, 0x1d, 0x01, 0xe5, + 0xe2, 0x41, 0xee, 0xe7, 0xe2, 0x41, 0xe1, 0xc0, 0xe2, 0x81, 0x0a, 0x42, + 0x1d, 0x01, 0xe4, 0xe2, 0x01, 0xf5, 0xd6, 0xe2, 0x41, 0xee, 0xe8, 0xe2, + 0xc1, 0x00, 0xe7, 0xe3, 0xe2, 0x41, 0x45, 0x7e, 0x0b, 0xf8, 0xe2, 0x01, + 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xf9, 0xe2, 0x01, 0x43, 0x7a, 0x0b, 0xf1, + 0xe2, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xf0, 0xe2, 0x41, + 0x44, 0x25, 0x01, 0xf3, 0xe2, 0x01, 0x42, 0x15, 0x02, 0xf2, 0xe2, 0x41, + 0x44, 0x06, 0x1f, 0xf7, 0xe2, 0x01, 0x42, 0x09, 0x24, 0xf6, 0xe2, 0x41, + 0x43, 0xf9, 0x05, 0xf5, 0xe2, 0x01, 0x43, 0xf6, 0x06, 0xf4, 0xe2, 0x41, + 0xa1, 0xbe, 0x13, 0xa5, 0xeb, 0x0d, 0xa9, 0xf0, 0x09, 0xaf, 0xd2, 0x09, + 0xb3, 0xa6, 0x01, 0xf4, 0x0b, 0x00, 0x80, 0x9c, 0x01, 0x02, 0x1f, 0x01, + 0x01, 0xff, 0x45, 0xee, 0xea, 0xe6, 0x2b, 0x00, 0x0d, 0x4a, 0x87, 0x01, + 0xff, 0xa6, 0x74, 0x04, 0x7a, 0x0b, 0x35, 0x4d, 0x58, 0x4f, 0x5e, 0x21, + 0x00, 0xb4, 0x06, 0x4b, 0xc1, 0xaa, 0x89, 0x21, 0x40, 0x05, 0x25, 0x01, + 0x11, 0x03, 0x45, 0x0a, 0x01, 0xff, 0x46, 0xdc, 0xb4, 0x56, 0x21, 0x00, + 0x46, 0x21, 0x78, 0x54, 0x21, 0x40, 0x47, 0x5e, 0x4f, 0x5c, 0x21, 0x00, + 0x46, 0xdc, 0xb4, 0x57, 0x21, 0x00, 0x48, 0x2a, 0x01, 0xbe, 0x00, 0x40, + 0x46, 0x7e, 0x0b, 0x5b, 0x21, 0x00, 0x45, 0xdc, 0xb4, 0x55, 0x21, 0x00, + 0x44, 0x22, 0x00, 0xbd, 0x00, 0x00, 0x45, 0x12, 0xef, 0x51, 0x21, 0x00, + 0x47, 0x2a, 0x01, 0xbc, 0x00, 0x00, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, + 0xa4, 0x1c, 0x52, 0x21, 0x00, 0x44, 0x22, 0x78, 0x53, 0x21, 0x40, 0x46, + 0x7a, 0xe1, 0x50, 0x21, 0x00, 0x44, 0x09, 0x24, 0x59, 0x21, 0x40, 0x04, + 0xf9, 0x05, 0x06, 0x4a, 0xd8, 0xb4, 0x58, 0x21, 0x40, 0x47, 0x5e, 0x4f, + 0x5d, 0x21, 0x00, 0x46, 0xe8, 0xe5, 0x5a, 0x21, 0x40, 0xf3, 0x8a, 0x00, + 0x40, 0xd1, 0x00, 0xfe, 0x80, 0xda, 0x04, 0xd2, 0x01, 0xfe, 0x80, 0xbf, 0x02, 0xd3, 0x02, 0xfe, 0x80, 0x91, 0x02, 0xd4, 0x03, 0xfe, 0x80, 0xe3, 0x01, 0xd5, 0x04, 0xfe, 0x80, 0xb5, 0x01, 0xd6, 0x05, 0xfe, 0x80, 0x87, 0x01, 0xd7, 0x06, 0xfe, 0x80, 0x5a, 0xd8, 0x07, 0xfe, 0x80, 0x2d, 0xd9, @@ -2103,1715 +1931,1913 @@ static const unsigned char uname2c_tree[222744] = { 0x01, 0x0e, 0xd9, 0x66, 0x01, 0x4e, 0xd0, 0x53, 0x01, 0x0e, 0xd1, 0x54, 0x01, 0x0e, 0xd2, 0x55, 0x01, 0x0e, 0xd3, 0x56, 0x01, 0x0e, 0xd4, 0x57, 0x01, 0x0e, 0xd5, 0x58, 0x01, 0x0e, 0xd6, 0x59, 0x01, 0x0e, 0xd7, 0x5a, - 0x01, 0x0e, 0xd8, 0x5b, 0x01, 0x0e, 0xd9, 0x5c, 0x01, 0x4e, 0x45, 0x13, - 0x05, 0x0d, 0xa6, 0x00, 0x06, 0xef, 0x06, 0x83, 0x0b, 0x49, 0x81, 0x16, - 0x0e, 0xa6, 0x00, 0x4d, 0xc1, 0x34, 0x0f, 0xa6, 0x00, 0x02, 0x16, 0x08, - 0x01, 0xff, 0x07, 0x38, 0x18, 0x5f, 0x05, 0x61, 0x16, 0x01, 0xff, 0x44, - 0x26, 0x16, 0x17, 0xa6, 0x00, 0xa4, 0x3d, 0xa6, 0x2f, 0x44, 0x5c, 0xac, - 0x1f, 0xa6, 0x00, 0xab, 0x1b, 0x43, 0x9d, 0xf4, 0x16, 0xa6, 0x00, 0xb4, - 0x01, 0xff, 0x42, 0x80, 0x12, 0x19, 0xa6, 0x00, 0x43, 0xa1, 0x01, 0x15, - 0xa6, 0x00, 0x43, 0xd8, 0x02, 0x1d, 0xa6, 0x40, 0x44, 0xd5, 0x9b, 0x14, - 0xa6, 0x00, 0x43, 0xb1, 0x45, 0x1c, 0xa6, 0x40, 0x42, 0x80, 0x12, 0x18, - 0xa6, 0x00, 0x44, 0xd5, 0x9b, 0x13, 0xa6, 0x40, 0x43, 0x1c, 0x01, 0x1a, - 0xa6, 0x00, 0xaf, 0x01, 0xff, 0x42, 0x51, 0x21, 0x1e, 0xa6, 0x00, 0x43, - 0xd8, 0x02, 0x1b, 0xa6, 0x40, 0xe1, 0x49, 0xa5, 0x80, 0x85, 0x0a, 0xa2, - 0xc4, 0x09, 0xa3, 0xa3, 0x09, 0xa4, 0xc2, 0x08, 0xe5, 0xe1, 0xa5, 0x80, - 0xaf, 0x08, 0xa6, 0x8e, 0x08, 0xa7, 0xc1, 0x07, 0xa8, 0x89, 0x07, 0xe9, - 0x24, 0xa5, 0x80, 0xff, 0x06, 0xaa, 0xde, 0x06, 0xab, 0x8f, 0x06, 0xac, - 0xe8, 0x05, 0xad, 0x85, 0x05, 0xae, 0xa4, 0x03, 0xef, 0xba, 0xa5, 0x80, - 0x91, 0x03, 0xb0, 0xf0, 0x02, 0xb2, 0xcf, 0x02, 0xb3, 0x8e, 0x02, 0xb4, - 0xcd, 0x01, 0xf5, 0x95, 0xa5, 0x80, 0xc3, 0x01, 0xb6, 0xa2, 0x01, 0xb7, - 0x61, 0xb9, 0x41, 0xba, 0x01, 0xff, 0xe1, 0x64, 0xa5, 0x00, 0xe5, 0xfd, - 0xa5, 0x80, 0x31, 0xa8, 0x11, 0xe9, 0x3d, 0xa5, 0x00, 0xef, 0xd5, 0xa5, - 0x80, 0x04, 0xf5, 0xae, 0xa5, 0x40, 0xef, 0x89, 0xa5, 0x40, 0xe1, 0x65, - 0xa5, 0x00, 0xe5, 0xfe, 0xa5, 0x80, 0x11, 0xe9, 0x3e, 0xa5, 0x00, 0xef, - 0xd6, 0xa5, 0x80, 0x04, 0xf5, 0xaf, 0xa5, 0x40, 0xef, 0x8a, 0xa5, 0x40, - 0xe5, 0x19, 0xa5, 0x40, 0xe5, 0x18, 0xa5, 0x40, 0xe1, 0x69, 0xa5, 0x00, - 0xe5, 0x02, 0xa6, 0x80, 0x11, 0xe9, 0x42, 0xa5, 0x00, 0xef, 0xda, 0xa5, - 0x80, 0x04, 0xf5, 0xb3, 0xa5, 0x40, 0xef, 0x8e, 0xa5, 0x40, 0xe5, 0x1d, - 0xa5, 0x40, 0xe1, 0x4e, 0xa5, 0x80, 0x36, 0xe5, 0xe6, 0xa5, 0x80, 0x24, - 0xe9, 0x28, 0xa5, 0x80, 0x1b, 0xef, 0xbf, 0xa5, 0x80, 0x09, 0xf5, 0x99, - 0xa5, 0xc0, 0x00, 0xee, 0x9a, 0xa5, 0x40, 0xee, 0xc0, 0xa5, 0x00, 0xef, - 0x74, 0xa5, 0xc0, 0x00, 0xee, 0x75, 0xa5, 0x40, 0xee, 0x29, 0xa5, 0x40, - 0xe5, 0x03, 0xa5, 0x80, 0x04, 0xee, 0xe7, 0xa5, 0x40, 0xee, 0x04, 0xa5, - 0x40, 0xee, 0x4f, 0xa5, 0x40, 0xe1, 0x59, 0xa5, 0x00, 0xe5, 0xf2, 0xa5, - 0x80, 0x11, 0xe9, 0x32, 0xa5, 0x00, 0xef, 0xca, 0xa5, 0x80, 0x04, 0xf5, - 0xa3, 0xa5, 0x40, 0xef, 0x7e, 0xa5, 0x40, 0xe5, 0x0d, 0xa5, 0x40, 0xee, - 0x96, 0xa5, 0x40, 0xe1, 0x5a, 0xa5, 0x00, 0xe5, 0xf3, 0xa5, 0x80, 0x31, - 0xa8, 0x11, 0xe9, 0x33, 0xa5, 0x00, 0xef, 0xcb, 0xa5, 0x80, 0x04, 0xf5, - 0xa4, 0xa5, 0x40, 0xef, 0x7f, 0xa5, 0x40, 0xe1, 0x5b, 0xa5, 0x00, 0xe5, - 0xf4, 0xa5, 0x80, 0x11, 0xe9, 0x34, 0xa5, 0x00, 0xef, 0xcc, 0xa5, 0x80, - 0x04, 0xf5, 0xa5, 0xa5, 0x40, 0xef, 0x80, 0xa5, 0x40, 0xe5, 0x0f, 0xa5, - 0x40, 0xe5, 0x0e, 0xa5, 0x40, 0xe1, 0x62, 0xa5, 0x00, 0xe5, 0xfb, 0xa5, - 0x80, 0x31, 0xa8, 0x11, 0xe9, 0x3b, 0xa5, 0x00, 0xef, 0xd3, 0xa5, 0x80, - 0x04, 0xf5, 0xac, 0xa5, 0x40, 0xef, 0x87, 0xa5, 0x40, 0xe1, 0x63, 0xa5, - 0x00, 0xe5, 0xfc, 0xa5, 0x80, 0x11, 0xe9, 0x3c, 0xa5, 0x00, 0xef, 0xd4, - 0xa5, 0x80, 0x04, 0xf5, 0xad, 0xa5, 0x40, 0xef, 0x88, 0xa5, 0x40, 0xe5, - 0x17, 0xa5, 0x40, 0xe5, 0x16, 0xa5, 0x40, 0xe1, 0x5f, 0xa5, 0x00, 0xe5, - 0xf8, 0xa5, 0x80, 0x11, 0xe9, 0x38, 0xa5, 0x00, 0xef, 0xd0, 0xa5, 0x80, - 0x04, 0xf5, 0xa9, 0xa5, 0x40, 0xef, 0x84, 0xa5, 0x40, 0xe5, 0x13, 0xa5, - 0x40, 0xe1, 0x50, 0xa5, 0x00, 0xe5, 0xe8, 0xa5, 0x80, 0x11, 0xe9, 0x2a, - 0xa5, 0x00, 0xef, 0xc1, 0xa5, 0x80, 0x04, 0xf5, 0x9b, 0xa5, 0x40, 0xef, - 0x76, 0xa5, 0x40, 0xe5, 0x05, 0xa5, 0x40, 0xee, 0xbb, 0xa5, 0x00, 0xef, - 0x71, 0xa5, 0xc0, 0x00, 0xee, 0x72, 0xa5, 0x40, 0xe1, 0x6f, 0xa5, 0x00, - 0xa4, 0x97, 0x01, 0xe5, 0x09, 0xa6, 0x80, 0x8d, 0x01, 0xe7, 0x0b, 0xa6, - 0x80, 0x52, 0xe9, 0x47, 0xa5, 0x00, 0xaa, 0x2e, 0xef, 0xdf, 0xa5, 0x80, - 0x25, 0xf5, 0xb8, 0xa5, 0x00, 0xb9, 0x01, 0xff, 0xe1, 0x70, 0xa5, 0x00, - 0xe5, 0x0a, 0xa6, 0x80, 0x11, 0xe9, 0x48, 0xa5, 0x00, 0xef, 0xe0, 0xa5, - 0x80, 0x04, 0xf5, 0xb9, 0xa5, 0x40, 0xef, 0x94, 0xa5, 0x40, 0xe5, 0x23, - 0xa5, 0x40, 0xef, 0x93, 0xa5, 0x40, 0xe1, 0x68, 0xa5, 0x00, 0xe5, 0x01, - 0xa6, 0x80, 0x11, 0xe9, 0x41, 0xa5, 0x00, 0xef, 0xd9, 0xa5, 0x80, 0x04, - 0xf5, 0xb2, 0xa5, 0x40, 0xef, 0x8d, 0xa5, 0x40, 0xe5, 0x1c, 0xa5, 0x40, - 0x42, 0x1a, 0x00, 0x4b, 0xa5, 0x00, 0x42, 0x92, 0x01, 0xe3, 0xa5, 0x00, - 0xa7, 0x06, 0x42, 0x10, 0x00, 0xbc, 0xa5, 0x40, 0xe1, 0x6c, 0xa5, 0x00, - 0xe5, 0x04, 0xa6, 0x80, 0x11, 0xe9, 0x44, 0xa5, 0x00, 0xef, 0xdc, 0xa5, - 0x80, 0x04, 0xf5, 0xb5, 0xa5, 0x40, 0xef, 0x90, 0xa5, 0x40, 0xe5, 0x1f, - 0xa5, 0x00, 0xee, 0x05, 0xa6, 0x40, 0xe5, 0x22, 0xa5, 0x40, 0xe1, 0x61, - 0xa5, 0x00, 0xe5, 0xfa, 0xa5, 0x80, 0x33, 0xe9, 0x3a, 0xa5, 0x00, 0xef, - 0xd2, 0xa5, 0x80, 0x04, 0xf5, 0xab, 0xa5, 0x40, 0x03, 0x3f, 0x01, 0x04, - 0xef, 0x86, 0xa5, 0x40, 0x42, 0x3b, 0x01, 0x2b, 0xa6, 0x00, 0x42, 0x0c, - 0x08, 0x10, 0xa6, 0x00, 0x42, 0x1b, 0x02, 0x11, 0xa6, 0x00, 0x42, 0x6c, - 0x00, 0x2a, 0xa6, 0x00, 0x43, 0x61, 0xe3, 0x12, 0xa6, 0x40, 0xe5, 0x15, - 0xa5, 0x40, 0xe1, 0x6e, 0xa5, 0x00, 0xa2, 0x3c, 0xe5, 0x08, 0xa6, 0x80, - 0x33, 0x02, 0xa0, 0x48, 0x11, 0xe9, 0x46, 0xa5, 0x00, 0xef, 0xde, 0xa5, - 0x80, 0x04, 0xf5, 0xb7, 0xa5, 0x40, 0xef, 0x92, 0xa5, 0x40, 0xe1, 0x56, - 0xa5, 0x00, 0xe5, 0xee, 0xa5, 0x80, 0x11, 0xe9, 0x2f, 0xa5, 0x00, 0xef, - 0xc6, 0xa5, 0x80, 0x04, 0xf5, 0xa0, 0xa5, 0x40, 0xef, 0x7b, 0xa5, 0x40, - 0xe5, 0x0a, 0xa5, 0x40, 0xe5, 0x21, 0xa5, 0x40, 0xe1, 0x53, 0xa5, 0x00, - 0xe5, 0xeb, 0xa5, 0x80, 0x11, 0xe9, 0x2d, 0xa5, 0x00, 0xef, 0xc4, 0xa5, - 0x80, 0x04, 0xf5, 0x9e, 0xa5, 0x40, 0xef, 0x79, 0xa5, 0x40, 0xe5, 0x08, - 0xa5, 0x40, 0xe1, 0x5e, 0xa5, 0x00, 0xe5, 0xf7, 0xa5, 0x80, 0x11, 0xe9, - 0x37, 0xa5, 0x00, 0xef, 0xcf, 0xa5, 0x80, 0x04, 0xf5, 0xa8, 0xa5, 0x40, - 0xef, 0x83, 0xa5, 0x40, 0xe5, 0x12, 0xa5, 0x00, 0x48, 0xdc, 0x56, 0x0c, - 0xa6, 0x40, 0xe1, 0x6a, 0xa5, 0x80, 0x43, 0xe5, 0x03, 0xa6, 0x80, 0x3a, - 0xe9, 0x43, 0xa5, 0x00, 0xef, 0xdb, 0xa5, 0x80, 0x2d, 0xb0, 0x04, 0xf5, - 0xb4, 0xa5, 0x40, 0xe1, 0x54, 0xa5, 0x80, 0x1e, 0xe5, 0xec, 0xa5, 0x80, - 0x11, 0xe9, 0x2e, 0xa5, 0x00, 0xef, 0xc5, 0xa5, 0x80, 0x04, 0xf5, 0x9f, - 0xa5, 0x40, 0xef, 0x7a, 0xa5, 0x40, 0xe5, 0x09, 0xa5, 0x00, 0xee, 0xed, - 0xa5, 0x40, 0xee, 0x55, 0xa5, 0x40, 0xef, 0x8f, 0xa5, 0x40, 0xe5, 0x1e, - 0xa5, 0x40, 0xee, 0x6b, 0xa5, 0x40, 0xe1, 0x67, 0xa5, 0x00, 0xe5, 0x00, - 0xa6, 0x80, 0x11, 0xe9, 0x40, 0xa5, 0x00, 0xef, 0xd8, 0xa5, 0x80, 0x04, - 0xf5, 0xb1, 0xa5, 0x40, 0xef, 0x8c, 0xa5, 0x40, 0xe5, 0x1b, 0xa5, 0x40, - 0xee, 0x25, 0xa5, 0x40, 0xe1, 0x4c, 0xa5, 0x80, 0x2c, 0xe5, 0xe4, 0xa5, - 0x80, 0x1f, 0xe9, 0x26, 0xa5, 0x80, 0x16, 0xef, 0xbd, 0xa5, 0x80, 0x09, - 0xf5, 0x97, 0xa5, 0xc0, 0x00, 0xee, 0x98, 0xa5, 0x40, 0xee, 0xbe, 0xa5, - 0x00, 0xef, 0x73, 0xa5, 0x40, 0xee, 0x27, 0xa5, 0x40, 0xe5, 0x02, 0xa5, - 0x00, 0xee, 0xe5, 0xa5, 0x40, 0xee, 0x4d, 0xa5, 0x40, 0xe1, 0x6d, 0xa5, - 0x00, 0xa2, 0x1e, 0xe5, 0x06, 0xa6, 0x80, 0x11, 0xe9, 0x45, 0xa5, 0x00, - 0xef, 0xdd, 0xa5, 0x80, 0x04, 0xf5, 0xb6, 0xa5, 0x40, 0xef, 0x91, 0xa5, - 0x40, 0xe5, 0x20, 0xa5, 0x00, 0xee, 0x07, 0xa6, 0x40, 0xe1, 0x57, 0xa5, - 0x00, 0xe5, 0xef, 0xa5, 0x80, 0x15, 0xe9, 0x30, 0xa5, 0x00, 0xef, 0xc7, - 0xa5, 0x80, 0x04, 0xf5, 0xa1, 0xa5, 0x40, 0xee, 0xc8, 0xa5, 0x00, 0xef, - 0x7c, 0xa5, 0x40, 0xe5, 0x0b, 0xa5, 0x00, 0xee, 0xf0, 0xa5, 0x40, 0xe1, - 0x58, 0xa5, 0x00, 0xe5, 0xf1, 0xa5, 0x80, 0x11, 0xe9, 0x31, 0xa5, 0x00, - 0xef, 0xc9, 0xa5, 0x80, 0x04, 0xf5, 0xa2, 0xa5, 0x40, 0xef, 0x7d, 0xa5, - 0x40, 0xe5, 0x0c, 0xa5, 0x40, 0xe5, 0x00, 0xa5, 0x80, 0x04, 0xee, 0xe2, - 0xa5, 0x40, 0xee, 0x01, 0xa5, 0x40, 0xe1, 0x60, 0xa5, 0x00, 0xe5, 0xf9, - 0xa5, 0x80, 0x51, 0xa8, 0x11, 0xe9, 0x39, 0xa5, 0x00, 0xef, 0xd1, 0xa5, - 0x80, 0x04, 0xf5, 0xaa, 0xa5, 0x40, 0xef, 0x85, 0xa5, 0x40, 0xe1, 0x5c, - 0xa5, 0x00, 0xe5, 0xf5, 0xa5, 0x80, 0x31, 0xa8, 0x11, 0xe9, 0x35, 0xa5, - 0x00, 0xef, 0xcd, 0xa5, 0x80, 0x04, 0xf5, 0xa6, 0xa5, 0x40, 0xef, 0x81, - 0xa5, 0x40, 0xe1, 0x5d, 0xa5, 0x00, 0xe5, 0xf6, 0xa5, 0x80, 0x11, 0xe9, - 0x36, 0xa5, 0x00, 0xef, 0xce, 0xa5, 0x80, 0x04, 0xf5, 0xa7, 0xa5, 0x40, - 0xef, 0x82, 0xa5, 0x40, 0xe5, 0x11, 0xa5, 0x40, 0xe5, 0x10, 0xa5, 0x40, - 0xe5, 0x14, 0xa5, 0x40, 0xe1, 0x66, 0xa5, 0x00, 0xe5, 0xff, 0xa5, 0x80, - 0x11, 0xe9, 0x3f, 0xa5, 0x00, 0xef, 0xd7, 0xa5, 0x80, 0x04, 0xf5, 0xb0, - 0xa5, 0x40, 0xef, 0x8b, 0xa5, 0x40, 0xe5, 0x1a, 0xa5, 0x40, 0xe1, 0x52, - 0xa5, 0x00, 0xe5, 0xea, 0xa5, 0x80, 0x31, 0xa8, 0x11, 0xe9, 0x2c, 0xa5, - 0x00, 0xef, 0xc3, 0xa5, 0x80, 0x04, 0xf5, 0x9d, 0xa5, 0x40, 0xef, 0x78, - 0xa5, 0x40, 0xe1, 0x51, 0xa5, 0x00, 0xe5, 0xe9, 0xa5, 0x80, 0x11, 0xe9, - 0x2b, 0xa5, 0x00, 0xef, 0xc2, 0xa5, 0x80, 0x04, 0xf5, 0x9c, 0xa5, 0x40, - 0xef, 0x77, 0xa5, 0x40, 0xe5, 0x06, 0xa5, 0x40, 0xe5, 0x07, 0xa5, 0x40, - 0xee, 0x4a, 0xa5, 0x40, 0x45, 0x12, 0x0b, 0x28, 0xa6, 0x00, 0xa6, 0x2e, - 0x44, 0xea, 0x2a, 0x29, 0xa6, 0x00, 0x43, 0x0e, 0x0b, 0x21, 0xa6, 0x00, - 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x20, 0xa6, 0x40, 0x44, 0x25, - 0x01, 0x23, 0xa6, 0x00, 0x42, 0x15, 0x02, 0x22, 0xa6, 0x40, 0x44, 0xe5, - 0x1d, 0x27, 0xa6, 0x00, 0x42, 0x1c, 0x26, 0x26, 0xa6, 0x40, 0x43, 0xd2, - 0x05, 0x25, 0xa6, 0x00, 0x43, 0xf6, 0x06, 0x24, 0xa6, 0x40, 0x08, 0x71, - 0xc6, 0xd6, 0x0d, 0x47, 0x66, 0x61, 0x02, 0x26, 0x80, 0xbf, 0x0d, 0xae, - 0xc9, 0x0c, 0xb0, 0x0a, 0x45, 0x21, 0xe1, 0x45, 0x26, 0x00, 0xf3, 0x1f, - 0x00, 0x40, 0x80, 0xad, 0x0b, 0x8d, 0xb4, 0x0a, 0x04, 0x6f, 0x02, 0xff, - 0x03, 0x4e, 0x4c, 0x7c, 0x43, 0xf6, 0x01, 0x06, 0xa9, 0x01, 0x01, 0xff, - 0xa1, 0xff, 0x02, 0x06, 0x0c, 0x03, 0xee, 0x02, 0x50, 0x8d, 0x61, 0x3d, - 0xf8, 0x01, 0xa4, 0xd9, 0x02, 0x51, 0x03, 0x5a, 0x35, 0xf8, 0x01, 0xa8, - 0xfa, 0x01, 0x4d, 0x79, 0x87, 0xc8, 0x21, 0x00, 0x4f, 0x13, 0x72, 0xf0, - 0x27, 0x00, 0x46, 0xc4, 0xdf, 0x6d, 0xf6, 0x01, 0xb3, 0xd9, 0x01, 0xb4, - 0x47, 0x06, 0xad, 0x02, 0x01, 0xff, 0x45, 0xce, 0x00, 0xe7, 0x21, 0x80, - 0x0d, 0x4c, 0x44, 0x8e, 0xee, 0x21, 0xc0, 0x00, 0x4c, 0x68, 0x8b, 0xef, - 0x21, 0x40, 0x80, 0x01, 0xff, 0x48, 0x78, 0xb4, 0xea, 0x21, 0x80, 0x1e, - 0x4b, 0x69, 0x8b, 0xeb, 0x21, 0x80, 0x06, 0x59, 0xe3, 0x1e, 0x95, 0xf8, - 0x41, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4e, 0x0b, 0x00, 0xec, 0x21, 0x00, - 0x4c, 0x32, 0x00, 0xed, 0x21, 0x40, 0x54, 0x07, 0x40, 0xb8, 0x2b, 0x40, - 0x02, 0x0d, 0x00, 0x1c, 0x02, 0x15, 0x02, 0x01, 0xff, 0x4d, 0x9a, 0x7f, - 0x9f, 0x21, 0x00, 0x0e, 0x1b, 0x06, 0x01, 0xff, 0x51, 0x36, 0x5a, 0x49, - 0x29, 0x00, 0x58, 0x29, 0x06, 0xed, 0x2b, 0x40, 0x05, 0x04, 0x02, 0x06, - 0x49, 0x19, 0x72, 0x0a, 0x29, 0x40, 0x4a, 0xe0, 0x01, 0x91, 0xf8, 0x01, - 0x08, 0x09, 0x02, 0x01, 0xff, 0x45, 0xce, 0x00, 0x61, 0x2b, 0x80, 0x0c, - 0x4c, 0xd8, 0x8d, 0x6b, 0x2b, 0x00, 0x4d, 0x79, 0x87, 0x85, 0x2b, 0x40, - 0x80, 0x01, 0xff, 0x6c, 0xea, 0x01, 0x81, 0x2b, 0x00, 0x46, 0xd1, 0x14, - 0x71, 0x2b, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4a, 0x74, 0xa8, 0x29, - 0xf8, 0x01, 0x58, 0x41, 0x28, 0x7b, 0x2b, 0x00, 0x4b, 0x72, 0x68, 0x2d, - 0xf8, 0x01, 0x09, 0xd0, 0xbb, 0x12, 0x4c, 0x04, 0x92, 0x25, 0xf8, 0x01, - 0x4c, 0x70, 0x92, 0x21, 0xf8, 0x01, 0x50, 0x6d, 0x68, 0x31, 0xf8, 0x41, - 0x49, 0xea, 0x01, 0xa2, 0x2b, 0x00, 0x4a, 0xb3, 0x02, 0xa3, 0x2b, 0x40, - 0x4f, 0xee, 0x66, 0x51, 0xf8, 0x01, 0x4c, 0x08, 0x94, 0x39, 0xf8, 0x41, - 0x11, 0x91, 0x05, 0x11, 0x05, 0x6e, 0x15, 0x01, 0xff, 0x45, 0xce, 0x00, - 0x45, 0xf8, 0x01, 0x50, 0x8d, 0x61, 0x41, 0xf8, 0x41, 0x04, 0xc3, 0x00, - 0x19, 0x05, 0xc8, 0x00, 0x01, 0xff, 0x80, 0x06, 0x45, 0xa9, 0x01, 0xbe, - 0x21, 0x40, 0x48, 0x78, 0xb4, 0x5c, 0x29, 0x00, 0x46, 0xd1, 0x14, 0x54, - 0x29, 0x40, 0x80, 0x06, 0x45, 0xa9, 0x01, 0xbf, 0x21, 0x40, 0x07, 0x92, - 0x0a, 0x0c, 0x48, 0x78, 0xb4, 0x60, 0x29, 0x00, 0x46, 0xd1, 0x14, 0x58, - 0x29, 0x40, 0x61, 0xc9, 0x0d, 0x6e, 0x29, 0x00, 0x5f, 0x08, 0x12, 0x63, - 0x29, 0x40, 0x4b, 0xd9, 0x8d, 0xe1, 0x21, 0x00, 0x4b, 0x45, 0x8e, 0xd1, - 0x21, 0x40, 0x45, 0xce, 0x00, 0x06, 0x2b, 0x00, 0x53, 0xda, 0x48, 0x89, - 0x2b, 0x40, 0x45, 0x18, 0xe9, 0x15, 0x2e, 0x00, 0x44, 0xcf, 0x00, 0x91, - 0x21, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x5a, 0x4a, 0x1f, 0xb8, 0xfb, 0x01, - 0x48, 0x78, 0xb4, 0xa5, 0x21, 0x00, 0x5c, 0x6a, 0x18, 0xc5, 0x21, 0x00, - 0x46, 0xd1, 0x14, 0x12, 0x29, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4d, - 0x4b, 0x82, 0xde, 0x21, 0x00, 0x55, 0xd5, 0x01, 0x15, 0xf8, 0x01, 0x51, - 0x47, 0x05, 0x09, 0x29, 0x00, 0x58, 0x91, 0x29, 0x09, 0xf8, 0x01, 0x59, - 0xfe, 0x24, 0x05, 0xf8, 0x01, 0x4c, 0xe8, 0x92, 0x99, 0xf8, 0x01, 0x06, - 0x5d, 0x07, 0x11, 0x04, 0x49, 0x0c, 0x01, 0xff, 0x49, 0xea, 0x01, 0xb0, - 0x21, 0x00, 0x4a, 0xb3, 0x02, 0xb1, 0x21, 0x40, 0x55, 0xd5, 0x01, 0x11, - 0xf8, 0x01, 0x52, 0x2e, 0x06, 0x01, 0xf8, 0x41, 0x04, 0x1a, 0x00, 0x8c, - 0x06, 0x4e, 0x48, 0x76, 0x01, 0x27, 0x00, 0x07, 0x73, 0x02, 0xda, 0x05, - 0x52, 0xb0, 0x51, 0x84, 0xfb, 0x01, 0x05, 0x22, 0x00, 0x8e, 0x05, 0x05, - 0xc3, 0x00, 0x8c, 0x03, 0x07, 0x7d, 0x02, 0xd6, 0x02, 0x04, 0x0e, 0x0b, - 0xc5, 0x02, 0x06, 0xc8, 0x00, 0x30, 0x53, 0x02, 0x4d, 0x86, 0xfb, 0x01, - 0xb4, 0x01, 0xff, 0x05, 0x25, 0x01, 0x06, 0x5b, 0x51, 0x1d, 0x6d, 0xfb, - 0x41, 0x4d, 0x08, 0x4d, 0x83, 0xfb, 0x01, 0x09, 0x2a, 0x01, 0x01, 0xff, - 0x45, 0x33, 0x01, 0x85, 0xfb, 0x01, 0x56, 0x52, 0x35, 0xa6, 0xce, 0x01, - 0x57, 0xf7, 0x30, 0xad, 0xce, 0x41, 0x0f, 0x74, 0x6b, 0xac, 0x01, 0x5a, - 0xe6, 0x1f, 0x50, 0x27, 0x00, 0xaf, 0x97, 0x01, 0x46, 0x34, 0xdf, 0x10, - 0x27, 0x00, 0x03, 0x7c, 0x00, 0x2f, 0x0f, 0xa4, 0x02, 0x1f, 0xb4, 0x01, - 0xff, 0x51, 0xc5, 0x55, 0x99, 0xfb, 0x01, 0x05, 0x1a, 0x01, 0x06, 0x4d, - 0x9d, 0x7d, 0x33, 0xcc, 0x41, 0x42, 0x68, 0x00, 0xf9, 0x25, 0x00, 0x51, - 0xa9, 0x5e, 0x9d, 0xfb, 0x41, 0x46, 0x12, 0x03, 0x3f, 0xf5, 0x01, 0x46, - 0xd6, 0x05, 0x52, 0x27, 0x40, 0x06, 0x7c, 0x0d, 0x06, 0x4b, 0x97, 0x4c, - 0x36, 0xcc, 0x41, 0xa3, 0x22, 0x0a, 0x0c, 0x08, 0x12, 0x4d, 0x00, 0x86, - 0xb7, 0xcc, 0x01, 0x4f, 0x5d, 0x73, 0xd3, 0xcc, 0x01, 0x4a, 0xca, 0xb1, - 0xb3, 0xcc, 0x41, 0x4b, 0x95, 0x23, 0xa9, 0xcc, 0x01, 0x49, 0x80, 0xbd, - 0xa7, 0xcc, 0x41, 0x05, 0x60, 0x88, 0x06, 0x4b, 0xd0, 0x9d, 0xdd, 0x25, - 0x40, 0x46, 0x4e, 0xda, 0xc7, 0xcc, 0x01, 0xab, 0x12, 0x44, 0x21, 0xf2, - 0xcf, 0xcc, 0x01, 0x45, 0x73, 0xbe, 0xbf, 0xcc, 0x01, 0x44, 0x81, 0xf2, - 0xc3, 0xcc, 0x41, 0x43, 0xa1, 0x01, 0xbb, 0xcc, 0x01, 0x45, 0x4e, 0x09, - 0xcb, 0xcc, 0x41, 0x52, 0x18, 0x26, 0x93, 0xce, 0x01, 0x62, 0x00, 0x0d, - 0xb1, 0x23, 0x40, 0x1b, 0x94, 0x1c, 0x50, 0x06, 0x6d, 0x02, 0x01, 0xff, - 0x0a, 0x73, 0x02, 0x31, 0x08, 0x84, 0x02, 0x17, 0x15, 0x7d, 0x02, 0x01, - 0xff, 0x46, 0x73, 0x02, 0x54, 0xfb, 0x01, 0x4c, 0x58, 0x0f, 0x67, 0xfb, - 0x01, 0x45, 0xc8, 0x00, 0x55, 0xfb, 0x41, 0x06, 0x13, 0x01, 0x06, 0x52, - 0x42, 0x56, 0x63, 0xfb, 0x41, 0x46, 0x73, 0x02, 0x56, 0xfb, 0x01, 0x4c, - 0x58, 0x0f, 0x65, 0xfb, 0x41, 0x06, 0x13, 0x01, 0x06, 0x52, 0x42, 0x56, - 0x62, 0xfb, 0x41, 0x4c, 0x58, 0x0f, 0x64, 0xfb, 0x01, 0x45, 0xc8, 0x00, - 0x66, 0xfb, 0x41, 0x46, 0x73, 0x02, 0x52, 0xfb, 0x01, 0x45, 0xc8, 0x00, - 0x53, 0xfb, 0x41, 0x4c, 0x12, 0x0b, 0x94, 0x25, 0x00, 0x4d, 0x5f, 0x1d, - 0x82, 0xfb, 0x41, 0x07, 0x73, 0x02, 0x21, 0x05, 0xc3, 0x00, 0x11, 0x06, - 0xc8, 0x00, 0x01, 0xff, 0x53, 0x17, 0x26, 0x97, 0xce, 0x01, 0x4e, 0x9c, - 0x7d, 0x37, 0xcc, 0x41, 0x53, 0x17, 0x26, 0x94, 0xce, 0x01, 0x4e, 0x9c, - 0x7d, 0x34, 0xcc, 0x41, 0x58, 0xc1, 0x29, 0x95, 0xce, 0x01, 0x59, 0x11, - 0x26, 0x96, 0xce, 0x41, 0x0f, 0x74, 0x6b, 0x96, 0x01, 0x4f, 0xdd, 0x6b, - 0xd4, 0x27, 0x00, 0xaf, 0x81, 0x01, 0x03, 0x7c, 0x00, 0x1f, 0xb4, 0x01, - 0xff, 0x52, 0xae, 0x4d, 0x98, 0xfb, 0x01, 0x05, 0x1a, 0x01, 0x06, 0x4d, - 0x9d, 0x7d, 0x30, 0xcc, 0x41, 0x42, 0x68, 0x00, 0xf8, 0x25, 0x00, 0x51, - 0xa9, 0x5e, 0x9c, 0xfb, 0x41, 0x06, 0x7c, 0x0d, 0x06, 0x4b, 0x97, 0x4c, - 0x35, 0xcc, 0x41, 0xa3, 0x22, 0x0a, 0x0c, 0x08, 0x12, 0x4d, 0x00, 0x86, - 0xb6, 0xcc, 0x01, 0x4f, 0x5d, 0x73, 0xd2, 0xcc, 0x01, 0x4a, 0xca, 0xb1, - 0xb2, 0xcc, 0x41, 0x4b, 0x95, 0x23, 0xa8, 0xcc, 0x01, 0x49, 0x80, 0xbd, - 0xa6, 0xcc, 0x41, 0x05, 0x60, 0x88, 0x06, 0x4b, 0xd0, 0x9d, 0xdc, 0x25, - 0x40, 0x46, 0x4e, 0xda, 0xc6, 0xcc, 0x01, 0xab, 0x12, 0x44, 0x21, 0xf2, - 0xce, 0xcc, 0x01, 0x45, 0x73, 0xbe, 0xbe, 0xcc, 0x01, 0x44, 0x81, 0xf2, - 0xc2, 0xcc, 0x41, 0x43, 0xa1, 0x01, 0xba, 0xcc, 0x01, 0x45, 0x4e, 0x09, - 0xca, 0xcc, 0x41, 0x52, 0x18, 0x26, 0x90, 0xce, 0x01, 0x63, 0x64, 0x0b, - 0xb0, 0x23, 0x40, 0x06, 0x13, 0x01, 0x11, 0x1b, 0x0e, 0x1e, 0x01, 0xff, - 0x46, 0x73, 0x02, 0x57, 0xfb, 0x01, 0x45, 0xc8, 0x00, 0x58, 0xfb, 0x41, - 0x0a, 0x73, 0x02, 0x32, 0x08, 0x84, 0x02, 0x17, 0x15, 0x14, 0x1e, 0x01, - 0xff, 0x46, 0x73, 0x02, 0x59, 0xfb, 0x01, 0x4c, 0x58, 0x0f, 0x5c, 0xfb, - 0x01, 0x45, 0xc8, 0x00, 0x5a, 0xfb, 0x41, 0x52, 0x96, 0x53, 0x5e, 0xfb, - 0x01, 0x06, 0x6d, 0x02, 0x01, 0xff, 0x46, 0x73, 0x02, 0x5b, 0xfb, 0x01, - 0x4c, 0x58, 0x0f, 0x60, 0xfb, 0x41, 0x52, 0x96, 0x53, 0x5d, 0xfb, 0x01, - 0x06, 0x6d, 0x02, 0x01, 0xff, 0x4c, 0x58, 0x0f, 0x5f, 0xfb, 0x01, 0x45, - 0xc8, 0x00, 0x61, 0xfb, 0x41, 0x45, 0x33, 0x01, 0x80, 0x25, 0x80, 0x34, - 0x46, 0x12, 0x03, 0xe0, 0x25, 0x00, 0x52, 0x2e, 0x52, 0x03, 0xce, 0x01, - 0x08, 0x3c, 0x04, 0x18, 0x56, 0x52, 0x35, 0xa7, 0xce, 0x01, 0x4c, 0x44, - 0x04, 0x8e, 0xfb, 0x01, 0x57, 0xf7, 0x30, 0xac, 0xce, 0x01, 0x63, 0xcd, - 0x0b, 0x14, 0xce, 0x41, 0x61, 0x4d, 0x0e, 0x92, 0xfb, 0x01, 0x4c, 0x32, - 0x11, 0xda, 0x25, 0x40, 0x64, 0x9b, 0x08, 0x91, 0xfb, 0x41, 0x05, 0xc3, - 0x00, 0x17, 0x51, 0x5b, 0x1d, 0xe4, 0xfb, 0x01, 0x06, 0xc8, 0x00, 0x01, - 0xff, 0x53, 0x17, 0x26, 0x92, 0xce, 0x01, 0x4e, 0x9c, 0x7d, 0x32, 0xcc, - 0x41, 0x53, 0x17, 0x26, 0x91, 0xce, 0x01, 0x4e, 0x9c, 0x7d, 0x31, 0xcc, - 0x41, 0xac, 0x06, 0x6f, 0x09, 0x01, 0x68, 0xfb, 0x41, 0x6d, 0x65, 0x01, - 0x6a, 0xfb, 0x01, 0x05, 0x14, 0x01, 0x01, 0xff, 0x50, 0x0e, 0x0b, 0x80, - 0xfb, 0x01, 0x55, 0xbd, 0x3e, 0x9a, 0xfb, 0x41, 0x17, 0x8a, 0x2e, 0x66, - 0x09, 0x9c, 0x01, 0x01, 0xff, 0xa1, 0x53, 0x4b, 0xcb, 0x9b, 0x79, 0xcc, - 0x01, 0x44, 0xf5, 0xef, 0xfb, 0xcd, 0x01, 0x47, 0x6e, 0xd1, 0x00, 0xcc, - 0x01, 0x51, 0x56, 0x5c, 0xe6, 0xf6, 0x01, 0xb2, 0x21, 0x06, 0x5d, 0x07, - 0x11, 0x0e, 0x80, 0x7d, 0x01, 0xff, 0x4f, 0x7f, 0x6f, 0xed, 0x25, 0x00, - 0x50, 0xbd, 0x66, 0xee, 0x25, 0x40, 0x48, 0x2c, 0x34, 0xe8, 0xf6, 0x01, - 0x4c, 0xf5, 0x5b, 0x3c, 0xf5, 0x41, 0x49, 0xbb, 0xb5, 0x98, 0xcc, 0x01, - 0x4b, 0x90, 0x06, 0x3a, 0xf5, 0x01, 0x44, 0xe6, 0xac, 0x66, 0xcc, 0x01, - 0x4a, 0xbe, 0xae, 0x57, 0xcc, 0x41, 0x47, 0x2d, 0x34, 0xe7, 0xf6, 0x01, - 0x4a, 0x24, 0xb2, 0x61, 0xcc, 0x41, 0x4c, 0x90, 0x8d, 0x75, 0xcc, 0x01, - 0x4a, 0x57, 0x29, 0x71, 0xcc, 0x41, 0x05, 0xce, 0x00, 0x6d, 0x05, 0x9d, - 0x05, 0x48, 0x05, 0x9e, 0x14, 0x19, 0x49, 0x1b, 0xb9, 0x7e, 0x29, 0x00, - 0x57, 0xc9, 0x30, 0xf0, 0x22, 0x00, 0x44, 0x10, 0x39, 0xa5, 0x22, 0xc0, - 0x00, 0x52, 0xa6, 0x4f, 0xdf, 0x27, 0x40, 0x45, 0xce, 0x00, 0x95, 0x21, - 0x80, 0x1e, 0x4b, 0xc6, 0x99, 0x0d, 0x2b, 0x00, 0x4c, 0x44, 0x8e, 0xd5, - 0x21, 0x00, 0x50, 0xed, 0x66, 0x59, 0xf8, 0x01, 0x55, 0x01, 0x02, 0x65, - 0x2b, 0x00, 0x4b, 0x49, 0x10, 0xf3, 0x21, 0x40, 0x4a, 0x6c, 0xa6, 0xa8, - 0x21, 0x40, 0x0f, 0x61, 0x6f, 0x11, 0x10, 0x9d, 0x66, 0x01, 0xff, 0x4c, - 0x14, 0x91, 0x4c, 0x29, 0x00, 0x4d, 0xe1, 0x87, 0x4f, 0x29, 0x40, 0x4c, - 0x14, 0x91, 0x51, 0x29, 0x00, 0x4d, 0xe1, 0x87, 0x4d, 0x29, 0x40, 0x4f, - 0xb2, 0x69, 0xbd, 0x29, 0x00, 0x44, 0xe6, 0x01, 0x03, 0x23, 0xc0, 0x00, - 0x80, 0x01, 0xff, 0x5b, 0x78, 0x1a, 0x24, 0x23, 0x00, 0x52, 0x85, 0x47, - 0xb9, 0x2b, 0x40, 0x4b, 0x2c, 0x99, 0x12, 0xf6, 0x01, 0x4e, 0x72, 0x76, - 0xd1, 0x2b, 0x00, 0xa4, 0x59, 0xa9, 0x06, 0x5a, 0x04, 0x21, 0xaf, 0x26, - 0x40, 0x49, 0x86, 0xb7, 0x84, 0xf9, 0x01, 0x42, 0x10, 0x00, 0x2a, 0x22, - 0x80, 0x14, 0xb4, 0x06, 0x57, 0x32, 0x25, 0x72, 0x26, 0x40, 0x4a, 0xd9, - 0x20, 0x1f, 0x00, 0x00, 0x49, 0x44, 0x77, 0xfa, 0x2b, 0x40, 0x80, 0x01, - 0xff, 0x06, 0x5c, 0x00, 0x1d, 0x5c, 0x36, 0x17, 0x4a, 0x2a, 0x00, 0x05, - 0x51, 0x00, 0x01, 0xff, 0x4a, 0x56, 0xad, 0x45, 0x2a, 0x00, 0x4a, 0x88, - 0x98, 0x41, 0x2a, 0x00, 0x47, 0xfb, 0x7f, 0x42, 0x2a, 0x40, 0x56, 0x16, - 0x33, 0x48, 0x2a, 0x00, 0x4c, 0xa9, 0x0a, 0x46, 0x2a, 0x40, 0x45, 0x34, - 0xcc, 0x3f, 0x20, 0x00, 0x48, 0x64, 0xb0, 0x8c, 0x23, 0x40, 0x80, 0x01, - 0xff, 0x49, 0x2f, 0xbd, 0xf1, 0x26, 0x00, 0x4f, 0xe3, 0x74, 0x14, 0x26, - 0x40, 0x07, 0xec, 0x05, 0x06, 0x4c, 0x56, 0x25, 0x9f, 0x03, 0x41, 0xa1, - 0xb3, 0x01, 0x44, 0xbb, 0x99, 0x81, 0x03, 0x01, 0xa4, 0x9e, 0x01, 0xa7, - 0x8f, 0x01, 0x42, 0x0b, 0x00, 0x85, 0x03, 0x81, 0x81, 0x01, 0xe9, 0x9b, - 0x03, 0x01, 0xab, 0x6f, 0x45, 0x37, 0xe8, 0x8d, 0x03, 0x01, 0x43, 0xb4, - 0x05, 0x8e, 0x03, 0x01, 0x43, 0xde, 0x22, 0x90, 0x03, 0x01, 0x42, 0x07, - 0x0c, 0x94, 0x03, 0x01, 0x44, 0x59, 0xf2, 0x96, 0x03, 0x01, 0x45, 0x53, - 0xea, 0x97, 0x03, 0x01, 0xb3, 0x2f, 0xb4, 0x1d, 0xf5, 0x9c, 0x03, 0x01, - 0x42, 0x15, 0x02, 0x86, 0x03, 0x01, 0x43, 0xa8, 0x52, 0x8a, 0x03, 0x01, - 0xba, 0x01, 0xff, 0x43, 0x94, 0x0f, 0x87, 0x03, 0x01, 0xf5, 0x91, 0x03, - 0x41, 0x42, 0xed, 0x05, 0x89, 0x03, 0x01, 0x45, 0x01, 0xe7, 0x98, 0x03, - 0x01, 0xef, 0x9a, 0x03, 0x41, 0xa1, 0x0c, 0x43, 0x7a, 0x16, 0x8c, 0x03, - 0x01, 0x42, 0x6f, 0x00, 0x9d, 0x03, 0x41, 0x42, 0x04, 0x00, 0x95, 0x03, - 0x01, 0x43, 0x29, 0x53, 0x92, 0x03, 0x41, 0x42, 0x44, 0x14, 0x8b, 0x03, - 0x01, 0x42, 0x22, 0x00, 0x83, 0x03, 0x41, 0x42, 0x12, 0x00, 0x88, 0x03, - 0x41, 0x44, 0x1d, 0xef, 0x82, 0x03, 0x01, 0x44, 0x87, 0x9c, 0x99, 0x03, - 0x41, 0x44, 0x58, 0xd6, 0x84, 0x03, 0x01, 0x43, 0x22, 0x00, 0x8f, 0x03, - 0x41, 0x42, 0x9e, 0x01, 0x93, 0x03, 0x01, 0x43, 0x09, 0x7b, 0x80, 0x03, - 0x41, 0x8d, 0xfb, 0x7b, 0xa1, 0xa4, 0x3b, 0xa5, 0xb9, 0x30, 0xa8, 0xa0, - 0x26, 0xa9, 0x83, 0x13, 0xaf, 0xd7, 0x09, 0xb2, 0xd4, 0x06, 0xb5, 0x88, - 0x01, 0xb7, 0x01, 0xff, 0x57, 0x02, 0x2c, 0x39, 0x27, 0x00, 0x57, 0x59, - 0x2f, 0x00, 0xf5, 0x01, 0xaf, 0x01, 0xff, 0x80, 0x06, 0x48, 0xe1, 0xc2, - 0x3a, 0x2e, 0x40, 0x5c, 0x1a, 0x17, 0x51, 0x20, 0x00, 0x4c, 0x18, 0x8d, - 0xb0, 0xf5, 0x01, 0x58, 0xe1, 0x27, 0x75, 0x2a, 0x00, 0x03, 0x23, 0x0a, - 0x44, 0x46, 0xe4, 0x86, 0x95, 0xf4, 0x01, 0x15, 0x1d, 0x3c, 0x2e, 0x4e, - 0x3c, 0x79, 0xc9, 0x29, 0x00, 0x08, 0x2d, 0x22, 0x18, 0x51, 0x05, 0x4f, - 0x6c, 0xf4, 0x01, 0x5a, 0xee, 0x21, 0x88, 0xcc, 0x01, 0x4e, 0x84, 0x7c, - 0xea, 0xf5, 0x01, 0x53, 0x03, 0x4f, 0x6d, 0xf4, 0x41, 0x4c, 0x58, 0x8c, - 0x07, 0x2a, 0x00, 0x4b, 0xfe, 0xa0, 0x08, 0x2a, 0x40, 0x43, 0x1a, 0x00, - 0x55, 0x2a, 0x00, 0x42, 0x0c, 0x00, 0x56, 0x2a, 0x40, 0x80, 0x06, 0x5a, - 0xf8, 0x0b, 0x2a, 0x2e, 0x40, 0x46, 0xb2, 0x7d, 0x25, 0x20, 0x00, 0x4b, - 0x07, 0x0c, 0x5a, 0x20, 0x40, 0x49, 0x63, 0xb9, 0xae, 0x20, 0x00, 0xac, - 0xc4, 0x01, 0x4b, 0x72, 0x9f, 0x43, 0xf9, 0x01, 0xb2, 0x01, 0xff, 0xab, - 0xac, 0x01, 0x04, 0x73, 0x07, 0x06, 0x43, 0xbd, 0x01, 0x22, 0xf4, 0x41, - 0xa1, 0x93, 0x01, 0x06, 0x0c, 0x03, 0x82, 0x01, 0xa3, 0x74, 0xa4, 0x5b, - 0x57, 0xa1, 0x2e, 0x29, 0x21, 0x00, 0x02, 0xb4, 0x01, 0x3b, 0x4c, 0x3c, - 0x93, 0x8f, 0xf5, 0x01, 0xb3, 0x06, 0x51, 0x86, 0x5f, 0xc9, 0x26, 0x40, - 0x12, 0x09, 0x48, 0x1d, 0x48, 0xe1, 0x59, 0x35, 0x2e, 0x00, 0x46, 0x14, - 0xde, 0x4e, 0x21, 0x00, 0x05, 0xa4, 0x20, 0x01, 0xff, 0x52, 0x32, 0x51, - 0x57, 0xf6, 0x01, 0x52, 0x8a, 0x56, 0x55, 0xf6, 0x41, 0xe7, 0x41, 0x21, - 0x00, 0xec, 0x42, 0x21, 0x00, 0xf9, 0x44, 0x21, 0x40, 0x04, 0xb6, 0x01, - 0x06, 0x46, 0x60, 0x33, 0x19, 0x23, 0x40, 0x52, 0x32, 0x51, 0x56, 0xf6, - 0x01, 0x52, 0x8a, 0x56, 0x54, 0xf6, 0x41, 0x45, 0xf7, 0xda, 0x38, 0x2e, - 0x00, 0x06, 0xf3, 0x15, 0x01, 0xff, 0x44, 0x25, 0x01, 0x8b, 0x21, 0x00, - 0x42, 0x15, 0x02, 0x8a, 0x21, 0x40, 0x48, 0x89, 0xc3, 0x32, 0x21, 0x00, - 0x44, 0x14, 0x05, 0x32, 0x2e, 0x40, 0x48, 0x01, 0xca, 0xc2, 0x2b, 0x00, - 0x4b, 0x8c, 0x5f, 0xca, 0x26, 0x40, 0x48, 0x2e, 0x3e, 0x4b, 0x21, 0x00, - 0x44, 0x05, 0x02, 0xa2, 0x29, 0x40, 0x42, 0xe2, 0x1c, 0x83, 0xf9, 0x01, - 0x4d, 0x94, 0x84, 0xba, 0x20, 0x40, 0x42, 0xba, 0x04, 0x37, 0xf3, 0x01, - 0x0b, 0x2c, 0xa4, 0x01, 0xff, 0x4e, 0x1e, 0x76, 0xc9, 0x13, 0x01, 0x49, - 0x7d, 0xb7, 0xd0, 0x13, 0x01, 0xa4, 0xd6, 0x03, 0x4f, 0x90, 0x6d, 0xd2, - 0x13, 0x01, 0x07, 0xec, 0x05, 0xa2, 0x01, 0x45, 0x76, 0xea, 0xd1, 0x13, - 0x01, 0x05, 0x5a, 0x03, 0x5b, 0xb6, 0x01, 0xff, 0x0a, 0xdc, 0xa9, 0x48, - 0x0a, 0x56, 0x77, 0x01, 0xff, 0xa1, 0x35, 0x42, 0x27, 0x01, 0xc2, 0x13, - 0x01, 0xe9, 0xb9, 0x13, 0x81, 0x26, 0x42, 0xcd, 0x02, 0xc7, 0x13, 0x01, - 0xf5, 0xbb, 0x13, 0x81, 0x17, 0x08, 0x43, 0xc1, 0x01, 0xff, 0xec, 0xbf, - 0x13, 0x81, 0x09, 0xf2, 0xbd, 0x13, 0xc1, 0x00, 0xf2, 0xbe, 0x13, 0x41, - 0xec, 0xc0, 0x13, 0x41, 0xf5, 0xbc, 0x13, 0x41, 0xe9, 0xba, 0x13, 0x41, - 0xe1, 0xb8, 0x13, 0x01, 0xe9, 0xc5, 0x13, 0x01, 0xf5, 0xc8, 0x13, 0x41, - 0x48, 0xde, 0x7c, 0xe2, 0x13, 0x01, 0x47, 0xf4, 0x0a, 0xe1, 0x13, 0x41, - 0xa1, 0x2f, 0x50, 0x3d, 0x61, 0xca, 0x13, 0x01, 0x4d, 0x57, 0x85, 0xcf, - 0x13, 0x01, 0x4b, 0xc7, 0xa0, 0xd7, 0x13, 0x01, 0x45, 0x12, 0xea, 0xd3, - 0x13, 0x01, 0x4e, 0x3e, 0x7c, 0xd8, 0x13, 0x01, 0x02, 0x02, 0x00, 0x01, - 0xff, 0x44, 0xe7, 0x23, 0xce, 0x13, 0x01, 0x45, 0xf3, 0x4b, 0xcd, 0x13, - 0x41, 0x47, 0x3d, 0x16, 0xcc, 0x13, 0x01, 0x47, 0xc4, 0x88, 0xb7, 0x13, - 0x41, 0xe1, 0x80, 0x13, 0x81, 0x97, 0x02, 0xa2, 0x8a, 0x02, 0xa3, 0xfd, - 0x01, 0xa4, 0xe4, 0x01, 0x42, 0x27, 0x01, 0x8b, 0x13, 0x01, 0xa7, 0xd1, - 0x01, 0x42, 0x22, 0x00, 0xb2, 0x13, 0x01, 0xe9, 0x82, 0x13, 0x81, 0xc1, - 0x01, 0xaa, 0xb4, 0x01, 0xab, 0xa7, 0x01, 0xac, 0x93, 0x01, 0x42, 0x6c, - 0x00, 0xaa, 0x13, 0x01, 0xae, 0x75, 0x42, 0xcd, 0x02, 0x90, 0x13, 0x01, - 0xb0, 0x63, 0xb2, 0x57, 0xb3, 0x45, 0xb4, 0x2c, 0xf5, 0x84, 0x13, 0x81, - 0x23, 0xb6, 0x06, 0x42, 0xbe, 0x22, 0xab, 0x13, 0x41, 0xe1, 0xae, 0x13, - 0x01, 0x07, 0x44, 0xc1, 0x01, 0xff, 0xec, 0x88, 0x13, 0x81, 0x09, 0xf2, - 0x86, 0x13, 0xc1, 0x00, 0xf2, 0x87, 0x13, 0x41, 0xec, 0x89, 0x13, 0x41, - 0xf5, 0x85, 0x13, 0x41, 0xe1, 0xa1, 0x13, 0x01, 0x42, 0x22, 0x00, 0xa2, - 0x13, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x9c, 0x13, 0x01, 0x42, 0x22, 0x00, - 0x9d, 0x13, 0x41, 0xe1, 0xb1, 0x13, 0x01, 0x42, 0x22, 0x00, 0xaf, 0x13, - 0x01, 0x42, 0x40, 0x06, 0xb0, 0x13, 0x41, 0xe1, 0xac, 0x13, 0x01, 0x42, - 0x71, 0x00, 0xb4, 0x13, 0x41, 0xe1, 0xa6, 0x13, 0x01, 0x42, 0x22, 0x00, - 0xa7, 0x13, 0x41, 0xe1, 0xa5, 0x13, 0x01, 0x42, 0x24, 0x02, 0x96, 0x13, - 0x01, 0x42, 0x2a, 0x05, 0xa0, 0x13, 0x01, 0x42, 0xbe, 0x22, 0x9b, 0x13, - 0x41, 0xe1, 0xad, 0x13, 0x01, 0xac, 0x01, 0xff, 0xe1, 0xb3, 0x13, 0x01, - 0x42, 0x74, 0x00, 0xb5, 0x13, 0x41, 0xe1, 0x92, 0x13, 0x01, 0x42, 0x22, - 0x00, 0x93, 0x13, 0x41, 0xe1, 0x99, 0x13, 0x01, 0x42, 0x22, 0x00, 0x9a, - 0x13, 0x41, 0xe9, 0x83, 0x13, 0x41, 0xe1, 0x94, 0x13, 0x01, 0x42, 0x22, - 0x00, 0x95, 0x13, 0x41, 0xe1, 0xa3, 0x13, 0x01, 0xa4, 0x06, 0x42, 0x22, - 0x00, 0xa4, 0x13, 0x41, 0xe1, 0x9e, 0x13, 0x01, 0x42, 0x22, 0x00, 0x9f, - 0x13, 0x41, 0xe1, 0x97, 0x13, 0x01, 0x42, 0x22, 0x00, 0x98, 0x13, 0x41, - 0xe1, 0xa8, 0x13, 0x01, 0x42, 0x22, 0x00, 0xa9, 0x13, 0x41, 0xe1, 0x81, - 0x13, 0x01, 0xe9, 0x8e, 0x13, 0x01, 0xf5, 0x91, 0x13, 0x41, 0x44, 0x75, - 0x20, 0xd4, 0x13, 0x01, 0x4b, 0x2a, 0xa1, 0xd5, 0x13, 0x41, 0xa1, 0xc7, - 0x02, 0xa5, 0xb8, 0x02, 0xa9, 0x43, 0xaf, 0x14, 0xb5, 0x01, 0xff, 0xe5, - 0xa8, 0x22, 0x80, 0x06, 0x44, 0x61, 0xf1, 0xba, 0xf3, 0x41, 0x50, 0x3d, - 0x60, 0xdf, 0x2b, 0x40, 0x42, 0x60, 0x07, 0xcc, 0xf9, 0x81, 0x20, 0x45, - 0x9b, 0xe8, 0x8a, 0xfa, 0x01, 0xb0, 0x01, 0xff, 0x42, 0x05, 0x47, 0xc6, - 0xf3, 0x01, 0x05, 0x36, 0x00, 0x01, 0xff, 0x45, 0xa5, 0xd0, 0x79, 0xf3, - 0x01, 0x44, 0x31, 0x5b, 0x20, 0xf4, 0x41, 0x45, 0x5c, 0xe6, 0x8e, 0xf6, - 0x41, 0x03, 0x1c, 0x01, 0xb1, 0x01, 0x45, 0xaf, 0x3b, 0x5d, 0x20, 0x00, - 0x4b, 0xfa, 0x9a, 0x31, 0xf5, 0x01, 0x09, 0x27, 0x96, 0x6e, 0x04, 0x89, - 0x1d, 0x01, 0xff, 0x4e, 0x80, 0x76, 0xf6, 0x2a, 0x00, 0x46, 0xf6, 0xda, - 0x4b, 0x2e, 0x00, 0x14, 0x68, 0x2a, 0x4d, 0x48, 0xaf, 0x26, 0x2d, 0x22, - 0x00, 0x07, 0x9e, 0xd3, 0x37, 0xb0, 0x29, 0x57, 0x6a, 0x31, 0xfb, 0x2a, - 0x00, 0x45, 0x37, 0x23, 0x4b, 0x22, 0x00, 0x0d, 0x42, 0x01, 0x01, 0xff, - 0x4f, 0x72, 0x31, 0xf4, 0x2a, 0x00, 0x49, 0xf6, 0x38, 0x80, 0x29, 0x00, - 0x4f, 0x56, 0x01, 0xaa, 0x22, 0x00, 0x56, 0x3e, 0x38, 0xf5, 0x2a, 0x40, - 0x43, 0x74, 0x28, 0xfb, 0x29, 0x00, 0x44, 0x07, 0x1b, 0x34, 0x20, 0x40, - 0x4c, 0x87, 0x00, 0xf8, 0x2a, 0x00, 0x49, 0xec, 0x00, 0xf7, 0x2a, 0x40, - 0x56, 0xb0, 0x33, 0x68, 0x2a, 0x00, 0x56, 0xba, 0x37, 0x69, 0x2a, 0x40, - 0x45, 0x59, 0x72, 0x37, 0x26, 0x00, 0x44, 0x58, 0x91, 0x32, 0x26, 0x00, - 0x46, 0x9e, 0x7b, 0x30, 0x26, 0x00, 0x44, 0xf9, 0x2e, 0x31, 0x26, 0x00, - 0x48, 0x1e, 0x35, 0x36, 0x26, 0x00, 0x47, 0xf5, 0x7a, 0x33, 0x26, 0x00, - 0xb7, 0x01, 0xff, 0x44, 0x8a, 0x00, 0x35, 0x26, 0x00, 0x43, 0xe9, 0x06, - 0x34, 0x26, 0x40, 0x02, 0x68, 0x00, 0x17, 0x05, 0x1f, 0x01, 0x01, 0xff, - 0x46, 0xb4, 0x21, 0x23, 0x20, 0x00, 0x4c, 0x04, 0x8f, 0xa9, 0xf6, 0x01, - 0x45, 0x1b, 0x30, 0xd0, 0xf4, 0x41, 0x06, 0x50, 0x00, 0x06, 0x58, 0x9b, - 0x06, 0x9d, 0x27, 0x40, 0x49, 0x56, 0x1e, 0xca, 0x29, 0x00, 0x4f, 0x3b, - 0x19, 0xc6, 0xf6, 0x01, 0x50, 0xfd, 0x66, 0xcd, 0x29, 0x00, 0x48, 0xea, - 0x59, 0xcb, 0x29, 0x40, 0x4b, 0x6e, 0x99, 0x8e, 0xfa, 0x01, 0x48, 0x5e, - 0x19, 0xbc, 0xce, 0x41, 0xa3, 0x28, 0x4c, 0xe4, 0x8d, 0x22, 0x21, 0x00, - 0x42, 0x9e, 0x01, 0x86, 0xf6, 0x01, 0xed, 0x8a, 0xf6, 0x81, 0x11, 0x02, - 0x5f, 0x01, 0x01, 0xff, 0x45, 0x17, 0xea, 0xd7, 0x2b, 0x00, 0x53, 0xb7, - 0x4e, 0xdb, 0x2a, 0x40, 0x44, 0xc9, 0x64, 0x8b, 0xf6, 0x41, 0x45, 0xe7, - 0xe7, 0xb2, 0xf5, 0x01, 0x43, 0xc7, 0x07, 0x9c, 0xf6, 0x41, 0x0c, 0xfc, - 0x8d, 0xf1, 0x06, 0x44, 0xb7, 0x37, 0xbd, 0xf6, 0x01, 0x49, 0x49, 0xbb, - 0xfc, 0xf5, 0x01, 0x0a, 0x74, 0xad, 0xc8, 0x04, 0x44, 0x39, 0x39, 0x45, - 0xf3, 0x01, 0x44, 0xb9, 0x67, 0x45, 0xf4, 0x01, 0xaf, 0xa6, 0x04, 0x02, - 0x20, 0x00, 0x8f, 0x02, 0x17, 0x25, 0x31, 0xbf, 0x01, 0xb4, 0x01, 0xff, - 0x49, 0x03, 0xb6, 0x30, 0x23, 0x00, 0x02, 0x7b, 0x02, 0x01, 0xff, 0x07, - 0xec, 0x05, 0x06, 0x50, 0x1d, 0x67, 0xae, 0xe2, 0x41, 0xe1, 0xad, 0xe2, - 0x81, 0x9d, 0x01, 0xa2, 0x7a, 0x43, 0xe6, 0x17, 0x9a, 0xe2, 0x01, 0x42, - 0xf0, 0x10, 0x93, 0xe2, 0x01, 0xe5, 0xa6, 0xe2, 0x81, 0x65, 0x42, 0x24, - 0x02, 0x95, 0xe2, 0x01, 0x42, 0x22, 0x00, 0x9e, 0xe2, 0x01, 0xe9, 0xa1, - 0xe2, 0x81, 0x50, 0x42, 0x72, 0x19, 0x9d, 0xe2, 0x01, 0x42, 0x1b, 0x02, - 0x94, 0xe2, 0x01, 0x42, 0x74, 0x00, 0xa0, 0xe2, 0x01, 0x42, 0x6c, 0x00, - 0x96, 0xe2, 0x01, 0xae, 0x2c, 0xef, 0xaa, 0xe2, 0x01, 0x42, 0xbb, 0x09, - 0x90, 0xe2, 0x01, 0x42, 0x71, 0x00, 0x9f, 0xe2, 0x01, 0x42, 0x40, 0x06, - 0x99, 0xe2, 0x01, 0x42, 0x12, 0x00, 0x92, 0xe2, 0x01, 0xf5, 0xa5, 0xe2, - 0x01, 0x42, 0xa9, 0x01, 0x9c, 0xe2, 0x01, 0x42, 0xbe, 0x22, 0x9b, 0xe2, - 0x41, 0xe1, 0x97, 0xe2, 0x01, 0x42, 0x24, 0x02, 0x98, 0xe2, 0x41, 0xf5, - 0xa3, 0xe2, 0x41, 0xef, 0xa8, 0xe2, 0x41, 0xe1, 0x91, 0xe2, 0x01, 0x07, - 0x65, 0xd5, 0x01, 0xff, 0x42, 0x93, 0x0f, 0xac, 0xe2, 0x01, 0xe5, 0xa7, - 0xe2, 0x81, 0x09, 0xe9, 0xa2, 0xe2, 0xc1, 0x00, 0xf5, 0xa4, 0xe2, 0x41, - 0xef, 0xa9, 0xe2, 0x41, 0xe5, 0xab, 0xe2, 0x41, 0x16, 0x2c, 0x33, 0x06, - 0x56, 0x26, 0x35, 0x2a, 0xf1, 0x41, 0x02, 0x27, 0xf5, 0x31, 0x95, 0x23, - 0x96, 0x0f, 0x97, 0x01, 0xff, 0x43, 0xa1, 0xf3, 0x44, 0xf2, 0x01, 0x43, - 0xef, 0xf3, 0x46, 0xf2, 0x41, 0x43, 0xbf, 0xf3, 0x45, 0xf2, 0x01, 0x43, - 0xe3, 0xf3, 0x48, 0xf2, 0x01, 0x43, 0xf5, 0xf3, 0x40, 0xf2, 0x41, 0x43, - 0xc2, 0xf3, 0x47, 0xf2, 0x01, 0x43, 0x1c, 0xf4, 0x43, 0xf2, 0x41, 0x42, - 0x00, 0xf4, 0x41, 0xf2, 0x01, 0x42, 0x7a, 0xe2, 0x42, 0xf2, 0x41, 0x04, - 0xaa, 0x17, 0xfa, 0x01, 0x4d, 0x72, 0x0b, 0xde, 0x23, 0x00, 0x02, 0x22, - 0x00, 0x6a, 0x15, 0x71, 0x3c, 0x5a, 0x05, 0xc3, 0x00, 0x36, 0x4b, 0xda, - 0x21, 0xdc, 0x23, 0x00, 0x06, 0xc8, 0x00, 0x12, 0x4e, 0xe3, 0x26, 0xb4, - 0x23, 0x00, 0x56, 0x54, 0x09, 0xe0, 0x23, 0x00, 0x58, 0x31, 0x2c, 0x1d, - 0xf5, 0x41, 0xa3, 0x0c, 0x4c, 0x94, 0x8f, 0x23, 0x2e, 0x00, 0x69, 0x65, - 0x04, 0xec, 0xfb, 0x41, 0x45, 0x1e, 0x0b, 0x1d, 0x23, 0x00, 0x43, 0x27, - 0x0d, 0x0e, 0x23, 0x40, 0x62, 0x12, 0x0c, 0x07, 0xce, 0x01, 0xa3, 0x0c, - 0x4c, 0x94, 0x8f, 0x22, 0x2e, 0x00, 0x6a, 0xee, 0x02, 0xef, 0xfb, 0x41, - 0x45, 0x1e, 0x0b, 0x1c, 0x23, 0x00, 0x43, 0x27, 0x0d, 0x0f, 0x23, 0x40, - 0x4c, 0x0c, 0x03, 0xe8, 0xfb, 0x01, 0x4c, 0x32, 0x11, 0xe0, 0xfb, 0x41, - 0x03, 0x24, 0x00, 0x04, 0xf4, 0xa9, 0xf3, 0x41, 0x4c, 0x0c, 0x03, 0xca, - 0x2b, 0x00, 0xa6, 0x59, 0x48, 0xaf, 0x26, 0x20, 0x23, 0x00, 0x04, 0xc3, - 0x00, 0x31, 0x05, 0xc8, 0x00, 0x0f, 0xb3, 0x01, 0xff, 0x4b, 0x35, 0x95, - 0x39, 0x2e, 0x00, 0x4e, 0x6d, 0x73, 0xe6, 0xcd, 0x41, 0x4c, 0xd9, 0x21, - 0x5a, 0x2e, 0x00, 0x09, 0x64, 0x63, 0x01, 0xff, 0x44, 0x0c, 0x44, 0x5c, - 0xcc, 0x01, 0x0c, 0x9c, 0x96, 0x01, 0xff, 0xd1, 0xe8, 0xcd, 0x01, 0xd2, - 0xea, 0xcd, 0x41, 0x4c, 0xd9, 0x21, 0x59, 0x2e, 0x00, 0x09, 0x64, 0x63, - 0x01, 0xff, 0x44, 0x0c, 0x44, 0x5a, 0xcc, 0x01, 0x0c, 0x9c, 0x96, 0x01, - 0xff, 0xd1, 0xec, 0xcd, 0x01, 0xd2, 0xee, 0xcd, 0x41, 0x14, 0x03, 0x44, - 0x11, 0x0f, 0x5e, 0x63, 0x01, 0xff, 0x44, 0x0c, 0x44, 0x5b, 0xcc, 0x01, - 0x45, 0x9c, 0x96, 0xf0, 0xcd, 0x41, 0xd1, 0xf6, 0xcd, 0x01, 0xd2, 0xf7, - 0xcd, 0x41, 0x53, 0x61, 0x10, 0x3a, 0x29, 0x80, 0x06, 0x5a, 0x7e, 0x1f, - 0x3c, 0x29, 0x40, 0x4a, 0x9e, 0xa6, 0x3d, 0x29, 0x40, 0x44, 0x8e, 0x85, - 0xf0, 0xf9, 0x01, 0x42, 0x53, 0x00, 0xb7, 0xf9, 0xc1, 0x00, 0x45, 0xec, - 0xb5, 0xa5, 0xfa, 0x41, 0x06, 0xef, 0x06, 0xd1, 0x01, 0x07, 0xec, 0x05, - 0x16, 0x05, 0x5a, 0x03, 0x06, 0x45, 0xf7, 0xeb, 0xdb, 0x1d, 0x41, 0x46, - 0x82, 0xdc, 0xda, 0x1d, 0x01, 0x44, 0xb9, 0xf2, 0xd9, 0x1d, 0x41, 0xe1, - 0xb4, 0x1d, 0x81, 0xad, 0x01, 0xe2, 0xb8, 0x1d, 0x81, 0xa3, 0x01, 0xe3, - 0xc5, 0x1d, 0x81, 0x99, 0x01, 0xe4, 0xbd, 0x1d, 0x81, 0x86, 0x01, 0xe5, - 0xb1, 0x1d, 0x01, 0xe7, 0xcc, 0x1d, 0x81, 0x79, 0xe8, 0xd5, 0x1d, 0x01, - 0xe9, 0xb0, 0x1d, 0x01, 0xea, 0xc7, 0x1d, 0x81, 0x68, 0xeb, 0xca, 0x1d, - 0x81, 0x5f, 0xec, 0xd1, 0x1d, 0x01, 0xed, 0xba, 0x1d, 0x01, 0xee, 0xbf, - 0x1d, 0x81, 0x41, 0xef, 0xb3, 0x1d, 0x01, 0xf0, 0xb6, 0x1d, 0x81, 0x34, - 0xf2, 0xd0, 0x1d, 0x81, 0x26, 0xf3, 0xd4, 0x1d, 0x01, 0xf4, 0xbb, 0x1d, - 0x81, 0x10, 0xf5, 0xb2, 0x1d, 0x01, 0xf6, 0xd2, 0x1d, 0x01, 0xf8, 0xd6, - 0x1d, 0x01, 0xf9, 0xcf, 0x1d, 0x41, 0xe8, 0xbc, 0x1d, 0x01, 0xf4, 0xc0, - 0x1d, 0xc1, 0x00, 0xe8, 0xc1, 0x1d, 0x41, 0xf2, 0xd7, 0x1d, 0xc1, 0x00, - 0xe8, 0xd8, 0x1d, 0x41, 0xe8, 0xb7, 0x1d, 0x41, 0xe7, 0xce, 0x1d, 0x01, - 0xee, 0xc4, 0x1d, 0x81, 0x04, 0xf9, 0xc9, 0x1d, 0x41, 0xf9, 0xd3, 0x1d, - 0x41, 0xe8, 0xcb, 0x1d, 0x41, 0xe8, 0xc8, 0x1d, 0x41, 0xe8, 0xcd, 0x1d, - 0x41, 0xe4, 0xc2, 0x1d, 0x81, 0x04, 0xe8, 0xbe, 0x1d, 0x41, 0xe8, 0xc3, - 0x1d, 0x41, 0xe8, 0xc6, 0x1d, 0x41, 0xe8, 0xb9, 0x1d, 0x41, 0xe1, 0xb5, - 0x1d, 0x41, 0x45, 0x12, 0x0b, 0xe8, 0x1d, 0x01, 0xa6, 0x2e, 0x44, 0xea, - 0x2a, 0xe9, 0x1d, 0x01, 0x43, 0x0e, 0x0b, 0xe1, 0x1d, 0x01, 0xb3, 0x14, - 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xe0, 0x1d, 0x41, 0x44, 0x25, 0x01, 0xe3, - 0x1d, 0x01, 0x42, 0x15, 0x02, 0xe2, 0x1d, 0x41, 0x44, 0xe5, 0x1d, 0xe7, - 0x1d, 0x01, 0x42, 0x1c, 0x26, 0xe6, 0x1d, 0x41, 0x43, 0xd2, 0x05, 0xe5, - 0x1d, 0x01, 0x43, 0xf6, 0x06, 0xe4, 0x1d, 0x41, 0xe1, 0xc0, 0x05, 0x81, - 0xa9, 0x02, 0x42, 0x16, 0x00, 0xc2, 0x05, 0x01, 0xa3, 0x96, 0x02, 0xa4, - 0x89, 0x02, 0xe5, 0xca, 0x05, 0x81, 0xff, 0x01, 0x42, 0x0c, 0x08, 0xcb, - 0x05, 0x01, 0xa7, 0xe6, 0x01, 0xa8, 0xd9, 0x01, 0xe9, 0xd2, 0x05, 0x01, - 0xaa, 0xca, 0x01, 0xab, 0xbd, 0x01, 0xac, 0xb0, 0x01, 0xad, 0xa3, 0x01, - 0xae, 0x78, 0xef, 0xda, 0x05, 0x81, 0x6f, 0xb0, 0x63, 0x42, 0x43, 0x14, - 0xdc, 0x05, 0x01, 0xb2, 0x51, 0xb3, 0x33, 0xb4, 0x27, 0xf5, 0xe4, 0x05, - 0x01, 0x42, 0xf5, 0x0a, 0xe5, 0x05, 0x01, 0xb8, 0x11, 0xf9, 0xea, 0x05, - 0x01, 0xba, 0x01, 0xff, 0xe1, 0xec, 0x05, 0x01, 0x42, 0x22, 0x00, 0xed, - 0x05, 0x41, 0xe1, 0xe6, 0x05, 0x01, 0x42, 0x22, 0x00, 0xe8, 0x05, 0x41, - 0xe1, 0xe2, 0x05, 0x01, 0x42, 0x22, 0x00, 0xe3, 0x05, 0x41, 0xe1, 0xdf, - 0x05, 0x01, 0xa8, 0x0c, 0x43, 0x6c, 0x27, 0xf0, 0x05, 0x01, 0x42, 0x12, - 0x00, 0xef, 0x05, 0x41, 0xe1, 0xe0, 0x05, 0x01, 0x42, 0x12, 0x00, 0xe1, - 0x05, 0x41, 0xe1, 0xdd, 0x05, 0x01, 0x42, 0x71, 0x00, 0xde, 0x05, 0x41, - 0xe1, 0xdb, 0x05, 0x01, 0x42, 0x40, 0x06, 0xf2, 0x05, 0x41, 0xef, 0xf3, - 0x05, 0x41, 0xe1, 0xd8, 0x05, 0x01, 0x42, 0xf0, 0x10, 0xc7, 0x05, 0x01, - 0xa7, 0x13, 0x43, 0xfb, 0xb5, 0xd9, 0x05, 0x01, 0xb8, 0x01, 0xff, 0xe1, - 0xe7, 0x05, 0x01, 0x42, 0x22, 0x00, 0xe9, 0x05, 0x41, 0xe1, 0xcd, 0x05, - 0x01, 0x42, 0x72, 0x19, 0xcf, 0x05, 0x41, 0xe1, 0xd7, 0x05, 0x01, 0x42, - 0x16, 0x00, 0xc3, 0x05, 0x41, 0xe1, 0xd5, 0x05, 0x01, 0x42, 0x74, 0x00, - 0xd6, 0x05, 0x41, 0xe1, 0xd4, 0x05, 0x01, 0x42, 0x22, 0x00, 0xf1, 0x05, - 0x41, 0xe1, 0xd3, 0x05, 0x01, 0xf9, 0xeb, 0x05, 0x41, 0xe1, 0xd0, 0x05, - 0x01, 0x42, 0x72, 0x19, 0xd1, 0x05, 0x41, 0xe1, 0xcc, 0x05, 0x01, 0x42, - 0x22, 0x00, 0xee, 0x05, 0x01, 0x42, 0x72, 0x19, 0xce, 0x05, 0x41, 0xe9, - 0xc9, 0x05, 0x41, 0xe1, 0xc6, 0x05, 0x01, 0x42, 0x22, 0x00, 0xc8, 0x05, - 0x41, 0xe1, 0xc4, 0x05, 0x01, 0x42, 0x22, 0x00, 0xc5, 0x05, 0x41, 0xf3, - 0xc1, 0x05, 0x41, 0x06, 0x3c, 0xda, 0xde, 0x07, 0x44, 0x66, 0x09, 0xab, - 0xf3, 0x01, 0x4f, 0x91, 0x6c, 0xdd, 0x29, 0x00, 0x07, 0x36, 0xd1, 0xa6, - 0x05, 0xa7, 0x90, 0x05, 0x43, 0x37, 0x1e, 0x7e, 0x00, 0x80, 0xbf, 0x04, - 0x02, 0x2a, 0x02, 0xa3, 0x04, 0x42, 0x99, 0x1a, 0xfe, 0x29, 0x80, 0x95, - 0x04, 0xb2, 0x01, 0xff, 0x47, 0x13, 0x15, 0x2b, 0xf6, 0x01, 0x05, 0x4c, - 0xe7, 0x11, 0x0b, 0xdd, 0xa0, 0x01, 0xff, 0x4a, 0x9c, 0xa8, 0x52, 0x2e, - 0x00, 0x42, 0xed, 0x05, 0x4a, 0x20, 0x40, 0xa1, 0xe8, 0x03, 0x06, 0xef, - 0x06, 0xa1, 0x03, 0x45, 0xde, 0xe6, 0xc5, 0x14, 0x01, 0x07, 0xec, 0x05, - 0x85, 0x01, 0x42, 0x14, 0x05, 0xc7, 0x14, 0x01, 0x05, 0x5a, 0x03, 0x50, - 0x0b, 0x55, 0x77, 0x01, 0xff, 0xa1, 0x3d, 0xe5, 0xb9, 0x14, 0x01, 0xe9, - 0xb1, 0x14, 0x81, 0x30, 0xef, 0xbc, 0x14, 0x01, 0x06, 0x33, 0x07, 0x20, - 0xf5, 0xb3, 0x14, 0x81, 0x17, 0x08, 0x43, 0xc1, 0x01, 0xff, 0xec, 0xb7, - 0x14, 0x81, 0x09, 0xf2, 0xb5, 0x14, 0xc1, 0x00, 0xf2, 0xb6, 0x14, 0x41, - 0xec, 0xb8, 0x14, 0x41, 0xf5, 0xb4, 0x14, 0x41, 0xe5, 0xba, 0x14, 0x01, - 0xef, 0xbd, 0x14, 0x41, 0xe9, 0xb2, 0x14, 0x41, 0xe1, 0xb0, 0x14, 0x01, - 0xe9, 0xbb, 0x14, 0x01, 0xf5, 0xbe, 0x14, 0x41, 0xa1, 0x1d, 0x4b, 0xd9, - 0x23, 0xbf, 0x14, 0x01, 0x45, 0x5a, 0x3f, 0xc3, 0x14, 0x01, 0x02, 0x02, - 0x00, 0x01, 0xff, 0x44, 0xe7, 0x23, 0xc2, 0x14, 0x01, 0x45, 0xf3, 0x4b, - 0xc1, 0x14, 0x41, 0x47, 0x3d, 0x16, 0xc0, 0x14, 0x01, 0x47, 0xc4, 0x88, - 0xc4, 0x14, 0x41, 0xe1, 0x81, 0x14, 0x81, 0xff, 0x01, 0xa2, 0xf2, 0x01, - 0xa3, 0xe5, 0x01, 0xa4, 0xcc, 0x01, 0xe5, 0x8b, 0x14, 0x01, 0xa7, 0xbb, - 0x01, 0x42, 0x22, 0x00, 0xaf, 0x14, 0x01, 0xe9, 0x83, 0x14, 0x81, 0xab, - 0x01, 0xaa, 0x9e, 0x01, 0xab, 0x91, 0x01, 0x42, 0x74, 0x00, 0xaa, 0x14, - 0x01, 0x42, 0x6c, 0x00, 0xa7, 0x14, 0x01, 0xae, 0x6d, 0xef, 0x8d, 0x14, - 0x01, 0xb0, 0x5d, 0x42, 0x71, 0x00, 0xa9, 0x14, 0x01, 0xb3, 0x45, 0xb4, - 0x2c, 0xf5, 0x85, 0x14, 0x81, 0x23, 0xb6, 0x06, 0x42, 0xbe, 0x22, 0xa8, - 0x14, 0x41, 0xe1, 0xab, 0x14, 0x01, 0x07, 0x44, 0xc1, 0x01, 0xff, 0xec, - 0x89, 0x14, 0x81, 0x09, 0xf2, 0x87, 0x14, 0xc1, 0x00, 0xf2, 0x88, 0x14, - 0x41, 0xec, 0x8a, 0x14, 0x41, 0xf5, 0x86, 0x14, 0x41, 0xe1, 0x9e, 0x14, - 0x01, 0x42, 0x22, 0x00, 0x9f, 0x14, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x99, - 0x14, 0x01, 0x42, 0x22, 0x00, 0x9a, 0x14, 0x41, 0xe1, 0xae, 0x14, 0x01, - 0x42, 0x22, 0x00, 0xac, 0x14, 0x01, 0x42, 0x40, 0x06, 0xad, 0x14, 0x41, - 0xe1, 0xa3, 0x14, 0x01, 0x42, 0x22, 0x00, 0xa4, 0x14, 0x41, 0xe1, 0xa2, - 0x14, 0x01, 0x42, 0x24, 0x02, 0x93, 0x14, 0x01, 0x42, 0x2a, 0x05, 0x9d, - 0x14, 0x01, 0x42, 0xbe, 0x22, 0x98, 0x14, 0x41, 0xe1, 0x8f, 0x14, 0x01, - 0x42, 0x22, 0x00, 0x90, 0x14, 0x41, 0xe1, 0x96, 0x14, 0x01, 0x42, 0x22, - 0x00, 0x97, 0x14, 0x41, 0xe9, 0x84, 0x14, 0x41, 0xe1, 0x91, 0x14, 0x01, - 0x42, 0x22, 0x00, 0x92, 0x14, 0x41, 0xe1, 0xa0, 0x14, 0x01, 0xa4, 0x06, - 0x42, 0x22, 0x00, 0xa1, 0x14, 0x41, 0xe1, 0x9b, 0x14, 0x01, 0x42, 0x22, - 0x00, 0x9c, 0x14, 0x41, 0xe1, 0x94, 0x14, 0x01, 0x42, 0x22, 0x00, 0x95, - 0x14, 0x41, 0xe1, 0xa5, 0x14, 0x01, 0x42, 0x22, 0x00, 0xa6, 0x14, 0x41, - 0xe1, 0x82, 0x14, 0x01, 0xe9, 0x8c, 0x14, 0x01, 0xf5, 0x8e, 0x14, 0x41, - 0x45, 0x12, 0x0b, 0xd8, 0x14, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0xd9, - 0x14, 0x01, 0x43, 0x0e, 0x0b, 0xd1, 0x14, 0x01, 0xb3, 0x14, 0xb4, 0x06, - 0x44, 0x5f, 0x1e, 0xd0, 0x14, 0x41, 0x44, 0x25, 0x01, 0xd3, 0x14, 0x01, - 0x42, 0x15, 0x02, 0xd2, 0x14, 0x41, 0x44, 0xe5, 0x1d, 0xd7, 0x14, 0x01, - 0x42, 0x1c, 0x26, 0xd6, 0x14, 0x41, 0x43, 0xd2, 0x05, 0xd5, 0x14, 0x01, - 0x43, 0xf6, 0x06, 0xd4, 0x14, 0x41, 0x50, 0xe4, 0x57, 0xc6, 0x14, 0x01, - 0x43, 0x6f, 0x87, 0x80, 0x14, 0x41, 0x62, 0xf0, 0x0b, 0x3a, 0x0b, 0x41, - 0x47, 0x3f, 0x1b, 0xf2, 0x23, 0x00, 0x07, 0xbc, 0x07, 0x01, 0xff, 0x4f, - 0x7f, 0x6f, 0xd4, 0x29, 0x00, 0x50, 0xbd, 0x66, 0xd5, 0x29, 0x40, 0x80, - 0x01, 0xff, 0x48, 0x9a, 0x1d, 0x3c, 0x22, 0x80, 0x1b, 0x05, 0x51, 0x00, - 0x01, 0xff, 0x04, 0x03, 0x0c, 0x06, 0x4a, 0x80, 0xb0, 0x1b, 0x2e, 0x40, - 0x45, 0x5c, 0x00, 0x1e, 0x2e, 0x00, 0x45, 0x20, 0x07, 0x1f, 0x2e, 0x40, - 0x80, 0x01, 0xff, 0x06, 0x5c, 0x00, 0x11, 0x05, 0x51, 0x00, 0x01, 0xff, - 0x49, 0x56, 0x1e, 0x6a, 0x2a, 0x00, 0x4b, 0x48, 0xa2, 0x6b, 0x2a, 0x40, - 0x4f, 0x69, 0x1a, 0x49, 0x2b, 0x00, 0x50, 0xb3, 0x02, 0x72, 0x29, 0x40, - 0x42, 0x33, 0x00, 0x05, 0xf4, 0x81, 0x06, 0x57, 0xe6, 0x2e, 0x45, 0x27, - 0x40, 0x45, 0x0b, 0x08, 0x2f, 0xf4, 0x41, 0x50, 0x9d, 0x61, 0x7f, 0x2d, - 0x00, 0x07, 0xec, 0x05, 0x0c, 0x62, 0x78, 0x0c, 0x6f, 0x2d, 0x00, 0x4e, - 0x14, 0x7c, 0x70, 0x2d, 0x40, 0xa1, 0x82, 0x02, 0x11, 0x9e, 0x58, 0xf5, - 0x01, 0xb4, 0xc0, 0x01, 0xb9, 0x01, 0xff, 0xe1, 0x30, 0x2d, 0x80, 0x15, - 0xe5, 0x66, 0x2d, 0x80, 0x0c, 0xe9, 0x49, 0x2d, 0x00, 0xef, 0x67, 0x2d, - 0x00, 0xf5, 0x53, 0x2d, 0x40, 0xf9, 0x3b, 0x2d, 0x40, 0xe1, 0x44, 0x2d, - 0x00, 0xe2, 0x31, 0x2d, 0x80, 0x95, 0x01, 0x42, 0x6d, 0x14, 0x5e, 0x2d, - 0x00, 0xe4, 0x37, 0x2d, 0x80, 0x7d, 0xe6, 0x3c, 0x2d, 0x00, 0xe7, 0x33, - 0x2d, 0x80, 0x6b, 0xe8, 0x40, 0x2d, 0x80, 0x62, 0xea, 0x36, 0x2d, 0x00, - 0xeb, 0x3d, 0x2d, 0x80, 0x50, 0xec, 0x4d, 0x2d, 0x00, 0xed, 0x4e, 0x2d, - 0x00, 0xee, 0x4f, 0x2d, 0x00, 0xf0, 0x52, 0x2d, 0x00, 0xf1, 0x47, 0x2d, - 0x00, 0xf2, 0x54, 0x2d, 0x80, 0x33, 0xf3, 0x59, 0x2d, 0x80, 0x26, 0xf4, - 0x5c, 0x2d, 0x80, 0x19, 0xf6, 0x60, 0x2d, 0x00, 0xf7, 0x61, 0x2d, 0x00, - 0xf9, 0x62, 0x2d, 0x00, 0xfa, 0x63, 0x2d, 0xc0, 0x00, 0xe8, 0x4a, 0x2d, - 0x00, 0xfa, 0x65, 0x2d, 0x40, 0xe8, 0x5d, 0x2d, 0x00, 0xf4, 0x5f, 0x2d, - 0x40, 0xe8, 0x5b, 0x2d, 0x00, 0xf3, 0x5a, 0x2d, 0x40, 0xf2, 0x55, 0x2d, - 0x40, 0xe8, 0x45, 0x2d, 0xc0, 0x00, 0xe8, 0x3f, 0x2d, 0x40, 0xe8, 0x43, - 0x2d, 0x40, 0xe8, 0x56, 0x2d, 0xc0, 0x00, 0xe8, 0x34, 0x2d, 0x40, 0xe4, - 0x39, 0x2d, 0x80, 0x04, 0xe8, 0x38, 0x2d, 0x40, 0xe8, 0x3a, 0x2d, 0x40, - 0xe8, 0x32, 0x2d, 0x40, 0x4d, 0x06, 0x81, 0x64, 0x2d, 0x00, 0x08, 0xf9, - 0xcb, 0x01, 0xff, 0xa7, 0x1d, 0xe8, 0x42, 0x2d, 0x00, 0xeb, 0x3e, 0x2d, - 0x80, 0x10, 0x42, 0x1d, 0x01, 0x51, 0x2d, 0x00, 0xf1, 0x48, 0x2d, 0x00, - 0x42, 0x6f, 0x28, 0x4c, 0x2d, 0x40, 0xe8, 0x46, 0x2d, 0x40, 0xe8, 0x57, - 0x2d, 0x00, 0xee, 0x50, 0x2d, 0x40, 0xe8, 0x41, 0x2d, 0x00, 0xea, 0x35, - 0x2d, 0x40, 0x4b, 0xc8, 0x9c, 0x4b, 0x2d, 0x00, 0x48, 0xf1, 0xcc, 0x58, - 0x2d, 0x40, 0x12, 0x5a, 0x50, 0x9d, 0x0b, 0x12, 0xb4, 0x50, 0x80, 0x0b, - 0x06, 0xef, 0x06, 0xf3, 0x09, 0x49, 0x40, 0xbb, 0xbe, 0x0f, 0x80, 0xe5, - 0x09, 0xac, 0xbf, 0x07, 0x05, 0xb9, 0x00, 0xf6, 0x04, 0xb3, 0x51, 0x0b, - 0x55, 0x77, 0x01, 0xff, 0x42, 0x80, 0x12, 0x71, 0x0f, 0x00, 0xe5, 0x7a, - 0x0f, 0x80, 0x3d, 0xe9, 0x72, 0x0f, 0x80, 0x34, 0xef, 0x7c, 0x0f, 0x80, - 0x2b, 0x4a, 0x44, 0xb0, 0x80, 0x0f, 0x80, 0x20, 0xf5, 0x74, 0x0f, 0x80, - 0x17, 0x08, 0x43, 0xc1, 0x01, 0xff, 0xec, 0x78, 0x0f, 0x80, 0x09, 0xf2, - 0x76, 0x0f, 0xc0, 0x00, 0xf2, 0x77, 0x0f, 0x40, 0xec, 0x79, 0x0f, 0x40, - 0xf5, 0x75, 0x0f, 0x40, 0xe9, 0x81, 0x0f, 0x40, 0xef, 0x7d, 0x0f, 0x40, - 0xe9, 0x73, 0x0f, 0x40, 0xe5, 0x7b, 0x0f, 0x40, 0x04, 0x5b, 0x03, 0xfd, - 0x02, 0x09, 0xdd, 0x67, 0x4b, 0xb9, 0x01, 0xff, 0x49, 0xbe, 0xbb, 0x00, - 0x0f, 0x00, 0x05, 0x61, 0x16, 0x01, 0xff, 0x47, 0x8e, 0xd0, 0xc4, 0x0f, - 0x00, 0x46, 0x8c, 0xde, 0xc9, 0x0f, 0x80, 0x1b, 0xb0, 0x0d, 0x47, 0x5e, - 0xd5, 0xc5, 0x0f, 0xc0, 0x00, 0x4a, 0x3a, 0xa6, 0xc7, 0x0f, 0x40, 0x49, - 0xcd, 0xb5, 0xc6, 0x0f, 0x00, 0x46, 0xc4, 0xdc, 0xc8, 0x0f, 0x40, 0x80, - 0x01, 0xff, 0x4b, 0xf2, 0x99, 0xcc, 0x0f, 0x00, 0x4b, 0xb2, 0x9c, 0xcb, - 0x0f, 0x00, 0x4b, 0x90, 0xa0, 0xca, 0x0f, 0x40, 0x07, 0xec, 0x05, 0x17, - 0x05, 0x5a, 0x03, 0x01, 0xff, 0x51, 0x46, 0x5b, 0x8f, 0x0f, 0x00, 0x4b, - 0x75, 0x9e, 0x8d, 0x0f, 0x00, 0x48, 0x4f, 0x5b, 0x8e, 0x0f, 0x40, 0x42, - 0xea, 0x25, 0xb0, 0x0f, 0x00, 0xe1, 0xb8, 0x0f, 0x00, 0xa2, 0xfc, 0x01, - 0xa3, 0xef, 0x01, 0xa4, 0xc9, 0x01, 0x0b, 0x0e, 0x83, 0xb2, 0x01, 0xa7, - 0xa5, 0x01, 0x42, 0x22, 0x00, 0xb7, 0x0f, 0x00, 0x42, 0x72, 0x19, 0x97, - 0x0f, 0x00, 0xab, 0x86, 0x01, 0x42, 0x74, 0x00, 0xb3, 0x0f, 0x00, 0x42, - 0x6c, 0x00, 0xa8, 0x0f, 0x00, 0xae, 0x62, 0xb0, 0x56, 0x42, 0x71, 0x00, - 0xb2, 0x0f, 0x00, 0xb3, 0x3e, 0xb4, 0x19, 0x42, 0xa9, 0x01, 0xad, 0x0f, - 0x00, 0x42, 0xbe, 0x22, 0xb1, 0x0f, 0x00, 0xba, 0x01, 0xff, 0xe1, 0xaf, - 0x0f, 0x00, 0x42, 0x22, 0x00, 0xae, 0x0f, 0x40, 0xe1, 0x9f, 0x0f, 0x00, - 0x42, 0x22, 0x00, 0xa0, 0x0f, 0x00, 0xb3, 0x0d, 0xb4, 0x01, 0xff, 0xe1, - 0x9a, 0x0f, 0x00, 0x42, 0x22, 0x00, 0x9b, 0x0f, 0x40, 0xe1, 0xa9, 0x0f, - 0x00, 0x42, 0x22, 0x00, 0xaa, 0x0f, 0x40, 0xe1, 0xb6, 0x0f, 0x00, 0x42, - 0x22, 0x00, 0xb4, 0x0f, 0x00, 0x42, 0x40, 0x06, 0xb5, 0x0f, 0x40, 0xe1, - 0xa4, 0x0f, 0x00, 0x42, 0x22, 0x00, 0xa5, 0x0f, 0x40, 0xe1, 0xa3, 0x0f, - 0x00, 0x42, 0x24, 0x02, 0x94, 0x0f, 0x00, 0x42, 0x2a, 0x05, 0x9e, 0x0f, - 0x00, 0x42, 0xbe, 0x22, 0x99, 0x0f, 0x40, 0xe1, 0x90, 0x0f, 0x00, 0x42, - 0x22, 0x00, 0x91, 0x0f, 0x00, 0x43, 0xfd, 0x20, 0xb9, 0x0f, 0x40, 0xe1, - 0x92, 0x0f, 0x00, 0x42, 0x22, 0x00, 0x93, 0x0f, 0x40, 0x42, 0x71, 0x00, - 0xbc, 0x0f, 0x00, 0x42, 0xa9, 0x01, 0xba, 0x0f, 0x00, 0x42, 0xbe, 0x22, - 0xbb, 0x0f, 0x40, 0xe1, 0xa1, 0x0f, 0x00, 0xa4, 0x13, 0x42, 0x22, 0x00, - 0xa2, 0x0f, 0x00, 0xba, 0x01, 0xff, 0xe1, 0xab, 0x0f, 0x00, 0x42, 0x22, - 0x00, 0xac, 0x0f, 0x40, 0xe1, 0x9c, 0x0f, 0x00, 0x42, 0x22, 0x00, 0x9d, - 0x0f, 0x40, 0xe1, 0x95, 0x0f, 0x00, 0x42, 0x22, 0x00, 0x96, 0x0f, 0x40, - 0xe1, 0xa6, 0x0f, 0x00, 0x42, 0x22, 0x00, 0xa7, 0x0f, 0x40, 0x04, 0x35, - 0xf0, 0x90, 0x01, 0x51, 0x46, 0x5b, 0x8c, 0x0f, 0x00, 0x02, 0x0f, 0x3a, - 0x7a, 0xad, 0x6c, 0x4e, 0x38, 0x7a, 0x82, 0x0f, 0x00, 0xb2, 0x17, 0x48, - 0x31, 0xcb, 0x83, 0x0f, 0x00, 0x02, 0xbe, 0x22, 0x01, 0xff, 0x48, 0xc9, - 0xc8, 0x87, 0x0f, 0x00, 0x47, 0x92, 0xc3, 0x3e, 0x0f, 0x40, 0x04, 0xa1, - 0xbe, 0x0c, 0x4d, 0xc8, 0x84, 0x7e, 0x0f, 0x00, 0x48, 0xe1, 0x94, 0x7f, - 0x0f, 0x40, 0x05, 0xb7, 0xe5, 0x1f, 0x04, 0x79, 0xf1, 0x01, 0xff, 0xa7, - 0x06, 0x49, 0xa0, 0xbe, 0xce, 0x0f, 0x40, 0x43, 0x2e, 0xf4, 0x1d, 0x0f, - 0x00, 0x44, 0x90, 0xa0, 0x1e, 0x0f, 0x00, 0x43, 0x1d, 0x56, 0xcf, 0x0f, - 0x40, 0xa7, 0x06, 0x48, 0x61, 0xca, 0x1f, 0x0f, 0x40, 0x43, 0x2e, 0xf4, - 0x1a, 0x0f, 0x00, 0x44, 0x90, 0xa0, 0x1b, 0x0f, 0x00, 0x43, 0x1d, 0x56, - 0x1c, 0x0f, 0x40, 0x48, 0x91, 0xc3, 0x3f, 0x0f, 0x00, 0x47, 0x50, 0x5b, - 0x89, 0x0f, 0x40, 0x49, 0x77, 0x9e, 0x88, 0x0f, 0x00, 0x47, 0xd7, 0xd1, - 0x86, 0x0f, 0x40, 0x4b, 0xfd, 0x99, 0x8a, 0x0f, 0x00, 0x4b, 0x88, 0x9f, - 0x8b, 0x0f, 0x40, 0x0c, 0x64, 0x8c, 0xb3, 0x02, 0xa2, 0x88, 0x02, 0xa3, - 0xd4, 0x01, 0x55, 0x3a, 0x3a, 0x0c, 0x0f, 0x00, 0xa7, 0x95, 0x01, 0x47, - 0x8a, 0xd1, 0x84, 0x0f, 0x00, 0x02, 0x9e, 0x01, 0x75, 0x53, 0xdb, 0x4a, - 0xd9, 0x0f, 0x00, 0x56, 0xc0, 0x35, 0xd1, 0x0f, 0x00, 0xae, 0x3f, 0x46, - 0x1c, 0xdf, 0x85, 0x0f, 0x00, 0xb2, 0x2b, 0xb3, 0x1d, 0xb4, 0x06, 0x55, - 0x7a, 0x3f, 0x07, 0x0f, 0x40, 0x53, 0x6a, 0x4c, 0xda, 0x0f, 0x00, 0xb3, - 0x01, 0xff, 0x47, 0x8f, 0xce, 0x39, 0x0f, 0x00, 0x48, 0x84, 0x3f, 0x0f, - 0x0f, 0x40, 0x49, 0xff, 0xb6, 0x08, 0x0f, 0x00, 0x43, 0xa5, 0x02, 0x0d, - 0x0f, 0x40, 0x4d, 0x83, 0x83, 0x12, 0x0f, 0x00, 0x53, 0x56, 0x4a, 0x11, - 0x0f, 0x40, 0x0a, 0xcc, 0xaa, 0x18, 0x04, 0x91, 0xa0, 0x01, 0xff, 0x44, - 0xa4, 0x02, 0x0e, 0x0f, 0x00, 0x45, 0x44, 0x3a, 0xd2, 0x0f, 0xc0, 0x00, - 0x45, 0x4a, 0x04, 0x10, 0x0f, 0x40, 0x47, 0x38, 0x7a, 0x35, 0x0f, 0x00, - 0x4a, 0x0c, 0xb1, 0x37, 0x0f, 0x40, 0x06, 0xba, 0x16, 0x06, 0x51, 0x54, - 0x5e, 0x0b, 0x0f, 0x40, 0x5b, 0x93, 0x1a, 0xd3, 0x0f, 0x00, 0x4f, 0x9f, - 0x1a, 0x04, 0x0f, 0x40, 0x04, 0x08, 0x03, 0x11, 0x0b, 0x4d, 0xa4, 0x01, - 0xff, 0x42, 0xbb, 0x01, 0x3b, 0x0f, 0x00, 0x42, 0x10, 0x00, 0x3a, 0x0f, - 0x40, 0x45, 0x44, 0x3a, 0x14, 0x0f, 0x00, 0x08, 0x9f, 0x1a, 0x01, 0xff, - 0x04, 0xf1, 0xec, 0x06, 0x4b, 0x00, 0xa4, 0x01, 0x0f, 0x40, 0x4d, 0x76, - 0x83, 0x03, 0x0f, 0x00, 0x4c, 0xe0, 0x94, 0x02, 0x0f, 0x40, 0x05, 0x09, - 0x9a, 0x17, 0x46, 0x7c, 0xdc, 0x38, 0x0f, 0x00, 0x07, 0x64, 0x85, 0x01, - 0xff, 0x5b, 0xae, 0x1a, 0xd4, 0x0f, 0x00, 0x4f, 0xba, 0x1a, 0x05, 0x0f, - 0x40, 0x0c, 0xc8, 0x8b, 0x06, 0x54, 0x23, 0x47, 0x06, 0x0f, 0x40, 0x4c, - 0x67, 0x7f, 0x36, 0x0f, 0x00, 0x4b, 0x7d, 0x9f, 0x13, 0x0f, 0x40, 0x09, - 0x13, 0xbb, 0x18, 0xb3, 0x01, 0xff, 0x49, 0x0d, 0xb8, 0x34, 0x0f, 0x00, - 0xab, 0x01, 0xff, 0x54, 0x43, 0x40, 0xd0, 0x0f, 0x00, 0x4a, 0x1e, 0xb3, - 0x09, 0x0f, 0x40, 0x4c, 0xca, 0x35, 0xd0, 0x0f, 0x00, 0x47, 0x9f, 0x1a, - 0x0a, 0x0f, 0x40, 0x42, 0xbb, 0x01, 0x3d, 0x0f, 0x00, 0x42, 0x10, 0x00, - 0x3c, 0x0f, 0x40, 0x06, 0xed, 0x05, 0x11, 0x0d, 0xd0, 0x86, 0x01, 0xff, - 0x4a, 0xb0, 0xa8, 0x15, 0x0f, 0x00, 0x4a, 0x1a, 0xad, 0x16, 0x0f, 0x40, - 0x42, 0xea, 0x25, 0x60, 0x0f, 0x00, 0xe1, 0x68, 0x0f, 0x00, 0xa2, 0xf7, - 0x01, 0xa3, 0xea, 0x01, 0xa4, 0xc4, 0x01, 0x4d, 0x0e, 0x83, 0x6a, 0x0f, - 0x00, 0xa7, 0xb1, 0x01, 0x42, 0x22, 0x00, 0x67, 0x0f, 0x00, 0x42, 0x72, - 0x19, 0x47, 0x0f, 0x00, 0xab, 0x8c, 0x01, 0x42, 0x74, 0x00, 0x63, 0x0f, - 0x00, 0x42, 0x6c, 0x00, 0x58, 0x0f, 0x00, 0xae, 0x68, 0xb0, 0x5c, 0xb2, - 0x50, 0xb3, 0x3e, 0xb4, 0x19, 0x42, 0xa9, 0x01, 0x5d, 0x0f, 0x00, 0x42, - 0xbe, 0x22, 0x61, 0x0f, 0x00, 0xba, 0x01, 0xff, 0xe1, 0x5f, 0x0f, 0x00, - 0x42, 0x22, 0x00, 0x5e, 0x0f, 0x40, 0xe1, 0x4f, 0x0f, 0x00, 0x42, 0x22, - 0x00, 0x50, 0x0f, 0x00, 0xb3, 0x0d, 0xb4, 0x01, 0xff, 0xe1, 0x4a, 0x0f, - 0x00, 0x42, 0x22, 0x00, 0x4b, 0x0f, 0x40, 0xe1, 0x59, 0x0f, 0x00, 0x42, - 0x22, 0x00, 0x5a, 0x0f, 0x40, 0xe1, 0x66, 0x0f, 0x00, 0x42, 0x22, 0x00, - 0x64, 0x0f, 0x00, 0x42, 0x40, 0x06, 0x65, 0x0f, 0x40, 0xe1, 0x62, 0x0f, - 0x00, 0x42, 0x71, 0x00, 0x6c, 0x0f, 0x40, 0xe1, 0x54, 0x0f, 0x00, 0x42, - 0x22, 0x00, 0x55, 0x0f, 0x40, 0xe1, 0x53, 0x0f, 0x00, 0x42, 0x24, 0x02, - 0x44, 0x0f, 0x00, 0x42, 0x2a, 0x05, 0x4e, 0x0f, 0x00, 0x42, 0xbe, 0x22, - 0x49, 0x0f, 0x40, 0xe1, 0x40, 0x0f, 0x00, 0x42, 0x22, 0x00, 0x41, 0x0f, - 0x00, 0x42, 0x1b, 0x02, 0x6b, 0x0f, 0x00, 0x43, 0xfd, 0x20, 0x69, 0x0f, - 0x40, 0xe1, 0x42, 0x0f, 0x00, 0x42, 0x22, 0x00, 0x43, 0x0f, 0x40, 0xe1, - 0x51, 0x0f, 0x00, 0xa4, 0x13, 0x42, 0x22, 0x00, 0x52, 0x0f, 0x00, 0xba, - 0x01, 0xff, 0xe1, 0x5b, 0x0f, 0x00, 0x42, 0x22, 0x00, 0x5c, 0x0f, 0x40, - 0xe1, 0x4c, 0x0f, 0x00, 0x42, 0x22, 0x00, 0x4d, 0x0f, 0x40, 0xe1, 0x45, - 0x0f, 0x00, 0x42, 0x22, 0x00, 0x46, 0x0f, 0x40, 0xe1, 0x56, 0x0f, 0x00, - 0x42, 0x22, 0x00, 0x57, 0x0f, 0x40, 0x4d, 0x66, 0x7f, 0xbf, 0x0f, 0x40, - 0x45, 0x12, 0x0b, 0x28, 0x0f, 0x00, 0xa6, 0x74, 0x05, 0x22, 0x00, 0x2e, - 0x44, 0xea, 0x2a, 0x29, 0x0f, 0x00, 0x43, 0x0e, 0x0b, 0x21, 0x0f, 0x00, - 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x20, 0x0f, 0x40, 0x44, 0x25, - 0x01, 0x23, 0x0f, 0x00, 0x42, 0x15, 0x02, 0x22, 0x0f, 0x40, 0x44, 0xe5, - 0x1d, 0x27, 0x0f, 0x00, 0x42, 0x1c, 0x26, 0x26, 0x0f, 0x40, 0x45, 0x12, - 0x0b, 0x31, 0x0f, 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x32, 0x0f, 0x00, - 0x43, 0x0e, 0x0b, 0x2a, 0x0f, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, - 0x1e, 0x33, 0x0f, 0x40, 0x44, 0x25, 0x01, 0x2c, 0x0f, 0x00, 0x42, 0x15, - 0x02, 0x2b, 0x0f, 0x40, 0x44, 0xe5, 0x1d, 0x30, 0x0f, 0x00, 0x42, 0x1c, - 0x26, 0x2f, 0x0f, 0x40, 0x43, 0xd2, 0x05, 0x2e, 0x0f, 0x00, 0x43, 0xf6, - 0x06, 0x2d, 0x0f, 0x40, 0x43, 0xd2, 0x05, 0x25, 0x0f, 0x00, 0x43, 0xf6, - 0x06, 0x24, 0x0f, 0x40, 0x49, 0x11, 0xb7, 0xc2, 0x0f, 0x00, 0x4a, 0x44, - 0xab, 0xc0, 0x0f, 0x00, 0x4a, 0x24, 0xad, 0xc1, 0x0f, 0x00, 0x4a, 0xe4, - 0xb0, 0xc3, 0x0f, 0x40, 0x49, 0x34, 0xb5, 0x18, 0x0f, 0x00, 0xb3, 0x01, - 0xff, 0x4b, 0x3c, 0x9b, 0x19, 0x0f, 0x00, 0x54, 0x9b, 0x42, 0x17, 0x0f, - 0x40, 0xa1, 0xbd, 0x02, 0xa5, 0x8b, 0x02, 0xa9, 0xe3, 0x01, 0xaf, 0xd4, - 0x01, 0x03, 0x26, 0x01, 0x24, 0xb5, 0x01, 0xff, 0x04, 0x46, 0x91, 0x11, - 0x04, 0xf0, 0x1a, 0x01, 0xff, 0x4f, 0x2b, 0x69, 0xc8, 0x26, 0x00, 0x45, - 0x3e, 0xeb, 0x08, 0x26, 0x40, 0x49, 0xe9, 0xb7, 0x4e, 0xf4, 0x01, 0x47, - 0xfb, 0xd6, 0x4d, 0xf4, 0x41, 0x80, 0x41, 0x8d, 0x01, 0xff, 0x02, 0x06, - 0x00, 0x0c, 0x47, 0xe2, 0xc2, 0x3b, 0x2e, 0x00, 0x4c, 0x44, 0x80, 0x04, - 0x20, 0x40, 0x63, 0xb5, 0x0a, 0xa3, 0x27, 0x00, 0x6c, 0xbe, 0x01, 0x9b, - 0x2b, 0x00, 0x6b, 0x42, 0x02, 0x99, 0x2b, 0x00, 0x0c, 0x18, 0x96, 0x01, - 0xff, 0x5f, 0x4e, 0x11, 0x98, 0x2b, 0x00, 0x0b, 0xb3, 0x02, 0x01, 0xff, - 0x49, 0xe1, 0x01, 0xa2, 0x27, 0x00, 0x55, 0xd5, 0x01, 0x9a, 0x2b, 0x40, - 0x4c, 0x18, 0x8d, 0xb1, 0xf5, 0x01, 0x58, 0xe1, 0x27, 0x76, 0x2a, 0x00, - 0xa4, 0x4f, 0xac, 0x36, 0x53, 0x99, 0x4b, 0xa7, 0xf5, 0x01, 0x52, 0x07, - 0x2c, 0xc2, 0xf7, 0x01, 0xb2, 0x06, 0x4e, 0x84, 0x7c, 0xeb, 0xf5, 0x41, - 0x04, 0xfc, 0x45, 0x06, 0x50, 0x60, 0x2f, 0xf6, 0x21, 0x40, 0x45, 0x5c, - 0x00, 0xe4, 0xf5, 0x01, 0x45, 0x20, 0x07, 0xe5, 0xf5, 0x01, 0x44, 0xc3, - 0x00, 0xe6, 0xf5, 0x01, 0x45, 0xc8, 0x00, 0xe7, 0xf5, 0x41, 0x4f, 0x46, - 0x3e, 0x31, 0x2b, 0x00, 0x10, 0x0d, 0x64, 0x01, 0xff, 0x44, 0xc3, 0x00, - 0x9f, 0x26, 0x00, 0x45, 0xc8, 0x00, 0x9e, 0x26, 0x40, 0x50, 0xdd, 0x63, - 0xc0, 0x27, 0x00, 0x4e, 0x04, 0x0c, 0x56, 0x20, 0x40, 0x49, 0x69, 0xbc, - 0x74, 0xfa, 0x01, 0x4c, 0x60, 0x96, 0xad, 0xf4, 0x41, 0xae, 0x06, 0x4e, - 0x88, 0x7b, 0x49, 0xf9, 0x41, 0x80, 0x06, 0x49, 0x95, 0xb0, 0x14, 0xf9, - 0x41, 0x4b, 0x22, 0x61, 0xa1, 0xf7, 0x01, 0xb3, 0x01, 0xff, 0x46, 0x2f, - 0x19, 0xa8, 0xf7, 0x01, 0x44, 0xd8, 0x4c, 0x09, 0x20, 0x40, 0xb2, 0x06, - 0x43, 0x33, 0x46, 0xca, 0xce, 0x41, 0xa5, 0x11, 0x02, 0xc3, 0x07, 0x01, - 0xff, 0x47, 0x9c, 0xd0, 0xe7, 0x29, 0x00, 0x45, 0x53, 0xab, 0x21, 0xf3, - 0x41, 0x80, 0x06, 0x44, 0x9e, 0x62, 0x34, 0x22, 0x40, 0x4e, 0x1a, 0x77, - 0x04, 0x22, 0x00, 0x46, 0xbc, 0xdb, 0x03, 0x22, 0x40, 0x04, 0x4b, 0x12, - 0xfc, 0x04, 0x02, 0xf1, 0x03, 0x01, 0xff, 0xa3, 0x47, 0x06, 0xef, 0x06, - 0x01, 0xff, 0x45, 0x12, 0x0b, 0x58, 0x0e, 0x00, 0xa6, 0x2e, 0x44, 0xea, - 0x2a, 0x59, 0x0e, 0x00, 0x43, 0x0e, 0x0b, 0x51, 0x0e, 0x00, 0xb3, 0x14, - 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x50, 0x0e, 0x40, 0x44, 0x25, 0x01, 0x53, - 0x0e, 0x00, 0x42, 0x15, 0x02, 0x52, 0x0e, 0x40, 0x44, 0xe5, 0x1d, 0x57, - 0x0e, 0x00, 0x42, 0x1c, 0x26, 0x56, 0x0e, 0x40, 0x43, 0xd2, 0x05, 0x55, - 0x0e, 0x00, 0x43, 0xf6, 0x06, 0x54, 0x0e, 0x40, 0x09, 0xe7, 0x17, 0x06, - 0x53, 0x58, 0x4e, 0x3f, 0x0e, 0x40, 0x4a, 0xe8, 0xa7, 0x5a, 0x0e, 0x00, - 0x49, 0xe4, 0xb6, 0x1a, 0x0e, 0x00, 0x06, 0xba, 0xda, 0xfc, 0x03, 0x03, - 0x40, 0x66, 0xeb, 0x03, 0x02, 0x68, 0x03, 0xd5, 0x03, 0x03, 0xdb, 0x71, - 0xc4, 0x03, 0xab, 0x8d, 0x03, 0xac, 0xf0, 0x02, 0xad, 0xb4, 0x02, 0xae, - 0x96, 0x02, 0x45, 0x77, 0xe9, 0x2d, 0x0e, 0x00, 0xb0, 0xde, 0x01, 0xb2, - 0xd1, 0x01, 0xb3, 0x69, 0xb4, 0x20, 0x47, 0xb8, 0xd7, 0x27, 0x0e, 0x00, - 0xb9, 0x01, 0xff, 0x47, 0xda, 0xcc, 0x4e, 0x0e, 0x00, 0x03, 0xa2, 0xe1, - 0x01, 0xff, 0x42, 0x6d, 0x00, 0x22, 0x0e, 0x00, 0x43, 0xa1, 0x01, 0x0d, - 0x0e, 0x40, 0xa8, 0x11, 0x02, 0x7b, 0x02, 0x01, 0xff, 0x45, 0xe0, 0xe9, - 0x0f, 0x0e, 0x00, 0x43, 0xf4, 0x18, 0x15, 0x0e, 0x40, 0x49, 0x54, 0xb6, - 0x4c, 0x0e, 0x00, 0x02, 0x7b, 0x02, 0x01, 0xff, 0x4a, 0x5a, 0xae, 0x11, - 0x0e, 0x00, 0x47, 0xd9, 0xd4, 0x12, 0x0e, 0x00, 0x02, 0x53, 0x00, 0x01, - 0xff, 0xa1, 0x0c, 0x43, 0xd8, 0x02, 0x18, 0x0e, 0x00, 0x43, 0xb1, 0x45, - 0x16, 0x0e, 0x40, 0x43, 0x90, 0x00, 0x17, 0x0e, 0x00, 0xee, 0x10, 0x0e, - 0x40, 0x04, 0x41, 0x16, 0x1e, 0x02, 0x7b, 0x02, 0x01, 0xff, 0x44, 0xa5, - 0xf2, 0x29, 0x0e, 0x00, 0xb3, 0x01, 0xff, 0x43, 0x69, 0x19, 0x28, 0x0e, - 0x00, 0xef, 0x0b, 0x0e, 0x00, 0x42, 0x7d, 0x00, 0x2a, 0x0e, 0x40, 0xe1, - 0x30, 0x0e, 0x80, 0x23, 0xe5, 0x40, 0x0e, 0x00, 0xe9, 0x34, 0x0e, 0x80, - 0x16, 0xef, 0x42, 0x0e, 0x00, 0xf5, 0x38, 0x0e, 0xc0, 0x00, 0xe5, 0x36, - 0x0e, 0x80, 0x04, 0xf5, 0x39, 0x0e, 0x40, 0xe5, 0x37, 0x0e, 0x40, 0xe9, - 0x35, 0x0e, 0x40, 0xe1, 0x32, 0x0e, 0x00, 0xe5, 0x41, 0x0e, 0x00, 0x06, - 0xd0, 0xdc, 0x04, 0xed, 0x33, 0x0e, 0x40, 0x44, 0x11, 0xef, 0x44, 0x0e, - 0x00, 0x43, 0x74, 0xa1, 0x43, 0x0e, 0x40, 0x45, 0x8b, 0xe9, 0x23, 0x0e, - 0x00, 0xf5, 0x24, 0x0e, 0x40, 0x48, 0x59, 0xc3, 0x2f, 0x0e, 0x00, 0xa8, - 0x06, 0x45, 0x86, 0xe9, 0x1b, 0x0e, 0x40, 0x45, 0xa1, 0xe7, 0x3a, 0x0e, - 0x00, 0x02, 0x7b, 0x02, 0x01, 0xff, 0x02, 0x84, 0x10, 0x06, 0x47, 0xb9, - 0xd5, 0x20, 0x0e, 0x40, 0x42, 0x1a, 0x00, 0x1e, 0x0e, 0x00, 0x43, 0xb1, - 0x45, 0x1c, 0x0e, 0x40, 0x46, 0x3a, 0xdc, 0x07, 0x0e, 0x00, 0x47, 0x01, - 0xd2, 0x4d, 0x0e, 0x00, 0x03, 0x3b, 0xdc, 0x01, 0xff, 0x42, 0x92, 0x01, - 0x13, 0x0e, 0x00, 0xf5, 0x19, 0x0e, 0x40, 0x02, 0x56, 0x07, 0x06, 0x44, - 0xc5, 0x4d, 0x21, 0x0e, 0x40, 0x80, 0x0c, 0x46, 0x78, 0xe0, 0x47, 0x0e, - 0x00, 0x45, 0xa6, 0xec, 0x46, 0x0e, 0x40, 0x48, 0xc1, 0xc4, 0x4b, 0x0e, - 0x00, 0x42, 0xf1, 0x18, 0x48, 0x0e, 0x00, 0x48, 0xb9, 0xc6, 0x31, 0x0e, - 0x00, 0xb4, 0x01, 0xff, 0x42, 0x0b, 0x00, 0x49, 0x0e, 0x00, 0x42, 0x0d, - 0x00, 0x4a, 0x0e, 0x40, 0x4a, 0xac, 0xa7, 0x45, 0x0e, 0x00, 0x02, 0x7b, - 0x02, 0x04, 0xf5, 0x26, 0x0e, 0x40, 0x45, 0x58, 0xe5, 0x2c, 0x0e, 0x00, - 0x44, 0x2f, 0x0b, 0x25, 0x0e, 0x40, 0x02, 0x0b, 0x00, 0x06, 0x45, 0x81, - 0xe9, 0x01, 0x0e, 0x40, 0x80, 0x06, 0x43, 0x2c, 0xac, 0x5b, 0x0e, 0x40, - 0x02, 0x60, 0x0c, 0x06, 0x47, 0x3b, 0xd5, 0x06, 0x0e, 0x40, 0x42, 0x56, - 0x07, 0x02, 0x0e, 0x00, 0x42, 0x10, 0x00, 0x05, 0x0e, 0x00, 0x43, 0x0c, - 0x0c, 0x03, 0x0e, 0x00, 0x43, 0xd1, 0x10, 0x04, 0x0e, 0x40, 0x43, 0x5c, - 0x0d, 0x2b, 0x0e, 0x00, 0x46, 0x86, 0xde, 0x2e, 0x0e, 0x40, 0x43, 0x0b, - 0x08, 0x1d, 0x0e, 0x80, 0x06, 0x45, 0x31, 0xe9, 0x4f, 0x0e, 0x40, 0xee, - 0x1f, 0x0e, 0x40, 0x45, 0x3f, 0xe5, 0x0e, 0x0e, 0x00, 0x43, 0xf0, 0x18, - 0x14, 0x0e, 0x40, 0x42, 0x1a, 0x00, 0x08, 0x0e, 0x80, 0x0c, 0x43, 0xa1, - 0x01, 0x09, 0x0e, 0x00, 0x42, 0x67, 0x51, 0x0c, 0x0e, 0x40, 0xe7, 0x0a, - 0x0e, 0x40, 0xa1, 0xc6, 0x02, 0xa5, 0xb1, 0x02, 0x47, 0xe5, 0xd1, 0xa8, - 0x07, 0x00, 0x07, 0xec, 0x05, 0x20, 0xaf, 0x0c, 0x45, 0x43, 0xeb, 0xb0, - 0x07, 0x00, 0x47, 0xca, 0xd6, 0xaa, 0x07, 0x40, 0x48, 0x41, 0xc3, 0xaf, - 0x07, 0x00, 0x46, 0x5a, 0xda, 0xae, 0x07, 0x00, 0x48, 0x11, 0xc9, 0xab, - 0x07, 0x40, 0xa1, 0xf8, 0x01, 0x43, 0x90, 0x50, 0x84, 0x07, 0x00, 0x49, - 0x50, 0xb7, 0x97, 0x07, 0x00, 0xa4, 0xd5, 0x01, 0x45, 0x75, 0xe6, 0x8a, - 0x07, 0x00, 0xa7, 0xba, 0x01, 0xa8, 0xab, 0x01, 0x48, 0x79, 0xc7, 0x96, - 0x07, 0x00, 0xab, 0x96, 0x01, 0xac, 0x87, 0x01, 0x45, 0xa0, 0xe8, 0x89, - 0x07, 0x00, 0xae, 0x73, 0x48, 0xf9, 0xc9, 0x95, 0x07, 0x00, 0x45, 0x3a, - 0xea, 0xa4, 0x07, 0x00, 0x43, 0xb0, 0x95, 0x83, 0x07, 0x00, 0xb3, 0x44, - 0xb4, 0x25, 0x45, 0x2e, 0xec, 0x88, 0x07, 0x00, 0x45, 0x51, 0xec, 0xa5, - 0x07, 0x00, 0x43, 0xd2, 0xb9, 0x94, 0x07, 0x00, 0xba, 0x01, 0xff, 0xa1, - 0x04, 0xef, 0xa1, 0x07, 0x40, 0xe1, 0x9c, 0x07, 0x00, 0x46, 0x53, 0xb7, - 0x92, 0x07, 0x40, 0x47, 0x52, 0xb7, 0x93, 0x07, 0x00, 0x43, 0x42, 0x41, - 0x8c, 0x07, 0x80, 0x0a, 0xef, 0xa0, 0x07, 0x00, 0x43, 0x7f, 0x12, 0x98, - 0x07, 0x40, 0x42, 0xc7, 0x15, 0x9b, 0x07, 0x40, 0x45, 0x18, 0xe4, 0x9e, - 0x07, 0x00, 0x44, 0xbd, 0xef, 0x90, 0x07, 0x00, 0xa8, 0x01, 0xff, 0x47, - 0x52, 0xb7, 0x81, 0x07, 0x00, 0x44, 0xbd, 0xef, 0x9d, 0x07, 0x40, 0x42, - 0x80, 0x12, 0xb1, 0x07, 0x00, 0x44, 0x69, 0x96, 0x82, 0x07, 0x40, 0x44, - 0x7e, 0x89, 0x8d, 0x07, 0x00, 0x48, 0x51, 0xb7, 0x85, 0x07, 0x40, 0x44, - 0x76, 0xe6, 0x86, 0x07, 0x00, 0x43, 0x42, 0x41, 0x9a, 0x07, 0x40, 0x42, - 0x80, 0x12, 0x80, 0x07, 0x00, 0x43, 0x42, 0x41, 0x99, 0x07, 0x40, 0x44, - 0x76, 0xe6, 0x8e, 0x07, 0x00, 0x45, 0xed, 0xe6, 0xa3, 0x07, 0x00, 0x48, - 0xa9, 0xc8, 0x8f, 0x07, 0x40, 0xa1, 0x06, 0x45, 0xe3, 0xe6, 0x8b, 0x07, - 0x40, 0x44, 0x19, 0xe4, 0x9f, 0x07, 0x00, 0x46, 0x53, 0xb7, 0x91, 0x07, - 0x40, 0x43, 0xe8, 0x1a, 0xa2, 0x07, 0x00, 0x44, 0x25, 0xf1, 0x87, 0x07, - 0x40, 0x46, 0x36, 0xda, 0xac, 0x07, 0x00, 0x48, 0x89, 0xc5, 0xa9, 0x07, - 0x00, 0x48, 0xe1, 0xcc, 0xad, 0x07, 0x40, 0x48, 0x39, 0xc3, 0xa7, 0x07, - 0x00, 0x46, 0x2a, 0xda, 0xa6, 0x07, 0x40, 0xa1, 0xbf, 0x0a, 0x48, 0x29, - 0xc5, 0xf8, 0xf9, 0x01, 0xac, 0xea, 0x04, 0xae, 0xd7, 0x04, 0x47, 0x1b, - 0xd6, 0xea, 0xf9, 0x01, 0x0c, 0x24, 0x96, 0x01, 0xff, 0xa1, 0xb1, 0x04, - 0xa2, 0x9c, 0x04, 0xa3, 0xc4, 0x03, 0xa4, 0xff, 0x02, 0xa5, 0xd0, 0x02, - 0xa6, 0xa2, 0x02, 0xa7, 0x80, 0x02, 0xa8, 0xf1, 0x01, 0x02, 0x9e, 0x01, - 0xe0, 0x01, 0x43, 0xd9, 0x95, 0x1d, 0xd3, 0x01, 0xab, 0xcb, 0x01, 0xac, - 0xb4, 0x01, 0xad, 0x9f, 0x01, 0xaf, 0x90, 0x01, 0xb0, 0x74, 0xb2, 0x47, - 0xb3, 0x22, 0x45, 0xfc, 0xeb, 0x3b, 0xd3, 0x01, 0x53, 0xa4, 0x4e, 0x37, - 0xd3, 0x01, 0x02, 0xa9, 0x01, 0x06, 0x4c, 0x68, 0x97, 0x11, 0xd3, 0x41, - 0x45, 0xa1, 0x84, 0x17, 0xd3, 0x01, 0x43, 0x98, 0x21, 0x44, 0xd3, 0x41, - 0x48, 0x29, 0xc6, 0x4b, 0xd3, 0x01, 0x46, 0x5d, 0x91, 0x45, 0xd3, 0x01, - 0xb4, 0x01, 0xff, 0xaf, 0x06, 0x46, 0xa6, 0xdf, 0x29, 0xd3, 0x41, 0x45, - 0x2b, 0xea, 0x4c, 0xd3, 0x01, 0x42, 0x32, 0x00, 0x31, 0xd3, 0x41, 0xa5, - 0x06, 0x45, 0xbf, 0xe7, 0x35, 0xd3, 0x41, 0x43, 0xa7, 0x2d, 0x14, 0xd3, - 0x01, 0x45, 0x46, 0xe8, 0x1a, 0xd3, 0x01, 0xb3, 0x01, 0xff, 0xa9, 0x06, - 0x45, 0x26, 0xea, 0x2e, 0xd3, 0x41, 0x45, 0xa3, 0xe5, 0x2c, 0xd3, 0x01, - 0x46, 0x30, 0xe0, 0x1b, 0xd3, 0x41, 0xa1, 0x0c, 0x4a, 0x0e, 0xaa, 0x13, - 0xd3, 0x01, 0x45, 0x10, 0xec, 0x2a, 0xd3, 0x41, 0x45, 0x80, 0x67, 0x24, - 0xd3, 0x01, 0x45, 0x7a, 0x91, 0x34, 0xd3, 0x41, 0x4b, 0xf6, 0x9f, 0x53, - 0xd3, 0x01, 0x49, 0x4f, 0xbe, 0x0d, 0xd3, 0x41, 0x46, 0x12, 0xda, 0x40, - 0xd3, 0x01, 0x46, 0x8e, 0x18, 0x39, 0xd3, 0x01, 0x44, 0x7b, 0x87, 0x08, - 0xd3, 0x41, 0xa1, 0x06, 0x45, 0xee, 0xe5, 0x25, 0xd3, 0x41, 0x47, 0xc3, - 0xcf, 0x55, 0xd3, 0x01, 0x4a, 0x82, 0xb3, 0x2d, 0xd3, 0x41, 0x4c, 0x74, - 0x8e, 0x0a, 0xd3, 0x01, 0x46, 0x24, 0xdd, 0x27, 0xd3, 0x41, 0x46, 0xde, - 0xda, 0x12, 0xd3, 0x01, 0x43, 0x20, 0x0b, 0x46, 0xd3, 0x41, 0x47, 0x14, - 0xcf, 0x4d, 0xd3, 0x01, 0x4b, 0x53, 0x52, 0x16, 0xd3, 0x41, 0x48, 0x6b, - 0x58, 0x28, 0xd3, 0x81, 0x12, 0x4c, 0x30, 0x93, 0x2f, 0xd3, 0x01, 0x48, - 0x69, 0xca, 0x32, 0xd3, 0x01, 0x4a, 0xa6, 0xb2, 0x3e, 0xd3, 0x41, 0x43, - 0x08, 0x06, 0x3f, 0xd3, 0x41, 0x46, 0xb8, 0xd9, 0x50, 0xd3, 0x01, 0x45, - 0xc3, 0x01, 0x36, 0xd3, 0x01, 0xaf, 0x11, 0x03, 0x82, 0x16, 0x01, 0xff, - 0x47, 0x11, 0x03, 0x07, 0xd3, 0x01, 0x44, 0x24, 0x24, 0x2b, 0xd3, 0x41, - 0x47, 0x42, 0xc9, 0x18, 0xd3, 0x01, 0x47, 0x22, 0xd6, 0x56, 0xd3, 0x41, - 0x43, 0xb5, 0x35, 0x1c, 0xd3, 0x01, 0x4c, 0xec, 0x91, 0x42, 0xd3, 0x01, - 0xae, 0x0c, 0x47, 0x0a, 0x33, 0x3a, 0xd3, 0x01, 0x49, 0x9d, 0xc1, 0x4a, - 0xd3, 0x41, 0x48, 0xf1, 0xc4, 0x30, 0xd3, 0x01, 0x47, 0x64, 0xd0, 0x1f, - 0xd3, 0x01, 0x49, 0x6d, 0xbb, 0x33, 0xd3, 0x41, 0x48, 0x7d, 0x39, 0x48, - 0xd3, 0x01, 0xa5, 0x28, 0xa9, 0x0c, 0x44, 0x11, 0xf2, 0x43, 0xd3, 0x01, - 0x45, 0x1f, 0xec, 0x20, 0xd3, 0x41, 0x4a, 0x72, 0xaa, 0x54, 0xd3, 0x01, - 0xad, 0x06, 0x48, 0x59, 0xcc, 0x10, 0xd3, 0x41, 0x49, 0xc2, 0xba, 0x3c, - 0xd3, 0x01, 0x44, 0xd1, 0x61, 0x49, 0xd3, 0x41, 0x4a, 0xd8, 0xa8, 0x22, - 0xd3, 0x01, 0x59, 0x1d, 0x24, 0x0f, 0xd3, 0x01, 0x47, 0xd0, 0xb7, 0x47, - 0xd3, 0x41, 0x45, 0x74, 0x02, 0x06, 0xd3, 0x01, 0x45, 0x34, 0xc6, 0x21, - 0xd3, 0x01, 0x03, 0xa3, 0x0d, 0x31, 0xaf, 0x01, 0xff, 0x03, 0xa5, 0x62, - 0x1e, 0xae, 0x01, 0xff, 0x46, 0x36, 0xe0, 0x38, 0xd3, 0x01, 0xb4, 0x01, - 0xff, 0x43, 0xef, 0x0c, 0x15, 0xd3, 0x01, 0x46, 0x20, 0x83, 0x1e, 0xd3, - 0x01, 0x47, 0x49, 0xd5, 0x0b, 0xd3, 0x41, 0x45, 0xa8, 0x62, 0x4e, 0xd3, - 0x01, 0x45, 0x64, 0xc3, 0x52, 0xd3, 0x41, 0xa5, 0x06, 0x43, 0x91, 0x18, - 0x4f, 0xd3, 0x41, 0x47, 0x95, 0x8d, 0x3d, 0xd3, 0x01, 0x44, 0x24, 0x24, - 0x26, 0xd3, 0x41, 0x46, 0x2c, 0x6a, 0x09, 0xd3, 0x01, 0x4e, 0x54, 0x7a, - 0x23, 0xd3, 0x01, 0x4c, 0x44, 0x94, 0x0e, 0xd3, 0x41, 0x4b, 0x13, 0x9a, - 0x41, 0xd3, 0x01, 0x46, 0x2c, 0xdb, 0x19, 0xd3, 0x01, 0x4a, 0xea, 0xaa, - 0x51, 0xd3, 0x01, 0x45, 0x4a, 0x41, 0x0c, 0xd3, 0x41, 0x47, 0x01, 0x97, - 0xb8, 0x20, 0x00, 0x54, 0x7b, 0x44, 0xbe, 0xf3, 0x01, 0xf4, 0xfa, 0x26, - 0x40, 0xa5, 0x90, 0x05, 0x04, 0xf1, 0xf2, 0x01, 0xff, 0xa1, 0xfc, 0x04, - 0x06, 0xef, 0x06, 0xb5, 0x04, 0x0f, 0x72, 0x6d, 0xf7, 0x03, 0x02, 0x68, - 0x00, 0x9c, 0x01, 0x05, 0x5a, 0x03, 0x4e, 0x0b, 0x55, 0x77, 0x01, 0xff, - 0xa1, 0x3b, 0xe5, 0x46, 0x0c, 0x80, 0x32, 0xe9, 0x3f, 0x0c, 0x80, 0x29, - 0xef, 0x4a, 0x0c, 0x80, 0x20, 0xf5, 0x41, 0x0c, 0x80, 0x17, 0x08, 0x43, - 0xc1, 0x01, 0xff, 0xec, 0x62, 0x0c, 0x80, 0x09, 0xf2, 0x43, 0x0c, 0xc0, - 0x00, 0xf2, 0x44, 0x0c, 0x40, 0xec, 0x63, 0x0c, 0x40, 0xf5, 0x42, 0x0c, - 0x40, 0xef, 0x4b, 0x0c, 0x40, 0xe9, 0x40, 0x0c, 0x40, 0xe5, 0x47, 0x0c, - 0x40, 0xe1, 0x3e, 0x0c, 0x00, 0xe9, 0x48, 0x0c, 0x00, 0xf5, 0x4c, 0x0c, - 0x40, 0xa1, 0x3c, 0xa3, 0x23, 0x45, 0x5a, 0x3f, 0x3c, 0x0c, 0x00, 0x47, - 0xf8, 0xd5, 0x77, 0x0c, 0x00, 0x45, 0xc5, 0xeb, 0x7f, 0x0c, 0x00, 0x02, - 0x02, 0x00, 0x01, 0xff, 0x44, 0xe7, 0x23, 0x4d, 0x0c, 0x00, 0x45, 0xf3, - 0x4b, 0x03, 0x0c, 0x40, 0x4a, 0xda, 0x23, 0x01, 0x0c, 0x00, 0x09, 0x33, - 0x16, 0x01, 0xff, 0x4e, 0x3c, 0x16, 0x04, 0x0c, 0x00, 0x51, 0x15, 0x59, - 0x00, 0x0c, 0x40, 0x47, 0x3d, 0x16, 0x02, 0x0c, 0x00, 0x47, 0xc4, 0x88, - 0x3d, 0x0c, 0x40, 0x49, 0x5f, 0x39, 0x55, 0x0c, 0x00, 0x05, 0xee, 0x05, - 0x01, 0xff, 0xe1, 0x05, 0x0c, 0x80, 0xb9, 0x02, 0xa2, 0xac, 0x02, 0xa3, - 0x9f, 0x02, 0xa4, 0x80, 0x02, 0xe5, 0x0e, 0x0c, 0x80, 0xf6, 0x01, 0xa7, - 0xe9, 0x01, 0x42, 0x22, 0x00, 0x39, 0x0c, 0x00, 0xe9, 0x07, 0x0c, 0x80, - 0xd9, 0x01, 0xaa, 0xcc, 0x01, 0xab, 0xbf, 0x01, 0xac, 0xab, 0x01, 0x42, - 0x6c, 0x00, 0x2e, 0x0c, 0x00, 0xae, 0x85, 0x01, 0xef, 0x12, 0x0c, 0x80, - 0x7c, 0xb0, 0x70, 0xb2, 0x5d, 0xb3, 0x4b, 0xb4, 0x2c, 0xf5, 0x09, 0x0c, - 0x80, 0x23, 0xb6, 0x06, 0x42, 0xbe, 0x22, 0x2f, 0x0c, 0x40, 0xe1, 0x35, - 0x0c, 0x00, 0x07, 0x44, 0xc1, 0x01, 0xff, 0xec, 0x0c, 0x0c, 0x80, 0x09, - 0xf2, 0x0b, 0x0c, 0xc0, 0x00, 0xf2, 0x60, 0x0c, 0x40, 0xec, 0x61, 0x0c, - 0x40, 0xf5, 0x0a, 0x0c, 0x40, 0xe1, 0x24, 0x0c, 0x00, 0x42, 0x22, 0x00, - 0x25, 0x0c, 0x00, 0x42, 0x40, 0x06, 0x58, 0x0c, 0x00, 0xb4, 0x01, 0xff, - 0xe1, 0x1f, 0x0c, 0x00, 0x42, 0x22, 0x00, 0x20, 0x0c, 0x40, 0xe1, 0x38, - 0x0c, 0x00, 0x42, 0x22, 0x00, 0x36, 0x0c, 0x00, 0x42, 0x40, 0x06, 0x37, - 0x0c, 0x40, 0xe1, 0x30, 0x0c, 0x00, 0xb2, 0x01, 0xff, 0xe1, 0x31, 0x0c, - 0x00, 0x42, 0x71, 0x00, 0x5a, 0x0c, 0x40, 0xe1, 0x2a, 0x0c, 0x00, 0x42, - 0x22, 0x00, 0x2b, 0x0c, 0x40, 0xef, 0x13, 0x0c, 0x40, 0xe1, 0x28, 0x0c, - 0x80, 0x12, 0x42, 0x24, 0x02, 0x19, 0x0c, 0x00, 0x42, 0x2a, 0x05, 0x23, - 0x0c, 0x00, 0x42, 0xbe, 0x22, 0x1e, 0x0c, 0x40, 0x4b, 0x1d, 0x9e, 0x5d, - 0x0c, 0x40, 0xe1, 0x32, 0x0c, 0x00, 0xac, 0x01, 0xff, 0xe1, 0x33, 0x0c, - 0x00, 0x42, 0x74, 0x00, 0x34, 0x0c, 0x40, 0xe1, 0x15, 0x0c, 0x00, 0x42, - 0x22, 0x00, 0x16, 0x0c, 0x40, 0xe1, 0x1c, 0x0c, 0x00, 0x42, 0x22, 0x00, - 0x1d, 0x0c, 0x40, 0xe9, 0x08, 0x0c, 0x40, 0xe1, 0x17, 0x0c, 0x00, 0x42, - 0x22, 0x00, 0x18, 0x0c, 0x40, 0xe5, 0x0f, 0x0c, 0x40, 0xe1, 0x26, 0x0c, - 0x00, 0xa4, 0x0c, 0x42, 0x22, 0x00, 0x27, 0x0c, 0x00, 0x42, 0x59, 0x00, - 0x59, 0x0c, 0x40, 0xe1, 0x21, 0x0c, 0x00, 0x42, 0x22, 0x00, 0x22, 0x0c, - 0x40, 0xe1, 0x1a, 0x0c, 0x00, 0x42, 0x22, 0x00, 0x1b, 0x0c, 0x40, 0xe1, - 0x2c, 0x0c, 0x00, 0x42, 0x22, 0x00, 0x2d, 0x0c, 0x40, 0xe1, 0x06, 0x0c, - 0x00, 0xe9, 0x10, 0x0c, 0x00, 0xf5, 0x14, 0x0c, 0x40, 0x08, 0x71, 0xc9, - 0x29, 0xb4, 0x06, 0x5b, 0x5f, 0x1e, 0x78, 0x0c, 0x40, 0x09, 0xea, 0xb9, - 0x11, 0x07, 0xaa, 0xd7, 0x01, 0xff, 0x53, 0x5f, 0x49, 0x7d, 0x0c, 0x00, - 0x52, 0x68, 0x1e, 0x7a, 0x0c, 0x40, 0x53, 0x5f, 0x49, 0x7e, 0x0c, 0x00, - 0x52, 0x68, 0x1e, 0x7b, 0x0c, 0x40, 0x53, 0x5f, 0x49, 0x7c, 0x0c, 0x00, - 0x52, 0x68, 0x1e, 0x79, 0x0c, 0x40, 0x45, 0x12, 0x0b, 0x6e, 0x0c, 0x00, - 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x6f, 0x0c, 0x00, 0x43, 0x0e, 0x0b, 0x67, - 0x0c, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x66, 0x0c, 0x40, - 0x44, 0x25, 0x01, 0x69, 0x0c, 0x00, 0x42, 0x15, 0x02, 0x68, 0x0c, 0x40, - 0x44, 0xe5, 0x1d, 0x6d, 0x0c, 0x00, 0x42, 0x1c, 0x26, 0x6c, 0x0c, 0x40, - 0x43, 0xd2, 0x05, 0x6b, 0x0c, 0x00, 0x43, 0xf6, 0x06, 0x6a, 0x0c, 0x40, - 0x4d, 0xeb, 0x83, 0x56, 0x0c, 0x00, 0x4c, 0x5c, 0x94, 0x5c, 0x0c, 0x40, - 0x06, 0x35, 0x3d, 0x0c, 0x45, 0xa4, 0xcb, 0x2d, 0xf5, 0x01, 0x46, 0xdf, - 0x32, 0xfa, 0xf4, 0x41, 0x4d, 0x3d, 0x85, 0x06, 0x27, 0x00, 0x4f, 0x32, - 0x71, 0x80, 0xf5, 0x01, 0x03, 0x89, 0x0d, 0x06, 0x44, 0x5a, 0x03, 0x21, - 0x21, 0x40, 0x45, 0x3e, 0x3d, 0xde, 0xf4, 0x81, 0x06, 0x45, 0x36, 0x89, - 0x15, 0x23, 0x40, 0x4a, 0x94, 0xa6, 0x7c, 0xf5, 0x41, 0x52, 0xfc, 0x50, - 0x75, 0xf3, 0x01, 0x43, 0x1b, 0x45, 0xd6, 0xfa, 0x01, 0xb2, 0x01, 0xff, - 0x4d, 0x29, 0x80, 0xc6, 0xf4, 0x01, 0x05, 0x26, 0x0d, 0x01, 0xff, 0x57, - 0xe9, 0x2d, 0xba, 0x27, 0x00, 0x4f, 0xf1, 0x1c, 0x3b, 0x27, 0x40, 0xe2, - 0x09, 0x00, 0x80, 0xc8, 0x40, 0x42, 0x13, 0x05, 0x2e, 0xf3, 0x01, 0xa7, - 0xa3, 0x3a, 0x02, 0xf1, 0x03, 0x93, 0x2c, 0xab, 0xe7, 0x28, 0x09, 0xd5, - 0xa7, 0xd6, 0x28, 0xad, 0x99, 0x22, 0xae, 0x1c, 0x03, 0x3f, 0x31, 0x0c, - 0x44, 0x05, 0xf3, 0x49, 0x26, 0x00, 0x42, 0xe2, 0x0c, 0x95, 0xf6, 0x41, - 0x49, 0x3e, 0xb7, 0xad, 0xf5, 0x01, 0x45, 0x96, 0xd7, 0x07, 0x27, 0x40, - 0x4a, 0x70, 0xa7, 0x8b, 0xf3, 0x01, 0xa7, 0x01, 0xff, 0x45, 0x34, 0xe6, - 0x4a, 0xf3, 0x01, 0x03, 0x86, 0x41, 0xef, 0x1d, 0x03, 0x6b, 0x0d, 0x01, - 0xff, 0x0a, 0xf6, 0xa8, 0x0f, 0xa9, 0x01, 0xff, 0x49, 0xd8, 0x27, 0x03, - 0xd8, 0x00, 0x4d, 0x5b, 0x20, 0xe0, 0x6f, 0x41, 0x90, 0xad, 0x1a, 0x91, - 0xff, 0x16, 0x92, 0xd1, 0x13, 0x93, 0xa3, 0x10, 0x94, 0xf5, 0x0c, 0x95, - 0xc7, 0x09, 0x96, 0x99, 0x06, 0x97, 0xeb, 0x02, 0x98, 0x01, 0xff, 0x90, - 0xbd, 0x02, 0x91, 0x92, 0x02, 0x92, 0xe7, 0x01, 0x93, 0xbc, 0x01, 0x94, - 0x91, 0x01, 0x95, 0x67, 0x96, 0x3d, 0x97, 0x13, 0x98, 0x01, 0xff, 0xd0, - 0xef, 0x8d, 0x01, 0xd1, 0xf0, 0x8d, 0x01, 0xd2, 0xf1, 0x8d, 0x01, 0xd3, - 0xf2, 0x8d, 0x41, 0xd0, 0xe5, 0x8d, 0x01, 0xd1, 0xe6, 0x8d, 0x01, 0xd2, - 0xe7, 0x8d, 0x01, 0xd3, 0xe8, 0x8d, 0x01, 0xd4, 0xe9, 0x8d, 0x01, 0xd5, - 0xea, 0x8d, 0x01, 0xd6, 0xeb, 0x8d, 0x01, 0xd7, 0xec, 0x8d, 0x01, 0xd8, - 0xed, 0x8d, 0x01, 0xd9, 0xee, 0x8d, 0x41, 0xd0, 0xdb, 0x8d, 0x01, 0xd1, - 0xdc, 0x8d, 0x01, 0xd2, 0xdd, 0x8d, 0x01, 0xd3, 0xde, 0x8d, 0x01, 0xd4, - 0xdf, 0x8d, 0x01, 0xd5, 0xe0, 0x8d, 0x01, 0xd6, 0xe1, 0x8d, 0x01, 0xd7, - 0xe2, 0x8d, 0x01, 0xd8, 0xe3, 0x8d, 0x01, 0xd9, 0xe4, 0x8d, 0x41, 0xd0, - 0xd1, 0x8d, 0x01, 0xd1, 0xd2, 0x8d, 0x01, 0xd2, 0xd3, 0x8d, 0x01, 0xd3, - 0xd4, 0x8d, 0x01, 0xd4, 0xd5, 0x8d, 0x01, 0xd5, 0xd6, 0x8d, 0x01, 0xd6, - 0xd7, 0x8d, 0x01, 0xd7, 0xd8, 0x8d, 0x01, 0xd8, 0xd9, 0x8d, 0x01, 0xd9, - 0xda, 0x8d, 0x41, 0xd0, 0xc7, 0x8d, 0x01, 0xd1, 0xc8, 0x8d, 0x01, 0xd2, - 0xc9, 0x8d, 0x01, 0xd3, 0xca, 0x8d, 0x01, 0xd4, 0xcb, 0x8d, 0x01, 0xd5, - 0xcc, 0x8d, 0x01, 0xd6, 0xcd, 0x8d, 0x01, 0xd7, 0xce, 0x8d, 0x01, 0xd8, - 0xcf, 0x8d, 0x01, 0xd9, 0xd0, 0x8d, 0x41, 0xd0, 0xbd, 0x8d, 0x01, 0xd1, - 0xbe, 0x8d, 0x01, 0xd2, 0xbf, 0x8d, 0x01, 0xd3, 0xc0, 0x8d, 0x01, 0xd4, - 0xc1, 0x8d, 0x01, 0xd5, 0xc2, 0x8d, 0x01, 0xd6, 0xc3, 0x8d, 0x01, 0xd7, - 0xc4, 0x8d, 0x01, 0xd8, 0xc5, 0x8d, 0x01, 0xd9, 0xc6, 0x8d, 0x41, 0xd0, - 0xb3, 0x8d, 0x01, 0xd1, 0xb4, 0x8d, 0x01, 0xd2, 0xb5, 0x8d, 0x01, 0xd3, - 0xb6, 0x8d, 0x01, 0xd4, 0xb7, 0x8d, 0x01, 0xd5, 0xb8, 0x8d, 0x01, 0xd6, - 0xb9, 0x8d, 0x01, 0xd7, 0xba, 0x8d, 0x01, 0xd8, 0xbb, 0x8d, 0x01, 0xd9, - 0xbc, 0x8d, 0x41, 0xd0, 0xa9, 0x8d, 0x01, 0xd1, 0xaa, 0x8d, 0x01, 0xd2, - 0xab, 0x8d, 0x01, 0xd3, 0xac, 0x8d, 0x01, 0xd4, 0xad, 0x8d, 0x01, 0xd5, - 0xae, 0x8d, 0x01, 0xd6, 0xaf, 0x8d, 0x01, 0xd7, 0xb0, 0x8d, 0x01, 0xd8, - 0xb1, 0x8d, 0x01, 0xd9, 0xb2, 0x8d, 0x41, 0xd0, 0x9f, 0x8d, 0x01, 0xd1, - 0xa0, 0x8d, 0x01, 0xd2, 0xa1, 0x8d, 0x01, 0xd3, 0xa2, 0x8d, 0x01, 0xd4, - 0xa3, 0x8d, 0x01, 0xd5, 0xa4, 0x8d, 0x01, 0xd6, 0xa5, 0x8d, 0x01, 0xd7, - 0xa6, 0x8d, 0x01, 0xd8, 0xa7, 0x8d, 0x01, 0xd9, 0xa8, 0x8d, 0x41, 0x90, - 0x80, 0x03, 0x91, 0xd5, 0x02, 0x92, 0xaa, 0x02, 0x93, 0xff, 0x01, 0x94, - 0xd4, 0x01, 0x95, 0xa9, 0x01, 0x96, 0x7f, 0x97, 0x55, 0x98, 0x2b, 0x99, - 0x01, 0xff, 0xd0, 0x95, 0x8d, 0x01, 0xd1, 0x96, 0x8d, 0x01, 0xd2, 0x97, - 0x8d, 0x01, 0xd3, 0x98, 0x8d, 0x01, 0xd4, 0x99, 0x8d, 0x01, 0xd5, 0x9a, - 0x8d, 0x01, 0xd6, 0x9b, 0x8d, 0x01, 0xd7, 0x9c, 0x8d, 0x01, 0xd8, 0x9d, - 0x8d, 0x01, 0xd9, 0x9e, 0x8d, 0x41, 0xd0, 0x8b, 0x8d, 0x01, 0xd1, 0x8c, - 0x8d, 0x01, 0xd2, 0x8d, 0x8d, 0x01, 0xd3, 0x8e, 0x8d, 0x01, 0xd4, 0x8f, - 0x8d, 0x01, 0xd5, 0x90, 0x8d, 0x01, 0xd6, 0x91, 0x8d, 0x01, 0xd7, 0x92, - 0x8d, 0x01, 0xd8, 0x93, 0x8d, 0x01, 0xd9, 0x94, 0x8d, 0x41, 0xd0, 0x81, - 0x8d, 0x01, 0xd1, 0x82, 0x8d, 0x01, 0xd2, 0x83, 0x8d, 0x01, 0xd3, 0x84, - 0x8d, 0x01, 0xd4, 0x85, 0x8d, 0x01, 0xd5, 0x86, 0x8d, 0x01, 0xd6, 0x87, - 0x8d, 0x01, 0xd7, 0x88, 0x8d, 0x01, 0xd8, 0x89, 0x8d, 0x01, 0xd9, 0x8a, - 0x8d, 0x41, 0xd0, 0xf7, 0x8a, 0x01, 0xd1, 0xf8, 0x8a, 0x01, 0xd2, 0xf9, - 0x8a, 0x01, 0xd3, 0xfa, 0x8a, 0x01, 0xd4, 0xfb, 0x8a, 0x01, 0xd5, 0xfc, - 0x8a, 0x01, 0xd6, 0xfd, 0x8a, 0x01, 0xd7, 0xfe, 0x8a, 0x01, 0xd8, 0xff, - 0x8a, 0x01, 0xd9, 0x80, 0x8d, 0x41, 0xd0, 0xed, 0x8a, 0x01, 0xd1, 0xee, - 0x8a, 0x01, 0xd2, 0xef, 0x8a, 0x01, 0xd3, 0xf0, 0x8a, 0x01, 0xd4, 0xf1, - 0x8a, 0x01, 0xd5, 0xf2, 0x8a, 0x01, 0xd6, 0xf3, 0x8a, 0x01, 0xd7, 0xf4, - 0x8a, 0x01, 0xd8, 0xf5, 0x8a, 0x01, 0xd9, 0xf6, 0x8a, 0x41, 0xd0, 0xe3, - 0x8a, 0x01, 0xd1, 0xe4, 0x8a, 0x01, 0xd2, 0xe5, 0x8a, 0x01, 0xd3, 0xe6, - 0x8a, 0x01, 0xd4, 0xe7, 0x8a, 0x01, 0xd5, 0xe8, 0x8a, 0x01, 0xd6, 0xe9, - 0x8a, 0x01, 0xd7, 0xea, 0x8a, 0x01, 0xd8, 0xeb, 0x8a, 0x01, 0xd9, 0xec, - 0x8a, 0x41, 0xd0, 0xd9, 0x8a, 0x01, 0xd1, 0xda, 0x8a, 0x01, 0xd2, 0xdb, - 0x8a, 0x01, 0xd3, 0xdc, 0x8a, 0x01, 0xd4, 0xdd, 0x8a, 0x01, 0xd5, 0xde, - 0x8a, 0x01, 0xd6, 0xdf, 0x8a, 0x01, 0xd7, 0xe0, 0x8a, 0x01, 0xd8, 0xe1, - 0x8a, 0x01, 0xd9, 0xe2, 0x8a, 0x41, 0xd0, 0xcf, 0x8a, 0x01, 0xd1, 0xd0, - 0x8a, 0x01, 0xd2, 0xd1, 0x8a, 0x01, 0xd3, 0xd2, 0x8a, 0x01, 0xd4, 0xd3, - 0x8a, 0x01, 0xd5, 0xd4, 0x8a, 0x01, 0xd6, 0xd5, 0x8a, 0x01, 0xd7, 0xd6, - 0x8a, 0x01, 0xd8, 0xd7, 0x8a, 0x01, 0xd9, 0xd8, 0x8a, 0x41, 0xd0, 0xc5, - 0x8a, 0x01, 0xd1, 0xc6, 0x8a, 0x01, 0xd2, 0xc7, 0x8a, 0x01, 0xd3, 0xc8, - 0x8a, 0x01, 0xd4, 0xc9, 0x8a, 0x01, 0xd5, 0xca, 0x8a, 0x01, 0xd6, 0xcb, - 0x8a, 0x01, 0xd7, 0xcc, 0x8a, 0x01, 0xd8, 0xcd, 0x8a, 0x01, 0xd9, 0xce, - 0x8a, 0x41, 0xd0, 0xbb, 0x8a, 0x01, 0xd1, 0xbc, 0x8a, 0x01, 0xd2, 0xbd, - 0x8a, 0x01, 0xd3, 0xbe, 0x8a, 0x01, 0xd4, 0xbf, 0x8a, 0x01, 0xd5, 0xc0, - 0x8a, 0x01, 0xd6, 0xc1, 0x8a, 0x01, 0xd7, 0xc2, 0x8a, 0x01, 0xd8, 0xc3, - 0x8a, 0x01, 0xd9, 0xc4, 0x8a, 0x41, 0x90, 0x80, 0x03, 0x91, 0xd5, 0x02, - 0x92, 0xaa, 0x02, 0x93, 0xff, 0x01, 0x94, 0xd4, 0x01, 0x95, 0xa9, 0x01, - 0x96, 0x7f, 0x97, 0x55, 0x98, 0x2b, 0x99, 0x01, 0xff, 0xd0, 0xb1, 0x8a, - 0x01, 0xd1, 0xb2, 0x8a, 0x01, 0xd2, 0xb3, 0x8a, 0x01, 0xd3, 0xb4, 0x8a, - 0x01, 0xd4, 0xb5, 0x8a, 0x01, 0xd5, 0xb6, 0x8a, 0x01, 0xd6, 0xb7, 0x8a, - 0x01, 0xd7, 0xb8, 0x8a, 0x01, 0xd8, 0xb9, 0x8a, 0x01, 0xd9, 0xba, 0x8a, - 0x41, 0xd0, 0xa7, 0x8a, 0x01, 0xd1, 0xa8, 0x8a, 0x01, 0xd2, 0xa9, 0x8a, - 0x01, 0xd3, 0xaa, 0x8a, 0x01, 0xd4, 0xab, 0x8a, 0x01, 0xd5, 0xac, 0x8a, - 0x01, 0xd6, 0xad, 0x8a, 0x01, 0xd7, 0xae, 0x8a, 0x01, 0xd8, 0xaf, 0x8a, - 0x01, 0xd9, 0xb0, 0x8a, 0x41, 0xd0, 0x9d, 0x8a, 0x01, 0xd1, 0x9e, 0x8a, - 0x01, 0xd2, 0x9f, 0x8a, 0x01, 0xd3, 0xa0, 0x8a, 0x01, 0xd4, 0xa1, 0x8a, - 0x01, 0xd5, 0xa2, 0x8a, 0x01, 0xd6, 0xa3, 0x8a, 0x01, 0xd7, 0xa4, 0x8a, - 0x01, 0xd8, 0xa5, 0x8a, 0x01, 0xd9, 0xa6, 0x8a, 0x41, 0xd0, 0x93, 0x8a, - 0x01, 0xd1, 0x94, 0x8a, 0x01, 0xd2, 0x95, 0x8a, 0x01, 0xd3, 0x96, 0x8a, - 0x01, 0xd4, 0x97, 0x8a, 0x01, 0xd5, 0x98, 0x8a, 0x01, 0xd6, 0x99, 0x8a, - 0x01, 0xd7, 0x9a, 0x8a, 0x01, 0xd8, 0x9b, 0x8a, 0x01, 0xd9, 0x9c, 0x8a, - 0x41, 0xd0, 0x89, 0x8a, 0x01, 0xd1, 0x8a, 0x8a, 0x01, 0xd2, 0x8b, 0x8a, - 0x01, 0xd3, 0x8c, 0x8a, 0x01, 0xd4, 0x8d, 0x8a, 0x01, 0xd5, 0x8e, 0x8a, - 0x01, 0xd6, 0x8f, 0x8a, 0x01, 0xd7, 0x90, 0x8a, 0x01, 0xd8, 0x91, 0x8a, - 0x01, 0xd9, 0x92, 0x8a, 0x41, 0xd0, 0x7f, 0x8a, 0x01, 0xd1, 0x80, 0x8a, - 0x01, 0xd2, 0x81, 0x8a, 0x01, 0xd3, 0x82, 0x8a, 0x01, 0xd4, 0x83, 0x8a, - 0x01, 0xd5, 0x84, 0x8a, 0x01, 0xd6, 0x85, 0x8a, 0x01, 0xd7, 0x86, 0x8a, - 0x01, 0xd8, 0x87, 0x8a, 0x01, 0xd9, 0x88, 0x8a, 0x41, 0xd0, 0x75, 0x8a, - 0x01, 0xd1, 0x76, 0x8a, 0x01, 0xd2, 0x77, 0x8a, 0x01, 0xd3, 0x78, 0x8a, - 0x01, 0xd4, 0x79, 0x8a, 0x01, 0xd5, 0x7a, 0x8a, 0x01, 0xd6, 0x7b, 0x8a, - 0x01, 0xd7, 0x7c, 0x8a, 0x01, 0xd8, 0x7d, 0x8a, 0x01, 0xd9, 0x7e, 0x8a, - 0x41, 0xd0, 0x6b, 0x8a, 0x01, 0xd1, 0x6c, 0x8a, 0x01, 0xd2, 0x6d, 0x8a, - 0x01, 0xd3, 0x6e, 0x8a, 0x01, 0xd4, 0x6f, 0x8a, 0x01, 0xd5, 0x70, 0x8a, - 0x01, 0xd6, 0x71, 0x8a, 0x01, 0xd7, 0x72, 0x8a, 0x01, 0xd8, 0x73, 0x8a, - 0x01, 0xd9, 0x74, 0x8a, 0x41, 0xd0, 0x61, 0x8a, 0x01, 0xd1, 0x62, 0x8a, - 0x01, 0xd2, 0x63, 0x8a, 0x01, 0xd3, 0x64, 0x8a, 0x01, 0xd4, 0x65, 0x8a, - 0x01, 0xd5, 0x66, 0x8a, 0x01, 0xd6, 0x67, 0x8a, 0x01, 0xd7, 0x68, 0x8a, - 0x01, 0xd8, 0x69, 0x8a, 0x01, 0xd9, 0x6a, 0x8a, 0x41, 0xd0, 0x57, 0x8a, - 0x01, 0xd1, 0x58, 0x8a, 0x01, 0xd2, 0x59, 0x8a, 0x01, 0xd3, 0x5a, 0x8a, - 0x01, 0xd4, 0x5b, 0x8a, 0x01, 0xd5, 0x5c, 0x8a, 0x01, 0xd6, 0x5d, 0x8a, - 0x01, 0xd7, 0x5e, 0x8a, 0x01, 0xd8, 0x5f, 0x8a, 0x01, 0xd9, 0x60, 0x8a, - 0x41, 0x90, 0x80, 0x03, 0x91, 0xd5, 0x02, 0x92, 0xaa, 0x02, 0x93, 0xff, - 0x01, 0x94, 0xd4, 0x01, 0x95, 0xa9, 0x01, 0x96, 0x7f, 0x97, 0x55, 0x98, - 0x2b, 0x99, 0x01, 0xff, 0xd0, 0x4d, 0x8a, 0x01, 0xd1, 0x4e, 0x8a, 0x01, - 0xd2, 0x4f, 0x8a, 0x01, 0xd3, 0x50, 0x8a, 0x01, 0xd4, 0x51, 0x8a, 0x01, - 0xd5, 0x52, 0x8a, 0x01, 0xd6, 0x53, 0x8a, 0x01, 0xd7, 0x54, 0x8a, 0x01, - 0xd8, 0x55, 0x8a, 0x01, 0xd9, 0x56, 0x8a, 0x41, 0xd0, 0x43, 0x8a, 0x01, - 0xd1, 0x44, 0x8a, 0x01, 0xd2, 0x45, 0x8a, 0x01, 0xd3, 0x46, 0x8a, 0x01, - 0xd4, 0x47, 0x8a, 0x01, 0xd5, 0x48, 0x8a, 0x01, 0xd6, 0x49, 0x8a, 0x01, - 0xd7, 0x4a, 0x8a, 0x01, 0xd8, 0x4b, 0x8a, 0x01, 0xd9, 0x4c, 0x8a, 0x41, - 0xd0, 0x39, 0x8a, 0x01, 0xd1, 0x3a, 0x8a, 0x01, 0xd2, 0x3b, 0x8a, 0x01, - 0xd3, 0x3c, 0x8a, 0x01, 0xd4, 0x3d, 0x8a, 0x01, 0xd5, 0x3e, 0x8a, 0x01, - 0xd6, 0x3f, 0x8a, 0x01, 0xd7, 0x40, 0x8a, 0x01, 0xd8, 0x41, 0x8a, 0x01, - 0xd9, 0x42, 0x8a, 0x41, 0xd0, 0x2f, 0x8a, 0x01, 0xd1, 0x30, 0x8a, 0x01, - 0xd2, 0x31, 0x8a, 0x01, 0xd3, 0x32, 0x8a, 0x01, 0xd4, 0x33, 0x8a, 0x01, - 0xd5, 0x34, 0x8a, 0x01, 0xd6, 0x35, 0x8a, 0x01, 0xd7, 0x36, 0x8a, 0x01, - 0xd8, 0x37, 0x8a, 0x01, 0xd9, 0x38, 0x8a, 0x41, 0xd0, 0x25, 0x8a, 0x01, - 0xd1, 0x26, 0x8a, 0x01, 0xd2, 0x27, 0x8a, 0x01, 0xd3, 0x28, 0x8a, 0x01, - 0xd4, 0x29, 0x8a, 0x01, 0xd5, 0x2a, 0x8a, 0x01, 0xd6, 0x2b, 0x8a, 0x01, - 0xd7, 0x2c, 0x8a, 0x01, 0xd8, 0x2d, 0x8a, 0x01, 0xd9, 0x2e, 0x8a, 0x41, - 0xd0, 0x1b, 0x8a, 0x01, 0xd1, 0x1c, 0x8a, 0x01, 0xd2, 0x1d, 0x8a, 0x01, - 0xd3, 0x1e, 0x8a, 0x01, 0xd4, 0x1f, 0x8a, 0x01, 0xd5, 0x20, 0x8a, 0x01, - 0xd6, 0x21, 0x8a, 0x01, 0xd7, 0x22, 0x8a, 0x01, 0xd8, 0x23, 0x8a, 0x01, - 0xd9, 0x24, 0x8a, 0x41, 0xd0, 0x11, 0x8a, 0x01, 0xd1, 0x12, 0x8a, 0x01, - 0xd2, 0x13, 0x8a, 0x01, 0xd3, 0x14, 0x8a, 0x01, 0xd4, 0x15, 0x8a, 0x01, - 0xd5, 0x16, 0x8a, 0x01, 0xd6, 0x17, 0x8a, 0x01, 0xd7, 0x18, 0x8a, 0x01, - 0xd8, 0x19, 0x8a, 0x01, 0xd9, 0x1a, 0x8a, 0x41, 0xd0, 0x07, 0x8a, 0x01, - 0xd1, 0x08, 0x8a, 0x01, 0xd2, 0x09, 0x8a, 0x01, 0xd3, 0x0a, 0x8a, 0x01, - 0xd4, 0x0b, 0x8a, 0x01, 0xd5, 0x0c, 0x8a, 0x01, 0xd6, 0x0d, 0x8a, 0x01, - 0xd7, 0x0e, 0x8a, 0x01, 0xd8, 0x0f, 0x8a, 0x01, 0xd9, 0x10, 0x8a, 0x41, - 0xd0, 0xfd, 0x89, 0x01, 0xd1, 0xfe, 0x89, 0x01, 0xd2, 0xff, 0x89, 0x01, - 0xd3, 0x00, 0x8a, 0x01, 0xd4, 0x01, 0x8a, 0x01, 0xd5, 0x02, 0x8a, 0x01, - 0xd6, 0x03, 0x8a, 0x01, 0xd7, 0x04, 0x8a, 0x01, 0xd8, 0x05, 0x8a, 0x01, - 0xd9, 0x06, 0x8a, 0x41, 0xd0, 0xf3, 0x89, 0x01, 0xd1, 0xf4, 0x89, 0x01, - 0xd2, 0xf5, 0x89, 0x01, 0xd3, 0xf6, 0x89, 0x01, 0xd4, 0xf7, 0x89, 0x01, - 0xd5, 0xf8, 0x89, 0x01, 0xd6, 0xf9, 0x89, 0x01, 0xd7, 0xfa, 0x89, 0x01, - 0xd8, 0xfb, 0x89, 0x01, 0xd9, 0xfc, 0x89, 0x41, 0x90, 0x80, 0x03, 0x91, - 0xd5, 0x02, 0x92, 0xaa, 0x02, 0x93, 0xff, 0x01, 0x94, 0xd4, 0x01, 0x95, - 0xa9, 0x01, 0x96, 0x7f, 0x97, 0x55, 0x98, 0x2b, 0x99, 0x01, 0xff, 0xd0, - 0xe9, 0x89, 0x01, 0xd1, 0xea, 0x89, 0x01, 0xd2, 0xeb, 0x89, 0x01, 0xd3, - 0xec, 0x89, 0x01, 0xd4, 0xed, 0x89, 0x01, 0xd5, 0xee, 0x89, 0x01, 0xd6, - 0xef, 0x89, 0x01, 0xd7, 0xf0, 0x89, 0x01, 0xd8, 0xf1, 0x89, 0x01, 0xd9, - 0xf2, 0x89, 0x41, 0xd0, 0xdf, 0x89, 0x01, 0xd1, 0xe0, 0x89, 0x01, 0xd2, - 0xe1, 0x89, 0x01, 0xd3, 0xe2, 0x89, 0x01, 0xd4, 0xe3, 0x89, 0x01, 0xd5, - 0xe4, 0x89, 0x01, 0xd6, 0xe5, 0x89, 0x01, 0xd7, 0xe6, 0x89, 0x01, 0xd8, - 0xe7, 0x89, 0x01, 0xd9, 0xe8, 0x89, 0x41, 0xd0, 0xd5, 0x89, 0x01, 0xd1, - 0xd6, 0x89, 0x01, 0xd2, 0xd7, 0x89, 0x01, 0xd3, 0xd8, 0x89, 0x01, 0xd4, - 0xd9, 0x89, 0x01, 0xd5, 0xda, 0x89, 0x01, 0xd6, 0xdb, 0x89, 0x01, 0xd7, - 0xdc, 0x89, 0x01, 0xd8, 0xdd, 0x89, 0x01, 0xd9, 0xde, 0x89, 0x41, 0xd0, - 0xcb, 0x89, 0x01, 0xd1, 0xcc, 0x89, 0x01, 0xd2, 0xcd, 0x89, 0x01, 0xd3, - 0xce, 0x89, 0x01, 0xd4, 0xcf, 0x89, 0x01, 0xd5, 0xd0, 0x89, 0x01, 0xd6, - 0xd1, 0x89, 0x01, 0xd7, 0xd2, 0x89, 0x01, 0xd8, 0xd3, 0x89, 0x01, 0xd9, - 0xd4, 0x89, 0x41, 0xd0, 0xc1, 0x89, 0x01, 0xd1, 0xc2, 0x89, 0x01, 0xd2, - 0xc3, 0x89, 0x01, 0xd3, 0xc4, 0x89, 0x01, 0xd4, 0xc5, 0x89, 0x01, 0xd5, - 0xc6, 0x89, 0x01, 0xd6, 0xc7, 0x89, 0x01, 0xd7, 0xc8, 0x89, 0x01, 0xd8, - 0xc9, 0x89, 0x01, 0xd9, 0xca, 0x89, 0x41, 0xd0, 0xb7, 0x89, 0x01, 0xd1, - 0xb8, 0x89, 0x01, 0xd2, 0xb9, 0x89, 0x01, 0xd3, 0xba, 0x89, 0x01, 0xd4, - 0xbb, 0x89, 0x01, 0xd5, 0xbc, 0x89, 0x01, 0xd6, 0xbd, 0x89, 0x01, 0xd7, - 0xbe, 0x89, 0x01, 0xd8, 0xbf, 0x89, 0x01, 0xd9, 0xc0, 0x89, 0x41, 0xd0, - 0xad, 0x89, 0x01, 0xd1, 0xae, 0x89, 0x01, 0xd2, 0xaf, 0x89, 0x01, 0xd3, - 0xb0, 0x89, 0x01, 0xd4, 0xb1, 0x89, 0x01, 0xd5, 0xb2, 0x89, 0x01, 0xd6, - 0xb3, 0x89, 0x01, 0xd7, 0xb4, 0x89, 0x01, 0xd8, 0xb5, 0x89, 0x01, 0xd9, - 0xb6, 0x89, 0x41, 0xd0, 0xa3, 0x89, 0x01, 0xd1, 0xa4, 0x89, 0x01, 0xd2, - 0xa5, 0x89, 0x01, 0xd3, 0xa6, 0x89, 0x01, 0xd4, 0xa7, 0x89, 0x01, 0xd5, - 0xa8, 0x89, 0x01, 0xd6, 0xa9, 0x89, 0x01, 0xd7, 0xaa, 0x89, 0x01, 0xd8, - 0xab, 0x89, 0x01, 0xd9, 0xac, 0x89, 0x41, 0xd0, 0x99, 0x89, 0x01, 0xd1, - 0x9a, 0x89, 0x01, 0xd2, 0x9b, 0x89, 0x01, 0xd3, 0x9c, 0x89, 0x01, 0xd4, - 0x9d, 0x89, 0x01, 0xd5, 0x9e, 0x89, 0x01, 0xd6, 0x9f, 0x89, 0x01, 0xd7, - 0xa0, 0x89, 0x01, 0xd8, 0xa1, 0x89, 0x01, 0xd9, 0xa2, 0x89, 0x41, 0xd0, - 0x8f, 0x89, 0x01, 0xd1, 0x90, 0x89, 0x01, 0xd2, 0x91, 0x89, 0x01, 0xd3, - 0x92, 0x89, 0x01, 0xd4, 0x93, 0x89, 0x01, 0xd5, 0x94, 0x89, 0x01, 0xd6, - 0x95, 0x89, 0x01, 0xd7, 0x96, 0x89, 0x01, 0xd8, 0x97, 0x89, 0x01, 0xd9, - 0x98, 0x89, 0x41, 0x90, 0x80, 0x03, 0x91, 0xd5, 0x02, 0x92, 0xaa, 0x02, - 0x93, 0xff, 0x01, 0x94, 0xd4, 0x01, 0x95, 0xa9, 0x01, 0x96, 0x7f, 0x97, - 0x55, 0x98, 0x2b, 0x99, 0x01, 0xff, 0xd0, 0x85, 0x89, 0x01, 0xd1, 0x86, - 0x89, 0x01, 0xd2, 0x87, 0x89, 0x01, 0xd3, 0x88, 0x89, 0x01, 0xd4, 0x89, - 0x89, 0x01, 0xd5, 0x8a, 0x89, 0x01, 0xd6, 0x8b, 0x89, 0x01, 0xd7, 0x8c, - 0x89, 0x01, 0xd8, 0x8d, 0x89, 0x01, 0xd9, 0x8e, 0x89, 0x41, 0xd0, 0x7b, - 0x89, 0x01, 0xd1, 0x7c, 0x89, 0x01, 0xd2, 0x7d, 0x89, 0x01, 0xd3, 0x7e, - 0x89, 0x01, 0xd4, 0x7f, 0x89, 0x01, 0xd5, 0x80, 0x89, 0x01, 0xd6, 0x81, - 0x89, 0x01, 0xd7, 0x82, 0x89, 0x01, 0xd8, 0x83, 0x89, 0x01, 0xd9, 0x84, - 0x89, 0x41, 0xd0, 0x71, 0x89, 0x01, 0xd1, 0x72, 0x89, 0x01, 0xd2, 0x73, - 0x89, 0x01, 0xd3, 0x74, 0x89, 0x01, 0xd4, 0x75, 0x89, 0x01, 0xd5, 0x76, - 0x89, 0x01, 0xd6, 0x77, 0x89, 0x01, 0xd7, 0x78, 0x89, 0x01, 0xd8, 0x79, - 0x89, 0x01, 0xd9, 0x7a, 0x89, 0x41, 0xd0, 0x67, 0x89, 0x01, 0xd1, 0x68, - 0x89, 0x01, 0xd2, 0x69, 0x89, 0x01, 0xd3, 0x6a, 0x89, 0x01, 0xd4, 0x6b, - 0x89, 0x01, 0xd5, 0x6c, 0x89, 0x01, 0xd6, 0x6d, 0x89, 0x01, 0xd7, 0x6e, - 0x89, 0x01, 0xd8, 0x6f, 0x89, 0x01, 0xd9, 0x70, 0x89, 0x41, 0xd0, 0x5d, - 0x89, 0x01, 0xd1, 0x5e, 0x89, 0x01, 0xd2, 0x5f, 0x89, 0x01, 0xd3, 0x60, - 0x89, 0x01, 0xd4, 0x61, 0x89, 0x01, 0xd5, 0x62, 0x89, 0x01, 0xd6, 0x63, - 0x89, 0x01, 0xd7, 0x64, 0x89, 0x01, 0xd8, 0x65, 0x89, 0x01, 0xd9, 0x66, - 0x89, 0x41, 0xd0, 0x53, 0x89, 0x01, 0xd1, 0x54, 0x89, 0x01, 0xd2, 0x55, - 0x89, 0x01, 0xd3, 0x56, 0x89, 0x01, 0xd4, 0x57, 0x89, 0x01, 0xd5, 0x58, - 0x89, 0x01, 0xd6, 0x59, 0x89, 0x01, 0xd7, 0x5a, 0x89, 0x01, 0xd8, 0x5b, - 0x89, 0x01, 0xd9, 0x5c, 0x89, 0x41, 0xd0, 0x49, 0x89, 0x01, 0xd1, 0x4a, - 0x89, 0x01, 0xd2, 0x4b, 0x89, 0x01, 0xd3, 0x4c, 0x89, 0x01, 0xd4, 0x4d, - 0x89, 0x01, 0xd5, 0x4e, 0x89, 0x01, 0xd6, 0x4f, 0x89, 0x01, 0xd7, 0x50, - 0x89, 0x01, 0xd8, 0x51, 0x89, 0x01, 0xd9, 0x52, 0x89, 0x41, 0xd0, 0x3f, - 0x89, 0x01, 0xd1, 0x40, 0x89, 0x01, 0xd2, 0x41, 0x89, 0x01, 0xd3, 0x42, - 0x89, 0x01, 0xd4, 0x43, 0x89, 0x01, 0xd5, 0x44, 0x89, 0x01, 0xd6, 0x45, - 0x89, 0x01, 0xd7, 0x46, 0x89, 0x01, 0xd8, 0x47, 0x89, 0x01, 0xd9, 0x48, - 0x89, 0x41, 0xd0, 0x35, 0x89, 0x01, 0xd1, 0x36, 0x89, 0x01, 0xd2, 0x37, - 0x89, 0x01, 0xd3, 0x38, 0x89, 0x01, 0xd4, 0x39, 0x89, 0x01, 0xd5, 0x3a, - 0x89, 0x01, 0xd6, 0x3b, 0x89, 0x01, 0xd7, 0x3c, 0x89, 0x01, 0xd8, 0x3d, - 0x89, 0x01, 0xd9, 0x3e, 0x89, 0x41, 0xd0, 0x2b, 0x89, 0x01, 0xd1, 0x2c, - 0x89, 0x01, 0xd2, 0x2d, 0x89, 0x01, 0xd3, 0x2e, 0x89, 0x01, 0xd4, 0x2f, - 0x89, 0x01, 0xd5, 0x30, 0x89, 0x01, 0xd6, 0x31, 0x89, 0x01, 0xd7, 0x32, - 0x89, 0x01, 0xd8, 0x33, 0x89, 0x01, 0xd9, 0x34, 0x89, 0x41, 0x90, 0x80, + 0x01, 0x0e, 0xd8, 0x5b, 0x01, 0x0e, 0xd9, 0x5c, 0x01, 0x4e, 0x50, 0x9a, + 0x66, 0xbb, 0xfb, 0x01, 0xac, 0x01, 0xff, 0x44, 0x38, 0xf5, 0x0b, 0xf3, + 0x01, 0x47, 0xb8, 0xd8, 0xd0, 0xf3, 0x01, 0x4c, 0x60, 0x9b, 0x30, 0x22, + 0x40, 0x4c, 0x88, 0x91, 0xf3, 0xf4, 0x01, 0x04, 0x8c, 0x10, 0xe1, 0x03, + 0x03, 0x70, 0x21, 0xc8, 0x03, 0xa5, 0xaf, 0x03, 0x44, 0x38, 0xb4, 0xbb, + 0xf3, 0x01, 0x43, 0x50, 0x18, 0x4d, 0x26, 0x00, 0x07, 0x4d, 0xdc, 0x01, + 0xff, 0x0f, 0x0b, 0x06, 0xcf, 0x01, 0x0d, 0x9b, 0x08, 0x01, 0xff, 0xe1, + 0x97, 0x05, 0x01, 0xa2, 0xb9, 0x01, 0xa3, 0xac, 0x01, 0xa4, 0x9f, 0x01, + 0xe5, 0x9f, 0x05, 0x81, 0x95, 0x01, 0x42, 0x2e, 0x1b, 0xa0, 0x05, 0x01, + 0x42, 0x24, 0x02, 0xa1, 0x05, 0x01, 0xa8, 0x7d, 0xe9, 0xa5, 0x05, 0x81, + 0x72, 0x42, 0xa3, 0x21, 0xa7, 0x05, 0x01, 0x42, 0x1b, 0x02, 0xa8, 0x05, + 0x01, 0xac, 0x5a, 0x42, 0x2a, 0x02, 0xab, 0x05, 0x01, 0xae, 0x48, 0xef, + 0xae, 0x05, 0x01, 0x42, 0x6f, 0x02, 0xaf, 0x05, 0x01, 0x42, 0x11, 0x15, + 0xb0, 0x05, 0x01, 0x42, 0x88, 0x00, 0xb1, 0x05, 0x01, 0xb3, 0x26, 0xb4, + 0x1a, 0xf5, 0xb7, 0x05, 0x01, 0x42, 0x32, 0x00, 0xb8, 0x05, 0x01, 0x42, + 0x90, 0x45, 0xb9, 0x05, 0x01, 0xf9, 0xbb, 0x05, 0x01, 0x42, 0x94, 0x0a, + 0xbc, 0x05, 0x41, 0xe5, 0xb5, 0x05, 0x01, 0x42, 0xb0, 0x01, 0xb6, 0x05, + 0x41, 0xe5, 0xb3, 0x05, 0x01, 0x42, 0xb0, 0x01, 0xb4, 0x05, 0x41, 0xe5, + 0xac, 0x05, 0x01, 0x42, 0xa3, 0x21, 0xad, 0x05, 0x41, 0xe1, 0xa9, 0x05, + 0x01, 0x42, 0x74, 0x00, 0xaa, 0x05, 0x41, 0x42, 0xa3, 0x21, 0xa6, 0x05, + 0x41, 0xe1, 0xa3, 0x05, 0x01, 0x42, 0x22, 0x00, 0xa4, 0x05, 0x41, 0xe9, + 0x9e, 0x05, 0x41, 0xe5, 0x9c, 0x05, 0x01, 0x42, 0xb0, 0x01, 0x9d, 0x05, + 0x41, 0xe5, 0x9a, 0x05, 0x01, 0x42, 0xb0, 0x01, 0x9b, 0x05, 0x41, 0x42, + 0xb7, 0x05, 0x98, 0x05, 0x01, 0xe5, 0x99, 0x05, 0x41, 0xe1, 0x70, 0x05, + 0x01, 0xa2, 0xb9, 0x01, 0xa3, 0xac, 0x01, 0xa4, 0x9f, 0x01, 0xe5, 0x78, + 0x05, 0x81, 0x95, 0x01, 0x42, 0x2e, 0x1b, 0x79, 0x05, 0x01, 0x42, 0x24, + 0x02, 0x7a, 0x05, 0x01, 0xa8, 0x7d, 0xe9, 0x7e, 0x05, 0x81, 0x72, 0x42, + 0xa3, 0x21, 0x80, 0x05, 0x01, 0x42, 0x1b, 0x02, 0x81, 0x05, 0x01, 0xac, + 0x5a, 0x42, 0x2a, 0x02, 0x84, 0x05, 0x01, 0xae, 0x48, 0xef, 0x87, 0x05, + 0x01, 0x42, 0x6f, 0x02, 0x88, 0x05, 0x01, 0x42, 0x11, 0x15, 0x89, 0x05, + 0x01, 0x42, 0x88, 0x00, 0x8a, 0x05, 0x01, 0xb3, 0x26, 0xb4, 0x1a, 0xf5, + 0x90, 0x05, 0x01, 0x42, 0x32, 0x00, 0x91, 0x05, 0x01, 0x42, 0x90, 0x45, + 0x92, 0x05, 0x01, 0xf9, 0x94, 0x05, 0x01, 0x42, 0x94, 0x0a, 0x95, 0x05, + 0x41, 0xe5, 0x8e, 0x05, 0x01, 0x42, 0xb0, 0x01, 0x8f, 0x05, 0x41, 0xe5, + 0x8c, 0x05, 0x01, 0x42, 0xb0, 0x01, 0x8d, 0x05, 0x41, 0xe5, 0x85, 0x05, + 0x01, 0x42, 0xa3, 0x21, 0x86, 0x05, 0x41, 0xe1, 0x82, 0x05, 0x01, 0x42, + 0x74, 0x00, 0x83, 0x05, 0x41, 0x42, 0xa3, 0x21, 0x7f, 0x05, 0x41, 0xe1, + 0x7c, 0x05, 0x01, 0x42, 0x22, 0x00, 0x7d, 0x05, 0x41, 0xe9, 0x77, 0x05, + 0x41, 0xe5, 0x75, 0x05, 0x01, 0x42, 0xb0, 0x01, 0x76, 0x05, 0x41, 0xe5, + 0x73, 0x05, 0x01, 0x42, 0xb0, 0x01, 0x74, 0x05, 0x41, 0x42, 0xb7, 0x05, + 0x71, 0x05, 0x01, 0xe5, 0x72, 0x05, 0x41, 0x1f, 0xb7, 0x12, 0x06, 0x4c, + 0xe4, 0x9b, 0x17, 0x23, 0x40, 0x42, 0x37, 0x00, 0xf0, 0x6f, 0x01, 0x44, + 0x70, 0xf7, 0xf1, 0x6f, 0x41, 0x80, 0x06, 0x48, 0x37, 0xca, 0xfc, 0xf4, + 0x41, 0x46, 0xec, 0xb8, 0xf9, 0xf4, 0x01, 0x44, 0xc4, 0xf5, 0xae, 0xf3, + 0x41, 0x42, 0x1b, 0x01, 0xc5, 0xce, 0x01, 0x46, 0xd2, 0x9b, 0x0c, 0x27, + 0x40, 0x55, 0x42, 0x3c, 0x2f, 0x2a, 0x00, 0x04, 0xeb, 0x06, 0x89, 0x03, + 0xb2, 0x0d, 0x43, 0xff, 0x13, 0xb6, 0x26, 0xc0, 0x00, 0x49, 0xa8, 0x2f, + 0x77, 0xf7, 0x41, 0x45, 0xde, 0xf0, 0x23, 0x21, 0x00, 0x06, 0x35, 0x00, + 0x67, 0x02, 0x09, 0x00, 0x01, 0xff, 0x50, 0xea, 0x63, 0xa5, 0xf7, 0x01, + 0x06, 0x3b, 0x16, 0x11, 0x05, 0xc7, 0xee, 0x01, 0xff, 0x4c, 0x87, 0x00, + 0xd9, 0x22, 0x00, 0x49, 0xec, 0x00, 0xd8, 0x22, 0x40, 0x06, 0xff, 0x14, + 0x37, 0x54, 0x7b, 0x44, 0xb3, 0xf7, 0x01, 0x4b, 0xef, 0x63, 0xa6, 0xf7, + 0x01, 0x4f, 0xa8, 0x75, 0x7d, 0xf6, 0x01, 0xb3, 0x11, 0x06, 0xad, 0x02, + 0x01, 0xff, 0x46, 0x12, 0x03, 0x88, 0xf7, 0x01, 0x46, 0xfd, 0x05, 0x92, + 0xf7, 0x41, 0x46, 0x35, 0x1a, 0xad, 0xf7, 0x01, 0x52, 0x5b, 0x55, 0xb9, + 0xf7, 0x01, 0x46, 0x1c, 0x33, 0x7c, 0xf6, 0x41, 0x52, 0x8a, 0x2d, 0xd0, + 0xf7, 0x01, 0x4f, 0xf7, 0x1d, 0xbf, 0xf7, 0x41, 0x04, 0x16, 0x00, 0xec, + 0x01, 0x49, 0x8a, 0xbc, 0x14, 0xcc, 0x01, 0x59, 0x25, 0x25, 0xf9, 0xf7, + 0x01, 0x48, 0x6c, 0x2b, 0xee, 0x22, 0x00, 0x49, 0x08, 0x49, 0x5e, 0x20, + 0x00, 0x47, 0x22, 0xd7, 0x9d, 0xcc, 0x01, 0x5a, 0x6f, 0x21, 0x3b, 0x30, + 0x00, 0x0c, 0x3c, 0x95, 0xa0, 0x01, 0xac, 0x61, 0x55, 0xf7, 0x3e, 0xa8, + 0x26, 0x00, 0x11, 0x69, 0x5f, 0x3f, 0xb2, 0x31, 0x48, 0xbf, 0xd0, 0x3d, + 0x2e, 0x00, 0xb4, 0x06, 0x4b, 0xcc, 0xaa, 0x9a, 0x29, 0x40, 0x02, 0x5c, + 0x00, 0x0c, 0x44, 0x72, 0x24, 0x2f, 0x2e, 0x00, 0x4c, 0xfc, 0x98, 0xa6, + 0xf6, 0x41, 0x44, 0x08, 0x48, 0x7f, 0x2b, 0x00, 0x47, 0x09, 0x3e, 0x0b, + 0x00, 0xc0, 0x00, 0x44, 0x00, 0xbe, 0x8a, 0x00, 0x40, 0x49, 0x22, 0xbb, + 0x9c, 0xcc, 0x01, 0x4f, 0xf9, 0x6f, 0x0a, 0xcc, 0x41, 0xd2, 0x70, 0xfb, + 0x01, 0xd3, 0x71, 0xfb, 0x01, 0xd4, 0x72, 0xfb, 0x01, 0xd5, 0x73, 0xfb, + 0x01, 0xd6, 0x74, 0xfb, 0x01, 0xd7, 0x75, 0xfb, 0x41, 0x45, 0x08, 0xea, + 0x84, 0xcc, 0x01, 0x43, 0xf0, 0x05, 0x7c, 0x00, 0xc0, 0x00, 0x80, 0x01, + 0xff, 0x49, 0x42, 0x5b, 0xd0, 0x23, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, + 0x07, 0xfb, 0x04, 0x12, 0x4f, 0x80, 0x70, 0x90, 0xcc, 0x01, 0x4a, 0x1d, + 0x48, 0x7f, 0x23, 0x00, 0x50, 0xf7, 0x07, 0x15, 0xce, 0x41, 0x45, 0x5c, + 0x00, 0xef, 0x2a, 0x00, 0x45, 0x20, 0x07, 0xf0, 0x2a, 0x40, 0x44, 0xb9, + 0x00, 0x31, 0x30, 0x80, 0x0d, 0x56, 0x5d, 0x3a, 0x32, 0x30, 0xc0, 0x00, + 0x4b, 0x4b, 0x1b, 0x34, 0x30, 0x40, 0x80, 0x01, 0xff, 0x4a, 0xc5, 0x08, + 0x35, 0x30, 0x00, 0x4a, 0x4c, 0x1b, 0x33, 0x30, 0x40, 0x55, 0xc4, 0x3b, + 0xd0, 0x29, 0x00, 0x55, 0x81, 0x3c, 0xe4, 0x2a, 0x00, 0x56, 0x97, 0x39, + 0xe2, 0x2a, 0x00, 0x56, 0x31, 0x3a, 0xca, 0x27, 0x40, 0x05, 0x5a, 0x03, + 0x94, 0x01, 0x05, 0xc2, 0x2e, 0x01, 0xff, 0x60, 0x23, 0x10, 0xe1, 0x1c, + 0x00, 0x07, 0x0a, 0x64, 0x79, 0x02, 0x3b, 0x01, 0x5e, 0x02, 0x1b, 0x02, + 0x4e, 0x47, 0xc5, 0xda, 0xd2, 0x1c, 0x00, 0x02, 0x0d, 0x00, 0x38, 0x45, + 0xc5, 0xf0, 0xd1, 0x1c, 0x00, 0xb4, 0x1e, 0x0b, 0xdf, 0x23, 0x01, 0xff, + 0x5e, 0x31, 0x13, 0xd5, 0x1c, 0x00, 0x53, 0x54, 0x0b, 0xd6, 0x1c, 0x00, + 0x5b, 0x2e, 0x1d, 0xd7, 0x1c, 0xc0, 0x00, 0x4a, 0x78, 0xab, 0xd9, 0x1c, + 0x40, 0x4f, 0x61, 0x71, 0xdf, 0x1c, 0x00, 0x4d, 0x5e, 0x8c, 0xdb, 0x1c, + 0x00, 0x4d, 0xb5, 0x0f, 0xde, 0x1c, 0x40, 0x63, 0x44, 0x0b, 0xe0, 0x1c, + 0x00, 0x48, 0xfc, 0xb5, 0xf8, 0x1c, 0x40, 0x46, 0xb2, 0xe5, 0xd0, 0x1c, + 0x00, 0x4e, 0x9e, 0x80, 0xdc, 0x1c, 0x40, 0x47, 0x6f, 0x13, 0xdd, 0x1c, + 0x00, 0x05, 0x3d, 0x01, 0x01, 0xff, 0x4a, 0xfa, 0xb5, 0xf9, 0x1c, 0x00, + 0x47, 0x60, 0x0b, 0xda, 0x1c, 0x40, 0x45, 0x5c, 0x00, 0xf4, 0x1c, 0x00, + 0x45, 0x20, 0x07, 0xd8, 0x1c, 0x40, 0xa1, 0x72, 0x5c, 0x3c, 0x18, 0xfa, + 0x1c, 0x00, 0x56, 0xfb, 0x35, 0xee, 0x1c, 0x00, 0x4b, 0x10, 0xa3, 0xf5, + 0x1c, 0x00, 0x4d, 0x04, 0x36, 0xef, 0x1c, 0x00, 0x49, 0x3c, 0xc2, 0xd3, + 0x1c, 0x00, 0xb2, 0x36, 0x46, 0xa8, 0xe6, 0xed, 0x1c, 0x00, 0x4b, 0xb9, + 0xa9, 0xf6, 0x1c, 0x00, 0x08, 0xf2, 0x65, 0x06, 0x5a, 0xdf, 0x23, 0xd4, + 0x1c, 0x40, 0x48, 0xa4, 0x80, 0xe5, 0x1c, 0x80, 0x13, 0x47, 0x60, 0x0b, + 0xe2, 0x1c, 0x00, 0x46, 0xa6, 0x80, 0xe3, 0x1c, 0xc0, 0x00, 0x4a, 0xe6, + 0xab, 0xe7, 0x1c, 0x40, 0x4a, 0xe6, 0xab, 0xe8, 0x1c, 0x40, 0x10, 0xea, + 0x65, 0x0c, 0x53, 0x3b, 0x4e, 0xf3, 0x1c, 0x00, 0x53, 0xdd, 0x4f, 0xf0, + 0x1c, 0x40, 0x48, 0xa4, 0x80, 0xe6, 0x1c, 0x00, 0x46, 0xa6, 0x80, 0xe4, + 0x1c, 0x40, 0x08, 0x0b, 0x17, 0x0c, 0x4b, 0x43, 0x4e, 0xf2, 0x1c, 0x00, + 0x47, 0x54, 0xdc, 0xf7, 0x1c, 0x40, 0x4c, 0x4c, 0x18, 0xe9, 0x1c, 0x00, + 0x4c, 0x40, 0x91, 0xea, 0x1c, 0x00, 0x4e, 0xb6, 0x81, 0xf1, 0x1c, 0x00, + 0x4b, 0xfb, 0xa9, 0xeb, 0x1c, 0xc0, 0x00, 0x4a, 0xe6, 0xab, 0xec, 0x1c, + 0x40, 0x02, 0xf1, 0x03, 0xb4, 0x08, 0x45, 0xb8, 0xee, 0xdb, 0xf9, 0x01, + 0x11, 0x35, 0x60, 0x01, 0xff, 0xd1, 0x00, 0xfe, 0x80, 0xda, 0x04, 0xd2, + 0x01, 0xfe, 0x80, 0xbf, 0x02, 0xd3, 0x02, 0xfe, 0x80, 0x91, 0x02, 0xd4, + 0x03, 0xfe, 0x80, 0xe3, 0x01, 0xd5, 0x04, 0xfe, 0x80, 0xb5, 0x01, 0xd6, + 0x05, 0xfe, 0x80, 0x87, 0x01, 0xd7, 0x06, 0xfe, 0x80, 0x5a, 0xd8, 0x07, + 0xfe, 0x80, 0x2d, 0xd9, 0x08, 0xfe, 0xc0, 0x00, 0xd0, 0x49, 0x01, 0x0e, + 0xd1, 0x4a, 0x01, 0x0e, 0xd2, 0x4b, 0x01, 0x0e, 0xd3, 0x4c, 0x01, 0x0e, + 0xd4, 0x4d, 0x01, 0x0e, 0xd5, 0x4e, 0x01, 0x0e, 0xd6, 0x4f, 0x01, 0x0e, + 0xd7, 0x50, 0x01, 0x0e, 0xd8, 0x51, 0x01, 0x0e, 0xd9, 0x52, 0x01, 0x4e, + 0xd0, 0x3f, 0x01, 0x0e, 0xd1, 0x40, 0x01, 0x0e, 0xd2, 0x41, 0x01, 0x0e, + 0xd3, 0x42, 0x01, 0x0e, 0xd4, 0x43, 0x01, 0x0e, 0xd5, 0x44, 0x01, 0x0e, + 0xd6, 0x45, 0x01, 0x0e, 0xd7, 0x46, 0x01, 0x0e, 0xd8, 0x47, 0x01, 0x0e, + 0xd9, 0x48, 0x01, 0x4e, 0xd0, 0x35, 0x01, 0x0e, 0xd1, 0x36, 0x01, 0x0e, + 0xd2, 0x37, 0x01, 0x0e, 0xd3, 0x38, 0x01, 0x0e, 0xd4, 0x39, 0x01, 0x0e, + 0xd5, 0x3a, 0x01, 0x0e, 0xd6, 0x3b, 0x01, 0x0e, 0xd7, 0x3c, 0x01, 0x0e, + 0xd8, 0x3d, 0x01, 0x0e, 0xd9, 0x3e, 0x01, 0x4e, 0xd0, 0x2b, 0x01, 0x0e, + 0xd1, 0x2c, 0x01, 0x0e, 0xd2, 0x2d, 0x01, 0x0e, 0xd3, 0x2e, 0x01, 0x0e, + 0xd4, 0x2f, 0x01, 0x0e, 0xd5, 0x30, 0x01, 0x0e, 0xd6, 0x31, 0x01, 0x0e, + 0xd7, 0x32, 0x01, 0x0e, 0xd8, 0x33, 0x01, 0x0e, 0xd9, 0x34, 0x01, 0x4e, + 0xd0, 0x21, 0x01, 0x0e, 0xd1, 0x22, 0x01, 0x0e, 0xd2, 0x23, 0x01, 0x0e, + 0xd3, 0x24, 0x01, 0x0e, 0xd4, 0x25, 0x01, 0x0e, 0xd5, 0x26, 0x01, 0x0e, + 0xd6, 0x27, 0x01, 0x0e, 0xd7, 0x28, 0x01, 0x0e, 0xd8, 0x29, 0x01, 0x0e, + 0xd9, 0x2a, 0x01, 0x4e, 0xd0, 0x17, 0x01, 0x0e, 0xd1, 0x18, 0x01, 0x0e, + 0xd2, 0x19, 0x01, 0x0e, 0xd3, 0x1a, 0x01, 0x0e, 0xd4, 0x1b, 0x01, 0x0e, + 0xd5, 0x1c, 0x01, 0x0e, 0xd6, 0x1d, 0x01, 0x0e, 0xd7, 0x1e, 0x01, 0x0e, + 0xd8, 0x1f, 0x01, 0x0e, 0xd9, 0x20, 0x01, 0x4e, 0xd0, 0x0d, 0x01, 0x0e, + 0xd1, 0x0e, 0x01, 0x0e, 0xd2, 0x0f, 0x01, 0x0e, 0xd3, 0x10, 0x01, 0x0e, + 0xd4, 0x11, 0x01, 0x0e, 0xd5, 0x12, 0x01, 0x0e, 0xd6, 0x13, 0x01, 0x0e, + 0xd7, 0x14, 0x01, 0x0e, 0xd8, 0x15, 0x01, 0x0e, 0xd9, 0x16, 0x01, 0x4e, + 0xd0, 0x03, 0x01, 0x8e, 0xe7, 0x01, 0xd1, 0x04, 0x01, 0x8e, 0xb9, 0x01, + 0xd2, 0x05, 0x01, 0x8e, 0x8b, 0x01, 0xd3, 0x06, 0x01, 0x8e, 0x5e, 0xd4, + 0x07, 0x01, 0x8e, 0x31, 0xd5, 0x08, 0x01, 0x8e, 0x10, 0xd6, 0x09, 0x01, + 0x0e, 0xd7, 0x0a, 0x01, 0x0e, 0xd8, 0x0b, 0x01, 0x0e, 0xd9, 0x0c, 0x01, + 0x4e, 0xd0, 0xe9, 0x01, 0x0e, 0xd1, 0xea, 0x01, 0x0e, 0xd2, 0xeb, 0x01, + 0x0e, 0xd3, 0xec, 0x01, 0x0e, 0xd4, 0xed, 0x01, 0x0e, 0xd5, 0xee, 0x01, + 0x0e, 0xd6, 0xef, 0x01, 0x4e, 0xd0, 0xdf, 0x01, 0x0e, 0xd1, 0xe0, 0x01, + 0x0e, 0xd2, 0xe1, 0x01, 0x0e, 0xd3, 0xe2, 0x01, 0x0e, 0xd4, 0xe3, 0x01, + 0x0e, 0xd5, 0xe4, 0x01, 0x0e, 0xd6, 0xe5, 0x01, 0x0e, 0xd7, 0xe6, 0x01, + 0x0e, 0xd8, 0xe7, 0x01, 0x0e, 0xd9, 0xe8, 0x01, 0x4e, 0xd0, 0xd5, 0x01, + 0x0e, 0xd1, 0xd6, 0x01, 0x0e, 0xd2, 0xd7, 0x01, 0x0e, 0xd3, 0xd8, 0x01, + 0x0e, 0xd4, 0xd9, 0x01, 0x0e, 0xd5, 0xda, 0x01, 0x0e, 0xd6, 0xdb, 0x01, + 0x0e, 0xd7, 0xdc, 0x01, 0x0e, 0xd8, 0xdd, 0x01, 0x0e, 0xd9, 0xde, 0x01, + 0x4e, 0xd0, 0xcb, 0x01, 0x0e, 0xd1, 0xcc, 0x01, 0x0e, 0xd2, 0xcd, 0x01, + 0x0e, 0xd3, 0xce, 0x01, 0x0e, 0xd4, 0xcf, 0x01, 0x0e, 0xd5, 0xd0, 0x01, + 0x0e, 0xd6, 0xd1, 0x01, 0x0e, 0xd7, 0xd2, 0x01, 0x0e, 0xd8, 0xd3, 0x01, + 0x0e, 0xd9, 0xd4, 0x01, 0x4e, 0xd0, 0xc1, 0x01, 0x0e, 0xd1, 0xc2, 0x01, + 0x0e, 0xd2, 0xc3, 0x01, 0x0e, 0xd3, 0xc4, 0x01, 0x0e, 0xd4, 0xc5, 0x01, + 0x0e, 0xd5, 0xc6, 0x01, 0x0e, 0xd6, 0xc7, 0x01, 0x0e, 0xd7, 0xc8, 0x01, + 0x0e, 0xd8, 0xc9, 0x01, 0x0e, 0xd9, 0xca, 0x01, 0x4e, 0xd0, 0xb7, 0x01, + 0x0e, 0xd1, 0xb8, 0x01, 0x0e, 0xd2, 0xb9, 0x01, 0x0e, 0xd3, 0xba, 0x01, + 0x0e, 0xd4, 0xbb, 0x01, 0x0e, 0xd5, 0xbc, 0x01, 0x0e, 0xd6, 0xbd, 0x01, + 0x0e, 0xd7, 0xbe, 0x01, 0x0e, 0xd8, 0xbf, 0x01, 0x0e, 0xd9, 0xc0, 0x01, + 0x4e, 0xd0, 0x09, 0xfe, 0x80, 0x9b, 0x03, 0xd1, 0x0a, 0xfe, 0x80, 0xed, + 0x02, 0xd2, 0x0b, 0xfe, 0x80, 0xbf, 0x02, 0xd3, 0x0c, 0xfe, 0x80, 0x91, + 0x02, 0xd4, 0x0d, 0xfe, 0x80, 0xe3, 0x01, 0xd5, 0x0e, 0xfe, 0x80, 0xb5, + 0x01, 0xd6, 0x0f, 0xfe, 0x80, 0x87, 0x01, 0xd7, 0x00, 0x01, 0x8e, 0x5a, + 0xd8, 0x01, 0x01, 0x8e, 0x2d, 0xd9, 0x02, 0x01, 0xce, 0x00, 0xd0, 0xad, + 0x01, 0x0e, 0xd1, 0xae, 0x01, 0x0e, 0xd2, 0xaf, 0x01, 0x0e, 0xd3, 0xb0, + 0x01, 0x0e, 0xd4, 0xb1, 0x01, 0x0e, 0xd5, 0xb2, 0x01, 0x0e, 0xd6, 0xb3, + 0x01, 0x0e, 0xd7, 0xb4, 0x01, 0x0e, 0xd8, 0xb5, 0x01, 0x0e, 0xd9, 0xb6, + 0x01, 0x4e, 0xd0, 0xa3, 0x01, 0x0e, 0xd1, 0xa4, 0x01, 0x0e, 0xd2, 0xa5, + 0x01, 0x0e, 0xd3, 0xa6, 0x01, 0x0e, 0xd4, 0xa7, 0x01, 0x0e, 0xd5, 0xa8, + 0x01, 0x0e, 0xd6, 0xa9, 0x01, 0x0e, 0xd7, 0xaa, 0x01, 0x0e, 0xd8, 0xab, + 0x01, 0x0e, 0xd9, 0xac, 0x01, 0x4e, 0xd0, 0x99, 0x01, 0x0e, 0xd1, 0x9a, + 0x01, 0x0e, 0xd2, 0x9b, 0x01, 0x0e, 0xd3, 0x9c, 0x01, 0x0e, 0xd4, 0x9d, + 0x01, 0x0e, 0xd5, 0x9e, 0x01, 0x0e, 0xd6, 0x9f, 0x01, 0x0e, 0xd7, 0xa0, + 0x01, 0x0e, 0xd8, 0xa1, 0x01, 0x0e, 0xd9, 0xa2, 0x01, 0x4e, 0xd0, 0x8f, + 0x01, 0x0e, 0xd1, 0x90, 0x01, 0x0e, 0xd2, 0x91, 0x01, 0x0e, 0xd3, 0x92, + 0x01, 0x0e, 0xd4, 0x93, 0x01, 0x0e, 0xd5, 0x94, 0x01, 0x0e, 0xd6, 0x95, + 0x01, 0x0e, 0xd7, 0x96, 0x01, 0x0e, 0xd8, 0x97, 0x01, 0x0e, 0xd9, 0x98, + 0x01, 0x4e, 0xd0, 0x85, 0x01, 0x0e, 0xd1, 0x86, 0x01, 0x0e, 0xd2, 0x87, + 0x01, 0x0e, 0xd3, 0x88, 0x01, 0x0e, 0xd4, 0x89, 0x01, 0x0e, 0xd5, 0x8a, + 0x01, 0x0e, 0xd6, 0x8b, 0x01, 0x0e, 0xd7, 0x8c, 0x01, 0x0e, 0xd8, 0x8d, + 0x01, 0x0e, 0xd9, 0x8e, 0x01, 0x4e, 0xd0, 0x7b, 0x01, 0x0e, 0xd1, 0x7c, + 0x01, 0x0e, 0xd2, 0x7d, 0x01, 0x0e, 0xd3, 0x7e, 0x01, 0x0e, 0xd4, 0x7f, + 0x01, 0x0e, 0xd5, 0x80, 0x01, 0x0e, 0xd6, 0x81, 0x01, 0x0e, 0xd7, 0x82, + 0x01, 0x0e, 0xd8, 0x83, 0x01, 0x0e, 0xd9, 0x84, 0x01, 0x4e, 0xd0, 0x71, + 0x01, 0x0e, 0xd1, 0x72, 0x01, 0x0e, 0xd2, 0x73, 0x01, 0x0e, 0xd3, 0x74, + 0x01, 0x0e, 0xd4, 0x75, 0x01, 0x0e, 0xd5, 0x76, 0x01, 0x0e, 0xd6, 0x77, + 0x01, 0x0e, 0xd7, 0x78, 0x01, 0x0e, 0xd8, 0x79, 0x01, 0x0e, 0xd9, 0x7a, + 0x01, 0x4e, 0xd0, 0x67, 0x01, 0x0e, 0xd1, 0x68, 0x01, 0x0e, 0xd2, 0x69, + 0x01, 0x0e, 0xd3, 0x6a, 0x01, 0x0e, 0xd4, 0x6b, 0x01, 0x0e, 0xd5, 0x6c, + 0x01, 0x0e, 0xd6, 0x6d, 0x01, 0x0e, 0xd7, 0x6e, 0x01, 0x0e, 0xd8, 0x6f, + 0x01, 0x0e, 0xd9, 0x70, 0x01, 0x4e, 0xd0, 0x5d, 0x01, 0x0e, 0xd1, 0x5e, + 0x01, 0x0e, 0xd2, 0x5f, 0x01, 0x0e, 0xd3, 0x60, 0x01, 0x0e, 0xd4, 0x61, + 0x01, 0x0e, 0xd5, 0x62, 0x01, 0x0e, 0xd6, 0x63, 0x01, 0x0e, 0xd7, 0x64, + 0x01, 0x0e, 0xd8, 0x65, 0x01, 0x0e, 0xd9, 0x66, 0x01, 0x4e, 0xd0, 0x53, + 0x01, 0x0e, 0xd1, 0x54, 0x01, 0x0e, 0xd2, 0x55, 0x01, 0x0e, 0xd3, 0x56, + 0x01, 0x0e, 0xd4, 0x57, 0x01, 0x0e, 0xd5, 0x58, 0x01, 0x0e, 0xd6, 0x59, + 0x01, 0x0e, 0xd7, 0x5a, 0x01, 0x0e, 0xd8, 0x5b, 0x01, 0x0e, 0xd9, 0x5c, + 0x01, 0x4e, 0x45, 0x13, 0x05, 0x0d, 0xa6, 0x00, 0x06, 0xef, 0x06, 0x83, + 0x0b, 0x49, 0x4f, 0x17, 0x0e, 0xa6, 0x00, 0x4d, 0x88, 0x36, 0x0f, 0xa6, + 0x00, 0x02, 0x16, 0x08, 0x01, 0xff, 0x07, 0x22, 0x19, 0x5f, 0x05, 0x2f, + 0x17, 0x01, 0xff, 0x44, 0xf4, 0x16, 0x17, 0xa6, 0x00, 0xa4, 0x3d, 0xa6, + 0x2f, 0x44, 0xb8, 0xb1, 0x1f, 0xa6, 0x00, 0xab, 0x1b, 0x43, 0x72, 0xfa, + 0x16, 0xa6, 0x00, 0xb4, 0x01, 0xff, 0x42, 0x4e, 0x13, 0x19, 0xa6, 0x00, + 0x43, 0xa1, 0x01, 0x15, 0xa6, 0x00, 0x43, 0xd8, 0x02, 0x1d, 0xa6, 0x40, + 0x44, 0xd3, 0xa0, 0x14, 0xa6, 0x00, 0x43, 0xe1, 0x47, 0x1c, 0xa6, 0x40, + 0x42, 0x4e, 0x13, 0x18, 0xa6, 0x00, 0x44, 0xd3, 0xa0, 0x13, 0xa6, 0x40, + 0x43, 0x1c, 0x01, 0x1a, 0xa6, 0x00, 0xaf, 0x01, 0xff, 0x42, 0x72, 0x22, + 0x1e, 0xa6, 0x00, 0x43, 0xd8, 0x02, 0x1b, 0xa6, 0x40, 0xe1, 0x49, 0xa5, + 0x80, 0x85, 0x0a, 0xa2, 0xc4, 0x09, 0xa3, 0xa3, 0x09, 0xa4, 0xc2, 0x08, + 0xe5, 0xe1, 0xa5, 0x80, 0xaf, 0x08, 0xa6, 0x8e, 0x08, 0xa7, 0xc1, 0x07, + 0xa8, 0x89, 0x07, 0xe9, 0x24, 0xa5, 0x80, 0xff, 0x06, 0xaa, 0xde, 0x06, + 0xab, 0x8f, 0x06, 0xac, 0xe8, 0x05, 0xad, 0x85, 0x05, 0xae, 0xa4, 0x03, + 0xef, 0xba, 0xa5, 0x80, 0x91, 0x03, 0xb0, 0xf0, 0x02, 0xb2, 0xcf, 0x02, + 0xb3, 0x8e, 0x02, 0xb4, 0xcd, 0x01, 0xf5, 0x95, 0xa5, 0x80, 0xc3, 0x01, + 0xb6, 0xa2, 0x01, 0xb7, 0x61, 0xb9, 0x41, 0xba, 0x01, 0xff, 0xe1, 0x64, + 0xa5, 0x00, 0xe5, 0xfd, 0xa5, 0x80, 0x31, 0xa8, 0x11, 0xe9, 0x3d, 0xa5, + 0x00, 0xef, 0xd5, 0xa5, 0x80, 0x04, 0xf5, 0xae, 0xa5, 0x40, 0xef, 0x89, + 0xa5, 0x40, 0xe1, 0x65, 0xa5, 0x00, 0xe5, 0xfe, 0xa5, 0x80, 0x11, 0xe9, + 0x3e, 0xa5, 0x00, 0xef, 0xd6, 0xa5, 0x80, 0x04, 0xf5, 0xaf, 0xa5, 0x40, + 0xef, 0x8a, 0xa5, 0x40, 0xe5, 0x19, 0xa5, 0x40, 0xe5, 0x18, 0xa5, 0x40, + 0xe1, 0x69, 0xa5, 0x00, 0xe5, 0x02, 0xa6, 0x80, 0x11, 0xe9, 0x42, 0xa5, + 0x00, 0xef, 0xda, 0xa5, 0x80, 0x04, 0xf5, 0xb3, 0xa5, 0x40, 0xef, 0x8e, + 0xa5, 0x40, 0xe5, 0x1d, 0xa5, 0x40, 0xe1, 0x4e, 0xa5, 0x80, 0x36, 0xe5, + 0xe6, 0xa5, 0x80, 0x24, 0xe9, 0x28, 0xa5, 0x80, 0x1b, 0xef, 0xbf, 0xa5, + 0x80, 0x09, 0xf5, 0x99, 0xa5, 0xc0, 0x00, 0xee, 0x9a, 0xa5, 0x40, 0xee, + 0xc0, 0xa5, 0x00, 0xef, 0x74, 0xa5, 0xc0, 0x00, 0xee, 0x75, 0xa5, 0x40, + 0xee, 0x29, 0xa5, 0x40, 0xe5, 0x03, 0xa5, 0x80, 0x04, 0xee, 0xe7, 0xa5, + 0x40, 0xee, 0x04, 0xa5, 0x40, 0xee, 0x4f, 0xa5, 0x40, 0xe1, 0x59, 0xa5, + 0x00, 0xe5, 0xf2, 0xa5, 0x80, 0x11, 0xe9, 0x32, 0xa5, 0x00, 0xef, 0xca, + 0xa5, 0x80, 0x04, 0xf5, 0xa3, 0xa5, 0x40, 0xef, 0x7e, 0xa5, 0x40, 0xe5, + 0x0d, 0xa5, 0x40, 0xee, 0x96, 0xa5, 0x40, 0xe1, 0x5a, 0xa5, 0x00, 0xe5, + 0xf3, 0xa5, 0x80, 0x31, 0xa8, 0x11, 0xe9, 0x33, 0xa5, 0x00, 0xef, 0xcb, + 0xa5, 0x80, 0x04, 0xf5, 0xa4, 0xa5, 0x40, 0xef, 0x7f, 0xa5, 0x40, 0xe1, + 0x5b, 0xa5, 0x00, 0xe5, 0xf4, 0xa5, 0x80, 0x11, 0xe9, 0x34, 0xa5, 0x00, + 0xef, 0xcc, 0xa5, 0x80, 0x04, 0xf5, 0xa5, 0xa5, 0x40, 0xef, 0x80, 0xa5, + 0x40, 0xe5, 0x0f, 0xa5, 0x40, 0xe5, 0x0e, 0xa5, 0x40, 0xe1, 0x62, 0xa5, + 0x00, 0xe5, 0xfb, 0xa5, 0x80, 0x31, 0xa8, 0x11, 0xe9, 0x3b, 0xa5, 0x00, + 0xef, 0xd3, 0xa5, 0x80, 0x04, 0xf5, 0xac, 0xa5, 0x40, 0xef, 0x87, 0xa5, + 0x40, 0xe1, 0x63, 0xa5, 0x00, 0xe5, 0xfc, 0xa5, 0x80, 0x11, 0xe9, 0x3c, + 0xa5, 0x00, 0xef, 0xd4, 0xa5, 0x80, 0x04, 0xf5, 0xad, 0xa5, 0x40, 0xef, + 0x88, 0xa5, 0x40, 0xe5, 0x17, 0xa5, 0x40, 0xe5, 0x16, 0xa5, 0x40, 0xe1, + 0x5f, 0xa5, 0x00, 0xe5, 0xf8, 0xa5, 0x80, 0x11, 0xe9, 0x38, 0xa5, 0x00, + 0xef, 0xd0, 0xa5, 0x80, 0x04, 0xf5, 0xa9, 0xa5, 0x40, 0xef, 0x84, 0xa5, + 0x40, 0xe5, 0x13, 0xa5, 0x40, 0xe1, 0x50, 0xa5, 0x00, 0xe5, 0xe8, 0xa5, + 0x80, 0x11, 0xe9, 0x2a, 0xa5, 0x00, 0xef, 0xc1, 0xa5, 0x80, 0x04, 0xf5, + 0x9b, 0xa5, 0x40, 0xef, 0x76, 0xa5, 0x40, 0xe5, 0x05, 0xa5, 0x40, 0xee, + 0xbb, 0xa5, 0x00, 0xef, 0x71, 0xa5, 0xc0, 0x00, 0xee, 0x72, 0xa5, 0x40, + 0xe1, 0x6f, 0xa5, 0x00, 0xa4, 0x97, 0x01, 0xe5, 0x09, 0xa6, 0x80, 0x8d, + 0x01, 0xe7, 0x0b, 0xa6, 0x80, 0x52, 0xe9, 0x47, 0xa5, 0x00, 0xaa, 0x2e, + 0xef, 0xdf, 0xa5, 0x80, 0x25, 0xf5, 0xb8, 0xa5, 0x00, 0xb9, 0x01, 0xff, + 0xe1, 0x70, 0xa5, 0x00, 0xe5, 0x0a, 0xa6, 0x80, 0x11, 0xe9, 0x48, 0xa5, + 0x00, 0xef, 0xe0, 0xa5, 0x80, 0x04, 0xf5, 0xb9, 0xa5, 0x40, 0xef, 0x94, + 0xa5, 0x40, 0xe5, 0x23, 0xa5, 0x40, 0xef, 0x93, 0xa5, 0x40, 0xe1, 0x68, + 0xa5, 0x00, 0xe5, 0x01, 0xa6, 0x80, 0x11, 0xe9, 0x41, 0xa5, 0x00, 0xef, + 0xd9, 0xa5, 0x80, 0x04, 0xf5, 0xb2, 0xa5, 0x40, 0xef, 0x8d, 0xa5, 0x40, + 0xe5, 0x1c, 0xa5, 0x40, 0x42, 0x1a, 0x00, 0x4b, 0xa5, 0x00, 0x42, 0x92, + 0x01, 0xe3, 0xa5, 0x00, 0xa7, 0x06, 0x42, 0x10, 0x00, 0xbc, 0xa5, 0x40, + 0xe1, 0x6c, 0xa5, 0x00, 0xe5, 0x04, 0xa6, 0x80, 0x11, 0xe9, 0x44, 0xa5, + 0x00, 0xef, 0xdc, 0xa5, 0x80, 0x04, 0xf5, 0xb5, 0xa5, 0x40, 0xef, 0x90, + 0xa5, 0x40, 0xe5, 0x1f, 0xa5, 0x00, 0xee, 0x05, 0xa6, 0x40, 0xe5, 0x22, + 0xa5, 0x40, 0xe1, 0x61, 0xa5, 0x00, 0xe5, 0xfa, 0xa5, 0x80, 0x33, 0xe9, + 0x3a, 0xa5, 0x00, 0xef, 0xd2, 0xa5, 0x80, 0x04, 0xf5, 0xab, 0xa5, 0x40, + 0x03, 0x3f, 0x01, 0x04, 0xef, 0x86, 0xa5, 0x40, 0x42, 0x3b, 0x01, 0x2b, + 0xa6, 0x00, 0x42, 0x0c, 0x08, 0x10, 0xa6, 0x00, 0x42, 0x1b, 0x02, 0x11, + 0xa6, 0x00, 0x42, 0x6c, 0x00, 0x2a, 0xa6, 0x00, 0x43, 0x42, 0xe9, 0x12, + 0xa6, 0x40, 0xe5, 0x15, 0xa5, 0x40, 0xe1, 0x6e, 0xa5, 0x00, 0xa2, 0x3c, + 0xe5, 0x08, 0xa6, 0x80, 0x33, 0x02, 0xd0, 0x4a, 0x11, 0xe9, 0x46, 0xa5, + 0x00, 0xef, 0xde, 0xa5, 0x80, 0x04, 0xf5, 0xb7, 0xa5, 0x40, 0xef, 0x92, + 0xa5, 0x40, 0xe1, 0x56, 0xa5, 0x00, 0xe5, 0xee, 0xa5, 0x80, 0x11, 0xe9, + 0x2f, 0xa5, 0x00, 0xef, 0xc6, 0xa5, 0x80, 0x04, 0xf5, 0xa0, 0xa5, 0x40, + 0xef, 0x7b, 0xa5, 0x40, 0xe5, 0x0a, 0xa5, 0x40, 0xe5, 0x21, 0xa5, 0x40, + 0xe1, 0x53, 0xa5, 0x00, 0xe5, 0xeb, 0xa5, 0x80, 0x11, 0xe9, 0x2d, 0xa5, + 0x00, 0xef, 0xc4, 0xa5, 0x80, 0x04, 0xf5, 0x9e, 0xa5, 0x40, 0xef, 0x79, + 0xa5, 0x40, 0xe5, 0x08, 0xa5, 0x40, 0xe1, 0x5e, 0xa5, 0x00, 0xe5, 0xf7, + 0xa5, 0x80, 0x11, 0xe9, 0x37, 0xa5, 0x00, 0xef, 0xcf, 0xa5, 0x80, 0x04, + 0xf5, 0xa8, 0xa5, 0x40, 0xef, 0x83, 0xa5, 0x40, 0xe5, 0x12, 0xa5, 0x00, + 0x48, 0x67, 0x59, 0x0c, 0xa6, 0x40, 0xe1, 0x6a, 0xa5, 0x80, 0x43, 0xe5, + 0x03, 0xa6, 0x80, 0x3a, 0xe9, 0x43, 0xa5, 0x00, 0xef, 0xdb, 0xa5, 0x80, + 0x2d, 0xb0, 0x04, 0xf5, 0xb4, 0xa5, 0x40, 0xe1, 0x54, 0xa5, 0x80, 0x1e, + 0xe5, 0xec, 0xa5, 0x80, 0x11, 0xe9, 0x2e, 0xa5, 0x00, 0xef, 0xc5, 0xa5, + 0x80, 0x04, 0xf5, 0x9f, 0xa5, 0x40, 0xef, 0x7a, 0xa5, 0x40, 0xe5, 0x09, + 0xa5, 0x00, 0xee, 0xed, 0xa5, 0x40, 0xee, 0x55, 0xa5, 0x40, 0xef, 0x8f, + 0xa5, 0x40, 0xe5, 0x1e, 0xa5, 0x40, 0xee, 0x6b, 0xa5, 0x40, 0xe1, 0x67, + 0xa5, 0x00, 0xe5, 0x00, 0xa6, 0x80, 0x11, 0xe9, 0x40, 0xa5, 0x00, 0xef, + 0xd8, 0xa5, 0x80, 0x04, 0xf5, 0xb1, 0xa5, 0x40, 0xef, 0x8c, 0xa5, 0x40, + 0xe5, 0x1b, 0xa5, 0x40, 0xee, 0x25, 0xa5, 0x40, 0xe1, 0x4c, 0xa5, 0x80, + 0x2c, 0xe5, 0xe4, 0xa5, 0x80, 0x1f, 0xe9, 0x26, 0xa5, 0x80, 0x16, 0xef, + 0xbd, 0xa5, 0x80, 0x09, 0xf5, 0x97, 0xa5, 0xc0, 0x00, 0xee, 0x98, 0xa5, + 0x40, 0xee, 0xbe, 0xa5, 0x00, 0xef, 0x73, 0xa5, 0x40, 0xee, 0x27, 0xa5, + 0x40, 0xe5, 0x02, 0xa5, 0x00, 0xee, 0xe5, 0xa5, 0x40, 0xee, 0x4d, 0xa5, + 0x40, 0xe1, 0x6d, 0xa5, 0x00, 0xa2, 0x1e, 0xe5, 0x06, 0xa6, 0x80, 0x11, + 0xe9, 0x45, 0xa5, 0x00, 0xef, 0xdd, 0xa5, 0x80, 0x04, 0xf5, 0xb6, 0xa5, + 0x40, 0xef, 0x91, 0xa5, 0x40, 0xe5, 0x20, 0xa5, 0x00, 0xee, 0x07, 0xa6, + 0x40, 0xe1, 0x57, 0xa5, 0x00, 0xe5, 0xef, 0xa5, 0x80, 0x15, 0xe9, 0x30, + 0xa5, 0x00, 0xef, 0xc7, 0xa5, 0x80, 0x04, 0xf5, 0xa1, 0xa5, 0x40, 0xee, + 0xc8, 0xa5, 0x00, 0xef, 0x7c, 0xa5, 0x40, 0xe5, 0x0b, 0xa5, 0x00, 0xee, + 0xf0, 0xa5, 0x40, 0xe1, 0x58, 0xa5, 0x00, 0xe5, 0xf1, 0xa5, 0x80, 0x11, + 0xe9, 0x31, 0xa5, 0x00, 0xef, 0xc9, 0xa5, 0x80, 0x04, 0xf5, 0xa2, 0xa5, + 0x40, 0xef, 0x7d, 0xa5, 0x40, 0xe5, 0x0c, 0xa5, 0x40, 0xe5, 0x00, 0xa5, + 0x80, 0x04, 0xee, 0xe2, 0xa5, 0x40, 0xee, 0x01, 0xa5, 0x40, 0xe1, 0x60, + 0xa5, 0x00, 0xe5, 0xf9, 0xa5, 0x80, 0x51, 0xa8, 0x11, 0xe9, 0x39, 0xa5, + 0x00, 0xef, 0xd1, 0xa5, 0x80, 0x04, 0xf5, 0xaa, 0xa5, 0x40, 0xef, 0x85, + 0xa5, 0x40, 0xe1, 0x5c, 0xa5, 0x00, 0xe5, 0xf5, 0xa5, 0x80, 0x31, 0xa8, + 0x11, 0xe9, 0x35, 0xa5, 0x00, 0xef, 0xcd, 0xa5, 0x80, 0x04, 0xf5, 0xa6, + 0xa5, 0x40, 0xef, 0x81, 0xa5, 0x40, 0xe1, 0x5d, 0xa5, 0x00, 0xe5, 0xf6, + 0xa5, 0x80, 0x11, 0xe9, 0x36, 0xa5, 0x00, 0xef, 0xce, 0xa5, 0x80, 0x04, + 0xf5, 0xa7, 0xa5, 0x40, 0xef, 0x82, 0xa5, 0x40, 0xe5, 0x11, 0xa5, 0x40, + 0xe5, 0x10, 0xa5, 0x40, 0xe5, 0x14, 0xa5, 0x40, 0xe1, 0x66, 0xa5, 0x00, + 0xe5, 0xff, 0xa5, 0x80, 0x11, 0xe9, 0x3f, 0xa5, 0x00, 0xef, 0xd7, 0xa5, + 0x80, 0x04, 0xf5, 0xb0, 0xa5, 0x40, 0xef, 0x8b, 0xa5, 0x40, 0xe5, 0x1a, + 0xa5, 0x40, 0xe1, 0x52, 0xa5, 0x00, 0xe5, 0xea, 0xa5, 0x80, 0x31, 0xa8, + 0x11, 0xe9, 0x2c, 0xa5, 0x00, 0xef, 0xc3, 0xa5, 0x80, 0x04, 0xf5, 0x9d, + 0xa5, 0x40, 0xef, 0x78, 0xa5, 0x40, 0xe1, 0x51, 0xa5, 0x00, 0xe5, 0xe9, + 0xa5, 0x80, 0x11, 0xe9, 0x2b, 0xa5, 0x00, 0xef, 0xc2, 0xa5, 0x80, 0x04, + 0xf5, 0x9c, 0xa5, 0x40, 0xef, 0x77, 0xa5, 0x40, 0xe5, 0x06, 0xa5, 0x40, + 0xe5, 0x07, 0xa5, 0x40, 0xee, 0x4a, 0xa5, 0x40, 0x45, 0x7e, 0x0b, 0x28, + 0xa6, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x29, 0xa6, 0x00, 0x43, 0x7a, + 0x0b, 0x21, 0xa6, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x20, + 0xa6, 0x40, 0x44, 0x25, 0x01, 0x23, 0xa6, 0x00, 0x42, 0x15, 0x02, 0x22, + 0xa6, 0x40, 0x44, 0x06, 0x1f, 0x27, 0xa6, 0x00, 0x42, 0x09, 0x24, 0x26, + 0xa6, 0x40, 0x43, 0xf9, 0x05, 0x25, 0xa6, 0x00, 0x43, 0xf6, 0x06, 0x24, + 0xa6, 0x40, 0x4e, 0x12, 0x79, 0xc3, 0x20, 0x00, 0x08, 0xff, 0xcb, 0xd6, + 0x0d, 0x47, 0x33, 0x64, 0x02, 0x26, 0x80, 0xbf, 0x0d, 0xae, 0xc9, 0x0c, + 0xb0, 0x0a, 0x45, 0xfd, 0xe6, 0x45, 0x26, 0x00, 0xf3, 0x1f, 0x00, 0x40, + 0x80, 0xad, 0x0b, 0x8d, 0xb4, 0x0a, 0x04, 0x6f, 0x02, 0xff, 0x03, 0x4e, + 0x12, 0x80, 0x43, 0xf6, 0x01, 0x06, 0xa9, 0x01, 0x01, 0xff, 0xa1, 0xff, + 0x02, 0x06, 0x0c, 0x03, 0xee, 0x02, 0x50, 0x5a, 0x64, 0x3d, 0xf8, 0x01, + 0xa4, 0xd9, 0x02, 0x51, 0x7d, 0x5c, 0x35, 0xf8, 0x01, 0xa8, 0xfa, 0x01, + 0x4d, 0xcf, 0x8b, 0xc8, 0x21, 0x00, 0x4f, 0x4e, 0x75, 0xf0, 0x27, 0x00, + 0x46, 0xa6, 0xe5, 0x6d, 0xf6, 0x01, 0xb3, 0xd9, 0x01, 0xb4, 0x47, 0x06, + 0xad, 0x02, 0x01, 0xff, 0x45, 0xce, 0x00, 0xe7, 0x21, 0x80, 0x0d, 0x4c, + 0xd8, 0x92, 0xee, 0x21, 0xc0, 0x00, 0x4c, 0xd8, 0x8f, 0xef, 0x21, 0x40, + 0x80, 0x01, 0xff, 0x48, 0xdf, 0xb9, 0xea, 0x21, 0x80, 0x1e, 0x4b, 0xd9, + 0x8f, 0xeb, 0x21, 0x80, 0x06, 0x59, 0x04, 0x20, 0x95, 0xf8, 0x41, 0x06, + 0x50, 0x00, 0x01, 0xff, 0x4e, 0x0b, 0x00, 0xec, 0x21, 0x00, 0x4c, 0x32, + 0x00, 0xed, 0x21, 0x40, 0x54, 0x0f, 0x42, 0xb8, 0x2b, 0x40, 0x02, 0x0d, + 0x00, 0x1c, 0x02, 0x15, 0x02, 0x01, 0xff, 0x4d, 0x6e, 0x83, 0x9f, 0x21, + 0x00, 0x0e, 0x1b, 0x06, 0x01, 0xff, 0x51, 0xb0, 0x5c, 0x49, 0x29, 0x00, + 0x58, 0x29, 0x06, 0xed, 0x2b, 0x40, 0x05, 0x04, 0x02, 0x06, 0x49, 0x54, + 0x75, 0x0a, 0x29, 0x40, 0x4a, 0xe0, 0x01, 0x91, 0xf8, 0x01, 0x08, 0x09, + 0x02, 0x01, 0xff, 0x45, 0xce, 0x00, 0x61, 0x2b, 0x80, 0x0c, 0x4c, 0x78, + 0x92, 0x6b, 0x2b, 0x00, 0x4d, 0xcf, 0x8b, 0x85, 0x2b, 0x40, 0x80, 0x01, + 0xff, 0x6c, 0xea, 0x01, 0x81, 0x2b, 0x00, 0x46, 0x9f, 0x15, 0x71, 0x2b, + 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4a, 0xb2, 0xad, 0x29, 0xf8, 0x01, + 0x58, 0x94, 0x29, 0x7b, 0x2b, 0x00, 0x4b, 0x7f, 0x6b, 0x2d, 0xf8, 0x01, + 0x09, 0x6d, 0xc1, 0x12, 0x4c, 0xbc, 0x96, 0x25, 0xf8, 0x01, 0x4c, 0x28, + 0x97, 0x21, 0xf8, 0x01, 0x50, 0x7a, 0x6b, 0x31, 0xf8, 0x41, 0x49, 0xea, + 0x01, 0xa2, 0x2b, 0x00, 0x4a, 0xb3, 0x02, 0xa3, 0x2b, 0x40, 0x4f, 0xfb, + 0x69, 0x51, 0xf8, 0x01, 0x4c, 0xd8, 0x98, 0x39, 0xf8, 0x41, 0x11, 0x91, + 0x05, 0x11, 0x05, 0x3c, 0x16, 0x01, 0xff, 0x45, 0xce, 0x00, 0x45, 0xf8, + 0x01, 0x50, 0x5a, 0x64, 0x41, 0xf8, 0x41, 0x04, 0xc3, 0x00, 0x19, 0x05, + 0xc8, 0x00, 0x01, 0xff, 0x80, 0x06, 0x45, 0xa9, 0x01, 0xbe, 0x21, 0x40, + 0x48, 0xdf, 0xb9, 0x5c, 0x29, 0x00, 0x46, 0x9f, 0x15, 0x54, 0x29, 0x40, + 0x80, 0x06, 0x45, 0xa9, 0x01, 0xbf, 0x21, 0x40, 0x07, 0xdb, 0x0a, 0x0c, + 0x48, 0xdf, 0xb9, 0x60, 0x29, 0x00, 0x46, 0x9f, 0x15, 0x58, 0x29, 0x40, + 0x61, 0x57, 0x0e, 0x6e, 0x29, 0x00, 0x5f, 0xd6, 0x12, 0x63, 0x29, 0x40, + 0x4b, 0x79, 0x92, 0xe1, 0x21, 0x00, 0x4b, 0xd9, 0x92, 0xd1, 0x21, 0x40, + 0x45, 0xce, 0x00, 0x06, 0x2b, 0x00, 0x53, 0x0a, 0x4b, 0x89, 0x2b, 0x40, + 0x45, 0xea, 0xee, 0x15, 0x2e, 0x00, 0x44, 0xcf, 0x00, 0x91, 0x21, 0xc0, + 0x00, 0x80, 0x01, 0xff, 0x5a, 0x6b, 0x20, 0xb8, 0xfb, 0x01, 0x48, 0xdf, + 0xb9, 0xa5, 0x21, 0x00, 0x5c, 0x54, 0x19, 0xc5, 0x21, 0x00, 0x46, 0x9f, + 0x15, 0x12, 0x29, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4d, 0x46, 0x86, + 0xde, 0x21, 0x00, 0x55, 0xd5, 0x01, 0x15, 0xf8, 0x01, 0x51, 0x47, 0x05, + 0x09, 0x29, 0x00, 0x58, 0x14, 0x2b, 0x09, 0xf8, 0x01, 0x59, 0x51, 0x26, + 0x05, 0xf8, 0x01, 0x4c, 0xa0, 0x97, 0x99, 0xf8, 0x01, 0x06, 0x5d, 0x07, + 0x11, 0x04, 0xb5, 0x0c, 0x01, 0xff, 0x49, 0xea, 0x01, 0xb0, 0x21, 0x00, + 0x4a, 0xb3, 0x02, 0xb1, 0x21, 0x40, 0x55, 0xd5, 0x01, 0x11, 0xf8, 0x01, + 0x52, 0x2e, 0x06, 0x01, 0xf8, 0x41, 0x04, 0x1a, 0x00, 0x8c, 0x06, 0x4e, + 0xba, 0x79, 0x01, 0x27, 0x00, 0x07, 0x73, 0x02, 0xda, 0x05, 0x52, 0x17, + 0x54, 0x84, 0xfb, 0x01, 0x05, 0x22, 0x00, 0x8e, 0x05, 0x05, 0xc3, 0x00, + 0x8c, 0x03, 0x07, 0x7d, 0x02, 0xd6, 0x02, 0x04, 0x7a, 0x0b, 0xc5, 0x02, + 0x06, 0xc8, 0x00, 0x30, 0x53, 0x58, 0x4f, 0x86, 0xfb, 0x01, 0xb4, 0x01, + 0xff, 0x05, 0x25, 0x01, 0x06, 0x5b, 0x57, 0x1e, 0x6d, 0xfb, 0x41, 0x4d, + 0x5e, 0x4f, 0x83, 0xfb, 0x01, 0x09, 0x2a, 0x01, 0x01, 0xff, 0x45, 0x33, + 0x01, 0x85, 0xfb, 0x01, 0x56, 0x19, 0x37, 0xa6, 0xce, 0x01, 0x57, 0x91, + 0x32, 0xad, 0xce, 0x41, 0x0f, 0xa0, 0x6e, 0xac, 0x01, 0x5a, 0x07, 0x21, + 0x50, 0x27, 0x00, 0xaf, 0x97, 0x01, 0x46, 0x0a, 0xe5, 0x10, 0x27, 0x00, + 0x03, 0x7c, 0x00, 0x2f, 0x0f, 0xa4, 0x02, 0x1f, 0xb4, 0x01, 0xff, 0x51, + 0x3e, 0x58, 0x99, 0xfb, 0x01, 0x05, 0x1a, 0x01, 0x06, 0x4d, 0x63, 0x81, + 0x33, 0xcc, 0x41, 0x42, 0x68, 0x00, 0xf9, 0x25, 0x00, 0x51, 0x56, 0x61, + 0x9d, 0xfb, 0x41, 0x46, 0x12, 0x03, 0x3f, 0xf5, 0x01, 0x46, 0xfd, 0x05, + 0x52, 0x27, 0x40, 0x06, 0x0a, 0x0e, 0x06, 0x4b, 0xed, 0x4e, 0x36, 0xcc, + 0x41, 0xa3, 0x22, 0x0a, 0x0c, 0x08, 0x12, 0x4d, 0x2f, 0x8a, 0xb7, 0xcc, + 0x01, 0x4f, 0x89, 0x76, 0xd3, 0xcc, 0x01, 0x4a, 0x4e, 0xb7, 0xb3, 0xcc, + 0x41, 0x4b, 0xcf, 0x24, 0xa9, 0xcc, 0x01, 0x49, 0x26, 0xc3, 0xa7, 0xcc, + 0x41, 0x05, 0xc3, 0x8c, 0x06, 0x4b, 0xd9, 0xa2, 0xdd, 0x25, 0x40, 0x46, + 0x1e, 0xe0, 0xc7, 0xcc, 0x01, 0xab, 0x12, 0x44, 0xf4, 0xf7, 0xcf, 0xcc, + 0x01, 0x45, 0x19, 0xc4, 0xbf, 0xcc, 0x01, 0x44, 0x58, 0xf8, 0xc3, 0xcc, + 0x41, 0x43, 0xa1, 0x01, 0xbb, 0xcc, 0x01, 0x45, 0x73, 0x09, 0xcb, 0xcc, + 0x41, 0x52, 0x6b, 0x27, 0x93, 0xce, 0x01, 0x62, 0x8e, 0x0d, 0xb1, 0x23, + 0x40, 0x1b, 0x9a, 0x1d, 0x50, 0x06, 0x6d, 0x02, 0x01, 0xff, 0x0a, 0x73, + 0x02, 0x31, 0x08, 0x84, 0x02, 0x17, 0x15, 0x7d, 0x02, 0x01, 0xff, 0x46, + 0x73, 0x02, 0x54, 0xfb, 0x01, 0x4c, 0x07, 0x10, 0x67, 0xfb, 0x01, 0x45, + 0xc8, 0x00, 0x55, 0xfb, 0x41, 0x06, 0x13, 0x01, 0x06, 0x52, 0xcd, 0x58, + 0x63, 0xfb, 0x41, 0x46, 0x73, 0x02, 0x56, 0xfb, 0x01, 0x4c, 0x07, 0x10, + 0x65, 0xfb, 0x41, 0x06, 0x13, 0x01, 0x06, 0x52, 0xcd, 0x58, 0x62, 0xfb, + 0x41, 0x4c, 0x07, 0x10, 0x64, 0xfb, 0x01, 0x45, 0xc8, 0x00, 0x66, 0xfb, + 0x41, 0x46, 0x73, 0x02, 0x52, 0xfb, 0x01, 0x45, 0xc8, 0x00, 0x53, 0xfb, + 0x41, 0x4c, 0x7e, 0x0b, 0x94, 0x25, 0x00, 0x4d, 0x65, 0x1e, 0x82, 0xfb, + 0x41, 0x07, 0x73, 0x02, 0x21, 0x05, 0xc3, 0x00, 0x11, 0x06, 0xc8, 0x00, + 0x01, 0xff, 0x53, 0x6a, 0x27, 0x97, 0xce, 0x01, 0x4e, 0x62, 0x81, 0x37, + 0xcc, 0x41, 0x53, 0x6a, 0x27, 0x94, 0xce, 0x01, 0x4e, 0x62, 0x81, 0x34, + 0xcc, 0x41, 0x58, 0x44, 0x2b, 0x95, 0xce, 0x01, 0x59, 0x64, 0x27, 0x96, + 0xce, 0x41, 0x0f, 0xa0, 0x6e, 0x96, 0x01, 0x4f, 0x09, 0x6f, 0xd4, 0x27, + 0x00, 0xaf, 0x81, 0x01, 0x03, 0x7c, 0x00, 0x1f, 0xb4, 0x01, 0xff, 0x52, + 0x04, 0x50, 0x98, 0xfb, 0x01, 0x05, 0x1a, 0x01, 0x06, 0x4d, 0x63, 0x81, + 0x30, 0xcc, 0x41, 0x42, 0x68, 0x00, 0xf8, 0x25, 0x00, 0x51, 0x56, 0x61, + 0x9c, 0xfb, 0x41, 0x06, 0x0a, 0x0e, 0x06, 0x4b, 0xed, 0x4e, 0x35, 0xcc, + 0x41, 0xa3, 0x22, 0x0a, 0x0c, 0x08, 0x12, 0x4d, 0x2f, 0x8a, 0xb6, 0xcc, + 0x01, 0x4f, 0x89, 0x76, 0xd2, 0xcc, 0x01, 0x4a, 0x4e, 0xb7, 0xb2, 0xcc, + 0x41, 0x4b, 0xcf, 0x24, 0xa8, 0xcc, 0x01, 0x49, 0x26, 0xc3, 0xa6, 0xcc, + 0x41, 0x05, 0xc3, 0x8c, 0x06, 0x4b, 0xd9, 0xa2, 0xdc, 0x25, 0x40, 0x46, + 0x1e, 0xe0, 0xc6, 0xcc, 0x01, 0xab, 0x12, 0x44, 0xf4, 0xf7, 0xce, 0xcc, + 0x01, 0x45, 0x19, 0xc4, 0xbe, 0xcc, 0x01, 0x44, 0x58, 0xf8, 0xc2, 0xcc, + 0x41, 0x43, 0xa1, 0x01, 0xba, 0xcc, 0x01, 0x45, 0x73, 0x09, 0xca, 0xcc, + 0x41, 0x52, 0x6b, 0x27, 0x90, 0xce, 0x01, 0x63, 0xd0, 0x0b, 0xb0, 0x23, + 0x40, 0x06, 0x13, 0x01, 0x11, 0x1b, 0x2f, 0x1f, 0x01, 0xff, 0x46, 0x73, + 0x02, 0x57, 0xfb, 0x01, 0x45, 0xc8, 0x00, 0x58, 0xfb, 0x41, 0x0a, 0x73, + 0x02, 0x32, 0x08, 0x84, 0x02, 0x17, 0x15, 0x35, 0x1f, 0x01, 0xff, 0x46, + 0x73, 0x02, 0x59, 0xfb, 0x01, 0x4c, 0x07, 0x10, 0x5c, 0xfb, 0x01, 0x45, + 0xc8, 0x00, 0x5a, 0xfb, 0x41, 0x52, 0xeb, 0x55, 0x5e, 0xfb, 0x01, 0x06, + 0x6d, 0x02, 0x01, 0xff, 0x46, 0x73, 0x02, 0x5b, 0xfb, 0x01, 0x4c, 0x07, + 0x10, 0x60, 0xfb, 0x41, 0x52, 0xeb, 0x55, 0x5d, 0xfb, 0x01, 0x06, 0x6d, + 0x02, 0x01, 0xff, 0x4c, 0x07, 0x10, 0x5f, 0xfb, 0x01, 0x45, 0xc8, 0x00, + 0x61, 0xfb, 0x41, 0x45, 0x33, 0x01, 0x80, 0x25, 0x80, 0x34, 0x46, 0x12, + 0x03, 0xe0, 0x25, 0x00, 0x52, 0x83, 0x54, 0x03, 0xce, 0x01, 0x08, 0x3c, + 0x04, 0x18, 0x56, 0x19, 0x37, 0xa7, 0xce, 0x01, 0x4c, 0x44, 0x04, 0x8e, + 0xfb, 0x01, 0x57, 0x91, 0x32, 0xac, 0xce, 0x01, 0x63, 0x39, 0x0c, 0x14, + 0xce, 0x41, 0x61, 0xdb, 0x0e, 0x92, 0xfb, 0x01, 0x4c, 0x00, 0x12, 0xda, + 0x25, 0x40, 0x64, 0xc0, 0x08, 0x91, 0xfb, 0x41, 0x05, 0xc3, 0x00, 0x17, + 0x51, 0x61, 0x1e, 0xe4, 0xfb, 0x01, 0x06, 0xc8, 0x00, 0x01, 0xff, 0x53, + 0x6a, 0x27, 0x92, 0xce, 0x01, 0x4e, 0x62, 0x81, 0x32, 0xcc, 0x41, 0x53, + 0x6a, 0x27, 0x91, 0xce, 0x01, 0x4e, 0x62, 0x81, 0x31, 0xcc, 0x41, 0xac, + 0x06, 0x6f, 0x09, 0x01, 0x68, 0xfb, 0x41, 0x6d, 0x65, 0x01, 0x6a, 0xfb, + 0x01, 0x05, 0x14, 0x01, 0x01, 0xff, 0x50, 0x7a, 0x0b, 0x80, 0xfb, 0x01, + 0x55, 0xc5, 0x40, 0x9a, 0xfb, 0x41, 0x17, 0xf6, 0x2f, 0x66, 0x09, 0x9c, + 0x01, 0x01, 0xff, 0xa1, 0x53, 0x4b, 0xc9, 0xa0, 0x79, 0xcc, 0x01, 0x44, + 0xb8, 0xf5, 0xfb, 0xcd, 0x01, 0x47, 0x22, 0xd7, 0x00, 0xcc, 0x01, 0x51, + 0xe1, 0x5e, 0xe6, 0xf6, 0x01, 0xb2, 0x21, 0x06, 0x5d, 0x07, 0x11, 0x0e, + 0x46, 0x81, 0x01, 0xff, 0x4f, 0xab, 0x72, 0xed, 0x25, 0x00, 0x50, 0xca, + 0x69, 0xee, 0x25, 0x40, 0x48, 0xdd, 0x35, 0xe8, 0xf6, 0x01, 0x4c, 0x80, + 0x5e, 0x3c, 0xf5, 0x41, 0x49, 0x22, 0xbb, 0x98, 0xcc, 0x01, 0x4b, 0x90, + 0x06, 0x3a, 0xf5, 0x01, 0x44, 0x42, 0xb2, 0x66, 0xcc, 0x01, 0x4a, 0x24, + 0xb4, 0x57, 0xcc, 0x41, 0x47, 0xde, 0x35, 0xe7, 0xf6, 0x01, 0x4a, 0xa8, + 0xb7, 0x61, 0xcc, 0x41, 0x4c, 0x24, 0x92, 0x75, 0xcc, 0x01, 0x4a, 0xda, + 0x2a, 0x71, 0xcc, 0x41, 0x05, 0xce, 0x00, 0x6d, 0x05, 0x9d, 0x05, 0x48, + 0x05, 0x6c, 0x15, 0x19, 0x49, 0x94, 0xbe, 0x7e, 0x29, 0x00, 0x57, 0x63, + 0x32, 0xf0, 0x22, 0x00, 0x44, 0x18, 0x3b, 0xa5, 0x22, 0xc0, 0x00, 0x52, + 0xe9, 0x51, 0xdf, 0x27, 0x40, 0x45, 0xce, 0x00, 0x95, 0x21, 0x80, 0x1e, + 0x4b, 0xae, 0x9e, 0x0d, 0x2b, 0x00, 0x4c, 0xd8, 0x92, 0xd5, 0x21, 0x00, + 0x50, 0xfa, 0x69, 0x59, 0xf8, 0x01, 0x55, 0x01, 0x02, 0x65, 0x2b, 0x00, + 0x4b, 0xf8, 0x10, 0xf3, 0x21, 0x40, 0x4a, 0x96, 0xab, 0xa8, 0x21, 0x40, + 0x0f, 0x8d, 0x72, 0x11, 0x10, 0xaa, 0x69, 0x01, 0xff, 0x4c, 0xb4, 0x95, + 0x4c, 0x29, 0x00, 0x4d, 0x44, 0x8c, 0x4f, 0x29, 0x40, 0x4c, 0xb4, 0x95, + 0x51, 0x29, 0x00, 0x4d, 0x44, 0x8c, 0x4d, 0x29, 0x40, 0x4f, 0xed, 0x6c, + 0xbd, 0x29, 0x00, 0x44, 0xe6, 0x01, 0x03, 0x23, 0xc0, 0x00, 0x80, 0x01, + 0xff, 0x5b, 0x7e, 0x1b, 0x24, 0x23, 0x00, 0x52, 0xb5, 0x49, 0xb9, 0x2b, + 0x40, 0x4b, 0x1f, 0x9e, 0x12, 0xf6, 0x01, 0x4e, 0xe4, 0x79, 0xd1, 0x2b, + 0x00, 0xa4, 0x59, 0xa9, 0x06, 0x5a, 0x25, 0x22, 0xaf, 0x26, 0x40, 0x49, + 0xf6, 0xbc, 0x84, 0xf9, 0x01, 0x42, 0x10, 0x00, 0x2a, 0x22, 0x80, 0x14, + 0xb4, 0x06, 0x57, 0x85, 0x26, 0x72, 0x26, 0x40, 0x4a, 0xfa, 0x21, 0x1f, + 0x00, 0x00, 0x49, 0xb6, 0x7a, 0xfa, 0x2b, 0x40, 0x80, 0x01, 0xff, 0x06, + 0x5c, 0x00, 0x1d, 0x5c, 0x20, 0x18, 0x4a, 0x2a, 0x00, 0x05, 0x51, 0x00, + 0x01, 0xff, 0x4a, 0xb2, 0xb2, 0x45, 0x2a, 0x00, 0x4a, 0x7b, 0x9d, 0x41, + 0x2a, 0x00, 0x47, 0xc2, 0x83, 0x42, 0x2a, 0x40, 0x56, 0xc7, 0x34, 0x48, + 0x2a, 0x00, 0x4c, 0xf2, 0x0a, 0x46, 0x2a, 0x40, 0x45, 0xda, 0xd1, 0x3f, + 0x20, 0x00, 0x48, 0xde, 0xb5, 0x8c, 0x23, 0x40, 0x80, 0x01, 0xff, 0x49, + 0xcc, 0xc2, 0xf1, 0x26, 0x00, 0x4f, 0x0f, 0x78, 0x14, 0x26, 0x40, 0x07, + 0x13, 0x06, 0x06, 0x4c, 0xa9, 0x26, 0x9f, 0x03, 0x41, 0xa1, 0xb3, 0x01, + 0x44, 0xa3, 0x9e, 0x81, 0x03, 0x01, 0xa4, 0x9e, 0x01, 0xa7, 0x8f, 0x01, + 0x42, 0x0b, 0x00, 0x85, 0x03, 0x81, 0x81, 0x01, 0xe9, 0x9b, 0x03, 0x01, + 0xab, 0x6f, 0x45, 0x0e, 0xee, 0x8d, 0x03, 0x01, 0x43, 0xb4, 0x05, 0x8e, + 0x03, 0x01, 0x43, 0x18, 0x24, 0x90, 0x03, 0x01, 0x42, 0x73, 0x0c, 0x94, + 0x03, 0x01, 0x44, 0x2c, 0xf8, 0x96, 0x03, 0x01, 0x45, 0x20, 0xf0, 0x97, + 0x03, 0x01, 0xb3, 0x2f, 0xb4, 0x1d, 0xf5, 0x9c, 0x03, 0x01, 0x42, 0x15, + 0x02, 0x86, 0x03, 0x01, 0x43, 0xfd, 0x54, 0x8a, 0x03, 0x01, 0xba, 0x01, + 0xff, 0x43, 0x43, 0x10, 0x87, 0x03, 0x01, 0xf5, 0x91, 0x03, 0x41, 0x42, + 0x14, 0x06, 0x89, 0x03, 0x01, 0x45, 0xd3, 0xec, 0x98, 0x03, 0x01, 0xef, + 0x9a, 0x03, 0x41, 0xa1, 0x0c, 0x43, 0x48, 0x17, 0x8c, 0x03, 0x01, 0x42, + 0x6f, 0x00, 0x9d, 0x03, 0x41, 0x42, 0x04, 0x00, 0x95, 0x03, 0x01, 0x43, + 0x7e, 0x55, 0x92, 0x03, 0x41, 0x42, 0x12, 0x15, 0x8b, 0x03, 0x01, 0x42, + 0x22, 0x00, 0x83, 0x03, 0x41, 0x42, 0x12, 0x00, 0x88, 0x03, 0x41, 0x44, + 0xe0, 0xf4, 0x82, 0x03, 0x01, 0x44, 0x90, 0xa1, 0x99, 0x03, 0x41, 0x44, + 0x28, 0xdc, 0x84, 0x03, 0x01, 0x43, 0x22, 0x00, 0x8f, 0x03, 0x41, 0x42, + 0x9e, 0x01, 0x93, 0x03, 0x01, 0x43, 0xc1, 0x7e, 0x80, 0x03, 0x41, 0x8d, + 0xa0, 0x7c, 0xa1, 0xc9, 0x3b, 0xa5, 0xde, 0x30, 0xa8, 0xc5, 0x26, 0xa9, + 0xa8, 0x13, 0xaf, 0xf3, 0x09, 0xb2, 0xe8, 0x06, 0xb5, 0x9c, 0x01, 0xb7, + 0x01, 0xff, 0x57, 0x85, 0x2d, 0x39, 0x27, 0x00, 0x57, 0xdc, 0x30, 0x00, + 0xf5, 0x01, 0xaf, 0x01, 0xff, 0x80, 0x1a, 0x8d, 0x01, 0xff, 0x47, 0x96, + 0xd6, 0x3a, 0x2e, 0x00, 0x05, 0xed, 0x07, 0x01, 0xff, 0x4c, 0x87, 0x00, + 0x0a, 0xdb, 0x01, 0x49, 0xec, 0x00, 0x0b, 0xdb, 0x41, 0x5c, 0x04, 0x18, + 0x51, 0x20, 0x00, 0x4c, 0xac, 0x91, 0xb0, 0xf5, 0x01, 0x58, 0x34, 0x29, + 0x75, 0x2a, 0x00, 0x03, 0x48, 0x0a, 0x44, 0x46, 0x20, 0x8b, 0x95, 0xf4, + 0x01, 0x15, 0x25, 0x3e, 0x2e, 0x4e, 0xca, 0x7c, 0xc9, 0x29, 0x00, 0x08, + 0x4e, 0x23, 0x18, 0x51, 0x48, 0x51, 0x6c, 0xf4, 0x01, 0x5a, 0x0f, 0x23, + 0x88, 0xcc, 0x01, 0x4e, 0x4a, 0x80, 0xea, 0xf5, 0x01, 0x53, 0x46, 0x51, + 0x6d, 0xf4, 0x41, 0x4c, 0xec, 0x90, 0x07, 0x2a, 0x00, 0x4b, 0x07, 0xa6, + 0x08, 0x2a, 0x40, 0x43, 0x1a, 0x00, 0x55, 0x2a, 0x00, 0x42, 0x0c, 0x00, + 0x56, 0x2a, 0x40, 0x80, 0x06, 0x5a, 0x64, 0x0c, 0x2a, 0x2e, 0x40, 0x46, + 0x86, 0x81, 0x25, 0x20, 0x00, 0x4b, 0x73, 0x0c, 0x5a, 0x20, 0x40, 0x49, + 0xdc, 0xbe, 0xae, 0x20, 0x00, 0xac, 0xc4, 0x01, 0x4b, 0x7b, 0xa4, 0x43, + 0xf9, 0x01, 0xb2, 0x01, 0xff, 0xab, 0xac, 0x01, 0x04, 0x73, 0x07, 0x06, + 0x43, 0xbd, 0x01, 0x22, 0xf4, 0x41, 0xa1, 0x93, 0x01, 0x06, 0x0c, 0x03, + 0x82, 0x01, 0xa3, 0x74, 0xa4, 0x5b, 0x57, 0x0d, 0x30, 0x29, 0x21, 0x00, + 0x02, 0xb4, 0x01, 0x3b, 0x4c, 0x00, 0x98, 0x8f, 0xf5, 0x01, 0xb3, 0x06, + 0x51, 0x33, 0x62, 0xc9, 0x26, 0x40, 0x12, 0x39, 0x4a, 0x1d, 0x48, 0x5b, + 0x5c, 0x35, 0x2e, 0x00, 0x46, 0xea, 0xe3, 0x4e, 0x21, 0x00, 0x05, 0xc5, + 0x21, 0x01, 0xff, 0x52, 0x99, 0x53, 0x57, 0xf6, 0x01, 0x52, 0x15, 0x59, + 0x55, 0xf6, 0x41, 0xe7, 0x41, 0x21, 0x00, 0xec, 0x42, 0x21, 0x00, 0xf9, + 0x44, 0x21, 0x40, 0x04, 0xb6, 0x01, 0x06, 0x46, 0x11, 0x35, 0x19, 0x23, + 0x40, 0x52, 0x99, 0x53, 0x56, 0xf6, 0x01, 0x52, 0x15, 0x59, 0x54, 0xf6, + 0x41, 0x45, 0xc1, 0xe0, 0x38, 0x2e, 0x00, 0x06, 0xc1, 0x16, 0x01, 0xff, + 0x44, 0x25, 0x01, 0x8b, 0x21, 0x00, 0x42, 0x15, 0x02, 0x8a, 0x21, 0x40, + 0x48, 0x1f, 0xc9, 0x32, 0x21, 0x00, 0x44, 0x14, 0x05, 0x32, 0x2e, 0x40, + 0x48, 0x97, 0xcf, 0xc2, 0x2b, 0x00, 0x4b, 0x39, 0x62, 0xca, 0x26, 0x40, + 0x48, 0x36, 0x40, 0x4b, 0x21, 0x00, 0x44, 0x05, 0x02, 0xa2, 0x29, 0x40, + 0x42, 0xe8, 0x1d, 0x83, 0xf9, 0x01, 0x4d, 0x9c, 0x88, 0xba, 0x20, 0x40, + 0x42, 0xba, 0x04, 0x37, 0xf3, 0x01, 0x0b, 0x56, 0xa9, 0x01, 0xff, 0x4e, + 0x90, 0x79, 0xc9, 0x13, 0x01, 0x49, 0xed, 0xbc, 0xd0, 0x13, 0x01, 0xa4, + 0xd6, 0x03, 0x4f, 0xad, 0x70, 0xd2, 0x13, 0x01, 0x07, 0x13, 0x06, 0xa2, + 0x01, 0x45, 0x43, 0xf0, 0xd1, 0x13, 0x01, 0x05, 0x5a, 0x03, 0x5b, 0xb6, + 0x01, 0xff, 0x0a, 0x10, 0xaf, 0x48, 0x0a, 0xc8, 0x7a, 0x01, 0xff, 0xa1, + 0x35, 0x42, 0x27, 0x01, 0xc2, 0x13, 0x01, 0xe9, 0xb9, 0x13, 0x81, 0x26, + 0x42, 0xcd, 0x02, 0xc7, 0x13, 0x01, 0xf5, 0xbb, 0x13, 0x81, 0x17, 0x08, + 0xf2, 0xc6, 0x01, 0xff, 0xec, 0xbf, 0x13, 0x81, 0x09, 0xf2, 0xbd, 0x13, + 0xc1, 0x00, 0xf2, 0xbe, 0x13, 0x41, 0xec, 0xc0, 0x13, 0x41, 0xf5, 0xbc, + 0x13, 0x41, 0xe9, 0xba, 0x13, 0x41, 0xe1, 0xb8, 0x13, 0x01, 0xe9, 0xc5, + 0x13, 0x01, 0xf5, 0xc8, 0x13, 0x41, 0x48, 0xa4, 0x80, 0xe2, 0x13, 0x01, + 0x47, 0x60, 0x0b, 0xe1, 0x13, 0x41, 0xa1, 0x2f, 0x50, 0x0a, 0x64, 0xca, + 0x13, 0x01, 0x4d, 0x6c, 0x89, 0xcf, 0x13, 0x01, 0x4b, 0xd0, 0xa5, 0xd7, + 0x13, 0x01, 0x45, 0xe4, 0xef, 0xd3, 0x13, 0x01, 0x4e, 0x04, 0x80, 0xd8, + 0x13, 0x01, 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0x21, 0x25, 0xce, 0x13, + 0x01, 0x45, 0x49, 0x4e, 0xcd, 0x13, 0x41, 0x47, 0x0b, 0x17, 0xcc, 0x13, + 0x01, 0x47, 0x34, 0x8d, 0xb7, 0x13, 0x41, 0xe1, 0x80, 0x13, 0x81, 0x97, + 0x02, 0xa2, 0x8a, 0x02, 0xa3, 0xfd, 0x01, 0xa4, 0xe4, 0x01, 0x42, 0x27, + 0x01, 0x8b, 0x13, 0x01, 0xa7, 0xd1, 0x01, 0x42, 0x22, 0x00, 0xb2, 0x13, + 0x01, 0xe9, 0x82, 0x13, 0x81, 0xc1, 0x01, 0xaa, 0xb4, 0x01, 0xab, 0xa7, + 0x01, 0xac, 0x93, 0x01, 0x42, 0x6c, 0x00, 0xaa, 0x13, 0x01, 0xae, 0x75, + 0x42, 0xcd, 0x02, 0x90, 0x13, 0x01, 0xb0, 0x63, 0xb2, 0x57, 0xb3, 0x45, + 0xb4, 0x2c, 0xf5, 0x84, 0x13, 0x81, 0x23, 0xb6, 0x06, 0x42, 0xdf, 0x23, + 0xab, 0x13, 0x41, 0xe1, 0xae, 0x13, 0x01, 0x07, 0xf3, 0xc6, 0x01, 0xff, + 0xec, 0x88, 0x13, 0x81, 0x09, 0xf2, 0x86, 0x13, 0xc1, 0x00, 0xf2, 0x87, + 0x13, 0x41, 0xec, 0x89, 0x13, 0x41, 0xf5, 0x85, 0x13, 0x41, 0xe1, 0xa1, + 0x13, 0x01, 0x42, 0x22, 0x00, 0xa2, 0x13, 0x01, 0xb4, 0x01, 0xff, 0xe1, + 0x9c, 0x13, 0x01, 0x42, 0x22, 0x00, 0x9d, 0x13, 0x41, 0xe1, 0xb1, 0x13, + 0x01, 0x42, 0x22, 0x00, 0xaf, 0x13, 0x01, 0x42, 0x40, 0x06, 0xb0, 0x13, + 0x41, 0xe1, 0xac, 0x13, 0x01, 0x42, 0x71, 0x00, 0xb4, 0x13, 0x41, 0xe1, + 0xa6, 0x13, 0x01, 0x42, 0x22, 0x00, 0xa7, 0x13, 0x41, 0xe1, 0xa5, 0x13, + 0x01, 0x42, 0x24, 0x02, 0x96, 0x13, 0x01, 0x42, 0x2a, 0x05, 0xa0, 0x13, + 0x01, 0x42, 0xdf, 0x23, 0x9b, 0x13, 0x41, 0xe1, 0xad, 0x13, 0x01, 0xac, + 0x01, 0xff, 0xe1, 0xb3, 0x13, 0x01, 0x42, 0x74, 0x00, 0xb5, 0x13, 0x41, + 0xe1, 0x92, 0x13, 0x01, 0x42, 0x22, 0x00, 0x93, 0x13, 0x41, 0xe1, 0x99, + 0x13, 0x01, 0x42, 0x22, 0x00, 0x9a, 0x13, 0x41, 0xe9, 0x83, 0x13, 0x41, + 0xe1, 0x94, 0x13, 0x01, 0x42, 0x22, 0x00, 0x95, 0x13, 0x41, 0xe1, 0xa3, + 0x13, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0xa4, 0x13, 0x41, 0xe1, 0x9e, + 0x13, 0x01, 0x42, 0x22, 0x00, 0x9f, 0x13, 0x41, 0xe1, 0x97, 0x13, 0x01, + 0x42, 0x22, 0x00, 0x98, 0x13, 0x41, 0xe1, 0xa8, 0x13, 0x01, 0x42, 0x22, + 0x00, 0xa9, 0x13, 0x41, 0xe1, 0x81, 0x13, 0x01, 0xe9, 0x8e, 0x13, 0x01, + 0xf5, 0x91, 0x13, 0x41, 0x44, 0x96, 0x21, 0xd4, 0x13, 0x01, 0x4b, 0x33, + 0xa6, 0xd5, 0x13, 0x41, 0xa1, 0xc7, 0x02, 0xa5, 0xb8, 0x02, 0xa9, 0x43, + 0xaf, 0x14, 0xb5, 0x01, 0xff, 0xe5, 0xa8, 0x22, 0x80, 0x06, 0x44, 0x30, + 0xf7, 0xba, 0xf3, 0x41, 0x50, 0xea, 0x62, 0xdf, 0x2b, 0x40, 0x42, 0x60, + 0x07, 0xcc, 0xf9, 0x81, 0x20, 0x45, 0x6d, 0xee, 0x8a, 0xfa, 0x01, 0xb0, + 0x01, 0xff, 0x42, 0x35, 0x49, 0xc6, 0xf3, 0x01, 0x05, 0x36, 0x00, 0x01, + 0xff, 0x45, 0x4b, 0xd6, 0x79, 0xf3, 0x01, 0x44, 0xab, 0x5d, 0x20, 0xf4, + 0x41, 0x45, 0x2e, 0xec, 0x8e, 0xf6, 0x41, 0x03, 0x1c, 0x01, 0xb1, 0x01, + 0x45, 0xb7, 0x3d, 0x5d, 0x20, 0x00, 0x4b, 0xf8, 0x9f, 0x31, 0xf5, 0x01, + 0x09, 0x03, 0x9b, 0x6e, 0x04, 0x8f, 0x1e, 0x01, 0xff, 0x4e, 0xf2, 0x79, + 0xf6, 0x2a, 0x00, 0x46, 0xc0, 0xe0, 0x4b, 0x2e, 0x00, 0x14, 0xeb, 0x2b, + 0x4d, 0x48, 0x02, 0x28, 0x2d, 0x22, 0x00, 0x07, 0x60, 0xd9, 0x37, 0xb0, + 0x29, 0x57, 0x1b, 0x33, 0xfb, 0x2a, 0x00, 0x45, 0x71, 0x24, 0x4b, 0x22, + 0x00, 0x0d, 0x42, 0x01, 0x01, 0xff, 0x4f, 0x23, 0x33, 0xf4, 0x2a, 0x00, + 0x49, 0xfe, 0x3a, 0x80, 0x29, 0x00, 0x4f, 0x56, 0x01, 0xaa, 0x22, 0x00, + 0x56, 0x31, 0x3a, 0xf5, 0x2a, 0x40, 0x43, 0xc7, 0x29, 0xfb, 0x29, 0x00, + 0x44, 0x0d, 0x1c, 0x34, 0x20, 0x40, 0x4c, 0x87, 0x00, 0xf8, 0x2a, 0x00, + 0x49, 0xec, 0x00, 0xf7, 0x2a, 0x40, 0x56, 0x61, 0x35, 0x68, 0x2a, 0x00, + 0x56, 0xad, 0x39, 0x69, 0x2a, 0x40, 0x45, 0x94, 0x75, 0x37, 0x26, 0x00, + 0x44, 0x04, 0x96, 0x32, 0x26, 0x00, 0x46, 0x56, 0x7f, 0x30, 0x26, 0x00, + 0x44, 0x65, 0x30, 0x31, 0x26, 0x00, 0x48, 0xe5, 0x36, 0x36, 0x26, 0x00, + 0x47, 0xad, 0x7e, 0x33, 0x26, 0x00, 0xb7, 0x01, 0xff, 0x44, 0x8a, 0x00, + 0x35, 0x26, 0x00, 0x43, 0xe9, 0x06, 0x34, 0x26, 0x40, 0x02, 0x68, 0x00, + 0x17, 0x05, 0x1f, 0x01, 0x01, 0xff, 0x46, 0xd5, 0x22, 0x23, 0x20, 0x00, + 0x4c, 0xa4, 0x93, 0xa9, 0xf6, 0x01, 0x45, 0x9e, 0x31, 0xd0, 0xf4, 0x41, + 0x06, 0x50, 0x00, 0x06, 0x58, 0x9b, 0x06, 0x9d, 0x27, 0x40, 0x49, 0x77, + 0x1f, 0xca, 0x29, 0x00, 0x4f, 0x41, 0x1a, 0xc6, 0xf6, 0x01, 0x50, 0x0a, + 0x6a, 0xcd, 0x29, 0x00, 0x48, 0x64, 0x5c, 0xcb, 0x29, 0x40, 0x4b, 0x56, + 0x9e, 0x8e, 0xfa, 0x01, 0x48, 0x64, 0x1a, 0xbc, 0xce, 0x41, 0xa3, 0x30, + 0x4c, 0x84, 0x92, 0x22, 0x21, 0x00, 0x42, 0x9e, 0x01, 0x86, 0xf6, 0x01, + 0xed, 0x8a, 0xf6, 0x81, 0x19, 0x02, 0x5f, 0x01, 0x01, 0xff, 0xb0, 0x06, + 0x53, 0x0d, 0x51, 0xdb, 0x2a, 0x40, 0x4a, 0x30, 0xad, 0xf6, 0xf7, 0x01, + 0x44, 0x0c, 0xf7, 0xd7, 0x2b, 0x40, 0x44, 0xb6, 0x67, 0x8b, 0xf6, 0x41, + 0x45, 0xbe, 0xed, 0xb2, 0xf5, 0x01, 0x43, 0xc7, 0x07, 0x9c, 0xf6, 0x41, + 0x0c, 0x9c, 0x92, 0xfa, 0x06, 0x44, 0xaa, 0x39, 0xbd, 0xf6, 0x01, 0x49, + 0xe6, 0xc0, 0xfc, 0xf5, 0x01, 0x0a, 0xd0, 0xb2, 0xd1, 0x04, 0xad, 0xc2, + 0x04, 0x44, 0xc6, 0x6a, 0x45, 0xf4, 0x01, 0xaf, 0xa6, 0x04, 0x02, 0x20, + 0x00, 0x8f, 0x02, 0x17, 0xd6, 0x32, 0xbf, 0x01, 0xb4, 0x01, 0xff, 0x49, + 0x6a, 0xbb, 0x30, 0x23, 0x00, 0x02, 0x7b, 0x02, 0x01, 0xff, 0x07, 0x13, + 0x06, 0x06, 0x50, 0x2a, 0x6a, 0xae, 0xe2, 0x41, 0xe1, 0xad, 0xe2, 0x81, + 0x9d, 0x01, 0xa2, 0x7a, 0x43, 0xd0, 0x18, 0x9a, 0xe2, 0x01, 0x42, 0x7b, + 0x08, 0x93, 0xe2, 0x01, 0xe5, 0xa6, 0xe2, 0x81, 0x65, 0x42, 0x24, 0x02, + 0x95, 0xe2, 0x01, 0x42, 0x22, 0x00, 0x9e, 0xe2, 0x01, 0xe9, 0xa1, 0xe2, + 0x81, 0x50, 0x42, 0x78, 0x1a, 0x9d, 0xe2, 0x01, 0x42, 0x1b, 0x02, 0x94, + 0xe2, 0x01, 0x42, 0x74, 0x00, 0xa0, 0xe2, 0x01, 0x42, 0x6c, 0x00, 0x96, + 0xe2, 0x01, 0xae, 0x2c, 0xef, 0xaa, 0xe2, 0x01, 0x42, 0xe0, 0x09, 0x90, + 0xe2, 0x01, 0x42, 0x71, 0x00, 0x9f, 0xe2, 0x01, 0x42, 0x40, 0x06, 0x99, + 0xe2, 0x01, 0x42, 0x12, 0x00, 0x92, 0xe2, 0x01, 0xf5, 0xa5, 0xe2, 0x01, + 0x42, 0xa9, 0x01, 0x9c, 0xe2, 0x01, 0x42, 0xdf, 0x23, 0x9b, 0xe2, 0x41, + 0xe1, 0x97, 0xe2, 0x01, 0x42, 0x24, 0x02, 0x98, 0xe2, 0x41, 0xf5, 0xa3, + 0xe2, 0x41, 0xef, 0xa8, 0xe2, 0x41, 0xe1, 0x91, 0xe2, 0x01, 0x07, 0x2e, + 0xdb, 0x01, 0xff, 0x42, 0x42, 0x10, 0xac, 0xe2, 0x01, 0xe5, 0xa7, 0xe2, + 0x81, 0x09, 0xe9, 0xa2, 0xe2, 0xc1, 0x00, 0xf5, 0xa4, 0xe2, 0x41, 0xef, + 0xa9, 0xe2, 0x41, 0xe5, 0xab, 0xe2, 0x41, 0x16, 0xdd, 0x34, 0x06, 0x56, + 0xed, 0x36, 0x2a, 0xf1, 0x41, 0x02, 0x01, 0xfb, 0x31, 0x95, 0x23, 0x96, + 0x0f, 0x97, 0x01, 0xff, 0x43, 0x7c, 0xf9, 0x44, 0xf2, 0x01, 0x43, 0xca, + 0xf9, 0x46, 0xf2, 0x41, 0x43, 0x9a, 0xf9, 0x45, 0xf2, 0x01, 0x43, 0xbe, + 0xf9, 0x48, 0xf2, 0x01, 0x43, 0xd0, 0xf9, 0x40, 0xf2, 0x41, 0x43, 0x9d, + 0xf9, 0x47, 0xf2, 0x01, 0x43, 0xfa, 0xf9, 0x43, 0xf2, 0x41, 0x42, 0xdb, + 0xf9, 0x41, 0xf2, 0x01, 0x42, 0x5b, 0xe8, 0x42, 0xf2, 0x41, 0x04, 0x94, + 0x18, 0xfa, 0x01, 0x4d, 0xde, 0x0b, 0xde, 0x23, 0x00, 0x02, 0x22, 0x00, + 0x6a, 0x15, 0x79, 0x3e, 0x5a, 0x05, 0xc3, 0x00, 0x36, 0x4b, 0xfb, 0x22, + 0xdc, 0x23, 0x00, 0x06, 0xc8, 0x00, 0x12, 0x4e, 0x36, 0x28, 0xb4, 0x23, + 0x00, 0x56, 0x79, 0x09, 0xe0, 0x23, 0x00, 0x58, 0xb4, 0x2d, 0x1d, 0xf5, + 0x41, 0xa3, 0x0c, 0x4c, 0x28, 0x94, 0x23, 0x2e, 0x00, 0x69, 0x65, 0x04, + 0xec, 0xfb, 0x41, 0x45, 0x8a, 0x0b, 0x1d, 0x23, 0x00, 0x43, 0xb5, 0x0d, + 0x0e, 0x23, 0x40, 0x62, 0x7e, 0x0c, 0x07, 0xce, 0x01, 0xa3, 0x0c, 0x4c, + 0x28, 0x94, 0x22, 0x2e, 0x00, 0x6a, 0xee, 0x02, 0xef, 0xfb, 0x41, 0x45, + 0x8a, 0x0b, 0x1c, 0x23, 0x00, 0x43, 0xb5, 0x0d, 0x0f, 0x23, 0x40, 0x4c, + 0x0c, 0x03, 0xe8, 0xfb, 0x01, 0x4c, 0x00, 0x12, 0xe0, 0xfb, 0x41, 0x03, + 0x24, 0x00, 0x04, 0xf4, 0xa9, 0xf3, 0x41, 0x4c, 0x0c, 0x03, 0xca, 0x2b, + 0x00, 0xa6, 0x59, 0x48, 0x02, 0x28, 0x20, 0x23, 0x00, 0x04, 0xc3, 0x00, + 0x31, 0x05, 0xc8, 0x00, 0x0f, 0xb3, 0x01, 0xff, 0x4b, 0x11, 0x9a, 0x39, + 0x2e, 0x00, 0x4e, 0x99, 0x76, 0xe6, 0xcd, 0x41, 0x4c, 0xfa, 0x22, 0x5a, + 0x2e, 0x00, 0x09, 0x41, 0x66, 0x01, 0xff, 0x44, 0x28, 0x46, 0x5c, 0xcc, + 0x01, 0x0c, 0x78, 0x9b, 0x01, 0xff, 0xd1, 0xe8, 0xcd, 0x01, 0xd2, 0xea, + 0xcd, 0x41, 0x4c, 0xfa, 0x22, 0x59, 0x2e, 0x00, 0x09, 0x41, 0x66, 0x01, + 0xff, 0x44, 0x28, 0x46, 0x5a, 0xcc, 0x01, 0x0c, 0x78, 0x9b, 0x01, 0xff, + 0xd1, 0xec, 0xcd, 0x01, 0xd2, 0xee, 0xcd, 0x41, 0x14, 0x1f, 0x46, 0x11, + 0x0f, 0x3b, 0x66, 0x01, 0xff, 0x44, 0x28, 0x46, 0x5b, 0xcc, 0x01, 0x45, + 0x78, 0x9b, 0xf0, 0xcd, 0x41, 0xd1, 0xf6, 0xcd, 0x01, 0xd2, 0xf7, 0xcd, + 0x41, 0x53, 0x10, 0x11, 0x3a, 0x29, 0x80, 0x06, 0x5a, 0x9f, 0x20, 0x3c, + 0x29, 0x40, 0x4a, 0xc8, 0xab, 0x3d, 0x29, 0x40, 0x44, 0xb0, 0x89, 0xf0, + 0xf9, 0x01, 0x42, 0x53, 0x00, 0xb7, 0xf9, 0xc1, 0x00, 0x45, 0x53, 0xbb, + 0xa5, 0xfa, 0x41, 0x43, 0x28, 0x17, 0x45, 0xf3, 0x01, 0x4c, 0xb8, 0x97, + 0xae, 0xf1, 0x41, 0x06, 0xef, 0x06, 0xd1, 0x01, 0x07, 0x13, 0x06, 0x16, + 0x05, 0x5a, 0x03, 0x06, 0x45, 0xba, 0xf1, 0xdb, 0x1d, 0x41, 0x46, 0x52, + 0xe2, 0xda, 0x1d, 0x01, 0x44, 0x90, 0xf8, 0xd9, 0x1d, 0x41, 0xe1, 0xb4, + 0x1d, 0x81, 0xad, 0x01, 0xe2, 0xb8, 0x1d, 0x81, 0xa3, 0x01, 0xe3, 0xc5, + 0x1d, 0x81, 0x99, 0x01, 0xe4, 0xbd, 0x1d, 0x81, 0x86, 0x01, 0xe5, 0xb1, + 0x1d, 0x01, 0xe7, 0xcc, 0x1d, 0x81, 0x79, 0xe8, 0xd5, 0x1d, 0x01, 0xe9, + 0xb0, 0x1d, 0x01, 0xea, 0xc7, 0x1d, 0x81, 0x68, 0xeb, 0xca, 0x1d, 0x81, + 0x5f, 0xec, 0xd1, 0x1d, 0x01, 0xed, 0xba, 0x1d, 0x01, 0xee, 0xbf, 0x1d, + 0x81, 0x41, 0xef, 0xb3, 0x1d, 0x01, 0xf0, 0xb6, 0x1d, 0x81, 0x34, 0xf2, + 0xd0, 0x1d, 0x81, 0x26, 0xf3, 0xd4, 0x1d, 0x01, 0xf4, 0xbb, 0x1d, 0x81, + 0x10, 0xf5, 0xb2, 0x1d, 0x01, 0xf6, 0xd2, 0x1d, 0x01, 0xf8, 0xd6, 0x1d, + 0x01, 0xf9, 0xcf, 0x1d, 0x41, 0xe8, 0xbc, 0x1d, 0x01, 0xf4, 0xc0, 0x1d, + 0xc1, 0x00, 0xe8, 0xc1, 0x1d, 0x41, 0xf2, 0xd7, 0x1d, 0xc1, 0x00, 0xe8, + 0xd8, 0x1d, 0x41, 0xe8, 0xb7, 0x1d, 0x41, 0xe7, 0xce, 0x1d, 0x01, 0xee, + 0xc4, 0x1d, 0x81, 0x04, 0xf9, 0xc9, 0x1d, 0x41, 0xf9, 0xd3, 0x1d, 0x41, + 0xe8, 0xcb, 0x1d, 0x41, 0xe8, 0xc8, 0x1d, 0x41, 0xe8, 0xcd, 0x1d, 0x41, + 0xe4, 0xc2, 0x1d, 0x81, 0x04, 0xe8, 0xbe, 0x1d, 0x41, 0xe8, 0xc3, 0x1d, + 0x41, 0xe8, 0xc6, 0x1d, 0x41, 0xe8, 0xb9, 0x1d, 0x41, 0xe1, 0xb5, 0x1d, + 0x41, 0x45, 0x7e, 0x0b, 0xe8, 0x1d, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, + 0xe9, 0x1d, 0x01, 0x43, 0x7a, 0x0b, 0xe1, 0x1d, 0x01, 0xb3, 0x14, 0xb4, + 0x06, 0x44, 0x80, 0x1f, 0xe0, 0x1d, 0x41, 0x44, 0x25, 0x01, 0xe3, 0x1d, + 0x01, 0x42, 0x15, 0x02, 0xe2, 0x1d, 0x41, 0x44, 0x06, 0x1f, 0xe7, 0x1d, + 0x01, 0x42, 0x09, 0x24, 0xe6, 0x1d, 0x41, 0x43, 0xf9, 0x05, 0xe5, 0x1d, + 0x01, 0x43, 0xf6, 0x06, 0xe4, 0x1d, 0x41, 0xe1, 0xc0, 0x05, 0x81, 0xa9, + 0x02, 0x42, 0x16, 0x00, 0xc2, 0x05, 0x01, 0xa3, 0x96, 0x02, 0xa4, 0x89, + 0x02, 0xe5, 0xca, 0x05, 0x81, 0xff, 0x01, 0x42, 0x0c, 0x08, 0xcb, 0x05, + 0x01, 0xa7, 0xe6, 0x01, 0xa8, 0xd9, 0x01, 0xe9, 0xd2, 0x05, 0x01, 0xaa, + 0xca, 0x01, 0xab, 0xbd, 0x01, 0xac, 0xb0, 0x01, 0xad, 0xa3, 0x01, 0xae, + 0x78, 0xef, 0xda, 0x05, 0x81, 0x6f, 0xb0, 0x63, 0x42, 0x11, 0x15, 0xdc, + 0x05, 0x01, 0xb2, 0x51, 0xb3, 0x33, 0xb4, 0x27, 0xf5, 0xe4, 0x05, 0x01, + 0x42, 0x61, 0x0b, 0xe5, 0x05, 0x01, 0xb8, 0x11, 0xf9, 0xea, 0x05, 0x01, + 0xba, 0x01, 0xff, 0xe1, 0xec, 0x05, 0x01, 0x42, 0x22, 0x00, 0xed, 0x05, + 0x41, 0xe1, 0xe6, 0x05, 0x01, 0x42, 0x22, 0x00, 0xe8, 0x05, 0x41, 0xe1, + 0xe2, 0x05, 0x01, 0x42, 0x22, 0x00, 0xe3, 0x05, 0x41, 0xe1, 0xdf, 0x05, + 0x01, 0xa8, 0x0c, 0x43, 0xbf, 0x28, 0xf0, 0x05, 0x01, 0x42, 0x12, 0x00, + 0xef, 0x05, 0x41, 0xe1, 0xe0, 0x05, 0x01, 0x42, 0x12, 0x00, 0xe1, 0x05, + 0x41, 0xe1, 0xdd, 0x05, 0x01, 0x42, 0x71, 0x00, 0xde, 0x05, 0x41, 0xe1, + 0xdb, 0x05, 0x01, 0x42, 0x40, 0x06, 0xf2, 0x05, 0x41, 0xef, 0xf3, 0x05, + 0x41, 0xe1, 0xd8, 0x05, 0x01, 0x42, 0x7b, 0x08, 0xc7, 0x05, 0x01, 0xa7, + 0x13, 0x43, 0x62, 0xbb, 0xd9, 0x05, 0x01, 0xb8, 0x01, 0xff, 0xe1, 0xe7, + 0x05, 0x01, 0x42, 0x22, 0x00, 0xe9, 0x05, 0x41, 0xe1, 0xcd, 0x05, 0x01, + 0x42, 0x78, 0x1a, 0xcf, 0x05, 0x41, 0xe1, 0xd7, 0x05, 0x01, 0x42, 0x16, + 0x00, 0xc3, 0x05, 0x41, 0xe1, 0xd5, 0x05, 0x01, 0x42, 0x74, 0x00, 0xd6, + 0x05, 0x41, 0xe1, 0xd4, 0x05, 0x01, 0x42, 0x22, 0x00, 0xf1, 0x05, 0x41, + 0xe1, 0xd3, 0x05, 0x01, 0xf9, 0xeb, 0x05, 0x41, 0xe1, 0xd0, 0x05, 0x01, + 0x42, 0x78, 0x1a, 0xd1, 0x05, 0x41, 0xe1, 0xcc, 0x05, 0x01, 0x42, 0x22, + 0x00, 0xee, 0x05, 0x01, 0x42, 0x78, 0x1a, 0xce, 0x05, 0x41, 0xe9, 0xc9, + 0x05, 0x41, 0xe1, 0xc6, 0x05, 0x01, 0x42, 0x22, 0x00, 0xc8, 0x05, 0x41, + 0xe1, 0xc4, 0x05, 0x01, 0x42, 0x22, 0x00, 0xc5, 0x05, 0x41, 0xf3, 0xc1, + 0x05, 0x41, 0x06, 0x0c, 0xe0, 0xde, 0x07, 0x44, 0x8b, 0x09, 0xab, 0xf3, + 0x01, 0x4f, 0xae, 0x6f, 0xdd, 0x29, 0x00, 0x07, 0xea, 0xd6, 0xa6, 0x05, + 0xa7, 0x90, 0x05, 0x43, 0x58, 0x1f, 0x7e, 0x00, 0x80, 0xbf, 0x04, 0x02, + 0x2a, 0x02, 0xa3, 0x04, 0x42, 0x9f, 0x1b, 0xfe, 0x29, 0x80, 0x95, 0x04, + 0xb2, 0x01, 0xff, 0x47, 0xe1, 0x15, 0x2b, 0xf6, 0x01, 0x05, 0x1e, 0xed, + 0x11, 0x0b, 0xe6, 0xa5, 0x01, 0xff, 0x4a, 0xda, 0xad, 0x52, 0x2e, 0x00, + 0x42, 0x14, 0x06, 0x4a, 0x20, 0x40, 0xa1, 0xe8, 0x03, 0x06, 0xef, 0x06, + 0xa1, 0x03, 0x45, 0xb0, 0xec, 0xc5, 0x14, 0x01, 0x07, 0x13, 0x06, 0x85, + 0x01, 0x42, 0x14, 0x05, 0xc7, 0x14, 0x01, 0x05, 0x5a, 0x03, 0x50, 0x0b, + 0xc7, 0x7a, 0x01, 0xff, 0xa1, 0x3d, 0xe5, 0xb9, 0x14, 0x01, 0xe9, 0xb1, + 0x14, 0x81, 0x30, 0xef, 0xbc, 0x14, 0x01, 0x06, 0x33, 0x07, 0x20, 0xf5, + 0xb3, 0x14, 0x81, 0x17, 0x08, 0xf2, 0xc6, 0x01, 0xff, 0xec, 0xb7, 0x14, + 0x81, 0x09, 0xf2, 0xb5, 0x14, 0xc1, 0x00, 0xf2, 0xb6, 0x14, 0x41, 0xec, + 0xb8, 0x14, 0x41, 0xf5, 0xb4, 0x14, 0x41, 0xe5, 0xba, 0x14, 0x01, 0xef, + 0xbd, 0x14, 0x41, 0xe9, 0xb2, 0x14, 0x41, 0xe1, 0xb0, 0x14, 0x01, 0xe9, + 0xbb, 0x14, 0x01, 0xf5, 0xbe, 0x14, 0x41, 0xa1, 0x1d, 0x4b, 0x13, 0x25, + 0xbf, 0x14, 0x01, 0x45, 0x62, 0x41, 0xc3, 0x14, 0x01, 0x02, 0x02, 0x00, + 0x01, 0xff, 0x44, 0x21, 0x25, 0xc2, 0x14, 0x01, 0x45, 0x49, 0x4e, 0xc1, + 0x14, 0x41, 0x47, 0x0b, 0x17, 0xc0, 0x14, 0x01, 0x47, 0x34, 0x8d, 0xc4, + 0x14, 0x41, 0xe1, 0x81, 0x14, 0x81, 0xff, 0x01, 0xa2, 0xf2, 0x01, 0xa3, + 0xe5, 0x01, 0xa4, 0xcc, 0x01, 0xe5, 0x8b, 0x14, 0x01, 0xa7, 0xbb, 0x01, + 0x42, 0x22, 0x00, 0xaf, 0x14, 0x01, 0xe9, 0x83, 0x14, 0x81, 0xab, 0x01, + 0xaa, 0x9e, 0x01, 0xab, 0x91, 0x01, 0x42, 0x74, 0x00, 0xaa, 0x14, 0x01, + 0x42, 0x6c, 0x00, 0xa7, 0x14, 0x01, 0xae, 0x6d, 0xef, 0x8d, 0x14, 0x01, + 0xb0, 0x5d, 0x42, 0x71, 0x00, 0xa9, 0x14, 0x01, 0xb3, 0x45, 0xb4, 0x2c, + 0xf5, 0x85, 0x14, 0x81, 0x23, 0xb6, 0x06, 0x42, 0xdf, 0x23, 0xa8, 0x14, + 0x41, 0xe1, 0xab, 0x14, 0x01, 0x07, 0xf3, 0xc6, 0x01, 0xff, 0xec, 0x89, + 0x14, 0x81, 0x09, 0xf2, 0x87, 0x14, 0xc1, 0x00, 0xf2, 0x88, 0x14, 0x41, + 0xec, 0x8a, 0x14, 0x41, 0xf5, 0x86, 0x14, 0x41, 0xe1, 0x9e, 0x14, 0x01, + 0x42, 0x22, 0x00, 0x9f, 0x14, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x99, 0x14, + 0x01, 0x42, 0x22, 0x00, 0x9a, 0x14, 0x41, 0xe1, 0xae, 0x14, 0x01, 0x42, + 0x22, 0x00, 0xac, 0x14, 0x01, 0x42, 0x40, 0x06, 0xad, 0x14, 0x41, 0xe1, + 0xa3, 0x14, 0x01, 0x42, 0x22, 0x00, 0xa4, 0x14, 0x41, 0xe1, 0xa2, 0x14, + 0x01, 0x42, 0x24, 0x02, 0x93, 0x14, 0x01, 0x42, 0x2a, 0x05, 0x9d, 0x14, + 0x01, 0x42, 0xdf, 0x23, 0x98, 0x14, 0x41, 0xe1, 0x8f, 0x14, 0x01, 0x42, + 0x22, 0x00, 0x90, 0x14, 0x41, 0xe1, 0x96, 0x14, 0x01, 0x42, 0x22, 0x00, + 0x97, 0x14, 0x41, 0xe9, 0x84, 0x14, 0x41, 0xe1, 0x91, 0x14, 0x01, 0x42, + 0x22, 0x00, 0x92, 0x14, 0x41, 0xe1, 0xa0, 0x14, 0x01, 0xa4, 0x06, 0x42, + 0x22, 0x00, 0xa1, 0x14, 0x41, 0xe1, 0x9b, 0x14, 0x01, 0x42, 0x22, 0x00, + 0x9c, 0x14, 0x41, 0xe1, 0x94, 0x14, 0x01, 0x42, 0x22, 0x00, 0x95, 0x14, + 0x41, 0xe1, 0xa5, 0x14, 0x01, 0x42, 0x22, 0x00, 0xa6, 0x14, 0x41, 0xe1, + 0x82, 0x14, 0x01, 0xe9, 0x8c, 0x14, 0x01, 0xf5, 0x8e, 0x14, 0x41, 0x45, + 0x7e, 0x0b, 0xd8, 0x14, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xd9, 0x14, + 0x01, 0x43, 0x7a, 0x0b, 0xd1, 0x14, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, + 0x80, 0x1f, 0xd0, 0x14, 0x41, 0x44, 0x25, 0x01, 0xd3, 0x14, 0x01, 0x42, + 0x15, 0x02, 0xd2, 0x14, 0x41, 0x44, 0x06, 0x1f, 0xd7, 0x14, 0x01, 0x42, + 0x09, 0x24, 0xd6, 0x14, 0x41, 0x43, 0xf9, 0x05, 0xd5, 0x14, 0x01, 0x43, + 0xf6, 0x06, 0xd4, 0x14, 0x41, 0x50, 0x5e, 0x5a, 0xc6, 0x14, 0x01, 0x43, + 0xc5, 0x8b, 0x80, 0x14, 0x41, 0x62, 0x5c, 0x0c, 0x3a, 0x0b, 0x41, 0x47, + 0x45, 0x1c, 0xf2, 0x23, 0x00, 0x07, 0xbc, 0x07, 0x01, 0xff, 0x4f, 0xab, + 0x72, 0xd4, 0x29, 0x00, 0x50, 0xca, 0x69, 0xd5, 0x29, 0x40, 0x80, 0x01, + 0xff, 0x48, 0xa0, 0x1e, 0x3c, 0x22, 0x80, 0x1b, 0x05, 0x51, 0x00, 0x01, + 0xff, 0x04, 0x6f, 0x0c, 0x06, 0x4a, 0xfa, 0xb5, 0x1b, 0x2e, 0x40, 0x45, + 0x5c, 0x00, 0x1e, 0x2e, 0x00, 0x45, 0x20, 0x07, 0x1f, 0x2e, 0x40, 0x80, + 0x01, 0xff, 0x06, 0x5c, 0x00, 0x11, 0x05, 0x51, 0x00, 0x01, 0xff, 0x49, + 0x77, 0x1f, 0x6a, 0x2a, 0x00, 0x4b, 0x5c, 0xa7, 0x6b, 0x2a, 0x40, 0x4f, + 0x6f, 0x1b, 0x49, 0x2b, 0x00, 0x50, 0xb3, 0x02, 0x72, 0x29, 0x40, 0x42, + 0x33, 0x00, 0x05, 0xf4, 0x81, 0x06, 0x57, 0x52, 0x30, 0x45, 0x27, 0x40, + 0x45, 0x0b, 0x08, 0x2f, 0xf4, 0x41, 0x50, 0x6a, 0x64, 0x7f, 0x2d, 0x00, + 0x07, 0x13, 0x06, 0x0c, 0x62, 0xe4, 0x0c, 0x6f, 0x2d, 0x00, 0x4e, 0xda, + 0x7f, 0x70, 0x2d, 0x40, 0xa1, 0x82, 0x02, 0x11, 0x18, 0x5b, 0xf5, 0x01, + 0xb4, 0xc0, 0x01, 0xb9, 0x01, 0xff, 0xe1, 0x30, 0x2d, 0x80, 0x15, 0xe5, + 0x66, 0x2d, 0x80, 0x0c, 0xe9, 0x49, 0x2d, 0x00, 0xef, 0x67, 0x2d, 0x00, + 0xf5, 0x53, 0x2d, 0x40, 0xf9, 0x3b, 0x2d, 0x40, 0xe1, 0x44, 0x2d, 0x00, + 0xe2, 0x31, 0x2d, 0x80, 0x95, 0x01, 0x42, 0x3b, 0x15, 0x5e, 0x2d, 0x00, + 0xe4, 0x37, 0x2d, 0x80, 0x7d, 0xe6, 0x3c, 0x2d, 0x00, 0xe7, 0x33, 0x2d, + 0x80, 0x6b, 0xe8, 0x40, 0x2d, 0x80, 0x62, 0xea, 0x36, 0x2d, 0x00, 0xeb, + 0x3d, 0x2d, 0x80, 0x50, 0xec, 0x4d, 0x2d, 0x00, 0xed, 0x4e, 0x2d, 0x00, + 0xee, 0x4f, 0x2d, 0x00, 0xf0, 0x52, 0x2d, 0x00, 0xf1, 0x47, 0x2d, 0x00, + 0xf2, 0x54, 0x2d, 0x80, 0x33, 0xf3, 0x59, 0x2d, 0x80, 0x26, 0xf4, 0x5c, + 0x2d, 0x80, 0x19, 0xf6, 0x60, 0x2d, 0x00, 0xf7, 0x61, 0x2d, 0x00, 0xf9, + 0x62, 0x2d, 0x00, 0xfa, 0x63, 0x2d, 0xc0, 0x00, 0xe8, 0x4a, 0x2d, 0x00, + 0xfa, 0x65, 0x2d, 0x40, 0xe8, 0x5d, 0x2d, 0x00, 0xf4, 0x5f, 0x2d, 0x40, + 0xe8, 0x5b, 0x2d, 0x00, 0xf3, 0x5a, 0x2d, 0x40, 0xf2, 0x55, 0x2d, 0x40, + 0xe8, 0x45, 0x2d, 0xc0, 0x00, 0xe8, 0x3f, 0x2d, 0x40, 0xe8, 0x43, 0x2d, + 0x40, 0xe8, 0x56, 0x2d, 0xc0, 0x00, 0xe8, 0x34, 0x2d, 0x40, 0xe4, 0x39, + 0x2d, 0x80, 0x04, 0xe8, 0x38, 0x2d, 0x40, 0xe8, 0x3a, 0x2d, 0x40, 0xe8, + 0x32, 0x2d, 0x40, 0x4d, 0x01, 0x85, 0x64, 0x2d, 0x00, 0x08, 0x9f, 0xd1, + 0x01, 0xff, 0xa7, 0x1d, 0xe8, 0x42, 0x2d, 0x00, 0xeb, 0x3e, 0x2d, 0x80, + 0x10, 0x42, 0x1d, 0x01, 0x51, 0x2d, 0x00, 0xf1, 0x48, 0x2d, 0x00, 0x42, + 0xc2, 0x29, 0x4c, 0x2d, 0x40, 0xe8, 0x46, 0x2d, 0x40, 0xe8, 0x57, 0x2d, + 0x00, 0xee, 0x50, 0x2d, 0x40, 0xe8, 0x41, 0x2d, 0x00, 0xea, 0x35, 0x2d, + 0x40, 0x4b, 0xd1, 0xa1, 0x4b, 0x2d, 0x00, 0x48, 0x97, 0xd2, 0x58, 0x2d, + 0x40, 0x12, 0xaf, 0x52, 0x9d, 0x0b, 0x12, 0x1b, 0x53, 0x80, 0x0b, 0x06, + 0xef, 0x06, 0xf3, 0x09, 0x49, 0xdd, 0xc0, 0xbe, 0x0f, 0x80, 0xe5, 0x09, + 0xac, 0xbf, 0x07, 0x05, 0xb9, 0x00, 0xf6, 0x04, 0xb3, 0x51, 0x0b, 0xc7, + 0x7a, 0x01, 0xff, 0x42, 0x4e, 0x13, 0x71, 0x0f, 0x00, 0xe5, 0x7a, 0x0f, + 0x80, 0x3d, 0xe9, 0x72, 0x0f, 0x80, 0x34, 0xef, 0x7c, 0x0f, 0x80, 0x2b, + 0x4a, 0xbe, 0xb5, 0x80, 0x0f, 0x80, 0x20, 0xf5, 0x74, 0x0f, 0x80, 0x17, + 0x08, 0xf2, 0xc6, 0x01, 0xff, 0xec, 0x78, 0x0f, 0x80, 0x09, 0xf2, 0x76, + 0x0f, 0xc0, 0x00, 0xf2, 0x77, 0x0f, 0x40, 0xec, 0x79, 0x0f, 0x40, 0xf5, + 0x75, 0x0f, 0x40, 0xe9, 0x81, 0x0f, 0x40, 0xef, 0x7d, 0x0f, 0x40, 0xe9, + 0x73, 0x0f, 0x40, 0xe5, 0x7b, 0x0f, 0x40, 0x04, 0x5b, 0x03, 0xfd, 0x02, + 0x09, 0xea, 0x6a, 0x4b, 0xb9, 0x01, 0xff, 0x49, 0x5b, 0xc1, 0x00, 0x0f, + 0x00, 0x05, 0x2f, 0x17, 0x01, 0xff, 0x47, 0x34, 0xd6, 0xc4, 0x0f, 0x00, + 0x46, 0x62, 0xe4, 0xc9, 0x0f, 0x80, 0x1b, 0xb0, 0x0d, 0x47, 0x27, 0xdb, + 0xc5, 0x0f, 0xc0, 0x00, 0x4a, 0x6e, 0xab, 0xc7, 0x0f, 0x40, 0x49, 0x34, + 0xbb, 0xc6, 0x0f, 0x00, 0x46, 0x94, 0xe2, 0xc8, 0x0f, 0x40, 0x80, 0x01, + 0xff, 0x4b, 0xda, 0x9e, 0xcc, 0x0f, 0x00, 0x4b, 0xbb, 0xa1, 0xcb, 0x0f, + 0x00, 0x4b, 0x99, 0xa5, 0xca, 0x0f, 0x40, 0x07, 0x13, 0x06, 0x17, 0x05, + 0x5a, 0x03, 0x01, 0xff, 0x51, 0xc0, 0x5d, 0x8f, 0x0f, 0x00, 0x4b, 0x7e, + 0xa3, 0x8d, 0x0f, 0x00, 0x48, 0xc9, 0x5d, 0x8e, 0x0f, 0x40, 0x42, 0x3d, + 0x27, 0xb0, 0x0f, 0x00, 0xe1, 0xb8, 0x0f, 0x00, 0xa2, 0xfc, 0x01, 0xa3, + 0xef, 0x01, 0xa4, 0xc9, 0x01, 0x0b, 0x09, 0x87, 0xb2, 0x01, 0xa7, 0xa5, + 0x01, 0x42, 0x22, 0x00, 0xb7, 0x0f, 0x00, 0x42, 0x78, 0x1a, 0x97, 0x0f, + 0x00, 0xab, 0x86, 0x01, 0x42, 0x74, 0x00, 0xb3, 0x0f, 0x00, 0x42, 0x6c, + 0x00, 0xa8, 0x0f, 0x00, 0xae, 0x62, 0xb0, 0x56, 0x42, 0x71, 0x00, 0xb2, + 0x0f, 0x00, 0xb3, 0x3e, 0xb4, 0x19, 0x42, 0xa9, 0x01, 0xad, 0x0f, 0x00, + 0x42, 0xdf, 0x23, 0xb1, 0x0f, 0x00, 0xba, 0x01, 0xff, 0xe1, 0xaf, 0x0f, + 0x00, 0x42, 0x22, 0x00, 0xae, 0x0f, 0x40, 0xe1, 0x9f, 0x0f, 0x00, 0x42, + 0x22, 0x00, 0xa0, 0x0f, 0x00, 0xb3, 0x0d, 0xb4, 0x01, 0xff, 0xe1, 0x9a, + 0x0f, 0x00, 0x42, 0x22, 0x00, 0x9b, 0x0f, 0x40, 0xe1, 0xa9, 0x0f, 0x00, + 0x42, 0x22, 0x00, 0xaa, 0x0f, 0x40, 0xe1, 0xb6, 0x0f, 0x00, 0x42, 0x22, + 0x00, 0xb4, 0x0f, 0x00, 0x42, 0x40, 0x06, 0xb5, 0x0f, 0x40, 0xe1, 0xa4, + 0x0f, 0x00, 0x42, 0x22, 0x00, 0xa5, 0x0f, 0x40, 0xe1, 0xa3, 0x0f, 0x00, + 0x42, 0x24, 0x02, 0x94, 0x0f, 0x00, 0x42, 0x2a, 0x05, 0x9e, 0x0f, 0x00, + 0x42, 0xdf, 0x23, 0x99, 0x0f, 0x40, 0xe1, 0x90, 0x0f, 0x00, 0x42, 0x22, + 0x00, 0x91, 0x0f, 0x00, 0x43, 0x1e, 0x22, 0xb9, 0x0f, 0x40, 0xe1, 0x92, + 0x0f, 0x00, 0x42, 0x22, 0x00, 0x93, 0x0f, 0x40, 0x42, 0x71, 0x00, 0xbc, + 0x0f, 0x00, 0x42, 0xa9, 0x01, 0xba, 0x0f, 0x00, 0x42, 0xdf, 0x23, 0xbb, + 0x0f, 0x40, 0xe1, 0xa1, 0x0f, 0x00, 0xa4, 0x13, 0x42, 0x22, 0x00, 0xa2, + 0x0f, 0x00, 0xba, 0x01, 0xff, 0xe1, 0xab, 0x0f, 0x00, 0x42, 0x22, 0x00, + 0xac, 0x0f, 0x40, 0xe1, 0x9c, 0x0f, 0x00, 0x42, 0x22, 0x00, 0x9d, 0x0f, + 0x40, 0xe1, 0x95, 0x0f, 0x00, 0x42, 0x22, 0x00, 0x96, 0x0f, 0x40, 0xe1, + 0xa6, 0x0f, 0x00, 0x42, 0x22, 0x00, 0xa7, 0x0f, 0x40, 0x04, 0xf8, 0xf5, + 0x90, 0x01, 0x51, 0xc0, 0x5d, 0x8c, 0x0f, 0x00, 0x02, 0x2c, 0x3c, 0x7a, + 0xad, 0x6c, 0x4e, 0xe2, 0x7d, 0x82, 0x0f, 0x00, 0xb2, 0x17, 0x48, 0xcf, + 0xd0, 0x83, 0x0f, 0x00, 0x02, 0xdf, 0x23, 0x01, 0xff, 0x48, 0x4f, 0xce, + 0x87, 0x0f, 0x00, 0x47, 0x28, 0xc9, 0x3e, 0x0f, 0x40, 0x04, 0x50, 0xc4, + 0x0c, 0x4d, 0xdd, 0x88, 0x7e, 0x0f, 0x00, 0x48, 0xb1, 0x99, 0x7f, 0x0f, + 0x40, 0x05, 0x8e, 0xeb, 0x1f, 0x04, 0x48, 0xf7, 0x01, 0xff, 0xa7, 0x06, + 0x49, 0x4f, 0xc4, 0xce, 0x0f, 0x40, 0x43, 0x0c, 0xfa, 0x1d, 0x0f, 0x00, + 0x44, 0x99, 0xa5, 0x1e, 0x0f, 0x00, 0x43, 0xa8, 0x58, 0xcf, 0x0f, 0x40, + 0xa7, 0x06, 0x48, 0x07, 0xd0, 0x1f, 0x0f, 0x40, 0x43, 0x0c, 0xfa, 0x1a, + 0x0f, 0x00, 0x44, 0x99, 0xa5, 0x1b, 0x0f, 0x00, 0x43, 0xa8, 0x58, 0x1c, + 0x0f, 0x40, 0x48, 0x27, 0xc9, 0x3f, 0x0f, 0x00, 0x47, 0xca, 0x5d, 0x89, + 0x0f, 0x40, 0x49, 0x80, 0xa3, 0x88, 0x0f, 0x00, 0x47, 0x8b, 0xd7, 0x86, + 0x0f, 0x40, 0x4b, 0xf0, 0x9e, 0x8a, 0x0f, 0x00, 0x4b, 0x91, 0xa4, 0x8b, + 0x0f, 0x40, 0x0c, 0xf8, 0x90, 0xb3, 0x02, 0xa2, 0x88, 0x02, 0xa3, 0xd4, + 0x01, 0x55, 0x57, 0x3c, 0x0c, 0x0f, 0x00, 0xa7, 0x95, 0x01, 0x47, 0x3e, + 0xd7, 0x84, 0x0f, 0x00, 0x02, 0x9e, 0x01, 0x75, 0x53, 0x1e, 0x4d, 0xd9, + 0x0f, 0x00, 0x56, 0x9d, 0x37, 0xd1, 0x0f, 0x00, 0xae, 0x3f, 0x46, 0xf2, + 0xe4, 0x85, 0x0f, 0x00, 0xb2, 0x2b, 0xb3, 0x1d, 0xb4, 0x06, 0x55, 0x82, + 0x41, 0x07, 0x0f, 0x40, 0x53, 0xc0, 0x4e, 0xda, 0x0f, 0x00, 0xb3, 0x01, + 0xff, 0x47, 0x35, 0xd4, 0x39, 0x0f, 0x00, 0x48, 0x8c, 0x41, 0x0f, 0x0f, + 0x40, 0x49, 0x6f, 0xbc, 0x08, 0x0f, 0x00, 0x43, 0xa5, 0x02, 0x0d, 0x0f, + 0x40, 0x4d, 0x7e, 0x87, 0x12, 0x0f, 0x00, 0x53, 0x99, 0x4c, 0x11, 0x0f, + 0x40, 0x0a, 0x28, 0xb0, 0x18, 0x04, 0x9a, 0xa5, 0x01, 0xff, 0x44, 0xa4, + 0x02, 0x0e, 0x0f, 0x00, 0x45, 0x61, 0x3c, 0xd2, 0x0f, 0xc0, 0x00, 0x45, + 0x4a, 0x04, 0x10, 0x0f, 0x40, 0x47, 0xe2, 0x7d, 0x35, 0x0f, 0x00, 0x4a, + 0x90, 0xb6, 0x37, 0x0f, 0x40, 0x06, 0x88, 0x17, 0x06, 0x51, 0xf0, 0x60, + 0x0b, 0x0f, 0x40, 0x5b, 0x99, 0x1b, 0xd3, 0x0f, 0x00, 0x4f, 0xa5, 0x1b, + 0x04, 0x0f, 0x40, 0x04, 0x08, 0x03, 0x11, 0x0b, 0x77, 0xa9, 0x01, 0xff, + 0x42, 0xbb, 0x01, 0x3b, 0x0f, 0x00, 0x42, 0x10, 0x00, 0x3a, 0x0f, 0x40, + 0x45, 0x61, 0x3c, 0x14, 0x0f, 0x00, 0x08, 0xa5, 0x1b, 0x01, 0xff, 0x04, + 0xb4, 0xf2, 0x06, 0x4b, 0x2a, 0xa9, 0x01, 0x0f, 0x40, 0x4d, 0x71, 0x87, + 0x03, 0x0f, 0x00, 0x4c, 0xb0, 0x99, 0x02, 0x0f, 0x40, 0x05, 0xfc, 0x9e, + 0x17, 0x46, 0x4c, 0xe2, 0x38, 0x0f, 0x00, 0x07, 0x79, 0x89, 0x01, 0xff, + 0x5b, 0xb4, 0x1b, 0xd4, 0x0f, 0x00, 0x4f, 0xc0, 0x1b, 0x05, 0x0f, 0x40, + 0x0c, 0x50, 0x90, 0x06, 0x54, 0x53, 0x49, 0x06, 0x0f, 0x40, 0x4c, 0x3b, + 0x83, 0x36, 0x0f, 0x00, 0x4b, 0x86, 0xa4, 0x13, 0x0f, 0x40, 0x09, 0xb0, + 0xc0, 0x18, 0xb3, 0x01, 0xff, 0x49, 0x86, 0xbd, 0x34, 0x0f, 0x00, 0xab, + 0x01, 0xff, 0x54, 0x4b, 0x42, 0xd0, 0x0f, 0x00, 0x4a, 0x98, 0xb8, 0x09, + 0x0f, 0x40, 0x4c, 0xa7, 0x37, 0xd0, 0x0f, 0x00, 0x47, 0xa5, 0x1b, 0x0a, + 0x0f, 0x40, 0x42, 0xbb, 0x01, 0x3d, 0x0f, 0x00, 0x42, 0x10, 0x00, 0x3c, + 0x0f, 0x40, 0x06, 0x14, 0x06, 0x11, 0x0d, 0x0c, 0x8b, 0x01, 0xff, 0x4a, + 0xee, 0xad, 0x15, 0x0f, 0x00, 0x4a, 0x76, 0xb2, 0x16, 0x0f, 0x40, 0x42, + 0x3d, 0x27, 0x60, 0x0f, 0x00, 0xe1, 0x68, 0x0f, 0x00, 0xa2, 0xf7, 0x01, + 0xa3, 0xea, 0x01, 0xa4, 0xc4, 0x01, 0x4d, 0x09, 0x87, 0x6a, 0x0f, 0x00, + 0xa7, 0xb1, 0x01, 0x42, 0x22, 0x00, 0x67, 0x0f, 0x00, 0x42, 0x78, 0x1a, + 0x47, 0x0f, 0x00, 0xab, 0x8c, 0x01, 0x42, 0x74, 0x00, 0x63, 0x0f, 0x00, + 0x42, 0x6c, 0x00, 0x58, 0x0f, 0x00, 0xae, 0x68, 0xb0, 0x5c, 0xb2, 0x50, + 0xb3, 0x3e, 0xb4, 0x19, 0x42, 0xa9, 0x01, 0x5d, 0x0f, 0x00, 0x42, 0xdf, + 0x23, 0x61, 0x0f, 0x00, 0xba, 0x01, 0xff, 0xe1, 0x5f, 0x0f, 0x00, 0x42, + 0x22, 0x00, 0x5e, 0x0f, 0x40, 0xe1, 0x4f, 0x0f, 0x00, 0x42, 0x22, 0x00, + 0x50, 0x0f, 0x00, 0xb3, 0x0d, 0xb4, 0x01, 0xff, 0xe1, 0x4a, 0x0f, 0x00, + 0x42, 0x22, 0x00, 0x4b, 0x0f, 0x40, 0xe1, 0x59, 0x0f, 0x00, 0x42, 0x22, + 0x00, 0x5a, 0x0f, 0x40, 0xe1, 0x66, 0x0f, 0x00, 0x42, 0x22, 0x00, 0x64, + 0x0f, 0x00, 0x42, 0x40, 0x06, 0x65, 0x0f, 0x40, 0xe1, 0x62, 0x0f, 0x00, + 0x42, 0x71, 0x00, 0x6c, 0x0f, 0x40, 0xe1, 0x54, 0x0f, 0x00, 0x42, 0x22, + 0x00, 0x55, 0x0f, 0x40, 0xe1, 0x53, 0x0f, 0x00, 0x42, 0x24, 0x02, 0x44, + 0x0f, 0x00, 0x42, 0x2a, 0x05, 0x4e, 0x0f, 0x00, 0x42, 0xdf, 0x23, 0x49, + 0x0f, 0x40, 0xe1, 0x40, 0x0f, 0x00, 0x42, 0x22, 0x00, 0x41, 0x0f, 0x00, + 0x42, 0x1b, 0x02, 0x6b, 0x0f, 0x00, 0x43, 0x1e, 0x22, 0x69, 0x0f, 0x40, + 0xe1, 0x42, 0x0f, 0x00, 0x42, 0x22, 0x00, 0x43, 0x0f, 0x40, 0xe1, 0x51, + 0x0f, 0x00, 0xa4, 0x13, 0x42, 0x22, 0x00, 0x52, 0x0f, 0x00, 0xba, 0x01, + 0xff, 0xe1, 0x5b, 0x0f, 0x00, 0x42, 0x22, 0x00, 0x5c, 0x0f, 0x40, 0xe1, + 0x4c, 0x0f, 0x00, 0x42, 0x22, 0x00, 0x4d, 0x0f, 0x40, 0xe1, 0x45, 0x0f, + 0x00, 0x42, 0x22, 0x00, 0x46, 0x0f, 0x40, 0xe1, 0x56, 0x0f, 0x00, 0x42, + 0x22, 0x00, 0x57, 0x0f, 0x40, 0x4d, 0x3a, 0x83, 0xbf, 0x0f, 0x40, 0x45, + 0x7e, 0x0b, 0x28, 0x0f, 0x00, 0xa6, 0x74, 0x05, 0x22, 0x00, 0x2e, 0x44, + 0x6d, 0x2c, 0x29, 0x0f, 0x00, 0x43, 0x7a, 0x0b, 0x21, 0x0f, 0x00, 0xb3, + 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x20, 0x0f, 0x40, 0x44, 0x25, 0x01, + 0x23, 0x0f, 0x00, 0x42, 0x15, 0x02, 0x22, 0x0f, 0x40, 0x44, 0x06, 0x1f, + 0x27, 0x0f, 0x00, 0x42, 0x09, 0x24, 0x26, 0x0f, 0x40, 0x45, 0x7e, 0x0b, + 0x31, 0x0f, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x32, 0x0f, 0x00, 0x43, + 0x7a, 0x0b, 0x2a, 0x0f, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, + 0x33, 0x0f, 0x40, 0x44, 0x25, 0x01, 0x2c, 0x0f, 0x00, 0x42, 0x15, 0x02, + 0x2b, 0x0f, 0x40, 0x44, 0x06, 0x1f, 0x30, 0x0f, 0x00, 0x42, 0x09, 0x24, + 0x2f, 0x0f, 0x40, 0x43, 0xf9, 0x05, 0x2e, 0x0f, 0x00, 0x43, 0xf6, 0x06, + 0x2d, 0x0f, 0x40, 0x43, 0xf9, 0x05, 0x25, 0x0f, 0x00, 0x43, 0xf6, 0x06, + 0x24, 0x0f, 0x40, 0x49, 0x81, 0xbc, 0xc2, 0x0f, 0x00, 0x4a, 0xa0, 0xb0, + 0xc0, 0x0f, 0x00, 0x4a, 0x80, 0xb2, 0xc1, 0x0f, 0x00, 0x4a, 0x68, 0xb6, + 0xc3, 0x0f, 0x40, 0x49, 0x9b, 0xba, 0x18, 0x0f, 0x00, 0xb3, 0x01, 0xff, + 0x4b, 0x3a, 0xa0, 0x19, 0x0f, 0x00, 0x54, 0xb7, 0x44, 0x17, 0x0f, 0x40, + 0xa1, 0xbd, 0x02, 0xa5, 0x8b, 0x02, 0xa9, 0xe3, 0x01, 0xaf, 0xd4, 0x01, + 0x03, 0x26, 0x01, 0x24, 0xb5, 0x01, 0xff, 0x04, 0xf2, 0x95, 0x11, 0x04, + 0xf7, 0x11, 0x01, 0xff, 0x4f, 0x57, 0x6c, 0xc8, 0x26, 0x00, 0x45, 0x06, + 0xf1, 0x08, 0x26, 0x40, 0x49, 0x62, 0xbd, 0x4e, 0xf4, 0x01, 0x47, 0xcb, + 0xdc, 0x4d, 0xf4, 0x41, 0x80, 0x41, 0x8d, 0x01, 0xff, 0x02, 0x06, 0x00, + 0x0c, 0x47, 0x96, 0xd6, 0x3b, 0x2e, 0x00, 0x4c, 0x18, 0x84, 0x04, 0x20, + 0x40, 0x63, 0xfe, 0x0a, 0xa3, 0x27, 0x00, 0x6c, 0xbe, 0x01, 0x9b, 0x2b, + 0x00, 0x6b, 0x42, 0x02, 0x99, 0x2b, 0x00, 0x0c, 0xf4, 0x9a, 0x01, 0xff, + 0x5f, 0x1c, 0x12, 0x98, 0x2b, 0x00, 0x0b, 0xb3, 0x02, 0x01, 0xff, 0x49, + 0xe1, 0x01, 0xa2, 0x27, 0x00, 0x55, 0xd5, 0x01, 0x9a, 0x2b, 0x40, 0x4c, + 0xac, 0x91, 0xb1, 0xf5, 0x01, 0x58, 0x34, 0x29, 0x76, 0x2a, 0x00, 0xa4, + 0x4f, 0xac, 0x36, 0x53, 0xef, 0x4d, 0xa7, 0xf5, 0x01, 0x52, 0x8a, 0x2d, + 0xc2, 0xf7, 0x01, 0xb2, 0x06, 0x4e, 0x4a, 0x80, 0xeb, 0xf5, 0x41, 0x04, + 0x2c, 0x48, 0x06, 0x50, 0xe3, 0x30, 0xf6, 0x21, 0x40, 0x45, 0x5c, 0x00, + 0xe4, 0xf5, 0x01, 0x45, 0x20, 0x07, 0xe5, 0xf5, 0x01, 0x44, 0xc3, 0x00, + 0xe6, 0xf5, 0x01, 0x45, 0xc8, 0x00, 0xe7, 0xf5, 0x41, 0x4f, 0x4e, 0x40, + 0x31, 0x2b, 0x00, 0x10, 0x0a, 0x67, 0x01, 0xff, 0x44, 0xc3, 0x00, 0x9f, + 0x26, 0x00, 0x45, 0xc8, 0x00, 0x9e, 0x26, 0x40, 0x50, 0xca, 0x66, 0xc0, + 0x27, 0x00, 0x4e, 0x70, 0x0c, 0x56, 0x20, 0x40, 0x49, 0x06, 0xc2, 0x74, + 0xfa, 0x01, 0x4c, 0x3c, 0x9b, 0xad, 0xf4, 0x41, 0xae, 0x06, 0x4e, 0x40, + 0x7f, 0x49, 0xf9, 0x41, 0x80, 0x06, 0x49, 0x17, 0xae, 0x14, 0xf9, 0x41, + 0x4b, 0xef, 0x63, 0xa1, 0xf7, 0x01, 0xb3, 0x01, 0xff, 0x46, 0x35, 0x1a, + 0xa8, 0xf7, 0x01, 0x44, 0x2e, 0x4f, 0x09, 0x20, 0x40, 0xb2, 0x06, 0x43, + 0x63, 0x48, 0xca, 0xce, 0x41, 0xa5, 0x11, 0x02, 0xc3, 0x07, 0x01, 0xff, + 0x47, 0x42, 0xd6, 0xe7, 0x29, 0x00, 0x45, 0xaf, 0xb0, 0x21, 0xf3, 0x41, + 0x80, 0x06, 0x44, 0x7b, 0x65, 0x34, 0x22, 0x40, 0x4e, 0x8c, 0x7a, 0x04, + 0x22, 0x00, 0x46, 0x86, 0xe1, 0x03, 0x22, 0x40, 0x04, 0x19, 0x13, 0xfc, + 0x04, 0x02, 0xf1, 0x03, 0x01, 0xff, 0xa3, 0x47, 0x06, 0xef, 0x06, 0x01, + 0xff, 0x45, 0x7e, 0x0b, 0x58, 0x0e, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, + 0x59, 0x0e, 0x00, 0x43, 0x7a, 0x0b, 0x51, 0x0e, 0x00, 0xb3, 0x14, 0xb4, + 0x06, 0x44, 0x80, 0x1f, 0x50, 0x0e, 0x40, 0x44, 0x25, 0x01, 0x53, 0x0e, + 0x00, 0x42, 0x15, 0x02, 0x52, 0x0e, 0x40, 0x44, 0x06, 0x1f, 0x57, 0x0e, + 0x00, 0x42, 0x09, 0x24, 0x56, 0x0e, 0x40, 0x43, 0xf9, 0x05, 0x55, 0x0e, + 0x00, 0x43, 0xf6, 0x06, 0x54, 0x0e, 0x40, 0x09, 0xd1, 0x18, 0x06, 0x53, + 0xae, 0x50, 0x3f, 0x0e, 0x40, 0x4a, 0x12, 0xad, 0x5a, 0x0e, 0x00, 0x49, + 0x54, 0xbc, 0x1a, 0x0e, 0x00, 0x06, 0x84, 0xe0, 0xfc, 0x03, 0x03, 0x6b, + 0x52, 0xeb, 0x03, 0x02, 0x68, 0x03, 0xd5, 0x03, 0x03, 0x16, 0x75, 0xc4, + 0x03, 0xab, 0x8d, 0x03, 0xac, 0xf0, 0x02, 0xad, 0xb4, 0x02, 0xae, 0x96, + 0x02, 0x45, 0x49, 0xef, 0x2d, 0x0e, 0x00, 0xb0, 0xde, 0x01, 0xb2, 0xd1, + 0x01, 0xb3, 0x69, 0xb4, 0x20, 0x47, 0x88, 0xdd, 0x27, 0x0e, 0x00, 0xb9, + 0x01, 0xff, 0x47, 0x80, 0xd2, 0x4e, 0x0e, 0x00, 0x03, 0x7e, 0xe7, 0x01, + 0xff, 0x42, 0x6d, 0x00, 0x22, 0x0e, 0x00, 0x43, 0xa1, 0x01, 0x0d, 0x0e, + 0x40, 0xa8, 0x11, 0x02, 0x7b, 0x02, 0x01, 0xff, 0x45, 0xb7, 0xef, 0x0f, + 0x0e, 0x00, 0x43, 0xde, 0x19, 0x15, 0x0e, 0x40, 0x49, 0xbb, 0xbb, 0x4c, + 0x0e, 0x00, 0x02, 0x7b, 0x02, 0x01, 0xff, 0x4a, 0xc0, 0xb3, 0x11, 0x0e, + 0x00, 0x47, 0xa2, 0xda, 0x12, 0x0e, 0x00, 0x02, 0x53, 0x00, 0x01, 0xff, + 0xa1, 0x0c, 0x43, 0xd8, 0x02, 0x18, 0x0e, 0x00, 0x43, 0xe1, 0x47, 0x16, + 0x0e, 0x40, 0x43, 0x90, 0x00, 0x17, 0x0e, 0x00, 0xee, 0x10, 0x0e, 0x40, + 0x04, 0x0f, 0x17, 0x1e, 0x02, 0x7b, 0x02, 0x01, 0xff, 0x44, 0x7c, 0xf8, + 0x29, 0x0e, 0x00, 0xb3, 0x01, 0xff, 0x43, 0x6f, 0x1a, 0x28, 0x0e, 0x00, + 0xef, 0x0b, 0x0e, 0x00, 0x42, 0x7d, 0x00, 0x2a, 0x0e, 0x40, 0xe1, 0x30, + 0x0e, 0x80, 0x23, 0xe5, 0x40, 0x0e, 0x00, 0xe9, 0x34, 0x0e, 0x80, 0x16, + 0xef, 0x42, 0x0e, 0x00, 0xf5, 0x38, 0x0e, 0xc0, 0x00, 0xe5, 0x36, 0x0e, + 0x80, 0x04, 0xf5, 0x39, 0x0e, 0x40, 0xe5, 0x37, 0x0e, 0x40, 0xe9, 0x35, + 0x0e, 0x40, 0xe1, 0x32, 0x0e, 0x00, 0xe5, 0x41, 0x0e, 0x00, 0x06, 0xa0, + 0xe2, 0x04, 0xed, 0x33, 0x0e, 0x40, 0x44, 0xd4, 0xf4, 0x44, 0x0e, 0x00, + 0x43, 0x88, 0xa6, 0x43, 0x0e, 0x40, 0x45, 0x5d, 0xef, 0x23, 0x0e, 0x00, + 0xf5, 0x24, 0x0e, 0x40, 0x48, 0xe7, 0xc8, 0x2f, 0x0e, 0x00, 0xa8, 0x06, + 0x45, 0x58, 0xef, 0x1b, 0x0e, 0x40, 0x45, 0x78, 0xed, 0x3a, 0x0e, 0x00, + 0x02, 0x7b, 0x02, 0x01, 0xff, 0x02, 0x33, 0x11, 0x06, 0x47, 0x82, 0xdb, + 0x20, 0x0e, 0x40, 0x42, 0x1a, 0x00, 0x1e, 0x0e, 0x00, 0x43, 0xe1, 0x47, + 0x1c, 0x0e, 0x40, 0x46, 0x0a, 0xe2, 0x07, 0x0e, 0x00, 0x47, 0xb5, 0xd7, + 0x4d, 0x0e, 0x00, 0x03, 0x0b, 0xe2, 0x01, 0xff, 0x42, 0x92, 0x01, 0x13, + 0x0e, 0x00, 0xf5, 0x19, 0x0e, 0x40, 0x02, 0x56, 0x07, 0x06, 0x44, 0x1b, + 0x50, 0x21, 0x0e, 0x40, 0x80, 0x0c, 0x46, 0x5a, 0xe6, 0x47, 0x0e, 0x00, + 0x45, 0x69, 0xf2, 0x46, 0x0e, 0x40, 0x48, 0x4f, 0xca, 0x4b, 0x0e, 0x00, + 0x42, 0xdb, 0x19, 0x48, 0x0e, 0x00, 0x48, 0x3f, 0xcc, 0x31, 0x0e, 0x00, + 0xb4, 0x01, 0xff, 0x42, 0x0b, 0x00, 0x49, 0x0e, 0x00, 0x42, 0x0d, 0x00, + 0x4a, 0x0e, 0x40, 0x4a, 0xd6, 0xac, 0x45, 0x0e, 0x00, 0x02, 0x7b, 0x02, + 0x04, 0xf5, 0x26, 0x0e, 0x40, 0x45, 0x34, 0xeb, 0x2c, 0x0e, 0x00, 0x44, + 0x9b, 0x0b, 0x25, 0x0e, 0x40, 0x02, 0x0b, 0x00, 0x06, 0x45, 0x53, 0xef, + 0x01, 0x0e, 0x40, 0x80, 0x06, 0x43, 0x88, 0xb1, 0x5b, 0x0e, 0x40, 0x02, + 0xcc, 0x0c, 0x06, 0x47, 0x04, 0xdb, 0x06, 0x0e, 0x40, 0x42, 0x56, 0x07, + 0x02, 0x0e, 0x00, 0x42, 0x10, 0x00, 0x05, 0x0e, 0x00, 0x43, 0x78, 0x0c, + 0x03, 0x0e, 0x00, 0x43, 0x80, 0x11, 0x04, 0x0e, 0x40, 0x43, 0xea, 0x0d, + 0x2b, 0x0e, 0x00, 0x46, 0x5c, 0xe4, 0x2e, 0x0e, 0x40, 0x43, 0x0b, 0x08, + 0x1d, 0x0e, 0x80, 0x06, 0x45, 0x03, 0xef, 0x4f, 0x0e, 0x40, 0xee, 0x1f, + 0x0e, 0x40, 0x45, 0x16, 0xeb, 0x0e, 0x0e, 0x00, 0x43, 0xda, 0x19, 0x14, + 0x0e, 0x40, 0x42, 0x1a, 0x00, 0x08, 0x0e, 0x80, 0x0c, 0x43, 0xa1, 0x01, + 0x09, 0x0e, 0x00, 0x42, 0xce, 0x53, 0x0c, 0x0e, 0x40, 0xe7, 0x0a, 0x0e, + 0x40, 0xa1, 0xc6, 0x02, 0xa5, 0xb1, 0x02, 0x47, 0x99, 0xd7, 0xa8, 0x07, + 0x00, 0x07, 0x13, 0x06, 0x20, 0xaf, 0x0c, 0x45, 0x0b, 0xf1, 0xb0, 0x07, + 0x00, 0x47, 0x9a, 0xdc, 0xaa, 0x07, 0x40, 0x48, 0xcf, 0xc8, 0xaf, 0x07, + 0x00, 0x46, 0x2a, 0xe0, 0xae, 0x07, 0x00, 0x48, 0x9f, 0xce, 0xab, 0x07, + 0x40, 0xa1, 0xf8, 0x01, 0x43, 0xf7, 0x52, 0x84, 0x07, 0x00, 0x49, 0xc0, + 0xbc, 0x97, 0x07, 0x00, 0xa4, 0xd5, 0x01, 0x45, 0x47, 0xec, 0x8a, 0x07, + 0x00, 0xa7, 0xba, 0x01, 0xa8, 0xab, 0x01, 0x48, 0x07, 0xcd, 0x96, 0x07, + 0x00, 0xab, 0x96, 0x01, 0xac, 0x87, 0x01, 0x45, 0x72, 0xee, 0x89, 0x07, + 0x00, 0xae, 0x73, 0x48, 0x8f, 0xcf, 0x95, 0x07, 0x00, 0x45, 0x07, 0xf0, + 0xa4, 0x07, 0x00, 0x43, 0x8c, 0x9a, 0x83, 0x07, 0x00, 0xb3, 0x44, 0xb4, + 0x25, 0x45, 0xf1, 0xf1, 0x88, 0x07, 0x00, 0x45, 0x14, 0xf2, 0xa5, 0x07, + 0x00, 0x43, 0xd0, 0xaf, 0x94, 0x07, 0x00, 0xba, 0x01, 0xff, 0xa1, 0x04, + 0xef, 0xa1, 0x07, 0x40, 0xe1, 0x9c, 0x07, 0x00, 0x46, 0xc3, 0xbc, 0x92, + 0x07, 0x40, 0x47, 0xc2, 0xbc, 0x93, 0x07, 0x00, 0x43, 0x5e, 0x43, 0x8c, + 0x07, 0x80, 0x0a, 0xef, 0xa0, 0x07, 0x00, 0x43, 0x4d, 0x13, 0x98, 0x07, + 0x40, 0x42, 0x95, 0x16, 0x9b, 0x07, 0x40, 0x45, 0xf9, 0xe9, 0x9e, 0x07, + 0x00, 0x44, 0x80, 0xf5, 0x90, 0x07, 0x00, 0xa8, 0x01, 0xff, 0x47, 0xc2, + 0xbc, 0x81, 0x07, 0x00, 0x44, 0x80, 0xf5, 0x9d, 0x07, 0x40, 0x42, 0x4e, + 0x13, 0xb1, 0x07, 0x00, 0x44, 0x45, 0x9b, 0x82, 0x07, 0x40, 0x44, 0xfb, + 0x8d, 0x8d, 0x07, 0x00, 0x48, 0xc1, 0xbc, 0x85, 0x07, 0x40, 0x44, 0x48, + 0xec, 0x86, 0x07, 0x00, 0x43, 0x5e, 0x43, 0x9a, 0x07, 0x40, 0x42, 0x4e, + 0x13, 0x80, 0x07, 0x00, 0x43, 0x5e, 0x43, 0x99, 0x07, 0x40, 0x44, 0x48, + 0xec, 0x8e, 0x07, 0x00, 0x45, 0xbf, 0xec, 0xa3, 0x07, 0x00, 0x48, 0x2f, + 0xce, 0x8f, 0x07, 0x40, 0xa1, 0x06, 0x45, 0xb5, 0xec, 0x8b, 0x07, 0x40, + 0x44, 0xfa, 0xe9, 0x9f, 0x07, 0x00, 0x46, 0xc3, 0xbc, 0x91, 0x07, 0x40, + 0x43, 0xee, 0x1b, 0xa2, 0x07, 0x00, 0x44, 0xf0, 0xf6, 0x87, 0x07, 0x40, + 0x46, 0x06, 0xe0, 0xac, 0x07, 0x00, 0x48, 0x17, 0xcb, 0xa9, 0x07, 0x00, + 0x48, 0x87, 0xd2, 0xad, 0x07, 0x40, 0x48, 0xc7, 0xc8, 0xa7, 0x07, 0x00, + 0x46, 0xfa, 0xdf, 0xa6, 0x07, 0x40, 0xa1, 0xbf, 0x0a, 0x48, 0xb7, 0xca, + 0xf8, 0xf9, 0x01, 0xac, 0xea, 0x04, 0xae, 0xd7, 0x04, 0x47, 0xeb, 0xdb, + 0xea, 0xf9, 0x01, 0x0c, 0x00, 0x9b, 0x01, 0xff, 0xa1, 0xb1, 0x04, 0xa2, + 0x9c, 0x04, 0xa3, 0xc4, 0x03, 0xa4, 0xff, 0x02, 0xa5, 0xd0, 0x02, 0xa6, + 0xa2, 0x02, 0xa7, 0x80, 0x02, 0xa8, 0xf1, 0x01, 0x02, 0x9e, 0x01, 0xe0, + 0x01, 0x43, 0xb5, 0x9a, 0x1d, 0xd3, 0x01, 0xab, 0xcb, 0x01, 0xac, 0xb4, + 0x01, 0xad, 0x9f, 0x01, 0xaf, 0x90, 0x01, 0xb0, 0x74, 0xb2, 0x47, 0xb3, + 0x22, 0x45, 0xbf, 0xf1, 0x3b, 0xd3, 0x01, 0x53, 0xfa, 0x50, 0x37, 0xd3, + 0x01, 0x02, 0xa9, 0x01, 0x06, 0x4c, 0x50, 0x9c, 0x11, 0xd3, 0x41, 0x45, + 0xa9, 0x88, 0x17, 0xd3, 0x01, 0x43, 0xb9, 0x22, 0x44, 0xd3, 0x41, 0x48, + 0xb7, 0xcb, 0x4b, 0xd3, 0x01, 0x46, 0x09, 0x96, 0x45, 0xd3, 0x01, 0xb4, + 0x01, 0xff, 0xaf, 0x06, 0x46, 0x82, 0xe5, 0x29, 0xd3, 0x41, 0x45, 0xf8, + 0xef, 0x4c, 0xd3, 0x01, 0x42, 0x32, 0x00, 0x31, 0xd3, 0x41, 0xa5, 0x06, + 0x45, 0x96, 0xed, 0x35, 0xd3, 0x41, 0x43, 0x13, 0x2f, 0x14, 0xd3, 0x01, + 0x45, 0x1d, 0xee, 0x1a, 0xd3, 0x01, 0xb3, 0x01, 0xff, 0xa9, 0x06, 0x45, + 0xf3, 0xef, 0x2e, 0xd3, 0x41, 0x45, 0x09, 0xc0, 0x2c, 0xd3, 0x01, 0x46, + 0x12, 0xe6, 0x1b, 0xd3, 0x41, 0xa1, 0x0c, 0x4a, 0x42, 0xaf, 0x13, 0xd3, + 0x01, 0x45, 0xd3, 0xf1, 0x2a, 0xd3, 0x41, 0x45, 0x8d, 0x6a, 0x24, 0xd3, + 0x01, 0x45, 0x26, 0x96, 0x34, 0xd3, 0x41, 0x4b, 0xff, 0xa4, 0x53, 0xd3, + 0x01, 0x49, 0xf5, 0xc3, 0x0d, 0xd3, 0x41, 0x46, 0xe2, 0xdf, 0x40, 0xd3, + 0x01, 0x46, 0x78, 0x19, 0x39, 0xd3, 0x01, 0x44, 0xd1, 0x8b, 0x08, 0xd3, + 0x41, 0xa1, 0x06, 0x45, 0xc0, 0xeb, 0x25, 0xd3, 0x41, 0x47, 0x69, 0xd5, + 0x55, 0xd3, 0x01, 0x4a, 0xfc, 0xb8, 0x2d, 0xd3, 0x41, 0x4c, 0x14, 0x93, + 0x0a, 0xd3, 0x01, 0x46, 0xf4, 0xe2, 0x27, 0xd3, 0x41, 0x46, 0xa8, 0xe0, + 0x12, 0xd3, 0x01, 0x43, 0x8c, 0x0b, 0x46, 0xd3, 0x41, 0x47, 0xba, 0xd4, + 0x4d, 0xd3, 0x01, 0x4b, 0xa8, 0x54, 0x16, 0xd3, 0x41, 0x48, 0xe5, 0x5a, + 0x28, 0xd3, 0x81, 0x12, 0x4c, 0xf4, 0x97, 0x2f, 0xd3, 0x01, 0x48, 0x0f, + 0xd0, 0x32, 0xd3, 0x01, 0x4a, 0x20, 0xb8, 0x3e, 0xd3, 0x41, 0x43, 0xca, + 0x07, 0x3f, 0xd3, 0x41, 0x46, 0x88, 0xdf, 0x50, 0xd3, 0x01, 0x45, 0xc3, + 0x01, 0x36, 0xd3, 0x01, 0xaf, 0x11, 0x03, 0x50, 0x17, 0x01, 0xff, 0x47, + 0x11, 0x03, 0x07, 0xd3, 0x01, 0x44, 0x77, 0x25, 0x2b, 0xd3, 0x41, 0x47, + 0xd0, 0xce, 0x18, 0xd3, 0x01, 0x47, 0xf2, 0xdb, 0x56, 0xd3, 0x41, 0x43, + 0x92, 0x37, 0x1c, 0xd3, 0x01, 0x4c, 0xa4, 0x96, 0x42, 0xd3, 0x01, 0xae, + 0x0c, 0x47, 0xbb, 0x34, 0x3a, 0xd3, 0x01, 0x49, 0x4c, 0xc7, 0x4a, 0xd3, + 0x41, 0x48, 0x7f, 0xca, 0x30, 0xd3, 0x01, 0x47, 0x0a, 0xd6, 0x1f, 0xd3, + 0x01, 0x49, 0x0a, 0xc1, 0x33, 0xd3, 0x41, 0x48, 0x9a, 0x3b, 0x48, 0xd3, + 0x01, 0xa5, 0x28, 0xa9, 0x0c, 0x44, 0xe4, 0xf7, 0x43, 0xd3, 0x01, 0x45, + 0xe2, 0xf1, 0x20, 0xd3, 0x41, 0x4a, 0xba, 0xaf, 0x54, 0xd3, 0x01, 0xad, + 0x06, 0x48, 0xff, 0xd1, 0x10, 0xd3, 0x41, 0x49, 0x44, 0xc0, 0x3c, 0xd3, + 0x01, 0x44, 0x9e, 0x64, 0x49, 0xd3, 0x41, 0x4a, 0x0c, 0xae, 0x22, 0xd3, + 0x01, 0x59, 0x70, 0x25, 0x0f, 0xd3, 0x01, 0x47, 0x40, 0xbd, 0x47, 0xd3, + 0x41, 0x45, 0x74, 0x02, 0x06, 0xd3, 0x01, 0x45, 0xc2, 0xcb, 0x21, 0xd3, + 0x01, 0x03, 0x31, 0x0e, 0x31, 0xaf, 0x01, 0xff, 0x03, 0x82, 0x65, 0x1e, + 0xae, 0x01, 0xff, 0x46, 0x18, 0xe6, 0x38, 0xd3, 0x01, 0xb4, 0x01, 0xff, + 0x43, 0x7d, 0x0d, 0x15, 0xd3, 0x01, 0x46, 0x1b, 0x87, 0x1e, 0xd3, 0x01, + 0x47, 0x12, 0xdb, 0x0b, 0xd3, 0x41, 0x45, 0x85, 0x65, 0x4e, 0xd3, 0x01, + 0x45, 0xf2, 0xc8, 0x52, 0xd3, 0x41, 0xa5, 0x06, 0x43, 0xe2, 0x11, 0x4f, + 0xd3, 0x41, 0x47, 0x29, 0x92, 0x3d, 0xd3, 0x01, 0x44, 0x77, 0x25, 0x26, + 0xd3, 0x41, 0x46, 0x49, 0x6d, 0x09, 0xd3, 0x01, 0x4e, 0xfe, 0x7d, 0x23, + 0xd3, 0x01, 0x4c, 0x14, 0x99, 0x0e, 0xd3, 0x41, 0x4b, 0x06, 0x9f, 0x41, + 0xd3, 0x01, 0x46, 0xf6, 0xe0, 0x19, 0xd3, 0x01, 0x4a, 0x46, 0xb0, 0x51, + 0xd3, 0x01, 0x45, 0x66, 0x43, 0x0c, 0xd3, 0x41, 0x47, 0xdd, 0x9b, 0xb8, + 0x20, 0x00, 0x54, 0xab, 0x46, 0xbe, 0xf3, 0x01, 0xf4, 0xfa, 0x26, 0x40, + 0xa5, 0x90, 0x05, 0x04, 0xc8, 0xf8, 0x01, 0xff, 0xa1, 0xfc, 0x04, 0x06, + 0xef, 0x06, 0xb5, 0x04, 0x0f, 0x8f, 0x70, 0xf7, 0x03, 0x02, 0x68, 0x00, + 0x9c, 0x01, 0x05, 0x5a, 0x03, 0x4e, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xa1, + 0x3b, 0xe5, 0x46, 0x0c, 0x80, 0x32, 0xe9, 0x3f, 0x0c, 0x80, 0x29, 0xef, + 0x4a, 0x0c, 0x80, 0x20, 0xf5, 0x41, 0x0c, 0x80, 0x17, 0x08, 0xf2, 0xc6, + 0x01, 0xff, 0xec, 0x62, 0x0c, 0x80, 0x09, 0xf2, 0x43, 0x0c, 0xc0, 0x00, + 0xf2, 0x44, 0x0c, 0x40, 0xec, 0x63, 0x0c, 0x40, 0xf5, 0x42, 0x0c, 0x40, + 0xef, 0x4b, 0x0c, 0x40, 0xe9, 0x40, 0x0c, 0x40, 0xe5, 0x47, 0x0c, 0x40, + 0xe1, 0x3e, 0x0c, 0x00, 0xe9, 0x48, 0x0c, 0x00, 0xf5, 0x4c, 0x0c, 0x40, + 0xa1, 0x3c, 0xa3, 0x23, 0x45, 0x62, 0x41, 0x3c, 0x0c, 0x00, 0x47, 0xc8, + 0xdb, 0x77, 0x0c, 0x00, 0x45, 0x8d, 0xf1, 0x7f, 0x0c, 0x00, 0x02, 0x02, + 0x00, 0x01, 0xff, 0x44, 0x21, 0x25, 0x4d, 0x0c, 0x00, 0x45, 0x49, 0x4e, + 0x03, 0x0c, 0x40, 0x4a, 0x14, 0x25, 0x01, 0x0c, 0x00, 0x09, 0x01, 0x17, + 0x01, 0xff, 0x4e, 0x0a, 0x17, 0x04, 0x0c, 0x00, 0x51, 0x8f, 0x5b, 0x00, + 0x0c, 0x40, 0x47, 0x0b, 0x17, 0x02, 0x0c, 0x00, 0x47, 0x34, 0x8d, 0x3d, + 0x0c, 0x40, 0x49, 0x7c, 0x3b, 0x55, 0x0c, 0x00, 0x05, 0x15, 0x06, 0x01, + 0xff, 0xe1, 0x05, 0x0c, 0x80, 0xb9, 0x02, 0xa2, 0xac, 0x02, 0xa3, 0x9f, + 0x02, 0xa4, 0x80, 0x02, 0xe5, 0x0e, 0x0c, 0x80, 0xf6, 0x01, 0xa7, 0xe9, + 0x01, 0x42, 0x22, 0x00, 0x39, 0x0c, 0x00, 0xe9, 0x07, 0x0c, 0x80, 0xd9, + 0x01, 0xaa, 0xcc, 0x01, 0xab, 0xbf, 0x01, 0xac, 0xab, 0x01, 0x42, 0x6c, + 0x00, 0x2e, 0x0c, 0x00, 0xae, 0x85, 0x01, 0xef, 0x12, 0x0c, 0x80, 0x7c, + 0xb0, 0x70, 0xb2, 0x5d, 0xb3, 0x4b, 0xb4, 0x2c, 0xf5, 0x09, 0x0c, 0x80, + 0x23, 0xb6, 0x06, 0x42, 0xdf, 0x23, 0x2f, 0x0c, 0x40, 0xe1, 0x35, 0x0c, + 0x00, 0x07, 0xf3, 0xc6, 0x01, 0xff, 0xec, 0x0c, 0x0c, 0x80, 0x09, 0xf2, + 0x0b, 0x0c, 0xc0, 0x00, 0xf2, 0x60, 0x0c, 0x40, 0xec, 0x61, 0x0c, 0x40, + 0xf5, 0x0a, 0x0c, 0x40, 0xe1, 0x24, 0x0c, 0x00, 0x42, 0x22, 0x00, 0x25, + 0x0c, 0x00, 0x42, 0x40, 0x06, 0x58, 0x0c, 0x00, 0xb4, 0x01, 0xff, 0xe1, + 0x1f, 0x0c, 0x00, 0x42, 0x22, 0x00, 0x20, 0x0c, 0x40, 0xe1, 0x38, 0x0c, + 0x00, 0x42, 0x22, 0x00, 0x36, 0x0c, 0x00, 0x42, 0x40, 0x06, 0x37, 0x0c, + 0x40, 0xe1, 0x30, 0x0c, 0x00, 0xb2, 0x01, 0xff, 0xe1, 0x31, 0x0c, 0x00, + 0x42, 0x71, 0x00, 0x5a, 0x0c, 0x40, 0xe1, 0x2a, 0x0c, 0x00, 0x42, 0x22, + 0x00, 0x2b, 0x0c, 0x40, 0xef, 0x13, 0x0c, 0x40, 0xe1, 0x28, 0x0c, 0x80, + 0x12, 0x42, 0x24, 0x02, 0x19, 0x0c, 0x00, 0x42, 0x2a, 0x05, 0x23, 0x0c, + 0x00, 0x42, 0xdf, 0x23, 0x1e, 0x0c, 0x40, 0x4b, 0x26, 0xa3, 0x5d, 0x0c, + 0x40, 0xe1, 0x32, 0x0c, 0x00, 0xac, 0x01, 0xff, 0xe1, 0x33, 0x0c, 0x00, + 0x42, 0x74, 0x00, 0x34, 0x0c, 0x40, 0xe1, 0x15, 0x0c, 0x00, 0x42, 0x22, + 0x00, 0x16, 0x0c, 0x40, 0xe1, 0x1c, 0x0c, 0x00, 0x42, 0x22, 0x00, 0x1d, + 0x0c, 0x40, 0xe9, 0x08, 0x0c, 0x40, 0xe1, 0x17, 0x0c, 0x00, 0x42, 0x22, + 0x00, 0x18, 0x0c, 0x40, 0xe5, 0x0f, 0x0c, 0x40, 0xe1, 0x26, 0x0c, 0x00, + 0xa4, 0x0c, 0x42, 0x22, 0x00, 0x27, 0x0c, 0x00, 0x42, 0x59, 0x00, 0x59, + 0x0c, 0x40, 0xe1, 0x21, 0x0c, 0x00, 0x42, 0x22, 0x00, 0x22, 0x0c, 0x40, + 0xe1, 0x1a, 0x0c, 0x00, 0x42, 0x22, 0x00, 0x1b, 0x0c, 0x40, 0xe1, 0x2c, + 0x0c, 0x00, 0x42, 0x22, 0x00, 0x2d, 0x0c, 0x40, 0xe1, 0x06, 0x0c, 0x00, + 0xe9, 0x10, 0x0c, 0x00, 0xf5, 0x14, 0x0c, 0x40, 0x08, 0xff, 0xce, 0x29, + 0xb4, 0x06, 0x5b, 0x80, 0x1f, 0x78, 0x0c, 0x40, 0x09, 0x5a, 0xbf, 0x11, + 0x07, 0x7a, 0xdd, 0x01, 0xff, 0x53, 0xa2, 0x4b, 0x7d, 0x0c, 0x00, 0x52, + 0x89, 0x1f, 0x7a, 0x0c, 0x40, 0x53, 0xa2, 0x4b, 0x7e, 0x0c, 0x00, 0x52, + 0x89, 0x1f, 0x7b, 0x0c, 0x40, 0x53, 0xa2, 0x4b, 0x7c, 0x0c, 0x00, 0x52, + 0x89, 0x1f, 0x79, 0x0c, 0x40, 0x45, 0x7e, 0x0b, 0x6e, 0x0c, 0x00, 0xa6, + 0x2e, 0x44, 0x6d, 0x2c, 0x6f, 0x0c, 0x00, 0x43, 0x7a, 0x0b, 0x67, 0x0c, + 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x66, 0x0c, 0x40, 0x44, + 0x25, 0x01, 0x69, 0x0c, 0x00, 0x42, 0x15, 0x02, 0x68, 0x0c, 0x40, 0x44, + 0x06, 0x1f, 0x6d, 0x0c, 0x00, 0x42, 0x09, 0x24, 0x6c, 0x0c, 0x40, 0x43, + 0xf9, 0x05, 0x6b, 0x0c, 0x00, 0x43, 0xf6, 0x06, 0x6a, 0x0c, 0x40, 0x4d, + 0xf3, 0x87, 0x56, 0x0c, 0x00, 0x4c, 0x2c, 0x99, 0x5c, 0x0c, 0x40, 0x06, + 0x3d, 0x3f, 0x0c, 0x45, 0x42, 0xd1, 0x2d, 0xf5, 0x01, 0x46, 0x90, 0x34, + 0xfa, 0xf4, 0x41, 0x4d, 0x52, 0x89, 0x06, 0x27, 0x00, 0x4f, 0x5e, 0x74, + 0x80, 0xf5, 0x01, 0x03, 0x17, 0x0e, 0x06, 0x44, 0x5a, 0x03, 0x21, 0x21, + 0x40, 0x45, 0x46, 0x3f, 0xde, 0xf4, 0x81, 0x06, 0x45, 0xb3, 0x8d, 0x15, + 0x23, 0x40, 0x4a, 0xbe, 0xab, 0x7c, 0xf5, 0x41, 0x52, 0x63, 0x53, 0x75, + 0xf3, 0x01, 0x43, 0x4b, 0x47, 0xd6, 0xfa, 0x01, 0xb2, 0x01, 0xff, 0x4d, + 0xfd, 0x83, 0xc6, 0xf4, 0x01, 0x05, 0xb4, 0x0d, 0x01, 0xff, 0x57, 0x55, + 0x2f, 0xba, 0x27, 0x00, 0x4f, 0xf7, 0x1d, 0x3b, 0x27, 0x40, 0xe2, 0x09, + 0x00, 0x80, 0xc8, 0x40, 0x42, 0x13, 0x05, 0x2e, 0xf3, 0x01, 0xa7, 0xa3, + 0x3a, 0x02, 0xf1, 0x03, 0x93, 0x2c, 0xab, 0xe7, 0x28, 0x09, 0xff, 0xac, + 0xd6, 0x28, 0xad, 0x99, 0x22, 0xae, 0x1c, 0x03, 0xf0, 0x32, 0x0c, 0x44, + 0xdc, 0xf8, 0x49, 0x26, 0x00, 0x42, 0x70, 0x0d, 0x95, 0xf6, 0x41, 0x49, + 0xae, 0xbc, 0xad, 0xf5, 0x01, 0x45, 0x66, 0xdd, 0x07, 0x27, 0x40, 0x4a, + 0x9a, 0xac, 0x8b, 0xf3, 0x01, 0xa7, 0x01, 0xff, 0x45, 0x06, 0xec, 0x4a, + 0xf3, 0x01, 0x03, 0xa2, 0x43, 0xef, 0x1d, 0x03, 0xf9, 0x0d, 0x01, 0xff, + 0x0a, 0x34, 0xae, 0x0f, 0xa9, 0x01, 0xff, 0x49, 0x2b, 0x29, 0x03, 0xd8, + 0x00, 0x4d, 0x7c, 0x21, 0xe0, 0x6f, 0x41, 0x90, 0xad, 0x1a, 0x91, 0xff, + 0x16, 0x92, 0xd1, 0x13, 0x93, 0xa3, 0x10, 0x94, 0xf5, 0x0c, 0x95, 0xc7, + 0x09, 0x96, 0x99, 0x06, 0x97, 0xeb, 0x02, 0x98, 0x01, 0xff, 0x90, 0xbd, + 0x02, 0x91, 0x92, 0x02, 0x92, 0xe7, 0x01, 0x93, 0xbc, 0x01, 0x94, 0x91, + 0x01, 0x95, 0x67, 0x96, 0x3d, 0x97, 0x13, 0x98, 0x01, 0xff, 0xd0, 0xef, + 0x8d, 0x01, 0xd1, 0xf0, 0x8d, 0x01, 0xd2, 0xf1, 0x8d, 0x01, 0xd3, 0xf2, + 0x8d, 0x41, 0xd0, 0xe5, 0x8d, 0x01, 0xd1, 0xe6, 0x8d, 0x01, 0xd2, 0xe7, + 0x8d, 0x01, 0xd3, 0xe8, 0x8d, 0x01, 0xd4, 0xe9, 0x8d, 0x01, 0xd5, 0xea, + 0x8d, 0x01, 0xd6, 0xeb, 0x8d, 0x01, 0xd7, 0xec, 0x8d, 0x01, 0xd8, 0xed, + 0x8d, 0x01, 0xd9, 0xee, 0x8d, 0x41, 0xd0, 0xdb, 0x8d, 0x01, 0xd1, 0xdc, + 0x8d, 0x01, 0xd2, 0xdd, 0x8d, 0x01, 0xd3, 0xde, 0x8d, 0x01, 0xd4, 0xdf, + 0x8d, 0x01, 0xd5, 0xe0, 0x8d, 0x01, 0xd6, 0xe1, 0x8d, 0x01, 0xd7, 0xe2, + 0x8d, 0x01, 0xd8, 0xe3, 0x8d, 0x01, 0xd9, 0xe4, 0x8d, 0x41, 0xd0, 0xd1, + 0x8d, 0x01, 0xd1, 0xd2, 0x8d, 0x01, 0xd2, 0xd3, 0x8d, 0x01, 0xd3, 0xd4, + 0x8d, 0x01, 0xd4, 0xd5, 0x8d, 0x01, 0xd5, 0xd6, 0x8d, 0x01, 0xd6, 0xd7, + 0x8d, 0x01, 0xd7, 0xd8, 0x8d, 0x01, 0xd8, 0xd9, 0x8d, 0x01, 0xd9, 0xda, + 0x8d, 0x41, 0xd0, 0xc7, 0x8d, 0x01, 0xd1, 0xc8, 0x8d, 0x01, 0xd2, 0xc9, + 0x8d, 0x01, 0xd3, 0xca, 0x8d, 0x01, 0xd4, 0xcb, 0x8d, 0x01, 0xd5, 0xcc, + 0x8d, 0x01, 0xd6, 0xcd, 0x8d, 0x01, 0xd7, 0xce, 0x8d, 0x01, 0xd8, 0xcf, + 0x8d, 0x01, 0xd9, 0xd0, 0x8d, 0x41, 0xd0, 0xbd, 0x8d, 0x01, 0xd1, 0xbe, + 0x8d, 0x01, 0xd2, 0xbf, 0x8d, 0x01, 0xd3, 0xc0, 0x8d, 0x01, 0xd4, 0xc1, + 0x8d, 0x01, 0xd5, 0xc2, 0x8d, 0x01, 0xd6, 0xc3, 0x8d, 0x01, 0xd7, 0xc4, + 0x8d, 0x01, 0xd8, 0xc5, 0x8d, 0x01, 0xd9, 0xc6, 0x8d, 0x41, 0xd0, 0xb3, + 0x8d, 0x01, 0xd1, 0xb4, 0x8d, 0x01, 0xd2, 0xb5, 0x8d, 0x01, 0xd3, 0xb6, + 0x8d, 0x01, 0xd4, 0xb7, 0x8d, 0x01, 0xd5, 0xb8, 0x8d, 0x01, 0xd6, 0xb9, + 0x8d, 0x01, 0xd7, 0xba, 0x8d, 0x01, 0xd8, 0xbb, 0x8d, 0x01, 0xd9, 0xbc, + 0x8d, 0x41, 0xd0, 0xa9, 0x8d, 0x01, 0xd1, 0xaa, 0x8d, 0x01, 0xd2, 0xab, + 0x8d, 0x01, 0xd3, 0xac, 0x8d, 0x01, 0xd4, 0xad, 0x8d, 0x01, 0xd5, 0xae, + 0x8d, 0x01, 0xd6, 0xaf, 0x8d, 0x01, 0xd7, 0xb0, 0x8d, 0x01, 0xd8, 0xb1, + 0x8d, 0x01, 0xd9, 0xb2, 0x8d, 0x41, 0xd0, 0x9f, 0x8d, 0x01, 0xd1, 0xa0, + 0x8d, 0x01, 0xd2, 0xa1, 0x8d, 0x01, 0xd3, 0xa2, 0x8d, 0x01, 0xd4, 0xa3, + 0x8d, 0x01, 0xd5, 0xa4, 0x8d, 0x01, 0xd6, 0xa5, 0x8d, 0x01, 0xd7, 0xa6, + 0x8d, 0x01, 0xd8, 0xa7, 0x8d, 0x01, 0xd9, 0xa8, 0x8d, 0x41, 0x90, 0x80, 0x03, 0x91, 0xd5, 0x02, 0x92, 0xaa, 0x02, 0x93, 0xff, 0x01, 0x94, 0xd4, 0x01, 0x95, 0xa9, 0x01, 0x96, 0x7f, 0x97, 0x55, 0x98, 0x2b, 0x99, 0x01, - 0xff, 0xd0, 0x21, 0x89, 0x01, 0xd1, 0x22, 0x89, 0x01, 0xd2, 0x23, 0x89, - 0x01, 0xd3, 0x24, 0x89, 0x01, 0xd4, 0x25, 0x89, 0x01, 0xd5, 0x26, 0x89, - 0x01, 0xd6, 0x27, 0x89, 0x01, 0xd7, 0x28, 0x89, 0x01, 0xd8, 0x29, 0x89, - 0x01, 0xd9, 0x2a, 0x89, 0x41, 0xd0, 0x17, 0x89, 0x01, 0xd1, 0x18, 0x89, - 0x01, 0xd2, 0x19, 0x89, 0x01, 0xd3, 0x1a, 0x89, 0x01, 0xd4, 0x1b, 0x89, - 0x01, 0xd5, 0x1c, 0x89, 0x01, 0xd6, 0x1d, 0x89, 0x01, 0xd7, 0x1e, 0x89, - 0x01, 0xd8, 0x1f, 0x89, 0x01, 0xd9, 0x20, 0x89, 0x41, 0xd0, 0x0d, 0x89, - 0x01, 0xd1, 0x0e, 0x89, 0x01, 0xd2, 0x0f, 0x89, 0x01, 0xd3, 0x10, 0x89, - 0x01, 0xd4, 0x11, 0x89, 0x01, 0xd5, 0x12, 0x89, 0x01, 0xd6, 0x13, 0x89, - 0x01, 0xd7, 0x14, 0x89, 0x01, 0xd8, 0x15, 0x89, 0x01, 0xd9, 0x16, 0x89, - 0x41, 0xd0, 0x03, 0x89, 0x01, 0xd1, 0x04, 0x89, 0x01, 0xd2, 0x05, 0x89, - 0x01, 0xd3, 0x06, 0x89, 0x01, 0xd4, 0x07, 0x89, 0x01, 0xd5, 0x08, 0x89, - 0x01, 0xd6, 0x09, 0x89, 0x01, 0xd7, 0x0a, 0x89, 0x01, 0xd8, 0x0b, 0x89, - 0x01, 0xd9, 0x0c, 0x89, 0x41, 0xd0, 0xf9, 0x88, 0x01, 0xd1, 0xfa, 0x88, - 0x01, 0xd2, 0xfb, 0x88, 0x01, 0xd3, 0xfc, 0x88, 0x01, 0xd4, 0xfd, 0x88, - 0x01, 0xd5, 0xfe, 0x88, 0x01, 0xd6, 0xff, 0x88, 0x01, 0xd7, 0x00, 0x89, - 0x01, 0xd8, 0x01, 0x89, 0x01, 0xd9, 0x02, 0x89, 0x41, 0xd0, 0xef, 0x88, - 0x01, 0xd1, 0xf0, 0x88, 0x01, 0xd2, 0xf1, 0x88, 0x01, 0xd3, 0xf2, 0x88, - 0x01, 0xd4, 0xf3, 0x88, 0x01, 0xd5, 0xf4, 0x88, 0x01, 0xd6, 0xf5, 0x88, - 0x01, 0xd7, 0xf6, 0x88, 0x01, 0xd8, 0xf7, 0x88, 0x01, 0xd9, 0xf8, 0x88, - 0x41, 0xd0, 0xe5, 0x88, 0x01, 0xd1, 0xe6, 0x88, 0x01, 0xd2, 0xe7, 0x88, - 0x01, 0xd3, 0xe8, 0x88, 0x01, 0xd4, 0xe9, 0x88, 0x01, 0xd5, 0xea, 0x88, - 0x01, 0xd6, 0xeb, 0x88, 0x01, 0xd7, 0xec, 0x88, 0x01, 0xd8, 0xed, 0x88, - 0x01, 0xd9, 0xee, 0x88, 0x41, 0xd0, 0xdb, 0x88, 0x01, 0xd1, 0xdc, 0x88, - 0x01, 0xd2, 0xdd, 0x88, 0x01, 0xd3, 0xde, 0x88, 0x01, 0xd4, 0xdf, 0x88, - 0x01, 0xd5, 0xe0, 0x88, 0x01, 0xd6, 0xe1, 0x88, 0x01, 0xd7, 0xe2, 0x88, - 0x01, 0xd8, 0xe3, 0x88, 0x01, 0xd9, 0xe4, 0x88, 0x41, 0xd0, 0xd1, 0x88, - 0x01, 0xd1, 0xd2, 0x88, 0x01, 0xd2, 0xd3, 0x88, 0x01, 0xd3, 0xd4, 0x88, - 0x01, 0xd4, 0xd5, 0x88, 0x01, 0xd5, 0xd6, 0x88, 0x01, 0xd6, 0xd7, 0x88, - 0x01, 0xd7, 0xd8, 0x88, 0x01, 0xd8, 0xd9, 0x88, 0x01, 0xd9, 0xda, 0x88, - 0x41, 0xd0, 0xc7, 0x88, 0x01, 0xd1, 0xc8, 0x88, 0x01, 0xd2, 0xc9, 0x88, - 0x01, 0xd3, 0xca, 0x88, 0x01, 0xd4, 0xcb, 0x88, 0x01, 0xd5, 0xcc, 0x88, - 0x01, 0xd6, 0xcd, 0x88, 0x01, 0xd7, 0xce, 0x88, 0x01, 0xd8, 0xcf, 0x88, - 0x01, 0xd9, 0xd0, 0x88, 0x41, 0x90, 0x80, 0x03, 0x91, 0xd5, 0x02, 0x92, + 0xff, 0xd0, 0x95, 0x8d, 0x01, 0xd1, 0x96, 0x8d, 0x01, 0xd2, 0x97, 0x8d, + 0x01, 0xd3, 0x98, 0x8d, 0x01, 0xd4, 0x99, 0x8d, 0x01, 0xd5, 0x9a, 0x8d, + 0x01, 0xd6, 0x9b, 0x8d, 0x01, 0xd7, 0x9c, 0x8d, 0x01, 0xd8, 0x9d, 0x8d, + 0x01, 0xd9, 0x9e, 0x8d, 0x41, 0xd0, 0x8b, 0x8d, 0x01, 0xd1, 0x8c, 0x8d, + 0x01, 0xd2, 0x8d, 0x8d, 0x01, 0xd3, 0x8e, 0x8d, 0x01, 0xd4, 0x8f, 0x8d, + 0x01, 0xd5, 0x90, 0x8d, 0x01, 0xd6, 0x91, 0x8d, 0x01, 0xd7, 0x92, 0x8d, + 0x01, 0xd8, 0x93, 0x8d, 0x01, 0xd9, 0x94, 0x8d, 0x41, 0xd0, 0x81, 0x8d, + 0x01, 0xd1, 0x82, 0x8d, 0x01, 0xd2, 0x83, 0x8d, 0x01, 0xd3, 0x84, 0x8d, + 0x01, 0xd4, 0x85, 0x8d, 0x01, 0xd5, 0x86, 0x8d, 0x01, 0xd6, 0x87, 0x8d, + 0x01, 0xd7, 0x88, 0x8d, 0x01, 0xd8, 0x89, 0x8d, 0x01, 0xd9, 0x8a, 0x8d, + 0x41, 0xd0, 0xf7, 0x8a, 0x01, 0xd1, 0xf8, 0x8a, 0x01, 0xd2, 0xf9, 0x8a, + 0x01, 0xd3, 0xfa, 0x8a, 0x01, 0xd4, 0xfb, 0x8a, 0x01, 0xd5, 0xfc, 0x8a, + 0x01, 0xd6, 0xfd, 0x8a, 0x01, 0xd7, 0xfe, 0x8a, 0x01, 0xd8, 0xff, 0x8a, + 0x01, 0xd9, 0x80, 0x8d, 0x41, 0xd0, 0xed, 0x8a, 0x01, 0xd1, 0xee, 0x8a, + 0x01, 0xd2, 0xef, 0x8a, 0x01, 0xd3, 0xf0, 0x8a, 0x01, 0xd4, 0xf1, 0x8a, + 0x01, 0xd5, 0xf2, 0x8a, 0x01, 0xd6, 0xf3, 0x8a, 0x01, 0xd7, 0xf4, 0x8a, + 0x01, 0xd8, 0xf5, 0x8a, 0x01, 0xd9, 0xf6, 0x8a, 0x41, 0xd0, 0xe3, 0x8a, + 0x01, 0xd1, 0xe4, 0x8a, 0x01, 0xd2, 0xe5, 0x8a, 0x01, 0xd3, 0xe6, 0x8a, + 0x01, 0xd4, 0xe7, 0x8a, 0x01, 0xd5, 0xe8, 0x8a, 0x01, 0xd6, 0xe9, 0x8a, + 0x01, 0xd7, 0xea, 0x8a, 0x01, 0xd8, 0xeb, 0x8a, 0x01, 0xd9, 0xec, 0x8a, + 0x41, 0xd0, 0xd9, 0x8a, 0x01, 0xd1, 0xda, 0x8a, 0x01, 0xd2, 0xdb, 0x8a, + 0x01, 0xd3, 0xdc, 0x8a, 0x01, 0xd4, 0xdd, 0x8a, 0x01, 0xd5, 0xde, 0x8a, + 0x01, 0xd6, 0xdf, 0x8a, 0x01, 0xd7, 0xe0, 0x8a, 0x01, 0xd8, 0xe1, 0x8a, + 0x01, 0xd9, 0xe2, 0x8a, 0x41, 0xd0, 0xcf, 0x8a, 0x01, 0xd1, 0xd0, 0x8a, + 0x01, 0xd2, 0xd1, 0x8a, 0x01, 0xd3, 0xd2, 0x8a, 0x01, 0xd4, 0xd3, 0x8a, + 0x01, 0xd5, 0xd4, 0x8a, 0x01, 0xd6, 0xd5, 0x8a, 0x01, 0xd7, 0xd6, 0x8a, + 0x01, 0xd8, 0xd7, 0x8a, 0x01, 0xd9, 0xd8, 0x8a, 0x41, 0xd0, 0xc5, 0x8a, + 0x01, 0xd1, 0xc6, 0x8a, 0x01, 0xd2, 0xc7, 0x8a, 0x01, 0xd3, 0xc8, 0x8a, + 0x01, 0xd4, 0xc9, 0x8a, 0x01, 0xd5, 0xca, 0x8a, 0x01, 0xd6, 0xcb, 0x8a, + 0x01, 0xd7, 0xcc, 0x8a, 0x01, 0xd8, 0xcd, 0x8a, 0x01, 0xd9, 0xce, 0x8a, + 0x41, 0xd0, 0xbb, 0x8a, 0x01, 0xd1, 0xbc, 0x8a, 0x01, 0xd2, 0xbd, 0x8a, + 0x01, 0xd3, 0xbe, 0x8a, 0x01, 0xd4, 0xbf, 0x8a, 0x01, 0xd5, 0xc0, 0x8a, + 0x01, 0xd6, 0xc1, 0x8a, 0x01, 0xd7, 0xc2, 0x8a, 0x01, 0xd8, 0xc3, 0x8a, + 0x01, 0xd9, 0xc4, 0x8a, 0x41, 0x90, 0x80, 0x03, 0x91, 0xd5, 0x02, 0x92, 0xaa, 0x02, 0x93, 0xff, 0x01, 0x94, 0xd4, 0x01, 0x95, 0xa9, 0x01, 0x96, - 0x7f, 0x97, 0x55, 0x98, 0x2b, 0x99, 0x01, 0xff, 0xd0, 0xbd, 0x88, 0x01, - 0xd1, 0xbe, 0x88, 0x01, 0xd2, 0xbf, 0x88, 0x01, 0xd3, 0xc0, 0x88, 0x01, - 0xd4, 0xc1, 0x88, 0x01, 0xd5, 0xc2, 0x88, 0x01, 0xd6, 0xc3, 0x88, 0x01, - 0xd7, 0xc4, 0x88, 0x01, 0xd8, 0xc5, 0x88, 0x01, 0xd9, 0xc6, 0x88, 0x41, - 0xd0, 0xb3, 0x88, 0x01, 0xd1, 0xb4, 0x88, 0x01, 0xd2, 0xb5, 0x88, 0x01, - 0xd3, 0xb6, 0x88, 0x01, 0xd4, 0xb7, 0x88, 0x01, 0xd5, 0xb8, 0x88, 0x01, - 0xd6, 0xb9, 0x88, 0x01, 0xd7, 0xba, 0x88, 0x01, 0xd8, 0xbb, 0x88, 0x01, - 0xd9, 0xbc, 0x88, 0x41, 0xd0, 0xa9, 0x88, 0x01, 0xd1, 0xaa, 0x88, 0x01, - 0xd2, 0xab, 0x88, 0x01, 0xd3, 0xac, 0x88, 0x01, 0xd4, 0xad, 0x88, 0x01, - 0xd5, 0xae, 0x88, 0x01, 0xd6, 0xaf, 0x88, 0x01, 0xd7, 0xb0, 0x88, 0x01, - 0xd8, 0xb1, 0x88, 0x01, 0xd9, 0xb2, 0x88, 0x41, 0xd0, 0x9f, 0x88, 0x01, - 0xd1, 0xa0, 0x88, 0x01, 0xd2, 0xa1, 0x88, 0x01, 0xd3, 0xa2, 0x88, 0x01, - 0xd4, 0xa3, 0x88, 0x01, 0xd5, 0xa4, 0x88, 0x01, 0xd6, 0xa5, 0x88, 0x01, - 0xd7, 0xa6, 0x88, 0x01, 0xd8, 0xa7, 0x88, 0x01, 0xd9, 0xa8, 0x88, 0x41, - 0xd0, 0x95, 0x88, 0x01, 0xd1, 0x96, 0x88, 0x01, 0xd2, 0x97, 0x88, 0x01, - 0xd3, 0x98, 0x88, 0x01, 0xd4, 0x99, 0x88, 0x01, 0xd5, 0x9a, 0x88, 0x01, - 0xd6, 0x9b, 0x88, 0x01, 0xd7, 0x9c, 0x88, 0x01, 0xd8, 0x9d, 0x88, 0x01, - 0xd9, 0x9e, 0x88, 0x41, 0xd0, 0x8b, 0x88, 0x01, 0xd1, 0x8c, 0x88, 0x01, - 0xd2, 0x8d, 0x88, 0x01, 0xd3, 0x8e, 0x88, 0x01, 0xd4, 0x8f, 0x88, 0x01, - 0xd5, 0x90, 0x88, 0x01, 0xd6, 0x91, 0x88, 0x01, 0xd7, 0x92, 0x88, 0x01, - 0xd8, 0x93, 0x88, 0x01, 0xd9, 0x94, 0x88, 0x41, 0xd0, 0x81, 0x88, 0x01, - 0xd1, 0x82, 0x88, 0x01, 0xd2, 0x83, 0x88, 0x01, 0xd3, 0x84, 0x88, 0x01, - 0xd4, 0x85, 0x88, 0x01, 0xd5, 0x86, 0x88, 0x01, 0xd6, 0x87, 0x88, 0x01, - 0xd7, 0x88, 0x88, 0x01, 0xd8, 0x89, 0x88, 0x01, 0xd9, 0x8a, 0x88, 0x41, - 0xd0, 0x77, 0x88, 0x01, 0xd1, 0x78, 0x88, 0x01, 0xd2, 0x79, 0x88, 0x01, - 0xd3, 0x7a, 0x88, 0x01, 0xd4, 0x7b, 0x88, 0x01, 0xd5, 0x7c, 0x88, 0x01, - 0xd6, 0x7d, 0x88, 0x01, 0xd7, 0x7e, 0x88, 0x01, 0xd8, 0x7f, 0x88, 0x01, - 0xd9, 0x80, 0x88, 0x41, 0xd0, 0x6d, 0x88, 0x01, 0xd1, 0x6e, 0x88, 0x01, - 0xd2, 0x6f, 0x88, 0x01, 0xd3, 0x70, 0x88, 0x01, 0xd4, 0x71, 0x88, 0x01, - 0xd5, 0x72, 0x88, 0x01, 0xd6, 0x73, 0x88, 0x01, 0xd7, 0x74, 0x88, 0x01, - 0xd8, 0x75, 0x88, 0x01, 0xd9, 0x76, 0x88, 0x41, 0xd0, 0x63, 0x88, 0x01, - 0xd1, 0x64, 0x88, 0x01, 0xd2, 0x65, 0x88, 0x01, 0xd3, 0x66, 0x88, 0x01, - 0xd4, 0x67, 0x88, 0x01, 0xd5, 0x68, 0x88, 0x01, 0xd6, 0x69, 0x88, 0x01, - 0xd7, 0x6a, 0x88, 0x01, 0xd8, 0x6b, 0x88, 0x01, 0xd9, 0x6c, 0x88, 0x41, + 0x7f, 0x97, 0x55, 0x98, 0x2b, 0x99, 0x01, 0xff, 0xd0, 0xb1, 0x8a, 0x01, + 0xd1, 0xb2, 0x8a, 0x01, 0xd2, 0xb3, 0x8a, 0x01, 0xd3, 0xb4, 0x8a, 0x01, + 0xd4, 0xb5, 0x8a, 0x01, 0xd5, 0xb6, 0x8a, 0x01, 0xd6, 0xb7, 0x8a, 0x01, + 0xd7, 0xb8, 0x8a, 0x01, 0xd8, 0xb9, 0x8a, 0x01, 0xd9, 0xba, 0x8a, 0x41, + 0xd0, 0xa7, 0x8a, 0x01, 0xd1, 0xa8, 0x8a, 0x01, 0xd2, 0xa9, 0x8a, 0x01, + 0xd3, 0xaa, 0x8a, 0x01, 0xd4, 0xab, 0x8a, 0x01, 0xd5, 0xac, 0x8a, 0x01, + 0xd6, 0xad, 0x8a, 0x01, 0xd7, 0xae, 0x8a, 0x01, 0xd8, 0xaf, 0x8a, 0x01, + 0xd9, 0xb0, 0x8a, 0x41, 0xd0, 0x9d, 0x8a, 0x01, 0xd1, 0x9e, 0x8a, 0x01, + 0xd2, 0x9f, 0x8a, 0x01, 0xd3, 0xa0, 0x8a, 0x01, 0xd4, 0xa1, 0x8a, 0x01, + 0xd5, 0xa2, 0x8a, 0x01, 0xd6, 0xa3, 0x8a, 0x01, 0xd7, 0xa4, 0x8a, 0x01, + 0xd8, 0xa5, 0x8a, 0x01, 0xd9, 0xa6, 0x8a, 0x41, 0xd0, 0x93, 0x8a, 0x01, + 0xd1, 0x94, 0x8a, 0x01, 0xd2, 0x95, 0x8a, 0x01, 0xd3, 0x96, 0x8a, 0x01, + 0xd4, 0x97, 0x8a, 0x01, 0xd5, 0x98, 0x8a, 0x01, 0xd6, 0x99, 0x8a, 0x01, + 0xd7, 0x9a, 0x8a, 0x01, 0xd8, 0x9b, 0x8a, 0x01, 0xd9, 0x9c, 0x8a, 0x41, + 0xd0, 0x89, 0x8a, 0x01, 0xd1, 0x8a, 0x8a, 0x01, 0xd2, 0x8b, 0x8a, 0x01, + 0xd3, 0x8c, 0x8a, 0x01, 0xd4, 0x8d, 0x8a, 0x01, 0xd5, 0x8e, 0x8a, 0x01, + 0xd6, 0x8f, 0x8a, 0x01, 0xd7, 0x90, 0x8a, 0x01, 0xd8, 0x91, 0x8a, 0x01, + 0xd9, 0x92, 0x8a, 0x41, 0xd0, 0x7f, 0x8a, 0x01, 0xd1, 0x80, 0x8a, 0x01, + 0xd2, 0x81, 0x8a, 0x01, 0xd3, 0x82, 0x8a, 0x01, 0xd4, 0x83, 0x8a, 0x01, + 0xd5, 0x84, 0x8a, 0x01, 0xd6, 0x85, 0x8a, 0x01, 0xd7, 0x86, 0x8a, 0x01, + 0xd8, 0x87, 0x8a, 0x01, 0xd9, 0x88, 0x8a, 0x41, 0xd0, 0x75, 0x8a, 0x01, + 0xd1, 0x76, 0x8a, 0x01, 0xd2, 0x77, 0x8a, 0x01, 0xd3, 0x78, 0x8a, 0x01, + 0xd4, 0x79, 0x8a, 0x01, 0xd5, 0x7a, 0x8a, 0x01, 0xd6, 0x7b, 0x8a, 0x01, + 0xd7, 0x7c, 0x8a, 0x01, 0xd8, 0x7d, 0x8a, 0x01, 0xd9, 0x7e, 0x8a, 0x41, + 0xd0, 0x6b, 0x8a, 0x01, 0xd1, 0x6c, 0x8a, 0x01, 0xd2, 0x6d, 0x8a, 0x01, + 0xd3, 0x6e, 0x8a, 0x01, 0xd4, 0x6f, 0x8a, 0x01, 0xd5, 0x70, 0x8a, 0x01, + 0xd6, 0x71, 0x8a, 0x01, 0xd7, 0x72, 0x8a, 0x01, 0xd8, 0x73, 0x8a, 0x01, + 0xd9, 0x74, 0x8a, 0x41, 0xd0, 0x61, 0x8a, 0x01, 0xd1, 0x62, 0x8a, 0x01, + 0xd2, 0x63, 0x8a, 0x01, 0xd3, 0x64, 0x8a, 0x01, 0xd4, 0x65, 0x8a, 0x01, + 0xd5, 0x66, 0x8a, 0x01, 0xd6, 0x67, 0x8a, 0x01, 0xd7, 0x68, 0x8a, 0x01, + 0xd8, 0x69, 0x8a, 0x01, 0xd9, 0x6a, 0x8a, 0x41, 0xd0, 0x57, 0x8a, 0x01, + 0xd1, 0x58, 0x8a, 0x01, 0xd2, 0x59, 0x8a, 0x01, 0xd3, 0x5a, 0x8a, 0x01, + 0xd4, 0x5b, 0x8a, 0x01, 0xd5, 0x5c, 0x8a, 0x01, 0xd6, 0x5d, 0x8a, 0x01, + 0xd7, 0x5e, 0x8a, 0x01, 0xd8, 0x5f, 0x8a, 0x01, 0xd9, 0x60, 0x8a, 0x41, 0x90, 0x80, 0x03, 0x91, 0xd5, 0x02, 0x92, 0xaa, 0x02, 0x93, 0xff, 0x01, 0x94, 0xd4, 0x01, 0x95, 0xa9, 0x01, 0x96, 0x7f, 0x97, 0x55, 0x98, 0x2b, - 0x99, 0x01, 0xff, 0xd0, 0x59, 0x88, 0x01, 0xd1, 0x5a, 0x88, 0x01, 0xd2, - 0x5b, 0x88, 0x01, 0xd3, 0x5c, 0x88, 0x01, 0xd4, 0x5d, 0x88, 0x01, 0xd5, - 0x5e, 0x88, 0x01, 0xd6, 0x5f, 0x88, 0x01, 0xd7, 0x60, 0x88, 0x01, 0xd8, - 0x61, 0x88, 0x01, 0xd9, 0x62, 0x88, 0x41, 0xd0, 0x4f, 0x88, 0x01, 0xd1, - 0x50, 0x88, 0x01, 0xd2, 0x51, 0x88, 0x01, 0xd3, 0x52, 0x88, 0x01, 0xd4, - 0x53, 0x88, 0x01, 0xd5, 0x54, 0x88, 0x01, 0xd6, 0x55, 0x88, 0x01, 0xd7, - 0x56, 0x88, 0x01, 0xd8, 0x57, 0x88, 0x01, 0xd9, 0x58, 0x88, 0x41, 0xd0, - 0x45, 0x88, 0x01, 0xd1, 0x46, 0x88, 0x01, 0xd2, 0x47, 0x88, 0x01, 0xd3, - 0x48, 0x88, 0x01, 0xd4, 0x49, 0x88, 0x01, 0xd5, 0x4a, 0x88, 0x01, 0xd6, - 0x4b, 0x88, 0x01, 0xd7, 0x4c, 0x88, 0x01, 0xd8, 0x4d, 0x88, 0x01, 0xd9, - 0x4e, 0x88, 0x41, 0xd0, 0x3b, 0x88, 0x01, 0xd1, 0x3c, 0x88, 0x01, 0xd2, - 0x3d, 0x88, 0x01, 0xd3, 0x3e, 0x88, 0x01, 0xd4, 0x3f, 0x88, 0x01, 0xd5, - 0x40, 0x88, 0x01, 0xd6, 0x41, 0x88, 0x01, 0xd7, 0x42, 0x88, 0x01, 0xd8, - 0x43, 0x88, 0x01, 0xd9, 0x44, 0x88, 0x41, 0xd0, 0x31, 0x88, 0x01, 0xd1, - 0x32, 0x88, 0x01, 0xd2, 0x33, 0x88, 0x01, 0xd3, 0x34, 0x88, 0x01, 0xd4, - 0x35, 0x88, 0x01, 0xd5, 0x36, 0x88, 0x01, 0xd6, 0x37, 0x88, 0x01, 0xd7, - 0x38, 0x88, 0x01, 0xd8, 0x39, 0x88, 0x01, 0xd9, 0x3a, 0x88, 0x41, 0xd0, - 0x27, 0x88, 0x01, 0xd1, 0x28, 0x88, 0x01, 0xd2, 0x29, 0x88, 0x01, 0xd3, - 0x2a, 0x88, 0x01, 0xd4, 0x2b, 0x88, 0x01, 0xd5, 0x2c, 0x88, 0x01, 0xd6, - 0x2d, 0x88, 0x01, 0xd7, 0x2e, 0x88, 0x01, 0xd8, 0x2f, 0x88, 0x01, 0xd9, - 0x30, 0x88, 0x41, 0xd0, 0x1d, 0x88, 0x01, 0xd1, 0x1e, 0x88, 0x01, 0xd2, - 0x1f, 0x88, 0x01, 0xd3, 0x20, 0x88, 0x01, 0xd4, 0x21, 0x88, 0x01, 0xd5, - 0x22, 0x88, 0x01, 0xd6, 0x23, 0x88, 0x01, 0xd7, 0x24, 0x88, 0x01, 0xd8, - 0x25, 0x88, 0x01, 0xd9, 0x26, 0x88, 0x41, 0xd0, 0x13, 0x88, 0x01, 0xd1, - 0x14, 0x88, 0x01, 0xd2, 0x15, 0x88, 0x01, 0xd3, 0x16, 0x88, 0x01, 0xd4, - 0x17, 0x88, 0x01, 0xd5, 0x18, 0x88, 0x01, 0xd6, 0x19, 0x88, 0x01, 0xd7, - 0x1a, 0x88, 0x01, 0xd8, 0x1b, 0x88, 0x01, 0xd9, 0x1c, 0x88, 0x41, 0xd0, - 0x09, 0x88, 0x01, 0xd1, 0x0a, 0x88, 0x01, 0xd2, 0x0b, 0x88, 0x01, 0xd3, - 0x0c, 0x88, 0x01, 0xd4, 0x0d, 0x88, 0x01, 0xd5, 0x0e, 0x88, 0x01, 0xd6, - 0x0f, 0x88, 0x01, 0xd7, 0x10, 0x88, 0x01, 0xd8, 0x11, 0x88, 0x01, 0xd9, - 0x12, 0x88, 0x41, 0xd1, 0x00, 0x88, 0x01, 0xd2, 0x01, 0x88, 0x01, 0xd3, - 0x02, 0x88, 0x01, 0xd4, 0x03, 0x88, 0x01, 0xd5, 0x04, 0x88, 0x01, 0xd6, - 0x05, 0x88, 0x01, 0xd7, 0x06, 0x88, 0x01, 0xd8, 0x07, 0x88, 0x01, 0xd9, - 0x08, 0x88, 0x41, 0x06, 0xef, 0x06, 0xb1, 0x03, 0x07, 0xec, 0x05, 0x01, - 0xff, 0xa1, 0x87, 0x03, 0x42, 0x16, 0x00, 0xaa, 0x6a, 0x01, 0xa3, 0xf4, - 0x02, 0xa4, 0xe7, 0x02, 0xa5, 0xd4, 0x02, 0xa6, 0xc7, 0x02, 0xa7, 0xba, - 0x02, 0xa8, 0xa6, 0x02, 0xa9, 0x93, 0x02, 0xab, 0x86, 0x02, 0xac, 0xf9, - 0x01, 0xad, 0xe2, 0x01, 0xae, 0xc9, 0x01, 0xaf, 0xb6, 0x01, 0xb0, 0xa9, - 0x01, 0x42, 0x71, 0x00, 0xb2, 0x6a, 0x01, 0xb3, 0x84, 0x01, 0xb4, 0x72, - 0xb5, 0x2a, 0xb6, 0x18, 0x42, 0xa9, 0x01, 0xa6, 0x6a, 0x01, 0x42, 0x08, - 0x27, 0xba, 0x6a, 0x01, 0x42, 0xbe, 0x22, 0xa5, 0x6a, 0x01, 0x42, 0x59, - 0x00, 0xbe, 0x6a, 0x41, 0xe3, 0x79, 0x6a, 0x01, 0xf1, 0x7a, 0x6a, 0x01, - 0xf8, 0x7b, 0x6a, 0x01, 0xfa, 0x78, 0x6a, 0x41, 0xe3, 0x85, 0x6a, 0x01, - 0xa5, 0x30, 0xa9, 0x0c, 0xf1, 0x86, 0x6a, 0x01, 0xf8, 0x87, 0x6a, 0x01, - 0xfa, 0x84, 0x6a, 0x41, 0xe3, 0x8d, 0x6a, 0x01, 0xf1, 0x8e, 0x6a, 0x01, - 0xb5, 0x08, 0xf8, 0x8f, 0x6a, 0x01, 0xfa, 0x8c, 0x6a, 0x41, 0xe3, 0x99, - 0x6a, 0x01, 0xf1, 0x9a, 0x6a, 0x01, 0xf8, 0x9b, 0x6a, 0x01, 0xfa, 0x98, - 0x6a, 0x41, 0xe3, 0x94, 0x6a, 0x01, 0xf1, 0x96, 0x6a, 0x01, 0xf8, 0x97, - 0x6a, 0x01, 0xfa, 0x95, 0x6a, 0x41, 0xe1, 0xb0, 0x6a, 0x01, 0x42, 0x22, - 0x00, 0xb9, 0x6a, 0x01, 0x42, 0x40, 0x06, 0xb6, 0x6a, 0x41, 0xe1, 0xa4, - 0x6a, 0x01, 0xa8, 0x01, 0xff, 0xe1, 0xb4, 0x6a, 0x01, 0x04, 0x35, 0x07, - 0x01, 0xff, 0x43, 0x13, 0xf4, 0x93, 0x6a, 0x01, 0x43, 0xd0, 0xf4, 0x92, - 0x6a, 0x41, 0xe1, 0xa7, 0x6a, 0x01, 0x42, 0x22, 0x00, 0xa9, 0x6a, 0x41, - 0xe3, 0x71, 0x6a, 0x01, 0xf1, 0x72, 0x6a, 0x01, 0xf8, 0x73, 0x6a, 0x01, - 0xfa, 0x70, 0x6a, 0x41, 0xe1, 0xac, 0x6a, 0x01, 0x42, 0x24, 0x02, 0xa3, - 0x6a, 0x01, 0x42, 0x22, 0x00, 0xb3, 0x6a, 0x01, 0x42, 0xbe, 0x22, 0xa8, - 0x6a, 0x41, 0xe1, 0xab, 0x6a, 0x01, 0xe3, 0x9d, 0x6a, 0x01, 0xf1, 0x9e, - 0x6a, 0x01, 0xf8, 0x9f, 0x6a, 0x01, 0xfa, 0x9c, 0x6a, 0x41, 0xe1, 0xae, - 0x6a, 0x01, 0x47, 0x07, 0xd4, 0x91, 0x6a, 0x41, 0xe1, 0xa0, 0x6a, 0x01, - 0x42, 0x22, 0x00, 0xa1, 0x6a, 0x41, 0xe3, 0x81, 0x6a, 0x01, 0xf1, 0x82, - 0x6a, 0x01, 0xf8, 0x83, 0x6a, 0x01, 0xfa, 0x80, 0x6a, 0x41, 0xe1, 0xad, - 0x6a, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0xaf, 0x6a, 0x01, 0x42, 0x12, 0x00, - 0xb8, 0x6a, 0x41, 0xe1, 0xa2, 0x6a, 0x01, 0x42, 0x22, 0x00, 0xb7, 0x6a, - 0x41, 0xe1, 0xbb, 0x6a, 0x01, 0x47, 0x0a, 0xb9, 0x90, 0x6a, 0x41, 0xe3, - 0x7d, 0x6a, 0x01, 0xf1, 0x7e, 0x6a, 0x01, 0xf8, 0x7f, 0x6a, 0x01, 0xfa, - 0x7c, 0x6a, 0x41, 0xe1, 0xb1, 0x6a, 0x01, 0x42, 0x22, 0x00, 0xbc, 0x6a, - 0x41, 0xe1, 0xb5, 0x6a, 0x01, 0x42, 0x22, 0x00, 0xbd, 0x6a, 0x41, 0xe3, - 0x75, 0x6a, 0x01, 0xf1, 0x76, 0x6a, 0x01, 0xb7, 0x08, 0xf8, 0x77, 0x6a, - 0x01, 0xfa, 0x74, 0x6a, 0x41, 0xe3, 0x89, 0x6a, 0x01, 0xf1, 0x8a, 0x6a, - 0x01, 0xf8, 0x8b, 0x6a, 0x01, 0xfa, 0x88, 0x6a, 0x41, 0x45, 0x12, 0x0b, - 0xc8, 0x6a, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0xc9, 0x6a, 0x01, 0x43, - 0x0e, 0x0b, 0xc1, 0x6a, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, - 0xc0, 0x6a, 0x41, 0x44, 0x25, 0x01, 0xc3, 0x6a, 0x01, 0x42, 0x15, 0x02, - 0xc2, 0x6a, 0x41, 0x44, 0xe5, 0x1d, 0xc7, 0x6a, 0x01, 0x42, 0x1c, 0x26, - 0xc6, 0x6a, 0x41, 0x43, 0xd2, 0x05, 0xc5, 0x6a, 0x01, 0x43, 0xf6, 0x06, - 0xc4, 0x6a, 0x41, 0x43, 0x67, 0x00, 0xd4, 0xfa, 0x01, 0x03, 0xda, 0x4f, - 0x01, 0xff, 0xa1, 0x9a, 0x06, 0xa3, 0x8b, 0x06, 0xa4, 0xb0, 0x05, 0x09, - 0x25, 0x5a, 0x93, 0x04, 0x52, 0xbe, 0x52, 0xee, 0x1f, 0x01, 0xac, 0xbc, - 0x02, 0x4a, 0x32, 0xae, 0xf4, 0x0b, 0x00, 0x07, 0x1a, 0x3a, 0x95, 0x02, - 0x42, 0x14, 0x05, 0xd0, 0x0b, 0x00, 0x57, 0x84, 0x30, 0xff, 0x1f, 0x01, - 0x4a, 0x7a, 0x80, 0xf9, 0x0b, 0x00, 0xb3, 0x5b, 0xb4, 0x42, 0x0b, 0x55, - 0x77, 0x0c, 0x54, 0xbf, 0x46, 0xe4, 0x1f, 0x01, 0x49, 0xb8, 0xc1, 0xf5, - 0x0b, 0x40, 0xa1, 0x24, 0xe5, 0xc6, 0x0b, 0x80, 0x1b, 0xe9, 0xbf, 0x0b, - 0x80, 0x12, 0xef, 0xca, 0x0b, 0x80, 0x09, 0xf5, 0xc1, 0x0b, 0xc0, 0x00, - 0xf5, 0xc2, 0x0b, 0x40, 0xef, 0xcb, 0x0b, 0x40, 0xe9, 0xc0, 0x0b, 0x40, - 0xe5, 0xc7, 0x0b, 0x40, 0xe1, 0xbe, 0x0b, 0x00, 0xe9, 0xc8, 0x0b, 0x00, - 0xf5, 0xcc, 0x0b, 0x40, 0x49, 0xa4, 0xbd, 0xed, 0x1f, 0x01, 0x0b, 0x57, - 0x7d, 0x01, 0xff, 0x4b, 0x76, 0x9a, 0xe8, 0x1f, 0x01, 0x4b, 0x64, 0xa0, - 0xe9, 0x1f, 0x41, 0x4c, 0x34, 0x8c, 0xe7, 0x1f, 0x01, 0x04, 0x5b, 0x03, - 0x0c, 0x49, 0x19, 0xbe, 0xec, 0x1f, 0x01, 0x51, 0x32, 0x5e, 0xef, 0x1f, - 0x41, 0xa1, 0x81, 0x01, 0x46, 0x8a, 0xda, 0xd6, 0x1f, 0x01, 0xab, 0x64, - 0x02, 0xc3, 0x16, 0x4e, 0x43, 0x17, 0xc8, 0xd5, 0x1f, 0x01, 0xb0, 0x2c, - 0x47, 0xeb, 0xc0, 0xd8, 0x1f, 0x01, 0xb6, 0x01, 0xff, 0xa1, 0x15, 0x43, - 0xc5, 0x2d, 0xe3, 0x1f, 0x01, 0xa9, 0x01, 0xff, 0x44, 0xe7, 0x23, 0xcd, - 0x0b, 0x00, 0x45, 0xf3, 0x4b, 0x83, 0x0b, 0x40, 0x48, 0x89, 0xc7, 0xf1, - 0x1f, 0x01, 0x46, 0x82, 0xdf, 0xe0, 0x1f, 0x41, 0xa1, 0x06, 0x42, 0x10, - 0x00, 0xdf, 0x1f, 0x41, 0x44, 0x90, 0x77, 0xe1, 0x1f, 0x01, 0x43, 0x2a, - 0x05, 0xde, 0x1f, 0x01, 0x46, 0xae, 0xe0, 0xdb, 0x1f, 0x41, 0x47, 0x86, - 0xd2, 0xdc, 0x1f, 0x01, 0x47, 0x68, 0xd6, 0xf0, 0x1f, 0x01, 0x49, 0xe9, - 0xc0, 0xd9, 0x1f, 0x41, 0x44, 0xfd, 0xee, 0xdd, 0x1f, 0x01, 0xb5, 0x01, - 0xff, 0x44, 0x19, 0x7e, 0xda, 0x1f, 0x01, 0x43, 0x68, 0x7f, 0xe2, 0x1f, - 0x41, 0x48, 0x01, 0xc4, 0xd7, 0x1f, 0x01, 0x47, 0x3d, 0x16, 0x82, 0x0b, - 0x40, 0x04, 0x0e, 0x0b, 0x0c, 0x44, 0x5a, 0x03, 0xfa, 0x0b, 0x00, 0x43, - 0xdb, 0x06, 0xf0, 0x0b, 0x40, 0x47, 0x71, 0x11, 0xf1, 0x0b, 0x00, 0x48, - 0x47, 0x5e, 0xf2, 0x0b, 0x40, 0x48, 0xb5, 0x47, 0xe6, 0x1f, 0x01, 0x06, - 0xed, 0x05, 0x01, 0xff, 0xe1, 0x85, 0x0b, 0x80, 0xb1, 0x01, 0x42, 0x37, - 0x00, 0x9a, 0x0b, 0x00, 0xe5, 0x8e, 0x0b, 0x80, 0xa1, 0x01, 0x42, 0x22, - 0x00, 0xb9, 0x0b, 0x00, 0xe9, 0x87, 0x0b, 0x80, 0x91, 0x01, 0x42, 0x72, - 0x19, 0x9c, 0x0b, 0x00, 0x42, 0x1b, 0x02, 0x95, 0x0b, 0x00, 0xac, 0x72, - 0x42, 0x6c, 0x00, 0xae, 0x0b, 0x00, 0xae, 0x4e, 0xef, 0x92, 0x0b, 0x80, - 0x45, 0x42, 0xbb, 0x09, 0xaa, 0x0b, 0x00, 0xb2, 0x33, 0xb3, 0x21, 0xb4, - 0x15, 0xf5, 0x89, 0x0b, 0x80, 0x0c, 0x42, 0xf5, 0x0a, 0xb5, 0x0b, 0x00, - 0x42, 0xbe, 0x22, 0xaf, 0x0b, 0x40, 0xf5, 0x8a, 0x0b, 0x40, 0xe1, 0xa4, - 0x0b, 0x00, 0x42, 0x12, 0x00, 0x9f, 0x0b, 0x40, 0xe1, 0xb8, 0x0b, 0x00, - 0x42, 0x22, 0x00, 0xb6, 0x0b, 0x00, 0x42, 0x40, 0x06, 0xb7, 0x0b, 0x40, - 0xe1, 0xb0, 0x0b, 0x00, 0x42, 0x71, 0x00, 0xb1, 0x0b, 0x40, 0xef, 0x93, - 0x0b, 0x40, 0xe1, 0xa8, 0x0b, 0x00, 0x42, 0x24, 0x02, 0x99, 0x0b, 0x00, - 0xae, 0x06, 0x42, 0xbe, 0x22, 0x9e, 0x0b, 0x40, 0xe1, 0xa3, 0x0b, 0x00, - 0x42, 0x2a, 0x05, 0xa9, 0x0b, 0x40, 0xe1, 0xb2, 0x0b, 0x00, 0xac, 0x01, - 0xff, 0xe1, 0xb3, 0x0b, 0x00, 0x42, 0x74, 0x00, 0xb4, 0x0b, 0x40, 0xe9, - 0x88, 0x0b, 0x40, 0xe5, 0x8f, 0x0b, 0x40, 0xe1, 0x86, 0x0b, 0x00, 0xe9, - 0x90, 0x0b, 0x00, 0xf5, 0x94, 0x0b, 0x40, 0x58, 0x59, 0x28, 0xd4, 0x1f, - 0x01, 0x04, 0x0e, 0x0b, 0x27, 0x06, 0x24, 0x01, 0x01, 0xff, 0x4a, 0xfa, - 0xa9, 0xc6, 0x1f, 0x01, 0x48, 0x2a, 0x01, 0xd3, 0x1f, 0x01, 0x04, 0x1b, - 0x26, 0x06, 0x4a, 0x60, 0xb2, 0xcd, 0x1f, 0x41, 0x46, 0x38, 0xb1, 0xce, - 0x1f, 0x01, 0x49, 0xaf, 0xc1, 0xc7, 0x1f, 0x41, 0x05, 0x12, 0x0b, 0x59, - 0xa6, 0x4b, 0x05, 0xdb, 0x2c, 0x3f, 0x58, 0x51, 0x2a, 0xc1, 0x1f, 0x01, - 0x47, 0x2a, 0x01, 0xd0, 0x1f, 0x01, 0x04, 0x1b, 0x26, 0x1d, 0xb4, 0x01, - 0xff, 0x44, 0x9e, 0x1b, 0xcb, 0x1f, 0x01, 0xa8, 0x06, 0x48, 0xf0, 0x25, - 0xc8, 0x1f, 0x41, 0x4b, 0x84, 0x90, 0xc5, 0x1f, 0x01, 0x59, 0xdf, 0x25, - 0xc0, 0x1f, 0x41, 0x06, 0x4a, 0xdb, 0x06, 0x48, 0xa6, 0xc1, 0xc3, 0x1f, - 0x41, 0xd1, 0xc9, 0x1f, 0x01, 0xd2, 0xca, 0x1f, 0x41, 0xd1, 0xd1, 0x1f, - 0x01, 0xd2, 0xd2, 0x1f, 0x41, 0x44, 0x63, 0xaf, 0xcf, 0x1f, 0x01, 0x47, - 0x38, 0xd4, 0xc4, 0x1f, 0x41, 0xe8, 0xcc, 0x1f, 0x01, 0x44, 0xf4, 0x25, - 0xc2, 0x1f, 0x41, 0x47, 0x68, 0xcf, 0xf3, 0x0b, 0x00, 0x49, 0x28, 0xb8, - 0xf6, 0x0b, 0x00, 0x05, 0xf0, 0x06, 0x06, 0x53, 0xdc, 0x4c, 0xe5, 0x1f, - 0x41, 0x45, 0x12, 0x0b, 0xee, 0x0b, 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, - 0xef, 0x0b, 0x00, 0x43, 0x0e, 0x0b, 0xe7, 0x0b, 0x00, 0xb3, 0x14, 0xb4, - 0x06, 0x44, 0x5f, 0x1e, 0xe6, 0x0b, 0x40, 0x44, 0x25, 0x01, 0xe9, 0x0b, - 0x00, 0x42, 0x15, 0x02, 0xe8, 0x0b, 0x40, 0x44, 0xe5, 0x1d, 0xed, 0x0b, - 0x00, 0x42, 0x1c, 0x26, 0xec, 0x0b, 0x40, 0x43, 0xd2, 0x05, 0xeb, 0x0b, - 0x00, 0x43, 0xf6, 0x06, 0xea, 0x0b, 0x40, 0x4a, 0x77, 0x9a, 0xf7, 0x0b, - 0x00, 0x4b, 0x9a, 0xa4, 0xea, 0x1f, 0x41, 0x4b, 0x0c, 0xa0, 0xeb, 0x1f, - 0x01, 0x4c, 0x10, 0x95, 0xf8, 0x0b, 0x00, 0x4d, 0x1f, 0x76, 0xd7, 0x0b, - 0x40, 0x44, 0x80, 0x11, 0x78, 0xd3, 0x01, 0x43, 0x0e, 0x0b, 0x77, 0xd3, - 0x41, 0x48, 0xc9, 0xc5, 0x61, 0xf9, 0x01, 0x03, 0xe5, 0x0a, 0x01, 0xff, - 0x51, 0xe3, 0x57, 0xb9, 0x16, 0x01, 0x06, 0xef, 0x06, 0xd1, 0x02, 0x07, - 0xec, 0x05, 0x4e, 0x05, 0x5a, 0x03, 0x2d, 0x0b, 0x55, 0x77, 0x01, 0xff, - 0xa1, 0x1a, 0xe5, 0xb2, 0x16, 0x01, 0xe9, 0xae, 0x16, 0x81, 0x0d, 0xef, - 0xb4, 0x16, 0x01, 0xf5, 0xb0, 0x16, 0xc1, 0x00, 0xf5, 0xb1, 0x16, 0x41, - 0xe9, 0xaf, 0x16, 0x41, 0xe1, 0xad, 0x16, 0x01, 0xe9, 0xb3, 0x16, 0x01, - 0xf5, 0xb5, 0x16, 0x41, 0x48, 0x3c, 0x16, 0xab, 0x16, 0x01, 0x45, 0x5a, - 0x3f, 0xb7, 0x16, 0x01, 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0xe7, 0x23, - 0xb6, 0x16, 0x01, 0x45, 0xf3, 0x4b, 0xac, 0x16, 0x41, 0xe1, 0x80, 0x16, - 0x81, 0xe7, 0x01, 0xa2, 0xda, 0x01, 0xa3, 0xcd, 0x01, 0xa4, 0xb4, 0x01, - 0xe5, 0x86, 0x16, 0x01, 0xa7, 0xa3, 0x01, 0x42, 0x22, 0x00, 0xa9, 0x16, - 0x01, 0xe9, 0x82, 0x16, 0x81, 0x93, 0x01, 0xaa, 0x86, 0x01, 0xab, 0x7a, - 0x42, 0x74, 0x00, 0xa5, 0x16, 0x01, 0x42, 0x6c, 0x00, 0xa2, 0x16, 0x01, - 0xae, 0x56, 0xef, 0x88, 0x16, 0x01, 0xb0, 0x46, 0xb2, 0x3a, 0xb3, 0x2e, - 0xb4, 0x15, 0xf5, 0x84, 0x16, 0x81, 0x0c, 0x42, 0xf5, 0x0a, 0xa6, 0x16, - 0x01, 0x42, 0xbe, 0x22, 0xa3, 0x16, 0x41, 0xf5, 0x85, 0x16, 0x41, 0xe1, - 0x99, 0x16, 0x01, 0x42, 0x22, 0x00, 0x9a, 0x16, 0x01, 0xb4, 0x01, 0xff, - 0xe1, 0x94, 0x16, 0x01, 0x42, 0x22, 0x00, 0x95, 0x16, 0x41, 0xe1, 0xa8, - 0x16, 0x01, 0x42, 0x22, 0x00, 0xa7, 0x16, 0x41, 0xe1, 0xa4, 0x16, 0x01, - 0x42, 0x71, 0x00, 0xaa, 0x16, 0x41, 0xe1, 0x9e, 0x16, 0x01, 0x42, 0x22, - 0x00, 0x9f, 0x16, 0x41, 0xe1, 0x9d, 0x16, 0x01, 0x42, 0x24, 0x02, 0x8e, - 0x16, 0x01, 0x42, 0x2a, 0x05, 0x98, 0x16, 0x01, 0x42, 0xbe, 0x22, 0x93, - 0x16, 0x41, 0xe1, 0x8a, 0x16, 0x01, 0x42, 0x22, 0x00, 0x8b, 0x16, 0x41, - 0xe1, 0x91, 0x16, 0x01, 0x42, 0x22, 0x00, 0x92, 0x16, 0x41, 0xe9, 0x83, - 0x16, 0x41, 0xe1, 0x8c, 0x16, 0x01, 0x42, 0x22, 0x00, 0x8d, 0x16, 0x41, - 0xe1, 0x9b, 0x16, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x9c, 0x16, 0x41, - 0xe1, 0x96, 0x16, 0x01, 0x42, 0x22, 0x00, 0x97, 0x16, 0x41, 0xe1, 0x8f, - 0x16, 0x01, 0x42, 0x22, 0x00, 0x90, 0x16, 0x41, 0xe1, 0xa0, 0x16, 0x01, - 0x42, 0x22, 0x00, 0xa1, 0x16, 0x41, 0xe1, 0x81, 0x16, 0x01, 0xe9, 0x87, - 0x16, 0x01, 0x4a, 0x12, 0xb0, 0xb8, 0x16, 0x01, 0xf5, 0x89, 0x16, 0x41, - 0x45, 0x12, 0x0b, 0xc8, 0x16, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0xc9, - 0x16, 0x01, 0x43, 0x0e, 0x0b, 0xc1, 0x16, 0x01, 0xb3, 0x14, 0xb4, 0x06, - 0x44, 0x5f, 0x1e, 0xc0, 0x16, 0x41, 0x44, 0x25, 0x01, 0xc3, 0x16, 0x01, - 0x42, 0x15, 0x02, 0xc2, 0x16, 0x41, 0x44, 0xe5, 0x1d, 0xc7, 0x16, 0x01, - 0x42, 0x1c, 0x26, 0xc6, 0x16, 0x41, 0x43, 0xd2, 0x05, 0xc5, 0x16, 0x01, - 0x43, 0xf6, 0x06, 0xc4, 0x16, 0x41, 0x0a, 0xac, 0xac, 0xc6, 0x0c, 0x05, - 0x7c, 0xa3, 0x8b, 0x06, 0x05, 0x3d, 0xec, 0xca, 0x02, 0x03, 0x4f, 0x58, - 0x01, 0xff, 0x07, 0xec, 0x05, 0x2e, 0xb3, 0x06, 0x47, 0xc6, 0xd7, 0xff, - 0xe6, 0x41, 0x04, 0x5b, 0x03, 0x06, 0x4c, 0x50, 0x97, 0xfe, 0xe6, 0x41, - 0xa1, 0x0c, 0x42, 0x14, 0x05, 0xf5, 0xe6, 0x01, 0x42, 0xd6, 0x13, 0xe3, - 0xe6, 0x41, 0x42, 0x1d, 0x01, 0xef, 0xe6, 0x01, 0xf5, 0xe6, 0xe6, 0x01, - 0xf9, 0xee, 0xe6, 0x41, 0xa1, 0xee, 0x01, 0x42, 0x5d, 0x00, 0xd0, 0xe6, - 0x01, 0x42, 0x13, 0x05, 0xc6, 0xe6, 0x01, 0x42, 0x3b, 0x01, 0xcb, 0xe6, - 0x01, 0xe5, 0xe8, 0xe6, 0x01, 0x42, 0x06, 0x14, 0xc4, 0xe6, 0x01, 0x05, - 0x48, 0x0b, 0x97, 0x01, 0xe9, 0xe1, 0xe6, 0x81, 0x8d, 0x01, 0x42, 0x13, - 0x01, 0xd8, 0xe6, 0x81, 0x4b, 0x42, 0xc3, 0x07, 0xd6, 0xe6, 0x01, 0xae, - 0x39, 0xef, 0xe7, 0xe6, 0x81, 0x30, 0x43, 0x1c, 0x3d, 0xd3, 0xe6, 0x01, - 0x42, 0x40, 0xbd, 0xdc, 0xe6, 0x01, 0x43, 0x2a, 0x08, 0xce, 0xe6, 0x01, - 0xf5, 0xe4, 0xe6, 0x81, 0x0c, 0x42, 0x26, 0x1d, 0xd9, 0xe6, 0x01, 0x42, - 0xb0, 0x47, 0xd7, 0xe6, 0x41, 0xe1, 0xeb, 0xe6, 0x01, 0xe5, 0xe2, 0xe6, - 0xc1, 0x00, 0xe1, 0xea, 0xe6, 0x41, 0xef, 0xec, 0xe6, 0x41, 0x42, 0x06, - 0x14, 0xc5, 0xe6, 0x01, 0xef, 0xcf, 0xe6, 0x41, 0x02, 0xd2, 0x00, 0x01, - 0xff, 0x42, 0x68, 0x03, 0xd4, 0xe6, 0x01, 0x42, 0x0b, 0x00, 0xda, 0xe6, - 0x01, 0xab, 0x18, 0x43, 0x14, 0x54, 0xc9, 0xe6, 0x01, 0x42, 0x9c, 0x01, - 0xd1, 0xe6, 0x01, 0x42, 0x1e, 0x00, 0xcc, 0xe6, 0x01, 0x42, 0xe2, 0x2f, - 0xc7, 0xe6, 0x41, 0x42, 0x0b, 0x00, 0xc2, 0xe6, 0x01, 0xef, 0xc0, 0xe6, - 0x01, 0x42, 0x26, 0x1d, 0xdd, 0xe6, 0x41, 0xe1, 0xe9, 0xe6, 0x41, 0x42, - 0x68, 0x03, 0xd5, 0xe6, 0x01, 0x42, 0x0b, 0x00, 0xdb, 0xe6, 0x01, 0xab, - 0x18, 0x43, 0x14, 0x54, 0xca, 0xe6, 0x01, 0x42, 0x9c, 0x01, 0xd2, 0xe6, - 0x01, 0x42, 0x1e, 0x00, 0xcd, 0xe6, 0x01, 0x42, 0xe2, 0x2f, 0xc8, 0xe6, - 0x41, 0x42, 0x0b, 0x00, 0xc3, 0xe6, 0x01, 0xef, 0xc1, 0xe6, 0x01, 0x42, - 0x26, 0x1d, 0xde, 0xe6, 0x41, 0xe1, 0xe0, 0xe6, 0x01, 0xe5, 0xe5, 0xe6, - 0x01, 0xeb, 0xf2, 0xe6, 0x01, 0xed, 0xf1, 0xe6, 0x01, 0xee, 0xf0, 0xe6, - 0x01, 0xf0, 0xf4, 0xe6, 0x01, 0xf4, 0xf3, 0xe6, 0x01, 0x42, 0xd6, 0x13, - 0xed, 0xe6, 0x41, 0x07, 0xec, 0x05, 0x91, 0x01, 0x05, 0x87, 0xe8, 0x80, - 0x01, 0x07, 0x5f, 0x16, 0x5c, 0x09, 0x08, 0xc0, 0x40, 0x06, 0x57, 0x39, - 0x01, 0xff, 0xa1, 0x23, 0xe5, 0xb5, 0xaa, 0x00, 0xe9, 0xb2, 0xaa, 0x80, - 0x16, 0xef, 0xb6, 0xaa, 0x00, 0xf5, 0xb4, 0xaa, 0xc0, 0x00, 0xe1, 0xba, - 0xaa, 0x00, 0xe5, 0xb3, 0xaa, 0xc0, 0x00, 0xe1, 0xb9, 0xaa, 0x40, 0xe1, - 0xb8, 0xaa, 0x40, 0xe1, 0xb1, 0xaa, 0x00, 0xed, 0xbe, 0xaa, 0x00, 0xee, - 0xbd, 0xaa, 0x00, 0x42, 0xd6, 0x13, 0xbb, 0xaa, 0x00, 0xf9, 0xbc, 0xaa, - 0x40, 0x42, 0xf1, 0x18, 0xbf, 0xaa, 0x00, 0x45, 0x6d, 0xe9, 0xc0, 0xaa, - 0x00, 0x44, 0xdd, 0xf2, 0xc2, 0xaa, 0x00, 0x43, 0x2a, 0x08, 0xc1, 0xaa, - 0x40, 0x46, 0xb2, 0xdc, 0xde, 0xaa, 0x00, 0x02, 0x4d, 0x03, 0x0c, 0x45, - 0x6d, 0xe9, 0xdc, 0xaa, 0x00, 0x43, 0xf1, 0x85, 0xdd, 0xaa, 0x40, 0x45, - 0x51, 0xe7, 0xdf, 0xaa, 0x00, 0xee, 0xdb, 0xaa, 0x40, 0x43, 0x1c, 0x01, - 0xb0, 0xaa, 0x00, 0x43, 0xae, 0x02, 0xb7, 0xaa, 0x40, 0x05, 0x48, 0x0b, - 0x93, 0x01, 0x04, 0x08, 0x05, 0x01, 0xff, 0x42, 0x5d, 0x00, 0x9a, 0xaa, - 0x00, 0xa3, 0x7c, 0x42, 0x3b, 0x01, 0x92, 0xaa, 0x00, 0x42, 0x68, 0x03, - 0xa0, 0xaa, 0x00, 0x42, 0x06, 0x14, 0x86, 0xaa, 0x00, 0x42, 0x0b, 0x00, - 0xac, 0xaa, 0x00, 0xab, 0x52, 0x42, 0x13, 0x01, 0xa8, 0xaa, 0x00, 0x42, - 0xc3, 0x07, 0xa2, 0xaa, 0x00, 0xae, 0x34, 0xef, 0xae, 0xaa, 0x00, 0xb0, - 0x24, 0x42, 0xd0, 0x00, 0xa6, 0xaa, 0x00, 0x42, 0x60, 0x03, 0x8e, 0xaa, - 0x00, 0xb4, 0x0c, 0x42, 0x26, 0x1d, 0xaa, 0xaa, 0x00, 0x42, 0xb0, 0x47, - 0xa4, 0xaa, 0x40, 0x42, 0x0b, 0x00, 0x96, 0xaa, 0x00, 0xef, 0x94, 0xaa, - 0x40, 0x42, 0x0b, 0x00, 0x9e, 0xaa, 0x00, 0xef, 0x9c, 0xaa, 0x40, 0x42, - 0x06, 0x14, 0x88, 0xaa, 0x00, 0xef, 0x98, 0xaa, 0x00, 0x42, 0xb0, 0x47, - 0x90, 0xaa, 0x40, 0xa8, 0x04, 0xef, 0x80, 0xaa, 0x40, 0x42, 0x0b, 0x00, - 0x84, 0xaa, 0x00, 0xef, 0x82, 0xaa, 0x40, 0x42, 0x0b, 0x00, 0x8c, 0xaa, - 0x00, 0xef, 0x8a, 0xaa, 0x40, 0x42, 0x5d, 0x00, 0x9b, 0xaa, 0x00, 0xa3, - 0x7c, 0x42, 0x3b, 0x01, 0x93, 0xaa, 0x00, 0x42, 0x68, 0x03, 0xa1, 0xaa, - 0x00, 0x42, 0x06, 0x14, 0x87, 0xaa, 0x00, 0x42, 0x0b, 0x00, 0xad, 0xaa, - 0x00, 0xab, 0x52, 0x42, 0x13, 0x01, 0xa9, 0xaa, 0x00, 0x42, 0xc3, 0x07, - 0xa3, 0xaa, 0x00, 0xae, 0x34, 0xef, 0xaf, 0xaa, 0x00, 0xb0, 0x24, 0x42, - 0xd0, 0x00, 0xa7, 0xaa, 0x00, 0x42, 0x60, 0x03, 0x8f, 0xaa, 0x00, 0xb4, - 0x0c, 0x42, 0x26, 0x1d, 0xab, 0xaa, 0x00, 0x42, 0xb0, 0x47, 0xa5, 0xaa, - 0x40, 0x42, 0x0b, 0x00, 0x97, 0xaa, 0x00, 0xef, 0x95, 0xaa, 0x40, 0x42, - 0x0b, 0x00, 0x9f, 0xaa, 0x00, 0xef, 0x9d, 0xaa, 0x40, 0x42, 0x06, 0x14, - 0x89, 0xaa, 0x00, 0xef, 0x99, 0xaa, 0x00, 0x42, 0xb0, 0x47, 0x91, 0xaa, - 0x40, 0xa8, 0x04, 0xef, 0x81, 0xaa, 0x40, 0x42, 0x0b, 0x00, 0x85, 0xaa, - 0x00, 0xef, 0x83, 0xaa, 0x40, 0x42, 0x0b, 0x00, 0x8d, 0xaa, 0x00, 0xef, - 0x8b, 0xaa, 0x40, 0x02, 0x13, 0x05, 0xe9, 0x05, 0x0b, 0x36, 0x9d, 0xa2, - 0x05, 0x07, 0xec, 0x05, 0xdd, 0x02, 0x05, 0x5a, 0x03, 0xac, 0x01, 0x0b, - 0x7c, 0xa3, 0x66, 0x0b, 0x55, 0x77, 0x01, 0xff, 0xe1, 0x61, 0x1a, 0x80, - 0x50, 0xe5, 0x6e, 0x1a, 0x00, 0xe9, 0x65, 0x1a, 0x80, 0x43, 0x47, 0x35, - 0xd3, 0x62, 0x1a, 0x00, 0xef, 0x6b, 0x1a, 0x80, 0x20, 0xb4, 0x12, 0xf5, - 0x69, 0x1a, 0xc0, 0x00, 0xe5, 0x67, 0x1a, 0x00, 0xf5, 0x6a, 0x1a, 0xc0, - 0x00, 0xe5, 0x68, 0x1a, 0x40, 0x46, 0x4d, 0xd6, 0x64, 0x1a, 0x00, 0x46, - 0x64, 0xdc, 0x72, 0x1a, 0x40, 0x02, 0x5a, 0x00, 0x08, 0xef, 0x70, 0x1a, - 0x00, 0xf9, 0x6d, 0x1a, 0x40, 0x45, 0x5c, 0x00, 0x73, 0x1a, 0x00, 0x45, - 0x20, 0x07, 0x6c, 0x1a, 0x40, 0xe9, 0x66, 0x1a, 0x40, 0xe1, 0x63, 0x1a, - 0x00, 0xe5, 0x6f, 0x1a, 0x00, 0xe9, 0x71, 0x1a, 0x40, 0x45, 0x12, 0x0b, - 0x98, 0x1a, 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x99, 0x1a, 0x00, 0x43, - 0x0e, 0x0b, 0x91, 0x1a, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, - 0x90, 0x1a, 0x40, 0x44, 0x25, 0x01, 0x93, 0x1a, 0x00, 0x42, 0x15, 0x02, - 0x92, 0x1a, 0x40, 0x44, 0xe5, 0x1d, 0x97, 0x1a, 0x00, 0x42, 0x1c, 0x26, - 0x96, 0x1a, 0x40, 0x43, 0xd2, 0x05, 0x95, 0x1a, 0x00, 0x43, 0xf6, 0x06, - 0x94, 0x1a, 0x40, 0x45, 0x03, 0xe5, 0xad, 0x1a, 0x00, 0x46, 0x1a, 0xdb, - 0xa5, 0x1a, 0x00, 0xa8, 0x91, 0x01, 0xab, 0x61, 0x04, 0xa9, 0x45, 0x44, - 0xb2, 0x36, 0x02, 0x40, 0x06, 0x19, 0x05, 0x06, 0x32, 0x0d, 0x45, 0x6f, - 0xec, 0xa0, 0x1a, 0xc0, 0x00, 0x44, 0x39, 0xf3, 0xa1, 0x1a, 0x40, 0xd1, - 0x75, 0x1a, 0x00, 0xd2, 0x76, 0x1a, 0x40, 0x43, 0x1c, 0x8e, 0x60, 0x1a, - 0x00, 0x45, 0x70, 0xeb, 0xaa, 0x1a, 0x80, 0x06, 0x43, 0x41, 0x1a, 0xa2, - 0x1a, 0x40, 0x43, 0xf0, 0x75, 0xab, 0x1a, 0x40, 0x46, 0x82, 0xd9, 0x7a, - 0x1a, 0x00, 0x54, 0x37, 0x42, 0xa6, 0x1a, 0x40, 0x44, 0xe7, 0xa7, 0x74, - 0x1a, 0x80, 0x0c, 0x43, 0xf1, 0x85, 0x7b, 0x1a, 0x00, 0x45, 0xa6, 0xec, - 0xa7, 0x1a, 0x40, 0x44, 0x02, 0x44, 0x58, 0x1a, 0x40, 0x43, 0x80, 0x12, - 0xa8, 0x1a, 0x80, 0x21, 0x43, 0x6d, 0x54, 0xa3, 0x1a, 0x00, 0x04, 0x81, - 0xf0, 0x01, 0xff, 0x06, 0x05, 0x32, 0x06, 0x4a, 0xd0, 0xa6, 0x7c, 0x1a, - 0x40, 0xd3, 0x77, 0x1a, 0x00, 0xd4, 0x78, 0x1a, 0x00, 0xd5, 0x79, 0x1a, - 0x40, 0x43, 0xf0, 0x75, 0xa9, 0x1a, 0x40, 0x43, 0x1c, 0x01, 0xac, 0x1a, - 0x00, 0x42, 0x5f, 0x69, 0xa4, 0x1a, 0x40, 0xe1, 0x4b, 0x1a, 0x00, 0x42, - 0x16, 0x00, 0x37, 0x1a, 0x00, 0x42, 0xf0, 0x10, 0x2f, 0x1a, 0x00, 0x42, - 0x27, 0x01, 0x51, 0x1a, 0x00, 0x48, 0xa1, 0xc6, 0x54, 0x1a, 0x00, 0x05, - 0x48, 0x0b, 0xbf, 0x01, 0xe9, 0x4d, 0x1a, 0x80, 0xb5, 0x01, 0xac, 0x46, - 0x42, 0x6c, 0x00, 0x3e, 0x1a, 0x00, 0xae, 0x2e, 0x42, 0xcd, 0x02, 0x52, - 0x1a, 0x00, 0xb2, 0x0f, 0xf5, 0x4f, 0x1a, 0x80, 0x06, 0x42, 0xa9, 0x01, - 0x45, 0x1a, 0x40, 0xf5, 0x50, 0x1a, 0x40, 0xe1, 0x41, 0x1a, 0x80, 0x06, - 0x42, 0xd6, 0x13, 0x42, 0x1a, 0x40, 0x42, 0x2a, 0x05, 0x31, 0x1a, 0x00, - 0x42, 0x12, 0x00, 0x2d, 0x1a, 0x40, 0xe1, 0x36, 0x1a, 0x00, 0x42, 0x24, - 0x02, 0x26, 0x1a, 0x00, 0x42, 0xbe, 0x22, 0x2c, 0x1a, 0x40, 0xe1, 0x43, - 0x1a, 0x80, 0x64, 0x42, 0x74, 0x00, 0x4a, 0x1a, 0x00, 0x03, 0xd1, 0x00, - 0x06, 0x42, 0xd6, 0x13, 0x44, 0x1a, 0x40, 0xa3, 0x48, 0x42, 0x0c, 0x08, - 0x3c, 0x1a, 0x00, 0x42, 0x22, 0x00, 0x4c, 0x1a, 0x00, 0xab, 0x2a, 0xb0, - 0x1e, 0x45, 0xdc, 0x42, 0x30, 0x1a, 0x00, 0x42, 0x40, 0x06, 0x2a, 0x1a, - 0x00, 0xb4, 0x06, 0x42, 0xbe, 0x22, 0x3f, 0x1a, 0x40, 0xe1, 0x34, 0x1a, - 0x00, 0x42, 0x22, 0x00, 0x35, 0x1a, 0x40, 0xe1, 0x3b, 0x1a, 0x00, 0x42, - 0x22, 0x00, 0x3d, 0x1a, 0x40, 0xe1, 0x23, 0x1a, 0x00, 0x42, 0x22, 0x00, - 0x25, 0x1a, 0x00, 0x42, 0x08, 0x27, 0x24, 0x1a, 0x40, 0xe1, 0x29, 0x1a, - 0x00, 0x42, 0x22, 0x00, 0x2b, 0x1a, 0x40, 0xe5, 0x53, 0x1a, 0x40, 0xe9, - 0x4e, 0x1a, 0x40, 0xa3, 0x54, 0x42, 0x0c, 0x08, 0x3a, 0x1a, 0x00, 0x42, - 0x22, 0x00, 0x49, 0x1a, 0x00, 0xab, 0x36, 0xb0, 0x2a, 0x45, 0xdc, 0x42, - 0x2e, 0x1a, 0x00, 0xb3, 0x12, 0xb4, 0x06, 0x42, 0xbe, 0x22, 0x40, 0x1a, - 0x40, 0xe1, 0x32, 0x1a, 0x00, 0x42, 0x22, 0x00, 0x33, 0x1a, 0x40, 0xe1, - 0x48, 0x1a, 0x00, 0x42, 0x22, 0x00, 0x46, 0x1a, 0x00, 0x42, 0x40, 0x06, - 0x47, 0x1a, 0x40, 0xe1, 0x38, 0x1a, 0x00, 0x42, 0x22, 0x00, 0x39, 0x1a, - 0x40, 0xe1, 0x20, 0x1a, 0x00, 0x42, 0x22, 0x00, 0x21, 0x1a, 0x00, 0x42, - 0x08, 0x27, 0x22, 0x1a, 0x40, 0xe1, 0x27, 0x1a, 0x00, 0x42, 0x22, 0x00, - 0x28, 0x1a, 0x40, 0x45, 0x12, 0x0b, 0x88, 0x1a, 0x00, 0xa6, 0x2e, 0x44, - 0xea, 0x2a, 0x89, 0x1a, 0x00, 0x43, 0x0e, 0x0b, 0x81, 0x1a, 0x00, 0xb3, - 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x80, 0x1a, 0x40, 0x44, 0x25, 0x01, - 0x83, 0x1a, 0x00, 0x42, 0x15, 0x02, 0x82, 0x1a, 0x40, 0x44, 0xe5, 0x1d, - 0x87, 0x1a, 0x00, 0x42, 0x1c, 0x26, 0x86, 0x1a, 0x40, 0x43, 0xd2, 0x05, - 0x85, 0x1a, 0x00, 0x43, 0xf6, 0x06, 0x84, 0x1a, 0x40, 0x59, 0xe5, 0x24, - 0x7f, 0x1a, 0x00, 0x0d, 0x5a, 0x33, 0x01, 0xff, 0x42, 0x16, 0x00, 0x5d, - 0x1a, 0x00, 0x49, 0x09, 0xb9, 0x59, 0x1a, 0x00, 0x54, 0xd7, 0x42, 0x5b, - 0x1a, 0x00, 0xac, 0x1d, 0xad, 0x06, 0x42, 0x40, 0x06, 0x5e, 0x1a, 0x40, - 0xe1, 0x5c, 0x1a, 0x00, 0x06, 0x68, 0x33, 0x01, 0xff, 0x42, 0x74, 0x00, - 0x56, 0x1a, 0x00, 0x42, 0x71, 0x00, 0x55, 0x1a, 0x40, 0x4a, 0x5c, 0xa7, - 0x57, 0x1a, 0x00, 0x45, 0xab, 0x35, 0x5a, 0x1a, 0x40, 0xe1, 0x63, 0x19, - 0x80, 0xb0, 0x01, 0xe5, 0x6b, 0x19, 0x80, 0xa2, 0x01, 0x42, 0x0c, 0x08, - 0x5c, 0x19, 0x00, 0x42, 0x22, 0x00, 0x5e, 0x19, 0x00, 0xe9, 0x64, 0x19, - 0x00, 0xab, 0x85, 0x01, 0x42, 0x74, 0x00, 0x58, 0x19, 0x00, 0x42, 0x6c, - 0x00, 0x5b, 0x19, 0x00, 0xae, 0x6d, 0xef, 0x69, 0x19, 0x80, 0x64, 0xb0, - 0x58, 0x42, 0x43, 0x14, 0x5f, 0x19, 0x00, 0x42, 0x40, 0x06, 0x54, 0x19, - 0x00, 0xb4, 0x1b, 0xf5, 0x67, 0x19, 0x80, 0x12, 0x42, 0xf5, 0x0a, 0x5d, - 0x19, 0x00, 0x42, 0x08, 0x27, 0x51, 0x19, 0x00, 0x42, 0xbe, 0x22, 0x55, - 0x19, 0x40, 0xe5, 0x6a, 0x19, 0x40, 0xe1, 0x56, 0x19, 0x00, 0x42, 0x22, - 0x00, 0x57, 0x19, 0x00, 0x04, 0x02, 0x20, 0x0d, 0xb3, 0x01, 0xff, 0xe1, - 0x53, 0x19, 0x00, 0x42, 0x22, 0x00, 0x61, 0x19, 0x40, 0xd2, 0x70, 0x19, - 0x00, 0xd3, 0x71, 0x19, 0x00, 0xd4, 0x72, 0x19, 0x00, 0xd5, 0x73, 0x19, - 0x00, 0xd6, 0x74, 0x19, 0x40, 0xe1, 0x59, 0x19, 0x00, 0x42, 0x22, 0x00, - 0x5a, 0x19, 0x40, 0xef, 0x68, 0x19, 0x40, 0xe1, 0x62, 0x19, 0x00, 0x42, - 0x24, 0x02, 0x52, 0x19, 0x40, 0xe1, 0x50, 0x19, 0x00, 0x42, 0x22, 0x00, - 0x60, 0x19, 0x40, 0xe5, 0x65, 0x19, 0x00, 0xe8, 0x66, 0x19, 0x40, 0xe9, - 0x6d, 0x19, 0x00, 0x42, 0xd6, 0x13, 0x6c, 0x19, 0x40, 0x80, 0x82, 0x02, - 0x05, 0x59, 0xe4, 0x70, 0x06, 0x30, 0xda, 0x01, 0xff, 0x07, 0xec, 0x05, - 0x0d, 0x0b, 0x55, 0x77, 0x01, 0xff, 0xe9, 0x72, 0x17, 0x00, 0xf5, 0x73, - 0x17, 0x40, 0xe1, 0x60, 0x17, 0x00, 0x42, 0x16, 0x00, 0x6a, 0x17, 0x00, - 0x42, 0xf0, 0x10, 0x67, 0x17, 0x00, 0x42, 0x24, 0x02, 0x64, 0x17, 0x00, - 0xe9, 0x61, 0x17, 0x00, 0x42, 0x1b, 0x02, 0x63, 0x17, 0x00, 0x42, 0x74, - 0x00, 0x6e, 0x17, 0x00, 0x42, 0x6c, 0x00, 0x6b, 0x17, 0x00, 0xae, 0x22, - 0x42, 0xbb, 0x09, 0x69, 0x17, 0x00, 0x42, 0x40, 0x06, 0x70, 0x17, 0x00, - 0x42, 0x12, 0x00, 0x66, 0x17, 0x00, 0xf5, 0x62, 0x17, 0x00, 0x42, 0xa9, - 0x01, 0x6f, 0x17, 0x00, 0x42, 0xbe, 0x22, 0x6c, 0x17, 0x40, 0xe1, 0x68, - 0x17, 0x00, 0x42, 0x24, 0x02, 0x65, 0x17, 0x40, 0x07, 0xec, 0x05, 0x1d, - 0x05, 0x5a, 0x03, 0x0d, 0x0b, 0x55, 0x77, 0x01, 0xff, 0xe9, 0x12, 0x17, - 0x00, 0xf5, 0x13, 0x17, 0x40, 0x48, 0xd0, 0x88, 0x15, 0x17, 0x00, 0x46, - 0xe5, 0x23, 0x14, 0x17, 0x40, 0xe1, 0x00, 0x17, 0x80, 0x62, 0x42, 0x16, - 0x00, 0x0a, 0x17, 0x00, 0x42, 0xf0, 0x10, 0x07, 0x17, 0x00, 0x42, 0x24, - 0x02, 0x04, 0x17, 0x00, 0x42, 0x22, 0x00, 0x11, 0x17, 0x00, 0xe9, 0x01, - 0x17, 0x00, 0x42, 0x1b, 0x02, 0x03, 0x17, 0x00, 0x42, 0x74, 0x00, 0x0e, - 0x17, 0x00, 0x42, 0x6c, 0x00, 0x0b, 0x17, 0x00, 0xae, 0x28, 0x42, 0xbb, - 0x09, 0x09, 0x17, 0x00, 0x42, 0x71, 0x00, 0x0d, 0x17, 0x00, 0x42, 0x40, - 0x06, 0x10, 0x17, 0x00, 0x42, 0x12, 0x00, 0x06, 0x17, 0x00, 0xf5, 0x02, - 0x17, 0x00, 0x42, 0xa9, 0x01, 0x0f, 0x17, 0x00, 0x42, 0xbe, 0x22, 0x0c, - 0x17, 0x40, 0xe1, 0x08, 0x17, 0x00, 0x42, 0x24, 0x02, 0x05, 0x17, 0x40, - 0x49, 0x97, 0xbe, 0x1f, 0x17, 0x40, 0xa1, 0x82, 0x04, 0xa3, 0xe1, 0x03, - 0xa4, 0x92, 0x03, 0xa5, 0x83, 0x03, 0x49, 0x81, 0x16, 0x2e, 0x00, 0x0e, - 0x02, 0x87, 0x00, 0xec, 0x02, 0x4c, 0xdc, 0x8f, 0x2d, 0x00, 0x0e, 0xac, - 0x63, 0x4b, 0x64, 0xa0, 0x23, 0x00, 0x0e, 0xb0, 0x4f, 0x02, 0x7c, 0x00, - 0x3f, 0xb2, 0x20, 0xb3, 0x0c, 0x45, 0x37, 0x23, 0x7e, 0x00, 0x0e, 0x4d, - 0xcd, 0x0b, 0x7c, 0x00, 0x4e, 0x48, 0xe1, 0x59, 0x3b, 0x00, 0x0e, 0x46, - 0x6b, 0x31, 0x2f, 0x00, 0x0e, 0x44, 0xd8, 0x4c, 0x20, 0x00, 0x4e, 0x4e, - 0x6e, 0x72, 0x5c, 0x00, 0x0e, 0x05, 0xc9, 0x00, 0x01, 0xff, 0x4d, 0x72, - 0x0b, 0x7d, 0x00, 0x0e, 0x4b, 0xda, 0x21, 0x29, 0x00, 0x0e, 0x4e, 0xe3, - 0x26, 0x5d, 0x00, 0x4e, 0x4b, 0xc3, 0x34, 0x3f, 0x00, 0x0e, 0x4c, 0x1b, - 0x05, 0x22, 0x00, 0x4e, 0x4b, 0x02, 0x9c, 0x25, 0x00, 0x0e, 0x48, 0xe7, - 0x71, 0x2b, 0x00, 0x4e, 0x05, 0xdf, 0x05, 0x24, 0xa5, 0x06, 0x47, 0x8b, - 0x8a, 0x5f, 0x00, 0x4e, 0x03, 0xc5, 0x00, 0x06, 0x4c, 0x88, 0x95, 0x3c, - 0x00, 0x4e, 0x4d, 0x72, 0x0b, 0x7b, 0x00, 0x0e, 0x4b, 0xda, 0x21, 0x28, - 0x00, 0x0e, 0x4e, 0xe3, 0x26, 0x5b, 0x00, 0x4e, 0x0f, 0xe4, 0x05, 0x6d, - 0x0d, 0x76, 0x08, 0x01, 0xff, 0xe1, 0x61, 0x00, 0x0e, 0xe2, 0x62, 0x00, - 0x0e, 0xe3, 0x63, 0x00, 0x0e, 0xe4, 0x64, 0x00, 0x0e, 0xe5, 0x65, 0x00, - 0x0e, 0xe6, 0x66, 0x00, 0x0e, 0xe7, 0x67, 0x00, 0x0e, 0xe8, 0x68, 0x00, - 0x0e, 0xe9, 0x69, 0x00, 0x0e, 0xea, 0x6a, 0x00, 0x0e, 0xeb, 0x6b, 0x00, - 0x0e, 0xec, 0x6c, 0x00, 0x0e, 0xed, 0x6d, 0x00, 0x0e, 0xee, 0x6e, 0x00, - 0x0e, 0xef, 0x6f, 0x00, 0x0e, 0xf0, 0x70, 0x00, 0x0e, 0xf1, 0x71, 0x00, - 0x0e, 0xf2, 0x72, 0x00, 0x0e, 0xf3, 0x73, 0x00, 0x0e, 0xf4, 0x74, 0x00, - 0x0e, 0xf5, 0x75, 0x00, 0x0e, 0xf6, 0x76, 0x00, 0x0e, 0xf7, 0x77, 0x00, - 0x0e, 0xf8, 0x78, 0x00, 0x0e, 0xf9, 0x79, 0x00, 0x0e, 0xfa, 0x7a, 0x00, - 0x4e, 0xe1, 0x41, 0x00, 0x0e, 0xe2, 0x42, 0x00, 0x0e, 0xe3, 0x43, 0x00, - 0x0e, 0xe4, 0x44, 0x00, 0x0e, 0xe5, 0x45, 0x00, 0x0e, 0xe6, 0x46, 0x00, - 0x0e, 0xe7, 0x47, 0x00, 0x0e, 0xe8, 0x48, 0x00, 0x0e, 0xe9, 0x49, 0x00, - 0x0e, 0xea, 0x4a, 0x00, 0x0e, 0xeb, 0x4b, 0x00, 0x0e, 0xec, 0x4c, 0x00, - 0x0e, 0xed, 0x4d, 0x00, 0x0e, 0xee, 0x4e, 0x00, 0x0e, 0xef, 0x4f, 0x00, - 0x0e, 0xf0, 0x50, 0x00, 0x0e, 0xf1, 0x51, 0x00, 0x0e, 0xf2, 0x52, 0x00, - 0x0e, 0xf3, 0x53, 0x00, 0x0e, 0xf4, 0x54, 0x00, 0x0e, 0xf5, 0x55, 0x00, - 0x0e, 0xf6, 0x56, 0x00, 0x0e, 0xf7, 0x57, 0x00, 0x0e, 0xf8, 0x58, 0x00, - 0x0e, 0xf9, 0x59, 0x00, 0x0e, 0xfa, 0x5a, 0x00, 0x4e, 0x4a, 0x19, 0x23, - 0x60, 0x00, 0x0e, 0x4f, 0x6b, 0x5a, 0x3e, 0x00, 0x4e, 0x4a, 0x49, 0x13, - 0x3d, 0x00, 0x0e, 0x4f, 0xae, 0x00, 0x21, 0x00, 0x4e, 0x05, 0xf0, 0x06, - 0x06, 0x4a, 0x32, 0x9b, 0x24, 0x00, 0x4e, 0x45, 0x12, 0x0b, 0x38, 0x00, - 0x0e, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x39, 0x00, 0x0e, 0x43, 0x0e, 0x0b, - 0x31, 0x00, 0x0e, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x30, 0x00, - 0x4e, 0x44, 0x25, 0x01, 0x33, 0x00, 0x0e, 0x42, 0x15, 0x02, 0x32, 0x00, - 0x4e, 0x44, 0xe5, 0x1d, 0x37, 0x00, 0x0e, 0x42, 0x1c, 0x26, 0x36, 0x00, - 0x4e, 0x43, 0xd2, 0x05, 0x35, 0x00, 0x0e, 0x43, 0xf6, 0x06, 0x34, 0x00, - 0x4e, 0x50, 0xd0, 0x04, 0x5e, 0x00, 0x0e, 0xaf, 0x01, 0xff, 0x43, 0xd7, - 0x02, 0x3a, 0x00, 0x0e, 0x02, 0x15, 0x05, 0x01, 0xff, 0xe1, 0x2c, 0x00, - 0x0e, 0x49, 0xa6, 0xb8, 0x40, 0x00, 0x4e, 0x48, 0x2e, 0x3e, 0x26, 0x00, - 0x0e, 0x49, 0x7d, 0x36, 0x27, 0x00, 0x0e, 0x47, 0x3d, 0x0d, 0x2a, 0x00, - 0x4e, 0x59, 0x81, 0x24, 0xd3, 0xf3, 0x41, 0x43, 0xb3, 0x77, 0x96, 0xf9, - 0x01, 0x45, 0x6d, 0x4a, 0x55, 0xf4, 0x41, 0x4c, 0x38, 0x8b, 0xcc, 0x29, - 0x00, 0xa1, 0xe2, 0x85, 0x01, 0xa3, 0xc0, 0x84, 0x01, 0xa5, 0xea, 0x7f, - 0x42, 0xc8, 0x27, 0x99, 0x00, 0x00, 0xa8, 0xf6, 0x75, 0xe9, 0x0f, 0x00, - 0x80, 0xab, 0x3e, 0xab, 0xfe, 0x3d, 0xac, 0xd4, 0x3c, 0xad, 0x9e, 0x38, - 0xae, 0xdc, 0x37, 0xef, 0x0e, 0x00, 0x80, 0xf5, 0x2c, 0xf0, 0x20, 0x00, - 0x80, 0xf7, 0x2a, 0x02, 0x7c, 0x00, 0xe5, 0x18, 0xb3, 0xd6, 0x18, 0xf4, + 0x99, 0x01, 0xff, 0xd0, 0x4d, 0x8a, 0x01, 0xd1, 0x4e, 0x8a, 0x01, 0xd2, + 0x4f, 0x8a, 0x01, 0xd3, 0x50, 0x8a, 0x01, 0xd4, 0x51, 0x8a, 0x01, 0xd5, + 0x52, 0x8a, 0x01, 0xd6, 0x53, 0x8a, 0x01, 0xd7, 0x54, 0x8a, 0x01, 0xd8, + 0x55, 0x8a, 0x01, 0xd9, 0x56, 0x8a, 0x41, 0xd0, 0x43, 0x8a, 0x01, 0xd1, + 0x44, 0x8a, 0x01, 0xd2, 0x45, 0x8a, 0x01, 0xd3, 0x46, 0x8a, 0x01, 0xd4, + 0x47, 0x8a, 0x01, 0xd5, 0x48, 0x8a, 0x01, 0xd6, 0x49, 0x8a, 0x01, 0xd7, + 0x4a, 0x8a, 0x01, 0xd8, 0x4b, 0x8a, 0x01, 0xd9, 0x4c, 0x8a, 0x41, 0xd0, + 0x39, 0x8a, 0x01, 0xd1, 0x3a, 0x8a, 0x01, 0xd2, 0x3b, 0x8a, 0x01, 0xd3, + 0x3c, 0x8a, 0x01, 0xd4, 0x3d, 0x8a, 0x01, 0xd5, 0x3e, 0x8a, 0x01, 0xd6, + 0x3f, 0x8a, 0x01, 0xd7, 0x40, 0x8a, 0x01, 0xd8, 0x41, 0x8a, 0x01, 0xd9, + 0x42, 0x8a, 0x41, 0xd0, 0x2f, 0x8a, 0x01, 0xd1, 0x30, 0x8a, 0x01, 0xd2, + 0x31, 0x8a, 0x01, 0xd3, 0x32, 0x8a, 0x01, 0xd4, 0x33, 0x8a, 0x01, 0xd5, + 0x34, 0x8a, 0x01, 0xd6, 0x35, 0x8a, 0x01, 0xd7, 0x36, 0x8a, 0x01, 0xd8, + 0x37, 0x8a, 0x01, 0xd9, 0x38, 0x8a, 0x41, 0xd0, 0x25, 0x8a, 0x01, 0xd1, + 0x26, 0x8a, 0x01, 0xd2, 0x27, 0x8a, 0x01, 0xd3, 0x28, 0x8a, 0x01, 0xd4, + 0x29, 0x8a, 0x01, 0xd5, 0x2a, 0x8a, 0x01, 0xd6, 0x2b, 0x8a, 0x01, 0xd7, + 0x2c, 0x8a, 0x01, 0xd8, 0x2d, 0x8a, 0x01, 0xd9, 0x2e, 0x8a, 0x41, 0xd0, + 0x1b, 0x8a, 0x01, 0xd1, 0x1c, 0x8a, 0x01, 0xd2, 0x1d, 0x8a, 0x01, 0xd3, + 0x1e, 0x8a, 0x01, 0xd4, 0x1f, 0x8a, 0x01, 0xd5, 0x20, 0x8a, 0x01, 0xd6, + 0x21, 0x8a, 0x01, 0xd7, 0x22, 0x8a, 0x01, 0xd8, 0x23, 0x8a, 0x01, 0xd9, + 0x24, 0x8a, 0x41, 0xd0, 0x11, 0x8a, 0x01, 0xd1, 0x12, 0x8a, 0x01, 0xd2, + 0x13, 0x8a, 0x01, 0xd3, 0x14, 0x8a, 0x01, 0xd4, 0x15, 0x8a, 0x01, 0xd5, + 0x16, 0x8a, 0x01, 0xd6, 0x17, 0x8a, 0x01, 0xd7, 0x18, 0x8a, 0x01, 0xd8, + 0x19, 0x8a, 0x01, 0xd9, 0x1a, 0x8a, 0x41, 0xd0, 0x07, 0x8a, 0x01, 0xd1, + 0x08, 0x8a, 0x01, 0xd2, 0x09, 0x8a, 0x01, 0xd3, 0x0a, 0x8a, 0x01, 0xd4, + 0x0b, 0x8a, 0x01, 0xd5, 0x0c, 0x8a, 0x01, 0xd6, 0x0d, 0x8a, 0x01, 0xd7, + 0x0e, 0x8a, 0x01, 0xd8, 0x0f, 0x8a, 0x01, 0xd9, 0x10, 0x8a, 0x41, 0xd0, + 0xfd, 0x89, 0x01, 0xd1, 0xfe, 0x89, 0x01, 0xd2, 0xff, 0x89, 0x01, 0xd3, + 0x00, 0x8a, 0x01, 0xd4, 0x01, 0x8a, 0x01, 0xd5, 0x02, 0x8a, 0x01, 0xd6, + 0x03, 0x8a, 0x01, 0xd7, 0x04, 0x8a, 0x01, 0xd8, 0x05, 0x8a, 0x01, 0xd9, + 0x06, 0x8a, 0x41, 0xd0, 0xf3, 0x89, 0x01, 0xd1, 0xf4, 0x89, 0x01, 0xd2, + 0xf5, 0x89, 0x01, 0xd3, 0xf6, 0x89, 0x01, 0xd4, 0xf7, 0x89, 0x01, 0xd5, + 0xf8, 0x89, 0x01, 0xd6, 0xf9, 0x89, 0x01, 0xd7, 0xfa, 0x89, 0x01, 0xd8, + 0xfb, 0x89, 0x01, 0xd9, 0xfc, 0x89, 0x41, 0x90, 0x80, 0x03, 0x91, 0xd5, + 0x02, 0x92, 0xaa, 0x02, 0x93, 0xff, 0x01, 0x94, 0xd4, 0x01, 0x95, 0xa9, + 0x01, 0x96, 0x7f, 0x97, 0x55, 0x98, 0x2b, 0x99, 0x01, 0xff, 0xd0, 0xe9, + 0x89, 0x01, 0xd1, 0xea, 0x89, 0x01, 0xd2, 0xeb, 0x89, 0x01, 0xd3, 0xec, + 0x89, 0x01, 0xd4, 0xed, 0x89, 0x01, 0xd5, 0xee, 0x89, 0x01, 0xd6, 0xef, + 0x89, 0x01, 0xd7, 0xf0, 0x89, 0x01, 0xd8, 0xf1, 0x89, 0x01, 0xd9, 0xf2, + 0x89, 0x41, 0xd0, 0xdf, 0x89, 0x01, 0xd1, 0xe0, 0x89, 0x01, 0xd2, 0xe1, + 0x89, 0x01, 0xd3, 0xe2, 0x89, 0x01, 0xd4, 0xe3, 0x89, 0x01, 0xd5, 0xe4, + 0x89, 0x01, 0xd6, 0xe5, 0x89, 0x01, 0xd7, 0xe6, 0x89, 0x01, 0xd8, 0xe7, + 0x89, 0x01, 0xd9, 0xe8, 0x89, 0x41, 0xd0, 0xd5, 0x89, 0x01, 0xd1, 0xd6, + 0x89, 0x01, 0xd2, 0xd7, 0x89, 0x01, 0xd3, 0xd8, 0x89, 0x01, 0xd4, 0xd9, + 0x89, 0x01, 0xd5, 0xda, 0x89, 0x01, 0xd6, 0xdb, 0x89, 0x01, 0xd7, 0xdc, + 0x89, 0x01, 0xd8, 0xdd, 0x89, 0x01, 0xd9, 0xde, 0x89, 0x41, 0xd0, 0xcb, + 0x89, 0x01, 0xd1, 0xcc, 0x89, 0x01, 0xd2, 0xcd, 0x89, 0x01, 0xd3, 0xce, + 0x89, 0x01, 0xd4, 0xcf, 0x89, 0x01, 0xd5, 0xd0, 0x89, 0x01, 0xd6, 0xd1, + 0x89, 0x01, 0xd7, 0xd2, 0x89, 0x01, 0xd8, 0xd3, 0x89, 0x01, 0xd9, 0xd4, + 0x89, 0x41, 0xd0, 0xc1, 0x89, 0x01, 0xd1, 0xc2, 0x89, 0x01, 0xd2, 0xc3, + 0x89, 0x01, 0xd3, 0xc4, 0x89, 0x01, 0xd4, 0xc5, 0x89, 0x01, 0xd5, 0xc6, + 0x89, 0x01, 0xd6, 0xc7, 0x89, 0x01, 0xd7, 0xc8, 0x89, 0x01, 0xd8, 0xc9, + 0x89, 0x01, 0xd9, 0xca, 0x89, 0x41, 0xd0, 0xb7, 0x89, 0x01, 0xd1, 0xb8, + 0x89, 0x01, 0xd2, 0xb9, 0x89, 0x01, 0xd3, 0xba, 0x89, 0x01, 0xd4, 0xbb, + 0x89, 0x01, 0xd5, 0xbc, 0x89, 0x01, 0xd6, 0xbd, 0x89, 0x01, 0xd7, 0xbe, + 0x89, 0x01, 0xd8, 0xbf, 0x89, 0x01, 0xd9, 0xc0, 0x89, 0x41, 0xd0, 0xad, + 0x89, 0x01, 0xd1, 0xae, 0x89, 0x01, 0xd2, 0xaf, 0x89, 0x01, 0xd3, 0xb0, + 0x89, 0x01, 0xd4, 0xb1, 0x89, 0x01, 0xd5, 0xb2, 0x89, 0x01, 0xd6, 0xb3, + 0x89, 0x01, 0xd7, 0xb4, 0x89, 0x01, 0xd8, 0xb5, 0x89, 0x01, 0xd9, 0xb6, + 0x89, 0x41, 0xd0, 0xa3, 0x89, 0x01, 0xd1, 0xa4, 0x89, 0x01, 0xd2, 0xa5, + 0x89, 0x01, 0xd3, 0xa6, 0x89, 0x01, 0xd4, 0xa7, 0x89, 0x01, 0xd5, 0xa8, + 0x89, 0x01, 0xd6, 0xa9, 0x89, 0x01, 0xd7, 0xaa, 0x89, 0x01, 0xd8, 0xab, + 0x89, 0x01, 0xd9, 0xac, 0x89, 0x41, 0xd0, 0x99, 0x89, 0x01, 0xd1, 0x9a, + 0x89, 0x01, 0xd2, 0x9b, 0x89, 0x01, 0xd3, 0x9c, 0x89, 0x01, 0xd4, 0x9d, + 0x89, 0x01, 0xd5, 0x9e, 0x89, 0x01, 0xd6, 0x9f, 0x89, 0x01, 0xd7, 0xa0, + 0x89, 0x01, 0xd8, 0xa1, 0x89, 0x01, 0xd9, 0xa2, 0x89, 0x41, 0xd0, 0x8f, + 0x89, 0x01, 0xd1, 0x90, 0x89, 0x01, 0xd2, 0x91, 0x89, 0x01, 0xd3, 0x92, + 0x89, 0x01, 0xd4, 0x93, 0x89, 0x01, 0xd5, 0x94, 0x89, 0x01, 0xd6, 0x95, + 0x89, 0x01, 0xd7, 0x96, 0x89, 0x01, 0xd8, 0x97, 0x89, 0x01, 0xd9, 0x98, + 0x89, 0x41, 0x90, 0x80, 0x03, 0x91, 0xd5, 0x02, 0x92, 0xaa, 0x02, 0x93, + 0xff, 0x01, 0x94, 0xd4, 0x01, 0x95, 0xa9, 0x01, 0x96, 0x7f, 0x97, 0x55, + 0x98, 0x2b, 0x99, 0x01, 0xff, 0xd0, 0x85, 0x89, 0x01, 0xd1, 0x86, 0x89, + 0x01, 0xd2, 0x87, 0x89, 0x01, 0xd3, 0x88, 0x89, 0x01, 0xd4, 0x89, 0x89, + 0x01, 0xd5, 0x8a, 0x89, 0x01, 0xd6, 0x8b, 0x89, 0x01, 0xd7, 0x8c, 0x89, + 0x01, 0xd8, 0x8d, 0x89, 0x01, 0xd9, 0x8e, 0x89, 0x41, 0xd0, 0x7b, 0x89, + 0x01, 0xd1, 0x7c, 0x89, 0x01, 0xd2, 0x7d, 0x89, 0x01, 0xd3, 0x7e, 0x89, + 0x01, 0xd4, 0x7f, 0x89, 0x01, 0xd5, 0x80, 0x89, 0x01, 0xd6, 0x81, 0x89, + 0x01, 0xd7, 0x82, 0x89, 0x01, 0xd8, 0x83, 0x89, 0x01, 0xd9, 0x84, 0x89, + 0x41, 0xd0, 0x71, 0x89, 0x01, 0xd1, 0x72, 0x89, 0x01, 0xd2, 0x73, 0x89, + 0x01, 0xd3, 0x74, 0x89, 0x01, 0xd4, 0x75, 0x89, 0x01, 0xd5, 0x76, 0x89, + 0x01, 0xd6, 0x77, 0x89, 0x01, 0xd7, 0x78, 0x89, 0x01, 0xd8, 0x79, 0x89, + 0x01, 0xd9, 0x7a, 0x89, 0x41, 0xd0, 0x67, 0x89, 0x01, 0xd1, 0x68, 0x89, + 0x01, 0xd2, 0x69, 0x89, 0x01, 0xd3, 0x6a, 0x89, 0x01, 0xd4, 0x6b, 0x89, + 0x01, 0xd5, 0x6c, 0x89, 0x01, 0xd6, 0x6d, 0x89, 0x01, 0xd7, 0x6e, 0x89, + 0x01, 0xd8, 0x6f, 0x89, 0x01, 0xd9, 0x70, 0x89, 0x41, 0xd0, 0x5d, 0x89, + 0x01, 0xd1, 0x5e, 0x89, 0x01, 0xd2, 0x5f, 0x89, 0x01, 0xd3, 0x60, 0x89, + 0x01, 0xd4, 0x61, 0x89, 0x01, 0xd5, 0x62, 0x89, 0x01, 0xd6, 0x63, 0x89, + 0x01, 0xd7, 0x64, 0x89, 0x01, 0xd8, 0x65, 0x89, 0x01, 0xd9, 0x66, 0x89, + 0x41, 0xd0, 0x53, 0x89, 0x01, 0xd1, 0x54, 0x89, 0x01, 0xd2, 0x55, 0x89, + 0x01, 0xd3, 0x56, 0x89, 0x01, 0xd4, 0x57, 0x89, 0x01, 0xd5, 0x58, 0x89, + 0x01, 0xd6, 0x59, 0x89, 0x01, 0xd7, 0x5a, 0x89, 0x01, 0xd8, 0x5b, 0x89, + 0x01, 0xd9, 0x5c, 0x89, 0x41, 0xd0, 0x49, 0x89, 0x01, 0xd1, 0x4a, 0x89, + 0x01, 0xd2, 0x4b, 0x89, 0x01, 0xd3, 0x4c, 0x89, 0x01, 0xd4, 0x4d, 0x89, + 0x01, 0xd5, 0x4e, 0x89, 0x01, 0xd6, 0x4f, 0x89, 0x01, 0xd7, 0x50, 0x89, + 0x01, 0xd8, 0x51, 0x89, 0x01, 0xd9, 0x52, 0x89, 0x41, 0xd0, 0x3f, 0x89, + 0x01, 0xd1, 0x40, 0x89, 0x01, 0xd2, 0x41, 0x89, 0x01, 0xd3, 0x42, 0x89, + 0x01, 0xd4, 0x43, 0x89, 0x01, 0xd5, 0x44, 0x89, 0x01, 0xd6, 0x45, 0x89, + 0x01, 0xd7, 0x46, 0x89, 0x01, 0xd8, 0x47, 0x89, 0x01, 0xd9, 0x48, 0x89, + 0x41, 0xd0, 0x35, 0x89, 0x01, 0xd1, 0x36, 0x89, 0x01, 0xd2, 0x37, 0x89, + 0x01, 0xd3, 0x38, 0x89, 0x01, 0xd4, 0x39, 0x89, 0x01, 0xd5, 0x3a, 0x89, + 0x01, 0xd6, 0x3b, 0x89, 0x01, 0xd7, 0x3c, 0x89, 0x01, 0xd8, 0x3d, 0x89, + 0x01, 0xd9, 0x3e, 0x89, 0x41, 0xd0, 0x2b, 0x89, 0x01, 0xd1, 0x2c, 0x89, + 0x01, 0xd2, 0x2d, 0x89, 0x01, 0xd3, 0x2e, 0x89, 0x01, 0xd4, 0x2f, 0x89, + 0x01, 0xd5, 0x30, 0x89, 0x01, 0xd6, 0x31, 0x89, 0x01, 0xd7, 0x32, 0x89, + 0x01, 0xd8, 0x33, 0x89, 0x01, 0xd9, 0x34, 0x89, 0x41, 0x90, 0x80, 0x03, + 0x91, 0xd5, 0x02, 0x92, 0xaa, 0x02, 0x93, 0xff, 0x01, 0x94, 0xd4, 0x01, + 0x95, 0xa9, 0x01, 0x96, 0x7f, 0x97, 0x55, 0x98, 0x2b, 0x99, 0x01, 0xff, + 0xd0, 0x21, 0x89, 0x01, 0xd1, 0x22, 0x89, 0x01, 0xd2, 0x23, 0x89, 0x01, + 0xd3, 0x24, 0x89, 0x01, 0xd4, 0x25, 0x89, 0x01, 0xd5, 0x26, 0x89, 0x01, + 0xd6, 0x27, 0x89, 0x01, 0xd7, 0x28, 0x89, 0x01, 0xd8, 0x29, 0x89, 0x01, + 0xd9, 0x2a, 0x89, 0x41, 0xd0, 0x17, 0x89, 0x01, 0xd1, 0x18, 0x89, 0x01, + 0xd2, 0x19, 0x89, 0x01, 0xd3, 0x1a, 0x89, 0x01, 0xd4, 0x1b, 0x89, 0x01, + 0xd5, 0x1c, 0x89, 0x01, 0xd6, 0x1d, 0x89, 0x01, 0xd7, 0x1e, 0x89, 0x01, + 0xd8, 0x1f, 0x89, 0x01, 0xd9, 0x20, 0x89, 0x41, 0xd0, 0x0d, 0x89, 0x01, + 0xd1, 0x0e, 0x89, 0x01, 0xd2, 0x0f, 0x89, 0x01, 0xd3, 0x10, 0x89, 0x01, + 0xd4, 0x11, 0x89, 0x01, 0xd5, 0x12, 0x89, 0x01, 0xd6, 0x13, 0x89, 0x01, + 0xd7, 0x14, 0x89, 0x01, 0xd8, 0x15, 0x89, 0x01, 0xd9, 0x16, 0x89, 0x41, + 0xd0, 0x03, 0x89, 0x01, 0xd1, 0x04, 0x89, 0x01, 0xd2, 0x05, 0x89, 0x01, + 0xd3, 0x06, 0x89, 0x01, 0xd4, 0x07, 0x89, 0x01, 0xd5, 0x08, 0x89, 0x01, + 0xd6, 0x09, 0x89, 0x01, 0xd7, 0x0a, 0x89, 0x01, 0xd8, 0x0b, 0x89, 0x01, + 0xd9, 0x0c, 0x89, 0x41, 0xd0, 0xf9, 0x88, 0x01, 0xd1, 0xfa, 0x88, 0x01, + 0xd2, 0xfb, 0x88, 0x01, 0xd3, 0xfc, 0x88, 0x01, 0xd4, 0xfd, 0x88, 0x01, + 0xd5, 0xfe, 0x88, 0x01, 0xd6, 0xff, 0x88, 0x01, 0xd7, 0x00, 0x89, 0x01, + 0xd8, 0x01, 0x89, 0x01, 0xd9, 0x02, 0x89, 0x41, 0xd0, 0xef, 0x88, 0x01, + 0xd1, 0xf0, 0x88, 0x01, 0xd2, 0xf1, 0x88, 0x01, 0xd3, 0xf2, 0x88, 0x01, + 0xd4, 0xf3, 0x88, 0x01, 0xd5, 0xf4, 0x88, 0x01, 0xd6, 0xf5, 0x88, 0x01, + 0xd7, 0xf6, 0x88, 0x01, 0xd8, 0xf7, 0x88, 0x01, 0xd9, 0xf8, 0x88, 0x41, + 0xd0, 0xe5, 0x88, 0x01, 0xd1, 0xe6, 0x88, 0x01, 0xd2, 0xe7, 0x88, 0x01, + 0xd3, 0xe8, 0x88, 0x01, 0xd4, 0xe9, 0x88, 0x01, 0xd5, 0xea, 0x88, 0x01, + 0xd6, 0xeb, 0x88, 0x01, 0xd7, 0xec, 0x88, 0x01, 0xd8, 0xed, 0x88, 0x01, + 0xd9, 0xee, 0x88, 0x41, 0xd0, 0xdb, 0x88, 0x01, 0xd1, 0xdc, 0x88, 0x01, + 0xd2, 0xdd, 0x88, 0x01, 0xd3, 0xde, 0x88, 0x01, 0xd4, 0xdf, 0x88, 0x01, + 0xd5, 0xe0, 0x88, 0x01, 0xd6, 0xe1, 0x88, 0x01, 0xd7, 0xe2, 0x88, 0x01, + 0xd8, 0xe3, 0x88, 0x01, 0xd9, 0xe4, 0x88, 0x41, 0xd0, 0xd1, 0x88, 0x01, + 0xd1, 0xd2, 0x88, 0x01, 0xd2, 0xd3, 0x88, 0x01, 0xd3, 0xd4, 0x88, 0x01, + 0xd4, 0xd5, 0x88, 0x01, 0xd5, 0xd6, 0x88, 0x01, 0xd6, 0xd7, 0x88, 0x01, + 0xd7, 0xd8, 0x88, 0x01, 0xd8, 0xd9, 0x88, 0x01, 0xd9, 0xda, 0x88, 0x41, + 0xd0, 0xc7, 0x88, 0x01, 0xd1, 0xc8, 0x88, 0x01, 0xd2, 0xc9, 0x88, 0x01, + 0xd3, 0xca, 0x88, 0x01, 0xd4, 0xcb, 0x88, 0x01, 0xd5, 0xcc, 0x88, 0x01, + 0xd6, 0xcd, 0x88, 0x01, 0xd7, 0xce, 0x88, 0x01, 0xd8, 0xcf, 0x88, 0x01, + 0xd9, 0xd0, 0x88, 0x41, 0x90, 0x80, 0x03, 0x91, 0xd5, 0x02, 0x92, 0xaa, + 0x02, 0x93, 0xff, 0x01, 0x94, 0xd4, 0x01, 0x95, 0xa9, 0x01, 0x96, 0x7f, + 0x97, 0x55, 0x98, 0x2b, 0x99, 0x01, 0xff, 0xd0, 0xbd, 0x88, 0x01, 0xd1, + 0xbe, 0x88, 0x01, 0xd2, 0xbf, 0x88, 0x01, 0xd3, 0xc0, 0x88, 0x01, 0xd4, + 0xc1, 0x88, 0x01, 0xd5, 0xc2, 0x88, 0x01, 0xd6, 0xc3, 0x88, 0x01, 0xd7, + 0xc4, 0x88, 0x01, 0xd8, 0xc5, 0x88, 0x01, 0xd9, 0xc6, 0x88, 0x41, 0xd0, + 0xb3, 0x88, 0x01, 0xd1, 0xb4, 0x88, 0x01, 0xd2, 0xb5, 0x88, 0x01, 0xd3, + 0xb6, 0x88, 0x01, 0xd4, 0xb7, 0x88, 0x01, 0xd5, 0xb8, 0x88, 0x01, 0xd6, + 0xb9, 0x88, 0x01, 0xd7, 0xba, 0x88, 0x01, 0xd8, 0xbb, 0x88, 0x01, 0xd9, + 0xbc, 0x88, 0x41, 0xd0, 0xa9, 0x88, 0x01, 0xd1, 0xaa, 0x88, 0x01, 0xd2, + 0xab, 0x88, 0x01, 0xd3, 0xac, 0x88, 0x01, 0xd4, 0xad, 0x88, 0x01, 0xd5, + 0xae, 0x88, 0x01, 0xd6, 0xaf, 0x88, 0x01, 0xd7, 0xb0, 0x88, 0x01, 0xd8, + 0xb1, 0x88, 0x01, 0xd9, 0xb2, 0x88, 0x41, 0xd0, 0x9f, 0x88, 0x01, 0xd1, + 0xa0, 0x88, 0x01, 0xd2, 0xa1, 0x88, 0x01, 0xd3, 0xa2, 0x88, 0x01, 0xd4, + 0xa3, 0x88, 0x01, 0xd5, 0xa4, 0x88, 0x01, 0xd6, 0xa5, 0x88, 0x01, 0xd7, + 0xa6, 0x88, 0x01, 0xd8, 0xa7, 0x88, 0x01, 0xd9, 0xa8, 0x88, 0x41, 0xd0, + 0x95, 0x88, 0x01, 0xd1, 0x96, 0x88, 0x01, 0xd2, 0x97, 0x88, 0x01, 0xd3, + 0x98, 0x88, 0x01, 0xd4, 0x99, 0x88, 0x01, 0xd5, 0x9a, 0x88, 0x01, 0xd6, + 0x9b, 0x88, 0x01, 0xd7, 0x9c, 0x88, 0x01, 0xd8, 0x9d, 0x88, 0x01, 0xd9, + 0x9e, 0x88, 0x41, 0xd0, 0x8b, 0x88, 0x01, 0xd1, 0x8c, 0x88, 0x01, 0xd2, + 0x8d, 0x88, 0x01, 0xd3, 0x8e, 0x88, 0x01, 0xd4, 0x8f, 0x88, 0x01, 0xd5, + 0x90, 0x88, 0x01, 0xd6, 0x91, 0x88, 0x01, 0xd7, 0x92, 0x88, 0x01, 0xd8, + 0x93, 0x88, 0x01, 0xd9, 0x94, 0x88, 0x41, 0xd0, 0x81, 0x88, 0x01, 0xd1, + 0x82, 0x88, 0x01, 0xd2, 0x83, 0x88, 0x01, 0xd3, 0x84, 0x88, 0x01, 0xd4, + 0x85, 0x88, 0x01, 0xd5, 0x86, 0x88, 0x01, 0xd6, 0x87, 0x88, 0x01, 0xd7, + 0x88, 0x88, 0x01, 0xd8, 0x89, 0x88, 0x01, 0xd9, 0x8a, 0x88, 0x41, 0xd0, + 0x77, 0x88, 0x01, 0xd1, 0x78, 0x88, 0x01, 0xd2, 0x79, 0x88, 0x01, 0xd3, + 0x7a, 0x88, 0x01, 0xd4, 0x7b, 0x88, 0x01, 0xd5, 0x7c, 0x88, 0x01, 0xd6, + 0x7d, 0x88, 0x01, 0xd7, 0x7e, 0x88, 0x01, 0xd8, 0x7f, 0x88, 0x01, 0xd9, + 0x80, 0x88, 0x41, 0xd0, 0x6d, 0x88, 0x01, 0xd1, 0x6e, 0x88, 0x01, 0xd2, + 0x6f, 0x88, 0x01, 0xd3, 0x70, 0x88, 0x01, 0xd4, 0x71, 0x88, 0x01, 0xd5, + 0x72, 0x88, 0x01, 0xd6, 0x73, 0x88, 0x01, 0xd7, 0x74, 0x88, 0x01, 0xd8, + 0x75, 0x88, 0x01, 0xd9, 0x76, 0x88, 0x41, 0xd0, 0x63, 0x88, 0x01, 0xd1, + 0x64, 0x88, 0x01, 0xd2, 0x65, 0x88, 0x01, 0xd3, 0x66, 0x88, 0x01, 0xd4, + 0x67, 0x88, 0x01, 0xd5, 0x68, 0x88, 0x01, 0xd6, 0x69, 0x88, 0x01, 0xd7, + 0x6a, 0x88, 0x01, 0xd8, 0x6b, 0x88, 0x01, 0xd9, 0x6c, 0x88, 0x41, 0x90, + 0x80, 0x03, 0x91, 0xd5, 0x02, 0x92, 0xaa, 0x02, 0x93, 0xff, 0x01, 0x94, + 0xd4, 0x01, 0x95, 0xa9, 0x01, 0x96, 0x7f, 0x97, 0x55, 0x98, 0x2b, 0x99, + 0x01, 0xff, 0xd0, 0x59, 0x88, 0x01, 0xd1, 0x5a, 0x88, 0x01, 0xd2, 0x5b, + 0x88, 0x01, 0xd3, 0x5c, 0x88, 0x01, 0xd4, 0x5d, 0x88, 0x01, 0xd5, 0x5e, + 0x88, 0x01, 0xd6, 0x5f, 0x88, 0x01, 0xd7, 0x60, 0x88, 0x01, 0xd8, 0x61, + 0x88, 0x01, 0xd9, 0x62, 0x88, 0x41, 0xd0, 0x4f, 0x88, 0x01, 0xd1, 0x50, + 0x88, 0x01, 0xd2, 0x51, 0x88, 0x01, 0xd3, 0x52, 0x88, 0x01, 0xd4, 0x53, + 0x88, 0x01, 0xd5, 0x54, 0x88, 0x01, 0xd6, 0x55, 0x88, 0x01, 0xd7, 0x56, + 0x88, 0x01, 0xd8, 0x57, 0x88, 0x01, 0xd9, 0x58, 0x88, 0x41, 0xd0, 0x45, + 0x88, 0x01, 0xd1, 0x46, 0x88, 0x01, 0xd2, 0x47, 0x88, 0x01, 0xd3, 0x48, + 0x88, 0x01, 0xd4, 0x49, 0x88, 0x01, 0xd5, 0x4a, 0x88, 0x01, 0xd6, 0x4b, + 0x88, 0x01, 0xd7, 0x4c, 0x88, 0x01, 0xd8, 0x4d, 0x88, 0x01, 0xd9, 0x4e, + 0x88, 0x41, 0xd0, 0x3b, 0x88, 0x01, 0xd1, 0x3c, 0x88, 0x01, 0xd2, 0x3d, + 0x88, 0x01, 0xd3, 0x3e, 0x88, 0x01, 0xd4, 0x3f, 0x88, 0x01, 0xd5, 0x40, + 0x88, 0x01, 0xd6, 0x41, 0x88, 0x01, 0xd7, 0x42, 0x88, 0x01, 0xd8, 0x43, + 0x88, 0x01, 0xd9, 0x44, 0x88, 0x41, 0xd0, 0x31, 0x88, 0x01, 0xd1, 0x32, + 0x88, 0x01, 0xd2, 0x33, 0x88, 0x01, 0xd3, 0x34, 0x88, 0x01, 0xd4, 0x35, + 0x88, 0x01, 0xd5, 0x36, 0x88, 0x01, 0xd6, 0x37, 0x88, 0x01, 0xd7, 0x38, + 0x88, 0x01, 0xd8, 0x39, 0x88, 0x01, 0xd9, 0x3a, 0x88, 0x41, 0xd0, 0x27, + 0x88, 0x01, 0xd1, 0x28, 0x88, 0x01, 0xd2, 0x29, 0x88, 0x01, 0xd3, 0x2a, + 0x88, 0x01, 0xd4, 0x2b, 0x88, 0x01, 0xd5, 0x2c, 0x88, 0x01, 0xd6, 0x2d, + 0x88, 0x01, 0xd7, 0x2e, 0x88, 0x01, 0xd8, 0x2f, 0x88, 0x01, 0xd9, 0x30, + 0x88, 0x41, 0xd0, 0x1d, 0x88, 0x01, 0xd1, 0x1e, 0x88, 0x01, 0xd2, 0x1f, + 0x88, 0x01, 0xd3, 0x20, 0x88, 0x01, 0xd4, 0x21, 0x88, 0x01, 0xd5, 0x22, + 0x88, 0x01, 0xd6, 0x23, 0x88, 0x01, 0xd7, 0x24, 0x88, 0x01, 0xd8, 0x25, + 0x88, 0x01, 0xd9, 0x26, 0x88, 0x41, 0xd0, 0x13, 0x88, 0x01, 0xd1, 0x14, + 0x88, 0x01, 0xd2, 0x15, 0x88, 0x01, 0xd3, 0x16, 0x88, 0x01, 0xd4, 0x17, + 0x88, 0x01, 0xd5, 0x18, 0x88, 0x01, 0xd6, 0x19, 0x88, 0x01, 0xd7, 0x1a, + 0x88, 0x01, 0xd8, 0x1b, 0x88, 0x01, 0xd9, 0x1c, 0x88, 0x41, 0xd0, 0x09, + 0x88, 0x01, 0xd1, 0x0a, 0x88, 0x01, 0xd2, 0x0b, 0x88, 0x01, 0xd3, 0x0c, + 0x88, 0x01, 0xd4, 0x0d, 0x88, 0x01, 0xd5, 0x0e, 0x88, 0x01, 0xd6, 0x0f, + 0x88, 0x01, 0xd7, 0x10, 0x88, 0x01, 0xd8, 0x11, 0x88, 0x01, 0xd9, 0x12, + 0x88, 0x41, 0xd1, 0x00, 0x88, 0x01, 0xd2, 0x01, 0x88, 0x01, 0xd3, 0x02, + 0x88, 0x01, 0xd4, 0x03, 0x88, 0x01, 0xd5, 0x04, 0x88, 0x01, 0xd6, 0x05, + 0x88, 0x01, 0xd7, 0x06, 0x88, 0x01, 0xd8, 0x07, 0x88, 0x01, 0xd9, 0x08, + 0x88, 0x41, 0x06, 0xef, 0x06, 0xb1, 0x03, 0x07, 0x13, 0x06, 0x01, 0xff, + 0xa1, 0x87, 0x03, 0x42, 0x16, 0x00, 0xaa, 0x6a, 0x01, 0xa3, 0xf4, 0x02, + 0xa4, 0xe7, 0x02, 0xa5, 0xd4, 0x02, 0xa6, 0xc7, 0x02, 0xa7, 0xba, 0x02, + 0xa8, 0xa6, 0x02, 0xa9, 0x93, 0x02, 0xab, 0x86, 0x02, 0xac, 0xf9, 0x01, + 0xad, 0xe2, 0x01, 0xae, 0xc9, 0x01, 0xaf, 0xb6, 0x01, 0xb0, 0xa9, 0x01, + 0x42, 0x71, 0x00, 0xb2, 0x6a, 0x01, 0xb3, 0x84, 0x01, 0xb4, 0x72, 0xb5, + 0x2a, 0xb6, 0x18, 0x42, 0xa9, 0x01, 0xa6, 0x6a, 0x01, 0x42, 0x5b, 0x28, + 0xba, 0x6a, 0x01, 0x42, 0xdf, 0x23, 0xa5, 0x6a, 0x01, 0x42, 0x59, 0x00, + 0xbe, 0x6a, 0x41, 0xe3, 0x79, 0x6a, 0x01, 0xf1, 0x7a, 0x6a, 0x01, 0xf8, + 0x7b, 0x6a, 0x01, 0xfa, 0x78, 0x6a, 0x41, 0xe3, 0x85, 0x6a, 0x01, 0xa5, + 0x30, 0xa9, 0x0c, 0xf1, 0x86, 0x6a, 0x01, 0xf8, 0x87, 0x6a, 0x01, 0xfa, + 0x84, 0x6a, 0x41, 0xe3, 0x8d, 0x6a, 0x01, 0xf1, 0x8e, 0x6a, 0x01, 0xb5, + 0x08, 0xf8, 0x8f, 0x6a, 0x01, 0xfa, 0x8c, 0x6a, 0x41, 0xe3, 0x99, 0x6a, + 0x01, 0xf1, 0x9a, 0x6a, 0x01, 0xf8, 0x9b, 0x6a, 0x01, 0xfa, 0x98, 0x6a, + 0x41, 0xe3, 0x94, 0x6a, 0x01, 0xf1, 0x96, 0x6a, 0x01, 0xf8, 0x97, 0x6a, + 0x01, 0xfa, 0x95, 0x6a, 0x41, 0xe1, 0xb0, 0x6a, 0x01, 0x42, 0x22, 0x00, + 0xb9, 0x6a, 0x01, 0x42, 0x40, 0x06, 0xb6, 0x6a, 0x41, 0xe1, 0xa4, 0x6a, + 0x01, 0xa8, 0x01, 0xff, 0xe1, 0xb4, 0x6a, 0x01, 0x04, 0x35, 0x07, 0x01, + 0xff, 0x43, 0xf1, 0xf9, 0x93, 0x6a, 0x01, 0x43, 0xa8, 0xfa, 0x92, 0x6a, + 0x41, 0xe1, 0xa7, 0x6a, 0x01, 0x42, 0x22, 0x00, 0xa9, 0x6a, 0x41, 0xe3, + 0x71, 0x6a, 0x01, 0xf1, 0x72, 0x6a, 0x01, 0xf8, 0x73, 0x6a, 0x01, 0xfa, + 0x70, 0x6a, 0x41, 0xe1, 0xac, 0x6a, 0x01, 0x42, 0x24, 0x02, 0xa3, 0x6a, + 0x01, 0x42, 0x22, 0x00, 0xb3, 0x6a, 0x01, 0x42, 0xdf, 0x23, 0xa8, 0x6a, + 0x41, 0xe1, 0xab, 0x6a, 0x01, 0xe3, 0x9d, 0x6a, 0x01, 0xf1, 0x9e, 0x6a, + 0x01, 0xf8, 0x9f, 0x6a, 0x01, 0xfa, 0x9c, 0x6a, 0x41, 0xe1, 0xae, 0x6a, + 0x01, 0x47, 0xd0, 0xd9, 0x91, 0x6a, 0x41, 0xe1, 0xa0, 0x6a, 0x01, 0x42, + 0x22, 0x00, 0xa1, 0x6a, 0x41, 0xe3, 0x81, 0x6a, 0x01, 0xf1, 0x82, 0x6a, + 0x01, 0xf8, 0x83, 0x6a, 0x01, 0xfa, 0x80, 0x6a, 0x41, 0xe1, 0xad, 0x6a, + 0x01, 0xb4, 0x01, 0xff, 0xe1, 0xaf, 0x6a, 0x01, 0x42, 0x12, 0x00, 0xb8, + 0x6a, 0x41, 0xe1, 0xa2, 0x6a, 0x01, 0x42, 0x22, 0x00, 0xb7, 0x6a, 0x41, + 0xe1, 0xbb, 0x6a, 0x01, 0x47, 0x83, 0xbe, 0x90, 0x6a, 0x41, 0xe3, 0x7d, + 0x6a, 0x01, 0xf1, 0x7e, 0x6a, 0x01, 0xf8, 0x7f, 0x6a, 0x01, 0xfa, 0x7c, + 0x6a, 0x41, 0xe1, 0xb1, 0x6a, 0x01, 0x42, 0x22, 0x00, 0xbc, 0x6a, 0x41, + 0xe1, 0xb5, 0x6a, 0x01, 0x42, 0x22, 0x00, 0xbd, 0x6a, 0x41, 0xe3, 0x75, + 0x6a, 0x01, 0xf1, 0x76, 0x6a, 0x01, 0xb7, 0x08, 0xf8, 0x77, 0x6a, 0x01, + 0xfa, 0x74, 0x6a, 0x41, 0xe3, 0x89, 0x6a, 0x01, 0xf1, 0x8a, 0x6a, 0x01, + 0xf8, 0x8b, 0x6a, 0x01, 0xfa, 0x88, 0x6a, 0x41, 0x45, 0x7e, 0x0b, 0xc8, + 0x6a, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xc9, 0x6a, 0x01, 0x43, 0x7a, + 0x0b, 0xc1, 0x6a, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xc0, + 0x6a, 0x41, 0x44, 0x25, 0x01, 0xc3, 0x6a, 0x01, 0x42, 0x15, 0x02, 0xc2, + 0x6a, 0x41, 0x44, 0x06, 0x1f, 0xc7, 0x6a, 0x01, 0x42, 0x09, 0x24, 0xc6, + 0x6a, 0x41, 0x43, 0xf9, 0x05, 0xc5, 0x6a, 0x01, 0x43, 0xf6, 0x06, 0xc4, + 0x6a, 0x41, 0x43, 0x67, 0x00, 0xd4, 0xfa, 0x01, 0x03, 0x1d, 0x52, 0x01, + 0xff, 0xa1, 0x9a, 0x06, 0xa3, 0x8b, 0x06, 0xa4, 0xb0, 0x05, 0x09, 0x54, + 0x2a, 0x93, 0x04, 0x52, 0x13, 0x55, 0xee, 0x1f, 0x01, 0xac, 0xbc, 0x02, + 0x4a, 0x98, 0xb3, 0xf4, 0x0b, 0x00, 0x07, 0x37, 0x3c, 0x95, 0x02, 0x42, + 0x14, 0x05, 0xd0, 0x0b, 0x00, 0x57, 0x07, 0x32, 0xff, 0x1f, 0x01, 0x4a, + 0x68, 0x84, 0xf9, 0x0b, 0x00, 0xb3, 0x5b, 0xb4, 0x42, 0x0b, 0xc7, 0x7a, + 0x0c, 0x54, 0xef, 0x48, 0xe4, 0x1f, 0x01, 0x49, 0x5e, 0xc7, 0xf5, 0x0b, + 0x40, 0xa1, 0x24, 0xe5, 0xc6, 0x0b, 0x80, 0x1b, 0xe9, 0xbf, 0x0b, 0x80, + 0x12, 0xef, 0xca, 0x0b, 0x80, 0x09, 0xf5, 0xc1, 0x0b, 0xc0, 0x00, 0xf5, + 0xc2, 0x0b, 0x40, 0xef, 0xcb, 0x0b, 0x40, 0xe9, 0xc0, 0x0b, 0x40, 0xe5, + 0xc7, 0x0b, 0x40, 0xe1, 0xbe, 0x0b, 0x00, 0xe9, 0xc8, 0x0b, 0x00, 0xf5, + 0xcc, 0x0b, 0x40, 0x49, 0x4a, 0xc3, 0xed, 0x1f, 0x01, 0x0b, 0x1d, 0x81, + 0x01, 0xff, 0x4b, 0x74, 0x9f, 0xe8, 0x1f, 0x01, 0x4b, 0x6d, 0xa5, 0xe9, + 0x1f, 0x41, 0x4c, 0xc8, 0x90, 0xe7, 0x1f, 0x01, 0x04, 0x5b, 0x03, 0x0c, + 0x49, 0xbf, 0xc3, 0xec, 0x1f, 0x01, 0x51, 0xce, 0x60, 0xef, 0x1f, 0x41, + 0xa1, 0x81, 0x01, 0x46, 0x54, 0xe0, 0xd6, 0x1f, 0x01, 0xab, 0x64, 0x02, + 0x91, 0x17, 0x4e, 0x43, 0x9d, 0xcd, 0xd5, 0x1f, 0x01, 0xb0, 0x2c, 0x47, + 0x9a, 0xc6, 0xd8, 0x1f, 0x01, 0xb6, 0x01, 0xff, 0xa1, 0x15, 0x43, 0x31, + 0x2f, 0xe3, 0x1f, 0x01, 0xa9, 0x01, 0xff, 0x44, 0x21, 0x25, 0xcd, 0x0b, + 0x00, 0x45, 0x49, 0x4e, 0x83, 0x0b, 0x40, 0x48, 0x17, 0xcd, 0xf1, 0x1f, + 0x01, 0x46, 0x58, 0xe5, 0xe0, 0x1f, 0x41, 0xa1, 0x06, 0x42, 0x10, 0x00, + 0xdf, 0x1f, 0x41, 0x44, 0x02, 0x7b, 0xe1, 0x1f, 0x01, 0x43, 0x2a, 0x05, + 0xde, 0x1f, 0x01, 0x46, 0x96, 0xe6, 0xdb, 0x1f, 0x41, 0x47, 0x41, 0xd8, + 0xdc, 0x1f, 0x01, 0x47, 0x38, 0xdc, 0xf0, 0x1f, 0x01, 0x49, 0x98, 0xc6, + 0xd9, 0x1f, 0x41, 0x44, 0xc0, 0xf4, 0xdd, 0x1f, 0x01, 0xb5, 0x01, 0xff, + 0x44, 0xed, 0x81, 0xda, 0x1f, 0x01, 0x43, 0x3c, 0x83, 0xe2, 0x1f, 0x41, + 0x48, 0x8f, 0xc9, 0xd7, 0x1f, 0x01, 0x47, 0x0b, 0x17, 0x82, 0x0b, 0x40, + 0x04, 0x7a, 0x0b, 0x0c, 0x44, 0x5a, 0x03, 0xfa, 0x0b, 0x00, 0x43, 0xdb, + 0x06, 0xf0, 0x0b, 0x40, 0x47, 0x3f, 0x12, 0xf1, 0x0b, 0x00, 0x48, 0xde, + 0x1e, 0xf2, 0x0b, 0x40, 0x48, 0xe5, 0x49, 0xe6, 0x1f, 0x01, 0x06, 0x14, + 0x06, 0x01, 0xff, 0xe1, 0x85, 0x0b, 0x80, 0xb1, 0x01, 0x42, 0x37, 0x00, + 0x9a, 0x0b, 0x00, 0xe5, 0x8e, 0x0b, 0x80, 0xa1, 0x01, 0x42, 0x22, 0x00, + 0xb9, 0x0b, 0x00, 0xe9, 0x87, 0x0b, 0x80, 0x91, 0x01, 0x42, 0x78, 0x1a, + 0x9c, 0x0b, 0x00, 0x42, 0x1b, 0x02, 0x95, 0x0b, 0x00, 0xac, 0x72, 0x42, + 0x6c, 0x00, 0xae, 0x0b, 0x00, 0xae, 0x4e, 0xef, 0x92, 0x0b, 0x80, 0x45, + 0x42, 0xe0, 0x09, 0xaa, 0x0b, 0x00, 0xb2, 0x33, 0xb3, 0x21, 0xb4, 0x15, + 0xf5, 0x89, 0x0b, 0x80, 0x0c, 0x42, 0x61, 0x0b, 0xb5, 0x0b, 0x00, 0x42, + 0xdf, 0x23, 0xaf, 0x0b, 0x40, 0xf5, 0x8a, 0x0b, 0x40, 0xe1, 0xa4, 0x0b, + 0x00, 0x42, 0x12, 0x00, 0x9f, 0x0b, 0x40, 0xe1, 0xb8, 0x0b, 0x00, 0x42, + 0x22, 0x00, 0xb6, 0x0b, 0x00, 0x42, 0x40, 0x06, 0xb7, 0x0b, 0x40, 0xe1, + 0xb0, 0x0b, 0x00, 0x42, 0x71, 0x00, 0xb1, 0x0b, 0x40, 0xef, 0x93, 0x0b, + 0x40, 0xe1, 0xa8, 0x0b, 0x00, 0x42, 0x24, 0x02, 0x99, 0x0b, 0x00, 0xae, + 0x06, 0x42, 0xdf, 0x23, 0x9e, 0x0b, 0x40, 0xe1, 0xa3, 0x0b, 0x00, 0x42, + 0x2a, 0x05, 0xa9, 0x0b, 0x40, 0xe1, 0xb2, 0x0b, 0x00, 0xac, 0x01, 0xff, + 0xe1, 0xb3, 0x0b, 0x00, 0x42, 0x74, 0x00, 0xb4, 0x0b, 0x40, 0xe9, 0x88, + 0x0b, 0x40, 0xe5, 0x8f, 0x0b, 0x40, 0xe1, 0x86, 0x0b, 0x00, 0xe9, 0x90, + 0x0b, 0x00, 0xf5, 0x94, 0x0b, 0x40, 0x58, 0xac, 0x29, 0xd4, 0x1f, 0x01, + 0x04, 0x7a, 0x0b, 0x27, 0x06, 0x24, 0x01, 0x01, 0xff, 0x4a, 0x2e, 0xaf, + 0xc6, 0x1f, 0x01, 0x48, 0x2a, 0x01, 0xd3, 0x1f, 0x01, 0x04, 0x08, 0x24, + 0x06, 0x4a, 0xda, 0xb7, 0xcd, 0x1f, 0x41, 0x46, 0xbc, 0xb6, 0xce, 0x1f, + 0x01, 0x49, 0x55, 0xc7, 0xc7, 0x1f, 0x41, 0x05, 0x7e, 0x0b, 0x59, 0xa6, + 0x4b, 0x05, 0x47, 0x2e, 0x3f, 0x58, 0xd4, 0x2b, 0xc1, 0x1f, 0x01, 0x47, + 0x2a, 0x01, 0xd0, 0x1f, 0x01, 0x04, 0x08, 0x24, 0x1d, 0xb4, 0x01, 0xff, + 0x44, 0xa4, 0x1c, 0xcb, 0x1f, 0x01, 0xa8, 0x06, 0x48, 0x43, 0x27, 0xc8, + 0x1f, 0x41, 0x4b, 0x18, 0x95, 0xc5, 0x1f, 0x01, 0x59, 0x32, 0x27, 0xc0, + 0x1f, 0x41, 0x06, 0x14, 0xe1, 0x06, 0x48, 0xec, 0x1e, 0xc3, 0x1f, 0x41, + 0xd1, 0xc9, 0x1f, 0x01, 0xd2, 0xca, 0x1f, 0x41, 0xd1, 0xd1, 0x1f, 0x01, + 0xd2, 0xd2, 0x1f, 0x41, 0x44, 0xdd, 0xb4, 0xcf, 0x1f, 0x01, 0x47, 0x01, + 0xda, 0xc4, 0x1f, 0x41, 0xe8, 0xcc, 0x1f, 0x01, 0x44, 0x47, 0x27, 0xc2, + 0x1f, 0x41, 0x47, 0x0e, 0xd5, 0xf3, 0x0b, 0x00, 0x49, 0xa1, 0xbd, 0xf6, + 0x0b, 0x00, 0x05, 0xf0, 0x06, 0x06, 0x53, 0x32, 0x4f, 0xe5, 0x1f, 0x41, + 0x45, 0x7e, 0x0b, 0xee, 0x0b, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xef, + 0x0b, 0x00, 0x43, 0x7a, 0x0b, 0xe7, 0x0b, 0x00, 0xb3, 0x14, 0xb4, 0x06, + 0x44, 0x80, 0x1f, 0xe6, 0x0b, 0x40, 0x44, 0x25, 0x01, 0xe9, 0x0b, 0x00, + 0x42, 0x15, 0x02, 0xe8, 0x0b, 0x40, 0x44, 0x06, 0x1f, 0xed, 0x0b, 0x00, + 0x42, 0x09, 0x24, 0xec, 0x0b, 0x40, 0x43, 0xf9, 0x05, 0xeb, 0x0b, 0x00, + 0x43, 0xf6, 0x06, 0xea, 0x0b, 0x40, 0x4a, 0x75, 0x9f, 0xf7, 0x0b, 0x00, + 0x4b, 0xc4, 0xa9, 0xea, 0x1f, 0x41, 0x4b, 0x15, 0xa5, 0xeb, 0x1f, 0x01, + 0x4c, 0xec, 0x99, 0xf8, 0x0b, 0x00, 0x4d, 0x91, 0x79, 0xd7, 0x0b, 0x40, + 0x44, 0x4e, 0x12, 0x78, 0xd3, 0x01, 0x43, 0x7a, 0x0b, 0x77, 0xd3, 0x41, + 0x48, 0x57, 0xcb, 0x61, 0xf9, 0x01, 0x03, 0x51, 0x0b, 0x01, 0xff, 0x51, + 0x5d, 0x5a, 0xb9, 0x16, 0x01, 0x06, 0xef, 0x06, 0xd1, 0x02, 0x07, 0x13, + 0x06, 0x4e, 0x05, 0x5a, 0x03, 0x2d, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xa1, + 0x1a, 0xe5, 0xb2, 0x16, 0x01, 0xe9, 0xae, 0x16, 0x81, 0x0d, 0xef, 0xb4, + 0x16, 0x01, 0xf5, 0xb0, 0x16, 0xc1, 0x00, 0xf5, 0xb1, 0x16, 0x41, 0xe9, + 0xaf, 0x16, 0x41, 0xe1, 0xad, 0x16, 0x01, 0xe9, 0xb3, 0x16, 0x01, 0xf5, + 0xb5, 0x16, 0x41, 0x48, 0x0a, 0x17, 0xab, 0x16, 0x01, 0x45, 0x62, 0x41, + 0xb7, 0x16, 0x01, 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0x21, 0x25, 0xb6, + 0x16, 0x01, 0x45, 0x49, 0x4e, 0xac, 0x16, 0x41, 0xe1, 0x80, 0x16, 0x81, + 0xe7, 0x01, 0xa2, 0xda, 0x01, 0xa3, 0xcd, 0x01, 0xa4, 0xb4, 0x01, 0xe5, + 0x86, 0x16, 0x01, 0xa7, 0xa3, 0x01, 0x42, 0x22, 0x00, 0xa9, 0x16, 0x01, + 0xe9, 0x82, 0x16, 0x81, 0x93, 0x01, 0xaa, 0x86, 0x01, 0xab, 0x7a, 0x42, + 0x74, 0x00, 0xa5, 0x16, 0x01, 0x42, 0x6c, 0x00, 0xa2, 0x16, 0x01, 0xae, + 0x56, 0xef, 0x88, 0x16, 0x01, 0xb0, 0x46, 0xb2, 0x3a, 0xb3, 0x2e, 0xb4, + 0x15, 0xf5, 0x84, 0x16, 0x81, 0x0c, 0x42, 0x61, 0x0b, 0xa6, 0x16, 0x01, + 0x42, 0xdf, 0x23, 0xa3, 0x16, 0x41, 0xf5, 0x85, 0x16, 0x41, 0xe1, 0x99, + 0x16, 0x01, 0x42, 0x22, 0x00, 0x9a, 0x16, 0x01, 0xb4, 0x01, 0xff, 0xe1, + 0x94, 0x16, 0x01, 0x42, 0x22, 0x00, 0x95, 0x16, 0x41, 0xe1, 0xa8, 0x16, + 0x01, 0x42, 0x22, 0x00, 0xa7, 0x16, 0x41, 0xe1, 0xa4, 0x16, 0x01, 0x42, + 0x71, 0x00, 0xaa, 0x16, 0x41, 0xe1, 0x9e, 0x16, 0x01, 0x42, 0x22, 0x00, + 0x9f, 0x16, 0x41, 0xe1, 0x9d, 0x16, 0x01, 0x42, 0x24, 0x02, 0x8e, 0x16, + 0x01, 0x42, 0x2a, 0x05, 0x98, 0x16, 0x01, 0x42, 0xdf, 0x23, 0x93, 0x16, + 0x41, 0xe1, 0x8a, 0x16, 0x01, 0x42, 0x22, 0x00, 0x8b, 0x16, 0x41, 0xe1, + 0x91, 0x16, 0x01, 0x42, 0x22, 0x00, 0x92, 0x16, 0x41, 0xe9, 0x83, 0x16, + 0x41, 0xe1, 0x8c, 0x16, 0x01, 0x42, 0x22, 0x00, 0x8d, 0x16, 0x41, 0xe1, + 0x9b, 0x16, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x9c, 0x16, 0x41, 0xe1, + 0x96, 0x16, 0x01, 0x42, 0x22, 0x00, 0x97, 0x16, 0x41, 0xe1, 0x8f, 0x16, + 0x01, 0x42, 0x22, 0x00, 0x90, 0x16, 0x41, 0xe1, 0xa0, 0x16, 0x01, 0x42, + 0x22, 0x00, 0xa1, 0x16, 0x41, 0xe1, 0x81, 0x16, 0x01, 0xe9, 0x87, 0x16, + 0x01, 0x4a, 0x8c, 0xb5, 0xb8, 0x16, 0x01, 0xf5, 0x89, 0x16, 0x41, 0x45, + 0x7e, 0x0b, 0xc8, 0x16, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xc9, 0x16, + 0x01, 0x43, 0x7a, 0x0b, 0xc1, 0x16, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, + 0x80, 0x1f, 0xc0, 0x16, 0x41, 0x44, 0x25, 0x01, 0xc3, 0x16, 0x01, 0x42, + 0x15, 0x02, 0xc2, 0x16, 0x41, 0x44, 0x06, 0x1f, 0xc7, 0x16, 0x01, 0x42, + 0x09, 0x24, 0xc6, 0x16, 0x41, 0x43, 0xf9, 0x05, 0xc5, 0x16, 0x01, 0x43, + 0xf6, 0x06, 0xc4, 0x16, 0x41, 0x0a, 0x08, 0xb2, 0xc6, 0x0c, 0x05, 0xa6, + 0xa8, 0x8b, 0x06, 0x05, 0x00, 0xf2, 0xca, 0x02, 0x03, 0xc9, 0x5a, 0x01, + 0xff, 0x07, 0x13, 0x06, 0x2e, 0xb3, 0x06, 0x47, 0x96, 0xdd, 0xff, 0xe6, + 0x41, 0x04, 0x5b, 0x03, 0x06, 0x4c, 0x38, 0x9c, 0xfe, 0xe6, 0x41, 0xa1, + 0x0c, 0x42, 0x14, 0x05, 0xf5, 0xe6, 0x01, 0x42, 0x5c, 0x0a, 0xe3, 0xe6, + 0x41, 0x42, 0x1d, 0x01, 0xef, 0xe6, 0x01, 0xf5, 0xe6, 0xe6, 0x01, 0xf9, + 0xee, 0xe6, 0x41, 0xa1, 0xee, 0x01, 0x42, 0x5d, 0x00, 0xd0, 0xe6, 0x01, + 0x42, 0x13, 0x05, 0xc6, 0xe6, 0x01, 0x42, 0x3b, 0x01, 0xcb, 0xe6, 0x01, + 0xe5, 0xe8, 0xe6, 0x01, 0x42, 0xd4, 0x14, 0xc4, 0xe6, 0x01, 0x05, 0xb4, + 0x0b, 0x97, 0x01, 0xe9, 0xe1, 0xe6, 0x81, 0x8d, 0x01, 0x42, 0x13, 0x01, + 0xd8, 0xe6, 0x81, 0x4b, 0x42, 0xc3, 0x07, 0xd6, 0xe6, 0x01, 0xae, 0x39, + 0xef, 0xe7, 0xe6, 0x81, 0x30, 0x43, 0x24, 0x3f, 0xd3, 0xe6, 0x01, 0x42, + 0xdd, 0xc2, 0xdc, 0xe6, 0x01, 0x43, 0x2a, 0x08, 0xce, 0xe6, 0x01, 0xf5, + 0xe4, 0xe6, 0x81, 0x0c, 0x42, 0x2c, 0x1e, 0xd9, 0xe6, 0x01, 0x42, 0xe0, + 0x49, 0xd7, 0xe6, 0x41, 0xe1, 0xeb, 0xe6, 0x01, 0xe5, 0xe2, 0xe6, 0xc1, + 0x00, 0xe1, 0xea, 0xe6, 0x41, 0xef, 0xec, 0xe6, 0x41, 0x42, 0xd4, 0x14, + 0xc5, 0xe6, 0x01, 0xef, 0xcf, 0xe6, 0x41, 0x02, 0xd2, 0x00, 0x01, 0xff, + 0x42, 0x68, 0x03, 0xd4, 0xe6, 0x01, 0x42, 0x0b, 0x00, 0xda, 0xe6, 0x01, + 0xab, 0x18, 0x43, 0x69, 0x56, 0xc9, 0xe6, 0x01, 0x42, 0x9c, 0x01, 0xd1, + 0xe6, 0x01, 0x42, 0x1e, 0x00, 0xcc, 0xe6, 0x01, 0x42, 0x65, 0x31, 0xc7, + 0xe6, 0x41, 0x42, 0x0b, 0x00, 0xc2, 0xe6, 0x01, 0xef, 0xc0, 0xe6, 0x01, + 0x42, 0x2c, 0x1e, 0xdd, 0xe6, 0x41, 0xe1, 0xe9, 0xe6, 0x41, 0x42, 0x68, + 0x03, 0xd5, 0xe6, 0x01, 0x42, 0x0b, 0x00, 0xdb, 0xe6, 0x01, 0xab, 0x18, + 0x43, 0x69, 0x56, 0xca, 0xe6, 0x01, 0x42, 0x9c, 0x01, 0xd2, 0xe6, 0x01, + 0x42, 0x1e, 0x00, 0xcd, 0xe6, 0x01, 0x42, 0x65, 0x31, 0xc8, 0xe6, 0x41, + 0x42, 0x0b, 0x00, 0xc3, 0xe6, 0x01, 0xef, 0xc1, 0xe6, 0x01, 0x42, 0x2c, + 0x1e, 0xde, 0xe6, 0x41, 0xe1, 0xe0, 0xe6, 0x01, 0xe5, 0xe5, 0xe6, 0x01, + 0xeb, 0xf2, 0xe6, 0x01, 0xed, 0xf1, 0xe6, 0x01, 0xee, 0xf0, 0xe6, 0x01, + 0xf0, 0xf4, 0xe6, 0x01, 0xf4, 0xf3, 0xe6, 0x01, 0x42, 0x5c, 0x0a, 0xed, + 0xe6, 0x41, 0x07, 0x13, 0x06, 0x91, 0x01, 0x05, 0x59, 0xee, 0x80, 0x01, + 0x07, 0x2d, 0x17, 0x5c, 0x09, 0xb7, 0xc5, 0x40, 0x06, 0x74, 0x3b, 0x01, + 0xff, 0xa1, 0x23, 0xe5, 0xb5, 0xaa, 0x00, 0xe9, 0xb2, 0xaa, 0x80, 0x16, + 0xef, 0xb6, 0xaa, 0x00, 0xf5, 0xb4, 0xaa, 0xc0, 0x00, 0xe1, 0xba, 0xaa, + 0x00, 0xe5, 0xb3, 0xaa, 0xc0, 0x00, 0xe1, 0xb9, 0xaa, 0x40, 0xe1, 0xb8, + 0xaa, 0x40, 0xe1, 0xb1, 0xaa, 0x00, 0xed, 0xbe, 0xaa, 0x00, 0xee, 0xbd, + 0xaa, 0x00, 0x42, 0x5c, 0x0a, 0xbb, 0xaa, 0x00, 0xf9, 0xbc, 0xaa, 0x40, + 0x42, 0xdb, 0x19, 0xbf, 0xaa, 0x00, 0x45, 0x3f, 0xef, 0xc0, 0xaa, 0x00, + 0x44, 0xb4, 0xf8, 0xc2, 0xaa, 0x00, 0x43, 0x2a, 0x08, 0xc1, 0xaa, 0x40, + 0x46, 0x82, 0xe2, 0xde, 0xaa, 0x00, 0x02, 0x4d, 0x03, 0x0c, 0x45, 0x3f, + 0xef, 0xdc, 0xaa, 0x00, 0x43, 0x13, 0x8a, 0xdd, 0xaa, 0x40, 0x45, 0x23, + 0xed, 0xdf, 0xaa, 0x00, 0xee, 0xdb, 0xaa, 0x40, 0x43, 0x1c, 0x01, 0xb0, + 0xaa, 0x00, 0x43, 0xae, 0x02, 0xb7, 0xaa, 0x40, 0x05, 0xb4, 0x0b, 0x93, + 0x01, 0x04, 0x08, 0x05, 0x01, 0xff, 0x42, 0x5d, 0x00, 0x9a, 0xaa, 0x00, + 0xa3, 0x7c, 0x42, 0x3b, 0x01, 0x92, 0xaa, 0x00, 0x42, 0x68, 0x03, 0xa0, + 0xaa, 0x00, 0x42, 0xd4, 0x14, 0x86, 0xaa, 0x00, 0x42, 0x0b, 0x00, 0xac, + 0xaa, 0x00, 0xab, 0x52, 0x42, 0x13, 0x01, 0xa8, 0xaa, 0x00, 0x42, 0xc3, + 0x07, 0xa2, 0xaa, 0x00, 0xae, 0x34, 0xef, 0xae, 0xaa, 0x00, 0xb0, 0x24, + 0x42, 0xd0, 0x00, 0xa6, 0xaa, 0x00, 0x42, 0x60, 0x03, 0x8e, 0xaa, 0x00, + 0xb4, 0x0c, 0x42, 0x2c, 0x1e, 0xaa, 0xaa, 0x00, 0x42, 0xe0, 0x49, 0xa4, + 0xaa, 0x40, 0x42, 0x0b, 0x00, 0x96, 0xaa, 0x00, 0xef, 0x94, 0xaa, 0x40, + 0x42, 0x0b, 0x00, 0x9e, 0xaa, 0x00, 0xef, 0x9c, 0xaa, 0x40, 0x42, 0xd4, + 0x14, 0x88, 0xaa, 0x00, 0xef, 0x98, 0xaa, 0x00, 0x42, 0xe0, 0x49, 0x90, + 0xaa, 0x40, 0xa8, 0x04, 0xef, 0x80, 0xaa, 0x40, 0x42, 0x0b, 0x00, 0x84, + 0xaa, 0x00, 0xef, 0x82, 0xaa, 0x40, 0x42, 0x0b, 0x00, 0x8c, 0xaa, 0x00, + 0xef, 0x8a, 0xaa, 0x40, 0x42, 0x5d, 0x00, 0x9b, 0xaa, 0x00, 0xa3, 0x7c, + 0x42, 0x3b, 0x01, 0x93, 0xaa, 0x00, 0x42, 0x68, 0x03, 0xa1, 0xaa, 0x00, + 0x42, 0xd4, 0x14, 0x87, 0xaa, 0x00, 0x42, 0x0b, 0x00, 0xad, 0xaa, 0x00, + 0xab, 0x52, 0x42, 0x13, 0x01, 0xa9, 0xaa, 0x00, 0x42, 0xc3, 0x07, 0xa3, + 0xaa, 0x00, 0xae, 0x34, 0xef, 0xaf, 0xaa, 0x00, 0xb0, 0x24, 0x42, 0xd0, + 0x00, 0xa7, 0xaa, 0x00, 0x42, 0x60, 0x03, 0x8f, 0xaa, 0x00, 0xb4, 0x0c, + 0x42, 0x2c, 0x1e, 0xab, 0xaa, 0x00, 0x42, 0xe0, 0x49, 0xa5, 0xaa, 0x40, + 0x42, 0x0b, 0x00, 0x97, 0xaa, 0x00, 0xef, 0x95, 0xaa, 0x40, 0x42, 0x0b, + 0x00, 0x9f, 0xaa, 0x00, 0xef, 0x9d, 0xaa, 0x40, 0x42, 0xd4, 0x14, 0x89, + 0xaa, 0x00, 0xef, 0x99, 0xaa, 0x00, 0x42, 0xe0, 0x49, 0x91, 0xaa, 0x40, + 0xa8, 0x04, 0xef, 0x81, 0xaa, 0x40, 0x42, 0x0b, 0x00, 0x85, 0xaa, 0x00, + 0xef, 0x83, 0xaa, 0x40, 0x42, 0x0b, 0x00, 0x8d, 0xaa, 0x00, 0xef, 0x8b, + 0xaa, 0x40, 0x02, 0x13, 0x05, 0xe9, 0x05, 0x0b, 0x4a, 0xa2, 0xa2, 0x05, + 0x07, 0x13, 0x06, 0xdd, 0x02, 0x05, 0x5a, 0x03, 0xac, 0x01, 0x0b, 0xa6, + 0xa8, 0x66, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xe1, 0x61, 0x1a, 0x80, 0x50, + 0xe5, 0x6e, 0x1a, 0x00, 0xe9, 0x65, 0x1a, 0x80, 0x43, 0x47, 0xf0, 0xd8, + 0x62, 0x1a, 0x00, 0xef, 0x6b, 0x1a, 0x80, 0x20, 0xb4, 0x12, 0xf5, 0x69, + 0x1a, 0xc0, 0x00, 0xe5, 0x67, 0x1a, 0x00, 0xf5, 0x6a, 0x1a, 0xc0, 0x00, + 0xe5, 0x68, 0x1a, 0x40, 0x46, 0x1d, 0xdc, 0x64, 0x1a, 0x00, 0x46, 0x34, + 0xe2, 0x72, 0x1a, 0x40, 0x02, 0x5a, 0x00, 0x08, 0xef, 0x70, 0x1a, 0x00, + 0xf9, 0x6d, 0x1a, 0x40, 0x45, 0x5c, 0x00, 0x73, 0x1a, 0x00, 0x45, 0x20, + 0x07, 0x6c, 0x1a, 0x40, 0xe9, 0x66, 0x1a, 0x40, 0xe1, 0x63, 0x1a, 0x00, + 0xe5, 0x6f, 0x1a, 0x00, 0xe9, 0x71, 0x1a, 0x40, 0x45, 0x7e, 0x0b, 0x98, + 0x1a, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x99, 0x1a, 0x00, 0x43, 0x7a, + 0x0b, 0x91, 0x1a, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x90, + 0x1a, 0x40, 0x44, 0x25, 0x01, 0x93, 0x1a, 0x00, 0x42, 0x15, 0x02, 0x92, + 0x1a, 0x40, 0x44, 0x06, 0x1f, 0x97, 0x1a, 0x00, 0x42, 0x09, 0x24, 0x96, + 0x1a, 0x40, 0x43, 0xf9, 0x05, 0x95, 0x1a, 0x00, 0x43, 0xf6, 0x06, 0x94, + 0x1a, 0x40, 0x45, 0xda, 0xea, 0xad, 0x1a, 0x00, 0x46, 0xe4, 0xe0, 0xa5, + 0x1a, 0x00, 0xa8, 0x91, 0x01, 0xab, 0x61, 0x04, 0xd9, 0x47, 0x44, 0xb2, + 0x36, 0x02, 0x40, 0x06, 0x19, 0x05, 0xa0, 0x33, 0x0d, 0x45, 0x32, 0xf2, + 0xa0, 0x1a, 0xc0, 0x00, 0x44, 0x10, 0xf9, 0xa1, 0x1a, 0x40, 0xd1, 0x75, + 0x1a, 0x00, 0xd2, 0x76, 0x1a, 0x40, 0x43, 0xc3, 0xb4, 0x60, 0x1a, 0x00, + 0x45, 0x38, 0xf1, 0xaa, 0x1a, 0x80, 0x06, 0x43, 0x47, 0x1b, 0xa2, 0x1a, + 0x40, 0x43, 0x54, 0x79, 0xab, 0x1a, 0x40, 0x46, 0x52, 0xdf, 0x7a, 0x1a, + 0x00, 0x54, 0x53, 0x44, 0xa6, 0x1a, 0x40, 0x44, 0x11, 0xad, 0x74, 0x1a, + 0x80, 0x0c, 0x43, 0x13, 0x8a, 0x7b, 0x1a, 0x00, 0x45, 0x69, 0xf2, 0xa7, + 0x1a, 0x40, 0x44, 0x1e, 0x46, 0x58, 0x1a, 0x40, 0x43, 0x4e, 0x13, 0xa8, + 0x1a, 0x80, 0x21, 0x43, 0xc2, 0x56, 0xa3, 0x1a, 0x00, 0x04, 0x44, 0xf6, + 0x01, 0xff, 0x06, 0x9f, 0x33, 0x06, 0x4a, 0xfa, 0xab, 0x7c, 0x1a, 0x40, + 0xd3, 0x77, 0x1a, 0x00, 0xd4, 0x78, 0x1a, 0x00, 0xd5, 0x79, 0x1a, 0x40, + 0x43, 0x54, 0x79, 0xa9, 0x1a, 0x40, 0x43, 0x1c, 0x01, 0xac, 0x1a, 0x00, + 0x42, 0x8b, 0x6c, 0xa4, 0x1a, 0x40, 0xe1, 0x4b, 0x1a, 0x00, 0x42, 0x16, + 0x00, 0x37, 0x1a, 0x00, 0x42, 0x7b, 0x08, 0x2f, 0x1a, 0x00, 0x42, 0x27, + 0x01, 0x51, 0x1a, 0x00, 0x48, 0x2f, 0xcc, 0x54, 0x1a, 0x00, 0x05, 0xb4, + 0x0b, 0xbf, 0x01, 0xe9, 0x4d, 0x1a, 0x80, 0xb5, 0x01, 0xac, 0x46, 0x42, + 0x6c, 0x00, 0x3e, 0x1a, 0x00, 0xae, 0x2e, 0x42, 0xcd, 0x02, 0x52, 0x1a, + 0x00, 0xb2, 0x0f, 0xf5, 0x4f, 0x1a, 0x80, 0x06, 0x42, 0xa9, 0x01, 0x45, + 0x1a, 0x40, 0xf5, 0x50, 0x1a, 0x40, 0xe1, 0x41, 0x1a, 0x80, 0x06, 0x42, + 0x5c, 0x0a, 0x42, 0x1a, 0x40, 0x42, 0x2a, 0x05, 0x31, 0x1a, 0x00, 0x42, + 0x12, 0x00, 0x2d, 0x1a, 0x40, 0xe1, 0x36, 0x1a, 0x00, 0x42, 0x24, 0x02, + 0x26, 0x1a, 0x00, 0x42, 0xdf, 0x23, 0x2c, 0x1a, 0x40, 0xe1, 0x43, 0x1a, + 0x80, 0x64, 0x42, 0x74, 0x00, 0x4a, 0x1a, 0x00, 0x03, 0xd1, 0x00, 0x06, + 0x42, 0x5c, 0x0a, 0x44, 0x1a, 0x40, 0xa3, 0x48, 0x42, 0x0c, 0x08, 0x3c, + 0x1a, 0x00, 0x42, 0x22, 0x00, 0x4c, 0x1a, 0x00, 0xab, 0x2a, 0xb0, 0x1e, + 0x45, 0xf8, 0x44, 0x30, 0x1a, 0x00, 0x42, 0x40, 0x06, 0x2a, 0x1a, 0x00, + 0xb4, 0x06, 0x42, 0xdf, 0x23, 0x3f, 0x1a, 0x40, 0xe1, 0x34, 0x1a, 0x00, + 0x42, 0x22, 0x00, 0x35, 0x1a, 0x40, 0xe1, 0x3b, 0x1a, 0x00, 0x42, 0x22, + 0x00, 0x3d, 0x1a, 0x40, 0xe1, 0x23, 0x1a, 0x00, 0x42, 0x22, 0x00, 0x25, + 0x1a, 0x00, 0x42, 0x5b, 0x28, 0x24, 0x1a, 0x40, 0xe1, 0x29, 0x1a, 0x00, + 0x42, 0x22, 0x00, 0x2b, 0x1a, 0x40, 0xe5, 0x53, 0x1a, 0x40, 0xe9, 0x4e, + 0x1a, 0x40, 0xa3, 0x54, 0x42, 0x0c, 0x08, 0x3a, 0x1a, 0x00, 0x42, 0x22, + 0x00, 0x49, 0x1a, 0x00, 0xab, 0x36, 0xb0, 0x2a, 0x45, 0xf8, 0x44, 0x2e, + 0x1a, 0x00, 0xb3, 0x12, 0xb4, 0x06, 0x42, 0xdf, 0x23, 0x40, 0x1a, 0x40, + 0xe1, 0x32, 0x1a, 0x00, 0x42, 0x22, 0x00, 0x33, 0x1a, 0x40, 0xe1, 0x48, + 0x1a, 0x00, 0x42, 0x22, 0x00, 0x46, 0x1a, 0x00, 0x42, 0x40, 0x06, 0x47, + 0x1a, 0x40, 0xe1, 0x38, 0x1a, 0x00, 0x42, 0x22, 0x00, 0x39, 0x1a, 0x40, + 0xe1, 0x20, 0x1a, 0x00, 0x42, 0x22, 0x00, 0x21, 0x1a, 0x00, 0x42, 0x5b, + 0x28, 0x22, 0x1a, 0x40, 0xe1, 0x27, 0x1a, 0x00, 0x42, 0x22, 0x00, 0x28, + 0x1a, 0x40, 0x45, 0x7e, 0x0b, 0x88, 0x1a, 0x00, 0xa6, 0x2e, 0x44, 0x6d, + 0x2c, 0x89, 0x1a, 0x00, 0x43, 0x7a, 0x0b, 0x81, 0x1a, 0x00, 0xb3, 0x14, + 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x80, 0x1a, 0x40, 0x44, 0x25, 0x01, 0x83, + 0x1a, 0x00, 0x42, 0x15, 0x02, 0x82, 0x1a, 0x40, 0x44, 0x06, 0x1f, 0x87, + 0x1a, 0x00, 0x42, 0x09, 0x24, 0x86, 0x1a, 0x40, 0x43, 0xf9, 0x05, 0x85, + 0x1a, 0x00, 0x43, 0xf6, 0x06, 0x84, 0x1a, 0x40, 0x59, 0x38, 0x26, 0x7f, + 0x1a, 0x00, 0x0d, 0x0b, 0x35, 0x01, 0xff, 0x42, 0x16, 0x00, 0x5d, 0x1a, + 0x00, 0x49, 0x82, 0xbe, 0x59, 0x1a, 0x00, 0x54, 0xf3, 0x44, 0x5b, 0x1a, + 0x00, 0xac, 0x1d, 0xad, 0x06, 0x42, 0x40, 0x06, 0x5e, 0x1a, 0x40, 0xe1, + 0x5c, 0x1a, 0x00, 0x06, 0x19, 0x35, 0x01, 0xff, 0x42, 0x74, 0x00, 0x56, + 0x1a, 0x00, 0x42, 0x71, 0x00, 0x55, 0x1a, 0x40, 0x4a, 0x86, 0xac, 0x57, + 0x1a, 0x00, 0x45, 0x88, 0x37, 0x5a, 0x1a, 0x40, 0xe1, 0x63, 0x19, 0x80, + 0xb0, 0x01, 0xe5, 0x6b, 0x19, 0x80, 0xa2, 0x01, 0x42, 0x0c, 0x08, 0x5c, + 0x19, 0x00, 0x42, 0x22, 0x00, 0x5e, 0x19, 0x00, 0xe9, 0x64, 0x19, 0x00, + 0xab, 0x85, 0x01, 0x42, 0x74, 0x00, 0x58, 0x19, 0x00, 0x42, 0x6c, 0x00, + 0x5b, 0x19, 0x00, 0xae, 0x6d, 0xef, 0x69, 0x19, 0x80, 0x64, 0xb0, 0x58, + 0x42, 0x11, 0x15, 0x5f, 0x19, 0x00, 0x42, 0x40, 0x06, 0x54, 0x19, 0x00, + 0xb4, 0x1b, 0xf5, 0x67, 0x19, 0x80, 0x12, 0x42, 0x61, 0x0b, 0x5d, 0x19, + 0x00, 0x42, 0x5b, 0x28, 0x51, 0x19, 0x00, 0x42, 0xdf, 0x23, 0x55, 0x19, + 0x40, 0xe5, 0x6a, 0x19, 0x40, 0xe1, 0x56, 0x19, 0x00, 0x42, 0x22, 0x00, + 0x57, 0x19, 0x00, 0x04, 0x23, 0x21, 0x0d, 0xb3, 0x01, 0xff, 0xe1, 0x53, + 0x19, 0x00, 0x42, 0x22, 0x00, 0x61, 0x19, 0x40, 0xd2, 0x70, 0x19, 0x00, + 0xd3, 0x71, 0x19, 0x00, 0xd4, 0x72, 0x19, 0x00, 0xd5, 0x73, 0x19, 0x00, + 0xd6, 0x74, 0x19, 0x40, 0xe1, 0x59, 0x19, 0x00, 0x42, 0x22, 0x00, 0x5a, + 0x19, 0x40, 0xef, 0x68, 0x19, 0x40, 0xe1, 0x62, 0x19, 0x00, 0x42, 0x24, + 0x02, 0x52, 0x19, 0x40, 0xe1, 0x50, 0x19, 0x00, 0x42, 0x22, 0x00, 0x60, + 0x19, 0x40, 0xe5, 0x65, 0x19, 0x00, 0xe8, 0x66, 0x19, 0x40, 0xe9, 0x6d, + 0x19, 0x00, 0x42, 0x5c, 0x0a, 0x6c, 0x19, 0x40, 0x80, 0x82, 0x02, 0x05, + 0x3a, 0xea, 0x70, 0x06, 0x00, 0xe0, 0x01, 0xff, 0x07, 0x13, 0x06, 0x0d, + 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xe9, 0x72, 0x17, 0x00, 0xf5, 0x73, 0x17, + 0x40, 0xe1, 0x60, 0x17, 0x00, 0x42, 0x16, 0x00, 0x6a, 0x17, 0x00, 0x42, + 0x7b, 0x08, 0x67, 0x17, 0x00, 0x42, 0x24, 0x02, 0x64, 0x17, 0x00, 0xe9, + 0x61, 0x17, 0x00, 0x42, 0x1b, 0x02, 0x63, 0x17, 0x00, 0x42, 0x74, 0x00, + 0x6e, 0x17, 0x00, 0x42, 0x6c, 0x00, 0x6b, 0x17, 0x00, 0xae, 0x22, 0x42, + 0xe0, 0x09, 0x69, 0x17, 0x00, 0x42, 0x40, 0x06, 0x70, 0x17, 0x00, 0x42, + 0x12, 0x00, 0x66, 0x17, 0x00, 0xf5, 0x62, 0x17, 0x00, 0x42, 0xa9, 0x01, + 0x6f, 0x17, 0x00, 0x42, 0xdf, 0x23, 0x6c, 0x17, 0x40, 0xe1, 0x68, 0x17, + 0x00, 0x42, 0x24, 0x02, 0x65, 0x17, 0x40, 0x07, 0x13, 0x06, 0x1d, 0x05, + 0x5a, 0x03, 0x0d, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xe9, 0x12, 0x17, 0x00, + 0xf5, 0x13, 0x17, 0x40, 0x48, 0x40, 0x8d, 0x15, 0x17, 0x00, 0x46, 0x1f, + 0x25, 0x14, 0x17, 0x40, 0xe1, 0x00, 0x17, 0x80, 0x62, 0x42, 0x16, 0x00, + 0x0a, 0x17, 0x00, 0x42, 0x7b, 0x08, 0x07, 0x17, 0x00, 0x42, 0x24, 0x02, + 0x04, 0x17, 0x00, 0x42, 0x22, 0x00, 0x11, 0x17, 0x00, 0xe9, 0x01, 0x17, + 0x00, 0x42, 0x1b, 0x02, 0x03, 0x17, 0x00, 0x42, 0x74, 0x00, 0x0e, 0x17, + 0x00, 0x42, 0x6c, 0x00, 0x0b, 0x17, 0x00, 0xae, 0x28, 0x42, 0xe0, 0x09, + 0x09, 0x17, 0x00, 0x42, 0x71, 0x00, 0x0d, 0x17, 0x00, 0x42, 0x40, 0x06, + 0x10, 0x17, 0x00, 0x42, 0x12, 0x00, 0x06, 0x17, 0x00, 0xf5, 0x02, 0x17, + 0x00, 0x42, 0xa9, 0x01, 0x0f, 0x17, 0x00, 0x42, 0xdf, 0x23, 0x0c, 0x17, + 0x40, 0xe1, 0x08, 0x17, 0x00, 0x42, 0x24, 0x02, 0x05, 0x17, 0x40, 0x49, + 0x3d, 0xc4, 0x1f, 0x17, 0x40, 0xa1, 0x82, 0x04, 0xa3, 0xe1, 0x03, 0xa4, + 0x92, 0x03, 0xa5, 0x83, 0x03, 0x49, 0x4f, 0x17, 0x2e, 0x00, 0x0e, 0x02, + 0x87, 0x00, 0xec, 0x02, 0x4c, 0x70, 0x94, 0x2d, 0x00, 0x0e, 0xac, 0x63, + 0x4b, 0x6d, 0xa5, 0x23, 0x00, 0x0e, 0xb0, 0x4f, 0x02, 0x7c, 0x00, 0x3f, + 0xb2, 0x20, 0xb3, 0x0c, 0x45, 0x71, 0x24, 0x7e, 0x00, 0x0e, 0x4d, 0x39, + 0x0c, 0x7c, 0x00, 0x4e, 0x48, 0x5b, 0x5c, 0x3b, 0x00, 0x0e, 0x46, 0x1c, + 0x33, 0x2f, 0x00, 0x0e, 0x44, 0x2e, 0x4f, 0x20, 0x00, 0x4e, 0x4e, 0xa9, + 0x75, 0x5c, 0x00, 0x0e, 0x05, 0xc9, 0x00, 0x01, 0xff, 0x4d, 0xde, 0x0b, + 0x7d, 0x00, 0x0e, 0x4b, 0xfb, 0x22, 0x29, 0x00, 0x0e, 0x4e, 0x36, 0x28, + 0x5d, 0x00, 0x4e, 0x4b, 0x8a, 0x36, 0x3f, 0x00, 0x0e, 0x4c, 0x1b, 0x05, + 0x22, 0x00, 0x4e, 0x4b, 0x00, 0xa1, 0x25, 0x00, 0x0e, 0x48, 0x22, 0x75, + 0x2b, 0x00, 0x4e, 0x05, 0x06, 0x06, 0x24, 0xa5, 0x06, 0x47, 0x08, 0x8f, + 0x5f, 0x00, 0x4e, 0x03, 0xc5, 0x00, 0x06, 0x4c, 0x64, 0x9a, 0x3c, 0x00, + 0x4e, 0x4d, 0xde, 0x0b, 0x7b, 0x00, 0x0e, 0x4b, 0xfb, 0x22, 0x28, 0x00, + 0x0e, 0x4e, 0x36, 0x28, 0x5b, 0x00, 0x4e, 0x0f, 0x0b, 0x06, 0x6d, 0x0d, + 0x9b, 0x08, 0x01, 0xff, 0xe1, 0x61, 0x00, 0x0e, 0xe2, 0x62, 0x00, 0x0e, + 0xe3, 0x63, 0x00, 0x0e, 0xe4, 0x64, 0x00, 0x0e, 0xe5, 0x65, 0x00, 0x0e, + 0xe6, 0x66, 0x00, 0x0e, 0xe7, 0x67, 0x00, 0x0e, 0xe8, 0x68, 0x00, 0x0e, + 0xe9, 0x69, 0x00, 0x0e, 0xea, 0x6a, 0x00, 0x0e, 0xeb, 0x6b, 0x00, 0x0e, + 0xec, 0x6c, 0x00, 0x0e, 0xed, 0x6d, 0x00, 0x0e, 0xee, 0x6e, 0x00, 0x0e, + 0xef, 0x6f, 0x00, 0x0e, 0xf0, 0x70, 0x00, 0x0e, 0xf1, 0x71, 0x00, 0x0e, + 0xf2, 0x72, 0x00, 0x0e, 0xf3, 0x73, 0x00, 0x0e, 0xf4, 0x74, 0x00, 0x0e, + 0xf5, 0x75, 0x00, 0x0e, 0xf6, 0x76, 0x00, 0x0e, 0xf7, 0x77, 0x00, 0x0e, + 0xf8, 0x78, 0x00, 0x0e, 0xf9, 0x79, 0x00, 0x0e, 0xfa, 0x7a, 0x00, 0x4e, + 0xe1, 0x41, 0x00, 0x0e, 0xe2, 0x42, 0x00, 0x0e, 0xe3, 0x43, 0x00, 0x0e, + 0xe4, 0x44, 0x00, 0x0e, 0xe5, 0x45, 0x00, 0x0e, 0xe6, 0x46, 0x00, 0x0e, + 0xe7, 0x47, 0x00, 0x0e, 0xe8, 0x48, 0x00, 0x0e, 0xe9, 0x49, 0x00, 0x0e, + 0xea, 0x4a, 0x00, 0x0e, 0xeb, 0x4b, 0x00, 0x0e, 0xec, 0x4c, 0x00, 0x0e, + 0xed, 0x4d, 0x00, 0x0e, 0xee, 0x4e, 0x00, 0x0e, 0xef, 0x4f, 0x00, 0x0e, + 0xf0, 0x50, 0x00, 0x0e, 0xf1, 0x51, 0x00, 0x0e, 0xf2, 0x52, 0x00, 0x0e, + 0xf3, 0x53, 0x00, 0x0e, 0xf4, 0x54, 0x00, 0x0e, 0xf5, 0x55, 0x00, 0x0e, + 0xf6, 0x56, 0x00, 0x0e, 0xf7, 0x57, 0x00, 0x0e, 0xf8, 0x58, 0x00, 0x0e, + 0xf9, 0x59, 0x00, 0x0e, 0xfa, 0x5a, 0x00, 0x4e, 0x4a, 0x53, 0x24, 0x60, + 0x00, 0x0e, 0x4f, 0xe5, 0x5c, 0x3e, 0x00, 0x4e, 0x4a, 0x17, 0x14, 0x3d, + 0x00, 0x0e, 0x4f, 0xae, 0x00, 0x21, 0x00, 0x4e, 0x05, 0xf0, 0x06, 0x06, + 0x4a, 0x30, 0xa0, 0x24, 0x00, 0x4e, 0x45, 0x7e, 0x0b, 0x38, 0x00, 0x0e, + 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x39, 0x00, 0x0e, 0x43, 0x7a, 0x0b, 0x31, + 0x00, 0x0e, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x30, 0x00, 0x4e, + 0x44, 0x25, 0x01, 0x33, 0x00, 0x0e, 0x42, 0x15, 0x02, 0x32, 0x00, 0x4e, + 0x44, 0x06, 0x1f, 0x37, 0x00, 0x0e, 0x42, 0x09, 0x24, 0x36, 0x00, 0x4e, + 0x43, 0xf9, 0x05, 0x35, 0x00, 0x0e, 0x43, 0xf6, 0x06, 0x34, 0x00, 0x4e, + 0x50, 0xd0, 0x04, 0x5e, 0x00, 0x0e, 0xaf, 0x01, 0xff, 0x43, 0xd7, 0x02, + 0x3a, 0x00, 0x0e, 0x02, 0x15, 0x05, 0x01, 0xff, 0xe1, 0x2c, 0x00, 0x0e, + 0x49, 0x1f, 0xbe, 0x40, 0x00, 0x4e, 0x48, 0x36, 0x40, 0x26, 0x00, 0x0e, + 0x49, 0x5a, 0x38, 0x27, 0x00, 0x0e, 0x47, 0xcb, 0x0d, 0x2a, 0x00, 0x4e, + 0x59, 0xd4, 0x25, 0xd3, 0xf3, 0x41, 0x43, 0x96, 0xfa, 0x96, 0xf9, 0x01, + 0x45, 0xb0, 0x4c, 0x55, 0xf4, 0x41, 0x4c, 0xa8, 0x8f, 0xcc, 0x29, 0x00, + 0xa1, 0x9b, 0x86, 0x01, 0xa3, 0xf9, 0x84, 0x01, 0xa5, 0x89, 0x80, 0x01, + 0x42, 0x1b, 0x29, 0x99, 0x00, 0x00, 0xa8, 0x95, 0x76, 0xe9, 0x0f, 0x00, + 0x80, 0xca, 0x3e, 0xab, 0x9d, 0x3e, 0xac, 0xf3, 0x3c, 0xad, 0xb3, 0x38, + 0xae, 0xf1, 0x37, 0xef, 0x0e, 0x00, 0x80, 0x8a, 0x2d, 0xf0, 0x20, 0x00, + 0x80, 0x8c, 0x2b, 0x02, 0x7c, 0x00, 0xe5, 0x18, 0xb3, 0xd6, 0x18, 0xf4, 0x9c, 0x00, 0x80, 0xfb, 0x15, 0xb5, 0xab, 0x0a, 0xb7, 0x90, 0x0a, 0xb9, - 0x01, 0xff, 0x0b, 0x0f, 0x9f, 0xfd, 0x07, 0xad, 0xb5, 0x05, 0xee, 0x16, - 0x00, 0x80, 0xa3, 0x05, 0x02, 0x0d, 0x00, 0x01, 0xff, 0x03, 0x55, 0x73, - 0x06, 0x43, 0xda, 0x09, 0x89, 0xf4, 0x41, 0x51, 0x12, 0x50, 0x0f, 0x07, - 0x00, 0x47, 0x7d, 0xcf, 0x4a, 0x07, 0x00, 0x02, 0x13, 0x05, 0xed, 0x04, - 0x0d, 0x17, 0x82, 0xdc, 0x04, 0xa5, 0xc2, 0x04, 0x4c, 0xec, 0x8e, 0x40, - 0x07, 0x00, 0xa8, 0x85, 0x04, 0x07, 0xec, 0x05, 0xca, 0x01, 0x45, 0x1c, - 0x28, 0x49, 0x07, 0x00, 0x0d, 0xc3, 0x86, 0xb3, 0x01, 0x07, 0x0a, 0xd5, - 0x9c, 0x01, 0x49, 0x7c, 0xbe, 0x41, 0x07, 0x00, 0xb2, 0x78, 0x02, 0x6f, - 0x00, 0x3a, 0xb4, 0x17, 0x07, 0x13, 0xd8, 0x01, 0xff, 0x45, 0x5c, 0x00, - 0x33, 0x07, 0x00, 0x45, 0x20, 0x07, 0x34, 0x07, 0x00, 0x46, 0xb2, 0x1f, - 0x35, 0x07, 0x40, 0x0a, 0xae, 0x12, 0x11, 0x11, 0xb9, 0x5f, 0x01, 0xff, + 0x01, 0xff, 0x0b, 0x18, 0xa4, 0xfd, 0x07, 0xad, 0xb5, 0x05, 0xee, 0x16, + 0x00, 0x80, 0xa3, 0x05, 0x02, 0x0d, 0x00, 0x01, 0xff, 0x03, 0x81, 0x76, + 0x06, 0x43, 0xff, 0x09, 0x89, 0xf4, 0x41, 0x51, 0x55, 0x52, 0x0f, 0x07, + 0x00, 0x47, 0x23, 0xd5, 0x4a, 0x07, 0x00, 0x02, 0x13, 0x05, 0xed, 0x04, + 0x0d, 0x1f, 0x86, 0xdc, 0x04, 0xa5, 0xc2, 0x04, 0x4c, 0x8c, 0x93, 0x40, + 0x07, 0x00, 0xa8, 0x85, 0x04, 0x07, 0x13, 0x06, 0xca, 0x01, 0x45, 0x6f, + 0x29, 0x49, 0x07, 0x00, 0x0d, 0xff, 0x8a, 0xb3, 0x01, 0x07, 0xd3, 0xda, + 0x9c, 0x01, 0x49, 0x22, 0xc4, 0x41, 0x07, 0x00, 0xb2, 0x78, 0x02, 0x6f, + 0x00, 0x3a, 0xb4, 0x17, 0x07, 0xe3, 0xdd, 0x01, 0xff, 0x45, 0x5c, 0x00, + 0x33, 0x07, 0x00, 0x45, 0x20, 0x07, 0x34, 0x07, 0x00, 0x46, 0xd3, 0x20, + 0x35, 0x07, 0x40, 0x0a, 0x7c, 0x13, 0x11, 0x11, 0x66, 0x62, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x43, 0x07, 0x00, 0x45, 0x20, 0x07, 0x44, 0x07, 0x40, 0x45, 0x5c, 0x00, 0x45, 0x07, 0x00, 0x45, 0x20, 0x07, 0x46, 0x07, 0x40, - 0x08, 0x59, 0xc4, 0x18, 0x0a, 0xea, 0xaf, 0x01, 0xff, 0x45, 0xaf, 0x3b, - 0x03, 0x07, 0x80, 0x06, 0x49, 0x81, 0x16, 0x01, 0x07, 0x40, 0x4c, 0x98, - 0x8b, 0x08, 0x07, 0x40, 0x45, 0xaf, 0x3b, 0x04, 0x07, 0x80, 0x06, 0x49, - 0x81, 0x16, 0x02, 0x07, 0x40, 0x08, 0x98, 0x8b, 0x01, 0xff, 0x44, 0xc3, - 0x00, 0x09, 0x07, 0x00, 0x45, 0xc8, 0x00, 0x09, 0x07, 0x40, 0x05, 0xc7, - 0xe4, 0x0c, 0x47, 0xd1, 0xd6, 0x42, 0x07, 0x00, 0x44, 0x41, 0xf3, 0x3f, + 0x08, 0xe7, 0xc9, 0x18, 0x0a, 0x64, 0xb5, 0x01, 0xff, 0x45, 0xb7, 0x3d, + 0x03, 0x07, 0x80, 0x06, 0x49, 0x4f, 0x17, 0x01, 0x07, 0x40, 0x4c, 0x14, + 0x90, 0x08, 0x07, 0x40, 0x45, 0xb7, 0x3d, 0x04, 0x07, 0x80, 0x06, 0x49, + 0x4f, 0x17, 0x02, 0x07, 0x40, 0x08, 0x14, 0x90, 0x01, 0xff, 0x44, 0xc3, + 0x00, 0x09, 0x07, 0x00, 0x45, 0xc8, 0x00, 0x09, 0x07, 0x40, 0x05, 0xa3, + 0xea, 0x0c, 0x47, 0xa1, 0xdc, 0x42, 0x07, 0x00, 0x44, 0x18, 0xf9, 0x3f, 0x07, 0x40, 0x45, 0x5c, 0x00, 0x36, 0x07, 0x00, 0x45, 0x20, 0x07, 0x37, 0x07, 0x40, 0x45, 0x5c, 0x00, 0x30, 0x07, 0x00, 0x45, 0x20, 0x07, 0x31, - 0x07, 0x00, 0x46, 0xb2, 0x1f, 0x32, 0x07, 0x40, 0x45, 0x5c, 0x00, 0x47, - 0x07, 0x00, 0x45, 0x20, 0x07, 0x48, 0x07, 0x40, 0x45, 0x48, 0x68, 0x10, - 0x07, 0x00, 0x44, 0x61, 0xef, 0x12, 0x07, 0x00, 0xa4, 0x9b, 0x02, 0xe5, - 0x25, 0x07, 0x00, 0x4d, 0x01, 0x83, 0x24, 0x07, 0x00, 0x45, 0xac, 0xe6, + 0x07, 0x00, 0x46, 0xd3, 0x20, 0x32, 0x07, 0x40, 0x45, 0x5c, 0x00, 0x47, + 0x07, 0x00, 0x45, 0x20, 0x07, 0x48, 0x07, 0x40, 0x45, 0x55, 0x6b, 0x10, + 0x07, 0x00, 0x44, 0x20, 0xf5, 0x12, 0x07, 0x00, 0xa4, 0x9b, 0x02, 0xe5, + 0x25, 0x07, 0x00, 0x4d, 0xfc, 0x86, 0x24, 0x07, 0x00, 0x45, 0x7e, 0xec, 0x13, 0x07, 0x80, 0x83, 0x02, 0x42, 0xb0, 0x01, 0x17, 0x07, 0x80, 0xf5, - 0x01, 0x44, 0xed, 0xf0, 0x1f, 0x07, 0x00, 0x46, 0xae, 0xdd, 0x20, 0x07, - 0x00, 0xad, 0x96, 0x01, 0x43, 0xde, 0x22, 0x22, 0x07, 0x00, 0x42, 0x6f, - 0x02, 0x26, 0x07, 0x80, 0x72, 0x44, 0x14, 0xd8, 0x29, 0x07, 0x00, 0xb2, - 0x5e, 0xb3, 0x2e, 0xb4, 0x19, 0x43, 0x9f, 0x8a, 0x18, 0x07, 0x00, 0x44, - 0x69, 0xf3, 0x1d, 0x07, 0x80, 0x06, 0x44, 0x2e, 0x75, 0x19, 0x07, 0x40, - 0x43, 0x29, 0x15, 0x1e, 0x07, 0x40, 0x42, 0xd2, 0x2d, 0x2c, 0x07, 0x00, - 0x43, 0xf5, 0x25, 0x1b, 0x07, 0xc0, 0x00, 0x49, 0x80, 0xb4, 0x1c, 0x07, - 0x40, 0x44, 0xcc, 0xea, 0x28, 0x07, 0x00, 0x46, 0x08, 0x83, 0x23, 0x07, - 0x00, 0x43, 0x7a, 0x16, 0x2b, 0x07, 0x00, 0x07, 0xe4, 0xd3, 0x06, 0x50, - 0x3d, 0x68, 0x11, 0x07, 0x40, 0x42, 0x28, 0x1a, 0x4f, 0x07, 0x00, 0x45, - 0xf6, 0xe7, 0x4e, 0x07, 0x00, 0x45, 0xc4, 0xec, 0x4d, 0x07, 0x40, 0x4a, - 0x54, 0xaa, 0x27, 0x07, 0x00, 0x43, 0xd1, 0x0c, 0x2a, 0x07, 0x40, 0x06, - 0xd6, 0xdf, 0x01, 0xff, 0x45, 0xe5, 0xe4, 0x2d, 0x07, 0x00, 0x47, 0x6b, - 0xd0, 0x2f, 0x07, 0x00, 0x46, 0x1c, 0xdc, 0x2e, 0x07, 0x40, 0x09, 0x0c, - 0xb6, 0x06, 0x42, 0x29, 0x02, 0x21, 0x07, 0x40, 0x43, 0xf4, 0x2a, 0x66, - 0x08, 0x00, 0x42, 0x72, 0x19, 0x61, 0x08, 0x00, 0x02, 0x60, 0x07, 0x2c, - 0xae, 0x12, 0x42, 0x71, 0x00, 0x67, 0x08, 0x00, 0x43, 0xfd, 0x20, 0x6a, - 0x08, 0x00, 0x43, 0xec, 0x28, 0x63, 0x08, 0x40, 0x42, 0x24, 0x02, 0x60, - 0x08, 0x00, 0xae, 0x06, 0x42, 0xbe, 0x22, 0x62, 0x08, 0x40, 0xe1, 0x64, + 0x01, 0x44, 0xb0, 0xf6, 0x1f, 0x07, 0x00, 0x46, 0x84, 0xe3, 0x20, 0x07, + 0x00, 0xad, 0x96, 0x01, 0x43, 0x18, 0x24, 0x22, 0x07, 0x00, 0x42, 0x6f, + 0x02, 0x26, 0x07, 0x80, 0x72, 0x44, 0xe4, 0xdd, 0x29, 0x07, 0x00, 0xb2, + 0x5e, 0xb3, 0x2e, 0xb4, 0x19, 0x43, 0x1c, 0x8f, 0x18, 0x07, 0x00, 0x44, + 0x44, 0xf9, 0x1d, 0x07, 0x80, 0x06, 0x44, 0x5a, 0x78, 0x19, 0x07, 0x40, + 0x43, 0xf7, 0x15, 0x1e, 0x07, 0x40, 0x42, 0x3e, 0x2f, 0x2c, 0x07, 0x00, + 0x43, 0x48, 0x27, 0x1b, 0x07, 0xc0, 0x00, 0x49, 0xe7, 0xb9, 0x1c, 0x07, + 0x40, 0x44, 0x94, 0xf0, 0x28, 0x07, 0x00, 0x46, 0x03, 0x87, 0x23, 0x07, + 0x00, 0x43, 0x48, 0x17, 0x2b, 0x07, 0x00, 0x07, 0xad, 0xd9, 0x06, 0x50, + 0x4a, 0x6b, 0x11, 0x07, 0x40, 0x42, 0x2e, 0x1b, 0x4f, 0x07, 0x00, 0x45, + 0xcd, 0xed, 0x4e, 0x07, 0x00, 0x45, 0x87, 0xf2, 0x4d, 0x07, 0x40, 0x4a, + 0x9c, 0xaf, 0x27, 0x07, 0x00, 0x43, 0x5f, 0x0d, 0x2a, 0x07, 0x40, 0x06, + 0xb8, 0xe5, 0x01, 0xff, 0x45, 0xbc, 0xea, 0x2d, 0x07, 0x00, 0x47, 0x11, + 0xd6, 0x2f, 0x07, 0x00, 0x46, 0xec, 0xe1, 0x2e, 0x07, 0x40, 0x09, 0x73, + 0xbb, 0x06, 0x42, 0x29, 0x02, 0x21, 0x07, 0x40, 0x43, 0x77, 0x2c, 0x66, + 0x08, 0x00, 0x42, 0x78, 0x1a, 0x61, 0x08, 0x00, 0x02, 0x60, 0x07, 0x2c, + 0xae, 0x12, 0x42, 0x71, 0x00, 0x67, 0x08, 0x00, 0x43, 0x1e, 0x22, 0x6a, + 0x08, 0x00, 0x43, 0x6f, 0x2a, 0x63, 0x08, 0x40, 0x42, 0x24, 0x02, 0x60, + 0x08, 0x00, 0xae, 0x06, 0x42, 0xdf, 0x23, 0x62, 0x08, 0x40, 0xe1, 0x64, 0x08, 0x00, 0x42, 0x2a, 0x05, 0x65, 0x08, 0x40, 0xe1, 0x68, 0x08, 0x00, 0x42, 0x74, 0x00, 0x69, 0x08, 0x40, 0x42, 0x53, 0x00, 0x1a, 0x07, 0x40, - 0x49, 0x80, 0xb4, 0x14, 0x07, 0x40, 0x45, 0x40, 0x54, 0x15, 0x07, 0x00, - 0x52, 0x38, 0x54, 0x16, 0x07, 0x40, 0x08, 0xa1, 0xc3, 0x1e, 0x04, 0x2d, - 0x81, 0x06, 0x4f, 0x6e, 0x71, 0x05, 0x07, 0x40, 0x80, 0x06, 0x4d, 0x1c, - 0x80, 0x3c, 0x07, 0x40, 0x45, 0x5c, 0x00, 0x3a, 0x07, 0x00, 0x45, 0x20, - 0x07, 0x3b, 0x07, 0x40, 0x4a, 0x10, 0xa8, 0x0d, 0x07, 0x00, 0x49, 0x21, - 0xbc, 0x0c, 0x07, 0x00, 0x46, 0x24, 0xbc, 0x0b, 0x07, 0x40, 0x4f, 0x9c, - 0x70, 0x00, 0x07, 0x00, 0x05, 0x1e, 0x80, 0x01, 0xff, 0x45, 0x5c, 0x00, + 0x49, 0xe7, 0xb9, 0x14, 0x07, 0x40, 0x45, 0x95, 0x56, 0x15, 0x07, 0x00, + 0x52, 0x8d, 0x56, 0x16, 0x07, 0x40, 0x08, 0x37, 0xc9, 0x1e, 0x04, 0x28, + 0x85, 0x06, 0x4f, 0x9a, 0x74, 0x05, 0x07, 0x40, 0x80, 0x06, 0x4d, 0xf0, + 0x83, 0x3c, 0x07, 0x40, 0x45, 0x5c, 0x00, 0x3a, 0x07, 0x00, 0x45, 0x20, + 0x07, 0x3b, 0x07, 0x40, 0x4a, 0x4e, 0xad, 0x0d, 0x07, 0x00, 0x49, 0xbe, + 0xc1, 0x0c, 0x07, 0x00, 0x46, 0xc1, 0xc1, 0x0b, 0x07, 0x40, 0x4f, 0xb9, + 0x73, 0x00, 0x07, 0x00, 0x05, 0xf2, 0x83, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x3d, 0x07, 0x00, 0x45, 0x20, 0x07, 0x3e, 0x07, 0x40, 0x47, 0x1c, 0x01, - 0x39, 0x07, 0x00, 0x4a, 0x0b, 0x00, 0x38, 0x07, 0x40, 0x0b, 0xee, 0x9e, - 0x06, 0x49, 0xd5, 0xbc, 0x0a, 0x07, 0x40, 0x44, 0xc3, 0x00, 0x06, 0x07, - 0x00, 0x45, 0xc8, 0x00, 0x07, 0x07, 0x40, 0x46, 0xac, 0xd9, 0x4d, 0xf5, - 0x01, 0x4d, 0x12, 0x75, 0x16, 0x00, 0x40, 0x08, 0x6a, 0x32, 0x06, 0x45, - 0xbe, 0xe8, 0x2f, 0x23, 0x40, 0x4b, 0xed, 0x51, 0x06, 0x24, 0x00, 0xa2, + 0x39, 0x07, 0x00, 0x4a, 0x0b, 0x00, 0x38, 0x07, 0x40, 0x0b, 0xf7, 0xa3, + 0x06, 0x49, 0x72, 0xc2, 0x0a, 0x07, 0x40, 0x44, 0xc3, 0x00, 0x06, 0x07, + 0x00, 0x45, 0xc8, 0x00, 0x07, 0x07, 0x40, 0x46, 0x7c, 0xdf, 0x4d, 0xf5, + 0x01, 0x4d, 0x3e, 0x78, 0x16, 0x00, 0x40, 0x08, 0x1b, 0x34, 0x06, 0x45, + 0x90, 0xee, 0x2f, 0x23, 0x40, 0x4b, 0x54, 0x54, 0x06, 0x24, 0x00, 0xa2, 0xa6, 0x02, 0x02, 0x37, 0x00, 0x95, 0x02, 0xa4, 0xc7, 0x01, 0xa5, 0x96, - 0x01, 0xa6, 0x87, 0x01, 0x4f, 0xbd, 0x6d, 0x1d, 0x24, 0x00, 0x55, 0xf3, - 0x3b, 0x09, 0x24, 0x00, 0x49, 0xd0, 0x20, 0x0a, 0x24, 0x00, 0x4d, 0xb2, - 0x85, 0x45, 0xf5, 0x01, 0xae, 0x59, 0x50, 0x5d, 0x66, 0x1e, 0x24, 0x00, - 0xb3, 0x12, 0x52, 0xfa, 0x55, 0x97, 0x2b, 0x00, 0x4e, 0x1a, 0x7e, 0x1f, - 0x24, 0x00, 0x53, 0xdd, 0x4e, 0x0b, 0x24, 0x40, 0x4f, 0xc0, 0x6a, 0x4f, - 0x21, 0x00, 0x05, 0xfd, 0xab, 0x29, 0x44, 0xd8, 0x4c, 0x20, 0x24, 0x00, - 0x08, 0x74, 0x4d, 0x13, 0x49, 0x50, 0xc0, 0x1a, 0x24, 0x80, 0x06, 0x4f, - 0x10, 0x75, 0x16, 0x24, 0x40, 0x49, 0x3c, 0x2e, 0x26, 0x24, 0x40, 0x47, - 0x9f, 0xd1, 0x01, 0x24, 0x00, 0x44, 0x97, 0x30, 0x02, 0x24, 0x40, 0x42, + 0x01, 0xa6, 0x87, 0x01, 0x4f, 0xda, 0x70, 0x1d, 0x24, 0x00, 0x55, 0xfb, + 0x3d, 0x09, 0x24, 0x00, 0x49, 0xf1, 0x21, 0x0a, 0x24, 0x00, 0x4d, 0xd4, + 0x89, 0x45, 0xf5, 0x01, 0xae, 0x59, 0x50, 0x6a, 0x69, 0x1e, 0x24, 0x00, + 0xb3, 0x12, 0x52, 0x85, 0x58, 0x97, 0x2b, 0x00, 0x4e, 0xee, 0x81, 0x1f, + 0x24, 0x00, 0x53, 0x20, 0x51, 0x0b, 0x24, 0x40, 0x4f, 0xdd, 0x6d, 0x4f, + 0x21, 0x00, 0x05, 0x59, 0xb1, 0x29, 0x44, 0x2e, 0x4f, 0x20, 0x24, 0x00, + 0x08, 0xca, 0x4f, 0x13, 0x49, 0xff, 0xc5, 0x1a, 0x24, 0x80, 0x06, 0x4f, + 0x3c, 0x78, 0x16, 0x24, 0x40, 0x49, 0xa8, 0x2f, 0x26, 0x24, 0x40, 0x47, + 0x53, 0xd7, 0x01, 0x24, 0x00, 0x44, 0x1a, 0x32, 0x02, 0x24, 0x40, 0x42, 0x9e, 0x01, 0x0f, 0x24, 0x00, 0x43, 0x28, 0x08, 0x0e, 0x24, 0x40, 0xa5, - 0x06, 0x43, 0x82, 0x16, 0x00, 0x24, 0x40, 0x52, 0xe6, 0x51, 0x15, 0x24, - 0x00, 0x45, 0xcf, 0x20, 0x24, 0x24, 0x40, 0x4d, 0x39, 0x84, 0x1c, 0x24, - 0x00, 0x48, 0x89, 0xc9, 0x0c, 0x24, 0x40, 0xae, 0x06, 0x45, 0xf7, 0x6a, - 0x1b, 0x24, 0x40, 0x05, 0x42, 0x05, 0x06, 0x45, 0x3f, 0xea, 0x05, 0x24, + 0x06, 0x43, 0x50, 0x17, 0x00, 0x24, 0x40, 0x52, 0x4d, 0x54, 0x15, 0x24, + 0x00, 0x45, 0xf0, 0x21, 0x24, 0x24, 0x40, 0x4d, 0x41, 0x88, 0x1c, 0x24, + 0x00, 0x48, 0x1f, 0xcf, 0x0c, 0x24, 0x40, 0xae, 0x06, 0x45, 0x23, 0x6e, + 0x1b, 0x24, 0x40, 0x05, 0x42, 0x05, 0x06, 0x45, 0x0c, 0xf0, 0x05, 0x24, 0x40, 0x46, 0x44, 0x04, 0x19, 0x24, 0x00, 0xb4, 0x01, 0xff, 0x43, 0xd9, - 0x06, 0x03, 0x24, 0x00, 0x4b, 0xe5, 0xa1, 0x04, 0x24, 0xc0, 0x00, 0x46, - 0x32, 0x01, 0x17, 0x24, 0x40, 0x4f, 0xed, 0x6a, 0x10, 0x24, 0x00, 0xa5, - 0x01, 0xff, 0x44, 0x43, 0x7b, 0x21, 0x24, 0x80, 0x20, 0x0d, 0x5e, 0x8a, - 0x01, 0xff, 0x44, 0xf5, 0x06, 0x14, 0x24, 0x00, 0x43, 0x0e, 0x0b, 0x11, + 0x06, 0x03, 0x24, 0x00, 0x4b, 0xf9, 0xa6, 0x04, 0x24, 0xc0, 0x00, 0x46, + 0x32, 0x01, 0x17, 0x24, 0x40, 0x4f, 0x19, 0x6e, 0x10, 0x24, 0x00, 0xa5, + 0x01, 0xff, 0x44, 0xfb, 0x7e, 0x21, 0x24, 0x80, 0x20, 0x0d, 0xdb, 0x8e, + 0x01, 0xff, 0x44, 0xf5, 0x06, 0x14, 0x24, 0x00, 0x43, 0x7a, 0x0b, 0x11, 0x24, 0x00, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0x13, 0x24, 0x00, 0x42, - 0x15, 0x02, 0x12, 0x24, 0x40, 0x80, 0x01, 0xff, 0x48, 0x3d, 0x2e, 0x25, - 0x24, 0x00, 0x51, 0x34, 0x5c, 0x29, 0x24, 0x00, 0x5e, 0x61, 0x14, 0x28, - 0x24, 0x00, 0x59, 0x5c, 0x26, 0x27, 0x24, 0x40, 0x44, 0x20, 0x2c, 0x18, - 0x24, 0x00, 0x4d, 0x3c, 0x88, 0x0d, 0x24, 0x40, 0x48, 0x49, 0xc3, 0x08, - 0x24, 0x00, 0x43, 0x5f, 0x09, 0x07, 0x24, 0x40, 0x07, 0xec, 0x05, 0x4d, - 0x0c, 0xcc, 0x93, 0x39, 0x05, 0x5a, 0x03, 0x1b, 0x0b, 0x55, 0x77, 0x01, + 0x15, 0x02, 0x12, 0x24, 0x40, 0x80, 0x01, 0xff, 0x48, 0xa9, 0x2f, 0x25, + 0x24, 0x00, 0x51, 0xbf, 0x5e, 0x29, 0x24, 0x00, 0x5e, 0x2f, 0x15, 0x28, + 0x24, 0x00, 0x59, 0xaf, 0x27, 0x27, 0x24, 0x40, 0x44, 0xa3, 0x2d, 0x18, + 0x24, 0x00, 0x4d, 0x9f, 0x8c, 0x0d, 0x24, 0x40, 0x48, 0xd7, 0xc8, 0x08, + 0x24, 0x00, 0x43, 0x84, 0x09, 0x07, 0x24, 0x40, 0x07, 0x13, 0x06, 0x4d, + 0x0c, 0x9c, 0x98, 0x39, 0x05, 0x5a, 0x03, 0x1b, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xe1, 0x23, 0xa8, 0x00, 0xe5, 0x26, 0xa8, 0x00, 0xe9, 0x24, 0xa8, 0x00, 0x42, 0xcd, 0x02, 0x27, 0xa8, 0x00, 0xf5, 0x25, 0xa8, 0x40, 0xa1, - 0x0c, 0x48, 0x71, 0xc5, 0x02, 0xa8, 0x00, 0x47, 0xf6, 0x64, 0x06, 0xa8, - 0x40, 0x50, 0xed, 0x64, 0x2c, 0xa8, 0x00, 0x47, 0x3d, 0x16, 0x0b, 0xa8, + 0x0c, 0x48, 0xff, 0xca, 0x02, 0xa8, 0x00, 0x47, 0xe3, 0x67, 0x06, 0xa8, + 0x40, 0x50, 0xda, 0x67, 0x2c, 0xa8, 0x00, 0x47, 0x0b, 0x17, 0x0b, 0xa8, 0x40, 0xd1, 0x28, 0xa8, 0x00, 0xd2, 0x29, 0xa8, 0x00, 0xd3, 0x2a, 0xa8, 0x00, 0xd4, 0x2b, 0xa8, 0x40, 0xe1, 0x00, 0xa8, 0x00, 0xa2, 0xa9, 0x01, 0xa3, 0x9c, 0x01, 0xa4, 0x83, 0x01, 0xe5, 0x04, 0xa8, 0x00, 0xa7, 0x73, @@ -3829,185 +3855,185 @@ static const unsigned char uname2c_tree[222744] = { 0x00, 0xef, 0x16, 0xa8, 0x40, 0x42, 0x0b, 0x00, 0x13, 0xa8, 0x00, 0xef, 0x12, 0xa8, 0x40, 0x42, 0x0b, 0x00, 0x0d, 0xa8, 0x00, 0xef, 0x0c, 0xa8, 0x40, 0x42, 0x0b, 0x00, 0x1c, 0xa8, 0x00, 0xef, 0x1b, 0xa8, 0x40, 0xa1, - 0x0c, 0x45, 0x92, 0xe7, 0xca, 0xf3, 0x01, 0x48, 0x39, 0xcc, 0x53, 0x20, - 0x40, 0xee, 0xa2, 0xf9, 0x01, 0x55, 0x2a, 0x3e, 0x75, 0xf6, 0x41, 0xe2, - 0x1a, 0x00, 0x80, 0xe9, 0x09, 0x46, 0x53, 0xcb, 0x7b, 0x22, 0x80, 0x91, - 0x09, 0x08, 0x79, 0xc8, 0xfa, 0x08, 0xee, 0x09, 0x26, 0x80, 0xac, 0x02, - 0x03, 0x6f, 0x02, 0x1f, 0x02, 0x11, 0x1c, 0x0f, 0xb3, 0x01, 0xff, 0x42, - 0x49, 0x00, 0x63, 0xf3, 0x01, 0x4f, 0xc8, 0x71, 0x9f, 0xf6, 0x41, 0x4c, - 0x04, 0x8c, 0x2f, 0x22, 0x00, 0x42, 0x33, 0x00, 0xc4, 0xf3, 0x41, 0x44, - 0x49, 0xf0, 0xb8, 0xf9, 0x01, 0xb3, 0x06, 0x47, 0x72, 0xd7, 0xb9, 0xf9, - 0x41, 0x06, 0x75, 0x06, 0x86, 0x01, 0x03, 0x68, 0x09, 0x01, 0xff, 0x06, - 0x5c, 0x00, 0x66, 0x07, 0x92, 0x0a, 0x56, 0x42, 0xf4, 0x01, 0x83, 0x22, - 0x80, 0x1d, 0x51, 0x44, 0x5d, 0xc9, 0x27, 0x00, 0x05, 0x51, 0x00, 0x01, - 0xff, 0x43, 0x23, 0x0a, 0xbe, 0x2a, 0x00, 0x59, 0x17, 0x25, 0xc2, 0x2a, - 0x00, 0x4f, 0xe6, 0x71, 0xc0, 0x2a, 0x40, 0x80, 0x01, 0xff, 0x06, 0x5c, - 0x00, 0x13, 0x4b, 0x0e, 0x29, 0x87, 0x22, 0x80, 0x06, 0x51, 0xa8, 0x5f, - 0x8b, 0x22, 0x40, 0x4f, 0x90, 0x3b, 0xc4, 0x2a, 0x40, 0x4f, 0xb1, 0x6a, - 0xca, 0x2a, 0x00, 0x4b, 0x48, 0x13, 0xc6, 0x2a, 0x00, 0x4c, 0x1d, 0x2b, - 0xcc, 0x2a, 0x00, 0x4e, 0x93, 0x3e, 0xc8, 0x2a, 0x40, 0x5e, 0x81, 0x12, - 0xd8, 0x2a, 0x00, 0x46, 0x99, 0x12, 0xd7, 0x2a, 0x40, 0x4f, 0x69, 0x1a, - 0x7b, 0x29, 0x00, 0x02, 0x6f, 0x00, 0x01, 0xff, 0x44, 0x9b, 0x12, 0xd4, - 0x2a, 0x00, 0x46, 0x44, 0x36, 0xd6, 0x2a, 0x40, 0xa5, 0x62, 0xa6, 0x54, - 0xac, 0x40, 0x45, 0x93, 0x1f, 0x7b, 0x20, 0x00, 0x44, 0xea, 0x2a, 0x79, - 0x20, 0x00, 0x43, 0x0e, 0x0b, 0xb9, 0x00, 0x00, 0x49, 0xe6, 0x71, 0x7a, - 0x20, 0x00, 0x51, 0xd4, 0x21, 0x7e, 0x20, 0x00, 0xb3, 0x14, 0xb4, 0x06, - 0x44, 0x5f, 0x1e, 0x70, 0x20, 0x40, 0x44, 0x25, 0x01, 0xb3, 0x00, 0x00, - 0x42, 0x15, 0x02, 0xb2, 0x00, 0x40, 0x44, 0xe5, 0x1d, 0x77, 0x20, 0x00, - 0x42, 0x1c, 0x26, 0x76, 0x20, 0x40, 0x12, 0x7e, 0x50, 0x06, 0x4f, 0x9b, - 0x24, 0x7d, 0x20, 0x40, 0xe9, 0x71, 0x20, 0x00, 0xee, 0x7f, 0x20, 0x40, - 0x43, 0xd2, 0x05, 0x75, 0x20, 0x00, 0x43, 0xf6, 0x06, 0x74, 0x20, 0x40, - 0x44, 0xc9, 0x00, 0x78, 0x20, 0x00, 0x4a, 0x49, 0x13, 0x7c, 0x20, 0x40, - 0x80, 0xb9, 0x06, 0x07, 0x56, 0xd0, 0xcc, 0x02, 0x46, 0x99, 0x97, 0x3b, - 0xf3, 0x01, 0x44, 0xc8, 0xbc, 0x05, 0xf3, 0x81, 0xb8, 0x02, 0x52, 0x34, - 0x55, 0x07, 0xf3, 0x01, 0x05, 0x29, 0xec, 0x01, 0xff, 0x06, 0xef, 0x06, - 0xe6, 0x01, 0x07, 0xec, 0x05, 0x06, 0x48, 0x19, 0xcb, 0xe1, 0x1b, 0x41, - 0xa1, 0xc7, 0x01, 0x43, 0x22, 0x36, 0xce, 0x1b, 0x01, 0xa3, 0xb2, 0x01, - 0xa4, 0xa3, 0x01, 0x43, 0xde, 0xde, 0xc2, 0x1b, 0x01, 0x43, 0x91, 0x9c, - 0xca, 0x1b, 0x01, 0x45, 0xfc, 0xe6, 0xcb, 0x1b, 0x01, 0x44, 0xb1, 0xf0, - 0xc3, 0x1b, 0x01, 0x44, 0xd9, 0xf0, 0xcf, 0x1b, 0x01, 0xab, 0x71, 0x46, - 0xf0, 0xdd, 0xd0, 0x1b, 0x01, 0x42, 0x6c, 0x00, 0xc7, 0x1b, 0x01, 0xae, - 0x57, 0x45, 0xd1, 0xe9, 0xd1, 0x1b, 0x01, 0xb0, 0x43, 0x43, 0x96, 0x02, - 0xc4, 0x1b, 0x01, 0x04, 0xcd, 0xf2, 0x2f, 0xb4, 0x12, 0x45, 0x24, 0xec, - 0xc5, 0x1b, 0x01, 0x45, 0x33, 0xec, 0xd3, 0x1b, 0x01, 0x43, 0xb8, 0x32, - 0xd4, 0x1b, 0x41, 0x44, 0x14, 0xa5, 0xc1, 0x1b, 0x01, 0x44, 0x57, 0x76, - 0xde, 0x1b, 0x01, 0xa8, 0x01, 0xff, 0x43, 0xf6, 0x0a, 0xd8, 0x1b, 0x01, - 0x43, 0x85, 0x0e, 0xdf, 0x1b, 0x41, 0x42, 0x68, 0x00, 0xd2, 0x1b, 0x01, + 0x0c, 0x45, 0x69, 0xed, 0xca, 0xf3, 0x01, 0x48, 0xdf, 0xd1, 0x53, 0x20, + 0x40, 0xee, 0xa2, 0xf9, 0x01, 0x55, 0x32, 0x40, 0x75, 0xf6, 0x41, 0xe2, + 0x1a, 0x00, 0x80, 0xe9, 0x09, 0x46, 0xf1, 0xd0, 0x7b, 0x22, 0x80, 0x91, + 0x09, 0x08, 0xff, 0xcd, 0xfa, 0x08, 0xee, 0x09, 0x26, 0x80, 0xac, 0x02, + 0x03, 0x6f, 0x02, 0x1f, 0x02, 0x17, 0x1d, 0x0f, 0xb3, 0x01, 0xff, 0x42, + 0x49, 0x00, 0x63, 0xf3, 0x01, 0x4f, 0x03, 0x75, 0x9f, 0xf6, 0x41, 0x4c, + 0x98, 0x90, 0x2f, 0x22, 0x00, 0x42, 0x33, 0x00, 0xc4, 0xf3, 0x41, 0x44, + 0x0c, 0xf6, 0xb8, 0xf9, 0x01, 0xb3, 0x06, 0x47, 0x3b, 0xdd, 0xb9, 0xf9, + 0x41, 0x06, 0x75, 0x06, 0x86, 0x01, 0x03, 0x8d, 0x09, 0x01, 0xff, 0x06, + 0x5c, 0x00, 0x66, 0x07, 0xdb, 0x0a, 0x56, 0x42, 0xf4, 0x01, 0x83, 0x22, + 0x80, 0x1d, 0x51, 0xe0, 0x5f, 0xc9, 0x27, 0x00, 0x05, 0x51, 0x00, 0x01, + 0xff, 0x43, 0x48, 0x0a, 0xbe, 0x2a, 0x00, 0x59, 0x6a, 0x26, 0xc2, 0x2a, + 0x00, 0x4f, 0x21, 0x75, 0xc0, 0x2a, 0x40, 0x80, 0x01, 0xff, 0x06, 0x5c, + 0x00, 0x13, 0x4b, 0x91, 0x2a, 0x87, 0x22, 0x80, 0x06, 0x51, 0x55, 0x62, + 0x8b, 0x22, 0x40, 0x4f, 0x98, 0x3d, 0xc4, 0x2a, 0x40, 0x4f, 0xce, 0x6d, + 0xca, 0x2a, 0x00, 0x4b, 0x16, 0x14, 0xc6, 0x2a, 0x00, 0x4c, 0xa0, 0x2c, + 0xcc, 0x2a, 0x00, 0x4e, 0x9b, 0x40, 0xc8, 0x2a, 0x40, 0x5e, 0x4f, 0x13, + 0xd8, 0x2a, 0x00, 0x46, 0x67, 0x13, 0xd7, 0x2a, 0x40, 0x4f, 0x6f, 0x1b, + 0x7b, 0x29, 0x00, 0x02, 0x6f, 0x00, 0x01, 0xff, 0x44, 0x69, 0x13, 0xd4, + 0x2a, 0x00, 0x46, 0x21, 0x38, 0xd6, 0x2a, 0x40, 0xa5, 0x62, 0xa6, 0x54, + 0xac, 0x40, 0x45, 0xb4, 0x20, 0x7b, 0x20, 0x00, 0x44, 0x6d, 0x2c, 0x79, + 0x20, 0x00, 0x43, 0x7a, 0x0b, 0xb9, 0x00, 0x00, 0x49, 0x21, 0x75, 0x7a, + 0x20, 0x00, 0x51, 0xf5, 0x22, 0x7e, 0x20, 0x00, 0xb3, 0x14, 0xb4, 0x06, + 0x44, 0x80, 0x1f, 0x70, 0x20, 0x40, 0x44, 0x25, 0x01, 0xb3, 0x00, 0x00, + 0x42, 0x15, 0x02, 0xb2, 0x00, 0x40, 0x44, 0x06, 0x1f, 0x77, 0x20, 0x00, + 0x42, 0x09, 0x24, 0x76, 0x20, 0x40, 0x12, 0xd3, 0x52, 0x06, 0x4f, 0xee, + 0x25, 0x7d, 0x20, 0x40, 0xe9, 0x71, 0x20, 0x00, 0xee, 0x7f, 0x20, 0x40, + 0x43, 0xf9, 0x05, 0x75, 0x20, 0x00, 0x43, 0xf6, 0x06, 0x74, 0x20, 0x40, + 0x44, 0xc9, 0x00, 0x78, 0x20, 0x00, 0x4a, 0x17, 0x14, 0x7c, 0x20, 0x40, + 0x80, 0xb9, 0x06, 0x07, 0xfc, 0xd5, 0xcc, 0x02, 0x46, 0x8c, 0x9c, 0x3b, + 0xf3, 0x01, 0x44, 0x65, 0xc2, 0x05, 0xf3, 0x81, 0xb8, 0x02, 0x52, 0x9b, + 0x57, 0x07, 0xf3, 0x01, 0x05, 0xec, 0xf1, 0x01, 0xff, 0x06, 0xef, 0x06, + 0xe6, 0x01, 0x07, 0x13, 0x06, 0x06, 0x48, 0xb7, 0xd0, 0xe1, 0x1b, 0x41, + 0xa1, 0xc7, 0x01, 0x43, 0xff, 0x37, 0xce, 0x1b, 0x01, 0xa3, 0xb2, 0x01, + 0xa4, 0xa3, 0x01, 0x43, 0xb4, 0xe4, 0xc2, 0x1b, 0x01, 0x43, 0x9a, 0xa1, + 0xca, 0x1b, 0x01, 0x45, 0xce, 0xec, 0xcb, 0x1b, 0x01, 0x44, 0x74, 0xf6, + 0xc3, 0x1b, 0x01, 0x44, 0x9c, 0xf6, 0xcf, 0x1b, 0x01, 0xab, 0x71, 0x46, + 0xc6, 0xe3, 0xd0, 0x1b, 0x01, 0x42, 0x6c, 0x00, 0xc7, 0x1b, 0x01, 0xae, + 0x57, 0x45, 0xa3, 0xef, 0xd1, 0x1b, 0x01, 0xb0, 0x43, 0x43, 0x96, 0x02, + 0xc4, 0x1b, 0x01, 0x04, 0xa4, 0xf8, 0x2f, 0xb4, 0x12, 0x45, 0xe7, 0xf1, + 0xc5, 0x1b, 0x01, 0x45, 0xf6, 0xf1, 0xd3, 0x1b, 0x01, 0x43, 0x69, 0x34, + 0xd4, 0x1b, 0x41, 0x44, 0x3e, 0xaa, 0xc1, 0x1b, 0x01, 0x44, 0xc9, 0x79, + 0xde, 0x1b, 0x01, 0xa8, 0x01, 0xff, 0x43, 0x62, 0x0b, 0xd8, 0x1b, 0x01, + 0x43, 0x34, 0x0f, 0xdf, 0x1b, 0x41, 0x42, 0x68, 0x00, 0xd2, 0x1b, 0x01, 0xf2, 0xdc, 0x1b, 0x41, 0x43, 0xc9, 0x02, 0xd9, 0x1b, 0x01, 0x42, 0xba, - 0x04, 0xc9, 0x1b, 0x41, 0x42, 0x18, 0x0a, 0xcd, 0x1b, 0x01, 0x43, 0x88, - 0x1e, 0xda, 0x1b, 0x41, 0x42, 0x22, 0x00, 0xdb, 0x1b, 0x01, 0x42, 0xf0, - 0x2a, 0xc6, 0x1b, 0x01, 0x44, 0x1c, 0xbd, 0xe0, 0x1b, 0x41, 0x43, 0xc0, - 0x27, 0xc0, 0x1b, 0x01, 0x44, 0xa9, 0x49, 0xd7, 0x1b, 0x41, 0x44, 0x25, - 0x86, 0xcc, 0x1b, 0x01, 0x45, 0x15, 0xe7, 0xdd, 0x1b, 0x41, 0x42, 0x13, - 0x00, 0xd6, 0x1b, 0x01, 0x44, 0x45, 0xf2, 0xc8, 0x1b, 0x01, 0x42, 0xf5, - 0x0a, 0xd5, 0x1b, 0x41, 0x45, 0x12, 0x0b, 0xf8, 0x1b, 0x01, 0xa6, 0x2e, - 0x44, 0xea, 0x2a, 0xf9, 0x1b, 0x01, 0x43, 0x0e, 0x0b, 0xf1, 0x1b, 0x01, - 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xf0, 0x1b, 0x41, 0x44, 0x25, - 0x01, 0xf3, 0x1b, 0x01, 0x42, 0x15, 0x02, 0xf2, 0x1b, 0x41, 0x44, 0xe5, - 0x1d, 0xf7, 0x1b, 0x01, 0x42, 0x1c, 0x26, 0xf6, 0x1b, 0x41, 0x43, 0xd2, - 0x05, 0xf5, 0x1b, 0x01, 0x43, 0xf6, 0x06, 0xf4, 0x1b, 0x41, 0x4f, 0x76, - 0x69, 0x04, 0xf3, 0x41, 0x48, 0xc3, 0x88, 0xba, 0x1b, 0x00, 0x11, 0x59, - 0x59, 0xb6, 0x03, 0x06, 0xef, 0x06, 0xef, 0x02, 0x07, 0xec, 0x05, 0x8d, - 0x01, 0x12, 0xa4, 0x54, 0x57, 0x05, 0x5a, 0x03, 0x2c, 0x0d, 0x6b, 0x8a, - 0x01, 0xff, 0x45, 0xb4, 0xe8, 0xa8, 0x1b, 0x00, 0xae, 0x01, 0xff, 0x47, - 0xab, 0xce, 0xa6, 0x1b, 0x00, 0x47, 0x13, 0xd1, 0xa9, 0x1b, 0x00, 0x45, - 0xca, 0xe6, 0xa4, 0x1b, 0x00, 0x45, 0x51, 0x12, 0xa7, 0x1b, 0x00, 0x44, - 0x6d, 0xf3, 0xa5, 0x1b, 0x40, 0x02, 0xbb, 0x09, 0x06, 0x46, 0xe5, 0x23, - 0xab, 0x1b, 0x40, 0x45, 0x73, 0xe8, 0xaa, 0x1b, 0x00, 0xae, 0x01, 0xff, - 0xa7, 0x06, 0x45, 0xab, 0xec, 0x80, 0x1b, 0x40, 0x45, 0x41, 0xe8, 0x81, - 0x1b, 0x00, 0x45, 0x83, 0xec, 0x82, 0x1b, 0x40, 0x4a, 0x4c, 0xa8, 0xc7, - 0x1c, 0x00, 0x45, 0x0d, 0xe5, 0xc3, 0x1c, 0x00, 0x4a, 0x50, 0xa9, 0xc6, - 0x1c, 0x00, 0x4a, 0x70, 0xac, 0xc5, 0x1c, 0x00, 0x4b, 0xd8, 0x9e, 0xc4, - 0x1c, 0x00, 0xb0, 0x06, 0x45, 0x48, 0xeb, 0xc0, 0x1c, 0x40, 0x47, 0xff, - 0xce, 0xc1, 0x1c, 0x00, 0x46, 0x26, 0xe1, 0xc2, 0x1c, 0x40, 0xe1, 0x83, + 0x04, 0xc9, 0x1b, 0x41, 0x42, 0x3d, 0x0a, 0xcd, 0x1b, 0x01, 0x43, 0xa9, + 0x1f, 0xda, 0x1b, 0x41, 0x42, 0x22, 0x00, 0xdb, 0x1b, 0x01, 0x42, 0x73, + 0x2c, 0xc6, 0x1b, 0x01, 0x44, 0xb9, 0xc2, 0xe0, 0x1b, 0x41, 0x43, 0x13, + 0x29, 0xc0, 0x1b, 0x01, 0x44, 0xec, 0x4b, 0xd7, 0x1b, 0x41, 0x44, 0x54, + 0x8a, 0xcc, 0x1b, 0x01, 0x45, 0xe7, 0xec, 0xdd, 0x1b, 0x41, 0x42, 0x13, + 0x00, 0xd6, 0x1b, 0x01, 0x44, 0x18, 0xf8, 0xc8, 0x1b, 0x01, 0x42, 0x61, + 0x0b, 0xd5, 0x1b, 0x41, 0x45, 0x7e, 0x0b, 0xf8, 0x1b, 0x01, 0xa6, 0x2e, + 0x44, 0x6d, 0x2c, 0xf9, 0x1b, 0x01, 0x43, 0x7a, 0x0b, 0xf1, 0x1b, 0x01, + 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xf0, 0x1b, 0x41, 0x44, 0x25, + 0x01, 0xf3, 0x1b, 0x01, 0x42, 0x15, 0x02, 0xf2, 0x1b, 0x41, 0x44, 0x06, + 0x1f, 0xf7, 0x1b, 0x01, 0x42, 0x09, 0x24, 0xf6, 0x1b, 0x41, 0x43, 0xf9, + 0x05, 0xf5, 0x1b, 0x01, 0x43, 0xf6, 0x06, 0xf4, 0x1b, 0x41, 0x4f, 0xb1, + 0x6c, 0x04, 0xf3, 0x41, 0x48, 0x33, 0x8d, 0xba, 0x1b, 0x00, 0x11, 0xd3, + 0x5b, 0xb6, 0x03, 0x06, 0xef, 0x06, 0xef, 0x02, 0x07, 0x13, 0x06, 0x8d, + 0x01, 0x12, 0xf9, 0x56, 0x57, 0x05, 0x5a, 0x03, 0x2c, 0x0d, 0xe8, 0x8e, + 0x01, 0xff, 0x45, 0x86, 0xee, 0xa8, 0x1b, 0x00, 0xae, 0x01, 0xff, 0x47, + 0x51, 0xd4, 0xa6, 0x1b, 0x00, 0x47, 0xc7, 0xd6, 0xa9, 0x1b, 0x00, 0x45, + 0x9c, 0xec, 0xa4, 0x1b, 0x00, 0x45, 0x1f, 0x13, 0xa7, 0x1b, 0x00, 0x44, + 0x48, 0xf9, 0xa5, 0x1b, 0x40, 0x02, 0xe0, 0x09, 0x06, 0x46, 0x1f, 0x25, + 0xab, 0x1b, 0x40, 0x45, 0x45, 0xee, 0xaa, 0x1b, 0x00, 0xae, 0x01, 0xff, + 0xa7, 0x06, 0x45, 0x6e, 0xf2, 0x80, 0x1b, 0x40, 0x45, 0x18, 0xee, 0x81, + 0x1b, 0x00, 0x45, 0x46, 0xf2, 0x82, 0x1b, 0x40, 0x4a, 0x8a, 0xad, 0xc7, + 0x1c, 0x00, 0x45, 0xe4, 0xea, 0xc3, 0x1c, 0x00, 0x4a, 0x8e, 0xae, 0xc6, + 0x1c, 0x00, 0x4a, 0xcc, 0xb1, 0xc5, 0x1c, 0x00, 0x4b, 0xe1, 0xa3, 0xc4, + 0x1c, 0x00, 0xb0, 0x06, 0x45, 0x10, 0xf1, 0xc0, 0x1c, 0x40, 0x47, 0xa5, + 0xd4, 0xc1, 0x1c, 0x00, 0x46, 0x02, 0xe7, 0xc2, 0x1c, 0x40, 0xe1, 0x83, 0x1b, 0x80, 0xcd, 0x01, 0xa2, 0xc0, 0x01, 0x42, 0x37, 0x00, 0x8e, 0x1b, - 0x00, 0x42, 0xf0, 0x10, 0x93, 0x1b, 0x00, 0xe5, 0x88, 0x1b, 0x80, 0xaa, + 0x00, 0x42, 0x7b, 0x08, 0x93, 0x1b, 0x00, 0xe5, 0x88, 0x1b, 0x80, 0xaa, 0x01, 0xa6, 0x96, 0x01, 0x42, 0x24, 0x02, 0x8c, 0x1b, 0x00, 0x42, 0x22, - 0x00, 0xa0, 0x1b, 0x00, 0xe9, 0x84, 0x1b, 0x00, 0x42, 0x72, 0x19, 0x8f, + 0x00, 0xa0, 0x1b, 0x00, 0xe9, 0x84, 0x1b, 0x00, 0x42, 0x78, 0x1a, 0x8f, 0x1b, 0x00, 0xab, 0x74, 0xac, 0x68, 0x42, 0x6c, 0x00, 0x99, 0x1b, 0x00, - 0xae, 0x50, 0xef, 0x87, 0x1b, 0x00, 0x42, 0xbb, 0x09, 0x95, 0x1b, 0x00, - 0x42, 0x43, 0x14, 0x8b, 0x1b, 0x00, 0xb2, 0x34, 0xb3, 0x28, 0x42, 0x12, - 0x00, 0x92, 0x1b, 0x00, 0xf5, 0x85, 0x1b, 0x00, 0x42, 0xf5, 0x0a, 0x97, - 0x1b, 0x00, 0x42, 0xa9, 0x01, 0x9d, 0x1b, 0x00, 0x42, 0x08, 0x27, 0x9f, - 0x1b, 0x00, 0x42, 0xbe, 0x22, 0x9a, 0x1b, 0x00, 0x42, 0x59, 0x00, 0x90, - 0x1b, 0x40, 0xe1, 0x9e, 0x1b, 0x00, 0x42, 0xbe, 0x22, 0xaf, 0x1b, 0x40, + 0xae, 0x50, 0xef, 0x87, 0x1b, 0x00, 0x42, 0xe0, 0x09, 0x95, 0x1b, 0x00, + 0x42, 0x11, 0x15, 0x8b, 0x1b, 0x00, 0xb2, 0x34, 0xb3, 0x28, 0x42, 0x12, + 0x00, 0x92, 0x1b, 0x00, 0xf5, 0x85, 0x1b, 0x00, 0x42, 0x61, 0x0b, 0x97, + 0x1b, 0x00, 0x42, 0xa9, 0x01, 0x9d, 0x1b, 0x00, 0x42, 0x5b, 0x28, 0x9f, + 0x1b, 0x00, 0x42, 0xdf, 0x23, 0x9a, 0x1b, 0x00, 0x42, 0x59, 0x00, 0x90, + 0x1b, 0x40, 0xe1, 0x9e, 0x1b, 0x00, 0x42, 0xdf, 0x23, 0xaf, 0x1b, 0x40, 0xe1, 0x9b, 0x1b, 0x00, 0x42, 0x97, 0x02, 0xbb, 0x1b, 0x40, 0xe1, 0x94, - 0x1b, 0x00, 0x42, 0x24, 0x02, 0x8d, 0x1b, 0x00, 0x42, 0xbe, 0x22, 0x91, + 0x1b, 0x00, 0x42, 0x24, 0x02, 0x8d, 0x1b, 0x00, 0x42, 0xdf, 0x23, 0x91, 0x1b, 0x40, 0xe1, 0x9c, 0x1b, 0x00, 0x42, 0x97, 0x02, 0xbc, 0x1b, 0x40, 0xe1, 0x8a, 0x1b, 0x00, 0x42, 0x22, 0x00, 0xae, 0x1b, 0x40, 0xe1, 0x96, - 0x1b, 0x00, 0x05, 0x03, 0x28, 0x01, 0xff, 0xeb, 0xbe, 0x1b, 0x00, 0xed, + 0x1b, 0x00, 0x05, 0x56, 0x29, 0x01, 0xff, 0xeb, 0xbe, 0x1b, 0x00, 0xed, 0xbf, 0x1b, 0x40, 0xf5, 0x89, 0x1b, 0x40, 0xe1, 0x98, 0x1b, 0x00, 0x42, - 0x22, 0x00, 0xbd, 0x1b, 0x40, 0xe5, 0x86, 0x1b, 0x00, 0x48, 0x8e, 0xbe, - 0xbd, 0x1b, 0x40, 0x45, 0x12, 0x0b, 0xb8, 0x1b, 0x00, 0xa6, 0x2e, 0x44, - 0xea, 0x2a, 0xb9, 0x1b, 0x00, 0x43, 0x0e, 0x0b, 0xb1, 0x1b, 0x00, 0xb3, - 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xb0, 0x1b, 0x40, 0x44, 0x25, 0x01, - 0xb3, 0x1b, 0x00, 0x42, 0x15, 0x02, 0xb2, 0x1b, 0x40, 0x44, 0xe5, 0x1d, - 0xb7, 0x1b, 0x00, 0x42, 0x1c, 0x26, 0xb6, 0x1b, 0x40, 0x43, 0xd2, 0x05, - 0xb5, 0x1b, 0x00, 0x43, 0xf6, 0x06, 0xb4, 0x1b, 0x40, 0x47, 0x66, 0xd3, - 0xa1, 0x1b, 0x00, 0x02, 0x99, 0x1a, 0x11, 0x07, 0xc7, 0xd5, 0x01, 0xff, + 0x22, 0x00, 0xbd, 0x1b, 0x40, 0xe5, 0x86, 0x1b, 0x00, 0x48, 0x34, 0xc4, + 0xbd, 0x1b, 0x40, 0x45, 0x7e, 0x0b, 0xb8, 0x1b, 0x00, 0xa6, 0x2e, 0x44, + 0x6d, 0x2c, 0xb9, 0x1b, 0x00, 0x43, 0x7a, 0x0b, 0xb1, 0x1b, 0x00, 0xb3, + 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xb0, 0x1b, 0x40, 0x44, 0x25, 0x01, + 0xb3, 0x1b, 0x00, 0x42, 0x15, 0x02, 0xb2, 0x1b, 0x40, 0x44, 0x06, 0x1f, + 0xb7, 0x1b, 0x00, 0x42, 0x09, 0x24, 0xb6, 0x1b, 0x40, 0x43, 0xf9, 0x05, + 0xb5, 0x1b, 0x00, 0x43, 0xf6, 0x06, 0xb4, 0x1b, 0x40, 0x47, 0x21, 0xd9, + 0xa1, 0x1b, 0x00, 0x02, 0x9f, 0x1b, 0x11, 0x07, 0x90, 0xdb, 0x01, 0xff, 0x42, 0x6c, 0x00, 0xac, 0x1b, 0x00, 0x42, 0xa9, 0x01, 0xad, 0x1b, 0x40, - 0x44, 0xd9, 0x96, 0xa2, 0x1b, 0x00, 0x43, 0x79, 0xe7, 0xa3, 0x1b, 0x40, - 0x4c, 0xb8, 0x8c, 0xc5, 0x26, 0x00, 0x49, 0x70, 0xc1, 0x1e, 0xf3, 0x41, - 0x46, 0xb5, 0x0a, 0xb3, 0x23, 0x00, 0x43, 0x1e, 0x00, 0xb2, 0x23, 0x00, - 0x4d, 0xc6, 0x8a, 0x0b, 0x2a, 0x40, 0x80, 0x01, 0xff, 0x06, 0x5c, 0x00, - 0x1c, 0x55, 0xe6, 0x39, 0xe9, 0x22, 0x00, 0x06, 0x0e, 0x29, 0x06, 0x4e, - 0xfe, 0x7d, 0xb1, 0x22, 0x40, 0x45, 0xfb, 0x0c, 0x7d, 0x22, 0x00, 0x4a, - 0xf1, 0x39, 0x7f, 0x22, 0x40, 0x4f, 0xb1, 0x6a, 0xb8, 0x2a, 0x00, 0x4b, - 0x48, 0x13, 0xb4, 0x2a, 0x00, 0x04, 0x72, 0x23, 0x11, 0x0c, 0x11, 0x2b, - 0x01, 0xff, 0x4b, 0x48, 0x13, 0xb0, 0x2a, 0x00, 0x4c, 0x1d, 0x2b, 0xb2, - 0x2a, 0x40, 0x4f, 0xb1, 0x6a, 0xba, 0x2a, 0x00, 0x48, 0xf8, 0x0c, 0xb6, - 0x2a, 0x40, 0xb3, 0x01, 0xff, 0x06, 0x75, 0x06, 0x75, 0x03, 0x68, 0x09, - 0x06, 0x46, 0x53, 0xc0, 0x1a, 0x00, 0x40, 0x06, 0x5c, 0x00, 0x50, 0x42, + 0x44, 0xb5, 0x9b, 0xa2, 0x1b, 0x00, 0x43, 0xae, 0x30, 0xa3, 0x1b, 0x40, + 0x4c, 0x4c, 0x91, 0xc5, 0x26, 0x00, 0x49, 0x1f, 0xc7, 0x1e, 0xf3, 0x41, + 0x46, 0xfe, 0x0a, 0xb3, 0x23, 0x00, 0x43, 0x1e, 0x00, 0xb2, 0x23, 0x00, + 0x4d, 0x36, 0x8f, 0x0b, 0x2a, 0x40, 0x80, 0x01, 0xff, 0x06, 0x5c, 0x00, + 0x1c, 0x55, 0x03, 0x3c, 0xe9, 0x22, 0x00, 0x06, 0x91, 0x2a, 0x06, 0x4e, + 0xd2, 0x81, 0xb1, 0x22, 0x40, 0x45, 0x89, 0x0d, 0x7d, 0x22, 0x00, 0x4a, + 0x0e, 0x3c, 0x7f, 0x22, 0x40, 0x4f, 0xce, 0x6d, 0xb8, 0x2a, 0x00, 0x4b, + 0x16, 0x14, 0xb4, 0x2a, 0x00, 0x04, 0xac, 0x24, 0x11, 0x0c, 0x94, 0x2c, + 0x01, 0xff, 0x4b, 0x16, 0x14, 0xb0, 0x2a, 0x00, 0x4c, 0xa0, 0x2c, 0xb2, + 0x2a, 0x40, 0x4f, 0xce, 0x6d, 0xba, 0x2a, 0x00, 0x48, 0x86, 0x0d, 0xb6, + 0x2a, 0x40, 0xb3, 0x01, 0xff, 0x06, 0x75, 0x06, 0x75, 0x03, 0x8d, 0x09, + 0x06, 0x46, 0x02, 0xc6, 0x1a, 0x00, 0x40, 0x06, 0x5c, 0x00, 0x50, 0x42, 0xf4, 0x01, 0x82, 0x22, 0x80, 0x17, 0x05, 0x51, 0x00, 0x01, 0xff, 0x43, - 0x23, 0x0a, 0xbd, 0x2a, 0x00, 0x59, 0x17, 0x25, 0xc1, 0x2a, 0x00, 0x4f, - 0xe6, 0x71, 0xbf, 0x2a, 0x40, 0x80, 0x01, 0xff, 0x06, 0x5c, 0x00, 0x13, - 0x4b, 0x0e, 0x29, 0x86, 0x22, 0x80, 0x06, 0x51, 0xa8, 0x5f, 0x8a, 0x22, - 0x40, 0x4f, 0x90, 0x3b, 0xc3, 0x2a, 0x40, 0x4f, 0xb1, 0x6a, 0xc9, 0x2a, - 0x00, 0x4b, 0x48, 0x13, 0xc5, 0x2a, 0x00, 0x4c, 0x1d, 0x2b, 0xcb, 0x2a, - 0x00, 0x4e, 0x93, 0x3e, 0xc7, 0x2a, 0x40, 0x50, 0xb3, 0x02, 0x79, 0x29, - 0x00, 0x02, 0x6f, 0x00, 0x01, 0xff, 0x44, 0x9b, 0x12, 0xd5, 0x2a, 0x00, - 0x46, 0x44, 0x36, 0xd3, 0x2a, 0x40, 0xa5, 0x54, 0xa6, 0x46, 0x50, 0x9a, - 0x24, 0x8d, 0x20, 0x00, 0x45, 0x93, 0x1f, 0x8b, 0x20, 0x00, 0x44, 0xea, - 0x2a, 0x89, 0x20, 0x00, 0x43, 0x0e, 0x0b, 0x81, 0x20, 0x00, 0x49, 0xe6, - 0x71, 0x8a, 0x20, 0x00, 0x51, 0xd4, 0x21, 0x8e, 0x20, 0x00, 0xb3, 0x14, - 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x80, 0x20, 0x40, 0x44, 0x25, 0x01, 0x83, - 0x20, 0x00, 0x42, 0x15, 0x02, 0x82, 0x20, 0x40, 0x44, 0xe5, 0x1d, 0x87, - 0x20, 0x00, 0x42, 0x1c, 0x26, 0x86, 0x20, 0x40, 0x43, 0xd2, 0x05, 0x85, + 0x48, 0x0a, 0xbd, 0x2a, 0x00, 0x59, 0x6a, 0x26, 0xc1, 0x2a, 0x00, 0x4f, + 0x21, 0x75, 0xbf, 0x2a, 0x40, 0x80, 0x01, 0xff, 0x06, 0x5c, 0x00, 0x13, + 0x4b, 0x91, 0x2a, 0x86, 0x22, 0x80, 0x06, 0x51, 0x55, 0x62, 0x8a, 0x22, + 0x40, 0x4f, 0x98, 0x3d, 0xc3, 0x2a, 0x40, 0x4f, 0xce, 0x6d, 0xc9, 0x2a, + 0x00, 0x4b, 0x16, 0x14, 0xc5, 0x2a, 0x00, 0x4c, 0xa0, 0x2c, 0xcb, 0x2a, + 0x00, 0x4e, 0x9b, 0x40, 0xc7, 0x2a, 0x40, 0x50, 0xb3, 0x02, 0x79, 0x29, + 0x00, 0x02, 0x6f, 0x00, 0x01, 0xff, 0x44, 0x69, 0x13, 0xd5, 0x2a, 0x00, + 0x46, 0x21, 0x38, 0xd3, 0x2a, 0x40, 0xa5, 0x54, 0xa6, 0x46, 0x50, 0xed, + 0x25, 0x8d, 0x20, 0x00, 0x45, 0xb4, 0x20, 0x8b, 0x20, 0x00, 0x44, 0x6d, + 0x2c, 0x89, 0x20, 0x00, 0x43, 0x7a, 0x0b, 0x81, 0x20, 0x00, 0x49, 0x21, + 0x75, 0x8a, 0x20, 0x00, 0x51, 0xf5, 0x22, 0x8e, 0x20, 0x00, 0xb3, 0x14, + 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x80, 0x20, 0x40, 0x44, 0x25, 0x01, 0x83, + 0x20, 0x00, 0x42, 0x15, 0x02, 0x82, 0x20, 0x40, 0x44, 0x06, 0x1f, 0x87, + 0x20, 0x00, 0x42, 0x09, 0x24, 0x86, 0x20, 0x40, 0x43, 0xf9, 0x05, 0x85, 0x20, 0x00, 0x43, 0xf6, 0x06, 0x84, 0x20, 0x40, 0x44, 0xc9, 0x00, 0x88, - 0x20, 0x00, 0x4a, 0x49, 0x13, 0x8c, 0x20, 0x40, 0xa1, 0xc7, 0x01, 0xa5, - 0xa8, 0x01, 0x4a, 0x96, 0x95, 0xc5, 0xfb, 0x81, 0x7d, 0xaf, 0x6f, 0xb2, + 0x20, 0x00, 0x4a, 0x17, 0x14, 0x8c, 0x20, 0x40, 0xa1, 0xc7, 0x01, 0xa5, + 0xa8, 0x01, 0x4a, 0x72, 0x9a, 0xc5, 0xfb, 0x81, 0x7d, 0xaf, 0x6f, 0xb2, 0x1c, 0xf3, 0x93, 0x00, 0x00, 0xb5, 0x04, 0xf8, 0x02, 0x00, 0x40, 0x4e, - 0xfe, 0x76, 0x99, 0xf3, 0x01, 0x4e, 0xde, 0x77, 0x59, 0xf9, 0x01, 0x42, - 0xbb, 0x09, 0xd3, 0xf6, 0x41, 0xa1, 0x32, 0x57, 0x73, 0x2e, 0x29, 0x27, - 0x00, 0xa9, 0x01, 0xff, 0x52, 0xea, 0x50, 0x63, 0x22, 0x00, 0x4d, 0x68, - 0x86, 0x9c, 0x00, 0x00, 0x04, 0xfe, 0x18, 0x01, 0xff, 0x56, 0xdc, 0x33, - 0x83, 0xcc, 0x01, 0x56, 0x7e, 0x35, 0x80, 0xcc, 0x01, 0x57, 0x0e, 0x31, - 0x82, 0xcc, 0x01, 0x54, 0x83, 0x46, 0x81, 0xcc, 0x41, 0x04, 0xc9, 0x00, - 0x0d, 0x46, 0x50, 0xe1, 0x53, 0xf3, 0xc1, 0x00, 0x47, 0x15, 0x08, 0xbf, - 0xce, 0x41, 0x46, 0x1a, 0x30, 0xcf, 0xf4, 0x01, 0x44, 0x24, 0x24, 0xe4, - 0x23, 0x40, 0x48, 0xd1, 0xc4, 0xe0, 0xf5, 0x01, 0x46, 0x70, 0xdf, 0xf1, - 0x23, 0x40, 0x80, 0x01, 0xff, 0x08, 0xc9, 0xc7, 0x11, 0x05, 0x51, 0x00, - 0x01, 0xff, 0x4b, 0x4d, 0x99, 0xc6, 0xfb, 0x01, 0x45, 0xa0, 0x27, 0xc9, + 0x70, 0x7a, 0x99, 0xf3, 0x01, 0x4e, 0x5e, 0x7b, 0x59, 0xf9, 0x01, 0x42, + 0xe0, 0x09, 0xd3, 0xf6, 0x41, 0xa1, 0x32, 0x57, 0xdf, 0x2f, 0x29, 0x27, + 0x00, 0xa9, 0x01, 0xff, 0x52, 0x51, 0x53, 0x63, 0x22, 0x00, 0x4d, 0xa4, + 0x8a, 0x9c, 0x00, 0x00, 0x04, 0x04, 0x1a, 0x01, 0xff, 0x56, 0x8d, 0x35, + 0x83, 0xcc, 0x01, 0x56, 0x5b, 0x37, 0x80, 0xcc, 0x01, 0x57, 0xbf, 0x32, + 0x82, 0xcc, 0x01, 0x54, 0xb3, 0x48, 0x81, 0xcc, 0x41, 0x04, 0xc9, 0x00, + 0x0d, 0x46, 0x2c, 0xe7, 0x53, 0xf3, 0xc1, 0x00, 0x47, 0x15, 0x08, 0xbf, + 0xce, 0x41, 0x46, 0x9d, 0x31, 0xcf, 0xf4, 0x01, 0x44, 0x77, 0x25, 0xe4, + 0x23, 0x40, 0x48, 0x5f, 0xca, 0xe0, 0xf5, 0x01, 0x46, 0x46, 0xe5, 0xf1, + 0x23, 0x40, 0x80, 0x01, 0xff, 0x08, 0x57, 0xcd, 0x11, 0x05, 0x51, 0x00, + 0x01, 0xff, 0x4b, 0x40, 0x9e, 0xc6, 0xfb, 0x01, 0x45, 0xf3, 0x28, 0xc9, 0xfb, 0x41, 0x44, 0xc3, 0x00, 0xc7, 0xfb, 0x01, 0x45, 0xc8, 0x00, 0xc8, - 0xfb, 0x41, 0x02, 0x57, 0x00, 0x0c, 0x53, 0xac, 0x4b, 0x3c, 0x2e, 0x00, - 0x48, 0xa1, 0xcb, 0x7a, 0xfa, 0x41, 0x4b, 0x09, 0x7c, 0x82, 0xf6, 0x01, - 0x48, 0x39, 0xc7, 0x5c, 0xf3, 0x41, 0x44, 0x46, 0x04, 0xdf, 0xf3, 0x01, - 0x06, 0xe0, 0xdb, 0x75, 0x4d, 0x59, 0x32, 0x83, 0xf5, 0x01, 0x4c, 0x6f, - 0x73, 0xcd, 0xf9, 0x01, 0xb2, 0x0f, 0xb4, 0x01, 0xff, 0x43, 0xb5, 0x00, - 0x89, 0xf6, 0x01, 0x4d, 0x8e, 0x89, 0xfd, 0xf5, 0x41, 0x80, 0x2b, 0x05, - 0x49, 0x36, 0x01, 0xff, 0x4c, 0x7c, 0x8f, 0x96, 0x00, 0x00, 0x47, 0x9f, - 0xd1, 0x01, 0x00, 0x00, 0x4e, 0x6c, 0x7b, 0x96, 0x00, 0x00, 0xb3, 0x06, - 0x44, 0x97, 0x30, 0x02, 0x00, 0x40, 0x4c, 0x98, 0x88, 0x86, 0x00, 0x00, - 0x45, 0xed, 0x21, 0x98, 0x00, 0x40, 0x4c, 0x4c, 0x8c, 0x2a, 0x26, 0x00, - 0x46, 0x48, 0x13, 0x5b, 0x22, 0x00, 0xaf, 0x11, 0x05, 0x51, 0x00, 0x01, - 0xff, 0x4f, 0x7f, 0x6f, 0xea, 0x2b, 0x00, 0x50, 0xbd, 0x66, 0xeb, 0x2b, - 0x40, 0x47, 0x1a, 0xd1, 0x21, 0x27, 0x00, 0x47, 0x9b, 0x1d, 0xc6, 0x22, - 0x40, 0x4b, 0xf5, 0x98, 0x95, 0x26, 0x00, 0x46, 0x94, 0xdc, 0x9a, 0x26, + 0xfb, 0x41, 0x02, 0x57, 0x00, 0x0c, 0x53, 0x02, 0x4e, 0x3c, 0x2e, 0x00, + 0x48, 0x3f, 0xd1, 0x7a, 0xfa, 0x41, 0x4b, 0xcf, 0x7f, 0x82, 0xf6, 0x01, + 0x48, 0xbf, 0xcc, 0x5c, 0xf3, 0x41, 0x44, 0x46, 0x04, 0xdf, 0xf3, 0x01, + 0x06, 0xaa, 0xe1, 0x75, 0x4d, 0x0a, 0x34, 0x83, 0xf5, 0x01, 0x4c, 0x9b, + 0x76, 0xcd, 0xf9, 0x01, 0xb2, 0x0f, 0xb4, 0x01, 0xff, 0x43, 0xb5, 0x00, + 0x89, 0xf6, 0x01, 0x4d, 0x0b, 0x8e, 0xfd, 0xf5, 0x41, 0x80, 0x2b, 0x05, + 0x26, 0x38, 0x01, 0xff, 0x4c, 0x10, 0x94, 0x96, 0x00, 0x00, 0x47, 0x53, + 0xd7, 0x01, 0x00, 0x00, 0x4e, 0x24, 0x7f, 0x96, 0x00, 0x00, 0xb3, 0x06, + 0x44, 0x1a, 0x32, 0x02, 0x00, 0x40, 0x4c, 0xfb, 0x8c, 0x86, 0x00, 0x00, + 0x45, 0x0e, 0x23, 0x98, 0x00, 0x40, 0x4c, 0xe0, 0x90, 0x2a, 0x26, 0x00, + 0x46, 0x16, 0x14, 0x5b, 0x22, 0x00, 0xaf, 0x11, 0x05, 0x51, 0x00, 0x01, + 0xff, 0x4f, 0xab, 0x72, 0xea, 0x2b, 0x00, 0x50, 0xca, 0x69, 0xeb, 0x2b, + 0x40, 0x47, 0xce, 0xd6, 0x21, 0x27, 0x00, 0x47, 0xa1, 0x1e, 0xc6, 0x22, + 0x40, 0x4b, 0xe8, 0x9d, 0x95, 0x26, 0x00, 0x46, 0x64, 0xe2, 0x9a, 0x26, 0x40, 0xd2, 0x8e, 0x00, 0x00, 0xd3, 0x8f, 0x00, 0x00, 0xe1, 0x86, 0x00, 0x40, 0xa1, 0x06, 0x42, 0x03, 0x00, 0x91, 0xf9, 0x41, 0x02, 0x88, 0x00, - 0x06, 0x58, 0x59, 0x2b, 0xa7, 0x27, 0x40, 0x80, 0xee, 0x05, 0x02, 0x06, - 0x00, 0x01, 0xff, 0x48, 0x3c, 0x0d, 0xc6, 0x29, 0x00, 0xa3, 0xb1, 0x03, - 0x4c, 0x2c, 0x8e, 0xa1, 0x22, 0x00, 0x47, 0xdb, 0xd0, 0x9f, 0xf1, 0x01, + 0x06, 0x58, 0xdc, 0x2c, 0xa7, 0x27, 0x40, 0x80, 0xee, 0x05, 0x02, 0x06, + 0x00, 0x01, 0xff, 0x48, 0xca, 0x0d, 0xc6, 0x29, 0x00, 0xa3, 0xb1, 0x03, + 0x4c, 0xc0, 0x92, 0xa1, 0x22, 0x00, 0x47, 0x88, 0xd6, 0x9f, 0xf1, 0x01, 0xa6, 0x82, 0x03, 0xa8, 0xeb, 0x02, 0x42, 0x03, 0x00, 0x94, 0xf1, 0x01, 0xab, 0xc6, 0x02, 0xac, 0xb4, 0x01, 0xad, 0xa7, 0x01, 0xae, 0x9a, 0x01, - 0xaf, 0x8d, 0x01, 0xb0, 0x7f, 0x55, 0x15, 0x3e, 0xc4, 0x29, 0x00, 0xb3, - 0x3d, 0xb4, 0x20, 0xb5, 0x12, 0xb6, 0x06, 0x42, 0xe3, 0x1a, 0x4f, 0xf1, - 0x41, 0x42, 0x79, 0x0c, 0xac, 0xf1, 0x01, 0xf3, 0x9a, 0xf1, 0x41, 0x42, - 0x96, 0x41, 0xab, 0xf1, 0x01, 0x57, 0x56, 0x30, 0x99, 0xf1, 0x41, 0x46, - 0x2b, 0x10, 0x9b, 0xf1, 0x01, 0x44, 0x29, 0x02, 0xa0, 0x22, 0x00, 0xb7, - 0x01, 0xff, 0x52, 0x56, 0x51, 0xa2, 0xf1, 0x01, 0x43, 0x93, 0x28, 0x9d, - 0xf1, 0x41, 0x46, 0x2f, 0x19, 0xdd, 0x26, 0x00, 0xe4, 0x4c, 0xf1, 0x01, - 0xa5, 0x22, 0x42, 0x52, 0x5f, 0xaa, 0xf1, 0x01, 0x46, 0x66, 0xdd, 0xa3, - 0xf1, 0x01, 0x4b, 0x40, 0x15, 0xc7, 0x29, 0x00, 0x42, 0xa4, 0x0d, 0x98, - 0xf1, 0x01, 0x45, 0xd7, 0x05, 0xc8, 0x29, 0x00, 0xf3, 0x4d, 0xf1, 0x41, - 0x4b, 0x60, 0x9a, 0x9c, 0xf1, 0x01, 0x4d, 0x10, 0x8a, 0xa1, 0xf1, 0x41, - 0x43, 0x74, 0x28, 0x9e, 0x22, 0x00, 0x42, 0x1e, 0xcb, 0x4e, 0xf1, 0x41, - 0xeb, 0x97, 0xf1, 0x01, 0x53, 0x86, 0x4b, 0xa4, 0xf1, 0x41, 0x42, 0x43, - 0x1e, 0x95, 0xf1, 0x01, 0xe7, 0x96, 0xf1, 0x41, 0x44, 0x94, 0x1f, 0x9f, - 0x22, 0x00, 0xf6, 0x4b, 0xf1, 0x41, 0x05, 0xdf, 0x05, 0x19, 0xaf, 0x01, - 0xff, 0x06, 0x2f, 0x22, 0x06, 0x46, 0x2a, 0xe0, 0xa9, 0xf1, 0x41, 0x43, + 0xaf, 0x8d, 0x01, 0xb0, 0x7f, 0x55, 0x1d, 0x40, 0xc4, 0x29, 0x00, 0xb3, + 0x3d, 0xb4, 0x20, 0xb5, 0x12, 0xb6, 0x06, 0x42, 0xe9, 0x1b, 0x4f, 0xf1, + 0x41, 0x42, 0xe5, 0x0c, 0xac, 0xf1, 0x01, 0xf3, 0x9a, 0xf1, 0x41, 0x42, + 0xb2, 0x43, 0xab, 0xf1, 0x01, 0x57, 0xd9, 0x31, 0x99, 0xf1, 0x41, 0x46, + 0xda, 0x10, 0x9b, 0xf1, 0x01, 0x44, 0x29, 0x02, 0xa0, 0x22, 0x00, 0xb7, + 0x01, 0xff, 0x52, 0xbd, 0x53, 0xa2, 0xf1, 0x01, 0x43, 0xe6, 0x29, 0x9d, + 0xf1, 0x41, 0x46, 0x35, 0x1a, 0xdd, 0x26, 0x00, 0xe4, 0x4c, 0xf1, 0x01, + 0xa5, 0x22, 0x42, 0xff, 0x61, 0xaa, 0xf1, 0x01, 0x46, 0x36, 0xe3, 0xa3, + 0xf1, 0x01, 0x4b, 0x0e, 0x16, 0xc7, 0x29, 0x00, 0x42, 0x90, 0x08, 0x98, + 0xf1, 0x01, 0x45, 0xfe, 0x05, 0xc8, 0x29, 0x00, 0xf3, 0x4d, 0xf1, 0x41, + 0x4b, 0x5e, 0x9f, 0x9c, 0xf1, 0x01, 0x4d, 0x8d, 0x8e, 0xa1, 0xf1, 0x41, + 0x43, 0xc7, 0x29, 0x9e, 0x22, 0x00, 0x42, 0xbc, 0xd0, 0x4e, 0xf1, 0x41, + 0xeb, 0x97, 0xf1, 0x01, 0x53, 0xdc, 0x4d, 0xa4, 0xf1, 0x41, 0x42, 0x64, + 0x1f, 0x95, 0xf1, 0x01, 0xe7, 0x96, 0xf1, 0x41, 0x44, 0xb5, 0x20, 0x9f, + 0x22, 0x00, 0xf6, 0x4b, 0xf1, 0x41, 0x05, 0x06, 0x06, 0x19, 0xaf, 0x01, + 0xff, 0x06, 0x50, 0x23, 0x06, 0x46, 0x0c, 0xe6, 0xa9, 0xf1, 0x41, 0x43, 0x1a, 0x00, 0xce, 0x27, 0x00, 0x42, 0x0c, 0x00, 0xcf, 0x27, 0x40, 0x0f, - 0xe4, 0x05, 0x06, 0x4e, 0x5a, 0x7c, 0xa5, 0xf1, 0x41, 0xe1, 0x30, 0xf1, + 0x0b, 0x06, 0x06, 0x4e, 0x20, 0x80, 0xa5, 0xf1, 0x41, 0xe1, 0x30, 0xf1, 0x01, 0xe2, 0x31, 0xf1, 0x01, 0xe3, 0x32, 0xf1, 0x01, 0xe4, 0x33, 0xf1, 0x01, 0xe5, 0x34, 0xf1, 0x01, 0xe6, 0x35, 0xf1, 0x01, 0xe7, 0x36, 0xf1, 0x01, 0xe8, 0x37, 0xf1, 0x01, 0xe9, 0x38, 0xf1, 0x01, 0xea, 0x39, 0xf1, @@ -4016,2761 +4042,2772 @@ static const unsigned char uname2c_tree[222744] = { 0x01, 0xf1, 0x40, 0xf1, 0x01, 0xf2, 0x41, 0xf1, 0x01, 0xf3, 0x42, 0xf1, 0x01, 0xf4, 0x43, 0xf1, 0x01, 0xf5, 0x44, 0xf1, 0x01, 0xf6, 0x45, 0xf1, 0x01, 0xf7, 0x46, 0xf1, 0x01, 0xf8, 0x47, 0xf1, 0x01, 0xf9, 0x48, 0xf1, - 0x01, 0xfa, 0x49, 0xf1, 0x41, 0x08, 0xd1, 0xc3, 0x06, 0x42, 0xe2, 0x1c, - 0xbf, 0x26, 0x40, 0x42, 0x04, 0x00, 0x13, 0xf2, 0x01, 0x44, 0x11, 0xf1, + 0x01, 0xfa, 0x49, 0xf1, 0x41, 0x08, 0x67, 0xc9, 0x06, 0x42, 0xe8, 0x1d, + 0xbf, 0x26, 0x40, 0x42, 0x04, 0x00, 0x13, 0xf2, 0x01, 0x44, 0xd4, 0xf6, 0x01, 0xf2, 0x01, 0x42, 0x40, 0x06, 0x02, 0xf2, 0x41, 0xe3, 0xa6, 0xf1, - 0x01, 0x42, 0x26, 0x0d, 0xa7, 0xf1, 0x01, 0x45, 0x56, 0xe7, 0xa8, 0xf1, - 0x01, 0xf6, 0x4a, 0xf1, 0x41, 0x55, 0x3e, 0x39, 0xc5, 0x29, 0x00, 0x4d, - 0xae, 0x84, 0xa0, 0xf1, 0x01, 0x04, 0xf6, 0x06, 0x06, 0x43, 0x26, 0x01, - 0x93, 0xf1, 0x41, 0x4f, 0x03, 0x0c, 0x2c, 0x2e, 0x00, 0xeb, 0x9e, 0xf1, - 0x41, 0x15, 0x2d, 0x33, 0x0a, 0xec, 0x91, 0xf1, 0x01, 0x43, 0xa5, 0x98, - 0x92, 0xf1, 0x41, 0x02, 0x27, 0xf5, 0x80, 0x02, 0x95, 0x9b, 0x01, 0x96, - 0x4b, 0x97, 0x23, 0x98, 0x0f, 0x99, 0x01, 0xff, 0x43, 0x9e, 0xf3, 0x2b, - 0xf2, 0x01, 0x43, 0xb0, 0xf3, 0x3b, 0xf2, 0x41, 0x43, 0x04, 0xf4, 0x16, - 0xf2, 0x01, 0x43, 0x25, 0xf4, 0x23, 0xf2, 0x01, 0x43, 0x3a, 0xf4, 0x30, - 0xf2, 0x41, 0x43, 0xad, 0xf3, 0x1a, 0xf2, 0x01, 0x95, 0x12, 0x43, 0x01, - 0xf4, 0x32, 0xf2, 0x01, 0x43, 0x07, 0xf4, 0x33, 0xf2, 0x01, 0x43, 0x37, - 0xf4, 0x21, 0xf2, 0x41, 0x42, 0x15, 0xf5, 0x22, 0xf2, 0x01, 0x42, 0xe1, - 0xe2, 0x38, 0xf2, 0x41, 0x92, 0x3a, 0x93, 0x2c, 0x95, 0x1e, 0x43, 0xec, - 0xf3, 0x19, 0xf2, 0x01, 0x02, 0x3b, 0xf4, 0x0c, 0x43, 0x4f, 0xf4, 0x35, - 0xf2, 0x01, 0x43, 0x5e, 0xf4, 0x26, 0xf2, 0x41, 0xd8, 0x37, 0xf2, 0x01, - 0xd9, 0x36, 0xf2, 0x41, 0x42, 0x33, 0xf5, 0x1b, 0xf2, 0x01, 0x42, 0xbc, - 0xbb, 0x1f, 0xf2, 0x41, 0x42, 0x3b, 0x40, 0x2f, 0xf2, 0x01, 0x42, 0xb4, - 0xf3, 0x28, 0xf2, 0x41, 0x42, 0x25, 0xf5, 0x10, 0xf2, 0x01, 0x42, 0xc0, - 0xf3, 0x31, 0xf2, 0x01, 0x42, 0x31, 0xf5, 0x27, 0xf2, 0x41, 0x43, 0xb6, - 0xf3, 0x1e, 0xf2, 0x01, 0x92, 0x48, 0x93, 0x3a, 0x94, 0x2c, 0x43, 0xe6, - 0xf3, 0x3a, 0xf2, 0x01, 0x43, 0xfe, 0xf3, 0x24, 0xf2, 0x01, 0x99, 0x12, - 0x43, 0x19, 0xf4, 0x11, 0xf2, 0x01, 0x43, 0x40, 0xf4, 0x2c, 0xf2, 0x01, - 0x43, 0x61, 0xf4, 0x1d, 0xf2, 0x41, 0x42, 0xbb, 0x75, 0x15, 0xf2, 0x01, - 0x42, 0xf9, 0xe3, 0x17, 0xf2, 0x41, 0x42, 0xb9, 0x75, 0x34, 0xf2, 0x01, - 0x42, 0x1d, 0xf5, 0x25, 0xf2, 0x41, 0x42, 0xdb, 0x04, 0x12, 0xf2, 0x01, - 0x42, 0x16, 0xf5, 0x2e, 0xf2, 0x41, 0x42, 0x13, 0xf5, 0x20, 0xf2, 0x01, - 0x42, 0xb1, 0xf3, 0x1c, 0xf2, 0x01, 0x42, 0xf5, 0xf3, 0x39, 0xf2, 0x41, - 0x90, 0x12, 0x42, 0xb0, 0xef, 0x2d, 0xf2, 0x01, 0x42, 0x7a, 0xe2, 0x14, - 0xf2, 0x01, 0x42, 0xeb, 0xd8, 0x18, 0xf2, 0x41, 0xd0, 0x29, 0xf2, 0x01, - 0xd9, 0x2a, 0xf2, 0x41, 0xa1, 0xd9, 0x0b, 0xa2, 0xae, 0x0b, 0xa3, 0xee, - 0x0a, 0xa4, 0xb4, 0x0a, 0xa5, 0xf9, 0x09, 0xa6, 0xcc, 0x09, 0xa7, 0x82, - 0x09, 0xa8, 0xa8, 0x08, 0xa9, 0xf8, 0x07, 0xab, 0xc7, 0x06, 0xac, 0xa6, - 0x06, 0xad, 0xb2, 0x04, 0xae, 0x8a, 0x04, 0xaf, 0xdf, 0x03, 0xb0, 0xd7, - 0x02, 0xb2, 0x89, 0x02, 0xb3, 0xb9, 0x01, 0xb4, 0xa4, 0x01, 0x43, 0x01, - 0xf3, 0x06, 0x33, 0x00, 0x48, 0x49, 0xcc, 0xde, 0x33, 0x00, 0xb7, 0x19, - 0xb9, 0x01, 0xff, 0x02, 0x80, 0x12, 0x06, 0x43, 0x74, 0xa1, 0x50, 0x33, + 0x01, 0x42, 0xb4, 0x0d, 0xa7, 0xf1, 0x01, 0x45, 0x28, 0xed, 0xa8, 0xf1, + 0x01, 0xf6, 0x4a, 0xf1, 0x41, 0x55, 0x46, 0x3b, 0xc5, 0x29, 0x00, 0x4d, + 0xc3, 0x88, 0xa0, 0xf1, 0x01, 0x04, 0xf6, 0x06, 0x06, 0x43, 0x26, 0x01, + 0x93, 0xf1, 0x41, 0x4f, 0x6f, 0x0c, 0x2c, 0x2e, 0x00, 0xeb, 0x9e, 0xf1, + 0x41, 0x15, 0xde, 0x34, 0x0a, 0xec, 0x91, 0xf1, 0x01, 0x43, 0x98, 0x9d, + 0x92, 0xf1, 0x41, 0x02, 0x01, 0xfb, 0x80, 0x02, 0x95, 0x9b, 0x01, 0x96, + 0x4b, 0x97, 0x23, 0x98, 0x0f, 0x99, 0x01, 0xff, 0x43, 0x79, 0xf9, 0x2b, + 0xf2, 0x01, 0x43, 0x8b, 0xf9, 0x3b, 0xf2, 0x41, 0x43, 0xdf, 0xf9, 0x16, + 0xf2, 0x01, 0x43, 0x03, 0xfa, 0x23, 0xf2, 0x01, 0x43, 0x18, 0xfa, 0x30, + 0xf2, 0x41, 0x43, 0x88, 0xf9, 0x1a, 0xf2, 0x01, 0x95, 0x12, 0x43, 0xdc, + 0xf9, 0x32, 0xf2, 0x01, 0x43, 0xe2, 0xf9, 0x33, 0xf2, 0x01, 0x43, 0x15, + 0xfa, 0x21, 0xf2, 0x41, 0x42, 0xed, 0xfa, 0x22, 0xf2, 0x01, 0x42, 0xc2, + 0xe8, 0x38, 0xf2, 0x41, 0x92, 0x3a, 0x93, 0x2c, 0x95, 0x1e, 0x43, 0xc7, + 0xf9, 0x19, 0xf2, 0x01, 0x02, 0x19, 0xfa, 0x0c, 0x43, 0x2a, 0xfa, 0x35, + 0xf2, 0x01, 0x43, 0x36, 0xfa, 0x26, 0xf2, 0x41, 0xd8, 0x37, 0xf2, 0x01, + 0xd9, 0x36, 0xf2, 0x41, 0x42, 0x0f, 0xfb, 0x1b, 0xf2, 0x01, 0x42, 0x59, + 0xc1, 0x1f, 0xf2, 0x41, 0x42, 0x43, 0x42, 0x2f, 0xf2, 0x01, 0x42, 0x8f, + 0xf9, 0x28, 0xf2, 0x41, 0x42, 0xff, 0xfa, 0x10, 0xf2, 0x01, 0x42, 0x9b, + 0xf9, 0x31, 0xf2, 0x01, 0x42, 0x0d, 0xfb, 0x27, 0xf2, 0x41, 0x43, 0x91, + 0xf9, 0x1e, 0xf2, 0x01, 0x92, 0x48, 0x93, 0x3a, 0x94, 0x2c, 0x43, 0xc1, + 0xf9, 0x3a, 0xf2, 0x01, 0x43, 0xd9, 0xf9, 0x24, 0xf2, 0x01, 0x99, 0x12, + 0x43, 0xf7, 0xf9, 0x11, 0xf2, 0x01, 0x43, 0x1b, 0xfa, 0x2c, 0xf2, 0x01, + 0x43, 0x39, 0xfa, 0x1d, 0xf2, 0x41, 0x42, 0x11, 0x79, 0x15, 0xf2, 0x01, + 0x42, 0xda, 0xe9, 0x17, 0xf2, 0x41, 0x42, 0x0f, 0x79, 0x34, 0xf2, 0x01, + 0x42, 0xf5, 0xfa, 0x25, 0xf2, 0x41, 0x42, 0xdb, 0x04, 0x12, 0xf2, 0x01, + 0x42, 0xee, 0xfa, 0x2e, 0xf2, 0x41, 0x42, 0xeb, 0xfa, 0x20, 0xf2, 0x01, + 0x42, 0x8c, 0xf9, 0x1c, 0xf2, 0x01, 0x42, 0xd0, 0xf9, 0x39, 0xf2, 0x41, + 0x90, 0x12, 0x42, 0x73, 0xf5, 0x2d, 0xf2, 0x01, 0x42, 0x5b, 0xe8, 0x14, + 0xf2, 0x01, 0x42, 0xbb, 0xde, 0x18, 0xf2, 0x41, 0xd0, 0x29, 0xf2, 0x01, + 0xd9, 0x2a, 0xf2, 0x41, 0xa1, 0xee, 0x0b, 0xa2, 0xc3, 0x0b, 0xa3, 0x83, + 0x0b, 0xa4, 0xc9, 0x0a, 0xa5, 0x8e, 0x0a, 0xa6, 0xe1, 0x09, 0xa7, 0x97, + 0x09, 0xa8, 0xbd, 0x08, 0xa9, 0x8d, 0x08, 0xab, 0xdc, 0x06, 0xac, 0xbb, + 0x06, 0xad, 0xc7, 0x04, 0xae, 0x9f, 0x04, 0xaf, 0xf4, 0x03, 0xb0, 0xec, + 0x02, 0xb2, 0x89, 0x02, 0xb3, 0xb9, 0x01, 0xb4, 0xa4, 0x01, 0x43, 0x4c, + 0x8b, 0x06, 0x33, 0x00, 0x48, 0xef, 0xd1, 0xde, 0x33, 0x00, 0xb7, 0x19, + 0xb9, 0x01, 0xff, 0x02, 0x4e, 0x13, 0x06, 0x43, 0x88, 0xa6, 0x50, 0x33, 0x40, 0x42, 0x3b, 0x01, 0x4e, 0x33, 0x00, 0x42, 0x3d, 0x00, 0x4f, 0x33, - 0x40, 0x44, 0x94, 0x8c, 0x57, 0x33, 0x00, 0xe2, 0xdd, 0x33, 0x00, 0x04, - 0x52, 0x00, 0x01, 0xff, 0x51, 0xaf, 0x58, 0x13, 0x2b, 0x00, 0x51, 0x7b, - 0x59, 0xe0, 0x29, 0x00, 0x58, 0x29, 0x28, 0xa9, 0x25, 0x00, 0x4f, 0x26, - 0x6e, 0xa4, 0x25, 0x00, 0xac, 0x3d, 0x5a, 0x86, 0x21, 0xa6, 0x25, 0x00, - 0x50, 0xbd, 0x66, 0xe8, 0x25, 0x00, 0x4e, 0x48, 0x7d, 0x12, 0x2b, 0x00, - 0x06, 0x6d, 0x02, 0x06, 0x4d, 0x44, 0x8a, 0xa5, 0x25, 0x40, 0x05, 0xc3, - 0x00, 0x11, 0x06, 0xc8, 0x00, 0x01, 0xff, 0x53, 0xfe, 0x25, 0x14, 0x2b, - 0x00, 0x52, 0xc4, 0x55, 0xa8, 0x25, 0x40, 0x53, 0xfe, 0x25, 0xe9, 0x25, - 0x00, 0x53, 0xad, 0x4d, 0xa7, 0x25, 0x40, 0x4e, 0x80, 0x6f, 0xe7, 0x25, - 0x00, 0x05, 0x14, 0x01, 0x01, 0xff, 0x58, 0xa9, 0x29, 0x15, 0x2b, 0x00, - 0x59, 0xf8, 0x25, 0xea, 0x25, 0x40, 0x45, 0x85, 0xe0, 0x96, 0xf7, 0x01, - 0x42, 0x96, 0xa5, 0x94, 0x33, 0x00, 0x42, 0x10, 0x00, 0x27, 0x33, 0x40, - 0xa1, 0x3f, 0x03, 0x92, 0x01, 0x33, 0x46, 0x30, 0xdd, 0x21, 0x33, 0x00, - 0x0b, 0x77, 0xa1, 0x08, 0xf2, 0xdb, 0x33, 0x00, 0xf6, 0xdc, 0x33, 0x40, - 0x07, 0x9b, 0x0d, 0x11, 0x04, 0x1e, 0x00, 0x01, 0xff, 0x44, 0xc3, 0x00, + 0x40, 0x44, 0x28, 0x91, 0x57, 0x33, 0x00, 0xe2, 0xdd, 0x33, 0x00, 0x04, + 0x52, 0x00, 0x01, 0xff, 0x51, 0x29, 0x5b, 0x13, 0x2b, 0x00, 0x51, 0xf5, + 0x5b, 0xe0, 0x29, 0x00, 0x58, 0x7c, 0x29, 0xa9, 0x25, 0x00, 0x4f, 0x43, + 0x71, 0xa4, 0x25, 0x00, 0xac, 0x3d, 0x5a, 0xa7, 0x22, 0xa6, 0x25, 0x00, + 0x50, 0xca, 0x69, 0xe8, 0x25, 0x00, 0x4e, 0x0e, 0x81, 0x12, 0x2b, 0x00, + 0x06, 0x6d, 0x02, 0x06, 0x4d, 0xc1, 0x8e, 0xa5, 0x25, 0x40, 0x05, 0xc3, + 0x00, 0x11, 0x06, 0xc8, 0x00, 0x01, 0xff, 0x53, 0x51, 0x27, 0x14, 0x2b, + 0x00, 0x52, 0x3d, 0x58, 0xa8, 0x25, 0x40, 0x53, 0x51, 0x27, 0xe9, 0x25, + 0x00, 0x53, 0x03, 0x50, 0xa7, 0x25, 0x40, 0x4e, 0xac, 0x72, 0xe7, 0x25, + 0x00, 0x05, 0x14, 0x01, 0x01, 0xff, 0x58, 0x2c, 0x2b, 0x15, 0x2b, 0x00, + 0x59, 0x4b, 0x27, 0xea, 0x25, 0x40, 0x45, 0x67, 0xe6, 0x96, 0xf7, 0x01, + 0x42, 0xc0, 0xaa, 0x94, 0x33, 0x00, 0x42, 0x10, 0x00, 0x27, 0x33, 0x40, + 0xa1, 0x3f, 0x03, 0x92, 0x01, 0x33, 0x46, 0x00, 0xe3, 0x21, 0x33, 0x00, + 0x0b, 0x8b, 0xa6, 0x08, 0xf2, 0xdb, 0x33, 0x00, 0xf6, 0xdc, 0x33, 0x40, + 0x07, 0x29, 0x0e, 0x11, 0x04, 0x1e, 0x00, 0x01, 0xff, 0x44, 0xc3, 0x00, 0x7c, 0xcc, 0x01, 0x45, 0xc8, 0x00, 0x7d, 0xcc, 0x41, 0x44, 0xc3, 0x00, 0x7f, 0xcc, 0x01, 0x45, 0xc8, 0x00, 0x7e, 0xcc, 0x41, 0xe9, 0x22, 0x33, - 0x00, 0xef, 0x23, 0x33, 0x40, 0x45, 0x79, 0xe7, 0x1f, 0x33, 0x00, 0x46, - 0xb0, 0xde, 0x20, 0x33, 0x40, 0x42, 0xe8, 0x01, 0xad, 0x33, 0x80, 0x37, - 0xa5, 0x29, 0xa9, 0x15, 0x43, 0xc6, 0x6c, 0x1a, 0x22, 0x00, 0xb5, 0x01, - 0xff, 0x43, 0xec, 0x75, 0x53, 0x33, 0x00, 0x45, 0xd4, 0xeb, 0x54, 0x33, - 0x40, 0x55, 0x60, 0x3b, 0xce, 0x2a, 0x00, 0x42, 0x71, 0x00, 0x52, 0x33, - 0x00, 0x45, 0xb6, 0xeb, 0x51, 0x33, 0x40, 0x42, 0xc3, 0x16, 0x55, 0x33, - 0x00, 0x46, 0xb6, 0xde, 0x56, 0x33, 0x40, 0x47, 0xa7, 0x0c, 0xae, 0x33, - 0xc0, 0x00, 0x48, 0xd5, 0x05, 0xaf, 0x33, 0x40, 0xe1, 0xa9, 0x33, 0x80, - 0x6b, 0xe3, 0x76, 0x33, 0x00, 0xa5, 0x4b, 0xe6, 0x8a, 0x33, 0x00, 0xe8, - 0xd7, 0x33, 0x00, 0xa9, 0x2e, 0xed, 0xd8, 0x33, 0x00, 0xaf, 0x16, 0x42, - 0xff, 0xc0, 0xd9, 0x33, 0x00, 0xf2, 0xda, 0x33, 0x00, 0xf3, 0xb0, 0x33, - 0x00, 0xf6, 0xb4, 0x33, 0x00, 0xf7, 0xba, 0x33, 0x40, 0x44, 0xcc, 0x13, - 0x3d, 0x33, 0x00, 0x43, 0xc8, 0x0d, 0x40, 0x33, 0x00, 0x50, 0x2d, 0x67, - 0xd0, 0x2b, 0x40, 0x47, 0x37, 0xcf, 0x2e, 0x33, 0x00, 0xab, 0x01, 0xff, - 0xef, 0x30, 0x33, 0x00, 0x43, 0xda, 0xaa, 0x2f, 0x33, 0x40, 0x43, 0xb6, - 0x9b, 0x3b, 0x33, 0x00, 0xae, 0x06, 0x42, 0x60, 0x03, 0x37, 0x33, 0x40, - 0x43, 0x2d, 0xe7, 0x38, 0x33, 0x00, 0x42, 0x6f, 0x00, 0x3a, 0x33, 0x40, - 0x45, 0xb6, 0xe1, 0x80, 0x33, 0x00, 0xa1, 0x01, 0xff, 0x45, 0xee, 0xea, - 0x2b, 0x33, 0x00, 0x42, 0x5c, 0x01, 0x2c, 0x33, 0x40, 0x43, 0x1c, 0x70, - 0x09, 0x33, 0x00, 0x43, 0x68, 0x17, 0x0a, 0x33, 0x00, 0x4a, 0xfb, 0x2f, - 0x90, 0x22, 0x80, 0x04, 0xf6, 0x75, 0x33, 0x40, 0x04, 0xc8, 0x1e, 0x01, - 0xff, 0x48, 0xf8, 0x0c, 0x92, 0x22, 0x00, 0x4c, 0x1d, 0x2b, 0xe5, 0x22, - 0x40, 0xe1, 0x81, 0x33, 0x80, 0x1a, 0xe6, 0x8b, 0x33, 0x00, 0xed, 0x9a, - 0x33, 0x00, 0x44, 0xb6, 0x0a, 0x29, 0x33, 0x00, 0xf3, 0xb1, 0x33, 0x00, - 0xf6, 0xb5, 0x33, 0x00, 0xf7, 0xbb, 0x33, 0x40, 0x42, 0xb4, 0x01, 0x28, - 0x33, 0x40, 0x80, 0xcd, 0x01, 0xe1, 0x83, 0x33, 0x80, 0xa7, 0x01, 0xe2, - 0x86, 0x33, 0x80, 0x9b, 0x01, 0xa5, 0x85, 0x01, 0xe7, 0x8e, 0x33, 0x00, - 0x42, 0x96, 0xa5, 0x92, 0x33, 0x00, 0xa9, 0x62, 0xec, 0x96, 0x33, 0x00, - 0xed, 0x9c, 0x33, 0x80, 0x4a, 0x42, 0x61, 0x03, 0xd6, 0x33, 0x00, 0x42, - 0xbb, 0x09, 0xab, 0x33, 0x00, 0xf3, 0xb3, 0x33, 0x00, 0x02, 0x2e, 0x02, - 0x16, 0xf6, 0xb7, 0x33, 0x80, 0x0b, 0xf7, 0xbd, 0x33, 0xc0, 0x00, 0x45, - 0xe0, 0x7b, 0xbf, 0x33, 0x40, 0x45, 0xe0, 0x7b, 0xb9, 0x33, 0x40, 0xe1, - 0x82, 0x33, 0x00, 0xe6, 0x8c, 0x33, 0x00, 0xe7, 0x8d, 0x33, 0x00, 0xec, - 0x95, 0x33, 0x00, 0xed, 0x9b, 0x33, 0x00, 0xf3, 0xb2, 0x33, 0x00, 0xf6, - 0xb6, 0x33, 0x00, 0xf7, 0xbc, 0x33, 0x40, 0x80, 0x01, 0xff, 0x45, 0x8a, - 0xe5, 0xa3, 0x33, 0x00, 0x47, 0xd6, 0x05, 0x9f, 0x33, 0x40, 0x45, 0x0a, - 0xe8, 0x48, 0x33, 0x00, 0xec, 0xd5, 0x33, 0x00, 0x42, 0x0d, 0x00, 0x49, - 0x33, 0xc0, 0x00, 0x45, 0xb8, 0xe4, 0x4a, 0x33, 0x40, 0x45, 0x5a, 0xd3, - 0x4d, 0x33, 0x00, 0x42, 0x24, 0x02, 0x4b, 0x33, 0xc0, 0x00, 0x43, 0xce, - 0x13, 0x4c, 0x33, 0x40, 0x46, 0x5c, 0x07, 0xd4, 0x33, 0x40, 0x43, 0x1b, - 0x52, 0x45, 0x33, 0x00, 0xa9, 0x0c, 0x45, 0x5e, 0xe9, 0x47, 0x33, 0x00, - 0x44, 0x9d, 0xf2, 0x46, 0x33, 0x40, 0x44, 0x0a, 0xe8, 0x43, 0x33, 0x00, - 0x42, 0x3d, 0x00, 0x44, 0x33, 0x40, 0x45, 0x8a, 0xe5, 0xa5, 0x33, 0x00, - 0xaf, 0x06, 0x47, 0xd6, 0x05, 0xa1, 0x33, 0x40, 0x42, 0xe2, 0x0a, 0xc1, - 0x33, 0x00, 0x45, 0xa9, 0x0c, 0xa7, 0x33, 0xc0, 0x00, 0x48, 0xd5, 0x05, - 0xa8, 0x33, 0x40, 0x55, 0xcd, 0x3a, 0xcd, 0x2a, 0x00, 0xed, 0xd0, 0x33, - 0x00, 0xee, 0xd1, 0x33, 0x00, 0xaf, 0x04, 0xf8, 0xd3, 0x33, 0x40, 0xe7, - 0xd2, 0x33, 0x00, 0x45, 0x4b, 0x0a, 0x11, 0x23, 0x40, 0x44, 0xe1, 0xec, - 0xc0, 0x33, 0x00, 0xe1, 0x84, 0x33, 0x80, 0x8d, 0x01, 0xe2, 0x85, 0x33, - 0x00, 0x43, 0x37, 0x00, 0x89, 0x33, 0x00, 0x44, 0xf0, 0x1d, 0x1c, 0x33, - 0x00, 0xe7, 0x8f, 0x33, 0x00, 0x42, 0x96, 0xa5, 0x91, 0x33, 0x00, 0x43, - 0x3d, 0x20, 0x14, 0x33, 0x80, 0x5a, 0xeb, 0xcd, 0x33, 0x00, 0xec, 0x98, - 0x33, 0x00, 0xed, 0x9e, 0x33, 0x80, 0x36, 0xaf, 0x28, 0x42, 0xbb, 0x09, - 0xaa, 0x33, 0x00, 0xf4, 0xcf, 0x33, 0x00, 0x02, 0x42, 0x00, 0x0e, 0xf6, - 0xb8, 0x33, 0x00, 0xf7, 0xbe, 0x33, 0x00, 0x45, 0xbf, 0xec, 0x12, 0x33, - 0x40, 0x44, 0xf9, 0xf1, 0x1b, 0x33, 0x00, 0x46, 0x38, 0xe1, 0x1a, 0x33, - 0x40, 0x43, 0x59, 0x36, 0x1e, 0x33, 0x00, 0x44, 0xa1, 0xf2, 0x1d, 0x33, - 0x40, 0x80, 0x01, 0xff, 0xa3, 0x06, 0x47, 0xd6, 0x05, 0xa2, 0x33, 0x40, - 0x46, 0xe5, 0x05, 0xce, 0x33, 0x00, 0x44, 0x8b, 0xe5, 0xa6, 0x33, 0x40, - 0x46, 0x58, 0xdc, 0x15, 0x33, 0x00, 0x47, 0x58, 0xd3, 0x16, 0x33, 0x00, - 0x45, 0x60, 0xec, 0x17, 0x33, 0x40, 0x43, 0xe4, 0x0a, 0x0b, 0x33, 0x00, - 0xb2, 0x01, 0xff, 0x44, 0x94, 0x8c, 0x0c, 0x33, 0x00, 0x44, 0x0d, 0xf2, - 0x0d, 0x33, 0x40, 0x47, 0x28, 0x43, 0x8f, 0x22, 0x80, 0x15, 0xee, 0xcc, - 0x33, 0x80, 0x04, 0xf5, 0x7a, 0x33, 0x40, 0x44, 0x83, 0xa5, 0x04, 0x33, - 0x00, 0x42, 0x35, 0x00, 0x05, 0x33, 0x40, 0x04, 0xc8, 0x1e, 0x01, 0xff, - 0x48, 0xf8, 0x0c, 0x91, 0x22, 0x00, 0x4c, 0x1d, 0x2b, 0xe4, 0x22, 0x40, - 0xe1, 0xca, 0x33, 0x80, 0x4c, 0xa5, 0x3e, 0xe7, 0xcc, 0x32, 0x00, 0x4c, - 0x78, 0x90, 0x00, 0xf2, 0x01, 0xaf, 0x21, 0xf0, 0xcb, 0x33, 0x80, 0x18, - 0xb5, 0x04, 0xfa, 0x90, 0x33, 0x40, 0x46, 0xfa, 0xd9, 0x32, 0x33, 0x00, - 0x44, 0xa1, 0xf0, 0x33, 0x33, 0x00, 0x43, 0x4f, 0x03, 0x35, 0x33, 0x40, - 0xe1, 0x71, 0x33, 0x40, 0xee, 0x3f, 0x33, 0x00, 0xaf, 0x01, 0xff, 0xee, - 0x42, 0x33, 0x00, 0x42, 0x3d, 0x00, 0x41, 0x33, 0x40, 0x47, 0xa9, 0xd2, - 0x36, 0x33, 0x00, 0x44, 0xb9, 0xeb, 0x39, 0x33, 0x40, 0x43, 0xd8, 0x1f, - 0x2a, 0x33, 0x40, 0xa1, 0x35, 0xe2, 0x87, 0x33, 0x00, 0x42, 0x96, 0xa5, - 0x93, 0x33, 0x00, 0xa9, 0x17, 0x42, 0xbb, 0x09, 0xac, 0x33, 0x00, 0x45, - 0x59, 0xdc, 0x18, 0x33, 0x80, 0x04, 0xf9, 0xc9, 0x33, 0x40, 0x43, 0xce, - 0x13, 0x19, 0x33, 0x40, 0x42, 0x24, 0x02, 0x10, 0x33, 0x00, 0x43, 0x9d, - 0xf4, 0x11, 0x33, 0x00, 0x45, 0xad, 0xea, 0x13, 0x33, 0x40, 0xec, 0xff, - 0x33, 0x00, 0x43, 0xdf, 0x91, 0x0f, 0x33, 0x00, 0x43, 0xb1, 0x0e, 0x0e, - 0x33, 0x40, 0xed, 0x99, 0x33, 0x00, 0xaf, 0x01, 0xff, 0x42, 0x1b, 0x05, - 0xcd, 0x23, 0x00, 0x09, 0x98, 0xc0, 0x01, 0xff, 0x80, 0x04, 0xf3, 0xf6, - 0x26, 0x40, 0x4f, 0x65, 0x6b, 0x8b, 0xcc, 0x01, 0x49, 0xd7, 0xb7, 0x8a, - 0xcc, 0x01, 0x48, 0xc1, 0xca, 0x89, 0xcc, 0x41, 0x44, 0x1c, 0x9e, 0x08, - 0x33, 0x00, 0xb2, 0x0a, 0x47, 0x29, 0xd6, 0x07, 0x33, 0x00, 0xf6, 0xce, - 0x32, 0x40, 0x07, 0x96, 0xce, 0x04, 0xe7, 0xcd, 0x32, 0x40, 0x46, 0x88, - 0xdc, 0x7b, 0x33, 0x00, 0x45, 0xa5, 0xe8, 0x7e, 0x33, 0x00, 0x45, 0x67, - 0xea, 0xff, 0x32, 0x00, 0x46, 0x6c, 0xe0, 0x7c, 0x33, 0x00, 0x47, 0x45, - 0xd6, 0x7d, 0x33, 0x40, 0xe1, 0x72, 0x33, 0x80, 0x2c, 0xe2, 0xc8, 0x33, - 0x00, 0x43, 0x93, 0x0a, 0x25, 0x33, 0x00, 0xea, 0x90, 0xf1, 0x01, 0xec, - 0x97, 0x33, 0x00, 0xed, 0x77, 0x33, 0x80, 0x06, 0x43, 0x87, 0x08, 0x26, - 0x33, 0x40, 0x80, 0x01, 0xff, 0x45, 0x8a, 0xe5, 0x79, 0x33, 0x00, 0x47, - 0xd6, 0x05, 0x78, 0x33, 0x40, 0x43, 0x8f, 0x18, 0x24, 0x33, 0x40, 0x48, - 0x61, 0xc2, 0xc6, 0x33, 0x00, 0xa1, 0x2d, 0xe3, 0xc4, 0x33, 0x00, 0xe4, - 0xc5, 0x33, 0x00, 0xed, 0x9d, 0x33, 0x80, 0x11, 0xef, 0xc7, 0x33, 0x80, - 0x06, 0x42, 0x50, 0x02, 0x94, 0x22, 0x40, 0x49, 0x0c, 0xbf, 0x7f, 0x33, - 0x40, 0x80, 0x01, 0xff, 0x45, 0x8a, 0xe5, 0xa4, 0x33, 0x00, 0x47, 0xd6, - 0x05, 0xa0, 0x33, 0x40, 0xec, 0x88, 0x33, 0x00, 0xf0, 0x93, 0x22, 0x40, - 0xa1, 0x1c, 0x44, 0x0f, 0x11, 0x3c, 0x33, 0x00, 0x43, 0xe0, 0x7d, 0x31, - 0x33, 0x00, 0x45, 0xc2, 0xe9, 0x3e, 0x33, 0x00, 0xf1, 0xc3, 0x33, 0x00, - 0x47, 0x25, 0xd7, 0x34, 0x33, 0x40, 0x45, 0x86, 0xe4, 0x2d, 0x33, 0x00, - 0xf2, 0x74, 0x33, 0x40, 0x47, 0xc6, 0x28, 0xdf, 0x33, 0x00, 0x43, 0x3c, - 0x00, 0x03, 0x33, 0x00, 0xed, 0xc2, 0x33, 0x00, 0x44, 0xb1, 0xf1, 0x02, - 0x33, 0x00, 0xb0, 0x0a, 0x45, 0xb2, 0xea, 0x01, 0x33, 0x00, 0xf5, 0x73, - 0x33, 0x40, 0x44, 0xae, 0xa0, 0x00, 0x33, 0x00, 0x46, 0x86, 0xdb, 0x8c, - 0xcc, 0x41, 0xe1, 0x96, 0x00, 0x80, 0xbf, 0x01, 0xa5, 0x6f, 0x4d, 0xb7, - 0x83, 0x22, 0x22, 0x80, 0x57, 0xa9, 0x31, 0x02, 0x74, 0x00, 0x21, 0xaf, - 0x01, 0xff, 0x43, 0xda, 0x09, 0xfd, 0xf9, 0x01, 0xaf, 0x0c, 0x49, 0x1e, - 0xbf, 0xc5, 0xf3, 0x01, 0x4b, 0xbb, 0xa4, 0x33, 0xf4, 0x41, 0x4b, 0x3e, - 0x9e, 0xf5, 0xf9, 0x01, 0xee, 0x44, 0xf9, 0x41, 0x52, 0x58, 0x55, 0xa6, - 0xf4, 0x01, 0x44, 0xee, 0x05, 0xdf, 0xfa, 0x41, 0x43, 0xf1, 0x1a, 0x77, - 0xf5, 0x81, 0x17, 0x04, 0xdd, 0x01, 0x01, 0xff, 0x4c, 0x3c, 0x8d, 0xd3, - 0xf5, 0x01, 0x48, 0xf9, 0xc8, 0xd2, 0xf5, 0x01, 0x45, 0x5d, 0x09, 0x1a, - 0xf4, 0x41, 0x44, 0xe9, 0xec, 0x78, 0xf5, 0x41, 0x09, 0x07, 0x76, 0x01, - 0xff, 0x44, 0xc3, 0x00, 0xa0, 0x29, 0x00, 0x42, 0x50, 0x02, 0xa1, 0x29, - 0x40, 0x02, 0x6d, 0x00, 0x20, 0x10, 0x6d, 0x61, 0x14, 0xa5, 0x06, 0x4a, - 0x3e, 0xb1, 0xb7, 0x20, 0x40, 0x4a, 0xa6, 0xa8, 0xac, 0xf4, 0x01, 0x45, - 0x99, 0xe5, 0xa4, 0xf6, 0x41, 0xd1, 0x46, 0xcc, 0x01, 0xd2, 0x47, 0xcc, - 0x41, 0x4f, 0x39, 0x6a, 0x4a, 0xf6, 0x01, 0x42, 0x33, 0x00, 0x08, 0xf5, - 0x81, 0x06, 0x56, 0xce, 0x34, 0xe3, 0xf5, 0x41, 0x06, 0x50, 0x00, 0x01, - 0xff, 0x53, 0x1e, 0x2c, 0x07, 0xf5, 0x01, 0x4e, 0x62, 0x7a, 0x09, 0xf5, - 0x01, 0x51, 0x65, 0x5e, 0x0a, 0xf5, 0x41, 0x42, 0x73, 0x02, 0x20, 0x00, - 0x00, 0x46, 0x22, 0xdc, 0x5d, 0xf3, 0x01, 0xb2, 0x01, 0xff, 0x02, 0x0a, - 0x0e, 0x11, 0x03, 0x41, 0x04, 0x01, 0xff, 0x4f, 0x26, 0x6e, 0x40, 0xcc, - 0x01, 0x4d, 0x44, 0x8a, 0x41, 0xcc, 0x41, 0xe5, 0x47, 0x27, 0x80, 0x06, - 0x49, 0xe0, 0x86, 0x96, 0xf4, 0x41, 0xf3, 0x28, 0x27, 0x40, 0xa3, 0xd2, - 0x0a, 0x02, 0xc5, 0x00, 0xad, 0x0a, 0x06, 0xe5, 0xd3, 0xf6, 0x07, 0xe8, - 0x01, 0x00, 0x00, 0x03, 0x6c, 0x31, 0xd3, 0x07, 0x46, 0x3d, 0x5e, 0xc0, - 0x20, 0x00, 0x5e, 0x07, 0x14, 0x1c, 0xf5, 0x01, 0x0b, 0xc4, 0xa1, 0xde, - 0x05, 0xf3, 0x98, 0x00, 0x00, 0xb5, 0x89, 0x04, 0x06, 0x9e, 0xe1, 0x01, - 0xff, 0x17, 0x17, 0x2e, 0xe6, 0x03, 0x15, 0x36, 0x3b, 0xad, 0x03, 0x4f, - 0x90, 0x6d, 0x98, 0x1a, 0x01, 0x5b, 0xbc, 0x1b, 0xa0, 0x1a, 0x81, 0x8e, - 0x03, 0x07, 0xec, 0x05, 0x8d, 0x01, 0x05, 0xb9, 0x00, 0x71, 0xb3, 0x4d, - 0x0e, 0xbc, 0x7c, 0x41, 0x06, 0x57, 0x39, 0x01, 0xff, 0x4b, 0x5d, 0x39, - 0x5b, 0x1a, 0x01, 0x05, 0x5a, 0x03, 0x01, 0xff, 0xa1, 0x27, 0xe5, 0x54, - 0x1a, 0x01, 0xe9, 0x51, 0x1a, 0x01, 0xef, 0x55, 0x1a, 0x81, 0x16, 0xf5, - 0x53, 0x1a, 0x81, 0x0d, 0x08, 0x43, 0xc1, 0x01, 0xff, 0xec, 0x5a, 0x1a, - 0x01, 0xf2, 0x59, 0x1a, 0x41, 0xe5, 0x52, 0x1a, 0x41, 0xe5, 0x56, 0x1a, - 0x41, 0xe9, 0x57, 0x1a, 0x01, 0xf5, 0x58, 0x1a, 0x41, 0xd1, 0xa1, 0x1a, - 0x01, 0xd2, 0xa2, 0x1a, 0x41, 0x04, 0x5b, 0x03, 0x06, 0x48, 0x09, 0xcc, - 0x99, 0x1a, 0x41, 0x48, 0x3c, 0x16, 0x96, 0x1a, 0x01, 0x4b, 0x07, 0x9e, - 0x84, 0x1a, 0x01, 0x4b, 0x8f, 0xa4, 0x85, 0x1a, 0x01, 0x47, 0xf1, 0x4b, - 0x97, 0x1a, 0x41, 0x4b, 0x68, 0x9b, 0x9c, 0x1a, 0x01, 0x45, 0x12, 0xea, - 0x9d, 0x1a, 0x01, 0x44, 0xa4, 0x02, 0x9b, 0x1a, 0x01, 0x45, 0x44, 0x3a, - 0x9a, 0x1a, 0x41, 0x42, 0xea, 0x25, 0x7a, 0x1a, 0x01, 0xe1, 0x50, 0x1a, - 0x01, 0xa2, 0xe5, 0x01, 0xa3, 0xd8, 0x01, 0xa4, 0xb9, 0x01, 0xa7, 0xac, - 0x01, 0x42, 0x22, 0x00, 0x82, 0x1a, 0x01, 0xaa, 0x99, 0x01, 0xab, 0x86, - 0x01, 0x42, 0x74, 0x00, 0x7d, 0x1a, 0x01, 0x42, 0x6c, 0x00, 0x74, 0x1a, - 0x01, 0xae, 0x62, 0xb0, 0x56, 0x42, 0x71, 0x00, 0x7c, 0x1a, 0x01, 0xb3, - 0x3e, 0xb4, 0x19, 0x42, 0xf5, 0x0a, 0x7e, 0x1a, 0x01, 0x42, 0xbe, 0x22, - 0x7b, 0x1a, 0x01, 0xba, 0x01, 0xff, 0xe1, 0x79, 0x1a, 0x01, 0x42, 0x22, - 0x00, 0x78, 0x1a, 0x41, 0xe1, 0x6b, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x6c, - 0x1a, 0x01, 0xb3, 0x0d, 0xb4, 0x01, 0xff, 0xe1, 0x66, 0x1a, 0x01, 0x42, - 0x22, 0x00, 0x67, 0x1a, 0x41, 0xe1, 0x75, 0x1a, 0x01, 0x42, 0x22, 0x00, - 0x76, 0x1a, 0x41, 0xe1, 0x81, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x7f, 0x1a, - 0x01, 0x42, 0x40, 0x06, 0x80, 0x1a, 0x41, 0xe1, 0x70, 0x1a, 0x01, 0x42, - 0x22, 0x00, 0x71, 0x1a, 0x41, 0xe1, 0x6f, 0x1a, 0x01, 0x42, 0x24, 0x02, - 0x60, 0x1a, 0x01, 0x42, 0x2a, 0x05, 0x6a, 0x1a, 0x01, 0x42, 0xbe, 0x22, - 0x65, 0x1a, 0x41, 0xe1, 0x5c, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x5d, 0x1a, - 0x01, 0x43, 0xfd, 0x20, 0x83, 0x1a, 0x41, 0xe1, 0x63, 0x1a, 0x01, 0x42, - 0x22, 0x00, 0x64, 0x1a, 0x41, 0xe1, 0x5e, 0x1a, 0x01, 0x42, 0x22, 0x00, - 0x5f, 0x1a, 0x41, 0xe1, 0x6d, 0x1a, 0x01, 0xa4, 0x0c, 0x42, 0x22, 0x00, - 0x6e, 0x1a, 0x01, 0x42, 0x59, 0x00, 0x77, 0x1a, 0x41, 0xe1, 0x68, 0x1a, - 0x01, 0x42, 0x22, 0x00, 0x69, 0x1a, 0x41, 0xe1, 0x61, 0x1a, 0x01, 0x42, - 0x22, 0x00, 0x62, 0x1a, 0x41, 0xe1, 0x72, 0x1a, 0x01, 0x42, 0x22, 0x00, - 0x73, 0x1a, 0x41, 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x43, 0x96, 0x9f, - 0x1a, 0x01, 0x4c, 0x3c, 0x96, 0x9e, 0x1a, 0x41, 0x42, 0xea, 0x25, 0x95, - 0x1a, 0x01, 0xe2, 0x8f, 0x1a, 0x01, 0xe4, 0x8d, 0x1a, 0x01, 0xe7, 0x8a, - 0x1a, 0x01, 0xeb, 0x8b, 0x1a, 0x01, 0xec, 0x92, 0x1a, 0x01, 0xed, 0x90, - 0x1a, 0x01, 0xee, 0x8e, 0x1a, 0x81, 0x0d, 0xf2, 0x91, 0x1a, 0x01, 0xf3, - 0x94, 0x1a, 0xc1, 0x00, 0xe8, 0x93, 0x1a, 0x41, 0xe7, 0x8c, 0x1a, 0x41, - 0x42, 0x74, 0x00, 0x87, 0x1a, 0x01, 0x42, 0x71, 0x00, 0x86, 0x1a, 0x01, - 0xb3, 0x01, 0xff, 0xe1, 0x89, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x88, 0x1a, - 0x41, 0x56, 0xd6, 0x35, 0x17, 0x21, 0x00, 0x03, 0x53, 0x00, 0x01, 0xff, - 0x05, 0xaf, 0x23, 0x5c, 0x05, 0xda, 0x1a, 0x01, 0xff, 0x45, 0xce, 0x00, - 0x99, 0x21, 0x80, 0x3b, 0x4b, 0xc6, 0x99, 0x0b, 0x2b, 0x00, 0x4c, 0x44, - 0x8e, 0xd9, 0x21, 0x00, 0x09, 0x9c, 0x01, 0x19, 0x50, 0xed, 0x66, 0x57, - 0xf8, 0x01, 0x55, 0x01, 0x02, 0x69, 0x2b, 0x80, 0x06, 0x4b, 0x49, 0x10, - 0x03, 0x2b, 0x40, 0x47, 0xd0, 0x14, 0x79, 0x2b, 0x40, 0x43, 0x93, 0xd0, - 0x61, 0xf6, 0x01, 0x44, 0x40, 0x51, 0x51, 0xf6, 0x01, 0x49, 0x31, 0xc1, - 0x59, 0xf6, 0x41, 0x80, 0x01, 0xff, 0x54, 0x7f, 0x40, 0x2a, 0x29, 0x00, - 0x48, 0x78, 0xb4, 0xbb, 0xf8, 0x01, 0x49, 0xc3, 0x24, 0x26, 0x29, 0x40, - 0x45, 0xce, 0x00, 0x98, 0x21, 0x80, 0x3b, 0x4b, 0xc6, 0x99, 0x0a, 0x2b, - 0x00, 0x4c, 0x44, 0x8e, 0xd8, 0x21, 0x00, 0x09, 0x9c, 0x01, 0x19, 0x50, - 0xed, 0x66, 0x56, 0xf8, 0x01, 0x55, 0x01, 0x02, 0x68, 0x2b, 0x80, 0x06, - 0x4b, 0x49, 0x10, 0x02, 0x2b, 0x40, 0x47, 0xd0, 0x14, 0x78, 0x2b, 0x40, - 0x43, 0x93, 0xd0, 0x63, 0xf6, 0x01, 0x44, 0x40, 0x51, 0x53, 0xf6, 0x01, - 0x49, 0x31, 0xc1, 0x5b, 0xf6, 0x41, 0x80, 0x01, 0xff, 0x54, 0xa7, 0x40, - 0x29, 0x29, 0x00, 0x59, 0xa0, 0x23, 0x2d, 0x29, 0x00, 0x48, 0x78, 0xb4, - 0xba, 0xf8, 0x01, 0x49, 0xff, 0xbf, 0xf2, 0x21, 0x00, 0x49, 0xc3, 0x24, - 0x25, 0x29, 0x40, 0x06, 0xef, 0x06, 0x9d, 0x01, 0x07, 0xec, 0x05, 0x01, - 0xff, 0x42, 0x18, 0x0a, 0xe2, 0x10, 0x01, 0x43, 0x67, 0x4e, 0xd2, 0x10, - 0x01, 0x43, 0x28, 0xf4, 0xd3, 0x10, 0x01, 0x43, 0xe6, 0x2d, 0xd4, 0x10, - 0x01, 0xa5, 0x74, 0x43, 0x90, 0xbc, 0xd5, 0x10, 0x01, 0x43, 0x28, 0x21, - 0xde, 0x10, 0x01, 0x42, 0xf5, 0x2c, 0xe4, 0x10, 0x01, 0x43, 0x72, 0x19, - 0xe0, 0x10, 0x01, 0x43, 0x86, 0xd3, 0xdf, 0x10, 0x01, 0x43, 0x53, 0x18, - 0xd8, 0x10, 0x01, 0x02, 0x6c, 0x00, 0x44, 0xae, 0x30, 0x42, 0x18, 0x29, - 0xe6, 0x10, 0x01, 0x43, 0xe9, 0x42, 0xdb, 0x10, 0x01, 0x43, 0x5a, 0x18, - 0xdd, 0x10, 0x01, 0x43, 0xa7, 0xc6, 0xd0, 0x10, 0x01, 0x43, 0x17, 0x0a, - 0xd1, 0x10, 0x01, 0x42, 0x23, 0x58, 0xe5, 0x10, 0x01, 0x43, 0xb5, 0xd5, - 0xda, 0x10, 0x01, 0x43, 0xb2, 0x4a, 0xdc, 0x10, 0x41, 0x42, 0x18, 0x0a, - 0xd9, 0x10, 0x01, 0x43, 0x90, 0xbc, 0xd7, 0x10, 0x01, 0x43, 0xb2, 0x4a, - 0xe1, 0x10, 0x41, 0xe5, 0xe8, 0x10, 0x01, 0xe8, 0xd6, 0x10, 0x41, 0x42, - 0x4e, 0x00, 0xe3, 0x10, 0x01, 0xe8, 0xe7, 0x10, 0x41, 0x45, 0x12, 0x0b, - 0xf8, 0x10, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0xf9, 0x10, 0x01, 0x43, - 0x0e, 0x0b, 0xf1, 0x10, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, - 0xf0, 0x10, 0x41, 0x44, 0x25, 0x01, 0xf3, 0x10, 0x01, 0x42, 0x15, 0x02, - 0xf2, 0x10, 0x41, 0x44, 0xe5, 0x1d, 0xf7, 0x10, 0x01, 0x42, 0x1c, 0x26, - 0xf6, 0x10, 0x41, 0x43, 0xd2, 0x05, 0xf5, 0x10, 0x01, 0x43, 0xf6, 0x06, - 0xf4, 0x10, 0x41, 0x56, 0xcf, 0x24, 0x6a, 0xf6, 0x81, 0x0d, 0x42, 0xef, - 0x02, 0x2f, 0x00, 0xc0, 0x00, 0x4d, 0xf5, 0x7f, 0xf6, 0x29, 0x40, 0x50, - 0x3e, 0x11, 0x6b, 0xf6, 0x41, 0x0a, 0x48, 0x59, 0xda, 0x01, 0x50, 0xed, - 0x63, 0x45, 0x0f, 0x01, 0x07, 0xec, 0x05, 0x49, 0x07, 0x1a, 0x3a, 0x29, - 0x0c, 0x6d, 0x16, 0x01, 0xff, 0x4f, 0xb4, 0x42, 0x57, 0x0f, 0x01, 0x54, - 0xaf, 0x42, 0x59, 0x0f, 0x01, 0x04, 0x1f, 0x0a, 0x01, 0xff, 0x51, 0x26, - 0x59, 0x58, 0x0f, 0x01, 0x4d, 0x37, 0x8a, 0x55, 0x0f, 0xc1, 0x00, 0x4a, - 0x2d, 0x59, 0x56, 0x0f, 0x41, 0x43, 0x0e, 0x0b, 0x51, 0x0f, 0x81, 0x0f, - 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x52, 0x0f, 0x01, 0x45, 0x9a, 0x2c, - 0x53, 0x0f, 0x41, 0x48, 0x70, 0x11, 0x54, 0x0f, 0x41, 0xa1, 0x79, 0x44, - 0x61, 0xef, 0x31, 0x0f, 0x01, 0x44, 0xe1, 0xef, 0x43, 0x0f, 0x01, 0x45, - 0xfe, 0xaa, 0x32, 0x0f, 0x01, 0x42, 0xb0, 0x01, 0x33, 0x0f, 0x81, 0x5a, - 0x44, 0xed, 0xf0, 0x38, 0x0f, 0x01, 0xac, 0x46, 0x43, 0xb4, 0x05, 0x3a, - 0x0f, 0x01, 0x43, 0xde, 0x22, 0x3b, 0x0f, 0x01, 0x42, 0x6f, 0x02, 0x3e, - 0x0f, 0x01, 0x49, 0x7d, 0x66, 0x40, 0x0f, 0x01, 0xb3, 0x18, 0x43, 0xc5, - 0xc4, 0x42, 0x0f, 0x01, 0x43, 0x9f, 0x8a, 0x34, 0x0f, 0x01, 0x44, 0xa8, - 0x52, 0x37, 0x0f, 0x01, 0x45, 0xa2, 0x52, 0x35, 0x0f, 0x41, 0xa1, 0x06, - 0x43, 0x7a, 0x16, 0x41, 0x0f, 0x41, 0x43, 0xcd, 0xea, 0x3f, 0x0f, 0x01, - 0x44, 0x69, 0xe4, 0x3c, 0x0f, 0x41, 0x45, 0x6b, 0xdc, 0x39, 0x0f, 0x01, - 0x43, 0x9a, 0x5a, 0x44, 0x0f, 0x41, 0x42, 0x53, 0x00, 0x36, 0x0f, 0x41, - 0x44, 0x33, 0x3d, 0x30, 0x0f, 0x01, 0x43, 0x9a, 0x1a, 0x3d, 0x0f, 0x41, - 0x06, 0x9b, 0x13, 0x43, 0x04, 0x03, 0x0c, 0x33, 0x05, 0xaf, 0x14, 0x23, - 0x4f, 0xe8, 0x6f, 0x4e, 0x0f, 0x01, 0x4a, 0x3a, 0xb0, 0x4f, 0x0f, 0x01, - 0x4c, 0xc5, 0x0e, 0x50, 0x0f, 0x01, 0x09, 0xf1, 0x0b, 0x01, 0xff, 0x45, - 0x5c, 0x00, 0x49, 0x0f, 0x01, 0x45, 0x20, 0x07, 0x47, 0x0f, 0x41, 0x45, - 0x5c, 0x00, 0x4c, 0x0f, 0x01, 0x45, 0x20, 0x07, 0x4d, 0x0f, 0x41, 0x45, - 0x5c, 0x00, 0x48, 0x0f, 0x01, 0x45, 0x20, 0x07, 0x46, 0x0f, 0x41, 0x45, - 0x5c, 0x00, 0x4a, 0x0f, 0x01, 0x45, 0x20, 0x07, 0x4b, 0x0f, 0x41, 0x80, - 0x0c, 0x44, 0xe9, 0x1c, 0x4e, 0xf9, 0x01, 0x54, 0xab, 0x46, 0x94, 0x23, - 0x40, 0x46, 0x9d, 0x63, 0xad, 0x00, 0x00, 0x49, 0x17, 0xba, 0x66, 0xf3, - 0x01, 0x51, 0x6c, 0x39, 0xac, 0xf5, 0x41, 0x48, 0xb9, 0xc4, 0xbd, 0x26, - 0x00, 0x42, 0x6e, 0x00, 0xe6, 0xf9, 0x41, 0xa1, 0x2a, 0x4b, 0xb5, 0x9b, - 0x27, 0xf9, 0x01, 0x02, 0xd1, 0x00, 0x01, 0xff, 0x50, 0x1d, 0x60, 0xd4, - 0xf3, 0x01, 0x47, 0xae, 0xcf, 0xc2, 0xf3, 0x01, 0x45, 0xf8, 0x2e, 0x44, - 0x27, 0x00, 0x43, 0x5d, 0x18, 0x03, 0x26, 0xc0, 0x00, 0x4d, 0x0f, 0x80, - 0xc4, 0x26, 0x40, 0x42, 0x62, 0x01, 0x0c, 0xf4, 0x01, 0x42, 0x37, 0x01, - 0x0d, 0xf4, 0xc1, 0x00, 0x47, 0x15, 0x08, 0xfa, 0xcc, 0x41, 0xa1, 0x86, - 0x01, 0xa9, 0x06, 0x4c, 0x78, 0x7c, 0xac, 0xf6, 0x41, 0xac, 0x06, 0x4a, - 0x94, 0xb0, 0x0f, 0xf6, 0x41, 0xe5, 0x23, 0x23, 0x00, 0x04, 0xa1, 0x01, - 0x01, 0xff, 0x0e, 0x64, 0x1f, 0x5d, 0x0a, 0x0c, 0x08, 0x01, 0xff, 0xa8, - 0x44, 0x4a, 0x57, 0x29, 0x03, 0xf6, 0x81, 0x26, 0xb3, 0x06, 0x44, 0x22, - 0x0d, 0x72, 0xf9, 0x41, 0x4b, 0x73, 0x1f, 0x0a, 0xf6, 0x81, 0x06, 0x49, - 0x74, 0xc0, 0x0e, 0xf6, 0x41, 0x05, 0x19, 0x00, 0x01, 0xff, 0x53, 0xd1, - 0x49, 0x2d, 0xf9, 0x01, 0x4c, 0x00, 0x96, 0x70, 0xf9, 0x41, 0x05, 0x19, - 0x00, 0x01, 0xff, 0x4a, 0xf8, 0x75, 0x05, 0xf6, 0x01, 0x4c, 0x72, 0x1f, - 0x04, 0xf6, 0x01, 0x53, 0x9a, 0x4d, 0x06, 0xf6, 0x41, 0x43, 0xc8, 0x4d, - 0x07, 0xf6, 0x01, 0x50, 0x8c, 0x5a, 0x0d, 0xf6, 0x01, 0x44, 0xb0, 0x7f, - 0x08, 0xf6, 0x41, 0x51, 0x8b, 0x5a, 0x3b, 0xf6, 0x01, 0x4a, 0x57, 0x29, - 0x3a, 0xf6, 0x41, 0x02, 0x60, 0x07, 0x06, 0x4a, 0x30, 0x4f, 0x33, 0x2a, - 0x40, 0x80, 0x0d, 0x47, 0xf7, 0xd0, 0xaa, 0x2a, 0xc0, 0x00, 0x4c, 0x0d, - 0x29, 0xac, 0x2a, 0x40, 0xa1, 0xfc, 0x02, 0x4c, 0xe8, 0x8c, 0x39, 0xf5, - 0x01, 0x02, 0x13, 0x05, 0xc1, 0x02, 0x4b, 0x31, 0x9b, 0x69, 0xfe, 0x00, - 0xa5, 0x8e, 0x02, 0x49, 0x81, 0x16, 0x52, 0xfe, 0x00, 0x51, 0x69, 0x5a, - 0x65, 0xfe, 0x00, 0x4c, 0xdc, 0x8f, 0x63, 0xfe, 0x00, 0x51, 0xf1, 0x5a, - 0x51, 0xfe, 0x00, 0x02, 0x68, 0x00, 0xd5, 0x01, 0x4b, 0x64, 0xa0, 0x5f, - 0xfe, 0x00, 0x4e, 0x9a, 0x7a, 0x38, 0xf5, 0x01, 0xb0, 0xba, 0x01, 0x4d, - 0xc1, 0x34, 0x56, 0xfe, 0x00, 0xb2, 0x20, 0x49, 0x42, 0xbf, 0x54, 0xfe, - 0x00, 0xb4, 0x0c, 0x54, 0x6f, 0x46, 0xfa, 0xcd, 0x01, 0x51, 0x31, 0x5f, - 0x61, 0x2a, 0x40, 0x44, 0x38, 0x23, 0xdc, 0x02, 0x00, 0x60, 0xf2, 0x0b, - 0x3b, 0x0b, 0x41, 0x4e, 0x6e, 0x72, 0x68, 0xfe, 0x00, 0x05, 0xc9, 0x00, - 0x76, 0x0d, 0xea, 0x86, 0x01, 0xff, 0xa5, 0x63, 0xa6, 0x46, 0x44, 0xea, - 0x2a, 0x78, 0x21, 0x00, 0x43, 0x0e, 0x0b, 0x70, 0x21, 0x80, 0x2a, 0xb3, - 0x1c, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x79, 0x21, 0x00, 0x44, 0x25, - 0x01, 0x72, 0x21, 0x00, 0xb7, 0x01, 0xff, 0x44, 0x02, 0x2c, 0x7b, 0x21, - 0x00, 0xef, 0x71, 0x21, 0x40, 0x44, 0xe5, 0x1d, 0x76, 0x21, 0x00, 0x42, - 0x1c, 0x26, 0x75, 0x21, 0x40, 0x80, 0x01, 0xff, 0x47, 0x71, 0x11, 0x7d, - 0x21, 0x00, 0x48, 0x47, 0x5e, 0x7f, 0x21, 0x40, 0xa9, 0x06, 0x43, 0xf6, - 0x06, 0x73, 0x21, 0x40, 0x43, 0x59, 0x4d, 0x7c, 0x21, 0x00, 0x42, 0x32, - 0x00, 0x74, 0x21, 0xc0, 0x00, 0x48, 0x70, 0x11, 0x7e, 0x21, 0x40, 0x44, - 0xc9, 0x00, 0x77, 0x21, 0x00, 0x45, 0xbb, 0x6f, 0x7a, 0x21, 0x40, 0x4d, - 0x72, 0x0b, 0x5c, 0xfe, 0x00, 0x4b, 0xda, 0x21, 0x5a, 0xfe, 0x00, 0x56, - 0x54, 0x09, 0x5e, 0xfe, 0x40, 0x4b, 0x02, 0x9c, 0x6a, 0xfe, 0x00, 0x48, - 0xe7, 0x71, 0x62, 0xfe, 0x40, 0x03, 0xc5, 0x00, 0x06, 0x4c, 0x88, 0x95, - 0x64, 0xfe, 0x40, 0x4d, 0x72, 0x0b, 0x5b, 0xfe, 0x00, 0x4b, 0xda, 0x21, - 0x59, 0xfe, 0x00, 0x56, 0x54, 0x09, 0x5d, 0xfe, 0x40, 0x49, 0x67, 0x92, - 0x0a, 0x22, 0x80, 0x12, 0x46, 0xe3, 0xc2, 0x58, 0xfe, 0x00, 0x4a, 0x49, - 0x13, 0x66, 0xfe, 0x00, 0x4f, 0xae, 0x00, 0x57, 0xfe, 0x40, 0x06, 0x50, - 0x00, 0x01, 0xff, 0x47, 0xfb, 0x7f, 0xf7, 0x22, 0x00, 0x68, 0x30, 0x05, - 0xf4, 0x22, 0x40, 0x43, 0xd7, 0x02, 0x55, 0xfe, 0x00, 0x02, 0x15, 0x05, - 0x1c, 0x07, 0x7f, 0x69, 0x01, 0xff, 0x49, 0x78, 0xb6, 0x0d, 0x22, 0x00, - 0x05, 0x51, 0x00, 0x01, 0xff, 0x47, 0xfb, 0x7f, 0xfe, 0x22, 0x00, 0x68, - 0x30, 0x05, 0xfc, 0x22, 0x40, 0xe1, 0x50, 0xfe, 0x00, 0x49, 0xa6, 0xb8, - 0x6b, 0xfe, 0x40, 0x47, 0x2d, 0x34, 0xe9, 0xf6, 0x01, 0x48, 0x2e, 0x3e, - 0x60, 0xfe, 0x00, 0x47, 0x3d, 0x0d, 0x61, 0xfe, 0x40, 0xa1, 0x6c, 0xa5, - 0x40, 0xa9, 0x27, 0xaf, 0x01, 0xff, 0xb0, 0x0d, 0xb4, 0x01, 0xff, 0x48, - 0x86, 0x48, 0xb0, 0xf3, 0x01, 0xe8, 0xa5, 0xf9, 0x41, 0xe5, 0x33, 0x23, - 0x00, 0x0a, 0xee, 0xab, 0x01, 0xff, 0x43, 0x1a, 0x00, 0x58, 0x2a, 0x00, - 0x42, 0x0c, 0x00, 0x57, 0x2a, 0x40, 0x4b, 0x1e, 0x9a, 0x55, 0xf3, 0x01, - 0x06, 0xa0, 0x79, 0x01, 0xff, 0x4d, 0x28, 0x83, 0x41, 0xf6, 0x01, 0x4c, - 0x7c, 0x95, 0x42, 0xf6, 0x41, 0xe4, 0xf7, 0xf6, 0x01, 0x02, 0xeb, 0x0a, - 0x06, 0x4a, 0x46, 0xb3, 0x75, 0xf5, 0x41, 0x04, 0xa1, 0x01, 0x06, 0x46, - 0xa5, 0xd5, 0x2a, 0xf6, 0x41, 0x4d, 0x50, 0x80, 0xcc, 0xf6, 0x01, 0x44, - 0x0c, 0x08, 0x34, 0xf6, 0x01, 0x46, 0x16, 0x08, 0xa4, 0xf4, 0x41, 0x05, - 0x76, 0x00, 0x06, 0x4e, 0xa6, 0x7e, 0x73, 0xa6, 0x40, 0x0c, 0xa1, 0x28, - 0x11, 0x13, 0xbf, 0x4b, 0x01, 0xff, 0x49, 0x0b, 0xbd, 0x5a, 0x2b, 0x00, - 0x4d, 0x08, 0x88, 0x5c, 0x2b, 0x40, 0x4c, 0x87, 0x00, 0x96, 0x2a, 0x80, - 0x0d, 0x49, 0xec, 0x00, 0x95, 0x2a, 0xc0, 0x00, 0x50, 0xad, 0x60, 0x97, - 0x2a, 0x40, 0x50, 0xad, 0x60, 0x98, 0x2a, 0x40, 0x48, 0xe1, 0xc3, 0xf9, - 0xf6, 0x01, 0xa9, 0x16, 0xb5, 0x01, 0xff, 0x42, 0x60, 0x07, 0x80, 0xf4, - 0x81, 0x06, 0x42, 0xce, 0x25, 0xa8, 0xf9, 0x41, 0x4f, 0xcc, 0x4a, 0x20, - 0x26, 0x40, 0x4d, 0x32, 0x7f, 0xbf, 0xf3, 0x01, 0x42, 0x33, 0x00, 0xf7, - 0x26, 0x40, 0xa4, 0xc2, 0x31, 0x02, 0x5c, 0x03, 0xf6, 0x07, 0x51, 0xce, - 0x5b, 0xfe, 0xf5, 0x01, 0x06, 0x17, 0xd2, 0xc4, 0x07, 0xae, 0x30, 0xb8, - 0x01, 0xff, 0x02, 0x9b, 0x01, 0x0c, 0x4d, 0x43, 0x80, 0x06, 0x20, 0x00, - 0x55, 0x69, 0x3e, 0x3a, 0x27, 0x40, 0x60, 0x94, 0x0f, 0x3e, 0x27, 0x00, - 0x07, 0x34, 0x08, 0x01, 0xff, 0x4a, 0x0f, 0x2c, 0x36, 0x27, 0x00, 0x4d, - 0x28, 0x13, 0xcd, 0xf7, 0x01, 0x54, 0x0b, 0x46, 0x2f, 0xf5, 0x41, 0x46, - 0x32, 0xdb, 0x3f, 0x22, 0x00, 0x03, 0x06, 0x02, 0xc1, 0x06, 0x05, 0xf2, - 0xe6, 0x01, 0xff, 0x08, 0xb8, 0x80, 0xa4, 0x05, 0xac, 0xae, 0x01, 0x56, - 0x86, 0x36, 0xf4, 0x0d, 0x00, 0x05, 0x5a, 0x03, 0x89, 0x01, 0x0b, 0x55, - 0x77, 0x01, 0xff, 0x4a, 0x2d, 0x6c, 0xcf, 0x0d, 0x00, 0x05, 0x28, 0x6c, - 0x52, 0x02, 0x24, 0x02, 0x42, 0xab, 0x01, 0xff, 0x05, 0xdc, 0xb8, 0x29, - 0x04, 0x8e, 0xd2, 0x01, 0xff, 0x45, 0xca, 0xe1, 0xdb, 0x0d, 0x00, 0x42, - 0xf5, 0x0a, 0xd9, 0x0d, 0xc0, 0x00, 0x05, 0xd9, 0xe1, 0x01, 0xff, 0x4a, - 0x2d, 0x6c, 0xdc, 0x0d, 0x00, 0x4f, 0x28, 0x6c, 0xdd, 0x0d, 0x00, 0x4b, - 0x65, 0x9c, 0xde, 0x0d, 0x40, 0x4a, 0x98, 0xa7, 0xd0, 0x0d, 0x00, 0x48, - 0x61, 0xc7, 0xd2, 0x0d, 0x00, 0x49, 0xfe, 0xbd, 0xd4, 0x0d, 0x40, 0x4a, - 0x40, 0xaa, 0xd8, 0x0d, 0x00, 0x49, 0x67, 0x9c, 0xdf, 0x0d, 0x40, 0x4a, - 0x98, 0xa7, 0xd1, 0x0d, 0x00, 0x02, 0x24, 0x02, 0x12, 0x48, 0x61, 0xc7, - 0xd3, 0x0d, 0x00, 0x47, 0x8d, 0xd2, 0xda, 0x0d, 0x00, 0x49, 0xfe, 0xbd, - 0xd6, 0x0d, 0x40, 0x4a, 0x40, 0xaa, 0xf2, 0x0d, 0x00, 0x49, 0x67, 0x9c, - 0xf3, 0x0d, 0x40, 0xa1, 0x0c, 0x4b, 0xd9, 0x23, 0x81, 0x0d, 0x00, 0x49, - 0x3a, 0xc1, 0x83, 0x0d, 0x40, 0x48, 0xa9, 0xc7, 0xca, 0x0d, 0x00, 0x49, - 0xde, 0xbc, 0x82, 0x0d, 0x40, 0x06, 0xed, 0x05, 0x47, 0x0a, 0x3e, 0xac, - 0x01, 0xff, 0x45, 0x12, 0x0b, 0xee, 0x0d, 0x00, 0xa6, 0x2e, 0x44, 0xea, - 0x2a, 0xef, 0x0d, 0x00, 0x43, 0x0e, 0x0b, 0xe7, 0x0d, 0x00, 0xb3, 0x14, - 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xe6, 0x0d, 0x40, 0x44, 0x25, 0x01, 0xe9, - 0x0d, 0x00, 0x42, 0x15, 0x02, 0xe8, 0x0d, 0x40, 0x44, 0xe5, 0x1d, 0xed, - 0x0d, 0x00, 0x42, 0x1c, 0x26, 0xec, 0x0d, 0x40, 0x43, 0xd2, 0x05, 0xeb, - 0x0d, 0x00, 0x43, 0xf6, 0x06, 0xea, 0x0d, 0x40, 0xa1, 0xb4, 0x02, 0x08, - 0x21, 0xc5, 0x9d, 0x02, 0xa5, 0x8e, 0x02, 0x47, 0x2f, 0xd1, 0xc6, 0x0d, - 0x00, 0x47, 0x98, 0xd1, 0xc4, 0x0d, 0x00, 0xa9, 0xd3, 0x01, 0x52, 0x2a, - 0x53, 0x9e, 0x0d, 0x00, 0xad, 0x67, 0xaf, 0x59, 0x47, 0x50, 0xd5, 0xbb, - 0x0d, 0x00, 0x08, 0xc9, 0xca, 0x35, 0x08, 0x71, 0xcb, 0x1a, 0xb5, 0x0c, - 0x47, 0x4f, 0xd7, 0xc0, 0x0d, 0x00, 0x47, 0xf7, 0xd7, 0xba, 0x0d, 0x40, - 0x46, 0x32, 0xe1, 0x8c, 0x0d, 0x00, 0x45, 0x60, 0x69, 0x8b, 0x0d, 0x40, - 0x4a, 0x32, 0x53, 0xa4, 0x0d, 0x00, 0x02, 0x40, 0x06, 0x01, 0xff, 0x52, - 0x14, 0x54, 0xa5, 0x0d, 0x00, 0x45, 0x60, 0x69, 0xc1, 0x0d, 0x40, 0xa4, - 0x0c, 0x47, 0x52, 0xd1, 0x9f, 0x0d, 0x00, 0x47, 0x4e, 0xd2, 0xa6, 0x0d, - 0x40, 0x46, 0x6c, 0x9f, 0xb3, 0x0d, 0x00, 0x47, 0x5d, 0xd0, 0xac, 0x0d, - 0x40, 0x46, 0x5f, 0x69, 0x95, 0x0d, 0x00, 0x45, 0x60, 0x69, 0x94, 0x0d, - 0x40, 0xa1, 0x17, 0x09, 0xe0, 0xc0, 0x01, 0xff, 0x47, 0xda, 0xd2, 0xc5, - 0x0d, 0x00, 0x47, 0x90, 0xd3, 0xab, 0x0d, 0x00, 0x47, 0xce, 0xd5, 0xc2, - 0x0d, 0x40, 0x0a, 0x26, 0xab, 0x06, 0x45, 0x60, 0x69, 0xb8, 0x0d, 0x40, - 0x47, 0x6b, 0x9f, 0xb7, 0x0d, 0x00, 0x47, 0xed, 0xcf, 0xa1, 0x0d, 0x00, - 0xa4, 0x27, 0x47, 0x52, 0xd1, 0x9d, 0x0d, 0x00, 0x47, 0x4e, 0xd2, 0xa3, - 0x0d, 0x00, 0x47, 0x71, 0xd2, 0x9b, 0x0d, 0x00, 0x47, 0xaf, 0xd4, 0xb5, - 0x0d, 0x00, 0xb4, 0x01, 0xff, 0x46, 0x6c, 0x9f, 0xae, 0x0d, 0x00, 0x47, - 0x5a, 0xd6, 0xa8, 0x0d, 0x40, 0x46, 0x6c, 0x9f, 0xb0, 0x0d, 0x00, 0x47, - 0x5d, 0xd0, 0xaa, 0x0d, 0x40, 0x46, 0x6c, 0xdd, 0x8a, 0x0d, 0x00, 0x02, - 0xc7, 0x15, 0x16, 0x02, 0x3d, 0x00, 0x06, 0x45, 0x60, 0x69, 0x89, 0x0d, - 0x40, 0x46, 0x32, 0xe1, 0x8e, 0x0d, 0x00, 0x45, 0x60, 0x69, 0x8d, 0x0d, - 0x40, 0x46, 0x32, 0xe1, 0x90, 0x0d, 0x00, 0x45, 0x60, 0x69, 0x8f, 0x0d, - 0x40, 0x46, 0xc2, 0xdb, 0x92, 0x0d, 0x00, 0x45, 0x60, 0x69, 0x91, 0x0d, - 0x40, 0x47, 0xda, 0xd2, 0xbd, 0x0d, 0x00, 0x47, 0x90, 0xd3, 0xb1, 0x0d, - 0x00, 0x47, 0xce, 0xd5, 0xc3, 0x0d, 0x40, 0x46, 0x6c, 0x9f, 0x86, 0x0d, - 0x00, 0xa5, 0x5d, 0x46, 0x6c, 0xdd, 0x93, 0x0d, 0x00, 0x0a, 0x9c, 0xad, - 0x12, 0x4b, 0x67, 0x9f, 0xb9, 0x0d, 0x00, 0x46, 0x32, 0xe1, 0x96, 0x0d, - 0x00, 0x45, 0x60, 0x69, 0x85, 0x0d, 0x40, 0x47, 0x6b, 0x9f, 0xb6, 0x0d, - 0x00, 0x47, 0xed, 0xcf, 0xa0, 0x0d, 0x00, 0xa4, 0x27, 0x47, 0x52, 0xd1, - 0x9c, 0x0d, 0x00, 0x47, 0x4e, 0xd2, 0xa2, 0x0d, 0x00, 0x47, 0x71, 0xd2, - 0x9a, 0x0d, 0x00, 0x47, 0xaf, 0xd4, 0xb4, 0x0d, 0x00, 0xb4, 0x01, 0xff, - 0x46, 0x6c, 0x9f, 0xad, 0x0d, 0x00, 0x47, 0x5a, 0xd6, 0xa7, 0x0d, 0x40, - 0x46, 0x6c, 0x9f, 0xaf, 0x0d, 0x00, 0x47, 0x5d, 0xd0, 0xa9, 0x0d, 0x40, - 0x46, 0xc2, 0xdb, 0x88, 0x0d, 0x00, 0x45, 0x60, 0x69, 0x87, 0x0d, 0x40, - 0x06, 0xef, 0x06, 0x52, 0x07, 0x1a, 0x3a, 0x01, 0xff, 0x46, 0x50, 0xdb, - 0xf1, 0x11, 0x01, 0xa6, 0x39, 0x46, 0xc7, 0x2c, 0xf2, 0x11, 0x01, 0x04, - 0x0e, 0x0b, 0x23, 0xb3, 0x15, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0xea, - 0x11, 0x01, 0x45, 0x7a, 0x11, 0xec, 0x11, 0x01, 0x45, 0x9a, 0x2c, 0xeb, - 0x11, 0x41, 0x46, 0xe5, 0x1d, 0xf0, 0x11, 0x01, 0x44, 0x66, 0xdd, 0xef, - 0x11, 0x41, 0x47, 0x71, 0x11, 0xf3, 0x11, 0x01, 0x48, 0x47, 0x5e, 0xf4, - 0x11, 0x41, 0x44, 0x58, 0x4d, 0xee, 0x11, 0x01, 0x44, 0xd5, 0x51, 0xed, - 0x11, 0x41, 0x45, 0x12, 0x0b, 0xe8, 0x11, 0x01, 0xa6, 0x29, 0x44, 0xea, - 0x2a, 0xe9, 0x11, 0x01, 0x43, 0x0e, 0x0b, 0xe1, 0x11, 0x01, 0xb3, 0x0f, - 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0xe3, 0x11, 0x01, 0x42, 0x15, 0x02, - 0xe2, 0x11, 0x41, 0x44, 0xe5, 0x1d, 0xe7, 0x11, 0x01, 0x42, 0x1c, 0x26, - 0xe6, 0x11, 0x41, 0x43, 0xd2, 0x05, 0xe5, 0x11, 0x01, 0x43, 0xf6, 0x06, - 0xe4, 0x11, 0x41, 0x80, 0x0d, 0x07, 0xee, 0xcd, 0x01, 0xff, 0xd2, 0x8e, - 0x00, 0x00, 0xd3, 0x8f, 0x00, 0x40, 0x54, 0xe6, 0x17, 0x9a, 0x00, 0x00, - 0x5c, 0xde, 0x17, 0x99, 0x00, 0x00, 0x5e, 0x53, 0x13, 0x1b, 0x20, 0x00, - 0xac, 0x17, 0x63, 0x87, 0x0b, 0x3a, 0x20, 0x00, 0x07, 0xea, 0xd5, 0x01, - 0xff, 0x44, 0x25, 0x01, 0x8f, 0x00, 0x00, 0x42, 0x15, 0x02, 0x8e, 0x00, - 0x40, 0x61, 0xea, 0x0d, 0x39, 0x20, 0x00, 0x53, 0x0b, 0x4c, 0x1a, 0x20, - 0x40, 0x06, 0x5c, 0x00, 0x17, 0x4d, 0x1a, 0x86, 0x6c, 0x2a, 0x00, 0x03, - 0xc8, 0x07, 0x01, 0xff, 0x4c, 0x87, 0x00, 0x9e, 0x2a, 0x00, 0x49, 0xec, - 0x00, 0x9d, 0x2a, 0x40, 0x5e, 0x35, 0x13, 0xa0, 0x2a, 0x00, 0x5b, 0x5e, - 0x1c, 0x9f, 0x2a, 0x40, 0x4d, 0xa7, 0x7f, 0x18, 0xf9, 0x01, 0x08, 0xb9, - 0xcc, 0x01, 0xff, 0x04, 0x56, 0x8d, 0x96, 0x29, 0x02, 0x63, 0x09, 0xea, - 0x28, 0xa3, 0xc2, 0x28, 0xa4, 0xd7, 0x27, 0xa5, 0xf8, 0x25, 0xa6, 0xec, - 0x24, 0x06, 0x4c, 0xdc, 0xd5, 0x24, 0xa8, 0xc7, 0x14, 0xac, 0xc2, 0x13, - 0x02, 0xc3, 0x07, 0x8c, 0x06, 0xae, 0xe3, 0x05, 0x4b, 0xda, 0x21, 0x8b, - 0xda, 0x01, 0xb2, 0xdf, 0x03, 0xb3, 0xe1, 0x02, 0xb4, 0x0c, 0x62, 0x44, - 0x0d, 0x75, 0xda, 0x01, 0x5b, 0x29, 0x1e, 0x6f, 0xda, 0x41, 0xa5, 0x84, - 0x02, 0xaf, 0x92, 0x01, 0x06, 0x94, 0xdf, 0x01, 0xff, 0x0b, 0x85, 0x49, - 0x52, 0x0a, 0x29, 0x1e, 0x01, 0xff, 0x0b, 0x42, 0x99, 0x37, 0x09, 0x03, - 0xbf, 0x06, 0x47, 0xe3, 0xd5, 0x51, 0xd9, 0x41, 0x0b, 0x85, 0x49, 0x17, - 0x0a, 0x29, 0x1e, 0x01, 0xff, 0x4b, 0x1a, 0x5a, 0x4d, 0xd9, 0x01, 0x46, - 0x3b, 0x01, 0x4c, 0xd9, 0x01, 0x46, 0xdf, 0x09, 0x4b, 0xd9, 0x41, 0x4b, - 0x1a, 0x5a, 0x50, 0xd9, 0x01, 0x46, 0x3b, 0x01, 0x4f, 0xd9, 0x01, 0x46, - 0xdf, 0x09, 0x4e, 0xd9, 0x41, 0x46, 0x3b, 0x01, 0x53, 0xd9, 0x01, 0x46, - 0xdf, 0x09, 0x52, 0xd9, 0x01, 0x46, 0x86, 0x1d, 0x54, 0xd9, 0x41, 0x09, - 0x03, 0xbf, 0x06, 0x47, 0xe3, 0xd5, 0x87, 0xd9, 0x41, 0x0b, 0x85, 0x49, - 0x17, 0x0a, 0x29, 0x1e, 0x01, 0xff, 0x4b, 0x1a, 0x5a, 0x86, 0xd9, 0x01, - 0x46, 0x3b, 0x01, 0x85, 0xd9, 0x01, 0x46, 0xdf, 0x09, 0x84, 0xd9, 0x41, - 0x4b, 0x1a, 0x5a, 0x83, 0xd9, 0x01, 0x46, 0x3b, 0x01, 0x82, 0xd9, 0x01, - 0x46, 0xdf, 0x09, 0x81, 0xd9, 0x41, 0x05, 0x36, 0xe9, 0x32, 0x04, 0x91, - 0xf2, 0x17, 0x04, 0xf6, 0xe8, 0x01, 0xff, 0x47, 0xc0, 0x09, 0x07, 0xd9, - 0x01, 0x48, 0x67, 0x44, 0x06, 0xd9, 0x01, 0x46, 0xdf, 0x09, 0x05, 0xd9, - 0x41, 0x53, 0x85, 0x49, 0x74, 0xda, 0x01, 0x0a, 0x29, 0x1e, 0x01, 0xff, - 0x4b, 0xce, 0x9a, 0x73, 0xda, 0x01, 0x50, 0x8d, 0x67, 0x72, 0xda, 0x41, - 0x07, 0x73, 0x02, 0x29, 0x54, 0x63, 0x43, 0x5d, 0xda, 0x01, 0x4c, 0x38, - 0x91, 0x5a, 0xda, 0x01, 0x53, 0x3a, 0x4b, 0x5e, 0xda, 0x01, 0x50, 0x7d, - 0x67, 0x59, 0xda, 0x01, 0x04, 0x49, 0x0c, 0x01, 0xff, 0x4c, 0xc4, 0x8c, - 0x5b, 0xda, 0x01, 0x55, 0xa8, 0x3e, 0x5c, 0xda, 0x41, 0x4c, 0xb1, 0x3e, - 0x60, 0xda, 0x01, 0x4c, 0x7d, 0x67, 0x5f, 0xda, 0x41, 0x43, 0xf5, 0x25, - 0x61, 0xda, 0x81, 0x17, 0x0b, 0x4e, 0xa0, 0x01, 0xff, 0x44, 0x48, 0x0b, - 0x2d, 0xda, 0x01, 0x43, 0x13, 0x01, 0x2f, 0xda, 0x01, 0x46, 0x7d, 0x02, - 0x2e, 0xda, 0x41, 0x80, 0x01, 0xff, 0x49, 0xd2, 0xb6, 0x67, 0xda, 0x01, - 0x48, 0x19, 0x5e, 0x62, 0xda, 0x01, 0x03, 0xb6, 0x00, 0x01, 0xff, 0x44, - 0x82, 0x1b, 0x65, 0xda, 0x81, 0x0d, 0x46, 0xb7, 0x67, 0x63, 0xda, 0xc1, - 0x00, 0x49, 0x18, 0x5e, 0x64, 0xda, 0x41, 0x49, 0x18, 0x5e, 0x66, 0xda, - 0x41, 0x48, 0xe1, 0x59, 0x89, 0xda, 0x01, 0x08, 0x34, 0x1e, 0x5b, 0x07, - 0x26, 0xd5, 0x27, 0x06, 0xd2, 0xe0, 0x11, 0x07, 0x17, 0xd7, 0x01, 0xff, - 0x47, 0xc0, 0x09, 0x15, 0xd9, 0x01, 0x47, 0x16, 0x08, 0x14, 0xd9, 0x41, - 0x47, 0xc0, 0x09, 0x0d, 0xd9, 0x01, 0x48, 0x67, 0x44, 0x0c, 0xd9, 0x01, - 0x46, 0xdf, 0x09, 0x0b, 0xd9, 0x41, 0x51, 0x14, 0x5a, 0x20, 0xd9, 0x01, - 0x06, 0x43, 0x1c, 0x1a, 0xb3, 0x01, 0xff, 0x49, 0x5b, 0x6c, 0x1a, 0xd9, - 0x01, 0x05, 0x5e, 0x07, 0x01, 0xff, 0x48, 0x67, 0x44, 0x19, 0xd9, 0x01, - 0x46, 0xdf, 0x09, 0x17, 0xd9, 0x41, 0x48, 0x67, 0x44, 0x18, 0xd9, 0x01, - 0x46, 0xdf, 0x09, 0x16, 0xd9, 0x41, 0x04, 0x5c, 0x0d, 0x06, 0x52, 0xb2, - 0x55, 0x71, 0xda, 0x41, 0x49, 0x3d, 0xbe, 0x6e, 0xda, 0x01, 0x45, 0x2a, - 0xeb, 0x6d, 0xda, 0x41, 0x07, 0x1b, 0x05, 0x17, 0x03, 0x7d, 0x4d, 0x01, - 0xff, 0x47, 0xc0, 0x09, 0x13, 0xd9, 0x01, 0x48, 0x67, 0x44, 0x12, 0xd9, - 0x01, 0x46, 0xdf, 0x09, 0x11, 0xd9, 0x41, 0x0a, 0x6a, 0x91, 0x9d, 0x01, - 0x8d, 0x01, 0xff, 0x0b, 0x85, 0x49, 0x4e, 0x0a, 0x29, 0x1e, 0x01, 0xff, - 0x08, 0xf1, 0x11, 0x30, 0x46, 0x3b, 0x01, 0xa3, 0xd9, 0x81, 0x18, 0x46, - 0xdf, 0x09, 0xa2, 0xd9, 0xc1, 0x00, 0x09, 0x4e, 0x26, 0x01, 0xff, 0x45, - 0x74, 0x99, 0xb1, 0xd9, 0x01, 0x4a, 0x9a, 0xaa, 0xaa, 0xd9, 0x41, 0x09, - 0x4e, 0x26, 0x01, 0xff, 0x45, 0x74, 0x99, 0xb2, 0xd9, 0x01, 0x4a, 0x9a, - 0xaa, 0xab, 0xd9, 0x41, 0xe5, 0xa4, 0xd9, 0x01, 0x0c, 0x3c, 0x90, 0x01, - 0xff, 0x45, 0x74, 0x99, 0xb3, 0xd9, 0x01, 0x4a, 0x9a, 0xaa, 0xac, 0xd9, - 0x41, 0x4b, 0x1a, 0x5a, 0xe1, 0xd9, 0x81, 0x30, 0x46, 0x3b, 0x01, 0xe0, - 0xd9, 0x81, 0x18, 0x46, 0xdf, 0x09, 0xdf, 0xd9, 0xc1, 0x00, 0x09, 0x4e, - 0x26, 0x01, 0xff, 0x47, 0xb1, 0xc4, 0xc3, 0xd9, 0x01, 0x45, 0x5a, 0x24, - 0xd2, 0xd9, 0x41, 0x09, 0x4e, 0x26, 0x01, 0xff, 0x47, 0xb1, 0xc4, 0xc4, - 0xd9, 0x01, 0x45, 0x5a, 0x24, 0xd3, 0xd9, 0x41, 0x09, 0x4e, 0x26, 0x01, - 0xff, 0x47, 0xb1, 0xc4, 0xc5, 0xd9, 0x01, 0x45, 0x5a, 0x24, 0xd4, 0xd9, - 0x41, 0x91, 0x20, 0xd2, 0xa1, 0xda, 0x01, 0xd3, 0xa2, 0xda, 0x01, 0xd4, - 0xa3, 0xda, 0x01, 0xd5, 0xa4, 0xda, 0x01, 0xd6, 0xa5, 0xda, 0x01, 0xd7, - 0xa6, 0xda, 0x01, 0xd8, 0xa7, 0xda, 0x01, 0xd9, 0xa8, 0xda, 0x41, 0xd0, - 0xa9, 0xda, 0x01, 0xd1, 0xaa, 0xda, 0x01, 0xd2, 0xab, 0xda, 0x01, 0xd3, - 0xac, 0xda, 0x01, 0xd4, 0xad, 0xda, 0x01, 0xd5, 0xae, 0xda, 0x01, 0xd6, - 0xaf, 0xda, 0x41, 0x43, 0x6f, 0x14, 0x6a, 0xda, 0x01, 0x04, 0x16, 0x17, - 0x01, 0xff, 0x47, 0x2c, 0xd0, 0x32, 0xda, 0x01, 0x47, 0x61, 0x8e, 0x31, - 0xda, 0x01, 0xb7, 0x01, 0xff, 0x46, 0xee, 0xdc, 0x34, 0xda, 0x01, 0x47, - 0x83, 0xc1, 0x33, 0xda, 0x41, 0x04, 0xa5, 0x20, 0xe1, 0x0b, 0x07, 0x5d, - 0xd7, 0x01, 0xff, 0x09, 0xfe, 0x25, 0xdd, 0x0a, 0x0b, 0x85, 0x49, 0xd5, - 0x05, 0x06, 0xa6, 0xdc, 0x99, 0x05, 0x0a, 0x29, 0x1e, 0x01, 0xff, 0x0b, - 0x39, 0x27, 0xee, 0x04, 0xa2, 0xbe, 0x04, 0xa3, 0x80, 0x03, 0x07, 0x3b, - 0x01, 0xe2, 0x02, 0x08, 0x6b, 0x1b, 0xc7, 0x02, 0x05, 0x47, 0xe7, 0xa0, - 0x02, 0x43, 0x51, 0x9a, 0x68, 0xda, 0x01, 0x05, 0x5a, 0xe8, 0xec, 0x01, - 0x06, 0x28, 0xdf, 0xd5, 0x01, 0xb3, 0xa4, 0x01, 0x07, 0x86, 0x1d, 0x86, - 0x01, 0xb7, 0x17, 0x07, 0xfc, 0x33, 0x01, 0xff, 0x45, 0x43, 0x1c, 0x47, - 0xd9, 0x01, 0x46, 0x44, 0x04, 0x46, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x45, - 0xd9, 0x41, 0x04, 0x19, 0x23, 0x11, 0x12, 0xda, 0x54, 0x01, 0xff, 0x46, - 0x3b, 0x01, 0xee, 0xd9, 0x01, 0x46, 0xdf, 0x09, 0xed, 0xd9, 0x41, 0x06, - 0x9b, 0x13, 0x27, 0x0e, 0xe2, 0x76, 0x11, 0x08, 0x4f, 0x26, 0x01, 0xff, - 0x45, 0x74, 0x99, 0xb0, 0xd9, 0x01, 0x4a, 0x9a, 0xaa, 0xa9, 0xd9, 0x41, - 0x45, 0x43, 0x1c, 0xb6, 0xd9, 0x01, 0x46, 0x44, 0x04, 0xb5, 0xd9, 0x01, - 0x45, 0x5d, 0x07, 0xb4, 0xd9, 0x41, 0x07, 0x3b, 0x01, 0x17, 0x07, 0x86, - 0x1d, 0x01, 0xff, 0x45, 0x43, 0x1c, 0x9e, 0xd9, 0x01, 0x46, 0x44, 0x04, - 0x9d, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x9c, 0xd9, 0x41, 0x45, 0x43, 0x1c, - 0x9b, 0xd9, 0x01, 0x46, 0x44, 0x04, 0x9a, 0xd9, 0x01, 0x45, 0x5d, 0x07, - 0x99, 0xd9, 0x41, 0x4b, 0x1a, 0x5a, 0x36, 0xd9, 0x81, 0x0c, 0x51, 0x10, - 0x5e, 0x34, 0xd9, 0x01, 0x4a, 0x72, 0x98, 0x35, 0xd9, 0x41, 0x4b, 0x71, - 0x98, 0x37, 0xd9, 0x41, 0x46, 0xcc, 0x6d, 0xa5, 0xd9, 0x01, 0x06, 0xe0, - 0x09, 0x01, 0xff, 0x09, 0x3b, 0x4d, 0x06, 0x4a, 0x72, 0x98, 0x2e, 0xd9, - 0x41, 0x45, 0x43, 0x1c, 0x2c, 0xd9, 0x81, 0x0c, 0x46, 0x44, 0x04, 0x2b, - 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x2a, 0xd9, 0x41, 0x42, 0x60, 0x01, 0x2d, - 0xd9, 0x41, 0x45, 0x43, 0x1c, 0x4a, 0xd9, 0x01, 0x46, 0x44, 0x04, 0x49, - 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x48, 0xd9, 0x41, 0x08, 0x4f, 0x26, 0x19, - 0x45, 0x43, 0x1c, 0x97, 0xd9, 0x01, 0x46, 0x44, 0x04, 0x96, 0xd9, 0x01, - 0x45, 0x5d, 0x07, 0x95, 0xd9, 0xc1, 0x00, 0x47, 0x3a, 0x01, 0x98, 0xd9, - 0x41, 0x45, 0x74, 0x99, 0xaf, 0xd9, 0x01, 0x4a, 0x9a, 0xaa, 0xa8, 0xd9, - 0x41, 0x08, 0x4f, 0x26, 0x12, 0x45, 0x43, 0x1c, 0x94, 0xd9, 0x01, 0x46, - 0x44, 0x04, 0x93, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x92, 0xd9, 0x41, 0x45, - 0x74, 0x99, 0xae, 0xd9, 0x01, 0x4a, 0x9a, 0xaa, 0xa7, 0xd9, 0x41, 0x07, - 0x9f, 0x43, 0x06, 0x46, 0x2d, 0xd0, 0x28, 0xd9, 0x41, 0x46, 0x3b, 0x01, - 0xf2, 0xd9, 0x01, 0x46, 0xdf, 0x09, 0xf1, 0xd9, 0x41, 0x4b, 0x1a, 0x5a, - 0x31, 0xd9, 0x81, 0x0c, 0x48, 0x3b, 0x4d, 0x2f, 0xd9, 0x01, 0x4a, 0x72, - 0x98, 0x30, 0xd9, 0x41, 0x4b, 0x71, 0x98, 0x32, 0xd9, 0x41, 0x05, 0xc5, - 0xa8, 0xa4, 0x01, 0x06, 0x1e, 0x0b, 0x87, 0x01, 0x44, 0x96, 0x10, 0x33, - 0xd9, 0x01, 0x04, 0x9c, 0x13, 0x01, 0xff, 0x80, 0x11, 0x08, 0x11, 0xc5, - 0x01, 0xff, 0x46, 0x44, 0x04, 0xa1, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0xa0, - 0xd9, 0x41, 0xa8, 0x39, 0x08, 0x04, 0x03, 0x1c, 0x02, 0x53, 0x00, 0x01, - 0xff, 0x4b, 0xc0, 0x9b, 0x9f, 0xd9, 0x01, 0x13, 0x90, 0x4c, 0x01, 0xff, - 0x46, 0x44, 0x04, 0x91, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x90, 0xd9, 0x41, - 0x45, 0x43, 0x1c, 0x8a, 0xd9, 0x81, 0x0c, 0x46, 0x44, 0x04, 0x89, 0xd9, - 0x01, 0x45, 0x5d, 0x07, 0x88, 0xd9, 0x41, 0x42, 0x60, 0x01, 0x8b, 0xd9, - 0x41, 0x0b, 0xdc, 0x2c, 0x11, 0x07, 0x50, 0x26, 0x01, 0xff, 0x45, 0x74, - 0x99, 0xad, 0xd9, 0x01, 0x4a, 0x9a, 0xaa, 0xa6, 0xd9, 0x41, 0x45, 0x43, - 0x1c, 0x8e, 0xd9, 0x81, 0x0c, 0x46, 0x44, 0x04, 0x8d, 0xd9, 0x01, 0x45, - 0x5d, 0x07, 0x8c, 0xd9, 0x41, 0x42, 0x60, 0x01, 0x8f, 0xd9, 0x41, 0x45, - 0x43, 0x1c, 0x3d, 0xd9, 0x01, 0x46, 0x44, 0x04, 0x3c, 0xd9, 0x01, 0x48, - 0x74, 0x60, 0x3e, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x3b, 0xd9, 0x41, 0x45, - 0x43, 0x1c, 0x41, 0xd9, 0x01, 0x46, 0x44, 0x04, 0x40, 0xd9, 0x01, 0x45, - 0x5d, 0x07, 0x3f, 0xd9, 0x41, 0x04, 0x40, 0x05, 0x17, 0x03, 0xd7, 0x3a, - 0x01, 0xff, 0x45, 0x43, 0x1c, 0x44, 0xd9, 0x01, 0x46, 0x44, 0x04, 0x43, - 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x42, 0xd9, 0x41, 0x45, 0x43, 0x1c, 0x3a, - 0xd9, 0x01, 0x46, 0x44, 0x04, 0x39, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x38, - 0xd9, 0x41, 0x07, 0x44, 0x04, 0x11, 0x06, 0x5d, 0x07, 0x01, 0xff, 0x46, - 0x3b, 0x01, 0xe5, 0xd9, 0x01, 0x46, 0xdf, 0x09, 0xe3, 0xd9, 0x41, 0x46, - 0x3b, 0x01, 0xe6, 0xd9, 0x01, 0x46, 0xdf, 0x09, 0xe4, 0xd9, 0x41, 0x4f, - 0x55, 0x6c, 0x24, 0xd9, 0x01, 0x55, 0x54, 0x3e, 0x27, 0xd9, 0x01, 0x03, - 0x7d, 0x15, 0x01, 0xff, 0x05, 0x9e, 0x14, 0x06, 0x4a, 0x5a, 0x6c, 0x23, - 0xd9, 0x41, 0x0c, 0x40, 0x8c, 0x0c, 0x45, 0x43, 0x1c, 0x21, 0xd9, 0x01, - 0x45, 0x5d, 0x07, 0x22, 0xd9, 0x41, 0x45, 0x43, 0x1c, 0x25, 0xd9, 0x01, - 0x45, 0x5d, 0x07, 0x26, 0xd9, 0x41, 0x18, 0x39, 0x27, 0xcd, 0x04, 0xa2, - 0xad, 0x04, 0xa3, 0xbf, 0x03, 0x07, 0x3b, 0x01, 0xa1, 0x03, 0x08, 0x6b, - 0x1b, 0x86, 0x03, 0x05, 0x47, 0xe7, 0xb0, 0x02, 0x43, 0x51, 0x9a, 0x69, - 0xda, 0x01, 0x05, 0x5a, 0xe8, 0xd0, 0x01, 0x06, 0x28, 0xdf, 0xb9, 0x01, - 0xb3, 0x88, 0x01, 0x07, 0x86, 0x1d, 0x68, 0xb7, 0x17, 0x07, 0xfc, 0x33, - 0x01, 0xff, 0x45, 0x43, 0x1c, 0x7d, 0xd9, 0x01, 0x46, 0x44, 0x04, 0x7c, - 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x7b, 0xd9, 0x41, 0x04, 0x19, 0x23, 0x11, - 0x19, 0x43, 0x26, 0x01, 0xff, 0x46, 0x3b, 0x01, 0xf0, 0xd9, 0x01, 0x46, - 0xdf, 0x09, 0xef, 0xd9, 0x41, 0x08, 0x4f, 0x26, 0x15, 0x45, 0x43, 0x1c, - 0xde, 0xd9, 0x01, 0xb3, 0x01, 0xff, 0x44, 0x5e, 0x07, 0xdd, 0xd9, 0x01, - 0x44, 0x92, 0x2e, 0xdc, 0xd9, 0x41, 0x08, 0xb1, 0xc4, 0x11, 0x06, 0x5a, - 0x24, 0x01, 0xff, 0x45, 0x43, 0x1c, 0xd1, 0xd9, 0x01, 0x45, 0x5d, 0x07, - 0xd0, 0xd9, 0x41, 0x45, 0x43, 0x1c, 0xc2, 0xd9, 0x01, 0x45, 0x5d, 0x07, - 0xc1, 0xd9, 0x41, 0x0c, 0x40, 0x8c, 0x0c, 0x51, 0x10, 0x5e, 0x6f, 0xd9, - 0x01, 0x4a, 0x72, 0x98, 0x70, 0xd9, 0x41, 0x48, 0x19, 0x5e, 0x71, 0xd9, - 0x01, 0x4a, 0x72, 0x98, 0x72, 0xd9, 0x41, 0x4f, 0xcc, 0x6d, 0xe2, 0xd9, - 0x01, 0x06, 0xe0, 0x09, 0x01, 0xff, 0x09, 0x3b, 0x4d, 0x06, 0x4a, 0x72, - 0x98, 0x69, 0xd9, 0x41, 0x45, 0x43, 0x1c, 0x67, 0xd9, 0x81, 0x0c, 0x46, - 0x44, 0x04, 0x66, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x65, 0xd9, 0x41, 0x42, - 0x60, 0x01, 0x68, 0xd9, 0x41, 0x45, 0x43, 0x1c, 0x80, 0xd9, 0x01, 0x46, - 0x44, 0x04, 0x7f, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x7e, 0xd9, 0x41, 0x08, - 0x4f, 0x26, 0x06, 0x45, 0x5d, 0x07, 0xdb, 0xd9, 0x41, 0x08, 0xb1, 0xc4, - 0x26, 0x06, 0x5a, 0x24, 0x01, 0xff, 0x06, 0x43, 0x1c, 0x11, 0x06, 0x5d, - 0x07, 0x01, 0xff, 0x46, 0x3b, 0x01, 0xce, 0xd9, 0x01, 0x46, 0xdf, 0x09, - 0xcc, 0xd9, 0x41, 0x46, 0x3b, 0x01, 0xcf, 0xd9, 0x01, 0x46, 0xdf, 0x09, - 0xcd, 0xd9, 0x41, 0x06, 0x43, 0x1c, 0x11, 0x06, 0x5d, 0x07, 0x01, 0xff, - 0x46, 0x3b, 0x01, 0xbf, 0xd9, 0x01, 0x46, 0xdf, 0x09, 0xbd, 0xd9, 0x41, - 0x46, 0x3b, 0x01, 0xc0, 0xd9, 0x01, 0x46, 0xdf, 0x09, 0xbe, 0xd9, 0x41, - 0x08, 0x4f, 0x26, 0x06, 0x45, 0x5d, 0x07, 0xda, 0xd9, 0x41, 0x08, 0xb1, - 0xc4, 0x22, 0x06, 0x5a, 0x24, 0x01, 0xff, 0x4c, 0xd8, 0x90, 0xc9, 0xd9, - 0x01, 0x4c, 0x64, 0x95, 0xc8, 0xd9, 0x01, 0x07, 0x86, 0x1d, 0x01, 0xff, - 0x4c, 0xe4, 0x90, 0xcb, 0xd9, 0x01, 0x4c, 0x70, 0x95, 0xca, 0xd9, 0x41, - 0x06, 0x43, 0x1c, 0x11, 0x06, 0x5d, 0x07, 0x01, 0xff, 0x46, 0x3b, 0x01, - 0xb9, 0xd9, 0x01, 0x46, 0x86, 0x1d, 0xbb, 0xd9, 0x41, 0x46, 0x3b, 0x01, - 0xba, 0xd9, 0x01, 0x46, 0x86, 0x1d, 0xbc, 0xd9, 0x41, 0x14, 0x9f, 0x43, - 0x06, 0x46, 0x2d, 0xd0, 0x29, 0xd9, 0x41, 0x46, 0x3b, 0x01, 0xf4, 0xd9, - 0x01, 0x46, 0xdf, 0x09, 0xf3, 0xd9, 0x41, 0x4b, 0x1a, 0x5a, 0x6c, 0xd9, - 0x81, 0x0c, 0x48, 0x3b, 0x4d, 0x6a, 0xd9, 0x01, 0x4a, 0x72, 0x98, 0x6b, - 0xd9, 0x41, 0x4b, 0x71, 0x98, 0x6d, 0xd9, 0x41, 0x44, 0x6e, 0x14, 0x77, - 0xd9, 0x01, 0x06, 0x1e, 0x0b, 0x4f, 0x44, 0x96, 0x10, 0x6e, 0xd9, 0x01, - 0x05, 0x9c, 0x13, 0x01, 0xff, 0x48, 0xe1, 0xc4, 0xd9, 0xd9, 0x01, 0x08, - 0x4f, 0x26, 0x19, 0x45, 0x43, 0x1c, 0xd7, 0xd9, 0x81, 0x0c, 0x46, 0x44, - 0x04, 0xd6, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0xd5, 0xd9, 0x41, 0x42, 0x60, - 0x01, 0xd8, 0xd9, 0x41, 0x08, 0xb1, 0xc4, 0x11, 0x06, 0x5a, 0x24, 0x01, - 0xff, 0x45, 0x43, 0x1c, 0xc7, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0xc6, 0xd9, - 0x41, 0x45, 0x43, 0x1c, 0xb8, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0xb7, 0xd9, - 0x41, 0x45, 0x43, 0x1c, 0x76, 0xd9, 0x01, 0x46, 0x44, 0x04, 0x75, 0xd9, - 0x01, 0x45, 0x5d, 0x07, 0x74, 0xd9, 0x41, 0x43, 0x40, 0x05, 0x73, 0xd9, - 0x01, 0x03, 0xd7, 0x3a, 0x01, 0xff, 0x45, 0x43, 0x1c, 0x7a, 0xd9, 0x01, - 0x46, 0x44, 0x04, 0x79, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x78, 0xd9, 0x41, - 0x06, 0x43, 0x1c, 0x21, 0x07, 0x44, 0x04, 0x11, 0x06, 0x5d, 0x07, 0x01, - 0xff, 0x46, 0x3b, 0x01, 0xea, 0xd9, 0x01, 0x46, 0xdf, 0x09, 0xe7, 0xd9, - 0x41, 0x46, 0x3b, 0x01, 0xeb, 0xd9, 0x01, 0x46, 0xdf, 0x09, 0xe8, 0xd9, - 0x41, 0x46, 0x3b, 0x01, 0xec, 0xd9, 0x01, 0x46, 0xdf, 0x09, 0xe9, 0xd9, - 0x41, 0x05, 0xb3, 0xe4, 0x5d, 0x08, 0xc0, 0x09, 0x1e, 0x08, 0xc9, 0xcb, - 0x01, 0xff, 0x45, 0x43, 0x1c, 0x5b, 0xd9, 0x81, 0x0c, 0x46, 0x44, 0x04, - 0x5a, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x59, 0xd9, 0x41, 0x42, 0x60, 0x01, - 0x5c, 0xd9, 0x41, 0x05, 0xb3, 0xe4, 0x1e, 0x08, 0xc9, 0xcb, 0x01, 0xff, - 0x45, 0x43, 0x1c, 0x63, 0xd9, 0x81, 0x0c, 0x46, 0x44, 0x04, 0x62, 0xd9, - 0x01, 0x45, 0x5d, 0x07, 0x61, 0xd9, 0x41, 0x42, 0x60, 0x01, 0x64, 0xd9, - 0x41, 0x45, 0x43, 0x1c, 0x5f, 0xd9, 0x81, 0x0c, 0x46, 0x44, 0x04, 0x5e, - 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x5d, 0xd9, 0x41, 0x42, 0x60, 0x01, 0x60, - 0xd9, 0x41, 0x45, 0x43, 0x1c, 0x57, 0xd9, 0x81, 0x0c, 0x46, 0x44, 0x04, - 0x56, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x55, 0xd9, 0x41, 0x42, 0x60, 0x01, - 0x58, 0xd9, 0x41, 0xa3, 0xac, 0x01, 0x45, 0x28, 0x83, 0x41, 0xda, 0x81, - 0x95, 0x01, 0x44, 0xc2, 0x73, 0x4d, 0xda, 0x81, 0x7f, 0x05, 0xf6, 0x04, - 0x3d, 0x45, 0x8f, 0xc1, 0x3e, 0xda, 0x81, 0x27, 0x45, 0x57, 0xeb, 0x50, - 0xda, 0x81, 0x11, 0x09, 0x82, 0xc1, 0x01, 0xff, 0x46, 0x3b, 0x01, 0x58, - 0xda, 0x01, 0x46, 0xdf, 0x09, 0x57, 0xda, 0x41, 0x80, 0x01, 0xff, 0x47, - 0xa8, 0x31, 0x51, 0xda, 0x01, 0x46, 0x4e, 0xe0, 0x52, 0xda, 0x41, 0x80, - 0x01, 0xff, 0x44, 0xf6, 0x04, 0x40, 0xda, 0x01, 0x48, 0xb1, 0xcc, 0x3f, - 0xda, 0x41, 0x46, 0x12, 0x03, 0x44, 0xda, 0x01, 0x47, 0xa8, 0x31, 0x45, - 0xda, 0x01, 0x44, 0xa0, 0x46, 0x47, 0xda, 0x81, 0x1c, 0x49, 0x8a, 0x47, - 0x4a, 0xda, 0x81, 0x06, 0x48, 0xb1, 0xcc, 0x46, 0xda, 0x41, 0x80, 0x01, - 0xff, 0x48, 0xb1, 0xcc, 0x4b, 0xda, 0x01, 0x44, 0x5d, 0xf3, 0x4c, 0xda, - 0x41, 0x80, 0x01, 0xff, 0x48, 0xb1, 0xcc, 0x48, 0xda, 0x01, 0x44, 0x5d, - 0xf3, 0x49, 0xda, 0x41, 0x80, 0x01, 0xff, 0x47, 0xa8, 0x31, 0x4e, 0xda, - 0x01, 0x48, 0xb1, 0xcc, 0x4f, 0xda, 0x41, 0x80, 0x01, 0xff, 0x44, 0xf6, - 0x04, 0x43, 0xda, 0x01, 0x48, 0xb1, 0xcc, 0x42, 0xda, 0x41, 0x06, 0x7c, - 0x1b, 0x06, 0x46, 0x44, 0x19, 0x56, 0xda, 0x41, 0x47, 0x2c, 0xd0, 0x3d, - 0xda, 0x01, 0x47, 0xa8, 0x31, 0x3c, 0xda, 0x01, 0x47, 0x61, 0x8e, 0x3b, - 0xda, 0x41, 0xa9, 0x3e, 0x07, 0x3e, 0x85, 0x01, 0xff, 0x80, 0x0f, 0x8d, - 0x01, 0xff, 0x50, 0x4d, 0x63, 0x80, 0xda, 0x01, 0x4f, 0xb6, 0x74, 0x7f, - 0xda, 0x41, 0x45, 0xa8, 0xe5, 0x83, 0xda, 0x01, 0x02, 0xb0, 0x01, 0x12, - 0x4c, 0x44, 0x91, 0x86, 0xda, 0x01, 0x45, 0x89, 0xeb, 0x85, 0xda, 0x01, - 0x45, 0x42, 0x50, 0x82, 0xda, 0x41, 0x47, 0xa4, 0xce, 0x84, 0xda, 0x01, - 0x44, 0xc9, 0x00, 0x81, 0xda, 0x41, 0x03, 0x98, 0x13, 0x17, 0xb0, 0x01, - 0xff, 0x80, 0x06, 0x52, 0x10, 0x55, 0x53, 0xda, 0x41, 0x50, 0xdd, 0x64, - 0x54, 0xda, 0x01, 0x50, 0x4d, 0x68, 0x55, 0xda, 0x41, 0x4b, 0x55, 0x9a, - 0x76, 0xda, 0x01, 0x07, 0xef, 0xd2, 0x01, 0xff, 0xd1, 0x77, 0xda, 0x01, - 0xd2, 0x78, 0xda, 0x01, 0xd3, 0x79, 0xda, 0x01, 0xd4, 0x7a, 0xda, 0x01, - 0xd5, 0x7b, 0xda, 0x01, 0xd6, 0x7c, 0xda, 0x01, 0xd7, 0x7d, 0xda, 0x41, - 0xa1, 0x44, 0x43, 0xe7, 0x01, 0xff, 0xd9, 0xc1, 0x00, 0x80, 0x01, 0xff, - 0x08, 0x19, 0x5e, 0x06, 0x43, 0x07, 0x1b, 0x00, 0xda, 0x41, 0x47, 0x11, - 0x03, 0x06, 0xda, 0x01, 0x8d, 0x01, 0xff, 0x0b, 0x85, 0x49, 0x17, 0x0a, - 0x29, 0x1e, 0x01, 0xff, 0x45, 0x9b, 0x13, 0x04, 0xda, 0x01, 0x48, 0x3b, - 0x4d, 0x01, 0xda, 0x01, 0x44, 0x59, 0x05, 0x02, 0xda, 0x41, 0x45, 0x9b, - 0x13, 0x05, 0xda, 0x01, 0x48, 0x3b, 0x4d, 0x03, 0xda, 0x41, 0x42, 0x46, - 0x00, 0x6b, 0xda, 0x01, 0x03, 0xf8, 0x18, 0x01, 0xff, 0x45, 0x04, 0x02, - 0x85, 0xd8, 0x81, 0xad, 0x0e, 0xa3, 0xe0, 0x0b, 0xa6, 0xee, 0x02, 0xa8, - 0x39, 0x44, 0xa0, 0x46, 0x77, 0xd8, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x53, - 0x72, 0x49, 0x56, 0xd8, 0x01, 0x45, 0x8f, 0x13, 0x03, 0xd8, 0x01, 0x49, - 0xa3, 0xbb, 0x95, 0xd8, 0x01, 0x48, 0xf1, 0xc8, 0x79, 0xd8, 0x01, 0x4b, - 0xc5, 0x18, 0xb2, 0xd8, 0x01, 0x06, 0x95, 0x13, 0x01, 0xff, 0x47, 0xa8, - 0x31, 0x7a, 0xd8, 0x01, 0x44, 0x94, 0x0a, 0x78, 0xd8, 0x41, 0x44, 0xd9, - 0x09, 0x7d, 0xd8, 0x81, 0x4c, 0x43, 0xad, 0x0e, 0x6b, 0xd8, 0xc1, 0x00, - 0x80, 0x01, 0xff, 0x48, 0xf9, 0xc4, 0x6a, 0xd8, 0x01, 0x12, 0x3b, 0x43, - 0x26, 0x07, 0x7d, 0x02, 0x06, 0x4a, 0x8a, 0xb0, 0xb9, 0xd8, 0x41, 0x55, - 0xc5, 0x18, 0xda, 0xd8, 0x81, 0x06, 0x45, 0x95, 0x13, 0xca, 0xd8, 0x41, - 0x80, 0x01, 0xff, 0x42, 0x9e, 0x01, 0xd9, 0xd8, 0x01, 0x43, 0x28, 0x08, - 0xd8, 0xd8, 0x41, 0x42, 0x9e, 0x01, 0xbe, 0xd8, 0x01, 0x43, 0x28, 0x08, - 0xbd, 0xd8, 0x01, 0x45, 0xef, 0x1a, 0xbf, 0xd8, 0x41, 0x80, 0x01, 0xff, - 0xa6, 0xce, 0x01, 0x45, 0x8f, 0x13, 0x04, 0xd8, 0x81, 0x7c, 0x46, 0xca, - 0x18, 0x8a, 0xd8, 0x81, 0x5f, 0x46, 0x7d, 0x02, 0xc5, 0xd8, 0x81, 0x52, - 0x48, 0xf1, 0xc8, 0x82, 0xd8, 0x01, 0x44, 0xf6, 0x04, 0x7b, 0xd8, 0x81, - 0x2b, 0x44, 0x22, 0x08, 0xa7, 0xd8, 0x81, 0x1e, 0x45, 0x5d, 0x07, 0x7e, - 0xd8, 0x01, 0x06, 0x95, 0x13, 0x01, 0xff, 0x53, 0x8e, 0x48, 0x84, 0xd8, - 0x01, 0x44, 0x94, 0x0a, 0x80, 0xd8, 0xc1, 0x00, 0x4f, 0xdf, 0x69, 0x83, - 0xd8, 0x41, 0x5d, 0x9d, 0x14, 0xac, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x48, - 0xf1, 0xc8, 0x81, 0xd8, 0x01, 0x06, 0x95, 0x13, 0x01, 0xff, 0x47, 0xa8, - 0x31, 0x7c, 0xd8, 0x01, 0x44, 0x94, 0x0a, 0x7f, 0xd8, 0x41, 0x4c, 0xc4, - 0x18, 0xd1, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x45, 0x8f, 0x13, 0xa2, 0xd8, - 0x81, 0x06, 0x45, 0x95, 0x13, 0x9b, 0xd8, 0x41, 0x46, 0x94, 0x13, 0x9d, - 0xd8, 0x41, 0x80, 0x01, 0xff, 0x46, 0x27, 0x68, 0xdb, 0xd8, 0x01, 0x07, - 0x7d, 0x02, 0x2b, 0x4b, 0xc5, 0x18, 0xc1, 0xd8, 0x01, 0x45, 0x95, 0x13, - 0xf0, 0xd8, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x45, 0x43, 0x1c, 0xef, 0xd8, - 0x01, 0x44, 0xf6, 0x04, 0xee, 0xd8, 0x01, 0xb3, 0x01, 0xff, 0x43, 0x03, - 0x00, 0xdd, 0xd8, 0x01, 0x44, 0x5e, 0x07, 0xf1, 0xd8, 0x41, 0x46, 0xca, - 0x18, 0xa6, 0xd8, 0x01, 0x44, 0x22, 0x08, 0x88, 0xd8, 0xc1, 0x00, 0x4a, - 0xd0, 0x18, 0x8d, 0xd8, 0x41, 0x57, 0x70, 0x2f, 0x55, 0xd8, 0x01, 0x55, - 0x87, 0x1b, 0x4b, 0xd8, 0x41, 0x43, 0x2d, 0x24, 0x03, 0xd9, 0x81, 0xc8, - 0x01, 0x43, 0xd9, 0x01, 0x5a, 0xd8, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x54, - 0xe3, 0x40, 0x5b, 0xd8, 0x01, 0xa6, 0x61, 0x44, 0x2c, 0x13, 0x5c, 0xd8, - 0x81, 0x3b, 0x06, 0x63, 0xd8, 0x17, 0x06, 0x95, 0x13, 0x01, 0xff, 0x44, - 0x9d, 0x1b, 0x5f, 0xd8, 0x01, 0x47, 0xa8, 0x31, 0x60, 0xd8, 0x01, 0x44, - 0x94, 0x0a, 0x5d, 0xd8, 0x41, 0x46, 0x73, 0x02, 0x62, 0xd8, 0x81, 0x0c, - 0x50, 0xfd, 0x63, 0x61, 0xd8, 0x01, 0x46, 0xca, 0x18, 0x65, 0xd8, 0x41, - 0x4b, 0x89, 0x4f, 0x63, 0xd8, 0xc1, 0x00, 0x45, 0x9c, 0x1b, 0x64, 0xd8, - 0x41, 0x80, 0x01, 0xff, 0x53, 0x72, 0x49, 0x4d, 0xd8, 0x81, 0x06, 0x4a, - 0x8a, 0x4f, 0x5e, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x44, 0x9d, 0x1b, 0x51, - 0xd8, 0x01, 0x49, 0x36, 0xb9, 0x4f, 0xd8, 0x41, 0x52, 0x70, 0x2f, 0x4c, - 0xd8, 0x81, 0x23, 0x4b, 0x87, 0x1b, 0x44, 0xd8, 0xc1, 0x00, 0x80, 0x01, - 0xff, 0x44, 0x9d, 0x1b, 0x45, 0xd8, 0x01, 0x49, 0xd1, 0x18, 0x47, 0xd8, - 0x81, 0x06, 0x46, 0x27, 0x68, 0x46, 0xd8, 0x41, 0x46, 0x62, 0xd8, 0x48, - 0xd8, 0x41, 0x80, 0x01, 0xff, 0x44, 0x9d, 0x1b, 0x50, 0xd8, 0x01, 0x49, - 0x36, 0xb9, 0x4e, 0xd8, 0x01, 0x46, 0x27, 0x68, 0x57, 0xd8, 0x81, 0x06, - 0x4d, 0xa2, 0x31, 0x52, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x48, 0xf1, 0xc8, - 0x59, 0xd8, 0x01, 0x4a, 0x8a, 0x4f, 0x58, 0xd8, 0x41, 0x80, 0x01, 0xff, - 0x5b, 0x86, 0x1b, 0x4a, 0xd8, 0x01, 0x44, 0x2c, 0x13, 0x04, 0xd9, 0x01, - 0x45, 0x8f, 0x13, 0x00, 0xd8, 0x81, 0x85, 0x03, 0x07, 0xca, 0x18, 0xb2, - 0x02, 0x07, 0x7d, 0x02, 0xbd, 0x01, 0x05, 0x22, 0x08, 0x7f, 0x45, 0x95, - 0x13, 0xf5, 0xd8, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x08, 0xc0, 0x09, 0x58, - 0x47, 0xa8, 0x31, 0xfa, 0xd8, 0x01, 0x44, 0x2c, 0x13, 0xf6, 0xd8, 0x01, - 0x05, 0x16, 0x02, 0x3c, 0x05, 0x94, 0x0a, 0x26, 0x06, 0x66, 0x25, 0x01, - 0xff, 0x4c, 0x86, 0x1b, 0x01, 0xd9, 0x01, 0x4a, 0xda, 0xab, 0x08, 0xd8, - 0x01, 0x49, 0xa3, 0xbb, 0x93, 0xd8, 0x01, 0xb4, 0x01, 0xff, 0x4c, 0xd0, - 0x8f, 0x00, 0xd9, 0x01, 0x4a, 0x0c, 0xa4, 0xfe, 0xd8, 0x41, 0x44, 0x9d, - 0x1b, 0xf9, 0xd8, 0x01, 0x49, 0xd1, 0x18, 0xf8, 0xd8, 0x01, 0x48, 0xfe, - 0x25, 0xf7, 0xd8, 0x41, 0x54, 0x87, 0x42, 0x02, 0xd9, 0x01, 0x4b, 0x0b, - 0xa4, 0xff, 0xd8, 0x41, 0x4c, 0x18, 0x90, 0xfb, 0xd8, 0x81, 0x0c, 0x4b, - 0xbe, 0x18, 0xfc, 0xd8, 0x01, 0x4b, 0xc5, 0x18, 0xfd, 0xd8, 0x41, 0x49, - 0xc7, 0x69, 0x2c, 0xd8, 0x41, 0x44, 0xa5, 0x01, 0xab, 0xd8, 0x01, 0x45, - 0x8f, 0x13, 0xb7, 0xd8, 0x01, 0x46, 0xca, 0x18, 0xb0, 0xd8, 0x01, 0x46, - 0x7d, 0x02, 0xb4, 0xd8, 0x81, 0x12, 0x4e, 0x8c, 0x42, 0xaf, 0xd8, 0x01, - 0x45, 0x95, 0x13, 0xb8, 0xd8, 0x01, 0x42, 0x50, 0x02, 0xae, 0xd8, 0x41, - 0x80, 0x01, 0xff, 0x49, 0xd1, 0x18, 0xb5, 0xd8, 0x01, 0x4f, 0x8c, 0x42, - 0xb6, 0xd8, 0x41, 0x4f, 0x47, 0x6b, 0x1c, 0xd8, 0x01, 0x44, 0xa5, 0x01, - 0xc4, 0xd8, 0x01, 0x46, 0xca, 0x18, 0xcc, 0xd8, 0x01, 0xb2, 0x50, 0x06, - 0x95, 0x13, 0x0d, 0x42, 0x50, 0x02, 0xc6, 0xd8, 0xc1, 0x00, 0x4b, 0x89, - 0x4f, 0xc9, 0xd8, 0x41, 0x07, 0xf8, 0xce, 0x24, 0xa3, 0x0c, 0x4f, 0x08, - 0x6e, 0x30, 0xd8, 0x01, 0x46, 0xca, 0x18, 0xcb, 0xd8, 0x41, 0x0d, 0x87, - 0x84, 0x06, 0x4e, 0x36, 0x7e, 0x36, 0xd8, 0x41, 0x46, 0x27, 0x68, 0x39, - 0xd8, 0x01, 0x42, 0x50, 0x02, 0x38, 0xd8, 0x41, 0x48, 0x0f, 0x6e, 0x42, - 0xd8, 0x01, 0x0a, 0x68, 0xaf, 0x01, 0xff, 0x47, 0x43, 0x1f, 0x41, 0xd8, - 0x01, 0x42, 0x50, 0x02, 0x40, 0xd8, 0x41, 0x4d, 0x8d, 0x42, 0xc8, 0xd8, - 0x01, 0x4a, 0xc6, 0x18, 0xcd, 0xd8, 0x41, 0x44, 0x9d, 0x1b, 0x98, 0xd8, - 0x01, 0x44, 0xa5, 0x01, 0x8e, 0xd8, 0x81, 0x27, 0x45, 0x8f, 0x13, 0xa0, - 0xd8, 0x81, 0x1a, 0x4e, 0x8c, 0x42, 0x97, 0xd8, 0x01, 0xb4, 0x06, 0x42, - 0x50, 0x02, 0x92, 0xd8, 0x41, 0x44, 0x96, 0x13, 0x9a, 0xd8, 0x01, 0x4c, - 0x9c, 0x93, 0x99, 0xd8, 0x41, 0x46, 0x94, 0x13, 0x9c, 0xd8, 0x41, 0x80, - 0x01, 0xff, 0x4e, 0xd2, 0x7a, 0x91, 0xd8, 0x01, 0x07, 0x7a, 0xd5, 0x01, - 0xff, 0x46, 0x6f, 0x41, 0x90, 0xd8, 0x01, 0x48, 0x3b, 0x4d, 0x8f, 0xd8, - 0x41, 0x80, 0x01, 0xff, 0x44, 0x9d, 0x1b, 0x06, 0xd8, 0x81, 0xf2, 0x03, - 0x46, 0xea, 0xda, 0x0a, 0xd8, 0x01, 0x46, 0x27, 0x68, 0x0b, 0xd8, 0x81, - 0xce, 0x03, 0x46, 0x7d, 0x02, 0x0e, 0xd8, 0x81, 0xcd, 0x01, 0xb2, 0xbe, - 0x01, 0x06, 0x95, 0x13, 0x18, 0x50, 0x1d, 0x68, 0x13, 0xd8, 0xc1, 0x00, - 0x07, 0x94, 0x13, 0x01, 0xff, 0x49, 0xd1, 0x18, 0x25, 0xd8, 0x01, 0x44, - 0x94, 0x0a, 0x24, 0xd8, 0x41, 0x07, 0xf8, 0xce, 0x91, 0x01, 0xa3, 0x5f, - 0x0e, 0x08, 0x78, 0x4f, 0x44, 0xac, 0x0e, 0xe6, 0xd8, 0x81, 0x37, 0x44, - 0x94, 0x0a, 0xdc, 0xd8, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x49, 0xf6, 0xb6, - 0xe2, 0xd8, 0x01, 0x06, 0x8f, 0x13, 0x17, 0x06, 0x95, 0x13, 0x01, 0xff, - 0x44, 0x9d, 0x1b, 0xe0, 0xd8, 0x01, 0x49, 0xd1, 0x18, 0xdf, 0xd8, 0x01, - 0x48, 0xfe, 0x25, 0xde, 0xd8, 0x41, 0x44, 0x9d, 0x1b, 0xe1, 0xd8, 0x01, - 0x45, 0x27, 0x68, 0xe3, 0xd8, 0x41, 0x0a, 0x60, 0x7b, 0x01, 0xff, 0x46, - 0x27, 0x68, 0x43, 0xd8, 0x01, 0x42, 0x50, 0x02, 0x31, 0xd8, 0x41, 0x44, - 0x9d, 0x1b, 0xe5, 0xd8, 0x01, 0x48, 0x3b, 0x4d, 0xe4, 0xd8, 0x41, 0x45, - 0x13, 0x03, 0xeb, 0xd8, 0x81, 0x23, 0xb5, 0x01, 0xff, 0x4e, 0x5e, 0x7b, - 0x37, 0xd8, 0x01, 0xb2, 0x01, 0xff, 0x45, 0xfc, 0xc4, 0xe7, 0xd8, 0x01, - 0x09, 0x9e, 0x13, 0x01, 0xff, 0x46, 0xa7, 0x13, 0xe8, 0xd8, 0x01, 0x45, - 0xef, 0x1a, 0xea, 0xd8, 0x41, 0x4b, 0x61, 0x7b, 0x3c, 0xd8, 0x41, 0x4c, - 0x0c, 0x90, 0x3b, 0xd8, 0x01, 0x4d, 0x5f, 0x87, 0x3a, 0xd8, 0x41, 0x4d, - 0x8d, 0x42, 0x09, 0xd8, 0x01, 0x4a, 0xc6, 0x18, 0xba, 0xd8, 0x41, 0x80, - 0x01, 0xff, 0x44, 0x9d, 0x1b, 0x10, 0xd8, 0x81, 0xe8, 0x01, 0xa3, 0x7d, - 0x46, 0x27, 0x68, 0x12, 0xd8, 0x81, 0x70, 0x46, 0xca, 0x18, 0xa4, 0xd8, - 0x01, 0xb2, 0x4c, 0x53, 0x3b, 0x4d, 0x20, 0xd8, 0x01, 0x45, 0x95, 0x13, - 0x1e, 0xd8, 0x81, 0x06, 0x57, 0x98, 0x31, 0x27, 0xd8, 0x41, 0x80, 0x01, - 0xff, 0x46, 0x2f, 0x0c, 0x3f, 0xd8, 0x81, 0x29, 0x44, 0x9d, 0x1b, 0x22, - 0xd8, 0x01, 0xa3, 0x0f, 0xa8, 0x01, 0xff, 0x45, 0x28, 0x68, 0x2b, 0xd8, - 0x01, 0x45, 0x09, 0x6e, 0x2a, 0xd8, 0x41, 0x46, 0x46, 0x15, 0x29, 0xd8, - 0x01, 0x4f, 0x50, 0x71, 0x3d, 0xd8, 0x01, 0x45, 0x36, 0x7e, 0x28, 0xd8, - 0x41, 0x44, 0x17, 0x11, 0x3e, 0xd8, 0x41, 0x4e, 0x8d, 0x42, 0x11, 0xd8, - 0x01, 0x43, 0xa1, 0x01, 0x86, 0xd8, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x44, - 0x9d, 0x1b, 0x8b, 0xd8, 0x01, 0x49, 0xd1, 0x18, 0x8c, 0xd8, 0x41, 0x52, - 0x82, 0x4f, 0x23, 0xd8, 0x41, 0x48, 0xd2, 0x18, 0x15, 0xd8, 0x81, 0x18, - 0x04, 0x96, 0x10, 0x01, 0xff, 0x47, 0xc9, 0x18, 0xa9, 0xd8, 0x01, 0x42, - 0x05, 0x00, 0x1a, 0xd8, 0xc1, 0x00, 0x4b, 0x89, 0x4f, 0x33, 0xd8, 0x41, - 0x80, 0x01, 0xff, 0x46, 0xea, 0xda, 0x18, 0xd8, 0x81, 0x3a, 0x46, 0x27, - 0x68, 0x19, 0xd8, 0x81, 0x2d, 0x4a, 0xda, 0xab, 0x16, 0xd8, 0x01, 0x4b, - 0xa9, 0x9f, 0x17, 0xd8, 0x01, 0x06, 0x95, 0x13, 0x01, 0xff, 0x47, 0xa8, - 0x31, 0x34, 0xd8, 0x01, 0x44, 0x94, 0x0a, 0x2d, 0xd8, 0xc1, 0x00, 0x80, - 0x01, 0xff, 0x44, 0x9d, 0x1b, 0x2f, 0xd8, 0x01, 0x49, 0xd1, 0x18, 0x2e, - 0xd8, 0x41, 0x4b, 0x89, 0x4f, 0x32, 0xd8, 0x41, 0x4e, 0xa1, 0x31, 0x35, - 0xd8, 0x41, 0x4f, 0xc1, 0x69, 0x21, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x43, - 0x13, 0x01, 0x0c, 0xd8, 0x01, 0x49, 0x63, 0x7b, 0x14, 0xd8, 0xc1, 0x00, - 0x4b, 0x89, 0x4f, 0x26, 0xd8, 0x41, 0x4c, 0x80, 0x8b, 0x1d, 0xd8, 0x41, - 0x45, 0x13, 0x03, 0x76, 0xd8, 0x81, 0xca, 0x01, 0x43, 0x96, 0xd4, 0x66, - 0xd8, 0x81, 0x8f, 0x01, 0xb5, 0x01, 0xff, 0xf0, 0x6d, 0xd8, 0x81, 0x1c, - 0x46, 0xfb, 0xc4, 0x75, 0xd8, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x54, 0x3b, - 0x43, 0xbc, 0xd8, 0x01, 0x55, 0x04, 0x3d, 0xcf, 0xd8, 0x01, 0x44, 0xf6, - 0x04, 0x74, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x53, 0x72, 0x49, 0x53, 0xd8, - 0x81, 0x5b, 0x45, 0x8f, 0x13, 0x02, 0xd8, 0x81, 0x3e, 0x52, 0xbe, 0x18, - 0xd0, 0xd8, 0x01, 0x48, 0xf1, 0xc8, 0x71, 0xd8, 0x01, 0x44, 0xf6, 0x04, - 0x6c, 0xd8, 0x81, 0x11, 0x06, 0x95, 0x13, 0x01, 0xff, 0x47, 0xa8, 0x31, - 0x73, 0xd8, 0x01, 0x44, 0x94, 0x0a, 0x6f, 0xd8, 0x41, 0x80, 0x01, 0xff, - 0x48, 0xf1, 0xc8, 0x70, 0xd8, 0x01, 0x06, 0x95, 0x13, 0x01, 0xff, 0x47, - 0xa8, 0x31, 0x72, 0xd8, 0x01, 0x44, 0x94, 0x0a, 0x6e, 0xd8, 0x41, 0x80, - 0x01, 0xff, 0x4b, 0xc5, 0x18, 0xc0, 0xd8, 0x01, 0x45, 0x95, 0x13, 0xec, - 0xd8, 0xc1, 0x00, 0x45, 0xf5, 0x04, 0xed, 0xd8, 0x41, 0x45, 0xf5, 0x04, - 0x54, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x56, 0x86, 0x1b, 0x49, 0xd8, 0x01, - 0x5e, 0x8f, 0x13, 0xe9, 0xd8, 0x01, 0x5c, 0xbe, 0x18, 0xd6, 0xd8, 0x81, - 0x17, 0x48, 0xf1, 0xc8, 0x68, 0xd8, 0x01, 0x06, 0x95, 0x13, 0x01, 0xff, - 0x47, 0xa8, 0x31, 0x69, 0xd8, 0x01, 0x44, 0x94, 0x0a, 0x67, 0xd8, 0x41, - 0x45, 0x5b, 0x3e, 0xd7, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x45, 0x8f, 0x13, - 0x01, 0xd8, 0x81, 0x2d, 0x07, 0xca, 0x18, 0x1d, 0x07, 0x7d, 0x02, 0x06, - 0x4b, 0xc5, 0x18, 0xb1, 0xd8, 0x41, 0x4b, 0xc5, 0x18, 0xce, 0xd8, 0x81, - 0x06, 0x42, 0x50, 0x02, 0xc7, 0xd8, 0x41, 0x45, 0x9c, 0x1b, 0xd5, 0xd8, - 0x41, 0x45, 0x8f, 0x13, 0xa1, 0xd8, 0x01, 0x42, 0x50, 0x02, 0x94, 0xd8, - 0x41, 0x80, 0x01, 0xff, 0x44, 0x9d, 0x1b, 0x07, 0xd8, 0x01, 0x45, 0x27, - 0x68, 0x0d, 0xd8, 0x01, 0x46, 0x7d, 0x02, 0x0f, 0xd8, 0x81, 0x06, 0x4b, - 0xc5, 0x18, 0xbb, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x05, 0x95, 0x10, 0x12, - 0x46, 0xca, 0x18, 0xa5, 0xd8, 0x01, 0x44, 0x22, 0x08, 0x87, 0xd8, 0x01, - 0x45, 0x95, 0x13, 0x1f, 0xd8, 0x41, 0x47, 0xc9, 0x18, 0xaa, 0xd8, 0x01, - 0x42, 0x05, 0x00, 0x1b, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x45, 0x8f, 0x13, - 0x05, 0xd8, 0x81, 0x45, 0x07, 0xca, 0x18, 0x27, 0x52, 0xbe, 0x18, 0xd4, - 0xd8, 0x81, 0x11, 0x05, 0x22, 0x08, 0x01, 0xff, 0x5d, 0x85, 0x15, 0xad, - 0xd8, 0x01, 0x46, 0xca, 0x18, 0xb3, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x42, - 0x9e, 0x01, 0xd3, 0xd8, 0x01, 0x43, 0x28, 0x08, 0xd2, 0xd8, 0x41, 0x45, - 0x8f, 0x13, 0xa3, 0xd8, 0x81, 0x06, 0x42, 0x50, 0x02, 0x96, 0xd8, 0x41, - 0x52, 0x94, 0x4f, 0x9f, 0xd8, 0xc1, 0x00, 0x44, 0x17, 0x11, 0x9e, 0xd8, - 0x41, 0x80, 0x01, 0xff, 0x07, 0x7d, 0x02, 0x23, 0x4b, 0xc5, 0x18, 0xc3, - 0xd8, 0x81, 0x16, 0x45, 0x95, 0x13, 0xf4, 0xd8, 0xc1, 0x00, 0x80, 0x01, - 0xff, 0x42, 0x9e, 0x01, 0xf3, 0xd8, 0x01, 0x43, 0x28, 0x08, 0xf2, 0xd8, - 0x41, 0x44, 0x17, 0x11, 0xc2, 0xd8, 0x41, 0x46, 0xca, 0x18, 0xa8, 0xd8, - 0x01, 0x44, 0x22, 0x08, 0x89, 0xd8, 0x41, 0x47, 0xc0, 0x09, 0x0a, 0xd9, - 0x01, 0x48, 0x67, 0x44, 0x09, 0xd9, 0x01, 0x46, 0xdf, 0x09, 0x08, 0xd9, - 0x41, 0x1c, 0xfe, 0x16, 0x72, 0xa9, 0x52, 0xac, 0x1c, 0x08, 0x81, 0xc9, - 0x06, 0x48, 0x82, 0x16, 0x88, 0xda, 0x41, 0x47, 0x2c, 0xd0, 0x12, 0xda, - 0x01, 0x47, 0x61, 0x8e, 0x11, 0xda, 0x01, 0x48, 0xb1, 0xcc, 0x13, 0xda, - 0x41, 0x04, 0xfe, 0x07, 0x06, 0x5a, 0x6c, 0x21, 0x70, 0xda, 0x41, 0x06, - 0x43, 0x1c, 0x1a, 0xb3, 0x01, 0xff, 0x49, 0x5b, 0x6c, 0x1f, 0xd9, 0x01, - 0x05, 0x5e, 0x07, 0x01, 0xff, 0x48, 0x67, 0x44, 0x1e, 0xd9, 0x01, 0x46, - 0xdf, 0x09, 0x1c, 0xd9, 0x41, 0x48, 0x67, 0x44, 0x1d, 0xd9, 0x01, 0x46, - 0xdf, 0x09, 0x1b, 0xd9, 0x41, 0x0c, 0x68, 0x91, 0x06, 0x44, 0xda, 0x09, - 0x7e, 0xda, 0x41, 0xd2, 0x9b, 0xda, 0x01, 0xd3, 0x9c, 0xda, 0x01, 0xd4, - 0x9d, 0xda, 0x01, 0xd5, 0x9e, 0xda, 0x01, 0xd6, 0x9f, 0xda, 0x41, 0x4f, - 0x27, 0x6d, 0x07, 0xda, 0x01, 0x4a, 0xf6, 0xb2, 0x08, 0xda, 0xc1, 0x00, - 0x48, 0x4e, 0x0d, 0x09, 0xda, 0x41, 0x43, 0x90, 0x1a, 0x30, 0xda, 0x01, - 0x49, 0x94, 0xc1, 0x6c, 0xda, 0x01, 0x02, 0x4d, 0x00, 0x01, 0xff, 0x80, - 0xb2, 0x01, 0x0f, 0x92, 0x6b, 0x9b, 0x01, 0x05, 0xb6, 0xe6, 0x4e, 0x07, - 0xd3, 0xd2, 0x38, 0x02, 0x31, 0x01, 0x01, 0xff, 0x46, 0xa2, 0x0d, 0x16, - 0xda, 0x01, 0x05, 0x22, 0x00, 0x1d, 0x44, 0xf6, 0x04, 0x14, 0xda, 0x01, - 0x48, 0x49, 0xcb, 0x15, 0xda, 0x01, 0x04, 0xf1, 0x1b, 0x01, 0xff, 0x45, - 0xf5, 0x04, 0x1a, 0xda, 0x01, 0x4d, 0x82, 0x86, 0x1c, 0xda, 0x41, 0x46, - 0xa2, 0x0d, 0x1b, 0xda, 0x01, 0x44, 0xf6, 0x04, 0x19, 0xda, 0x41, 0x44, - 0xa5, 0x01, 0x1f, 0xda, 0x01, 0x4a, 0x72, 0x47, 0x20, 0xda, 0x01, 0x42, - 0x50, 0x02, 0x1e, 0xda, 0x41, 0x0b, 0x85, 0x49, 0x29, 0x0a, 0x29, 0x1e, - 0x01, 0xff, 0xa3, 0x16, 0x48, 0x3b, 0x4d, 0x21, 0xda, 0xc1, 0x00, 0x80, - 0x01, 0xff, 0x4b, 0x1a, 0x5a, 0x23, 0xda, 0x01, 0x46, 0x3b, 0x01, 0x22, - 0xda, 0x41, 0x47, 0x2c, 0x0b, 0x29, 0xda, 0x01, 0x45, 0xc1, 0x22, 0x27, - 0xda, 0x41, 0x46, 0x6f, 0x41, 0x28, 0xda, 0x01, 0x48, 0x3b, 0x4d, 0x24, - 0xda, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x4b, 0x1a, 0x5a, 0x26, 0xda, 0x01, - 0x46, 0x3b, 0x01, 0x25, 0xda, 0x41, 0x44, 0xa5, 0x01, 0x0c, 0xda, 0x01, - 0x47, 0x61, 0x8e, 0x0b, 0xda, 0x01, 0x42, 0x50, 0x02, 0x0a, 0xda, 0x41, - 0x06, 0x54, 0xda, 0x06, 0x44, 0x3f, 0xa5, 0x1d, 0xda, 0x41, 0x48, 0x67, - 0x44, 0x18, 0xda, 0x01, 0x46, 0xdf, 0x09, 0x17, 0xda, 0x41, 0x0f, 0x40, - 0x72, 0x48, 0x07, 0x0c, 0xd8, 0x01, 0xff, 0x0a, 0xf1, 0x3d, 0x33, 0x50, - 0x1d, 0x63, 0xfd, 0xd9, 0x01, 0x44, 0xd5, 0xef, 0xf7, 0xd9, 0x01, 0x47, - 0x7c, 0xd1, 0xfe, 0xd9, 0x01, 0x47, 0x70, 0x43, 0xfa, 0xd9, 0x01, 0xb3, - 0x06, 0x45, 0x57, 0xeb, 0xf9, 0xd9, 0x41, 0x4b, 0x8e, 0x9d, 0xfb, 0xd9, - 0x81, 0x06, 0x43, 0x13, 0x01, 0xf8, 0xd9, 0x41, 0x4c, 0x19, 0x5a, 0xfc, - 0xd9, 0x41, 0x45, 0x43, 0x1c, 0xf6, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0xf5, - 0xd9, 0x41, 0x4c, 0x5c, 0x8e, 0x0e, 0xda, 0x01, 0x08, 0xac, 0x92, 0x06, - 0x4a, 0xec, 0xb2, 0x0f, 0xda, 0x41, 0x44, 0xa5, 0x01, 0x0d, 0xda, 0x01, - 0x42, 0x50, 0x02, 0x10, 0xda, 0x41, 0x06, 0x53, 0xa0, 0x0f, 0xaf, 0x01, - 0xff, 0x43, 0xd7, 0x02, 0x8a, 0xda, 0x01, 0x43, 0x15, 0x05, 0x87, 0xda, - 0x41, 0x47, 0x61, 0x8e, 0x2b, 0xda, 0x01, 0x46, 0x6a, 0xdf, 0x2a, 0xda, - 0x01, 0x46, 0x4e, 0xe0, 0x2c, 0xda, 0x41, 0x05, 0xda, 0xe5, 0x17, 0x04, - 0xc2, 0xea, 0x01, 0xff, 0x47, 0xc0, 0x09, 0x10, 0xd9, 0x01, 0x48, 0x67, - 0x44, 0x0f, 0xd9, 0x01, 0x46, 0xdf, 0x09, 0x0e, 0xd9, 0x41, 0x46, 0xb6, - 0xdb, 0x3a, 0xda, 0x01, 0x46, 0x18, 0xdd, 0x39, 0xda, 0x41, 0x04, 0xdc, - 0x8c, 0x11, 0x04, 0x4e, 0xe0, 0x01, 0xff, 0x50, 0x6d, 0x60, 0x38, 0xda, - 0x01, 0x46, 0x05, 0x06, 0x36, 0xda, 0x41, 0x50, 0x6d, 0x60, 0x37, 0xda, - 0x01, 0x47, 0x82, 0x67, 0x35, 0xda, 0x41, 0x05, 0xb2, 0xe5, 0xb4, 0x01, - 0xa5, 0x01, 0xff, 0x0c, 0x0c, 0x96, 0x3e, 0x05, 0xfb, 0x45, 0x01, 0xff, - 0x06, 0x0c, 0x03, 0x1d, 0x06, 0xad, 0x02, 0x01, 0xff, 0x53, 0x26, 0x49, - 0x9f, 0xf5, 0x01, 0x53, 0xee, 0x4a, 0x98, 0xf5, 0x01, 0x54, 0x90, 0x22, - 0x99, 0xf5, 0x01, 0x51, 0xcb, 0x5e, 0x9e, 0xf5, 0x41, 0x53, 0x26, 0x49, - 0xa1, 0xf5, 0x01, 0x53, 0xee, 0x4a, 0x9a, 0xf5, 0x01, 0x54, 0x90, 0x22, - 0x9b, 0xf5, 0x01, 0x51, 0xcb, 0x5e, 0xa0, 0xf5, 0x41, 0x90, 0x49, 0x91, - 0x1f, 0x92, 0x01, 0xff, 0xd0, 0x53, 0x09, 0x01, 0xd1, 0x54, 0x09, 0x01, - 0xd2, 0x55, 0x09, 0x01, 0xd3, 0x56, 0x09, 0x01, 0xd4, 0x57, 0x09, 0x01, - 0xd5, 0x58, 0x09, 0x01, 0xd6, 0x59, 0x09, 0x41, 0xd0, 0x49, 0x09, 0x01, - 0xd1, 0x4a, 0x09, 0x01, 0xd2, 0x4b, 0x09, 0x01, 0xd3, 0x4c, 0x09, 0x01, - 0xd4, 0x4d, 0x09, 0x01, 0xd5, 0x4e, 0x09, 0x01, 0xd6, 0x4f, 0x09, 0x01, - 0xd7, 0x50, 0x09, 0x01, 0xd8, 0x51, 0x09, 0x01, 0xd9, 0x52, 0x09, 0x41, - 0xd1, 0x40, 0x09, 0x01, 0xd2, 0x41, 0x09, 0x01, 0xd3, 0x42, 0x09, 0x01, - 0xd4, 0x43, 0x09, 0x01, 0xd5, 0x44, 0x09, 0x01, 0xd6, 0x45, 0x09, 0x01, - 0xd7, 0x46, 0x09, 0x01, 0xd8, 0x47, 0x09, 0x01, 0xd9, 0x48, 0x09, 0x41, - 0xa4, 0xb8, 0x04, 0x50, 0xbd, 0x62, 0xc9, 0x15, 0x01, 0x07, 0xec, 0x05, - 0x86, 0x02, 0x10, 0x6d, 0x66, 0xf5, 0x01, 0xb3, 0x43, 0x0b, 0x55, 0x77, - 0x01, 0xff, 0xa1, 0x25, 0xe5, 0xb8, 0x15, 0x01, 0xe9, 0xb0, 0x15, 0x81, - 0x18, 0xef, 0xba, 0x15, 0x01, 0xf5, 0xb2, 0x15, 0x81, 0x0b, 0x49, 0x43, - 0xc1, 0xb4, 0x15, 0xc1, 0x00, 0xf2, 0xb5, 0x15, 0x41, 0xf5, 0xb3, 0x15, - 0x41, 0xe9, 0xb1, 0x15, 0x41, 0xe1, 0xaf, 0x15, 0x01, 0xe9, 0xb9, 0x15, - 0x01, 0x4a, 0xa6, 0xad, 0xdc, 0x15, 0x81, 0x04, 0xf5, 0xbb, 0x15, 0x41, - 0xf5, 0xdd, 0x15, 0x41, 0xa5, 0x2e, 0x04, 0x5b, 0x03, 0x01, 0xff, 0x48, - 0x3c, 0x16, 0xbd, 0x15, 0x01, 0x4b, 0xd9, 0x23, 0xbc, 0x15, 0x01, 0x45, - 0x5a, 0x3f, 0xc0, 0x15, 0x01, 0x47, 0xf8, 0xd5, 0xc1, 0x15, 0x01, 0x02, - 0x02, 0x00, 0x01, 0xff, 0x44, 0xe7, 0x23, 0xbf, 0x15, 0x01, 0x45, 0xf3, - 0x4b, 0xbe, 0x15, 0x41, 0x0b, 0xb8, 0x9a, 0x11, 0x08, 0xdc, 0x20, 0x01, - 0xff, 0x43, 0x16, 0x00, 0xc5, 0x15, 0x01, 0x43, 0x23, 0x0a, 0xc4, 0x15, - 0x41, 0x4b, 0x5d, 0x9b, 0xcf, 0x15, 0x81, 0x5e, 0x05, 0x51, 0x00, 0x01, - 0xff, 0x0c, 0x78, 0x8d, 0x43, 0x50, 0x0d, 0x62, 0xd1, 0x15, 0x01, 0x53, - 0x44, 0x4c, 0xd3, 0x15, 0x01, 0x10, 0x4d, 0x66, 0x21, 0x52, 0x22, 0x55, - 0xd4, 0x15, 0x01, 0x03, 0x19, 0x01, 0x01, 0xff, 0x09, 0xc5, 0xb7, 0x06, - 0x4d, 0x4a, 0x4c, 0xd2, 0x15, 0x41, 0x50, 0xfd, 0x61, 0xcb, 0x15, 0x01, - 0x52, 0x0c, 0x56, 0xca, 0x15, 0x41, 0x49, 0x4e, 0x4c, 0xcc, 0x15, 0x01, - 0x50, 0x0d, 0x62, 0xcd, 0x15, 0x01, 0x50, 0xcd, 0x67, 0xce, 0x15, 0x41, - 0x4f, 0x54, 0x6d, 0xd7, 0x15, 0x01, 0x44, 0x4d, 0x66, 0xd5, 0x15, 0x01, - 0x4e, 0xb8, 0x7d, 0xd6, 0x15, 0x41, 0x4a, 0x92, 0x96, 0xd0, 0x15, 0x41, - 0xd1, 0xc6, 0x15, 0x01, 0xd2, 0xc7, 0x15, 0x01, 0xd3, 0xc8, 0x15, 0x41, - 0xe1, 0x80, 0x15, 0x81, 0x8f, 0x02, 0xa2, 0x82, 0x02, 0xa3, 0xf5, 0x01, - 0xa4, 0xdc, 0x01, 0xe5, 0x8a, 0x15, 0x01, 0xa7, 0xcb, 0x01, 0x42, 0x22, - 0x00, 0xae, 0x15, 0x01, 0xe9, 0x82, 0x15, 0x81, 0xbb, 0x01, 0xaa, 0xae, - 0x01, 0xab, 0xa1, 0x01, 0x42, 0x74, 0x00, 0xa9, 0x15, 0x01, 0x42, 0x6c, - 0x00, 0xa6, 0x15, 0x01, 0xae, 0x7d, 0xef, 0x8c, 0x15, 0x01, 0xb0, 0x6d, - 0x42, 0x71, 0x00, 0xa8, 0x15, 0x01, 0xb3, 0x55, 0xb4, 0x2c, 0xf5, 0x84, - 0x15, 0x81, 0x23, 0xb6, 0x06, 0x42, 0xbe, 0x22, 0xa7, 0x15, 0x41, 0xe1, - 0xaa, 0x15, 0x01, 0x07, 0x44, 0xc1, 0x01, 0xff, 0xec, 0x88, 0x15, 0x81, - 0x09, 0xf2, 0x86, 0x15, 0xc1, 0x00, 0xf2, 0x87, 0x15, 0x41, 0xec, 0x89, - 0x15, 0x41, 0xf5, 0x85, 0x15, 0x41, 0xe1, 0x9d, 0x15, 0x01, 0xa8, 0x17, - 0xb4, 0x0b, 0x55, 0x3b, 0x3f, 0xd9, 0x15, 0xc1, 0x00, 0xe9, 0xda, 0x15, - 0x41, 0xe1, 0x98, 0x15, 0x01, 0x42, 0x22, 0x00, 0x99, 0x15, 0x41, 0xe1, - 0x9e, 0x15, 0x01, 0x56, 0xde, 0x36, 0xd8, 0x15, 0x41, 0xe1, 0xad, 0x15, - 0x01, 0x42, 0x22, 0x00, 0xab, 0x15, 0x01, 0x42, 0x40, 0x06, 0xac, 0x15, - 0x41, 0xe1, 0xa2, 0x15, 0x01, 0x42, 0x22, 0x00, 0xa3, 0x15, 0x41, 0xe1, - 0xa1, 0x15, 0x01, 0x42, 0x24, 0x02, 0x92, 0x15, 0x01, 0x42, 0x2a, 0x05, - 0x9c, 0x15, 0x01, 0x42, 0xbe, 0x22, 0x97, 0x15, 0x41, 0xe1, 0x8e, 0x15, - 0x01, 0x42, 0x22, 0x00, 0x8f, 0x15, 0x41, 0xe1, 0x95, 0x15, 0x01, 0x42, - 0x22, 0x00, 0x96, 0x15, 0x41, 0xe9, 0x83, 0x15, 0x41, 0xe1, 0x90, 0x15, - 0x01, 0x42, 0x22, 0x00, 0x91, 0x15, 0x41, 0xe1, 0x9f, 0x15, 0x01, 0xa4, - 0x06, 0x42, 0x22, 0x00, 0xa0, 0x15, 0x41, 0xe1, 0x9a, 0x15, 0x01, 0x42, - 0x22, 0x00, 0x9b, 0x15, 0x41, 0xe1, 0x93, 0x15, 0x01, 0x42, 0x22, 0x00, - 0x94, 0x15, 0x41, 0xe1, 0xa4, 0x15, 0x01, 0x42, 0x22, 0x00, 0xa5, 0x15, - 0x41, 0xe1, 0x81, 0x15, 0x01, 0xe9, 0x8b, 0x15, 0x01, 0x4a, 0xa6, 0xad, - 0xdb, 0x15, 0x01, 0xf5, 0x8d, 0x15, 0x41, 0x44, 0x75, 0x20, 0xc2, 0x15, - 0x01, 0x4b, 0x2a, 0xa1, 0xc3, 0x15, 0x41, 0xa1, 0xf5, 0x01, 0x43, 0x11, - 0x35, 0x11, 0xf4, 0x01, 0xa9, 0xcc, 0x01, 0xaf, 0x18, 0xb2, 0x0a, 0x4d, - 0x9b, 0x89, 0xe2, 0x29, 0x00, 0xf9, 0xad, 0x00, 0x40, 0x43, 0x0d, 0x1c, - 0x90, 0xf9, 0x01, 0x42, 0xd2, 0x0e, 0x37, 0xf9, 0x41, 0x5d, 0x11, 0x15, - 0x2f, 0xf9, 0x01, 0x4a, 0x4a, 0xaf, 0x20, 0xf3, 0x01, 0x06, 0x45, 0x30, - 0x95, 0x01, 0x02, 0x34, 0x00, 0x12, 0x50, 0xfd, 0x67, 0x7d, 0x23, 0x00, - 0x43, 0xd7, 0x00, 0x8f, 0xfa, 0x01, 0x43, 0x15, 0x01, 0xbf, 0xf6, 0x41, - 0x80, 0x26, 0x44, 0x7a, 0x2c, 0x70, 0xf3, 0x01, 0x0c, 0xa0, 0x8f, 0x04, - 0xf3, 0x73, 0xfa, 0x41, 0x52, 0xc6, 0x50, 0xa1, 0xbc, 0x01, 0x49, 0xf2, - 0xb7, 0xa2, 0xbc, 0x01, 0x4e, 0x82, 0x79, 0xa0, 0xbc, 0x01, 0x47, 0x02, - 0xd7, 0xa3, 0xbc, 0x41, 0xa2, 0x49, 0x49, 0x0b, 0x39, 0xdf, 0x2a, 0x80, - 0x3c, 0x04, 0xc3, 0x00, 0x2c, 0x0b, 0xb3, 0x02, 0x1c, 0x53, 0x28, 0x4d, - 0x4e, 0x2b, 0x00, 0x47, 0x09, 0xd7, 0xe0, 0x2a, 0xc0, 0x00, 0x80, 0x01, - 0xff, 0x55, 0xff, 0x38, 0xe9, 0x2a, 0x00, 0x4d, 0x35, 0x5f, 0xe8, 0x2a, - 0x40, 0x5b, 0x5d, 0x1a, 0x44, 0x29, 0x00, 0x64, 0x2b, 0x09, 0xd3, 0xf8, - 0x41, 0x45, 0x0f, 0x39, 0xde, 0x2a, 0x00, 0x6b, 0xc3, 0x02, 0xd5, 0xf8, - 0x41, 0x4d, 0xf5, 0x7f, 0xe7, 0x2a, 0x40, 0x56, 0xea, 0x32, 0x4f, 0x2b, - 0x00, 0x6c, 0x92, 0x01, 0x5f, 0x2b, 0x40, 0x44, 0x0b, 0x6b, 0xcd, 0xf6, - 0x01, 0x47, 0xa0, 0xd6, 0xd2, 0xf6, 0x41, 0x43, 0x04, 0x24, 0xe1, 0xf6, - 0x01, 0x03, 0xc5, 0x00, 0x0a, 0x4a, 0xa0, 0xae, 0xe9, 0x26, 0x00, 0xf0, - 0xa2, 0xf6, 0x41, 0x42, 0x9e, 0x01, 0x0f, 0x00, 0x00, 0x43, 0x28, 0x08, - 0x0e, 0x00, 0x40, 0x0c, 0xa7, 0x02, 0xdc, 0x07, 0x49, 0x95, 0xb0, 0xe8, - 0xfa, 0x01, 0x50, 0xcd, 0x64, 0x58, 0xf9, 0x01, 0x45, 0xeb, 0xe8, 0x18, - 0x26, 0x00, 0xb2, 0xbb, 0x02, 0xb6, 0x01, 0xff, 0x46, 0x44, 0xdb, 0x67, - 0xf3, 0x01, 0x0b, 0x61, 0x8d, 0x01, 0xff, 0xa1, 0xfc, 0x01, 0x43, 0x1f, - 0xf4, 0x5a, 0x04, 0x01, 0x46, 0xc0, 0xda, 0x57, 0x04, 0x01, 0x44, 0xa5, - 0xef, 0x5b, 0x04, 0x01, 0xa5, 0xd1, 0x01, 0x43, 0xd5, 0x20, 0x53, 0x04, - 0x01, 0x43, 0xb8, 0xaa, 0x5c, 0x04, 0x01, 0xa8, 0xb6, 0x01, 0xa9, 0xa3, - 0x01, 0x45, 0xce, 0xe7, 0x61, 0x04, 0x01, 0x44, 0xf9, 0xf0, 0x52, 0x04, - 0x01, 0x44, 0x31, 0xf1, 0x64, 0x04, 0x01, 0xad, 0x82, 0x01, 0x43, 0xde, - 0x22, 0x6f, 0x04, 0x01, 0xaf, 0x5a, 0x44, 0x29, 0xf2, 0x50, 0x04, 0x01, - 0x44, 0x7d, 0xf2, 0x6e, 0x04, 0x01, 0xb3, 0x42, 0xb4, 0x2c, 0x42, 0x50, - 0x02, 0x73, 0x04, 0x01, 0x43, 0x57, 0x39, 0x5d, 0x04, 0x01, 0x02, 0x15, - 0x02, 0x12, 0x02, 0x4d, 0x00, 0x06, 0x43, 0x03, 0xf5, 0x5f, 0x04, 0x41, - 0xe1, 0x58, 0x04, 0x01, 0xf7, 0x7f, 0x04, 0x41, 0xe5, 0x62, 0x04, 0x01, - 0x42, 0x61, 0x03, 0x6b, 0x04, 0x41, 0xa8, 0x06, 0x42, 0x1b, 0x05, 0x51, - 0x04, 0x41, 0x42, 0xe2, 0x1c, 0x5e, 0x04, 0x01, 0x43, 0x3f, 0x00, 0x54, - 0x04, 0x41, 0xef, 0x55, 0x04, 0x01, 0x43, 0x91, 0x18, 0x56, 0x04, 0x41, - 0x42, 0x6d, 0x00, 0x74, 0x04, 0x01, 0x42, 0x62, 0x01, 0x76, 0x04, 0x01, - 0xee, 0x6a, 0x04, 0x01, 0x43, 0x69, 0x0a, 0x75, 0x04, 0x01, 0xf2, 0x79, - 0x04, 0x01, 0x42, 0x29, 0x08, 0x6c, 0x04, 0x41, 0x46, 0x8e, 0x18, 0x60, - 0x04, 0x01, 0x43, 0x29, 0x02, 0x65, 0x04, 0x41, 0x42, 0x1a, 0x00, 0x7e, - 0x04, 0x01, 0x42, 0x73, 0x02, 0x72, 0x04, 0x01, 0xe6, 0x66, 0x04, 0x41, - 0x44, 0xf9, 0xee, 0x63, 0x04, 0x01, 0x43, 0xb1, 0x45, 0x59, 0x04, 0x41, - 0xa1, 0x0c, 0x42, 0x64, 0x12, 0x67, 0x04, 0x01, 0x42, 0xcf, 0x00, 0x7b, - 0x04, 0x41, 0xf2, 0x7d, 0x04, 0x01, 0xf4, 0x70, 0x04, 0x41, 0x42, 0x3b, - 0x01, 0x69, 0x04, 0x01, 0x42, 0xdb, 0x09, 0x71, 0x04, 0x01, 0xe8, 0x6d, - 0x04, 0x01, 0x42, 0x46, 0x00, 0x7a, 0x04, 0x01, 0xb2, 0x0c, 0x42, 0xa4, - 0x02, 0x68, 0x04, 0x01, 0x42, 0x15, 0x01, 0x77, 0x04, 0x41, 0xe5, 0x78, - 0x04, 0x01, 0x43, 0x4d, 0x66, 0x7c, 0x04, 0x41, 0x04, 0xdb, 0x4d, 0x04, - 0xeb, 0x88, 0xf9, 0x41, 0x51, 0xe3, 0x57, 0xc7, 0x11, 0x01, 0x51, 0x6a, - 0x59, 0xdd, 0x11, 0x01, 0xa4, 0xa3, 0x04, 0xa5, 0x94, 0x04, 0x4a, 0xc3, - 0x60, 0xdc, 0x11, 0x01, 0x07, 0xec, 0x05, 0xf1, 0x01, 0x42, 0x14, 0x05, - 0xc4, 0x11, 0x01, 0xb3, 0x81, 0x01, 0x06, 0x57, 0x39, 0x01, 0xff, 0x4d, - 0x41, 0x86, 0xcb, 0x11, 0x01, 0x05, 0x5a, 0x03, 0x01, 0xff, 0xa1, 0x63, - 0x07, 0x3d, 0x61, 0x57, 0xe5, 0xbc, 0x11, 0x01, 0xe9, 0xb4, 0x11, 0x81, - 0x4a, 0xef, 0xbe, 0x11, 0x81, 0x3b, 0x4f, 0xf5, 0x71, 0xce, 0x11, 0x01, - 0x06, 0x33, 0x07, 0x29, 0xf5, 0xb6, 0x11, 0x81, 0x17, 0x08, 0x43, 0xc1, - 0x01, 0xff, 0xec, 0xba, 0x11, 0x81, 0x09, 0xf2, 0xb8, 0x11, 0xc1, 0x00, - 0xf2, 0xb9, 0x11, 0x41, 0xec, 0xbb, 0x11, 0x41, 0xe5, 0x62, 0x1b, 0x01, - 0xf5, 0xb7, 0x11, 0xc1, 0x00, 0xe5, 0x63, 0x1b, 0x41, 0xe5, 0x64, 0x1b, - 0x01, 0xef, 0x65, 0x1b, 0x41, 0xe5, 0x60, 0x1b, 0x01, 0x42, 0x67, 0x51, - 0x61, 0x1b, 0x41, 0xe9, 0xb5, 0x11, 0x41, 0xe5, 0x66, 0x1b, 0x01, 0xef, - 0x67, 0x1b, 0x41, 0xe1, 0xb3, 0x11, 0x01, 0xe9, 0xbd, 0x11, 0x01, 0xf5, - 0xbf, 0x11, 0x41, 0x4a, 0xde, 0xa7, 0xc9, 0x11, 0x01, 0xa5, 0x4d, 0x04, - 0x5b, 0x03, 0x06, 0x49, 0xd7, 0xc0, 0xcd, 0x11, 0x41, 0xa1, 0x35, 0x4b, - 0xd9, 0x23, 0x80, 0x11, 0x01, 0x54, 0x8b, 0x43, 0xcf, 0x11, 0x01, 0x4b, - 0x07, 0x9e, 0xc2, 0x11, 0x01, 0x45, 0x5a, 0x3f, 0xca, 0x11, 0x01, 0x47, - 0xf8, 0xd5, 0xdb, 0x11, 0x01, 0x4b, 0x8f, 0xa4, 0xc3, 0x11, 0x01, 0x02, - 0x02, 0x00, 0x01, 0xff, 0x44, 0xe7, 0x23, 0xc0, 0x11, 0x01, 0x45, 0xf3, - 0x4b, 0x82, 0x11, 0x41, 0x47, 0x3d, 0x16, 0x81, 0x11, 0x01, 0x47, 0xc4, - 0x88, 0xc1, 0x11, 0x41, 0x0b, 0xc3, 0x9a, 0x06, 0x47, 0xdc, 0x20, 0xc8, - 0x11, 0x41, 0xd1, 0xde, 0x11, 0x01, 0xd2, 0xdf, 0x11, 0x41, 0xe1, 0x83, - 0x11, 0x81, 0x86, 0x02, 0xa2, 0xf9, 0x01, 0xa3, 0xec, 0x01, 0xa4, 0xd3, - 0x01, 0xe5, 0x8d, 0x11, 0x01, 0xa7, 0xc2, 0x01, 0x42, 0x22, 0x00, 0xb2, - 0x11, 0x01, 0xe9, 0x85, 0x11, 0x81, 0xb2, 0x01, 0xaa, 0xa5, 0x01, 0xab, - 0x98, 0x01, 0xac, 0x8b, 0x01, 0x42, 0x6c, 0x00, 0xa9, 0x11, 0x01, 0xae, - 0x6d, 0xef, 0x8f, 0x11, 0x01, 0xb0, 0x5d, 0x42, 0x71, 0x00, 0xab, 0x11, - 0x01, 0xb3, 0x45, 0xb4, 0x2c, 0xf5, 0x87, 0x11, 0x81, 0x23, 0xb6, 0x06, - 0x42, 0xbe, 0x22, 0xaa, 0x11, 0x41, 0xe1, 0xae, 0x11, 0x01, 0x07, 0x44, - 0xc1, 0x01, 0xff, 0xec, 0x8b, 0x11, 0x81, 0x09, 0xf2, 0x89, 0x11, 0xc1, - 0x00, 0xf2, 0x8a, 0x11, 0x41, 0xec, 0x8c, 0x11, 0x41, 0xf5, 0x88, 0x11, - 0x41, 0xe1, 0xa0, 0x11, 0x01, 0x42, 0x22, 0x00, 0xa1, 0x11, 0x01, 0xb4, - 0x01, 0xff, 0xe1, 0x9b, 0x11, 0x01, 0x42, 0x22, 0x00, 0x9c, 0x11, 0x41, - 0xe1, 0xb1, 0x11, 0x01, 0x42, 0x22, 0x00, 0xaf, 0x11, 0x01, 0x42, 0x40, - 0x06, 0xb0, 0x11, 0x41, 0xe1, 0xa5, 0x11, 0x01, 0x42, 0x22, 0x00, 0xa6, - 0x11, 0x41, 0xe1, 0xa4, 0x11, 0x01, 0x42, 0x24, 0x02, 0x95, 0x11, 0x01, - 0x42, 0x2a, 0x05, 0x9f, 0x11, 0x01, 0x42, 0xbe, 0x22, 0x9a, 0x11, 0x41, - 0xe1, 0xac, 0x11, 0x01, 0x42, 0x74, 0x00, 0xad, 0x11, 0x41, 0xe1, 0x91, - 0x11, 0x01, 0x42, 0x22, 0x00, 0x92, 0x11, 0x41, 0xe1, 0x98, 0x11, 0x01, - 0x42, 0x22, 0x00, 0x99, 0x11, 0x41, 0xe9, 0x86, 0x11, 0x41, 0xe1, 0x93, - 0x11, 0x01, 0x42, 0x22, 0x00, 0x94, 0x11, 0x41, 0xe1, 0xa2, 0x11, 0x01, - 0xa4, 0x06, 0x42, 0x22, 0x00, 0xa3, 0x11, 0x41, 0xe1, 0x9d, 0x11, 0x01, - 0x42, 0x22, 0x00, 0x9e, 0x11, 0x41, 0xe1, 0x96, 0x11, 0x01, 0x42, 0x22, - 0x00, 0x97, 0x11, 0x41, 0xe1, 0xa7, 0x11, 0x01, 0x42, 0x22, 0x00, 0xa8, - 0x11, 0x41, 0xe1, 0x84, 0x11, 0x01, 0xe9, 0x8e, 0x11, 0x01, 0xf5, 0x90, - 0x11, 0x41, 0x43, 0x1c, 0xbb, 0xda, 0x11, 0x01, 0x55, 0x65, 0x3f, 0xcc, - 0x11, 0x41, 0x44, 0x75, 0x20, 0xc5, 0x11, 0x01, 0x05, 0xf0, 0x06, 0x06, - 0x4b, 0x2a, 0xa1, 0xc6, 0x11, 0x41, 0x45, 0x12, 0x0b, 0xd8, 0x11, 0x01, - 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0xd9, 0x11, 0x01, 0x43, 0x0e, 0x0b, 0xd1, - 0x11, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xd0, 0x11, 0x41, - 0x44, 0x25, 0x01, 0xd3, 0x11, 0x01, 0x42, 0x15, 0x02, 0xd2, 0x11, 0x41, - 0x44, 0xe5, 0x1d, 0xd7, 0x11, 0x01, 0x42, 0x1c, 0x26, 0xd6, 0x11, 0x41, - 0x43, 0xd2, 0x05, 0xd5, 0x11, 0x01, 0x43, 0xf6, 0x06, 0xd4, 0x11, 0x41, - 0x46, 0x12, 0x03, 0x4d, 0x27, 0x00, 0x4b, 0x6a, 0x9e, 0x1e, 0x27, 0x00, - 0x44, 0x31, 0x13, 0x30, 0x27, 0x40, 0xa1, 0xc8, 0x04, 0xa3, 0xb0, 0x04, - 0x43, 0x57, 0x9f, 0xf2, 0x2b, 0x00, 0xa5, 0x9b, 0x04, 0x45, 0x23, 0x30, - 0x13, 0x23, 0x80, 0xcc, 0x03, 0x44, 0x21, 0xf1, 0x33, 0xf9, 0x01, 0x02, - 0x7d, 0x02, 0xaf, 0x03, 0x08, 0xf1, 0xc9, 0x38, 0xb2, 0x2a, 0xb3, 0x1c, - 0x02, 0xc6, 0x00, 0x0c, 0x4b, 0x34, 0xa5, 0xa1, 0xfa, 0x01, 0x45, 0xde, - 0xd5, 0xb9, 0x26, 0x40, 0x45, 0x93, 0x1f, 0x16, 0x22, 0x00, 0x4e, 0x64, - 0x7d, 0x93, 0x00, 0x40, 0x47, 0xc3, 0xb8, 0x45, 0xfe, 0x00, 0x4b, 0xb9, - 0xa1, 0xbc, 0x26, 0x40, 0x65, 0x07, 0x08, 0x2c, 0xf9, 0x01, 0x49, 0x1f, - 0xc1, 0x20, 0x21, 0x40, 0x06, 0x74, 0x6b, 0x06, 0x46, 0x16, 0x08, 0xfb, - 0x2b, 0x40, 0x09, 0x6a, 0xbe, 0xa1, 0x02, 0x08, 0xe9, 0xca, 0x01, 0xff, - 0xd1, 0x51, 0xce, 0x81, 0x8b, 0x01, 0xd2, 0x52, 0xce, 0x81, 0x43, 0xd3, - 0x54, 0xce, 0x81, 0x1f, 0xd4, 0x58, 0xce, 0x81, 0x0d, 0xd5, 0x60, 0xce, - 0x81, 0x04, 0xd6, 0x70, 0xce, 0x41, 0xd6, 0x80, 0xce, 0x41, 0xd5, 0x68, - 0xce, 0x81, 0x04, 0xd6, 0x78, 0xce, 0x41, 0xd6, 0x88, 0xce, 0x41, 0xd4, - 0x5c, 0xce, 0x81, 0x0d, 0xd5, 0x64, 0xce, 0x81, 0x04, 0xd6, 0x74, 0xce, - 0x41, 0xd6, 0x84, 0xce, 0x41, 0xd5, 0x6c, 0xce, 0x81, 0x04, 0xd6, 0x7c, - 0xce, 0x41, 0xd6, 0x8c, 0xce, 0x41, 0xd3, 0x56, 0xce, 0x81, 0x1f, 0xd4, - 0x5a, 0xce, 0x81, 0x0d, 0xd5, 0x62, 0xce, 0x81, 0x04, 0xd6, 0x72, 0xce, - 0x41, 0xd6, 0x82, 0xce, 0x41, 0xd5, 0x6a, 0xce, 0x81, 0x04, 0xd6, 0x7a, - 0xce, 0x41, 0xd6, 0x8a, 0xce, 0x41, 0xd4, 0x5e, 0xce, 0x81, 0x0d, 0xd5, - 0x66, 0xce, 0x81, 0x04, 0xd6, 0x76, 0xce, 0x41, 0xd6, 0x86, 0xce, 0x41, - 0xd5, 0x6e, 0xce, 0x81, 0x04, 0xd6, 0x7e, 0xce, 0x41, 0xd6, 0x8e, 0xce, - 0x41, 0xd2, 0x53, 0xce, 0x81, 0x43, 0xd3, 0x55, 0xce, 0x81, 0x1f, 0xd4, - 0x59, 0xce, 0x81, 0x0d, 0xd5, 0x61, 0xce, 0x81, 0x04, 0xd6, 0x71, 0xce, - 0x41, 0xd6, 0x81, 0xce, 0x41, 0xd5, 0x69, 0xce, 0x81, 0x04, 0xd6, 0x79, - 0xce, 0x41, 0xd6, 0x89, 0xce, 0x41, 0xd4, 0x5d, 0xce, 0x81, 0x0d, 0xd5, - 0x65, 0xce, 0x81, 0x04, 0xd6, 0x75, 0xce, 0x41, 0xd6, 0x85, 0xce, 0x41, - 0xd5, 0x6d, 0xce, 0x81, 0x04, 0xd6, 0x7d, 0xce, 0x41, 0xd6, 0x8d, 0xce, - 0x41, 0xd3, 0x57, 0xce, 0x81, 0x1f, 0xd4, 0x5b, 0xce, 0x81, 0x0d, 0xd5, - 0x63, 0xce, 0x81, 0x04, 0xd6, 0x73, 0xce, 0x41, 0xd6, 0x83, 0xce, 0x41, - 0xd5, 0x6b, 0xce, 0x81, 0x04, 0xd6, 0x7b, 0xce, 0x41, 0xd6, 0x8b, 0xce, - 0x41, 0xd4, 0x5f, 0xce, 0x81, 0x0d, 0xd5, 0x67, 0xce, 0x81, 0x04, 0xd6, - 0x77, 0xce, 0x41, 0xd6, 0x87, 0xce, 0x41, 0xd5, 0x6f, 0xce, 0x81, 0x04, - 0xd6, 0x7f, 0xce, 0x41, 0xd6, 0x8f, 0xce, 0x41, 0xd1, 0x21, 0xcc, 0x81, - 0x1f, 0xd2, 0x22, 0xcc, 0x81, 0x0d, 0xd3, 0x24, 0xcc, 0x81, 0x04, 0xd4, - 0x28, 0xcc, 0x41, 0xd4, 0x2c, 0xcc, 0x41, 0xd3, 0x26, 0xcc, 0x81, 0x04, - 0xd4, 0x2a, 0xcc, 0x41, 0xd4, 0x2e, 0xcc, 0x41, 0xd2, 0x23, 0xcc, 0x81, - 0x0d, 0xd3, 0x25, 0xcc, 0x81, 0x04, 0xd4, 0x29, 0xcc, 0x41, 0xd4, 0x2d, - 0xcc, 0x41, 0xd3, 0x27, 0xcc, 0x81, 0x04, 0xd4, 0x2b, 0xcc, 0x41, 0xd4, - 0x2f, 0xcc, 0x41, 0x45, 0xaf, 0x3b, 0x3b, 0x00, 0x00, 0x61, 0x87, 0x0d, - 0x32, 0x2a, 0x00, 0x47, 0xdc, 0xd5, 0xba, 0x26, 0x40, 0x09, 0x31, 0xb8, - 0x01, 0xff, 0x45, 0x12, 0x0b, 0xf8, 0xfb, 0x01, 0xa6, 0x2e, 0x44, 0xea, - 0x2a, 0xf9, 0xfb, 0x01, 0x43, 0x0e, 0x0b, 0xf1, 0xfb, 0x01, 0xb3, 0x14, - 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xf0, 0xfb, 0x41, 0x44, 0x25, 0x01, 0xf3, - 0xfb, 0x01, 0x42, 0x15, 0x02, 0xf2, 0xfb, 0x41, 0x44, 0xe5, 0x1d, 0xf7, - 0xfb, 0x01, 0x42, 0x1c, 0x26, 0xf6, 0xfb, 0x41, 0x43, 0xd2, 0x05, 0xf5, - 0xfb, 0x01, 0x43, 0xf6, 0x06, 0xf4, 0xfb, 0x41, 0x4f, 0x39, 0x6a, 0x48, - 0xf6, 0x01, 0x45, 0xbc, 0xe5, 0x31, 0xf3, 0x41, 0x4f, 0x41, 0x71, 0x48, - 0xf9, 0x01, 0xb4, 0x01, 0xff, 0x48, 0xc1, 0x04, 0xa7, 0x00, 0x00, 0x42, - 0x0c, 0x00, 0x14, 0x23, 0x40, 0xec, 0xad, 0xf9, 0x01, 0xf4, 0xba, 0xf4, - 0x41, 0xa1, 0x8f, 0x01, 0x44, 0x54, 0xe5, 0xeb, 0xf3, 0x81, 0x81, 0x01, - 0xe9, 0x9a, 0x00, 0x00, 0xaf, 0x64, 0xb2, 0x01, 0xff, 0xa5, 0x53, 0x04, - 0x77, 0x06, 0x0c, 0x43, 0xe8, 0x20, 0xdc, 0xf4, 0x01, 0x44, 0x49, 0x4c, - 0x08, 0x21, 0x40, 0x08, 0xe4, 0x05, 0x1b, 0x54, 0x9e, 0x1f, 0x70, 0xf6, - 0x01, 0x06, 0x5d, 0x07, 0x01, 0xff, 0xe5, 0x2f, 0x21, 0x00, 0xe7, 0x0a, - 0x21, 0x00, 0xec, 0x13, 0x21, 0x00, 0xef, 0x34, 0x21, 0x40, 0xe2, 0x2c, - 0x21, 0x00, 0xe5, 0x30, 0x21, 0x00, 0xe6, 0x31, 0x21, 0x00, 0xe8, 0x0b, - 0x21, 0x00, 0xe9, 0x10, 0x21, 0x00, 0xec, 0x12, 0x21, 0x00, 0xed, 0x33, - 0x21, 0x00, 0xf0, 0x18, 0x21, 0x00, 0xf2, 0x1b, 0x21, 0x40, 0x42, 0x92, - 0x01, 0xb5, 0xf5, 0x01, 0x47, 0x95, 0xd7, 0x9b, 0xfa, 0x41, 0x44, 0xd8, - 0xd5, 0xf4, 0xf6, 0x01, 0x03, 0x76, 0x48, 0x01, 0xff, 0x42, 0x10, 0x00, - 0x82, 0xf9, 0x01, 0x42, 0xef, 0x02, 0x4f, 0x26, 0x40, 0x48, 0xa1, 0xc2, - 0x92, 0xf3, 0x41, 0x43, 0xec, 0x00, 0x96, 0x26, 0x00, 0x42, 0x11, 0x1c, - 0xe3, 0xf9, 0x41, 0x05, 0xbd, 0x75, 0x88, 0x08, 0x49, 0x51, 0xb9, 0x50, - 0x26, 0x00, 0x46, 0xf4, 0xdc, 0xf5, 0x26, 0x00, 0x51, 0x68, 0x5b, 0x76, - 0xf3, 0x01, 0xac, 0xdf, 0x07, 0x08, 0xc1, 0x6a, 0xd6, 0x04, 0xae, 0xa8, - 0x04, 0x42, 0x0d, 0x00, 0x7b, 0xf9, 0x01, 0xb4, 0x8c, 0x04, 0xb5, 0x06, - 0x47, 0xcd, 0xd7, 0xb7, 0xf3, 0x41, 0x4d, 0xf0, 0x81, 0xc1, 0x20, 0x00, - 0xb2, 0x01, 0xff, 0x07, 0x30, 0xcf, 0x06, 0x44, 0x01, 0xf2, 0x95, 0xf9, - 0x41, 0x54, 0x33, 0x41, 0xb4, 0xa8, 0x00, 0xa4, 0x96, 0x03, 0x07, 0xec, - 0x05, 0x6f, 0x05, 0x5a, 0x03, 0x4e, 0x0b, 0x55, 0x77, 0x01, 0xff, 0xa1, - 0x3b, 0xe5, 0xbe, 0xa8, 0x80, 0x32, 0xe9, 0xb6, 0xa8, 0x80, 0x29, 0xef, - 0xc1, 0xa8, 0x80, 0x20, 0xf5, 0xb8, 0xa8, 0x80, 0x17, 0x08, 0x43, 0xc1, - 0x01, 0xff, 0xec, 0xbc, 0xa8, 0x80, 0x09, 0xf2, 0xba, 0xa8, 0xc0, 0x00, - 0xf2, 0xbb, 0xa8, 0x40, 0xec, 0xbd, 0xa8, 0x40, 0xf5, 0xb9, 0xa8, 0x40, - 0xef, 0xc2, 0xa8, 0x40, 0xe9, 0xb7, 0xa8, 0x40, 0xe5, 0xbf, 0xa8, 0x40, - 0xe1, 0xb5, 0xa8, 0x00, 0xe9, 0xc0, 0xa8, 0x00, 0xf5, 0xc3, 0xa8, 0x40, - 0x48, 0x3c, 0x16, 0x80, 0xa8, 0x00, 0x4b, 0xd9, 0x23, 0xc5, 0xa8, 0x00, - 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0xe7, 0x23, 0xc4, 0xa8, 0x00, 0x45, - 0xf3, 0x4b, 0x81, 0xa8, 0x40, 0xe1, 0x82, 0xa8, 0x80, 0x91, 0x02, 0xa2, - 0x84, 0x02, 0xa3, 0xf7, 0x01, 0xa4, 0xde, 0x01, 0xe5, 0x8c, 0xa8, 0x80, - 0xd4, 0x01, 0xa7, 0xc7, 0x01, 0x42, 0x22, 0x00, 0xb2, 0xa8, 0x00, 0xe9, - 0x84, 0xa8, 0x80, 0xb7, 0x01, 0xaa, 0xaa, 0x01, 0xab, 0x9d, 0x01, 0xac, - 0x90, 0x01, 0x42, 0x6c, 0x00, 0xaa, 0xa8, 0x00, 0xae, 0x72, 0xef, 0x8f, - 0xa8, 0x80, 0x69, 0xb0, 0x5d, 0x42, 0x71, 0x00, 0xac, 0xa8, 0x00, 0xb3, - 0x45, 0xb4, 0x2c, 0xf5, 0x86, 0xa8, 0x80, 0x23, 0xb6, 0x06, 0x42, 0xbe, - 0x22, 0xab, 0xa8, 0x40, 0xe1, 0xae, 0xa8, 0x00, 0x07, 0x44, 0xc1, 0x01, - 0xff, 0xec, 0x8a, 0xa8, 0x80, 0x09, 0xf2, 0x88, 0xa8, 0xc0, 0x00, 0xf2, - 0x89, 0xa8, 0x40, 0xec, 0x8b, 0xa8, 0x40, 0xf5, 0x87, 0xa8, 0x40, 0xe1, - 0xa1, 0xa8, 0x00, 0x42, 0x22, 0x00, 0xa2, 0xa8, 0x00, 0xb4, 0x01, 0xff, - 0xe1, 0x9c, 0xa8, 0x00, 0x42, 0x22, 0x00, 0x9d, 0xa8, 0x40, 0xe1, 0xb1, - 0xa8, 0x00, 0x42, 0x22, 0x00, 0xaf, 0xa8, 0x00, 0x42, 0x40, 0x06, 0xb0, - 0xa8, 0x40, 0xe1, 0xa6, 0xa8, 0x00, 0x42, 0x22, 0x00, 0xa7, 0xa8, 0x40, - 0xef, 0x90, 0xa8, 0x40, 0xe1, 0xa5, 0xa8, 0x00, 0x42, 0x24, 0x02, 0x96, - 0xa8, 0x00, 0x42, 0x2a, 0x05, 0xa0, 0xa8, 0x00, 0x42, 0xbe, 0x22, 0x9b, - 0xa8, 0x40, 0xe1, 0xad, 0xa8, 0x00, 0x42, 0x74, 0x00, 0xb3, 0xa8, 0x40, - 0xe1, 0x92, 0xa8, 0x00, 0x42, 0x22, 0x00, 0x93, 0xa8, 0x40, 0xe1, 0x99, - 0xa8, 0x00, 0x42, 0x22, 0x00, 0x9a, 0xa8, 0x40, 0xe9, 0x85, 0xa8, 0x40, - 0xe1, 0x94, 0xa8, 0x00, 0x42, 0x22, 0x00, 0x95, 0xa8, 0x40, 0xe5, 0x8d, - 0xa8, 0x40, 0xe1, 0xa3, 0xa8, 0x00, 0xa4, 0x06, 0x42, 0x22, 0x00, 0xa4, - 0xa8, 0x40, 0xe1, 0x9e, 0xa8, 0x00, 0x42, 0x22, 0x00, 0x9f, 0xa8, 0x40, - 0xe1, 0x97, 0xa8, 0x00, 0x42, 0x22, 0x00, 0x98, 0xa8, 0x40, 0xe1, 0xa8, - 0xa8, 0x00, 0x42, 0x22, 0x00, 0xa9, 0xa8, 0x40, 0xe1, 0x83, 0xa8, 0x00, - 0xe9, 0x8e, 0xa8, 0x00, 0xf5, 0x91, 0xa8, 0x40, 0x44, 0x75, 0x20, 0xce, - 0xa8, 0x00, 0x05, 0xf0, 0x06, 0x06, 0x4b, 0x2a, 0xa1, 0xcf, 0xa8, 0x40, - 0x45, 0x12, 0x0b, 0xd8, 0xa8, 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0xd9, - 0xa8, 0x00, 0x43, 0x0e, 0x0b, 0xd1, 0xa8, 0x00, 0xb3, 0x14, 0xb4, 0x06, - 0x44, 0x5f, 0x1e, 0xd0, 0xa8, 0x40, 0x44, 0x25, 0x01, 0xd3, 0xa8, 0x00, - 0x42, 0x15, 0x02, 0xd2, 0xa8, 0x40, 0x44, 0xe5, 0x1d, 0xd7, 0xa8, 0x00, - 0x42, 0x1c, 0x26, 0xd6, 0xa8, 0x40, 0x43, 0xd2, 0x05, 0xd5, 0xa8, 0x00, - 0x43, 0xf6, 0x06, 0xd4, 0xa8, 0x40, 0x46, 0x56, 0xdb, 0xf0, 0xf6, 0x81, - 0x06, 0x43, 0x5d, 0x01, 0x44, 0x26, 0x40, 0x48, 0x09, 0xc2, 0xe1, 0xf4, - 0x41, 0x45, 0xcb, 0xe5, 0x6a, 0xf9, 0x01, 0x08, 0x17, 0x16, 0x01, 0xff, - 0x06, 0x6d, 0x15, 0x06, 0x54, 0x1f, 0x16, 0x7a, 0xf6, 0x41, 0x07, 0x3b, - 0x01, 0x06, 0x68, 0x08, 0x05, 0x78, 0xf6, 0x41, 0x5d, 0x13, 0x05, 0x77, - 0xf6, 0x01, 0x64, 0x27, 0x0a, 0x76, 0xf6, 0x41, 0x51, 0x12, 0x50, 0x36, - 0x08, 0x00, 0x07, 0xec, 0x05, 0xf3, 0x01, 0xad, 0xb2, 0x01, 0x0c, 0x6d, - 0x16, 0x51, 0x0b, 0x55, 0x77, 0x01, 0xff, 0xe1, 0x23, 0x08, 0x80, 0x43, - 0xe5, 0x1d, 0x08, 0x00, 0xe9, 0x2a, 0x08, 0x00, 0x05, 0xd7, 0x02, 0x22, - 0xef, 0x2b, 0x08, 0x80, 0x12, 0xb3, 0x04, 0xf5, 0x27, 0x08, 0x40, 0x46, - 0xf2, 0xd5, 0x25, 0x08, 0x00, 0x44, 0x44, 0xeb, 0x2c, 0x08, 0x40, 0x49, - 0x0d, 0xc1, 0x21, 0x08, 0xc0, 0x00, 0xe1, 0x1e, 0x08, 0x40, 0xe1, 0x22, - 0x08, 0x80, 0x0c, 0xe5, 0x1c, 0x08, 0x00, 0xe9, 0x29, 0x08, 0x00, 0xf5, - 0x26, 0x08, 0x40, 0xe1, 0x1f, 0x08, 0x40, 0xe1, 0x20, 0x08, 0x40, 0xa1, - 0x3b, 0x43, 0x9a, 0xb2, 0x33, 0x08, 0x00, 0x4d, 0xe6, 0x85, 0x37, 0x08, - 0x00, 0x47, 0x97, 0xd3, 0x30, 0x08, 0x00, 0x45, 0xee, 0x85, 0x39, 0x08, - 0x00, 0xb3, 0x15, 0x44, 0xe9, 0xf2, 0x3b, 0x08, 0x00, 0xba, 0x01, 0xff, - 0x43, 0x0a, 0xf4, 0x3a, 0x08, 0x00, 0x44, 0xc5, 0xf0, 0x38, 0x08, 0x40, - 0x49, 0xcf, 0xb9, 0x35, 0x08, 0x00, 0x4b, 0xa6, 0xa0, 0x3d, 0x08, 0x40, - 0x45, 0x9d, 0xe6, 0x31, 0x08, 0x00, 0xae, 0x0c, 0x46, 0xbe, 0xdf, 0x3c, - 0x08, 0x00, 0x45, 0x75, 0xeb, 0x34, 0x08, 0x40, 0x43, 0x55, 0x12, 0x32, - 0x08, 0x00, 0x44, 0x75, 0xf1, 0x3e, 0x08, 0x40, 0x04, 0xba, 0x00, 0x15, - 0x0f, 0x79, 0x0c, 0x01, 0xff, 0x4e, 0x7c, 0x77, 0x1a, 0x08, 0x00, 0xe9, - 0x28, 0x08, 0x00, 0x47, 0xf1, 0xd5, 0x24, 0x08, 0x40, 0x46, 0xec, 0x6b, - 0x19, 0x08, 0x00, 0x4e, 0x7c, 0x77, 0x1b, 0x08, 0x00, 0x42, 0x9e, 0x01, - 0x16, 0x08, 0x80, 0x0c, 0x47, 0x97, 0xd3, 0x2d, 0x08, 0x00, 0x49, 0xf0, - 0xbc, 0x18, 0x08, 0x40, 0x45, 0x0b, 0xe2, 0x17, 0x08, 0x40, 0x44, 0x0c, - 0xe2, 0x00, 0x08, 0x00, 0xa2, 0x72, 0x45, 0x3f, 0x54, 0x03, 0x08, 0x00, - 0x42, 0xf3, 0x02, 0x10, 0x08, 0x00, 0x45, 0xb1, 0xe6, 0x02, 0x08, 0x00, - 0xa9, 0x52, 0x44, 0xdd, 0xf0, 0x0a, 0x08, 0x00, 0x45, 0x23, 0xe8, 0x0b, - 0x08, 0x00, 0x43, 0xc2, 0x90, 0x0c, 0x08, 0x00, 0x43, 0xde, 0x22, 0x0d, - 0x08, 0x00, 0x43, 0xbe, 0xf4, 0x12, 0x08, 0x00, 0x44, 0x46, 0x54, 0x13, - 0x08, 0x00, 0xb3, 0x20, 0xb4, 0x0c, 0x43, 0x87, 0x77, 0x09, 0x08, 0x00, - 0x43, 0x4b, 0x0a, 0x06, 0x08, 0x40, 0x43, 0x3b, 0xc3, 0x15, 0x08, 0x00, - 0x42, 0x52, 0x00, 0x08, 0x08, 0x00, 0x46, 0xee, 0xdf, 0x11, 0x08, 0x40, - 0x43, 0x90, 0x00, 0x14, 0x08, 0x00, 0x46, 0x12, 0xdd, 0x0e, 0x08, 0x40, - 0xee, 0x0f, 0x08, 0x00, 0xf4, 0x07, 0x08, 0x00, 0xf9, 0x04, 0x08, 0x40, - 0x42, 0x80, 0x12, 0x05, 0x08, 0x00, 0x42, 0x52, 0x00, 0x01, 0x08, 0x40, - 0xb4, 0x06, 0x4a, 0xe6, 0x93, 0xe1, 0xfa, 0x41, 0x47, 0xa1, 0xcd, 0xc2, - 0xf9, 0x01, 0x43, 0x88, 0x0d, 0x13, 0x26, 0x40, 0x43, 0x28, 0x13, 0xf7, - 0xf9, 0x01, 0x44, 0x73, 0x5e, 0xba, 0xf9, 0x41, 0xa1, 0x9b, 0x21, 0xa5, - 0xfe, 0x1a, 0x49, 0xc6, 0xb9, 0x8f, 0xf9, 0x01, 0xe9, 0x8d, 0x00, 0x80, - 0xeb, 0x0a, 0xac, 0xd8, 0x0a, 0xaf, 0x85, 0x07, 0xf3, 0x1e, 0x00, 0x00, - 0xb5, 0x01, 0xff, 0x48, 0x49, 0xc4, 0xbd, 0x20, 0x00, 0x4c, 0x4c, 0x8f, - 0xc9, 0xf3, 0x01, 0x4a, 0xb6, 0xac, 0xf4, 0x29, 0x00, 0x03, 0xd6, 0xd1, - 0xf3, 0x04, 0xae, 0x2f, 0x48, 0x7c, 0x80, 0xa8, 0x20, 0x00, 0x1a, 0x22, - 0x22, 0x01, 0xff, 0x48, 0x41, 0xc4, 0xf6, 0x2b, 0x00, 0x46, 0x43, 0xc4, - 0xf4, 0x2b, 0x00, 0x48, 0x31, 0xca, 0xf5, 0x2b, 0x00, 0x48, 0xe1, 0xca, - 0xf7, 0x2b, 0x00, 0x49, 0x1a, 0xc0, 0xf8, 0x2b, 0x00, 0x49, 0x28, 0xc1, - 0xf3, 0x2b, 0x40, 0x03, 0x52, 0x03, 0x0f, 0xae, 0x01, 0xff, 0x42, 0x33, - 0x00, 0xc3, 0xf3, 0x01, 0x53, 0x69, 0x4a, 0xbd, 0xf3, 0x41, 0x4d, 0xd2, - 0x80, 0xee, 0x16, 0x00, 0x4f, 0x29, 0x6b, 0xf0, 0x16, 0x00, 0x51, 0x8c, - 0x59, 0xed, 0x16, 0x00, 0x07, 0xec, 0x05, 0x12, 0x54, 0x67, 0x44, 0xec, - 0x16, 0x00, 0x52, 0x6a, 0x55, 0xeb, 0x16, 0x00, 0x4f, 0x02, 0x74, 0xef, - 0x16, 0x40, 0xa1, 0xec, 0x03, 0x58, 0x69, 0x27, 0xd2, 0x16, 0x00, 0xe3, - 0xcd, 0x16, 0x80, 0xc8, 0x03, 0xe4, 0xd1, 0x16, 0x80, 0xab, 0x03, 0xe5, - 0xc2, 0x16, 0x80, 0x8d, 0x03, 0xa6, 0xe1, 0x02, 0xe7, 0xb5, 0x16, 0x80, - 0xc8, 0x02, 0x02, 0x22, 0x00, 0xb7, 0x02, 0xa9, 0x8f, 0x02, 0x47, 0x5c, - 0xd2, 0xc3, 0x16, 0x00, 0xeb, 0xf1, 0x16, 0x80, 0xf4, 0x01, 0xac, 0xc8, - 0x01, 0x4c, 0xe0, 0x91, 0xd7, 0x16, 0x00, 0x51, 0x78, 0x5c, 0xbe, 0x16, - 0x00, 0xef, 0xae, 0x16, 0x80, 0x98, 0x01, 0x4f, 0xd7, 0x71, 0xc8, 0x16, - 0x00, 0xf1, 0xe9, 0x16, 0x00, 0x50, 0x3d, 0x66, 0xb1, 0x16, 0x00, 0xb3, - 0x34, 0xb4, 0x26, 0x49, 0xce, 0xc0, 0xa2, 0x16, 0x00, 0xf6, 0xa1, 0x16, - 0x00, 0xf7, 0xa5, 0x16, 0x80, 0x11, 0xf8, 0xea, 0x16, 0x00, 0xf9, 0xa4, - 0x16, 0x80, 0x04, 0xfa, 0xce, 0x16, 0x40, 0xf2, 0xa3, 0x16, 0x40, 0x4b, - 0x84, 0xa4, 0xb9, 0x16, 0x40, 0x53, 0x0a, 0x4a, 0xa6, 0x16, 0x00, 0x4e, - 0x2e, 0x79, 0xcf, 0x16, 0x40, 0xe8, 0xf2, 0x16, 0x80, 0x12, 0x56, 0x8c, - 0x34, 0xcb, 0x16, 0x00, 0x47, 0x77, 0xd4, 0xca, 0x16, 0x00, 0x43, 0xf9, - 0x0a, 0xe5, 0x16, 0x40, 0x09, 0x92, 0xbd, 0x01, 0xff, 0x44, 0x17, 0x00, - 0xc6, 0x16, 0x00, 0x49, 0x78, 0x27, 0xd3, 0x16, 0x00, 0x48, 0xa9, 0xc6, - 0xbd, 0x16, 0x00, 0x46, 0x0e, 0xde, 0xd9, 0x16, 0x00, 0x46, 0x83, 0x5c, - 0xbf, 0x16, 0x00, 0x45, 0xeb, 0x7b, 0xad, 0x16, 0x00, 0x45, 0x9d, 0x34, - 0xcc, 0x16, 0x00, 0x45, 0x37, 0x79, 0xd0, 0x16, 0x00, 0x42, 0x07, 0x22, - 0xe7, 0x16, 0x40, 0xe5, 0xaf, 0x16, 0x00, 0xee, 0xb0, 0x16, 0x00, 0xef, - 0xf3, 0x16, 0x00, 0x45, 0xf9, 0xe9, 0xd5, 0x16, 0x00, 0x43, 0xf2, 0x01, - 0xa9, 0x16, 0x00, 0x4e, 0xe6, 0x7c, 0xdf, 0x16, 0x40, 0x51, 0x7c, 0x58, - 0xda, 0x16, 0x00, 0x0b, 0x92, 0x34, 0x01, 0xff, 0x45, 0x7c, 0xe4, 0xc5, - 0x16, 0x00, 0x48, 0xa9, 0xc6, 0xbc, 0x16, 0x00, 0x46, 0x0e, 0xde, 0xd8, - 0x16, 0x00, 0x45, 0xeb, 0x7b, 0xac, 0x16, 0x00, 0x42, 0x07, 0x22, 0xe6, - 0x16, 0x40, 0x03, 0xb0, 0x45, 0x01, 0xff, 0x42, 0x44, 0x00, 0xb4, 0x16, - 0x00, 0xe1, 0xb2, 0x16, 0x40, 0x4b, 0x29, 0x9a, 0xe8, 0x16, 0x00, 0x42, - 0x1d, 0x01, 0xdd, 0x16, 0x80, 0x12, 0x42, 0x0c, 0x00, 0xe1, 0x16, 0x00, - 0x4c, 0x28, 0x95, 0xc1, 0x16, 0x00, 0x47, 0x8e, 0xd7, 0xc7, 0x16, 0x40, - 0x43, 0x2f, 0x79, 0xdc, 0x16, 0x40, 0x45, 0xf3, 0xe5, 0xbb, 0x16, 0x00, - 0x46, 0x2e, 0xdc, 0xba, 0x16, 0x40, 0x42, 0x17, 0x00, 0xb8, 0x16, 0x00, - 0xa5, 0x01, 0xff, 0x49, 0xed, 0xb6, 0xb7, 0x16, 0x00, 0xf2, 0xc4, 0x16, - 0x40, 0x4d, 0x99, 0x82, 0xa0, 0x16, 0x00, 0x0d, 0xd4, 0x87, 0x01, 0xff, - 0xa1, 0x12, 0x42, 0x4e, 0x00, 0xf6, 0x16, 0x00, 0x42, 0x5f, 0x03, 0xf5, - 0x16, 0x00, 0x42, 0xa4, 0x0d, 0xf4, 0x16, 0x40, 0xe3, 0xf7, 0x16, 0x00, - 0x43, 0x7c, 0x1f, 0xf8, 0x16, 0x40, 0x42, 0x17, 0x00, 0xe0, 0x16, 0x00, - 0x49, 0xf3, 0xb9, 0xd6, 0x16, 0x00, 0x42, 0x1d, 0x01, 0xb6, 0x16, 0x00, - 0x42, 0x53, 0x00, 0xa7, 0x16, 0x40, 0x4b, 0x0b, 0x99, 0xde, 0x16, 0x00, - 0x06, 0x24, 0x80, 0x01, 0xff, 0xec, 0xdb, 0x16, 0x00, 0xee, 0xc0, 0x16, - 0x00, 0xf0, 0xd4, 0x16, 0x40, 0x43, 0xc5, 0x6b, 0xe3, 0x16, 0x00, 0xa5, - 0x06, 0x46, 0x56, 0xe1, 0xe2, 0x16, 0x40, 0x43, 0xc5, 0x6b, 0xe4, 0x16, - 0x00, 0xee, 0xb3, 0x16, 0x40, 0x43, 0xdd, 0x1b, 0xaa, 0x16, 0x00, 0x43, - 0x7c, 0x1f, 0xab, 0x16, 0x00, 0x4a, 0x10, 0xad, 0xc9, 0x16, 0x00, 0x46, - 0xa4, 0xde, 0xa8, 0x16, 0x40, 0x06, 0xef, 0x06, 0xb2, 0x01, 0x09, 0x25, - 0x5a, 0x91, 0x01, 0x07, 0x1a, 0x3a, 0x01, 0xff, 0x05, 0x12, 0x0b, 0x7e, - 0xa6, 0x5f, 0x04, 0xea, 0x2a, 0x4f, 0x4b, 0x6d, 0x11, 0x72, 0x0e, 0x01, - 0xb3, 0x26, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x69, 0x0e, 0x01, 0xa8, - 0x0f, 0xb7, 0x01, 0xff, 0x44, 0xe7, 0x1d, 0x6a, 0x0e, 0x01, 0x49, 0xda, - 0x1d, 0x73, 0x0e, 0x41, 0x44, 0x7b, 0x11, 0x6b, 0x0e, 0x01, 0x4b, 0x17, - 0x18, 0x74, 0x0e, 0x41, 0x04, 0xe5, 0x1d, 0x11, 0x02, 0x1c, 0x26, 0x01, - 0xff, 0x48, 0x70, 0x11, 0x77, 0x0e, 0x01, 0x42, 0x7d, 0x11, 0x6e, 0x0e, - 0x41, 0x48, 0x70, 0x11, 0x78, 0x0e, 0x01, 0x42, 0x7d, 0x11, 0x6f, 0x0e, - 0x41, 0x48, 0x70, 0x11, 0x7a, 0x0e, 0x01, 0x42, 0x7d, 0x11, 0x71, 0x0e, - 0x41, 0xa9, 0x0f, 0xaf, 0x01, 0xff, 0x43, 0x7c, 0x11, 0x6c, 0x0e, 0x01, - 0x4a, 0x14, 0xb3, 0x75, 0x0e, 0x41, 0x43, 0x59, 0x4d, 0x6d, 0x0e, 0x01, - 0x4a, 0x9d, 0x39, 0x76, 0x0e, 0x41, 0x48, 0x70, 0x11, 0x79, 0x0e, 0x01, - 0xf9, 0x70, 0x0e, 0x41, 0x04, 0x0e, 0x0b, 0x06, 0x4a, 0x74, 0xb2, 0x7e, - 0x0e, 0x41, 0x44, 0x22, 0x00, 0x7b, 0x0e, 0x01, 0x47, 0x2a, 0x01, 0x7c, - 0x0e, 0x01, 0x45, 0xf5, 0x74, 0x7d, 0x0e, 0x41, 0x45, 0x12, 0x0b, 0x67, - 0x0e, 0x01, 0xa6, 0x29, 0x44, 0xea, 0x2a, 0x68, 0x0e, 0x01, 0x43, 0x0e, - 0x0b, 0x60, 0x0e, 0x01, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, - 0x62, 0x0e, 0x01, 0x42, 0x15, 0x02, 0x61, 0x0e, 0x41, 0x44, 0xe5, 0x1d, - 0x66, 0x0e, 0x01, 0x42, 0x1c, 0x26, 0x65, 0x0e, 0x41, 0x43, 0xd2, 0x05, - 0x64, 0x0e, 0x01, 0x43, 0xf6, 0x06, 0x63, 0x0e, 0x41, 0x52, 0x48, 0x50, - 0x60, 0xf3, 0x01, 0x48, 0x69, 0xc4, 0x16, 0xf9, 0x01, 0x42, 0x36, 0x01, - 0xa8, 0xfa, 0x81, 0xb6, 0x03, 0x02, 0x60, 0x07, 0x8c, 0x03, 0x04, 0x5d, - 0x18, 0x82, 0x01, 0xaf, 0x74, 0x42, 0x46, 0x03, 0x39, 0xf3, 0x81, 0x67, - 0x06, 0xa1, 0x21, 0x45, 0x03, 0x42, 0x0b, 0x06, 0x45, 0x65, 0xec, 0xa3, - 0xf6, 0x41, 0x80, 0x2d, 0x0e, 0x44, 0x77, 0x01, 0xff, 0x43, 0x2b, 0xf4, - 0x65, 0xf2, 0x01, 0x42, 0x81, 0x16, 0x60, 0xf2, 0x01, 0x42, 0xc7, 0x15, - 0x61, 0xf2, 0x01, 0x02, 0xa4, 0x02, 0x06, 0x42, 0xe2, 0x0c, 0x63, 0xf2, - 0x41, 0x42, 0x3c, 0x01, 0x62, 0xf2, 0x01, 0x46, 0xf0, 0xe0, 0x64, 0xf2, - 0x41, 0x47, 0x18, 0xd5, 0xcd, 0xf4, 0x01, 0x46, 0x84, 0xe0, 0x8b, 0xf7, - 0x41, 0x49, 0x35, 0xb7, 0x3a, 0x21, 0x00, 0x53, 0xa7, 0x21, 0x67, 0x27, - 0x00, 0x58, 0x19, 0x29, 0x65, 0x27, 0x00, 0x5d, 0xf9, 0x15, 0xcd, 0x2b, - 0x00, 0x57, 0x0b, 0x32, 0xcf, 0x2b, 0x40, 0x43, 0xee, 0x05, 0xf5, 0xf3, - 0x41, 0x44, 0x3d, 0x0d, 0x13, 0xf4, 0x01, 0x4b, 0x3a, 0xa3, 0xdc, 0xfa, - 0x41, 0x47, 0x29, 0xcf, 0x9a, 0x01, 0x01, 0x4e, 0x56, 0x76, 0x9b, 0x01, - 0x01, 0xa4, 0xe4, 0x01, 0x08, 0x27, 0x5d, 0x33, 0x4e, 0x7a, 0x7b, 0x97, - 0x01, 0x01, 0xb3, 0x06, 0x4a, 0xe1, 0x9f, 0x91, 0x01, 0x41, 0xa5, 0x06, - 0x4b, 0x83, 0x9d, 0x95, 0x01, 0x41, 0x4b, 0xe0, 0x9f, 0x92, 0x01, 0x01, - 0x4d, 0x19, 0x89, 0x98, 0x01, 0x01, 0x02, 0xda, 0x06, 0x01, 0xff, 0x48, - 0x81, 0xc3, 0x90, 0x01, 0x01, 0x48, 0x4e, 0x4a, 0x93, 0x01, 0x41, 0xa5, - 0x9e, 0x01, 0xa6, 0x68, 0x44, 0xea, 0x2a, 0x68, 0x21, 0x00, 0x43, 0x0e, - 0x0b, 0x60, 0x21, 0x80, 0x3e, 0x54, 0x43, 0x45, 0x83, 0x21, 0x00, 0xb3, - 0x23, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x69, 0x21, 0x80, 0x13, 0x44, - 0x25, 0x01, 0x62, 0x21, 0x00, 0xb7, 0x01, 0xff, 0x44, 0x02, 0x2c, 0x6b, - 0x21, 0x00, 0xef, 0x61, 0x21, 0x40, 0x49, 0x46, 0x5e, 0x82, 0x21, 0x40, - 0x44, 0xe5, 0x1d, 0x66, 0x21, 0x00, 0x42, 0x1c, 0x26, 0x65, 0x21, 0xc0, - 0x00, 0x4a, 0xfe, 0xa5, 0x85, 0x21, 0x40, 0x80, 0x01, 0xff, 0x47, 0x71, - 0x11, 0x6d, 0x21, 0x80, 0x0d, 0x48, 0x47, 0x5e, 0x6f, 0x21, 0xc0, 0x00, - 0x44, 0xdd, 0xec, 0x80, 0x21, 0x40, 0x49, 0x46, 0x5e, 0x88, 0x21, 0x40, - 0xa9, 0x06, 0x43, 0xf6, 0x06, 0x63, 0x21, 0x40, 0x43, 0x59, 0x4d, 0x6c, - 0x21, 0x80, 0x16, 0x42, 0x32, 0x00, 0x64, 0x21, 0xc0, 0x00, 0x80, 0x01, - 0xff, 0x47, 0x71, 0x11, 0x6e, 0x21, 0x00, 0x48, 0x47, 0x5e, 0x81, 0x21, - 0x40, 0x80, 0x01, 0xff, 0x4a, 0xa0, 0xa9, 0x86, 0x21, 0x00, 0x48, 0x47, - 0x5e, 0x87, 0x21, 0x40, 0x44, 0xc9, 0x00, 0x67, 0x21, 0x00, 0x45, 0xbb, - 0x6f, 0x6a, 0x21, 0x40, 0x4c, 0xa4, 0x8e, 0x96, 0x01, 0x01, 0x53, 0x43, - 0x4a, 0x94, 0x01, 0x01, 0x4d, 0xb5, 0x89, 0x99, 0x01, 0x41, 0x49, 0x92, - 0xb4, 0xfb, 0xf9, 0x01, 0xa5, 0x06, 0x59, 0x4f, 0x24, 0x23, 0xf9, 0x41, - 0x4e, 0xaa, 0x76, 0xde, 0xf5, 0x01, 0x02, 0x18, 0x00, 0x01, 0xff, 0x47, - 0xc2, 0x64, 0xa2, 0xf3, 0x01, 0x45, 0x20, 0xeb, 0xfc, 0xf6, 0x41, 0x42, - 0xed, 0x05, 0x80, 0xf6, 0x41, 0xe5, 0x2b, 0x20, 0x00, 0xe9, 0x67, 0x20, - 0x00, 0xed, 0x0f, 0x20, 0x00, 0xef, 0x2e, 0x20, 0x40, 0x47, 0x3d, 0x4c, - 0xfc, 0xfd, 0x00, 0x44, 0x16, 0x86, 0x80, 0xf3, 0x81, 0xb3, 0x0f, 0x03, - 0x0e, 0x08, 0xa2, 0x0f, 0x43, 0xd5, 0x04, 0x46, 0xf9, 0x01, 0x03, 0xca, - 0x00, 0x4a, 0x42, 0x1d, 0x01, 0x8d, 0xf4, 0x81, 0x11, 0x17, 0x53, 0x31, - 0x01, 0xff, 0x50, 0x2d, 0x63, 0x2b, 0x29, 0x00, 0x50, 0x97, 0x40, 0x30, - 0x29, 0x40, 0x80, 0x0c, 0x49, 0x3a, 0xb8, 0x90, 0xfa, 0x01, 0x48, 0x31, - 0xc7, 0x6d, 0xf5, 0x41, 0x45, 0x5c, 0x00, 0xda, 0x02, 0x00, 0x44, 0x71, - 0xef, 0xdf, 0xf6, 0x01, 0x48, 0xf8, 0x0c, 0x57, 0x22, 0x00, 0x4b, 0x99, - 0x9d, 0x56, 0x22, 0x00, 0x48, 0x9a, 0x1d, 0x18, 0x22, 0x00, 0x45, 0x9c, - 0x01, 0x30, 0x2e, 0x40, 0x80, 0xc6, 0x08, 0x8d, 0xe3, 0x06, 0x55, 0xb4, - 0x3b, 0x3d, 0x2a, 0x00, 0x06, 0xa9, 0x01, 0x01, 0xff, 0x45, 0xce, 0x00, - 0x92, 0x21, 0x80, 0xba, 0x04, 0xa2, 0x9b, 0x04, 0x50, 0x8d, 0x61, 0x3e, - 0xf8, 0x01, 0xa4, 0xdb, 0x03, 0xa6, 0xcc, 0x03, 0xa8, 0xcb, 0x02, 0x57, - 0x87, 0x2f, 0xa7, 0xf8, 0x01, 0x51, 0x00, 0x5d, 0xfe, 0x21, 0x00, 0xb0, - 0xb0, 0x02, 0x4f, 0x13, 0x72, 0x46, 0x2b, 0x00, 0xb2, 0x9b, 0x02, 0xb3, - 0x81, 0x02, 0xb4, 0x1f, 0xb7, 0x01, 0xff, 0x49, 0x93, 0xb6, 0x9d, 0x21, - 0x00, 0x4a, 0x4a, 0x10, 0xe8, 0x21, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x49, - 0x3f, 0xb9, 0xf0, 0x21, 0x00, 0x59, 0xe3, 0x1e, 0x96, 0xf8, 0x41, 0x55, - 0x6d, 0x3d, 0xa3, 0xf8, 0x01, 0x02, 0x0d, 0x00, 0x51, 0x02, 0x15, 0x02, - 0x01, 0xff, 0x4d, 0x9a, 0x7f, 0xa0, 0x21, 0x00, 0x08, 0x09, 0x02, 0x01, - 0xff, 0x06, 0xce, 0x00, 0x06, 0x51, 0x98, 0x5e, 0x10, 0x29, 0x40, 0x48, - 0x78, 0xb4, 0x05, 0x29, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x56, 0xb0, - 0x33, 0x01, 0x29, 0x00, 0xb4, 0x06, 0x4f, 0xb7, 0x33, 0x00, 0x29, 0x40, - 0x43, 0x90, 0x17, 0x16, 0x29, 0x80, 0x06, 0x52, 0x2f, 0x06, 0xee, 0x2b, - 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x56, 0xb0, 0x33, 0x18, 0x29, 0x00, - 0x4f, 0xb7, 0x33, 0x17, 0x29, 0x40, 0x05, 0x04, 0x02, 0x11, 0x04, 0x89, - 0x1d, 0x01, 0xff, 0x45, 0xce, 0x00, 0xdb, 0x21, 0x00, 0x4a, 0x9f, 0x5e, - 0x0f, 0x29, 0x40, 0x4a, 0xe0, 0x01, 0x92, 0xf8, 0x01, 0x08, 0x09, 0x02, - 0x01, 0xff, 0x45, 0xce, 0x00, 0x62, 0x2b, 0x80, 0x0c, 0x4c, 0xd8, 0x8d, - 0x6c, 0x2b, 0x00, 0x4d, 0x79, 0x87, 0x86, 0x2b, 0x40, 0x80, 0x01, 0xff, - 0x64, 0x97, 0x09, 0x82, 0x2b, 0x00, 0x46, 0xd1, 0x14, 0x72, 0x2b, 0x00, - 0x05, 0x51, 0x00, 0x01, 0xff, 0x4a, 0x74, 0xa8, 0x2a, 0xf8, 0x01, 0x07, - 0x3b, 0x01, 0x28, 0x4b, 0x72, 0x68, 0x2e, 0xf8, 0x01, 0x09, 0xd0, 0xbb, - 0x12, 0x4c, 0x04, 0x92, 0x26, 0xf8, 0x01, 0x4c, 0x70, 0x92, 0x22, 0xf8, - 0x01, 0x50, 0x6d, 0x68, 0x32, 0xf8, 0x41, 0x49, 0xa5, 0x01, 0xa7, 0x2b, - 0x00, 0x47, 0x50, 0x02, 0xa5, 0x2b, 0x40, 0x51, 0x47, 0x05, 0x7c, 0x2b, - 0x00, 0x4f, 0xb7, 0x33, 0x7c, 0x2b, 0x40, 0x4f, 0xee, 0x66, 0x52, 0xf8, - 0x01, 0x02, 0x7c, 0x00, 0x01, 0xff, 0x4a, 0x0a, 0x94, 0x3a, 0xf8, 0x01, - 0x4b, 0x95, 0x7c, 0xdd, 0x21, 0x40, 0x57, 0x2b, 0x2f, 0xa5, 0xf8, 0x01, - 0x45, 0xbe, 0xae, 0x6e, 0xf6, 0x41, 0x4c, 0x7a, 0x87, 0xc9, 0x21, 0x00, - 0x4b, 0xa5, 0xa4, 0xf8, 0xfa, 0x41, 0xa1, 0x11, 0x05, 0x6e, 0x15, 0x01, - 0xff, 0x45, 0xce, 0x00, 0x46, 0xf8, 0x01, 0x50, 0x8d, 0x61, 0x42, 0xf8, - 0x41, 0x42, 0x1b, 0x00, 0xf1, 0xfa, 0x01, 0x06, 0xcb, 0x02, 0x01, 0xff, - 0x56, 0x02, 0x36, 0xcc, 0x21, 0x00, 0x0a, 0x98, 0x05, 0x01, 0xff, 0x04, - 0xa5, 0x01, 0x31, 0x02, 0x50, 0x02, 0x01, 0xff, 0x80, 0x06, 0x45, 0xa9, - 0x01, 0xc0, 0x21, 0x40, 0x06, 0x5c, 0x00, 0x0c, 0x48, 0x78, 0xb4, 0x5b, - 0x29, 0x00, 0x46, 0xd1, 0x14, 0x53, 0x29, 0x40, 0xac, 0x06, 0x61, 0x85, - 0x05, 0x64, 0x29, 0x40, 0x5d, 0xa2, 0x15, 0x68, 0x29, 0x00, 0x48, 0x3f, - 0x6b, 0x6c, 0x29, 0x40, 0x80, 0x06, 0x45, 0xa9, 0x01, 0xc1, 0x21, 0x40, - 0x66, 0x41, 0x06, 0x69, 0x29, 0x00, 0x4f, 0x38, 0x6b, 0x6d, 0x29, 0x00, - 0x48, 0x78, 0xb4, 0x5f, 0x29, 0x00, 0x46, 0xd1, 0x14, 0x57, 0x29, 0x40, - 0x50, 0x04, 0x5a, 0x36, 0xf8, 0x01, 0x60, 0x34, 0x10, 0xab, 0xf8, 0x41, - 0x4b, 0xd9, 0x8d, 0xe2, 0x21, 0x00, 0x06, 0x3c, 0x01, 0x01, 0xff, 0x45, - 0xce, 0x00, 0xd2, 0x21, 0x80, 0x06, 0x4a, 0x9f, 0x5e, 0x0d, 0x29, 0x40, - 0x80, 0x06, 0x45, 0x8e, 0x17, 0x1c, 0x29, 0x40, 0x48, 0x78, 0xb4, 0x07, - 0x29, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x46, 0x52, 0x05, 0xcf, 0x21, - 0x00, 0x4f, 0xb7, 0x33, 0x03, 0x29, 0x40, 0x5f, 0xb3, 0x10, 0xa9, 0xf8, - 0x01, 0x05, 0x0d, 0x03, 0x06, 0x58, 0x81, 0x2a, 0xa1, 0xf8, 0x41, 0x45, - 0xce, 0x00, 0x95, 0x2b, 0x00, 0x53, 0xda, 0x48, 0x8a, 0x2b, 0x40, 0x80, - 0x06, 0x45, 0x8e, 0x17, 0x1a, 0x29, 0x40, 0xa1, 0xdf, 0x01, 0x05, 0xaa, - 0x05, 0xc7, 0x01, 0x54, 0xdf, 0x44, 0xc4, 0x21, 0x00, 0xb4, 0x99, 0x01, - 0x05, 0x51, 0x00, 0x01, 0xff, 0x50, 0xad, 0x61, 0xb4, 0x21, 0x00, 0x02, - 0x3b, 0x01, 0x7e, 0x55, 0xd5, 0x01, 0x16, 0xf8, 0x01, 0x44, 0xac, 0x0e, - 0xaa, 0x21, 0x00, 0xac, 0x5b, 0x59, 0xfe, 0x24, 0x06, 0xf8, 0x01, 0x4c, - 0xe8, 0x92, 0x9a, 0xf8, 0x01, 0x4a, 0xa4, 0xaf, 0x45, 0x29, 0x00, 0xb3, - 0x31, 0xb4, 0x06, 0x4f, 0xb7, 0x33, 0xf8, 0x21, 0x40, 0x43, 0x90, 0x17, - 0xa3, 0x21, 0x80, 0x11, 0x03, 0x4a, 0x0c, 0x01, 0xff, 0x49, 0xa5, 0x01, - 0x0e, 0x2b, 0x00, 0x47, 0x50, 0x02, 0x0f, 0x2b, 0x40, 0x06, 0x50, 0x00, - 0x01, 0xff, 0x56, 0xb0, 0x33, 0x15, 0x29, 0x00, 0x4f, 0xb7, 0x33, 0x14, - 0x29, 0x40, 0x05, 0x5e, 0x07, 0x06, 0x45, 0x53, 0x05, 0x9b, 0x21, 0x40, - 0x55, 0xd5, 0x01, 0x12, 0xf8, 0x01, 0x52, 0x2e, 0x06, 0x02, 0xf8, 0x41, - 0x57, 0x92, 0x29, 0x0a, 0xf8, 0x01, 0xaf, 0x01, 0xff, 0x42, 0x1f, 0x00, - 0xac, 0x21, 0x00, 0x48, 0x8a, 0xad, 0xb2, 0xf8, 0x41, 0x49, 0x35, 0xc0, - 0x11, 0x29, 0x00, 0x54, 0xb2, 0x33, 0xfb, 0x21, 0x40, 0x07, 0x31, 0x2b, - 0x11, 0x03, 0xd2, 0x14, 0x01, 0xff, 0x42, 0x17, 0x00, 0xe5, 0x21, 0x00, - 0x4c, 0x60, 0x57, 0x1e, 0x29, 0x40, 0x4c, 0x87, 0x00, 0x43, 0x2b, 0x00, - 0x48, 0x59, 0xcb, 0x44, 0x2b, 0x00, 0xf8, 0x47, 0x29, 0x40, 0x43, 0x16, - 0x00, 0xa6, 0x21, 0x80, 0x06, 0x4f, 0x34, 0x0c, 0xc1, 0xf8, 0x41, 0x51, - 0x5b, 0x57, 0x20, 0x29, 0x40, 0x05, 0x5d, 0x00, 0x06, 0x63, 0xfb, 0x0a, - 0xb6, 0xfb, 0x41, 0x4f, 0xb1, 0x6a, 0x75, 0x29, 0x00, 0x08, 0x6d, 0x72, - 0x0c, 0x55, 0x3f, 0x3e, 0x42, 0x29, 0x00, 0x4e, 0x93, 0x3e, 0x74, 0x29, - 0x40, 0x4f, 0xb1, 0x6a, 0x48, 0x2b, 0x00, 0x4e, 0x93, 0x3e, 0x4c, 0x2b, - 0x40, 0x07, 0x8a, 0x2e, 0x9c, 0x01, 0x5b, 0xa1, 0x1b, 0xe5, 0x26, 0x00, - 0x09, 0x9c, 0x01, 0x2b, 0xb3, 0x1d, 0x08, 0xc1, 0xcb, 0x01, 0xff, 0x49, - 0x79, 0xb8, 0x2b, 0x20, 0x00, 0x47, 0x5f, 0x03, 0x67, 0x20, 0x00, 0x44, - 0xb9, 0x00, 0x0f, 0x20, 0x00, 0x48, 0xd1, 0xc9, 0x2e, 0x20, 0x40, 0x5c, - 0xfa, 0x17, 0xa9, 0x27, 0x00, 0x57, 0x14, 0x2f, 0x38, 0x29, 0x40, 0xa1, - 0x59, 0x54, 0x6f, 0x41, 0xfd, 0x29, 0x00, 0xa4, 0x45, 0x4b, 0xcb, 0x9b, - 0x7a, 0xcc, 0x01, 0x47, 0x6e, 0xd1, 0x01, 0xcc, 0x01, 0x50, 0xfd, 0x64, - 0x0e, 0xf5, 0x01, 0xb2, 0x0c, 0x4c, 0x94, 0x95, 0x03, 0xcc, 0x01, 0x44, - 0x96, 0xc7, 0x9f, 0xcc, 0x41, 0x49, 0xbb, 0xb5, 0x99, 0xcc, 0x01, 0x44, - 0xe6, 0xac, 0x67, 0xcc, 0x01, 0xaf, 0x01, 0xff, 0x05, 0x66, 0x09, 0x06, - 0x50, 0xbd, 0x64, 0xa3, 0xcc, 0x41, 0x47, 0xb5, 0xcf, 0xa1, 0xcc, 0x01, - 0x44, 0x13, 0x21, 0x58, 0xcc, 0x41, 0x44, 0xbd, 0xf0, 0x0f, 0xcc, 0x01, - 0x5a, 0xba, 0x21, 0xbb, 0x00, 0x40, 0x4c, 0x3f, 0x0f, 0x2a, 0x23, 0x00, - 0x4a, 0x24, 0xb2, 0x62, 0xcc, 0x41, 0x56, 0x00, 0x33, 0x8d, 0x05, 0x00, - 0x48, 0x11, 0xc4, 0x49, 0xcc, 0x01, 0x03, 0x31, 0x5b, 0x20, 0xb3, 0x01, - 0xff, 0x0f, 0x92, 0x2e, 0x0d, 0x4a, 0x50, 0xb3, 0xd5, 0x0f, 0xc0, 0x00, - 0x4a, 0x2d, 0x59, 0xd7, 0x0f, 0x40, 0x4c, 0x90, 0x8d, 0x76, 0xcc, 0x01, - 0x4a, 0x57, 0x29, 0x72, 0xcc, 0x41, 0xe8, 0x93, 0xcc, 0x81, 0x04, 0xf4, - 0x1c, 0xf9, 0x41, 0x50, 0x51, 0x29, 0x95, 0xcc, 0x41, 0xa1, 0x93, 0x05, - 0x06, 0x0c, 0x03, 0x82, 0x05, 0xa3, 0xd7, 0x04, 0x02, 0x3b, 0x01, 0xa7, - 0x04, 0xa6, 0x90, 0x04, 0x02, 0x22, 0x00, 0xa9, 0x03, 0x14, 0xc7, 0x43, - 0x98, 0x03, 0x56, 0xaa, 0x35, 0x1d, 0x2e, 0x00, 0x60, 0xd4, 0x0f, 0xca, - 0x22, 0x00, 0xaf, 0xed, 0x02, 0x4b, 0xda, 0x21, 0x29, 0x00, 0x80, 0xd0, - 0x02, 0x57, 0x9b, 0x30, 0x0d, 0x2e, 0x00, 0xb3, 0xb4, 0x01, 0xb4, 0x4b, - 0x09, 0x32, 0x00, 0x33, 0xb7, 0x01, 0xff, 0x05, 0xae, 0x02, 0x06, 0x4b, - 0x15, 0x97, 0xd9, 0x29, 0x40, 0xa3, 0x18, 0x52, 0x87, 0x27, 0x17, 0x30, - 0x00, 0x4b, 0xda, 0x21, 0x86, 0x29, 0x00, 0x4e, 0xe3, 0x26, 0x1b, 0x30, - 0x00, 0x56, 0x54, 0x09, 0x19, 0x30, 0x40, 0x4d, 0x3c, 0x69, 0x0f, 0x30, - 0x00, 0x4c, 0x73, 0x0b, 0x84, 0x29, 0x40, 0xa2, 0x06, 0x4d, 0x1b, 0x30, - 0x06, 0xcc, 0x41, 0x4d, 0xab, 0x80, 0x21, 0x2e, 0x00, 0x47, 0x85, 0xd4, - 0xb9, 0x23, 0x40, 0x43, 0x0e, 0x03, 0xa2, 0x22, 0x00, 0xa8, 0x27, 0x55, - 0x55, 0x09, 0x15, 0x30, 0x00, 0xb2, 0x01, 0xff, 0x53, 0x1c, 0x48, 0x0a, - 0x2e, 0x00, 0x04, 0x1b, 0x01, 0x01, 0xff, 0x42, 0x68, 0x00, 0xbf, 0x22, - 0x80, 0x06, 0x56, 0x56, 0x1d, 0x6e, 0xfb, 0x41, 0x54, 0x8f, 0x3f, 0xce, - 0x29, 0x40, 0x04, 0x4f, 0x89, 0x28, 0x4c, 0xa8, 0x93, 0xed, 0xf5, 0x01, - 0x04, 0x26, 0x01, 0x01, 0xff, 0x4d, 0x08, 0x4d, 0x88, 0xfb, 0x01, 0x09, - 0x2a, 0x01, 0x01, 0xff, 0x45, 0x33, 0x01, 0x8a, 0xfb, 0x01, 0x57, 0x9e, - 0x2f, 0xa1, 0xce, 0x01, 0x57, 0xaf, 0x31, 0xaa, 0xce, 0x41, 0x48, 0x29, - 0xc7, 0x0d, 0xcc, 0x01, 0x5a, 0x8a, 0x22, 0xc3, 0xfb, 0x41, 0x55, 0xea, - 0x38, 0xc6, 0x27, 0x00, 0xa5, 0x7f, 0xa9, 0x71, 0x02, 0x6f, 0x02, 0x4f, - 0x4d, 0xe4, 0x26, 0x5d, 0x00, 0x80, 0x06, 0x53, 0xc6, 0x26, 0x03, 0x2e, - 0x40, 0x80, 0x01, 0xff, 0x49, 0xc8, 0x58, 0xa5, 0x23, 0x00, 0x4c, 0x80, - 0x91, 0xa6, 0x23, 0x00, 0x4c, 0xa8, 0x96, 0xa4, 0x23, 0x00, 0x05, 0x51, - 0x00, 0x01, 0xff, 0x4d, 0x4b, 0x82, 0x58, 0x2e, 0x00, 0x45, 0xb3, 0x80, - 0x46, 0x20, 0x00, 0x46, 0x52, 0x05, 0x56, 0x2e, 0x00, 0x08, 0xa9, 0xcb, - 0x06, 0x48, 0xea, 0x59, 0x8c, 0x29, 0x40, 0x4d, 0x47, 0x81, 0x8e, 0x29, - 0x00, 0x4a, 0x2e, 0xb2, 0x90, 0x29, 0x40, 0x44, 0xad, 0x27, 0x68, 0xf5, - 0x81, 0x06, 0x4a, 0x87, 0x7c, 0xe9, 0xf5, 0x41, 0x06, 0x50, 0x00, 0x01, - 0xff, 0x4e, 0x62, 0x7a, 0x69, 0xf5, 0x01, 0x51, 0x65, 0x5e, 0x6a, 0xf5, - 0x41, 0x50, 0xdd, 0x61, 0x27, 0x2e, 0x00, 0x53, 0x97, 0x0b, 0x19, 0x20, - 0x40, 0x50, 0xe4, 0x0f, 0xcc, 0x22, 0x00, 0x51, 0x04, 0x4d, 0x8b, 0xfb, - 0x41, 0x80, 0x01, 0xff, 0x49, 0xc8, 0x58, 0x9f, 0x23, 0x00, 0x4a, 0x88, - 0xad, 0xa0, 0x23, 0x00, 0x4a, 0x00, 0xb3, 0x9e, 0x23, 0x40, 0x03, 0xef, - 0x07, 0x0c, 0x4f, 0xb9, 0x71, 0xbc, 0xfb, 0x01, 0x49, 0x73, 0xaf, 0xd6, - 0x27, 0x40, 0x4c, 0x12, 0x0b, 0x95, 0x25, 0x00, 0x4d, 0x5f, 0x1d, 0x87, - 0xfb, 0x41, 0x4c, 0x0c, 0x03, 0xe9, 0xfb, 0x01, 0x4c, 0x32, 0x11, 0xe1, - 0xfb, 0x41, 0x03, 0x24, 0x00, 0x06, 0x55, 0x2e, 0x3d, 0x7d, 0xf5, 0x41, - 0x5a, 0x16, 0x1f, 0x00, 0xce, 0x01, 0x02, 0x33, 0x01, 0x38, 0xa6, 0x2a, - 0x65, 0xe2, 0x07, 0x11, 0xce, 0x01, 0x57, 0x9e, 0x2f, 0xa0, 0xce, 0x01, - 0x4c, 0x44, 0x04, 0x8d, 0xfb, 0x01, 0x4b, 0x8a, 0xa2, 0xb3, 0xfb, 0x01, - 0x56, 0x8e, 0x37, 0x0e, 0xce, 0x01, 0x57, 0xaf, 0x31, 0xab, 0xce, 0x01, - 0x4d, 0xac, 0x8a, 0x0c, 0xce, 0x41, 0x4c, 0xb0, 0x91, 0xa5, 0xcc, 0x01, - 0x45, 0xd3, 0x65, 0xba, 0xfb, 0x41, 0x04, 0x0e, 0x03, 0x06, 0x43, 0x35, - 0x01, 0x90, 0x25, 0x40, 0x46, 0x12, 0x03, 0xd7, 0x25, 0x00, 0x44, 0x31, - 0x13, 0xe9, 0x2b, 0x40, 0xa9, 0x06, 0x44, 0x5b, 0x24, 0x0b, 0x23, 0x40, - 0x47, 0x1d, 0xb9, 0x7d, 0x29, 0x00, 0x50, 0xb2, 0x51, 0x89, 0xfb, 0x41, - 0x59, 0xc0, 0x26, 0x05, 0x2e, 0x00, 0x05, 0x3d, 0x01, 0x01, 0xff, 0xa1, - 0x12, 0x4b, 0xda, 0x21, 0x29, 0x2e, 0x00, 0x4e, 0x19, 0x05, 0x1d, 0x20, - 0x00, 0x4c, 0x14, 0x97, 0xdb, 0x29, 0x40, 0x4c, 0x3f, 0x0f, 0x0b, 0x30, - 0x00, 0x56, 0x20, 0x37, 0x70, 0x29, 0x40, 0x46, 0xb2, 0xc4, 0x09, 0x23, - 0x00, 0x4d, 0x3c, 0x69, 0x0d, 0x30, 0x00, 0x4c, 0x73, 0x0b, 0x7d, 0x00, - 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x88, 0xad, 0xad, 0x23, 0x00, 0x4c, - 0x1c, 0x92, 0xac, 0x23, 0x00, 0x4a, 0x00, 0xb3, 0xab, 0x23, 0x40, 0x52, - 0x87, 0x27, 0x11, 0x30, 0x00, 0x56, 0x54, 0x09, 0x98, 0x29, 0x40, 0xae, - 0x1a, 0xb2, 0x01, 0xff, 0x56, 0xac, 0x17, 0x94, 0x29, 0x00, 0x09, 0x25, - 0x06, 0x01, 0xff, 0x4c, 0x6c, 0x8d, 0xf4, 0x27, 0x00, 0x4c, 0x3f, 0x15, - 0xf4, 0x21, 0x40, 0x02, 0x06, 0x00, 0x43, 0xa7, 0x01, 0xff, 0x49, 0x9d, - 0xb8, 0xef, 0xf5, 0x01, 0x42, 0x68, 0x00, 0x1f, 0x22, 0xc0, 0x00, 0x80, - 0x01, 0xff, 0x47, 0x63, 0x09, 0x09, 0x30, 0x80, 0x23, 0x5a, 0xcc, 0x1f, - 0x01, 0x2e, 0x00, 0x53, 0xd3, 0x1f, 0x00, 0x2e, 0x00, 0x53, 0x7e, 0x4e, - 0x9c, 0x29, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x43, 0xaa, 0x17, 0xbe, - 0x22, 0x00, 0x56, 0xf2, 0x33, 0x7c, 0x23, 0x40, 0x49, 0x90, 0x3b, 0x92, - 0x29, 0x40, 0x56, 0x08, 0x0b, 0x7f, 0xfb, 0x01, 0x56, 0xe6, 0x37, 0x7e, - 0xfb, 0x41, 0x44, 0xe9, 0x1c, 0x59, 0xf3, 0x01, 0x47, 0x3a, 0xd0, 0x58, - 0xf3, 0x41, 0x07, 0xcd, 0x00, 0x01, 0xff, 0x05, 0x9e, 0x14, 0x31, 0x05, - 0xc3, 0x00, 0x21, 0x06, 0xc8, 0x00, 0x11, 0x03, 0x7d, 0x15, 0x01, 0xff, - 0x44, 0xc3, 0x00, 0xb2, 0x2b, 0x00, 0x45, 0xc8, 0x00, 0xb3, 0x2b, 0x40, - 0x44, 0xa5, 0x01, 0xb7, 0x2b, 0x00, 0x42, 0x50, 0x02, 0xb5, 0x2b, 0x40, - 0x44, 0xa5, 0x01, 0xb6, 0x2b, 0x00, 0x42, 0x50, 0x02, 0xb4, 0x2b, 0x40, - 0x44, 0xc3, 0x00, 0xb0, 0x2b, 0x00, 0x45, 0xc8, 0x00, 0xb1, 0x2b, 0x40, - 0xa3, 0xb8, 0x05, 0x02, 0x06, 0x00, 0xa7, 0x05, 0x4c, 0xf8, 0x8e, 0x3b, - 0x20, 0x00, 0x02, 0xf1, 0x06, 0xaa, 0x04, 0x05, 0xc4, 0xe7, 0xcb, 0x02, - 0x4b, 0xe8, 0x58, 0x0c, 0xf6, 0x01, 0x4d, 0x0d, 0x86, 0x97, 0xf3, 0x01, - 0x53, 0x89, 0x20, 0xfd, 0xff, 0x00, 0xb3, 0x99, 0x02, 0x05, 0xc0, 0xeb, - 0x82, 0x02, 0xb6, 0x01, 0xff, 0x04, 0x3f, 0x04, 0x06, 0x4d, 0xdd, 0x86, - 0x9e, 0xf4, 0x41, 0x80, 0xa9, 0x01, 0x02, 0x06, 0x00, 0x01, 0xff, 0x45, - 0x04, 0x02, 0xa3, 0x29, 0x80, 0x96, 0x01, 0x45, 0x13, 0x05, 0x41, 0x2e, - 0x00, 0x07, 0x3b, 0x01, 0x79, 0x49, 0x82, 0xb8, 0xb0, 0x29, 0x00, 0x52, - 0xc2, 0x51, 0x11, 0x2e, 0x00, 0x60, 0xb4, 0x0f, 0x95, 0xf5, 0x01, 0x48, - 0x91, 0x73, 0x10, 0x23, 0x00, 0xb0, 0x53, 0x4d, 0xc1, 0x34, 0x2e, 0x2e, - 0x00, 0xb2, 0x39, 0xb3, 0x2b, 0xb4, 0x06, 0x4c, 0xf0, 0x96, 0x94, 0xf5, - 0x41, 0x06, 0xbe, 0xdc, 0x13, 0x44, 0x38, 0x23, 0x3d, 0x22, 0x80, 0x06, - 0x4b, 0x3d, 0xa2, 0x37, 0x20, 0x40, 0x47, 0x47, 0x13, 0xcd, 0x22, 0x40, - 0x49, 0xe9, 0xb7, 0x93, 0xf5, 0x01, 0x47, 0xfb, 0xd6, 0x92, 0xf5, 0x41, - 0x53, 0x09, 0x48, 0x43, 0x21, 0x00, 0x48, 0xe1, 0x59, 0x4f, 0x20, 0x40, - 0x5f, 0xd2, 0x10, 0x91, 0xf5, 0x01, 0x4a, 0x58, 0x45, 0xfe, 0x2b, 0x00, - 0x5a, 0xa0, 0x21, 0x19, 0x26, 0x40, 0x4b, 0x78, 0x9d, 0x4b, 0x20, 0x00, - 0x44, 0x07, 0x1b, 0x35, 0x20, 0x40, 0x45, 0x06, 0x1b, 0x36, 0x20, 0x80, - 0x06, 0x4f, 0x8a, 0x73, 0xed, 0x2a, 0x40, 0x4f, 0x18, 0x05, 0x1d, 0x30, - 0x40, 0x4e, 0x34, 0x5f, 0xa5, 0x29, 0x40, 0x4d, 0x6d, 0x14, 0x7f, 0xf6, - 0x01, 0x45, 0x8f, 0x13, 0x8d, 0x00, 0x00, 0x02, 0xc3, 0x01, 0x2d, 0x47, - 0x6a, 0x31, 0x5c, 0x00, 0x80, 0x11, 0x15, 0x93, 0x3e, 0x01, 0xff, 0x4f, - 0x69, 0x1a, 0x41, 0x2b, 0x00, 0x50, 0xb3, 0x02, 0x47, 0x2b, 0x40, 0x80, - 0x01, 0xff, 0x48, 0x9a, 0x1d, 0xf5, 0x29, 0x00, 0x50, 0xfd, 0x65, 0xc8, - 0x27, 0x00, 0x56, 0x3e, 0x38, 0xf7, 0x29, 0x40, 0x5e, 0x17, 0x13, 0xc8, - 0xf7, 0x01, 0x47, 0xd2, 0x20, 0x8d, 0x00, 0x40, 0x44, 0xc3, 0x00, 0x90, - 0x2b, 0x00, 0x45, 0xc8, 0x00, 0x91, 0x2b, 0x00, 0x46, 0x16, 0x08, 0xce, - 0x23, 0x40, 0x45, 0x26, 0xea, 0x1f, 0x21, 0x00, 0x02, 0x19, 0x01, 0x01, - 0xff, 0x11, 0xe0, 0x5a, 0x06, 0x43, 0x0a, 0x54, 0xbb, 0xf6, 0x41, 0xd1, - 0xe0, 0x26, 0x00, 0xd2, 0xe1, 0x26, 0x40, 0x0f, 0x58, 0x33, 0xc4, 0x01, - 0x07, 0xec, 0x05, 0x37, 0x4c, 0x13, 0x27, 0x5f, 0xa9, 0x00, 0xb6, 0x01, - 0xff, 0x45, 0xe6, 0x23, 0x53, 0xa9, 0x00, 0x0a, 0x56, 0x77, 0x01, 0xff, - 0xa1, 0x19, 0xe5, 0x49, 0xa9, 0x80, 0x0c, 0xe9, 0x47, 0xa9, 0x00, 0xef, - 0x4b, 0xa9, 0x00, 0xf5, 0x48, 0xa9, 0x40, 0xe1, 0x4e, 0xa9, 0x00, 0xf5, - 0x4d, 0xa9, 0x40, 0xe9, 0x4a, 0xa9, 0x00, 0xf5, 0x4c, 0xa9, 0x40, 0xe1, - 0x46, 0xa9, 0x00, 0x42, 0x16, 0x00, 0x37, 0xa9, 0x00, 0x42, 0x37, 0x00, - 0x39, 0xa9, 0x00, 0x42, 0xf0, 0x10, 0x34, 0xa9, 0x00, 0x42, 0x24, 0x02, - 0x31, 0xa9, 0x00, 0x42, 0x22, 0x00, 0x41, 0xa9, 0x00, 0x42, 0x72, 0x19, - 0x3a, 0xa9, 0x00, 0x42, 0x1b, 0x02, 0x30, 0xa9, 0x00, 0x42, 0x74, 0x00, - 0x3e, 0xa9, 0x00, 0xad, 0x49, 0xae, 0x24, 0x42, 0xbb, 0x09, 0x36, 0xa9, - 0x00, 0x42, 0x71, 0x00, 0x3d, 0xa9, 0x00, 0x42, 0x40, 0x06, 0x3c, 0xa9, - 0x00, 0x42, 0x12, 0x00, 0x33, 0xa9, 0x00, 0x42, 0xa9, 0x01, 0x40, 0xa9, - 0x00, 0x42, 0xbe, 0x22, 0x3f, 0xa9, 0x40, 0xe1, 0x35, 0xa9, 0x00, 0x42, - 0xf0, 0x10, 0x44, 0xa9, 0x00, 0xa7, 0x0d, 0xb9, 0x01, 0xff, 0xe1, 0x3b, - 0xa9, 0x00, 0x42, 0x72, 0x19, 0x45, 0xa9, 0x40, 0xe1, 0x32, 0xa9, 0x00, - 0x42, 0x24, 0x02, 0x43, 0xa9, 0x40, 0xe1, 0x38, 0xa9, 0x00, 0x42, 0x16, - 0x00, 0x42, 0xa9, 0x40, 0xe8, 0x52, 0xa9, 0x00, 0xee, 0x50, 0xa9, 0x80, - 0x04, 0xf2, 0x51, 0xa9, 0x40, 0xe7, 0x4f, 0xa9, 0x40, 0x1d, 0x50, 0x16, - 0x06, 0x4b, 0x0e, 0xa3, 0xae, 0x00, 0x40, 0xe1, 0xe6, 0xf1, 0x01, 0xe2, - 0xe7, 0xf1, 0x01, 0xe3, 0xe8, 0xf1, 0x01, 0xe4, 0xe9, 0xf1, 0x01, 0xe5, - 0xea, 0xf1, 0x01, 0xe6, 0xeb, 0xf1, 0x01, 0xe7, 0xec, 0xf1, 0x01, 0xe8, - 0xed, 0xf1, 0x01, 0xe9, 0xee, 0xf1, 0x01, 0xea, 0xef, 0xf1, 0x01, 0xeb, - 0xf0, 0xf1, 0x01, 0xec, 0xf1, 0xf1, 0x01, 0xed, 0xf2, 0xf1, 0x01, 0xee, - 0xf3, 0xf1, 0x01, 0xef, 0xf4, 0xf1, 0x01, 0xf0, 0xf5, 0xf1, 0x01, 0xf1, - 0xf6, 0xf1, 0x01, 0xf2, 0xf7, 0xf1, 0x01, 0xf3, 0xf8, 0xf1, 0x01, 0xf4, - 0xf9, 0xf1, 0x01, 0xf5, 0xfa, 0xf1, 0x01, 0xf6, 0xfb, 0xf1, 0x01, 0xf7, - 0xfc, 0xf1, 0x01, 0xf8, 0xfd, 0xf1, 0x01, 0xf9, 0xfe, 0xf1, 0x01, 0xfa, - 0xff, 0xf1, 0x41, 0x45, 0x77, 0xe4, 0x4e, 0xf3, 0x01, 0x4d, 0x69, 0x83, - 0xe7, 0xf9, 0x41, 0xa5, 0x51, 0x4d, 0x60, 0x66, 0x1e, 0x00, 0x00, 0x51, - 0x88, 0x5d, 0x99, 0xf6, 0x01, 0x03, 0x3c, 0x25, 0x01, 0xff, 0x4f, 0xfa, - 0x29, 0x7c, 0x26, 0x00, 0x0f, 0xad, 0x6e, 0x01, 0xff, 0x51, 0x47, 0x5a, - 0x7a, 0x26, 0x00, 0x05, 0x4d, 0x21, 0x01, 0xff, 0x4a, 0xee, 0xa6, 0x73, - 0x26, 0x00, 0x4a, 0x02, 0xa7, 0x74, 0x26, 0x00, 0x4a, 0x16, 0xa7, 0x75, - 0x26, 0x00, 0x4a, 0x20, 0xa7, 0x76, 0x26, 0x00, 0x4a, 0x2a, 0xa7, 0x77, - 0x26, 0x00, 0x4a, 0x34, 0xa7, 0x78, 0x26, 0x00, 0x4a, 0x3e, 0xa7, 0x79, - 0x26, 0x40, 0x43, 0x77, 0x06, 0xfe, 0xf9, 0x01, 0x46, 0x64, 0xdf, 0x12, - 0xcc, 0x41, 0x44, 0x59, 0xef, 0x07, 0xf4, 0x81, 0xcd, 0x01, 0xa3, 0xb3, - 0x01, 0x02, 0x00, 0x00, 0x97, 0x01, 0xa9, 0x15, 0xed, 0x0f, 0xf4, 0x01, - 0xf4, 0x00, 0xf4, 0x81, 0x06, 0x43, 0x06, 0xf5, 0x92, 0xfa, 0x41, 0x42, - 0xb5, 0x00, 0x36, 0x22, 0x40, 0x05, 0x69, 0xe8, 0x70, 0xee, 0xc6, 0x26, - 0x80, 0x65, 0x04, 0x46, 0x03, 0x01, 0xff, 0x4c, 0xa0, 0x8c, 0x1a, 0xf9, - 0x01, 0x45, 0x13, 0x05, 0x34, 0x2e, 0x00, 0x43, 0x23, 0x0a, 0x33, 0x2e, - 0x80, 0x47, 0x44, 0x0b, 0xcb, 0x0a, 0x27, 0x00, 0x44, 0xc6, 0x0d, 0x0b, - 0x27, 0x80, 0x29, 0x54, 0xa5, 0x2b, 0x06, 0x2e, 0x00, 0xad, 0x0f, 0xb3, - 0x01, 0xff, 0x58, 0x21, 0x2a, 0xcc, 0xfb, 0x01, 0x45, 0xd7, 0x05, 0x0b, - 0x2e, 0x40, 0x46, 0x46, 0x64, 0x6a, 0xf1, 0x01, 0x46, 0xb7, 0x47, 0x6b, - 0xf1, 0x01, 0x46, 0x2f, 0x0e, 0x6c, 0xf1, 0x41, 0x06, 0x50, 0x00, 0x01, - 0xff, 0x4f, 0xe2, 0x10, 0x90, 0xf5, 0x01, 0x64, 0xbb, 0x09, 0x96, 0xf5, - 0x41, 0x58, 0xa1, 0x2b, 0x07, 0x2e, 0x40, 0x43, 0x54, 0x81, 0x08, 0xf3, - 0x41, 0x43, 0xca, 0x64, 0x83, 0xf6, 0x01, 0x45, 0x93, 0xeb, 0xe4, 0xf6, - 0x41, 0x51, 0xf3, 0x58, 0xb7, 0x23, 0x00, 0xef, 0xfb, 0xf4, 0xc1, 0x00, - 0x47, 0x38, 0xcd, 0x18, 0xf5, 0x01, 0x4b, 0xdf, 0x98, 0x22, 0x26, 0x40, - 0x44, 0x85, 0xef, 0x9d, 0xf9, 0x01, 0x04, 0xa1, 0x01, 0x01, 0xff, 0x43, - 0xca, 0x64, 0xce, 0xf3, 0x01, 0x4a, 0x3c, 0xae, 0xcd, 0xf3, 0x41, 0x45, - 0x0b, 0x08, 0x30, 0xf4, 0x41, 0xa1, 0x24, 0x06, 0xc3, 0x34, 0x0c, 0x46, - 0x06, 0xdd, 0xbb, 0x26, 0x00, 0x4c, 0x1b, 0x05, 0x22, 0x00, 0x40, 0x80, - 0x06, 0x4b, 0x42, 0x67, 0x5f, 0x22, 0x40, 0x50, 0xad, 0x00, 0x48, 0x20, - 0x00, 0x44, 0xb9, 0x00, 0x3f, 0x00, 0x40, 0x02, 0x26, 0x0d, 0x12, 0x43, - 0x76, 0x14, 0x7e, 0xf7, 0x01, 0x49, 0xb9, 0x54, 0x69, 0x26, 0x00, 0x59, - 0xa7, 0x26, 0x16, 0x2a, 0x40, 0x04, 0x7e, 0x0d, 0x11, 0x05, 0x49, 0x4c, - 0x01, 0xff, 0x51, 0xaf, 0x26, 0x0c, 0x2a, 0x00, 0x45, 0x06, 0x1b, 0x57, - 0x20, 0x40, 0x06, 0x13, 0x01, 0x46, 0x06, 0x6d, 0x02, 0x01, 0xff, 0x44, - 0xc3, 0x00, 0x98, 0x25, 0x80, 0x14, 0x45, 0xc8, 0x00, 0x9d, 0x25, 0xc0, - 0x00, 0x4f, 0xc2, 0x39, 0x9e, 0x25, 0xc0, 0x00, 0x50, 0x43, 0x44, 0x9f, - 0x25, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x06, 0x13, 0x01, 0x11, 0x16, - 0xfc, 0x37, 0x01, 0xff, 0x44, 0xc3, 0x00, 0x9b, 0x25, 0x00, 0x45, 0xc8, - 0x00, 0x9c, 0x25, 0x40, 0x54, 0x3f, 0x44, 0x99, 0x25, 0x00, 0x45, 0xc8, - 0x00, 0x9a, 0x25, 0x40, 0x44, 0xc3, 0x00, 0x96, 0x25, 0x00, 0x45, 0xc8, - 0x00, 0x97, 0x25, 0x40, 0xa1, 0xb3, 0x18, 0xa4, 0xa8, 0x18, 0xa5, 0x95, - 0x16, 0xa8, 0xff, 0x0e, 0xa9, 0xf8, 0x0d, 0xac, 0x85, 0x08, 0xed, 0x9e, - 0x00, 0x00, 0x4d, 0x8f, 0x86, 0x11, 0xcc, 0x01, 0xaf, 0x9c, 0x06, 0xb2, - 0x8c, 0x02, 0xb3, 0x3b, 0xb5, 0x01, 0xff, 0xd1, 0x91, 0x00, 0x00, 0xd2, - 0x92, 0x00, 0x00, 0x58, 0x99, 0x27, 0xe2, 0xf4, 0x01, 0x04, 0x09, 0x0c, - 0x1a, 0xb2, 0x0c, 0x45, 0x1a, 0xd5, 0xcc, 0xf4, 0x01, 0x5c, 0x4a, 0x19, - 0xae, 0xf6, 0x41, 0x49, 0x34, 0xbe, 0x9c, 0xf4, 0x01, 0x42, 0x46, 0x03, - 0x5b, 0xf4, 0x41, 0x4b, 0x8f, 0x99, 0x08, 0x20, 0x00, 0x4f, 0xe5, 0x72, - 0x4e, 0x2e, 0x40, 0x0e, 0xd8, 0x75, 0x06, 0x44, 0x61, 0xf3, 0xc9, 0xce, - 0x41, 0x0f, 0x45, 0x6d, 0xb4, 0x01, 0x07, 0xec, 0x05, 0x3f, 0x07, 0x1a, - 0x3a, 0x0c, 0x4c, 0x13, 0x27, 0x99, 0x0b, 0x01, 0x53, 0xe6, 0x4d, 0x9a, - 0x0b, 0x41, 0x44, 0xf5, 0x06, 0xac, 0x0b, 0x01, 0x43, 0x0e, 0x0b, 0xa9, - 0x0b, 0x81, 0x1c, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0xad, 0x0b, 0x01, - 0x44, 0x25, 0x01, 0xab, 0x0b, 0x01, 0xb7, 0x01, 0xff, 0x44, 0xe7, 0x1d, - 0xae, 0x0b, 0x01, 0xef, 0xaa, 0x0b, 0x41, 0x48, 0x70, 0x11, 0xaf, 0x0b, - 0x41, 0x45, 0xd3, 0xad, 0x80, 0x0b, 0x01, 0x44, 0x61, 0xef, 0x81, 0x0b, - 0x01, 0x46, 0x2a, 0x4a, 0x83, 0x0b, 0x01, 0x45, 0xfe, 0xaa, 0x82, 0x0b, - 0x01, 0x42, 0xb0, 0x01, 0x84, 0x0b, 0x81, 0x4c, 0x44, 0xed, 0xf0, 0x89, - 0x0b, 0x01, 0x46, 0xb4, 0xdd, 0x8a, 0x0b, 0x01, 0x48, 0x69, 0xc8, 0x8b, - 0x0b, 0x01, 0x43, 0xde, 0x22, 0x8c, 0x0b, 0x01, 0x42, 0x6f, 0x02, 0x8e, - 0x0b, 0x01, 0xb3, 0x18, 0x43, 0xc5, 0xc4, 0x91, 0x0b, 0x01, 0x4d, 0x9f, - 0x8a, 0x85, 0x0b, 0x01, 0x44, 0xa8, 0x52, 0x88, 0x0b, 0x01, 0x45, 0xa2, - 0x52, 0x86, 0x0b, 0x41, 0xa1, 0x06, 0x43, 0x7a, 0x16, 0x90, 0x0b, 0x41, - 0x43, 0xcd, 0xea, 0x8f, 0x0b, 0x01, 0x44, 0x69, 0xe4, 0x8d, 0x0b, 0x41, - 0x42, 0x53, 0x00, 0x87, 0x0b, 0x41, 0x45, 0x95, 0x10, 0x9b, 0x0b, 0x01, - 0x43, 0x23, 0x0a, 0x9c, 0x0b, 0x41, 0x4a, 0x42, 0xa8, 0xff, 0xf4, 0x01, - 0xa5, 0x86, 0x01, 0xa9, 0x30, 0xaf, 0x01, 0xff, 0x49, 0xc9, 0xb6, 0xaf, - 0xf9, 0x01, 0x4c, 0xc4, 0x8f, 0xc7, 0xf6, 0x01, 0x47, 0x55, 0xd2, 0x05, - 0x23, 0x00, 0xb0, 0x06, 0x47, 0x74, 0x48, 0xd8, 0x2b, 0x40, 0x49, 0xaf, - 0xb8, 0x4a, 0x21, 0x00, 0x46, 0x30, 0x24, 0x37, 0x22, 0xc0, 0x00, 0x45, - 0xfb, 0x0c, 0x1d, 0x22, 0x40, 0x42, 0x2a, 0x02, 0x32, 0x20, 0x00, 0xae, - 0x29, 0x02, 0xf5, 0x0a, 0x01, 0xff, 0x4a, 0x28, 0xa9, 0x9e, 0x00, 0x00, - 0x06, 0x9c, 0xe0, 0x01, 0xff, 0x80, 0x0b, 0x8d, 0x01, 0xff, 0xd1, 0x91, - 0x00, 0x00, 0xd2, 0x92, 0x00, 0x40, 0x43, 0x0e, 0x0b, 0x91, 0x00, 0x00, - 0x43, 0x1f, 0x0a, 0x92, 0x00, 0x40, 0x42, 0x73, 0x02, 0x34, 0xf9, 0x81, - 0x16, 0xb4, 0x01, 0xff, 0x4e, 0xd3, 0x59, 0x99, 0x23, 0x00, 0x42, 0x33, - 0x00, 0xa8, 0xf5, 0xc1, 0x00, 0x45, 0xde, 0xe1, 0xb6, 0xf5, 0x41, 0x42, - 0xee, 0x00, 0x78, 0xf4, 0x41, 0x45, 0x0c, 0xca, 0x7a, 0x22, 0x80, 0xa6, - 0x02, 0x06, 0x34, 0xdc, 0x8f, 0x02, 0xb3, 0x0c, 0x44, 0xed, 0xf2, 0x68, - 0xf9, 0x01, 0x4a, 0x78, 0xb3, 0x97, 0x23, 0x40, 0x4d, 0xa2, 0x81, 0x1e, - 0x21, 0x00, 0x1b, 0x50, 0x1b, 0x01, 0xff, 0x02, 0x13, 0x05, 0xe5, 0x01, - 0xa5, 0xd0, 0x01, 0x53, 0xde, 0x29, 0x19, 0xfe, 0x00, 0x0c, 0x4e, 0x20, - 0xb9, 0x01, 0xac, 0x6a, 0x4d, 0xc1, 0x34, 0x16, 0xfe, 0x00, 0x06, 0xc8, - 0x00, 0x12, 0x49, 0x42, 0xbf, 0x14, 0xfe, 0x00, 0x4e, 0xaa, 0x7d, 0x30, - 0xfe, 0x00, 0x4d, 0x85, 0x8a, 0x34, 0xfe, 0x40, 0x4d, 0x3e, 0x0f, 0x40, - 0xfe, 0x00, 0x58, 0x81, 0x27, 0x3c, 0xfe, 0x00, 0xa3, 0x34, 0x54, 0xab, - 0x41, 0x3e, 0xfe, 0x00, 0x4b, 0xda, 0x21, 0x36, 0xfe, 0x00, 0x4e, 0xe3, - 0x26, 0x48, 0xfe, 0x00, 0x56, 0x54, 0x09, 0x3a, 0xfe, 0x00, 0x06, 0xad, - 0x02, 0x01, 0xff, 0x4e, 0x3b, 0x69, 0x44, 0xfe, 0x00, 0x0e, 0x87, 0x27, - 0x01, 0xff, 0x44, 0x66, 0x09, 0x18, 0xfe, 0x00, 0x44, 0xf1, 0xf0, 0x18, - 0xfe, 0x40, 0x4d, 0x3c, 0x69, 0x42, 0xfe, 0x00, 0x4c, 0x73, 0x0b, 0x38, - 0xfe, 0x40, 0x04, 0xc4, 0x00, 0x06, 0x47, 0x8b, 0x8a, 0x33, 0xfe, 0x40, - 0x4d, 0x3e, 0x0f, 0x3f, 0xfe, 0x00, 0x58, 0x81, 0x27, 0x3b, 0xfe, 0x00, - 0xa3, 0x29, 0x54, 0xab, 0x41, 0x3d, 0xfe, 0x00, 0x4b, 0xda, 0x21, 0x35, - 0xfe, 0x00, 0x4e, 0xe3, 0x26, 0x47, 0xfe, 0x00, 0x56, 0x54, 0x09, 0x39, - 0xfe, 0x00, 0x06, 0xad, 0x02, 0x01, 0xff, 0x4e, 0x3b, 0x69, 0x43, 0xfe, - 0x00, 0x52, 0x87, 0x27, 0x17, 0xfe, 0x40, 0x4d, 0x3c, 0x69, 0x41, 0xfe, - 0x00, 0x4c, 0x73, 0x0b, 0x37, 0xfe, 0x40, 0x45, 0x13, 0x05, 0x11, 0xfe, - 0x00, 0x49, 0x81, 0x16, 0x12, 0xfe, 0x40, 0x46, 0xe3, 0xc2, 0x31, 0xfe, - 0x00, 0x46, 0x38, 0xde, 0x32, 0xfe, 0x00, 0x4f, 0xae, 0x00, 0x15, 0xfe, - 0x40, 0x43, 0xd7, 0x02, 0x13, 0xfe, 0x00, 0x43, 0x15, 0x05, 0x10, 0xfe, - 0x40, 0x43, 0x5d, 0x18, 0xc3, 0xfa, 0x01, 0x46, 0x3a, 0x1d, 0xc4, 0xfa, - 0x01, 0x45, 0x35, 0x2d, 0x30, 0xf9, 0x41, 0x80, 0x01, 0xff, 0x06, 0x5c, - 0x00, 0x1c, 0x55, 0xe6, 0x39, 0xe8, 0x22, 0x00, 0x06, 0x0e, 0x29, 0x06, - 0x4e, 0xfe, 0x7d, 0xb0, 0x22, 0x40, 0x45, 0xfb, 0x0c, 0x7c, 0x22, 0x00, - 0x4a, 0xf1, 0x39, 0x7e, 0x22, 0x40, 0x4f, 0xb1, 0x6a, 0xb7, 0x2a, 0x00, - 0x4b, 0x48, 0x13, 0xb3, 0x2a, 0x00, 0x04, 0x72, 0x23, 0x11, 0x0c, 0x11, - 0x2b, 0x01, 0xff, 0x4b, 0x48, 0x13, 0xaf, 0x2a, 0x00, 0x4c, 0x1d, 0x2b, - 0xb1, 0x2a, 0x40, 0x4f, 0xb1, 0x6a, 0xb9, 0x2a, 0x00, 0x48, 0xf8, 0x0c, - 0xb5, 0x2a, 0x40, 0x4f, 0xbf, 0x6b, 0xa9, 0xf5, 0x01, 0x05, 0xc4, 0xaf, - 0xbe, 0x01, 0x44, 0xe1, 0xf1, 0x29, 0xf4, 0x01, 0xb0, 0x9f, 0x01, 0x4d, - 0x49, 0x88, 0xfe, 0xf4, 0x01, 0xb3, 0x6b, 0xb4, 0x4f, 0xb5, 0x24, 0x04, - 0x15, 0x01, 0x01, 0xff, 0x02, 0x10, 0x00, 0x0f, 0xb3, 0x01, 0xff, 0x4b, - 0xa1, 0x9e, 0xfe, 0x23, 0x00, 0x45, 0x17, 0x08, 0xfb, 0x23, 0x40, 0x47, - 0x15, 0x08, 0xfd, 0x23, 0x00, 0x4b, 0x92, 0x98, 0xfc, 0x23, 0x40, 0x42, - 0x6d, 0x14, 0x5d, 0xf4, 0x01, 0x48, 0x29, 0xc8, 0x57, 0xf3, 0x01, 0x47, - 0xb6, 0x47, 0xa3, 0x00, 0x00, 0x4b, 0x32, 0xa2, 0xd7, 0xfa, 0x01, 0x05, - 0xa0, 0x01, 0x01, 0xff, 0x48, 0x64, 0x1f, 0x3e, 0xf6, 0x01, 0x44, 0x0c, - 0x08, 0x21, 0xf6, 0x41, 0x48, 0xd5, 0x64, 0x72, 0xf3, 0x01, 0xa1, 0x06, - 0x49, 0xd2, 0xbf, 0xb4, 0xfa, 0x41, 0x50, 0x1f, 0x45, 0xb0, 0xf6, 0x01, - 0x42, 0x1e, 0x00, 0x54, 0xf9, 0x41, 0x45, 0xf8, 0xe5, 0xe7, 0x2b, 0x00, - 0x4f, 0x2e, 0x67, 0x16, 0x23, 0x00, 0xb4, 0x01, 0xff, 0x03, 0x13, 0x00, - 0x06, 0x43, 0xd6, 0x3a, 0xee, 0xf4, 0x41, 0x44, 0x7b, 0x2d, 0xef, 0xf4, - 0x01, 0x44, 0xb9, 0x00, 0x12, 0x30, 0xc0, 0x00, 0x45, 0x0b, 0x08, 0x20, - 0x30, 0x40, 0x0d, 0x8d, 0x7f, 0x06, 0x44, 0x43, 0x19, 0x7f, 0xf3, 0x41, - 0x4a, 0x90, 0xaa, 0x2c, 0x20, 0x00, 0x47, 0x5f, 0x03, 0x69, 0x20, 0x40, - 0x43, 0xca, 0x64, 0x93, 0xf6, 0x81, 0x06, 0x47, 0xdd, 0xd3, 0x6e, 0xf4, - 0x41, 0x51, 0xcc, 0x5d, 0xa8, 0xf6, 0x41, 0xa1, 0x9c, 0x01, 0xe4, 0x8b, - 0x00, 0x00, 0xf5, 0x8c, 0x00, 0xc0, 0x00, 0x44, 0xda, 0x09, 0xa0, 0xfa, - 0x01, 0xb3, 0x29, 0x42, 0x1e, 0x00, 0x47, 0x26, 0xc0, 0x00, 0x06, 0x58, - 0x1b, 0x01, 0xff, 0xa6, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0xd4, - 0x2b, 0x00, 0x42, 0x15, 0x02, 0xd3, 0x2b, 0x40, 0x43, 0xd2, 0x05, 0xd6, - 0x2b, 0x00, 0x43, 0xf6, 0x06, 0xd5, 0x2b, 0x40, 0x45, 0x59, 0x03, 0x2b, - 0x00, 0x80, 0x06, 0x4b, 0x87, 0x98, 0xb1, 0x00, 0x40, 0x80, 0x01, 0xff, - 0x51, 0x42, 0x13, 0x72, 0x2a, 0x00, 0x03, 0xe1, 0x05, 0x36, 0x05, 0x51, - 0x00, 0x01, 0xff, 0x4e, 0x65, 0x6b, 0x28, 0x2a, 0x00, 0x57, 0x00, 0x2e, - 0x23, 0x2a, 0x00, 0x49, 0x9f, 0x12, 0x25, 0x2a, 0x00, 0xb3, 0x11, 0x06, - 0x37, 0x23, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x24, 0x2a, 0x00, 0x45, 0x20, - 0x07, 0x26, 0x2a, 0x40, 0x51, 0x7d, 0x55, 0x22, 0x2a, 0x00, 0x4c, 0x48, - 0x96, 0x27, 0x2a, 0x40, 0x50, 0x8d, 0x64, 0x2d, 0x2a, 0x00, 0x51, 0xaa, - 0x5d, 0x2e, 0x2a, 0x00, 0x48, 0x01, 0x02, 0x39, 0x2a, 0x40, 0xa3, 0xb7, - 0x04, 0x4c, 0x88, 0x92, 0x0e, 0x21, 0x80, 0xa9, 0x04, 0xb9, 0x01, 0xff, - 0x4c, 0x70, 0x8f, 0xdd, 0xf6, 0x01, 0x09, 0x95, 0xba, 0x01, 0xff, 0x07, - 0x4b, 0x79, 0xfe, 0x03, 0xa2, 0xef, 0x03, 0x09, 0x5e, 0xb8, 0xd2, 0x03, - 0xa6, 0x8d, 0x03, 0x08, 0x71, 0xc7, 0xf0, 0x02, 0xab, 0xb4, 0x02, 0x08, - 0xd9, 0xc8, 0x97, 0x02, 0x09, 0x73, 0xbe, 0xfa, 0x01, 0x49, 0xb2, 0xbe, - 0xbf, 0xf0, 0x01, 0xb3, 0xb8, 0x01, 0xb4, 0x06, 0x4b, 0x29, 0xa5, 0xdf, - 0xf0, 0x41, 0x06, 0x76, 0xbe, 0x93, 0x01, 0x08, 0xe9, 0xc6, 0x77, 0x05, - 0xbc, 0xea, 0x1d, 0x06, 0x6e, 0xe1, 0x01, 0xff, 0x45, 0x7b, 0xe5, 0xd2, - 0xf0, 0x01, 0x48, 0x31, 0xc5, 0xc2, 0xf0, 0x01, 0x46, 0xe4, 0x86, 0xb2, - 0xf0, 0x01, 0x46, 0x18, 0xe0, 0xa2, 0xf0, 0x41, 0xd1, 0xe1, 0xf0, 0x81, - 0x29, 0xd2, 0xe2, 0xf0, 0x81, 0x1c, 0xd3, 0xe3, 0xf0, 0x01, 0xd4, 0xe4, - 0xf0, 0x01, 0xd5, 0xe5, 0xf0, 0x01, 0xd6, 0xe6, 0xf0, 0x01, 0xd7, 0xe7, - 0xf0, 0x01, 0xd8, 0xe8, 0xf0, 0x01, 0xd9, 0xe9, 0xf0, 0x41, 0xd0, 0xf4, - 0xf0, 0x01, 0xd1, 0xf5, 0xf0, 0x41, 0xd0, 0xea, 0xf0, 0x01, 0xd1, 0xeb, - 0xf0, 0x01, 0xd2, 0xec, 0xf0, 0x01, 0xd3, 0xed, 0xf0, 0x01, 0xd4, 0xee, - 0xf0, 0x01, 0xd5, 0xef, 0xf0, 0x01, 0xd6, 0xf0, 0xf0, 0x01, 0xd7, 0xf1, - 0xf0, 0x01, 0xd8, 0xf2, 0xf0, 0x01, 0xd9, 0xf3, 0xf0, 0x41, 0x45, 0x7b, - 0xe5, 0xd3, 0xf0, 0x01, 0x48, 0x31, 0xc5, 0xc3, 0xf0, 0x01, 0x46, 0xe4, - 0x86, 0xb3, 0xf0, 0x01, 0x46, 0x18, 0xe0, 0xa3, 0xf0, 0x41, 0x45, 0x7b, - 0xe5, 0xda, 0xf0, 0x01, 0x48, 0x31, 0xc5, 0xca, 0xf0, 0x01, 0x46, 0xe4, - 0x86, 0xba, 0xf0, 0x01, 0x46, 0x18, 0xe0, 0xaa, 0xf0, 0x41, 0x08, 0x21, - 0xc6, 0x1d, 0x06, 0x60, 0xdd, 0x01, 0xff, 0x45, 0x7b, 0xe5, 0xd6, 0xf0, - 0x01, 0x48, 0x31, 0xc5, 0xc6, 0xf0, 0x01, 0x46, 0xe4, 0x86, 0xb6, 0xf0, - 0x01, 0x46, 0x18, 0xe0, 0xa6, 0xf0, 0x41, 0x45, 0x7b, 0xe5, 0xd7, 0xf0, - 0x01, 0x48, 0x31, 0xc5, 0xc7, 0xf0, 0x01, 0x46, 0xe4, 0x86, 0xb7, 0xf0, - 0x01, 0x46, 0x18, 0xe0, 0xa7, 0xf0, 0x41, 0x45, 0x7b, 0xe5, 0xdd, 0xf0, - 0x01, 0x48, 0x31, 0xc5, 0xcd, 0xf0, 0x01, 0x46, 0xe4, 0x86, 0xbd, 0xf0, - 0x01, 0x46, 0x18, 0xe0, 0xad, 0xf0, 0x41, 0x45, 0x7b, 0xe5, 0xd9, 0xf0, - 0x01, 0x48, 0x31, 0xc5, 0xc9, 0xf0, 0x01, 0x46, 0xe4, 0x86, 0xb9, 0xf0, - 0x01, 0x46, 0x18, 0xe0, 0xa9, 0xf0, 0x41, 0x07, 0x82, 0x39, 0x1d, 0x09, - 0x96, 0xbc, 0x01, 0xff, 0x45, 0x7b, 0xe5, 0xdc, 0xf0, 0x01, 0x48, 0x31, - 0xc5, 0xcc, 0xf0, 0x01, 0x46, 0xe4, 0x86, 0xbc, 0xf0, 0x01, 0x46, 0x18, - 0xe0, 0xac, 0xf0, 0x41, 0x45, 0x7b, 0xe5, 0xde, 0xf0, 0x01, 0x48, 0x31, - 0xc5, 0xce, 0xf0, 0x01, 0x46, 0xe4, 0x86, 0xbe, 0xf0, 0x01, 0x46, 0x18, - 0xe0, 0xae, 0xf0, 0x41, 0x45, 0x7b, 0xe5, 0xdb, 0xf0, 0x01, 0x48, 0x31, - 0xc5, 0xcb, 0xf0, 0x01, 0x46, 0xe4, 0x86, 0xbb, 0xf0, 0x01, 0x46, 0x18, - 0xe0, 0xab, 0xf0, 0x41, 0x07, 0x39, 0xd2, 0x26, 0xaf, 0x01, 0xff, 0x42, - 0x61, 0x03, 0xe0, 0xf0, 0x01, 0x06, 0x4e, 0xd4, 0x01, 0xff, 0x45, 0x7b, - 0xe5, 0xd4, 0xf0, 0x01, 0x48, 0x31, 0xc5, 0xc4, 0xf0, 0x01, 0x46, 0xe4, - 0x86, 0xb4, 0xf0, 0x01, 0x46, 0x18, 0xe0, 0xa4, 0xf0, 0x41, 0x45, 0x7b, - 0xe5, 0xd5, 0xf0, 0x01, 0x48, 0x31, 0xc5, 0xc5, 0xf0, 0x01, 0x46, 0xe4, - 0x86, 0xb5, 0xf0, 0x01, 0x46, 0x18, 0xe0, 0xa5, 0xf0, 0x41, 0x45, 0x7b, - 0xe5, 0xd8, 0xf0, 0x01, 0x48, 0x31, 0xc5, 0xc8, 0xf0, 0x01, 0x46, 0xe4, - 0x86, 0xb8, 0xf0, 0x01, 0x46, 0x18, 0xe0, 0xa8, 0xf0, 0x41, 0x43, 0x0e, - 0x03, 0xa0, 0xf0, 0x01, 0x4a, 0x98, 0xac, 0xcf, 0xf0, 0x41, 0x45, 0x7b, - 0xe5, 0xd1, 0xf0, 0x01, 0x48, 0x31, 0xc5, 0xc1, 0xf0, 0x01, 0x46, 0xe4, - 0x86, 0xb1, 0xf0, 0x01, 0x46, 0x18, 0xe0, 0xa1, 0xf0, 0x41, 0x4c, 0x8c, - 0x8b, 0x0f, 0x21, 0x40, 0x43, 0xaa, 0x01, 0xa7, 0xfa, 0x01, 0x05, 0x2b, - 0x43, 0x01, 0xff, 0x4d, 0x53, 0x84, 0x18, 0x23, 0x00, 0x47, 0xbf, 0xd7, - 0xd0, 0xf6, 0x41, 0x42, 0x36, 0x01, 0xcf, 0x26, 0x80, 0x77, 0xe5, 0x67, - 0xf9, 0x01, 0xe7, 0x16, 0xf4, 0x81, 0x5f, 0xac, 0x4d, 0xae, 0x1b, 0xb3, - 0x0d, 0x47, 0x61, 0xd6, 0xd4, 0x22, 0xc0, 0x00, 0x4d, 0x02, 0x80, 0xda, - 0x2a, 0x40, 0x43, 0x58, 0x7c, 0x53, 0x26, 0x00, 0x43, 0xd8, 0x3c, 0x2b, - 0xf5, 0x41, 0x43, 0xf3, 0x18, 0x85, 0xfa, 0x01, 0x02, 0x6d, 0x14, 0x1a, - 0xa5, 0x0c, 0x47, 0x23, 0x29, 0x77, 0xfa, 0x01, 0x4a, 0x2b, 0x13, 0x2f, - 0x27, 0x40, 0x4b, 0x7f, 0x97, 0x8d, 0xf3, 0x01, 0x45, 0x77, 0xe4, 0x4d, - 0xf3, 0x41, 0x4a, 0xc8, 0xa9, 0x0c, 0xf9, 0x01, 0x48, 0x3f, 0x2d, 0x0f, - 0xf9, 0x41, 0x49, 0x7a, 0x9d, 0xb6, 0x00, 0x00, 0x48, 0x81, 0xc5, 0xa9, - 0xf4, 0x01, 0xec, 0x8a, 0xf4, 0x41, 0x80, 0x01, 0xff, 0x44, 0x0c, 0x08, - 0x37, 0xf4, 0x01, 0x44, 0x15, 0x17, 0x3d, 0xf4, 0x41, 0x48, 0x41, 0xcc, - 0xfb, 0xf6, 0x41, 0xa1, 0xde, 0x01, 0x09, 0x68, 0xba, 0xcd, 0x01, 0xaf, - 0x01, 0xff, 0x08, 0xc1, 0xc5, 0x06, 0x43, 0x74, 0x28, 0xdb, 0x2b, 0x40, - 0x07, 0xec, 0x05, 0x33, 0x07, 0x1a, 0x3a, 0x06, 0x4e, 0xec, 0x7e, 0x1f, - 0x09, 0x41, 0x43, 0x0e, 0x0b, 0x16, 0x09, 0x81, 0x1c, 0xb4, 0x01, 0xff, - 0x42, 0x92, 0x01, 0x17, 0x09, 0x01, 0x44, 0x25, 0x01, 0x1b, 0x09, 0x01, - 0xb7, 0x01, 0xff, 0x44, 0xe7, 0x1d, 0x18, 0x09, 0x01, 0xef, 0x1a, 0x09, - 0x41, 0x48, 0x70, 0x11, 0x19, 0x09, 0x41, 0xa1, 0x7b, 0x43, 0xc0, 0x09, - 0x01, 0x09, 0x01, 0x44, 0x9e, 0xe5, 0x03, 0x09, 0x01, 0x44, 0x05, 0xf0, - 0x02, 0x09, 0x01, 0x42, 0xb0, 0x01, 0x04, 0x09, 0x81, 0x5e, 0x43, 0xae, - 0x51, 0x0a, 0x09, 0x01, 0x44, 0x37, 0xe8, 0x0b, 0x09, 0x01, 0x43, 0xb4, - 0x05, 0x0c, 0x09, 0x01, 0x43, 0xde, 0x22, 0x0d, 0x09, 0x01, 0x42, 0x6f, - 0x02, 0x10, 0x09, 0x01, 0x43, 0xb8, 0xf4, 0x12, 0x09, 0x01, 0x44, 0xcc, - 0xb9, 0x13, 0x09, 0x01, 0xb3, 0x20, 0xb4, 0x12, 0x43, 0x2a, 0xa4, 0x05, - 0x09, 0x01, 0x43, 0xa8, 0x52, 0x09, 0x09, 0x01, 0x43, 0x2e, 0x75, 0x06, - 0x09, 0x41, 0x42, 0x61, 0x24, 0x15, 0x09, 0x01, 0x42, 0xed, 0x05, 0x08, - 0x09, 0x41, 0x43, 0x0c, 0x02, 0x11, 0x09, 0x01, 0x43, 0x08, 0x83, 0x0e, - 0x09, 0x01, 0x43, 0x7a, 0x16, 0x14, 0x09, 0x41, 0xf4, 0x07, 0x09, 0x41, - 0x42, 0x9e, 0x01, 0x0f, 0x09, 0x01, 0x42, 0x24, 0x00, 0x00, 0x09, 0x41, - 0x52, 0x0e, 0x51, 0x36, 0x17, 0x00, 0x52, 0x6a, 0x55, 0x35, 0x17, 0x40, - 0x06, 0x52, 0xdc, 0xc7, 0x02, 0x10, 0x3d, 0x64, 0x01, 0xff, 0x45, 0xce, - 0x00, 0xd9, 0x01, 0x01, 0xa2, 0x9a, 0x02, 0xa3, 0xe3, 0x01, 0x02, 0x3b, - 0x01, 0xd2, 0x01, 0x45, 0xd5, 0xe5, 0xee, 0x01, 0x01, 0x45, 0x93, 0xe6, - 0xf8, 0x01, 0x01, 0xa7, 0xb7, 0x01, 0xa8, 0xa2, 0x01, 0x02, 0xc3, 0x01, - 0x93, 0x01, 0x02, 0x6c, 0x00, 0x82, 0x01, 0x47, 0x7e, 0xd4, 0xf7, 0x01, - 0x01, 0xb0, 0x5f, 0xb2, 0x51, 0xb3, 0x29, 0xb4, 0x15, 0x44, 0x31, 0xc1, - 0xf3, 0x01, 0x01, 0xb7, 0x01, 0xff, 0x48, 0xf1, 0xc3, 0xfc, 0x01, 0x01, - 0x44, 0x36, 0x2d, 0xd5, 0x01, 0x41, 0x4c, 0x94, 0x8c, 0xd2, 0x01, 0x01, - 0x44, 0x91, 0xf0, 0xd8, 0x01, 0x01, 0x44, 0xa4, 0x60, 0xf0, 0x01, 0x41, - 0x42, 0xd2, 0x2d, 0xdf, 0x01, 0x01, 0x02, 0x49, 0x00, 0x12, 0x44, 0x2f, - 0x0b, 0xe5, 0x01, 0x01, 0x48, 0x39, 0xc8, 0xfb, 0x01, 0x01, 0x47, 0x99, - 0xd6, 0xfa, 0x01, 0x41, 0x43, 0x04, 0x24, 0xdb, 0x01, 0x01, 0xf0, 0xe8, - 0x01, 0x41, 0x42, 0x57, 0x00, 0xed, 0x01, 0x01, 0x46, 0x10, 0xdf, 0xf5, - 0x01, 0x41, 0x46, 0xf4, 0xd9, 0xf4, 0x01, 0x01, 0x49, 0xd2, 0xa9, 0xd0, - 0x01, 0x01, 0xac, 0x01, 0xff, 0x48, 0x79, 0xc3, 0xf2, 0x01, 0x01, 0x49, - 0x6b, 0xc0, 0xd1, 0x01, 0x41, 0x46, 0x4a, 0xde, 0xdd, 0x01, 0x01, 0x45, - 0xb1, 0xeb, 0xde, 0x01, 0x41, 0xe4, 0xe0, 0x01, 0x01, 0x42, 0x75, 0x0b, - 0xf6, 0x01, 0x41, 0x45, 0x14, 0xc3, 0xd6, 0x01, 0x01, 0x43, 0x03, 0x00, - 0xea, 0x01, 0x01, 0x43, 0x28, 0x05, 0xe9, 0x01, 0x41, 0x47, 0x5a, 0xcf, - 0xd7, 0x01, 0x01, 0x45, 0xc0, 0xa1, 0xf9, 0x01, 0x41, 0x44, 0x29, 0xf1, - 0xe3, 0x01, 0x01, 0x42, 0x32, 0x00, 0xef, 0x01, 0x41, 0xa1, 0x22, 0x44, - 0x2f, 0x4a, 0xd4, 0x01, 0x01, 0x43, 0x27, 0x4b, 0xdc, 0x01, 0x01, 0xaf, - 0x01, 0xff, 0x44, 0x3d, 0xf1, 0xe6, 0x01, 0x01, 0x42, 0xb6, 0x05, 0xe4, - 0x01, 0xc1, 0x00, 0x54, 0x4f, 0x43, 0xfd, 0x01, 0x41, 0x45, 0x53, 0x72, - 0xd3, 0x01, 0x01, 0x4d, 0x2f, 0x88, 0xe2, 0x01, 0x01, 0xf4, 0xec, 0x01, - 0x41, 0x42, 0x27, 0x01, 0xf1, 0x01, 0x81, 0x12, 0xaf, 0x06, 0x48, 0x21, - 0xcc, 0xeb, 0x01, 0x41, 0x47, 0xf9, 0xd3, 0xe1, 0x01, 0x01, 0xf7, 0xda, - 0x01, 0x41, 0x44, 0xad, 0x84, 0xe7, 0x01, 0x41, 0x50, 0x2d, 0x62, 0x75, - 0xa8, 0x00, 0x07, 0xec, 0x05, 0x38, 0x05, 0xb9, 0x00, 0x28, 0xb3, 0x01, - 0xff, 0x4f, 0xbc, 0x6e, 0x74, 0xa8, 0x00, 0xb5, 0x01, 0xff, 0x0f, 0xde, - 0x67, 0x06, 0x52, 0x92, 0x54, 0x72, 0xa8, 0x40, 0x42, 0x71, 0x00, 0x71, - 0xa8, 0x00, 0x42, 0xa9, 0x01, 0x67, 0xa8, 0x00, 0x42, 0xbe, 0x22, 0x68, - 0xa8, 0x40, 0x4b, 0x68, 0x9b, 0x77, 0xa8, 0x00, 0x44, 0xa4, 0x02, 0x76, - 0xa8, 0x40, 0xe1, 0x5d, 0xa8, 0x80, 0x92, 0x02, 0x42, 0x16, 0x00, 0x4e, - 0xa8, 0x00, 0xa3, 0xf8, 0x01, 0xa4, 0xe5, 0x01, 0xe5, 0x60, 0xa8, 0x80, - 0xdb, 0x01, 0x42, 0x0c, 0x08, 0x64, 0xa8, 0x00, 0xa7, 0xc8, 0x01, 0x42, - 0x22, 0x00, 0x5c, 0xa8, 0x00, 0xe9, 0x5e, 0xa8, 0x00, 0x42, 0x72, 0x19, - 0x46, 0xa8, 0x00, 0xab, 0xab, 0x01, 0x42, 0x74, 0x00, 0x59, 0xa8, 0x00, - 0x42, 0x6c, 0x00, 0x4f, 0xa8, 0x00, 0xae, 0x86, 0x01, 0xef, 0x61, 0xa8, - 0x00, 0xb0, 0x76, 0x42, 0x43, 0x14, 0x62, 0xa8, 0x00, 0x42, 0x71, 0x00, - 0x58, 0xa8, 0x00, 0xb3, 0x58, 0xb4, 0x33, 0xf5, 0x5f, 0xa8, 0x00, 0x05, - 0x26, 0x1d, 0x1f, 0x42, 0xa9, 0x01, 0x53, 0xa8, 0x00, 0x42, 0x08, 0x27, - 0x63, 0xa8, 0x00, 0x42, 0xbe, 0x22, 0x57, 0xa8, 0x00, 0xba, 0x01, 0xff, - 0xe1, 0x55, 0xa8, 0x00, 0x42, 0x22, 0x00, 0x54, 0xa8, 0x40, 0x44, 0xd6, - 0x10, 0x6f, 0xa8, 0x00, 0x48, 0xd1, 0xc7, 0x6e, 0xa8, 0x40, 0xe1, 0x48, - 0xa8, 0x00, 0x42, 0x22, 0x00, 0x49, 0xa8, 0x00, 0xb3, 0x0d, 0xb4, 0x01, - 0xff, 0xe1, 0x69, 0xa8, 0x00, 0x42, 0x22, 0x00, 0x6a, 0xa8, 0x40, 0xe1, - 0x50, 0xa8, 0x00, 0x42, 0x22, 0x00, 0x51, 0xa8, 0x40, 0xe1, 0x5b, 0xa8, - 0x00, 0x42, 0x22, 0x00, 0x5a, 0xa8, 0x00, 0x46, 0x04, 0x0a, 0x56, 0xa8, - 0x40, 0xe1, 0x4c, 0xa8, 0x00, 0x42, 0x22, 0x00, 0x4d, 0xa8, 0x40, 0xe1, - 0x4b, 0xa8, 0x00, 0x42, 0x24, 0x02, 0x43, 0xa8, 0x00, 0x42, 0x2a, 0x05, - 0x6c, 0xa8, 0x00, 0x42, 0xbe, 0x22, 0x47, 0xa8, 0x40, 0xe1, 0x40, 0xa8, - 0x00, 0x42, 0x22, 0x00, 0x41, 0xa8, 0x40, 0xe1, 0x42, 0xa8, 0x00, 0x42, - 0x24, 0x02, 0x65, 0xa8, 0x40, 0xe5, 0x66, 0xa8, 0x40, 0xe1, 0x4a, 0xa8, - 0x00, 0x42, 0xf0, 0x10, 0x6b, 0xa8, 0x00, 0x42, 0x59, 0x00, 0x52, 0xa8, - 0x40, 0xe1, 0x44, 0xa8, 0x80, 0x06, 0x42, 0x22, 0x00, 0x45, 0xa8, 0x40, - 0x49, 0xdb, 0x23, 0x73, 0xa8, 0x40, 0x4b, 0x3b, 0x9f, 0x6d, 0xa8, 0x00, - 0x4b, 0xed, 0xa2, 0x70, 0xa8, 0x40, 0xa1, 0xeb, 0x01, 0x48, 0xd3, 0xa9, - 0xb6, 0xf6, 0x01, 0xae, 0xc4, 0x01, 0x4c, 0x6c, 0x93, 0xc2, 0xfa, 0x01, - 0xb2, 0x14, 0xb3, 0x06, 0x48, 0xd1, 0xcb, 0xeb, 0xf9, 0x41, 0x48, 0x09, - 0xc6, 0xa7, 0x20, 0x00, 0x46, 0x42, 0xb1, 0xb1, 0x20, 0x40, 0x80, 0x93, - 0x01, 0x49, 0x04, 0x9c, 0x25, 0x00, 0x00, 0x4c, 0x1c, 0x8f, 0xad, 0xf3, - 0x01, 0x51, 0x12, 0x5c, 0x7e, 0x26, 0x00, 0x4a, 0xbe, 0x8e, 0xc2, 0x27, - 0x80, 0x74, 0xb3, 0x01, 0xff, 0x4c, 0xd4, 0x8e, 0x23, 0xf6, 0x01, 0x02, - 0x10, 0x00, 0x06, 0x47, 0xbd, 0xd4, 0x06, 0x23, 0x40, 0x80, 0x06, 0x4b, - 0xf9, 0x86, 0xbb, 0xf4, 0x41, 0x4d, 0x54, 0x81, 0x47, 0xf6, 0x01, 0x48, - 0xd9, 0xc4, 0xd7, 0xf9, 0x01, 0x4f, 0x37, 0x6c, 0x38, 0xf9, 0x01, 0x48, - 0x28, 0x83, 0x4d, 0xf6, 0x01, 0x03, 0xe1, 0x05, 0x31, 0x61, 0x6e, 0x0e, - 0x4c, 0xf6, 0x01, 0x05, 0x51, 0x00, 0x01, 0xff, 0xa2, 0x18, 0x45, 0x80, - 0xe5, 0xc5, 0xfa, 0x01, 0x4c, 0x10, 0x8f, 0x4f, 0xf6, 0x01, 0x49, 0xab, - 0xb9, 0xd5, 0xf9, 0x01, 0x4c, 0xe4, 0x93, 0x4e, 0xf6, 0x41, 0x43, 0x5f, - 0x07, 0xf9, 0x26, 0x00, 0x49, 0xc7, 0xbb, 0x71, 0xf4, 0x41, 0x4e, 0xba, - 0x79, 0xd8, 0xf9, 0x01, 0x4b, 0x03, 0xa3, 0xd6, 0xf9, 0x41, 0x47, 0x69, - 0x06, 0xe1, 0x2a, 0x40, 0x4a, 0x00, 0xae, 0x30, 0x20, 0x00, 0x44, 0x5a, - 0x03, 0x4c, 0x21, 0x00, 0x51, 0x43, 0x5e, 0x31, 0x20, 0x40, 0x56, 0x50, - 0x32, 0x86, 0xf5, 0x01, 0x43, 0x1f, 0xc0, 0x0f, 0x27, 0x00, 0x44, 0x39, - 0xf0, 0x27, 0xf4, 0x01, 0x49, 0x5d, 0xbf, 0x14, 0xf6, 0x01, 0x46, 0xb6, - 0x1b, 0xe4, 0x26, 0x40, 0x44, 0x81, 0xa1, 0xdb, 0xfa, 0x01, 0xa3, 0x0a, - 0x44, 0x3b, 0xeb, 0x5c, 0xf9, 0x01, 0xf2, 0x50, 0xf3, 0x41, 0x48, 0x5e, - 0x19, 0x2e, 0x26, 0x00, 0xe8, 0x51, 0xf3, 0x01, 0x43, 0x35, 0x01, 0x9a, - 0xf9, 0x41, 0xe6, 0x2c, 0x20, 0x00, 0xe9, 0x69, 0x20, 0x40, 0x45, 0x67, - 0xe5, 0xe6, 0xf4, 0x01, 0xe4, 0x80, 0x00, 0x80, 0xb6, 0x14, 0xa7, 0x87, - 0x14, 0x0b, 0xde, 0x9c, 0xa3, 0x0d, 0xac, 0x94, 0x0b, 0xae, 0x85, 0x0b, - 0x47, 0x77, 0x82, 0xce, 0xf4, 0x01, 0xb2, 0x96, 0x03, 0x02, 0xee, 0x00, - 0xed, 0x02, 0x0a, 0x88, 0xb2, 0x06, 0x48, 0x79, 0xcc, 0x3e, 0xf4, 0x41, - 0x4c, 0xe9, 0x28, 0xf5, 0x1a, 0x81, 0xcc, 0x02, 0xac, 0x62, 0x4e, 0x00, - 0x7a, 0xef, 0x1a, 0x81, 0x4c, 0x4b, 0xcd, 0x66, 0xe6, 0x1a, 0x81, 0x2f, - 0x07, 0xc0, 0xd5, 0x01, 0xff, 0x4c, 0xe9, 0x28, 0xe7, 0x1a, 0x81, 0x1d, - 0x44, 0x56, 0x2d, 0xec, 0x1a, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x45, 0x10, - 0x2d, 0xee, 0x1a, 0x01, 0x44, 0xd7, 0x02, 0xeb, 0x1a, 0xc1, 0x00, 0x46, - 0x0f, 0x2d, 0xed, 0x1a, 0x41, 0x46, 0x0f, 0x2d, 0xea, 0x1a, 0x41, 0x80, - 0x01, 0xff, 0x45, 0x10, 0x2d, 0xe9, 0x1a, 0x01, 0x44, 0xd7, 0x02, 0xe5, - 0x1a, 0xc1, 0x00, 0x46, 0x0f, 0x2d, 0xe8, 0x1a, 0x41, 0x80, 0x01, 0xff, - 0x45, 0x10, 0x2d, 0xf2, 0x1a, 0x01, 0x4a, 0x60, 0xad, 0xf1, 0x1a, 0x41, - 0x06, 0xed, 0x05, 0x1d, 0x4f, 0x9b, 0x71, 0xf4, 0x1a, 0xc1, 0x00, 0x80, - 0x01, 0xff, 0x45, 0x10, 0x2d, 0xf7, 0x1a, 0x01, 0x44, 0xd7, 0x02, 0xf3, - 0x1a, 0xc1, 0x00, 0x46, 0x0f, 0x2d, 0xf6, 0x1a, 0x41, 0xe1, 0xd5, 0x1a, - 0x01, 0x42, 0x16, 0x00, 0xcc, 0x1a, 0x01, 0xa3, 0xb0, 0x01, 0x42, 0xf0, - 0x10, 0xc4, 0x1a, 0x01, 0xe5, 0xd6, 0x1a, 0x01, 0xa6, 0x76, 0x42, 0x24, - 0x02, 0xc9, 0x1a, 0x01, 0x42, 0x22, 0x00, 0xc8, 0x1a, 0x01, 0xe9, 0xd7, - 0x1a, 0x81, 0x61, 0xab, 0x55, 0x42, 0x74, 0x00, 0xc2, 0x1a, 0x01, 0x42, - 0x6c, 0x00, 0xc3, 0x1a, 0x01, 0xae, 0x3d, 0xef, 0xd8, 0x1a, 0x01, 0xb0, - 0x2d, 0x42, 0x71, 0x00, 0xd2, 0x1a, 0x01, 0x42, 0x40, 0x06, 0xcb, 0x1a, - 0x01, 0xb4, 0x15, 0xf5, 0xd9, 0x1a, 0x81, 0x0c, 0x42, 0xf5, 0x0a, 0xc6, - 0x1a, 0x01, 0x42, 0x59, 0x00, 0xc5, 0x1a, 0x41, 0xe1, 0xda, 0x1a, 0x41, - 0xe1, 0xce, 0x1a, 0x01, 0x42, 0x22, 0x00, 0xcf, 0x1a, 0x41, 0xe1, 0xc0, - 0x1a, 0x01, 0x42, 0x22, 0x00, 0xd1, 0x1a, 0x41, 0xe1, 0xd0, 0x1a, 0x01, - 0x42, 0x24, 0x02, 0xc7, 0x1a, 0x41, 0xe1, 0xc1, 0x1a, 0x01, 0x42, 0x22, - 0x00, 0xca, 0x1a, 0x41, 0xe1, 0xdb, 0x1a, 0x41, 0xe1, 0xd3, 0x1a, 0x01, - 0x05, 0x03, 0x28, 0x01, 0xff, 0xeb, 0xdd, 0x1a, 0x01, 0xec, 0xe1, 0x1a, - 0x01, 0xed, 0xdf, 0x1a, 0x01, 0xee, 0xe0, 0x1a, 0x81, 0x10, 0xf0, 0xdc, - 0x1a, 0x01, 0xf4, 0xde, 0x1a, 0x01, 0xf7, 0xe2, 0x1a, 0x01, 0xf9, 0xe4, - 0x1a, 0x41, 0xe7, 0xe3, 0x1a, 0x41, 0xe1, 0xcd, 0x1a, 0x01, 0x42, 0x22, - 0x00, 0xd4, 0x1a, 0x41, 0x80, 0x01, 0xff, 0x45, 0x10, 0x2d, 0xf8, 0x1a, - 0x01, 0x47, 0x6b, 0x4e, 0xf0, 0x1a, 0x41, 0xa5, 0x16, 0x09, 0xef, 0xba, - 0x06, 0x4c, 0xd8, 0x93, 0xc2, 0xf6, 0x41, 0x52, 0x20, 0x51, 0x91, 0x23, - 0x00, 0x50, 0x2d, 0x68, 0x92, 0x23, 0x40, 0x48, 0x7a, 0x20, 0xfd, 0x2b, - 0x00, 0x49, 0x7b, 0xbc, 0xf3, 0xf6, 0x41, 0xa1, 0xab, 0x07, 0x0b, 0xe1, - 0x9b, 0x57, 0x43, 0xbf, 0x2c, 0x9c, 0xf9, 0x01, 0xb4, 0x01, 0xff, 0x51, - 0xe4, 0x56, 0x3d, 0x30, 0x00, 0x46, 0x8e, 0xdc, 0xc4, 0xce, 0x81, 0x3b, - 0x03, 0x8b, 0x0c, 0x0c, 0x4c, 0xa0, 0x92, 0x50, 0x32, 0x00, 0x48, 0xd1, - 0xcc, 0x89, 0xf3, 0x41, 0x80, 0x06, 0x58, 0xf1, 0x29, 0x7d, 0x26, 0x40, - 0x4c, 0x5c, 0x48, 0x02, 0x22, 0x00, 0x05, 0xed, 0x07, 0x01, 0xff, 0x48, - 0x09, 0xc4, 0x8c, 0x00, 0x00, 0x44, 0xa5, 0x01, 0x8b, 0x00, 0x00, 0x47, - 0xa8, 0x31, 0x8b, 0x00, 0x00, 0x42, 0x50, 0x02, 0x8c, 0x00, 0x40, 0x49, - 0x3c, 0x2e, 0x7a, 0xf7, 0x41, 0x06, 0xef, 0x06, 0x8e, 0x06, 0x07, 0x91, - 0xd1, 0xc2, 0x04, 0x0a, 0x9e, 0xab, 0xc3, 0x02, 0x12, 0x4e, 0x53, 0xb2, - 0x02, 0x06, 0xde, 0x05, 0x55, 0x07, 0x1a, 0x3a, 0x01, 0xff, 0xa5, 0x42, - 0xa6, 0x34, 0x48, 0xcc, 0x53, 0x86, 0x24, 0x00, 0xb3, 0x20, 0xb4, 0x01, - 0xff, 0x42, 0x92, 0x01, 0x7d, 0x24, 0x00, 0x47, 0x9c, 0x5a, 0x80, 0x24, - 0x00, 0x02, 0x15, 0x01, 0x01, 0xff, 0x43, 0x03, 0x2c, 0x7f, 0x24, 0x00, - 0x43, 0xe8, 0x1d, 0x87, 0x24, 0x40, 0x48, 0x8c, 0x51, 0x84, 0x24, 0x00, - 0x46, 0x1c, 0x26, 0x83, 0x24, 0x40, 0x46, 0x24, 0x18, 0x82, 0x24, 0x00, - 0x47, 0x11, 0x5d, 0x81, 0x24, 0x40, 0x47, 0x6d, 0x25, 0x85, 0x24, 0x00, - 0x45, 0xbb, 0x6f, 0x7e, 0x24, 0x40, 0x0f, 0xe4, 0x05, 0x6d, 0x0d, 0x76, - 0x08, 0x01, 0xff, 0xe1, 0x9c, 0x24, 0x00, 0xe2, 0x9d, 0x24, 0x00, 0xe3, - 0x9e, 0x24, 0x00, 0xe4, 0x9f, 0x24, 0x00, 0xe5, 0xa0, 0x24, 0x00, 0xe6, - 0xa1, 0x24, 0x00, 0xe7, 0xa2, 0x24, 0x00, 0xe8, 0xa3, 0x24, 0x00, 0xe9, - 0xa4, 0x24, 0x00, 0xea, 0xa5, 0x24, 0x00, 0xeb, 0xa6, 0x24, 0x00, 0xec, - 0xa7, 0x24, 0x00, 0xed, 0xa8, 0x24, 0x00, 0xee, 0xa9, 0x24, 0x00, 0xef, - 0xaa, 0x24, 0x00, 0xf0, 0xab, 0x24, 0x00, 0xf1, 0xac, 0x24, 0x00, 0xf2, - 0xad, 0x24, 0x00, 0xf3, 0xae, 0x24, 0x00, 0xf4, 0xaf, 0x24, 0x00, 0xf5, - 0xb0, 0x24, 0x00, 0xf6, 0xb1, 0x24, 0x00, 0xf7, 0xb2, 0x24, 0x00, 0xf8, - 0xb3, 0x24, 0x00, 0xf9, 0xb4, 0x24, 0x00, 0xfa, 0xb5, 0x24, 0x40, 0xe1, - 0x10, 0xf1, 0x01, 0xe2, 0x11, 0xf1, 0x01, 0xe3, 0x12, 0xf1, 0x01, 0xe4, - 0x13, 0xf1, 0x01, 0xe5, 0x14, 0xf1, 0x01, 0xe6, 0x15, 0xf1, 0x01, 0xe7, - 0x16, 0xf1, 0x01, 0xe8, 0x17, 0xf1, 0x01, 0xe9, 0x18, 0xf1, 0x01, 0xea, - 0x19, 0xf1, 0x01, 0xeb, 0x1a, 0xf1, 0x01, 0xec, 0x1b, 0xf1, 0x01, 0xed, - 0x1c, 0xf1, 0x01, 0xee, 0x1d, 0xf1, 0x01, 0xef, 0x1e, 0xf1, 0x01, 0xf0, - 0x1f, 0xf1, 0x01, 0xf1, 0x20, 0xf1, 0x01, 0xf2, 0x21, 0xf1, 0x01, 0xf3, - 0x22, 0xf1, 0x01, 0xf4, 0x23, 0xf1, 0x01, 0xf5, 0x24, 0xf1, 0x01, 0xf6, - 0x25, 0xf1, 0x01, 0xf7, 0x26, 0xf1, 0x01, 0xf8, 0x27, 0xf1, 0x01, 0xf9, - 0x28, 0xf1, 0x01, 0xfa, 0x29, 0xf1, 0x41, 0x43, 0x70, 0x11, 0x1e, 0x32, - 0x00, 0x44, 0xcd, 0xf0, 0x1d, 0x32, 0x40, 0x48, 0x61, 0xc3, 0x3f, 0x32, - 0x00, 0xa3, 0xe5, 0x01, 0xa5, 0xd0, 0x01, 0xa6, 0xad, 0x01, 0x44, 0x3d, - 0xf0, 0x32, 0x32, 0x00, 0x45, 0x28, 0xe8, 0x38, 0x32, 0x00, 0xad, 0x92, - 0x01, 0xae, 0x83, 0x01, 0x43, 0x0e, 0x0b, 0x20, 0x32, 0x00, 0x02, 0x88, - 0x00, 0x60, 0xb3, 0x23, 0xb4, 0x0f, 0xb7, 0x01, 0xff, 0x44, 0x8a, 0x00, - 0x2c, 0x32, 0x00, 0x43, 0xcf, 0x2d, 0x2d, 0x32, 0x40, 0x42, 0x92, 0x01, - 0x29, 0x32, 0x00, 0x44, 0x25, 0x01, 0x22, 0x32, 0x00, 0x42, 0x15, 0x02, - 0x21, 0x32, 0x40, 0xa5, 0x2d, 0x42, 0x1c, 0x26, 0x25, 0x32, 0x00, 0x46, - 0xc8, 0xde, 0x33, 0x32, 0x00, 0x46, 0x2e, 0xdf, 0x35, 0x32, 0x00, 0xb4, - 0x0d, 0xb5, 0x01, 0xff, 0xee, 0x30, 0x32, 0x00, 0x47, 0xd2, 0xd4, 0x3c, - 0x32, 0x40, 0x43, 0x35, 0x01, 0x31, 0x32, 0x00, 0x43, 0xcd, 0xf4, 0x3b, - 0x32, 0x40, 0x42, 0x24, 0x00, 0x42, 0x32, 0x00, 0x43, 0xe6, 0x1d, 0x26, - 0x32, 0x40, 0x43, 0xa7, 0x2d, 0x43, 0x32, 0x00, 0x47, 0xa4, 0x80, 0x39, - 0x32, 0x00, 0xb3, 0x01, 0xff, 0x45, 0xc8, 0x5c, 0x3e, 0x32, 0x00, 0xf4, - 0x41, 0x32, 0x40, 0x43, 0x2b, 0x05, 0x34, 0x32, 0x00, 0x43, 0xee, 0x07, - 0x28, 0x32, 0x40, 0x44, 0x94, 0x0f, 0x2e, 0x32, 0x00, 0x43, 0xcd, 0x02, - 0x2a, 0x32, 0x40, 0x47, 0x05, 0xd1, 0x40, 0x32, 0x00, 0xa9, 0x06, 0x43, - 0xf6, 0x06, 0x23, 0x32, 0x40, 0x47, 0x89, 0xd3, 0x36, 0x32, 0x00, 0x42, - 0x88, 0x00, 0x2b, 0x32, 0x00, 0x42, 0x32, 0x00, 0x24, 0x32, 0x40, 0x44, - 0x5a, 0x72, 0x2f, 0x32, 0x00, 0x44, 0xc9, 0x00, 0x27, 0x32, 0x00, 0x49, - 0xc3, 0xbc, 0x3d, 0x32, 0x40, 0x43, 0x5f, 0x07, 0x3a, 0x32, 0x00, 0x4d, - 0x1e, 0x87, 0x37, 0x32, 0x40, 0xa3, 0xa5, 0x01, 0x45, 0x92, 0xa5, 0x0d, - 0x32, 0x80, 0x97, 0x01, 0x45, 0x37, 0xcc, 0x07, 0x32, 0x80, 0x89, 0x01, - 0xab, 0x6d, 0x45, 0xc8, 0xe8, 0x04, 0x32, 0x80, 0x60, 0x45, 0x3b, 0xe9, - 0x01, 0x32, 0x80, 0x53, 0xb0, 0x37, 0x45, 0x85, 0xea, 0x03, 0x32, 0x80, - 0x2a, 0x44, 0x86, 0xbf, 0x06, 0x32, 0x80, 0x1d, 0xb4, 0x01, 0xff, 0x46, - 0x77, 0xd6, 0x0b, 0x32, 0x80, 0x0d, 0x45, 0xfe, 0xcd, 0x02, 0x32, 0xc0, - 0x00, 0x42, 0x19, 0x00, 0x10, 0x32, 0x40, 0x42, 0x19, 0x00, 0x19, 0x32, - 0x40, 0x42, 0x19, 0x00, 0x14, 0x32, 0x40, 0x42, 0x19, 0x00, 0x11, 0x32, - 0x40, 0x46, 0xf3, 0xc2, 0x0c, 0x32, 0x80, 0x0d, 0x44, 0xf8, 0x84, 0x05, - 0x32, 0xc0, 0x00, 0x42, 0x19, 0x00, 0x13, 0x32, 0x40, 0x42, 0x19, 0x00, - 0x1a, 0x32, 0x40, 0x42, 0x19, 0x00, 0x0f, 0x32, 0x40, 0x42, 0x19, 0x00, - 0x12, 0x32, 0x40, 0x46, 0xeb, 0xc2, 0x0a, 0x32, 0x80, 0x0d, 0x45, 0xfe, - 0xa2, 0x00, 0x32, 0xc0, 0x00, 0x42, 0x19, 0x00, 0x0e, 0x32, 0x40, 0x42, - 0x19, 0x00, 0x18, 0x32, 0x40, 0x42, 0x19, 0x00, 0x15, 0x32, 0x40, 0x42, - 0x19, 0x00, 0x1b, 0x32, 0x40, 0x46, 0x03, 0xd0, 0x09, 0x32, 0x80, 0x12, - 0x44, 0x04, 0xd0, 0x08, 0x32, 0xc0, 0x00, 0x80, 0x01, 0xff, 0xe1, 0x16, - 0x32, 0x00, 0xf5, 0x1c, 0x32, 0x40, 0x42, 0x19, 0x00, 0x17, 0x32, 0x40, - 0x45, 0x12, 0x0b, 0x7b, 0x24, 0x00, 0xa6, 0x29, 0x44, 0xea, 0x2a, 0x7c, - 0x24, 0x00, 0x43, 0x0e, 0x0b, 0x74, 0x24, 0x00, 0xb3, 0x0f, 0xb4, 0x01, - 0xff, 0x44, 0x25, 0x01, 0x76, 0x24, 0x00, 0x42, 0x15, 0x02, 0x75, 0x24, - 0x40, 0x44, 0xe5, 0x1d, 0x7a, 0x24, 0x00, 0x42, 0x1c, 0x26, 0x79, 0x24, - 0x40, 0x43, 0xd2, 0x05, 0x78, 0x24, 0x00, 0x43, 0xf6, 0x06, 0x77, 0x24, - 0x40, 0x45, 0x5d, 0xe5, 0x82, 0xfa, 0x01, 0x05, 0x81, 0x10, 0x1c, 0x05, - 0xa7, 0x38, 0x01, 0xff, 0x42, 0x1e, 0x00, 0x25, 0x22, 0x00, 0x05, 0x51, - 0x00, 0x01, 0xff, 0x51, 0x47, 0x05, 0xf2, 0x2a, 0x00, 0x4e, 0x93, 0x3e, - 0xf3, 0x2a, 0x40, 0x4a, 0xd9, 0x20, 0x29, 0x20, 0x00, 0x42, 0xa4, 0x0d, - 0x0f, 0x2e, 0x00, 0x47, 0xed, 0x72, 0x4d, 0x2e, 0x40, 0x45, 0x08, 0xe5, - 0x5e, 0xf9, 0x01, 0x47, 0x48, 0xd0, 0x3c, 0xf4, 0x41, 0x43, 0x49, 0x0e, - 0xb4, 0x26, 0x00, 0xad, 0x01, 0xff, 0x80, 0xe8, 0x01, 0x4d, 0x70, 0x88, - 0x32, 0xf9, 0x01, 0x06, 0xa4, 0xe1, 0x01, 0xff, 0x02, 0x68, 0x00, 0x3a, - 0x07, 0x1a, 0x3a, 0x06, 0x56, 0xf4, 0x36, 0x78, 0x08, 0x41, 0xa6, 0x22, - 0x43, 0x0e, 0x0b, 0x79, 0x08, 0x01, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, - 0x7e, 0x08, 0x01, 0x44, 0x25, 0x01, 0x7b, 0x08, 0x01, 0xb7, 0x01, 0xff, - 0x44, 0xe7, 0x1d, 0x7f, 0x08, 0x01, 0xef, 0x7a, 0x08, 0x41, 0x43, 0xd2, - 0x05, 0x7d, 0x08, 0x01, 0x43, 0xf6, 0x06, 0x7c, 0x08, 0x41, 0x53, 0x98, - 0x49, 0x77, 0x08, 0x01, 0x05, 0xee, 0x05, 0x01, 0xff, 0xa1, 0x85, 0x01, - 0x44, 0x61, 0xef, 0x61, 0x08, 0x01, 0x46, 0x2a, 0x4a, 0x63, 0x08, 0x01, - 0x49, 0x12, 0xb9, 0x6d, 0x08, 0x01, 0x45, 0xfe, 0xaa, 0x62, 0x08, 0x01, - 0x42, 0xb0, 0x01, 0x64, 0x08, 0x81, 0x60, 0x44, 0xed, 0xf0, 0x6a, 0x08, - 0x01, 0x46, 0xb4, 0xdd, 0x6b, 0x08, 0x01, 0x43, 0xb4, 0x05, 0x6c, 0x08, - 0x01, 0x43, 0xde, 0x22, 0x6e, 0x08, 0x01, 0x42, 0x6f, 0x02, 0x71, 0x08, - 0x01, 0x44, 0x6d, 0xc8, 0x73, 0x08, 0x01, 0x44, 0x7d, 0x66, 0x74, 0x08, - 0x01, 0xb3, 0x20, 0xb4, 0x12, 0x43, 0x9f, 0x8a, 0x65, 0x08, 0x01, 0x44, - 0xa8, 0x52, 0x69, 0x08, 0x01, 0x45, 0xa2, 0x52, 0x66, 0x08, 0x41, 0x42, - 0xd2, 0x2d, 0x76, 0x08, 0x01, 0x43, 0xf5, 0x25, 0x68, 0x08, 0x41, 0xa1, - 0x06, 0x43, 0x7a, 0x16, 0x75, 0x08, 0x41, 0x43, 0xcd, 0xea, 0x72, 0x08, - 0x01, 0x44, 0x69, 0xe4, 0x6f, 0x08, 0x41, 0x42, 0x53, 0x00, 0x67, 0x08, - 0x41, 0x44, 0x33, 0x3d, 0x60, 0x08, 0x01, 0x43, 0x9a, 0x1a, 0x70, 0x08, - 0x41, 0x46, 0xf2, 0x2f, 0x19, 0x2e, 0x00, 0x49, 0xe0, 0xb7, 0xf3, 0xfa, - 0x01, 0x44, 0x0d, 0x11, 0x34, 0xf3, 0x01, 0x47, 0xed, 0xd6, 0xf4, 0xfa, - 0x41, 0xa3, 0xcf, 0x04, 0x06, 0xef, 0x06, 0x88, 0x04, 0x09, 0x06, 0xbc, - 0xd4, 0x03, 0x07, 0x1a, 0x3a, 0x9c, 0x03, 0x05, 0x5a, 0x03, 0x93, 0x01, - 0x07, 0x80, 0xd7, 0x01, 0xff, 0xa1, 0x5b, 0xa5, 0x47, 0xa9, 0x33, 0xaf, - 0x1f, 0xb5, 0x0b, 0xb7, 0x01, 0xff, 0xe2, 0x18, 0x6b, 0x01, 0xf6, 0x19, - 0x6b, 0x41, 0xa1, 0x08, 0xe2, 0x06, 0x6b, 0x01, 0xf6, 0x07, 0x6b, 0x41, - 0xe2, 0x10, 0x6b, 0x01, 0xf6, 0x11, 0x6b, 0x41, 0xe2, 0x12, 0x6b, 0x01, - 0xaf, 0x04, 0xf6, 0x13, 0x6b, 0x41, 0xe2, 0x0c, 0x6b, 0x01, 0xf6, 0x0d, - 0x6b, 0x41, 0xa1, 0x08, 0xe2, 0x02, 0x6b, 0x01, 0xf6, 0x03, 0x6b, 0x41, - 0xe2, 0x14, 0x6b, 0x01, 0xf6, 0x15, 0x6b, 0x41, 0xe2, 0x08, 0x6b, 0x01, - 0xa5, 0x04, 0xf6, 0x09, 0x6b, 0x41, 0xe2, 0x00, 0x6b, 0x01, 0xf6, 0x01, - 0x6b, 0x41, 0xa1, 0x27, 0xe2, 0x16, 0x6b, 0x01, 0xa9, 0x19, 0xb5, 0x0f, - 0xf6, 0x17, 0x6b, 0x01, 0xb7, 0x01, 0xff, 0xe2, 0x0e, 0x6b, 0x01, 0xf6, - 0x0f, 0x6b, 0x41, 0xe2, 0x04, 0x6b, 0x01, 0xf6, 0x05, 0x6b, 0x41, 0xe2, - 0x0a, 0x6b, 0x01, 0xf6, 0x0b, 0x6b, 0x41, 0xe2, 0x1a, 0x6b, 0x01, 0xf6, - 0x1b, 0x6b, 0x41, 0x42, 0x2f, 0x08, 0x6c, 0x6b, 0x01, 0x04, 0x0b, 0xbc, - 0xc3, 0x01, 0xa8, 0xb4, 0x01, 0x46, 0xdc, 0xdc, 0x43, 0x6b, 0x01, 0x43, - 0xa3, 0x0d, 0x70, 0x6b, 0x01, 0xad, 0x8f, 0x01, 0xae, 0x80, 0x01, 0xb4, - 0x6c, 0x04, 0x31, 0xf3, 0x39, 0xb8, 0x06, 0x48, 0x29, 0xcd, 0x67, 0x6b, - 0x41, 0x43, 0xc1, 0x2f, 0x44, 0x6b, 0x01, 0x43, 0xbb, 0x4a, 0x6a, 0x6b, - 0x01, 0xb9, 0x01, 0xff, 0x04, 0x1f, 0x21, 0x06, 0x42, 0xcd, 0x02, 0x64, - 0x6b, 0x41, 0x44, 0xd1, 0xef, 0x3f, 0x6b, 0x01, 0x45, 0x68, 0xe9, 0x3c, - 0x6b, 0x01, 0x43, 0xf6, 0x49, 0x3d, 0x6b, 0x01, 0x43, 0x96, 0x09, 0x3e, - 0x6b, 0x41, 0x44, 0xd9, 0xef, 0x3b, 0x6b, 0x01, 0x43, 0x27, 0x4b, 0x63, - 0x6b, 0x01, 0x44, 0xb5, 0xf1, 0x42, 0x6b, 0x01, 0x44, 0xb5, 0xf2, 0x40, - 0x6b, 0x01, 0xb4, 0x01, 0xff, 0xa8, 0x06, 0x49, 0x54, 0xbf, 0x38, 0x6b, - 0x41, 0x43, 0xbb, 0x4a, 0x3a, 0x6b, 0x01, 0x42, 0x14, 0x05, 0x37, 0x6b, - 0x41, 0x42, 0x61, 0x24, 0x6f, 0x6b, 0x01, 0x4e, 0x5c, 0x78, 0x66, 0x6b, - 0x01, 0x4a, 0xe6, 0xb3, 0x6d, 0x6b, 0x41, 0x43, 0xb5, 0xf4, 0x69, 0x6b, - 0x01, 0x43, 0xca, 0xf4, 0x6b, 0x6b, 0x41, 0x04, 0xe8, 0xb3, 0x06, 0x42, - 0xef, 0x02, 0x71, 0x6b, 0x41, 0x44, 0xe1, 0xf2, 0x41, 0x6b, 0x01, 0x45, - 0xa7, 0xeb, 0x6e, 0x6b, 0x41, 0x42, 0xc3, 0x01, 0x65, 0x6b, 0x01, 0x43, - 0x80, 0x31, 0x68, 0x6b, 0x41, 0xa3, 0x28, 0x52, 0x1c, 0x52, 0x72, 0x6b, - 0x01, 0x48, 0x09, 0xc9, 0x77, 0x6b, 0x01, 0x48, 0x19, 0xca, 0x76, 0x6b, - 0x01, 0xb4, 0x01, 0xff, 0x47, 0x0d, 0xd6, 0x45, 0x6b, 0x01, 0x43, 0xf7, - 0xf4, 0x74, 0x6b, 0xc1, 0x00, 0x45, 0xc0, 0xe1, 0x75, 0x6b, 0x41, 0x44, - 0x66, 0x18, 0x39, 0x6b, 0x01, 0x4a, 0x9c, 0xb2, 0x73, 0x6b, 0x41, 0x07, - 0x71, 0x11, 0x25, 0x48, 0x10, 0x3c, 0x5e, 0x6b, 0x01, 0xb4, 0x01, 0xff, - 0x02, 0x92, 0x01, 0x06, 0x48, 0x89, 0xca, 0x61, 0x6b, 0x41, 0x80, 0x04, - 0xf3, 0x5b, 0x6b, 0x41, 0x48, 0x39, 0xc4, 0x60, 0x6b, 0x01, 0x49, 0x02, - 0x7d, 0x5d, 0x6b, 0x41, 0x49, 0x0f, 0x3c, 0x5f, 0x6b, 0x01, 0xf3, 0x5c, - 0x6b, 0x41, 0x43, 0x9d, 0xcb, 0x35, 0x6b, 0x01, 0xab, 0x1b, 0xb3, 0x0f, - 0xb4, 0x01, 0xff, 0x43, 0xc3, 0xb2, 0x36, 0x6b, 0x01, 0x42, 0x3d, 0x01, - 0x30, 0x6b, 0x41, 0xef, 0x31, 0x6b, 0x01, 0x43, 0x9c, 0xb2, 0x34, 0x6b, - 0x41, 0x42, 0xed, 0x00, 0x32, 0x6b, 0x01, 0x43, 0xef, 0x4b, 0x33, 0x6b, - 0x41, 0x45, 0x12, 0x0b, 0x58, 0x6b, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, - 0x59, 0x6b, 0x01, 0x43, 0x0e, 0x0b, 0x51, 0x6b, 0x01, 0xb3, 0x14, 0xb4, - 0x06, 0x44, 0x5f, 0x1e, 0x50, 0x6b, 0x41, 0x44, 0x25, 0x01, 0x53, 0x6b, - 0x01, 0x42, 0x15, 0x02, 0x52, 0x6b, 0x41, 0x44, 0xe5, 0x1d, 0x57, 0x6b, - 0x01, 0x42, 0x1c, 0x26, 0x56, 0x6b, 0x41, 0x43, 0xd2, 0x05, 0x55, 0x6b, - 0x01, 0x43, 0xf6, 0x06, 0x54, 0x6b, 0x41, 0x09, 0x64, 0xbb, 0x86, 0x01, - 0x09, 0x43, 0x33, 0x01, 0xff, 0x42, 0x61, 0x24, 0x2d, 0x6b, 0x01, 0xa3, - 0x6d, 0xa8, 0x59, 0x43, 0x60, 0x24, 0x1e, 0x6b, 0x01, 0x43, 0x2a, 0xe1, - 0x26, 0x6b, 0x01, 0xae, 0x24, 0x45, 0x0d, 0xea, 0x2a, 0x6b, 0x01, 0x44, - 0x55, 0xf2, 0x23, 0x6b, 0x01, 0x43, 0x7b, 0x58, 0x21, 0x6b, 0x01, 0x43, - 0xdc, 0xf4, 0x1c, 0x6b, 0x01, 0x43, 0xf1, 0xf4, 0x2e, 0x6b, 0x01, 0x43, - 0xf8, 0x80, 0x24, 0x6b, 0x41, 0x42, 0x61, 0x24, 0x2c, 0x6b, 0x01, 0x44, - 0x81, 0xef, 0x28, 0x6b, 0x01, 0x43, 0x52, 0xcf, 0x22, 0x6b, 0x01, 0x43, - 0x60, 0x24, 0x20, 0x6b, 0x01, 0xb4, 0x01, 0xff, 0x43, 0xee, 0x7d, 0x2b, - 0x6b, 0x01, 0x43, 0xb6, 0x91, 0x1d, 0x6b, 0x41, 0x42, 0x61, 0x24, 0x1f, - 0x6b, 0x01, 0x43, 0x60, 0x24, 0x25, 0x6b, 0x01, 0x43, 0x78, 0x5c, 0x29, - 0x6b, 0x41, 0x42, 0x61, 0x24, 0x2f, 0x6b, 0x01, 0x43, 0xee, 0x7d, 0x27, - 0x6b, 0x41, 0x43, 0x64, 0xf4, 0x8b, 0x6b, 0x01, 0x02, 0x22, 0x00, 0x6e, - 0xab, 0x5a, 0xac, 0x4c, 0x44, 0x65, 0xf1, 0x84, 0x6b, 0x01, 0x44, 0x31, - 0xf2, 0x87, 0x6b, 0x01, 0xb4, 0x23, 0xb6, 0x15, 0x45, 0xa1, 0xec, 0x81, - 0x6b, 0x01, 0xb9, 0x01, 0xff, 0x42, 0x71, 0x19, 0x8c, 0x6b, 0x01, 0x43, - 0x52, 0xf4, 0x7e, 0x6b, 0x41, 0x42, 0x71, 0x19, 0x8a, 0x6b, 0x01, 0x42, - 0x2a, 0xcd, 0x8f, 0x6b, 0x41, 0x43, 0x73, 0xf4, 0x85, 0x6b, 0x01, 0xb3, - 0x01, 0xff, 0x42, 0x5c, 0x00, 0x86, 0x6b, 0x01, 0x44, 0xe7, 0xb3, 0x7d, - 0x6b, 0x01, 0x42, 0x77, 0x1a, 0x8d, 0x6b, 0x41, 0x43, 0x10, 0xf4, 0x80, - 0x6b, 0x01, 0x42, 0x5f, 0x03, 0x7f, 0x6b, 0x41, 0x43, 0xf3, 0x14, 0x88, - 0x6b, 0x01, 0x42, 0xcd, 0x02, 0x82, 0x6b, 0x01, 0x42, 0x33, 0x5c, 0x8e, - 0x6b, 0x41, 0xed, 0x89, 0x6b, 0x01, 0x42, 0x2a, 0xcd, 0x83, 0x6b, 0x41, - 0xe5, 0xcf, 0xf5, 0x81, 0x06, 0x43, 0xd0, 0x2d, 0xd4, 0xf6, 0x41, 0x80, - 0x08, 0xf2, 0xdf, 0xf4, 0x01, 0xf3, 0xd0, 0xf5, 0x41, 0x49, 0xee, 0xb8, - 0xc4, 0xf4, 0x01, 0x06, 0xca, 0x04, 0x01, 0xff, 0x4b, 0xc5, 0x9d, 0xdf, - 0xf5, 0x01, 0x43, 0x73, 0x0b, 0xc3, 0xf4, 0x41, 0x4e, 0xf0, 0x76, 0x80, - 0x00, 0x40, 0xa2, 0xc2, 0x2e, 0xa3, 0xde, 0x2d, 0x43, 0xef, 0x0a, 0x62, - 0xf3, 0x01, 0x4e, 0xec, 0x77, 0xe2, 0xf3, 0x81, 0xca, 0x2d, 0xa7, 0xfd, - 0x2b, 0x47, 0x3a, 0xc9, 0x26, 0x21, 0x00, 0x47, 0x08, 0xd2, 0xe2, 0xf6, - 0x01, 0x4b, 0x3d, 0x93, 0x4c, 0xf4, 0x01, 0xac, 0xdc, 0x12, 0x48, 0x27, - 0xbd, 0x49, 0xf5, 0x01, 0xae, 0x84, 0x12, 0xb0, 0xd3, 0x10, 0xb2, 0xb7, - 0x0b, 0xb3, 0xfd, 0x05, 0x02, 0xee, 0x05, 0xab, 0x02, 0xb5, 0x46, 0x03, - 0x32, 0x00, 0x10, 0x42, 0x95, 0x03, 0x89, 0xf9, 0x01, 0xf8, 0x02, 0xf4, - 0x01, 0x45, 0xba, 0xec, 0xaa, 0xf9, 0x41, 0x4b, 0xe9, 0x9c, 0x75, 0xf9, - 0x01, 0xac, 0x01, 0xff, 0x42, 0xe5, 0x05, 0xd7, 0xf5, 0x81, 0x06, 0x43, - 0xee, 0x07, 0x3e, 0x20, 0x40, 0x05, 0x46, 0x30, 0x01, 0xff, 0x4d, 0x3c, - 0x58, 0xbc, 0x2b, 0x00, 0x06, 0xad, 0x02, 0x01, 0xff, 0x51, 0x38, 0x58, - 0xbb, 0x2b, 0x00, 0x47, 0x42, 0x58, 0xba, 0x2b, 0x40, 0x48, 0xb1, 0xc8, - 0x25, 0x21, 0x00, 0xb4, 0x01, 0xff, 0x48, 0x71, 0xc4, 0xe4, 0xf4, 0x01, - 0x06, 0x1b, 0x11, 0x01, 0xff, 0x4a, 0x0f, 0x2c, 0x2d, 0x27, 0x00, 0x06, - 0xef, 0x06, 0x82, 0x01, 0x4b, 0x22, 0x61, 0x19, 0x27, 0x00, 0x07, 0xde, - 0x05, 0x06, 0x4a, 0x80, 0x2e, 0x9d, 0x26, 0x40, 0x0e, 0xe5, 0x05, 0x06, - 0x44, 0x96, 0x10, 0x1f, 0x27, 0x40, 0xe1, 0xd6, 0xcc, 0x01, 0xe2, 0xd7, - 0xcc, 0x01, 0xe3, 0xd8, 0xcc, 0x01, 0xe4, 0xd9, 0xcc, 0x01, 0xe5, 0xda, - 0xcc, 0x01, 0xe6, 0xdb, 0xcc, 0x01, 0xe7, 0xdc, 0xcc, 0x01, 0xe8, 0xdd, - 0xcc, 0x01, 0xe9, 0xde, 0xcc, 0x01, 0xea, 0xdf, 0xcc, 0x01, 0xeb, 0xe0, - 0xcc, 0x01, 0xec, 0xe1, 0xcc, 0x01, 0xed, 0xe2, 0xcc, 0x01, 0xee, 0xe3, - 0xcc, 0x01, 0xef, 0xe4, 0xcc, 0x01, 0xf0, 0xe5, 0xcc, 0x01, 0xf1, 0xe6, - 0xcc, 0x01, 0xf2, 0xe7, 0xcc, 0x01, 0xf3, 0xe8, 0xcc, 0x01, 0xf4, 0xe9, - 0xcc, 0x01, 0xf5, 0xea, 0xcc, 0x01, 0xf6, 0xeb, 0xcc, 0x01, 0xf7, 0xec, - 0xcc, 0x01, 0xf8, 0xed, 0xcc, 0x01, 0xf9, 0xee, 0xcc, 0x01, 0xfa, 0xef, - 0xcc, 0x41, 0x45, 0x12, 0x0b, 0xf8, 0xcc, 0x01, 0xa6, 0x2e, 0x44, 0xea, - 0x2a, 0xf9, 0xcc, 0x01, 0x43, 0x0e, 0x0b, 0xf1, 0xcc, 0x01, 0xb3, 0x14, - 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xf0, 0xcc, 0x41, 0x44, 0x25, 0x01, 0xf3, - 0xcc, 0x01, 0x42, 0x15, 0x02, 0xf2, 0xcc, 0x41, 0x44, 0xe5, 0x1d, 0xf7, - 0xcc, 0x01, 0x42, 0x1c, 0x26, 0xf6, 0xcc, 0x41, 0x43, 0xd2, 0x05, 0xf5, - 0xcc, 0x01, 0x43, 0xf6, 0x06, 0xf4, 0xcc, 0x41, 0x42, 0x33, 0x00, 0xa6, - 0xf9, 0x01, 0x0b, 0xd2, 0xa0, 0x01, 0xff, 0x11, 0x05, 0x58, 0xe4, 0x02, - 0x0d, 0x25, 0x5a, 0xd3, 0x02, 0x48, 0x51, 0xc8, 0x2e, 0xed, 0x01, 0x07, - 0x1a, 0x3a, 0x01, 0xff, 0x45, 0x12, 0x0b, 0x08, 0xed, 0x81, 0xa7, 0x02, - 0xa6, 0xd9, 0x01, 0x44, 0xea, 0x2a, 0x09, 0xed, 0x81, 0xb6, 0x01, 0x43, - 0x0e, 0x0b, 0x01, 0xed, 0x81, 0x9f, 0x01, 0xb3, 0x59, 0xb4, 0x01, 0xff, - 0x42, 0x92, 0x01, 0x0a, 0xed, 0x81, 0x49, 0xa8, 0x24, 0xb7, 0x01, 0xff, - 0x44, 0xe7, 0x1d, 0x0b, 0xed, 0x81, 0x14, 0xef, 0x02, 0xed, 0xc1, 0x00, - 0x80, 0x01, 0xff, 0x47, 0x71, 0x11, 0x14, 0xed, 0x01, 0x48, 0x47, 0x5e, - 0x1d, 0xed, 0x41, 0x49, 0x46, 0x5e, 0x26, 0xed, 0x41, 0x44, 0x7b, 0x11, - 0x0c, 0xed, 0x81, 0x16, 0x43, 0x26, 0x01, 0x03, 0xed, 0xc1, 0x00, 0x80, - 0x01, 0xff, 0x47, 0x71, 0x11, 0x15, 0xed, 0x01, 0x48, 0x47, 0x5e, 0x1e, - 0xed, 0x41, 0x49, 0x46, 0x5e, 0x27, 0xed, 0x41, 0x49, 0x46, 0x5e, 0x25, - 0xed, 0x41, 0x44, 0xe5, 0x1d, 0x07, 0xed, 0x81, 0x22, 0x42, 0x1c, 0x26, - 0x06, 0xed, 0xc1, 0x00, 0x80, 0x0d, 0x42, 0x7d, 0x11, 0x0f, 0xed, 0xc1, - 0x00, 0x49, 0x46, 0x5e, 0x2a, 0xed, 0x41, 0x47, 0x71, 0x11, 0x18, 0xed, - 0x01, 0x48, 0x47, 0x5e, 0x21, 0xed, 0x41, 0x80, 0x0d, 0x42, 0x7d, 0x11, - 0x10, 0xed, 0xc1, 0x00, 0x49, 0x46, 0x5e, 0x2b, 0xed, 0x41, 0x47, 0x71, - 0x11, 0x19, 0xed, 0x01, 0x48, 0x47, 0x5e, 0x22, 0xed, 0x41, 0x80, 0x01, - 0xff, 0x47, 0x71, 0x11, 0x13, 0xed, 0x01, 0x48, 0x47, 0x5e, 0x1c, 0xed, - 0x41, 0x80, 0x0d, 0x42, 0x7d, 0x11, 0x12, 0xed, 0xc1, 0x00, 0x49, 0x46, - 0x5e, 0x2d, 0xed, 0x41, 0x47, 0x71, 0x11, 0x1b, 0xed, 0x01, 0x48, 0x47, - 0x5e, 0x24, 0xed, 0x41, 0xa9, 0x26, 0xaf, 0x01, 0xff, 0x43, 0x7c, 0x11, - 0x0d, 0xed, 0x81, 0x16, 0x42, 0x42, 0x00, 0x04, 0xed, 0xc1, 0x00, 0x80, - 0x01, 0xff, 0x47, 0x71, 0x11, 0x16, 0xed, 0x01, 0x48, 0x47, 0x5e, 0x1f, - 0xed, 0x41, 0x49, 0x46, 0x5e, 0x28, 0xed, 0x41, 0x43, 0x59, 0x4d, 0x0e, - 0xed, 0x81, 0x16, 0x42, 0x32, 0x00, 0x05, 0xed, 0xc1, 0x00, 0x80, 0x01, - 0xff, 0x47, 0x71, 0x11, 0x17, 0xed, 0x01, 0x48, 0x47, 0x5e, 0x20, 0xed, - 0x41, 0x49, 0x46, 0x5e, 0x29, 0xed, 0x41, 0x80, 0x0b, 0xf9, 0x11, 0xed, - 0xc1, 0x00, 0x49, 0x46, 0x5e, 0x2c, 0xed, 0x41, 0x47, 0x71, 0x11, 0x1a, - 0xed, 0x01, 0x48, 0x47, 0x5e, 0x23, 0xed, 0x41, 0x44, 0x22, 0x00, 0x3c, - 0xed, 0x01, 0x45, 0x06, 0xe0, 0x3d, 0xed, 0x41, 0x45, 0x12, 0x0b, 0x35, - 0xed, 0x01, 0xa6, 0x3e, 0x44, 0xea, 0x2a, 0x36, 0xed, 0x01, 0xb3, 0x23, - 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x37, 0xed, 0x81, 0x13, 0x44, 0x25, - 0x01, 0x30, 0xed, 0x01, 0x42, 0x15, 0x02, 0x2f, 0xed, 0xc1, 0x00, 0x49, - 0x46, 0x5e, 0x3a, 0xed, 0x41, 0x49, 0x46, 0x5e, 0x3b, 0xed, 0x41, 0x44, - 0xe5, 0x1d, 0x34, 0xed, 0x01, 0x42, 0x1c, 0x26, 0x33, 0xed, 0xc1, 0x00, - 0x48, 0x70, 0x11, 0x39, 0xed, 0x41, 0x43, 0xd2, 0x05, 0x32, 0xed, 0x01, - 0x43, 0xf6, 0x06, 0x31, 0xed, 0xc1, 0x00, 0x48, 0x70, 0x11, 0x38, 0xed, - 0x41, 0x04, 0x29, 0x43, 0x82, 0x02, 0xe3, 0x9d, 0x00, 0x00, 0x06, 0x1a, - 0xde, 0x01, 0xff, 0x06, 0xef, 0x06, 0xb2, 0x01, 0x07, 0xec, 0x05, 0x01, - 0xff, 0xe1, 0x96, 0x04, 0x81, 0x9d, 0x01, 0x42, 0x16, 0x00, 0x81, 0x04, - 0x01, 0x44, 0x7d, 0xef, 0x8b, 0x04, 0x01, 0xa4, 0x82, 0x01, 0xe5, 0x97, - 0x04, 0x81, 0x79, 0x42, 0x0c, 0x08, 0x8d, 0x04, 0x01, 0x42, 0x24, 0x02, - 0x8c, 0x04, 0x01, 0x42, 0x22, 0x00, 0x94, 0x04, 0x01, 0xe9, 0x98, 0x04, - 0x01, 0x42, 0x72, 0x19, 0x83, 0x04, 0x01, 0xab, 0x4f, 0x44, 0x1f, 0xef, - 0x90, 0x04, 0x01, 0x44, 0x55, 0xf1, 0x91, 0x04, 0x01, 0x44, 0xcd, 0xf1, - 0x92, 0x04, 0x01, 0xef, 0x99, 0x04, 0x81, 0x34, 0x44, 0x3a, 0xea, 0x8e, - 0x04, 0x01, 0x42, 0x71, 0x00, 0x87, 0x04, 0x01, 0xb3, 0x1c, 0x42, 0x12, - 0x00, 0x82, 0x04, 0x01, 0xf5, 0x9a, 0x04, 0x01, 0x43, 0x9f, 0x8a, 0x93, - 0x04, 0x01, 0x42, 0x08, 0x27, 0x84, 0x04, 0x01, 0x42, 0xbe, 0x22, 0x95, - 0x04, 0x41, 0xe1, 0x88, 0x04, 0x01, 0x44, 0x65, 0xf0, 0x89, 0x04, 0x41, - 0xef, 0x9d, 0x04, 0x41, 0x43, 0x3b, 0xc3, 0x8f, 0x04, 0x01, 0x42, 0x22, - 0x00, 0x85, 0x04, 0x41, 0xe5, 0x9c, 0x04, 0x41, 0x43, 0x2d, 0x13, 0x86, - 0x04, 0x01, 0x42, 0x22, 0x00, 0x8a, 0x04, 0x41, 0xe1, 0x9b, 0x04, 0x01, - 0x43, 0x68, 0x00, 0x80, 0x04, 0x41, 0x45, 0x12, 0x0b, 0xa8, 0x04, 0x01, - 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0xa9, 0x04, 0x01, 0x43, 0x0e, 0x0b, 0xa1, - 0x04, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xa0, 0x04, 0x41, - 0x44, 0x25, 0x01, 0xa3, 0x04, 0x01, 0x42, 0x15, 0x02, 0xa2, 0x04, 0x41, - 0x44, 0xe5, 0x1d, 0xa7, 0x04, 0x01, 0x42, 0x1c, 0x26, 0xa6, 0x04, 0x41, - 0x43, 0xd2, 0x05, 0xa5, 0x04, 0x01, 0x43, 0xf6, 0x06, 0xa4, 0x04, 0x41, - 0x0f, 0xe4, 0x05, 0xd8, 0x01, 0x0d, 0x76, 0x08, 0x01, 0xff, 0xe1, 0xd8, - 0x04, 0x81, 0xc0, 0x01, 0x43, 0x63, 0x09, 0xdc, 0x04, 0x01, 0x43, 0xe6, - 0x17, 0xdd, 0x04, 0x01, 0x43, 0xee, 0x4b, 0xf5, 0x04, 0x01, 0xe5, 0xdf, - 0x04, 0x81, 0x81, 0x01, 0x43, 0x2f, 0x9c, 0xf9, 0x04, 0x01, 0xa8, 0x6f, - 0xe9, 0xe3, 0x04, 0x01, 0xab, 0x59, 0x42, 0x74, 0x00, 0xe7, 0x04, 0x01, - 0x42, 0x6c, 0x00, 0xe8, 0x04, 0x01, 0x42, 0x2a, 0x05, 0xe9, 0x04, 0x01, - 0xef, 0xea, 0x04, 0x81, 0x3c, 0x42, 0xbb, 0x09, 0xec, 0x04, 0x01, 0xb3, - 0x2a, 0xb4, 0x17, 0xf5, 0xf6, 0x04, 0x01, 0x42, 0xa9, 0x01, 0xf7, 0x04, - 0x01, 0xba, 0x01, 0xff, 0xe1, 0xfa, 0x04, 0x01, 0x42, 0x22, 0x00, 0xfb, - 0x04, 0x41, 0xe1, 0xf0, 0x04, 0x01, 0xb3, 0x01, 0xff, 0xe1, 0xf2, 0x04, - 0x01, 0x42, 0x22, 0x00, 0xf4, 0x04, 0x41, 0xe1, 0xee, 0x04, 0x01, 0x42, - 0x22, 0x00, 0xef, 0x04, 0x41, 0x42, 0x9e, 0x01, 0xeb, 0x04, 0x41, 0xe1, - 0xe4, 0x04, 0x01, 0x42, 0x22, 0x00, 0xf8, 0x04, 0x01, 0x42, 0xbe, 0x22, - 0xe6, 0x04, 0x41, 0xe1, 0xe1, 0x04, 0x01, 0x42, 0xbe, 0x22, 0xe2, 0x04, - 0x41, 0xa8, 0x06, 0x42, 0x9e, 0x01, 0xe0, 0x04, 0x41, 0x43, 0xe6, 0x17, - 0xde, 0x04, 0x01, 0x42, 0x1b, 0x02, 0xe5, 0x04, 0x01, 0x42, 0xbb, 0x09, - 0xed, 0x04, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0xf1, 0x04, 0x01, 0x42, 0x40, - 0x06, 0xf3, 0x04, 0x41, 0xe8, 0xdb, 0x04, 0x01, 0xe9, 0xd9, 0x04, 0xc1, - 0x00, 0xee, 0xda, 0x04, 0x41, 0xe1, 0xb0, 0x04, 0x81, 0xc0, 0x01, 0x43, - 0x63, 0x09, 0xb4, 0x04, 0x01, 0x43, 0xe6, 0x17, 0xb5, 0x04, 0x01, 0x43, - 0xee, 0x4b, 0xcd, 0x04, 0x01, 0xe5, 0xb7, 0x04, 0x81, 0x81, 0x01, 0x43, - 0x2f, 0x9c, 0xd1, 0x04, 0x01, 0xa8, 0x6f, 0xe9, 0xbb, 0x04, 0x01, 0xab, - 0x59, 0x42, 0x74, 0x00, 0xbf, 0x04, 0x01, 0x42, 0x6c, 0x00, 0xc0, 0x04, - 0x01, 0x42, 0x2a, 0x05, 0xc1, 0x04, 0x01, 0xef, 0xc2, 0x04, 0x81, 0x3c, - 0x42, 0xbb, 0x09, 0xc4, 0x04, 0x01, 0xb3, 0x2a, 0xb4, 0x17, 0xf5, 0xce, - 0x04, 0x01, 0x42, 0xa9, 0x01, 0xcf, 0x04, 0x01, 0xba, 0x01, 0xff, 0xe1, - 0xd2, 0x04, 0x01, 0x42, 0x22, 0x00, 0xd3, 0x04, 0x41, 0xe1, 0xc8, 0x04, - 0x01, 0xb3, 0x01, 0xff, 0xe1, 0xca, 0x04, 0x01, 0x42, 0x22, 0x00, 0xcc, - 0x04, 0x41, 0xe1, 0xc6, 0x04, 0x01, 0x42, 0x22, 0x00, 0xc7, 0x04, 0x41, - 0x42, 0x9e, 0x01, 0xc3, 0x04, 0x41, 0xe1, 0xbc, 0x04, 0x01, 0x42, 0x22, - 0x00, 0xd0, 0x04, 0x01, 0x42, 0xbe, 0x22, 0xbe, 0x04, 0x41, 0xe1, 0xb9, - 0x04, 0x01, 0x42, 0xbe, 0x22, 0xba, 0x04, 0x41, 0xa8, 0x06, 0x42, 0x9e, - 0x01, 0xb8, 0x04, 0x41, 0x43, 0xe6, 0x17, 0xb6, 0x04, 0x01, 0x42, 0x1b, - 0x02, 0xbd, 0x04, 0x01, 0x42, 0xbb, 0x09, 0xc5, 0x04, 0x01, 0xb4, 0x01, - 0xff, 0xe1, 0xc9, 0x04, 0x01, 0x42, 0x40, 0x06, 0xcb, 0x04, 0x41, 0xe8, - 0xb3, 0x04, 0x01, 0xe9, 0xb1, 0x04, 0xc1, 0x00, 0xee, 0xb2, 0x04, 0x41, - 0x50, 0xad, 0x60, 0xc7, 0x27, 0x00, 0x03, 0x1c, 0x01, 0xf8, 0x04, 0xa3, - 0xeb, 0x04, 0xa9, 0x21, 0x05, 0xf6, 0x11, 0x11, 0x03, 0x2a, 0x08, 0x01, - 0xff, 0x49, 0xfb, 0xb7, 0x26, 0x26, 0x00, 0x55, 0x8b, 0x21, 0x42, 0xcc, - 0x41, 0x50, 0x9a, 0x24, 0x3e, 0xfd, 0x00, 0x51, 0xd4, 0x21, 0x3f, 0xfd, - 0x40, 0x48, 0xfd, 0x2f, 0xb6, 0x22, 0x00, 0x03, 0xbc, 0x32, 0x01, 0xff, - 0xa1, 0xae, 0x04, 0x06, 0xef, 0x06, 0xe7, 0x03, 0x09, 0x25, 0x5a, 0xb5, - 0x03, 0x46, 0x3c, 0xdd, 0x70, 0x0b, 0x00, 0x07, 0xec, 0x05, 0x79, 0x05, - 0x5a, 0x03, 0x44, 0x0b, 0x55, 0x77, 0x01, 0xff, 0xa1, 0x31, 0xe5, 0x47, - 0x0b, 0x00, 0xe9, 0x3f, 0x0b, 0x80, 0x24, 0xef, 0x4b, 0x0b, 0x00, 0xf5, - 0x41, 0x0b, 0x80, 0x17, 0x08, 0x43, 0xc1, 0x01, 0xff, 0xec, 0x62, 0x0b, - 0x80, 0x09, 0xf2, 0x43, 0x0b, 0xc0, 0x00, 0xf2, 0x44, 0x0b, 0x40, 0xec, - 0x63, 0x0b, 0x40, 0xf5, 0x42, 0x0b, 0x40, 0xe9, 0x40, 0x0b, 0x40, 0xe1, - 0x3e, 0x0b, 0x00, 0xe9, 0x48, 0x0b, 0x00, 0xf5, 0x4c, 0x0b, 0x40, 0xa1, - 0x23, 0x4b, 0xd9, 0x23, 0x01, 0x0b, 0x00, 0x45, 0x5a, 0x3f, 0x3c, 0x0b, - 0x00, 0x48, 0x97, 0x8a, 0x55, 0x0b, 0x00, 0x02, 0x02, 0x00, 0x01, 0xff, - 0x44, 0xe7, 0x23, 0x4d, 0x0b, 0x00, 0x45, 0xf3, 0x4b, 0x03, 0x0b, 0x40, - 0x47, 0x3d, 0x16, 0x02, 0x0b, 0x00, 0x47, 0xc4, 0x88, 0x3d, 0x0b, 0x40, - 0xe1, 0x05, 0x0b, 0x80, 0xa0, 0x02, 0xa2, 0x93, 0x02, 0xa3, 0x86, 0x02, - 0xa4, 0xed, 0x01, 0xe5, 0x0f, 0x0b, 0x00, 0xa7, 0xdc, 0x01, 0x42, 0x22, - 0x00, 0x39, 0x0b, 0x00, 0xe9, 0x07, 0x0b, 0x80, 0xcc, 0x01, 0xaa, 0xbf, - 0x01, 0xab, 0xb2, 0x01, 0xac, 0xa5, 0x01, 0x42, 0x6c, 0x00, 0x2e, 0x0b, - 0x00, 0xae, 0x86, 0x01, 0xef, 0x13, 0x0b, 0x00, 0xb0, 0x76, 0xb2, 0x64, - 0xb3, 0x52, 0xb4, 0x39, 0xf5, 0x09, 0x0b, 0x80, 0x30, 0xb6, 0x13, 0x42, - 0xa9, 0x01, 0x71, 0x0b, 0x00, 0xb9, 0x01, 0xff, 0xe1, 0x2f, 0x0b, 0x00, - 0x42, 0xbe, 0x22, 0x5f, 0x0b, 0x40, 0xe1, 0x35, 0x0b, 0x00, 0x07, 0x44, - 0xc1, 0x01, 0xff, 0xec, 0x0c, 0x0b, 0x80, 0x09, 0xf2, 0x0b, 0x0b, 0xc0, - 0x00, 0xf2, 0x60, 0x0b, 0x40, 0xec, 0x61, 0x0b, 0x40, 0xf5, 0x0a, 0x0b, - 0x40, 0xe1, 0x24, 0x0b, 0x00, 0x42, 0x22, 0x00, 0x25, 0x0b, 0x00, 0xb4, - 0x01, 0xff, 0xe1, 0x1f, 0x0b, 0x00, 0x42, 0x22, 0x00, 0x20, 0x0b, 0x40, - 0xe1, 0x38, 0x0b, 0x00, 0x42, 0x22, 0x00, 0x36, 0x0b, 0x00, 0x42, 0x40, - 0x06, 0x37, 0x0b, 0x40, 0xe1, 0x30, 0x0b, 0x00, 0x42, 0x22, 0x00, 0x5d, - 0x0b, 0x00, 0x42, 0x71, 0x00, 0x5c, 0x0b, 0x40, 0xe1, 0x2a, 0x0b, 0x00, - 0x42, 0x22, 0x00, 0x2b, 0x0b, 0x40, 0xe1, 0x28, 0x0b, 0x00, 0x42, 0x24, - 0x02, 0x19, 0x0b, 0x00, 0x42, 0x2a, 0x05, 0x23, 0x0b, 0x00, 0x42, 0xbe, - 0x22, 0x1e, 0x0b, 0x40, 0xe1, 0x32, 0x0b, 0x00, 0x42, 0x74, 0x00, 0x33, - 0x0b, 0x40, 0xe1, 0x15, 0x0b, 0x00, 0x42, 0x22, 0x00, 0x16, 0x0b, 0x40, - 0xe1, 0x1c, 0x0b, 0x00, 0x42, 0x22, 0x00, 0x1d, 0x0b, 0x40, 0xe9, 0x08, - 0x0b, 0x40, 0xe1, 0x17, 0x0b, 0x00, 0x42, 0x22, 0x00, 0x18, 0x0b, 0x40, - 0xe1, 0x26, 0x0b, 0x00, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x27, 0x0b, 0x40, - 0xe1, 0x21, 0x0b, 0x00, 0x42, 0x22, 0x00, 0x22, 0x0b, 0x40, 0xe1, 0x1a, - 0x0b, 0x00, 0x42, 0x22, 0x00, 0x1b, 0x0b, 0x40, 0xe1, 0x2c, 0x0b, 0x00, - 0x42, 0x22, 0x00, 0x2d, 0x0b, 0x40, 0xe1, 0x06, 0x0b, 0x00, 0xe9, 0x10, - 0x0b, 0x00, 0xf5, 0x14, 0x0b, 0x40, 0x04, 0x0e, 0x0b, 0x11, 0x06, 0x24, - 0x01, 0x01, 0xff, 0x48, 0x2a, 0x01, 0x74, 0x0b, 0x00, 0x4a, 0x34, 0xb1, - 0x77, 0x0b, 0x40, 0x46, 0x12, 0x0b, 0x76, 0x0b, 0x00, 0x44, 0x22, 0x00, - 0x73, 0x0b, 0x00, 0x47, 0x2a, 0x01, 0x72, 0x0b, 0x00, 0x49, 0x1b, 0x26, - 0x75, 0x0b, 0x40, 0x45, 0x12, 0x0b, 0x6e, 0x0b, 0x00, 0xa6, 0x2e, 0x44, - 0xea, 0x2a, 0x6f, 0x0b, 0x00, 0x43, 0x0e, 0x0b, 0x67, 0x0b, 0x00, 0xb3, - 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x66, 0x0b, 0x40, 0x44, 0x25, 0x01, - 0x69, 0x0b, 0x00, 0x42, 0x15, 0x02, 0x68, 0x0b, 0x40, 0x44, 0xe5, 0x1d, - 0x6d, 0x0b, 0x00, 0x42, 0x1c, 0x26, 0x6c, 0x0b, 0x40, 0x43, 0xd2, 0x05, - 0x6b, 0x0b, 0x00, 0x43, 0xf6, 0x06, 0x6a, 0x0b, 0x40, 0x4d, 0xeb, 0x83, - 0x56, 0x0b, 0x00, 0x4d, 0x1f, 0x76, 0x57, 0x0b, 0x40, 0xe1, 0xcd, 0xfa, - 0x01, 0x42, 0xef, 0x02, 0x7f, 0xf7, 0x41, 0x02, 0x60, 0x00, 0x06, 0x44, - 0x11, 0xf3, 0xa7, 0xf9, 0x41, 0x44, 0x65, 0xef, 0xd9, 0xf4, 0x01, 0x45, - 0xae, 0x21, 0xe1, 0xf9, 0x41, 0xa5, 0x24, 0x47, 0xbb, 0xd1, 0xce, 0x26, - 0x00, 0x48, 0x0c, 0x17, 0x0d, 0x26, 0x00, 0x02, 0x35, 0x00, 0x01, 0xff, - 0x48, 0x99, 0xc4, 0xbf, 0xf4, 0x81, 0x06, 0x46, 0xe6, 0xde, 0x25, 0x23, - 0x40, 0x45, 0xde, 0xe1, 0xb8, 0xf5, 0x41, 0xae, 0x06, 0x55, 0xac, 0x3d, - 0x9d, 0x00, 0x40, 0x80, 0x19, 0x8d, 0x01, 0xff, 0x0f, 0xb0, 0x6b, 0x06, - 0x59, 0x94, 0x25, 0xbe, 0x27, 0x40, 0x4d, 0x90, 0x83, 0x8f, 0x23, 0x00, - 0x4d, 0xfc, 0x84, 0x90, 0x23, 0x40, 0x02, 0x5d, 0x00, 0x57, 0x07, 0x73, - 0x02, 0x3b, 0xa6, 0x2d, 0x4a, 0x98, 0x78, 0x50, 0xf4, 0x01, 0x44, 0x34, - 0x01, 0x13, 0xf5, 0x01, 0x0d, 0x8b, 0x85, 0x11, 0x02, 0x6f, 0x00, 0x01, - 0xff, 0x44, 0x9b, 0x12, 0xc3, 0x27, 0x00, 0x46, 0x44, 0x36, 0xc4, 0x27, - 0x40, 0x4c, 0x8c, 0x91, 0xed, 0xf4, 0x01, 0x4b, 0xda, 0xa1, 0xec, 0xf4, - 0x41, 0x4a, 0xd0, 0xab, 0xc2, 0xf4, 0x01, 0x45, 0xd3, 0x65, 0xc1, 0xf5, - 0x41, 0x48, 0x3c, 0x0d, 0x32, 0x27, 0x00, 0x4a, 0x0f, 0x2c, 0x2b, 0x27, - 0x00, 0x45, 0x95, 0x10, 0x1b, 0x27, 0x00, 0x58, 0x89, 0x2b, 0x3c, 0x27, - 0x40, 0x42, 0x55, 0x05, 0xd6, 0xf4, 0x01, 0xf8, 0x23, 0x24, 0x40, 0x72, - 0xa7, 0x00, 0x1b, 0xf5, 0x01, 0x07, 0x25, 0xd0, 0x27, 0xa5, 0x06, 0x43, - 0xb5, 0x00, 0xc5, 0xf9, 0x41, 0x80, 0x06, 0x4f, 0x48, 0x6a, 0x71, 0xfa, - 0x41, 0x4c, 0x18, 0x8d, 0xaf, 0xf5, 0x01, 0x04, 0x03, 0x0c, 0x01, 0xff, - 0x46, 0xb2, 0x7d, 0x24, 0x20, 0x00, 0x59, 0x4f, 0x15, 0x2b, 0x2e, 0x40, - 0x4a, 0x38, 0xa8, 0x98, 0xf6, 0x01, 0x43, 0xb1, 0x27, 0x8d, 0xf6, 0x01, - 0x4b, 0x44, 0x9c, 0xf1, 0xf6, 0x01, 0x4a, 0xc2, 0xaf, 0x94, 0xf6, 0x01, - 0x44, 0x60, 0xcf, 0x96, 0xf6, 0x41, 0x80, 0xf5, 0x14, 0xa4, 0x06, 0x43, - 0xd2, 0x05, 0xd2, 0xfa, 0x41, 0x80, 0x17, 0x03, 0x16, 0x01, 0x01, 0xff, - 0x45, 0x2c, 0xe4, 0xd3, 0xf9, 0x01, 0x43, 0x5d, 0x18, 0x74, 0xf4, 0x01, - 0x45, 0x35, 0x2d, 0x75, 0xf4, 0x41, 0x08, 0xc9, 0xc4, 0xc3, 0x14, 0x0a, - 0x76, 0xab, 0x91, 0x10, 0x07, 0x2b, 0xd2, 0xb2, 0x0e, 0x43, 0x0b, 0x24, - 0xdd, 0xf5, 0x01, 0x0e, 0x2a, 0x7a, 0xca, 0x0c, 0x03, 0x6f, 0x02, 0xa1, - 0x08, 0x02, 0x60, 0x03, 0x98, 0x04, 0x0e, 0x8e, 0x7d, 0xc3, 0x01, 0x07, - 0x33, 0xd7, 0x01, 0xff, 0x0a, 0x48, 0x59, 0x98, 0x01, 0x07, 0xec, 0x05, - 0x22, 0x0c, 0x6d, 0x16, 0x01, 0xff, 0x43, 0x16, 0x00, 0x86, 0x0f, 0x01, - 0x49, 0xd8, 0x46, 0x89, 0x0f, 0x01, 0x04, 0x1f, 0x0a, 0x01, 0xff, 0x44, - 0x8f, 0x1a, 0x87, 0x0f, 0x01, 0x44, 0x23, 0x0a, 0x88, 0x0f, 0x41, 0x45, - 0xd3, 0xad, 0x70, 0x0f, 0x01, 0x44, 0x61, 0xef, 0x71, 0x0f, 0x01, 0x4a, - 0x7c, 0xaa, 0x75, 0x0f, 0x01, 0x4a, 0xfe, 0xaa, 0x72, 0x0f, 0x01, 0x44, - 0xed, 0xf0, 0x77, 0x0f, 0x01, 0xac, 0x46, 0x43, 0xb4, 0x05, 0x79, 0x0f, - 0x01, 0x43, 0xde, 0x22, 0x7a, 0x0f, 0x01, 0x42, 0x6f, 0x02, 0x7c, 0x0f, - 0x01, 0x44, 0x7d, 0x66, 0x7e, 0x0f, 0x01, 0xb3, 0x18, 0x43, 0xc5, 0xc4, - 0x80, 0x0f, 0x01, 0x43, 0x9f, 0x8a, 0x73, 0x0f, 0x01, 0x44, 0xa8, 0x52, - 0x76, 0x0f, 0x01, 0x45, 0xa2, 0x52, 0x74, 0x0f, 0x41, 0xa1, 0x06, 0x43, - 0x7a, 0x16, 0x7f, 0x0f, 0x41, 0x43, 0xcd, 0xea, 0x7d, 0x0f, 0x01, 0x44, - 0x69, 0xe4, 0x7b, 0x0f, 0x41, 0x45, 0x6b, 0xdc, 0x78, 0x0f, 0x01, 0x43, - 0x9a, 0x5a, 0x81, 0x0f, 0x41, 0x04, 0x03, 0x0c, 0x11, 0x09, 0xf1, 0x0b, - 0x01, 0xff, 0x45, 0x5c, 0x00, 0x84, 0x0f, 0x01, 0x45, 0x20, 0x07, 0x85, - 0x0f, 0x41, 0x45, 0x5c, 0x00, 0x82, 0x0f, 0x01, 0x45, 0x20, 0x07, 0x83, - 0x0f, 0x41, 0x07, 0x31, 0xd4, 0x92, 0x01, 0x08, 0xe9, 0xcc, 0x01, 0xff, - 0xe1, 0x01, 0x0c, 0x81, 0x3a, 0xe5, 0x05, 0x0c, 0x81, 0x19, 0xe9, 0x04, - 0x0c, 0x81, 0x10, 0xaf, 0x01, 0xff, 0xe5, 0x08, 0x0c, 0x81, 0x04, 0xf1, - 0x39, 0x0c, 0x41, 0xeb, 0x1d, 0x0c, 0x41, 0xf1, 0x37, 0x0c, 0x41, 0xe3, - 0x33, 0x0c, 0x01, 0xae, 0x0a, 0x42, 0xa4, 0x02, 0x42, 0x0c, 0x01, 0xfa, - 0x15, 0x0c, 0x41, 0xe3, 0x29, 0x0c, 0x01, 0xf4, 0x27, 0x0c, 0x01, 0xf9, - 0x2b, 0x0c, 0x41, 0xe2, 0x0a, 0x0c, 0x01, 0xe4, 0x12, 0x0c, 0x01, 0xe5, - 0x02, 0x0c, 0x81, 0x24, 0xe7, 0x0e, 0x0c, 0x01, 0xec, 0x1f, 0x0c, 0x01, - 0x42, 0x1d, 0x01, 0x2c, 0x0c, 0x01, 0xf1, 0x35, 0x0c, 0x01, 0xf2, 0x3b, - 0x0c, 0x01, 0x42, 0xa4, 0x02, 0x40, 0x0c, 0x01, 0xf4, 0x44, 0x0c, 0x01, - 0xf9, 0x17, 0x0c, 0x41, 0xe2, 0x0c, 0x0c, 0x01, 0xe7, 0x10, 0x0c, 0x01, - 0xeb, 0x1b, 0x0c, 0x01, 0xee, 0x25, 0x0c, 0x81, 0x08, 0xf4, 0x46, 0x0c, - 0x01, 0xf9, 0x19, 0x0c, 0x41, 0xe7, 0x2e, 0x0c, 0x41, 0xe1, 0x00, 0x0c, - 0x81, 0x5d, 0x44, 0x51, 0xef, 0x48, 0x0c, 0x01, 0xa5, 0x27, 0xe9, 0x03, - 0x0c, 0x81, 0x1a, 0xef, 0x06, 0x0c, 0xc1, 0x00, 0xe5, 0x07, 0x0c, 0x81, - 0x0c, 0xf0, 0x30, 0x0c, 0x01, 0xf1, 0x38, 0x0c, 0x01, 0xf4, 0x47, 0x0c, - 0x41, 0xeb, 0x1c, 0x0c, 0x41, 0xe3, 0x31, 0x0c, 0x01, 0xf1, 0x36, 0x0c, - 0x41, 0xe3, 0x32, 0x0c, 0x01, 0x42, 0xb8, 0x04, 0x21, 0x0c, 0x01, 0xed, - 0x22, 0x0c, 0x01, 0xae, 0x0e, 0xf0, 0x2f, 0x0c, 0x01, 0x42, 0xa4, 0x02, - 0x41, 0x0c, 0x01, 0xfa, 0x14, 0x0c, 0x41, 0xe3, 0x28, 0x0c, 0x01, 0xe7, - 0x2d, 0x0c, 0x01, 0xf4, 0x26, 0x0c, 0x01, 0xf9, 0x2a, 0x0c, 0x41, 0xe2, - 0x09, 0x0c, 0x01, 0xe4, 0x11, 0x0c, 0x01, 0xa5, 0x25, 0xe7, 0x0d, 0x0c, - 0x01, 0xec, 0x1e, 0x0c, 0x01, 0xee, 0x23, 0x0c, 0x01, 0xf1, 0x34, 0x0c, - 0x01, 0xf2, 0x3a, 0x0c, 0x01, 0xf3, 0x3d, 0x0c, 0x81, 0x08, 0xf4, 0x43, - 0x0c, 0x01, 0xf9, 0x16, 0x0c, 0x41, 0xe8, 0x3f, 0x0c, 0x41, 0xe2, 0x0b, - 0x0c, 0x01, 0xe4, 0x13, 0x0c, 0x01, 0xe7, 0x0f, 0x0c, 0x01, 0xeb, 0x1a, - 0x0c, 0x01, 0xec, 0x20, 0x0c, 0x01, 0xee, 0x24, 0x0c, 0x01, 0xf2, 0x3c, - 0x0c, 0x01, 0xf3, 0x3e, 0x0c, 0x01, 0xf4, 0x45, 0x0c, 0x01, 0xf9, 0x18, - 0x0c, 0x41, 0x06, 0xe5, 0xd3, 0xea, 0x01, 0x0c, 0xc0, 0x96, 0x01, 0xff, - 0x07, 0xec, 0x05, 0x1b, 0x03, 0x22, 0x38, 0x01, 0xff, 0x04, 0xb7, 0x05, - 0x06, 0x4e, 0x98, 0x77, 0x7f, 0x0a, 0x41, 0x45, 0x57, 0x4d, 0x7e, 0x0a, - 0x01, 0x43, 0x0e, 0x0b, 0x7d, 0x0a, 0x41, 0xa1, 0xb7, 0x01, 0x44, 0x61, - 0xef, 0x68, 0x0a, 0x01, 0xa4, 0x97, 0x01, 0x42, 0x28, 0x1a, 0x70, 0x0a, - 0x01, 0xa7, 0x82, 0x01, 0x42, 0xb0, 0x01, 0x60, 0x0a, 0x81, 0x75, 0xab, - 0x67, 0x46, 0xb4, 0xdd, 0x61, 0x0a, 0x01, 0x43, 0xb4, 0x05, 0x63, 0x0a, - 0x01, 0x43, 0xde, 0x22, 0x6c, 0x0a, 0x01, 0x44, 0x6d, 0xc8, 0x64, 0x0a, - 0x01, 0x44, 0x7d, 0x66, 0x67, 0x0a, 0x01, 0xb3, 0x2f, 0xb4, 0x12, 0x43, - 0x9f, 0x8a, 0x65, 0x0a, 0x01, 0x44, 0xa8, 0x52, 0x7a, 0x0a, 0x01, 0x44, - 0x7d, 0xf3, 0x78, 0x0a, 0x41, 0x42, 0xd2, 0x2d, 0x69, 0x0a, 0x01, 0x43, - 0xf5, 0x25, 0x77, 0x0a, 0x01, 0xa8, 0x01, 0xff, 0x42, 0xd2, 0x2d, 0x7b, - 0x0a, 0x01, 0x43, 0xf5, 0x25, 0x7c, 0x0a, 0x41, 0xa1, 0x06, 0x43, 0x7a, - 0x16, 0x66, 0x0a, 0x41, 0x43, 0xcd, 0xea, 0x6e, 0x0a, 0x01, 0x44, 0x69, - 0xe4, 0x6f, 0x0a, 0x01, 0xf4, 0x6a, 0x0a, 0x41, 0x43, 0x83, 0x10, 0x6b, - 0x0a, 0x01, 0x44, 0x82, 0xaa, 0x6d, 0x0a, 0x41, 0x42, 0x53, 0x00, 0x62, - 0x0a, 0x41, 0x44, 0x41, 0xf0, 0x76, 0x0a, 0x01, 0x44, 0xff, 0xaa, 0x74, - 0x0a, 0x41, 0x45, 0x2b, 0x4a, 0x75, 0x0a, 0x01, 0x02, 0x22, 0x00, 0x01, - 0xff, 0x43, 0xcd, 0xea, 0x73, 0x0a, 0x01, 0x44, 0x2c, 0x4a, 0x79, 0x0a, - 0x41, 0x43, 0x68, 0x00, 0x71, 0x0a, 0x01, 0x42, 0x1f, 0x1d, 0x72, 0x0a, - 0x41, 0x51, 0x25, 0x5a, 0x26, 0x0f, 0x01, 0xac, 0x44, 0x07, 0x1a, 0x3a, - 0x01, 0xff, 0xa6, 0x31, 0x43, 0x0e, 0x0b, 0x1d, 0x0f, 0x81, 0x24, 0xb4, - 0x01, 0xff, 0x42, 0x92, 0x01, 0x22, 0x0f, 0x01, 0xa8, 0x0d, 0xb7, 0x01, - 0xff, 0x44, 0xe7, 0x1d, 0x23, 0x0f, 0x01, 0xef, 0x1e, 0x0f, 0x41, 0x44, - 0x7b, 0x11, 0x24, 0x0f, 0x01, 0x43, 0x26, 0x01, 0x1f, 0x0f, 0x41, 0x48, - 0x70, 0x11, 0x25, 0x0f, 0x41, 0x43, 0xd2, 0x05, 0x21, 0x0f, 0x01, 0x43, - 0xf6, 0x06, 0x20, 0x0f, 0x41, 0x06, 0xed, 0x05, 0x06, 0x53, 0x1d, 0x4a, - 0x27, 0x0f, 0x41, 0xa1, 0xa8, 0x01, 0x44, 0x61, 0xef, 0x02, 0x0f, 0x01, - 0x06, 0x10, 0x2d, 0x65, 0x45, 0xfe, 0xaa, 0x04, 0x0f, 0x01, 0x42, 0xb0, - 0x01, 0x05, 0x0f, 0x81, 0x52, 0x44, 0xed, 0xf0, 0x0b, 0x0f, 0x01, 0x46, - 0xb4, 0xdd, 0x0c, 0x0f, 0x01, 0x43, 0xb4, 0x05, 0x0d, 0x0f, 0x01, 0x43, - 0xde, 0x22, 0x0e, 0x0f, 0x01, 0x42, 0x6f, 0x02, 0x14, 0x0f, 0x01, 0x50, - 0x7d, 0x66, 0x18, 0x0f, 0x01, 0xb3, 0x18, 0x43, 0xc5, 0xc4, 0x1a, 0x0f, - 0x01, 0x43, 0x9f, 0x8a, 0x07, 0x0f, 0x01, 0x44, 0xa8, 0x52, 0x0a, 0x0f, - 0x01, 0x45, 0xa2, 0x52, 0x08, 0x0f, 0x41, 0xa1, 0x06, 0x43, 0x7a, 0x16, - 0x19, 0x0f, 0x41, 0x43, 0xcd, 0xea, 0x15, 0x0f, 0x01, 0x44, 0x69, 0xe4, - 0x11, 0x0f, 0x41, 0x42, 0x53, 0x00, 0x09, 0x0f, 0x41, 0x45, 0xd3, 0xad, - 0x01, 0x0f, 0x01, 0x44, 0x61, 0xef, 0x03, 0x0f, 0x01, 0x42, 0xb0, 0x01, - 0x06, 0x0f, 0x01, 0x43, 0xde, 0x22, 0x0f, 0x0f, 0x81, 0x1a, 0x45, 0xcb, - 0xea, 0x16, 0x0f, 0x81, 0x0d, 0x43, 0xc5, 0xc4, 0x1b, 0x0f, 0xc1, 0x00, - 0x53, 0xd0, 0x47, 0x1c, 0x0f, 0x41, 0x53, 0xd0, 0x47, 0x17, 0x0f, 0x41, - 0x53, 0xd0, 0x47, 0x10, 0x0f, 0x41, 0xac, 0x06, 0x43, 0x9a, 0x1a, 0x12, - 0x0f, 0x41, 0x43, 0x34, 0x3d, 0x00, 0x0f, 0x01, 0x4c, 0xdc, 0x95, 0x13, - 0x0f, 0x41, 0x0b, 0xc3, 0x5b, 0xbb, 0x02, 0xb3, 0x01, 0xff, 0x04, 0x96, - 0x08, 0x0d, 0x4d, 0xf7, 0x86, 0xb3, 0xf5, 0xc1, 0x00, 0x65, 0xbd, 0x07, - 0xb2, 0xce, 0x41, 0x07, 0x1a, 0x3a, 0x80, 0x02, 0x05, 0x5a, 0x03, 0x06, - 0x4c, 0x56, 0x25, 0xd0, 0x03, 0x41, 0xe1, 0xa0, 0x03, 0x81, 0xdd, 0x01, - 0xa2, 0xc9, 0x01, 0x42, 0x37, 0x00, 0xa8, 0x03, 0x01, 0xa4, 0xa6, 0x01, - 0x42, 0x0c, 0x08, 0xb3, 0x03, 0x01, 0xa7, 0x95, 0x01, 0x42, 0x22, 0x00, - 0xc3, 0x03, 0x01, 0xe9, 0xa1, 0x03, 0x01, 0xaa, 0x80, 0x01, 0xab, 0x76, - 0x42, 0x74, 0x00, 0xbe, 0x03, 0x01, 0xad, 0x62, 0xae, 0x58, 0x42, 0xbb, - 0x09, 0xb1, 0x03, 0x01, 0xb2, 0x48, 0xb3, 0x36, 0xb4, 0x26, 0xf5, 0xa2, - 0x03, 0x01, 0xb6, 0x18, 0xb8, 0x0c, 0x42, 0xbe, 0x22, 0xb9, 0x03, 0x01, - 0x42, 0x59, 0x00, 0xc0, 0x03, 0x41, 0xe1, 0xa7, 0x03, 0x01, 0x4b, 0xab, - 0xa2, 0xcb, 0x03, 0x41, 0xe1, 0xba, 0x03, 0x01, 0xe9, 0xbb, 0x03, 0x41, - 0xe1, 0xab, 0x03, 0x01, 0x42, 0x22, 0x00, 0xb0, 0x03, 0x01, 0xf5, 0xac, - 0x03, 0x41, 0xe1, 0xbf, 0x03, 0x01, 0x42, 0x22, 0x00, 0xc1, 0x03, 0x01, - 0x42, 0x40, 0x06, 0xc2, 0x03, 0x41, 0xe1, 0xbc, 0x03, 0x01, 0xf5, 0xbd, - 0x03, 0x41, 0xe1, 0xb4, 0x03, 0x01, 0xf5, 0xb5, 0x03, 0x41, 0xe1, 0xb6, - 0x03, 0x01, 0xe9, 0xb7, 0x03, 0x01, 0xf5, 0xb8, 0x03, 0x41, 0xe1, 0xa3, - 0x03, 0x01, 0xf5, 0xa4, 0x03, 0x41, 0xe1, 0xa9, 0x03, 0x01, 0xe9, 0xaa, - 0x03, 0x41, 0xe1, 0xa5, 0x03, 0x01, 0xf5, 0xa6, 0x03, 0x41, 0xe1, 0xad, - 0x03, 0x81, 0x08, 0xe9, 0xae, 0x03, 0x01, 0xf5, 0xaf, 0x03, 0x41, 0x47, - 0xc9, 0xd1, 0xcc, 0x03, 0xc1, 0x00, 0x42, 0xab, 0xf3, 0xcd, 0x03, 0x41, - 0xe1, 0xb2, 0x03, 0x81, 0x06, 0x46, 0x2c, 0xe1, 0xcf, 0x03, 0x41, 0x42, - 0x24, 0x02, 0xce, 0x03, 0x41, 0x49, 0xaa, 0xc0, 0xc8, 0x03, 0xc1, 0x00, - 0x42, 0xab, 0xf3, 0xc9, 0x03, 0x01, 0x42, 0x22, 0x00, 0xca, 0x03, 0x41, - 0x47, 0x71, 0x11, 0xd5, 0x03, 0x01, 0x43, 0x0e, 0x0b, 0xd1, 0x03, 0x01, - 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0xd3, 0x03, 0x01, 0xb7, 0x01, 0xff, - 0x44, 0xe7, 0x1d, 0xd4, 0x03, 0x01, 0xef, 0xd2, 0x03, 0x41, 0x42, 0x1a, - 0x00, 0x50, 0x03, 0x01, 0x43, 0x22, 0x36, 0x51, 0x03, 0x01, 0x45, 0x44, - 0xe5, 0x64, 0x03, 0x01, 0xa4, 0xba, 0x01, 0xe5, 0x54, 0x03, 0x81, 0xb0, - 0x01, 0x43, 0x41, 0x4b, 0x52, 0x03, 0x01, 0x42, 0x22, 0x00, 0x6c, 0x03, - 0x01, 0xe9, 0x59, 0x03, 0x81, 0x96, 0x01, 0x44, 0x0d, 0xf1, 0x5a, 0x03, - 0x01, 0x43, 0x89, 0x43, 0x5b, 0x03, 0x01, 0x45, 0xaf, 0xe8, 0x5c, 0x03, - 0x01, 0x45, 0x27, 0xe9, 0x5d, 0x03, 0x01, 0xef, 0x69, 0x03, 0x81, 0x75, - 0x44, 0x25, 0xf2, 0x5f, 0x03, 0x01, 0x43, 0xb9, 0x2f, 0x60, 0x03, 0x01, - 0xb3, 0x53, 0xb4, 0x45, 0xf5, 0x63, 0x03, 0x01, 0xb6, 0x33, 0xb9, 0x0f, - 0xba, 0x01, 0xff, 0x43, 0xf3, 0x18, 0x57, 0x03, 0x01, 0x43, 0xb5, 0xdc, - 0x55, 0x03, 0x41, 0xe1, 0x74, 0x03, 0x81, 0x19, 0x42, 0x33, 0x00, 0x6f, - 0x03, 0x81, 0x0a, 0x42, 0x83, 0x0a, 0x67, 0x03, 0x01, 0xf5, 0x73, 0x03, - 0x41, 0xe9, 0x70, 0x03, 0x01, 0xf5, 0x68, 0x03, 0x41, 0xf4, 0x71, 0x03, - 0x41, 0x42, 0x33, 0x00, 0x6e, 0x03, 0x01, 0x43, 0x50, 0xe5, 0x5e, 0x03, - 0x41, 0x42, 0x56, 0x07, 0x62, 0x03, 0x01, 0x43, 0xf7, 0xcf, 0x6d, 0x03, - 0x41, 0xa8, 0x06, 0x42, 0x6d, 0x28, 0x61, 0x03, 0x41, 0x45, 0x4e, 0xe5, - 0x66, 0x03, 0x01, 0x43, 0x50, 0xe5, 0x65, 0x03, 0x41, 0xef, 0x6a, 0x03, - 0x41, 0xe1, 0x75, 0x03, 0x01, 0xe5, 0x72, 0x03, 0x41, 0xe6, 0x6b, 0x03, - 0x41, 0x42, 0x9d, 0x01, 0x53, 0x03, 0x01, 0xba, 0x01, 0xff, 0x43, 0xb5, - 0xdc, 0x56, 0x03, 0x01, 0x43, 0xe7, 0x05, 0x58, 0x03, 0x41, 0x07, 0xec, - 0x05, 0x1a, 0x07, 0x1a, 0x3a, 0x01, 0xff, 0x43, 0x0e, 0x0b, 0x9d, 0x0a, - 0x01, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x9e, 0x0a, 0x01, 0x45, 0x9a, - 0x2c, 0x9f, 0x0a, 0x41, 0xa1, 0xb0, 0x01, 0x43, 0xb8, 0x8c, 0x88, 0x0a, - 0x01, 0x02, 0xf0, 0x10, 0x9d, 0x01, 0x03, 0xaa, 0xd5, 0x8c, 0x01, 0x43, - 0xf7, 0xb8, 0x90, 0x0a, 0x01, 0xa7, 0x78, 0xa8, 0x6a, 0xab, 0x5c, 0x43, - 0xb0, 0x00, 0x81, 0x0a, 0x01, 0x44, 0x1e, 0x21, 0x83, 0x0a, 0x01, 0x44, - 0x00, 0x46, 0x8c, 0x0a, 0x01, 0x43, 0x43, 0x14, 0x84, 0x0a, 0x01, 0x43, - 0x3e, 0x52, 0x87, 0x0a, 0x01, 0x43, 0x7f, 0x14, 0x8e, 0x0a, 0x01, 0xb4, - 0x1b, 0x43, 0x9f, 0x8a, 0x85, 0x0a, 0x01, 0x43, 0x4d, 0x00, 0x9a, 0x0a, - 0x01, 0x02, 0x59, 0x00, 0x01, 0xff, 0xe8, 0x9c, 0x0a, 0x01, 0x42, 0x9e, - 0x01, 0x98, 0x0a, 0x41, 0x42, 0x18, 0x0a, 0x97, 0x0a, 0x01, 0x42, 0x4e, - 0x00, 0x89, 0x0a, 0x01, 0xa8, 0x01, 0xff, 0x42, 0x13, 0x00, 0x99, 0x0a, - 0x01, 0x42, 0x4e, 0x00, 0x9b, 0x0a, 0x41, 0x42, 0x44, 0x14, 0x8b, 0x0a, - 0x01, 0x43, 0x28, 0x21, 0x8d, 0x0a, 0x41, 0x42, 0x18, 0x0a, 0x82, 0x0a, - 0x01, 0x42, 0x4e, 0x00, 0x80, 0x0a, 0x41, 0x43, 0x67, 0x18, 0x94, 0x0a, - 0x01, 0x44, 0x87, 0x9c, 0x96, 0x0a, 0x41, 0xd1, 0x8a, 0x0a, 0x01, 0xd2, - 0x86, 0x0a, 0x01, 0xd3, 0x8f, 0x0a, 0x41, 0xe4, 0x93, 0x0a, 0x01, 0xec, - 0x95, 0x0a, 0x41, 0x42, 0x9e, 0x01, 0x92, 0x0a, 0x01, 0x43, 0x68, 0x00, - 0x91, 0x0a, 0x41, 0x07, 0xec, 0x05, 0x21, 0x08, 0x27, 0x5d, 0x01, 0xff, - 0x02, 0xf3, 0x02, 0x0c, 0x43, 0x0e, 0x0b, 0x20, 0x03, 0x01, 0x43, 0xdb, - 0x06, 0x22, 0x03, 0x41, 0x43, 0x59, 0x4d, 0x23, 0x03, 0x01, 0x42, 0x32, - 0x00, 0x21, 0x03, 0x41, 0xe1, 0x00, 0x03, 0x01, 0x42, 0xb7, 0x05, 0x01, - 0x03, 0x01, 0x43, 0x6d, 0x14, 0x1c, 0x03, 0x01, 0x42, 0x04, 0x00, 0x03, - 0x03, 0x01, 0xe5, 0x04, 0x03, 0x81, 0x6e, 0x42, 0xb0, 0x01, 0x07, 0x03, - 0x01, 0xe9, 0x09, 0x03, 0x81, 0x5f, 0xab, 0x4b, 0x4c, 0xd0, 0x92, 0x2e, - 0x03, 0x01, 0xef, 0x0f, 0x03, 0x01, 0xb0, 0x35, 0xb3, 0x27, 0xb4, 0x1b, - 0xf5, 0x16, 0x03, 0x81, 0x12, 0x42, 0x32, 0x00, 0x05, 0x03, 0x01, 0x42, - 0x4d, 0x00, 0x2d, 0x03, 0x01, 0x42, 0x4b, 0x0a, 0x06, 0x03, 0x41, 0xf5, - 0x1e, 0x03, 0x41, 0xe5, 0x15, 0x03, 0x01, 0x42, 0xb0, 0x01, 0x08, 0x03, - 0x41, 0x42, 0xb0, 0x01, 0x11, 0x03, 0x01, 0x4b, 0x40, 0xa1, 0x2f, 0x03, - 0x41, 0xe5, 0x10, 0x03, 0x01, 0x42, 0xb0, 0x01, 0x18, 0x03, 0x41, 0xe1, - 0x0a, 0x03, 0x01, 0xe5, 0x02, 0x03, 0x01, 0x42, 0xb0, 0x01, 0x19, 0x03, - 0x01, 0xf5, 0x12, 0x03, 0x41, 0xe9, 0x1d, 0x03, 0x41, 0xe6, 0x1a, 0x03, - 0x01, 0x42, 0x6e, 0x00, 0x17, 0x03, 0x01, 0xec, 0x0b, 0x03, 0x01, 0xed, - 0x0c, 0x03, 0x01, 0xee, 0x0d, 0x03, 0x01, 0xf2, 0x13, 0x03, 0x81, 0x0d, - 0xf3, 0x14, 0x03, 0xc1, 0x00, 0xe8, 0x0e, 0x03, 0x01, 0xf3, 0x1f, 0x03, - 0x41, 0xf3, 0x1b, 0x03, 0x41, 0x0f, 0xe4, 0x05, 0xaf, 0x02, 0x07, 0x1a, - 0x3a, 0xfe, 0x01, 0x0d, 0x76, 0x08, 0x01, 0xff, 0xe1, 0xc0, 0x0c, 0x81, - 0xdf, 0x01, 0x47, 0x17, 0xd0, 0xca, 0x0c, 0x01, 0xe5, 0xc9, 0x0c, 0x81, - 0x51, 0xe9, 0xd0, 0x0c, 0x81, 0x48, 0x0b, 0x38, 0xa0, 0x38, 0xef, 0xdb, - 0x0c, 0x81, 0x29, 0x0a, 0xd0, 0xb0, 0x19, 0x48, 0x01, 0xcb, 0xe3, 0x0c, - 0x01, 0xf5, 0xea, 0x0c, 0xc1, 0x00, 0x42, 0xce, 0x25, 0xd5, 0x0c, 0x01, - 0xf3, 0xf2, 0x0c, 0x01, 0xf5, 0xeb, 0x0c, 0x41, 0x42, 0x67, 0x51, 0xde, - 0x0c, 0x01, 0x42, 0xd6, 0x13, 0xed, 0x0c, 0x41, 0x42, 0x27, 0x01, 0xdf, - 0x0c, 0x01, 0xef, 0xdc, 0x0c, 0x41, 0x42, 0x67, 0x51, 0xdd, 0x0c, 0x01, - 0x42, 0xd6, 0x13, 0xec, 0x0c, 0x41, 0xe9, 0xd1, 0x0c, 0x41, 0xe2, 0xc2, - 0x0c, 0x01, 0xe3, 0xc4, 0x0c, 0x81, 0x72, 0xe4, 0xc7, 0x0c, 0x01, 0xe5, - 0xcb, 0x0c, 0x01, 0xe6, 0xcc, 0x0c, 0x01, 0xe7, 0xcd, 0x0c, 0x81, 0x5d, - 0xe8, 0xcf, 0x0c, 0x01, 0xea, 0xd2, 0x0c, 0x01, 0xeb, 0xd3, 0x0c, 0x01, - 0xec, 0xd6, 0x0c, 0x81, 0x48, 0xed, 0xd8, 0x0c, 0x81, 0x3f, 0xee, 0xd9, - 0x0c, 0x81, 0x27, 0xf0, 0xe0, 0x0c, 0x01, 0xf2, 0xe2, 0x0c, 0x01, 0xf3, - 0xe4, 0x0c, 0x81, 0x16, 0xf4, 0xe6, 0x0c, 0x81, 0x0d, 0xf6, 0xee, 0x0c, - 0x01, 0xfa, 0xef, 0x0c, 0xc1, 0x00, 0xf3, 0xf0, 0x0c, 0x41, 0xf9, 0xe8, - 0x0c, 0x41, 0xfa, 0xe5, 0x0c, 0x41, 0xe3, 0xc5, 0x0c, 0x01, 0xf4, 0xe7, - 0x0c, 0x81, 0x04, 0xf9, 0xda, 0x0c, 0x41, 0x4c, 0xe0, 0x8b, 0xf1, 0x0c, - 0x41, 0xf0, 0xe1, 0x0c, 0x41, 0xf9, 0xd7, 0x0c, 0x41, 0xf9, 0xce, 0x0c, - 0x41, 0xe8, 0xe9, 0x0c, 0x01, 0xf3, 0xc6, 0x0c, 0x41, 0xe1, 0xc1, 0x0c, - 0x01, 0xeb, 0xd4, 0x0c, 0x01, 0x42, 0xb6, 0x05, 0xc3, 0x0c, 0x01, 0x42, - 0x1b, 0x00, 0xc8, 0x0c, 0x41, 0x02, 0xf3, 0x02, 0x1c, 0x43, 0x0e, 0x0b, - 0xfa, 0x0c, 0x81, 0x06, 0x43, 0xdb, 0x06, 0xfc, 0x0c, 0x41, 0x80, 0x01, - 0xff, 0x47, 0x71, 0x11, 0xfe, 0x0c, 0x01, 0x48, 0x47, 0x5e, 0xff, 0x0c, - 0x41, 0x43, 0x59, 0x4d, 0xfd, 0x0c, 0x01, 0x42, 0x32, 0x00, 0xfb, 0x0c, - 0x41, 0xe1, 0x80, 0x0c, 0x81, 0xdf, 0x01, 0x47, 0x17, 0xd0, 0x8a, 0x0c, - 0x01, 0xe5, 0x89, 0x0c, 0x81, 0x51, 0xe9, 0x90, 0x0c, 0x81, 0x48, 0x0b, - 0x38, 0xa0, 0x38, 0xef, 0x9b, 0x0c, 0x81, 0x29, 0x0a, 0xd0, 0xb0, 0x19, - 0x48, 0x01, 0xcb, 0xa3, 0x0c, 0x01, 0xf5, 0xaa, 0x0c, 0xc1, 0x00, 0x42, - 0xce, 0x25, 0x95, 0x0c, 0x01, 0xf3, 0xb2, 0x0c, 0x01, 0xf5, 0xab, 0x0c, - 0x41, 0x42, 0x67, 0x51, 0x9e, 0x0c, 0x01, 0x42, 0xd6, 0x13, 0xad, 0x0c, - 0x41, 0x42, 0x27, 0x01, 0x9f, 0x0c, 0x01, 0xef, 0x9c, 0x0c, 0x41, 0x42, - 0x67, 0x51, 0x9d, 0x0c, 0x01, 0x42, 0xd6, 0x13, 0xac, 0x0c, 0x41, 0xe9, - 0x91, 0x0c, 0x41, 0xe2, 0x82, 0x0c, 0x01, 0xe3, 0x84, 0x0c, 0x81, 0x72, - 0xe4, 0x87, 0x0c, 0x01, 0xe5, 0x8b, 0x0c, 0x01, 0xe6, 0x8c, 0x0c, 0x01, - 0xe7, 0x8d, 0x0c, 0x81, 0x5d, 0xe8, 0x8f, 0x0c, 0x01, 0xea, 0x92, 0x0c, - 0x01, 0xeb, 0x93, 0x0c, 0x01, 0xec, 0x96, 0x0c, 0x81, 0x48, 0xed, 0x98, - 0x0c, 0x81, 0x3f, 0xee, 0x99, 0x0c, 0x81, 0x27, 0xf0, 0xa0, 0x0c, 0x01, - 0xf2, 0xa2, 0x0c, 0x01, 0xf3, 0xa4, 0x0c, 0x81, 0x16, 0xf4, 0xa6, 0x0c, - 0x81, 0x0d, 0xf6, 0xae, 0x0c, 0x01, 0xfa, 0xaf, 0x0c, 0xc1, 0x00, 0xf3, - 0xb0, 0x0c, 0x41, 0xf9, 0xa8, 0x0c, 0x41, 0xfa, 0xa5, 0x0c, 0x41, 0xe3, - 0x85, 0x0c, 0x01, 0xf4, 0xa7, 0x0c, 0x81, 0x04, 0xf9, 0x9a, 0x0c, 0x41, - 0x4c, 0xe0, 0x8b, 0xb1, 0x0c, 0x41, 0xf0, 0xa1, 0x0c, 0x41, 0xf9, 0x97, - 0x0c, 0x41, 0xf9, 0x8e, 0x0c, 0x41, 0xe8, 0xa9, 0x0c, 0x01, 0xf3, 0x86, - 0x0c, 0x41, 0xe1, 0x81, 0x0c, 0x01, 0xeb, 0x94, 0x0c, 0x01, 0x42, 0xb6, - 0x05, 0x83, 0x0c, 0x01, 0x42, 0x1b, 0x00, 0x88, 0x0c, 0x41, 0x49, 0xd8, - 0xb9, 0xe2, 0x6f, 0x01, 0x4e, 0x5a, 0x20, 0xe3, 0x6f, 0x41, 0x06, 0xae, - 0xda, 0xf5, 0x01, 0x05, 0x50, 0x16, 0x01, 0xff, 0x51, 0xe3, 0x57, 0xff, - 0xe5, 0x01, 0x06, 0xef, 0x06, 0xa3, 0x01, 0x07, 0xec, 0x05, 0x17, 0x05, - 0x5a, 0x03, 0x01, 0xff, 0x47, 0xc2, 0xd1, 0xf0, 0xe5, 0x01, 0x44, 0xa9, - 0xf0, 0xef, 0xe5, 0x01, 0x42, 0xc3, 0x16, 0xee, 0xe5, 0x41, 0xe1, 0xd6, - 0xe5, 0x81, 0x6f, 0xe5, 0xe8, 0xe5, 0x81, 0x54, 0xe9, 0xdc, 0xe5, 0x81, - 0x3a, 0xef, 0xd0, 0xe5, 0x81, 0x1d, 0xf5, 0xe2, 0xe5, 0xc1, 0x00, 0x42, - 0x7f, 0x02, 0xe4, 0xe5, 0x01, 0xea, 0xe5, 0xe5, 0x01, 0xeb, 0xe3, 0xe5, - 0x01, 0x42, 0x99, 0x1a, 0xe6, 0xe5, 0x01, 0xf2, 0xe7, 0xe5, 0x41, 0xed, - 0xd1, 0xe5, 0x01, 0x42, 0x1d, 0x01, 0xd2, 0xe5, 0x01, 0xef, 0xd4, 0xe5, - 0x01, 0x42, 0xcf, 0x00, 0xd3, 0xe5, 0x01, 0xf9, 0xd5, 0xe5, 0x41, 0xe4, - 0xe0, 0xe5, 0x01, 0xee, 0xe1, 0xe5, 0x01, 0xf0, 0xde, 0xe5, 0x01, 0xf4, - 0xdd, 0xe5, 0xc1, 0x00, 0xf4, 0xdf, 0xe5, 0x41, 0xe3, 0xeb, 0xe5, 0x01, - 0xe7, 0xed, 0xe5, 0x01, 0xe8, 0xea, 0xe5, 0x01, 0x42, 0x4a, 0x24, 0xec, - 0xe5, 0x01, 0xf3, 0xe9, 0xe5, 0x41, 0xe2, 0xd8, 0xe5, 0x01, 0xe4, 0xd7, - 0xe5, 0x01, 0xe8, 0xd9, 0xe5, 0x01, 0xec, 0xda, 0xe5, 0x01, 0xf7, 0xdb, - 0xe5, 0x41, 0x45, 0x12, 0x0b, 0xf9, 0xe5, 0x01, 0xa6, 0x2e, 0x44, 0xea, - 0x2a, 0xfa, 0xe5, 0x01, 0x43, 0x0e, 0x0b, 0xf2, 0xe5, 0x01, 0xb3, 0x14, - 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xf1, 0xe5, 0x41, 0x44, 0x25, 0x01, 0xf4, - 0xe5, 0x01, 0x42, 0x15, 0x02, 0xf3, 0xe5, 0x41, 0x44, 0xe5, 0x1d, 0xf8, - 0xe5, 0x01, 0x42, 0x1c, 0x26, 0xf7, 0xe5, 0x41, 0x43, 0xd2, 0x05, 0xf6, - 0xe5, 0x01, 0x43, 0xf6, 0x06, 0xf5, 0xe5, 0x41, 0x44, 0x05, 0xef, 0x7d, - 0x1c, 0x00, 0x06, 0xef, 0x06, 0xcd, 0x01, 0x50, 0xa0, 0x57, 0x79, 0x1c, - 0x00, 0x07, 0xec, 0x05, 0x2f, 0x02, 0xc3, 0x16, 0x1f, 0xb0, 0x06, 0x45, - 0x71, 0xea, 0x7b, 0x1c, 0x40, 0x47, 0x83, 0xd1, 0x7c, 0x1c, 0x00, 0x0b, - 0x6e, 0x16, 0x01, 0xff, 0x4d, 0x3e, 0x82, 0x7f, 0x1c, 0x00, 0x46, 0x45, - 0x82, 0x7e, 0x1c, 0x40, 0x48, 0xc1, 0xc2, 0x78, 0x1c, 0x00, 0x51, 0x9f, - 0x57, 0x7a, 0x1c, 0x40, 0xa1, 0x6e, 0xa5, 0x58, 0xa9, 0x44, 0xac, 0x29, - 0xaf, 0x15, 0xb5, 0x01, 0xff, 0xe3, 0x6a, 0x1c, 0x00, 0xe4, 0x6b, 0x1c, - 0x00, 0x42, 0x4a, 0x24, 0x6c, 0x1c, 0x00, 0xf9, 0x6d, 0x1c, 0x40, 0xe2, - 0x75, 0x1c, 0x00, 0xe8, 0x77, 0x1c, 0x00, 0x42, 0xee, 0x05, 0x74, 0x1c, - 0x00, 0xf6, 0x76, 0x1c, 0x40, 0xe1, 0x5a, 0x1c, 0x80, 0x10, 0xe5, 0x6e, - 0x1c, 0x00, 0xe9, 0x64, 0x1c, 0x00, 0xef, 0x73, 0x1c, 0x00, 0xf5, 0x69, - 0x1c, 0x40, 0xe1, 0x5f, 0x1c, 0x40, 0xe8, 0x66, 0x1c, 0x00, 0x42, 0x99, - 0x1a, 0x67, 0x1c, 0x00, 0xf2, 0x68, 0x1c, 0x00, 0xf3, 0x65, 0x1c, 0x40, - 0x42, 0x7f, 0x02, 0x70, 0x1c, 0x00, 0xee, 0x71, 0x1c, 0x00, 0xf0, 0x6f, - 0x1c, 0x00, 0x42, 0xcf, 0x00, 0x72, 0x1c, 0x40, 0xa1, 0x12, 0xe7, 0x5c, - 0x1c, 0x00, 0xec, 0x5e, 0x1c, 0x00, 0x42, 0x1d, 0x01, 0x5d, 0x1c, 0x00, - 0xf4, 0x5b, 0x1c, 0x40, 0xea, 0x61, 0x1c, 0x00, 0xeb, 0x60, 0x1c, 0x00, - 0xed, 0x62, 0x1c, 0x00, 0xf7, 0x63, 0x1c, 0x40, 0x45, 0x12, 0x0b, 0x58, - 0x1c, 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x59, 0x1c, 0x00, 0x43, 0x0e, - 0x0b, 0x51, 0x1c, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x50, - 0x1c, 0x40, 0x44, 0x25, 0x01, 0x53, 0x1c, 0x00, 0x42, 0x15, 0x02, 0x52, - 0x1c, 0x40, 0x44, 0xe5, 0x1d, 0x57, 0x1c, 0x00, 0x42, 0x1c, 0x26, 0x56, - 0x1c, 0x40, 0x43, 0xd2, 0x05, 0x55, 0x1c, 0x00, 0x43, 0xf6, 0x06, 0x54, - 0x1c, 0x40, 0x04, 0xaa, 0x83, 0x06, 0x44, 0xdc, 0xde, 0xdb, 0x02, 0x40, - 0x4c, 0xdf, 0x3d, 0x9b, 0x16, 0x00, 0x07, 0xec, 0x05, 0x0c, 0x55, 0xd6, - 0x3d, 0x9c, 0x16, 0x00, 0x4a, 0x48, 0xb1, 0x80, 0x16, 0x40, 0x44, 0x09, - 0xef, 0x90, 0x16, 0x00, 0x45, 0xd6, 0xe4, 0x81, 0x16, 0x00, 0xa3, 0x8f, - 0x01, 0x44, 0x99, 0xef, 0x87, 0x16, 0x00, 0x02, 0x89, 0x00, 0x73, 0x45, - 0x7f, 0xe6, 0x83, 0x16, 0x00, 0x44, 0x2d, 0xf0, 0x8c, 0x16, 0x00, 0xa9, - 0x59, 0x44, 0x39, 0xf1, 0x82, 0x16, 0x00, 0x44, 0x69, 0xf1, 0x8b, 0x16, - 0x00, 0xae, 0x3f, 0xaf, 0x33, 0x45, 0xef, 0xe9, 0x9a, 0x16, 0x00, 0x44, - 0x99, 0xf2, 0x8f, 0x16, 0x00, 0xb3, 0x19, 0x45, 0x66, 0xeb, 0x88, 0x16, - 0x00, 0xb5, 0x01, 0xff, 0x43, 0x74, 0x0f, 0x86, 0x16, 0x00, 0x47, 0x0f, - 0xd2, 0x97, 0x16, 0x00, 0xf2, 0x92, 0x16, 0x40, 0x43, 0x90, 0x17, 0x84, - 0x16, 0x00, 0x45, 0x98, 0xeb, 0x8e, 0x16, 0x40, 0x42, 0x4a, 0x24, 0x91, - 0x16, 0x00, 0xf2, 0x96, 0x16, 0x40, 0x46, 0x0a, 0xdc, 0x8d, 0x16, 0x00, - 0x43, 0xb5, 0x00, 0x85, 0x16, 0x40, 0x43, 0xd8, 0x09, 0x98, 0x16, 0x00, - 0x46, 0xce, 0xde, 0x94, 0x16, 0x40, 0x45, 0xe0, 0xe4, 0x95, 0x16, 0x00, - 0x45, 0xcf, 0xde, 0x93, 0x16, 0x00, 0x49, 0x2a, 0xbc, 0x99, 0x16, 0x40, - 0x44, 0xc5, 0xef, 0x8a, 0x16, 0x00, 0x43, 0xe8, 0x20, 0x89, 0x16, 0x40, - 0x47, 0x15, 0x08, 0xbb, 0xce, 0x41, 0x49, 0xb3, 0xb7, 0x75, 0xf7, 0x01, - 0x02, 0x18, 0x00, 0x0f, 0xb4, 0x01, 0xff, 0x4b, 0x16, 0x99, 0xd1, 0xf6, - 0x01, 0x44, 0x05, 0xf2, 0x19, 0xf4, 0x41, 0x4f, 0xcf, 0x6a, 0x47, 0x24, - 0x00, 0xa2, 0x2e, 0xa3, 0x20, 0xa4, 0x12, 0x44, 0xc2, 0x51, 0x42, 0x24, - 0x00, 0x44, 0xac, 0x0e, 0x40, 0x24, 0x00, 0x4d, 0x60, 0x84, 0x43, 0x24, - 0x40, 0x43, 0xf9, 0x03, 0x48, 0x24, 0x00, 0x4f, 0x8c, 0x71, 0x4a, 0x24, - 0x40, 0x44, 0x21, 0x6f, 0x41, 0x24, 0x00, 0x56, 0x12, 0x38, 0x49, 0x24, - 0x40, 0x4a, 0x04, 0xaa, 0x44, 0x24, 0x00, 0x46, 0x16, 0xdf, 0x45, 0x24, - 0x00, 0x59, 0xc6, 0x25, 0x46, 0x24, 0x40, 0x5a, 0x82, 0x20, 0xfc, 0xff, - 0x00, 0x06, 0x57, 0x43, 0x06, 0x51, 0xdd, 0x5d, 0xff, 0x23, 0x40, 0x0e, - 0x02, 0x76, 0x06, 0x46, 0x9d, 0x63, 0x5d, 0x2e, 0x40, 0x44, 0xa5, 0x01, - 0xa7, 0x29, 0x00, 0x42, 0x50, 0x02, 0xa6, 0x29, 0x40, 0x05, 0x70, 0x70, - 0xfc, 0x24, 0xa1, 0xa5, 0x1d, 0xa2, 0x98, 0x1d, 0xa5, 0xaf, 0x0d, 0xa9, - 0x97, 0x0d, 0x03, 0x8b, 0xd7, 0xfa, 0x09, 0xec, 0x0a, 0x00, 0x00, 0x44, - 0x85, 0xf1, 0x2f, 0x20, 0x00, 0xaf, 0xc3, 0x04, 0x4d, 0x93, 0x87, 0x10, - 0xcc, 0x01, 0xb5, 0xb6, 0x03, 0x16, 0x80, 0x38, 0x01, 0xff, 0x4a, 0xce, - 0xa8, 0x4f, 0xe1, 0x01, 0x06, 0xef, 0x06, 0xe4, 0x02, 0xac, 0x55, 0xb3, - 0x21, 0x05, 0x06, 0x32, 0x01, 0xff, 0xe2, 0x30, 0xe1, 0x01, 0xe4, 0x36, - 0xe1, 0x01, 0xe7, 0x35, 0xe1, 0x01, 0xea, 0x32, 0xe1, 0x01, 0xed, 0x31, - 0xe1, 0x01, 0xf3, 0x34, 0xe1, 0x01, 0xf6, 0x33, 0xe1, 0x41, 0x04, 0x5b, - 0x03, 0x06, 0x52, 0xd2, 0x56, 0x3d, 0xe1, 0x41, 0x04, 0x5e, 0x1b, 0x06, - 0x45, 0x9c, 0xec, 0x3c, 0xe1, 0x41, 0x46, 0xdc, 0xd9, 0x3a, 0xe1, 0x01, - 0x4c, 0x6c, 0x90, 0x3b, 0xe1, 0x01, 0x48, 0x3d, 0x85, 0x39, 0xe1, 0x01, - 0x46, 0x3a, 0x1d, 0x37, 0xe1, 0x01, 0x45, 0x5c, 0xeb, 0x38, 0xe1, 0x41, - 0x06, 0xed, 0x05, 0x06, 0x4c, 0x0c, 0x93, 0x4e, 0xe1, 0x41, 0xe1, 0x24, - 0xe1, 0x81, 0xf9, 0x01, 0x42, 0x37, 0x00, 0x08, 0xe1, 0x01, 0xa4, 0xe6, - 0x01, 0xe5, 0x2a, 0xe1, 0x81, 0xdc, 0x01, 0x42, 0x0c, 0x08, 0x15, 0xe1, - 0x01, 0x42, 0x24, 0x02, 0x22, 0xe1, 0x01, 0x42, 0x22, 0x00, 0x04, 0xe1, - 0x81, 0xc4, 0x01, 0xe9, 0x26, 0xe1, 0x01, 0x42, 0x1b, 0x02, 0x0e, 0xe1, - 0x01, 0x42, 0x74, 0x00, 0x09, 0xe1, 0x01, 0xad, 0xa7, 0x01, 0xae, 0x65, - 0xef, 0x28, 0xe1, 0x81, 0x5c, 0xb0, 0x50, 0x42, 0x43, 0x14, 0x17, 0xe1, - 0x01, 0xb2, 0x3e, 0x42, 0x40, 0x06, 0x0a, 0xe1, 0x01, 0xb4, 0x26, 0xf5, - 0x27, 0xe1, 0x01, 0x42, 0xf5, 0x0a, 0x12, 0xe1, 0x01, 0xf7, 0x2c, 0xe1, - 0x01, 0xb8, 0x0c, 0x42, 0xbe, 0x22, 0x18, 0xe1, 0x01, 0x42, 0x59, 0x00, - 0x0b, 0xe1, 0x41, 0xe1, 0x06, 0xe1, 0x01, 0x42, 0xbe, 0x22, 0x1b, 0xe1, - 0x41, 0xe1, 0x03, 0xe1, 0x01, 0x42, 0x40, 0x06, 0x01, 0xe1, 0x01, 0x42, - 0x08, 0x27, 0x14, 0xe1, 0x41, 0xe1, 0x16, 0xe1, 0x01, 0x42, 0x71, 0x00, - 0x23, 0xe1, 0x41, 0xe1, 0x1a, 0xe1, 0x01, 0x42, 0x74, 0x00, 0x21, 0xe1, - 0x41, 0xef, 0x29, 0xe1, 0x41, 0xe1, 0x05, 0xe1, 0x01, 0x42, 0x37, 0x00, - 0x0c, 0xe1, 0x01, 0x42, 0x1b, 0x02, 0x07, 0xe1, 0x01, 0xb0, 0x24, 0x42, - 0x43, 0x14, 0x19, 0xe1, 0x01, 0x42, 0x71, 0x00, 0x11, 0xe1, 0x01, 0xb4, - 0x06, 0x42, 0xbe, 0x22, 0x10, 0xe1, 0x41, 0xe1, 0x02, 0xe1, 0x01, 0x42, - 0x40, 0x06, 0x0d, 0xe1, 0x01, 0x42, 0x08, 0x27, 0x13, 0xe1, 0x41, 0xe1, - 0x1c, 0xe1, 0x01, 0x42, 0x74, 0x00, 0x1e, 0xe1, 0x41, 0xe1, 0x00, 0xe1, - 0x01, 0x42, 0x74, 0x00, 0x20, 0xe1, 0x41, 0xe8, 0x1f, 0xe1, 0x41, 0xe5, - 0x2b, 0xe1, 0x41, 0xe1, 0x0f, 0xe1, 0x01, 0x42, 0x74, 0x00, 0x1d, 0xe1, - 0x41, 0xe1, 0x25, 0xe1, 0x41, 0x45, 0x12, 0x0b, 0x48, 0xe1, 0x01, 0xa6, - 0x2e, 0x44, 0xea, 0x2a, 0x49, 0xe1, 0x01, 0x43, 0x0e, 0x0b, 0x41, 0xe1, - 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x40, 0xe1, 0x41, 0x44, - 0x25, 0x01, 0x43, 0xe1, 0x01, 0x42, 0x15, 0x02, 0x42, 0xe1, 0x41, 0x44, - 0xe5, 0x1d, 0x47, 0xe1, 0x01, 0x42, 0x1c, 0x26, 0x46, 0xe1, 0x41, 0x43, - 0xd2, 0x05, 0x45, 0xe1, 0x01, 0x43, 0xf6, 0x06, 0x44, 0xe1, 0x41, 0xec, - 0x00, 0x00, 0x80, 0x7b, 0xad, 0x16, 0x04, 0x7f, 0x4f, 0x06, 0x4a, 0xac, - 0xb1, 0x29, 0xf5, 0x41, 0x4a, 0xba, 0xa8, 0x05, 0xd8, 0x00, 0x4e, 0x5a, - 0x20, 0xe1, 0x6f, 0x41, 0x04, 0xb7, 0x05, 0x06, 0x48, 0xf8, 0xc1, 0x16, - 0x21, 0x40, 0xa5, 0x4b, 0xa6, 0x3d, 0x52, 0xcc, 0x53, 0x9a, 0x24, 0x00, - 0xb3, 0x20, 0xb4, 0x01, 0xff, 0x4c, 0x92, 0x51, 0x91, 0x24, 0x00, 0x51, - 0x9c, 0x5a, 0x94, 0x24, 0x00, 0x02, 0x15, 0x01, 0x01, 0xff, 0x4d, 0x71, - 0x85, 0x93, 0x24, 0x00, 0x4d, 0x9c, 0x86, 0x9b, 0x24, 0x40, 0x52, 0x8c, - 0x51, 0x98, 0x24, 0x00, 0xa9, 0x01, 0xff, 0x42, 0x5c, 0x03, 0x23, 0x00, - 0x00, 0x4f, 0x01, 0x75, 0x97, 0x24, 0x40, 0x50, 0xbd, 0x63, 0x96, 0x24, - 0x00, 0x51, 0x11, 0x5d, 0x95, 0x24, 0x40, 0x51, 0x02, 0x5b, 0x99, 0x24, - 0x00, 0x4f, 0xbb, 0x6f, 0x92, 0x24, 0x40, 0xec, 0x00, 0x00, 0x40, 0x80, - 0xec, 0x04, 0x4c, 0xd0, 0x4c, 0xa0, 0x00, 0x00, 0x02, 0x7d, 0x02, 0xd5, - 0x04, 0xae, 0xbe, 0x04, 0xf2, 0xbd, 0x22, 0x80, 0xd8, 0x01, 0x42, 0x46, - 0x03, 0x43, 0xf4, 0x81, 0xca, 0x01, 0xb4, 0x01, 0xff, 0x80, 0x3e, 0x05, - 0xdf, 0x92, 0x20, 0xe5, 0xc8, 0xf5, 0xc1, 0x00, 0x03, 0xee, 0x0e, 0x0d, - 0x44, 0x65, 0xef, 0xd3, 0xf4, 0xc1, 0x00, 0x56, 0x92, 0x32, 0xd4, 0xf4, - 0x41, 0xe4, 0xca, 0xf5, 0x01, 0x42, 0xdb, 0x09, 0xc9, 0xf5, 0x41, 0xac, - 0x0c, 0x60, 0x14, 0x10, 0x44, 0xf5, 0x01, 0x6b, 0x98, 0x02, 0xb1, 0x27, - 0x40, 0x5e, 0xf9, 0x12, 0x43, 0xf5, 0x01, 0x6a, 0xc0, 0x03, 0xaf, 0x27, - 0x40, 0xa1, 0x63, 0x4a, 0xc4, 0xa8, 0x7b, 0x23, 0x00, 0x03, 0x7b, 0x00, - 0x4d, 0x4c, 0x87, 0x00, 0x6f, 0x22, 0x00, 0x4c, 0xe8, 0x8f, 0x62, 0x22, - 0x00, 0x49, 0xec, 0x00, 0x6e, 0x22, 0x00, 0x52, 0xf0, 0x53, 0xea, 0x22, - 0x80, 0x2e, 0x4b, 0xe2, 0x6a, 0x26, 0x22, 0x00, 0xb3, 0x0f, 0xb4, 0x01, - 0xff, 0x44, 0x38, 0x23, 0x41, 0x22, 0x00, 0x43, 0x8b, 0x3b, 0xad, 0x22, - 0x40, 0x43, 0x5b, 0x03, 0xac, 0x00, 0x00, 0x06, 0xd7, 0x24, 0x01, 0xff, - 0x54, 0x27, 0x43, 0xe2, 0x22, 0x00, 0x57, 0xfa, 0x2f, 0xe3, 0x22, 0x40, - 0x4c, 0x0d, 0x29, 0xec, 0x22, 0x40, 0x45, 0xfb, 0x0c, 0x60, 0x22, 0x00, - 0x4a, 0xf1, 0x39, 0x6d, 0x22, 0x40, 0x03, 0x6e, 0x06, 0x12, 0x4e, 0xb2, - 0x6a, 0x49, 0x22, 0x00, 0x4c, 0x64, 0x92, 0x09, 0x22, 0x00, 0x56, 0x78, - 0x37, 0x44, 0x22, 0x40, 0x47, 0xf7, 0x40, 0x84, 0x22, 0x00, 0x49, 0x44, - 0x36, 0x85, 0x22, 0x40, 0x47, 0x15, 0x08, 0xfc, 0xcc, 0x41, 0x4d, 0x0a, - 0x82, 0xbb, 0x20, 0x00, 0x4f, 0xf3, 0x53, 0xb2, 0x22, 0x80, 0xcc, 0x02, - 0x02, 0x53, 0x00, 0x01, 0xff, 0x80, 0x06, 0x56, 0x1e, 0x34, 0xea, 0xf6, - 0x41, 0x05, 0xaf, 0x23, 0xcb, 0x01, 0x06, 0xe9, 0x06, 0x7a, 0x05, 0xda, - 0x1a, 0x01, 0xff, 0xa1, 0x3b, 0x4b, 0xc6, 0x99, 0x09, 0x2b, 0x00, 0x4c, - 0x44, 0x8e, 0xd6, 0x21, 0x00, 0x09, 0x9c, 0x01, 0x19, 0x50, 0xed, 0x66, - 0x54, 0xf8, 0x01, 0x55, 0x01, 0x02, 0x66, 0x2b, 0x80, 0x06, 0x4b, 0x49, - 0x10, 0x01, 0x2b, 0x40, 0x47, 0xd0, 0x14, 0x76, 0x2b, 0x40, 0x43, 0x93, - 0xd0, 0x60, 0xf6, 0x01, 0x44, 0x40, 0x51, 0x50, 0xf6, 0x01, 0x49, 0x31, - 0xc1, 0x58, 0xf6, 0x41, 0x53, 0x94, 0x40, 0x21, 0x29, 0x00, 0x44, 0xcf, - 0x00, 0x96, 0x21, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x54, 0x6b, 0x40, 0x27, - 0x29, 0x00, 0x59, 0xa0, 0x23, 0x32, 0x29, 0x00, 0x48, 0x78, 0xb4, 0xb8, - 0xf8, 0x01, 0x03, 0x7a, 0x02, 0x06, 0x49, 0xc3, 0x24, 0x23, 0x29, 0x40, - 0x46, 0x43, 0x19, 0xf1, 0x21, 0x00, 0x48, 0x01, 0xc8, 0xb8, 0x21, 0x40, - 0x09, 0x25, 0x5a, 0x1c, 0x50, 0xcd, 0x65, 0x37, 0xa8, 0x00, 0x03, 0x7c, - 0x00, 0x06, 0x4a, 0xda, 0xb0, 0x38, 0xa8, 0x40, 0x4a, 0x96, 0xae, 0x39, - 0xa8, 0x00, 0x49, 0x15, 0xbf, 0x36, 0xa8, 0x40, 0x04, 0x0e, 0x0b, 0x11, - 0x06, 0x24, 0x01, 0x01, 0xff, 0x48, 0x2a, 0x01, 0x32, 0xa8, 0x00, 0x4a, - 0x34, 0xb1, 0x35, 0xa8, 0x40, 0x46, 0x12, 0x0b, 0x34, 0xa8, 0x00, 0x44, - 0x22, 0x00, 0x31, 0xa8, 0x00, 0x47, 0x2a, 0x01, 0x30, 0xa8, 0x00, 0x49, - 0x1b, 0x26, 0x33, 0xa8, 0x40, 0xa1, 0x3b, 0x4b, 0xc6, 0x99, 0x08, 0x2b, - 0x00, 0x4c, 0x44, 0x8e, 0xd7, 0x21, 0x00, 0x09, 0x9c, 0x01, 0x19, 0x50, - 0xed, 0x66, 0x55, 0xf8, 0x01, 0x55, 0x01, 0x02, 0x67, 0x2b, 0x80, 0x06, - 0x4b, 0x49, 0x10, 0x00, 0x2b, 0x40, 0x47, 0xd0, 0x14, 0x77, 0x2b, 0x40, - 0x43, 0x93, 0xd0, 0x62, 0xf6, 0x01, 0x44, 0x40, 0x51, 0x52, 0xf6, 0x01, - 0x49, 0x31, 0xc1, 0x5a, 0xf6, 0x41, 0x53, 0xa8, 0x40, 0x22, 0x29, 0x00, - 0x44, 0xcf, 0x00, 0x97, 0x21, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x54, 0x93, - 0x40, 0x28, 0x29, 0x00, 0x09, 0x95, 0x10, 0x0c, 0x48, 0x78, 0xb4, 0xb9, - 0xf8, 0x01, 0x49, 0xc3, 0x24, 0x24, 0x29, 0x40, 0x50, 0x83, 0x40, 0x31, - 0x29, 0x00, 0x50, 0x97, 0x40, 0x2e, 0x29, 0x40, 0x4c, 0x0d, 0x29, 0xb4, - 0x22, 0x40, 0x8d, 0x06, 0x47, 0x4b, 0xd1, 0xdd, 0x2a, 0x40, 0x4f, 0x83, - 0x6b, 0x11, 0x20, 0x00, 0x54, 0x1b, 0x45, 0xb1, 0xf6, 0x41, 0x50, 0x3d, - 0x65, 0x6f, 0x20, 0x00, 0x48, 0x29, 0xcb, 0x8e, 0x01, 0x41, 0xa2, 0x2d, - 0x45, 0xeb, 0x5a, 0xd4, 0x26, 0x80, 0x20, 0x4d, 0x34, 0x86, 0xf5, 0xf4, - 0x01, 0x59, 0x62, 0x25, 0x1e, 0xf5, 0x01, 0xb0, 0x06, 0x4e, 0x76, 0x7c, - 0xad, 0xf6, 0x41, 0x4a, 0xd2, 0xa9, 0xb7, 0xf6, 0x01, 0x45, 0xb0, 0xe7, - 0x72, 0xf5, 0x41, 0x45, 0x59, 0x03, 0xab, 0xf6, 0x41, 0x47, 0xfa, 0xd1, - 0xb3, 0xf6, 0x01, 0x49, 0xa9, 0xbe, 0x83, 0x00, 0x40, 0x03, 0x13, 0x05, - 0xca, 0x02, 0xa4, 0xf5, 0x01, 0x50, 0xad, 0x00, 0xf9, 0x07, 0x00, 0x54, - 0xeb, 0x42, 0xf4, 0x07, 0x00, 0xac, 0x16, 0x07, 0x5f, 0x16, 0x06, 0x4a, - 0xc0, 0xb1, 0xff, 0x07, 0x40, 0x4a, 0xd6, 0xaa, 0xf7, 0x07, 0x00, 0x49, - 0x6e, 0xbd, 0xf6, 0x07, 0x40, 0x49, 0xfa, 0xb5, 0xfa, 0x07, 0x00, 0x06, - 0xed, 0x05, 0x06, 0x52, 0x6e, 0x54, 0xf5, 0x07, 0x40, 0xe1, 0xca, 0x07, - 0x00, 0x42, 0x16, 0x00, 0xd3, 0x07, 0x00, 0x43, 0xe6, 0x17, 0xd7, 0x07, - 0x00, 0x42, 0xf0, 0x10, 0xd8, 0x07, 0x80, 0xa3, 0x01, 0xe5, 0xcd, 0x07, - 0x80, 0x99, 0x01, 0x42, 0x0c, 0x08, 0xdd, 0x07, 0x00, 0x43, 0xd6, 0xaa, - 0xdc, 0x07, 0x00, 0x42, 0x22, 0x00, 0xe4, 0x07, 0x00, 0xe9, 0xcc, 0x07, - 0x00, 0xaa, 0x66, 0x42, 0x1b, 0x02, 0xde, 0x07, 0x00, 0x42, 0x74, 0x00, - 0xdf, 0x07, 0x00, 0x42, 0x6c, 0x00, 0xe1, 0x07, 0x00, 0xee, 0xd2, 0x07, - 0x80, 0x37, 0xef, 0xd0, 0x07, 0x80, 0x2e, 0x42, 0xbb, 0x09, 0xd4, 0x07, - 0x00, 0xb2, 0x1c, 0x42, 0x40, 0x06, 0xdb, 0x07, 0x00, 0x42, 0x12, 0x00, - 0xd5, 0x07, 0x00, 0xf5, 0xce, 0x07, 0x00, 0x42, 0xa9, 0x01, 0xe5, 0x07, - 0x00, 0x42, 0xbe, 0x22, 0xe6, 0x07, 0x40, 0xe1, 0xd9, 0x07, 0x00, 0x42, - 0x71, 0x00, 0xda, 0x07, 0x40, 0xef, 0xcf, 0x07, 0x40, 0xe1, 0xe3, 0x07, - 0x80, 0x0d, 0x42, 0xbe, 0x22, 0xe2, 0x07, 0xc0, 0x00, 0x47, 0xcb, 0xcd, - 0xe7, 0x07, 0x40, 0x47, 0xcb, 0xcd, 0xe0, 0x07, 0x40, 0xe1, 0xd6, 0x07, - 0x00, 0x04, 0xf1, 0xf1, 0x01, 0xff, 0x43, 0xe6, 0x17, 0xe9, 0x07, 0x00, - 0x42, 0x72, 0x19, 0xe8, 0x07, 0x00, 0x42, 0x71, 0x00, 0xea, 0x07, 0x40, - 0xe5, 0xcb, 0x07, 0x40, 0x48, 0x79, 0xc6, 0xd1, 0x07, 0x40, 0x49, 0x4b, - 0xb6, 0xfd, 0x07, 0x00, 0x05, 0xf0, 0x06, 0x06, 0x4a, 0x22, 0xaf, 0xfe, - 0x07, 0x40, 0x45, 0x12, 0x0b, 0xc8, 0x07, 0x00, 0xa6, 0x2e, 0x44, 0xea, - 0x2a, 0xc9, 0x07, 0x00, 0x43, 0x0e, 0x0b, 0xc1, 0x07, 0x00, 0xb3, 0x14, - 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xc0, 0x07, 0x40, 0x44, 0x25, 0x01, 0xc3, - 0x07, 0x00, 0x42, 0x15, 0x02, 0xc2, 0x07, 0x40, 0x44, 0xe5, 0x1d, 0xc7, - 0x07, 0x00, 0x42, 0x1c, 0x26, 0xc6, 0x07, 0x40, 0x43, 0xd2, 0x05, 0xc5, - 0x07, 0x00, 0x43, 0xf6, 0x06, 0xc4, 0x07, 0x40, 0x07, 0x35, 0x16, 0x06, - 0x42, 0x6c, 0x00, 0xf8, 0x07, 0x40, 0x50, 0x1d, 0x62, 0xf3, 0x07, 0x00, - 0x05, 0xd7, 0x02, 0x1d, 0x51, 0x67, 0x5c, 0xf2, 0x07, 0x00, 0x06, 0x33, - 0x07, 0x01, 0xff, 0x49, 0xeb, 0x42, 0xeb, 0x07, 0x00, 0x48, 0x3e, 0xb5, - 0xec, 0x07, 0x00, 0x4b, 0xcd, 0x66, 0xed, 0x07, 0x40, 0x4f, 0xfb, 0x6b, - 0xee, 0x07, 0x00, 0x49, 0xeb, 0x42, 0xef, 0x07, 0x00, 0x48, 0x3e, 0xb5, - 0xf0, 0x07, 0x00, 0x4b, 0xcd, 0x66, 0xf1, 0x07, 0x40, 0x4e, 0x24, 0x78, - 0x03, 0xf3, 0x01, 0xae, 0x01, 0xff, 0x54, 0xfb, 0x41, 0xd9, 0xf7, 0x01, - 0x42, 0x72, 0x19, 0x77, 0xf9, 0x41, 0x45, 0x6c, 0xe5, 0x54, 0xf4, 0x01, - 0x03, 0xcf, 0x05, 0xad, 0x0c, 0x06, 0x4e, 0xdd, 0xdb, 0x0b, 0xec, 0x85, - 0x00, 0x00, 0x45, 0x35, 0xea, 0x46, 0x26, 0x80, 0xc9, 0x0b, 0x47, 0x57, - 0xd5, 0x13, 0xf9, 0x01, 0xb3, 0xab, 0x0b, 0x02, 0x29, 0x08, 0xa5, 0x09, - 0xb7, 0x11, 0x03, 0xc6, 0x62, 0x01, 0xff, 0x44, 0xed, 0x07, 0x85, 0x00, - 0x00, 0x44, 0x9a, 0xa6, 0x98, 0x23, 0x40, 0x80, 0xfa, 0x04, 0x02, 0x5a, - 0x00, 0x16, 0x05, 0xed, 0x07, 0x06, 0x46, 0xb2, 0x76, 0xf0, 0xf4, 0x41, + 0x00, 0xef, 0x23, 0x33, 0x40, 0x45, 0x50, 0xed, 0x1f, 0x33, 0x00, 0x46, + 0x86, 0xe4, 0x20, 0x33, 0x40, 0x42, 0xe8, 0x01, 0xad, 0x33, 0x80, 0x4c, + 0xa5, 0x3e, 0xa9, 0x2a, 0x43, 0x9f, 0x6c, 0x1a, 0x22, 0x80, 0x0f, 0xb5, + 0x01, 0xff, 0x43, 0x50, 0x79, 0x53, 0x33, 0x00, 0x45, 0x97, 0xf1, 0x54, + 0x33, 0x40, 0x4f, 0x93, 0x6c, 0xdd, 0xce, 0xc1, 0x00, 0x4f, 0x93, 0x6c, + 0xde, 0xce, 0xc1, 0x00, 0x4f, 0x93, 0x6c, 0xdf, 0xce, 0x41, 0x55, 0xaa, + 0x32, 0xce, 0x2a, 0x00, 0x42, 0x71, 0x00, 0x52, 0x33, 0x00, 0x45, 0x7e, + 0xf1, 0x51, 0x33, 0x40, 0x42, 0x91, 0x17, 0x55, 0x33, 0x00, 0x46, 0x8c, + 0xe4, 0x56, 0x33, 0x40, 0x47, 0x35, 0x0d, 0xae, 0x33, 0xc0, 0x00, 0x48, + 0xfc, 0x05, 0xaf, 0x33, 0x40, 0xe1, 0xa9, 0x33, 0x80, 0x6b, 0xe3, 0x76, + 0x33, 0x00, 0xa5, 0x4b, 0xe6, 0x8a, 0x33, 0x00, 0xe8, 0xd7, 0x33, 0x00, + 0xa9, 0x2e, 0xed, 0xd8, 0x33, 0x00, 0xaf, 0x16, 0x42, 0xae, 0xc6, 0xd9, + 0x33, 0x00, 0xf2, 0xda, 0x33, 0x00, 0xf3, 0xb0, 0x33, 0x00, 0xf6, 0xb4, + 0x33, 0x00, 0xf7, 0xba, 0x33, 0x40, 0x44, 0x9a, 0x14, 0x3d, 0x33, 0x00, + 0x43, 0x56, 0x0e, 0x40, 0x33, 0x00, 0x50, 0x3a, 0x6a, 0xd0, 0x2b, 0x40, + 0x47, 0xdd, 0xd4, 0x2e, 0x33, 0x00, 0xab, 0x01, 0xff, 0xef, 0x30, 0x33, + 0x00, 0x43, 0x36, 0xb0, 0x2f, 0x33, 0x40, 0x43, 0xb4, 0xa0, 0x3b, 0x33, + 0x00, 0xae, 0x06, 0x42, 0x60, 0x03, 0x37, 0x33, 0x40, 0x43, 0xff, 0xec, + 0x38, 0x33, 0x00, 0x42, 0x6f, 0x00, 0x3a, 0x33, 0x40, 0x45, 0x92, 0xe7, + 0x80, 0x33, 0x00, 0xa1, 0x01, 0xff, 0x45, 0xb6, 0xf0, 0x2b, 0x33, 0x00, + 0x42, 0x5c, 0x01, 0x2c, 0x33, 0x40, 0x43, 0x17, 0x8a, 0x09, 0x33, 0x00, + 0x43, 0x52, 0x18, 0x0a, 0x33, 0x00, 0x4a, 0x7e, 0x31, 0x90, 0x22, 0x80, + 0x04, 0xf6, 0x75, 0x33, 0x40, 0x04, 0xe9, 0x1f, 0x01, 0xff, 0x48, 0x86, + 0x0d, 0x92, 0x22, 0x00, 0x4c, 0xa0, 0x2c, 0xe5, 0x22, 0x40, 0xe1, 0x81, + 0x33, 0x80, 0x1a, 0xe6, 0x8b, 0x33, 0x00, 0xed, 0x9a, 0x33, 0x00, 0x44, + 0xff, 0x0a, 0x29, 0x33, 0x00, 0xf3, 0xb1, 0x33, 0x00, 0xf6, 0xb5, 0x33, + 0x00, 0xf7, 0xbb, 0x33, 0x40, 0x42, 0xb4, 0x01, 0x28, 0x33, 0x40, 0x80, + 0xcd, 0x01, 0xe1, 0x83, 0x33, 0x80, 0xa7, 0x01, 0xe2, 0x86, 0x33, 0x80, + 0x9b, 0x01, 0xa5, 0x85, 0x01, 0xe7, 0x8e, 0x33, 0x00, 0x42, 0xc0, 0xaa, + 0x92, 0x33, 0x00, 0xa9, 0x62, 0xec, 0x96, 0x33, 0x00, 0xed, 0x9c, 0x33, + 0x80, 0x4a, 0x42, 0x61, 0x03, 0xd6, 0x33, 0x00, 0x42, 0xe0, 0x09, 0xab, + 0x33, 0x00, 0xf3, 0xb3, 0x33, 0x00, 0x02, 0x2e, 0x02, 0x16, 0xf6, 0xb7, + 0x33, 0x80, 0x0b, 0xf7, 0xbd, 0x33, 0xc0, 0x00, 0x45, 0x98, 0x7f, 0xbf, + 0x33, 0x40, 0x45, 0x98, 0x7f, 0xb9, 0x33, 0x40, 0xe1, 0x82, 0x33, 0x00, + 0xe6, 0x8c, 0x33, 0x00, 0xe7, 0x8d, 0x33, 0x00, 0xec, 0x95, 0x33, 0x00, + 0xed, 0x9b, 0x33, 0x00, 0xf3, 0xb2, 0x33, 0x00, 0xf6, 0xb6, 0x33, 0x00, + 0xf7, 0xbc, 0x33, 0x40, 0x80, 0x01, 0xff, 0x45, 0x66, 0xeb, 0xa3, 0x33, + 0x00, 0x47, 0xfd, 0x05, 0x9f, 0x33, 0x40, 0x45, 0xe1, 0xed, 0x48, 0x33, + 0x00, 0xec, 0xd5, 0x33, 0x00, 0x42, 0x0d, 0x00, 0x49, 0x33, 0xc0, 0x00, + 0x45, 0x94, 0xea, 0x4a, 0x33, 0x40, 0x45, 0x15, 0xd9, 0x4d, 0x33, 0x00, + 0x42, 0x24, 0x02, 0x4b, 0x33, 0xc0, 0x00, 0x43, 0x9c, 0x14, 0x4c, 0x33, + 0x40, 0x46, 0x5c, 0x07, 0xd4, 0x33, 0x40, 0x43, 0x70, 0x54, 0x45, 0x33, + 0x00, 0xa9, 0x0c, 0x45, 0x30, 0xef, 0x47, 0x33, 0x00, 0x44, 0x74, 0xf8, + 0x46, 0x33, 0x40, 0x44, 0xe1, 0xed, 0x43, 0x33, 0x00, 0x42, 0x3d, 0x00, + 0x44, 0x33, 0x40, 0x45, 0x66, 0xeb, 0xa5, 0x33, 0x00, 0xaf, 0x06, 0x47, + 0xfd, 0x05, 0xa1, 0x33, 0x40, 0x42, 0x4e, 0x0b, 0xc1, 0x33, 0x00, 0x45, + 0x37, 0x0d, 0xa7, 0x33, 0xc0, 0x00, 0x48, 0xfc, 0x05, 0xa8, 0x33, 0x40, + 0x55, 0x30, 0x37, 0xcd, 0x2a, 0x00, 0xed, 0xd0, 0x33, 0x00, 0xee, 0xd1, + 0x33, 0x00, 0xaf, 0x04, 0xf8, 0xd3, 0x33, 0x40, 0xe7, 0xd2, 0x33, 0x00, + 0x45, 0x94, 0x0a, 0x11, 0x23, 0x40, 0x44, 0xa4, 0xf2, 0xc0, 0x33, 0x00, + 0xe1, 0x84, 0x33, 0x80, 0x8d, 0x01, 0xe2, 0x85, 0x33, 0x00, 0x43, 0x37, + 0x00, 0x89, 0x33, 0x00, 0x44, 0x11, 0x1f, 0x1c, 0x33, 0x00, 0xe7, 0x8f, + 0x33, 0x00, 0x42, 0xc0, 0xaa, 0x91, 0x33, 0x00, 0x43, 0x5e, 0x21, 0x14, + 0x33, 0x80, 0x5a, 0xeb, 0xcd, 0x33, 0x00, 0xec, 0x98, 0x33, 0x00, 0xed, + 0x9e, 0x33, 0x80, 0x36, 0xaf, 0x28, 0x42, 0xe0, 0x09, 0xaa, 0x33, 0x00, + 0xf4, 0xcf, 0x33, 0x00, 0x02, 0x42, 0x00, 0x0e, 0xf6, 0xb8, 0x33, 0x00, + 0xf7, 0xbe, 0x33, 0x00, 0x45, 0x82, 0xf2, 0x12, 0x33, 0x40, 0x44, 0xcc, + 0xf7, 0x1b, 0x33, 0x00, 0x46, 0x14, 0xe7, 0x1a, 0x33, 0x40, 0x43, 0x36, + 0x38, 0x1e, 0x33, 0x00, 0x44, 0x78, 0xf8, 0x1d, 0x33, 0x40, 0x80, 0x01, + 0xff, 0xa3, 0x06, 0x47, 0xfd, 0x05, 0xa2, 0x33, 0x40, 0x46, 0x0c, 0x06, + 0xce, 0x33, 0x00, 0x44, 0x67, 0xeb, 0xa6, 0x33, 0x40, 0x46, 0x28, 0xe2, + 0x15, 0x33, 0x00, 0x47, 0x13, 0xd9, 0x16, 0x33, 0x00, 0x45, 0x23, 0xf2, + 0x17, 0x33, 0x40, 0x43, 0x50, 0x0b, 0x0b, 0x33, 0x00, 0xb2, 0x01, 0xff, + 0x44, 0x28, 0x91, 0x0c, 0x33, 0x00, 0x44, 0xe0, 0xf7, 0x0d, 0x33, 0x40, + 0x47, 0x44, 0x45, 0x8f, 0x22, 0x80, 0x15, 0xee, 0xcc, 0x33, 0x80, 0x04, + 0xf5, 0x7a, 0x33, 0x40, 0x44, 0xad, 0xaa, 0x04, 0x33, 0x00, 0x42, 0x35, + 0x00, 0x05, 0x33, 0x40, 0x04, 0xe9, 0x1f, 0x01, 0xff, 0x48, 0x86, 0x0d, + 0x91, 0x22, 0x00, 0x4c, 0xa0, 0x2c, 0xe4, 0x22, 0x40, 0xe1, 0xca, 0x33, + 0x80, 0x4c, 0xa5, 0x3e, 0xe7, 0xcc, 0x32, 0x00, 0x4c, 0x0c, 0x95, 0x00, + 0xf2, 0x01, 0xaf, 0x21, 0xf0, 0xcb, 0x33, 0x80, 0x18, 0xb5, 0x04, 0xfa, + 0x90, 0x33, 0x40, 0x46, 0xca, 0xdf, 0x32, 0x33, 0x00, 0x44, 0x64, 0xf6, + 0x33, 0x33, 0x00, 0x43, 0x4f, 0x03, 0x35, 0x33, 0x40, 0xe1, 0x71, 0x33, + 0x40, 0xee, 0x3f, 0x33, 0x00, 0xaf, 0x01, 0xff, 0xee, 0x42, 0x33, 0x00, + 0x42, 0x3d, 0x00, 0x41, 0x33, 0x40, 0x47, 0x64, 0xd8, 0x36, 0x33, 0x00, + 0x44, 0x81, 0xf1, 0x39, 0x33, 0x40, 0x43, 0xf9, 0x20, 0x2a, 0x33, 0x40, + 0xa1, 0x35, 0xe2, 0x87, 0x33, 0x00, 0x42, 0xc0, 0xaa, 0x93, 0x33, 0x00, + 0xa9, 0x17, 0x42, 0xe0, 0x09, 0xac, 0x33, 0x00, 0x45, 0x29, 0xe2, 0x18, + 0x33, 0x80, 0x04, 0xf9, 0xc9, 0x33, 0x40, 0x43, 0x9c, 0x14, 0x19, 0x33, + 0x40, 0x42, 0x24, 0x02, 0x10, 0x33, 0x00, 0x43, 0x72, 0xfa, 0x11, 0x33, + 0x00, 0x45, 0x75, 0xf0, 0x13, 0x33, 0x40, 0xec, 0xff, 0x33, 0x00, 0x43, + 0x97, 0x96, 0x0f, 0x33, 0x00, 0x43, 0x60, 0x0f, 0x0e, 0x33, 0x40, 0xed, + 0x99, 0x33, 0x00, 0xaf, 0x01, 0xff, 0x42, 0x1b, 0x05, 0xcd, 0x23, 0x00, + 0x09, 0x47, 0xc6, 0x01, 0xff, 0x80, 0x04, 0xf3, 0xf6, 0x26, 0x40, 0x4f, + 0x91, 0x6e, 0x8b, 0xcc, 0x01, 0x49, 0x47, 0xbd, 0x8a, 0xcc, 0x01, 0x48, + 0x67, 0xd0, 0x89, 0xcc, 0x41, 0x44, 0x25, 0xa3, 0x08, 0x33, 0x00, 0xb2, + 0x0a, 0x47, 0xf9, 0xdb, 0x07, 0x33, 0x00, 0xf6, 0xce, 0x32, 0x40, 0x07, + 0x3c, 0xd4, 0x04, 0xe7, 0xcd, 0x32, 0x40, 0x46, 0x58, 0xe2, 0x7b, 0x33, + 0x00, 0x45, 0x77, 0xee, 0x7e, 0x33, 0x00, 0x45, 0x34, 0xf0, 0xff, 0x32, + 0x00, 0x46, 0x4e, 0xe6, 0x7c, 0x33, 0x00, 0x47, 0x15, 0xdc, 0x7d, 0x33, + 0x40, 0xe1, 0x72, 0x33, 0x80, 0x2c, 0xe2, 0xc8, 0x33, 0x00, 0x43, 0xdc, + 0x0a, 0x25, 0x33, 0x00, 0xea, 0x90, 0xf1, 0x01, 0xec, 0x97, 0x33, 0x00, + 0xed, 0x77, 0x33, 0x80, 0x06, 0x43, 0xac, 0x08, 0x26, 0x33, 0x40, 0x80, + 0x01, 0xff, 0x45, 0x66, 0xeb, 0x79, 0x33, 0x00, 0x47, 0xfd, 0x05, 0x78, + 0x33, 0x40, 0x43, 0x79, 0x19, 0x24, 0x33, 0x40, 0x48, 0xf7, 0xc7, 0xc6, + 0x33, 0x00, 0xa1, 0x2d, 0xe3, 0xc4, 0x33, 0x00, 0xe4, 0xc5, 0x33, 0x00, + 0xed, 0x9d, 0x33, 0x80, 0x11, 0xef, 0xc7, 0x33, 0x80, 0x06, 0x42, 0x50, + 0x02, 0x94, 0x22, 0x40, 0x49, 0xbb, 0xc4, 0x7f, 0x33, 0x40, 0x80, 0x01, + 0xff, 0x45, 0x66, 0xeb, 0xa4, 0x33, 0x00, 0x47, 0xfd, 0x05, 0xa0, 0x33, + 0x40, 0xec, 0x88, 0x33, 0x00, 0xf0, 0x93, 0x22, 0x40, 0xa1, 0x1c, 0x44, + 0xbe, 0x11, 0x3c, 0x33, 0x00, 0x43, 0xb4, 0x81, 0x31, 0x33, 0x00, 0x45, + 0x94, 0xef, 0x3e, 0x33, 0x00, 0xf1, 0xc3, 0x33, 0x00, 0x47, 0xf5, 0xdc, + 0x34, 0x33, 0x40, 0x45, 0x67, 0xea, 0x2d, 0x33, 0x00, 0xf2, 0x74, 0x33, + 0x40, 0x47, 0x19, 0x2a, 0xdf, 0x33, 0x00, 0x43, 0x3c, 0x00, 0x03, 0x33, + 0x00, 0xed, 0xc2, 0x33, 0x00, 0x44, 0x80, 0xf7, 0x02, 0x33, 0x00, 0xb0, + 0x0a, 0x45, 0x7a, 0xf0, 0x01, 0x33, 0x00, 0xf5, 0x73, 0x33, 0x40, 0x44, + 0xb7, 0xa5, 0x00, 0x33, 0x00, 0x46, 0x50, 0xe1, 0x8c, 0xcc, 0x41, 0xe1, + 0x96, 0x00, 0x80, 0xbf, 0x01, 0xa5, 0x6f, 0x4d, 0xbf, 0x87, 0x22, 0x22, + 0x80, 0x57, 0xa9, 0x31, 0x02, 0x74, 0x00, 0x21, 0xaf, 0x01, 0xff, 0x43, + 0xff, 0x09, 0xfd, 0xf9, 0x01, 0xaf, 0x0c, 0x49, 0xcd, 0xc4, 0xc5, 0xf3, + 0x01, 0x4b, 0xe5, 0xa9, 0x33, 0xf4, 0x41, 0x4b, 0x47, 0xa3, 0xf5, 0xf9, + 0x01, 0xee, 0x44, 0xf9, 0x41, 0x52, 0xbf, 0x57, 0xa6, 0xf4, 0x01, 0x44, + 0x15, 0x06, 0xdf, 0xfa, 0x41, 0x43, 0xf8, 0x11, 0x77, 0xf5, 0x81, 0x17, + 0x04, 0xdd, 0x01, 0x01, 0xff, 0x4c, 0xd0, 0x91, 0xd3, 0xf5, 0x01, 0x48, + 0x87, 0xce, 0xd2, 0xf5, 0x01, 0x45, 0x82, 0x09, 0x1a, 0xf4, 0x41, 0x44, + 0xac, 0xf2, 0x78, 0xf5, 0x41, 0x09, 0x6b, 0x79, 0x01, 0xff, 0x44, 0xc3, + 0x00, 0xa0, 0x29, 0x00, 0x42, 0x50, 0x02, 0xa1, 0x29, 0x40, 0x02, 0x6d, + 0x00, 0x20, 0x10, 0x3a, 0x64, 0x14, 0xa5, 0x06, 0x4a, 0xc2, 0xb6, 0xb7, + 0x20, 0x40, 0x4a, 0xe4, 0xad, 0xac, 0xf4, 0x01, 0x45, 0x75, 0xeb, 0xa4, + 0xf6, 0x41, 0xd1, 0x46, 0xcc, 0x01, 0xd2, 0x47, 0xcc, 0x41, 0x4f, 0x56, + 0x6d, 0x4a, 0xf6, 0x01, 0x42, 0x33, 0x00, 0x08, 0xf5, 0x81, 0x06, 0x56, + 0x95, 0x36, 0xe3, 0xf5, 0x41, 0x06, 0x50, 0x00, 0x01, 0xff, 0x53, 0xa1, + 0x2d, 0x07, 0xf5, 0x01, 0x4e, 0x1a, 0x7e, 0x09, 0xf5, 0x01, 0x51, 0x01, + 0x61, 0x0a, 0xf5, 0x41, 0x42, 0x73, 0x02, 0x20, 0x00, 0x00, 0x46, 0xf2, + 0xe1, 0x5d, 0xf3, 0x01, 0xb2, 0x01, 0xff, 0x02, 0x98, 0x0e, 0x11, 0x03, + 0x41, 0x04, 0x01, 0xff, 0x4f, 0x43, 0x71, 0x40, 0xcc, 0x01, 0x4d, 0xc1, + 0x8e, 0x41, 0xcc, 0x41, 0xe5, 0x47, 0x27, 0x80, 0x06, 0x49, 0x1c, 0x8b, + 0x96, 0xf4, 0x41, 0xf3, 0x28, 0x27, 0x40, 0xa3, 0xd2, 0x0a, 0x02, 0xc5, + 0x00, 0xad, 0x0a, 0x06, 0xae, 0xd9, 0xf6, 0x07, 0xe8, 0x01, 0x00, 0x00, + 0x03, 0x1d, 0x33, 0xd3, 0x07, 0x46, 0xd9, 0x60, 0xc0, 0x20, 0x00, 0x5e, + 0xd5, 0x14, 0x1c, 0xf5, 0x01, 0x0b, 0xd8, 0xa6, 0xde, 0x05, 0xf3, 0x98, + 0x00, 0x00, 0xb5, 0x89, 0x04, 0x06, 0x7a, 0xe7, 0x01, 0xff, 0x17, 0x83, + 0x2f, 0xe6, 0x03, 0x15, 0x53, 0x3d, 0xad, 0x03, 0x4f, 0xad, 0x70, 0x98, + 0x1a, 0x01, 0x5b, 0xc2, 0x1c, 0xa0, 0x1a, 0x81, 0x8e, 0x03, 0x07, 0x13, + 0x06, 0x8d, 0x01, 0x05, 0xb9, 0x00, 0x71, 0xb3, 0x4d, 0x0e, 0x82, 0x80, + 0x41, 0x06, 0x74, 0x3b, 0x01, 0xff, 0x4b, 0x7a, 0x3b, 0x5b, 0x1a, 0x01, + 0x05, 0x5a, 0x03, 0x01, 0xff, 0xa1, 0x27, 0xe5, 0x54, 0x1a, 0x01, 0xe9, + 0x51, 0x1a, 0x01, 0xef, 0x55, 0x1a, 0x81, 0x16, 0xf5, 0x53, 0x1a, 0x81, + 0x0d, 0x08, 0xf2, 0xc6, 0x01, 0xff, 0xec, 0x5a, 0x1a, 0x01, 0xf2, 0x59, + 0x1a, 0x41, 0xe5, 0x52, 0x1a, 0x41, 0xe5, 0x56, 0x1a, 0x41, 0xe9, 0x57, + 0x1a, 0x01, 0xf5, 0x58, 0x1a, 0x41, 0xd1, 0xa1, 0x1a, 0x01, 0xd2, 0xa2, + 0x1a, 0x41, 0x04, 0x5b, 0x03, 0x06, 0x48, 0xaf, 0xd1, 0x99, 0x1a, 0x41, + 0x48, 0x0a, 0x17, 0x96, 0x1a, 0x01, 0x4b, 0x10, 0xa3, 0x84, 0x1a, 0x01, + 0x4b, 0xb9, 0xa9, 0x85, 0x1a, 0x01, 0x47, 0x47, 0x4e, 0x97, 0x1a, 0x41, + 0x4b, 0x66, 0xa0, 0x9c, 0x1a, 0x01, 0x45, 0xe4, 0xef, 0x9d, 0x1a, 0x01, + 0x44, 0xa4, 0x02, 0x9b, 0x1a, 0x01, 0x45, 0x61, 0x3c, 0x9a, 0x1a, 0x41, + 0x42, 0x3d, 0x27, 0x7a, 0x1a, 0x01, 0xe1, 0x50, 0x1a, 0x01, 0xa2, 0xe5, + 0x01, 0xa3, 0xd8, 0x01, 0xa4, 0xb9, 0x01, 0xa7, 0xac, 0x01, 0x42, 0x22, + 0x00, 0x82, 0x1a, 0x01, 0xaa, 0x99, 0x01, 0xab, 0x86, 0x01, 0x42, 0x74, + 0x00, 0x7d, 0x1a, 0x01, 0x42, 0x6c, 0x00, 0x74, 0x1a, 0x01, 0xae, 0x62, + 0xb0, 0x56, 0x42, 0x71, 0x00, 0x7c, 0x1a, 0x01, 0xb3, 0x3e, 0xb4, 0x19, + 0x42, 0x61, 0x0b, 0x7e, 0x1a, 0x01, 0x42, 0xdf, 0x23, 0x7b, 0x1a, 0x01, + 0xba, 0x01, 0xff, 0xe1, 0x79, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x78, 0x1a, + 0x41, 0xe1, 0x6b, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x6c, 0x1a, 0x01, 0xb3, + 0x0d, 0xb4, 0x01, 0xff, 0xe1, 0x66, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x67, + 0x1a, 0x41, 0xe1, 0x75, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x76, 0x1a, 0x41, + 0xe1, 0x81, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x7f, 0x1a, 0x01, 0x42, 0x40, + 0x06, 0x80, 0x1a, 0x41, 0xe1, 0x70, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x71, + 0x1a, 0x41, 0xe1, 0x6f, 0x1a, 0x01, 0x42, 0x24, 0x02, 0x60, 0x1a, 0x01, + 0x42, 0x2a, 0x05, 0x6a, 0x1a, 0x01, 0x42, 0xdf, 0x23, 0x65, 0x1a, 0x41, + 0xe1, 0x5c, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x5d, 0x1a, 0x01, 0x43, 0x1e, + 0x22, 0x83, 0x1a, 0x41, 0xe1, 0x63, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x64, + 0x1a, 0x41, 0xe1, 0x5e, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x5f, 0x1a, 0x41, + 0xe1, 0x6d, 0x1a, 0x01, 0xa4, 0x0c, 0x42, 0x22, 0x00, 0x6e, 0x1a, 0x01, + 0x42, 0x59, 0x00, 0x77, 0x1a, 0x41, 0xe1, 0x68, 0x1a, 0x01, 0x42, 0x22, + 0x00, 0x69, 0x1a, 0x41, 0xe1, 0x61, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x62, + 0x1a, 0x41, 0xe1, 0x72, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x73, 0x1a, 0x41, + 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x1f, 0x9b, 0x9f, 0x1a, 0x01, 0x4c, + 0x18, 0x9b, 0x9e, 0x1a, 0x41, 0x42, 0x3d, 0x27, 0x95, 0x1a, 0x01, 0xe2, + 0x8f, 0x1a, 0x01, 0xe4, 0x8d, 0x1a, 0x01, 0xe7, 0x8a, 0x1a, 0x01, 0xeb, + 0x8b, 0x1a, 0x01, 0xec, 0x92, 0x1a, 0x01, 0xed, 0x90, 0x1a, 0x01, 0xee, + 0x8e, 0x1a, 0x81, 0x0d, 0xf2, 0x91, 0x1a, 0x01, 0xf3, 0x94, 0x1a, 0xc1, + 0x00, 0xe8, 0x93, 0x1a, 0x41, 0xe7, 0x8c, 0x1a, 0x41, 0x42, 0x74, 0x00, + 0x87, 0x1a, 0x01, 0x42, 0x71, 0x00, 0x86, 0x1a, 0x01, 0xb3, 0x01, 0xff, + 0xe1, 0x89, 0x1a, 0x01, 0x42, 0x22, 0x00, 0x88, 0x1a, 0x41, 0x56, 0xb3, + 0x37, 0x17, 0x21, 0x00, 0x03, 0x53, 0x00, 0x01, 0xff, 0x05, 0xe4, 0x19, + 0x5c, 0x05, 0x00, 0x0f, 0x01, 0xff, 0x45, 0xce, 0x00, 0x99, 0x21, 0x80, + 0x3b, 0x4b, 0xae, 0x9e, 0x0b, 0x2b, 0x00, 0x4c, 0xd8, 0x92, 0xd9, 0x21, + 0x00, 0x09, 0x9c, 0x01, 0x19, 0x50, 0xfa, 0x69, 0x57, 0xf8, 0x01, 0x55, + 0x01, 0x02, 0x69, 0x2b, 0x80, 0x06, 0x4b, 0xf8, 0x10, 0x03, 0x2b, 0x40, + 0x47, 0x9e, 0x15, 0x79, 0x2b, 0x40, 0x43, 0x39, 0xd6, 0x61, 0xf6, 0x01, + 0x44, 0xa7, 0x53, 0x51, 0xf6, 0x01, 0x49, 0xe0, 0xc6, 0x59, 0xf6, 0x41, + 0x80, 0x01, 0xff, 0x54, 0x87, 0x42, 0x2a, 0x29, 0x00, 0x48, 0xdf, 0xb9, + 0xbb, 0xf8, 0x01, 0x49, 0x16, 0x26, 0x26, 0x29, 0x40, 0x45, 0xce, 0x00, + 0x98, 0x21, 0x80, 0x3b, 0x4b, 0xae, 0x9e, 0x0a, 0x2b, 0x00, 0x4c, 0xd8, + 0x92, 0xd8, 0x21, 0x00, 0x09, 0x9c, 0x01, 0x19, 0x50, 0xfa, 0x69, 0x56, + 0xf8, 0x01, 0x55, 0x01, 0x02, 0x68, 0x2b, 0x80, 0x06, 0x4b, 0xf8, 0x10, + 0x02, 0x2b, 0x40, 0x47, 0x9e, 0x15, 0x78, 0x2b, 0x40, 0x43, 0x39, 0xd6, + 0x63, 0xf6, 0x01, 0x44, 0xa7, 0x53, 0x53, 0xf6, 0x01, 0x49, 0xe0, 0xc6, + 0x5b, 0xf6, 0x41, 0x80, 0x01, 0xff, 0x54, 0xaf, 0x42, 0x29, 0x29, 0x00, + 0x59, 0xda, 0x24, 0x2d, 0x29, 0x00, 0x48, 0xdf, 0xb9, 0xba, 0xf8, 0x01, + 0x49, 0xae, 0xc5, 0xf2, 0x21, 0x00, 0x49, 0x16, 0x26, 0x25, 0x29, 0x40, + 0x06, 0xef, 0x06, 0x9d, 0x01, 0x07, 0x13, 0x06, 0x01, 0xff, 0x42, 0x3d, + 0x0a, 0xe2, 0x10, 0x01, 0x43, 0xbd, 0x50, 0xd2, 0x10, 0x01, 0x43, 0x06, + 0xfa, 0xd3, 0x10, 0x01, 0x43, 0x52, 0x2f, 0xd4, 0x10, 0x01, 0xa5, 0x74, + 0x43, 0x2d, 0xc2, 0xd5, 0x10, 0x01, 0x43, 0x49, 0x22, 0xde, 0x10, 0x01, + 0x42, 0x61, 0x2e, 0xe4, 0x10, 0x01, 0x43, 0x78, 0x1a, 0xe0, 0x10, 0x01, + 0x43, 0x41, 0xd9, 0xdf, 0x10, 0x01, 0x43, 0x3d, 0x19, 0xd8, 0x10, 0x01, + 0x02, 0x6c, 0x00, 0x44, 0xae, 0x30, 0x42, 0x9b, 0x2a, 0xe6, 0x10, 0x01, + 0x43, 0x05, 0x45, 0xdb, 0x10, 0x01, 0x43, 0x44, 0x19, 0xdd, 0x10, 0x01, + 0x43, 0x35, 0xcc, 0xd0, 0x10, 0x01, 0x43, 0x3c, 0x0a, 0xd1, 0x10, 0x01, + 0x42, 0x9d, 0x5a, 0xe5, 0x10, 0x01, 0x43, 0x7e, 0xdb, 0xda, 0x10, 0x01, + 0x43, 0xf5, 0x4c, 0xdc, 0x10, 0x41, 0x42, 0x3d, 0x0a, 0xd9, 0x10, 0x01, + 0x43, 0x2d, 0xc2, 0xd7, 0x10, 0x01, 0x43, 0xf5, 0x4c, 0xe1, 0x10, 0x41, + 0xe5, 0xe8, 0x10, 0x01, 0xe8, 0xd6, 0x10, 0x41, 0x42, 0x4e, 0x00, 0xe3, + 0x10, 0x01, 0xe8, 0xe7, 0x10, 0x41, 0x45, 0x7e, 0x0b, 0xf8, 0x10, 0x01, + 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xf9, 0x10, 0x01, 0x43, 0x7a, 0x0b, 0xf1, + 0x10, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xf0, 0x10, 0x41, + 0x44, 0x25, 0x01, 0xf3, 0x10, 0x01, 0x42, 0x15, 0x02, 0xf2, 0x10, 0x41, + 0x44, 0x06, 0x1f, 0xf7, 0x10, 0x01, 0x42, 0x09, 0x24, 0xf6, 0x10, 0x41, + 0x43, 0xf9, 0x05, 0xf5, 0x10, 0x01, 0x43, 0xf6, 0x06, 0xf4, 0x10, 0x41, + 0x56, 0x22, 0x26, 0x6a, 0xf6, 0x81, 0x0d, 0x42, 0xef, 0x02, 0x2f, 0x00, + 0xc0, 0x00, 0x4d, 0xbc, 0x83, 0xf6, 0x29, 0x40, 0x50, 0x0c, 0x12, 0x6b, + 0xf6, 0x41, 0x0a, 0xc2, 0x5b, 0xda, 0x01, 0x50, 0xea, 0x66, 0x45, 0x0f, + 0x01, 0x07, 0x13, 0x06, 0x49, 0x07, 0x37, 0x3c, 0x29, 0x0c, 0x3b, 0x17, + 0x01, 0xff, 0x4f, 0xd0, 0x44, 0x57, 0x0f, 0x01, 0x54, 0xcb, 0x44, 0x59, + 0x0f, 0x01, 0x04, 0x44, 0x0a, 0x01, 0xff, 0x51, 0xa0, 0x5b, 0x58, 0x0f, + 0x01, 0x4d, 0xb4, 0x8e, 0x55, 0x0f, 0xc1, 0x00, 0x4a, 0xa7, 0x5b, 0x56, + 0x0f, 0x41, 0x43, 0x7a, 0x0b, 0x51, 0x0f, 0x81, 0x0f, 0xb4, 0x01, 0xff, + 0x42, 0x92, 0x01, 0x52, 0x0f, 0x01, 0x45, 0xe8, 0x1e, 0x53, 0x0f, 0x41, + 0x48, 0x3e, 0x12, 0x54, 0x0f, 0x41, 0xa1, 0x79, 0x44, 0x20, 0xf5, 0x31, + 0x0f, 0x01, 0x44, 0xa4, 0xf5, 0x43, 0x0f, 0x01, 0x45, 0x5a, 0xb0, 0x32, + 0x0f, 0x01, 0x42, 0xb0, 0x01, 0x33, 0x0f, 0x81, 0x5a, 0x44, 0xb0, 0xf6, + 0x38, 0x0f, 0x01, 0xac, 0x46, 0x43, 0xb4, 0x05, 0x3a, 0x0f, 0x01, 0x43, + 0x18, 0x24, 0x3b, 0x0f, 0x01, 0x42, 0x6f, 0x02, 0x3e, 0x0f, 0x01, 0x49, + 0x8a, 0x69, 0x40, 0x0f, 0x01, 0xb3, 0x18, 0x43, 0x53, 0xca, 0x42, 0x0f, + 0x01, 0x43, 0x1c, 0x8f, 0x34, 0x0f, 0x01, 0x44, 0xfd, 0x54, 0x37, 0x0f, + 0x01, 0x45, 0xf7, 0x54, 0x35, 0x0f, 0x41, 0xa1, 0x06, 0x43, 0x48, 0x17, + 0x41, 0x0f, 0x41, 0x43, 0x95, 0xf0, 0x3f, 0x0f, 0x01, 0x44, 0x4a, 0xea, + 0x3c, 0x0f, 0x41, 0x45, 0x3b, 0xe2, 0x39, 0x0f, 0x01, 0x43, 0x14, 0x5d, + 0x44, 0x0f, 0x41, 0x42, 0x53, 0x00, 0x36, 0x0f, 0x41, 0x44, 0x3b, 0x3f, + 0x30, 0x0f, 0x01, 0x43, 0xa0, 0x1b, 0x3d, 0x0f, 0x41, 0x06, 0x69, 0x14, + 0x43, 0x04, 0x6f, 0x0c, 0x33, 0x05, 0x7d, 0x15, 0x23, 0x4f, 0x14, 0x73, + 0x4e, 0x0f, 0x01, 0x4a, 0xb4, 0xb5, 0x4f, 0x0f, 0x01, 0x4c, 0x74, 0x0f, + 0x50, 0x0f, 0x01, 0x09, 0x5d, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x49, + 0x0f, 0x01, 0x45, 0x20, 0x07, 0x47, 0x0f, 0x41, 0x45, 0x5c, 0x00, 0x4c, + 0x0f, 0x01, 0x45, 0x20, 0x07, 0x4d, 0x0f, 0x41, 0x45, 0x5c, 0x00, 0x48, + 0x0f, 0x01, 0x45, 0x20, 0x07, 0x46, 0x0f, 0x41, 0x45, 0x5c, 0x00, 0x4a, + 0x0f, 0x01, 0x45, 0x20, 0x07, 0x4b, 0x0f, 0x41, 0x80, 0x0c, 0x44, 0xef, + 0x1d, 0x4e, 0xf9, 0x01, 0x54, 0xdb, 0x48, 0x94, 0x23, 0x40, 0x46, 0x8a, + 0x66, 0xad, 0x00, 0x00, 0x49, 0x99, 0xbf, 0x66, 0xf3, 0x01, 0x51, 0x89, + 0x3b, 0xac, 0xf5, 0x41, 0x48, 0x47, 0xca, 0xbd, 0x26, 0x00, 0x42, 0x6e, + 0x00, 0xe6, 0xf9, 0x41, 0xa1, 0x2a, 0x4b, 0xb3, 0xa0, 0x27, 0xf9, 0x01, + 0x02, 0xd1, 0x00, 0x01, 0xff, 0x50, 0xca, 0x62, 0xd4, 0xf3, 0x01, 0x47, + 0x54, 0xd5, 0xc2, 0xf3, 0x01, 0x45, 0x64, 0x30, 0x44, 0x27, 0x00, 0x43, + 0x47, 0x19, 0x03, 0x26, 0xc0, 0x00, 0x4d, 0xe3, 0x83, 0xc4, 0x26, 0x40, + 0x42, 0x62, 0x01, 0x0c, 0xf4, 0x01, 0x42, 0x37, 0x01, 0x0d, 0xf4, 0xc1, + 0x00, 0x47, 0x15, 0x08, 0xfa, 0xcc, 0x41, 0xa1, 0x86, 0x01, 0xa9, 0x06, + 0x4c, 0x3e, 0x80, 0xac, 0xf6, 0x41, 0xac, 0x06, 0x4a, 0x0e, 0xb6, 0x0f, + 0xf6, 0x41, 0xe5, 0x23, 0x23, 0x00, 0x04, 0xa1, 0x01, 0x01, 0xff, 0x0e, + 0x85, 0x20, 0x5d, 0x0a, 0x0c, 0x08, 0x01, 0xff, 0xa8, 0x44, 0x4a, 0xda, + 0x2a, 0x03, 0xf6, 0x81, 0x26, 0xb3, 0x06, 0x44, 0xb0, 0x0d, 0x72, 0xf9, + 0x41, 0x4b, 0x94, 0x20, 0x0a, 0xf6, 0x81, 0x06, 0x49, 0x23, 0xc6, 0x0e, + 0xf6, 0x41, 0x05, 0x19, 0x00, 0x01, 0xff, 0x53, 0x14, 0x4c, 0x2d, 0xf9, + 0x01, 0x4c, 0xdc, 0x9a, 0x70, 0xf9, 0x41, 0x05, 0x19, 0x00, 0x01, 0xff, + 0x4a, 0x5c, 0x79, 0x05, 0xf6, 0x01, 0x4c, 0x93, 0x20, 0x04, 0xf6, 0x01, + 0x53, 0xf0, 0x4f, 0x06, 0xf6, 0x41, 0x43, 0x1e, 0x50, 0x07, 0xf6, 0x01, + 0x50, 0x06, 0x5d, 0x0d, 0xf6, 0x01, 0x44, 0x84, 0x83, 0x08, 0xf6, 0x41, + 0x51, 0x05, 0x5d, 0x3b, 0xf6, 0x01, 0x4a, 0xda, 0x2a, 0x3a, 0xf6, 0x41, + 0x02, 0x60, 0x07, 0x06, 0x4a, 0x73, 0x51, 0x33, 0x2a, 0x40, 0x80, 0x0d, + 0x47, 0xab, 0xd6, 0xaa, 0x2a, 0xc0, 0x00, 0x4c, 0x90, 0x2a, 0xac, 0x2a, + 0x40, 0xa1, 0x86, 0x03, 0x4c, 0x7c, 0x91, 0x39, 0xf5, 0x01, 0x02, 0x13, + 0x05, 0xcb, 0x02, 0x4b, 0x2f, 0xa0, 0x69, 0xfe, 0x00, 0xa5, 0x98, 0x02, + 0x49, 0x4f, 0x17, 0x52, 0xfe, 0x00, 0x51, 0xe3, 0x5c, 0x65, 0xfe, 0x00, + 0x4c, 0x70, 0x94, 0x63, 0xfe, 0x00, 0x51, 0x6b, 0x5d, 0x51, 0xfe, 0x00, + 0x02, 0x68, 0x00, 0xdf, 0x01, 0x4b, 0x6d, 0xa5, 0x5f, 0xfe, 0x00, 0x4e, + 0x52, 0x7e, 0x38, 0xf5, 0x01, 0xb0, 0xc4, 0x01, 0x4d, 0x88, 0x36, 0x56, + 0xfe, 0x00, 0xb2, 0x2a, 0x02, 0x46, 0x03, 0x1a, 0xb4, 0x0c, 0x54, 0x9f, + 0x48, 0xfa, 0xcd, 0x01, 0x51, 0xde, 0x61, 0x61, 0x2a, 0x40, 0x44, 0x72, + 0x24, 0xdc, 0x02, 0x00, 0x60, 0x5e, 0x0c, 0x3b, 0x0b, 0x41, 0x4d, 0x3e, + 0x84, 0x07, 0xd8, 0x00, 0x47, 0x5c, 0x5c, 0x54, 0xfe, 0x40, 0x4e, 0xa9, + 0x75, 0x68, 0xfe, 0x00, 0x05, 0xc9, 0x00, 0x76, 0x0d, 0x26, 0x8b, 0x01, + 0xff, 0xa5, 0x63, 0xa6, 0x46, 0x44, 0x6d, 0x2c, 0x78, 0x21, 0x00, 0x43, + 0x7a, 0x0b, 0x70, 0x21, 0x80, 0x2a, 0xb3, 0x1c, 0xb4, 0x01, 0xff, 0x42, + 0x92, 0x01, 0x79, 0x21, 0x00, 0x44, 0x25, 0x01, 0x72, 0x21, 0x00, 0xb7, + 0x01, 0xff, 0x44, 0x85, 0x2d, 0x7b, 0x21, 0x00, 0xef, 0x71, 0x21, 0x40, + 0x44, 0x06, 0x1f, 0x76, 0x21, 0x00, 0x42, 0x09, 0x24, 0x75, 0x21, 0x40, + 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0x7d, 0x21, 0x00, 0x48, 0xde, 0x1e, + 0x7f, 0x21, 0x40, 0xa9, 0x06, 0x43, 0xf6, 0x06, 0x73, 0x21, 0x40, 0x43, + 0x04, 0x24, 0x7c, 0x21, 0x00, 0x42, 0x32, 0x00, 0x74, 0x21, 0xc0, 0x00, + 0x48, 0x3e, 0x12, 0x7e, 0x21, 0x40, 0x44, 0xc9, 0x00, 0x77, 0x21, 0x00, + 0x45, 0xe7, 0x72, 0x7a, 0x21, 0x40, 0x4d, 0xde, 0x0b, 0x5c, 0xfe, 0x00, + 0x4b, 0xfb, 0x22, 0x5a, 0xfe, 0x00, 0x56, 0x79, 0x09, 0x5e, 0xfe, 0x40, + 0x4b, 0x00, 0xa1, 0x6a, 0xfe, 0x00, 0x48, 0x22, 0x75, 0x62, 0xfe, 0x40, + 0x03, 0xc5, 0x00, 0x06, 0x4c, 0x64, 0x9a, 0x64, 0xfe, 0x40, 0x4d, 0xde, + 0x0b, 0x5b, 0xfe, 0x00, 0x4b, 0xfb, 0x22, 0x59, 0xfe, 0x00, 0x56, 0x79, + 0x09, 0x5d, 0xfe, 0x40, 0x49, 0x1f, 0x97, 0x0a, 0x22, 0x80, 0x12, 0x46, + 0x97, 0xd6, 0x58, 0xfe, 0x00, 0x4a, 0x17, 0x14, 0x66, 0xfe, 0x00, 0x4f, + 0xae, 0x00, 0x57, 0xfe, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x47, 0xc2, + 0x83, 0xf7, 0x22, 0x00, 0x68, 0x30, 0x05, 0xf4, 0x22, 0x40, 0x43, 0xd7, + 0x02, 0x55, 0xfe, 0x00, 0x02, 0x15, 0x05, 0x1c, 0x07, 0xba, 0x6c, 0x01, + 0xff, 0x49, 0xdf, 0xbb, 0x0d, 0x22, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, + 0x47, 0xc2, 0x83, 0xfe, 0x22, 0x00, 0x68, 0x30, 0x05, 0xfc, 0x22, 0x40, + 0xe1, 0x50, 0xfe, 0x00, 0x49, 0x1f, 0xbe, 0x6b, 0xfe, 0x40, 0x47, 0xde, + 0x35, 0xe9, 0xf6, 0x01, 0x48, 0x36, 0x40, 0x60, 0xfe, 0x00, 0x47, 0xcb, + 0x0d, 0x61, 0xfe, 0x40, 0xa1, 0x6c, 0xa5, 0x40, 0xa9, 0x27, 0xaf, 0x01, + 0xff, 0xb0, 0x0d, 0xb4, 0x01, 0xff, 0x48, 0xb6, 0x4a, 0xb0, 0xf3, 0x01, + 0xe8, 0xa5, 0xf9, 0x41, 0xe5, 0x33, 0x23, 0x00, 0x0a, 0x4a, 0xb1, 0x01, + 0xff, 0x43, 0x1a, 0x00, 0x58, 0x2a, 0x00, 0x42, 0x0c, 0x00, 0x57, 0x2a, + 0x40, 0x4b, 0x11, 0x9f, 0x55, 0xf3, 0x01, 0x06, 0x2e, 0x7d, 0x01, 0xff, + 0x4d, 0x23, 0x87, 0x41, 0xf6, 0x01, 0x4c, 0x58, 0x9a, 0x42, 0xf6, 0x41, + 0xe4, 0xf7, 0xf6, 0x01, 0x02, 0x57, 0x0b, 0x06, 0x4a, 0xc0, 0xb8, 0x75, + 0xf5, 0x41, 0x04, 0xa1, 0x01, 0x06, 0x46, 0x6e, 0xdb, 0x2a, 0xf6, 0x41, + 0x4d, 0x31, 0x84, 0xcc, 0xf6, 0x01, 0x44, 0x0c, 0x08, 0x34, 0xf6, 0x01, + 0x46, 0x16, 0x08, 0xa4, 0xf4, 0x41, 0x05, 0x76, 0x00, 0x06, 0x4e, 0x7a, + 0x82, 0x73, 0xa6, 0x40, 0x0c, 0xf4, 0x29, 0x11, 0x13, 0x15, 0x4e, 0x01, + 0xff, 0x49, 0xa8, 0xc2, 0x5a, 0x2b, 0x00, 0x4d, 0x6b, 0x8c, 0x5c, 0x2b, + 0x40, 0x4c, 0x87, 0x00, 0x96, 0x2a, 0x80, 0x0d, 0x49, 0xec, 0x00, 0x95, + 0x2a, 0xc0, 0x00, 0x50, 0x5a, 0x63, 0x97, 0x2a, 0x40, 0x50, 0x5a, 0x63, + 0x98, 0x2a, 0x40, 0x48, 0x77, 0xc9, 0xf9, 0xf6, 0x01, 0xa9, 0x16, 0xb5, + 0x01, 0xff, 0x42, 0x60, 0x07, 0x80, 0xf4, 0x81, 0x06, 0x42, 0x21, 0x27, + 0xa8, 0xf9, 0x41, 0x4f, 0x0f, 0x4d, 0x20, 0x26, 0x40, 0x4d, 0x06, 0x83, + 0xbf, 0xf3, 0x01, 0x42, 0x33, 0x00, 0xf7, 0x26, 0x40, 0xa4, 0xc2, 0x31, + 0x02, 0x5c, 0x03, 0xf6, 0x07, 0x51, 0x48, 0x5e, 0xfe, 0xf5, 0x01, 0x06, + 0xcb, 0xd7, 0xc4, 0x07, 0xae, 0x30, 0xb8, 0x01, 0xff, 0x02, 0x9b, 0x01, + 0x0c, 0x4d, 0x17, 0x84, 0x06, 0x20, 0x00, 0x55, 0x71, 0x40, 0x3a, 0x27, + 0x40, 0x60, 0x43, 0x10, 0x3e, 0x27, 0x00, 0x07, 0x34, 0x08, 0x01, 0xff, + 0x4a, 0x92, 0x2d, 0x36, 0x27, 0x00, 0x4d, 0xf6, 0x13, 0xcd, 0xf7, 0x01, + 0x54, 0x3b, 0x48, 0x2f, 0xf5, 0x41, 0x46, 0xfc, 0xe0, 0x3f, 0x22, 0x00, + 0x03, 0x06, 0x02, 0xc1, 0x06, 0x05, 0xc4, 0xec, 0x01, 0xff, 0x08, 0xb3, + 0x84, 0xa4, 0x05, 0xac, 0xae, 0x01, 0x56, 0x79, 0x38, 0xf4, 0x0d, 0x00, + 0x05, 0x5a, 0x03, 0x89, 0x01, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0x4a, 0x4a, + 0x6f, 0xcf, 0x0d, 0x00, 0x05, 0x45, 0x6f, 0x52, 0x02, 0x24, 0x02, 0x42, + 0xab, 0x01, 0xff, 0x05, 0x55, 0xbe, 0x29, 0x04, 0x49, 0xd8, 0x01, 0xff, + 0x45, 0xab, 0xe7, 0xdb, 0x0d, 0x00, 0x42, 0x61, 0x0b, 0xd9, 0x0d, 0xc0, + 0x00, 0x05, 0xba, 0xe7, 0x01, 0xff, 0x4a, 0x4a, 0x6f, 0xdc, 0x0d, 0x00, + 0x4f, 0x45, 0x6f, 0xdd, 0x0d, 0x00, 0x4b, 0x6e, 0xa1, 0xde, 0x0d, 0x40, + 0x4a, 0xc2, 0xac, 0xd0, 0x0d, 0x00, 0x48, 0xef, 0xcc, 0xd2, 0x0d, 0x00, + 0x49, 0xa4, 0xc3, 0xd4, 0x0d, 0x40, 0x4a, 0x7e, 0xaf, 0xd8, 0x0d, 0x00, + 0x49, 0x70, 0xa1, 0xdf, 0x0d, 0x40, 0x4a, 0xc2, 0xac, 0xd1, 0x0d, 0x00, + 0x02, 0x24, 0x02, 0x12, 0x48, 0xef, 0xcc, 0xd3, 0x0d, 0x00, 0x47, 0x48, + 0xd8, 0xda, 0x0d, 0x00, 0x49, 0xa4, 0xc3, 0xd6, 0x0d, 0x40, 0x4a, 0x7e, + 0xaf, 0xf2, 0x0d, 0x00, 0x49, 0x70, 0xa1, 0xf3, 0x0d, 0x40, 0xa1, 0x0c, + 0x4b, 0x13, 0x25, 0x81, 0x0d, 0x00, 0x49, 0xe9, 0xc6, 0x83, 0x0d, 0x40, + 0x48, 0x37, 0xcd, 0xca, 0x0d, 0x00, 0x49, 0x7b, 0xc2, 0x82, 0x0d, 0x40, + 0x06, 0x14, 0x06, 0x47, 0x0a, 0x9a, 0xb1, 0x01, 0xff, 0x45, 0x7e, 0x0b, + 0xee, 0x0d, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xef, 0x0d, 0x00, 0x43, + 0x7a, 0x0b, 0xe7, 0x0d, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, + 0xe6, 0x0d, 0x40, 0x44, 0x25, 0x01, 0xe9, 0x0d, 0x00, 0x42, 0x15, 0x02, + 0xe8, 0x0d, 0x40, 0x44, 0x06, 0x1f, 0xed, 0x0d, 0x00, 0x42, 0x09, 0x24, + 0xec, 0x0d, 0x40, 0x43, 0xf9, 0x05, 0xeb, 0x0d, 0x00, 0x43, 0xf6, 0x06, + 0xea, 0x0d, 0x40, 0xa1, 0xb4, 0x02, 0x08, 0xaf, 0xca, 0x9d, 0x02, 0xa5, + 0x8e, 0x02, 0x47, 0xe3, 0xd6, 0xc6, 0x0d, 0x00, 0x47, 0x4c, 0xd7, 0xc4, + 0x0d, 0x00, 0xa9, 0xd3, 0x01, 0x52, 0x7f, 0x55, 0x9e, 0x0d, 0x00, 0xad, + 0x67, 0xaf, 0x59, 0x47, 0x19, 0xdb, 0xbb, 0x0d, 0x00, 0x08, 0x6f, 0xd0, + 0x35, 0x08, 0x0f, 0xd1, 0x1a, 0xb5, 0x0c, 0x47, 0x18, 0xdd, 0xc0, 0x0d, + 0x00, 0x47, 0xc7, 0xdd, 0xba, 0x0d, 0x40, 0x46, 0x0e, 0xe7, 0x8c, 0x0d, + 0x00, 0x45, 0x8c, 0x6c, 0x8b, 0x0d, 0x40, 0x4a, 0x87, 0x55, 0xa4, 0x0d, + 0x00, 0x02, 0x40, 0x06, 0x01, 0xff, 0x52, 0x69, 0x56, 0xa5, 0x0d, 0x00, + 0x45, 0x8c, 0x6c, 0xc1, 0x0d, 0x40, 0xa4, 0x0c, 0x47, 0x06, 0xd7, 0x9f, + 0x0d, 0x00, 0x47, 0x09, 0xd8, 0xa6, 0x0d, 0x40, 0x46, 0x75, 0xa4, 0xb3, + 0x0d, 0x00, 0x47, 0x03, 0xd6, 0xac, 0x0d, 0x40, 0x46, 0x8b, 0x6c, 0x95, + 0x0d, 0x00, 0x45, 0x8c, 0x6c, 0x94, 0x0d, 0x40, 0xa1, 0x17, 0x09, 0x8f, + 0xc6, 0x01, 0xff, 0x47, 0x95, 0xd8, 0xc5, 0x0d, 0x00, 0x47, 0x52, 0xd9, + 0xab, 0x0d, 0x00, 0x47, 0x97, 0xdb, 0xc2, 0x0d, 0x40, 0x0a, 0x82, 0xb0, + 0x06, 0x45, 0x8c, 0x6c, 0xb8, 0x0d, 0x40, 0x47, 0x74, 0xa4, 0xb7, 0x0d, + 0x00, 0x47, 0x93, 0xd5, 0xa1, 0x0d, 0x00, 0xa4, 0x27, 0x47, 0x06, 0xd7, + 0x9d, 0x0d, 0x00, 0x47, 0x09, 0xd8, 0xa3, 0x0d, 0x00, 0x47, 0x2c, 0xd8, + 0x9b, 0x0d, 0x00, 0x47, 0x78, 0xda, 0xb5, 0x0d, 0x00, 0xb4, 0x01, 0xff, + 0x46, 0x75, 0xa4, 0xae, 0x0d, 0x00, 0x47, 0x2a, 0xdc, 0xa8, 0x0d, 0x40, + 0x46, 0x75, 0xa4, 0xb0, 0x0d, 0x00, 0x47, 0x03, 0xd6, 0xaa, 0x0d, 0x40, + 0x46, 0x3c, 0xe3, 0x8a, 0x0d, 0x00, 0x02, 0x95, 0x16, 0x16, 0x02, 0x3d, + 0x00, 0x06, 0x45, 0x8c, 0x6c, 0x89, 0x0d, 0x40, 0x46, 0x0e, 0xe7, 0x8e, + 0x0d, 0x00, 0x45, 0x8c, 0x6c, 0x8d, 0x0d, 0x40, 0x46, 0x0e, 0xe7, 0x90, + 0x0d, 0x00, 0x45, 0x8c, 0x6c, 0x8f, 0x0d, 0x40, 0x46, 0x8c, 0xe1, 0x92, + 0x0d, 0x00, 0x45, 0x8c, 0x6c, 0x91, 0x0d, 0x40, 0x47, 0x95, 0xd8, 0xbd, + 0x0d, 0x00, 0x47, 0x52, 0xd9, 0xb1, 0x0d, 0x00, 0x47, 0x97, 0xdb, 0xc3, + 0x0d, 0x40, 0x46, 0x75, 0xa4, 0x86, 0x0d, 0x00, 0xa5, 0x5d, 0x46, 0x3c, + 0xe3, 0x93, 0x0d, 0x00, 0x0a, 0x02, 0xb3, 0x12, 0x4b, 0x70, 0xa4, 0xb9, + 0x0d, 0x00, 0x46, 0x0e, 0xe7, 0x96, 0x0d, 0x00, 0x45, 0x8c, 0x6c, 0x85, + 0x0d, 0x40, 0x47, 0x74, 0xa4, 0xb6, 0x0d, 0x00, 0x47, 0x93, 0xd5, 0xa0, + 0x0d, 0x00, 0xa4, 0x27, 0x47, 0x06, 0xd7, 0x9c, 0x0d, 0x00, 0x47, 0x09, + 0xd8, 0xa2, 0x0d, 0x00, 0x47, 0x2c, 0xd8, 0x9a, 0x0d, 0x00, 0x47, 0x78, + 0xda, 0xb4, 0x0d, 0x00, 0xb4, 0x01, 0xff, 0x46, 0x75, 0xa4, 0xad, 0x0d, + 0x00, 0x47, 0x2a, 0xdc, 0xa7, 0x0d, 0x40, 0x46, 0x75, 0xa4, 0xaf, 0x0d, + 0x00, 0x47, 0x03, 0xd6, 0xa9, 0x0d, 0x40, 0x46, 0x8c, 0xe1, 0x88, 0x0d, + 0x00, 0x45, 0x8c, 0x6c, 0x87, 0x0d, 0x40, 0x06, 0xef, 0x06, 0x52, 0x07, + 0x37, 0x3c, 0x01, 0xff, 0x46, 0x1a, 0xe1, 0xf1, 0x11, 0x01, 0xa6, 0x39, + 0x46, 0x33, 0x2e, 0xf2, 0x11, 0x01, 0x04, 0x7a, 0x0b, 0x23, 0xb3, 0x15, + 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0xea, 0x11, 0x01, 0x45, 0x48, 0x12, + 0xec, 0x11, 0x01, 0x45, 0xe8, 0x1e, 0xeb, 0x11, 0x41, 0x46, 0x06, 0x1f, + 0xf0, 0x11, 0x01, 0x44, 0x36, 0xe3, 0xef, 0x11, 0x41, 0x47, 0x3f, 0x12, + 0xf3, 0x11, 0x01, 0x48, 0xde, 0x1e, 0xf4, 0x11, 0x41, 0x44, 0x03, 0x24, + 0xee, 0x11, 0x01, 0x44, 0x3c, 0x54, 0xed, 0x11, 0x41, 0x45, 0x7e, 0x0b, + 0xe8, 0x11, 0x01, 0xa6, 0x29, 0x44, 0x6d, 0x2c, 0xe9, 0x11, 0x01, 0x43, + 0x7a, 0x0b, 0xe1, 0x11, 0x01, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, + 0x01, 0xe3, 0x11, 0x01, 0x42, 0x15, 0x02, 0xe2, 0x11, 0x41, 0x44, 0x06, + 0x1f, 0xe7, 0x11, 0x01, 0x42, 0x09, 0x24, 0xe6, 0x11, 0x41, 0x43, 0xf9, + 0x05, 0xe5, 0x11, 0x01, 0x43, 0xf6, 0x06, 0xe4, 0x11, 0x41, 0x80, 0x0d, + 0x07, 0x94, 0xd3, 0x01, 0xff, 0xd2, 0x8e, 0x00, 0x00, 0xd3, 0x8f, 0x00, + 0x40, 0x54, 0xd0, 0x18, 0x9a, 0x00, 0x00, 0x5c, 0xc8, 0x18, 0x99, 0x00, + 0x00, 0x5e, 0x21, 0x14, 0x1b, 0x20, 0x00, 0xac, 0x17, 0x63, 0xf3, 0x0b, + 0x3a, 0x20, 0x00, 0x07, 0xba, 0xdb, 0x01, 0xff, 0x44, 0x25, 0x01, 0x8f, + 0x00, 0x00, 0x42, 0x15, 0x02, 0x8e, 0x00, 0x40, 0x61, 0x78, 0x0e, 0x39, + 0x20, 0x00, 0x53, 0x61, 0x4e, 0x1a, 0x20, 0x40, 0x06, 0x5c, 0x00, 0x17, + 0x4d, 0x49, 0x8a, 0x6c, 0x2a, 0x00, 0x03, 0xc8, 0x07, 0x01, 0xff, 0x4c, + 0x87, 0x00, 0x9e, 0x2a, 0x00, 0x49, 0xec, 0x00, 0x9d, 0x2a, 0x40, 0x5e, + 0x03, 0x14, 0xa0, 0x2a, 0x00, 0x5b, 0x64, 0x1d, 0x9f, 0x2a, 0x40, 0x4d, + 0x7b, 0x83, 0x18, 0xf9, 0x01, 0x08, 0x5f, 0xd2, 0x01, 0xff, 0x04, 0xea, + 0x91, 0x96, 0x29, 0x02, 0x88, 0x09, 0xea, 0x28, 0xa3, 0xc2, 0x28, 0xa4, + 0xd7, 0x27, 0xa5, 0xf8, 0x25, 0xa6, 0xec, 0x24, 0x06, 0x1c, 0xe2, 0xd5, + 0x24, 0xa8, 0xc7, 0x14, 0xac, 0xc2, 0x13, 0x02, 0xc3, 0x07, 0x8c, 0x06, + 0xae, 0xe3, 0x05, 0x4b, 0xfb, 0x22, 0x8b, 0xda, 0x01, 0xb2, 0xdf, 0x03, + 0xb3, 0xe1, 0x02, 0xb4, 0x0c, 0x62, 0xd2, 0x0d, 0x75, 0xda, 0x01, 0x5b, + 0x4a, 0x1f, 0x6f, 0xda, 0x41, 0xa5, 0x84, 0x02, 0xaf, 0x92, 0x01, 0x06, + 0x6a, 0xe5, 0x01, 0xff, 0x0b, 0xc8, 0x4b, 0x52, 0x0a, 0x4a, 0x1f, 0x01, + 0xff, 0x0b, 0x35, 0x9e, 0x37, 0x09, 0xb2, 0xc4, 0x06, 0x47, 0xb3, 0xdb, + 0x51, 0xd9, 0x41, 0x0b, 0xc8, 0x4b, 0x17, 0x0a, 0x4a, 0x1f, 0x01, 0xff, + 0x4b, 0x94, 0x5c, 0x4d, 0xd9, 0x01, 0x46, 0x3b, 0x01, 0x4c, 0xd9, 0x01, + 0x46, 0x04, 0x0a, 0x4b, 0xd9, 0x41, 0x4b, 0x94, 0x5c, 0x50, 0xd9, 0x01, + 0x46, 0x3b, 0x01, 0x4f, 0xd9, 0x01, 0x46, 0x04, 0x0a, 0x4e, 0xd9, 0x41, + 0x46, 0x3b, 0x01, 0x53, 0xd9, 0x01, 0x46, 0x04, 0x0a, 0x52, 0xd9, 0x01, + 0x46, 0x8c, 0x1e, 0x54, 0xd9, 0x41, 0x09, 0xb2, 0xc4, 0x06, 0x47, 0xb3, + 0xdb, 0x87, 0xd9, 0x41, 0x0b, 0xc8, 0x4b, 0x17, 0x0a, 0x4a, 0x1f, 0x01, + 0xff, 0x4b, 0x94, 0x5c, 0x86, 0xd9, 0x01, 0x46, 0x3b, 0x01, 0x85, 0xd9, + 0x01, 0x46, 0x04, 0x0a, 0x84, 0xd9, 0x41, 0x4b, 0x94, 0x5c, 0x83, 0xd9, + 0x01, 0x46, 0x3b, 0x01, 0x82, 0xd9, 0x01, 0x46, 0x04, 0x0a, 0x81, 0xd9, + 0x41, 0x05, 0x08, 0xef, 0x32, 0x04, 0x68, 0xf8, 0x17, 0x04, 0xc8, 0xee, + 0x01, 0xff, 0x47, 0xe5, 0x09, 0x07, 0xd9, 0x01, 0x48, 0x97, 0x46, 0x06, + 0xd9, 0x01, 0x46, 0x04, 0x0a, 0x05, 0xd9, 0x41, 0x53, 0xc8, 0x4b, 0x74, + 0xda, 0x01, 0x0a, 0x4a, 0x1f, 0x01, 0xff, 0x4b, 0xcc, 0x9f, 0x73, 0xda, + 0x01, 0x50, 0x9a, 0x6a, 0x72, 0xda, 0x41, 0x07, 0x73, 0x02, 0x29, 0x54, + 0x7f, 0x45, 0x5d, 0xda, 0x01, 0x4c, 0xe4, 0x95, 0x5a, 0xda, 0x01, 0x53, + 0x90, 0x4d, 0x5e, 0xda, 0x01, 0x50, 0x8a, 0x6a, 0x59, 0xda, 0x01, 0x04, + 0xb5, 0x0c, 0x01, 0xff, 0x4c, 0x58, 0x91, 0x5b, 0xda, 0x01, 0x55, 0xb0, + 0x40, 0x5c, 0xda, 0x41, 0x4c, 0xb9, 0x40, 0x60, 0xda, 0x01, 0x4c, 0x8a, + 0x6a, 0x5f, 0xda, 0x41, 0x43, 0x48, 0x27, 0x61, 0xda, 0x81, 0x17, 0x0b, + 0x57, 0xa5, 0x01, 0xff, 0x44, 0xb4, 0x0b, 0x2d, 0xda, 0x01, 0x43, 0x13, + 0x01, 0x2f, 0xda, 0x01, 0x46, 0x7d, 0x02, 0x2e, 0xda, 0x41, 0x80, 0x01, + 0xff, 0x49, 0x42, 0xbc, 0x67, 0xda, 0x01, 0x48, 0xb5, 0x60, 0x62, 0xda, + 0x01, 0x03, 0xb6, 0x00, 0x01, 0xff, 0x44, 0x88, 0x1c, 0x65, 0xda, 0x81, + 0x0d, 0x46, 0xc4, 0x6a, 0x63, 0xda, 0xc1, 0x00, 0x49, 0xb4, 0x60, 0x64, + 0xda, 0x41, 0x49, 0xb4, 0x60, 0x66, 0xda, 0x41, 0x48, 0x5b, 0x5c, 0x89, + 0xda, 0x01, 0x08, 0x55, 0x1f, 0x5b, 0x07, 0xef, 0xda, 0x27, 0x06, 0xb4, + 0xe6, 0x11, 0x07, 0xe7, 0xdc, 0x01, 0xff, 0x47, 0xe5, 0x09, 0x15, 0xd9, + 0x01, 0x47, 0x16, 0x08, 0x14, 0xd9, 0x41, 0x47, 0xe5, 0x09, 0x0d, 0xd9, + 0x01, 0x48, 0x97, 0x46, 0x0c, 0xd9, 0x01, 0x46, 0x04, 0x0a, 0x0b, 0xd9, + 0x41, 0x51, 0x8e, 0x5c, 0x20, 0xd9, 0x01, 0x06, 0x49, 0x1d, 0x1a, 0xb3, + 0x01, 0xff, 0x49, 0x78, 0x6f, 0x1a, 0xd9, 0x01, 0x05, 0x5e, 0x07, 0x01, + 0xff, 0x48, 0x97, 0x46, 0x19, 0xd9, 0x01, 0x46, 0x04, 0x0a, 0x17, 0xd9, + 0x41, 0x48, 0x97, 0x46, 0x18, 0xd9, 0x01, 0x46, 0x04, 0x0a, 0x16, 0xd9, + 0x41, 0x04, 0xea, 0x0d, 0x06, 0x52, 0x2b, 0x58, 0x71, 0xda, 0x41, 0x49, + 0xe3, 0xc3, 0x6e, 0xda, 0x01, 0x45, 0xf2, 0xf0, 0x6d, 0xda, 0x41, 0x07, + 0x1b, 0x05, 0x17, 0x03, 0xd3, 0x4f, 0x01, 0xff, 0x47, 0xe5, 0x09, 0x13, + 0xd9, 0x01, 0x48, 0x97, 0x46, 0x12, 0xd9, 0x01, 0x46, 0x04, 0x0a, 0x11, + 0xd9, 0x41, 0x0a, 0x16, 0x96, 0x9d, 0x01, 0x8d, 0x01, 0xff, 0x0b, 0xc8, + 0x4b, 0x4e, 0x0a, 0x4a, 0x1f, 0x01, 0xff, 0x08, 0xbf, 0x12, 0x30, 0x46, + 0x3b, 0x01, 0xa3, 0xd9, 0x81, 0x18, 0x46, 0x04, 0x0a, 0xa2, 0xd9, 0xc1, + 0x00, 0x09, 0xa1, 0x27, 0x01, 0xff, 0x45, 0x5c, 0x9e, 0xb1, 0xd9, 0x01, + 0x4a, 0xec, 0xaf, 0xaa, 0xd9, 0x41, 0x09, 0xa1, 0x27, 0x01, 0xff, 0x45, + 0x5c, 0x9e, 0xb2, 0xd9, 0x01, 0x4a, 0xec, 0xaf, 0xab, 0xd9, 0x41, 0xe5, + 0xa4, 0xd9, 0x01, 0x0c, 0xd0, 0x94, 0x01, 0xff, 0x45, 0x5c, 0x9e, 0xb3, + 0xd9, 0x01, 0x4a, 0xec, 0xaf, 0xac, 0xd9, 0x41, 0x4b, 0x94, 0x5c, 0xe1, + 0xd9, 0x81, 0x30, 0x46, 0x3b, 0x01, 0xe0, 0xd9, 0x81, 0x18, 0x46, 0x04, + 0x0a, 0xdf, 0xd9, 0xc1, 0x00, 0x09, 0xa1, 0x27, 0x01, 0xff, 0x47, 0x3f, + 0xca, 0xc3, 0xd9, 0x01, 0x45, 0xad, 0x25, 0xd2, 0xd9, 0x41, 0x09, 0xa1, + 0x27, 0x01, 0xff, 0x47, 0x3f, 0xca, 0xc4, 0xd9, 0x01, 0x45, 0xad, 0x25, + 0xd3, 0xd9, 0x41, 0x09, 0xa1, 0x27, 0x01, 0xff, 0x47, 0x3f, 0xca, 0xc5, + 0xd9, 0x01, 0x45, 0xad, 0x25, 0xd4, 0xd9, 0x41, 0x91, 0x20, 0xd2, 0xa1, + 0xda, 0x01, 0xd3, 0xa2, 0xda, 0x01, 0xd4, 0xa3, 0xda, 0x01, 0xd5, 0xa4, + 0xda, 0x01, 0xd6, 0xa5, 0xda, 0x01, 0xd7, 0xa6, 0xda, 0x01, 0xd8, 0xa7, + 0xda, 0x01, 0xd9, 0xa8, 0xda, 0x41, 0xd0, 0xa9, 0xda, 0x01, 0xd1, 0xaa, + 0xda, 0x01, 0xd2, 0xab, 0xda, 0x01, 0xd3, 0xac, 0xda, 0x01, 0xd4, 0xad, + 0xda, 0x01, 0xd5, 0xae, 0xda, 0x01, 0xd6, 0xaf, 0xda, 0x41, 0x43, 0x3d, + 0x15, 0x6a, 0xda, 0x01, 0x04, 0x00, 0x18, 0x01, 0xff, 0x47, 0xd2, 0xd5, + 0x32, 0xda, 0x01, 0x47, 0x01, 0x93, 0x31, 0xda, 0x01, 0xb7, 0x01, 0xff, + 0x46, 0xbe, 0xe2, 0x34, 0xda, 0x01, 0x47, 0x32, 0xc7, 0x33, 0xda, 0x41, + 0x04, 0xc6, 0x21, 0xe1, 0x0b, 0x07, 0x26, 0xdd, 0x01, 0xff, 0x09, 0x51, + 0x27, 0xdd, 0x0a, 0x0b, 0xc8, 0x4b, 0xd5, 0x05, 0x06, 0x76, 0xe2, 0x99, + 0x05, 0x0a, 0x4a, 0x1f, 0x01, 0xff, 0x0b, 0x8c, 0x28, 0xee, 0x04, 0xa2, + 0xbe, 0x04, 0xa3, 0x80, 0x03, 0x07, 0x3b, 0x01, 0xe2, 0x02, 0x08, 0x71, + 0x1c, 0xc7, 0x02, 0x05, 0x19, 0xed, 0xa0, 0x02, 0x43, 0x44, 0x9f, 0x68, + 0xda, 0x01, 0x05, 0xba, 0xab, 0xec, 0x01, 0x06, 0xfe, 0xe4, 0xd5, 0x01, + 0xb3, 0xa4, 0x01, 0x07, 0x8c, 0x1e, 0x86, 0x01, 0xb7, 0x17, 0x07, 0xad, + 0x35, 0x01, 0xff, 0x45, 0x49, 0x1d, 0x47, 0xd9, 0x01, 0x46, 0x44, 0x04, + 0x46, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x45, 0xd9, 0x41, 0x04, 0x53, 0x24, + 0x11, 0x12, 0x41, 0x57, 0x01, 0xff, 0x46, 0x3b, 0x01, 0xee, 0xd9, 0x01, + 0x46, 0x04, 0x0a, 0xed, 0xd9, 0x41, 0x06, 0x69, 0x14, 0x27, 0x0e, 0x54, + 0x7a, 0x11, 0x08, 0xa2, 0x27, 0x01, 0xff, 0x45, 0x5c, 0x9e, 0xb0, 0xd9, + 0x01, 0x4a, 0xec, 0xaf, 0xa9, 0xd9, 0x41, 0x45, 0x49, 0x1d, 0xb6, 0xd9, + 0x01, 0x46, 0x44, 0x04, 0xb5, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0xb4, 0xd9, + 0x41, 0x07, 0x3b, 0x01, 0x17, 0x07, 0x8c, 0x1e, 0x01, 0xff, 0x45, 0x49, + 0x1d, 0x9e, 0xd9, 0x01, 0x46, 0x44, 0x04, 0x9d, 0xd9, 0x01, 0x45, 0x5d, + 0x07, 0x9c, 0xd9, 0x41, 0x45, 0x49, 0x1d, 0x9b, 0xd9, 0x01, 0x46, 0x44, + 0x04, 0x9a, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x99, 0xd9, 0x41, 0x4b, 0x94, + 0x5c, 0x36, 0xd9, 0x81, 0x0c, 0x51, 0xac, 0x60, 0x34, 0xd9, 0x01, 0x4a, + 0x65, 0x9d, 0x35, 0xd9, 0x41, 0x4b, 0x64, 0x9d, 0x37, 0xd9, 0x41, 0x46, + 0xe9, 0x70, 0xa5, 0xd9, 0x01, 0x06, 0x05, 0x0a, 0x01, 0xff, 0x09, 0x91, + 0x4f, 0x06, 0x4a, 0x65, 0x9d, 0x2e, 0xd9, 0x41, 0x45, 0x49, 0x1d, 0x2c, + 0xd9, 0x81, 0x0c, 0x46, 0x44, 0x04, 0x2b, 0xd9, 0x01, 0x45, 0x5d, 0x07, + 0x2a, 0xd9, 0x41, 0x42, 0x60, 0x01, 0x2d, 0xd9, 0x41, 0x45, 0x49, 0x1d, + 0x4a, 0xd9, 0x01, 0x46, 0x44, 0x04, 0x49, 0xd9, 0x01, 0x45, 0x5d, 0x07, + 0x48, 0xd9, 0x41, 0x08, 0xa2, 0x27, 0x19, 0x45, 0x49, 0x1d, 0x97, 0xd9, + 0x01, 0x46, 0x44, 0x04, 0x96, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x95, 0xd9, + 0xc1, 0x00, 0x47, 0x3a, 0x01, 0x98, 0xd9, 0x41, 0x45, 0x5c, 0x9e, 0xaf, + 0xd9, 0x01, 0x4a, 0xec, 0xaf, 0xa8, 0xd9, 0x41, 0x08, 0xa2, 0x27, 0x12, + 0x45, 0x49, 0x1d, 0x94, 0xd9, 0x01, 0x46, 0x44, 0x04, 0x93, 0xd9, 0x01, + 0x45, 0x5d, 0x07, 0x92, 0xd9, 0x41, 0x45, 0x5c, 0x9e, 0xae, 0xd9, 0x01, + 0x4a, 0xec, 0xaf, 0xa7, 0xd9, 0x41, 0x07, 0xbb, 0x45, 0x06, 0x46, 0xd3, + 0xd5, 0x28, 0xd9, 0x41, 0x46, 0x3b, 0x01, 0xf2, 0xd9, 0x01, 0x46, 0x04, + 0x0a, 0xf1, 0xd9, 0x41, 0x4b, 0x94, 0x5c, 0x31, 0xd9, 0x81, 0x0c, 0x48, + 0x91, 0x4f, 0x2f, 0xd9, 0x01, 0x4a, 0x65, 0x9d, 0x30, 0xd9, 0x41, 0x4b, + 0x64, 0x9d, 0x32, 0xd9, 0x41, 0x05, 0xf9, 0xad, 0xa4, 0x01, 0x06, 0x8a, + 0x0b, 0x87, 0x01, 0x44, 0x8f, 0x08, 0x33, 0xd9, 0x01, 0x04, 0x6a, 0x14, + 0x01, 0xff, 0x80, 0x11, 0x08, 0x9f, 0xca, 0x01, 0xff, 0x46, 0x44, 0x04, + 0xa1, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0xa0, 0xd9, 0x41, 0xa8, 0x39, 0x08, + 0x04, 0x03, 0x1c, 0x02, 0x53, 0x00, 0x01, 0xff, 0x4b, 0xbe, 0xa0, 0x9f, + 0xd9, 0x01, 0x13, 0xe6, 0x4e, 0x01, 0xff, 0x46, 0x44, 0x04, 0x91, 0xd9, + 0x01, 0x45, 0x5d, 0x07, 0x90, 0xd9, 0x41, 0x45, 0x49, 0x1d, 0x8a, 0xd9, + 0x81, 0x0c, 0x46, 0x44, 0x04, 0x89, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x88, + 0xd9, 0x41, 0x42, 0x60, 0x01, 0x8b, 0xd9, 0x41, 0x0b, 0x48, 0x2e, 0x11, + 0x07, 0xa3, 0x27, 0x01, 0xff, 0x45, 0x5c, 0x9e, 0xad, 0xd9, 0x01, 0x4a, + 0xec, 0xaf, 0xa6, 0xd9, 0x41, 0x45, 0x49, 0x1d, 0x8e, 0xd9, 0x81, 0x0c, + 0x46, 0x44, 0x04, 0x8d, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x8c, 0xd9, 0x41, + 0x42, 0x60, 0x01, 0x8f, 0xd9, 0x41, 0x45, 0x49, 0x1d, 0x3d, 0xd9, 0x01, + 0x46, 0x44, 0x04, 0x3c, 0xd9, 0x01, 0x48, 0x21, 0x63, 0x3e, 0xd9, 0x01, + 0x45, 0x5d, 0x07, 0x3b, 0xd9, 0x41, 0x45, 0x49, 0x1d, 0x41, 0xd9, 0x01, + 0x46, 0x44, 0x04, 0x40, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x3f, 0xd9, 0x41, + 0x04, 0x40, 0x05, 0x17, 0x03, 0xb4, 0x32, 0x01, 0xff, 0x45, 0x49, 0x1d, + 0x44, 0xd9, 0x01, 0x46, 0x44, 0x04, 0x43, 0xd9, 0x01, 0x45, 0x5d, 0x07, + 0x42, 0xd9, 0x41, 0x45, 0x49, 0x1d, 0x3a, 0xd9, 0x01, 0x46, 0x44, 0x04, + 0x39, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x38, 0xd9, 0x41, 0x07, 0x44, 0x04, + 0x11, 0x06, 0x5d, 0x07, 0x01, 0xff, 0x46, 0x3b, 0x01, 0xe5, 0xd9, 0x01, + 0x46, 0x04, 0x0a, 0xe3, 0xd9, 0x41, 0x46, 0x3b, 0x01, 0xe6, 0xd9, 0x01, + 0x46, 0x04, 0x0a, 0xe4, 0xd9, 0x41, 0x4f, 0x72, 0x6f, 0x24, 0xd9, 0x01, + 0x55, 0x5c, 0x40, 0x27, 0xd9, 0x01, 0x03, 0x4b, 0x16, 0x01, 0xff, 0x05, + 0x6c, 0x15, 0x06, 0x4a, 0x77, 0x6f, 0x23, 0xd9, 0x41, 0x0c, 0xd4, 0x90, + 0x0c, 0x45, 0x49, 0x1d, 0x21, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x22, 0xd9, + 0x41, 0x45, 0x49, 0x1d, 0x25, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x26, 0xd9, + 0x41, 0x18, 0x8c, 0x28, 0xcd, 0x04, 0xa2, 0xad, 0x04, 0xa3, 0xbf, 0x03, + 0x07, 0x3b, 0x01, 0xa1, 0x03, 0x08, 0x71, 0x1c, 0x86, 0x03, 0x05, 0x19, + 0xed, 0xb0, 0x02, 0x43, 0x44, 0x9f, 0x69, 0xda, 0x01, 0x05, 0xba, 0xab, + 0xd0, 0x01, 0x06, 0xfe, 0xe4, 0xb9, 0x01, 0xb3, 0x88, 0x01, 0x07, 0x8c, + 0x1e, 0x68, 0xb7, 0x17, 0x07, 0xad, 0x35, 0x01, 0xff, 0x45, 0x49, 0x1d, + 0x7d, 0xd9, 0x01, 0x46, 0x44, 0x04, 0x7c, 0xd9, 0x01, 0x45, 0x5d, 0x07, + 0x7b, 0xd9, 0x41, 0x04, 0x53, 0x24, 0x11, 0x19, 0x96, 0x27, 0x01, 0xff, + 0x46, 0x3b, 0x01, 0xf0, 0xd9, 0x01, 0x46, 0x04, 0x0a, 0xef, 0xd9, 0x41, + 0x08, 0xa2, 0x27, 0x15, 0x45, 0x49, 0x1d, 0xde, 0xd9, 0x01, 0xb3, 0x01, + 0xff, 0x44, 0x5e, 0x07, 0xdd, 0xd9, 0x01, 0x44, 0xfe, 0x2f, 0xdc, 0xd9, + 0x41, 0x08, 0x3f, 0xca, 0x11, 0x06, 0xad, 0x25, 0x01, 0xff, 0x45, 0x49, + 0x1d, 0xd1, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0xd0, 0xd9, 0x41, 0x45, 0x49, + 0x1d, 0xc2, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0xc1, 0xd9, 0x41, 0x0c, 0xd4, + 0x90, 0x0c, 0x51, 0xac, 0x60, 0x6f, 0xd9, 0x01, 0x4a, 0x65, 0x9d, 0x70, + 0xd9, 0x41, 0x48, 0xb5, 0x60, 0x71, 0xd9, 0x01, 0x4a, 0x65, 0x9d, 0x72, + 0xd9, 0x41, 0x4f, 0xe9, 0x70, 0xe2, 0xd9, 0x01, 0x06, 0x05, 0x0a, 0x01, + 0xff, 0x09, 0x91, 0x4f, 0x06, 0x4a, 0x65, 0x9d, 0x69, 0xd9, 0x41, 0x45, + 0x49, 0x1d, 0x67, 0xd9, 0x81, 0x0c, 0x46, 0x44, 0x04, 0x66, 0xd9, 0x01, + 0x45, 0x5d, 0x07, 0x65, 0xd9, 0x41, 0x42, 0x60, 0x01, 0x68, 0xd9, 0x41, + 0x45, 0x49, 0x1d, 0x80, 0xd9, 0x01, 0x46, 0x44, 0x04, 0x7f, 0xd9, 0x01, + 0x45, 0x5d, 0x07, 0x7e, 0xd9, 0x41, 0x08, 0xa2, 0x27, 0x06, 0x45, 0x5d, + 0x07, 0xdb, 0xd9, 0x41, 0x08, 0x3f, 0xca, 0x26, 0x06, 0xad, 0x25, 0x01, + 0xff, 0x06, 0x49, 0x1d, 0x11, 0x06, 0x5d, 0x07, 0x01, 0xff, 0x46, 0x3b, + 0x01, 0xce, 0xd9, 0x01, 0x46, 0x04, 0x0a, 0xcc, 0xd9, 0x41, 0x46, 0x3b, + 0x01, 0xcf, 0xd9, 0x01, 0x46, 0x04, 0x0a, 0xcd, 0xd9, 0x41, 0x06, 0x49, + 0x1d, 0x11, 0x06, 0x5d, 0x07, 0x01, 0xff, 0x46, 0x3b, 0x01, 0xbf, 0xd9, + 0x01, 0x46, 0x04, 0x0a, 0xbd, 0xd9, 0x41, 0x46, 0x3b, 0x01, 0xc0, 0xd9, + 0x01, 0x46, 0x04, 0x0a, 0xbe, 0xd9, 0x41, 0x08, 0xa2, 0x27, 0x06, 0x45, + 0x5d, 0x07, 0xda, 0xd9, 0x41, 0x08, 0x3f, 0xca, 0x22, 0x06, 0xad, 0x25, + 0x01, 0xff, 0x4c, 0x78, 0x95, 0xc9, 0xd9, 0x01, 0x4c, 0x40, 0x9a, 0xc8, + 0xd9, 0x01, 0x07, 0x8c, 0x1e, 0x01, 0xff, 0x4c, 0x84, 0x95, 0xcb, 0xd9, + 0x01, 0x4c, 0x4c, 0x9a, 0xca, 0xd9, 0x41, 0x06, 0x49, 0x1d, 0x11, 0x06, + 0x5d, 0x07, 0x01, 0xff, 0x46, 0x3b, 0x01, 0xb9, 0xd9, 0x01, 0x46, 0x8c, + 0x1e, 0xbb, 0xd9, 0x41, 0x46, 0x3b, 0x01, 0xba, 0xd9, 0x01, 0x46, 0x8c, + 0x1e, 0xbc, 0xd9, 0x41, 0x14, 0xbb, 0x45, 0x06, 0x46, 0xd3, 0xd5, 0x29, + 0xd9, 0x41, 0x46, 0x3b, 0x01, 0xf4, 0xd9, 0x01, 0x46, 0x04, 0x0a, 0xf3, + 0xd9, 0x41, 0x4b, 0x94, 0x5c, 0x6c, 0xd9, 0x81, 0x0c, 0x48, 0x91, 0x4f, + 0x6a, 0xd9, 0x01, 0x4a, 0x65, 0x9d, 0x6b, 0xd9, 0x41, 0x4b, 0x64, 0x9d, + 0x6d, 0xd9, 0x41, 0x44, 0x3c, 0x15, 0x77, 0xd9, 0x01, 0x06, 0x8a, 0x0b, + 0x4f, 0x44, 0x8f, 0x08, 0x6e, 0xd9, 0x01, 0x05, 0x6a, 0x14, 0x01, 0xff, + 0x48, 0x6f, 0xca, 0xd9, 0xd9, 0x01, 0x08, 0xa2, 0x27, 0x19, 0x45, 0x49, + 0x1d, 0xd7, 0xd9, 0x81, 0x0c, 0x46, 0x44, 0x04, 0xd6, 0xd9, 0x01, 0x45, + 0x5d, 0x07, 0xd5, 0xd9, 0x41, 0x42, 0x60, 0x01, 0xd8, 0xd9, 0x41, 0x08, + 0x3f, 0xca, 0x11, 0x06, 0xad, 0x25, 0x01, 0xff, 0x45, 0x49, 0x1d, 0xc7, + 0xd9, 0x01, 0x45, 0x5d, 0x07, 0xc6, 0xd9, 0x41, 0x45, 0x49, 0x1d, 0xb8, + 0xd9, 0x01, 0x45, 0x5d, 0x07, 0xb7, 0xd9, 0x41, 0x45, 0x49, 0x1d, 0x76, + 0xd9, 0x01, 0x46, 0x44, 0x04, 0x75, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x74, + 0xd9, 0x41, 0x43, 0x40, 0x05, 0x73, 0xd9, 0x01, 0x03, 0xb4, 0x32, 0x01, + 0xff, 0x45, 0x49, 0x1d, 0x7a, 0xd9, 0x01, 0x46, 0x44, 0x04, 0x79, 0xd9, + 0x01, 0x45, 0x5d, 0x07, 0x78, 0xd9, 0x41, 0x06, 0x49, 0x1d, 0x21, 0x07, + 0x44, 0x04, 0x11, 0x06, 0x5d, 0x07, 0x01, 0xff, 0x46, 0x3b, 0x01, 0xea, + 0xd9, 0x01, 0x46, 0x04, 0x0a, 0xe7, 0xd9, 0x41, 0x46, 0x3b, 0x01, 0xeb, + 0xd9, 0x01, 0x46, 0x04, 0x0a, 0xe8, 0xd9, 0x41, 0x46, 0x3b, 0x01, 0xec, + 0xd9, 0x01, 0x46, 0x04, 0x0a, 0xe9, 0xd9, 0x41, 0x05, 0x8f, 0xea, 0x5d, + 0x08, 0xe5, 0x09, 0x1e, 0x08, 0x67, 0xd1, 0x01, 0xff, 0x45, 0x49, 0x1d, + 0x5b, 0xd9, 0x81, 0x0c, 0x46, 0x44, 0x04, 0x5a, 0xd9, 0x01, 0x45, 0x5d, + 0x07, 0x59, 0xd9, 0x41, 0x42, 0x60, 0x01, 0x5c, 0xd9, 0x41, 0x05, 0x8f, + 0xea, 0x1e, 0x08, 0x67, 0xd1, 0x01, 0xff, 0x45, 0x49, 0x1d, 0x63, 0xd9, + 0x81, 0x0c, 0x46, 0x44, 0x04, 0x62, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0x61, + 0xd9, 0x41, 0x42, 0x60, 0x01, 0x64, 0xd9, 0x41, 0x45, 0x49, 0x1d, 0x5f, + 0xd9, 0x81, 0x0c, 0x46, 0x44, 0x04, 0x5e, 0xd9, 0x01, 0x45, 0x5d, 0x07, + 0x5d, 0xd9, 0x41, 0x42, 0x60, 0x01, 0x60, 0xd9, 0x41, 0x45, 0x49, 0x1d, + 0x57, 0xd9, 0x81, 0x0c, 0x46, 0x44, 0x04, 0x56, 0xd9, 0x01, 0x45, 0x5d, + 0x07, 0x55, 0xd9, 0x41, 0x42, 0x60, 0x01, 0x58, 0xd9, 0x41, 0xa3, 0xac, + 0x01, 0x45, 0x23, 0x87, 0x41, 0xda, 0x81, 0x95, 0x01, 0x44, 0xee, 0x76, + 0x4d, 0xda, 0x81, 0x7f, 0x05, 0xf6, 0x04, 0x3d, 0x45, 0x3e, 0xc7, 0x3e, + 0xda, 0x81, 0x27, 0x45, 0x1f, 0xf1, 0x50, 0xda, 0x81, 0x11, 0x09, 0x31, + 0xc7, 0x01, 0xff, 0x46, 0x3b, 0x01, 0x58, 0xda, 0x01, 0x46, 0x04, 0x0a, + 0x57, 0xda, 0x41, 0x80, 0x01, 0xff, 0x47, 0x59, 0x33, 0x51, 0xda, 0x01, + 0x46, 0x30, 0xe6, 0x52, 0xda, 0x41, 0x80, 0x01, 0xff, 0x44, 0xf6, 0x04, + 0x40, 0xda, 0x01, 0x48, 0x57, 0xd2, 0x3f, 0xda, 0x41, 0x46, 0x12, 0x03, + 0x44, 0xda, 0x01, 0x47, 0x59, 0x33, 0x45, 0xda, 0x01, 0x44, 0xd0, 0x48, + 0x47, 0xda, 0x81, 0x1c, 0x49, 0xba, 0x49, 0x4a, 0xda, 0x81, 0x06, 0x48, + 0x57, 0xd2, 0x46, 0xda, 0x41, 0x80, 0x01, 0xff, 0x48, 0x57, 0xd2, 0x4b, + 0xda, 0x01, 0x44, 0x34, 0xf9, 0x4c, 0xda, 0x41, 0x80, 0x01, 0xff, 0x48, + 0x57, 0xd2, 0x48, 0xda, 0x01, 0x44, 0x34, 0xf9, 0x49, 0xda, 0x41, 0x80, + 0x01, 0xff, 0x47, 0x59, 0x33, 0x4e, 0xda, 0x01, 0x48, 0x57, 0xd2, 0x4f, + 0xda, 0x41, 0x80, 0x01, 0xff, 0x44, 0xf6, 0x04, 0x43, 0xda, 0x01, 0x48, + 0x57, 0xd2, 0x42, 0xda, 0x41, 0x06, 0x82, 0x1c, 0x06, 0x46, 0x4a, 0x1a, + 0x56, 0xda, 0x41, 0x47, 0xd2, 0xd5, 0x3d, 0xda, 0x01, 0x47, 0x59, 0x33, + 0x3c, 0xda, 0x01, 0x47, 0x01, 0x93, 0x3b, 0xda, 0x41, 0xa9, 0x3e, 0x07, + 0x53, 0x89, 0x01, 0xff, 0x80, 0x0f, 0x8d, 0x01, 0xff, 0x50, 0x2a, 0x66, + 0x80, 0xda, 0x01, 0x4f, 0xf1, 0x77, 0x7f, 0xda, 0x41, 0x45, 0x7f, 0xeb, + 0x83, 0xda, 0x01, 0x02, 0xb0, 0x01, 0x12, 0x4c, 0xf0, 0x95, 0x86, 0xda, + 0x01, 0x45, 0x51, 0xf1, 0x85, 0xda, 0x01, 0x45, 0x97, 0x52, 0x82, 0xda, + 0x41, 0x47, 0x4a, 0xd4, 0x84, 0xda, 0x01, 0x44, 0xc9, 0x00, 0x81, 0xda, + 0x41, 0x03, 0x66, 0x14, 0x17, 0xb0, 0x01, 0xff, 0x80, 0x06, 0x52, 0x77, + 0x57, 0x53, 0xda, 0x41, 0x50, 0xca, 0x67, 0x54, 0xda, 0x01, 0x50, 0x5a, + 0x6b, 0x55, 0xda, 0x41, 0x4b, 0x48, 0x9f, 0x76, 0xda, 0x01, 0x07, 0xaa, + 0xd8, 0x01, 0xff, 0xd1, 0x77, 0xda, 0x01, 0xd2, 0x78, 0xda, 0x01, 0xd3, + 0x79, 0xda, 0x01, 0xd4, 0x7a, 0xda, 0x01, 0xd5, 0x7b, 0xda, 0x01, 0xd6, + 0x7c, 0xda, 0x01, 0xd7, 0x7d, 0xda, 0x41, 0xa1, 0x44, 0x43, 0xe7, 0x01, + 0xff, 0xd9, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x08, 0xb5, 0x60, 0x06, 0x43, + 0x0d, 0x1c, 0x00, 0xda, 0x41, 0x47, 0x11, 0x03, 0x06, 0xda, 0x01, 0x8d, + 0x01, 0xff, 0x0b, 0xc8, 0x4b, 0x17, 0x0a, 0x4a, 0x1f, 0x01, 0xff, 0x45, + 0x69, 0x14, 0x04, 0xda, 0x01, 0x48, 0x91, 0x4f, 0x01, 0xda, 0x01, 0x44, + 0x59, 0x05, 0x02, 0xda, 0x41, 0x45, 0x69, 0x14, 0x05, 0xda, 0x01, 0x48, + 0x91, 0x4f, 0x03, 0xda, 0x41, 0x42, 0x46, 0x00, 0x6b, 0xda, 0x01, 0x03, + 0xfe, 0x19, 0x01, 0xff, 0x45, 0x04, 0x02, 0x85, 0xd8, 0x81, 0xad, 0x0e, + 0xa3, 0xe0, 0x0b, 0xa6, 0xee, 0x02, 0xa8, 0x39, 0x44, 0xd0, 0x48, 0x77, + 0xd8, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x53, 0xb5, 0x4b, 0x56, 0xd8, 0x01, + 0x45, 0x5d, 0x14, 0x03, 0xd8, 0x01, 0x49, 0x40, 0xc1, 0x95, 0xd8, 0x01, + 0x48, 0x7f, 0xce, 0x79, 0xd8, 0x01, 0x4b, 0xaf, 0x19, 0xb2, 0xd8, 0x01, + 0x06, 0x63, 0x14, 0x01, 0xff, 0x47, 0x59, 0x33, 0x7a, 0xd8, 0x01, 0x44, + 0xdd, 0x0a, 0x78, 0xd8, 0x41, 0x44, 0xfe, 0x09, 0x7d, 0xd8, 0x81, 0x4c, + 0x43, 0x5c, 0x0f, 0x6b, 0xd8, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x48, 0x87, + 0xca, 0x6a, 0xd8, 0x01, 0x12, 0x57, 0x45, 0x26, 0x07, 0x7d, 0x02, 0x06, + 0x4a, 0x04, 0xb6, 0xb9, 0xd8, 0x41, 0x55, 0xaf, 0x19, 0xda, 0xd8, 0x81, + 0x06, 0x45, 0x63, 0x14, 0xca, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x42, 0x9e, + 0x01, 0xd9, 0xd8, 0x01, 0x43, 0x28, 0x08, 0xd8, 0xd8, 0x41, 0x42, 0x9e, + 0x01, 0xbe, 0xd8, 0x01, 0x43, 0x28, 0x08, 0xbd, 0xd8, 0x01, 0x45, 0xf5, + 0x1b, 0xbf, 0xd8, 0x41, 0x80, 0x01, 0xff, 0xa6, 0xce, 0x01, 0x45, 0x5d, + 0x14, 0x04, 0xd8, 0x81, 0x7c, 0x46, 0xb4, 0x19, 0x8a, 0xd8, 0x81, 0x5f, + 0x46, 0x7d, 0x02, 0xc5, 0xd8, 0x81, 0x52, 0x48, 0x7f, 0xce, 0x82, 0xd8, + 0x01, 0x44, 0xf6, 0x04, 0x7b, 0xd8, 0x81, 0x2b, 0x44, 0x22, 0x08, 0xa7, + 0xd8, 0x81, 0x1e, 0x45, 0x5d, 0x07, 0x7e, 0xd8, 0x01, 0x06, 0x63, 0x14, + 0x01, 0xff, 0x53, 0xbe, 0x4a, 0x84, 0xd8, 0x01, 0x44, 0xdd, 0x0a, 0x80, + 0xd8, 0xc1, 0x00, 0x4f, 0x1a, 0x6d, 0x83, 0xd8, 0x41, 0x5d, 0x6b, 0x15, + 0xac, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x48, 0x7f, 0xce, 0x81, 0xd8, 0x01, + 0x06, 0x63, 0x14, 0x01, 0xff, 0x47, 0x59, 0x33, 0x7c, 0xd8, 0x01, 0x44, + 0xdd, 0x0a, 0x7f, 0xd8, 0x41, 0x4c, 0xae, 0x19, 0xd1, 0xd8, 0x41, 0x80, + 0x01, 0xff, 0x45, 0x5d, 0x14, 0xa2, 0xd8, 0x81, 0x06, 0x45, 0x63, 0x14, + 0x9b, 0xd8, 0x41, 0x46, 0x62, 0x14, 0x9d, 0xd8, 0x41, 0x80, 0x01, 0xff, + 0x46, 0x34, 0x6b, 0xdb, 0xd8, 0x01, 0x07, 0x7d, 0x02, 0x2b, 0x4b, 0xaf, + 0x19, 0xc1, 0xd8, 0x01, 0x45, 0x63, 0x14, 0xf0, 0xd8, 0xc1, 0x00, 0x80, + 0x01, 0xff, 0x45, 0x49, 0x1d, 0xef, 0xd8, 0x01, 0x44, 0xf6, 0x04, 0xee, + 0xd8, 0x01, 0xb3, 0x01, 0xff, 0x43, 0x03, 0x00, 0xdd, 0xd8, 0x01, 0x44, + 0x5e, 0x07, 0xf1, 0xd8, 0x41, 0x46, 0xb4, 0x19, 0xa6, 0xd8, 0x01, 0x44, + 0x22, 0x08, 0x88, 0xd8, 0xc1, 0x00, 0x4a, 0xba, 0x19, 0x8d, 0xd8, 0x41, + 0x57, 0xf3, 0x30, 0x55, 0xd8, 0x01, 0x55, 0x8d, 0x1c, 0x4b, 0xd8, 0x41, + 0x43, 0x80, 0x25, 0x03, 0xd9, 0x81, 0xc8, 0x01, 0x43, 0xd9, 0x01, 0x5a, + 0xd8, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x54, 0xeb, 0x42, 0x5b, 0xd8, 0x01, + 0xa6, 0x61, 0x44, 0xfa, 0x13, 0x5c, 0xd8, 0x81, 0x3b, 0x06, 0x33, 0xde, + 0x17, 0x06, 0x63, 0x14, 0x01, 0xff, 0x44, 0xa3, 0x1c, 0x5f, 0xd8, 0x01, + 0x47, 0x59, 0x33, 0x60, 0xd8, 0x01, 0x44, 0xdd, 0x0a, 0x5d, 0xd8, 0x41, + 0x46, 0x73, 0x02, 0x62, 0xd8, 0x81, 0x0c, 0x50, 0xfa, 0x66, 0x61, 0xd8, + 0x01, 0x46, 0xb4, 0x19, 0x65, 0xd8, 0x41, 0x4b, 0xcc, 0x51, 0x63, 0xd8, + 0xc1, 0x00, 0x45, 0xa2, 0x1c, 0x64, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x53, + 0xb5, 0x4b, 0x4d, 0xd8, 0x81, 0x06, 0x4a, 0xcd, 0x51, 0x5e, 0xd8, 0x41, + 0x80, 0x01, 0xff, 0x44, 0xa3, 0x1c, 0x51, 0xd8, 0x01, 0x49, 0xaf, 0xbe, + 0x4f, 0xd8, 0x41, 0x52, 0xf3, 0x30, 0x4c, 0xd8, 0x81, 0x23, 0x4b, 0x8d, + 0x1c, 0x44, 0xd8, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x44, 0xa3, 0x1c, 0x45, + 0xd8, 0x01, 0x49, 0xbb, 0x19, 0x47, 0xd8, 0x81, 0x06, 0x46, 0x34, 0x6b, + 0x46, 0xd8, 0x41, 0x46, 0x32, 0xde, 0x48, 0xd8, 0x41, 0x80, 0x01, 0xff, + 0x44, 0xa3, 0x1c, 0x50, 0xd8, 0x01, 0x49, 0xaf, 0xbe, 0x4e, 0xd8, 0x01, + 0x46, 0x34, 0x6b, 0x57, 0xd8, 0x81, 0x06, 0x4d, 0x53, 0x33, 0x52, 0xd8, + 0x41, 0x80, 0x01, 0xff, 0x48, 0x7f, 0xce, 0x59, 0xd8, 0x01, 0x4a, 0xcd, + 0x51, 0x58, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x5b, 0x8c, 0x1c, 0x4a, 0xd8, + 0x01, 0x44, 0xfa, 0x13, 0x04, 0xd9, 0x01, 0x45, 0x5d, 0x14, 0x00, 0xd8, + 0x81, 0x85, 0x03, 0x07, 0xb4, 0x19, 0xb2, 0x02, 0x07, 0x7d, 0x02, 0xbd, + 0x01, 0x05, 0x22, 0x08, 0x7f, 0x45, 0x63, 0x14, 0xf5, 0xd8, 0xc1, 0x00, + 0x80, 0x01, 0xff, 0x08, 0xe5, 0x09, 0x58, 0x47, 0x59, 0x33, 0xfa, 0xd8, + 0x01, 0x44, 0xfa, 0x13, 0xf6, 0xd8, 0x01, 0x05, 0x16, 0x02, 0x3c, 0x05, + 0xdd, 0x0a, 0x26, 0x06, 0xb9, 0x26, 0x01, 0xff, 0x4c, 0x8c, 0x1c, 0x01, + 0xd9, 0x01, 0x4a, 0x36, 0xb1, 0x08, 0xd8, 0x01, 0x49, 0x40, 0xc1, 0x93, + 0xd8, 0x01, 0xb4, 0x01, 0xff, 0x4c, 0x64, 0x94, 0x00, 0xd9, 0x01, 0x4a, + 0x36, 0xa9, 0xfe, 0xd8, 0x41, 0x44, 0xa3, 0x1c, 0xf9, 0xd8, 0x01, 0x49, + 0xbb, 0x19, 0xf8, 0xd8, 0x01, 0x48, 0x51, 0x27, 0xf7, 0xd8, 0x41, 0x54, + 0xa3, 0x44, 0x02, 0xd9, 0x01, 0x4b, 0x35, 0xa9, 0xff, 0xd8, 0x41, 0x4c, + 0xac, 0x94, 0xfb, 0xd8, 0x81, 0x0c, 0x4b, 0xa8, 0x19, 0xfc, 0xd8, 0x01, + 0x4b, 0xaf, 0x19, 0xfd, 0xd8, 0x41, 0x49, 0x02, 0x6d, 0x2c, 0xd8, 0x41, + 0x44, 0xa5, 0x01, 0xab, 0xd8, 0x01, 0x45, 0x5d, 0x14, 0xb7, 0xd8, 0x01, + 0x46, 0xb4, 0x19, 0xb0, 0xd8, 0x01, 0x46, 0x7d, 0x02, 0xb4, 0xd8, 0x81, + 0x12, 0x4e, 0xa8, 0x44, 0xaf, 0xd8, 0x01, 0x45, 0x63, 0x14, 0xb8, 0xd8, + 0x01, 0x42, 0x50, 0x02, 0xae, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x49, 0xbb, + 0x19, 0xb5, 0xd8, 0x01, 0x4f, 0xa8, 0x44, 0xb6, 0xd8, 0x41, 0x4f, 0x73, + 0x6e, 0x1c, 0xd8, 0x01, 0x44, 0xa5, 0x01, 0xc4, 0xd8, 0x01, 0x46, 0xb4, + 0x19, 0xcc, 0xd8, 0x01, 0xb2, 0x50, 0x06, 0x63, 0x14, 0x0d, 0x42, 0x50, + 0x02, 0xc6, 0xd8, 0xc1, 0x00, 0x4b, 0xcc, 0x51, 0xc9, 0xd8, 0x41, 0x07, + 0x9e, 0xd4, 0x24, 0xa3, 0x0c, 0x4f, 0x25, 0x71, 0x30, 0xd8, 0x01, 0x46, + 0xb4, 0x19, 0xcb, 0xd8, 0x41, 0x0d, 0x8f, 0x88, 0x06, 0x4e, 0x0a, 0x82, + 0x36, 0xd8, 0x41, 0x46, 0x34, 0x6b, 0x39, 0xd8, 0x01, 0x42, 0x50, 0x02, + 0x38, 0xd8, 0x41, 0x48, 0x2c, 0x71, 0x42, 0xd8, 0x01, 0x0a, 0xe2, 0xb4, + 0x01, 0xff, 0x47, 0x64, 0x20, 0x41, 0xd8, 0x01, 0x42, 0x50, 0x02, 0x40, + 0xd8, 0x41, 0x4d, 0xa9, 0x44, 0xc8, 0xd8, 0x01, 0x4a, 0xb0, 0x19, 0xcd, + 0xd8, 0x41, 0x44, 0xa3, 0x1c, 0x98, 0xd8, 0x01, 0x44, 0xa5, 0x01, 0x8e, + 0xd8, 0x81, 0x27, 0x45, 0x5d, 0x14, 0xa0, 0xd8, 0x81, 0x1a, 0x4e, 0xa8, + 0x44, 0x97, 0xd8, 0x01, 0xb4, 0x06, 0x42, 0x50, 0x02, 0x92, 0xd8, 0x41, + 0x44, 0x64, 0x14, 0x9a, 0xd8, 0x01, 0x4c, 0x6c, 0x98, 0x99, 0xd8, 0x41, + 0x46, 0x62, 0x14, 0x9c, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x4e, 0x8a, 0x7e, + 0x91, 0xd8, 0x01, 0x07, 0x43, 0xdb, 0x01, 0xff, 0x46, 0xb2, 0x30, 0x90, + 0xd8, 0x01, 0x48, 0x91, 0x4f, 0x8f, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x44, + 0xa3, 0x1c, 0x06, 0xd8, 0x81, 0xf2, 0x03, 0x46, 0xb4, 0xe0, 0x0a, 0xd8, + 0x01, 0x46, 0x34, 0x6b, 0x0b, 0xd8, 0x81, 0xce, 0x03, 0x46, 0x7d, 0x02, + 0x0e, 0xd8, 0x81, 0xcd, 0x01, 0xb2, 0xbe, 0x01, 0x06, 0x63, 0x14, 0x18, + 0x50, 0x2a, 0x6b, 0x13, 0xd8, 0xc1, 0x00, 0x07, 0x62, 0x14, 0x01, 0xff, + 0x49, 0xbb, 0x19, 0x25, 0xd8, 0x01, 0x44, 0xdd, 0x0a, 0x24, 0xd8, 0x41, + 0x07, 0x9e, 0xd4, 0x91, 0x01, 0xa3, 0x5f, 0x0e, 0x88, 0x7b, 0x4f, 0x44, + 0x5b, 0x0f, 0xe6, 0xd8, 0x81, 0x37, 0x44, 0xdd, 0x0a, 0xdc, 0xd8, 0xc1, + 0x00, 0x80, 0x01, 0xff, 0x49, 0x66, 0xbc, 0xe2, 0xd8, 0x01, 0x06, 0x5d, + 0x14, 0x17, 0x06, 0x63, 0x14, 0x01, 0xff, 0x44, 0xa3, 0x1c, 0xe0, 0xd8, + 0x01, 0x49, 0xbb, 0x19, 0xdf, 0xd8, 0x01, 0x48, 0x51, 0x27, 0xde, 0xd8, + 0x41, 0x44, 0xa3, 0x1c, 0xe1, 0xd8, 0x01, 0x45, 0x34, 0x6b, 0xe3, 0xd8, + 0x41, 0x0a, 0x18, 0x7f, 0x01, 0xff, 0x46, 0x34, 0x6b, 0x43, 0xd8, 0x01, + 0x42, 0x50, 0x02, 0x31, 0xd8, 0x41, 0x44, 0xa3, 0x1c, 0xe5, 0xd8, 0x01, + 0x48, 0x91, 0x4f, 0xe4, 0xd8, 0x41, 0x45, 0x13, 0x03, 0xeb, 0xd8, 0x81, + 0x23, 0xb5, 0x01, 0xff, 0x4e, 0x16, 0x7f, 0x37, 0xd8, 0x01, 0xb2, 0x01, + 0xff, 0x45, 0x8a, 0xca, 0xe7, 0xd8, 0x01, 0x09, 0x6c, 0x14, 0x01, 0xff, + 0x46, 0x75, 0x14, 0xe8, 0xd8, 0x01, 0x45, 0xf5, 0x1b, 0xea, 0xd8, 0x41, + 0x4b, 0x19, 0x7f, 0x3c, 0xd8, 0x41, 0x4c, 0xa0, 0x94, 0x3b, 0xd8, 0x01, + 0x4d, 0xb5, 0x8b, 0x3a, 0xd8, 0x41, 0x4d, 0xa9, 0x44, 0x09, 0xd8, 0x01, + 0x4a, 0xb0, 0x19, 0xba, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x44, 0xa3, 0x1c, + 0x10, 0xd8, 0x81, 0xe8, 0x01, 0xa3, 0x7d, 0x46, 0x34, 0x6b, 0x12, 0xd8, + 0x81, 0x70, 0x46, 0xb4, 0x19, 0xa4, 0xd8, 0x01, 0xb2, 0x4c, 0x53, 0x91, + 0x4f, 0x20, 0xd8, 0x01, 0x45, 0x63, 0x14, 0x1e, 0xd8, 0x81, 0x06, 0x57, + 0x49, 0x33, 0x27, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x46, 0x9b, 0x0c, 0x3f, + 0xd8, 0x81, 0x29, 0x44, 0xa3, 0x1c, 0x22, 0xd8, 0x01, 0xa3, 0x0f, 0xa8, + 0x01, 0xff, 0x45, 0x35, 0x6b, 0x2b, 0xd8, 0x01, 0x45, 0x26, 0x71, 0x2a, + 0xd8, 0x41, 0x46, 0x14, 0x16, 0x29, 0xd8, 0x01, 0x4f, 0x7c, 0x74, 0x3d, + 0xd8, 0x01, 0x45, 0x0a, 0x82, 0x28, 0xd8, 0x41, 0x44, 0xc6, 0x11, 0x3e, + 0xd8, 0x41, 0x4e, 0xa9, 0x44, 0x11, 0xd8, 0x01, 0x43, 0xa1, 0x01, 0x86, + 0xd8, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x44, 0xa3, 0x1c, 0x8b, 0xd8, 0x01, + 0x49, 0xbb, 0x19, 0x8c, 0xd8, 0x41, 0x52, 0xc5, 0x51, 0x23, 0xd8, 0x41, + 0x48, 0xbc, 0x19, 0x15, 0xd8, 0x81, 0x18, 0x04, 0x8f, 0x08, 0x01, 0xff, + 0x47, 0xb3, 0x19, 0xa9, 0xd8, 0x01, 0x42, 0x05, 0x00, 0x1a, 0xd8, 0xc1, + 0x00, 0x4b, 0xcc, 0x51, 0x33, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x46, 0xb4, + 0xe0, 0x18, 0xd8, 0x81, 0x3a, 0x46, 0x34, 0x6b, 0x19, 0xd8, 0x81, 0x2d, + 0x4a, 0x36, 0xb1, 0x16, 0xd8, 0x01, 0x4b, 0xb2, 0xa4, 0x17, 0xd8, 0x01, + 0x06, 0x63, 0x14, 0x01, 0xff, 0x47, 0x59, 0x33, 0x34, 0xd8, 0x01, 0x44, + 0xdd, 0x0a, 0x2d, 0xd8, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x44, 0xa3, 0x1c, + 0x2f, 0xd8, 0x01, 0x49, 0xbb, 0x19, 0x2e, 0xd8, 0x41, 0x4b, 0xcc, 0x51, + 0x32, 0xd8, 0x41, 0x4e, 0x52, 0x33, 0x35, 0xd8, 0x41, 0x4f, 0xfc, 0x6c, + 0x21, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x43, 0x13, 0x01, 0x0c, 0xd8, 0x01, + 0x49, 0x1b, 0x7f, 0x14, 0xd8, 0xc1, 0x00, 0x4b, 0xcc, 0x51, 0x26, 0xd8, + 0x41, 0x4c, 0xfc, 0x8f, 0x1d, 0xd8, 0x41, 0x45, 0x13, 0x03, 0x76, 0xd8, + 0x81, 0xca, 0x01, 0x43, 0x5f, 0xda, 0x66, 0xd8, 0x81, 0x8f, 0x01, 0xb5, + 0x01, 0xff, 0xf0, 0x6d, 0xd8, 0x81, 0x1c, 0x46, 0x89, 0xca, 0x75, 0xd8, + 0xc1, 0x00, 0x80, 0x01, 0xff, 0x54, 0x57, 0x45, 0xbc, 0xd8, 0x01, 0x55, + 0x0c, 0x3f, 0xcf, 0xd8, 0x01, 0x44, 0xf6, 0x04, 0x74, 0xd8, 0x41, 0x80, + 0x01, 0xff, 0x53, 0xb5, 0x4b, 0x53, 0xd8, 0x81, 0x5b, 0x45, 0x5d, 0x14, + 0x02, 0xd8, 0x81, 0x3e, 0x52, 0xa8, 0x19, 0xd0, 0xd8, 0x01, 0x48, 0x7f, + 0xce, 0x71, 0xd8, 0x01, 0x44, 0xf6, 0x04, 0x6c, 0xd8, 0x81, 0x11, 0x06, + 0x63, 0x14, 0x01, 0xff, 0x47, 0x59, 0x33, 0x73, 0xd8, 0x01, 0x44, 0xdd, + 0x0a, 0x6f, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x48, 0x7f, 0xce, 0x70, 0xd8, + 0x01, 0x06, 0x63, 0x14, 0x01, 0xff, 0x47, 0x59, 0x33, 0x72, 0xd8, 0x01, + 0x44, 0xdd, 0x0a, 0x6e, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x4b, 0xaf, 0x19, + 0xc0, 0xd8, 0x01, 0x45, 0x63, 0x14, 0xec, 0xd8, 0xc1, 0x00, 0x45, 0xf5, + 0x04, 0xed, 0xd8, 0x41, 0x45, 0xf5, 0x04, 0x54, 0xd8, 0x41, 0x80, 0x01, + 0xff, 0x56, 0x8c, 0x1c, 0x49, 0xd8, 0x01, 0x5e, 0x5d, 0x14, 0xe9, 0xd8, + 0x01, 0x5c, 0xa8, 0x19, 0xd6, 0xd8, 0x81, 0x17, 0x48, 0x7f, 0xce, 0x68, + 0xd8, 0x01, 0x06, 0x63, 0x14, 0x01, 0xff, 0x47, 0x59, 0x33, 0x69, 0xd8, + 0x01, 0x44, 0xdd, 0x0a, 0x67, 0xd8, 0x41, 0x45, 0x63, 0x40, 0xd7, 0xd8, + 0x41, 0x80, 0x01, 0xff, 0x45, 0x5d, 0x14, 0x01, 0xd8, 0x81, 0x2d, 0x07, + 0xb4, 0x19, 0x1d, 0x07, 0x7d, 0x02, 0x06, 0x4b, 0xaf, 0x19, 0xb1, 0xd8, + 0x41, 0x4b, 0xaf, 0x19, 0xce, 0xd8, 0x81, 0x06, 0x42, 0x50, 0x02, 0xc7, + 0xd8, 0x41, 0x45, 0xa2, 0x1c, 0xd5, 0xd8, 0x41, 0x45, 0x5d, 0x14, 0xa1, + 0xd8, 0x01, 0x42, 0x50, 0x02, 0x94, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x44, + 0xa3, 0x1c, 0x07, 0xd8, 0x01, 0x45, 0x34, 0x6b, 0x0d, 0xd8, 0x01, 0x46, + 0x7d, 0x02, 0x0f, 0xd8, 0x81, 0x06, 0x4b, 0xaf, 0x19, 0xbb, 0xd8, 0x41, + 0x80, 0x01, 0xff, 0x05, 0x8e, 0x08, 0x12, 0x46, 0xb4, 0x19, 0xa5, 0xd8, + 0x01, 0x44, 0x22, 0x08, 0x87, 0xd8, 0x01, 0x45, 0x63, 0x14, 0x1f, 0xd8, + 0x41, 0x47, 0xb3, 0x19, 0xaa, 0xd8, 0x01, 0x42, 0x05, 0x00, 0x1b, 0xd8, + 0x41, 0x80, 0x01, 0xff, 0x45, 0x5d, 0x14, 0x05, 0xd8, 0x81, 0x45, 0x07, + 0xb4, 0x19, 0x27, 0x52, 0xa8, 0x19, 0xd4, 0xd8, 0x81, 0x11, 0x05, 0x22, + 0x08, 0x01, 0xff, 0x5d, 0x53, 0x16, 0xad, 0xd8, 0x01, 0x46, 0xb4, 0x19, + 0xb3, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x42, 0x9e, 0x01, 0xd3, 0xd8, 0x01, + 0x43, 0x28, 0x08, 0xd2, 0xd8, 0x41, 0x45, 0x5d, 0x14, 0xa3, 0xd8, 0x81, + 0x06, 0x42, 0x50, 0x02, 0x96, 0xd8, 0x41, 0x52, 0xd7, 0x51, 0x9f, 0xd8, + 0xc1, 0x00, 0x44, 0xc6, 0x11, 0x9e, 0xd8, 0x41, 0x80, 0x01, 0xff, 0x07, + 0x7d, 0x02, 0x23, 0x4b, 0xaf, 0x19, 0xc3, 0xd8, 0x81, 0x16, 0x45, 0x63, + 0x14, 0xf4, 0xd8, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x42, 0x9e, 0x01, 0xf3, + 0xd8, 0x01, 0x43, 0x28, 0x08, 0xf2, 0xd8, 0x41, 0x44, 0xc6, 0x11, 0xc2, + 0xd8, 0x41, 0x46, 0xb4, 0x19, 0xa8, 0xd8, 0x01, 0x44, 0x22, 0x08, 0x89, + 0xd8, 0x41, 0x47, 0xe5, 0x09, 0x0a, 0xd9, 0x01, 0x48, 0x97, 0x46, 0x09, + 0xd9, 0x01, 0x46, 0x04, 0x0a, 0x08, 0xd9, 0x41, 0x1c, 0xe8, 0x17, 0x72, + 0xa9, 0x52, 0xac, 0x1c, 0x08, 0x17, 0xcf, 0x06, 0x48, 0x50, 0x17, 0x88, + 0xda, 0x41, 0x47, 0xd2, 0xd5, 0x12, 0xda, 0x01, 0x47, 0x01, 0x93, 0x11, + 0xda, 0x01, 0x48, 0x57, 0xd2, 0x13, 0xda, 0x41, 0x04, 0xfe, 0x07, 0x06, + 0x5a, 0x8d, 0x22, 0x70, 0xda, 0x41, 0x06, 0x49, 0x1d, 0x1a, 0xb3, 0x01, + 0xff, 0x49, 0x78, 0x6f, 0x1f, 0xd9, 0x01, 0x05, 0x5e, 0x07, 0x01, 0xff, + 0x48, 0x97, 0x46, 0x1e, 0xd9, 0x01, 0x46, 0x04, 0x0a, 0x1c, 0xd9, 0x41, + 0x48, 0x97, 0x46, 0x1d, 0xd9, 0x01, 0x46, 0x04, 0x0a, 0x1b, 0xd9, 0x41, + 0x0c, 0x14, 0x96, 0x06, 0x44, 0xff, 0x09, 0x7e, 0xda, 0x41, 0xd2, 0x9b, + 0xda, 0x01, 0xd3, 0x9c, 0xda, 0x01, 0xd4, 0x9d, 0xda, 0x01, 0xd5, 0x9e, + 0xda, 0x01, 0xd6, 0x9f, 0xda, 0x41, 0x4f, 0x44, 0x70, 0x07, 0xda, 0x01, + 0x4a, 0x70, 0xb8, 0x08, 0xda, 0xc1, 0x00, 0x48, 0xdc, 0x0d, 0x09, 0xda, + 0x41, 0x43, 0x96, 0x1b, 0x30, 0xda, 0x01, 0x49, 0x43, 0xc7, 0x6c, 0xda, + 0x01, 0x02, 0x4d, 0x00, 0x01, 0xff, 0x80, 0xb2, 0x01, 0x0f, 0xbe, 0x6e, + 0x9b, 0x01, 0x05, 0x88, 0xec, 0x4e, 0x07, 0x8e, 0xd8, 0x38, 0x02, 0x31, + 0x01, 0x01, 0xff, 0x46, 0x30, 0x0e, 0x16, 0xda, 0x01, 0x05, 0x22, 0x00, + 0x1d, 0x44, 0xf6, 0x04, 0x14, 0xda, 0x01, 0x48, 0xe7, 0xd0, 0x15, 0xda, + 0x01, 0x04, 0xf7, 0x1c, 0x01, 0xff, 0x45, 0xf5, 0x04, 0x1a, 0xda, 0x01, + 0x4d, 0xbe, 0x8a, 0x1c, 0xda, 0x41, 0x46, 0x30, 0x0e, 0x1b, 0xda, 0x01, + 0x44, 0xf6, 0x04, 0x19, 0xda, 0x41, 0x44, 0xa5, 0x01, 0x1f, 0xda, 0x01, + 0x4a, 0xa2, 0x49, 0x20, 0xda, 0x01, 0x42, 0x50, 0x02, 0x1e, 0xda, 0x41, + 0x0b, 0xc8, 0x4b, 0x29, 0x0a, 0x4a, 0x1f, 0x01, 0xff, 0xa3, 0x16, 0x48, + 0x91, 0x4f, 0x21, 0xda, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x4b, 0x94, 0x5c, + 0x23, 0xda, 0x01, 0x46, 0x3b, 0x01, 0x22, 0xda, 0x41, 0x47, 0x98, 0x0b, + 0x29, 0xda, 0x01, 0x45, 0xe2, 0x23, 0x27, 0xda, 0x41, 0x46, 0xb2, 0x30, + 0x28, 0xda, 0x01, 0x48, 0x91, 0x4f, 0x24, 0xda, 0xc1, 0x00, 0x80, 0x01, + 0xff, 0x4b, 0x94, 0x5c, 0x26, 0xda, 0x01, 0x46, 0x3b, 0x01, 0x25, 0xda, + 0x41, 0x44, 0xa5, 0x01, 0x0c, 0xda, 0x01, 0x47, 0x01, 0x93, 0x0b, 0xda, + 0x01, 0x42, 0x50, 0x02, 0x0a, 0xda, 0x41, 0x06, 0x24, 0xe0, 0x06, 0x44, + 0x69, 0xaa, 0x1d, 0xda, 0x41, 0x48, 0x97, 0x46, 0x18, 0xda, 0x01, 0x46, + 0x04, 0x0a, 0x17, 0xda, 0x41, 0x0f, 0x7b, 0x75, 0x48, 0x07, 0xdc, 0xdd, + 0x01, 0xff, 0x0a, 0x0e, 0x0f, 0x33, 0x50, 0xfa, 0x65, 0xfd, 0xd9, 0x01, + 0x44, 0x98, 0xf5, 0xf7, 0xd9, 0x01, 0x47, 0x30, 0xd7, 0xfe, 0xd9, 0x01, + 0x47, 0x8c, 0x45, 0xfa, 0xd9, 0x01, 0xb3, 0x06, 0x45, 0x1f, 0xf1, 0xf9, + 0xd9, 0x41, 0x4b, 0xa2, 0xa2, 0xfb, 0xd9, 0x81, 0x06, 0x43, 0x13, 0x01, + 0xf8, 0xd9, 0x41, 0x4c, 0x93, 0x5c, 0xfc, 0xd9, 0x41, 0x45, 0x49, 0x1d, + 0xf6, 0xd9, 0x01, 0x45, 0x5d, 0x07, 0xf5, 0xd9, 0x41, 0x4c, 0xfc, 0x92, + 0x0e, 0xda, 0x01, 0x08, 0x64, 0x97, 0x06, 0x4a, 0x66, 0xb8, 0x0f, 0xda, + 0x41, 0x44, 0xa5, 0x01, 0x0d, 0xda, 0x01, 0x42, 0x50, 0x02, 0x10, 0xda, + 0x41, 0x06, 0x5c, 0xa5, 0x0f, 0xaf, 0x01, 0xff, 0x43, 0xd7, 0x02, 0x8a, + 0xda, 0x01, 0x43, 0x15, 0x05, 0x87, 0xda, 0x41, 0x47, 0x01, 0x93, 0x2b, + 0xda, 0x01, 0x46, 0x40, 0xe5, 0x2a, 0xda, 0x01, 0x46, 0x30, 0xe6, 0x2c, + 0xda, 0x41, 0x05, 0x70, 0x52, 0x17, 0x04, 0x8a, 0xf0, 0x01, 0xff, 0x47, + 0xe5, 0x09, 0x10, 0xd9, 0x01, 0x48, 0x97, 0x46, 0x0f, 0xd9, 0x01, 0x46, + 0x04, 0x0a, 0x0e, 0xd9, 0x41, 0x46, 0x80, 0xe1, 0x3a, 0xda, 0x01, 0x46, + 0xe8, 0xe2, 0x39, 0xda, 0x41, 0x04, 0x70, 0x91, 0x11, 0x04, 0x30, 0xe6, + 0x01, 0xff, 0x50, 0x1a, 0x63, 0x38, 0xda, 0x01, 0x46, 0x12, 0x0d, 0x36, + 0xda, 0x41, 0x50, 0x1a, 0x63, 0x37, 0xda, 0x01, 0x47, 0x8f, 0x6a, 0x35, + 0xda, 0x41, 0x05, 0x89, 0xeb, 0xb4, 0x01, 0xa5, 0x01, 0xff, 0x0c, 0xe8, + 0x9a, 0x3e, 0x05, 0x2b, 0x48, 0x01, 0xff, 0x06, 0x0c, 0x03, 0x1d, 0x06, + 0xad, 0x02, 0x01, 0xff, 0x53, 0x69, 0x4b, 0x9f, 0xf5, 0x01, 0x53, 0x31, + 0x4d, 0x98, 0xf5, 0x01, 0x54, 0xb1, 0x23, 0x99, 0xf5, 0x01, 0x51, 0x78, + 0x61, 0x9e, 0xf5, 0x41, 0x53, 0x69, 0x4b, 0xa1, 0xf5, 0x01, 0x53, 0x31, + 0x4d, 0x9a, 0xf5, 0x01, 0x54, 0xb1, 0x23, 0x9b, 0xf5, 0x01, 0x51, 0x78, + 0x61, 0xa0, 0xf5, 0x41, 0x90, 0x49, 0x91, 0x1f, 0x92, 0x01, 0xff, 0xd0, + 0x53, 0x09, 0x01, 0xd1, 0x54, 0x09, 0x01, 0xd2, 0x55, 0x09, 0x01, 0xd3, + 0x56, 0x09, 0x01, 0xd4, 0x57, 0x09, 0x01, 0xd5, 0x58, 0x09, 0x01, 0xd6, + 0x59, 0x09, 0x41, 0xd0, 0x49, 0x09, 0x01, 0xd1, 0x4a, 0x09, 0x01, 0xd2, + 0x4b, 0x09, 0x01, 0xd3, 0x4c, 0x09, 0x01, 0xd4, 0x4d, 0x09, 0x01, 0xd5, + 0x4e, 0x09, 0x01, 0xd6, 0x4f, 0x09, 0x01, 0xd7, 0x50, 0x09, 0x01, 0xd8, + 0x51, 0x09, 0x01, 0xd9, 0x52, 0x09, 0x41, 0xd1, 0x40, 0x09, 0x01, 0xd2, + 0x41, 0x09, 0x01, 0xd3, 0x42, 0x09, 0x01, 0xd4, 0x43, 0x09, 0x01, 0xd5, + 0x44, 0x09, 0x01, 0xd6, 0x45, 0x09, 0x01, 0xd7, 0x46, 0x09, 0x01, 0xd8, + 0x47, 0x09, 0x01, 0xd9, 0x48, 0x09, 0x41, 0xa4, 0xb8, 0x04, 0x50, 0x9a, + 0x65, 0xc9, 0x15, 0x01, 0x07, 0x13, 0x06, 0x86, 0x02, 0x10, 0x7a, 0x69, + 0xf5, 0x01, 0xb3, 0x43, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xa1, 0x25, 0xe5, + 0xb8, 0x15, 0x01, 0xe9, 0xb0, 0x15, 0x81, 0x18, 0xef, 0xba, 0x15, 0x01, + 0xf5, 0xb2, 0x15, 0x81, 0x0b, 0x49, 0xf2, 0xc6, 0xb4, 0x15, 0xc1, 0x00, + 0xf2, 0xb5, 0x15, 0x41, 0xf5, 0xb3, 0x15, 0x41, 0xe9, 0xb1, 0x15, 0x41, + 0xe1, 0xaf, 0x15, 0x01, 0xe9, 0xb9, 0x15, 0x01, 0x4a, 0x0c, 0xb3, 0xdc, + 0x15, 0x81, 0x04, 0xf5, 0xbb, 0x15, 0x41, 0xf5, 0xdd, 0x15, 0x41, 0xa5, + 0x2e, 0x04, 0x5b, 0x03, 0x01, 0xff, 0x48, 0x0a, 0x17, 0xbd, 0x15, 0x01, + 0x4b, 0x13, 0x25, 0xbc, 0x15, 0x01, 0x45, 0x62, 0x41, 0xc0, 0x15, 0x01, + 0x47, 0xc8, 0xdb, 0xc1, 0x15, 0x01, 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, + 0x21, 0x25, 0xbf, 0x15, 0x01, 0x45, 0x49, 0x4e, 0xbe, 0x15, 0x41, 0x0b, + 0xb6, 0x9f, 0x11, 0x08, 0xfd, 0x21, 0x01, 0xff, 0x43, 0x16, 0x00, 0xc5, + 0x15, 0x01, 0x43, 0x48, 0x0a, 0xc4, 0x15, 0x41, 0x4b, 0x5b, 0xa0, 0xcf, + 0x15, 0x81, 0x5e, 0x05, 0x51, 0x00, 0x01, 0xff, 0x0c, 0x0c, 0x92, 0x43, + 0x50, 0xda, 0x64, 0xd1, 0x15, 0x01, 0x53, 0x9a, 0x4e, 0xd3, 0x15, 0x01, + 0x10, 0x5a, 0x69, 0x21, 0x52, 0x89, 0x57, 0xd4, 0x15, 0x01, 0x03, 0x19, + 0x01, 0x01, 0xff, 0x09, 0x35, 0xbd, 0x06, 0x4d, 0xa0, 0x4e, 0xd2, 0x15, + 0x41, 0x50, 0xca, 0x64, 0xcb, 0x15, 0x01, 0x52, 0x97, 0x58, 0xca, 0x15, + 0x41, 0x49, 0xa4, 0x4e, 0xcc, 0x15, 0x01, 0x50, 0xda, 0x64, 0xcd, 0x15, + 0x01, 0x50, 0xda, 0x6a, 0xce, 0x15, 0x41, 0x4f, 0x71, 0x70, 0xd7, 0x15, + 0x01, 0x44, 0x5a, 0x69, 0xd5, 0x15, 0x01, 0x4e, 0x8c, 0x81, 0xd6, 0x15, + 0x41, 0x4a, 0x6e, 0x9b, 0xd0, 0x15, 0x41, 0xd1, 0xc6, 0x15, 0x01, 0xd2, + 0xc7, 0x15, 0x01, 0xd3, 0xc8, 0x15, 0x41, 0xe1, 0x80, 0x15, 0x81, 0x8f, + 0x02, 0xa2, 0x82, 0x02, 0xa3, 0xf5, 0x01, 0xa4, 0xdc, 0x01, 0xe5, 0x8a, + 0x15, 0x01, 0xa7, 0xcb, 0x01, 0x42, 0x22, 0x00, 0xae, 0x15, 0x01, 0xe9, + 0x82, 0x15, 0x81, 0xbb, 0x01, 0xaa, 0xae, 0x01, 0xab, 0xa1, 0x01, 0x42, + 0x74, 0x00, 0xa9, 0x15, 0x01, 0x42, 0x6c, 0x00, 0xa6, 0x15, 0x01, 0xae, + 0x7d, 0xef, 0x8c, 0x15, 0x01, 0xb0, 0x6d, 0x42, 0x71, 0x00, 0xa8, 0x15, + 0x01, 0xb3, 0x55, 0xb4, 0x2c, 0xf5, 0x84, 0x15, 0x81, 0x23, 0xb6, 0x06, + 0x42, 0xdf, 0x23, 0xa7, 0x15, 0x41, 0xe1, 0xaa, 0x15, 0x01, 0x07, 0xf3, + 0xc6, 0x01, 0xff, 0xec, 0x88, 0x15, 0x81, 0x09, 0xf2, 0x86, 0x15, 0xc1, + 0x00, 0xf2, 0x87, 0x15, 0x41, 0xec, 0x89, 0x15, 0x41, 0xf5, 0x85, 0x15, + 0x41, 0xe1, 0x9d, 0x15, 0x01, 0xa8, 0x17, 0xb4, 0x0b, 0x55, 0x43, 0x41, + 0xd9, 0x15, 0xc1, 0x00, 0xe9, 0xda, 0x15, 0x41, 0xe1, 0x98, 0x15, 0x01, + 0x42, 0x22, 0x00, 0x99, 0x15, 0x41, 0xe1, 0x9e, 0x15, 0x01, 0x56, 0xd1, + 0x38, 0xd8, 0x15, 0x41, 0xe1, 0xad, 0x15, 0x01, 0x42, 0x22, 0x00, 0xab, + 0x15, 0x01, 0x42, 0x40, 0x06, 0xac, 0x15, 0x41, 0xe1, 0xa2, 0x15, 0x01, + 0x42, 0x22, 0x00, 0xa3, 0x15, 0x41, 0xe1, 0xa1, 0x15, 0x01, 0x42, 0x24, + 0x02, 0x92, 0x15, 0x01, 0x42, 0x2a, 0x05, 0x9c, 0x15, 0x01, 0x42, 0xdf, + 0x23, 0x97, 0x15, 0x41, 0xe1, 0x8e, 0x15, 0x01, 0x42, 0x22, 0x00, 0x8f, + 0x15, 0x41, 0xe1, 0x95, 0x15, 0x01, 0x42, 0x22, 0x00, 0x96, 0x15, 0x41, + 0xe9, 0x83, 0x15, 0x41, 0xe1, 0x90, 0x15, 0x01, 0x42, 0x22, 0x00, 0x91, + 0x15, 0x41, 0xe1, 0x9f, 0x15, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0xa0, + 0x15, 0x41, 0xe1, 0x9a, 0x15, 0x01, 0x42, 0x22, 0x00, 0x9b, 0x15, 0x41, + 0xe1, 0x93, 0x15, 0x01, 0x42, 0x22, 0x00, 0x94, 0x15, 0x41, 0xe1, 0xa4, + 0x15, 0x01, 0x42, 0x22, 0x00, 0xa5, 0x15, 0x41, 0xe1, 0x81, 0x15, 0x01, + 0xe9, 0x8b, 0x15, 0x01, 0x4a, 0x0c, 0xb3, 0xdb, 0x15, 0x01, 0xf5, 0x8d, + 0x15, 0x41, 0x44, 0x96, 0x21, 0xc2, 0x15, 0x01, 0x4b, 0x33, 0xa6, 0xc3, + 0x15, 0x41, 0xa1, 0xf5, 0x01, 0x43, 0xd8, 0x36, 0x11, 0xf4, 0x01, 0xa9, + 0xcc, 0x01, 0xaf, 0x18, 0xb2, 0x0a, 0x4d, 0x18, 0x8e, 0xe2, 0x29, 0x00, + 0xf9, 0xad, 0x00, 0x40, 0x43, 0x13, 0x1d, 0x90, 0xf9, 0x01, 0x42, 0x81, + 0x0f, 0x37, 0xf9, 0x41, 0x5d, 0xdf, 0x15, 0x2f, 0xf9, 0x01, 0x4a, 0xc4, + 0xb4, 0x20, 0xf3, 0x01, 0x06, 0xc8, 0x31, 0x95, 0x01, 0x02, 0x34, 0x00, + 0x12, 0x50, 0x0a, 0x6b, 0x7d, 0x23, 0x00, 0x43, 0xd7, 0x00, 0x8f, 0xfa, + 0x01, 0x43, 0x15, 0x01, 0xbf, 0xf6, 0x41, 0x80, 0x26, 0x44, 0xfd, 0x2d, + 0x70, 0xf3, 0x01, 0x0c, 0x34, 0x94, 0x04, 0xf3, 0x73, 0xfa, 0x41, 0x52, + 0x2d, 0x53, 0xa1, 0xbc, 0x01, 0x49, 0x6b, 0xbd, 0xa2, 0xbc, 0x01, 0x4e, + 0x10, 0x7d, 0xa0, 0xbc, 0x01, 0x47, 0xd2, 0xdc, 0xa3, 0xbc, 0x41, 0xa2, + 0x49, 0x49, 0x13, 0x3b, 0xdf, 0x2a, 0x80, 0x3c, 0x04, 0xc3, 0x00, 0x2c, + 0x0b, 0xb3, 0x02, 0x1c, 0x53, 0x7e, 0x4f, 0x4e, 0x2b, 0x00, 0x47, 0xd9, + 0xdc, 0xe0, 0x2a, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x55, 0x07, 0x3b, 0xe9, + 0x2a, 0x00, 0x4d, 0xe2, 0x61, 0xe8, 0x2a, 0x40, 0x5b, 0x63, 0x1b, 0x44, + 0x29, 0x00, 0x64, 0x50, 0x09, 0xd3, 0xf8, 0x41, 0x45, 0x17, 0x3b, 0xde, + 0x2a, 0x00, 0x6b, 0xc3, 0x02, 0xd5, 0xf8, 0x41, 0x4d, 0xbc, 0x83, 0xe7, + 0x2a, 0x40, 0x56, 0x9b, 0x34, 0x4f, 0x2b, 0x00, 0x6c, 0x92, 0x01, 0x5f, + 0x2b, 0x40, 0x44, 0x37, 0x6e, 0xcd, 0xf6, 0x01, 0x47, 0x70, 0xdc, 0xd2, + 0xf6, 0x41, 0x43, 0x57, 0x25, 0xe1, 0xf6, 0x01, 0x03, 0xc5, 0x00, 0x0a, + 0x4a, 0x06, 0xb4, 0xe9, 0x26, 0x00, 0xf0, 0xa2, 0xf6, 0x41, 0x42, 0x9e, + 0x01, 0x0f, 0x00, 0x00, 0x43, 0x28, 0x08, 0x0e, 0x00, 0x40, 0x0c, 0xa7, + 0x02, 0xdc, 0x07, 0x49, 0x17, 0xae, 0xe8, 0xfa, 0x01, 0x50, 0xba, 0x67, + 0x58, 0xf9, 0x01, 0x45, 0xbd, 0xee, 0x18, 0x26, 0x00, 0xb2, 0xbb, 0x02, + 0xb6, 0x01, 0xff, 0x46, 0x0e, 0xe1, 0x67, 0xf3, 0x01, 0x0b, 0xf5, 0x91, + 0x01, 0xff, 0xa1, 0xfc, 0x01, 0x43, 0xfd, 0xf9, 0x5a, 0x04, 0x01, 0x46, + 0x8a, 0xe0, 0x57, 0x04, 0x01, 0x44, 0x68, 0xf5, 0x5b, 0x04, 0x01, 0xa5, + 0xd1, 0x01, 0x43, 0xf6, 0x21, 0x53, 0x04, 0x01, 0x43, 0x0a, 0xb0, 0x5c, + 0x04, 0x01, 0xa8, 0xb6, 0x01, 0xa9, 0xa3, 0x01, 0x45, 0xa5, 0xed, 0x61, + 0x04, 0x01, 0x44, 0xbc, 0xf6, 0x52, 0x04, 0x01, 0x44, 0xfc, 0xf6, 0x64, + 0x04, 0x01, 0xad, 0x82, 0x01, 0x43, 0x18, 0x24, 0x6f, 0x04, 0x01, 0xaf, + 0x5a, 0x44, 0xfc, 0xf7, 0x50, 0x04, 0x01, 0x44, 0x54, 0xf8, 0x6e, 0x04, + 0x01, 0xb3, 0x42, 0xb4, 0x2c, 0x42, 0x50, 0x02, 0x73, 0x04, 0x01, 0x43, + 0x74, 0x3b, 0x5d, 0x04, 0x01, 0x02, 0x15, 0x02, 0x12, 0x02, 0x4d, 0x00, + 0x06, 0x43, 0xdb, 0xfa, 0x5f, 0x04, 0x41, 0xe1, 0x58, 0x04, 0x01, 0xf7, + 0x7f, 0x04, 0x41, 0xe5, 0x62, 0x04, 0x01, 0x42, 0x61, 0x03, 0x6b, 0x04, + 0x41, 0xa8, 0x06, 0x42, 0x1b, 0x05, 0x51, 0x04, 0x41, 0x42, 0xe8, 0x1d, + 0x5e, 0x04, 0x01, 0x43, 0x3f, 0x00, 0x54, 0x04, 0x41, 0xef, 0x55, 0x04, + 0x01, 0x43, 0xe2, 0x11, 0x56, 0x04, 0x41, 0x42, 0x6d, 0x00, 0x74, 0x04, + 0x01, 0x42, 0x62, 0x01, 0x76, 0x04, 0x01, 0xee, 0x6a, 0x04, 0x01, 0x43, + 0xb2, 0x0a, 0x75, 0x04, 0x01, 0xf2, 0x79, 0x04, 0x01, 0x42, 0x29, 0x08, + 0x6c, 0x04, 0x41, 0x46, 0x78, 0x19, 0x60, 0x04, 0x01, 0x43, 0x29, 0x02, + 0x65, 0x04, 0x41, 0x42, 0x1a, 0x00, 0x7e, 0x04, 0x01, 0x42, 0x73, 0x02, + 0x72, 0x04, 0x01, 0xe6, 0x66, 0x04, 0x41, 0x44, 0xbc, 0xf4, 0x63, 0x04, + 0x01, 0x43, 0xe1, 0x47, 0x59, 0x04, 0x41, 0xa1, 0x0c, 0x42, 0x32, 0x13, + 0x67, 0x04, 0x01, 0x42, 0xcf, 0x00, 0x7b, 0x04, 0x41, 0xf2, 0x7d, 0x04, + 0x01, 0xf4, 0x70, 0x04, 0x41, 0x42, 0x3b, 0x01, 0x69, 0x04, 0x01, 0x42, + 0x00, 0x0a, 0x71, 0x04, 0x01, 0xe8, 0x6d, 0x04, 0x01, 0x42, 0x46, 0x00, + 0x7a, 0x04, 0x01, 0xb2, 0x0c, 0x42, 0xa4, 0x02, 0x68, 0x04, 0x01, 0x42, + 0x15, 0x01, 0x77, 0x04, 0x41, 0xe5, 0x78, 0x04, 0x01, 0x43, 0x5a, 0x69, + 0x7c, 0x04, 0x41, 0x04, 0x31, 0x50, 0x04, 0xeb, 0x88, 0xf9, 0x41, 0x51, + 0x5d, 0x5a, 0xc7, 0x11, 0x01, 0x51, 0xe4, 0x5b, 0xdd, 0x11, 0x01, 0xa4, + 0xa3, 0x04, 0xa5, 0x94, 0x04, 0x4a, 0x70, 0x63, 0xdc, 0x11, 0x01, 0x07, + 0x13, 0x06, 0xf1, 0x01, 0x42, 0x14, 0x05, 0xc4, 0x11, 0x01, 0xb3, 0x81, + 0x01, 0x06, 0x74, 0x3b, 0x01, 0xff, 0x4d, 0x70, 0x8a, 0xcb, 0x11, 0x01, + 0x05, 0x5a, 0x03, 0x01, 0xff, 0xa1, 0x63, 0x07, 0x0a, 0x64, 0x57, 0xe5, + 0xbc, 0x11, 0x01, 0xe9, 0xb4, 0x11, 0x81, 0x4a, 0xef, 0xbe, 0x11, 0x81, + 0x3b, 0x4f, 0x30, 0x75, 0xce, 0x11, 0x01, 0x06, 0x33, 0x07, 0x29, 0xf5, + 0xb6, 0x11, 0x81, 0x17, 0x08, 0xf2, 0xc6, 0x01, 0xff, 0xec, 0xba, 0x11, + 0x81, 0x09, 0xf2, 0xb8, 0x11, 0xc1, 0x00, 0xf2, 0xb9, 0x11, 0x41, 0xec, + 0xbb, 0x11, 0x41, 0xe5, 0x62, 0x1b, 0x01, 0xf5, 0xb7, 0x11, 0xc1, 0x00, + 0xe5, 0x63, 0x1b, 0x41, 0xe5, 0x64, 0x1b, 0x01, 0xef, 0x65, 0x1b, 0x41, + 0xe5, 0x60, 0x1b, 0x01, 0x42, 0xce, 0x53, 0x61, 0x1b, 0x41, 0xe9, 0xb5, + 0x11, 0x41, 0xe5, 0x66, 0x1b, 0x01, 0xef, 0x67, 0x1b, 0x41, 0xe1, 0xb3, + 0x11, 0x01, 0xe9, 0xbd, 0x11, 0x01, 0xf5, 0xbf, 0x11, 0x41, 0x4a, 0x08, + 0xad, 0xc9, 0x11, 0x01, 0xa5, 0x4d, 0x04, 0x5b, 0x03, 0x06, 0x49, 0x86, + 0xc6, 0xcd, 0x11, 0x41, 0xa1, 0x35, 0x4b, 0x13, 0x25, 0x80, 0x11, 0x01, + 0x54, 0xa7, 0x45, 0xcf, 0x11, 0x01, 0x4b, 0x10, 0xa3, 0xc2, 0x11, 0x01, + 0x45, 0x62, 0x41, 0xca, 0x11, 0x01, 0x47, 0xc8, 0xdb, 0xdb, 0x11, 0x01, + 0x4b, 0xb9, 0xa9, 0xc3, 0x11, 0x01, 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, + 0x21, 0x25, 0xc0, 0x11, 0x01, 0x45, 0x49, 0x4e, 0x82, 0x11, 0x41, 0x47, + 0x0b, 0x17, 0x81, 0x11, 0x01, 0x47, 0x34, 0x8d, 0xc1, 0x11, 0x41, 0x0b, + 0xc1, 0x9f, 0x06, 0x47, 0xfd, 0x21, 0xc8, 0x11, 0x41, 0xd1, 0xde, 0x11, + 0x01, 0xd2, 0xdf, 0x11, 0x41, 0xe1, 0x83, 0x11, 0x81, 0x86, 0x02, 0xa2, + 0xf9, 0x01, 0xa3, 0xec, 0x01, 0xa4, 0xd3, 0x01, 0xe5, 0x8d, 0x11, 0x01, + 0xa7, 0xc2, 0x01, 0x42, 0x22, 0x00, 0xb2, 0x11, 0x01, 0xe9, 0x85, 0x11, + 0x81, 0xb2, 0x01, 0xaa, 0xa5, 0x01, 0xab, 0x98, 0x01, 0xac, 0x8b, 0x01, + 0x42, 0x6c, 0x00, 0xa9, 0x11, 0x01, 0xae, 0x6d, 0xef, 0x8f, 0x11, 0x01, + 0xb0, 0x5d, 0x42, 0x71, 0x00, 0xab, 0x11, 0x01, 0xb3, 0x45, 0xb4, 0x2c, + 0xf5, 0x87, 0x11, 0x81, 0x23, 0xb6, 0x06, 0x42, 0xdf, 0x23, 0xaa, 0x11, + 0x41, 0xe1, 0xae, 0x11, 0x01, 0x07, 0xf3, 0xc6, 0x01, 0xff, 0xec, 0x8b, + 0x11, 0x81, 0x09, 0xf2, 0x89, 0x11, 0xc1, 0x00, 0xf2, 0x8a, 0x11, 0x41, + 0xec, 0x8c, 0x11, 0x41, 0xf5, 0x88, 0x11, 0x41, 0xe1, 0xa0, 0x11, 0x01, + 0x42, 0x22, 0x00, 0xa1, 0x11, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x9b, 0x11, + 0x01, 0x42, 0x22, 0x00, 0x9c, 0x11, 0x41, 0xe1, 0xb1, 0x11, 0x01, 0x42, + 0x22, 0x00, 0xaf, 0x11, 0x01, 0x42, 0x40, 0x06, 0xb0, 0x11, 0x41, 0xe1, + 0xa5, 0x11, 0x01, 0x42, 0x22, 0x00, 0xa6, 0x11, 0x41, 0xe1, 0xa4, 0x11, + 0x01, 0x42, 0x24, 0x02, 0x95, 0x11, 0x01, 0x42, 0x2a, 0x05, 0x9f, 0x11, + 0x01, 0x42, 0xdf, 0x23, 0x9a, 0x11, 0x41, 0xe1, 0xac, 0x11, 0x01, 0x42, + 0x74, 0x00, 0xad, 0x11, 0x41, 0xe1, 0x91, 0x11, 0x01, 0x42, 0x22, 0x00, + 0x92, 0x11, 0x41, 0xe1, 0x98, 0x11, 0x01, 0x42, 0x22, 0x00, 0x99, 0x11, + 0x41, 0xe9, 0x86, 0x11, 0x41, 0xe1, 0x93, 0x11, 0x01, 0x42, 0x22, 0x00, + 0x94, 0x11, 0x41, 0xe1, 0xa2, 0x11, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, + 0xa3, 0x11, 0x41, 0xe1, 0x9d, 0x11, 0x01, 0x42, 0x22, 0x00, 0x9e, 0x11, + 0x41, 0xe1, 0x96, 0x11, 0x01, 0x42, 0x22, 0x00, 0x97, 0x11, 0x41, 0xe1, + 0xa7, 0x11, 0x01, 0x42, 0x22, 0x00, 0xa8, 0x11, 0x41, 0xe1, 0x84, 0x11, + 0x01, 0xe9, 0x8e, 0x11, 0x01, 0xf5, 0x90, 0x11, 0x41, 0x43, 0xb9, 0xc0, + 0xda, 0x11, 0x01, 0x55, 0x6d, 0x41, 0xcc, 0x11, 0x41, 0x44, 0x96, 0x21, + 0xc5, 0x11, 0x01, 0x05, 0xf0, 0x06, 0x06, 0x4b, 0x33, 0xa6, 0xc6, 0x11, + 0x41, 0x45, 0x7e, 0x0b, 0xd8, 0x11, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, + 0xd9, 0x11, 0x01, 0x43, 0x7a, 0x0b, 0xd1, 0x11, 0x01, 0xb3, 0x14, 0xb4, + 0x06, 0x44, 0x80, 0x1f, 0xd0, 0x11, 0x41, 0x44, 0x25, 0x01, 0xd3, 0x11, + 0x01, 0x42, 0x15, 0x02, 0xd2, 0x11, 0x41, 0x44, 0x06, 0x1f, 0xd7, 0x11, + 0x01, 0x42, 0x09, 0x24, 0xd6, 0x11, 0x41, 0x43, 0xf9, 0x05, 0xd5, 0x11, + 0x01, 0x43, 0xf6, 0x06, 0xd4, 0x11, 0x41, 0x46, 0x12, 0x03, 0x4d, 0x27, + 0x00, 0x4b, 0x73, 0xa3, 0x1e, 0x27, 0x00, 0x44, 0xff, 0x13, 0x30, 0x27, + 0x40, 0xa1, 0xe1, 0x04, 0xa3, 0xb0, 0x04, 0x43, 0x60, 0xa4, 0xf2, 0x2b, + 0x00, 0xa5, 0x9b, 0x04, 0x45, 0xa6, 0x31, 0x13, 0x23, 0x80, 0xcc, 0x03, + 0x44, 0xec, 0xf6, 0x33, 0xf9, 0x01, 0x02, 0x7d, 0x02, 0xaf, 0x03, 0x08, + 0x87, 0xcf, 0x38, 0xb2, 0x2a, 0xb3, 0x1c, 0x02, 0xc6, 0x00, 0x0c, 0x4b, + 0x5e, 0xaa, 0xa1, 0xfa, 0x01, 0x45, 0xae, 0xdb, 0xb9, 0x26, 0x40, 0x45, + 0xb4, 0x20, 0x16, 0x22, 0x00, 0x4e, 0x2a, 0x81, 0x93, 0x00, 0x40, 0x47, + 0x3c, 0xbe, 0x45, 0xfe, 0x00, 0x4b, 0xcd, 0xa6, 0xbc, 0x26, 0x40, 0x65, + 0x07, 0x08, 0x2c, 0xf9, 0x01, 0x49, 0xce, 0xc6, 0x20, 0x21, 0x40, 0x06, + 0xa0, 0x6e, 0x06, 0x46, 0x16, 0x08, 0xfb, 0x2b, 0x40, 0x09, 0x10, 0xc4, + 0xa1, 0x02, 0x08, 0x87, 0xd0, 0x01, 0xff, 0xd1, 0x51, 0xce, 0x81, 0x8b, + 0x01, 0xd2, 0x52, 0xce, 0x81, 0x43, 0xd3, 0x54, 0xce, 0x81, 0x1f, 0xd4, + 0x58, 0xce, 0x81, 0x0d, 0xd5, 0x60, 0xce, 0x81, 0x04, 0xd6, 0x70, 0xce, + 0x41, 0xd6, 0x80, 0xce, 0x41, 0xd5, 0x68, 0xce, 0x81, 0x04, 0xd6, 0x78, + 0xce, 0x41, 0xd6, 0x88, 0xce, 0x41, 0xd4, 0x5c, 0xce, 0x81, 0x0d, 0xd5, + 0x64, 0xce, 0x81, 0x04, 0xd6, 0x74, 0xce, 0x41, 0xd6, 0x84, 0xce, 0x41, + 0xd5, 0x6c, 0xce, 0x81, 0x04, 0xd6, 0x7c, 0xce, 0x41, 0xd6, 0x8c, 0xce, + 0x41, 0xd3, 0x56, 0xce, 0x81, 0x1f, 0xd4, 0x5a, 0xce, 0x81, 0x0d, 0xd5, + 0x62, 0xce, 0x81, 0x04, 0xd6, 0x72, 0xce, 0x41, 0xd6, 0x82, 0xce, 0x41, + 0xd5, 0x6a, 0xce, 0x81, 0x04, 0xd6, 0x7a, 0xce, 0x41, 0xd6, 0x8a, 0xce, + 0x41, 0xd4, 0x5e, 0xce, 0x81, 0x0d, 0xd5, 0x66, 0xce, 0x81, 0x04, 0xd6, + 0x76, 0xce, 0x41, 0xd6, 0x86, 0xce, 0x41, 0xd5, 0x6e, 0xce, 0x81, 0x04, + 0xd6, 0x7e, 0xce, 0x41, 0xd6, 0x8e, 0xce, 0x41, 0xd2, 0x53, 0xce, 0x81, + 0x43, 0xd3, 0x55, 0xce, 0x81, 0x1f, 0xd4, 0x59, 0xce, 0x81, 0x0d, 0xd5, + 0x61, 0xce, 0x81, 0x04, 0xd6, 0x71, 0xce, 0x41, 0xd6, 0x81, 0xce, 0x41, + 0xd5, 0x69, 0xce, 0x81, 0x04, 0xd6, 0x79, 0xce, 0x41, 0xd6, 0x89, 0xce, + 0x41, 0xd4, 0x5d, 0xce, 0x81, 0x0d, 0xd5, 0x65, 0xce, 0x81, 0x04, 0xd6, + 0x75, 0xce, 0x41, 0xd6, 0x85, 0xce, 0x41, 0xd5, 0x6d, 0xce, 0x81, 0x04, + 0xd6, 0x7d, 0xce, 0x41, 0xd6, 0x8d, 0xce, 0x41, 0xd3, 0x57, 0xce, 0x81, + 0x1f, 0xd4, 0x5b, 0xce, 0x81, 0x0d, 0xd5, 0x63, 0xce, 0x81, 0x04, 0xd6, + 0x73, 0xce, 0x41, 0xd6, 0x83, 0xce, 0x41, 0xd5, 0x6b, 0xce, 0x81, 0x04, + 0xd6, 0x7b, 0xce, 0x41, 0xd6, 0x8b, 0xce, 0x41, 0xd4, 0x5f, 0xce, 0x81, + 0x0d, 0xd5, 0x67, 0xce, 0x81, 0x04, 0xd6, 0x77, 0xce, 0x41, 0xd6, 0x87, + 0xce, 0x41, 0xd5, 0x6f, 0xce, 0x81, 0x04, 0xd6, 0x7f, 0xce, 0x41, 0xd6, + 0x8f, 0xce, 0x41, 0xd1, 0x21, 0xcc, 0x81, 0x1f, 0xd2, 0x22, 0xcc, 0x81, + 0x0d, 0xd3, 0x24, 0xcc, 0x81, 0x04, 0xd4, 0x28, 0xcc, 0x41, 0xd4, 0x2c, + 0xcc, 0x41, 0xd3, 0x26, 0xcc, 0x81, 0x04, 0xd4, 0x2a, 0xcc, 0x41, 0xd4, + 0x2e, 0xcc, 0x41, 0xd2, 0x23, 0xcc, 0x81, 0x0d, 0xd3, 0x25, 0xcc, 0x81, + 0x04, 0xd4, 0x29, 0xcc, 0x41, 0xd4, 0x2d, 0xcc, 0x41, 0xd3, 0x27, 0xcc, + 0x81, 0x04, 0xd4, 0x2b, 0xcc, 0x41, 0xd4, 0x2f, 0xcc, 0x41, 0x45, 0xb7, + 0x3d, 0x3b, 0x00, 0x00, 0x61, 0x15, 0x0e, 0x32, 0x2a, 0x00, 0x47, 0xac, + 0xdb, 0xba, 0x26, 0x40, 0x09, 0xaa, 0xbd, 0x01, 0xff, 0x45, 0x7e, 0x0b, + 0xf8, 0xfb, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xf9, 0xfb, 0x01, 0x43, + 0x7a, 0x0b, 0xf1, 0xfb, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, + 0xf0, 0xfb, 0x41, 0x44, 0x25, 0x01, 0xf3, 0xfb, 0x01, 0x42, 0x15, 0x02, + 0xf2, 0xfb, 0x41, 0x44, 0x06, 0x1f, 0xf7, 0xfb, 0x01, 0x42, 0x09, 0x24, + 0xf6, 0xfb, 0x41, 0x43, 0xf9, 0x05, 0xf5, 0xfb, 0x01, 0x43, 0xf6, 0x06, + 0xf4, 0xfb, 0x41, 0x4f, 0x56, 0x6d, 0x48, 0xf6, 0x01, 0x45, 0x93, 0xeb, + 0x31, 0xf3, 0x41, 0x4f, 0x6d, 0x74, 0x48, 0xf9, 0x01, 0xb4, 0x01, 0xff, + 0x48, 0xc1, 0x04, 0xa7, 0x00, 0x00, 0x42, 0x0c, 0x00, 0x14, 0x23, 0xc0, + 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0x2f, 0xeb, 0xf6, 0xce, 0x81, + 0x06, 0x4a, 0xcc, 0x92, 0xf7, 0xce, 0x41, 0x4f, 0x48, 0x6c, 0xf8, 0xce, + 0x41, 0xec, 0xad, 0xf9, 0x01, 0xf4, 0xba, 0xf4, 0x41, 0xa1, 0x8f, 0x01, + 0x44, 0x2b, 0xeb, 0xeb, 0xf3, 0x81, 0x81, 0x01, 0xe9, 0x9a, 0x00, 0x00, + 0xaf, 0x64, 0xb2, 0x01, 0xff, 0xa5, 0x53, 0x04, 0x77, 0x06, 0x0c, 0x43, + 0x09, 0x22, 0xdc, 0xf4, 0x01, 0x44, 0x9f, 0x4e, 0x08, 0x21, 0x40, 0x08, + 0x0b, 0x06, 0x1b, 0x54, 0xbf, 0x20, 0x70, 0xf6, 0x01, 0x06, 0x5d, 0x07, + 0x01, 0xff, 0xe5, 0x2f, 0x21, 0x00, 0xe7, 0x0a, 0x21, 0x00, 0xec, 0x13, + 0x21, 0x00, 0xef, 0x34, 0x21, 0x40, 0xe2, 0x2c, 0x21, 0x00, 0xe5, 0x30, + 0x21, 0x00, 0xe6, 0x31, 0x21, 0x00, 0xe8, 0x0b, 0x21, 0x00, 0xe9, 0x10, + 0x21, 0x00, 0xec, 0x12, 0x21, 0x00, 0xed, 0x33, 0x21, 0x00, 0xf0, 0x18, + 0x21, 0x00, 0xf2, 0x1b, 0x21, 0x40, 0x42, 0x92, 0x01, 0xb5, 0xf5, 0x01, + 0x47, 0x65, 0xdd, 0x9b, 0xfa, 0x41, 0x44, 0xa1, 0xdb, 0xf4, 0xf6, 0x01, + 0x03, 0xa6, 0x4a, 0x01, 0xff, 0x42, 0x10, 0x00, 0x82, 0xf9, 0x01, 0x42, + 0xef, 0x02, 0x4f, 0x26, 0x40, 0x48, 0x37, 0xc8, 0x92, 0xf3, 0x41, 0x43, + 0xec, 0x00, 0x96, 0x26, 0x00, 0x42, 0x17, 0x1d, 0xe3, 0xf9, 0x41, 0x05, + 0x21, 0x79, 0x88, 0x08, 0x49, 0xca, 0xbe, 0x50, 0x26, 0x00, 0x46, 0xc4, + 0xe2, 0xf5, 0x26, 0x00, 0x51, 0xe2, 0x5d, 0x76, 0xf3, 0x01, 0xac, 0xdf, + 0x07, 0x08, 0xde, 0x6d, 0xd6, 0x04, 0xae, 0xa8, 0x04, 0x42, 0x0d, 0x00, + 0x7b, 0xf9, 0x01, 0xb4, 0x8c, 0x04, 0xb5, 0x06, 0x47, 0x9d, 0xdd, 0xb7, + 0xf3, 0x41, 0x4d, 0xf8, 0x85, 0xc1, 0x20, 0x00, 0xb2, 0x01, 0xff, 0x07, + 0xd6, 0xd4, 0x06, 0x44, 0xd4, 0xf7, 0x95, 0xf9, 0x41, 0x54, 0x4f, 0x43, + 0xb4, 0xa8, 0x00, 0xa4, 0x96, 0x03, 0x07, 0x13, 0x06, 0x6f, 0x05, 0x5a, + 0x03, 0x4e, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xa1, 0x3b, 0xe5, 0xbe, 0xa8, + 0x80, 0x32, 0xe9, 0xb6, 0xa8, 0x80, 0x29, 0xef, 0xc1, 0xa8, 0x80, 0x20, + 0xf5, 0xb8, 0xa8, 0x80, 0x17, 0x08, 0xf2, 0xc6, 0x01, 0xff, 0xec, 0xbc, + 0xa8, 0x80, 0x09, 0xf2, 0xba, 0xa8, 0xc0, 0x00, 0xf2, 0xbb, 0xa8, 0x40, + 0xec, 0xbd, 0xa8, 0x40, 0xf5, 0xb9, 0xa8, 0x40, 0xef, 0xc2, 0xa8, 0x40, + 0xe9, 0xb7, 0xa8, 0x40, 0xe5, 0xbf, 0xa8, 0x40, 0xe1, 0xb5, 0xa8, 0x00, + 0xe9, 0xc0, 0xa8, 0x00, 0xf5, 0xc3, 0xa8, 0x40, 0x48, 0x0a, 0x17, 0x80, + 0xa8, 0x00, 0x4b, 0x13, 0x25, 0xc5, 0xa8, 0x00, 0x02, 0x02, 0x00, 0x01, + 0xff, 0x44, 0x21, 0x25, 0xc4, 0xa8, 0x00, 0x45, 0x49, 0x4e, 0x81, 0xa8, + 0x40, 0xe1, 0x82, 0xa8, 0x80, 0x91, 0x02, 0xa2, 0x84, 0x02, 0xa3, 0xf7, + 0x01, 0xa4, 0xde, 0x01, 0xe5, 0x8c, 0xa8, 0x80, 0xd4, 0x01, 0xa7, 0xc7, + 0x01, 0x42, 0x22, 0x00, 0xb2, 0xa8, 0x00, 0xe9, 0x84, 0xa8, 0x80, 0xb7, + 0x01, 0xaa, 0xaa, 0x01, 0xab, 0x9d, 0x01, 0xac, 0x90, 0x01, 0x42, 0x6c, + 0x00, 0xaa, 0xa8, 0x00, 0xae, 0x72, 0xef, 0x8f, 0xa8, 0x80, 0x69, 0xb0, + 0x5d, 0x42, 0x71, 0x00, 0xac, 0xa8, 0x00, 0xb3, 0x45, 0xb4, 0x2c, 0xf5, + 0x86, 0xa8, 0x80, 0x23, 0xb6, 0x06, 0x42, 0xdf, 0x23, 0xab, 0xa8, 0x40, + 0xe1, 0xae, 0xa8, 0x00, 0x07, 0xf3, 0xc6, 0x01, 0xff, 0xec, 0x8a, 0xa8, + 0x80, 0x09, 0xf2, 0x88, 0xa8, 0xc0, 0x00, 0xf2, 0x89, 0xa8, 0x40, 0xec, + 0x8b, 0xa8, 0x40, 0xf5, 0x87, 0xa8, 0x40, 0xe1, 0xa1, 0xa8, 0x00, 0x42, + 0x22, 0x00, 0xa2, 0xa8, 0x00, 0xb4, 0x01, 0xff, 0xe1, 0x9c, 0xa8, 0x00, + 0x42, 0x22, 0x00, 0x9d, 0xa8, 0x40, 0xe1, 0xb1, 0xa8, 0x00, 0x42, 0x22, + 0x00, 0xaf, 0xa8, 0x00, 0x42, 0x40, 0x06, 0xb0, 0xa8, 0x40, 0xe1, 0xa6, + 0xa8, 0x00, 0x42, 0x22, 0x00, 0xa7, 0xa8, 0x40, 0xef, 0x90, 0xa8, 0x40, + 0xe1, 0xa5, 0xa8, 0x00, 0x42, 0x24, 0x02, 0x96, 0xa8, 0x00, 0x42, 0x2a, + 0x05, 0xa0, 0xa8, 0x00, 0x42, 0xdf, 0x23, 0x9b, 0xa8, 0x40, 0xe1, 0xad, + 0xa8, 0x00, 0x42, 0x74, 0x00, 0xb3, 0xa8, 0x40, 0xe1, 0x92, 0xa8, 0x00, + 0x42, 0x22, 0x00, 0x93, 0xa8, 0x40, 0xe1, 0x99, 0xa8, 0x00, 0x42, 0x22, + 0x00, 0x9a, 0xa8, 0x40, 0xe9, 0x85, 0xa8, 0x40, 0xe1, 0x94, 0xa8, 0x00, + 0x42, 0x22, 0x00, 0x95, 0xa8, 0x40, 0xe5, 0x8d, 0xa8, 0x40, 0xe1, 0xa3, + 0xa8, 0x00, 0xa4, 0x06, 0x42, 0x22, 0x00, 0xa4, 0xa8, 0x40, 0xe1, 0x9e, + 0xa8, 0x00, 0x42, 0x22, 0x00, 0x9f, 0xa8, 0x40, 0xe1, 0x97, 0xa8, 0x00, + 0x42, 0x22, 0x00, 0x98, 0xa8, 0x40, 0xe1, 0xa8, 0xa8, 0x00, 0x42, 0x22, + 0x00, 0xa9, 0xa8, 0x40, 0xe1, 0x83, 0xa8, 0x00, 0xe9, 0x8e, 0xa8, 0x00, + 0xf5, 0x91, 0xa8, 0x40, 0x44, 0x96, 0x21, 0xce, 0xa8, 0x00, 0x05, 0xf0, + 0x06, 0x06, 0x4b, 0x33, 0xa6, 0xcf, 0xa8, 0x40, 0x45, 0x7e, 0x0b, 0xd8, + 0xa8, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xd9, 0xa8, 0x00, 0x43, 0x7a, + 0x0b, 0xd1, 0xa8, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xd0, + 0xa8, 0x40, 0x44, 0x25, 0x01, 0xd3, 0xa8, 0x00, 0x42, 0x15, 0x02, 0xd2, + 0xa8, 0x40, 0x44, 0x06, 0x1f, 0xd7, 0xa8, 0x00, 0x42, 0x09, 0x24, 0xd6, + 0xa8, 0x40, 0x43, 0xf9, 0x05, 0xd5, 0xa8, 0x00, 0x43, 0xf6, 0x06, 0xd4, + 0xa8, 0x40, 0x46, 0x20, 0xe1, 0xf0, 0xf6, 0x81, 0x06, 0x43, 0x5d, 0x01, + 0x44, 0x26, 0x40, 0x48, 0xaf, 0xc7, 0xe1, 0xf4, 0x41, 0x45, 0xa2, 0xeb, + 0x6a, 0xf9, 0x01, 0x08, 0xe5, 0x16, 0x01, 0xff, 0x06, 0x3b, 0x16, 0x06, + 0x54, 0xed, 0x16, 0x7a, 0xf6, 0x41, 0x07, 0x3b, 0x01, 0x06, 0x68, 0x08, + 0x05, 0x78, 0xf6, 0x41, 0x5d, 0x13, 0x05, 0x77, 0xf6, 0x01, 0x64, 0x70, + 0x0a, 0x76, 0xf6, 0x41, 0x51, 0x55, 0x52, 0x36, 0x08, 0x00, 0x07, 0x13, + 0x06, 0xf3, 0x01, 0xad, 0xb2, 0x01, 0x0c, 0x3b, 0x17, 0x51, 0x0b, 0xc7, + 0x7a, 0x01, 0xff, 0xe1, 0x23, 0x08, 0x80, 0x43, 0xe5, 0x1d, 0x08, 0x00, + 0xe9, 0x2a, 0x08, 0x00, 0x05, 0xd7, 0x02, 0x22, 0xef, 0x2b, 0x08, 0x80, + 0x12, 0xb3, 0x04, 0xf5, 0x27, 0x08, 0x40, 0x46, 0xc2, 0xdb, 0x25, 0x08, + 0x00, 0x44, 0x0c, 0xf1, 0x2c, 0x08, 0x40, 0x49, 0xbc, 0xc6, 0x21, 0x08, + 0xc0, 0x00, 0xe1, 0x1e, 0x08, 0x40, 0xe1, 0x22, 0x08, 0x80, 0x0c, 0xe5, + 0x1c, 0x08, 0x00, 0xe9, 0x29, 0x08, 0x00, 0xf5, 0x26, 0x08, 0x40, 0xe1, + 0x1f, 0x08, 0x40, 0xe1, 0x20, 0x08, 0x40, 0xa1, 0x3b, 0x43, 0x14, 0xb8, + 0x33, 0x08, 0x00, 0x4d, 0x08, 0x8a, 0x37, 0x08, 0x00, 0x47, 0x59, 0xd9, + 0x30, 0x08, 0x00, 0x45, 0x10, 0x8a, 0x39, 0x08, 0x00, 0xb3, 0x15, 0x44, + 0xc0, 0xf8, 0x3b, 0x08, 0x00, 0xba, 0x01, 0xff, 0x43, 0xe5, 0xf9, 0x3a, + 0x08, 0x00, 0x44, 0x88, 0xf6, 0x38, 0x08, 0x40, 0x49, 0x3f, 0xbf, 0x35, + 0x08, 0x00, 0x4b, 0xaf, 0xa5, 0x3d, 0x08, 0x40, 0x45, 0x6f, 0xec, 0x31, + 0x08, 0x00, 0xae, 0x0c, 0x46, 0xa0, 0xe5, 0x3c, 0x08, 0x00, 0x45, 0x3d, + 0xf1, 0x34, 0x08, 0x40, 0x43, 0x23, 0x13, 0x32, 0x08, 0x00, 0x44, 0x44, + 0xf7, 0x3e, 0x08, 0x40, 0x04, 0xba, 0x00, 0x15, 0x0f, 0xe5, 0x0c, 0x01, + 0xff, 0x4e, 0xee, 0x7a, 0x1a, 0x08, 0x00, 0xe9, 0x28, 0x08, 0x00, 0x47, + 0xc1, 0xdb, 0x24, 0x08, 0x40, 0x46, 0x32, 0x90, 0x19, 0x08, 0x00, 0x4e, + 0xee, 0x7a, 0x1b, 0x08, 0x00, 0x42, 0x9e, 0x01, 0x16, 0x08, 0x80, 0x0c, + 0x47, 0x59, 0xd9, 0x2d, 0x08, 0x00, 0x49, 0x8d, 0xc2, 0x18, 0x08, 0x40, + 0x45, 0xec, 0xe7, 0x17, 0x08, 0x40, 0x44, 0xed, 0xe7, 0x00, 0x08, 0x00, + 0xa2, 0x72, 0x45, 0x94, 0x56, 0x03, 0x08, 0x00, 0x42, 0xf3, 0x02, 0x10, + 0x08, 0x00, 0x45, 0x83, 0xec, 0x02, 0x08, 0x00, 0xa9, 0x52, 0x44, 0xa0, + 0xf6, 0x0a, 0x08, 0x00, 0x45, 0xfa, 0xed, 0x0b, 0x08, 0x00, 0x43, 0x62, + 0x95, 0x0c, 0x08, 0x00, 0x43, 0x18, 0x24, 0x0d, 0x08, 0x00, 0x43, 0x93, + 0xfa, 0x12, 0x08, 0x00, 0x44, 0x9b, 0x56, 0x13, 0x08, 0x00, 0xb3, 0x20, + 0xb4, 0x0c, 0x43, 0xf9, 0x7a, 0x09, 0x08, 0x00, 0x43, 0x94, 0x0a, 0x06, + 0x08, 0x40, 0x43, 0xc9, 0xc8, 0x15, 0x08, 0x00, 0x42, 0x52, 0x00, 0x08, + 0x08, 0x00, 0x46, 0xd0, 0xe5, 0x11, 0x08, 0x40, 0x43, 0x90, 0x00, 0x14, + 0x08, 0x00, 0x46, 0xe2, 0xe2, 0x0e, 0x08, 0x40, 0xee, 0x0f, 0x08, 0x00, + 0xf4, 0x07, 0x08, 0x00, 0xf9, 0x04, 0x08, 0x40, 0x42, 0x4e, 0x13, 0x05, + 0x08, 0x00, 0x42, 0x52, 0x00, 0x01, 0x08, 0x40, 0xb4, 0x06, 0x4a, 0xb6, + 0x98, 0xe1, 0xfa, 0x41, 0x47, 0x47, 0xd3, 0xc2, 0xf9, 0x01, 0x43, 0x16, + 0x0e, 0x13, 0x26, 0x40, 0x43, 0xf6, 0x13, 0xf7, 0xf9, 0x01, 0x44, 0x0f, + 0x61, 0xba, 0xf9, 0x41, 0xa1, 0xc1, 0x21, 0xa5, 0xa4, 0x1b, 0xa8, 0x95, + 0x1b, 0xe9, 0x8d, 0x00, 0x80, 0xf1, 0x0a, 0xac, 0xde, 0x0a, 0xaf, 0x8b, + 0x07, 0xf3, 0x1e, 0x00, 0x00, 0xb5, 0x01, 0xff, 0x48, 0xd7, 0xc9, 0xbd, + 0x20, 0x00, 0x4a, 0xce, 0xaf, 0xc2, 0x20, 0x00, 0x4c, 0xe0, 0x93, 0xc9, + 0xf3, 0x01, 0x4a, 0x12, 0xb2, 0xf4, 0x29, 0x00, 0x03, 0x8a, 0xd7, 0xf3, + 0x04, 0xae, 0x2f, 0x48, 0x6a, 0x84, 0xa8, 0x20, 0x00, 0x1a, 0x43, 0x23, + 0x01, 0xff, 0x48, 0xcf, 0xc9, 0xf6, 0x2b, 0x00, 0x46, 0xd1, 0xc9, 0xf4, + 0x2b, 0x00, 0x48, 0xcf, 0xcf, 0xf5, 0x2b, 0x00, 0x48, 0x7f, 0xd0, 0xf7, + 0x2b, 0x00, 0x49, 0xc9, 0xc5, 0xf8, 0x2b, 0x00, 0x49, 0xd7, 0xc6, 0xf3, + 0x2b, 0x40, 0x03, 0x52, 0x03, 0x0f, 0xae, 0x01, 0xff, 0x42, 0x33, 0x00, + 0xc3, 0xf3, 0x01, 0x53, 0xac, 0x4c, 0xbd, 0xf3, 0x41, 0x4d, 0xcd, 0x84, + 0xee, 0x16, 0x00, 0x4f, 0x55, 0x6e, 0xf0, 0x16, 0x00, 0x51, 0x06, 0x5c, + 0xed, 0x16, 0x00, 0x07, 0x13, 0x06, 0x12, 0x54, 0x97, 0x46, 0xec, 0x16, + 0x00, 0x52, 0xd1, 0x57, 0xeb, 0x16, 0x00, 0x4f, 0x2e, 0x77, 0xef, 0x16, + 0x40, 0xa1, 0xec, 0x03, 0x58, 0xbc, 0x28, 0xd2, 0x16, 0x00, 0xe3, 0xcd, + 0x16, 0x80, 0xc8, 0x03, 0xe4, 0xd1, 0x16, 0x80, 0xab, 0x03, 0xe5, 0xc2, + 0x16, 0x80, 0x8d, 0x03, 0xa6, 0xe1, 0x02, 0xe7, 0xb5, 0x16, 0x80, 0xc8, + 0x02, 0x02, 0x22, 0x00, 0xb7, 0x02, 0xa9, 0x8f, 0x02, 0x47, 0x17, 0xd8, + 0xc3, 0x16, 0x00, 0xeb, 0xf1, 0x16, 0x80, 0xf4, 0x01, 0xac, 0xc8, 0x01, + 0x4c, 0x98, 0x96, 0xd7, 0x16, 0x00, 0x51, 0x03, 0x5f, 0xbe, 0x16, 0x00, + 0xef, 0xae, 0x16, 0x80, 0x98, 0x01, 0x4f, 0x12, 0x75, 0xc8, 0x16, 0x00, + 0xf1, 0xe9, 0x16, 0x00, 0x50, 0x4a, 0x69, 0xb1, 0x16, 0x00, 0xb3, 0x34, + 0xb4, 0x26, 0x49, 0x7d, 0xc6, 0xa2, 0x16, 0x00, 0xf6, 0xa1, 0x16, 0x00, + 0xf7, 0xa5, 0x16, 0x80, 0x11, 0xf8, 0xea, 0x16, 0x00, 0xf9, 0xa4, 0x16, + 0x80, 0x04, 0xfa, 0xce, 0x16, 0x40, 0xf2, 0xa3, 0x16, 0x40, 0x4b, 0xae, + 0xa9, 0xb9, 0x16, 0x40, 0x53, 0x4d, 0x4c, 0xa6, 0x16, 0x00, 0x4e, 0xae, + 0x7c, 0xcf, 0x16, 0x40, 0xe8, 0xf2, 0x16, 0x80, 0x12, 0x56, 0x53, 0x36, + 0xcb, 0x16, 0x00, 0x47, 0x40, 0xda, 0xca, 0x16, 0x00, 0x43, 0x65, 0x0b, + 0xe5, 0x16, 0x40, 0x09, 0x38, 0xc3, 0x01, 0xff, 0x44, 0x17, 0x00, 0xc6, + 0x16, 0x00, 0x49, 0xcb, 0x28, 0xd3, 0x16, 0x00, 0x48, 0x37, 0xcc, 0xbd, + 0x16, 0x00, 0x46, 0xe4, 0xe3, 0xd9, 0x16, 0x00, 0x46, 0x0e, 0x5f, 0xbf, + 0x16, 0x00, 0x45, 0xb1, 0x7f, 0xad, 0x16, 0x00, 0x45, 0x64, 0x36, 0xcc, + 0x16, 0x00, 0x45, 0xb7, 0x7c, 0xd0, 0x16, 0x00, 0x42, 0x28, 0x23, 0xe7, + 0x16, 0x40, 0xe5, 0xaf, 0x16, 0x00, 0xee, 0xb0, 0x16, 0x00, 0xef, 0xf3, + 0x16, 0x00, 0x45, 0xd0, 0xef, 0xd5, 0x16, 0x00, 0x43, 0xf2, 0x01, 0xa9, + 0x16, 0x00, 0x4e, 0xac, 0x80, 0xdf, 0x16, 0x40, 0x51, 0xf6, 0x5a, 0xda, + 0x16, 0x00, 0x0b, 0x59, 0x36, 0x01, 0xff, 0x45, 0x5d, 0xea, 0xc5, 0x16, + 0x00, 0x48, 0x37, 0xcc, 0xbc, 0x16, 0x00, 0x46, 0xe4, 0xe3, 0xd8, 0x16, + 0x00, 0x45, 0xb1, 0x7f, 0xac, 0x16, 0x00, 0x42, 0x28, 0x23, 0xe6, 0x16, + 0x40, 0x03, 0xe0, 0x47, 0x01, 0xff, 0x42, 0x44, 0x00, 0xb4, 0x16, 0x00, + 0xe1, 0xb2, 0x16, 0x40, 0x4b, 0x1c, 0x9f, 0xe8, 0x16, 0x00, 0x42, 0x1d, + 0x01, 0xdd, 0x16, 0x80, 0x12, 0x42, 0x0c, 0x00, 0xe1, 0x16, 0x00, 0x4c, + 0x04, 0x9a, 0xc1, 0x16, 0x00, 0x47, 0x5e, 0xdd, 0xc7, 0x16, 0x40, 0x43, + 0xaf, 0x7c, 0xdc, 0x16, 0x40, 0x45, 0xc5, 0xeb, 0xbb, 0x16, 0x00, 0x46, + 0xfe, 0xe1, 0xba, 0x16, 0x40, 0x42, 0x17, 0x00, 0xb8, 0x16, 0x00, 0xa5, + 0x01, 0xff, 0x49, 0x5d, 0xbc, 0xb7, 0x16, 0x00, 0xf2, 0xc4, 0x16, 0x40, + 0x4d, 0x94, 0x86, 0xa0, 0x16, 0x00, 0x0d, 0x37, 0x8c, 0x01, 0xff, 0xa1, + 0x12, 0x42, 0x4e, 0x00, 0xf6, 0x16, 0x00, 0x42, 0x5f, 0x03, 0xf5, 0x16, + 0x00, 0x42, 0x90, 0x08, 0xf4, 0x16, 0x40, 0xe3, 0xf7, 0x16, 0x00, 0x43, + 0x84, 0x08, 0xf8, 0x16, 0x40, 0x42, 0x17, 0x00, 0xe0, 0x16, 0x00, 0x49, + 0x6c, 0xbf, 0xd6, 0x16, 0x00, 0x42, 0x1d, 0x01, 0xb6, 0x16, 0x00, 0x42, + 0x53, 0x00, 0xa7, 0x16, 0x40, 0x4b, 0xfe, 0x9d, 0xde, 0x16, 0x00, 0x06, + 0xf8, 0x83, 0x01, 0xff, 0xec, 0xdb, 0x16, 0x00, 0xee, 0xc0, 0x16, 0x00, + 0xf0, 0xd4, 0x16, 0x40, 0x43, 0xf1, 0x6e, 0xe3, 0x16, 0x00, 0xa5, 0x06, + 0x46, 0x32, 0xe7, 0xe2, 0x16, 0x40, 0x43, 0xf1, 0x6e, 0xe4, 0x16, 0x00, + 0xee, 0xb3, 0x16, 0x40, 0x43, 0xe3, 0x1c, 0xaa, 0x16, 0x00, 0x43, 0x84, + 0x08, 0xab, 0x16, 0x00, 0x4a, 0x6c, 0xb2, 0xc9, 0x16, 0x00, 0x46, 0x7a, + 0xe4, 0xa8, 0x16, 0x40, 0x06, 0xef, 0x06, 0xb2, 0x01, 0x09, 0x54, 0x2a, + 0x91, 0x01, 0x07, 0x37, 0x3c, 0x01, 0xff, 0x05, 0x7e, 0x0b, 0x7e, 0xa6, + 0x5f, 0x04, 0x6d, 0x2c, 0x4f, 0x4b, 0x3b, 0x12, 0x72, 0x0e, 0x01, 0xb3, + 0x26, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x69, 0x0e, 0x01, 0xa8, 0x0f, + 0xb7, 0x01, 0xff, 0x44, 0xe9, 0x1e, 0x6a, 0x0e, 0x01, 0x49, 0xfb, 0x1e, + 0x73, 0x0e, 0x41, 0x44, 0x49, 0x12, 0x6b, 0x0e, 0x01, 0x4b, 0x01, 0x19, + 0x74, 0x0e, 0x41, 0x04, 0x06, 0x1f, 0x11, 0x02, 0x09, 0x24, 0x01, 0xff, + 0x48, 0x3e, 0x12, 0x77, 0x0e, 0x01, 0x42, 0x4b, 0x12, 0x6e, 0x0e, 0x41, + 0x48, 0x3e, 0x12, 0x78, 0x0e, 0x01, 0x42, 0x4b, 0x12, 0x6f, 0x0e, 0x41, + 0x48, 0x3e, 0x12, 0x7a, 0x0e, 0x01, 0x42, 0x4b, 0x12, 0x71, 0x0e, 0x41, + 0xa9, 0x0f, 0xaf, 0x01, 0xff, 0x43, 0x4a, 0x12, 0x6c, 0x0e, 0x01, 0x4a, + 0x8e, 0xb8, 0x75, 0x0e, 0x41, 0x43, 0x04, 0x24, 0x6d, 0x0e, 0x01, 0x4a, + 0xba, 0x3b, 0x76, 0x0e, 0x41, 0x48, 0x3e, 0x12, 0x79, 0x0e, 0x01, 0xf9, + 0x70, 0x0e, 0x41, 0x04, 0x7a, 0x0b, 0x06, 0x4a, 0xee, 0xb7, 0x7e, 0x0e, + 0x41, 0x44, 0x22, 0x00, 0x7b, 0x0e, 0x01, 0x47, 0x2a, 0x01, 0x7c, 0x0e, + 0x01, 0x45, 0x21, 0x78, 0x7d, 0x0e, 0x41, 0x45, 0x7e, 0x0b, 0x67, 0x0e, + 0x01, 0xa6, 0x29, 0x44, 0x6d, 0x2c, 0x68, 0x0e, 0x01, 0x43, 0x7a, 0x0b, + 0x60, 0x0e, 0x01, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0x62, + 0x0e, 0x01, 0x42, 0x15, 0x02, 0x61, 0x0e, 0x41, 0x44, 0x06, 0x1f, 0x66, + 0x0e, 0x01, 0x42, 0x09, 0x24, 0x65, 0x0e, 0x41, 0x43, 0xf9, 0x05, 0x64, + 0x0e, 0x01, 0x43, 0xf6, 0x06, 0x63, 0x0e, 0x41, 0x52, 0x9d, 0x52, 0x60, + 0xf3, 0x01, 0x48, 0xf7, 0xc9, 0x16, 0xf9, 0x01, 0x42, 0x36, 0x01, 0xa8, + 0xfa, 0x81, 0xb6, 0x03, 0x02, 0x60, 0x07, 0x8c, 0x03, 0x04, 0x47, 0x19, + 0x82, 0x01, 0xaf, 0x74, 0x42, 0x46, 0x03, 0x39, 0xf3, 0x81, 0x67, 0x06, + 0xc2, 0x22, 0x45, 0x03, 0x79, 0x08, 0x06, 0x45, 0x28, 0xf2, 0xa3, 0xf6, + 0x41, 0x80, 0x2d, 0x0e, 0xb6, 0x7a, 0x01, 0xff, 0x43, 0x09, 0xfa, 0x65, + 0xf2, 0x01, 0x42, 0x4f, 0x17, 0x60, 0xf2, 0x01, 0x42, 0x95, 0x16, 0x61, + 0xf2, 0x01, 0x02, 0xa4, 0x02, 0x06, 0x42, 0x70, 0x0d, 0x63, 0xf2, 0x41, + 0x42, 0x3c, 0x01, 0x62, 0xf2, 0x01, 0x46, 0xd2, 0xe6, 0x64, 0xf2, 0x41, + 0x47, 0xe1, 0xda, 0xcd, 0xf4, 0x01, 0x46, 0x66, 0xe6, 0x8b, 0xf7, 0x41, + 0x49, 0xa5, 0xbc, 0x3a, 0x21, 0x00, 0x53, 0xc8, 0x22, 0x67, 0x27, 0x00, + 0x58, 0x9c, 0x2a, 0x65, 0x27, 0x00, 0x5d, 0xc7, 0x16, 0xcd, 0x2b, 0x00, + 0x57, 0xa5, 0x33, 0xcf, 0x2b, 0x40, 0x43, 0x15, 0x06, 0xf5, 0xf3, 0x41, + 0x44, 0xcb, 0x0d, 0x13, 0xf4, 0x01, 0x4b, 0x59, 0xa8, 0xdc, 0xfa, 0x41, + 0x47, 0xcf, 0xd4, 0x9a, 0x01, 0x01, 0x4e, 0xc8, 0x79, 0x9b, 0x01, 0x01, + 0xa4, 0xe4, 0x01, 0x08, 0xb2, 0x5f, 0x33, 0x4e, 0x32, 0x7f, 0x97, 0x01, + 0x01, 0xb3, 0x06, 0x4a, 0xea, 0xa4, 0x91, 0x01, 0x41, 0xa5, 0x06, 0x4b, + 0x97, 0xa2, 0x95, 0x01, 0x41, 0x4b, 0xe9, 0xa4, 0x92, 0x01, 0x01, 0x4d, + 0x89, 0x8d, 0x98, 0x01, 0x01, 0x02, 0xda, 0x06, 0x01, 0xff, 0x48, 0x17, + 0xc9, 0x90, 0x01, 0x01, 0x48, 0x91, 0x4c, 0x93, 0x01, 0x41, 0xa5, 0x9e, + 0x01, 0xa6, 0x68, 0x44, 0x6d, 0x2c, 0x68, 0x21, 0x00, 0x43, 0x7a, 0x0b, + 0x60, 0x21, 0x80, 0x3e, 0x54, 0x73, 0x47, 0x83, 0x21, 0x00, 0xb3, 0x23, + 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x69, 0x21, 0x80, 0x13, 0x44, 0x25, + 0x01, 0x62, 0x21, 0x00, 0xb7, 0x01, 0xff, 0x44, 0x85, 0x2d, 0x6b, 0x21, + 0x00, 0xef, 0x61, 0x21, 0x40, 0x49, 0xdd, 0x1e, 0x82, 0x21, 0x40, 0x44, + 0x06, 0x1f, 0x66, 0x21, 0x00, 0x42, 0x09, 0x24, 0x65, 0x21, 0xc0, 0x00, + 0x4a, 0x32, 0xab, 0x85, 0x21, 0x40, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, + 0x6d, 0x21, 0x80, 0x0d, 0x48, 0xde, 0x1e, 0x6f, 0x21, 0xc0, 0x00, 0x44, + 0xa0, 0xf2, 0x80, 0x21, 0x40, 0x49, 0xdd, 0x1e, 0x88, 0x21, 0x40, 0xa9, + 0x06, 0x43, 0xf6, 0x06, 0x63, 0x21, 0x40, 0x43, 0x04, 0x24, 0x6c, 0x21, + 0x80, 0x16, 0x42, 0x32, 0x00, 0x64, 0x21, 0xc0, 0x00, 0x80, 0x01, 0xff, + 0x47, 0x3f, 0x12, 0x6e, 0x21, 0x00, 0x48, 0xde, 0x1e, 0x81, 0x21, 0x40, + 0x80, 0x01, 0xff, 0x4a, 0xd4, 0xae, 0x86, 0x21, 0x00, 0x48, 0xde, 0x1e, + 0x87, 0x21, 0x40, 0x44, 0xc9, 0x00, 0x67, 0x21, 0x00, 0x45, 0xe7, 0x72, + 0x6a, 0x21, 0x40, 0x4c, 0x44, 0x93, 0x96, 0x01, 0x01, 0x53, 0x86, 0x4c, + 0x94, 0x01, 0x01, 0x4d, 0x32, 0x8e, 0x99, 0x01, 0x41, 0x49, 0xf9, 0xb9, + 0xfb, 0xf9, 0x01, 0xa5, 0x06, 0x59, 0xa2, 0x25, 0x23, 0xf9, 0x41, 0x4e, + 0x1c, 0x7a, 0xde, 0xf5, 0x01, 0x02, 0x18, 0x00, 0x01, 0xff, 0x47, 0xaf, + 0x67, 0xa2, 0xf3, 0x01, 0x45, 0xe8, 0xf0, 0xfc, 0xf6, 0x41, 0x42, 0x14, + 0x06, 0x80, 0xf6, 0x41, 0xe5, 0x2b, 0x20, 0x00, 0xe9, 0x67, 0x20, 0x00, + 0xed, 0x0f, 0x20, 0x00, 0xef, 0x2e, 0x20, 0x40, 0x47, 0x93, 0x4e, 0xfc, + 0xfd, 0x00, 0x44, 0x45, 0x8a, 0x80, 0xf3, 0x81, 0xca, 0x0f, 0x03, 0x0e, + 0x08, 0xb9, 0x0f, 0x43, 0xd5, 0x04, 0x46, 0xf9, 0x01, 0x03, 0xca, 0x00, + 0x4a, 0x42, 0x1d, 0x01, 0x8d, 0xf4, 0x81, 0x11, 0x17, 0x04, 0x33, 0x01, + 0xff, 0x50, 0x0a, 0x66, 0x2b, 0x29, 0x00, 0x50, 0x9f, 0x42, 0x30, 0x29, + 0x40, 0x80, 0x0c, 0x49, 0xb3, 0xbd, 0x90, 0xfa, 0x01, 0x48, 0xb7, 0xcc, + 0x6d, 0xf5, 0x41, 0x45, 0x5c, 0x00, 0xda, 0x02, 0x00, 0x44, 0x34, 0xf5, + 0xdf, 0xf6, 0x01, 0x48, 0x86, 0x0d, 0x57, 0x22, 0x00, 0x4b, 0xad, 0xa2, + 0x56, 0x22, 0x00, 0x48, 0xa0, 0x1e, 0x18, 0x22, 0x00, 0x45, 0x9c, 0x01, + 0x30, 0x2e, 0x40, 0x80, 0xcc, 0x08, 0x8d, 0xe9, 0x06, 0x55, 0xbc, 0x3d, + 0x3d, 0x2a, 0x00, 0x06, 0xa9, 0x01, 0x01, 0xff, 0x45, 0xce, 0x00, 0x92, + 0x21, 0x80, 0xc0, 0x04, 0xa2, 0xa1, 0x04, 0x50, 0x5a, 0x64, 0x3e, 0xf8, + 0x01, 0xa4, 0xe1, 0x03, 0xa6, 0xd2, 0x03, 0xa8, 0xd1, 0x02, 0x57, 0x0a, + 0x31, 0xa7, 0xf8, 0x01, 0x51, 0x8b, 0x5f, 0xfe, 0x21, 0x00, 0xb0, 0xb6, + 0x02, 0x4f, 0x4e, 0x75, 0x46, 0x2b, 0x00, 0xb2, 0xa1, 0x02, 0xb3, 0x87, + 0x02, 0xb4, 0x1f, 0xb7, 0x01, 0xff, 0x49, 0xfa, 0xbb, 0x9d, 0x21, 0x00, + 0x4a, 0xf9, 0x10, 0xe8, 0x21, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x49, 0xb8, + 0xbe, 0xf0, 0x21, 0x00, 0x59, 0x04, 0x20, 0x96, 0xf8, 0x41, 0x49, 0x63, + 0xbf, 0xfa, 0xfa, 0x01, 0x55, 0x75, 0x3f, 0xa3, 0xf8, 0x01, 0x02, 0x0d, + 0x00, 0x51, 0x02, 0x15, 0x02, 0x01, 0xff, 0x4d, 0x6e, 0x83, 0xa0, 0x21, + 0x00, 0x08, 0x09, 0x02, 0x01, 0xff, 0x06, 0xce, 0x00, 0x06, 0x51, 0x45, + 0x61, 0x10, 0x29, 0x40, 0x48, 0xdf, 0xb9, 0x05, 0x29, 0x00, 0x05, 0x51, + 0x00, 0x01, 0xff, 0x56, 0x61, 0x35, 0x01, 0x29, 0x00, 0xb4, 0x06, 0x4f, + 0x68, 0x35, 0x00, 0x29, 0x40, 0x43, 0x7a, 0x18, 0x16, 0x29, 0x80, 0x06, + 0x52, 0x2f, 0x06, 0xee, 0x2b, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x56, + 0x61, 0x35, 0x18, 0x29, 0x00, 0x4f, 0x68, 0x35, 0x17, 0x29, 0x40, 0x05, + 0x04, 0x02, 0x11, 0x04, 0x8f, 0x1e, 0x01, 0xff, 0x45, 0xce, 0x00, 0xdb, + 0x21, 0x00, 0x4a, 0x4c, 0x61, 0x0f, 0x29, 0x40, 0x4a, 0xe0, 0x01, 0x92, + 0xf8, 0x01, 0x08, 0x09, 0x02, 0x01, 0xff, 0x45, 0xce, 0x00, 0x62, 0x2b, + 0x80, 0x0c, 0x4c, 0x78, 0x92, 0x6c, 0x2b, 0x00, 0x4d, 0xcf, 0x8b, 0x86, + 0x2b, 0x40, 0x80, 0x01, 0xff, 0x64, 0xbc, 0x09, 0x82, 0x2b, 0x00, 0x46, + 0x9f, 0x15, 0x72, 0x2b, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4a, 0xb2, + 0xad, 0x2a, 0xf8, 0x01, 0x07, 0x3b, 0x01, 0x28, 0x4b, 0x7f, 0x6b, 0x2e, + 0xf8, 0x01, 0x09, 0x6d, 0xc1, 0x12, 0x4c, 0xbc, 0x96, 0x26, 0xf8, 0x01, + 0x4c, 0x28, 0x97, 0x22, 0xf8, 0x01, 0x50, 0x7a, 0x6b, 0x32, 0xf8, 0x41, + 0x49, 0xa5, 0x01, 0xa7, 0x2b, 0x00, 0x47, 0x50, 0x02, 0xa5, 0x2b, 0x40, + 0x51, 0x47, 0x05, 0x7c, 0x2b, 0x00, 0x4f, 0x68, 0x35, 0x7c, 0x2b, 0x40, + 0x4f, 0xfb, 0x69, 0x52, 0xf8, 0x01, 0x02, 0x7c, 0x00, 0x01, 0xff, 0x4a, + 0xda, 0x98, 0x3a, 0xf8, 0x01, 0x4b, 0x5b, 0x80, 0xdd, 0x21, 0x40, 0x57, + 0x97, 0x30, 0xa5, 0xf8, 0x01, 0x45, 0x24, 0xb4, 0x6e, 0xf6, 0x41, 0x4c, + 0xd0, 0x8b, 0xc9, 0x21, 0x00, 0x4b, 0xcf, 0xa9, 0xf8, 0xfa, 0x41, 0xa1, + 0x11, 0x05, 0x3c, 0x16, 0x01, 0xff, 0x45, 0xce, 0x00, 0x46, 0xf8, 0x01, + 0x50, 0x5a, 0x64, 0x42, 0xf8, 0x41, 0x42, 0x1b, 0x00, 0xf1, 0xfa, 0x01, + 0x06, 0xcb, 0x02, 0x01, 0xff, 0x56, 0xdf, 0x37, 0xcc, 0x21, 0x00, 0x0a, + 0x98, 0x05, 0x01, 0xff, 0x04, 0xa5, 0x01, 0x31, 0x02, 0x50, 0x02, 0x01, + 0xff, 0x80, 0x06, 0x45, 0xa9, 0x01, 0xc0, 0x21, 0x40, 0x06, 0x5c, 0x00, + 0x0c, 0x48, 0xdf, 0xb9, 0x5b, 0x29, 0x00, 0x46, 0x9f, 0x15, 0x53, 0x29, + 0x40, 0xac, 0x06, 0x61, 0x85, 0x05, 0x64, 0x29, 0x40, 0x5d, 0x70, 0x16, + 0x68, 0x29, 0x00, 0x48, 0x6b, 0x6e, 0x6c, 0x29, 0x40, 0x80, 0x06, 0x45, + 0xa9, 0x01, 0xc1, 0x21, 0x40, 0x66, 0x41, 0x06, 0x69, 0x29, 0x00, 0x4f, + 0x64, 0x6e, 0x6d, 0x29, 0x00, 0x48, 0xdf, 0xb9, 0x5f, 0x29, 0x00, 0x46, + 0x9f, 0x15, 0x57, 0x29, 0x40, 0x50, 0x7e, 0x5c, 0x36, 0xf8, 0x01, 0x60, + 0xe3, 0x10, 0xab, 0xf8, 0x41, 0x4b, 0x79, 0x92, 0xe2, 0x21, 0x00, 0x06, + 0x3c, 0x01, 0x01, 0xff, 0x45, 0xce, 0x00, 0xd2, 0x21, 0x80, 0x06, 0x4a, + 0x4c, 0x61, 0x0d, 0x29, 0x40, 0x80, 0x06, 0x45, 0x78, 0x18, 0x1c, 0x29, + 0x40, 0x48, 0xdf, 0xb9, 0x07, 0x29, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, + 0x46, 0x52, 0x05, 0xcf, 0x21, 0x00, 0x4f, 0x68, 0x35, 0x03, 0x29, 0x40, + 0x5f, 0x62, 0x11, 0xa9, 0xf8, 0x01, 0x05, 0x0d, 0x03, 0x06, 0x58, 0x04, + 0x2c, 0xa1, 0xf8, 0x41, 0x45, 0xce, 0x00, 0x95, 0x2b, 0x00, 0x53, 0x0a, + 0x4b, 0x8a, 0x2b, 0x40, 0x80, 0x06, 0x45, 0x78, 0x18, 0x1a, 0x29, 0x40, + 0xa1, 0xdf, 0x01, 0x05, 0xaa, 0x05, 0xc7, 0x01, 0x54, 0x0f, 0x47, 0xc4, + 0x21, 0x00, 0xb4, 0x99, 0x01, 0x05, 0x51, 0x00, 0x01, 0xff, 0x50, 0x7a, + 0x64, 0xb4, 0x21, 0x00, 0x02, 0x3b, 0x01, 0x7e, 0x55, 0xd5, 0x01, 0x16, + 0xf8, 0x01, 0x44, 0x5b, 0x0f, 0xaa, 0x21, 0x00, 0xac, 0x5b, 0x59, 0x51, + 0x26, 0x06, 0xf8, 0x01, 0x4c, 0xa0, 0x97, 0x9a, 0xf8, 0x01, 0x4a, 0x1e, + 0xb5, 0x45, 0x29, 0x00, 0xb3, 0x31, 0xb4, 0x06, 0x4f, 0x68, 0x35, 0xf8, + 0x21, 0x40, 0x43, 0x7a, 0x18, 0xa3, 0x21, 0x80, 0x11, 0x03, 0xb6, 0x0c, + 0x01, 0xff, 0x49, 0xa5, 0x01, 0x0e, 0x2b, 0x00, 0x47, 0x50, 0x02, 0x0f, + 0x2b, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x56, 0x61, 0x35, 0x15, 0x29, + 0x00, 0x4f, 0x68, 0x35, 0x14, 0x29, 0x40, 0x05, 0x5e, 0x07, 0x06, 0x45, + 0x53, 0x05, 0x9b, 0x21, 0x40, 0x55, 0xd5, 0x01, 0x12, 0xf8, 0x01, 0x52, + 0x2e, 0x06, 0x02, 0xf8, 0x41, 0x57, 0x15, 0x2b, 0x0a, 0xf8, 0x01, 0xaf, + 0x01, 0xff, 0x42, 0x1f, 0x00, 0xac, 0x21, 0x00, 0x48, 0xf0, 0xb2, 0xb2, + 0xf8, 0x41, 0x49, 0xe4, 0xc5, 0x11, 0x29, 0x00, 0x54, 0x63, 0x35, 0xfb, + 0x21, 0x40, 0x07, 0xb4, 0x2c, 0x11, 0x03, 0xa0, 0x15, 0x01, 0xff, 0x42, + 0x17, 0x00, 0xe5, 0x21, 0x00, 0x4c, 0xeb, 0x59, 0x1e, 0x29, 0x40, 0x4c, + 0x87, 0x00, 0x43, 0x2b, 0x00, 0x48, 0xf7, 0xd0, 0x44, 0x2b, 0x00, 0xf8, + 0x47, 0x29, 0x40, 0x43, 0x16, 0x00, 0xa6, 0x21, 0x80, 0x06, 0x4f, 0xa0, + 0x0c, 0xc1, 0xf8, 0x41, 0x51, 0xe6, 0x59, 0x20, 0x29, 0x40, 0x05, 0x5d, + 0x00, 0x06, 0x63, 0x67, 0x0b, 0xb6, 0xfb, 0x41, 0x4f, 0xce, 0x6d, 0x75, + 0x29, 0x00, 0x08, 0xa8, 0x75, 0x0c, 0x55, 0x47, 0x40, 0x42, 0x29, 0x00, + 0x4e, 0x9b, 0x40, 0x74, 0x29, 0x40, 0x4f, 0xce, 0x6d, 0x48, 0x2b, 0x00, + 0x4e, 0x9b, 0x40, 0x4c, 0x2b, 0x40, 0x07, 0xf6, 0x2f, 0x9c, 0x01, 0x5b, + 0xa7, 0x1c, 0xe5, 0x26, 0x00, 0x09, 0x9c, 0x01, 0x2b, 0xb3, 0x1d, 0x08, + 0x57, 0xd1, 0x01, 0xff, 0x49, 0xf2, 0xbd, 0x2b, 0x20, 0x00, 0x47, 0x5f, + 0x03, 0x67, 0x20, 0x00, 0x44, 0xb9, 0x00, 0x0f, 0x20, 0x00, 0x48, 0x67, + 0xcf, 0x2e, 0x20, 0x40, 0x5c, 0xe4, 0x18, 0xa9, 0x27, 0x00, 0x57, 0x80, + 0x30, 0x38, 0x29, 0x40, 0xa1, 0x59, 0x54, 0x8b, 0x43, 0xfd, 0x29, 0x00, + 0xa4, 0x45, 0x4b, 0xc9, 0xa0, 0x7a, 0xcc, 0x01, 0x47, 0x22, 0xd7, 0x01, + 0xcc, 0x01, 0x50, 0xea, 0x67, 0x0e, 0xf5, 0x01, 0xb2, 0x0c, 0x4c, 0x70, + 0x9a, 0x03, 0xcc, 0x01, 0x44, 0x24, 0xcd, 0x9f, 0xcc, 0x41, 0x49, 0x22, + 0xbb, 0x99, 0xcc, 0x01, 0x44, 0x42, 0xb2, 0x67, 0xcc, 0x01, 0xaf, 0x01, + 0xff, 0x05, 0x8b, 0x09, 0x06, 0x50, 0xaa, 0x67, 0xa3, 0xcc, 0x41, 0x47, + 0x5b, 0xd5, 0xa1, 0xcc, 0x01, 0x44, 0x34, 0x22, 0x58, 0xcc, 0x41, 0x44, + 0x80, 0xf6, 0x0f, 0xcc, 0x01, 0x5a, 0xdb, 0x22, 0xbb, 0x00, 0x40, 0x4c, + 0xee, 0x0f, 0x2a, 0x23, 0x00, 0x4a, 0xa8, 0xb7, 0x62, 0xcc, 0x41, 0x56, + 0xb1, 0x34, 0x8d, 0x05, 0x00, 0x48, 0x9f, 0xc9, 0x49, 0xcc, 0x01, 0x03, + 0xab, 0x5d, 0x20, 0xb3, 0x01, 0xff, 0x0f, 0xfe, 0x2f, 0x0d, 0x4a, 0xca, + 0xb8, 0xd5, 0x0f, 0xc0, 0x00, 0x4a, 0xa7, 0x5b, 0xd7, 0x0f, 0x40, 0x4c, + 0x24, 0x92, 0x76, 0xcc, 0x01, 0x4a, 0xda, 0x2a, 0x72, 0xcc, 0x41, 0xe8, + 0x93, 0xcc, 0x81, 0x04, 0xf4, 0x1c, 0xf9, 0x41, 0x50, 0xd4, 0x2a, 0x95, + 0xcc, 0x41, 0xa1, 0xa4, 0x05, 0x06, 0x0c, 0x03, 0x93, 0x05, 0xa3, 0xe8, + 0x04, 0x02, 0x3b, 0x01, 0xb8, 0x04, 0xa6, 0xa1, 0x04, 0x02, 0x22, 0x00, + 0xaf, 0x03, 0x14, 0xe3, 0x45, 0x9e, 0x03, 0x56, 0x87, 0x37, 0x1d, 0x2e, + 0x00, 0x60, 0x83, 0x10, 0xca, 0x22, 0x00, 0xaf, 0xf3, 0x02, 0x4b, 0xfb, + 0x22, 0x29, 0x00, 0x80, 0xd0, 0x02, 0x57, 0x1e, 0x32, 0x0d, 0x2e, 0x00, + 0xb3, 0xb4, 0x01, 0xb4, 0x4b, 0x09, 0x32, 0x00, 0x33, 0xb7, 0x01, 0xff, + 0x05, 0xae, 0x02, 0x06, 0x4b, 0xf1, 0x9b, 0xd9, 0x29, 0x40, 0xa3, 0x18, + 0x52, 0xda, 0x28, 0x17, 0x30, 0x00, 0x4b, 0xfb, 0x22, 0x86, 0x29, 0x00, + 0x4e, 0x36, 0x28, 0x1b, 0x30, 0x00, 0x56, 0x79, 0x09, 0x19, 0x30, 0x40, + 0x4d, 0x68, 0x6c, 0x0f, 0x30, 0x00, 0x4c, 0xdf, 0x0b, 0x84, 0x29, 0x40, + 0xa2, 0x06, 0x4d, 0x9e, 0x31, 0x06, 0xcc, 0x41, 0x4d, 0xa6, 0x84, 0x21, + 0x2e, 0x00, 0x47, 0x4e, 0xda, 0xb9, 0x23, 0x40, 0x43, 0x0e, 0x03, 0xa2, + 0x22, 0x00, 0xa8, 0x27, 0x55, 0x7a, 0x09, 0x15, 0x30, 0x00, 0xb2, 0x01, + 0xff, 0x53, 0x4c, 0x4a, 0x0a, 0x2e, 0x00, 0x04, 0x1b, 0x01, 0x01, 0xff, + 0x42, 0x68, 0x00, 0xbf, 0x22, 0x80, 0x06, 0x56, 0x5c, 0x1e, 0x6e, 0xfb, + 0x41, 0x54, 0x97, 0x41, 0xce, 0x29, 0x40, 0x04, 0xcc, 0x8d, 0x28, 0x4c, + 0x78, 0x98, 0xed, 0xf5, 0x01, 0x04, 0x26, 0x01, 0x01, 0xff, 0x4d, 0x5e, + 0x4f, 0x88, 0xfb, 0x01, 0x09, 0x2a, 0x01, 0x01, 0xff, 0x45, 0x33, 0x01, + 0x8a, 0xfb, 0x01, 0x57, 0x21, 0x31, 0xa1, 0xce, 0x01, 0x57, 0x60, 0x33, + 0xaa, 0xce, 0x41, 0x48, 0xaf, 0xcc, 0x0d, 0xcc, 0x01, 0x5a, 0xab, 0x23, + 0xc3, 0xfb, 0x41, 0x55, 0xf2, 0x3a, 0xc6, 0x27, 0x00, 0xa5, 0x7f, 0xa9, + 0x71, 0x02, 0x6f, 0x02, 0x4f, 0x4d, 0x37, 0x28, 0x5d, 0x00, 0x80, 0x06, + 0x53, 0x19, 0x28, 0x03, 0x2e, 0x40, 0x80, 0x01, 0xff, 0x49, 0x42, 0x5b, + 0xa5, 0x23, 0x00, 0x4c, 0x38, 0x96, 0xa6, 0x23, 0x00, 0x4c, 0x84, 0x9b, + 0xa4, 0x23, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4d, 0x46, 0x86, 0x58, + 0x2e, 0x00, 0x45, 0xae, 0x84, 0x46, 0x20, 0x00, 0x46, 0x52, 0x05, 0x56, + 0x2e, 0x00, 0x08, 0x47, 0xd1, 0x06, 0x48, 0x64, 0x5c, 0x8c, 0x29, 0x40, + 0x4d, 0x4f, 0x85, 0x8e, 0x29, 0x00, 0x4a, 0xb2, 0xb7, 0x90, 0x29, 0x40, + 0x44, 0x00, 0x29, 0x68, 0xf5, 0x81, 0x06, 0x4a, 0x4d, 0x80, 0xe9, 0xf5, + 0x41, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4e, 0x1a, 0x7e, 0x69, 0xf5, 0x01, + 0x51, 0x01, 0x61, 0x6a, 0xf5, 0x41, 0x50, 0xaa, 0x64, 0x27, 0x2e, 0x00, + 0x53, 0x03, 0x0c, 0x19, 0x20, 0x40, 0x50, 0x93, 0x10, 0xcc, 0x22, 0x00, + 0x51, 0x5a, 0x4f, 0x8b, 0xfb, 0x41, 0x80, 0x01, 0xff, 0x49, 0x42, 0x5b, + 0x9f, 0x23, 0x00, 0x4a, 0xee, 0xb2, 0xa0, 0x23, 0x00, 0x4a, 0x7a, 0xb8, + 0x9e, 0x23, 0x00, 0x50, 0xfa, 0x6b, 0x63, 0x2e, 0x40, 0x03, 0xef, 0x07, + 0x0c, 0x4f, 0xf4, 0x74, 0xbc, 0xfb, 0x01, 0x49, 0xed, 0xb4, 0xd6, 0x27, + 0x40, 0x4c, 0x7e, 0x0b, 0x95, 0x25, 0x00, 0x4d, 0x65, 0x1e, 0x87, 0xfb, + 0x41, 0x4c, 0x0c, 0x03, 0xe9, 0xfb, 0x01, 0x4c, 0x00, 0x12, 0xe1, 0xfb, + 0x41, 0x03, 0x24, 0x00, 0x06, 0x55, 0x36, 0x3f, 0x7d, 0xf5, 0x41, 0x5a, + 0x37, 0x20, 0x00, 0xce, 0x01, 0x02, 0x33, 0x01, 0x43, 0xa6, 0x35, 0x65, + 0xe2, 0x07, 0x11, 0xce, 0x01, 0x57, 0x21, 0x31, 0xa0, 0xce, 0x01, 0x4c, + 0x44, 0x04, 0x8d, 0xfb, 0x01, 0x4b, 0x9e, 0xa7, 0xb3, 0xfb, 0x01, 0x56, + 0x81, 0x39, 0x0e, 0xce, 0x01, 0x57, 0x60, 0x33, 0xab, 0xce, 0x01, 0x06, + 0xad, 0x02, 0x01, 0xff, 0x46, 0x12, 0x03, 0xf5, 0xf7, 0x01, 0x47, 0xf3, + 0x69, 0x0c, 0xce, 0x41, 0x4c, 0x68, 0x96, 0xa5, 0xcc, 0x01, 0x45, 0xe0, + 0x68, 0xba, 0xfb, 0x41, 0x04, 0x0e, 0x03, 0x06, 0x43, 0x35, 0x01, 0x90, + 0x25, 0x40, 0x46, 0x12, 0x03, 0xd7, 0x25, 0x00, 0x44, 0xff, 0x13, 0xe9, + 0x2b, 0x40, 0xa9, 0x06, 0x44, 0xae, 0x25, 0x0b, 0x23, 0x40, 0x47, 0x96, + 0xbe, 0x7d, 0x29, 0x00, 0x50, 0x19, 0x54, 0x89, 0xfb, 0x41, 0x59, 0x13, + 0x28, 0x05, 0x2e, 0x00, 0x05, 0x3d, 0x01, 0x01, 0xff, 0xa1, 0x12, 0x4b, + 0xfb, 0x22, 0x29, 0x2e, 0x00, 0x4e, 0x19, 0x05, 0x1d, 0x20, 0x00, 0x4c, + 0xf0, 0x9b, 0xdb, 0x29, 0x40, 0x4c, 0xee, 0x0f, 0x0b, 0x30, 0x00, 0x56, + 0x13, 0x39, 0x70, 0x29, 0x40, 0x46, 0x40, 0xca, 0x09, 0x23, 0x00, 0x4d, + 0x68, 0x6c, 0x0d, 0x30, 0x00, 0x4c, 0xdf, 0x0b, 0x7d, 0x00, 0xc0, 0x00, + 0x80, 0x01, 0xff, 0x4a, 0xee, 0xb2, 0xad, 0x23, 0x00, 0x4c, 0xd4, 0x96, + 0xac, 0x23, 0x00, 0x4a, 0x7a, 0xb8, 0xab, 0x23, 0x40, 0x52, 0xda, 0x28, + 0x11, 0x30, 0x00, 0x56, 0x79, 0x09, 0x98, 0x29, 0x40, 0xae, 0x1a, 0xb2, + 0x01, 0xff, 0x56, 0x96, 0x18, 0x94, 0x29, 0x00, 0x09, 0x25, 0x06, 0x01, + 0xff, 0x4c, 0x00, 0x92, 0xf4, 0x27, 0x00, 0x4c, 0x0d, 0x16, 0xf4, 0x21, + 0x40, 0x02, 0x06, 0x00, 0x43, 0xa7, 0x01, 0xff, 0x49, 0x16, 0xbe, 0xef, + 0xf5, 0x01, 0x42, 0x68, 0x00, 0x1f, 0x22, 0xc0, 0x00, 0x80, 0x01, 0xff, + 0x47, 0x88, 0x09, 0x09, 0x30, 0x80, 0x23, 0x5a, 0xed, 0x20, 0x01, 0x2e, + 0x00, 0x53, 0xf4, 0x20, 0x00, 0x2e, 0x00, 0x53, 0xd4, 0x50, 0x9c, 0x29, + 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x43, 0x94, 0x18, 0xbe, 0x22, 0x00, + 0x56, 0xa3, 0x35, 0x7c, 0x23, 0x40, 0x49, 0x98, 0x3d, 0x92, 0x29, 0x40, + 0x56, 0x74, 0x0b, 0x7f, 0xfb, 0x01, 0x56, 0xd9, 0x39, 0x7e, 0xfb, 0x41, + 0x44, 0xef, 0x1d, 0x59, 0xf3, 0x01, 0x47, 0xe0, 0xd5, 0x58, 0xf3, 0x41, + 0x07, 0xcd, 0x00, 0x01, 0xff, 0x05, 0x6c, 0x15, 0x31, 0x05, 0xc3, 0x00, + 0x21, 0x06, 0xc8, 0x00, 0x11, 0x03, 0x4b, 0x16, 0x01, 0xff, 0x44, 0xc3, + 0x00, 0xb2, 0x2b, 0x00, 0x45, 0xc8, 0x00, 0xb3, 0x2b, 0x40, 0x44, 0xa5, + 0x01, 0xb7, 0x2b, 0x00, 0x42, 0x50, 0x02, 0xb5, 0x2b, 0x40, 0x44, 0xa5, + 0x01, 0xb6, 0x2b, 0x00, 0x42, 0x50, 0x02, 0xb4, 0x2b, 0x40, 0x44, 0xc3, + 0x00, 0xb0, 0x2b, 0x00, 0x45, 0xc8, 0x00, 0xb1, 0x2b, 0x40, 0x48, 0xcf, + 0xcc, 0x8f, 0xf9, 0x01, 0x45, 0x80, 0xef, 0xff, 0xf7, 0x41, 0xa3, 0xb8, + 0x05, 0x02, 0x06, 0x00, 0xa7, 0x05, 0x4c, 0x98, 0x93, 0x3b, 0x20, 0x00, + 0x02, 0xf1, 0x06, 0xaa, 0x04, 0x05, 0x9b, 0xed, 0xcb, 0x02, 0x4b, 0x62, + 0x5b, 0x0c, 0xf6, 0x01, 0x4d, 0x3c, 0x8a, 0x97, 0xf3, 0x01, 0x53, 0xaa, + 0x21, 0xfd, 0xff, 0x00, 0xb3, 0x99, 0x02, 0x05, 0x88, 0xf1, 0x82, 0x02, + 0xb6, 0x01, 0xff, 0x04, 0x3f, 0x04, 0x06, 0x4d, 0x19, 0x8b, 0x9e, 0xf4, + 0x41, 0x80, 0xa9, 0x01, 0x02, 0x06, 0x00, 0x01, 0xff, 0x45, 0x04, 0x02, + 0xa3, 0x29, 0x80, 0x96, 0x01, 0x45, 0x13, 0x05, 0x41, 0x2e, 0x00, 0x07, + 0x3b, 0x01, 0x79, 0x49, 0xfb, 0xbd, 0xb0, 0x29, 0x00, 0x52, 0x29, 0x54, + 0x11, 0x2e, 0x00, 0x60, 0x63, 0x10, 0x95, 0xf5, 0x01, 0x48, 0xbd, 0x76, + 0x10, 0x23, 0x00, 0xb0, 0x53, 0x4d, 0x88, 0x36, 0x2e, 0x2e, 0x00, 0xb2, + 0x39, 0xb3, 0x2b, 0xb4, 0x06, 0x4c, 0xcc, 0x9b, 0x94, 0xf5, 0x41, 0x06, + 0x8e, 0xe2, 0x13, 0x44, 0x72, 0x24, 0x3d, 0x22, 0x80, 0x06, 0x4b, 0x51, + 0xa7, 0x37, 0x20, 0x40, 0x47, 0x15, 0x14, 0xcd, 0x22, 0x40, 0x49, 0x62, + 0xbd, 0x93, 0xf5, 0x01, 0x47, 0xcb, 0xdc, 0x92, 0xf5, 0x41, 0x53, 0x39, + 0x4a, 0x43, 0x21, 0x00, 0x48, 0x5b, 0x5c, 0x4f, 0x20, 0x40, 0x5f, 0x81, + 0x11, 0x91, 0xf5, 0x01, 0x4a, 0x88, 0x47, 0xfe, 0x2b, 0x00, 0x5a, 0xc1, + 0x22, 0x19, 0x26, 0x40, 0x4b, 0x8c, 0xa2, 0x4b, 0x20, 0x00, 0x44, 0x0d, + 0x1c, 0x35, 0x20, 0x40, 0x45, 0x0c, 0x1c, 0x36, 0x20, 0x80, 0x06, 0x4f, + 0xb6, 0x76, 0xed, 0x2a, 0x40, 0x4f, 0x18, 0x05, 0x1d, 0x30, 0x40, 0x4e, + 0xe1, 0x61, 0xa5, 0x29, 0x40, 0x4d, 0x3b, 0x15, 0x7f, 0xf6, 0x01, 0x45, + 0x5d, 0x14, 0x8d, 0x00, 0x00, 0x02, 0xc3, 0x01, 0x2d, 0x47, 0x1b, 0x33, + 0x5c, 0x00, 0x80, 0x11, 0x15, 0x9b, 0x40, 0x01, 0xff, 0x4f, 0x6f, 0x1b, + 0x41, 0x2b, 0x00, 0x50, 0xb3, 0x02, 0x47, 0x2b, 0x40, 0x80, 0x01, 0xff, + 0x48, 0xa0, 0x1e, 0xf5, 0x29, 0x00, 0x50, 0x0a, 0x69, 0xc8, 0x27, 0x00, + 0x56, 0x31, 0x3a, 0xf7, 0x29, 0x40, 0x5e, 0xe5, 0x13, 0xc8, 0xf7, 0x01, + 0x47, 0xf3, 0x21, 0x8d, 0x00, 0x40, 0x44, 0xc3, 0x00, 0x90, 0x2b, 0x00, + 0x45, 0xc8, 0x00, 0x91, 0x2b, 0x00, 0x46, 0x16, 0x08, 0xce, 0x23, 0x40, + 0x45, 0xf3, 0xef, 0x1f, 0x21, 0x00, 0x02, 0x19, 0x01, 0x01, 0xff, 0x11, + 0x5a, 0x5d, 0x06, 0x43, 0x5f, 0x56, 0xbb, 0xf6, 0x41, 0xd1, 0xe0, 0x26, + 0x00, 0xd2, 0xe1, 0x26, 0x40, 0x0f, 0x09, 0x35, 0xc4, 0x01, 0x07, 0x13, + 0x06, 0x37, 0x4c, 0x66, 0x28, 0x5f, 0xa9, 0x00, 0xb6, 0x01, 0xff, 0x45, + 0x20, 0x25, 0x53, 0xa9, 0x00, 0x0a, 0xc8, 0x7a, 0x01, 0xff, 0xa1, 0x19, + 0xe5, 0x49, 0xa9, 0x80, 0x0c, 0xe9, 0x47, 0xa9, 0x00, 0xef, 0x4b, 0xa9, + 0x00, 0xf5, 0x48, 0xa9, 0x40, 0xe1, 0x4e, 0xa9, 0x00, 0xf5, 0x4d, 0xa9, + 0x40, 0xe9, 0x4a, 0xa9, 0x00, 0xf5, 0x4c, 0xa9, 0x40, 0xe1, 0x46, 0xa9, + 0x00, 0x42, 0x16, 0x00, 0x37, 0xa9, 0x00, 0x42, 0x37, 0x00, 0x39, 0xa9, + 0x00, 0x42, 0x7b, 0x08, 0x34, 0xa9, 0x00, 0x42, 0x24, 0x02, 0x31, 0xa9, + 0x00, 0x42, 0x22, 0x00, 0x41, 0xa9, 0x00, 0x42, 0x78, 0x1a, 0x3a, 0xa9, + 0x00, 0x42, 0x1b, 0x02, 0x30, 0xa9, 0x00, 0x42, 0x74, 0x00, 0x3e, 0xa9, + 0x00, 0xad, 0x49, 0xae, 0x24, 0x42, 0xe0, 0x09, 0x36, 0xa9, 0x00, 0x42, + 0x71, 0x00, 0x3d, 0xa9, 0x00, 0x42, 0x40, 0x06, 0x3c, 0xa9, 0x00, 0x42, + 0x12, 0x00, 0x33, 0xa9, 0x00, 0x42, 0xa9, 0x01, 0x40, 0xa9, 0x00, 0x42, + 0xdf, 0x23, 0x3f, 0xa9, 0x40, 0xe1, 0x35, 0xa9, 0x00, 0x42, 0x7b, 0x08, + 0x44, 0xa9, 0x00, 0xa7, 0x0d, 0xb9, 0x01, 0xff, 0xe1, 0x3b, 0xa9, 0x00, + 0x42, 0x78, 0x1a, 0x45, 0xa9, 0x40, 0xe1, 0x32, 0xa9, 0x00, 0x42, 0x24, + 0x02, 0x43, 0xa9, 0x40, 0xe1, 0x38, 0xa9, 0x00, 0x42, 0x16, 0x00, 0x42, + 0xa9, 0x40, 0xe8, 0x52, 0xa9, 0x00, 0xee, 0x50, 0xa9, 0x80, 0x04, 0xf2, + 0x51, 0xa9, 0x40, 0xe7, 0x4f, 0xa9, 0x40, 0x1d, 0x1e, 0x17, 0x06, 0x4b, + 0x2d, 0xa8, 0xae, 0x00, 0x40, 0xe1, 0xe6, 0xf1, 0x01, 0xe2, 0xe7, 0xf1, + 0x01, 0xe3, 0xe8, 0xf1, 0x01, 0xe4, 0xe9, 0xf1, 0x01, 0xe5, 0xea, 0xf1, + 0x01, 0xe6, 0xeb, 0xf1, 0x01, 0xe7, 0xec, 0xf1, 0x01, 0xe8, 0xed, 0xf1, + 0x01, 0xe9, 0xee, 0xf1, 0x01, 0xea, 0xef, 0xf1, 0x01, 0xeb, 0xf0, 0xf1, + 0x01, 0xec, 0xf1, 0xf1, 0x01, 0xed, 0xf2, 0xf1, 0x01, 0xee, 0xf3, 0xf1, + 0x01, 0xef, 0xf4, 0xf1, 0x01, 0xf0, 0xf5, 0xf1, 0x01, 0xf1, 0xf6, 0xf1, + 0x01, 0xf2, 0xf7, 0xf1, 0x01, 0xf3, 0xf8, 0xf1, 0x01, 0xf4, 0xf9, 0xf1, + 0x01, 0xf5, 0xfa, 0xf1, 0x01, 0xf6, 0xfb, 0xf1, 0x01, 0xf7, 0xfc, 0xf1, + 0x01, 0xf8, 0xfd, 0xf1, 0x01, 0xf9, 0xfe, 0xf1, 0x01, 0xfa, 0xff, 0xf1, + 0x41, 0x45, 0x58, 0xea, 0x4e, 0xf3, 0x01, 0x4d, 0x64, 0x87, 0xe7, 0xf9, + 0x41, 0xa5, 0x51, 0x4d, 0x6d, 0x69, 0x1e, 0x00, 0x00, 0x51, 0x24, 0x60, + 0x99, 0xf6, 0x01, 0x03, 0x8f, 0x26, 0x01, 0xff, 0x4f, 0x7d, 0x2b, 0x7c, + 0x26, 0x00, 0x0f, 0xca, 0x71, 0x01, 0xff, 0x51, 0xc1, 0x5c, 0x7a, 0x26, + 0x00, 0x05, 0x6e, 0x22, 0x01, 0xff, 0x4a, 0x18, 0xac, 0x73, 0x26, 0x00, + 0x4a, 0x2c, 0xac, 0x74, 0x26, 0x00, 0x4a, 0x40, 0xac, 0x75, 0x26, 0x00, + 0x4a, 0x4a, 0xac, 0x76, 0x26, 0x00, 0x4a, 0x54, 0xac, 0x77, 0x26, 0x00, + 0x4a, 0x5e, 0xac, 0x78, 0x26, 0x00, 0x4a, 0x68, 0xac, 0x79, 0x26, 0x40, + 0x43, 0x77, 0x06, 0xfe, 0xf9, 0x01, 0x46, 0x3a, 0xe5, 0x12, 0xcc, 0x41, + 0x44, 0x18, 0xf5, 0x07, 0xf4, 0x81, 0xcd, 0x01, 0xa3, 0xb3, 0x01, 0x02, + 0x00, 0x00, 0x97, 0x01, 0xa9, 0x15, 0xed, 0x0f, 0xf4, 0x01, 0xf4, 0x00, + 0xf4, 0x81, 0x06, 0x43, 0xde, 0xfa, 0x92, 0xfa, 0x41, 0x42, 0xb5, 0x00, + 0x36, 0x22, 0x40, 0x05, 0x3b, 0xee, 0x70, 0xee, 0xc6, 0x26, 0x80, 0x65, + 0x04, 0x46, 0x03, 0x01, 0xff, 0x4c, 0x34, 0x91, 0x1a, 0xf9, 0x01, 0x45, + 0x13, 0x05, 0x34, 0x2e, 0x00, 0x43, 0x48, 0x0a, 0x33, 0x2e, 0x80, 0x47, + 0x44, 0xa9, 0xd0, 0x0a, 0x27, 0x00, 0x44, 0x54, 0x0e, 0x0b, 0x27, 0x80, + 0x29, 0x54, 0x28, 0x2d, 0x06, 0x2e, 0x00, 0xad, 0x0f, 0xb3, 0x01, 0xff, + 0x58, 0xa4, 0x2b, 0xcc, 0xfb, 0x01, 0x45, 0xfe, 0x05, 0x0b, 0x2e, 0x40, + 0x46, 0x43, 0x67, 0x6a, 0xf1, 0x01, 0x46, 0xe7, 0x49, 0x6b, 0xf1, 0x01, + 0x46, 0xbd, 0x0e, 0x6c, 0xf1, 0x41, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4f, + 0x91, 0x11, 0x90, 0xf5, 0x01, 0x64, 0xe0, 0x09, 0x96, 0xf5, 0x41, 0x58, + 0x24, 0x2d, 0x07, 0x2e, 0x40, 0x43, 0x5c, 0x85, 0x08, 0xf3, 0x41, 0x43, + 0xb7, 0x67, 0x83, 0xf6, 0x01, 0x45, 0x5b, 0xf1, 0xe4, 0xf6, 0x41, 0x51, + 0x6d, 0x5b, 0xb7, 0x23, 0x00, 0xef, 0xfb, 0xf4, 0xc1, 0x00, 0x47, 0xde, + 0xd2, 0x18, 0xf5, 0x01, 0x4b, 0xd2, 0x9d, 0x22, 0x26, 0x40, 0x44, 0x48, + 0xf5, 0x9d, 0xf9, 0x01, 0x04, 0xa1, 0x01, 0x01, 0xff, 0x43, 0xb7, 0x67, + 0xce, 0xf3, 0x01, 0x4a, 0xa2, 0xb3, 0xcd, 0xf3, 0x41, 0x45, 0x0b, 0x08, + 0x30, 0xf4, 0x41, 0xa1, 0x24, 0x06, 0x8a, 0x36, 0x0c, 0x46, 0xd6, 0xe2, + 0xbb, 0x26, 0x00, 0x4c, 0x1b, 0x05, 0x22, 0x00, 0x40, 0x80, 0x06, 0x4b, + 0x4f, 0x6a, 0x5f, 0x22, 0x40, 0x50, 0xad, 0x00, 0x48, 0x20, 0x00, 0x44, + 0xb9, 0x00, 0x3f, 0x00, 0x40, 0x02, 0xb4, 0x0d, 0x12, 0x43, 0x44, 0x15, + 0x7e, 0xf7, 0x01, 0x49, 0x0e, 0x57, 0x69, 0x26, 0x00, 0x59, 0xfa, 0x27, + 0x16, 0x2a, 0x40, 0x04, 0x0c, 0x0e, 0x11, 0x05, 0x9f, 0x4e, 0x01, 0xff, + 0x51, 0x02, 0x28, 0x0c, 0x2a, 0x00, 0x45, 0x0c, 0x1c, 0x57, 0x20, 0x40, + 0x06, 0x13, 0x01, 0x46, 0x06, 0x6d, 0x02, 0x01, 0xff, 0x44, 0xc3, 0x00, + 0x98, 0x25, 0x80, 0x14, 0x45, 0xc8, 0x00, 0x9d, 0x25, 0xc0, 0x00, 0x4f, + 0xdf, 0x3b, 0x9e, 0x25, 0xc0, 0x00, 0x50, 0x5f, 0x46, 0x9f, 0x25, 0x40, + 0x05, 0x19, 0x00, 0x01, 0xff, 0x06, 0x13, 0x01, 0x11, 0x16, 0xef, 0x39, + 0x01, 0xff, 0x44, 0xc3, 0x00, 0x9b, 0x25, 0x00, 0x45, 0xc8, 0x00, 0x9c, + 0x25, 0x40, 0x54, 0x5b, 0x46, 0x99, 0x25, 0x00, 0x45, 0xc8, 0x00, 0x9a, + 0x25, 0x40, 0x44, 0xc3, 0x00, 0x96, 0x25, 0x00, 0x45, 0xc8, 0x00, 0x97, + 0x25, 0x40, 0xa1, 0xb9, 0x18, 0xa4, 0xae, 0x18, 0xa5, 0x9b, 0x16, 0xa8, + 0x85, 0x0f, 0xa9, 0xf8, 0x0d, 0xac, 0x85, 0x08, 0xed, 0x9e, 0x00, 0x00, + 0x4d, 0xcb, 0x8a, 0x11, 0xcc, 0x01, 0xaf, 0x9c, 0x06, 0xb2, 0x8c, 0x02, + 0xb3, 0x3b, 0xb5, 0x01, 0xff, 0xd1, 0x91, 0x00, 0x00, 0xd2, 0x92, 0x00, + 0x00, 0x58, 0xec, 0x28, 0xe2, 0xf4, 0x01, 0x04, 0x75, 0x0c, 0x1a, 0xb2, + 0x0c, 0x45, 0xe3, 0xda, 0xcc, 0xf4, 0x01, 0x5c, 0x50, 0x1a, 0xae, 0xf6, + 0x41, 0x49, 0xda, 0xc3, 0x9c, 0xf4, 0x01, 0x42, 0x46, 0x03, 0x5b, 0xf4, + 0x41, 0x4b, 0x77, 0x9e, 0x08, 0x20, 0x00, 0x4f, 0x11, 0x76, 0x4e, 0x2e, + 0x40, 0x0e, 0x3c, 0x79, 0x06, 0x44, 0x38, 0xf9, 0xc9, 0xce, 0x41, 0x0f, + 0x62, 0x70, 0xb4, 0x01, 0x07, 0x13, 0x06, 0x3f, 0x07, 0x37, 0x3c, 0x0c, + 0x4c, 0x66, 0x28, 0x99, 0x0b, 0x01, 0x53, 0x3c, 0x50, 0x9a, 0x0b, 0x41, + 0x44, 0xf5, 0x06, 0xac, 0x0b, 0x01, 0x43, 0x7a, 0x0b, 0xa9, 0x0b, 0x81, + 0x1c, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0xad, 0x0b, 0x01, 0x44, 0x25, + 0x01, 0xab, 0x0b, 0x01, 0xb7, 0x01, 0xff, 0x44, 0xe9, 0x1e, 0xae, 0x0b, + 0x01, 0xef, 0xaa, 0x0b, 0x41, 0x48, 0x3e, 0x12, 0xaf, 0x0b, 0x41, 0x45, + 0x39, 0xb3, 0x80, 0x0b, 0x01, 0x44, 0x20, 0xf5, 0x81, 0x0b, 0x01, 0x46, + 0x6d, 0x4c, 0x83, 0x0b, 0x01, 0x45, 0x5a, 0xb0, 0x82, 0x0b, 0x01, 0x42, + 0xb0, 0x01, 0x84, 0x0b, 0x81, 0x4c, 0x44, 0xb0, 0xf6, 0x89, 0x0b, 0x01, + 0x46, 0x8a, 0xe3, 0x8a, 0x0b, 0x01, 0x48, 0xef, 0xcd, 0x8b, 0x0b, 0x01, + 0x43, 0x18, 0x24, 0x8c, 0x0b, 0x01, 0x42, 0x6f, 0x02, 0x8e, 0x0b, 0x01, + 0xb3, 0x18, 0x43, 0x53, 0xca, 0x91, 0x0b, 0x01, 0x4d, 0x1c, 0x8f, 0x85, + 0x0b, 0x01, 0x44, 0xfd, 0x54, 0x88, 0x0b, 0x01, 0x45, 0xf7, 0x54, 0x86, + 0x0b, 0x41, 0xa1, 0x06, 0x43, 0x48, 0x17, 0x90, 0x0b, 0x41, 0x43, 0x95, + 0xf0, 0x8f, 0x0b, 0x01, 0x44, 0x4a, 0xea, 0x8d, 0x0b, 0x41, 0x42, 0x53, + 0x00, 0x87, 0x0b, 0x41, 0x45, 0x8e, 0x08, 0x9b, 0x0b, 0x01, 0x43, 0x48, + 0x0a, 0x9c, 0x0b, 0x41, 0x4a, 0x80, 0xad, 0xff, 0xf4, 0x01, 0xa5, 0x86, + 0x01, 0xa9, 0x30, 0xaf, 0x01, 0xff, 0x49, 0x39, 0xbc, 0xaf, 0xf9, 0x01, + 0x4c, 0x58, 0x94, 0xc7, 0xf6, 0x01, 0x47, 0x10, 0xd8, 0x05, 0x23, 0x00, + 0xb0, 0x06, 0x47, 0xa4, 0x4a, 0xd8, 0x2b, 0x40, 0x49, 0x28, 0xbe, 0x4a, + 0x21, 0x00, 0x46, 0x83, 0x25, 0x37, 0x22, 0xc0, 0x00, 0x45, 0x89, 0x0d, + 0x1d, 0x22, 0x40, 0x42, 0x2a, 0x02, 0x32, 0x20, 0x00, 0xae, 0x29, 0x02, + 0x61, 0x0b, 0x01, 0xff, 0x4a, 0x66, 0xae, 0x9e, 0x00, 0x00, 0x06, 0x84, + 0xe6, 0x01, 0xff, 0x80, 0x0b, 0x8d, 0x01, 0xff, 0xd1, 0x91, 0x00, 0x00, + 0xd2, 0x92, 0x00, 0x40, 0x43, 0x7a, 0x0b, 0x91, 0x00, 0x00, 0x43, 0x44, + 0x0a, 0x92, 0x00, 0x40, 0x42, 0x73, 0x02, 0x34, 0xf9, 0x81, 0x16, 0xb4, + 0x01, 0xff, 0x4e, 0x4d, 0x5c, 0x99, 0x23, 0x00, 0x42, 0x33, 0x00, 0xa8, + 0xf5, 0xc1, 0x00, 0x45, 0xbf, 0xe7, 0xb6, 0xf5, 0x41, 0x42, 0xee, 0x00, + 0x78, 0xf4, 0x41, 0x45, 0xaa, 0xcf, 0x7a, 0x22, 0x80, 0xa6, 0x02, 0x06, + 0x04, 0xe2, 0x8f, 0x02, 0xb3, 0x0c, 0x44, 0xc4, 0xf8, 0x68, 0xf9, 0x01, + 0x4a, 0xf2, 0xb8, 0x97, 0x23, 0x40, 0x4d, 0xaa, 0x85, 0x1e, 0x21, 0x00, + 0x1b, 0x56, 0x1c, 0x01, 0xff, 0x02, 0x13, 0x05, 0xe5, 0x01, 0xa5, 0xd0, + 0x01, 0x53, 0x61, 0x2b, 0x19, 0xfe, 0x00, 0x0c, 0x6f, 0x21, 0xb9, 0x01, + 0xac, 0x6a, 0x4d, 0x88, 0x36, 0x16, 0xfe, 0x00, 0x06, 0xc8, 0x00, 0x12, + 0x49, 0xf1, 0xc4, 0x14, 0xfe, 0x00, 0x4e, 0x7e, 0x81, 0x30, 0xfe, 0x00, + 0x4d, 0x02, 0x8f, 0x34, 0xfe, 0x40, 0x4d, 0xed, 0x0f, 0x40, 0xfe, 0x00, + 0x58, 0xd4, 0x28, 0x3c, 0xfe, 0x00, 0xa3, 0x34, 0x54, 0xc7, 0x43, 0x3e, + 0xfe, 0x00, 0x4b, 0xfb, 0x22, 0x36, 0xfe, 0x00, 0x4e, 0x36, 0x28, 0x48, + 0xfe, 0x00, 0x56, 0x79, 0x09, 0x3a, 0xfe, 0x00, 0x06, 0xad, 0x02, 0x01, + 0xff, 0x4e, 0x67, 0x6c, 0x44, 0xfe, 0x00, 0x0e, 0xda, 0x28, 0x01, 0xff, + 0x44, 0x8b, 0x09, 0x18, 0xfe, 0x00, 0x44, 0xb4, 0xf6, 0x18, 0xfe, 0x40, + 0x4d, 0x68, 0x6c, 0x42, 0xfe, 0x00, 0x4c, 0xdf, 0x0b, 0x38, 0xfe, 0x40, + 0x04, 0xc4, 0x00, 0x06, 0x47, 0x08, 0x8f, 0x33, 0xfe, 0x40, 0x4d, 0xed, + 0x0f, 0x3f, 0xfe, 0x00, 0x58, 0xd4, 0x28, 0x3b, 0xfe, 0x00, 0xa3, 0x29, + 0x54, 0xc7, 0x43, 0x3d, 0xfe, 0x00, 0x4b, 0xfb, 0x22, 0x35, 0xfe, 0x00, + 0x4e, 0x36, 0x28, 0x47, 0xfe, 0x00, 0x56, 0x79, 0x09, 0x39, 0xfe, 0x00, + 0x06, 0xad, 0x02, 0x01, 0xff, 0x4e, 0x67, 0x6c, 0x43, 0xfe, 0x00, 0x52, + 0xda, 0x28, 0x17, 0xfe, 0x40, 0x4d, 0x68, 0x6c, 0x41, 0xfe, 0x00, 0x4c, + 0xdf, 0x0b, 0x37, 0xfe, 0x40, 0x45, 0x13, 0x05, 0x11, 0xfe, 0x00, 0x49, + 0x4f, 0x17, 0x12, 0xfe, 0x40, 0x46, 0x97, 0xd6, 0x31, 0xfe, 0x00, 0x46, + 0x0e, 0xe4, 0x32, 0xfe, 0x00, 0x4f, 0xae, 0x00, 0x15, 0xfe, 0x40, 0x43, + 0xd7, 0x02, 0x13, 0xfe, 0x00, 0x43, 0x15, 0x05, 0x10, 0xfe, 0x40, 0x43, + 0x47, 0x19, 0xc3, 0xfa, 0x01, 0x46, 0x40, 0x1e, 0xc4, 0xfa, 0x01, 0x45, + 0xa1, 0x2e, 0x30, 0xf9, 0x41, 0x80, 0x01, 0xff, 0x06, 0x5c, 0x00, 0x1c, + 0x55, 0x03, 0x3c, 0xe8, 0x22, 0x00, 0x06, 0x91, 0x2a, 0x06, 0x4e, 0xd2, + 0x81, 0xb0, 0x22, 0x40, 0x45, 0x89, 0x0d, 0x7c, 0x22, 0x00, 0x4a, 0x0e, + 0x3c, 0x7e, 0x22, 0x40, 0x4f, 0xce, 0x6d, 0xb7, 0x2a, 0x00, 0x4b, 0x16, + 0x14, 0xb3, 0x2a, 0x00, 0x04, 0xac, 0x24, 0x11, 0x0c, 0x94, 0x2c, 0x01, + 0xff, 0x4b, 0x16, 0x14, 0xaf, 0x2a, 0x00, 0x4c, 0xa0, 0x2c, 0xb1, 0x2a, + 0x40, 0x4f, 0xce, 0x6d, 0xb9, 0x2a, 0x00, 0x48, 0x86, 0x0d, 0xb5, 0x2a, + 0x40, 0x4f, 0xeb, 0x6e, 0xa9, 0xf5, 0x01, 0x05, 0x3e, 0xb5, 0xbe, 0x01, + 0x44, 0xb4, 0xf7, 0x29, 0xf4, 0x01, 0xb0, 0x9f, 0x01, 0x4d, 0xac, 0x8c, + 0xfe, 0xf4, 0x01, 0xb3, 0x6b, 0xb4, 0x4f, 0xb5, 0x24, 0x04, 0x15, 0x01, + 0x01, 0xff, 0x02, 0x10, 0x00, 0x0f, 0xb3, 0x01, 0xff, 0x4b, 0xaa, 0xa3, + 0xfe, 0x23, 0x00, 0x45, 0x17, 0x08, 0xfb, 0x23, 0x40, 0x47, 0x15, 0x08, + 0xfd, 0x23, 0x00, 0x4b, 0x85, 0x9d, 0xfc, 0x23, 0x40, 0x42, 0x3b, 0x15, + 0x5d, 0xf4, 0x01, 0x48, 0xaf, 0xcd, 0x57, 0xf3, 0x01, 0x47, 0xe6, 0x49, + 0xa3, 0x00, 0x00, 0x4b, 0x46, 0xa7, 0xd7, 0xfa, 0x01, 0x05, 0xa0, 0x01, + 0x01, 0xff, 0x48, 0x85, 0x20, 0x3e, 0xf6, 0x01, 0x44, 0x0c, 0x08, 0x21, + 0xf6, 0x41, 0x48, 0xc2, 0x67, 0x72, 0xf3, 0x01, 0xa1, 0x06, 0x49, 0x81, + 0xc5, 0xb4, 0xfa, 0x41, 0x50, 0x4f, 0x47, 0xb0, 0xf6, 0x01, 0x42, 0x1e, + 0x00, 0x54, 0xf9, 0x41, 0x45, 0xca, 0xeb, 0xe7, 0x2b, 0x00, 0x4f, 0x3b, + 0x6a, 0x16, 0x23, 0x00, 0xb4, 0x01, 0xff, 0x03, 0x13, 0x00, 0x06, 0x43, + 0xb3, 0x32, 0xee, 0xf4, 0x41, 0x44, 0xe7, 0x2e, 0xef, 0xf4, 0x01, 0x44, + 0xb9, 0x00, 0x12, 0x30, 0xc0, 0x00, 0x45, 0x0b, 0x08, 0x20, 0x30, 0x40, + 0x0d, 0x61, 0x83, 0x06, 0x44, 0x49, 0x1a, 0x7f, 0xf3, 0x41, 0x4a, 0xe2, + 0xaf, 0x2c, 0x20, 0x00, 0x47, 0x5f, 0x03, 0x69, 0x20, 0x40, 0x43, 0xb7, + 0x67, 0x93, 0xf6, 0x81, 0x06, 0x47, 0xa6, 0xd9, 0x6e, 0xf4, 0x41, 0x51, + 0x68, 0x60, 0xa8, 0xf6, 0x41, 0xa1, 0x9c, 0x01, 0xe4, 0x8b, 0x00, 0x00, + 0xf5, 0x8c, 0x00, 0xc0, 0x00, 0x44, 0xff, 0x09, 0xa0, 0xfa, 0x01, 0xb3, + 0x29, 0x42, 0x1e, 0x00, 0x47, 0x26, 0xc0, 0x00, 0x06, 0x5e, 0x1c, 0x01, + 0xff, 0xa6, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0xd4, 0x2b, 0x00, + 0x42, 0x15, 0x02, 0xd3, 0x2b, 0x40, 0x43, 0xf9, 0x05, 0xd6, 0x2b, 0x00, + 0x43, 0xf6, 0x06, 0xd5, 0x2b, 0x40, 0x45, 0x59, 0x03, 0x2b, 0x00, 0x80, + 0x06, 0x4b, 0x7a, 0x9d, 0xb1, 0x00, 0x40, 0x80, 0x01, 0xff, 0x51, 0x10, + 0x14, 0x72, 0x2a, 0x00, 0x03, 0x08, 0x06, 0x36, 0x05, 0x51, 0x00, 0x01, + 0xff, 0x4e, 0x91, 0x6e, 0x28, 0x2a, 0x00, 0x57, 0x6c, 0x2f, 0x23, 0x2a, + 0x00, 0x49, 0x6d, 0x13, 0x25, 0x2a, 0x00, 0xb3, 0x11, 0x06, 0x71, 0x24, + 0x01, 0xff, 0x45, 0x5c, 0x00, 0x24, 0x2a, 0x00, 0x45, 0x20, 0x07, 0x26, + 0x2a, 0x40, 0x51, 0xe4, 0x57, 0x22, 0x2a, 0x00, 0x4c, 0x24, 0x9b, 0x27, + 0x2a, 0x40, 0x50, 0x7a, 0x67, 0x2d, 0x2a, 0x00, 0x51, 0x46, 0x60, 0x2e, + 0x2a, 0x00, 0x48, 0x01, 0x02, 0x39, 0x2a, 0x40, 0xa3, 0xb7, 0x04, 0x4c, + 0x40, 0x97, 0x0e, 0x21, 0x80, 0xa9, 0x04, 0xb9, 0x01, 0xff, 0x4c, 0x04, + 0x94, 0xdd, 0xf6, 0x01, 0x09, 0x17, 0xc0, 0x01, 0xff, 0x07, 0xd9, 0x7c, + 0xfe, 0x03, 0xa2, 0xef, 0x03, 0x09, 0xd7, 0xbd, 0xd2, 0x03, 0xa6, 0x8d, + 0x03, 0x08, 0xff, 0xcc, 0xf0, 0x02, 0xab, 0xb4, 0x02, 0x08, 0x67, 0xce, + 0x97, 0x02, 0x09, 0x19, 0xc4, 0xfa, 0x01, 0x49, 0x61, 0xc4, 0xbf, 0xf0, + 0x01, 0xb3, 0xb8, 0x01, 0xb4, 0x06, 0x4b, 0x53, 0xaa, 0xdf, 0xf0, 0x41, + 0x06, 0x1c, 0xc4, 0x93, 0x01, 0x08, 0x6f, 0xcc, 0x77, 0x05, 0x84, 0xf0, + 0x1d, 0x06, 0x4a, 0xe7, 0x01, 0xff, 0x45, 0x57, 0xeb, 0xd2, 0xf0, 0x01, + 0x48, 0xbf, 0xca, 0xc2, 0xf0, 0x01, 0x46, 0x20, 0x8b, 0xb2, 0xf0, 0x01, + 0x46, 0xfa, 0xe5, 0xa2, 0xf0, 0x41, 0xd1, 0xe1, 0xf0, 0x81, 0x29, 0xd2, + 0xe2, 0xf0, 0x81, 0x1c, 0xd3, 0xe3, 0xf0, 0x01, 0xd4, 0xe4, 0xf0, 0x01, + 0xd5, 0xe5, 0xf0, 0x01, 0xd6, 0xe6, 0xf0, 0x01, 0xd7, 0xe7, 0xf0, 0x01, + 0xd8, 0xe8, 0xf0, 0x01, 0xd9, 0xe9, 0xf0, 0x41, 0xd0, 0xf4, 0xf0, 0x01, + 0xd1, 0xf5, 0xf0, 0x41, 0xd0, 0xea, 0xf0, 0x01, 0xd1, 0xeb, 0xf0, 0x01, + 0xd2, 0xec, 0xf0, 0x01, 0xd3, 0xed, 0xf0, 0x01, 0xd4, 0xee, 0xf0, 0x01, + 0xd5, 0xef, 0xf0, 0x01, 0xd6, 0xf0, 0xf0, 0x01, 0xd7, 0xf1, 0xf0, 0x01, + 0xd8, 0xf2, 0xf0, 0x01, 0xd9, 0xf3, 0xf0, 0x41, 0x45, 0x57, 0xeb, 0xd3, + 0xf0, 0x01, 0x48, 0xbf, 0xca, 0xc3, 0xf0, 0x01, 0x46, 0x20, 0x8b, 0xb3, + 0xf0, 0x01, 0x46, 0xfa, 0xe5, 0xa3, 0xf0, 0x41, 0x45, 0x57, 0xeb, 0xda, + 0xf0, 0x01, 0x48, 0xbf, 0xca, 0xca, 0xf0, 0x01, 0x46, 0x20, 0x8b, 0xba, + 0xf0, 0x01, 0x46, 0xfa, 0xe5, 0xaa, 0xf0, 0x41, 0x08, 0xaf, 0xcb, 0x1d, + 0x06, 0x30, 0xe3, 0x01, 0xff, 0x45, 0x57, 0xeb, 0xd6, 0xf0, 0x01, 0x48, + 0xbf, 0xca, 0xc6, 0xf0, 0x01, 0x46, 0x20, 0x8b, 0xb6, 0xf0, 0x01, 0x46, + 0xfa, 0xe5, 0xa6, 0xf0, 0x41, 0x45, 0x57, 0xeb, 0xd7, 0xf0, 0x01, 0x48, + 0xbf, 0xca, 0xc7, 0xf0, 0x01, 0x46, 0x20, 0x8b, 0xb7, 0xf0, 0x01, 0x46, + 0xfa, 0xe5, 0xa7, 0xf0, 0x41, 0x45, 0x57, 0xeb, 0xdd, 0xf0, 0x01, 0x48, + 0xbf, 0xca, 0xcd, 0xf0, 0x01, 0x46, 0x20, 0x8b, 0xbd, 0xf0, 0x01, 0x46, + 0xfa, 0xe5, 0xad, 0xf0, 0x41, 0x45, 0x57, 0xeb, 0xd9, 0xf0, 0x01, 0x48, + 0xbf, 0xca, 0xc9, 0xf0, 0x01, 0x46, 0x20, 0x8b, 0xb9, 0xf0, 0x01, 0x46, + 0xfa, 0xe5, 0xa9, 0xf0, 0x41, 0x07, 0x9f, 0x3b, 0x1d, 0x09, 0x33, 0xc2, + 0x01, 0xff, 0x45, 0x57, 0xeb, 0xdc, 0xf0, 0x01, 0x48, 0xbf, 0xca, 0xcc, + 0xf0, 0x01, 0x46, 0x20, 0x8b, 0xbc, 0xf0, 0x01, 0x46, 0xfa, 0xe5, 0xac, + 0xf0, 0x41, 0x45, 0x57, 0xeb, 0xde, 0xf0, 0x01, 0x48, 0xbf, 0xca, 0xce, + 0xf0, 0x01, 0x46, 0x20, 0x8b, 0xbe, 0xf0, 0x01, 0x46, 0xfa, 0xe5, 0xae, + 0xf0, 0x41, 0x45, 0x57, 0xeb, 0xdb, 0xf0, 0x01, 0x48, 0xbf, 0xca, 0xcb, + 0xf0, 0x01, 0x46, 0x20, 0x8b, 0xbb, 0xf0, 0x01, 0x46, 0xfa, 0xe5, 0xab, + 0xf0, 0x41, 0x07, 0xf4, 0xd7, 0x26, 0xaf, 0x01, 0xff, 0x42, 0x61, 0x03, + 0xe0, 0xf0, 0x01, 0x06, 0x17, 0xda, 0x01, 0xff, 0x45, 0x57, 0xeb, 0xd4, + 0xf0, 0x01, 0x48, 0xbf, 0xca, 0xc4, 0xf0, 0x01, 0x46, 0x20, 0x8b, 0xb4, + 0xf0, 0x01, 0x46, 0xfa, 0xe5, 0xa4, 0xf0, 0x41, 0x45, 0x57, 0xeb, 0xd5, + 0xf0, 0x01, 0x48, 0xbf, 0xca, 0xc5, 0xf0, 0x01, 0x46, 0x20, 0x8b, 0xb5, + 0xf0, 0x01, 0x46, 0xfa, 0xe5, 0xa5, 0xf0, 0x41, 0x45, 0x57, 0xeb, 0xd8, + 0xf0, 0x01, 0x48, 0xbf, 0xca, 0xc8, 0xf0, 0x01, 0x46, 0x20, 0x8b, 0xb8, + 0xf0, 0x01, 0x46, 0xfa, 0xe5, 0xa8, 0xf0, 0x41, 0x43, 0x0e, 0x03, 0xa0, + 0xf0, 0x01, 0x4a, 0xf4, 0xb1, 0xcf, 0xf0, 0x41, 0x45, 0x57, 0xeb, 0xd1, + 0xf0, 0x01, 0x48, 0xbf, 0xca, 0xc1, 0xf0, 0x01, 0x46, 0x20, 0x8b, 0xb1, + 0xf0, 0x01, 0x46, 0xfa, 0xe5, 0xa1, 0xf0, 0x41, 0x4c, 0x08, 0x90, 0x0f, + 0x21, 0x40, 0x43, 0xaa, 0x01, 0xa7, 0xfa, 0x01, 0x05, 0x47, 0x45, 0x01, + 0xff, 0x4d, 0x5b, 0x88, 0x18, 0x23, 0x00, 0x47, 0x8f, 0xdd, 0xd0, 0xf6, + 0x41, 0x42, 0x36, 0x01, 0xcf, 0x26, 0x80, 0x77, 0xe5, 0x67, 0xf9, 0x01, + 0xe7, 0x16, 0xf4, 0x81, 0x5f, 0xac, 0x4d, 0xae, 0x1b, 0xb3, 0x0d, 0x47, + 0x31, 0xdc, 0xd4, 0x22, 0xc0, 0x00, 0x4d, 0xd6, 0x83, 0xda, 0x2a, 0x40, + 0x43, 0x23, 0x57, 0x53, 0x26, 0x00, 0x43, 0xe0, 0x3e, 0x2b, 0xf5, 0x41, + 0x43, 0xdd, 0x19, 0x85, 0xfa, 0x01, 0x02, 0x3b, 0x15, 0x1a, 0xa5, 0x0c, + 0x47, 0xa6, 0x2a, 0x77, 0xfa, 0x01, 0x4a, 0xf9, 0x13, 0x2f, 0x27, 0x40, + 0x4b, 0x67, 0x9c, 0x8d, 0xf3, 0x01, 0x45, 0x58, 0xea, 0x4d, 0xf3, 0x41, + 0x4a, 0xfc, 0xae, 0x0c, 0xf9, 0x01, 0x48, 0xab, 0x2e, 0x0f, 0xf9, 0x41, + 0x49, 0x8e, 0xa2, 0xb6, 0x00, 0x00, 0x48, 0x0f, 0xcb, 0xa9, 0xf4, 0x01, + 0xec, 0x8a, 0xf4, 0x41, 0x80, 0x01, 0xff, 0x44, 0x0c, 0x08, 0x37, 0xf4, + 0x01, 0x44, 0xff, 0x17, 0x3d, 0xf4, 0x41, 0x42, 0x68, 0x00, 0xdd, 0xfa, + 0x01, 0x48, 0xe7, 0xd1, 0xfb, 0xf6, 0x41, 0xa1, 0xde, 0x01, 0x09, 0xea, + 0xbf, 0xcd, 0x01, 0xaf, 0x01, 0xff, 0x08, 0x4f, 0xcb, 0x06, 0x43, 0xc7, + 0x29, 0xdb, 0x2b, 0x40, 0x07, 0x13, 0x06, 0x33, 0x07, 0x37, 0x3c, 0x06, + 0x4e, 0xc0, 0x82, 0x1f, 0x09, 0x41, 0x43, 0x7a, 0x0b, 0x16, 0x09, 0x81, + 0x1c, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x17, 0x09, 0x01, 0x44, 0x25, + 0x01, 0x1b, 0x09, 0x01, 0xb7, 0x01, 0xff, 0x44, 0xe9, 0x1e, 0x18, 0x09, + 0x01, 0xef, 0x1a, 0x09, 0x41, 0x48, 0x3e, 0x12, 0x19, 0x09, 0x41, 0xa1, + 0x7b, 0x43, 0xe5, 0x09, 0x01, 0x09, 0x01, 0x44, 0x7a, 0xeb, 0x03, 0x09, + 0x01, 0x44, 0xc8, 0xf5, 0x02, 0x09, 0x01, 0x42, 0xb0, 0x01, 0x04, 0x09, + 0x81, 0x5e, 0x43, 0x15, 0x54, 0x0a, 0x09, 0x01, 0x44, 0x0e, 0xee, 0x0b, + 0x09, 0x01, 0x43, 0xb4, 0x05, 0x0c, 0x09, 0x01, 0x43, 0x18, 0x24, 0x0d, + 0x09, 0x01, 0x42, 0x6f, 0x02, 0x10, 0x09, 0x01, 0x43, 0x8d, 0xfa, 0x12, + 0x09, 0x01, 0x44, 0x3f, 0xd0, 0x13, 0x09, 0x01, 0xb3, 0x20, 0xb4, 0x12, + 0x43, 0x54, 0xa9, 0x05, 0x09, 0x01, 0x43, 0xfd, 0x54, 0x09, 0x09, 0x01, + 0x43, 0x5a, 0x78, 0x06, 0x09, 0x41, 0x42, 0xb4, 0x25, 0x15, 0x09, 0x01, + 0x42, 0x14, 0x06, 0x08, 0x09, 0x41, 0x43, 0x0c, 0x02, 0x11, 0x09, 0x01, + 0x43, 0x03, 0x87, 0x0e, 0x09, 0x01, 0x43, 0x48, 0x17, 0x14, 0x09, 0x41, + 0xf4, 0x07, 0x09, 0x41, 0x42, 0x9e, 0x01, 0x0f, 0x09, 0x01, 0x42, 0x24, + 0x00, 0x00, 0x09, 0x41, 0x52, 0x75, 0x53, 0x36, 0x17, 0x00, 0x52, 0xd1, + 0x57, 0x35, 0x17, 0x40, 0x06, 0x22, 0xe2, 0xc7, 0x02, 0x10, 0x3a, 0x67, + 0x01, 0xff, 0x45, 0xce, 0x00, 0xd9, 0x01, 0x01, 0xa2, 0x9a, 0x02, 0xa3, + 0xe3, 0x01, 0x02, 0x3b, 0x01, 0xd2, 0x01, 0x45, 0xac, 0xeb, 0xee, 0x01, + 0x01, 0x45, 0x65, 0xec, 0xf8, 0x01, 0x01, 0xa7, 0xb7, 0x01, 0xa8, 0xa2, + 0x01, 0x02, 0xc3, 0x01, 0x93, 0x01, 0x02, 0x6c, 0x00, 0x82, 0x01, 0x47, + 0x47, 0xda, 0xf7, 0x01, 0x01, 0xb0, 0x5f, 0xb2, 0x51, 0xb3, 0x29, 0xb4, + 0x15, 0x44, 0xe0, 0xc6, 0xf3, 0x01, 0x01, 0xb7, 0x01, 0xff, 0x48, 0x7f, + 0xc9, 0xfc, 0x01, 0x01, 0x44, 0xa2, 0x2e, 0xd5, 0x01, 0x41, 0x4c, 0x28, + 0x91, 0xd2, 0x01, 0x01, 0x44, 0x54, 0xf6, 0xd8, 0x01, 0x01, 0x44, 0x51, + 0x63, 0xf0, 0x01, 0x41, 0x42, 0x3e, 0x2f, 0xdf, 0x01, 0x01, 0x02, 0x49, + 0x00, 0x12, 0x44, 0x9b, 0x0b, 0xe5, 0x01, 0x01, 0x48, 0xbf, 0xcd, 0xfb, + 0x01, 0x01, 0x47, 0x69, 0xdc, 0xfa, 0x01, 0x41, 0x43, 0x57, 0x25, 0xdb, + 0x01, 0x01, 0xf0, 0xe8, 0x01, 0x41, 0x42, 0x57, 0x00, 0xed, 0x01, 0x01, + 0x46, 0xe6, 0xe4, 0xf5, 0x01, 0x41, 0x46, 0xc4, 0xdf, 0xf4, 0x01, 0x01, + 0x49, 0x06, 0xaf, 0xd0, 0x01, 0x01, 0xac, 0x01, 0xff, 0x48, 0x0f, 0xc9, + 0xf2, 0x01, 0x01, 0x49, 0x1a, 0xc6, 0xd1, 0x01, 0x41, 0x46, 0x20, 0xe4, + 0xdd, 0x01, 0x01, 0x45, 0x79, 0xf1, 0xde, 0x01, 0x41, 0xe4, 0xe0, 0x01, + 0x01, 0x42, 0xe1, 0x0b, 0xf6, 0x01, 0x41, 0x45, 0xa2, 0xc8, 0xd6, 0x01, + 0x01, 0x43, 0x03, 0x00, 0xea, 0x01, 0x01, 0x43, 0x28, 0x05, 0xe9, 0x01, + 0x41, 0x47, 0x00, 0xd5, 0xd7, 0x01, 0x01, 0x45, 0xd4, 0xa6, 0xf9, 0x01, + 0x41, 0x44, 0xf4, 0xf6, 0xe3, 0x01, 0x01, 0x42, 0x32, 0x00, 0xef, 0x01, + 0x41, 0xa1, 0x22, 0x44, 0x72, 0x4c, 0xd4, 0x01, 0x01, 0x43, 0x7d, 0x4d, + 0xdc, 0x01, 0x01, 0xaf, 0x01, 0xff, 0x44, 0x08, 0xf7, 0xe6, 0x01, 0x01, + 0x42, 0xb6, 0x05, 0xe4, 0x01, 0xc1, 0x00, 0x54, 0x6b, 0x45, 0xfd, 0x01, + 0x41, 0x45, 0x8e, 0x75, 0xd3, 0x01, 0x01, 0x4d, 0x92, 0x8c, 0xe2, 0x01, + 0x01, 0xf4, 0xec, 0x01, 0x41, 0x42, 0x27, 0x01, 0xf1, 0x01, 0x81, 0x12, + 0xaf, 0x06, 0x48, 0xc7, 0xd1, 0xeb, 0x01, 0x41, 0x47, 0xc2, 0xd9, 0xe1, + 0x01, 0x01, 0xf7, 0xda, 0x01, 0x41, 0x44, 0xb5, 0x88, 0xe7, 0x01, 0x41, + 0x50, 0xfa, 0x64, 0x75, 0xa8, 0x00, 0x07, 0x13, 0x06, 0x38, 0x05, 0xb9, + 0x00, 0x28, 0xb3, 0x01, 0xff, 0x4f, 0xd9, 0x71, 0x74, 0xa8, 0x00, 0xb5, + 0x01, 0xff, 0x0f, 0xeb, 0x6a, 0x06, 0x52, 0xe7, 0x56, 0x72, 0xa8, 0x40, + 0x42, 0x71, 0x00, 0x71, 0xa8, 0x00, 0x42, 0xa9, 0x01, 0x67, 0xa8, 0x00, + 0x42, 0xdf, 0x23, 0x68, 0xa8, 0x40, 0x4b, 0x66, 0xa0, 0x77, 0xa8, 0x00, + 0x44, 0xa4, 0x02, 0x76, 0xa8, 0x40, 0xe1, 0x5d, 0xa8, 0x80, 0x92, 0x02, + 0x42, 0x16, 0x00, 0x4e, 0xa8, 0x00, 0xa3, 0xf8, 0x01, 0xa4, 0xe5, 0x01, + 0xe5, 0x60, 0xa8, 0x80, 0xdb, 0x01, 0x42, 0x0c, 0x08, 0x64, 0xa8, 0x00, + 0xa7, 0xc8, 0x01, 0x42, 0x22, 0x00, 0x5c, 0xa8, 0x00, 0xe9, 0x5e, 0xa8, + 0x00, 0x42, 0x78, 0x1a, 0x46, 0xa8, 0x00, 0xab, 0xab, 0x01, 0x42, 0x74, + 0x00, 0x59, 0xa8, 0x00, 0x42, 0x6c, 0x00, 0x4f, 0xa8, 0x00, 0xae, 0x86, + 0x01, 0xef, 0x61, 0xa8, 0x00, 0xb0, 0x76, 0x42, 0x11, 0x15, 0x62, 0xa8, + 0x00, 0x42, 0x71, 0x00, 0x58, 0xa8, 0x00, 0xb3, 0x58, 0xb4, 0x33, 0xf5, + 0x5f, 0xa8, 0x00, 0x05, 0x2c, 0x1e, 0x1f, 0x42, 0xa9, 0x01, 0x53, 0xa8, + 0x00, 0x42, 0x5b, 0x28, 0x63, 0xa8, 0x00, 0x42, 0xdf, 0x23, 0x57, 0xa8, + 0x00, 0xba, 0x01, 0xff, 0xe1, 0x55, 0xa8, 0x00, 0x42, 0x22, 0x00, 0x54, + 0xa8, 0x40, 0x44, 0x85, 0x11, 0x6f, 0xa8, 0x00, 0x48, 0x5f, 0xcd, 0x6e, + 0xa8, 0x40, 0xe1, 0x48, 0xa8, 0x00, 0x42, 0x22, 0x00, 0x49, 0xa8, 0x00, + 0xb3, 0x0d, 0xb4, 0x01, 0xff, 0xe1, 0x69, 0xa8, 0x00, 0x42, 0x22, 0x00, + 0x6a, 0xa8, 0x40, 0xe1, 0x50, 0xa8, 0x00, 0x42, 0x22, 0x00, 0x51, 0xa8, + 0x40, 0xe1, 0x5b, 0xa8, 0x00, 0x42, 0x22, 0x00, 0x5a, 0xa8, 0x00, 0x46, + 0x29, 0x0a, 0x56, 0xa8, 0x40, 0xe1, 0x4c, 0xa8, 0x00, 0x42, 0x22, 0x00, + 0x4d, 0xa8, 0x40, 0xe1, 0x4b, 0xa8, 0x00, 0x42, 0x24, 0x02, 0x43, 0xa8, + 0x00, 0x42, 0x2a, 0x05, 0x6c, 0xa8, 0x00, 0x42, 0xdf, 0x23, 0x47, 0xa8, + 0x40, 0xe1, 0x40, 0xa8, 0x00, 0x42, 0x22, 0x00, 0x41, 0xa8, 0x40, 0xe1, + 0x42, 0xa8, 0x00, 0x42, 0x24, 0x02, 0x65, 0xa8, 0x40, 0xe5, 0x66, 0xa8, + 0x40, 0xe1, 0x4a, 0xa8, 0x00, 0x42, 0x7b, 0x08, 0x6b, 0xa8, 0x00, 0x42, + 0x59, 0x00, 0x52, 0xa8, 0x40, 0xe1, 0x44, 0xa8, 0x80, 0x06, 0x42, 0x22, + 0x00, 0x45, 0xa8, 0x40, 0x49, 0x15, 0x25, 0x73, 0xa8, 0x40, 0x4b, 0x44, + 0xa4, 0x6d, 0xa8, 0x00, 0x4b, 0x01, 0xa8, 0x70, 0xa8, 0x40, 0xa1, 0xeb, + 0x01, 0x48, 0x07, 0xaf, 0xb6, 0xf6, 0x01, 0xae, 0xc4, 0x01, 0x4c, 0x3c, + 0x98, 0xc2, 0xfa, 0x01, 0xb2, 0x14, 0xb3, 0x06, 0x48, 0x6f, 0xd1, 0xeb, + 0xf9, 0x41, 0x48, 0x97, 0xcb, 0xa7, 0x20, 0x00, 0x46, 0xc6, 0xb6, 0xb1, + 0x20, 0x40, 0x80, 0x93, 0x01, 0x49, 0x02, 0xa1, 0x25, 0x00, 0x00, 0x4c, + 0xbc, 0x93, 0xad, 0xf3, 0x01, 0x51, 0x9d, 0x5e, 0x7e, 0x26, 0x00, 0x4a, + 0x5e, 0x93, 0xc2, 0x27, 0x80, 0x74, 0xb3, 0x01, 0xff, 0x4c, 0x74, 0x93, + 0x23, 0xf6, 0x01, 0x02, 0x10, 0x00, 0x06, 0x47, 0x86, 0xda, 0x06, 0x23, + 0x40, 0x80, 0x06, 0x4b, 0x35, 0x8b, 0xbb, 0xf4, 0x41, 0x4d, 0x5c, 0x85, + 0x47, 0xf6, 0x01, 0x48, 0x67, 0xca, 0xd7, 0xf9, 0x01, 0x4f, 0x54, 0x6f, + 0x38, 0xf9, 0x01, 0x48, 0x23, 0x87, 0x4d, 0xf6, 0x01, 0x03, 0x08, 0x06, + 0x31, 0x61, 0x1d, 0x0f, 0x4c, 0xf6, 0x01, 0x05, 0x51, 0x00, 0x01, 0xff, + 0xa2, 0x18, 0x45, 0x5c, 0xeb, 0xc5, 0xfa, 0x01, 0x4c, 0xb0, 0x93, 0x4f, + 0xf6, 0x01, 0x49, 0x24, 0xbf, 0xd5, 0xf9, 0x01, 0x4c, 0xb4, 0x98, 0x4e, + 0xf6, 0x41, 0x43, 0x5f, 0x07, 0xf9, 0x26, 0x00, 0x49, 0x64, 0xc1, 0x71, + 0xf4, 0x41, 0x4e, 0x48, 0x7d, 0xd8, 0xf9, 0x01, 0x4b, 0x22, 0xa8, 0xd6, + 0xf9, 0x41, 0x47, 0x69, 0x06, 0xe1, 0x2a, 0x40, 0x4a, 0x66, 0xb3, 0x30, + 0x20, 0x00, 0x44, 0x5a, 0x03, 0x4c, 0x21, 0x00, 0x51, 0xdf, 0x60, 0x31, + 0x20, 0x40, 0x56, 0x01, 0x34, 0x86, 0xf5, 0x01, 0x43, 0xce, 0xc5, 0x0f, + 0x27, 0x00, 0x44, 0xfc, 0xf5, 0x27, 0xf4, 0x01, 0x49, 0x0c, 0xc5, 0x14, + 0xf6, 0x01, 0x46, 0xbc, 0x1c, 0xe4, 0x26, 0x40, 0x44, 0x95, 0xa6, 0xdb, + 0xfa, 0x01, 0xa3, 0x0a, 0x44, 0x03, 0xf1, 0x5c, 0xf9, 0x01, 0xf2, 0x50, + 0xf3, 0x41, 0x48, 0x64, 0x1a, 0x2e, 0x26, 0x00, 0xe8, 0x51, 0xf3, 0x01, + 0x43, 0x35, 0x01, 0x9a, 0xf9, 0x41, 0xe6, 0x2c, 0x20, 0x00, 0xe9, 0x69, + 0x20, 0x40, 0x45, 0x43, 0xeb, 0xe6, 0xf4, 0x01, 0xe4, 0x80, 0x00, 0x80, + 0xb6, 0x14, 0xa7, 0x87, 0x14, 0x0b, 0xf2, 0xa1, 0xa3, 0x0d, 0xac, 0x94, + 0x0b, 0xae, 0x85, 0x0b, 0x47, 0x72, 0x86, 0xce, 0xf4, 0x01, 0xb2, 0x96, + 0x03, 0x02, 0xee, 0x00, 0xed, 0x02, 0x0a, 0x02, 0xb8, 0x06, 0x48, 0x1f, + 0xd2, 0x3e, 0xf4, 0x41, 0x4c, 0x6c, 0x2a, 0xf5, 0x1a, 0x81, 0xcc, 0x02, + 0xac, 0x62, 0x4e, 0x8e, 0x7d, 0xef, 0x1a, 0x81, 0x4c, 0x4b, 0xda, 0x69, + 0xe6, 0x1a, 0x81, 0x2f, 0x07, 0x89, 0xdb, 0x01, 0xff, 0x4c, 0x6c, 0x2a, + 0xe7, 0x1a, 0x81, 0x1d, 0x44, 0xc2, 0x2e, 0xec, 0x1a, 0xc1, 0x00, 0x80, + 0x01, 0xff, 0x45, 0x7c, 0x2e, 0xee, 0x1a, 0x01, 0x44, 0xd7, 0x02, 0xeb, + 0x1a, 0xc1, 0x00, 0x46, 0x7b, 0x2e, 0xed, 0x1a, 0x41, 0x46, 0x7b, 0x2e, + 0xea, 0x1a, 0x41, 0x80, 0x01, 0xff, 0x45, 0x7c, 0x2e, 0xe9, 0x1a, 0x01, + 0x44, 0xd7, 0x02, 0xe5, 0x1a, 0xc1, 0x00, 0x46, 0x7b, 0x2e, 0xe8, 0x1a, + 0x41, 0x80, 0x01, 0xff, 0x45, 0x7c, 0x2e, 0xf2, 0x1a, 0x01, 0x4a, 0xbc, + 0xb2, 0xf1, 0x1a, 0x41, 0x06, 0x14, 0x06, 0x1d, 0x4f, 0xd6, 0x74, 0xf4, + 0x1a, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x45, 0x7c, 0x2e, 0xf7, 0x1a, 0x01, + 0x44, 0xd7, 0x02, 0xf3, 0x1a, 0xc1, 0x00, 0x46, 0x7b, 0x2e, 0xf6, 0x1a, + 0x41, 0xe1, 0xd5, 0x1a, 0x01, 0x42, 0x16, 0x00, 0xcc, 0x1a, 0x01, 0xa3, + 0xb0, 0x01, 0x42, 0x7b, 0x08, 0xc4, 0x1a, 0x01, 0xe5, 0xd6, 0x1a, 0x01, + 0xa6, 0x76, 0x42, 0x24, 0x02, 0xc9, 0x1a, 0x01, 0x42, 0x22, 0x00, 0xc8, + 0x1a, 0x01, 0xe9, 0xd7, 0x1a, 0x81, 0x61, 0xab, 0x55, 0x42, 0x74, 0x00, + 0xc2, 0x1a, 0x01, 0x42, 0x6c, 0x00, 0xc3, 0x1a, 0x01, 0xae, 0x3d, 0xef, + 0xd8, 0x1a, 0x01, 0xb0, 0x2d, 0x42, 0x71, 0x00, 0xd2, 0x1a, 0x01, 0x42, + 0x40, 0x06, 0xcb, 0x1a, 0x01, 0xb4, 0x15, 0xf5, 0xd9, 0x1a, 0x81, 0x0c, + 0x42, 0x61, 0x0b, 0xc6, 0x1a, 0x01, 0x42, 0x59, 0x00, 0xc5, 0x1a, 0x41, + 0xe1, 0xda, 0x1a, 0x41, 0xe1, 0xce, 0x1a, 0x01, 0x42, 0x22, 0x00, 0xcf, + 0x1a, 0x41, 0xe1, 0xc0, 0x1a, 0x01, 0x42, 0x22, 0x00, 0xd1, 0x1a, 0x41, + 0xe1, 0xd0, 0x1a, 0x01, 0x42, 0x24, 0x02, 0xc7, 0x1a, 0x41, 0xe1, 0xc1, + 0x1a, 0x01, 0x42, 0x22, 0x00, 0xca, 0x1a, 0x41, 0xe1, 0xdb, 0x1a, 0x41, + 0xe1, 0xd3, 0x1a, 0x01, 0x05, 0x56, 0x29, 0x01, 0xff, 0xeb, 0xdd, 0x1a, + 0x01, 0xec, 0xe1, 0x1a, 0x01, 0xed, 0xdf, 0x1a, 0x01, 0xee, 0xe0, 0x1a, + 0x81, 0x10, 0xf0, 0xdc, 0x1a, 0x01, 0xf4, 0xde, 0x1a, 0x01, 0xf7, 0xe2, + 0x1a, 0x01, 0xf9, 0xe4, 0x1a, 0x41, 0xe7, 0xe3, 0x1a, 0x41, 0xe1, 0xcd, + 0x1a, 0x01, 0x42, 0x22, 0x00, 0xd4, 0x1a, 0x41, 0x80, 0x01, 0xff, 0x45, + 0x7c, 0x2e, 0xf8, 0x1a, 0x01, 0x47, 0xb9, 0x30, 0xf0, 0x1a, 0x41, 0xa5, + 0x16, 0x09, 0x8c, 0xc0, 0x06, 0x4c, 0xa8, 0x98, 0xc2, 0xf6, 0x41, 0x52, + 0x87, 0x53, 0x91, 0x23, 0x00, 0x50, 0x3a, 0x6b, 0x92, 0x23, 0x40, 0x48, + 0x9b, 0x21, 0xfd, 0x2b, 0x00, 0x49, 0x18, 0xc2, 0xf3, 0xf6, 0x41, 0xa1, + 0xab, 0x07, 0x0b, 0xdf, 0xa0, 0x57, 0x43, 0x76, 0x08, 0x9c, 0xf9, 0x01, + 0xb4, 0x01, 0xff, 0x51, 0x6f, 0x59, 0x3d, 0x30, 0x00, 0x46, 0x5e, 0xe2, + 0xc4, 0xce, 0x81, 0x3b, 0x03, 0xf7, 0x0c, 0x0c, 0x4c, 0x58, 0x97, 0x50, + 0x32, 0x00, 0x48, 0x77, 0xd2, 0x89, 0xf3, 0x41, 0x80, 0x06, 0x58, 0x74, + 0x2b, 0x7d, 0x26, 0x40, 0x4c, 0x8c, 0x4a, 0x02, 0x22, 0x00, 0x05, 0xed, + 0x07, 0x01, 0xff, 0x48, 0x97, 0xc9, 0x8c, 0x00, 0x00, 0x44, 0xa5, 0x01, + 0x8b, 0x00, 0x00, 0x47, 0x59, 0x33, 0x8b, 0x00, 0x00, 0x42, 0x50, 0x02, + 0x8c, 0x00, 0x40, 0x49, 0xa8, 0x2f, 0x7a, 0xf7, 0x41, 0x06, 0xef, 0x06, + 0x8e, 0x06, 0x07, 0x45, 0xd7, 0xc2, 0x04, 0x0a, 0xfa, 0xb0, 0xc3, 0x02, + 0x12, 0xa3, 0x55, 0xb2, 0x02, 0x06, 0x05, 0x06, 0x55, 0x07, 0x37, 0x3c, + 0x01, 0xff, 0xa5, 0x42, 0xa6, 0x34, 0x48, 0x21, 0x56, 0x86, 0x24, 0x00, + 0xb3, 0x20, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x7d, 0x24, 0x00, 0x47, + 0x16, 0x5d, 0x80, 0x24, 0x00, 0x02, 0x15, 0x01, 0x01, 0xff, 0x43, 0x86, + 0x2d, 0x7f, 0x24, 0x00, 0x43, 0xea, 0x1e, 0x87, 0x24, 0x40, 0x48, 0xf3, + 0x53, 0x84, 0x24, 0x00, 0x46, 0x6f, 0x27, 0x83, 0x24, 0x40, 0x46, 0x0e, + 0x19, 0x82, 0x24, 0x00, 0x47, 0x9c, 0x5f, 0x81, 0x24, 0x40, 0x47, 0xc0, + 0x26, 0x85, 0x24, 0x00, 0x45, 0xe7, 0x72, 0x7e, 0x24, 0x40, 0x0f, 0x0b, + 0x06, 0x6d, 0x0d, 0x9b, 0x08, 0x01, 0xff, 0xe1, 0x9c, 0x24, 0x00, 0xe2, + 0x9d, 0x24, 0x00, 0xe3, 0x9e, 0x24, 0x00, 0xe4, 0x9f, 0x24, 0x00, 0xe5, + 0xa0, 0x24, 0x00, 0xe6, 0xa1, 0x24, 0x00, 0xe7, 0xa2, 0x24, 0x00, 0xe8, + 0xa3, 0x24, 0x00, 0xe9, 0xa4, 0x24, 0x00, 0xea, 0xa5, 0x24, 0x00, 0xeb, + 0xa6, 0x24, 0x00, 0xec, 0xa7, 0x24, 0x00, 0xed, 0xa8, 0x24, 0x00, 0xee, + 0xa9, 0x24, 0x00, 0xef, 0xaa, 0x24, 0x00, 0xf0, 0xab, 0x24, 0x00, 0xf1, + 0xac, 0x24, 0x00, 0xf2, 0xad, 0x24, 0x00, 0xf3, 0xae, 0x24, 0x00, 0xf4, + 0xaf, 0x24, 0x00, 0xf5, 0xb0, 0x24, 0x00, 0xf6, 0xb1, 0x24, 0x00, 0xf7, + 0xb2, 0x24, 0x00, 0xf8, 0xb3, 0x24, 0x00, 0xf9, 0xb4, 0x24, 0x00, 0xfa, + 0xb5, 0x24, 0x40, 0xe1, 0x10, 0xf1, 0x01, 0xe2, 0x11, 0xf1, 0x01, 0xe3, + 0x12, 0xf1, 0x01, 0xe4, 0x13, 0xf1, 0x01, 0xe5, 0x14, 0xf1, 0x01, 0xe6, + 0x15, 0xf1, 0x01, 0xe7, 0x16, 0xf1, 0x01, 0xe8, 0x17, 0xf1, 0x01, 0xe9, + 0x18, 0xf1, 0x01, 0xea, 0x19, 0xf1, 0x01, 0xeb, 0x1a, 0xf1, 0x01, 0xec, + 0x1b, 0xf1, 0x01, 0xed, 0x1c, 0xf1, 0x01, 0xee, 0x1d, 0xf1, 0x01, 0xef, + 0x1e, 0xf1, 0x01, 0xf0, 0x1f, 0xf1, 0x01, 0xf1, 0x20, 0xf1, 0x01, 0xf2, + 0x21, 0xf1, 0x01, 0xf3, 0x22, 0xf1, 0x01, 0xf4, 0x23, 0xf1, 0x01, 0xf5, + 0x24, 0xf1, 0x01, 0xf6, 0x25, 0xf1, 0x01, 0xf7, 0x26, 0xf1, 0x01, 0xf8, + 0x27, 0xf1, 0x01, 0xf9, 0x28, 0xf1, 0x01, 0xfa, 0x29, 0xf1, 0x41, 0x43, + 0x3e, 0x12, 0x1e, 0x32, 0x00, 0x44, 0x90, 0xf6, 0x1d, 0x32, 0x40, 0x48, + 0xef, 0xc8, 0x3f, 0x32, 0x00, 0xa3, 0xe5, 0x01, 0xa5, 0xd0, 0x01, 0xa6, + 0xad, 0x01, 0x44, 0x00, 0xf6, 0x32, 0x32, 0x00, 0x45, 0xff, 0xed, 0x38, + 0x32, 0x00, 0xad, 0x92, 0x01, 0xae, 0x83, 0x01, 0x43, 0x7a, 0x0b, 0x20, + 0x32, 0x00, 0x02, 0x88, 0x00, 0x60, 0xb3, 0x23, 0xb4, 0x0f, 0xb7, 0x01, + 0xff, 0x44, 0x8a, 0x00, 0x2c, 0x32, 0x00, 0x43, 0x3b, 0x2f, 0x2d, 0x32, + 0x40, 0x42, 0x92, 0x01, 0x29, 0x32, 0x00, 0x44, 0x25, 0x01, 0x22, 0x32, + 0x00, 0x42, 0x15, 0x02, 0x21, 0x32, 0x40, 0xa5, 0x2d, 0x42, 0x09, 0x24, + 0x25, 0x32, 0x00, 0x46, 0x9e, 0xe4, 0x33, 0x32, 0x00, 0x46, 0x04, 0xe5, + 0x35, 0x32, 0x00, 0xb4, 0x0d, 0xb5, 0x01, 0xff, 0xee, 0x30, 0x32, 0x00, + 0x47, 0x9b, 0xda, 0x3c, 0x32, 0x40, 0x43, 0x35, 0x01, 0x31, 0x32, 0x00, + 0x43, 0xa5, 0xfa, 0x3b, 0x32, 0x40, 0x42, 0x24, 0x00, 0x42, 0x32, 0x00, + 0x43, 0x07, 0x1f, 0x26, 0x32, 0x40, 0x43, 0x13, 0x2f, 0x43, 0x32, 0x00, + 0x47, 0x9f, 0x84, 0x39, 0x32, 0x00, 0xb3, 0x01, 0xff, 0x45, 0x53, 0x5f, + 0x3e, 0x32, 0x00, 0xf4, 0x41, 0x32, 0x40, 0x43, 0x2b, 0x05, 0x34, 0x32, + 0x00, 0x43, 0xf0, 0x05, 0x28, 0x32, 0x40, 0x44, 0x43, 0x10, 0x2e, 0x32, + 0x00, 0x43, 0xcd, 0x02, 0x2a, 0x32, 0x40, 0x47, 0xb9, 0xd6, 0x40, 0x32, + 0x00, 0xa9, 0x06, 0x43, 0xf6, 0x06, 0x23, 0x32, 0x40, 0x47, 0x44, 0xd9, + 0x36, 0x32, 0x00, 0x42, 0x88, 0x00, 0x2b, 0x32, 0x00, 0x42, 0x32, 0x00, + 0x24, 0x32, 0x40, 0x44, 0x95, 0x75, 0x2f, 0x32, 0x00, 0x44, 0xc9, 0x00, + 0x27, 0x32, 0x00, 0x49, 0x60, 0xc2, 0x3d, 0x32, 0x40, 0x43, 0x5f, 0x07, + 0x3a, 0x32, 0x00, 0x4d, 0x67, 0x8b, 0x37, 0x32, 0x40, 0xa3, 0xa5, 0x01, + 0x45, 0xbc, 0xaa, 0x0d, 0x32, 0x80, 0x97, 0x01, 0x45, 0xdd, 0xd1, 0x07, + 0x32, 0x80, 0x89, 0x01, 0xab, 0x6d, 0x45, 0x9a, 0xee, 0x04, 0x32, 0x80, + 0x60, 0x45, 0x0d, 0xef, 0x01, 0x32, 0x80, 0x53, 0xb0, 0x37, 0x45, 0x52, + 0xf0, 0x03, 0x32, 0x80, 0x2a, 0x44, 0x35, 0xc5, 0x06, 0x32, 0x80, 0x1d, + 0xb4, 0x01, 0xff, 0x46, 0x47, 0xdc, 0x0b, 0x32, 0x80, 0x0d, 0x45, 0xa4, + 0xd3, 0x02, 0x32, 0xc0, 0x00, 0x42, 0x19, 0x00, 0x10, 0x32, 0x40, 0x42, + 0x19, 0x00, 0x19, 0x32, 0x40, 0x42, 0x19, 0x00, 0x14, 0x32, 0x40, 0x42, + 0x19, 0x00, 0x11, 0x32, 0x40, 0x46, 0x81, 0xc8, 0x0c, 0x32, 0x80, 0x0d, + 0x44, 0x0d, 0x89, 0x05, 0x32, 0xc0, 0x00, 0x42, 0x19, 0x00, 0x13, 0x32, + 0x40, 0x42, 0x19, 0x00, 0x1a, 0x32, 0x40, 0x42, 0x19, 0x00, 0x0f, 0x32, + 0x40, 0x42, 0x19, 0x00, 0x12, 0x32, 0x40, 0x46, 0x79, 0xc8, 0x0a, 0x32, + 0x80, 0x0d, 0x45, 0x12, 0xa8, 0x00, 0x32, 0xc0, 0x00, 0x42, 0x19, 0x00, + 0x0e, 0x32, 0x40, 0x42, 0x19, 0x00, 0x18, 0x32, 0x40, 0x42, 0x19, 0x00, + 0x15, 0x32, 0x40, 0x42, 0x19, 0x00, 0x1b, 0x32, 0x40, 0x46, 0xa9, 0xd5, + 0x09, 0x32, 0x80, 0x12, 0x44, 0xaa, 0xd5, 0x08, 0x32, 0xc0, 0x00, 0x80, + 0x01, 0xff, 0xe1, 0x16, 0x32, 0x00, 0xf5, 0x1c, 0x32, 0x40, 0x42, 0x19, + 0x00, 0x17, 0x32, 0x40, 0x45, 0x7e, 0x0b, 0x7b, 0x24, 0x00, 0xa6, 0x29, + 0x44, 0x6d, 0x2c, 0x7c, 0x24, 0x00, 0x43, 0x7a, 0x0b, 0x74, 0x24, 0x00, + 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0x76, 0x24, 0x00, 0x42, + 0x15, 0x02, 0x75, 0x24, 0x40, 0x44, 0x06, 0x1f, 0x7a, 0x24, 0x00, 0x42, + 0x09, 0x24, 0x79, 0x24, 0x40, 0x43, 0xf9, 0x05, 0x78, 0x24, 0x00, 0x43, + 0xf6, 0x06, 0x77, 0x24, 0x40, 0x45, 0x39, 0xeb, 0x82, 0xfa, 0x01, 0x05, + 0x30, 0x11, 0x1c, 0x05, 0x9a, 0x3a, 0x01, 0xff, 0x42, 0x1e, 0x00, 0x25, + 0x22, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x51, 0x47, 0x05, 0xf2, 0x2a, + 0x00, 0x4e, 0x9b, 0x40, 0xf3, 0x2a, 0x40, 0x4a, 0xfa, 0x21, 0x29, 0x20, + 0x00, 0x42, 0x90, 0x08, 0x0f, 0x2e, 0x00, 0x47, 0x19, 0x76, 0x4d, 0x2e, + 0x40, 0x45, 0xdf, 0xea, 0x5e, 0xf9, 0x01, 0x47, 0xee, 0xd5, 0x3c, 0xf4, + 0x41, 0x43, 0xd7, 0x0e, 0xb4, 0x26, 0x00, 0xad, 0x01, 0xff, 0x80, 0xe8, + 0x01, 0x4d, 0xd3, 0x8c, 0x32, 0xf9, 0x01, 0x06, 0x80, 0xe7, 0x01, 0xff, + 0x02, 0x68, 0x00, 0x3a, 0x07, 0x37, 0x3c, 0x06, 0x56, 0xe7, 0x38, 0x78, + 0x08, 0x41, 0xa6, 0x22, 0x43, 0x7a, 0x0b, 0x79, 0x08, 0x01, 0xb4, 0x01, + 0xff, 0x42, 0x92, 0x01, 0x7e, 0x08, 0x01, 0x44, 0x25, 0x01, 0x7b, 0x08, + 0x01, 0xb7, 0x01, 0xff, 0x44, 0xe9, 0x1e, 0x7f, 0x08, 0x01, 0xef, 0x7a, + 0x08, 0x41, 0x43, 0xf9, 0x05, 0x7d, 0x08, 0x01, 0x43, 0xf6, 0x06, 0x7c, + 0x08, 0x41, 0x53, 0xdb, 0x4b, 0x77, 0x08, 0x01, 0x05, 0x15, 0x06, 0x01, + 0xff, 0xa1, 0x85, 0x01, 0x44, 0x20, 0xf5, 0x61, 0x08, 0x01, 0x46, 0x6d, + 0x4c, 0x63, 0x08, 0x01, 0x49, 0x8b, 0xbe, 0x6d, 0x08, 0x01, 0x45, 0x5a, + 0xb0, 0x62, 0x08, 0x01, 0x42, 0xb0, 0x01, 0x64, 0x08, 0x81, 0x60, 0x44, + 0xb0, 0xf6, 0x6a, 0x08, 0x01, 0x46, 0x8a, 0xe3, 0x6b, 0x08, 0x01, 0x43, + 0xb4, 0x05, 0x6c, 0x08, 0x01, 0x43, 0x18, 0x24, 0x6e, 0x08, 0x01, 0x42, + 0x6f, 0x02, 0x71, 0x08, 0x01, 0x44, 0xf3, 0xcd, 0x73, 0x08, 0x01, 0x44, + 0x8a, 0x69, 0x74, 0x08, 0x01, 0xb3, 0x20, 0xb4, 0x12, 0x43, 0x1c, 0x8f, + 0x65, 0x08, 0x01, 0x44, 0xfd, 0x54, 0x69, 0x08, 0x01, 0x45, 0xf7, 0x54, + 0x66, 0x08, 0x41, 0x42, 0x3e, 0x2f, 0x76, 0x08, 0x01, 0x43, 0x48, 0x27, + 0x68, 0x08, 0x41, 0xa1, 0x06, 0x43, 0x48, 0x17, 0x75, 0x08, 0x41, 0x43, + 0x95, 0xf0, 0x72, 0x08, 0x01, 0x44, 0x4a, 0xea, 0x6f, 0x08, 0x41, 0x42, + 0x53, 0x00, 0x67, 0x08, 0x41, 0x44, 0x3b, 0x3f, 0x60, 0x08, 0x01, 0x43, + 0xa0, 0x1b, 0x70, 0x08, 0x41, 0x46, 0x75, 0x31, 0x19, 0x2e, 0x00, 0x49, + 0x59, 0xbd, 0xf3, 0xfa, 0x01, 0x44, 0xbc, 0x11, 0x34, 0xf3, 0x01, 0x47, + 0xbd, 0xdc, 0xf4, 0xfa, 0x41, 0xa3, 0xcf, 0x04, 0x06, 0xef, 0x06, 0x88, + 0x04, 0x09, 0xa3, 0xc1, 0xd4, 0x03, 0x07, 0x37, 0x3c, 0x9c, 0x03, 0x05, + 0x5a, 0x03, 0x93, 0x01, 0x07, 0x49, 0xdd, 0x01, 0xff, 0xa1, 0x5b, 0xa5, + 0x47, 0xa9, 0x33, 0xaf, 0x1f, 0xb5, 0x0b, 0xb7, 0x01, 0xff, 0xe2, 0x18, + 0x6b, 0x01, 0xf6, 0x19, 0x6b, 0x41, 0xa1, 0x08, 0xe2, 0x06, 0x6b, 0x01, + 0xf6, 0x07, 0x6b, 0x41, 0xe2, 0x10, 0x6b, 0x01, 0xf6, 0x11, 0x6b, 0x41, + 0xe2, 0x12, 0x6b, 0x01, 0xaf, 0x04, 0xf6, 0x13, 0x6b, 0x41, 0xe2, 0x0c, + 0x6b, 0x01, 0xf6, 0x0d, 0x6b, 0x41, 0xa1, 0x08, 0xe2, 0x02, 0x6b, 0x01, + 0xf6, 0x03, 0x6b, 0x41, 0xe2, 0x14, 0x6b, 0x01, 0xf6, 0x15, 0x6b, 0x41, + 0xe2, 0x08, 0x6b, 0x01, 0xa5, 0x04, 0xf6, 0x09, 0x6b, 0x41, 0xe2, 0x00, + 0x6b, 0x01, 0xf6, 0x01, 0x6b, 0x41, 0xa1, 0x27, 0xe2, 0x16, 0x6b, 0x01, + 0xa9, 0x19, 0xb5, 0x0f, 0xf6, 0x17, 0x6b, 0x01, 0xb7, 0x01, 0xff, 0xe2, + 0x0e, 0x6b, 0x01, 0xf6, 0x0f, 0x6b, 0x41, 0xe2, 0x04, 0x6b, 0x01, 0xf6, + 0x05, 0x6b, 0x41, 0xe2, 0x0a, 0x6b, 0x01, 0xf6, 0x0b, 0x6b, 0x41, 0xe2, + 0x1a, 0x6b, 0x01, 0xf6, 0x1b, 0x6b, 0x41, 0x42, 0x2f, 0x08, 0x6c, 0x6b, + 0x01, 0x04, 0xa8, 0xc1, 0xc3, 0x01, 0xa8, 0xb4, 0x01, 0x46, 0xac, 0xe2, + 0x43, 0x6b, 0x01, 0x43, 0x31, 0x0e, 0x70, 0x6b, 0x01, 0xad, 0x8f, 0x01, + 0xae, 0x80, 0x01, 0xb4, 0x6c, 0x04, 0x08, 0xf9, 0x39, 0xb8, 0x06, 0x48, + 0xcf, 0xd2, 0x67, 0x6b, 0x41, 0x43, 0x44, 0x31, 0x44, 0x6b, 0x01, 0x43, + 0xfe, 0x4c, 0x6a, 0x6b, 0x01, 0xb9, 0x01, 0xff, 0x04, 0x40, 0x22, 0x06, + 0x42, 0xcd, 0x02, 0x64, 0x6b, 0x41, 0x44, 0x94, 0xf5, 0x3f, 0x6b, 0x01, + 0x45, 0x3a, 0xef, 0x3c, 0x6b, 0x01, 0x43, 0x39, 0x4c, 0x3d, 0x6b, 0x01, + 0x43, 0xbb, 0x09, 0x3e, 0x6b, 0x41, 0x44, 0x9c, 0xf5, 0x3b, 0x6b, 0x01, + 0x43, 0x7d, 0x4d, 0x63, 0x6b, 0x01, 0x44, 0x84, 0xf7, 0x42, 0x6b, 0x01, + 0x44, 0x8c, 0xf8, 0x40, 0x6b, 0x01, 0xb4, 0x01, 0xff, 0xa8, 0x06, 0x49, + 0x03, 0xc5, 0x38, 0x6b, 0x41, 0x43, 0xfe, 0x4c, 0x3a, 0x6b, 0x01, 0x42, + 0x14, 0x05, 0x37, 0x6b, 0x41, 0x42, 0xb4, 0x25, 0x6f, 0x6b, 0x01, 0x4e, + 0xdc, 0x7b, 0x66, 0x6b, 0x01, 0x4a, 0x60, 0xb9, 0x6d, 0x6b, 0x41, 0x43, + 0x8a, 0xfa, 0x69, 0x6b, 0x01, 0x43, 0xa2, 0xfa, 0x6b, 0x6b, 0x41, 0x04, + 0x62, 0xb9, 0x06, 0x42, 0xef, 0x02, 0x71, 0x6b, 0x41, 0x44, 0xb8, 0xf8, + 0x41, 0x6b, 0x01, 0x45, 0x6f, 0xf1, 0x6e, 0x6b, 0x41, 0x42, 0xc3, 0x01, + 0x65, 0x6b, 0x01, 0x43, 0x31, 0x33, 0x68, 0x6b, 0x41, 0xa3, 0x28, 0x52, + 0x71, 0x54, 0x72, 0x6b, 0x01, 0x48, 0x97, 0xce, 0x77, 0x6b, 0x01, 0x48, + 0xb7, 0xcf, 0x76, 0x6b, 0x01, 0xb4, 0x01, 0xff, 0x47, 0xdd, 0xdb, 0x45, + 0x6b, 0x01, 0x43, 0xcf, 0xfa, 0x74, 0x6b, 0xc1, 0x00, 0x45, 0xa1, 0xe7, + 0x75, 0x6b, 0x41, 0x44, 0x50, 0x19, 0x39, 0x6b, 0x01, 0x4a, 0x16, 0xb8, + 0x73, 0x6b, 0x41, 0x07, 0x3f, 0x12, 0x25, 0x48, 0x18, 0x3e, 0x5e, 0x6b, + 0x01, 0xb4, 0x01, 0xff, 0x02, 0x92, 0x01, 0x06, 0x48, 0x2f, 0xd0, 0x61, + 0x6b, 0x41, 0x80, 0x04, 0xf3, 0x5b, 0x6b, 0x41, 0x48, 0xc7, 0xc9, 0x60, + 0x6b, 0x01, 0x49, 0xc8, 0x80, 0x5d, 0x6b, 0x41, 0x49, 0x17, 0x3e, 0x5f, + 0x6b, 0x01, 0xf3, 0x5c, 0x6b, 0x41, 0x43, 0x3b, 0xd1, 0x35, 0x6b, 0x01, + 0xab, 0x1b, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x43, 0x3d, 0xb8, 0x36, 0x6b, + 0x01, 0x42, 0x3d, 0x01, 0x30, 0x6b, 0x41, 0xef, 0x31, 0x6b, 0x01, 0x43, + 0x16, 0xb8, 0x34, 0x6b, 0x41, 0x42, 0xed, 0x00, 0x32, 0x6b, 0x01, 0x43, + 0x45, 0x4e, 0x33, 0x6b, 0x41, 0x45, 0x7e, 0x0b, 0x58, 0x6b, 0x01, 0xa6, + 0x2e, 0x44, 0x6d, 0x2c, 0x59, 0x6b, 0x01, 0x43, 0x7a, 0x0b, 0x51, 0x6b, + 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x50, 0x6b, 0x41, 0x44, + 0x25, 0x01, 0x53, 0x6b, 0x01, 0x42, 0x15, 0x02, 0x52, 0x6b, 0x41, 0x44, + 0x06, 0x1f, 0x57, 0x6b, 0x01, 0x42, 0x09, 0x24, 0x56, 0x6b, 0x41, 0x43, + 0xf9, 0x05, 0x55, 0x6b, 0x01, 0x43, 0xf6, 0x06, 0x54, 0x6b, 0x41, 0x09, + 0x01, 0xc1, 0x86, 0x01, 0x09, 0xf4, 0x34, 0x01, 0xff, 0x42, 0xb4, 0x25, + 0x2d, 0x6b, 0x01, 0xa3, 0x6d, 0xa8, 0x59, 0x43, 0xb3, 0x25, 0x1e, 0x6b, + 0x01, 0x43, 0x7e, 0x8e, 0x26, 0x6b, 0x01, 0xae, 0x24, 0x45, 0xdf, 0xef, + 0x2a, 0x6b, 0x01, 0x44, 0x28, 0xf8, 0x23, 0x6b, 0x01, 0x43, 0xf5, 0x5a, + 0x21, 0x6b, 0x01, 0x43, 0xb4, 0xfa, 0x1c, 0x6b, 0x01, 0x43, 0xc9, 0xfa, + 0x2e, 0x6b, 0x01, 0x43, 0xf3, 0x84, 0x24, 0x6b, 0x41, 0x42, 0xb4, 0x25, + 0x2c, 0x6b, 0x01, 0x44, 0x44, 0xf5, 0x28, 0x6b, 0x01, 0x43, 0xf8, 0xd4, + 0x22, 0x6b, 0x01, 0x43, 0xb3, 0x25, 0x20, 0x6b, 0x01, 0xb4, 0x01, 0xff, + 0x43, 0xc2, 0x81, 0x2b, 0x6b, 0x01, 0x43, 0x6e, 0x96, 0x1d, 0x6b, 0x41, + 0x42, 0xb4, 0x25, 0x1f, 0x6b, 0x01, 0x43, 0xb3, 0x25, 0x25, 0x6b, 0x01, + 0x43, 0x03, 0x5f, 0x29, 0x6b, 0x41, 0x42, 0xb4, 0x25, 0x2f, 0x6b, 0x01, + 0x43, 0xc2, 0x81, 0x27, 0x6b, 0x41, 0x43, 0x3c, 0xfa, 0x8b, 0x6b, 0x01, + 0x02, 0x22, 0x00, 0x6e, 0xab, 0x5a, 0xac, 0x4c, 0x44, 0x34, 0xf7, 0x84, + 0x6b, 0x01, 0x44, 0x04, 0xf8, 0x87, 0x6b, 0x01, 0xb4, 0x23, 0xb6, 0x15, + 0x45, 0x64, 0xf2, 0x81, 0x6b, 0x01, 0xb9, 0x01, 0xff, 0x42, 0x77, 0x1a, + 0x8c, 0x6b, 0x01, 0x43, 0x2d, 0xfa, 0x7e, 0x6b, 0x41, 0x42, 0x77, 0x1a, + 0x8a, 0x6b, 0x01, 0x42, 0xd0, 0xd2, 0x8f, 0x6b, 0x41, 0x43, 0x48, 0xfa, + 0x85, 0x6b, 0x01, 0xb3, 0x01, 0xff, 0x42, 0x5c, 0x00, 0x86, 0x6b, 0x01, + 0x44, 0x61, 0xb9, 0x7d, 0x6b, 0x01, 0x42, 0x7d, 0x1b, 0x8d, 0x6b, 0x41, + 0x43, 0xee, 0xf9, 0x80, 0x6b, 0x01, 0x42, 0x5f, 0x03, 0x7f, 0x6b, 0x41, + 0x43, 0xc1, 0x15, 0x88, 0x6b, 0x01, 0x42, 0xcd, 0x02, 0x82, 0x6b, 0x01, + 0x42, 0x7a, 0x5e, 0x8e, 0x6b, 0x41, 0xed, 0x89, 0x6b, 0x01, 0x42, 0xd0, + 0xd2, 0x83, 0x6b, 0x41, 0xe5, 0xcf, 0xf5, 0x81, 0x06, 0x43, 0x3c, 0x2f, + 0xd4, 0xf6, 0x41, 0x80, 0x08, 0xf2, 0xdf, 0xf4, 0x01, 0xf3, 0xd0, 0xf5, + 0x41, 0x49, 0x67, 0xbe, 0xc4, 0xf4, 0x01, 0x06, 0xca, 0x04, 0x01, 0xff, + 0x4b, 0xce, 0xa2, 0xdf, 0xf5, 0x01, 0x43, 0xdf, 0x0b, 0xc3, 0xf4, 0x41, + 0x4e, 0x62, 0x7a, 0x80, 0x00, 0x40, 0xa2, 0xdc, 0x2e, 0xa3, 0xf8, 0x2d, + 0x43, 0x5b, 0x0b, 0x62, 0xf3, 0x01, 0x4e, 0x6c, 0x7b, 0xe2, 0xf3, 0x81, + 0xe4, 0x2d, 0xa7, 0x97, 0x2c, 0x47, 0xc8, 0xce, 0x26, 0x21, 0x00, 0x47, + 0xbc, 0xd7, 0xe2, 0xf6, 0x01, 0x4b, 0x01, 0x98, 0x4c, 0xf4, 0x01, 0xac, + 0xf6, 0x12, 0xad, 0xe7, 0x12, 0xae, 0x95, 0x12, 0xb0, 0xe4, 0x10, 0xb2, + 0xb7, 0x0b, 0xb3, 0xfd, 0x05, 0x02, 0x15, 0x06, 0xab, 0x02, 0xb5, 0x46, + 0x03, 0x32, 0x00, 0x10, 0x42, 0x95, 0x03, 0x89, 0xf9, 0x01, 0xf8, 0x02, + 0xf4, 0x01, 0x45, 0x7d, 0xf2, 0xaa, 0xf9, 0x41, 0x4b, 0xfd, 0xa1, 0x75, + 0xf9, 0x01, 0xac, 0x01, 0xff, 0x42, 0x0c, 0x06, 0xd7, 0xf5, 0x81, 0x06, + 0x43, 0xf0, 0x05, 0x3e, 0x20, 0x40, 0x05, 0xc9, 0x31, 0x01, 0xff, 0x4d, + 0xb6, 0x5a, 0xbc, 0x2b, 0x00, 0x06, 0xad, 0x02, 0x01, 0xff, 0x51, 0xb2, + 0x5a, 0xbb, 0x2b, 0x00, 0x47, 0xbc, 0x5a, 0xba, 0x2b, 0x40, 0x48, 0x37, + 0xce, 0x25, 0x21, 0x00, 0xb4, 0x01, 0xff, 0x48, 0xff, 0xc9, 0xe4, 0xf4, + 0x01, 0x06, 0xca, 0x11, 0x01, 0xff, 0x4a, 0x92, 0x2d, 0x2d, 0x27, 0x00, + 0x06, 0xef, 0x06, 0x82, 0x01, 0x4b, 0xef, 0x63, 0x19, 0x27, 0x00, 0x07, + 0x05, 0x06, 0x06, 0x4a, 0xec, 0x2f, 0x9d, 0x26, 0x40, 0x0e, 0x0c, 0x06, + 0x06, 0x44, 0x8f, 0x08, 0x1f, 0x27, 0x40, 0xe1, 0xd6, 0xcc, 0x01, 0xe2, + 0xd7, 0xcc, 0x01, 0xe3, 0xd8, 0xcc, 0x01, 0xe4, 0xd9, 0xcc, 0x01, 0xe5, + 0xda, 0xcc, 0x01, 0xe6, 0xdb, 0xcc, 0x01, 0xe7, 0xdc, 0xcc, 0x01, 0xe8, + 0xdd, 0xcc, 0x01, 0xe9, 0xde, 0xcc, 0x01, 0xea, 0xdf, 0xcc, 0x01, 0xeb, + 0xe0, 0xcc, 0x01, 0xec, 0xe1, 0xcc, 0x01, 0xed, 0xe2, 0xcc, 0x01, 0xee, + 0xe3, 0xcc, 0x01, 0xef, 0xe4, 0xcc, 0x01, 0xf0, 0xe5, 0xcc, 0x01, 0xf1, + 0xe6, 0xcc, 0x01, 0xf2, 0xe7, 0xcc, 0x01, 0xf3, 0xe8, 0xcc, 0x01, 0xf4, + 0xe9, 0xcc, 0x01, 0xf5, 0xea, 0xcc, 0x01, 0xf6, 0xeb, 0xcc, 0x01, 0xf7, + 0xec, 0xcc, 0x01, 0xf8, 0xed, 0xcc, 0x01, 0xf9, 0xee, 0xcc, 0x01, 0xfa, + 0xef, 0xcc, 0x41, 0x45, 0x7e, 0x0b, 0xf8, 0xcc, 0x01, 0xa6, 0x2e, 0x44, + 0x6d, 0x2c, 0xf9, 0xcc, 0x01, 0x43, 0x7a, 0x0b, 0xf1, 0xcc, 0x01, 0xb3, + 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xf0, 0xcc, 0x41, 0x44, 0x25, 0x01, + 0xf3, 0xcc, 0x01, 0x42, 0x15, 0x02, 0xf2, 0xcc, 0x41, 0x44, 0x06, 0x1f, + 0xf7, 0xcc, 0x01, 0x42, 0x09, 0x24, 0xf6, 0xcc, 0x41, 0x43, 0xf9, 0x05, + 0xf5, 0xcc, 0x01, 0x43, 0xf6, 0x06, 0xf4, 0xcc, 0x41, 0x42, 0x33, 0x00, + 0xa6, 0xf9, 0x01, 0x0b, 0xdb, 0xa5, 0x01, 0xff, 0x11, 0x7f, 0x5a, 0xe4, + 0x02, 0x0d, 0x9f, 0x5c, 0xd3, 0x02, 0x48, 0xd7, 0xcd, 0x2e, 0xed, 0x01, + 0x07, 0x37, 0x3c, 0x01, 0xff, 0x45, 0x7e, 0x0b, 0x08, 0xed, 0x81, 0xa7, + 0x02, 0xa6, 0xd9, 0x01, 0x44, 0x6d, 0x2c, 0x09, 0xed, 0x81, 0xb6, 0x01, + 0x43, 0x7a, 0x0b, 0x01, 0xed, 0x81, 0x9f, 0x01, 0xb3, 0x59, 0xb4, 0x01, + 0xff, 0x42, 0x92, 0x01, 0x0a, 0xed, 0x81, 0x49, 0xa8, 0x24, 0xb7, 0x01, + 0xff, 0x44, 0xe9, 0x1e, 0x0b, 0xed, 0x81, 0x14, 0xef, 0x02, 0xed, 0xc1, + 0x00, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0x14, 0xed, 0x01, 0x48, 0xde, + 0x1e, 0x1d, 0xed, 0x41, 0x49, 0xdd, 0x1e, 0x26, 0xed, 0x41, 0x44, 0x49, + 0x12, 0x0c, 0xed, 0x81, 0x16, 0x43, 0x26, 0x01, 0x03, 0xed, 0xc1, 0x00, + 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0x15, 0xed, 0x01, 0x48, 0xde, 0x1e, + 0x1e, 0xed, 0x41, 0x49, 0xdd, 0x1e, 0x27, 0xed, 0x41, 0x49, 0xdd, 0x1e, + 0x25, 0xed, 0x41, 0x44, 0x06, 0x1f, 0x07, 0xed, 0x81, 0x22, 0x42, 0x09, + 0x24, 0x06, 0xed, 0xc1, 0x00, 0x80, 0x0d, 0x42, 0x4b, 0x12, 0x0f, 0xed, + 0xc1, 0x00, 0x49, 0xdd, 0x1e, 0x2a, 0xed, 0x41, 0x47, 0x3f, 0x12, 0x18, + 0xed, 0x01, 0x48, 0xde, 0x1e, 0x21, 0xed, 0x41, 0x80, 0x0d, 0x42, 0x4b, + 0x12, 0x10, 0xed, 0xc1, 0x00, 0x49, 0xdd, 0x1e, 0x2b, 0xed, 0x41, 0x47, + 0x3f, 0x12, 0x19, 0xed, 0x01, 0x48, 0xde, 0x1e, 0x22, 0xed, 0x41, 0x80, + 0x01, 0xff, 0x47, 0x3f, 0x12, 0x13, 0xed, 0x01, 0x48, 0xde, 0x1e, 0x1c, + 0xed, 0x41, 0x80, 0x0d, 0x42, 0x4b, 0x12, 0x12, 0xed, 0xc1, 0x00, 0x49, + 0xdd, 0x1e, 0x2d, 0xed, 0x41, 0x47, 0x3f, 0x12, 0x1b, 0xed, 0x01, 0x48, + 0xde, 0x1e, 0x24, 0xed, 0x41, 0xa9, 0x26, 0xaf, 0x01, 0xff, 0x43, 0x4a, + 0x12, 0x0d, 0xed, 0x81, 0x16, 0x42, 0x42, 0x00, 0x04, 0xed, 0xc1, 0x00, + 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0x16, 0xed, 0x01, 0x48, 0xde, 0x1e, + 0x1f, 0xed, 0x41, 0x49, 0xdd, 0x1e, 0x28, 0xed, 0x41, 0x43, 0x04, 0x24, + 0x0e, 0xed, 0x81, 0x16, 0x42, 0x32, 0x00, 0x05, 0xed, 0xc1, 0x00, 0x80, + 0x01, 0xff, 0x47, 0x3f, 0x12, 0x17, 0xed, 0x01, 0x48, 0xde, 0x1e, 0x20, + 0xed, 0x41, 0x49, 0xdd, 0x1e, 0x29, 0xed, 0x41, 0x80, 0x0b, 0xf9, 0x11, + 0xed, 0xc1, 0x00, 0x49, 0xdd, 0x1e, 0x2c, 0xed, 0x41, 0x47, 0x3f, 0x12, + 0x1a, 0xed, 0x01, 0x48, 0xde, 0x1e, 0x23, 0xed, 0x41, 0x44, 0x22, 0x00, + 0x3c, 0xed, 0x01, 0x45, 0x08, 0x24, 0x3d, 0xed, 0x41, 0x45, 0x7e, 0x0b, + 0x35, 0xed, 0x01, 0xa6, 0x3e, 0x44, 0x6d, 0x2c, 0x36, 0xed, 0x01, 0xb3, + 0x23, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x37, 0xed, 0x81, 0x13, 0x44, + 0x25, 0x01, 0x30, 0xed, 0x01, 0x42, 0x15, 0x02, 0x2f, 0xed, 0xc1, 0x00, + 0x49, 0xdd, 0x1e, 0x3a, 0xed, 0x41, 0x49, 0xdd, 0x1e, 0x3b, 0xed, 0x41, + 0x44, 0x06, 0x1f, 0x34, 0xed, 0x01, 0x42, 0x09, 0x24, 0x33, 0xed, 0xc1, + 0x00, 0x48, 0x3e, 0x12, 0x39, 0xed, 0x41, 0x43, 0xf9, 0x05, 0x32, 0xed, + 0x01, 0x43, 0xf6, 0x06, 0x31, 0xed, 0xc1, 0x00, 0x48, 0x3e, 0x12, 0x38, + 0xed, 0x41, 0x04, 0x45, 0x45, 0x82, 0x02, 0xe3, 0x9d, 0x00, 0x00, 0x06, + 0xf0, 0xe3, 0x01, 0xff, 0x06, 0xef, 0x06, 0xb2, 0x01, 0x07, 0x13, 0x06, + 0x01, 0xff, 0xe1, 0x96, 0x04, 0x81, 0x9d, 0x01, 0x42, 0x16, 0x00, 0x81, + 0x04, 0x01, 0x44, 0x40, 0xf5, 0x8b, 0x04, 0x01, 0xa4, 0x82, 0x01, 0xe5, + 0x97, 0x04, 0x81, 0x79, 0x42, 0x0c, 0x08, 0x8d, 0x04, 0x01, 0x42, 0x24, + 0x02, 0x8c, 0x04, 0x01, 0x42, 0x22, 0x00, 0x94, 0x04, 0x01, 0xe9, 0x98, + 0x04, 0x01, 0x42, 0x78, 0x1a, 0x83, 0x04, 0x01, 0xab, 0x4f, 0x44, 0xe2, + 0xf4, 0x90, 0x04, 0x01, 0x44, 0x24, 0xf7, 0x91, 0x04, 0x01, 0x44, 0x9c, + 0xf7, 0x92, 0x04, 0x01, 0xef, 0x99, 0x04, 0x81, 0x34, 0x44, 0x07, 0xf0, + 0x8e, 0x04, 0x01, 0x42, 0x71, 0x00, 0x87, 0x04, 0x01, 0xb3, 0x1c, 0x42, + 0x12, 0x00, 0x82, 0x04, 0x01, 0xf5, 0x9a, 0x04, 0x01, 0x43, 0x1c, 0x8f, + 0x93, 0x04, 0x01, 0x42, 0x5b, 0x28, 0x84, 0x04, 0x01, 0x42, 0xdf, 0x23, + 0x95, 0x04, 0x41, 0xe1, 0x88, 0x04, 0x01, 0x44, 0x28, 0xf6, 0x89, 0x04, + 0x41, 0xef, 0x9d, 0x04, 0x41, 0x43, 0xc9, 0xc8, 0x8f, 0x04, 0x01, 0x42, + 0x22, 0x00, 0x85, 0x04, 0x41, 0xe5, 0x9c, 0x04, 0x41, 0x43, 0xfb, 0x13, + 0x86, 0x04, 0x01, 0x42, 0x22, 0x00, 0x8a, 0x04, 0x41, 0xe1, 0x9b, 0x04, + 0x01, 0x43, 0x68, 0x00, 0x80, 0x04, 0x41, 0x45, 0x7e, 0x0b, 0xa8, 0x04, + 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xa9, 0x04, 0x01, 0x43, 0x7a, 0x0b, + 0xa1, 0x04, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xa0, 0x04, + 0x41, 0x44, 0x25, 0x01, 0xa3, 0x04, 0x01, 0x42, 0x15, 0x02, 0xa2, 0x04, + 0x41, 0x44, 0x06, 0x1f, 0xa7, 0x04, 0x01, 0x42, 0x09, 0x24, 0xa6, 0x04, + 0x41, 0x43, 0xf9, 0x05, 0xa5, 0x04, 0x01, 0x43, 0xf6, 0x06, 0xa4, 0x04, + 0x41, 0x0f, 0x0b, 0x06, 0xd8, 0x01, 0x0d, 0x9b, 0x08, 0x01, 0xff, 0xe1, + 0xd8, 0x04, 0x81, 0xc0, 0x01, 0x43, 0x88, 0x09, 0xdc, 0x04, 0x01, 0x43, + 0xd0, 0x18, 0xdd, 0x04, 0x01, 0x43, 0x44, 0x4e, 0xf5, 0x04, 0x01, 0xe5, + 0xdf, 0x04, 0x81, 0x81, 0x01, 0x43, 0x38, 0xa1, 0xf9, 0x04, 0x01, 0xa8, + 0x6f, 0xe9, 0xe3, 0x04, 0x01, 0xab, 0x59, 0x42, 0x74, 0x00, 0xe7, 0x04, + 0x01, 0x42, 0x6c, 0x00, 0xe8, 0x04, 0x01, 0x42, 0x2a, 0x05, 0xe9, 0x04, + 0x01, 0xef, 0xea, 0x04, 0x81, 0x3c, 0x42, 0xe0, 0x09, 0xec, 0x04, 0x01, + 0xb3, 0x2a, 0xb4, 0x17, 0xf5, 0xf6, 0x04, 0x01, 0x42, 0xa9, 0x01, 0xf7, + 0x04, 0x01, 0xba, 0x01, 0xff, 0xe1, 0xfa, 0x04, 0x01, 0x42, 0x22, 0x00, + 0xfb, 0x04, 0x41, 0xe1, 0xf0, 0x04, 0x01, 0xb3, 0x01, 0xff, 0xe1, 0xf2, + 0x04, 0x01, 0x42, 0x22, 0x00, 0xf4, 0x04, 0x41, 0xe1, 0xee, 0x04, 0x01, + 0x42, 0x22, 0x00, 0xef, 0x04, 0x41, 0x42, 0x9e, 0x01, 0xeb, 0x04, 0x41, + 0xe1, 0xe4, 0x04, 0x01, 0x42, 0x22, 0x00, 0xf8, 0x04, 0x01, 0x42, 0xdf, + 0x23, 0xe6, 0x04, 0x41, 0xe1, 0xe1, 0x04, 0x01, 0x42, 0xdf, 0x23, 0xe2, + 0x04, 0x41, 0xa8, 0x06, 0x42, 0x9e, 0x01, 0xe0, 0x04, 0x41, 0x43, 0xd0, + 0x18, 0xde, 0x04, 0x01, 0x42, 0x1b, 0x02, 0xe5, 0x04, 0x01, 0x42, 0xe0, + 0x09, 0xed, 0x04, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0xf1, 0x04, 0x01, 0x42, + 0x40, 0x06, 0xf3, 0x04, 0x41, 0xe8, 0xdb, 0x04, 0x01, 0xe9, 0xd9, 0x04, + 0xc1, 0x00, 0xee, 0xda, 0x04, 0x41, 0xe1, 0xb0, 0x04, 0x81, 0xc0, 0x01, + 0x43, 0x88, 0x09, 0xb4, 0x04, 0x01, 0x43, 0xd0, 0x18, 0xb5, 0x04, 0x01, + 0x43, 0x44, 0x4e, 0xcd, 0x04, 0x01, 0xe5, 0xb7, 0x04, 0x81, 0x81, 0x01, + 0x43, 0x38, 0xa1, 0xd1, 0x04, 0x01, 0xa8, 0x6f, 0xe9, 0xbb, 0x04, 0x01, + 0xab, 0x59, 0x42, 0x74, 0x00, 0xbf, 0x04, 0x01, 0x42, 0x6c, 0x00, 0xc0, + 0x04, 0x01, 0x42, 0x2a, 0x05, 0xc1, 0x04, 0x01, 0xef, 0xc2, 0x04, 0x81, + 0x3c, 0x42, 0xe0, 0x09, 0xc4, 0x04, 0x01, 0xb3, 0x2a, 0xb4, 0x17, 0xf5, + 0xce, 0x04, 0x01, 0x42, 0xa9, 0x01, 0xcf, 0x04, 0x01, 0xba, 0x01, 0xff, + 0xe1, 0xd2, 0x04, 0x01, 0x42, 0x22, 0x00, 0xd3, 0x04, 0x41, 0xe1, 0xc8, + 0x04, 0x01, 0xb3, 0x01, 0xff, 0xe1, 0xca, 0x04, 0x01, 0x42, 0x22, 0x00, + 0xcc, 0x04, 0x41, 0xe1, 0xc6, 0x04, 0x01, 0x42, 0x22, 0x00, 0xc7, 0x04, + 0x41, 0x42, 0x9e, 0x01, 0xc3, 0x04, 0x41, 0xe1, 0xbc, 0x04, 0x01, 0x42, + 0x22, 0x00, 0xd0, 0x04, 0x01, 0x42, 0xdf, 0x23, 0xbe, 0x04, 0x41, 0xe1, + 0xb9, 0x04, 0x01, 0x42, 0xdf, 0x23, 0xba, 0x04, 0x41, 0xa8, 0x06, 0x42, + 0x9e, 0x01, 0xb8, 0x04, 0x41, 0x43, 0xd0, 0x18, 0xb6, 0x04, 0x01, 0x42, + 0x1b, 0x02, 0xbd, 0x04, 0x01, 0x42, 0xe0, 0x09, 0xc5, 0x04, 0x01, 0xb4, + 0x01, 0xff, 0xe1, 0xc9, 0x04, 0x01, 0x42, 0x40, 0x06, 0xcb, 0x04, 0x41, + 0xe8, 0xb3, 0x04, 0x01, 0xe9, 0xb1, 0x04, 0xc1, 0x00, 0xee, 0xb2, 0x04, + 0x41, 0x50, 0x5a, 0x63, 0xc7, 0x27, 0x00, 0x03, 0x1c, 0x01, 0x89, 0x05, + 0xa3, 0xfc, 0x04, 0xa9, 0x21, 0x05, 0xc4, 0x12, 0x11, 0x03, 0x2a, 0x08, + 0x01, 0xff, 0x49, 0x74, 0xbd, 0x26, 0x26, 0x00, 0x55, 0xac, 0x22, 0x42, + 0xcc, 0x41, 0x50, 0xed, 0x25, 0x3e, 0xfd, 0x00, 0x51, 0xf5, 0x22, 0x3f, + 0xfd, 0x40, 0x48, 0x80, 0x31, 0xb6, 0x22, 0x00, 0x03, 0x6d, 0x34, 0x01, + 0xff, 0xa1, 0xbf, 0x04, 0x06, 0xef, 0x06, 0xf8, 0x03, 0x09, 0x54, 0x2a, + 0xc6, 0x03, 0x46, 0x0c, 0xe3, 0x70, 0x0b, 0x00, 0x07, 0x13, 0x06, 0x89, + 0x01, 0x05, 0x5a, 0x03, 0x44, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xa1, 0x31, + 0xe5, 0x47, 0x0b, 0x00, 0xe9, 0x3f, 0x0b, 0x80, 0x24, 0xef, 0x4b, 0x0b, + 0x00, 0xf5, 0x41, 0x0b, 0x80, 0x17, 0x08, 0xf2, 0xc6, 0x01, 0xff, 0xec, + 0x62, 0x0b, 0x80, 0x09, 0xf2, 0x43, 0x0b, 0xc0, 0x00, 0xf2, 0x44, 0x0b, + 0x40, 0xec, 0x63, 0x0b, 0x40, 0xf5, 0x42, 0x0b, 0x40, 0xe9, 0x40, 0x0b, + 0x40, 0xe1, 0x3e, 0x0b, 0x00, 0xe9, 0x48, 0x0b, 0x00, 0xf5, 0x4c, 0x0b, + 0x40, 0xa1, 0x33, 0x4b, 0x13, 0x25, 0x01, 0x0b, 0x00, 0x02, 0x3b, 0x01, + 0x1d, 0x45, 0x62, 0x41, 0x3c, 0x0b, 0x00, 0x48, 0x14, 0x8f, 0x55, 0x0b, + 0x00, 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0x21, 0x25, 0x4d, 0x0b, 0x00, + 0x45, 0x49, 0x4e, 0x03, 0x0b, 0x40, 0x47, 0x79, 0x1f, 0x53, 0x0b, 0x00, + 0x4e, 0xec, 0x64, 0x54, 0x0b, 0x40, 0x47, 0x0b, 0x17, 0x02, 0x0b, 0x00, + 0x47, 0x34, 0x8d, 0x3d, 0x0b, 0x40, 0xe1, 0x05, 0x0b, 0x80, 0xa0, 0x02, + 0xa2, 0x93, 0x02, 0xa3, 0x86, 0x02, 0xa4, 0xed, 0x01, 0xe5, 0x0f, 0x0b, + 0x00, 0xa7, 0xdc, 0x01, 0x42, 0x22, 0x00, 0x39, 0x0b, 0x00, 0xe9, 0x07, + 0x0b, 0x80, 0xcc, 0x01, 0xaa, 0xbf, 0x01, 0xab, 0xb2, 0x01, 0xac, 0xa5, + 0x01, 0x42, 0x6c, 0x00, 0x2e, 0x0b, 0x00, 0xae, 0x86, 0x01, 0xef, 0x13, + 0x0b, 0x00, 0xb0, 0x76, 0xb2, 0x64, 0xb3, 0x52, 0xb4, 0x39, 0xf5, 0x09, + 0x0b, 0x80, 0x30, 0xb6, 0x13, 0x42, 0xa9, 0x01, 0x71, 0x0b, 0x00, 0xb9, + 0x01, 0xff, 0xe1, 0x2f, 0x0b, 0x00, 0x42, 0xdf, 0x23, 0x5f, 0x0b, 0x40, + 0xe1, 0x35, 0x0b, 0x00, 0x07, 0xf3, 0xc6, 0x01, 0xff, 0xec, 0x0c, 0x0b, + 0x80, 0x09, 0xf2, 0x0b, 0x0b, 0xc0, 0x00, 0xf2, 0x60, 0x0b, 0x40, 0xec, + 0x61, 0x0b, 0x40, 0xf5, 0x0a, 0x0b, 0x40, 0xe1, 0x24, 0x0b, 0x00, 0x42, + 0x22, 0x00, 0x25, 0x0b, 0x00, 0xb4, 0x01, 0xff, 0xe1, 0x1f, 0x0b, 0x00, + 0x42, 0x22, 0x00, 0x20, 0x0b, 0x40, 0xe1, 0x38, 0x0b, 0x00, 0x42, 0x22, + 0x00, 0x36, 0x0b, 0x00, 0x42, 0x40, 0x06, 0x37, 0x0b, 0x40, 0xe1, 0x30, + 0x0b, 0x00, 0x42, 0x22, 0x00, 0x5d, 0x0b, 0x00, 0x42, 0x71, 0x00, 0x5c, + 0x0b, 0x40, 0xe1, 0x2a, 0x0b, 0x00, 0x42, 0x22, 0x00, 0x2b, 0x0b, 0x40, + 0xe1, 0x28, 0x0b, 0x00, 0x42, 0x24, 0x02, 0x19, 0x0b, 0x00, 0x42, 0x2a, + 0x05, 0x23, 0x0b, 0x00, 0x42, 0xdf, 0x23, 0x1e, 0x0b, 0x40, 0xe1, 0x32, + 0x0b, 0x00, 0x42, 0x74, 0x00, 0x33, 0x0b, 0x40, 0xe1, 0x15, 0x0b, 0x00, + 0x42, 0x22, 0x00, 0x16, 0x0b, 0x40, 0xe1, 0x1c, 0x0b, 0x00, 0x42, 0x22, + 0x00, 0x1d, 0x0b, 0x40, 0xe9, 0x08, 0x0b, 0x40, 0xe1, 0x17, 0x0b, 0x00, + 0x42, 0x22, 0x00, 0x18, 0x0b, 0x40, 0xe1, 0x26, 0x0b, 0x00, 0xa4, 0x06, + 0x42, 0x22, 0x00, 0x27, 0x0b, 0x40, 0xe1, 0x21, 0x0b, 0x00, 0x42, 0x22, + 0x00, 0x22, 0x0b, 0x40, 0xe1, 0x1a, 0x0b, 0x00, 0x42, 0x22, 0x00, 0x1b, + 0x0b, 0x40, 0xe1, 0x2c, 0x0b, 0x00, 0x42, 0x22, 0x00, 0x2d, 0x0b, 0x40, + 0xe1, 0x06, 0x0b, 0x00, 0xe9, 0x10, 0x0b, 0x00, 0xf5, 0x14, 0x0b, 0x40, + 0x04, 0x7a, 0x0b, 0x11, 0x06, 0x24, 0x01, 0x01, 0xff, 0x48, 0x2a, 0x01, + 0x74, 0x0b, 0x00, 0x4a, 0xb8, 0xb6, 0x77, 0x0b, 0x40, 0x46, 0x7e, 0x0b, + 0x76, 0x0b, 0x00, 0x44, 0x22, 0x00, 0x73, 0x0b, 0x00, 0x47, 0x2a, 0x01, + 0x72, 0x0b, 0x00, 0x49, 0x6e, 0x27, 0x75, 0x0b, 0x40, 0x45, 0x7e, 0x0b, + 0x6e, 0x0b, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x6f, 0x0b, 0x00, 0x43, + 0x7a, 0x0b, 0x67, 0x0b, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, + 0x66, 0x0b, 0x40, 0x44, 0x25, 0x01, 0x69, 0x0b, 0x00, 0x42, 0x15, 0x02, + 0x68, 0x0b, 0x40, 0x44, 0x06, 0x1f, 0x6d, 0x0b, 0x00, 0x42, 0x09, 0x24, + 0x6c, 0x0b, 0x40, 0x43, 0xf9, 0x05, 0x6b, 0x0b, 0x00, 0x43, 0xf6, 0x06, + 0x6a, 0x0b, 0x40, 0x4d, 0xf3, 0x87, 0x56, 0x0b, 0x00, 0x4d, 0x91, 0x79, + 0x57, 0x0b, 0x40, 0xe1, 0xcd, 0xfa, 0x01, 0x42, 0xef, 0x02, 0x7f, 0xf7, + 0x41, 0x02, 0x60, 0x00, 0x06, 0x44, 0xe8, 0xf8, 0xa7, 0xf9, 0x41, 0x44, + 0x28, 0xf5, 0xd9, 0xf4, 0x01, 0x45, 0xcf, 0x22, 0xe1, 0xf9, 0x41, 0xa5, + 0x24, 0x47, 0x6f, 0xd7, 0xce, 0x26, 0x00, 0x48, 0xf6, 0x17, 0x0d, 0x26, + 0x00, 0x02, 0x35, 0x00, 0x01, 0xff, 0x48, 0x27, 0xca, 0xbf, 0xf4, 0x81, + 0x06, 0x46, 0xbc, 0xe4, 0x25, 0x23, 0x40, 0x45, 0xbf, 0xe7, 0xb8, 0xf5, + 0x41, 0xae, 0x06, 0x55, 0xb4, 0x3f, 0x9d, 0x00, 0x40, 0x80, 0x19, 0x8d, + 0x01, 0xff, 0x0f, 0xdc, 0x6e, 0x06, 0x59, 0xe7, 0x26, 0xbe, 0x27, 0x40, + 0x4d, 0x8b, 0x87, 0x8f, 0x23, 0x00, 0x4d, 0x11, 0x89, 0x90, 0x23, 0x40, + 0x02, 0x5d, 0x00, 0x57, 0x07, 0x73, 0x02, 0x3b, 0xa6, 0x2d, 0x4a, 0x18, + 0x7c, 0x50, 0xf4, 0x01, 0x44, 0x34, 0x01, 0x13, 0xf5, 0x01, 0x0d, 0xad, + 0x89, 0x11, 0x02, 0x6f, 0x00, 0x01, 0xff, 0x44, 0x69, 0x13, 0xc3, 0x27, + 0x00, 0x46, 0x21, 0x38, 0xc4, 0x27, 0x40, 0x4c, 0x44, 0x96, 0xed, 0xf4, + 0x01, 0x4b, 0xee, 0xa6, 0xec, 0xf4, 0x41, 0x4a, 0x2c, 0xb1, 0xc2, 0xf4, + 0x01, 0x45, 0xe0, 0x68, 0xc1, 0xf5, 0x41, 0x48, 0xca, 0x0d, 0x32, 0x27, + 0x00, 0x4a, 0x92, 0x2d, 0x2b, 0x27, 0x00, 0x45, 0x8e, 0x08, 0x1b, 0x27, + 0x00, 0x58, 0x0c, 0x2d, 0x3c, 0x27, 0x40, 0x42, 0x55, 0x05, 0xd6, 0xf4, + 0x01, 0xf8, 0x23, 0x24, 0x40, 0x72, 0xa7, 0x00, 0x1b, 0xf5, 0x01, 0x07, + 0xcb, 0xd5, 0x27, 0xa5, 0x06, 0x43, 0xb5, 0x00, 0xc5, 0xf9, 0x41, 0x80, + 0x06, 0x4f, 0x65, 0x6d, 0x71, 0xfa, 0x41, 0x4c, 0xac, 0x91, 0xaf, 0xf5, + 0x01, 0x04, 0x6f, 0x0c, 0x01, 0xff, 0x46, 0x86, 0x81, 0x24, 0x20, 0x00, + 0x59, 0x1d, 0x16, 0x2b, 0x2e, 0x40, 0x4a, 0x76, 0xad, 0x98, 0xf6, 0x01, + 0x43, 0x04, 0x29, 0x8d, 0xf6, 0x01, 0x4b, 0x4d, 0xa1, 0xf1, 0xf6, 0x01, + 0x4a, 0x3c, 0xb5, 0x94, 0xf6, 0x01, 0x44, 0x06, 0xd5, 0x96, 0xf6, 0x41, + 0x47, 0x15, 0x08, 0x49, 0xf5, 0x01, 0x4d, 0x72, 0x84, 0xc4, 0x20, 0x40, + 0x80, 0xf5, 0x14, 0xa4, 0x06, 0x43, 0xf9, 0x05, 0xd2, 0xfa, 0x41, 0x80, + 0x17, 0x03, 0x16, 0x01, 0x01, 0xff, 0x45, 0x0d, 0xea, 0xd3, 0xf9, 0x01, + 0x43, 0x47, 0x19, 0x74, 0xf4, 0x01, 0x45, 0xa1, 0x2e, 0x75, 0xf4, 0x41, + 0x08, 0x57, 0xca, 0xc3, 0x14, 0x0a, 0xd2, 0xb0, 0x91, 0x10, 0x07, 0xe6, + 0xd7, 0xb2, 0x0e, 0x43, 0x5e, 0x25, 0xdd, 0xf5, 0x01, 0x0e, 0xd4, 0x7d, + 0xca, 0x0c, 0x03, 0x6f, 0x02, 0xa1, 0x08, 0x02, 0x60, 0x03, 0x98, 0x04, + 0x0e, 0x54, 0x81, 0xc3, 0x01, 0x07, 0xfc, 0xdc, 0x01, 0xff, 0x0a, 0xc2, + 0x5b, 0x98, 0x01, 0x07, 0x13, 0x06, 0x22, 0x0c, 0x3b, 0x17, 0x01, 0xff, + 0x43, 0x16, 0x00, 0x86, 0x0f, 0x01, 0x49, 0x08, 0x49, 0x89, 0x0f, 0x01, + 0x04, 0x44, 0x0a, 0x01, 0xff, 0x44, 0x95, 0x1b, 0x87, 0x0f, 0x01, 0x44, + 0x48, 0x0a, 0x88, 0x0f, 0x41, 0x45, 0x39, 0xb3, 0x70, 0x0f, 0x01, 0x44, + 0x20, 0xf5, 0x71, 0x0f, 0x01, 0x4a, 0xc4, 0xaf, 0x75, 0x0f, 0x01, 0x4a, + 0x5a, 0xb0, 0x72, 0x0f, 0x01, 0x44, 0xb0, 0xf6, 0x77, 0x0f, 0x01, 0xac, + 0x46, 0x43, 0xb4, 0x05, 0x79, 0x0f, 0x01, 0x43, 0x18, 0x24, 0x7a, 0x0f, + 0x01, 0x42, 0x6f, 0x02, 0x7c, 0x0f, 0x01, 0x44, 0x8a, 0x69, 0x7e, 0x0f, + 0x01, 0xb3, 0x18, 0x43, 0x53, 0xca, 0x80, 0x0f, 0x01, 0x43, 0x1c, 0x8f, + 0x73, 0x0f, 0x01, 0x44, 0xfd, 0x54, 0x76, 0x0f, 0x01, 0x45, 0xf7, 0x54, + 0x74, 0x0f, 0x41, 0xa1, 0x06, 0x43, 0x48, 0x17, 0x7f, 0x0f, 0x41, 0x43, + 0x95, 0xf0, 0x7d, 0x0f, 0x01, 0x44, 0x4a, 0xea, 0x7b, 0x0f, 0x41, 0x45, + 0x3b, 0xe2, 0x78, 0x0f, 0x01, 0x43, 0x14, 0x5d, 0x81, 0x0f, 0x41, 0x04, + 0x6f, 0x0c, 0x11, 0x09, 0x5d, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x84, + 0x0f, 0x01, 0x45, 0x20, 0x07, 0x85, 0x0f, 0x41, 0x45, 0x5c, 0x00, 0x82, + 0x0f, 0x01, 0x45, 0x20, 0x07, 0x83, 0x0f, 0x41, 0x07, 0xfa, 0xd9, 0x92, + 0x01, 0x08, 0x8f, 0xd2, 0x01, 0xff, 0xe1, 0x01, 0x0c, 0x81, 0x3a, 0xe5, + 0x05, 0x0c, 0x81, 0x19, 0xe9, 0x04, 0x0c, 0x81, 0x10, 0xaf, 0x01, 0xff, + 0xe5, 0x08, 0x0c, 0x81, 0x04, 0xf1, 0x39, 0x0c, 0x41, 0xeb, 0x1d, 0x0c, + 0x41, 0xf1, 0x37, 0x0c, 0x41, 0xe3, 0x33, 0x0c, 0x01, 0xae, 0x0a, 0x42, + 0xa4, 0x02, 0x42, 0x0c, 0x01, 0xfa, 0x15, 0x0c, 0x41, 0xe3, 0x29, 0x0c, + 0x01, 0xf4, 0x27, 0x0c, 0x01, 0xf9, 0x2b, 0x0c, 0x41, 0xe2, 0x0a, 0x0c, + 0x01, 0xe4, 0x12, 0x0c, 0x01, 0xe5, 0x02, 0x0c, 0x81, 0x24, 0xe7, 0x0e, + 0x0c, 0x01, 0xec, 0x1f, 0x0c, 0x01, 0x42, 0x1d, 0x01, 0x2c, 0x0c, 0x01, + 0xf1, 0x35, 0x0c, 0x01, 0xf2, 0x3b, 0x0c, 0x01, 0x42, 0xa4, 0x02, 0x40, + 0x0c, 0x01, 0xf4, 0x44, 0x0c, 0x01, 0xf9, 0x17, 0x0c, 0x41, 0xe2, 0x0c, + 0x0c, 0x01, 0xe7, 0x10, 0x0c, 0x01, 0xeb, 0x1b, 0x0c, 0x01, 0xee, 0x25, + 0x0c, 0x81, 0x08, 0xf4, 0x46, 0x0c, 0x01, 0xf9, 0x19, 0x0c, 0x41, 0xe7, + 0x2e, 0x0c, 0x41, 0xe1, 0x00, 0x0c, 0x81, 0x5d, 0x44, 0x10, 0xf5, 0x48, + 0x0c, 0x01, 0xa5, 0x27, 0xe9, 0x03, 0x0c, 0x81, 0x1a, 0xef, 0x06, 0x0c, + 0xc1, 0x00, 0xe5, 0x07, 0x0c, 0x81, 0x0c, 0xf0, 0x30, 0x0c, 0x01, 0xf1, + 0x38, 0x0c, 0x01, 0xf4, 0x47, 0x0c, 0x41, 0xeb, 0x1c, 0x0c, 0x41, 0xe3, + 0x31, 0x0c, 0x01, 0xf1, 0x36, 0x0c, 0x41, 0xe3, 0x32, 0x0c, 0x01, 0x42, + 0xb8, 0x04, 0x21, 0x0c, 0x01, 0xed, 0x22, 0x0c, 0x01, 0xae, 0x0e, 0xf0, + 0x2f, 0x0c, 0x01, 0x42, 0xa4, 0x02, 0x41, 0x0c, 0x01, 0xfa, 0x14, 0x0c, + 0x41, 0xe3, 0x28, 0x0c, 0x01, 0xe7, 0x2d, 0x0c, 0x01, 0xf4, 0x26, 0x0c, + 0x01, 0xf9, 0x2a, 0x0c, 0x41, 0xe2, 0x09, 0x0c, 0x01, 0xe4, 0x11, 0x0c, + 0x01, 0xa5, 0x25, 0xe7, 0x0d, 0x0c, 0x01, 0xec, 0x1e, 0x0c, 0x01, 0xee, + 0x23, 0x0c, 0x01, 0xf1, 0x34, 0x0c, 0x01, 0xf2, 0x3a, 0x0c, 0x01, 0xf3, + 0x3d, 0x0c, 0x81, 0x08, 0xf4, 0x43, 0x0c, 0x01, 0xf9, 0x16, 0x0c, 0x41, + 0xe8, 0x3f, 0x0c, 0x41, 0xe2, 0x0b, 0x0c, 0x01, 0xe4, 0x13, 0x0c, 0x01, + 0xe7, 0x0f, 0x0c, 0x01, 0xeb, 0x1a, 0x0c, 0x01, 0xec, 0x20, 0x0c, 0x01, + 0xee, 0x24, 0x0c, 0x01, 0xf2, 0x3c, 0x0c, 0x01, 0xf3, 0x3e, 0x0c, 0x01, + 0xf4, 0x45, 0x0c, 0x01, 0xf9, 0x18, 0x0c, 0x41, 0x06, 0xae, 0xd9, 0xea, + 0x01, 0x0c, 0x9c, 0x9b, 0x01, 0xff, 0x07, 0x13, 0x06, 0x1b, 0x03, 0x15, + 0x3a, 0x01, 0xff, 0x04, 0xb7, 0x05, 0x06, 0x4e, 0x0a, 0x7b, 0x7f, 0x0a, + 0x41, 0x45, 0x02, 0x24, 0x7e, 0x0a, 0x01, 0x43, 0x7a, 0x0b, 0x7d, 0x0a, + 0x41, 0xa1, 0xb7, 0x01, 0x44, 0x20, 0xf5, 0x68, 0x0a, 0x01, 0xa4, 0x97, + 0x01, 0x42, 0x2e, 0x1b, 0x70, 0x0a, 0x01, 0xa7, 0x82, 0x01, 0x42, 0xb0, + 0x01, 0x60, 0x0a, 0x81, 0x75, 0xab, 0x67, 0x46, 0x8a, 0xe3, 0x61, 0x0a, + 0x01, 0x43, 0xb4, 0x05, 0x63, 0x0a, 0x01, 0x43, 0x18, 0x24, 0x6c, 0x0a, + 0x01, 0x44, 0xf3, 0xcd, 0x64, 0x0a, 0x01, 0x44, 0x8a, 0x69, 0x67, 0x0a, + 0x01, 0xb3, 0x2f, 0xb4, 0x12, 0x43, 0x1c, 0x8f, 0x65, 0x0a, 0x01, 0x44, + 0xfd, 0x54, 0x7a, 0x0a, 0x01, 0x44, 0x58, 0xf9, 0x78, 0x0a, 0x41, 0x42, + 0x3e, 0x2f, 0x69, 0x0a, 0x01, 0x43, 0x48, 0x27, 0x77, 0x0a, 0x01, 0xa8, + 0x01, 0xff, 0x42, 0x3e, 0x2f, 0x7b, 0x0a, 0x01, 0x43, 0x48, 0x27, 0x7c, + 0x0a, 0x41, 0xa1, 0x06, 0x43, 0x48, 0x17, 0x66, 0x0a, 0x41, 0x43, 0x95, + 0xf0, 0x6e, 0x0a, 0x01, 0x44, 0x4a, 0xea, 0x6f, 0x0a, 0x01, 0xf4, 0x6a, + 0x0a, 0x41, 0x43, 0x32, 0x11, 0x6b, 0x0a, 0x01, 0x44, 0xca, 0xaf, 0x6d, + 0x0a, 0x41, 0x42, 0x53, 0x00, 0x62, 0x0a, 0x41, 0x44, 0x04, 0xf6, 0x76, + 0x0a, 0x01, 0x44, 0x5b, 0xb0, 0x74, 0x0a, 0x41, 0x45, 0x6e, 0x4c, 0x75, + 0x0a, 0x01, 0x02, 0x22, 0x00, 0x01, 0xff, 0x43, 0x95, 0xf0, 0x73, 0x0a, + 0x01, 0x44, 0x6f, 0x4c, 0x79, 0x0a, 0x41, 0x43, 0x68, 0x00, 0x71, 0x0a, + 0x01, 0x42, 0x25, 0x1e, 0x72, 0x0a, 0x41, 0x51, 0x9f, 0x5c, 0x26, 0x0f, + 0x01, 0xac, 0x44, 0x07, 0x37, 0x3c, 0x01, 0xff, 0xa6, 0x31, 0x43, 0x7a, + 0x0b, 0x1d, 0x0f, 0x81, 0x24, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x22, + 0x0f, 0x01, 0xa8, 0x0d, 0xb7, 0x01, 0xff, 0x44, 0xe9, 0x1e, 0x23, 0x0f, + 0x01, 0xef, 0x1e, 0x0f, 0x41, 0x44, 0x49, 0x12, 0x24, 0x0f, 0x01, 0x43, + 0x26, 0x01, 0x1f, 0x0f, 0x41, 0x48, 0x3e, 0x12, 0x25, 0x0f, 0x41, 0x43, + 0xf9, 0x05, 0x21, 0x0f, 0x01, 0x43, 0xf6, 0x06, 0x20, 0x0f, 0x41, 0x06, + 0x14, 0x06, 0x06, 0x53, 0x60, 0x4c, 0x27, 0x0f, 0x41, 0xa1, 0xa8, 0x01, + 0x44, 0x20, 0xf5, 0x02, 0x0f, 0x01, 0x06, 0x7c, 0x2e, 0x65, 0x45, 0x5a, + 0xb0, 0x04, 0x0f, 0x01, 0x42, 0xb0, 0x01, 0x05, 0x0f, 0x81, 0x52, 0x44, + 0xb0, 0xf6, 0x0b, 0x0f, 0x01, 0x46, 0x8a, 0xe3, 0x0c, 0x0f, 0x01, 0x43, + 0xb4, 0x05, 0x0d, 0x0f, 0x01, 0x43, 0x18, 0x24, 0x0e, 0x0f, 0x01, 0x42, + 0x6f, 0x02, 0x14, 0x0f, 0x01, 0x50, 0x8a, 0x69, 0x18, 0x0f, 0x01, 0xb3, + 0x18, 0x43, 0x53, 0xca, 0x1a, 0x0f, 0x01, 0x43, 0x1c, 0x8f, 0x07, 0x0f, + 0x01, 0x44, 0xfd, 0x54, 0x0a, 0x0f, 0x01, 0x45, 0xf7, 0x54, 0x08, 0x0f, + 0x41, 0xa1, 0x06, 0x43, 0x48, 0x17, 0x19, 0x0f, 0x41, 0x43, 0x95, 0xf0, + 0x15, 0x0f, 0x01, 0x44, 0x4a, 0xea, 0x11, 0x0f, 0x41, 0x42, 0x53, 0x00, + 0x09, 0x0f, 0x41, 0x45, 0x39, 0xb3, 0x01, 0x0f, 0x01, 0x44, 0x20, 0xf5, + 0x03, 0x0f, 0x01, 0x42, 0xb0, 0x01, 0x06, 0x0f, 0x01, 0x43, 0x18, 0x24, + 0x0f, 0x0f, 0x81, 0x1a, 0x45, 0x93, 0xf0, 0x16, 0x0f, 0x81, 0x0d, 0x43, + 0x53, 0xca, 0x1b, 0x0f, 0xc1, 0x00, 0x53, 0x00, 0x4a, 0x1c, 0x0f, 0x41, + 0x53, 0x00, 0x4a, 0x17, 0x0f, 0x41, 0x53, 0x00, 0x4a, 0x10, 0x0f, 0x41, + 0xac, 0x06, 0x43, 0xa0, 0x1b, 0x12, 0x0f, 0x41, 0x43, 0x3c, 0x3f, 0x00, + 0x0f, 0x01, 0x4c, 0xb8, 0x9a, 0x13, 0x0f, 0x41, 0x0b, 0x3d, 0x5e, 0xbb, + 0x02, 0xb3, 0x01, 0xff, 0x04, 0xbb, 0x08, 0x0d, 0x4d, 0x33, 0x8b, 0xb3, + 0xf5, 0xc1, 0x00, 0x65, 0xbd, 0x07, 0xb2, 0xce, 0x41, 0x07, 0x37, 0x3c, + 0x80, 0x02, 0x05, 0x5a, 0x03, 0x06, 0x4c, 0xa9, 0x26, 0xd0, 0x03, 0x41, + 0xe1, 0xa0, 0x03, 0x81, 0xdd, 0x01, 0xa2, 0xc9, 0x01, 0x42, 0x37, 0x00, + 0xa8, 0x03, 0x01, 0xa4, 0xa6, 0x01, 0x42, 0x0c, 0x08, 0xb3, 0x03, 0x01, + 0xa7, 0x95, 0x01, 0x42, 0x22, 0x00, 0xc3, 0x03, 0x01, 0xe9, 0xa1, 0x03, + 0x01, 0xaa, 0x80, 0x01, 0xab, 0x76, 0x42, 0x74, 0x00, 0xbe, 0x03, 0x01, + 0xad, 0x62, 0xae, 0x58, 0x42, 0xe0, 0x09, 0xb1, 0x03, 0x01, 0xb2, 0x48, + 0xb3, 0x36, 0xb4, 0x26, 0xf5, 0xa2, 0x03, 0x01, 0xb6, 0x18, 0xb8, 0x0c, + 0x42, 0xdf, 0x23, 0xb9, 0x03, 0x01, 0x42, 0x59, 0x00, 0xc0, 0x03, 0x41, + 0xe1, 0xa7, 0x03, 0x01, 0x4b, 0xbf, 0xa7, 0xcb, 0x03, 0x41, 0xe1, 0xba, + 0x03, 0x01, 0xe9, 0xbb, 0x03, 0x41, 0xe1, 0xab, 0x03, 0x01, 0x42, 0x22, + 0x00, 0xb0, 0x03, 0x01, 0xf5, 0xac, 0x03, 0x41, 0xe1, 0xbf, 0x03, 0x01, + 0x42, 0x22, 0x00, 0xc1, 0x03, 0x01, 0x42, 0x40, 0x06, 0xc2, 0x03, 0x41, + 0xe1, 0xbc, 0x03, 0x01, 0xf5, 0xbd, 0x03, 0x41, 0xe1, 0xb4, 0x03, 0x01, + 0xf5, 0xb5, 0x03, 0x41, 0xe1, 0xb6, 0x03, 0x01, 0xe9, 0xb7, 0x03, 0x01, + 0xf5, 0xb8, 0x03, 0x41, 0xe1, 0xa3, 0x03, 0x01, 0xf5, 0xa4, 0x03, 0x41, + 0xe1, 0xa9, 0x03, 0x01, 0xe9, 0xaa, 0x03, 0x41, 0xe1, 0xa5, 0x03, 0x01, + 0xf5, 0xa6, 0x03, 0x41, 0xe1, 0xad, 0x03, 0x81, 0x08, 0xe9, 0xae, 0x03, + 0x01, 0xf5, 0xaf, 0x03, 0x41, 0x47, 0x7d, 0xd7, 0xcc, 0x03, 0xc1, 0x00, + 0x42, 0x86, 0xf9, 0xcd, 0x03, 0x41, 0xe1, 0xb2, 0x03, 0x81, 0x06, 0x46, + 0x08, 0xe7, 0xcf, 0x03, 0x41, 0x42, 0x24, 0x02, 0xce, 0x03, 0x41, 0x49, + 0x59, 0xc6, 0xc8, 0x03, 0xc1, 0x00, 0x42, 0x86, 0xf9, 0xc9, 0x03, 0x01, + 0x42, 0x22, 0x00, 0xca, 0x03, 0x41, 0x47, 0x3f, 0x12, 0xd5, 0x03, 0x01, + 0x43, 0x7a, 0x0b, 0xd1, 0x03, 0x01, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, + 0xd3, 0x03, 0x01, 0xb7, 0x01, 0xff, 0x44, 0xe9, 0x1e, 0xd4, 0x03, 0x01, + 0xef, 0xd2, 0x03, 0x41, 0x42, 0x1a, 0x00, 0x50, 0x03, 0x01, 0x43, 0xff, + 0x37, 0x51, 0x03, 0x01, 0x45, 0x1b, 0xeb, 0x64, 0x03, 0x01, 0xa4, 0xba, + 0x01, 0xe5, 0x54, 0x03, 0x81, 0xb0, 0x01, 0x43, 0x97, 0x4d, 0x52, 0x03, + 0x01, 0x42, 0x22, 0x00, 0x6c, 0x03, 0x01, 0xe9, 0x59, 0x03, 0x81, 0x96, + 0x01, 0x44, 0xd0, 0xf6, 0x5a, 0x03, 0x01, 0x43, 0xa5, 0x45, 0x5b, 0x03, + 0x01, 0x45, 0x81, 0xee, 0x5c, 0x03, 0x01, 0x45, 0xf9, 0xee, 0x5d, 0x03, + 0x01, 0xef, 0x69, 0x03, 0x81, 0x75, 0x44, 0xf8, 0xf7, 0x5f, 0x03, 0x01, + 0x43, 0x3c, 0x31, 0x60, 0x03, 0x01, 0xb3, 0x53, 0xb4, 0x45, 0xf5, 0x63, + 0x03, 0x01, 0xb6, 0x33, 0xb9, 0x0f, 0xba, 0x01, 0xff, 0x43, 0xdd, 0x19, + 0x57, 0x03, 0x01, 0x43, 0x85, 0xe2, 0x55, 0x03, 0x41, 0xe1, 0x74, 0x03, + 0x81, 0x19, 0x42, 0x33, 0x00, 0x6f, 0x03, 0x81, 0x0a, 0x42, 0xcc, 0x0a, + 0x67, 0x03, 0x01, 0xf5, 0x73, 0x03, 0x41, 0xe9, 0x70, 0x03, 0x01, 0xf5, + 0x68, 0x03, 0x41, 0xf4, 0x71, 0x03, 0x41, 0x42, 0x33, 0x00, 0x6e, 0x03, + 0x01, 0x43, 0x27, 0xeb, 0x5e, 0x03, 0x41, 0x42, 0x56, 0x07, 0x62, 0x03, + 0x01, 0x43, 0x9d, 0xd5, 0x6d, 0x03, 0x41, 0xa8, 0x06, 0x42, 0xc0, 0x29, + 0x61, 0x03, 0x41, 0x45, 0x25, 0xeb, 0x66, 0x03, 0x01, 0x43, 0x27, 0xeb, + 0x65, 0x03, 0x41, 0xef, 0x6a, 0x03, 0x41, 0xe1, 0x75, 0x03, 0x01, 0xe5, + 0x72, 0x03, 0x41, 0xe6, 0x6b, 0x03, 0x41, 0x42, 0x9d, 0x01, 0x53, 0x03, + 0x01, 0xba, 0x01, 0xff, 0x43, 0x85, 0xe2, 0x56, 0x03, 0x01, 0x43, 0x0e, + 0x06, 0x58, 0x03, 0x41, 0x07, 0x13, 0x06, 0x1a, 0x07, 0x37, 0x3c, 0x01, + 0xff, 0x43, 0x7a, 0x0b, 0x9d, 0x0a, 0x01, 0xb4, 0x01, 0xff, 0x42, 0x92, + 0x01, 0x9e, 0x0a, 0x01, 0x45, 0xe8, 0x1e, 0x9f, 0x0a, 0x41, 0xa1, 0xb0, + 0x01, 0x43, 0x35, 0x85, 0x88, 0x0a, 0x01, 0x02, 0x7b, 0x08, 0x9d, 0x01, + 0x03, 0x73, 0xdb, 0x8c, 0x01, 0x43, 0x70, 0xbe, 0x90, 0x0a, 0x01, 0xa7, + 0x78, 0xa8, 0x6a, 0xab, 0x5c, 0x43, 0xb0, 0x00, 0x81, 0x0a, 0x01, 0x44, + 0x3f, 0x22, 0x83, 0x0a, 0x01, 0x44, 0x30, 0x48, 0x8c, 0x0a, 0x01, 0x43, + 0x11, 0x15, 0x84, 0x0a, 0x01, 0x43, 0x93, 0x54, 0x87, 0x0a, 0x01, 0x43, + 0x4d, 0x15, 0x8e, 0x0a, 0x01, 0xb4, 0x1b, 0x43, 0x1c, 0x8f, 0x85, 0x0a, + 0x01, 0x43, 0x4d, 0x00, 0x9a, 0x0a, 0x01, 0x02, 0x59, 0x00, 0x01, 0xff, + 0xe8, 0x9c, 0x0a, 0x01, 0x42, 0x9e, 0x01, 0x98, 0x0a, 0x41, 0x42, 0x3d, + 0x0a, 0x97, 0x0a, 0x01, 0x42, 0x4e, 0x00, 0x89, 0x0a, 0x01, 0xa8, 0x01, + 0xff, 0x42, 0x13, 0x00, 0x99, 0x0a, 0x01, 0x42, 0x4e, 0x00, 0x9b, 0x0a, + 0x41, 0x42, 0x12, 0x15, 0x8b, 0x0a, 0x01, 0x43, 0x49, 0x22, 0x8d, 0x0a, + 0x41, 0x42, 0x3d, 0x0a, 0x82, 0x0a, 0x01, 0x42, 0x4e, 0x00, 0x80, 0x0a, + 0x41, 0x43, 0x51, 0x19, 0x94, 0x0a, 0x01, 0x44, 0x90, 0xa1, 0x96, 0x0a, + 0x41, 0xd1, 0x8a, 0x0a, 0x01, 0xd2, 0x86, 0x0a, 0x01, 0xd3, 0x8f, 0x0a, + 0x41, 0xe4, 0x93, 0x0a, 0x01, 0xec, 0x95, 0x0a, 0x41, 0x42, 0x9e, 0x01, + 0x92, 0x0a, 0x01, 0x43, 0x68, 0x00, 0x91, 0x0a, 0x41, 0x07, 0x13, 0x06, + 0x21, 0x08, 0xb2, 0x5f, 0x01, 0xff, 0x02, 0xf3, 0x02, 0x0c, 0x43, 0x7a, + 0x0b, 0x20, 0x03, 0x01, 0x43, 0xdb, 0x06, 0x22, 0x03, 0x41, 0x43, 0x04, + 0x24, 0x23, 0x03, 0x01, 0x42, 0x32, 0x00, 0x21, 0x03, 0x41, 0xe1, 0x00, + 0x03, 0x01, 0x42, 0xb7, 0x05, 0x01, 0x03, 0x01, 0x43, 0x3b, 0x15, 0x1c, + 0x03, 0x01, 0x42, 0x04, 0x00, 0x03, 0x03, 0x01, 0xe5, 0x04, 0x03, 0x81, + 0x6e, 0x42, 0xb0, 0x01, 0x07, 0x03, 0x01, 0xe9, 0x09, 0x03, 0x81, 0x5f, + 0xab, 0x4b, 0x4c, 0x88, 0x97, 0x2e, 0x03, 0x01, 0xef, 0x0f, 0x03, 0x01, + 0xb0, 0x35, 0xb3, 0x27, 0xb4, 0x1b, 0xf5, 0x16, 0x03, 0x81, 0x12, 0x42, + 0x32, 0x00, 0x05, 0x03, 0x01, 0x42, 0x4d, 0x00, 0x2d, 0x03, 0x01, 0x42, + 0x94, 0x0a, 0x06, 0x03, 0x41, 0xf5, 0x1e, 0x03, 0x41, 0xe5, 0x15, 0x03, + 0x01, 0x42, 0xb0, 0x01, 0x08, 0x03, 0x41, 0x42, 0xb0, 0x01, 0x11, 0x03, + 0x01, 0x4b, 0x54, 0xa6, 0x2f, 0x03, 0x41, 0xe5, 0x10, 0x03, 0x01, 0x42, + 0xb0, 0x01, 0x18, 0x03, 0x41, 0xe1, 0x0a, 0x03, 0x01, 0xe5, 0x02, 0x03, + 0x01, 0x42, 0xb0, 0x01, 0x19, 0x03, 0x01, 0xf5, 0x12, 0x03, 0x41, 0xe9, + 0x1d, 0x03, 0x41, 0xe6, 0x1a, 0x03, 0x01, 0x42, 0x6e, 0x00, 0x17, 0x03, + 0x01, 0xec, 0x0b, 0x03, 0x01, 0xed, 0x0c, 0x03, 0x01, 0xee, 0x0d, 0x03, + 0x01, 0xf2, 0x13, 0x03, 0x81, 0x0d, 0xf3, 0x14, 0x03, 0xc1, 0x00, 0xe8, + 0x0e, 0x03, 0x01, 0xf3, 0x1f, 0x03, 0x41, 0xf3, 0x1b, 0x03, 0x41, 0x0f, + 0x0b, 0x06, 0xaf, 0x02, 0x07, 0x37, 0x3c, 0xfe, 0x01, 0x0d, 0x9b, 0x08, + 0x01, 0xff, 0xe1, 0xc0, 0x0c, 0x81, 0xdf, 0x01, 0x47, 0xbd, 0xd5, 0xca, + 0x0c, 0x01, 0xe5, 0xc9, 0x0c, 0x81, 0x51, 0xe9, 0xd0, 0x0c, 0x81, 0x48, + 0x0b, 0x41, 0xa5, 0x38, 0xef, 0xdb, 0x0c, 0x81, 0x29, 0x0a, 0x54, 0xb6, + 0x19, 0x48, 0x9f, 0xd0, 0xe3, 0x0c, 0x01, 0xf5, 0xea, 0x0c, 0xc1, 0x00, + 0x42, 0x21, 0x27, 0xd5, 0x0c, 0x01, 0xf3, 0xf2, 0x0c, 0x01, 0xf5, 0xeb, + 0x0c, 0x41, 0x42, 0xce, 0x53, 0xde, 0x0c, 0x01, 0x42, 0x5c, 0x0a, 0xed, + 0x0c, 0x41, 0x42, 0x27, 0x01, 0xdf, 0x0c, 0x01, 0xef, 0xdc, 0x0c, 0x41, + 0x42, 0xce, 0x53, 0xdd, 0x0c, 0x01, 0x42, 0x5c, 0x0a, 0xec, 0x0c, 0x41, + 0xe9, 0xd1, 0x0c, 0x41, 0xe2, 0xc2, 0x0c, 0x01, 0xe3, 0xc4, 0x0c, 0x81, + 0x72, 0xe4, 0xc7, 0x0c, 0x01, 0xe5, 0xcb, 0x0c, 0x01, 0xe6, 0xcc, 0x0c, + 0x01, 0xe7, 0xcd, 0x0c, 0x81, 0x5d, 0xe8, 0xcf, 0x0c, 0x01, 0xea, 0xd2, + 0x0c, 0x01, 0xeb, 0xd3, 0x0c, 0x01, 0xec, 0xd6, 0x0c, 0x81, 0x48, 0xed, + 0xd8, 0x0c, 0x81, 0x3f, 0xee, 0xd9, 0x0c, 0x81, 0x27, 0xf0, 0xe0, 0x0c, + 0x01, 0xf2, 0xe2, 0x0c, 0x01, 0xf3, 0xe4, 0x0c, 0x81, 0x16, 0xf4, 0xe6, + 0x0c, 0x81, 0x0d, 0xf6, 0xee, 0x0c, 0x01, 0xfa, 0xef, 0x0c, 0xc1, 0x00, + 0xf3, 0xf0, 0x0c, 0x41, 0xf9, 0xe8, 0x0c, 0x41, 0xfa, 0xe5, 0x0c, 0x41, + 0xe3, 0xc5, 0x0c, 0x01, 0xf4, 0xe7, 0x0c, 0x81, 0x04, 0xf9, 0xda, 0x0c, + 0x41, 0x4c, 0x68, 0x90, 0xf1, 0x0c, 0x41, 0xf0, 0xe1, 0x0c, 0x41, 0xf9, + 0xd7, 0x0c, 0x41, 0xf9, 0xce, 0x0c, 0x41, 0xe8, 0xe9, 0x0c, 0x01, 0xf3, + 0xc6, 0x0c, 0x41, 0xe1, 0xc1, 0x0c, 0x01, 0xeb, 0xd4, 0x0c, 0x01, 0x42, + 0xb6, 0x05, 0xc3, 0x0c, 0x01, 0x42, 0x1b, 0x00, 0xc8, 0x0c, 0x41, 0x02, + 0xf3, 0x02, 0x1c, 0x43, 0x7a, 0x0b, 0xfa, 0x0c, 0x81, 0x06, 0x43, 0xdb, + 0x06, 0xfc, 0x0c, 0x41, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0xfe, 0x0c, + 0x01, 0x48, 0xde, 0x1e, 0xff, 0x0c, 0x41, 0x43, 0x04, 0x24, 0xfd, 0x0c, + 0x01, 0x42, 0x32, 0x00, 0xfb, 0x0c, 0x41, 0xe1, 0x80, 0x0c, 0x81, 0xdf, + 0x01, 0x47, 0xbd, 0xd5, 0x8a, 0x0c, 0x01, 0xe5, 0x89, 0x0c, 0x81, 0x51, + 0xe9, 0x90, 0x0c, 0x81, 0x48, 0x0b, 0x41, 0xa5, 0x38, 0xef, 0x9b, 0x0c, + 0x81, 0x29, 0x0a, 0x54, 0xb6, 0x19, 0x48, 0x9f, 0xd0, 0xa3, 0x0c, 0x01, + 0xf5, 0xaa, 0x0c, 0xc1, 0x00, 0x42, 0x21, 0x27, 0x95, 0x0c, 0x01, 0xf3, + 0xb2, 0x0c, 0x01, 0xf5, 0xab, 0x0c, 0x41, 0x42, 0xce, 0x53, 0x9e, 0x0c, + 0x01, 0x42, 0x5c, 0x0a, 0xad, 0x0c, 0x41, 0x42, 0x27, 0x01, 0x9f, 0x0c, + 0x01, 0xef, 0x9c, 0x0c, 0x41, 0x42, 0xce, 0x53, 0x9d, 0x0c, 0x01, 0x42, + 0x5c, 0x0a, 0xac, 0x0c, 0x41, 0xe9, 0x91, 0x0c, 0x41, 0xe2, 0x82, 0x0c, + 0x01, 0xe3, 0x84, 0x0c, 0x81, 0x72, 0xe4, 0x87, 0x0c, 0x01, 0xe5, 0x8b, + 0x0c, 0x01, 0xe6, 0x8c, 0x0c, 0x01, 0xe7, 0x8d, 0x0c, 0x81, 0x5d, 0xe8, + 0x8f, 0x0c, 0x01, 0xea, 0x92, 0x0c, 0x01, 0xeb, 0x93, 0x0c, 0x01, 0xec, + 0x96, 0x0c, 0x81, 0x48, 0xed, 0x98, 0x0c, 0x81, 0x3f, 0xee, 0x99, 0x0c, + 0x81, 0x27, 0xf0, 0xa0, 0x0c, 0x01, 0xf2, 0xa2, 0x0c, 0x01, 0xf3, 0xa4, + 0x0c, 0x81, 0x16, 0xf4, 0xa6, 0x0c, 0x81, 0x0d, 0xf6, 0xae, 0x0c, 0x01, + 0xfa, 0xaf, 0x0c, 0xc1, 0x00, 0xf3, 0xb0, 0x0c, 0x41, 0xf9, 0xa8, 0x0c, + 0x41, 0xfa, 0xa5, 0x0c, 0x41, 0xe3, 0x85, 0x0c, 0x01, 0xf4, 0xa7, 0x0c, + 0x81, 0x04, 0xf9, 0x9a, 0x0c, 0x41, 0x4c, 0x68, 0x90, 0xb1, 0x0c, 0x41, + 0xf0, 0xa1, 0x0c, 0x41, 0xf9, 0x97, 0x0c, 0x41, 0xf9, 0x8e, 0x0c, 0x41, + 0xe8, 0xa9, 0x0c, 0x01, 0xf3, 0x86, 0x0c, 0x41, 0xe1, 0x81, 0x0c, 0x01, + 0xeb, 0x94, 0x0c, 0x01, 0x42, 0xb6, 0x05, 0x83, 0x0c, 0x01, 0x42, 0x1b, + 0x00, 0x88, 0x0c, 0x41, 0x49, 0x48, 0xbf, 0xe2, 0x6f, 0x01, 0x4e, 0x7b, + 0x21, 0xe3, 0x6f, 0x41, 0x06, 0x78, 0xe0, 0xf5, 0x01, 0x05, 0x1e, 0x17, + 0x01, 0xff, 0x51, 0x5d, 0x5a, 0xff, 0xe5, 0x01, 0x06, 0xef, 0x06, 0xa3, + 0x01, 0x07, 0x13, 0x06, 0x17, 0x05, 0x5a, 0x03, 0x01, 0xff, 0x47, 0x76, + 0xd7, 0xf0, 0xe5, 0x01, 0x44, 0x6c, 0xf6, 0xef, 0xe5, 0x01, 0x42, 0x91, + 0x17, 0xee, 0xe5, 0x41, 0xe1, 0xd6, 0xe5, 0x81, 0x6f, 0xe5, 0xe8, 0xe5, + 0x81, 0x54, 0xe9, 0xdc, 0xe5, 0x81, 0x3a, 0xef, 0xd0, 0xe5, 0x81, 0x1d, + 0xf5, 0xe2, 0xe5, 0xc1, 0x00, 0x42, 0x7f, 0x02, 0xe4, 0xe5, 0x01, 0xea, + 0xe5, 0xe5, 0x01, 0xeb, 0xe3, 0xe5, 0x01, 0x42, 0x9f, 0x1b, 0xe6, 0xe5, + 0x01, 0xf2, 0xe7, 0xe5, 0x41, 0xed, 0xd1, 0xe5, 0x01, 0x42, 0x1d, 0x01, + 0xd2, 0xe5, 0x01, 0xef, 0xd4, 0xe5, 0x01, 0x42, 0xcf, 0x00, 0xd3, 0xe5, + 0x01, 0xf9, 0xd5, 0xe5, 0x41, 0xe4, 0xe0, 0xe5, 0x01, 0xee, 0xe1, 0xe5, + 0x01, 0xf0, 0xde, 0xe5, 0x01, 0xf4, 0xdd, 0xe5, 0xc1, 0x00, 0xf4, 0xdf, + 0xe5, 0x41, 0xe3, 0xeb, 0xe5, 0x01, 0xe7, 0xed, 0xe5, 0x01, 0xe8, 0xea, + 0xe5, 0x01, 0x42, 0x9d, 0x25, 0xec, 0xe5, 0x01, 0xf3, 0xe9, 0xe5, 0x41, + 0xe2, 0xd8, 0xe5, 0x01, 0xe4, 0xd7, 0xe5, 0x01, 0xe8, 0xd9, 0xe5, 0x01, + 0xec, 0xda, 0xe5, 0x01, 0xf7, 0xdb, 0xe5, 0x41, 0x45, 0x7e, 0x0b, 0xf9, + 0xe5, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xfa, 0xe5, 0x01, 0x43, 0x7a, + 0x0b, 0xf2, 0xe5, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xf1, + 0xe5, 0x41, 0x44, 0x25, 0x01, 0xf4, 0xe5, 0x01, 0x42, 0x15, 0x02, 0xf3, + 0xe5, 0x41, 0x44, 0x06, 0x1f, 0xf8, 0xe5, 0x01, 0x42, 0x09, 0x24, 0xf7, + 0xe5, 0x41, 0x43, 0xf9, 0x05, 0xf6, 0xe5, 0x01, 0x43, 0xf6, 0x06, 0xf5, + 0xe5, 0x41, 0x44, 0xc8, 0xf4, 0x7d, 0x1c, 0x00, 0x06, 0xef, 0x06, 0xcd, + 0x01, 0x50, 0x2b, 0x5a, 0x79, 0x1c, 0x00, 0x07, 0x13, 0x06, 0x2f, 0x02, + 0x91, 0x17, 0x1f, 0xb0, 0x06, 0x45, 0x3e, 0xf0, 0x7b, 0x1c, 0x40, 0x47, + 0x37, 0xd7, 0x7c, 0x1c, 0x00, 0x0b, 0x3c, 0x17, 0x01, 0xff, 0x4d, 0x39, + 0x86, 0x7f, 0x1c, 0x00, 0x46, 0x40, 0x86, 0x7e, 0x1c, 0x40, 0x48, 0x57, + 0xc8, 0x78, 0x1c, 0x00, 0x51, 0x2a, 0x5a, 0x7a, 0x1c, 0x40, 0xa1, 0x6e, + 0xa5, 0x58, 0xa9, 0x44, 0xac, 0x29, 0xaf, 0x15, 0xb5, 0x01, 0xff, 0xe3, + 0x6a, 0x1c, 0x00, 0xe4, 0x6b, 0x1c, 0x00, 0x42, 0x9d, 0x25, 0x6c, 0x1c, + 0x00, 0xf9, 0x6d, 0x1c, 0x40, 0xe2, 0x75, 0x1c, 0x00, 0xe8, 0x77, 0x1c, + 0x00, 0x42, 0x15, 0x06, 0x74, 0x1c, 0x00, 0xf6, 0x76, 0x1c, 0x40, 0xe1, + 0x5a, 0x1c, 0x80, 0x10, 0xe5, 0x6e, 0x1c, 0x00, 0xe9, 0x64, 0x1c, 0x00, + 0xef, 0x73, 0x1c, 0x00, 0xf5, 0x69, 0x1c, 0x40, 0xe1, 0x5f, 0x1c, 0x40, + 0xe8, 0x66, 0x1c, 0x00, 0x42, 0x9f, 0x1b, 0x67, 0x1c, 0x00, 0xf2, 0x68, + 0x1c, 0x00, 0xf3, 0x65, 0x1c, 0x40, 0x42, 0x7f, 0x02, 0x70, 0x1c, 0x00, + 0xee, 0x71, 0x1c, 0x00, 0xf0, 0x6f, 0x1c, 0x00, 0x42, 0xcf, 0x00, 0x72, + 0x1c, 0x40, 0xa1, 0x12, 0xe7, 0x5c, 0x1c, 0x00, 0xec, 0x5e, 0x1c, 0x00, + 0x42, 0x1d, 0x01, 0x5d, 0x1c, 0x00, 0xf4, 0x5b, 0x1c, 0x40, 0xea, 0x61, + 0x1c, 0x00, 0xeb, 0x60, 0x1c, 0x00, 0xed, 0x62, 0x1c, 0x00, 0xf7, 0x63, + 0x1c, 0x40, 0x45, 0x7e, 0x0b, 0x58, 0x1c, 0x00, 0xa6, 0x2e, 0x44, 0x6d, + 0x2c, 0x59, 0x1c, 0x00, 0x43, 0x7a, 0x0b, 0x51, 0x1c, 0x00, 0xb3, 0x14, + 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x50, 0x1c, 0x40, 0x44, 0x25, 0x01, 0x53, + 0x1c, 0x00, 0x42, 0x15, 0x02, 0x52, 0x1c, 0x40, 0x44, 0x06, 0x1f, 0x57, + 0x1c, 0x00, 0x42, 0x09, 0x24, 0x56, 0x1c, 0x40, 0x43, 0xf9, 0x05, 0x55, + 0x1c, 0x00, 0x43, 0xf6, 0x06, 0x54, 0x1c, 0x40, 0x04, 0x18, 0x79, 0x06, + 0x44, 0xb2, 0xe4, 0xdb, 0x02, 0x40, 0x4c, 0xe7, 0x3f, 0x9b, 0x16, 0x00, + 0x07, 0x13, 0x06, 0x0c, 0x55, 0xde, 0x3f, 0x9c, 0x16, 0x00, 0x4a, 0xcc, + 0xb6, 0x80, 0x16, 0x40, 0x44, 0xcc, 0xf4, 0x90, 0x16, 0x00, 0x45, 0xad, + 0xea, 0x81, 0x16, 0x00, 0xa3, 0x8f, 0x01, 0x44, 0x5c, 0xf5, 0x87, 0x16, + 0x00, 0x02, 0x89, 0x00, 0x73, 0x45, 0x51, 0xec, 0x83, 0x16, 0x00, 0x44, + 0xf0, 0xf5, 0x8c, 0x16, 0x00, 0xa9, 0x59, 0x44, 0x04, 0xf7, 0x82, 0x16, + 0x00, 0x44, 0x38, 0xf7, 0x8b, 0x16, 0x00, 0xae, 0x3f, 0xaf, 0x33, 0x45, + 0xc6, 0xef, 0x9a, 0x16, 0x00, 0x44, 0x70, 0xf8, 0x8f, 0x16, 0x00, 0xb3, + 0x19, 0x45, 0x2e, 0xf1, 0x88, 0x16, 0x00, 0xb5, 0x01, 0xff, 0x43, 0x23, + 0x10, 0x86, 0x16, 0x00, 0x47, 0xc3, 0xd7, 0x97, 0x16, 0x00, 0xf2, 0x92, + 0x16, 0x40, 0x43, 0x7a, 0x18, 0x84, 0x16, 0x00, 0x45, 0x60, 0xf1, 0x8e, + 0x16, 0x40, 0x42, 0x9d, 0x25, 0x91, 0x16, 0x00, 0xf2, 0x96, 0x16, 0x40, + 0x46, 0xda, 0xe1, 0x8d, 0x16, 0x00, 0x43, 0xb5, 0x00, 0x85, 0x16, 0x40, + 0x43, 0xfd, 0x09, 0x98, 0x16, 0x00, 0x46, 0xa4, 0xe4, 0x94, 0x16, 0x40, + 0x45, 0xb7, 0xea, 0x95, 0x16, 0x00, 0x45, 0xa5, 0xe4, 0x93, 0x16, 0x00, + 0x49, 0xc7, 0xc1, 0x99, 0x16, 0x40, 0x44, 0x88, 0xf5, 0x8a, 0x16, 0x00, + 0x43, 0x09, 0x22, 0x89, 0x16, 0x40, 0x47, 0x15, 0x08, 0xbb, 0xce, 0x41, + 0x49, 0x23, 0xbd, 0x75, 0xf7, 0x01, 0x02, 0x18, 0x00, 0x0f, 0xb4, 0x01, + 0xff, 0x4b, 0x09, 0x9e, 0xd1, 0xf6, 0x01, 0x44, 0xd8, 0xf7, 0x19, 0xf4, + 0x41, 0x4f, 0xfb, 0x6d, 0x47, 0x24, 0x00, 0xa2, 0x2e, 0xa3, 0x20, 0xa4, + 0x12, 0x44, 0x29, 0x54, 0x42, 0x24, 0x00, 0x44, 0x5b, 0x0f, 0x40, 0x24, + 0x00, 0x4d, 0x68, 0x88, 0x43, 0x24, 0x40, 0x43, 0xf9, 0x03, 0x48, 0x24, + 0x00, 0x4f, 0xb8, 0x74, 0x4a, 0x24, 0x40, 0x44, 0x3e, 0x72, 0x41, 0x24, + 0x00, 0x56, 0x05, 0x3a, 0x49, 0x24, 0x40, 0x4a, 0x38, 0xaf, 0x44, 0x24, + 0x00, 0x46, 0xec, 0xe4, 0x45, 0x24, 0x00, 0x59, 0x19, 0x27, 0x46, 0x24, + 0x40, 0x5a, 0xa3, 0x21, 0xfc, 0xff, 0x00, 0x06, 0x59, 0x0a, 0x06, 0x51, + 0x79, 0x60, 0xff, 0x23, 0x40, 0x0e, 0x66, 0x79, 0x06, 0x46, 0x8a, 0x66, + 0x5d, 0x2e, 0x40, 0x44, 0xa5, 0x01, 0xa7, 0x29, 0x00, 0x42, 0x50, 0x02, + 0xa6, 0x29, 0x40, 0x05, 0x8d, 0x73, 0x82, 0x25, 0xa1, 0xab, 0x1d, 0xa2, + 0x9e, 0x1d, 0xa5, 0xaf, 0x0d, 0xa9, 0x97, 0x0d, 0x03, 0x54, 0xdd, 0xfa, + 0x09, 0xec, 0x0a, 0x00, 0x00, 0x44, 0x54, 0xf7, 0x2f, 0x20, 0x00, 0xaf, + 0xc3, 0x04, 0x4d, 0xe9, 0x8b, 0x10, 0xcc, 0x01, 0xb5, 0xb6, 0x03, 0x16, + 0x73, 0x3a, 0x01, 0xff, 0x4a, 0x02, 0xae, 0x4f, 0xe1, 0x01, 0x06, 0xef, + 0x06, 0xe4, 0x02, 0xac, 0x55, 0xb3, 0x21, 0x05, 0xa0, 0x33, 0x01, 0xff, + 0xe2, 0x30, 0xe1, 0x01, 0xe4, 0x36, 0xe1, 0x01, 0xe7, 0x35, 0xe1, 0x01, + 0xea, 0x32, 0xe1, 0x01, 0xed, 0x31, 0xe1, 0x01, 0xf3, 0x34, 0xe1, 0x01, + 0xf6, 0x33, 0xe1, 0x41, 0x04, 0x5b, 0x03, 0x06, 0x52, 0x5d, 0x59, 0x3d, + 0xe1, 0x41, 0x04, 0x64, 0x1c, 0x06, 0x45, 0x5f, 0xf2, 0x3c, 0xe1, 0x41, + 0x46, 0xac, 0xdf, 0x3a, 0xe1, 0x01, 0x4c, 0x00, 0x95, 0x3b, 0xe1, 0x01, + 0x48, 0x52, 0x89, 0x39, 0xe1, 0x01, 0x46, 0x40, 0x1e, 0x37, 0xe1, 0x01, + 0x45, 0x24, 0xf1, 0x38, 0xe1, 0x41, 0x06, 0x14, 0x06, 0x06, 0x4c, 0xd0, + 0x97, 0x4e, 0xe1, 0x41, 0xe1, 0x24, 0xe1, 0x81, 0xf9, 0x01, 0x42, 0x37, + 0x00, 0x08, 0xe1, 0x01, 0xa4, 0xe6, 0x01, 0xe5, 0x2a, 0xe1, 0x81, 0xdc, + 0x01, 0x42, 0x0c, 0x08, 0x15, 0xe1, 0x01, 0x42, 0x24, 0x02, 0x22, 0xe1, + 0x01, 0x42, 0x22, 0x00, 0x04, 0xe1, 0x81, 0xc4, 0x01, 0xe9, 0x26, 0xe1, + 0x01, 0x42, 0x1b, 0x02, 0x0e, 0xe1, 0x01, 0x42, 0x74, 0x00, 0x09, 0xe1, + 0x01, 0xad, 0xa7, 0x01, 0xae, 0x65, 0xef, 0x28, 0xe1, 0x81, 0x5c, 0xb0, + 0x50, 0x42, 0x11, 0x15, 0x17, 0xe1, 0x01, 0xb2, 0x3e, 0x42, 0x40, 0x06, + 0x0a, 0xe1, 0x01, 0xb4, 0x26, 0xf5, 0x27, 0xe1, 0x01, 0x42, 0x61, 0x0b, + 0x12, 0xe1, 0x01, 0xf7, 0x2c, 0xe1, 0x01, 0xb8, 0x0c, 0x42, 0xdf, 0x23, + 0x18, 0xe1, 0x01, 0x42, 0x59, 0x00, 0x0b, 0xe1, 0x41, 0xe1, 0x06, 0xe1, + 0x01, 0x42, 0xdf, 0x23, 0x1b, 0xe1, 0x41, 0xe1, 0x03, 0xe1, 0x01, 0x42, + 0x40, 0x06, 0x01, 0xe1, 0x01, 0x42, 0x5b, 0x28, 0x14, 0xe1, 0x41, 0xe1, + 0x16, 0xe1, 0x01, 0x42, 0x71, 0x00, 0x23, 0xe1, 0x41, 0xe1, 0x1a, 0xe1, + 0x01, 0x42, 0x74, 0x00, 0x21, 0xe1, 0x41, 0xef, 0x29, 0xe1, 0x41, 0xe1, + 0x05, 0xe1, 0x01, 0x42, 0x37, 0x00, 0x0c, 0xe1, 0x01, 0x42, 0x1b, 0x02, + 0x07, 0xe1, 0x01, 0xb0, 0x24, 0x42, 0x11, 0x15, 0x19, 0xe1, 0x01, 0x42, + 0x71, 0x00, 0x11, 0xe1, 0x01, 0xb4, 0x06, 0x42, 0xdf, 0x23, 0x10, 0xe1, + 0x41, 0xe1, 0x02, 0xe1, 0x01, 0x42, 0x40, 0x06, 0x0d, 0xe1, 0x01, 0x42, + 0x5b, 0x28, 0x13, 0xe1, 0x41, 0xe1, 0x1c, 0xe1, 0x01, 0x42, 0x74, 0x00, + 0x1e, 0xe1, 0x41, 0xe1, 0x00, 0xe1, 0x01, 0x42, 0x74, 0x00, 0x20, 0xe1, + 0x41, 0xe8, 0x1f, 0xe1, 0x41, 0xe5, 0x2b, 0xe1, 0x41, 0xe1, 0x0f, 0xe1, + 0x01, 0x42, 0x74, 0x00, 0x1d, 0xe1, 0x41, 0xe1, 0x25, 0xe1, 0x41, 0x45, + 0x7e, 0x0b, 0x48, 0xe1, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x49, 0xe1, + 0x01, 0x43, 0x7a, 0x0b, 0x41, 0xe1, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, + 0x80, 0x1f, 0x40, 0xe1, 0x41, 0x44, 0x25, 0x01, 0x43, 0xe1, 0x01, 0x42, + 0x15, 0x02, 0x42, 0xe1, 0x41, 0x44, 0x06, 0x1f, 0x47, 0xe1, 0x01, 0x42, + 0x09, 0x24, 0x46, 0xe1, 0x41, 0x43, 0xf9, 0x05, 0x45, 0xe1, 0x01, 0x43, + 0xf6, 0x06, 0x44, 0xe1, 0x41, 0xec, 0x00, 0x00, 0x80, 0x7b, 0xad, 0x16, + 0x04, 0xc2, 0x51, 0x06, 0x4a, 0x30, 0xb7, 0x29, 0xf5, 0x41, 0x4a, 0x41, + 0x84, 0x06, 0xd8, 0x00, 0x4e, 0x7b, 0x21, 0xe1, 0x6f, 0x41, 0x04, 0xb7, + 0x05, 0x06, 0x48, 0x9e, 0xc7, 0x16, 0x21, 0x40, 0xa5, 0x4b, 0xa6, 0x3d, + 0x52, 0x21, 0x56, 0x9a, 0x24, 0x00, 0xb3, 0x20, 0xb4, 0x01, 0xff, 0x4c, + 0xf9, 0x53, 0x91, 0x24, 0x00, 0x51, 0x16, 0x5d, 0x94, 0x24, 0x00, 0x02, + 0x15, 0x01, 0x01, 0xff, 0x4d, 0x93, 0x89, 0x93, 0x24, 0x00, 0x4d, 0xd8, + 0x8a, 0x9b, 0x24, 0x40, 0x52, 0xf3, 0x53, 0x98, 0x24, 0x00, 0xa9, 0x01, + 0xff, 0x42, 0x5c, 0x03, 0x23, 0x00, 0x00, 0x4f, 0x2d, 0x78, 0x97, 0x24, + 0x40, 0x50, 0xaa, 0x66, 0x96, 0x24, 0x00, 0x51, 0x9c, 0x5f, 0x95, 0x24, + 0x40, 0x51, 0x7c, 0x5d, 0x99, 0x24, 0x00, 0x4f, 0xe7, 0x72, 0x92, 0x24, + 0x40, 0xec, 0x00, 0x00, 0x40, 0x80, 0xec, 0x04, 0x4c, 0x26, 0x4f, 0xa0, + 0x00, 0x00, 0x02, 0x7d, 0x02, 0xd5, 0x04, 0xae, 0xbe, 0x04, 0xf2, 0xbd, + 0x22, 0x80, 0xd8, 0x01, 0x42, 0x46, 0x03, 0x43, 0xf4, 0x81, 0xca, 0x01, + 0xb4, 0x01, 0xff, 0x80, 0x3e, 0x05, 0x97, 0x97, 0x20, 0xe5, 0xc8, 0xf5, + 0xc1, 0x00, 0x03, 0x9d, 0x0f, 0x0d, 0x44, 0x28, 0xf5, 0xd3, 0xf4, 0xc1, + 0x00, 0x56, 0x43, 0x34, 0xd4, 0xf4, 0x41, 0xe4, 0xca, 0xf5, 0x01, 0x42, + 0x00, 0x0a, 0xc9, 0xf5, 0x41, 0xac, 0x0c, 0x60, 0xc3, 0x10, 0x44, 0xf5, + 0x01, 0x6b, 0x98, 0x02, 0xb1, 0x27, 0x40, 0x5e, 0xc7, 0x13, 0x43, 0xf5, + 0x01, 0x6a, 0xc0, 0x03, 0xaf, 0x27, 0x40, 0xa1, 0x63, 0x4a, 0xf8, 0xad, + 0x7b, 0x23, 0x00, 0x03, 0x7b, 0x00, 0x4d, 0x4c, 0x87, 0x00, 0x6f, 0x22, + 0x00, 0x4c, 0x7c, 0x94, 0x62, 0x22, 0x00, 0x49, 0xec, 0x00, 0x6e, 0x22, + 0x00, 0x52, 0x45, 0x56, 0xea, 0x22, 0x80, 0x2e, 0x4b, 0x0e, 0x6e, 0x26, + 0x22, 0x00, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x72, 0x24, 0x41, 0x22, + 0x00, 0x43, 0x93, 0x3d, 0xad, 0x22, 0x40, 0x43, 0x5b, 0x03, 0xac, 0x00, + 0x00, 0x06, 0x2a, 0x26, 0x01, 0xff, 0x54, 0x43, 0x45, 0xe2, 0x22, 0x00, + 0x57, 0x7d, 0x31, 0xe3, 0x22, 0x40, 0x4c, 0x90, 0x2a, 0xec, 0x22, 0x40, + 0x45, 0x89, 0x0d, 0x60, 0x22, 0x00, 0x4a, 0x0e, 0x3c, 0x6d, 0x22, 0x40, + 0x03, 0x6e, 0x06, 0x12, 0x4e, 0xcf, 0x6d, 0x49, 0x22, 0x00, 0x4c, 0x1c, + 0x97, 0x09, 0x22, 0x00, 0x56, 0x6b, 0x39, 0x44, 0x22, 0x40, 0x47, 0x13, + 0x43, 0x84, 0x22, 0x00, 0x49, 0x21, 0x38, 0x85, 0x22, 0x40, 0x47, 0x15, + 0x08, 0xfc, 0xcc, 0x41, 0x4d, 0x12, 0x86, 0xbb, 0x20, 0x00, 0x4f, 0x48, + 0x56, 0xb2, 0x22, 0x80, 0xcc, 0x02, 0x02, 0x53, 0x00, 0x01, 0xff, 0x80, + 0x06, 0x56, 0xcf, 0x35, 0xea, 0xf6, 0x41, 0x05, 0xe4, 0x19, 0xcb, 0x01, + 0x06, 0xe9, 0x06, 0x7a, 0x05, 0x00, 0x0f, 0x01, 0xff, 0xa1, 0x3b, 0x4b, + 0xae, 0x9e, 0x09, 0x2b, 0x00, 0x4c, 0xd8, 0x92, 0xd6, 0x21, 0x00, 0x09, + 0x9c, 0x01, 0x19, 0x50, 0xfa, 0x69, 0x54, 0xf8, 0x01, 0x55, 0x01, 0x02, + 0x66, 0x2b, 0x80, 0x06, 0x4b, 0xf8, 0x10, 0x01, 0x2b, 0x40, 0x47, 0x9e, + 0x15, 0x76, 0x2b, 0x40, 0x43, 0x39, 0xd6, 0x60, 0xf6, 0x01, 0x44, 0xa7, + 0x53, 0x50, 0xf6, 0x01, 0x49, 0xe0, 0xc6, 0x58, 0xf6, 0x41, 0x53, 0x9c, + 0x42, 0x21, 0x29, 0x00, 0x44, 0xcf, 0x00, 0x96, 0x21, 0xc0, 0x00, 0x80, + 0x01, 0xff, 0x54, 0x73, 0x42, 0x27, 0x29, 0x00, 0x59, 0xda, 0x24, 0x32, + 0x29, 0x00, 0x48, 0xdf, 0xb9, 0xb8, 0xf8, 0x01, 0x03, 0x7a, 0x02, 0x06, + 0x49, 0x16, 0x26, 0x23, 0x29, 0x40, 0x46, 0x49, 0x1a, 0xf1, 0x21, 0x00, + 0x48, 0x8f, 0xcd, 0xb8, 0x21, 0x40, 0x09, 0x54, 0x2a, 0x1c, 0x50, 0xda, + 0x68, 0x37, 0xa8, 0x00, 0x03, 0x7c, 0x00, 0x06, 0x4a, 0x5e, 0xb6, 0x38, + 0xa8, 0x40, 0x4a, 0xfc, 0xb3, 0x39, 0xa8, 0x00, 0x49, 0xc4, 0xc4, 0x36, + 0xa8, 0x40, 0x04, 0x7a, 0x0b, 0x11, 0x06, 0x24, 0x01, 0x01, 0xff, 0x48, + 0x2a, 0x01, 0x32, 0xa8, 0x00, 0x4a, 0xb8, 0xb6, 0x35, 0xa8, 0x40, 0x46, + 0x7e, 0x0b, 0x34, 0xa8, 0x00, 0x44, 0x22, 0x00, 0x31, 0xa8, 0x00, 0x47, + 0x2a, 0x01, 0x30, 0xa8, 0x00, 0x49, 0x6e, 0x27, 0x33, 0xa8, 0x40, 0xa1, + 0x3b, 0x4b, 0xae, 0x9e, 0x08, 0x2b, 0x00, 0x4c, 0xd8, 0x92, 0xd7, 0x21, + 0x00, 0x09, 0x9c, 0x01, 0x19, 0x50, 0xfa, 0x69, 0x55, 0xf8, 0x01, 0x55, + 0x01, 0x02, 0x67, 0x2b, 0x80, 0x06, 0x4b, 0xf8, 0x10, 0x00, 0x2b, 0x40, + 0x47, 0x9e, 0x15, 0x77, 0x2b, 0x40, 0x43, 0x39, 0xd6, 0x62, 0xf6, 0x01, + 0x44, 0xa7, 0x53, 0x52, 0xf6, 0x01, 0x49, 0xe0, 0xc6, 0x5a, 0xf6, 0x41, + 0x53, 0xb0, 0x42, 0x22, 0x29, 0x00, 0x44, 0xcf, 0x00, 0x97, 0x21, 0xc0, + 0x00, 0x80, 0x01, 0xff, 0x54, 0x9b, 0x42, 0x28, 0x29, 0x00, 0x09, 0x8e, + 0x08, 0x0c, 0x48, 0xdf, 0xb9, 0xb9, 0xf8, 0x01, 0x49, 0x16, 0x26, 0x24, + 0x29, 0x40, 0x50, 0x8b, 0x42, 0x31, 0x29, 0x00, 0x50, 0x9f, 0x42, 0x2e, + 0x29, 0x40, 0x4c, 0x90, 0x2a, 0xb4, 0x22, 0x40, 0x8d, 0x06, 0x47, 0xff, + 0xd6, 0xdd, 0x2a, 0x40, 0x4f, 0xaf, 0x6e, 0x11, 0x20, 0x00, 0x54, 0x4b, + 0x47, 0xb1, 0xf6, 0x41, 0x50, 0x2a, 0x68, 0x6f, 0x20, 0x00, 0x48, 0xc7, + 0xd0, 0x8e, 0x01, 0x41, 0xa2, 0x2d, 0x45, 0x65, 0x5d, 0xd4, 0x26, 0x80, + 0x20, 0x4d, 0x63, 0x8a, 0xf5, 0xf4, 0x01, 0x59, 0xb5, 0x26, 0x1e, 0xf5, + 0x01, 0xb0, 0x06, 0x4e, 0x3c, 0x80, 0xad, 0xf6, 0x41, 0x4a, 0x06, 0xaf, + 0xb7, 0xf6, 0x01, 0x45, 0x87, 0xed, 0x72, 0xf5, 0x41, 0x45, 0x59, 0x03, + 0xab, 0xf6, 0x41, 0x47, 0xae, 0xd7, 0xb3, 0xf6, 0x01, 0x49, 0x58, 0xc4, + 0x83, 0x00, 0x40, 0x03, 0x13, 0x05, 0xca, 0x02, 0xa4, 0xf5, 0x01, 0x50, + 0xad, 0x00, 0xf9, 0x07, 0x00, 0x54, 0x07, 0x45, 0xf4, 0x07, 0x00, 0xac, + 0x16, 0x07, 0x2d, 0x17, 0x06, 0x4a, 0x44, 0xb7, 0xff, 0x07, 0x40, 0x4a, + 0x32, 0xb0, 0xf7, 0x07, 0x00, 0x49, 0x14, 0xc3, 0xf6, 0x07, 0x40, 0x49, + 0x61, 0xbb, 0xfa, 0x07, 0x00, 0x06, 0x14, 0x06, 0x06, 0x52, 0xc3, 0x56, + 0xf5, 0x07, 0x40, 0xe1, 0xca, 0x07, 0x00, 0x42, 0x16, 0x00, 0xd3, 0x07, + 0x00, 0x43, 0xd0, 0x18, 0xd7, 0x07, 0x00, 0x42, 0x7b, 0x08, 0xd8, 0x07, + 0x80, 0xa3, 0x01, 0xe5, 0xcd, 0x07, 0x80, 0x99, 0x01, 0x42, 0x0c, 0x08, + 0xdd, 0x07, 0x00, 0x43, 0x32, 0xb0, 0xdc, 0x07, 0x00, 0x42, 0x22, 0x00, + 0xe4, 0x07, 0x00, 0xe9, 0xcc, 0x07, 0x00, 0xaa, 0x66, 0x42, 0x1b, 0x02, + 0xde, 0x07, 0x00, 0x42, 0x74, 0x00, 0xdf, 0x07, 0x00, 0x42, 0x6c, 0x00, + 0xe1, 0x07, 0x00, 0xee, 0xd2, 0x07, 0x80, 0x37, 0xef, 0xd0, 0x07, 0x80, + 0x2e, 0x42, 0xe0, 0x09, 0xd4, 0x07, 0x00, 0xb2, 0x1c, 0x42, 0x40, 0x06, + 0xdb, 0x07, 0x00, 0x42, 0x12, 0x00, 0xd5, 0x07, 0x00, 0xf5, 0xce, 0x07, + 0x00, 0x42, 0xa9, 0x01, 0xe5, 0x07, 0x00, 0x42, 0xdf, 0x23, 0xe6, 0x07, + 0x40, 0xe1, 0xd9, 0x07, 0x00, 0x42, 0x71, 0x00, 0xda, 0x07, 0x40, 0xef, + 0xcf, 0x07, 0x40, 0xe1, 0xe3, 0x07, 0x80, 0x0d, 0x42, 0xdf, 0x23, 0xe2, + 0x07, 0xc0, 0x00, 0x47, 0x71, 0xd3, 0xe7, 0x07, 0x40, 0x47, 0x71, 0xd3, + 0xe0, 0x07, 0x40, 0xe1, 0xd6, 0x07, 0x00, 0x04, 0xc4, 0xf7, 0x01, 0xff, + 0x43, 0xd0, 0x18, 0xe9, 0x07, 0x00, 0x42, 0x78, 0x1a, 0xe8, 0x07, 0x00, + 0x42, 0x71, 0x00, 0xea, 0x07, 0x40, 0xe5, 0xcb, 0x07, 0x40, 0x48, 0x07, + 0xcc, 0xd1, 0x07, 0x40, 0x49, 0xb2, 0xbb, 0xfd, 0x07, 0x00, 0x05, 0xf0, + 0x06, 0x06, 0x4a, 0x9c, 0xb4, 0xfe, 0x07, 0x40, 0x45, 0x7e, 0x0b, 0xc8, + 0x07, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xc9, 0x07, 0x00, 0x43, 0x7a, + 0x0b, 0xc1, 0x07, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xc0, + 0x07, 0x40, 0x44, 0x25, 0x01, 0xc3, 0x07, 0x00, 0x42, 0x15, 0x02, 0xc2, + 0x07, 0x40, 0x44, 0x06, 0x1f, 0xc7, 0x07, 0x00, 0x42, 0x09, 0x24, 0xc6, + 0x07, 0x40, 0x43, 0xf9, 0x05, 0xc5, 0x07, 0x00, 0x43, 0xf6, 0x06, 0xc4, + 0x07, 0x40, 0x07, 0x03, 0x17, 0x06, 0x42, 0x6c, 0x00, 0xf8, 0x07, 0x40, + 0x50, 0xea, 0x64, 0xf3, 0x07, 0x00, 0x05, 0xd7, 0x02, 0x1d, 0x51, 0xf2, + 0x5e, 0xf2, 0x07, 0x00, 0x06, 0x33, 0x07, 0x01, 0xff, 0x49, 0x07, 0x45, + 0xeb, 0x07, 0x00, 0x48, 0xa5, 0xba, 0xec, 0x07, 0x00, 0x4b, 0xda, 0x69, + 0xed, 0x07, 0x40, 0x4f, 0x18, 0x6f, 0xee, 0x07, 0x00, 0x49, 0x07, 0x45, + 0xef, 0x07, 0x00, 0x48, 0xa5, 0xba, 0xf0, 0x07, 0x00, 0x4b, 0xda, 0x69, + 0xf1, 0x07, 0x40, 0x4e, 0xa4, 0x7b, 0x03, 0xf3, 0x01, 0xae, 0x01, 0xff, + 0x54, 0x17, 0x44, 0xd9, 0xf7, 0x01, 0x42, 0x78, 0x1a, 0x77, 0xf9, 0x41, + 0x45, 0x48, 0xeb, 0x54, 0xf4, 0x01, 0x03, 0xf6, 0x05, 0xb3, 0x0c, 0x06, + 0x1e, 0xe3, 0xe1, 0x0b, 0xec, 0x85, 0x00, 0x00, 0x45, 0x02, 0xf0, 0x46, + 0x26, 0x80, 0xcf, 0x0b, 0x47, 0x20, 0xdb, 0x13, 0xf9, 0x01, 0xb3, 0xb1, + 0x0b, 0x4d, 0xa3, 0x8d, 0x8d, 0xfa, 0x01, 0x02, 0x29, 0x08, 0xa5, 0x09, + 0xb7, 0x11, 0x03, 0xa3, 0x65, 0x01, 0xff, 0x44, 0xef, 0x05, 0x85, 0x00, + 0x00, 0x44, 0xc4, 0xab, 0x98, 0x23, 0x40, 0x80, 0xfa, 0x04, 0x02, 0x5a, + 0x00, 0x16, 0x05, 0xed, 0x07, 0x06, 0x46, 0x24, 0x7a, 0xf0, 0xf4, 0x41, 0x44, 0xc3, 0x00, 0x92, 0x2b, 0x00, 0x45, 0xc8, 0x00, 0x93, 0x2b, 0x40, - 0x51, 0xe3, 0x57, 0x4f, 0x14, 0x01, 0x45, 0x13, 0x05, 0x4d, 0x14, 0x01, - 0xa4, 0xf4, 0x03, 0x4a, 0x5a, 0x9c, 0x4e, 0x14, 0x01, 0x4e, 0xb0, 0x78, - 0x5d, 0x14, 0x01, 0x07, 0xec, 0x05, 0xa3, 0x01, 0x42, 0x14, 0x05, 0x49, - 0x14, 0x01, 0x50, 0xcd, 0x65, 0x5b, 0x14, 0x01, 0xb3, 0x44, 0x0b, 0x55, - 0x77, 0x01, 0xff, 0xa1, 0x31, 0xe5, 0x3e, 0x14, 0x01, 0xe9, 0x36, 0x14, + 0x51, 0x5d, 0x5a, 0x4f, 0x14, 0x01, 0x45, 0x13, 0x05, 0x4d, 0x14, 0x01, + 0xa4, 0xf4, 0x03, 0x4a, 0x63, 0xa1, 0x4e, 0x14, 0x01, 0x4e, 0x30, 0x7c, + 0x5d, 0x14, 0x01, 0x07, 0x13, 0x06, 0xa3, 0x01, 0x42, 0x14, 0x05, 0x49, + 0x14, 0x01, 0x50, 0xda, 0x68, 0x5b, 0x14, 0x01, 0xb3, 0x44, 0x0b, 0xc7, + 0x7a, 0x01, 0xff, 0xa1, 0x31, 0xe5, 0x3e, 0x14, 0x01, 0xe9, 0x36, 0x14, 0x81, 0x24, 0xef, 0x40, 0x14, 0x01, 0xf5, 0x38, 0x14, 0x81, 0x17, 0x08, - 0x43, 0xc1, 0x01, 0xff, 0xec, 0x3c, 0x14, 0x81, 0x09, 0xf2, 0x3a, 0x14, + 0xf2, 0xc6, 0x01, 0xff, 0xec, 0x3c, 0x14, 0x81, 0x09, 0xf2, 0x3a, 0x14, 0xc1, 0x00, 0xf2, 0x3b, 0x14, 0x41, 0xec, 0x3d, 0x14, 0x41, 0xf5, 0x39, 0x14, 0x41, 0xe9, 0x37, 0x14, 0x41, 0xe1, 0x35, 0x14, 0x01, 0xe9, 0x3f, - 0x14, 0x01, 0xf5, 0x41, 0x14, 0x41, 0x4a, 0xde, 0xa7, 0x5e, 0x14, 0x01, - 0xa9, 0x01, 0xff, 0x44, 0xa1, 0xef, 0x4a, 0x14, 0x01, 0x03, 0x5c, 0x03, - 0x01, 0xff, 0xa1, 0x2f, 0x4b, 0xd9, 0x23, 0x43, 0x14, 0x01, 0x4e, 0xfa, - 0x77, 0x48, 0x14, 0x01, 0x4b, 0x07, 0x9e, 0x60, 0x14, 0x01, 0x45, 0x5a, - 0x3f, 0x46, 0x14, 0x01, 0x4b, 0x8f, 0xa4, 0x61, 0x14, 0x01, 0x02, 0x02, - 0x00, 0x01, 0xff, 0x44, 0xe7, 0x23, 0x42, 0x14, 0x01, 0x45, 0xf3, 0x4b, - 0x45, 0x14, 0x41, 0x47, 0x3d, 0x16, 0x44, 0x14, 0x01, 0x47, 0xc4, 0x88, + 0x14, 0x01, 0xf5, 0x41, 0x14, 0x41, 0x4a, 0x08, 0xad, 0x5e, 0x14, 0x01, + 0xa9, 0x01, 0xff, 0x44, 0x64, 0xf5, 0x4a, 0x14, 0x01, 0x03, 0x5c, 0x03, + 0x01, 0xff, 0xa1, 0x2f, 0x4b, 0x13, 0x25, 0x43, 0x14, 0x01, 0x4e, 0x7a, + 0x7b, 0x48, 0x14, 0x01, 0x4b, 0x10, 0xa3, 0x60, 0x14, 0x01, 0x45, 0x62, + 0x41, 0x46, 0x14, 0x01, 0x4b, 0xb9, 0xa9, 0x61, 0x14, 0x01, 0x02, 0x02, + 0x00, 0x01, 0xff, 0x44, 0x21, 0x25, 0x42, 0x14, 0x01, 0x45, 0x49, 0x4e, + 0x45, 0x14, 0x41, 0x47, 0x0b, 0x17, 0x44, 0x14, 0x01, 0x47, 0x34, 0x8d, 0x47, 0x14, 0x41, 0xe1, 0x00, 0x14, 0x81, 0xae, 0x02, 0xa2, 0xa1, 0x02, 0xa3, 0x94, 0x02, 0xa4, 0xfb, 0x01, 0xe5, 0x0a, 0x14, 0x01, 0xa7, 0xea, 0x01, 0x42, 0x22, 0x00, 0x34, 0x14, 0x01, 0xe9, 0x02, 0x14, 0x81, 0xda, 0x01, 0xaa, 0xcd, 0x01, 0xab, 0xc0, 0x01, 0xac, 0xb3, 0x01, 0xad, 0xa6, 0x01, 0xae, 0x7b, 0xef, 0x0c, 0x14, 0x01, 0xb0, 0x6b, 0xb2, 0x5f, 0xb3, 0x4d, 0xb4, 0x34, 0xf5, 0x04, 0x14, 0x81, 0x2b, 0xb6, 0x0c, 0x42, 0xa9, - 0x01, 0x30, 0x14, 0x01, 0x42, 0xbe, 0x22, 0x2b, 0x14, 0x41, 0x4d, 0x7f, - 0x82, 0x5f, 0x14, 0x01, 0x07, 0x44, 0xc1, 0x01, 0xff, 0xec, 0x08, 0x14, + 0x01, 0x30, 0x14, 0x01, 0x42, 0xdf, 0x23, 0x2b, 0x14, 0x41, 0x4d, 0x7a, + 0x86, 0x5f, 0x14, 0x01, 0x07, 0xf3, 0xc6, 0x01, 0xff, 0xec, 0x08, 0x14, 0x81, 0x09, 0xf2, 0x06, 0x14, 0xc1, 0x00, 0xf2, 0x07, 0x14, 0x41, 0xec, 0x09, 0x14, 0x41, 0xf5, 0x05, 0x14, 0x41, 0xe1, 0x1f, 0x14, 0x01, 0x42, 0x22, 0x00, 0x20, 0x14, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x1a, 0x14, 0x01, @@ -6790,97 +6827,97 @@ static const unsigned char uname2c_tree[222744] = { 0x1d, 0x14, 0x41, 0xe1, 0x14, 0x14, 0x01, 0x42, 0x22, 0x00, 0x15, 0x14, 0x41, 0xe1, 0x27, 0x14, 0x01, 0x42, 0x22, 0x00, 0x28, 0x14, 0x41, 0xe1, 0x01, 0x14, 0x01, 0xe9, 0x0b, 0x14, 0x01, 0xf5, 0x0d, 0x14, 0x41, 0x44, - 0x75, 0x20, 0x4b, 0x14, 0x01, 0x05, 0xf0, 0x06, 0x11, 0x06, 0x3c, 0x01, - 0x01, 0xff, 0x45, 0x13, 0x05, 0x5a, 0x14, 0x01, 0x45, 0x37, 0x96, 0x4c, - 0x14, 0x41, 0x45, 0x12, 0x0b, 0x58, 0x14, 0x01, 0xa6, 0x2e, 0x44, 0xea, - 0x2a, 0x59, 0x14, 0x01, 0x43, 0x0e, 0x0b, 0x51, 0x14, 0x01, 0xb3, 0x14, - 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x50, 0x14, 0x41, 0x44, 0x25, 0x01, 0x53, - 0x14, 0x01, 0x42, 0x15, 0x02, 0x52, 0x14, 0x41, 0x44, 0xe5, 0x1d, 0x57, - 0x14, 0x01, 0x42, 0x1c, 0x26, 0x56, 0x14, 0x41, 0x43, 0xd2, 0x05, 0x55, - 0x14, 0x01, 0x43, 0xf6, 0x06, 0x54, 0x14, 0x41, 0x44, 0xed, 0x07, 0x0a, - 0x00, 0x00, 0x05, 0xcb, 0x1b, 0xfe, 0x03, 0x4b, 0xb6, 0xa2, 0xaa, 0x20, - 0x00, 0x08, 0x79, 0xcb, 0x01, 0xff, 0x06, 0xef, 0x06, 0xac, 0x03, 0x07, - 0xec, 0x05, 0x74, 0x48, 0x11, 0xcb, 0xde, 0x19, 0x80, 0x69, 0xb4, 0x54, - 0x0b, 0x55, 0x77, 0x01, 0xff, 0xa1, 0x3c, 0xe5, 0xb5, 0x19, 0x00, 0xa9, + 0x96, 0x21, 0x4b, 0x14, 0x01, 0x05, 0xf0, 0x06, 0x11, 0x06, 0x3c, 0x01, + 0x01, 0xff, 0x45, 0x13, 0x05, 0x5a, 0x14, 0x01, 0x45, 0x13, 0x9b, 0x4c, + 0x14, 0x41, 0x45, 0x7e, 0x0b, 0x58, 0x14, 0x01, 0xa6, 0x2e, 0x44, 0x6d, + 0x2c, 0x59, 0x14, 0x01, 0x43, 0x7a, 0x0b, 0x51, 0x14, 0x01, 0xb3, 0x14, + 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x50, 0x14, 0x41, 0x44, 0x25, 0x01, 0x53, + 0x14, 0x01, 0x42, 0x15, 0x02, 0x52, 0x14, 0x41, 0x44, 0x06, 0x1f, 0x57, + 0x14, 0x01, 0x42, 0x09, 0x24, 0x56, 0x14, 0x41, 0x43, 0xf9, 0x05, 0x55, + 0x14, 0x01, 0x43, 0xf6, 0x06, 0x54, 0x14, 0x41, 0x44, 0xef, 0x05, 0x0a, + 0x00, 0x00, 0x05, 0xd1, 0x1c, 0xfe, 0x03, 0x4b, 0xca, 0xa7, 0xaa, 0x20, + 0x00, 0x08, 0x17, 0xd1, 0x01, 0xff, 0x06, 0xef, 0x06, 0xac, 0x03, 0x07, + 0x13, 0x06, 0x74, 0x48, 0xaf, 0xd0, 0xde, 0x19, 0x80, 0x69, 0xb4, 0x54, + 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xa1, 0x3c, 0xe5, 0xb5, 0x19, 0x00, 0xa9, 0x2e, 0xef, 0xb7, 0x19, 0x80, 0x1c, 0xf5, 0xb3, 0x19, 0x80, 0x06, 0x4f, - 0xa7, 0x74, 0xb0, 0x19, 0x40, 0xe5, 0xb9, 0x19, 0x80, 0x08, 0xf5, 0xb4, + 0xe2, 0x77, 0xb0, 0x19, 0x40, 0xe5, 0xb9, 0x19, 0x80, 0x08, 0xf5, 0xb4, 0x19, 0x00, 0xf9, 0xbc, 0x19, 0x40, 0xf9, 0xbf, 0x19, 0x40, 0xe1, 0xb8, 0x19, 0x80, 0x04, 0xf9, 0xbd, 0x19, 0x40, 0xf9, 0xbe, 0x19, 0x40, 0xe9, 0xb2, 0x19, 0x00, 0xf9, 0xc0, 0x19, 0x40, 0xe1, 0xb1, 0x19, 0x80, 0x08, 0xe5, 0xb6, 0x19, 0x00, 0xf9, 0xba, 0x19, 0x40, 0xf9, 0xbb, 0x19, 0x40, - 0x4d, 0xaa, 0x83, 0xda, 0x19, 0x00, 0x09, 0x41, 0xbd, 0x01, 0xff, 0xd1, + 0x4d, 0xa5, 0x87, 0xda, 0x19, 0x00, 0x09, 0xde, 0xc2, 0x01, 0xff, 0xd1, 0xc8, 0x19, 0x00, 0xd2, 0xc9, 0x19, 0x40, 0xf6, 0xdf, 0x19, 0x40, 0x06, - 0x10, 0x2d, 0x92, 0x02, 0x05, 0x48, 0x0b, 0x89, 0x01, 0x04, 0x08, 0x05, - 0x01, 0xff, 0x42, 0x16, 0x00, 0xa5, 0x19, 0x00, 0x42, 0xf0, 0x10, 0xa4, + 0x7c, 0x2e, 0x92, 0x02, 0x05, 0xb4, 0x0b, 0x89, 0x01, 0x04, 0x08, 0x05, + 0x01, 0xff, 0x42, 0x16, 0x00, 0xa5, 0x19, 0x00, 0x42, 0x7b, 0x08, 0xa4, 0x19, 0x00, 0x42, 0x0c, 0x08, 0x9d, 0x19, 0x00, 0x42, 0x22, 0x00, 0xa3, 0x19, 0x00, 0xab, 0x60, 0x42, 0x74, 0x00, 0x9f, 0x19, 0x00, 0x42, 0x6c, - 0x00, 0x99, 0x19, 0x00, 0xae, 0x48, 0xb0, 0x3c, 0x42, 0x43, 0x14, 0x81, - 0x19, 0x00, 0xb3, 0x2a, 0xb4, 0x18, 0x42, 0xf5, 0x0a, 0x9e, 0x19, 0x00, - 0xb8, 0x06, 0x42, 0xbe, 0x22, 0x8d, 0x19, 0x40, 0xe1, 0x86, 0x19, 0x00, - 0x42, 0xf5, 0x0a, 0xa9, 0x19, 0x40, 0xe1, 0x91, 0x19, 0x00, 0x42, 0x22, + 0x00, 0x99, 0x19, 0x00, 0xae, 0x48, 0xb0, 0x3c, 0x42, 0x11, 0x15, 0x81, + 0x19, 0x00, 0xb3, 0x2a, 0xb4, 0x18, 0x42, 0x61, 0x0b, 0x9e, 0x19, 0x00, + 0xb8, 0x06, 0x42, 0xdf, 0x23, 0x8d, 0x19, 0x40, 0xe1, 0x86, 0x19, 0x00, + 0x42, 0x61, 0x0b, 0xa9, 0x19, 0x40, 0xe1, 0x91, 0x19, 0x00, 0x42, 0x22, 0x00, 0x92, 0x19, 0x00, 0x42, 0x40, 0x06, 0x8b, 0x19, 0x40, 0xe1, 0x8c, 0x19, 0x00, 0x42, 0x7d, 0x00, 0xab, 0x19, 0x40, 0xe1, 0x97, 0x19, 0x00, 0x42, 0x22, 0x00, 0x98, 0x19, 0x40, 0xe1, 0x93, 0x19, 0x00, 0x42, 0x24, - 0x02, 0x87, 0x19, 0x40, 0xe1, 0x85, 0x19, 0x00, 0x42, 0xf5, 0x0a, 0xa8, - 0x19, 0x40, 0x42, 0x16, 0x00, 0xa2, 0x19, 0x00, 0x42, 0xf0, 0x10, 0xa1, + 0x02, 0x87, 0x19, 0x40, 0xe1, 0x85, 0x19, 0x00, 0x42, 0x61, 0x0b, 0xa8, + 0x19, 0x40, 0x42, 0x16, 0x00, 0xa2, 0x19, 0x00, 0x42, 0x7b, 0x08, 0xa1, 0x19, 0x00, 0x42, 0x0c, 0x08, 0x9a, 0x19, 0x00, 0x42, 0x22, 0x00, 0xa0, 0x19, 0x00, 0xab, 0x60, 0x42, 0x74, 0x00, 0x9c, 0x19, 0x00, 0x42, 0x6c, - 0x00, 0x96, 0x19, 0x00, 0xae, 0x48, 0xb0, 0x3c, 0x42, 0x43, 0x14, 0x80, - 0x19, 0x00, 0xb3, 0x2a, 0xb4, 0x18, 0x42, 0xf5, 0x0a, 0x9b, 0x19, 0x00, - 0xb8, 0x06, 0x42, 0xbe, 0x22, 0x8a, 0x19, 0x40, 0xe1, 0x83, 0x19, 0x00, - 0x42, 0xf5, 0x0a, 0xa7, 0x19, 0x40, 0xe1, 0x8e, 0x19, 0x00, 0x42, 0x22, + 0x00, 0x96, 0x19, 0x00, 0xae, 0x48, 0xb0, 0x3c, 0x42, 0x11, 0x15, 0x80, + 0x19, 0x00, 0xb3, 0x2a, 0xb4, 0x18, 0x42, 0x61, 0x0b, 0x9b, 0x19, 0x00, + 0xb8, 0x06, 0x42, 0xdf, 0x23, 0x8a, 0x19, 0x40, 0xe1, 0x83, 0x19, 0x00, + 0x42, 0x61, 0x0b, 0xa7, 0x19, 0x40, 0xe1, 0x8e, 0x19, 0x00, 0x42, 0x22, 0x00, 0x8f, 0x19, 0x00, 0x42, 0x40, 0x06, 0x88, 0x19, 0x40, 0xe1, 0x89, 0x19, 0x00, 0x42, 0x7d, 0x00, 0xaa, 0x19, 0x40, 0xe1, 0x94, 0x19, 0x00, 0x42, 0x22, 0x00, 0x95, 0x19, 0x40, 0xe1, 0x90, 0x19, 0x00, 0x42, 0x24, - 0x02, 0x84, 0x19, 0x40, 0xe1, 0x82, 0x19, 0x00, 0x42, 0xf5, 0x0a, 0xa6, + 0x02, 0x84, 0x19, 0x40, 0xe1, 0x82, 0x19, 0x00, 0x42, 0x61, 0x0b, 0xa6, 0x19, 0x40, 0xe2, 0xc7, 0x19, 0x00, 0xe4, 0xc6, 0x19, 0x00, 0xeb, 0xc5, 0x19, 0x00, 0xed, 0xc4, 0x19, 0x00, 0xee, 0xc3, 0x19, 0x80, 0x04, 0xf6, - 0xc1, 0x19, 0x40, 0xe7, 0xc2, 0x19, 0x40, 0x45, 0x12, 0x0b, 0xd8, 0x19, - 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0xd9, 0x19, 0x00, 0x43, 0x0e, 0x0b, - 0xd1, 0x19, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xd0, 0x19, + 0xc1, 0x19, 0x40, 0xe7, 0xc2, 0x19, 0x40, 0x45, 0x7e, 0x0b, 0xd8, 0x19, + 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xd9, 0x19, 0x00, 0x43, 0x7a, 0x0b, + 0xd1, 0x19, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xd0, 0x19, 0x40, 0x44, 0x25, 0x01, 0xd3, 0x19, 0x00, 0x42, 0x15, 0x02, 0xd2, 0x19, - 0x40, 0x44, 0xe5, 0x1d, 0xd7, 0x19, 0x00, 0x42, 0x1c, 0x26, 0xd6, 0x19, - 0x40, 0x43, 0xd2, 0x05, 0xd5, 0x19, 0x00, 0x43, 0xf6, 0x06, 0xd4, 0x19, - 0x40, 0x46, 0x16, 0x08, 0x11, 0xf3, 0x01, 0x49, 0x70, 0xc1, 0x1a, 0xf3, + 0x40, 0x44, 0x06, 0x1f, 0xd7, 0x19, 0x00, 0x42, 0x09, 0x24, 0xd6, 0x19, + 0x40, 0x43, 0xf9, 0x05, 0xd5, 0x19, 0x00, 0x43, 0xf6, 0x06, 0xd4, 0x19, + 0x40, 0x46, 0x16, 0x08, 0x11, 0xf3, 0x01, 0x49, 0x1f, 0xc7, 0x1a, 0xf3, 0x41, 0x42, 0x33, 0x00, 0xb2, 0x26, 0x00, 0x04, 0xdd, 0x01, 0x01, 0xff, - 0x06, 0xa8, 0xda, 0x06, 0x44, 0x0c, 0x08, 0x10, 0xf6, 0x41, 0x46, 0x4e, - 0xda, 0x03, 0xfa, 0x81, 0xd3, 0x01, 0x4a, 0x36, 0xaa, 0x4a, 0xfa, 0x81, - 0xc5, 0x01, 0xab, 0x73, 0x44, 0x21, 0xf2, 0x05, 0xfa, 0x81, 0x5b, 0x45, - 0x73, 0xbe, 0x01, 0xfa, 0x81, 0x43, 0x44, 0x81, 0xf2, 0x02, 0xfa, 0x81, - 0x2b, 0x07, 0x27, 0x0a, 0x01, 0xff, 0x46, 0x4e, 0xda, 0x2d, 0xfa, 0x01, - 0xab, 0x12, 0x44, 0x21, 0xf2, 0x2f, 0xfa, 0x01, 0x45, 0x73, 0xbe, 0x2b, - 0xfa, 0x01, 0x44, 0x81, 0xf2, 0x2c, 0xfa, 0x41, 0x43, 0xa1, 0x01, 0x2a, - 0xfa, 0x01, 0x45, 0x4e, 0x09, 0x2e, 0xfa, 0x41, 0x09, 0xbe, 0x2c, 0x01, - 0xff, 0x4e, 0xc7, 0x2c, 0x17, 0xfa, 0x01, 0x5b, 0xd8, 0x1d, 0x41, 0xfa, - 0x41, 0x09, 0xbe, 0x2c, 0x01, 0xff, 0x4e, 0xc7, 0x2c, 0x16, 0xfa, 0x01, - 0x5b, 0xd8, 0x1d, 0x40, 0xfa, 0x41, 0x09, 0xbe, 0x2c, 0x01, 0xff, 0x4e, - 0xc7, 0x2c, 0x1a, 0xfa, 0x01, 0x5b, 0xd8, 0x1d, 0x44, 0xfa, 0x41, 0x43, - 0xa1, 0x01, 0x00, 0xfa, 0x81, 0x38, 0x45, 0x4e, 0x09, 0x04, 0xfa, 0xc1, - 0x00, 0x09, 0xbe, 0x2c, 0x01, 0xff, 0x52, 0xd4, 0x51, 0x08, 0xfa, 0x01, - 0x4e, 0xc7, 0x2c, 0x19, 0xfa, 0x01, 0x5f, 0x6d, 0x11, 0x1d, 0xfa, 0x01, - 0xb4, 0x01, 0xff, 0x5c, 0x16, 0x18, 0x47, 0xfa, 0x01, 0x0b, 0xd9, 0x1d, - 0x01, 0xff, 0x4f, 0xe4, 0x1d, 0x43, 0xfa, 0x01, 0x53, 0xf9, 0x4d, 0x32, - 0xfa, 0x41, 0x09, 0xbe, 0x2c, 0x01, 0xff, 0x4e, 0xc7, 0x2c, 0x15, 0xfa, - 0x01, 0x5b, 0xd8, 0x1d, 0x3f, 0xfa, 0x41, 0x57, 0xbe, 0x2c, 0x4d, 0xfa, - 0x41, 0x09, 0xbe, 0x2c, 0x01, 0xff, 0x4e, 0xc7, 0x2c, 0x18, 0xfa, 0x01, - 0x5b, 0xd8, 0x1d, 0x42, 0xfa, 0x41, 0x43, 0x24, 0xd7, 0xdc, 0x2b, 0x00, - 0xb4, 0x01, 0xff, 0x4a, 0x80, 0xa6, 0xba, 0xfa, 0x01, 0x49, 0x9e, 0xba, - 0x86, 0xfa, 0x41, 0x49, 0x3c, 0x2e, 0xc9, 0x2b, 0x40, 0xa1, 0x35, 0x11, - 0x58, 0x5a, 0x1b, 0x0e, 0x74, 0x79, 0x01, 0xff, 0x03, 0x7b, 0x00, 0x06, - 0x4c, 0x87, 0x00, 0x78, 0x22, 0x40, 0x45, 0xfb, 0x0c, 0x70, 0x22, 0x00, - 0x4a, 0xf1, 0x39, 0x74, 0x22, 0x40, 0x03, 0x7b, 0x00, 0x06, 0x49, 0xec, - 0x00, 0x79, 0x22, 0x40, 0x45, 0xfb, 0x0c, 0x71, 0x22, 0x00, 0x4a, 0xf1, - 0x39, 0x75, 0x22, 0x40, 0x03, 0x6e, 0x06, 0x06, 0x62, 0xde, 0x0c, 0x47, - 0x22, 0x40, 0x54, 0xf7, 0x40, 0x88, 0x22, 0x00, 0x56, 0x44, 0x36, 0x89, - 0x22, 0x40, 0x6d, 0x38, 0x01, 0xaf, 0x22, 0x00, 0x04, 0xd2, 0x05, 0x01, - 0xff, 0x4b, 0xed, 0x51, 0x15, 0x00, 0x00, 0x08, 0xf7, 0x22, 0xcc, 0x01, - 0x09, 0xfe, 0x25, 0xb5, 0x01, 0x08, 0xd6, 0x05, 0x01, 0xff, 0x42, 0x5c, - 0x00, 0x8e, 0xf1, 0x01, 0x4a, 0x0a, 0xa9, 0x4e, 0x27, 0x00, 0x4f, 0x34, + 0x06, 0x72, 0xe0, 0x06, 0x44, 0x0c, 0x08, 0x10, 0xf6, 0x41, 0x46, 0x1e, + 0xe0, 0x03, 0xfa, 0x81, 0xd3, 0x01, 0x4a, 0x74, 0xaf, 0x4a, 0xfa, 0x81, + 0xc5, 0x01, 0xab, 0x73, 0x44, 0xf4, 0xf7, 0x05, 0xfa, 0x81, 0x5b, 0x45, + 0x19, 0xc4, 0x01, 0xfa, 0x81, 0x43, 0x44, 0x58, 0xf8, 0x02, 0xfa, 0x81, + 0x2b, 0x07, 0x70, 0x0a, 0x01, 0xff, 0x46, 0x1e, 0xe0, 0x2d, 0xfa, 0x01, + 0xab, 0x12, 0x44, 0xf4, 0xf7, 0x2f, 0xfa, 0x01, 0x45, 0x19, 0xc4, 0x2b, + 0xfa, 0x01, 0x44, 0x58, 0xf8, 0x2c, 0xfa, 0x41, 0x43, 0xa1, 0x01, 0x2a, + 0xfa, 0x01, 0x45, 0x73, 0x09, 0x2e, 0xfa, 0x41, 0x09, 0x2a, 0x2e, 0x01, + 0xff, 0x4e, 0x33, 0x2e, 0x17, 0xfa, 0x01, 0x5b, 0xf9, 0x1e, 0x41, 0xfa, + 0x41, 0x09, 0x2a, 0x2e, 0x01, 0xff, 0x4e, 0x33, 0x2e, 0x16, 0xfa, 0x01, + 0x5b, 0xf9, 0x1e, 0x40, 0xfa, 0x41, 0x09, 0x2a, 0x2e, 0x01, 0xff, 0x4e, + 0x33, 0x2e, 0x1a, 0xfa, 0x01, 0x5b, 0xf9, 0x1e, 0x44, 0xfa, 0x41, 0x43, + 0xa1, 0x01, 0x00, 0xfa, 0x81, 0x38, 0x45, 0x73, 0x09, 0x04, 0xfa, 0xc1, + 0x00, 0x09, 0x2a, 0x2e, 0x01, 0xff, 0x52, 0x3b, 0x54, 0x08, 0xfa, 0x01, + 0x4e, 0x33, 0x2e, 0x19, 0xfa, 0x01, 0x5f, 0x3b, 0x12, 0x1d, 0xfa, 0x01, + 0xb4, 0x01, 0xff, 0x5c, 0x00, 0x19, 0x47, 0xfa, 0x01, 0x0b, 0xfa, 0x1e, + 0x01, 0xff, 0x4f, 0x05, 0x1f, 0x43, 0xfa, 0x01, 0x53, 0x4f, 0x50, 0x32, + 0xfa, 0x41, 0x09, 0x2a, 0x2e, 0x01, 0xff, 0x4e, 0x33, 0x2e, 0x15, 0xfa, + 0x01, 0x5b, 0xf9, 0x1e, 0x3f, 0xfa, 0x41, 0x57, 0x2a, 0x2e, 0x4d, 0xfa, + 0x41, 0x09, 0x2a, 0x2e, 0x01, 0xff, 0x4e, 0x33, 0x2e, 0x18, 0xfa, 0x01, + 0x5b, 0xf9, 0x1e, 0x42, 0xfa, 0x41, 0x43, 0xf4, 0xdc, 0xdc, 0x2b, 0x00, + 0xb4, 0x01, 0xff, 0x4a, 0xaa, 0xab, 0xba, 0xfa, 0x01, 0x49, 0x20, 0xc0, + 0x86, 0xfa, 0x41, 0x49, 0xa8, 0x2f, 0xc9, 0x2b, 0x40, 0xa1, 0x35, 0x11, + 0xd2, 0x5c, 0x1b, 0x0e, 0x02, 0x7d, 0x01, 0xff, 0x03, 0x7b, 0x00, 0x06, + 0x4c, 0x87, 0x00, 0x78, 0x22, 0x40, 0x45, 0x89, 0x0d, 0x70, 0x22, 0x00, + 0x4a, 0x0e, 0x3c, 0x74, 0x22, 0x40, 0x03, 0x7b, 0x00, 0x06, 0x49, 0xec, + 0x00, 0x79, 0x22, 0x40, 0x45, 0x89, 0x0d, 0x71, 0x22, 0x00, 0x4a, 0x0e, + 0x3c, 0x75, 0x22, 0x40, 0x03, 0x6e, 0x06, 0x06, 0x62, 0x6c, 0x0d, 0x47, + 0x22, 0x40, 0x54, 0x13, 0x43, 0x88, 0x22, 0x00, 0x56, 0x21, 0x38, 0x89, + 0x22, 0x40, 0x6d, 0x38, 0x01, 0xaf, 0x22, 0x00, 0x04, 0xf9, 0x05, 0x01, + 0xff, 0x4b, 0x54, 0x54, 0x15, 0x00, 0x00, 0x08, 0x31, 0x24, 0xcc, 0x01, + 0x09, 0x51, 0x27, 0xb5, 0x01, 0x08, 0xfd, 0x05, 0x01, 0xff, 0x42, 0x5c, + 0x00, 0x8e, 0xf1, 0x01, 0x4a, 0x48, 0xae, 0x4e, 0x27, 0x00, 0x4f, 0xa0, 0x0c, 0xb7, 0xf8, 0x01, 0x42, 0x36, 0x00, 0x8b, 0xf1, 0x01, 0xac, 0x24, - 0x42, 0xbb, 0x09, 0x8c, 0xf1, 0x01, 0x4d, 0xc1, 0x34, 0xc4, 0xfb, 0x01, + 0x42, 0xe0, 0x09, 0x8c, 0xf1, 0x01, 0x4d, 0x88, 0x36, 0xc4, 0xfb, 0x01, 0x50, 0xb3, 0x02, 0xb6, 0xf8, 0x01, 0x42, 0x40, 0x06, 0x8d, 0xf1, 0x01, - 0x4d, 0xc3, 0x20, 0xb5, 0xf8, 0x01, 0x42, 0xe3, 0x1a, 0x8f, 0xf1, 0x41, - 0x14, 0xdf, 0x05, 0x06, 0x4e, 0x6a, 0x1a, 0xb4, 0xf8, 0x41, 0xe1, 0x70, + 0x4d, 0xe4, 0x21, 0xb5, 0xf8, 0x01, 0x42, 0xe9, 0x1b, 0x8f, 0xf1, 0x41, + 0x14, 0x06, 0x06, 0x06, 0x4e, 0x70, 0x1b, 0xb4, 0xf8, 0x41, 0xe1, 0x70, 0xf1, 0x01, 0xe2, 0x71, 0xf1, 0x01, 0xe3, 0x72, 0xf1, 0x01, 0xe4, 0x73, 0xf1, 0x01, 0xe5, 0x74, 0xf1, 0x01, 0xe6, 0x75, 0xf1, 0x01, 0xe7, 0x76, 0xf1, 0x01, 0xe8, 0x77, 0xf1, 0x01, 0xe9, 0x78, 0xf1, 0x01, 0xea, 0x79, @@ -6889,17 +6926,17 @@ static const unsigned char uname2c_tree[222744] = { 0xf1, 0x01, 0xf1, 0x80, 0xf1, 0x01, 0xf2, 0x81, 0xf1, 0x01, 0xf3, 0x82, 0xf1, 0x01, 0xf4, 0x83, 0xf1, 0x01, 0xf5, 0x84, 0xf1, 0x01, 0xf6, 0x85, 0xf1, 0x01, 0xf7, 0x86, 0xf1, 0x01, 0xf8, 0x87, 0xf1, 0x01, 0xf9, 0x88, - 0xf1, 0x01, 0xfa, 0x89, 0xf1, 0x41, 0x45, 0x95, 0x10, 0xbd, 0xfb, 0x01, - 0x47, 0x9c, 0x44, 0xbf, 0xfb, 0x01, 0x5c, 0x58, 0x0f, 0xbe, 0xfb, 0x41, - 0x4a, 0x6e, 0xa9, 0xff, 0x24, 0x00, 0x15, 0xde, 0x05, 0x5a, 0x07, 0x1a, - 0x3a, 0x0c, 0x46, 0xd6, 0x05, 0xd8, 0xf7, 0x01, 0x48, 0x01, 0x02, 0xd6, - 0xf7, 0x41, 0xa5, 0x3c, 0xa6, 0x2e, 0x48, 0xcc, 0x53, 0xf3, 0x24, 0x00, - 0xb3, 0x1a, 0xb4, 0x01, 0xff, 0x47, 0x9c, 0x5a, 0xed, 0x24, 0x00, 0x02, - 0x15, 0x01, 0x01, 0xff, 0x43, 0x03, 0x2c, 0xec, 0x24, 0x00, 0x43, 0xe8, - 0x1d, 0xf4, 0x24, 0x40, 0x48, 0x8c, 0x51, 0xf1, 0x24, 0x00, 0x46, 0x1c, - 0x26, 0xf0, 0x24, 0x40, 0x46, 0x24, 0x18, 0xef, 0x24, 0x00, 0x47, 0x11, - 0x5d, 0xee, 0x24, 0x40, 0x47, 0x6d, 0x25, 0xf2, 0x24, 0x00, 0x45, 0xbb, - 0x6f, 0xeb, 0x24, 0x40, 0xe1, 0x50, 0xf1, 0x01, 0xe2, 0x51, 0xf1, 0x01, + 0xf1, 0x01, 0xfa, 0x89, 0xf1, 0x41, 0x45, 0x8e, 0x08, 0xbd, 0xfb, 0x01, + 0x47, 0xcc, 0x46, 0xbf, 0xfb, 0x01, 0x5c, 0x07, 0x10, 0xbe, 0xfb, 0x41, + 0x4a, 0xac, 0xae, 0xff, 0x24, 0x00, 0x15, 0x05, 0x06, 0x5a, 0x07, 0x37, + 0x3c, 0x0c, 0x46, 0xfd, 0x05, 0xd8, 0xf7, 0x01, 0x48, 0x01, 0x02, 0xd6, + 0xf7, 0x41, 0xa5, 0x3c, 0xa6, 0x2e, 0x48, 0x21, 0x56, 0xf3, 0x24, 0x00, + 0xb3, 0x1a, 0xb4, 0x01, 0xff, 0x47, 0x16, 0x5d, 0xed, 0x24, 0x00, 0x02, + 0x15, 0x01, 0x01, 0xff, 0x43, 0x86, 0x2d, 0xec, 0x24, 0x00, 0x43, 0xea, + 0x1e, 0xf4, 0x24, 0x40, 0x48, 0xf3, 0x53, 0xf1, 0x24, 0x00, 0x46, 0x6f, + 0x27, 0xf0, 0x24, 0x40, 0x46, 0x0e, 0x19, 0xef, 0x24, 0x00, 0x47, 0x9c, + 0x5f, 0xee, 0x24, 0x40, 0x47, 0xc0, 0x26, 0xf2, 0x24, 0x00, 0x45, 0xe7, + 0x72, 0xeb, 0x24, 0x40, 0xe1, 0x50, 0xf1, 0x01, 0xe2, 0x51, 0xf1, 0x01, 0xe3, 0x52, 0xf1, 0x01, 0xe4, 0x53, 0xf1, 0x01, 0xe5, 0x54, 0xf1, 0x01, 0xe6, 0x55, 0xf1, 0x01, 0xe7, 0x56, 0xf1, 0x01, 0xe8, 0x57, 0xf1, 0x01, 0xe9, 0x58, 0xf1, 0x01, 0xea, 0x59, 0xf1, 0x01, 0xeb, 0x5a, 0xf1, 0x01, @@ -6908,29 +6945,29 @@ static const unsigned char uname2c_tree[222744] = { 0xf2, 0x61, 0xf1, 0x01, 0xf3, 0x62, 0xf1, 0x01, 0xf4, 0x63, 0xf1, 0x01, 0xf5, 0x64, 0xf1, 0x01, 0xf6, 0x65, 0xf1, 0x01, 0xf7, 0x66, 0xf1, 0x01, 0xf8, 0x67, 0xf1, 0x01, 0xf9, 0x68, 0xf1, 0x01, 0xfa, 0x69, 0xf1, 0x41, - 0xe8, 0x83, 0x00, 0x00, 0x42, 0x2b, 0x0d, 0xa0, 0x00, 0x40, 0xa2, 0xb9, - 0x05, 0x0a, 0xae, 0xaa, 0xca, 0x03, 0xa9, 0xbb, 0x03, 0xeb, 0x15, 0x00, - 0x00, 0x48, 0x59, 0xc8, 0xdb, 0xf4, 0x01, 0x42, 0x1b, 0x00, 0xbc, 0x22, - 0x80, 0x22, 0x53, 0xc9, 0x4c, 0x2f, 0x20, 0x00, 0x07, 0xfa, 0x3a, 0x0c, - 0x4c, 0xb4, 0x96, 0x22, 0xf9, 0x01, 0x4a, 0x22, 0xb4, 0xff, 0xf9, 0x41, - 0x4c, 0x41, 0x65, 0x6e, 0x20, 0x00, 0x44, 0x00, 0xb5, 0xde, 0xf3, 0x41, - 0x08, 0x21, 0xc7, 0x01, 0xff, 0x4a, 0xc3, 0x60, 0xe3, 0x19, 0x01, 0x07, - 0xec, 0x05, 0x67, 0x05, 0x5a, 0x03, 0x3e, 0x0b, 0x55, 0x77, 0x01, 0xff, + 0xe8, 0x83, 0x00, 0x00, 0x42, 0xb9, 0x0d, 0xa0, 0x00, 0x40, 0xa2, 0xb9, + 0x05, 0x0a, 0x00, 0xb0, 0xca, 0x03, 0xa9, 0xbb, 0x03, 0xeb, 0x15, 0x00, + 0x00, 0x48, 0xdf, 0xcd, 0xdb, 0xf4, 0x01, 0x42, 0x1b, 0x00, 0xbc, 0x22, + 0x80, 0x22, 0x53, 0x1f, 0x4f, 0x2f, 0x20, 0x00, 0x07, 0x02, 0x3d, 0x0c, + 0x4c, 0x90, 0x9b, 0x22, 0xf9, 0x01, 0x4a, 0x9c, 0xb9, 0xff, 0xf9, 0x41, + 0x4c, 0x2e, 0x68, 0x6e, 0x20, 0x00, 0x44, 0x67, 0xba, 0xde, 0xf3, 0x41, + 0x08, 0xa7, 0xcc, 0x01, 0xff, 0x4a, 0x70, 0x63, 0xe3, 0x19, 0x01, 0x07, + 0x13, 0x06, 0x67, 0x05, 0x5a, 0x03, 0x3e, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xa1, 0x2b, 0xe5, 0xda, 0x19, 0x01, 0xe9, 0xd2, 0x19, 0x81, 0x1e, 0xef, - 0xdc, 0x19, 0x01, 0x4f, 0xf5, 0x71, 0xe4, 0x19, 0x01, 0xf5, 0xd4, 0x19, - 0x81, 0x0b, 0x49, 0x43, 0xc1, 0xd6, 0x19, 0xc1, 0x00, 0xf2, 0xd7, 0x19, + 0xdc, 0x19, 0x01, 0x4f, 0x30, 0x75, 0xe4, 0x19, 0x01, 0xf5, 0xd4, 0x19, + 0x81, 0x0b, 0x49, 0xf2, 0xc6, 0xd6, 0x19, 0xc1, 0x00, 0xf2, 0xd7, 0x19, 0x41, 0xf5, 0xd5, 0x19, 0x41, 0xe9, 0xd3, 0x19, 0x41, 0xe1, 0xd1, 0x19, 0x01, 0xe9, 0xdb, 0x19, 0x01, 0xf5, 0xdd, 0x19, 0x41, 0xa1, 0x17, 0x47, - 0xf8, 0xd5, 0xe2, 0x19, 0x01, 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0xe7, - 0x23, 0xe0, 0x19, 0x01, 0x45, 0xf3, 0x4b, 0xdf, 0x19, 0x41, 0x47, 0x3d, - 0x16, 0xde, 0x19, 0x01, 0x47, 0xc4, 0x88, 0xe1, 0x19, 0x41, 0xe1, 0xa0, + 0xc8, 0xdb, 0xe2, 0x19, 0x01, 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0x21, + 0x25, 0xe0, 0x19, 0x01, 0x45, 0x49, 0x4e, 0xdf, 0x19, 0x41, 0x47, 0x0b, + 0x17, 0xde, 0x19, 0x01, 0x47, 0x34, 0x8d, 0xe1, 0x19, 0x41, 0xe1, 0xa0, 0x19, 0x81, 0x80, 0x02, 0xa2, 0xf3, 0x01, 0xa3, 0xe6, 0x01, 0xa4, 0xcd, 0x01, 0xe5, 0xaa, 0x19, 0x01, 0xa7, 0xbc, 0x01, 0x42, 0x22, 0x00, 0xce, 0x19, 0x01, 0xe9, 0xa2, 0x19, 0x81, 0xac, 0x01, 0xaa, 0x9f, 0x01, 0xab, 0x92, 0x01, 0xac, 0x85, 0x01, 0x42, 0x6c, 0x00, 0xc6, 0x19, 0x01, 0xae, 0x67, 0xef, 0xac, 0x19, 0x01, 0xb0, 0x57, 0xb2, 0x4b, 0xb3, 0x39, 0xb4, - 0x20, 0xf5, 0xa4, 0x19, 0x81, 0x17, 0xb6, 0x06, 0x42, 0xbe, 0x22, 0xc7, - 0x19, 0x41, 0xe1, 0xca, 0x19, 0x01, 0x48, 0x44, 0xc1, 0xa6, 0x19, 0xc1, + 0x20, 0xf5, 0xa4, 0x19, 0x81, 0x17, 0xb6, 0x06, 0x42, 0xdf, 0x23, 0xc7, + 0x19, 0x41, 0xe1, 0xca, 0x19, 0x01, 0x48, 0xf3, 0xc6, 0xa6, 0x19, 0xc1, 0x00, 0xf2, 0xa7, 0x19, 0x41, 0xf5, 0xa5, 0x19, 0x41, 0xe1, 0xbd, 0x19, 0x01, 0x42, 0x22, 0x00, 0xbe, 0x19, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0xb8, 0x19, 0x01, 0x42, 0x22, 0x00, 0xb9, 0x19, 0x41, 0xe1, 0xcd, 0x19, 0x01, @@ -6938,7 +6975,7 @@ static const unsigned char uname2c_tree[222744] = { 0xe1, 0xc8, 0x19, 0x01, 0x42, 0x71, 0x00, 0xd0, 0x19, 0x41, 0xe1, 0xc2, 0x19, 0x01, 0x42, 0x22, 0x00, 0xc3, 0x19, 0x41, 0xe1, 0xc1, 0x19, 0x01, 0x42, 0x24, 0x02, 0xb2, 0x19, 0x01, 0x42, 0x2a, 0x05, 0xbc, 0x19, 0x01, - 0x42, 0xbe, 0x22, 0xb7, 0x19, 0x41, 0xe1, 0xc9, 0x19, 0x01, 0x42, 0x74, + 0x42, 0xdf, 0x23, 0xb7, 0x19, 0x41, 0xe1, 0xc9, 0x19, 0x01, 0x42, 0x74, 0x00, 0xcf, 0x19, 0x41, 0xe1, 0xae, 0x19, 0x01, 0x42, 0x22, 0x00, 0xaf, 0x19, 0x41, 0xe1, 0xb5, 0x19, 0x01, 0x42, 0x22, 0x00, 0xb6, 0x19, 0x41, 0xe9, 0xa3, 0x19, 0x41, 0xe1, 0xb0, 0x19, 0x01, 0x42, 0x22, 0x00, 0xb1, @@ -6946,12 +6983,12 @@ static const unsigned char uname2c_tree[222744] = { 0x19, 0x41, 0xe1, 0xba, 0x19, 0x01, 0x42, 0x22, 0x00, 0xbb, 0x19, 0x41, 0xe1, 0xb3, 0x19, 0x01, 0x42, 0x22, 0x00, 0xb4, 0x19, 0x41, 0xe1, 0xc4, 0x19, 0x01, 0x42, 0x22, 0x00, 0xc5, 0x19, 0x41, 0xe1, 0xa1, 0x19, 0x01, - 0xe9, 0xab, 0x19, 0x01, 0xf5, 0xad, 0x19, 0x41, 0x48, 0xa1, 0xc7, 0x85, - 0xf4, 0x01, 0x47, 0x9a, 0x84, 0xa6, 0x20, 0x40, 0x06, 0xef, 0x06, 0xa3, - 0x01, 0x07, 0xec, 0x05, 0x23, 0x05, 0x5a, 0x03, 0x01, 0xff, 0x44, 0xa9, - 0xf0, 0xee, 0xe4, 0x01, 0x45, 0xfa, 0xe8, 0xec, 0xe4, 0x01, 0x44, 0xed, - 0xf1, 0xeb, 0xe4, 0x01, 0x45, 0x4d, 0xeb, 0xef, 0xe4, 0x01, 0x45, 0x8e, - 0xeb, 0xed, 0xe4, 0x41, 0xe1, 0xd5, 0xe4, 0x81, 0x65, 0xe5, 0xe4, 0xe4, + 0xe9, 0xab, 0x19, 0x01, 0xf5, 0xad, 0x19, 0x41, 0x48, 0x2f, 0xcd, 0x85, + 0xf4, 0x01, 0x47, 0xa2, 0x88, 0xa6, 0x20, 0x40, 0x06, 0xef, 0x06, 0xa3, + 0x01, 0x07, 0x13, 0x06, 0x23, 0x05, 0x5a, 0x03, 0x01, 0xff, 0x44, 0x6c, + 0xf6, 0xee, 0xe4, 0x01, 0x45, 0xcc, 0xee, 0xec, 0xe4, 0x01, 0x44, 0xc0, + 0xf7, 0xeb, 0xe4, 0x01, 0x45, 0x15, 0xf1, 0xef, 0xe4, 0x01, 0x45, 0x56, + 0xf1, 0xed, 0xe4, 0x41, 0xe1, 0xd5, 0xe4, 0x81, 0x65, 0xe5, 0xe4, 0xe4, 0x81, 0x43, 0xe9, 0xda, 0xe4, 0x81, 0x2c, 0xef, 0xd0, 0xe4, 0x81, 0x15, 0xf5, 0xdf, 0xe4, 0xc1, 0x00, 0xe3, 0xe0, 0xe4, 0x01, 0xe4, 0xe1, 0xe4, 0x01, 0xeb, 0xe2, 0xe4, 0x01, 0xf2, 0xe3, 0xe4, 0x41, 0xec, 0xd2, 0xe4, @@ -6959,3686 +6996,3852 @@ static const unsigned char uname2c_tree[222744] = { 0xd3, 0xe4, 0x41, 0x42, 0x7f, 0x02, 0xdc, 0xe4, 0x01, 0xe8, 0xde, 0xe4, 0x01, 0xf3, 0xdb, 0xe4, 0x01, 0xf4, 0xdd, 0xe4, 0x41, 0xe7, 0xe6, 0xe4, 0x01, 0x42, 0x60, 0x07, 0xea, 0xe4, 0x01, 0xed, 0xe7, 0xe4, 0x01, 0xee, - 0xe8, 0xe4, 0x81, 0x06, 0x42, 0xee, 0x05, 0xe9, 0xe4, 0x41, 0xee, 0xe5, + 0xe8, 0xe4, 0x81, 0x06, 0x42, 0x15, 0x06, 0xe9, 0xe4, 0x41, 0xee, 0xe5, 0xe4, 0x41, 0xe2, 0xd7, 0xe4, 0x01, 0xe8, 0xd9, 0xe4, 0x01, 0xea, 0xd6, - 0xe4, 0x01, 0x42, 0x99, 0x1a, 0xd8, 0xe4, 0x41, 0x45, 0x12, 0x0b, 0xf8, - 0xe4, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0xf9, 0xe4, 0x01, 0x43, 0x0e, - 0x0b, 0xf1, 0xe4, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xf0, + 0xe4, 0x01, 0x42, 0x9f, 0x1b, 0xd8, 0xe4, 0x41, 0x45, 0x7e, 0x0b, 0xf8, + 0xe4, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xf9, 0xe4, 0x01, 0x43, 0x7a, + 0x0b, 0xf1, 0xe4, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xf0, 0xe4, 0x41, 0x44, 0x25, 0x01, 0xf3, 0xe4, 0x01, 0x42, 0x15, 0x02, 0xf2, - 0xe4, 0x41, 0x44, 0xe5, 0x1d, 0xf7, 0xe4, 0x01, 0x42, 0x1c, 0x26, 0xf6, - 0xe4, 0x41, 0x43, 0xd2, 0x05, 0xf5, 0xe4, 0x01, 0x43, 0xf6, 0x06, 0xf4, - 0xe4, 0x41, 0x07, 0x3e, 0xcf, 0x06, 0x42, 0x74, 0x00, 0x07, 0x22, 0x40, - 0x55, 0x10, 0x3a, 0xab, 0x08, 0x01, 0x07, 0xec, 0x05, 0x3c, 0x07, 0x1a, - 0x3a, 0x01, 0xff, 0xa6, 0x29, 0x43, 0x0e, 0x0b, 0xa7, 0x08, 0x81, 0x1c, + 0xe4, 0x41, 0x44, 0x06, 0x1f, 0xf7, 0xe4, 0x01, 0x42, 0x09, 0x24, 0xf6, + 0xe4, 0x41, 0x43, 0xf9, 0x05, 0xf5, 0xe4, 0x01, 0x43, 0xf6, 0x06, 0xf4, + 0xe4, 0x41, 0x07, 0xe4, 0xd4, 0x06, 0x42, 0x74, 0x00, 0x07, 0x22, 0x40, + 0x55, 0x2d, 0x3c, 0xab, 0x08, 0x01, 0x07, 0x13, 0x06, 0x3c, 0x07, 0x37, + 0x3c, 0x01, 0xff, 0xa6, 0x29, 0x43, 0x7a, 0x0b, 0xa7, 0x08, 0x81, 0x1c, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0xad, 0x08, 0x01, 0x44, 0x25, 0x01, - 0xa9, 0x08, 0x01, 0xb7, 0x01, 0xff, 0x44, 0xe7, 0x1d, 0xae, 0x08, 0x01, - 0xef, 0xa8, 0x08, 0x41, 0x48, 0x70, 0x11, 0xaf, 0x08, 0x41, 0x43, 0xd2, + 0xa9, 0x08, 0x01, 0xb7, 0x01, 0xff, 0x44, 0xe9, 0x1e, 0xae, 0x08, 0x01, + 0xef, 0xa8, 0x08, 0x41, 0x48, 0x3e, 0x12, 0xaf, 0x08, 0x41, 0x43, 0xf9, 0x05, 0xac, 0x08, 0x01, 0x43, 0xf6, 0x06, 0xaa, 0x08, 0x41, 0xa1, 0xb9, - 0x01, 0x44, 0x61, 0xef, 0x83, 0x08, 0x01, 0x46, 0x2a, 0x4a, 0x85, 0x08, - 0x01, 0x06, 0x10, 0x2d, 0x73, 0x45, 0xfe, 0xaa, 0x84, 0x08, 0x01, 0x42, - 0xb0, 0x01, 0x87, 0x08, 0x81, 0x60, 0x44, 0xed, 0xf0, 0x8f, 0x08, 0x01, - 0x46, 0xb4, 0xdd, 0x91, 0x08, 0x01, 0x43, 0xb4, 0x05, 0x93, 0x08, 0x01, - 0x43, 0xde, 0x22, 0x95, 0x08, 0x01, 0x42, 0x6f, 0x02, 0x98, 0x08, 0x01, - 0x44, 0x6d, 0xc8, 0x9a, 0x08, 0x01, 0x44, 0x7d, 0x66, 0x9b, 0x08, 0x01, - 0xb3, 0x20, 0xb4, 0x12, 0x43, 0x9f, 0x8a, 0x88, 0x08, 0x01, 0x44, 0xa8, - 0x52, 0x8d, 0x08, 0x01, 0x45, 0xa2, 0x52, 0x89, 0x08, 0x41, 0x42, 0xd2, - 0x2d, 0x9e, 0x08, 0x01, 0x43, 0xf5, 0x25, 0x8b, 0x08, 0x41, 0xa1, 0x06, - 0x43, 0x7a, 0x16, 0x9d, 0x08, 0x41, 0x43, 0xcd, 0xea, 0x99, 0x08, 0x01, - 0x44, 0x69, 0xe4, 0x96, 0x08, 0x41, 0x42, 0x53, 0x00, 0x8a, 0x08, 0x41, - 0x45, 0xd3, 0xad, 0x80, 0x08, 0x01, 0x44, 0x61, 0xef, 0x82, 0x08, 0x01, - 0x42, 0xb0, 0x01, 0x86, 0x08, 0x01, 0x44, 0xed, 0xf0, 0x8e, 0x08, 0x01, - 0x46, 0xb4, 0xdd, 0x90, 0x08, 0x01, 0x43, 0xb4, 0x05, 0x92, 0x08, 0x01, - 0x43, 0xde, 0x22, 0x94, 0x08, 0x01, 0x44, 0x7a, 0x4a, 0x9c, 0x08, 0x01, - 0x44, 0xa8, 0x52, 0x8c, 0x08, 0x41, 0x44, 0x33, 0x3d, 0x81, 0x08, 0x01, - 0x43, 0x9a, 0x1a, 0x97, 0x08, 0x41, 0xa3, 0x58, 0x4c, 0xa9, 0x0a, 0xc2, - 0x22, 0x00, 0x08, 0x2d, 0x22, 0x42, 0x47, 0x8e, 0x0d, 0x0f, 0x22, 0x00, - 0xb3, 0x24, 0x4e, 0x2c, 0x7d, 0x09, 0x2a, 0x00, 0x45, 0x4d, 0x17, 0xc3, - 0x22, 0x80, 0x06, 0x52, 0x9c, 0x56, 0xff, 0x2a, 0x40, 0x0f, 0x67, 0x69, - 0x01, 0xff, 0x43, 0x23, 0x0a, 0x03, 0x2a, 0x00, 0x44, 0x73, 0x28, 0x04, - 0x2a, 0x40, 0x06, 0xd7, 0x24, 0x06, 0x48, 0x76, 0x70, 0x11, 0x22, 0x40, - 0x55, 0x32, 0x3c, 0x05, 0x2a, 0x00, 0x4e, 0x0c, 0x7e, 0x06, 0x2a, 0x40, + 0x01, 0x44, 0x20, 0xf5, 0x83, 0x08, 0x01, 0x46, 0x6d, 0x4c, 0x85, 0x08, + 0x01, 0x06, 0x7c, 0x2e, 0x73, 0x45, 0x5a, 0xb0, 0x84, 0x08, 0x01, 0x42, + 0xb0, 0x01, 0x87, 0x08, 0x81, 0x60, 0x44, 0xb0, 0xf6, 0x8f, 0x08, 0x01, + 0x46, 0x8a, 0xe3, 0x91, 0x08, 0x01, 0x43, 0xb4, 0x05, 0x93, 0x08, 0x01, + 0x43, 0x18, 0x24, 0x95, 0x08, 0x01, 0x42, 0x6f, 0x02, 0x98, 0x08, 0x01, + 0x44, 0xf3, 0xcd, 0x9a, 0x08, 0x01, 0x44, 0x8a, 0x69, 0x9b, 0x08, 0x01, + 0xb3, 0x20, 0xb4, 0x12, 0x43, 0x1c, 0x8f, 0x88, 0x08, 0x01, 0x44, 0xfd, + 0x54, 0x8d, 0x08, 0x01, 0x45, 0xf7, 0x54, 0x89, 0x08, 0x41, 0x42, 0x3e, + 0x2f, 0x9e, 0x08, 0x01, 0x43, 0x48, 0x27, 0x8b, 0x08, 0x41, 0xa1, 0x06, + 0x43, 0x48, 0x17, 0x9d, 0x08, 0x41, 0x43, 0x95, 0xf0, 0x99, 0x08, 0x01, + 0x44, 0x4a, 0xea, 0x96, 0x08, 0x41, 0x42, 0x53, 0x00, 0x8a, 0x08, 0x41, + 0x45, 0x39, 0xb3, 0x80, 0x08, 0x01, 0x44, 0x20, 0xf5, 0x82, 0x08, 0x01, + 0x42, 0xb0, 0x01, 0x86, 0x08, 0x01, 0x44, 0xb0, 0xf6, 0x8e, 0x08, 0x01, + 0x46, 0x8a, 0xe3, 0x90, 0x08, 0x01, 0x43, 0xb4, 0x05, 0x92, 0x08, 0x01, + 0x43, 0x18, 0x24, 0x94, 0x08, 0x01, 0x44, 0xbd, 0x4c, 0x9c, 0x08, 0x01, + 0x44, 0xfd, 0x54, 0x8c, 0x08, 0x41, 0x44, 0x3b, 0x3f, 0x81, 0x08, 0x01, + 0x43, 0xa0, 0x1b, 0x97, 0x08, 0x41, 0xa3, 0x58, 0x4c, 0xf2, 0x0a, 0xc2, + 0x22, 0x00, 0x08, 0x4e, 0x23, 0x42, 0x47, 0x1c, 0x0e, 0x0f, 0x22, 0x00, + 0xb3, 0x24, 0x4e, 0xf2, 0x80, 0x09, 0x2a, 0x00, 0x45, 0x37, 0x18, 0xc3, + 0x22, 0x80, 0x06, 0x52, 0x27, 0x59, 0xff, 0x2a, 0x40, 0x0f, 0xa2, 0x6c, + 0x01, 0xff, 0x43, 0x48, 0x0a, 0x03, 0x2a, 0x00, 0x44, 0xc6, 0x29, 0x04, + 0x2a, 0x40, 0x06, 0x2a, 0x26, 0x06, 0x48, 0x93, 0x73, 0x11, 0x22, 0x40, + 0x55, 0x3a, 0x3e, 0x05, 0x2a, 0x00, 0x4e, 0xe0, 0x81, 0x06, 0x2a, 0x40, 0x43, 0x1a, 0x00, 0xc0, 0x22, 0x00, 0x42, 0x0c, 0x00, 0xc1, 0x22, 0x40, - 0x07, 0xf8, 0x22, 0x06, 0x48, 0x29, 0x2d, 0x10, 0x22, 0x40, 0x4c, 0x2c, - 0x8e, 0x00, 0x2a, 0x00, 0x4d, 0x86, 0x87, 0x01, 0x2a, 0x00, 0x4e, 0x2c, - 0x7d, 0x02, 0x2a, 0x40, 0xa1, 0xeb, 0x65, 0xa5, 0xaa, 0x48, 0xa9, 0xd9, - 0x3f, 0x43, 0x9a, 0xf4, 0x5f, 0x20, 0x00, 0xaf, 0xb3, 0x20, 0x03, 0x61, - 0x1e, 0xa1, 0x1e, 0xb5, 0x80, 0x0d, 0x42, 0xb8, 0xf2, 0x0e, 0x18, 0x00, - 0xf7, 0x95, 0x00, 0x00, 0x07, 0xf0, 0xd7, 0x01, 0xff, 0x0f, 0x58, 0x33, - 0xb1, 0x0c, 0x06, 0xef, 0x06, 0xea, 0x0b, 0x18, 0x89, 0x28, 0xa3, 0x0b, - 0xac, 0xa2, 0x05, 0x10, 0x78, 0x0c, 0x91, 0x05, 0x0a, 0x86, 0xaf, 0xca, - 0x04, 0xb3, 0x8d, 0x02, 0xb4, 0xb3, 0x01, 0x0b, 0x55, 0x77, 0x01, 0xff, - 0xa1, 0x97, 0x01, 0xe5, 0x31, 0x10, 0x80, 0x8b, 0x01, 0x4c, 0x58, 0x8f, - 0x71, 0x10, 0x00, 0xe9, 0x2d, 0x10, 0x80, 0x7c, 0x06, 0x72, 0xdd, 0x68, - 0x04, 0x81, 0xc8, 0x5a, 0xb3, 0x36, 0x47, 0x4c, 0xd6, 0x2b, 0x10, 0x00, - 0xf5, 0x2f, 0x10, 0x80, 0x27, 0x08, 0x43, 0xc1, 0x11, 0x12, 0xf4, 0x31, - 0x01, 0xff, 0x42, 0x97, 0x02, 0x67, 0x10, 0x00, 0x42, 0xd6, 0x13, 0x68, + 0x07, 0x32, 0x24, 0x06, 0x48, 0x95, 0x2e, 0x10, 0x22, 0x40, 0x4c, 0xc0, + 0x92, 0x00, 0x2a, 0x00, 0x4d, 0xdc, 0x8b, 0x01, 0x2a, 0x00, 0x4e, 0xf2, + 0x80, 0x02, 0x2a, 0x40, 0xa1, 0xe0, 0x6d, 0xa5, 0xfe, 0x4f, 0xa9, 0xad, + 0x47, 0x43, 0x6f, 0xfa, 0x5f, 0x20, 0x00, 0xaf, 0xea, 0x24, 0x03, 0x82, + 0x1f, 0xd8, 0x22, 0xb5, 0x80, 0x0d, 0x42, 0x8f, 0xf8, 0x0e, 0x18, 0x00, + 0xf7, 0x95, 0x00, 0x00, 0x07, 0xc0, 0xdd, 0x01, 0xff, 0x0f, 0x09, 0x35, + 0xb1, 0x0c, 0x06, 0xef, 0x06, 0xea, 0x0b, 0x18, 0xdc, 0x29, 0xa3, 0x0b, + 0xac, 0xa2, 0x05, 0x10, 0xe4, 0x0c, 0x91, 0x05, 0x0a, 0x00, 0xb5, 0xca, + 0x04, 0xb3, 0x8d, 0x02, 0xb4, 0xb3, 0x01, 0x0b, 0xc7, 0x7a, 0x01, 0xff, + 0xa1, 0x97, 0x01, 0xe5, 0x31, 0x10, 0x80, 0x8b, 0x01, 0x4c, 0xec, 0x93, + 0x71, 0x10, 0x00, 0xe9, 0x2d, 0x10, 0x80, 0x7c, 0x06, 0x48, 0xe3, 0x68, + 0x04, 0x07, 0xce, 0x5a, 0xb3, 0x36, 0x47, 0x1c, 0xdc, 0x2b, 0x10, 0x00, + 0xf5, 0x2f, 0x10, 0x80, 0x27, 0x08, 0xf2, 0xc6, 0x11, 0x12, 0x8e, 0x33, + 0x01, 0xff, 0x42, 0x97, 0x02, 0x67, 0x10, 0x00, 0x42, 0x5c, 0x0a, 0x68, 0x10, 0x40, 0xec, 0x58, 0x10, 0x80, 0x09, 0xf2, 0x56, 0x10, 0xc0, 0x00, 0xf2, 0x57, 0x10, 0x40, 0xec, 0x59, 0x10, 0x40, 0xf5, 0x30, 0x10, 0x40, - 0x4c, 0x40, 0x8f, 0x62, 0x10, 0x00, 0x04, 0x90, 0x00, 0x01, 0xff, 0x42, - 0x80, 0x12, 0x83, 0x10, 0x00, 0xe5, 0x84, 0x10, 0x80, 0x06, 0x47, 0x3d, - 0xd1, 0x86, 0x10, 0x40, 0x46, 0x5b, 0x00, 0x85, 0x10, 0x40, 0x42, 0x6d, - 0x28, 0x33, 0x10, 0x00, 0xef, 0x34, 0x10, 0x40, 0x42, 0x27, 0x01, 0x74, - 0x10, 0x00, 0x42, 0x67, 0x51, 0x72, 0x10, 0x00, 0xf5, 0x73, 0x10, 0x40, + 0x4c, 0xd4, 0x93, 0x62, 0x10, 0x00, 0x04, 0x90, 0x00, 0x01, 0xff, 0x42, + 0x4e, 0x13, 0x83, 0x10, 0x00, 0xe5, 0x84, 0x10, 0x80, 0x06, 0x47, 0xf1, + 0xd6, 0x86, 0x10, 0x40, 0x46, 0x5b, 0x00, 0x85, 0x10, 0x40, 0x42, 0xc0, + 0x29, 0x33, 0x10, 0x00, 0xef, 0x34, 0x10, 0x40, 0x42, 0x27, 0x01, 0x74, + 0x10, 0x00, 0x42, 0xce, 0x53, 0x72, 0x10, 0x00, 0xf5, 0x73, 0x10, 0x40, 0xe9, 0x2e, 0x10, 0x40, 0x46, 0x5b, 0x00, 0x35, 0x10, 0x40, 0xe1, 0x2c, - 0x10, 0x00, 0xe9, 0x32, 0x10, 0xc0, 0x00, 0x45, 0x7a, 0xeb, 0x9c, 0x10, - 0xc0, 0x00, 0xe9, 0x9d, 0x10, 0x40, 0x0f, 0x75, 0x6a, 0x11, 0x14, 0xa3, - 0x44, 0x01, 0xff, 0x45, 0x0b, 0xe7, 0x63, 0x10, 0x00, 0x46, 0x78, 0xdd, - 0x64, 0x10, 0x40, 0x45, 0x12, 0x0b, 0xf8, 0xa9, 0x00, 0xa6, 0x2e, 0x44, - 0xea, 0x2a, 0xf9, 0xa9, 0x00, 0x43, 0x0e, 0x0b, 0xf1, 0xa9, 0x00, 0xb3, - 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xf0, 0xa9, 0x40, 0x44, 0x25, 0x01, - 0xf3, 0xa9, 0x00, 0x42, 0x15, 0x02, 0xf2, 0xa9, 0x40, 0x44, 0xe5, 0x1d, - 0xf7, 0xa9, 0x00, 0x42, 0x1c, 0x26, 0xf6, 0xa9, 0x40, 0x43, 0xd2, 0x05, - 0xf5, 0xa9, 0x00, 0x43, 0xf6, 0x06, 0xf4, 0xa9, 0x40, 0x0a, 0x3a, 0xab, - 0xf3, 0x01, 0x04, 0x5b, 0x03, 0x47, 0x06, 0x60, 0x16, 0x01, 0xff, 0xa1, - 0x23, 0x49, 0x74, 0xb7, 0x4d, 0x10, 0x00, 0x48, 0x81, 0xc6, 0x4f, 0x10, - 0x00, 0x48, 0xf9, 0xc7, 0x4c, 0x10, 0x00, 0x05, 0x46, 0x55, 0x01, 0xff, - 0x4b, 0xad, 0x00, 0x9f, 0x10, 0x00, 0x43, 0x0e, 0x0b, 0x9e, 0x10, 0x40, - 0x4d, 0x1b, 0x83, 0x4e, 0x10, 0x00, 0x05, 0x32, 0xd2, 0x01, 0xff, 0x4b, - 0xad, 0x00, 0x77, 0xaa, 0x00, 0x43, 0x0e, 0x0b, 0x78, 0xaa, 0x00, 0x43, - 0x1f, 0x0a, 0x79, 0xaa, 0x40, 0xa1, 0x99, 0x01, 0x49, 0x9f, 0x12, 0x37, - 0x10, 0x00, 0x0c, 0xb4, 0x90, 0x86, 0x01, 0x4e, 0xac, 0x79, 0x4a, 0x10, - 0x00, 0x4e, 0x0a, 0x7b, 0x7b, 0xaa, 0x00, 0x54, 0xa7, 0x45, 0x8f, 0x10, - 0x00, 0xb3, 0x35, 0x0f, 0x99, 0x73, 0x29, 0x02, 0x02, 0x00, 0x19, 0x17, - 0xf4, 0x31, 0x01, 0xff, 0xd1, 0x69, 0x10, 0x00, 0xd2, 0x6a, 0x10, 0x00, + 0x10, 0x00, 0xe9, 0x32, 0x10, 0xc0, 0x00, 0x45, 0x42, 0xf1, 0x9c, 0x10, + 0xc0, 0x00, 0xe9, 0x9d, 0x10, 0x40, 0x0f, 0x92, 0x6d, 0x11, 0x14, 0xd3, + 0x46, 0x01, 0xff, 0x45, 0xdd, 0xec, 0x63, 0x10, 0x00, 0x46, 0x4e, 0xe3, + 0x64, 0x10, 0x40, 0x45, 0x7e, 0x0b, 0xf8, 0xa9, 0x00, 0xa6, 0x2e, 0x44, + 0x6d, 0x2c, 0xf9, 0xa9, 0x00, 0x43, 0x7a, 0x0b, 0xf1, 0xa9, 0x00, 0xb3, + 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xf0, 0xa9, 0x40, 0x44, 0x25, 0x01, + 0xf3, 0xa9, 0x00, 0x42, 0x15, 0x02, 0xf2, 0xa9, 0x40, 0x44, 0x06, 0x1f, + 0xf7, 0xa9, 0x00, 0x42, 0x09, 0x24, 0xf6, 0xa9, 0x40, 0x43, 0xf9, 0x05, + 0xf5, 0xa9, 0x00, 0x43, 0xf6, 0x06, 0xf4, 0xa9, 0x40, 0x0a, 0x96, 0xb0, + 0xf3, 0x01, 0x04, 0x5b, 0x03, 0x47, 0x06, 0x2e, 0x17, 0x01, 0xff, 0xa1, + 0x23, 0x49, 0xe4, 0xbc, 0x4d, 0x10, 0x00, 0x48, 0x0f, 0xcc, 0x4f, 0x10, + 0x00, 0x48, 0x87, 0xcd, 0x4c, 0x10, 0x00, 0x05, 0xad, 0x57, 0x01, 0xff, + 0x4b, 0xad, 0x00, 0x9f, 0x10, 0x00, 0x43, 0x7a, 0x0b, 0x9e, 0x10, 0x40, + 0x4d, 0x16, 0x87, 0x4e, 0x10, 0x00, 0x05, 0xed, 0xd7, 0x01, 0xff, 0x4b, + 0xad, 0x00, 0x77, 0xaa, 0x00, 0x43, 0x7a, 0x0b, 0x78, 0xaa, 0x00, 0x43, + 0x44, 0x0a, 0x79, 0xaa, 0x40, 0xa1, 0x99, 0x01, 0x49, 0x6d, 0x13, 0x37, + 0x10, 0x00, 0x0c, 0x54, 0x95, 0x86, 0x01, 0x4e, 0x3a, 0x7d, 0x4a, 0x10, + 0x00, 0x4e, 0xc2, 0x7e, 0x7b, 0xaa, 0x00, 0x54, 0xd7, 0x47, 0x8f, 0x10, + 0x00, 0xb3, 0x35, 0x0f, 0xc5, 0x76, 0x29, 0x02, 0x02, 0x00, 0x19, 0x17, + 0x8e, 0x33, 0x01, 0xff, 0xd1, 0x69, 0x10, 0x00, 0xd2, 0x6a, 0x10, 0x00, 0xd3, 0x6b, 0x10, 0x00, 0xd4, 0x6c, 0x10, 0x00, 0xd5, 0x6d, 0x10, 0x40, - 0x44, 0xe7, 0x23, 0x39, 0x10, 0x00, 0x45, 0xf3, 0x4b, 0x38, 0x10, 0x40, - 0xd2, 0x7c, 0xaa, 0x00, 0xd5, 0x7d, 0xaa, 0x40, 0x46, 0xaf, 0x0a, 0x4b, - 0x10, 0x00, 0x04, 0x90, 0x00, 0x01, 0xff, 0x08, 0xe9, 0xc4, 0x1b, 0x43, - 0xae, 0x52, 0xe5, 0xa9, 0x00, 0x05, 0x06, 0x32, 0x01, 0xff, 0xd2, 0x87, + 0x44, 0x21, 0x25, 0x39, 0x10, 0x00, 0x45, 0x49, 0x4e, 0x38, 0x10, 0x40, + 0xd2, 0x7c, 0xaa, 0x00, 0xd5, 0x7d, 0xaa, 0x40, 0x46, 0xf8, 0x0a, 0x4b, + 0x10, 0x00, 0x04, 0x90, 0x00, 0x01, 0xff, 0x08, 0x77, 0xca, 0x1b, 0x43, + 0x03, 0x55, 0xe5, 0xa9, 0x00, 0x05, 0xa0, 0x33, 0x01, 0xff, 0xd2, 0x87, 0x10, 0x00, 0xd3, 0x88, 0x10, 0x00, 0xd5, 0x89, 0x10, 0x00, 0xd6, 0x8a, - 0x10, 0x40, 0x4d, 0xa6, 0x82, 0x8d, 0x10, 0x00, 0x05, 0x06, 0x32, 0x01, + 0x10, 0x40, 0x4d, 0xa1, 0x86, 0x8d, 0x10, 0x00, 0x05, 0xa0, 0x33, 0x01, 0xff, 0xd2, 0x8b, 0x10, 0x00, 0xd3, 0x8c, 0x10, 0x40, 0xd1, 0x9a, 0x10, - 0x00, 0xd3, 0x9b, 0x10, 0x40, 0x47, 0x3d, 0x16, 0x36, 0x10, 0x00, 0x43, - 0xa3, 0x2d, 0x3a, 0x10, 0x40, 0x45, 0x12, 0x0b, 0x98, 0x10, 0x00, 0xa6, - 0x2e, 0x44, 0xea, 0x2a, 0x99, 0x10, 0x00, 0x43, 0x0e, 0x0b, 0x91, 0x10, - 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x90, 0x10, 0x40, 0x44, + 0x00, 0xd3, 0x9b, 0x10, 0x40, 0x47, 0x0b, 0x17, 0x36, 0x10, 0x00, 0x43, + 0x0f, 0x2f, 0x3a, 0x10, 0x40, 0x45, 0x7e, 0x0b, 0x98, 0x10, 0x00, 0xa6, + 0x2e, 0x44, 0x6d, 0x2c, 0x99, 0x10, 0x00, 0x43, 0x7a, 0x0b, 0x91, 0x10, + 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x90, 0x10, 0x40, 0x44, 0x25, 0x01, 0x93, 0x10, 0x00, 0x42, 0x15, 0x02, 0x92, 0x10, 0x40, 0x44, - 0xe5, 0x1d, 0x97, 0x10, 0x00, 0x42, 0x1c, 0x26, 0x96, 0x10, 0x40, 0x43, - 0xd2, 0x05, 0x95, 0x10, 0x00, 0x43, 0xf6, 0x06, 0x94, 0x10, 0x40, 0x45, - 0x12, 0x0b, 0xd8, 0x16, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0xd9, 0x16, - 0x01, 0x43, 0x0e, 0x0b, 0xd1, 0x16, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, - 0x5f, 0x1e, 0xd0, 0x16, 0x41, 0x44, 0x25, 0x01, 0xd3, 0x16, 0x01, 0x42, - 0x15, 0x02, 0xd2, 0x16, 0x41, 0x44, 0xe5, 0x1d, 0xd7, 0x16, 0x01, 0x42, - 0x1c, 0x26, 0xd6, 0x16, 0x41, 0x43, 0xd2, 0x05, 0xd5, 0x16, 0x01, 0x43, - 0xf6, 0x06, 0xd4, 0x16, 0x41, 0x54, 0xdb, 0x43, 0x70, 0xaa, 0x00, 0x52, - 0x46, 0x55, 0xe6, 0xa9, 0x40, 0x06, 0xed, 0x05, 0x17, 0x0f, 0x14, 0x71, - 0x01, 0xff, 0x42, 0xe2, 0x0a, 0x76, 0xaa, 0x00, 0x43, 0xa0, 0xf4, 0x74, - 0xaa, 0x00, 0x42, 0x96, 0xd2, 0x75, 0xaa, 0x40, 0xe1, 0x21, 0x10, 0x80, + 0x06, 0x1f, 0x97, 0x10, 0x00, 0x42, 0x09, 0x24, 0x96, 0x10, 0x40, 0x43, + 0xf9, 0x05, 0x95, 0x10, 0x00, 0x43, 0xf6, 0x06, 0x94, 0x10, 0x40, 0x45, + 0x7e, 0x0b, 0xd8, 0x16, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xd9, 0x16, + 0x01, 0x43, 0x7a, 0x0b, 0xd1, 0x16, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, + 0x80, 0x1f, 0xd0, 0x16, 0x41, 0x44, 0x25, 0x01, 0xd3, 0x16, 0x01, 0x42, + 0x15, 0x02, 0xd2, 0x16, 0x41, 0x44, 0x06, 0x1f, 0xd7, 0x16, 0x01, 0x42, + 0x09, 0x24, 0xd6, 0x16, 0x41, 0x43, 0xf9, 0x05, 0xd5, 0x16, 0x01, 0x43, + 0xf6, 0x06, 0xd4, 0x16, 0x41, 0x54, 0xf7, 0x45, 0x70, 0xaa, 0x00, 0x52, + 0xad, 0x57, 0xe6, 0xa9, 0x40, 0x06, 0x14, 0x06, 0x17, 0x0f, 0x40, 0x74, + 0x01, 0xff, 0x42, 0x4e, 0x0b, 0x76, 0xaa, 0x00, 0x43, 0x75, 0xfa, 0x74, + 0xaa, 0x00, 0x42, 0x51, 0xd8, 0x75, 0xaa, 0x40, 0xe1, 0x21, 0x10, 0x80, 0xd3, 0x05, 0xa2, 0xc6, 0x05, 0xa3, 0xb9, 0x05, 0xa4, 0xa0, 0x05, 0xe5, 0x27, 0x10, 0x80, 0x83, 0x05, 0xa7, 0xf0, 0x04, 0x42, 0x22, 0x00, 0x1f, 0x10, 0x00, 0xe9, 0x23, 0x10, 0x80, 0xe0, 0x04, 0xaa, 0xd3, 0x04, 0xab, 0xc4, 0x03, 0xac, 0xb7, 0x03, 0xad, 0x8f, 0x03, 0xae, 0xf0, 0x02, 0xef, 0x29, 0x10, 0x00, 0xb0, 0xdf, 0x02, 0xb2, 0xd2, 0x02, 0xb3, 0xb2, 0x01, - 0xb4, 0x3c, 0xf5, 0x25, 0x10, 0x80, 0x33, 0x08, 0x43, 0xc1, 0x1d, 0xb7, - 0x06, 0x42, 0xbe, 0x22, 0x1a, 0x10, 0x40, 0xe1, 0x1d, 0x10, 0x00, 0x11, - 0xf5, 0x31, 0x01, 0xff, 0x43, 0x51, 0x02, 0x66, 0x10, 0x00, 0x43, 0x8f, + 0xb4, 0x3c, 0xf5, 0x25, 0x10, 0x80, 0x33, 0x08, 0xf2, 0xc6, 0x1d, 0xb7, + 0x06, 0x42, 0xdf, 0x23, 0x1a, 0x10, 0x40, 0xe1, 0x1d, 0x10, 0x00, 0x11, + 0x8f, 0x33, 0x01, 0xff, 0x43, 0x51, 0x02, 0x66, 0x10, 0x00, 0x43, 0x8f, 0x00, 0x65, 0x10, 0x40, 0xec, 0x54, 0x10, 0x80, 0x09, 0xf2, 0x52, 0x10, 0xc0, 0x00, 0xf2, 0x53, 0x10, 0x40, 0xec, 0x55, 0x10, 0x40, 0xf5, 0x26, 0x10, 0x40, 0xe1, 0x10, 0x10, 0x80, 0x13, 0x42, 0x22, 0x00, 0x11, 0x10, 0x00, 0xb4, 0x01, 0xff, 0xe1, 0x0b, 0x10, 0x00, 0x42, 0x22, 0x00, 0x0c, - 0x10, 0x40, 0x08, 0x76, 0x6a, 0x01, 0xff, 0xa2, 0x4b, 0xa4, 0x33, 0x42, - 0x0c, 0x08, 0xe8, 0xa9, 0x00, 0xa7, 0x21, 0xaa, 0x15, 0x43, 0x2c, 0x0e, + 0x10, 0x40, 0x08, 0x93, 0x6d, 0x01, 0xff, 0xa2, 0x4b, 0xa4, 0x33, 0x42, + 0x0c, 0x08, 0xe8, 0xa9, 0x00, 0xa7, 0x21, 0xaa, 0x15, 0x43, 0xba, 0x0e, 0xfa, 0xa9, 0x00, 0xae, 0x01, 0xff, 0x42, 0x2a, 0x05, 0xef, 0xa9, 0x00, - 0x42, 0xbe, 0x22, 0xe7, 0xa9, 0x40, 0xe1, 0xeb, 0xa9, 0x00, 0x42, 0x22, + 0x42, 0xdf, 0x23, 0xe7, 0xa9, 0x40, 0xe1, 0xeb, 0xa9, 0x00, 0x42, 0x22, 0x00, 0xec, 0xa9, 0x40, 0xe1, 0xe9, 0xa9, 0x00, 0x42, 0x22, 0x00, 0xea, 0xa9, 0x40, 0xe1, 0xfb, 0xa9, 0x00, 0xa4, 0x06, 0x42, 0x22, 0x00, 0xfc, 0xa9, 0x40, 0xe1, 0xed, 0xa9, 0x00, 0x42, 0x22, 0x00, 0xee, 0xa9, 0x40, 0xe1, 0xfd, 0xa9, 0x00, 0x42, 0x22, 0x00, 0xfe, 0xa9, 0x40, 0xe1, 0x1e, - 0x10, 0x00, 0x4d, 0x5c, 0x83, 0x61, 0x10, 0x00, 0xa8, 0x06, 0x42, 0x40, - 0x06, 0x51, 0x10, 0x40, 0xe1, 0x50, 0x10, 0x80, 0x11, 0x0b, 0x1e, 0xa5, - 0x01, 0xff, 0x43, 0xe6, 0x17, 0x7e, 0xaa, 0x00, 0x43, 0xa4, 0x02, 0x7f, + 0x10, 0x00, 0x4d, 0x57, 0x87, 0x61, 0x10, 0x00, 0xa8, 0x06, 0x42, 0x40, + 0x06, 0x51, 0x10, 0x40, 0xe1, 0x50, 0x10, 0x80, 0x11, 0x0b, 0x48, 0xaa, + 0x01, 0xff, 0x43, 0xd0, 0x18, 0x7e, 0xaa, 0x00, 0x43, 0xa4, 0x02, 0x7f, 0xaa, 0x40, 0x02, 0x92, 0x00, 0x01, 0xff, 0xe1, 0x22, 0x10, 0x00, 0xa2, - 0x60, 0xa3, 0x54, 0x42, 0xf0, 0x10, 0x7b, 0x10, 0x00, 0x42, 0x0c, 0x08, + 0x60, 0xa3, 0x54, 0x42, 0x7b, 0x08, 0x7b, 0x10, 0x00, 0x42, 0x0c, 0x08, 0x7e, 0x10, 0x00, 0xa7, 0x3c, 0x42, 0x22, 0x00, 0x81, 0x10, 0x00, 0x43, - 0xa3, 0x45, 0xe2, 0xa9, 0x00, 0xab, 0x24, 0xae, 0x12, 0x43, 0x1b, 0x1d, + 0xd3, 0x47, 0xe2, 0xa9, 0x00, 0xab, 0x24, 0xae, 0x12, 0x43, 0x21, 0x1e, 0x7d, 0x10, 0x00, 0x43, 0x8f, 0x00, 0x80, 0x10, 0x00, 0x42, 0x59, 0x00, 0x79, 0x10, 0x40, 0xe1, 0x7c, 0x10, 0x00, 0x42, 0x2a, 0x05, 0xe3, 0xa9, - 0x00, 0x42, 0xbe, 0x22, 0x7a, 0x10, 0x40, 0xe1, 0x75, 0x10, 0x00, 0x42, + 0x00, 0x42, 0xdf, 0x23, 0x7a, 0x10, 0x40, 0xe1, 0x75, 0x10, 0x00, 0x42, 0x22, 0x00, 0x76, 0x10, 0x40, 0xe1, 0x77, 0x10, 0x00, 0x42, 0x22, 0x00, 0xe0, 0xa9, 0x40, 0xe1, 0x78, 0x10, 0x00, 0x42, 0x22, 0x00, 0xe1, 0xa9, 0x40, 0xe1, 0x7f, 0x10, 0x00, 0x42, 0x22, 0x00, 0xe4, 0xa9, 0x40, 0xe1, - 0x1b, 0x10, 0x00, 0x4f, 0x5c, 0x74, 0x8e, 0x10, 0x40, 0xe1, 0x15, 0x10, + 0x1b, 0x10, 0x00, 0x4f, 0x88, 0x77, 0x8e, 0x10, 0x40, 0xe1, 0x15, 0x10, 0x00, 0x42, 0x22, 0x00, 0x16, 0x10, 0x40, 0xe1, 0x14, 0x10, 0x00, 0x42, - 0x24, 0x02, 0x04, 0x10, 0x00, 0xae, 0x06, 0x42, 0xbe, 0x22, 0x09, 0x10, - 0x40, 0xe1, 0x0f, 0x10, 0x00, 0x42, 0xbe, 0x22, 0x0a, 0x10, 0x40, 0xe1, - 0x19, 0x10, 0x00, 0x03, 0xb6, 0x00, 0x01, 0xff, 0x02, 0x80, 0x27, 0x10, - 0xe5, 0x28, 0x10, 0x00, 0x43, 0xa3, 0x45, 0x5b, 0x10, 0x00, 0x43, 0x40, - 0x48, 0x5a, 0x10, 0x40, 0xe1, 0x5c, 0x10, 0x00, 0xe5, 0x5d, 0x10, 0x40, + 0x24, 0x02, 0x04, 0x10, 0x00, 0xae, 0x06, 0x42, 0xdf, 0x23, 0x09, 0x10, + 0x40, 0xe1, 0x0f, 0x10, 0x00, 0x42, 0xdf, 0x23, 0x0a, 0x10, 0x40, 0xe1, + 0x19, 0x10, 0x00, 0x03, 0xb6, 0x00, 0x01, 0xff, 0x02, 0xd3, 0x28, 0x10, + 0xe5, 0x28, 0x10, 0x00, 0x43, 0xd3, 0x47, 0x5b, 0x10, 0x00, 0x43, 0x70, + 0x4a, 0x5a, 0x10, 0x40, 0xe1, 0x5c, 0x10, 0x00, 0xe5, 0x5d, 0x10, 0x40, 0xe1, 0x1c, 0x10, 0x00, 0x42, 0x74, 0x00, 0x20, 0x10, 0x40, 0xe1, 0x00, - 0x10, 0x00, 0x42, 0x22, 0x00, 0x01, 0x10, 0xc0, 0x00, 0x04, 0xde, 0x43, + 0x10, 0x00, 0x42, 0x22, 0x00, 0x01, 0x10, 0xc0, 0x00, 0x04, 0xfa, 0x45, 0x01, 0xff, 0xa3, 0x70, 0xa4, 0x5c, 0x42, 0x0c, 0x08, 0x6f, 0xaa, 0x00, - 0x42, 0x24, 0x02, 0x60, 0xaa, 0x00, 0xa8, 0x44, 0xaa, 0x38, 0x43, 0x2c, + 0x42, 0x24, 0x02, 0x60, 0xaa, 0x00, 0xa8, 0x44, 0xaa, 0x38, 0x43, 0xba, 0x0e, 0x6e, 0xaa, 0x00, 0xae, 0x26, 0x42, 0x71, 0x00, 0x73, 0xaa, 0x00, - 0x42, 0x40, 0x06, 0x6c, 0xaa, 0x00, 0x02, 0xee, 0x05, 0x0c, 0x42, 0x08, - 0x27, 0x71, 0xaa, 0x00, 0x42, 0x59, 0x00, 0x72, 0xaa, 0x40, 0xe1, 0x66, + 0x42, 0x40, 0x06, 0x6c, 0xaa, 0x00, 0x02, 0x15, 0x06, 0x0c, 0x42, 0x5b, + 0x28, 0x71, 0xaa, 0x00, 0x42, 0x59, 0x00, 0x72, 0xaa, 0x40, 0xe1, 0x66, 0xaa, 0x00, 0x42, 0x22, 0x00, 0x67, 0xaa, 0x40, 0xe1, 0x6b, 0xaa, 0x00, - 0x42, 0xbe, 0x22, 0x65, 0xaa, 0x40, 0xe1, 0x63, 0xaa, 0x00, 0x42, 0x22, + 0x42, 0xdf, 0x23, 0x65, 0xaa, 0x40, 0xe1, 0x63, 0xaa, 0x00, 0x42, 0x22, 0x00, 0x64, 0xaa, 0x40, 0xe1, 0x6d, 0xaa, 0x00, 0x42, 0x22, 0x00, 0x6e, 0xaa, 0x40, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x6a, 0xaa, 0x40, 0xe1, 0x68, 0xaa, 0x00, 0x42, 0x22, 0x00, 0x69, 0xaa, 0x40, 0xe1, 0x61, 0xaa, 0x00, 0x42, 0x22, 0x00, 0x62, 0xaa, 0x40, 0xe1, 0x07, 0x10, 0x00, 0x42, 0x22, 0x00, 0x08, 0x10, 0x40, 0xe9, 0x24, 0x10, 0x40, 0xe1, 0x02, 0x10, 0x00, - 0x42, 0x22, 0x00, 0x03, 0x10, 0x00, 0x47, 0xa2, 0xc6, 0x3f, 0x10, 0x40, - 0x11, 0x8a, 0x28, 0x01, 0xff, 0x44, 0x15, 0xf0, 0x70, 0x10, 0x00, 0x43, - 0x08, 0x46, 0x6e, 0x10, 0x00, 0x43, 0x75, 0xf3, 0x6f, 0x10, 0x40, 0xe1, + 0x42, 0x22, 0x00, 0x03, 0x10, 0x00, 0x47, 0x30, 0xcc, 0x3f, 0x10, 0x40, + 0x11, 0xdd, 0x29, 0x01, 0xff, 0x44, 0xd8, 0xf5, 0x70, 0x10, 0x00, 0x43, + 0x38, 0x48, 0x6e, 0x10, 0x00, 0x43, 0x50, 0xf9, 0x6f, 0x10, 0x40, 0xe1, 0x12, 0x10, 0x00, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x13, 0x10, 0x40, 0xe1, 0x0d, 0x10, 0x00, 0x42, 0x22, 0x00, 0x0e, 0x10, 0x40, 0xe1, 0x05, 0x10, 0x00, 0x42, 0x22, 0x00, 0x06, 0x10, 0x40, 0xe1, 0x17, 0x10, 0x00, 0x42, - 0x22, 0x00, 0x18, 0x10, 0x40, 0x47, 0x32, 0xd2, 0x7a, 0xaa, 0x00, 0xf5, - 0x2a, 0x10, 0x40, 0x45, 0x12, 0x0b, 0xe2, 0x16, 0x01, 0xa6, 0x2e, 0x44, - 0xea, 0x2a, 0xe3, 0x16, 0x01, 0x43, 0x0e, 0x0b, 0xdb, 0x16, 0x01, 0xb3, - 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xda, 0x16, 0x41, 0x44, 0x25, 0x01, - 0xdd, 0x16, 0x01, 0x42, 0x15, 0x02, 0xdc, 0x16, 0x41, 0x44, 0xe5, 0x1d, - 0xe1, 0x16, 0x01, 0x42, 0x1c, 0x26, 0xe0, 0x16, 0x41, 0x43, 0xd2, 0x05, - 0xdf, 0x16, 0x01, 0x43, 0xf6, 0x06, 0xde, 0x16, 0x41, 0x45, 0x12, 0x0b, - 0x48, 0x10, 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x49, 0x10, 0x00, 0x43, - 0x0e, 0x0b, 0x41, 0x10, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, + 0x22, 0x00, 0x18, 0x10, 0x40, 0x47, 0xed, 0xd7, 0x7a, 0xaa, 0x00, 0xf5, + 0x2a, 0x10, 0x40, 0x45, 0x7e, 0x0b, 0xe2, 0x16, 0x01, 0xa6, 0x2e, 0x44, + 0x6d, 0x2c, 0xe3, 0x16, 0x01, 0x43, 0x7a, 0x0b, 0xdb, 0x16, 0x01, 0xb3, + 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xda, 0x16, 0x41, 0x44, 0x25, 0x01, + 0xdd, 0x16, 0x01, 0x42, 0x15, 0x02, 0xdc, 0x16, 0x41, 0x44, 0x06, 0x1f, + 0xe1, 0x16, 0x01, 0x42, 0x09, 0x24, 0xe0, 0x16, 0x41, 0x43, 0xf9, 0x05, + 0xdf, 0x16, 0x01, 0x43, 0xf6, 0x06, 0xde, 0x16, 0x41, 0x45, 0x7e, 0x0b, + 0x48, 0x10, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x49, 0x10, 0x00, 0x43, + 0x7a, 0x0b, 0x41, 0x10, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x40, 0x10, 0x40, 0x44, 0x25, 0x01, 0x43, 0x10, 0x00, 0x42, 0x15, 0x02, - 0x42, 0x10, 0x40, 0x44, 0xe5, 0x1d, 0x47, 0x10, 0x00, 0x42, 0x1c, 0x26, - 0x46, 0x10, 0x40, 0x43, 0xd2, 0x05, 0x45, 0x10, 0x00, 0x43, 0xf6, 0x06, - 0x44, 0x10, 0x40, 0xad, 0x06, 0x4e, 0x22, 0x7c, 0x82, 0x10, 0x40, 0x06, - 0x68, 0x33, 0x17, 0x0a, 0xf0, 0xae, 0x01, 0xff, 0x42, 0x74, 0x00, 0x60, + 0x42, 0x10, 0x40, 0x44, 0x06, 0x1f, 0x47, 0x10, 0x00, 0x42, 0x09, 0x24, + 0x46, 0x10, 0x40, 0x43, 0xf9, 0x05, 0x45, 0x10, 0x00, 0x43, 0xf6, 0x06, + 0x44, 0x10, 0x40, 0xad, 0x06, 0x4e, 0xe8, 0x7f, 0x82, 0x10, 0x40, 0x06, + 0x19, 0x35, 0x17, 0x0a, 0x56, 0xb4, 0x01, 0xff, 0x42, 0x74, 0x00, 0x60, 0x10, 0x00, 0x42, 0x6c, 0x00, 0x5f, 0x10, 0x00, 0x42, 0x2a, 0x05, 0x5e, 0x10, 0x40, 0x42, 0x22, 0x00, 0x3e, 0x10, 0x00, 0x42, 0x71, 0x00, 0x3c, - 0x10, 0x00, 0x42, 0xa9, 0x01, 0x3d, 0x10, 0x00, 0x42, 0xbe, 0x22, 0x3b, - 0x10, 0x40, 0x03, 0x99, 0x21, 0x8d, 0x11, 0x02, 0xb8, 0x04, 0xb6, 0x0e, - 0xb3, 0x01, 0xff, 0x45, 0x42, 0xe7, 0x44, 0xf3, 0x81, 0xa5, 0x0e, 0x02, - 0x36, 0x00, 0x01, 0xff, 0x80, 0x8b, 0x0e, 0x03, 0x13, 0x00, 0x01, 0xff, - 0x48, 0x34, 0xa9, 0xb9, 0xf3, 0x81, 0xf8, 0x0d, 0x44, 0x24, 0x28, 0xb5, - 0xf3, 0x01, 0xb3, 0x01, 0xff, 0x44, 0x89, 0xef, 0xbc, 0xf3, 0x01, 0x06, - 0x60, 0x16, 0x01, 0xff, 0x0b, 0x58, 0x99, 0xd3, 0x0d, 0xa2, 0x86, 0x0d, - 0xa3, 0xe0, 0x0a, 0xa4, 0x8b, 0x0a, 0xa5, 0xd5, 0x09, 0xa6, 0xd2, 0x08, - 0xa7, 0x83, 0x08, 0x02, 0x22, 0x00, 0xe2, 0x07, 0x4d, 0x6d, 0x84, 0x98, - 0xd1, 0x01, 0xab, 0x81, 0x07, 0xac, 0xe2, 0x06, 0xad, 0x9c, 0x06, 0xae, - 0xf7, 0x05, 0xaf, 0x98, 0x05, 0xb0, 0xd5, 0x04, 0x02, 0x7c, 0x00, 0x9e, - 0x04, 0xb2, 0xe9, 0x03, 0xb3, 0xa4, 0x02, 0xb4, 0x30, 0xb6, 0x22, 0xb7, - 0x0a, 0x4a, 0x33, 0x64, 0x43, 0xd1, 0x01, 0xfa, 0x8e, 0xd1, 0x41, 0x05, - 0xa1, 0xb3, 0x06, 0x4f, 0x07, 0x6f, 0xb3, 0xd1, 0x41, 0x44, 0x24, 0x28, - 0x5d, 0xd1, 0x01, 0x44, 0x8f, 0x33, 0x3b, 0xd1, 0x41, 0x44, 0x7e, 0x07, - 0xd3, 0xd1, 0x01, 0x4c, 0x24, 0x93, 0x57, 0xd1, 0x41, 0x06, 0x62, 0xdb, - 0xb3, 0x01, 0xa8, 0x9a, 0x01, 0x47, 0x23, 0xd4, 0xd8, 0xd1, 0x81, 0x8c, - 0x01, 0xf2, 0x96, 0xd1, 0x81, 0x1c, 0x43, 0x5d, 0x01, 0x97, 0xd1, 0x81, - 0x06, 0x4d, 0xd3, 0x8a, 0x17, 0xd1, 0x41, 0x80, 0x01, 0xff, 0x45, 0x48, - 0x0e, 0x99, 0xd1, 0x01, 0x42, 0x50, 0x02, 0x9a, 0xd1, 0x41, 0x06, 0x03, - 0x02, 0x01, 0xff, 0x0a, 0xdb, 0x38, 0x11, 0x15, 0xd5, 0x38, 0x01, 0xff, - 0x45, 0x0c, 0x03, 0x55, 0xd1, 0x01, 0x45, 0xad, 0x02, 0x54, 0xd1, 0x41, - 0x05, 0x9e, 0x14, 0x41, 0x05, 0xc3, 0x00, 0x31, 0x06, 0xc8, 0x00, 0x21, - 0x03, 0x7d, 0x15, 0x01, 0xff, 0x45, 0x0c, 0x03, 0x49, 0xd1, 0x01, 0x06, - 0xc8, 0x00, 0x06, 0x45, 0xad, 0x02, 0x48, 0xd1, 0x41, 0x45, 0x0c, 0x03, - 0x51, 0xd1, 0x01, 0x45, 0xad, 0x02, 0x50, 0xd1, 0x41, 0x45, 0x0c, 0x03, - 0x4d, 0xd1, 0x01, 0x45, 0xad, 0x02, 0x4c, 0xd1, 0x41, 0x45, 0x0c, 0x03, - 0x4b, 0xd1, 0x01, 0x45, 0xad, 0x02, 0x4a, 0xd1, 0x41, 0x45, 0x0c, 0x03, - 0x4f, 0xd1, 0x01, 0x45, 0xad, 0x02, 0x4e, 0xd1, 0x41, 0x4a, 0x30, 0xa6, - 0xdc, 0xd1, 0x41, 0x0c, 0x84, 0x90, 0x06, 0x4e, 0xa4, 0x7b, 0x18, 0xd1, - 0x41, 0x44, 0x24, 0x28, 0x62, 0xd1, 0x01, 0x44, 0x8f, 0x33, 0x40, 0xd1, - 0x41, 0x1b, 0x0d, 0x1c, 0x18, 0x19, 0x0f, 0x1c, 0x01, 0xff, 0x4a, 0x9e, - 0x6e, 0xc8, 0xd1, 0x01, 0x48, 0xa0, 0x6e, 0xc7, 0xd1, 0xc1, 0x00, 0x4d, - 0x80, 0x7f, 0xc9, 0xd1, 0x41, 0x4a, 0x9e, 0x6e, 0xcb, 0xd1, 0x81, 0x06, - 0x48, 0xa0, 0x6e, 0xca, 0xd1, 0x41, 0x0c, 0x80, 0x7f, 0x01, 0xff, 0xd1, - 0xcc, 0xd1, 0x01, 0xd2, 0xcd, 0xd1, 0x01, 0xd3, 0xce, 0xd1, 0x41, 0x48, - 0xa1, 0xc4, 0xd6, 0xd1, 0x81, 0xb4, 0x01, 0xa5, 0x7a, 0xa8, 0x62, 0xa9, - 0x25, 0x43, 0x0c, 0x00, 0xe9, 0xd1, 0x01, 0x06, 0xd7, 0x24, 0x06, 0x45, - 0xcf, 0xeb, 0x8d, 0xd1, 0x41, 0xe2, 0xd2, 0xd1, 0x01, 0x09, 0xdc, 0x38, + 0x10, 0x00, 0x42, 0xa9, 0x01, 0x3d, 0x10, 0x00, 0x42, 0xdf, 0x23, 0x3b, + 0x10, 0x40, 0x03, 0xba, 0x22, 0xc4, 0x15, 0x02, 0xb8, 0x04, 0xed, 0x12, + 0xb3, 0x01, 0xff, 0x45, 0x14, 0xed, 0x44, 0xf3, 0x81, 0xdc, 0x12, 0x02, + 0x36, 0x00, 0x01, 0xff, 0x80, 0xc2, 0x12, 0x03, 0x13, 0x00, 0x01, 0xff, + 0x48, 0x72, 0xae, 0xb9, 0xf3, 0x81, 0xaf, 0x12, 0x44, 0x77, 0x29, 0xb5, + 0xf3, 0x01, 0xb3, 0x01, 0xff, 0x44, 0x4c, 0xf5, 0xbc, 0xf3, 0x01, 0x06, + 0x2e, 0x17, 0x01, 0xff, 0x0b, 0x4b, 0x9e, 0x83, 0x12, 0xa2, 0xb6, 0x11, + 0xa3, 0xaf, 0x0e, 0xa4, 0xd9, 0x0c, 0xa5, 0xa3, 0x0c, 0xa6, 0xdd, 0x0a, + 0xa7, 0xeb, 0x09, 0xa8, 0x94, 0x09, 0x4d, 0x75, 0x88, 0x98, 0xd1, 0x01, + 0xab, 0xb3, 0x08, 0xac, 0x8e, 0x08, 0xad, 0xc8, 0x07, 0xae, 0x9d, 0x07, + 0xaf, 0x8d, 0x06, 0xb0, 0xca, 0x05, 0x02, 0x7c, 0x00, 0x93, 0x05, 0xb2, + 0xad, 0x04, 0xb3, 0xc7, 0x02, 0xb4, 0x30, 0xb6, 0x22, 0xb7, 0x0a, 0x4a, + 0x30, 0x67, 0x43, 0xd1, 0x01, 0xfa, 0x8e, 0xd1, 0x41, 0x05, 0x1b, 0xb9, + 0x06, 0x4f, 0x24, 0x72, 0xb3, 0xd1, 0x41, 0x44, 0x77, 0x29, 0x5d, 0xd1, + 0x01, 0x44, 0xf5, 0x1e, 0x3b, 0xd1, 0x41, 0x44, 0x7e, 0x07, 0xd3, 0xd1, + 0x01, 0x4c, 0xe8, 0x97, 0x57, 0xd1, 0x41, 0x4d, 0x24, 0x84, 0x7e, 0xd2, + 0x01, 0x06, 0x2c, 0xe1, 0xd0, 0x01, 0xa8, 0xb7, 0x01, 0x47, 0xec, 0xd9, + 0xd8, 0xd1, 0x81, 0xa9, 0x01, 0xf2, 0x96, 0xd1, 0x81, 0x27, 0x43, 0x5d, + 0x01, 0x97, 0xd1, 0x81, 0x11, 0x02, 0x15, 0x02, 0x01, 0xff, 0x59, 0xf9, + 0x23, 0x53, 0xd2, 0x01, 0x4b, 0x5f, 0x7f, 0x17, 0xd1, 0x41, 0x80, 0x01, + 0xff, 0x45, 0xd6, 0x0e, 0x99, 0xd1, 0x01, 0x42, 0x50, 0x02, 0x9a, 0xd1, + 0x41, 0xa9, 0x01, 0xff, 0x03, 0x1c, 0x01, 0x06, 0x48, 0x9f, 0xcf, 0x60, + 0xd2, 0x41, 0x02, 0x68, 0x00, 0x06, 0x4c, 0x67, 0x58, 0x6b, 0xd2, 0x41, + 0x0a, 0xe3, 0x3a, 0x11, 0x15, 0xdd, 0x3a, 0x01, 0xff, 0x45, 0x0c, 0x03, + 0x55, 0xd1, 0x01, 0x45, 0xad, 0x02, 0x54, 0xd1, 0x41, 0x05, 0x6c, 0x15, + 0x41, 0x05, 0xc3, 0x00, 0x31, 0x06, 0xc8, 0x00, 0x21, 0x03, 0x4b, 0x16, + 0x01, 0xff, 0x45, 0x0c, 0x03, 0x49, 0xd1, 0x01, 0x06, 0xc8, 0x00, 0x06, + 0x45, 0xad, 0x02, 0x48, 0xd1, 0x41, 0x45, 0x0c, 0x03, 0x51, 0xd1, 0x01, + 0x45, 0xad, 0x02, 0x50, 0xd1, 0x41, 0x45, 0x0c, 0x03, 0x4d, 0xd1, 0x01, + 0x45, 0xad, 0x02, 0x4c, 0xd1, 0x41, 0x45, 0x0c, 0x03, 0x4b, 0xd1, 0x01, + 0x45, 0xad, 0x02, 0x4a, 0xd1, 0x41, 0x45, 0x0c, 0x03, 0x4f, 0xd1, 0x01, + 0x45, 0xad, 0x02, 0x4e, 0xd1, 0x41, 0x4a, 0x64, 0xab, 0xdc, 0xd1, 0x41, + 0x0c, 0x18, 0x95, 0x06, 0x4e, 0x5c, 0x7f, 0x18, 0xd1, 0x41, 0x44, 0x77, + 0x29, 0x62, 0xd1, 0x01, 0x44, 0xf5, 0x1e, 0x40, 0xd1, 0x41, 0x1b, 0x13, + 0x1d, 0x18, 0x19, 0x15, 0x1d, 0x01, 0xff, 0x4a, 0xbb, 0x71, 0xc8, 0xd1, + 0x01, 0x48, 0xbd, 0x71, 0xc7, 0xd1, 0xc1, 0x00, 0x4d, 0x54, 0x83, 0xc9, + 0xd1, 0x41, 0x4a, 0xbb, 0x71, 0xcb, 0xd1, 0x81, 0x06, 0x48, 0xbd, 0x71, + 0xca, 0xd1, 0x41, 0x0c, 0x54, 0x83, 0x01, 0xff, 0xd1, 0xcc, 0xd1, 0x01, + 0xd2, 0xcd, 0xd1, 0x01, 0xd3, 0xce, 0xd1, 0x41, 0x52, 0x67, 0x52, 0x72, + 0xd2, 0x01, 0x48, 0x2f, 0xca, 0xd6, 0xd1, 0x81, 0xcf, 0x01, 0xa5, 0x94, + 0x01, 0xa8, 0x76, 0xa9, 0x39, 0x43, 0x0c, 0x00, 0xe9, 0xd1, 0x01, 0x06, + 0x2a, 0x26, 0x14, 0xb5, 0x06, 0x4d, 0x5d, 0x8f, 0x63, 0xd2, 0x41, 0x44, + 0x24, 0xf5, 0x8d, 0xd1, 0x01, 0x48, 0x27, 0x82, 0x61, 0xd2, 0x41, 0xe2, + 0xd2, 0xd1, 0x01, 0x47, 0x6c, 0x58, 0x6d, 0xd2, 0x01, 0x09, 0xe4, 0x3a, 0x01, 0xff, 0x45, 0x0c, 0x03, 0x47, 0xd1, 0x01, 0x45, 0xad, 0x02, 0x46, - 0xd1, 0x41, 0x4c, 0xb8, 0x92, 0x00, 0xd1, 0x01, 0xb8, 0x01, 0xff, 0x8d, - 0x24, 0xb4, 0x01, 0xff, 0x06, 0x1f, 0x26, 0x11, 0x09, 0xa6, 0xc1, 0x01, - 0xff, 0x44, 0x24, 0x28, 0x63, 0xd1, 0x01, 0x44, 0x8f, 0x33, 0x41, 0xd1, - 0x41, 0x44, 0x24, 0x28, 0x61, 0xd1, 0x01, 0x44, 0x8f, 0x33, 0x3f, 0xd1, - 0x41, 0x4a, 0xa8, 0x7b, 0x1b, 0xd1, 0x01, 0x50, 0x9d, 0x67, 0x1c, 0xd1, - 0x41, 0x04, 0x18, 0xb1, 0x06, 0x4b, 0x14, 0xa1, 0x05, 0xd1, 0x41, 0x44, - 0xa5, 0x01, 0x31, 0xd1, 0x01, 0x42, 0x50, 0x02, 0x30, 0xd1, 0x41, 0x43, - 0x6a, 0x21, 0x0b, 0xd1, 0x01, 0x02, 0x7d, 0x02, 0x01, 0xff, 0x07, 0xca, - 0xcf, 0x17, 0x07, 0x6d, 0xd3, 0x01, 0xff, 0x45, 0x0c, 0x03, 0xbe, 0xd1, - 0x01, 0x44, 0x8f, 0x33, 0xc6, 0xd1, 0x01, 0x45, 0xad, 0x02, 0xbd, 0xd1, - 0x41, 0x45, 0x0c, 0x03, 0xba, 0xd1, 0x01, 0x44, 0x8f, 0x33, 0xc4, 0xd1, - 0x01, 0x45, 0xad, 0x02, 0xb9, 0xd1, 0x41, 0x47, 0x46, 0xcd, 0xdb, 0xd1, - 0x41, 0xa5, 0x0f, 0xa9, 0x01, 0xff, 0x4f, 0xae, 0x6d, 0x07, 0xd1, 0x01, - 0x49, 0x60, 0xbc, 0x8c, 0xd1, 0x41, 0x04, 0xfa, 0x6a, 0x06, 0x53, 0xca, - 0x4e, 0x03, 0xd1, 0x41, 0x45, 0x22, 0x0a, 0x08, 0xd1, 0x01, 0x0a, 0xbe, - 0xa9, 0x01, 0xff, 0xd1, 0x0d, 0xd1, 0x01, 0xd2, 0x0e, 0xd1, 0x01, 0xd3, - 0x0f, 0xd1, 0x41, 0x06, 0x06, 0x03, 0x11, 0x0b, 0xaf, 0x9d, 0x01, 0xff, - 0x44, 0x19, 0xef, 0x38, 0xd1, 0x01, 0x45, 0xcc, 0xe4, 0x39, 0xd1, 0x41, - 0x44, 0x24, 0x28, 0x5f, 0xd1, 0x01, 0x44, 0x8f, 0x33, 0x3d, 0xd1, 0x01, - 0x05, 0x56, 0x2d, 0x01, 0xff, 0x44, 0x4b, 0x3b, 0x33, 0xd1, 0x01, 0x45, - 0x16, 0xb1, 0x32, 0xd1, 0x41, 0x53, 0x42, 0x48, 0x56, 0xd1, 0x01, 0xa5, - 0x22, 0x44, 0x8d, 0xf0, 0x8f, 0xd1, 0x01, 0x4c, 0xa4, 0x91, 0x44, 0xd1, - 0x01, 0xaf, 0x01, 0xff, 0x45, 0x94, 0xe5, 0xd4, 0xd1, 0x01, 0x47, 0x96, - 0xd5, 0xd9, 0xd1, 0xc1, 0x00, 0x47, 0x46, 0xcd, 0xda, 0xd1, 0x41, 0x04, - 0x9c, 0xaf, 0x06, 0x4c, 0x1c, 0x95, 0xdd, 0xd1, 0x41, 0x44, 0xb9, 0x00, - 0xae, 0xd1, 0x01, 0x47, 0xf4, 0xd6, 0xaf, 0xd1, 0x41, 0x02, 0xcd, 0x05, - 0x42, 0x0f, 0xd6, 0x72, 0x11, 0x06, 0x5b, 0xc2, 0x01, 0xff, 0x44, 0x19, - 0xef, 0x36, 0xd1, 0x01, 0x45, 0xcc, 0xe4, 0x37, 0xd1, 0x41, 0xd1, 0x9b, - 0xd1, 0x81, 0x20, 0xd2, 0x9c, 0xd1, 0x01, 0xd3, 0x9d, 0xd1, 0x01, 0xd4, - 0x9e, 0xd1, 0x01, 0xd5, 0x9f, 0xd1, 0x01, 0xd6, 0xa0, 0xd1, 0x01, 0xd7, - 0xa1, 0xd1, 0x01, 0xd8, 0xa2, 0xd1, 0x01, 0xd9, 0xa3, 0xd1, 0x41, 0xd0, - 0xa4, 0xd1, 0x01, 0xd1, 0xa5, 0xd1, 0x41, 0x17, 0x90, 0x2c, 0x06, 0x4b, - 0xa7, 0x7b, 0x16, 0xd1, 0x41, 0x44, 0x24, 0x28, 0x64, 0xd1, 0x01, 0x44, - 0x8f, 0x33, 0x42, 0xd1, 0x41, 0x07, 0x7d, 0x92, 0x12, 0x4a, 0xb4, 0xa9, - 0xa7, 0xd1, 0x01, 0x4d, 0x45, 0x87, 0x58, 0xd1, 0x01, 0x4c, 0x78, 0x96, - 0x59, 0xd1, 0x41, 0x44, 0xa5, 0x01, 0x2f, 0xd1, 0x01, 0x42, 0x50, 0x02, - 0x2e, 0xd1, 0x41, 0x45, 0x61, 0xcf, 0xb6, 0xd1, 0x01, 0x44, 0xcd, 0xef, - 0x90, 0xd1, 0x01, 0x45, 0x6e, 0xd3, 0xbb, 0xd1, 0x81, 0x21, 0x0d, 0x2b, - 0x87, 0x11, 0x04, 0xb7, 0x04, 0x01, 0xff, 0x45, 0xe8, 0x65, 0x3a, 0xd1, - 0x01, 0x50, 0xdd, 0x65, 0x29, 0xd1, 0x41, 0x45, 0x0c, 0x03, 0x53, 0xd1, - 0x01, 0x45, 0xad, 0x02, 0x52, 0xd1, 0x41, 0x80, 0x01, 0xff, 0x45, 0x0c, - 0x03, 0xbc, 0xd1, 0x01, 0x44, 0x8f, 0x33, 0xc5, 0xd1, 0x41, 0x4f, 0xa0, - 0x6c, 0x06, 0xd1, 0x01, 0x44, 0xa9, 0x49, 0xb7, 0xd1, 0xc1, 0x00, 0x80, - 0x01, 0xff, 0x4f, 0x9e, 0x6e, 0xc2, 0xd1, 0x01, 0x4d, 0xa0, 0x6e, 0xc1, - 0xd1, 0x41, 0x06, 0xe8, 0xdc, 0x06, 0x44, 0xc8, 0x1c, 0xea, 0xd1, 0x41, - 0x46, 0x72, 0xda, 0xde, 0xd1, 0x01, 0xa5, 0x30, 0xa6, 0x22, 0x49, 0x7e, - 0xb9, 0xe3, 0xd1, 0x01, 0x12, 0xb6, 0x54, 0x0c, 0x4f, 0x5e, 0x72, 0xe1, - 0xd1, 0x01, 0x4a, 0xa0, 0xb3, 0xe2, 0xd1, 0x41, 0x44, 0xa5, 0x01, 0xe4, - 0xd1, 0x01, 0x42, 0x50, 0x02, 0xe5, 0xd1, 0x41, 0x49, 0x7a, 0xba, 0xe0, - 0xd1, 0x01, 0x48, 0x25, 0xb9, 0xe8, 0xd1, 0x41, 0x10, 0xcd, 0x63, 0x06, - 0x4b, 0x17, 0xa0, 0xdf, 0xd1, 0x41, 0x44, 0xa5, 0x01, 0xe6, 0xd1, 0x01, - 0x42, 0x50, 0x02, 0xe7, 0xd1, 0x41, 0x03, 0x24, 0x00, 0x06, 0x49, 0x8f, - 0xc0, 0xa6, 0xd1, 0x41, 0x44, 0x24, 0x28, 0x5e, 0xd1, 0x01, 0x4a, 0x9a, - 0xaf, 0xb0, 0xd1, 0x01, 0x44, 0x8f, 0x33, 0x3c, 0xd1, 0x41, 0x45, 0x2a, - 0xbf, 0x1e, 0xd1, 0x81, 0x34, 0x09, 0x9a, 0xbb, 0x24, 0xb2, 0x01, 0xff, - 0x09, 0xb2, 0xb5, 0x11, 0x08, 0xa1, 0xc5, 0x01, 0xff, 0x46, 0x72, 0xda, - 0xd0, 0xd1, 0x01, 0x46, 0xc8, 0xdb, 0xd1, 0xd1, 0x41, 0x48, 0xe9, 0xc8, - 0x95, 0xd1, 0x01, 0x45, 0x48, 0x0e, 0x94, 0xd1, 0x41, 0x44, 0xa5, 0x01, - 0xb2, 0xd1, 0x01, 0x42, 0x50, 0x02, 0xb1, 0xd1, 0x41, 0x08, 0x59, 0xc2, - 0x01, 0xff, 0x44, 0x19, 0xef, 0x1f, 0xd1, 0x01, 0x45, 0xcc, 0xe4, 0x20, - 0xd1, 0x41, 0x45, 0x2a, 0xbf, 0x22, 0xd1, 0x81, 0x68, 0x46, 0x80, 0xdb, - 0x10, 0xd1, 0x81, 0x5b, 0xa9, 0x3a, 0x04, 0x25, 0xb9, 0x2a, 0xaf, 0x11, - 0x04, 0x09, 0xf3, 0x01, 0xff, 0x45, 0x0c, 0x03, 0xc0, 0xd1, 0x01, 0x45, - 0xad, 0x02, 0xbf, 0xd1, 0x41, 0x43, 0x2d, 0x01, 0x91, 0xd1, 0x01, 0x03, - 0xa1, 0xc0, 0x01, 0xff, 0x4a, 0xa8, 0x7b, 0x19, 0xd1, 0x01, 0x50, 0x9d, - 0x67, 0x1d, 0xd1, 0x41, 0x44, 0xa5, 0x01, 0x2d, 0xd1, 0x01, 0x42, 0x50, - 0x02, 0x2c, 0xd1, 0x41, 0xae, 0x06, 0x4d, 0x03, 0x8a, 0x1a, 0xd1, 0x41, - 0x4a, 0xd3, 0x4e, 0x02, 0xd1, 0x01, 0x0e, 0x16, 0x78, 0x01, 0xff, 0xd1, - 0x6a, 0xd1, 0x01, 0xd2, 0x6b, 0xd1, 0x01, 0xd3, 0x6c, 0xd1, 0x41, 0x46, - 0x1f, 0x07, 0x11, 0xd1, 0x41, 0x08, 0x59, 0xc2, 0x01, 0xff, 0x44, 0x19, - 0xef, 0x23, 0xd1, 0x01, 0x45, 0xcc, 0xe4, 0x24, 0xd1, 0x41, 0x06, 0x13, - 0x0b, 0x23, 0x03, 0x1b, 0x00, 0x01, 0xff, 0x44, 0xba, 0xbd, 0x74, 0xd1, - 0x01, 0x49, 0x02, 0xbd, 0xa8, 0xd1, 0x01, 0x46, 0xb2, 0x35, 0x7a, 0xd1, - 0x01, 0x44, 0xd5, 0xf2, 0x78, 0xd1, 0x01, 0x43, 0xf3, 0x25, 0x76, 0xd1, - 0x41, 0x44, 0x24, 0x28, 0x60, 0xd1, 0x01, 0x44, 0x8f, 0x33, 0x3e, 0xd1, - 0x41, 0xa1, 0x31, 0xa5, 0x23, 0x06, 0x3c, 0x01, 0x0d, 0x09, 0x27, 0xbf, - 0x01, 0xff, 0xd1, 0x25, 0xd1, 0x01, 0xd2, 0x26, 0xd1, 0x41, 0x47, 0xd6, - 0x4e, 0x01, 0xd1, 0x01, 0x44, 0x4b, 0x3b, 0x2b, 0xd1, 0x01, 0x45, 0x16, - 0xb1, 0x2a, 0xd1, 0x41, 0x49, 0x98, 0xb7, 0x93, 0xd1, 0x01, 0x4a, 0x12, - 0xab, 0xa9, 0xd1, 0x41, 0x45, 0xbb, 0xe1, 0x0a, 0xd1, 0x01, 0x47, 0xb7, - 0xd2, 0x09, 0xd1, 0x01, 0x42, 0x0e, 0x1c, 0xb4, 0xd1, 0x81, 0x06, 0x4c, - 0x4c, 0x95, 0x04, 0xd1, 0x41, 0x44, 0xd8, 0x2d, 0xb5, 0xd1, 0x41, 0x45, - 0x2a, 0xbf, 0x21, 0xd1, 0x01, 0x46, 0xa0, 0xd9, 0x13, 0xd1, 0x01, 0x50, - 0x2d, 0x64, 0x45, 0xd1, 0x01, 0xac, 0xef, 0x01, 0xaf, 0x14, 0xb2, 0x06, - 0x47, 0x2c, 0xd7, 0x35, 0xd1, 0x41, 0x47, 0x9a, 0xb7, 0x92, 0xd1, 0x01, - 0x43, 0xa3, 0xf4, 0xcf, 0xd1, 0x41, 0x42, 0xf0, 0x10, 0x0c, 0xd1, 0x01, - 0xad, 0x01, 0xff, 0x07, 0x35, 0x16, 0x06, 0x48, 0x81, 0xc8, 0x34, 0xd1, - 0x41, 0xa1, 0xb0, 0x01, 0x44, 0xd5, 0x9a, 0x89, 0xd1, 0x01, 0x02, 0x3b, - 0x01, 0x93, 0x01, 0x02, 0xd5, 0x04, 0x71, 0x48, 0xc9, 0xc6, 0xac, 0xd1, - 0x01, 0x45, 0x5f, 0xe8, 0x82, 0xd1, 0x01, 0x47, 0x43, 0xd3, 0x7f, 0xd1, - 0x81, 0x58, 0x43, 0x76, 0x06, 0x86, 0xd1, 0x01, 0xb3, 0x27, 0xb4, 0x06, - 0x46, 0x14, 0xe1, 0xab, 0xd1, 0x41, 0x45, 0x45, 0x7d, 0x7d, 0xd1, 0x01, - 0xb2, 0x01, 0xff, 0x06, 0x1e, 0x78, 0x06, 0x4b, 0xba, 0x9d, 0x8b, 0xd1, - 0x41, 0xd1, 0x67, 0xd1, 0x01, 0xd2, 0x68, 0xd1, 0x01, 0xd3, 0x69, 0xd1, - 0x41, 0x44, 0x9f, 0xa9, 0x88, 0xd1, 0x01, 0x4d, 0x5b, 0x86, 0xad, 0xd1, - 0x01, 0x50, 0x0d, 0x66, 0x66, 0xd1, 0x01, 0xb4, 0x01, 0xff, 0x05, 0x52, - 0xb5, 0x06, 0x42, 0xb5, 0x05, 0x65, 0xd1, 0x41, 0x46, 0x42, 0xdd, 0x7e, - 0xd1, 0x01, 0xef, 0x7c, 0xd1, 0x41, 0x49, 0x4f, 0xb5, 0x80, 0xd1, 0x41, - 0x03, 0xae, 0x57, 0x06, 0x42, 0xba, 0x04, 0x87, 0xd1, 0x41, 0xd1, 0x6e, - 0xd1, 0x01, 0xd2, 0x6f, 0xd1, 0x01, 0xd3, 0x70, 0xd1, 0x01, 0xd4, 0x71, - 0xd1, 0x01, 0xd5, 0x72, 0xd1, 0x41, 0x42, 0x52, 0x00, 0x85, 0xd1, 0x01, - 0x4b, 0x37, 0xa4, 0x8a, 0xd1, 0x01, 0x46, 0x62, 0xe1, 0xaa, 0xd1, 0x41, - 0x45, 0xdb, 0x04, 0x7b, 0xd1, 0x81, 0x06, 0x4f, 0x3e, 0x74, 0x6d, 0xd1, - 0x41, 0x49, 0x4f, 0xb5, 0x81, 0xd1, 0x41, 0xa9, 0x11, 0x0f, 0x7a, 0x74, - 0x01, 0xff, 0x45, 0x0c, 0x03, 0x5b, 0xd1, 0x01, 0x45, 0xad, 0x02, 0x5a, - 0xd1, 0x41, 0x45, 0x7d, 0xe8, 0xd7, 0xd1, 0x01, 0x43, 0xdf, 0x32, 0xd5, - 0xd1, 0x41, 0x05, 0xb9, 0x3f, 0x2e, 0xb2, 0x01, 0xff, 0x02, 0x0e, 0x03, - 0x1d, 0xa5, 0x01, 0xff, 0x48, 0xe9, 0xc3, 0x12, 0xd1, 0x01, 0xb6, 0x01, - 0xff, 0xe5, 0x5c, 0xd1, 0x01, 0x42, 0x5f, 0x03, 0xb8, 0xd1, 0xc1, 0x00, - 0x45, 0xe8, 0x65, 0xc3, 0xd1, 0x41, 0xe5, 0x14, 0xd1, 0x01, 0x43, 0x67, - 0x09, 0x15, 0xd1, 0x41, 0x44, 0xba, 0xbd, 0x73, 0xd1, 0x01, 0x46, 0xb2, - 0x35, 0x79, 0xd1, 0x01, 0x44, 0xd5, 0xf2, 0x77, 0xd1, 0x01, 0x43, 0xf3, - 0x25, 0x75, 0xd1, 0x41, 0x44, 0xa5, 0x01, 0x84, 0xd1, 0x01, 0x42, 0x50, - 0x02, 0x83, 0xd1, 0x41, 0x4b, 0x2f, 0x98, 0x98, 0xf3, 0x41, 0x49, 0x24, - 0xb9, 0x6d, 0x26, 0x00, 0x4c, 0x7c, 0x92, 0x6e, 0x26, 0x00, 0x4a, 0x16, - 0xb1, 0x6f, 0x26, 0x40, 0x46, 0x2b, 0x69, 0x64, 0xcc, 0x41, 0x04, 0x31, - 0x9c, 0x69, 0xa9, 0x01, 0xff, 0x43, 0xf6, 0x6b, 0xb8, 0x22, 0x00, 0x02, - 0xbb, 0x04, 0x16, 0x43, 0x9c, 0x12, 0x8c, 0x22, 0xc0, 0x00, 0x80, 0x01, - 0xff, 0x4e, 0x17, 0x25, 0x8d, 0x22, 0x00, 0x45, 0x4d, 0x17, 0x8e, 0x22, - 0x40, 0x4f, 0x82, 0x6c, 0xb6, 0xf3, 0x01, 0x08, 0xbd, 0x04, 0x01, 0xff, - 0x44, 0x5a, 0x03, 0xd7, 0x00, 0x80, 0x04, 0xf8, 0x15, 0x27, 0x40, 0x80, - 0x01, 0xff, 0x03, 0xe1, 0x05, 0x11, 0x05, 0x51, 0x00, 0x01, 0xff, 0x49, - 0x56, 0x1e, 0x30, 0x2a, 0x00, 0x48, 0xea, 0x59, 0x31, 0x2a, 0x40, 0x4d, - 0x24, 0x82, 0x37, 0x2a, 0x00, 0x50, 0x8d, 0x64, 0x34, 0x2a, 0x00, 0x51, - 0xaa, 0x5d, 0x35, 0x2a, 0x00, 0x48, 0x01, 0x02, 0x3b, 0x2a, 0x40, 0x07, - 0xec, 0x05, 0x06, 0x4c, 0x13, 0x27, 0xa9, 0x12, 0x41, 0xe1, 0x80, 0x12, - 0x01, 0xa2, 0xca, 0x01, 0xa3, 0xbd, 0x01, 0xa4, 0x9e, 0x01, 0xe5, 0x83, - 0x12, 0x01, 0xa7, 0x8d, 0x01, 0x42, 0x22, 0x00, 0xa6, 0x12, 0x01, 0xe9, - 0x81, 0x12, 0x01, 0xaa, 0x77, 0xab, 0x6b, 0x42, 0x74, 0x00, 0xa3, 0x12, - 0x01, 0x42, 0x6c, 0x00, 0xa0, 0x12, 0x01, 0xae, 0x4d, 0xb0, 0x41, 0xb2, - 0x2f, 0x42, 0x40, 0x06, 0xa5, 0x12, 0x01, 0xb4, 0x10, 0xf5, 0x82, 0x12, - 0x01, 0x42, 0xf5, 0x0a, 0xa4, 0x12, 0x01, 0x42, 0xbe, 0x22, 0xa1, 0x12, - 0x41, 0xe1, 0x96, 0x12, 0x01, 0x42, 0x22, 0x00, 0x97, 0x12, 0x01, 0xb4, - 0x01, 0xff, 0xe1, 0x90, 0x12, 0x01, 0x42, 0x22, 0x00, 0x91, 0x12, 0x41, - 0xe1, 0xa2, 0x12, 0x01, 0x42, 0x22, 0x00, 0xa8, 0x12, 0x01, 0x42, 0x71, - 0x00, 0xa7, 0x12, 0x41, 0xe1, 0x9b, 0x12, 0x01, 0x42, 0x22, 0x00, 0x9c, - 0x12, 0x41, 0xe1, 0x9a, 0x12, 0x01, 0x42, 0x2a, 0x05, 0x95, 0x12, 0x01, - 0x42, 0xbe, 0x22, 0x8f, 0x12, 0x41, 0xe1, 0x84, 0x12, 0x01, 0x42, 0x22, - 0x00, 0x85, 0x12, 0x41, 0xe1, 0x8c, 0x12, 0x01, 0x42, 0x72, 0x19, 0x8d, - 0x12, 0x41, 0xe1, 0x86, 0x12, 0x01, 0x42, 0x22, 0x00, 0x88, 0x12, 0x41, - 0xe1, 0x98, 0x12, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x99, 0x12, 0x41, - 0xe1, 0x92, 0x12, 0x01, 0x42, 0xf0, 0x10, 0x93, 0x12, 0x01, 0x42, 0x22, - 0x00, 0x94, 0x12, 0x41, 0xe1, 0x8a, 0x12, 0x01, 0x42, 0x22, 0x00, 0x8b, - 0x12, 0x41, 0xe1, 0x9d, 0x12, 0x01, 0x42, 0x22, 0x00, 0x9f, 0x12, 0x41, - 0x4c, 0x87, 0x00, 0x6b, 0x22, 0x00, 0x49, 0xec, 0x00, 0x6a, 0x22, 0x40, - 0xa4, 0xb8, 0x01, 0x07, 0xec, 0x05, 0x01, 0xff, 0xe1, 0x46, 0x6a, 0x01, - 0x42, 0x16, 0x00, 0x44, 0x6a, 0x01, 0x43, 0x8b, 0x38, 0x4b, 0x6a, 0x01, - 0x42, 0xf0, 0x10, 0x45, 0x6a, 0x81, 0x97, 0x01, 0xe5, 0x58, 0x6a, 0x81, - 0x8d, 0x01, 0x02, 0x22, 0x00, 0x80, 0x01, 0xab, 0x6e, 0x42, 0x74, 0x00, - 0x5b, 0x6a, 0x81, 0x63, 0xad, 0x55, 0xae, 0x47, 0xef, 0x52, 0x6a, 0x81, - 0x3a, 0xb0, 0x2e, 0xb2, 0x24, 0x43, 0xa3, 0x0c, 0x54, 0x6a, 0x01, 0xb4, - 0x0c, 0x42, 0xa9, 0x01, 0x57, 0x6a, 0x01, 0x42, 0xb0, 0x47, 0x42, 0x6a, - 0x41, 0xe1, 0x40, 0x6a, 0x01, 0x42, 0xf1, 0x18, 0x5e, 0x6a, 0x01, 0x43, - 0xe6, 0x01, 0x55, 0x6a, 0x41, 0xe9, 0x5d, 0x6a, 0x01, 0xef, 0x53, 0x6a, - 0x41, 0xe1, 0x50, 0x6a, 0x01, 0x42, 0x49, 0x00, 0x47, 0x6a, 0x41, 0xec, - 0x4d, 0x6a, 0x01, 0xef, 0x51, 0x6a, 0x41, 0x42, 0xf1, 0x06, 0x41, 0x6a, - 0x01, 0x42, 0x9e, 0x01, 0x4f, 0x6a, 0x41, 0x43, 0x76, 0x87, 0x4e, 0x6a, - 0x01, 0x42, 0x29, 0x02, 0x43, 0x6a, 0x41, 0xee, 0x5a, 0x6a, 0x41, 0x44, - 0xb5, 0xef, 0x4c, 0x6a, 0x01, 0x43, 0x1c, 0x52, 0x48, 0x6a, 0x01, 0xef, - 0x59, 0x6a, 0x41, 0xe9, 0x5c, 0x6a, 0x01, 0xef, 0x49, 0x6a, 0x41, 0xe1, - 0x56, 0x6a, 0x41, 0xe9, 0x4a, 0x6a, 0x41, 0x44, 0x75, 0x20, 0x6e, 0x6a, - 0x01, 0x05, 0xf0, 0x06, 0x06, 0x4b, 0x2a, 0xa1, 0x6f, 0x6a, 0x41, 0x45, - 0x12, 0x0b, 0x68, 0x6a, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x69, 0x6a, - 0x01, 0x43, 0x0e, 0x0b, 0x61, 0x6a, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, - 0x5f, 0x1e, 0x60, 0x6a, 0x41, 0x44, 0x25, 0x01, 0x63, 0x6a, 0x01, 0x42, - 0x15, 0x02, 0x62, 0x6a, 0x41, 0x44, 0xe5, 0x1d, 0x67, 0x6a, 0x01, 0x42, - 0x1c, 0x26, 0x66, 0x6a, 0x41, 0x43, 0xd2, 0x05, 0x65, 0x6a, 0x01, 0x43, - 0xf6, 0x06, 0x64, 0x6a, 0x41, 0x4a, 0x56, 0x4b, 0xf1, 0xf4, 0x81, 0x86, - 0x1f, 0xa4, 0xcb, 0x0a, 0xae, 0xaa, 0x01, 0xaf, 0x85, 0x01, 0x03, 0xd6, - 0x05, 0x77, 0xb4, 0x50, 0xb5, 0x0c, 0x4a, 0x6e, 0xb3, 0xa5, 0xf3, 0x01, - 0x43, 0x92, 0x78, 0xff, 0xf5, 0x41, 0x02, 0x11, 0x00, 0x1c, 0x42, 0x46, - 0x03, 0x01, 0xf4, 0x81, 0x06, 0x42, 0x53, 0x00, 0x44, 0xf4, 0x41, 0x80, - 0x01, 0xff, 0x44, 0x0c, 0x08, 0x2d, 0xf4, 0x01, 0x44, 0xcc, 0xe0, 0xa4, - 0xfa, 0x41, 0x45, 0xcf, 0xe1, 0xfb, 0xf5, 0x01, 0x43, 0x56, 0x07, 0xf0, - 0x26, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x49, 0xc0, 0xb6, 0xb5, 0xf6, 0x01, - 0x48, 0x91, 0xc4, 0xa0, 0xf6, 0x01, 0x47, 0xd0, 0x71, 0x9e, 0xf6, 0x41, - 0x4d, 0xf5, 0x7c, 0x36, 0xf9, 0x01, 0x02, 0x0c, 0x00, 0x01, 0xff, 0x80, - 0x0c, 0x4f, 0x16, 0x6f, 0xbc, 0xf9, 0x01, 0x43, 0x06, 0x20, 0xe3, 0xf6, - 0x41, 0x44, 0xf6, 0xdc, 0xe5, 0xf6, 0x01, 0x47, 0xd5, 0xd5, 0xf5, 0xf6, - 0x41, 0xe5, 0x4c, 0xf5, 0x01, 0x43, 0xc6, 0x07, 0x9f, 0xf9, 0x41, 0x48, - 0x09, 0xc5, 0xf0, 0xf5, 0x01, 0x02, 0x92, 0x00, 0x06, 0x42, 0x46, 0x03, - 0xce, 0xfa, 0x41, 0x44, 0x7a, 0x2c, 0x6e, 0xf9, 0x01, 0x46, 0xba, 0xdd, - 0xf5, 0xcd, 0x01, 0x50, 0x7d, 0x68, 0x91, 0xf3, 0x41, 0x02, 0xe2, 0x1c, - 0x85, 0x09, 0x07, 0x75, 0xd1, 0x35, 0x43, 0x0b, 0x24, 0x12, 0xf4, 0x81, - 0x28, 0xaf, 0x01, 0xff, 0x09, 0x27, 0x96, 0x0c, 0x44, 0x6a, 0x4c, 0x9d, - 0xf6, 0x01, 0x4d, 0x0c, 0x89, 0x8d, 0x23, 0x40, 0x45, 0x59, 0x72, 0x00, - 0xd3, 0x01, 0xb9, 0x01, 0xff, 0x43, 0x1c, 0x01, 0x8a, 0x26, 0x00, 0x42, - 0x9e, 0x01, 0x8b, 0x26, 0x40, 0x45, 0x0b, 0x08, 0x35, 0xf4, 0x41, 0x45, - 0x7d, 0x07, 0x00, 0x18, 0x80, 0xb3, 0x08, 0x02, 0x13, 0x05, 0xa2, 0x08, - 0xa4, 0xd3, 0x07, 0x48, 0xe9, 0x29, 0x01, 0x18, 0x00, 0xa6, 0x9f, 0x07, - 0x4e, 0xbe, 0x78, 0x67, 0x16, 0x81, 0x91, 0x07, 0x07, 0xec, 0x05, 0x68, - 0x07, 0x3c, 0xd3, 0x58, 0x46, 0x6e, 0xde, 0x0a, 0x18, 0x00, 0x4d, 0x22, - 0x88, 0x61, 0x16, 0x81, 0x3a, 0xb3, 0x1a, 0xb4, 0x06, 0x4f, 0x98, 0x74, - 0x0e, 0x18, 0x40, 0x4f, 0x05, 0x71, 0x06, 0x18, 0x00, 0x59, 0x2a, 0x26, - 0x63, 0x16, 0x01, 0x66, 0x71, 0x07, 0x6c, 0x16, 0x41, 0x5c, 0x32, 0x18, - 0x07, 0x18, 0x00, 0x4a, 0x78, 0x07, 0x69, 0x16, 0xc1, 0x00, 0x06, 0x50, - 0x00, 0x01, 0xff, 0x4f, 0x88, 0x07, 0x6b, 0x16, 0x01, 0x48, 0x28, 0x05, - 0x6a, 0x16, 0x41, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4f, 0x88, 0x07, 0x66, - 0x16, 0x01, 0x48, 0x28, 0x05, 0x65, 0x16, 0x41, 0x45, 0x13, 0x05, 0x08, - 0x18, 0x00, 0x49, 0x81, 0x16, 0x09, 0x18, 0x40, 0xe1, 0x20, 0x18, 0x80, - 0xef, 0x04, 0x42, 0x16, 0x00, 0x2a, 0x18, 0x00, 0x02, 0x6d, 0x14, 0xd5, - 0x04, 0x42, 0xf0, 0x10, 0x33, 0x18, 0x00, 0xe5, 0x21, 0x18, 0x80, 0xc5, - 0x04, 0x42, 0x0c, 0x08, 0x39, 0x18, 0x00, 0x42, 0x24, 0x02, 0x2d, 0x18, - 0x00, 0x43, 0x42, 0x41, 0x3e, 0x18, 0x00, 0xe9, 0x22, 0x18, 0x00, 0x42, - 0x72, 0x19, 0x35, 0x18, 0x00, 0xab, 0x9c, 0x04, 0xac, 0x8f, 0x04, 0x42, - 0x6c, 0x00, 0x2e, 0x18, 0x80, 0x8b, 0x03, 0x42, 0x2a, 0x05, 0x28, 0x18, - 0x00, 0xef, 0x23, 0x18, 0x80, 0xfb, 0x02, 0x42, 0xbb, 0x09, 0x2b, 0x18, - 0x00, 0x42, 0x43, 0x14, 0x2c, 0x18, 0x00, 0x42, 0x71, 0x00, 0x37, 0x18, - 0x00, 0xb3, 0xdc, 0x01, 0xb4, 0x28, 0xf5, 0x24, 0x18, 0x80, 0x1f, 0x42, - 0xa9, 0x01, 0x38, 0x18, 0x00, 0x42, 0xbe, 0x22, 0x36, 0x18, 0x00, 0xba, - 0x01, 0xff, 0xe1, 0x3d, 0x18, 0x00, 0x42, 0x49, 0x00, 0x41, 0x18, 0x00, - 0x42, 0x71, 0x00, 0x3f, 0x18, 0x40, 0xe5, 0x26, 0x18, 0x40, 0xe1, 0x32, - 0x18, 0x00, 0x04, 0x05, 0x71, 0x06, 0x42, 0x40, 0x06, 0x3c, 0x18, 0x40, - 0xa1, 0x8b, 0x01, 0x42, 0x16, 0x00, 0x4b, 0x18, 0x00, 0x43, 0xe6, 0x17, - 0x52, 0x18, 0x00, 0xa4, 0x73, 0xe5, 0x44, 0x18, 0x00, 0x42, 0x24, 0x02, - 0x4e, 0x18, 0x80, 0x64, 0x43, 0x42, 0x41, 0x59, 0x18, 0x00, 0xe9, 0x45, - 0x18, 0x00, 0xaa, 0x4e, 0x42, 0x1b, 0x02, 0x57, 0x18, 0x00, 0x4f, 0xf7, - 0x6f, 0x43, 0x18, 0x00, 0x42, 0x6c, 0x00, 0x4f, 0x18, 0x00, 0x43, 0x4a, - 0x07, 0x5b, 0x18, 0x00, 0xef, 0x46, 0x18, 0x80, 0x2d, 0x42, 0xbb, 0x09, - 0x4c, 0x18, 0x00, 0x42, 0x43, 0x14, 0x4d, 0x18, 0x00, 0xb4, 0x15, 0xf5, - 0x47, 0x18, 0x80, 0x0c, 0x42, 0xa9, 0x01, 0x56, 0x18, 0x00, 0x42, 0xbe, - 0x22, 0x55, 0x18, 0x40, 0xe5, 0x49, 0x18, 0x40, 0xe1, 0x50, 0x18, 0x00, - 0x42, 0x40, 0x06, 0x54, 0x18, 0x40, 0xe5, 0x48, 0x18, 0x40, 0xe1, 0x53, - 0x18, 0x00, 0x42, 0x1b, 0x01, 0x5a, 0x18, 0x40, 0xe1, 0x58, 0x18, 0x40, - 0xe1, 0x51, 0x18, 0x00, 0x42, 0x59, 0x00, 0x5c, 0x18, 0x40, 0x08, 0x16, - 0xb6, 0x06, 0x42, 0x1d, 0x01, 0x4a, 0x18, 0x40, 0x42, 0x12, 0x00, 0x98, - 0x18, 0x00, 0x43, 0xec, 0xc0, 0x99, 0x18, 0x40, 0xe1, 0x30, 0x18, 0x00, - 0x42, 0x22, 0x00, 0x31, 0x18, 0x00, 0x04, 0x32, 0x18, 0x01, 0xff, 0x43, - 0x1c, 0x01, 0x62, 0x18, 0x00, 0x43, 0xe6, 0x17, 0x71, 0x18, 0x00, 0x42, - 0xf0, 0x10, 0x69, 0x18, 0x00, 0xe5, 0x5d, 0x18, 0x00, 0x42, 0x0c, 0x08, - 0x6b, 0x18, 0x00, 0x42, 0x24, 0x02, 0x64, 0x18, 0x80, 0x54, 0x42, 0x22, - 0x00, 0x65, 0x18, 0x80, 0x49, 0xe9, 0x5e, 0x18, 0x80, 0x40, 0x42, 0x72, - 0x19, 0x6a, 0x18, 0x00, 0x42, 0x1b, 0x02, 0x63, 0x18, 0x00, 0x42, 0xbb, - 0x09, 0x66, 0x18, 0x00, 0x43, 0xb0, 0x95, 0x70, 0x18, 0x00, 0x43, 0xa4, - 0x02, 0x67, 0x18, 0x00, 0xb4, 0x16, 0xf5, 0x61, 0x18, 0x80, 0x0d, 0xba, - 0x01, 0xff, 0xe1, 0x6f, 0x18, 0x00, 0x42, 0x22, 0x00, 0x72, 0x18, 0x40, - 0xe5, 0x60, 0x18, 0x40, 0xe1, 0x68, 0x18, 0x00, 0x42, 0x40, 0x06, 0x6e, - 0x18, 0x40, 0xf9, 0x5f, 0x18, 0x40, 0xe1, 0x6d, 0x18, 0x40, 0xe1, 0x6c, - 0x18, 0x40, 0xe5, 0x25, 0x18, 0x40, 0x05, 0x3e, 0xd3, 0x01, 0xff, 0x09, - 0x15, 0xb6, 0x1c, 0x42, 0x0c, 0x08, 0x76, 0x18, 0x00, 0xe9, 0x73, 0x18, - 0x00, 0x42, 0x1b, 0x02, 0x74, 0x18, 0x00, 0x42, 0x71, 0x00, 0x75, 0x18, - 0x00, 0x43, 0xec, 0xc0, 0x77, 0x18, 0x40, 0x43, 0xf4, 0x2a, 0xa8, 0x18, - 0x00, 0xa3, 0x45, 0xa4, 0x37, 0x43, 0x2f, 0x9c, 0x9a, 0x18, 0x00, 0x43, - 0xa3, 0x45, 0x9d, 0x18, 0x00, 0x43, 0x2a, 0x09, 0xaa, 0x18, 0x00, 0x43, - 0x40, 0x48, 0x9b, 0x18, 0x00, 0x43, 0xfd, 0x20, 0xa2, 0x18, 0x00, 0xb4, - 0x0d, 0xba, 0x01, 0xff, 0xe1, 0xa5, 0x18, 0x00, 0x42, 0x22, 0x00, 0xa4, - 0x18, 0x40, 0xe1, 0xa0, 0x18, 0x00, 0x42, 0x12, 0x00, 0x9e, 0x18, 0x40, - 0x43, 0xee, 0x4b, 0x9f, 0x18, 0x00, 0x42, 0x22, 0x00, 0xa1, 0x18, 0x40, - 0xe1, 0x9c, 0x18, 0x00, 0x42, 0xbe, 0x22, 0xa3, 0x18, 0x40, 0xe1, 0x2f, - 0x18, 0x00, 0x42, 0x22, 0x00, 0x40, 0x18, 0x40, 0xe1, 0x3a, 0x18, 0x00, - 0x42, 0x22, 0x00, 0x3b, 0x18, 0x40, 0xe5, 0x27, 0x18, 0x40, 0xe1, 0x34, - 0x18, 0x80, 0x04, 0xe9, 0x42, 0x18, 0x40, 0x4e, 0xf8, 0x19, 0x78, 0x18, - 0x40, 0x08, 0x16, 0xb6, 0x06, 0x42, 0x1d, 0x01, 0x29, 0x18, 0x40, 0xe1, - 0x87, 0x18, 0x80, 0x96, 0x01, 0x46, 0x46, 0x9d, 0x85, 0x18, 0x00, 0x42, - 0x37, 0x00, 0x8b, 0x18, 0x00, 0xa4, 0x71, 0x05, 0x22, 0x00, 0x63, 0xe9, - 0x88, 0x18, 0x80, 0x58, 0x42, 0x1b, 0x02, 0x89, 0x18, 0x00, 0xae, 0x44, - 0xb0, 0x38, 0x43, 0xfd, 0x20, 0x94, 0x18, 0x00, 0xb4, 0x19, 0x47, 0xef, - 0x70, 0x83, 0x18, 0x00, 0x4b, 0xfd, 0xa4, 0x81, 0x18, 0x00, 0xba, 0x01, - 0xff, 0xe1, 0x96, 0x18, 0x00, 0x42, 0x22, 0x00, 0x95, 0x18, 0x40, 0xe1, - 0x90, 0x18, 0x00, 0x4b, 0x41, 0x9d, 0x86, 0x18, 0x00, 0xb4, 0x01, 0xff, - 0xe1, 0x8c, 0x18, 0x00, 0x42, 0x22, 0x00, 0x8d, 0x18, 0x40, 0xe1, 0x92, - 0x18, 0x00, 0x42, 0x22, 0x00, 0x93, 0x18, 0x40, 0x42, 0x24, 0x02, 0x8a, - 0x18, 0x00, 0x42, 0x2a, 0x05, 0x8f, 0x18, 0x40, 0x4f, 0xe7, 0x70, 0x84, - 0x18, 0x40, 0xf5, 0xa6, 0x18, 0x00, 0x42, 0xbe, 0x22, 0xa7, 0x18, 0x40, - 0xe1, 0x91, 0x18, 0x80, 0x06, 0x42, 0xf0, 0x10, 0x8e, 0x18, 0x40, 0x45, - 0xa7, 0xe6, 0xa9, 0x18, 0x00, 0x44, 0x41, 0xf1, 0x82, 0x18, 0x40, 0xe8, - 0x97, 0x18, 0x00, 0x4b, 0x85, 0xa0, 0x80, 0x18, 0x40, 0x55, 0x82, 0x07, - 0x68, 0x16, 0x41, 0x48, 0xd9, 0x46, 0x05, 0x18, 0x00, 0x17, 0xb2, 0x30, - 0x06, 0x48, 0x82, 0x16, 0x03, 0x18, 0x40, 0x44, 0xf5, 0x06, 0x0f, 0x18, - 0x00, 0x43, 0x0e, 0x0b, 0x0b, 0x18, 0x00, 0xb4, 0x01, 0xff, 0x44, 0x25, - 0x01, 0x0d, 0x18, 0x00, 0x42, 0x15, 0x02, 0x0c, 0x18, 0x40, 0x05, 0xf0, - 0x06, 0x06, 0x59, 0x7b, 0x25, 0x62, 0x16, 0x41, 0x45, 0x12, 0x0b, 0x18, - 0x18, 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x19, 0x18, 0x00, 0x43, 0x0e, - 0x0b, 0x11, 0x18, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x10, - 0x18, 0x40, 0x44, 0x25, 0x01, 0x13, 0x18, 0x00, 0x42, 0x15, 0x02, 0x12, - 0x18, 0x40, 0x44, 0xe5, 0x1d, 0x17, 0x18, 0x00, 0x42, 0x1c, 0x26, 0x16, - 0x18, 0x40, 0x43, 0xd2, 0x05, 0x15, 0x18, 0x00, 0x43, 0xf6, 0x06, 0x14, - 0x18, 0x40, 0x43, 0xd7, 0x02, 0x04, 0x18, 0x00, 0x43, 0x15, 0x05, 0x02, - 0x18, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4f, 0x88, 0x07, 0x64, 0x16, - 0x01, 0x48, 0x28, 0x05, 0x60, 0x16, 0x41, 0x80, 0x06, 0x4b, 0x22, 0x64, - 0x11, 0xf9, 0x41, 0x43, 0xf2, 0x38, 0xb0, 0xf4, 0x01, 0x4a, 0xc8, 0xb3, - 0xb8, 0xf4, 0x41, 0xa5, 0xa9, 0x14, 0xa9, 0x06, 0x4b, 0x63, 0xa4, 0x0a, - 0x2a, 0x40, 0x80, 0xba, 0x10, 0x05, 0x7c, 0x0c, 0x01, 0xff, 0x59, 0x55, - 0x23, 0x5b, 0xab, 0x00, 0x07, 0xec, 0x05, 0x01, 0xff, 0xa1, 0x95, 0x10, - 0xa2, 0xfc, 0x0f, 0xa3, 0xa6, 0x0c, 0xa4, 0xe3, 0x0b, 0xa5, 0x8a, 0x0b, - 0xa7, 0xee, 0x0a, 0xa8, 0xc4, 0x0a, 0xac, 0x9e, 0x09, 0xad, 0xd1, 0x08, - 0x4a, 0x18, 0xaf, 0xfe, 0x02, 0x00, 0xb0, 0xbc, 0x08, 0xb2, 0xda, 0x07, - 0xb3, 0x47, 0xb4, 0x39, 0xb5, 0x1d, 0xb6, 0x0f, 0xb9, 0x01, 0xff, 0x57, - 0x48, 0x2d, 0xeb, 0x02, 0x00, 0x56, 0xa2, 0x34, 0xea, 0x02, 0x40, 0x4c, - 0xce, 0x0b, 0xc8, 0x02, 0x00, 0x46, 0x7a, 0xd7, 0xec, 0x02, 0x40, 0x4a, - 0x64, 0xae, 0xed, 0x02, 0x00, 0x02, 0x20, 0x00, 0x04, 0xf3, 0x70, 0xa7, - 0x40, 0x49, 0xe1, 0x01, 0xc4, 0x02, 0x00, 0x44, 0x10, 0x39, 0xd4, 0x02, - 0x40, 0x4f, 0xa5, 0x3b, 0xd0, 0x02, 0x00, 0x4b, 0x28, 0x0a, 0xbb, 0x02, - 0x40, 0xa8, 0x82, 0x07, 0x05, 0x5e, 0x07, 0x21, 0x0a, 0x42, 0xb2, 0x11, - 0x0b, 0x70, 0x06, 0x01, 0xff, 0x55, 0x9f, 0x3b, 0x82, 0x07, 0x01, 0x50, - 0xa4, 0x3b, 0x81, 0x07, 0x41, 0x49, 0xeb, 0x42, 0x20, 0xa7, 0x00, 0x48, - 0x3e, 0xb5, 0x21, 0xa7, 0x40, 0xe1, 0x43, 0x1d, 0x80, 0xc7, 0x06, 0xe2, - 0x47, 0x1d, 0x80, 0xa9, 0x06, 0xe3, 0x9c, 0x1d, 0x80, 0xb7, 0x05, 0xe4, - 0x48, 0x1d, 0x80, 0xe7, 0x04, 0xe5, 0x49, 0x1d, 0x80, 0xc9, 0x04, 0xe6, - 0xa0, 0x1d, 0x80, 0xbd, 0x04, 0xe7, 0x4d, 0x1d, 0x80, 0x9a, 0x04, 0xe8, - 0xb0, 0x02, 0x80, 0xf7, 0x03, 0xa9, 0xe8, 0x03, 0xea, 0xb2, 0x02, 0x80, - 0xdc, 0x03, 0xeb, 0x4f, 0x1d, 0x00, 0xec, 0xe1, 0x02, 0x80, 0x8a, 0x03, - 0xed, 0x50, 0x1d, 0x80, 0xfe, 0x02, 0x07, 0xc8, 0x04, 0xed, 0x02, 0xef, - 0x52, 0x1d, 0x80, 0xd4, 0x02, 0xf0, 0x56, 0x1d, 0x80, 0xc8, 0x02, 0xf1, - 0xa5, 0x07, 0x01, 0xf2, 0xb3, 0x02, 0x80, 0x93, 0x02, 0xf3, 0xe2, 0x02, - 0x80, 0xe9, 0x01, 0xf4, 0x57, 0x1d, 0x80, 0x51, 0xf5, 0x58, 0x1d, 0x80, - 0x38, 0xf6, 0x5b, 0x1d, 0x80, 0x22, 0xf7, 0xb7, 0x02, 0x00, 0xf8, 0xe3, - 0x02, 0x00, 0xf9, 0xb8, 0x02, 0x00, 0xfa, 0xbb, 0x1d, 0xc0, 0x00, 0x06, - 0x50, 0x00, 0x01, 0xff, 0x44, 0x72, 0x0b, 0xbd, 0x1d, 0x00, 0x4e, 0xa2, - 0x0e, 0xbc, 0x1d, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x44, 0xac, 0x0e, - 0xb9, 0x1d, 0x00, 0x4a, 0x6c, 0xb0, 0xb0, 0x07, 0x41, 0x80, 0x06, 0x46, - 0xcf, 0x15, 0xb7, 0x1d, 0x40, 0x43, 0x16, 0x00, 0xb6, 0x1d, 0x00, 0x4e, - 0xde, 0x7e, 0x5f, 0xab, 0x40, 0x06, 0x50, 0x00, 0x82, 0x01, 0x53, 0xb4, - 0x48, 0xab, 0x07, 0x01, 0x4b, 0x0d, 0x9c, 0xae, 0x07, 0x01, 0x44, 0xe9, - 0x95, 0xbf, 0x1d, 0x00, 0x49, 0x77, 0xbd, 0x54, 0x1d, 0x00, 0x49, 0x39, - 0xbf, 0xac, 0x07, 0x81, 0x5d, 0x06, 0x71, 0x07, 0x01, 0xff, 0xe1, 0x44, - 0x1d, 0x80, 0x49, 0xe8, 0xa3, 0x1d, 0x00, 0xe9, 0x4e, 0x1d, 0x00, 0xed, - 0x5a, 0x1d, 0x80, 0x36, 0x46, 0x39, 0x29, 0x4c, 0x1d, 0x00, 0xf2, 0xb4, - 0x02, 0x80, 0x13, 0xf6, 0xba, 0x1d, 0x00, 0xf7, 0x69, 0xab, 0x00, 0xf9, - 0xa0, 0x07, 0xc1, 0x00, 0x4a, 0x76, 0xa6, 0xa1, 0x07, 0x41, 0x06, 0x50, - 0x00, 0x01, 0xff, 0x44, 0xac, 0x0e, 0xb5, 0x02, 0x00, 0x48, 0x98, 0x75, - 0xa6, 0x07, 0xc1, 0x00, 0x53, 0x5e, 0x47, 0xa7, 0x07, 0x41, 0x4e, 0x92, - 0x75, 0xad, 0x1d, 0x40, 0xe5, 0x46, 0x1d, 0x00, 0x44, 0x5f, 0xe4, 0x9b, - 0x1d, 0x40, 0x54, 0x9c, 0x0e, 0xad, 0x07, 0x41, 0x4c, 0xfa, 0x56, 0xb5, - 0x1d, 0x00, 0x4e, 0xa2, 0x0e, 0xaf, 0x07, 0x41, 0x06, 0x50, 0x00, 0x14, - 0xa3, 0x06, 0x49, 0x29, 0xba, 0x59, 0x1d, 0x40, 0x43, 0xcb, 0x7b, 0x4a, - 0x1d, 0x00, 0x46, 0xd3, 0xca, 0xa2, 0x1d, 0x40, 0x44, 0x72, 0x0b, 0xba, - 0x07, 0x01, 0x44, 0xac, 0x0e, 0xb3, 0x1d, 0x40, 0x06, 0x50, 0x00, 0x1b, - 0x48, 0x69, 0xc3, 0x91, 0x07, 0x01, 0x08, 0xde, 0x14, 0x01, 0xff, 0xe5, - 0x8e, 0x07, 0x01, 0x4c, 0xe9, 0x28, 0xe4, 0x02, 0x00, 0x46, 0x39, 0x29, - 0x9f, 0x1d, 0x40, 0x48, 0x38, 0x72, 0xa9, 0x07, 0x01, 0x44, 0x8f, 0x17, - 0xa8, 0x07, 0x41, 0x42, 0x49, 0x00, 0xb2, 0x1d, 0x40, 0x4c, 0xf5, 0x28, + 0xd1, 0x41, 0x4c, 0x70, 0x97, 0x00, 0xd1, 0x01, 0xb8, 0x01, 0xff, 0x8d, + 0x24, 0xb4, 0x01, 0xff, 0x06, 0x72, 0x27, 0x11, 0x09, 0xec, 0x1e, 0x01, + 0xff, 0x44, 0x77, 0x29, 0x63, 0xd1, 0x01, 0x44, 0xf5, 0x1e, 0x41, 0xd1, + 0x41, 0x44, 0x77, 0x29, 0x61, 0xd1, 0x01, 0x44, 0xf5, 0x1e, 0x3f, 0xd1, + 0x41, 0x4a, 0x60, 0x7f, 0x1b, 0xd1, 0x01, 0x50, 0xaa, 0x6a, 0x1c, 0xd1, + 0x41, 0x04, 0x9c, 0xb6, 0x06, 0x4b, 0x1d, 0xa6, 0x05, 0xd1, 0x41, 0x44, + 0xa5, 0x01, 0x31, 0xd1, 0x01, 0x42, 0x50, 0x02, 0x30, 0xd1, 0x01, 0x4b, + 0x79, 0x2a, 0x5a, 0xd2, 0x41, 0x43, 0x8b, 0x22, 0x0b, 0xd1, 0x01, 0x02, + 0x7d, 0x02, 0x01, 0xff, 0x07, 0x70, 0xd5, 0x17, 0x07, 0x28, 0xd9, 0x01, + 0xff, 0x45, 0x0c, 0x03, 0xbe, 0xd1, 0x01, 0x44, 0xf5, 0x1e, 0xc6, 0xd1, + 0x01, 0x45, 0xad, 0x02, 0xbd, 0xd1, 0x41, 0x45, 0x0c, 0x03, 0xba, 0xd1, + 0x01, 0x44, 0xf5, 0x1e, 0xc4, 0xd1, 0x01, 0x45, 0xad, 0x02, 0xb9, 0xd1, + 0x41, 0x47, 0xec, 0xd2, 0xdb, 0xd1, 0x41, 0xa5, 0x0f, 0xa9, 0x01, 0xff, + 0x4f, 0xcb, 0x70, 0x07, 0xd1, 0x01, 0x49, 0xfd, 0xc1, 0x8c, 0xd1, 0x41, + 0x04, 0x26, 0x6e, 0x37, 0x05, 0x3e, 0x04, 0x01, 0xff, 0x4e, 0xa2, 0x78, + 0x03, 0xd1, 0x01, 0x46, 0x61, 0x7b, 0xed, 0xd1, 0xc1, 0x00, 0x80, 0x01, + 0xff, 0x48, 0x07, 0xc9, 0xee, 0xd1, 0x81, 0x0c, 0x44, 0xa5, 0x01, 0xf4, + 0xd1, 0x01, 0x42, 0x50, 0x02, 0xf3, 0xd1, 0x41, 0x80, 0x01, 0xff, 0x44, + 0xa5, 0x01, 0xf6, 0xd1, 0x01, 0x42, 0x50, 0x02, 0xf5, 0xd1, 0x41, 0x45, + 0x47, 0x0a, 0x08, 0xd1, 0x01, 0x0a, 0xf2, 0xae, 0x01, 0xff, 0xd1, 0x0d, + 0xd1, 0x01, 0xd2, 0x0e, 0xd1, 0x01, 0xd3, 0x0f, 0xd1, 0x41, 0x06, 0x06, + 0x03, 0x11, 0x0b, 0x1f, 0x57, 0x01, 0xff, 0x44, 0xdc, 0xf4, 0x38, 0xd1, + 0x01, 0x45, 0x74, 0x38, 0x39, 0xd1, 0x41, 0x44, 0x77, 0x29, 0x5f, 0xd1, + 0x01, 0x44, 0xf5, 0x1e, 0x3d, 0xd1, 0x01, 0x05, 0xc2, 0x2e, 0x01, 0xff, + 0x44, 0x3c, 0x2a, 0x33, 0xd1, 0x01, 0x45, 0xb5, 0x63, 0x32, 0xd1, 0x41, + 0x53, 0x72, 0x4a, 0x56, 0xd1, 0x01, 0xa5, 0x22, 0x44, 0x50, 0xf6, 0x8f, + 0xd1, 0x01, 0x4c, 0x5c, 0x96, 0x44, 0xd1, 0x01, 0xaf, 0x01, 0xff, 0x45, + 0x70, 0xeb, 0xd4, 0xd1, 0x01, 0x47, 0x5f, 0xdb, 0xd9, 0xd1, 0xc1, 0x00, + 0x47, 0xec, 0xd2, 0xda, 0xd1, 0x41, 0x04, 0x1a, 0xb0, 0x06, 0x4c, 0xf8, + 0x99, 0xdd, 0xd1, 0x41, 0x44, 0xb9, 0x00, 0xae, 0xd1, 0x01, 0x47, 0xc4, + 0xdc, 0xaf, 0xd1, 0x41, 0x02, 0xf1, 0x05, 0x55, 0xb2, 0x11, 0x06, 0x6e, + 0x38, 0x01, 0xff, 0x44, 0xdc, 0xf4, 0x36, 0xd1, 0x01, 0x45, 0x74, 0x38, + 0x37, 0xd1, 0x41, 0x0a, 0x14, 0xb0, 0x32, 0x0e, 0xb8, 0x7d, 0x01, 0xff, + 0xd1, 0x9b, 0xd1, 0x81, 0x20, 0xd2, 0x9c, 0xd1, 0x01, 0xd3, 0x9d, 0xd1, + 0x01, 0xd4, 0x9e, 0xd1, 0x01, 0xd5, 0x9f, 0xd1, 0x01, 0xd6, 0xa0, 0xd1, + 0x01, 0xd7, 0xa1, 0xd1, 0x01, 0xd8, 0xa2, 0xd1, 0x01, 0xd9, 0xa3, 0xd1, + 0x41, 0xd0, 0xa4, 0xd1, 0x01, 0xd1, 0xa5, 0xd1, 0x41, 0x44, 0xfa, 0x13, + 0x73, 0xd2, 0x01, 0x43, 0xc4, 0xd2, 0x74, 0xd2, 0x41, 0x80, 0x06, 0x4b, + 0x5f, 0x7f, 0x16, 0xd1, 0x41, 0x50, 0xaa, 0x63, 0xec, 0xd1, 0x81, 0x16, + 0x16, 0x27, 0x36, 0x06, 0x5b, 0xde, 0x1e, 0x55, 0xd2, 0x41, 0x44, 0x77, + 0x29, 0x64, 0xd1, 0x01, 0x44, 0xf5, 0x1e, 0x42, 0xd1, 0x41, 0x80, 0x01, + 0xff, 0x44, 0xa5, 0x01, 0xf2, 0xd1, 0x01, 0x42, 0x50, 0x02, 0xf1, 0xd1, + 0x41, 0x07, 0x35, 0x97, 0x18, 0x4a, 0xe8, 0xae, 0xa7, 0xd1, 0x01, 0x45, + 0x41, 0xed, 0x64, 0xd2, 0x01, 0x4d, 0x8e, 0x8b, 0x58, 0xd1, 0x01, 0x4c, + 0x54, 0x9b, 0x59, 0xd1, 0x41, 0x44, 0xa5, 0x01, 0x2f, 0xd1, 0x01, 0x42, + 0x50, 0x02, 0x2e, 0xd1, 0x41, 0x45, 0x07, 0xd5, 0xb6, 0xd1, 0x01, 0x44, + 0x90, 0xf5, 0x90, 0xd1, 0x01, 0x45, 0x29, 0xd9, 0xbb, 0xd1, 0x81, 0x21, + 0x0d, 0x74, 0x8b, 0x11, 0x04, 0xb7, 0x04, 0x01, 0xff, 0x45, 0xf4, 0x1e, + 0x3a, 0xd1, 0x01, 0x50, 0xea, 0x68, 0x29, 0xd1, 0x41, 0x45, 0x0c, 0x03, + 0x53, 0xd1, 0x01, 0x45, 0xad, 0x02, 0x52, 0xd1, 0x41, 0x80, 0x01, 0xff, + 0x45, 0x0c, 0x03, 0xbc, 0xd1, 0x01, 0x44, 0xf5, 0x1e, 0xc5, 0xd1, 0x41, + 0x4f, 0xbd, 0x6f, 0x06, 0xd1, 0x01, 0x44, 0xec, 0x4b, 0xb7, 0xd1, 0xc1, + 0x00, 0x80, 0x01, 0xff, 0x4f, 0xbb, 0x71, 0xc2, 0xd1, 0x01, 0x4d, 0xbd, + 0x71, 0xc1, 0xd1, 0x01, 0x44, 0xf5, 0x1e, 0xff, 0xd1, 0x41, 0x06, 0xb8, + 0xe2, 0x06, 0x44, 0xce, 0x1d, 0xea, 0xd1, 0x41, 0x46, 0x26, 0x90, 0xde, + 0xd1, 0x01, 0xa5, 0x30, 0xa6, 0x22, 0x49, 0xf7, 0xbe, 0xe3, 0xd1, 0x01, + 0x12, 0x0b, 0x57, 0x0c, 0x4f, 0x99, 0x75, 0xe1, 0xd1, 0x01, 0x4a, 0x1a, + 0xb9, 0xe2, 0xd1, 0x41, 0x44, 0xa5, 0x01, 0xe4, 0xd1, 0x01, 0x42, 0x50, + 0x02, 0xe5, 0xd1, 0x41, 0x49, 0xf3, 0xbf, 0xe0, 0xd1, 0x01, 0x48, 0x9e, + 0xbe, 0xe8, 0xd1, 0x41, 0x10, 0xba, 0x66, 0x06, 0x4b, 0x20, 0xa5, 0xdf, + 0xd1, 0x41, 0x44, 0xa5, 0x01, 0xe6, 0xd1, 0x01, 0x42, 0x50, 0x02, 0xe7, + 0xd1, 0x41, 0xa1, 0x1a, 0xa5, 0x01, 0xff, 0x52, 0xe5, 0x52, 0x62, 0xd2, + 0x01, 0x04, 0xa4, 0xf7, 0x01, 0xff, 0x4c, 0x2c, 0x96, 0x6f, 0xd2, 0x01, + 0x4d, 0x14, 0x8d, 0x70, 0xd2, 0x41, 0x03, 0x24, 0x00, 0x06, 0x49, 0x3e, + 0xc6, 0xa6, 0xd1, 0x41, 0x44, 0x77, 0x29, 0x5e, 0xd1, 0x01, 0x4a, 0x14, + 0xb5, 0xb0, 0xd1, 0x01, 0x44, 0xf5, 0x1e, 0x3c, 0xd1, 0x01, 0x45, 0xb5, + 0x63, 0xeb, 0xd1, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x44, 0xa5, 0x01, 0xf0, + 0xd1, 0x01, 0x42, 0x50, 0x02, 0xef, 0xd1, 0x01, 0x4b, 0x79, 0x2a, 0x59, + 0xd2, 0x41, 0x45, 0x2c, 0x84, 0x1e, 0xd1, 0x81, 0x34, 0x09, 0x37, 0xc1, + 0x24, 0xb2, 0x01, 0xff, 0x09, 0x19, 0xbb, 0x11, 0x08, 0x2f, 0xcb, 0x01, + 0xff, 0x46, 0x26, 0x90, 0xd0, 0xd1, 0x01, 0x46, 0x92, 0xe1, 0xd1, 0xd1, + 0x41, 0x48, 0x77, 0xce, 0x95, 0xd1, 0x01, 0x45, 0xd6, 0x0e, 0x94, 0xd1, + 0x41, 0x44, 0xa5, 0x01, 0xb2, 0xd1, 0x01, 0x42, 0x50, 0x02, 0xb1, 0xd1, + 0x41, 0x80, 0x01, 0xff, 0xaf, 0x11, 0x0d, 0x1d, 0x57, 0x01, 0xff, 0x44, + 0xdc, 0xf4, 0x79, 0xd2, 0x01, 0x45, 0x74, 0x38, 0x7a, 0xd2, 0x41, 0x56, + 0x63, 0x38, 0x75, 0xd2, 0x01, 0x06, 0x6e, 0x38, 0x01, 0xff, 0x44, 0xdc, + 0xf4, 0x1f, 0xd1, 0x01, 0x45, 0x74, 0x38, 0x20, 0xd1, 0xc1, 0x00, 0x4c, + 0x20, 0x90, 0x77, 0xd2, 0x41, 0x45, 0x2c, 0x84, 0x22, 0xd1, 0x81, 0x97, + 0x01, 0x46, 0x6d, 0x58, 0x10, 0xd1, 0x81, 0x89, 0x01, 0xa9, 0x55, 0x04, + 0x9e, 0xbe, 0x2a, 0xaf, 0x11, 0x04, 0xe0, 0xf8, 0x01, 0xff, 0x45, 0x0c, + 0x03, 0xc0, 0xd1, 0x01, 0x45, 0xad, 0x02, 0xbf, 0xd1, 0x41, 0x43, 0x2d, + 0x01, 0x91, 0xd1, 0x01, 0x03, 0x50, 0xc6, 0x01, 0xff, 0x4a, 0x60, 0x7f, + 0x19, 0xd1, 0x01, 0x50, 0xaa, 0x6a, 0x1d, 0xd1, 0x41, 0x44, 0xa5, 0x01, + 0x2d, 0xd1, 0x01, 0x42, 0x50, 0x02, 0x2c, 0xd1, 0x01, 0x05, 0x51, 0x00, + 0x01, 0xff, 0x09, 0x46, 0x86, 0x06, 0x46, 0x52, 0x05, 0x56, 0xd2, 0x41, + 0x42, 0xb5, 0x05, 0x58, 0xd2, 0x01, 0x44, 0x54, 0x05, 0x57, 0xd2, 0x41, + 0xae, 0x11, 0x02, 0x32, 0x00, 0x01, 0xff, 0x55, 0x9e, 0x3a, 0x54, 0xd2, + 0x01, 0x4b, 0x5f, 0x7f, 0x1a, 0xd1, 0x41, 0x4a, 0xa6, 0x78, 0x02, 0xd1, + 0x01, 0x0e, 0x96, 0x7b, 0x01, 0xff, 0xd1, 0x6a, 0xd1, 0x01, 0xd2, 0x6b, + 0xd1, 0x01, 0xd3, 0x6c, 0xd1, 0x01, 0xd4, 0x5d, 0xd2, 0x01, 0xd5, 0x5e, + 0xd2, 0x41, 0x46, 0x1f, 0x07, 0x11, 0xd1, 0x41, 0x80, 0x01, 0xff, 0x07, + 0x6d, 0x38, 0x11, 0x0d, 0x1d, 0x57, 0x01, 0xff, 0x44, 0xdc, 0xf4, 0x7b, + 0xd2, 0x01, 0x45, 0x74, 0x38, 0x7c, 0xd2, 0x41, 0x44, 0xdc, 0xf4, 0x23, + 0xd1, 0x01, 0x45, 0x74, 0x38, 0x24, 0xd1, 0x41, 0x06, 0x7f, 0x0b, 0x23, + 0x03, 0x1b, 0x00, 0x01, 0xff, 0x44, 0x60, 0xc3, 0x74, 0xd1, 0x01, 0x49, + 0x9f, 0xc2, 0xa8, 0xd1, 0x01, 0x46, 0x8f, 0x37, 0x7a, 0xd1, 0x01, 0x44, + 0xac, 0xf8, 0x78, 0xd1, 0x01, 0x43, 0x46, 0x27, 0x76, 0xd1, 0x41, 0x44, + 0x77, 0x29, 0x60, 0xd1, 0x01, 0x44, 0xf5, 0x1e, 0x3e, 0xd1, 0x41, 0xa1, + 0xb1, 0x01, 0xa5, 0x9b, 0x01, 0xa9, 0x37, 0x06, 0x3c, 0x01, 0x0d, 0x09, + 0xd6, 0xc4, 0x01, 0xff, 0xd1, 0x25, 0xd1, 0x01, 0xd2, 0x26, 0xd1, 0x41, + 0x47, 0xf0, 0x52, 0x01, 0xd1, 0x01, 0x44, 0x3c, 0x2a, 0x2b, 0xd1, 0x01, + 0x46, 0xc8, 0xe1, 0x76, 0xd2, 0x01, 0xb3, 0x06, 0x52, 0x61, 0x58, 0x6c, + 0xd2, 0x41, 0x44, 0xc9, 0x02, 0x2a, 0xd1, 0x01, 0x4d, 0x10, 0x8c, 0x6e, + 0xd2, 0x41, 0x0f, 0xec, 0x6d, 0x41, 0x04, 0xf1, 0x06, 0x01, 0xff, 0xa6, + 0x24, 0x50, 0x4a, 0x68, 0xfc, 0xd1, 0x01, 0xb3, 0x06, 0x4f, 0x3d, 0x77, + 0xf7, 0xd1, 0x41, 0x0a, 0x92, 0xaf, 0x06, 0x4e, 0xbc, 0x7c, 0xfa, 0xd1, + 0x41, 0x4a, 0xe4, 0xb2, 0xfe, 0xd1, 0x01, 0x46, 0x52, 0x05, 0xfb, 0xd1, + 0x41, 0x09, 0x83, 0xc0, 0x06, 0x4f, 0xc7, 0x74, 0xf8, 0xd1, 0x41, 0x4a, + 0xe4, 0xb2, 0xfd, 0xd1, 0x01, 0x46, 0x52, 0x05, 0xf9, 0xd1, 0x41, 0x45, + 0x0c, 0x03, 0x69, 0xd2, 0x01, 0x4b, 0xdc, 0xa1, 0x6a, 0xd2, 0x01, 0x02, + 0xe5, 0x01, 0x01, 0xff, 0x43, 0xaf, 0x02, 0x68, 0xd2, 0x01, 0x43, 0xa8, + 0x16, 0x67, 0xd2, 0x41, 0x49, 0x08, 0xbd, 0x93, 0xd1, 0x81, 0x06, 0x4a, + 0x6e, 0xb0, 0xa9, 0xd1, 0x41, 0x4a, 0xdc, 0xab, 0x66, 0xd2, 0x41, 0x45, + 0x9c, 0xe7, 0x0a, 0xd1, 0x01, 0x47, 0x72, 0xd8, 0x09, 0xd1, 0x01, 0x42, + 0x14, 0x1d, 0xb4, 0xd1, 0x81, 0x06, 0x4c, 0x28, 0x9a, 0x04, 0xd1, 0x41, + 0x44, 0x44, 0x2f, 0xb5, 0xd1, 0x41, 0x45, 0x2c, 0x84, 0x21, 0xd1, 0x81, + 0xed, 0x02, 0x46, 0x70, 0xdf, 0x13, 0xd1, 0x01, 0x50, 0x2a, 0x67, 0x45, + 0xd1, 0x01, 0xac, 0xbf, 0x02, 0xaf, 0x24, 0xb2, 0x0f, 0xb5, 0x01, 0xff, + 0x44, 0x4c, 0xf8, 0x71, 0xd2, 0x01, 0x46, 0x0a, 0x6d, 0x35, 0xd1, 0x41, + 0x47, 0x0a, 0xbd, 0x92, 0xd1, 0x81, 0x06, 0x43, 0x78, 0xfa, 0xcf, 0xd1, + 0x41, 0x4a, 0xdc, 0xab, 0x65, 0xd2, 0x41, 0x42, 0x7b, 0x08, 0x0c, 0xd1, + 0x01, 0xad, 0x01, 0xff, 0x07, 0x03, 0x17, 0x06, 0x48, 0x07, 0xce, 0x34, + 0xd1, 0x41, 0xa1, 0xf0, 0x01, 0xa2, 0xe1, 0x01, 0x02, 0x3b, 0x01, 0xca, + 0x01, 0x02, 0xd5, 0x04, 0x9b, 0x01, 0x48, 0x4f, 0xcc, 0xac, 0xd1, 0x01, + 0x45, 0x31, 0xee, 0x82, 0xd1, 0x01, 0x47, 0xfe, 0xd8, 0x7f, 0xd1, 0x81, + 0x81, 0x01, 0x43, 0x76, 0x06, 0x86, 0xd1, 0x01, 0xb3, 0x38, 0xb4, 0x0f, + 0xb5, 0x01, 0xff, 0x47, 0x7c, 0xd9, 0x28, 0xd1, 0x01, 0x45, 0xad, 0xef, + 0xab, 0xd1, 0x41, 0x45, 0x0b, 0x81, 0x7d, 0xd1, 0x01, 0xb2, 0x01, 0xff, + 0x06, 0x9e, 0x7b, 0x06, 0x4b, 0xc3, 0xa2, 0x8b, 0xd1, 0x41, 0xd1, 0x67, + 0xd1, 0x01, 0xd2, 0x68, 0xd1, 0x01, 0xd3, 0x69, 0xd1, 0x01, 0xd4, 0x5b, + 0xd2, 0x01, 0xd5, 0x5c, 0xd2, 0x41, 0x44, 0xd3, 0xae, 0x88, 0xd1, 0x01, + 0x4d, 0x8a, 0x8a, 0xad, 0xd1, 0x01, 0x50, 0x1a, 0x69, 0x66, 0xd1, 0x01, + 0xb4, 0x01, 0xff, 0x05, 0xb9, 0xba, 0x1e, 0x42, 0xb5, 0x05, 0x65, 0xd1, + 0x81, 0x06, 0x44, 0xf4, 0x28, 0x27, 0xd1, 0x41, 0x05, 0x97, 0xe7, 0x01, + 0xff, 0x4d, 0x35, 0x85, 0x80, 0xd2, 0x01, 0x50, 0xaa, 0x68, 0x81, 0xd2, + 0x41, 0x46, 0x12, 0xe3, 0x7e, 0xd1, 0x01, 0xef, 0x7c, 0xd1, 0x41, 0x49, + 0xb6, 0xba, 0x80, 0xd1, 0x41, 0x03, 0xe8, 0xf9, 0x06, 0x42, 0xba, 0x04, + 0x87, 0xd1, 0x41, 0xd1, 0x6e, 0xd1, 0x01, 0xd2, 0x6f, 0xd1, 0x01, 0xd3, + 0x70, 0xd1, 0x01, 0xd4, 0x71, 0xd1, 0x01, 0xd5, 0x72, 0xd1, 0x01, 0xd6, + 0x50, 0xd2, 0x01, 0xd7, 0x51, 0xd2, 0x01, 0xd8, 0x52, 0xd2, 0x41, 0x42, + 0x52, 0x00, 0x85, 0xd1, 0x01, 0x4b, 0x61, 0xa9, 0x8a, 0xd1, 0x01, 0x46, + 0x3e, 0xe7, 0xaa, 0xd1, 0x41, 0x43, 0x40, 0x05, 0x89, 0xd1, 0x01, 0x4d, + 0x80, 0x8e, 0x5f, 0xd2, 0x41, 0x45, 0xdb, 0x04, 0x7b, 0xd1, 0x81, 0x06, + 0x4f, 0x6a, 0x77, 0x6d, 0xd1, 0x41, 0x49, 0xb6, 0xba, 0x81, 0xd1, 0x41, + 0xa9, 0x11, 0x0f, 0xa6, 0x77, 0x01, 0xff, 0x45, 0x0c, 0x03, 0x5b, 0xd1, + 0x01, 0x45, 0xad, 0x02, 0x5a, 0xd1, 0x41, 0x45, 0x4f, 0xee, 0xd7, 0xd1, + 0x01, 0x43, 0x90, 0x34, 0xd5, 0xd1, 0x41, 0x80, 0x01, 0xff, 0x4c, 0x6d, + 0x38, 0x78, 0xd2, 0x01, 0x52, 0x1d, 0x57, 0x7d, 0xd2, 0x41, 0x05, 0xc1, + 0x41, 0x2e, 0xb2, 0x01, 0xff, 0x02, 0x0e, 0x03, 0x1d, 0xa5, 0x01, 0xff, + 0x48, 0x71, 0x52, 0x12, 0xd1, 0x01, 0xb6, 0x01, 0xff, 0xe5, 0x5c, 0xd1, + 0x01, 0x42, 0x5f, 0x03, 0xb8, 0xd1, 0xc1, 0x00, 0x45, 0xf4, 0x1e, 0xc3, + 0xd1, 0x41, 0xe5, 0x14, 0xd1, 0x01, 0x43, 0x8c, 0x09, 0x15, 0xd1, 0x41, + 0x44, 0x60, 0xc3, 0x73, 0xd1, 0x01, 0x46, 0x8f, 0x37, 0x79, 0xd1, 0x01, + 0x44, 0xac, 0xf8, 0x77, 0xd1, 0x01, 0x43, 0x46, 0x27, 0x75, 0xd1, 0x41, + 0x44, 0xa5, 0x01, 0x84, 0xd1, 0x01, 0x42, 0x50, 0x02, 0x83, 0xd1, 0xc1, + 0x00, 0x4b, 0xf6, 0x9c, 0x7f, 0xd2, 0x41, 0x4b, 0x2d, 0x9d, 0x98, 0xf3, + 0x41, 0x49, 0x9d, 0xbe, 0x6d, 0x26, 0x00, 0x4c, 0x34, 0x97, 0x6e, 0x26, + 0x00, 0x4a, 0x9a, 0xb6, 0x6f, 0x26, 0x40, 0x46, 0x57, 0x6c, 0x64, 0xcc, + 0x41, 0x04, 0x72, 0x84, 0x69, 0xa9, 0x01, 0xff, 0x43, 0xeb, 0x7a, 0xb8, + 0x22, 0x00, 0x02, 0xbb, 0x04, 0x16, 0x43, 0x6a, 0x13, 0x8c, 0x22, 0xc0, + 0x00, 0x80, 0x01, 0xff, 0x4e, 0x6a, 0x26, 0x8d, 0x22, 0x00, 0x45, 0x37, + 0x18, 0x8e, 0x22, 0x40, 0x4f, 0x9f, 0x6f, 0xb6, 0xf3, 0x01, 0x08, 0xbd, + 0x04, 0x01, 0xff, 0x44, 0x5a, 0x03, 0xd7, 0x00, 0x80, 0x04, 0xf8, 0x15, + 0x27, 0x40, 0x80, 0x01, 0xff, 0x03, 0x08, 0x06, 0x11, 0x05, 0x51, 0x00, + 0x01, 0xff, 0x49, 0x77, 0x1f, 0x30, 0x2a, 0x00, 0x48, 0x64, 0x5c, 0x31, + 0x2a, 0x40, 0x4d, 0xdd, 0x66, 0x37, 0x2a, 0x00, 0x50, 0x7a, 0x67, 0x34, + 0x2a, 0x00, 0x51, 0x46, 0x60, 0x35, 0x2a, 0x00, 0x48, 0x01, 0x02, 0x3b, + 0x2a, 0x40, 0x07, 0x13, 0x06, 0x06, 0x4c, 0x66, 0x28, 0xa9, 0x12, 0x41, + 0xe1, 0x80, 0x12, 0x01, 0xa2, 0xca, 0x01, 0xa3, 0xbd, 0x01, 0xa4, 0x9e, + 0x01, 0xe5, 0x83, 0x12, 0x01, 0xa7, 0x8d, 0x01, 0x42, 0x22, 0x00, 0xa6, + 0x12, 0x01, 0xe9, 0x81, 0x12, 0x01, 0xaa, 0x77, 0xab, 0x6b, 0x42, 0x74, + 0x00, 0xa3, 0x12, 0x01, 0x42, 0x6c, 0x00, 0xa0, 0x12, 0x01, 0xae, 0x4d, + 0xb0, 0x41, 0xb2, 0x2f, 0x42, 0x40, 0x06, 0xa5, 0x12, 0x01, 0xb4, 0x10, + 0xf5, 0x82, 0x12, 0x01, 0x42, 0x61, 0x0b, 0xa4, 0x12, 0x01, 0x42, 0xdf, + 0x23, 0xa1, 0x12, 0x41, 0xe1, 0x96, 0x12, 0x01, 0x42, 0x22, 0x00, 0x97, + 0x12, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x90, 0x12, 0x01, 0x42, 0x22, 0x00, + 0x91, 0x12, 0x41, 0xe1, 0xa2, 0x12, 0x01, 0x42, 0x22, 0x00, 0xa8, 0x12, + 0x01, 0x42, 0x71, 0x00, 0xa7, 0x12, 0x41, 0xe1, 0x9b, 0x12, 0x01, 0x42, + 0x22, 0x00, 0x9c, 0x12, 0x41, 0xe1, 0x9a, 0x12, 0x01, 0x42, 0x2a, 0x05, + 0x95, 0x12, 0x01, 0x42, 0xdf, 0x23, 0x8f, 0x12, 0x41, 0xe1, 0x84, 0x12, + 0x01, 0x42, 0x22, 0x00, 0x85, 0x12, 0x41, 0xe1, 0x8c, 0x12, 0x01, 0x42, + 0x78, 0x1a, 0x8d, 0x12, 0x41, 0xe1, 0x86, 0x12, 0x01, 0x42, 0x22, 0x00, + 0x88, 0x12, 0x41, 0xe1, 0x98, 0x12, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, + 0x99, 0x12, 0x41, 0xe1, 0x92, 0x12, 0x01, 0x42, 0x7b, 0x08, 0x93, 0x12, + 0x01, 0x42, 0x22, 0x00, 0x94, 0x12, 0x41, 0xe1, 0x8a, 0x12, 0x01, 0x42, + 0x22, 0x00, 0x8b, 0x12, 0x41, 0xe1, 0x9d, 0x12, 0x01, 0x42, 0x22, 0x00, + 0x9f, 0x12, 0x41, 0x4c, 0x87, 0x00, 0x6b, 0x22, 0x00, 0x49, 0xec, 0x00, + 0x6a, 0x22, 0x40, 0xa4, 0xb8, 0x01, 0x07, 0x13, 0x06, 0x01, 0xff, 0xe1, + 0x46, 0x6a, 0x01, 0x42, 0x16, 0x00, 0x44, 0x6a, 0x01, 0x43, 0x7e, 0x3a, + 0x4b, 0x6a, 0x01, 0x42, 0x7b, 0x08, 0x45, 0x6a, 0x81, 0x97, 0x01, 0xe5, + 0x58, 0x6a, 0x81, 0x8d, 0x01, 0x02, 0x22, 0x00, 0x80, 0x01, 0xab, 0x6e, + 0x42, 0x74, 0x00, 0x5b, 0x6a, 0x81, 0x63, 0xad, 0x55, 0xae, 0x47, 0xef, + 0x52, 0x6a, 0x81, 0x3a, 0xb0, 0x2e, 0xb2, 0x24, 0x43, 0x31, 0x0d, 0x54, + 0x6a, 0x01, 0xb4, 0x0c, 0x42, 0xa9, 0x01, 0x57, 0x6a, 0x01, 0x42, 0xe0, + 0x49, 0x42, 0x6a, 0x41, 0xe1, 0x40, 0x6a, 0x01, 0x42, 0xdb, 0x19, 0x5e, + 0x6a, 0x01, 0x43, 0xe6, 0x01, 0x55, 0x6a, 0x41, 0xe9, 0x5d, 0x6a, 0x01, + 0xef, 0x53, 0x6a, 0x41, 0xe1, 0x50, 0x6a, 0x01, 0x42, 0x49, 0x00, 0x47, + 0x6a, 0x41, 0xec, 0x4d, 0x6a, 0x01, 0xef, 0x51, 0x6a, 0x41, 0x42, 0xf1, + 0x06, 0x41, 0x6a, 0x01, 0x42, 0x9e, 0x01, 0x4f, 0x6a, 0x41, 0x43, 0xcc, + 0x8b, 0x4e, 0x6a, 0x01, 0x42, 0x29, 0x02, 0x43, 0x6a, 0x41, 0xee, 0x5a, + 0x6a, 0x41, 0x44, 0x78, 0xf5, 0x4c, 0x6a, 0x01, 0x43, 0x71, 0x54, 0x48, + 0x6a, 0x01, 0xef, 0x59, 0x6a, 0x41, 0xe9, 0x5c, 0x6a, 0x01, 0xef, 0x49, + 0x6a, 0x41, 0xe1, 0x56, 0x6a, 0x41, 0xe9, 0x4a, 0x6a, 0x41, 0x44, 0x96, + 0x21, 0x6e, 0x6a, 0x01, 0x05, 0xf0, 0x06, 0x06, 0x4b, 0x33, 0xa6, 0x6f, + 0x6a, 0x41, 0x45, 0x7e, 0x0b, 0x68, 0x6a, 0x01, 0xa6, 0x2e, 0x44, 0x6d, + 0x2c, 0x69, 0x6a, 0x01, 0x43, 0x7a, 0x0b, 0x61, 0x6a, 0x01, 0xb3, 0x14, + 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x60, 0x6a, 0x41, 0x44, 0x25, 0x01, 0x63, + 0x6a, 0x01, 0x42, 0x15, 0x02, 0x62, 0x6a, 0x41, 0x44, 0x06, 0x1f, 0x67, + 0x6a, 0x01, 0x42, 0x09, 0x24, 0x66, 0x6a, 0x41, 0x43, 0xf9, 0x05, 0x65, + 0x6a, 0x01, 0x43, 0xf6, 0x06, 0x64, 0x6a, 0x41, 0x4a, 0xac, 0x4d, 0xf1, + 0xf4, 0x81, 0xa3, 0x22, 0xa4, 0xd1, 0x0a, 0xae, 0xaa, 0x01, 0xaf, 0x85, + 0x01, 0x03, 0xfd, 0x05, 0x77, 0xb4, 0x50, 0xb5, 0x0c, 0x4a, 0xe8, 0xb8, + 0xa5, 0xf3, 0x01, 0x43, 0x12, 0x7c, 0xff, 0xf5, 0x41, 0x02, 0x11, 0x00, + 0x1c, 0x42, 0x46, 0x03, 0x01, 0xf4, 0x81, 0x06, 0x42, 0x53, 0x00, 0x44, + 0xf4, 0x41, 0x80, 0x01, 0xff, 0x44, 0x0c, 0x08, 0x2d, 0xf4, 0x01, 0x44, + 0xae, 0xe6, 0xa4, 0xfa, 0x41, 0x45, 0xb0, 0xe7, 0xfb, 0xf5, 0x01, 0x43, + 0x56, 0x07, 0xf0, 0x26, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x49, 0x30, 0xbc, + 0xb5, 0xf6, 0x01, 0x48, 0x1f, 0xca, 0xa0, 0xf6, 0x01, 0x47, 0x0b, 0x75, + 0x9e, 0xf6, 0x41, 0x4d, 0xbb, 0x80, 0x36, 0xf9, 0x01, 0x02, 0x0c, 0x00, + 0x01, 0xff, 0x80, 0x0c, 0x4f, 0x33, 0x72, 0xbc, 0xf9, 0x01, 0x43, 0x27, + 0x21, 0xe3, 0xf6, 0x41, 0x44, 0xc6, 0xe2, 0xe5, 0xf6, 0x01, 0x47, 0x9e, + 0xdb, 0xf5, 0xf6, 0x41, 0xe5, 0x4c, 0xf5, 0x01, 0x43, 0xc6, 0x07, 0x9f, + 0xf9, 0x41, 0x48, 0x97, 0xca, 0xf0, 0xf5, 0x01, 0x02, 0x92, 0x00, 0x06, + 0x42, 0x46, 0x03, 0xce, 0xfa, 0x41, 0x44, 0xfd, 0x2d, 0x6e, 0xf9, 0x01, + 0x46, 0x90, 0xe3, 0xf5, 0xcd, 0x01, 0x50, 0x8a, 0x6b, 0x91, 0xf3, 0x41, + 0x4e, 0x74, 0x79, 0xcc, 0xfa, 0x01, 0x02, 0xe8, 0x1d, 0x85, 0x09, 0x07, + 0x29, 0xd7, 0x35, 0x43, 0x5e, 0x25, 0x12, 0xf4, 0x81, 0x28, 0xaf, 0x01, + 0xff, 0x09, 0x03, 0x9b, 0x0c, 0x44, 0xc0, 0x4e, 0x9d, 0xf6, 0x01, 0x4d, + 0x7c, 0x8d, 0x8d, 0x23, 0x40, 0x45, 0x94, 0x75, 0x00, 0xd3, 0x01, 0xb9, + 0x01, 0xff, 0x43, 0x1c, 0x01, 0x8a, 0x26, 0x00, 0x42, 0x9e, 0x01, 0x8b, + 0x26, 0x40, 0x45, 0x0b, 0x08, 0x35, 0xf4, 0x41, 0x45, 0x7d, 0x07, 0x00, + 0x18, 0x80, 0xb3, 0x08, 0x02, 0x13, 0x05, 0xa2, 0x08, 0xa4, 0xd3, 0x07, + 0x48, 0x6c, 0x2b, 0x01, 0x18, 0x00, 0xa6, 0x9f, 0x07, 0x4e, 0x3e, 0x7c, + 0x67, 0x16, 0x81, 0x91, 0x07, 0x07, 0x13, 0x06, 0x68, 0x07, 0xf7, 0xd8, + 0x58, 0x46, 0x44, 0xe4, 0x0a, 0x18, 0x00, 0x4d, 0x85, 0x8c, 0x61, 0x16, + 0x81, 0x3a, 0xb3, 0x1a, 0xb4, 0x06, 0x4f, 0xd3, 0x77, 0x0e, 0x18, 0x40, + 0x4f, 0x31, 0x74, 0x06, 0x18, 0x00, 0x59, 0x7d, 0x27, 0x63, 0x16, 0x01, + 0x66, 0x71, 0x07, 0x6c, 0x16, 0x41, 0x5c, 0x1c, 0x19, 0x07, 0x18, 0x00, + 0x4a, 0x78, 0x07, 0x69, 0x16, 0xc1, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, + 0x4f, 0x88, 0x07, 0x6b, 0x16, 0x01, 0x48, 0x28, 0x05, 0x6a, 0x16, 0x41, + 0x06, 0x50, 0x00, 0x01, 0xff, 0x4f, 0x88, 0x07, 0x66, 0x16, 0x01, 0x48, + 0x28, 0x05, 0x65, 0x16, 0x41, 0x45, 0x13, 0x05, 0x08, 0x18, 0x00, 0x49, + 0x4f, 0x17, 0x09, 0x18, 0x40, 0xe1, 0x20, 0x18, 0x80, 0xef, 0x04, 0x42, + 0x16, 0x00, 0x2a, 0x18, 0x00, 0x02, 0x3b, 0x15, 0xd5, 0x04, 0x42, 0x7b, + 0x08, 0x33, 0x18, 0x00, 0xe5, 0x21, 0x18, 0x80, 0xc5, 0x04, 0x42, 0x0c, + 0x08, 0x39, 0x18, 0x00, 0x42, 0x24, 0x02, 0x2d, 0x18, 0x00, 0x43, 0x5e, + 0x43, 0x3e, 0x18, 0x00, 0xe9, 0x22, 0x18, 0x00, 0x42, 0x78, 0x1a, 0x35, + 0x18, 0x00, 0xab, 0x9c, 0x04, 0xac, 0x8f, 0x04, 0x42, 0x6c, 0x00, 0x2e, + 0x18, 0x80, 0x8b, 0x03, 0x42, 0x2a, 0x05, 0x28, 0x18, 0x00, 0xef, 0x23, + 0x18, 0x80, 0xfb, 0x02, 0x42, 0xe0, 0x09, 0x2b, 0x18, 0x00, 0x42, 0x11, + 0x15, 0x2c, 0x18, 0x00, 0x42, 0x71, 0x00, 0x37, 0x18, 0x00, 0xb3, 0xdc, + 0x01, 0xb4, 0x28, 0xf5, 0x24, 0x18, 0x80, 0x1f, 0x42, 0xa9, 0x01, 0x38, + 0x18, 0x00, 0x42, 0xdf, 0x23, 0x36, 0x18, 0x00, 0xba, 0x01, 0xff, 0xe1, + 0x3d, 0x18, 0x00, 0x42, 0x49, 0x00, 0x41, 0x18, 0x00, 0x42, 0x71, 0x00, + 0x3f, 0x18, 0x40, 0xe5, 0x26, 0x18, 0x40, 0xe1, 0x32, 0x18, 0x00, 0x04, + 0x31, 0x74, 0x06, 0x42, 0x40, 0x06, 0x3c, 0x18, 0x40, 0xa1, 0x8b, 0x01, + 0x42, 0x16, 0x00, 0x4b, 0x18, 0x00, 0x43, 0xd0, 0x18, 0x52, 0x18, 0x00, + 0xa4, 0x73, 0xe5, 0x44, 0x18, 0x00, 0x42, 0x24, 0x02, 0x4e, 0x18, 0x80, + 0x64, 0x43, 0x5e, 0x43, 0x59, 0x18, 0x00, 0xe9, 0x45, 0x18, 0x00, 0xaa, + 0x4e, 0x42, 0x1b, 0x02, 0x57, 0x18, 0x00, 0x4f, 0x23, 0x73, 0x43, 0x18, + 0x00, 0x42, 0x6c, 0x00, 0x4f, 0x18, 0x00, 0x43, 0x4a, 0x07, 0x5b, 0x18, + 0x00, 0xef, 0x46, 0x18, 0x80, 0x2d, 0x42, 0xe0, 0x09, 0x4c, 0x18, 0x00, + 0x42, 0x11, 0x15, 0x4d, 0x18, 0x00, 0xb4, 0x15, 0xf5, 0x47, 0x18, 0x80, + 0x0c, 0x42, 0xa9, 0x01, 0x56, 0x18, 0x00, 0x42, 0xdf, 0x23, 0x55, 0x18, + 0x40, 0xe5, 0x49, 0x18, 0x40, 0xe1, 0x50, 0x18, 0x00, 0x42, 0x40, 0x06, + 0x54, 0x18, 0x40, 0xe5, 0x48, 0x18, 0x40, 0xe1, 0x53, 0x18, 0x00, 0x42, + 0x1b, 0x01, 0x5a, 0x18, 0x40, 0xe1, 0x58, 0x18, 0x40, 0xe1, 0x51, 0x18, + 0x00, 0x42, 0x59, 0x00, 0x5c, 0x18, 0x40, 0x08, 0x7d, 0xbb, 0x06, 0x42, + 0x1d, 0x01, 0x4a, 0x18, 0x40, 0x42, 0x12, 0x00, 0x98, 0x18, 0x00, 0x43, + 0x9b, 0xc6, 0x99, 0x18, 0x40, 0xe1, 0x30, 0x18, 0x00, 0x42, 0x22, 0x00, + 0x31, 0x18, 0x00, 0x04, 0x1c, 0x19, 0x01, 0xff, 0x43, 0x1c, 0x01, 0x62, + 0x18, 0x00, 0x43, 0xd0, 0x18, 0x71, 0x18, 0x00, 0x42, 0x7b, 0x08, 0x69, + 0x18, 0x00, 0xe5, 0x5d, 0x18, 0x00, 0x42, 0x0c, 0x08, 0x6b, 0x18, 0x00, + 0x42, 0x24, 0x02, 0x64, 0x18, 0x80, 0x54, 0x42, 0x22, 0x00, 0x65, 0x18, + 0x80, 0x49, 0xe9, 0x5e, 0x18, 0x80, 0x40, 0x42, 0x78, 0x1a, 0x6a, 0x18, + 0x00, 0x42, 0x1b, 0x02, 0x63, 0x18, 0x00, 0x42, 0xe0, 0x09, 0x66, 0x18, + 0x00, 0x43, 0x8c, 0x9a, 0x70, 0x18, 0x00, 0x43, 0xa4, 0x02, 0x67, 0x18, + 0x00, 0xb4, 0x16, 0xf5, 0x61, 0x18, 0x80, 0x0d, 0xba, 0x01, 0xff, 0xe1, + 0x6f, 0x18, 0x00, 0x42, 0x22, 0x00, 0x72, 0x18, 0x40, 0xe5, 0x60, 0x18, + 0x40, 0xe1, 0x68, 0x18, 0x00, 0x42, 0x40, 0x06, 0x6e, 0x18, 0x40, 0xf9, + 0x5f, 0x18, 0x40, 0xe1, 0x6d, 0x18, 0x40, 0xe1, 0x6c, 0x18, 0x40, 0xe5, + 0x25, 0x18, 0x40, 0x05, 0xf9, 0xd8, 0x01, 0xff, 0x09, 0x7c, 0xbb, 0x1c, + 0x42, 0x0c, 0x08, 0x76, 0x18, 0x00, 0xe9, 0x73, 0x18, 0x00, 0x42, 0x1b, + 0x02, 0x74, 0x18, 0x00, 0x42, 0x71, 0x00, 0x75, 0x18, 0x00, 0x43, 0x9b, + 0xc6, 0x77, 0x18, 0x40, 0x43, 0x77, 0x2c, 0xa8, 0x18, 0x00, 0xa3, 0x45, + 0xa4, 0x37, 0x43, 0x38, 0xa1, 0x9a, 0x18, 0x00, 0x43, 0xd3, 0x47, 0x9d, + 0x18, 0x00, 0x43, 0x4f, 0x09, 0xaa, 0x18, 0x00, 0x43, 0x70, 0x4a, 0x9b, + 0x18, 0x00, 0x43, 0x1e, 0x22, 0xa2, 0x18, 0x00, 0xb4, 0x0d, 0xba, 0x01, + 0xff, 0xe1, 0xa5, 0x18, 0x00, 0x42, 0x22, 0x00, 0xa4, 0x18, 0x40, 0xe1, + 0xa0, 0x18, 0x00, 0x42, 0x12, 0x00, 0x9e, 0x18, 0x40, 0x43, 0x44, 0x4e, + 0x9f, 0x18, 0x00, 0x42, 0x22, 0x00, 0xa1, 0x18, 0x40, 0xe1, 0x9c, 0x18, + 0x00, 0x42, 0xdf, 0x23, 0xa3, 0x18, 0x40, 0xe1, 0x2f, 0x18, 0x00, 0x42, + 0x22, 0x00, 0x40, 0x18, 0x40, 0xe1, 0x3a, 0x18, 0x00, 0x42, 0x22, 0x00, + 0x3b, 0x18, 0x40, 0xe5, 0x27, 0x18, 0x40, 0xe1, 0x34, 0x18, 0x80, 0x04, + 0xe9, 0x42, 0x18, 0x40, 0x4e, 0xfe, 0x1a, 0x78, 0x18, 0x40, 0x08, 0x7d, + 0xbb, 0x06, 0x42, 0x1d, 0x01, 0x29, 0x18, 0x40, 0xe1, 0x87, 0x18, 0x80, + 0x96, 0x01, 0x46, 0x5a, 0xa2, 0x85, 0x18, 0x00, 0x42, 0x37, 0x00, 0x8b, + 0x18, 0x00, 0xa4, 0x71, 0x05, 0x22, 0x00, 0x63, 0xe9, 0x88, 0x18, 0x80, + 0x58, 0x42, 0x1b, 0x02, 0x89, 0x18, 0x00, 0xae, 0x44, 0xb0, 0x38, 0x43, + 0x1e, 0x22, 0x94, 0x18, 0x00, 0xb4, 0x19, 0x47, 0x1b, 0x74, 0x83, 0x18, + 0x00, 0x4b, 0x27, 0xaa, 0x81, 0x18, 0x00, 0xba, 0x01, 0xff, 0xe1, 0x96, + 0x18, 0x00, 0x42, 0x22, 0x00, 0x95, 0x18, 0x40, 0xe1, 0x90, 0x18, 0x00, + 0x4b, 0x55, 0xa2, 0x86, 0x18, 0x00, 0xb4, 0x01, 0xff, 0xe1, 0x8c, 0x18, + 0x00, 0x42, 0x22, 0x00, 0x8d, 0x18, 0x40, 0xe1, 0x92, 0x18, 0x00, 0x42, + 0x22, 0x00, 0x93, 0x18, 0x40, 0x42, 0x24, 0x02, 0x8a, 0x18, 0x00, 0x42, + 0x2a, 0x05, 0x8f, 0x18, 0x40, 0x4f, 0x13, 0x74, 0x84, 0x18, 0x40, 0xf5, + 0xa6, 0x18, 0x00, 0x42, 0xdf, 0x23, 0xa7, 0x18, 0x40, 0xe1, 0x91, 0x18, + 0x80, 0x06, 0x42, 0x7b, 0x08, 0x8e, 0x18, 0x40, 0x45, 0x79, 0xec, 0xa9, + 0x18, 0x00, 0x44, 0x10, 0xf7, 0x82, 0x18, 0x40, 0xe8, 0x97, 0x18, 0x00, + 0x4b, 0x8e, 0xa5, 0x80, 0x18, 0x40, 0x55, 0x82, 0x07, 0x68, 0x16, 0x41, + 0x48, 0x09, 0x49, 0x05, 0x18, 0x00, 0x17, 0x35, 0x32, 0x06, 0x48, 0x50, + 0x17, 0x03, 0x18, 0x40, 0x44, 0xf5, 0x06, 0x0f, 0x18, 0x00, 0x43, 0x7a, + 0x0b, 0x0b, 0x18, 0x00, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0x0d, 0x18, + 0x00, 0x42, 0x15, 0x02, 0x0c, 0x18, 0x40, 0x05, 0xf0, 0x06, 0x06, 0x59, + 0xce, 0x26, 0x62, 0x16, 0x41, 0x45, 0x7e, 0x0b, 0x18, 0x18, 0x00, 0xa6, + 0x2e, 0x44, 0x6d, 0x2c, 0x19, 0x18, 0x00, 0x43, 0x7a, 0x0b, 0x11, 0x18, + 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x10, 0x18, 0x40, 0x44, + 0x25, 0x01, 0x13, 0x18, 0x00, 0x42, 0x15, 0x02, 0x12, 0x18, 0x40, 0x44, + 0x06, 0x1f, 0x17, 0x18, 0x00, 0x42, 0x09, 0x24, 0x16, 0x18, 0x40, 0x43, + 0xf9, 0x05, 0x15, 0x18, 0x00, 0x43, 0xf6, 0x06, 0x14, 0x18, 0x40, 0x43, + 0xd7, 0x02, 0x04, 0x18, 0x00, 0x43, 0x15, 0x05, 0x02, 0x18, 0x40, 0x06, + 0x50, 0x00, 0x01, 0xff, 0x4f, 0x88, 0x07, 0x64, 0x16, 0x01, 0x48, 0x28, + 0x05, 0x60, 0x16, 0x41, 0x80, 0x06, 0x4b, 0x1f, 0x67, 0x11, 0xf9, 0x41, + 0x43, 0xfa, 0x3a, 0xb0, 0xf4, 0x01, 0x4a, 0x42, 0xb9, 0xb8, 0xf4, 0x41, + 0xa5, 0xc0, 0x17, 0xa9, 0x06, 0x4b, 0x8d, 0xa9, 0x0a, 0x2a, 0x40, 0x80, + 0xd1, 0x13, 0x05, 0xe8, 0x0c, 0x01, 0xff, 0x59, 0x8f, 0x24, 0x5b, 0xab, + 0x00, 0x07, 0x13, 0x06, 0x01, 0xff, 0xa1, 0x95, 0x13, 0xa2, 0xfc, 0x12, + 0xa3, 0xa6, 0x0f, 0xa4, 0xe3, 0x0e, 0xa5, 0x8a, 0x0e, 0xa7, 0xee, 0x0d, + 0xa8, 0xbe, 0x0d, 0x55, 0x64, 0x3e, 0xbc, 0x07, 0x01, 0xac, 0x92, 0x0c, + 0xad, 0xc5, 0x0b, 0x4a, 0x88, 0xb4, 0xfe, 0x02, 0x00, 0xb0, 0xb0, 0x0b, + 0xb2, 0xce, 0x0a, 0xb3, 0x47, 0xb4, 0x39, 0xb5, 0x1d, 0xb6, 0x0f, 0xb9, + 0x01, 0xff, 0x57, 0xb4, 0x2e, 0xeb, 0x02, 0x00, 0x56, 0x69, 0x36, 0xea, + 0x02, 0x40, 0x4c, 0x3a, 0x0c, 0xc8, 0x02, 0x00, 0x46, 0x43, 0xdd, 0xec, + 0x02, 0x40, 0x4a, 0xca, 0xb3, 0xed, 0x02, 0x00, 0x02, 0x20, 0x00, 0x04, + 0xf3, 0x70, 0xa7, 0x40, 0x49, 0xe1, 0x01, 0xc4, 0x02, 0x00, 0x44, 0x18, + 0x3b, 0xd4, 0x02, 0x40, 0x4f, 0xad, 0x3d, 0xd0, 0x02, 0x00, 0x4b, 0x71, + 0x0a, 0xbb, 0x02, 0x40, 0xa8, 0xf6, 0x09, 0x05, 0x5e, 0x07, 0x2b, 0x03, + 0x76, 0x02, 0x11, 0x0b, 0x70, 0x06, 0x01, 0xff, 0x55, 0xa7, 0x3d, 0x82, + 0x07, 0x01, 0x50, 0xac, 0x3d, 0x81, 0x07, 0x41, 0x07, 0x5a, 0x9c, 0x06, + 0x47, 0xc9, 0xb7, 0xbd, 0x07, 0x41, 0x49, 0x07, 0x45, 0x20, 0xa7, 0x00, + 0x48, 0xa5, 0xba, 0x21, 0xa7, 0x40, 0xe1, 0x43, 0x1d, 0x80, 0xb1, 0x09, + 0xe2, 0x47, 0x1d, 0x80, 0xfd, 0x08, 0xe3, 0x9c, 0x1d, 0x80, 0xf2, 0x07, + 0xe4, 0x48, 0x1d, 0x80, 0xf8, 0x06, 0xe5, 0x49, 0x1d, 0x80, 0xb0, 0x06, + 0xe6, 0xa0, 0x1d, 0x80, 0xa4, 0x06, 0xe7, 0x4d, 0x1d, 0x80, 0xe8, 0x05, + 0xe8, 0xb0, 0x02, 0x80, 0xbf, 0x05, 0xa9, 0xb0, 0x05, 0xea, 0xb2, 0x02, + 0x80, 0x99, 0x05, 0xeb, 0x4f, 0x1d, 0x80, 0x8d, 0x05, 0xec, 0xe1, 0x02, + 0x80, 0xab, 0x04, 0xed, 0x50, 0x1d, 0x80, 0x9f, 0x04, 0x07, 0xc8, 0x04, + 0xfa, 0x03, 0xef, 0x52, 0x1d, 0x80, 0xe1, 0x03, 0xf0, 0x56, 0x1d, 0x80, + 0xcf, 0x03, 0xf1, 0xa5, 0x07, 0x81, 0xbd, 0x03, 0xf2, 0xb3, 0x02, 0x80, + 0x80, 0x03, 0xf3, 0xe2, 0x02, 0x80, 0xbe, 0x02, 0xf4, 0x57, 0x1d, 0x80, + 0x5e, 0xf5, 0x58, 0x1d, 0x80, 0x3e, 0xf6, 0x5b, 0x1d, 0x80, 0x28, 0xf7, + 0xb7, 0x02, 0x00, 0xf8, 0xe3, 0x02, 0x00, 0xf9, 0xb8, 0x02, 0x00, 0xfa, + 0xbb, 0x1d, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x44, 0xde, 0x0b, + 0xbd, 0x1d, 0x00, 0x4c, 0x47, 0x3d, 0xf9, 0xdf, 0x01, 0x4e, 0x51, 0x0f, + 0xbc, 0x1d, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x44, 0x5b, 0x0f, 0xb9, + 0x1d, 0x00, 0x4a, 0xe6, 0xb5, 0xb0, 0x07, 0x41, 0x80, 0x0d, 0x46, 0x9d, + 0x16, 0xb7, 0x1d, 0xc0, 0x00, 0x4c, 0x78, 0x2a, 0xda, 0xdf, 0x41, 0x43, + 0x16, 0x00, 0xb6, 0x1d, 0x00, 0x4e, 0xb2, 0x82, 0x5f, 0xab, 0x40, 0x06, + 0x50, 0x00, 0xb7, 0x01, 0x53, 0xe4, 0x4a, 0xab, 0x07, 0x01, 0x4b, 0x0b, + 0xa1, 0xae, 0x07, 0x81, 0x98, 0x01, 0x44, 0xf8, 0x78, 0xbf, 0x1d, 0x00, + 0x49, 0x1d, 0xc3, 0x54, 0x1d, 0x00, 0x49, 0xe8, 0xc4, 0xac, 0x07, 0x81, + 0x7f, 0x06, 0x71, 0x07, 0x01, 0xff, 0xe1, 0x44, 0x1d, 0x80, 0x6b, 0xe8, + 0xa3, 0x1d, 0x80, 0x59, 0xe9, 0x4e, 0x1d, 0x00, 0xeb, 0xbe, 0x07, 0x01, + 0xed, 0x5a, 0x1d, 0x80, 0x46, 0x46, 0xbc, 0x2a, 0x4c, 0x1d, 0x00, 0xf2, + 0xb4, 0x02, 0x80, 0x17, 0xf4, 0xbb, 0x07, 0x01, 0xf6, 0xba, 0x1d, 0x00, + 0xf7, 0x69, 0xab, 0x00, 0xf9, 0xa0, 0x07, 0xc1, 0x00, 0x4a, 0xa0, 0xab, + 0xa1, 0x07, 0x41, 0x06, 0x50, 0x00, 0x01, 0xff, 0x44, 0x5b, 0x0f, 0xb5, + 0x02, 0x00, 0x48, 0xd2, 0x78, 0xa6, 0x07, 0x81, 0x0c, 0x54, 0x83, 0x46, + 0xcd, 0xdf, 0x01, 0x46, 0x52, 0x05, 0xd7, 0xdf, 0x41, 0x53, 0x8e, 0x49, + 0xa7, 0x07, 0x41, 0x4e, 0xcc, 0x78, 0xad, 0x1d, 0x40, 0x4e, 0x6d, 0x75, + 0xed, 0xdf, 0xc1, 0x00, 0x49, 0xc3, 0xb9, 0xee, 0xdf, 0x41, 0xe5, 0x46, + 0x1d, 0x00, 0x44, 0x40, 0xea, 0x9b, 0x1d, 0x40, 0x54, 0x4b, 0x0f, 0xad, + 0x07, 0x41, 0x06, 0x50, 0x00, 0x01, 0xff, 0x44, 0xde, 0x0b, 0xe4, 0xdf, + 0x01, 0x4e, 0x51, 0x0f, 0xe5, 0xdf, 0x41, 0x44, 0xde, 0x0b, 0xf2, 0xdf, + 0x01, 0x44, 0x5b, 0x0f, 0xfe, 0xdf, 0x81, 0x0c, 0x4c, 0x47, 0x3d, 0xb5, + 0x1d, 0x00, 0x4e, 0x51, 0x0f, 0xaf, 0x07, 0x41, 0x53, 0x8e, 0x49, 0xff, + 0xdf, 0x41, 0x06, 0x50, 0x00, 0x26, 0xa3, 0x18, 0x49, 0xab, 0xbf, 0x59, + 0x1d, 0x00, 0x05, 0x34, 0xde, 0x06, 0x51, 0x13, 0x60, 0xec, 0xdf, 0x41, + 0xef, 0xce, 0xdf, 0x01, 0xf5, 0xcf, 0xdf, 0x41, 0x43, 0x83, 0x7f, 0x4a, + 0x1d, 0x00, 0x46, 0x94, 0xe5, 0xa2, 0x1d, 0x40, 0x44, 0xde, 0x0b, 0xba, + 0x07, 0x01, 0x44, 0x5b, 0x0f, 0xb3, 0x1d, 0x00, 0x4c, 0x47, 0x3d, 0xf8, + 0xdf, 0x41, 0x06, 0x50, 0x00, 0x21, 0x48, 0xf7, 0xc8, 0x91, 0x07, 0x01, + 0x08, 0xac, 0x15, 0x01, 0xff, 0xe5, 0x8e, 0x07, 0x01, 0x4c, 0x6c, 0x2a, + 0xe4, 0x02, 0x00, 0x46, 0xbc, 0x2a, 0x9f, 0x1d, 0x00, 0x4f, 0x6c, 0x75, + 0xeb, 0xdf, 0x41, 0x48, 0x73, 0x75, 0xa9, 0x07, 0x01, 0x48, 0xd2, 0x78, + 0xdd, 0xdf, 0x01, 0x44, 0x79, 0x18, 0xa8, 0x07, 0x41, 0x4a, 0x15, 0x26, + 0xfd, 0xdf, 0x01, 0x49, 0x92, 0xc3, 0xdf, 0xdf, 0x41, 0x4a, 0x15, 0x26, + 0xfc, 0xdf, 0x01, 0x42, 0x49, 0x00, 0xb2, 0x1d, 0x40, 0x4c, 0x78, 0x2a, 0xa2, 0x07, 0x01, 0x04, 0xf7, 0x04, 0x01, 0xff, 0xe5, 0x4b, 0x1d, 0x00, - 0xef, 0x53, 0x1d, 0x40, 0x49, 0xb8, 0x57, 0xae, 0x1d, 0x00, 0x4e, 0xa2, - 0x0e, 0xaf, 0x1d, 0x40, 0x4a, 0xc2, 0x24, 0xac, 0x1d, 0x40, 0x06, 0x50, - 0x00, 0x1f, 0x43, 0x5b, 0xf4, 0x9e, 0x07, 0x81, 0x12, 0x4a, 0xbc, 0xab, - 0xf9, 0xa7, 0x00, 0x49, 0x39, 0xbf, 0x99, 0x07, 0x01, 0x49, 0xd3, 0xc1, - 0x9a, 0x07, 0x41, 0x54, 0x9c, 0x0e, 0x9f, 0x07, 0x41, 0x44, 0x7c, 0xa6, - 0x9b, 0x07, 0x01, 0x4f, 0xda, 0x6e, 0x5d, 0xab, 0x00, 0x4c, 0x30, 0x23, - 0x5e, 0xab, 0x00, 0x4c, 0xfa, 0x56, 0xaa, 0x1d, 0x00, 0x4e, 0xa2, 0x0e, - 0xa9, 0x1d, 0xc0, 0x00, 0x49, 0x4a, 0xb4, 0x9d, 0x07, 0x41, 0x52, 0xca, - 0x4f, 0xa8, 0x1d, 0x40, 0x4c, 0xf5, 0x28, 0xa4, 0x1d, 0x00, 0x43, 0x1b, - 0x05, 0xa5, 0x1d, 0x40, 0x06, 0x50, 0x00, 0x0d, 0x43, 0x4c, 0x0a, 0x5c, - 0xab, 0xc0, 0x00, 0x4a, 0xc2, 0x24, 0x97, 0x07, 0x41, 0x44, 0xac, 0x0e, - 0xb1, 0x02, 0x00, 0x46, 0x52, 0x05, 0x95, 0x07, 0x41, 0x4a, 0xc2, 0x24, - 0x93, 0x07, 0x01, 0x44, 0x02, 0x21, 0xe0, 0x02, 0x00, 0x05, 0xa2, 0x2e, - 0x01, 0xff, 0x45, 0x33, 0x58, 0x5e, 0x1d, 0x00, 0x43, 0xe1, 0x17, 0x60, - 0x1d, 0x40, 0x4b, 0xd6, 0x9b, 0x90, 0x07, 0x41, 0x42, 0x1d, 0x01, 0x51, - 0x1d, 0x00, 0x42, 0xa4, 0x02, 0xb4, 0x1d, 0x00, 0x42, 0x53, 0x00, 0x9e, - 0x1d, 0x00, 0x42, 0x6f, 0x28, 0xbe, 0x1d, 0x40, 0x06, 0x50, 0x00, 0x33, - 0xa5, 0x25, 0x54, 0xcb, 0x44, 0xa1, 0x1d, 0x80, 0x18, 0x49, 0xd3, 0xc1, - 0x87, 0x07, 0xc1, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x44, 0x72, 0x0b, - 0x89, 0x07, 0x01, 0x4e, 0xa2, 0x0e, 0x88, 0x07, 0x41, 0x49, 0xc2, 0x23, - 0x98, 0x07, 0x41, 0x43, 0x65, 0x19, 0x5f, 0x1d, 0x00, 0x4a, 0x36, 0xb4, - 0x8a, 0x07, 0x41, 0x44, 0xac, 0x0e, 0x8c, 0x07, 0x81, 0x06, 0x44, 0x8f, - 0x17, 0x8b, 0x07, 0x41, 0x49, 0x5c, 0xb4, 0x8d, 0x07, 0x41, 0x4a, 0xbd, - 0x48, 0x9d, 0x1d, 0x00, 0x07, 0xe5, 0x05, 0x17, 0x42, 0x49, 0x00, 0x61, - 0x1d, 0x00, 0x06, 0x7c, 0x1b, 0x01, 0xff, 0x45, 0x59, 0xaf, 0xa4, 0x07, - 0x01, 0x4f, 0x7c, 0x72, 0x8f, 0x07, 0x41, 0x42, 0x80, 0x12, 0x80, 0x07, - 0x01, 0xe2, 0x84, 0x07, 0x01, 0xe7, 0x92, 0x07, 0x81, 0x36, 0xe8, 0x96, - 0x07, 0x01, 0xe9, 0xa6, 0x1d, 0x80, 0x21, 0xec, 0xab, 0x1d, 0x80, 0x16, - 0xee, 0xb0, 0x1d, 0x00, 0x42, 0x67, 0x51, 0xa3, 0x07, 0x01, 0xf2, 0xaa, - 0x07, 0x01, 0xf5, 0xb8, 0x1d, 0x00, 0xf9, 0xb2, 0x07, 0x41, 0x4a, 0x76, - 0xa6, 0x9c, 0x07, 0x41, 0x4c, 0xf5, 0x28, 0xa7, 0x1d, 0x00, 0x49, 0xe7, - 0xbc, 0xb6, 0x02, 0x40, 0x4a, 0xc2, 0x24, 0x94, 0x07, 0x41, 0x4a, 0xc2, - 0x24, 0x85, 0x07, 0x01, 0x47, 0x22, 0xcf, 0xb1, 0x1d, 0x00, 0x43, 0x94, - 0x0f, 0x5d, 0x1d, 0x00, 0x4c, 0x90, 0x93, 0x55, 0x1d, 0x40, 0xe5, 0x83, - 0x07, 0x01, 0x42, 0x9e, 0x01, 0x5c, 0x1d, 0x00, 0x44, 0x5f, 0xe4, 0x45, - 0x1d, 0x40, 0x43, 0x98, 0x79, 0xfd, 0x02, 0x00, 0x4f, 0x7d, 0x71, 0x8a, - 0xa7, 0x40, 0x06, 0xd2, 0x10, 0x3d, 0xa5, 0x1d, 0x4a, 0x62, 0xab, 0xde, - 0x02, 0x00, 0x05, 0xc9, 0x00, 0x01, 0xff, 0x49, 0xe1, 0x01, 0xc3, 0x02, - 0x00, 0x49, 0xfe, 0x13, 0xbe, 0x02, 0x00, 0x44, 0x10, 0x39, 0x6b, 0xab, - 0x40, 0x61, 0x8f, 0x0e, 0xb9, 0x07, 0x01, 0x07, 0xdf, 0x14, 0x01, 0xff, - 0x45, 0x13, 0x05, 0xbd, 0x02, 0x00, 0x4c, 0xe9, 0x28, 0xc1, 0x02, 0xc0, - 0x00, 0x4c, 0xf5, 0x28, 0xb4, 0x07, 0x41, 0x45, 0xaf, 0x3b, 0xf8, 0x02, - 0x00, 0x4a, 0xd3, 0x41, 0x1c, 0xa7, 0x00, 0x50, 0xad, 0x00, 0x1d, 0xa7, - 0x00, 0x59, 0x68, 0x24, 0x1e, 0xa7, 0x00, 0x48, 0x30, 0x56, 0x1b, 0xa7, - 0x40, 0x48, 0xe7, 0x71, 0xd6, 0x02, 0x00, 0x44, 0x07, 0x1b, 0xb9, 0x02, - 0x40, 0x45, 0xb5, 0x70, 0xc9, 0x02, 0x00, 0xa9, 0x01, 0xff, 0xa4, 0x06, - 0x48, 0x8a, 0x98, 0xd7, 0x02, 0x40, 0x80, 0x1b, 0x04, 0x80, 0x02, 0x01, - 0xff, 0x07, 0x3b, 0x01, 0x06, 0x4c, 0x17, 0x23, 0xf4, 0x02, 0x40, 0x4c, - 0x10, 0x8c, 0xf6, 0x02, 0x00, 0x4c, 0x17, 0x23, 0xf5, 0x02, 0x40, 0x07, - 0xb2, 0x1f, 0x0c, 0x52, 0x72, 0x53, 0x14, 0xa7, 0x00, 0x48, 0x7c, 0x53, - 0xe7, 0x02, 0x40, 0x52, 0x72, 0x53, 0x0f, 0xa7, 0x00, 0x48, 0x7c, 0x53, - 0x0a, 0xa7, 0x40, 0x4c, 0x0a, 0x85, 0xb7, 0x07, 0x01, 0x04, 0xc4, 0x00, - 0x86, 0x01, 0x02, 0xd1, 0x00, 0x01, 0xff, 0x80, 0x06, 0x55, 0x21, 0x3b, - 0x1a, 0xa7, 0x40, 0x4c, 0x10, 0x8c, 0xcf, 0x02, 0x00, 0x51, 0xcf, 0x04, - 0x88, 0xa7, 0x00, 0x02, 0x3b, 0x01, 0x53, 0x4c, 0x17, 0x23, 0xce, 0x02, - 0x00, 0x59, 0x68, 0x24, 0x1f, 0xa7, 0x00, 0x04, 0xc3, 0x00, 0x30, 0x46, - 0xb4, 0x70, 0xcd, 0x02, 0x00, 0x02, 0x0d, 0x00, 0x1a, 0xb4, 0x0c, 0x4c, - 0x30, 0x56, 0xf0, 0x02, 0x00, 0x4d, 0xcd, 0x0b, 0xcc, 0x02, 0x40, 0x44, - 0x38, 0x23, 0xf7, 0x02, 0x00, 0x47, 0x7d, 0x53, 0xe8, 0x02, 0x40, 0x4d, - 0xed, 0x3d, 0xf2, 0x02, 0x00, 0x42, 0x1d, 0x01, 0xf3, 0x02, 0x40, 0x46, - 0xcd, 0x00, 0xff, 0x02, 0x80, 0x06, 0x4e, 0x76, 0x53, 0x15, 0xa7, 0x40, - 0x44, 0xe6, 0x01, 0xf1, 0x02, 0x40, 0x05, 0xb4, 0x1f, 0x06, 0x4c, 0xd5, - 0x41, 0xef, 0x02, 0x40, 0x52, 0x72, 0x53, 0x10, 0xa7, 0x00, 0x48, 0x7c, - 0x53, 0x0b, 0xa7, 0x40, 0x49, 0xe1, 0x01, 0xc2, 0x02, 0x00, 0x49, 0xfe, - 0x13, 0xbf, 0x02, 0x00, 0x44, 0x10, 0x39, 0x6a, 0xab, 0x40, 0x54, 0xa0, - 0x3b, 0xd1, 0x02, 0x00, 0x04, 0x49, 0x0b, 0x01, 0xff, 0x07, 0xb2, 0x1f, - 0x0c, 0x52, 0x72, 0x53, 0x13, 0xa7, 0x00, 0x48, 0x7c, 0x53, 0xe6, 0x02, - 0x40, 0x52, 0x72, 0x53, 0x0e, 0xa7, 0x00, 0x48, 0x7c, 0x53, 0x09, 0xa7, - 0x40, 0x4b, 0xec, 0x9b, 0xfc, 0x10, 0x00, 0x4b, 0xea, 0x28, 0xc0, 0x02, - 0x80, 0x06, 0x4b, 0x18, 0x23, 0xcb, 0x02, 0x40, 0x4c, 0xf5, 0x28, 0xb3, - 0x07, 0x41, 0x03, 0x1b, 0x00, 0x46, 0x05, 0x97, 0xec, 0x01, 0xff, 0x05, - 0x48, 0x0b, 0x21, 0x04, 0x08, 0x05, 0x01, 0xff, 0x07, 0xb2, 0x1f, 0x0c, - 0x52, 0x72, 0x53, 0x16, 0xa7, 0x00, 0x48, 0x7c, 0x53, 0xe9, 0x02, 0x40, - 0x52, 0x72, 0x53, 0x11, 0xa7, 0x00, 0x48, 0x7c, 0x53, 0x0c, 0xa7, 0x40, - 0x07, 0xb2, 0x1f, 0x0c, 0x52, 0x72, 0x53, 0x12, 0xa7, 0x00, 0x48, 0x7c, - 0x53, 0xe5, 0x02, 0x40, 0x52, 0x72, 0x53, 0x0d, 0xa7, 0x00, 0x48, 0x7c, - 0x53, 0x08, 0xa7, 0x40, 0x49, 0xeb, 0x42, 0xfa, 0x02, 0x00, 0x48, 0x3e, - 0xb5, 0xfc, 0x02, 0x40, 0x4b, 0xf1, 0x8d, 0xb6, 0x07, 0x01, 0xaf, 0x01, - 0xff, 0x02, 0xc6, 0x00, 0x21, 0x05, 0x3d, 0x01, 0x11, 0x03, 0xa0, 0x14, - 0x01, 0xff, 0x49, 0xe1, 0x01, 0xc5, 0x02, 0x00, 0x44, 0x10, 0x39, 0xd5, - 0x02, 0x40, 0x4a, 0x7c, 0x36, 0xee, 0x02, 0x00, 0x45, 0x06, 0x1b, 0xba, - 0x02, 0x40, 0x4e, 0x0b, 0x00, 0x19, 0xa7, 0x00, 0x45, 0x48, 0x0e, 0x18, - 0xa7, 0x00, 0x4c, 0x32, 0x00, 0x17, 0xa7, 0x40, 0x07, 0xe5, 0x05, 0xcc, - 0x02, 0x07, 0xc3, 0x68, 0xbb, 0x02, 0x0d, 0xd1, 0x83, 0xfd, 0x01, 0x50, - 0xd0, 0x04, 0xc6, 0x02, 0x00, 0x44, 0x51, 0x12, 0x89, 0xa7, 0x00, 0x4b, - 0x7f, 0xa2, 0xdf, 0x02, 0x00, 0x08, 0x11, 0xcd, 0x01, 0xff, 0x42, 0x92, - 0x01, 0x78, 0x1d, 0x00, 0x49, 0xa2, 0xb9, 0x9c, 0xa6, 0x00, 0xb3, 0x01, - 0xff, 0x05, 0x5e, 0x07, 0x06, 0x48, 0x9c, 0x8e, 0x9d, 0xa6, 0x40, 0xe1, - 0x30, 0xe0, 0x01, 0xa2, 0xb6, 0x01, 0x43, 0x6d, 0x14, 0x45, 0xe0, 0x01, - 0xa4, 0xa3, 0x01, 0xe5, 0x48, 0xe0, 0x81, 0x82, 0x01, 0x43, 0x2d, 0x52, - 0x33, 0xe0, 0x01, 0x42, 0x22, 0x00, 0x43, 0xe0, 0x01, 0xe9, 0x38, 0xe0, - 0x81, 0x6d, 0x42, 0x82, 0x20, 0x4d, 0xe0, 0x01, 0x42, 0x1b, 0x02, 0x39, - 0xe0, 0x01, 0xef, 0x3c, 0xe0, 0x01, 0xb0, 0x51, 0xb3, 0x36, 0xb4, 0x2a, - 0xf5, 0x41, 0xe0, 0x01, 0x42, 0x32, 0x00, 0x32, 0xe0, 0x01, 0xb9, 0x0d, - 0xba, 0x01, 0xff, 0xe5, 0x37, 0xe0, 0x01, 0x42, 0xb0, 0x01, 0x36, 0xe0, - 0x41, 0x43, 0xb7, 0x2b, 0x47, 0xe0, 0x81, 0x04, 0xf5, 0x49, 0xe0, 0x41, - 0x4e, 0x84, 0x75, 0x6c, 0xe0, 0x41, 0xe5, 0x40, 0xe0, 0x01, 0x42, 0x46, - 0x03, 0x44, 0xe0, 0x41, 0x44, 0xca, 0x7b, 0x4b, 0xe0, 0x01, 0x42, 0x22, - 0x00, 0x46, 0xe0, 0x01, 0x49, 0x11, 0xc0, 0x4f, 0xe0, 0xc1, 0x00, 0x4c, - 0xf5, 0x28, 0x6d, 0xe0, 0x41, 0x47, 0xea, 0xc9, 0x50, 0xe0, 0x01, 0xe5, - 0x3d, 0xe0, 0x41, 0xe5, 0x35, 0xe0, 0x41, 0xe6, 0x42, 0xe0, 0x01, 0xec, - 0x3a, 0xe0, 0x01, 0xed, 0x3b, 0xe0, 0x01, 0xf2, 0x3e, 0xe0, 0x01, 0xf3, - 0x3f, 0xe0, 0xc1, 0x00, 0x4f, 0xee, 0x69, 0x6b, 0xe0, 0x41, 0xe5, 0x34, - 0xe0, 0x01, 0x43, 0x0c, 0xf5, 0x4a, 0xe0, 0x41, 0x47, 0x22, 0xcf, 0x4e, - 0xe0, 0x01, 0xe5, 0x31, 0xe0, 0x01, 0x57, 0x84, 0x08, 0x4c, 0xe0, 0x41, - 0x04, 0x27, 0x16, 0x1d, 0x03, 0xe1, 0x05, 0x01, 0xff, 0x44, 0x46, 0x30, - 0x00, 0xa7, 0x00, 0x42, 0x7c, 0x00, 0x04, 0xa7, 0x00, 0x42, 0x3d, 0x00, - 0x06, 0xa7, 0x00, 0x45, 0xf3, 0xea, 0x02, 0xa7, 0x40, 0x44, 0x46, 0x30, - 0x01, 0xa7, 0x00, 0x42, 0x7c, 0x00, 0x05, 0xa7, 0x00, 0x42, 0x3d, 0x00, - 0x07, 0xa7, 0x00, 0x45, 0xf3, 0xea, 0x03, 0xa7, 0x40, 0x4e, 0xf9, 0x13, - 0xd3, 0x02, 0x00, 0x4f, 0x8b, 0x72, 0xd2, 0x02, 0x40, 0xe1, 0x2c, 0x1d, - 0x80, 0x79, 0xe2, 0x2e, 0x1d, 0x80, 0x6e, 0xe3, 0xf2, 0xa7, 0x00, 0xe4, - 0x30, 0x1d, 0x00, 0xe5, 0x31, 0x1d, 0x00, 0xe6, 0xf3, 0xa7, 0x00, 0xe7, - 0x33, 0x1d, 0x00, 0xe8, 0x34, 0x1d, 0x80, 0x4f, 0xe9, 0x35, 0x1d, 0x00, - 0xea, 0x36, 0x1d, 0x00, 0xeb, 0x37, 0x1d, 0x00, 0xec, 0x38, 0x1d, 0x00, - 0xed, 0x39, 0x1d, 0x00, 0xee, 0x3a, 0x1d, 0x00, 0xef, 0x3c, 0x1d, 0x80, - 0x2e, 0xf0, 0x3e, 0x1d, 0x00, 0xf1, 0xf4, 0xa7, 0x00, 0xf2, 0x3f, 0x1d, - 0x80, 0x14, 0xf3, 0xf1, 0xa7, 0x00, 0xf4, 0x40, 0x1d, 0x00, 0xf5, 0x41, - 0x1d, 0x00, 0xf6, 0x7d, 0x2c, 0x00, 0xf7, 0x42, 0x1d, 0x40, 0x08, 0xde, - 0x14, 0x01, 0xff, 0xe5, 0x32, 0x1d, 0x00, 0xee, 0x3b, 0x1d, 0x40, 0xf5, - 0x3d, 0x1d, 0x40, 0x4c, 0xf5, 0x28, 0xf8, 0xa7, 0x40, 0x47, 0x1b, 0xcf, - 0x2f, 0x1d, 0x40, 0xe5, 0x2d, 0x1d, 0x40, 0x05, 0xb9, 0x3f, 0x06, 0x4d, - 0x2c, 0x84, 0xb5, 0x07, 0x41, 0x49, 0xeb, 0x42, 0xf9, 0x02, 0x00, 0x48, - 0x3e, 0xb5, 0xfb, 0x02, 0x40, 0x4b, 0x11, 0x8c, 0xca, 0x02, 0x00, 0x4d, - 0x7e, 0x85, 0xb8, 0x07, 0x01, 0x49, 0x7d, 0x36, 0xbc, 0x02, 0x40, 0x51, - 0xe3, 0x57, 0x43, 0x16, 0x01, 0xa4, 0x89, 0x03, 0x07, 0xec, 0x05, 0x6d, - 0x05, 0x5a, 0x03, 0x44, 0x0b, 0x55, 0x77, 0x01, 0xff, 0xa1, 0x31, 0xe5, - 0x39, 0x16, 0x01, 0xe9, 0x31, 0x16, 0x81, 0x24, 0xef, 0x3b, 0x16, 0x01, - 0xf5, 0x33, 0x16, 0x81, 0x17, 0x08, 0x43, 0xc1, 0x01, 0xff, 0xec, 0x37, - 0x16, 0x81, 0x09, 0xf2, 0x35, 0x16, 0xc1, 0x00, 0xf2, 0x36, 0x16, 0x41, - 0xec, 0x38, 0x16, 0x41, 0xf5, 0x34, 0x16, 0x41, 0xe9, 0x32, 0x16, 0x41, - 0xe1, 0x30, 0x16, 0x01, 0xe9, 0x3a, 0x16, 0x01, 0xf5, 0x3c, 0x16, 0x41, - 0xa1, 0x17, 0x44, 0x85, 0xf0, 0x44, 0x16, 0x01, 0x02, 0x02, 0x00, 0x01, - 0xff, 0x44, 0xe7, 0x23, 0x3f, 0x16, 0x01, 0x45, 0xf3, 0x4b, 0x3e, 0x16, - 0x41, 0x47, 0x3d, 0x16, 0x3d, 0x16, 0x01, 0x4a, 0x1c, 0xb0, 0x40, 0x16, - 0x41, 0xe1, 0x00, 0x16, 0x81, 0x86, 0x02, 0xa2, 0xf9, 0x01, 0xa3, 0xec, - 0x01, 0xa4, 0xd3, 0x01, 0xe5, 0x0a, 0x16, 0x01, 0xa7, 0xc2, 0x01, 0x42, - 0x22, 0x00, 0x2e, 0x16, 0x01, 0xe9, 0x02, 0x16, 0x81, 0xb2, 0x01, 0xaa, - 0xa5, 0x01, 0xab, 0x98, 0x01, 0xac, 0x8b, 0x01, 0x42, 0x6c, 0x00, 0x26, - 0x16, 0x01, 0xae, 0x6d, 0xef, 0x0c, 0x16, 0x01, 0xb0, 0x5d, 0x42, 0x71, - 0x00, 0x28, 0x16, 0x01, 0xb3, 0x45, 0xb4, 0x2c, 0xf5, 0x04, 0x16, 0x81, - 0x23, 0xb6, 0x06, 0x42, 0xbe, 0x22, 0x27, 0x16, 0x41, 0xe1, 0x2a, 0x16, - 0x01, 0x07, 0x44, 0xc1, 0x01, 0xff, 0xec, 0x08, 0x16, 0x81, 0x09, 0xf2, - 0x06, 0x16, 0xc1, 0x00, 0xf2, 0x07, 0x16, 0x41, 0xec, 0x09, 0x16, 0x41, - 0xf5, 0x05, 0x16, 0x41, 0xe1, 0x1d, 0x16, 0x01, 0x42, 0x22, 0x00, 0x1e, - 0x16, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x18, 0x16, 0x01, 0x42, 0x22, 0x00, - 0x19, 0x16, 0x41, 0xe1, 0x2d, 0x16, 0x01, 0x42, 0x22, 0x00, 0x2b, 0x16, - 0x01, 0x42, 0x40, 0x06, 0x2c, 0x16, 0x41, 0xe1, 0x22, 0x16, 0x01, 0x42, - 0x22, 0x00, 0x23, 0x16, 0x41, 0xe1, 0x21, 0x16, 0x01, 0x42, 0x24, 0x02, - 0x12, 0x16, 0x01, 0x42, 0x2a, 0x05, 0x1c, 0x16, 0x01, 0x42, 0xbe, 0x22, - 0x17, 0x16, 0x41, 0xe1, 0x29, 0x16, 0x01, 0x42, 0x74, 0x00, 0x2f, 0x16, - 0x41, 0xe1, 0x0e, 0x16, 0x01, 0x42, 0x22, 0x00, 0x0f, 0x16, 0x41, 0xe1, - 0x15, 0x16, 0x01, 0x42, 0x22, 0x00, 0x16, 0x16, 0x41, 0xe9, 0x03, 0x16, - 0x41, 0xe1, 0x10, 0x16, 0x01, 0x42, 0x22, 0x00, 0x11, 0x16, 0x41, 0xe1, - 0x1f, 0x16, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x20, 0x16, 0x41, 0xe1, - 0x1a, 0x16, 0x01, 0x42, 0x22, 0x00, 0x1b, 0x16, 0x41, 0xe1, 0x13, 0x16, - 0x01, 0x42, 0x22, 0x00, 0x14, 0x16, 0x41, 0xe1, 0x24, 0x16, 0x01, 0x42, - 0x22, 0x00, 0x25, 0x16, 0x41, 0xe1, 0x01, 0x16, 0x01, 0xe9, 0x0b, 0x16, - 0x01, 0xf5, 0x0d, 0x16, 0x41, 0x44, 0x75, 0x20, 0x41, 0x16, 0x01, 0x05, - 0xf0, 0x06, 0x06, 0x4b, 0x2a, 0xa1, 0x42, 0x16, 0x41, 0x45, 0x12, 0x0b, - 0x58, 0x16, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x59, 0x16, 0x01, 0x43, - 0x0e, 0x0b, 0x51, 0x16, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, - 0x50, 0x16, 0x41, 0x44, 0x25, 0x01, 0x53, 0x16, 0x01, 0x42, 0x15, 0x02, - 0x52, 0x16, 0x41, 0x44, 0xe5, 0x1d, 0x57, 0x16, 0x01, 0x42, 0x1c, 0x26, - 0x56, 0x16, 0x41, 0x43, 0xd2, 0x05, 0x55, 0x16, 0x01, 0x43, 0xf6, 0x06, - 0x54, 0x16, 0x41, 0x42, 0x1b, 0x08, 0xa7, 0x22, 0x00, 0x4d, 0x15, 0x88, - 0x3b, 0xf9, 0x41, 0x80, 0x01, 0xff, 0x43, 0x2a, 0x80, 0xf4, 0xf4, 0x01, - 0x5d, 0xe1, 0x16, 0xf2, 0xf4, 0x41, 0x03, 0x0b, 0x7b, 0xe2, 0x01, 0x02, - 0x75, 0x06, 0xb4, 0x01, 0xa4, 0x84, 0x01, 0xac, 0x66, 0xae, 0x0d, 0x44, - 0xe3, 0x52, 0x9e, 0xfa, 0xc1, 0x00, 0x45, 0xe8, 0x1c, 0xa9, 0xfa, 0x41, - 0xa9, 0x43, 0x02, 0xef, 0x02, 0x04, 0xf9, 0xff, 0x29, 0x40, 0x80, 0x06, - 0x4d, 0x36, 0x80, 0x13, 0x22, 0x40, 0x44, 0x5a, 0x03, 0x12, 0x22, 0x80, - 0x06, 0x45, 0x37, 0x23, 0x42, 0x22, 0x40, 0x80, 0x01, 0xff, 0x4b, 0xe7, - 0x1e, 0x3a, 0x2a, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4b, 0xe2, 0x5e, - 0x29, 0x2a, 0x00, 0x49, 0x9f, 0x12, 0x2a, 0x2a, 0x00, 0x4c, 0xe0, 0x8e, - 0x2b, 0x2a, 0x00, 0x4b, 0x48, 0xa2, 0x2c, 0x2a, 0x40, 0x43, 0xb1, 0x27, - 0x90, 0xf6, 0x01, 0x44, 0x43, 0x64, 0xbd, 0xf4, 0x01, 0x44, 0x88, 0xe1, - 0xd5, 0xf5, 0x41, 0x06, 0x59, 0x5c, 0x0c, 0x46, 0xa2, 0xdd, 0x0c, 0xf3, - 0x01, 0x46, 0x3e, 0x4c, 0xa5, 0x20, 0x40, 0x46, 0x13, 0xc3, 0x96, 0xfa, - 0x01, 0x45, 0x4b, 0x71, 0x96, 0xf3, 0x41, 0x04, 0x80, 0x02, 0x06, 0x58, - 0xd9, 0x29, 0xef, 0x22, 0x40, 0x43, 0x23, 0x0a, 0xb7, 0x00, 0x00, 0x56, - 0x52, 0x35, 0xe6, 0xfb, 0x01, 0x57, 0xf7, 0x30, 0xe7, 0xfb, 0x01, 0x06, - 0x4d, 0x89, 0x01, 0xff, 0x48, 0x29, 0xc7, 0x0c, 0xcc, 0x01, 0x5a, 0x8a, - 0x22, 0xc2, 0xfb, 0x41, 0x80, 0x1b, 0xaf, 0x01, 0xff, 0x45, 0x59, 0x03, - 0xb5, 0x00, 0x00, 0x42, 0xb7, 0x05, 0xa0, 0xf9, 0x01, 0x45, 0x35, 0x3d, - 0xa4, 0xf3, 0x01, 0x45, 0xa4, 0xcb, 0x2c, 0xf5, 0x41, 0x4b, 0xe4, 0x9a, - 0x49, 0x24, 0x00, 0x4c, 0x48, 0x93, 0x48, 0x24, 0x40, 0x07, 0xec, 0x05, - 0xbc, 0x02, 0x05, 0x5a, 0x03, 0x9a, 0x02, 0x05, 0x56, 0x2d, 0xfd, 0x01, - 0x0b, 0x55, 0x77, 0x01, 0xff, 0xe1, 0x54, 0x6f, 0x81, 0xce, 0x01, 0xe5, - 0x5d, 0x6f, 0x81, 0xae, 0x01, 0xe9, 0x61, 0x6f, 0x81, 0x7a, 0xee, 0x7d, - 0x6f, 0x81, 0x71, 0xef, 0x59, 0x6f, 0x81, 0x56, 0x4a, 0xbc, 0xb0, 0x78, - 0x6f, 0x81, 0x4b, 0xf5, 0x6a, 0x6f, 0x81, 0x1e, 0x42, 0x47, 0xf5, 0x83, - 0x6f, 0x01, 0xf7, 0x5c, 0x6f, 0x81, 0x0f, 0xf9, 0x71, 0x6f, 0xc1, 0x00, - 0xe9, 0x72, 0x6f, 0x01, 0x42, 0x3e, 0x00, 0x80, 0x6f, 0x41, 0xef, 0x5b, - 0x6f, 0x41, 0xe1, 0x6b, 0x6f, 0x81, 0x1a, 0x42, 0x12, 0x0b, 0x6f, 0x6f, - 0x01, 0xe9, 0x87, 0x6f, 0x01, 0x42, 0x1d, 0x01, 0x70, 0x6f, 0x01, 0x42, - 0xdd, 0x18, 0x7f, 0x6f, 0x01, 0xf5, 0x6e, 0x6f, 0x41, 0xee, 0x6c, 0x6f, - 0xc1, 0x00, 0xe7, 0x6d, 0x6f, 0x41, 0xf2, 0x76, 0x6f, 0x41, 0xa5, 0x0c, - 0xe7, 0x81, 0x6f, 0x01, 0xef, 0x5a, 0x6f, 0x01, 0xf5, 0x7c, 0x6f, 0x41, - 0xf2, 0x82, 0x6f, 0x01, 0xf9, 0x60, 0x6f, 0x41, 0xe7, 0x7e, 0x6f, 0x41, - 0xe1, 0x62, 0x6f, 0x81, 0x21, 0xe5, 0x66, 0x6f, 0x01, 0xe7, 0x84, 0x6f, - 0x01, 0xe9, 0x67, 0x6f, 0x01, 0x42, 0x1d, 0x01, 0x69, 0x6f, 0x01, 0xef, - 0x65, 0x6f, 0x81, 0x04, 0xf5, 0x68, 0x6f, 0x41, 0x42, 0x1d, 0x01, 0x86, - 0x6f, 0x41, 0xee, 0x63, 0x6f, 0xc1, 0x00, 0xe7, 0x64, 0x6f, 0x41, 0xe1, - 0x85, 0x6f, 0x01, 0xe9, 0x7a, 0x6f, 0x01, 0xee, 0x5e, 0x6f, 0x81, 0x09, - 0xf2, 0x77, 0x6f, 0xc1, 0x00, 0xf2, 0x75, 0x6f, 0x41, 0xe7, 0x5f, 0x6f, - 0x41, 0xe1, 0x55, 0x6f, 0x01, 0xe5, 0x73, 0x6f, 0x81, 0x17, 0x42, 0xe3, - 0x49, 0x56, 0x6f, 0x01, 0xe9, 0x79, 0x6f, 0x01, 0xee, 0x57, 0x6f, 0x81, - 0x04, 0xf5, 0x7b, 0x6f, 0x41, 0xe7, 0x58, 0x6f, 0x41, 0xe5, 0x74, 0x6f, - 0x41, 0x45, 0x5c, 0x00, 0x91, 0x6f, 0x01, 0x45, 0x20, 0x07, 0x92, 0x6f, - 0x01, 0x45, 0xc8, 0x00, 0x8f, 0x6f, 0x01, 0x49, 0xe4, 0x73, 0x90, 0x6f, - 0x41, 0x4a, 0x06, 0xa8, 0x51, 0x6f, 0x01, 0x56, 0x42, 0x33, 0x4f, 0x6f, - 0x01, 0x09, 0xc4, 0xbe, 0x01, 0xff, 0x4a, 0x06, 0xa8, 0x53, 0x6f, 0x01, - 0x47, 0x79, 0xd7, 0x52, 0x6f, 0x41, 0xa1, 0x82, 0x04, 0xa2, 0xf5, 0x03, - 0xa4, 0xc1, 0x03, 0x42, 0x0c, 0x08, 0x07, 0x6f, 0x01, 0xa7, 0xa7, 0x03, - 0xa8, 0x9a, 0x03, 0x42, 0x1b, 0x02, 0x1e, 0x6f, 0x01, 0xac, 0xfb, 0x02, - 0xad, 0xee, 0x02, 0xae, 0xb5, 0x02, 0xb0, 0xa8, 0x02, 0xb1, 0x9b, 0x02, - 0xb2, 0xec, 0x01, 0xb3, 0xd3, 0x01, 0xb4, 0x7f, 0xb6, 0x73, 0x42, 0xa9, - 0x01, 0x42, 0x6f, 0x01, 0x42, 0x08, 0x27, 0x27, 0x6f, 0x01, 0x03, 0x39, - 0x7a, 0x32, 0xba, 0x01, 0xff, 0xe1, 0x3b, 0x6f, 0x01, 0x42, 0x22, 0x00, - 0x35, 0x6f, 0x01, 0xb3, 0x19, 0xba, 0x01, 0xff, 0xe1, 0x3d, 0x6f, 0x01, - 0xb3, 0x06, 0x42, 0xbe, 0x22, 0x40, 0x6f, 0x41, 0xe1, 0x3e, 0x6f, 0x01, - 0x42, 0xbe, 0x22, 0x41, 0x6f, 0x41, 0xe1, 0x3c, 0x6f, 0x01, 0x42, 0x22, - 0x00, 0x36, 0x6f, 0x41, 0x44, 0xb1, 0xef, 0x31, 0x6f, 0x01, 0x42, 0x1b, - 0x02, 0x20, 0x6f, 0x01, 0x43, 0x08, 0x46, 0x12, 0x6f, 0x01, 0x42, 0xbb, - 0x09, 0x02, 0x6f, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x0d, 0x6f, 0x01, 0xb3, - 0x06, 0x42, 0x12, 0x00, 0x0c, 0x6f, 0x41, 0xe1, 0x39, 0x6f, 0x01, 0x42, - 0x22, 0x00, 0x30, 0x6f, 0x41, 0xe1, 0x08, 0x6f, 0x01, 0x42, 0x0c, 0x08, - 0x09, 0x6f, 0x41, 0xe1, 0x0a, 0x6f, 0x01, 0xe5, 0x48, 0x6f, 0x01, 0x02, - 0x2a, 0x09, 0x3c, 0x04, 0x02, 0x20, 0x1c, 0xb3, 0x06, 0x42, 0x12, 0x00, - 0x0e, 0x6f, 0x41, 0xe1, 0x37, 0x6f, 0x01, 0xe5, 0x49, 0x6f, 0x01, 0x42, - 0x22, 0x00, 0x2e, 0x6f, 0x01, 0x42, 0x40, 0x06, 0x2a, 0x6f, 0x41, 0xd2, - 0x93, 0x6f, 0x01, 0xd3, 0x94, 0x6f, 0x01, 0xd4, 0x95, 0x6f, 0x01, 0xd5, - 0x96, 0x6f, 0x01, 0xd6, 0x97, 0x6f, 0x01, 0xd7, 0x98, 0x6f, 0x01, 0xd8, - 0x99, 0x6f, 0x41, 0xe1, 0x1a, 0x6f, 0x01, 0x42, 0xbe, 0x22, 0x1c, 0x6f, - 0x41, 0xe1, 0x3a, 0x6f, 0x01, 0x42, 0x22, 0x00, 0x33, 0x6f, 0x01, 0x42, - 0x40, 0x06, 0x34, 0x6f, 0x01, 0x42, 0x9a, 0x1a, 0x46, 0x6f, 0x41, 0x09, - 0x55, 0xb8, 0x06, 0x42, 0x77, 0x00, 0x4a, 0x6f, 0x41, 0x04, 0x02, 0x20, - 0x06, 0x43, 0xa4, 0x02, 0x32, 0x6f, 0x41, 0xd1, 0x9a, 0x6f, 0x01, 0xd2, - 0x9b, 0x6f, 0x01, 0xd4, 0x9c, 0x6f, 0x01, 0xd5, 0x9d, 0x6f, 0x01, 0xd6, - 0x9e, 0x6f, 0x01, 0xd8, 0x9f, 0x6f, 0x41, 0xe1, 0x21, 0x6f, 0x01, 0x42, - 0x24, 0x02, 0x22, 0x6f, 0x41, 0xe1, 0x00, 0x6f, 0x01, 0x42, 0x74, 0x00, - 0x03, 0x6f, 0x41, 0xe1, 0x10, 0x6f, 0x81, 0x2b, 0xa7, 0x1f, 0x42, 0x22, - 0x00, 0x11, 0x6f, 0x01, 0xae, 0x0d, 0xb9, 0x01, 0xff, 0xe1, 0x2c, 0x6f, - 0x01, 0x42, 0x22, 0x00, 0x2d, 0x6f, 0x41, 0xe1, 0x14, 0x6f, 0x01, 0x42, - 0x22, 0x00, 0x15, 0x6f, 0x41, 0xe1, 0x23, 0x6f, 0x01, 0x42, 0x22, 0x00, - 0x24, 0x6f, 0x41, 0x4a, 0x69, 0x5c, 0x50, 0x6f, 0x41, 0xe1, 0x04, 0x6f, - 0x01, 0x42, 0x22, 0x00, 0x05, 0x6f, 0x41, 0xe1, 0x16, 0x6f, 0x01, 0xa8, - 0x06, 0x42, 0xbe, 0x22, 0x17, 0x6f, 0x41, 0xe1, 0x18, 0x6f, 0x01, 0x42, - 0xbe, 0x22, 0x19, 0x6f, 0x41, 0xe1, 0x26, 0x6f, 0x01, 0x42, 0x22, 0x00, - 0x44, 0x6f, 0x41, 0xe1, 0x1f, 0x6f, 0x01, 0xa8, 0x01, 0xff, 0xe1, 0x28, - 0x6f, 0x01, 0x42, 0x22, 0x00, 0x29, 0x6f, 0x41, 0xe1, 0x0b, 0x6f, 0x01, - 0x42, 0xf0, 0x10, 0x0f, 0x6f, 0x01, 0x02, 0x2a, 0x09, 0x19, 0xba, 0x01, - 0xff, 0xe1, 0x38, 0x6f, 0x01, 0x42, 0x22, 0x00, 0x2f, 0x6f, 0x01, 0x42, - 0x9a, 0x1a, 0x47, 0x6f, 0x01, 0x42, 0x59, 0x00, 0x2b, 0x6f, 0x41, 0xe1, - 0x1b, 0x6f, 0x01, 0x42, 0xbe, 0x22, 0x1d, 0x6f, 0x41, 0xe1, 0x01, 0x6f, - 0x01, 0x42, 0x0d, 0x00, 0x45, 0x6f, 0x41, 0xe8, 0x43, 0x6f, 0x01, 0x07, - 0xb9, 0x80, 0x01, 0xff, 0x42, 0x6c, 0x00, 0x06, 0x6f, 0x01, 0xae, 0x06, - 0x43, 0x26, 0x9a, 0x3f, 0x6f, 0x41, 0xe1, 0x13, 0x6f, 0x01, 0x42, 0x24, - 0x02, 0x25, 0x6f, 0x41, 0xa1, 0xcf, 0x1c, 0x09, 0x47, 0xb7, 0xbe, 0x1c, - 0xa4, 0xd1, 0x16, 0x0b, 0x18, 0x9c, 0xba, 0x12, 0xac, 0xa5, 0x12, 0x42, - 0xc3, 0x07, 0xdd, 0xf4, 0x01, 0xae, 0xa8, 0x07, 0xb2, 0x5c, 0x4d, 0xff, - 0x88, 0x95, 0x00, 0x00, 0xb4, 0x01, 0xff, 0x42, 0x5f, 0x03, 0xc3, 0xce, - 0x01, 0xb2, 0x01, 0xff, 0x05, 0x36, 0x00, 0x04, 0xef, 0x87, 0xf6, 0x41, - 0x45, 0x55, 0x23, 0xd1, 0x23, 0x00, 0x0a, 0x6a, 0xad, 0x2c, 0x49, 0x22, - 0xbe, 0xd9, 0x23, 0x00, 0x4f, 0x12, 0x73, 0xd3, 0x23, 0x00, 0xb4, 0x01, - 0xff, 0x48, 0x11, 0xc6, 0xd8, 0x23, 0x00, 0x46, 0xb8, 0xdf, 0xd7, 0x23, - 0x00, 0x0a, 0xd2, 0xb3, 0x01, 0xff, 0x46, 0x9d, 0x0a, 0xd6, 0x23, 0x00, - 0x49, 0x00, 0x1d, 0xd5, 0x23, 0x40, 0x45, 0x33, 0x07, 0xd2, 0x23, 0x00, - 0x4a, 0x6a, 0xb2, 0xd4, 0x23, 0x40, 0x44, 0xff, 0x62, 0x3f, 0x26, 0x00, - 0x06, 0xe0, 0xde, 0x06, 0x46, 0x3a, 0x1d, 0xdc, 0xf9, 0x41, 0x08, 0x01, - 0xc5, 0xc2, 0x01, 0x0d, 0xc4, 0x83, 0x01, 0xff, 0x07, 0xec, 0x05, 0x0d, - 0x4b, 0x24, 0xa3, 0x9e, 0x09, 0xc1, 0x00, 0x42, 0xab, 0xf3, 0x9f, 0x09, - 0x41, 0xe1, 0x80, 0x09, 0x01, 0x42, 0x16, 0x00, 0x86, 0x09, 0x81, 0x9a, - 0x01, 0x42, 0xf0, 0x10, 0x9d, 0x09, 0x01, 0xe5, 0x81, 0x09, 0x01, 0x43, - 0x1b, 0x52, 0x92, 0x09, 0x01, 0xe9, 0x82, 0x09, 0x01, 0xab, 0x7a, 0x42, - 0x74, 0x00, 0x90, 0x09, 0x01, 0x42, 0x6c, 0x00, 0x89, 0x09, 0x01, 0xae, - 0x56, 0xef, 0x83, 0x09, 0x01, 0x42, 0xbb, 0x09, 0x88, 0x09, 0x01, 0x42, - 0x43, 0x14, 0x97, 0x09, 0x01, 0x42, 0x71, 0x00, 0x8e, 0x09, 0x81, 0x39, - 0xb3, 0x28, 0xb4, 0x0c, 0x42, 0xa9, 0x01, 0x85, 0x09, 0x01, 0x42, 0xbe, - 0x22, 0x84, 0x09, 0x41, 0xe1, 0x98, 0x09, 0x81, 0x0f, 0xe5, 0x9a, 0x09, - 0x81, 0x04, 0xef, 0x9c, 0x09, 0x41, 0x42, 0xab, 0xf3, 0x9b, 0x09, 0x41, - 0x42, 0xab, 0xf3, 0x99, 0x09, 0x41, 0xe1, 0x93, 0x09, 0x81, 0x04, 0xe5, - 0x95, 0x09, 0x41, 0x42, 0xab, 0xf3, 0x94, 0x09, 0x41, 0x42, 0xab, 0xf3, - 0x8f, 0x09, 0x41, 0xe1, 0x8a, 0x09, 0x81, 0x0b, 0xe5, 0x8c, 0x09, 0xc1, - 0x00, 0x42, 0xab, 0xf3, 0x8d, 0x09, 0x41, 0x42, 0xab, 0xf3, 0x8b, 0x09, - 0x41, 0xe1, 0x96, 0x09, 0x01, 0x42, 0x22, 0x00, 0x91, 0x09, 0x41, 0x42, - 0xab, 0xf3, 0x87, 0x09, 0x41, 0x09, 0x25, 0x5a, 0x99, 0x04, 0xac, 0x80, - 0x03, 0x07, 0x1a, 0x3a, 0x01, 0xff, 0x45, 0x12, 0x0b, 0xc7, 0x09, 0x81, - 0xd8, 0x02, 0xa6, 0xfc, 0x01, 0x44, 0xea, 0x2a, 0xc8, 0x09, 0x81, 0xd9, - 0x01, 0x43, 0x0e, 0x0b, 0xc0, 0x09, 0x81, 0xbb, 0x01, 0xb3, 0x67, 0xb4, - 0x01, 0xff, 0x42, 0x92, 0x01, 0xc9, 0x09, 0x81, 0x57, 0xa8, 0x2b, 0xb7, - 0x01, 0xff, 0x44, 0xe7, 0x1d, 0xca, 0x09, 0x81, 0x1b, 0xef, 0xc1, 0x09, - 0xc1, 0x00, 0x80, 0x01, 0xff, 0x47, 0x71, 0x11, 0xd3, 0x09, 0x81, 0x06, - 0x48, 0x47, 0x5e, 0xdc, 0x09, 0x41, 0x49, 0x46, 0x5e, 0xee, 0x09, 0x41, - 0x49, 0x46, 0x5e, 0xe5, 0x09, 0x41, 0x44, 0x7b, 0x11, 0xcb, 0x09, 0x81, - 0x1d, 0x43, 0x26, 0x01, 0xc2, 0x09, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x47, - 0x71, 0x11, 0xd4, 0x09, 0x81, 0x06, 0x48, 0x47, 0x5e, 0xdd, 0x09, 0x41, - 0x49, 0x46, 0x5e, 0xef, 0x09, 0x41, 0x49, 0x46, 0x5e, 0xe6, 0x09, 0x41, - 0x49, 0x46, 0x5e, 0xe4, 0x09, 0x41, 0x44, 0xe5, 0x1d, 0xc6, 0x09, 0x81, - 0x29, 0x42, 0x1c, 0x26, 0xc5, 0x09, 0xc1, 0x00, 0x80, 0x0d, 0x42, 0x7d, - 0x11, 0xce, 0x09, 0xc1, 0x00, 0x49, 0x46, 0x5e, 0xe9, 0x09, 0x41, 0x47, - 0x71, 0x11, 0xd7, 0x09, 0x81, 0x06, 0x48, 0x47, 0x5e, 0xe0, 0x09, 0x41, - 0x49, 0x46, 0x5e, 0xf2, 0x09, 0x41, 0x80, 0x0d, 0x42, 0x7d, 0x11, 0xcf, - 0x09, 0xc1, 0x00, 0x49, 0x46, 0x5e, 0xea, 0x09, 0x41, 0x47, 0x71, 0x11, - 0xd8, 0x09, 0x81, 0x06, 0x48, 0x47, 0x5e, 0xe1, 0x09, 0x41, 0x49, 0x46, - 0x5e, 0xf3, 0x09, 0x41, 0x80, 0x01, 0xff, 0x47, 0x71, 0x11, 0xd2, 0x09, - 0x81, 0x06, 0x48, 0x47, 0x5e, 0xdb, 0x09, 0x41, 0x49, 0x46, 0x5e, 0xed, - 0x09, 0x41, 0x80, 0x06, 0x4b, 0x16, 0xa4, 0xec, 0x09, 0x41, 0x47, 0x71, - 0x11, 0xda, 0x09, 0x81, 0x06, 0x48, 0x47, 0x5e, 0xe3, 0x09, 0x41, 0x49, - 0x46, 0x5e, 0xf5, 0x09, 0x41, 0xa9, 0x2d, 0xaf, 0x01, 0xff, 0x43, 0x7c, - 0x11, 0xcc, 0x09, 0x81, 0x1d, 0x42, 0x42, 0x00, 0xc3, 0x09, 0xc1, 0x00, - 0x80, 0x01, 0xff, 0x47, 0x71, 0x11, 0xd5, 0x09, 0x81, 0x06, 0x48, 0x47, - 0x5e, 0xde, 0x09, 0x41, 0x49, 0x46, 0x5e, 0xf0, 0x09, 0x41, 0x49, 0x46, - 0x5e, 0xe7, 0x09, 0x41, 0x43, 0x59, 0x4d, 0xcd, 0x09, 0x81, 0x1d, 0x42, - 0x32, 0x00, 0xc4, 0x09, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x47, 0x71, 0x11, - 0xd6, 0x09, 0x81, 0x06, 0x48, 0x47, 0x5e, 0xdf, 0x09, 0x41, 0x49, 0x46, - 0x5e, 0xf1, 0x09, 0x41, 0x49, 0x46, 0x5e, 0xe8, 0x09, 0x41, 0x80, 0x06, - 0x4a, 0x17, 0xa4, 0xeb, 0x09, 0x41, 0x47, 0x71, 0x11, 0xd9, 0x09, 0x81, - 0x06, 0x48, 0x47, 0x5e, 0xe2, 0x09, 0x41, 0x49, 0x46, 0x5e, 0xf4, 0x09, - 0x41, 0x06, 0xed, 0x05, 0x11, 0x08, 0xbf, 0x3f, 0x01, 0xff, 0x43, 0x7c, - 0xf4, 0xbf, 0x09, 0x01, 0x43, 0x30, 0x5e, 0xbe, 0x09, 0x41, 0xe1, 0xa0, - 0x09, 0x81, 0x76, 0x42, 0x16, 0x00, 0xa6, 0x09, 0x01, 0x42, 0xf0, 0x10, - 0xb7, 0x09, 0x01, 0xe5, 0xa1, 0x09, 0x01, 0x43, 0x1b, 0x52, 0xae, 0x09, - 0x01, 0xe9, 0xa2, 0x09, 0x01, 0xab, 0x50, 0x42, 0x74, 0x00, 0xac, 0x09, - 0x01, 0x42, 0x6c, 0x00, 0xa8, 0x09, 0x01, 0xae, 0x3a, 0xef, 0xa3, 0x09, - 0x01, 0x42, 0xbb, 0x09, 0xa7, 0x09, 0x01, 0x42, 0x43, 0x14, 0xb3, 0x09, - 0x01, 0x42, 0x71, 0x00, 0xab, 0x09, 0x01, 0xb3, 0x1a, 0xb4, 0x0c, 0x42, - 0xa9, 0x01, 0xa5, 0x09, 0x01, 0x42, 0xbe, 0x22, 0xa4, 0x09, 0x41, 0xe1, - 0xb4, 0x09, 0x01, 0xe5, 0xb5, 0x09, 0x01, 0xef, 0xb6, 0x09, 0x41, 0xe1, - 0xaf, 0x09, 0x01, 0xe5, 0xb1, 0x09, 0x41, 0xe1, 0xa9, 0x09, 0x01, 0xe5, - 0xaa, 0x09, 0x41, 0xe1, 0xb2, 0x09, 0x01, 0x42, 0x22, 0x00, 0xad, 0x09, - 0x41, 0x49, 0x50, 0x94, 0xb0, 0x09, 0x41, 0xa5, 0x47, 0xa6, 0x39, 0x4d, - 0x75, 0x86, 0xfe, 0x09, 0x01, 0x04, 0x0e, 0x0b, 0x23, 0xb3, 0x15, 0xb4, - 0x01, 0xff, 0x4b, 0x93, 0x79, 0xff, 0x09, 0x01, 0x4d, 0xde, 0x83, 0xf8, - 0x09, 0x01, 0x4b, 0x55, 0xa5, 0xf7, 0x09, 0x41, 0x4d, 0x91, 0x79, 0xfc, - 0x09, 0x01, 0x4b, 0xf1, 0x9d, 0xfb, 0x09, 0x41, 0x44, 0x22, 0x00, 0xbd, - 0x09, 0x01, 0x47, 0x96, 0x79, 0xf6, 0x09, 0x41, 0x4c, 0x90, 0x90, 0xfa, - 0x09, 0x01, 0x4c, 0xb4, 0x93, 0xf9, 0x09, 0x41, 0x4d, 0x1f, 0x84, 0xfd, - 0x09, 0x01, 0x4e, 0x90, 0x79, 0xbc, 0x09, 0x41, 0x0b, 0xef, 0x9a, 0x0c, - 0x57, 0xe3, 0x2f, 0x4e, 0xf5, 0x01, 0x48, 0x7e, 0x4b, 0xb9, 0xf6, 0x41, - 0x11, 0x48, 0x59, 0xad, 0x0a, 0x06, 0xef, 0x06, 0xeb, 0x09, 0x0a, 0xa2, - 0xb1, 0x01, 0xff, 0x90, 0xf5, 0x04, 0x91, 0x01, 0xff, 0x90, 0xb3, 0x04, - 0x91, 0xf4, 0x03, 0x92, 0xb5, 0x03, 0x93, 0xf6, 0x02, 0x94, 0xb7, 0x02, - 0x95, 0xf8, 0x01, 0x96, 0xb9, 0x01, 0x97, 0x71, 0x98, 0x33, 0x99, 0x01, - 0xff, 0x45, 0x2e, 0xe2, 0x86, 0xe8, 0x01, 0x46, 0xc2, 0xd8, 0xb1, 0xe8, - 0x01, 0x45, 0xab, 0xe2, 0xb6, 0xe8, 0x01, 0x45, 0xd3, 0xe2, 0x75, 0xe8, - 0x01, 0x45, 0x2d, 0xe3, 0x0f, 0xe8, 0x01, 0x44, 0xf5, 0xed, 0x2c, 0xe8, - 0x01, 0x45, 0x5a, 0xe3, 0x35, 0xe8, 0x01, 0x45, 0x73, 0xe3, 0x61, 0xe8, - 0x41, 0x45, 0x1f, 0xe2, 0x42, 0xe8, 0x01, 0x44, 0x29, 0xed, 0x43, 0xe8, - 0x01, 0x44, 0x89, 0xed, 0xb9, 0xe8, 0x01, 0x4b, 0xa8, 0x98, 0x82, 0xe8, - 0x01, 0x46, 0x04, 0xd9, 0x89, 0xe8, 0x01, 0x44, 0x31, 0xee, 0xba, 0xe8, - 0x01, 0x44, 0x28, 0xd9, 0x6a, 0xe8, 0x01, 0x46, 0x4c, 0xd9, 0x9b, 0xe8, - 0x01, 0x46, 0x64, 0xd9, 0x97, 0xe8, 0x01, 0x46, 0x76, 0xd9, 0x1a, 0xe8, - 0x41, 0x46, 0xa4, 0xd8, 0xc2, 0xe8, 0x01, 0x44, 0x4d, 0xed, 0xad, 0xe8, - 0x01, 0x45, 0x9c, 0xe2, 0x99, 0xe8, 0x81, 0x2f, 0x45, 0xe2, 0xe2, 0xbc, - 0xe8, 0x01, 0x45, 0x0f, 0xe3, 0x9a, 0xe8, 0x81, 0x1e, 0x49, 0x97, 0xb5, - 0x52, 0xe8, 0x01, 0x44, 0x4d, 0xee, 0x68, 0xe8, 0x01, 0x47, 0x7a, 0xce, - 0x8b, 0xe8, 0x01, 0x44, 0xad, 0xee, 0x2d, 0xe8, 0x01, 0x45, 0xd2, 0xe3, - 0x07, 0xe8, 0x41, 0xef, 0x9a, 0xe8, 0x41, 0xef, 0x99, 0xe8, 0x41, 0x45, - 0x3d, 0xe2, 0x50, 0xe8, 0x01, 0x4a, 0xe4, 0xa6, 0x9c, 0xe8, 0x01, 0x45, - 0xba, 0xe2, 0x31, 0xe8, 0x01, 0x44, 0x95, 0xed, 0x25, 0xe8, 0x01, 0x46, - 0x10, 0xd9, 0xc0, 0xe8, 0x01, 0x44, 0x25, 0xee, 0x27, 0xe8, 0x01, 0x46, - 0x22, 0xd9, 0x87, 0xe8, 0x01, 0x46, 0x3a, 0xd9, 0x88, 0xe8, 0x01, 0x44, - 0xb5, 0xee, 0x85, 0xe8, 0x01, 0x45, 0xeb, 0xe3, 0x67, 0xe8, 0x41, 0x45, - 0x1a, 0xe2, 0x1e, 0xe8, 0x01, 0x44, 0x5d, 0xed, 0xbb, 0xe8, 0x01, 0x45, - 0xa6, 0xe2, 0xb5, 0xe8, 0x01, 0x44, 0xa8, 0x98, 0x3c, 0xe8, 0x01, 0x46, - 0xfe, 0xd8, 0x19, 0xe8, 0x01, 0x44, 0x0d, 0xee, 0x83, 0xe8, 0x01, 0x47, - 0x6c, 0xce, 0x7c, 0xe8, 0x01, 0x45, 0x82, 0xe3, 0x4e, 0xe8, 0x01, 0x45, - 0xaf, 0xe3, 0xa5, 0xe8, 0x01, 0x47, 0x88, 0xce, 0x7e, 0xe8, 0x41, 0x44, - 0xf9, 0xec, 0x6e, 0xe8, 0x01, 0x45, 0x6f, 0xe2, 0x58, 0xe8, 0x01, 0x4a, - 0xf8, 0xa6, 0x9e, 0xe8, 0x01, 0x45, 0xe7, 0xe2, 0x10, 0xe8, 0x01, 0x45, - 0x23, 0xe3, 0xbe, 0xe8, 0x01, 0x45, 0x3c, 0xe3, 0x93, 0xe8, 0x01, 0x46, - 0x2e, 0xd9, 0x7b, 0xe8, 0x01, 0x43, 0xf2, 0xf3, 0x28, 0xe8, 0x01, 0x45, - 0xa5, 0xe3, 0xa8, 0xe8, 0x01, 0x46, 0x7c, 0xd9, 0xb7, 0xe8, 0x41, 0x45, - 0x33, 0xe2, 0x72, 0xe8, 0x01, 0x44, 0x39, 0xed, 0x2a, 0xe8, 0x01, 0x45, - 0x8d, 0xe2, 0x9f, 0xe8, 0x01, 0x45, 0xc9, 0xe2, 0x5f, 0xe8, 0x01, 0x46, - 0x0a, 0xd9, 0xb8, 0xe8, 0x01, 0x44, 0x11, 0xee, 0x2b, 0xe8, 0x01, 0x45, - 0x5f, 0xe3, 0x33, 0xe8, 0x01, 0x44, 0x85, 0xee, 0x29, 0xe8, 0x01, 0x44, - 0xa5, 0xee, 0x21, 0xe8, 0x01, 0x45, 0xff, 0xe3, 0x13, 0xe8, 0x41, 0x46, - 0x98, 0xd8, 0x7d, 0xe8, 0x01, 0x44, 0x6f, 0xe2, 0x59, 0xe8, 0x01, 0x45, - 0xa1, 0xe2, 0x95, 0xe8, 0x01, 0x45, 0xd8, 0xe2, 0xae, 0xe8, 0x01, 0x45, - 0xfb, 0xe2, 0xa6, 0xe8, 0x01, 0x45, 0x41, 0xe3, 0xb0, 0xe8, 0x01, 0x45, - 0x69, 0xe3, 0x0b, 0xe8, 0x01, 0x47, 0x73, 0xce, 0x7f, 0xe8, 0x01, 0x46, - 0x5e, 0xd9, 0x70, 0xe8, 0x01, 0x45, 0xe1, 0xe3, 0xaf, 0xe8, 0x41, 0x49, - 0x58, 0xb5, 0x3d, 0xe8, 0x01, 0x44, 0x31, 0xed, 0x84, 0xe8, 0x01, 0x46, - 0xce, 0xd8, 0xa4, 0xe8, 0x01, 0x44, 0x99, 0xed, 0x4f, 0xe8, 0x01, 0x45, - 0x28, 0xe3, 0x0d, 0xe8, 0x01, 0x47, 0x65, 0xce, 0x7a, 0xe8, 0x01, 0x44, - 0x71, 0xee, 0x32, 0xe8, 0x01, 0x45, 0x8c, 0xe3, 0x66, 0xe8, 0x01, 0x44, - 0xcd, 0xee, 0x0c, 0xe8, 0x01, 0x45, 0xe6, 0xe3, 0xb2, 0xe8, 0x41, 0x43, - 0x95, 0xf3, 0x26, 0xe8, 0x01, 0x45, 0x56, 0xe2, 0x62, 0xe8, 0x01, 0x45, - 0xb0, 0xe2, 0x91, 0xe8, 0x01, 0x45, 0xc4, 0xe2, 0x20, 0xe8, 0x01, 0x45, - 0x1e, 0xe3, 0x49, 0xe8, 0x01, 0x4b, 0xb3, 0x98, 0x9d, 0xe8, 0x01, 0x4c, - 0xf8, 0x8b, 0x81, 0xe8, 0x01, 0x45, 0x78, 0xe3, 0xaa, 0xe8, 0x01, 0x45, - 0xaa, 0xe3, 0xa3, 0xe8, 0x01, 0x45, 0x04, 0xe4, 0x56, 0xe8, 0x41, 0x90, - 0xb5, 0x04, 0x91, 0xf6, 0x03, 0x92, 0xb7, 0x03, 0x93, 0xf8, 0x02, 0x94, - 0xb9, 0x02, 0x95, 0xfa, 0x01, 0x96, 0xbb, 0x01, 0x97, 0x7d, 0x98, 0x3f, - 0x99, 0x01, 0xff, 0x46, 0x92, 0xd8, 0x77, 0xe8, 0x01, 0x45, 0x60, 0xe2, - 0x47, 0xe8, 0x01, 0x45, 0x88, 0xe2, 0xa0, 0xe8, 0x01, 0x46, 0xda, 0xd8, - 0xa9, 0xe8, 0x01, 0x45, 0x14, 0xe3, 0x18, 0xe8, 0x01, 0x44, 0x37, 0xe3, - 0x04, 0xe8, 0x01, 0x44, 0x49, 0xee, 0x6c, 0xe8, 0x01, 0x44, 0x79, 0xee, - 0x1f, 0xe8, 0x01, 0x46, 0x70, 0xd9, 0xc3, 0xe8, 0x01, 0x44, 0xd5, 0xee, - 0x8d, 0xe8, 0x41, 0x44, 0x19, 0xed, 0x57, 0xe8, 0x01, 0x45, 0x5b, 0xe2, - 0x8f, 0xe8, 0x01, 0x46, 0xd4, 0xd8, 0x79, 0xe8, 0x01, 0x46, 0xe0, 0xd8, - 0x6f, 0xe8, 0x01, 0x45, 0x05, 0xe3, 0x39, 0xe8, 0x01, 0x44, 0x35, 0xee, - 0xbd, 0xe8, 0x01, 0x4b, 0xbe, 0x98, 0x80, 0xe8, 0x01, 0x45, 0x7d, 0xe3, - 0x73, 0xe8, 0x01, 0x44, 0xb1, 0xee, 0x60, 0xe8, 0x01, 0x45, 0xcd, 0xe3, - 0x41, 0xe8, 0x41, 0x45, 0x29, 0xe2, 0xac, 0xe8, 0x01, 0x46, 0xb0, 0xd8, - 0xab, 0xe8, 0x01, 0x45, 0x97, 0xe2, 0x98, 0xe8, 0x01, 0x44, 0xa9, 0xed, - 0x3a, 0xe8, 0x01, 0x45, 0x00, 0xe3, 0xa1, 0xe8, 0x01, 0x44, 0x09, 0xee, - 0x5e, 0xe8, 0x01, 0x45, 0x50, 0xe3, 0x05, 0xe8, 0x01, 0x44, 0x9d, 0xee, - 0xbf, 0xe8, 0x01, 0x45, 0xa0, 0xe3, 0x5d, 0xe8, 0x01, 0x44, 0xe5, 0xee, - 0x34, 0xe8, 0x41, 0x46, 0x9e, 0xd8, 0xc4, 0xe8, 0x01, 0x45, 0x6a, 0xe2, - 0x11, 0xe8, 0x01, 0x45, 0x92, 0xe2, 0x94, 0xe8, 0x01, 0x44, 0x9d, 0xed, - 0x51, 0xe8, 0x01, 0x45, 0x19, 0xe3, 0xb4, 0xe8, 0x01, 0x45, 0x37, 0xe3, - 0x03, 0xe8, 0x01, 0x44, 0x65, 0xee, 0x92, 0xe8, 0x01, 0x46, 0x52, 0xd9, - 0xb3, 0xe8, 0x01, 0x44, 0xc1, 0xee, 0x8c, 0xe8, 0x01, 0x44, 0xed, 0xee, - 0x4a, 0xe8, 0x41, 0x44, 0x09, 0xed, 0x8e, 0xe8, 0x01, 0x44, 0x5b, 0xe2, - 0x90, 0xe8, 0x01, 0x45, 0x7e, 0xe2, 0x74, 0xe8, 0x01, 0x45, 0xce, 0xe2, - 0x71, 0xe8, 0x01, 0x45, 0x0a, 0xe3, 0x3b, 0xe8, 0x01, 0x44, 0x29, 0xee, - 0x48, 0xe8, 0x01, 0x45, 0x4b, 0xe3, 0xa7, 0xe8, 0x01, 0x46, 0x58, 0xd9, - 0x8a, 0xe8, 0x01, 0x46, 0x6a, 0xd9, 0xc1, 0xe8, 0x01, 0x45, 0xd7, 0xe3, - 0x17, 0xe8, 0x41, 0x45, 0x38, 0xe2, 0x6b, 0xe8, 0x01, 0x44, 0x35, 0xed, - 0x69, 0xe8, 0x01, 0x45, 0x83, 0xe2, 0x6d, 0xe8, 0x01, 0x46, 0xe6, 0xd8, - 0x78, 0xe8, 0x01, 0x46, 0xf8, 0xd8, 0xa2, 0xe8, 0x01, 0x44, 0x1c, 0xd9, - 0x0e, 0xe8, 0x01, 0x46, 0x28, 0xd9, 0x76, 0xe8, 0x01, 0x46, 0x46, 0xd9, - 0x96, 0xe8, 0x01, 0x44, 0xbd, 0xee, 0x06, 0xe8, 0x01, 0x45, 0xfa, 0xe3, - 0x12, 0xe8, 0x41, 0x44, 0xfd, 0xec, 0x4d, 0xe8, 0x01, 0x44, 0x61, 0xed, - 0x53, 0xe8, 0x01, 0x44, 0x8d, 0xed, 0x54, 0xe8, 0x01, 0x44, 0xc5, 0xed, - 0x55, 0xe8, 0x01, 0x44, 0xcd, 0xed, 0x5a, 0xe8, 0x01, 0x44, 0x05, 0xee, - 0x5b, 0xe8, 0x01, 0x44, 0x45, 0xee, 0x5c, 0xe8, 0x01, 0x45, 0x91, 0xe3, - 0x63, 0xe8, 0x01, 0x45, 0xb9, 0xe3, 0x64, 0xe8, 0x01, 0x45, 0xf0, 0xe3, - 0x65, 0xe8, 0x41, 0x44, 0x11, 0xed, 0x2f, 0xe8, 0x01, 0x44, 0x59, 0xed, - 0x30, 0xe8, 0x01, 0x44, 0xc6, 0x42, 0x44, 0xe8, 0x01, 0x44, 0xc1, 0xed, - 0x45, 0xe8, 0x01, 0x44, 0xe1, 0xed, 0x46, 0xe8, 0x01, 0x44, 0x19, 0xee, - 0x36, 0xe8, 0x01, 0x44, 0x5d, 0xee, 0x37, 0xe8, 0x01, 0x44, 0x91, 0xee, - 0x38, 0xe8, 0x01, 0x44, 0xb9, 0xee, 0x4b, 0xe8, 0x01, 0x44, 0xd1, 0xee, - 0x4c, 0xe8, 0x41, 0x44, 0xf5, 0xec, 0x1b, 0xe8, 0x01, 0x44, 0x09, 0xc3, - 0x1c, 0xe8, 0x01, 0x44, 0x69, 0xed, 0x1d, 0xe8, 0x01, 0x43, 0xc8, 0xf3, - 0x22, 0xe8, 0x01, 0x43, 0xf6, 0xe2, 0x23, 0xe8, 0x01, 0x43, 0xda, 0xf3, - 0x24, 0xe8, 0x01, 0x44, 0x41, 0xee, 0x3e, 0xe8, 0x01, 0x44, 0x7d, 0xee, - 0x3f, 0xe8, 0x01, 0x44, 0xa9, 0xee, 0x40, 0xe8, 0x01, 0x44, 0xe1, 0xee, - 0x2e, 0xe8, 0x41, 0x44, 0x3d, 0xed, 0x00, 0xe8, 0x01, 0x44, 0x6d, 0xed, - 0x01, 0xe8, 0x01, 0x44, 0xa1, 0xed, 0x02, 0xe8, 0x01, 0x44, 0xe9, 0xed, - 0x08, 0xe8, 0x01, 0x44, 0x39, 0xee, 0x09, 0xe8, 0x01, 0x44, 0x75, 0xee, - 0x0a, 0xe8, 0x01, 0x45, 0x87, 0xe3, 0x14, 0xe8, 0x01, 0x45, 0xb4, 0xe3, - 0x15, 0xe8, 0x01, 0x45, 0xdc, 0xe3, 0x16, 0xe8, 0x41, 0x45, 0x12, 0x0b, - 0xce, 0xe8, 0x01, 0xa6, 0x29, 0x44, 0xea, 0x2a, 0xcf, 0xe8, 0x01, 0x43, - 0x0e, 0x0b, 0xc7, 0xe8, 0x01, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, - 0x01, 0xc9, 0xe8, 0x01, 0x42, 0x15, 0x02, 0xc8, 0xe8, 0x41, 0x44, 0xe5, - 0x1d, 0xcd, 0xe8, 0x01, 0x42, 0x1c, 0x26, 0xcc, 0xe8, 0x41, 0x43, 0xd2, - 0x05, 0xcb, 0xe8, 0x01, 0x43, 0xf6, 0x06, 0xca, 0xe8, 0x41, 0x07, 0x71, - 0x11, 0x24, 0x48, 0x10, 0x3c, 0xd6, 0xe8, 0x01, 0xb4, 0x01, 0xff, 0xa5, - 0x06, 0x48, 0x76, 0x52, 0xd3, 0xe8, 0x41, 0x43, 0xcb, 0x58, 0xd0, 0xe8, - 0x01, 0xae, 0x01, 0xff, 0x4a, 0x4e, 0xa6, 0xd4, 0xe8, 0x01, 0xf3, 0xd1, - 0xe8, 0x41, 0x4a, 0x4e, 0xa6, 0xd5, 0xe8, 0x01, 0xf3, 0xd2, 0xe8, 0x41, - 0x42, 0x10, 0x00, 0x48, 0xf3, 0x01, 0x46, 0x58, 0xdf, 0xcb, 0xce, 0x01, - 0x49, 0x48, 0x29, 0xe0, 0xfa, 0x41, 0xa1, 0xfd, 0x03, 0x06, 0x9c, 0xda, - 0xec, 0x03, 0x06, 0xef, 0x06, 0xa5, 0x03, 0xac, 0x6b, 0x58, 0x41, 0x2b, - 0xf3, 0xaa, 0x00, 0xb6, 0x06, 0x54, 0x0f, 0x47, 0xf4, 0xaa, 0x40, 0x45, - 0xe6, 0x23, 0xf6, 0xaa, 0x00, 0x0a, 0x56, 0x77, 0x01, 0xff, 0xa1, 0x3c, - 0x47, 0xfb, 0xcf, 0xe9, 0xab, 0x00, 0xa9, 0x2a, 0x44, 0xc9, 0xf1, 0xea, - 0xab, 0x00, 0x44, 0x5a, 0x86, 0xe3, 0xab, 0x00, 0x46, 0x12, 0xe0, 0xe7, - 0xab, 0x00, 0xb5, 0x0c, 0x47, 0xf1, 0x4b, 0xf5, 0xaa, 0x00, 0x45, 0xb0, - 0xec, 0xe6, 0xab, 0x40, 0x43, 0x5b, 0x86, 0xe8, 0xab, 0x00, 0xf5, 0xec, - 0xaa, 0x40, 0xe9, 0xeb, 0xaa, 0x00, 0x43, 0x5b, 0x86, 0xe4, 0xab, 0x40, - 0xa1, 0x0a, 0x43, 0x5b, 0x86, 0xe5, 0xab, 0x00, 0xf5, 0xee, 0xaa, 0x40, - 0xe9, 0xed, 0xaa, 0x00, 0xf5, 0xef, 0xaa, 0x40, 0x06, 0xed, 0x05, 0x06, - 0x47, 0xdf, 0xd6, 0xec, 0xab, 0x40, 0x45, 0xa4, 0xe4, 0xd1, 0xab, 0x00, - 0xa2, 0x9b, 0x02, 0x02, 0x6d, 0x14, 0x8c, 0x02, 0xa4, 0xf1, 0x01, 0xe5, - 0xe0, 0xaa, 0x00, 0xa7, 0xde, 0x01, 0x43, 0x89, 0xde, 0xcd, 0xab, 0x00, - 0xe9, 0xcf, 0xab, 0x80, 0xcc, 0x01, 0xaa, 0xbd, 0x01, 0xab, 0xa7, 0x01, - 0x43, 0x3f, 0x0e, 0xc2, 0xab, 0x80, 0x99, 0x01, 0x43, 0xcc, 0x2f, 0xc3, - 0xab, 0x80, 0x8b, 0x01, 0xae, 0x65, 0xef, 0xe1, 0xaa, 0x00, 0xb0, 0x4e, - 0x43, 0xd2, 0x07, 0xd4, 0xab, 0x00, 0xb3, 0x34, 0xb4, 0x12, 0x42, 0x42, - 0x0b, 0xce, 0xab, 0x00, 0x43, 0xd1, 0x10, 0xcb, 0xab, 0x00, 0x44, 0x13, - 0xbe, 0xcc, 0xab, 0x40, 0x43, 0x34, 0x1e, 0xca, 0xab, 0x00, 0x42, 0x62, - 0x01, 0xc7, 0xab, 0x80, 0x0d, 0xb4, 0x01, 0xff, 0xe1, 0xe4, 0xaa, 0x00, - 0x42, 0x22, 0x00, 0xe5, 0xaa, 0x40, 0x47, 0x5b, 0xcd, 0xe0, 0xab, 0x40, - 0x42, 0x57, 0x00, 0xc1, 0xab, 0x00, 0x42, 0x22, 0x00, 0xe9, 0xaa, 0x00, - 0x42, 0x40, 0x06, 0xea, 0xaa, 0x40, 0xe1, 0xc4, 0xab, 0x80, 0x06, 0x43, - 0x56, 0x00, 0xd0, 0xab, 0x40, 0x47, 0x5b, 0xcd, 0xde, 0xab, 0x40, 0xe1, - 0xc5, 0xab, 0x80, 0x19, 0x43, 0x26, 0xb3, 0xc9, 0xab, 0x80, 0x0c, 0x42, - 0x2a, 0x05, 0xe8, 0xaa, 0x00, 0x42, 0xbe, 0x22, 0xe3, 0xaa, 0x40, 0x47, - 0x5b, 0xcd, 0xe1, 0xab, 0x40, 0x47, 0x5b, 0xcd, 0xdf, 0xab, 0x40, 0x47, - 0x5b, 0xcd, 0xdd, 0xab, 0x40, 0x47, 0x5b, 0xcd, 0xdc, 0xab, 0x40, 0x43, - 0x34, 0x1e, 0xc8, 0xab, 0x00, 0x42, 0x55, 0x05, 0xc0, 0xab, 0xc0, 0x00, - 0x47, 0x5b, 0xcd, 0xdb, 0xab, 0x40, 0x43, 0x56, 0x00, 0xd3, 0xab, 0x00, - 0x42, 0x62, 0x01, 0xd6, 0xab, 0x40, 0x47, 0x5b, 0xcd, 0xe2, 0xab, 0x40, - 0x43, 0x34, 0x1e, 0xd8, 0xab, 0x00, 0x42, 0x55, 0x05, 0xd2, 0xab, 0x40, - 0xa4, 0x0c, 0x43, 0x34, 0x1e, 0xd9, 0xab, 0x00, 0x42, 0x62, 0x01, 0xd7, - 0xab, 0x40, 0xe1, 0xe6, 0xaa, 0x00, 0x42, 0x22, 0x00, 0xe7, 0xaa, 0x40, - 0xe1, 0xe2, 0xaa, 0x00, 0x42, 0x62, 0x01, 0xc6, 0xab, 0x40, 0xe1, 0xd5, - 0xab, 0x00, 0x43, 0x56, 0x00, 0xda, 0xab, 0x40, 0x45, 0x12, 0x0b, 0xf8, - 0xab, 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0xf9, 0xab, 0x00, 0x43, 0x0e, - 0x0b, 0xf1, 0xab, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xf0, - 0xab, 0x40, 0x44, 0x25, 0x01, 0xf3, 0xab, 0x00, 0x42, 0x15, 0x02, 0xf2, - 0xab, 0x40, 0x44, 0xe5, 0x1d, 0xf7, 0xab, 0x00, 0x42, 0x1c, 0x26, 0xf6, - 0xab, 0x40, 0x43, 0xd2, 0x05, 0xf5, 0xab, 0x00, 0x43, 0xf6, 0x06, 0xf4, - 0xab, 0x40, 0x42, 0x1a, 0x00, 0xf0, 0xaa, 0x00, 0x42, 0x12, 0x0b, 0xeb, - 0xab, 0x40, 0x4b, 0xd3, 0x9c, 0xf1, 0xaa, 0x00, 0x43, 0x6f, 0x87, 0xf2, - 0xaa, 0x00, 0x48, 0x21, 0xca, 0xed, 0xab, 0x40, 0x09, 0x4c, 0xb8, 0xf7, - 0x01, 0xa9, 0x01, 0xff, 0x05, 0x96, 0x46, 0xdd, 0x01, 0x03, 0x48, 0x04, - 0x01, 0xff, 0xa2, 0xc9, 0x01, 0x06, 0x31, 0x14, 0xb8, 0x01, 0xa6, 0x8e, - 0x01, 0x4b, 0x22, 0x61, 0xa3, 0xf7, 0x01, 0x04, 0xc3, 0x00, 0x70, 0x52, - 0xa8, 0x53, 0x5f, 0x20, 0x00, 0x05, 0xc8, 0x00, 0x52, 0xb3, 0x27, 0x0e, - 0x1e, 0x7d, 0x17, 0x4c, 0x32, 0x00, 0x59, 0x27, 0x00, 0x06, 0xad, 0x02, - 0x01, 0xff, 0x46, 0x12, 0x03, 0xaa, 0x26, 0x00, 0x46, 0xd6, 0x05, 0x8f, - 0xf7, 0x41, 0x4a, 0x0f, 0x2c, 0xc1, 0xf7, 0x01, 0x4d, 0x28, 0x13, 0xc3, - 0xf7, 0x41, 0x46, 0x2f, 0x19, 0xaa, 0xf7, 0x01, 0x44, 0x4c, 0x04, 0x92, - 0x25, 0x00, 0x03, 0x06, 0x53, 0x0d, 0x51, 0x01, 0x5c, 0xac, 0x26, 0xc0, - 0x00, 0x54, 0x07, 0x40, 0xf0, 0xce, 0x41, 0x52, 0x07, 0x2c, 0xcb, 0xf7, - 0x01, 0x4f, 0xf1, 0x1c, 0xb6, 0xf7, 0x41, 0x80, 0x06, 0x60, 0x34, 0x0f, - 0x6d, 0x27, 0x40, 0x56, 0x6e, 0x33, 0x75, 0x27, 0x00, 0x54, 0xda, 0x21, - 0x69, 0x27, 0x40, 0x80, 0x06, 0x60, 0x34, 0x0f, 0x6c, 0x27, 0x40, 0x56, - 0x6e, 0x33, 0x74, 0x27, 0x00, 0x54, 0xda, 0x21, 0x68, 0x27, 0x40, 0x53, - 0x60, 0x42, 0xb0, 0xf7, 0x01, 0x09, 0x4c, 0x3b, 0x11, 0x0c, 0x1c, 0x13, - 0x01, 0xff, 0x4a, 0x0f, 0x2c, 0xc5, 0xf7, 0x01, 0x4d, 0x28, 0x13, 0xc7, - 0xf7, 0x41, 0x59, 0x9a, 0x24, 0x6a, 0x27, 0x00, 0x5a, 0xd4, 0x21, 0x6b, - 0x27, 0x40, 0x52, 0x07, 0x2c, 0xce, 0xf7, 0x01, 0x4f, 0xf1, 0x1c, 0xbc, - 0xf7, 0x41, 0x4b, 0x0d, 0x03, 0xab, 0x26, 0x00, 0x50, 0x9d, 0x65, 0x85, - 0xf7, 0x41, 0x45, 0x13, 0x05, 0x4c, 0x2e, 0x00, 0x50, 0xad, 0x00, 0x53, - 0x2e, 0x00, 0x4d, 0xc1, 0x34, 0x54, 0x2e, 0x40, 0xa3, 0xd0, 0x02, 0x06, - 0xef, 0x06, 0xf4, 0x01, 0x4e, 0xb4, 0x77, 0x9a, 0x6e, 0x01, 0x49, 0x81, - 0x16, 0x98, 0x6e, 0x01, 0x07, 0x1a, 0x3a, 0x9e, 0x01, 0xb3, 0x01, 0xff, - 0x0c, 0x77, 0x08, 0x06, 0x4a, 0x0e, 0xb4, 0x99, 0x6e, 0x41, 0xe1, 0x6d, - 0x6e, 0x81, 0x81, 0x01, 0xe2, 0x70, 0x6e, 0x01, 0xe3, 0x71, 0x6e, 0x01, - 0xe4, 0x79, 0x6e, 0x01, 0xe5, 0x6f, 0x6e, 0x01, 0xe6, 0x6a, 0x6e, 0x01, - 0xe7, 0x69, 0x6e, 0x01, 0xe8, 0x76, 0x6e, 0x81, 0x60, 0xe9, 0x6b, 0x6e, - 0x01, 0xea, 0x6e, 0x6e, 0x01, 0xeb, 0x6c, 0x6e, 0x81, 0x4f, 0xec, 0x74, - 0x6e, 0x01, 0xed, 0x60, 0x6e, 0x01, 0xee, 0x7b, 0x6e, 0x81, 0x3a, 0xef, - 0x7d, 0x6e, 0x81, 0x31, 0xf0, 0x67, 0x6e, 0x01, 0xf1, 0x75, 0x6e, 0x01, - 0xf2, 0x7c, 0x6e, 0x01, 0xf3, 0x61, 0x6e, 0x01, 0xf4, 0x68, 0x6e, 0x01, - 0xf5, 0x72, 0x6e, 0x01, 0xf6, 0x62, 0x6e, 0x01, 0xf7, 0x63, 0x6e, 0x01, - 0xf8, 0x78, 0x6e, 0x01, 0xf9, 0x7f, 0x6e, 0x81, 0x04, 0xfa, 0x65, 0x6e, - 0x41, 0xf5, 0x73, 0x6e, 0x41, 0xe5, 0x7a, 0x6e, 0x41, 0xe7, 0x77, 0x6e, - 0x01, 0xf9, 0x77, 0x6e, 0x41, 0xf0, 0x66, 0x6e, 0x41, 0xf0, 0x76, 0x6e, - 0x41, 0xe9, 0x7e, 0x6e, 0x01, 0x43, 0x1d, 0x89, 0x64, 0x6e, 0x41, 0xa5, - 0x37, 0xa6, 0x29, 0x48, 0xcc, 0x53, 0x93, 0x6e, 0x01, 0xb3, 0x15, 0xb4, - 0x01, 0xff, 0x42, 0x92, 0x01, 0x8a, 0x6e, 0x01, 0x47, 0x9c, 0x5a, 0x8d, - 0x6e, 0x01, 0x45, 0x01, 0x2c, 0x8c, 0x6e, 0x41, 0x48, 0x8c, 0x51, 0x91, - 0x6e, 0x01, 0x46, 0x1c, 0x26, 0x90, 0x6e, 0x41, 0x46, 0x24, 0x18, 0x8f, - 0x6e, 0x01, 0x47, 0x11, 0x5d, 0x8e, 0x6e, 0x41, 0x47, 0x6d, 0x25, 0x92, - 0x6e, 0x01, 0x45, 0xbb, 0x6f, 0x8b, 0x6e, 0x41, 0x45, 0x12, 0x0b, 0x88, - 0x6e, 0x01, 0xa6, 0x43, 0x44, 0xea, 0x2a, 0x89, 0x6e, 0x01, 0x43, 0x0e, - 0x0b, 0x81, 0x6e, 0x81, 0x30, 0xb3, 0x22, 0xb4, 0x06, 0x44, 0x5f, 0x1e, - 0x80, 0x6e, 0x41, 0x44, 0x25, 0x01, 0x83, 0x6e, 0x81, 0x0d, 0x42, 0x15, - 0x02, 0x82, 0x6e, 0xc1, 0x00, 0x4f, 0x0d, 0x69, 0x95, 0x6e, 0x41, 0x4f, - 0x0d, 0x69, 0x96, 0x6e, 0x41, 0x44, 0xe5, 0x1d, 0x87, 0x6e, 0x01, 0x42, - 0x1c, 0x26, 0x86, 0x6e, 0x41, 0x4f, 0x0d, 0x69, 0x94, 0x6e, 0x41, 0x43, - 0xd2, 0x05, 0x85, 0x6e, 0x01, 0x43, 0xf6, 0x06, 0x84, 0x6e, 0x41, 0x0e, - 0xe5, 0x05, 0x06, 0x44, 0x14, 0x05, 0x97, 0x6e, 0x41, 0xe1, 0x4d, 0x6e, - 0x81, 0x81, 0x01, 0xe2, 0x50, 0x6e, 0x01, 0xe3, 0x51, 0x6e, 0x01, 0xe4, - 0x59, 0x6e, 0x01, 0xe5, 0x4f, 0x6e, 0x01, 0xe6, 0x4a, 0x6e, 0x01, 0xe7, - 0x49, 0x6e, 0x01, 0xe8, 0x56, 0x6e, 0x81, 0x60, 0xe9, 0x4b, 0x6e, 0x01, - 0xea, 0x4e, 0x6e, 0x01, 0xeb, 0x4c, 0x6e, 0x81, 0x4f, 0xec, 0x54, 0x6e, - 0x01, 0xed, 0x40, 0x6e, 0x01, 0xee, 0x5b, 0x6e, 0x81, 0x3a, 0xef, 0x5d, - 0x6e, 0x81, 0x31, 0xf0, 0x47, 0x6e, 0x01, 0xf1, 0x55, 0x6e, 0x01, 0xf2, - 0x5c, 0x6e, 0x01, 0xf3, 0x41, 0x6e, 0x01, 0xf4, 0x48, 0x6e, 0x01, 0xf5, - 0x52, 0x6e, 0x01, 0xf6, 0x42, 0x6e, 0x01, 0xf7, 0x43, 0x6e, 0x01, 0xf8, - 0x58, 0x6e, 0x01, 0xf9, 0x5f, 0x6e, 0x81, 0x04, 0xfa, 0x45, 0x6e, 0x41, - 0xf5, 0x53, 0x6e, 0x41, 0xe5, 0x5a, 0x6e, 0x41, 0xe7, 0x57, 0x6e, 0x01, - 0xf9, 0x57, 0x6e, 0x41, 0xf0, 0x46, 0x6e, 0x41, 0xf0, 0x56, 0x6e, 0x41, - 0xe9, 0x5e, 0x6e, 0x01, 0x43, 0x1d, 0x89, 0x44, 0x6e, 0x41, 0x43, 0xfe, - 0x05, 0xbe, 0xf9, 0x01, 0x43, 0xbd, 0x38, 0xbf, 0xf9, 0x41, 0x06, 0x5a, - 0xe0, 0x06, 0x49, 0xae, 0xbf, 0x56, 0xf3, 0x41, 0x45, 0x04, 0x02, 0x21, - 0x22, 0x80, 0x0c, 0x42, 0x08, 0x00, 0x5e, 0x22, 0x00, 0x54, 0x57, 0x45, - 0x9d, 0x29, 0x40, 0x80, 0x01, 0xff, 0x4c, 0x60, 0x93, 0x9b, 0x29, 0x00, - 0x27, 0xf4, 0x05, 0x01, 0xff, 0x09, 0x13, 0x49, 0x31, 0x09, 0x3f, 0x44, - 0x21, 0x0a, 0x09, 0x01, 0x11, 0x07, 0xba, 0x5e, 0x01, 0xff, 0x44, 0xc3, - 0x00, 0xa9, 0x29, 0x00, 0x45, 0xc8, 0x00, 0xa8, 0x29, 0x40, 0x44, 0xa5, - 0x01, 0xae, 0x29, 0x00, 0x42, 0x50, 0x02, 0xac, 0x29, 0x40, 0x44, 0xa5, - 0x01, 0xaf, 0x29, 0x00, 0x42, 0x50, 0x02, 0xad, 0x29, 0x40, 0x44, 0xc3, - 0x00, 0xab, 0x29, 0x00, 0x45, 0xc8, 0x00, 0xaa, 0x29, 0x40, 0x44, 0xb6, - 0x70, 0xaf, 0x00, 0x00, 0xa7, 0xf6, 0x42, 0xa8, 0x99, 0x3e, 0xab, 0xf7, - 0x3c, 0xac, 0xe2, 0x36, 0x45, 0xdc, 0xe8, 0xa3, 0xf9, 0x01, 0xee, 0x68, - 0xf4, 0x81, 0x81, 0x32, 0xb0, 0xf2, 0x31, 0xb2, 0xaf, 0x2e, 0xb3, 0xcd, - 0x2a, 0xb4, 0x95, 0x01, 0x46, 0x86, 0xe1, 0xd6, 0xf5, 0x01, 0x0c, 0x38, - 0x97, 0x01, 0xff, 0xa5, 0x75, 0xa6, 0x58, 0x44, 0xea, 0x2a, 0xe9, 0xd2, - 0x81, 0x4b, 0x43, 0x0e, 0x0b, 0xe1, 0xd2, 0x01, 0xb3, 0x29, 0xb4, 0x06, - 0x44, 0x5f, 0x1e, 0xe0, 0xd2, 0x41, 0x42, 0x92, 0x01, 0xea, 0xd2, 0x01, - 0xa8, 0x0d, 0xb7, 0x01, 0xff, 0x44, 0x02, 0x2c, 0xec, 0xd2, 0x01, 0xef, - 0xe2, 0xd2, 0x41, 0x46, 0x9d, 0x5a, 0xed, 0xd2, 0x01, 0x43, 0x26, 0x01, - 0xe3, 0xd2, 0x41, 0x44, 0xe5, 0x1d, 0xe7, 0xd2, 0x81, 0x0d, 0x42, 0x1c, - 0x26, 0xe6, 0xd2, 0xc1, 0x00, 0x44, 0x26, 0x18, 0xf0, 0xd2, 0x41, 0x44, - 0x26, 0x18, 0xf1, 0xd2, 0x41, 0x44, 0x26, 0x18, 0xf3, 0xd2, 0x41, 0xa9, - 0x0d, 0x43, 0xf6, 0x06, 0xe4, 0xd2, 0xc1, 0x00, 0x44, 0x26, 0x18, 0xee, - 0xd2, 0x41, 0x45, 0x25, 0x18, 0xef, 0xd2, 0x01, 0x42, 0x32, 0x00, 0xe5, - 0xd2, 0x41, 0x44, 0xc9, 0x00, 0xe8, 0xd2, 0x81, 0x06, 0x45, 0xbb, 0x6f, - 0xeb, 0xd2, 0x41, 0x43, 0xc4, 0x09, 0xf2, 0xd2, 0x41, 0x47, 0xa3, 0xd0, - 0xc9, 0xf9, 0x01, 0x0a, 0xab, 0x53, 0x01, 0xff, 0x05, 0x1d, 0x61, 0xb6, - 0x1b, 0x0e, 0x28, 0x77, 0xad, 0x19, 0xa6, 0xda, 0x17, 0x07, 0x2b, 0xd2, - 0xe0, 0x12, 0x05, 0xc3, 0x00, 0xb8, 0x12, 0x0a, 0x28, 0xae, 0x93, 0x10, - 0x02, 0x0d, 0x00, 0xe1, 0x0f, 0xb3, 0x01, 0xff, 0x0a, 0x09, 0x48, 0xb2, - 0x01, 0x06, 0x75, 0x06, 0x01, 0xff, 0x08, 0xe4, 0x05, 0x61, 0x06, 0x5d, - 0x07, 0x01, 0xff, 0xe1, 0xb6, 0xd4, 0x01, 0xe2, 0xb7, 0xd4, 0x01, 0xe3, - 0xb8, 0xd4, 0x01, 0xe4, 0xb9, 0xd4, 0x01, 0xe6, 0xbb, 0xd4, 0x01, 0xe8, - 0xbd, 0xd4, 0x01, 0xe9, 0xbe, 0xd4, 0x01, 0xea, 0xbf, 0xd4, 0x01, 0xeb, - 0xc0, 0xd4, 0x01, 0xec, 0xc1, 0xd4, 0x01, 0xed, 0xc2, 0xd4, 0x01, 0xee, - 0xc3, 0xd4, 0x01, 0xf0, 0xc5, 0xd4, 0x01, 0xf1, 0xc6, 0xd4, 0x01, 0xf2, - 0xc7, 0xd4, 0x01, 0xf3, 0xc8, 0xd4, 0x01, 0xf4, 0xc9, 0xd4, 0x01, 0xf5, - 0xca, 0xd4, 0x01, 0xf6, 0xcb, 0xd4, 0x01, 0xf7, 0xcc, 0xd4, 0x01, 0xf8, - 0xcd, 0xd4, 0x01, 0xf9, 0xce, 0xd4, 0x01, 0xfa, 0xcf, 0xd4, 0x41, 0xe1, - 0x9c, 0xd4, 0x01, 0xe3, 0x9e, 0xd4, 0x01, 0xe4, 0x9f, 0xd4, 0x01, 0xe7, - 0xa2, 0xd4, 0x01, 0xea, 0xa5, 0xd4, 0x01, 0xeb, 0xa6, 0xd4, 0x01, 0xee, - 0xa9, 0xd4, 0x01, 0xef, 0xaa, 0xd4, 0x01, 0xf0, 0xab, 0xd4, 0x01, 0xf1, - 0xac, 0xd4, 0x01, 0xf3, 0xae, 0xd4, 0x01, 0xf4, 0xaf, 0xd4, 0x01, 0xf5, - 0xb0, 0xd4, 0x01, 0xf6, 0xb1, 0xd4, 0x01, 0xf7, 0xb2, 0xd4, 0x01, 0xf8, - 0xb3, 0xd4, 0x01, 0xf9, 0xb4, 0xd4, 0x01, 0xfa, 0xb5, 0xd4, 0x41, 0x05, - 0x1d, 0x61, 0xfe, 0x03, 0x08, 0xe4, 0x05, 0x91, 0x03, 0x06, 0xef, 0x06, - 0xca, 0x02, 0x07, 0x2b, 0xd2, 0x6d, 0x06, 0x5d, 0x07, 0x01, 0xff, 0xe1, - 0xba, 0xd5, 0x01, 0xe2, 0xbb, 0xd5, 0x01, 0xe3, 0xbc, 0xd5, 0x01, 0xe4, - 0xbd, 0xd5, 0x01, 0xe5, 0xbe, 0xd5, 0x01, 0xe6, 0xbf, 0xd5, 0x01, 0xe7, - 0xc0, 0xd5, 0x01, 0xe8, 0xc1, 0xd5, 0x01, 0xe9, 0xc2, 0xd5, 0x01, 0xea, - 0xc3, 0xd5, 0x01, 0xeb, 0xc4, 0xd5, 0x01, 0xec, 0xc5, 0xd5, 0x01, 0xed, - 0xc6, 0xd5, 0x01, 0xee, 0xc7, 0xd5, 0x01, 0xef, 0xc8, 0xd5, 0x01, 0xf0, - 0xc9, 0xd5, 0x01, 0xf1, 0xca, 0xd5, 0x01, 0xf2, 0xcb, 0xd5, 0x01, 0xf3, - 0xcc, 0xd5, 0x01, 0xf4, 0xcd, 0xd5, 0x01, 0xf5, 0xce, 0xd5, 0x01, 0xf6, - 0xcf, 0xd5, 0x01, 0xf7, 0xd0, 0xd5, 0x01, 0xf8, 0xd1, 0xd5, 0x01, 0xf9, - 0xd2, 0xd5, 0x01, 0xfa, 0xd3, 0xd5, 0x41, 0x08, 0xe4, 0x05, 0x6d, 0x06, - 0x5d, 0x07, 0x01, 0xff, 0xe1, 0x22, 0xd6, 0x01, 0xe2, 0x23, 0xd6, 0x01, - 0xe3, 0x24, 0xd6, 0x01, 0xe4, 0x25, 0xd6, 0x01, 0xe5, 0x26, 0xd6, 0x01, - 0xe6, 0x27, 0xd6, 0x01, 0xe7, 0x28, 0xd6, 0x01, 0xe8, 0x29, 0xd6, 0x01, - 0xe9, 0x2a, 0xd6, 0x01, 0xea, 0x2b, 0xd6, 0x01, 0xeb, 0x2c, 0xd6, 0x01, - 0xec, 0x2d, 0xd6, 0x01, 0xed, 0x2e, 0xd6, 0x01, 0xee, 0x2f, 0xd6, 0x01, - 0xef, 0x30, 0xd6, 0x01, 0xf0, 0x31, 0xd6, 0x01, 0xf1, 0x32, 0xd6, 0x01, - 0xf2, 0x33, 0xd6, 0x01, 0xf3, 0x34, 0xd6, 0x01, 0xf4, 0x35, 0xd6, 0x01, - 0xf5, 0x36, 0xd6, 0x01, 0xf6, 0x37, 0xd6, 0x01, 0xf7, 0x38, 0xd6, 0x01, - 0xf8, 0x39, 0xd6, 0x01, 0xf9, 0x3a, 0xd6, 0x01, 0xfa, 0x3b, 0xd6, 0x41, - 0xe1, 0x08, 0xd6, 0x01, 0xe2, 0x09, 0xd6, 0x01, 0xe3, 0x0a, 0xd6, 0x01, - 0xe4, 0x0b, 0xd6, 0x01, 0xe5, 0x0c, 0xd6, 0x01, 0xe6, 0x0d, 0xd6, 0x01, - 0xe7, 0x0e, 0xd6, 0x01, 0xe8, 0x0f, 0xd6, 0x01, 0xe9, 0x10, 0xd6, 0x01, - 0xea, 0x11, 0xd6, 0x01, 0xeb, 0x12, 0xd6, 0x01, 0xec, 0x13, 0xd6, 0x01, - 0xed, 0x14, 0xd6, 0x01, 0xee, 0x15, 0xd6, 0x01, 0xef, 0x16, 0xd6, 0x01, - 0xf0, 0x17, 0xd6, 0x01, 0xf1, 0x18, 0xd6, 0x01, 0xf2, 0x19, 0xd6, 0x01, - 0xf3, 0x1a, 0xd6, 0x01, 0xf4, 0x1b, 0xd6, 0x01, 0xf5, 0x1c, 0xd6, 0x01, - 0xf6, 0x1d, 0xd6, 0x01, 0xf7, 0x1e, 0xd6, 0x01, 0xf8, 0x1f, 0xd6, 0x01, - 0xf9, 0x20, 0xd6, 0x01, 0xfa, 0x21, 0xd6, 0x41, 0x45, 0x12, 0x0b, 0xea, - 0xd7, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0xeb, 0xd7, 0x01, 0x43, 0x0e, - 0x0b, 0xe3, 0xd7, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xe2, - 0xd7, 0x41, 0x44, 0x25, 0x01, 0xe5, 0xd7, 0x01, 0x42, 0x15, 0x02, 0xe4, - 0xd7, 0x41, 0x44, 0xe5, 0x1d, 0xe9, 0xd7, 0x01, 0x42, 0x1c, 0x26, 0xe8, - 0xd7, 0x41, 0x43, 0xd2, 0x05, 0xe7, 0xd7, 0x01, 0x43, 0xf6, 0x06, 0xe6, - 0xd7, 0x41, 0xe1, 0xa0, 0xd5, 0x01, 0xe2, 0xa1, 0xd5, 0x01, 0xe3, 0xa2, - 0xd5, 0x01, 0xe4, 0xa3, 0xd5, 0x01, 0xe5, 0xa4, 0xd5, 0x01, 0xe6, 0xa5, - 0xd5, 0x01, 0xe7, 0xa6, 0xd5, 0x01, 0xe8, 0xa7, 0xd5, 0x01, 0xe9, 0xa8, - 0xd5, 0x01, 0xea, 0xa9, 0xd5, 0x01, 0xeb, 0xaa, 0xd5, 0x01, 0xec, 0xab, - 0xd5, 0x01, 0xed, 0xac, 0xd5, 0x01, 0xee, 0xad, 0xd5, 0x01, 0xef, 0xae, - 0xd5, 0x01, 0xf0, 0xaf, 0xd5, 0x01, 0xf1, 0xb0, 0xd5, 0x01, 0xf2, 0xb1, - 0xd5, 0x01, 0xf3, 0xb2, 0xd5, 0x01, 0xf4, 0xb3, 0xd5, 0x01, 0xf5, 0xb4, - 0xd5, 0x01, 0xf6, 0xb5, 0xd5, 0x01, 0xf7, 0xb6, 0xd5, 0x01, 0xf8, 0xb7, - 0xd5, 0x01, 0xf9, 0xb8, 0xd5, 0x01, 0xfa, 0xb9, 0xd5, 0x41, 0x08, 0xe4, - 0x05, 0x87, 0x08, 0x06, 0xef, 0x06, 0xc0, 0x07, 0x4e, 0xce, 0x15, 0x8a, - 0xd7, 0x01, 0x07, 0x2b, 0xd2, 0xc9, 0x02, 0x4c, 0xa8, 0x90, 0x8c, 0xd7, - 0x01, 0x45, 0x09, 0xe9, 0x6f, 0xd7, 0x01, 0xb0, 0xa8, 0x02, 0x4a, 0x62, - 0xb0, 0x8e, 0xd7, 0x01, 0x06, 0x5d, 0x07, 0x06, 0x4c, 0xe8, 0x95, 0x8b, - 0xd7, 0x41, 0xe1, 0xee, 0xd5, 0x81, 0x8c, 0x02, 0xe2, 0xef, 0xd5, 0x81, - 0x80, 0x02, 0xe3, 0xf0, 0xd5, 0x81, 0xf4, 0x01, 0xe4, 0xf1, 0xd5, 0x81, - 0xe8, 0x01, 0xe5, 0xf2, 0xd5, 0x81, 0xd6, 0x01, 0xe6, 0xf3, 0xd5, 0x81, - 0xca, 0x01, 0xe7, 0xf4, 0xd5, 0x81, 0xbe, 0x01, 0xe8, 0xf5, 0xd5, 0x01, - 0xe9, 0xf6, 0xd5, 0x81, 0xae, 0x01, 0xea, 0xf7, 0xd5, 0x01, 0xeb, 0xf8, - 0xd5, 0x81, 0x9e, 0x01, 0xec, 0xf9, 0xd5, 0x81, 0x92, 0x01, 0xed, 0xfa, - 0xd5, 0x81, 0x88, 0x01, 0xee, 0xfb, 0xd5, 0x81, 0x7f, 0xef, 0xfc, 0xd5, - 0x81, 0x6b, 0xf0, 0xfd, 0xd5, 0x81, 0x56, 0xf1, 0xfe, 0xd5, 0x01, 0xf2, - 0xff, 0xd5, 0x81, 0x47, 0xf3, 0x00, 0xd6, 0x81, 0x3c, 0xf4, 0x01, 0xd6, - 0x81, 0x2b, 0xf5, 0x02, 0xd6, 0x81, 0x20, 0xf6, 0x03, 0xd6, 0x01, 0xf7, - 0x04, 0xd6, 0x01, 0xf8, 0x05, 0xd6, 0x81, 0x0f, 0xf9, 0x06, 0xd6, 0x01, - 0xfa, 0x07, 0xd6, 0xc1, 0x00, 0x43, 0x94, 0x0f, 0x75, 0xd7, 0x41, 0xe9, - 0x7d, 0xd7, 0x41, 0x46, 0xcf, 0x15, 0x84, 0xd7, 0x41, 0x42, 0x61, 0x24, - 0x83, 0xd7, 0x01, 0x44, 0xe9, 0x95, 0x77, 0xd7, 0x41, 0x44, 0xc1, 0x1f, - 0x82, 0xd7, 0x41, 0x42, 0x0b, 0x00, 0x80, 0xd7, 0x41, 0x42, 0x49, 0x00, - 0x85, 0xd7, 0x01, 0xe9, 0x7f, 0xd7, 0x01, 0x42, 0x5a, 0x03, 0x87, 0xd7, - 0x41, 0xad, 0x01, 0xff, 0x43, 0xce, 0x05, 0x88, 0xd7, 0x01, 0x45, 0x6a, - 0xe7, 0x7e, 0xd7, 0x41, 0xf5, 0x7c, 0xd7, 0x41, 0xf5, 0x7b, 0xd7, 0x41, - 0x44, 0x38, 0xe8, 0x7a, 0xd7, 0x41, 0x44, 0xa9, 0x90, 0x79, 0xd7, 0x41, - 0x43, 0x1b, 0x05, 0x78, 0xd7, 0x41, 0x44, 0x02, 0x21, 0x72, 0xd7, 0x41, - 0x4a, 0x3a, 0x9c, 0x81, 0xd7, 0x41, 0x46, 0xcf, 0x15, 0x74, 0xd7, 0x01, - 0x42, 0x12, 0x00, 0x76, 0xd7, 0x41, 0x44, 0x58, 0xd6, 0x73, 0xd7, 0x41, - 0x42, 0x49, 0x00, 0x86, 0xd7, 0x41, 0x43, 0x94, 0x0f, 0x71, 0xd7, 0x41, - 0x44, 0x5f, 0xe4, 0x70, 0xd7, 0x41, 0x53, 0x55, 0x48, 0x89, 0xd7, 0x01, - 0x49, 0xb4, 0xb9, 0x8d, 0xd7, 0x01, 0x48, 0x7c, 0xac, 0x8f, 0xd7, 0x41, - 0x08, 0xe4, 0x05, 0xcf, 0x02, 0x4e, 0xce, 0x15, 0xc4, 0xd7, 0x01, 0x4c, - 0xa8, 0x90, 0xc6, 0xd7, 0x01, 0x45, 0x09, 0xe9, 0xa9, 0xd7, 0x01, 0xb0, - 0xa8, 0x02, 0x4a, 0x62, 0xb0, 0xc8, 0xd7, 0x01, 0x06, 0x5d, 0x07, 0x06, - 0x4c, 0xe8, 0x95, 0xc5, 0xd7, 0x41, 0xe1, 0x56, 0xd6, 0x81, 0x8c, 0x02, - 0xe2, 0x57, 0xd6, 0x81, 0x80, 0x02, 0xe3, 0x58, 0xd6, 0x81, 0xf4, 0x01, - 0xe4, 0x59, 0xd6, 0x81, 0xe8, 0x01, 0xe5, 0x5a, 0xd6, 0x81, 0xd6, 0x01, - 0xe6, 0x5b, 0xd6, 0x81, 0xca, 0x01, 0xe7, 0x5c, 0xd6, 0x81, 0xbe, 0x01, - 0xe8, 0x5d, 0xd6, 0x01, 0xe9, 0x5e, 0xd6, 0x81, 0xae, 0x01, 0xea, 0x5f, - 0xd6, 0x01, 0xeb, 0x60, 0xd6, 0x81, 0x9e, 0x01, 0xec, 0x61, 0xd6, 0x81, - 0x92, 0x01, 0xed, 0x62, 0xd6, 0x81, 0x88, 0x01, 0xee, 0x63, 0xd6, 0x81, - 0x7f, 0xef, 0x64, 0xd6, 0x81, 0x6b, 0xf0, 0x65, 0xd6, 0x81, 0x56, 0xf1, - 0x66, 0xd6, 0x01, 0xf2, 0x67, 0xd6, 0x81, 0x47, 0xf3, 0x68, 0xd6, 0x81, - 0x3c, 0xf4, 0x69, 0xd6, 0x81, 0x2b, 0xf5, 0x6a, 0xd6, 0x81, 0x20, 0xf6, - 0x6b, 0xd6, 0x01, 0xf7, 0x6c, 0xd6, 0x01, 0xf8, 0x6d, 0xd6, 0x81, 0x0f, - 0xf9, 0x6e, 0xd6, 0x01, 0xfa, 0x6f, 0xd6, 0xc1, 0x00, 0x43, 0x94, 0x0f, - 0xaf, 0xd7, 0x41, 0xe9, 0xb7, 0xd7, 0x41, 0x46, 0xcf, 0x15, 0xbe, 0xd7, - 0x41, 0x42, 0x61, 0x24, 0xbd, 0xd7, 0x01, 0x44, 0xe9, 0x95, 0xb1, 0xd7, - 0x41, 0x44, 0xc1, 0x1f, 0xbc, 0xd7, 0x41, 0x42, 0x0b, 0x00, 0xba, 0xd7, - 0x41, 0x42, 0x49, 0x00, 0xbf, 0xd7, 0x01, 0xe9, 0xb9, 0xd7, 0x01, 0x42, - 0x5a, 0x03, 0xc1, 0xd7, 0x41, 0xad, 0x01, 0xff, 0x43, 0xce, 0x05, 0xc2, - 0xd7, 0x01, 0x45, 0x6a, 0xe7, 0xb8, 0xd7, 0x41, 0xf5, 0xb6, 0xd7, 0x41, - 0xf5, 0xb5, 0xd7, 0x41, 0x44, 0x38, 0xe8, 0xb4, 0xd7, 0x41, 0x44, 0xa9, - 0x90, 0xb3, 0xd7, 0x41, 0x43, 0x1b, 0x05, 0xb2, 0xd7, 0x41, 0x44, 0x02, - 0x21, 0xac, 0xd7, 0x41, 0x4a, 0x3a, 0x9c, 0xbb, 0xd7, 0x41, 0x46, 0xcf, - 0x15, 0xae, 0xd7, 0x01, 0x42, 0x12, 0x00, 0xb0, 0xd7, 0x41, 0x44, 0x58, - 0xd6, 0xad, 0xd7, 0x41, 0x42, 0x49, 0x00, 0xc0, 0xd7, 0x41, 0x43, 0x94, - 0x0f, 0xab, 0xd7, 0x41, 0x44, 0x5f, 0xe4, 0xaa, 0xd7, 0x41, 0x53, 0x55, - 0x48, 0xc3, 0xd7, 0x01, 0x49, 0xb4, 0xb9, 0xc7, 0xd7, 0x01, 0x48, 0x7c, - 0xac, 0xc9, 0xd7, 0x41, 0xe1, 0x3c, 0xd6, 0x81, 0x8c, 0x02, 0xe2, 0x3d, - 0xd6, 0x81, 0x80, 0x02, 0xe3, 0x3e, 0xd6, 0x81, 0xf4, 0x01, 0xe4, 0x3f, - 0xd6, 0x81, 0xe8, 0x01, 0xe5, 0x40, 0xd6, 0x81, 0xd6, 0x01, 0xe6, 0x41, - 0xd6, 0x01, 0xe7, 0x42, 0xd6, 0x81, 0xc6, 0x01, 0xe8, 0x43, 0xd6, 0x01, - 0xe9, 0x44, 0xd6, 0x81, 0xb6, 0x01, 0xea, 0x45, 0xd6, 0x01, 0xeb, 0x46, - 0xd6, 0x81, 0xa6, 0x01, 0xec, 0x47, 0xd6, 0x81, 0x9a, 0x01, 0xed, 0x48, - 0xd6, 0x81, 0x90, 0x01, 0xee, 0x49, 0xd6, 0x81, 0x86, 0x01, 0xef, 0x4a, - 0xd6, 0x81, 0x72, 0xf0, 0x4b, 0xd6, 0x81, 0x5d, 0xf1, 0x4c, 0xd6, 0x01, - 0xf2, 0x4d, 0xd6, 0x81, 0x4e, 0xf3, 0x4e, 0xd6, 0x81, 0x43, 0xf4, 0x4f, - 0xd6, 0x81, 0x2b, 0xf5, 0x50, 0xd6, 0x81, 0x20, 0xf6, 0x51, 0xd6, 0x01, - 0xf7, 0x52, 0xd6, 0x01, 0xf8, 0x53, 0xd6, 0x81, 0x0f, 0xf9, 0x54, 0xd6, - 0x01, 0xfa, 0x55, 0xd6, 0xc1, 0x00, 0x43, 0x94, 0x0f, 0x95, 0xd7, 0x41, - 0xe9, 0x9d, 0xd7, 0x41, 0x46, 0xcf, 0x15, 0xa4, 0xd7, 0x41, 0x42, 0x61, - 0x24, 0xa3, 0xd7, 0x01, 0x44, 0xe9, 0x95, 0x97, 0xd7, 0xc1, 0x00, 0x47, - 0x15, 0x08, 0xa1, 0xd7, 0x41, 0x44, 0xc1, 0x1f, 0xa2, 0xd7, 0x41, 0x42, - 0x0b, 0x00, 0xa0, 0xd7, 0x41, 0x42, 0x49, 0x00, 0xa5, 0xd7, 0x01, 0xe9, - 0x9f, 0xd7, 0x01, 0x42, 0x5a, 0x03, 0xa7, 0xd7, 0x41, 0xad, 0x01, 0xff, - 0x43, 0xce, 0x05, 0xa8, 0xd7, 0x01, 0x45, 0x6a, 0xe7, 0x9e, 0xd7, 0x41, - 0xf5, 0x9c, 0xd7, 0x41, 0xf5, 0x9b, 0xd7, 0x41, 0x44, 0x38, 0xe8, 0x9a, - 0xd7, 0x41, 0x44, 0xa9, 0x90, 0x99, 0xd7, 0x41, 0x43, 0x1b, 0x05, 0x98, - 0xd7, 0x41, 0x44, 0x02, 0x21, 0x92, 0xd7, 0x41, 0x46, 0xcf, 0x15, 0x94, - 0xd7, 0x01, 0x42, 0x12, 0x00, 0x96, 0xd7, 0x41, 0x44, 0x58, 0xd6, 0x93, - 0xd7, 0x41, 0x42, 0x49, 0x00, 0xa6, 0xd7, 0x41, 0x43, 0x94, 0x0f, 0x91, - 0xd7, 0x41, 0x44, 0x5f, 0xe4, 0x90, 0xd7, 0x41, 0x45, 0x12, 0x0b, 0xf4, - 0xd7, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0xf5, 0xd7, 0x01, 0x43, 0x0e, - 0x0b, 0xed, 0xd7, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xec, - 0xd7, 0x41, 0x44, 0x25, 0x01, 0xef, 0xd7, 0x01, 0x42, 0x15, 0x02, 0xee, - 0xd7, 0x41, 0x44, 0xe5, 0x1d, 0xf3, 0xd7, 0x01, 0x42, 0x1c, 0x26, 0xf2, - 0xd7, 0x41, 0x43, 0xd2, 0x05, 0xf1, 0xd7, 0x01, 0x43, 0xf6, 0x06, 0xf0, - 0xd7, 0x41, 0xe1, 0xd4, 0xd5, 0x81, 0x8c, 0x02, 0xe2, 0xd5, 0xd5, 0x81, - 0x80, 0x02, 0xe3, 0xd6, 0xd5, 0x81, 0xf4, 0x01, 0xe4, 0xd7, 0xd5, 0x81, - 0xe8, 0x01, 0xe5, 0xd8, 0xd5, 0x81, 0xd6, 0x01, 0xe6, 0xd9, 0xd5, 0x01, - 0xe7, 0xda, 0xd5, 0x81, 0xc6, 0x01, 0xe8, 0xdb, 0xd5, 0x01, 0xe9, 0xdc, - 0xd5, 0x81, 0xb6, 0x01, 0xea, 0xdd, 0xd5, 0x01, 0xeb, 0xde, 0xd5, 0x81, - 0xa6, 0x01, 0xec, 0xdf, 0xd5, 0x81, 0x9a, 0x01, 0xed, 0xe0, 0xd5, 0x81, - 0x90, 0x01, 0xee, 0xe1, 0xd5, 0x81, 0x86, 0x01, 0xef, 0xe2, 0xd5, 0x81, - 0x72, 0xf0, 0xe3, 0xd5, 0x81, 0x5d, 0xf1, 0xe4, 0xd5, 0x01, 0xf2, 0xe5, - 0xd5, 0x81, 0x4e, 0xf3, 0xe6, 0xd5, 0x81, 0x43, 0xf4, 0xe7, 0xd5, 0x81, - 0x2b, 0xf5, 0xe8, 0xd5, 0x81, 0x20, 0xf6, 0xe9, 0xd5, 0x01, 0xf7, 0xea, - 0xd5, 0x01, 0xf8, 0xeb, 0xd5, 0x81, 0x0f, 0xf9, 0xec, 0xd5, 0x01, 0xfa, - 0xed, 0xd5, 0xc1, 0x00, 0x43, 0x94, 0x0f, 0x5b, 0xd7, 0x41, 0xe9, 0x63, - 0xd7, 0x41, 0x46, 0xcf, 0x15, 0x6a, 0xd7, 0x41, 0x42, 0x61, 0x24, 0x69, - 0xd7, 0x01, 0x44, 0xe9, 0x95, 0x5d, 0xd7, 0xc1, 0x00, 0x47, 0x15, 0x08, - 0x67, 0xd7, 0x41, 0x44, 0xc1, 0x1f, 0x68, 0xd7, 0x41, 0x42, 0x0b, 0x00, - 0x66, 0xd7, 0x41, 0x42, 0x49, 0x00, 0x6b, 0xd7, 0x01, 0xe9, 0x65, 0xd7, - 0x01, 0x42, 0x5a, 0x03, 0x6d, 0xd7, 0x41, 0xad, 0x01, 0xff, 0x43, 0xce, - 0x05, 0x6e, 0xd7, 0x01, 0x45, 0x6a, 0xe7, 0x64, 0xd7, 0x41, 0xf5, 0x62, - 0xd7, 0x41, 0xf5, 0x61, 0xd7, 0x41, 0x44, 0x38, 0xe8, 0x60, 0xd7, 0x41, - 0x44, 0xa9, 0x90, 0x5f, 0xd7, 0x41, 0x43, 0x1b, 0x05, 0x5e, 0xd7, 0x41, - 0x44, 0x02, 0x21, 0x58, 0xd7, 0x41, 0x46, 0xcf, 0x15, 0x5a, 0xd7, 0x01, - 0x42, 0x12, 0x00, 0x5c, 0xd7, 0x41, 0x44, 0x58, 0xd6, 0x59, 0xd7, 0x41, - 0x42, 0x49, 0x00, 0x6c, 0xd7, 0x41, 0x43, 0x94, 0x0f, 0x57, 0xd7, 0x41, - 0x44, 0x5f, 0xe4, 0x56, 0xd7, 0x41, 0x04, 0xca, 0x00, 0x06, 0x4d, 0x53, - 0x31, 0xcb, 0x27, 0x40, 0x4d, 0x3e, 0x0f, 0xe9, 0x27, 0x00, 0x54, 0xab, - 0x41, 0xeb, 0x27, 0x00, 0x55, 0x4b, 0x3b, 0xef, 0x27, 0x00, 0x06, 0xad, - 0x02, 0x01, 0xff, 0x4e, 0xe3, 0x26, 0xe7, 0x27, 0x00, 0x56, 0x54, 0x09, - 0xed, 0x27, 0x40, 0x08, 0xe4, 0x05, 0xb3, 0x01, 0x06, 0xef, 0x06, 0x6d, - 0x06, 0x5d, 0x07, 0x01, 0xff, 0xe1, 0x8a, 0xd6, 0x01, 0xe2, 0x8b, 0xd6, - 0x01, 0xe3, 0x8c, 0xd6, 0x01, 0xe4, 0x8d, 0xd6, 0x01, 0xe5, 0x8e, 0xd6, - 0x01, 0xe6, 0x8f, 0xd6, 0x01, 0xe7, 0x90, 0xd6, 0x01, 0xe8, 0x91, 0xd6, - 0x01, 0xe9, 0x92, 0xd6, 0x01, 0xea, 0x93, 0xd6, 0x01, 0xeb, 0x94, 0xd6, - 0x01, 0xec, 0x95, 0xd6, 0x01, 0xed, 0x96, 0xd6, 0x01, 0xee, 0x97, 0xd6, - 0x01, 0xef, 0x98, 0xd6, 0x01, 0xf0, 0x99, 0xd6, 0x01, 0xf1, 0x9a, 0xd6, - 0x01, 0xf2, 0x9b, 0xd6, 0x01, 0xf3, 0x9c, 0xd6, 0x01, 0xf4, 0x9d, 0xd6, - 0x01, 0xf5, 0x9e, 0xd6, 0x01, 0xf6, 0x9f, 0xd6, 0x01, 0xf7, 0xa0, 0xd6, - 0x01, 0xf8, 0xa1, 0xd6, 0x01, 0xf9, 0xa2, 0xd6, 0x01, 0xfa, 0xa3, 0xd6, - 0x41, 0x45, 0x12, 0x0b, 0xfe, 0xd7, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, - 0xff, 0xd7, 0x01, 0x43, 0x0e, 0x0b, 0xf7, 0xd7, 0x01, 0xb3, 0x14, 0xb4, - 0x06, 0x44, 0x5f, 0x1e, 0xf6, 0xd7, 0x41, 0x44, 0x25, 0x01, 0xf9, 0xd7, - 0x01, 0x42, 0x15, 0x02, 0xf8, 0xd7, 0x41, 0x44, 0xe5, 0x1d, 0xfd, 0xd7, - 0x01, 0x42, 0x1c, 0x26, 0xfc, 0xd7, 0x41, 0x43, 0xd2, 0x05, 0xfb, 0xd7, - 0x01, 0x43, 0xf6, 0x06, 0xfa, 0xd7, 0x41, 0xe1, 0x70, 0xd6, 0x01, 0xe2, - 0x71, 0xd6, 0x01, 0xe3, 0x72, 0xd6, 0x01, 0xe4, 0x73, 0xd6, 0x01, 0xe5, - 0x74, 0xd6, 0x01, 0xe6, 0x75, 0xd6, 0x01, 0xe7, 0x76, 0xd6, 0x01, 0xe8, - 0x77, 0xd6, 0x01, 0xe9, 0x78, 0xd6, 0x01, 0xea, 0x79, 0xd6, 0x01, 0xeb, - 0x7a, 0xd6, 0x01, 0xec, 0x7b, 0xd6, 0x01, 0xed, 0x7c, 0xd6, 0x01, 0xee, - 0x7d, 0xd6, 0x01, 0xef, 0x7e, 0xd6, 0x01, 0xf0, 0x7f, 0xd6, 0x01, 0xf1, - 0x80, 0xd6, 0x01, 0xf2, 0x81, 0xd6, 0x01, 0xf3, 0x82, 0xd6, 0x01, 0xf4, - 0x83, 0xd6, 0x01, 0xf5, 0x84, 0xd6, 0x01, 0xf6, 0x85, 0xd6, 0x01, 0xf7, - 0x86, 0xd6, 0x01, 0xf8, 0x87, 0xd6, 0x01, 0xf9, 0x88, 0xd6, 0x01, 0xfa, - 0x89, 0xd6, 0x41, 0x4d, 0x3e, 0x0f, 0xe8, 0x27, 0x00, 0x54, 0xab, 0x41, - 0xea, 0x27, 0x00, 0x55, 0x4b, 0x3b, 0xee, 0x27, 0x00, 0x06, 0xad, 0x02, - 0x01, 0xff, 0x4e, 0xe3, 0x26, 0xe6, 0x27, 0x00, 0x56, 0x54, 0x09, 0xec, - 0x27, 0x40, 0x08, 0xe4, 0x05, 0xd8, 0x02, 0x4e, 0xce, 0x15, 0x16, 0xd7, - 0x01, 0x4c, 0xa8, 0x90, 0x18, 0xd7, 0x01, 0x45, 0x09, 0xe9, 0xfb, 0xd6, - 0x01, 0xb0, 0xb1, 0x02, 0x4a, 0x62, 0xb0, 0x1a, 0xd7, 0x01, 0x06, 0x5d, - 0x07, 0x06, 0x4c, 0xe8, 0x95, 0x17, 0xd7, 0x41, 0xe1, 0x4e, 0xd4, 0x81, - 0x95, 0x02, 0xe2, 0x4f, 0xd4, 0x81, 0x89, 0x02, 0xe3, 0x50, 0xd4, 0x81, - 0xfd, 0x01, 0xe4, 0x51, 0xd4, 0x81, 0xe4, 0x01, 0xe5, 0x52, 0xd4, 0x81, - 0xd2, 0x01, 0xe6, 0x53, 0xd4, 0x81, 0xc6, 0x01, 0xe7, 0x54, 0xd4, 0x81, - 0xba, 0x01, 0xe9, 0x56, 0xd4, 0x81, 0xae, 0x01, 0xea, 0x57, 0xd4, 0x01, - 0xeb, 0x58, 0xd4, 0x81, 0x9e, 0x01, 0xec, 0x59, 0xd4, 0x81, 0x92, 0x01, - 0xed, 0x5a, 0xd4, 0x81, 0x88, 0x01, 0xee, 0x5b, 0xd4, 0x81, 0x7f, 0xef, - 0x5c, 0xd4, 0x81, 0x6b, 0xf0, 0x5d, 0xd4, 0x81, 0x56, 0xf1, 0x5e, 0xd4, - 0x01, 0xf2, 0x5f, 0xd4, 0x81, 0x47, 0xf3, 0x60, 0xd4, 0x81, 0x3c, 0xf4, - 0x61, 0xd4, 0x81, 0x2b, 0xf5, 0x62, 0xd4, 0x81, 0x20, 0xf6, 0x63, 0xd4, - 0x01, 0xf7, 0x64, 0xd4, 0x01, 0xf8, 0x65, 0xd4, 0x81, 0x0f, 0xf9, 0x66, - 0xd4, 0x01, 0xfa, 0x67, 0xd4, 0xc1, 0x00, 0x43, 0x94, 0x0f, 0x01, 0xd7, - 0x41, 0xe9, 0x09, 0xd7, 0x41, 0x46, 0xcf, 0x15, 0x10, 0xd7, 0x41, 0x42, - 0x61, 0x24, 0x0f, 0xd7, 0x01, 0x44, 0xe9, 0x95, 0x03, 0xd7, 0x41, 0x44, - 0xc1, 0x1f, 0x0e, 0xd7, 0x41, 0x42, 0x0b, 0x00, 0x0c, 0xd7, 0x41, 0x42, - 0x49, 0x00, 0x11, 0xd7, 0x01, 0xe9, 0x0b, 0xd7, 0x01, 0x42, 0x5a, 0x03, - 0x13, 0xd7, 0x41, 0xad, 0x01, 0xff, 0x43, 0xce, 0x05, 0x14, 0xd7, 0x01, - 0x45, 0x6a, 0xe7, 0x0a, 0xd7, 0x41, 0xf5, 0x08, 0xd7, 0x41, 0xf5, 0x07, - 0xd7, 0x41, 0x44, 0x38, 0xe8, 0x06, 0xd7, 0x41, 0x44, 0xa9, 0x90, 0x05, - 0xd7, 0x41, 0x43, 0x1b, 0x05, 0x04, 0xd7, 0x41, 0x44, 0x02, 0x21, 0xfe, - 0xd6, 0x41, 0x4a, 0x3a, 0x9c, 0x0d, 0xd7, 0x41, 0x46, 0xcf, 0x15, 0x00, - 0xd7, 0x01, 0x42, 0x12, 0x00, 0x02, 0xd7, 0x41, 0x44, 0x58, 0xd6, 0xff, - 0xd6, 0x01, 0x07, 0x98, 0x41, 0x01, 0xff, 0xe9, 0xa4, 0xd6, 0x01, 0xea, - 0xa5, 0xd6, 0x41, 0x42, 0x49, 0x00, 0x12, 0xd7, 0x41, 0x43, 0x94, 0x0f, - 0xfd, 0xd6, 0x41, 0x44, 0x5f, 0xe4, 0xfc, 0xd6, 0x41, 0x53, 0x55, 0x48, - 0x15, 0xd7, 0x01, 0x49, 0xb4, 0xb9, 0x19, 0xd7, 0x01, 0x48, 0x7c, 0xac, - 0x1b, 0xd7, 0x41, 0xe1, 0x34, 0xd4, 0x81, 0x8c, 0x02, 0xe2, 0x35, 0xd4, - 0x81, 0x80, 0x02, 0xe3, 0x36, 0xd4, 0x81, 0xf4, 0x01, 0xe4, 0x37, 0xd4, - 0x81, 0xe8, 0x01, 0xe5, 0x38, 0xd4, 0x81, 0xd6, 0x01, 0xe6, 0x39, 0xd4, - 0x01, 0xe7, 0x3a, 0xd4, 0x81, 0xc6, 0x01, 0xe8, 0x3b, 0xd4, 0x01, 0xe9, - 0x3c, 0xd4, 0x81, 0xb6, 0x01, 0xea, 0x3d, 0xd4, 0x01, 0xeb, 0x3e, 0xd4, - 0x81, 0xa6, 0x01, 0xec, 0x3f, 0xd4, 0x81, 0x9a, 0x01, 0xed, 0x40, 0xd4, - 0x81, 0x90, 0x01, 0xee, 0x41, 0xd4, 0x81, 0x86, 0x01, 0xef, 0x42, 0xd4, - 0x81, 0x72, 0xf0, 0x43, 0xd4, 0x81, 0x5d, 0xf1, 0x44, 0xd4, 0x01, 0xf2, - 0x45, 0xd4, 0x81, 0x4e, 0xf3, 0x46, 0xd4, 0x81, 0x43, 0xf4, 0x47, 0xd4, - 0x81, 0x2b, 0xf5, 0x48, 0xd4, 0x81, 0x20, 0xf6, 0x49, 0xd4, 0x01, 0xf7, - 0x4a, 0xd4, 0x01, 0xf8, 0x4b, 0xd4, 0x81, 0x0f, 0xf9, 0x4c, 0xd4, 0x01, - 0xfa, 0x4d, 0xd4, 0xc1, 0x00, 0x43, 0x94, 0x0f, 0xe7, 0xd6, 0x41, 0xe9, - 0xef, 0xd6, 0x41, 0x46, 0xcf, 0x15, 0xf6, 0xd6, 0x41, 0x42, 0x61, 0x24, - 0xf5, 0xd6, 0x01, 0x44, 0xe9, 0x95, 0xe9, 0xd6, 0xc1, 0x00, 0x47, 0x15, - 0x08, 0xf3, 0xd6, 0x41, 0x44, 0xc1, 0x1f, 0xf4, 0xd6, 0x41, 0x42, 0x0b, - 0x00, 0xf2, 0xd6, 0x41, 0x42, 0x49, 0x00, 0xf7, 0xd6, 0x01, 0xe9, 0xf1, - 0xd6, 0x01, 0x42, 0x5a, 0x03, 0xf9, 0xd6, 0x41, 0xad, 0x01, 0xff, 0x43, - 0xce, 0x05, 0xfa, 0xd6, 0x01, 0x45, 0x6a, 0xe7, 0xf0, 0xd6, 0x41, 0xf5, - 0xee, 0xd6, 0x41, 0xf5, 0xed, 0xd6, 0x41, 0x44, 0x38, 0xe8, 0xec, 0xd6, - 0x41, 0x44, 0xa9, 0x90, 0xeb, 0xd6, 0x41, 0x43, 0x1b, 0x05, 0xea, 0xd6, - 0x41, 0x44, 0x02, 0x21, 0xe4, 0xd6, 0x41, 0x46, 0xcf, 0x15, 0xe6, 0xd6, - 0x01, 0x42, 0x12, 0x00, 0xe8, 0xd6, 0x41, 0x44, 0x58, 0xd6, 0xe5, 0xd6, - 0x41, 0x42, 0x49, 0x00, 0xf8, 0xd6, 0x41, 0x43, 0x94, 0x0f, 0xe3, 0xd6, - 0x41, 0x44, 0x5f, 0xe4, 0xe2, 0xd6, 0x41, 0x4f, 0x3e, 0x39, 0xcd, 0x27, - 0x00, 0x07, 0x62, 0xc6, 0x01, 0xff, 0x08, 0xe4, 0x05, 0x6d, 0x06, 0x5d, - 0x07, 0x01, 0xff, 0xe1, 0x1e, 0xd5, 0x01, 0xe2, 0x1f, 0xd5, 0x01, 0xe3, - 0x20, 0xd5, 0x01, 0xe4, 0x21, 0xd5, 0x01, 0xe5, 0x22, 0xd5, 0x01, 0xe6, - 0x23, 0xd5, 0x01, 0xe7, 0x24, 0xd5, 0x01, 0xe8, 0x25, 0xd5, 0x01, 0xe9, - 0x26, 0xd5, 0x01, 0xea, 0x27, 0xd5, 0x01, 0xeb, 0x28, 0xd5, 0x01, 0xec, - 0x29, 0xd5, 0x01, 0xed, 0x2a, 0xd5, 0x01, 0xee, 0x2b, 0xd5, 0x01, 0xef, - 0x2c, 0xd5, 0x01, 0xf0, 0x2d, 0xd5, 0x01, 0xf1, 0x2e, 0xd5, 0x01, 0xf2, - 0x2f, 0xd5, 0x01, 0xf3, 0x30, 0xd5, 0x01, 0xf4, 0x31, 0xd5, 0x01, 0xf5, - 0x32, 0xd5, 0x01, 0xf6, 0x33, 0xd5, 0x01, 0xf7, 0x34, 0xd5, 0x01, 0xf8, - 0x35, 0xd5, 0x01, 0xf9, 0x36, 0xd5, 0x01, 0xfa, 0x37, 0xd5, 0x41, 0xe1, - 0x04, 0xd5, 0x01, 0xe2, 0x05, 0xd5, 0x01, 0xe4, 0x07, 0xd5, 0x01, 0xe5, - 0x08, 0xd5, 0x01, 0xe6, 0x09, 0xd5, 0x01, 0xe7, 0x0a, 0xd5, 0x01, 0xea, - 0x0d, 0xd5, 0x01, 0xeb, 0x0e, 0xd5, 0x01, 0xec, 0x0f, 0xd5, 0x01, 0xed, - 0x10, 0xd5, 0x01, 0xee, 0x11, 0xd5, 0x01, 0xef, 0x12, 0xd5, 0x01, 0xf0, - 0x13, 0xd5, 0x01, 0xf1, 0x14, 0xd5, 0x01, 0xf3, 0x16, 0xd5, 0x01, 0xf4, - 0x17, 0xd5, 0x01, 0xf5, 0x18, 0xd5, 0x01, 0xf6, 0x19, 0xd5, 0x01, 0xf7, - 0x1a, 0xd5, 0x01, 0xf8, 0x1b, 0xd5, 0x01, 0xf9, 0x1c, 0xd5, 0x41, 0x08, - 0xe4, 0x05, 0xb3, 0x01, 0x06, 0xef, 0x06, 0x6d, 0x06, 0x5d, 0x07, 0x01, - 0xff, 0xe1, 0x52, 0xd5, 0x01, 0xe2, 0x53, 0xd5, 0x01, 0xe3, 0x54, 0xd5, - 0x01, 0xe4, 0x55, 0xd5, 0x01, 0xe5, 0x56, 0xd5, 0x01, 0xe6, 0x57, 0xd5, - 0x01, 0xe7, 0x58, 0xd5, 0x01, 0xe8, 0x59, 0xd5, 0x01, 0xe9, 0x5a, 0xd5, - 0x01, 0xea, 0x5b, 0xd5, 0x01, 0xeb, 0x5c, 0xd5, 0x01, 0xec, 0x5d, 0xd5, - 0x01, 0xed, 0x5e, 0xd5, 0x01, 0xee, 0x5f, 0xd5, 0x01, 0xef, 0x60, 0xd5, - 0x01, 0xf0, 0x61, 0xd5, 0x01, 0xf1, 0x62, 0xd5, 0x01, 0xf2, 0x63, 0xd5, - 0x01, 0xf3, 0x64, 0xd5, 0x01, 0xf4, 0x65, 0xd5, 0x01, 0xf5, 0x66, 0xd5, - 0x01, 0xf6, 0x67, 0xd5, 0x01, 0xf7, 0x68, 0xd5, 0x01, 0xf8, 0x69, 0xd5, - 0x01, 0xf9, 0x6a, 0xd5, 0x01, 0xfa, 0x6b, 0xd5, 0x41, 0x45, 0x12, 0x0b, - 0xe0, 0xd7, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0xe1, 0xd7, 0x01, 0x43, - 0x0e, 0x0b, 0xd9, 0xd7, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, - 0xd8, 0xd7, 0x41, 0x44, 0x25, 0x01, 0xdb, 0xd7, 0x01, 0x42, 0x15, 0x02, - 0xda, 0xd7, 0x41, 0x44, 0xe5, 0x1d, 0xdf, 0xd7, 0x01, 0x42, 0x1c, 0x26, - 0xde, 0xd7, 0x41, 0x43, 0xd2, 0x05, 0xdd, 0xd7, 0x01, 0x43, 0xf6, 0x06, - 0xdc, 0xd7, 0x41, 0xe1, 0x38, 0xd5, 0x01, 0xe2, 0x39, 0xd5, 0x01, 0xe4, - 0x3b, 0xd5, 0x01, 0xe5, 0x3c, 0xd5, 0x01, 0xe6, 0x3d, 0xd5, 0x01, 0xe7, - 0x3e, 0xd5, 0x01, 0xe9, 0x40, 0xd5, 0x01, 0xea, 0x41, 0xd5, 0x01, 0xeb, - 0x42, 0xd5, 0x01, 0xec, 0x43, 0xd5, 0x01, 0xed, 0x44, 0xd5, 0x01, 0xef, - 0x46, 0xd5, 0x01, 0xf3, 0x4a, 0xd5, 0x01, 0xf4, 0x4b, 0xd5, 0x01, 0xf5, - 0x4c, 0xd5, 0x01, 0xf6, 0x4d, 0xd5, 0x01, 0xf7, 0x4e, 0xd5, 0x01, 0xf8, - 0x4f, 0xd5, 0x01, 0xf9, 0x50, 0xd5, 0x41, 0x08, 0xe4, 0x05, 0xcc, 0x0b, - 0x06, 0xef, 0x06, 0x85, 0x0b, 0x4e, 0xce, 0x15, 0xdc, 0xd6, 0x01, 0x08, - 0x61, 0xc6, 0xa1, 0x09, 0x07, 0x2b, 0xd2, 0xb0, 0x04, 0x4c, 0xa8, 0x90, - 0xde, 0xd6, 0x01, 0x45, 0x09, 0xe9, 0xc1, 0xd6, 0x01, 0xb0, 0x8f, 0x04, - 0x4a, 0x62, 0xb0, 0xe0, 0xd6, 0x01, 0xb3, 0x06, 0x4c, 0xe8, 0x95, 0xdd, - 0xd6, 0x41, 0x06, 0x75, 0x06, 0xa3, 0x02, 0x05, 0x5e, 0x07, 0x01, 0xff, - 0xe1, 0x1a, 0xd4, 0x81, 0x92, 0x02, 0xe2, 0x1b, 0xd4, 0x81, 0x86, 0x02, - 0xe3, 0x1c, 0xd4, 0x81, 0xfa, 0x01, 0xe4, 0x1d, 0xd4, 0x81, 0xe8, 0x01, - 0xe5, 0x1e, 0xd4, 0x81, 0xd6, 0x01, 0xe6, 0x1f, 0xd4, 0x81, 0xca, 0x01, - 0xe7, 0x20, 0xd4, 0x81, 0xbe, 0x01, 0xe8, 0x21, 0xd4, 0x01, 0xe9, 0x22, - 0xd4, 0x81, 0xae, 0x01, 0xea, 0x23, 0xd4, 0x01, 0xeb, 0x24, 0xd4, 0x81, - 0x9e, 0x01, 0xec, 0x25, 0xd4, 0x81, 0x92, 0x01, 0xed, 0x26, 0xd4, 0x81, - 0x88, 0x01, 0xee, 0x27, 0xd4, 0x81, 0x7f, 0xef, 0x28, 0xd4, 0x81, 0x6b, - 0xf0, 0x29, 0xd4, 0x81, 0x56, 0xf1, 0x2a, 0xd4, 0x01, 0xf2, 0x2b, 0xd4, - 0x81, 0x47, 0xf3, 0x2c, 0xd4, 0x81, 0x3c, 0xf4, 0x2d, 0xd4, 0x81, 0x2b, - 0xf5, 0x2e, 0xd4, 0x81, 0x20, 0xf6, 0x2f, 0xd4, 0x01, 0xf7, 0x30, 0xd4, - 0x01, 0xf8, 0x31, 0xd4, 0x81, 0x0f, 0xf9, 0x32, 0xd4, 0x01, 0xfa, 0x33, - 0xd4, 0xc1, 0x00, 0x43, 0x94, 0x0f, 0xc7, 0xd6, 0x41, 0xe9, 0xcf, 0xd6, - 0x41, 0x46, 0xcf, 0x15, 0xd6, 0xd6, 0x41, 0x42, 0x61, 0x24, 0xd5, 0xd6, - 0x01, 0x44, 0xe9, 0x95, 0xc9, 0xd6, 0x41, 0x44, 0xc1, 0x1f, 0xd4, 0xd6, - 0x41, 0x42, 0x0b, 0x00, 0xd2, 0xd6, 0x41, 0x42, 0x49, 0x00, 0xd7, 0xd6, - 0x01, 0xe9, 0xd1, 0xd6, 0x01, 0x42, 0x5a, 0x03, 0xd9, 0xd6, 0x41, 0xad, - 0x01, 0xff, 0x43, 0xce, 0x05, 0xda, 0xd6, 0x01, 0x45, 0x6a, 0xe7, 0xd0, - 0xd6, 0x41, 0xf5, 0xce, 0xd6, 0x41, 0xf5, 0xcd, 0xd6, 0x41, 0x44, 0x38, - 0xe8, 0xcc, 0xd6, 0x41, 0x44, 0xa9, 0x90, 0xcb, 0xd6, 0x41, 0x43, 0x1b, - 0x05, 0xca, 0xd6, 0x41, 0x44, 0x02, 0x21, 0xc4, 0xd6, 0x41, 0x4a, 0x3a, - 0x9c, 0xd3, 0xd6, 0x41, 0x46, 0xcf, 0x15, 0xc6, 0xd6, 0x01, 0x42, 0x12, - 0x00, 0xc8, 0xd6, 0x41, 0x44, 0x58, 0xd6, 0xc5, 0xd6, 0x01, 0x46, 0x32, - 0x58, 0xcb, 0xd7, 0x41, 0x42, 0x49, 0x00, 0xd8, 0xd6, 0x41, 0x43, 0x94, - 0x0f, 0xc3, 0xd6, 0x41, 0x44, 0x5f, 0xe4, 0xc2, 0xd6, 0x41, 0x08, 0xe4, - 0x05, 0x6d, 0x06, 0x5d, 0x07, 0x01, 0xff, 0xe1, 0xea, 0xd4, 0x01, 0xe2, - 0xeb, 0xd4, 0x01, 0xe3, 0xec, 0xd4, 0x01, 0xe4, 0xed, 0xd4, 0x01, 0xe5, - 0xee, 0xd4, 0x01, 0xe6, 0xef, 0xd4, 0x01, 0xe7, 0xf0, 0xd4, 0x01, 0xe8, - 0xf1, 0xd4, 0x01, 0xe9, 0xf2, 0xd4, 0x01, 0xea, 0xf3, 0xd4, 0x01, 0xeb, - 0xf4, 0xd4, 0x01, 0xec, 0xf5, 0xd4, 0x01, 0xed, 0xf6, 0xd4, 0x01, 0xee, - 0xf7, 0xd4, 0x01, 0xef, 0xf8, 0xd4, 0x01, 0xf0, 0xf9, 0xd4, 0x01, 0xf1, - 0xfa, 0xd4, 0x01, 0xf2, 0xfb, 0xd4, 0x01, 0xf3, 0xfc, 0xd4, 0x01, 0xf4, - 0xfd, 0xd4, 0x01, 0xf5, 0xfe, 0xd4, 0x01, 0xf6, 0xff, 0xd4, 0x01, 0xf7, - 0x00, 0xd5, 0x01, 0xf8, 0x01, 0xd5, 0x01, 0xf9, 0x02, 0xd5, 0x01, 0xfa, - 0x03, 0xd5, 0x41, 0xe1, 0xd0, 0xd4, 0x01, 0xe2, 0xd1, 0xd4, 0x01, 0xe3, - 0xd2, 0xd4, 0x01, 0xe4, 0xd3, 0xd4, 0x01, 0xe5, 0xd4, 0xd4, 0x01, 0xe6, - 0xd5, 0xd4, 0x01, 0xe7, 0xd6, 0xd4, 0x01, 0xe8, 0xd7, 0xd4, 0x01, 0xe9, - 0xd8, 0xd4, 0x01, 0xea, 0xd9, 0xd4, 0x01, 0xeb, 0xda, 0xd4, 0x01, 0xec, - 0xdb, 0xd4, 0x01, 0xed, 0xdc, 0xd4, 0x01, 0xee, 0xdd, 0xd4, 0x01, 0xef, - 0xde, 0xd4, 0x01, 0xf0, 0xdf, 0xd4, 0x01, 0xf1, 0xe0, 0xd4, 0x01, 0xf2, - 0xe1, 0xd4, 0x01, 0xf3, 0xe2, 0xd4, 0x01, 0xf4, 0xe3, 0xd4, 0x01, 0xf5, - 0xe4, 0xd4, 0x01, 0xf6, 0xe5, 0xd4, 0x01, 0xf7, 0xe6, 0xd4, 0x01, 0xf8, - 0xe7, 0xd4, 0x01, 0xf9, 0xe8, 0xd4, 0x01, 0xfa, 0xe9, 0xd4, 0x41, 0x53, - 0x55, 0x48, 0xdb, 0xd6, 0x01, 0x49, 0xb4, 0xb9, 0xdf, 0xd6, 0x01, 0x48, - 0x7c, 0xac, 0xe1, 0xd6, 0x41, 0x08, 0xe4, 0x05, 0xcf, 0x02, 0x4e, 0xce, - 0x15, 0x50, 0xd7, 0x01, 0x4c, 0xa8, 0x90, 0x52, 0xd7, 0x01, 0x45, 0x09, - 0xe9, 0x35, 0xd7, 0x01, 0xb0, 0xa8, 0x02, 0x4a, 0x62, 0xb0, 0x54, 0xd7, - 0x01, 0x06, 0x5d, 0x07, 0x06, 0x4c, 0xe8, 0x95, 0x51, 0xd7, 0x41, 0xe1, - 0x82, 0xd4, 0x81, 0x8c, 0x02, 0xe2, 0x83, 0xd4, 0x81, 0x80, 0x02, 0xe3, - 0x84, 0xd4, 0x81, 0xf4, 0x01, 0xe4, 0x85, 0xd4, 0x81, 0xe8, 0x01, 0xe5, - 0x86, 0xd4, 0x81, 0xd6, 0x01, 0xe6, 0x87, 0xd4, 0x81, 0xca, 0x01, 0xe7, - 0x88, 0xd4, 0x81, 0xbe, 0x01, 0xe8, 0x89, 0xd4, 0x01, 0xe9, 0x8a, 0xd4, - 0x81, 0xae, 0x01, 0xea, 0x8b, 0xd4, 0x01, 0xeb, 0x8c, 0xd4, 0x81, 0x9e, - 0x01, 0xec, 0x8d, 0xd4, 0x81, 0x92, 0x01, 0xed, 0x8e, 0xd4, 0x81, 0x88, - 0x01, 0xee, 0x8f, 0xd4, 0x81, 0x7f, 0xef, 0x90, 0xd4, 0x81, 0x6b, 0xf0, - 0x91, 0xd4, 0x81, 0x56, 0xf1, 0x92, 0xd4, 0x01, 0xf2, 0x93, 0xd4, 0x81, - 0x47, 0xf3, 0x94, 0xd4, 0x81, 0x3c, 0xf4, 0x95, 0xd4, 0x81, 0x2b, 0xf5, - 0x96, 0xd4, 0x81, 0x20, 0xf6, 0x97, 0xd4, 0x01, 0xf7, 0x98, 0xd4, 0x01, - 0xf8, 0x99, 0xd4, 0x81, 0x0f, 0xf9, 0x9a, 0xd4, 0x01, 0xfa, 0x9b, 0xd4, - 0xc1, 0x00, 0x43, 0x94, 0x0f, 0x3b, 0xd7, 0x41, 0xe9, 0x43, 0xd7, 0x41, - 0x46, 0xcf, 0x15, 0x4a, 0xd7, 0x41, 0x42, 0x61, 0x24, 0x49, 0xd7, 0x01, - 0x44, 0xe9, 0x95, 0x3d, 0xd7, 0x41, 0x44, 0xc1, 0x1f, 0x48, 0xd7, 0x41, - 0x42, 0x0b, 0x00, 0x46, 0xd7, 0x41, 0x42, 0x49, 0x00, 0x4b, 0xd7, 0x01, - 0xe9, 0x45, 0xd7, 0x01, 0x42, 0x5a, 0x03, 0x4d, 0xd7, 0x41, 0xad, 0x01, - 0xff, 0x43, 0xce, 0x05, 0x4e, 0xd7, 0x01, 0x45, 0x6a, 0xe7, 0x44, 0xd7, - 0x41, 0xf5, 0x42, 0xd7, 0x41, 0xf5, 0x41, 0xd7, 0x41, 0x44, 0x38, 0xe8, - 0x40, 0xd7, 0x41, 0x44, 0xa9, 0x90, 0x3f, 0xd7, 0x41, 0x43, 0x1b, 0x05, - 0x3e, 0xd7, 0x41, 0x44, 0x02, 0x21, 0x38, 0xd7, 0x41, 0x4a, 0x3a, 0x9c, - 0x47, 0xd7, 0x41, 0x46, 0xcf, 0x15, 0x3a, 0xd7, 0x01, 0x42, 0x12, 0x00, - 0x3c, 0xd7, 0x41, 0x44, 0x58, 0xd6, 0x39, 0xd7, 0x41, 0x42, 0x49, 0x00, - 0x4c, 0xd7, 0x41, 0x43, 0x94, 0x0f, 0x37, 0xd7, 0x41, 0x44, 0x5f, 0xe4, - 0x36, 0xd7, 0x41, 0x53, 0x55, 0x48, 0x4f, 0xd7, 0x01, 0x49, 0xb4, 0xb9, - 0x53, 0xd7, 0x01, 0x48, 0x7c, 0xac, 0x55, 0xd7, 0x41, 0xe1, 0x68, 0xd4, - 0x81, 0x8c, 0x02, 0xe2, 0x69, 0xd4, 0x81, 0x80, 0x02, 0xe3, 0x6a, 0xd4, - 0x81, 0xf4, 0x01, 0xe4, 0x6b, 0xd4, 0x81, 0xe8, 0x01, 0xe5, 0x6c, 0xd4, - 0x81, 0xd6, 0x01, 0xe6, 0x6d, 0xd4, 0x01, 0xe7, 0x6e, 0xd4, 0x81, 0xc6, - 0x01, 0xe8, 0x6f, 0xd4, 0x01, 0xe9, 0x70, 0xd4, 0x81, 0xb6, 0x01, 0xea, - 0x71, 0xd4, 0x01, 0xeb, 0x72, 0xd4, 0x81, 0xa6, 0x01, 0xec, 0x73, 0xd4, - 0x81, 0x9a, 0x01, 0xed, 0x74, 0xd4, 0x81, 0x90, 0x01, 0xee, 0x75, 0xd4, - 0x81, 0x86, 0x01, 0xef, 0x76, 0xd4, 0x81, 0x72, 0xf0, 0x77, 0xd4, 0x81, - 0x5d, 0xf1, 0x78, 0xd4, 0x01, 0xf2, 0x79, 0xd4, 0x81, 0x4e, 0xf3, 0x7a, - 0xd4, 0x81, 0x43, 0xf4, 0x7b, 0xd4, 0x81, 0x2b, 0xf5, 0x7c, 0xd4, 0x81, - 0x20, 0xf6, 0x7d, 0xd4, 0x01, 0xf7, 0x7e, 0xd4, 0x01, 0xf8, 0x7f, 0xd4, - 0x81, 0x0f, 0xf9, 0x80, 0xd4, 0x01, 0xfa, 0x81, 0xd4, 0xc1, 0x00, 0x43, - 0x94, 0x0f, 0x21, 0xd7, 0x41, 0xe9, 0x29, 0xd7, 0x41, 0x46, 0xcf, 0x15, - 0x30, 0xd7, 0x41, 0x42, 0x61, 0x24, 0x2f, 0xd7, 0x01, 0x44, 0xe9, 0x95, - 0x23, 0xd7, 0xc1, 0x00, 0x47, 0x15, 0x08, 0x2d, 0xd7, 0x41, 0x44, 0xc1, - 0x1f, 0x2e, 0xd7, 0x41, 0x42, 0x0b, 0x00, 0x2c, 0xd7, 0x41, 0x42, 0x49, - 0x00, 0x31, 0xd7, 0x01, 0xe9, 0x2b, 0xd7, 0x01, 0x42, 0x5a, 0x03, 0x33, - 0xd7, 0x41, 0xad, 0x01, 0xff, 0x43, 0xce, 0x05, 0x34, 0xd7, 0x01, 0x45, - 0x6a, 0xe7, 0x2a, 0xd7, 0x41, 0xf5, 0x28, 0xd7, 0x41, 0xf5, 0x27, 0xd7, - 0x41, 0x44, 0x38, 0xe8, 0x26, 0xd7, 0x41, 0x44, 0xa9, 0x90, 0x25, 0xd7, - 0x41, 0x43, 0x1b, 0x05, 0x24, 0xd7, 0x41, 0x44, 0x02, 0x21, 0x1e, 0xd7, - 0x41, 0x46, 0xcf, 0x15, 0x20, 0xd7, 0x01, 0x42, 0x12, 0x00, 0x22, 0xd7, - 0x41, 0x44, 0x58, 0xd6, 0x1f, 0xd7, 0x41, 0x42, 0x49, 0x00, 0x32, 0xd7, - 0x41, 0x43, 0x94, 0x0f, 0x1d, 0xd7, 0x41, 0x44, 0x5f, 0xe4, 0x1c, 0xd7, - 0x41, 0x08, 0xe4, 0x05, 0x6d, 0x06, 0x5d, 0x07, 0x01, 0xff, 0xe1, 0x86, - 0xd5, 0x01, 0xe2, 0x87, 0xd5, 0x01, 0xe3, 0x88, 0xd5, 0x01, 0xe4, 0x89, - 0xd5, 0x01, 0xe5, 0x8a, 0xd5, 0x01, 0xe6, 0x8b, 0xd5, 0x01, 0xe7, 0x8c, - 0xd5, 0x01, 0xe8, 0x8d, 0xd5, 0x01, 0xe9, 0x8e, 0xd5, 0x01, 0xea, 0x8f, - 0xd5, 0x01, 0xeb, 0x90, 0xd5, 0x01, 0xec, 0x91, 0xd5, 0x01, 0xed, 0x92, - 0xd5, 0x01, 0xee, 0x93, 0xd5, 0x01, 0xef, 0x94, 0xd5, 0x01, 0xf0, 0x95, - 0xd5, 0x01, 0xf1, 0x96, 0xd5, 0x01, 0xf2, 0x97, 0xd5, 0x01, 0xf3, 0x98, - 0xd5, 0x01, 0xf4, 0x99, 0xd5, 0x01, 0xf5, 0x9a, 0xd5, 0x01, 0xf6, 0x9b, - 0xd5, 0x01, 0xf7, 0x9c, 0xd5, 0x01, 0xf8, 0x9d, 0xd5, 0x01, 0xf9, 0x9e, - 0xd5, 0x01, 0xfa, 0x9f, 0xd5, 0x41, 0xe1, 0x6c, 0xd5, 0x01, 0xe2, 0x6d, - 0xd5, 0x01, 0xe3, 0x6e, 0xd5, 0x01, 0xe4, 0x6f, 0xd5, 0x01, 0xe5, 0x70, - 0xd5, 0x01, 0xe6, 0x71, 0xd5, 0x01, 0xe7, 0x72, 0xd5, 0x01, 0xe8, 0x73, - 0xd5, 0x01, 0xe9, 0x74, 0xd5, 0x01, 0xea, 0x75, 0xd5, 0x01, 0xeb, 0x76, - 0xd5, 0x01, 0xec, 0x77, 0xd5, 0x01, 0xed, 0x78, 0xd5, 0x01, 0xee, 0x79, - 0xd5, 0x01, 0xef, 0x7a, 0xd5, 0x01, 0xf0, 0x7b, 0xd5, 0x01, 0xf1, 0x7c, - 0xd5, 0x01, 0xf2, 0x7d, 0xd5, 0x01, 0xf3, 0x7e, 0xd5, 0x01, 0xf4, 0x7f, - 0xd5, 0x01, 0xf5, 0x80, 0xd5, 0x01, 0xf6, 0x81, 0xd5, 0x01, 0xf7, 0x82, - 0xd5, 0x01, 0xf8, 0x83, 0xd5, 0x01, 0xf9, 0x84, 0xd5, 0x01, 0xfa, 0x85, - 0xd5, 0x41, 0x45, 0x12, 0x0b, 0xd6, 0xd7, 0x01, 0xa6, 0x2e, 0x44, 0xea, - 0x2a, 0xd7, 0xd7, 0x01, 0x43, 0x0e, 0x0b, 0xcf, 0xd7, 0x01, 0xb3, 0x14, - 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xce, 0xd7, 0x41, 0x44, 0x25, 0x01, 0xd1, - 0xd7, 0x01, 0x42, 0x15, 0x02, 0xd0, 0xd7, 0x41, 0x44, 0xe5, 0x1d, 0xd5, - 0xd7, 0x01, 0x42, 0x1c, 0x26, 0xd4, 0xd7, 0x41, 0x43, 0xd2, 0x05, 0xd3, - 0xd7, 0x01, 0x43, 0xf6, 0x06, 0xd2, 0xd7, 0x41, 0xe1, 0x00, 0xd4, 0x81, - 0x92, 0x02, 0xe2, 0x01, 0xd4, 0x81, 0x86, 0x02, 0xe3, 0x02, 0xd4, 0x81, - 0xfa, 0x01, 0xe4, 0x03, 0xd4, 0x81, 0xe8, 0x01, 0xe5, 0x04, 0xd4, 0x81, - 0xd6, 0x01, 0xe6, 0x05, 0xd4, 0x01, 0xe7, 0x06, 0xd4, 0x81, 0xc6, 0x01, - 0xe8, 0x07, 0xd4, 0x01, 0xe9, 0x08, 0xd4, 0x81, 0xb6, 0x01, 0xea, 0x09, - 0xd4, 0x01, 0xeb, 0x0a, 0xd4, 0x81, 0xa6, 0x01, 0xec, 0x0b, 0xd4, 0x81, - 0x9a, 0x01, 0xed, 0x0c, 0xd4, 0x81, 0x90, 0x01, 0xee, 0x0d, 0xd4, 0x81, - 0x86, 0x01, 0xef, 0x0e, 0xd4, 0x81, 0x72, 0xf0, 0x0f, 0xd4, 0x81, 0x5d, - 0xf1, 0x10, 0xd4, 0x01, 0xf2, 0x11, 0xd4, 0x81, 0x4e, 0xf3, 0x12, 0xd4, - 0x81, 0x43, 0xf4, 0x13, 0xd4, 0x81, 0x2b, 0xf5, 0x14, 0xd4, 0x81, 0x20, - 0xf6, 0x15, 0xd4, 0x01, 0xf7, 0x16, 0xd4, 0x01, 0xf8, 0x17, 0xd4, 0x81, - 0x0f, 0xf9, 0x18, 0xd4, 0x01, 0xfa, 0x19, 0xd4, 0xc1, 0x00, 0x43, 0x94, - 0x0f, 0xad, 0xd6, 0x41, 0xe9, 0xb5, 0xd6, 0x41, 0x46, 0xcf, 0x15, 0xbc, - 0xd6, 0x41, 0x42, 0x61, 0x24, 0xbb, 0xd6, 0x01, 0x44, 0xe9, 0x95, 0xaf, - 0xd6, 0xc1, 0x00, 0x47, 0x15, 0x08, 0xb9, 0xd6, 0x41, 0x44, 0xc1, 0x1f, - 0xba, 0xd6, 0x41, 0x42, 0x0b, 0x00, 0xb8, 0xd6, 0x41, 0x42, 0x49, 0x00, - 0xbd, 0xd6, 0x01, 0xe9, 0xb7, 0xd6, 0x01, 0x42, 0x5a, 0x03, 0xbf, 0xd6, - 0x41, 0xad, 0x01, 0xff, 0x43, 0xce, 0x05, 0xc0, 0xd6, 0x01, 0x45, 0x6a, - 0xe7, 0xb6, 0xd6, 0x41, 0xf5, 0xb4, 0xd6, 0x41, 0xf5, 0xb3, 0xd6, 0x41, - 0x44, 0x38, 0xe8, 0xb2, 0xd6, 0x41, 0x44, 0xa9, 0x90, 0xb1, 0xd6, 0x41, - 0x43, 0x1b, 0x05, 0xb0, 0xd6, 0x41, 0x44, 0x02, 0x21, 0xaa, 0xd6, 0x41, - 0x46, 0xcf, 0x15, 0xac, 0xd6, 0x01, 0x42, 0x12, 0x00, 0xae, 0xd6, 0x41, - 0x44, 0x58, 0xd6, 0xab, 0xd6, 0x01, 0x46, 0x32, 0x58, 0xca, 0xd7, 0x41, - 0x42, 0x49, 0x00, 0xbe, 0xd6, 0x41, 0x43, 0x94, 0x0f, 0xa9, 0xd6, 0x41, - 0x44, 0x5f, 0xe4, 0xa8, 0xd6, 0x41, 0x0b, 0x37, 0x99, 0x12, 0x58, 0xf9, - 0x27, 0xba, 0x00, 0x00, 0x4d, 0xe2, 0x84, 0xad, 0xf1, 0x01, 0x46, 0x4d, - 0xcf, 0x3c, 0x30, 0x40, 0x06, 0xef, 0x06, 0x82, 0x03, 0x07, 0xec, 0x05, - 0x6c, 0xb2, 0x5e, 0x05, 0x5a, 0x03, 0x3c, 0xb6, 0x01, 0xff, 0x45, 0xe6, - 0x23, 0x45, 0x1d, 0x01, 0x0a, 0x56, 0x77, 0x01, 0xff, 0xa1, 0x20, 0xe5, - 0x3a, 0x1d, 0x01, 0xe9, 0x32, 0x1d, 0x81, 0x13, 0xef, 0x3d, 0x1d, 0x01, - 0xf5, 0x34, 0x1d, 0x81, 0x06, 0x49, 0x43, 0xc1, 0x36, 0x1d, 0x41, 0xf5, - 0x35, 0x1d, 0x41, 0xe9, 0x33, 0x1d, 0x41, 0xe1, 0x31, 0x1d, 0x01, 0xe9, - 0x3c, 0x1d, 0x01, 0xf5, 0x3f, 0x1d, 0x41, 0x48, 0x3c, 0x16, 0x40, 0x1d, - 0x01, 0x46, 0xd9, 0x23, 0x43, 0x1d, 0x01, 0x47, 0x8a, 0xd1, 0x44, 0x1d, - 0x01, 0x45, 0x5a, 0x3f, 0x42, 0x1d, 0x01, 0x47, 0xf1, 0x4b, 0x41, 0x1d, - 0x41, 0x46, 0x88, 0xd9, 0x47, 0x1d, 0x01, 0x44, 0xb3, 0xc5, 0x46, 0x1d, - 0x41, 0xe1, 0x00, 0x1d, 0x81, 0x80, 0x02, 0xa2, 0xf3, 0x01, 0xa3, 0xe6, - 0x01, 0xa4, 0xcd, 0x01, 0xe5, 0x06, 0x1d, 0x01, 0xa7, 0xbc, 0x01, 0x42, - 0x22, 0x00, 0x2c, 0x1d, 0x01, 0xe9, 0x02, 0x1d, 0x81, 0xac, 0x01, 0xaa, - 0x99, 0x01, 0xab, 0x86, 0x01, 0xac, 0x7a, 0x42, 0x6c, 0x00, 0x24, 0x1d, - 0x01, 0xae, 0x5c, 0xef, 0x09, 0x1d, 0x01, 0xb0, 0x4c, 0x42, 0x71, 0x00, - 0x26, 0x1d, 0x01, 0xb3, 0x34, 0xb4, 0x15, 0xf5, 0x04, 0x1d, 0x81, 0x0c, - 0x42, 0xf5, 0x0a, 0x28, 0x1d, 0x01, 0x42, 0xbe, 0x22, 0x25, 0x1d, 0x41, - 0xf5, 0x05, 0x1d, 0x41, 0xe1, 0x1b, 0x1d, 0x01, 0x42, 0x22, 0x00, 0x1c, - 0x1d, 0x01, 0x42, 0x71, 0x00, 0x30, 0x1d, 0x01, 0xb4, 0x01, 0xff, 0xe1, - 0x16, 0x1d, 0x01, 0x42, 0x22, 0x00, 0x17, 0x1d, 0x41, 0xe1, 0x2b, 0x1d, - 0x01, 0x42, 0x22, 0x00, 0x29, 0x1d, 0x01, 0x42, 0x40, 0x06, 0x2a, 0x1d, - 0x41, 0xe1, 0x20, 0x1d, 0x01, 0x42, 0x22, 0x00, 0x21, 0x1d, 0x41, 0xe1, - 0x1f, 0x1d, 0x01, 0x42, 0x24, 0x02, 0x10, 0x1d, 0x01, 0x42, 0x2a, 0x05, - 0x1a, 0x1d, 0x01, 0x42, 0xbe, 0x22, 0x15, 0x1d, 0x41, 0xe1, 0x27, 0x1d, - 0x01, 0x42, 0x74, 0x00, 0x2d, 0x1d, 0x41, 0xe1, 0x0c, 0x1d, 0x01, 0x42, - 0x22, 0x00, 0x0d, 0x1d, 0x01, 0x43, 0xfd, 0x20, 0x2e, 0x1d, 0x41, 0xe1, - 0x13, 0x1d, 0x01, 0x42, 0x22, 0x00, 0x14, 0x1d, 0x01, 0x43, 0xc1, 0x35, - 0x2f, 0x1d, 0x41, 0xe9, 0x03, 0x1d, 0x41, 0xe1, 0x0e, 0x1d, 0x01, 0x42, - 0x22, 0x00, 0x0f, 0x1d, 0x41, 0xe1, 0x1d, 0x1d, 0x01, 0xa4, 0x06, 0x42, - 0x22, 0x00, 0x1e, 0x1d, 0x41, 0xe1, 0x18, 0x1d, 0x01, 0x42, 0x22, 0x00, - 0x19, 0x1d, 0x41, 0xe1, 0x11, 0x1d, 0x01, 0x42, 0x22, 0x00, 0x12, 0x1d, - 0x41, 0xe1, 0x22, 0x1d, 0x01, 0x42, 0x22, 0x00, 0x23, 0x1d, 0x41, 0xe1, - 0x01, 0x1d, 0x01, 0xe9, 0x08, 0x1d, 0x01, 0xf5, 0x0b, 0x1d, 0x41, 0x45, - 0x12, 0x0b, 0x58, 0x1d, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x59, 0x1d, - 0x01, 0x43, 0x0e, 0x0b, 0x51, 0x1d, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, - 0x5f, 0x1e, 0x50, 0x1d, 0x41, 0x44, 0x25, 0x01, 0x53, 0x1d, 0x01, 0x42, - 0x15, 0x02, 0x52, 0x1d, 0x41, 0x44, 0xe5, 0x1d, 0x57, 0x1d, 0x01, 0x42, - 0x1c, 0x26, 0x56, 0x1d, 0x41, 0x43, 0xd2, 0x05, 0x55, 0x1d, 0x01, 0x43, - 0xf6, 0x06, 0x54, 0x1d, 0x41, 0x44, 0x4c, 0x61, 0x87, 0xfa, 0x01, 0x05, - 0x59, 0x4a, 0x0c, 0x4c, 0x8c, 0x94, 0xad, 0x26, 0x00, 0x51, 0x76, 0x5e, - 0x4b, 0xf9, 0x41, 0x49, 0xbc, 0x1b, 0x70, 0x1c, 0x01, 0x07, 0xec, 0x05, - 0xe9, 0x01, 0x49, 0x0f, 0xbc, 0x71, 0x1c, 0x01, 0xb3, 0x1b, 0x0b, 0x55, - 0x77, 0x01, 0xff, 0x42, 0x80, 0x12, 0xb0, 0x1c, 0x01, 0xe5, 0xb3, 0x1c, - 0x01, 0xe9, 0xb1, 0x1c, 0x01, 0xef, 0xb4, 0x1c, 0x01, 0xf5, 0xb2, 0x1c, - 0x41, 0x04, 0x5b, 0x03, 0xb5, 0x01, 0x10, 0xdd, 0x67, 0x01, 0xff, 0xe1, - 0xaf, 0x1c, 0x01, 0x42, 0x16, 0x00, 0xa0, 0x1c, 0x01, 0xa3, 0x99, 0x01, - 0xa4, 0x8c, 0x01, 0x42, 0x24, 0x02, 0x94, 0x1c, 0x01, 0x42, 0x22, 0x00, - 0xae, 0x1c, 0x01, 0x42, 0x72, 0x19, 0x98, 0x1c, 0x01, 0xab, 0x6e, 0x42, - 0x74, 0x00, 0xab, 0x1c, 0x01, 0x42, 0x6c, 0x00, 0xa1, 0x1c, 0x01, 0xae, - 0x50, 0xb0, 0x44, 0x42, 0x71, 0x00, 0xaa, 0x1c, 0x01, 0xb3, 0x32, 0xb4, - 0x19, 0x42, 0xa9, 0x01, 0xa5, 0x1c, 0x01, 0x42, 0xbe, 0x22, 0xa9, 0x1c, - 0x01, 0xba, 0x01, 0xff, 0xe1, 0xa7, 0x1c, 0x01, 0x42, 0x22, 0x00, 0xa6, - 0x1c, 0x41, 0xe1, 0x9a, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x9b, 0x1c, 0x01, - 0xb3, 0x01, 0xff, 0xe1, 0xa2, 0x1c, 0x01, 0x42, 0x22, 0x00, 0xa3, 0x1c, - 0x41, 0xe1, 0xad, 0x1c, 0x01, 0x42, 0x22, 0x00, 0xac, 0x1c, 0x41, 0xe1, - 0x9e, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x9f, 0x1c, 0x41, 0xe1, 0x9d, 0x1c, - 0x01, 0x42, 0x24, 0x02, 0x95, 0x1c, 0x01, 0x42, 0xbe, 0x22, 0x99, 0x1c, - 0x41, 0xe1, 0x92, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x93, 0x1c, 0x41, 0xe1, - 0x9c, 0x1c, 0x01, 0x42, 0x59, 0x00, 0xa4, 0x1c, 0x41, 0xe1, 0x96, 0x1c, - 0x01, 0x42, 0x22, 0x00, 0x97, 0x1c, 0x41, 0x48, 0x3c, 0x16, 0xb5, 0x1c, - 0x01, 0x4b, 0xd9, 0x23, 0xb6, 0x1c, 0x41, 0x42, 0xea, 0x25, 0x88, 0x1c, - 0x01, 0xe1, 0x8f, 0x1c, 0x01, 0x42, 0x16, 0x00, 0x80, 0x1c, 0x01, 0xa3, - 0x99, 0x01, 0xa4, 0x8c, 0x01, 0x42, 0x24, 0x02, 0x74, 0x1c, 0x01, 0x42, - 0x22, 0x00, 0x8e, 0x1c, 0x01, 0x42, 0x72, 0x19, 0x78, 0x1c, 0x01, 0xab, - 0x6e, 0x42, 0x74, 0x00, 0x8b, 0x1c, 0x01, 0x42, 0x6c, 0x00, 0x81, 0x1c, - 0x01, 0xae, 0x50, 0xb0, 0x44, 0x42, 0x71, 0x00, 0x8a, 0x1c, 0x01, 0xb3, - 0x32, 0xb4, 0x19, 0x42, 0xa9, 0x01, 0x85, 0x1c, 0x01, 0x42, 0xbe, 0x22, - 0x89, 0x1c, 0x01, 0xba, 0x01, 0xff, 0xe1, 0x87, 0x1c, 0x01, 0x42, 0x22, - 0x00, 0x86, 0x1c, 0x41, 0xe1, 0x7a, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x7b, - 0x1c, 0x01, 0xb3, 0x01, 0xff, 0xe1, 0x82, 0x1c, 0x01, 0x42, 0x22, 0x00, - 0x83, 0x1c, 0x41, 0xe1, 0x8d, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x8c, 0x1c, - 0x41, 0xe1, 0x7e, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x7f, 0x1c, 0x41, 0xe1, - 0x7d, 0x1c, 0x01, 0x42, 0x24, 0x02, 0x75, 0x1c, 0x01, 0x42, 0xbe, 0x22, - 0x79, 0x1c, 0x41, 0xe1, 0x72, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x73, 0x1c, - 0x41, 0xe1, 0x7c, 0x1c, 0x01, 0x42, 0x59, 0x00, 0x84, 0x1c, 0x41, 0xe1, - 0x76, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x77, 0x1c, 0x41, 0x56, 0x66, 0x32, - 0xef, 0x26, 0x00, 0x47, 0xe1, 0xd2, 0x41, 0xf3, 0x41, 0x80, 0xa5, 0x04, - 0x47, 0xa8, 0x6c, 0xbc, 0x20, 0x00, 0x05, 0x8f, 0xe5, 0x87, 0x03, 0x42, - 0x06, 0x14, 0x6d, 0xf9, 0x01, 0x08, 0x01, 0xc7, 0x12, 0x46, 0xe2, 0xdf, - 0x5e, 0xf4, 0x01, 0x4e, 0xae, 0x7c, 0x70, 0xf5, 0x01, 0x4e, 0xd4, 0x7d, - 0xbd, 0xf9, 0x41, 0x12, 0x12, 0x50, 0xda, 0x02, 0x07, 0xec, 0x05, 0x5d, - 0x07, 0x1a, 0x3a, 0x37, 0x0c, 0x6d, 0x16, 0x06, 0x47, 0xff, 0xd5, 0xc8, - 0x0a, 0x41, 0x02, 0x3b, 0x01, 0x18, 0x47, 0x03, 0x37, 0xf1, 0x0a, 0x01, - 0x4b, 0xe3, 0x9e, 0xf6, 0x0a, 0x01, 0x44, 0x31, 0x13, 0xf0, 0x0a, 0x01, - 0x48, 0x1f, 0x0a, 0xf5, 0x0a, 0x41, 0xf4, 0xf4, 0x0a, 0x81, 0x06, 0x53, - 0x0c, 0x4e, 0xf2, 0x0a, 0x41, 0x4b, 0x14, 0x4e, 0xf3, 0x0a, 0x41, 0x44, - 0x80, 0x11, 0xec, 0x0a, 0x01, 0x43, 0x0e, 0x0b, 0xeb, 0x0a, 0x81, 0x0f, - 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0xed, 0x0a, 0x01, 0x45, 0x9a, 0x2c, - 0xee, 0x0a, 0x41, 0x48, 0x70, 0x11, 0xef, 0x0a, 0x41, 0xa1, 0xe4, 0x01, - 0xa2, 0xd5, 0x01, 0xa4, 0xc6, 0x01, 0x42, 0x28, 0x1a, 0xdc, 0x0a, 0x01, - 0xa7, 0xb1, 0x01, 0x42, 0xb0, 0x01, 0xc6, 0x0a, 0x81, 0xa3, 0x01, 0xaa, - 0x94, 0x01, 0xab, 0x85, 0x01, 0x46, 0xb4, 0xdd, 0xd3, 0x0a, 0x01, 0x43, - 0xb4, 0x05, 0xd6, 0x0a, 0x01, 0x43, 0xde, 0x22, 0xd7, 0x0a, 0x01, 0x42, - 0x6f, 0x02, 0xdb, 0x0a, 0x01, 0xb1, 0x5f, 0x44, 0x7d, 0x66, 0xe1, 0x0a, - 0x01, 0xb3, 0x3d, 0xb4, 0x29, 0x43, 0x9f, 0x8a, 0xc7, 0x0a, 0x01, 0xb8, - 0x15, 0x44, 0xa8, 0x52, 0xcf, 0x0a, 0x01, 0xba, 0x01, 0xff, 0x44, 0x25, - 0x4a, 0xc9, 0x0a, 0x01, 0x45, 0x10, 0xe7, 0xca, 0x0a, 0x41, 0x43, 0x83, - 0x10, 0xd1, 0x0a, 0x01, 0x43, 0x82, 0x36, 0xdf, 0x0a, 0x41, 0x42, 0xd2, - 0x2d, 0xe4, 0x0a, 0x01, 0x43, 0xf5, 0x25, 0xce, 0x0a, 0x01, 0x46, 0x6a, - 0xdc, 0xd5, 0x0a, 0x41, 0xa1, 0x0c, 0x43, 0x7a, 0x16, 0xe2, 0x0a, 0x01, - 0x44, 0x7a, 0x4a, 0xe3, 0x0a, 0x41, 0x43, 0xcd, 0xea, 0xdd, 0x0a, 0x01, - 0x44, 0x69, 0xe4, 0xd8, 0x0a, 0x41, 0x44, 0x71, 0xf0, 0xe0, 0x0a, 0x01, - 0x43, 0x82, 0x36, 0xde, 0x0a, 0x41, 0x43, 0x83, 0x10, 0xd0, 0x0a, 0x01, - 0x44, 0xf7, 0xe7, 0xd2, 0x0a, 0x41, 0x44, 0x25, 0x4a, 0xcb, 0x0a, 0x01, - 0x45, 0x10, 0xe7, 0xcc, 0x0a, 0x41, 0x42, 0x53, 0x00, 0xcd, 0x0a, 0x41, - 0x45, 0x1f, 0xe7, 0xc4, 0x0a, 0x01, 0x44, 0xff, 0xaa, 0xc3, 0x0a, 0x41, - 0x45, 0x2b, 0x4a, 0xc5, 0x0a, 0x01, 0x46, 0x6a, 0xdc, 0xd4, 0x0a, 0x41, - 0x43, 0xf5, 0x25, 0xc1, 0x0a, 0x01, 0x44, 0x82, 0xaa, 0xc2, 0x0a, 0x41, - 0x44, 0x25, 0x4a, 0xda, 0x0a, 0x01, 0x44, 0x33, 0x3d, 0xc0, 0x0a, 0x01, - 0x43, 0x9a, 0x1a, 0xd9, 0x0a, 0x41, 0x45, 0x5c, 0x00, 0xe5, 0x0a, 0x01, - 0x45, 0x20, 0x07, 0xe6, 0x0a, 0x41, 0x50, 0xdd, 0x60, 0x59, 0x08, 0x00, - 0x4f, 0x90, 0x6d, 0x5b, 0x08, 0x00, 0x07, 0xec, 0x05, 0x0c, 0x4b, 0x07, - 0x0c, 0x5e, 0x08, 0x00, 0x51, 0x53, 0x5f, 0x5a, 0x08, 0x40, 0xa1, 0x22, - 0x48, 0x61, 0xc5, 0x56, 0x08, 0x00, 0x45, 0xf7, 0xe6, 0x40, 0x08, 0x00, - 0xa9, 0x0c, 0x43, 0x18, 0xa6, 0x57, 0x08, 0x00, 0x47, 0x62, 0xc5, 0x45, - 0x08, 0x40, 0xee, 0x4f, 0x08, 0x00, 0xf4, 0x47, 0x08, 0x40, 0xe2, 0x41, - 0x08, 0x00, 0xe4, 0x43, 0x08, 0x00, 0xe7, 0x42, 0x08, 0x00, 0xe8, 0x44, - 0x08, 0x00, 0x42, 0x9e, 0x01, 0x58, 0x08, 0x00, 0xeb, 0x4a, 0x08, 0x80, - 0x32, 0xec, 0x4b, 0x08, 0x00, 0xed, 0x4c, 0x08, 0x00, 0xee, 0x4d, 0x08, - 0x00, 0xf0, 0x50, 0x08, 0x00, 0xf1, 0x52, 0x08, 0x00, 0xf2, 0x53, 0x08, - 0x00, 0xf3, 0x4e, 0x08, 0x80, 0x0d, 0xf4, 0x55, 0x08, 0x80, 0x04, 0xfa, - 0x46, 0x08, 0x40, 0xf4, 0x48, 0x08, 0x40, 0xe8, 0x54, 0x08, 0x00, 0xfa, - 0x51, 0x08, 0x40, 0x42, 0x40, 0x06, 0x49, 0x08, 0x40, 0x57, 0x31, 0x2d, - 0x6b, 0xf4, 0x01, 0x47, 0x4f, 0xd0, 0x7a, 0xf5, 0x01, 0x03, 0xe1, 0x05, - 0x11, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4a, 0x1c, 0xab, 0x72, 0xf4, 0x01, - 0x46, 0xd8, 0xe0, 0x73, 0xf4, 0x41, 0x58, 0xb1, 0x27, 0x74, 0xf5, 0x01, - 0x46, 0xde, 0xe0, 0x35, 0xf9, 0x41, 0x07, 0x0e, 0xb6, 0x27, 0x02, 0x60, - 0x00, 0x06, 0x4a, 0xe8, 0xb1, 0x20, 0x27, 0x40, 0x4f, 0x2a, 0x27, 0xa5, - 0x26, 0x00, 0x44, 0x5a, 0x03, 0x42, 0x26, 0x00, 0x0c, 0xf4, 0x3c, 0x01, - 0xff, 0x58, 0x21, 0x27, 0xa7, 0x26, 0x00, 0x44, 0x5a, 0x03, 0xa6, 0x26, - 0x40, 0x4e, 0x1e, 0x76, 0x57, 0x0d, 0x00, 0xa4, 0x91, 0x05, 0x09, 0x25, - 0x5a, 0xb0, 0x04, 0x07, 0xec, 0x05, 0xad, 0x01, 0x07, 0x1a, 0x3a, 0x92, - 0x01, 0x05, 0x5a, 0x03, 0x4e, 0x0b, 0x55, 0x77, 0x01, 0xff, 0xa1, 0x3b, - 0xe5, 0x46, 0x0d, 0x80, 0x32, 0xe9, 0x3f, 0x0d, 0x80, 0x29, 0xef, 0x4a, - 0x0d, 0x80, 0x20, 0xf5, 0x41, 0x0d, 0x80, 0x17, 0x08, 0x43, 0xc1, 0x01, - 0xff, 0xec, 0x62, 0x0d, 0x80, 0x09, 0xf2, 0x43, 0x0d, 0xc0, 0x00, 0xf2, - 0x44, 0x0d, 0x40, 0xec, 0x63, 0x0d, 0x40, 0xf5, 0x42, 0x0d, 0x40, 0xef, - 0x4b, 0x0d, 0x40, 0xe9, 0x40, 0x0d, 0x40, 0xe5, 0x47, 0x0d, 0x40, 0xe1, - 0x3e, 0x0d, 0x00, 0xe9, 0x48, 0x0d, 0x00, 0xf5, 0x4c, 0x0d, 0x40, 0xa1, - 0x32, 0xa3, 0x1e, 0x44, 0x7d, 0x10, 0x4f, 0x0d, 0x00, 0xb6, 0x01, 0xff, - 0x52, 0x7a, 0x51, 0x3b, 0x0d, 0x00, 0xa9, 0x01, 0xff, 0x44, 0xe7, 0x23, - 0x4d, 0x0d, 0x00, 0x45, 0xf3, 0x4b, 0x03, 0x0d, 0x40, 0x4a, 0xda, 0x23, - 0x01, 0x0d, 0x00, 0x4e, 0xda, 0x78, 0x3c, 0x0d, 0x00, 0x57, 0x33, 0x16, - 0x00, 0x0d, 0x40, 0x47, 0x3d, 0x16, 0x02, 0x0d, 0x00, 0x47, 0xc4, 0x88, - 0x3d, 0x0d, 0x40, 0x04, 0x0e, 0x0b, 0x06, 0x43, 0xdb, 0x06, 0x70, 0x0d, - 0x40, 0x47, 0x71, 0x11, 0x71, 0x0d, 0x00, 0x48, 0x47, 0x5e, 0x72, 0x0d, - 0x40, 0xe1, 0x05, 0x0d, 0x80, 0xe6, 0x02, 0xa2, 0xd9, 0x02, 0xa3, 0x9d, - 0x02, 0xa4, 0xfe, 0x01, 0xe5, 0x0e, 0x0d, 0x80, 0xf4, 0x01, 0xa7, 0xe7, - 0x01, 0x42, 0x22, 0x00, 0x39, 0x0d, 0x00, 0xe9, 0x07, 0x0d, 0x80, 0xd7, - 0x01, 0xaa, 0xca, 0x01, 0xab, 0xbd, 0x01, 0xac, 0xa9, 0x01, 0x42, 0x6c, - 0x00, 0x2e, 0x0d, 0x00, 0xae, 0x84, 0x01, 0xef, 0x12, 0x0d, 0x80, 0x7b, - 0xb0, 0x6f, 0xb2, 0x63, 0xb3, 0x51, 0xb4, 0x32, 0xf5, 0x09, 0x0d, 0x80, - 0x29, 0xb6, 0x06, 0x42, 0xbe, 0x22, 0x2f, 0x0d, 0x40, 0xe1, 0x35, 0x0d, - 0x00, 0x4d, 0x7f, 0x82, 0x04, 0x0d, 0x00, 0x07, 0x44, 0xc1, 0x01, 0xff, - 0xec, 0x0c, 0x0d, 0x80, 0x09, 0xf2, 0x0b, 0x0d, 0xc0, 0x00, 0xf2, 0x60, - 0x0d, 0x40, 0xec, 0x61, 0x0d, 0x40, 0xf5, 0x0a, 0x0d, 0x40, 0xe1, 0x24, - 0x0d, 0x00, 0x42, 0x22, 0x00, 0x25, 0x0d, 0x00, 0xb4, 0x01, 0xff, 0xe1, - 0x1f, 0x0d, 0x00, 0x42, 0x22, 0x00, 0x20, 0x0d, 0x00, 0x42, 0x12, 0x00, - 0x3a, 0x0d, 0x40, 0xe1, 0x38, 0x0d, 0x00, 0x42, 0x22, 0x00, 0x36, 0x0d, - 0x00, 0x42, 0x40, 0x06, 0x37, 0x0d, 0x40, 0xe1, 0x30, 0x0d, 0x00, 0x42, - 0x71, 0x00, 0x31, 0x0d, 0x40, 0xe1, 0x2a, 0x0d, 0x00, 0x42, 0x22, 0x00, - 0x2b, 0x0d, 0x40, 0xef, 0x13, 0x0d, 0x40, 0xe1, 0x28, 0x0d, 0x00, 0x42, - 0x24, 0x02, 0x19, 0x0d, 0x00, 0xae, 0x06, 0x42, 0xbe, 0x22, 0x1e, 0x0d, - 0x40, 0xe1, 0x23, 0x0d, 0x00, 0x42, 0x2a, 0x05, 0x29, 0x0d, 0x40, 0xe1, - 0x32, 0x0d, 0x00, 0xac, 0x01, 0xff, 0xe1, 0x33, 0x0d, 0x00, 0x42, 0x74, - 0x00, 0x34, 0x0d, 0x40, 0xe1, 0x15, 0x0d, 0x00, 0x42, 0x22, 0x00, 0x16, - 0x0d, 0x40, 0xe1, 0x1c, 0x0d, 0x00, 0x42, 0x22, 0x00, 0x1d, 0x0d, 0x40, - 0xe9, 0x08, 0x0d, 0x40, 0xe1, 0x17, 0x0d, 0x00, 0x42, 0x22, 0x00, 0x18, - 0x0d, 0x40, 0xe5, 0x0f, 0x0d, 0x40, 0xe1, 0x26, 0x0d, 0x00, 0xa4, 0x0c, - 0x42, 0x22, 0x00, 0x27, 0x0d, 0x00, 0x47, 0x46, 0xd4, 0x4e, 0x0d, 0x40, - 0xe1, 0x21, 0x0d, 0x00, 0x42, 0x22, 0x00, 0x22, 0x0d, 0x40, 0xe1, 0x1a, - 0x0d, 0x00, 0xa8, 0x01, 0xff, 0xe1, 0x1b, 0x0d, 0x00, 0x05, 0x45, 0xc2, - 0x01, 0xff, 0xeb, 0x7f, 0x0d, 0x00, 0xec, 0x7d, 0x0d, 0x80, 0x17, 0xed, - 0x54, 0x0d, 0x00, 0xee, 0x7b, 0x0d, 0x80, 0x0a, 0x42, 0xcf, 0x00, 0x7c, - 0x0d, 0x00, 0xf9, 0x55, 0x0d, 0x40, 0xee, 0x7a, 0x0d, 0x40, 0xec, 0x7e, - 0x0d, 0xc0, 0x00, 0xec, 0x56, 0x0d, 0x40, 0xe1, 0x2c, 0x0d, 0x00, 0x42, - 0x22, 0x00, 0x2d, 0x0d, 0x40, 0xe1, 0x06, 0x0d, 0x00, 0xe9, 0x10, 0x0d, - 0x00, 0x49, 0x8e, 0xbe, 0x5f, 0x0d, 0x00, 0xf5, 0x14, 0x0d, 0x40, 0x04, - 0x0e, 0x0b, 0x1d, 0x06, 0x24, 0x01, 0x01, 0xff, 0x4a, 0xfa, 0xa9, 0x5a, - 0x0d, 0x00, 0x48, 0x2a, 0x01, 0x75, 0x0d, 0x00, 0x4a, 0x34, 0xb1, 0x78, - 0x0d, 0x00, 0x4a, 0x60, 0xb2, 0x5d, 0x0d, 0x40, 0x46, 0x12, 0x0b, 0x77, - 0x0d, 0x00, 0xa6, 0x27, 0x44, 0x22, 0x00, 0x74, 0x0d, 0x00, 0x58, 0x51, - 0x2a, 0x58, 0x0d, 0x00, 0x47, 0x2a, 0x01, 0x73, 0x0d, 0x00, 0x49, 0x1b, - 0x26, 0x76, 0x0d, 0x00, 0xb4, 0x01, 0xff, 0x44, 0x9e, 0x1b, 0x5c, 0x0d, - 0x00, 0x48, 0xf0, 0x25, 0x5b, 0x0d, 0x40, 0x44, 0x63, 0xaf, 0x5e, 0x0d, - 0x00, 0x47, 0x38, 0xd4, 0x59, 0x0d, 0x40, 0x48, 0xd9, 0xc3, 0x79, 0x0d, - 0x00, 0x05, 0xf0, 0x06, 0x01, 0xff, 0x45, 0x12, 0x0b, 0x6e, 0x0d, 0x00, - 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x6f, 0x0d, 0x00, 0x43, 0x0e, 0x0b, 0x67, - 0x0d, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x66, 0x0d, 0x40, - 0x44, 0x25, 0x01, 0x69, 0x0d, 0x00, 0x42, 0x15, 0x02, 0x68, 0x0d, 0x40, - 0x44, 0xe5, 0x1d, 0x6d, 0x0d, 0x00, 0x42, 0x1c, 0x26, 0x6c, 0x0d, 0x40, - 0x43, 0xd2, 0x05, 0x6b, 0x0d, 0x00, 0x43, 0xf6, 0x06, 0x6a, 0x0d, 0x40, - 0x05, 0x90, 0xe4, 0x06, 0x45, 0x07, 0xe6, 0x7c, 0xf7, 0x41, 0x45, 0xd6, - 0xd9, 0xf2, 0x1e, 0x01, 0x4e, 0x60, 0x77, 0xf8, 0x1e, 0x01, 0x07, 0xec, - 0x05, 0x1b, 0x4a, 0x90, 0xaf, 0xf7, 0x1e, 0x01, 0x0b, 0x55, 0x77, 0x01, - 0xff, 0xe5, 0xf5, 0x1e, 0x01, 0xe9, 0xf3, 0x1e, 0x01, 0xef, 0xf6, 0x1e, - 0x01, 0xf5, 0xf4, 0x1e, 0x41, 0xe1, 0xf1, 0x1e, 0x01, 0x42, 0x16, 0x00, - 0xe4, 0x1e, 0x01, 0x42, 0x37, 0x00, 0xe9, 0x1e, 0x01, 0x42, 0xf0, 0x10, - 0xe7, 0x1e, 0x01, 0x42, 0x24, 0x02, 0xe1, 0x1e, 0x01, 0x42, 0x72, 0x19, - 0xea, 0x1e, 0x01, 0x42, 0x1b, 0x02, 0xe0, 0x1e, 0x01, 0x42, 0x74, 0x00, - 0xee, 0x1e, 0x01, 0x42, 0x6c, 0x00, 0xe5, 0x1e, 0x01, 0xae, 0x24, 0x42, - 0xbb, 0x09, 0xe3, 0x1e, 0x01, 0x42, 0x71, 0x00, 0xed, 0x1e, 0x01, 0x42, - 0x40, 0x06, 0xf0, 0x1e, 0x01, 0x42, 0x12, 0x00, 0xe6, 0x1e, 0x01, 0x42, - 0xf5, 0x0a, 0xef, 0x1e, 0x01, 0x42, 0xbe, 0x22, 0xec, 0x1e, 0x41, 0xe1, - 0xe8, 0x1e, 0x01, 0x42, 0x24, 0x02, 0xe2, 0x1e, 0x01, 0x42, 0xbe, 0x22, - 0xeb, 0x1e, 0x41, 0x06, 0xbe, 0xd9, 0xe7, 0x02, 0x0a, 0x5c, 0xac, 0x01, - 0xff, 0x46, 0x24, 0xda, 0x28, 0xf0, 0x01, 0x02, 0x16, 0x00, 0xcb, 0x02, - 0x4d, 0x7b, 0x81, 0x25, 0xf0, 0x01, 0xa5, 0xa2, 0x02, 0xa6, 0xec, 0x01, - 0x4c, 0x64, 0x8f, 0x05, 0xf0, 0x01, 0x45, 0x2f, 0xa5, 0x2a, 0xf0, 0x01, - 0xae, 0xbe, 0x01, 0xaf, 0x9c, 0x01, 0x44, 0x3d, 0xf2, 0x22, 0xf0, 0x01, - 0x4a, 0x30, 0xb0, 0x04, 0xf0, 0x01, 0xb3, 0x4a, 0xb4, 0x15, 0xb7, 0x01, - 0xff, 0x48, 0xf9, 0xc5, 0x02, 0xf0, 0x01, 0x4b, 0x15, 0x9d, 0x06, 0xf0, - 0x01, 0x45, 0xa9, 0x0a, 0x29, 0xf0, 0x41, 0x08, 0xe9, 0xc6, 0x1a, 0x06, - 0x6e, 0xe1, 0x01, 0xff, 0x47, 0x76, 0xcf, 0x11, 0xf0, 0x01, 0xa3, 0x01, - 0xff, 0x49, 0x99, 0xb9, 0x08, 0xf0, 0x01, 0x46, 0x9f, 0x43, 0x1a, 0xf0, - 0x41, 0x47, 0x76, 0xcf, 0x12, 0xf0, 0x01, 0xa3, 0x01, 0xff, 0x49, 0x99, - 0xb9, 0x09, 0xf0, 0x01, 0x46, 0x9f, 0x43, 0x1b, 0xf0, 0x41, 0x08, 0x21, - 0xc6, 0x2b, 0x06, 0x60, 0xdd, 0x12, 0x49, 0xc8, 0xbd, 0x01, 0xf0, 0x01, - 0x45, 0xaa, 0x11, 0x26, 0xf0, 0x01, 0x45, 0xed, 0xeb, 0x27, 0xf0, 0x41, - 0x47, 0x76, 0xcf, 0x15, 0xf0, 0x01, 0xa3, 0x01, 0xff, 0x49, 0x99, 0xb9, - 0x0c, 0xf0, 0x01, 0x46, 0x9f, 0x43, 0x1e, 0xf0, 0x41, 0x47, 0x76, 0xcf, - 0x16, 0xf0, 0x01, 0xa3, 0x01, 0xff, 0x49, 0x99, 0xb9, 0x0d, 0xf0, 0x01, - 0x46, 0x9f, 0x43, 0x1f, 0xf0, 0x41, 0x06, 0xdb, 0xc8, 0x06, 0x45, 0x58, - 0xea, 0x23, 0xf0, 0x41, 0x47, 0x76, 0xcf, 0x10, 0xf0, 0x01, 0xa3, 0x01, - 0xff, 0x49, 0x99, 0xb9, 0x07, 0xf0, 0x01, 0x46, 0x9f, 0x43, 0x19, 0xf0, - 0x41, 0x07, 0xda, 0xc8, 0x06, 0x49, 0x9b, 0xbd, 0x03, 0xf0, 0x41, 0x47, - 0x76, 0xcf, 0x18, 0xf0, 0x01, 0xa3, 0x01, 0xff, 0x49, 0x99, 0xb9, 0x0f, - 0xf0, 0x01, 0x46, 0x9f, 0x43, 0x21, 0xf0, 0x41, 0x07, 0x39, 0xd2, 0x1a, - 0x07, 0x4d, 0xd4, 0x01, 0xff, 0x47, 0x76, 0xcf, 0x13, 0xf0, 0x01, 0xa3, - 0x01, 0xff, 0x49, 0x99, 0xb9, 0x0a, 0xf0, 0x01, 0x46, 0x9f, 0x43, 0x1c, - 0xf0, 0x41, 0x47, 0x76, 0xcf, 0x14, 0xf0, 0x01, 0xa3, 0x01, 0xff, 0x49, - 0x99, 0xb9, 0x0b, 0xf0, 0x01, 0x46, 0x9f, 0x43, 0x1d, 0xf0, 0x41, 0x48, - 0xc1, 0xc3, 0x00, 0xf0, 0x01, 0x08, 0x5f, 0xb8, 0x01, 0xff, 0x47, 0x76, - 0xcf, 0x17, 0xf0, 0x01, 0xa3, 0x01, 0xff, 0x49, 0x99, 0xb9, 0x0e, 0xf0, - 0x01, 0x46, 0x9f, 0x43, 0x20, 0xf0, 0x41, 0x42, 0x36, 0x01, 0x2b, 0xf0, - 0x01, 0x44, 0xba, 0x98, 0x24, 0xf0, 0x41, 0x51, 0xe3, 0x57, 0x74, 0x11, - 0x01, 0xac, 0x0f, 0xb3, 0x01, 0xff, 0x4b, 0x14, 0x27, 0x75, 0x11, 0x01, - 0x49, 0x44, 0xba, 0x73, 0x11, 0x41, 0x06, 0xed, 0x05, 0x06, 0x4c, 0xf4, - 0x8f, 0x76, 0x11, 0x41, 0xe1, 0x50, 0x11, 0x01, 0xa2, 0xbc, 0x01, 0xa3, - 0xaf, 0x01, 0xa4, 0x96, 0x01, 0xe5, 0x53, 0x11, 0x01, 0xa7, 0x85, 0x01, - 0x42, 0x22, 0x00, 0x71, 0x11, 0x01, 0xe9, 0x51, 0x11, 0x01, 0xaa, 0x6f, - 0xab, 0x63, 0x42, 0x74, 0x00, 0x6e, 0x11, 0x01, 0x42, 0x6c, 0x00, 0x6c, - 0x11, 0x01, 0xae, 0x45, 0xef, 0x54, 0x11, 0x01, 0xb0, 0x35, 0xb2, 0x29, - 0x42, 0x40, 0x06, 0x70, 0x11, 0x01, 0xb4, 0x0a, 0xf5, 0x52, 0x11, 0x01, - 0x42, 0xf5, 0x0a, 0x6f, 0x11, 0x41, 0xe1, 0x63, 0x11, 0x01, 0x42, 0x22, - 0x00, 0x64, 0x11, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x5e, 0x11, 0x01, 0x42, - 0x22, 0x00, 0x5f, 0x11, 0x41, 0xe1, 0x6d, 0x11, 0x01, 0x42, 0x71, 0x00, - 0x72, 0x11, 0x41, 0xe1, 0x68, 0x11, 0x01, 0x42, 0x22, 0x00, 0x69, 0x11, - 0x41, 0xe1, 0x67, 0x11, 0x01, 0x42, 0x2a, 0x05, 0x62, 0x11, 0x01, 0x42, - 0xbe, 0x22, 0x5d, 0x11, 0x41, 0xe1, 0x55, 0x11, 0x01, 0x42, 0x22, 0x00, - 0x56, 0x11, 0x41, 0xe1, 0x5b, 0x11, 0x01, 0x42, 0x22, 0x00, 0x5c, 0x11, - 0x41, 0xe1, 0x57, 0x11, 0x01, 0x42, 0x22, 0x00, 0x58, 0x11, 0x41, 0xe1, - 0x65, 0x11, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x66, 0x11, 0x41, 0xe1, - 0x60, 0x11, 0x01, 0x42, 0x22, 0x00, 0x61, 0x11, 0x41, 0xe1, 0x59, 0x11, - 0x01, 0x42, 0x22, 0x00, 0x5a, 0x11, 0x41, 0xe1, 0x6a, 0x11, 0x01, 0x42, - 0x22, 0x00, 0x6b, 0x11, 0x41, 0xe5, 0xd9, 0xf9, 0x01, 0x47, 0xec, 0xd1, - 0x84, 0xfa, 0x01, 0x43, 0xc9, 0x2c, 0xf2, 0xf9, 0x41, 0x4d, 0x4c, 0x7f, - 0x14, 0x21, 0x00, 0xa1, 0x94, 0x41, 0xa5, 0xba, 0x2b, 0xe6, 0x0a, 0x00, - 0x00, 0xa9, 0xf9, 0x0c, 0x44, 0xb0, 0x00, 0x99, 0xf9, 0x01, 0xaf, 0xb0, - 0x02, 0xb2, 0x9d, 0x02, 0xb5, 0x85, 0x02, 0xb9, 0x01, 0xff, 0x0c, 0x60, - 0x8d, 0x82, 0x01, 0x05, 0xce, 0x60, 0x06, 0x48, 0x49, 0x29, 0x25, 0xf9, - 0x41, 0x07, 0xec, 0x05, 0x06, 0x4f, 0xf3, 0x73, 0x3f, 0x09, 0x41, 0xe1, - 0x20, 0x09, 0x81, 0x65, 0xe2, 0x21, 0x09, 0x01, 0xe3, 0x39, 0x09, 0x01, - 0xe4, 0x23, 0x09, 0x01, 0xe5, 0x24, 0x09, 0x81, 0x50, 0xe6, 0x31, 0x09, - 0x01, 0xe7, 0x22, 0x09, 0x01, 0xe9, 0x26, 0x09, 0x01, 0xeb, 0x28, 0x09, - 0x01, 0xec, 0x29, 0x09, 0x81, 0x37, 0xed, 0x2a, 0x09, 0x01, 0xee, 0x2b, - 0x09, 0x81, 0x2a, 0xef, 0x2c, 0x09, 0x01, 0xf1, 0x32, 0x09, 0x01, 0xf2, - 0x2d, 0x09, 0x01, 0xf3, 0x33, 0x09, 0x81, 0x15, 0xf4, 0x2f, 0x09, 0x81, - 0x0c, 0xf5, 0x30, 0x09, 0x01, 0xf6, 0x25, 0x09, 0x01, 0xf9, 0x27, 0x09, - 0x41, 0xf4, 0x34, 0x09, 0x41, 0xf3, 0x2e, 0x09, 0x41, 0xee, 0x38, 0x09, - 0x41, 0xf9, 0x37, 0x09, 0x41, 0xee, 0x36, 0x09, 0x41, 0xee, 0x35, 0x09, - 0x41, 0xe1, 0x80, 0x02, 0x81, 0x72, 0xe2, 0x82, 0x02, 0x81, 0x69, 0xe4, - 0x85, 0x02, 0x01, 0xe5, 0x81, 0x02, 0x81, 0x5c, 0xe7, 0x84, 0x02, 0x01, - 0xe8, 0x9b, 0x02, 0x01, 0xe9, 0x86, 0x02, 0x01, 0xea, 0x8a, 0x02, 0x01, - 0xeb, 0x8b, 0x02, 0x81, 0x43, 0xec, 0x8d, 0x02, 0x01, 0xed, 0x8e, 0x02, - 0x81, 0x36, 0xee, 0x8f, 0x02, 0x81, 0x2d, 0xf0, 0x93, 0x02, 0x01, 0xf1, - 0x8c, 0x02, 0x01, 0xf2, 0x95, 0x02, 0x01, 0xf3, 0x96, 0x02, 0x01, 0xf4, - 0x97, 0x02, 0x81, 0x10, 0xf5, 0x92, 0x02, 0x01, 0xf7, 0x87, 0x02, 0x01, - 0xf8, 0x9c, 0x02, 0x01, 0xfa, 0x88, 0x02, 0x41, 0xe8, 0x89, 0x02, 0x01, - 0xf4, 0x98, 0x02, 0x41, 0xee, 0x91, 0x02, 0x41, 0xed, 0x90, 0x02, 0x41, - 0xeb, 0x94, 0x02, 0x41, 0xee, 0x9a, 0x02, 0x41, 0xe8, 0x83, 0x02, 0x41, - 0xee, 0x99, 0x02, 0x41, 0x45, 0x0f, 0xe1, 0xf3, 0xf9, 0x01, 0xae, 0x01, - 0xff, 0x4a, 0xfc, 0xa7, 0x76, 0xf7, 0x01, 0x42, 0xbc, 0x11, 0xc1, 0xfa, - 0x41, 0xe5, 0x2a, 0x20, 0x00, 0xe9, 0x66, 0x20, 0x00, 0xed, 0x0e, 0x20, - 0x00, 0xef, 0x2d, 0x20, 0x40, 0x45, 0xfe, 0xe4, 0x9e, 0xf9, 0x01, 0x42, - 0x36, 0x01, 0x12, 0xf5, 0x81, 0x9b, 0x0a, 0x03, 0x2f, 0x22, 0xef, 0x08, - 0x46, 0xea, 0xdd, 0x6d, 0xf3, 0x01, 0x03, 0xa2, 0x01, 0xac, 0x07, 0xb4, - 0x97, 0x07, 0x50, 0xed, 0x67, 0x2d, 0xf6, 0x01, 0x03, 0x5f, 0x00, 0x80, - 0x07, 0xb7, 0x0d, 0x45, 0x4b, 0x0a, 0xca, 0x25, 0xc0, 0x00, 0x5b, 0x0c, - 0x1a, 0xe0, 0x27, 0x40, 0x80, 0xc1, 0x06, 0x03, 0x16, 0x01, 0x01, 0xff, - 0x4e, 0x48, 0x76, 0x03, 0x27, 0x00, 0x07, 0x73, 0x02, 0x8a, 0x06, 0x52, - 0xb0, 0x51, 0x85, 0x25, 0x00, 0xa8, 0xc1, 0x05, 0x05, 0xc3, 0x00, 0xa0, - 0x03, 0x07, 0x7d, 0x02, 0xea, 0x02, 0x04, 0x0e, 0x0b, 0xd9, 0x02, 0x06, - 0xc8, 0x00, 0x30, 0x53, 0x02, 0x4d, 0x87, 0x25, 0x00, 0xb4, 0x01, 0xff, - 0x05, 0x25, 0x01, 0x06, 0x5b, 0x51, 0x1d, 0x6f, 0xfb, 0x41, 0x4d, 0x08, - 0x4d, 0x83, 0x25, 0x00, 0x09, 0x2a, 0x01, 0x01, 0xff, 0x45, 0x33, 0x01, - 0x86, 0x25, 0x00, 0x56, 0x52, 0x35, 0xa5, 0xce, 0x01, 0x57, 0xf7, 0x30, - 0xae, 0xce, 0x41, 0x0f, 0x74, 0x6b, 0xbe, 0x01, 0x4f, 0xdd, 0x6b, 0xd3, - 0x27, 0x00, 0x5a, 0xe6, 0x1f, 0x4f, 0x27, 0x00, 0x53, 0x17, 0x26, 0x9f, - 0xce, 0x01, 0x46, 0x34, 0xdf, 0x0e, 0x27, 0x00, 0x03, 0x7c, 0x00, 0x38, - 0x4d, 0x1b, 0x30, 0x07, 0xcc, 0x01, 0xb3, 0x19, 0xb4, 0x01, 0xff, 0x05, - 0x1a, 0x01, 0x06, 0x4d, 0x9d, 0x7d, 0x3f, 0xcc, 0x41, 0x42, 0x68, 0x00, - 0xff, 0x25, 0x00, 0x51, 0xa9, 0x5e, 0x9e, 0xfb, 0x41, 0x5b, 0x35, 0x1b, - 0x3e, 0x29, 0x00, 0x0e, 0xa5, 0x02, 0x01, 0xff, 0x46, 0x12, 0x03, 0x3e, - 0xf5, 0x01, 0x46, 0xd6, 0x05, 0x51, 0x27, 0x40, 0x06, 0x7c, 0x0d, 0x06, - 0x4b, 0x97, 0x4c, 0x3a, 0xcc, 0x41, 0xa3, 0x2e, 0xa6, 0x20, 0x4d, 0x00, - 0x86, 0xb9, 0xcc, 0x01, 0x4c, 0xac, 0x92, 0xad, 0xcc, 0x01, 0xb3, 0x06, - 0x4a, 0xca, 0xb1, 0xb5, 0xcc, 0x41, 0x4b, 0x7d, 0x95, 0xab, 0xcc, 0x01, - 0x4e, 0x5e, 0x73, 0xd5, 0xcc, 0x41, 0x53, 0x4e, 0x29, 0xaf, 0xcc, 0x01, - 0x4c, 0x29, 0x83, 0xb1, 0xcc, 0x41, 0x05, 0x60, 0x88, 0x06, 0x4b, 0xd0, - 0x9d, 0xde, 0x25, 0x40, 0x46, 0x4e, 0xda, 0xc9, 0xcc, 0x01, 0xab, 0x12, - 0x44, 0x21, 0xf2, 0xd1, 0xcc, 0x01, 0x45, 0x73, 0xbe, 0xc1, 0xcc, 0x01, - 0x44, 0x81, 0xf2, 0xc5, 0xcc, 0x41, 0x43, 0xa1, 0x01, 0xbd, 0xcc, 0x01, - 0x45, 0x4e, 0x09, 0xcd, 0xcc, 0x41, 0x06, 0x13, 0x01, 0x11, 0x1b, 0x0e, - 0x1e, 0x01, 0xff, 0x46, 0x73, 0x02, 0x41, 0xfb, 0x01, 0x45, 0xc8, 0x00, - 0x42, 0xfb, 0x41, 0x0a, 0x73, 0x02, 0x32, 0x08, 0x84, 0x02, 0x17, 0x15, - 0x14, 0x1e, 0x01, 0xff, 0x46, 0x73, 0x02, 0x43, 0xfb, 0x01, 0x4c, 0x58, - 0x0f, 0x46, 0xfb, 0x01, 0x45, 0xc8, 0x00, 0x44, 0xfb, 0x41, 0x52, 0x96, - 0x53, 0x48, 0xfb, 0x01, 0x06, 0x6d, 0x02, 0x01, 0xff, 0x46, 0x73, 0x02, - 0x45, 0xfb, 0x01, 0x4c, 0x58, 0x0f, 0x4a, 0xfb, 0x41, 0x52, 0x96, 0x53, - 0x47, 0xfb, 0x01, 0x06, 0x6d, 0x02, 0x01, 0xff, 0x4c, 0x58, 0x0f, 0x49, - 0xfb, 0x01, 0x45, 0xc8, 0x00, 0x4b, 0xfb, 0x41, 0x4c, 0x12, 0x0b, 0x81, - 0x25, 0x00, 0x4d, 0x5f, 0x1d, 0x82, 0x25, 0x40, 0x07, 0x73, 0x02, 0x21, - 0x05, 0xc3, 0x00, 0x11, 0x06, 0xc8, 0x00, 0x01, 0xff, 0x53, 0x17, 0x26, - 0x9b, 0xce, 0x01, 0x4e, 0x9c, 0x7d, 0x3b, 0xcc, 0x41, 0x53, 0x17, 0x26, - 0x98, 0xce, 0x01, 0x4e, 0x9c, 0x7d, 0x38, 0xcc, 0x41, 0x58, 0xc1, 0x29, - 0x99, 0xce, 0x01, 0x59, 0x11, 0x26, 0x9a, 0xce, 0x41, 0xa2, 0xae, 0x01, - 0x46, 0xd8, 0xda, 0x8d, 0xf5, 0x01, 0x4c, 0x28, 0x8f, 0x8b, 0xf5, 0x01, - 0x53, 0x17, 0x26, 0x9c, 0xce, 0x01, 0xb0, 0x8d, 0x01, 0x03, 0x7c, 0x00, - 0x1f, 0x60, 0x54, 0x10, 0x3f, 0x29, 0x00, 0xb4, 0x01, 0xff, 0x05, 0x1a, - 0x01, 0x06, 0x4d, 0x9d, 0x7d, 0x3c, 0xcc, 0x41, 0x42, 0x68, 0x00, 0xfa, - 0x25, 0x00, 0x51, 0xa9, 0x5e, 0x9f, 0xfb, 0x41, 0x06, 0x7c, 0x0d, 0x06, - 0x4b, 0x97, 0x4c, 0x39, 0xcc, 0x41, 0xa3, 0x2e, 0xa6, 0x20, 0x4d, 0x00, - 0x86, 0xb8, 0xcc, 0x01, 0x4c, 0xac, 0x92, 0xac, 0xcc, 0x01, 0xb3, 0x06, - 0x4a, 0xca, 0xb1, 0xb4, 0xcc, 0x41, 0x4b, 0x7d, 0x95, 0xaa, 0xcc, 0x01, - 0x4e, 0x5e, 0x73, 0xd4, 0xcc, 0x41, 0x53, 0x4e, 0x29, 0xae, 0xcc, 0x01, - 0x4c, 0x29, 0x83, 0xb0, 0xcc, 0x41, 0x05, 0x60, 0x88, 0x06, 0x4b, 0xd0, - 0x9d, 0xdf, 0x25, 0x40, 0x46, 0x4e, 0xda, 0xc8, 0xcc, 0x01, 0xab, 0x12, - 0x44, 0x21, 0xf2, 0xd0, 0xcc, 0x01, 0x45, 0x73, 0xbe, 0xc0, 0xcc, 0x01, - 0x44, 0x81, 0xf2, 0xc4, 0xcc, 0x41, 0x43, 0xa1, 0x01, 0xbc, 0xcc, 0x01, - 0x45, 0x4e, 0x09, 0xcc, 0xcc, 0x41, 0x49, 0xe8, 0xb5, 0x8c, 0xf5, 0x01, - 0x45, 0x35, 0xdf, 0x89, 0xf5, 0x41, 0x4c, 0x28, 0x8c, 0x8a, 0xf5, 0x01, - 0x0e, 0x75, 0x6b, 0x01, 0xff, 0x1b, 0x94, 0x1c, 0x50, 0x06, 0x6d, 0x02, - 0x01, 0xff, 0x0a, 0x73, 0x02, 0x31, 0x08, 0x84, 0x02, 0x17, 0x15, 0x7d, - 0x02, 0x01, 0xff, 0x46, 0x73, 0x02, 0x3e, 0xfb, 0x01, 0x4c, 0x58, 0x0f, - 0x51, 0xfb, 0x01, 0x45, 0xc8, 0x00, 0x3f, 0xfb, 0x41, 0x06, 0x13, 0x01, - 0x06, 0x52, 0x42, 0x56, 0x4d, 0xfb, 0x41, 0x46, 0x73, 0x02, 0x40, 0xfb, - 0x01, 0x4c, 0x58, 0x0f, 0x4f, 0xfb, 0x41, 0x06, 0x13, 0x01, 0x06, 0x52, - 0x42, 0x56, 0x4c, 0xfb, 0x41, 0x4c, 0x58, 0x0f, 0x4e, 0xfb, 0x01, 0x45, - 0xc8, 0x00, 0x50, 0xfb, 0x41, 0x46, 0x73, 0x02, 0x3c, 0xfb, 0x01, 0x45, - 0xc8, 0x00, 0x3d, 0xfb, 0x41, 0x04, 0x23, 0x00, 0x06, 0x57, 0x11, 0x30, - 0x05, 0xcc, 0x41, 0x5b, 0x42, 0x1a, 0x01, 0xce, 0x01, 0x45, 0x33, 0x01, - 0x84, 0x25, 0x00, 0x46, 0x12, 0x03, 0xe1, 0x25, 0x00, 0x52, 0x2e, 0x52, - 0x04, 0xce, 0x01, 0x54, 0x77, 0x43, 0xdb, 0x25, 0x00, 0x56, 0x52, 0x35, - 0xa4, 0xce, 0x01, 0x4c, 0x44, 0x04, 0x8f, 0xfb, 0x01, 0x57, 0xf7, 0x30, - 0xaf, 0xce, 0x01, 0x63, 0xcd, 0x0b, 0x13, 0xce, 0x41, 0x05, 0xc3, 0x00, - 0x17, 0x51, 0x5b, 0x1d, 0xe5, 0xfb, 0x01, 0x06, 0xc8, 0x00, 0x01, 0xff, - 0x53, 0x17, 0x26, 0x9e, 0xce, 0x01, 0x4e, 0x9c, 0x7d, 0x3e, 0xcc, 0x41, - 0x53, 0x17, 0x26, 0x9d, 0xce, 0x01, 0x4e, 0x9c, 0x7d, 0x3d, 0xcc, 0x41, - 0x48, 0x3c, 0x0d, 0x4e, 0x20, 0x00, 0xa2, 0x19, 0x5b, 0xff, 0x1a, 0x1f, - 0x30, 0x00, 0x46, 0xf4, 0x4f, 0x47, 0x2e, 0x80, 0x06, 0x44, 0xed, 0x07, - 0x5f, 0x00, 0x40, 0x49, 0x90, 0x3b, 0x48, 0x2e, 0x40, 0x46, 0x18, 0xda, - 0xab, 0xfa, 0x01, 0x50, 0xd2, 0x58, 0x05, 0xf5, 0x41, 0x45, 0x3d, 0xe7, - 0xe9, 0xf3, 0x01, 0x46, 0xec, 0x05, 0x8c, 0xf4, 0x41, 0x4b, 0xa0, 0x97, - 0x74, 0xf7, 0x01, 0x4a, 0x20, 0xac, 0xf4, 0xf9, 0x01, 0x42, 0xef, 0x02, - 0xb7, 0xfa, 0x41, 0xa4, 0xa3, 0x01, 0x04, 0xc3, 0x00, 0x55, 0x05, 0xc8, - 0x00, 0x01, 0xff, 0x45, 0x0f, 0x39, 0xdd, 0x27, 0x00, 0x06, 0xa9, 0x01, - 0x01, 0xff, 0x45, 0xce, 0x00, 0xf6, 0x27, 0x80, 0x23, 0x4c, 0x44, 0x8e, - 0xf9, 0x27, 0x80, 0x16, 0x08, 0xc9, 0x02, 0x06, 0x4e, 0x92, 0x7c, 0xff, - 0x27, 0x40, 0x5d, 0xf4, 0x14, 0xd2, 0xf8, 0x01, 0x5b, 0x00, 0x1d, 0xd1, - 0xf8, 0x41, 0x49, 0x77, 0xb4, 0xfe, 0x27, 0x40, 0x80, 0x01, 0xff, 0x48, - 0x78, 0xb4, 0xfc, 0x27, 0x00, 0x59, 0xad, 0x25, 0xd0, 0xf8, 0x01, 0x49, - 0xe4, 0xbf, 0xd6, 0xf8, 0x01, 0x51, 0x97, 0x5f, 0xd7, 0xf8, 0x41, 0x80, - 0x2b, 0x06, 0xa9, 0x01, 0x01, 0xff, 0x45, 0xce, 0x00, 0xf5, 0x27, 0x80, - 0x19, 0x4c, 0x44, 0x8e, 0xf8, 0x27, 0x80, 0x0c, 0x66, 0x25, 0x07, 0xd4, - 0xf8, 0x01, 0x4e, 0x92, 0x7c, 0x33, 0x2b, 0x40, 0x49, 0x77, 0xb4, 0xfd, - 0x27, 0x40, 0x49, 0x77, 0xb4, 0xfb, 0x27, 0x40, 0x06, 0xc8, 0x00, 0x06, - 0x44, 0x10, 0x39, 0xde, 0x27, 0x40, 0x45, 0xce, 0x00, 0xf7, 0x27, 0x80, - 0x06, 0x4c, 0x44, 0x8e, 0xfa, 0x27, 0x40, 0x54, 0xf3, 0x3f, 0xd8, 0xf8, - 0x41, 0x67, 0xa6, 0x05, 0xe6, 0x2a, 0x00, 0x47, 0xde, 0x32, 0xcc, 0x27, - 0x00, 0x43, 0xa4, 0x1d, 0x98, 0xfa, 0x41, 0x06, 0x38, 0xd8, 0x7a, 0x03, - 0x13, 0x00, 0x01, 0xff, 0x43, 0x1a, 0x00, 0x27, 0x22, 0x80, 0x3c, 0x42, - 0x0c, 0x00, 0x28, 0x22, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x57, 0x3f, 0x30, - 0x59, 0x2a, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x02, 0x3b, 0x01, 0x0c, - 0x4f, 0x17, 0x6e, 0x5d, 0x2a, 0x00, 0x4b, 0xbf, 0x9f, 0x5b, 0x2a, 0x40, - 0x47, 0x58, 0x1e, 0x52, 0x2a, 0x00, 0x05, 0x3d, 0x01, 0x01, 0xff, 0x47, - 0xfb, 0x7f, 0x62, 0x2a, 0x00, 0x48, 0xea, 0x59, 0x63, 0x2a, 0x40, 0x06, - 0x50, 0x00, 0x01, 0xff, 0x02, 0x3b, 0x01, 0x12, 0x4f, 0x17, 0x6e, 0x5c, - 0x2a, 0x00, 0x4b, 0xbf, 0x9f, 0x5a, 0x2a, 0x00, 0x48, 0xea, 0x59, 0x5f, - 0x2a, 0x40, 0x47, 0x58, 0x1e, 0x51, 0x2a, 0x00, 0x05, 0x3d, 0x01, 0x01, - 0xff, 0x47, 0xfb, 0x7f, 0x5e, 0x2a, 0x00, 0x48, 0xea, 0x59, 0x60, 0x2a, - 0x40, 0x43, 0x1a, 0x00, 0x16, 0xcc, 0x01, 0x46, 0x66, 0xda, 0x19, 0xcc, - 0x81, 0x16, 0x09, 0x60, 0x23, 0x06, 0x42, 0x0c, 0x00, 0x15, 0xcc, 0x41, - 0x46, 0x1e, 0xdd, 0x17, 0xcc, 0x01, 0x46, 0x25, 0x51, 0x18, 0xcc, 0x41, - 0x54, 0x1b, 0x40, 0x1a, 0xcc, 0x41, 0x4d, 0xdb, 0x7f, 0x0f, 0xf5, 0x01, - 0x0a, 0xf8, 0xab, 0x01, 0xff, 0x43, 0x0e, 0x0b, 0x0e, 0x00, 0x00, 0x44, - 0x5f, 0x1e, 0x0f, 0x00, 0x40, 0x43, 0x63, 0x09, 0x4e, 0x26, 0x00, 0xa7, - 0x93, 0x1d, 0xad, 0xd3, 0x19, 0xae, 0xdd, 0x02, 0x47, 0x00, 0xd4, 0x81, - 0xf9, 0x01, 0x42, 0xcf, 0x15, 0xe2, 0xf5, 0x81, 0xc9, 0x02, 0x47, 0x9a, - 0x84, 0xa4, 0x20, 0x00, 0x03, 0x55, 0x22, 0x0c, 0x51, 0x64, 0x5f, 0xb6, - 0x20, 0x00, 0x44, 0x1b, 0x93, 0x8e, 0xf9, 0x41, 0x07, 0xec, 0x05, 0x11, - 0x0c, 0x6d, 0x16, 0x01, 0xff, 0x45, 0x13, 0x05, 0xfe, 0xa4, 0x00, 0x49, - 0x81, 0x16, 0xff, 0xa4, 0x40, 0xe1, 0xee, 0xa4, 0x80, 0x94, 0x02, 0x42, - 0x16, 0x00, 0xd0, 0xa4, 0x00, 0xa3, 0x81, 0x02, 0xa4, 0xf4, 0x01, 0xe5, - 0xf0, 0xa4, 0x80, 0xea, 0x01, 0x42, 0x0c, 0x08, 0xe9, 0xa4, 0x00, 0xa7, - 0xd7, 0x01, 0xa8, 0xca, 0x01, 0xe9, 0xf2, 0xa4, 0x00, 0x42, 0x72, 0x19, - 0xd9, 0xa4, 0x00, 0xab, 0xb3, 0x01, 0x42, 0x74, 0x00, 0xe1, 0xa4, 0x00, - 0x42, 0x6c, 0x00, 0xdf, 0xa4, 0x00, 0xae, 0x9a, 0x01, 0xef, 0xf3, 0xa4, - 0x80, 0x90, 0x01, 0xb0, 0x83, 0x01, 0xb3, 0x77, 0xb4, 0x32, 0xf5, 0xf4, - 0xa4, 0x80, 0x25, 0x42, 0xa9, 0x01, 0xea, 0xa4, 0x00, 0x42, 0x08, 0x27, - 0xe7, 0xa4, 0x00, 0xb9, 0x0d, 0xba, 0x01, 0xff, 0xe1, 0xe4, 0xa4, 0x00, - 0x42, 0x22, 0x00, 0xe3, 0xa4, 0x40, 0xe1, 0xec, 0xa4, 0x00, 0x42, 0x22, - 0x00, 0xb0, 0x1f, 0x41, 0xe5, 0xf5, 0xa4, 0x00, 0xe8, 0xf6, 0xa4, 0x40, - 0xe1, 0xd4, 0xa4, 0x00, 0x42, 0x22, 0x00, 0xd5, 0xa4, 0x00, 0x04, 0x0e, - 0x0b, 0x0d, 0xb3, 0x01, 0xff, 0xe1, 0xdd, 0xa4, 0x00, 0x42, 0x22, 0x00, - 0xde, 0xa4, 0x40, 0x04, 0x70, 0x62, 0x06, 0x45, 0x04, 0xe9, 0xf9, 0xa4, - 0x40, 0x42, 0x5d, 0x00, 0xfb, 0xa4, 0x00, 0x43, 0x34, 0xf4, 0xfa, 0xa4, - 0x00, 0x43, 0x82, 0xf4, 0xfd, 0xa4, 0x00, 0x42, 0x2a, 0x05, 0xfc, 0xa4, - 0x00, 0x42, 0x35, 0x00, 0xf8, 0xa4, 0x40, 0xe1, 0xe2, 0xa4, 0x00, 0x42, - 0x22, 0x00, 0xeb, 0xa4, 0x40, 0xe1, 0xd1, 0xa4, 0x00, 0x42, 0x22, 0x00, - 0xd2, 0xa4, 0x40, 0xe5, 0xf7, 0xa4, 0x40, 0xe1, 0xe0, 0xa4, 0x00, 0x42, - 0x24, 0x02, 0xe5, 0xa4, 0x40, 0xe1, 0xd7, 0xa4, 0x00, 0x42, 0x22, 0x00, - 0xd8, 0xa4, 0x40, 0xe1, 0xe6, 0xa4, 0x00, 0x42, 0x22, 0x00, 0xe8, 0xa4, - 0x40, 0xe1, 0xd6, 0xa4, 0x00, 0x42, 0x22, 0x00, 0xed, 0xa4, 0x40, 0xf5, - 0xf1, 0xa4, 0x40, 0xe1, 0xd3, 0xa4, 0x00, 0x42, 0x59, 0x00, 0xdc, 0xa4, - 0x40, 0xe1, 0xda, 0xa4, 0x00, 0x42, 0x22, 0x00, 0xdb, 0xa4, 0x40, 0xe5, - 0xef, 0xa4, 0x40, 0x44, 0xfd, 0x07, 0x84, 0xf4, 0x41, 0xa5, 0x0f, 0xab, - 0x01, 0xff, 0x47, 0x15, 0x08, 0x17, 0xf5, 0x01, 0x4d, 0x72, 0x82, 0x87, - 0xf5, 0x41, 0x80, 0xab, 0x16, 0x03, 0x17, 0x00, 0x01, 0xff, 0x08, 0x31, - 0xc3, 0xd5, 0x09, 0x02, 0x26, 0x02, 0x01, 0xff, 0x09, 0x20, 0xba, 0xdd, - 0x04, 0x0a, 0x1e, 0xae, 0xae, 0x04, 0x02, 0x16, 0x08, 0x01, 0xff, 0x09, - 0xb5, 0xbb, 0x4e, 0x07, 0x51, 0xd3, 0x01, 0xff, 0x91, 0x3f, 0x42, 0x74, - 0xed, 0x52, 0x00, 0x01, 0x42, 0x17, 0xf5, 0x53, 0x00, 0x01, 0x94, 0x29, - 0x42, 0x21, 0xc3, 0x56, 0x00, 0x01, 0x96, 0x19, 0x42, 0x2f, 0x40, 0x59, - 0x00, 0x01, 0x98, 0x01, 0xff, 0xd2, 0x5a, 0x00, 0x01, 0xd3, 0x5b, 0x00, - 0x01, 0xd6, 0x5c, 0x00, 0x01, 0xd9, 0x5d, 0x00, 0x41, 0xd3, 0x57, 0x00, - 0x01, 0xd4, 0x58, 0x00, 0x41, 0xd7, 0x54, 0x00, 0x01, 0xd9, 0x55, 0x00, - 0x41, 0xd8, 0x50, 0x00, 0x01, 0xd9, 0x51, 0x00, 0x41, 0x90, 0x9e, 0x03, - 0x91, 0xeb, 0x02, 0x92, 0xb2, 0x02, 0x93, 0xff, 0x01, 0x94, 0xcc, 0x01, - 0x95, 0x93, 0x01, 0x96, 0x61, 0x97, 0x29, 0x98, 0x0f, 0x99, 0x01, 0xff, - 0x45, 0x24, 0xe2, 0x44, 0x00, 0x01, 0x45, 0x65, 0xe2, 0x4d, 0x00, 0x41, - 0x44, 0x42, 0xe2, 0x14, 0x00, 0x01, 0x44, 0x41, 0xed, 0x13, 0x00, 0x01, - 0x44, 0xf9, 0xed, 0x42, 0x00, 0x01, 0x45, 0x96, 0xe3, 0x4c, 0x00, 0x41, - 0x44, 0x01, 0xed, 0x12, 0x00, 0x01, 0x45, 0x51, 0xe2, 0x43, 0x00, 0x01, - 0x44, 0x79, 0xed, 0x1f, 0x00, 0x01, 0x44, 0xb1, 0xed, 0x16, 0x00, 0x01, - 0x44, 0xed, 0xed, 0x3d, 0x00, 0x01, 0x44, 0x3d, 0xee, 0x38, 0x00, 0x01, - 0x45, 0x55, 0xe3, 0x48, 0x00, 0x01, 0x44, 0x40, 0xd9, 0x0f, 0x00, 0x01, - 0x44, 0xc5, 0xee, 0x24, 0x00, 0x41, 0x44, 0x0d, 0xed, 0x28, 0x00, 0x01, - 0x43, 0xae, 0x75, 0x03, 0x00, 0x01, 0x45, 0xb5, 0xe2, 0x47, 0x00, 0x01, - 0x44, 0x15, 0xee, 0x0e, 0x00, 0x01, 0x45, 0x64, 0xe3, 0x4b, 0x00, 0x01, - 0x44, 0x8d, 0xee, 0x11, 0x00, 0x01, 0x45, 0xc3, 0xe3, 0x4a, 0x00, 0x01, - 0x44, 0xf1, 0xee, 0x36, 0x00, 0x41, 0x44, 0x09, 0xed, 0x22, 0x00, 0x01, - 0x44, 0x2d, 0xed, 0x09, 0x00, 0x01, 0x44, 0x75, 0xed, 0x1c, 0x00, 0x01, - 0x44, 0xbd, 0xed, 0x2a, 0x00, 0x01, 0x44, 0xe5, 0xed, 0x37, 0x00, 0x01, - 0x44, 0x21, 0xee, 0x1d, 0x00, 0x01, 0x44, 0x89, 0xee, 0x0a, 0x00, 0x01, - 0x44, 0xc9, 0xee, 0x31, 0x00, 0x01, 0x44, 0xe9, 0xee, 0x32, 0x00, 0x41, - 0x44, 0x15, 0xed, 0x39, 0x00, 0x01, 0x44, 0x55, 0xed, 0x2f, 0x00, 0x01, - 0x44, 0x26, 0xce, 0x3a, 0x00, 0x01, 0x44, 0x91, 0xed, 0x41, 0x00, 0x01, - 0x44, 0xd1, 0xed, 0x10, 0x00, 0x01, 0x44, 0x01, 0xee, 0x06, 0x00, 0x01, - 0x44, 0x51, 0xee, 0x0b, 0x00, 0x01, 0x45, 0xbe, 0xe3, 0x45, 0x00, 0x41, - 0x44, 0x05, 0xed, 0x1b, 0x00, 0x01, 0x44, 0x51, 0xed, 0x2d, 0x00, 0x01, - 0x44, 0x7d, 0xed, 0x26, 0x00, 0x01, 0x45, 0xdd, 0xe2, 0x49, 0x00, 0x01, - 0x44, 0x55, 0xee, 0x0d, 0x00, 0x01, 0x44, 0x99, 0xee, 0x34, 0x00, 0x01, - 0x43, 0xad, 0xee, 0x01, 0x00, 0x01, 0x44, 0xd9, 0xee, 0x20, 0x00, 0x41, - 0x44, 0x1d, 0xed, 0x3f, 0x00, 0x01, 0x44, 0x49, 0xed, 0x25, 0x00, 0x01, - 0x44, 0xb5, 0xed, 0x18, 0x00, 0x01, 0x44, 0xd9, 0xed, 0x1a, 0x00, 0x01, - 0x44, 0xf1, 0xed, 0x40, 0x00, 0x01, 0x44, 0x6d, 0xee, 0x2c, 0x00, 0x01, - 0x44, 0x95, 0xee, 0x29, 0x00, 0x01, 0x43, 0xfb, 0xf3, 0x02, 0x00, 0x01, - 0x45, 0xf5, 0xe3, 0x46, 0x00, 0x41, 0x43, 0x98, 0xf3, 0x04, 0x00, 0x01, - 0x44, 0x45, 0xed, 0x21, 0x00, 0x01, 0x44, 0x85, 0xed, 0x30, 0x00, 0x01, - 0x44, 0xad, 0xed, 0x15, 0x00, 0x01, 0x44, 0xc9, 0xed, 0x08, 0x00, 0x01, - 0x44, 0x1d, 0xee, 0x17, 0x00, 0x01, 0x44, 0x69, 0xee, 0x23, 0x00, 0x01, - 0x44, 0xa1, 0xee, 0x3c, 0x00, 0x41, 0x44, 0x25, 0xed, 0x05, 0x00, 0x01, - 0x44, 0x81, 0xed, 0x2b, 0x00, 0x01, 0x44, 0xb9, 0xed, 0x1e, 0x00, 0x01, - 0x44, 0xdd, 0xed, 0x33, 0x00, 0x01, 0x44, 0x2d, 0xee, 0x35, 0x00, 0x01, - 0x44, 0x61, 0xee, 0x19, 0x00, 0x01, 0x44, 0x75, 0xb5, 0x07, 0x00, 0x01, - 0x43, 0xf8, 0xf3, 0x00, 0x00, 0x01, 0x44, 0xdd, 0xee, 0x2e, 0x00, 0x41, - 0x91, 0x06, 0x49, 0x73, 0xb5, 0xd2, 0x00, 0x41, 0x92, 0x14, 0x93, 0x06, - 0x48, 0x21, 0xc3, 0xa4, 0x00, 0x41, 0x47, 0x34, 0xce, 0x98, 0x00, 0x01, - 0x46, 0x16, 0xd9, 0x99, 0x00, 0x41, 0x46, 0x40, 0xd9, 0x93, 0x00, 0x01, - 0x48, 0x29, 0xc3, 0x94, 0x00, 0x41, 0xa2, 0x87, 0x01, 0x08, 0x61, 0xcc, - 0x01, 0xff, 0x43, 0xb3, 0xf3, 0xde, 0x00, 0x01, 0x92, 0x06, 0x43, 0xce, - 0xf3, 0xfa, 0x00, 0x41, 0x90, 0x4a, 0x91, 0x20, 0x92, 0x06, 0x42, 0xca, - 0xd2, 0xf9, 0x00, 0x41, 0xd1, 0xf3, 0x00, 0x01, 0xd2, 0xf4, 0x00, 0x01, - 0xd6, 0xf5, 0x00, 0x01, 0xd7, 0xf6, 0x00, 0x01, 0xd8, 0xf7, 0x00, 0x01, - 0xd9, 0xf8, 0x00, 0x41, 0xd0, 0xe9, 0x00, 0x01, 0xd1, 0xea, 0x00, 0x01, - 0xd2, 0xeb, 0x00, 0x01, 0xd3, 0xec, 0x00, 0x01, 0xd4, 0xed, 0x00, 0x01, - 0xd5, 0xee, 0x00, 0x01, 0xd6, 0xef, 0x00, 0x01, 0xd7, 0xf0, 0x00, 0x01, - 0xd8, 0xf1, 0x00, 0x01, 0xd9, 0xf2, 0x00, 0x41, 0xd0, 0xdf, 0x00, 0x01, - 0xd1, 0xe0, 0x00, 0x01, 0xd2, 0xe1, 0x00, 0x01, 0xd3, 0xe2, 0x00, 0x01, - 0xd4, 0xe3, 0x00, 0x01, 0xd5, 0xe4, 0x00, 0x01, 0xd6, 0xe5, 0x00, 0x01, - 0xd7, 0xe6, 0x00, 0x01, 0xd8, 0xe7, 0x00, 0x01, 0xd9, 0xe8, 0x00, 0x41, - 0x91, 0x84, 0x01, 0x92, 0x01, 0xff, 0x92, 0x73, 0x93, 0x53, 0x94, 0x29, - 0x95, 0x01, 0xff, 0xd1, 0xd5, 0x00, 0x01, 0xd2, 0xd6, 0x00, 0x01, 0xd3, - 0xd7, 0x00, 0x01, 0x46, 0xec, 0xd8, 0xd8, 0x00, 0x01, 0xd5, 0xd9, 0x00, - 0x01, 0xd6, 0xda, 0x00, 0x01, 0xd7, 0xdb, 0x00, 0x01, 0xd8, 0xdc, 0x00, - 0x01, 0xd9, 0xdd, 0x00, 0x41, 0x51, 0xc1, 0x57, 0xcc, 0x00, 0x01, 0x49, - 0x61, 0xb5, 0xcd, 0x00, 0x01, 0x4f, 0x57, 0x6a, 0xce, 0x00, 0x01, 0x47, - 0x5e, 0xce, 0xcf, 0x00, 0x01, 0xd5, 0xd0, 0x00, 0x01, 0xd6, 0xd1, 0x00, - 0x01, 0xd8, 0xd3, 0x00, 0x01, 0xd9, 0xd4, 0x00, 0x41, 0x47, 0x0a, 0xce, - 0xc6, 0x00, 0x01, 0x47, 0x18, 0xce, 0xc7, 0x00, 0x01, 0xd2, 0xc8, 0x00, - 0x01, 0x47, 0x57, 0xce, 0xc9, 0x00, 0x01, 0xd4, 0xca, 0x00, 0x01, 0xd6, - 0xcb, 0x00, 0x41, 0x4b, 0x9d, 0x98, 0xc4, 0x00, 0x01, 0x49, 0x85, 0xb5, - 0xc5, 0x00, 0x41, 0x90, 0xfb, 0x01, 0x92, 0xda, 0x01, 0x93, 0xc7, 0x01, - 0x94, 0xaa, 0x01, 0x95, 0x83, 0x01, 0x96, 0x55, 0x97, 0x2b, 0x98, 0x0d, - 0x99, 0x01, 0xff, 0xd0, 0xc2, 0x00, 0x01, 0x48, 0x11, 0xc3, 0xc3, 0x00, - 0x41, 0xd0, 0xbb, 0x00, 0x01, 0xd1, 0xbc, 0x00, 0x01, 0xd2, 0xbd, 0x00, - 0x01, 0xd3, 0xbe, 0x00, 0x01, 0xd4, 0xbf, 0x00, 0x01, 0xd5, 0xc0, 0x00, - 0x01, 0xd9, 0xc1, 0x00, 0x41, 0xd0, 0xb2, 0x00, 0x01, 0xd1, 0xb3, 0x00, - 0x01, 0xd2, 0xb4, 0x00, 0x01, 0x47, 0x42, 0xce, 0xb5, 0x00, 0x01, 0xd4, - 0xb6, 0x00, 0x01, 0x46, 0x34, 0xd9, 0xb7, 0x00, 0x01, 0xd7, 0xb8, 0x00, - 0x01, 0xd8, 0xb9, 0x00, 0x01, 0xd9, 0xba, 0x00, 0x41, 0xd0, 0xa8, 0x00, - 0x01, 0xd1, 0xa9, 0x00, 0x01, 0x49, 0x6a, 0xb5, 0xaa, 0x00, 0x01, 0x48, - 0x19, 0xc3, 0xab, 0x00, 0x01, 0xd4, 0xac, 0x00, 0x01, 0xd5, 0xad, 0x00, - 0x01, 0xd6, 0xae, 0x00, 0x01, 0xd7, 0xaf, 0x00, 0x01, 0xd8, 0xb0, 0x00, - 0x01, 0xd9, 0xb1, 0x00, 0x41, 0xd0, 0x9f, 0x00, 0x01, 0x46, 0xbc, 0xd8, - 0xa0, 0x00, 0x01, 0xd2, 0xa1, 0x00, 0x01, 0xd3, 0xa2, 0x00, 0x01, 0xd4, - 0xa3, 0x00, 0x01, 0xd7, 0xa5, 0x00, 0x01, 0xd8, 0xa6, 0x00, 0x01, 0x47, - 0x81, 0xce, 0xa7, 0x00, 0x41, 0x48, 0x01, 0xc3, 0x9a, 0x00, 0x01, 0x46, - 0xb6, 0xd8, 0x9b, 0x00, 0x01, 0xd2, 0x9c, 0x00, 0x01, 0x46, 0x1c, 0xd9, - 0x9d, 0x00, 0x01, 0xd6, 0x9e, 0x00, 0x41, 0x45, 0x47, 0xe2, 0x95, 0x00, - 0x01, 0x46, 0xc8, 0xd8, 0x96, 0x00, 0x01, 0xd2, 0x97, 0x00, 0x41, 0x47, - 0x11, 0xce, 0x8e, 0x00, 0x01, 0x48, 0x09, 0xc3, 0x8f, 0x00, 0x01, 0x47, - 0x1f, 0xce, 0x90, 0x00, 0x01, 0x47, 0x50, 0xce, 0x91, 0x00, 0x01, 0x49, - 0x8e, 0xb5, 0x92, 0x00, 0x41, 0x45, 0x42, 0xe2, 0x80, 0x00, 0x01, 0x47, - 0x26, 0xce, 0x81, 0x00, 0x01, 0x46, 0xf2, 0xd8, 0x82, 0x00, 0x01, 0x95, - 0x39, 0x96, 0x2b, 0x97, 0x1d, 0x98, 0x0f, 0x99, 0x01, 0xff, 0x45, 0x66, - 0xe6, 0x8c, 0x00, 0x01, 0x46, 0x02, 0xde, 0x8d, 0x00, 0x41, 0x45, 0x70, - 0xe6, 0x8a, 0x00, 0x01, 0x46, 0xfc, 0xdd, 0x8b, 0x00, 0x41, 0x4a, 0x5e, - 0xaa, 0x88, 0x00, 0x01, 0x49, 0xeb, 0xbb, 0x89, 0x00, 0x41, 0x45, 0x6b, - 0xe6, 0x86, 0x00, 0x01, 0x45, 0x6e, 0xe8, 0x87, 0x00, 0x41, 0x46, 0x2c, - 0xd8, 0x83, 0x00, 0x01, 0x46, 0xce, 0xdb, 0x84, 0x00, 0x01, 0x4a, 0xba, - 0xad, 0x85, 0x00, 0x41, 0x44, 0x21, 0xed, 0x1b, 0x06, 0x01, 0x91, 0xb1, - 0x0c, 0x93, 0xe8, 0x09, 0x94, 0xee, 0x08, 0x95, 0x90, 0x06, 0x96, 0xac, - 0x04, 0x97, 0x9b, 0x03, 0x02, 0x50, 0xf4, 0xf6, 0x02, 0xa2, 0x01, 0xff, - 0x90, 0x3f, 0x91, 0x01, 0xff, 0x42, 0x79, 0xe2, 0x48, 0x06, 0x01, 0x92, - 0x28, 0x02, 0x8a, 0xec, 0x1c, 0x42, 0x29, 0xf5, 0x50, 0x06, 0x01, 0x42, - 0x12, 0xf5, 0x51, 0x06, 0x01, 0x98, 0x06, 0x42, 0xa3, 0xf3, 0x54, 0x06, - 0x41, 0xd0, 0x52, 0x06, 0x01, 0xd8, 0x53, 0x06, 0x41, 0xe1, 0x4d, 0x06, - 0x01, 0xe2, 0x4e, 0x06, 0x41, 0xd0, 0x49, 0x06, 0x01, 0xd2, 0x4b, 0x06, - 0x01, 0xd3, 0x4c, 0x06, 0x41, 0x90, 0x8b, 0x02, 0x91, 0xf4, 0x01, 0x92, - 0xb6, 0x01, 0x93, 0x9b, 0x01, 0x94, 0x79, 0x95, 0x53, 0x96, 0x39, 0x97, - 0x1b, 0x98, 0x01, 0xff, 0xd0, 0x41, 0x06, 0x01, 0xd1, 0x42, 0x06, 0x01, - 0xd2, 0x43, 0x06, 0x01, 0xd5, 0x44, 0x06, 0x01, 0xd6, 0x45, 0x06, 0x01, - 0xd7, 0x46, 0x06, 0x41, 0xd0, 0x3a, 0x06, 0x01, 0xd3, 0x3b, 0x06, 0x01, - 0xd4, 0x3c, 0x06, 0x01, 0xd6, 0x3d, 0x06, 0x01, 0xd7, 0x3e, 0x06, 0x01, - 0xd8, 0x3f, 0x06, 0x01, 0xd9, 0x40, 0x06, 0x41, 0xd0, 0x34, 0x06, 0x01, - 0xd1, 0x35, 0x06, 0x01, 0xd5, 0x36, 0x06, 0x01, 0xd6, 0x37, 0x06, 0x01, - 0xd7, 0x38, 0x06, 0x01, 0xd9, 0x39, 0x06, 0x41, 0xd0, 0x2b, 0x06, 0x01, - 0xd1, 0x2c, 0x06, 0x01, 0xd3, 0x2d, 0x06, 0x01, 0xd4, 0x2e, 0x06, 0x01, - 0xd5, 0x2f, 0x06, 0x01, 0xd6, 0x30, 0x06, 0x01, 0xd7, 0x31, 0x06, 0x01, - 0xd8, 0x32, 0x06, 0x01, 0xd9, 0x33, 0x06, 0x41, 0xd0, 0x23, 0x06, 0x01, - 0xd1, 0x24, 0x06, 0x01, 0xd4, 0x25, 0x06, 0x01, 0xd5, 0x26, 0x06, 0x01, - 0xd6, 0x27, 0x06, 0x01, 0xd7, 0x28, 0x06, 0x01, 0xd8, 0x29, 0x06, 0x01, - 0xd9, 0x2a, 0x06, 0x41, 0xd0, 0x1d, 0x06, 0x01, 0xd1, 0x1e, 0x06, 0x01, - 0xd4, 0x1f, 0x06, 0x01, 0xd7, 0x20, 0x06, 0x01, 0xd8, 0x21, 0x06, 0x01, - 0xd9, 0x22, 0x06, 0x41, 0xd0, 0x0e, 0x06, 0x01, 0xd1, 0x0f, 0x06, 0x81, - 0x2a, 0xd2, 0x12, 0x06, 0x81, 0x1d, 0xd3, 0x15, 0x06, 0x81, 0x14, 0xd4, - 0x17, 0x06, 0x01, 0xd6, 0x18, 0x06, 0x01, 0xd7, 0x19, 0x06, 0x01, 0xd8, - 0x1a, 0x06, 0x01, 0xd9, 0x1c, 0x06, 0x41, 0xed, 0x16, 0x06, 0x41, 0xe6, - 0x13, 0x06, 0x01, 0xed, 0x14, 0x06, 0x41, 0xe6, 0x10, 0x06, 0x01, 0xed, - 0x11, 0x06, 0x41, 0xd0, 0x09, 0x06, 0x01, 0xd1, 0x0a, 0x06, 0x01, 0xd3, - 0x0b, 0x06, 0x01, 0xd6, 0x0c, 0x06, 0x01, 0xd7, 0x0d, 0x06, 0x41, 0xd1, - 0x00, 0x06, 0x01, 0xd2, 0x01, 0x06, 0x01, 0xd3, 0x02, 0x06, 0x01, 0xd4, - 0x03, 0x06, 0x01, 0xd5, 0x04, 0x06, 0x01, 0xd6, 0x05, 0x06, 0x01, 0xd7, - 0x06, 0x06, 0x01, 0xd8, 0x07, 0x06, 0x01, 0xd9, 0x08, 0x06, 0x41, 0xd0, - 0x60, 0x07, 0x01, 0xd1, 0x61, 0x07, 0x01, 0xd2, 0x62, 0x07, 0x01, 0xd3, - 0x63, 0x07, 0x01, 0xd4, 0x64, 0x07, 0x01, 0xd5, 0x65, 0x07, 0x01, 0xd6, - 0x66, 0x07, 0x01, 0xd7, 0x67, 0x07, 0x41, 0x90, 0x38, 0x91, 0x0c, 0x47, - 0x2d, 0xce, 0x54, 0x07, 0x01, 0x45, 0xf1, 0xe2, 0x55, 0x07, 0x41, 0x43, - 0xc1, 0x57, 0x4d, 0x07, 0x01, 0x43, 0xa4, 0xf3, 0x4e, 0x07, 0x01, 0x43, - 0x8d, 0xed, 0x4f, 0x07, 0x01, 0x47, 0x49, 0xce, 0x50, 0x07, 0x01, 0x45, - 0xf6, 0xe2, 0x51, 0x07, 0x01, 0x44, 0xfd, 0xed, 0x52, 0x07, 0x01, 0x44, - 0x81, 0xee, 0x53, 0x07, 0x41, 0x43, 0x18, 0xce, 0x40, 0x07, 0x01, 0x43, - 0x69, 0xed, 0x41, 0x07, 0x01, 0x43, 0xc5, 0xf3, 0x42, 0x07, 0x01, 0x43, - 0xd4, 0xf3, 0x43, 0x07, 0x01, 0x43, 0x05, 0xee, 0x44, 0x07, 0x01, 0x43, - 0x28, 0xd9, 0x45, 0x07, 0x01, 0x43, 0x82, 0xe3, 0x46, 0x07, 0x01, 0x43, - 0x29, 0xc3, 0x47, 0x07, 0x01, 0x99, 0x01, 0xff, 0x42, 0x73, 0x00, 0x48, - 0x07, 0x01, 0x8d, 0x01, 0xff, 0x44, 0x71, 0xed, 0x49, 0x07, 0x01, 0x44, - 0xa5, 0xed, 0x4a, 0x07, 0x01, 0x44, 0xd5, 0xed, 0x4b, 0x07, 0x01, 0x44, - 0x59, 0xee, 0x4c, 0x07, 0x41, 0x90, 0xbe, 0x01, 0x91, 0x93, 0x01, 0x92, - 0x6d, 0x93, 0x5f, 0x94, 0x3d, 0x95, 0x17, 0x96, 0x01, 0xff, 0xd0, 0x32, - 0x07, 0x01, 0xd1, 0x33, 0x07, 0x01, 0xd2, 0x34, 0x07, 0x01, 0xd3, 0x35, - 0x07, 0x01, 0xd4, 0x36, 0x07, 0x41, 0xd1, 0x29, 0x07, 0x01, 0xd2, 0x2a, - 0x07, 0x01, 0xd3, 0x2b, 0x07, 0x01, 0xd4, 0x2c, 0x07, 0x01, 0xd5, 0x2d, - 0x07, 0x01, 0xd6, 0x2e, 0x07, 0x01, 0xd7, 0x2f, 0x07, 0x01, 0xd8, 0x30, - 0x07, 0x01, 0xd9, 0x31, 0x07, 0x41, 0xd0, 0x21, 0x07, 0x01, 0xd2, 0x22, - 0x07, 0x01, 0xd3, 0x23, 0x07, 0x01, 0xd4, 0x24, 0x07, 0x01, 0xd5, 0x25, - 0x07, 0x01, 0xd6, 0x26, 0x07, 0x01, 0xd8, 0x27, 0x07, 0x01, 0xd9, 0x28, - 0x07, 0x41, 0xd4, 0x1e, 0x07, 0x01, 0xd7, 0x1f, 0x07, 0x01, 0xd8, 0x20, - 0x07, 0x41, 0xd0, 0x15, 0x07, 0x01, 0xd1, 0x16, 0x07, 0x01, 0xd2, 0x17, - 0x07, 0x01, 0xd3, 0x18, 0x07, 0x01, 0xd4, 0x19, 0x07, 0x01, 0xd6, 0x1a, - 0x07, 0x01, 0xd7, 0x1b, 0x07, 0x01, 0xd8, 0x1c, 0x07, 0x01, 0xd9, 0x1d, - 0x07, 0x41, 0xd0, 0x0b, 0x07, 0x01, 0xd1, 0x0c, 0x07, 0x01, 0xd2, 0x0d, - 0x07, 0x01, 0xd3, 0x0e, 0x07, 0x01, 0xd4, 0x0f, 0x07, 0x01, 0xd5, 0x10, - 0x07, 0x01, 0xd6, 0x11, 0x07, 0x01, 0xd7, 0x12, 0x07, 0x01, 0xd8, 0x13, - 0x07, 0x01, 0xd9, 0x14, 0x07, 0x41, 0xd0, 0x03, 0x07, 0x01, 0xd1, 0x04, - 0x07, 0x01, 0xd2, 0x05, 0x07, 0x01, 0xd3, 0x06, 0x07, 0x01, 0xd4, 0x07, - 0x07, 0x01, 0xd6, 0x08, 0x07, 0x01, 0xd8, 0x09, 0x07, 0x01, 0xd9, 0x0a, - 0x07, 0x41, 0x90, 0xb8, 0x02, 0x91, 0x9d, 0x02, 0x92, 0xf6, 0x01, 0x93, - 0xcf, 0x01, 0x94, 0xb0, 0x01, 0x95, 0x89, 0x01, 0x96, 0x6f, 0x97, 0x45, - 0x98, 0x1b, 0x99, 0x01, 0xff, 0xd1, 0xfd, 0x06, 0x01, 0xd2, 0xfe, 0x06, - 0x01, 0xd4, 0xff, 0x06, 0x01, 0xd5, 0x00, 0x07, 0x01, 0xd6, 0x01, 0x07, - 0x01, 0xd8, 0x02, 0x07, 0x41, 0xd0, 0xf3, 0x06, 0x01, 0xd1, 0xf4, 0x06, - 0x01, 0xd2, 0xf5, 0x06, 0x01, 0xd3, 0xf6, 0x06, 0x01, 0xd4, 0xf7, 0x06, - 0x01, 0xd5, 0xf8, 0x06, 0x01, 0xd6, 0xf9, 0x06, 0x01, 0xd7, 0xfa, 0x06, - 0x01, 0xd8, 0xfb, 0x06, 0x01, 0xd9, 0xfc, 0x06, 0x41, 0xd0, 0xe9, 0x06, - 0x01, 0xd1, 0xea, 0x06, 0x01, 0xd2, 0xeb, 0x06, 0x01, 0xd3, 0xec, 0x06, - 0x01, 0xd4, 0xed, 0x06, 0x01, 0xd5, 0xee, 0x06, 0x01, 0xd6, 0xef, 0x06, - 0x01, 0xd7, 0xf0, 0x06, 0x01, 0xd8, 0xf1, 0x06, 0x01, 0xd9, 0xf2, 0x06, - 0x41, 0xd3, 0xe3, 0x06, 0x01, 0xd4, 0xe4, 0x06, 0x01, 0xd5, 0xe5, 0x06, - 0x01, 0xd6, 0xe6, 0x06, 0x01, 0xd8, 0xe7, 0x06, 0x01, 0xd9, 0xe8, 0x06, - 0x41, 0xd0, 0xda, 0x06, 0x01, 0xd1, 0xdb, 0x06, 0x01, 0xd2, 0xdc, 0x06, - 0x01, 0xd3, 0xdd, 0x06, 0x01, 0xd4, 0xde, 0x06, 0x01, 0xd5, 0xdf, 0x06, - 0x01, 0xd6, 0xe0, 0x06, 0x01, 0xd7, 0xe1, 0x06, 0x01, 0xd9, 0xe2, 0x06, - 0x41, 0xd0, 0xd3, 0x06, 0x01, 0xd1, 0xd4, 0x06, 0x01, 0xd2, 0xd5, 0x06, - 0x01, 0xd5, 0xd6, 0x06, 0x01, 0xd7, 0xd7, 0x06, 0x01, 0xd8, 0xd8, 0x06, - 0x01, 0xd9, 0xd9, 0x06, 0x41, 0xd0, 0xca, 0x06, 0x01, 0xd1, 0xcb, 0x06, - 0x01, 0xd2, 0xcc, 0x06, 0x01, 0xd4, 0xcd, 0x06, 0x01, 0xd5, 0xce, 0x06, - 0x01, 0xd6, 0xcf, 0x06, 0x01, 0xd7, 0xd0, 0x06, 0x01, 0xd8, 0xd1, 0x06, - 0x01, 0xd9, 0xd2, 0x06, 0x41, 0xd0, 0xc1, 0x06, 0x01, 0xd1, 0xc2, 0x06, - 0x01, 0xd3, 0xc3, 0x06, 0x01, 0xd4, 0xc4, 0x06, 0x01, 0xd5, 0xc5, 0x06, - 0x01, 0xd6, 0xc6, 0x06, 0x01, 0xd7, 0xc7, 0x06, 0x01, 0xd8, 0xc8, 0x06, - 0x01, 0xd9, 0xc9, 0x06, 0x41, 0xd0, 0xbb, 0x06, 0x01, 0xd1, 0xbc, 0x06, - 0x01, 0xd2, 0xbd, 0x06, 0x01, 0xd3, 0xbe, 0x06, 0x01, 0xd5, 0xbf, 0x06, - 0x01, 0xd6, 0xc0, 0x06, 0x41, 0xd1, 0xb3, 0x06, 0x01, 0xd2, 0xb4, 0x06, - 0x01, 0xd3, 0xb5, 0x06, 0x01, 0xd4, 0xb6, 0x06, 0x01, 0xd5, 0xb7, 0x06, - 0x01, 0xd6, 0xb8, 0x06, 0x01, 0xd8, 0xb9, 0x06, 0x01, 0xd9, 0xba, 0x06, - 0x41, 0x90, 0x39, 0x91, 0x01, 0xff, 0x45, 0x4c, 0xe2, 0xaa, 0x06, 0x01, - 0x45, 0x74, 0xe2, 0xab, 0x06, 0x01, 0x45, 0xbf, 0xe2, 0xac, 0x06, 0x01, - 0x45, 0xec, 0xe2, 0xad, 0x06, 0x01, 0x45, 0x32, 0xe3, 0xae, 0x06, 0x01, - 0x45, 0x46, 0xe3, 0xaf, 0x06, 0x01, 0x45, 0x6e, 0xe3, 0xb0, 0x06, 0x01, - 0x45, 0x9b, 0xe3, 0xb1, 0x06, 0x01, 0x45, 0xc8, 0xe3, 0xb2, 0x06, 0x41, - 0x45, 0x4c, 0xe2, 0xa0, 0x06, 0x01, 0x45, 0x74, 0xe2, 0xa1, 0x06, 0x01, - 0x45, 0xbf, 0xe2, 0xa2, 0x06, 0x01, 0x45, 0xec, 0xe2, 0xa3, 0x06, 0x01, - 0x45, 0x32, 0xe3, 0xa4, 0x06, 0x01, 0x45, 0x46, 0xe3, 0xa5, 0x06, 0x01, - 0x45, 0x6e, 0xe3, 0xa6, 0x06, 0x01, 0x45, 0x9b, 0xe3, 0xa7, 0x06, 0x01, - 0x45, 0xc8, 0xe3, 0xa8, 0x06, 0x01, 0x45, 0x09, 0xe4, 0xa9, 0x06, 0x41, - 0x90, 0x94, 0x02, 0x91, 0xdf, 0x01, 0x92, 0xb4, 0x01, 0x93, 0x89, 0x01, - 0x94, 0x5f, 0x95, 0x35, 0x96, 0x0b, 0x97, 0x01, 0xff, 0xd0, 0x9e, 0x06, - 0x01, 0xd1, 0x9f, 0x06, 0x41, 0xd0, 0x94, 0x06, 0x01, 0xd1, 0x95, 0x06, - 0x01, 0xd2, 0x96, 0x06, 0x01, 0xd3, 0x97, 0x06, 0x01, 0xd4, 0x98, 0x06, - 0x01, 0xd5, 0x99, 0x06, 0x01, 0xd6, 0x9a, 0x06, 0x01, 0xd7, 0x9b, 0x06, - 0x01, 0xd8, 0x9c, 0x06, 0x01, 0xd9, 0x9d, 0x06, 0x41, 0xd0, 0x8a, 0x06, - 0x01, 0xd1, 0x8b, 0x06, 0x01, 0xd2, 0x8c, 0x06, 0x01, 0xd3, 0x8d, 0x06, - 0x01, 0xd4, 0x8e, 0x06, 0x01, 0xd5, 0x8f, 0x06, 0x01, 0xd6, 0x90, 0x06, - 0x01, 0xd7, 0x91, 0x06, 0x01, 0xd8, 0x92, 0x06, 0x01, 0xd9, 0x93, 0x06, - 0x41, 0xd0, 0x80, 0x06, 0x01, 0xd1, 0x81, 0x06, 0x01, 0xd2, 0x82, 0x06, - 0x01, 0xd3, 0x83, 0x06, 0x01, 0xd4, 0x84, 0x06, 0x01, 0xd5, 0x85, 0x06, - 0x01, 0xd6, 0x86, 0x06, 0x01, 0xd7, 0x87, 0x06, 0x01, 0xd8, 0x88, 0x06, - 0x01, 0xd9, 0x89, 0x06, 0x41, 0xd0, 0x76, 0x06, 0x01, 0xd1, 0x77, 0x06, - 0x01, 0xd2, 0x78, 0x06, 0x01, 0xd3, 0x79, 0x06, 0x01, 0xd4, 0x7a, 0x06, - 0x01, 0xd5, 0x7b, 0x06, 0x01, 0xd6, 0x7c, 0x06, 0x01, 0xd7, 0x7d, 0x06, - 0x01, 0xd8, 0x7e, 0x06, 0x01, 0xd9, 0x7f, 0x06, 0x41, 0xd0, 0x6c, 0x06, - 0x01, 0xd1, 0x6d, 0x06, 0x01, 0xd2, 0x6e, 0x06, 0x01, 0xd3, 0x6f, 0x06, - 0x01, 0xd4, 0x70, 0x06, 0x01, 0xd5, 0x71, 0x06, 0x01, 0xd6, 0x72, 0x06, - 0x01, 0xd7, 0x73, 0x06, 0x01, 0xd8, 0x74, 0x06, 0x01, 0xd9, 0x75, 0x06, - 0x41, 0xd0, 0x60, 0x06, 0x01, 0xd1, 0x61, 0x06, 0x01, 0xd2, 0x62, 0x06, - 0x01, 0x93, 0x18, 0xd4, 0x66, 0x06, 0x01, 0xd5, 0x67, 0x06, 0x01, 0xd6, - 0x68, 0x06, 0x01, 0xd7, 0x69, 0x06, 0x01, 0xd8, 0x6a, 0x06, 0x01, 0xd9, - 0x6b, 0x06, 0x41, 0xe1, 0x63, 0x06, 0x01, 0xe2, 0x64, 0x06, 0x01, 0xe3, - 0x65, 0x06, 0x41, 0xd1, 0x55, 0x06, 0x01, 0xd2, 0x56, 0x06, 0x01, 0xd3, - 0x57, 0x06, 0x01, 0xd4, 0x58, 0x06, 0x01, 0xd5, 0x59, 0x06, 0x01, 0xd6, - 0x5a, 0x06, 0x01, 0xd7, 0x5b, 0x06, 0x01, 0xd8, 0x5c, 0x06, 0x01, 0x99, - 0x01, 0xff, 0xe1, 0x5d, 0x06, 0x01, 0xe2, 0x5e, 0x06, 0x01, 0xe3, 0x5f, - 0x06, 0x41, 0x46, 0xaa, 0xd8, 0x47, 0x06, 0x01, 0x43, 0xbc, 0xf3, 0x4a, - 0x06, 0x01, 0x43, 0xd1, 0xf3, 0x4f, 0x06, 0x41, 0x44, 0xd5, 0x20, 0x0a, - 0x00, 0x00, 0x0c, 0x54, 0x90, 0x13, 0x49, 0xda, 0x20, 0x28, 0x20, 0x00, - 0x4a, 0xfe, 0x3b, 0x0b, 0x00, 0xc0, 0x00, 0x44, 0x87, 0xb8, 0x8a, 0x00, - 0x40, 0x56, 0xec, 0x35, 0x14, 0x2a, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, - 0x5c, 0x12, 0x19, 0x12, 0x2a, 0x00, 0x5d, 0x8a, 0x16, 0x13, 0x2a, 0x40, - 0x03, 0xa6, 0xc9, 0x06, 0x53, 0xb5, 0x4a, 0xcf, 0x32, 0x40, 0x06, 0xef, - 0x06, 0xec, 0x02, 0x50, 0xad, 0x00, 0x44, 0x19, 0x00, 0x07, 0xec, 0x05, - 0xab, 0x01, 0x4d, 0xc1, 0x34, 0x45, 0x19, 0x00, 0xb3, 0x36, 0x05, 0x57, - 0x39, 0x01, 0xff, 0x06, 0x59, 0x03, 0x06, 0x4f, 0x2a, 0x6a, 0x00, 0x19, - 0x40, 0xe1, 0x20, 0x19, 0x80, 0x1a, 0xe5, 0x27, 0x19, 0x80, 0x11, 0xe9, - 0x21, 0x19, 0x00, 0xef, 0x28, 0x19, 0x80, 0x04, 0xf5, 0x22, 0x19, 0x40, - 0xef, 0x25, 0x19, 0x40, 0xe5, 0x23, 0x19, 0x40, 0xe9, 0x24, 0x19, 0x00, - 0xf5, 0x26, 0x19, 0x40, 0x04, 0x5b, 0x03, 0x51, 0x0c, 0x77, 0x08, 0x17, - 0x10, 0xdd, 0x67, 0x01, 0xff, 0x42, 0x71, 0x00, 0x2a, 0x19, 0x00, 0x42, - 0xa9, 0x01, 0x2b, 0x19, 0x00, 0x42, 0xbe, 0x22, 0x29, 0x19, 0x40, 0x48, - 0x3c, 0x16, 0x32, 0x19, 0x00, 0x42, 0x1b, 0x02, 0x30, 0x19, 0x00, 0x42, - 0x74, 0x00, 0x38, 0x19, 0x00, 0x42, 0x6c, 0x00, 0x36, 0x19, 0x00, 0xae, - 0x12, 0x42, 0xbb, 0x09, 0x35, 0x19, 0x00, 0x42, 0x71, 0x00, 0x37, 0x19, - 0x00, 0x42, 0x12, 0x00, 0x33, 0x19, 0x40, 0xe1, 0x34, 0x19, 0x00, 0x42, - 0x24, 0x02, 0x31, 0x19, 0x40, 0x49, 0x25, 0xbb, 0x3a, 0x19, 0x00, 0x43, - 0xec, 0x1c, 0x40, 0x19, 0x00, 0x49, 0x3c, 0xbc, 0x39, 0x19, 0x00, 0x44, - 0xa9, 0xf2, 0x3b, 0x19, 0x40, 0xa2, 0xa9, 0x01, 0xa3, 0x9c, 0x01, 0xa4, - 0x8f, 0x01, 0xa7, 0x7d, 0x42, 0x22, 0x00, 0x1c, 0x19, 0x00, 0xaa, 0x6b, - 0xab, 0x5f, 0x42, 0x74, 0x00, 0x17, 0x19, 0x00, 0x42, 0x6c, 0x00, 0x14, - 0x19, 0x00, 0xae, 0x47, 0xb0, 0x3b, 0x42, 0x71, 0x00, 0x16, 0x19, 0x00, - 0xb3, 0x23, 0xb4, 0x11, 0x42, 0xa9, 0x01, 0x18, 0x19, 0x00, 0x42, 0xbe, - 0x22, 0x15, 0x19, 0xc0, 0x00, 0xee, 0x0a, 0x19, 0x40, 0xe1, 0x0b, 0x19, - 0x00, 0x42, 0x22, 0x00, 0x0c, 0x19, 0x00, 0x42, 0x71, 0x00, 0x1e, 0x19, - 0x40, 0xe1, 0x1b, 0x19, 0x00, 0x42, 0x22, 0x00, 0x19, 0x19, 0x00, 0x42, - 0x40, 0x06, 0x1a, 0x19, 0x40, 0xe1, 0x10, 0x19, 0x00, 0x42, 0x22, 0x00, - 0x11, 0x19, 0x40, 0xe1, 0x0f, 0x19, 0x00, 0x42, 0x24, 0x02, 0x05, 0x19, - 0x40, 0xe1, 0x01, 0x19, 0x00, 0x42, 0x22, 0x00, 0x02, 0x19, 0x40, 0xe1, - 0x08, 0x19, 0x00, 0x42, 0x22, 0x00, 0x09, 0x19, 0x40, 0xe1, 0x03, 0x19, - 0x00, 0x42, 0x22, 0x00, 0x04, 0x19, 0x00, 0x43, 0xd3, 0x35, 0x1d, 0x19, - 0x40, 0xe1, 0x0d, 0x19, 0x00, 0x42, 0x22, 0x00, 0x0e, 0x19, 0x40, 0xe1, - 0x06, 0x19, 0x00, 0x42, 0x22, 0x00, 0x07, 0x19, 0x40, 0xe1, 0x12, 0x19, - 0x00, 0x42, 0x22, 0x00, 0x13, 0x19, 0x40, 0x45, 0x12, 0x0b, 0x4e, 0x19, - 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x4f, 0x19, 0x00, 0x43, 0x0e, 0x0b, - 0x47, 0x19, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x46, 0x19, - 0x40, 0x44, 0x25, 0x01, 0x49, 0x19, 0x00, 0x42, 0x15, 0x02, 0x48, 0x19, - 0x40, 0x44, 0xe5, 0x1d, 0x4d, 0x19, 0x00, 0x42, 0x1c, 0x26, 0x4c, 0x19, - 0x40, 0x43, 0xd2, 0x05, 0x4b, 0x19, 0x00, 0x43, 0xf6, 0x06, 0x4a, 0x19, - 0x40, 0x56, 0x33, 0x29, 0x72, 0xf6, 0x01, 0x02, 0xcb, 0x00, 0x01, 0xff, - 0x80, 0x14, 0x44, 0x58, 0x07, 0x07, 0x26, 0xc0, 0x00, 0x45, 0xf7, 0xe1, - 0xf2, 0xf5, 0xc1, 0x00, 0x47, 0x8a, 0x7c, 0xf1, 0xf5, 0x41, 0x4a, 0x6a, - 0xa8, 0x75, 0xfa, 0x01, 0x4a, 0xc4, 0xa8, 0xf8, 0xf5, 0x01, 0x55, 0xe2, - 0x3a, 0xbb, 0xf7, 0x01, 0xa6, 0x48, 0x4b, 0x22, 0x61, 0xa2, 0xf7, 0x01, - 0x64, 0x73, 0x09, 0x72, 0x27, 0x00, 0xb2, 0x2e, 0xb3, 0x1a, 0xb4, 0x0c, - 0x4c, 0x32, 0x00, 0x58, 0x27, 0x00, 0x4c, 0xf4, 0x1f, 0x8e, 0xf7, 0x41, - 0x57, 0xcf, 0x2e, 0xc0, 0xf7, 0x01, 0x58, 0x01, 0x2c, 0xd2, 0xf7, 0x41, - 0x46, 0x2f, 0x19, 0xa9, 0xf7, 0x01, 0x44, 0x4c, 0x04, 0x91, 0x25, 0x00, - 0x52, 0x06, 0x53, 0xb5, 0xf7, 0x41, 0x43, 0x90, 0x17, 0x88, 0xf6, 0x01, - 0x64, 0x4f, 0x09, 0x73, 0x27, 0x40, 0x04, 0xd2, 0x05, 0x11, 0x12, 0x00, - 0x16, 0x01, 0xff, 0x44, 0x12, 0x16, 0xcc, 0x2b, 0x00, 0x44, 0x31, 0x13, - 0xc4, 0xf7, 0x41, 0x52, 0x07, 0x2c, 0xc9, 0xf7, 0x01, 0x4f, 0xf1, 0x1c, - 0xaf, 0xf7, 0x41, 0x02, 0x44, 0x14, 0xc0, 0x15, 0x44, 0xa9, 0xef, 0xd2, - 0xf4, 0x01, 0x02, 0xc5, 0x00, 0xcc, 0x05, 0xe7, 0xb5, 0xf9, 0x01, 0x43, - 0xc3, 0x07, 0x4b, 0xf3, 0x01, 0xef, 0x4c, 0x26, 0x80, 0xb6, 0x05, 0x05, - 0xe5, 0xe9, 0xda, 0x01, 0x08, 0xee, 0x00, 0x0c, 0x47, 0xd8, 0xd6, 0xd0, - 0xce, 0x01, 0x4a, 0x5a, 0xb3, 0x9a, 0xf3, 0x41, 0xa1, 0x87, 0x01, 0x0b, - 0xe6, 0x39, 0x77, 0x4f, 0xce, 0x6b, 0xa6, 0x2a, 0x80, 0x6a, 0x58, 0xa1, - 0x28, 0xda, 0x22, 0x00, 0xaf, 0x1d, 0x44, 0x5a, 0x03, 0x3c, 0x00, 0x00, - 0x05, 0x51, 0x00, 0x01, 0xff, 0x4d, 0x88, 0x81, 0x79, 0x2a, 0x00, 0x43, - 0x23, 0x0a, 0xd6, 0x22, 0x00, 0x53, 0x57, 0x4c, 0x7b, 0x2a, 0x40, 0x02, - 0x18, 0x00, 0x06, 0x4c, 0xe4, 0x96, 0x66, 0x22, 0x40, 0x4b, 0xcc, 0x1e, - 0x85, 0x2a, 0x00, 0x03, 0x7b, 0x00, 0x25, 0x4c, 0x87, 0x00, 0x76, 0x22, - 0x00, 0x50, 0x3d, 0x67, 0x7d, 0x2a, 0xc0, 0x00, 0x0a, 0x90, 0x3b, 0x01, - 0xff, 0x45, 0x5c, 0x00, 0x81, 0x2a, 0x80, 0x06, 0x46, 0xa7, 0x13, 0x7f, - 0x2a, 0x40, 0x46, 0xc7, 0x00, 0x83, 0x2a, 0x40, 0x45, 0xfb, 0x0c, 0x64, - 0x22, 0x00, 0x4a, 0xf1, 0x39, 0x72, 0x22, 0x40, 0x54, 0x93, 0x00, 0xa8, - 0x2a, 0x40, 0x45, 0xfb, 0x0c, 0x68, 0x22, 0x00, 0x4a, 0xf1, 0x39, 0xe6, - 0x22, 0x40, 0x05, 0x5d, 0x00, 0x11, 0x03, 0x1b, 0x00, 0x01, 0xff, 0x4f, - 0xd8, 0x70, 0x89, 0x2a, 0x00, 0x58, 0x11, 0x2b, 0x87, 0x2a, 0x40, 0x64, - 0xe3, 0x08, 0x8b, 0x2a, 0x00, 0x64, 0x07, 0x09, 0x91, 0x2a, 0x00, 0x4f, - 0x69, 0x1a, 0x76, 0x29, 0x00, 0xb3, 0x01, 0xff, 0x07, 0x16, 0xd2, 0x06, - 0x73, 0x74, 0x00, 0x93, 0x2a, 0x40, 0x52, 0x81, 0x00, 0x8f, 0x2a, 0x00, - 0x48, 0x0e, 0x29, 0x8d, 0x2a, 0x40, 0x0f, 0x58, 0x33, 0xa8, 0x03, 0x06, - 0xef, 0x06, 0xe1, 0x02, 0x07, 0xec, 0x05, 0x6e, 0x0c, 0x6d, 0x16, 0x48, - 0xb3, 0x25, 0x0b, 0x55, 0x77, 0x01, 0xff, 0x42, 0x80, 0x12, 0x26, 0x1c, - 0x00, 0xe5, 0x2c, 0x1c, 0x00, 0xe9, 0x27, 0x1c, 0x00, 0xef, 0x28, 0x1c, - 0x80, 0x09, 0xf5, 0x2a, 0x1c, 0xc0, 0x00, 0xf5, 0x2b, 0x1c, 0x40, 0xef, - 0x29, 0x1c, 0x40, 0x04, 0x5b, 0x03, 0x11, 0x10, 0xdd, 0x67, 0x01, 0xff, - 0x42, 0x71, 0x00, 0x25, 0x1c, 0x00, 0x42, 0xbe, 0x22, 0x24, 0x1c, 0x40, - 0x45, 0x5a, 0x3f, 0x37, 0x1c, 0x00, 0x43, 0x4f, 0x03, 0x36, 0x1c, 0x40, - 0x46, 0x40, 0xcd, 0x3d, 0x1c, 0x00, 0x52, 0x02, 0x54, 0x3c, 0x1c, 0x00, - 0xb4, 0x01, 0xff, 0x45, 0x0f, 0x54, 0x3b, 0x1c, 0x00, 0x45, 0x0c, 0xeb, - 0x3f, 0x1c, 0xc0, 0x00, 0x47, 0x3f, 0xcd, 0x3e, 0x1c, 0x40, 0xe1, 0x23, - 0x1c, 0x00, 0xa2, 0xde, 0x01, 0xa3, 0xd1, 0x01, 0xa4, 0xbe, 0x01, 0xa6, - 0xb1, 0x01, 0xa7, 0xa4, 0x01, 0xa8, 0x97, 0x01, 0x42, 0x72, 0x19, 0x08, - 0x1c, 0x00, 0xab, 0x7f, 0x42, 0x74, 0x00, 0x1c, 0x1c, 0x00, 0xad, 0x6d, - 0xae, 0x5b, 0xb0, 0x49, 0x42, 0x71, 0x00, 0x1b, 0x1c, 0x00, 0xb3, 0x37, - 0xb4, 0x12, 0x42, 0xf5, 0x0a, 0x1f, 0x1c, 0x00, 0x42, 0xa9, 0x01, 0x22, - 0x1c, 0x00, 0x42, 0xbe, 0x22, 0x1a, 0x1c, 0x40, 0xe1, 0x0a, 0x1c, 0x00, - 0x42, 0x22, 0x00, 0x0b, 0x1c, 0x00, 0xb3, 0x0d, 0xb4, 0x01, 0xff, 0xe1, - 0x4d, 0x1c, 0x00, 0x42, 0x22, 0x00, 0x4e, 0x1c, 0x40, 0xe1, 0x17, 0x1c, - 0x00, 0x42, 0x22, 0x00, 0x18, 0x1c, 0x40, 0xe1, 0x20, 0x1c, 0x00, 0x42, - 0x22, 0x00, 0x21, 0x1c, 0x40, 0xe1, 0x0e, 0x1c, 0x00, 0x42, 0x22, 0x00, - 0x10, 0x1c, 0x00, 0x42, 0x74, 0x00, 0x0f, 0x1c, 0x40, 0xe1, 0x0d, 0x1c, - 0x00, 0x42, 0x24, 0x02, 0x05, 0x1c, 0x00, 0x42, 0xbe, 0x22, 0x09, 0x1c, - 0x40, 0xe1, 0x15, 0x1c, 0x00, 0x42, 0x74, 0x00, 0x16, 0x1c, 0x40, 0xe1, - 0x00, 0x1c, 0x00, 0x42, 0x22, 0x00, 0x02, 0x1c, 0x00, 0x42, 0x74, 0x00, - 0x01, 0x1c, 0x40, 0xe1, 0x1d, 0x1c, 0x00, 0x42, 0x74, 0x00, 0x1e, 0x1c, - 0x40, 0xe1, 0x03, 0x1c, 0x00, 0x42, 0x74, 0x00, 0x04, 0x1c, 0x40, 0xe1, - 0x11, 0x1c, 0x00, 0x42, 0x74, 0x00, 0x12, 0x1c, 0x40, 0xe1, 0x0c, 0x1c, - 0x00, 0x42, 0xf0, 0x10, 0x4f, 0x1c, 0x00, 0x42, 0x59, 0x00, 0x19, 0x1c, - 0x40, 0xe1, 0x06, 0x1c, 0x00, 0x42, 0x22, 0x00, 0x07, 0x1c, 0x40, 0xe1, - 0x13, 0x1c, 0x00, 0x42, 0x74, 0x00, 0x14, 0x1c, 0x40, 0x45, 0x12, 0x0b, - 0x48, 0x1c, 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x49, 0x1c, 0x00, 0x43, - 0x0e, 0x0b, 0x41, 0x1c, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, - 0x40, 0x1c, 0x40, 0x44, 0x25, 0x01, 0x43, 0x1c, 0x00, 0x42, 0x15, 0x02, - 0x42, 0x1c, 0x40, 0x44, 0xe5, 0x1d, 0x47, 0x1c, 0x00, 0x42, 0x1c, 0x26, - 0x46, 0x1c, 0x40, 0x43, 0xd2, 0x05, 0x45, 0x1c, 0x00, 0x43, 0xf6, 0x06, - 0x44, 0x1c, 0x40, 0xeb, 0x2d, 0x1c, 0x80, 0x1f, 0xec, 0x2f, 0x1c, 0x00, - 0xed, 0x2e, 0x1c, 0x00, 0xee, 0x30, 0x1c, 0x80, 0x0c, 0xf0, 0x31, 0x1c, - 0x00, 0xf2, 0x32, 0x1c, 0x00, 0xf4, 0x33, 0x1c, 0x40, 0x46, 0x98, 0xe1, - 0x34, 0x1c, 0x40, 0x43, 0x1c, 0x01, 0x35, 0x1c, 0x40, 0x44, 0x1d, 0xf2, - 0x06, 0xf4, 0x41, 0x80, 0xaf, 0x08, 0x8d, 0xcc, 0x06, 0x06, 0xa9, 0x01, - 0x01, 0xff, 0x45, 0xce, 0x00, 0x90, 0x21, 0x80, 0xb1, 0x04, 0xa2, 0x92, - 0x04, 0x50, 0x8d, 0x61, 0x3c, 0xf8, 0x01, 0xa4, 0xd2, 0x03, 0xa6, 0xc3, - 0x03, 0xa8, 0xc2, 0x02, 0x57, 0x87, 0x2f, 0xa4, 0xf8, 0x01, 0x51, 0x00, - 0x5d, 0xfd, 0x21, 0x00, 0xb0, 0xa7, 0x02, 0x4f, 0x13, 0x72, 0x45, 0x2b, - 0x00, 0xb2, 0x92, 0x02, 0xb3, 0xf8, 0x01, 0xb4, 0x16, 0xb7, 0x01, 0xff, - 0x49, 0x93, 0xb6, 0x9c, 0x21, 0x00, 0x4a, 0x4a, 0x10, 0xe6, 0x21, 0xc0, - 0x00, 0x5a, 0xe2, 0x1e, 0x94, 0xf8, 0x41, 0x55, 0x6d, 0x3d, 0xa2, 0xf8, - 0x01, 0x02, 0x0d, 0x00, 0x51, 0x02, 0x15, 0x02, 0x01, 0xff, 0x4d, 0x9a, - 0x7f, 0x9e, 0x21, 0x00, 0x08, 0x09, 0x02, 0x01, 0xff, 0x06, 0xce, 0x00, - 0x06, 0x51, 0x98, 0x5e, 0x37, 0x2b, 0x40, 0x48, 0x78, 0xb4, 0x36, 0x2b, - 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x56, 0xb0, 0x33, 0x35, 0x2b, 0x00, - 0xb4, 0x06, 0x4f, 0xb7, 0x33, 0x34, 0x2b, 0x40, 0x43, 0x90, 0x17, 0x3b, - 0x2b, 0x80, 0x06, 0x52, 0x2f, 0x06, 0xec, 0x2b, 0x40, 0x06, 0x50, 0x00, - 0x01, 0xff, 0x56, 0xb0, 0x33, 0x3d, 0x2b, 0x00, 0x4f, 0xb7, 0x33, 0x3c, - 0x2b, 0x40, 0x05, 0x04, 0x02, 0x11, 0x04, 0x89, 0x1d, 0x01, 0xff, 0x45, - 0xce, 0x00, 0xda, 0x21, 0x00, 0x4a, 0x9f, 0x5e, 0x0e, 0x29, 0x40, 0x4a, - 0xe0, 0x01, 0x90, 0xf8, 0x01, 0x08, 0x09, 0x02, 0x01, 0xff, 0x45, 0xce, - 0x00, 0x60, 0x2b, 0x80, 0x0c, 0x4c, 0xd8, 0x8d, 0x6a, 0x2b, 0x00, 0x4d, - 0x79, 0x87, 0x84, 0x2b, 0x40, 0x80, 0x01, 0xff, 0x65, 0x51, 0x08, 0x80, - 0x2b, 0x00, 0x46, 0xd1, 0x14, 0x70, 0x2b, 0x00, 0x05, 0x51, 0x00, 0x01, - 0xff, 0x4a, 0x74, 0xa8, 0x28, 0xf8, 0x01, 0x07, 0x3b, 0x01, 0x28, 0x4b, - 0x72, 0x68, 0x2c, 0xf8, 0x01, 0x09, 0xd0, 0xbb, 0x12, 0x4c, 0x04, 0x92, - 0x24, 0xf8, 0x01, 0x4c, 0x70, 0x92, 0x20, 0xf8, 0x01, 0x50, 0x6d, 0x68, - 0x30, 0xf8, 0x41, 0x49, 0xa5, 0x01, 0xa6, 0x2b, 0x00, 0x47, 0x50, 0x02, - 0xa4, 0x2b, 0x40, 0x51, 0x47, 0x05, 0x7a, 0x2b, 0x00, 0x4f, 0xb7, 0x33, - 0x7a, 0x2b, 0x40, 0x4f, 0xee, 0x66, 0x50, 0xf8, 0x01, 0x02, 0x7c, 0x00, - 0x01, 0xff, 0x4a, 0x0a, 0x94, 0x38, 0xf8, 0x01, 0x4b, 0x95, 0x7c, 0xdc, - 0x21, 0x40, 0x57, 0x2b, 0x2f, 0xa6, 0xf8, 0x01, 0x45, 0xbe, 0xae, 0x6c, - 0xf6, 0x41, 0x4c, 0x7a, 0x87, 0xc7, 0x21, 0x00, 0x4b, 0xa5, 0xa4, 0xf7, - 0xfa, 0x41, 0xa1, 0x11, 0x05, 0x6e, 0x15, 0x01, 0xff, 0x45, 0xce, 0x00, - 0x44, 0xf8, 0x01, 0x50, 0x8d, 0x61, 0x40, 0xf8, 0x41, 0x42, 0x1b, 0x00, - 0xf2, 0xfa, 0x01, 0x06, 0xcb, 0x02, 0x01, 0xff, 0x57, 0x28, 0x30, 0xcb, - 0x21, 0x00, 0x0a, 0x98, 0x05, 0x01, 0xff, 0x04, 0xa5, 0x01, 0x31, 0x02, - 0x50, 0x02, 0x01, 0xff, 0x80, 0x06, 0x45, 0xa9, 0x01, 0xbc, 0x21, 0x40, - 0x06, 0x5c, 0x00, 0x0c, 0x48, 0x78, 0xb4, 0x5a, 0x29, 0x00, 0x46, 0xd1, - 0x14, 0x52, 0x29, 0x40, 0xac, 0x06, 0x5f, 0x8c, 0x11, 0x66, 0x29, 0x40, - 0x5f, 0x48, 0x06, 0x62, 0x29, 0x00, 0x48, 0x3f, 0x6b, 0x6a, 0x29, 0x40, - 0x80, 0x06, 0x45, 0xa9, 0x01, 0xbd, 0x21, 0x40, 0x67, 0x7f, 0x05, 0x67, - 0x29, 0x00, 0x4f, 0x38, 0x6b, 0x6b, 0x29, 0x00, 0x48, 0x78, 0xb4, 0x5e, - 0x29, 0x00, 0x46, 0xd1, 0x14, 0x56, 0x29, 0x40, 0x50, 0x04, 0x5a, 0x34, - 0xf8, 0x01, 0x60, 0x34, 0x10, 0xaa, 0xf8, 0x41, 0x4b, 0xd9, 0x8d, 0xe0, - 0x21, 0x00, 0x06, 0x3c, 0x01, 0x01, 0xff, 0x45, 0xce, 0x00, 0xd0, 0x21, - 0x80, 0x06, 0x4a, 0x9f, 0x5e, 0x0c, 0x29, 0x40, 0x80, 0x06, 0x45, 0x8e, - 0x17, 0x1b, 0x29, 0x40, 0x48, 0x78, 0xb4, 0x06, 0x29, 0x00, 0x05, 0x51, - 0x00, 0x01, 0xff, 0x46, 0x52, 0x05, 0xcd, 0x21, 0x00, 0x4f, 0xb7, 0x33, - 0x02, 0x29, 0x40, 0x5f, 0xb3, 0x10, 0xa8, 0xf8, 0x01, 0x05, 0x0d, 0x03, - 0x06, 0x58, 0x99, 0x2a, 0xa0, 0xf8, 0x41, 0x45, 0xce, 0x00, 0x05, 0x2b, - 0x00, 0x53, 0xda, 0x48, 0x88, 0x2b, 0x40, 0x80, 0x06, 0x45, 0x8e, 0x17, - 0x19, 0x29, 0x40, 0xa1, 0xd7, 0x01, 0x05, 0xaa, 0x05, 0xbf, 0x01, 0x55, - 0xbb, 0x14, 0xc6, 0x21, 0x00, 0xb4, 0x8a, 0x01, 0x05, 0x51, 0x00, 0x01, - 0xff, 0x02, 0x3b, 0x01, 0x75, 0x55, 0xd5, 0x01, 0x14, 0xf8, 0x01, 0x44, - 0xac, 0x0e, 0xa9, 0x21, 0x00, 0xac, 0x5b, 0x59, 0xfe, 0x24, 0x04, 0xf8, - 0x01, 0x4c, 0xe8, 0x92, 0x98, 0xf8, 0x01, 0x4a, 0xa4, 0xaf, 0x46, 0x29, - 0x00, 0xb3, 0x31, 0xb4, 0x06, 0x4f, 0xb7, 0x33, 0xf7, 0x21, 0x40, 0x43, - 0x90, 0x17, 0xa2, 0x21, 0x80, 0x11, 0x03, 0x4a, 0x0c, 0x01, 0xff, 0x49, - 0xa5, 0x01, 0x10, 0x2b, 0x00, 0x47, 0x50, 0x02, 0x11, 0x2b, 0x40, 0x06, - 0x50, 0x00, 0x01, 0xff, 0x56, 0xb0, 0x33, 0x3a, 0x2b, 0x00, 0x4f, 0xb7, - 0x33, 0x39, 0x2b, 0x40, 0x05, 0x5e, 0x07, 0x06, 0x45, 0x53, 0x05, 0x9a, - 0x21, 0x40, 0x55, 0xd5, 0x01, 0x10, 0xf8, 0x01, 0x52, 0x2e, 0x06, 0x00, - 0xf8, 0x41, 0x57, 0x92, 0x29, 0x08, 0xf8, 0x01, 0x43, 0xd1, 0x4b, 0xab, - 0x21, 0x40, 0x49, 0x35, 0xc0, 0x38, 0x2b, 0x00, 0x54, 0xb2, 0x33, 0xfa, - 0x21, 0x40, 0x07, 0x31, 0x2b, 0x18, 0x03, 0xd2, 0x14, 0x01, 0xff, 0x42, - 0x17, 0x00, 0xe4, 0x21, 0x80, 0x06, 0x4c, 0x60, 0x57, 0x1d, 0x29, 0x40, - 0x5d, 0xba, 0x14, 0xb9, 0x21, 0x40, 0x49, 0xec, 0x00, 0x77, 0x29, 0x00, - 0x46, 0x99, 0x12, 0x7a, 0x29, 0x00, 0xf8, 0x3e, 0x2b, 0x40, 0x43, 0x16, - 0x00, 0xa4, 0x21, 0x80, 0x06, 0x4f, 0x34, 0x0c, 0xc0, 0xf8, 0x41, 0x51, - 0x5b, 0x57, 0x1f, 0x29, 0x40, 0x05, 0x5d, 0x00, 0x06, 0x63, 0xfb, 0x0a, - 0xb5, 0xfb, 0x41, 0x4f, 0xb1, 0x6a, 0x4a, 0x2b, 0x00, 0x08, 0x6d, 0x72, - 0x0c, 0x56, 0x4c, 0x37, 0x43, 0x29, 0x00, 0x4e, 0x93, 0x3e, 0x73, 0x29, - 0x40, 0x4f, 0xb1, 0x6a, 0x42, 0x2b, 0x00, 0x4e, 0x93, 0x3e, 0x4b, 0x2b, - 0x40, 0x07, 0x8a, 0x2e, 0x9c, 0x01, 0x5b, 0xa1, 0x1b, 0xe6, 0x26, 0x00, - 0x09, 0x9c, 0x01, 0x2b, 0xb3, 0x1d, 0x09, 0x58, 0x44, 0x01, 0xff, 0x49, - 0x79, 0xb8, 0x2a, 0x20, 0x00, 0x47, 0x5f, 0x03, 0x66, 0x20, 0x00, 0x44, - 0xb9, 0x00, 0x0e, 0x20, 0x00, 0x48, 0xd1, 0xc9, 0x2d, 0x20, 0x40, 0x5c, - 0xfa, 0x17, 0xaa, 0x27, 0x00, 0x5b, 0xd7, 0x1b, 0x39, 0x29, 0x40, 0xa1, - 0x53, 0x54, 0x6f, 0x41, 0xfc, 0x29, 0x00, 0xa4, 0x3f, 0x4b, 0xcb, 0x9b, - 0x78, 0xcc, 0x01, 0x50, 0xfd, 0x64, 0x0d, 0xf5, 0x01, 0xb2, 0x0c, 0x4c, - 0x94, 0x95, 0x02, 0xcc, 0x01, 0x44, 0x96, 0xc7, 0x9e, 0xcc, 0x41, 0x49, - 0xbb, 0xb5, 0x97, 0xcc, 0x01, 0x44, 0xe6, 0xac, 0x65, 0xcc, 0x01, 0xaf, - 0x01, 0xff, 0x05, 0x66, 0x09, 0x06, 0x50, 0xbd, 0x64, 0xa2, 0xcc, 0x41, - 0x47, 0xb5, 0xcf, 0xa0, 0xcc, 0x01, 0x44, 0x13, 0x21, 0x56, 0xcc, 0x41, - 0x44, 0xbd, 0xf0, 0x0e, 0xcc, 0x01, 0x5a, 0xba, 0x21, 0xab, 0x00, 0x40, - 0x47, 0x2d, 0x34, 0xf9, 0xcd, 0x01, 0x4c, 0x3f, 0x0f, 0x29, 0x23, 0x00, - 0x4a, 0x24, 0xb2, 0x60, 0xcc, 0x41, 0x56, 0x00, 0x33, 0x8e, 0x05, 0x00, - 0x48, 0x11, 0xc4, 0x48, 0xcc, 0x01, 0x03, 0x31, 0x5b, 0x20, 0xb3, 0x01, - 0xff, 0x0f, 0x92, 0x2e, 0x0d, 0x4a, 0x50, 0xb3, 0xd6, 0x0f, 0xc0, 0x00, - 0x4a, 0x2d, 0x59, 0xd8, 0x0f, 0x40, 0x4c, 0x90, 0x8d, 0x74, 0xcc, 0x01, - 0x4a, 0x57, 0x29, 0x70, 0xcc, 0x41, 0xe8, 0x92, 0xcc, 0x81, 0x04, 0xf4, - 0x1b, 0xf9, 0x41, 0x50, 0x51, 0x29, 0x94, 0xcc, 0x41, 0xa1, 0xbd, 0x06, - 0xa2, 0x84, 0x06, 0xa3, 0xd3, 0x05, 0x02, 0x3b, 0x01, 0xab, 0x05, 0xa6, - 0x94, 0x05, 0x02, 0x22, 0x00, 0x86, 0x04, 0x15, 0x86, 0x3c, 0xf5, 0x03, - 0xac, 0xe6, 0x03, 0x48, 0x74, 0x77, 0xdc, 0x27, 0x00, 0x60, 0xd4, 0x0f, - 0xc9, 0x22, 0x00, 0xaf, 0xbb, 0x03, 0x4b, 0xda, 0x21, 0x28, 0x00, 0x80, - 0x9e, 0x03, 0xb2, 0xaa, 0x02, 0xb3, 0xb0, 0x01, 0xb4, 0x49, 0x0a, 0x32, - 0x00, 0x39, 0xb7, 0x01, 0xff, 0x05, 0xae, 0x02, 0x0c, 0x4b, 0x15, 0x97, - 0xd8, 0x29, 0x00, 0x4b, 0x53, 0xa2, 0x8e, 0xf5, 0x41, 0xa3, 0x18, 0x52, - 0x87, 0x27, 0x16, 0x30, 0x00, 0x4b, 0xda, 0x21, 0x85, 0x29, 0x00, 0x4e, - 0xe3, 0x26, 0x1a, 0x30, 0x00, 0x56, 0x54, 0x09, 0x18, 0x30, 0x40, 0x4d, - 0x3c, 0x69, 0x0e, 0x30, 0x00, 0x4c, 0x73, 0x0b, 0x83, 0x29, 0x40, 0x4d, - 0xab, 0x80, 0x20, 0x2e, 0x00, 0x47, 0x85, 0xd4, 0xb8, 0x23, 0x40, 0x43, - 0x0e, 0x03, 0xa3, 0x22, 0x00, 0xa8, 0x25, 0x55, 0x55, 0x09, 0x14, 0x30, - 0x00, 0xb2, 0x06, 0x4f, 0xf2, 0x74, 0xce, 0xfb, 0x41, 0x53, 0x1c, 0x48, - 0x09, 0x2e, 0x00, 0x04, 0x1b, 0x01, 0x01, 0xff, 0x56, 0x3c, 0x35, 0xcf, - 0x29, 0x00, 0x56, 0x56, 0x1d, 0x6c, 0xfb, 0x41, 0x04, 0x4f, 0x89, 0x28, - 0x4c, 0xa8, 0x93, 0xec, 0xf5, 0x01, 0x04, 0x26, 0x01, 0x01, 0xff, 0x4d, - 0x08, 0x4d, 0x8d, 0x25, 0x00, 0x09, 0x2a, 0x01, 0x01, 0xff, 0x45, 0x33, - 0x01, 0x8a, 0x25, 0x00, 0x57, 0x9e, 0x2f, 0xa2, 0xce, 0x01, 0x57, 0xaf, - 0x31, 0xa9, 0xce, 0x41, 0x48, 0x29, 0xc7, 0x0b, 0xcc, 0x01, 0x5a, 0x8a, - 0x22, 0xc1, 0xfb, 0x41, 0x55, 0xea, 0x38, 0xc5, 0x27, 0x00, 0xa5, 0x63, - 0xa9, 0x55, 0x4c, 0x85, 0x7c, 0xe8, 0xf5, 0x01, 0x4d, 0xe4, 0x26, 0x5b, - 0x00, 0x80, 0x06, 0x53, 0xc6, 0x26, 0x02, 0x2e, 0x40, 0x80, 0x01, 0xff, - 0x49, 0xc8, 0x58, 0xa2, 0x23, 0x00, 0x4c, 0x80, 0x91, 0xa3, 0x23, 0x00, - 0x4c, 0xa8, 0x96, 0xa1, 0x23, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4d, - 0x4b, 0x82, 0x57, 0x2e, 0x00, 0x45, 0xb3, 0x80, 0x45, 0x20, 0x00, 0x46, - 0x52, 0x05, 0x55, 0x2e, 0x00, 0x08, 0xa9, 0xcb, 0x06, 0x48, 0xea, 0x59, - 0x8b, 0x29, 0x40, 0x4d, 0x47, 0x81, 0x8f, 0x29, 0x00, 0x4a, 0x2e, 0xb2, - 0x8d, 0x29, 0x40, 0x50, 0xdd, 0x61, 0x26, 0x2e, 0x00, 0x53, 0x97, 0x0b, - 0x18, 0x20, 0x40, 0x50, 0xe4, 0x0f, 0xcb, 0x22, 0x00, 0x51, 0x04, 0x4d, - 0x89, 0x25, 0x40, 0x56, 0x9c, 0x30, 0x0c, 0x2e, 0x00, 0x05, 0xc9, 0x00, - 0x01, 0xff, 0x45, 0xce, 0x00, 0x94, 0x21, 0x80, 0x3f, 0x4b, 0xc6, 0x99, - 0x0c, 0x2b, 0x00, 0x4c, 0x44, 0x8e, 0xd4, 0x21, 0x80, 0x21, 0x51, 0x00, - 0x5d, 0xff, 0x21, 0x00, 0x50, 0xed, 0x66, 0x58, 0xf8, 0x01, 0x55, 0x01, - 0x02, 0x64, 0x2b, 0x00, 0xb7, 0x01, 0xff, 0x49, 0x93, 0xb6, 0xad, 0x21, - 0x00, 0x4a, 0x4a, 0x10, 0x04, 0x2b, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, - 0x46, 0x52, 0x05, 0xce, 0x21, 0x00, 0x4f, 0xb7, 0x33, 0x04, 0x29, 0x40, - 0x80, 0x01, 0xff, 0x54, 0x1f, 0x46, 0x48, 0x29, 0x00, 0x05, 0x51, 0x00, - 0x01, 0xff, 0x56, 0xb0, 0x33, 0xfc, 0x21, 0x00, 0x46, 0x52, 0x05, 0xae, - 0x21, 0x00, 0x4f, 0xb7, 0x33, 0xf9, 0x21, 0x40, 0x80, 0x01, 0xff, 0x49, - 0xc8, 0x58, 0x9c, 0x23, 0x00, 0x4a, 0x88, 0xad, 0x9d, 0x23, 0x00, 0x4a, - 0x00, 0xb3, 0x9b, 0x23, 0x40, 0x03, 0xef, 0x07, 0x06, 0x49, 0x73, 0xaf, - 0xd5, 0x27, 0x40, 0x4c, 0x12, 0x0b, 0x8f, 0x25, 0x00, 0x4d, 0x5f, 0x1d, - 0x8e, 0x25, 0x00, 0x4b, 0x87, 0xa3, 0xcf, 0xfb, 0x41, 0x55, 0xab, 0x35, - 0x1c, 0x2e, 0x00, 0x46, 0x0e, 0xe1, 0xc5, 0xf6, 0x41, 0x4c, 0x0c, 0x03, - 0xeb, 0xfb, 0x01, 0x4c, 0x32, 0x11, 0xe3, 0xfb, 0x41, 0x03, 0x24, 0x00, - 0x06, 0x55, 0x2e, 0x3d, 0x7b, 0xf5, 0x41, 0x02, 0x33, 0x01, 0x65, 0x46, - 0x12, 0x03, 0x07, 0xf9, 0x81, 0x3e, 0xa6, 0x30, 0x65, 0xe2, 0x07, 0x10, - 0xce, 0x01, 0x69, 0x3c, 0x04, 0x94, 0xfb, 0x01, 0x57, 0x9e, 0x2f, 0xa3, - 0xce, 0x01, 0x4c, 0x44, 0x04, 0x8c, 0xfb, 0x01, 0x4b, 0x8a, 0xa2, 0xb2, - 0xfb, 0x01, 0x56, 0x8e, 0x37, 0x0d, 0xce, 0x01, 0x57, 0xaf, 0x31, 0xa8, - 0xce, 0x01, 0x4d, 0xac, 0x8a, 0x0b, 0xce, 0x41, 0x4c, 0xb0, 0x91, 0xa4, - 0xcc, 0x01, 0x45, 0xd3, 0x65, 0xb9, 0xfb, 0x41, 0x06, 0x50, 0x00, 0x01, - 0xff, 0x43, 0x23, 0x0a, 0x06, 0xf9, 0x01, 0x49, 0xd8, 0x46, 0x03, 0xf9, - 0x01, 0xb4, 0x01, 0xff, 0x49, 0x2b, 0x10, 0x04, 0xf9, 0x01, 0x47, 0x20, - 0x0a, 0x05, 0xf9, 0x41, 0x04, 0x0e, 0x03, 0x06, 0x43, 0x35, 0x01, 0x8c, - 0x25, 0x40, 0x46, 0x12, 0x03, 0xd6, 0x25, 0x00, 0x44, 0x31, 0x13, 0xe8, - 0x2b, 0x40, 0xa9, 0x06, 0x44, 0x5b, 0x24, 0x0a, 0x23, 0x40, 0x47, 0x1d, - 0xb9, 0x7c, 0x29, 0x00, 0x50, 0xb2, 0x51, 0x8b, 0x25, 0x40, 0x59, 0xc0, - 0x26, 0x04, 0x2e, 0x00, 0x05, 0x3d, 0x01, 0x01, 0xff, 0x4d, 0x3e, 0x0f, - 0x0a, 0x30, 0x00, 0x4b, 0xda, 0x21, 0x28, 0x2e, 0x00, 0x4e, 0x19, 0x05, - 0x1c, 0x20, 0x00, 0x4c, 0x14, 0x97, 0xda, 0x29, 0x40, 0x46, 0xb2, 0xc4, - 0x08, 0x23, 0x00, 0x4b, 0xf9, 0x9e, 0xdc, 0x26, 0x00, 0x4d, 0x3c, 0x69, - 0x0c, 0x30, 0x00, 0x4c, 0x73, 0x0b, 0x7b, 0x00, 0xc0, 0x00, 0x80, 0x01, - 0xff, 0x4a, 0x88, 0xad, 0xa9, 0x23, 0x00, 0x4c, 0x1c, 0x92, 0xa8, 0x23, - 0x00, 0x4a, 0x00, 0xb3, 0xa7, 0x23, 0x40, 0x04, 0x9e, 0x05, 0x11, 0x05, - 0x0d, 0x03, 0x01, 0xff, 0x52, 0x87, 0x27, 0x10, 0x30, 0x00, 0x56, 0x54, - 0x09, 0x97, 0x29, 0x40, 0x10, 0x5d, 0x62, 0x11, 0x0e, 0x28, 0x7e, 0x01, - 0xff, 0x4c, 0x50, 0x8e, 0x4a, 0x29, 0x00, 0x4a, 0xe2, 0xb2, 0x4e, 0x29, - 0x40, 0x4c, 0x50, 0x8e, 0x50, 0x29, 0x00, 0x4a, 0xe2, 0xb2, 0x4b, 0x29, - 0x40, 0xae, 0x1a, 0xb2, 0x01, 0xff, 0x53, 0x74, 0x1d, 0x93, 0x29, 0x00, - 0x09, 0x25, 0x06, 0x01, 0xff, 0x4c, 0x6c, 0x8d, 0x32, 0x2b, 0x00, 0x4c, - 0x3f, 0x15, 0x30, 0x2b, 0x40, 0x02, 0x06, 0x00, 0x16, 0xa7, 0x01, 0xff, - 0x49, 0x9d, 0xb8, 0xee, 0xf5, 0x01, 0x4a, 0x41, 0x0f, 0x08, 0x30, 0xc0, - 0x00, 0x49, 0x90, 0x3b, 0x91, 0x29, 0x40, 0x06, 0x13, 0x01, 0x31, 0x06, - 0xc8, 0x00, 0x18, 0x06, 0x6d, 0x02, 0x01, 0xff, 0x69, 0x13, 0x04, 0x6b, - 0xfb, 0x01, 0x50, 0x0e, 0x0b, 0x7d, 0xfb, 0xc1, 0x00, 0x5e, 0x27, 0x12, - 0x8e, 0xcc, 0x41, 0x50, 0x3d, 0x62, 0xda, 0x27, 0x00, 0xb4, 0x01, 0xff, - 0x43, 0x0e, 0x03, 0xdb, 0x27, 0x00, 0x54, 0xbe, 0x3e, 0x9b, 0xfb, 0x41, - 0x69, 0x13, 0x04, 0x69, 0xfb, 0x01, 0x50, 0x0e, 0x0b, 0x7c, 0xfb, 0x41, - 0x53, 0x71, 0x47, 0x43, 0xf3, 0x01, 0x49, 0x7f, 0xbb, 0xbe, 0xfa, 0x01, - 0x47, 0xd4, 0xd7, 0x6c, 0xf9, 0x41, 0xa2, 0xdd, 0x4b, 0x55, 0xfb, 0x39, - 0x4d, 0xf9, 0x01, 0xa4, 0xc8, 0x4b, 0xae, 0xb9, 0x4b, 0x02, 0x7b, 0x02, - 0xdd, 0x46, 0xb2, 0xda, 0x41, 0x4f, 0x3f, 0x73, 0x3e, 0x26, 0x80, 0xc3, - 0x41, 0x04, 0xe0, 0x05, 0x01, 0xff, 0xa3, 0xd3, 0x28, 0x12, 0x68, 0x51, - 0xa8, 0x28, 0x07, 0xec, 0x05, 0x87, 0x25, 0xb3, 0x01, 0xff, 0x05, 0x5e, - 0x07, 0x50, 0x16, 0xd0, 0x37, 0x01, 0xff, 0xe1, 0x90, 0x20, 0x00, 0xe5, - 0x91, 0x20, 0x00, 0xe8, 0x95, 0x20, 0x00, 0xe9, 0x62, 0x1d, 0x00, 0xea, - 0x7c, 0x2c, 0x00, 0xeb, 0x96, 0x20, 0x00, 0xec, 0x97, 0x20, 0x00, 0xed, - 0x98, 0x20, 0x00, 0xee, 0x99, 0x20, 0x00, 0xef, 0x92, 0x20, 0x00, 0xf0, - 0x9a, 0x20, 0x00, 0xf2, 0x63, 0x1d, 0x00, 0xf3, 0x9b, 0x20, 0x80, 0x10, - 0xf4, 0x9c, 0x20, 0x00, 0xf5, 0x64, 0x1d, 0x00, 0xf6, 0x65, 0x1d, 0x00, - 0xf8, 0x93, 0x20, 0x40, 0x44, 0xca, 0x7b, 0x94, 0x20, 0x40, 0x0f, 0xe4, - 0x05, 0x9f, 0x24, 0xac, 0x01, 0xff, 0x06, 0xed, 0x05, 0x34, 0x08, 0x9f, - 0x1f, 0x01, 0xff, 0xa6, 0x18, 0x42, 0x80, 0xc7, 0x33, 0x01, 0x00, 0x48, - 0x09, 0xc8, 0x05, 0xfb, 0x00, 0x42, 0x67, 0x51, 0x53, 0x01, 0x00, 0x42, - 0x60, 0x01, 0x06, 0xfb, 0x40, 0xe6, 0x00, 0xfb, 0x80, 0x08, 0xe9, 0x01, - 0xfb, 0x00, 0xec, 0x02, 0xfb, 0x40, 0xe9, 0x03, 0xfb, 0x00, 0xec, 0x04, - 0xfb, 0x40, 0xe1, 0x61, 0x00, 0x80, 0xa7, 0x21, 0xe2, 0x62, 0x00, 0x80, - 0xa4, 0x20, 0xe3, 0x63, 0x00, 0x80, 0x86, 0x1f, 0xe4, 0x64, 0x00, 0x80, - 0x81, 0x1d, 0xe5, 0x65, 0x00, 0x80, 0x9b, 0x1a, 0xe6, 0x66, 0x00, 0x80, - 0xe6, 0x19, 0xe7, 0x67, 0x00, 0x80, 0xf5, 0x18, 0xe8, 0x68, 0x00, 0x80, - 0x83, 0x18, 0xe9, 0x69, 0x00, 0x80, 0xbb, 0x16, 0xea, 0x6a, 0x00, 0x80, - 0x96, 0x16, 0xeb, 0x6b, 0x00, 0x80, 0xb9, 0x15, 0xec, 0x6c, 0x00, 0x80, - 0xad, 0x13, 0xed, 0x6d, 0x00, 0x80, 0xd6, 0x12, 0xee, 0x6e, 0x00, 0x80, - 0xb8, 0x11, 0xef, 0x6f, 0x00, 0x80, 0xc8, 0x0e, 0xf0, 0x70, 0x00, 0x80, - 0xf7, 0x0d, 0xf1, 0x71, 0x00, 0x80, 0xce, 0x0d, 0xf2, 0x72, 0x00, 0x80, - 0xc9, 0x0b, 0xf3, 0x73, 0x00, 0x80, 0xb7, 0x09, 0xf4, 0x74, 0x00, 0x80, - 0xe2, 0x05, 0xf5, 0x75, 0x00, 0x80, 0xb4, 0x03, 0xf6, 0x76, 0x00, 0x80, - 0xd8, 0x02, 0xf7, 0x77, 0x00, 0x80, 0x96, 0x02, 0xf8, 0x78, 0x00, 0x80, - 0xd7, 0x01, 0xf9, 0x79, 0x00, 0x80, 0x6a, 0xfa, 0x7a, 0x00, 0xc0, 0x00, - 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0x7a, 0x01, 0x00, 0xa3, - 0x46, 0xa4, 0x2d, 0x44, 0xac, 0x0e, 0x25, 0x02, 0x00, 0x4a, 0xa4, 0x6d, - 0x95, 0x1e, 0x00, 0x4c, 0x30, 0x23, 0x76, 0x1d, 0x00, 0x4c, 0xfa, 0x56, - 0x8e, 0x1d, 0x00, 0x4e, 0xa2, 0x0e, 0x90, 0x02, 0x00, 0xb3, 0x01, 0xff, - 0x45, 0x53, 0x05, 0xb6, 0x01, 0x00, 0x49, 0x5e, 0xc1, 0x40, 0x02, 0x40, - 0x48, 0x39, 0x2b, 0x6c, 0x2c, 0x00, 0x03, 0x04, 0x0c, 0x01, 0xff, 0x45, - 0x5c, 0x00, 0x7c, 0x01, 0x00, 0x45, 0x20, 0x07, 0x93, 0x1e, 0x40, 0x44, - 0xee, 0x6c, 0x7e, 0x01, 0x00, 0x49, 0xd0, 0x04, 0x91, 0x1e, 0x00, 0x43, - 0x73, 0x0b, 0x91, 0x02, 0x40, 0x06, 0x50, 0x00, 0x06, 0x43, 0x2c, 0x52, - 0x1d, 0x02, 0x40, 0x45, 0x14, 0x39, 0xfd, 0x00, 0x00, 0x4a, 0xcf, 0x04, - 0x77, 0x01, 0x00, 0xa4, 0x39, 0x45, 0x17, 0x23, 0xf3, 0x1e, 0x00, 0x44, - 0xac, 0x0e, 0xb4, 0x01, 0x80, 0x26, 0x44, 0x57, 0x85, 0xff, 0x1e, 0x00, - 0x46, 0xb4, 0x70, 0x33, 0x02, 0x00, 0x4a, 0x80, 0xb0, 0x99, 0x1e, 0x00, - 0xb3, 0x06, 0x45, 0x37, 0x23, 0xf9, 0x1e, 0x40, 0x4e, 0xb2, 0x38, 0x5a, - 0xab, 0x00, 0x45, 0x53, 0x05, 0x4f, 0x02, 0x40, 0x46, 0x5b, 0x00, 0xf7, - 0x1e, 0x40, 0x48, 0xba, 0x23, 0xff, 0x00, 0x00, 0x03, 0x04, 0x0c, 0x01, - 0xff, 0x45, 0x5c, 0x00, 0x8f, 0x1e, 0x00, 0x45, 0x20, 0x07, 0xf5, 0x1e, - 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0xa4, 0x26, 0x02, 0x13, 0x01, 0x06, - 0x4c, 0xfa, 0x56, 0x8d, 0x1d, 0x40, 0x4b, 0x2d, 0xa0, 0x57, 0xab, 0x80, - 0x06, 0x4c, 0x2a, 0x50, 0x56, 0xab, 0x40, 0x80, 0x01, 0xff, 0x52, 0x24, - 0x50, 0x58, 0xab, 0x00, 0x4a, 0x6e, 0x29, 0x59, 0xab, 0x40, 0x48, 0xba, - 0x23, 0x8d, 0x1e, 0x00, 0x48, 0x57, 0x1e, 0x8b, 0x1e, 0x40, 0x06, 0x50, - 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0x83, 0x1e, 0x00, 0x4a, 0xcf, 0x04, - 0x75, 0x01, 0x00, 0xa4, 0x12, 0x45, 0x17, 0x23, 0x81, 0x1e, 0x00, 0x44, - 0xac, 0x0e, 0x73, 0x2c, 0x00, 0x4a, 0x80, 0xb0, 0x98, 0x1e, 0x40, 0x48, - 0xba, 0x23, 0x85, 0x1e, 0x00, 0x03, 0x04, 0x0c, 0x01, 0xff, 0x45, 0x5c, - 0x00, 0x87, 0x1e, 0x00, 0x45, 0x20, 0x07, 0x89, 0x1e, 0x40, 0x06, 0x50, - 0x00, 0x26, 0x43, 0x40, 0x05, 0x69, 0xa7, 0x00, 0x4b, 0xdb, 0x9d, 0x63, - 0xa7, 0x00, 0x07, 0xf2, 0xd3, 0x04, 0xf9, 0x61, 0xa7, 0x40, 0x42, 0x93, - 0x0f, 0x9b, 0xa7, 0x00, 0x42, 0x67, 0x51, 0x9d, 0xa7, 0x00, 0x42, 0xd6, - 0x13, 0x9f, 0xa7, 0x40, 0x44, 0x72, 0x0b, 0x74, 0x2c, 0x00, 0xa4, 0x18, - 0x44, 0xac, 0x0e, 0x8b, 0x02, 0x00, 0x4c, 0xfa, 0x56, 0x8c, 0x1d, 0x00, - 0x4a, 0x6c, 0xb0, 0x71, 0x2c, 0x00, 0x45, 0x37, 0x23, 0x7d, 0x1e, 0x40, - 0x4e, 0xa9, 0x3f, 0x5f, 0xa7, 0x00, 0x48, 0xa0, 0x12, 0x7f, 0x1e, 0x40, - 0x80, 0x1d, 0xe5, 0x6b, 0x1d, 0x00, 0xe9, 0x50, 0xab, 0x00, 0xed, 0x78, - 0xa7, 0x00, 0xef, 0x63, 0xab, 0x00, 0x46, 0xcf, 0x15, 0x8a, 0x02, 0xc0, - 0x00, 0x4c, 0xf5, 0x28, 0x7f, 0x1d, 0x40, 0x43, 0x16, 0x00, 0x89, 0x02, - 0x80, 0xfb, 0x01, 0x05, 0x51, 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0xfa, - 0x00, 0x00, 0x45, 0x55, 0x23, 0x6d, 0x01, 0x00, 0xa3, 0xd4, 0x01, 0xa4, - 0x8b, 0x01, 0x45, 0x17, 0x23, 0xf9, 0x00, 0x00, 0x02, 0x0b, 0x00, 0x51, - 0x4e, 0x60, 0x23, 0x17, 0x02, 0x00, 0x49, 0xb8, 0x57, 0x52, 0xab, 0x00, - 0x46, 0xb4, 0x70, 0x6b, 0x01, 0x80, 0x38, 0x46, 0xda, 0xde, 0x73, 0x01, - 0x00, 0xb2, 0x24, 0xb3, 0x16, 0x45, 0x37, 0x23, 0x69, 0x01, 0xc0, 0x00, - 0x80, 0x01, 0xff, 0x49, 0xb9, 0xa5, 0x79, 0x1e, 0x00, 0x45, 0x20, 0x07, - 0x75, 0x1e, 0x40, 0x4e, 0xb2, 0x38, 0x4e, 0xab, 0x00, 0x45, 0x53, 0x05, - 0xb9, 0xa7, 0x40, 0x4d, 0xa3, 0x0e, 0x99, 0x1d, 0x00, 0x49, 0x81, 0xb0, - 0x6f, 0x01, 0x40, 0x4e, 0x4c, 0x75, 0x7b, 0x1e, 0x40, 0x48, 0x5a, 0xab, - 0xe7, 0x1e, 0x00, 0x42, 0x5e, 0x01, 0xb0, 0x01, 0xc0, 0x00, 0x05, 0x19, - 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0xe9, 0x1e, 0x00, 0x49, 0x9f, 0x12, - 0xf1, 0x1e, 0x00, 0x45, 0x17, 0x23, 0xeb, 0x1e, 0x00, 0x4a, 0x58, 0xab, - 0xed, 0x1e, 0x00, 0x45, 0x37, 0x23, 0xef, 0x1e, 0x40, 0x48, 0xba, 0x23, - 0xfc, 0x00, 0x80, 0x1a, 0xaf, 0x01, 0xff, 0x47, 0xa1, 0x12, 0xe5, 0x1e, - 0x00, 0x05, 0x3d, 0x01, 0x01, 0xff, 0x45, 0x14, 0x39, 0x71, 0x01, 0x00, - 0x45, 0x17, 0x23, 0x15, 0x02, 0x40, 0x80, 0x01, 0xff, 0x04, 0x1a, 0x00, - 0x06, 0x45, 0x20, 0x07, 0x73, 0x1e, 0x40, 0x45, 0x14, 0x39, 0xd8, 0x01, - 0x00, 0x45, 0x09, 0x98, 0xda, 0x01, 0x00, 0x45, 0x17, 0x23, 0xdc, 0x01, - 0x00, 0x46, 0xb4, 0x70, 0xd6, 0x01, 0x40, 0x44, 0xee, 0x6c, 0xd4, 0x01, - 0x00, 0x49, 0xd0, 0x04, 0xfb, 0x00, 0xc0, 0x00, 0x46, 0x1f, 0x07, 0x77, - 0x1e, 0x40, 0x55, 0xab, 0x38, 0x4f, 0xab, 0x40, 0x06, 0x50, 0x00, 0xd2, - 0x02, 0x4b, 0x21, 0x99, 0x77, 0x2c, 0x00, 0x53, 0xb4, 0x48, 0xa8, 0x02, - 0x00, 0x4b, 0x0d, 0x9c, 0xa7, 0x02, 0x80, 0xad, 0x02, 0xa8, 0x90, 0x02, - 0xaf, 0xf1, 0x01, 0x47, 0x73, 0xd5, 0x2b, 0xa7, 0x00, 0x49, 0x39, 0xbf, - 0xa6, 0x02, 0x80, 0xdd, 0x01, 0xb5, 0x04, 0xfa, 0x29, 0xa7, 0x40, 0xed, - 0x77, 0xa7, 0x00, 0x05, 0x72, 0x07, 0x01, 0xff, 0xe1, 0x50, 0x02, 0x80, - 0xbe, 0x01, 0x45, 0x9e, 0xe5, 0x8d, 0x01, 0x00, 0xe5, 0xdd, 0x01, 0x00, - 0xe7, 0x77, 0x1d, 0x00, 0xe8, 0x65, 0x02, 0x80, 0x9d, 0x01, 0xe9, 0x09, - 0x1d, 0x80, 0x91, 0x01, 0xeb, 0x9e, 0x02, 0x00, 0xec, 0x81, 0xa7, 0x00, - 0xed, 0x6f, 0x02, 0x80, 0x7e, 0xaf, 0x53, 0xf2, 0x79, 0x02, 0x80, 0x24, - 0xf4, 0x87, 0x02, 0x80, 0x19, 0x42, 0x3e, 0x00, 0x51, 0xab, 0x00, 0xf6, - 0x8c, 0x02, 0x00, 0xf7, 0x8d, 0x02, 0x00, 0xf9, 0x8e, 0x02, 0xc0, 0x00, - 0x4a, 0x76, 0xa6, 0x06, 0xdf, 0x41, 0x4a, 0xbd, 0x48, 0x0d, 0xdf, 0x41, - 0x06, 0x50, 0x00, 0x01, 0xff, 0x44, 0xac, 0x0e, 0x7b, 0x02, 0x00, 0x48, - 0x98, 0x75, 0x7a, 0x02, 0x80, 0x12, 0x4c, 0x30, 0x23, 0x68, 0xab, 0x00, - 0x4c, 0xfa, 0x56, 0x15, 0xdf, 0x01, 0x44, 0x8f, 0x17, 0x79, 0x2c, 0x40, - 0x53, 0x5e, 0x47, 0x08, 0xdf, 0x41, 0x47, 0x8c, 0xcd, 0x43, 0xab, 0x80, - 0x1c, 0xe5, 0x14, 0x1d, 0x80, 0x06, 0x45, 0x3a, 0x29, 0x08, 0x1d, 0x40, - 0x06, 0x50, 0x00, 0x01, 0xff, 0x51, 0x47, 0x05, 0x42, 0xab, 0x00, 0x46, - 0x52, 0x05, 0x41, 0xab, 0x40, 0x4c, 0xf5, 0x28, 0x44, 0xab, 0x40, 0x4e, - 0x92, 0x75, 0x70, 0x02, 0x40, 0x48, 0x1c, 0x70, 0x7f, 0xa7, 0x40, 0x4e, - 0x32, 0x72, 0xae, 0x02, 0xc0, 0x00, 0x49, 0x5c, 0xb4, 0xaf, 0x02, 0x40, - 0xe5, 0x02, 0x1d, 0x00, 0x44, 0x5f, 0xe4, 0x52, 0x02, 0x40, 0x54, 0x9c, - 0x0e, 0x67, 0xab, 0x40, 0x03, 0xef, 0x07, 0x06, 0x48, 0x78, 0xbd, 0x16, - 0x1d, 0x40, 0x44, 0x80, 0x11, 0xbd, 0x01, 0x00, 0x43, 0x1b, 0x26, 0x85, - 0x01, 0x00, 0x43, 0x1f, 0x0a, 0xa8, 0x01, 0x40, 0x53, 0xbd, 0x47, 0x7a, - 0x1d, 0x00, 0x43, 0x28, 0x05, 0xfe, 0x00, 0xc0, 0x00, 0x4c, 0xf5, 0x28, - 0x65, 0xa7, 0xc0, 0x00, 0x52, 0x2f, 0x2b, 0x67, 0xa7, 0x40, 0x06, 0x50, - 0x00, 0x01, 0xff, 0x4c, 0xfa, 0x56, 0x17, 0xdf, 0x01, 0x4e, 0xa2, 0x0e, - 0x1c, 0xdf, 0x41, 0xa3, 0x58, 0xa4, 0x35, 0x44, 0xac, 0x0e, 0xad, 0x01, - 0x80, 0x28, 0x4a, 0xa4, 0x6d, 0x6f, 0x1e, 0x00, 0x03, 0x7d, 0x02, 0x12, - 0x4c, 0xfa, 0x56, 0xab, 0x01, 0x00, 0x4e, 0xa2, 0x0e, 0x88, 0x02, 0x00, - 0x46, 0x52, 0x05, 0x67, 0x01, 0x40, 0x51, 0xb0, 0x57, 0x2a, 0xdf, 0x01, - 0x49, 0x33, 0x23, 0x75, 0x1d, 0x40, 0x53, 0x5e, 0x47, 0x09, 0xdf, 0x41, - 0x02, 0x1b, 0x01, 0x11, 0x03, 0x04, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, - 0x6b, 0x1e, 0x00, 0x45, 0x20, 0x07, 0x6d, 0x1e, 0x40, 0x46, 0xbc, 0x23, - 0x97, 0x1e, 0x00, 0x4c, 0xab, 0x3f, 0x66, 0x2c, 0x40, 0x44, 0xee, 0x6c, - 0x65, 0x01, 0x00, 0x46, 0x1b, 0xc2, 0x63, 0x01, 0x00, 0x4f, 0xf8, 0x6e, - 0x71, 0x1e, 0x00, 0x4a, 0xe6, 0xae, 0x1b, 0x02, 0x00, 0x43, 0x73, 0x0b, - 0x36, 0x02, 0x40, 0x06, 0x50, 0x00, 0x82, 0x01, 0xa1, 0x74, 0xa3, 0x3f, - 0x46, 0x17, 0xb1, 0xdf, 0x00, 0x00, 0xa9, 0x0c, 0x51, 0x77, 0x5d, 0x85, - 0x02, 0x00, 0x48, 0xb1, 0xcb, 0x45, 0xab, 0x40, 0x07, 0xf9, 0x45, 0x06, - 0x47, 0x12, 0xc7, 0xd9, 0xa7, 0x40, 0x4d, 0xfd, 0x81, 0x1e, 0x1d, 0x00, - 0xef, 0x11, 0x1d, 0x80, 0x0a, 0x48, 0xf1, 0xcb, 0x1f, 0x1d, 0x00, 0xf5, - 0x1d, 0x1d, 0x40, 0x4c, 0xf5, 0x28, 0x13, 0x1d, 0x00, 0x45, 0xf4, 0xe9, - 0x12, 0x1d, 0x40, 0x43, 0xcb, 0x7b, 0x59, 0x02, 0x80, 0x1b, 0x05, 0x76, - 0x06, 0x01, 0xff, 0xe7, 0x61, 0x02, 0x80, 0x0b, 0xf2, 0x4b, 0xab, 0xc0, - 0x00, 0x4a, 0xb2, 0xa6, 0x4c, 0xab, 0x40, 0x52, 0xca, 0x4f, 0x36, 0xab, - 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x44, 0xac, 0x0e, 0x5a, 0x02, 0x00, - 0x4e, 0xa2, 0x0e, 0x95, 0x1d, 0x40, 0x47, 0x7f, 0xd2, 0x60, 0xab, 0x00, - 0x46, 0xcf, 0xce, 0x8c, 0xa7, 0x40, 0x45, 0x14, 0x39, 0x5b, 0x01, 0x80, - 0x78, 0xa3, 0x51, 0xa4, 0x31, 0x44, 0xac, 0x0e, 0x82, 0x02, 0x00, 0x03, - 0x7d, 0x02, 0x1b, 0x4e, 0x55, 0x43, 0xa9, 0xa7, 0x00, 0x4c, 0xfa, 0x56, - 0x8a, 0x1d, 0x00, 0xb3, 0x01, 0xff, 0x53, 0xf7, 0x49, 0xca, 0xa7, 0x00, - 0x49, 0x5e, 0xc1, 0x3f, 0x02, 0x40, 0x51, 0xb0, 0x57, 0x29, 0xdf, 0x01, - 0x49, 0x33, 0x23, 0x74, 0x1d, 0x40, 0x4e, 0xa9, 0x3f, 0xcd, 0xa7, 0x00, - 0x03, 0x04, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x61, 0x1e, 0x00, 0x45, - 0x20, 0x07, 0x63, 0x1e, 0xc0, 0x00, 0x4e, 0x51, 0x1e, 0x69, 0x1e, 0x40, - 0x44, 0xee, 0x6c, 0x61, 0x01, 0x80, 0x18, 0x46, 0x1b, 0xc2, 0x5f, 0x01, - 0x00, 0x49, 0xd0, 0x04, 0x5d, 0x01, 0x00, 0x4a, 0xe6, 0xae, 0x19, 0x02, - 0x00, 0x43, 0x73, 0x0b, 0x1e, 0xdf, 0x41, 0x4e, 0x51, 0x1e, 0x67, 0x1e, - 0x40, 0x4e, 0x51, 0x1e, 0x65, 0x1e, 0x40, 0x80, 0x5b, 0x48, 0x69, 0xc3, - 0x64, 0x02, 0x00, 0x08, 0xde, 0x14, 0x0d, 0x42, 0x48, 0x04, 0x75, 0xa7, - 0xc0, 0x00, 0x48, 0xbc, 0xb2, 0x5d, 0xa7, 0x40, 0xe3, 0x84, 0x21, 0x80, - 0x39, 0xe5, 0x58, 0x02, 0x80, 0x2e, 0x46, 0x5e, 0xdc, 0xf6, 0xa7, 0x00, - 0xeb, 0x03, 0xdf, 0x01, 0x46, 0x39, 0x29, 0x5c, 0x02, 0x80, 0x0c, 0x4f, - 0x31, 0x72, 0x7f, 0x02, 0x00, 0x48, 0xd1, 0xca, 0x01, 0xdf, 0x41, 0x06, - 0x50, 0x00, 0x01, 0xff, 0x44, 0xac, 0x0e, 0x5d, 0x02, 0x00, 0x4e, 0xa2, - 0x0e, 0x94, 0x1d, 0x40, 0x42, 0x1d, 0x01, 0x07, 0xdf, 0x41, 0x49, 0x90, - 0x3b, 0x3f, 0xa7, 0x40, 0x47, 0xbd, 0xb2, 0x5b, 0xa7, 0x00, 0x04, 0x51, - 0x00, 0x01, 0xff, 0x80, 0x06, 0x4a, 0x04, 0x51, 0x47, 0xab, 0x40, 0x45, - 0x14, 0x39, 0x55, 0x01, 0x00, 0xa3, 0x75, 0x02, 0x3b, 0x01, 0x54, 0x48, - 0x38, 0x72, 0x7e, 0x02, 0x80, 0x3c, 0x4e, 0x60, 0x23, 0x13, 0x02, 0x00, - 0xac, 0x28, 0x03, 0x7d, 0x02, 0x18, 0x4e, 0x55, 0x43, 0xa7, 0xa7, 0x00, - 0x4c, 0xfa, 0x56, 0x89, 0x1d, 0x00, 0x46, 0x52, 0x05, 0x4d, 0x02, 0x00, - 0x44, 0x8f, 0x17, 0x7d, 0x02, 0x40, 0x51, 0xb0, 0x57, 0x28, 0xdf, 0x01, - 0x49, 0x33, 0x23, 0x72, 0x1d, 0x40, 0x49, 0xa5, 0x6d, 0x5f, 0x1e, 0x00, - 0x47, 0x99, 0x75, 0x7c, 0x02, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x4c, - 0x30, 0x23, 0x73, 0x1d, 0x00, 0x4c, 0xfa, 0x56, 0x16, 0xdf, 0x41, 0x02, - 0xc6, 0x00, 0x06, 0x4a, 0x12, 0x23, 0x11, 0x02, 0x40, 0x45, 0x5c, 0x00, - 0x59, 0x1e, 0x00, 0x45, 0x20, 0x07, 0x5b, 0x1e, 0xc0, 0x00, 0x4b, 0x74, - 0x97, 0x5d, 0x1e, 0x40, 0x44, 0xee, 0x6c, 0x59, 0x01, 0x00, 0x46, 0x1b, - 0xc2, 0x57, 0x01, 0x00, 0x4b, 0xd1, 0x4f, 0x49, 0xab, 0x40, 0x06, 0x50, - 0x00, 0x06, 0x49, 0xec, 0xbd, 0x39, 0x02, 0x40, 0x4f, 0xa8, 0x3f, 0x59, - 0xa7, 0x00, 0x44, 0xac, 0x0e, 0xa0, 0x02, 0x80, 0x06, 0x58, 0x29, 0x2b, - 0x57, 0xa7, 0x40, 0x45, 0xde, 0x47, 0x4b, 0x02, 0x40, 0x06, 0x50, 0x00, - 0x0d, 0xa8, 0x01, 0xff, 0x59, 0x1d, 0x1d, 0xcf, 0xa7, 0x00, 0xe9, 0x78, - 0x02, 0x40, 0x45, 0x14, 0x39, 0x55, 0x1e, 0x00, 0x49, 0x56, 0x1e, 0x57, - 0x1e, 0x00, 0x48, 0x51, 0xc6, 0x53, 0xa7, 0x00, 0x44, 0xac, 0x0e, 0xa5, - 0x01, 0x00, 0x4c, 0x30, 0x23, 0x71, 0x1d, 0x00, 0x4c, 0xfa, 0x56, 0x88, - 0x1d, 0x00, 0xb3, 0x01, 0xff, 0x4c, 0x20, 0x94, 0x55, 0xa7, 0x00, 0x45, - 0x53, 0x05, 0x7d, 0x1d, 0xc0, 0x00, 0x52, 0x2f, 0x2b, 0x51, 0xa7, 0x40, - 0x06, 0x50, 0x00, 0x40, 0xe9, 0xa3, 0x01, 0x00, 0x4b, 0x80, 0x9e, 0xc1, - 0xa7, 0x00, 0x44, 0xe1, 0x7b, 0xb7, 0xa7, 0x00, 0xef, 0x4f, 0xa7, 0x00, - 0x04, 0xf7, 0x04, 0x04, 0xf5, 0x23, 0x02, 0x40, 0xe5, 0x5b, 0x02, 0x80, - 0x19, 0xef, 0x54, 0x02, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x04, 0xe5, 0x62, - 0xab, 0x40, 0x4e, 0xa2, 0x0e, 0x97, 0x1d, 0x00, 0x46, 0x52, 0x05, 0x3f, - 0xab, 0x40, 0x54, 0x9c, 0x0e, 0x93, 0x1d, 0x40, 0x45, 0x14, 0x39, 0xf3, - 0x00, 0x00, 0x45, 0x55, 0x23, 0x4f, 0x01, 0x00, 0xa3, 0xe7, 0x01, 0xa4, - 0xac, 0x01, 0x45, 0x17, 0x23, 0xf2, 0x00, 0x00, 0x02, 0x0b, 0x00, 0x72, - 0x4e, 0x60, 0x23, 0x0f, 0x02, 0x00, 0x02, 0x13, 0x01, 0x56, 0x46, 0xb4, - 0x70, 0x4d, 0x01, 0x80, 0x3e, 0x46, 0xda, 0xde, 0xeb, 0x01, 0x80, 0x31, - 0x4e, 0xa2, 0x0e, 0x1b, 0xdf, 0x01, 0x46, 0x52, 0x05, 0xf8, 0x00, 0x80, - 0x1e, 0x45, 0x37, 0x23, 0xf5, 0x00, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, - 0xff, 0x45, 0x14, 0x39, 0x4d, 0x1e, 0x00, 0x49, 0xb9, 0x23, 0x4f, 0x1e, - 0x00, 0x46, 0xb4, 0x70, 0x2d, 0x02, 0x40, 0x4a, 0xb8, 0xa5, 0xff, 0x01, - 0x40, 0x4b, 0x74, 0x97, 0xed, 0x01, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, - 0x45, 0x14, 0x39, 0x53, 0x1e, 0x00, 0x45, 0x17, 0x23, 0x51, 0x1e, 0x40, - 0x51, 0xcd, 0x5c, 0x4b, 0xa7, 0x00, 0x42, 0x1f, 0x00, 0x4d, 0xa7, 0x00, - 0x4d, 0x78, 0x8a, 0x7a, 0x2c, 0x40, 0x48, 0x5a, 0xab, 0xcf, 0x1e, 0x00, - 0x42, 0x5e, 0x01, 0xa1, 0x01, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, - 0x45, 0x14, 0x39, 0xdb, 0x1e, 0x00, 0x49, 0x9f, 0x12, 0xe3, 0x1e, 0x00, - 0x45, 0x17, 0x23, 0xdd, 0x1e, 0x00, 0x4a, 0x58, 0xab, 0xdf, 0x1e, 0x00, - 0x45, 0x37, 0x23, 0xe1, 0x1e, 0x40, 0x48, 0xba, 0x23, 0xf6, 0x00, 0x80, - 0x2b, 0xaf, 0x01, 0xff, 0x02, 0xc6, 0x00, 0x11, 0x05, 0x3d, 0x01, 0x01, - 0xff, 0x45, 0x14, 0x39, 0x51, 0x01, 0x00, 0x45, 0x17, 0x23, 0x0d, 0x02, - 0x40, 0x45, 0x5c, 0x00, 0x2f, 0x02, 0x80, 0x06, 0x45, 0x20, 0x07, 0xcd, - 0x1e, 0x40, 0x4b, 0x74, 0x97, 0x31, 0x02, 0x40, 0x4b, 0x74, 0x97, 0x2b, - 0x02, 0x40, 0x44, 0xee, 0x6c, 0xd2, 0x01, 0x00, 0x49, 0xd0, 0x04, 0xf4, - 0x00, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0xd1, - 0x1e, 0x00, 0x49, 0x9f, 0x12, 0xd9, 0x1e, 0x00, 0x45, 0x17, 0x23, 0xd3, - 0x1e, 0x00, 0x4a, 0x58, 0xab, 0xd5, 0x1e, 0x00, 0x45, 0x37, 0x23, 0xd7, - 0x1e, 0x40, 0x80, 0x0a, 0xea, 0xcc, 0x01, 0x00, 0x42, 0x48, 0x04, 0x74, - 0xa7, 0x40, 0x56, 0x70, 0x36, 0x49, 0x01, 0x00, 0x05, 0x51, 0x00, 0x01, - 0xff, 0x45, 0x14, 0x39, 0x44, 0x01, 0x00, 0xa3, 0x5b, 0xa4, 0x42, 0x45, - 0x17, 0x23, 0xf9, 0x01, 0x00, 0xac, 0x28, 0x03, 0x7d, 0x02, 0x18, 0x4e, - 0x55, 0x43, 0xa5, 0xa7, 0x00, 0x4c, 0xfa, 0x56, 0x87, 0x1d, 0x00, 0x4e, - 0xa2, 0x0e, 0x73, 0x02, 0x00, 0x45, 0x37, 0x23, 0xf1, 0x00, 0x40, 0x51, - 0xb0, 0x57, 0x27, 0xdf, 0x01, 0x49, 0x33, 0x23, 0x70, 0x1d, 0x40, 0x48, - 0xb9, 0x57, 0x72, 0x02, 0x00, 0x49, 0xa5, 0x6d, 0x49, 0x1e, 0x00, 0x4d, - 0x04, 0x87, 0x9e, 0x01, 0x40, 0x48, 0x39, 0x2b, 0x91, 0xa7, 0x00, 0x03, - 0x04, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x45, 0x1e, 0x00, 0x45, 0x20, - 0x07, 0x47, 0x1e, 0x40, 0x44, 0xee, 0x6c, 0x48, 0x01, 0x00, 0x46, 0x1b, - 0xc2, 0x46, 0x01, 0x00, 0x4f, 0xf8, 0x6e, 0x4b, 0x1e, 0x00, 0x4b, 0xd1, - 0x4f, 0x3b, 0xab, 0x00, 0x43, 0x73, 0x0b, 0x35, 0x02, 0x40, 0x06, 0x50, - 0x00, 0x1f, 0x05, 0x7e, 0x02, 0x06, 0x42, 0x48, 0x04, 0x73, 0xa7, 0x40, - 0x48, 0xa9, 0xc2, 0xd7, 0xa7, 0x00, 0x07, 0x03, 0xce, 0x01, 0xff, 0x42, - 0x60, 0x07, 0xfb, 0x1e, 0x00, 0xf6, 0xfd, 0x1e, 0x40, 0x45, 0x14, 0x39, - 0x3f, 0x1e, 0x00, 0x4c, 0xd0, 0x4f, 0x3a, 0xab, 0x00, 0x04, 0x03, 0x0c, - 0x12, 0x44, 0xac, 0x0e, 0x71, 0x02, 0x00, 0x4c, 0x30, 0x23, 0x6f, 0x1d, - 0x00, 0x4c, 0xfa, 0x56, 0x86, 0x1d, 0x40, 0x45, 0x5c, 0x00, 0x41, 0x1e, - 0x00, 0x45, 0x20, 0x07, 0x43, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x58, 0x45, - 0x63, 0xe4, 0xdb, 0xa7, 0x80, 0x4b, 0xa5, 0x36, 0xea, 0xc9, 0x01, 0x00, - 0x45, 0x75, 0xad, 0x7f, 0x01, 0x80, 0x12, 0x49, 0x39, 0xbf, 0xaa, 0x02, - 0x00, 0x42, 0x48, 0x04, 0x72, 0xa7, 0x00, 0x49, 0xd3, 0xc1, 0xab, 0x02, - 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0xa4, 0x06, 0x4b, 0x0a, 0x9d, 0x9d, - 0x1e, 0x40, 0x4e, 0xa9, 0x3f, 0x9c, 0x1e, 0x00, 0x48, 0x57, 0x1e, 0x9b, - 0x1e, 0x40, 0x45, 0x45, 0xe9, 0x35, 0xab, 0x00, 0x42, 0x6f, 0x28, 0x6e, - 0x02, 0xc0, 0x00, 0x54, 0x9c, 0x0e, 0x05, 0xdf, 0x41, 0x4c, 0xf5, 0x28, - 0x9b, 0x01, 0x40, 0x45, 0x14, 0x39, 0x3a, 0x01, 0x00, 0xa2, 0x8e, 0x01, - 0xa3, 0x74, 0x02, 0x3b, 0x01, 0x52, 0x48, 0x38, 0x72, 0x11, 0xdf, 0x01, - 0x4b, 0x0a, 0x9d, 0x49, 0xa7, 0x00, 0x4f, 0xda, 0x6e, 0x37, 0xab, 0x00, - 0x4a, 0xa4, 0x6d, 0x3b, 0x1e, 0x00, 0x03, 0x7d, 0x02, 0x19, 0x4c, 0xfa, - 0x56, 0x85, 0x1d, 0x00, 0x4e, 0xa2, 0x0e, 0x6d, 0x02, 0x80, 0x06, 0x46, - 0x52, 0x05, 0x42, 0x01, 0x40, 0x49, 0x4a, 0xb4, 0x8e, 0xa7, 0x40, 0x51, - 0xb0, 0x57, 0x26, 0xdf, 0x01, 0x04, 0x80, 0x02, 0x01, 0xff, 0x43, 0x23, - 0x0a, 0x40, 0x01, 0x00, 0x44, 0x22, 0x08, 0x39, 0xab, 0x00, 0x45, 0x37, - 0x23, 0x6b, 0x02, 0x40, 0x47, 0xa1, 0x12, 0x37, 0x1e, 0x80, 0x11, 0x05, - 0x3d, 0x01, 0x01, 0xff, 0x43, 0x16, 0x00, 0x61, 0x2c, 0x00, 0x4c, 0x30, - 0x23, 0x38, 0xab, 0x40, 0x4b, 0x74, 0x97, 0x39, 0x1e, 0x40, 0x44, 0xee, - 0x6c, 0x3e, 0x01, 0x00, 0x46, 0x1b, 0xc2, 0x3c, 0x01, 0x00, 0x4f, 0xf8, - 0x6e, 0x3d, 0x1e, 0x00, 0x43, 0x73, 0x0b, 0x34, 0x02, 0x40, 0x42, 0x17, - 0x00, 0x9a, 0x01, 0x00, 0x43, 0xfe, 0xa3, 0x6c, 0x02, 0xc0, 0x00, 0x51, - 0xf5, 0x56, 0x13, 0xdf, 0x41, 0x06, 0x50, 0x00, 0x06, 0x42, 0x71, 0x00, - 0x38, 0x01, 0x40, 0x45, 0x14, 0x39, 0x31, 0x1e, 0x00, 0xa3, 0x39, 0xa4, - 0x25, 0x44, 0xac, 0x0e, 0x99, 0x01, 0x00, 0x4a, 0xa4, 0x6d, 0x35, 0x1e, - 0x00, 0x4e, 0x55, 0x43, 0xa3, 0xa7, 0x00, 0x4c, 0xfa, 0x56, 0x84, 0x1d, - 0x00, 0x46, 0x52, 0x05, 0x41, 0xa7, 0xc0, 0x00, 0x54, 0xa3, 0x3f, 0x45, - 0xa7, 0x40, 0x48, 0x39, 0x2b, 0x6a, 0x2c, 0x00, 0x4e, 0xa9, 0x3f, 0x43, - 0xa7, 0x00, 0x48, 0xa0, 0x12, 0x33, 0x1e, 0x40, 0x44, 0xee, 0x6c, 0xe9, - 0x01, 0x00, 0x46, 0x1b, 0xc2, 0x37, 0x01, 0x40, 0x06, 0x50, 0x00, 0x01, - 0xff, 0xa3, 0x06, 0x46, 0x52, 0x05, 0x49, 0x02, 0x40, 0x44, 0xee, 0x6c, - 0xf0, 0x01, 0x00, 0x49, 0xd0, 0x04, 0x35, 0x01, 0x00, 0x4b, 0xd1, 0x4f, - 0x9d, 0x02, 0x40, 0x06, 0x50, 0x00, 0x48, 0xae, 0x19, 0x02, 0x1b, 0x05, - 0x04, 0xf3, 0x6d, 0xa7, 0x40, 0xe1, 0x69, 0x02, 0x80, 0x06, 0x47, 0xea, - 0x88, 0x61, 0xab, 0x40, 0x4c, 0xf5, 0x28, 0x7c, 0x1d, 0x40, 0x06, 0x1d, - 0x70, 0x11, 0x07, 0x62, 0x23, 0x01, 0xff, 0x45, 0x5e, 0xe4, 0x64, 0xab, - 0x00, 0x42, 0x67, 0x51, 0x40, 0xab, 0x40, 0xe4, 0x7a, 0xa7, 0x00, 0xe6, - 0x7c, 0xa7, 0x00, 0xe7, 0x79, 0x1d, 0x00, 0xf2, 0x83, 0xa7, 0x00, 0xf3, - 0x85, 0xa7, 0x00, 0xf4, 0x87, 0xa7, 0x40, 0x45, 0x14, 0x39, 0xed, 0x00, - 0x00, 0x45, 0x55, 0x23, 0x2d, 0x01, 0x00, 0xa3, 0x5c, 0xa4, 0x3e, 0x45, - 0x17, 0x23, 0xec, 0x00, 0x00, 0x4a, 0x58, 0xab, 0xc9, 0x1e, 0x00, 0x4e, - 0x60, 0x23, 0x0b, 0x02, 0x00, 0x46, 0xb4, 0x70, 0x2b, 0x01, 0x00, 0x46, - 0xda, 0xde, 0x2f, 0x01, 0x00, 0x4e, 0xa2, 0x0e, 0x96, 0x1d, 0x00, 0x46, - 0x52, 0x05, 0x68, 0x02, 0x80, 0x0d, 0x45, 0x37, 0x23, 0x29, 0x01, 0xc0, - 0x00, 0x46, 0x1f, 0x07, 0x2d, 0x1e, 0x40, 0x53, 0x5e, 0x47, 0x1a, 0xdf, - 0x41, 0x48, 0xba, 0x23, 0xef, 0x00, 0x80, 0x0f, 0xaf, 0x01, 0xff, 0x47, - 0xa1, 0x12, 0xcb, 0x1e, 0x00, 0x4a, 0x12, 0x23, 0x09, 0x02, 0x40, 0x4a, - 0xb8, 0xa5, 0x2f, 0x1e, 0x40, 0x44, 0xee, 0x6c, 0xd0, 0x01, 0x00, 0x49, - 0xd0, 0x04, 0xee, 0x00, 0x40, 0x06, 0x50, 0x00, 0x17, 0x45, 0x5f, 0xdc, - 0x76, 0x2c, 0x00, 0x43, 0x4c, 0x0a, 0x27, 0xa7, 0x80, 0x04, 0xf6, 0x95, - 0x01, 0x40, 0x4a, 0xc2, 0x24, 0x67, 0x02, 0x40, 0x4b, 0xdc, 0x99, 0x2b, - 0x1e, 0x00, 0xa3, 0x37, 0xa4, 0x18, 0x44, 0xac, 0x0e, 0x66, 0x02, 0x00, - 0x4a, 0xa4, 0x6d, 0x96, 0x1e, 0x00, 0x4c, 0xfa, 0x56, 0x95, 0xa7, 0x00, - 0x46, 0x52, 0x05, 0x27, 0x01, 0x40, 0x48, 0x39, 0x2b, 0x68, 0x2c, 0x00, - 0x48, 0xba, 0x23, 0x27, 0x1e, 0x00, 0x03, 0x04, 0x0c, 0x01, 0xff, 0x45, - 0x5c, 0x00, 0x23, 0x1e, 0x00, 0x45, 0x20, 0x07, 0x25, 0x1e, 0x40, 0x44, - 0xee, 0x6c, 0x1f, 0x02, 0x00, 0x46, 0x1b, 0xc2, 0x29, 0x1e, 0x00, 0x49, - 0xd0, 0x04, 0x25, 0x01, 0x40, 0x06, 0x50, 0x00, 0x23, 0x44, 0x02, 0x21, - 0x63, 0x02, 0x00, 0x42, 0x22, 0x00, 0xa3, 0x01, 0x00, 0x07, 0xea, 0x28, + 0xef, 0x53, 0x1d, 0x40, 0x44, 0xde, 0x0b, 0xf1, 0xdf, 0x01, 0xac, 0x0c, + 0x4c, 0x47, 0x3d, 0xf7, 0xdf, 0x01, 0x4e, 0x51, 0x0f, 0xaf, 0x1d, 0x40, + 0x48, 0x8f, 0x46, 0xae, 0x1d, 0x00, 0x4d, 0x4d, 0x8b, 0xdc, 0xdf, 0x41, + 0x4a, 0x15, 0x26, 0xac, 0x1d, 0x40, 0x06, 0x50, 0x00, 0x1f, 0x43, 0xd9, + 0x95, 0x9e, 0x07, 0x81, 0x12, 0x4a, 0x18, 0xb1, 0xf9, 0xa7, 0x00, 0x49, + 0xe8, 0xc4, 0x99, 0x07, 0x01, 0x49, 0x79, 0xc7, 0x9a, 0x07, 0x41, 0x54, + 0x4b, 0x0f, 0x9f, 0x07, 0x41, 0xa2, 0x2b, 0x44, 0xde, 0x0b, 0xf0, 0xdf, + 0x01, 0x4f, 0xf7, 0x71, 0x5d, 0xab, 0x00, 0x4c, 0x6a, 0x24, 0x5e, 0xab, + 0x00, 0x4c, 0x47, 0x3d, 0xaa, 0x1d, 0x00, 0x4e, 0x51, 0x0f, 0xa9, 0x1d, + 0x80, 0x06, 0x46, 0x52, 0x05, 0xd5, 0xdf, 0x41, 0x49, 0x5a, 0x32, 0x9d, + 0x07, 0x41, 0x42, 0x17, 0x00, 0xd6, 0xdf, 0x01, 0x43, 0x60, 0x32, 0x9b, + 0x07, 0x41, 0x4a, 0x15, 0x26, 0xfb, 0xdf, 0x41, 0x06, 0x50, 0x00, 0x01, + 0xff, 0x4c, 0x13, 0x52, 0xa8, 0x1d, 0x00, 0x46, 0x52, 0x05, 0xd9, 0xdf, + 0x41, 0x4c, 0x78, 0x2a, 0xa4, 0x1d, 0x00, 0x43, 0x1b, 0x05, 0xa5, 0x1d, + 0x40, 0x06, 0x50, 0x00, 0x0d, 0x43, 0x95, 0x0a, 0x5c, 0xab, 0xc0, 0x00, + 0x4a, 0x15, 0x26, 0x97, 0x07, 0x41, 0x44, 0x5b, 0x0f, 0xb1, 0x02, 0x00, + 0x4c, 0x47, 0x3d, 0xf6, 0xdf, 0x01, 0x46, 0x52, 0x05, 0x95, 0x07, 0x41, + 0x06, 0x50, 0x00, 0x26, 0x44, 0x23, 0x22, 0xe0, 0x02, 0x00, 0x05, 0x0e, + 0x30, 0x01, 0xff, 0x45, 0xad, 0x5a, 0x5e, 0x1d, 0x00, 0x45, 0x37, 0x92, + 0xf4, 0xdf, 0x01, 0xb0, 0x01, 0xff, 0x42, 0x49, 0x00, 0x60, 0x1d, 0x00, + 0x42, 0x5a, 0x03, 0xf3, 0xdf, 0x41, 0x44, 0x5b, 0x0f, 0x93, 0x07, 0x01, + 0x46, 0x52, 0x05, 0xd4, 0xdf, 0x41, 0x4b, 0xd4, 0xa0, 0x90, 0x07, 0x41, + 0x42, 0x1d, 0x01, 0x51, 0x1d, 0x00, 0x42, 0xa4, 0x02, 0xb4, 0x1d, 0x80, + 0x1e, 0x42, 0x53, 0x00, 0x9e, 0x1d, 0x00, 0x42, 0xc2, 0x29, 0xbe, 0x1d, + 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x44, 0xde, 0x0b, 0xe6, 0xdf, + 0x01, 0x4e, 0x51, 0x0f, 0xe7, 0xdf, 0x41, 0x06, 0x50, 0x00, 0x01, 0xff, + 0x44, 0xde, 0x0b, 0xe2, 0xdf, 0x01, 0x4a, 0xe9, 0x52, 0xbf, 0x07, 0x01, + 0x4e, 0x51, 0x0f, 0xe3, 0xdf, 0x41, 0x06, 0x50, 0x00, 0x4b, 0x49, 0x03, + 0xbc, 0xde, 0xdf, 0x01, 0xa5, 0x25, 0x54, 0xfb, 0x46, 0xa1, 0x1d, 0x80, + 0x18, 0x49, 0x79, 0xc7, 0x87, 0x07, 0xc1, 0x00, 0x06, 0x50, 0x00, 0x01, + 0xff, 0x44, 0xde, 0x0b, 0x89, 0x07, 0x01, 0x4e, 0x51, 0x0f, 0x88, 0x07, + 0x41, 0x49, 0xfc, 0x24, 0x98, 0x07, 0x41, 0x43, 0x6b, 0x1a, 0x5f, 0x1d, + 0x00, 0x4a, 0xda, 0x95, 0x8a, 0x07, 0xc1, 0x00, 0x06, 0x50, 0x00, 0x01, + 0xff, 0x44, 0xde, 0x0b, 0xe0, 0xdf, 0x01, 0x4e, 0x51, 0x0f, 0xe1, 0xdf, + 0x41, 0x44, 0xde, 0x0b, 0xef, 0xdf, 0x01, 0x44, 0x5b, 0x0f, 0x8c, 0x07, + 0x81, 0x12, 0x4c, 0x47, 0x3d, 0xf5, 0xdf, 0x01, 0x46, 0x52, 0x05, 0xd3, + 0xdf, 0x01, 0x44, 0x79, 0x18, 0x8b, 0x07, 0x41, 0x49, 0xc3, 0xb9, 0x8d, + 0x07, 0x41, 0x06, 0x50, 0x00, 0x75, 0x07, 0x0c, 0x06, 0x17, 0x42, 0x49, + 0x00, 0x61, 0x1d, 0x00, 0x06, 0x82, 0x1c, 0x01, 0xff, 0x45, 0x37, 0x92, + 0xa4, 0x07, 0x01, 0x4f, 0xb7, 0x75, 0x8f, 0x07, 0x41, 0xe1, 0xe9, 0xdf, + 0x81, 0x51, 0xe2, 0x84, 0x07, 0x01, 0xe4, 0xe8, 0xdf, 0x01, 0xe5, 0xea, + 0xdf, 0x01, 0xe7, 0x92, 0x07, 0x81, 0x3a, 0xe8, 0x96, 0x07, 0x01, 0xe9, + 0xa6, 0x1d, 0x80, 0x25, 0xec, 0xab, 0x1d, 0x80, 0x1a, 0xee, 0xb0, 0x1d, + 0x00, 0x42, 0xce, 0x53, 0xa3, 0x07, 0x01, 0xf0, 0xd1, 0xdf, 0x01, 0xf2, + 0xaa, 0x07, 0x01, 0xf5, 0xb8, 0x1d, 0x00, 0xf9, 0xb2, 0x07, 0x41, 0x4a, + 0xa0, 0xab, 0x9c, 0x07, 0x41, 0x4c, 0x78, 0x2a, 0xa7, 0x1d, 0x00, 0x49, + 0x84, 0xc2, 0xb6, 0x02, 0x40, 0x4a, 0x15, 0x26, 0x94, 0x07, 0x41, 0xe1, + 0x80, 0x07, 0x41, 0x44, 0xde, 0x0b, 0x9d, 0x1d, 0x00, 0x44, 0x5b, 0x0f, + 0xfa, 0xdf, 0x41, 0x06, 0x50, 0x00, 0x1e, 0x06, 0xda, 0x84, 0x0c, 0x43, + 0x43, 0x10, 0x5d, 0x1d, 0x00, 0x4c, 0x60, 0x98, 0x55, 0x1d, 0x40, 0xef, + 0xb1, 0x1d, 0x00, 0x48, 0x8f, 0xd1, 0xd8, 0xdf, 0x01, 0xf7, 0xdb, 0xdf, + 0x41, 0x44, 0x5b, 0x0f, 0x85, 0x07, 0x01, 0x46, 0x52, 0x05, 0xd2, 0xdf, + 0x41, 0xe5, 0x83, 0x07, 0x01, 0x42, 0x9e, 0x01, 0x5c, 0x1d, 0x00, 0x44, + 0x40, 0xea, 0x45, 0x1d, 0x40, 0x43, 0xa9, 0x3a, 0xfd, 0x02, 0x00, 0x4f, + 0xa9, 0x74, 0x8a, 0xa7, 0x40, 0x06, 0x81, 0x11, 0x3d, 0xa5, 0x1d, 0x4a, + 0xbe, 0xb0, 0xde, 0x02, 0x00, 0x05, 0xc9, 0x00, 0x01, 0xff, 0x49, 0xe1, + 0x01, 0xc3, 0x02, 0x00, 0x49, 0xcc, 0x14, 0xbe, 0x02, 0x00, 0x44, 0x18, + 0x3b, 0x6b, 0xab, 0x40, 0x61, 0x3e, 0x0f, 0xb9, 0x07, 0x01, 0x07, 0xad, + 0x15, 0x01, 0xff, 0x45, 0x13, 0x05, 0xbd, 0x02, 0x00, 0x4c, 0x6c, 0x2a, + 0xc1, 0x02, 0xc0, 0x00, 0x4c, 0x78, 0x2a, 0xb4, 0x07, 0x41, 0x45, 0xb7, + 0x3d, 0xf8, 0x02, 0x00, 0x4a, 0xef, 0x43, 0x1c, 0xa7, 0x00, 0x50, 0xad, + 0x00, 0x1d, 0xa7, 0x00, 0x59, 0xbb, 0x25, 0x1e, 0xa7, 0x00, 0x48, 0xbb, + 0x58, 0x1b, 0xa7, 0x40, 0x48, 0x22, 0x75, 0xd6, 0x02, 0x00, 0x44, 0x0d, + 0x1c, 0xb9, 0x02, 0x40, 0x45, 0xd2, 0x73, 0xc9, 0x02, 0x00, 0xa9, 0x01, + 0xff, 0xa4, 0x06, 0x48, 0x7d, 0x9d, 0xd7, 0x02, 0x40, 0x80, 0x1b, 0x04, + 0x80, 0x02, 0x01, 0xff, 0x07, 0x3b, 0x01, 0x06, 0x4c, 0x51, 0x24, 0xf4, + 0x02, 0x40, 0x4c, 0xa4, 0x90, 0xf6, 0x02, 0x00, 0x4c, 0x51, 0x24, 0xf5, + 0x02, 0x40, 0x07, 0xd3, 0x20, 0x0c, 0x52, 0xc7, 0x55, 0x14, 0xa7, 0x00, + 0x48, 0xd1, 0x55, 0xe7, 0x02, 0x40, 0x52, 0xc7, 0x55, 0x0f, 0xa7, 0x00, + 0x48, 0xd1, 0x55, 0x0a, 0xa7, 0x40, 0x4c, 0x1f, 0x89, 0xb7, 0x07, 0x01, + 0x04, 0xc4, 0x00, 0x86, 0x01, 0x02, 0xd1, 0x00, 0x01, 0xff, 0x80, 0x06, + 0x55, 0x29, 0x3d, 0x1a, 0xa7, 0x40, 0x4c, 0xa4, 0x90, 0xcf, 0x02, 0x00, + 0x51, 0xcf, 0x04, 0x88, 0xa7, 0x00, 0x02, 0x3b, 0x01, 0x53, 0x4c, 0x51, + 0x24, 0xce, 0x02, 0x00, 0x59, 0xbb, 0x25, 0x1f, 0xa7, 0x00, 0x04, 0xc3, + 0x00, 0x30, 0x46, 0xd1, 0x73, 0xcd, 0x02, 0x00, 0x02, 0x0d, 0x00, 0x1a, + 0xb4, 0x0c, 0x4c, 0xbb, 0x58, 0xf0, 0x02, 0x00, 0x4d, 0x39, 0x0c, 0xcc, + 0x02, 0x40, 0x44, 0x72, 0x24, 0xf7, 0x02, 0x00, 0x47, 0xd2, 0x55, 0xe8, + 0x02, 0x40, 0x4d, 0xf5, 0x3f, 0xf2, 0x02, 0x00, 0x42, 0x1d, 0x01, 0xf3, + 0x02, 0x40, 0x46, 0xcd, 0x00, 0xff, 0x02, 0x80, 0x06, 0x4e, 0xcb, 0x55, + 0x15, 0xa7, 0x40, 0x44, 0xe6, 0x01, 0xf1, 0x02, 0x40, 0x05, 0xd5, 0x20, + 0x06, 0x4c, 0xf1, 0x43, 0xef, 0x02, 0x40, 0x52, 0xc7, 0x55, 0x10, 0xa7, + 0x00, 0x48, 0xd1, 0x55, 0x0b, 0xa7, 0x40, 0x49, 0xe1, 0x01, 0xc2, 0x02, + 0x00, 0x49, 0xcc, 0x14, 0xbf, 0x02, 0x00, 0x44, 0x18, 0x3b, 0x6a, 0xab, + 0x40, 0x54, 0xa8, 0x3d, 0xd1, 0x02, 0x00, 0x04, 0xb5, 0x0b, 0x01, 0xff, + 0x55, 0x5b, 0x3b, 0x8f, 0x20, 0x00, 0x07, 0xd3, 0x20, 0x0c, 0x52, 0xc7, + 0x55, 0x13, 0xa7, 0x00, 0x48, 0xd1, 0x55, 0xe6, 0x02, 0x40, 0x52, 0xc7, + 0x55, 0x0e, 0xa7, 0x00, 0x48, 0xd1, 0x55, 0x09, 0xa7, 0x40, 0x4b, 0xea, + 0xa0, 0xfc, 0x10, 0x00, 0x4b, 0x6d, 0x2a, 0xc0, 0x02, 0x80, 0x06, 0x4b, + 0x52, 0x24, 0xcb, 0x02, 0x40, 0x4c, 0x78, 0x2a, 0xb3, 0x07, 0x41, 0x03, + 0x1b, 0x00, 0x46, 0x05, 0x5a, 0xf2, 0x01, 0xff, 0x05, 0xb4, 0x0b, 0x21, + 0x04, 0x08, 0x05, 0x01, 0xff, 0x07, 0xd3, 0x20, 0x0c, 0x52, 0xc7, 0x55, + 0x16, 0xa7, 0x00, 0x48, 0xd1, 0x55, 0xe9, 0x02, 0x40, 0x52, 0xc7, 0x55, + 0x11, 0xa7, 0x00, 0x48, 0xd1, 0x55, 0x0c, 0xa7, 0x40, 0x07, 0xd3, 0x20, + 0x0c, 0x52, 0xc7, 0x55, 0x12, 0xa7, 0x00, 0x48, 0xd1, 0x55, 0xe5, 0x02, + 0x40, 0x52, 0xc7, 0x55, 0x0d, 0xa7, 0x00, 0x48, 0xd1, 0x55, 0x08, 0xa7, + 0x40, 0x49, 0x07, 0x45, 0xfa, 0x02, 0x00, 0x48, 0xa5, 0xba, 0xfc, 0x02, + 0x40, 0x4b, 0x91, 0x92, 0xb6, 0x07, 0x01, 0xaf, 0x01, 0xff, 0x02, 0xc6, + 0x00, 0x21, 0x05, 0x3d, 0x01, 0x11, 0x03, 0x6e, 0x15, 0x01, 0xff, 0x49, + 0xe1, 0x01, 0xc5, 0x02, 0x00, 0x44, 0x18, 0x3b, 0xd5, 0x02, 0x40, 0x4a, + 0x59, 0x38, 0xee, 0x02, 0x00, 0x45, 0x0c, 0x1c, 0xba, 0x02, 0x40, 0x4e, + 0x0b, 0x00, 0x19, 0xa7, 0x00, 0x45, 0xd6, 0x0e, 0x18, 0xa7, 0x00, 0x4c, + 0x32, 0x00, 0x17, 0xa7, 0x40, 0x07, 0x0c, 0x06, 0xcc, 0x02, 0x07, 0xd0, + 0x6b, 0xbb, 0x02, 0x0d, 0xd9, 0x87, 0xfd, 0x01, 0x50, 0xd0, 0x04, 0xc6, + 0x02, 0x00, 0x44, 0x1f, 0x13, 0x89, 0xa7, 0x00, 0x4b, 0x93, 0xa7, 0xdf, + 0x02, 0x00, 0x08, 0xb7, 0xd2, 0x01, 0xff, 0x42, 0x92, 0x01, 0x78, 0x1d, + 0x00, 0x49, 0x1b, 0xbf, 0x9c, 0xa6, 0x00, 0xb3, 0x01, 0xff, 0x05, 0x5e, + 0x07, 0x06, 0x48, 0x3c, 0x93, 0x9d, 0xa6, 0x40, 0xe1, 0x30, 0xe0, 0x01, + 0xa2, 0xb6, 0x01, 0x43, 0x3b, 0x15, 0x45, 0xe0, 0x01, 0xa4, 0xa3, 0x01, + 0xe5, 0x48, 0xe0, 0x81, 0x82, 0x01, 0x43, 0x82, 0x54, 0x33, 0xe0, 0x01, + 0x42, 0x22, 0x00, 0x43, 0xe0, 0x01, 0xe9, 0x38, 0xe0, 0x81, 0x6d, 0x42, + 0xa3, 0x21, 0x4d, 0xe0, 0x01, 0x42, 0x1b, 0x02, 0x39, 0xe0, 0x01, 0xef, + 0x3c, 0xe0, 0x01, 0xb0, 0x51, 0xb3, 0x36, 0xb4, 0x2a, 0xf5, 0x41, 0xe0, + 0x01, 0x42, 0x32, 0x00, 0x32, 0xe0, 0x01, 0xb9, 0x0d, 0xba, 0x01, 0xff, + 0xe5, 0x37, 0xe0, 0x01, 0x42, 0xb0, 0x01, 0x36, 0xe0, 0x41, 0x43, 0x3a, + 0x2d, 0x47, 0xe0, 0x81, 0x04, 0xf5, 0x49, 0xe0, 0x41, 0x4e, 0xbe, 0x78, + 0x6c, 0xe0, 0x41, 0xe5, 0x40, 0xe0, 0x01, 0x42, 0x46, 0x03, 0x44, 0xe0, + 0x41, 0x44, 0x82, 0x7f, 0x4b, 0xe0, 0x01, 0x42, 0x22, 0x00, 0x46, 0xe0, + 0x01, 0x49, 0xc0, 0xc5, 0x4f, 0xe0, 0xc1, 0x00, 0x4c, 0x78, 0x2a, 0x6d, + 0xe0, 0x41, 0x47, 0x80, 0xcf, 0x50, 0xe0, 0x01, 0xe5, 0x3d, 0xe0, 0x41, + 0xe5, 0x35, 0xe0, 0x41, 0xe6, 0x42, 0xe0, 0x01, 0xec, 0x3a, 0xe0, 0x01, + 0xed, 0x3b, 0xe0, 0x01, 0xf2, 0x3e, 0xe0, 0x01, 0xf3, 0x3f, 0xe0, 0xc1, + 0x00, 0x4f, 0xec, 0x11, 0x6b, 0xe0, 0x41, 0xe5, 0x34, 0xe0, 0x01, 0x43, + 0xe4, 0xfa, 0x4a, 0xe0, 0x41, 0x47, 0xc8, 0xd4, 0x4e, 0xe0, 0x01, 0xe5, + 0x31, 0xe0, 0x01, 0x57, 0xa9, 0x08, 0x4c, 0xe0, 0x41, 0x04, 0xf5, 0x16, + 0x1d, 0x03, 0x08, 0x06, 0x01, 0xff, 0x44, 0xc9, 0x31, 0x00, 0xa7, 0x00, + 0x42, 0x7c, 0x00, 0x04, 0xa7, 0x00, 0x42, 0x3d, 0x00, 0x06, 0xa7, 0x00, + 0x45, 0xbb, 0xf0, 0x02, 0xa7, 0x40, 0x44, 0xc9, 0x31, 0x01, 0xa7, 0x00, + 0x42, 0x7c, 0x00, 0x05, 0xa7, 0x00, 0x42, 0x3d, 0x00, 0x07, 0xa7, 0x00, + 0x45, 0xbb, 0xf0, 0x03, 0xa7, 0x40, 0x4e, 0xc7, 0x14, 0xd3, 0x02, 0x00, + 0x4f, 0xc6, 0x75, 0xd2, 0x02, 0x40, 0xe1, 0x2c, 0x1d, 0x80, 0x79, 0xe2, + 0x2e, 0x1d, 0x80, 0x6e, 0xe3, 0xf2, 0xa7, 0x00, 0xe4, 0x30, 0x1d, 0x00, + 0xe5, 0x31, 0x1d, 0x00, 0xe6, 0xf3, 0xa7, 0x00, 0xe7, 0x33, 0x1d, 0x00, + 0xe8, 0x34, 0x1d, 0x80, 0x4f, 0xe9, 0x35, 0x1d, 0x00, 0xea, 0x36, 0x1d, + 0x00, 0xeb, 0x37, 0x1d, 0x00, 0xec, 0x38, 0x1d, 0x00, 0xed, 0x39, 0x1d, + 0x00, 0xee, 0x3a, 0x1d, 0x00, 0xef, 0x3c, 0x1d, 0x80, 0x2e, 0xf0, 0x3e, + 0x1d, 0x00, 0xf1, 0xf4, 0xa7, 0x00, 0xf2, 0x3f, 0x1d, 0x80, 0x14, 0xf3, + 0xf1, 0xa7, 0x00, 0xf4, 0x40, 0x1d, 0x00, 0xf5, 0x41, 0x1d, 0x00, 0xf6, + 0x7d, 0x2c, 0x00, 0xf7, 0x42, 0x1d, 0x40, 0x08, 0xac, 0x15, 0x01, 0xff, + 0xe5, 0x32, 0x1d, 0x00, 0xee, 0x3b, 0x1d, 0x40, 0xf5, 0x3d, 0x1d, 0x40, + 0x4c, 0x78, 0x2a, 0xf8, 0xa7, 0x40, 0x47, 0xc1, 0xd4, 0x2f, 0x1d, 0x40, + 0xe5, 0x2d, 0x1d, 0x40, 0x05, 0xc1, 0x41, 0x06, 0x4d, 0x34, 0x88, 0xb5, + 0x07, 0x41, 0x49, 0x07, 0x45, 0xf9, 0x02, 0x00, 0x48, 0xa5, 0xba, 0xfb, + 0x02, 0x40, 0x4b, 0xa5, 0x90, 0xca, 0x02, 0x00, 0x4d, 0xa0, 0x89, 0xb8, + 0x07, 0x01, 0x49, 0x5a, 0x38, 0xbc, 0x02, 0x00, 0x0e, 0xa2, 0x7f, 0x01, + 0xff, 0x42, 0x4e, 0x00, 0x58, 0x05, 0x00, 0x43, 0x57, 0x07, 0x8b, 0x05, + 0x00, 0x42, 0xa0, 0x1b, 0x8c, 0x05, 0x40, 0x51, 0x5d, 0x5a, 0x43, 0x16, + 0x01, 0xa4, 0x89, 0x03, 0x07, 0x13, 0x06, 0x6d, 0x05, 0x5a, 0x03, 0x44, + 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xa1, 0x31, 0xe5, 0x39, 0x16, 0x01, 0xe9, + 0x31, 0x16, 0x81, 0x24, 0xef, 0x3b, 0x16, 0x01, 0xf5, 0x33, 0x16, 0x81, + 0x17, 0x08, 0xf2, 0xc6, 0x01, 0xff, 0xec, 0x37, 0x16, 0x81, 0x09, 0xf2, + 0x35, 0x16, 0xc1, 0x00, 0xf2, 0x36, 0x16, 0x41, 0xec, 0x38, 0x16, 0x41, + 0xf5, 0x34, 0x16, 0x41, 0xe9, 0x32, 0x16, 0x41, 0xe1, 0x30, 0x16, 0x01, + 0xe9, 0x3a, 0x16, 0x01, 0xf5, 0x3c, 0x16, 0x41, 0xa1, 0x17, 0x44, 0x48, + 0xf6, 0x44, 0x16, 0x01, 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0x21, 0x25, + 0x3f, 0x16, 0x01, 0x45, 0x49, 0x4e, 0x3e, 0x16, 0x41, 0x47, 0x0b, 0x17, + 0x3d, 0x16, 0x01, 0x4a, 0x96, 0xb5, 0x40, 0x16, 0x41, 0xe1, 0x00, 0x16, + 0x81, 0x86, 0x02, 0xa2, 0xf9, 0x01, 0xa3, 0xec, 0x01, 0xa4, 0xd3, 0x01, + 0xe5, 0x0a, 0x16, 0x01, 0xa7, 0xc2, 0x01, 0x42, 0x22, 0x00, 0x2e, 0x16, + 0x01, 0xe9, 0x02, 0x16, 0x81, 0xb2, 0x01, 0xaa, 0xa5, 0x01, 0xab, 0x98, + 0x01, 0xac, 0x8b, 0x01, 0x42, 0x6c, 0x00, 0x26, 0x16, 0x01, 0xae, 0x6d, + 0xef, 0x0c, 0x16, 0x01, 0xb0, 0x5d, 0x42, 0x71, 0x00, 0x28, 0x16, 0x01, + 0xb3, 0x45, 0xb4, 0x2c, 0xf5, 0x04, 0x16, 0x81, 0x23, 0xb6, 0x06, 0x42, + 0xdf, 0x23, 0x27, 0x16, 0x41, 0xe1, 0x2a, 0x16, 0x01, 0x07, 0xf3, 0xc6, + 0x01, 0xff, 0xec, 0x08, 0x16, 0x81, 0x09, 0xf2, 0x06, 0x16, 0xc1, 0x00, + 0xf2, 0x07, 0x16, 0x41, 0xec, 0x09, 0x16, 0x41, 0xf5, 0x05, 0x16, 0x41, + 0xe1, 0x1d, 0x16, 0x01, 0x42, 0x22, 0x00, 0x1e, 0x16, 0x01, 0xb4, 0x01, + 0xff, 0xe1, 0x18, 0x16, 0x01, 0x42, 0x22, 0x00, 0x19, 0x16, 0x41, 0xe1, + 0x2d, 0x16, 0x01, 0x42, 0x22, 0x00, 0x2b, 0x16, 0x01, 0x42, 0x40, 0x06, + 0x2c, 0x16, 0x41, 0xe1, 0x22, 0x16, 0x01, 0x42, 0x22, 0x00, 0x23, 0x16, + 0x41, 0xe1, 0x21, 0x16, 0x01, 0x42, 0x24, 0x02, 0x12, 0x16, 0x01, 0x42, + 0x2a, 0x05, 0x1c, 0x16, 0x01, 0x42, 0xdf, 0x23, 0x17, 0x16, 0x41, 0xe1, + 0x29, 0x16, 0x01, 0x42, 0x74, 0x00, 0x2f, 0x16, 0x41, 0xe1, 0x0e, 0x16, + 0x01, 0x42, 0x22, 0x00, 0x0f, 0x16, 0x41, 0xe1, 0x15, 0x16, 0x01, 0x42, + 0x22, 0x00, 0x16, 0x16, 0x41, 0xe9, 0x03, 0x16, 0x41, 0xe1, 0x10, 0x16, + 0x01, 0x42, 0x22, 0x00, 0x11, 0x16, 0x41, 0xe1, 0x1f, 0x16, 0x01, 0xa4, + 0x06, 0x42, 0x22, 0x00, 0x20, 0x16, 0x41, 0xe1, 0x1a, 0x16, 0x01, 0x42, + 0x22, 0x00, 0x1b, 0x16, 0x41, 0xe1, 0x13, 0x16, 0x01, 0x42, 0x22, 0x00, + 0x14, 0x16, 0x41, 0xe1, 0x24, 0x16, 0x01, 0x42, 0x22, 0x00, 0x25, 0x16, + 0x41, 0xe1, 0x01, 0x16, 0x01, 0xe9, 0x0b, 0x16, 0x01, 0xf5, 0x0d, 0x16, + 0x41, 0x44, 0x96, 0x21, 0x41, 0x16, 0x01, 0x05, 0xf0, 0x06, 0x06, 0x4b, + 0x33, 0xa6, 0x42, 0x16, 0x41, 0x45, 0x7e, 0x0b, 0x58, 0x16, 0x01, 0xa6, + 0x2e, 0x44, 0x6d, 0x2c, 0x59, 0x16, 0x01, 0x43, 0x7a, 0x0b, 0x51, 0x16, + 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x50, 0x16, 0x41, 0x44, + 0x25, 0x01, 0x53, 0x16, 0x01, 0x42, 0x15, 0x02, 0x52, 0x16, 0x41, 0x44, + 0x06, 0x1f, 0x57, 0x16, 0x01, 0x42, 0x09, 0x24, 0x56, 0x16, 0x41, 0x43, + 0xf9, 0x05, 0x55, 0x16, 0x01, 0x43, 0xf6, 0x06, 0x54, 0x16, 0x41, 0x42, + 0x1b, 0x08, 0xa7, 0x22, 0x00, 0x4d, 0x78, 0x8c, 0x3b, 0xf9, 0x41, 0x80, + 0x01, 0xff, 0x43, 0xfe, 0x83, 0xf4, 0xf4, 0x01, 0x5d, 0xaf, 0x17, 0xf2, + 0xf4, 0x41, 0x03, 0xc3, 0x7e, 0xe2, 0x01, 0x02, 0x75, 0x06, 0xb4, 0x01, + 0xa4, 0x84, 0x01, 0xac, 0x66, 0xae, 0x0d, 0x44, 0x38, 0x55, 0x9e, 0xfa, + 0xc1, 0x00, 0x45, 0xee, 0x1d, 0xa9, 0xfa, 0x41, 0xa9, 0x43, 0x02, 0xef, + 0x02, 0x04, 0xf9, 0xff, 0x29, 0x40, 0x80, 0x06, 0x4d, 0x0a, 0x84, 0x13, + 0x22, 0x40, 0x44, 0x5a, 0x03, 0x12, 0x22, 0x80, 0x06, 0x45, 0x71, 0x24, + 0x42, 0x22, 0x40, 0x80, 0x01, 0xff, 0x4b, 0x08, 0x20, 0x3a, 0x2a, 0x00, + 0x05, 0x51, 0x00, 0x01, 0xff, 0x4b, 0x8f, 0x61, 0x29, 0x2a, 0x00, 0x49, + 0x6d, 0x13, 0x2a, 0x2a, 0x00, 0x4c, 0x80, 0x93, 0x2b, 0x2a, 0x00, 0x4b, + 0x5c, 0xa7, 0x2c, 0x2a, 0x40, 0x43, 0x04, 0x29, 0x90, 0xf6, 0x01, 0x44, + 0x40, 0x67, 0xbd, 0xf4, 0x01, 0x44, 0x64, 0xe7, 0xd5, 0xf5, 0x41, 0x06, + 0xe4, 0x5e, 0x0c, 0x46, 0x78, 0xe3, 0x0c, 0xf3, 0x01, 0x46, 0x94, 0x4e, + 0xa5, 0x20, 0x40, 0x46, 0xa1, 0xc8, 0x96, 0xfa, 0x01, 0x45, 0x77, 0x74, + 0x96, 0xf3, 0x41, 0x04, 0x80, 0x02, 0x06, 0x58, 0x5c, 0x2b, 0xef, 0x22, + 0x40, 0x43, 0x48, 0x0a, 0xb7, 0x00, 0x00, 0x56, 0x19, 0x37, 0xe6, 0xfb, + 0x01, 0x57, 0x91, 0x32, 0xe7, 0xfb, 0x01, 0x06, 0xca, 0x8d, 0x01, 0xff, + 0x48, 0xaf, 0xcc, 0x0c, 0xcc, 0x01, 0x5a, 0xab, 0x23, 0xc2, 0xfb, 0x41, + 0x80, 0x1b, 0xaf, 0x01, 0xff, 0x45, 0x59, 0x03, 0xb5, 0x00, 0x00, 0x42, + 0xb7, 0x05, 0xa0, 0xf9, 0x01, 0x45, 0x3d, 0x3f, 0xa4, 0xf3, 0x01, 0x45, + 0x42, 0xd1, 0x2c, 0xf5, 0x41, 0x4b, 0xe2, 0x9f, 0x49, 0x24, 0x00, 0x4c, + 0x0c, 0x98, 0x48, 0x24, 0x40, 0x07, 0x13, 0x06, 0xbc, 0x02, 0x05, 0x5a, + 0x03, 0x9a, 0x02, 0x05, 0xc2, 0x2e, 0xfd, 0x01, 0x0b, 0xc7, 0x7a, 0x01, + 0xff, 0xe1, 0x54, 0x6f, 0x81, 0xce, 0x01, 0xe5, 0x5d, 0x6f, 0x81, 0xae, + 0x01, 0xe9, 0x61, 0x6f, 0x81, 0x7a, 0xee, 0x7d, 0x6f, 0x81, 0x71, 0xef, + 0x59, 0x6f, 0x81, 0x56, 0x4a, 0x36, 0xb6, 0x78, 0x6f, 0x81, 0x4b, 0xf5, + 0x6a, 0x6f, 0x81, 0x1e, 0x42, 0x07, 0x9c, 0x83, 0x6f, 0x01, 0xf7, 0x5c, + 0x6f, 0x81, 0x0f, 0xf9, 0x71, 0x6f, 0xc1, 0x00, 0xe9, 0x72, 0x6f, 0x01, + 0x42, 0x3e, 0x00, 0x80, 0x6f, 0x41, 0xef, 0x5b, 0x6f, 0x41, 0xe1, 0x6b, + 0x6f, 0x81, 0x1a, 0x42, 0x7e, 0x0b, 0x6f, 0x6f, 0x01, 0xe9, 0x87, 0x6f, + 0x01, 0x42, 0x1d, 0x01, 0x70, 0x6f, 0x01, 0x42, 0xc7, 0x19, 0x7f, 0x6f, + 0x01, 0xf5, 0x6e, 0x6f, 0x41, 0xee, 0x6c, 0x6f, 0xc1, 0x00, 0xe7, 0x6d, + 0x6f, 0x41, 0xf2, 0x76, 0x6f, 0x41, 0xa5, 0x0c, 0xe7, 0x81, 0x6f, 0x01, + 0xef, 0x5a, 0x6f, 0x01, 0xf5, 0x7c, 0x6f, 0x41, 0xf2, 0x82, 0x6f, 0x01, + 0xf9, 0x60, 0x6f, 0x41, 0xe7, 0x7e, 0x6f, 0x41, 0xe1, 0x62, 0x6f, 0x81, + 0x21, 0xe5, 0x66, 0x6f, 0x01, 0xe7, 0x84, 0x6f, 0x01, 0xe9, 0x67, 0x6f, + 0x01, 0x42, 0x1d, 0x01, 0x69, 0x6f, 0x01, 0xef, 0x65, 0x6f, 0x81, 0x04, + 0xf5, 0x68, 0x6f, 0x41, 0x42, 0x1d, 0x01, 0x86, 0x6f, 0x41, 0xee, 0x63, + 0x6f, 0xc1, 0x00, 0xe7, 0x64, 0x6f, 0x41, 0xe1, 0x85, 0x6f, 0x01, 0xe9, + 0x7a, 0x6f, 0x01, 0xee, 0x5e, 0x6f, 0x81, 0x09, 0xf2, 0x77, 0x6f, 0xc1, + 0x00, 0xf2, 0x75, 0x6f, 0x41, 0xe7, 0x5f, 0x6f, 0x41, 0xe1, 0x55, 0x6f, + 0x01, 0xe5, 0x73, 0x6f, 0x81, 0x17, 0x42, 0x26, 0x4c, 0x56, 0x6f, 0x01, + 0xe9, 0x79, 0x6f, 0x01, 0xee, 0x57, 0x6f, 0x81, 0x04, 0xf5, 0x7b, 0x6f, + 0x41, 0xe7, 0x58, 0x6f, 0x41, 0xe5, 0x74, 0x6f, 0x41, 0x45, 0x5c, 0x00, + 0x91, 0x6f, 0x01, 0x45, 0x20, 0x07, 0x92, 0x6f, 0x01, 0x45, 0xc8, 0x00, + 0x8f, 0x6f, 0x01, 0x49, 0x10, 0x77, 0x90, 0x6f, 0x41, 0x4a, 0x44, 0xad, + 0x51, 0x6f, 0x01, 0x56, 0xf3, 0x34, 0x4f, 0x6f, 0x01, 0x09, 0x73, 0xc4, + 0x01, 0xff, 0x4a, 0x44, 0xad, 0x53, 0x6f, 0x01, 0x47, 0x42, 0xdd, 0x52, + 0x6f, 0x41, 0xa1, 0x82, 0x04, 0xa2, 0xf5, 0x03, 0xa4, 0xc1, 0x03, 0x42, + 0x0c, 0x08, 0x07, 0x6f, 0x01, 0xa7, 0xa7, 0x03, 0xa8, 0x9a, 0x03, 0x42, + 0x1b, 0x02, 0x1e, 0x6f, 0x01, 0xac, 0xfb, 0x02, 0xad, 0xee, 0x02, 0xae, + 0xb5, 0x02, 0xb0, 0xa8, 0x02, 0xb1, 0x9b, 0x02, 0xb2, 0xec, 0x01, 0xb3, + 0xd3, 0x01, 0xb4, 0x7f, 0xb6, 0x73, 0x42, 0xa9, 0x01, 0x42, 0x6f, 0x01, + 0x42, 0x5b, 0x28, 0x27, 0x6f, 0x01, 0x03, 0xe3, 0x7d, 0x32, 0xba, 0x01, + 0xff, 0xe1, 0x3b, 0x6f, 0x01, 0x42, 0x22, 0x00, 0x35, 0x6f, 0x01, 0xb3, + 0x19, 0xba, 0x01, 0xff, 0xe1, 0x3d, 0x6f, 0x01, 0xb3, 0x06, 0x42, 0xdf, + 0x23, 0x40, 0x6f, 0x41, 0xe1, 0x3e, 0x6f, 0x01, 0x42, 0xdf, 0x23, 0x41, + 0x6f, 0x41, 0xe1, 0x3c, 0x6f, 0x01, 0x42, 0x22, 0x00, 0x36, 0x6f, 0x41, + 0x44, 0x74, 0xf5, 0x31, 0x6f, 0x01, 0x42, 0x1b, 0x02, 0x20, 0x6f, 0x01, + 0x43, 0x38, 0x48, 0x12, 0x6f, 0x01, 0x42, 0xe0, 0x09, 0x02, 0x6f, 0x01, + 0xb4, 0x01, 0xff, 0xe1, 0x0d, 0x6f, 0x01, 0xb3, 0x06, 0x42, 0x12, 0x00, + 0x0c, 0x6f, 0x41, 0xe1, 0x39, 0x6f, 0x01, 0x42, 0x22, 0x00, 0x30, 0x6f, + 0x41, 0xe1, 0x08, 0x6f, 0x01, 0x42, 0x0c, 0x08, 0x09, 0x6f, 0x41, 0xe1, + 0x0a, 0x6f, 0x01, 0xe5, 0x48, 0x6f, 0x01, 0x02, 0xcc, 0x05, 0x3c, 0x04, + 0x23, 0x21, 0x1c, 0xb3, 0x06, 0x42, 0x12, 0x00, 0x0e, 0x6f, 0x41, 0xe1, + 0x37, 0x6f, 0x01, 0xe5, 0x49, 0x6f, 0x01, 0x42, 0x22, 0x00, 0x2e, 0x6f, + 0x01, 0x42, 0x40, 0x06, 0x2a, 0x6f, 0x41, 0xd2, 0x93, 0x6f, 0x01, 0xd3, + 0x94, 0x6f, 0x01, 0xd4, 0x95, 0x6f, 0x01, 0xd5, 0x96, 0x6f, 0x01, 0xd6, + 0x97, 0x6f, 0x01, 0xd7, 0x98, 0x6f, 0x01, 0xd8, 0x99, 0x6f, 0x41, 0xe1, + 0x1a, 0x6f, 0x01, 0x42, 0xdf, 0x23, 0x1c, 0x6f, 0x41, 0xe1, 0x3a, 0x6f, + 0x01, 0x42, 0x22, 0x00, 0x33, 0x6f, 0x01, 0x42, 0x40, 0x06, 0x34, 0x6f, + 0x01, 0x42, 0xa0, 0x1b, 0x46, 0x6f, 0x41, 0x09, 0xce, 0xbd, 0x06, 0x42, + 0x77, 0x00, 0x4a, 0x6f, 0x41, 0x04, 0x23, 0x21, 0x06, 0x43, 0xa4, 0x02, + 0x32, 0x6f, 0x41, 0xd1, 0x9a, 0x6f, 0x01, 0xd2, 0x9b, 0x6f, 0x01, 0xd4, + 0x9c, 0x6f, 0x01, 0xd5, 0x9d, 0x6f, 0x01, 0xd6, 0x9e, 0x6f, 0x01, 0xd8, + 0x9f, 0x6f, 0x41, 0xe1, 0x21, 0x6f, 0x01, 0x42, 0x24, 0x02, 0x22, 0x6f, + 0x41, 0xe1, 0x00, 0x6f, 0x01, 0x42, 0x74, 0x00, 0x03, 0x6f, 0x41, 0xe1, + 0x10, 0x6f, 0x81, 0x2b, 0xa7, 0x1f, 0x42, 0x22, 0x00, 0x11, 0x6f, 0x01, + 0xae, 0x0d, 0xb9, 0x01, 0xff, 0xe1, 0x2c, 0x6f, 0x01, 0x42, 0x22, 0x00, + 0x2d, 0x6f, 0x41, 0xe1, 0x14, 0x6f, 0x01, 0x42, 0x22, 0x00, 0x15, 0x6f, + 0x41, 0xe1, 0x23, 0x6f, 0x01, 0x42, 0x22, 0x00, 0x24, 0x6f, 0x41, 0x4a, + 0xf4, 0x5e, 0x50, 0x6f, 0x41, 0xe1, 0x04, 0x6f, 0x01, 0x42, 0x22, 0x00, + 0x05, 0x6f, 0x41, 0xe1, 0x16, 0x6f, 0x01, 0xa8, 0x06, 0x42, 0xdf, 0x23, + 0x17, 0x6f, 0x41, 0xe1, 0x18, 0x6f, 0x01, 0x42, 0xdf, 0x23, 0x19, 0x6f, + 0x41, 0xe1, 0x26, 0x6f, 0x01, 0x42, 0x22, 0x00, 0x44, 0x6f, 0x41, 0xe1, + 0x1f, 0x6f, 0x01, 0xa8, 0x01, 0xff, 0xe1, 0x28, 0x6f, 0x01, 0x42, 0x22, + 0x00, 0x29, 0x6f, 0x41, 0xe1, 0x0b, 0x6f, 0x01, 0x42, 0x7b, 0x08, 0x0f, + 0x6f, 0x01, 0x02, 0xcc, 0x05, 0x19, 0xba, 0x01, 0xff, 0xe1, 0x38, 0x6f, + 0x01, 0x42, 0x22, 0x00, 0x2f, 0x6f, 0x01, 0x42, 0xa0, 0x1b, 0x47, 0x6f, + 0x01, 0x42, 0x59, 0x00, 0x2b, 0x6f, 0x41, 0xe1, 0x1b, 0x6f, 0x01, 0x42, + 0xdf, 0x23, 0x1d, 0x6f, 0x41, 0xe1, 0x01, 0x6f, 0x01, 0x42, 0x0d, 0x00, + 0x45, 0x6f, 0x41, 0xe8, 0x43, 0x6f, 0x01, 0x07, 0xb4, 0x84, 0x01, 0xff, + 0x42, 0x6c, 0x00, 0x06, 0x6f, 0x01, 0xae, 0x06, 0x43, 0x19, 0x9f, 0x3f, + 0x6f, 0x41, 0xe1, 0x13, 0x6f, 0x01, 0x42, 0x24, 0x02, 0x25, 0x6f, 0x41, + 0xa1, 0xd5, 0x1c, 0x09, 0xb7, 0xbc, 0xc4, 0x1c, 0xa4, 0xd7, 0x16, 0x0b, + 0x16, 0xa1, 0xc0, 0x12, 0xac, 0xab, 0x12, 0x42, 0xc3, 0x07, 0xdd, 0xf4, + 0x01, 0xae, 0xae, 0x07, 0xb2, 0x62, 0x4d, 0x6f, 0x8d, 0x95, 0x00, 0x00, + 0xb4, 0x01, 0xff, 0x43, 0xa6, 0x22, 0x8b, 0xfa, 0x01, 0x42, 0x5f, 0x03, + 0xc3, 0xce, 0x01, 0xb2, 0x01, 0xff, 0x05, 0x36, 0x00, 0x04, 0xef, 0x87, + 0xf6, 0x41, 0x45, 0x8f, 0x24, 0xd1, 0x23, 0x00, 0x0a, 0xc6, 0xb2, 0x2c, + 0x49, 0xc8, 0xc3, 0xd9, 0x23, 0x00, 0x4f, 0x3e, 0x76, 0xd3, 0x23, 0x00, + 0xb4, 0x01, 0xff, 0x48, 0x9f, 0xcb, 0xd8, 0x23, 0x00, 0x46, 0x9a, 0xe5, + 0xd7, 0x23, 0x00, 0x0a, 0x4c, 0xb9, 0x01, 0xff, 0x46, 0xe6, 0x0a, 0xd6, + 0x23, 0x00, 0x49, 0x06, 0x1e, 0xd5, 0x23, 0x40, 0x45, 0x33, 0x07, 0xd2, + 0x23, 0x00, 0x4a, 0xe4, 0xb7, 0xd4, 0x23, 0x40, 0x44, 0xdc, 0x65, 0x3f, + 0x26, 0x00, 0x06, 0xb6, 0xe4, 0x06, 0x46, 0x40, 0x1e, 0xdc, 0xf9, 0x41, + 0x08, 0x8f, 0xca, 0xc2, 0x01, 0x0d, 0xcc, 0x87, 0x01, 0xff, 0x07, 0x13, + 0x06, 0x0d, 0x4b, 0x43, 0xa8, 0x9e, 0x09, 0xc1, 0x00, 0x42, 0x86, 0xf9, + 0x9f, 0x09, 0x41, 0xe1, 0x80, 0x09, 0x01, 0x42, 0x16, 0x00, 0x86, 0x09, + 0x81, 0x9a, 0x01, 0x42, 0x7b, 0x08, 0x9d, 0x09, 0x01, 0xe5, 0x81, 0x09, + 0x01, 0x43, 0x70, 0x54, 0x92, 0x09, 0x01, 0xe9, 0x82, 0x09, 0x01, 0xab, + 0x7a, 0x42, 0x74, 0x00, 0x90, 0x09, 0x01, 0x42, 0x6c, 0x00, 0x89, 0x09, + 0x01, 0xae, 0x56, 0xef, 0x83, 0x09, 0x01, 0x42, 0xe0, 0x09, 0x88, 0x09, + 0x01, 0x42, 0x11, 0x15, 0x97, 0x09, 0x01, 0x42, 0x71, 0x00, 0x8e, 0x09, + 0x81, 0x39, 0xb3, 0x28, 0xb4, 0x0c, 0x42, 0xa9, 0x01, 0x85, 0x09, 0x01, + 0x42, 0xdf, 0x23, 0x84, 0x09, 0x41, 0xe1, 0x98, 0x09, 0x81, 0x0f, 0xe5, + 0x9a, 0x09, 0x81, 0x04, 0xef, 0x9c, 0x09, 0x41, 0x42, 0x86, 0xf9, 0x9b, + 0x09, 0x41, 0x42, 0x86, 0xf9, 0x99, 0x09, 0x41, 0xe1, 0x93, 0x09, 0x81, + 0x04, 0xe5, 0x95, 0x09, 0x41, 0x42, 0x86, 0xf9, 0x94, 0x09, 0x41, 0x42, + 0x86, 0xf9, 0x8f, 0x09, 0x41, 0xe1, 0x8a, 0x09, 0x81, 0x0b, 0xe5, 0x8c, + 0x09, 0xc1, 0x00, 0x42, 0x86, 0xf9, 0x8d, 0x09, 0x41, 0x42, 0x86, 0xf9, + 0x8b, 0x09, 0x41, 0xe1, 0x96, 0x09, 0x01, 0x42, 0x22, 0x00, 0x91, 0x09, + 0x41, 0x42, 0x86, 0xf9, 0x87, 0x09, 0x41, 0x09, 0x54, 0x2a, 0x99, 0x04, + 0xac, 0x80, 0x03, 0x07, 0x37, 0x3c, 0x01, 0xff, 0x45, 0x7e, 0x0b, 0xc7, + 0x09, 0x81, 0xd8, 0x02, 0xa6, 0xfc, 0x01, 0x44, 0x6d, 0x2c, 0xc8, 0x09, + 0x81, 0xd9, 0x01, 0x43, 0x7a, 0x0b, 0xc0, 0x09, 0x81, 0xbb, 0x01, 0xb3, + 0x67, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0xc9, 0x09, 0x81, 0x57, 0xa8, + 0x2b, 0xb7, 0x01, 0xff, 0x44, 0xe9, 0x1e, 0xca, 0x09, 0x81, 0x1b, 0xef, + 0xc1, 0x09, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0xd3, 0x09, + 0x81, 0x06, 0x48, 0xde, 0x1e, 0xdc, 0x09, 0x41, 0x49, 0xdd, 0x1e, 0xee, + 0x09, 0x41, 0x49, 0xdd, 0x1e, 0xe5, 0x09, 0x41, 0x44, 0x49, 0x12, 0xcb, + 0x09, 0x81, 0x1d, 0x43, 0x26, 0x01, 0xc2, 0x09, 0xc1, 0x00, 0x80, 0x01, + 0xff, 0x47, 0x3f, 0x12, 0xd4, 0x09, 0x81, 0x06, 0x48, 0xde, 0x1e, 0xdd, + 0x09, 0x41, 0x49, 0xdd, 0x1e, 0xef, 0x09, 0x41, 0x49, 0xdd, 0x1e, 0xe6, + 0x09, 0x41, 0x49, 0xdd, 0x1e, 0xe4, 0x09, 0x41, 0x44, 0x06, 0x1f, 0xc6, + 0x09, 0x81, 0x29, 0x42, 0x09, 0x24, 0xc5, 0x09, 0xc1, 0x00, 0x80, 0x0d, + 0x42, 0x4b, 0x12, 0xce, 0x09, 0xc1, 0x00, 0x49, 0xdd, 0x1e, 0xe9, 0x09, + 0x41, 0x47, 0x3f, 0x12, 0xd7, 0x09, 0x81, 0x06, 0x48, 0xde, 0x1e, 0xe0, + 0x09, 0x41, 0x49, 0xdd, 0x1e, 0xf2, 0x09, 0x41, 0x80, 0x0d, 0x42, 0x4b, + 0x12, 0xcf, 0x09, 0xc1, 0x00, 0x49, 0xdd, 0x1e, 0xea, 0x09, 0x41, 0x47, + 0x3f, 0x12, 0xd8, 0x09, 0x81, 0x06, 0x48, 0xde, 0x1e, 0xe1, 0x09, 0x41, + 0x49, 0xdd, 0x1e, 0xf3, 0x09, 0x41, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, + 0xd2, 0x09, 0x81, 0x06, 0x48, 0xde, 0x1e, 0xdb, 0x09, 0x41, 0x49, 0xdd, + 0x1e, 0xed, 0x09, 0x41, 0x80, 0x06, 0x4b, 0x40, 0xa9, 0xec, 0x09, 0x41, + 0x47, 0x3f, 0x12, 0xda, 0x09, 0x81, 0x06, 0x48, 0xde, 0x1e, 0xe3, 0x09, + 0x41, 0x49, 0xdd, 0x1e, 0xf5, 0x09, 0x41, 0xa9, 0x2d, 0xaf, 0x01, 0xff, + 0x43, 0x4a, 0x12, 0xcc, 0x09, 0x81, 0x1d, 0x42, 0x42, 0x00, 0xc3, 0x09, + 0xc1, 0x00, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0xd5, 0x09, 0x81, 0x06, + 0x48, 0xde, 0x1e, 0xde, 0x09, 0x41, 0x49, 0xdd, 0x1e, 0xf0, 0x09, 0x41, + 0x49, 0xdd, 0x1e, 0xe7, 0x09, 0x41, 0x43, 0x04, 0x24, 0xcd, 0x09, 0x81, + 0x1d, 0x42, 0x32, 0x00, 0xc4, 0x09, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x47, + 0x3f, 0x12, 0xd6, 0x09, 0x81, 0x06, 0x48, 0xde, 0x1e, 0xdf, 0x09, 0x41, + 0x49, 0xdd, 0x1e, 0xf1, 0x09, 0x41, 0x49, 0xdd, 0x1e, 0xe8, 0x09, 0x41, + 0x80, 0x06, 0x4a, 0x41, 0xa9, 0xeb, 0x09, 0x41, 0x47, 0x3f, 0x12, 0xd9, + 0x09, 0x81, 0x06, 0x48, 0xde, 0x1e, 0xe2, 0x09, 0x41, 0x49, 0xdd, 0x1e, + 0xf4, 0x09, 0x41, 0x06, 0x14, 0x06, 0x11, 0x08, 0xc7, 0x41, 0x01, 0xff, + 0x43, 0x51, 0xfa, 0xbf, 0x09, 0x01, 0x43, 0xcc, 0x60, 0xbe, 0x09, 0x41, + 0xe1, 0xa0, 0x09, 0x81, 0x76, 0x42, 0x16, 0x00, 0xa6, 0x09, 0x01, 0x42, + 0x7b, 0x08, 0xb7, 0x09, 0x01, 0xe5, 0xa1, 0x09, 0x01, 0x43, 0x70, 0x54, + 0xae, 0x09, 0x01, 0xe9, 0xa2, 0x09, 0x01, 0xab, 0x50, 0x42, 0x74, 0x00, + 0xac, 0x09, 0x01, 0x42, 0x6c, 0x00, 0xa8, 0x09, 0x01, 0xae, 0x3a, 0xef, + 0xa3, 0x09, 0x01, 0x42, 0xe0, 0x09, 0xa7, 0x09, 0x01, 0x42, 0x11, 0x15, + 0xb3, 0x09, 0x01, 0x42, 0x71, 0x00, 0xab, 0x09, 0x01, 0xb3, 0x1a, 0xb4, + 0x0c, 0x42, 0xa9, 0x01, 0xa5, 0x09, 0x01, 0x42, 0xdf, 0x23, 0xa4, 0x09, + 0x41, 0xe1, 0xb4, 0x09, 0x01, 0xe5, 0xb5, 0x09, 0x01, 0xef, 0xb6, 0x09, + 0x41, 0xe1, 0xaf, 0x09, 0x01, 0xe5, 0xb1, 0x09, 0x41, 0xe1, 0xa9, 0x09, + 0x01, 0xe5, 0xaa, 0x09, 0x41, 0xe1, 0xb2, 0x09, 0x01, 0x42, 0x22, 0x00, + 0xad, 0x09, 0x41, 0x49, 0x20, 0x99, 0xb0, 0x09, 0x41, 0xa5, 0x47, 0xa6, + 0x39, 0x4d, 0xb1, 0x8a, 0xfe, 0x09, 0x01, 0x04, 0x7a, 0x0b, 0x23, 0xb3, + 0x15, 0xb4, 0x01, 0xff, 0x4b, 0x21, 0x7d, 0xff, 0x09, 0x01, 0x4d, 0xe6, + 0x87, 0xf8, 0x09, 0x01, 0x4b, 0x7f, 0xaa, 0xf7, 0x09, 0x41, 0x4d, 0x1f, + 0x7d, 0xfc, 0x09, 0x01, 0x4b, 0xfa, 0xa2, 0xfb, 0x09, 0x41, 0x44, 0x22, + 0x00, 0xbd, 0x09, 0x01, 0x47, 0xa7, 0x3a, 0xf6, 0x09, 0x41, 0x4c, 0x24, + 0x95, 0xfa, 0x09, 0x01, 0x4c, 0x84, 0x98, 0xf9, 0x09, 0x41, 0x4d, 0x27, + 0x88, 0xfd, 0x09, 0x01, 0x4e, 0x1e, 0x7d, 0xbc, 0x09, 0x41, 0x0b, 0xed, + 0x9f, 0x0c, 0x57, 0x66, 0x31, 0x4e, 0xf5, 0x01, 0x48, 0xd4, 0x4d, 0xb9, + 0xf6, 0x41, 0x11, 0xc2, 0x5b, 0xad, 0x0a, 0x06, 0xef, 0x06, 0xeb, 0x09, + 0x0a, 0x26, 0xb7, 0x01, 0xff, 0x90, 0xf5, 0x04, 0x91, 0x01, 0xff, 0x90, + 0xb3, 0x04, 0x91, 0xf4, 0x03, 0x92, 0xb5, 0x03, 0x93, 0xf6, 0x02, 0x94, + 0xb7, 0x02, 0x95, 0xf8, 0x01, 0x96, 0xb9, 0x01, 0x97, 0x71, 0x98, 0x33, + 0x99, 0x01, 0xff, 0x45, 0x0f, 0xe8, 0x86, 0xe8, 0x01, 0x46, 0x92, 0xde, + 0xb1, 0xe8, 0x01, 0x45, 0x8c, 0xe8, 0xb6, 0xe8, 0x01, 0x45, 0xb4, 0xe8, + 0x75, 0xe8, 0x01, 0x45, 0x0e, 0xe9, 0x0f, 0xe8, 0x01, 0x44, 0xb8, 0xf3, + 0x2c, 0xe8, 0x01, 0x45, 0x3b, 0xe9, 0x35, 0xe8, 0x01, 0x45, 0x54, 0xe9, + 0x61, 0xe8, 0x41, 0x45, 0x00, 0xe8, 0x42, 0xe8, 0x01, 0x44, 0xec, 0xf2, + 0x43, 0xe8, 0x01, 0x44, 0x4c, 0xf3, 0xb9, 0xe8, 0x01, 0x4b, 0x9b, 0x9d, + 0x82, 0xe8, 0x01, 0x46, 0xd4, 0xde, 0x89, 0xe8, 0x01, 0x44, 0xf4, 0xf3, + 0xba, 0xe8, 0x01, 0x44, 0xf8, 0xde, 0x6a, 0xe8, 0x01, 0x46, 0x1c, 0xdf, + 0x9b, 0xe8, 0x01, 0x46, 0x34, 0xdf, 0x97, 0xe8, 0x01, 0x46, 0x46, 0xdf, + 0x1a, 0xe8, 0x41, 0x46, 0x74, 0xde, 0xc2, 0xe8, 0x01, 0x44, 0x10, 0xf3, + 0xad, 0xe8, 0x01, 0x45, 0x7d, 0xe8, 0x99, 0xe8, 0x81, 0x2f, 0x45, 0xc3, + 0xe8, 0xbc, 0xe8, 0x01, 0x45, 0xf0, 0xe8, 0x9a, 0xe8, 0x81, 0x1e, 0x49, + 0xfe, 0xba, 0x52, 0xe8, 0x01, 0x44, 0x10, 0xf4, 0x68, 0xe8, 0x01, 0x47, + 0x20, 0xd4, 0x8b, 0xe8, 0x01, 0x44, 0x70, 0xf4, 0x2d, 0xe8, 0x01, 0x45, + 0xb3, 0xe9, 0x07, 0xe8, 0x41, 0xef, 0x9a, 0xe8, 0x41, 0xef, 0x99, 0xe8, + 0x41, 0x45, 0x1e, 0xe8, 0x50, 0xe8, 0x01, 0x4a, 0x0e, 0xac, 0x9c, 0xe8, + 0x01, 0x45, 0x9b, 0xe8, 0x31, 0xe8, 0x01, 0x44, 0x58, 0xf3, 0x25, 0xe8, + 0x01, 0x46, 0xe0, 0xde, 0xc0, 0xe8, 0x01, 0x44, 0xe8, 0xf3, 0x27, 0xe8, + 0x01, 0x46, 0xf2, 0xde, 0x87, 0xe8, 0x01, 0x46, 0x0a, 0xdf, 0x88, 0xe8, + 0x01, 0x44, 0x78, 0xf4, 0x85, 0xe8, 0x01, 0x45, 0xcc, 0xe9, 0x67, 0xe8, + 0x41, 0x45, 0xfb, 0xe7, 0x1e, 0xe8, 0x01, 0x44, 0x20, 0xf3, 0xbb, 0xe8, + 0x01, 0x45, 0x87, 0xe8, 0xb5, 0xe8, 0x01, 0x44, 0x9b, 0x9d, 0x3c, 0xe8, + 0x01, 0x46, 0xce, 0xde, 0x19, 0xe8, 0x01, 0x44, 0xd0, 0xf3, 0x83, 0xe8, + 0x01, 0x47, 0x12, 0xd4, 0x7c, 0xe8, 0x01, 0x45, 0x63, 0xe9, 0x4e, 0xe8, + 0x01, 0x45, 0x90, 0xe9, 0xa5, 0xe8, 0x01, 0x47, 0x2e, 0xd4, 0x7e, 0xe8, + 0x41, 0x44, 0xbc, 0xf2, 0x6e, 0xe8, 0x01, 0x45, 0x50, 0xe8, 0x58, 0xe8, + 0x01, 0x4a, 0x22, 0xac, 0x9e, 0xe8, 0x01, 0x45, 0xc8, 0xe8, 0x10, 0xe8, + 0x01, 0x45, 0x04, 0xe9, 0xbe, 0xe8, 0x01, 0x45, 0x1d, 0xe9, 0x93, 0xe8, + 0x01, 0x46, 0xfe, 0xde, 0x7b, 0xe8, 0x01, 0x43, 0xcd, 0xf9, 0x28, 0xe8, + 0x01, 0x45, 0x86, 0xe9, 0xa8, 0xe8, 0x01, 0x46, 0x4c, 0xdf, 0xb7, 0xe8, + 0x41, 0x45, 0x14, 0xe8, 0x72, 0xe8, 0x01, 0x44, 0xfc, 0xf2, 0x2a, 0xe8, + 0x01, 0x45, 0x6e, 0xe8, 0x9f, 0xe8, 0x01, 0x45, 0xaa, 0xe8, 0x5f, 0xe8, + 0x01, 0x46, 0xda, 0xde, 0xb8, 0xe8, 0x01, 0x44, 0xd4, 0xf3, 0x2b, 0xe8, + 0x01, 0x45, 0x40, 0xe9, 0x33, 0xe8, 0x01, 0x44, 0x48, 0xf4, 0x29, 0xe8, + 0x01, 0x44, 0x68, 0xf4, 0x21, 0xe8, 0x01, 0x45, 0xe0, 0xe9, 0x13, 0xe8, + 0x41, 0x46, 0x68, 0xde, 0x7d, 0xe8, 0x01, 0x44, 0x50, 0xe8, 0x59, 0xe8, + 0x01, 0x45, 0x82, 0xe8, 0x95, 0xe8, 0x01, 0x45, 0xb9, 0xe8, 0xae, 0xe8, + 0x01, 0x45, 0xdc, 0xe8, 0xa6, 0xe8, 0x01, 0x45, 0x22, 0xe9, 0xb0, 0xe8, + 0x01, 0x45, 0x4a, 0xe9, 0x0b, 0xe8, 0x01, 0x47, 0x19, 0xd4, 0x7f, 0xe8, + 0x01, 0x46, 0x2e, 0xdf, 0x70, 0xe8, 0x01, 0x45, 0xc2, 0xe9, 0xaf, 0xe8, + 0x41, 0x49, 0xbf, 0xba, 0x3d, 0xe8, 0x01, 0x44, 0xf4, 0xf2, 0x84, 0xe8, + 0x01, 0x46, 0x9e, 0xde, 0xa4, 0xe8, 0x01, 0x44, 0x5c, 0xf3, 0x4f, 0xe8, + 0x01, 0x45, 0x09, 0xe9, 0x0d, 0xe8, 0x01, 0x47, 0x0b, 0xd4, 0x7a, 0xe8, + 0x01, 0x44, 0x34, 0xf4, 0x32, 0xe8, 0x01, 0x45, 0x6d, 0xe9, 0x66, 0xe8, + 0x01, 0x44, 0x90, 0xf4, 0x0c, 0xe8, 0x01, 0x45, 0xc7, 0xe9, 0xb2, 0xe8, + 0x41, 0x43, 0x70, 0xf9, 0x26, 0xe8, 0x01, 0x45, 0x37, 0xe8, 0x62, 0xe8, + 0x01, 0x45, 0x91, 0xe8, 0x91, 0xe8, 0x01, 0x45, 0xa5, 0xe8, 0x20, 0xe8, + 0x01, 0x45, 0xff, 0xe8, 0x49, 0xe8, 0x01, 0x4b, 0xa6, 0x9d, 0x9d, 0xe8, + 0x01, 0x4c, 0x80, 0x90, 0x81, 0xe8, 0x01, 0x45, 0x59, 0xe9, 0xaa, 0xe8, + 0x01, 0x45, 0x8b, 0xe9, 0xa3, 0xe8, 0x01, 0x45, 0xe5, 0xe9, 0x56, 0xe8, + 0x41, 0x90, 0xb5, 0x04, 0x91, 0xf6, 0x03, 0x92, 0xb7, 0x03, 0x93, 0xf8, + 0x02, 0x94, 0xb9, 0x02, 0x95, 0xfa, 0x01, 0x96, 0xbb, 0x01, 0x97, 0x7d, + 0x98, 0x3f, 0x99, 0x01, 0xff, 0x46, 0x62, 0xde, 0x77, 0xe8, 0x01, 0x45, + 0x41, 0xe8, 0x47, 0xe8, 0x01, 0x45, 0x69, 0xe8, 0xa0, 0xe8, 0x01, 0x46, + 0xaa, 0xde, 0xa9, 0xe8, 0x01, 0x45, 0xf5, 0xe8, 0x18, 0xe8, 0x01, 0x44, + 0x18, 0xe9, 0x04, 0xe8, 0x01, 0x44, 0x0c, 0xf4, 0x6c, 0xe8, 0x01, 0x44, + 0x3c, 0xf4, 0x1f, 0xe8, 0x01, 0x46, 0x40, 0xdf, 0xc3, 0xe8, 0x01, 0x44, + 0x98, 0xf4, 0x8d, 0xe8, 0x41, 0x44, 0xdc, 0xf2, 0x57, 0xe8, 0x01, 0x45, + 0x3c, 0xe8, 0x8f, 0xe8, 0x01, 0x46, 0xa4, 0xde, 0x79, 0xe8, 0x01, 0x46, + 0xb0, 0xde, 0x6f, 0xe8, 0x01, 0x45, 0xe6, 0xe8, 0x39, 0xe8, 0x01, 0x44, + 0xf8, 0xf3, 0xbd, 0xe8, 0x01, 0x4b, 0xb1, 0x9d, 0x80, 0xe8, 0x01, 0x45, + 0x5e, 0xe9, 0x73, 0xe8, 0x01, 0x44, 0x74, 0xf4, 0x60, 0xe8, 0x01, 0x45, + 0xae, 0xe9, 0x41, 0xe8, 0x41, 0x45, 0x0a, 0xe8, 0xac, 0xe8, 0x01, 0x46, + 0x80, 0xde, 0xab, 0xe8, 0x01, 0x45, 0x78, 0xe8, 0x98, 0xe8, 0x01, 0x44, + 0x6c, 0xf3, 0x3a, 0xe8, 0x01, 0x45, 0xe1, 0xe8, 0xa1, 0xe8, 0x01, 0x44, + 0xcc, 0xf3, 0x5e, 0xe8, 0x01, 0x45, 0x31, 0xe9, 0x05, 0xe8, 0x01, 0x44, + 0x60, 0xf4, 0xbf, 0xe8, 0x01, 0x45, 0x81, 0xe9, 0x5d, 0xe8, 0x01, 0x44, + 0xa8, 0xf4, 0x34, 0xe8, 0x41, 0x46, 0x6e, 0xde, 0xc4, 0xe8, 0x01, 0x45, + 0x4b, 0xe8, 0x11, 0xe8, 0x01, 0x45, 0x73, 0xe8, 0x94, 0xe8, 0x01, 0x44, + 0x60, 0xf3, 0x51, 0xe8, 0x01, 0x45, 0xfa, 0xe8, 0xb4, 0xe8, 0x01, 0x45, + 0x18, 0xe9, 0x03, 0xe8, 0x01, 0x44, 0x28, 0xf4, 0x92, 0xe8, 0x01, 0x46, + 0x22, 0xdf, 0xb3, 0xe8, 0x01, 0x44, 0x84, 0xf4, 0x8c, 0xe8, 0x01, 0x44, + 0xb0, 0xf4, 0x4a, 0xe8, 0x41, 0x44, 0xcc, 0xf2, 0x8e, 0xe8, 0x01, 0x44, + 0x3c, 0xe8, 0x90, 0xe8, 0x01, 0x45, 0x5f, 0xe8, 0x74, 0xe8, 0x01, 0x45, + 0xaf, 0xe8, 0x71, 0xe8, 0x01, 0x45, 0xeb, 0xe8, 0x3b, 0xe8, 0x01, 0x44, + 0xec, 0xf3, 0x48, 0xe8, 0x01, 0x45, 0x2c, 0xe9, 0xa7, 0xe8, 0x01, 0x46, + 0x28, 0xdf, 0x8a, 0xe8, 0x01, 0x46, 0x3a, 0xdf, 0xc1, 0xe8, 0x01, 0x45, + 0xb8, 0xe9, 0x17, 0xe8, 0x41, 0x45, 0x19, 0xe8, 0x6b, 0xe8, 0x01, 0x44, + 0xf8, 0xf2, 0x69, 0xe8, 0x01, 0x45, 0x64, 0xe8, 0x6d, 0xe8, 0x01, 0x46, + 0xb6, 0xde, 0x78, 0xe8, 0x01, 0x46, 0xc8, 0xde, 0xa2, 0xe8, 0x01, 0x44, + 0xec, 0xde, 0x0e, 0xe8, 0x01, 0x46, 0xf8, 0xde, 0x76, 0xe8, 0x01, 0x46, + 0x16, 0xdf, 0x96, 0xe8, 0x01, 0x44, 0x80, 0xf4, 0x06, 0xe8, 0x01, 0x45, + 0xdb, 0xe9, 0x12, 0xe8, 0x41, 0x44, 0xc0, 0xf2, 0x4d, 0xe8, 0x01, 0x44, + 0x24, 0xf3, 0x53, 0xe8, 0x01, 0x44, 0x50, 0xf3, 0x54, 0xe8, 0x01, 0x44, + 0x88, 0xf3, 0x55, 0xe8, 0x01, 0x44, 0x90, 0xf3, 0x5a, 0xe8, 0x01, 0x44, + 0xc8, 0xf3, 0x5b, 0xe8, 0x01, 0x44, 0x08, 0xf4, 0x5c, 0xe8, 0x01, 0x45, + 0x72, 0xe9, 0x63, 0xe8, 0x01, 0x45, 0x9a, 0xe9, 0x64, 0xe8, 0x01, 0x45, + 0xd1, 0xe9, 0x65, 0xe8, 0x41, 0x44, 0xd4, 0xf2, 0x2f, 0xe8, 0x01, 0x44, + 0x1c, 0xf3, 0x30, 0xe8, 0x01, 0x44, 0xe2, 0x44, 0x44, 0xe8, 0x01, 0x44, + 0x84, 0xf3, 0x45, 0xe8, 0x01, 0x44, 0xa4, 0xf3, 0x46, 0xe8, 0x01, 0x44, + 0xdc, 0xf3, 0x36, 0xe8, 0x01, 0x44, 0x20, 0xf4, 0x37, 0xe8, 0x01, 0x44, + 0x54, 0xf4, 0x38, 0xe8, 0x01, 0x44, 0x7c, 0xf4, 0x4b, 0xe8, 0x01, 0x44, + 0x94, 0xf4, 0x4c, 0xe8, 0x41, 0x44, 0xb8, 0xf2, 0x1b, 0xe8, 0x01, 0x44, + 0x97, 0xc8, 0x1c, 0xe8, 0x01, 0x44, 0x2c, 0xf3, 0x1d, 0xe8, 0x01, 0x43, + 0xa3, 0xf9, 0x22, 0xe8, 0x01, 0x43, 0xd7, 0xe8, 0x23, 0xe8, 0x01, 0x43, + 0xb5, 0xf9, 0x24, 0xe8, 0x01, 0x44, 0x04, 0xf4, 0x3e, 0xe8, 0x01, 0x44, + 0x40, 0xf4, 0x3f, 0xe8, 0x01, 0x44, 0x6c, 0xf4, 0x40, 0xe8, 0x01, 0x44, + 0xa4, 0xf4, 0x2e, 0xe8, 0x41, 0x44, 0x00, 0xf3, 0x00, 0xe8, 0x01, 0x44, + 0x30, 0xf3, 0x01, 0xe8, 0x01, 0x44, 0x64, 0xf3, 0x02, 0xe8, 0x01, 0x44, + 0xac, 0xf3, 0x08, 0xe8, 0x01, 0x44, 0xfc, 0xf3, 0x09, 0xe8, 0x01, 0x44, + 0x38, 0xf4, 0x0a, 0xe8, 0x01, 0x45, 0x68, 0xe9, 0x14, 0xe8, 0x01, 0x45, + 0x95, 0xe9, 0x15, 0xe8, 0x01, 0x45, 0xbd, 0xe9, 0x16, 0xe8, 0x41, 0x45, + 0x7e, 0x0b, 0xce, 0xe8, 0x01, 0xa6, 0x29, 0x44, 0x6d, 0x2c, 0xcf, 0xe8, + 0x01, 0x43, 0x7a, 0x0b, 0xc7, 0xe8, 0x01, 0xb3, 0x0f, 0xb4, 0x01, 0xff, + 0x44, 0x25, 0x01, 0xc9, 0xe8, 0x01, 0x42, 0x15, 0x02, 0xc8, 0xe8, 0x41, + 0x44, 0x06, 0x1f, 0xcd, 0xe8, 0x01, 0x42, 0x09, 0x24, 0xcc, 0xe8, 0x41, + 0x43, 0xf9, 0x05, 0xcb, 0xe8, 0x01, 0x43, 0xf6, 0x06, 0xca, 0xe8, 0x41, + 0x07, 0x3f, 0x12, 0x24, 0x48, 0x18, 0x3e, 0xd6, 0xe8, 0x01, 0xb4, 0x01, + 0xff, 0xa5, 0x06, 0x48, 0xcb, 0x54, 0xd3, 0xe8, 0x41, 0x43, 0x45, 0x5b, + 0xd0, 0xe8, 0x01, 0xae, 0x01, 0xff, 0x4a, 0x82, 0xab, 0xd4, 0xe8, 0x01, + 0xf3, 0xd1, 0xe8, 0x41, 0x4a, 0x82, 0xab, 0xd5, 0xe8, 0x01, 0xf3, 0xd2, + 0xe8, 0x41, 0x42, 0x10, 0x00, 0x48, 0xf3, 0x01, 0x46, 0x2e, 0xe5, 0xcb, + 0xce, 0x01, 0x49, 0xcb, 0x2a, 0xe0, 0xfa, 0x41, 0xa1, 0xfd, 0x03, 0x06, + 0x66, 0xe0, 0xec, 0x03, 0x06, 0xef, 0x06, 0xa5, 0x03, 0xac, 0x6b, 0x58, + 0xc4, 0x2c, 0xf3, 0xaa, 0x00, 0xb6, 0x06, 0x54, 0x3f, 0x49, 0xf4, 0xaa, + 0x40, 0x45, 0x20, 0x25, 0xf6, 0xaa, 0x00, 0x0a, 0xc8, 0x7a, 0x01, 0xff, + 0xa1, 0x3c, 0x47, 0xa1, 0xd5, 0xe9, 0xab, 0x00, 0xa9, 0x2a, 0x44, 0x98, + 0xf7, 0xea, 0xab, 0x00, 0x44, 0x89, 0x8a, 0xe3, 0xab, 0x00, 0x46, 0xf4, + 0xe5, 0xe7, 0xab, 0x00, 0xb5, 0x0c, 0x47, 0x47, 0x4e, 0xf5, 0xaa, 0x00, + 0x45, 0x73, 0xf2, 0xe6, 0xab, 0x40, 0x43, 0x8a, 0x8a, 0xe8, 0xab, 0x00, + 0xf5, 0xec, 0xaa, 0x40, 0xe9, 0xeb, 0xaa, 0x00, 0x43, 0x8a, 0x8a, 0xe4, + 0xab, 0x40, 0xa1, 0x0a, 0x43, 0x8a, 0x8a, 0xe5, 0xab, 0x00, 0xf5, 0xee, + 0xaa, 0x40, 0xe9, 0xed, 0xaa, 0x00, 0xf5, 0xef, 0xaa, 0x40, 0x06, 0x14, + 0x06, 0x06, 0x47, 0xaf, 0xdc, 0xec, 0xab, 0x40, 0x45, 0x80, 0xea, 0xd1, + 0xab, 0x00, 0xa2, 0x9b, 0x02, 0x02, 0x3b, 0x15, 0x8c, 0x02, 0xa4, 0xf1, + 0x01, 0xe5, 0xe0, 0xaa, 0x00, 0xa7, 0xde, 0x01, 0x43, 0x5f, 0xe4, 0xcd, + 0xab, 0x00, 0xe9, 0xcf, 0xab, 0x80, 0xcc, 0x01, 0xaa, 0xbd, 0x01, 0xab, + 0xa7, 0x01, 0x43, 0xcd, 0x0e, 0xc2, 0xab, 0x80, 0x99, 0x01, 0x43, 0x4f, + 0x31, 0xc3, 0xab, 0x80, 0x8b, 0x01, 0xae, 0x65, 0xef, 0xe1, 0xaa, 0x00, + 0xb0, 0x4e, 0x43, 0xd2, 0x07, 0xd4, 0xab, 0x00, 0xb3, 0x34, 0xb4, 0x12, + 0x42, 0x79, 0x08, 0xce, 0xab, 0x00, 0x43, 0x80, 0x11, 0xcb, 0xab, 0x00, + 0x44, 0xb9, 0xc3, 0xcc, 0xab, 0x40, 0x43, 0xdf, 0x1e, 0xca, 0xab, 0x00, + 0x42, 0x62, 0x01, 0xc7, 0xab, 0x80, 0x0d, 0xb4, 0x01, 0xff, 0xe1, 0xe4, + 0xaa, 0x00, 0x42, 0x22, 0x00, 0xe5, 0xaa, 0x40, 0x47, 0x01, 0xd3, 0xe0, + 0xab, 0x40, 0x42, 0x57, 0x00, 0xc1, 0xab, 0x00, 0x42, 0x22, 0x00, 0xe9, + 0xaa, 0x00, 0x42, 0x40, 0x06, 0xea, 0xaa, 0x40, 0xe1, 0xc4, 0xab, 0x80, + 0x06, 0x43, 0x56, 0x00, 0xd0, 0xab, 0x40, 0x47, 0x01, 0xd3, 0xde, 0xab, + 0x40, 0xe1, 0xc5, 0xab, 0x80, 0x19, 0x43, 0xa0, 0xb8, 0xc9, 0xab, 0x80, + 0x0c, 0x42, 0x2a, 0x05, 0xe8, 0xaa, 0x00, 0x42, 0xdf, 0x23, 0xe3, 0xaa, + 0x40, 0x47, 0x01, 0xd3, 0xe1, 0xab, 0x40, 0x47, 0x01, 0xd3, 0xdf, 0xab, + 0x40, 0x47, 0x01, 0xd3, 0xdd, 0xab, 0x40, 0x47, 0x01, 0xd3, 0xdc, 0xab, + 0x40, 0x43, 0xdf, 0x1e, 0xc8, 0xab, 0x00, 0x42, 0x55, 0x05, 0xc0, 0xab, + 0xc0, 0x00, 0x47, 0x01, 0xd3, 0xdb, 0xab, 0x40, 0x43, 0x56, 0x00, 0xd3, + 0xab, 0x00, 0x42, 0x62, 0x01, 0xd6, 0xab, 0x40, 0x47, 0x01, 0xd3, 0xe2, + 0xab, 0x40, 0x43, 0xdf, 0x1e, 0xd8, 0xab, 0x00, 0x42, 0x55, 0x05, 0xd2, + 0xab, 0x40, 0xa4, 0x0c, 0x43, 0xdf, 0x1e, 0xd9, 0xab, 0x00, 0x42, 0x62, + 0x01, 0xd7, 0xab, 0x40, 0xe1, 0xe6, 0xaa, 0x00, 0x42, 0x22, 0x00, 0xe7, + 0xaa, 0x40, 0xe1, 0xe2, 0xaa, 0x00, 0x42, 0x62, 0x01, 0xc6, 0xab, 0x40, + 0xe1, 0xd5, 0xab, 0x00, 0x43, 0x56, 0x00, 0xda, 0xab, 0x40, 0x45, 0x7e, + 0x0b, 0xf8, 0xab, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xf9, 0xab, 0x00, + 0x43, 0x7a, 0x0b, 0xf1, 0xab, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, + 0x1f, 0xf0, 0xab, 0x40, 0x44, 0x25, 0x01, 0xf3, 0xab, 0x00, 0x42, 0x15, + 0x02, 0xf2, 0xab, 0x40, 0x44, 0x06, 0x1f, 0xf7, 0xab, 0x00, 0x42, 0x09, + 0x24, 0xf6, 0xab, 0x40, 0x43, 0xf9, 0x05, 0xf5, 0xab, 0x00, 0x43, 0xf6, + 0x06, 0xf4, 0xab, 0x40, 0x42, 0x1a, 0x00, 0xf0, 0xaa, 0x00, 0x42, 0x7e, + 0x0b, 0xeb, 0xab, 0x40, 0x4b, 0xe7, 0xa1, 0xf1, 0xaa, 0x00, 0x43, 0xc5, + 0x8b, 0xf2, 0xaa, 0x00, 0x48, 0xbf, 0xcf, 0xed, 0xab, 0x40, 0x09, 0xc5, + 0xbd, 0xf7, 0x01, 0xa9, 0x01, 0xff, 0x05, 0xc6, 0x48, 0xdd, 0x01, 0x03, + 0x48, 0x04, 0x01, 0xff, 0xa2, 0xc9, 0x01, 0x06, 0xff, 0x14, 0xb8, 0x01, + 0xa6, 0x8e, 0x01, 0x4b, 0xef, 0x63, 0xa3, 0xf7, 0x01, 0x04, 0xc3, 0x00, + 0x70, 0x52, 0xfd, 0x55, 0x5f, 0x20, 0x00, 0x05, 0xc8, 0x00, 0x52, 0xb3, + 0x27, 0x0e, 0xe4, 0x80, 0x17, 0x4c, 0x32, 0x00, 0x59, 0x27, 0x00, 0x06, + 0xad, 0x02, 0x01, 0xff, 0x46, 0x12, 0x03, 0xaa, 0x26, 0x00, 0x46, 0xfd, + 0x05, 0x8f, 0xf7, 0x41, 0x4a, 0x92, 0x2d, 0xc1, 0xf7, 0x01, 0x4d, 0xf6, + 0x13, 0xc3, 0xf7, 0x41, 0x46, 0x35, 0x1a, 0xaa, 0xf7, 0x01, 0x44, 0x4c, + 0x04, 0x92, 0x25, 0x00, 0x03, 0x5b, 0x55, 0x0d, 0x51, 0x8c, 0x5e, 0xac, + 0x26, 0xc0, 0x00, 0x54, 0x0f, 0x42, 0xf0, 0xce, 0x41, 0x52, 0x8a, 0x2d, + 0xcb, 0xf7, 0x01, 0x4f, 0xf7, 0x1d, 0xb6, 0xf7, 0x41, 0x80, 0x06, 0x60, + 0xe3, 0x0f, 0x6d, 0x27, 0x40, 0x56, 0x1f, 0x35, 0x75, 0x27, 0x00, 0x54, + 0xfb, 0x22, 0x69, 0x27, 0x40, 0x80, 0x06, 0x60, 0xe3, 0x0f, 0x6c, 0x27, + 0x40, 0x56, 0x1f, 0x35, 0x74, 0x27, 0x00, 0x54, 0xfb, 0x22, 0x68, 0x27, + 0x40, 0x53, 0x7c, 0x44, 0xb0, 0xf7, 0x01, 0x09, 0x3d, 0x2a, 0x11, 0x0c, + 0xea, 0x13, 0x01, 0xff, 0x4a, 0x92, 0x2d, 0xc5, 0xf7, 0x01, 0x4d, 0xf6, + 0x13, 0xc7, 0xf7, 0x41, 0x59, 0xed, 0x25, 0x6a, 0x27, 0x00, 0x5a, 0xf5, + 0x22, 0x6b, 0x27, 0x40, 0x52, 0x8a, 0x2d, 0xce, 0xf7, 0x01, 0x4f, 0xf7, + 0x1d, 0xbc, 0xf7, 0x41, 0x4b, 0x0d, 0x03, 0xab, 0x26, 0x00, 0x50, 0x9a, + 0x68, 0x85, 0xf7, 0x41, 0x45, 0x13, 0x05, 0x4c, 0x2e, 0x00, 0x50, 0xad, + 0x00, 0x53, 0x2e, 0x00, 0x4d, 0x88, 0x36, 0x54, 0x2e, 0x40, 0xa3, 0xd0, + 0x02, 0x06, 0xef, 0x06, 0xf4, 0x01, 0x4e, 0x34, 0x7b, 0x9a, 0x6e, 0x01, + 0x49, 0x4f, 0x17, 0x98, 0x6e, 0x01, 0x07, 0x37, 0x3c, 0x9e, 0x01, 0xb3, + 0x01, 0xff, 0x0c, 0x9c, 0x08, 0x06, 0x4a, 0x88, 0xb9, 0x99, 0x6e, 0x41, + 0xe1, 0x6d, 0x6e, 0x81, 0x81, 0x01, 0xe2, 0x70, 0x6e, 0x01, 0xe3, 0x71, + 0x6e, 0x01, 0xe4, 0x79, 0x6e, 0x01, 0xe5, 0x6f, 0x6e, 0x01, 0xe6, 0x6a, + 0x6e, 0x01, 0xe7, 0x69, 0x6e, 0x01, 0xe8, 0x76, 0x6e, 0x81, 0x60, 0xe9, + 0x6b, 0x6e, 0x01, 0xea, 0x6e, 0x6e, 0x01, 0xeb, 0x6c, 0x6e, 0x81, 0x4f, + 0xec, 0x74, 0x6e, 0x01, 0xed, 0x60, 0x6e, 0x01, 0xee, 0x7b, 0x6e, 0x81, + 0x3a, 0xef, 0x7d, 0x6e, 0x81, 0x31, 0xf0, 0x67, 0x6e, 0x01, 0xf1, 0x75, + 0x6e, 0x01, 0xf2, 0x7c, 0x6e, 0x01, 0xf3, 0x61, 0x6e, 0x01, 0xf4, 0x68, + 0x6e, 0x01, 0xf5, 0x72, 0x6e, 0x01, 0xf6, 0x62, 0x6e, 0x01, 0xf7, 0x63, + 0x6e, 0x01, 0xf8, 0x78, 0x6e, 0x01, 0xf9, 0x7f, 0x6e, 0x81, 0x04, 0xfa, + 0x65, 0x6e, 0x41, 0xf5, 0x73, 0x6e, 0x41, 0xe5, 0x7a, 0x6e, 0x41, 0xe7, + 0x77, 0x6e, 0x01, 0xf9, 0x77, 0x6e, 0x41, 0xf0, 0x66, 0x6e, 0x41, 0xf0, + 0x76, 0x6e, 0x41, 0xe9, 0x7e, 0x6e, 0x01, 0x43, 0x8d, 0x8d, 0x64, 0x6e, + 0x41, 0xa5, 0x37, 0xa6, 0x29, 0x48, 0x21, 0x56, 0x93, 0x6e, 0x01, 0xb3, + 0x15, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x8a, 0x6e, 0x01, 0x47, 0x16, + 0x5d, 0x8d, 0x6e, 0x01, 0x45, 0x84, 0x2d, 0x8c, 0x6e, 0x41, 0x48, 0xf3, + 0x53, 0x91, 0x6e, 0x01, 0x46, 0x6f, 0x27, 0x90, 0x6e, 0x41, 0x46, 0x0e, + 0x19, 0x8f, 0x6e, 0x01, 0x47, 0x9c, 0x5f, 0x8e, 0x6e, 0x41, 0x47, 0xc0, + 0x26, 0x92, 0x6e, 0x01, 0x45, 0xe7, 0x72, 0x8b, 0x6e, 0x41, 0x45, 0x7e, + 0x0b, 0x88, 0x6e, 0x01, 0xa6, 0x43, 0x44, 0x6d, 0x2c, 0x89, 0x6e, 0x01, + 0x43, 0x7a, 0x0b, 0x81, 0x6e, 0x81, 0x30, 0xb3, 0x22, 0xb4, 0x06, 0x44, + 0x80, 0x1f, 0x80, 0x6e, 0x41, 0x44, 0x25, 0x01, 0x83, 0x6e, 0x81, 0x0d, + 0x42, 0x15, 0x02, 0x82, 0x6e, 0xc1, 0x00, 0x4f, 0x2a, 0x6c, 0x95, 0x6e, + 0x41, 0x4f, 0x2a, 0x6c, 0x96, 0x6e, 0x41, 0x44, 0x06, 0x1f, 0x87, 0x6e, + 0x01, 0x42, 0x09, 0x24, 0x86, 0x6e, 0x41, 0x4f, 0x2a, 0x6c, 0x94, 0x6e, + 0x41, 0x43, 0xf9, 0x05, 0x85, 0x6e, 0x01, 0x43, 0xf6, 0x06, 0x84, 0x6e, + 0x41, 0x0e, 0x0c, 0x06, 0x06, 0x44, 0x14, 0x05, 0x97, 0x6e, 0x41, 0xe1, + 0x4d, 0x6e, 0x81, 0x81, 0x01, 0xe2, 0x50, 0x6e, 0x01, 0xe3, 0x51, 0x6e, + 0x01, 0xe4, 0x59, 0x6e, 0x01, 0xe5, 0x4f, 0x6e, 0x01, 0xe6, 0x4a, 0x6e, + 0x01, 0xe7, 0x49, 0x6e, 0x01, 0xe8, 0x56, 0x6e, 0x81, 0x60, 0xe9, 0x4b, + 0x6e, 0x01, 0xea, 0x4e, 0x6e, 0x01, 0xeb, 0x4c, 0x6e, 0x81, 0x4f, 0xec, + 0x54, 0x6e, 0x01, 0xed, 0x40, 0x6e, 0x01, 0xee, 0x5b, 0x6e, 0x81, 0x3a, + 0xef, 0x5d, 0x6e, 0x81, 0x31, 0xf0, 0x47, 0x6e, 0x01, 0xf1, 0x55, 0x6e, + 0x01, 0xf2, 0x5c, 0x6e, 0x01, 0xf3, 0x41, 0x6e, 0x01, 0xf4, 0x48, 0x6e, + 0x01, 0xf5, 0x52, 0x6e, 0x01, 0xf6, 0x42, 0x6e, 0x01, 0xf7, 0x43, 0x6e, + 0x01, 0xf8, 0x58, 0x6e, 0x01, 0xf9, 0x5f, 0x6e, 0x81, 0x04, 0xfa, 0x45, + 0x6e, 0x41, 0xf5, 0x53, 0x6e, 0x41, 0xe5, 0x5a, 0x6e, 0x41, 0xe7, 0x57, + 0x6e, 0x01, 0xf9, 0x57, 0x6e, 0x41, 0xf0, 0x46, 0x6e, 0x41, 0xf0, 0x56, + 0x6e, 0x41, 0xe9, 0x5e, 0x6e, 0x01, 0x43, 0x8d, 0x8d, 0x44, 0x6e, 0x41, + 0x43, 0x0b, 0x0d, 0xbe, 0xf9, 0x01, 0x43, 0xc5, 0x3a, 0xbf, 0xf9, 0x41, + 0x06, 0x3c, 0xe6, 0x06, 0x49, 0x5d, 0xc5, 0x56, 0xf3, 0x41, 0x45, 0x04, + 0x02, 0x21, 0x22, 0x80, 0x0c, 0x42, 0x08, 0x00, 0x5e, 0x22, 0x00, 0x54, + 0x87, 0x47, 0x9d, 0x29, 0x40, 0x80, 0x01, 0xff, 0x4c, 0x30, 0x98, 0x9b, + 0x29, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4b, 0x53, 0x9f, 0xfa, 0xce, + 0x01, 0x07, 0x3b, 0x01, 0x46, 0x22, 0x06, 0x0d, 0x01, 0xff, 0x09, 0x56, + 0x4b, 0x31, 0x09, 0x5b, 0x46, 0x21, 0x0a, 0x09, 0x01, 0x11, 0x07, 0x67, + 0x61, 0x01, 0xff, 0x44, 0xc3, 0x00, 0xa9, 0x29, 0x00, 0x45, 0xc8, 0x00, + 0xa8, 0x29, 0x40, 0x44, 0xa5, 0x01, 0xae, 0x29, 0x00, 0x42, 0x50, 0x02, + 0xac, 0x29, 0x40, 0x44, 0xa5, 0x01, 0xaf, 0x29, 0x00, 0x42, 0x50, 0x02, + 0xad, 0x29, 0x40, 0x44, 0xc3, 0x00, 0xab, 0x29, 0x00, 0x45, 0xc8, 0x00, + 0xaa, 0x29, 0x40, 0x43, 0x94, 0x18, 0xf9, 0xce, 0x01, 0x4b, 0x53, 0x9f, + 0xfb, 0xce, 0x41, 0x44, 0xd3, 0x73, 0xaf, 0x00, 0x00, 0xa7, 0xfc, 0x42, + 0xa8, 0x9f, 0x3e, 0xab, 0xfd, 0x3c, 0xac, 0xe8, 0x36, 0x45, 0xae, 0xee, + 0xa3, 0xf9, 0x01, 0xee, 0x68, 0xf4, 0x81, 0x87, 0x32, 0xb0, 0xf8, 0x31, + 0xb2, 0xb5, 0x2e, 0xb3, 0xd3, 0x2a, 0xb4, 0x95, 0x01, 0x46, 0x62, 0xe7, + 0xd6, 0xf5, 0x01, 0x0c, 0x20, 0x9c, 0x01, 0xff, 0xa5, 0x75, 0xa6, 0x58, + 0x44, 0x6d, 0x2c, 0xe9, 0xd2, 0x81, 0x4b, 0x43, 0x7a, 0x0b, 0xe1, 0xd2, + 0x01, 0xb3, 0x29, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xe0, 0xd2, 0x41, 0x42, + 0x92, 0x01, 0xea, 0xd2, 0x01, 0xa8, 0x0d, 0xb7, 0x01, 0xff, 0x44, 0x85, + 0x2d, 0xec, 0xd2, 0x01, 0xef, 0xe2, 0xd2, 0x41, 0x46, 0x17, 0x5d, 0xed, + 0xd2, 0x01, 0x43, 0x26, 0x01, 0xe3, 0xd2, 0x41, 0x44, 0x06, 0x1f, 0xe7, + 0xd2, 0x81, 0x0d, 0x42, 0x09, 0x24, 0xe6, 0xd2, 0xc1, 0x00, 0x44, 0x10, + 0x19, 0xf0, 0xd2, 0x41, 0x44, 0x10, 0x19, 0xf1, 0xd2, 0x41, 0x44, 0x10, + 0x19, 0xf3, 0xd2, 0x41, 0xa9, 0x0d, 0x43, 0xf6, 0x06, 0xe4, 0xd2, 0xc1, + 0x00, 0x44, 0x10, 0x19, 0xee, 0xd2, 0x41, 0x45, 0x0f, 0x19, 0xef, 0xd2, + 0x01, 0x42, 0x32, 0x00, 0xe5, 0xd2, 0x41, 0x44, 0xc9, 0x00, 0xe8, 0xd2, + 0x81, 0x06, 0x45, 0xe7, 0x72, 0xeb, 0xd2, 0x41, 0x43, 0xe9, 0x09, 0xf2, + 0xd2, 0x41, 0x47, 0x49, 0xd6, 0xc9, 0xf9, 0x01, 0x0a, 0x00, 0x56, 0x01, + 0xff, 0x05, 0xea, 0x63, 0xbc, 0x1b, 0x0e, 0x9a, 0x7a, 0xb3, 0x19, 0xa6, + 0xe0, 0x17, 0x07, 0xe6, 0xd7, 0xe0, 0x12, 0x05, 0xc3, 0x00, 0xb8, 0x12, + 0x0a, 0x8e, 0xb3, 0x93, 0x10, 0x02, 0x0d, 0x00, 0xe1, 0x0f, 0xb3, 0x01, + 0xff, 0x0a, 0x39, 0x4a, 0xb2, 0x01, 0x06, 0x75, 0x06, 0x01, 0xff, 0x08, + 0x0b, 0x06, 0x61, 0x06, 0x5d, 0x07, 0x01, 0xff, 0xe1, 0xb6, 0xd4, 0x01, + 0xe2, 0xb7, 0xd4, 0x01, 0xe3, 0xb8, 0xd4, 0x01, 0xe4, 0xb9, 0xd4, 0x01, + 0xe6, 0xbb, 0xd4, 0x01, 0xe8, 0xbd, 0xd4, 0x01, 0xe9, 0xbe, 0xd4, 0x01, + 0xea, 0xbf, 0xd4, 0x01, 0xeb, 0xc0, 0xd4, 0x01, 0xec, 0xc1, 0xd4, 0x01, + 0xed, 0xc2, 0xd4, 0x01, 0xee, 0xc3, 0xd4, 0x01, 0xf0, 0xc5, 0xd4, 0x01, + 0xf1, 0xc6, 0xd4, 0x01, 0xf2, 0xc7, 0xd4, 0x01, 0xf3, 0xc8, 0xd4, 0x01, + 0xf4, 0xc9, 0xd4, 0x01, 0xf5, 0xca, 0xd4, 0x01, 0xf6, 0xcb, 0xd4, 0x01, + 0xf7, 0xcc, 0xd4, 0x01, 0xf8, 0xcd, 0xd4, 0x01, 0xf9, 0xce, 0xd4, 0x01, + 0xfa, 0xcf, 0xd4, 0x41, 0xe1, 0x9c, 0xd4, 0x01, 0xe3, 0x9e, 0xd4, 0x01, + 0xe4, 0x9f, 0xd4, 0x01, 0xe7, 0xa2, 0xd4, 0x01, 0xea, 0xa5, 0xd4, 0x01, + 0xeb, 0xa6, 0xd4, 0x01, 0xee, 0xa9, 0xd4, 0x01, 0xef, 0xaa, 0xd4, 0x01, + 0xf0, 0xab, 0xd4, 0x01, 0xf1, 0xac, 0xd4, 0x01, 0xf3, 0xae, 0xd4, 0x01, + 0xf4, 0xaf, 0xd4, 0x01, 0xf5, 0xb0, 0xd4, 0x01, 0xf6, 0xb1, 0xd4, 0x01, + 0xf7, 0xb2, 0xd4, 0x01, 0xf8, 0xb3, 0xd4, 0x01, 0xf9, 0xb4, 0xd4, 0x01, + 0xfa, 0xb5, 0xd4, 0x41, 0x05, 0xea, 0x63, 0xfe, 0x03, 0x08, 0x0b, 0x06, + 0x91, 0x03, 0x06, 0xef, 0x06, 0xca, 0x02, 0x07, 0xe6, 0xd7, 0x6d, 0x06, + 0x5d, 0x07, 0x01, 0xff, 0xe1, 0xba, 0xd5, 0x01, 0xe2, 0xbb, 0xd5, 0x01, + 0xe3, 0xbc, 0xd5, 0x01, 0xe4, 0xbd, 0xd5, 0x01, 0xe5, 0xbe, 0xd5, 0x01, + 0xe6, 0xbf, 0xd5, 0x01, 0xe7, 0xc0, 0xd5, 0x01, 0xe8, 0xc1, 0xd5, 0x01, + 0xe9, 0xc2, 0xd5, 0x01, 0xea, 0xc3, 0xd5, 0x01, 0xeb, 0xc4, 0xd5, 0x01, + 0xec, 0xc5, 0xd5, 0x01, 0xed, 0xc6, 0xd5, 0x01, 0xee, 0xc7, 0xd5, 0x01, + 0xef, 0xc8, 0xd5, 0x01, 0xf0, 0xc9, 0xd5, 0x01, 0xf1, 0xca, 0xd5, 0x01, + 0xf2, 0xcb, 0xd5, 0x01, 0xf3, 0xcc, 0xd5, 0x01, 0xf4, 0xcd, 0xd5, 0x01, + 0xf5, 0xce, 0xd5, 0x01, 0xf6, 0xcf, 0xd5, 0x01, 0xf7, 0xd0, 0xd5, 0x01, + 0xf8, 0xd1, 0xd5, 0x01, 0xf9, 0xd2, 0xd5, 0x01, 0xfa, 0xd3, 0xd5, 0x41, + 0x08, 0x0b, 0x06, 0x6d, 0x06, 0x5d, 0x07, 0x01, 0xff, 0xe1, 0x22, 0xd6, + 0x01, 0xe2, 0x23, 0xd6, 0x01, 0xe3, 0x24, 0xd6, 0x01, 0xe4, 0x25, 0xd6, + 0x01, 0xe5, 0x26, 0xd6, 0x01, 0xe6, 0x27, 0xd6, 0x01, 0xe7, 0x28, 0xd6, + 0x01, 0xe8, 0x29, 0xd6, 0x01, 0xe9, 0x2a, 0xd6, 0x01, 0xea, 0x2b, 0xd6, + 0x01, 0xeb, 0x2c, 0xd6, 0x01, 0xec, 0x2d, 0xd6, 0x01, 0xed, 0x2e, 0xd6, + 0x01, 0xee, 0x2f, 0xd6, 0x01, 0xef, 0x30, 0xd6, 0x01, 0xf0, 0x31, 0xd6, + 0x01, 0xf1, 0x32, 0xd6, 0x01, 0xf2, 0x33, 0xd6, 0x01, 0xf3, 0x34, 0xd6, + 0x01, 0xf4, 0x35, 0xd6, 0x01, 0xf5, 0x36, 0xd6, 0x01, 0xf6, 0x37, 0xd6, + 0x01, 0xf7, 0x38, 0xd6, 0x01, 0xf8, 0x39, 0xd6, 0x01, 0xf9, 0x3a, 0xd6, + 0x01, 0xfa, 0x3b, 0xd6, 0x41, 0xe1, 0x08, 0xd6, 0x01, 0xe2, 0x09, 0xd6, + 0x01, 0xe3, 0x0a, 0xd6, 0x01, 0xe4, 0x0b, 0xd6, 0x01, 0xe5, 0x0c, 0xd6, + 0x01, 0xe6, 0x0d, 0xd6, 0x01, 0xe7, 0x0e, 0xd6, 0x01, 0xe8, 0x0f, 0xd6, + 0x01, 0xe9, 0x10, 0xd6, 0x01, 0xea, 0x11, 0xd6, 0x01, 0xeb, 0x12, 0xd6, + 0x01, 0xec, 0x13, 0xd6, 0x01, 0xed, 0x14, 0xd6, 0x01, 0xee, 0x15, 0xd6, + 0x01, 0xef, 0x16, 0xd6, 0x01, 0xf0, 0x17, 0xd6, 0x01, 0xf1, 0x18, 0xd6, + 0x01, 0xf2, 0x19, 0xd6, 0x01, 0xf3, 0x1a, 0xd6, 0x01, 0xf4, 0x1b, 0xd6, + 0x01, 0xf5, 0x1c, 0xd6, 0x01, 0xf6, 0x1d, 0xd6, 0x01, 0xf7, 0x1e, 0xd6, + 0x01, 0xf8, 0x1f, 0xd6, 0x01, 0xf9, 0x20, 0xd6, 0x01, 0xfa, 0x21, 0xd6, + 0x41, 0x45, 0x7e, 0x0b, 0xea, 0xd7, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, + 0xeb, 0xd7, 0x01, 0x43, 0x7a, 0x0b, 0xe3, 0xd7, 0x01, 0xb3, 0x14, 0xb4, + 0x06, 0x44, 0x80, 0x1f, 0xe2, 0xd7, 0x41, 0x44, 0x25, 0x01, 0xe5, 0xd7, + 0x01, 0x42, 0x15, 0x02, 0xe4, 0xd7, 0x41, 0x44, 0x06, 0x1f, 0xe9, 0xd7, + 0x01, 0x42, 0x09, 0x24, 0xe8, 0xd7, 0x41, 0x43, 0xf9, 0x05, 0xe7, 0xd7, + 0x01, 0x43, 0xf6, 0x06, 0xe6, 0xd7, 0x41, 0xe1, 0xa0, 0xd5, 0x01, 0xe2, + 0xa1, 0xd5, 0x01, 0xe3, 0xa2, 0xd5, 0x01, 0xe4, 0xa3, 0xd5, 0x01, 0xe5, + 0xa4, 0xd5, 0x01, 0xe6, 0xa5, 0xd5, 0x01, 0xe7, 0xa6, 0xd5, 0x01, 0xe8, + 0xa7, 0xd5, 0x01, 0xe9, 0xa8, 0xd5, 0x01, 0xea, 0xa9, 0xd5, 0x01, 0xeb, + 0xaa, 0xd5, 0x01, 0xec, 0xab, 0xd5, 0x01, 0xed, 0xac, 0xd5, 0x01, 0xee, + 0xad, 0xd5, 0x01, 0xef, 0xae, 0xd5, 0x01, 0xf0, 0xaf, 0xd5, 0x01, 0xf1, + 0xb0, 0xd5, 0x01, 0xf2, 0xb1, 0xd5, 0x01, 0xf3, 0xb2, 0xd5, 0x01, 0xf4, + 0xb3, 0xd5, 0x01, 0xf5, 0xb4, 0xd5, 0x01, 0xf6, 0xb5, 0xd5, 0x01, 0xf7, + 0xb6, 0xd5, 0x01, 0xf8, 0xb7, 0xd5, 0x01, 0xf9, 0xb8, 0xd5, 0x01, 0xfa, + 0xb9, 0xd5, 0x41, 0x08, 0x0b, 0x06, 0x87, 0x08, 0x06, 0xef, 0x06, 0xc0, + 0x07, 0x4e, 0x9c, 0x16, 0x8a, 0xd7, 0x01, 0x07, 0xe6, 0xd7, 0xc9, 0x02, + 0x4c, 0x48, 0x95, 0x8c, 0xd7, 0x01, 0x45, 0xdb, 0xee, 0x6f, 0xd7, 0x01, + 0xb0, 0xa8, 0x02, 0x4a, 0xdc, 0xb5, 0x8e, 0xd7, 0x01, 0x06, 0x5d, 0x07, + 0x06, 0x4c, 0xc4, 0x9a, 0x8b, 0xd7, 0x41, 0xe1, 0xee, 0xd5, 0x81, 0x8c, + 0x02, 0xe2, 0xef, 0xd5, 0x81, 0x80, 0x02, 0xe3, 0xf0, 0xd5, 0x81, 0xf4, + 0x01, 0xe4, 0xf1, 0xd5, 0x81, 0xe8, 0x01, 0xe5, 0xf2, 0xd5, 0x81, 0xd6, + 0x01, 0xe6, 0xf3, 0xd5, 0x81, 0xca, 0x01, 0xe7, 0xf4, 0xd5, 0x81, 0xbe, + 0x01, 0xe8, 0xf5, 0xd5, 0x01, 0xe9, 0xf6, 0xd5, 0x81, 0xae, 0x01, 0xea, + 0xf7, 0xd5, 0x01, 0xeb, 0xf8, 0xd5, 0x81, 0x9e, 0x01, 0xec, 0xf9, 0xd5, + 0x81, 0x92, 0x01, 0xed, 0xfa, 0xd5, 0x81, 0x88, 0x01, 0xee, 0xfb, 0xd5, + 0x81, 0x7f, 0xef, 0xfc, 0xd5, 0x81, 0x6b, 0xf0, 0xfd, 0xd5, 0x81, 0x56, + 0xf1, 0xfe, 0xd5, 0x01, 0xf2, 0xff, 0xd5, 0x81, 0x47, 0xf3, 0x00, 0xd6, + 0x81, 0x3c, 0xf4, 0x01, 0xd6, 0x81, 0x2b, 0xf5, 0x02, 0xd6, 0x81, 0x20, + 0xf6, 0x03, 0xd6, 0x01, 0xf7, 0x04, 0xd6, 0x01, 0xf8, 0x05, 0xd6, 0x81, + 0x0f, 0xf9, 0x06, 0xd6, 0x01, 0xfa, 0x07, 0xd6, 0xc1, 0x00, 0x43, 0x43, + 0x10, 0x75, 0xd7, 0x41, 0xe9, 0x7d, 0xd7, 0x41, 0x46, 0x9d, 0x16, 0x84, + 0xd7, 0x41, 0x42, 0xb4, 0x25, 0x83, 0xd7, 0x01, 0x44, 0xf8, 0x78, 0x77, + 0xd7, 0x41, 0x44, 0xe2, 0x20, 0x82, 0xd7, 0x41, 0x42, 0x0b, 0x00, 0x80, + 0xd7, 0x41, 0x42, 0x49, 0x00, 0x85, 0xd7, 0x01, 0xe9, 0x7f, 0xd7, 0x01, + 0x42, 0x5a, 0x03, 0x87, 0xd7, 0x41, 0xad, 0x01, 0xff, 0x43, 0xf5, 0x05, + 0x88, 0xd7, 0x01, 0x45, 0x3c, 0xed, 0x7e, 0xd7, 0x41, 0xf5, 0x7c, 0xd7, + 0x41, 0xf5, 0x7b, 0xd7, 0x41, 0x44, 0x0f, 0xee, 0x7a, 0xd7, 0x41, 0x44, + 0x49, 0x95, 0x79, 0xd7, 0x41, 0x43, 0x1b, 0x05, 0x78, 0xd7, 0x41, 0x44, + 0x23, 0x22, 0x72, 0xd7, 0x41, 0x4a, 0x43, 0xa1, 0x81, 0xd7, 0x41, 0x46, + 0x9d, 0x16, 0x74, 0xd7, 0x01, 0x42, 0x12, 0x00, 0x76, 0xd7, 0x41, 0x44, + 0x28, 0xdc, 0x73, 0xd7, 0x41, 0x42, 0x49, 0x00, 0x86, 0xd7, 0x41, 0x43, + 0x43, 0x10, 0x71, 0xd7, 0x41, 0x44, 0x40, 0xea, 0x70, 0xd7, 0x41, 0x53, + 0x85, 0x4a, 0x89, 0xd7, 0x01, 0x49, 0x2d, 0xbf, 0x8d, 0xd7, 0x01, 0x48, + 0xbc, 0x97, 0x8f, 0xd7, 0x41, 0x08, 0x0b, 0x06, 0xcf, 0x02, 0x4e, 0x9c, + 0x16, 0xc4, 0xd7, 0x01, 0x4c, 0x48, 0x95, 0xc6, 0xd7, 0x01, 0x45, 0xdb, + 0xee, 0xa9, 0xd7, 0x01, 0xb0, 0xa8, 0x02, 0x4a, 0xdc, 0xb5, 0xc8, 0xd7, + 0x01, 0x06, 0x5d, 0x07, 0x06, 0x4c, 0xc4, 0x9a, 0xc5, 0xd7, 0x41, 0xe1, + 0x56, 0xd6, 0x81, 0x8c, 0x02, 0xe2, 0x57, 0xd6, 0x81, 0x80, 0x02, 0xe3, + 0x58, 0xd6, 0x81, 0xf4, 0x01, 0xe4, 0x59, 0xd6, 0x81, 0xe8, 0x01, 0xe5, + 0x5a, 0xd6, 0x81, 0xd6, 0x01, 0xe6, 0x5b, 0xd6, 0x81, 0xca, 0x01, 0xe7, + 0x5c, 0xd6, 0x81, 0xbe, 0x01, 0xe8, 0x5d, 0xd6, 0x01, 0xe9, 0x5e, 0xd6, + 0x81, 0xae, 0x01, 0xea, 0x5f, 0xd6, 0x01, 0xeb, 0x60, 0xd6, 0x81, 0x9e, + 0x01, 0xec, 0x61, 0xd6, 0x81, 0x92, 0x01, 0xed, 0x62, 0xd6, 0x81, 0x88, + 0x01, 0xee, 0x63, 0xd6, 0x81, 0x7f, 0xef, 0x64, 0xd6, 0x81, 0x6b, 0xf0, + 0x65, 0xd6, 0x81, 0x56, 0xf1, 0x66, 0xd6, 0x01, 0xf2, 0x67, 0xd6, 0x81, + 0x47, 0xf3, 0x68, 0xd6, 0x81, 0x3c, 0xf4, 0x69, 0xd6, 0x81, 0x2b, 0xf5, + 0x6a, 0xd6, 0x81, 0x20, 0xf6, 0x6b, 0xd6, 0x01, 0xf7, 0x6c, 0xd6, 0x01, + 0xf8, 0x6d, 0xd6, 0x81, 0x0f, 0xf9, 0x6e, 0xd6, 0x01, 0xfa, 0x6f, 0xd6, + 0xc1, 0x00, 0x43, 0x43, 0x10, 0xaf, 0xd7, 0x41, 0xe9, 0xb7, 0xd7, 0x41, + 0x46, 0x9d, 0x16, 0xbe, 0xd7, 0x41, 0x42, 0xb4, 0x25, 0xbd, 0xd7, 0x01, + 0x44, 0xf8, 0x78, 0xb1, 0xd7, 0x41, 0x44, 0xe2, 0x20, 0xbc, 0xd7, 0x41, + 0x42, 0x0b, 0x00, 0xba, 0xd7, 0x41, 0x42, 0x49, 0x00, 0xbf, 0xd7, 0x01, + 0xe9, 0xb9, 0xd7, 0x01, 0x42, 0x5a, 0x03, 0xc1, 0xd7, 0x41, 0xad, 0x01, + 0xff, 0x43, 0xf5, 0x05, 0xc2, 0xd7, 0x01, 0x45, 0x3c, 0xed, 0xb8, 0xd7, + 0x41, 0xf5, 0xb6, 0xd7, 0x41, 0xf5, 0xb5, 0xd7, 0x41, 0x44, 0x0f, 0xee, + 0xb4, 0xd7, 0x41, 0x44, 0x49, 0x95, 0xb3, 0xd7, 0x41, 0x43, 0x1b, 0x05, + 0xb2, 0xd7, 0x41, 0x44, 0x23, 0x22, 0xac, 0xd7, 0x41, 0x4a, 0x43, 0xa1, + 0xbb, 0xd7, 0x41, 0x46, 0x9d, 0x16, 0xae, 0xd7, 0x01, 0x42, 0x12, 0x00, + 0xb0, 0xd7, 0x41, 0x44, 0x28, 0xdc, 0xad, 0xd7, 0x41, 0x42, 0x49, 0x00, + 0xc0, 0xd7, 0x41, 0x43, 0x43, 0x10, 0xab, 0xd7, 0x41, 0x44, 0x40, 0xea, + 0xaa, 0xd7, 0x41, 0x53, 0x85, 0x4a, 0xc3, 0xd7, 0x01, 0x49, 0x2d, 0xbf, + 0xc7, 0xd7, 0x01, 0x48, 0xbc, 0x97, 0xc9, 0xd7, 0x41, 0xe1, 0x3c, 0xd6, + 0x81, 0x8c, 0x02, 0xe2, 0x3d, 0xd6, 0x81, 0x80, 0x02, 0xe3, 0x3e, 0xd6, + 0x81, 0xf4, 0x01, 0xe4, 0x3f, 0xd6, 0x81, 0xe8, 0x01, 0xe5, 0x40, 0xd6, + 0x81, 0xd6, 0x01, 0xe6, 0x41, 0xd6, 0x01, 0xe7, 0x42, 0xd6, 0x81, 0xc6, + 0x01, 0xe8, 0x43, 0xd6, 0x01, 0xe9, 0x44, 0xd6, 0x81, 0xb6, 0x01, 0xea, + 0x45, 0xd6, 0x01, 0xeb, 0x46, 0xd6, 0x81, 0xa6, 0x01, 0xec, 0x47, 0xd6, + 0x81, 0x9a, 0x01, 0xed, 0x48, 0xd6, 0x81, 0x90, 0x01, 0xee, 0x49, 0xd6, + 0x81, 0x86, 0x01, 0xef, 0x4a, 0xd6, 0x81, 0x72, 0xf0, 0x4b, 0xd6, 0x81, + 0x5d, 0xf1, 0x4c, 0xd6, 0x01, 0xf2, 0x4d, 0xd6, 0x81, 0x4e, 0xf3, 0x4e, + 0xd6, 0x81, 0x43, 0xf4, 0x4f, 0xd6, 0x81, 0x2b, 0xf5, 0x50, 0xd6, 0x81, + 0x20, 0xf6, 0x51, 0xd6, 0x01, 0xf7, 0x52, 0xd6, 0x01, 0xf8, 0x53, 0xd6, + 0x81, 0x0f, 0xf9, 0x54, 0xd6, 0x01, 0xfa, 0x55, 0xd6, 0xc1, 0x00, 0x43, + 0x43, 0x10, 0x95, 0xd7, 0x41, 0xe9, 0x9d, 0xd7, 0x41, 0x46, 0x9d, 0x16, + 0xa4, 0xd7, 0x41, 0x42, 0xb4, 0x25, 0xa3, 0xd7, 0x01, 0x44, 0xf8, 0x78, + 0x97, 0xd7, 0xc1, 0x00, 0x47, 0x15, 0x08, 0xa1, 0xd7, 0x41, 0x44, 0xe2, + 0x20, 0xa2, 0xd7, 0x41, 0x42, 0x0b, 0x00, 0xa0, 0xd7, 0x41, 0x42, 0x49, + 0x00, 0xa5, 0xd7, 0x01, 0xe9, 0x9f, 0xd7, 0x01, 0x42, 0x5a, 0x03, 0xa7, + 0xd7, 0x41, 0xad, 0x01, 0xff, 0x43, 0xf5, 0x05, 0xa8, 0xd7, 0x01, 0x45, + 0x3c, 0xed, 0x9e, 0xd7, 0x41, 0xf5, 0x9c, 0xd7, 0x41, 0xf5, 0x9b, 0xd7, + 0x41, 0x44, 0x0f, 0xee, 0x9a, 0xd7, 0x41, 0x44, 0x49, 0x95, 0x99, 0xd7, + 0x41, 0x43, 0x1b, 0x05, 0x98, 0xd7, 0x41, 0x44, 0x23, 0x22, 0x92, 0xd7, + 0x41, 0x46, 0x9d, 0x16, 0x94, 0xd7, 0x01, 0x42, 0x12, 0x00, 0x96, 0xd7, + 0x41, 0x44, 0x28, 0xdc, 0x93, 0xd7, 0x41, 0x42, 0x49, 0x00, 0xa6, 0xd7, + 0x41, 0x43, 0x43, 0x10, 0x91, 0xd7, 0x41, 0x44, 0x40, 0xea, 0x90, 0xd7, + 0x41, 0x45, 0x7e, 0x0b, 0xf4, 0xd7, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, + 0xf5, 0xd7, 0x01, 0x43, 0x7a, 0x0b, 0xed, 0xd7, 0x01, 0xb3, 0x14, 0xb4, + 0x06, 0x44, 0x80, 0x1f, 0xec, 0xd7, 0x41, 0x44, 0x25, 0x01, 0xef, 0xd7, + 0x01, 0x42, 0x15, 0x02, 0xee, 0xd7, 0x41, 0x44, 0x06, 0x1f, 0xf3, 0xd7, + 0x01, 0x42, 0x09, 0x24, 0xf2, 0xd7, 0x41, 0x43, 0xf9, 0x05, 0xf1, 0xd7, + 0x01, 0x43, 0xf6, 0x06, 0xf0, 0xd7, 0x41, 0xe1, 0xd4, 0xd5, 0x81, 0x8c, + 0x02, 0xe2, 0xd5, 0xd5, 0x81, 0x80, 0x02, 0xe3, 0xd6, 0xd5, 0x81, 0xf4, + 0x01, 0xe4, 0xd7, 0xd5, 0x81, 0xe8, 0x01, 0xe5, 0xd8, 0xd5, 0x81, 0xd6, + 0x01, 0xe6, 0xd9, 0xd5, 0x01, 0xe7, 0xda, 0xd5, 0x81, 0xc6, 0x01, 0xe8, + 0xdb, 0xd5, 0x01, 0xe9, 0xdc, 0xd5, 0x81, 0xb6, 0x01, 0xea, 0xdd, 0xd5, + 0x01, 0xeb, 0xde, 0xd5, 0x81, 0xa6, 0x01, 0xec, 0xdf, 0xd5, 0x81, 0x9a, + 0x01, 0xed, 0xe0, 0xd5, 0x81, 0x90, 0x01, 0xee, 0xe1, 0xd5, 0x81, 0x86, + 0x01, 0xef, 0xe2, 0xd5, 0x81, 0x72, 0xf0, 0xe3, 0xd5, 0x81, 0x5d, 0xf1, + 0xe4, 0xd5, 0x01, 0xf2, 0xe5, 0xd5, 0x81, 0x4e, 0xf3, 0xe6, 0xd5, 0x81, + 0x43, 0xf4, 0xe7, 0xd5, 0x81, 0x2b, 0xf5, 0xe8, 0xd5, 0x81, 0x20, 0xf6, + 0xe9, 0xd5, 0x01, 0xf7, 0xea, 0xd5, 0x01, 0xf8, 0xeb, 0xd5, 0x81, 0x0f, + 0xf9, 0xec, 0xd5, 0x01, 0xfa, 0xed, 0xd5, 0xc1, 0x00, 0x43, 0x43, 0x10, + 0x5b, 0xd7, 0x41, 0xe9, 0x63, 0xd7, 0x41, 0x46, 0x9d, 0x16, 0x6a, 0xd7, + 0x41, 0x42, 0xb4, 0x25, 0x69, 0xd7, 0x01, 0x44, 0xf8, 0x78, 0x5d, 0xd7, + 0xc1, 0x00, 0x47, 0x15, 0x08, 0x67, 0xd7, 0x41, 0x44, 0xe2, 0x20, 0x68, + 0xd7, 0x41, 0x42, 0x0b, 0x00, 0x66, 0xd7, 0x41, 0x42, 0x49, 0x00, 0x6b, + 0xd7, 0x01, 0xe9, 0x65, 0xd7, 0x01, 0x42, 0x5a, 0x03, 0x6d, 0xd7, 0x41, + 0xad, 0x01, 0xff, 0x43, 0xf5, 0x05, 0x6e, 0xd7, 0x01, 0x45, 0x3c, 0xed, + 0x64, 0xd7, 0x41, 0xf5, 0x62, 0xd7, 0x41, 0xf5, 0x61, 0xd7, 0x41, 0x44, + 0x0f, 0xee, 0x60, 0xd7, 0x41, 0x44, 0x49, 0x95, 0x5f, 0xd7, 0x41, 0x43, + 0x1b, 0x05, 0x5e, 0xd7, 0x41, 0x44, 0x23, 0x22, 0x58, 0xd7, 0x41, 0x46, + 0x9d, 0x16, 0x5a, 0xd7, 0x01, 0x42, 0x12, 0x00, 0x5c, 0xd7, 0x41, 0x44, + 0x28, 0xdc, 0x59, 0xd7, 0x41, 0x42, 0x49, 0x00, 0x6c, 0xd7, 0x41, 0x43, + 0x43, 0x10, 0x57, 0xd7, 0x41, 0x44, 0x40, 0xea, 0x56, 0xd7, 0x41, 0x04, + 0xca, 0x00, 0x06, 0x4d, 0x04, 0x33, 0xcb, 0x27, 0x40, 0x4d, 0xed, 0x0f, + 0xe9, 0x27, 0x00, 0x54, 0xc7, 0x43, 0xeb, 0x27, 0x00, 0x55, 0x68, 0x3d, + 0xef, 0x27, 0x00, 0x06, 0xad, 0x02, 0x01, 0xff, 0x4e, 0x36, 0x28, 0xe7, + 0x27, 0x00, 0x56, 0x79, 0x09, 0xed, 0x27, 0x40, 0x08, 0x0b, 0x06, 0xb3, + 0x01, 0x06, 0xef, 0x06, 0x6d, 0x06, 0x5d, 0x07, 0x01, 0xff, 0xe1, 0x8a, + 0xd6, 0x01, 0xe2, 0x8b, 0xd6, 0x01, 0xe3, 0x8c, 0xd6, 0x01, 0xe4, 0x8d, + 0xd6, 0x01, 0xe5, 0x8e, 0xd6, 0x01, 0xe6, 0x8f, 0xd6, 0x01, 0xe7, 0x90, + 0xd6, 0x01, 0xe8, 0x91, 0xd6, 0x01, 0xe9, 0x92, 0xd6, 0x01, 0xea, 0x93, + 0xd6, 0x01, 0xeb, 0x94, 0xd6, 0x01, 0xec, 0x95, 0xd6, 0x01, 0xed, 0x96, + 0xd6, 0x01, 0xee, 0x97, 0xd6, 0x01, 0xef, 0x98, 0xd6, 0x01, 0xf0, 0x99, + 0xd6, 0x01, 0xf1, 0x9a, 0xd6, 0x01, 0xf2, 0x9b, 0xd6, 0x01, 0xf3, 0x9c, + 0xd6, 0x01, 0xf4, 0x9d, 0xd6, 0x01, 0xf5, 0x9e, 0xd6, 0x01, 0xf6, 0x9f, + 0xd6, 0x01, 0xf7, 0xa0, 0xd6, 0x01, 0xf8, 0xa1, 0xd6, 0x01, 0xf9, 0xa2, + 0xd6, 0x01, 0xfa, 0xa3, 0xd6, 0x41, 0x45, 0x7e, 0x0b, 0xfe, 0xd7, 0x01, + 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xff, 0xd7, 0x01, 0x43, 0x7a, 0x0b, 0xf7, + 0xd7, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xf6, 0xd7, 0x41, + 0x44, 0x25, 0x01, 0xf9, 0xd7, 0x01, 0x42, 0x15, 0x02, 0xf8, 0xd7, 0x41, + 0x44, 0x06, 0x1f, 0xfd, 0xd7, 0x01, 0x42, 0x09, 0x24, 0xfc, 0xd7, 0x41, + 0x43, 0xf9, 0x05, 0xfb, 0xd7, 0x01, 0x43, 0xf6, 0x06, 0xfa, 0xd7, 0x41, + 0xe1, 0x70, 0xd6, 0x01, 0xe2, 0x71, 0xd6, 0x01, 0xe3, 0x72, 0xd6, 0x01, + 0xe4, 0x73, 0xd6, 0x01, 0xe5, 0x74, 0xd6, 0x01, 0xe6, 0x75, 0xd6, 0x01, + 0xe7, 0x76, 0xd6, 0x01, 0xe8, 0x77, 0xd6, 0x01, 0xe9, 0x78, 0xd6, 0x01, + 0xea, 0x79, 0xd6, 0x01, 0xeb, 0x7a, 0xd6, 0x01, 0xec, 0x7b, 0xd6, 0x01, + 0xed, 0x7c, 0xd6, 0x01, 0xee, 0x7d, 0xd6, 0x01, 0xef, 0x7e, 0xd6, 0x01, + 0xf0, 0x7f, 0xd6, 0x01, 0xf1, 0x80, 0xd6, 0x01, 0xf2, 0x81, 0xd6, 0x01, + 0xf3, 0x82, 0xd6, 0x01, 0xf4, 0x83, 0xd6, 0x01, 0xf5, 0x84, 0xd6, 0x01, + 0xf6, 0x85, 0xd6, 0x01, 0xf7, 0x86, 0xd6, 0x01, 0xf8, 0x87, 0xd6, 0x01, + 0xf9, 0x88, 0xd6, 0x01, 0xfa, 0x89, 0xd6, 0x41, 0x4d, 0xed, 0x0f, 0xe8, + 0x27, 0x00, 0x54, 0xc7, 0x43, 0xea, 0x27, 0x00, 0x55, 0x68, 0x3d, 0xee, + 0x27, 0x00, 0x06, 0xad, 0x02, 0x01, 0xff, 0x4e, 0x36, 0x28, 0xe6, 0x27, + 0x00, 0x56, 0x79, 0x09, 0xec, 0x27, 0x40, 0x08, 0x0b, 0x06, 0xde, 0x02, + 0x4e, 0x9c, 0x16, 0x16, 0xd7, 0x01, 0x4c, 0x48, 0x95, 0x18, 0xd7, 0x01, + 0x45, 0xdb, 0xee, 0xfb, 0xd6, 0x01, 0xb0, 0xb7, 0x02, 0x4a, 0xdc, 0xb5, + 0x1a, 0xd7, 0x01, 0x06, 0x5d, 0x07, 0x06, 0x4c, 0xc4, 0x9a, 0x17, 0xd7, + 0x41, 0xe1, 0x4e, 0xd4, 0x81, 0x9b, 0x02, 0xe2, 0x4f, 0xd4, 0x81, 0x8f, + 0x02, 0xe3, 0x50, 0xd4, 0x81, 0x83, 0x02, 0xe4, 0x51, 0xd4, 0x81, 0xea, + 0x01, 0xe5, 0x52, 0xd4, 0x81, 0xd8, 0x01, 0xe6, 0x53, 0xd4, 0x81, 0xcc, + 0x01, 0xe7, 0x54, 0xd4, 0x81, 0xc0, 0x01, 0xe9, 0x56, 0xd4, 0x81, 0xb4, + 0x01, 0xea, 0x57, 0xd4, 0x01, 0xeb, 0x58, 0xd4, 0x81, 0xa4, 0x01, 0xec, + 0x59, 0xd4, 0x81, 0x92, 0x01, 0xed, 0x5a, 0xd4, 0x81, 0x88, 0x01, 0xee, + 0x5b, 0xd4, 0x81, 0x7f, 0xef, 0x5c, 0xd4, 0x81, 0x6b, 0xf0, 0x5d, 0xd4, + 0x81, 0x56, 0xf1, 0x5e, 0xd4, 0x01, 0xf2, 0x5f, 0xd4, 0x81, 0x47, 0xf3, + 0x60, 0xd4, 0x81, 0x3c, 0xf4, 0x61, 0xd4, 0x81, 0x2b, 0xf5, 0x62, 0xd4, + 0x81, 0x20, 0xf6, 0x63, 0xd4, 0x01, 0xf7, 0x64, 0xd4, 0x01, 0xf8, 0x65, + 0xd4, 0x81, 0x0f, 0xf9, 0x66, 0xd4, 0x01, 0xfa, 0x67, 0xd4, 0xc1, 0x00, + 0x43, 0x43, 0x10, 0x01, 0xd7, 0x41, 0xe9, 0x09, 0xd7, 0x41, 0x46, 0x9d, + 0x16, 0x10, 0xd7, 0x41, 0x42, 0xb4, 0x25, 0x0f, 0xd7, 0x01, 0x44, 0xf8, + 0x78, 0x03, 0xd7, 0x41, 0x44, 0xe2, 0x20, 0x0e, 0xd7, 0x41, 0x42, 0x0b, + 0x00, 0x0c, 0xd7, 0x41, 0x42, 0x49, 0x00, 0x11, 0xd7, 0x01, 0xe9, 0x0b, + 0xd7, 0x01, 0x42, 0x5a, 0x03, 0x13, 0xd7, 0x41, 0xad, 0x01, 0xff, 0x43, + 0xf5, 0x05, 0x14, 0xd7, 0x01, 0x45, 0x3c, 0xed, 0x0a, 0xd7, 0x41, 0xf5, + 0x08, 0xd7, 0x41, 0xf5, 0x07, 0xd7, 0x41, 0x44, 0x0f, 0xee, 0x06, 0xd7, + 0x01, 0x5f, 0xde, 0x11, 0xa6, 0xd6, 0x41, 0x44, 0x49, 0x95, 0x05, 0xd7, + 0x41, 0x43, 0x1b, 0x05, 0x04, 0xd7, 0x41, 0x44, 0x23, 0x22, 0xfe, 0xd6, + 0x41, 0x4a, 0x43, 0xa1, 0x0d, 0xd7, 0x41, 0x46, 0x9d, 0x16, 0x00, 0xd7, + 0x01, 0x42, 0x12, 0x00, 0x02, 0xd7, 0x41, 0x44, 0x28, 0xdc, 0xff, 0xd6, + 0x01, 0x07, 0xb4, 0x43, 0x01, 0xff, 0xe9, 0xa4, 0xd6, 0x01, 0xea, 0xa5, + 0xd6, 0x41, 0x42, 0x49, 0x00, 0x12, 0xd7, 0x41, 0x43, 0x43, 0x10, 0xfd, + 0xd6, 0x41, 0x44, 0x40, 0xea, 0xfc, 0xd6, 0x41, 0x53, 0x85, 0x4a, 0x15, + 0xd7, 0x01, 0x49, 0x2d, 0xbf, 0x19, 0xd7, 0x01, 0x48, 0xbc, 0x97, 0x1b, + 0xd7, 0x41, 0xe1, 0x34, 0xd4, 0x81, 0x8c, 0x02, 0xe2, 0x35, 0xd4, 0x81, + 0x80, 0x02, 0xe3, 0x36, 0xd4, 0x81, 0xf4, 0x01, 0xe4, 0x37, 0xd4, 0x81, + 0xe8, 0x01, 0xe5, 0x38, 0xd4, 0x81, 0xd6, 0x01, 0xe6, 0x39, 0xd4, 0x01, + 0xe7, 0x3a, 0xd4, 0x81, 0xc6, 0x01, 0xe8, 0x3b, 0xd4, 0x01, 0xe9, 0x3c, + 0xd4, 0x81, 0xb6, 0x01, 0xea, 0x3d, 0xd4, 0x01, 0xeb, 0x3e, 0xd4, 0x81, + 0xa6, 0x01, 0xec, 0x3f, 0xd4, 0x81, 0x9a, 0x01, 0xed, 0x40, 0xd4, 0x81, + 0x90, 0x01, 0xee, 0x41, 0xd4, 0x81, 0x86, 0x01, 0xef, 0x42, 0xd4, 0x81, + 0x72, 0xf0, 0x43, 0xd4, 0x81, 0x5d, 0xf1, 0x44, 0xd4, 0x01, 0xf2, 0x45, + 0xd4, 0x81, 0x4e, 0xf3, 0x46, 0xd4, 0x81, 0x43, 0xf4, 0x47, 0xd4, 0x81, + 0x2b, 0xf5, 0x48, 0xd4, 0x81, 0x20, 0xf6, 0x49, 0xd4, 0x01, 0xf7, 0x4a, + 0xd4, 0x01, 0xf8, 0x4b, 0xd4, 0x81, 0x0f, 0xf9, 0x4c, 0xd4, 0x01, 0xfa, + 0x4d, 0xd4, 0xc1, 0x00, 0x43, 0x43, 0x10, 0xe7, 0xd6, 0x41, 0xe9, 0xef, + 0xd6, 0x41, 0x46, 0x9d, 0x16, 0xf6, 0xd6, 0x41, 0x42, 0xb4, 0x25, 0xf5, + 0xd6, 0x01, 0x44, 0xf8, 0x78, 0xe9, 0xd6, 0xc1, 0x00, 0x47, 0x15, 0x08, + 0xf3, 0xd6, 0x41, 0x44, 0xe2, 0x20, 0xf4, 0xd6, 0x41, 0x42, 0x0b, 0x00, + 0xf2, 0xd6, 0x41, 0x42, 0x49, 0x00, 0xf7, 0xd6, 0x01, 0xe9, 0xf1, 0xd6, + 0x01, 0x42, 0x5a, 0x03, 0xf9, 0xd6, 0x41, 0xad, 0x01, 0xff, 0x43, 0xf5, + 0x05, 0xfa, 0xd6, 0x01, 0x45, 0x3c, 0xed, 0xf0, 0xd6, 0x41, 0xf5, 0xee, + 0xd6, 0x41, 0xf5, 0xed, 0xd6, 0x41, 0x44, 0x0f, 0xee, 0xec, 0xd6, 0x41, + 0x44, 0x49, 0x95, 0xeb, 0xd6, 0x41, 0x43, 0x1b, 0x05, 0xea, 0xd6, 0x41, + 0x44, 0x23, 0x22, 0xe4, 0xd6, 0x41, 0x46, 0x9d, 0x16, 0xe6, 0xd6, 0x01, + 0x42, 0x12, 0x00, 0xe8, 0xd6, 0x41, 0x44, 0x28, 0xdc, 0xe5, 0xd6, 0x41, + 0x42, 0x49, 0x00, 0xf8, 0xd6, 0x41, 0x43, 0x43, 0x10, 0xe3, 0xd6, 0x41, + 0x44, 0x40, 0xea, 0xe2, 0xd6, 0x41, 0x4f, 0x46, 0x3b, 0xcd, 0x27, 0x00, + 0x07, 0xf0, 0xcb, 0x01, 0xff, 0x08, 0x0b, 0x06, 0x6d, 0x06, 0x5d, 0x07, + 0x01, 0xff, 0xe1, 0x1e, 0xd5, 0x01, 0xe2, 0x1f, 0xd5, 0x01, 0xe3, 0x20, + 0xd5, 0x01, 0xe4, 0x21, 0xd5, 0x01, 0xe5, 0x22, 0xd5, 0x01, 0xe6, 0x23, + 0xd5, 0x01, 0xe7, 0x24, 0xd5, 0x01, 0xe8, 0x25, 0xd5, 0x01, 0xe9, 0x26, + 0xd5, 0x01, 0xea, 0x27, 0xd5, 0x01, 0xeb, 0x28, 0xd5, 0x01, 0xec, 0x29, + 0xd5, 0x01, 0xed, 0x2a, 0xd5, 0x01, 0xee, 0x2b, 0xd5, 0x01, 0xef, 0x2c, + 0xd5, 0x01, 0xf0, 0x2d, 0xd5, 0x01, 0xf1, 0x2e, 0xd5, 0x01, 0xf2, 0x2f, + 0xd5, 0x01, 0xf3, 0x30, 0xd5, 0x01, 0xf4, 0x31, 0xd5, 0x01, 0xf5, 0x32, + 0xd5, 0x01, 0xf6, 0x33, 0xd5, 0x01, 0xf7, 0x34, 0xd5, 0x01, 0xf8, 0x35, + 0xd5, 0x01, 0xf9, 0x36, 0xd5, 0x01, 0xfa, 0x37, 0xd5, 0x41, 0xe1, 0x04, + 0xd5, 0x01, 0xe2, 0x05, 0xd5, 0x01, 0xe4, 0x07, 0xd5, 0x01, 0xe5, 0x08, + 0xd5, 0x01, 0xe6, 0x09, 0xd5, 0x01, 0xe7, 0x0a, 0xd5, 0x01, 0xea, 0x0d, + 0xd5, 0x01, 0xeb, 0x0e, 0xd5, 0x01, 0xec, 0x0f, 0xd5, 0x01, 0xed, 0x10, + 0xd5, 0x01, 0xee, 0x11, 0xd5, 0x01, 0xef, 0x12, 0xd5, 0x01, 0xf0, 0x13, + 0xd5, 0x01, 0xf1, 0x14, 0xd5, 0x01, 0xf3, 0x16, 0xd5, 0x01, 0xf4, 0x17, + 0xd5, 0x01, 0xf5, 0x18, 0xd5, 0x01, 0xf6, 0x19, 0xd5, 0x01, 0xf7, 0x1a, + 0xd5, 0x01, 0xf8, 0x1b, 0xd5, 0x01, 0xf9, 0x1c, 0xd5, 0x41, 0x08, 0x0b, + 0x06, 0xb3, 0x01, 0x06, 0xef, 0x06, 0x6d, 0x06, 0x5d, 0x07, 0x01, 0xff, + 0xe1, 0x52, 0xd5, 0x01, 0xe2, 0x53, 0xd5, 0x01, 0xe3, 0x54, 0xd5, 0x01, + 0xe4, 0x55, 0xd5, 0x01, 0xe5, 0x56, 0xd5, 0x01, 0xe6, 0x57, 0xd5, 0x01, + 0xe7, 0x58, 0xd5, 0x01, 0xe8, 0x59, 0xd5, 0x01, 0xe9, 0x5a, 0xd5, 0x01, + 0xea, 0x5b, 0xd5, 0x01, 0xeb, 0x5c, 0xd5, 0x01, 0xec, 0x5d, 0xd5, 0x01, + 0xed, 0x5e, 0xd5, 0x01, 0xee, 0x5f, 0xd5, 0x01, 0xef, 0x60, 0xd5, 0x01, + 0xf0, 0x61, 0xd5, 0x01, 0xf1, 0x62, 0xd5, 0x01, 0xf2, 0x63, 0xd5, 0x01, + 0xf3, 0x64, 0xd5, 0x01, 0xf4, 0x65, 0xd5, 0x01, 0xf5, 0x66, 0xd5, 0x01, + 0xf6, 0x67, 0xd5, 0x01, 0xf7, 0x68, 0xd5, 0x01, 0xf8, 0x69, 0xd5, 0x01, + 0xf9, 0x6a, 0xd5, 0x01, 0xfa, 0x6b, 0xd5, 0x41, 0x45, 0x7e, 0x0b, 0xe0, + 0xd7, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xe1, 0xd7, 0x01, 0x43, 0x7a, + 0x0b, 0xd9, 0xd7, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xd8, + 0xd7, 0x41, 0x44, 0x25, 0x01, 0xdb, 0xd7, 0x01, 0x42, 0x15, 0x02, 0xda, + 0xd7, 0x41, 0x44, 0x06, 0x1f, 0xdf, 0xd7, 0x01, 0x42, 0x09, 0x24, 0xde, + 0xd7, 0x41, 0x43, 0xf9, 0x05, 0xdd, 0xd7, 0x01, 0x43, 0xf6, 0x06, 0xdc, + 0xd7, 0x41, 0xe1, 0x38, 0xd5, 0x01, 0xe2, 0x39, 0xd5, 0x01, 0xe4, 0x3b, + 0xd5, 0x01, 0xe5, 0x3c, 0xd5, 0x01, 0xe6, 0x3d, 0xd5, 0x01, 0xe7, 0x3e, + 0xd5, 0x01, 0xe9, 0x40, 0xd5, 0x01, 0xea, 0x41, 0xd5, 0x01, 0xeb, 0x42, + 0xd5, 0x01, 0xec, 0x43, 0xd5, 0x01, 0xed, 0x44, 0xd5, 0x01, 0xef, 0x46, + 0xd5, 0x01, 0xf3, 0x4a, 0xd5, 0x01, 0xf4, 0x4b, 0xd5, 0x01, 0xf5, 0x4c, + 0xd5, 0x01, 0xf6, 0x4d, 0xd5, 0x01, 0xf7, 0x4e, 0xd5, 0x01, 0xf8, 0x4f, + 0xd5, 0x01, 0xf9, 0x50, 0xd5, 0x41, 0x08, 0x0b, 0x06, 0xcc, 0x0b, 0x06, + 0xef, 0x06, 0x85, 0x0b, 0x4e, 0x9c, 0x16, 0xdc, 0xd6, 0x01, 0x08, 0xef, + 0xcb, 0xa1, 0x09, 0x07, 0xe6, 0xd7, 0xb0, 0x04, 0x4c, 0x48, 0x95, 0xde, + 0xd6, 0x01, 0x45, 0xdb, 0xee, 0xc1, 0xd6, 0x01, 0xb0, 0x8f, 0x04, 0x4a, + 0xdc, 0xb5, 0xe0, 0xd6, 0x01, 0xb3, 0x06, 0x4c, 0xc4, 0x9a, 0xdd, 0xd6, + 0x41, 0x06, 0x75, 0x06, 0xa3, 0x02, 0x05, 0x5e, 0x07, 0x01, 0xff, 0xe1, + 0x1a, 0xd4, 0x81, 0x92, 0x02, 0xe2, 0x1b, 0xd4, 0x81, 0x86, 0x02, 0xe3, + 0x1c, 0xd4, 0x81, 0xfa, 0x01, 0xe4, 0x1d, 0xd4, 0x81, 0xe8, 0x01, 0xe5, + 0x1e, 0xd4, 0x81, 0xd6, 0x01, 0xe6, 0x1f, 0xd4, 0x81, 0xca, 0x01, 0xe7, + 0x20, 0xd4, 0x81, 0xbe, 0x01, 0xe8, 0x21, 0xd4, 0x01, 0xe9, 0x22, 0xd4, + 0x81, 0xae, 0x01, 0xea, 0x23, 0xd4, 0x01, 0xeb, 0x24, 0xd4, 0x81, 0x9e, + 0x01, 0xec, 0x25, 0xd4, 0x81, 0x92, 0x01, 0xed, 0x26, 0xd4, 0x81, 0x88, + 0x01, 0xee, 0x27, 0xd4, 0x81, 0x7f, 0xef, 0x28, 0xd4, 0x81, 0x6b, 0xf0, + 0x29, 0xd4, 0x81, 0x56, 0xf1, 0x2a, 0xd4, 0x01, 0xf2, 0x2b, 0xd4, 0x81, + 0x47, 0xf3, 0x2c, 0xd4, 0x81, 0x3c, 0xf4, 0x2d, 0xd4, 0x81, 0x2b, 0xf5, + 0x2e, 0xd4, 0x81, 0x20, 0xf6, 0x2f, 0xd4, 0x01, 0xf7, 0x30, 0xd4, 0x01, + 0xf8, 0x31, 0xd4, 0x81, 0x0f, 0xf9, 0x32, 0xd4, 0x01, 0xfa, 0x33, 0xd4, + 0xc1, 0x00, 0x43, 0x43, 0x10, 0xc7, 0xd6, 0x41, 0xe9, 0xcf, 0xd6, 0x41, + 0x46, 0x9d, 0x16, 0xd6, 0xd6, 0x41, 0x42, 0xb4, 0x25, 0xd5, 0xd6, 0x01, + 0x44, 0xf8, 0x78, 0xc9, 0xd6, 0x41, 0x44, 0xe2, 0x20, 0xd4, 0xd6, 0x41, + 0x42, 0x0b, 0x00, 0xd2, 0xd6, 0x41, 0x42, 0x49, 0x00, 0xd7, 0xd6, 0x01, + 0xe9, 0xd1, 0xd6, 0x01, 0x42, 0x5a, 0x03, 0xd9, 0xd6, 0x41, 0xad, 0x01, + 0xff, 0x43, 0xf5, 0x05, 0xda, 0xd6, 0x01, 0x45, 0x3c, 0xed, 0xd0, 0xd6, + 0x41, 0xf5, 0xce, 0xd6, 0x41, 0xf5, 0xcd, 0xd6, 0x41, 0x44, 0x0f, 0xee, + 0xcc, 0xd6, 0x41, 0x44, 0x49, 0x95, 0xcb, 0xd6, 0x41, 0x43, 0x1b, 0x05, + 0xca, 0xd6, 0x41, 0x44, 0x23, 0x22, 0xc4, 0xd6, 0x41, 0x4a, 0x43, 0xa1, + 0xd3, 0xd6, 0x41, 0x46, 0x9d, 0x16, 0xc6, 0xd6, 0x01, 0x42, 0x12, 0x00, + 0xc8, 0xd6, 0x41, 0x44, 0x28, 0xdc, 0xc5, 0xd6, 0x01, 0x46, 0xac, 0x5a, + 0xcb, 0xd7, 0x41, 0x42, 0x49, 0x00, 0xd8, 0xd6, 0x41, 0x43, 0x43, 0x10, + 0xc3, 0xd6, 0x41, 0x44, 0x40, 0xea, 0xc2, 0xd6, 0x41, 0x08, 0x0b, 0x06, + 0x6d, 0x06, 0x5d, 0x07, 0x01, 0xff, 0xe1, 0xea, 0xd4, 0x01, 0xe2, 0xeb, + 0xd4, 0x01, 0xe3, 0xec, 0xd4, 0x01, 0xe4, 0xed, 0xd4, 0x01, 0xe5, 0xee, + 0xd4, 0x01, 0xe6, 0xef, 0xd4, 0x01, 0xe7, 0xf0, 0xd4, 0x01, 0xe8, 0xf1, + 0xd4, 0x01, 0xe9, 0xf2, 0xd4, 0x01, 0xea, 0xf3, 0xd4, 0x01, 0xeb, 0xf4, + 0xd4, 0x01, 0xec, 0xf5, 0xd4, 0x01, 0xed, 0xf6, 0xd4, 0x01, 0xee, 0xf7, + 0xd4, 0x01, 0xef, 0xf8, 0xd4, 0x01, 0xf0, 0xf9, 0xd4, 0x01, 0xf1, 0xfa, + 0xd4, 0x01, 0xf2, 0xfb, 0xd4, 0x01, 0xf3, 0xfc, 0xd4, 0x01, 0xf4, 0xfd, + 0xd4, 0x01, 0xf5, 0xfe, 0xd4, 0x01, 0xf6, 0xff, 0xd4, 0x01, 0xf7, 0x00, + 0xd5, 0x01, 0xf8, 0x01, 0xd5, 0x01, 0xf9, 0x02, 0xd5, 0x01, 0xfa, 0x03, + 0xd5, 0x41, 0xe1, 0xd0, 0xd4, 0x01, 0xe2, 0xd1, 0xd4, 0x01, 0xe3, 0xd2, + 0xd4, 0x01, 0xe4, 0xd3, 0xd4, 0x01, 0xe5, 0xd4, 0xd4, 0x01, 0xe6, 0xd5, + 0xd4, 0x01, 0xe7, 0xd6, 0xd4, 0x01, 0xe8, 0xd7, 0xd4, 0x01, 0xe9, 0xd8, + 0xd4, 0x01, 0xea, 0xd9, 0xd4, 0x01, 0xeb, 0xda, 0xd4, 0x01, 0xec, 0xdb, + 0xd4, 0x01, 0xed, 0xdc, 0xd4, 0x01, 0xee, 0xdd, 0xd4, 0x01, 0xef, 0xde, + 0xd4, 0x01, 0xf0, 0xdf, 0xd4, 0x01, 0xf1, 0xe0, 0xd4, 0x01, 0xf2, 0xe1, + 0xd4, 0x01, 0xf3, 0xe2, 0xd4, 0x01, 0xf4, 0xe3, 0xd4, 0x01, 0xf5, 0xe4, + 0xd4, 0x01, 0xf6, 0xe5, 0xd4, 0x01, 0xf7, 0xe6, 0xd4, 0x01, 0xf8, 0xe7, + 0xd4, 0x01, 0xf9, 0xe8, 0xd4, 0x01, 0xfa, 0xe9, 0xd4, 0x41, 0x53, 0x85, + 0x4a, 0xdb, 0xd6, 0x01, 0x49, 0x2d, 0xbf, 0xdf, 0xd6, 0x01, 0x48, 0xbc, + 0x97, 0xe1, 0xd6, 0x41, 0x08, 0x0b, 0x06, 0xcf, 0x02, 0x4e, 0x9c, 0x16, + 0x50, 0xd7, 0x01, 0x4c, 0x48, 0x95, 0x52, 0xd7, 0x01, 0x45, 0xdb, 0xee, + 0x35, 0xd7, 0x01, 0xb0, 0xa8, 0x02, 0x4a, 0xdc, 0xb5, 0x54, 0xd7, 0x01, + 0x06, 0x5d, 0x07, 0x06, 0x4c, 0xc4, 0x9a, 0x51, 0xd7, 0x41, 0xe1, 0x82, + 0xd4, 0x81, 0x8c, 0x02, 0xe2, 0x83, 0xd4, 0x81, 0x80, 0x02, 0xe3, 0x84, + 0xd4, 0x81, 0xf4, 0x01, 0xe4, 0x85, 0xd4, 0x81, 0xe8, 0x01, 0xe5, 0x86, + 0xd4, 0x81, 0xd6, 0x01, 0xe6, 0x87, 0xd4, 0x81, 0xca, 0x01, 0xe7, 0x88, + 0xd4, 0x81, 0xbe, 0x01, 0xe8, 0x89, 0xd4, 0x01, 0xe9, 0x8a, 0xd4, 0x81, + 0xae, 0x01, 0xea, 0x8b, 0xd4, 0x01, 0xeb, 0x8c, 0xd4, 0x81, 0x9e, 0x01, + 0xec, 0x8d, 0xd4, 0x81, 0x92, 0x01, 0xed, 0x8e, 0xd4, 0x81, 0x88, 0x01, + 0xee, 0x8f, 0xd4, 0x81, 0x7f, 0xef, 0x90, 0xd4, 0x81, 0x6b, 0xf0, 0x91, + 0xd4, 0x81, 0x56, 0xf1, 0x92, 0xd4, 0x01, 0xf2, 0x93, 0xd4, 0x81, 0x47, + 0xf3, 0x94, 0xd4, 0x81, 0x3c, 0xf4, 0x95, 0xd4, 0x81, 0x2b, 0xf5, 0x96, + 0xd4, 0x81, 0x20, 0xf6, 0x97, 0xd4, 0x01, 0xf7, 0x98, 0xd4, 0x01, 0xf8, + 0x99, 0xd4, 0x81, 0x0f, 0xf9, 0x9a, 0xd4, 0x01, 0xfa, 0x9b, 0xd4, 0xc1, + 0x00, 0x43, 0x43, 0x10, 0x3b, 0xd7, 0x41, 0xe9, 0x43, 0xd7, 0x41, 0x46, + 0x9d, 0x16, 0x4a, 0xd7, 0x41, 0x42, 0xb4, 0x25, 0x49, 0xd7, 0x01, 0x44, + 0xf8, 0x78, 0x3d, 0xd7, 0x41, 0x44, 0xe2, 0x20, 0x48, 0xd7, 0x41, 0x42, + 0x0b, 0x00, 0x46, 0xd7, 0x41, 0x42, 0x49, 0x00, 0x4b, 0xd7, 0x01, 0xe9, + 0x45, 0xd7, 0x01, 0x42, 0x5a, 0x03, 0x4d, 0xd7, 0x41, 0xad, 0x01, 0xff, + 0x43, 0xf5, 0x05, 0x4e, 0xd7, 0x01, 0x45, 0x3c, 0xed, 0x44, 0xd7, 0x41, + 0xf5, 0x42, 0xd7, 0x41, 0xf5, 0x41, 0xd7, 0x41, 0x44, 0x0f, 0xee, 0x40, + 0xd7, 0x41, 0x44, 0x49, 0x95, 0x3f, 0xd7, 0x41, 0x43, 0x1b, 0x05, 0x3e, + 0xd7, 0x41, 0x44, 0x23, 0x22, 0x38, 0xd7, 0x41, 0x4a, 0x43, 0xa1, 0x47, + 0xd7, 0x41, 0x46, 0x9d, 0x16, 0x3a, 0xd7, 0x01, 0x42, 0x12, 0x00, 0x3c, + 0xd7, 0x41, 0x44, 0x28, 0xdc, 0x39, 0xd7, 0x41, 0x42, 0x49, 0x00, 0x4c, + 0xd7, 0x41, 0x43, 0x43, 0x10, 0x37, 0xd7, 0x41, 0x44, 0x40, 0xea, 0x36, + 0xd7, 0x41, 0x53, 0x85, 0x4a, 0x4f, 0xd7, 0x01, 0x49, 0x2d, 0xbf, 0x53, + 0xd7, 0x01, 0x48, 0xbc, 0x97, 0x55, 0xd7, 0x41, 0xe1, 0x68, 0xd4, 0x81, + 0x8c, 0x02, 0xe2, 0x69, 0xd4, 0x81, 0x80, 0x02, 0xe3, 0x6a, 0xd4, 0x81, + 0xf4, 0x01, 0xe4, 0x6b, 0xd4, 0x81, 0xe8, 0x01, 0xe5, 0x6c, 0xd4, 0x81, + 0xd6, 0x01, 0xe6, 0x6d, 0xd4, 0x01, 0xe7, 0x6e, 0xd4, 0x81, 0xc6, 0x01, + 0xe8, 0x6f, 0xd4, 0x01, 0xe9, 0x70, 0xd4, 0x81, 0xb6, 0x01, 0xea, 0x71, + 0xd4, 0x01, 0xeb, 0x72, 0xd4, 0x81, 0xa6, 0x01, 0xec, 0x73, 0xd4, 0x81, + 0x9a, 0x01, 0xed, 0x74, 0xd4, 0x81, 0x90, 0x01, 0xee, 0x75, 0xd4, 0x81, + 0x86, 0x01, 0xef, 0x76, 0xd4, 0x81, 0x72, 0xf0, 0x77, 0xd4, 0x81, 0x5d, + 0xf1, 0x78, 0xd4, 0x01, 0xf2, 0x79, 0xd4, 0x81, 0x4e, 0xf3, 0x7a, 0xd4, + 0x81, 0x43, 0xf4, 0x7b, 0xd4, 0x81, 0x2b, 0xf5, 0x7c, 0xd4, 0x81, 0x20, + 0xf6, 0x7d, 0xd4, 0x01, 0xf7, 0x7e, 0xd4, 0x01, 0xf8, 0x7f, 0xd4, 0x81, + 0x0f, 0xf9, 0x80, 0xd4, 0x01, 0xfa, 0x81, 0xd4, 0xc1, 0x00, 0x43, 0x43, + 0x10, 0x21, 0xd7, 0x41, 0xe9, 0x29, 0xd7, 0x41, 0x46, 0x9d, 0x16, 0x30, + 0xd7, 0x41, 0x42, 0xb4, 0x25, 0x2f, 0xd7, 0x01, 0x44, 0xf8, 0x78, 0x23, + 0xd7, 0xc1, 0x00, 0x47, 0x15, 0x08, 0x2d, 0xd7, 0x41, 0x44, 0xe2, 0x20, + 0x2e, 0xd7, 0x41, 0x42, 0x0b, 0x00, 0x2c, 0xd7, 0x41, 0x42, 0x49, 0x00, + 0x31, 0xd7, 0x01, 0xe9, 0x2b, 0xd7, 0x01, 0x42, 0x5a, 0x03, 0x33, 0xd7, + 0x41, 0xad, 0x01, 0xff, 0x43, 0xf5, 0x05, 0x34, 0xd7, 0x01, 0x45, 0x3c, + 0xed, 0x2a, 0xd7, 0x41, 0xf5, 0x28, 0xd7, 0x41, 0xf5, 0x27, 0xd7, 0x41, + 0x44, 0x0f, 0xee, 0x26, 0xd7, 0x41, 0x44, 0x49, 0x95, 0x25, 0xd7, 0x41, + 0x43, 0x1b, 0x05, 0x24, 0xd7, 0x41, 0x44, 0x23, 0x22, 0x1e, 0xd7, 0x41, + 0x46, 0x9d, 0x16, 0x20, 0xd7, 0x01, 0x42, 0x12, 0x00, 0x22, 0xd7, 0x41, + 0x44, 0x28, 0xdc, 0x1f, 0xd7, 0x41, 0x42, 0x49, 0x00, 0x32, 0xd7, 0x41, + 0x43, 0x43, 0x10, 0x1d, 0xd7, 0x41, 0x44, 0x40, 0xea, 0x1c, 0xd7, 0x41, + 0x08, 0x0b, 0x06, 0x6d, 0x06, 0x5d, 0x07, 0x01, 0xff, 0xe1, 0x86, 0xd5, + 0x01, 0xe2, 0x87, 0xd5, 0x01, 0xe3, 0x88, 0xd5, 0x01, 0xe4, 0x89, 0xd5, + 0x01, 0xe5, 0x8a, 0xd5, 0x01, 0xe6, 0x8b, 0xd5, 0x01, 0xe7, 0x8c, 0xd5, + 0x01, 0xe8, 0x8d, 0xd5, 0x01, 0xe9, 0x8e, 0xd5, 0x01, 0xea, 0x8f, 0xd5, + 0x01, 0xeb, 0x90, 0xd5, 0x01, 0xec, 0x91, 0xd5, 0x01, 0xed, 0x92, 0xd5, + 0x01, 0xee, 0x93, 0xd5, 0x01, 0xef, 0x94, 0xd5, 0x01, 0xf0, 0x95, 0xd5, + 0x01, 0xf1, 0x96, 0xd5, 0x01, 0xf2, 0x97, 0xd5, 0x01, 0xf3, 0x98, 0xd5, + 0x01, 0xf4, 0x99, 0xd5, 0x01, 0xf5, 0x9a, 0xd5, 0x01, 0xf6, 0x9b, 0xd5, + 0x01, 0xf7, 0x9c, 0xd5, 0x01, 0xf8, 0x9d, 0xd5, 0x01, 0xf9, 0x9e, 0xd5, + 0x01, 0xfa, 0x9f, 0xd5, 0x41, 0xe1, 0x6c, 0xd5, 0x01, 0xe2, 0x6d, 0xd5, + 0x01, 0xe3, 0x6e, 0xd5, 0x01, 0xe4, 0x6f, 0xd5, 0x01, 0xe5, 0x70, 0xd5, + 0x01, 0xe6, 0x71, 0xd5, 0x01, 0xe7, 0x72, 0xd5, 0x01, 0xe8, 0x73, 0xd5, + 0x01, 0xe9, 0x74, 0xd5, 0x01, 0xea, 0x75, 0xd5, 0x01, 0xeb, 0x76, 0xd5, + 0x01, 0xec, 0x77, 0xd5, 0x01, 0xed, 0x78, 0xd5, 0x01, 0xee, 0x79, 0xd5, + 0x01, 0xef, 0x7a, 0xd5, 0x01, 0xf0, 0x7b, 0xd5, 0x01, 0xf1, 0x7c, 0xd5, + 0x01, 0xf2, 0x7d, 0xd5, 0x01, 0xf3, 0x7e, 0xd5, 0x01, 0xf4, 0x7f, 0xd5, + 0x01, 0xf5, 0x80, 0xd5, 0x01, 0xf6, 0x81, 0xd5, 0x01, 0xf7, 0x82, 0xd5, + 0x01, 0xf8, 0x83, 0xd5, 0x01, 0xf9, 0x84, 0xd5, 0x01, 0xfa, 0x85, 0xd5, + 0x41, 0x45, 0x7e, 0x0b, 0xd6, 0xd7, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, + 0xd7, 0xd7, 0x01, 0x43, 0x7a, 0x0b, 0xcf, 0xd7, 0x01, 0xb3, 0x14, 0xb4, + 0x06, 0x44, 0x80, 0x1f, 0xce, 0xd7, 0x41, 0x44, 0x25, 0x01, 0xd1, 0xd7, + 0x01, 0x42, 0x15, 0x02, 0xd0, 0xd7, 0x41, 0x44, 0x06, 0x1f, 0xd5, 0xd7, + 0x01, 0x42, 0x09, 0x24, 0xd4, 0xd7, 0x41, 0x43, 0xf9, 0x05, 0xd3, 0xd7, + 0x01, 0x43, 0xf6, 0x06, 0xd2, 0xd7, 0x41, 0xe1, 0x00, 0xd4, 0x81, 0x92, + 0x02, 0xe2, 0x01, 0xd4, 0x81, 0x86, 0x02, 0xe3, 0x02, 0xd4, 0x81, 0xfa, + 0x01, 0xe4, 0x03, 0xd4, 0x81, 0xe8, 0x01, 0xe5, 0x04, 0xd4, 0x81, 0xd6, + 0x01, 0xe6, 0x05, 0xd4, 0x01, 0xe7, 0x06, 0xd4, 0x81, 0xc6, 0x01, 0xe8, + 0x07, 0xd4, 0x01, 0xe9, 0x08, 0xd4, 0x81, 0xb6, 0x01, 0xea, 0x09, 0xd4, + 0x01, 0xeb, 0x0a, 0xd4, 0x81, 0xa6, 0x01, 0xec, 0x0b, 0xd4, 0x81, 0x9a, + 0x01, 0xed, 0x0c, 0xd4, 0x81, 0x90, 0x01, 0xee, 0x0d, 0xd4, 0x81, 0x86, + 0x01, 0xef, 0x0e, 0xd4, 0x81, 0x72, 0xf0, 0x0f, 0xd4, 0x81, 0x5d, 0xf1, + 0x10, 0xd4, 0x01, 0xf2, 0x11, 0xd4, 0x81, 0x4e, 0xf3, 0x12, 0xd4, 0x81, + 0x43, 0xf4, 0x13, 0xd4, 0x81, 0x2b, 0xf5, 0x14, 0xd4, 0x81, 0x20, 0xf6, + 0x15, 0xd4, 0x01, 0xf7, 0x16, 0xd4, 0x01, 0xf8, 0x17, 0xd4, 0x81, 0x0f, + 0xf9, 0x18, 0xd4, 0x01, 0xfa, 0x19, 0xd4, 0xc1, 0x00, 0x43, 0x43, 0x10, + 0xad, 0xd6, 0x41, 0xe9, 0xb5, 0xd6, 0x41, 0x46, 0x9d, 0x16, 0xbc, 0xd6, + 0x41, 0x42, 0xb4, 0x25, 0xbb, 0xd6, 0x01, 0x44, 0xf8, 0x78, 0xaf, 0xd6, + 0xc1, 0x00, 0x47, 0x15, 0x08, 0xb9, 0xd6, 0x41, 0x44, 0xe2, 0x20, 0xba, + 0xd6, 0x41, 0x42, 0x0b, 0x00, 0xb8, 0xd6, 0x41, 0x42, 0x49, 0x00, 0xbd, + 0xd6, 0x01, 0xe9, 0xb7, 0xd6, 0x01, 0x42, 0x5a, 0x03, 0xbf, 0xd6, 0x41, + 0xad, 0x01, 0xff, 0x43, 0xf5, 0x05, 0xc0, 0xd6, 0x01, 0x45, 0x3c, 0xed, + 0xb6, 0xd6, 0x41, 0xf5, 0xb4, 0xd6, 0x41, 0xf5, 0xb3, 0xd6, 0x41, 0x44, + 0x0f, 0xee, 0xb2, 0xd6, 0x41, 0x44, 0x49, 0x95, 0xb1, 0xd6, 0x41, 0x43, + 0x1b, 0x05, 0xb0, 0xd6, 0x41, 0x44, 0x23, 0x22, 0xaa, 0xd6, 0x41, 0x46, + 0x9d, 0x16, 0xac, 0xd6, 0x01, 0x42, 0x12, 0x00, 0xae, 0xd6, 0x41, 0x44, + 0x28, 0xdc, 0xab, 0xd6, 0x01, 0x46, 0xac, 0x5a, 0xca, 0xd7, 0x41, 0x42, + 0x49, 0x00, 0xbe, 0xd6, 0x41, 0x43, 0x43, 0x10, 0xa9, 0xd6, 0x41, 0x44, + 0x40, 0xea, 0xa8, 0xd6, 0x41, 0x0b, 0x2a, 0x9e, 0x12, 0x58, 0x4c, 0x29, + 0xba, 0x00, 0x00, 0x4d, 0xf7, 0x88, 0xad, 0xf1, 0x01, 0x46, 0xf3, 0xd4, + 0x3c, 0x30, 0x40, 0x06, 0xef, 0x06, 0x82, 0x03, 0x07, 0x13, 0x06, 0x6c, + 0xb2, 0x5e, 0x05, 0x5a, 0x03, 0x3c, 0xb6, 0x01, 0xff, 0x45, 0x20, 0x25, + 0x45, 0x1d, 0x01, 0x0a, 0xc8, 0x7a, 0x01, 0xff, 0xa1, 0x20, 0xe5, 0x3a, + 0x1d, 0x01, 0xe9, 0x32, 0x1d, 0x81, 0x13, 0xef, 0x3d, 0x1d, 0x01, 0xf5, + 0x34, 0x1d, 0x81, 0x06, 0x49, 0xf2, 0xc6, 0x36, 0x1d, 0x41, 0xf5, 0x35, + 0x1d, 0x41, 0xe9, 0x33, 0x1d, 0x41, 0xe1, 0x31, 0x1d, 0x01, 0xe9, 0x3c, + 0x1d, 0x01, 0xf5, 0x3f, 0x1d, 0x41, 0x48, 0x0a, 0x17, 0x40, 0x1d, 0x01, + 0x46, 0x13, 0x25, 0x43, 0x1d, 0x01, 0x47, 0x3e, 0xd7, 0x44, 0x1d, 0x01, + 0x45, 0x62, 0x41, 0x42, 0x1d, 0x01, 0x47, 0x47, 0x4e, 0x41, 0x1d, 0x41, + 0x46, 0x58, 0xdf, 0x47, 0x1d, 0x01, 0x44, 0x41, 0xcb, 0x46, 0x1d, 0x41, + 0xe1, 0x00, 0x1d, 0x81, 0x80, 0x02, 0xa2, 0xf3, 0x01, 0xa3, 0xe6, 0x01, + 0xa4, 0xcd, 0x01, 0xe5, 0x06, 0x1d, 0x01, 0xa7, 0xbc, 0x01, 0x42, 0x22, + 0x00, 0x2c, 0x1d, 0x01, 0xe9, 0x02, 0x1d, 0x81, 0xac, 0x01, 0xaa, 0x99, + 0x01, 0xab, 0x86, 0x01, 0xac, 0x7a, 0x42, 0x6c, 0x00, 0x24, 0x1d, 0x01, + 0xae, 0x5c, 0xef, 0x09, 0x1d, 0x01, 0xb0, 0x4c, 0x42, 0x71, 0x00, 0x26, + 0x1d, 0x01, 0xb3, 0x34, 0xb4, 0x15, 0xf5, 0x04, 0x1d, 0x81, 0x0c, 0x42, + 0x61, 0x0b, 0x28, 0x1d, 0x01, 0x42, 0xdf, 0x23, 0x25, 0x1d, 0x41, 0xf5, + 0x05, 0x1d, 0x41, 0xe1, 0x1b, 0x1d, 0x01, 0x42, 0x22, 0x00, 0x1c, 0x1d, + 0x01, 0x42, 0x71, 0x00, 0x30, 0x1d, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x16, + 0x1d, 0x01, 0x42, 0x22, 0x00, 0x17, 0x1d, 0x41, 0xe1, 0x2b, 0x1d, 0x01, + 0x42, 0x22, 0x00, 0x29, 0x1d, 0x01, 0x42, 0x40, 0x06, 0x2a, 0x1d, 0x41, + 0xe1, 0x20, 0x1d, 0x01, 0x42, 0x22, 0x00, 0x21, 0x1d, 0x41, 0xe1, 0x1f, + 0x1d, 0x01, 0x42, 0x24, 0x02, 0x10, 0x1d, 0x01, 0x42, 0x2a, 0x05, 0x1a, + 0x1d, 0x01, 0x42, 0xdf, 0x23, 0x15, 0x1d, 0x41, 0xe1, 0x27, 0x1d, 0x01, + 0x42, 0x74, 0x00, 0x2d, 0x1d, 0x41, 0xe1, 0x0c, 0x1d, 0x01, 0x42, 0x22, + 0x00, 0x0d, 0x1d, 0x01, 0x43, 0x1e, 0x22, 0x2e, 0x1d, 0x41, 0xe1, 0x13, + 0x1d, 0x01, 0x42, 0x22, 0x00, 0x14, 0x1d, 0x01, 0x43, 0x9e, 0x37, 0x2f, + 0x1d, 0x41, 0xe9, 0x03, 0x1d, 0x41, 0xe1, 0x0e, 0x1d, 0x01, 0x42, 0x22, + 0x00, 0x0f, 0x1d, 0x41, 0xe1, 0x1d, 0x1d, 0x01, 0xa4, 0x06, 0x42, 0x22, + 0x00, 0x1e, 0x1d, 0x41, 0xe1, 0x18, 0x1d, 0x01, 0x42, 0x22, 0x00, 0x19, + 0x1d, 0x41, 0xe1, 0x11, 0x1d, 0x01, 0x42, 0x22, 0x00, 0x12, 0x1d, 0x41, + 0xe1, 0x22, 0x1d, 0x01, 0x42, 0x22, 0x00, 0x23, 0x1d, 0x41, 0xe1, 0x01, + 0x1d, 0x01, 0xe9, 0x08, 0x1d, 0x01, 0xf5, 0x0b, 0x1d, 0x41, 0x45, 0x7e, + 0x0b, 0x58, 0x1d, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x59, 0x1d, 0x01, + 0x43, 0x7a, 0x0b, 0x51, 0x1d, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, + 0x1f, 0x50, 0x1d, 0x41, 0x44, 0x25, 0x01, 0x53, 0x1d, 0x01, 0x42, 0x15, + 0x02, 0x52, 0x1d, 0x41, 0x44, 0x06, 0x1f, 0x57, 0x1d, 0x01, 0x42, 0x09, + 0x24, 0x56, 0x1d, 0x41, 0x43, 0xf9, 0x05, 0x55, 0x1d, 0x01, 0x43, 0xf6, + 0x06, 0x54, 0x1d, 0x41, 0x44, 0x19, 0x64, 0x87, 0xfa, 0x01, 0x05, 0x9c, + 0x4c, 0x0c, 0x4c, 0x5c, 0x99, 0xad, 0x26, 0x00, 0x51, 0x12, 0x61, 0x4b, + 0xf9, 0x41, 0x49, 0xc2, 0x1c, 0x70, 0x1c, 0x01, 0x07, 0x13, 0x06, 0xe9, + 0x01, 0x49, 0xac, 0xc1, 0x71, 0x1c, 0x01, 0xb3, 0x1b, 0x0b, 0xc7, 0x7a, + 0x01, 0xff, 0x42, 0x4e, 0x13, 0xb0, 0x1c, 0x01, 0xe5, 0xb3, 0x1c, 0x01, + 0xe9, 0xb1, 0x1c, 0x01, 0xef, 0xb4, 0x1c, 0x01, 0xf5, 0xb2, 0x1c, 0x41, + 0x04, 0x5b, 0x03, 0xb5, 0x01, 0x10, 0xea, 0x6a, 0x01, 0xff, 0xe1, 0xaf, + 0x1c, 0x01, 0x42, 0x16, 0x00, 0xa0, 0x1c, 0x01, 0xa3, 0x99, 0x01, 0xa4, + 0x8c, 0x01, 0x42, 0x24, 0x02, 0x94, 0x1c, 0x01, 0x42, 0x22, 0x00, 0xae, + 0x1c, 0x01, 0x42, 0x78, 0x1a, 0x98, 0x1c, 0x01, 0xab, 0x6e, 0x42, 0x74, + 0x00, 0xab, 0x1c, 0x01, 0x42, 0x6c, 0x00, 0xa1, 0x1c, 0x01, 0xae, 0x50, + 0xb0, 0x44, 0x42, 0x71, 0x00, 0xaa, 0x1c, 0x01, 0xb3, 0x32, 0xb4, 0x19, + 0x42, 0xa9, 0x01, 0xa5, 0x1c, 0x01, 0x42, 0xdf, 0x23, 0xa9, 0x1c, 0x01, + 0xba, 0x01, 0xff, 0xe1, 0xa7, 0x1c, 0x01, 0x42, 0x22, 0x00, 0xa6, 0x1c, + 0x41, 0xe1, 0x9a, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x9b, 0x1c, 0x01, 0xb3, + 0x01, 0xff, 0xe1, 0xa2, 0x1c, 0x01, 0x42, 0x22, 0x00, 0xa3, 0x1c, 0x41, + 0xe1, 0xad, 0x1c, 0x01, 0x42, 0x22, 0x00, 0xac, 0x1c, 0x41, 0xe1, 0x9e, + 0x1c, 0x01, 0x42, 0x22, 0x00, 0x9f, 0x1c, 0x41, 0xe1, 0x9d, 0x1c, 0x01, + 0x42, 0x24, 0x02, 0x95, 0x1c, 0x01, 0x42, 0xdf, 0x23, 0x99, 0x1c, 0x41, + 0xe1, 0x92, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x93, 0x1c, 0x41, 0xe1, 0x9c, + 0x1c, 0x01, 0x42, 0x59, 0x00, 0xa4, 0x1c, 0x41, 0xe1, 0x96, 0x1c, 0x01, + 0x42, 0x22, 0x00, 0x97, 0x1c, 0x41, 0x48, 0x0a, 0x17, 0xb5, 0x1c, 0x01, + 0x4b, 0x13, 0x25, 0xb6, 0x1c, 0x41, 0x42, 0x3d, 0x27, 0x88, 0x1c, 0x01, + 0xe1, 0x8f, 0x1c, 0x01, 0x42, 0x16, 0x00, 0x80, 0x1c, 0x01, 0xa3, 0x99, + 0x01, 0xa4, 0x8c, 0x01, 0x42, 0x24, 0x02, 0x74, 0x1c, 0x01, 0x42, 0x22, + 0x00, 0x8e, 0x1c, 0x01, 0x42, 0x78, 0x1a, 0x78, 0x1c, 0x01, 0xab, 0x6e, + 0x42, 0x74, 0x00, 0x8b, 0x1c, 0x01, 0x42, 0x6c, 0x00, 0x81, 0x1c, 0x01, + 0xae, 0x50, 0xb0, 0x44, 0x42, 0x71, 0x00, 0x8a, 0x1c, 0x01, 0xb3, 0x32, + 0xb4, 0x19, 0x42, 0xa9, 0x01, 0x85, 0x1c, 0x01, 0x42, 0xdf, 0x23, 0x89, + 0x1c, 0x01, 0xba, 0x01, 0xff, 0xe1, 0x87, 0x1c, 0x01, 0x42, 0x22, 0x00, + 0x86, 0x1c, 0x41, 0xe1, 0x7a, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x7b, 0x1c, + 0x01, 0xb3, 0x01, 0xff, 0xe1, 0x82, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x83, + 0x1c, 0x41, 0xe1, 0x8d, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x8c, 0x1c, 0x41, + 0xe1, 0x7e, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x7f, 0x1c, 0x41, 0xe1, 0x7d, + 0x1c, 0x01, 0x42, 0x24, 0x02, 0x75, 0x1c, 0x01, 0x42, 0xdf, 0x23, 0x79, + 0x1c, 0x41, 0xe1, 0x72, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x73, 0x1c, 0x41, + 0xe1, 0x7c, 0x1c, 0x01, 0x42, 0x59, 0x00, 0x84, 0x1c, 0x41, 0xe1, 0x76, + 0x1c, 0x01, 0x42, 0x22, 0x00, 0x77, 0x1c, 0x41, 0x56, 0x17, 0x34, 0xef, + 0x26, 0x00, 0x47, 0x9c, 0xd8, 0x41, 0xf3, 0x41, 0x80, 0xa5, 0x04, 0x47, + 0xc5, 0x6f, 0xbc, 0x20, 0x00, 0x05, 0x6b, 0xeb, 0x87, 0x03, 0x42, 0xd4, + 0x14, 0x6d, 0xf9, 0x01, 0x08, 0x87, 0xcc, 0x12, 0x46, 0xc4, 0xe5, 0x5e, + 0xf4, 0x01, 0x4e, 0x74, 0x80, 0x70, 0xf5, 0x01, 0x4e, 0xa8, 0x81, 0xbd, + 0xf9, 0x41, 0x12, 0x55, 0x52, 0xda, 0x02, 0x07, 0x13, 0x06, 0x5d, 0x07, + 0x37, 0x3c, 0x37, 0x0c, 0x3b, 0x17, 0x06, 0x47, 0xcf, 0xdb, 0xc8, 0x0a, + 0x41, 0x02, 0x3b, 0x01, 0x18, 0x47, 0xf6, 0x38, 0xf1, 0x0a, 0x01, 0x4b, + 0xec, 0xa3, 0xf6, 0x0a, 0x01, 0x44, 0xff, 0x13, 0xf0, 0x0a, 0x01, 0x48, + 0x44, 0x0a, 0xf5, 0x0a, 0x41, 0xf4, 0xf4, 0x0a, 0x81, 0x06, 0x53, 0x62, + 0x50, 0xf2, 0x0a, 0x41, 0x4b, 0x6a, 0x50, 0xf3, 0x0a, 0x41, 0x44, 0x4e, + 0x12, 0xec, 0x0a, 0x01, 0x43, 0x7a, 0x0b, 0xeb, 0x0a, 0x81, 0x0f, 0xb4, + 0x01, 0xff, 0x42, 0x92, 0x01, 0xed, 0x0a, 0x01, 0x45, 0xe8, 0x1e, 0xee, + 0x0a, 0x41, 0x48, 0x3e, 0x12, 0xef, 0x0a, 0x41, 0xa1, 0xe4, 0x01, 0xa2, + 0xd5, 0x01, 0xa4, 0xc6, 0x01, 0x42, 0x2e, 0x1b, 0xdc, 0x0a, 0x01, 0xa7, + 0xb1, 0x01, 0x42, 0xb0, 0x01, 0xc6, 0x0a, 0x81, 0xa3, 0x01, 0xaa, 0x94, + 0x01, 0xab, 0x85, 0x01, 0x46, 0x8a, 0xe3, 0xd3, 0x0a, 0x01, 0x43, 0xb4, + 0x05, 0xd6, 0x0a, 0x01, 0x43, 0x18, 0x24, 0xd7, 0x0a, 0x01, 0x42, 0x6f, + 0x02, 0xdb, 0x0a, 0x01, 0xb1, 0x5f, 0x44, 0x8a, 0x69, 0xe1, 0x0a, 0x01, + 0xb3, 0x3d, 0xb4, 0x29, 0x43, 0x1c, 0x8f, 0xc7, 0x0a, 0x01, 0xb8, 0x15, + 0x44, 0xfd, 0x54, 0xcf, 0x0a, 0x01, 0xba, 0x01, 0xff, 0x44, 0x68, 0x4c, + 0xc9, 0x0a, 0x01, 0x45, 0xe2, 0xec, 0xca, 0x0a, 0x41, 0x43, 0x32, 0x11, + 0xd1, 0x0a, 0x01, 0x43, 0x5f, 0x38, 0xdf, 0x0a, 0x41, 0x42, 0x3e, 0x2f, + 0xe4, 0x0a, 0x01, 0x43, 0x48, 0x27, 0xce, 0x0a, 0x01, 0x46, 0x3a, 0xe2, + 0xd5, 0x0a, 0x41, 0xa1, 0x0c, 0x43, 0x48, 0x17, 0xe2, 0x0a, 0x01, 0x44, + 0xbd, 0x4c, 0xe3, 0x0a, 0x41, 0x43, 0x95, 0xf0, 0xdd, 0x0a, 0x01, 0x44, + 0x4a, 0xea, 0xd8, 0x0a, 0x41, 0x44, 0x34, 0xf6, 0xe0, 0x0a, 0x01, 0x43, + 0x5f, 0x38, 0xde, 0x0a, 0x41, 0x43, 0x32, 0x11, 0xd0, 0x0a, 0x01, 0x44, + 0xce, 0xed, 0xd2, 0x0a, 0x41, 0x44, 0x68, 0x4c, 0xcb, 0x0a, 0x01, 0x45, + 0xe2, 0xec, 0xcc, 0x0a, 0x41, 0x42, 0x53, 0x00, 0xcd, 0x0a, 0x41, 0x45, + 0xf1, 0xec, 0xc4, 0x0a, 0x01, 0x44, 0x5b, 0xb0, 0xc3, 0x0a, 0x41, 0x45, + 0x6e, 0x4c, 0xc5, 0x0a, 0x01, 0x46, 0x3a, 0xe2, 0xd4, 0x0a, 0x41, 0x43, + 0x48, 0x27, 0xc1, 0x0a, 0x01, 0x44, 0xca, 0xaf, 0xc2, 0x0a, 0x41, 0x44, + 0x68, 0x4c, 0xda, 0x0a, 0x01, 0x44, 0x3b, 0x3f, 0xc0, 0x0a, 0x01, 0x43, + 0xa0, 0x1b, 0xd9, 0x0a, 0x41, 0x45, 0x5c, 0x00, 0xe5, 0x0a, 0x01, 0x45, + 0x20, 0x07, 0xe6, 0x0a, 0x41, 0x50, 0x8a, 0x63, 0x59, 0x08, 0x00, 0x4f, + 0xad, 0x70, 0x5b, 0x08, 0x00, 0x07, 0x13, 0x06, 0x0c, 0x4b, 0x73, 0x0c, + 0x5e, 0x08, 0x00, 0x51, 0x00, 0x62, 0x5a, 0x08, 0x40, 0xa1, 0x22, 0x48, + 0xef, 0xca, 0x56, 0x08, 0x00, 0x45, 0xc9, 0xec, 0x40, 0x08, 0x00, 0xa9, + 0x0c, 0x43, 0x4c, 0xab, 0x57, 0x08, 0x00, 0x47, 0xf0, 0xca, 0x45, 0x08, + 0x40, 0xee, 0x4f, 0x08, 0x00, 0xf4, 0x47, 0x08, 0x40, 0xe2, 0x41, 0x08, + 0x00, 0xe4, 0x43, 0x08, 0x00, 0xe7, 0x42, 0x08, 0x00, 0xe8, 0x44, 0x08, + 0x00, 0x42, 0x9e, 0x01, 0x58, 0x08, 0x00, 0xeb, 0x4a, 0x08, 0x80, 0x32, + 0xec, 0x4b, 0x08, 0x00, 0xed, 0x4c, 0x08, 0x00, 0xee, 0x4d, 0x08, 0x00, + 0xf0, 0x50, 0x08, 0x00, 0xf1, 0x52, 0x08, 0x00, 0xf2, 0x53, 0x08, 0x00, + 0xf3, 0x4e, 0x08, 0x80, 0x0d, 0xf4, 0x55, 0x08, 0x80, 0x04, 0xfa, 0x46, + 0x08, 0x40, 0xf4, 0x48, 0x08, 0x40, 0xe8, 0x54, 0x08, 0x00, 0xfa, 0x51, + 0x08, 0x40, 0x42, 0x40, 0x06, 0x49, 0x08, 0x40, 0x57, 0x9d, 0x2e, 0x6b, + 0xf4, 0x01, 0x47, 0xf5, 0xd5, 0x7a, 0xf5, 0x01, 0x03, 0x08, 0x06, 0x11, + 0x05, 0x51, 0x00, 0x01, 0xff, 0x4a, 0x78, 0xb0, 0x72, 0xf4, 0x01, 0x46, + 0xba, 0xe6, 0x73, 0xf4, 0x41, 0x58, 0x04, 0x29, 0x74, 0xf5, 0x01, 0x46, + 0xc0, 0xe6, 0x35, 0xf9, 0x41, 0x07, 0x75, 0xbb, 0x27, 0x02, 0x60, 0x00, + 0x06, 0x4a, 0x6c, 0xb7, 0x20, 0x27, 0x40, 0x4f, 0x7d, 0x28, 0xa5, 0x26, + 0x00, 0x44, 0x5a, 0x03, 0x42, 0x26, 0x00, 0x0c, 0xfc, 0x3e, 0x01, 0xff, + 0x58, 0x74, 0x28, 0xa7, 0x26, 0x00, 0x44, 0x5a, 0x03, 0xa6, 0x26, 0x40, + 0x4e, 0x90, 0x79, 0x57, 0x0d, 0x00, 0xa4, 0x91, 0x05, 0x09, 0x54, 0x2a, + 0xb0, 0x04, 0x07, 0x13, 0x06, 0xad, 0x01, 0x07, 0x37, 0x3c, 0x92, 0x01, + 0x05, 0x5a, 0x03, 0x4e, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xa1, 0x3b, 0xe5, + 0x46, 0x0d, 0x80, 0x32, 0xe9, 0x3f, 0x0d, 0x80, 0x29, 0xef, 0x4a, 0x0d, + 0x80, 0x20, 0xf5, 0x41, 0x0d, 0x80, 0x17, 0x08, 0xf2, 0xc6, 0x01, 0xff, + 0xec, 0x62, 0x0d, 0x80, 0x09, 0xf2, 0x43, 0x0d, 0xc0, 0x00, 0xf2, 0x44, + 0x0d, 0x40, 0xec, 0x63, 0x0d, 0x40, 0xf5, 0x42, 0x0d, 0x40, 0xef, 0x4b, + 0x0d, 0x40, 0xe9, 0x40, 0x0d, 0x40, 0xe5, 0x47, 0x0d, 0x40, 0xe1, 0x3e, + 0x0d, 0x00, 0xe9, 0x48, 0x0d, 0x00, 0xf5, 0x4c, 0x0d, 0x40, 0xa1, 0x32, + 0xa3, 0x1e, 0x44, 0x2c, 0x11, 0x4f, 0x0d, 0x00, 0xb6, 0x01, 0xff, 0x52, + 0xe1, 0x53, 0x3b, 0x0d, 0x00, 0xa9, 0x01, 0xff, 0x44, 0x21, 0x25, 0x4d, + 0x0d, 0x00, 0x45, 0x49, 0x4e, 0x03, 0x0d, 0x40, 0x4a, 0x14, 0x25, 0x01, + 0x0d, 0x00, 0x4e, 0x5a, 0x7c, 0x3c, 0x0d, 0x00, 0x57, 0x01, 0x17, 0x00, + 0x0d, 0x40, 0x47, 0x0b, 0x17, 0x02, 0x0d, 0x00, 0x47, 0x34, 0x8d, 0x3d, + 0x0d, 0x40, 0x04, 0x7a, 0x0b, 0x06, 0x43, 0xdb, 0x06, 0x70, 0x0d, 0x40, + 0x47, 0x3f, 0x12, 0x71, 0x0d, 0x00, 0x48, 0xde, 0x1e, 0x72, 0x0d, 0x40, + 0xe1, 0x05, 0x0d, 0x80, 0xe6, 0x02, 0xa2, 0xd9, 0x02, 0xa3, 0x9d, 0x02, + 0xa4, 0xfe, 0x01, 0xe5, 0x0e, 0x0d, 0x80, 0xf4, 0x01, 0xa7, 0xe7, 0x01, + 0x42, 0x22, 0x00, 0x39, 0x0d, 0x00, 0xe9, 0x07, 0x0d, 0x80, 0xd7, 0x01, + 0xaa, 0xca, 0x01, 0xab, 0xbd, 0x01, 0xac, 0xa9, 0x01, 0x42, 0x6c, 0x00, + 0x2e, 0x0d, 0x00, 0xae, 0x84, 0x01, 0xef, 0x12, 0x0d, 0x80, 0x7b, 0xb0, + 0x6f, 0xb2, 0x63, 0xb3, 0x51, 0xb4, 0x32, 0xf5, 0x09, 0x0d, 0x80, 0x29, + 0xb6, 0x06, 0x42, 0xdf, 0x23, 0x2f, 0x0d, 0x40, 0xe1, 0x35, 0x0d, 0x00, + 0x4d, 0x7a, 0x86, 0x04, 0x0d, 0x00, 0x07, 0xf3, 0xc6, 0x01, 0xff, 0xec, + 0x0c, 0x0d, 0x80, 0x09, 0xf2, 0x0b, 0x0d, 0xc0, 0x00, 0xf2, 0x60, 0x0d, + 0x40, 0xec, 0x61, 0x0d, 0x40, 0xf5, 0x0a, 0x0d, 0x40, 0xe1, 0x24, 0x0d, + 0x00, 0x42, 0x22, 0x00, 0x25, 0x0d, 0x00, 0xb4, 0x01, 0xff, 0xe1, 0x1f, + 0x0d, 0x00, 0x42, 0x22, 0x00, 0x20, 0x0d, 0x00, 0x42, 0x12, 0x00, 0x3a, + 0x0d, 0x40, 0xe1, 0x38, 0x0d, 0x00, 0x42, 0x22, 0x00, 0x36, 0x0d, 0x00, + 0x42, 0x40, 0x06, 0x37, 0x0d, 0x40, 0xe1, 0x30, 0x0d, 0x00, 0x42, 0x71, + 0x00, 0x31, 0x0d, 0x40, 0xe1, 0x2a, 0x0d, 0x00, 0x42, 0x22, 0x00, 0x2b, + 0x0d, 0x40, 0xef, 0x13, 0x0d, 0x40, 0xe1, 0x28, 0x0d, 0x00, 0x42, 0x24, + 0x02, 0x19, 0x0d, 0x00, 0xae, 0x06, 0x42, 0xdf, 0x23, 0x1e, 0x0d, 0x40, + 0xe1, 0x23, 0x0d, 0x00, 0x42, 0x2a, 0x05, 0x29, 0x0d, 0x40, 0xe1, 0x32, + 0x0d, 0x00, 0xac, 0x01, 0xff, 0xe1, 0x33, 0x0d, 0x00, 0x42, 0x74, 0x00, + 0x34, 0x0d, 0x40, 0xe1, 0x15, 0x0d, 0x00, 0x42, 0x22, 0x00, 0x16, 0x0d, + 0x40, 0xe1, 0x1c, 0x0d, 0x00, 0x42, 0x22, 0x00, 0x1d, 0x0d, 0x40, 0xe9, + 0x08, 0x0d, 0x40, 0xe1, 0x17, 0x0d, 0x00, 0x42, 0x22, 0x00, 0x18, 0x0d, + 0x40, 0xe5, 0x0f, 0x0d, 0x40, 0xe1, 0x26, 0x0d, 0x00, 0xa4, 0x0c, 0x42, + 0x22, 0x00, 0x27, 0x0d, 0x00, 0x47, 0x0f, 0xda, 0x4e, 0x0d, 0x40, 0xe1, + 0x21, 0x0d, 0x00, 0x42, 0x22, 0x00, 0x22, 0x0d, 0x40, 0xe1, 0x1a, 0x0d, + 0x00, 0xa8, 0x01, 0xff, 0xe1, 0x1b, 0x0d, 0x00, 0x05, 0xe3, 0xc7, 0x01, + 0xff, 0xeb, 0x7f, 0x0d, 0x00, 0xec, 0x7d, 0x0d, 0x80, 0x17, 0xed, 0x54, + 0x0d, 0x00, 0xee, 0x7b, 0x0d, 0x80, 0x0a, 0x42, 0xcf, 0x00, 0x7c, 0x0d, + 0x00, 0xf9, 0x55, 0x0d, 0x40, 0xee, 0x7a, 0x0d, 0x40, 0xec, 0x7e, 0x0d, + 0xc0, 0x00, 0xec, 0x56, 0x0d, 0x40, 0xe1, 0x2c, 0x0d, 0x00, 0x42, 0x22, + 0x00, 0x2d, 0x0d, 0x40, 0xe1, 0x06, 0x0d, 0x00, 0xe9, 0x10, 0x0d, 0x00, + 0x49, 0x34, 0xc4, 0x5f, 0x0d, 0x00, 0xf5, 0x14, 0x0d, 0x40, 0x04, 0x7a, + 0x0b, 0x1d, 0x06, 0x24, 0x01, 0x01, 0xff, 0x4a, 0x2e, 0xaf, 0x5a, 0x0d, + 0x00, 0x48, 0x2a, 0x01, 0x75, 0x0d, 0x00, 0x4a, 0xb8, 0xb6, 0x78, 0x0d, + 0x00, 0x4a, 0xda, 0xb7, 0x5d, 0x0d, 0x40, 0x46, 0x7e, 0x0b, 0x77, 0x0d, + 0x00, 0xa6, 0x27, 0x44, 0x22, 0x00, 0x74, 0x0d, 0x00, 0x58, 0xd4, 0x2b, + 0x58, 0x0d, 0x00, 0x47, 0x2a, 0x01, 0x73, 0x0d, 0x00, 0x49, 0x6e, 0x27, + 0x76, 0x0d, 0x00, 0xb4, 0x01, 0xff, 0x44, 0xa4, 0x1c, 0x5c, 0x0d, 0x00, + 0x48, 0x43, 0x27, 0x5b, 0x0d, 0x40, 0x44, 0xdd, 0xb4, 0x5e, 0x0d, 0x00, + 0x47, 0x01, 0xda, 0x59, 0x0d, 0x40, 0x48, 0x6f, 0xc9, 0x79, 0x0d, 0x00, + 0x05, 0xf0, 0x06, 0x01, 0xff, 0x45, 0x7e, 0x0b, 0x6e, 0x0d, 0x00, 0xa6, + 0x2e, 0x44, 0x6d, 0x2c, 0x6f, 0x0d, 0x00, 0x43, 0x7a, 0x0b, 0x67, 0x0d, + 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x66, 0x0d, 0x40, 0x44, + 0x25, 0x01, 0x69, 0x0d, 0x00, 0x42, 0x15, 0x02, 0x68, 0x0d, 0x40, 0x44, + 0x06, 0x1f, 0x6d, 0x0d, 0x00, 0x42, 0x09, 0x24, 0x6c, 0x0d, 0x40, 0x43, + 0xf9, 0x05, 0x6b, 0x0d, 0x00, 0x43, 0xf6, 0x06, 0x6a, 0x0d, 0x40, 0x05, + 0x6c, 0xea, 0x06, 0x45, 0xd9, 0xeb, 0x7c, 0xf7, 0x41, 0x45, 0xa6, 0xdf, + 0xf2, 0x1e, 0x01, 0x4e, 0xd2, 0x7a, 0xf8, 0x1e, 0x01, 0x07, 0x13, 0x06, + 0x1b, 0x4a, 0x0a, 0xb5, 0xf7, 0x1e, 0x01, 0x0b, 0xc7, 0x7a, 0x01, 0xff, + 0xe5, 0xf5, 0x1e, 0x01, 0xe9, 0xf3, 0x1e, 0x01, 0xef, 0xf6, 0x1e, 0x01, + 0xf5, 0xf4, 0x1e, 0x41, 0xe1, 0xf1, 0x1e, 0x01, 0x42, 0x16, 0x00, 0xe4, + 0x1e, 0x01, 0x42, 0x37, 0x00, 0xe9, 0x1e, 0x01, 0x42, 0x7b, 0x08, 0xe7, + 0x1e, 0x01, 0x42, 0x24, 0x02, 0xe1, 0x1e, 0x01, 0x42, 0x78, 0x1a, 0xea, + 0x1e, 0x01, 0x42, 0x1b, 0x02, 0xe0, 0x1e, 0x01, 0x42, 0x74, 0x00, 0xee, + 0x1e, 0x01, 0x42, 0x6c, 0x00, 0xe5, 0x1e, 0x01, 0xae, 0x24, 0x42, 0xe0, + 0x09, 0xe3, 0x1e, 0x01, 0x42, 0x71, 0x00, 0xed, 0x1e, 0x01, 0x42, 0x40, + 0x06, 0xf0, 0x1e, 0x01, 0x42, 0x12, 0x00, 0xe6, 0x1e, 0x01, 0x42, 0x61, + 0x0b, 0xef, 0x1e, 0x01, 0x42, 0xdf, 0x23, 0xec, 0x1e, 0x41, 0xe1, 0xe8, + 0x1e, 0x01, 0x42, 0x24, 0x02, 0xe2, 0x1e, 0x01, 0x42, 0xdf, 0x23, 0xeb, + 0x1e, 0x41, 0x06, 0x8e, 0xdf, 0xe7, 0x02, 0x0a, 0xb8, 0xb1, 0x01, 0xff, + 0x46, 0xf4, 0xdf, 0x28, 0xf0, 0x01, 0x02, 0x16, 0x00, 0xcb, 0x02, 0x4d, + 0x83, 0x85, 0x25, 0xf0, 0x01, 0xa5, 0xa2, 0x02, 0xa6, 0xec, 0x01, 0x4c, + 0xf8, 0x93, 0x05, 0xf0, 0x01, 0x45, 0x59, 0xaa, 0x2a, 0xf0, 0x01, 0xae, + 0xbe, 0x01, 0xaf, 0x9c, 0x01, 0x44, 0x10, 0xf8, 0x22, 0xf0, 0x01, 0x4a, + 0xaa, 0xb5, 0x04, 0xf0, 0x01, 0xb3, 0x4a, 0xb4, 0x15, 0xb7, 0x01, 0xff, + 0x48, 0x87, 0xcb, 0x02, 0xf0, 0x01, 0x4b, 0x29, 0xa2, 0x06, 0xf0, 0x01, + 0x45, 0xf2, 0x0a, 0x29, 0xf0, 0x41, 0x08, 0x6f, 0xcc, 0x1a, 0x06, 0x4a, + 0xe7, 0x01, 0xff, 0x47, 0x1c, 0xd5, 0x11, 0xf0, 0x01, 0xa3, 0x01, 0xff, + 0x49, 0x12, 0xbf, 0x08, 0xf0, 0x01, 0x46, 0xbb, 0x45, 0x1a, 0xf0, 0x41, + 0x47, 0x1c, 0xd5, 0x12, 0xf0, 0x01, 0xa3, 0x01, 0xff, 0x49, 0x12, 0xbf, + 0x09, 0xf0, 0x01, 0x46, 0xbb, 0x45, 0x1b, 0xf0, 0x41, 0x08, 0xaf, 0xcb, + 0x2b, 0x06, 0x30, 0xe3, 0x12, 0x49, 0x6e, 0xc3, 0x01, 0xf0, 0x01, 0x45, + 0x78, 0x12, 0x26, 0xf0, 0x01, 0x45, 0xb0, 0xf1, 0x27, 0xf0, 0x41, 0x47, + 0x1c, 0xd5, 0x15, 0xf0, 0x01, 0xa3, 0x01, 0xff, 0x49, 0x12, 0xbf, 0x0c, + 0xf0, 0x01, 0x46, 0xbb, 0x45, 0x1e, 0xf0, 0x41, 0x47, 0x1c, 0xd5, 0x16, + 0xf0, 0x01, 0xa3, 0x01, 0xff, 0x49, 0x12, 0xbf, 0x0d, 0xf0, 0x01, 0x46, + 0xbb, 0x45, 0x1f, 0xf0, 0x41, 0x06, 0x69, 0xce, 0x06, 0x45, 0x25, 0xf0, + 0x23, 0xf0, 0x41, 0x47, 0x1c, 0xd5, 0x10, 0xf0, 0x01, 0xa3, 0x01, 0xff, + 0x49, 0x12, 0xbf, 0x07, 0xf0, 0x01, 0x46, 0xbb, 0x45, 0x19, 0xf0, 0x41, + 0x07, 0x68, 0xce, 0x06, 0x49, 0x41, 0xc3, 0x03, 0xf0, 0x41, 0x47, 0x1c, + 0xd5, 0x18, 0xf0, 0x01, 0xa3, 0x01, 0xff, 0x49, 0x12, 0xbf, 0x0f, 0xf0, + 0x01, 0x46, 0xbb, 0x45, 0x21, 0xf0, 0x41, 0x07, 0xf4, 0xd7, 0x1a, 0x07, + 0x16, 0xda, 0x01, 0xff, 0x47, 0x1c, 0xd5, 0x13, 0xf0, 0x01, 0xa3, 0x01, + 0xff, 0x49, 0x12, 0xbf, 0x0a, 0xf0, 0x01, 0x46, 0xbb, 0x45, 0x1c, 0xf0, + 0x41, 0x47, 0x1c, 0xd5, 0x14, 0xf0, 0x01, 0xa3, 0x01, 0xff, 0x49, 0x12, + 0xbf, 0x0b, 0xf0, 0x01, 0x46, 0xbb, 0x45, 0x1d, 0xf0, 0x41, 0x48, 0x57, + 0xc9, 0x00, 0xf0, 0x01, 0x08, 0xd8, 0xbd, 0x01, 0xff, 0x47, 0x1c, 0xd5, + 0x17, 0xf0, 0x01, 0xa3, 0x01, 0xff, 0x49, 0x12, 0xbf, 0x0e, 0xf0, 0x01, + 0x46, 0xbb, 0x45, 0x20, 0xf0, 0x41, 0x42, 0x36, 0x01, 0x2b, 0xf0, 0x01, + 0x44, 0xad, 0x9d, 0x24, 0xf0, 0x41, 0x51, 0x5d, 0x5a, 0x74, 0x11, 0x01, + 0xac, 0x0f, 0xb3, 0x01, 0xff, 0x4b, 0x67, 0x28, 0x75, 0x11, 0x01, 0x49, + 0xc6, 0xbf, 0x73, 0x11, 0x41, 0x06, 0x14, 0x06, 0x06, 0x4c, 0x88, 0x94, + 0x76, 0x11, 0x41, 0xe1, 0x50, 0x11, 0x01, 0xa2, 0xbc, 0x01, 0xa3, 0xaf, + 0x01, 0xa4, 0x96, 0x01, 0xe5, 0x53, 0x11, 0x01, 0xa7, 0x85, 0x01, 0x42, + 0x22, 0x00, 0x71, 0x11, 0x01, 0xe9, 0x51, 0x11, 0x01, 0xaa, 0x6f, 0xab, + 0x63, 0x42, 0x74, 0x00, 0x6e, 0x11, 0x01, 0x42, 0x6c, 0x00, 0x6c, 0x11, + 0x01, 0xae, 0x45, 0xef, 0x54, 0x11, 0x01, 0xb0, 0x35, 0xb2, 0x29, 0x42, + 0x40, 0x06, 0x70, 0x11, 0x01, 0xb4, 0x0a, 0xf5, 0x52, 0x11, 0x01, 0x42, + 0x61, 0x0b, 0x6f, 0x11, 0x41, 0xe1, 0x63, 0x11, 0x01, 0x42, 0x22, 0x00, + 0x64, 0x11, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x5e, 0x11, 0x01, 0x42, 0x22, + 0x00, 0x5f, 0x11, 0x41, 0xe1, 0x6d, 0x11, 0x01, 0x42, 0x71, 0x00, 0x72, + 0x11, 0x41, 0xe1, 0x68, 0x11, 0x01, 0x42, 0x22, 0x00, 0x69, 0x11, 0x41, + 0xe1, 0x67, 0x11, 0x01, 0x42, 0x2a, 0x05, 0x62, 0x11, 0x01, 0x42, 0xdf, + 0x23, 0x5d, 0x11, 0x41, 0xe1, 0x55, 0x11, 0x01, 0x42, 0x22, 0x00, 0x56, + 0x11, 0x41, 0xe1, 0x5b, 0x11, 0x01, 0x42, 0x22, 0x00, 0x5c, 0x11, 0x41, + 0xe1, 0x57, 0x11, 0x01, 0x42, 0x22, 0x00, 0x58, 0x11, 0x41, 0xe1, 0x65, + 0x11, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x66, 0x11, 0x41, 0xe1, 0x60, + 0x11, 0x01, 0x42, 0x22, 0x00, 0x61, 0x11, 0x41, 0xe1, 0x59, 0x11, 0x01, + 0x42, 0x22, 0x00, 0x5a, 0x11, 0x41, 0xe1, 0x6a, 0x11, 0x01, 0x42, 0x22, + 0x00, 0x6b, 0x11, 0x41, 0xe5, 0xd9, 0xf9, 0x01, 0x47, 0xa0, 0xd7, 0x84, + 0xfa, 0x01, 0x43, 0x35, 0x2e, 0xf2, 0xf9, 0x41, 0x4d, 0x20, 0x83, 0x14, + 0x21, 0x00, 0xa1, 0xf1, 0x42, 0xa5, 0xcf, 0x2b, 0xe6, 0x0a, 0x00, 0x00, + 0xa9, 0x88, 0x0d, 0x44, 0xb0, 0x00, 0x99, 0xf9, 0x01, 0xaf, 0xb0, 0x02, + 0xb2, 0x9d, 0x02, 0xb5, 0x85, 0x02, 0xb9, 0x01, 0xff, 0x0c, 0xf4, 0x91, + 0x82, 0x01, 0x05, 0x7b, 0x63, 0x06, 0x48, 0xcc, 0x2a, 0x25, 0xf9, 0x41, + 0x07, 0x13, 0x06, 0x06, 0x4f, 0x1f, 0x77, 0x3f, 0x09, 0x41, 0xe1, 0x20, + 0x09, 0x81, 0x65, 0xe2, 0x21, 0x09, 0x01, 0xe3, 0x39, 0x09, 0x01, 0xe4, + 0x23, 0x09, 0x01, 0xe5, 0x24, 0x09, 0x81, 0x50, 0xe6, 0x31, 0x09, 0x01, + 0xe7, 0x22, 0x09, 0x01, 0xe9, 0x26, 0x09, 0x01, 0xeb, 0x28, 0x09, 0x01, + 0xec, 0x29, 0x09, 0x81, 0x37, 0xed, 0x2a, 0x09, 0x01, 0xee, 0x2b, 0x09, + 0x81, 0x2a, 0xef, 0x2c, 0x09, 0x01, 0xf1, 0x32, 0x09, 0x01, 0xf2, 0x2d, + 0x09, 0x01, 0xf3, 0x33, 0x09, 0x81, 0x15, 0xf4, 0x2f, 0x09, 0x81, 0x0c, + 0xf5, 0x30, 0x09, 0x01, 0xf6, 0x25, 0x09, 0x01, 0xf9, 0x27, 0x09, 0x41, + 0xf4, 0x34, 0x09, 0x41, 0xf3, 0x2e, 0x09, 0x41, 0xee, 0x38, 0x09, 0x41, + 0xf9, 0x37, 0x09, 0x41, 0xee, 0x36, 0x09, 0x41, 0xee, 0x35, 0x09, 0x41, + 0xe1, 0x80, 0x02, 0x81, 0x72, 0xe2, 0x82, 0x02, 0x81, 0x69, 0xe4, 0x85, + 0x02, 0x01, 0xe5, 0x81, 0x02, 0x81, 0x5c, 0xe7, 0x84, 0x02, 0x01, 0xe8, + 0x9b, 0x02, 0x01, 0xe9, 0x86, 0x02, 0x01, 0xea, 0x8a, 0x02, 0x01, 0xeb, + 0x8b, 0x02, 0x81, 0x43, 0xec, 0x8d, 0x02, 0x01, 0xed, 0x8e, 0x02, 0x81, + 0x36, 0xee, 0x8f, 0x02, 0x81, 0x2d, 0xf0, 0x93, 0x02, 0x01, 0xf1, 0x8c, + 0x02, 0x01, 0xf2, 0x95, 0x02, 0x01, 0xf3, 0x96, 0x02, 0x01, 0xf4, 0x97, + 0x02, 0x81, 0x10, 0xf5, 0x92, 0x02, 0x01, 0xf7, 0x87, 0x02, 0x01, 0xf8, + 0x9c, 0x02, 0x01, 0xfa, 0x88, 0x02, 0x41, 0xe8, 0x89, 0x02, 0x01, 0xf4, + 0x98, 0x02, 0x41, 0xee, 0x91, 0x02, 0x41, 0xed, 0x90, 0x02, 0x41, 0xeb, + 0x94, 0x02, 0x41, 0xee, 0x9a, 0x02, 0x41, 0xe8, 0x83, 0x02, 0x41, 0xee, + 0x99, 0x02, 0x41, 0x45, 0xf1, 0xe6, 0xf3, 0xf9, 0x01, 0xae, 0x01, 0xff, + 0x4a, 0x26, 0xad, 0x76, 0xf7, 0x01, 0x42, 0x8a, 0x12, 0xc1, 0xfa, 0x41, + 0xe5, 0x2a, 0x20, 0x00, 0xe9, 0x66, 0x20, 0x00, 0xed, 0x0e, 0x20, 0x00, + 0xef, 0x2d, 0x20, 0x40, 0x45, 0xd5, 0xea, 0x9e, 0xf9, 0x01, 0x42, 0x36, + 0x01, 0x12, 0xf5, 0x81, 0xaa, 0x0a, 0x03, 0x50, 0x23, 0xfe, 0x08, 0x46, + 0xc0, 0xe3, 0x6d, 0xf3, 0x01, 0x03, 0xa2, 0x01, 0xbb, 0x07, 0xb4, 0xa6, + 0x07, 0x50, 0xfa, 0x6a, 0x2d, 0xf6, 0x01, 0x03, 0x5f, 0x00, 0x8f, 0x07, + 0xb7, 0x0d, 0x45, 0x94, 0x0a, 0xca, 0x25, 0xc0, 0x00, 0x5b, 0x12, 0x1b, + 0xe0, 0x27, 0x40, 0x80, 0xd0, 0x06, 0x03, 0x16, 0x01, 0x01, 0xff, 0x4e, + 0xba, 0x79, 0x03, 0x27, 0x00, 0x07, 0x73, 0x02, 0x99, 0x06, 0x52, 0x17, + 0x54, 0x85, 0x25, 0x00, 0xa8, 0xd0, 0x05, 0x05, 0xc3, 0x00, 0xa6, 0x03, + 0x07, 0x7d, 0x02, 0xf0, 0x02, 0x04, 0x7a, 0x0b, 0xdf, 0x02, 0x06, 0xc8, + 0x00, 0x30, 0x53, 0x58, 0x4f, 0x87, 0x25, 0x00, 0xb4, 0x01, 0xff, 0x05, + 0x25, 0x01, 0x06, 0x5b, 0x57, 0x1e, 0x6f, 0xfb, 0x41, 0x4d, 0x5e, 0x4f, + 0x83, 0x25, 0x00, 0x09, 0x2a, 0x01, 0x01, 0xff, 0x45, 0x33, 0x01, 0x86, + 0x25, 0x00, 0x56, 0x19, 0x37, 0xa5, 0xce, 0x01, 0x57, 0x91, 0x32, 0xae, + 0xce, 0x41, 0x0f, 0xa0, 0x6e, 0xc4, 0x01, 0x4f, 0x09, 0x6f, 0xd3, 0x27, + 0x00, 0x5a, 0x07, 0x21, 0x4f, 0x27, 0x00, 0x58, 0x3c, 0x2a, 0xfe, 0xf7, + 0x01, 0x53, 0x6a, 0x27, 0x9f, 0xce, 0x01, 0x46, 0x0a, 0xe5, 0x0e, 0x27, + 0x00, 0x03, 0x7c, 0x00, 0x38, 0x4d, 0x9e, 0x31, 0x07, 0xcc, 0x01, 0xb3, + 0x19, 0xb4, 0x01, 0xff, 0x05, 0x1a, 0x01, 0x06, 0x4d, 0x63, 0x81, 0x3f, + 0xcc, 0x41, 0x42, 0x68, 0x00, 0xff, 0x25, 0x00, 0x51, 0x56, 0x61, 0x9e, + 0xfb, 0x41, 0x5b, 0x3b, 0x1c, 0x3e, 0x29, 0x00, 0x0e, 0xa5, 0x02, 0x01, + 0xff, 0x46, 0x12, 0x03, 0x3e, 0xf5, 0x01, 0x46, 0xfd, 0x05, 0x51, 0x27, + 0x40, 0x06, 0x0a, 0x0e, 0x06, 0x4b, 0xed, 0x4e, 0x3a, 0xcc, 0x41, 0xa3, + 0x2e, 0xa6, 0x20, 0x4d, 0x2f, 0x8a, 0xb9, 0xcc, 0x01, 0x4c, 0x64, 0x97, + 0xad, 0xcc, 0x01, 0xb3, 0x06, 0x4a, 0x4e, 0xb7, 0xb5, 0xcc, 0x41, 0x4b, + 0x59, 0x9a, 0xab, 0xcc, 0x01, 0x4e, 0x8a, 0x76, 0xd5, 0xcc, 0x41, 0x53, + 0xd1, 0x2a, 0xaf, 0xcc, 0x01, 0x4c, 0x24, 0x87, 0xb1, 0xcc, 0x41, 0x05, + 0xc3, 0x8c, 0x06, 0x4b, 0xd9, 0xa2, 0xde, 0x25, 0x40, 0x46, 0x1e, 0xe0, + 0xc9, 0xcc, 0x01, 0xab, 0x12, 0x44, 0xf4, 0xf7, 0xd1, 0xcc, 0x01, 0x45, + 0x19, 0xc4, 0xc1, 0xcc, 0x01, 0x44, 0x58, 0xf8, 0xc5, 0xcc, 0x41, 0x43, + 0xa1, 0x01, 0xbd, 0xcc, 0x01, 0x45, 0x73, 0x09, 0xcd, 0xcc, 0x41, 0x06, + 0x13, 0x01, 0x11, 0x1b, 0x2f, 0x1f, 0x01, 0xff, 0x46, 0x73, 0x02, 0x41, + 0xfb, 0x01, 0x45, 0xc8, 0x00, 0x42, 0xfb, 0x41, 0x0a, 0x73, 0x02, 0x32, + 0x08, 0x84, 0x02, 0x17, 0x15, 0x35, 0x1f, 0x01, 0xff, 0x46, 0x73, 0x02, + 0x43, 0xfb, 0x01, 0x4c, 0x07, 0x10, 0x46, 0xfb, 0x01, 0x45, 0xc8, 0x00, + 0x44, 0xfb, 0x41, 0x52, 0xeb, 0x55, 0x48, 0xfb, 0x01, 0x06, 0x6d, 0x02, + 0x01, 0xff, 0x46, 0x73, 0x02, 0x45, 0xfb, 0x01, 0x4c, 0x07, 0x10, 0x4a, + 0xfb, 0x41, 0x52, 0xeb, 0x55, 0x47, 0xfb, 0x01, 0x06, 0x6d, 0x02, 0x01, + 0xff, 0x4c, 0x07, 0x10, 0x49, 0xfb, 0x01, 0x45, 0xc8, 0x00, 0x4b, 0xfb, + 0x41, 0x4c, 0x7e, 0x0b, 0x81, 0x25, 0x00, 0x4d, 0x65, 0x1e, 0x82, 0x25, + 0x40, 0x07, 0x73, 0x02, 0x21, 0x05, 0xc3, 0x00, 0x11, 0x06, 0xc8, 0x00, + 0x01, 0xff, 0x53, 0x6a, 0x27, 0x9b, 0xce, 0x01, 0x4e, 0x62, 0x81, 0x3b, + 0xcc, 0x41, 0x53, 0x6a, 0x27, 0x98, 0xce, 0x01, 0x4e, 0x62, 0x81, 0x38, + 0xcc, 0x41, 0x58, 0x44, 0x2b, 0x99, 0xce, 0x01, 0x59, 0x64, 0x27, 0x9a, + 0xce, 0x41, 0xa2, 0xb7, 0x01, 0x46, 0xa2, 0xe0, 0x8d, 0xf5, 0x01, 0xa6, + 0xa2, 0x01, 0x53, 0x6a, 0x27, 0x9c, 0xce, 0x01, 0xb0, 0x8d, 0x01, 0x03, + 0x7c, 0x00, 0x1f, 0x60, 0x03, 0x11, 0x3f, 0x29, 0x00, 0xb4, 0x01, 0xff, + 0x05, 0x1a, 0x01, 0x06, 0x4d, 0x63, 0x81, 0x3c, 0xcc, 0x41, 0x42, 0x68, + 0x00, 0xfa, 0x25, 0x00, 0x51, 0x56, 0x61, 0x9f, 0xfb, 0x41, 0x06, 0x0a, + 0x0e, 0x06, 0x4b, 0xed, 0x4e, 0x39, 0xcc, 0x41, 0xa3, 0x2e, 0xa6, 0x20, + 0x4d, 0x2f, 0x8a, 0xb8, 0xcc, 0x01, 0x4c, 0x64, 0x97, 0xac, 0xcc, 0x01, + 0xb3, 0x06, 0x4a, 0x4e, 0xb7, 0xb4, 0xcc, 0x41, 0x4b, 0x59, 0x9a, 0xaa, + 0xcc, 0x01, 0x4e, 0x8a, 0x76, 0xd4, 0xcc, 0x41, 0x53, 0xd1, 0x2a, 0xae, + 0xcc, 0x01, 0x4c, 0x24, 0x87, 0xb0, 0xcc, 0x41, 0x05, 0xc3, 0x8c, 0x06, + 0x4b, 0xd9, 0xa2, 0xdf, 0x25, 0x40, 0x46, 0x1e, 0xe0, 0xc8, 0xcc, 0x01, + 0xab, 0x12, 0x44, 0xf4, 0xf7, 0xd0, 0xcc, 0x01, 0x45, 0x19, 0xc4, 0xc0, + 0xcc, 0x01, 0x44, 0x58, 0xf8, 0xc4, 0xcc, 0x41, 0x43, 0xa1, 0x01, 0xbc, + 0xcc, 0x01, 0x45, 0x73, 0x09, 0xcc, 0xcc, 0x41, 0x49, 0x4f, 0xbb, 0x8c, + 0xf5, 0x01, 0x45, 0x0b, 0xe5, 0x89, 0xf5, 0x41, 0x57, 0x3d, 0x2a, 0xfd, + 0xf7, 0x01, 0x4b, 0x49, 0xa6, 0x8b, 0xf5, 0x41, 0x4c, 0xbc, 0x90, 0x8a, + 0xf5, 0x01, 0x0e, 0xa1, 0x6e, 0x01, 0xff, 0x1b, 0x9a, 0x1d, 0x50, 0x06, + 0x6d, 0x02, 0x01, 0xff, 0x0a, 0x73, 0x02, 0x31, 0x08, 0x84, 0x02, 0x17, + 0x15, 0x7d, 0x02, 0x01, 0xff, 0x46, 0x73, 0x02, 0x3e, 0xfb, 0x01, 0x4c, + 0x07, 0x10, 0x51, 0xfb, 0x01, 0x45, 0xc8, 0x00, 0x3f, 0xfb, 0x41, 0x06, + 0x13, 0x01, 0x06, 0x52, 0xcd, 0x58, 0x4d, 0xfb, 0x41, 0x46, 0x73, 0x02, + 0x40, 0xfb, 0x01, 0x4c, 0x07, 0x10, 0x4f, 0xfb, 0x41, 0x06, 0x13, 0x01, + 0x06, 0x52, 0xcd, 0x58, 0x4c, 0xfb, 0x41, 0x4c, 0x07, 0x10, 0x4e, 0xfb, + 0x01, 0x45, 0xc8, 0x00, 0x50, 0xfb, 0x41, 0x46, 0x73, 0x02, 0x3c, 0xfb, + 0x01, 0x45, 0xc8, 0x00, 0x3d, 0xfb, 0x41, 0x04, 0x23, 0x00, 0x06, 0x57, + 0x94, 0x31, 0x05, 0xcc, 0x41, 0x5b, 0x48, 0x1b, 0x01, 0xce, 0x01, 0x45, + 0x33, 0x01, 0x84, 0x25, 0x00, 0x46, 0x12, 0x03, 0xe1, 0x25, 0x00, 0x52, + 0x83, 0x54, 0x04, 0xce, 0x01, 0x54, 0x93, 0x45, 0xdb, 0x25, 0x00, 0x56, + 0x19, 0x37, 0xa4, 0xce, 0x01, 0x4c, 0x44, 0x04, 0x8f, 0xfb, 0x01, 0x57, + 0x91, 0x32, 0xaf, 0xce, 0x01, 0x63, 0x39, 0x0c, 0x13, 0xce, 0x41, 0x05, + 0xc3, 0x00, 0x17, 0x51, 0x61, 0x1e, 0xe5, 0xfb, 0x01, 0x06, 0xc8, 0x00, + 0x01, 0xff, 0x53, 0x6a, 0x27, 0x9e, 0xce, 0x01, 0x4e, 0x62, 0x81, 0x3e, + 0xcc, 0x41, 0x53, 0x6a, 0x27, 0x9d, 0xce, 0x01, 0x4e, 0x62, 0x81, 0x3d, + 0xcc, 0x41, 0x48, 0xca, 0x0d, 0x4e, 0x20, 0x00, 0xa2, 0x19, 0x5b, 0x05, + 0x1c, 0x1f, 0x30, 0x00, 0x46, 0x37, 0x52, 0x47, 0x2e, 0x80, 0x06, 0x44, + 0xef, 0x05, 0x5f, 0x00, 0x40, 0x49, 0x98, 0x3d, 0x48, 0x2e, 0x40, 0x46, + 0xe8, 0xdf, 0xab, 0xfa, 0x01, 0x50, 0x4c, 0x5b, 0x05, 0xf5, 0x41, 0x45, + 0x0f, 0xed, 0xe9, 0xf3, 0x01, 0x46, 0x13, 0x06, 0x8c, 0xf4, 0x41, 0x4b, + 0x93, 0x9c, 0x74, 0xf7, 0x01, 0x4a, 0x7c, 0xb1, 0xf4, 0xf9, 0x01, 0x42, + 0xef, 0x02, 0xb7, 0xfa, 0x41, 0xa4, 0xa3, 0x01, 0x04, 0xc3, 0x00, 0x55, + 0x05, 0xc8, 0x00, 0x01, 0xff, 0x45, 0x17, 0x3b, 0xdd, 0x27, 0x00, 0x06, + 0xa9, 0x01, 0x01, 0xff, 0x45, 0xce, 0x00, 0xf6, 0x27, 0x80, 0x23, 0x4c, + 0xd8, 0x92, 0xf9, 0x27, 0x80, 0x16, 0x08, 0xc9, 0x02, 0x06, 0x4e, 0x58, + 0x80, 0xff, 0x27, 0x40, 0x5d, 0xc2, 0x15, 0xd2, 0xf8, 0x01, 0x5b, 0x06, + 0x1e, 0xd1, 0xf8, 0x41, 0x49, 0xde, 0xb9, 0xfe, 0x27, 0x40, 0x80, 0x01, + 0xff, 0x48, 0xdf, 0xb9, 0xfc, 0x27, 0x00, 0x59, 0x00, 0x27, 0xd0, 0xf8, + 0x01, 0x49, 0x93, 0xc5, 0xd6, 0xf8, 0x01, 0x51, 0x44, 0x62, 0xd7, 0xf8, + 0x41, 0x80, 0x2b, 0x06, 0xa9, 0x01, 0x01, 0xff, 0x45, 0xce, 0x00, 0xf5, + 0x27, 0x80, 0x19, 0x4c, 0xd8, 0x92, 0xf8, 0x27, 0x80, 0x0c, 0x66, 0x25, + 0x07, 0xd4, 0xf8, 0x01, 0x4e, 0x58, 0x80, 0x33, 0x2b, 0x40, 0x49, 0xde, + 0xb9, 0xfd, 0x27, 0x40, 0x49, 0xde, 0xb9, 0xfb, 0x27, 0x40, 0x06, 0xc8, + 0x00, 0x06, 0x44, 0x18, 0x3b, 0xde, 0x27, 0x40, 0x45, 0xce, 0x00, 0xf7, + 0x27, 0x80, 0x06, 0x4c, 0xd8, 0x92, 0xfa, 0x27, 0x40, 0x54, 0xfb, 0x41, + 0xd8, 0xf8, 0x41, 0x67, 0xa6, 0x05, 0xe6, 0x2a, 0x00, 0x47, 0x8f, 0x34, + 0xcc, 0x27, 0x00, 0x43, 0xaa, 0x1e, 0x98, 0xfa, 0x41, 0x06, 0x08, 0xde, + 0x7a, 0x03, 0x13, 0x00, 0x01, 0xff, 0x43, 0x1a, 0x00, 0x27, 0x22, 0x80, + 0x3c, 0x42, 0x0c, 0x00, 0x28, 0x22, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x57, + 0xc2, 0x31, 0x59, 0x2a, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x02, 0x3b, + 0x01, 0x0c, 0x4f, 0x34, 0x71, 0x5d, 0x2a, 0x00, 0x4b, 0xc8, 0xa4, 0x5b, + 0x2a, 0x40, 0x47, 0x79, 0x1f, 0x52, 0x2a, 0x00, 0x05, 0x3d, 0x01, 0x01, + 0xff, 0x47, 0xc2, 0x83, 0x62, 0x2a, 0x00, 0x48, 0x64, 0x5c, 0x63, 0x2a, + 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x02, 0x3b, 0x01, 0x12, 0x4f, 0x34, + 0x71, 0x5c, 0x2a, 0x00, 0x4b, 0xc8, 0xa4, 0x5a, 0x2a, 0x00, 0x48, 0x64, + 0x5c, 0x5f, 0x2a, 0x40, 0x47, 0x79, 0x1f, 0x51, 0x2a, 0x00, 0x05, 0x3d, + 0x01, 0x01, 0xff, 0x47, 0xc2, 0x83, 0x5e, 0x2a, 0x00, 0x48, 0x64, 0x5c, + 0x60, 0x2a, 0x40, 0x43, 0x1a, 0x00, 0x16, 0xcc, 0x01, 0x46, 0x36, 0xe0, + 0x19, 0xcc, 0x81, 0x16, 0x09, 0x9a, 0x24, 0x06, 0x42, 0x0c, 0x00, 0x15, + 0xcc, 0x41, 0x46, 0xee, 0xe2, 0x17, 0xcc, 0x01, 0x46, 0x8c, 0x53, 0x18, + 0xcc, 0x41, 0x54, 0x23, 0x42, 0x1a, 0xcc, 0x41, 0x4d, 0xa2, 0x83, 0x0f, + 0xf5, 0x01, 0x0a, 0x54, 0xb1, 0x01, 0xff, 0x43, 0x7a, 0x0b, 0x0e, 0x00, + 0x00, 0x44, 0x80, 0x1f, 0x0f, 0x00, 0x40, 0x43, 0x88, 0x09, 0x4e, 0x26, + 0x00, 0xa7, 0x93, 0x1d, 0xad, 0xd3, 0x19, 0xae, 0xdd, 0x02, 0x47, 0xc9, + 0xd9, 0x81, 0xf9, 0x01, 0x42, 0x9a, 0x08, 0xe2, 0xf5, 0x81, 0xc9, 0x02, + 0x47, 0xa2, 0x88, 0xa4, 0x20, 0x00, 0x03, 0x76, 0x23, 0x0c, 0x51, 0x11, + 0x62, 0xb6, 0x20, 0x00, 0x44, 0xdf, 0x97, 0x8e, 0xf9, 0x41, 0x07, 0x13, + 0x06, 0x11, 0x0c, 0x3b, 0x17, 0x01, 0xff, 0x45, 0x13, 0x05, 0xfe, 0xa4, + 0x00, 0x49, 0x4f, 0x17, 0xff, 0xa4, 0x40, 0xe1, 0xee, 0xa4, 0x80, 0x94, + 0x02, 0x42, 0x16, 0x00, 0xd0, 0xa4, 0x00, 0xa3, 0x81, 0x02, 0xa4, 0xf4, + 0x01, 0xe5, 0xf0, 0xa4, 0x80, 0xea, 0x01, 0x42, 0x0c, 0x08, 0xe9, 0xa4, + 0x00, 0xa7, 0xd7, 0x01, 0xa8, 0xca, 0x01, 0xe9, 0xf2, 0xa4, 0x00, 0x42, + 0x78, 0x1a, 0xd9, 0xa4, 0x00, 0xab, 0xb3, 0x01, 0x42, 0x74, 0x00, 0xe1, + 0xa4, 0x00, 0x42, 0x6c, 0x00, 0xdf, 0xa4, 0x00, 0xae, 0x9a, 0x01, 0xef, + 0xf3, 0xa4, 0x80, 0x90, 0x01, 0xb0, 0x83, 0x01, 0xb3, 0x77, 0xb4, 0x32, + 0xf5, 0xf4, 0xa4, 0x80, 0x25, 0x42, 0xa9, 0x01, 0xea, 0xa4, 0x00, 0x42, + 0x5b, 0x28, 0xe7, 0xa4, 0x00, 0xb9, 0x0d, 0xba, 0x01, 0xff, 0xe1, 0xe4, + 0xa4, 0x00, 0x42, 0x22, 0x00, 0xe3, 0xa4, 0x40, 0xe1, 0xec, 0xa4, 0x00, + 0x42, 0x22, 0x00, 0xb0, 0x1f, 0x41, 0xe5, 0xf5, 0xa4, 0x00, 0xe8, 0xf6, + 0xa4, 0x40, 0xe1, 0xd4, 0xa4, 0x00, 0x42, 0x22, 0x00, 0xd5, 0xa4, 0x00, + 0x04, 0x7a, 0x0b, 0x0d, 0xb3, 0x01, 0xff, 0xe1, 0xdd, 0xa4, 0x00, 0x42, + 0x22, 0x00, 0xde, 0xa4, 0x40, 0x04, 0x4d, 0x65, 0x06, 0x45, 0xd6, 0xee, + 0xf9, 0xa4, 0x40, 0x42, 0x5d, 0x00, 0xfb, 0xa4, 0x00, 0x43, 0x12, 0xfa, + 0xfa, 0xa4, 0x00, 0x43, 0x57, 0xfa, 0xfd, 0xa4, 0x00, 0x42, 0x2a, 0x05, + 0xfc, 0xa4, 0x00, 0x42, 0x35, 0x00, 0xf8, 0xa4, 0x40, 0xe1, 0xe2, 0xa4, + 0x00, 0x42, 0x22, 0x00, 0xeb, 0xa4, 0x40, 0xe1, 0xd1, 0xa4, 0x00, 0x42, + 0x22, 0x00, 0xd2, 0xa4, 0x40, 0xe5, 0xf7, 0xa4, 0x40, 0xe1, 0xe0, 0xa4, + 0x00, 0x42, 0x24, 0x02, 0xe5, 0xa4, 0x40, 0xe1, 0xd7, 0xa4, 0x00, 0x42, + 0x22, 0x00, 0xd8, 0xa4, 0x40, 0xe1, 0xe6, 0xa4, 0x00, 0x42, 0x22, 0x00, + 0xe8, 0xa4, 0x40, 0xe1, 0xd6, 0xa4, 0x00, 0x42, 0x22, 0x00, 0xed, 0xa4, + 0x40, 0xf5, 0xf1, 0xa4, 0x40, 0xe1, 0xd3, 0xa4, 0x00, 0x42, 0x59, 0x00, + 0xdc, 0xa4, 0x40, 0xe1, 0xda, 0xa4, 0x00, 0x42, 0x22, 0x00, 0xdb, 0xa4, + 0x40, 0xe5, 0xef, 0xa4, 0x40, 0x44, 0xfd, 0x07, 0x84, 0xf4, 0x41, 0xa5, + 0x0f, 0xab, 0x01, 0xff, 0x47, 0x15, 0x08, 0x17, 0xf5, 0x01, 0x4d, 0x6d, + 0x86, 0x87, 0xf5, 0x41, 0x80, 0xab, 0x16, 0x03, 0x17, 0x00, 0x01, 0xff, + 0x08, 0xbf, 0xc8, 0xd5, 0x09, 0x02, 0x26, 0x02, 0x01, 0xff, 0x09, 0xa2, + 0xbf, 0xdd, 0x04, 0x0a, 0x84, 0xb3, 0xae, 0x04, 0x02, 0x16, 0x08, 0x01, + 0xff, 0x09, 0x52, 0xc1, 0x4e, 0x07, 0x0c, 0xd9, 0x01, 0xff, 0x91, 0x3f, + 0x42, 0x37, 0xf3, 0x52, 0x00, 0x01, 0x42, 0xef, 0xfa, 0x53, 0x00, 0x01, + 0x94, 0x29, 0x42, 0xaf, 0xc8, 0x56, 0x00, 0x01, 0x96, 0x19, 0x42, 0x37, + 0x42, 0x59, 0x00, 0x01, 0x98, 0x01, 0xff, 0xd2, 0x5a, 0x00, 0x01, 0xd3, + 0x5b, 0x00, 0x01, 0xd6, 0x5c, 0x00, 0x01, 0xd9, 0x5d, 0x00, 0x41, 0xd3, + 0x57, 0x00, 0x01, 0xd4, 0x58, 0x00, 0x41, 0xd7, 0x54, 0x00, 0x01, 0xd9, + 0x55, 0x00, 0x41, 0xd8, 0x50, 0x00, 0x01, 0xd9, 0x51, 0x00, 0x41, 0x90, + 0x9e, 0x03, 0x91, 0xeb, 0x02, 0x92, 0xb2, 0x02, 0x93, 0xff, 0x01, 0x94, + 0xcc, 0x01, 0x95, 0x93, 0x01, 0x96, 0x61, 0x97, 0x29, 0x98, 0x0f, 0x99, + 0x01, 0xff, 0x45, 0x05, 0xe8, 0x44, 0x00, 0x01, 0x45, 0x46, 0xe8, 0x4d, + 0x00, 0x41, 0x44, 0x23, 0xe8, 0x14, 0x00, 0x01, 0x44, 0x04, 0xf3, 0x13, + 0x00, 0x01, 0x44, 0xbc, 0xf3, 0x42, 0x00, 0x01, 0x45, 0x77, 0xe9, 0x4c, + 0x00, 0x41, 0x44, 0xc4, 0xf2, 0x12, 0x00, 0x01, 0x45, 0x32, 0xe8, 0x43, + 0x00, 0x01, 0x44, 0x3c, 0xf3, 0x1f, 0x00, 0x01, 0x44, 0x74, 0xf3, 0x16, + 0x00, 0x01, 0x44, 0xb0, 0xf3, 0x3d, 0x00, 0x01, 0x44, 0x00, 0xf4, 0x38, + 0x00, 0x01, 0x45, 0x36, 0xe9, 0x48, 0x00, 0x01, 0x44, 0x10, 0xdf, 0x0f, + 0x00, 0x01, 0x44, 0x88, 0xf4, 0x24, 0x00, 0x41, 0x44, 0xd0, 0xf2, 0x28, + 0x00, 0x01, 0x43, 0x04, 0x79, 0x03, 0x00, 0x01, 0x45, 0x96, 0xe8, 0x47, + 0x00, 0x01, 0x44, 0xd8, 0xf3, 0x0e, 0x00, 0x01, 0x45, 0x45, 0xe9, 0x4b, + 0x00, 0x01, 0x44, 0x50, 0xf4, 0x11, 0x00, 0x01, 0x45, 0xa4, 0xe9, 0x4a, + 0x00, 0x01, 0x44, 0xb4, 0xf4, 0x36, 0x00, 0x41, 0x44, 0xcc, 0xf2, 0x22, + 0x00, 0x01, 0x44, 0xf0, 0xf2, 0x09, 0x00, 0x01, 0x44, 0x38, 0xf3, 0x1c, + 0x00, 0x01, 0x44, 0x80, 0xf3, 0x2a, 0x00, 0x01, 0x44, 0xa8, 0xf3, 0x37, + 0x00, 0x01, 0x44, 0xe4, 0xf3, 0x1d, 0x00, 0x01, 0x44, 0x4c, 0xf4, 0x0a, + 0x00, 0x01, 0x44, 0x8c, 0xf4, 0x31, 0x00, 0x01, 0x44, 0xac, 0xf4, 0x32, + 0x00, 0x41, 0x44, 0xd8, 0xf2, 0x39, 0x00, 0x01, 0x44, 0x18, 0xf3, 0x2f, + 0x00, 0x01, 0x44, 0xcc, 0xd3, 0x3a, 0x00, 0x01, 0x44, 0x54, 0xf3, 0x41, + 0x00, 0x01, 0x44, 0x94, 0xf3, 0x10, 0x00, 0x01, 0x44, 0xc4, 0xf3, 0x06, + 0x00, 0x01, 0x44, 0x14, 0xf4, 0x0b, 0x00, 0x01, 0x45, 0x9f, 0xe9, 0x45, + 0x00, 0x41, 0x44, 0xc8, 0xf2, 0x1b, 0x00, 0x01, 0x44, 0x14, 0xf3, 0x2d, + 0x00, 0x01, 0x44, 0x40, 0xf3, 0x26, 0x00, 0x01, 0x45, 0xbe, 0xe8, 0x49, + 0x00, 0x01, 0x44, 0x18, 0xf4, 0x0d, 0x00, 0x01, 0x44, 0x5c, 0xf4, 0x34, + 0x00, 0x01, 0x43, 0x70, 0xf4, 0x01, 0x00, 0x01, 0x44, 0x9c, 0xf4, 0x20, + 0x00, 0x41, 0x44, 0xe0, 0xf2, 0x3f, 0x00, 0x01, 0x44, 0x0c, 0xf3, 0x25, + 0x00, 0x01, 0x44, 0x78, 0xf3, 0x18, 0x00, 0x01, 0x44, 0x9c, 0xf3, 0x1a, + 0x00, 0x01, 0x44, 0xb4, 0xf3, 0x40, 0x00, 0x01, 0x44, 0x30, 0xf4, 0x2c, + 0x00, 0x01, 0x44, 0x58, 0xf4, 0x29, 0x00, 0x01, 0x43, 0xd6, 0xf9, 0x02, + 0x00, 0x01, 0x45, 0xd6, 0xe9, 0x46, 0x00, 0x41, 0x43, 0x73, 0xf9, 0x04, + 0x00, 0x01, 0x44, 0x08, 0xf3, 0x21, 0x00, 0x01, 0x44, 0x48, 0xf3, 0x30, + 0x00, 0x01, 0x44, 0x70, 0xf3, 0x15, 0x00, 0x01, 0x44, 0x8c, 0xf3, 0x08, + 0x00, 0x01, 0x44, 0xe0, 0xf3, 0x17, 0x00, 0x01, 0x44, 0x2c, 0xf4, 0x23, + 0x00, 0x01, 0x44, 0x64, 0xf4, 0x3c, 0x00, 0x41, 0x44, 0xe8, 0xf2, 0x05, + 0x00, 0x01, 0x44, 0x44, 0xf3, 0x2b, 0x00, 0x01, 0x44, 0x7c, 0xf3, 0x1e, + 0x00, 0x01, 0x44, 0xa0, 0xf3, 0x33, 0x00, 0x01, 0x44, 0xf0, 0xf3, 0x35, + 0x00, 0x01, 0x44, 0x24, 0xf4, 0x19, 0x00, 0x01, 0x44, 0xdc, 0xba, 0x07, + 0x00, 0x01, 0x43, 0xd3, 0xf9, 0x00, 0x00, 0x01, 0x44, 0xa0, 0xf4, 0x2e, + 0x00, 0x41, 0x91, 0x06, 0x49, 0xda, 0xba, 0xd2, 0x00, 0x41, 0x92, 0x14, + 0x93, 0x06, 0x48, 0xaf, 0xc8, 0xa4, 0x00, 0x41, 0x47, 0xda, 0xd3, 0x98, + 0x00, 0x01, 0x46, 0xe6, 0xde, 0x99, 0x00, 0x41, 0x46, 0x10, 0xdf, 0x93, + 0x00, 0x01, 0x48, 0xb7, 0xc8, 0x94, 0x00, 0x41, 0xa2, 0x87, 0x01, 0x08, + 0x07, 0xd2, 0x01, 0xff, 0x43, 0x8e, 0xf9, 0xde, 0x00, 0x01, 0x92, 0x06, + 0x43, 0xa9, 0xf9, 0xfa, 0x00, 0x41, 0x90, 0x4a, 0x91, 0x20, 0x92, 0x06, + 0x42, 0x85, 0xd8, 0xf9, 0x00, 0x41, 0xd1, 0xf3, 0x00, 0x01, 0xd2, 0xf4, + 0x00, 0x01, 0xd6, 0xf5, 0x00, 0x01, 0xd7, 0xf6, 0x00, 0x01, 0xd8, 0xf7, + 0x00, 0x01, 0xd9, 0xf8, 0x00, 0x41, 0xd0, 0xe9, 0x00, 0x01, 0xd1, 0xea, + 0x00, 0x01, 0xd2, 0xeb, 0x00, 0x01, 0xd3, 0xec, 0x00, 0x01, 0xd4, 0xed, + 0x00, 0x01, 0xd5, 0xee, 0x00, 0x01, 0xd6, 0xef, 0x00, 0x01, 0xd7, 0xf0, + 0x00, 0x01, 0xd8, 0xf1, 0x00, 0x01, 0xd9, 0xf2, 0x00, 0x41, 0xd0, 0xdf, + 0x00, 0x01, 0xd1, 0xe0, 0x00, 0x01, 0xd2, 0xe1, 0x00, 0x01, 0xd3, 0xe2, + 0x00, 0x01, 0xd4, 0xe3, 0x00, 0x01, 0xd5, 0xe4, 0x00, 0x01, 0xd6, 0xe5, + 0x00, 0x01, 0xd7, 0xe6, 0x00, 0x01, 0xd8, 0xe7, 0x00, 0x01, 0xd9, 0xe8, + 0x00, 0x41, 0x91, 0x84, 0x01, 0x92, 0x01, 0xff, 0x92, 0x73, 0x93, 0x53, + 0x94, 0x29, 0x95, 0x01, 0xff, 0xd1, 0xd5, 0x00, 0x01, 0xd2, 0xd6, 0x00, + 0x01, 0xd3, 0xd7, 0x00, 0x01, 0x46, 0xbc, 0xde, 0xd8, 0x00, 0x01, 0xd5, + 0xd9, 0x00, 0x01, 0xd6, 0xda, 0x00, 0x01, 0xd7, 0xdb, 0x00, 0x01, 0xd8, + 0xdc, 0x00, 0x01, 0xd9, 0xdd, 0x00, 0x41, 0x51, 0x3b, 0x5a, 0xcc, 0x00, + 0x01, 0x49, 0xc8, 0xba, 0xcd, 0x00, 0x01, 0x4f, 0x74, 0x6d, 0xce, 0x00, + 0x01, 0x47, 0x04, 0xd4, 0xcf, 0x00, 0x01, 0xd5, 0xd0, 0x00, 0x01, 0xd6, + 0xd1, 0x00, 0x01, 0xd8, 0xd3, 0x00, 0x01, 0xd9, 0xd4, 0x00, 0x41, 0x47, + 0xb0, 0xd3, 0xc6, 0x00, 0x01, 0x47, 0xbe, 0xd3, 0xc7, 0x00, 0x01, 0xd2, + 0xc8, 0x00, 0x01, 0x47, 0xfd, 0xd3, 0xc9, 0x00, 0x01, 0xd4, 0xca, 0x00, + 0x01, 0xd6, 0xcb, 0x00, 0x41, 0x4b, 0x90, 0x9d, 0xc4, 0x00, 0x01, 0x49, + 0xec, 0xba, 0xc5, 0x00, 0x41, 0x90, 0xfb, 0x01, 0x92, 0xda, 0x01, 0x93, + 0xc7, 0x01, 0x94, 0xaa, 0x01, 0x95, 0x83, 0x01, 0x96, 0x55, 0x97, 0x2b, + 0x98, 0x0d, 0x99, 0x01, 0xff, 0xd0, 0xc2, 0x00, 0x01, 0x48, 0x9f, 0xc8, + 0xc3, 0x00, 0x41, 0xd0, 0xbb, 0x00, 0x01, 0xd1, 0xbc, 0x00, 0x01, 0xd2, + 0xbd, 0x00, 0x01, 0xd3, 0xbe, 0x00, 0x01, 0xd4, 0xbf, 0x00, 0x01, 0xd5, + 0xc0, 0x00, 0x01, 0xd9, 0xc1, 0x00, 0x41, 0xd0, 0xb2, 0x00, 0x01, 0xd1, + 0xb3, 0x00, 0x01, 0xd2, 0xb4, 0x00, 0x01, 0x47, 0xe8, 0xd3, 0xb5, 0x00, + 0x01, 0xd4, 0xb6, 0x00, 0x01, 0x46, 0x04, 0xdf, 0xb7, 0x00, 0x01, 0xd7, + 0xb8, 0x00, 0x01, 0xd8, 0xb9, 0x00, 0x01, 0xd9, 0xba, 0x00, 0x41, 0xd0, + 0xa8, 0x00, 0x01, 0xd1, 0xa9, 0x00, 0x01, 0x49, 0xd1, 0xba, 0xaa, 0x00, + 0x01, 0x48, 0xa7, 0xc8, 0xab, 0x00, 0x01, 0xd4, 0xac, 0x00, 0x01, 0xd5, + 0xad, 0x00, 0x01, 0xd6, 0xae, 0x00, 0x01, 0xd7, 0xaf, 0x00, 0x01, 0xd8, + 0xb0, 0x00, 0x01, 0xd9, 0xb1, 0x00, 0x41, 0xd0, 0x9f, 0x00, 0x01, 0x46, + 0x8c, 0xde, 0xa0, 0x00, 0x01, 0xd2, 0xa1, 0x00, 0x01, 0xd3, 0xa2, 0x00, + 0x01, 0xd4, 0xa3, 0x00, 0x01, 0xd7, 0xa5, 0x00, 0x01, 0xd8, 0xa6, 0x00, + 0x01, 0x47, 0x27, 0xd4, 0xa7, 0x00, 0x41, 0x48, 0x8f, 0xc8, 0x9a, 0x00, + 0x01, 0x46, 0x86, 0xde, 0x9b, 0x00, 0x01, 0xd2, 0x9c, 0x00, 0x01, 0x46, + 0xec, 0xde, 0x9d, 0x00, 0x01, 0xd6, 0x9e, 0x00, 0x41, 0x45, 0x28, 0xe8, + 0x95, 0x00, 0x01, 0x46, 0x98, 0xde, 0x96, 0x00, 0x01, 0xd2, 0x97, 0x00, + 0x41, 0x47, 0xb7, 0xd3, 0x8e, 0x00, 0x01, 0x48, 0x97, 0xc8, 0x8f, 0x00, + 0x01, 0x47, 0xc5, 0xd3, 0x90, 0x00, 0x01, 0x47, 0xf6, 0xd3, 0x91, 0x00, + 0x01, 0x49, 0xf5, 0xba, 0x92, 0x00, 0x41, 0x45, 0x23, 0xe8, 0x80, 0x00, + 0x01, 0x47, 0xcc, 0xd3, 0x81, 0x00, 0x01, 0x46, 0xc2, 0xde, 0x82, 0x00, + 0x01, 0x95, 0x39, 0x96, 0x2b, 0x97, 0x1d, 0x98, 0x0f, 0x99, 0x01, 0xff, + 0x45, 0x38, 0xec, 0x8c, 0x00, 0x01, 0x46, 0xd8, 0xe3, 0x8d, 0x00, 0x41, + 0x45, 0x42, 0xec, 0x8a, 0x00, 0x01, 0x46, 0xd2, 0xe3, 0x8b, 0x00, 0x41, + 0x4a, 0xa6, 0xaf, 0x88, 0x00, 0x01, 0x49, 0x88, 0xc1, 0x89, 0x00, 0x41, + 0x45, 0x3d, 0xec, 0x86, 0x00, 0x01, 0x45, 0x40, 0xee, 0x87, 0x00, 0x41, + 0x46, 0xfc, 0xdd, 0x83, 0x00, 0x01, 0x46, 0x98, 0xe1, 0x84, 0x00, 0x01, + 0x4a, 0x20, 0xb3, 0x85, 0x00, 0x41, 0x44, 0xe4, 0xf2, 0x1b, 0x06, 0x01, + 0x91, 0xb1, 0x0c, 0x93, 0xe8, 0x09, 0x94, 0xee, 0x08, 0x95, 0x90, 0x06, + 0x96, 0xac, 0x04, 0x97, 0x9b, 0x03, 0x02, 0x2b, 0xfa, 0xf6, 0x02, 0xa2, + 0x01, 0xff, 0x90, 0x3f, 0x91, 0x01, 0xff, 0x42, 0x5a, 0xe8, 0x48, 0x06, + 0x01, 0x92, 0x28, 0x02, 0x4d, 0xf2, 0x1c, 0x42, 0x05, 0xfb, 0x50, 0x06, + 0x01, 0x42, 0xea, 0xfa, 0x51, 0x06, 0x01, 0x98, 0x06, 0x42, 0x7e, 0xf9, + 0x54, 0x06, 0x41, 0xd0, 0x52, 0x06, 0x01, 0xd8, 0x53, 0x06, 0x41, 0xe1, + 0x4d, 0x06, 0x01, 0xe2, 0x4e, 0x06, 0x41, 0xd0, 0x49, 0x06, 0x01, 0xd2, + 0x4b, 0x06, 0x01, 0xd3, 0x4c, 0x06, 0x41, 0x90, 0x8b, 0x02, 0x91, 0xf4, + 0x01, 0x92, 0xb6, 0x01, 0x93, 0x9b, 0x01, 0x94, 0x79, 0x95, 0x53, 0x96, + 0x39, 0x97, 0x1b, 0x98, 0x01, 0xff, 0xd0, 0x41, 0x06, 0x01, 0xd1, 0x42, + 0x06, 0x01, 0xd2, 0x43, 0x06, 0x01, 0xd5, 0x44, 0x06, 0x01, 0xd6, 0x45, + 0x06, 0x01, 0xd7, 0x46, 0x06, 0x41, 0xd0, 0x3a, 0x06, 0x01, 0xd3, 0x3b, + 0x06, 0x01, 0xd4, 0x3c, 0x06, 0x01, 0xd6, 0x3d, 0x06, 0x01, 0xd7, 0x3e, + 0x06, 0x01, 0xd8, 0x3f, 0x06, 0x01, 0xd9, 0x40, 0x06, 0x41, 0xd0, 0x34, + 0x06, 0x01, 0xd1, 0x35, 0x06, 0x01, 0xd5, 0x36, 0x06, 0x01, 0xd6, 0x37, + 0x06, 0x01, 0xd7, 0x38, 0x06, 0x01, 0xd9, 0x39, 0x06, 0x41, 0xd0, 0x2b, + 0x06, 0x01, 0xd1, 0x2c, 0x06, 0x01, 0xd3, 0x2d, 0x06, 0x01, 0xd4, 0x2e, + 0x06, 0x01, 0xd5, 0x2f, 0x06, 0x01, 0xd6, 0x30, 0x06, 0x01, 0xd7, 0x31, + 0x06, 0x01, 0xd8, 0x32, 0x06, 0x01, 0xd9, 0x33, 0x06, 0x41, 0xd0, 0x23, + 0x06, 0x01, 0xd1, 0x24, 0x06, 0x01, 0xd4, 0x25, 0x06, 0x01, 0xd5, 0x26, + 0x06, 0x01, 0xd6, 0x27, 0x06, 0x01, 0xd7, 0x28, 0x06, 0x01, 0xd8, 0x29, + 0x06, 0x01, 0xd9, 0x2a, 0x06, 0x41, 0xd0, 0x1d, 0x06, 0x01, 0xd1, 0x1e, + 0x06, 0x01, 0xd4, 0x1f, 0x06, 0x01, 0xd7, 0x20, 0x06, 0x01, 0xd8, 0x21, + 0x06, 0x01, 0xd9, 0x22, 0x06, 0x41, 0xd0, 0x0e, 0x06, 0x01, 0xd1, 0x0f, + 0x06, 0x81, 0x2a, 0xd2, 0x12, 0x06, 0x81, 0x1d, 0xd3, 0x15, 0x06, 0x81, + 0x14, 0xd4, 0x17, 0x06, 0x01, 0xd6, 0x18, 0x06, 0x01, 0xd7, 0x19, 0x06, + 0x01, 0xd8, 0x1a, 0x06, 0x01, 0xd9, 0x1c, 0x06, 0x41, 0xed, 0x16, 0x06, + 0x41, 0xe6, 0x13, 0x06, 0x01, 0xed, 0x14, 0x06, 0x41, 0xe6, 0x10, 0x06, + 0x01, 0xed, 0x11, 0x06, 0x41, 0xd0, 0x09, 0x06, 0x01, 0xd1, 0x0a, 0x06, + 0x01, 0xd3, 0x0b, 0x06, 0x01, 0xd6, 0x0c, 0x06, 0x01, 0xd7, 0x0d, 0x06, + 0x41, 0xd1, 0x00, 0x06, 0x01, 0xd2, 0x01, 0x06, 0x01, 0xd3, 0x02, 0x06, + 0x01, 0xd4, 0x03, 0x06, 0x01, 0xd5, 0x04, 0x06, 0x01, 0xd6, 0x05, 0x06, + 0x01, 0xd7, 0x06, 0x06, 0x01, 0xd8, 0x07, 0x06, 0x01, 0xd9, 0x08, 0x06, + 0x41, 0xd0, 0x60, 0x07, 0x01, 0xd1, 0x61, 0x07, 0x01, 0xd2, 0x62, 0x07, + 0x01, 0xd3, 0x63, 0x07, 0x01, 0xd4, 0x64, 0x07, 0x01, 0xd5, 0x65, 0x07, + 0x01, 0xd6, 0x66, 0x07, 0x01, 0xd7, 0x67, 0x07, 0x41, 0x90, 0x38, 0x91, + 0x0c, 0x47, 0xd3, 0xd3, 0x54, 0x07, 0x01, 0x45, 0xd2, 0xe8, 0x55, 0x07, + 0x41, 0x43, 0x3b, 0x5a, 0x4d, 0x07, 0x01, 0x43, 0x7f, 0xf9, 0x4e, 0x07, + 0x01, 0x43, 0x50, 0xf3, 0x4f, 0x07, 0x01, 0x47, 0xef, 0xd3, 0x50, 0x07, + 0x01, 0x45, 0xd7, 0xe8, 0x51, 0x07, 0x01, 0x44, 0xc0, 0xf3, 0x52, 0x07, + 0x01, 0x44, 0x44, 0xf4, 0x53, 0x07, 0x41, 0x43, 0xbe, 0xd3, 0x40, 0x07, + 0x01, 0x43, 0x2c, 0xf3, 0x41, 0x07, 0x01, 0x43, 0xa0, 0xf9, 0x42, 0x07, + 0x01, 0x43, 0xaf, 0xf9, 0x43, 0x07, 0x01, 0x43, 0xc8, 0xf3, 0x44, 0x07, + 0x01, 0x43, 0xf8, 0xde, 0x45, 0x07, 0x01, 0x43, 0x63, 0xe9, 0x46, 0x07, + 0x01, 0x43, 0xb7, 0xc8, 0x47, 0x07, 0x01, 0x99, 0x01, 0xff, 0x42, 0x73, + 0x00, 0x48, 0x07, 0x01, 0x8d, 0x01, 0xff, 0x44, 0x34, 0xf3, 0x49, 0x07, + 0x01, 0x44, 0x68, 0xf3, 0x4a, 0x07, 0x01, 0x44, 0x98, 0xf3, 0x4b, 0x07, + 0x01, 0x44, 0x1c, 0xf4, 0x4c, 0x07, 0x41, 0x90, 0xbe, 0x01, 0x91, 0x93, + 0x01, 0x92, 0x6d, 0x93, 0x5f, 0x94, 0x3d, 0x95, 0x17, 0x96, 0x01, 0xff, + 0xd0, 0x32, 0x07, 0x01, 0xd1, 0x33, 0x07, 0x01, 0xd2, 0x34, 0x07, 0x01, + 0xd3, 0x35, 0x07, 0x01, 0xd4, 0x36, 0x07, 0x41, 0xd1, 0x29, 0x07, 0x01, + 0xd2, 0x2a, 0x07, 0x01, 0xd3, 0x2b, 0x07, 0x01, 0xd4, 0x2c, 0x07, 0x01, + 0xd5, 0x2d, 0x07, 0x01, 0xd6, 0x2e, 0x07, 0x01, 0xd7, 0x2f, 0x07, 0x01, + 0xd8, 0x30, 0x07, 0x01, 0xd9, 0x31, 0x07, 0x41, 0xd0, 0x21, 0x07, 0x01, + 0xd2, 0x22, 0x07, 0x01, 0xd3, 0x23, 0x07, 0x01, 0xd4, 0x24, 0x07, 0x01, + 0xd5, 0x25, 0x07, 0x01, 0xd6, 0x26, 0x07, 0x01, 0xd8, 0x27, 0x07, 0x01, + 0xd9, 0x28, 0x07, 0x41, 0xd4, 0x1e, 0x07, 0x01, 0xd7, 0x1f, 0x07, 0x01, + 0xd8, 0x20, 0x07, 0x41, 0xd0, 0x15, 0x07, 0x01, 0xd1, 0x16, 0x07, 0x01, + 0xd2, 0x17, 0x07, 0x01, 0xd3, 0x18, 0x07, 0x01, 0xd4, 0x19, 0x07, 0x01, + 0xd6, 0x1a, 0x07, 0x01, 0xd7, 0x1b, 0x07, 0x01, 0xd8, 0x1c, 0x07, 0x01, + 0xd9, 0x1d, 0x07, 0x41, 0xd0, 0x0b, 0x07, 0x01, 0xd1, 0x0c, 0x07, 0x01, + 0xd2, 0x0d, 0x07, 0x01, 0xd3, 0x0e, 0x07, 0x01, 0xd4, 0x0f, 0x07, 0x01, + 0xd5, 0x10, 0x07, 0x01, 0xd6, 0x11, 0x07, 0x01, 0xd7, 0x12, 0x07, 0x01, + 0xd8, 0x13, 0x07, 0x01, 0xd9, 0x14, 0x07, 0x41, 0xd0, 0x03, 0x07, 0x01, + 0xd1, 0x04, 0x07, 0x01, 0xd2, 0x05, 0x07, 0x01, 0xd3, 0x06, 0x07, 0x01, + 0xd4, 0x07, 0x07, 0x01, 0xd6, 0x08, 0x07, 0x01, 0xd8, 0x09, 0x07, 0x01, + 0xd9, 0x0a, 0x07, 0x41, 0x90, 0xb8, 0x02, 0x91, 0x9d, 0x02, 0x92, 0xf6, + 0x01, 0x93, 0xcf, 0x01, 0x94, 0xb0, 0x01, 0x95, 0x89, 0x01, 0x96, 0x6f, + 0x97, 0x45, 0x98, 0x1b, 0x99, 0x01, 0xff, 0xd1, 0xfd, 0x06, 0x01, 0xd2, + 0xfe, 0x06, 0x01, 0xd4, 0xff, 0x06, 0x01, 0xd5, 0x00, 0x07, 0x01, 0xd6, + 0x01, 0x07, 0x01, 0xd8, 0x02, 0x07, 0x41, 0xd0, 0xf3, 0x06, 0x01, 0xd1, + 0xf4, 0x06, 0x01, 0xd2, 0xf5, 0x06, 0x01, 0xd3, 0xf6, 0x06, 0x01, 0xd4, + 0xf7, 0x06, 0x01, 0xd5, 0xf8, 0x06, 0x01, 0xd6, 0xf9, 0x06, 0x01, 0xd7, + 0xfa, 0x06, 0x01, 0xd8, 0xfb, 0x06, 0x01, 0xd9, 0xfc, 0x06, 0x41, 0xd0, + 0xe9, 0x06, 0x01, 0xd1, 0xea, 0x06, 0x01, 0xd2, 0xeb, 0x06, 0x01, 0xd3, + 0xec, 0x06, 0x01, 0xd4, 0xed, 0x06, 0x01, 0xd5, 0xee, 0x06, 0x01, 0xd6, + 0xef, 0x06, 0x01, 0xd7, 0xf0, 0x06, 0x01, 0xd8, 0xf1, 0x06, 0x01, 0xd9, + 0xf2, 0x06, 0x41, 0xd3, 0xe3, 0x06, 0x01, 0xd4, 0xe4, 0x06, 0x01, 0xd5, + 0xe5, 0x06, 0x01, 0xd6, 0xe6, 0x06, 0x01, 0xd8, 0xe7, 0x06, 0x01, 0xd9, + 0xe8, 0x06, 0x41, 0xd0, 0xda, 0x06, 0x01, 0xd1, 0xdb, 0x06, 0x01, 0xd2, + 0xdc, 0x06, 0x01, 0xd3, 0xdd, 0x06, 0x01, 0xd4, 0xde, 0x06, 0x01, 0xd5, + 0xdf, 0x06, 0x01, 0xd6, 0xe0, 0x06, 0x01, 0xd7, 0xe1, 0x06, 0x01, 0xd9, + 0xe2, 0x06, 0x41, 0xd0, 0xd3, 0x06, 0x01, 0xd1, 0xd4, 0x06, 0x01, 0xd2, + 0xd5, 0x06, 0x01, 0xd5, 0xd6, 0x06, 0x01, 0xd7, 0xd7, 0x06, 0x01, 0xd8, + 0xd8, 0x06, 0x01, 0xd9, 0xd9, 0x06, 0x41, 0xd0, 0xca, 0x06, 0x01, 0xd1, + 0xcb, 0x06, 0x01, 0xd2, 0xcc, 0x06, 0x01, 0xd4, 0xcd, 0x06, 0x01, 0xd5, + 0xce, 0x06, 0x01, 0xd6, 0xcf, 0x06, 0x01, 0xd7, 0xd0, 0x06, 0x01, 0xd8, + 0xd1, 0x06, 0x01, 0xd9, 0xd2, 0x06, 0x41, 0xd0, 0xc1, 0x06, 0x01, 0xd1, + 0xc2, 0x06, 0x01, 0xd3, 0xc3, 0x06, 0x01, 0xd4, 0xc4, 0x06, 0x01, 0xd5, + 0xc5, 0x06, 0x01, 0xd6, 0xc6, 0x06, 0x01, 0xd7, 0xc7, 0x06, 0x01, 0xd8, + 0xc8, 0x06, 0x01, 0xd9, 0xc9, 0x06, 0x41, 0xd0, 0xbb, 0x06, 0x01, 0xd1, + 0xbc, 0x06, 0x01, 0xd2, 0xbd, 0x06, 0x01, 0xd3, 0xbe, 0x06, 0x01, 0xd5, + 0xbf, 0x06, 0x01, 0xd6, 0xc0, 0x06, 0x41, 0xd1, 0xb3, 0x06, 0x01, 0xd2, + 0xb4, 0x06, 0x01, 0xd3, 0xb5, 0x06, 0x01, 0xd4, 0xb6, 0x06, 0x01, 0xd5, + 0xb7, 0x06, 0x01, 0xd6, 0xb8, 0x06, 0x01, 0xd8, 0xb9, 0x06, 0x01, 0xd9, + 0xba, 0x06, 0x41, 0x90, 0x39, 0x91, 0x01, 0xff, 0x45, 0x2d, 0xe8, 0xaa, + 0x06, 0x01, 0x45, 0x55, 0xe8, 0xab, 0x06, 0x01, 0x45, 0xa0, 0xe8, 0xac, + 0x06, 0x01, 0x45, 0xcd, 0xe8, 0xad, 0x06, 0x01, 0x45, 0x13, 0xe9, 0xae, + 0x06, 0x01, 0x45, 0x27, 0xe9, 0xaf, 0x06, 0x01, 0x45, 0x4f, 0xe9, 0xb0, + 0x06, 0x01, 0x45, 0x7c, 0xe9, 0xb1, 0x06, 0x01, 0x45, 0xa9, 0xe9, 0xb2, + 0x06, 0x41, 0x45, 0x2d, 0xe8, 0xa0, 0x06, 0x01, 0x45, 0x55, 0xe8, 0xa1, + 0x06, 0x01, 0x45, 0xa0, 0xe8, 0xa2, 0x06, 0x01, 0x45, 0xcd, 0xe8, 0xa3, + 0x06, 0x01, 0x45, 0x13, 0xe9, 0xa4, 0x06, 0x01, 0x45, 0x27, 0xe9, 0xa5, + 0x06, 0x01, 0x45, 0x4f, 0xe9, 0xa6, 0x06, 0x01, 0x45, 0x7c, 0xe9, 0xa7, + 0x06, 0x01, 0x45, 0xa9, 0xe9, 0xa8, 0x06, 0x01, 0x45, 0xea, 0xe9, 0xa9, + 0x06, 0x41, 0x90, 0x94, 0x02, 0x91, 0xdf, 0x01, 0x92, 0xb4, 0x01, 0x93, + 0x89, 0x01, 0x94, 0x5f, 0x95, 0x35, 0x96, 0x0b, 0x97, 0x01, 0xff, 0xd0, + 0x9e, 0x06, 0x01, 0xd1, 0x9f, 0x06, 0x41, 0xd0, 0x94, 0x06, 0x01, 0xd1, + 0x95, 0x06, 0x01, 0xd2, 0x96, 0x06, 0x01, 0xd3, 0x97, 0x06, 0x01, 0xd4, + 0x98, 0x06, 0x01, 0xd5, 0x99, 0x06, 0x01, 0xd6, 0x9a, 0x06, 0x01, 0xd7, + 0x9b, 0x06, 0x01, 0xd8, 0x9c, 0x06, 0x01, 0xd9, 0x9d, 0x06, 0x41, 0xd0, + 0x8a, 0x06, 0x01, 0xd1, 0x8b, 0x06, 0x01, 0xd2, 0x8c, 0x06, 0x01, 0xd3, + 0x8d, 0x06, 0x01, 0xd4, 0x8e, 0x06, 0x01, 0xd5, 0x8f, 0x06, 0x01, 0xd6, + 0x90, 0x06, 0x01, 0xd7, 0x91, 0x06, 0x01, 0xd8, 0x92, 0x06, 0x01, 0xd9, + 0x93, 0x06, 0x41, 0xd0, 0x80, 0x06, 0x01, 0xd1, 0x81, 0x06, 0x01, 0xd2, + 0x82, 0x06, 0x01, 0xd3, 0x83, 0x06, 0x01, 0xd4, 0x84, 0x06, 0x01, 0xd5, + 0x85, 0x06, 0x01, 0xd6, 0x86, 0x06, 0x01, 0xd7, 0x87, 0x06, 0x01, 0xd8, + 0x88, 0x06, 0x01, 0xd9, 0x89, 0x06, 0x41, 0xd0, 0x76, 0x06, 0x01, 0xd1, + 0x77, 0x06, 0x01, 0xd2, 0x78, 0x06, 0x01, 0xd3, 0x79, 0x06, 0x01, 0xd4, + 0x7a, 0x06, 0x01, 0xd5, 0x7b, 0x06, 0x01, 0xd6, 0x7c, 0x06, 0x01, 0xd7, + 0x7d, 0x06, 0x01, 0xd8, 0x7e, 0x06, 0x01, 0xd9, 0x7f, 0x06, 0x41, 0xd0, + 0x6c, 0x06, 0x01, 0xd1, 0x6d, 0x06, 0x01, 0xd2, 0x6e, 0x06, 0x01, 0xd3, + 0x6f, 0x06, 0x01, 0xd4, 0x70, 0x06, 0x01, 0xd5, 0x71, 0x06, 0x01, 0xd6, + 0x72, 0x06, 0x01, 0xd7, 0x73, 0x06, 0x01, 0xd8, 0x74, 0x06, 0x01, 0xd9, + 0x75, 0x06, 0x41, 0xd0, 0x60, 0x06, 0x01, 0xd1, 0x61, 0x06, 0x01, 0xd2, + 0x62, 0x06, 0x01, 0x93, 0x18, 0xd4, 0x66, 0x06, 0x01, 0xd5, 0x67, 0x06, + 0x01, 0xd6, 0x68, 0x06, 0x01, 0xd7, 0x69, 0x06, 0x01, 0xd8, 0x6a, 0x06, + 0x01, 0xd9, 0x6b, 0x06, 0x41, 0xe1, 0x63, 0x06, 0x01, 0xe2, 0x64, 0x06, + 0x01, 0xe3, 0x65, 0x06, 0x41, 0xd1, 0x55, 0x06, 0x01, 0xd2, 0x56, 0x06, + 0x01, 0xd3, 0x57, 0x06, 0x01, 0xd4, 0x58, 0x06, 0x01, 0xd5, 0x59, 0x06, + 0x01, 0xd6, 0x5a, 0x06, 0x01, 0xd7, 0x5b, 0x06, 0x01, 0xd8, 0x5c, 0x06, + 0x01, 0x99, 0x01, 0xff, 0xe1, 0x5d, 0x06, 0x01, 0xe2, 0x5e, 0x06, 0x01, + 0xe3, 0x5f, 0x06, 0x41, 0x46, 0x7a, 0xde, 0x47, 0x06, 0x01, 0x43, 0x97, + 0xf9, 0x4a, 0x06, 0x01, 0x43, 0xac, 0xf9, 0x4f, 0x06, 0x41, 0x44, 0xf6, + 0x21, 0x0a, 0x00, 0x00, 0x0c, 0xe8, 0x94, 0x13, 0x49, 0xfb, 0x21, 0x28, + 0x20, 0x00, 0x4a, 0x06, 0x3e, 0x0b, 0x00, 0xc0, 0x00, 0x44, 0x00, 0xbe, + 0x8a, 0x00, 0x40, 0x56, 0xc9, 0x37, 0x14, 0x2a, 0x00, 0x05, 0x51, 0x00, + 0x01, 0xff, 0x5c, 0x18, 0x1a, 0x12, 0x2a, 0x00, 0x5d, 0x58, 0x17, 0x13, + 0x2a, 0x40, 0x03, 0x3c, 0xcf, 0x06, 0x53, 0xf8, 0x4c, 0xcf, 0x32, 0x40, + 0x06, 0xef, 0x06, 0xec, 0x02, 0x50, 0xad, 0x00, 0x44, 0x19, 0x00, 0x07, + 0x13, 0x06, 0xab, 0x01, 0x4d, 0x88, 0x36, 0x45, 0x19, 0x00, 0xb3, 0x36, + 0x05, 0x74, 0x3b, 0x01, 0xff, 0x06, 0x59, 0x03, 0x06, 0x4f, 0x47, 0x6d, + 0x00, 0x19, 0x40, 0xe1, 0x20, 0x19, 0x80, 0x1a, 0xe5, 0x27, 0x19, 0x80, + 0x11, 0xe9, 0x21, 0x19, 0x00, 0xef, 0x28, 0x19, 0x80, 0x04, 0xf5, 0x22, + 0x19, 0x40, 0xef, 0x25, 0x19, 0x40, 0xe5, 0x23, 0x19, 0x40, 0xe9, 0x24, + 0x19, 0x00, 0xf5, 0x26, 0x19, 0x40, 0x04, 0x5b, 0x03, 0x51, 0x0c, 0x9c, + 0x08, 0x17, 0x10, 0xea, 0x6a, 0x01, 0xff, 0x42, 0x71, 0x00, 0x2a, 0x19, + 0x00, 0x42, 0xa9, 0x01, 0x2b, 0x19, 0x00, 0x42, 0xdf, 0x23, 0x29, 0x19, + 0x40, 0x48, 0x0a, 0x17, 0x32, 0x19, 0x00, 0x42, 0x1b, 0x02, 0x30, 0x19, + 0x00, 0x42, 0x74, 0x00, 0x38, 0x19, 0x00, 0x42, 0x6c, 0x00, 0x36, 0x19, + 0x00, 0xae, 0x12, 0x42, 0xe0, 0x09, 0x35, 0x19, 0x00, 0x42, 0x71, 0x00, + 0x37, 0x19, 0x00, 0x42, 0x12, 0x00, 0x33, 0x19, 0x40, 0xe1, 0x34, 0x19, + 0x00, 0x42, 0x24, 0x02, 0x31, 0x19, 0x40, 0x49, 0xc2, 0xc0, 0x3a, 0x19, + 0x00, 0x43, 0x97, 0x08, 0x40, 0x19, 0x00, 0x49, 0xd9, 0xc1, 0x39, 0x19, + 0x00, 0x44, 0x80, 0xf8, 0x3b, 0x19, 0x40, 0xa2, 0xa9, 0x01, 0xa3, 0x9c, + 0x01, 0xa4, 0x8f, 0x01, 0xa7, 0x7d, 0x42, 0x22, 0x00, 0x1c, 0x19, 0x00, + 0xaa, 0x6b, 0xab, 0x5f, 0x42, 0x74, 0x00, 0x17, 0x19, 0x00, 0x42, 0x6c, + 0x00, 0x14, 0x19, 0x00, 0xae, 0x47, 0xb0, 0x3b, 0x42, 0x71, 0x00, 0x16, + 0x19, 0x00, 0xb3, 0x23, 0xb4, 0x11, 0x42, 0xa9, 0x01, 0x18, 0x19, 0x00, + 0x42, 0xdf, 0x23, 0x15, 0x19, 0xc0, 0x00, 0xee, 0x0a, 0x19, 0x40, 0xe1, + 0x0b, 0x19, 0x00, 0x42, 0x22, 0x00, 0x0c, 0x19, 0x00, 0x42, 0x71, 0x00, + 0x1e, 0x19, 0x40, 0xe1, 0x1b, 0x19, 0x00, 0x42, 0x22, 0x00, 0x19, 0x19, + 0x00, 0x42, 0x40, 0x06, 0x1a, 0x19, 0x40, 0xe1, 0x10, 0x19, 0x00, 0x42, + 0x22, 0x00, 0x11, 0x19, 0x40, 0xe1, 0x0f, 0x19, 0x00, 0x42, 0x24, 0x02, + 0x05, 0x19, 0x40, 0xe1, 0x01, 0x19, 0x00, 0x42, 0x22, 0x00, 0x02, 0x19, + 0x40, 0xe1, 0x08, 0x19, 0x00, 0x42, 0x22, 0x00, 0x09, 0x19, 0x40, 0xe1, + 0x03, 0x19, 0x00, 0x42, 0x22, 0x00, 0x04, 0x19, 0x00, 0x43, 0xb0, 0x37, + 0x1d, 0x19, 0x40, 0xe1, 0x0d, 0x19, 0x00, 0x42, 0x22, 0x00, 0x0e, 0x19, + 0x40, 0xe1, 0x06, 0x19, 0x00, 0x42, 0x22, 0x00, 0x07, 0x19, 0x40, 0xe1, + 0x12, 0x19, 0x00, 0x42, 0x22, 0x00, 0x13, 0x19, 0x40, 0x45, 0x7e, 0x0b, + 0x4e, 0x19, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x4f, 0x19, 0x00, 0x43, + 0x7a, 0x0b, 0x47, 0x19, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, + 0x46, 0x19, 0x40, 0x44, 0x25, 0x01, 0x49, 0x19, 0x00, 0x42, 0x15, 0x02, + 0x48, 0x19, 0x40, 0x44, 0x06, 0x1f, 0x4d, 0x19, 0x00, 0x42, 0x09, 0x24, + 0x4c, 0x19, 0x40, 0x43, 0xf9, 0x05, 0x4b, 0x19, 0x00, 0x43, 0xf6, 0x06, + 0x4a, 0x19, 0x40, 0x56, 0xb6, 0x2a, 0x72, 0xf6, 0x01, 0x02, 0xcb, 0x00, + 0x01, 0xff, 0x80, 0x1a, 0x45, 0x28, 0x34, 0xd9, 0xf6, 0x01, 0x44, 0x58, + 0x07, 0x07, 0x26, 0xc0, 0x00, 0x45, 0xd8, 0xe7, 0xf2, 0xf5, 0xc1, 0x00, + 0x47, 0x50, 0x80, 0xf1, 0xf5, 0x41, 0x4a, 0xa8, 0xad, 0x75, 0xfa, 0x01, + 0x4a, 0xf8, 0xad, 0xf8, 0xf5, 0x01, 0x55, 0xea, 0x3c, 0xbb, 0xf7, 0x01, + 0xa6, 0x48, 0x4b, 0xef, 0x63, 0xa2, 0xf7, 0x01, 0x64, 0x98, 0x09, 0x72, + 0x27, 0x00, 0xb2, 0x2e, 0xb3, 0x1a, 0xb4, 0x0c, 0x4c, 0x32, 0x00, 0x58, + 0x27, 0x00, 0x4c, 0x15, 0x21, 0x8e, 0xf7, 0x41, 0x57, 0x3b, 0x30, 0xc0, + 0xf7, 0x01, 0x58, 0x84, 0x2d, 0xd2, 0xf7, 0x41, 0x46, 0x35, 0x1a, 0xa9, + 0xf7, 0x01, 0x44, 0x4c, 0x04, 0x91, 0x25, 0x00, 0x52, 0x5b, 0x55, 0xb5, + 0xf7, 0x41, 0x43, 0x7a, 0x18, 0x88, 0xf6, 0x01, 0x64, 0x74, 0x09, 0x73, + 0x27, 0x40, 0x04, 0xf9, 0x05, 0x11, 0x12, 0xce, 0x16, 0x01, 0xff, 0x44, + 0xe0, 0x16, 0xcc, 0x2b, 0x00, 0x44, 0xff, 0x13, 0xc4, 0xf7, 0x41, 0x52, + 0x8a, 0x2d, 0xc9, 0xf7, 0x01, 0x4f, 0xf7, 0x1d, 0xaf, 0xf7, 0x41, 0x02, + 0x12, 0x15, 0x88, 0x17, 0x44, 0x6c, 0xf5, 0xd2, 0xf4, 0x01, 0x02, 0xc5, + 0x00, 0xfd, 0x06, 0xe7, 0xb5, 0xf9, 0x01, 0x09, 0x90, 0xbf, 0xc8, 0x05, + 0x43, 0xc3, 0x07, 0x4b, 0xf3, 0x01, 0xef, 0x4c, 0x26, 0x80, 0xb6, 0x05, + 0x05, 0xbc, 0xef, 0xda, 0x01, 0x08, 0xee, 0x00, 0x0c, 0x47, 0xa8, 0xdc, + 0xd0, 0xce, 0x01, 0x4a, 0xd4, 0xb8, 0x9a, 0xf3, 0x41, 0xa1, 0x87, 0x01, + 0x0b, 0x03, 0x3c, 0x77, 0x4f, 0xfa, 0x6e, 0xa6, 0x2a, 0x80, 0x6a, 0x58, + 0xf4, 0x29, 0xda, 0x22, 0x00, 0xaf, 0x1d, 0x44, 0x5a, 0x03, 0x3c, 0x00, + 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4d, 0x90, 0x85, 0x79, 0x2a, 0x00, + 0x43, 0x48, 0x0a, 0xd6, 0x22, 0x00, 0x53, 0xad, 0x4e, 0x7b, 0x2a, 0x40, + 0x02, 0x18, 0x00, 0x06, 0x4c, 0xc0, 0x9b, 0x66, 0x22, 0x40, 0x4b, 0xed, + 0x1f, 0x85, 0x2a, 0x00, 0x03, 0x7b, 0x00, 0x25, 0x4c, 0x87, 0x00, 0x76, + 0x22, 0x00, 0x50, 0x4a, 0x6a, 0x7d, 0x2a, 0xc0, 0x00, 0x0a, 0x98, 0x3d, + 0x01, 0xff, 0x45, 0x5c, 0x00, 0x81, 0x2a, 0x80, 0x06, 0x46, 0x75, 0x14, + 0x7f, 0x2a, 0x40, 0x46, 0xc7, 0x00, 0x83, 0x2a, 0x40, 0x45, 0x89, 0x0d, + 0x64, 0x22, 0x00, 0x4a, 0x0e, 0x3c, 0x72, 0x22, 0x40, 0x54, 0x93, 0x00, + 0xa8, 0x2a, 0x40, 0x45, 0x89, 0x0d, 0x68, 0x22, 0x00, 0x4a, 0x0e, 0x3c, + 0xe6, 0x22, 0x40, 0x05, 0x5d, 0x00, 0x11, 0x03, 0x1b, 0x00, 0x01, 0xff, + 0x4f, 0xf5, 0x73, 0x89, 0x2a, 0x00, 0x58, 0x94, 0x2c, 0x87, 0x2a, 0x40, + 0x64, 0x08, 0x09, 0x8b, 0x2a, 0x00, 0x64, 0x2c, 0x09, 0x91, 0x2a, 0x00, + 0x4f, 0x6f, 0x1b, 0x76, 0x29, 0x00, 0xb3, 0x01, 0xff, 0x07, 0xca, 0xd7, + 0x06, 0x73, 0x74, 0x00, 0x93, 0x2a, 0x40, 0x52, 0x81, 0x00, 0x8f, 0x2a, + 0x00, 0x48, 0x91, 0x2a, 0x8d, 0x2a, 0x40, 0x0f, 0x09, 0x35, 0xa8, 0x03, + 0x06, 0xef, 0x06, 0xe1, 0x02, 0x07, 0x13, 0x06, 0x6e, 0x0c, 0x3b, 0x17, + 0x48, 0xb3, 0x25, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0x42, 0x4e, 0x13, 0x26, + 0x1c, 0x00, 0xe5, 0x2c, 0x1c, 0x00, 0xe9, 0x27, 0x1c, 0x00, 0xef, 0x28, + 0x1c, 0x80, 0x09, 0xf5, 0x2a, 0x1c, 0xc0, 0x00, 0xf5, 0x2b, 0x1c, 0x40, + 0xef, 0x29, 0x1c, 0x40, 0x04, 0x5b, 0x03, 0x11, 0x10, 0xea, 0x6a, 0x01, + 0xff, 0x42, 0x71, 0x00, 0x25, 0x1c, 0x00, 0x42, 0xdf, 0x23, 0x24, 0x1c, + 0x40, 0x45, 0x62, 0x41, 0x37, 0x1c, 0x00, 0x43, 0x4f, 0x03, 0x36, 0x1c, + 0x40, 0x46, 0xe6, 0xd2, 0x3d, 0x1c, 0x00, 0x52, 0x57, 0x56, 0x3c, 0x1c, + 0x00, 0xb4, 0x01, 0xff, 0x45, 0x64, 0x56, 0x3b, 0x1c, 0x00, 0x45, 0xd4, + 0xf0, 0x3f, 0x1c, 0xc0, 0x00, 0x47, 0xe5, 0xd2, 0x3e, 0x1c, 0x40, 0xe1, + 0x23, 0x1c, 0x00, 0xa2, 0xde, 0x01, 0xa3, 0xd1, 0x01, 0xa4, 0xbe, 0x01, + 0xa6, 0xb1, 0x01, 0xa7, 0xa4, 0x01, 0xa8, 0x97, 0x01, 0x42, 0x78, 0x1a, + 0x08, 0x1c, 0x00, 0xab, 0x7f, 0x42, 0x74, 0x00, 0x1c, 0x1c, 0x00, 0xad, + 0x6d, 0xae, 0x5b, 0xb0, 0x49, 0x42, 0x71, 0x00, 0x1b, 0x1c, 0x00, 0xb3, + 0x37, 0xb4, 0x12, 0x42, 0x61, 0x0b, 0x1f, 0x1c, 0x00, 0x42, 0xa9, 0x01, + 0x22, 0x1c, 0x00, 0x42, 0xdf, 0x23, 0x1a, 0x1c, 0x40, 0xe1, 0x0a, 0x1c, + 0x00, 0x42, 0x22, 0x00, 0x0b, 0x1c, 0x00, 0xb3, 0x0d, 0xb4, 0x01, 0xff, + 0xe1, 0x4d, 0x1c, 0x00, 0x42, 0x22, 0x00, 0x4e, 0x1c, 0x40, 0xe1, 0x17, + 0x1c, 0x00, 0x42, 0x22, 0x00, 0x18, 0x1c, 0x40, 0xe1, 0x20, 0x1c, 0x00, + 0x42, 0x22, 0x00, 0x21, 0x1c, 0x40, 0xe1, 0x0e, 0x1c, 0x00, 0x42, 0x22, + 0x00, 0x10, 0x1c, 0x00, 0x42, 0x74, 0x00, 0x0f, 0x1c, 0x40, 0xe1, 0x0d, + 0x1c, 0x00, 0x42, 0x24, 0x02, 0x05, 0x1c, 0x00, 0x42, 0xdf, 0x23, 0x09, + 0x1c, 0x40, 0xe1, 0x15, 0x1c, 0x00, 0x42, 0x74, 0x00, 0x16, 0x1c, 0x40, + 0xe1, 0x00, 0x1c, 0x00, 0x42, 0x22, 0x00, 0x02, 0x1c, 0x00, 0x42, 0x74, + 0x00, 0x01, 0x1c, 0x40, 0xe1, 0x1d, 0x1c, 0x00, 0x42, 0x74, 0x00, 0x1e, + 0x1c, 0x40, 0xe1, 0x03, 0x1c, 0x00, 0x42, 0x74, 0x00, 0x04, 0x1c, 0x40, + 0xe1, 0x11, 0x1c, 0x00, 0x42, 0x74, 0x00, 0x12, 0x1c, 0x40, 0xe1, 0x0c, + 0x1c, 0x00, 0x42, 0x7b, 0x08, 0x4f, 0x1c, 0x00, 0x42, 0x59, 0x00, 0x19, + 0x1c, 0x40, 0xe1, 0x06, 0x1c, 0x00, 0x42, 0x22, 0x00, 0x07, 0x1c, 0x40, + 0xe1, 0x13, 0x1c, 0x00, 0x42, 0x74, 0x00, 0x14, 0x1c, 0x40, 0x45, 0x7e, + 0x0b, 0x48, 0x1c, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x49, 0x1c, 0x00, + 0x43, 0x7a, 0x0b, 0x41, 0x1c, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, + 0x1f, 0x40, 0x1c, 0x40, 0x44, 0x25, 0x01, 0x43, 0x1c, 0x00, 0x42, 0x15, + 0x02, 0x42, 0x1c, 0x40, 0x44, 0x06, 0x1f, 0x47, 0x1c, 0x00, 0x42, 0x09, + 0x24, 0x46, 0x1c, 0x40, 0x43, 0xf9, 0x05, 0x45, 0x1c, 0x00, 0x43, 0xf6, + 0x06, 0x44, 0x1c, 0x40, 0xeb, 0x2d, 0x1c, 0x80, 0x1f, 0xec, 0x2f, 0x1c, + 0x00, 0xed, 0x2e, 0x1c, 0x00, 0xee, 0x30, 0x1c, 0x80, 0x0c, 0xf0, 0x31, + 0x1c, 0x00, 0xf2, 0x32, 0x1c, 0x00, 0xf4, 0x33, 0x1c, 0x40, 0x46, 0x74, + 0xe7, 0x34, 0x1c, 0x40, 0x43, 0x1c, 0x01, 0x35, 0x1c, 0x40, 0x44, 0xf0, + 0xf7, 0x06, 0xf4, 0x41, 0x02, 0x13, 0x05, 0x74, 0x02, 0x00, 0x00, 0x64, + 0x4b, 0x16, 0x14, 0x00, 0xdb, 0x81, 0x4c, 0x18, 0x54, 0x2a, 0x40, 0x4c, + 0x87, 0x00, 0x03, 0xdb, 0x81, 0x2a, 0x49, 0xec, 0x00, 0x04, 0xdb, 0x81, + 0x1d, 0x0e, 0x6a, 0x26, 0x0d, 0x4a, 0x18, 0xa8, 0x19, 0xdb, 0xc1, 0x00, + 0x42, 0x86, 0xf9, 0x1a, 0xdb, 0x41, 0x45, 0x59, 0x03, 0xf2, 0xce, 0x01, + 0x4e, 0xe8, 0x78, 0xf3, 0xce, 0x41, 0x4d, 0xc9, 0x83, 0x06, 0xdb, 0x41, + 0x80, 0x01, 0xff, 0x4c, 0x1d, 0x3d, 0x07, 0xdb, 0x01, 0x4c, 0xca, 0x83, + 0x05, 0xdb, 0x41, 0xd1, 0xf4, 0xce, 0x01, 0xd2, 0xf5, 0xce, 0x41, 0x06, + 0x50, 0x00, 0x01, 0xff, 0x50, 0x1a, 0x65, 0x01, 0xdb, 0x01, 0x47, 0xcf, + 0x0a, 0x02, 0xdb, 0x41, 0x4b, 0x17, 0xa8, 0x1b, 0xdb, 0x01, 0x4b, 0x90, + 0x34, 0xf1, 0xce, 0x41, 0x49, 0x05, 0xc0, 0x17, 0xdb, 0x01, 0x48, 0x57, + 0xce, 0x11, 0xdb, 0xc1, 0x00, 0x52, 0xd7, 0x1f, 0x12, 0xdb, 0x01, 0x42, + 0x86, 0xf9, 0x13, 0xdb, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x48, 0x9a, 0x24, + 0x14, 0xdb, 0x01, 0x10, 0xe5, 0x08, 0x01, 0xff, 0x50, 0xba, 0x63, 0x16, + 0xdb, 0x01, 0x43, 0x16, 0x00, 0x15, 0xdb, 0x41, 0x80, 0xb5, 0x08, 0x8d, + 0xd2, 0x06, 0x06, 0xa9, 0x01, 0x01, 0xff, 0x45, 0xce, 0x00, 0x90, 0x21, + 0x80, 0xb7, 0x04, 0xa2, 0x98, 0x04, 0x50, 0x5a, 0x64, 0x3c, 0xf8, 0x01, + 0xa4, 0xd8, 0x03, 0xa6, 0xc9, 0x03, 0xa8, 0xc8, 0x02, 0x57, 0x0a, 0x31, + 0xa4, 0xf8, 0x01, 0x51, 0x8b, 0x5f, 0xfd, 0x21, 0x00, 0xb0, 0xad, 0x02, + 0x4f, 0x4e, 0x75, 0x45, 0x2b, 0x00, 0xb2, 0x98, 0x02, 0xb3, 0xfe, 0x01, + 0xb4, 0x16, 0xb7, 0x01, 0xff, 0x49, 0xfa, 0xbb, 0x9c, 0x21, 0x00, 0x4a, + 0xf9, 0x10, 0xe6, 0x21, 0xc0, 0x00, 0x5a, 0x03, 0x20, 0x94, 0xf8, 0x41, + 0x49, 0x63, 0xbf, 0xf9, 0xfa, 0x01, 0x55, 0x75, 0x3f, 0xa2, 0xf8, 0x01, + 0x02, 0x0d, 0x00, 0x51, 0x02, 0x15, 0x02, 0x01, 0xff, 0x4d, 0x6e, 0x83, + 0x9e, 0x21, 0x00, 0x08, 0x09, 0x02, 0x01, 0xff, 0x06, 0xce, 0x00, 0x06, + 0x51, 0x45, 0x61, 0x37, 0x2b, 0x40, 0x48, 0xdf, 0xb9, 0x36, 0x2b, 0x00, + 0x05, 0x51, 0x00, 0x01, 0xff, 0x56, 0x61, 0x35, 0x35, 0x2b, 0x00, 0xb4, + 0x06, 0x4f, 0x68, 0x35, 0x34, 0x2b, 0x40, 0x43, 0x7a, 0x18, 0x3b, 0x2b, + 0x80, 0x06, 0x52, 0x2f, 0x06, 0xec, 0x2b, 0x40, 0x06, 0x50, 0x00, 0x01, + 0xff, 0x56, 0x61, 0x35, 0x3d, 0x2b, 0x00, 0x4f, 0x68, 0x35, 0x3c, 0x2b, + 0x40, 0x05, 0x04, 0x02, 0x11, 0x04, 0x8f, 0x1e, 0x01, 0xff, 0x45, 0xce, + 0x00, 0xda, 0x21, 0x00, 0x4a, 0x4c, 0x61, 0x0e, 0x29, 0x40, 0x4a, 0xe0, + 0x01, 0x90, 0xf8, 0x01, 0x08, 0x09, 0x02, 0x01, 0xff, 0x45, 0xce, 0x00, + 0x60, 0x2b, 0x80, 0x0c, 0x4c, 0x78, 0x92, 0x6a, 0x2b, 0x00, 0x4d, 0xcf, + 0x8b, 0x84, 0x2b, 0x40, 0x80, 0x01, 0xff, 0x65, 0x51, 0x08, 0x80, 0x2b, + 0x00, 0x46, 0x9f, 0x15, 0x70, 0x2b, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, + 0x4a, 0xb2, 0xad, 0x28, 0xf8, 0x01, 0x07, 0x3b, 0x01, 0x28, 0x4b, 0x7f, + 0x6b, 0x2c, 0xf8, 0x01, 0x09, 0x6d, 0xc1, 0x12, 0x4c, 0xbc, 0x96, 0x24, + 0xf8, 0x01, 0x4c, 0x28, 0x97, 0x20, 0xf8, 0x01, 0x50, 0x7a, 0x6b, 0x30, + 0xf8, 0x41, 0x49, 0xa5, 0x01, 0xa6, 0x2b, 0x00, 0x47, 0x50, 0x02, 0xa4, + 0x2b, 0x40, 0x51, 0x47, 0x05, 0x7a, 0x2b, 0x00, 0x4f, 0x68, 0x35, 0x7a, + 0x2b, 0x40, 0x4f, 0xfb, 0x69, 0x50, 0xf8, 0x01, 0x02, 0x7c, 0x00, 0x01, + 0xff, 0x4a, 0xda, 0x98, 0x38, 0xf8, 0x01, 0x4b, 0x5b, 0x80, 0xdc, 0x21, + 0x40, 0x57, 0x97, 0x30, 0xa6, 0xf8, 0x01, 0x45, 0x24, 0xb4, 0x6c, 0xf6, + 0x41, 0x4c, 0xd0, 0x8b, 0xc7, 0x21, 0x00, 0x4b, 0xcf, 0xa9, 0xf7, 0xfa, + 0x41, 0xa1, 0x11, 0x05, 0x3c, 0x16, 0x01, 0xff, 0x45, 0xce, 0x00, 0x44, + 0xf8, 0x01, 0x50, 0x5a, 0x64, 0x40, 0xf8, 0x41, 0x42, 0x1b, 0x00, 0xf2, + 0xfa, 0x01, 0x06, 0xcb, 0x02, 0x01, 0xff, 0x57, 0xab, 0x31, 0xcb, 0x21, + 0x00, 0x0a, 0x98, 0x05, 0x01, 0xff, 0x04, 0xa5, 0x01, 0x31, 0x02, 0x50, + 0x02, 0x01, 0xff, 0x80, 0x06, 0x45, 0xa9, 0x01, 0xbc, 0x21, 0x40, 0x06, + 0x5c, 0x00, 0x0c, 0x48, 0xdf, 0xb9, 0x5a, 0x29, 0x00, 0x46, 0x9f, 0x15, + 0x52, 0x29, 0x40, 0xac, 0x06, 0x5f, 0x5a, 0x12, 0x66, 0x29, 0x40, 0x5f, + 0x48, 0x06, 0x62, 0x29, 0x00, 0x48, 0x6b, 0x6e, 0x6a, 0x29, 0x40, 0x80, + 0x06, 0x45, 0xa9, 0x01, 0xbd, 0x21, 0x40, 0x67, 0x7f, 0x05, 0x67, 0x29, + 0x00, 0x4f, 0x64, 0x6e, 0x6b, 0x29, 0x00, 0x48, 0xdf, 0xb9, 0x5e, 0x29, + 0x00, 0x46, 0x9f, 0x15, 0x56, 0x29, 0x40, 0x50, 0x7e, 0x5c, 0x34, 0xf8, + 0x01, 0x60, 0xe3, 0x10, 0xaa, 0xf8, 0x41, 0x4b, 0x79, 0x92, 0xe0, 0x21, + 0x00, 0x06, 0x3c, 0x01, 0x01, 0xff, 0x45, 0xce, 0x00, 0xd0, 0x21, 0x80, + 0x06, 0x4a, 0x4c, 0x61, 0x0c, 0x29, 0x40, 0x80, 0x06, 0x45, 0x78, 0x18, + 0x1b, 0x29, 0x40, 0x48, 0xdf, 0xb9, 0x06, 0x29, 0x00, 0x05, 0x51, 0x00, + 0x01, 0xff, 0x46, 0x52, 0x05, 0xcd, 0x21, 0x00, 0x4f, 0x68, 0x35, 0x02, + 0x29, 0x40, 0x5f, 0x62, 0x11, 0xa8, 0xf8, 0x01, 0x05, 0x0d, 0x03, 0x06, + 0x58, 0x1c, 0x2c, 0xa0, 0xf8, 0x41, 0x45, 0xce, 0x00, 0x05, 0x2b, 0x00, + 0x53, 0x0a, 0x4b, 0x88, 0x2b, 0x40, 0x80, 0x06, 0x45, 0x78, 0x18, 0x19, + 0x29, 0x40, 0xa1, 0xd7, 0x01, 0x05, 0xaa, 0x05, 0xbf, 0x01, 0x55, 0x89, + 0x15, 0xc6, 0x21, 0x00, 0xb4, 0x8a, 0x01, 0x05, 0x51, 0x00, 0x01, 0xff, + 0x02, 0x3b, 0x01, 0x75, 0x55, 0xd5, 0x01, 0x14, 0xf8, 0x01, 0x44, 0x5b, + 0x0f, 0xa9, 0x21, 0x00, 0xac, 0x5b, 0x59, 0x51, 0x26, 0x04, 0xf8, 0x01, + 0x4c, 0xa0, 0x97, 0x98, 0xf8, 0x01, 0x4a, 0x1e, 0xb5, 0x46, 0x29, 0x00, + 0xb3, 0x31, 0xb4, 0x06, 0x4f, 0x68, 0x35, 0xf7, 0x21, 0x40, 0x43, 0x7a, + 0x18, 0xa2, 0x21, 0x80, 0x11, 0x03, 0xb6, 0x0c, 0x01, 0xff, 0x49, 0xa5, + 0x01, 0x10, 0x2b, 0x00, 0x47, 0x50, 0x02, 0x11, 0x2b, 0x40, 0x06, 0x50, + 0x00, 0x01, 0xff, 0x56, 0x61, 0x35, 0x3a, 0x2b, 0x00, 0x4f, 0x68, 0x35, + 0x39, 0x2b, 0x40, 0x05, 0x5e, 0x07, 0x06, 0x45, 0x53, 0x05, 0x9a, 0x21, + 0x40, 0x55, 0xd5, 0x01, 0x10, 0xf8, 0x01, 0x52, 0x2e, 0x06, 0x00, 0xf8, + 0x41, 0x57, 0x15, 0x2b, 0x08, 0xf8, 0x01, 0x43, 0x98, 0x08, 0xab, 0x21, + 0x40, 0x49, 0xe4, 0xc5, 0x38, 0x2b, 0x00, 0x54, 0x63, 0x35, 0xfa, 0x21, + 0x40, 0x07, 0xb4, 0x2c, 0x18, 0x03, 0xa0, 0x15, 0x01, 0xff, 0x42, 0x17, + 0x00, 0xe4, 0x21, 0x80, 0x06, 0x4c, 0xeb, 0x59, 0x1d, 0x29, 0x40, 0x5d, + 0x88, 0x15, 0xb9, 0x21, 0x40, 0x49, 0xec, 0x00, 0x77, 0x29, 0x00, 0x46, + 0x67, 0x13, 0x7a, 0x29, 0x00, 0xf8, 0x3e, 0x2b, 0x40, 0x43, 0x16, 0x00, + 0xa4, 0x21, 0x80, 0x06, 0x4f, 0xa0, 0x0c, 0xc0, 0xf8, 0x41, 0x51, 0xe6, + 0x59, 0x1f, 0x29, 0x40, 0x05, 0x5d, 0x00, 0x06, 0x63, 0x67, 0x0b, 0xb5, + 0xfb, 0x41, 0x4f, 0xce, 0x6d, 0x4a, 0x2b, 0x00, 0x08, 0xa8, 0x75, 0x0c, + 0x56, 0x3f, 0x39, 0x43, 0x29, 0x00, 0x4e, 0x9b, 0x40, 0x73, 0x29, 0x40, + 0x4f, 0xce, 0x6d, 0x42, 0x2b, 0x00, 0x4e, 0x9b, 0x40, 0x4b, 0x2b, 0x40, + 0x07, 0xf6, 0x2f, 0x9c, 0x01, 0x5b, 0xa7, 0x1c, 0xe6, 0x26, 0x00, 0x09, + 0x9c, 0x01, 0x2b, 0xb3, 0x1d, 0x09, 0x74, 0x46, 0x01, 0xff, 0x49, 0xf2, + 0xbd, 0x2a, 0x20, 0x00, 0x47, 0x5f, 0x03, 0x66, 0x20, 0x00, 0x44, 0xb9, + 0x00, 0x0e, 0x20, 0x00, 0x48, 0x67, 0xcf, 0x2d, 0x20, 0x40, 0x5c, 0xe4, + 0x18, 0xaa, 0x27, 0x00, 0x5b, 0xdd, 0x1c, 0x39, 0x29, 0x40, 0xa1, 0x53, + 0x54, 0x8b, 0x43, 0xfc, 0x29, 0x00, 0xa4, 0x3f, 0x4b, 0xc9, 0xa0, 0x78, + 0xcc, 0x01, 0x50, 0xea, 0x67, 0x0d, 0xf5, 0x01, 0xb2, 0x0c, 0x4c, 0x70, + 0x9a, 0x02, 0xcc, 0x01, 0x44, 0x24, 0xcd, 0x9e, 0xcc, 0x41, 0x49, 0x22, + 0xbb, 0x97, 0xcc, 0x01, 0x44, 0x42, 0xb2, 0x65, 0xcc, 0x01, 0xaf, 0x01, + 0xff, 0x05, 0x8b, 0x09, 0x06, 0x50, 0xaa, 0x67, 0xa2, 0xcc, 0x41, 0x47, + 0x5b, 0xd5, 0xa0, 0xcc, 0x01, 0x44, 0x34, 0x22, 0x56, 0xcc, 0x41, 0x44, + 0x80, 0xf6, 0x0e, 0xcc, 0x01, 0x5a, 0xdb, 0x22, 0xab, 0x00, 0x40, 0x47, + 0xde, 0x35, 0xf9, 0xcd, 0x01, 0x4c, 0xee, 0x0f, 0x29, 0x23, 0x00, 0x4a, + 0xa8, 0xb7, 0x60, 0xcc, 0x41, 0x56, 0xb1, 0x34, 0x8e, 0x05, 0x00, 0x48, + 0x9f, 0xc9, 0x48, 0xcc, 0x01, 0x03, 0xab, 0x5d, 0x20, 0xb3, 0x01, 0xff, + 0x0f, 0xfe, 0x2f, 0x0d, 0x4a, 0xca, 0xb8, 0xd6, 0x0f, 0xc0, 0x00, 0x4a, + 0xa7, 0x5b, 0xd8, 0x0f, 0x40, 0x4c, 0x24, 0x92, 0x74, 0xcc, 0x01, 0x4a, + 0xda, 0x2a, 0x70, 0xcc, 0x41, 0xe8, 0x92, 0xcc, 0x81, 0x04, 0xf4, 0x1b, + 0xf9, 0x41, 0x50, 0xd4, 0x2a, 0x94, 0xcc, 0x41, 0xa1, 0xce, 0x06, 0xa2, + 0x95, 0x06, 0xa3, 0xe4, 0x05, 0x02, 0x3b, 0x01, 0xbc, 0x05, 0xa6, 0xa5, + 0x05, 0x02, 0x22, 0x00, 0x8c, 0x04, 0x15, 0x8e, 0x3e, 0xfb, 0x03, 0xac, + 0xec, 0x03, 0x48, 0xe6, 0x7a, 0xdc, 0x27, 0x00, 0x60, 0x83, 0x10, 0xc9, + 0x22, 0x00, 0xaf, 0xc1, 0x03, 0x4b, 0xfb, 0x22, 0x28, 0x00, 0x80, 0x9e, + 0x03, 0xb2, 0xaa, 0x02, 0xb3, 0xb0, 0x01, 0xb4, 0x49, 0x0a, 0x32, 0x00, + 0x39, 0xb7, 0x01, 0xff, 0x05, 0xae, 0x02, 0x0c, 0x4b, 0xf1, 0x9b, 0xd8, + 0x29, 0x00, 0x4b, 0x67, 0xa7, 0x8e, 0xf5, 0x41, 0xa3, 0x18, 0x52, 0xda, + 0x28, 0x16, 0x30, 0x00, 0x4b, 0xfb, 0x22, 0x85, 0x29, 0x00, 0x4e, 0x36, + 0x28, 0x1a, 0x30, 0x00, 0x56, 0x79, 0x09, 0x18, 0x30, 0x40, 0x4d, 0x68, + 0x6c, 0x0e, 0x30, 0x00, 0x4c, 0xdf, 0x0b, 0x83, 0x29, 0x40, 0x4d, 0xa6, + 0x84, 0x20, 0x2e, 0x00, 0x47, 0x4e, 0xda, 0xb8, 0x23, 0x40, 0x43, 0x0e, + 0x03, 0xa3, 0x22, 0x00, 0xa8, 0x25, 0x55, 0x7a, 0x09, 0x14, 0x30, 0x00, + 0xb2, 0x06, 0x4f, 0x1e, 0x78, 0xce, 0xfb, 0x41, 0x53, 0x4c, 0x4a, 0x09, + 0x2e, 0x00, 0x04, 0x1b, 0x01, 0x01, 0xff, 0x56, 0x03, 0x37, 0xcf, 0x29, + 0x00, 0x56, 0x5c, 0x1e, 0x6c, 0xfb, 0x41, 0x04, 0xcc, 0x8d, 0x28, 0x4c, + 0x78, 0x98, 0xec, 0xf5, 0x01, 0x04, 0x26, 0x01, 0x01, 0xff, 0x4d, 0x5e, + 0x4f, 0x8d, 0x25, 0x00, 0x09, 0x2a, 0x01, 0x01, 0xff, 0x45, 0x33, 0x01, + 0x8a, 0x25, 0x00, 0x57, 0x21, 0x31, 0xa2, 0xce, 0x01, 0x57, 0x60, 0x33, + 0xa9, 0xce, 0x41, 0x48, 0xaf, 0xcc, 0x0b, 0xcc, 0x01, 0x5a, 0xab, 0x23, + 0xc1, 0xfb, 0x41, 0x55, 0xf2, 0x3a, 0xc5, 0x27, 0x00, 0xa5, 0x63, 0xa9, + 0x55, 0x4c, 0x4b, 0x80, 0xe8, 0xf5, 0x01, 0x4d, 0x37, 0x28, 0x5b, 0x00, + 0x80, 0x06, 0x53, 0x19, 0x28, 0x02, 0x2e, 0x40, 0x80, 0x01, 0xff, 0x49, + 0x42, 0x5b, 0xa2, 0x23, 0x00, 0x4c, 0x38, 0x96, 0xa3, 0x23, 0x00, 0x4c, + 0x84, 0x9b, 0xa1, 0x23, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4d, 0x46, + 0x86, 0x57, 0x2e, 0x00, 0x45, 0xae, 0x84, 0x45, 0x20, 0x00, 0x46, 0x52, + 0x05, 0x55, 0x2e, 0x00, 0x08, 0x47, 0xd1, 0x06, 0x48, 0x64, 0x5c, 0x8b, + 0x29, 0x40, 0x4d, 0x4f, 0x85, 0x8f, 0x29, 0x00, 0x4a, 0xb2, 0xb7, 0x8d, + 0x29, 0x40, 0x50, 0xaa, 0x64, 0x26, 0x2e, 0x00, 0x53, 0x03, 0x0c, 0x18, + 0x20, 0x40, 0x50, 0x93, 0x10, 0xcb, 0x22, 0x00, 0x51, 0x5a, 0x4f, 0x89, + 0x25, 0x40, 0x56, 0x1f, 0x32, 0x0c, 0x2e, 0x00, 0x05, 0xc9, 0x00, 0x01, + 0xff, 0x45, 0xce, 0x00, 0x94, 0x21, 0x80, 0x3f, 0x4b, 0xae, 0x9e, 0x0c, + 0x2b, 0x00, 0x4c, 0xd8, 0x92, 0xd4, 0x21, 0x80, 0x21, 0x51, 0x8b, 0x5f, + 0xff, 0x21, 0x00, 0x50, 0xfa, 0x69, 0x58, 0xf8, 0x01, 0x55, 0x01, 0x02, + 0x64, 0x2b, 0x00, 0xb7, 0x01, 0xff, 0x49, 0xfa, 0xbb, 0xad, 0x21, 0x00, + 0x4a, 0xf9, 0x10, 0x04, 0x2b, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x46, + 0x52, 0x05, 0xce, 0x21, 0x00, 0x4f, 0x68, 0x35, 0x04, 0x29, 0x40, 0x80, + 0x01, 0xff, 0x54, 0x4f, 0x48, 0x48, 0x29, 0x00, 0x05, 0x51, 0x00, 0x01, + 0xff, 0x56, 0x61, 0x35, 0xfc, 0x21, 0x00, 0x46, 0x52, 0x05, 0xae, 0x21, + 0x00, 0x4f, 0x68, 0x35, 0xf9, 0x21, 0x40, 0x80, 0x01, 0xff, 0x49, 0x42, + 0x5b, 0x9c, 0x23, 0x00, 0x4a, 0xee, 0xb2, 0x9d, 0x23, 0x00, 0x4a, 0x7a, + 0xb8, 0x9b, 0x23, 0x00, 0x50, 0xfa, 0x6b, 0x62, 0x2e, 0x40, 0x03, 0xef, + 0x07, 0x06, 0x49, 0xed, 0xb4, 0xd5, 0x27, 0x40, 0x4c, 0x7e, 0x0b, 0x8f, + 0x25, 0x00, 0x4d, 0x65, 0x1e, 0x8e, 0x25, 0x00, 0x4b, 0xb1, 0xa8, 0xcf, + 0xfb, 0x41, 0x55, 0x88, 0x37, 0x1c, 0x2e, 0x00, 0x46, 0xf0, 0xe6, 0xc5, + 0xf6, 0x41, 0x4c, 0x0c, 0x03, 0xeb, 0xfb, 0x01, 0x4c, 0x00, 0x12, 0xe3, + 0xfb, 0x41, 0x03, 0x24, 0x00, 0x06, 0x55, 0x36, 0x3f, 0x7b, 0xf5, 0x41, + 0x02, 0x33, 0x01, 0x70, 0x46, 0x12, 0x03, 0x07, 0xf9, 0x81, 0x49, 0xa6, + 0x3b, 0x65, 0xe2, 0x07, 0x10, 0xce, 0x01, 0x69, 0x3c, 0x04, 0x94, 0xfb, + 0x01, 0x57, 0x21, 0x31, 0xa3, 0xce, 0x01, 0x4c, 0x44, 0x04, 0x8c, 0xfb, + 0x01, 0x4b, 0x9e, 0xa7, 0xb2, 0xfb, 0x01, 0x56, 0x81, 0x39, 0x0d, 0xce, + 0x01, 0x57, 0x60, 0x33, 0xa8, 0xce, 0x01, 0x06, 0xad, 0x02, 0x01, 0xff, + 0x46, 0x12, 0x03, 0xf4, 0xf7, 0x01, 0x47, 0xf3, 0x69, 0x0b, 0xce, 0x41, + 0x4c, 0x68, 0x96, 0xa4, 0xcc, 0x01, 0x45, 0xe0, 0x68, 0xb9, 0xfb, 0x41, + 0x06, 0x50, 0x00, 0x01, 0xff, 0x43, 0x48, 0x0a, 0x06, 0xf9, 0x01, 0x49, + 0x08, 0x49, 0x03, 0xf9, 0x01, 0xb4, 0x01, 0xff, 0x49, 0xda, 0x10, 0x04, + 0xf9, 0x01, 0x47, 0x45, 0x0a, 0x05, 0xf9, 0x41, 0x04, 0x0e, 0x03, 0x06, + 0x43, 0x35, 0x01, 0x8c, 0x25, 0x40, 0x46, 0x12, 0x03, 0xd6, 0x25, 0x00, + 0x44, 0xff, 0x13, 0xe8, 0x2b, 0x40, 0xa9, 0x06, 0x44, 0xae, 0x25, 0x0a, + 0x23, 0x40, 0x47, 0x96, 0xbe, 0x7c, 0x29, 0x00, 0x50, 0x19, 0x54, 0x8b, + 0x25, 0x40, 0x59, 0x13, 0x28, 0x04, 0x2e, 0x00, 0x05, 0x3d, 0x01, 0x01, + 0xff, 0x4d, 0xed, 0x0f, 0x0a, 0x30, 0x00, 0x4b, 0xfb, 0x22, 0x28, 0x2e, + 0x00, 0x4e, 0x19, 0x05, 0x1c, 0x20, 0x00, 0x4c, 0xf0, 0x9b, 0xda, 0x29, + 0x40, 0x46, 0x40, 0xca, 0x08, 0x23, 0x00, 0x4b, 0x02, 0xa4, 0xdc, 0x26, + 0x00, 0x4d, 0x68, 0x6c, 0x0c, 0x30, 0x00, 0x4c, 0xdf, 0x0b, 0x7b, 0x00, + 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0xee, 0xb2, 0xa9, 0x23, 0x00, 0x4c, + 0xd4, 0x96, 0xa8, 0x23, 0x00, 0x4a, 0x7a, 0xb8, 0xa7, 0x23, 0x40, 0x04, + 0x9e, 0x05, 0x11, 0x05, 0x0d, 0x03, 0x01, 0xff, 0x52, 0xda, 0x28, 0x10, + 0x30, 0x00, 0x56, 0x79, 0x09, 0x97, 0x29, 0x40, 0x10, 0x3a, 0x65, 0x11, + 0x0e, 0xfc, 0x81, 0x01, 0xff, 0x4c, 0xf0, 0x92, 0x4a, 0x29, 0x00, 0x4a, + 0x5c, 0xb8, 0x4e, 0x29, 0x40, 0x4c, 0xf0, 0x92, 0x50, 0x29, 0x00, 0x4a, + 0x5c, 0xb8, 0x4b, 0x29, 0x40, 0xae, 0x1a, 0xb2, 0x01, 0xff, 0x53, 0x7a, + 0x1e, 0x93, 0x29, 0x00, 0x09, 0x25, 0x06, 0x01, 0xff, 0x4c, 0x00, 0x92, + 0x32, 0x2b, 0x00, 0x4c, 0x0d, 0x16, 0x30, 0x2b, 0x40, 0x02, 0x06, 0x00, + 0x16, 0xa7, 0x01, 0xff, 0x49, 0x16, 0xbe, 0xee, 0xf5, 0x01, 0x4a, 0xf0, + 0x0f, 0x08, 0x30, 0xc0, 0x00, 0x49, 0x98, 0x3d, 0x91, 0x29, 0x40, 0x06, + 0x13, 0x01, 0x31, 0x06, 0xc8, 0x00, 0x18, 0x06, 0x6d, 0x02, 0x01, 0xff, + 0x69, 0x13, 0x04, 0x6b, 0xfb, 0x01, 0x50, 0x7a, 0x0b, 0x7d, 0xfb, 0xc1, + 0x00, 0x5e, 0xf5, 0x12, 0x8e, 0xcc, 0x41, 0x50, 0x0a, 0x65, 0xda, 0x27, + 0x00, 0xb4, 0x01, 0xff, 0x43, 0x0e, 0x03, 0xdb, 0x27, 0x00, 0x54, 0xc6, + 0x40, 0x9b, 0xfb, 0x41, 0x69, 0x13, 0x04, 0x69, 0xfb, 0x01, 0x50, 0x7a, + 0x0b, 0x7c, 0xfb, 0x41, 0x53, 0xa1, 0x49, 0x43, 0xf3, 0x01, 0x49, 0x1c, + 0xc1, 0xbe, 0xfa, 0x01, 0x47, 0xa4, 0xdd, 0x6c, 0xf9, 0x41, 0xa2, 0xcc, + 0x51, 0x55, 0x18, 0x3c, 0x4d, 0xf9, 0x01, 0xa4, 0xb7, 0x51, 0xae, 0xa8, + 0x51, 0x02, 0x7b, 0x02, 0xcc, 0x4c, 0xb2, 0xc9, 0x47, 0x4f, 0x6b, 0x76, + 0x3e, 0x26, 0x80, 0xb2, 0x47, 0x04, 0x07, 0x06, 0x01, 0xff, 0xa3, 0xaa, + 0x2d, 0x12, 0xcf, 0x53, 0xff, 0x2c, 0x07, 0x13, 0x06, 0xa7, 0x29, 0xb3, + 0x01, 0xff, 0x05, 0x5e, 0x07, 0x62, 0x16, 0xc3, 0x39, 0x01, 0xff, 0xe1, + 0x90, 0x20, 0x00, 0xe5, 0x91, 0x20, 0x00, 0x45, 0xad, 0x5a, 0xd0, 0xdf, + 0x01, 0xe8, 0x95, 0x20, 0x00, 0xe9, 0x62, 0x1d, 0x00, 0xea, 0x7c, 0x2c, + 0x00, 0xeb, 0x96, 0x20, 0x00, 0xec, 0x97, 0x20, 0x00, 0xed, 0x98, 0x20, + 0x00, 0xee, 0x99, 0x20, 0x00, 0xef, 0x92, 0x20, 0x00, 0xf0, 0x9a, 0x20, + 0x00, 0xf2, 0x63, 0x1d, 0x00, 0xf3, 0x9b, 0x20, 0x80, 0x1c, 0xf4, 0x9c, + 0x20, 0x00, 0xf5, 0x64, 0x1d, 0x00, 0xf6, 0x65, 0x1d, 0x00, 0xf7, 0x9d, + 0x20, 0x00, 0xf8, 0x93, 0x20, 0x00, 0xf9, 0x9e, 0x20, 0x00, 0xfa, 0x9f, + 0x20, 0x40, 0x44, 0x82, 0x7f, 0x94, 0x20, 0x40, 0x0f, 0x0b, 0x06, 0xad, + 0x28, 0xac, 0x01, 0xff, 0x06, 0x14, 0x06, 0x3c, 0x08, 0xde, 0x11, 0x01, + 0xff, 0xa6, 0x20, 0x42, 0x0e, 0xcd, 0x33, 0x01, 0x00, 0x07, 0xe6, 0x11, + 0x0c, 0x42, 0xce, 0x53, 0x53, 0x01, 0x00, 0x42, 0x60, 0x01, 0x06, 0xfb, + 0x40, 0xf4, 0x05, 0xfb, 0x00, 0x50, 0xed, 0x11, 0x95, 0xdf, 0x41, 0xe6, + 0x00, 0xfb, 0x80, 0x08, 0xe9, 0x01, 0xfb, 0x00, 0xec, 0x02, 0xfb, 0x40, + 0xe9, 0x03, 0xfb, 0x00, 0xec, 0x04, 0xfb, 0x40, 0xe1, 0x61, 0x00, 0x80, + 0xad, 0x25, 0xe2, 0x62, 0x00, 0x80, 0xce, 0x23, 0xe3, 0x63, 0x00, 0x80, + 0x87, 0x22, 0xe4, 0x64, 0x00, 0x80, 0xcc, 0x1f, 0xe5, 0x65, 0x00, 0x80, + 0xda, 0x1c, 0xe6, 0x66, 0x00, 0x80, 0xa5, 0x1c, 0xe7, 0x67, 0x00, 0x80, + 0xa6, 0x1b, 0xe8, 0x68, 0x00, 0x80, 0xa7, 0x1a, 0xe9, 0x69, 0x00, 0x80, + 0xd5, 0x18, 0xea, 0x6a, 0x00, 0x80, 0xb0, 0x18, 0xeb, 0x6b, 0x00, 0x80, + 0xd3, 0x17, 0xec, 0x6c, 0x00, 0x80, 0xb0, 0x15, 0xed, 0x6d, 0x00, 0x80, + 0xd9, 0x14, 0xee, 0x6e, 0x00, 0x80, 0xbb, 0x13, 0xef, 0x6f, 0x00, 0x80, + 0xb0, 0x10, 0xf0, 0x70, 0x00, 0x80, 0xbb, 0x0f, 0xf1, 0x71, 0x00, 0x80, + 0x8c, 0x0f, 0xf2, 0x72, 0x00, 0x80, 0xd9, 0x0c, 0xf3, 0x73, 0x00, 0x80, + 0xa2, 0x0a, 0xf4, 0x74, 0x00, 0x80, 0x88, 0x06, 0xf5, 0x75, 0x00, 0x80, + 0xca, 0x03, 0xf6, 0x76, 0x00, 0x80, 0xe7, 0x02, 0xf7, 0x77, 0x00, 0x80, + 0xa0, 0x02, 0xf8, 0x78, 0x00, 0x80, 0xe1, 0x01, 0xf9, 0x79, 0x00, 0x80, + 0x6a, 0xfa, 0x7a, 0x00, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, + 0x1c, 0x3b, 0x7a, 0x01, 0x00, 0xa3, 0x46, 0xa4, 0x2d, 0x44, 0x5b, 0x0f, + 0x25, 0x02, 0x00, 0x4a, 0xc1, 0x70, 0x95, 0x1e, 0x00, 0x4c, 0x6a, 0x24, + 0x76, 0x1d, 0x00, 0x4c, 0x47, 0x3d, 0x8e, 0x1d, 0x00, 0x4e, 0x51, 0x0f, + 0x90, 0x02, 0x00, 0xb3, 0x01, 0xff, 0x45, 0x53, 0x05, 0xb6, 0x01, 0x00, + 0x49, 0x0d, 0xc7, 0x40, 0x02, 0x40, 0x48, 0xf3, 0x11, 0x6c, 0x2c, 0x00, + 0x03, 0x70, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x7c, 0x01, 0x00, 0x45, + 0x20, 0x07, 0x93, 0x1e, 0x40, 0x44, 0x0b, 0x70, 0x7e, 0x01, 0x00, 0x49, + 0xd0, 0x04, 0x91, 0x1e, 0x00, 0x43, 0xdf, 0x0b, 0x91, 0x02, 0x40, 0x06, + 0x50, 0x00, 0x06, 0x43, 0x81, 0x54, 0x1d, 0x02, 0x40, 0x45, 0x1c, 0x3b, + 0xfd, 0x00, 0x00, 0x4a, 0xcf, 0x04, 0x77, 0x01, 0x00, 0xa4, 0x43, 0x45, + 0x51, 0x24, 0xf3, 0x1e, 0x00, 0x44, 0x5b, 0x0f, 0xb4, 0x01, 0x80, 0x30, + 0x02, 0x13, 0x01, 0x20, 0x46, 0xd1, 0x73, 0x33, 0x02, 0x00, 0x4a, 0xfa, + 0xb5, 0x99, 0x1e, 0x00, 0xb3, 0x06, 0x45, 0x71, 0x24, 0xf9, 0x1e, 0x40, + 0x4e, 0xba, 0x3a, 0x5a, 0xab, 0x00, 0x45, 0x53, 0x05, 0x4f, 0x02, 0x40, + 0x42, 0x1f, 0x00, 0xff, 0x1e, 0x00, 0x48, 0xe6, 0xb2, 0x55, 0xdf, 0x41, + 0x46, 0x5b, 0x00, 0xf7, 0x1e, 0x40, 0x48, 0xf4, 0x24, 0xff, 0x00, 0x00, + 0x03, 0x70, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x8f, 0x1e, 0x00, 0x45, + 0x20, 0x07, 0xf5, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0xa4, 0x26, + 0x02, 0x13, 0x01, 0x06, 0x4c, 0x47, 0x3d, 0x8d, 0x1d, 0x40, 0x4b, 0x36, + 0xa5, 0x57, 0xab, 0x80, 0x06, 0x4c, 0x7f, 0x52, 0x56, 0xab, 0x40, 0x80, + 0x01, 0xff, 0x52, 0x79, 0x52, 0x58, 0xab, 0x00, 0x4a, 0xf1, 0x2a, 0x59, + 0xab, 0x40, 0x48, 0xf4, 0x24, 0x8d, 0x1e, 0x00, 0x48, 0x78, 0x1f, 0x8b, + 0x1e, 0x40, 0x06, 0x50, 0x00, 0x06, 0x49, 0xdb, 0x95, 0x65, 0xdf, 0x41, + 0x45, 0x1c, 0x3b, 0x83, 0x1e, 0x00, 0x4a, 0xcf, 0x04, 0x75, 0x01, 0x00, + 0xa4, 0x12, 0x45, 0x51, 0x24, 0x81, 0x1e, 0x00, 0x44, 0x5b, 0x0f, 0x73, + 0x2c, 0x00, 0x4a, 0xfa, 0xb5, 0x98, 0x1e, 0x40, 0x48, 0xf4, 0x24, 0x85, + 0x1e, 0x00, 0x03, 0x70, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x87, 0x1e, + 0x00, 0x45, 0x20, 0x07, 0x89, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x26, 0x43, + 0x40, 0x05, 0x69, 0xa7, 0x00, 0x4b, 0xe4, 0xa2, 0x63, 0xa7, 0x00, 0x07, + 0xbb, 0xd9, 0x04, 0xf9, 0x61, 0xa7, 0x40, 0x42, 0x42, 0x10, 0x9b, 0xa7, + 0x00, 0x42, 0xce, 0x53, 0x9d, 0xa7, 0x00, 0x42, 0x5c, 0x0a, 0x9f, 0xa7, + 0x40, 0x44, 0xde, 0x0b, 0x74, 0x2c, 0x00, 0xa4, 0x1f, 0x44, 0x5b, 0x0f, + 0x8b, 0x02, 0x80, 0x12, 0x4c, 0x47, 0x3d, 0x8c, 0x1d, 0x00, 0x4a, 0xe6, + 0xb5, 0x71, 0x2c, 0x00, 0x45, 0x71, 0x24, 0x7d, 0x1e, 0x40, 0x51, 0x80, + 0x59, 0x39, 0xdf, 0x41, 0x4e, 0xb1, 0x41, 0x5f, 0xa7, 0x00, 0x48, 0x6e, + 0x13, 0x7f, 0x1e, 0x40, 0x80, 0x1d, 0xe5, 0x6b, 0x1d, 0x00, 0xe9, 0x50, + 0xab, 0x00, 0xed, 0x78, 0xa7, 0x00, 0xef, 0x63, 0xab, 0x00, 0x46, 0x9d, + 0x16, 0x8a, 0x02, 0xc0, 0x00, 0x4c, 0x78, 0x2a, 0x7f, 0x1d, 0x40, 0x43, + 0x16, 0x00, 0x89, 0x02, 0x80, 0x8b, 0x02, 0x05, 0x51, 0x00, 0x01, 0xff, + 0x45, 0x1c, 0x3b, 0xfa, 0x00, 0x00, 0x45, 0x8f, 0x24, 0x6d, 0x01, 0x00, + 0xa3, 0xe4, 0x01, 0xa4, 0x9b, 0x01, 0x45, 0x51, 0x24, 0xf9, 0x00, 0x00, + 0x02, 0x0b, 0x00, 0x57, 0x4e, 0x9a, 0x24, 0x17, 0x02, 0x00, 0x49, 0x8e, + 0x46, 0x52, 0xab, 0x00, 0x46, 0xd1, 0x73, 0x6b, 0x01, 0x80, 0x3e, 0x4f, + 0x04, 0x74, 0x7d, 0xdf, 0x01, 0x46, 0xb0, 0xe4, 0x73, 0x01, 0x00, 0xb2, + 0x24, 0xb3, 0x16, 0x45, 0x71, 0x24, 0x69, 0x01, 0xc0, 0x00, 0x80, 0x01, + 0xff, 0x49, 0xe3, 0xaa, 0x79, 0x1e, 0x00, 0x45, 0x20, 0x07, 0x75, 0x1e, + 0x40, 0x4e, 0xba, 0x3a, 0x4e, 0xab, 0x00, 0x45, 0x53, 0x05, 0xb9, 0xa7, + 0x40, 0x4d, 0x52, 0x0f, 0x99, 0x1d, 0x00, 0x49, 0xfb, 0xb5, 0x6f, 0x01, + 0x40, 0x4e, 0x78, 0x78, 0x7b, 0x1e, 0x40, 0x03, 0x7f, 0x15, 0x2a, 0x42, + 0x5e, 0x01, 0xb0, 0x01, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, + 0x1c, 0x3b, 0xe9, 0x1e, 0x00, 0x49, 0x6d, 0x13, 0xf1, 0x1e, 0x00, 0x45, + 0x51, 0x24, 0xeb, 0x1e, 0x00, 0x4a, 0xb4, 0xb0, 0xed, 0x1e, 0x00, 0x45, + 0x71, 0x24, 0xef, 0x1e, 0x40, 0x45, 0x5c, 0x00, 0xe7, 0x1e, 0x00, 0x44, + 0x79, 0x18, 0x7b, 0xdf, 0x41, 0x48, 0xf4, 0x24, 0xfc, 0x00, 0x80, 0x1a, + 0xaf, 0x01, 0xff, 0x47, 0x6f, 0x13, 0xe5, 0x1e, 0x00, 0x05, 0x3d, 0x01, + 0x01, 0xff, 0x45, 0x1c, 0x3b, 0x71, 0x01, 0x00, 0x45, 0x51, 0x24, 0x15, + 0x02, 0x40, 0x80, 0x01, 0xff, 0x04, 0x1a, 0x00, 0x06, 0x45, 0x20, 0x07, + 0x73, 0x1e, 0x40, 0x45, 0x1c, 0x3b, 0xd8, 0x01, 0x00, 0x45, 0x07, 0x9d, + 0xda, 0x01, 0x00, 0x45, 0x51, 0x24, 0xdc, 0x01, 0x00, 0x46, 0xd1, 0x73, + 0xd6, 0x01, 0x40, 0x44, 0x0b, 0x70, 0xd4, 0x01, 0x00, 0x49, 0xd0, 0x04, + 0xfb, 0x00, 0xc0, 0x00, 0x46, 0x1f, 0x07, 0x77, 0x1e, 0x40, 0x55, 0xb3, + 0x3a, 0x4f, 0xab, 0x40, 0x06, 0x50, 0x00, 0x97, 0x03, 0x4e, 0xf6, 0x78, + 0x24, 0xdf, 0x01, 0x4b, 0x14, 0x9e, 0x77, 0x2c, 0x00, 0x53, 0xe4, 0x4a, + 0xa8, 0x02, 0x00, 0x4b, 0x0b, 0xa1, 0xa7, 0x02, 0x80, 0xe6, 0x02, 0xa8, + 0xc3, 0x02, 0x0f, 0x60, 0x72, 0xb2, 0x02, 0xaf, 0x93, 0x02, 0x47, 0x3c, + 0xdb, 0x2b, 0xa7, 0x00, 0x49, 0xe8, 0xc4, 0xa6, 0x02, 0x80, 0xf4, 0x01, + 0xb5, 0x04, 0xfa, 0x29, 0xa7, 0x40, 0xed, 0x77, 0xa7, 0x00, 0x05, 0x72, + 0x07, 0x01, 0xff, 0xe1, 0x50, 0x02, 0x80, 0xd5, 0x01, 0x4c, 0x30, 0x92, + 0x77, 0xdf, 0x01, 0x45, 0x7a, 0xeb, 0x8d, 0x01, 0x00, 0xe5, 0xdd, 0x01, + 0x00, 0xe7, 0x77, 0x1d, 0x00, 0xe8, 0x65, 0x02, 0x80, 0xae, 0x01, 0xe9, + 0x09, 0x1d, 0x80, 0xa2, 0x01, 0xeb, 0x9e, 0x02, 0x00, 0xec, 0x81, 0xa7, + 0x00, 0xed, 0x6f, 0x02, 0x80, 0x8e, 0x01, 0xaf, 0x63, 0xf2, 0x79, 0x02, + 0x80, 0x24, 0xf4, 0x87, 0x02, 0x80, 0x19, 0x42, 0x3e, 0x00, 0x51, 0xab, + 0x00, 0xf6, 0x8c, 0x02, 0x00, 0xf7, 0x8d, 0x02, 0x00, 0xf9, 0x8e, 0x02, + 0xc0, 0x00, 0x4a, 0xa0, 0xab, 0x06, 0xdf, 0x41, 0x4a, 0xed, 0x4a, 0x0d, + 0xdf, 0x41, 0x06, 0x50, 0x00, 0x01, 0xff, 0x44, 0x5b, 0x0f, 0x7b, 0x02, + 0x00, 0x48, 0xd2, 0x78, 0x7a, 0x02, 0x80, 0x22, 0x03, 0x7d, 0x02, 0x12, + 0x4c, 0x47, 0x3d, 0x15, 0xdf, 0x01, 0x46, 0x52, 0x05, 0x50, 0xdf, 0x01, + 0x44, 0x79, 0x18, 0x79, 0x2c, 0x40, 0x51, 0x86, 0x46, 0x57, 0xdf, 0x01, + 0x49, 0x6d, 0x24, 0x68, 0xab, 0x40, 0x53, 0x8e, 0x49, 0x08, 0xdf, 0x41, + 0x47, 0x32, 0xd3, 0x43, 0xab, 0x80, 0x1c, 0xe5, 0x14, 0x1d, 0x80, 0x06, + 0x45, 0xbd, 0x2a, 0x08, 0x1d, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x51, + 0x47, 0x05, 0x42, 0xab, 0x00, 0x46, 0x52, 0x05, 0x41, 0xab, 0x40, 0x4c, + 0x78, 0x2a, 0x44, 0xab, 0x40, 0x4e, 0xcc, 0x78, 0x70, 0x02, 0x40, 0x48, + 0x57, 0xc0, 0x7f, 0xa7, 0x40, 0x4e, 0x6d, 0x75, 0xae, 0x02, 0xc0, 0x00, + 0x49, 0xc3, 0xb9, 0xaf, 0x02, 0x40, 0xe5, 0x02, 0x1d, 0x00, 0x44, 0x40, + 0xea, 0x52, 0x02, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4c, 0x47, 0x3d, + 0x38, 0xdf, 0x01, 0x4e, 0x51, 0x0f, 0x67, 0xab, 0x40, 0x03, 0xef, 0x07, + 0x06, 0x48, 0x1e, 0xc3, 0x16, 0x1d, 0x40, 0x44, 0x4e, 0x12, 0xbd, 0x01, + 0x00, 0x43, 0x08, 0x24, 0x85, 0x01, 0x00, 0x43, 0x44, 0x0a, 0xa8, 0x01, + 0x40, 0x44, 0x5f, 0x32, 0x22, 0xdf, 0x01, 0x57, 0x4c, 0x32, 0x23, 0xdf, + 0x41, 0x53, 0xed, 0x49, 0x7a, 0x1d, 0x00, 0x55, 0x3e, 0x3d, 0x3c, 0xdf, + 0x01, 0x43, 0x28, 0x05, 0xfe, 0x00, 0xc0, 0x00, 0x4c, 0x78, 0x2a, 0x65, + 0xa7, 0xc0, 0x00, 0x52, 0xb2, 0x2c, 0x67, 0xa7, 0x40, 0x06, 0x50, 0x00, + 0x01, 0xff, 0x44, 0xde, 0x0b, 0x2c, 0xdf, 0x01, 0x4c, 0x47, 0x3d, 0x17, + 0xdf, 0x01, 0x4e, 0x51, 0x0f, 0x1c, 0xdf, 0x41, 0xa3, 0x58, 0xa4, 0x35, + 0x44, 0x5b, 0x0f, 0xad, 0x01, 0x80, 0x28, 0x4a, 0xc1, 0x70, 0x6f, 0x1e, + 0x00, 0x03, 0x7d, 0x02, 0x12, 0x4c, 0x47, 0x3d, 0xab, 0x01, 0x00, 0x4e, + 0x51, 0x0f, 0x88, 0x02, 0x00, 0x46, 0x52, 0x05, 0x67, 0x01, 0x40, 0x51, + 0x86, 0x46, 0x2a, 0xdf, 0x01, 0x49, 0x6d, 0x24, 0x75, 0x1d, 0x40, 0x53, + 0x8e, 0x49, 0x09, 0xdf, 0x41, 0x02, 0x1b, 0x01, 0x11, 0x03, 0x70, 0x0c, + 0x01, 0xff, 0x45, 0x5c, 0x00, 0x6b, 0x1e, 0x00, 0x45, 0x20, 0x07, 0x6d, + 0x1e, 0x40, 0x46, 0xf6, 0x24, 0x97, 0x1e, 0x00, 0x4c, 0xb3, 0x41, 0x66, + 0x2c, 0x40, 0x44, 0x0b, 0x70, 0x65, 0x01, 0x00, 0x46, 0x2a, 0x98, 0x63, + 0x01, 0x00, 0x4f, 0x15, 0x72, 0x71, 0x1e, 0x00, 0x4a, 0x4c, 0xb4, 0x1b, + 0x02, 0x00, 0x43, 0xdf, 0x0b, 0x36, 0x02, 0x40, 0x06, 0x50, 0x00, 0xa7, + 0x01, 0xa1, 0x98, 0x01, 0xa3, 0x63, 0x46, 0x9b, 0xb6, 0xdf, 0x00, 0x00, + 0xa9, 0x30, 0x05, 0x34, 0xde, 0x24, 0x51, 0x13, 0x60, 0x85, 0x02, 0x00, + 0xb4, 0x01, 0xff, 0x47, 0xd8, 0xd7, 0x45, 0xab, 0x00, 0x08, 0xc7, 0xb7, + 0x01, 0xff, 0x4b, 0xe5, 0x9e, 0x5b, 0xdf, 0x01, 0xe9, 0x71, 0xdf, 0x01, + 0x4b, 0x64, 0xa8, 0x63, 0xdf, 0x41, 0xef, 0x58, 0xdf, 0x01, 0xf5, 0x59, + 0xdf, 0x41, 0x07, 0x29, 0x48, 0x06, 0x47, 0x98, 0xcc, 0xd9, 0xa7, 0x40, + 0x4d, 0x05, 0x86, 0x1e, 0x1d, 0x00, 0xef, 0x11, 0x1d, 0x80, 0x0a, 0x48, + 0x97, 0xd1, 0x1f, 0x1d, 0x00, 0xf5, 0x1d, 0x1d, 0x40, 0x4c, 0x78, 0x2a, + 0x13, 0x1d, 0x00, 0x45, 0xcb, 0xef, 0x12, 0x1d, 0x40, 0x43, 0x83, 0x7f, + 0x59, 0x02, 0x80, 0x1b, 0x05, 0x76, 0x06, 0x01, 0xff, 0xe7, 0x61, 0x02, + 0x80, 0x0b, 0xf2, 0x4b, 0xab, 0xc0, 0x00, 0x4a, 0xdc, 0xab, 0x4c, 0xab, + 0x40, 0x52, 0x0d, 0x52, 0x36, 0xab, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, + 0x44, 0x5b, 0x0f, 0x5a, 0x02, 0x00, 0x4e, 0x51, 0x0f, 0x95, 0x1d, 0x40, + 0x47, 0x3a, 0xd8, 0x60, 0xab, 0x00, 0x46, 0x75, 0xd4, 0x8c, 0xa7, 0x40, + 0x45, 0x1c, 0x3b, 0x5b, 0x01, 0x80, 0x78, 0xa3, 0x51, 0xa4, 0x31, 0x44, + 0x5b, 0x0f, 0x82, 0x02, 0x00, 0x03, 0x7d, 0x02, 0x1b, 0x4e, 0x71, 0x45, + 0xa9, 0xa7, 0x00, 0x4c, 0x47, 0x3d, 0x8a, 0x1d, 0x00, 0xb3, 0x01, 0xff, + 0x53, 0x3a, 0x4c, 0xca, 0xa7, 0x00, 0x49, 0x0d, 0xc7, 0x3f, 0x02, 0x40, + 0x51, 0x86, 0x46, 0x29, 0xdf, 0x01, 0x49, 0x6d, 0x24, 0x74, 0x1d, 0x40, + 0x4e, 0xb1, 0x41, 0xcd, 0xa7, 0x00, 0x03, 0x70, 0x0c, 0x01, 0xff, 0x45, + 0x5c, 0x00, 0x61, 0x1e, 0x00, 0x45, 0x20, 0x07, 0x63, 0x1e, 0xc0, 0x00, + 0x4e, 0x72, 0x1f, 0x69, 0x1e, 0x40, 0x44, 0x0b, 0x70, 0x61, 0x01, 0x80, + 0x18, 0x46, 0x2a, 0x98, 0x5f, 0x01, 0x00, 0x49, 0xd0, 0x04, 0x5d, 0x01, + 0x00, 0x4a, 0x4c, 0xb4, 0x19, 0x02, 0x00, 0x43, 0xdf, 0x0b, 0x1e, 0xdf, + 0x41, 0x4e, 0x72, 0x1f, 0x67, 0x1e, 0x40, 0x4e, 0x72, 0x1f, 0x65, 0x1e, + 0x40, 0x80, 0x73, 0x48, 0xf7, 0xc8, 0x64, 0x02, 0x00, 0x08, 0xac, 0x15, + 0x0d, 0x42, 0x48, 0x04, 0x75, 0xa7, 0xc0, 0x00, 0x48, 0x36, 0xb8, 0x5d, + 0xa7, 0x40, 0xe3, 0x84, 0x21, 0x80, 0x51, 0xe5, 0x58, 0x02, 0x80, 0x46, + 0x46, 0x2e, 0xe2, 0xf6, 0xa7, 0x00, 0xeb, 0x03, 0xdf, 0x01, 0x46, 0xbc, + 0x2a, 0x5c, 0x02, 0x80, 0x24, 0x4f, 0x6c, 0x75, 0x7f, 0x02, 0x00, 0x03, + 0x74, 0x06, 0x0e, 0x4b, 0x64, 0xa8, 0x64, 0xdf, 0x01, 0xf5, 0x7f, 0xdf, + 0x01, 0xfa, 0x66, 0xdf, 0x41, 0x45, 0x95, 0xe5, 0x01, 0xdf, 0x01, 0x44, + 0x9f, 0x4e, 0x6d, 0xdf, 0x41, 0x06, 0x50, 0x00, 0x01, 0xff, 0x44, 0x5b, + 0x0f, 0x5d, 0x02, 0x00, 0x4e, 0x51, 0x0f, 0x94, 0x1d, 0x40, 0x42, 0x1d, + 0x01, 0x07, 0xdf, 0x41, 0x49, 0x98, 0x3d, 0x3f, 0xa7, 0x40, 0x47, 0x76, + 0x08, 0x5b, 0xa7, 0x80, 0xaa, 0x01, 0x04, 0x51, 0x00, 0x01, 0xff, 0x80, + 0x06, 0x4a, 0x6b, 0x53, 0x47, 0xab, 0x40, 0x45, 0x1c, 0x3b, 0x55, 0x01, + 0x00, 0xa3, 0x82, 0x01, 0x02, 0x3b, 0x01, 0x61, 0x48, 0x73, 0x75, 0x7e, + 0x02, 0x80, 0x49, 0x4e, 0x9a, 0x24, 0x13, 0x02, 0x00, 0xac, 0x2f, 0x03, + 0x7d, 0x02, 0x1f, 0x4e, 0x71, 0x45, 0xa7, 0xa7, 0x00, 0x4c, 0x47, 0x3d, + 0x89, 0x1d, 0x00, 0x46, 0x52, 0x05, 0x4d, 0x02, 0x00, 0x44, 0x79, 0x18, + 0x7d, 0x02, 0xc0, 0x00, 0x51, 0x80, 0x59, 0x37, 0xdf, 0x41, 0x51, 0x86, + 0x46, 0x28, 0xdf, 0x01, 0x49, 0x6d, 0x24, 0x72, 0x1d, 0x40, 0x47, 0x81, + 0xd6, 0x61, 0xdf, 0x01, 0x49, 0xc2, 0x70, 0x5f, 0x1e, 0x00, 0x47, 0xd3, + 0x78, 0x7c, 0x02, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x4c, 0x6a, 0x24, + 0x73, 0x1d, 0x00, 0x4c, 0x47, 0x3d, 0x16, 0xdf, 0x41, 0x02, 0xc6, 0x00, + 0x06, 0x4a, 0x4c, 0x24, 0x11, 0x02, 0x40, 0x45, 0x5c, 0x00, 0x59, 0x1e, + 0x00, 0x45, 0x20, 0x07, 0x5b, 0x1e, 0xc0, 0x00, 0x4b, 0x5c, 0x9c, 0x5d, + 0x1e, 0x40, 0x44, 0x0b, 0x70, 0x59, 0x01, 0x00, 0x46, 0x2a, 0x98, 0x57, + 0x01, 0x00, 0x4b, 0x14, 0x52, 0x49, 0xab, 0x40, 0x4a, 0xb4, 0xab, 0x94, + 0xdf, 0x41, 0x06, 0x50, 0x00, 0x06, 0x49, 0x92, 0xc3, 0x39, 0x02, 0x40, + 0x4f, 0xb0, 0x41, 0x59, 0xa7, 0x00, 0x44, 0x5b, 0x0f, 0xa0, 0x02, 0x80, + 0x0c, 0x4c, 0x47, 0x3d, 0x34, 0xdf, 0x01, 0x58, 0xac, 0x2c, 0x57, 0xa7, + 0x40, 0x45, 0x0e, 0x4a, 0x4b, 0x02, 0x40, 0x06, 0x50, 0x00, 0x31, 0xa8, + 0x01, 0xff, 0x59, 0x23, 0x1e, 0xcf, 0xa7, 0x00, 0xe9, 0x78, 0x02, 0x80, + 0x1d, 0x09, 0x0b, 0xc3, 0x01, 0xff, 0x4c, 0x8c, 0x90, 0x69, 0xdf, 0x01, + 0x4c, 0xb4, 0x92, 0x6f, 0xdf, 0x01, 0x4a, 0x40, 0xb6, 0x6b, 0xdf, 0x01, + 0x42, 0x53, 0x00, 0x79, 0xdf, 0x41, 0x52, 0x41, 0x3d, 0x33, 0xdf, 0x41, + 0x45, 0x1c, 0x3b, 0x55, 0x1e, 0x00, 0x49, 0x77, 0x1f, 0x57, 0x1e, 0x00, + 0x48, 0xdf, 0xcb, 0x53, 0xa7, 0x00, 0x44, 0x5b, 0x0f, 0xa5, 0x01, 0x00, + 0x4c, 0x6a, 0x24, 0x71, 0x1d, 0x00, 0x4c, 0x47, 0x3d, 0x88, 0x1d, 0x00, + 0xb3, 0x01, 0xff, 0x4c, 0xf0, 0x98, 0x55, 0xa7, 0x00, 0x45, 0x53, 0x05, + 0x7d, 0x1d, 0xc0, 0x00, 0x52, 0xb2, 0x2c, 0x51, 0xa7, 0x40, 0x06, 0x50, + 0x00, 0x55, 0xe9, 0xa3, 0x01, 0x80, 0x4a, 0x4b, 0x89, 0xa3, 0xc1, 0xa7, + 0x00, 0x44, 0x99, 0x7f, 0xb7, 0xa7, 0x80, 0x37, 0xef, 0x4f, 0xa7, 0x00, + 0x04, 0xf7, 0x04, 0x0b, 0xf5, 0x23, 0x02, 0xc0, 0x00, 0x48, 0xe5, 0x4a, + 0x5f, 0xdf, 0x41, 0xe5, 0x5b, 0x02, 0x80, 0x19, 0xef, 0x54, 0x02, 0xc0, + 0x00, 0x06, 0x50, 0x00, 0x04, 0xe5, 0x62, 0xab, 0x40, 0x4e, 0x51, 0x0f, + 0x97, 0x1d, 0x00, 0x46, 0x52, 0x05, 0x3f, 0xab, 0x40, 0x54, 0x4b, 0x0f, + 0x93, 0x1d, 0x40, 0x4a, 0xb4, 0xab, 0x60, 0xdf, 0x41, 0x48, 0xe5, 0x4a, + 0x5e, 0xdf, 0x41, 0x45, 0x1c, 0x3b, 0xf3, 0x00, 0x00, 0x45, 0x8f, 0x24, + 0x4f, 0x01, 0x00, 0xa3, 0xe7, 0x01, 0xa4, 0xac, 0x01, 0x45, 0x51, 0x24, + 0xf2, 0x00, 0x00, 0x02, 0x0b, 0x00, 0x72, 0x4e, 0x9a, 0x24, 0x0f, 0x02, + 0x00, 0x02, 0x13, 0x01, 0x56, 0x46, 0xd1, 0x73, 0x4d, 0x01, 0x80, 0x3e, + 0x46, 0xb0, 0xe4, 0xeb, 0x01, 0x80, 0x31, 0x4e, 0x51, 0x0f, 0x1b, 0xdf, + 0x01, 0x46, 0x52, 0x05, 0xf8, 0x00, 0x80, 0x1e, 0x45, 0x71, 0x24, 0xf5, + 0x00, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0x4d, + 0x1e, 0x00, 0x49, 0xf3, 0x24, 0x4f, 0x1e, 0x00, 0x46, 0xd1, 0x73, 0x2d, + 0x02, 0x40, 0x4a, 0xe2, 0xaa, 0xff, 0x01, 0x40, 0x4b, 0x5c, 0x9c, 0xed, + 0x01, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0x53, 0x1e, + 0x00, 0x45, 0x51, 0x24, 0x51, 0x1e, 0x40, 0x51, 0x58, 0x5f, 0x4b, 0xa7, + 0x00, 0x42, 0x1f, 0x00, 0x4d, 0xa7, 0x00, 0x4d, 0xf5, 0x8e, 0x7a, 0x2c, + 0x40, 0x48, 0xb6, 0xb0, 0xcf, 0x1e, 0x00, 0x42, 0x5e, 0x01, 0xa1, 0x01, + 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0xdb, 0x1e, + 0x00, 0x49, 0x6d, 0x13, 0xe3, 0x1e, 0x00, 0x45, 0x51, 0x24, 0xdd, 0x1e, + 0x00, 0x4a, 0xb4, 0xb0, 0xdf, 0x1e, 0x00, 0x45, 0x71, 0x24, 0xe1, 0x1e, + 0x40, 0x48, 0xf4, 0x24, 0xf6, 0x00, 0x80, 0x2b, 0xaf, 0x01, 0xff, 0x02, + 0xc6, 0x00, 0x11, 0x05, 0x3d, 0x01, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0x51, + 0x01, 0x00, 0x45, 0x51, 0x24, 0x0d, 0x02, 0x40, 0x45, 0x5c, 0x00, 0x2f, + 0x02, 0x80, 0x06, 0x45, 0x20, 0x07, 0xcd, 0x1e, 0x40, 0x4b, 0x5c, 0x9c, + 0x31, 0x02, 0x40, 0x4b, 0x5c, 0x9c, 0x2b, 0x02, 0x40, 0x44, 0x0b, 0x70, + 0xd2, 0x01, 0x00, 0x49, 0xd0, 0x04, 0xf4, 0x00, 0x80, 0x06, 0x43, 0xdf, + 0x0b, 0x73, 0xdf, 0x41, 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x1c, 0x3b, + 0xd1, 0x1e, 0x00, 0x49, 0x6d, 0x13, 0xd9, 0x1e, 0x00, 0x45, 0x51, 0x24, + 0xd3, 0x1e, 0x00, 0x4a, 0xb4, 0xb0, 0xd5, 0x1e, 0x00, 0x45, 0x71, 0x24, + 0xd7, 0x1e, 0x40, 0x80, 0x0a, 0xea, 0xcc, 0x01, 0x00, 0x42, 0x48, 0x04, + 0x74, 0xa7, 0x40, 0x56, 0x4d, 0x38, 0x49, 0x01, 0x00, 0x05, 0x51, 0x00, + 0x01, 0xff, 0x45, 0x1c, 0x3b, 0x44, 0x01, 0x00, 0xa3, 0x5b, 0xa4, 0x42, + 0x45, 0x51, 0x24, 0xf9, 0x01, 0x00, 0xac, 0x28, 0x03, 0x7d, 0x02, 0x18, + 0x4e, 0x71, 0x45, 0xa5, 0xa7, 0x00, 0x4c, 0x47, 0x3d, 0x87, 0x1d, 0x00, + 0x4e, 0x51, 0x0f, 0x73, 0x02, 0x00, 0x45, 0x71, 0x24, 0xf1, 0x00, 0x40, + 0x51, 0x86, 0x46, 0x27, 0xdf, 0x01, 0x49, 0x6d, 0x24, 0x70, 0x1d, 0x40, + 0x48, 0x8f, 0x46, 0x72, 0x02, 0x00, 0x49, 0xc2, 0x70, 0x49, 0x1e, 0x00, + 0x4d, 0x4d, 0x8b, 0x9e, 0x01, 0x40, 0x48, 0xf3, 0x11, 0x91, 0xa7, 0x00, + 0x03, 0x70, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x45, 0x1e, 0x00, 0x45, + 0x20, 0x07, 0x47, 0x1e, 0x40, 0x44, 0x0b, 0x70, 0x48, 0x01, 0x00, 0x46, + 0x2a, 0x98, 0x46, 0x01, 0x00, 0x4f, 0x15, 0x72, 0x4b, 0x1e, 0x00, 0x4b, + 0x14, 0x52, 0x3b, 0xab, 0x00, 0x43, 0xdf, 0x0b, 0x35, 0x02, 0x40, 0x06, + 0x50, 0x00, 0x1f, 0x05, 0x7e, 0x02, 0x06, 0x42, 0x48, 0x04, 0x73, 0xa7, + 0x40, 0x48, 0x3f, 0xc8, 0xd7, 0xa7, 0x00, 0x07, 0xa9, 0xd3, 0x01, 0xff, + 0x42, 0x60, 0x07, 0xfb, 0x1e, 0x00, 0xf6, 0xfd, 0x1e, 0x40, 0x45, 0x1c, + 0x3b, 0x3f, 0x1e, 0x00, 0x4c, 0x13, 0x52, 0x3a, 0xab, 0x00, 0x04, 0x6f, + 0x0c, 0x12, 0x44, 0x5b, 0x0f, 0x71, 0x02, 0x00, 0x4c, 0x6a, 0x24, 0x6f, + 0x1d, 0x00, 0x4c, 0x47, 0x3d, 0x86, 0x1d, 0x40, 0x45, 0x5c, 0x00, 0x41, + 0x1e, 0x00, 0x45, 0x20, 0x07, 0x43, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x6f, + 0x45, 0x44, 0xea, 0xdb, 0xa7, 0x80, 0x62, 0xa5, 0x42, 0xea, 0xc9, 0x01, + 0x00, 0x45, 0xe7, 0x11, 0x7f, 0x01, 0x80, 0x18, 0x49, 0xe8, 0xc4, 0xaa, + 0x02, 0x00, 0xb5, 0x06, 0x49, 0x79, 0xc7, 0xab, 0x02, 0x40, 0xed, 0x72, + 0xa7, 0x00, 0x47, 0x4b, 0xd9, 0x5c, 0xdf, 0x41, 0x06, 0x50, 0x00, 0x01, + 0xff, 0xa4, 0x0c, 0x4b, 0x1e, 0xa2, 0x9d, 0x1e, 0x00, 0x48, 0x5f, 0xd1, + 0x96, 0xdf, 0x41, 0x4e, 0xb1, 0x41, 0x9c, 0x1e, 0x00, 0x48, 0x78, 0x1f, + 0x9b, 0x1e, 0x40, 0x45, 0x17, 0xef, 0x35, 0xab, 0x00, 0x42, 0xc2, 0x29, + 0x6e, 0x02, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x44, 0xde, 0x0b, + 0x67, 0xdf, 0x01, 0x4e, 0x51, 0x0f, 0x05, 0xdf, 0x41, 0x4c, 0x78, 0x2a, + 0x9b, 0x01, 0x40, 0x45, 0x1c, 0x3b, 0x3a, 0x01, 0x00, 0xa2, 0x8e, 0x01, + 0xa3, 0x74, 0x02, 0x3b, 0x01, 0x52, 0x48, 0x73, 0x75, 0x11, 0xdf, 0x01, + 0x4b, 0x1e, 0xa2, 0x49, 0xa7, 0x00, 0x4f, 0xf7, 0x71, 0x37, 0xab, 0x00, + 0x4a, 0xc1, 0x70, 0x3b, 0x1e, 0x00, 0x03, 0x7d, 0x02, 0x19, 0x4c, 0x47, + 0x3d, 0x85, 0x1d, 0x00, 0x4e, 0x51, 0x0f, 0x6d, 0x02, 0x80, 0x06, 0x46, + 0x52, 0x05, 0x42, 0x01, 0x40, 0x49, 0x5a, 0x32, 0x8e, 0xa7, 0x40, 0x51, + 0x86, 0x46, 0x26, 0xdf, 0x01, 0x04, 0x80, 0x02, 0x01, 0xff, 0x43, 0x48, + 0x0a, 0x40, 0x01, 0x00, 0x44, 0x22, 0x08, 0x39, 0xab, 0x00, 0x45, 0x71, + 0x24, 0x6b, 0x02, 0x40, 0x47, 0x6f, 0x13, 0x37, 0x1e, 0x80, 0x11, 0x05, + 0x3d, 0x01, 0x01, 0xff, 0x43, 0x16, 0x00, 0x61, 0x2c, 0x00, 0x4c, 0x6a, + 0x24, 0x38, 0xab, 0x40, 0x4b, 0x5c, 0x9c, 0x39, 0x1e, 0x40, 0x44, 0x0b, + 0x70, 0x3e, 0x01, 0x00, 0x46, 0x2a, 0x98, 0x3c, 0x01, 0x00, 0x4f, 0x15, + 0x72, 0x3d, 0x1e, 0x00, 0x43, 0xdf, 0x0b, 0x34, 0x02, 0x40, 0x42, 0x17, + 0x00, 0x9a, 0x01, 0x00, 0x43, 0x60, 0x32, 0x6c, 0x02, 0xc0, 0x00, 0x51, + 0x80, 0x59, 0x13, 0xdf, 0x41, 0x06, 0x50, 0x00, 0x06, 0x42, 0x71, 0x00, + 0x38, 0x01, 0x40, 0x45, 0x1c, 0x3b, 0x31, 0x1e, 0x00, 0xa3, 0x39, 0xa4, + 0x25, 0x44, 0x5b, 0x0f, 0x99, 0x01, 0x00, 0x4a, 0xc1, 0x70, 0x35, 0x1e, + 0x00, 0x4e, 0x71, 0x45, 0xa3, 0xa7, 0x00, 0x4c, 0x47, 0x3d, 0x84, 0x1d, + 0x00, 0x46, 0x52, 0x05, 0x41, 0xa7, 0xc0, 0x00, 0x54, 0xab, 0x41, 0x45, + 0xa7, 0x40, 0x48, 0xf3, 0x11, 0x6a, 0x2c, 0x00, 0x4e, 0xb1, 0x41, 0x43, + 0xa7, 0x00, 0x48, 0x6e, 0x13, 0x33, 0x1e, 0x40, 0x44, 0x0b, 0x70, 0xe9, + 0x01, 0x00, 0x46, 0x2a, 0x98, 0x37, 0x01, 0x40, 0x06, 0x50, 0x00, 0x01, + 0xff, 0xa3, 0x06, 0x46, 0x52, 0x05, 0x49, 0x02, 0x40, 0x44, 0x0b, 0x70, + 0xf0, 0x01, 0x00, 0x49, 0xd0, 0x04, 0x35, 0x01, 0x00, 0x4b, 0x14, 0x52, + 0x9d, 0x02, 0x40, 0x06, 0x50, 0x00, 0x4c, 0xe5, 0x5d, 0xdf, 0x01, 0xae, + 0x19, 0x02, 0x1b, 0x05, 0x04, 0xf3, 0x6d, 0xa7, 0x40, 0xe1, 0x69, 0x02, + 0x80, 0x06, 0x47, 0x5a, 0x8d, 0x61, 0xab, 0x40, 0x4c, 0x78, 0x2a, 0x7c, + 0x1d, 0x40, 0x06, 0x58, 0xc0, 0x11, 0x07, 0x9c, 0x24, 0x01, 0xff, 0x45, + 0x3f, 0xea, 0x64, 0xab, 0x00, 0x42, 0xce, 0x53, 0x40, 0xab, 0x40, 0xe4, + 0x7a, 0xa7, 0x00, 0xe6, 0x7c, 0xa7, 0x00, 0xe7, 0x79, 0x1d, 0x00, 0xf2, + 0x83, 0xa7, 0x00, 0xf3, 0x85, 0xa7, 0x00, 0xf4, 0x87, 0xa7, 0x40, 0x45, + 0x1c, 0x3b, 0xed, 0x00, 0x00, 0x45, 0x8f, 0x24, 0x2d, 0x01, 0x00, 0xa3, + 0x62, 0xa4, 0x44, 0x45, 0x51, 0x24, 0xec, 0x00, 0x00, 0x4a, 0xb4, 0xb0, + 0xc9, 0x1e, 0x00, 0x4e, 0x9a, 0x24, 0x0b, 0x02, 0x00, 0x46, 0xd1, 0x73, + 0x2b, 0x01, 0x00, 0x46, 0xb0, 0xe4, 0x2f, 0x01, 0x00, 0x51, 0xbe, 0x5f, + 0x70, 0xdf, 0x01, 0x4e, 0x51, 0x0f, 0x96, 0x1d, 0x00, 0x46, 0x52, 0x05, + 0x68, 0x02, 0x80, 0x0d, 0x45, 0x71, 0x24, 0x29, 0x01, 0xc0, 0x00, 0x46, + 0x1f, 0x07, 0x2d, 0x1e, 0x40, 0x53, 0x8e, 0x49, 0x1a, 0xdf, 0x41, 0x48, + 0xf4, 0x24, 0xef, 0x00, 0x80, 0x0f, 0xaf, 0x01, 0xff, 0x47, 0x6f, 0x13, + 0xcb, 0x1e, 0x00, 0x4a, 0x4c, 0x24, 0x09, 0x02, 0x40, 0x4a, 0xe2, 0xaa, + 0x2f, 0x1e, 0x40, 0x44, 0x0b, 0x70, 0xd0, 0x01, 0x00, 0x49, 0xd0, 0x04, + 0xee, 0x00, 0x40, 0x06, 0x50, 0x00, 0x1d, 0x04, 0x23, 0x00, 0x11, 0x43, + 0x95, 0x0a, 0x27, 0xa7, 0x80, 0x04, 0xf6, 0x95, 0x01, 0x40, 0x4a, 0x15, + 0x26, 0x67, 0x02, 0x40, 0xe1, 0x5a, 0xdf, 0x01, 0xe8, 0x76, 0x2c, 0x40, + 0x4b, 0xc4, 0x9e, 0x2b, 0x1e, 0x00, 0xa3, 0x3e, 0xa4, 0x1f, 0x44, 0x5b, + 0x0f, 0x66, 0x02, 0x00, 0x4a, 0xc1, 0x70, 0x96, 0x1e, 0x00, 0x4c, 0x47, + 0x3d, 0x95, 0xa7, 0x00, 0x46, 0x52, 0x05, 0x27, 0x01, 0xc0, 0x00, 0x51, + 0x80, 0x59, 0x32, 0xdf, 0x41, 0x48, 0xf3, 0x11, 0x68, 0x2c, 0x00, 0x48, + 0xf4, 0x24, 0x27, 0x1e, 0x00, 0x03, 0x70, 0x0c, 0x01, 0xff, 0x45, 0x5c, + 0x00, 0x23, 0x1e, 0x00, 0x45, 0x20, 0x07, 0x25, 0x1e, 0x40, 0x44, 0x0b, + 0x70, 0x1f, 0x02, 0x00, 0x46, 0x2a, 0x98, 0x29, 0x1e, 0x00, 0x49, 0xd0, + 0x04, 0x25, 0x01, 0x40, 0x06, 0x50, 0x00, 0x2a, 0x44, 0x23, 0x22, 0x63, + 0x02, 0x80, 0x1d, 0x42, 0x22, 0x00, 0xa3, 0x01, 0x00, 0x07, 0x6d, 0x2a, 0x01, 0xff, 0xe1, 0xbb, 0xa7, 0x00, 0xe9, 0xbd, 0xa7, 0x00, 0x44, 0x55, - 0x03, 0x42, 0x02, 0x00, 0xf5, 0xbf, 0xa7, 0x40, 0x45, 0x14, 0x39, 0xf5, - 0x01, 0x00, 0x45, 0x55, 0x23, 0x1f, 0x01, 0x00, 0xa3, 0x24, 0x49, 0x56, - 0x1e, 0x21, 0x01, 0x00, 0x44, 0xac, 0x0e, 0x60, 0x02, 0x00, 0x46, 0xb4, - 0x70, 0x21, 0x1e, 0x00, 0x4e, 0x55, 0x43, 0xa1, 0xa7, 0x00, 0x4c, 0xfa, - 0x56, 0x83, 0x1d, 0x00, 0x46, 0x52, 0x05, 0xe5, 0x01, 0x40, 0x44, 0xee, - 0x6c, 0xe7, 0x01, 0x00, 0x46, 0x1b, 0xc2, 0x23, 0x01, 0x00, 0x49, 0xd0, - 0x04, 0x1d, 0x01, 0x40, 0x06, 0x50, 0x00, 0x0d, 0x4b, 0xd6, 0x9b, 0xa9, - 0x02, 0xc0, 0x00, 0x4b, 0x66, 0x98, 0x00, 0xdf, 0x41, 0x49, 0x56, 0x1e, - 0x1f, 0x1e, 0x00, 0x44, 0xac, 0x0e, 0x92, 0x01, 0x00, 0x4c, 0x30, 0x23, - 0x6e, 0x1d, 0x00, 0x4c, 0xfa, 0x56, 0x82, 0x1d, 0x00, 0x46, 0x52, 0x05, - 0x99, 0xa7, 0x40, 0x06, 0x50, 0x00, 0x92, 0x01, 0x0e, 0x40, 0x78, 0x81, - 0x01, 0x42, 0x1d, 0x01, 0x4b, 0x01, 0x80, 0x69, 0x42, 0xa4, 0x02, 0x83, - 0x02, 0x80, 0x3e, 0xf4, 0x6b, 0xa7, 0x80, 0x35, 0x42, 0x6f, 0x28, 0x92, - 0x02, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x48, 0x58, 0x13, 0xb9, 0x01, 0x00, - 0x05, 0x51, 0x00, 0x01, 0xff, 0xa3, 0x12, 0x4c, 0xfa, 0x56, 0x18, 0xdf, - 0x01, 0x4e, 0xa2, 0x0e, 0x9a, 0x1d, 0x00, 0x44, 0x8f, 0x17, 0xba, 0x01, - 0x40, 0x44, 0xee, 0x6c, 0xef, 0x01, 0x00, 0x43, 0x73, 0x0b, 0x93, 0x02, - 0x40, 0xe8, 0xf0, 0x00, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x44, 0x72, - 0x0b, 0x86, 0x02, 0x00, 0x4a, 0x82, 0xa9, 0x0b, 0xdf, 0x81, 0x0c, 0x4c, - 0xfa, 0x56, 0x8b, 0x1d, 0x00, 0x4e, 0xa2, 0x0e, 0x98, 0x1d, 0x40, 0x49, - 0x53, 0xb4, 0x0c, 0xdf, 0x41, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4c, 0xd0, - 0x4f, 0x3c, 0xab, 0x00, 0x4c, 0xfa, 0x56, 0x14, 0xdf, 0x41, 0x42, 0x9e, - 0x01, 0x25, 0xa7, 0x00, 0x43, 0x68, 0x00, 0x23, 0xa7, 0x40, 0x45, 0x14, - 0x39, 0xe9, 0x00, 0x00, 0x45, 0x55, 0x23, 0x15, 0x01, 0x00, 0xa3, 0x76, - 0xa4, 0x55, 0x48, 0x51, 0xc6, 0x34, 0xab, 0x00, 0x45, 0x17, 0x23, 0xe8, - 0x00, 0x00, 0x4a, 0x58, 0xab, 0xbb, 0x1e, 0x00, 0x4e, 0x60, 0x23, 0x07, - 0x02, 0x00, 0x46, 0xb4, 0x70, 0x13, 0x01, 0x80, 0x25, 0x45, 0x7c, 0x2a, - 0x78, 0x2c, 0x00, 0x46, 0xda, 0xde, 0x19, 0x01, 0x00, 0x4e, 0xa2, 0x0e, - 0x92, 0x1d, 0x00, 0x46, 0x52, 0x05, 0x47, 0x02, 0x00, 0x45, 0x37, 0x23, - 0xbd, 0x1e, 0xc0, 0x00, 0x46, 0x1f, 0x07, 0x1b, 0x1e, 0x40, 0x05, 0x19, - 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0x17, 0x1e, 0x00, 0x45, 0x17, 0x23, - 0x15, 0x1e, 0x40, 0x48, 0xba, 0x23, 0xeb, 0x00, 0x00, 0xaf, 0x01, 0xff, - 0x02, 0xc6, 0x00, 0x06, 0x4a, 0x12, 0x23, 0x05, 0x02, 0x40, 0x45, 0x5c, - 0x00, 0x17, 0x01, 0x00, 0x45, 0x20, 0x07, 0xb9, 0x1e, 0x40, 0x44, 0xee, - 0x6c, 0x1b, 0x01, 0x00, 0x46, 0x1b, 0xc2, 0x29, 0x02, 0x80, 0x32, 0x49, - 0xd0, 0x04, 0xea, 0x00, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x04, 0x1a, 0x00, - 0x06, 0x45, 0x20, 0x07, 0x19, 0x1e, 0x40, 0x45, 0x14, 0x39, 0xbf, 0x1e, - 0x00, 0x49, 0x9f, 0x12, 0xc7, 0x1e, 0x00, 0x45, 0x17, 0x23, 0xc1, 0x1e, - 0x00, 0x4a, 0x58, 0xab, 0xc3, 0x1e, 0x00, 0x45, 0x37, 0x23, 0xc5, 0x1e, - 0x40, 0x4a, 0xcc, 0xa5, 0x1d, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x8a, 0x01, - 0x49, 0x9c, 0xb6, 0x38, 0x02, 0x00, 0xa5, 0x64, 0xaf, 0x2c, 0x42, 0x48, - 0x04, 0x71, 0xa7, 0x00, 0xfa, 0xf3, 0x01, 0xc0, 0x00, 0x80, 0x01, 0xff, - 0x47, 0xb6, 0x48, 0xa3, 0x02, 0x80, 0x06, 0x4a, 0x04, 0x98, 0xc6, 0x01, - 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x44, 0x72, 0x0b, 0xa5, 0x02, 0x00, - 0x4e, 0xa2, 0x0e, 0x66, 0xab, 0x40, 0x06, 0x99, 0x41, 0x1c, 0x05, 0x3d, - 0x01, 0x01, 0xff, 0xf2, 0x48, 0xab, 0x80, 0x0c, 0x45, 0x18, 0x4a, 0xd3, - 0xa7, 0x00, 0x44, 0x89, 0xa4, 0xd5, 0xa7, 0x40, 0x52, 0xca, 0x4f, 0x4a, - 0xab, 0x40, 0xe9, 0x31, 0x01, 0x00, 0xea, 0x37, 0x02, 0xc0, 0x00, 0x4c, - 0xf5, 0x28, 0x5f, 0x02, 0xc0, 0x00, 0x49, 0xc2, 0x23, 0x84, 0x02, 0x40, - 0x43, 0x65, 0x19, 0x9f, 0x1e, 0x00, 0x4a, 0x36, 0xb4, 0xa4, 0x02, 0xc0, - 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4c, 0xfa, 0x56, 0x12, 0xdf, 0x01, - 0x4e, 0xa2, 0x0e, 0x19, 0xdf, 0x41, 0xa3, 0x56, 0x04, 0x03, 0x0c, 0x46, - 0x44, 0xac, 0x0e, 0x57, 0x02, 0x80, 0x39, 0x4a, 0xa4, 0x6d, 0x0f, 0x1e, - 0x00, 0x03, 0x7d, 0x02, 0x23, 0x4c, 0xfa, 0x56, 0x81, 0x1d, 0x00, 0xb3, - 0x0f, 0xb4, 0x01, 0xff, 0x43, 0x90, 0x17, 0x56, 0x02, 0x00, 0x45, 0xc7, - 0xe0, 0x8c, 0x01, 0x40, 0x53, 0xf7, 0x49, 0xc8, 0xa7, 0x00, 0x45, 0x53, - 0x05, 0x11, 0x01, 0x40, 0x51, 0xb0, 0x57, 0x25, 0xdf, 0x01, 0x49, 0x33, - 0x23, 0x6d, 0x1d, 0x40, 0x49, 0x5c, 0xb4, 0x91, 0x1d, 0x40, 0x45, 0x5c, - 0x00, 0x0b, 0x1e, 0x00, 0x45, 0x20, 0x07, 0x0d, 0x1e, 0x40, 0x44, 0xee, - 0x6c, 0x0f, 0x01, 0x00, 0x46, 0x1b, 0xc2, 0x11, 0x1e, 0x00, 0x4f, 0xf8, - 0x6e, 0x13, 0x1e, 0x00, 0x43, 0x73, 0x0b, 0x21, 0x02, 0x40, 0x06, 0x50, - 0x00, 0x49, 0x42, 0x49, 0x00, 0x53, 0xab, 0x80, 0x31, 0x06, 0x7c, 0x1b, - 0x13, 0x42, 0x10, 0x00, 0x6f, 0xa7, 0x00, 0x48, 0x01, 0xcc, 0x2d, 0xa7, - 0xc0, 0x00, 0x4b, 0x0e, 0x98, 0x2f, 0xa7, 0x40, 0x49, 0x1b, 0x70, 0xd1, - 0xa7, 0x00, 0xaf, 0x06, 0x4f, 0x7c, 0x72, 0x5e, 0x02, 0x40, 0x44, 0xe1, - 0x7b, 0x77, 0x02, 0x00, 0x45, 0x3a, 0x29, 0x9a, 0x02, 0x40, 0x0a, 0x8a, - 0xa6, 0x01, 0xff, 0x4a, 0xde, 0xac, 0x55, 0xab, 0x00, 0x4a, 0x2c, 0x50, - 0x54, 0xab, 0x40, 0x45, 0x14, 0x39, 0x07, 0x01, 0x00, 0x43, 0x16, 0x00, - 0x93, 0xa7, 0x00, 0xa3, 0x1e, 0x49, 0x56, 0x1e, 0x0b, 0x01, 0x00, 0x44, - 0xac, 0x0e, 0x88, 0x01, 0x00, 0x4c, 0xfa, 0x56, 0x94, 0xa7, 0x00, 0x4e, - 0xa2, 0x0e, 0x1d, 0xdf, 0x01, 0x46, 0x52, 0x05, 0x3c, 0x02, 0x40, 0x44, - 0xee, 0x6c, 0x0d, 0x01, 0x00, 0x46, 0x1b, 0xc2, 0xe7, 0x00, 0x80, 0x0c, - 0x49, 0xd0, 0x04, 0x09, 0x01, 0x00, 0x43, 0x73, 0x0b, 0x55, 0x02, 0x40, - 0x4a, 0xb8, 0xa5, 0x09, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x3f, 0xa1, 0x25, - 0x43, 0x94, 0x0f, 0xb5, 0xa7, 0x00, 0x0b, 0x5f, 0x9e, 0x0c, 0x4c, 0x90, - 0x93, 0x17, 0x1d, 0x00, 0x47, 0x8f, 0xd5, 0x47, 0xa7, 0x40, 0xe5, 0x32, - 0xab, 0x00, 0xef, 0x3d, 0xab, 0xc0, 0x00, 0x4c, 0xf5, 0x28, 0x3e, 0xab, - 0x40, 0x05, 0xe0, 0x80, 0x06, 0x4a, 0x02, 0xb1, 0x4d, 0xab, 0x40, 0x45, - 0x5e, 0xe4, 0x30, 0xab, 0x00, 0xe5, 0x33, 0xab, 0x00, 0xef, 0x75, 0x02, - 0x40, 0x04, 0x03, 0x0c, 0x2a, 0x48, 0x51, 0xc6, 0x97, 0xa7, 0x00, 0x44, - 0xac, 0x0e, 0x53, 0x02, 0x00, 0x4a, 0xa4, 0x6d, 0x07, 0x1e, 0x00, 0x4c, - 0x30, 0x23, 0x6c, 0x1d, 0x00, 0x4c, 0xfa, 0x56, 0x80, 0x1d, 0x00, 0x46, - 0x52, 0x05, 0x80, 0x01, 0x00, 0x46, 0xc6, 0xe0, 0x83, 0x01, 0x40, 0x45, - 0x5c, 0x00, 0x03, 0x1e, 0x00, 0x45, 0x20, 0x07, 0x05, 0x1e, 0x40, 0x80, - 0x44, 0xe1, 0x33, 0xa7, 0x00, 0xe5, 0xe6, 0x00, 0x80, 0x2a, 0x44, 0x5f, - 0xe4, 0x51, 0x02, 0x80, 0x1d, 0x4a, 0x82, 0xae, 0xc3, 0xa7, 0x00, 0xef, - 0x35, 0xa7, 0x00, 0xf5, 0x37, 0xa7, 0x00, 0xf6, 0x39, 0xa7, 0x80, 0x04, - 0xf9, 0x3d, 0xa7, 0x40, 0x54, 0x07, 0x40, 0x3b, 0xa7, 0x40, 0x54, 0x9c, - 0x0e, 0x90, 0x1d, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, - 0xfd, 0x01, 0x00, 0x46, 0xb4, 0x70, 0xe3, 0x01, 0x40, 0x4e, 0xc0, 0x7b, - 0x31, 0xab, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0xe1, - 0x00, 0x00, 0x45, 0x55, 0x23, 0x03, 0x01, 0x80, 0xb5, 0x01, 0xa3, 0x82, - 0x01, 0xa4, 0x53, 0x45, 0x17, 0x23, 0xe0, 0x00, 0x00, 0x4a, 0x58, 0xab, - 0xa3, 0x1e, 0x00, 0x4e, 0x60, 0x23, 0x03, 0x02, 0x00, 0x46, 0xb4, 0x70, - 0x01, 0x01, 0x00, 0x46, 0xda, 0xde, 0x05, 0x01, 0x00, 0xb2, 0x0c, 0x46, - 0x52, 0x05, 0x65, 0x2c, 0x00, 0x45, 0x37, 0x23, 0xe3, 0x00, 0x40, 0x4d, - 0xa3, 0x0e, 0x8f, 0x1d, 0x00, 0xa9, 0x01, 0xff, 0x4d, 0x8d, 0x72, 0x9a, - 0x1e, 0x00, 0x03, 0xa2, 0x01, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xe5, 0x00, - 0x80, 0x06, 0x45, 0x20, 0x07, 0x01, 0x1e, 0x40, 0x4a, 0xb8, 0xa5, 0xfb, - 0x01, 0x40, 0x48, 0xba, 0x23, 0xe4, 0x00, 0x80, 0x20, 0xaf, 0x01, 0xff, - 0x02, 0xc6, 0x00, 0x06, 0x4a, 0x12, 0x23, 0x01, 0x02, 0x40, 0x45, 0x5c, - 0x00, 0x27, 0x02, 0x80, 0x06, 0x45, 0x20, 0x07, 0xa1, 0x1e, 0x40, 0x4b, - 0x74, 0x97, 0xe1, 0x01, 0x40, 0x4b, 0x74, 0x97, 0xdf, 0x01, 0x40, 0x44, - 0xee, 0x6c, 0xce, 0x01, 0x00, 0x49, 0xd0, 0x04, 0xe2, 0x00, 0xc0, 0x00, - 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0xa5, 0x1e, 0x00, 0x49, - 0x9f, 0x12, 0xad, 0x1e, 0x00, 0x45, 0x17, 0x23, 0xa7, 0x1e, 0x00, 0x4a, - 0x58, 0xab, 0xa9, 0x1e, 0x00, 0x45, 0x37, 0x23, 0xab, 0x1e, 0x40, 0x05, - 0x19, 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0xaf, 0x1e, 0x00, 0x49, 0x9f, - 0x12, 0xb7, 0x1e, 0x00, 0x45, 0x17, 0x23, 0xb1, 0x1e, 0x00, 0x4a, 0x58, - 0xab, 0xb3, 0x1e, 0x00, 0x45, 0x37, 0x23, 0xb5, 0x1e, 0x40, 0x4d, 0xf8, - 0x83, 0x7b, 0x1d, 0x00, 0x4d, 0x81, 0x89, 0x7e, 0x1d, 0x40, 0xa1, 0x8d, - 0x03, 0x02, 0xe5, 0x06, 0xf1, 0x02, 0x4c, 0xf0, 0x8d, 0xc0, 0x01, 0x00, - 0x4c, 0xe9, 0x28, 0x94, 0x02, 0x80, 0xdd, 0x02, 0x55, 0x5c, 0x3c, 0x96, - 0x02, 0x80, 0xc4, 0x02, 0x4d, 0x09, 0x85, 0xc1, 0x01, 0x00, 0x5b, 0x1b, - 0x1d, 0x95, 0x02, 0x00, 0x02, 0x88, 0x00, 0x95, 0x02, 0xb3, 0x18, 0x4f, - 0x11, 0x74, 0xbb, 0x01, 0x00, 0x58, 0xe9, 0x2b, 0x24, 0x1d, 0x00, 0x44, - 0x89, 0xa4, 0xbf, 0x01, 0x00, 0x42, 0x07, 0x22, 0xa6, 0x01, 0x40, 0x4e, - 0xa2, 0x78, 0x8f, 0xa7, 0x00, 0x0d, 0xe2, 0x3c, 0x0d, 0x4a, 0x4c, 0xb2, - 0x97, 0x02, 0xc0, 0x00, 0x4a, 0xbd, 0x48, 0x0f, 0xdf, 0x41, 0xe1, 0x00, - 0x1d, 0x80, 0xda, 0x01, 0xe2, 0x99, 0x02, 0x80, 0xce, 0x01, 0xe3, 0x04, - 0x1d, 0x00, 0xe4, 0x05, 0x1d, 0x00, 0xe5, 0x07, 0x1d, 0x80, 0xb4, 0x01, - 0xe6, 0x30, 0xa7, 0x00, 0xe7, 0x62, 0x02, 0x80, 0xa4, 0x01, 0xe8, 0x9c, - 0x02, 0x00, 0xe9, 0x6a, 0x02, 0x80, 0x94, 0x01, 0xea, 0x0a, 0x1d, 0x00, - 0xeb, 0x0b, 0x1d, 0x00, 0xec, 0x9f, 0x02, 0x80, 0x76, 0xed, 0x0d, 0x1d, - 0x00, 0xee, 0x74, 0x02, 0x00, 0xef, 0x0f, 0x1d, 0x80, 0x5b, 0xf0, 0x18, - 0x1d, 0x00, 0xf1, 0xaf, 0xa7, 0x00, 0xf2, 0x80, 0x02, 0x80, 0x36, 0xf3, - 0x31, 0xa7, 0x00, 0xf4, 0x1b, 0x1d, 0x80, 0x14, 0xf5, 0x1c, 0x1d, 0x00, - 0xf6, 0x20, 0x1d, 0x00, 0xf7, 0x21, 0x1d, 0x00, 0xf9, 0x8f, 0x02, 0x00, - 0xfa, 0x22, 0x1d, 0x40, 0x06, 0x71, 0x07, 0x01, 0xff, 0xe5, 0x7b, 0x2c, - 0x00, 0xe7, 0x02, 0xdf, 0x01, 0xeb, 0x10, 0xdf, 0x01, 0xed, 0xfa, 0xa7, - 0x00, 0xf2, 0x1a, 0x1d, 0x40, 0x4f, 0x0c, 0x6a, 0x46, 0xab, 0x00, 0x08, - 0xde, 0x14, 0x06, 0x42, 0x48, 0x04, 0x76, 0xa7, 0x40, 0xee, 0x0e, 0x1d, - 0x00, 0xf2, 0x19, 0x1d, 0x40, 0xe5, 0x76, 0x02, 0x00, 0x45, 0xf4, 0xe9, - 0x10, 0x1d, 0x00, 0xf5, 0x15, 0x1d, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, - 0x44, 0x7c, 0xa6, 0x04, 0xdf, 0x01, 0x46, 0x52, 0x05, 0x0c, 0x1d, 0x40, - 0x49, 0xe7, 0xbc, 0x81, 0x02, 0x40, 0x4a, 0xc2, 0x24, 0x9b, 0x02, 0x40, - 0x42, 0x53, 0x00, 0x06, 0x1d, 0x00, 0x42, 0x6f, 0x28, 0x23, 0x1d, 0x40, - 0x47, 0x1b, 0xcf, 0x03, 0x1d, 0x40, 0xe5, 0x01, 0x1d, 0x40, 0x4d, 0x8f, - 0x0e, 0xc3, 0x01, 0x80, 0x11, 0x07, 0xdf, 0x14, 0x01, 0xff, 0x48, 0xf1, - 0xc5, 0xaa, 0x01, 0x00, 0x58, 0xe9, 0x28, 0xa2, 0x02, 0x40, 0x54, 0x9c, - 0x0e, 0x0a, 0xdf, 0x41, 0x06, 0x50, 0x00, 0x01, 0xff, 0x44, 0x72, 0x0b, - 0x0e, 0xdf, 0x01, 0x46, 0x52, 0x05, 0xbe, 0x01, 0x40, 0x4c, 0xf5, 0x28, - 0xa1, 0x02, 0x40, 0x51, 0xbf, 0x59, 0xad, 0x02, 0x00, 0x07, 0x2d, 0x84, - 0x01, 0xff, 0x45, 0x97, 0x0e, 0x98, 0x02, 0x00, 0x4a, 0xc6, 0x59, 0xac, - 0x02, 0x40, 0x42, 0x9e, 0x01, 0x25, 0x1d, 0x00, 0x4d, 0x7e, 0x85, 0xc2, - 0x01, 0x40, 0x49, 0x66, 0xb6, 0xff, 0xa7, 0x00, 0xa9, 0x12, 0x09, 0xdd, - 0x14, 0x06, 0x4a, 0x2a, 0xb1, 0xf7, 0xa7, 0x40, 0xe6, 0xfb, 0xa7, 0x00, - 0xf0, 0xfc, 0xa7, 0x40, 0x46, 0x4a, 0xd8, 0xfe, 0xa7, 0x00, 0x49, 0x47, - 0x5b, 0xfd, 0xa7, 0x40, 0x08, 0xe5, 0x05, 0x06, 0x44, 0x96, 0x10, 0x1d, - 0x27, 0x40, 0x06, 0xed, 0x05, 0x11, 0x08, 0x9f, 0x1f, 0x01, 0xff, 0x42, - 0x80, 0xc7, 0x32, 0x01, 0x00, 0x42, 0x67, 0x51, 0x52, 0x01, 0x40, 0xe1, - 0x41, 0x00, 0x80, 0xa9, 0x16, 0xe2, 0x42, 0x00, 0x80, 0xe5, 0x15, 0xe3, - 0x43, 0x00, 0x80, 0xfd, 0x14, 0xe4, 0x44, 0x00, 0x80, 0x87, 0x14, 0xe5, - 0x45, 0x00, 0x80, 0x8b, 0x12, 0xe6, 0x46, 0x00, 0x80, 0xee, 0x11, 0xe7, - 0x47, 0x00, 0x80, 0x83, 0x11, 0xe8, 0x48, 0x00, 0x80, 0xa2, 0x10, 0xe9, - 0x49, 0x00, 0x80, 0xff, 0x0e, 0xea, 0x4a, 0x00, 0x80, 0xe0, 0x0e, 0xeb, - 0x4b, 0x00, 0x80, 0x8e, 0x0e, 0xec, 0x4c, 0x00, 0x80, 0x89, 0x0d, 0xed, - 0x4d, 0x00, 0x80, 0xc9, 0x0c, 0xee, 0x4e, 0x00, 0x80, 0xdc, 0x0b, 0xef, - 0x4f, 0x00, 0x80, 0x8c, 0x09, 0xf0, 0x50, 0x00, 0x80, 0xce, 0x08, 0xf1, - 0x51, 0x00, 0x80, 0xb7, 0x08, 0xf2, 0x52, 0x00, 0x80, 0xab, 0x07, 0xf3, - 0x53, 0x00, 0x80, 0x87, 0x06, 0xf4, 0x54, 0x00, 0x80, 0xd1, 0x04, 0xf5, - 0x55, 0x00, 0x80, 0xd9, 0x02, 0xf6, 0x56, 0x00, 0x80, 0x8f, 0x02, 0xf7, - 0x57, 0x00, 0x80, 0xce, 0x01, 0xf8, 0x58, 0x00, 0x80, 0xb7, 0x01, 0xf9, - 0x59, 0x00, 0x80, 0x58, 0xfa, 0x5a, 0x00, 0xc0, 0x00, 0x06, 0x50, 0x00, - 0x01, 0xff, 0x45, 0x14, 0x39, 0x79, 0x01, 0x00, 0xa3, 0x3a, 0xa4, 0x21, - 0x44, 0xac, 0x0e, 0x24, 0x02, 0x00, 0x4a, 0xa4, 0x6d, 0x94, 0x1e, 0x00, - 0x4c, 0xfa, 0x56, 0xc6, 0xa7, 0x00, 0xb3, 0x01, 0xff, 0x45, 0x53, 0x05, - 0xb5, 0x01, 0x00, 0x49, 0x5e, 0xc1, 0x7f, 0x2c, 0x40, 0x48, 0x39, 0x2b, - 0x6b, 0x2c, 0x00, 0x03, 0x04, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x7b, - 0x01, 0x00, 0x45, 0x20, 0x07, 0x92, 0x1e, 0x40, 0x44, 0xee, 0x6c, 0x7d, - 0x01, 0x00, 0x49, 0xd0, 0x04, 0x90, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x06, - 0x43, 0x2c, 0x52, 0x1c, 0x02, 0x40, 0x45, 0x14, 0x39, 0xdd, 0x00, 0x00, - 0x4a, 0xcf, 0x04, 0x76, 0x01, 0x00, 0xa4, 0x2b, 0x45, 0x17, 0x23, 0xf2, - 0x1e, 0x00, 0x44, 0xac, 0x0e, 0xb3, 0x01, 0x80, 0x18, 0x44, 0x57, 0x85, - 0xfe, 0x1e, 0x00, 0x46, 0xb4, 0x70, 0x32, 0x02, 0x00, 0x46, 0x52, 0x05, - 0x4e, 0x02, 0x00, 0x45, 0x37, 0x23, 0xf8, 0x1e, 0x40, 0x46, 0x5b, 0x00, - 0xf6, 0x1e, 0x40, 0x48, 0xba, 0x23, 0x78, 0x01, 0x00, 0x03, 0x04, 0x0c, - 0x01, 0xff, 0x45, 0x5c, 0x00, 0x8e, 0x1e, 0x00, 0x45, 0x20, 0x07, 0xf4, - 0x1e, 0x40, 0x07, 0x82, 0x07, 0x01, 0xff, 0x48, 0xba, 0x23, 0x8c, 0x1e, - 0x00, 0x48, 0x57, 0x1e, 0x8a, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x06, 0x43, - 0x8a, 0xa4, 0xf7, 0x01, 0x40, 0x45, 0x14, 0x39, 0x82, 0x1e, 0x00, 0x4a, - 0xcf, 0x04, 0x74, 0x01, 0x00, 0xa4, 0x0c, 0x45, 0x17, 0x23, 0x80, 0x1e, - 0x00, 0x44, 0xac, 0x0e, 0x72, 0x2c, 0x40, 0x48, 0xba, 0x23, 0x84, 0x1e, - 0x00, 0x03, 0x04, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x86, 0x1e, 0x00, - 0x45, 0x20, 0x07, 0x88, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x26, 0x43, 0x40, - 0x05, 0x68, 0xa7, 0x00, 0x4b, 0xdb, 0x9d, 0x62, 0xa7, 0x00, 0x07, 0xf2, - 0xd3, 0x04, 0xf9, 0x60, 0xa7, 0x40, 0x42, 0x93, 0x0f, 0x9a, 0xa7, 0x00, - 0x42, 0x67, 0x51, 0x9c, 0xa7, 0x00, 0x42, 0xd6, 0x13, 0x9e, 0xa7, 0x40, - 0xa4, 0x0c, 0x44, 0xac, 0x0e, 0xb2, 0x01, 0x00, 0x45, 0x37, 0x23, 0x7c, - 0x1e, 0x40, 0x4e, 0xa9, 0x3f, 0x5e, 0xa7, 0x00, 0x48, 0xa0, 0x12, 0x7e, - 0x1e, 0x40, 0x80, 0x06, 0x46, 0xcf, 0x15, 0xb1, 0x01, 0x40, 0x43, 0x16, - 0x00, 0x44, 0x02, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, - 0xda, 0x00, 0x00, 0x45, 0x55, 0x23, 0x6c, 0x01, 0x00, 0xa3, 0xbd, 0x01, - 0xa4, 0x75, 0x45, 0x17, 0x23, 0xd9, 0x00, 0x00, 0x02, 0x0b, 0x00, 0x3b, - 0x4e, 0x60, 0x23, 0x16, 0x02, 0x00, 0x46, 0xb4, 0x70, 0x6a, 0x01, 0x80, - 0x28, 0x46, 0xda, 0xde, 0x72, 0x01, 0x00, 0x4a, 0x80, 0xb0, 0x6e, 0x01, - 0x00, 0x46, 0x52, 0x05, 0xb8, 0xa7, 0x00, 0x45, 0x37, 0x23, 0x68, 0x01, - 0xc0, 0x00, 0x80, 0x01, 0xff, 0x49, 0xb9, 0xa5, 0x78, 0x1e, 0x00, 0x45, - 0x20, 0x07, 0x74, 0x1e, 0x40, 0x4e, 0x4c, 0x75, 0x7a, 0x1e, 0x40, 0x48, - 0x5a, 0xab, 0xe6, 0x1e, 0x00, 0x42, 0x5e, 0x01, 0xaf, 0x01, 0xc0, 0x00, - 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0xe8, 0x1e, 0x00, 0x49, - 0x9f, 0x12, 0xf0, 0x1e, 0x00, 0x45, 0x17, 0x23, 0xea, 0x1e, 0x00, 0x4a, - 0x58, 0xab, 0xec, 0x1e, 0x00, 0x45, 0x37, 0x23, 0xee, 0x1e, 0x40, 0x48, - 0xba, 0x23, 0xdc, 0x00, 0x80, 0x1a, 0xaf, 0x01, 0xff, 0x47, 0xa1, 0x12, - 0xe4, 0x1e, 0x00, 0x05, 0x3d, 0x01, 0x01, 0xff, 0x45, 0x14, 0x39, 0x70, - 0x01, 0x00, 0x45, 0x17, 0x23, 0x14, 0x02, 0x40, 0x80, 0x01, 0xff, 0x04, - 0x1a, 0x00, 0x06, 0x45, 0x20, 0x07, 0x72, 0x1e, 0x40, 0x45, 0x14, 0x39, - 0xd7, 0x01, 0x00, 0x45, 0x09, 0x98, 0xd9, 0x01, 0x00, 0x45, 0x17, 0x23, - 0xdb, 0x01, 0x00, 0x46, 0xb4, 0x70, 0xd5, 0x01, 0x40, 0x44, 0xee, 0x6c, - 0xd3, 0x01, 0x00, 0x49, 0xd0, 0x04, 0xdb, 0x00, 0xc0, 0x00, 0x46, 0x1f, - 0x07, 0x76, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x61, 0x44, 0x7b, 0x2d, 0xde, - 0x00, 0x80, 0x4d, 0x04, 0x0e, 0x0b, 0x37, 0x47, 0x73, 0xd5, 0x2a, 0xa7, - 0x00, 0x06, 0x71, 0x07, 0x04, 0xfa, 0x28, 0xa7, 0x40, 0xe1, 0x6f, 0x2c, - 0x80, 0x1e, 0xe8, 0x8d, 0xa7, 0x00, 0x49, 0x1b, 0x70, 0x7e, 0xa7, 0x00, - 0xeb, 0xb0, 0xa7, 0x00, 0xec, 0x80, 0xa7, 0x00, 0xed, 0x9c, 0x01, 0x00, - 0xf4, 0xb1, 0xa7, 0x00, 0xf6, 0x45, 0x02, 0x40, 0x44, 0x5f, 0xe4, 0x70, - 0x2c, 0x40, 0x44, 0x80, 0x11, 0xbc, 0x01, 0x00, 0x43, 0x1b, 0x26, 0x84, - 0x01, 0x00, 0x43, 0x1f, 0x0a, 0xa7, 0x01, 0x40, 0x4c, 0xf5, 0x28, 0x64, - 0xa7, 0xc0, 0x00, 0x52, 0x2f, 0x2b, 0x66, 0xa7, 0x40, 0xa3, 0x31, 0xa4, - 0x18, 0x44, 0xac, 0x0e, 0xac, 0x01, 0x00, 0x4a, 0xa4, 0x6d, 0x6e, 0x1e, - 0x00, 0x4e, 0xa2, 0x0e, 0xae, 0x01, 0x00, 0x46, 0x52, 0x05, 0x66, 0x01, - 0x40, 0x4e, 0xa9, 0x3f, 0x3e, 0x02, 0x00, 0x03, 0x04, 0x0c, 0x01, 0xff, - 0x45, 0x5c, 0x00, 0x6a, 0x1e, 0x00, 0x45, 0x20, 0x07, 0x6c, 0x1e, 0x40, - 0x44, 0xee, 0x6c, 0x64, 0x01, 0x00, 0x46, 0x1b, 0xc2, 0x62, 0x01, 0x00, - 0x4f, 0xf8, 0x6e, 0x70, 0x1e, 0x00, 0x4a, 0xe6, 0xae, 0x1a, 0x02, 0x40, - 0x06, 0x50, 0x00, 0x31, 0x47, 0xce, 0xce, 0x8b, 0xa7, 0x00, 0xa3, 0x1d, - 0x46, 0x17, 0xb1, 0x9e, 0x1e, 0x00, 0x48, 0x11, 0xc7, 0xd8, 0xa7, 0x00, - 0x05, 0x5e, 0x07, 0x01, 0xff, 0x49, 0x2c, 0xb7, 0xae, 0xa7, 0x00, 0x50, - 0x1d, 0x66, 0x4a, 0x02, 0x40, 0x43, 0xcb, 0x7b, 0x8f, 0x01, 0x00, 0x46, - 0xd3, 0xca, 0xac, 0xa7, 0x40, 0x45, 0x14, 0x39, 0x5a, 0x01, 0x80, 0x5c, - 0xa3, 0x3b, 0xa4, 0x1b, 0x44, 0xac, 0x0e, 0xc5, 0xa7, 0x00, 0x4e, 0x55, - 0x43, 0xa8, 0xa7, 0x00, 0xb3, 0x01, 0xff, 0x53, 0xf7, 0x49, 0xc9, 0xa7, - 0x00, 0x49, 0x5e, 0xc1, 0x7e, 0x2c, 0x40, 0x4e, 0xa9, 0x3f, 0xcc, 0xa7, - 0x00, 0x03, 0x04, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x60, 0x1e, 0x00, - 0x45, 0x20, 0x07, 0x62, 0x1e, 0xc0, 0x00, 0x4e, 0x51, 0x1e, 0x68, 0x1e, - 0x40, 0x44, 0xee, 0x6c, 0x60, 0x01, 0x80, 0x12, 0x46, 0x1b, 0xc2, 0x5e, - 0x01, 0x00, 0x49, 0xd0, 0x04, 0x5c, 0x01, 0x00, 0x4a, 0xe6, 0xae, 0x18, - 0x02, 0x40, 0x4e, 0x51, 0x1e, 0x66, 0x1e, 0x40, 0x4e, 0x51, 0x1e, 0x64, - 0x1e, 0x40, 0x80, 0x26, 0x48, 0x69, 0xc3, 0xcb, 0xa7, 0x00, 0x08, 0xde, - 0x14, 0x06, 0x4a, 0xba, 0xb2, 0x5c, 0xa7, 0x40, 0x4a, 0x92, 0xa8, 0x3e, - 0xa7, 0x00, 0xe5, 0x8e, 0x01, 0x00, 0x46, 0x5e, 0xdc, 0xf5, 0xa7, 0x00, - 0x46, 0x39, 0x29, 0xab, 0xa7, 0x40, 0x47, 0xbd, 0xb2, 0x5a, 0xa7, 0x00, - 0x05, 0x51, 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0x54, 0x01, 0x00, 0xa3, - 0x3f, 0x02, 0x3b, 0x01, 0x1e, 0x4e, 0x60, 0x23, 0x12, 0x02, 0x00, 0x4a, - 0xa4, 0x6d, 0x5e, 0x1e, 0x00, 0x4e, 0x55, 0x43, 0xa6, 0xa7, 0x00, 0x46, - 0x52, 0x05, 0x4c, 0x02, 0x00, 0x44, 0x8f, 0x17, 0x64, 0x2c, 0x40, 0x02, - 0xc6, 0x00, 0x06, 0x4a, 0x12, 0x23, 0x10, 0x02, 0x40, 0x45, 0x5c, 0x00, - 0x58, 0x1e, 0x00, 0x45, 0x20, 0x07, 0x5a, 0x1e, 0xc0, 0x00, 0x4b, 0x74, - 0x97, 0x5c, 0x1e, 0x40, 0x44, 0xee, 0x6c, 0x58, 0x01, 0x00, 0x46, 0x1b, - 0xc2, 0x56, 0x01, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4f, 0xa8, 0x3f, - 0x58, 0xa7, 0x00, 0x58, 0x29, 0x2b, 0x56, 0xa7, 0x40, 0x06, 0x50, 0x00, - 0x06, 0x5a, 0x1c, 0x1d, 0xce, 0xa7, 0x40, 0x45, 0x14, 0x39, 0x54, 0x1e, - 0x00, 0x49, 0x56, 0x1e, 0x56, 0x1e, 0x00, 0x48, 0x51, 0xc6, 0x52, 0xa7, - 0x00, 0x44, 0xac, 0x0e, 0xa4, 0x01, 0x00, 0xb3, 0x01, 0xff, 0x4c, 0x20, - 0x94, 0x54, 0xa7, 0x00, 0x45, 0x53, 0x05, 0x63, 0x2c, 0xc0, 0x00, 0x52, - 0x2f, 0x2b, 0x50, 0xa7, 0x40, 0x06, 0x50, 0x00, 0x24, 0xe9, 0xa2, 0x01, - 0x00, 0x4b, 0x80, 0x9e, 0xc0, 0xa7, 0x00, 0x44, 0xe1, 0x7b, 0xb6, 0xa7, - 0x00, 0xef, 0x4e, 0xa7, 0x00, 0x04, 0xf7, 0x04, 0x04, 0xf5, 0x22, 0x02, - 0x40, 0xe5, 0x90, 0x01, 0x00, 0xef, 0x86, 0x01, 0x40, 0x45, 0x14, 0x39, - 0xd3, 0x00, 0x00, 0x45, 0x55, 0x23, 0x4e, 0x01, 0x00, 0xa3, 0xe3, 0x01, - 0xa4, 0xa8, 0x01, 0x45, 0x17, 0x23, 0xd2, 0x00, 0x00, 0x02, 0x0b, 0x00, - 0x6e, 0x4e, 0x60, 0x23, 0x0e, 0x02, 0x00, 0x02, 0x13, 0x01, 0x58, 0xad, - 0x38, 0x46, 0xda, 0xde, 0xea, 0x01, 0x80, 0x2b, 0x46, 0x52, 0x05, 0xd8, - 0x00, 0x80, 0x1e, 0x45, 0x37, 0x23, 0xd5, 0x00, 0xc0, 0x00, 0x05, 0x19, - 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0x4c, 0x1e, 0x00, 0x49, 0xb9, 0x23, - 0x4e, 0x1e, 0x00, 0x46, 0xb4, 0x70, 0x2c, 0x02, 0x40, 0x4a, 0xb8, 0xa5, - 0xfe, 0x01, 0x40, 0x4b, 0x74, 0x97, 0xec, 0x01, 0x40, 0x45, 0xb5, 0x70, - 0x4c, 0x01, 0x80, 0x06, 0x4b, 0x31, 0x23, 0x9f, 0x01, 0x40, 0x05, 0x19, - 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0x52, 0x1e, 0x00, 0x45, 0x17, 0x23, - 0x50, 0x1e, 0x40, 0x51, 0xcd, 0x5c, 0x4a, 0xa7, 0x00, 0x42, 0x1f, 0x00, - 0x4c, 0xa7, 0x40, 0x48, 0x5a, 0xab, 0xce, 0x1e, 0x00, 0x42, 0x5e, 0x01, - 0xa0, 0x01, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, - 0xda, 0x1e, 0x00, 0x49, 0x9f, 0x12, 0xe2, 0x1e, 0x00, 0x45, 0x17, 0x23, - 0xdc, 0x1e, 0x00, 0x4a, 0x58, 0xab, 0xde, 0x1e, 0x00, 0x45, 0x37, 0x23, - 0xe0, 0x1e, 0x40, 0x48, 0xba, 0x23, 0xd6, 0x00, 0x80, 0x2b, 0xaf, 0x01, - 0xff, 0x02, 0xc6, 0x00, 0x11, 0x05, 0x3d, 0x01, 0x01, 0xff, 0x45, 0x14, - 0x39, 0x50, 0x01, 0x00, 0x45, 0x17, 0x23, 0x0c, 0x02, 0x40, 0x45, 0x5c, - 0x00, 0x2e, 0x02, 0x80, 0x06, 0x45, 0x20, 0x07, 0xcc, 0x1e, 0x40, 0x4b, - 0x74, 0x97, 0x30, 0x02, 0x40, 0x4b, 0x74, 0x97, 0x2a, 0x02, 0x40, 0x44, - 0xee, 0x6c, 0xd1, 0x01, 0x00, 0x49, 0xd0, 0x04, 0xd4, 0x00, 0xc0, 0x00, - 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0xd0, 0x1e, 0x00, 0x49, - 0x9f, 0x12, 0xd8, 0x1e, 0x00, 0x45, 0x17, 0x23, 0xd2, 0x1e, 0x00, 0x4a, - 0x58, 0xab, 0xd4, 0x1e, 0x00, 0x45, 0x37, 0x23, 0xd6, 0x1e, 0x40, 0x06, - 0x50, 0x00, 0x04, 0xea, 0xca, 0x01, 0x40, 0x45, 0x14, 0x39, 0x43, 0x01, - 0x00, 0xa3, 0x45, 0xa4, 0x2c, 0x45, 0x17, 0x23, 0xf8, 0x01, 0x00, 0xac, - 0x12, 0x4e, 0x55, 0x43, 0xa4, 0xa7, 0x00, 0x4e, 0x68, 0x7c, 0xcb, 0x01, - 0x00, 0x45, 0x37, 0x23, 0xd1, 0x00, 0x40, 0x48, 0xb9, 0x57, 0x9d, 0x01, - 0x00, 0x49, 0xa5, 0x6d, 0x48, 0x1e, 0x00, 0x4d, 0x04, 0x87, 0x20, 0x02, - 0x40, 0x48, 0x39, 0x2b, 0x90, 0xa7, 0x00, 0x03, 0x04, 0x0c, 0x01, 0xff, + 0x03, 0x42, 0x02, 0x00, 0xf5, 0xbf, 0xa7, 0x40, 0x52, 0x41, 0x3d, 0x31, + 0xdf, 0x41, 0x45, 0x1c, 0x3b, 0xf5, 0x01, 0x00, 0x45, 0x8f, 0x24, 0x1f, + 0x01, 0x00, 0xa3, 0x2b, 0x49, 0x77, 0x1f, 0x21, 0x01, 0x00, 0x44, 0x5b, + 0x0f, 0x60, 0x02, 0x00, 0x46, 0xd1, 0x73, 0x21, 0x1e, 0x00, 0x4e, 0x71, + 0x45, 0xa1, 0xa7, 0x00, 0x4c, 0x47, 0x3d, 0x83, 0x1d, 0x00, 0x46, 0x52, + 0x05, 0xe5, 0x01, 0xc0, 0x00, 0x51, 0x80, 0x59, 0x45, 0xdf, 0x41, 0x44, + 0x0b, 0x70, 0xe7, 0x01, 0x00, 0x46, 0x2a, 0x98, 0x23, 0x01, 0x00, 0x49, + 0xd0, 0x04, 0x1d, 0x01, 0x40, 0x06, 0x50, 0x00, 0x0d, 0x4b, 0xd4, 0xa0, + 0xa9, 0x02, 0xc0, 0x00, 0x4b, 0x59, 0x9d, 0x00, 0xdf, 0x41, 0x49, 0x77, + 0x1f, 0x1f, 0x1e, 0x00, 0x44, 0x5b, 0x0f, 0x92, 0x01, 0x00, 0x4c, 0x6a, + 0x24, 0x6e, 0x1d, 0x00, 0x4c, 0x47, 0x3d, 0x82, 0x1d, 0x00, 0x46, 0x52, + 0x05, 0x99, 0xa7, 0x40, 0x06, 0x50, 0x00, 0x9e, 0x01, 0x0e, 0xc0, 0x7b, + 0x8d, 0x01, 0x42, 0x1d, 0x01, 0x4b, 0x01, 0x80, 0x75, 0x42, 0xa4, 0x02, + 0x83, 0x02, 0x80, 0x45, 0xf4, 0x6b, 0xa7, 0x80, 0x35, 0x42, 0xc2, 0x29, + 0x92, 0x02, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x48, 0x26, 0x14, 0xb9, 0x01, + 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0xa3, 0x12, 0x4c, 0x47, 0x3d, 0x18, + 0xdf, 0x01, 0x4e, 0x51, 0x0f, 0x9a, 0x1d, 0x00, 0x44, 0x79, 0x18, 0xba, + 0x01, 0x40, 0x44, 0x0b, 0x70, 0xef, 0x01, 0x00, 0x43, 0xdf, 0x0b, 0x93, + 0x02, 0x40, 0xe8, 0xf0, 0x00, 0xc0, 0x00, 0x52, 0x41, 0x3d, 0x2f, 0xdf, + 0x41, 0x06, 0x50, 0x00, 0x06, 0x4a, 0xe6, 0x9e, 0x62, 0xdf, 0x41, 0x44, + 0xde, 0x0b, 0x86, 0x02, 0x00, 0x4a, 0xe9, 0x52, 0x0b, 0xdf, 0x81, 0x0c, + 0x4c, 0x47, 0x3d, 0x8b, 0x1d, 0x00, 0x4e, 0x51, 0x0f, 0x98, 0x1d, 0x40, + 0x49, 0xba, 0xb9, 0x0c, 0xdf, 0x41, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4c, + 0x13, 0x52, 0x3c, 0xab, 0x00, 0x4c, 0x47, 0x3d, 0x14, 0xdf, 0x41, 0x42, + 0x9e, 0x01, 0x25, 0xa7, 0x00, 0x43, 0x68, 0x00, 0x23, 0xa7, 0x40, 0x45, + 0x1c, 0x3b, 0xe9, 0x00, 0x00, 0x45, 0x8f, 0x24, 0x15, 0x01, 0x00, 0xa3, + 0x76, 0xa4, 0x55, 0x48, 0xdf, 0xcb, 0x34, 0xab, 0x00, 0x45, 0x51, 0x24, + 0xe8, 0x00, 0x00, 0x4a, 0xb4, 0xb0, 0xbb, 0x1e, 0x00, 0x4e, 0x9a, 0x24, + 0x07, 0x02, 0x00, 0x46, 0xd1, 0x73, 0x13, 0x01, 0x80, 0x25, 0x45, 0xff, + 0x2b, 0x78, 0x2c, 0x00, 0x46, 0xb0, 0xe4, 0x19, 0x01, 0x00, 0x4e, 0x51, + 0x0f, 0x92, 0x1d, 0x00, 0x46, 0x52, 0x05, 0x47, 0x02, 0x00, 0x45, 0x71, + 0x24, 0xbd, 0x1e, 0xc0, 0x00, 0x46, 0x1f, 0x07, 0x1b, 0x1e, 0x40, 0x05, + 0x19, 0x00, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0x17, 0x1e, 0x00, 0x45, 0x51, + 0x24, 0x15, 0x1e, 0x40, 0x48, 0xf4, 0x24, 0xeb, 0x00, 0x00, 0xaf, 0x01, + 0xff, 0x02, 0xc6, 0x00, 0x06, 0x4a, 0x4c, 0x24, 0x05, 0x02, 0x40, 0x45, + 0x5c, 0x00, 0x17, 0x01, 0x00, 0x45, 0x20, 0x07, 0xb9, 0x1e, 0x40, 0x44, + 0x0b, 0x70, 0x1b, 0x01, 0x00, 0x46, 0x2a, 0x98, 0x29, 0x02, 0x80, 0x32, + 0x49, 0xd0, 0x04, 0xea, 0x00, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x04, 0x1a, + 0x00, 0x06, 0x45, 0x20, 0x07, 0x19, 0x1e, 0x40, 0x45, 0x1c, 0x3b, 0xbf, + 0x1e, 0x00, 0x49, 0x6d, 0x13, 0xc7, 0x1e, 0x00, 0x45, 0x51, 0x24, 0xc1, + 0x1e, 0x00, 0x4a, 0xb4, 0xb0, 0xc3, 0x1e, 0x00, 0x45, 0x71, 0x24, 0xc5, + 0x1e, 0x40, 0x4a, 0xf6, 0xaa, 0x1d, 0x1e, 0x40, 0x80, 0xac, 0x01, 0x8d, + 0x96, 0x01, 0x49, 0x03, 0xbc, 0x38, 0x02, 0x00, 0xa5, 0x6a, 0xaf, 0x32, + 0x42, 0x48, 0x04, 0x71, 0xa7, 0x00, 0xfa, 0xf3, 0x01, 0xc0, 0x00, 0x80, + 0x01, 0xff, 0x47, 0xe6, 0x4a, 0xa3, 0x02, 0x80, 0x06, 0x4a, 0x02, 0x9d, + 0xc6, 0x01, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x44, 0xde, 0x0b, 0xa5, + 0x02, 0x00, 0x4c, 0x47, 0x3d, 0x2e, 0xdf, 0x01, 0x4e, 0x51, 0x0f, 0x66, + 0xab, 0x40, 0x06, 0xb5, 0x43, 0x1c, 0x05, 0x3d, 0x01, 0x01, 0xff, 0xf2, + 0x48, 0xab, 0x80, 0x0c, 0x45, 0x5b, 0x4c, 0xd3, 0xa7, 0x00, 0x44, 0xb3, + 0xa9, 0xd5, 0xa7, 0x40, 0x52, 0x0d, 0x52, 0x4a, 0xab, 0x40, 0xe9, 0x31, + 0x01, 0x00, 0xea, 0x37, 0x02, 0xc0, 0x00, 0x4c, 0x78, 0x2a, 0x5f, 0x02, + 0xc0, 0x00, 0x49, 0xfc, 0x24, 0x84, 0x02, 0x40, 0x43, 0x6b, 0x1a, 0x9f, + 0x1e, 0x00, 0x4a, 0xda, 0x95, 0xa4, 0x02, 0xc0, 0x00, 0x06, 0x50, 0x00, + 0x01, 0xff, 0x44, 0xde, 0x0b, 0x2b, 0xdf, 0x01, 0x4c, 0x47, 0x3d, 0x12, + 0xdf, 0x01, 0x4e, 0x51, 0x0f, 0x19, 0xdf, 0x41, 0x4b, 0x21, 0xa1, 0x1f, + 0xdf, 0x01, 0x4c, 0xd8, 0x95, 0x20, 0xdf, 0xc1, 0x00, 0x54, 0x4b, 0x0f, + 0x21, 0xdf, 0x41, 0x65, 0x76, 0x08, 0x93, 0xdf, 0x01, 0x05, 0x51, 0x00, + 0x01, 0xff, 0xa3, 0x61, 0x04, 0x6f, 0x0c, 0x51, 0x44, 0x5b, 0x0f, 0x57, + 0x02, 0x80, 0x39, 0x4a, 0xc1, 0x70, 0x0f, 0x1e, 0x00, 0x03, 0x7d, 0x02, + 0x23, 0x4c, 0x47, 0x3d, 0x81, 0x1d, 0x00, 0xb3, 0x0f, 0xb4, 0x01, 0xff, + 0x43, 0x7a, 0x18, 0x56, 0x02, 0x00, 0x45, 0x5b, 0xaf, 0x8c, 0x01, 0x40, + 0x53, 0x3a, 0x4c, 0xc8, 0xa7, 0x00, 0x45, 0x53, 0x05, 0x11, 0x01, 0x40, + 0x51, 0x86, 0x46, 0x25, 0xdf, 0x01, 0x49, 0x6d, 0x24, 0x6d, 0x1d, 0x40, + 0x05, 0x19, 0x00, 0x01, 0xff, 0x4c, 0x47, 0x3d, 0x2d, 0xdf, 0x01, 0x44, + 0x79, 0x18, 0x91, 0x1d, 0x40, 0x45, 0x5c, 0x00, 0x0b, 0x1e, 0x00, 0x45, + 0x20, 0x07, 0x0d, 0x1e, 0x40, 0x44, 0x0b, 0x70, 0x0f, 0x01, 0x00, 0x46, + 0x2a, 0x98, 0x11, 0x1e, 0x00, 0x4f, 0x15, 0x72, 0x13, 0x1e, 0x00, 0x43, + 0xdf, 0x0b, 0x21, 0x02, 0x40, 0x06, 0x50, 0x00, 0x5a, 0x42, 0x49, 0x00, + 0x53, 0xab, 0x80, 0x38, 0x06, 0x82, 0x1c, 0x13, 0x42, 0x10, 0x00, 0x6f, + 0xa7, 0x00, 0x48, 0xa7, 0xd1, 0x2d, 0xa7, 0xc0, 0x00, 0x4b, 0x0c, 0x9d, + 0x2f, 0xa7, 0x40, 0x49, 0x56, 0xc0, 0xd1, 0xa7, 0x00, 0xaf, 0x06, 0x4f, + 0xb7, 0x75, 0x5e, 0x02, 0x40, 0x44, 0x99, 0x7f, 0x77, 0x02, 0x80, 0x06, + 0x45, 0xbd, 0x2a, 0x9a, 0x02, 0x40, 0x4f, 0x38, 0x6d, 0x75, 0xdf, 0x41, + 0x06, 0x50, 0x00, 0x01, 0xff, 0x04, 0x08, 0x05, 0x06, 0x4c, 0x47, 0x3d, + 0x3d, 0xdf, 0x41, 0x4a, 0x3a, 0xb2, 0x55, 0xab, 0x00, 0x4a, 0x81, 0x52, + 0x54, 0xab, 0x40, 0x45, 0x1c, 0x3b, 0x07, 0x01, 0x00, 0x43, 0x16, 0x00, + 0x93, 0xa7, 0x00, 0xa3, 0x36, 0x49, 0x77, 0x1f, 0x0b, 0x01, 0x00, 0x44, + 0x5b, 0x0f, 0x88, 0x01, 0x00, 0x02, 0x13, 0x01, 0x1a, 0x4c, 0x47, 0x3d, + 0x94, 0xa7, 0x00, 0xb2, 0x06, 0x46, 0x52, 0x05, 0x3c, 0x02, 0x40, 0x4d, + 0x52, 0x0f, 0x1d, 0xdf, 0x01, 0x49, 0xbd, 0xbf, 0x92, 0xdf, 0x41, 0x4c, + 0x24, 0x98, 0x91, 0xdf, 0x01, 0x47, 0x57, 0xdd, 0x90, 0xdf, 0x41, 0x44, + 0x0b, 0x70, 0x0d, 0x01, 0x00, 0x46, 0x2a, 0x98, 0xe7, 0x00, 0x80, 0x0c, + 0x49, 0xd0, 0x04, 0x09, 0x01, 0x00, 0x43, 0xdf, 0x0b, 0x55, 0x02, 0x40, + 0x4a, 0xe2, 0xaa, 0x09, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x9a, 0x01, 0xa1, + 0x2c, 0x43, 0x43, 0x10, 0xb5, 0xa7, 0x80, 0x1f, 0x0b, 0x68, 0xa3, 0x0c, + 0x4c, 0x60, 0x98, 0x17, 0x1d, 0x00, 0x47, 0x58, 0xdb, 0x47, 0xa7, 0x40, + 0xe5, 0x32, 0xab, 0x00, 0xef, 0x3d, 0xab, 0xc0, 0x00, 0x4c, 0x78, 0x2a, + 0x3e, 0xab, 0x40, 0x52, 0x41, 0x3d, 0x3b, 0xdf, 0x41, 0x05, 0xdb, 0x84, + 0x06, 0x4a, 0x86, 0xb6, 0x4d, 0xab, 0x40, 0xe1, 0x41, 0xdf, 0x81, 0x57, + 0xa3, 0x49, 0xe5, 0x33, 0xab, 0x80, 0x3e, 0xe8, 0x46, 0xdf, 0x81, 0x33, + 0xeb, 0x49, 0xdf, 0x01, 0xed, 0x4b, 0xdf, 0x81, 0x24, 0xee, 0x4e, 0xdf, + 0x01, 0xef, 0x75, 0x02, 0x80, 0x0e, 0x48, 0x8f, 0xd1, 0x3e, 0xdf, 0x01, + 0xf6, 0x52, 0xdf, 0x01, 0xf7, 0x3f, 0xdf, 0x41, 0x04, 0xf7, 0x04, 0x01, + 0xff, 0xe5, 0x44, 0xdf, 0x01, 0xef, 0x42, 0xdf, 0x41, 0x4a, 0x15, 0x26, + 0x4c, 0xdf, 0x41, 0x4a, 0x15, 0x26, 0x47, 0xdf, 0x41, 0x42, 0x1d, 0x01, + 0x4f, 0xdf, 0x41, 0x42, 0x49, 0x00, 0x54, 0xdf, 0x01, 0x4b, 0x31, 0x92, + 0x53, 0xdf, 0x41, 0x44, 0x40, 0xea, 0x30, 0xab, 0x40, 0x04, 0x6f, 0x0c, + 0x2a, 0x48, 0xdf, 0xcb, 0x97, 0xa7, 0x00, 0x44, 0x5b, 0x0f, 0x53, 0x02, + 0x00, 0x4a, 0xc1, 0x70, 0x07, 0x1e, 0x00, 0x4c, 0x6a, 0x24, 0x6c, 0x1d, + 0x00, 0x4c, 0x47, 0x3d, 0x80, 0x1d, 0x00, 0x46, 0x52, 0x05, 0x80, 0x01, + 0x00, 0x46, 0x5a, 0xaf, 0x83, 0x01, 0x40, 0x45, 0x5c, 0x00, 0x03, 0x1e, + 0x00, 0x45, 0x20, 0x07, 0x05, 0x1e, 0x40, 0x80, 0x44, 0xe1, 0x33, 0xa7, + 0x00, 0xe5, 0xe6, 0x00, 0x80, 0x2a, 0x44, 0x40, 0xea, 0x51, 0x02, 0x80, + 0x1d, 0x4a, 0xe8, 0xb3, 0xc3, 0xa7, 0x00, 0xef, 0x35, 0xa7, 0x00, 0xf5, + 0x37, 0xa7, 0x00, 0xf6, 0x39, 0xa7, 0x80, 0x04, 0xf9, 0x3d, 0xa7, 0x40, + 0x54, 0x0f, 0x42, 0x3b, 0xa7, 0x40, 0x54, 0x4b, 0x0f, 0x90, 0x1d, 0x40, + 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0xfd, 0x01, 0x00, 0x46, + 0xd1, 0x73, 0xe3, 0x01, 0x40, 0x4e, 0x78, 0x7f, 0x31, 0xab, 0x00, 0x05, + 0x51, 0x00, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0xe1, 0x00, 0x00, 0x45, 0x8f, + 0x24, 0x03, 0x01, 0x80, 0xb5, 0x01, 0xa3, 0x82, 0x01, 0xa4, 0x53, 0x45, + 0x51, 0x24, 0xe0, 0x00, 0x00, 0x4a, 0xb4, 0xb0, 0xa3, 0x1e, 0x00, 0x4e, + 0x9a, 0x24, 0x03, 0x02, 0x00, 0x46, 0xd1, 0x73, 0x01, 0x01, 0x00, 0x46, + 0xb0, 0xe4, 0x05, 0x01, 0x00, 0xb2, 0x0c, 0x46, 0x52, 0x05, 0x65, 0x2c, + 0x00, 0x45, 0x71, 0x24, 0xe3, 0x00, 0x40, 0x4d, 0x52, 0x0f, 0x8f, 0x1d, + 0x00, 0xa9, 0x01, 0xff, 0x4d, 0xc8, 0x75, 0x9a, 0x1e, 0x00, 0x03, 0xa2, + 0x01, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xe5, 0x00, 0x80, 0x06, 0x45, 0x20, + 0x07, 0x01, 0x1e, 0x40, 0x4a, 0xe2, 0xaa, 0xfb, 0x01, 0x40, 0x48, 0xf4, + 0x24, 0xe4, 0x00, 0x80, 0x20, 0xaf, 0x01, 0xff, 0x02, 0xc6, 0x00, 0x06, + 0x4a, 0x4c, 0x24, 0x01, 0x02, 0x40, 0x45, 0x5c, 0x00, 0x27, 0x02, 0x80, + 0x06, 0x45, 0x20, 0x07, 0xa1, 0x1e, 0x40, 0x4b, 0x5c, 0x9c, 0xe1, 0x01, + 0x40, 0x4b, 0x5c, 0x9c, 0xdf, 0x01, 0x40, 0x44, 0x0b, 0x70, 0xce, 0x01, + 0x00, 0x49, 0xd0, 0x04, 0xe2, 0x00, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, + 0xff, 0x45, 0x1c, 0x3b, 0xa5, 0x1e, 0x00, 0x49, 0x6d, 0x13, 0xad, 0x1e, + 0x00, 0x45, 0x51, 0x24, 0xa7, 0x1e, 0x00, 0x4a, 0xb4, 0xb0, 0xa9, 0x1e, + 0x00, 0x45, 0x71, 0x24, 0xab, 0x1e, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, + 0x45, 0x1c, 0x3b, 0xaf, 0x1e, 0x00, 0x49, 0x6d, 0x13, 0xb7, 0x1e, 0x00, + 0x45, 0x51, 0x24, 0xb1, 0x1e, 0x00, 0x4a, 0xb4, 0xb0, 0xb3, 0x1e, 0x00, + 0x45, 0x71, 0x24, 0xb5, 0x1e, 0x40, 0x4d, 0x00, 0x88, 0x7b, 0x1d, 0x00, + 0x4d, 0xfe, 0x8d, 0x7e, 0x1d, 0x40, 0xa1, 0xc4, 0x03, 0x02, 0xe5, 0x05, + 0xa8, 0x03, 0x4c, 0x90, 0x92, 0xc0, 0x01, 0x00, 0x4c, 0x6c, 0x2a, 0x94, + 0x02, 0x80, 0x89, 0x03, 0x55, 0x64, 0x3e, 0x96, 0x02, 0x80, 0xf0, 0x02, + 0x4d, 0x1e, 0x89, 0xc1, 0x01, 0x00, 0x5b, 0x21, 0x1e, 0x95, 0x02, 0x80, + 0xdc, 0x02, 0x02, 0x88, 0x00, 0xb9, 0x02, 0xb3, 0x18, 0x4f, 0x3d, 0x77, + 0xbb, 0x01, 0x00, 0x58, 0x6c, 0x2d, 0x24, 0x1d, 0x00, 0x44, 0xb3, 0xa9, + 0xbf, 0x01, 0x00, 0x42, 0x28, 0x23, 0xa6, 0x01, 0x40, 0x4e, 0x22, 0x7c, + 0x8f, 0xa7, 0x00, 0x0d, 0xea, 0x3e, 0x0d, 0x4a, 0xc6, 0xb7, 0x97, 0x02, + 0xc0, 0x00, 0x4a, 0xed, 0x4a, 0x0f, 0xdf, 0x41, 0xe1, 0x00, 0x1d, 0x80, + 0xfe, 0x01, 0xe2, 0x99, 0x02, 0x80, 0xeb, 0x01, 0xe3, 0x04, 0x1d, 0x00, + 0xe4, 0x05, 0x1d, 0x00, 0xe5, 0x07, 0x1d, 0x80, 0xd1, 0x01, 0xe6, 0x30, + 0xa7, 0x00, 0xe7, 0x62, 0x02, 0x80, 0xb6, 0x01, 0xe8, 0x9c, 0x02, 0x00, + 0xe9, 0x6a, 0x02, 0x80, 0x9f, 0x01, 0xea, 0x0a, 0x1d, 0x00, 0xeb, 0x0b, + 0x1d, 0x00, 0xec, 0x9f, 0x02, 0x80, 0x80, 0x01, 0xed, 0x0d, 0x1d, 0x00, + 0xee, 0x74, 0x02, 0x00, 0xef, 0x0f, 0x1d, 0x80, 0x65, 0xf0, 0x18, 0x1d, + 0x00, 0xf1, 0xaf, 0xa7, 0x00, 0xf2, 0x80, 0x02, 0x80, 0x36, 0xf3, 0x31, + 0xa7, 0x00, 0xf4, 0x1b, 0x1d, 0x80, 0x14, 0xf5, 0x1c, 0x1d, 0x00, 0xf6, + 0x20, 0x1d, 0x00, 0xf7, 0x21, 0x1d, 0x00, 0xf9, 0x8f, 0x02, 0x00, 0xfa, + 0x22, 0x1d, 0x40, 0x06, 0x71, 0x07, 0x01, 0xff, 0xe5, 0x7b, 0x2c, 0x00, + 0xe7, 0x02, 0xdf, 0x01, 0xeb, 0x10, 0xdf, 0x01, 0xed, 0xfa, 0xa7, 0x00, + 0xf2, 0x1a, 0x1d, 0x40, 0x06, 0x50, 0x00, 0x12, 0x08, 0xac, 0x15, 0x06, + 0x42, 0x48, 0x04, 0x76, 0xa7, 0x40, 0xee, 0x0e, 0x1d, 0x00, 0xf2, 0x19, + 0x1d, 0x40, 0x4c, 0x47, 0x3d, 0x35, 0xdf, 0x01, 0x49, 0xbf, 0x3a, 0x46, + 0xab, 0x40, 0xe5, 0x76, 0x02, 0x00, 0x45, 0xcb, 0xef, 0x10, 0x1d, 0x00, + 0xf5, 0x15, 0x1d, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x44, 0x5f, 0x32, + 0x04, 0xdf, 0x01, 0x46, 0x52, 0x05, 0x0c, 0x1d, 0x40, 0x49, 0x84, 0xc2, + 0x81, 0x02, 0xc0, 0x00, 0x52, 0x41, 0x3d, 0x36, 0xdf, 0x41, 0x06, 0x50, + 0x00, 0x01, 0xff, 0x44, 0x5b, 0x0f, 0x9b, 0x02, 0x00, 0x4c, 0x47, 0x3d, + 0x30, 0xdf, 0x41, 0x42, 0x53, 0x00, 0x06, 0x1d, 0x00, 0x42, 0xc2, 0x29, + 0x23, 0x1d, 0x40, 0x06, 0xda, 0x84, 0x01, 0xff, 0xe2, 0x03, 0x1d, 0x00, + 0xe5, 0x43, 0xdf, 0x41, 0xe5, 0x01, 0x1d, 0x40, 0x4d, 0x3e, 0x0f, 0xc3, + 0x01, 0x80, 0x11, 0x07, 0xad, 0x15, 0x01, 0xff, 0x48, 0x7f, 0xcb, 0xaa, + 0x01, 0x00, 0x58, 0x6c, 0x2a, 0xa2, 0x02, 0x40, 0x54, 0x4b, 0x0f, 0x0a, + 0xdf, 0x41, 0x52, 0x41, 0x3d, 0x3a, 0xdf, 0x41, 0x06, 0x50, 0x00, 0x01, + 0xff, 0x44, 0xde, 0x0b, 0x0e, 0xdf, 0x01, 0x46, 0x52, 0x05, 0xbe, 0x01, + 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4d, 0x46, 0x86, 0x56, 0xdf, 0x01, + 0x46, 0x52, 0x05, 0xa1, 0x02, 0x40, 0x51, 0x39, 0x5c, 0xad, 0x02, 0x00, + 0x07, 0x35, 0x88, 0x01, 0xff, 0x45, 0x46, 0x0f, 0x98, 0x02, 0x00, 0x4a, + 0x40, 0x5c, 0xac, 0x02, 0x40, 0x42, 0x9e, 0x01, 0x25, 0x1d, 0x00, 0x4d, + 0xa0, 0x89, 0xc2, 0x01, 0x40, 0x49, 0xcd, 0xbb, 0xff, 0xa7, 0x00, 0xa9, + 0x12, 0x09, 0xab, 0x15, 0x06, 0x4a, 0xae, 0xb6, 0xf7, 0xa7, 0x40, 0xe6, + 0xfb, 0xa7, 0x00, 0xf0, 0xfc, 0xa7, 0x40, 0x46, 0x1a, 0xde, 0xfe, 0xa7, + 0x00, 0x49, 0xc1, 0x5d, 0xfd, 0xa7, 0x40, 0x08, 0x0c, 0x06, 0x06, 0x44, + 0x8f, 0x08, 0x1d, 0x27, 0x40, 0x06, 0x14, 0x06, 0x11, 0x08, 0xde, 0x11, + 0x01, 0xff, 0x42, 0x0e, 0xcd, 0x32, 0x01, 0x00, 0x42, 0xce, 0x53, 0x52, + 0x01, 0x40, 0xe1, 0x41, 0x00, 0x80, 0xb8, 0x17, 0xe2, 0x42, 0x00, 0x80, + 0xdc, 0x16, 0xe3, 0x43, 0x00, 0x80, 0xe3, 0x15, 0xe4, 0x44, 0x00, 0x80, + 0xed, 0x14, 0xe5, 0x45, 0x00, 0x80, 0xe8, 0x12, 0xe6, 0x46, 0x00, 0x80, + 0xcb, 0x12, 0xe7, 0x47, 0x00, 0x80, 0xe0, 0x11, 0xe8, 0x48, 0x00, 0x80, + 0xff, 0x10, 0xe9, 0x49, 0x00, 0x80, 0xdc, 0x0f, 0xea, 0x4a, 0x00, 0x80, + 0xbd, 0x0f, 0xeb, 0x4b, 0x00, 0x80, 0xeb, 0x0e, 0xec, 0x4c, 0x00, 0x80, + 0xe6, 0x0d, 0xed, 0x4d, 0x00, 0x80, 0xa6, 0x0d, 0xee, 0x4e, 0x00, 0x80, + 0xb9, 0x0c, 0xef, 0x4f, 0x00, 0x80, 0xe3, 0x09, 0xf0, 0x50, 0x00, 0x80, + 0x85, 0x09, 0xf1, 0x51, 0x00, 0x80, 0xee, 0x08, 0xf2, 0x52, 0x00, 0x80, + 0xd0, 0x07, 0xf3, 0x53, 0x00, 0x80, 0x9e, 0x06, 0xf4, 0x54, 0x00, 0x80, + 0xe2, 0x04, 0xf5, 0x55, 0x00, 0x80, 0xd9, 0x02, 0xf6, 0x56, 0x00, 0x80, + 0x8f, 0x02, 0xf7, 0x57, 0x00, 0x80, 0xce, 0x01, 0xf8, 0x58, 0x00, 0x80, + 0xb7, 0x01, 0xf9, 0x59, 0x00, 0x80, 0x58, 0xfa, 0x5a, 0x00, 0xc0, 0x00, + 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0x79, 0x01, 0x00, 0xa3, + 0x3a, 0xa4, 0x21, 0x44, 0x5b, 0x0f, 0x24, 0x02, 0x00, 0x4a, 0xc1, 0x70, + 0x94, 0x1e, 0x00, 0x4c, 0x47, 0x3d, 0xc6, 0xa7, 0x00, 0xb3, 0x01, 0xff, + 0x45, 0x53, 0x05, 0xb5, 0x01, 0x00, 0x49, 0x0d, 0xc7, 0x7f, 0x2c, 0x40, + 0x48, 0xf3, 0x11, 0x6b, 0x2c, 0x00, 0x03, 0x70, 0x0c, 0x01, 0xff, 0x45, + 0x5c, 0x00, 0x7b, 0x01, 0x00, 0x45, 0x20, 0x07, 0x92, 0x1e, 0x40, 0x44, + 0x0b, 0x70, 0x7d, 0x01, 0x00, 0x49, 0xd0, 0x04, 0x90, 0x1e, 0x40, 0x06, + 0x50, 0x00, 0x06, 0x43, 0x81, 0x54, 0x1c, 0x02, 0x40, 0x45, 0x1c, 0x3b, + 0xdd, 0x00, 0x00, 0x4a, 0xcf, 0x04, 0x76, 0x01, 0x00, 0xa4, 0x2b, 0x45, + 0x51, 0x24, 0xf2, 0x1e, 0x00, 0x44, 0x5b, 0x0f, 0xb3, 0x01, 0x80, 0x18, + 0x44, 0x97, 0x08, 0xfe, 0x1e, 0x00, 0x46, 0xd1, 0x73, 0x32, 0x02, 0x00, + 0x46, 0x52, 0x05, 0x4e, 0x02, 0x00, 0x45, 0x71, 0x24, 0xf8, 0x1e, 0x40, + 0x46, 0x5b, 0x00, 0xf6, 0x1e, 0x40, 0x48, 0xf4, 0x24, 0x78, 0x01, 0x00, + 0x03, 0x70, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x8e, 0x1e, 0x00, 0x45, + 0x20, 0x07, 0xf4, 0x1e, 0x40, 0x07, 0x82, 0x07, 0x01, 0xff, 0x48, 0xf4, + 0x24, 0x8c, 0x1e, 0x00, 0x48, 0x78, 0x1f, 0x8a, 0x1e, 0x40, 0x06, 0x50, + 0x00, 0x06, 0x43, 0xb4, 0xa9, 0xf7, 0x01, 0x40, 0x45, 0x1c, 0x3b, 0x82, + 0x1e, 0x00, 0x4a, 0xcf, 0x04, 0x74, 0x01, 0x00, 0xa4, 0x0c, 0x45, 0x51, + 0x24, 0x80, 0x1e, 0x00, 0x44, 0x5b, 0x0f, 0x72, 0x2c, 0x40, 0x48, 0xf4, + 0x24, 0x84, 0x1e, 0x00, 0x03, 0x70, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, + 0x86, 0x1e, 0x00, 0x45, 0x20, 0x07, 0x88, 0x1e, 0x40, 0x06, 0x50, 0x00, + 0x26, 0x43, 0x40, 0x05, 0x68, 0xa7, 0x00, 0x4b, 0xe4, 0xa2, 0x62, 0xa7, + 0x00, 0x07, 0xbb, 0xd9, 0x04, 0xf9, 0x60, 0xa7, 0x40, 0x42, 0x42, 0x10, + 0x9a, 0xa7, 0x00, 0x42, 0xce, 0x53, 0x9c, 0xa7, 0x00, 0x42, 0x5c, 0x0a, + 0x9e, 0xa7, 0x40, 0xa4, 0x0c, 0x44, 0x5b, 0x0f, 0xb2, 0x01, 0x00, 0x45, + 0x71, 0x24, 0x7c, 0x1e, 0x40, 0x4e, 0xb1, 0x41, 0x5e, 0xa7, 0x00, 0x48, + 0x6e, 0x13, 0x7e, 0x1e, 0x40, 0x80, 0x06, 0x46, 0x9d, 0x16, 0xb1, 0x01, + 0x40, 0x43, 0x16, 0x00, 0x44, 0x02, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, + 0x45, 0x1c, 0x3b, 0xda, 0x00, 0x00, 0x45, 0x8f, 0x24, 0x6c, 0x01, 0x00, + 0xa3, 0xce, 0x01, 0xa4, 0x85, 0x01, 0x45, 0x51, 0x24, 0xd9, 0x00, 0x00, + 0x02, 0x0b, 0x00, 0x41, 0x4e, 0x9a, 0x24, 0x16, 0x02, 0x00, 0x46, 0xd1, + 0x73, 0x6a, 0x01, 0x80, 0x2e, 0x4f, 0x04, 0x74, 0x7c, 0xdf, 0x01, 0x46, + 0xb0, 0xe4, 0x72, 0x01, 0x00, 0x4a, 0xfa, 0xb5, 0x6e, 0x01, 0x00, 0x46, + 0x52, 0x05, 0xb8, 0xa7, 0x00, 0x45, 0x71, 0x24, 0x68, 0x01, 0xc0, 0x00, + 0x80, 0x01, 0xff, 0x49, 0xe3, 0xaa, 0x78, 0x1e, 0x00, 0x45, 0x20, 0x07, + 0x74, 0x1e, 0x40, 0x4e, 0x78, 0x78, 0x7a, 0x1e, 0x40, 0x03, 0x7f, 0x15, + 0x2a, 0x42, 0x5e, 0x01, 0xaf, 0x01, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, + 0xff, 0x45, 0x1c, 0x3b, 0xe8, 0x1e, 0x00, 0x49, 0x6d, 0x13, 0xf0, 0x1e, + 0x00, 0x45, 0x51, 0x24, 0xea, 0x1e, 0x00, 0x4a, 0xb4, 0xb0, 0xec, 0x1e, + 0x00, 0x45, 0x71, 0x24, 0xee, 0x1e, 0x40, 0x45, 0x5c, 0x00, 0xe6, 0x1e, + 0x00, 0x44, 0x79, 0x18, 0x7a, 0xdf, 0x41, 0x48, 0xf4, 0x24, 0xdc, 0x00, + 0x80, 0x1a, 0xaf, 0x01, 0xff, 0x47, 0x6f, 0x13, 0xe4, 0x1e, 0x00, 0x05, + 0x3d, 0x01, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0x70, 0x01, 0x00, 0x45, 0x51, + 0x24, 0x14, 0x02, 0x40, 0x80, 0x01, 0xff, 0x04, 0x1a, 0x00, 0x06, 0x45, + 0x20, 0x07, 0x72, 0x1e, 0x40, 0x45, 0x1c, 0x3b, 0xd7, 0x01, 0x00, 0x45, + 0x07, 0x9d, 0xd9, 0x01, 0x00, 0x45, 0x51, 0x24, 0xdb, 0x01, 0x00, 0x46, + 0xd1, 0x73, 0xd5, 0x01, 0x40, 0x44, 0x0b, 0x70, 0xd3, 0x01, 0x00, 0x49, + 0xd0, 0x04, 0xdb, 0x00, 0xc0, 0x00, 0x46, 0x1f, 0x07, 0x76, 0x1e, 0x40, + 0x06, 0x50, 0x00, 0x67, 0x44, 0xe7, 0x2e, 0xde, 0x00, 0x80, 0x53, 0x04, + 0x7a, 0x0b, 0x3d, 0x47, 0x3c, 0xdb, 0x2a, 0xa7, 0x00, 0x06, 0x71, 0x07, + 0x04, 0xfa, 0x28, 0xa7, 0x40, 0xe1, 0x6f, 0x2c, 0x80, 0x24, 0x4c, 0x30, + 0x92, 0x76, 0xdf, 0x01, 0xe8, 0x8d, 0xa7, 0x00, 0x49, 0x56, 0xc0, 0x7e, + 0xa7, 0x00, 0xeb, 0xb0, 0xa7, 0x00, 0xec, 0x80, 0xa7, 0x00, 0xed, 0x9c, + 0x01, 0x00, 0xf4, 0xb1, 0xa7, 0x00, 0xf6, 0x45, 0x02, 0x40, 0x44, 0x40, + 0xea, 0x70, 0x2c, 0x40, 0x44, 0x4e, 0x12, 0xbc, 0x01, 0x00, 0x43, 0x08, + 0x24, 0x84, 0x01, 0x00, 0x43, 0x44, 0x0a, 0xa7, 0x01, 0x40, 0x4c, 0x78, + 0x2a, 0x64, 0xa7, 0xc0, 0x00, 0x52, 0xb2, 0x2c, 0x66, 0xa7, 0x40, 0xa3, + 0x31, 0xa4, 0x18, 0x44, 0x5b, 0x0f, 0xac, 0x01, 0x00, 0x4a, 0xc1, 0x70, + 0x6e, 0x1e, 0x00, 0x4e, 0x51, 0x0f, 0xae, 0x01, 0x00, 0x46, 0x52, 0x05, + 0x66, 0x01, 0x40, 0x4e, 0xb1, 0x41, 0x3e, 0x02, 0x00, 0x03, 0x70, 0x0c, + 0x01, 0xff, 0x45, 0x5c, 0x00, 0x6a, 0x1e, 0x00, 0x45, 0x20, 0x07, 0x6c, + 0x1e, 0x40, 0x44, 0x0b, 0x70, 0x64, 0x01, 0x00, 0x46, 0x2a, 0x98, 0x62, + 0x01, 0x00, 0x4f, 0x15, 0x72, 0x70, 0x1e, 0x00, 0x4a, 0x4c, 0xb4, 0x1a, + 0x02, 0x40, 0x06, 0x50, 0x00, 0x3f, 0x47, 0x74, 0xd4, 0x8b, 0xa7, 0x00, + 0xa3, 0x1d, 0x46, 0x9b, 0xb6, 0x9e, 0x1e, 0x00, 0x48, 0x97, 0xcc, 0xd8, + 0xa7, 0x00, 0x05, 0x5e, 0x07, 0x01, 0xff, 0x49, 0x9c, 0xbc, 0xae, 0xa7, + 0x00, 0x50, 0x2a, 0x69, 0x4a, 0x02, 0x40, 0x43, 0x83, 0x7f, 0x8f, 0x01, + 0x00, 0x05, 0x76, 0x06, 0x01, 0xff, 0xe7, 0xac, 0xa7, 0x00, 0xf2, 0x6c, + 0xab, 0xc0, 0x00, 0x4a, 0xdc, 0xab, 0x6d, 0xab, 0x40, 0x45, 0x1c, 0x3b, + 0x5a, 0x01, 0x80, 0x5c, 0xa3, 0x3b, 0xa4, 0x1b, 0x44, 0x5b, 0x0f, 0xc5, + 0xa7, 0x00, 0x4e, 0x71, 0x45, 0xa8, 0xa7, 0x00, 0xb3, 0x01, 0xff, 0x53, + 0x3a, 0x4c, 0xc9, 0xa7, 0x00, 0x49, 0x0d, 0xc7, 0x7e, 0x2c, 0x40, 0x4e, + 0xb1, 0x41, 0xcc, 0xa7, 0x00, 0x03, 0x70, 0x0c, 0x01, 0xff, 0x45, 0x5c, + 0x00, 0x60, 0x1e, 0x00, 0x45, 0x20, 0x07, 0x62, 0x1e, 0xc0, 0x00, 0x4e, + 0x72, 0x1f, 0x68, 0x1e, 0x40, 0x44, 0x0b, 0x70, 0x60, 0x01, 0x80, 0x12, + 0x46, 0x2a, 0x98, 0x5e, 0x01, 0x00, 0x49, 0xd0, 0x04, 0x5c, 0x01, 0x00, + 0x4a, 0x4c, 0xb4, 0x18, 0x02, 0x40, 0x4e, 0x72, 0x1f, 0x66, 0x1e, 0x40, + 0x4e, 0x72, 0x1f, 0x64, 0x1e, 0x40, 0x80, 0x30, 0x48, 0xf7, 0xc8, 0xcb, + 0xa7, 0x00, 0x08, 0xac, 0x15, 0x06, 0x4a, 0x34, 0xb8, 0x5c, 0xa7, 0x40, + 0x4a, 0xd0, 0xad, 0x3e, 0xa7, 0x00, 0xe5, 0x8e, 0x01, 0x00, 0x46, 0x2e, + 0xe2, 0xf5, 0xa7, 0x00, 0x46, 0xbc, 0x2a, 0xab, 0xa7, 0x00, 0x47, 0xa5, + 0xdb, 0x6c, 0xdf, 0x01, 0xf5, 0x7e, 0xdf, 0x41, 0x47, 0x76, 0x08, 0x5a, + 0xa7, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0x54, 0x01, + 0x00, 0xa3, 0x47, 0x02, 0x3b, 0x01, 0x26, 0x4e, 0x9a, 0x24, 0x12, 0x02, + 0x00, 0xac, 0x12, 0x4e, 0x71, 0x45, 0xa6, 0xa7, 0x00, 0x46, 0x52, 0x05, + 0x4c, 0x02, 0x00, 0x44, 0x79, 0x18, 0x64, 0x2c, 0x40, 0x49, 0xc2, 0x70, + 0x5e, 0x1e, 0x00, 0x47, 0xd3, 0x78, 0xe2, 0xa7, 0x40, 0x02, 0xc6, 0x00, + 0x06, 0x4a, 0x4c, 0x24, 0x10, 0x02, 0x40, 0x45, 0x5c, 0x00, 0x58, 0x1e, + 0x00, 0x45, 0x20, 0x07, 0x5a, 0x1e, 0xc0, 0x00, 0x4b, 0x5c, 0x9c, 0x5c, + 0x1e, 0x40, 0x44, 0x0b, 0x70, 0x58, 0x01, 0x00, 0x46, 0x2a, 0x98, 0x56, + 0x01, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4f, 0xb0, 0x41, 0x58, 0xa7, + 0x00, 0x58, 0xac, 0x2c, 0x56, 0xa7, 0x40, 0x06, 0x50, 0x00, 0x26, 0xa8, + 0x01, 0xff, 0x59, 0x23, 0x1e, 0xce, 0xa7, 0x00, 0x09, 0x0b, 0xc3, 0x01, + 0xff, 0x4c, 0x8c, 0x90, 0x68, 0xdf, 0x01, 0x4c, 0xb4, 0x92, 0x6e, 0xdf, + 0x01, 0x4a, 0x40, 0xb6, 0x6a, 0xdf, 0x01, 0x42, 0x53, 0x00, 0x78, 0xdf, + 0x41, 0x45, 0x1c, 0x3b, 0x54, 0x1e, 0x00, 0x49, 0x77, 0x1f, 0x56, 0x1e, + 0x00, 0x48, 0xdf, 0xcb, 0x52, 0xa7, 0x00, 0x44, 0x5b, 0x0f, 0xa4, 0x01, + 0x00, 0xb3, 0x01, 0xff, 0x4c, 0xf0, 0x98, 0x54, 0xa7, 0x00, 0x45, 0x53, + 0x05, 0x63, 0x2c, 0xc0, 0x00, 0x52, 0xb2, 0x2c, 0x50, 0xa7, 0x40, 0x06, + 0x50, 0x00, 0x24, 0xe9, 0xa2, 0x01, 0x00, 0x4b, 0x89, 0xa3, 0xc0, 0xa7, + 0x00, 0x44, 0x99, 0x7f, 0xb6, 0xa7, 0x00, 0xef, 0x4e, 0xa7, 0x00, 0x04, + 0xf7, 0x04, 0x04, 0xf5, 0x22, 0x02, 0x40, 0xe5, 0x90, 0x01, 0x00, 0xef, + 0x86, 0x01, 0x40, 0x45, 0x1c, 0x3b, 0xd3, 0x00, 0x00, 0x45, 0x8f, 0x24, + 0x4e, 0x01, 0x00, 0xa3, 0xe3, 0x01, 0xa4, 0xa8, 0x01, 0x45, 0x51, 0x24, + 0xd2, 0x00, 0x00, 0x02, 0x0b, 0x00, 0x6e, 0x4e, 0x9a, 0x24, 0x0e, 0x02, + 0x00, 0x02, 0x13, 0x01, 0x58, 0xad, 0x38, 0x46, 0xb0, 0xe4, 0xea, 0x01, + 0x80, 0x2b, 0x46, 0x52, 0x05, 0xd8, 0x00, 0x80, 0x1e, 0x45, 0x71, 0x24, + 0xd5, 0x00, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x1c, 0x3b, + 0x4c, 0x1e, 0x00, 0x49, 0xf3, 0x24, 0x4e, 0x1e, 0x00, 0x46, 0xd1, 0x73, + 0x2c, 0x02, 0x40, 0x4a, 0xe2, 0xaa, 0xfe, 0x01, 0x40, 0x4b, 0x5c, 0x9c, + 0xec, 0x01, 0x40, 0x45, 0xd2, 0x73, 0x4c, 0x01, 0x80, 0x06, 0x4b, 0x6b, + 0x24, 0x9f, 0x01, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x1c, 0x3b, + 0x52, 0x1e, 0x00, 0x45, 0x51, 0x24, 0x50, 0x1e, 0x40, 0x51, 0x58, 0x5f, + 0x4a, 0xa7, 0x00, 0x42, 0x1f, 0x00, 0x4c, 0xa7, 0x40, 0x48, 0xb6, 0xb0, + 0xce, 0x1e, 0x00, 0x42, 0x5e, 0x01, 0xa0, 0x01, 0xc0, 0x00, 0x05, 0x19, + 0x00, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0xda, 0x1e, 0x00, 0x49, 0x6d, 0x13, + 0xe2, 0x1e, 0x00, 0x45, 0x51, 0x24, 0xdc, 0x1e, 0x00, 0x4a, 0xb4, 0xb0, + 0xde, 0x1e, 0x00, 0x45, 0x71, 0x24, 0xe0, 0x1e, 0x40, 0x48, 0xf4, 0x24, + 0xd6, 0x00, 0x80, 0x2b, 0xaf, 0x01, 0xff, 0x02, 0xc6, 0x00, 0x11, 0x05, + 0x3d, 0x01, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0x50, 0x01, 0x00, 0x45, 0x51, + 0x24, 0x0c, 0x02, 0x40, 0x45, 0x5c, 0x00, 0x2e, 0x02, 0x80, 0x06, 0x45, + 0x20, 0x07, 0xcc, 0x1e, 0x40, 0x4b, 0x5c, 0x9c, 0x30, 0x02, 0x40, 0x4b, + 0x5c, 0x9c, 0x2a, 0x02, 0x40, 0x44, 0x0b, 0x70, 0xd1, 0x01, 0x00, 0x49, + 0xd0, 0x04, 0xd4, 0x00, 0x80, 0x06, 0x43, 0xdf, 0x0b, 0x72, 0xdf, 0x41, + 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0xd0, 0x1e, 0x00, 0x49, + 0x6d, 0x13, 0xd8, 0x1e, 0x00, 0x45, 0x51, 0x24, 0xd2, 0x1e, 0x00, 0x4a, + 0xb4, 0xb0, 0xd4, 0x1e, 0x00, 0x45, 0x71, 0x24, 0xd6, 0x1e, 0x40, 0x06, + 0x50, 0x00, 0x04, 0xea, 0xca, 0x01, 0x40, 0x45, 0x1c, 0x3b, 0x43, 0x01, + 0x00, 0xa3, 0x45, 0xa4, 0x2c, 0x45, 0x51, 0x24, 0xf8, 0x01, 0x00, 0xac, + 0x12, 0x4e, 0x71, 0x45, 0xa4, 0xa7, 0x00, 0x4e, 0x2e, 0x80, 0xcb, 0x01, + 0x00, 0x45, 0x71, 0x24, 0xd1, 0x00, 0x40, 0x48, 0x8f, 0x46, 0x9d, 0x01, + 0x00, 0x49, 0xc2, 0x70, 0x48, 0x1e, 0x00, 0x4d, 0x4d, 0x8b, 0x20, 0x02, + 0x40, 0x48, 0xf3, 0x11, 0x90, 0xa7, 0x00, 0x03, 0x70, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x44, 0x1e, 0x00, 0x45, 0x20, 0x07, 0x46, 0x1e, 0x40, - 0x44, 0xee, 0x6c, 0x47, 0x01, 0x00, 0x46, 0x1b, 0xc2, 0x45, 0x01, 0x00, - 0x4f, 0xf8, 0x6e, 0x4a, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x1a, 0x05, 0x7e, - 0x02, 0x01, 0xff, 0x48, 0xa9, 0xc2, 0xd6, 0xa7, 0x00, 0x07, 0x03, 0xce, + 0x44, 0x0b, 0x70, 0x47, 0x01, 0x00, 0x46, 0x2a, 0x98, 0x45, 0x01, 0x00, + 0x4f, 0x15, 0x72, 0x4a, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x1a, 0x05, 0x7e, + 0x02, 0x01, 0xff, 0x48, 0x3f, 0xc8, 0xd6, 0xa7, 0x00, 0x07, 0xa9, 0xd3, 0x01, 0xff, 0x42, 0x60, 0x07, 0xfa, 0x1e, 0x00, 0xf6, 0xfc, 0x1e, 0x40, - 0x45, 0x14, 0x39, 0x3e, 0x1e, 0x00, 0x04, 0x03, 0x0c, 0x06, 0x44, 0xac, - 0x0e, 0x6e, 0x2c, 0x40, 0x45, 0x5c, 0x00, 0x40, 0x1e, 0x00, 0x45, 0x20, - 0x07, 0x42, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x11, 0x45, 0x63, 0xe4, 0xda, - 0xa7, 0x80, 0x04, 0xea, 0xc7, 0x01, 0x40, 0x4c, 0xf5, 0x28, 0xdc, 0xa7, - 0x40, 0x45, 0x14, 0x39, 0x39, 0x01, 0x00, 0xa2, 0x56, 0xa3, 0x42, 0x02, - 0x3b, 0x01, 0x2b, 0x4b, 0x0a, 0x9d, 0x48, 0xa7, 0x00, 0x4a, 0xa4, 0x6d, - 0x3a, 0x1e, 0x00, 0x07, 0x7d, 0x02, 0x0f, 0xb3, 0x01, 0xff, 0x4d, 0x69, - 0x7c, 0xc8, 0x01, 0x00, 0x45, 0x53, 0x05, 0x41, 0x01, 0x40, 0x43, 0x23, - 0x0a, 0x3f, 0x01, 0x00, 0x45, 0x37, 0x23, 0x62, 0x2c, 0x40, 0x47, 0xa1, - 0x12, 0x36, 0x1e, 0x80, 0x06, 0x48, 0x84, 0xa9, 0x60, 0x2c, 0x40, 0x4b, - 0x74, 0x97, 0x38, 0x1e, 0x40, 0x44, 0xee, 0x6c, 0x3d, 0x01, 0x00, 0x46, - 0x1b, 0xc2, 0x3b, 0x01, 0x00, 0x4f, 0xf8, 0x6e, 0x3c, 0x1e, 0x40, 0x42, - 0x17, 0x00, 0x3d, 0x02, 0x00, 0x43, 0xfe, 0xa3, 0xad, 0xa7, 0x40, 0x06, - 0x50, 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0x30, 0x1e, 0x00, 0xa3, 0x33, - 0xa4, 0x1f, 0x44, 0xac, 0x0e, 0x98, 0x01, 0x00, 0x4a, 0xa4, 0x6d, 0x34, - 0x1e, 0x00, 0x4e, 0x55, 0x43, 0xa2, 0xa7, 0x00, 0x46, 0x52, 0x05, 0x40, - 0xa7, 0xc0, 0x00, 0x54, 0xa3, 0x3f, 0x44, 0xa7, 0x40, 0x48, 0x39, 0x2b, - 0x69, 0x2c, 0x00, 0x4e, 0xa9, 0x3f, 0x42, 0xa7, 0x00, 0x48, 0xa0, 0x12, - 0x32, 0x1e, 0x40, 0x44, 0xee, 0x6c, 0xe8, 0x01, 0x00, 0x46, 0x1b, 0xc2, + 0x45, 0x1c, 0x3b, 0x3e, 0x1e, 0x00, 0x04, 0x6f, 0x0c, 0x06, 0x44, 0x5b, + 0x0f, 0x6e, 0x2c, 0x40, 0x45, 0x5c, 0x00, 0x40, 0x1e, 0x00, 0x45, 0x20, + 0x07, 0x42, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x11, 0x45, 0x44, 0xea, 0xda, + 0xa7, 0x80, 0x04, 0xea, 0xc7, 0x01, 0x40, 0x4c, 0x78, 0x2a, 0xdc, 0xa7, + 0x40, 0x45, 0x1c, 0x3b, 0x39, 0x01, 0x00, 0xa2, 0x56, 0xa3, 0x42, 0x02, + 0x3b, 0x01, 0x2b, 0x4b, 0x1e, 0xa2, 0x48, 0xa7, 0x00, 0x4a, 0xc1, 0x70, + 0x3a, 0x1e, 0x00, 0x07, 0x7d, 0x02, 0x0f, 0xb3, 0x01, 0xff, 0x4d, 0x2f, + 0x80, 0xc8, 0x01, 0x00, 0x45, 0x53, 0x05, 0x41, 0x01, 0x40, 0x43, 0x48, + 0x0a, 0x3f, 0x01, 0x00, 0x45, 0x71, 0x24, 0x62, 0x2c, 0x40, 0x47, 0x6f, + 0x13, 0x36, 0x1e, 0x80, 0x06, 0x48, 0xeb, 0x52, 0x60, 0x2c, 0x40, 0x4b, + 0x5c, 0x9c, 0x38, 0x1e, 0x40, 0x44, 0x0b, 0x70, 0x3d, 0x01, 0x00, 0x46, + 0x2a, 0x98, 0x3b, 0x01, 0x00, 0x4f, 0x15, 0x72, 0x3c, 0x1e, 0x40, 0x42, + 0x17, 0x00, 0x3d, 0x02, 0x00, 0x43, 0x60, 0x32, 0xad, 0xa7, 0x40, 0x06, + 0x50, 0x00, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0x30, 0x1e, 0x00, 0xa3, 0x33, + 0xa4, 0x1f, 0x44, 0x5b, 0x0f, 0x98, 0x01, 0x00, 0x4a, 0xc1, 0x70, 0x34, + 0x1e, 0x00, 0x4e, 0x71, 0x45, 0xa2, 0xa7, 0x00, 0x46, 0x52, 0x05, 0x40, + 0xa7, 0xc0, 0x00, 0x54, 0xab, 0x41, 0x44, 0xa7, 0x40, 0x48, 0xf3, 0x11, + 0x69, 0x2c, 0x00, 0x4e, 0xb1, 0x41, 0x42, 0xa7, 0x00, 0x48, 0x6e, 0x13, + 0x32, 0x1e, 0x40, 0x44, 0x0b, 0x70, 0xe8, 0x01, 0x00, 0x46, 0x2a, 0x98, 0x36, 0x01, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0xa3, 0x06, 0x46, 0x52, - 0x05, 0x48, 0x02, 0x40, 0x49, 0xd0, 0x04, 0x34, 0x01, 0x00, 0x4b, 0xd1, - 0x4f, 0xb2, 0xa7, 0x40, 0x06, 0x50, 0x00, 0x26, 0x07, 0x1c, 0x70, 0x0a, + 0x05, 0x48, 0x02, 0x40, 0x49, 0xd0, 0x04, 0x34, 0x01, 0x00, 0x4b, 0x14, + 0x52, 0xb2, 0xa7, 0x40, 0x06, 0x50, 0x00, 0x26, 0x07, 0x57, 0xc0, 0x0a, 0x43, 0x1b, 0x05, 0x96, 0x01, 0x00, 0xf3, 0x6c, 0xa7, 0x40, 0xe4, 0x79, 0xa7, 0x00, 0xe6, 0x7b, 0xa7, 0x00, 0xe7, 0x7d, 0xa7, 0x00, 0xf2, 0x82, - 0xa7, 0x00, 0xf3, 0x84, 0xa7, 0x00, 0xf4, 0x86, 0xa7, 0x40, 0x45, 0x14, - 0x39, 0xcd, 0x00, 0x00, 0x45, 0x55, 0x23, 0x2c, 0x01, 0x00, 0xa3, 0x59, - 0xa4, 0x31, 0x45, 0x17, 0x23, 0xcc, 0x00, 0x00, 0x4a, 0x58, 0xab, 0xc8, - 0x1e, 0x00, 0x4e, 0x60, 0x23, 0x0a, 0x02, 0x00, 0x46, 0xb4, 0x70, 0x2a, - 0x01, 0x00, 0x46, 0xda, 0xde, 0x2e, 0x01, 0x00, 0x46, 0x52, 0x05, 0x97, - 0x01, 0x00, 0x45, 0x37, 0x23, 0x28, 0x01, 0xc0, 0x00, 0x46, 0x1f, 0x07, - 0x2c, 0x1e, 0x40, 0x48, 0xba, 0x23, 0xcf, 0x00, 0x80, 0x19, 0xaf, 0x01, - 0xff, 0x02, 0xc6, 0x00, 0x06, 0x4a, 0x12, 0x23, 0x08, 0x02, 0x40, 0x45, + 0xa7, 0x00, 0xf3, 0x84, 0xa7, 0x00, 0xf4, 0x86, 0xa7, 0x40, 0x45, 0x1c, + 0x3b, 0xcd, 0x00, 0x00, 0x45, 0x8f, 0x24, 0x2c, 0x01, 0x00, 0xa3, 0x59, + 0xa4, 0x31, 0x45, 0x51, 0x24, 0xcc, 0x00, 0x00, 0x4a, 0xb4, 0xb0, 0xc8, + 0x1e, 0x00, 0x4e, 0x9a, 0x24, 0x0a, 0x02, 0x00, 0x46, 0xd1, 0x73, 0x2a, + 0x01, 0x00, 0x46, 0xb0, 0xe4, 0x2e, 0x01, 0x00, 0x46, 0x52, 0x05, 0x97, + 0x01, 0x00, 0x45, 0x71, 0x24, 0x28, 0x01, 0xc0, 0x00, 0x46, 0x1f, 0x07, + 0x2c, 0x1e, 0x40, 0x48, 0xf4, 0x24, 0xcf, 0x00, 0x80, 0x19, 0xaf, 0x01, + 0xff, 0x02, 0xc6, 0x00, 0x06, 0x4a, 0x4c, 0x24, 0x08, 0x02, 0x40, 0x45, 0x5c, 0x00, 0x30, 0x01, 0x00, 0x45, 0x20, 0x07, 0xca, 0x1e, 0x40, 0x4a, - 0xb8, 0xa5, 0x2e, 0x1e, 0x40, 0x44, 0xee, 0x6c, 0xcf, 0x01, 0x00, 0x49, - 0xd0, 0x04, 0xce, 0x00, 0x40, 0x06, 0x50, 0x00, 0x12, 0x45, 0x5f, 0xdc, - 0x75, 0x2c, 0x00, 0x43, 0x4c, 0x0a, 0x26, 0xa7, 0x00, 0x44, 0x45, 0xf3, - 0xf6, 0x01, 0x40, 0x4b, 0xdc, 0x99, 0x2a, 0x1e, 0x00, 0xa3, 0x2b, 0xa4, - 0x0c, 0x44, 0xac, 0x0e, 0xaa, 0xa7, 0x00, 0x46, 0x52, 0x05, 0x26, 0x01, - 0x40, 0x48, 0x39, 0x2b, 0x67, 0x2c, 0x00, 0x48, 0xba, 0x23, 0x26, 0x1e, - 0x00, 0x03, 0x04, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x22, 0x1e, 0x00, - 0x45, 0x20, 0x07, 0x24, 0x1e, 0x40, 0x44, 0xee, 0x6c, 0x1e, 0x02, 0x00, - 0x46, 0x1b, 0xc2, 0x28, 0x1e, 0x00, 0x49, 0xd0, 0x04, 0x24, 0x01, 0x40, - 0x06, 0x50, 0x00, 0x23, 0x44, 0x02, 0x21, 0x94, 0x01, 0x00, 0x42, 0x22, - 0x00, 0xa2, 0x01, 0x00, 0x07, 0xea, 0x28, 0x01, 0xff, 0xe1, 0xba, 0xa7, + 0xe2, 0xaa, 0x2e, 0x1e, 0x40, 0x44, 0x0b, 0x70, 0xcf, 0x01, 0x00, 0x49, + 0xd0, 0x04, 0xce, 0x00, 0x40, 0x06, 0x50, 0x00, 0x12, 0x45, 0x2f, 0xe2, + 0x75, 0x2c, 0x00, 0x43, 0x95, 0x0a, 0x26, 0xa7, 0x00, 0x44, 0x1c, 0xf9, + 0xf6, 0x01, 0x40, 0x4b, 0xc4, 0x9e, 0x2a, 0x1e, 0x00, 0xa3, 0x2b, 0xa4, + 0x0c, 0x44, 0x5b, 0x0f, 0xaa, 0xa7, 0x00, 0x46, 0x52, 0x05, 0x26, 0x01, + 0x40, 0x48, 0xf3, 0x11, 0x67, 0x2c, 0x00, 0x48, 0xf4, 0x24, 0x26, 0x1e, + 0x00, 0x03, 0x70, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x22, 0x1e, 0x00, + 0x45, 0x20, 0x07, 0x24, 0x1e, 0x40, 0x44, 0x0b, 0x70, 0x1e, 0x02, 0x00, + 0x46, 0x2a, 0x98, 0x28, 0x1e, 0x00, 0x49, 0xd0, 0x04, 0x24, 0x01, 0x40, + 0x06, 0x50, 0x00, 0x23, 0x44, 0x23, 0x22, 0x94, 0x01, 0x00, 0x42, 0x22, + 0x00, 0xa2, 0x01, 0x00, 0x07, 0x6d, 0x2a, 0x01, 0xff, 0xe1, 0xba, 0xa7, 0x00, 0xe9, 0xbc, 0xa7, 0x00, 0x44, 0x55, 0x03, 0x41, 0x02, 0x00, 0xf5, - 0xbe, 0xa7, 0x40, 0x45, 0x14, 0x39, 0xf4, 0x01, 0x00, 0x45, 0x55, 0x23, - 0x1e, 0x01, 0x00, 0xa3, 0x1e, 0x49, 0x56, 0x1e, 0x20, 0x01, 0x00, 0x44, - 0xac, 0x0e, 0x93, 0x01, 0x00, 0x46, 0xb4, 0x70, 0x20, 0x1e, 0x00, 0x4e, - 0x55, 0x43, 0xa0, 0xa7, 0x00, 0x46, 0x52, 0x05, 0xe4, 0x01, 0x40, 0x44, - 0xee, 0x6c, 0xe6, 0x01, 0x00, 0x46, 0x1b, 0xc2, 0x22, 0x01, 0x00, 0x49, - 0xd0, 0x04, 0x1c, 0x01, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x49, 0x56, - 0x1e, 0x1e, 0x1e, 0x00, 0x44, 0xac, 0x0e, 0x91, 0x01, 0x00, 0x46, 0x52, - 0x05, 0x98, 0xa7, 0x40, 0x06, 0x50, 0x00, 0x3b, 0x0e, 0x40, 0x78, 0x2b, + 0xbe, 0xa7, 0x40, 0x45, 0x1c, 0x3b, 0xf4, 0x01, 0x00, 0x45, 0x8f, 0x24, + 0x1e, 0x01, 0x00, 0xa3, 0x1e, 0x49, 0x77, 0x1f, 0x20, 0x01, 0x00, 0x44, + 0x5b, 0x0f, 0x93, 0x01, 0x00, 0x46, 0xd1, 0x73, 0x20, 0x1e, 0x00, 0x4e, + 0x71, 0x45, 0xa0, 0xa7, 0x00, 0x46, 0x52, 0x05, 0xe4, 0x01, 0x40, 0x44, + 0x0b, 0x70, 0xe6, 0x01, 0x00, 0x46, 0x2a, 0x98, 0x22, 0x01, 0x00, 0x49, + 0xd0, 0x04, 0x1c, 0x01, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x49, 0x77, + 0x1f, 0x1e, 0x1e, 0x00, 0x44, 0x5b, 0x0f, 0x91, 0x01, 0x00, 0x46, 0x52, + 0x05, 0x98, 0xa7, 0x40, 0x06, 0x50, 0x00, 0x3b, 0x0e, 0xc0, 0x7b, 0x2b, 0x42, 0x1d, 0x01, 0x4a, 0x01, 0x00, 0x42, 0xa4, 0x02, 0xa9, 0x01, 0x00, - 0xf4, 0x6a, 0xa7, 0x80, 0x16, 0x42, 0x6f, 0x28, 0xb7, 0x01, 0xc0, 0x00, - 0x80, 0x01, 0xff, 0x48, 0x58, 0x13, 0xb8, 0x01, 0x00, 0x4a, 0x04, 0x98, + 0xf4, 0x6a, 0xa7, 0x80, 0x16, 0x42, 0xc2, 0x29, 0xb7, 0x01, 0xc0, 0x00, + 0x80, 0x01, 0xff, 0x48, 0x26, 0x14, 0xb8, 0x01, 0x00, 0x4a, 0x02, 0x9d, 0xee, 0x01, 0x40, 0xe8, 0xd0, 0x00, 0x40, 0x42, 0x9e, 0x01, 0x24, 0xa7, - 0x00, 0x43, 0x68, 0x00, 0x22, 0xa7, 0x40, 0x45, 0x14, 0x39, 0xc9, 0x00, - 0x00, 0x45, 0x55, 0x23, 0x14, 0x01, 0x00, 0xa3, 0x64, 0xa4, 0x43, 0x45, - 0x17, 0x23, 0xc8, 0x00, 0x00, 0x4a, 0x58, 0xab, 0xba, 0x1e, 0x00, 0x4e, - 0x60, 0x23, 0x06, 0x02, 0x00, 0x46, 0xb4, 0x70, 0x12, 0x01, 0x80, 0x19, - 0x46, 0xda, 0xde, 0x18, 0x01, 0x00, 0x46, 0x52, 0x05, 0x46, 0x02, 0x00, - 0x45, 0x37, 0x23, 0xbc, 0x1e, 0xc0, 0x00, 0x46, 0x1f, 0x07, 0x1a, 0x1e, - 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0x16, 0x1e, 0x00, - 0x45, 0x17, 0x23, 0x14, 0x1e, 0x40, 0x48, 0xba, 0x23, 0xcb, 0x00, 0x00, - 0xaf, 0x01, 0xff, 0x02, 0xc6, 0x00, 0x06, 0x4a, 0x12, 0x23, 0x04, 0x02, - 0x40, 0x45, 0x5c, 0x00, 0x16, 0x01, 0x00, 0x45, 0x20, 0x07, 0xb8, 0x1e, - 0x40, 0x44, 0xee, 0x6c, 0x1a, 0x01, 0x00, 0x46, 0x1b, 0xc2, 0x28, 0x02, - 0x80, 0x32, 0x49, 0xd0, 0x04, 0xca, 0x00, 0xc0, 0x00, 0x80, 0x01, 0xff, - 0x04, 0x1a, 0x00, 0x06, 0x45, 0x20, 0x07, 0x18, 0x1e, 0x40, 0x45, 0x14, - 0x39, 0xbe, 0x1e, 0x00, 0x49, 0x9f, 0x12, 0xc6, 0x1e, 0x00, 0x45, 0x17, - 0x23, 0xc0, 0x1e, 0x00, 0x4a, 0x58, 0xab, 0xc2, 0x1e, 0x00, 0x45, 0x37, - 0x23, 0xc4, 0x1e, 0x40, 0x4a, 0xcc, 0xa5, 0x1c, 0x1e, 0x40, 0x06, 0x50, - 0x00, 0x1b, 0x06, 0x3c, 0x01, 0x0b, 0xfa, 0xf1, 0x01, 0xc0, 0x00, 0x4b, - 0x03, 0x98, 0xc4, 0x01, 0x40, 0x45, 0x18, 0x4a, 0xd2, 0xa7, 0x00, 0x44, - 0x89, 0xa4, 0xd4, 0xa7, 0x40, 0xa3, 0x3d, 0x04, 0x03, 0x0c, 0x2d, 0x44, - 0xac, 0x0e, 0x8a, 0x01, 0x00, 0x4a, 0xa4, 0x6d, 0x0e, 0x1e, 0x00, 0xb3, - 0x06, 0x46, 0xc6, 0xe0, 0x8b, 0x01, 0x40, 0x53, 0xf7, 0x49, 0xc7, 0xa7, - 0x00, 0x4d, 0x98, 0x85, 0xf2, 0x01, 0x80, 0x06, 0x45, 0x53, 0x05, 0x10, - 0x01, 0x40, 0x4b, 0x03, 0x98, 0xc5, 0x01, 0x40, 0x45, 0x5c, 0x00, 0x0a, - 0x1e, 0x00, 0x45, 0x20, 0x07, 0x0c, 0x1e, 0x40, 0x44, 0xee, 0x6c, 0x0e, - 0x01, 0x00, 0x46, 0x1b, 0xc2, 0x10, 0x1e, 0x00, 0x4f, 0xf8, 0x6e, 0x12, - 0x1e, 0x40, 0x06, 0x50, 0x00, 0x1f, 0x42, 0x49, 0x00, 0xb3, 0xa7, 0x00, - 0x4f, 0x15, 0x70, 0xd0, 0xa7, 0x00, 0x42, 0x10, 0x00, 0x6e, 0xa7, 0x00, - 0x48, 0x01, 0xcc, 0x2c, 0xa7, 0xc0, 0x00, 0x4b, 0x0e, 0x98, 0x2e, 0xa7, - 0x40, 0x45, 0x14, 0x39, 0x06, 0x01, 0x00, 0x43, 0x16, 0x00, 0x92, 0xa7, - 0x00, 0xa3, 0x18, 0x49, 0x56, 0x1e, 0x0a, 0x01, 0x00, 0x44, 0xac, 0x0e, - 0x87, 0x01, 0x00, 0x4c, 0xfa, 0x56, 0xc4, 0xa7, 0x00, 0x46, 0x52, 0x05, - 0x3b, 0x02, 0x40, 0x44, 0xee, 0x6c, 0x0c, 0x01, 0x00, 0x46, 0x1b, 0xc2, - 0xc7, 0x00, 0x80, 0x06, 0x49, 0xd0, 0x04, 0x08, 0x01, 0x40, 0x4a, 0xb8, - 0xa5, 0x08, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x0c, 0x43, 0x94, 0x0f, 0xb4, - 0xa7, 0x00, 0x47, 0x8f, 0xd5, 0x46, 0xa7, 0x40, 0x04, 0x03, 0x0c, 0x1e, - 0x48, 0x51, 0xc6, 0x96, 0xa7, 0x00, 0x44, 0xac, 0x0e, 0x81, 0x01, 0x00, - 0x4a, 0xa4, 0x6d, 0x06, 0x1e, 0x00, 0x46, 0x52, 0x05, 0x43, 0x02, 0x00, - 0x46, 0xc6, 0xe0, 0x82, 0x01, 0x40, 0x45, 0x5c, 0x00, 0x02, 0x1e, 0x00, - 0x45, 0x20, 0x07, 0x04, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x43, 0xe1, 0x32, - 0xa7, 0x00, 0xe5, 0xc6, 0x00, 0x80, 0x29, 0x48, 0x69, 0xc6, 0x89, 0x01, - 0x00, 0x44, 0x5f, 0xe4, 0x6d, 0x2c, 0x00, 0x4a, 0x82, 0xae, 0xc2, 0xa7, - 0x00, 0xef, 0x34, 0xa7, 0x00, 0xf5, 0x36, 0xa7, 0x00, 0xf6, 0x38, 0xa7, - 0x80, 0x04, 0xf9, 0x3c, 0xa7, 0x40, 0x54, 0x07, 0x40, 0x3a, 0xa7, 0x40, - 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0xfc, 0x01, 0x00, 0x46, - 0xb4, 0x70, 0xe2, 0x01, 0x40, 0x45, 0x14, 0x39, 0xc1, 0x00, 0x00, 0x45, - 0x55, 0x23, 0x02, 0x01, 0x80, 0xa2, 0x01, 0xa3, 0x70, 0xa4, 0x41, 0x45, - 0x17, 0x23, 0xc0, 0x00, 0x00, 0x4a, 0x58, 0xab, 0xa2, 0x1e, 0x00, 0x4e, - 0x60, 0x23, 0x02, 0x02, 0x00, 0x46, 0xb4, 0x70, 0x00, 0x01, 0x00, 0x46, - 0xda, 0xde, 0x04, 0x01, 0x00, 0x05, 0x22, 0x08, 0x0c, 0x46, 0x52, 0x05, - 0x3a, 0x02, 0x00, 0x45, 0x37, 0x23, 0xc3, 0x00, 0x40, 0x45, 0x5c, 0x00, - 0xc5, 0x00, 0x80, 0x06, 0x45, 0x20, 0x07, 0x00, 0x1e, 0x40, 0x4a, 0xb8, - 0xa5, 0xfa, 0x01, 0x40, 0x48, 0xba, 0x23, 0xc4, 0x00, 0x80, 0x20, 0xaf, - 0x01, 0xff, 0x02, 0xc6, 0x00, 0x06, 0x4a, 0x12, 0x23, 0x00, 0x02, 0x40, - 0x45, 0x5c, 0x00, 0x26, 0x02, 0x80, 0x06, 0x45, 0x20, 0x07, 0xa0, 0x1e, - 0x40, 0x4b, 0x74, 0x97, 0xe0, 0x01, 0x40, 0x4b, 0x74, 0x97, 0xde, 0x01, - 0x40, 0x44, 0xee, 0x6c, 0xcd, 0x01, 0x00, 0x49, 0xd0, 0x04, 0xc2, 0x00, - 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0xa4, 0x1e, - 0x00, 0x49, 0x9f, 0x12, 0xac, 0x1e, 0x00, 0x45, 0x17, 0x23, 0xa6, 0x1e, - 0x00, 0x4a, 0x58, 0xab, 0xa8, 0x1e, 0x00, 0x45, 0x37, 0x23, 0xaa, 0x1e, - 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x14, 0x39, 0xae, 0x1e, 0x00, - 0x49, 0x9f, 0x12, 0xb6, 0x1e, 0x00, 0x45, 0x17, 0x23, 0xb0, 0x1e, 0x00, - 0x4a, 0x58, 0xab, 0xb2, 0x1e, 0x00, 0x45, 0x37, 0x23, 0xb4, 0x1e, 0x40, - 0x80, 0x01, 0xff, 0x46, 0x16, 0x08, 0x17, 0xf3, 0x01, 0x49, 0x70, 0xc1, - 0x1c, 0xf3, 0x41, 0x02, 0xdb, 0x09, 0x06, 0x46, 0x33, 0x9c, 0xbe, 0x20, - 0x40, 0x80, 0x0d, 0x46, 0xf8, 0xd0, 0xab, 0x2a, 0xc0, 0x00, 0x4c, 0x0d, - 0x29, 0xad, 0x2a, 0x40, 0xa2, 0xbd, 0x04, 0x46, 0x12, 0x03, 0xef, 0x25, - 0x00, 0x49, 0x0b, 0x39, 0xd9, 0x27, 0x00, 0x06, 0x20, 0x8a, 0xa0, 0x04, - 0x56, 0x68, 0x35, 0x1e, 0x2a, 0x00, 0xaf, 0xf0, 0x03, 0x07, 0x11, 0xd5, - 0xdf, 0x03, 0x04, 0xda, 0x05, 0xce, 0x03, 0xb4, 0x17, 0x47, 0x09, 0xd7, - 0xd8, 0x27, 0x00, 0x07, 0xfe, 0xd7, 0x01, 0xff, 0x46, 0x12, 0x03, 0xe1, - 0xf7, 0x01, 0x46, 0xd6, 0x05, 0xe8, 0xf7, 0x41, 0x5b, 0x87, 0x1d, 0xfc, - 0x2a, 0x00, 0x03, 0x20, 0x0a, 0x9e, 0x03, 0x0a, 0x18, 0xb4, 0x01, 0xff, - 0xa3, 0xe8, 0x02, 0x09, 0xfe, 0x25, 0xb4, 0x02, 0xac, 0xcb, 0x01, 0xb2, - 0xbc, 0x01, 0xb3, 0x4e, 0x06, 0x6d, 0x02, 0x06, 0x4b, 0xf2, 0xa4, 0x41, - 0xce, 0x41, 0x0f, 0xea, 0x6d, 0x38, 0x05, 0xc3, 0x00, 0x1f, 0x06, 0xc8, - 0x00, 0x06, 0x48, 0xdc, 0x79, 0x1c, 0xce, 0x41, 0x43, 0xaa, 0x17, 0x24, - 0xce, 0x01, 0xa3, 0x01, 0xff, 0x45, 0x1e, 0x0b, 0x27, 0xce, 0x01, 0x45, - 0x9e, 0xea, 0x26, 0xce, 0x41, 0x43, 0xaa, 0x17, 0x1a, 0xce, 0x01, 0xa3, - 0x01, 0xff, 0x45, 0x1e, 0x0b, 0x1b, 0xce, 0x01, 0x45, 0x9e, 0xea, 0x1d, - 0xce, 0x41, 0xed, 0x21, 0xce, 0x01, 0xf7, 0x31, 0xce, 0x41, 0x05, 0x34, - 0x07, 0x5c, 0x43, 0x79, 0x10, 0x29, 0xce, 0xc1, 0x00, 0x06, 0x50, 0x00, - 0x35, 0x8d, 0x01, 0xff, 0x42, 0xad, 0xf3, 0x50, 0xce, 0x81, 0x25, 0xd2, - 0x4f, 0xce, 0x81, 0x12, 0xd3, 0x4d, 0xce, 0x81, 0x09, 0xd4, 0x49, 0xce, - 0xc1, 0x00, 0xd5, 0x47, 0xce, 0x41, 0xd4, 0x4a, 0xce, 0x41, 0xd3, 0x4e, - 0xce, 0xc1, 0x00, 0xd4, 0x4b, 0xce, 0xc1, 0x00, 0xd5, 0x48, 0xce, 0x41, - 0x42, 0x17, 0xf5, 0x4c, 0xce, 0x41, 0x48, 0x26, 0x75, 0x3a, 0xce, 0x01, - 0x05, 0xc3, 0x00, 0x06, 0x4e, 0xce, 0x7b, 0x28, 0xce, 0x41, 0x48, 0x26, - 0x75, 0x36, 0xce, 0x01, 0x45, 0x60, 0x0d, 0x39, 0xce, 0x41, 0x4e, 0xd6, - 0x79, 0x2d, 0xce, 0x01, 0x4e, 0x44, 0x7e, 0x23, 0xce, 0x41, 0x54, 0x57, - 0x40, 0x35, 0xce, 0x01, 0x48, 0x09, 0xc7, 0x25, 0xce, 0x41, 0x47, 0xd4, - 0xd0, 0x1e, 0xce, 0x01, 0x05, 0x14, 0x01, 0x01, 0xff, 0x0f, 0xea, 0x6d, - 0x4f, 0x05, 0xc3, 0x00, 0x2e, 0x06, 0xc8, 0x00, 0x06, 0x48, 0xdc, 0x79, - 0x3c, 0xce, 0x41, 0xa1, 0x0f, 0xa3, 0x01, 0xff, 0x45, 0x1e, 0x0b, 0x44, - 0xce, 0x01, 0x45, 0x9e, 0xea, 0x46, 0xce, 0x41, 0x52, 0xba, 0x53, 0x37, - 0xce, 0x01, 0x42, 0x14, 0x03, 0x43, 0xce, 0xc1, 0x00, 0x4a, 0xbc, 0xa6, - 0x45, 0xce, 0x41, 0xa1, 0x0f, 0xa3, 0x01, 0xff, 0x45, 0x1e, 0x0b, 0x3d, - 0xce, 0x01, 0x45, 0x9e, 0xea, 0x3f, 0xce, 0x41, 0x51, 0x89, 0x5c, 0x2e, - 0xce, 0x01, 0x42, 0x14, 0x03, 0x3e, 0xce, 0x41, 0xed, 0x30, 0xce, 0x01, - 0xf7, 0x42, 0xce, 0x41, 0x06, 0x13, 0x01, 0x1f, 0x06, 0x6d, 0x02, 0x01, - 0xff, 0x44, 0xc3, 0x00, 0x3b, 0xce, 0x81, 0x0d, 0x45, 0xc8, 0x00, 0x2b, - 0xce, 0xc1, 0x00, 0x50, 0x43, 0x44, 0x2a, 0xce, 0x41, 0x4f, 0xc2, 0x39, - 0x38, 0xce, 0x41, 0x44, 0xc3, 0x00, 0x22, 0xce, 0x01, 0x45, 0xc8, 0x00, - 0x2c, 0xce, 0x41, 0x09, 0x8b, 0xb8, 0x18, 0x47, 0x27, 0x75, 0x1f, 0xce, - 0xc1, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4a, 0x92, 0xad, 0x20, 0xce, - 0x01, 0x4a, 0x0a, 0xb3, 0x40, 0xce, 0x41, 0xeb, 0x2f, 0xce, 0x01, 0xf8, - 0x32, 0xce, 0x01, 0xf9, 0x33, 0xce, 0x01, 0x4f, 0x1f, 0x75, 0x34, 0xce, - 0x41, 0x5d, 0xf5, 0x0b, 0x3c, 0x0b, 0x01, 0x5f, 0xca, 0x11, 0x3e, 0x0b, - 0x41, 0x46, 0x12, 0x03, 0x34, 0xf5, 0x01, 0x46, 0xd6, 0x05, 0xe5, 0xf7, - 0x41, 0x46, 0x12, 0x03, 0xe3, 0xf7, 0x01, 0x46, 0xd6, 0x05, 0xea, 0xf7, - 0x41, 0x03, 0xef, 0x07, 0x17, 0x06, 0xbb, 0x1c, 0x01, 0xff, 0x46, 0x12, - 0x03, 0xe0, 0xf7, 0x01, 0x47, 0x9c, 0x44, 0x36, 0xf5, 0x01, 0x46, 0xd6, - 0x05, 0xe7, 0xf7, 0x41, 0x5d, 0x4b, 0x15, 0x3d, 0x0b, 0x01, 0x5f, 0xab, - 0x11, 0x3f, 0x0b, 0x41, 0x46, 0x12, 0x03, 0xe2, 0xf7, 0x01, 0x46, 0xd6, - 0x05, 0xe9, 0xf7, 0x41, 0x04, 0xe9, 0x8c, 0x11, 0x05, 0xa3, 0xea, 0x01, - 0xff, 0x46, 0x12, 0x03, 0xe4, 0xf7, 0x01, 0x46, 0xd6, 0x05, 0xeb, 0xf7, - 0x41, 0x46, 0x12, 0x03, 0x35, 0xf5, 0x01, 0x47, 0x9c, 0x44, 0x37, 0xf5, - 0x01, 0x46, 0xd6, 0x05, 0xe6, 0xf7, 0x41, 0x51, 0x04, 0x59, 0xcc, 0x0e, - 0x00, 0x06, 0xef, 0x06, 0x8a, 0x04, 0x48, 0xe9, 0x29, 0xaf, 0x0e, 0x00, - 0x03, 0xdb, 0x71, 0xf3, 0x03, 0x45, 0x00, 0xe8, 0xc6, 0x0e, 0x00, 0x07, - 0xec, 0x05, 0x92, 0x01, 0x49, 0x8d, 0xbc, 0xcd, 0x0e, 0x00, 0xb3, 0x74, - 0x09, 0x08, 0xc0, 0x57, 0x0b, 0x55, 0x77, 0x06, 0x48, 0xd9, 0xcc, 0xce, - 0x0e, 0x40, 0xe1, 0xb0, 0x0e, 0x80, 0x38, 0xe5, 0xc0, 0x0e, 0x80, 0x2f, - 0xe9, 0xb4, 0x0e, 0x80, 0x26, 0x05, 0x87, 0xe8, 0x16, 0xef, 0xc2, 0x0e, - 0x00, 0xf5, 0xb8, 0x0e, 0x80, 0x09, 0xf9, 0xb6, 0x0e, 0xc0, 0x00, 0xf9, - 0xb7, 0x0e, 0x40, 0xf5, 0xb9, 0x0e, 0x40, 0x42, 0x1a, 0x00, 0xb1, 0x0e, - 0x00, 0x42, 0x10, 0x00, 0xbb, 0x0e, 0x40, 0xe9, 0xb5, 0x0e, 0x40, 0xe9, - 0xc1, 0x0e, 0x40, 0xe1, 0xb2, 0x0e, 0x00, 0xe9, 0xc4, 0x0e, 0x00, 0xed, - 0xb3, 0x0e, 0x00, 0xf9, 0xc3, 0x0e, 0x40, 0x46, 0x84, 0xda, 0xcb, 0x0e, - 0x00, 0x42, 0xf1, 0x18, 0xc8, 0x0e, 0x00, 0xb4, 0x01, 0xff, 0x42, 0x0b, - 0x00, 0xc9, 0x0e, 0x00, 0xe9, 0xca, 0x0e, 0x40, 0x0e, 0x52, 0x77, 0x06, - 0x4f, 0x80, 0x6e, 0xba, 0x0e, 0x40, 0x42, 0x13, 0x01, 0xbc, 0x0e, 0x00, - 0x43, 0x14, 0x54, 0xbd, 0x0e, 0x40, 0x42, 0x5d, 0x00, 0x9a, 0x0e, 0x00, - 0x42, 0x13, 0x05, 0x88, 0x0e, 0x00, 0x42, 0x3b, 0x01, 0x94, 0x0e, 0x00, - 0x03, 0xeb, 0xd4, 0xa5, 0x02, 0x03, 0xdb, 0x71, 0x94, 0x02, 0xab, 0xea, - 0x01, 0x42, 0x13, 0x01, 0xa5, 0x0e, 0x80, 0xd1, 0x01, 0x42, 0xc3, 0x07, - 0xa1, 0x0e, 0x00, 0xae, 0xb8, 0x01, 0xef, 0xad, 0x0e, 0x00, 0xb0, 0x4b, - 0x42, 0xd0, 0x00, 0xa3, 0x0e, 0x00, 0xb3, 0x22, 0xb4, 0x0c, 0x42, 0x15, - 0x02, 0xa7, 0x0e, 0x00, 0x42, 0xb0, 0x47, 0xa2, 0x0e, 0x40, 0x03, 0xdb, - 0x71, 0x04, 0xef, 0x95, 0x0e, 0x40, 0x44, 0x7c, 0xc0, 0x96, 0x0e, 0x00, - 0x43, 0x57, 0x32, 0x97, 0x0e, 0x40, 0x09, 0x42, 0xb6, 0x11, 0x02, 0x7b, - 0x02, 0x01, 0xff, 0x44, 0x7c, 0xc0, 0xaa, 0x0e, 0x00, 0x43, 0x57, 0x32, - 0x8a, 0x0e, 0x40, 0x42, 0x22, 0x00, 0xa8, 0x0e, 0x00, 0x42, 0x40, 0x06, - 0xa9, 0x0e, 0x40, 0x04, 0x85, 0x6e, 0x14, 0x03, 0xdb, 0x71, 0x04, 0xef, - 0x9b, 0x0e, 0x40, 0x44, 0x7c, 0xc0, 0x9c, 0x0e, 0x00, 0x43, 0x57, 0x32, - 0x9e, 0x0e, 0x40, 0x43, 0xf4, 0x2a, 0xa0, 0x0e, 0x00, 0x43, 0xe6, 0x17, - 0x89, 0x0e, 0x00, 0xa4, 0x2f, 0x43, 0x2f, 0x9c, 0x86, 0x0e, 0x00, 0x43, - 0xa3, 0x45, 0x8c, 0x0e, 0x00, 0x43, 0x2c, 0x0e, 0xac, 0x0e, 0x00, 0xae, - 0x0f, 0x02, 0xee, 0x05, 0x01, 0xff, 0xe1, 0x8f, 0x0e, 0x00, 0x42, 0x22, - 0x00, 0x90, 0x0e, 0x40, 0x42, 0x2a, 0x05, 0x93, 0x0e, 0x00, 0x42, 0xbe, - 0x22, 0x8e, 0x0e, 0x40, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x98, 0x0e, 0x40, - 0xe1, 0x91, 0x0e, 0x00, 0x42, 0x22, 0x00, 0x92, 0x0e, 0x40, 0x42, 0x06, - 0x14, 0x87, 0x0e, 0x00, 0xef, 0x99, 0x0e, 0x00, 0x42, 0xb0, 0x47, 0x8d, - 0x0e, 0x40, 0x02, 0x73, 0x00, 0x01, 0xff, 0x43, 0xa1, 0x01, 0xa3, 0x0e, - 0x00, 0x43, 0xc6, 0x6c, 0xa5, 0x0e, 0x40, 0xa8, 0x04, 0xef, 0x81, 0x0e, - 0x40, 0x03, 0x80, 0x89, 0x11, 0x02, 0x7b, 0x02, 0x01, 0xff, 0x44, 0x7c, - 0xc0, 0x82, 0x0e, 0x00, 0x43, 0x57, 0x32, 0x84, 0x0e, 0x40, 0x42, 0x06, - 0x14, 0xde, 0x0e, 0x00, 0x43, 0x14, 0x54, 0xdf, 0x0e, 0x40, 0x44, 0x7c, - 0xc0, 0xab, 0x0e, 0x00, 0x43, 0x57, 0x32, 0xae, 0x0e, 0x40, 0xa6, 0x0c, - 0x44, 0x7c, 0xc0, 0x9f, 0x0e, 0x00, 0x43, 0x57, 0x32, 0x9d, 0x0e, 0x40, - 0x42, 0xed, 0x10, 0x9f, 0x0e, 0x00, 0x42, 0x10, 0x00, 0x9d, 0x0e, 0x40, - 0x42, 0xc3, 0x07, 0xdd, 0x0e, 0x00, 0x42, 0xb4, 0x01, 0xdc, 0x0e, 0x40, - 0x45, 0x12, 0x0b, 0xd8, 0x0e, 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0xd9, - 0x0e, 0x00, 0x43, 0x0e, 0x0b, 0xd1, 0x0e, 0x00, 0xb3, 0x14, 0xb4, 0x06, - 0x44, 0x5f, 0x1e, 0xd0, 0x0e, 0x40, 0x44, 0x25, 0x01, 0xd3, 0x0e, 0x00, - 0x42, 0x15, 0x02, 0xd2, 0x0e, 0x40, 0x44, 0xe5, 0x1d, 0xd7, 0x0e, 0x00, - 0x42, 0x1c, 0x26, 0xd6, 0x0e, 0x40, 0x43, 0xd2, 0x05, 0xd5, 0x0e, 0x00, - 0x43, 0xf6, 0x06, 0xd4, 0x0e, 0x40, 0x46, 0x20, 0xdb, 0xd8, 0xf6, 0x01, - 0x49, 0x6c, 0xb9, 0x01, 0x00, 0x4e, 0x43, 0xf1, 0x1a, 0x9c, 0xfa, 0x01, - 0x48, 0xc9, 0xcc, 0x1e, 0xf4, 0x41, 0x45, 0xc5, 0xe1, 0x7c, 0xf9, 0x01, - 0x42, 0xd8, 0x00, 0xf7, 0xf3, 0x41, 0xa1, 0x8f, 0x16, 0xa5, 0xe8, 0x15, - 0xa8, 0xdf, 0x03, 0xa9, 0x22, 0xae, 0x14, 0xaf, 0x06, 0x45, 0x99, 0xea, - 0xe3, 0x2b, 0x40, 0x43, 0x69, 0x19, 0x28, 0xf4, 0x01, 0x54, 0x2f, 0x45, - 0x7f, 0x32, 0x40, 0x4d, 0x8c, 0x82, 0xce, 0xf9, 0x01, 0x42, 0x1b, 0x05, - 0xa2, 0xfa, 0x41, 0x44, 0xda, 0x18, 0x58, 0xf4, 0x01, 0x46, 0x58, 0x03, - 0xad, 0x20, 0x00, 0x08, 0x51, 0xca, 0x3c, 0x42, 0xee, 0x00, 0x8f, 0xf4, - 0x81, 0x0c, 0x42, 0x77, 0x00, 0x81, 0xfa, 0x01, 0x47, 0x9c, 0xd7, 0x5d, - 0xf9, 0x41, 0x45, 0xb8, 0x00, 0x8b, 0xf4, 0x01, 0x04, 0xa1, 0x01, 0x01, - 0xff, 0x59, 0x87, 0x23, 0x3d, 0xf6, 0x01, 0x44, 0x0c, 0x08, 0x17, 0xf6, - 0xc1, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4b, 0x95, 0x23, 0x1a, 0xf6, - 0x01, 0x4c, 0x72, 0x1f, 0x19, 0xf6, 0x41, 0xa4, 0x9a, 0x02, 0x07, 0xec, - 0x05, 0x54, 0x05, 0x5a, 0x03, 0x28, 0x0b, 0x55, 0x77, 0x01, 0xff, 0xa1, - 0x15, 0xe5, 0x67, 0x6d, 0x01, 0xe9, 0x64, 0x6d, 0x01, 0xef, 0x69, 0x6d, - 0x01, 0xf5, 0x65, 0x6d, 0xc1, 0x00, 0xe5, 0x66, 0x6d, 0x41, 0xe1, 0x63, - 0x6d, 0x01, 0xe9, 0x68, 0x6d, 0x01, 0xf5, 0x6a, 0x6d, 0x41, 0x48, 0x3c, - 0x16, 0x40, 0x6d, 0x01, 0x44, 0xad, 0xf2, 0x6c, 0x6d, 0x01, 0x45, 0x7f, - 0xeb, 0x41, 0x6d, 0x01, 0x02, 0x02, 0x00, 0x06, 0x44, 0x71, 0xf3, 0x6d, - 0x6d, 0x41, 0x44, 0xe7, 0x23, 0x6b, 0x6d, 0x01, 0x45, 0xf3, 0x4b, 0x42, - 0x6d, 0x41, 0xe1, 0x43, 0x6d, 0x01, 0xa2, 0xb1, 0x01, 0xa3, 0xa4, 0x01, - 0xa4, 0x8b, 0x01, 0xa7, 0x7f, 0x42, 0x22, 0x00, 0x62, 0x6d, 0x01, 0xaa, - 0x6d, 0xab, 0x61, 0x42, 0x74, 0x00, 0x5e, 0x6d, 0x01, 0x42, 0x6c, 0x00, - 0x5b, 0x6d, 0x01, 0xae, 0x43, 0xb0, 0x37, 0x42, 0x71, 0x00, 0x5d, 0x6d, - 0x01, 0xb3, 0x25, 0xb4, 0x0c, 0x42, 0xf5, 0x0a, 0x5f, 0x6d, 0x01, 0x42, - 0xbe, 0x22, 0x5c, 0x6d, 0x41, 0xe1, 0x52, 0x6d, 0x01, 0x42, 0x22, 0x00, - 0x53, 0x6d, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x4e, 0x6d, 0x01, 0x42, 0x22, - 0x00, 0x4f, 0x6d, 0x41, 0xe1, 0x60, 0x6d, 0x01, 0x42, 0x22, 0x00, 0x61, - 0x6d, 0x41, 0xe1, 0x57, 0x6d, 0x01, 0x42, 0x22, 0x00, 0x58, 0x6d, 0x41, - 0xe1, 0x56, 0x6d, 0x01, 0x42, 0x24, 0x02, 0x48, 0x6d, 0x01, 0x42, 0xbe, - 0x22, 0x4d, 0x6d, 0x41, 0xe1, 0x44, 0x6d, 0x01, 0x42, 0x22, 0x00, 0x45, - 0x6d, 0x41, 0xe1, 0x4b, 0x6d, 0x01, 0x42, 0x22, 0x00, 0x4c, 0x6d, 0x41, - 0xe1, 0x46, 0x6d, 0x01, 0x42, 0x22, 0x00, 0x47, 0x6d, 0x41, 0xe1, 0x54, - 0x6d, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x55, 0x6d, 0x41, 0xe1, 0x50, - 0x6d, 0x01, 0x42, 0x22, 0x00, 0x51, 0x6d, 0x41, 0xe1, 0x49, 0x6d, 0x01, - 0x42, 0x22, 0x00, 0x4a, 0x6d, 0x41, 0xe1, 0x59, 0x6d, 0x01, 0x42, 0x22, - 0x00, 0x5a, 0x6d, 0x41, 0x44, 0x75, 0x20, 0x6e, 0x6d, 0x01, 0x05, 0xf0, - 0x06, 0x06, 0x4b, 0x2a, 0xa1, 0x6f, 0x6d, 0x41, 0x45, 0x12, 0x0b, 0x78, - 0x6d, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x79, 0x6d, 0x01, 0x43, 0x0e, - 0x0b, 0x71, 0x6d, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x70, - 0x6d, 0x41, 0x44, 0x25, 0x01, 0x73, 0x6d, 0x01, 0x42, 0x15, 0x02, 0x72, - 0x6d, 0x41, 0x44, 0xe5, 0x1d, 0x77, 0x6d, 0x01, 0x42, 0x1c, 0x26, 0x76, - 0x6d, 0x41, 0x43, 0xd2, 0x05, 0x75, 0x6d, 0x01, 0x43, 0xf6, 0x06, 0x74, - 0x6d, 0x41, 0xa1, 0xaa, 0x0e, 0x12, 0xf4, 0x52, 0x92, 0x0e, 0x04, 0x16, - 0x38, 0xb3, 0x06, 0x05, 0x9a, 0xe9, 0xa4, 0x03, 0x08, 0x11, 0xcc, 0x01, - 0xff, 0x06, 0xef, 0x06, 0xd8, 0x02, 0x07, 0xec, 0x05, 0x43, 0x05, 0x5a, - 0x03, 0x2d, 0x0b, 0x55, 0x77, 0x01, 0xff, 0xa1, 0x1a, 0xe5, 0xe5, 0x12, - 0x01, 0xe9, 0xe1, 0x12, 0x81, 0x0d, 0xef, 0xe7, 0x12, 0x01, 0xf5, 0xe3, - 0x12, 0xc1, 0x00, 0xf5, 0xe4, 0x12, 0x41, 0xe9, 0xe2, 0x12, 0x41, 0xe1, - 0xe0, 0x12, 0x01, 0xe9, 0xe6, 0x12, 0x01, 0xf5, 0xe8, 0x12, 0x41, 0x48, - 0x3c, 0x16, 0xdf, 0x12, 0x01, 0x45, 0x5a, 0x3f, 0xe9, 0x12, 0x01, 0x46, - 0xe5, 0x23, 0xea, 0x12, 0x41, 0xe1, 0xb0, 0x12, 0x81, 0xff, 0x01, 0xa2, - 0xec, 0x01, 0xa3, 0xdf, 0x01, 0xa4, 0xc0, 0x01, 0xe5, 0xb6, 0x12, 0x01, - 0xa7, 0xa9, 0x01, 0x42, 0x22, 0x00, 0xde, 0x12, 0x01, 0xe9, 0xb2, 0x12, - 0x81, 0x99, 0x01, 0xaa, 0x86, 0x01, 0xab, 0x7a, 0x42, 0x74, 0x00, 0xda, - 0x12, 0x01, 0x42, 0x6c, 0x00, 0xd7, 0x12, 0x01, 0xae, 0x56, 0xef, 0xb8, - 0x12, 0x01, 0xb0, 0x46, 0xb2, 0x3a, 0xb3, 0x2e, 0xb4, 0x15, 0xf5, 0xb4, - 0x12, 0x81, 0x0c, 0x42, 0xf5, 0x0a, 0xdb, 0x12, 0x01, 0x42, 0xbe, 0x22, - 0xd8, 0x12, 0x41, 0xf5, 0xb5, 0x12, 0x41, 0xe1, 0xcd, 0x12, 0x01, 0x42, - 0x22, 0x00, 0xce, 0x12, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0xc6, 0x12, 0x01, - 0x42, 0x22, 0x00, 0xc7, 0x12, 0x41, 0xe1, 0xdd, 0x12, 0x01, 0x42, 0x22, - 0x00, 0xdc, 0x12, 0x41, 0xe1, 0xd9, 0x12, 0x01, 0x42, 0x71, 0x00, 0xca, - 0x12, 0x41, 0xe1, 0xd2, 0x12, 0x01, 0x42, 0x22, 0x00, 0xd3, 0x12, 0x41, - 0xe1, 0xd1, 0x12, 0x01, 0x42, 0x24, 0x02, 0xbf, 0x12, 0x01, 0x42, 0x2a, - 0x05, 0xcc, 0x12, 0x01, 0x42, 0xbe, 0x22, 0xc5, 0x12, 0x41, 0xe1, 0xba, - 0x12, 0x01, 0x42, 0x22, 0x00, 0xbb, 0x12, 0x41, 0xe1, 0xc2, 0x12, 0x01, - 0x42, 0x22, 0x00, 0xc4, 0x12, 0x01, 0x42, 0x72, 0x19, 0xc3, 0x12, 0x41, - 0xe9, 0xb3, 0x12, 0x41, 0xe1, 0xbc, 0x12, 0x01, 0x42, 0x24, 0x02, 0xbd, - 0x12, 0x01, 0x42, 0x22, 0x00, 0xbe, 0x12, 0x41, 0xe1, 0xcf, 0x12, 0x01, - 0xa4, 0x06, 0x42, 0x22, 0x00, 0xd0, 0x12, 0x41, 0xe1, 0xc8, 0x12, 0x01, - 0x42, 0xf0, 0x10, 0xc9, 0x12, 0x01, 0x42, 0x22, 0x00, 0xcb, 0x12, 0x41, - 0xe1, 0xc0, 0x12, 0x01, 0x42, 0x22, 0x00, 0xc1, 0x12, 0x41, 0xe1, 0xd4, - 0x12, 0x01, 0x42, 0x16, 0x00, 0xd5, 0x12, 0x01, 0x42, 0x22, 0x00, 0xd6, - 0x12, 0x41, 0xe1, 0xb1, 0x12, 0x01, 0xe9, 0xb7, 0x12, 0x01, 0xf5, 0xb9, - 0x12, 0x41, 0x45, 0x12, 0x0b, 0xf8, 0x12, 0x01, 0xa6, 0x2e, 0x44, 0xea, - 0x2a, 0xf9, 0x12, 0x01, 0x43, 0x0e, 0x0b, 0xf1, 0x12, 0x01, 0xb3, 0x14, - 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xf0, 0x12, 0x41, 0x44, 0x25, 0x01, 0xf3, - 0x12, 0x01, 0x42, 0x15, 0x02, 0xf2, 0x12, 0x41, 0x44, 0xe5, 0x1d, 0xf7, - 0x12, 0x01, 0x42, 0x1c, 0x26, 0xf6, 0x12, 0x41, 0x43, 0xd2, 0x05, 0xf5, - 0x12, 0x01, 0x43, 0xf6, 0x06, 0xf4, 0x12, 0x41, 0x51, 0xe3, 0x57, 0x3d, - 0x12, 0x01, 0xa4, 0xea, 0x02, 0x07, 0xec, 0x05, 0x60, 0xb3, 0x33, 0x0b, - 0x55, 0x77, 0x06, 0x4e, 0xec, 0x7e, 0x3a, 0x12, 0x41, 0xa1, 0x1b, 0xe5, - 0x30, 0x12, 0x01, 0xe9, 0x2d, 0x12, 0x81, 0x0e, 0xef, 0x32, 0x12, 0x01, - 0xf5, 0x2f, 0x12, 0x01, 0x49, 0x43, 0xc1, 0x41, 0x12, 0x41, 0xe9, 0x2e, - 0x12, 0x41, 0xe1, 0x2c, 0x12, 0x01, 0xe9, 0x31, 0x12, 0x01, 0xf5, 0x33, - 0x12, 0x41, 0x4b, 0x14, 0x27, 0x3b, 0x12, 0x01, 0x04, 0x5b, 0x03, 0x01, - 0xff, 0x48, 0x3c, 0x16, 0x34, 0x12, 0x01, 0x45, 0x5a, 0x3f, 0x36, 0x12, - 0x01, 0xb3, 0x06, 0x46, 0xe5, 0x23, 0x35, 0x12, 0x41, 0x45, 0xe8, 0xe6, - 0x37, 0x12, 0x01, 0x44, 0x44, 0xeb, 0x3e, 0x12, 0x41, 0xe1, 0x00, 0x12, - 0x81, 0xf4, 0x01, 0xa2, 0xe1, 0x01, 0xa3, 0xd4, 0x01, 0xa4, 0xb5, 0x01, - 0xe5, 0x04, 0x12, 0x01, 0xa7, 0x9e, 0x01, 0x42, 0x22, 0x00, 0x2a, 0x12, - 0x01, 0xe9, 0x02, 0x12, 0x01, 0xaa, 0x87, 0x01, 0xab, 0x7b, 0xac, 0x6f, - 0x42, 0x6c, 0x00, 0x24, 0x12, 0x01, 0xae, 0x51, 0xef, 0x06, 0x12, 0x01, - 0xb0, 0x41, 0x42, 0x43, 0x14, 0x3f, 0x12, 0x01, 0x42, 0x71, 0x00, 0x26, - 0x12, 0x01, 0xb3, 0x29, 0xb4, 0x10, 0xf5, 0x03, 0x12, 0x01, 0x42, 0xf5, - 0x0a, 0x28, 0x12, 0x01, 0x42, 0xbe, 0x22, 0x25, 0x12, 0x41, 0xe1, 0x19, - 0x12, 0x01, 0x42, 0x22, 0x00, 0x1a, 0x12, 0x01, 0xb4, 0x01, 0xff, 0xe1, - 0x14, 0x12, 0x01, 0x42, 0x22, 0x00, 0x15, 0x12, 0x41, 0xe1, 0x29, 0x12, - 0x01, 0x46, 0xb8, 0xdc, 0x40, 0x12, 0x41, 0xe1, 0x1f, 0x12, 0x01, 0x42, - 0x22, 0x00, 0x20, 0x12, 0x41, 0xe1, 0x1e, 0x12, 0x01, 0x42, 0x24, 0x02, - 0x0d, 0x12, 0x01, 0x42, 0x2a, 0x05, 0x18, 0x12, 0x01, 0x42, 0xbe, 0x22, - 0x13, 0x12, 0x41, 0xe1, 0x27, 0x12, 0x01, 0x42, 0x74, 0x00, 0x2b, 0x12, - 0x41, 0xe1, 0x08, 0x12, 0x01, 0x42, 0x22, 0x00, 0x09, 0x12, 0x41, 0xe1, - 0x10, 0x12, 0x01, 0x42, 0x72, 0x19, 0x11, 0x12, 0x41, 0xe1, 0x0a, 0x12, - 0x01, 0x42, 0x24, 0x02, 0x0b, 0x12, 0x01, 0x42, 0x22, 0x00, 0x0c, 0x12, - 0x41, 0xe1, 0x1b, 0x12, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x1d, 0x12, - 0x41, 0xe1, 0x16, 0x12, 0x01, 0x42, 0xf0, 0x10, 0x1c, 0x12, 0x01, 0x42, - 0x22, 0x00, 0x17, 0x12, 0x41, 0xe1, 0x0e, 0x12, 0x01, 0x42, 0x22, 0x00, - 0x0f, 0x12, 0x41, 0xe1, 0x21, 0x12, 0x01, 0x42, 0x16, 0x00, 0x22, 0x12, - 0x01, 0x42, 0x22, 0x00, 0x23, 0x12, 0x41, 0xe1, 0x01, 0x12, 0x01, 0xe9, - 0x05, 0x12, 0x01, 0xf5, 0x07, 0x12, 0x41, 0x44, 0x75, 0x20, 0x38, 0x12, - 0x01, 0x06, 0x3c, 0x01, 0x01, 0xff, 0x45, 0x37, 0x96, 0x39, 0x12, 0x01, - 0x4c, 0x13, 0x27, 0x3c, 0x12, 0x41, 0x54, 0x5b, 0x41, 0xdb, 0x17, 0x00, - 0x06, 0xef, 0x06, 0x8d, 0x07, 0x12, 0xd0, 0x52, 0xaf, 0x06, 0x07, 0xec, - 0x05, 0xe6, 0x04, 0xb3, 0x5d, 0x06, 0x57, 0x39, 0x01, 0xff, 0x0a, 0x02, - 0xac, 0x4c, 0x05, 0x5a, 0x03, 0x01, 0xff, 0xa1, 0x35, 0xe5, 0xc1, 0x17, - 0x00, 0xe9, 0xb7, 0x17, 0x80, 0x24, 0xaf, 0x1a, 0xf5, 0xbb, 0x17, 0x80, - 0x0d, 0xf9, 0xb9, 0x17, 0xc0, 0x00, 0xe1, 0xbf, 0x17, 0x00, 0xf9, 0xba, - 0x17, 0x40, 0xe1, 0xbd, 0x17, 0x00, 0xf5, 0xbc, 0x17, 0x40, 0xe5, 0xbe, - 0x17, 0x00, 0xef, 0xc4, 0x17, 0x40, 0xe5, 0xc0, 0x17, 0x00, 0xe9, 0xb8, - 0x17, 0x40, 0xe1, 0xb6, 0x17, 0x00, 0xe5, 0xc2, 0x17, 0x00, 0xe9, 0xc3, - 0x17, 0x00, 0xf5, 0xc5, 0x17, 0x40, 0xe1, 0xb5, 0x17, 0x00, 0xf1, 0xb4, - 0x17, 0x40, 0x04, 0x5b, 0x03, 0xe9, 0x02, 0x06, 0x60, 0x16, 0x01, 0xff, - 0xa2, 0xc0, 0x02, 0x03, 0x8e, 0xf1, 0xd3, 0x01, 0x0a, 0xf2, 0xac, 0x88, - 0x01, 0x05, 0xff, 0xe8, 0x78, 0xb0, 0x06, 0x49, 0x47, 0xc0, 0xf0, 0x19, - 0x40, 0x49, 0x81, 0xb6, 0xe0, 0x19, 0x00, 0x03, 0xed, 0x75, 0x5a, 0x03, - 0xdf, 0x18, 0x01, 0xff, 0x80, 0x47, 0x8d, 0x01, 0xff, 0xa2, 0x21, 0x05, - 0xff, 0xe8, 0x11, 0x04, 0xec, 0x75, 0x01, 0xff, 0x44, 0x09, 0xf1, 0xe7, - 0x19, 0x00, 0x43, 0x42, 0x3d, 0xf7, 0x19, 0x40, 0x44, 0x09, 0xf1, 0xe6, - 0x19, 0x00, 0x43, 0x42, 0x3d, 0xf6, 0x19, 0x40, 0x03, 0x75, 0x34, 0x11, - 0x04, 0x01, 0xf3, 0x01, 0xff, 0x44, 0x09, 0xf1, 0xe9, 0x19, 0x00, 0x43, - 0x42, 0x3d, 0xf9, 0x19, 0x40, 0x44, 0x09, 0xf1, 0xe8, 0x19, 0x00, 0x43, - 0x42, 0x3d, 0xf8, 0x19, 0x40, 0x44, 0x09, 0xf1, 0xe5, 0x19, 0x00, 0x43, - 0x42, 0x3d, 0xf5, 0x19, 0x40, 0x44, 0x09, 0xf1, 0xe2, 0x19, 0x00, 0x43, - 0x42, 0x3d, 0xf2, 0x19, 0x40, 0x44, 0x09, 0xf1, 0xe1, 0x19, 0x00, 0x43, - 0x42, 0x3d, 0xf1, 0x19, 0x40, 0xa2, 0x38, 0x44, 0xff, 0xe8, 0xf1, 0x17, - 0x00, 0xb0, 0x06, 0x43, 0x3d, 0x1d, 0xf0, 0x17, 0x40, 0x42, 0x6d, 0x28, - 0xf2, 0x17, 0x00, 0x43, 0xdf, 0x18, 0xf5, 0x17, 0xc0, 0x00, 0x8d, 0x01, - 0xff, 0xa2, 0x0c, 0x44, 0xff, 0xe8, 0xf6, 0x17, 0x00, 0x43, 0xec, 0x75, - 0xf7, 0x17, 0x40, 0x42, 0x12, 0x0b, 0xf8, 0x17, 0x00, 0x43, 0x01, 0xf3, - 0xf9, 0x17, 0x40, 0x42, 0x12, 0x0b, 0xf3, 0x17, 0x00, 0x43, 0x01, 0xf3, - 0xf4, 0x17, 0x40, 0x80, 0x5a, 0x8d, 0x01, 0xff, 0xa2, 0x34, 0x05, 0xff, - 0xe8, 0x24, 0xb0, 0x01, 0xff, 0x03, 0xed, 0x75, 0x11, 0x04, 0x09, 0x2f, - 0x01, 0xff, 0x44, 0x09, 0xf1, 0xef, 0x19, 0x00, 0x43, 0x42, 0x3d, 0xff, - 0x19, 0x40, 0x44, 0x09, 0xf1, 0xec, 0x19, 0x00, 0x43, 0x42, 0x3d, 0xfc, - 0x19, 0x40, 0x44, 0x09, 0xf1, 0xeb, 0x19, 0x00, 0x43, 0x42, 0x3d, 0xfb, - 0x19, 0x40, 0x03, 0x75, 0x34, 0x11, 0x04, 0x01, 0xf3, 0x01, 0xff, 0x44, - 0x09, 0xf1, 0xee, 0x19, 0x00, 0x43, 0x42, 0x3d, 0xfe, 0x19, 0x40, 0x44, - 0x09, 0xf1, 0xed, 0x19, 0x00, 0x43, 0x42, 0x3d, 0xfd, 0x19, 0x40, 0x44, - 0x09, 0xf1, 0xea, 0x19, 0x00, 0x43, 0x42, 0x3d, 0xfa, 0x19, 0x40, 0x03, - 0x75, 0x34, 0x11, 0x04, 0x01, 0xf3, 0x01, 0xff, 0x44, 0x09, 0xf1, 0xe4, - 0x19, 0x00, 0x43, 0x42, 0x3d, 0xf4, 0x19, 0x40, 0x44, 0x09, 0xf1, 0xe3, - 0x19, 0x00, 0x43, 0x42, 0x3d, 0xf3, 0x19, 0x40, 0xa1, 0x84, 0x01, 0xa2, - 0x68, 0xa3, 0x5a, 0xab, 0x46, 0x47, 0xe8, 0xd2, 0xd7, 0x17, 0x00, 0x4b, - 0xeb, 0x9f, 0xc9, 0x17, 0x00, 0x47, 0xac, 0xd3, 0xc6, 0x17, 0x00, 0x4b, - 0x6c, 0xa1, 0xd9, 0x17, 0x00, 0xb2, 0x20, 0x4d, 0x8a, 0x88, 0xd0, 0x17, - 0x00, 0xb4, 0x0c, 0x46, 0x4a, 0xe1, 0xd1, 0x17, 0x00, 0x4d, 0xfa, 0x8a, - 0xc8, 0x17, 0x40, 0x4a, 0xb4, 0xae, 0xcd, 0x17, 0x00, 0x46, 0xb2, 0xdf, - 0xca, 0x17, 0x40, 0x46, 0x38, 0xdb, 0xc7, 0x17, 0x00, 0x44, 0xd9, 0xf1, - 0xcc, 0x17, 0x40, 0x46, 0xca, 0xd9, 0xce, 0x17, 0x00, 0x43, 0x90, 0x00, - 0xd4, 0x17, 0x00, 0x46, 0xf2, 0xde, 0xda, 0x17, 0x40, 0x4e, 0xe6, 0x75, - 0xd6, 0x17, 0x00, 0x44, 0x2a, 0xe9, 0xd2, 0x17, 0x40, 0xa1, 0x06, 0x45, - 0x61, 0xe6, 0xd8, 0x17, 0x40, 0x44, 0xc5, 0xf1, 0xcb, 0x17, 0x00, 0x48, - 0x91, 0xca, 0xd5, 0x17, 0x00, 0x48, 0x82, 0xb6, 0xd3, 0x17, 0x40, 0x44, - 0x75, 0xf0, 0xcf, 0x17, 0x00, 0x47, 0xb5, 0xd6, 0xdd, 0x17, 0x00, 0x4c, - 0xd8, 0x96, 0xdc, 0x17, 0x40, 0x42, 0x16, 0x00, 0x94, 0x17, 0x00, 0xa3, - 0xa9, 0x01, 0xa4, 0x9e, 0x01, 0x42, 0x22, 0x00, 0xa0, 0x17, 0x00, 0xab, - 0x83, 0x01, 0xac, 0x79, 0x42, 0xc3, 0x07, 0x98, 0x17, 0x00, 0xae, 0x5b, - 0xb0, 0x4b, 0x42, 0x43, 0x14, 0xa2, 0x17, 0x00, 0x42, 0xd0, 0x00, 0x9a, - 0x17, 0x00, 0xb3, 0x2d, 0xb4, 0x0c, 0x42, 0x26, 0x1d, 0x9c, 0x17, 0x00, - 0x42, 0xb0, 0x47, 0x99, 0x17, 0x40, 0xe1, 0x8f, 0x17, 0x00, 0xa8, 0x11, - 0xef, 0x91, 0x17, 0x00, 0x02, 0x53, 0x00, 0x01, 0xff, 0xe1, 0x8b, 0x17, - 0x00, 0xef, 0x8d, 0x17, 0x40, 0xe1, 0x90, 0x17, 0x00, 0xef, 0x92, 0x17, - 0x40, 0xe1, 0x9f, 0x17, 0x00, 0x42, 0x22, 0x00, 0x9d, 0x17, 0x00, 0x42, - 0x60, 0x03, 0x9e, 0x17, 0x40, 0xa8, 0x04, 0xef, 0x96, 0x17, 0x40, 0xe1, - 0x95, 0x17, 0x00, 0xef, 0x97, 0x17, 0x40, 0x42, 0x06, 0x14, 0x84, 0x17, - 0x00, 0x42, 0xb4, 0x01, 0x8e, 0x17, 0x00, 0xef, 0x93, 0x17, 0x00, 0x42, - 0xb0, 0x47, 0x89, 0x17, 0x40, 0xe1, 0xa1, 0x17, 0x00, 0xef, 0x9b, 0x17, - 0x40, 0xe1, 0x80, 0x17, 0x00, 0xa8, 0x04, 0xef, 0x82, 0x17, 0x40, 0xe1, - 0x81, 0x17, 0x00, 0xef, 0x83, 0x17, 0x40, 0xe1, 0x8a, 0x17, 0x00, 0xef, - 0x8c, 0x17, 0x40, 0xe1, 0x85, 0x17, 0x00, 0xa8, 0x04, 0xef, 0x87, 0x17, - 0x40, 0xe1, 0x86, 0x17, 0x00, 0xef, 0x88, 0x17, 0x40, 0x42, 0x75, 0x0b, - 0xad, 0x17, 0x80, 0x4e, 0xb1, 0x0b, 0x42, 0x83, 0x0a, 0xab, 0x17, 0xc0, - 0x00, 0xf9, 0xac, 0x17, 0x40, 0xa1, 0x2f, 0xe5, 0xaf, 0x17, 0x00, 0xe9, - 0xa5, 0x17, 0x80, 0x22, 0x08, 0x79, 0xc9, 0x12, 0xf5, 0xa7, 0x17, 0xc0, - 0x00, 0xeb, 0xa8, 0x17, 0x00, 0xf5, 0xa9, 0x17, 0xc0, 0x00, 0xf6, 0xaa, - 0x17, 0x40, 0x43, 0x0e, 0x0b, 0xb1, 0x17, 0x00, 0x43, 0x1f, 0x0a, 0xb2, - 0x17, 0x40, 0xe9, 0xa6, 0x17, 0x40, 0xe1, 0xa4, 0x17, 0x00, 0xe9, 0xb0, - 0x17, 0x00, 0xf1, 0xa3, 0x17, 0x00, 0xf5, 0xb3, 0x17, 0x40, 0xf9, 0xae, - 0x17, 0x40, 0x45, 0x12, 0x0b, 0xe8, 0x17, 0x00, 0xa6, 0x2e, 0x44, 0xea, - 0x2a, 0xe9, 0x17, 0x00, 0x43, 0x0e, 0x0b, 0xe1, 0x17, 0x00, 0xb3, 0x14, - 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xe0, 0x17, 0x40, 0x44, 0x25, 0x01, 0xe3, - 0x17, 0x00, 0x42, 0x15, 0x02, 0xe2, 0x17, 0x40, 0x44, 0xe5, 0x1d, 0xe7, - 0x17, 0x00, 0x42, 0x1c, 0x26, 0xe6, 0x17, 0x40, 0x43, 0xd2, 0x05, 0xe5, - 0x17, 0x00, 0x43, 0xf6, 0x06, 0xe4, 0x17, 0x40, 0x4a, 0xba, 0xa8, 0x04, - 0xd8, 0x80, 0x06, 0x46, 0xbc, 0x82, 0xe4, 0x6f, 0x41, 0x45, 0x79, 0xe2, - 0xff, 0x8c, 0x41, 0x43, 0x42, 0x18, 0xaf, 0xfa, 0x01, 0x08, 0x99, 0xca, - 0x01, 0xff, 0x06, 0xef, 0x06, 0xae, 0x03, 0x51, 0x25, 0x5a, 0x48, 0x0a, - 0x01, 0x07, 0xec, 0x05, 0xc0, 0x01, 0x07, 0x1a, 0x3a, 0x9c, 0x01, 0x0c, - 0x6d, 0x16, 0x5b, 0x05, 0x5a, 0x03, 0x2f, 0xb6, 0x01, 0xff, 0x45, 0xe6, - 0x23, 0x3f, 0x0a, 0x01, 0x05, 0x58, 0x39, 0x01, 0xff, 0x4b, 0x5d, 0x39, - 0x0c, 0x0a, 0x01, 0x05, 0x5a, 0x03, 0x01, 0xff, 0xe5, 0x05, 0x0a, 0x01, - 0xe9, 0x01, 0x0a, 0x01, 0xef, 0x06, 0x0a, 0x01, 0xf5, 0x02, 0x0a, 0x01, - 0x49, 0x43, 0xc1, 0x03, 0x0a, 0x41, 0x48, 0x3c, 0x16, 0x0e, 0x0a, 0x01, - 0x49, 0x16, 0x33, 0x38, 0x0a, 0x01, 0x45, 0x1c, 0xe5, 0x39, 0x0a, 0x01, - 0x02, 0x3b, 0x01, 0x06, 0x47, 0xf1, 0x4b, 0x0f, 0x0a, 0x41, 0x47, 0xa1, - 0x12, 0x3a, 0x0a, 0x01, 0x4f, 0x2f, 0x74, 0x0d, 0x0a, 0x41, 0xa3, 0x2f, - 0xa4, 0x1a, 0xac, 0x0c, 0x48, 0x49, 0xc8, 0x54, 0x0a, 0x01, 0x4c, 0x3f, - 0x15, 0x51, 0x0a, 0x41, 0x44, 0xb4, 0x27, 0x58, 0x0a, 0x01, 0x44, 0xbb, - 0x79, 0x55, 0x0a, 0x41, 0x44, 0x75, 0x20, 0x56, 0x0a, 0x01, 0xaf, 0x01, - 0xff, 0xf4, 0x50, 0x0a, 0x01, 0x4a, 0x2b, 0xa1, 0x57, 0x0a, 0x41, 0x45, - 0x13, 0x03, 0x52, 0x0a, 0x01, 0x4b, 0x9d, 0x8d, 0x53, 0x0a, 0x41, 0x04, - 0x0e, 0x0b, 0x0f, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x44, 0x0a, 0x01, - 0x45, 0x9a, 0x2c, 0x45, 0x0a, 0x41, 0x47, 0x71, 0x11, 0x46, 0x0a, 0x01, - 0x48, 0x47, 0x5e, 0x47, 0x0a, 0x41, 0xe1, 0x00, 0x0a, 0x01, 0xa2, 0xd2, - 0x01, 0xa3, 0xc5, 0x01, 0xa4, 0xac, 0x01, 0xa7, 0x9f, 0x01, 0x42, 0x22, - 0x00, 0x31, 0x0a, 0x01, 0x42, 0x72, 0x19, 0x17, 0x0a, 0x01, 0xab, 0x80, - 0x01, 0x42, 0x74, 0x00, 0x2b, 0x0a, 0x01, 0x42, 0x6c, 0x00, 0x28, 0x0a, - 0x01, 0xae, 0x62, 0xb0, 0x56, 0x42, 0x71, 0x00, 0x2a, 0x0a, 0x01, 0xb3, - 0x3e, 0xb4, 0x18, 0xb6, 0x0c, 0x42, 0xbe, 0x22, 0x29, 0x0a, 0x01, 0x42, - 0x59, 0x00, 0x30, 0x0a, 0x41, 0xe1, 0x2c, 0x0a, 0x01, 0x42, 0x22, 0x00, - 0x35, 0x0a, 0x41, 0xe1, 0x1f, 0x0a, 0x01, 0x42, 0x22, 0x00, 0x20, 0x0a, - 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x1a, 0x0a, 0x01, 0x42, 0x22, 0x00, 0x1b, - 0x0a, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x34, 0x0a, 0x01, 0x42, 0x22, 0x00, - 0x33, 0x0a, 0x41, 0xe1, 0x2f, 0x0a, 0x01, 0x42, 0x22, 0x00, 0x2d, 0x0a, - 0x01, 0x42, 0x40, 0x06, 0x2e, 0x0a, 0x41, 0xe1, 0x24, 0x0a, 0x01, 0x42, - 0x22, 0x00, 0x25, 0x0a, 0x41, 0xe1, 0x23, 0x0a, 0x01, 0x42, 0x2a, 0x05, - 0x1e, 0x0a, 0x01, 0x42, 0xbe, 0x22, 0x19, 0x0a, 0x41, 0xe1, 0x10, 0x0a, - 0x01, 0x42, 0x22, 0x00, 0x11, 0x0a, 0x01, 0x42, 0x1b, 0x02, 0x32, 0x0a, - 0x41, 0xe1, 0x12, 0x0a, 0x01, 0x42, 0x22, 0x00, 0x13, 0x0a, 0x41, 0xe1, - 0x21, 0x0a, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x22, 0x0a, 0x41, 0xe1, - 0x1c, 0x0a, 0x01, 0x42, 0x22, 0x00, 0x1d, 0x0a, 0x41, 0xe1, 0x15, 0x0a, - 0x01, 0x42, 0x22, 0x00, 0x16, 0x0a, 0x41, 0xe1, 0x26, 0x0a, 0x01, 0x42, - 0x22, 0x00, 0x27, 0x0a, 0x41, 0x44, 0xf5, 0x06, 0x43, 0x0a, 0x01, 0x43, - 0x0e, 0x0b, 0x40, 0x0a, 0x01, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0x42, - 0x0a, 0x01, 0x42, 0x15, 0x02, 0x41, 0x0a, 0x41, 0x49, 0xe2, 0xbb, 0x2a, - 0x21, 0x00, 0xf9, 0x11, 0xf5, 0xc1, 0x00, 0x45, 0x75, 0x14, 0x28, 0x23, - 0x80, 0x0c, 0x47, 0xe6, 0xcf, 0x1f, 0xf5, 0x01, 0x44, 0xb4, 0x20, 0xb1, - 0xce, 0x41, 0x4a, 0xe0, 0xa5, 0xa6, 0xf5, 0x41, 0x43, 0xef, 0x60, 0x4b, - 0xf5, 0x01, 0x05, 0xba, 0xe7, 0x99, 0x1d, 0x0f, 0x34, 0x6f, 0x8a, 0x1c, - 0xae, 0xf2, 0x0b, 0x06, 0xbd, 0x67, 0xda, 0x06, 0x03, 0xf0, 0xe1, 0xb4, - 0x02, 0x07, 0xe9, 0xd7, 0x01, 0xff, 0x06, 0xef, 0x06, 0xe8, 0x01, 0x07, - 0xec, 0x05, 0x42, 0x05, 0x5a, 0x03, 0x32, 0x05, 0x56, 0x2d, 0x1b, 0x06, - 0x57, 0x39, 0x01, 0xff, 0xe5, 0x27, 0xa9, 0x80, 0x0d, 0xef, 0x2a, 0xa9, - 0x00, 0xf5, 0x28, 0xa9, 0xc0, 0x00, 0xe5, 0x26, 0xa9, 0x40, 0xe5, 0x29, - 0xa9, 0x40, 0x45, 0x12, 0xe5, 0x2c, 0xa9, 0x80, 0x06, 0x46, 0x94, 0xcd, - 0x2b, 0xa9, 0x40, 0x47, 0x93, 0xcd, 0x2d, 0xa9, 0x40, 0x43, 0x31, 0xf4, - 0x2e, 0xa9, 0x00, 0x44, 0xc9, 0xf2, 0x2f, 0xa9, 0x40, 0xe1, 0x22, 0xa9, - 0x00, 0x42, 0x16, 0x00, 0x19, 0xa9, 0x00, 0x42, 0x37, 0x00, 0x21, 0xa9, - 0x00, 0x42, 0xf0, 0x10, 0x18, 0xa9, 0x00, 0x42, 0x24, 0x02, 0x0c, 0xa9, - 0x00, 0xa8, 0x7a, 0xe9, 0x24, 0xa9, 0x00, 0xab, 0x6a, 0x42, 0x74, 0x00, - 0x1c, 0xa9, 0x00, 0x42, 0x6c, 0x00, 0x17, 0xa9, 0x00, 0xae, 0x4c, 0xaf, - 0x42, 0xb0, 0x36, 0x42, 0x71, 0x00, 0x1a, 0xa9, 0x00, 0xb3, 0x24, 0xb4, - 0x18, 0x42, 0xf5, 0x0a, 0x20, 0xa9, 0x00, 0x42, 0xa9, 0x01, 0x1d, 0xa9, - 0x00, 0x42, 0xbe, 0x22, 0x1b, 0xa9, 0x00, 0x42, 0x59, 0x00, 0x10, 0xa9, - 0x40, 0xe1, 0x12, 0xa9, 0x00, 0x42, 0x22, 0x00, 0x1e, 0xa9, 0x40, 0xe1, - 0x0e, 0xa9, 0x00, 0x42, 0x22, 0x00, 0x0f, 0xa9, 0x40, 0xe1, 0x15, 0xa9, - 0x00, 0x42, 0x22, 0x00, 0x16, 0xa9, 0x40, 0xe5, 0x23, 0xa9, 0x00, 0xef, - 0x25, 0xa9, 0x40, 0xe1, 0x14, 0xa9, 0x00, 0x42, 0x24, 0x02, 0x0d, 0xa9, - 0x00, 0x42, 0xbe, 0x22, 0x11, 0xa9, 0x40, 0xe1, 0x0a, 0xa9, 0x00, 0x42, - 0x22, 0x00, 0x0b, 0xa9, 0x40, 0xe1, 0x1f, 0xa9, 0x00, 0x42, 0x12, 0x00, - 0x13, 0xa9, 0x40, 0x45, 0x12, 0x0b, 0x08, 0xa9, 0x00, 0xa6, 0x2e, 0x44, - 0xea, 0x2a, 0x09, 0xa9, 0x00, 0x43, 0x0e, 0x0b, 0x01, 0xa9, 0x00, 0xb3, - 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x00, 0xa9, 0x40, 0x44, 0x25, 0x01, - 0x03, 0xa9, 0x00, 0x42, 0x15, 0x02, 0x02, 0xa9, 0x40, 0x44, 0xe5, 0x1d, - 0x07, 0xa9, 0x00, 0x42, 0x1c, 0x26, 0x06, 0xa9, 0x40, 0x43, 0xd2, 0x05, - 0x05, 0xa9, 0x00, 0x43, 0xf6, 0x06, 0x04, 0xa9, 0x40, 0x49, 0x7d, 0xb7, - 0x42, 0x1f, 0x01, 0xa4, 0xc6, 0x03, 0x07, 0xec, 0x05, 0xaf, 0x01, 0x0c, - 0x6d, 0x16, 0x5e, 0x05, 0x5a, 0x03, 0x36, 0x0b, 0x55, 0x77, 0x01, 0xff, - 0xa1, 0x21, 0xe5, 0x3e, 0x1f, 0x81, 0x18, 0xe9, 0x36, 0x1f, 0x81, 0x0f, - 0xf5, 0x38, 0x1f, 0x81, 0x06, 0x49, 0x43, 0xc1, 0x3a, 0x1f, 0x41, 0xf5, - 0x39, 0x1f, 0x41, 0xe9, 0x37, 0x1f, 0x41, 0xf5, 0x40, 0x1f, 0x41, 0xe1, - 0x34, 0x1f, 0x01, 0xe9, 0x3f, 0x1f, 0x01, 0x4b, 0x30, 0x9f, 0x35, 0x1f, - 0x41, 0x48, 0x3c, 0x16, 0x01, 0x1f, 0x01, 0x4b, 0xd9, 0x23, 0x00, 0x1f, - 0x01, 0x46, 0x84, 0xdd, 0x41, 0x1f, 0x01, 0x45, 0x5a, 0x3f, 0x5a, 0x1f, - 0x01, 0x45, 0x76, 0xea, 0x02, 0x1f, 0x01, 0x47, 0xf1, 0x4b, 0x03, 0x1f, - 0x41, 0x58, 0x09, 0x27, 0x46, 0x1f, 0x01, 0xa3, 0x39, 0x02, 0x3b, 0x01, - 0x2b, 0xa6, 0x1d, 0xb3, 0x06, 0x4a, 0x56, 0xb2, 0x4b, 0x1f, 0x41, 0x4d, - 0x14, 0x27, 0x45, 0x1f, 0x01, 0xb0, 0x01, 0xff, 0x4a, 0x7a, 0xa7, 0x48, - 0x1f, 0x01, 0x44, 0x6d, 0x85, 0x4e, 0x1f, 0x41, 0x4c, 0x00, 0x90, 0x4d, - 0x1f, 0x01, 0x45, 0x13, 0x01, 0x47, 0x1f, 0x41, 0xf4, 0x49, 0x1f, 0x01, - 0x48, 0xc1, 0x41, 0x4a, 0x1f, 0x41, 0x45, 0x13, 0x03, 0x4c, 0x1f, 0x01, - 0x4d, 0x64, 0x85, 0x4f, 0x1f, 0x41, 0xe1, 0x04, 0x1f, 0x81, 0x84, 0x02, - 0xa2, 0xf7, 0x01, 0xa3, 0xea, 0x01, 0xa4, 0xd1, 0x01, 0xe5, 0x0e, 0x1f, - 0x01, 0xa7, 0xc0, 0x01, 0x42, 0x22, 0x00, 0x32, 0x1f, 0x01, 0xe9, 0x06, - 0x1f, 0x81, 0xb0, 0x01, 0xaa, 0x9d, 0x01, 0xab, 0x90, 0x01, 0x42, 0x74, - 0x00, 0x2d, 0x1f, 0x01, 0x42, 0x6c, 0x00, 0x2a, 0x1f, 0x01, 0xae, 0x6c, - 0xef, 0x10, 0x1f, 0x01, 0xb0, 0x5c, 0x42, 0x71, 0x00, 0x2c, 0x1f, 0x01, - 0xb3, 0x44, 0xb4, 0x2b, 0xf5, 0x08, 0x1f, 0x81, 0x22, 0x08, 0x43, 0xc1, - 0x0c, 0x42, 0xa9, 0x01, 0x2e, 0x1f, 0x01, 0x42, 0xbe, 0x22, 0x2b, 0x1f, - 0x41, 0xec, 0x0c, 0x1f, 0x81, 0x09, 0xf2, 0x0a, 0x1f, 0xc1, 0x00, 0xf2, - 0x0b, 0x1f, 0x41, 0xec, 0x0d, 0x1f, 0x41, 0xf5, 0x09, 0x1f, 0x41, 0xe1, - 0x21, 0x1f, 0x01, 0x42, 0x22, 0x00, 0x22, 0x1f, 0x01, 0xb4, 0x01, 0xff, - 0xe1, 0x1c, 0x1f, 0x01, 0x42, 0x22, 0x00, 0x1d, 0x1f, 0x41, 0xe1, 0x31, - 0x1f, 0x01, 0x42, 0x22, 0x00, 0x2f, 0x1f, 0x01, 0x42, 0x40, 0x06, 0x30, - 0x1f, 0x41, 0xe1, 0x26, 0x1f, 0x01, 0x42, 0x22, 0x00, 0x27, 0x1f, 0x41, - 0xe1, 0x25, 0x1f, 0x01, 0x42, 0x24, 0x02, 0x16, 0x1f, 0x01, 0x42, 0x2a, - 0x05, 0x20, 0x1f, 0x01, 0x42, 0xbe, 0x22, 0x1b, 0x1f, 0x41, 0xe1, 0x12, - 0x1f, 0x01, 0x42, 0x22, 0x00, 0x13, 0x1f, 0x41, 0xe1, 0x19, 0x1f, 0x01, - 0x42, 0x22, 0x00, 0x1a, 0x1f, 0x01, 0x43, 0xc1, 0x35, 0x33, 0x1f, 0x41, - 0xe9, 0x07, 0x1f, 0x41, 0xe1, 0x14, 0x1f, 0x01, 0x42, 0x22, 0x00, 0x15, - 0x1f, 0x41, 0xe1, 0x23, 0x1f, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x24, - 0x1f, 0x41, 0xe1, 0x1e, 0x1f, 0x01, 0x42, 0x22, 0x00, 0x1f, 0x1f, 0x41, - 0xe1, 0x17, 0x1f, 0x01, 0x42, 0x22, 0x00, 0x18, 0x1f, 0x41, 0xe1, 0x28, - 0x1f, 0x01, 0x42, 0x22, 0x00, 0x29, 0x1f, 0x41, 0xe1, 0x05, 0x1f, 0x01, - 0xe9, 0x0f, 0x1f, 0x41, 0x44, 0x75, 0x20, 0x43, 0x1f, 0x01, 0x05, 0xf0, - 0x06, 0x06, 0x4b, 0x2a, 0xa1, 0x44, 0x1f, 0x41, 0x45, 0x12, 0x0b, 0x58, - 0x1f, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x59, 0x1f, 0x01, 0x43, 0x0e, - 0x0b, 0x51, 0x1f, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x50, - 0x1f, 0x41, 0x44, 0x25, 0x01, 0x53, 0x1f, 0x01, 0x42, 0x15, 0x02, 0x52, - 0x1f, 0x41, 0x44, 0xe5, 0x1d, 0x57, 0x1f, 0x01, 0x42, 0x1c, 0x26, 0x56, - 0x1f, 0x41, 0x43, 0xd2, 0x05, 0x55, 0x1f, 0x01, 0x43, 0xf6, 0x06, 0x54, - 0x1f, 0x41, 0x80, 0x1d, 0x0a, 0x45, 0x12, 0x01, 0xff, 0x4d, 0x31, 0x82, - 0xa0, 0x30, 0x00, 0x54, 0x4f, 0x12, 0xfc, 0x30, 0x00, 0x56, 0x36, 0x37, - 0x9c, 0x30, 0x00, 0x51, 0x3b, 0x37, 0x9b, 0x30, 0x40, 0x4c, 0x14, 0x8e, - 0xff, 0x30, 0x00, 0x4e, 0x5a, 0x20, 0xfd, 0x30, 0x00, 0x07, 0xec, 0x05, - 0x0c, 0x4a, 0xed, 0x45, 0xfb, 0x30, 0x00, 0x55, 0x11, 0x3f, 0xfe, 0x30, - 0x40, 0xe1, 0xa2, 0x30, 0x80, 0xb8, 0x04, 0xa2, 0xa1, 0x04, 0xa4, 0x8a, - 0x04, 0xe5, 0xa8, 0x30, 0x00, 0xa7, 0xef, 0x03, 0xa8, 0xd8, 0x03, 0xe9, - 0xa4, 0x30, 0x00, 0xab, 0xbd, 0x03, 0xad, 0xe3, 0x02, 0xee, 0xf3, 0x30, - 0x80, 0xc9, 0x02, 0xef, 0xaa, 0x30, 0x00, 0xb0, 0xae, 0x02, 0xb2, 0x97, - 0x02, 0xb3, 0x67, 0xb4, 0x51, 0xf5, 0xa6, 0x30, 0x00, 0xb6, 0x37, 0xb7, - 0x25, 0xb9, 0x17, 0xba, 0x01, 0xff, 0xe1, 0xb6, 0x30, 0x00, 0xe5, 0xbc, - 0x30, 0x00, 0xe9, 0xb8, 0x30, 0x00, 0xef, 0xbe, 0x30, 0x00, 0xf5, 0xba, - 0x30, 0x40, 0xe1, 0xe4, 0x30, 0x00, 0xef, 0xe8, 0x30, 0x00, 0xf5, 0xe6, - 0x30, 0x40, 0xe1, 0xef, 0x30, 0x00, 0xe5, 0xf1, 0x30, 0x00, 0xe9, 0xf0, - 0x30, 0x00, 0xef, 0xf2, 0x30, 0x40, 0xe1, 0xf7, 0x30, 0x00, 0xe5, 0xf9, - 0x30, 0x00, 0xe9, 0xf8, 0x30, 0x00, 0xef, 0xfa, 0x30, 0x00, 0xf5, 0xf4, - 0x30, 0x40, 0xe1, 0xbf, 0x30, 0x00, 0xe5, 0xc6, 0x30, 0x00, 0xe9, 0xc1, - 0x30, 0x00, 0xef, 0xc8, 0x30, 0x00, 0xf5, 0xc4, 0x30, 0x40, 0xe1, 0xb5, - 0x30, 0x00, 0xe5, 0xbb, 0x30, 0x00, 0xe9, 0xb7, 0x30, 0x00, 0x05, 0x5e, - 0x07, 0x08, 0xef, 0xbd, 0x30, 0x00, 0xf5, 0xb9, 0x30, 0x40, 0xe1, 0xa1, - 0x30, 0x00, 0xe5, 0xa7, 0x30, 0x00, 0xa8, 0x78, 0xe9, 0xa3, 0x30, 0x00, - 0xab, 0x62, 0x42, 0xc3, 0x16, 0xfa, 0x31, 0x00, 0xee, 0x67, 0xb1, 0x81, + 0x00, 0x43, 0x68, 0x00, 0x22, 0xa7, 0x40, 0x45, 0x1c, 0x3b, 0xc9, 0x00, + 0x00, 0xa2, 0xab, 0x01, 0xa3, 0x64, 0xa4, 0x43, 0x45, 0x51, 0x24, 0xc8, + 0x00, 0x00, 0x4a, 0xb4, 0xb0, 0xba, 0x1e, 0x00, 0x4e, 0x9a, 0x24, 0x06, + 0x02, 0x00, 0x46, 0xd1, 0x73, 0x12, 0x01, 0x80, 0x19, 0x46, 0xb0, 0xe4, + 0x18, 0x01, 0x00, 0x46, 0x52, 0x05, 0x46, 0x02, 0x00, 0x45, 0x71, 0x24, + 0xbc, 0x1e, 0xc0, 0x00, 0x46, 0x1f, 0x07, 0x1a, 0x1e, 0x40, 0x05, 0x19, + 0x00, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0x16, 0x1e, 0x00, 0x45, 0x51, 0x24, + 0x14, 0x1e, 0x40, 0x48, 0xf4, 0x24, 0xcb, 0x00, 0x00, 0xaf, 0x01, 0xff, + 0x02, 0xc6, 0x00, 0x06, 0x4a, 0x4c, 0x24, 0x04, 0x02, 0x40, 0x45, 0x5c, + 0x00, 0x16, 0x01, 0x00, 0x45, 0x20, 0x07, 0xb8, 0x1e, 0x40, 0x44, 0x0b, + 0x70, 0x1a, 0x01, 0x00, 0x46, 0x2a, 0x98, 0x28, 0x02, 0x80, 0x32, 0x49, + 0xd0, 0x04, 0xca, 0x00, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x04, 0x1a, 0x00, + 0x06, 0x45, 0x20, 0x07, 0x18, 0x1e, 0x40, 0x45, 0x1c, 0x3b, 0xbe, 0x1e, + 0x00, 0x49, 0x6d, 0x13, 0xc6, 0x1e, 0x00, 0x45, 0x51, 0x24, 0xc0, 0x1e, + 0x00, 0x4a, 0xb4, 0xb0, 0xc2, 0x1e, 0x00, 0x45, 0x71, 0x24, 0xc4, 0x1e, + 0x40, 0x4a, 0xf6, 0xaa, 0x1c, 0x1e, 0x40, 0x4a, 0x56, 0xaf, 0x81, 0xdf, + 0x01, 0x44, 0x26, 0x14, 0x14, 0x01, 0x40, 0x06, 0x50, 0x00, 0x1b, 0x06, + 0x3c, 0x01, 0x0b, 0xfa, 0xf1, 0x01, 0xc0, 0x00, 0x4b, 0x01, 0x9d, 0xc4, + 0x01, 0x40, 0x45, 0x5b, 0x4c, 0xd2, 0xa7, 0x00, 0x44, 0xb3, 0xa9, 0xd4, + 0xa7, 0x40, 0xa3, 0x3d, 0x04, 0x6f, 0x0c, 0x2d, 0x44, 0x5b, 0x0f, 0x8a, + 0x01, 0x00, 0x4a, 0xc1, 0x70, 0x0e, 0x1e, 0x00, 0xb3, 0x06, 0x46, 0x5a, + 0xaf, 0x8b, 0x01, 0x40, 0x53, 0x3a, 0x4c, 0xc7, 0xa7, 0x00, 0x4d, 0xba, + 0x89, 0xf2, 0x01, 0x80, 0x06, 0x45, 0x53, 0x05, 0x10, 0x01, 0x40, 0x4b, + 0x01, 0x9d, 0xc5, 0x01, 0x40, 0x45, 0x5c, 0x00, 0x0a, 0x1e, 0x00, 0x45, + 0x20, 0x07, 0x0c, 0x1e, 0x40, 0x44, 0x0b, 0x70, 0x0e, 0x01, 0x00, 0x46, + 0x2a, 0x98, 0x10, 0x1e, 0x00, 0x4f, 0x15, 0x72, 0x12, 0x1e, 0x40, 0x06, + 0x50, 0x00, 0x30, 0x42, 0x49, 0x00, 0xb3, 0xa7, 0x00, 0x06, 0x82, 0x1c, + 0x13, 0x42, 0x10, 0x00, 0x6e, 0xa7, 0x00, 0x48, 0xa7, 0xd1, 0x2c, 0xa7, + 0xc0, 0x00, 0x4b, 0x0c, 0x9d, 0x2e, 0xa7, 0x40, 0x49, 0x56, 0xc0, 0xd0, + 0xa7, 0x00, 0x45, 0x37, 0x92, 0xdd, 0xa7, 0xc0, 0x00, 0x4f, 0x38, 0x6d, + 0x74, 0xdf, 0x41, 0x45, 0x1c, 0x3b, 0x06, 0x01, 0x00, 0x43, 0x16, 0x00, + 0x92, 0xa7, 0x00, 0xa3, 0x18, 0x49, 0x77, 0x1f, 0x0a, 0x01, 0x00, 0x44, + 0x5b, 0x0f, 0x87, 0x01, 0x00, 0x4c, 0x47, 0x3d, 0xc4, 0xa7, 0x00, 0x46, + 0x52, 0x05, 0x3b, 0x02, 0x40, 0x44, 0x0b, 0x70, 0x0c, 0x01, 0x00, 0x46, + 0x2a, 0x98, 0xc7, 0x00, 0x80, 0x06, 0x49, 0xd0, 0x04, 0x08, 0x01, 0x40, + 0x4a, 0xe2, 0xaa, 0x08, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x24, 0x06, 0xda, + 0x84, 0x0c, 0x43, 0x43, 0x10, 0xb4, 0xa7, 0x00, 0x47, 0x58, 0xdb, 0x46, + 0xa7, 0x40, 0xe1, 0x40, 0xdf, 0x01, 0xeb, 0x48, 0xdf, 0x01, 0xed, 0x4a, + 0xdf, 0x01, 0xee, 0x4d, 0xdf, 0x01, 0xf6, 0x51, 0xdf, 0x41, 0x04, 0x6f, + 0x0c, 0x1e, 0x48, 0xdf, 0xcb, 0x96, 0xa7, 0x00, 0x44, 0x5b, 0x0f, 0x81, + 0x01, 0x00, 0x4a, 0xc1, 0x70, 0x06, 0x1e, 0x00, 0x46, 0x52, 0x05, 0x43, + 0x02, 0x00, 0x46, 0x5a, 0xaf, 0x82, 0x01, 0x40, 0x45, 0x5c, 0x00, 0x02, + 0x1e, 0x00, 0x45, 0x20, 0x07, 0x04, 0x1e, 0x40, 0x06, 0x50, 0x00, 0x43, + 0xe1, 0x32, 0xa7, 0x00, 0xe5, 0xc6, 0x00, 0x80, 0x29, 0x48, 0xf7, 0xcb, + 0x89, 0x01, 0x00, 0x44, 0x40, 0xea, 0x6d, 0x2c, 0x00, 0x4a, 0xe8, 0xb3, + 0xc2, 0xa7, 0x00, 0xef, 0x34, 0xa7, 0x00, 0xf5, 0x36, 0xa7, 0x00, 0xf6, + 0x38, 0xa7, 0x80, 0x04, 0xf9, 0x3c, 0xa7, 0x40, 0x54, 0x0f, 0x42, 0x3a, + 0xa7, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0xfc, 0x01, + 0x00, 0x46, 0xd1, 0x73, 0xe2, 0x01, 0x40, 0x45, 0x1c, 0x3b, 0xc1, 0x00, + 0x00, 0x45, 0x8f, 0x24, 0x02, 0x01, 0x80, 0xab, 0x01, 0xa3, 0x79, 0xa4, + 0x4a, 0x45, 0x51, 0x24, 0xc0, 0x00, 0x00, 0x4a, 0xb4, 0xb0, 0xa2, 0x1e, + 0x00, 0x4e, 0x9a, 0x24, 0x02, 0x02, 0x00, 0x46, 0xd1, 0x73, 0x00, 0x01, + 0x00, 0x46, 0xb0, 0xe4, 0x04, 0x01, 0x00, 0x05, 0x22, 0x08, 0x15, 0x46, + 0x52, 0x05, 0x3a, 0x02, 0x00, 0xb4, 0x01, 0xff, 0x44, 0x72, 0x24, 0xc3, + 0x00, 0x00, 0x45, 0x5b, 0xaf, 0x80, 0xdf, 0x41, 0x45, 0x5c, 0x00, 0xc5, + 0x00, 0x80, 0x06, 0x45, 0x20, 0x07, 0x00, 0x1e, 0x40, 0x4a, 0xe2, 0xaa, + 0xfa, 0x01, 0x40, 0x48, 0xf4, 0x24, 0xc4, 0x00, 0x80, 0x20, 0xaf, 0x01, + 0xff, 0x02, 0xc6, 0x00, 0x06, 0x4a, 0x4c, 0x24, 0x00, 0x02, 0x40, 0x45, + 0x5c, 0x00, 0x26, 0x02, 0x80, 0x06, 0x45, 0x20, 0x07, 0xa0, 0x1e, 0x40, + 0x4b, 0x5c, 0x9c, 0xe0, 0x01, 0x40, 0x4b, 0x5c, 0x9c, 0xde, 0x01, 0x40, + 0x44, 0x0b, 0x70, 0xcd, 0x01, 0x00, 0x49, 0xd0, 0x04, 0xc2, 0x00, 0xc0, + 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0xa4, 0x1e, 0x00, + 0x49, 0x6d, 0x13, 0xac, 0x1e, 0x00, 0x45, 0x51, 0x24, 0xa6, 0x1e, 0x00, + 0x4a, 0xb4, 0xb0, 0xa8, 0x1e, 0x00, 0x45, 0x71, 0x24, 0xaa, 0x1e, 0x40, + 0x05, 0x19, 0x00, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0xae, 0x1e, 0x00, 0x49, + 0x6d, 0x13, 0xb6, 0x1e, 0x00, 0x45, 0x51, 0x24, 0xb0, 0x1e, 0x00, 0x4a, + 0xb4, 0xb0, 0xb2, 0x1e, 0x00, 0x45, 0x71, 0x24, 0xb4, 0x1e, 0x40, 0x80, + 0x01, 0xff, 0x46, 0x16, 0x08, 0x17, 0xf3, 0x01, 0x49, 0x1f, 0xc7, 0x1c, + 0xf3, 0x41, 0x02, 0x00, 0x0a, 0x06, 0x46, 0x3c, 0xa1, 0xbe, 0x20, 0x40, + 0x80, 0x0d, 0x46, 0xac, 0xd6, 0xab, 0x2a, 0xc0, 0x00, 0x4c, 0x90, 0x2a, + 0xad, 0x2a, 0x40, 0xa2, 0xbd, 0x04, 0x46, 0x12, 0x03, 0xef, 0x25, 0x00, + 0x49, 0x13, 0x3b, 0xd9, 0x27, 0x00, 0x06, 0x9d, 0x8e, 0xa0, 0x04, 0x56, + 0x45, 0x37, 0x1e, 0x2a, 0x00, 0xaf, 0xf0, 0x03, 0x07, 0xda, 0xda, 0xdf, + 0x03, 0x04, 0x01, 0x06, 0xce, 0x03, 0xb4, 0x17, 0x47, 0xd9, 0xdc, 0xd8, + 0x27, 0x00, 0x07, 0xce, 0xdd, 0x01, 0xff, 0x46, 0x12, 0x03, 0xe1, 0xf7, + 0x01, 0x46, 0xfd, 0x05, 0xe8, 0xf7, 0x41, 0x5b, 0x8d, 0x1e, 0xfc, 0x2a, + 0x00, 0x03, 0x45, 0x0a, 0x9e, 0x03, 0x0a, 0x92, 0xb9, 0x01, 0xff, 0xa3, + 0xe8, 0x02, 0x09, 0x51, 0x27, 0xb4, 0x02, 0xac, 0xcb, 0x01, 0xb2, 0xbc, + 0x01, 0xb3, 0x4e, 0x06, 0x6d, 0x02, 0x06, 0x4b, 0x1c, 0xaa, 0x41, 0xce, + 0x41, 0x0f, 0x07, 0x71, 0x38, 0x05, 0xc3, 0x00, 0x1f, 0x06, 0xc8, 0x00, + 0x06, 0x48, 0x6a, 0x7d, 0x1c, 0xce, 0x41, 0x43, 0x94, 0x18, 0x24, 0xce, + 0x01, 0xa3, 0x01, 0xff, 0x45, 0x8a, 0x0b, 0x27, 0xce, 0x01, 0x45, 0x6b, + 0xf0, 0x26, 0xce, 0x41, 0x43, 0x94, 0x18, 0x1a, 0xce, 0x01, 0xa3, 0x01, + 0xff, 0x45, 0x8a, 0x0b, 0x1b, 0xce, 0x01, 0x45, 0x6b, 0xf0, 0x1d, 0xce, + 0x41, 0xed, 0x21, 0xce, 0x01, 0xf7, 0x31, 0xce, 0x41, 0x05, 0x34, 0x07, + 0x5c, 0x43, 0x28, 0x11, 0x29, 0xce, 0xc1, 0x00, 0x06, 0x50, 0x00, 0x35, + 0x8d, 0x01, 0xff, 0x42, 0x88, 0xf9, 0x50, 0xce, 0x81, 0x25, 0xd2, 0x4f, + 0xce, 0x81, 0x12, 0xd3, 0x4d, 0xce, 0x81, 0x09, 0xd4, 0x49, 0xce, 0xc1, + 0x00, 0xd5, 0x47, 0xce, 0x41, 0xd4, 0x4a, 0xce, 0x41, 0xd3, 0x4e, 0xce, + 0xc1, 0x00, 0xd4, 0x4b, 0xce, 0xc1, 0x00, 0xd5, 0x48, 0xce, 0x41, 0x42, + 0xef, 0xfa, 0x4c, 0xce, 0x41, 0x48, 0x52, 0x78, 0x3a, 0xce, 0x01, 0x05, + 0xc3, 0x00, 0x06, 0x4e, 0x86, 0x7f, 0x28, 0xce, 0x41, 0x48, 0x52, 0x78, + 0x36, 0xce, 0x01, 0x45, 0xee, 0x0d, 0x39, 0xce, 0x41, 0x4e, 0x64, 0x7d, + 0x2d, 0xce, 0x01, 0x4e, 0x18, 0x82, 0x23, 0xce, 0x41, 0x54, 0x5f, 0x42, + 0x35, 0xce, 0x01, 0x48, 0x8f, 0xcc, 0x25, 0xce, 0x41, 0x47, 0x7a, 0xd6, + 0x1e, 0xce, 0x01, 0x05, 0x14, 0x01, 0x01, 0xff, 0x0f, 0x07, 0x71, 0x4f, + 0x05, 0xc3, 0x00, 0x2e, 0x06, 0xc8, 0x00, 0x06, 0x48, 0x6a, 0x7d, 0x3c, + 0xce, 0x41, 0xa1, 0x0f, 0xa3, 0x01, 0xff, 0x45, 0x8a, 0x0b, 0x44, 0xce, + 0x01, 0x45, 0x6b, 0xf0, 0x46, 0xce, 0x41, 0x52, 0x0f, 0x56, 0x37, 0xce, + 0x01, 0x42, 0x14, 0x03, 0x43, 0xce, 0xc1, 0x00, 0x4a, 0xe6, 0xab, 0x45, + 0xce, 0x41, 0xa1, 0x0f, 0xa3, 0x01, 0xff, 0x45, 0x8a, 0x0b, 0x3d, 0xce, + 0x01, 0x45, 0x6b, 0xf0, 0x3f, 0xce, 0x41, 0x51, 0x14, 0x5f, 0x2e, 0xce, + 0x01, 0x42, 0x14, 0x03, 0x3e, 0xce, 0x41, 0xed, 0x30, 0xce, 0x01, 0xf7, + 0x42, 0xce, 0x41, 0x06, 0x13, 0x01, 0x1f, 0x06, 0x6d, 0x02, 0x01, 0xff, + 0x44, 0xc3, 0x00, 0x3b, 0xce, 0x81, 0x0d, 0x45, 0xc8, 0x00, 0x2b, 0xce, + 0xc1, 0x00, 0x50, 0x5f, 0x46, 0x2a, 0xce, 0x41, 0x4f, 0xdf, 0x3b, 0x38, + 0xce, 0x41, 0x44, 0xc3, 0x00, 0x22, 0xce, 0x01, 0x45, 0xc8, 0x00, 0x2c, + 0xce, 0x41, 0x09, 0x04, 0xbe, 0x18, 0x47, 0x53, 0x78, 0x1f, 0xce, 0xc1, + 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4a, 0xf8, 0xb2, 0x20, 0xce, 0x01, + 0x4a, 0x84, 0xb8, 0x40, 0xce, 0x41, 0xeb, 0x2f, 0xce, 0x01, 0xf8, 0x32, + 0xce, 0x01, 0xf9, 0x33, 0xce, 0x01, 0x4f, 0x4b, 0x78, 0x34, 0xce, 0x41, + 0x5d, 0x61, 0x0c, 0x3c, 0x0b, 0x01, 0x5f, 0x98, 0x12, 0x3e, 0x0b, 0x41, + 0x46, 0x12, 0x03, 0x34, 0xf5, 0x01, 0x46, 0xfd, 0x05, 0xe5, 0xf7, 0x41, + 0x46, 0x12, 0x03, 0xe3, 0xf7, 0x01, 0x46, 0xfd, 0x05, 0xea, 0xf7, 0x41, + 0x03, 0xef, 0x07, 0x17, 0x06, 0xc1, 0x1d, 0x01, 0xff, 0x46, 0x12, 0x03, + 0xe0, 0xf7, 0x01, 0x47, 0xcc, 0x46, 0x36, 0xf5, 0x01, 0x46, 0xfd, 0x05, + 0xe7, 0xf7, 0x41, 0x5d, 0x19, 0x16, 0x3d, 0x0b, 0x01, 0x5f, 0x79, 0x12, + 0x3f, 0x0b, 0x41, 0x46, 0x12, 0x03, 0xe2, 0xf7, 0x01, 0x46, 0xfd, 0x05, + 0xe9, 0xf7, 0x41, 0x04, 0x7d, 0x91, 0x11, 0x05, 0xd4, 0x99, 0x01, 0xff, + 0x46, 0x12, 0x03, 0xe4, 0xf7, 0x01, 0x46, 0xfd, 0x05, 0xeb, 0xf7, 0x41, + 0x46, 0x12, 0x03, 0x35, 0xf5, 0x01, 0x47, 0xcc, 0x46, 0x37, 0xf5, 0x01, + 0x46, 0xfd, 0x05, 0xe6, 0xf7, 0x41, 0x51, 0x7e, 0x5b, 0xcc, 0x0e, 0x00, + 0x06, 0xef, 0x06, 0x8a, 0x04, 0x48, 0x6c, 0x2b, 0xaf, 0x0e, 0x00, 0x03, + 0x16, 0x75, 0xf3, 0x03, 0x45, 0xd7, 0xed, 0xc6, 0x0e, 0x00, 0x07, 0x13, + 0x06, 0x92, 0x01, 0x49, 0x2a, 0xc2, 0xcd, 0x0e, 0x00, 0xb3, 0x74, 0x09, + 0xb7, 0xc5, 0x57, 0x0b, 0xc7, 0x7a, 0x06, 0x48, 0x7f, 0xd2, 0xce, 0x0e, + 0x40, 0xe1, 0xb0, 0x0e, 0x80, 0x38, 0xe5, 0xc0, 0x0e, 0x80, 0x2f, 0xe9, + 0xb4, 0x0e, 0x80, 0x26, 0x05, 0x59, 0xee, 0x16, 0xef, 0xc2, 0x0e, 0x00, + 0xf5, 0xb8, 0x0e, 0x80, 0x09, 0xf9, 0xb6, 0x0e, 0xc0, 0x00, 0xf9, 0xb7, + 0x0e, 0x40, 0xf5, 0xb9, 0x0e, 0x40, 0x42, 0x1a, 0x00, 0xb1, 0x0e, 0x00, + 0x42, 0x10, 0x00, 0xbb, 0x0e, 0x40, 0xe9, 0xb5, 0x0e, 0x40, 0xe9, 0xc1, + 0x0e, 0x40, 0xe1, 0xb2, 0x0e, 0x00, 0xe9, 0xc4, 0x0e, 0x00, 0xed, 0xb3, + 0x0e, 0x00, 0xf9, 0xc3, 0x0e, 0x40, 0x46, 0x4e, 0xe0, 0xcb, 0x0e, 0x00, + 0x42, 0xdb, 0x19, 0xc8, 0x0e, 0x00, 0xb4, 0x01, 0xff, 0x42, 0x0b, 0x00, + 0xc9, 0x0e, 0x00, 0xe9, 0xca, 0x0e, 0x40, 0x0e, 0xc4, 0x7a, 0x06, 0x4f, + 0x9d, 0x71, 0xba, 0x0e, 0x40, 0x42, 0x13, 0x01, 0xbc, 0x0e, 0x00, 0x43, + 0x69, 0x56, 0xbd, 0x0e, 0x40, 0x42, 0x5d, 0x00, 0x9a, 0x0e, 0x00, 0x42, + 0x13, 0x05, 0x88, 0x0e, 0x00, 0x42, 0x3b, 0x01, 0x94, 0x0e, 0x00, 0x03, + 0xb4, 0xda, 0xa5, 0x02, 0x03, 0x16, 0x75, 0x94, 0x02, 0xab, 0xea, 0x01, + 0x42, 0x13, 0x01, 0xa5, 0x0e, 0x80, 0xd1, 0x01, 0x42, 0xc3, 0x07, 0xa1, + 0x0e, 0x00, 0xae, 0xb8, 0x01, 0xef, 0xad, 0x0e, 0x00, 0xb0, 0x4b, 0x42, + 0xd0, 0x00, 0xa3, 0x0e, 0x00, 0xb3, 0x22, 0xb4, 0x0c, 0x42, 0x15, 0x02, + 0xa7, 0x0e, 0x00, 0x42, 0xe0, 0x49, 0xa2, 0x0e, 0x40, 0x03, 0x16, 0x75, + 0x04, 0xef, 0x95, 0x0e, 0x40, 0x44, 0x2b, 0xc6, 0x96, 0x0e, 0x00, 0x43, + 0x08, 0x34, 0x97, 0x0e, 0x40, 0x09, 0xa9, 0xbb, 0x11, 0x02, 0x7b, 0x02, + 0x01, 0xff, 0x44, 0x2b, 0xc6, 0xaa, 0x0e, 0x00, 0x43, 0x08, 0x34, 0x8a, + 0x0e, 0x40, 0x42, 0x22, 0x00, 0xa8, 0x0e, 0x00, 0x42, 0x40, 0x06, 0xa9, + 0x0e, 0x40, 0x04, 0xa2, 0x71, 0x14, 0x03, 0x16, 0x75, 0x04, 0xef, 0x9b, + 0x0e, 0x40, 0x44, 0x2b, 0xc6, 0x9c, 0x0e, 0x00, 0x43, 0x08, 0x34, 0x9e, + 0x0e, 0x40, 0x43, 0x77, 0x2c, 0xa0, 0x0e, 0x00, 0x43, 0xd0, 0x18, 0x89, + 0x0e, 0x00, 0xa4, 0x2f, 0x43, 0x38, 0xa1, 0x86, 0x0e, 0x00, 0x43, 0xd3, + 0x47, 0x8c, 0x0e, 0x00, 0x43, 0xba, 0x0e, 0xac, 0x0e, 0x00, 0xae, 0x0f, + 0x02, 0x15, 0x06, 0x01, 0xff, 0xe1, 0x8f, 0x0e, 0x00, 0x42, 0x22, 0x00, + 0x90, 0x0e, 0x40, 0x42, 0x2a, 0x05, 0x93, 0x0e, 0x00, 0x42, 0xdf, 0x23, + 0x8e, 0x0e, 0x40, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x98, 0x0e, 0x40, 0xe1, + 0x91, 0x0e, 0x00, 0x42, 0x22, 0x00, 0x92, 0x0e, 0x40, 0x42, 0xd4, 0x14, + 0x87, 0x0e, 0x00, 0xef, 0x99, 0x0e, 0x00, 0x42, 0xe0, 0x49, 0x8d, 0x0e, + 0x40, 0x02, 0x73, 0x00, 0x01, 0xff, 0x43, 0xa1, 0x01, 0xa3, 0x0e, 0x00, + 0x43, 0x9f, 0x6c, 0xa5, 0x0e, 0x40, 0xa8, 0x04, 0xef, 0x81, 0x0e, 0x40, + 0x03, 0xfd, 0x8d, 0x11, 0x02, 0x7b, 0x02, 0x01, 0xff, 0x44, 0x2b, 0xc6, + 0x82, 0x0e, 0x00, 0x43, 0x08, 0x34, 0x84, 0x0e, 0x40, 0x42, 0xd4, 0x14, + 0xde, 0x0e, 0x00, 0x43, 0x69, 0x56, 0xdf, 0x0e, 0x40, 0x44, 0x2b, 0xc6, + 0xab, 0x0e, 0x00, 0x43, 0x08, 0x34, 0xae, 0x0e, 0x40, 0xa6, 0x0c, 0x44, + 0x2b, 0xc6, 0x9f, 0x0e, 0x00, 0x43, 0x08, 0x34, 0x9d, 0x0e, 0x40, 0x42, + 0x9c, 0x11, 0x9f, 0x0e, 0x00, 0x42, 0x10, 0x00, 0x9d, 0x0e, 0x40, 0x42, + 0xc3, 0x07, 0xdd, 0x0e, 0x00, 0x42, 0xb4, 0x01, 0xdc, 0x0e, 0x40, 0x45, + 0x7e, 0x0b, 0xd8, 0x0e, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xd9, 0x0e, + 0x00, 0x43, 0x7a, 0x0b, 0xd1, 0x0e, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, + 0x80, 0x1f, 0xd0, 0x0e, 0x40, 0x44, 0x25, 0x01, 0xd3, 0x0e, 0x00, 0x42, + 0x15, 0x02, 0xd2, 0x0e, 0x40, 0x44, 0x06, 0x1f, 0xd7, 0x0e, 0x00, 0x42, + 0x09, 0x24, 0xd6, 0x0e, 0x40, 0x43, 0xf9, 0x05, 0xd5, 0x0e, 0x00, 0x43, + 0xf6, 0x06, 0xd4, 0x0e, 0x40, 0x46, 0xea, 0xe0, 0xd8, 0xf6, 0x01, 0x49, + 0xe5, 0xbe, 0x01, 0x00, 0x4e, 0x43, 0xf8, 0x11, 0x9c, 0xfa, 0x01, 0x48, + 0x6f, 0xd2, 0x1e, 0xf4, 0x41, 0x45, 0xa6, 0xe7, 0x7c, 0xf9, 0x01, 0x42, + 0xd8, 0x00, 0xf7, 0xf3, 0x41, 0xa1, 0x8f, 0x16, 0xa5, 0xe8, 0x15, 0xa8, + 0xdf, 0x03, 0xa9, 0x22, 0xae, 0x14, 0xaf, 0x06, 0x45, 0x66, 0xf0, 0xe3, + 0x2b, 0x40, 0x43, 0x6f, 0x1a, 0x28, 0xf4, 0x01, 0x54, 0x5f, 0x47, 0x7f, + 0x32, 0x40, 0x4d, 0x87, 0x86, 0xce, 0xf9, 0x01, 0x42, 0x1b, 0x05, 0xa2, + 0xfa, 0x41, 0x44, 0xc4, 0x19, 0x58, 0xf4, 0x01, 0x46, 0x58, 0x03, 0xad, + 0x20, 0x00, 0x08, 0xf7, 0xcf, 0x3c, 0x42, 0xee, 0x00, 0x8f, 0xf4, 0x81, + 0x0c, 0x42, 0x77, 0x00, 0x81, 0xfa, 0x01, 0x47, 0x6c, 0xdd, 0x5d, 0xf9, + 0x41, 0x45, 0xb8, 0x00, 0x8b, 0xf4, 0x01, 0x04, 0xa1, 0x01, 0x01, 0xff, + 0x59, 0xc1, 0x24, 0x3d, 0xf6, 0x01, 0x44, 0x0c, 0x08, 0x17, 0xf6, 0xc1, + 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4b, 0xcf, 0x24, 0x1a, 0xf6, 0x01, + 0x4c, 0x93, 0x20, 0x19, 0xf6, 0x41, 0xa4, 0x9a, 0x02, 0x07, 0x13, 0x06, + 0x54, 0x05, 0x5a, 0x03, 0x28, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xa1, 0x15, + 0xe5, 0x67, 0x6d, 0x01, 0xe9, 0x64, 0x6d, 0x01, 0xef, 0x69, 0x6d, 0x01, + 0xf5, 0x65, 0x6d, 0xc1, 0x00, 0xe5, 0x66, 0x6d, 0x41, 0xe1, 0x63, 0x6d, + 0x01, 0xe9, 0x68, 0x6d, 0x01, 0xf5, 0x6a, 0x6d, 0x41, 0x48, 0x0a, 0x17, + 0x40, 0x6d, 0x01, 0x44, 0x84, 0xf8, 0x6c, 0x6d, 0x01, 0x45, 0x47, 0xf1, + 0x41, 0x6d, 0x01, 0x02, 0x02, 0x00, 0x06, 0x44, 0x4c, 0xf9, 0x6d, 0x6d, + 0x41, 0x44, 0x21, 0x25, 0x6b, 0x6d, 0x01, 0x45, 0x49, 0x4e, 0x42, 0x6d, + 0x41, 0xe1, 0x43, 0x6d, 0x01, 0xa2, 0xb1, 0x01, 0xa3, 0xa4, 0x01, 0xa4, + 0x8b, 0x01, 0xa7, 0x7f, 0x42, 0x22, 0x00, 0x62, 0x6d, 0x01, 0xaa, 0x6d, + 0xab, 0x61, 0x42, 0x74, 0x00, 0x5e, 0x6d, 0x01, 0x42, 0x6c, 0x00, 0x5b, + 0x6d, 0x01, 0xae, 0x43, 0xb0, 0x37, 0x42, 0x71, 0x00, 0x5d, 0x6d, 0x01, + 0xb3, 0x25, 0xb4, 0x0c, 0x42, 0x61, 0x0b, 0x5f, 0x6d, 0x01, 0x42, 0xdf, + 0x23, 0x5c, 0x6d, 0x41, 0xe1, 0x52, 0x6d, 0x01, 0x42, 0x22, 0x00, 0x53, + 0x6d, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x4e, 0x6d, 0x01, 0x42, 0x22, 0x00, + 0x4f, 0x6d, 0x41, 0xe1, 0x60, 0x6d, 0x01, 0x42, 0x22, 0x00, 0x61, 0x6d, + 0x41, 0xe1, 0x57, 0x6d, 0x01, 0x42, 0x22, 0x00, 0x58, 0x6d, 0x41, 0xe1, + 0x56, 0x6d, 0x01, 0x42, 0x24, 0x02, 0x48, 0x6d, 0x01, 0x42, 0xdf, 0x23, + 0x4d, 0x6d, 0x41, 0xe1, 0x44, 0x6d, 0x01, 0x42, 0x22, 0x00, 0x45, 0x6d, + 0x41, 0xe1, 0x4b, 0x6d, 0x01, 0x42, 0x22, 0x00, 0x4c, 0x6d, 0x41, 0xe1, + 0x46, 0x6d, 0x01, 0x42, 0x22, 0x00, 0x47, 0x6d, 0x41, 0xe1, 0x54, 0x6d, + 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x55, 0x6d, 0x41, 0xe1, 0x50, 0x6d, + 0x01, 0x42, 0x22, 0x00, 0x51, 0x6d, 0x41, 0xe1, 0x49, 0x6d, 0x01, 0x42, + 0x22, 0x00, 0x4a, 0x6d, 0x41, 0xe1, 0x59, 0x6d, 0x01, 0x42, 0x22, 0x00, + 0x5a, 0x6d, 0x41, 0x44, 0x96, 0x21, 0x6e, 0x6d, 0x01, 0x05, 0xf0, 0x06, + 0x06, 0x4b, 0x33, 0xa6, 0x6f, 0x6d, 0x41, 0x45, 0x7e, 0x0b, 0x78, 0x6d, + 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x79, 0x6d, 0x01, 0x43, 0x7a, 0x0b, + 0x71, 0x6d, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x70, 0x6d, + 0x41, 0x44, 0x25, 0x01, 0x73, 0x6d, 0x01, 0x42, 0x15, 0x02, 0x72, 0x6d, + 0x41, 0x44, 0x06, 0x1f, 0x77, 0x6d, 0x01, 0x42, 0x09, 0x24, 0x76, 0x6d, + 0x41, 0x43, 0xf9, 0x05, 0x75, 0x6d, 0x01, 0x43, 0xf6, 0x06, 0x74, 0x6d, + 0x41, 0xa1, 0xaa, 0x0e, 0x12, 0x49, 0x55, 0x92, 0x0e, 0x04, 0x09, 0x3a, + 0xb3, 0x06, 0x05, 0x6c, 0xef, 0xa4, 0x03, 0x08, 0xb7, 0xd1, 0x01, 0xff, + 0x06, 0xef, 0x06, 0xd8, 0x02, 0x07, 0x13, 0x06, 0x43, 0x05, 0x5a, 0x03, + 0x2d, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xa1, 0x1a, 0xe5, 0xe5, 0x12, 0x01, + 0xe9, 0xe1, 0x12, 0x81, 0x0d, 0xef, 0xe7, 0x12, 0x01, 0xf5, 0xe3, 0x12, + 0xc1, 0x00, 0xf5, 0xe4, 0x12, 0x41, 0xe9, 0xe2, 0x12, 0x41, 0xe1, 0xe0, + 0x12, 0x01, 0xe9, 0xe6, 0x12, 0x01, 0xf5, 0xe8, 0x12, 0x41, 0x48, 0x0a, + 0x17, 0xdf, 0x12, 0x01, 0x45, 0x62, 0x41, 0xe9, 0x12, 0x01, 0x46, 0x1f, + 0x25, 0xea, 0x12, 0x41, 0xe1, 0xb0, 0x12, 0x81, 0xff, 0x01, 0xa2, 0xec, + 0x01, 0xa3, 0xdf, 0x01, 0xa4, 0xc0, 0x01, 0xe5, 0xb6, 0x12, 0x01, 0xa7, + 0xa9, 0x01, 0x42, 0x22, 0x00, 0xde, 0x12, 0x01, 0xe9, 0xb2, 0x12, 0x81, + 0x99, 0x01, 0xaa, 0x86, 0x01, 0xab, 0x7a, 0x42, 0x74, 0x00, 0xda, 0x12, + 0x01, 0x42, 0x6c, 0x00, 0xd7, 0x12, 0x01, 0xae, 0x56, 0xef, 0xb8, 0x12, + 0x01, 0xb0, 0x46, 0xb2, 0x3a, 0xb3, 0x2e, 0xb4, 0x15, 0xf5, 0xb4, 0x12, + 0x81, 0x0c, 0x42, 0x61, 0x0b, 0xdb, 0x12, 0x01, 0x42, 0xdf, 0x23, 0xd8, + 0x12, 0x41, 0xf5, 0xb5, 0x12, 0x41, 0xe1, 0xcd, 0x12, 0x01, 0x42, 0x22, + 0x00, 0xce, 0x12, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0xc6, 0x12, 0x01, 0x42, + 0x22, 0x00, 0xc7, 0x12, 0x41, 0xe1, 0xdd, 0x12, 0x01, 0x42, 0x22, 0x00, + 0xdc, 0x12, 0x41, 0xe1, 0xd9, 0x12, 0x01, 0x42, 0x71, 0x00, 0xca, 0x12, + 0x41, 0xe1, 0xd2, 0x12, 0x01, 0x42, 0x22, 0x00, 0xd3, 0x12, 0x41, 0xe1, + 0xd1, 0x12, 0x01, 0x42, 0x24, 0x02, 0xbf, 0x12, 0x01, 0x42, 0x2a, 0x05, + 0xcc, 0x12, 0x01, 0x42, 0xdf, 0x23, 0xc5, 0x12, 0x41, 0xe1, 0xba, 0x12, + 0x01, 0x42, 0x22, 0x00, 0xbb, 0x12, 0x41, 0xe1, 0xc2, 0x12, 0x01, 0x42, + 0x22, 0x00, 0xc4, 0x12, 0x01, 0x42, 0x78, 0x1a, 0xc3, 0x12, 0x41, 0xe9, + 0xb3, 0x12, 0x41, 0xe1, 0xbc, 0x12, 0x01, 0x42, 0x24, 0x02, 0xbd, 0x12, + 0x01, 0x42, 0x22, 0x00, 0xbe, 0x12, 0x41, 0xe1, 0xcf, 0x12, 0x01, 0xa4, + 0x06, 0x42, 0x22, 0x00, 0xd0, 0x12, 0x41, 0xe1, 0xc8, 0x12, 0x01, 0x42, + 0x7b, 0x08, 0xc9, 0x12, 0x01, 0x42, 0x22, 0x00, 0xcb, 0x12, 0x41, 0xe1, + 0xc0, 0x12, 0x01, 0x42, 0x22, 0x00, 0xc1, 0x12, 0x41, 0xe1, 0xd4, 0x12, + 0x01, 0x42, 0x16, 0x00, 0xd5, 0x12, 0x01, 0x42, 0x22, 0x00, 0xd6, 0x12, + 0x41, 0xe1, 0xb1, 0x12, 0x01, 0xe9, 0xb7, 0x12, 0x01, 0xf5, 0xb9, 0x12, + 0x41, 0x45, 0x7e, 0x0b, 0xf8, 0x12, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, + 0xf9, 0x12, 0x01, 0x43, 0x7a, 0x0b, 0xf1, 0x12, 0x01, 0xb3, 0x14, 0xb4, + 0x06, 0x44, 0x80, 0x1f, 0xf0, 0x12, 0x41, 0x44, 0x25, 0x01, 0xf3, 0x12, + 0x01, 0x42, 0x15, 0x02, 0xf2, 0x12, 0x41, 0x44, 0x06, 0x1f, 0xf7, 0x12, + 0x01, 0x42, 0x09, 0x24, 0xf6, 0x12, 0x41, 0x43, 0xf9, 0x05, 0xf5, 0x12, + 0x01, 0x43, 0xf6, 0x06, 0xf4, 0x12, 0x41, 0x51, 0x5d, 0x5a, 0x3d, 0x12, + 0x01, 0xa4, 0xea, 0x02, 0x07, 0x13, 0x06, 0x60, 0xb3, 0x33, 0x0b, 0xc7, + 0x7a, 0x06, 0x4e, 0xc0, 0x82, 0x3a, 0x12, 0x41, 0xa1, 0x1b, 0xe5, 0x30, + 0x12, 0x01, 0xe9, 0x2d, 0x12, 0x81, 0x0e, 0xef, 0x32, 0x12, 0x01, 0xf5, + 0x2f, 0x12, 0x01, 0x49, 0xf2, 0xc6, 0x41, 0x12, 0x41, 0xe9, 0x2e, 0x12, + 0x41, 0xe1, 0x2c, 0x12, 0x01, 0xe9, 0x31, 0x12, 0x01, 0xf5, 0x33, 0x12, + 0x41, 0x4b, 0x67, 0x28, 0x3b, 0x12, 0x01, 0x04, 0x5b, 0x03, 0x01, 0xff, + 0x48, 0x0a, 0x17, 0x34, 0x12, 0x01, 0x45, 0x62, 0x41, 0x36, 0x12, 0x01, + 0xb3, 0x06, 0x46, 0x1f, 0x25, 0x35, 0x12, 0x41, 0x45, 0xba, 0xec, 0x37, + 0x12, 0x01, 0x44, 0x0c, 0xf1, 0x3e, 0x12, 0x41, 0xe1, 0x00, 0x12, 0x81, + 0xf4, 0x01, 0xa2, 0xe1, 0x01, 0xa3, 0xd4, 0x01, 0xa4, 0xb5, 0x01, 0xe5, + 0x04, 0x12, 0x01, 0xa7, 0x9e, 0x01, 0x42, 0x22, 0x00, 0x2a, 0x12, 0x01, + 0xe9, 0x02, 0x12, 0x01, 0xaa, 0x87, 0x01, 0xab, 0x7b, 0xac, 0x6f, 0x42, + 0x6c, 0x00, 0x24, 0x12, 0x01, 0xae, 0x51, 0xef, 0x06, 0x12, 0x01, 0xb0, + 0x41, 0x42, 0x11, 0x15, 0x3f, 0x12, 0x01, 0x42, 0x71, 0x00, 0x26, 0x12, + 0x01, 0xb3, 0x29, 0xb4, 0x10, 0xf5, 0x03, 0x12, 0x01, 0x42, 0x61, 0x0b, + 0x28, 0x12, 0x01, 0x42, 0xdf, 0x23, 0x25, 0x12, 0x41, 0xe1, 0x19, 0x12, + 0x01, 0x42, 0x22, 0x00, 0x1a, 0x12, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x14, + 0x12, 0x01, 0x42, 0x22, 0x00, 0x15, 0x12, 0x41, 0xe1, 0x29, 0x12, 0x01, + 0x46, 0x88, 0xe2, 0x40, 0x12, 0x41, 0xe1, 0x1f, 0x12, 0x01, 0x42, 0x22, + 0x00, 0x20, 0x12, 0x41, 0xe1, 0x1e, 0x12, 0x01, 0x42, 0x24, 0x02, 0x0d, + 0x12, 0x01, 0x42, 0x2a, 0x05, 0x18, 0x12, 0x01, 0x42, 0xdf, 0x23, 0x13, + 0x12, 0x41, 0xe1, 0x27, 0x12, 0x01, 0x42, 0x74, 0x00, 0x2b, 0x12, 0x41, + 0xe1, 0x08, 0x12, 0x01, 0x42, 0x22, 0x00, 0x09, 0x12, 0x41, 0xe1, 0x10, + 0x12, 0x01, 0x42, 0x78, 0x1a, 0x11, 0x12, 0x41, 0xe1, 0x0a, 0x12, 0x01, + 0x42, 0x24, 0x02, 0x0b, 0x12, 0x01, 0x42, 0x22, 0x00, 0x0c, 0x12, 0x41, + 0xe1, 0x1b, 0x12, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x1d, 0x12, 0x41, + 0xe1, 0x16, 0x12, 0x01, 0x42, 0x7b, 0x08, 0x1c, 0x12, 0x01, 0x42, 0x22, + 0x00, 0x17, 0x12, 0x41, 0xe1, 0x0e, 0x12, 0x01, 0x42, 0x22, 0x00, 0x0f, + 0x12, 0x41, 0xe1, 0x21, 0x12, 0x01, 0x42, 0x16, 0x00, 0x22, 0x12, 0x01, + 0x42, 0x22, 0x00, 0x23, 0x12, 0x41, 0xe1, 0x01, 0x12, 0x01, 0xe9, 0x05, + 0x12, 0x01, 0xf5, 0x07, 0x12, 0x41, 0x44, 0x96, 0x21, 0x38, 0x12, 0x01, + 0x06, 0x3c, 0x01, 0x01, 0xff, 0x45, 0x13, 0x9b, 0x39, 0x12, 0x01, 0x4c, + 0x66, 0x28, 0x3c, 0x12, 0x41, 0x54, 0x77, 0x43, 0xdb, 0x17, 0x00, 0x06, + 0xef, 0x06, 0x8d, 0x07, 0x12, 0x25, 0x55, 0xaf, 0x06, 0x07, 0x13, 0x06, + 0xe6, 0x04, 0xb3, 0x5d, 0x06, 0x74, 0x3b, 0x01, 0xff, 0x0a, 0x5e, 0xb1, + 0x4c, 0x05, 0x5a, 0x03, 0x01, 0xff, 0xa1, 0x35, 0xe5, 0xc1, 0x17, 0x00, + 0xe9, 0xb7, 0x17, 0x80, 0x24, 0xaf, 0x1a, 0xf5, 0xbb, 0x17, 0x80, 0x0d, + 0xf9, 0xb9, 0x17, 0xc0, 0x00, 0xe1, 0xbf, 0x17, 0x00, 0xf9, 0xba, 0x17, + 0x40, 0xe1, 0xbd, 0x17, 0x00, 0xf5, 0xbc, 0x17, 0x40, 0xe5, 0xbe, 0x17, + 0x00, 0xef, 0xc4, 0x17, 0x40, 0xe5, 0xc0, 0x17, 0x00, 0xe9, 0xb8, 0x17, + 0x40, 0xe1, 0xb6, 0x17, 0x00, 0xe5, 0xc2, 0x17, 0x00, 0xe9, 0xc3, 0x17, + 0x00, 0xf5, 0xc5, 0x17, 0x40, 0xe1, 0xb5, 0x17, 0x00, 0xf1, 0xb4, 0x17, + 0x40, 0x04, 0x5b, 0x03, 0xe9, 0x02, 0x06, 0x2e, 0x17, 0x01, 0xff, 0xa2, + 0xc0, 0x02, 0x03, 0x5d, 0xf7, 0xd3, 0x01, 0x0a, 0x4e, 0xb2, 0x88, 0x01, + 0x05, 0xd1, 0xee, 0x78, 0xb0, 0x06, 0x49, 0xf6, 0xc5, 0xf0, 0x19, 0x40, + 0x49, 0xe8, 0xbb, 0xe0, 0x19, 0x00, 0x03, 0x51, 0x79, 0x5a, 0x03, 0xc9, + 0x19, 0x01, 0xff, 0x80, 0x47, 0x8d, 0x01, 0xff, 0xa2, 0x21, 0x05, 0xd1, + 0xee, 0x11, 0x04, 0x50, 0x79, 0x01, 0xff, 0x44, 0xcc, 0xf6, 0xe7, 0x19, + 0x00, 0x43, 0x4a, 0x3f, 0xf7, 0x19, 0x40, 0x44, 0xcc, 0xf6, 0xe6, 0x19, + 0x00, 0x43, 0x4a, 0x3f, 0xf6, 0x19, 0x40, 0x03, 0x18, 0xa1, 0x11, 0x04, + 0xd8, 0xf8, 0x01, 0xff, 0x44, 0xcc, 0xf6, 0xe9, 0x19, 0x00, 0x43, 0x4a, + 0x3f, 0xf9, 0x19, 0x40, 0x44, 0xcc, 0xf6, 0xe8, 0x19, 0x00, 0x43, 0x4a, + 0x3f, 0xf8, 0x19, 0x40, 0x44, 0xcc, 0xf6, 0xe5, 0x19, 0x00, 0x43, 0x4a, + 0x3f, 0xf5, 0x19, 0x40, 0x44, 0xcc, 0xf6, 0xe2, 0x19, 0x00, 0x43, 0x4a, + 0x3f, 0xf2, 0x19, 0x40, 0x44, 0xcc, 0xf6, 0xe1, 0x19, 0x00, 0x43, 0x4a, + 0x3f, 0xf1, 0x19, 0x40, 0xa2, 0x38, 0x44, 0xd1, 0xee, 0xf1, 0x17, 0x00, + 0xb0, 0x06, 0x43, 0x43, 0x1e, 0xf0, 0x17, 0x40, 0x42, 0xc0, 0x29, 0xf2, + 0x17, 0x00, 0x43, 0xc9, 0x19, 0xf5, 0x17, 0xc0, 0x00, 0x8d, 0x01, 0xff, + 0xa2, 0x0c, 0x44, 0xd1, 0xee, 0xf6, 0x17, 0x00, 0x43, 0x50, 0x79, 0xf7, + 0x17, 0x40, 0x42, 0x7e, 0x0b, 0xf8, 0x17, 0x00, 0x43, 0x4c, 0x8b, 0xf9, + 0x17, 0x40, 0x42, 0x7e, 0x0b, 0xf3, 0x17, 0x00, 0x43, 0x4c, 0x8b, 0xf4, + 0x17, 0x40, 0x80, 0x5a, 0x8d, 0x01, 0xff, 0xa2, 0x34, 0x05, 0xd1, 0xee, + 0x24, 0xb0, 0x01, 0xff, 0x03, 0x51, 0x79, 0x11, 0x04, 0x75, 0x30, 0x01, + 0xff, 0x44, 0xcc, 0xf6, 0xef, 0x19, 0x00, 0x43, 0x4a, 0x3f, 0xff, 0x19, + 0x40, 0x44, 0xcc, 0xf6, 0xec, 0x19, 0x00, 0x43, 0x4a, 0x3f, 0xfc, 0x19, + 0x40, 0x44, 0xcc, 0xf6, 0xeb, 0x19, 0x00, 0x43, 0x4a, 0x3f, 0xfb, 0x19, + 0x40, 0x03, 0x18, 0xa1, 0x11, 0x04, 0xd8, 0xf8, 0x01, 0xff, 0x44, 0xcc, + 0xf6, 0xee, 0x19, 0x00, 0x43, 0x4a, 0x3f, 0xfe, 0x19, 0x40, 0x44, 0xcc, + 0xf6, 0xed, 0x19, 0x00, 0x43, 0x4a, 0x3f, 0xfd, 0x19, 0x40, 0x44, 0xcc, + 0xf6, 0xea, 0x19, 0x00, 0x43, 0x4a, 0x3f, 0xfa, 0x19, 0x40, 0x03, 0x18, + 0xa1, 0x11, 0x04, 0xd8, 0xf8, 0x01, 0xff, 0x44, 0xcc, 0xf6, 0xe4, 0x19, + 0x00, 0x43, 0x4a, 0x3f, 0xf4, 0x19, 0x40, 0x44, 0xcc, 0xf6, 0xe3, 0x19, + 0x00, 0x43, 0x4a, 0x3f, 0xf3, 0x19, 0x40, 0xa1, 0x84, 0x01, 0xa2, 0x68, + 0xa3, 0x5a, 0xab, 0x46, 0x47, 0xa3, 0xd8, 0xd7, 0x17, 0x00, 0x4b, 0xf4, + 0xa4, 0xc9, 0x17, 0x00, 0x47, 0x6e, 0xd9, 0xc6, 0x17, 0x00, 0x4b, 0x80, + 0xa6, 0xd9, 0x17, 0x00, 0xb2, 0x20, 0x4d, 0xed, 0x8c, 0xd0, 0x17, 0x00, + 0xb4, 0x0c, 0x46, 0x26, 0xe7, 0xd1, 0x17, 0x00, 0x4d, 0x6a, 0x8f, 0xc8, + 0x17, 0x40, 0x4a, 0x1a, 0xb4, 0xcd, 0x17, 0x00, 0x46, 0x8e, 0xe5, 0xca, + 0x17, 0x40, 0x46, 0x02, 0xe1, 0xc7, 0x17, 0x00, 0x44, 0xac, 0xf7, 0xcc, + 0x17, 0x40, 0x46, 0x9a, 0xdf, 0xce, 0x17, 0x00, 0x43, 0x90, 0x00, 0xd4, + 0x17, 0x00, 0x46, 0xc8, 0xe4, 0xda, 0x17, 0x40, 0x4e, 0x4a, 0x79, 0xd6, + 0x17, 0x00, 0x44, 0xfc, 0xee, 0xd2, 0x17, 0x40, 0xa1, 0x06, 0x45, 0x33, + 0xec, 0xd8, 0x17, 0x40, 0x44, 0x94, 0xf7, 0xcb, 0x17, 0x00, 0x48, 0x37, + 0xd0, 0xd5, 0x17, 0x00, 0x48, 0xe9, 0xbb, 0xd3, 0x17, 0x40, 0x44, 0x38, + 0xf6, 0xcf, 0x17, 0x00, 0x47, 0x85, 0xdc, 0xdd, 0x17, 0x00, 0x4c, 0xb4, + 0x9b, 0xdc, 0x17, 0x40, 0x42, 0x16, 0x00, 0x94, 0x17, 0x00, 0xa3, 0xa9, + 0x01, 0xa4, 0x9e, 0x01, 0x42, 0x22, 0x00, 0xa0, 0x17, 0x00, 0xab, 0x83, + 0x01, 0xac, 0x79, 0x42, 0xc3, 0x07, 0x98, 0x17, 0x00, 0xae, 0x5b, 0xb0, + 0x4b, 0x42, 0x11, 0x15, 0xa2, 0x17, 0x00, 0x42, 0xd0, 0x00, 0x9a, 0x17, + 0x00, 0xb3, 0x2d, 0xb4, 0x0c, 0x42, 0x2c, 0x1e, 0x9c, 0x17, 0x00, 0x42, + 0xe0, 0x49, 0x99, 0x17, 0x40, 0xe1, 0x8f, 0x17, 0x00, 0xa8, 0x11, 0xef, + 0x91, 0x17, 0x00, 0x02, 0x53, 0x00, 0x01, 0xff, 0xe1, 0x8b, 0x17, 0x00, + 0xef, 0x8d, 0x17, 0x40, 0xe1, 0x90, 0x17, 0x00, 0xef, 0x92, 0x17, 0x40, + 0xe1, 0x9f, 0x17, 0x00, 0x42, 0x22, 0x00, 0x9d, 0x17, 0x00, 0x42, 0x60, + 0x03, 0x9e, 0x17, 0x40, 0xa8, 0x04, 0xef, 0x96, 0x17, 0x40, 0xe1, 0x95, + 0x17, 0x00, 0xef, 0x97, 0x17, 0x40, 0x42, 0xd4, 0x14, 0x84, 0x17, 0x00, + 0x42, 0xb4, 0x01, 0x8e, 0x17, 0x00, 0xef, 0x93, 0x17, 0x00, 0x42, 0xe0, + 0x49, 0x89, 0x17, 0x40, 0xe1, 0xa1, 0x17, 0x00, 0xef, 0x9b, 0x17, 0x40, + 0xe1, 0x80, 0x17, 0x00, 0xa8, 0x04, 0xef, 0x82, 0x17, 0x40, 0xe1, 0x81, + 0x17, 0x00, 0xef, 0x83, 0x17, 0x40, 0xe1, 0x8a, 0x17, 0x00, 0xef, 0x8c, + 0x17, 0x40, 0xe1, 0x85, 0x17, 0x00, 0xa8, 0x04, 0xef, 0x87, 0x17, 0x40, + 0xe1, 0x86, 0x17, 0x00, 0xef, 0x88, 0x17, 0x40, 0x42, 0xe1, 0x0b, 0xad, + 0x17, 0x80, 0x4e, 0xb1, 0x0b, 0x42, 0xcc, 0x0a, 0xab, 0x17, 0xc0, 0x00, + 0xf9, 0xac, 0x17, 0x40, 0xa1, 0x2f, 0xe5, 0xaf, 0x17, 0x00, 0xe9, 0xa5, + 0x17, 0x80, 0x22, 0x08, 0x07, 0xcf, 0x12, 0xf5, 0xa7, 0x17, 0xc0, 0x00, + 0xeb, 0xa8, 0x17, 0x00, 0xf5, 0xa9, 0x17, 0xc0, 0x00, 0xf6, 0xaa, 0x17, + 0x40, 0x43, 0x7a, 0x0b, 0xb1, 0x17, 0x00, 0x43, 0x44, 0x0a, 0xb2, 0x17, + 0x40, 0xe9, 0xa6, 0x17, 0x40, 0xe1, 0xa4, 0x17, 0x00, 0xe9, 0xb0, 0x17, + 0x00, 0xf1, 0xa3, 0x17, 0x00, 0xf5, 0xb3, 0x17, 0x40, 0xf9, 0xae, 0x17, + 0x40, 0x45, 0x7e, 0x0b, 0xe8, 0x17, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, + 0xe9, 0x17, 0x00, 0x43, 0x7a, 0x0b, 0xe1, 0x17, 0x00, 0xb3, 0x14, 0xb4, + 0x06, 0x44, 0x80, 0x1f, 0xe0, 0x17, 0x40, 0x44, 0x25, 0x01, 0xe3, 0x17, + 0x00, 0x42, 0x15, 0x02, 0xe2, 0x17, 0x40, 0x44, 0x06, 0x1f, 0xe7, 0x17, + 0x00, 0x42, 0x09, 0x24, 0xe6, 0x17, 0x40, 0x43, 0xf9, 0x05, 0xe5, 0x17, + 0x00, 0x43, 0xf6, 0x06, 0xe4, 0x17, 0x40, 0x4a, 0x41, 0x84, 0x04, 0xd8, + 0x80, 0x06, 0x46, 0xb7, 0x86, 0xe4, 0x6f, 0x41, 0x45, 0x5a, 0xe8, 0xff, + 0x8c, 0x41, 0x43, 0x7a, 0x08, 0xaf, 0xfa, 0x01, 0x08, 0x3f, 0xd0, 0x01, + 0xff, 0x06, 0xef, 0x06, 0xae, 0x03, 0x51, 0x9f, 0x5c, 0x48, 0x0a, 0x01, + 0x07, 0x13, 0x06, 0xc0, 0x01, 0x07, 0x37, 0x3c, 0x9c, 0x01, 0x0c, 0x3b, + 0x17, 0x5b, 0x05, 0x5a, 0x03, 0x2f, 0xb6, 0x01, 0xff, 0x45, 0x20, 0x25, + 0x3f, 0x0a, 0x01, 0x05, 0x75, 0x3b, 0x01, 0xff, 0x4b, 0x7a, 0x3b, 0x0c, + 0x0a, 0x01, 0x05, 0x5a, 0x03, 0x01, 0xff, 0xe5, 0x05, 0x0a, 0x01, 0xe9, + 0x01, 0x0a, 0x01, 0xef, 0x06, 0x0a, 0x01, 0xf5, 0x02, 0x0a, 0x01, 0x49, + 0xf2, 0xc6, 0x03, 0x0a, 0x41, 0x48, 0x0a, 0x17, 0x0e, 0x0a, 0x01, 0x49, + 0xc7, 0x34, 0x38, 0x0a, 0x01, 0x45, 0xf3, 0xea, 0x39, 0x0a, 0x01, 0x02, + 0x3b, 0x01, 0x06, 0x47, 0x47, 0x4e, 0x0f, 0x0a, 0x41, 0x47, 0x6f, 0x13, + 0x3a, 0x0a, 0x01, 0x4f, 0x5b, 0x77, 0x0d, 0x0a, 0x41, 0xa3, 0x2f, 0xa4, + 0x1a, 0xac, 0x0c, 0x48, 0xcf, 0xcd, 0x54, 0x0a, 0x01, 0x4c, 0x0d, 0x16, + 0x51, 0x0a, 0x41, 0x44, 0xf0, 0x05, 0x58, 0x0a, 0x01, 0x44, 0x49, 0x7d, + 0x55, 0x0a, 0x41, 0x44, 0x96, 0x21, 0x56, 0x0a, 0x01, 0xaf, 0x01, 0xff, + 0xf4, 0x50, 0x0a, 0x01, 0x4a, 0x34, 0xa6, 0x57, 0x0a, 0x41, 0x45, 0x13, + 0x03, 0x52, 0x0a, 0x01, 0x4b, 0x3d, 0x92, 0x53, 0x0a, 0x41, 0x04, 0x7a, + 0x0b, 0x0f, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x44, 0x0a, 0x01, 0x45, + 0xe8, 0x1e, 0x45, 0x0a, 0x41, 0x47, 0x3f, 0x12, 0x46, 0x0a, 0x01, 0x48, + 0xde, 0x1e, 0x47, 0x0a, 0x41, 0xe1, 0x00, 0x0a, 0x01, 0xa2, 0xd2, 0x01, + 0xa3, 0xc5, 0x01, 0xa4, 0xac, 0x01, 0xa7, 0x9f, 0x01, 0x42, 0x22, 0x00, + 0x31, 0x0a, 0x01, 0x42, 0x78, 0x1a, 0x17, 0x0a, 0x01, 0xab, 0x80, 0x01, + 0x42, 0x74, 0x00, 0x2b, 0x0a, 0x01, 0x42, 0x6c, 0x00, 0x28, 0x0a, 0x01, + 0xae, 0x62, 0xb0, 0x56, 0x42, 0x71, 0x00, 0x2a, 0x0a, 0x01, 0xb3, 0x3e, + 0xb4, 0x18, 0xb6, 0x0c, 0x42, 0xdf, 0x23, 0x29, 0x0a, 0x01, 0x42, 0x59, + 0x00, 0x30, 0x0a, 0x41, 0xe1, 0x2c, 0x0a, 0x01, 0x42, 0x22, 0x00, 0x35, + 0x0a, 0x41, 0xe1, 0x1f, 0x0a, 0x01, 0x42, 0x22, 0x00, 0x20, 0x0a, 0x01, + 0xb4, 0x01, 0xff, 0xe1, 0x1a, 0x0a, 0x01, 0x42, 0x22, 0x00, 0x1b, 0x0a, + 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x34, 0x0a, 0x01, 0x42, 0x22, 0x00, 0x33, + 0x0a, 0x41, 0xe1, 0x2f, 0x0a, 0x01, 0x42, 0x22, 0x00, 0x2d, 0x0a, 0x01, + 0x42, 0x40, 0x06, 0x2e, 0x0a, 0x41, 0xe1, 0x24, 0x0a, 0x01, 0x42, 0x22, + 0x00, 0x25, 0x0a, 0x41, 0xe1, 0x23, 0x0a, 0x01, 0x42, 0x2a, 0x05, 0x1e, + 0x0a, 0x01, 0x42, 0xdf, 0x23, 0x19, 0x0a, 0x41, 0xe1, 0x10, 0x0a, 0x01, + 0x42, 0x22, 0x00, 0x11, 0x0a, 0x01, 0x42, 0x1b, 0x02, 0x32, 0x0a, 0x41, + 0xe1, 0x12, 0x0a, 0x01, 0x42, 0x22, 0x00, 0x13, 0x0a, 0x41, 0xe1, 0x21, + 0x0a, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x22, 0x0a, 0x41, 0xe1, 0x1c, + 0x0a, 0x01, 0x42, 0x22, 0x00, 0x1d, 0x0a, 0x41, 0xe1, 0x15, 0x0a, 0x01, + 0x42, 0x22, 0x00, 0x16, 0x0a, 0x41, 0xe1, 0x26, 0x0a, 0x01, 0x42, 0x22, + 0x00, 0x27, 0x0a, 0x41, 0x44, 0xf5, 0x06, 0x43, 0x0a, 0x01, 0x43, 0x7a, + 0x0b, 0x40, 0x0a, 0x01, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0x42, 0x0a, + 0x01, 0x42, 0x15, 0x02, 0x41, 0x0a, 0x41, 0x49, 0x7f, 0xc1, 0x2a, 0x21, + 0x00, 0xf9, 0x11, 0xf5, 0xc1, 0x00, 0x45, 0x43, 0x15, 0x28, 0x23, 0x80, + 0x0c, 0x47, 0x8c, 0xd5, 0x1f, 0xf5, 0x01, 0x44, 0xd5, 0x21, 0xb1, 0xce, + 0x41, 0x4a, 0x0a, 0xab, 0xa6, 0xf5, 0x41, 0x43, 0x9c, 0x63, 0x4b, 0xf5, + 0x01, 0x05, 0x91, 0xed, 0xcc, 0x1d, 0x0f, 0x51, 0x72, 0xbd, 0x1c, 0xae, + 0xa5, 0x0c, 0x06, 0xca, 0x6a, 0xda, 0x06, 0x03, 0xd1, 0xe7, 0xb4, 0x02, + 0x07, 0xb9, 0xdd, 0x01, 0xff, 0x06, 0xef, 0x06, 0xe8, 0x01, 0x07, 0x13, + 0x06, 0x42, 0x05, 0x5a, 0x03, 0x32, 0x05, 0xc2, 0x2e, 0x1b, 0x06, 0x74, + 0x3b, 0x01, 0xff, 0xe5, 0x27, 0xa9, 0x80, 0x0d, 0xef, 0x2a, 0xa9, 0x00, + 0xf5, 0x28, 0xa9, 0xc0, 0x00, 0xe5, 0x26, 0xa9, 0x40, 0xe5, 0x29, 0xa9, + 0x40, 0x45, 0xe9, 0xea, 0x2c, 0xa9, 0x80, 0x06, 0x46, 0x3a, 0xd3, 0x2b, + 0xa9, 0x40, 0x47, 0x39, 0xd3, 0x2d, 0xa9, 0x40, 0x43, 0x0f, 0xfa, 0x2e, + 0xa9, 0x00, 0x44, 0xa0, 0xf8, 0x2f, 0xa9, 0x40, 0xe1, 0x22, 0xa9, 0x00, + 0x42, 0x16, 0x00, 0x19, 0xa9, 0x00, 0x42, 0x37, 0x00, 0x21, 0xa9, 0x00, + 0x42, 0x7b, 0x08, 0x18, 0xa9, 0x00, 0x42, 0x24, 0x02, 0x0c, 0xa9, 0x00, + 0xa8, 0x7a, 0xe9, 0x24, 0xa9, 0x00, 0xab, 0x6a, 0x42, 0x74, 0x00, 0x1c, + 0xa9, 0x00, 0x42, 0x6c, 0x00, 0x17, 0xa9, 0x00, 0xae, 0x4c, 0xaf, 0x42, + 0xb0, 0x36, 0x42, 0x71, 0x00, 0x1a, 0xa9, 0x00, 0xb3, 0x24, 0xb4, 0x18, + 0x42, 0x61, 0x0b, 0x20, 0xa9, 0x00, 0x42, 0xa9, 0x01, 0x1d, 0xa9, 0x00, + 0x42, 0xdf, 0x23, 0x1b, 0xa9, 0x00, 0x42, 0x59, 0x00, 0x10, 0xa9, 0x40, + 0xe1, 0x12, 0xa9, 0x00, 0x42, 0x22, 0x00, 0x1e, 0xa9, 0x40, 0xe1, 0x0e, + 0xa9, 0x00, 0x42, 0x22, 0x00, 0x0f, 0xa9, 0x40, 0xe1, 0x15, 0xa9, 0x00, + 0x42, 0x22, 0x00, 0x16, 0xa9, 0x40, 0xe5, 0x23, 0xa9, 0x00, 0xef, 0x25, + 0xa9, 0x40, 0xe1, 0x14, 0xa9, 0x00, 0x42, 0x24, 0x02, 0x0d, 0xa9, 0x00, + 0x42, 0xdf, 0x23, 0x11, 0xa9, 0x40, 0xe1, 0x0a, 0xa9, 0x00, 0x42, 0x22, + 0x00, 0x0b, 0xa9, 0x40, 0xe1, 0x1f, 0xa9, 0x00, 0x42, 0x12, 0x00, 0x13, + 0xa9, 0x40, 0x45, 0x7e, 0x0b, 0x08, 0xa9, 0x00, 0xa6, 0x2e, 0x44, 0x6d, + 0x2c, 0x09, 0xa9, 0x00, 0x43, 0x7a, 0x0b, 0x01, 0xa9, 0x00, 0xb3, 0x14, + 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x00, 0xa9, 0x40, 0x44, 0x25, 0x01, 0x03, + 0xa9, 0x00, 0x42, 0x15, 0x02, 0x02, 0xa9, 0x40, 0x44, 0x06, 0x1f, 0x07, + 0xa9, 0x00, 0x42, 0x09, 0x24, 0x06, 0xa9, 0x40, 0x43, 0xf9, 0x05, 0x05, + 0xa9, 0x00, 0x43, 0xf6, 0x06, 0x04, 0xa9, 0x40, 0x49, 0xed, 0xbc, 0x42, + 0x1f, 0x01, 0xa4, 0xc6, 0x03, 0x07, 0x13, 0x06, 0xaf, 0x01, 0x0c, 0x3b, + 0x17, 0x5e, 0x05, 0x5a, 0x03, 0x36, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xa1, + 0x21, 0xe5, 0x3e, 0x1f, 0x81, 0x18, 0xe9, 0x36, 0x1f, 0x81, 0x0f, 0xf5, + 0x38, 0x1f, 0x81, 0x06, 0x49, 0xf2, 0xc6, 0x3a, 0x1f, 0x41, 0xf5, 0x39, + 0x1f, 0x41, 0xe9, 0x37, 0x1f, 0x41, 0xf5, 0x40, 0x1f, 0x41, 0xe1, 0x34, + 0x1f, 0x01, 0xe9, 0x3f, 0x1f, 0x01, 0x4b, 0x39, 0xa4, 0x35, 0x1f, 0x41, + 0x48, 0x0a, 0x17, 0x01, 0x1f, 0x01, 0x4b, 0x13, 0x25, 0x00, 0x1f, 0x01, + 0x46, 0x5a, 0xe3, 0x41, 0x1f, 0x01, 0x45, 0x62, 0x41, 0x5a, 0x1f, 0x01, + 0x45, 0x43, 0xf0, 0x02, 0x1f, 0x01, 0x47, 0x47, 0x4e, 0x03, 0x1f, 0x41, + 0x58, 0x5c, 0x28, 0x46, 0x1f, 0x01, 0xa3, 0x39, 0x02, 0x3b, 0x01, 0x2b, + 0xa6, 0x1d, 0xb3, 0x06, 0x4a, 0xd0, 0xb7, 0x4b, 0x1f, 0x41, 0x4d, 0x67, + 0x28, 0x45, 0x1f, 0x01, 0xb0, 0x01, 0xff, 0x4a, 0xa4, 0xac, 0x48, 0x1f, + 0x01, 0x44, 0x82, 0x89, 0x4e, 0x1f, 0x41, 0x4c, 0x94, 0x94, 0x4d, 0x1f, + 0x01, 0x45, 0x13, 0x01, 0x47, 0x1f, 0x41, 0xf4, 0x49, 0x1f, 0x01, 0x48, + 0xdd, 0x43, 0x4a, 0x1f, 0x41, 0x45, 0x13, 0x03, 0x4c, 0x1f, 0x01, 0x4d, + 0x79, 0x89, 0x4f, 0x1f, 0x41, 0xe1, 0x04, 0x1f, 0x81, 0x84, 0x02, 0xa2, + 0xf7, 0x01, 0xa3, 0xea, 0x01, 0xa4, 0xd1, 0x01, 0xe5, 0x0e, 0x1f, 0x01, + 0xa7, 0xc0, 0x01, 0x42, 0x22, 0x00, 0x32, 0x1f, 0x01, 0xe9, 0x06, 0x1f, + 0x81, 0xb0, 0x01, 0xaa, 0x9d, 0x01, 0xab, 0x90, 0x01, 0x42, 0x74, 0x00, + 0x2d, 0x1f, 0x01, 0x42, 0x6c, 0x00, 0x2a, 0x1f, 0x01, 0xae, 0x6c, 0xef, + 0x10, 0x1f, 0x01, 0xb0, 0x5c, 0x42, 0x71, 0x00, 0x2c, 0x1f, 0x01, 0xb3, + 0x44, 0xb4, 0x2b, 0xf5, 0x08, 0x1f, 0x81, 0x22, 0x08, 0xf2, 0xc6, 0x0c, + 0x42, 0xa9, 0x01, 0x2e, 0x1f, 0x01, 0x42, 0xdf, 0x23, 0x2b, 0x1f, 0x41, + 0xec, 0x0c, 0x1f, 0x81, 0x09, 0xf2, 0x0a, 0x1f, 0xc1, 0x00, 0xf2, 0x0b, + 0x1f, 0x41, 0xec, 0x0d, 0x1f, 0x41, 0xf5, 0x09, 0x1f, 0x41, 0xe1, 0x21, + 0x1f, 0x01, 0x42, 0x22, 0x00, 0x22, 0x1f, 0x01, 0xb4, 0x01, 0xff, 0xe1, + 0x1c, 0x1f, 0x01, 0x42, 0x22, 0x00, 0x1d, 0x1f, 0x41, 0xe1, 0x31, 0x1f, + 0x01, 0x42, 0x22, 0x00, 0x2f, 0x1f, 0x01, 0x42, 0x40, 0x06, 0x30, 0x1f, + 0x41, 0xe1, 0x26, 0x1f, 0x01, 0x42, 0x22, 0x00, 0x27, 0x1f, 0x41, 0xe1, + 0x25, 0x1f, 0x01, 0x42, 0x24, 0x02, 0x16, 0x1f, 0x01, 0x42, 0x2a, 0x05, + 0x20, 0x1f, 0x01, 0x42, 0xdf, 0x23, 0x1b, 0x1f, 0x41, 0xe1, 0x12, 0x1f, + 0x01, 0x42, 0x22, 0x00, 0x13, 0x1f, 0x41, 0xe1, 0x19, 0x1f, 0x01, 0x42, + 0x22, 0x00, 0x1a, 0x1f, 0x01, 0x43, 0x9e, 0x37, 0x33, 0x1f, 0x41, 0xe9, + 0x07, 0x1f, 0x41, 0xe1, 0x14, 0x1f, 0x01, 0x42, 0x22, 0x00, 0x15, 0x1f, + 0x41, 0xe1, 0x23, 0x1f, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x24, 0x1f, + 0x41, 0xe1, 0x1e, 0x1f, 0x01, 0x42, 0x22, 0x00, 0x1f, 0x1f, 0x41, 0xe1, + 0x17, 0x1f, 0x01, 0x42, 0x22, 0x00, 0x18, 0x1f, 0x41, 0xe1, 0x28, 0x1f, + 0x01, 0x42, 0x22, 0x00, 0x29, 0x1f, 0x41, 0xe1, 0x05, 0x1f, 0x01, 0xe9, + 0x0f, 0x1f, 0x41, 0x44, 0x96, 0x21, 0x43, 0x1f, 0x01, 0x05, 0xf0, 0x06, + 0x06, 0x4b, 0x33, 0xa6, 0x44, 0x1f, 0x41, 0x45, 0x7e, 0x0b, 0x58, 0x1f, + 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x59, 0x1f, 0x01, 0x43, 0x7a, 0x0b, + 0x51, 0x1f, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x50, 0x1f, + 0x41, 0x44, 0x25, 0x01, 0x53, 0x1f, 0x01, 0x42, 0x15, 0x02, 0x52, 0x1f, + 0x41, 0x44, 0x06, 0x1f, 0x57, 0x1f, 0x01, 0x42, 0x09, 0x24, 0x56, 0x1f, + 0x41, 0x43, 0xf9, 0x05, 0x55, 0x1f, 0x01, 0x43, 0xf6, 0x06, 0x54, 0x1f, + 0x41, 0x80, 0x1d, 0x0a, 0x13, 0x13, 0x01, 0xff, 0x4d, 0x2c, 0x86, 0xa0, + 0x30, 0x00, 0x54, 0x1d, 0x13, 0xfc, 0x30, 0x00, 0x56, 0x29, 0x39, 0x9c, + 0x30, 0x00, 0x51, 0x2e, 0x39, 0x9b, 0x30, 0x40, 0x08, 0xe6, 0x4a, 0x86, + 0x05, 0x4e, 0x7b, 0x21, 0xfd, 0x30, 0x00, 0x07, 0x13, 0x06, 0x0c, 0x4a, + 0x1d, 0x48, 0xfb, 0x30, 0x00, 0x55, 0x19, 0x41, 0xfe, 0x30, 0x40, 0xe1, + 0xa2, 0x30, 0x80, 0xc0, 0x04, 0xa2, 0xa9, 0x04, 0xa4, 0x92, 0x04, 0xe5, + 0xa8, 0x30, 0x00, 0xa7, 0xf7, 0x03, 0xa8, 0xe0, 0x03, 0xe9, 0xa4, 0x30, + 0x00, 0xab, 0xc5, 0x03, 0xad, 0xeb, 0x02, 0xee, 0xf3, 0x30, 0x80, 0xd1, + 0x02, 0xef, 0xaa, 0x30, 0x00, 0xb0, 0xb6, 0x02, 0xb2, 0x9f, 0x02, 0xb3, + 0x67, 0xb4, 0x51, 0xf5, 0xa6, 0x30, 0x00, 0xb6, 0x37, 0xb7, 0x25, 0xb9, + 0x17, 0xba, 0x01, 0xff, 0xe1, 0xb6, 0x30, 0x00, 0xe5, 0xbc, 0x30, 0x00, + 0xe9, 0xb8, 0x30, 0x00, 0xef, 0xbe, 0x30, 0x00, 0xf5, 0xba, 0x30, 0x40, + 0xe1, 0xe4, 0x30, 0x00, 0xef, 0xe8, 0x30, 0x00, 0xf5, 0xe6, 0x30, 0x40, + 0xe1, 0xef, 0x30, 0x00, 0xe5, 0xf1, 0x30, 0x00, 0xe9, 0xf0, 0x30, 0x00, + 0xef, 0xf2, 0x30, 0x40, 0xe1, 0xf7, 0x30, 0x00, 0xe5, 0xf9, 0x30, 0x00, + 0xe9, 0xf8, 0x30, 0x00, 0xef, 0xfa, 0x30, 0x00, 0xf5, 0xf4, 0x30, 0x40, + 0xe1, 0xbf, 0x30, 0x00, 0xe5, 0xc6, 0x30, 0x00, 0xe9, 0xc1, 0x30, 0x00, + 0xef, 0xc8, 0x30, 0x00, 0xf5, 0xc4, 0x30, 0x40, 0xe1, 0xb5, 0x30, 0x00, + 0xe5, 0xbb, 0x30, 0x00, 0xe9, 0xb7, 0x30, 0x00, 0x05, 0x5e, 0x07, 0x08, + 0xef, 0xbd, 0x30, 0x00, 0xf5, 0xb9, 0x30, 0x40, 0xe1, 0xa1, 0x30, 0x80, + 0x92, 0x01, 0xe5, 0xa7, 0x30, 0x00, 0xa8, 0x78, 0xe9, 0xa3, 0x30, 0x00, + 0xab, 0x62, 0x42, 0x91, 0x17, 0xfa, 0x31, 0x00, 0xee, 0x67, 0xb1, 0x81, 0x53, 0xef, 0xa9, 0x30, 0x00, 0xb2, 0x39, 0xb3, 0x2f, 0xb4, 0x25, 0xf5, 0xa5, 0x30, 0x00, 0xb7, 0x0f, 0xb9, 0x01, 0xff, 0xe1, 0xe3, 0x30, 0x00, 0xef, 0xe7, 0x30, 0x00, 0xf5, 0xe5, 0x30, 0x40, 0xe1, 0xee, 0x30, 0x00, @@ -10649,3230 +10852,3263 @@ static const unsigned char uname2c_tree[222744] = { 0xf5, 0xf4, 0x31, 0x40, 0xe1, 0xf5, 0x30, 0x00, 0xe5, 0xf6, 0x30, 0x00, 0xef, 0x55, 0xb1, 0x01, 0xf5, 0xf0, 0x31, 0x40, 0xe1, 0xf5, 0x31, 0x00, 0xe5, 0xf8, 0x31, 0x00, 0xe9, 0xf6, 0x31, 0x00, 0xef, 0xf9, 0x31, 0x00, - 0xf5, 0xf7, 0x31, 0x40, 0xe1, 0xe9, 0x30, 0x00, 0xe5, 0xec, 0x30, 0x00, - 0xe9, 0xea, 0x30, 0x00, 0xef, 0xed, 0x30, 0x00, 0xf5, 0xeb, 0x30, 0x40, - 0xe1, 0xd1, 0x30, 0x00, 0xe5, 0xda, 0x30, 0x00, 0xe9, 0xd4, 0x30, 0x00, - 0xef, 0xdd, 0x30, 0x00, 0xf5, 0xd7, 0x30, 0x40, 0xe1, 0xca, 0x30, 0x00, - 0xe5, 0xcd, 0x30, 0x00, 0xe9, 0xcb, 0x30, 0x00, 0xef, 0xce, 0x30, 0x00, - 0xf5, 0xcc, 0x30, 0x40, 0xe1, 0xde, 0x30, 0x00, 0xe5, 0xe1, 0x30, 0x00, - 0xe9, 0xdf, 0x30, 0x80, 0x08, 0xef, 0xe2, 0x30, 0x00, 0xf5, 0xe0, 0x30, - 0x40, 0x05, 0x4a, 0xe9, 0x01, 0xff, 0x0f, 0x8d, 0x70, 0x1d, 0x05, 0x06, - 0x32, 0x01, 0xff, 0xd2, 0xf0, 0xaf, 0x01, 0xd3, 0xf1, 0xaf, 0x01, 0xd4, - 0xf2, 0xaf, 0x01, 0xd5, 0xf3, 0xaf, 0x01, 0xd7, 0xf5, 0xaf, 0x01, 0xd8, - 0xf6, 0xaf, 0x41, 0xd1, 0xf7, 0xaf, 0x01, 0xd2, 0xf8, 0xaf, 0x01, 0xd3, - 0xf9, 0xaf, 0x01, 0xd4, 0xfa, 0xaf, 0x01, 0xd5, 0xfb, 0xaf, 0x01, 0xd7, - 0xfd, 0xaf, 0x01, 0xd8, 0xfe, 0xaf, 0x41, 0xe1, 0xab, 0x30, 0x00, 0xe5, - 0xb1, 0x30, 0x00, 0xe9, 0xad, 0x30, 0x00, 0xef, 0xb3, 0x30, 0x00, 0xf5, - 0xaf, 0x30, 0x40, 0xe1, 0xcf, 0x30, 0x00, 0xe5, 0xd8, 0x30, 0x00, 0xe9, - 0xd2, 0x30, 0x00, 0xef, 0xdb, 0x30, 0x00, 0xf5, 0xd5, 0x30, 0x40, 0xe1, - 0xac, 0x30, 0x00, 0xe5, 0xb2, 0x30, 0x00, 0xe9, 0xae, 0x30, 0x00, 0xef, - 0xb4, 0x30, 0x00, 0xf5, 0xb0, 0x30, 0x40, 0xe1, 0xc0, 0x30, 0x00, 0xe5, - 0xc7, 0x30, 0x00, 0xe9, 0xc2, 0x30, 0x00, 0xef, 0xc9, 0x30, 0x00, 0xf5, - 0xc5, 0x30, 0x40, 0xe1, 0xd0, 0x30, 0x00, 0xe5, 0xd9, 0x30, 0x00, 0xe9, - 0xd3, 0x30, 0x00, 0xef, 0xdc, 0x30, 0x00, 0xf5, 0xd6, 0x30, 0x40, 0x07, - 0xb9, 0x80, 0x01, 0xff, 0xe5, 0x00, 0xb0, 0x01, 0x42, 0x97, 0x31, 0x22, - 0xb1, 0x01, 0xb9, 0x01, 0xff, 0xe5, 0x21, 0xb1, 0x01, 0xe9, 0x20, 0xb1, - 0x41, 0xa7, 0xc7, 0x04, 0x05, 0x0e, 0xe9, 0x01, 0xff, 0xa1, 0xb3, 0x04, - 0x06, 0xef, 0x06, 0xec, 0x03, 0x02, 0x68, 0x00, 0x9f, 0x01, 0x05, 0x5a, - 0x03, 0x4e, 0x0b, 0x55, 0x77, 0x01, 0xff, 0xa1, 0x3b, 0xe5, 0xc6, 0x0c, - 0x80, 0x32, 0xe9, 0xbf, 0x0c, 0x80, 0x29, 0xef, 0xca, 0x0c, 0x80, 0x20, - 0xf5, 0xc1, 0x0c, 0x80, 0x17, 0x08, 0x43, 0xc1, 0x01, 0xff, 0xec, 0xe2, - 0x0c, 0x80, 0x09, 0xf2, 0xc3, 0x0c, 0xc0, 0x00, 0xf2, 0xc4, 0x0c, 0x40, - 0xec, 0xe3, 0x0c, 0x40, 0xf5, 0xc2, 0x0c, 0x40, 0xef, 0xcb, 0x0c, 0x40, - 0xe9, 0xc0, 0x0c, 0x40, 0xe5, 0xc7, 0x0c, 0x40, 0xe1, 0xbe, 0x0c, 0x00, - 0xe9, 0xc8, 0x0c, 0x00, 0xf5, 0xcc, 0x0c, 0x40, 0xa1, 0x3f, 0xa3, 0x31, - 0x4b, 0x07, 0x9e, 0xf1, 0x0c, 0x00, 0x45, 0x5a, 0x3f, 0xbc, 0x0c, 0x00, - 0xb3, 0x17, 0x4b, 0x8f, 0xa4, 0xf2, 0x0c, 0x00, 0x02, 0x02, 0x00, 0x01, - 0xff, 0x44, 0xe7, 0x23, 0xcd, 0x0c, 0x00, 0x45, 0xf3, 0x4b, 0x83, 0x0c, - 0x40, 0x46, 0xf9, 0xd5, 0x84, 0x0c, 0x00, 0x52, 0x80, 0x54, 0x80, 0x0c, - 0x40, 0x4a, 0xda, 0x23, 0x81, 0x0c, 0x00, 0x5d, 0x33, 0x16, 0xf3, 0x0c, - 0x40, 0x47, 0x3d, 0x16, 0x82, 0x0c, 0x00, 0x47, 0xc4, 0x88, 0xbd, 0x0c, - 0x40, 0x49, 0x5f, 0x39, 0xd5, 0x0c, 0x00, 0x05, 0xee, 0x05, 0x01, 0xff, - 0xe1, 0x85, 0x0c, 0x80, 0xab, 0x02, 0xa2, 0x9e, 0x02, 0xa3, 0x91, 0x02, - 0xa4, 0xf8, 0x01, 0xe5, 0x8e, 0x0c, 0x80, 0xee, 0x01, 0x42, 0x0c, 0x08, - 0xde, 0x0c, 0x00, 0xa7, 0xdb, 0x01, 0x42, 0x22, 0x00, 0xb9, 0x0c, 0x00, - 0xe9, 0x87, 0x0c, 0x80, 0xcb, 0x01, 0xaa, 0xbe, 0x01, 0xab, 0xb1, 0x01, - 0xac, 0x9d, 0x01, 0x42, 0x6c, 0x00, 0xae, 0x0c, 0x00, 0xae, 0x78, 0xef, - 0x92, 0x0c, 0x80, 0x6f, 0xb0, 0x63, 0xb2, 0x57, 0xb3, 0x45, 0xb4, 0x2c, - 0xf5, 0x89, 0x0c, 0x80, 0x23, 0xb6, 0x06, 0x42, 0xbe, 0x22, 0xaf, 0x0c, - 0x40, 0xe1, 0xb5, 0x0c, 0x00, 0x07, 0x44, 0xc1, 0x01, 0xff, 0xec, 0x8c, - 0x0c, 0x80, 0x09, 0xf2, 0x8b, 0x0c, 0xc0, 0x00, 0xf2, 0xe0, 0x0c, 0x40, - 0xec, 0xe1, 0x0c, 0x40, 0xf5, 0x8a, 0x0c, 0x40, 0xe1, 0xa4, 0x0c, 0x00, - 0x42, 0x22, 0x00, 0xa5, 0x0c, 0x00, 0xb4, 0x01, 0xff, 0xe1, 0x9f, 0x0c, - 0x00, 0x42, 0x22, 0x00, 0xa0, 0x0c, 0x40, 0xe1, 0xb8, 0x0c, 0x00, 0x42, - 0x22, 0x00, 0xb6, 0x0c, 0x00, 0x42, 0x40, 0x06, 0xb7, 0x0c, 0x40, 0xe1, - 0xb0, 0x0c, 0x00, 0x42, 0x71, 0x00, 0xb1, 0x0c, 0x40, 0xe1, 0xaa, 0x0c, - 0x00, 0x42, 0x22, 0x00, 0xab, 0x0c, 0x40, 0xef, 0x93, 0x0c, 0x40, 0xe1, - 0xa8, 0x0c, 0x80, 0x12, 0x42, 0x24, 0x02, 0x99, 0x0c, 0x00, 0x42, 0x2a, - 0x05, 0xa3, 0x0c, 0x00, 0x42, 0xbe, 0x22, 0x9e, 0x0c, 0x40, 0x4b, 0x1d, - 0x9e, 0xdd, 0x0c, 0x40, 0xe1, 0xb2, 0x0c, 0x00, 0xac, 0x01, 0xff, 0xe1, - 0xb3, 0x0c, 0x00, 0x42, 0x74, 0x00, 0xde, 0x0c, 0x40, 0xe1, 0x95, 0x0c, - 0x00, 0x42, 0x22, 0x00, 0x96, 0x0c, 0x40, 0xe1, 0x9c, 0x0c, 0x00, 0x42, - 0x22, 0x00, 0x9d, 0x0c, 0x40, 0xe9, 0x88, 0x0c, 0x40, 0xe1, 0x97, 0x0c, - 0x00, 0x42, 0x22, 0x00, 0x98, 0x0c, 0x40, 0xe5, 0x8f, 0x0c, 0x40, 0xe1, - 0xa6, 0x0c, 0x00, 0xa4, 0x06, 0x42, 0x22, 0x00, 0xa7, 0x0c, 0x40, 0xe1, - 0xa1, 0x0c, 0x00, 0x42, 0x22, 0x00, 0xa2, 0x0c, 0x40, 0xe1, 0x9a, 0x0c, - 0x00, 0x42, 0x22, 0x00, 0x9b, 0x0c, 0x40, 0xe1, 0xac, 0x0c, 0x00, 0x42, - 0x22, 0x00, 0xad, 0x0c, 0x40, 0xe1, 0x86, 0x0c, 0x00, 0xe9, 0x90, 0x0c, - 0x00, 0xf5, 0x94, 0x0c, 0x40, 0x45, 0x12, 0x0b, 0xee, 0x0c, 0x00, 0xa6, - 0x2e, 0x44, 0xea, 0x2a, 0xef, 0x0c, 0x00, 0x43, 0x0e, 0x0b, 0xe7, 0x0c, - 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xe6, 0x0c, 0x40, 0x44, - 0x25, 0x01, 0xe9, 0x0c, 0x00, 0x42, 0x15, 0x02, 0xe8, 0x0c, 0x40, 0x44, - 0xe5, 0x1d, 0xed, 0x0c, 0x00, 0x42, 0x1c, 0x26, 0xec, 0x0c, 0x40, 0x43, - 0xd2, 0x05, 0xeb, 0x0c, 0x00, 0x43, 0xf6, 0x06, 0xea, 0x0c, 0x40, 0x4d, - 0xeb, 0x83, 0xd6, 0x0c, 0x00, 0x4c, 0x5c, 0x94, 0xdc, 0x0c, 0x40, 0x44, - 0x39, 0xef, 0x98, 0xf9, 0x01, 0x0b, 0x76, 0xa5, 0x01, 0xff, 0xa1, 0x9b, - 0x0b, 0xa2, 0xab, 0x0a, 0xa3, 0xd1, 0x09, 0xa4, 0xdf, 0x08, 0xa5, 0x9e, - 0x08, 0xa6, 0xc1, 0x07, 0xa7, 0x90, 0x07, 0xa8, 0xc1, 0x06, 0xa9, 0xa9, - 0x06, 0x02, 0x72, 0x19, 0x9a, 0x06, 0x45, 0xdb, 0xa5, 0x11, 0x2f, 0x00, - 0xac, 0xca, 0x05, 0xad, 0xf9, 0x04, 0xae, 0xe3, 0x04, 0xaf, 0xbe, 0x04, - 0xb0, 0x9a, 0x04, 0xb2, 0xe1, 0x03, 0xb3, 0xdf, 0x01, 0xb4, 0x76, 0x43, - 0x45, 0x03, 0x64, 0x2f, 0x00, 0xb6, 0x62, 0xb7, 0x06, 0x46, 0xfe, 0xd7, - 0xc8, 0x2f, 0x40, 0xa1, 0x45, 0xa5, 0x37, 0xa8, 0x29, 0x02, 0x9e, 0x01, - 0x1d, 0xaf, 0x0f, 0xb2, 0x01, 0xff, 0x42, 0xe5, 0x05, 0x13, 0x2f, 0x00, - 0x43, 0xd8, 0x02, 0xae, 0x2f, 0x40, 0x43, 0x5d, 0x18, 0x25, 0x2f, 0x00, - 0x42, 0xbb, 0x00, 0x2f, 0x2f, 0x40, 0xe4, 0xb5, 0x2f, 0x00, 0xe5, 0xa3, - 0x2f, 0x40, 0x43, 0x89, 0x00, 0xc6, 0x2f, 0x00, 0x43, 0xaf, 0x02, 0x69, - 0x2f, 0x40, 0x44, 0x2d, 0xef, 0x4e, 0x2f, 0x00, 0x42, 0x60, 0x01, 0x91, - 0x2f, 0x40, 0x42, 0x67, 0x5b, 0xa1, 0x2f, 0x80, 0x06, 0x43, 0x8b, 0x00, - 0x54, 0x2f, 0x40, 0x4a, 0xa3, 0x68, 0x8f, 0x2f, 0x40, 0x45, 0x4f, 0xe4, - 0x95, 0x2f, 0x00, 0x46, 0xfa, 0xdc, 0xa5, 0x2f, 0x40, 0xa1, 0x53, 0x42, - 0x92, 0x01, 0x17, 0x2f, 0x00, 0xa9, 0x3f, 0xaf, 0x31, 0xb2, 0x1d, 0x02, - 0x42, 0x00, 0x0d, 0x42, 0x15, 0x02, 0x06, 0x2f, 0xc0, 0x00, 0x46, 0x7a, - 0x0e, 0x36, 0x2f, 0x40, 0x43, 0x26, 0x16, 0x31, 0x2f, 0x00, 0x43, 0xbd, - 0x01, 0xd4, 0x2f, 0x40, 0x43, 0x0e, 0x03, 0x71, 0x2f, 0x00, 0x42, 0x27, - 0x01, 0x4a, 0x2f, 0x00, 0x44, 0xc1, 0xf0, 0xcd, 0x2f, 0x40, 0x44, 0xb9, - 0x67, 0x86, 0x2f, 0x00, 0x43, 0x77, 0x0e, 0xd2, 0x2f, 0x40, 0x43, 0xdb, - 0x09, 0x8c, 0x2f, 0x00, 0x42, 0x68, 0x00, 0x61, 0x2f, 0x40, 0x43, 0x3e, - 0x01, 0x0f, 0x2f, 0x00, 0x42, 0x60, 0x07, 0xbc, 0x2f, 0x00, 0x4c, 0x85, - 0x80, 0xb1, 0x2f, 0x40, 0xa1, 0xec, 0x01, 0xa3, 0xdd, 0x01, 0xa5, 0xc4, - 0x01, 0xa8, 0x99, 0x01, 0xa9, 0x8a, 0x01, 0x43, 0x3b, 0x04, 0x6a, 0x2f, - 0x00, 0xac, 0x6e, 0x44, 0x5e, 0x07, 0x29, 0x2f, 0x00, 0x44, 0x7b, 0xaf, - 0x39, 0x2f, 0x00, 0x44, 0x41, 0x0b, 0xb3, 0x2f, 0x00, 0xb0, 0x3a, 0x45, - 0xd7, 0x05, 0x45, 0x2f, 0x00, 0xb4, 0x0c, 0x42, 0x42, 0x0b, 0x47, 0x2f, - 0x00, 0x44, 0x4f, 0x50, 0x62, 0x2f, 0x40, 0x43, 0x1a, 0x00, 0x74, 0x2f, - 0x00, 0xa5, 0x14, 0xaf, 0x01, 0xff, 0x42, 0xcd, 0x05, 0x6f, 0x2f, 0x00, - 0xf0, 0x4c, 0x2f, 0xc0, 0x00, 0x44, 0x46, 0x30, 0x89, 0x2f, 0x40, 0x42, - 0x57, 0x00, 0x53, 0x2f, 0x00, 0xf0, 0x3b, 0x2f, 0x40, 0xa5, 0x12, 0x44, - 0x7a, 0xbf, 0x70, 0x2f, 0x00, 0x43, 0xcd, 0x02, 0x14, 0x2f, 0x00, 0x44, - 0x85, 0xf2, 0x2c, 0x2f, 0x40, 0x42, 0x17, 0x00, 0x6d, 0x2f, 0x00, 0x43, - 0x1e, 0x41, 0x94, 0x2f, 0x40, 0xa1, 0x06, 0x43, 0x28, 0x1d, 0x5a, 0x2f, - 0x40, 0x42, 0xa4, 0x02, 0x03, 0x2f, 0x00, 0x42, 0x32, 0x00, 0xaa, 0x2f, - 0x40, 0x46, 0xc6, 0xda, 0x67, 0x2f, 0x00, 0x42, 0x67, 0x5b, 0x77, 0x2f, - 0x40, 0xa5, 0x1a, 0xaf, 0x01, 0xff, 0x42, 0x1b, 0x05, 0x37, 0x2f, 0x00, - 0x04, 0x95, 0xf2, 0x01, 0xff, 0x4a, 0xa2, 0xa7, 0xab, 0x2f, 0x00, 0x45, - 0x44, 0x9e, 0x33, 0x2f, 0x40, 0x42, 0xeb, 0x0a, 0x7a, 0x2f, 0x00, 0x42, - 0x60, 0x07, 0x99, 0x2f, 0x40, 0x42, 0x13, 0x00, 0x19, 0x2f, 0x00, 0x44, - 0xfa, 0x7b, 0x04, 0x2f, 0x00, 0xe5, 0x92, 0x2f, 0x00, 0x42, 0x24, 0x00, - 0x83, 0x2f, 0x40, 0x45, 0x38, 0xe7, 0x20, 0x2f, 0x00, 0x44, 0x76, 0x06, - 0x42, 0x2f, 0x40, 0x4e, 0x9c, 0x76, 0xbf, 0x2f, 0x00, 0x42, 0xb8, 0x04, - 0xc4, 0x2f, 0x00, 0xf9, 0x48, 0x2f, 0x40, 0xa1, 0x26, 0x42, 0x05, 0x00, - 0x9a, 0x2f, 0x00, 0xa9, 0x0c, 0x43, 0x13, 0xc9, 0x27, 0x2f, 0x00, 0x42, - 0x42, 0x0b, 0x9b, 0x2f, 0x40, 0x42, 0x73, 0x02, 0x76, 0x2f, 0x00, 0x4c, - 0x60, 0x3b, 0x15, 0x2f, 0x00, 0x43, 0x32, 0x00, 0x2e, 0x2f, 0x40, 0x42, - 0x9e, 0x01, 0xac, 0x2f, 0x00, 0xf0, 0x41, 0x2f, 0x00, 0xf4, 0xcf, 0x2f, - 0x40, 0x42, 0x3f, 0x00, 0x97, 0x2f, 0x00, 0x43, 0x13, 0x01, 0x7e, 0x2f, - 0x00, 0x44, 0x14, 0x01, 0x12, 0x2f, 0x00, 0xb2, 0x01, 0xff, 0x45, 0x8c, - 0xd6, 0x1b, 0x2f, 0x00, 0x46, 0xd4, 0xde, 0x5e, 0x2f, 0x40, 0x42, 0xfe, - 0x1a, 0x7c, 0x2f, 0x00, 0x42, 0xcd, 0x05, 0x00, 0x2f, 0x80, 0x0f, 0xb0, - 0x01, 0xff, 0x46, 0xd3, 0x3a, 0x10, 0x2f, 0x00, 0x44, 0xae, 0x89, 0x87, - 0x2f, 0x40, 0x44, 0xbd, 0xf2, 0x30, 0x2f, 0x40, 0x42, 0xed, 0x05, 0x79, - 0x2f, 0x00, 0xaf, 0x01, 0xff, 0x42, 0x46, 0x03, 0xd0, 0x2f, 0x00, 0xf4, - 0x46, 0x2f, 0x40, 0x42, 0x1a, 0x00, 0x08, 0x2f, 0x00, 0xa5, 0x3a, 0xa9, - 0x2c, 0xaf, 0x01, 0xff, 0x42, 0x10, 0x00, 0x49, 0x2f, 0x00, 0xb2, 0x15, - 0xb5, 0x01, 0xff, 0xae, 0x06, 0x42, 0x53, 0x00, 0x1d, 0x2f, 0x40, 0xe4, - 0xa9, 0x2f, 0x00, 0x44, 0x55, 0x07, 0x2d, 0x2f, 0x40, 0x44, 0x58, 0x07, - 0xa0, 0x2f, 0x00, 0x43, 0x32, 0x13, 0x85, 0x2f, 0x40, 0x44, 0xb6, 0x21, - 0xc9, 0x2f, 0x00, 0x46, 0x74, 0xde, 0x82, 0x2f, 0x40, 0x42, 0x8a, 0x00, - 0x81, 0x2f, 0x00, 0x43, 0xd7, 0x02, 0x60, 0x2f, 0x40, 0xa1, 0x39, 0xa5, - 0x1f, 0xa9, 0x0d, 0x43, 0xd8, 0x02, 0xa7, 0x2f, 0xc0, 0x00, 0x47, 0xaf, - 0xcd, 0x35, 0x2f, 0x40, 0xe4, 0x07, 0x2f, 0x00, 0x42, 0x28, 0x1a, 0x63, - 0x2f, 0x00, 0x42, 0xcd, 0x05, 0x01, 0x2f, 0x40, 0xa1, 0x0c, 0x42, 0xf1, - 0x18, 0xb2, 0x2f, 0x00, 0x42, 0xbc, 0x11, 0x09, 0x2f, 0x40, 0xe6, 0xb4, - 0x2f, 0x00, 0x44, 0x2b, 0x1a, 0xb0, 0x2f, 0x40, 0x42, 0x36, 0x01, 0x4b, - 0x2f, 0x00, 0x42, 0x2a, 0x02, 0x2a, 0x2f, 0x40, 0x42, 0x04, 0x00, 0x5f, - 0x2f, 0x00, 0xf2, 0x78, 0x2f, 0x40, 0x42, 0x73, 0x02, 0x0e, 0x2f, 0x00, - 0xae, 0x01, 0xff, 0x42, 0x6d, 0x14, 0x28, 0x2f, 0x00, 0x44, 0xae, 0x0a, - 0x8d, 0x2f, 0x40, 0xa1, 0x30, 0xa5, 0x1c, 0x4f, 0x71, 0x6e, 0x16, 0x2f, - 0x00, 0xaf, 0x01, 0xff, 0x42, 0x55, 0x05, 0x05, 0x2f, 0x00, 0xb2, 0x01, - 0xff, 0xee, 0x93, 0x2f, 0x00, 0x42, 0x46, 0x03, 0xba, 0x2f, 0x40, 0xa1, - 0x06, 0x42, 0x0e, 0x1c, 0xc7, 0x2f, 0x40, 0xe4, 0xb8, 0x2f, 0x00, 0x42, - 0x34, 0x00, 0x3c, 0x2f, 0x40, 0x42, 0x46, 0x00, 0xbd, 0x2f, 0x00, 0xac, - 0x06, 0x42, 0x1b, 0x00, 0x3f, 0x2f, 0x40, 0x44, 0x5d, 0xef, 0x3d, 0x2f, - 0x00, 0x4c, 0xcc, 0x75, 0x59, 0x2f, 0x40, 0x43, 0x8a, 0x00, 0xa8, 0x2f, - 0x00, 0x44, 0xd5, 0x7c, 0xc1, 0x2f, 0x00, 0xef, 0x21, 0x2f, 0x80, 0x11, - 0x02, 0x71, 0x00, 0x01, 0xff, 0x42, 0x9e, 0x01, 0x72, 0x2f, 0x00, 0x42, - 0xee, 0x00, 0x8b, 0x2f, 0x40, 0x47, 0xa8, 0xcd, 0x22, 0x2f, 0x00, 0x42, - 0xfe, 0x1a, 0xa6, 0x2f, 0x40, 0xa1, 0x46, 0x46, 0x29, 0x1a, 0x7b, 0x2f, - 0x00, 0xa9, 0x26, 0xac, 0x1a, 0x43, 0xc6, 0x6c, 0x9c, 0x2f, 0x00, 0xb2, - 0x06, 0x42, 0x42, 0x00, 0x51, 0x2f, 0x40, 0x46, 0xb2, 0xd9, 0xb9, 0x2f, - 0x00, 0x42, 0xdd, 0x18, 0xcc, 0x2f, 0x40, 0x43, 0x16, 0x39, 0xd5, 0x2f, - 0x00, 0xf9, 0xb6, 0x2f, 0x40, 0x43, 0x04, 0x24, 0x65, 0x2f, 0x00, 0x43, - 0xca, 0x00, 0xbe, 0x2f, 0x00, 0x42, 0x88, 0x00, 0x55, 0x2f, 0x00, 0x42, - 0xa4, 0x02, 0xc2, 0x2f, 0x40, 0x42, 0x73, 0x02, 0xaf, 0x2f, 0x00, 0x42, - 0x1d, 0x01, 0x5b, 0x2f, 0x00, 0x44, 0x2b, 0x1a, 0x57, 0x2f, 0x40, 0xa1, - 0x2d, 0x44, 0xc9, 0x00, 0x0b, 0x2f, 0x00, 0x49, 0x18, 0xbc, 0xcb, 0x2f, - 0x00, 0xae, 0x13, 0x43, 0xe6, 0x1d, 0xd1, 0x2f, 0x80, 0x06, 0x42, 0x4d, - 0x00, 0x6c, 0x2f, 0x40, 0x43, 0xa1, 0x01, 0x23, 0x2f, 0x40, 0x47, 0xa6, - 0x68, 0x1e, 0x2f, 0x00, 0x43, 0x8b, 0x00, 0x0a, 0x2f, 0x40, 0xf2, 0x7f, - 0x2f, 0x80, 0x04, 0xf4, 0xb7, 0x2f, 0x40, 0x42, 0x53, 0x00, 0x1f, 0x2f, - 0x40, 0xa5, 0x61, 0xa9, 0x47, 0xaf, 0x13, 0xb2, 0x01, 0xff, 0x44, 0x00, - 0x26, 0xd3, 0x2f, 0x00, 0x42, 0x48, 0x04, 0xce, 0x2f, 0x00, 0xf9, 0x32, - 0x2f, 0x40, 0x44, 0xac, 0x1d, 0x4f, 0x2f, 0x00, 0xe7, 0x5d, 0x2f, 0x00, - 0x42, 0x0c, 0x00, 0x3e, 0x2f, 0x00, 0xf4, 0x02, 0x2f, 0x80, 0x0c, 0x46, - 0xf6, 0xe0, 0x58, 0x2f, 0x00, 0x46, 0x68, 0xe1, 0x0c, 0x2f, 0x40, 0x04, - 0x77, 0x00, 0x01, 0xff, 0x45, 0x71, 0xe5, 0x34, 0x2f, 0x00, 0x44, 0x84, - 0x61, 0x68, 0x2f, 0x40, 0x44, 0x6e, 0x02, 0x43, 0x2f, 0x00, 0xb3, 0x06, - 0x48, 0xf9, 0xba, 0x18, 0x2f, 0x40, 0xe8, 0x6b, 0x2f, 0x00, 0x48, 0x82, - 0xa5, 0xa4, 0x2f, 0x40, 0x43, 0x74, 0x0f, 0x4d, 0x2f, 0x00, 0x42, 0x33, - 0x00, 0xc5, 0x2f, 0x40, 0xa1, 0x43, 0x44, 0x2f, 0x4a, 0x26, 0x2f, 0x00, - 0x43, 0xd3, 0x27, 0xa2, 0x2f, 0x00, 0xac, 0x1f, 0xaf, 0x01, 0xff, 0x43, - 0x86, 0x08, 0x8a, 0x2f, 0x00, 0x45, 0xe1, 0xe8, 0x50, 0x2f, 0x00, 0x44, - 0x89, 0xf2, 0x2b, 0x2f, 0x00, 0x43, 0x32, 0x00, 0x0d, 0x2f, 0x00, 0xf7, - 0x5c, 0x2f, 0x40, 0xa1, 0x0c, 0x43, 0x5d, 0x48, 0x1a, 0x2f, 0x00, 0x45, - 0x5e, 0x88, 0x90, 0x2f, 0x40, 0xee, 0x52, 0x2f, 0x00, 0xf7, 0x56, 0x2f, - 0x40, 0x42, 0x34, 0x00, 0x9e, 0x2f, 0x00, 0x46, 0x54, 0xcf, 0xc0, 0x2f, - 0x00, 0x42, 0x32, 0x00, 0x73, 0x2f, 0x40, 0xa1, 0x5f, 0x43, 0x2f, 0x1f, - 0x96, 0x2f, 0x00, 0xa9, 0x47, 0xac, 0x33, 0xaf, 0x15, 0xb2, 0x01, 0xff, - 0x44, 0xc7, 0x25, 0x40, 0x2f, 0x00, 0x45, 0xb5, 0xe7, 0x3a, 0x2f, 0x00, - 0x43, 0x45, 0x7c, 0x80, 0x2f, 0x40, 0x42, 0x8a, 0x00, 0x88, 0x2f, 0x00, - 0x42, 0x4c, 0x0d, 0x9d, 0x2f, 0x00, 0x4b, 0x1a, 0x9f, 0x66, 0x2f, 0x00, - 0x42, 0xcd, 0x05, 0xbb, 0x2f, 0x00, 0xf7, 0x38, 0x2f, 0x40, 0x43, 0x0e, - 0x03, 0xca, 0x2f, 0x00, 0x43, 0xcf, 0x2d, 0x8e, 0x2f, 0x00, 0x42, 0xd6, - 0x13, 0xad, 0x2f, 0x40, 0xe7, 0x24, 0x2f, 0x00, 0x42, 0xab, 0x01, 0xc3, - 0x2f, 0x00, 0x44, 0xee, 0x05, 0x9f, 0x2f, 0x40, 0x44, 0xa9, 0xef, 0x98, - 0x2f, 0x00, 0x44, 0xba, 0x98, 0x75, 0x2f, 0x40, 0x44, 0x41, 0x4b, 0x1c, - 0x2f, 0x00, 0x42, 0x1b, 0x00, 0x7d, 0x2f, 0x00, 0x02, 0xcf, 0x00, 0x06, - 0x42, 0x74, 0x43, 0x44, 0x2f, 0x40, 0x43, 0xd2, 0x05, 0x84, 0x2f, 0x00, - 0x42, 0xd1, 0x00, 0x6e, 0x2f, 0x40, 0xa5, 0x75, 0xa6, 0x58, 0x44, 0xea, - 0x2a, 0xc9, 0xd2, 0x81, 0x4b, 0x43, 0x0e, 0x0b, 0xc1, 0xd2, 0x01, 0xb3, - 0x29, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xc0, 0xd2, 0x41, 0x42, 0x92, 0x01, - 0xca, 0xd2, 0x01, 0xa8, 0x0d, 0xb7, 0x01, 0xff, 0x44, 0x02, 0x2c, 0xcc, - 0xd2, 0x01, 0xef, 0xc2, 0xd2, 0x41, 0x46, 0x9d, 0x5a, 0xcd, 0xd2, 0x01, - 0x43, 0x26, 0x01, 0xc3, 0xd2, 0x41, 0x44, 0xe5, 0x1d, 0xc7, 0xd2, 0x81, - 0x0d, 0x42, 0x1c, 0x26, 0xc6, 0xd2, 0xc1, 0x00, 0x44, 0x26, 0x18, 0xd0, - 0xd2, 0x41, 0x44, 0x26, 0x18, 0xd1, 0xd2, 0x41, 0x44, 0x26, 0x18, 0xd3, - 0xd2, 0x41, 0xa9, 0x0d, 0x43, 0xf6, 0x06, 0xc4, 0xd2, 0xc1, 0x00, 0x44, - 0x26, 0x18, 0xce, 0xd2, 0x41, 0x45, 0x25, 0x18, 0xcf, 0xd2, 0x01, 0x42, - 0x32, 0x00, 0xc5, 0xd2, 0x41, 0x44, 0xc9, 0x00, 0xc8, 0xd2, 0x81, 0x06, - 0x45, 0xbb, 0x6f, 0xcb, 0xd2, 0x41, 0x43, 0xc4, 0x09, 0xd2, 0xd2, 0x41, - 0x51, 0xe3, 0x57, 0xbb, 0x10, 0x01, 0xa4, 0x80, 0x03, 0x50, 0xdd, 0x62, - 0xbc, 0x10, 0x01, 0x07, 0xec, 0x05, 0x70, 0x4b, 0x64, 0xa0, 0xbd, 0x10, - 0x81, 0x63, 0xb3, 0x33, 0x0b, 0x55, 0x77, 0x01, 0xff, 0xa1, 0x20, 0xe5, - 0xb5, 0x10, 0x01, 0xe9, 0xb1, 0x10, 0x81, 0x13, 0xef, 0xb7, 0x10, 0x01, - 0xf5, 0xb3, 0x10, 0x81, 0x06, 0x49, 0x43, 0xc1, 0xc2, 0x10, 0x41, 0xf5, - 0xb4, 0x10, 0x41, 0xe9, 0xb2, 0x10, 0x41, 0xe1, 0xb0, 0x10, 0x01, 0xe9, - 0xb6, 0x10, 0x01, 0xf5, 0xb8, 0x10, 0x41, 0x4b, 0x14, 0x27, 0xbe, 0x10, - 0x01, 0x04, 0x5b, 0x03, 0x01, 0xff, 0x48, 0x3c, 0x16, 0x81, 0x10, 0x01, - 0x4b, 0xd9, 0x23, 0x80, 0x10, 0x01, 0x45, 0x5a, 0x3f, 0xba, 0x10, 0x01, - 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0xe7, 0x23, 0xb9, 0x10, 0x01, 0x45, - 0xf3, 0x4b, 0x82, 0x10, 0x41, 0x46, 0x5b, 0x00, 0xcd, 0x10, 0x41, 0xe1, - 0x83, 0x10, 0x81, 0xf4, 0x01, 0xa2, 0xe7, 0x01, 0xa3, 0xda, 0x01, 0xa4, - 0xbb, 0x01, 0xe5, 0x89, 0x10, 0x01, 0xa7, 0xaa, 0x01, 0x42, 0x22, 0x00, - 0xaf, 0x10, 0x01, 0xe9, 0x85, 0x10, 0x81, 0x9a, 0x01, 0xaa, 0x8d, 0x01, - 0xab, 0x80, 0x01, 0x42, 0x74, 0x00, 0xaa, 0x10, 0x01, 0x42, 0x6c, 0x00, - 0xa7, 0x10, 0x01, 0xae, 0x5c, 0xef, 0x8b, 0x10, 0x01, 0xb0, 0x4c, 0xb2, - 0x40, 0xb3, 0x2e, 0xb4, 0x15, 0xf5, 0x87, 0x10, 0x81, 0x0c, 0x42, 0xf5, - 0x0a, 0xab, 0x10, 0x01, 0x42, 0xbe, 0x22, 0xa8, 0x10, 0x41, 0xf5, 0x88, - 0x10, 0x41, 0xe1, 0x9e, 0x10, 0x01, 0x42, 0x22, 0x00, 0x9f, 0x10, 0x01, - 0xb4, 0x01, 0xff, 0xe1, 0x97, 0x10, 0x01, 0x42, 0x22, 0x00, 0x98, 0x10, - 0x41, 0xe1, 0xae, 0x10, 0x01, 0x42, 0x22, 0x00, 0xac, 0x10, 0x01, 0x42, - 0x40, 0x06, 0xad, 0x10, 0x41, 0xe1, 0xa9, 0x10, 0x01, 0x42, 0x22, 0x00, - 0x9c, 0x10, 0x41, 0xe1, 0xa3, 0x10, 0x01, 0x42, 0x22, 0x00, 0xa4, 0x10, - 0x41, 0xe1, 0xa2, 0x10, 0x01, 0x42, 0x24, 0x02, 0x91, 0x10, 0x01, 0x42, - 0x2a, 0x05, 0x9d, 0x10, 0x01, 0x42, 0xbe, 0x22, 0x96, 0x10, 0x41, 0xe1, - 0x8d, 0x10, 0x01, 0x42, 0x22, 0x00, 0x8e, 0x10, 0x41, 0xe1, 0x94, 0x10, - 0x01, 0x42, 0x22, 0x00, 0x95, 0x10, 0x41, 0xe9, 0x86, 0x10, 0x41, 0xe1, - 0x8f, 0x10, 0x01, 0x42, 0x22, 0x00, 0x90, 0x10, 0x41, 0xe1, 0xa0, 0x10, - 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0xa1, 0x10, 0x41, 0xe1, 0x99, 0x10, - 0x01, 0x43, 0xee, 0x4b, 0x9a, 0x10, 0x01, 0x42, 0x22, 0x00, 0x9b, 0x10, - 0x41, 0xe1, 0x92, 0x10, 0x01, 0x42, 0x22, 0x00, 0x93, 0x10, 0x41, 0xe1, - 0xa5, 0x10, 0x01, 0x42, 0x22, 0x00, 0xa6, 0x10, 0x41, 0xe1, 0x84, 0x10, - 0x01, 0xe9, 0x8a, 0x10, 0x01, 0xf5, 0x8c, 0x10, 0x41, 0x44, 0x75, 0x20, - 0xc0, 0x10, 0x01, 0x06, 0x3c, 0x01, 0x01, 0xff, 0x45, 0x37, 0x96, 0xc1, - 0x10, 0x01, 0x4c, 0x13, 0x27, 0xbf, 0x10, 0x41, 0xa1, 0x37, 0xa5, 0x29, - 0x52, 0xac, 0x52, 0xe9, 0xf9, 0x01, 0xaf, 0x15, 0xb5, 0x01, 0xff, 0x46, - 0x16, 0xdc, 0x39, 0xf9, 0x01, 0x42, 0xb4, 0x01, 0xb5, 0x26, 0x00, 0x45, - 0x08, 0xea, 0x43, 0x26, 0x40, 0x42, 0x9e, 0x01, 0x1d, 0x2a, 0x00, 0x46, - 0xaa, 0xe1, 0x79, 0xf5, 0x41, 0x43, 0x49, 0x46, 0x56, 0xf4, 0x01, 0x47, - 0x19, 0xd3, 0xbc, 0xfa, 0x41, 0x4c, 0x84, 0x8d, 0x83, 0xf3, 0x01, 0x07, - 0x9a, 0xd4, 0x83, 0x05, 0xf2, 0xd9, 0xfa, 0x01, 0x07, 0x3a, 0xd7, 0x01, - 0xff, 0x0f, 0x58, 0x33, 0xe3, 0x04, 0x06, 0xef, 0x06, 0x9c, 0x04, 0x02, - 0x68, 0x00, 0xdb, 0x01, 0x02, 0xbb, 0x09, 0x70, 0x4f, 0x9a, 0x72, 0xc2, - 0xa9, 0x00, 0x05, 0x5a, 0x03, 0x47, 0x53, 0xd3, 0x4d, 0xcd, 0xa9, 0x00, - 0x0b, 0x55, 0x77, 0x01, 0xff, 0x4a, 0x78, 0xa9, 0xbb, 0xa9, 0x00, 0x45, - 0xfe, 0xe9, 0xbc, 0xa9, 0x00, 0x44, 0x29, 0xd6, 0xb8, 0xa9, 0x80, 0x23, - 0xb4, 0x0d, 0x44, 0x51, 0xf3, 0xb6, 0xa9, 0xc0, 0x00, 0x46, 0x50, 0xd8, - 0xb7, 0xa9, 0x40, 0xa1, 0x06, 0x45, 0x51, 0x12, 0xb5, 0xa9, 0x40, 0x44, - 0x2f, 0x0b, 0xba, 0xa9, 0x00, 0x44, 0xf1, 0xeb, 0xb4, 0xa9, 0x40, 0x47, - 0x69, 0xcd, 0xb9, 0xa9, 0x40, 0x45, 0x30, 0xe5, 0x81, 0xa9, 0x80, 0x12, - 0x45, 0x41, 0xe8, 0x82, 0xa9, 0x00, 0x49, 0x10, 0xbe, 0x80, 0xa9, 0x00, - 0x47, 0xa3, 0xd7, 0x83, 0xa9, 0x40, 0x45, 0x06, 0xe2, 0xb3, 0xa9, 0x40, - 0x03, 0x95, 0x1a, 0x11, 0x02, 0x1d, 0x01, 0x01, 0xff, 0x43, 0x28, 0x70, - 0xc0, 0xa9, 0x00, 0x47, 0x42, 0xd5, 0xcf, 0xa9, 0x40, 0xa1, 0x3d, 0x49, - 0xdd, 0xba, 0xdf, 0xa9, 0x00, 0xac, 0x20, 0x45, 0x82, 0xe8, 0xc4, 0xa9, - 0x00, 0xb0, 0x0c, 0x4d, 0x5a, 0x89, 0xde, 0xa9, 0x00, 0x45, 0x79, 0xec, - 0xc6, 0xa9, 0x40, 0x46, 0xd6, 0xd9, 0xc7, 0xa9, 0x00, 0x46, 0xe0, 0x4d, - 0xcc, 0xa9, 0x40, 0x45, 0x97, 0xe7, 0xc8, 0xa9, 0x00, 0xb5, 0x01, 0xff, - 0x43, 0x41, 0x00, 0xc5, 0xa9, 0x00, 0x44, 0x1f, 0x73, 0xc9, 0xa9, 0x40, - 0x43, 0x85, 0x11, 0xca, 0xa9, 0x80, 0x06, 0x44, 0x8d, 0xf1, 0xc3, 0xa9, - 0x40, 0x45, 0xc8, 0xb5, 0xcb, 0xa9, 0x40, 0x4c, 0x34, 0x8f, 0xc1, 0xa9, - 0x00, 0x05, 0xee, 0x05, 0x01, 0xff, 0xe1, 0x84, 0xa9, 0x80, 0xa7, 0x02, + 0xf5, 0xf7, 0x31, 0x40, 0x49, 0x46, 0xc4, 0x68, 0xb1, 0x41, 0xe1, 0xe9, + 0x30, 0x00, 0xe5, 0xec, 0x30, 0x00, 0xe9, 0xea, 0x30, 0x00, 0xef, 0xed, + 0x30, 0x00, 0xf5, 0xeb, 0x30, 0x40, 0xe1, 0xd1, 0x30, 0x00, 0xe5, 0xda, + 0x30, 0x00, 0xe9, 0xd4, 0x30, 0x00, 0xef, 0xdd, 0x30, 0x00, 0xf5, 0xd7, + 0x30, 0x40, 0xe1, 0xca, 0x30, 0x00, 0xe5, 0xcd, 0x30, 0x00, 0xe9, 0xcb, + 0x30, 0x00, 0xef, 0xce, 0x30, 0x00, 0xf5, 0xcc, 0x30, 0x40, 0xe1, 0xde, + 0x30, 0x00, 0xe5, 0xe1, 0x30, 0x00, 0xe9, 0xdf, 0x30, 0x80, 0x08, 0xef, + 0xe2, 0x30, 0x00, 0xf5, 0xe0, 0x30, 0x40, 0x05, 0x1c, 0xef, 0x01, 0xff, + 0x0f, 0xaa, 0x73, 0x1d, 0x05, 0xa0, 0x33, 0x01, 0xff, 0xd2, 0xf0, 0xaf, + 0x01, 0xd3, 0xf1, 0xaf, 0x01, 0xd4, 0xf2, 0xaf, 0x01, 0xd5, 0xf3, 0xaf, + 0x01, 0xd7, 0xf5, 0xaf, 0x01, 0xd8, 0xf6, 0xaf, 0x41, 0xd1, 0xf7, 0xaf, + 0x01, 0xd2, 0xf8, 0xaf, 0x01, 0xd3, 0xf9, 0xaf, 0x01, 0xd4, 0xfa, 0xaf, + 0x01, 0xd5, 0xfb, 0xaf, 0x01, 0xd7, 0xfd, 0xaf, 0x01, 0xd8, 0xfe, 0xaf, + 0x41, 0xe1, 0xab, 0x30, 0x00, 0xe5, 0xb1, 0x30, 0x00, 0xe9, 0xad, 0x30, + 0x00, 0xef, 0xb3, 0x30, 0x00, 0xf5, 0xaf, 0x30, 0x40, 0xe1, 0xcf, 0x30, + 0x00, 0xe5, 0xd8, 0x30, 0x00, 0xe9, 0xd2, 0x30, 0x00, 0xef, 0xdb, 0x30, + 0x00, 0xf5, 0xd5, 0x30, 0x40, 0xe1, 0xac, 0x30, 0x00, 0xe5, 0xb2, 0x30, + 0x00, 0xe9, 0xae, 0x30, 0x00, 0xef, 0xb4, 0x30, 0x00, 0xf5, 0xb0, 0x30, + 0x40, 0xe1, 0xc0, 0x30, 0x00, 0xe5, 0xc7, 0x30, 0x00, 0xe9, 0xc2, 0x30, + 0x00, 0xef, 0xc9, 0x30, 0x00, 0xf5, 0xc5, 0x30, 0x40, 0xe1, 0xd0, 0x30, + 0x00, 0xe5, 0xd9, 0x30, 0x00, 0xe9, 0xd3, 0x30, 0x00, 0xef, 0xdc, 0x30, + 0x00, 0xf5, 0xd6, 0x30, 0x40, 0x09, 0xc0, 0x12, 0x1a, 0x07, 0xb4, 0x84, + 0x01, 0xff, 0xe5, 0x00, 0xb0, 0x01, 0x42, 0x48, 0x33, 0x22, 0xb1, 0x01, + 0xb9, 0x01, 0xff, 0xe5, 0x21, 0xb1, 0x01, 0xe9, 0x20, 0xb1, 0x41, 0x42, + 0xf1, 0x05, 0x27, 0xb1, 0x01, 0x42, 0x51, 0x00, 0x28, 0xb1, 0x41, 0x44, + 0xd8, 0xf6, 0xff, 0x30, 0x00, 0x02, 0x1e, 0x00, 0x06, 0x44, 0x40, 0xf9, + 0x26, 0xb1, 0x41, 0x42, 0x45, 0x00, 0x24, 0xb1, 0x01, 0x42, 0x77, 0x00, + 0x25, 0xb1, 0x41, 0xa7, 0xc7, 0x04, 0x05, 0xe0, 0xee, 0x01, 0xff, 0xa1, + 0xb3, 0x04, 0x06, 0xef, 0x06, 0xec, 0x03, 0x02, 0x68, 0x00, 0x9f, 0x01, + 0x05, 0x5a, 0x03, 0x4e, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xa1, 0x3b, 0xe5, + 0xc6, 0x0c, 0x80, 0x32, 0xe9, 0xbf, 0x0c, 0x80, 0x29, 0xef, 0xca, 0x0c, + 0x80, 0x20, 0xf5, 0xc1, 0x0c, 0x80, 0x17, 0x08, 0xf2, 0xc6, 0x01, 0xff, + 0xec, 0xe2, 0x0c, 0x80, 0x09, 0xf2, 0xc3, 0x0c, 0xc0, 0x00, 0xf2, 0xc4, + 0x0c, 0x40, 0xec, 0xe3, 0x0c, 0x40, 0xf5, 0xc2, 0x0c, 0x40, 0xef, 0xcb, + 0x0c, 0x40, 0xe9, 0xc0, 0x0c, 0x40, 0xe5, 0xc7, 0x0c, 0x40, 0xe1, 0xbe, + 0x0c, 0x00, 0xe9, 0xc8, 0x0c, 0x00, 0xf5, 0xcc, 0x0c, 0x40, 0xa1, 0x3f, + 0xa3, 0x31, 0x4b, 0x10, 0xa3, 0xf1, 0x0c, 0x00, 0x45, 0x62, 0x41, 0xbc, + 0x0c, 0x00, 0xb3, 0x17, 0x4b, 0xb9, 0xa9, 0xf2, 0x0c, 0x00, 0x02, 0x02, + 0x00, 0x01, 0xff, 0x44, 0x21, 0x25, 0xcd, 0x0c, 0x00, 0x45, 0x49, 0x4e, + 0x83, 0x0c, 0x40, 0x46, 0xc9, 0xdb, 0x84, 0x0c, 0x00, 0x52, 0xd5, 0x56, + 0x80, 0x0c, 0x40, 0x4a, 0x14, 0x25, 0x81, 0x0c, 0x00, 0x5d, 0x01, 0x17, + 0xf3, 0x0c, 0x40, 0x47, 0x0b, 0x17, 0x82, 0x0c, 0x00, 0x47, 0x34, 0x8d, + 0xbd, 0x0c, 0x40, 0x49, 0x7c, 0x3b, 0xd5, 0x0c, 0x00, 0x05, 0x15, 0x06, + 0x01, 0xff, 0xe1, 0x85, 0x0c, 0x80, 0xab, 0x02, 0xa2, 0x9e, 0x02, 0xa3, + 0x91, 0x02, 0xa4, 0xf8, 0x01, 0xe5, 0x8e, 0x0c, 0x80, 0xee, 0x01, 0x42, + 0x0c, 0x08, 0xde, 0x0c, 0x00, 0xa7, 0xdb, 0x01, 0x42, 0x22, 0x00, 0xb9, + 0x0c, 0x00, 0xe9, 0x87, 0x0c, 0x80, 0xcb, 0x01, 0xaa, 0xbe, 0x01, 0xab, + 0xb1, 0x01, 0xac, 0x9d, 0x01, 0x42, 0x6c, 0x00, 0xae, 0x0c, 0x00, 0xae, + 0x78, 0xef, 0x92, 0x0c, 0x80, 0x6f, 0xb0, 0x63, 0xb2, 0x57, 0xb3, 0x45, + 0xb4, 0x2c, 0xf5, 0x89, 0x0c, 0x80, 0x23, 0xb6, 0x06, 0x42, 0xdf, 0x23, + 0xaf, 0x0c, 0x40, 0xe1, 0xb5, 0x0c, 0x00, 0x07, 0xf3, 0xc6, 0x01, 0xff, + 0xec, 0x8c, 0x0c, 0x80, 0x09, 0xf2, 0x8b, 0x0c, 0xc0, 0x00, 0xf2, 0xe0, + 0x0c, 0x40, 0xec, 0xe1, 0x0c, 0x40, 0xf5, 0x8a, 0x0c, 0x40, 0xe1, 0xa4, + 0x0c, 0x00, 0x42, 0x22, 0x00, 0xa5, 0x0c, 0x00, 0xb4, 0x01, 0xff, 0xe1, + 0x9f, 0x0c, 0x00, 0x42, 0x22, 0x00, 0xa0, 0x0c, 0x40, 0xe1, 0xb8, 0x0c, + 0x00, 0x42, 0x22, 0x00, 0xb6, 0x0c, 0x00, 0x42, 0x40, 0x06, 0xb7, 0x0c, + 0x40, 0xe1, 0xb0, 0x0c, 0x00, 0x42, 0x71, 0x00, 0xb1, 0x0c, 0x40, 0xe1, + 0xaa, 0x0c, 0x00, 0x42, 0x22, 0x00, 0xab, 0x0c, 0x40, 0xef, 0x93, 0x0c, + 0x40, 0xe1, 0xa8, 0x0c, 0x80, 0x12, 0x42, 0x24, 0x02, 0x99, 0x0c, 0x00, + 0x42, 0x2a, 0x05, 0xa3, 0x0c, 0x00, 0x42, 0xdf, 0x23, 0x9e, 0x0c, 0x40, + 0x4b, 0x26, 0xa3, 0xdd, 0x0c, 0x40, 0xe1, 0xb2, 0x0c, 0x00, 0xac, 0x01, + 0xff, 0xe1, 0xb3, 0x0c, 0x00, 0x42, 0x74, 0x00, 0xde, 0x0c, 0x40, 0xe1, + 0x95, 0x0c, 0x00, 0x42, 0x22, 0x00, 0x96, 0x0c, 0x40, 0xe1, 0x9c, 0x0c, + 0x00, 0x42, 0x22, 0x00, 0x9d, 0x0c, 0x40, 0xe9, 0x88, 0x0c, 0x40, 0xe1, + 0x97, 0x0c, 0x00, 0x42, 0x22, 0x00, 0x98, 0x0c, 0x40, 0xe5, 0x8f, 0x0c, + 0x40, 0xe1, 0xa6, 0x0c, 0x00, 0xa4, 0x06, 0x42, 0x22, 0x00, 0xa7, 0x0c, + 0x40, 0xe1, 0xa1, 0x0c, 0x00, 0x42, 0x22, 0x00, 0xa2, 0x0c, 0x40, 0xe1, + 0x9a, 0x0c, 0x00, 0x42, 0x22, 0x00, 0x9b, 0x0c, 0x40, 0xe1, 0xac, 0x0c, + 0x00, 0x42, 0x22, 0x00, 0xad, 0x0c, 0x40, 0xe1, 0x86, 0x0c, 0x00, 0xe9, + 0x90, 0x0c, 0x00, 0xf5, 0x94, 0x0c, 0x40, 0x45, 0x7e, 0x0b, 0xee, 0x0c, + 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xef, 0x0c, 0x00, 0x43, 0x7a, 0x0b, + 0xe7, 0x0c, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xe6, 0x0c, + 0x40, 0x44, 0x25, 0x01, 0xe9, 0x0c, 0x00, 0x42, 0x15, 0x02, 0xe8, 0x0c, + 0x40, 0x44, 0x06, 0x1f, 0xed, 0x0c, 0x00, 0x42, 0x09, 0x24, 0xec, 0x0c, + 0x40, 0x43, 0xf9, 0x05, 0xeb, 0x0c, 0x00, 0x43, 0xf6, 0x06, 0xea, 0x0c, + 0x40, 0x4d, 0xf3, 0x87, 0xd6, 0x0c, 0x00, 0x4c, 0x2c, 0x99, 0xdc, 0x0c, + 0x40, 0x44, 0xf8, 0xf4, 0x98, 0xf9, 0x01, 0x0b, 0xa0, 0xaa, 0x01, 0xff, + 0xa1, 0x9b, 0x0b, 0xa2, 0xab, 0x0a, 0xa3, 0xd1, 0x09, 0xa4, 0xdf, 0x08, + 0xa5, 0x9e, 0x08, 0xa6, 0xc1, 0x07, 0xa7, 0x90, 0x07, 0xa8, 0xc1, 0x06, + 0xa9, 0xa9, 0x06, 0x02, 0x78, 0x1a, 0x9a, 0x06, 0x45, 0x05, 0xab, 0x11, + 0x2f, 0x00, 0xac, 0xca, 0x05, 0xad, 0xf9, 0x04, 0xae, 0xe3, 0x04, 0xaf, + 0xbe, 0x04, 0xb0, 0x9a, 0x04, 0xb2, 0xe1, 0x03, 0xb3, 0xdf, 0x01, 0xb4, + 0x76, 0x43, 0x45, 0x03, 0x64, 0x2f, 0x00, 0xb6, 0x62, 0xb7, 0x06, 0x46, + 0xce, 0xdd, 0xc8, 0x2f, 0x40, 0xa1, 0x45, 0xa5, 0x37, 0xa8, 0x29, 0x02, + 0x9e, 0x01, 0x1d, 0xaf, 0x0f, 0xb2, 0x01, 0xff, 0x42, 0x0c, 0x06, 0x13, + 0x2f, 0x00, 0x43, 0xd8, 0x02, 0xae, 0x2f, 0x40, 0x43, 0x47, 0x19, 0x25, + 0x2f, 0x00, 0x42, 0xbb, 0x00, 0x2f, 0x2f, 0x40, 0xe4, 0xb5, 0x2f, 0x00, + 0xe5, 0xa3, 0x2f, 0x40, 0x43, 0x89, 0x00, 0xc6, 0x2f, 0x00, 0x43, 0xaf, + 0x02, 0x69, 0x2f, 0x40, 0x44, 0xf0, 0xf4, 0x4e, 0x2f, 0x00, 0x42, 0x60, + 0x01, 0x91, 0x2f, 0x40, 0x42, 0xe1, 0x5d, 0xa1, 0x2f, 0x80, 0x06, 0x43, + 0x8b, 0x00, 0x54, 0x2f, 0x40, 0x4a, 0xb0, 0x6b, 0x8f, 0x2f, 0x40, 0x45, + 0x30, 0xea, 0x95, 0x2f, 0x00, 0x46, 0xca, 0xe2, 0xa5, 0x2f, 0x40, 0xa1, + 0x53, 0x42, 0x92, 0x01, 0x17, 0x2f, 0x00, 0xa9, 0x3f, 0xaf, 0x31, 0xb2, + 0x1d, 0x02, 0x42, 0x00, 0x0d, 0x42, 0x15, 0x02, 0x06, 0x2f, 0xc0, 0x00, + 0x46, 0x29, 0x0f, 0x36, 0x2f, 0x40, 0x43, 0xf4, 0x16, 0x31, 0x2f, 0x00, + 0x43, 0xbd, 0x01, 0xd4, 0x2f, 0x40, 0x43, 0x0e, 0x03, 0x71, 0x2f, 0x00, + 0x42, 0x27, 0x01, 0x4a, 0x2f, 0x00, 0x44, 0x84, 0xf6, 0xcd, 0x2f, 0x40, + 0x44, 0xc6, 0x6a, 0x86, 0x2f, 0x00, 0x43, 0x26, 0x0f, 0xd2, 0x2f, 0x40, + 0x43, 0x00, 0x0a, 0x8c, 0x2f, 0x00, 0x42, 0x68, 0x00, 0x61, 0x2f, 0x40, + 0x43, 0x3e, 0x01, 0x0f, 0x2f, 0x00, 0x42, 0x60, 0x07, 0xbc, 0x2f, 0x00, + 0x4c, 0x80, 0x84, 0xb1, 0x2f, 0x40, 0xa1, 0xec, 0x01, 0xa3, 0xdd, 0x01, + 0xa5, 0xc4, 0x01, 0xa8, 0x99, 0x01, 0xa9, 0x8a, 0x01, 0x43, 0x3b, 0x04, + 0x6a, 0x2f, 0x00, 0xac, 0x6e, 0x44, 0x5e, 0x07, 0x29, 0x2f, 0x00, 0x44, + 0x53, 0xa6, 0x39, 0x2f, 0x00, 0x44, 0xad, 0x0b, 0xb3, 0x2f, 0x00, 0xb0, + 0x3a, 0x45, 0xfe, 0x05, 0x45, 0x2f, 0x00, 0xb4, 0x0c, 0x42, 0x79, 0x08, + 0x47, 0x2f, 0x00, 0x44, 0xa4, 0x52, 0x62, 0x2f, 0x40, 0x43, 0x1a, 0x00, + 0x74, 0x2f, 0x00, 0xa5, 0x14, 0xaf, 0x01, 0xff, 0x42, 0xf1, 0x05, 0x6f, + 0x2f, 0x00, 0xf0, 0x4c, 0x2f, 0xc0, 0x00, 0x44, 0xc9, 0x31, 0x89, 0x2f, + 0x40, 0x42, 0x57, 0x00, 0x53, 0x2f, 0x00, 0xf0, 0x3b, 0x2f, 0x40, 0xa5, + 0x12, 0x44, 0x29, 0xc5, 0x70, 0x2f, 0x00, 0x43, 0xcd, 0x02, 0x14, 0x2f, + 0x00, 0x44, 0x5c, 0xf8, 0x2c, 0x2f, 0x40, 0x42, 0x17, 0x00, 0x6d, 0x2f, + 0x00, 0x43, 0x3a, 0x43, 0x94, 0x2f, 0x40, 0xa1, 0x06, 0x43, 0x2e, 0x1e, + 0x5a, 0x2f, 0x40, 0x42, 0xa4, 0x02, 0x03, 0x2f, 0x00, 0x42, 0x32, 0x00, + 0xaa, 0x2f, 0x40, 0x46, 0x90, 0xe0, 0x67, 0x2f, 0x00, 0x42, 0xe1, 0x5d, + 0x77, 0x2f, 0x40, 0xa5, 0x1a, 0xaf, 0x01, 0xff, 0x42, 0x1b, 0x05, 0x37, + 0x2f, 0x00, 0x04, 0x6c, 0xf8, 0x01, 0xff, 0x4a, 0xcc, 0xac, 0xab, 0x2f, + 0x00, 0x45, 0x4d, 0xa3, 0x33, 0x2f, 0x40, 0x42, 0x57, 0x0b, 0x7a, 0x2f, + 0x00, 0x42, 0x60, 0x07, 0x99, 0x2f, 0x40, 0x42, 0x13, 0x00, 0x19, 0x2f, + 0x00, 0x44, 0xc0, 0x7f, 0x04, 0x2f, 0x00, 0xe5, 0x92, 0x2f, 0x00, 0x42, + 0x24, 0x00, 0x83, 0x2f, 0x40, 0x45, 0x0a, 0xed, 0x20, 0x2f, 0x00, 0x44, + 0x76, 0x06, 0x42, 0x2f, 0x40, 0x4e, 0x0e, 0x7a, 0xbf, 0x2f, 0x00, 0x42, + 0xb8, 0x04, 0xc4, 0x2f, 0x00, 0xf9, 0x48, 0x2f, 0x40, 0xa1, 0x26, 0x42, + 0x05, 0x00, 0x9a, 0x2f, 0x00, 0xa9, 0x0c, 0x43, 0xa1, 0xce, 0x27, 0x2f, + 0x00, 0x42, 0x79, 0x08, 0x9b, 0x2f, 0x40, 0x42, 0x73, 0x02, 0x76, 0x2f, + 0x00, 0x4c, 0xaa, 0x32, 0x15, 0x2f, 0x00, 0x43, 0x32, 0x00, 0x2e, 0x2f, + 0x40, 0x42, 0x9e, 0x01, 0xac, 0x2f, 0x00, 0xf0, 0x41, 0x2f, 0x00, 0xf4, + 0xcf, 0x2f, 0x40, 0x42, 0x3f, 0x00, 0x97, 0x2f, 0x00, 0x43, 0x13, 0x01, + 0x7e, 0x2f, 0x00, 0x44, 0x14, 0x01, 0x12, 0x2f, 0x00, 0xb2, 0x01, 0xff, + 0x45, 0x5c, 0xdc, 0x1b, 0x2f, 0x00, 0x46, 0xaa, 0xe4, 0x5e, 0x2f, 0x40, + 0x42, 0x04, 0x1c, 0x7c, 0x2f, 0x00, 0x42, 0xf1, 0x05, 0x00, 0x2f, 0x80, + 0x0f, 0xb0, 0x01, 0xff, 0x46, 0xb0, 0x32, 0x10, 0x2f, 0x00, 0x44, 0x2b, + 0x8e, 0x87, 0x2f, 0x40, 0x44, 0x94, 0xf8, 0x30, 0x2f, 0x40, 0x42, 0x14, + 0x06, 0x79, 0x2f, 0x00, 0xaf, 0x01, 0xff, 0x42, 0x46, 0x03, 0xd0, 0x2f, + 0x00, 0xf4, 0x46, 0x2f, 0x40, 0x42, 0x1a, 0x00, 0x08, 0x2f, 0x00, 0xa5, + 0x3a, 0xa9, 0x2c, 0xaf, 0x01, 0xff, 0x42, 0x10, 0x00, 0x49, 0x2f, 0x00, + 0xb2, 0x15, 0xb5, 0x01, 0xff, 0xae, 0x06, 0x42, 0x53, 0x00, 0x1d, 0x2f, + 0x40, 0xe4, 0xa9, 0x2f, 0x00, 0x44, 0x55, 0x07, 0x2d, 0x2f, 0x40, 0x44, + 0x58, 0x07, 0xa0, 0x2f, 0x00, 0x43, 0x00, 0x14, 0x85, 0x2f, 0x40, 0x44, + 0xd7, 0x22, 0xc9, 0x2f, 0x00, 0x46, 0x4a, 0xe4, 0x82, 0x2f, 0x40, 0x42, + 0x8a, 0x00, 0x81, 0x2f, 0x00, 0x43, 0xd7, 0x02, 0x60, 0x2f, 0x40, 0xa1, + 0x39, 0xa5, 0x1f, 0xa9, 0x0d, 0x43, 0xd8, 0x02, 0xa7, 0x2f, 0xc0, 0x00, + 0x47, 0x55, 0xd3, 0x35, 0x2f, 0x40, 0xe4, 0x07, 0x2f, 0x00, 0x42, 0x2e, + 0x1b, 0x63, 0x2f, 0x00, 0x42, 0xf1, 0x05, 0x01, 0x2f, 0x40, 0xa1, 0x0c, + 0x42, 0xdb, 0x19, 0xb2, 0x2f, 0x00, 0x42, 0x8a, 0x12, 0x09, 0x2f, 0x40, + 0xe6, 0xb4, 0x2f, 0x00, 0x44, 0x31, 0x1b, 0xb0, 0x2f, 0x40, 0x42, 0x36, + 0x01, 0x4b, 0x2f, 0x00, 0x42, 0x2a, 0x02, 0x2a, 0x2f, 0x40, 0x42, 0x04, + 0x00, 0x5f, 0x2f, 0x00, 0xf2, 0x78, 0x2f, 0x40, 0x42, 0x73, 0x02, 0x0e, + 0x2f, 0x00, 0xae, 0x01, 0xff, 0x42, 0x3b, 0x15, 0x28, 0x2f, 0x00, 0x44, + 0xe7, 0x05, 0x8d, 0x2f, 0x40, 0xa1, 0x30, 0xa5, 0x1c, 0x4f, 0x8e, 0x71, + 0x16, 0x2f, 0x00, 0xaf, 0x01, 0xff, 0x42, 0x55, 0x05, 0x05, 0x2f, 0x00, + 0xb2, 0x01, 0xff, 0xee, 0x93, 0x2f, 0x00, 0x42, 0x46, 0x03, 0xba, 0x2f, + 0x40, 0xa1, 0x06, 0x42, 0x14, 0x1d, 0xc7, 0x2f, 0x40, 0xe4, 0xb8, 0x2f, + 0x00, 0x42, 0x34, 0x00, 0x3c, 0x2f, 0x40, 0x42, 0x46, 0x00, 0xbd, 0x2f, + 0x00, 0xac, 0x06, 0x42, 0x1b, 0x00, 0x3f, 0x2f, 0x40, 0x44, 0x1c, 0xf5, + 0x3d, 0x2f, 0x00, 0x4c, 0x30, 0x79, 0x59, 0x2f, 0x40, 0x43, 0x8a, 0x00, + 0xa8, 0x2f, 0x00, 0x44, 0x9b, 0x80, 0xc1, 0x2f, 0x00, 0xef, 0x21, 0x2f, + 0x80, 0x11, 0x02, 0x71, 0x00, 0x01, 0xff, 0x42, 0x9e, 0x01, 0x72, 0x2f, + 0x00, 0x42, 0xee, 0x00, 0x8b, 0x2f, 0x40, 0x47, 0x4e, 0xd3, 0x22, 0x2f, + 0x00, 0x42, 0x04, 0x1c, 0xa6, 0x2f, 0x40, 0xa1, 0x46, 0x46, 0x2f, 0x1b, + 0x7b, 0x2f, 0x00, 0xa9, 0x26, 0xac, 0x1a, 0x43, 0x9f, 0x6c, 0x9c, 0x2f, + 0x00, 0xb2, 0x06, 0x42, 0x42, 0x00, 0x51, 0x2f, 0x40, 0x46, 0x82, 0xdf, + 0xb9, 0x2f, 0x00, 0x42, 0xc7, 0x19, 0xcc, 0x2f, 0x40, 0x43, 0x1e, 0x3b, + 0xd5, 0x2f, 0x00, 0xf9, 0xb6, 0x2f, 0x40, 0x43, 0x57, 0x25, 0x65, 0x2f, + 0x00, 0x43, 0xca, 0x00, 0xbe, 0x2f, 0x00, 0x42, 0x88, 0x00, 0x55, 0x2f, + 0x00, 0x42, 0xa4, 0x02, 0xc2, 0x2f, 0x40, 0x42, 0x73, 0x02, 0xaf, 0x2f, + 0x00, 0x42, 0x1d, 0x01, 0x5b, 0x2f, 0x00, 0x44, 0x31, 0x1b, 0x57, 0x2f, + 0x40, 0xa1, 0x2d, 0x44, 0xc9, 0x00, 0x0b, 0x2f, 0x00, 0x49, 0xb5, 0xc1, + 0xcb, 0x2f, 0x00, 0xae, 0x13, 0x43, 0x07, 0x1f, 0xd1, 0x2f, 0x80, 0x06, + 0x42, 0x4d, 0x00, 0x6c, 0x2f, 0x40, 0x43, 0xa1, 0x01, 0x23, 0x2f, 0x40, + 0x47, 0xb3, 0x6b, 0x1e, 0x2f, 0x00, 0x43, 0x8b, 0x00, 0x0a, 0x2f, 0x40, + 0xf2, 0x7f, 0x2f, 0x80, 0x04, 0xf4, 0xb7, 0x2f, 0x40, 0x42, 0x53, 0x00, + 0x1f, 0x2f, 0x40, 0xa5, 0x61, 0xa9, 0x47, 0xaf, 0x13, 0xb2, 0x01, 0xff, + 0x44, 0x53, 0x27, 0xd3, 0x2f, 0x00, 0x42, 0x48, 0x04, 0xce, 0x2f, 0x00, + 0xf9, 0x32, 0x2f, 0x40, 0x44, 0xb2, 0x1e, 0x4f, 0x2f, 0x00, 0xe7, 0x5d, + 0x2f, 0x00, 0x42, 0x0c, 0x00, 0x3e, 0x2f, 0x00, 0xf4, 0x02, 0x2f, 0x80, + 0x0c, 0x46, 0xd8, 0xe6, 0x58, 0x2f, 0x00, 0x46, 0x44, 0xe7, 0x0c, 0x2f, + 0x40, 0x04, 0x77, 0x00, 0x01, 0xff, 0x45, 0x4d, 0xeb, 0x34, 0x2f, 0x00, + 0x44, 0x51, 0x64, 0x68, 0x2f, 0x40, 0x44, 0x6e, 0x02, 0x43, 0x2f, 0x00, + 0xb3, 0x06, 0x48, 0x96, 0xc0, 0x18, 0x2f, 0x40, 0xe8, 0x6b, 0x2f, 0x00, + 0x48, 0xac, 0xaa, 0xa4, 0x2f, 0x40, 0x43, 0x23, 0x10, 0x4d, 0x2f, 0x00, + 0x42, 0x33, 0x00, 0xc5, 0x2f, 0x40, 0xa1, 0x43, 0x44, 0x72, 0x4c, 0x26, + 0x2f, 0x00, 0x43, 0x26, 0x29, 0xa2, 0x2f, 0x00, 0xac, 0x1f, 0xaf, 0x01, + 0xff, 0x43, 0xab, 0x08, 0x8a, 0x2f, 0x00, 0x45, 0xb3, 0xee, 0x50, 0x2f, + 0x00, 0x44, 0x60, 0xf8, 0x2b, 0x2f, 0x00, 0x43, 0x32, 0x00, 0x0d, 0x2f, + 0x00, 0xf7, 0x5c, 0x2f, 0x40, 0xa1, 0x0c, 0x43, 0x8d, 0x4a, 0x1a, 0x2f, + 0x00, 0x45, 0xc1, 0x8c, 0x90, 0x2f, 0x40, 0xee, 0x52, 0x2f, 0x00, 0xf7, + 0x56, 0x2f, 0x40, 0x42, 0x34, 0x00, 0x9e, 0x2f, 0x00, 0x46, 0xfa, 0xd4, + 0xc0, 0x2f, 0x00, 0x42, 0x32, 0x00, 0x73, 0x2f, 0x40, 0xa1, 0x5f, 0x43, + 0x50, 0x20, 0x96, 0x2f, 0x00, 0xa9, 0x47, 0xac, 0x33, 0xaf, 0x15, 0xb2, + 0x01, 0xff, 0x44, 0x1a, 0x27, 0x40, 0x2f, 0x00, 0x45, 0x8c, 0xed, 0x3a, + 0x2f, 0x00, 0x43, 0x0b, 0x80, 0x80, 0x2f, 0x40, 0x42, 0x8a, 0x00, 0x88, + 0x2f, 0x00, 0x42, 0xda, 0x0d, 0x9d, 0x2f, 0x00, 0x4b, 0x23, 0xa4, 0x66, + 0x2f, 0x00, 0x42, 0xf1, 0x05, 0xbb, 0x2f, 0x00, 0xf7, 0x38, 0x2f, 0x40, + 0x43, 0x0e, 0x03, 0xca, 0x2f, 0x00, 0x43, 0x3b, 0x2f, 0x8e, 0x2f, 0x00, + 0x42, 0x5c, 0x0a, 0xad, 0x2f, 0x40, 0xe7, 0x24, 0x2f, 0x00, 0x42, 0xab, + 0x01, 0xc3, 0x2f, 0x00, 0x44, 0x15, 0x06, 0x9f, 0x2f, 0x40, 0x44, 0x6c, + 0xf5, 0x98, 0x2f, 0x00, 0x44, 0xad, 0x9d, 0x75, 0x2f, 0x40, 0x44, 0x97, + 0x4d, 0x1c, 0x2f, 0x00, 0x42, 0x1b, 0x00, 0x7d, 0x2f, 0x00, 0x02, 0xcf, + 0x00, 0x06, 0x42, 0x90, 0x45, 0x44, 0x2f, 0x40, 0x43, 0xf9, 0x05, 0x84, + 0x2f, 0x00, 0x42, 0xd1, 0x00, 0x6e, 0x2f, 0x40, 0xa5, 0x75, 0xa6, 0x58, + 0x44, 0x6d, 0x2c, 0xc9, 0xd2, 0x81, 0x4b, 0x43, 0x7a, 0x0b, 0xc1, 0xd2, + 0x01, 0xb3, 0x29, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xc0, 0xd2, 0x41, 0x42, + 0x92, 0x01, 0xca, 0xd2, 0x01, 0xa8, 0x0d, 0xb7, 0x01, 0xff, 0x44, 0x85, + 0x2d, 0xcc, 0xd2, 0x01, 0xef, 0xc2, 0xd2, 0x41, 0x46, 0x17, 0x5d, 0xcd, + 0xd2, 0x01, 0x43, 0x26, 0x01, 0xc3, 0xd2, 0x41, 0x44, 0x06, 0x1f, 0xc7, + 0xd2, 0x81, 0x0d, 0x42, 0x09, 0x24, 0xc6, 0xd2, 0xc1, 0x00, 0x44, 0x10, + 0x19, 0xd0, 0xd2, 0x41, 0x44, 0x10, 0x19, 0xd1, 0xd2, 0x41, 0x44, 0x10, + 0x19, 0xd3, 0xd2, 0x41, 0xa9, 0x0d, 0x43, 0xf6, 0x06, 0xc4, 0xd2, 0xc1, + 0x00, 0x44, 0x10, 0x19, 0xce, 0xd2, 0x41, 0x45, 0x0f, 0x19, 0xcf, 0xd2, + 0x01, 0x42, 0x32, 0x00, 0xc5, 0xd2, 0x41, 0x44, 0xc9, 0x00, 0xc8, 0xd2, + 0x81, 0x06, 0x45, 0xe7, 0x72, 0xcb, 0xd2, 0x41, 0x43, 0xe9, 0x09, 0xd2, + 0xd2, 0x41, 0x51, 0x5d, 0x5a, 0xbb, 0x10, 0x01, 0xa4, 0x80, 0x03, 0x50, + 0xba, 0x65, 0xbc, 0x10, 0x01, 0x07, 0x13, 0x06, 0x70, 0x4b, 0x6d, 0xa5, + 0xbd, 0x10, 0x81, 0x63, 0xb3, 0x33, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xa1, + 0x20, 0xe5, 0xb5, 0x10, 0x01, 0xe9, 0xb1, 0x10, 0x81, 0x13, 0xef, 0xb7, + 0x10, 0x01, 0xf5, 0xb3, 0x10, 0x81, 0x06, 0x49, 0xf2, 0xc6, 0xc2, 0x10, + 0x41, 0xf5, 0xb4, 0x10, 0x41, 0xe9, 0xb2, 0x10, 0x41, 0xe1, 0xb0, 0x10, + 0x01, 0xe9, 0xb6, 0x10, 0x01, 0xf5, 0xb8, 0x10, 0x41, 0x4b, 0x67, 0x28, + 0xbe, 0x10, 0x01, 0x04, 0x5b, 0x03, 0x01, 0xff, 0x48, 0x0a, 0x17, 0x81, + 0x10, 0x01, 0x4b, 0x13, 0x25, 0x80, 0x10, 0x01, 0x45, 0x62, 0x41, 0xba, + 0x10, 0x01, 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0x21, 0x25, 0xb9, 0x10, + 0x01, 0x45, 0x49, 0x4e, 0x82, 0x10, 0x41, 0x46, 0x5b, 0x00, 0xcd, 0x10, + 0x41, 0xe1, 0x83, 0x10, 0x81, 0xf4, 0x01, 0xa2, 0xe7, 0x01, 0xa3, 0xda, + 0x01, 0xa4, 0xbb, 0x01, 0xe5, 0x89, 0x10, 0x01, 0xa7, 0xaa, 0x01, 0x42, + 0x22, 0x00, 0xaf, 0x10, 0x01, 0xe9, 0x85, 0x10, 0x81, 0x9a, 0x01, 0xaa, + 0x8d, 0x01, 0xab, 0x80, 0x01, 0x42, 0x74, 0x00, 0xaa, 0x10, 0x01, 0x42, + 0x6c, 0x00, 0xa7, 0x10, 0x01, 0xae, 0x5c, 0xef, 0x8b, 0x10, 0x01, 0xb0, + 0x4c, 0xb2, 0x40, 0xb3, 0x2e, 0xb4, 0x15, 0xf5, 0x87, 0x10, 0x81, 0x0c, + 0x42, 0x61, 0x0b, 0xab, 0x10, 0x01, 0x42, 0xdf, 0x23, 0xa8, 0x10, 0x41, + 0xf5, 0x88, 0x10, 0x41, 0xe1, 0x9e, 0x10, 0x01, 0x42, 0x22, 0x00, 0x9f, + 0x10, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x97, 0x10, 0x01, 0x42, 0x22, 0x00, + 0x98, 0x10, 0x41, 0xe1, 0xae, 0x10, 0x01, 0x42, 0x22, 0x00, 0xac, 0x10, + 0x01, 0x42, 0x40, 0x06, 0xad, 0x10, 0x41, 0xe1, 0xa9, 0x10, 0x01, 0x42, + 0x22, 0x00, 0x9c, 0x10, 0x41, 0xe1, 0xa3, 0x10, 0x01, 0x42, 0x22, 0x00, + 0xa4, 0x10, 0x41, 0xe1, 0xa2, 0x10, 0x01, 0x42, 0x24, 0x02, 0x91, 0x10, + 0x01, 0x42, 0x2a, 0x05, 0x9d, 0x10, 0x01, 0x42, 0xdf, 0x23, 0x96, 0x10, + 0x41, 0xe1, 0x8d, 0x10, 0x01, 0x42, 0x22, 0x00, 0x8e, 0x10, 0x41, 0xe1, + 0x94, 0x10, 0x01, 0x42, 0x22, 0x00, 0x95, 0x10, 0x41, 0xe9, 0x86, 0x10, + 0x41, 0xe1, 0x8f, 0x10, 0x01, 0x42, 0x22, 0x00, 0x90, 0x10, 0x41, 0xe1, + 0xa0, 0x10, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0xa1, 0x10, 0x41, 0xe1, + 0x99, 0x10, 0x01, 0x43, 0x44, 0x4e, 0x9a, 0x10, 0x01, 0x42, 0x22, 0x00, + 0x9b, 0x10, 0x41, 0xe1, 0x92, 0x10, 0x01, 0x42, 0x22, 0x00, 0x93, 0x10, + 0x41, 0xe1, 0xa5, 0x10, 0x01, 0x42, 0x22, 0x00, 0xa6, 0x10, 0x41, 0xe1, + 0x84, 0x10, 0x01, 0xe9, 0x8a, 0x10, 0x01, 0xf5, 0x8c, 0x10, 0x41, 0x44, + 0x96, 0x21, 0xc0, 0x10, 0x01, 0x06, 0x3c, 0x01, 0x01, 0xff, 0x45, 0x13, + 0x9b, 0xc1, 0x10, 0x01, 0x4c, 0x66, 0x28, 0xbf, 0x10, 0x41, 0xa1, 0xa4, + 0x02, 0xa5, 0x95, 0x02, 0x52, 0x01, 0x55, 0xe9, 0xf9, 0x01, 0xaf, 0x80, + 0x02, 0xb5, 0x01, 0xff, 0x46, 0xe6, 0xe1, 0x39, 0xf9, 0x01, 0x42, 0xb4, + 0x01, 0xb5, 0x26, 0x00, 0x45, 0x65, 0xb4, 0x43, 0x26, 0x00, 0x06, 0x76, + 0xe5, 0x01, 0xff, 0x4a, 0x41, 0x84, 0x05, 0xd8, 0x00, 0x08, 0xdf, 0xcf, + 0x01, 0xff, 0x90, 0xb4, 0x01, 0x91, 0x89, 0x01, 0x92, 0x5f, 0x93, 0x35, + 0x94, 0x0b, 0x95, 0x01, 0xff, 0xd0, 0xd1, 0x91, 0x01, 0xd1, 0xd2, 0x91, + 0x41, 0xd0, 0xc7, 0x91, 0x01, 0xd1, 0xc8, 0x91, 0x01, 0xd2, 0xc9, 0x91, + 0x01, 0xd3, 0xca, 0x91, 0x01, 0xd4, 0xcb, 0x91, 0x01, 0xd5, 0xcc, 0x91, + 0x01, 0xd6, 0xcd, 0x91, 0x01, 0xd7, 0xce, 0x91, 0x01, 0xd8, 0xcf, 0x91, + 0x01, 0xd9, 0xd0, 0x91, 0x41, 0xd0, 0xbd, 0x91, 0x01, 0xd1, 0xbe, 0x91, + 0x01, 0xd2, 0xbf, 0x91, 0x01, 0xd3, 0xc0, 0x91, 0x01, 0xd4, 0xc1, 0x91, + 0x01, 0xd5, 0xc2, 0x91, 0x01, 0xd6, 0xc3, 0x91, 0x01, 0xd7, 0xc4, 0x91, + 0x01, 0xd8, 0xc5, 0x91, 0x01, 0xd9, 0xc6, 0x91, 0x41, 0xd0, 0xb3, 0x91, + 0x01, 0xd1, 0xb4, 0x91, 0x01, 0xd2, 0xb5, 0x91, 0x01, 0xd3, 0xb6, 0x91, + 0x01, 0xd4, 0xb7, 0x91, 0x01, 0xd5, 0xb8, 0x91, 0x01, 0xd6, 0xb9, 0x91, + 0x01, 0xd7, 0xba, 0x91, 0x01, 0xd8, 0xbb, 0x91, 0x01, 0xd9, 0xbc, 0x91, + 0x41, 0xd0, 0xa9, 0x91, 0x01, 0xd1, 0xaa, 0x91, 0x01, 0xd2, 0xab, 0x91, + 0x01, 0xd3, 0xac, 0x91, 0x01, 0xd4, 0xad, 0x91, 0x01, 0xd5, 0xae, 0x91, + 0x01, 0xd6, 0xaf, 0x91, 0x01, 0xd7, 0xb0, 0x91, 0x01, 0xd8, 0xb1, 0x91, + 0x01, 0xd9, 0xb2, 0x91, 0x41, 0xd1, 0xa0, 0x91, 0x01, 0xd2, 0xa1, 0x91, + 0x01, 0xd3, 0xa2, 0x91, 0x01, 0xd4, 0xa3, 0x91, 0x01, 0xd5, 0xa4, 0x91, + 0x01, 0xd6, 0xa5, 0x91, 0x01, 0xd7, 0xa6, 0x91, 0x01, 0xd8, 0xa7, 0x91, + 0x01, 0xd9, 0xa8, 0x91, 0x41, 0x42, 0x9e, 0x01, 0x1d, 0x2a, 0x00, 0x46, + 0x86, 0xe7, 0x79, 0xf5, 0x41, 0x43, 0x79, 0x48, 0x56, 0xf4, 0x01, 0x47, + 0xd4, 0xd8, 0xbc, 0xfa, 0x41, 0x4c, 0x18, 0x92, 0x83, 0xf3, 0x01, 0x07, + 0x63, 0xda, 0x83, 0x05, 0xf2, 0xd9, 0xfa, 0x01, 0x07, 0x03, 0xdd, 0x01, + 0xff, 0x0f, 0x09, 0x35, 0xe3, 0x04, 0x06, 0xef, 0x06, 0x9c, 0x04, 0x02, + 0x68, 0x00, 0xdb, 0x01, 0x02, 0xe0, 0x09, 0x70, 0x4f, 0xd5, 0x75, 0xc2, + 0xa9, 0x00, 0x05, 0x5a, 0x03, 0x47, 0x53, 0x29, 0x50, 0xcd, 0xa9, 0x00, + 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0x4a, 0xb6, 0xae, 0xbb, 0xa9, 0x00, 0x45, + 0xd5, 0xef, 0xbc, 0xa9, 0x00, 0x44, 0xf9, 0xdb, 0xb8, 0xa9, 0x80, 0x23, + 0xb4, 0x0d, 0x44, 0x28, 0xf9, 0xb6, 0xa9, 0xc0, 0x00, 0x46, 0x20, 0xde, + 0xb7, 0xa9, 0x40, 0xa1, 0x06, 0x45, 0x1f, 0x13, 0xb5, 0xa9, 0x40, 0x44, + 0x9b, 0x0b, 0xba, 0xa9, 0x00, 0x44, 0xb4, 0xf1, 0xb4, 0xa9, 0x40, 0x47, + 0x0f, 0xd3, 0xb9, 0xa9, 0x40, 0x45, 0x07, 0xeb, 0x81, 0xa9, 0x80, 0x12, + 0x45, 0x18, 0xee, 0x82, 0xa9, 0x00, 0x49, 0xb6, 0xc3, 0x80, 0xa9, 0x00, + 0x47, 0x73, 0xdd, 0x83, 0xa9, 0x40, 0x45, 0xe7, 0xe7, 0xb3, 0xa9, 0x40, + 0x03, 0x7b, 0x08, 0x11, 0x02, 0x1d, 0x01, 0x01, 0xff, 0x43, 0x45, 0x73, + 0xc0, 0xa9, 0x00, 0x47, 0x0b, 0xdb, 0xcf, 0xa9, 0x40, 0xa1, 0x3d, 0x49, + 0x68, 0xc0, 0xdf, 0xa9, 0x00, 0xac, 0x20, 0x45, 0x54, 0xee, 0xc4, 0xa9, + 0x00, 0xb0, 0x0c, 0x4d, 0xd7, 0x8d, 0xde, 0xa9, 0x00, 0x45, 0x3c, 0xf2, + 0xc6, 0xa9, 0x40, 0x46, 0xa6, 0xdf, 0xc7, 0xa9, 0x00, 0x46, 0x36, 0x50, + 0xcc, 0xa9, 0x40, 0x45, 0x6e, 0xed, 0xc8, 0xa9, 0x00, 0xb5, 0x01, 0xff, + 0x43, 0x41, 0x00, 0xc5, 0xa9, 0x00, 0x44, 0x4b, 0x76, 0xc9, 0xa9, 0x40, + 0x43, 0x53, 0x12, 0xca, 0xa9, 0x80, 0x06, 0x44, 0x5c, 0xf7, 0xc3, 0xa9, + 0x40, 0x45, 0x2f, 0xbb, 0xcb, 0xa9, 0x40, 0x4c, 0xc8, 0x93, 0xc1, 0xa9, + 0x00, 0x05, 0x15, 0x06, 0x01, 0xff, 0xe1, 0x84, 0xa9, 0x80, 0xa7, 0x02, 0x42, 0x16, 0x00, 0xa7, 0xa9, 0x80, 0x99, 0x02, 0x42, 0x37, 0x00, 0x95, 0xa9, 0x80, 0x8b, 0x02, 0xa4, 0xf0, 0x01, 0xe5, 0x8c, 0xa9, 0x00, 0x42, 0x24, 0x02, 0x92, 0xa9, 0x80, 0xde, 0x01, 0x42, 0x22, 0x00, 0xb2, 0xa9, - 0x00, 0xe9, 0x86, 0xa9, 0x80, 0xc8, 0x01, 0x42, 0x72, 0x19, 0x97, 0xa9, + 0x00, 0xe9, 0x86, 0xa9, 0x80, 0xc8, 0x01, 0x42, 0x78, 0x1a, 0x97, 0xa9, 0x80, 0xba, 0x01, 0x42, 0x1b, 0x02, 0x8f, 0xa9, 0x80, 0xa3, 0x01, 0x42, 0x74, 0x00, 0xad, 0xa9, 0x00, 0x42, 0x6c, 0x00, 0xa9, 0xa9, 0x00, 0xae, - 0x69, 0xef, 0x8e, 0xa9, 0x00, 0x42, 0xbb, 0x09, 0xa5, 0xa9, 0x80, 0x4f, + 0x69, 0xef, 0x8e, 0xa9, 0x00, 0x42, 0xe0, 0x09, 0xa5, 0xa9, 0x80, 0x4f, 0x42, 0x71, 0x00, 0xab, 0xa9, 0x80, 0x42, 0x42, 0x40, 0x06, 0xb1, 0xa9, 0x80, 0x2a, 0xb4, 0x10, 0xf5, 0x88, 0xa9, 0x00, 0x42, 0xa9, 0x01, 0xae, - 0xa9, 0x00, 0x42, 0xbe, 0x22, 0xaa, 0xa9, 0x40, 0xe1, 0xa0, 0xa9, 0x80, - 0x0d, 0x42, 0x12, 0x00, 0x9b, 0xa9, 0xc0, 0x00, 0x4a, 0x65, 0x70, 0x9c, - 0xa9, 0x40, 0x46, 0x56, 0xd8, 0xa1, 0xa9, 0x40, 0x02, 0x6b, 0x00, 0x01, - 0xff, 0x48, 0x67, 0x70, 0xb0, 0xa9, 0x00, 0x44, 0x61, 0x70, 0xaf, 0xa9, - 0x40, 0x46, 0x1a, 0xd8, 0xac, 0xa9, 0x40, 0x80, 0x01, 0xff, 0x45, 0x3a, - 0xe5, 0x89, 0xa9, 0x00, 0x45, 0x60, 0x70, 0xa6, 0xa9, 0x40, 0xe1, 0xa4, - 0xa9, 0x80, 0x21, 0x42, 0x24, 0x02, 0x94, 0xa9, 0x80, 0x0d, 0x42, 0xbe, - 0x22, 0x9a, 0xa9, 0xc0, 0x00, 0x46, 0x56, 0xd8, 0x98, 0xa9, 0x40, 0x46, - 0x44, 0xd8, 0x8a, 0xa9, 0xc0, 0x00, 0x48, 0x99, 0xc2, 0x8b, 0xa9, 0x40, - 0x46, 0x56, 0xd8, 0x9f, 0xa9, 0x40, 0x80, 0x01, 0xff, 0x45, 0x60, 0x70, - 0x91, 0xa9, 0x00, 0x45, 0x35, 0xa3, 0x90, 0xa9, 0x40, 0x4a, 0x65, 0x70, - 0x99, 0xa9, 0x40, 0x45, 0xed, 0xe1, 0x85, 0xa9, 0x00, 0xe9, 0x87, 0xa9, - 0x40, 0x46, 0x56, 0xd8, 0x93, 0xa9, 0x40, 0xe1, 0xa2, 0xa9, 0x80, 0x0d, - 0x42, 0xf0, 0x10, 0x9d, 0xa9, 0xc0, 0x00, 0x4a, 0x65, 0x70, 0x9e, 0xa9, - 0x40, 0x4a, 0x65, 0x70, 0xa3, 0xa9, 0x40, 0x46, 0x56, 0xd8, 0x96, 0xa9, - 0x40, 0x46, 0x56, 0xd8, 0xa8, 0xa9, 0x40, 0xe9, 0x8d, 0xa9, 0x40, 0x45, - 0x12, 0x0b, 0xd8, 0xa9, 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0xd9, 0xa9, - 0x00, 0x43, 0x0e, 0x0b, 0xd1, 0xa9, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, - 0x5f, 0x1e, 0xd0, 0xa9, 0x40, 0x44, 0x25, 0x01, 0xd3, 0xa9, 0x00, 0x42, - 0x15, 0x02, 0xd2, 0xa9, 0x40, 0x44, 0xe5, 0x1d, 0xd7, 0xa9, 0x00, 0x42, - 0x1c, 0x26, 0xd6, 0xa9, 0x40, 0x43, 0xd2, 0x05, 0xd5, 0xa9, 0x00, 0x43, - 0xf6, 0x06, 0xd4, 0xa9, 0x40, 0x45, 0x0d, 0xe5, 0xbf, 0xa9, 0x00, 0x45, - 0xec, 0xe7, 0xbd, 0xa9, 0x00, 0x47, 0xcb, 0xd4, 0xbe, 0xa9, 0x40, 0x4b, - 0x9a, 0x99, 0xfb, 0x26, 0x00, 0x46, 0x7e, 0xda, 0xef, 0xf3, 0x01, 0x45, - 0xa2, 0xba, 0x8e, 0xf3, 0x01, 0x46, 0x40, 0xdc, 0x7a, 0xf4, 0x01, 0x5a, - 0x68, 0x20, 0x04, 0x30, 0x00, 0x44, 0x89, 0xd5, 0x79, 0xf4, 0x01, 0x4b, - 0x8d, 0xa1, 0xe3, 0xf3, 0x01, 0x53, 0x61, 0x4d, 0x30, 0xf5, 0x41, 0x53, - 0xaa, 0x47, 0x1f, 0xf9, 0x01, 0x03, 0x0e, 0x08, 0xe8, 0x14, 0x02, 0x04, - 0x00, 0xc7, 0x0d, 0xad, 0xd8, 0x0b, 0xae, 0x14, 0xb2, 0x06, 0x4e, 0x24, - 0x7f, 0xee, 0xf3, 0x41, 0x43, 0x23, 0x24, 0xc7, 0xce, 0x01, 0x42, 0x5f, - 0x03, 0xc1, 0xce, 0x41, 0x48, 0x71, 0xc4, 0xe5, 0xf4, 0x01, 0xa3, 0x8e, - 0x0b, 0xe4, 0x84, 0x00, 0x80, 0xf5, 0x06, 0xa6, 0xb2, 0x06, 0x06, 0xa0, - 0xdc, 0xa1, 0x06, 0x0f, 0x04, 0x72, 0xfa, 0x05, 0xb3, 0xdb, 0x02, 0x02, - 0x77, 0x00, 0x9a, 0x01, 0xb6, 0x01, 0xff, 0x02, 0x33, 0x00, 0x17, 0x07, - 0x24, 0xd2, 0x01, 0xff, 0x44, 0x73, 0x28, 0x64, 0x20, 0x00, 0x49, 0xda, - 0x20, 0x63, 0x20, 0x00, 0x45, 0x28, 0x02, 0x62, 0x20, 0x40, 0x03, 0x41, - 0x04, 0x3e, 0x04, 0x77, 0x00, 0x01, 0xff, 0x50, 0xad, 0x00, 0xa1, 0x00, - 0x00, 0x4b, 0x1f, 0x16, 0x18, 0x2e, 0x00, 0xac, 0x18, 0x48, 0x39, 0xc9, - 0x27, 0x21, 0x00, 0x49, 0xb3, 0x1b, 0xe7, 0x26, 0x00, 0x4d, 0xc1, 0x34, - 0xbf, 0x00, 0x00, 0x48, 0x31, 0xcc, 0x54, 0x20, 0x40, 0x45, 0xe4, 0x6e, - 0x3e, 0x22, 0x00, 0x49, 0xe3, 0xbd, 0x45, 0x2e, 0xc0, 0x00, 0x52, 0xee, - 0x4f, 0x46, 0x2e, 0x40, 0xa2, 0x22, 0x05, 0x6d, 0x14, 0x12, 0x62, 0x34, - 0x0c, 0xb4, 0xfb, 0x01, 0x4c, 0x44, 0x04, 0x90, 0xfb, 0x01, 0x4c, 0x32, - 0x11, 0xd9, 0x25, 0x40, 0x45, 0xb8, 0x00, 0xb1, 0xfb, 0x01, 0x4d, 0xb3, - 0x82, 0x96, 0xfb, 0x41, 0x05, 0x0d, 0x03, 0x06, 0x45, 0xb5, 0x21, 0xd8, - 0x25, 0x40, 0x47, 0x9c, 0x44, 0x8d, 0xcc, 0x01, 0x4c, 0x86, 0x0a, 0x8f, - 0xcc, 0x41, 0x44, 0xb3, 0x26, 0x2b, 0x22, 0x80, 0x6a, 0xb2, 0x01, 0xff, - 0x46, 0x78, 0xda, 0xba, 0x22, 0x00, 0x4b, 0xbe, 0x3b, 0x3c, 0x2a, 0x00, - 0xac, 0x3d, 0x46, 0x24, 0x16, 0x3d, 0x20, 0x00, 0x47, 0xae, 0x0a, 0x29, - 0x22, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x06, 0x5c, 0x00, 0x1d, 0x63, 0x92, - 0x0a, 0x4b, 0x2a, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x43, 0x23, 0x0a, - 0x40, 0x2a, 0x00, 0x4b, 0x4b, 0x30, 0x44, 0x2a, 0x00, 0x47, 0xfb, 0x7f, - 0x43, 0x2a, 0x40, 0x4f, 0x1a, 0x6b, 0x49, 0x2a, 0x00, 0x45, 0x4d, 0x17, - 0x47, 0x2a, 0x40, 0x11, 0x13, 0x5b, 0x06, 0x5a, 0x52, 0x21, 0xa4, 0x26, - 0x40, 0x46, 0xd0, 0xd9, 0xf9, 0xff, 0x00, 0x49, 0xda, 0x20, 0xfa, 0xff, - 0x00, 0x4a, 0x6b, 0x86, 0xfb, 0xff, 0x40, 0x80, 0x01, 0xff, 0xa1, 0x3a, - 0x49, 0xc8, 0x58, 0xae, 0x23, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4d, - 0x4b, 0x82, 0x0e, 0x2a, 0x00, 0x4c, 0xa9, 0x0a, 0x19, 0x2a, 0x00, 0x59, - 0xb3, 0x24, 0x17, 0x2a, 0x00, 0x47, 0xfb, 0x7f, 0x1b, 0x2a, 0x00, 0x4a, - 0x10, 0xb2, 0x18, 0x2a, 0x00, 0x02, 0x42, 0x0b, 0x01, 0xff, 0x46, 0xec, - 0x59, 0x1c, 0x2a, 0x00, 0x43, 0xb5, 0x00, 0x1a, 0x2a, 0x40, 0x56, 0x0a, - 0x37, 0x15, 0x2a, 0x00, 0x51, 0x42, 0x5f, 0x0f, 0x2a, 0x40, 0x0d, 0xaf, - 0x81, 0x06, 0x4d, 0xc0, 0x82, 0x80, 0x23, 0x40, 0x06, 0xe0, 0x75, 0xd3, - 0x01, 0x07, 0x9d, 0xd5, 0x01, 0xff, 0x07, 0xec, 0x05, 0x3d, 0x07, 0x1a, - 0x3a, 0x01, 0xff, 0x44, 0xf5, 0x06, 0x5b, 0x0b, 0x01, 0x43, 0x0e, 0x0b, - 0x58, 0x0b, 0x81, 0x1c, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x5c, 0x0b, - 0x01, 0x44, 0x25, 0x01, 0x5a, 0x0b, 0x01, 0xb7, 0x01, 0xff, 0x44, 0xe7, - 0x1d, 0x5d, 0x0b, 0x01, 0xef, 0x59, 0x0b, 0x41, 0x80, 0x01, 0xff, 0x47, - 0x71, 0x11, 0x5e, 0x0b, 0x01, 0x48, 0x47, 0x5e, 0x5f, 0x0b, 0x41, 0xa1, - 0x7f, 0x44, 0x61, 0xef, 0x41, 0x0b, 0x01, 0x46, 0x2a, 0x4a, 0x43, 0x0b, - 0x01, 0x45, 0xfe, 0xaa, 0x42, 0x0b, 0x01, 0x42, 0xb0, 0x01, 0x44, 0x0b, - 0x81, 0x60, 0x44, 0xed, 0xf0, 0x4a, 0x0b, 0x01, 0x46, 0xb4, 0xdd, 0x4b, - 0x0b, 0x01, 0x43, 0xb4, 0x05, 0x4c, 0x0b, 0x01, 0x43, 0xde, 0x22, 0x4d, - 0x0b, 0x01, 0x42, 0x6f, 0x02, 0x50, 0x0b, 0x01, 0x44, 0x6d, 0xc8, 0x52, - 0x0b, 0x01, 0x44, 0x7d, 0x66, 0x53, 0x0b, 0x01, 0xb3, 0x20, 0xb4, 0x12, - 0x43, 0x9f, 0x8a, 0x45, 0x0b, 0x01, 0x44, 0xa8, 0x52, 0x49, 0x0b, 0x01, - 0x45, 0xa2, 0x52, 0x46, 0x0b, 0x41, 0x42, 0xd2, 0x2d, 0x55, 0x0b, 0x01, - 0x43, 0xf5, 0x25, 0x48, 0x0b, 0x41, 0xa1, 0x06, 0x43, 0x7a, 0x16, 0x54, - 0x0b, 0x41, 0x43, 0xcd, 0xea, 0x51, 0x0b, 0x01, 0x44, 0x69, 0xe4, 0x4e, - 0x0b, 0x41, 0x42, 0x53, 0x00, 0x47, 0x0b, 0x41, 0x44, 0x33, 0x3d, 0x40, - 0x0b, 0x01, 0x43, 0x9a, 0x1a, 0x4f, 0x0b, 0x41, 0x07, 0xec, 0x05, 0x3d, - 0x07, 0x1a, 0x3a, 0x01, 0xff, 0x44, 0xf5, 0x06, 0x7b, 0x0b, 0x01, 0x43, - 0x0e, 0x0b, 0x78, 0x0b, 0x81, 0x1c, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, - 0x7c, 0x0b, 0x01, 0x44, 0x25, 0x01, 0x7a, 0x0b, 0x01, 0xb7, 0x01, 0xff, - 0x44, 0xe7, 0x1d, 0x7d, 0x0b, 0x01, 0xef, 0x79, 0x0b, 0x41, 0x80, 0x01, - 0xff, 0x47, 0x71, 0x11, 0x7e, 0x0b, 0x01, 0x48, 0x47, 0x5e, 0x7f, 0x0b, - 0x41, 0x45, 0xd3, 0xad, 0x60, 0x0b, 0x01, 0x44, 0x61, 0xef, 0x61, 0x0b, - 0x01, 0x46, 0x2a, 0x4a, 0x63, 0x0b, 0x01, 0x45, 0xfe, 0xaa, 0x62, 0x0b, - 0x01, 0x42, 0xb0, 0x01, 0x64, 0x0b, 0x81, 0x54, 0x44, 0xed, 0xf0, 0x6a, - 0x0b, 0x01, 0x46, 0xb4, 0xdd, 0x6b, 0x0b, 0x01, 0x48, 0x69, 0xc8, 0x6c, - 0x0b, 0x01, 0x43, 0xde, 0x22, 0x6d, 0x0b, 0x01, 0x42, 0x6f, 0x02, 0x6f, - 0x0b, 0x01, 0xb3, 0x20, 0xb4, 0x12, 0x4d, 0x9f, 0x8a, 0x65, 0x0b, 0x01, - 0x44, 0xa8, 0x52, 0x69, 0x0b, 0x01, 0x45, 0xa2, 0x52, 0x66, 0x0b, 0x41, - 0x42, 0xd2, 0x2d, 0x72, 0x0b, 0x01, 0x43, 0xf5, 0x25, 0x68, 0x0b, 0x41, - 0xa1, 0x06, 0x43, 0x7a, 0x16, 0x71, 0x0b, 0x41, 0x43, 0xcd, 0xea, 0x70, - 0x0b, 0x01, 0x44, 0x69, 0xe4, 0x6e, 0x0b, 0x41, 0x42, 0x53, 0x00, 0x67, - 0x0b, 0x41, 0x06, 0xde, 0x05, 0x0c, 0x47, 0xba, 0xd3, 0x22, 0xf5, 0x01, - 0x47, 0x16, 0x08, 0x23, 0xf5, 0x41, 0x4f, 0xa1, 0x6b, 0x20, 0xf5, 0x01, - 0x47, 0xa9, 0x6b, 0x24, 0xf5, 0x01, 0x4d, 0xf2, 0x88, 0x21, 0xf5, 0x41, - 0x53, 0x2f, 0x48, 0x6c, 0x20, 0x00, 0x52, 0xa0, 0x55, 0x6a, 0x20, 0x40, - 0x45, 0x9b, 0x6c, 0x1e, 0x22, 0x80, 0x33, 0x09, 0xbe, 0x5c, 0x01, 0xff, - 0x4b, 0x05, 0x9b, 0x81, 0xf4, 0x01, 0xb3, 0x01, 0xff, 0x09, 0xdb, 0x20, - 0x06, 0x45, 0xc8, 0x5c, 0x39, 0x21, 0x40, 0x44, 0xf5, 0x06, 0x1c, 0x00, - 0x00, 0x43, 0x0e, 0x0b, 0x1f, 0x00, 0x00, 0xb4, 0x01, 0xff, 0x44, 0x25, - 0x01, 0x1d, 0x00, 0x00, 0x42, 0x15, 0x02, 0x1e, 0x00, 0x40, 0x5a, 0xae, - 0x1e, 0xde, 0x29, 0x40, 0x42, 0xad, 0x00, 0x84, 0x00, 0x80, 0x85, 0x04, - 0xa9, 0x01, 0xff, 0x4d, 0x77, 0x80, 0xb9, 0x20, 0x00, 0x08, 0x89, 0xc4, - 0x01, 0xff, 0x53, 0xf6, 0x47, 0xb4, 0xec, 0x01, 0x09, 0x25, 0x5a, 0xd6, - 0x03, 0x49, 0x00, 0x48, 0xa0, 0xec, 0x01, 0x07, 0x1a, 0x3a, 0x0c, 0x4b, - 0xcd, 0x65, 0xac, 0xec, 0x01, 0x4a, 0xda, 0xb0, 0xb0, 0xec, 0x41, 0x0a, - 0xf1, 0x11, 0xa6, 0x03, 0x45, 0x12, 0x0b, 0x78, 0xec, 0x81, 0x85, 0x03, - 0xa6, 0xb7, 0x02, 0x45, 0xe2, 0xe7, 0xa1, 0xec, 0x81, 0xa9, 0x02, 0x44, - 0x00, 0x48, 0x9e, 0xec, 0x81, 0x9b, 0x02, 0x44, 0xea, 0x2a, 0x79, 0xec, - 0x81, 0xf8, 0x01, 0x43, 0x0e, 0x0b, 0x71, 0xec, 0x81, 0xe1, 0x01, 0x09, - 0x31, 0x4c, 0x9f, 0x01, 0xb3, 0x59, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, - 0x7a, 0xec, 0x81, 0x49, 0xa8, 0x24, 0xb7, 0x01, 0xff, 0x44, 0xe7, 0x1d, - 0x7b, 0xec, 0x81, 0x14, 0xef, 0x72, 0xec, 0xc1, 0x00, 0x80, 0x01, 0xff, - 0x47, 0x71, 0x11, 0x84, 0xec, 0x01, 0x48, 0x47, 0x5e, 0x8d, 0xec, 0x41, - 0x49, 0x46, 0x5e, 0x96, 0xec, 0x41, 0x44, 0x7b, 0x11, 0x7c, 0xec, 0x81, - 0x16, 0x43, 0x26, 0x01, 0x73, 0xec, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x47, - 0x71, 0x11, 0x85, 0xec, 0x01, 0x48, 0x47, 0x5e, 0x8e, 0xec, 0x41, 0x49, - 0x46, 0x5e, 0x97, 0xec, 0x41, 0x49, 0x46, 0x5e, 0x95, 0xec, 0x41, 0x44, - 0xe5, 0x1d, 0x77, 0xec, 0x81, 0x22, 0x42, 0x1c, 0x26, 0x76, 0xec, 0xc1, - 0x00, 0x80, 0x0d, 0x42, 0x7d, 0x11, 0x7f, 0xec, 0xc1, 0x00, 0x49, 0x46, - 0x5e, 0x9a, 0xec, 0x41, 0x47, 0x71, 0x11, 0x88, 0xec, 0x01, 0x48, 0x47, - 0x5e, 0x91, 0xec, 0x41, 0x80, 0x0d, 0x42, 0x7d, 0x11, 0x80, 0xec, 0xc1, - 0x00, 0x49, 0x46, 0x5e, 0x9b, 0xec, 0x41, 0x47, 0x71, 0x11, 0x89, 0xec, - 0x01, 0x48, 0x47, 0x5e, 0x92, 0xec, 0x41, 0x45, 0x12, 0x0b, 0xaa, 0xec, - 0x01, 0xa6, 0x29, 0x44, 0xea, 0x2a, 0xab, 0xec, 0x01, 0x43, 0x0e, 0x0b, - 0xa3, 0xec, 0x01, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0xa5, - 0xec, 0x01, 0x42, 0x15, 0x02, 0xa4, 0xec, 0x41, 0x44, 0xe5, 0x1d, 0xa9, - 0xec, 0x01, 0x42, 0x1c, 0x26, 0xa8, 0xec, 0x41, 0x43, 0xd2, 0x05, 0xa7, - 0xec, 0x01, 0x43, 0xf6, 0x06, 0xa6, 0xec, 0x41, 0x80, 0x01, 0xff, 0x47, - 0x71, 0x11, 0x83, 0xec, 0x01, 0x48, 0x47, 0x5e, 0x8c, 0xec, 0x41, 0x80, - 0x0d, 0x42, 0x7d, 0x11, 0x82, 0xec, 0xc1, 0x00, 0x49, 0x46, 0x5e, 0x9d, - 0xec, 0x41, 0x47, 0x71, 0x11, 0x8b, 0xec, 0x01, 0x48, 0x47, 0x5e, 0x94, - 0xec, 0x41, 0x42, 0x1a, 0x00, 0x9f, 0xec, 0x41, 0x42, 0x1a, 0x00, 0xa2, - 0xec, 0x41, 0xa9, 0x26, 0xaf, 0x01, 0xff, 0x43, 0x7c, 0x11, 0x7d, 0xec, - 0x81, 0x16, 0x42, 0x42, 0x00, 0x74, 0xec, 0xc1, 0x00, 0x80, 0x01, 0xff, - 0x47, 0x71, 0x11, 0x86, 0xec, 0x01, 0x48, 0x47, 0x5e, 0x8f, 0xec, 0x41, - 0x49, 0x46, 0x5e, 0x98, 0xec, 0x41, 0x43, 0x59, 0x4d, 0x7e, 0xec, 0x81, - 0x16, 0x42, 0x32, 0x00, 0x75, 0xec, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x47, - 0x71, 0x11, 0x87, 0xec, 0x01, 0x48, 0x47, 0x5e, 0x90, 0xec, 0x41, 0x49, - 0x46, 0x5e, 0x99, 0xec, 0x41, 0x80, 0x0b, 0xf9, 0x81, 0xec, 0xc1, 0x00, - 0x49, 0x46, 0x5e, 0x9c, 0xec, 0x41, 0x47, 0x71, 0x11, 0x8a, 0xec, 0x01, - 0x48, 0x47, 0x5e, 0x93, 0xec, 0x41, 0x43, 0x0e, 0x0b, 0xb1, 0xec, 0x01, - 0xb4, 0x01, 0xff, 0x4b, 0x44, 0x5e, 0xb3, 0xec, 0x01, 0x42, 0x15, 0x02, - 0xb2, 0xec, 0x41, 0x04, 0x0e, 0x0b, 0x06, 0x4e, 0x24, 0x01, 0xaf, 0xec, - 0x41, 0x44, 0x22, 0x00, 0xae, 0xec, 0x01, 0x47, 0x2a, 0x01, 0xad, 0xec, - 0x41, 0x57, 0xa7, 0x2c, 0xf5, 0xfa, 0x41, 0x02, 0x14, 0x05, 0x1b, 0x02, - 0x88, 0x00, 0x01, 0xff, 0x03, 0xb5, 0x35, 0x06, 0x44, 0x2c, 0x05, 0x06, - 0x22, 0x40, 0x51, 0xb7, 0x36, 0xda, 0xf5, 0x01, 0x44, 0xf7, 0x03, 0xe1, - 0x29, 0x40, 0x4c, 0x24, 0x90, 0xe8, 0xf4, 0x01, 0x4e, 0x42, 0x7b, 0xdc, - 0x29, 0x40, 0x46, 0x29, 0x43, 0xb7, 0x22, 0x80, 0xde, 0x01, 0xf0, 0x7f, - 0xf4, 0xc1, 0x00, 0x0e, 0x8a, 0x77, 0x01, 0xff, 0x07, 0xec, 0x05, 0x43, - 0x07, 0x1a, 0x3a, 0x06, 0x4c, 0x34, 0x95, 0x57, 0x08, 0x41, 0x43, 0x0e, - 0x0b, 0x58, 0x08, 0x81, 0x23, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x5b, - 0x08, 0x81, 0x13, 0x44, 0x25, 0x01, 0x5a, 0x08, 0x01, 0xb7, 0x01, 0xff, - 0x44, 0xe7, 0x1d, 0x5c, 0x08, 0x01, 0xef, 0x59, 0x08, 0x41, 0x49, 0x46, - 0x5e, 0x5f, 0x08, 0x41, 0x80, 0x01, 0xff, 0x47, 0x71, 0x11, 0x5d, 0x08, - 0x01, 0x48, 0x47, 0x5e, 0x5e, 0x08, 0x41, 0xa1, 0x7f, 0x44, 0x61, 0xef, - 0x41, 0x08, 0x01, 0x46, 0x2a, 0x4a, 0x43, 0x08, 0x01, 0x45, 0xfe, 0xaa, - 0x42, 0x08, 0x01, 0x42, 0xb0, 0x01, 0x44, 0x08, 0x81, 0x60, 0x44, 0xed, - 0xf0, 0x4a, 0x08, 0x01, 0x46, 0xb4, 0xdd, 0x4b, 0x08, 0x01, 0x43, 0xb4, - 0x05, 0x4c, 0x08, 0x01, 0x43, 0xde, 0x22, 0x4d, 0x08, 0x01, 0x42, 0x6f, - 0x02, 0x50, 0x08, 0x01, 0x44, 0x6d, 0xc8, 0x52, 0x08, 0x01, 0x44, 0x7d, - 0x66, 0x53, 0x08, 0x01, 0xb3, 0x20, 0xb4, 0x12, 0x43, 0x9f, 0x8a, 0x45, - 0x08, 0x01, 0x44, 0xa8, 0x52, 0x49, 0x08, 0x01, 0x45, 0xa2, 0x52, 0x46, - 0x08, 0x41, 0x42, 0xd2, 0x2d, 0x55, 0x08, 0x01, 0x43, 0xf5, 0x25, 0x48, - 0x08, 0x41, 0xa1, 0x06, 0x43, 0x7a, 0x16, 0x54, 0x08, 0x41, 0x43, 0xcd, - 0xea, 0x51, 0x08, 0x01, 0x44, 0x69, 0xe4, 0x4e, 0x08, 0x41, 0x42, 0x53, - 0x00, 0x47, 0x08, 0x41, 0x44, 0x33, 0x3d, 0x40, 0x08, 0x01, 0x43, 0x9a, - 0x1a, 0x4f, 0x08, 0x41, 0x5a, 0xc8, 0x1e, 0x53, 0x22, 0x40, 0x03, 0x9f, - 0x01, 0xfa, 0x06, 0x09, 0x51, 0x20, 0x01, 0xff, 0x0b, 0x19, 0x5b, 0x82, - 0x06, 0xa3, 0xf3, 0x05, 0x02, 0x04, 0x00, 0xdf, 0x04, 0x52, 0x44, 0x51, - 0x2d, 0x30, 0x00, 0x49, 0x81, 0x16, 0x02, 0x30, 0x00, 0x4f, 0xdb, 0x6d, - 0x3f, 0x30, 0x00, 0x4e, 0x5a, 0x20, 0x05, 0x30, 0x00, 0x4f, 0xac, 0x6f, - 0x2a, 0x30, 0x00, 0x4b, 0x6f, 0xa0, 0x07, 0x30, 0x00, 0x50, 0xcd, 0x66, - 0x2b, 0x30, 0x00, 0x45, 0xd7, 0x4c, 0x00, 0x30, 0x00, 0xb4, 0x06, 0x53, - 0x91, 0x4e, 0x3e, 0x30, 0x40, 0x0a, 0xd4, 0xa7, 0xff, 0x03, 0x09, 0x67, - 0xb8, 0x01, 0xff, 0x5a, 0xd0, 0x20, 0x37, 0x30, 0x00, 0x0b, 0x67, 0x32, - 0x01, 0xff, 0xa1, 0xe0, 0x03, 0xa4, 0xf3, 0x01, 0x48, 0x39, 0xc6, 0xc1, - 0x32, 0x00, 0x05, 0x4c, 0xd4, 0x37, 0xaa, 0x20, 0x02, 0x6c, 0x00, 0x12, - 0x48, 0x01, 0xc9, 0xca, 0x32, 0x00, 0x47, 0xcf, 0xd3, 0xc9, 0x32, 0x00, - 0x49, 0x4b, 0xbf, 0xc8, 0x32, 0x40, 0x43, 0xb9, 0x80, 0xc2, 0x32, 0x00, - 0xf9, 0xc4, 0x32, 0x40, 0x46, 0xe2, 0xd9, 0xc0, 0x32, 0x00, 0xb5, 0x01, - 0xff, 0x42, 0x75, 0x0b, 0xc6, 0x32, 0x00, 0x42, 0xcd, 0x05, 0xc5, 0x32, - 0x40, 0xa5, 0x9c, 0x01, 0xa6, 0x7f, 0x44, 0xea, 0x2a, 0x61, 0x33, 0x80, - 0x72, 0x43, 0x0e, 0x0b, 0x59, 0x33, 0x00, 0xb3, 0x50, 0xb4, 0x06, 0x44, - 0x5f, 0x1e, 0x58, 0x33, 0x40, 0x42, 0x92, 0x01, 0x62, 0x33, 0x00, 0xa8, - 0x34, 0xb7, 0x01, 0xff, 0xa5, 0x04, 0xef, 0x5a, 0x33, 0x40, 0x43, 0x03, - 0x2c, 0x64, 0x33, 0x00, 0x43, 0xe8, 0x1d, 0x6c, 0x33, 0xc0, 0x00, 0x8d, - 0x01, 0xff, 0x44, 0xf5, 0x06, 0x70, 0x33, 0x00, 0x43, 0x0e, 0x0b, 0x6d, - 0x33, 0x00, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0x6f, 0x33, 0x00, 0x42, - 0x15, 0x02, 0x6e, 0x33, 0x40, 0x46, 0x9d, 0x5a, 0x65, 0x33, 0x00, 0x43, - 0x26, 0x01, 0x5b, 0x33, 0x40, 0x44, 0xe5, 0x1d, 0x5f, 0x33, 0x80, 0x0d, - 0x42, 0x1c, 0x26, 0x5e, 0x33, 0xc0, 0x00, 0x44, 0x26, 0x18, 0x68, 0x33, - 0x40, 0x44, 0x26, 0x18, 0x69, 0x33, 0x40, 0x44, 0x26, 0x18, 0x6b, 0x33, - 0x40, 0xa9, 0x0d, 0x43, 0xf6, 0x06, 0x5c, 0x33, 0xc0, 0x00, 0x44, 0x26, - 0x18, 0x66, 0x33, 0x40, 0x45, 0x25, 0x18, 0x67, 0x33, 0x00, 0x42, 0x32, - 0x00, 0x5d, 0x33, 0x40, 0x44, 0xc9, 0x00, 0x60, 0x33, 0x80, 0x06, 0x45, - 0xbb, 0x6f, 0x63, 0x33, 0x40, 0x43, 0xc4, 0x09, 0x6a, 0x33, 0x40, 0x03, - 0x07, 0x20, 0x06, 0x47, 0xc6, 0xd0, 0xcb, 0x32, 0x40, 0xa5, 0xca, 0x01, - 0xa6, 0xac, 0x01, 0x44, 0xea, 0x2a, 0xe8, 0x33, 0x80, 0x9e, 0x01, 0x43, - 0x0e, 0x0b, 0xe0, 0x33, 0x00, 0xb3, 0x7c, 0xb4, 0x01, 0xff, 0x42, 0x92, - 0x01, 0xe9, 0x33, 0x00, 0xa8, 0x56, 0xb7, 0x01, 0xff, 0xa5, 0x04, 0xef, - 0xe1, 0x33, 0x40, 0x43, 0x03, 0x2c, 0xeb, 0x33, 0x00, 0x43, 0xe8, 0x1d, - 0xf3, 0x33, 0xc0, 0x00, 0x8d, 0x01, 0xff, 0x45, 0x12, 0x0b, 0xfb, 0x33, - 0x00, 0xa6, 0x29, 0x44, 0xea, 0x2a, 0xfc, 0x33, 0x00, 0x43, 0x0e, 0x0b, - 0xf4, 0x33, 0x00, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0xf6, - 0x33, 0x00, 0x42, 0x15, 0x02, 0xf5, 0x33, 0x40, 0x44, 0xe5, 0x1d, 0xfa, - 0x33, 0x00, 0x42, 0x1c, 0x26, 0xf9, 0x33, 0x40, 0x43, 0xd2, 0x05, 0xf8, - 0x33, 0x00, 0x43, 0xf6, 0x06, 0xf7, 0x33, 0x40, 0x03, 0x7b, 0x11, 0x06, - 0x43, 0x26, 0x01, 0xe2, 0x33, 0x40, 0x43, 0xc4, 0x09, 0xec, 0x33, 0x00, - 0xf9, 0xfd, 0x33, 0xc0, 0x00, 0x44, 0x49, 0xbd, 0xfe, 0x33, 0x40, 0x44, - 0xe5, 0x1d, 0xe6, 0x33, 0x80, 0x0d, 0x42, 0x1c, 0x26, 0xe5, 0x33, 0xc0, - 0x00, 0x44, 0x26, 0x18, 0xef, 0x33, 0x40, 0x44, 0x26, 0x18, 0xf0, 0x33, - 0x40, 0x44, 0x26, 0x18, 0xf2, 0x33, 0x40, 0xa9, 0x0d, 0x43, 0xf6, 0x06, - 0xe3, 0x33, 0xc0, 0x00, 0x44, 0x26, 0x18, 0xed, 0x33, 0x40, 0x45, 0x25, - 0x18, 0xee, 0x33, 0x00, 0x42, 0x32, 0x00, 0xe4, 0x33, 0x40, 0x44, 0xc9, - 0x00, 0xe7, 0x33, 0x80, 0x06, 0x45, 0xbb, 0x6f, 0xea, 0x33, 0x40, 0x43, - 0xc4, 0x09, 0xf1, 0x33, 0x40, 0x44, 0x49, 0xf2, 0xc3, 0x32, 0x00, 0x45, - 0xe3, 0xeb, 0xc7, 0x32, 0x40, 0xa6, 0x15, 0x43, 0x0e, 0x0b, 0x72, 0xd3, - 0x01, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0x74, 0xd3, 0x01, 0x42, 0x15, - 0x02, 0x73, 0xd3, 0x41, 0x43, 0xd2, 0x05, 0x76, 0xd3, 0x01, 0x43, 0xf6, - 0x06, 0x75, 0xd3, 0x41, 0x51, 0x4e, 0x2d, 0x2c, 0x30, 0x00, 0x14, 0xbb, - 0x45, 0x01, 0xff, 0x09, 0xa9, 0xb5, 0x74, 0x4d, 0x42, 0x83, 0xf4, 0x2f, - 0x00, 0x55, 0xde, 0x3b, 0xfe, 0x2f, 0x00, 0x08, 0x84, 0x02, 0x58, 0x48, - 0x3b, 0x0e, 0xfb, 0x2f, 0x00, 0x48, 0x74, 0x60, 0xff, 0x2f, 0x00, 0x02, - 0x6f, 0x00, 0x01, 0xff, 0x49, 0x08, 0xb7, 0xef, 0x31, 0x00, 0x0c, 0x04, - 0x95, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xf5, 0x2f, 0x00, 0x45, 0x20, 0x07, - 0xf6, 0x2f, 0x00, 0xac, 0x17, 0x45, 0xc8, 0x00, 0xfc, 0x2f, 0x00, 0x06, - 0x6d, 0x02, 0x01, 0xff, 0x44, 0xc3, 0x00, 0xf8, 0x2f, 0x00, 0x45, 0xc8, - 0x00, 0xf9, 0x2f, 0x40, 0x43, 0xc4, 0x00, 0xf7, 0x2f, 0x00, 0x05, 0x14, - 0x01, 0x01, 0xff, 0x44, 0xc3, 0x00, 0xfa, 0x2f, 0x00, 0x45, 0xc8, 0x00, - 0xfd, 0x2f, 0x40, 0x50, 0x2d, 0x65, 0xf2, 0x2f, 0x00, 0x45, 0xc8, 0x00, - 0xf0, 0x2f, 0x40, 0x45, 0x20, 0x07, 0xf1, 0x2f, 0x00, 0x50, 0x1d, 0x65, - 0xf3, 0x2f, 0x40, 0x4b, 0x04, 0x9f, 0x06, 0x30, 0x00, 0x44, 0x14, 0x05, - 0x01, 0x30, 0x40, 0x4b, 0xd1, 0x99, 0x98, 0x31, 0x00, 0x4a, 0xaa, 0xa9, - 0x9e, 0x31, 0x00, 0xa6, 0x49, 0x4b, 0xf4, 0x9c, 0x9d, 0x31, 0x00, 0x4c, - 0x5c, 0x91, 0x90, 0x31, 0x00, 0xad, 0x2f, 0x48, 0x57, 0x2d, 0x92, 0x31, - 0x00, 0x4c, 0x80, 0x94, 0x91, 0x31, 0x00, 0x4b, 0xa0, 0xa2, 0x9a, 0x31, - 0x00, 0xb4, 0x01, 0xff, 0xa8, 0x0c, 0x47, 0x1c, 0xd4, 0x96, 0x31, 0x00, - 0x47, 0xb1, 0xd7, 0x93, 0x31, 0x40, 0x48, 0x49, 0xc7, 0x9b, 0x31, 0x00, - 0x48, 0x79, 0xca, 0x94, 0x31, 0x40, 0x47, 0xdc, 0xce, 0x9f, 0x31, 0x00, - 0x4a, 0x94, 0xab, 0x97, 0x31, 0x40, 0x49, 0xd4, 0xba, 0x99, 0x31, 0x00, - 0x03, 0xf6, 0x06, 0x01, 0xff, 0x45, 0xb8, 0x00, 0x95, 0x31, 0x00, 0x47, - 0x61, 0x39, 0x9c, 0x31, 0x40, 0x04, 0x37, 0x00, 0x06, 0x4d, 0xe7, 0x82, - 0xaa, 0xfa, 0x41, 0x42, 0x1e, 0x00, 0x61, 0x22, 0x80, 0x06, 0x4e, 0x91, - 0x3b, 0x67, 0x2a, 0x40, 0x55, 0x96, 0x38, 0xe5, 0x29, 0x40, 0xa3, 0x0c, - 0x55, 0xc9, 0x3b, 0xd2, 0xf3, 0x01, 0x45, 0x20, 0xeb, 0xf8, 0x26, 0x40, - 0x44, 0xce, 0x61, 0x68, 0xf3, 0x01, 0x43, 0xe2, 0x40, 0xca, 0xf9, 0x41, - 0xa1, 0x81, 0x26, 0xa5, 0x80, 0x08, 0xa9, 0xe7, 0x03, 0xaf, 0x70, 0x4b, - 0x95, 0xa2, 0xb4, 0x20, 0x00, 0xf4, 0x09, 0x00, 0x80, 0x5d, 0xb5, 0x45, - 0xb9, 0x01, 0xff, 0x46, 0x94, 0xd9, 0xbb, 0xfa, 0x01, 0x44, 0x21, 0xf0, - 0xda, 0x2b, 0x80, 0x2f, 0xb0, 0x06, 0x4f, 0x7b, 0x73, 0x8e, 0x23, 0x40, - 0x43, 0xb0, 0x01, 0x10, 0x20, 0x80, 0x06, 0x49, 0xf9, 0xbc, 0x12, 0x2e, - 0x40, 0x80, 0x0c, 0x46, 0xe2, 0x8f, 0x2d, 0x00, 0x00, 0x4b, 0x84, 0x99, - 0x27, 0x20, 0x40, 0x46, 0xb4, 0x21, 0x43, 0x20, 0x00, 0x4e, 0xfe, 0x69, - 0x1a, 0x2e, 0x40, 0x49, 0x3c, 0x2e, 0x79, 0xf7, 0x41, 0x4a, 0xe0, 0xaa, - 0x17, 0xf9, 0x01, 0x53, 0x73, 0x4b, 0xaf, 0xf4, 0x01, 0x49, 0x57, 0x93, + 0xa9, 0x00, 0x42, 0xdf, 0x23, 0xaa, 0xa9, 0x40, 0xe1, 0xa0, 0xa9, 0x80, + 0x0d, 0x42, 0x12, 0x00, 0x9b, 0xa9, 0xc0, 0x00, 0x4a, 0x82, 0x73, 0x9c, + 0xa9, 0x40, 0x46, 0x26, 0xde, 0xa1, 0xa9, 0x40, 0x02, 0x6b, 0x00, 0x01, + 0xff, 0x48, 0x84, 0x73, 0xb0, 0xa9, 0x00, 0x44, 0x7e, 0x73, 0xaf, 0xa9, + 0x40, 0x46, 0xea, 0xdd, 0xac, 0xa9, 0x40, 0x80, 0x01, 0xff, 0x45, 0x11, + 0xeb, 0x89, 0xa9, 0x00, 0x45, 0x7d, 0x73, 0xa6, 0xa9, 0x40, 0xe1, 0xa4, + 0xa9, 0x80, 0x21, 0x42, 0x24, 0x02, 0x94, 0xa9, 0x80, 0x0d, 0x42, 0xdf, + 0x23, 0x9a, 0xa9, 0xc0, 0x00, 0x46, 0x26, 0xde, 0x98, 0xa9, 0x40, 0x46, + 0x14, 0xde, 0x8a, 0xa9, 0xc0, 0x00, 0x48, 0x2f, 0xc8, 0x8b, 0xa9, 0x40, + 0x46, 0x26, 0xde, 0x9f, 0xa9, 0x40, 0x80, 0x01, 0xff, 0x45, 0x7d, 0x73, + 0x91, 0xa9, 0x00, 0x45, 0x54, 0xa8, 0x90, 0xa9, 0x40, 0x4a, 0x82, 0x73, + 0x99, 0xa9, 0x40, 0x45, 0xce, 0xe7, 0x85, 0xa9, 0x00, 0xe9, 0x87, 0xa9, + 0x40, 0x46, 0x26, 0xde, 0x93, 0xa9, 0x40, 0xe1, 0xa2, 0xa9, 0x80, 0x0d, + 0x42, 0x7b, 0x08, 0x9d, 0xa9, 0xc0, 0x00, 0x4a, 0x82, 0x73, 0x9e, 0xa9, + 0x40, 0x4a, 0x82, 0x73, 0xa3, 0xa9, 0x40, 0x46, 0x26, 0xde, 0x96, 0xa9, + 0x40, 0x46, 0x26, 0xde, 0xa8, 0xa9, 0x40, 0xe9, 0x8d, 0xa9, 0x40, 0x45, + 0x7e, 0x0b, 0xd8, 0xa9, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xd9, 0xa9, + 0x00, 0x43, 0x7a, 0x0b, 0xd1, 0xa9, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, + 0x80, 0x1f, 0xd0, 0xa9, 0x40, 0x44, 0x25, 0x01, 0xd3, 0xa9, 0x00, 0x42, + 0x15, 0x02, 0xd2, 0xa9, 0x40, 0x44, 0x06, 0x1f, 0xd7, 0xa9, 0x00, 0x42, + 0x09, 0x24, 0xd6, 0xa9, 0x40, 0x43, 0xf9, 0x05, 0xd5, 0xa9, 0x00, 0x43, + 0xf6, 0x06, 0xd4, 0xa9, 0x40, 0x45, 0xe4, 0xea, 0xbf, 0xa9, 0x00, 0x45, + 0xc3, 0xed, 0xbd, 0xa9, 0x00, 0x47, 0x94, 0xda, 0xbe, 0xa9, 0x40, 0x4b, + 0x82, 0x9e, 0xfb, 0x26, 0x00, 0x46, 0x48, 0xe0, 0xef, 0xf3, 0x01, 0x45, + 0x24, 0xc0, 0x8e, 0xf3, 0x01, 0x46, 0x10, 0xe2, 0x7a, 0xf4, 0x01, 0x5a, + 0x89, 0x21, 0x04, 0x30, 0x00, 0x44, 0x52, 0xdb, 0x79, 0xf4, 0x01, 0x4b, + 0xa1, 0xa6, 0xe3, 0xf3, 0x01, 0x53, 0xb7, 0x4f, 0x30, 0xf5, 0x41, 0x53, + 0xda, 0x49, 0x1f, 0xf9, 0x01, 0x03, 0x0e, 0x08, 0x92, 0x15, 0x02, 0x04, + 0x00, 0xf1, 0x0d, 0xad, 0x82, 0x0c, 0xae, 0x14, 0xb2, 0x06, 0x4e, 0xf8, + 0x82, 0xee, 0xf3, 0x41, 0x43, 0x76, 0x25, 0xc7, 0xce, 0x01, 0x42, 0x5f, + 0x03, 0xc1, 0xce, 0x41, 0x48, 0xff, 0xc9, 0xe5, 0xf4, 0x01, 0xa3, 0xab, + 0x0b, 0xe4, 0x84, 0x00, 0x80, 0x92, 0x07, 0xa6, 0xcf, 0x06, 0x06, 0x70, + 0xe2, 0xbe, 0x06, 0x0f, 0x3f, 0x75, 0x97, 0x06, 0xb3, 0xf8, 0x02, 0x02, + 0x77, 0x00, 0xb7, 0x01, 0xb6, 0x01, 0xff, 0x02, 0x33, 0x00, 0x17, 0x07, + 0xdf, 0xd7, 0x01, 0xff, 0x44, 0xc6, 0x29, 0x64, 0x20, 0x00, 0x49, 0xfb, + 0x21, 0x63, 0x20, 0x00, 0x45, 0x28, 0x02, 0x62, 0x20, 0x40, 0x03, 0x41, + 0x04, 0x5b, 0x04, 0x77, 0x00, 0x01, 0xff, 0x50, 0xad, 0x00, 0xa1, 0x00, + 0x00, 0x4b, 0xed, 0x16, 0x18, 0x2e, 0x00, 0xac, 0x2e, 0x48, 0xc7, 0xce, + 0x27, 0x21, 0x00, 0x49, 0xb9, 0x1c, 0xe7, 0x26, 0x00, 0x4d, 0x88, 0x36, + 0xbf, 0x00, 0x00, 0x07, 0x29, 0x26, 0x0c, 0x48, 0xd7, 0xd1, 0x54, 0x20, + 0x00, 0x57, 0xbc, 0x33, 0x61, 0x2e, 0x40, 0x56, 0x2f, 0x37, 0x08, 0xdb, + 0x01, 0x57, 0xa8, 0x32, 0x09, 0xdb, 0x41, 0x45, 0x01, 0x72, 0x3e, 0x22, + 0x80, 0x0d, 0x49, 0x89, 0xc3, 0x45, 0x2e, 0xc0, 0x00, 0x52, 0x31, 0x52, + 0x46, 0x2e, 0x40, 0x4c, 0xf0, 0x8f, 0x18, 0xdb, 0x41, 0xa2, 0x22, 0x05, + 0x3b, 0x15, 0x12, 0x62, 0xa0, 0x0c, 0xb4, 0xfb, 0x01, 0x4c, 0x44, 0x04, + 0x90, 0xfb, 0x01, 0x4c, 0x00, 0x12, 0xd9, 0x25, 0x40, 0x45, 0xb8, 0x00, + 0xb1, 0xfb, 0x01, 0x4d, 0xae, 0x86, 0x96, 0xfb, 0x41, 0x05, 0x0d, 0x03, + 0x06, 0x45, 0xd6, 0x22, 0xd8, 0x25, 0x40, 0x47, 0xcc, 0x46, 0x8d, 0xcc, + 0x01, 0x4c, 0xcf, 0x0a, 0x8f, 0xcc, 0x41, 0x44, 0x06, 0x28, 0x2b, 0x22, + 0x80, 0x6a, 0xb2, 0x01, 0xff, 0x46, 0x42, 0xe0, 0xba, 0x22, 0x00, 0x4b, + 0xc6, 0x3d, 0x3c, 0x2a, 0x00, 0xac, 0x3d, 0x46, 0xf2, 0x16, 0x3d, 0x20, + 0x00, 0x47, 0xf7, 0x0a, 0x29, 0x22, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x06, + 0x5c, 0x00, 0x1d, 0x63, 0xdb, 0x0a, 0x4b, 0x2a, 0x00, 0x05, 0x51, 0x00, + 0x01, 0xff, 0x43, 0x48, 0x0a, 0x40, 0x2a, 0x00, 0x4b, 0xce, 0x31, 0x44, + 0x2a, 0x00, 0x47, 0xc2, 0x83, 0x43, 0x2a, 0x40, 0x4f, 0x46, 0x6e, 0x49, + 0x2a, 0x00, 0x45, 0x37, 0x18, 0x47, 0x2a, 0x40, 0x11, 0x8d, 0x5d, 0x06, + 0x5a, 0x73, 0x22, 0xa4, 0x26, 0x40, 0x46, 0xa0, 0xdf, 0xf9, 0xff, 0x00, + 0x49, 0xfb, 0x21, 0xfa, 0xff, 0x00, 0x4a, 0xa7, 0x8a, 0xfb, 0xff, 0x40, + 0x80, 0x01, 0xff, 0xa1, 0x3a, 0x49, 0x42, 0x5b, 0xae, 0x23, 0x00, 0x05, + 0x51, 0x00, 0x01, 0xff, 0x4d, 0x46, 0x86, 0x0e, 0x2a, 0x00, 0x4c, 0xf2, + 0x0a, 0x19, 0x2a, 0x00, 0x59, 0x06, 0x26, 0x17, 0x2a, 0x00, 0x47, 0xc2, + 0x83, 0x1b, 0x2a, 0x00, 0x4a, 0x94, 0xb7, 0x18, 0x2a, 0x00, 0x02, 0x79, + 0x08, 0x01, 0xff, 0x46, 0x66, 0x5c, 0x1c, 0x2a, 0x00, 0x43, 0xb5, 0x00, + 0x1a, 0x2a, 0x40, 0x56, 0xfd, 0x38, 0x15, 0x2a, 0x00, 0x51, 0xef, 0x61, + 0x0f, 0x2a, 0x40, 0x0d, 0xb7, 0x85, 0x06, 0x4d, 0xbb, 0x86, 0x80, 0x23, + 0x40, 0x06, 0x44, 0x79, 0xd3, 0x01, 0x07, 0x66, 0xdb, 0x01, 0xff, 0x07, + 0x13, 0x06, 0x3d, 0x07, 0x37, 0x3c, 0x01, 0xff, 0x44, 0xf5, 0x06, 0x5b, + 0x0b, 0x01, 0x43, 0x7a, 0x0b, 0x58, 0x0b, 0x81, 0x1c, 0xb4, 0x01, 0xff, + 0x42, 0x92, 0x01, 0x5c, 0x0b, 0x01, 0x44, 0x25, 0x01, 0x5a, 0x0b, 0x01, + 0xb7, 0x01, 0xff, 0x44, 0xe9, 0x1e, 0x5d, 0x0b, 0x01, 0xef, 0x59, 0x0b, + 0x41, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0x5e, 0x0b, 0x01, 0x48, 0xde, + 0x1e, 0x5f, 0x0b, 0x41, 0xa1, 0x7f, 0x44, 0x20, 0xf5, 0x41, 0x0b, 0x01, + 0x46, 0x6d, 0x4c, 0x43, 0x0b, 0x01, 0x45, 0x5a, 0xb0, 0x42, 0x0b, 0x01, + 0x42, 0xb0, 0x01, 0x44, 0x0b, 0x81, 0x60, 0x44, 0xb0, 0xf6, 0x4a, 0x0b, + 0x01, 0x46, 0x8a, 0xe3, 0x4b, 0x0b, 0x01, 0x43, 0xb4, 0x05, 0x4c, 0x0b, + 0x01, 0x43, 0x18, 0x24, 0x4d, 0x0b, 0x01, 0x42, 0x6f, 0x02, 0x50, 0x0b, + 0x01, 0x44, 0xf3, 0xcd, 0x52, 0x0b, 0x01, 0x44, 0x8a, 0x69, 0x53, 0x0b, + 0x01, 0xb3, 0x20, 0xb4, 0x12, 0x43, 0x1c, 0x8f, 0x45, 0x0b, 0x01, 0x44, + 0xfd, 0x54, 0x49, 0x0b, 0x01, 0x45, 0xf7, 0x54, 0x46, 0x0b, 0x41, 0x42, + 0x3e, 0x2f, 0x55, 0x0b, 0x01, 0x43, 0x48, 0x27, 0x48, 0x0b, 0x41, 0xa1, + 0x06, 0x43, 0x48, 0x17, 0x54, 0x0b, 0x41, 0x43, 0x95, 0xf0, 0x51, 0x0b, + 0x01, 0x44, 0x4a, 0xea, 0x4e, 0x0b, 0x41, 0x42, 0x53, 0x00, 0x47, 0x0b, + 0x41, 0x44, 0x3b, 0x3f, 0x40, 0x0b, 0x01, 0x43, 0xa0, 0x1b, 0x4f, 0x0b, + 0x41, 0x07, 0x13, 0x06, 0x3d, 0x07, 0x37, 0x3c, 0x01, 0xff, 0x44, 0xf5, + 0x06, 0x7b, 0x0b, 0x01, 0x43, 0x7a, 0x0b, 0x78, 0x0b, 0x81, 0x1c, 0xb4, + 0x01, 0xff, 0x42, 0x92, 0x01, 0x7c, 0x0b, 0x01, 0x44, 0x25, 0x01, 0x7a, + 0x0b, 0x01, 0xb7, 0x01, 0xff, 0x44, 0xe9, 0x1e, 0x7d, 0x0b, 0x01, 0xef, + 0x79, 0x0b, 0x41, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0x7e, 0x0b, 0x01, + 0x48, 0xde, 0x1e, 0x7f, 0x0b, 0x41, 0x45, 0x39, 0xb3, 0x60, 0x0b, 0x01, + 0x44, 0x20, 0xf5, 0x61, 0x0b, 0x01, 0x46, 0x6d, 0x4c, 0x63, 0x0b, 0x01, + 0x45, 0x5a, 0xb0, 0x62, 0x0b, 0x01, 0x42, 0xb0, 0x01, 0x64, 0x0b, 0x81, + 0x54, 0x44, 0xb0, 0xf6, 0x6a, 0x0b, 0x01, 0x46, 0x8a, 0xe3, 0x6b, 0x0b, + 0x01, 0x48, 0xef, 0xcd, 0x6c, 0x0b, 0x01, 0x43, 0x18, 0x24, 0x6d, 0x0b, + 0x01, 0x42, 0x6f, 0x02, 0x6f, 0x0b, 0x01, 0xb3, 0x20, 0xb4, 0x12, 0x4d, + 0x1c, 0x8f, 0x65, 0x0b, 0x01, 0x44, 0xfd, 0x54, 0x69, 0x0b, 0x01, 0x45, + 0xf7, 0x54, 0x66, 0x0b, 0x41, 0x42, 0x3e, 0x2f, 0x72, 0x0b, 0x01, 0x43, + 0x48, 0x27, 0x68, 0x0b, 0x41, 0xa1, 0x06, 0x43, 0x48, 0x17, 0x71, 0x0b, + 0x41, 0x43, 0x95, 0xf0, 0x70, 0x0b, 0x01, 0x44, 0x4a, 0xea, 0x6e, 0x0b, + 0x41, 0x42, 0x53, 0x00, 0x67, 0x0b, 0x41, 0x06, 0x05, 0x06, 0x0c, 0x47, + 0x83, 0xd9, 0x22, 0xf5, 0x01, 0x47, 0x16, 0x08, 0x23, 0xf5, 0x41, 0x4f, + 0xcd, 0x6e, 0x20, 0xf5, 0x01, 0x47, 0xd5, 0x6e, 0x24, 0xf5, 0x01, 0x4d, + 0x62, 0x8d, 0x21, 0xf5, 0x41, 0x53, 0x5f, 0x4a, 0x6c, 0x20, 0x00, 0x52, + 0x07, 0x58, 0x6a, 0x20, 0x40, 0x45, 0xb8, 0x6f, 0x1e, 0x22, 0x80, 0x33, + 0x09, 0x49, 0x5f, 0x01, 0xff, 0x4b, 0x03, 0xa0, 0x81, 0xf4, 0x01, 0xb3, + 0x01, 0xff, 0x09, 0xfc, 0x21, 0x06, 0x45, 0x53, 0x5f, 0x39, 0x21, 0x40, + 0x44, 0xf5, 0x06, 0x1c, 0x00, 0x00, 0x43, 0x7a, 0x0b, 0x1f, 0x00, 0x00, + 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0x1d, 0x00, 0x00, 0x42, 0x15, 0x02, + 0x1e, 0x00, 0x40, 0x5a, 0xcf, 0x1f, 0xde, 0x29, 0x40, 0x42, 0xad, 0x00, + 0x84, 0x00, 0x80, 0x85, 0x04, 0xa9, 0x01, 0xff, 0x4d, 0x65, 0x84, 0xb9, + 0x20, 0x00, 0x08, 0x17, 0xca, 0x01, 0xff, 0x53, 0x26, 0x4a, 0xb4, 0xec, + 0x01, 0x09, 0x54, 0x2a, 0xd6, 0x03, 0x49, 0x30, 0x4a, 0xa0, 0xec, 0x01, + 0x07, 0x37, 0x3c, 0x0c, 0x4b, 0xda, 0x68, 0xac, 0xec, 0x01, 0x4a, 0x5e, + 0xb6, 0xb0, 0xec, 0x41, 0x0a, 0xbf, 0x12, 0xa6, 0x03, 0x45, 0x7e, 0x0b, + 0x78, 0xec, 0x81, 0x85, 0x03, 0xa6, 0xb7, 0x02, 0x45, 0xb9, 0xed, 0xa1, + 0xec, 0x81, 0xa9, 0x02, 0x44, 0x30, 0x4a, 0x9e, 0xec, 0x81, 0x9b, 0x02, + 0x44, 0x6d, 0x2c, 0x79, 0xec, 0x81, 0xf8, 0x01, 0x43, 0x7a, 0x0b, 0x71, + 0xec, 0x81, 0xe1, 0x01, 0x09, 0x87, 0x4e, 0x9f, 0x01, 0xb3, 0x59, 0xb4, + 0x01, 0xff, 0x42, 0x92, 0x01, 0x7a, 0xec, 0x81, 0x49, 0xa8, 0x24, 0xb7, + 0x01, 0xff, 0x44, 0xe9, 0x1e, 0x7b, 0xec, 0x81, 0x14, 0xef, 0x72, 0xec, + 0xc1, 0x00, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0x84, 0xec, 0x01, 0x48, + 0xde, 0x1e, 0x8d, 0xec, 0x41, 0x49, 0xdd, 0x1e, 0x96, 0xec, 0x41, 0x44, + 0x49, 0x12, 0x7c, 0xec, 0x81, 0x16, 0x43, 0x26, 0x01, 0x73, 0xec, 0xc1, + 0x00, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0x85, 0xec, 0x01, 0x48, 0xde, + 0x1e, 0x8e, 0xec, 0x41, 0x49, 0xdd, 0x1e, 0x97, 0xec, 0x41, 0x49, 0xdd, + 0x1e, 0x95, 0xec, 0x41, 0x44, 0x06, 0x1f, 0x77, 0xec, 0x81, 0x22, 0x42, + 0x09, 0x24, 0x76, 0xec, 0xc1, 0x00, 0x80, 0x0d, 0x42, 0x4b, 0x12, 0x7f, + 0xec, 0xc1, 0x00, 0x49, 0xdd, 0x1e, 0x9a, 0xec, 0x41, 0x47, 0x3f, 0x12, + 0x88, 0xec, 0x01, 0x48, 0xde, 0x1e, 0x91, 0xec, 0x41, 0x80, 0x0d, 0x42, + 0x4b, 0x12, 0x80, 0xec, 0xc1, 0x00, 0x49, 0xdd, 0x1e, 0x9b, 0xec, 0x41, + 0x47, 0x3f, 0x12, 0x89, 0xec, 0x01, 0x48, 0xde, 0x1e, 0x92, 0xec, 0x41, + 0x45, 0x7e, 0x0b, 0xaa, 0xec, 0x01, 0xa6, 0x29, 0x44, 0x6d, 0x2c, 0xab, + 0xec, 0x01, 0x43, 0x7a, 0x0b, 0xa3, 0xec, 0x01, 0xb3, 0x0f, 0xb4, 0x01, + 0xff, 0x44, 0x25, 0x01, 0xa5, 0xec, 0x01, 0x42, 0x15, 0x02, 0xa4, 0xec, + 0x41, 0x44, 0x06, 0x1f, 0xa9, 0xec, 0x01, 0x42, 0x09, 0x24, 0xa8, 0xec, + 0x41, 0x43, 0xf9, 0x05, 0xa7, 0xec, 0x01, 0x43, 0xf6, 0x06, 0xa6, 0xec, + 0x41, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0x83, 0xec, 0x01, 0x48, 0xde, + 0x1e, 0x8c, 0xec, 0x41, 0x80, 0x0d, 0x42, 0x4b, 0x12, 0x82, 0xec, 0xc1, + 0x00, 0x49, 0xdd, 0x1e, 0x9d, 0xec, 0x41, 0x47, 0x3f, 0x12, 0x8b, 0xec, + 0x01, 0x48, 0xde, 0x1e, 0x94, 0xec, 0x41, 0x42, 0x1a, 0x00, 0x9f, 0xec, + 0x41, 0x42, 0x1a, 0x00, 0xa2, 0xec, 0x41, 0xa9, 0x26, 0xaf, 0x01, 0xff, + 0x43, 0x4a, 0x12, 0x7d, 0xec, 0x81, 0x16, 0x42, 0x42, 0x00, 0x74, 0xec, + 0xc1, 0x00, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0x86, 0xec, 0x01, 0x48, + 0xde, 0x1e, 0x8f, 0xec, 0x41, 0x49, 0xdd, 0x1e, 0x98, 0xec, 0x41, 0x43, + 0x04, 0x24, 0x7e, 0xec, 0x81, 0x16, 0x42, 0x32, 0x00, 0x75, 0xec, 0xc1, + 0x00, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0x87, 0xec, 0x01, 0x48, 0xde, + 0x1e, 0x90, 0xec, 0x41, 0x49, 0xdd, 0x1e, 0x99, 0xec, 0x41, 0x80, 0x0b, + 0xf9, 0x81, 0xec, 0xc1, 0x00, 0x49, 0xdd, 0x1e, 0x9c, 0xec, 0x41, 0x47, + 0x3f, 0x12, 0x8a, 0xec, 0x01, 0x48, 0xde, 0x1e, 0x93, 0xec, 0x41, 0x43, + 0x7a, 0x0b, 0xb1, 0xec, 0x01, 0xb4, 0x01, 0xff, 0x4b, 0xe0, 0x60, 0xb3, + 0xec, 0x01, 0x42, 0x15, 0x02, 0xb2, 0xec, 0x41, 0x04, 0x7a, 0x0b, 0x06, + 0x4e, 0x24, 0x01, 0xaf, 0xec, 0x41, 0x44, 0x22, 0x00, 0xae, 0xec, 0x01, + 0x47, 0x2a, 0x01, 0xad, 0xec, 0x41, 0x57, 0x13, 0x2e, 0xf5, 0xfa, 0x41, + 0x02, 0x14, 0x05, 0x1b, 0x02, 0x88, 0x00, 0x01, 0xff, 0x03, 0x92, 0x37, + 0x06, 0x44, 0x2c, 0x05, 0x06, 0x22, 0x40, 0x51, 0xaa, 0x38, 0xda, 0xf5, + 0x01, 0x44, 0xf7, 0x03, 0xe1, 0x29, 0x40, 0x4c, 0xb8, 0x94, 0xe8, 0xf4, + 0x01, 0x4d, 0x15, 0x8a, 0x0d, 0xdb, 0x81, 0x06, 0x4e, 0xfa, 0x7e, 0xdc, + 0x29, 0x40, 0x4a, 0x1e, 0xab, 0x0f, 0xdb, 0x41, 0x46, 0x45, 0x45, 0xb7, + 0x22, 0x80, 0xde, 0x01, 0xf0, 0x7f, 0xf4, 0xc1, 0x00, 0x0e, 0xfc, 0x7a, + 0x01, 0xff, 0x07, 0x13, 0x06, 0x43, 0x07, 0x37, 0x3c, 0x06, 0x4c, 0x10, + 0x9a, 0x57, 0x08, 0x41, 0x43, 0x7a, 0x0b, 0x58, 0x08, 0x81, 0x23, 0xb4, + 0x01, 0xff, 0x42, 0x92, 0x01, 0x5b, 0x08, 0x81, 0x13, 0x44, 0x25, 0x01, + 0x5a, 0x08, 0x01, 0xb7, 0x01, 0xff, 0x44, 0xe9, 0x1e, 0x5c, 0x08, 0x01, + 0xef, 0x59, 0x08, 0x41, 0x49, 0xdd, 0x1e, 0x5f, 0x08, 0x41, 0x80, 0x01, + 0xff, 0x47, 0x3f, 0x12, 0x5d, 0x08, 0x01, 0x48, 0xde, 0x1e, 0x5e, 0x08, + 0x41, 0xa1, 0x7f, 0x44, 0x20, 0xf5, 0x41, 0x08, 0x01, 0x46, 0x6d, 0x4c, + 0x43, 0x08, 0x01, 0x45, 0x5a, 0xb0, 0x42, 0x08, 0x01, 0x42, 0xb0, 0x01, + 0x44, 0x08, 0x81, 0x60, 0x44, 0xb0, 0xf6, 0x4a, 0x08, 0x01, 0x46, 0x8a, + 0xe3, 0x4b, 0x08, 0x01, 0x43, 0xb4, 0x05, 0x4c, 0x08, 0x01, 0x43, 0x18, + 0x24, 0x4d, 0x08, 0x01, 0x42, 0x6f, 0x02, 0x50, 0x08, 0x01, 0x44, 0xf3, + 0xcd, 0x52, 0x08, 0x01, 0x44, 0x8a, 0x69, 0x53, 0x08, 0x01, 0xb3, 0x20, + 0xb4, 0x12, 0x43, 0x1c, 0x8f, 0x45, 0x08, 0x01, 0x44, 0xfd, 0x54, 0x49, + 0x08, 0x01, 0x45, 0xf7, 0x54, 0x46, 0x08, 0x41, 0x42, 0x3e, 0x2f, 0x55, + 0x08, 0x01, 0x43, 0x48, 0x27, 0x48, 0x08, 0x41, 0xa1, 0x06, 0x43, 0x48, + 0x17, 0x54, 0x08, 0x41, 0x43, 0x95, 0xf0, 0x51, 0x08, 0x01, 0x44, 0x4a, + 0xea, 0x4e, 0x08, 0x41, 0x42, 0x53, 0x00, 0x47, 0x08, 0x41, 0x44, 0x3b, + 0x3f, 0x40, 0x08, 0x01, 0x43, 0xa0, 0x1b, 0x4f, 0x08, 0x41, 0x5a, 0xe9, + 0x1f, 0x53, 0x22, 0x40, 0x03, 0x9f, 0x01, 0xfa, 0x06, 0x09, 0x72, 0x21, + 0x01, 0xff, 0x0b, 0x93, 0x5d, 0x82, 0x06, 0xa3, 0xf3, 0x05, 0x02, 0x04, + 0x00, 0xdf, 0x04, 0x52, 0xab, 0x53, 0x2d, 0x30, 0x00, 0x49, 0x4f, 0x17, + 0x02, 0x30, 0x00, 0x4f, 0xf8, 0x70, 0x3f, 0x30, 0x00, 0x4e, 0x7b, 0x21, + 0x05, 0x30, 0x00, 0x4f, 0xd8, 0x72, 0x2a, 0x30, 0x00, 0x4b, 0x78, 0xa5, + 0x07, 0x30, 0x00, 0x50, 0xda, 0x69, 0x2b, 0x30, 0x00, 0x45, 0x2d, 0x4f, + 0x00, 0x30, 0x00, 0xb4, 0x06, 0x53, 0xe7, 0x50, 0x3e, 0x30, 0x40, 0x0a, + 0xfe, 0xac, 0xff, 0x03, 0x09, 0xe0, 0xbd, 0x01, 0xff, 0x5a, 0xf1, 0x21, + 0x37, 0x30, 0x00, 0x0b, 0x18, 0x34, 0x01, 0xff, 0xa1, 0xe0, 0x03, 0xa4, + 0xf3, 0x01, 0x48, 0xc7, 0xcb, 0xc1, 0x32, 0x00, 0x05, 0xc6, 0x74, 0x37, + 0xaa, 0x20, 0x02, 0x6c, 0x00, 0x12, 0x48, 0x8f, 0xce, 0xca, 0x32, 0x00, + 0x47, 0x98, 0xd9, 0xc9, 0x32, 0x00, 0x49, 0xfa, 0xc4, 0xc8, 0x32, 0x40, + 0x43, 0x75, 0x79, 0xc2, 0x32, 0x00, 0xf9, 0xc4, 0x32, 0x40, 0x46, 0xb2, + 0xdf, 0xc0, 0x32, 0x00, 0xb5, 0x01, 0xff, 0x42, 0xe1, 0x0b, 0xc6, 0x32, + 0x00, 0x42, 0xf1, 0x05, 0xc5, 0x32, 0x40, 0xa5, 0x9c, 0x01, 0xa6, 0x7f, + 0x44, 0x6d, 0x2c, 0x61, 0x33, 0x80, 0x72, 0x43, 0x7a, 0x0b, 0x59, 0x33, + 0x00, 0xb3, 0x50, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x58, 0x33, 0x40, 0x42, + 0x92, 0x01, 0x62, 0x33, 0x00, 0xa8, 0x34, 0xb7, 0x01, 0xff, 0xa5, 0x04, + 0xef, 0x5a, 0x33, 0x40, 0x43, 0x86, 0x2d, 0x64, 0x33, 0x00, 0x43, 0xea, + 0x1e, 0x6c, 0x33, 0xc0, 0x00, 0x8d, 0x01, 0xff, 0x44, 0xf5, 0x06, 0x70, + 0x33, 0x00, 0x43, 0x7a, 0x0b, 0x6d, 0x33, 0x00, 0xb4, 0x01, 0xff, 0x44, + 0x25, 0x01, 0x6f, 0x33, 0x00, 0x42, 0x15, 0x02, 0x6e, 0x33, 0x40, 0x46, + 0x17, 0x5d, 0x65, 0x33, 0x00, 0x43, 0x26, 0x01, 0x5b, 0x33, 0x40, 0x44, + 0x06, 0x1f, 0x5f, 0x33, 0x80, 0x0d, 0x42, 0x09, 0x24, 0x5e, 0x33, 0xc0, + 0x00, 0x44, 0x10, 0x19, 0x68, 0x33, 0x40, 0x44, 0x10, 0x19, 0x69, 0x33, + 0x40, 0x44, 0x10, 0x19, 0x6b, 0x33, 0x40, 0xa9, 0x0d, 0x43, 0xf6, 0x06, + 0x5c, 0x33, 0xc0, 0x00, 0x44, 0x10, 0x19, 0x66, 0x33, 0x40, 0x45, 0x0f, + 0x19, 0x67, 0x33, 0x00, 0x42, 0x32, 0x00, 0x5d, 0x33, 0x40, 0x44, 0xc9, + 0x00, 0x60, 0x33, 0x80, 0x06, 0x45, 0xe7, 0x72, 0x63, 0x33, 0x40, 0x43, + 0xe9, 0x09, 0x6a, 0x33, 0x40, 0x03, 0x28, 0x21, 0x06, 0x47, 0x6c, 0xd6, + 0xcb, 0x32, 0x40, 0xa5, 0xca, 0x01, 0xa6, 0xac, 0x01, 0x44, 0x6d, 0x2c, + 0xe8, 0x33, 0x80, 0x9e, 0x01, 0x43, 0x7a, 0x0b, 0xe0, 0x33, 0x00, 0xb3, + 0x7c, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0xe9, 0x33, 0x00, 0xa8, 0x56, + 0xb7, 0x01, 0xff, 0xa5, 0x04, 0xef, 0xe1, 0x33, 0x40, 0x43, 0x86, 0x2d, + 0xeb, 0x33, 0x00, 0x43, 0xea, 0x1e, 0xf3, 0x33, 0xc0, 0x00, 0x8d, 0x01, + 0xff, 0x45, 0x7e, 0x0b, 0xfb, 0x33, 0x00, 0xa6, 0x29, 0x44, 0x6d, 0x2c, + 0xfc, 0x33, 0x00, 0x43, 0x7a, 0x0b, 0xf4, 0x33, 0x00, 0xb3, 0x0f, 0xb4, + 0x01, 0xff, 0x44, 0x25, 0x01, 0xf6, 0x33, 0x00, 0x42, 0x15, 0x02, 0xf5, + 0x33, 0x40, 0x44, 0x06, 0x1f, 0xfa, 0x33, 0x00, 0x42, 0x09, 0x24, 0xf9, + 0x33, 0x40, 0x43, 0xf9, 0x05, 0xf8, 0x33, 0x00, 0x43, 0xf6, 0x06, 0xf7, + 0x33, 0x40, 0x03, 0x49, 0x12, 0x06, 0x43, 0x26, 0x01, 0xe2, 0x33, 0x40, + 0x43, 0xe9, 0x09, 0xec, 0x33, 0x00, 0xf9, 0xfd, 0x33, 0xc0, 0x00, 0x44, + 0xe6, 0xc2, 0xfe, 0x33, 0x40, 0x44, 0x06, 0x1f, 0xe6, 0x33, 0x80, 0x0d, + 0x42, 0x09, 0x24, 0xe5, 0x33, 0xc0, 0x00, 0x44, 0x10, 0x19, 0xef, 0x33, + 0x40, 0x44, 0x10, 0x19, 0xf0, 0x33, 0x40, 0x44, 0x10, 0x19, 0xf2, 0x33, + 0x40, 0xa9, 0x0d, 0x43, 0xf6, 0x06, 0xe3, 0x33, 0xc0, 0x00, 0x44, 0x10, + 0x19, 0xed, 0x33, 0x40, 0x45, 0x0f, 0x19, 0xee, 0x33, 0x00, 0x42, 0x32, + 0x00, 0xe4, 0x33, 0x40, 0x44, 0xc9, 0x00, 0xe7, 0x33, 0x80, 0x06, 0x45, + 0xe7, 0x72, 0xea, 0x33, 0x40, 0x43, 0xe9, 0x09, 0xf1, 0x33, 0x40, 0x44, + 0x1c, 0xf8, 0xc3, 0x32, 0x00, 0x45, 0xa6, 0xf1, 0xc7, 0x32, 0x40, 0xa6, + 0x15, 0x43, 0x7a, 0x0b, 0x72, 0xd3, 0x01, 0xb4, 0x01, 0xff, 0x44, 0x25, + 0x01, 0x74, 0xd3, 0x01, 0x42, 0x15, 0x02, 0x73, 0xd3, 0x41, 0x43, 0xf9, + 0x05, 0x76, 0xd3, 0x01, 0x43, 0xf6, 0x06, 0x75, 0xd3, 0x41, 0x51, 0xba, + 0x2e, 0x2c, 0x30, 0x00, 0x14, 0xeb, 0x47, 0x01, 0xff, 0x09, 0x10, 0xbb, + 0x74, 0x4d, 0x3d, 0x87, 0xf4, 0x2f, 0x00, 0x55, 0xe6, 0x3d, 0xfe, 0x2f, + 0x00, 0x08, 0x84, 0x02, 0x58, 0x48, 0xc9, 0x0e, 0xfb, 0x2f, 0x00, 0x48, + 0x21, 0x63, 0xff, 0x2f, 0x00, 0x02, 0x6f, 0x00, 0x01, 0xff, 0x49, 0x78, + 0xbc, 0xef, 0x31, 0x00, 0x0c, 0xe0, 0x99, 0x01, 0xff, 0x45, 0x5c, 0x00, + 0xf5, 0x2f, 0x00, 0x45, 0x20, 0x07, 0xf6, 0x2f, 0x00, 0xac, 0x17, 0x45, + 0xc8, 0x00, 0xfc, 0x2f, 0x00, 0x06, 0x6d, 0x02, 0x01, 0xff, 0x44, 0xc3, + 0x00, 0xf8, 0x2f, 0x00, 0x45, 0xc8, 0x00, 0xf9, 0x2f, 0x40, 0x43, 0xc4, + 0x00, 0xf7, 0x2f, 0x00, 0x05, 0x14, 0x01, 0x01, 0xff, 0x44, 0xc3, 0x00, + 0xfa, 0x2f, 0x00, 0x45, 0xc8, 0x00, 0xfd, 0x2f, 0x40, 0x50, 0x1a, 0x68, + 0xf2, 0x2f, 0x00, 0x45, 0xc8, 0x00, 0xf0, 0x2f, 0x40, 0x45, 0x20, 0x07, + 0xf1, 0x2f, 0x00, 0x50, 0x0a, 0x68, 0xf3, 0x2f, 0x40, 0x4b, 0x0d, 0xa4, + 0x06, 0x30, 0x00, 0x44, 0x14, 0x05, 0x01, 0x30, 0x40, 0x4b, 0xb9, 0x9e, + 0x98, 0x31, 0x00, 0x4a, 0xde, 0xae, 0x9e, 0x31, 0x00, 0xa6, 0x49, 0x4b, + 0x08, 0xa2, 0x9d, 0x31, 0x00, 0x4c, 0x08, 0x96, 0x90, 0x31, 0x00, 0xad, + 0x2f, 0x48, 0xc3, 0x2e, 0x92, 0x31, 0x00, 0x4c, 0x50, 0x99, 0x91, 0x31, + 0x00, 0x4b, 0xb4, 0xa7, 0x9a, 0x31, 0x00, 0xb4, 0x01, 0xff, 0xa8, 0x0c, + 0x47, 0xe5, 0xd9, 0x96, 0x31, 0x00, 0x47, 0x81, 0xdd, 0x93, 0x31, 0x40, + 0x48, 0xd7, 0xcc, 0x9b, 0x31, 0x00, 0x48, 0x1f, 0xd0, 0x94, 0x31, 0x40, + 0x47, 0x82, 0xd4, 0x9f, 0x31, 0x00, 0x4a, 0xf0, 0xb0, 0x97, 0x31, 0x40, + 0x49, 0x5f, 0xc0, 0x99, 0x31, 0x00, 0x03, 0xf6, 0x06, 0x01, 0xff, 0x45, + 0xb8, 0x00, 0x95, 0x31, 0x00, 0x47, 0x7e, 0x3b, 0x9c, 0x31, 0x40, 0x04, + 0x37, 0x00, 0x06, 0x4d, 0xe2, 0x86, 0xaa, 0xfa, 0x41, 0x42, 0x1e, 0x00, + 0x61, 0x22, 0x80, 0x06, 0x4e, 0x99, 0x3d, 0x67, 0x2a, 0x40, 0x55, 0x89, + 0x3a, 0xe5, 0x29, 0x40, 0xa3, 0x0c, 0x55, 0xd1, 0x3d, 0xd2, 0xf3, 0x01, + 0x45, 0xe8, 0xf0, 0xf8, 0x26, 0x40, 0x44, 0x9b, 0x64, 0x68, 0xf3, 0x01, + 0x43, 0xea, 0x42, 0xca, 0xf9, 0x41, 0xa1, 0xaa, 0x26, 0xa5, 0x97, 0x08, + 0xa9, 0xf3, 0x03, 0xaf, 0x76, 0x4b, 0xa9, 0xa7, 0xb4, 0x20, 0x00, 0xf4, + 0x09, 0x00, 0x80, 0x63, 0xb5, 0x4b, 0xb9, 0x01, 0xff, 0x46, 0x64, 0xdf, + 0xbb, 0xfa, 0x01, 0x44, 0xe4, 0xf5, 0xda, 0x2b, 0x80, 0x35, 0xb0, 0x06, + 0x4f, 0xa7, 0x76, 0x8e, 0x23, 0x40, 0x46, 0x4a, 0xe1, 0xfd, 0xce, 0x01, + 0x43, 0xb0, 0x01, 0x10, 0x20, 0x80, 0x06, 0x49, 0x96, 0xc2, 0x12, 0x2e, + 0x40, 0x80, 0x0c, 0x46, 0x76, 0x94, 0x2d, 0x00, 0x00, 0x4b, 0x6c, 0x9e, + 0x27, 0x20, 0x40, 0x46, 0xd5, 0x22, 0x43, 0x20, 0x00, 0x4e, 0x2a, 0x6d, + 0x1a, 0x2e, 0x40, 0x49, 0xa8, 0x2f, 0x79, 0xf7, 0x41, 0x4a, 0x3c, 0xb0, + 0x17, 0xf9, 0x01, 0x53, 0xc9, 0x4d, 0xaf, 0xf4, 0x01, 0x49, 0x1b, 0x98, 0x2f, 0xf6, 0x01, 0xf4, 0xd6, 0xf6, 0x41, 0xea, 0x89, 0x00, 0x00, 0xf3, - 0x88, 0x00, 0x40, 0x43, 0x7f, 0x2a, 0x2a, 0xf5, 0x01, 0xac, 0xdb, 0x02, - 0x48, 0x0e, 0x7a, 0x3b, 0x22, 0x00, 0x03, 0xb8, 0x28, 0xc4, 0x02, 0x42, + 0x88, 0x00, 0x40, 0x43, 0x02, 0x2c, 0x2a, 0xf5, 0x01, 0xac, 0xe1, 0x02, + 0x48, 0x9c, 0x7d, 0x3b, 0x22, 0x00, 0x03, 0x0b, 0x2a, 0xca, 0x02, 0x42, 0x55, 0x05, 0x9d, 0xfa, 0x01, 0xf0, 0x81, 0x00, 0x00, 0xb2, 0x53, 0x46, - 0x24, 0xe0, 0xe5, 0xf3, 0x01, 0xb4, 0x2b, 0xb5, 0x01, 0xff, 0x46, 0x1f, - 0xd7, 0x1b, 0x23, 0x80, 0x1b, 0x42, 0x46, 0x03, 0x02, 0x23, 0xc0, 0x00, - 0x80, 0x01, 0xff, 0x48, 0xce, 0x3d, 0xe0, 0xf3, 0x81, 0x06, 0x4b, 0x4a, - 0xa5, 0xe1, 0xf3, 0x41, 0xf3, 0xd8, 0xf3, 0x41, 0x52, 0xdc, 0x4f, 0xf3, - 0x23, 0x40, 0x80, 0x06, 0x42, 0xd8, 0x00, 0xe8, 0xf3, 0x41, 0x48, 0x29, - 0xc4, 0x15, 0x26, 0x00, 0x43, 0xff, 0xda, 0x2d, 0xf3, 0x01, 0x46, 0x3a, - 0xdf, 0x36, 0xf3, 0x01, 0x47, 0x14, 0xd6, 0x68, 0x26, 0x40, 0x08, 0x0e, + 0x06, 0xe6, 0xe5, 0xf3, 0x01, 0xb4, 0x2b, 0xb5, 0x01, 0xff, 0x46, 0xef, + 0xdc, 0x1b, 0x23, 0x80, 0x1b, 0x42, 0x46, 0x03, 0x02, 0x23, 0xc0, 0x00, + 0x80, 0x01, 0xff, 0x48, 0xd6, 0x3f, 0xe0, 0xf3, 0x81, 0x06, 0x4b, 0x74, + 0xaa, 0xe1, 0xf3, 0x41, 0xf3, 0xd8, 0xf3, 0x41, 0x52, 0x1f, 0x52, 0xf3, + 0x23, 0x40, 0x80, 0x06, 0x42, 0xd8, 0x00, 0xe8, 0xf3, 0x41, 0x48, 0xb7, + 0xc9, 0x15, 0x26, 0x00, 0x43, 0xc9, 0xe0, 0x2d, 0xf3, 0x01, 0x46, 0x10, + 0xe5, 0x36, 0xf3, 0x01, 0x47, 0xe4, 0xdb, 0x68, 0x26, 0x40, 0x08, 0x0e, 0x00, 0x16, 0x42, 0x46, 0x03, 0x0e, 0xf4, 0xc1, 0x00, 0x80, 0x01, 0xff, - 0x44, 0x0c, 0x08, 0x34, 0xf4, 0x01, 0x46, 0x88, 0xdf, 0xc7, 0xf3, 0x41, - 0xa2, 0xb1, 0x01, 0x49, 0x1a, 0xb7, 0x13, 0xcc, 0x01, 0x48, 0xe9, 0x29, - 0x26, 0x20, 0x00, 0xac, 0x78, 0x55, 0xef, 0x3c, 0xa9, 0x26, 0x00, 0x11, - 0xde, 0x5c, 0x50, 0xb2, 0x42, 0x0a, 0xee, 0xb0, 0x2e, 0xb4, 0x06, 0x4b, - 0xa2, 0xa5, 0xb0, 0xce, 0x41, 0x02, 0x5c, 0x00, 0x06, 0x4c, 0x2c, 0x94, - 0xa5, 0xf6, 0x41, 0x44, 0xd8, 0x45, 0x7e, 0x2b, 0x00, 0x47, 0x01, 0x3c, - 0x09, 0x00, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x43, 0x9c, 0x12, 0x88, 0x00, - 0x00, 0x52, 0xae, 0x56, 0x89, 0x00, 0x40, 0xd1, 0xba, 0x23, 0x00, 0xd3, - 0xbb, 0x23, 0x00, 0xd7, 0xbc, 0x23, 0x00, 0xd9, 0xbd, 0x23, 0x40, 0x49, - 0xbb, 0xb5, 0x9b, 0xcc, 0x01, 0x4f, 0xdc, 0x6c, 0x09, 0xcc, 0x41, 0x44, - 0x65, 0xed, 0x81, 0xfb, 0x01, 0xd2, 0x76, 0xfb, 0x01, 0xd3, 0x77, 0xfb, - 0x01, 0xd4, 0x78, 0xfb, 0x01, 0xd5, 0x79, 0xfb, 0x01, 0xd6, 0x7a, 0xfb, - 0x01, 0xd7, 0x7b, 0xfb, 0x41, 0x45, 0x27, 0xe4, 0x85, 0xcc, 0x01, 0x04, - 0xee, 0x07, 0x01, 0xff, 0x49, 0xc8, 0x58, 0xaf, 0x23, 0x00, 0x05, 0x51, - 0x00, 0x01, 0xff, 0x4f, 0x63, 0x6d, 0x91, 0xcc, 0x01, 0xb4, 0x01, 0xff, - 0x4f, 0xf8, 0x07, 0x12, 0xce, 0x01, 0x48, 0xfe, 0x07, 0x0f, 0xce, 0x41, - 0x42, 0x17, 0x00, 0x15, 0x20, 0x00, 0x05, 0x0d, 0x03, 0x01, 0xff, 0x47, - 0xa6, 0xd1, 0x23, 0x2b, 0x00, 0x47, 0xc1, 0xd3, 0xc3, 0x2b, 0x40, 0x44, - 0x53, 0x50, 0x6f, 0xf3, 0x01, 0x43, 0xae, 0xb6, 0x1d, 0xf4, 0x41, 0xe5, - 0x73, 0xf5, 0x01, 0x59, 0xcc, 0x24, 0x68, 0xf6, 0xc1, 0x00, 0x50, 0x3e, - 0x11, 0x69, 0xf6, 0x41, 0x46, 0x48, 0xda, 0x3a, 0xf3, 0x01, 0x02, 0x40, - 0x00, 0xe1, 0x03, 0x49, 0x2e, 0xbb, 0x7e, 0xf9, 0x01, 0x4a, 0x78, 0xae, - 0xd5, 0xf6, 0x01, 0x4a, 0xe0, 0xaf, 0x9b, 0xf9, 0x01, 0x07, 0x48, 0x12, - 0x06, 0x4b, 0x19, 0xa3, 0xec, 0x26, 0x40, 0x4c, 0x20, 0x8e, 0x9f, 0x30, - 0x00, 0x4e, 0x5a, 0x20, 0x9d, 0x30, 0x00, 0x07, 0xec, 0x05, 0x06, 0x55, - 0x11, 0x3f, 0x9e, 0x30, 0x40, 0xe1, 0x42, 0x30, 0x80, 0x98, 0x03, 0xa2, - 0x81, 0x03, 0xa4, 0xea, 0x02, 0xe5, 0x48, 0x30, 0x00, 0xa7, 0xcf, 0x02, - 0xa8, 0xb8, 0x02, 0xe9, 0x44, 0x30, 0x00, 0xab, 0x9d, 0x02, 0xad, 0x86, - 0x02, 0xee, 0x93, 0x30, 0x80, 0xec, 0x01, 0xef, 0x4a, 0x30, 0x00, 0xb0, - 0xd1, 0x01, 0xb2, 0xba, 0x01, 0xb3, 0x57, 0xb4, 0x41, 0xf5, 0x46, 0x30, - 0x00, 0x42, 0x6e, 0x62, 0x94, 0x30, 0x00, 0xb7, 0x25, 0xb9, 0x17, 0xba, - 0x01, 0xff, 0xe1, 0x56, 0x30, 0x00, 0xe5, 0x5c, 0x30, 0x00, 0xe9, 0x58, - 0x30, 0x00, 0xef, 0x5e, 0x30, 0x00, 0xf5, 0x5a, 0x30, 0x40, 0xe1, 0x84, - 0x30, 0x00, 0xef, 0x88, 0x30, 0x00, 0xf5, 0x86, 0x30, 0x40, 0xe1, 0x8f, - 0x30, 0x00, 0xe5, 0x91, 0x30, 0x00, 0xe9, 0x90, 0x30, 0x00, 0xef, 0x92, - 0x30, 0x40, 0xe1, 0x5f, 0x30, 0x00, 0xe5, 0x66, 0x30, 0x00, 0xe9, 0x61, - 0x30, 0x00, 0xef, 0x68, 0x30, 0x00, 0xf5, 0x64, 0x30, 0x40, 0xe1, 0x55, - 0x30, 0x00, 0xe5, 0x5b, 0x30, 0x00, 0xe9, 0x57, 0x30, 0x00, 0x05, 0x5e, - 0x07, 0x08, 0xef, 0x5d, 0x30, 0x00, 0xf5, 0x59, 0x30, 0x40, 0xe1, 0x41, - 0x30, 0x00, 0xe5, 0x47, 0x30, 0x00, 0xe9, 0x43, 0x30, 0x00, 0xab, 0x2f, - 0xef, 0x49, 0x30, 0x00, 0x42, 0x5c, 0x01, 0x63, 0x30, 0x00, 0xf5, 0x45, - 0x30, 0x00, 0xb7, 0x0f, 0xb9, 0x01, 0xff, 0xe1, 0x83, 0x30, 0x00, 0xef, - 0x87, 0x30, 0x00, 0xf5, 0x85, 0x30, 0x40, 0xe1, 0x8e, 0x30, 0x00, 0xe5, - 0x51, 0xb1, 0x01, 0xe9, 0x50, 0xb1, 0x01, 0xef, 0x52, 0xb1, 0x41, 0xe1, - 0x95, 0x30, 0x00, 0xe5, 0x96, 0x30, 0x00, 0xef, 0x32, 0xb1, 0x41, 0xe1, - 0x89, 0x30, 0x00, 0xe5, 0x8c, 0x30, 0x00, 0xe9, 0x8a, 0x30, 0x00, 0xef, - 0x8d, 0x30, 0x00, 0xf5, 0x8b, 0x30, 0x40, 0xe1, 0x71, 0x30, 0x00, 0xe5, - 0x7a, 0x30, 0x00, 0xe9, 0x74, 0x30, 0x00, 0xef, 0x7d, 0x30, 0x00, 0xf5, - 0x77, 0x30, 0x40, 0xe1, 0x6a, 0x30, 0x00, 0xe5, 0x6d, 0x30, 0x00, 0xe9, - 0x6b, 0x30, 0x00, 0xef, 0x6e, 0x30, 0x00, 0xf5, 0x6c, 0x30, 0x40, 0xe1, - 0x7e, 0x30, 0x00, 0xe5, 0x81, 0x30, 0x00, 0xe9, 0x7f, 0x30, 0x00, 0xef, - 0x82, 0x30, 0x00, 0xf5, 0x80, 0x30, 0x40, 0xe1, 0x4b, 0x30, 0x00, 0xe5, - 0x51, 0x30, 0x00, 0xe9, 0x4d, 0x30, 0x00, 0xef, 0x53, 0x30, 0x00, 0xf5, - 0x4f, 0x30, 0x40, 0xe1, 0x6f, 0x30, 0x00, 0xe5, 0x78, 0x30, 0x00, 0xe9, - 0x72, 0x30, 0x00, 0xef, 0x7b, 0x30, 0x00, 0xf5, 0x75, 0x30, 0x40, 0xe1, - 0x4c, 0x30, 0x00, 0xe5, 0x52, 0x30, 0x00, 0xe9, 0x4e, 0x30, 0x00, 0xef, - 0x54, 0x30, 0x00, 0xf5, 0x50, 0x30, 0x40, 0xe1, 0x60, 0x30, 0x00, 0xe5, - 0x67, 0x30, 0x00, 0xe9, 0x62, 0x30, 0x00, 0xef, 0x69, 0x30, 0x00, 0xf5, - 0x65, 0x30, 0x40, 0xe1, 0x70, 0x30, 0x00, 0xe5, 0x79, 0x30, 0x00, 0xe9, - 0x73, 0x30, 0x00, 0xef, 0x7c, 0x30, 0x00, 0xf5, 0x76, 0x30, 0x40, 0x07, - 0xb9, 0x80, 0x01, 0xff, 0x42, 0x97, 0x31, 0x1f, 0xb1, 0x01, 0x42, 0x4d, - 0x00, 0x01, 0xb0, 0x41, 0x80, 0x16, 0x8d, 0x01, 0xff, 0x4b, 0xff, 0x9c, - 0x60, 0xf4, 0x01, 0x4b, 0xe2, 0xa2, 0x84, 0xf6, 0xc1, 0x00, 0x51, 0x6c, - 0x57, 0x85, 0xf6, 0x41, 0x51, 0xd1, 0x58, 0x06, 0xf5, 0x01, 0x4c, 0x00, - 0x93, 0x81, 0x00, 0x00, 0x4c, 0xfc, 0x96, 0xa1, 0x26, 0x40, 0xa1, 0x8a, - 0x17, 0xa2, 0x8f, 0x0f, 0x46, 0x08, 0xdb, 0x94, 0xf9, 0x01, 0xac, 0xeb, - 0x0e, 0x10, 0x6d, 0x65, 0xf0, 0x03, 0xb2, 0xe3, 0x03, 0x0b, 0x60, 0xa5, - 0x01, 0xff, 0xa1, 0xc9, 0x03, 0xa2, 0xb4, 0x03, 0x02, 0x13, 0x05, 0x9a, - 0x03, 0xa4, 0xe9, 0x02, 0x4a, 0x22, 0xaa, 0xcf, 0x4d, 0x00, 0xa6, 0xd4, - 0x02, 0xa7, 0xa1, 0x02, 0x50, 0x8d, 0x63, 0xc7, 0x4d, 0x00, 0x02, 0x9e, - 0x01, 0xfb, 0x01, 0x4a, 0x38, 0xad, 0xfb, 0x4d, 0x00, 0x02, 0xc3, 0x07, - 0xe4, 0x01, 0xaf, 0xca, 0x01, 0xb0, 0xb5, 0x01, 0x02, 0x88, 0x00, 0x9c, - 0x01, 0xb3, 0x7e, 0xb4, 0x14, 0xb7, 0x06, 0x4e, 0x08, 0x7f, 0xc3, 0x4d, - 0x40, 0x46, 0x06, 0x89, 0xc4, 0x4d, 0x00, 0x52, 0x26, 0x54, 0xd1, 0x4d, - 0x40, 0x03, 0xc5, 0x0b, 0x06, 0x47, 0xfb, 0x11, 0xc9, 0x4d, 0x40, 0xa1, - 0x47, 0xa3, 0x33, 0x46, 0xd4, 0xdb, 0xe4, 0x4d, 0x00, 0x4b, 0x7b, 0x9c, - 0xf8, 0x4d, 0x00, 0x4b, 0x12, 0x9e, 0xf9, 0x4d, 0x00, 0x56, 0x10, 0x35, - 0xf3, 0x4d, 0x00, 0x4f, 0x33, 0x70, 0xf5, 0x4d, 0x00, 0x4f, 0x4f, 0x72, - 0xc1, 0x4d, 0x00, 0xb7, 0x01, 0xff, 0x47, 0xea, 0xce, 0xf7, 0x4d, 0x00, - 0x43, 0x5f, 0x09, 0xef, 0x4d, 0x40, 0x47, 0x53, 0xcf, 0xf1, 0x4d, 0x00, - 0x4c, 0x50, 0x91, 0xdd, 0x4d, 0x00, 0x4e, 0x96, 0x7b, 0xc0, 0x4d, 0x40, - 0x4c, 0x24, 0x8d, 0xdc, 0x4d, 0x00, 0xb2, 0x01, 0xff, 0x42, 0xaa, 0x58, - 0xc6, 0x4d, 0x00, 0x4e, 0xee, 0x7a, 0xf2, 0x4d, 0x40, 0x05, 0x5e, 0x07, - 0x0c, 0x4e, 0x50, 0x7b, 0xd6, 0x4d, 0x00, 0x49, 0xc9, 0xbf, 0xcb, 0x4d, - 0x40, 0x4d, 0xad, 0x87, 0xfd, 0x4d, 0x00, 0x46, 0x7e, 0xe0, 0xc8, 0x4d, - 0x40, 0xb4, 0x06, 0x48, 0x69, 0xcc, 0xf0, 0x4d, 0x40, 0x44, 0x88, 0x00, - 0xe0, 0x4d, 0x00, 0x43, 0x5d, 0x01, 0xd7, 0x4d, 0x40, 0x44, 0xee, 0xa4, - 0xca, 0x4d, 0x00, 0x47, 0x88, 0xd5, 0xe2, 0x4d, 0x00, 0x4d, 0xe9, 0x89, - 0xed, 0x4d, 0x40, 0x4a, 0x88, 0xa8, 0xe6, 0x4d, 0x00, 0x02, 0x6e, 0x02, - 0x01, 0xff, 0x47, 0x0d, 0x17, 0xe5, 0x4d, 0x00, 0x47, 0x8d, 0x66, 0xee, - 0x4d, 0x40, 0x45, 0xad, 0xe5, 0xce, 0x4d, 0x00, 0x4b, 0xb0, 0xa4, 0xda, - 0x4d, 0x40, 0x46, 0xde, 0xda, 0xe9, 0x4d, 0x00, 0x47, 0x44, 0xd1, 0xde, - 0x4d, 0x00, 0xae, 0x01, 0xff, 0x48, 0xd1, 0xc5, 0xfc, 0x4d, 0x00, 0x46, - 0xc2, 0xde, 0xd8, 0x4d, 0x40, 0x51, 0x6b, 0x58, 0xec, 0x4d, 0x00, 0xb2, - 0x01, 0xff, 0x43, 0x0d, 0x08, 0xd5, 0x4d, 0x00, 0x04, 0x60, 0x55, 0x01, - 0xff, 0xb0, 0x06, 0x46, 0x7e, 0xe0, 0xd9, 0x4d, 0x40, 0xaf, 0x06, 0x4c, - 0xae, 0x87, 0xdb, 0x4d, 0x40, 0x48, 0xc3, 0x52, 0xcd, 0x4d, 0x00, 0x43, - 0x15, 0x01, 0xe1, 0x4d, 0x40, 0x49, 0x70, 0xb8, 0xcc, 0x4d, 0x00, 0x48, - 0x41, 0xc9, 0xd0, 0x4d, 0x40, 0x55, 0x7d, 0x39, 0xe3, 0x4d, 0x00, 0xa5, - 0x14, 0xa9, 0x06, 0x47, 0x10, 0xd7, 0xdf, 0x4d, 0x40, 0x59, 0x36, 0x24, - 0xc2, 0x4d, 0x00, 0x48, 0x41, 0xcb, 0xfa, 0x4d, 0x40, 0x46, 0xde, 0xda, - 0xe8, 0x4d, 0x00, 0x49, 0xac, 0xbb, 0xe7, 0x4d, 0x00, 0x49, 0xfb, 0xc0, - 0xf4, 0x4d, 0x40, 0x4c, 0x28, 0x92, 0xeb, 0x4d, 0x00, 0xae, 0x01, 0xff, - 0x45, 0x8e, 0xe6, 0xc5, 0x4d, 0x00, 0x4a, 0xd4, 0xb1, 0xd3, 0x4d, 0x40, - 0x50, 0x9d, 0x62, 0xff, 0x4d, 0x00, 0x4d, 0xa1, 0x84, 0xd4, 0x4d, 0x00, - 0x4b, 0xfb, 0xa1, 0xea, 0x4d, 0x40, 0x48, 0x81, 0xc4, 0xf6, 0x4d, 0x00, - 0x4f, 0x81, 0x6d, 0xfe, 0x4d, 0x00, 0x47, 0xf5, 0xd4, 0xd2, 0x4d, 0x40, - 0xe2, 0x3f, 0xf3, 0x01, 0x57, 0xcc, 0x2f, 0xb9, 0x22, 0x40, 0x02, 0x81, - 0x2b, 0xdf, 0x0a, 0x02, 0x08, 0x02, 0xc2, 0x0a, 0xa8, 0x99, 0x09, 0x02, - 0x39, 0x37, 0x84, 0x09, 0xab, 0xd3, 0x07, 0xad, 0xcd, 0x06, 0xae, 0xa4, - 0x05, 0x02, 0x23, 0x32, 0x93, 0x05, 0xb2, 0x8f, 0x04, 0xb3, 0xef, 0x02, - 0xb4, 0xd2, 0x01, 0x02, 0xd8, 0x39, 0xb9, 0x01, 0xb7, 0x52, 0xb9, 0x01, - 0xff, 0x02, 0x81, 0x2b, 0x31, 0x02, 0x23, 0x32, 0x15, 0x02, 0xd8, 0x39, - 0x01, 0xff, 0xd1, 0xe3, 0xb0, 0x01, 0xd2, 0xe4, 0xb0, 0x01, 0xd3, 0xe5, - 0xb0, 0x01, 0xd4, 0xe6, 0xb0, 0x41, 0xd1, 0xe7, 0xb0, 0x01, 0xd2, 0xe8, - 0xb0, 0x01, 0xd3, 0xe9, 0xb0, 0x01, 0xd4, 0xea, 0xb0, 0x01, 0xd5, 0xeb, - 0xb0, 0x01, 0xd6, 0xec, 0xb0, 0x41, 0xd1, 0xdd, 0xb0, 0x01, 0xd2, 0xde, - 0xb0, 0x01, 0xd3, 0xdf, 0xb0, 0x01, 0xd4, 0xe0, 0xb0, 0x01, 0xd5, 0xe1, - 0xb0, 0x01, 0x42, 0xb0, 0x47, 0xe2, 0xb0, 0x41, 0x02, 0x81, 0x2b, 0x4d, - 0x02, 0x08, 0x02, 0x39, 0x02, 0x39, 0x37, 0x21, 0x02, 0x23, 0x32, 0x01, - 0xff, 0xd1, 0x16, 0xb1, 0x01, 0xd2, 0x17, 0xb1, 0x01, 0xd3, 0x18, 0xb1, - 0x01, 0xd4, 0x19, 0xb1, 0x01, 0xd5, 0x1a, 0xb1, 0x01, 0xd6, 0x1b, 0xb1, - 0x01, 0xd7, 0x1c, 0xb1, 0x41, 0xd1, 0x0d, 0xb1, 0x01, 0xd2, 0x0e, 0xb1, - 0x01, 0xd3, 0x0f, 0xb1, 0x01, 0xd4, 0x10, 0xb1, 0x01, 0xd5, 0x11, 0xb1, - 0x41, 0xd1, 0x12, 0xb1, 0x01, 0xd2, 0x13, 0xb1, 0x01, 0xd3, 0x14, 0xb1, - 0x01, 0xd4, 0x15, 0xb1, 0x41, 0xd1, 0x08, 0xb1, 0x01, 0xd2, 0x09, 0xb1, - 0x01, 0xd3, 0x0a, 0xb1, 0x01, 0xd4, 0x0b, 0xb1, 0x01, 0xd5, 0x0c, 0xb1, - 0x41, 0xd1, 0x0a, 0xb0, 0x01, 0xd2, 0x0b, 0xb0, 0x01, 0xd3, 0x0c, 0xb0, - 0x01, 0xd4, 0x0d, 0xb0, 0x01, 0xd5, 0x0e, 0xb0, 0x41, 0x02, 0x81, 0x2b, - 0x85, 0x01, 0x02, 0x08, 0x02, 0x5d, 0x02, 0x39, 0x37, 0x3d, 0x02, 0x23, - 0x32, 0x1b, 0x02, 0xd8, 0x39, 0x01, 0xff, 0xd1, 0x69, 0xb0, 0x01, 0xd2, - 0x6a, 0xb0, 0x01, 0xd3, 0x6b, 0xb0, 0x01, 0xd4, 0x6c, 0xb0, 0x01, 0x42, - 0x1e, 0x00, 0x6d, 0xb0, 0x41, 0xd1, 0x77, 0xb0, 0x01, 0xd2, 0x78, 0xb0, - 0x01, 0xd3, 0x79, 0xb0, 0x01, 0xd4, 0x7a, 0xb0, 0x01, 0xd5, 0x7b, 0xb0, - 0x01, 0xd6, 0x7c, 0xb0, 0x01, 0x42, 0x71, 0x00, 0x7d, 0xb0, 0x41, 0xd1, - 0x62, 0xb0, 0x01, 0xd2, 0x63, 0xb0, 0x01, 0xd3, 0x64, 0xb0, 0x01, 0xd4, - 0x65, 0xb0, 0x01, 0xd5, 0x66, 0xb0, 0x01, 0xd6, 0x67, 0xb0, 0x01, 0xd7, - 0x68, 0xb0, 0x41, 0xd1, 0x6e, 0xb0, 0x01, 0xd2, 0x6f, 0xb0, 0x01, 0xd3, - 0x70, 0xb0, 0x01, 0xd4, 0x71, 0xb0, 0x01, 0xd5, 0x72, 0xb0, 0x01, 0xd6, - 0x73, 0xb0, 0x01, 0xd7, 0x74, 0xb0, 0x01, 0xd8, 0x75, 0xb0, 0x01, 0xd9, - 0x76, 0xb0, 0x41, 0xd1, 0x5e, 0xb0, 0x01, 0xd2, 0x5f, 0xb0, 0x01, 0xd3, - 0x60, 0xb0, 0x01, 0xd4, 0x61, 0xb0, 0x41, 0x02, 0x81, 0x2b, 0x79, 0x02, - 0x08, 0x02, 0x61, 0x02, 0x39, 0x37, 0x45, 0x02, 0x23, 0x32, 0x25, 0x02, - 0xd8, 0x39, 0x01, 0xff, 0xd1, 0x4a, 0xb0, 0x01, 0xd2, 0x4b, 0xb0, 0x01, - 0xd3, 0x4c, 0xb0, 0x01, 0xd4, 0x4d, 0xb0, 0x01, 0xd5, 0x4e, 0xb0, 0x01, - 0xd6, 0x4f, 0xb0, 0x01, 0xd7, 0x50, 0xb0, 0x01, 0xd8, 0x51, 0xb0, 0x41, - 0xd1, 0x57, 0xb0, 0x01, 0xd2, 0x58, 0xb0, 0x01, 0xd3, 0x59, 0xb0, 0x01, - 0xd4, 0x5a, 0xb0, 0x01, 0xd5, 0x5b, 0xb0, 0x01, 0xd6, 0x5c, 0xb0, 0x01, - 0xd7, 0x5d, 0xb0, 0x41, 0xd1, 0x44, 0xb0, 0x01, 0xd2, 0x45, 0xb0, 0x01, - 0xd3, 0x46, 0xb0, 0x01, 0xd4, 0x47, 0xb0, 0x01, 0xd5, 0x48, 0xb0, 0x01, - 0xd6, 0x49, 0xb0, 0x41, 0xd1, 0x52, 0xb0, 0x01, 0xd2, 0x53, 0xb0, 0x01, - 0xd3, 0x54, 0xb0, 0x01, 0xd4, 0x55, 0xb0, 0x01, 0xd5, 0x56, 0xb0, 0x41, - 0xd1, 0x3c, 0xb0, 0x01, 0xd2, 0x3d, 0xb0, 0x01, 0xd3, 0x3e, 0xb0, 0x01, - 0xd4, 0x3f, 0xb0, 0x01, 0xd5, 0x40, 0xb0, 0x01, 0xd6, 0x41, 0xb0, 0x01, - 0xd7, 0x42, 0xb0, 0x01, 0xd8, 0x43, 0xb0, 0x41, 0x02, 0x81, 0x2b, 0x6d, - 0x02, 0x08, 0x02, 0x59, 0x02, 0x39, 0x37, 0x39, 0x02, 0x23, 0x32, 0x1d, - 0x02, 0xd8, 0x39, 0x01, 0xff, 0xd1, 0xf8, 0xb0, 0x01, 0xd2, 0xf9, 0xb0, - 0x01, 0xd3, 0xfa, 0xb0, 0x01, 0xd4, 0xfb, 0xb0, 0x01, 0xd5, 0xfc, 0xb0, - 0x01, 0xd6, 0xfd, 0xb0, 0x41, 0xd1, 0x02, 0xb1, 0x01, 0xd2, 0x03, 0xb1, - 0x01, 0xd3, 0x04, 0xb1, 0x01, 0xd4, 0x05, 0xb1, 0x01, 0xd5, 0x06, 0xb1, - 0x01, 0xd6, 0x07, 0xb1, 0x41, 0xd1, 0xf1, 0xb0, 0x01, 0xd2, 0xf2, 0xb0, - 0x01, 0xd3, 0xf3, 0xb0, 0x01, 0xd4, 0xf4, 0xb0, 0x01, 0xd5, 0xf5, 0xb0, - 0x01, 0xd6, 0xf6, 0xb0, 0x01, 0xd7, 0xf7, 0xb0, 0x41, 0xd1, 0xfe, 0xb0, - 0x01, 0xd2, 0xff, 0xb0, 0x01, 0xd3, 0x00, 0xb1, 0x01, 0xd4, 0x01, 0xb1, - 0x41, 0xd1, 0xed, 0xb0, 0x01, 0xd2, 0xee, 0xb0, 0x01, 0xd3, 0xef, 0xb0, - 0x01, 0xd4, 0xf0, 0xb0, 0x41, 0xd1, 0x14, 0xb0, 0x01, 0xd2, 0x15, 0xb0, - 0x01, 0xd3, 0x16, 0xb0, 0x41, 0x07, 0xe7, 0xcd, 0x99, 0x01, 0x02, 0x81, - 0x2b, 0x71, 0x02, 0x08, 0x02, 0x4f, 0x02, 0x39, 0x37, 0x29, 0x02, 0x23, - 0x32, 0x11, 0x02, 0xd8, 0x39, 0x01, 0xff, 0xd1, 0x8f, 0xb0, 0x01, 0xd2, - 0x90, 0xb0, 0x01, 0xd3, 0x91, 0xb0, 0x41, 0xd1, 0x99, 0xb0, 0x01, 0xd2, - 0x9a, 0xb0, 0x01, 0xd3, 0x9b, 0xb0, 0x01, 0xd4, 0x9c, 0xb0, 0x01, 0xd5, - 0x9d, 0xb0, 0x41, 0xd1, 0x87, 0xb0, 0x01, 0xd2, 0x88, 0xb0, 0x01, 0xd3, - 0x89, 0xb0, 0x01, 0xd4, 0x8a, 0xb0, 0x01, 0xd5, 0x8b, 0xb0, 0x01, 0xd6, - 0x8c, 0xb0, 0x01, 0xd7, 0x8d, 0xb0, 0x01, 0x42, 0x77, 0x00, 0x8e, 0xb0, - 0x41, 0xd1, 0x92, 0xb0, 0x01, 0xd2, 0x93, 0xb0, 0x01, 0xd3, 0x94, 0xb0, - 0x01, 0xd4, 0x95, 0xb0, 0x01, 0xd5, 0x96, 0xb0, 0x01, 0xd6, 0x97, 0xb0, - 0x01, 0x42, 0x4d, 0x03, 0x98, 0xb0, 0x41, 0xd1, 0x7e, 0xb0, 0x01, 0xd2, - 0x7f, 0xb0, 0x01, 0xd3, 0x80, 0xb0, 0x01, 0xd4, 0x81, 0xb0, 0x01, 0xd5, - 0x82, 0xb0, 0x01, 0xd6, 0x83, 0xb0, 0x01, 0xd7, 0x84, 0xb0, 0x01, 0xd8, - 0x85, 0xb0, 0x01, 0xd9, 0x86, 0xb0, 0x41, 0xd1, 0x1d, 0xb1, 0x01, 0xd2, - 0x1e, 0xb1, 0x41, 0x02, 0x81, 0x2b, 0x63, 0x02, 0x08, 0x02, 0x51, 0x02, - 0x39, 0x37, 0x31, 0x02, 0x23, 0x32, 0x15, 0x02, 0xd8, 0x39, 0x01, 0xff, - 0xd1, 0xd0, 0xb0, 0x01, 0xd2, 0xd1, 0xb0, 0x01, 0xd3, 0xd2, 0xb0, 0x01, - 0xd4, 0xd3, 0xb0, 0x41, 0xd1, 0xd7, 0xb0, 0x01, 0xd2, 0xd8, 0xb0, 0x01, - 0xd3, 0xd9, 0xb0, 0x01, 0xd4, 0xda, 0xb0, 0x01, 0xd5, 0xdb, 0xb0, 0x01, - 0xd6, 0xdc, 0xb0, 0x41, 0xd1, 0xc9, 0xb0, 0x01, 0xd2, 0xca, 0xb0, 0x01, - 0xd3, 0xcb, 0xb0, 0x01, 0xd4, 0xcc, 0xb0, 0x01, 0xd5, 0xcd, 0xb0, 0x01, - 0xd6, 0xce, 0xb0, 0x01, 0xd7, 0xcf, 0xb0, 0x41, 0xd1, 0xd4, 0xb0, 0x01, - 0xd2, 0xd5, 0xb0, 0x01, 0x42, 0x6c, 0x00, 0xd6, 0xb0, 0x41, 0xd1, 0xc2, - 0xb0, 0x01, 0xd2, 0xc3, 0xb0, 0x01, 0xd3, 0xc4, 0xb0, 0x01, 0xd4, 0xc5, - 0xb0, 0x01, 0xd5, 0xc6, 0xb0, 0x01, 0xd6, 0xc7, 0xb0, 0x01, 0xd7, 0xc8, - 0xb0, 0x41, 0x02, 0x81, 0x2b, 0x77, 0x02, 0x08, 0x02, 0x5b, 0x02, 0x39, - 0x37, 0x37, 0x02, 0x23, 0x32, 0x21, 0x02, 0xd8, 0x39, 0x01, 0xff, 0xd1, - 0x2b, 0xb0, 0x01, 0xd2, 0x2c, 0xb0, 0x01, 0xd3, 0x2d, 0xb0, 0x01, 0xd4, - 0x2e, 0xb0, 0x01, 0xd5, 0x2f, 0xb0, 0x01, 0xd6, 0x30, 0xb0, 0x01, 0xd7, - 0x31, 0xb0, 0x41, 0xd1, 0x38, 0xb0, 0x01, 0xd2, 0x39, 0xb0, 0x01, 0xd3, - 0x3a, 0xb0, 0x01, 0x42, 0x45, 0x00, 0x3b, 0xb0, 0x41, 0xd1, 0x23, 0xb0, - 0x01, 0xd2, 0x24, 0xb0, 0x01, 0xd3, 0x25, 0xb0, 0x01, 0xd4, 0x26, 0xb0, - 0x01, 0xd5, 0x27, 0xb0, 0x01, 0xd6, 0x28, 0xb0, 0x01, 0xd7, 0x29, 0xb0, - 0x01, 0xd8, 0x2a, 0xb0, 0x41, 0xd1, 0x32, 0xb0, 0x01, 0xd2, 0x33, 0xb0, - 0x01, 0xd3, 0x34, 0xb0, 0x01, 0xd4, 0x35, 0xb0, 0x01, 0xd5, 0x36, 0xb0, - 0x01, 0xd6, 0x37, 0xb0, 0x41, 0xd1, 0x17, 0xb0, 0x81, 0x26, 0xd2, 0x18, - 0xb0, 0x01, 0xd3, 0x19, 0xb0, 0x01, 0xd4, 0x1a, 0xb0, 0x01, 0xd5, 0x1b, - 0xb0, 0x01, 0xd6, 0x1c, 0xb0, 0x01, 0xd7, 0x1d, 0xb0, 0x01, 0xd8, 0x1e, - 0xb0, 0x01, 0xd9, 0x1f, 0xb0, 0x01, 0x42, 0x37, 0x01, 0x22, 0xb0, 0x41, - 0xd0, 0x20, 0xb0, 0x01, 0xd1, 0x21, 0xb0, 0x41, 0xd1, 0x06, 0xb0, 0x01, - 0xd2, 0x07, 0xb0, 0x01, 0xd3, 0x08, 0xb0, 0x01, 0xd4, 0x09, 0xb0, 0x41, - 0x02, 0x81, 0x2b, 0x75, 0x02, 0x08, 0x02, 0x55, 0x02, 0x39, 0x37, 0x35, - 0x02, 0x23, 0x32, 0x11, 0x02, 0xd8, 0x39, 0x01, 0xff, 0xd1, 0xb0, 0xb0, - 0x01, 0xd2, 0xb1, 0xb0, 0x01, 0xd3, 0xb2, 0xb0, 0x41, 0xd1, 0xba, 0xb0, - 0x01, 0xd2, 0xbb, 0xb0, 0x01, 0xd3, 0xbc, 0xb0, 0x01, 0xd4, 0xbd, 0xb0, - 0x01, 0xd5, 0xbe, 0xb0, 0x01, 0xd6, 0xbf, 0xb0, 0x01, 0xd7, 0xc0, 0xb0, - 0x01, 0xd8, 0xc1, 0xb0, 0x41, 0xd1, 0xa9, 0xb0, 0x01, 0xd2, 0xaa, 0xb0, - 0x01, 0xd3, 0xab, 0xb0, 0x01, 0xd4, 0xac, 0xb0, 0x01, 0xd5, 0xad, 0xb0, - 0x01, 0xd6, 0xae, 0xb0, 0x01, 0xd7, 0xaf, 0xb0, 0x41, 0xd1, 0xb3, 0xb0, - 0x01, 0xd2, 0xb4, 0xb0, 0x01, 0xd3, 0xb5, 0xb0, 0x01, 0xd4, 0xb6, 0xb0, - 0x01, 0xd5, 0xb7, 0xb0, 0x01, 0xd6, 0xb8, 0xb0, 0x01, 0xd7, 0xb9, 0xb0, - 0x41, 0xd1, 0x9e, 0xb0, 0x81, 0x20, 0xd2, 0x9f, 0xb0, 0x01, 0xd3, 0xa0, - 0xb0, 0x01, 0xd4, 0xa1, 0xb0, 0x01, 0xd5, 0xa2, 0xb0, 0x01, 0xd6, 0xa3, - 0xb0, 0x01, 0xd7, 0xa4, 0xb0, 0x01, 0xd8, 0xa5, 0xb0, 0x01, 0xd9, 0xa6, - 0xb0, 0x41, 0xd0, 0xa7, 0xb0, 0x01, 0xd1, 0xa8, 0xb0, 0x41, 0xd1, 0x01, - 0xb0, 0x01, 0xd2, 0x0f, 0xb0, 0x01, 0xd3, 0x10, 0xb0, 0x01, 0xd4, 0x11, - 0xb0, 0x01, 0xd5, 0x12, 0xb0, 0x01, 0xd6, 0x13, 0xb0, 0x41, 0xd1, 0x02, - 0xb0, 0x01, 0xd2, 0x03, 0xb0, 0x01, 0xd3, 0x04, 0xb0, 0x01, 0x42, 0x15, - 0x02, 0x05, 0xb0, 0x41, 0x47, 0xf3, 0xd1, 0x81, 0xf6, 0x01, 0x57, 0xb5, - 0x2f, 0xff, 0x2b, 0x00, 0xad, 0x01, 0xff, 0x47, 0x15, 0x08, 0x88, 0x23, - 0x00, 0x53, 0x4c, 0x49, 0xd1, 0x26, 0x40, 0xe5, 0xc0, 0xce, 0x01, 0x04, - 0x69, 0xf2, 0x01, 0xff, 0x07, 0x1d, 0x23, 0x8a, 0x06, 0xac, 0xd0, 0x01, - 0x05, 0xb9, 0x00, 0xb9, 0x01, 0xb0, 0x06, 0x4c, 0x5c, 0x97, 0xef, 0x05, - 0x40, 0x05, 0xc9, 0x17, 0x2d, 0x0b, 0x6e, 0x16, 0x01, 0xff, 0x03, 0xdb, - 0x09, 0x18, 0x45, 0x96, 0xe8, 0xbe, 0x05, 0x00, 0x4b, 0x7a, 0xa0, 0xc6, - 0x05, 0x00, 0x45, 0xdb, 0xe9, 0xc0, 0x05, 0x00, 0x49, 0x6f, 0xbf, 0xc3, - 0x05, 0x40, 0x43, 0x9a, 0x5a, 0xf3, 0x05, 0x00, 0x46, 0xf4, 0xdf, 0xf4, - 0x05, 0x40, 0x4f, 0xec, 0x6b, 0xbc, 0x05, 0x00, 0xa8, 0x4f, 0x54, 0xb3, - 0x43, 0x1e, 0xfb, 0x00, 0x45, 0xb9, 0xe8, 0xbd, 0x05, 0x00, 0x45, 0xf5, - 0x8a, 0xb7, 0x05, 0x00, 0xb1, 0x28, 0x44, 0x5d, 0xf2, 0xbf, 0x05, 0x00, - 0xb3, 0x06, 0x45, 0xac, 0xeb, 0xb5, 0x05, 0x40, 0x44, 0xea, 0xea, 0xb6, - 0x05, 0x00, 0xa8, 0x06, 0x46, 0x19, 0x4e, 0xc2, 0x05, 0x40, 0x43, 0x96, - 0x46, 0xb0, 0x05, 0x00, 0x46, 0x19, 0x4e, 0xc1, 0x05, 0x40, 0x45, 0x77, - 0xdf, 0xb8, 0x05, 0x80, 0x06, 0x45, 0xd9, 0xeb, 0xbb, 0x05, 0x40, 0x46, - 0x5c, 0xd8, 0xc7, 0x05, 0x40, 0x05, 0x9f, 0xe4, 0x13, 0x44, 0x25, 0xe7, - 0xb4, 0x05, 0x00, 0x44, 0x34, 0xe7, 0xb9, 0x05, 0xc0, 0x00, 0x4e, 0x76, - 0x75, 0xba, 0x05, 0x40, 0x45, 0xf5, 0x8a, 0xb2, 0x05, 0x00, 0x46, 0x76, - 0xdf, 0xb3, 0x05, 0x00, 0x45, 0xe9, 0xea, 0xb1, 0x05, 0x40, 0x49, 0xd9, - 0xbb, 0xc5, 0x05, 0x00, 0x4d, 0xbf, 0x85, 0xaf, 0x05, 0x00, 0x49, 0x86, - 0xc0, 0xc4, 0x05, 0x40, 0x06, 0xed, 0x05, 0x2c, 0x08, 0x9f, 0x1f, 0x01, - 0xff, 0x4a, 0xb6, 0xa7, 0x4f, 0xfb, 0x00, 0x08, 0x01, 0xcd, 0x01, 0xff, - 0x07, 0x3b, 0x01, 0x0c, 0x47, 0x48, 0xd7, 0xf1, 0x05, 0x00, 0x4d, 0xed, - 0x8a, 0x1f, 0xfb, 0x40, 0x43, 0x79, 0x0f, 0xf0, 0x05, 0x00, 0x43, 0xa8, - 0x52, 0xf2, 0x05, 0x40, 0xa1, 0xcd, 0x03, 0x43, 0xc0, 0x09, 0xd1, 0x05, - 0x80, 0xb4, 0x03, 0x45, 0x2a, 0x4a, 0xd3, 0x05, 0x80, 0xa6, 0x03, 0x06, - 0x10, 0x2d, 0xf5, 0x02, 0x45, 0xfe, 0xaa, 0xd2, 0x05, 0x80, 0xe7, 0x02, - 0x42, 0xb0, 0x01, 0xd4, 0x05, 0x80, 0xd5, 0x02, 0x43, 0xae, 0x51, 0xdb, - 0x05, 0x80, 0xbc, 0x02, 0x45, 0xbb, 0xa7, 0xdc, 0x05, 0x80, 0xae, 0x02, - 0x43, 0xb4, 0x05, 0xde, 0x05, 0x80, 0xa0, 0x02, 0x43, 0xde, 0x22, 0xe0, - 0x05, 0x80, 0x92, 0x02, 0x42, 0x6f, 0x02, 0xe4, 0x05, 0x80, 0xf9, 0x01, - 0x43, 0xb8, 0xf4, 0xe7, 0x05, 0x80, 0xeb, 0x01, 0x44, 0x7d, 0x66, 0xe8, - 0x05, 0x80, 0xdd, 0x01, 0xb3, 0x9a, 0x01, 0xb4, 0x71, 0x43, 0x79, 0x0f, - 0xd5, 0x05, 0x80, 0x59, 0x05, 0x74, 0xec, 0x25, 0x43, 0xa8, 0x52, 0xd9, - 0x05, 0x80, 0x0d, 0x45, 0xa2, 0x52, 0xd6, 0x05, 0xc0, 0x00, 0x4c, 0xa4, - 0x8b, 0x36, 0xfb, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x46, 0xec, 0x6b, - 0x39, 0xfb, 0x00, 0x45, 0x24, 0xe7, 0x1d, 0xfb, 0x40, 0x44, 0x67, 0x00, - 0x21, 0xfb, 0x00, 0x45, 0x2a, 0x4a, 0x22, 0xfb, 0x00, 0x49, 0x00, 0xb9, - 0x26, 0xfb, 0x00, 0x42, 0xb0, 0x01, 0x23, 0xfb, 0x00, 0x43, 0xae, 0x51, - 0x24, 0xfb, 0x00, 0x45, 0xbb, 0xa7, 0x25, 0xfb, 0x00, 0x44, 0x7d, 0x66, - 0x27, 0xfb, 0x00, 0x43, 0x3a, 0x2a, 0x28, 0xfb, 0x40, 0x06, 0x50, 0x00, - 0x01, 0xff, 0x46, 0xec, 0x6b, 0x35, 0xfb, 0x00, 0x45, 0x33, 0xe7, 0x4b, - 0xfb, 0x40, 0x42, 0x2f, 0x08, 0xea, 0x05, 0x80, 0x1a, 0x42, 0xed, 0x05, - 0xd8, 0x05, 0x80, 0x0d, 0x44, 0xa3, 0xeb, 0xe6, 0x05, 0xc0, 0x00, 0x4c, - 0xa4, 0x8b, 0x46, 0xfb, 0x40, 0x4c, 0xa4, 0x8b, 0x38, 0xfb, 0x40, 0x4c, - 0xa4, 0x8b, 0x4a, 0xfb, 0x40, 0x45, 0x68, 0xe4, 0xe1, 0x05, 0x80, 0x33, - 0x43, 0x7a, 0x16, 0xe9, 0x05, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, - 0x46, 0xec, 0x6b, 0x49, 0xfb, 0x80, 0x0f, 0xb3, 0x01, 0xff, 0x47, 0x18, - 0x4e, 0x2a, 0xfb, 0x00, 0x46, 0x19, 0x4e, 0x2b, 0xfb, 0x40, 0x06, 0xd9, - 0x13, 0x01, 0xff, 0x47, 0x18, 0x4e, 0x2c, 0xfb, 0x00, 0x46, 0x19, 0x4e, - 0x2d, 0xfb, 0x40, 0x4c, 0xa4, 0x8b, 0x41, 0xfb, 0x40, 0x4c, 0xa4, 0x8b, - 0x48, 0xfb, 0x40, 0x4c, 0xa4, 0x8b, 0x47, 0xfb, 0x40, 0x06, 0x50, 0x00, - 0x01, 0xff, 0x46, 0xec, 0x6b, 0x44, 0xfb, 0x00, 0x44, 0x5d, 0xf2, 0x4e, - 0xfb, 0x40, 0x4c, 0xa4, 0x8b, 0x40, 0xfb, 0x40, 0x4c, 0xa4, 0x8b, 0x3e, - 0xfb, 0x40, 0x4c, 0xa4, 0x8b, 0x3c, 0xfb, 0x40, 0x06, 0x50, 0x00, 0x01, - 0xff, 0x46, 0xec, 0x6b, 0x3b, 0xfb, 0x00, 0x44, 0x5d, 0xf2, 0x4d, 0xfb, - 0x40, 0x4b, 0x45, 0x98, 0x34, 0xfb, 0x00, 0xf4, 0xd7, 0x05, 0x40, 0x4c, - 0xa4, 0x8b, 0x32, 0xfb, 0x40, 0x43, 0xae, 0x51, 0xda, 0x05, 0x80, 0x1f, - 0x43, 0xb4, 0x05, 0xdd, 0x05, 0x00, 0x43, 0xde, 0x22, 0xdf, 0x05, 0x00, - 0x42, 0x6f, 0x02, 0xe3, 0x05, 0x80, 0x06, 0x45, 0xa2, 0xeb, 0xe5, 0x05, - 0x40, 0x4c, 0xa4, 0x8b, 0x43, 0xfb, 0x40, 0x4c, 0xa4, 0x8b, 0x3a, 0xfb, - 0x40, 0x4c, 0xa4, 0x8b, 0x33, 0xfb, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, - 0x46, 0xec, 0x6b, 0x31, 0xfb, 0x00, 0x44, 0x5d, 0xf2, 0x4c, 0xfb, 0x40, - 0xac, 0x06, 0x43, 0x9a, 0x1a, 0xe2, 0x05, 0x40, 0x42, 0x69, 0x00, 0xd0, - 0x05, 0x80, 0x11, 0x0a, 0xde, 0xb1, 0x01, 0xff, 0x44, 0x25, 0x4a, 0x20, - 0xfb, 0x00, 0x49, 0xe6, 0x71, 0x29, 0xfb, 0x40, 0x06, 0x50, 0x00, 0x01, - 0xff, 0x45, 0xf6, 0x6b, 0x30, 0xfb, 0x00, 0x45, 0xf5, 0x8a, 0x2e, 0xfb, - 0x00, 0x46, 0x76, 0xdf, 0x2f, 0xfb, 0x40, 0x4c, 0x88, 0x8c, 0xa2, 0x05, - 0x00, 0xa4, 0xcb, 0x01, 0x47, 0x0c, 0xd1, 0x91, 0x05, 0x00, 0x03, 0xdb, - 0x09, 0xad, 0x01, 0x44, 0xad, 0xf0, 0xac, 0x05, 0x00, 0xad, 0x8b, 0x01, - 0x43, 0xda, 0x15, 0xab, 0x05, 0x00, 0x02, 0xbb, 0x09, 0x75, 0x02, 0x43, - 0x14, 0x65, 0x45, 0x15, 0x50, 0x97, 0x05, 0x00, 0xb3, 0x51, 0xb4, 0x31, - 0x02, 0x4d, 0x00, 0x21, 0xba, 0x01, 0xff, 0xa1, 0x06, 0x44, 0xb5, 0xf0, - 0xae, 0x05, 0x40, 0x04, 0x51, 0xf2, 0x06, 0x43, 0x42, 0x14, 0x98, 0x05, - 0x40, 0x45, 0xa2, 0xe6, 0x95, 0x05, 0x00, 0x45, 0x5d, 0xd8, 0x94, 0x05, - 0x40, 0x4c, 0x38, 0x94, 0xaa, 0x05, 0x00, 0x43, 0xd1, 0x05, 0x9a, 0x05, - 0x40, 0xa5, 0x06, 0x45, 0xa6, 0xe7, 0x96, 0x05, 0x40, 0x06, 0xde, 0xdd, - 0x06, 0x43, 0xe5, 0x23, 0x9b, 0x05, 0x40, 0x46, 0x10, 0xdc, 0xa0, 0x05, - 0x00, 0x46, 0x7c, 0xdf, 0xa9, 0x05, 0x40, 0x44, 0xea, 0xea, 0x92, 0x05, - 0x00, 0x49, 0x90, 0xb9, 0x93, 0x05, 0x40, 0x43, 0xce, 0xb5, 0xa8, 0x05, - 0x00, 0x49, 0xe8, 0xbe, 0x9f, 0x05, 0x40, 0x44, 0xc5, 0xf2, 0x99, 0x05, - 0x00, 0x43, 0x5f, 0x1e, 0xa1, 0x05, 0x40, 0x47, 0xb9, 0xce, 0xa4, 0x05, - 0x00, 0x45, 0x39, 0xe6, 0xa5, 0x05, 0x80, 0x06, 0x44, 0xb7, 0xce, 0xa3, - 0x05, 0x40, 0x47, 0x54, 0xcd, 0xa6, 0x05, 0x40, 0x43, 0x9a, 0x5a, 0x9c, - 0x05, 0x80, 0x06, 0x46, 0xf4, 0xdf, 0x9e, 0x05, 0x40, 0x47, 0x7e, 0xcd, - 0x9d, 0x05, 0x40, 0x44, 0xf4, 0x4b, 0xa7, 0x05, 0x00, 0x43, 0x3f, 0x52, - 0xad, 0x05, 0x40, 0xa4, 0xdb, 0x06, 0xb2, 0xaa, 0x06, 0x03, 0x70, 0x15, - 0x01, 0xff, 0xa1, 0xf6, 0x05, 0xa2, 0xb9, 0x05, 0xa3, 0x83, 0x05, 0xa4, - 0xca, 0x04, 0xa5, 0x8a, 0x04, 0xa6, 0xf1, 0x03, 0x4b, 0x22, 0x61, 0x1a, - 0x27, 0x00, 0xa8, 0xdc, 0x03, 0x54, 0x1f, 0x16, 0x79, 0xf6, 0x01, 0xac, - 0x81, 0x03, 0xad, 0xf2, 0x02, 0x06, 0xb4, 0x01, 0xc1, 0x02, 0xaf, 0xac, - 0x02, 0x49, 0xe6, 0x71, 0x95, 0x27, 0x00, 0xb2, 0xf1, 0x01, 0xb3, 0x81, - 0x01, 0xb4, 0x4d, 0x02, 0x50, 0x02, 0x32, 0x4c, 0x32, 0x00, 0x5a, 0x27, - 0x00, 0xb7, 0x01, 0xff, 0x5c, 0x8a, 0x17, 0xbd, 0x27, 0x00, 0x05, 0xae, - 0x02, 0x06, 0x5b, 0xf2, 0x1b, 0x94, 0x27, 0x40, 0x46, 0x12, 0x03, 0x87, - 0xf7, 0x01, 0x56, 0xdc, 0x33, 0xdb, 0x26, 0x00, 0x46, 0xd6, 0x05, 0x91, - 0xf7, 0xc1, 0x00, 0x63, 0x6f, 0x0a, 0x05, 0xce, 0x41, 0x69, 0x9a, 0x02, - 0xae, 0x27, 0x00, 0x11, 0x38, 0x0c, 0x01, 0xff, 0x55, 0xd5, 0x01, 0x19, - 0xf8, 0x01, 0x5b, 0x43, 0x1c, 0x1d, 0xf8, 0x41, 0x09, 0x23, 0x0d, 0x17, - 0x5f, 0x94, 0x06, 0x9e, 0x27, 0x00, 0x0e, 0x01, 0x2c, 0x01, 0xff, 0x4a, - 0x0f, 0x2c, 0xd3, 0xf7, 0x01, 0x4d, 0x28, 0x13, 0xd4, 0xf7, 0x41, 0x57, - 0xb8, 0x2e, 0xbb, 0x27, 0x00, 0x06, 0x2c, 0x0d, 0x01, 0xff, 0x48, 0x3c, - 0x0d, 0x3d, 0x27, 0x00, 0x51, 0x33, 0x5d, 0x43, 0x27, 0x40, 0xa1, 0x5f, - 0x5a, 0x98, 0x1f, 0x71, 0xf6, 0x01, 0xa9, 0x36, 0x05, 0xa4, 0x20, 0x06, - 0x46, 0x00, 0xb5, 0x48, 0x27, 0x40, 0x05, 0xaf, 0x23, 0x11, 0x0e, 0x8a, - 0x56, 0x01, 0xff, 0x43, 0x93, 0xd0, 0x65, 0xf6, 0x01, 0x49, 0x31, 0xc1, - 0x5d, 0xf6, 0x41, 0x45, 0xce, 0x00, 0x98, 0x27, 0x00, 0x09, 0x9c, 0x01, - 0x01, 0xff, 0x43, 0x93, 0xd0, 0x67, 0xf6, 0x01, 0x49, 0x31, 0xc1, 0x5f, - 0xf6, 0x41, 0x05, 0x32, 0x06, 0x11, 0x02, 0xd8, 0x04, 0x01, 0xff, 0x52, - 0x07, 0x2c, 0xcc, 0xf7, 0x01, 0x4f, 0xf1, 0x1c, 0xb8, 0xf7, 0x41, 0x5d, - 0x13, 0x05, 0x5c, 0x27, 0x00, 0x64, 0x27, 0x0a, 0x5b, 0x27, 0x40, 0x45, - 0x30, 0x19, 0xac, 0xf7, 0x01, 0x5d, 0x16, 0x16, 0x7b, 0xf6, 0x41, 0x04, - 0xc9, 0x00, 0x06, 0x5c, 0xf6, 0x18, 0x9c, 0x27, 0x40, 0x10, 0x8c, 0x0b, - 0x18, 0x4b, 0xb8, 0x02, 0x99, 0x27, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, - 0xff, 0x55, 0xd5, 0x01, 0x1a, 0xf8, 0x01, 0x5b, 0x43, 0x1c, 0x1e, 0xf8, - 0x41, 0x50, 0x63, 0x09, 0x71, 0x27, 0x00, 0x57, 0x19, 0x05, 0x6f, 0x27, - 0x40, 0x50, 0xbd, 0x65, 0x1c, 0x27, 0x00, 0x52, 0x54, 0x56, 0x2e, 0x27, - 0x00, 0x54, 0x97, 0x46, 0x56, 0x2b, 0x40, 0x05, 0xaf, 0x23, 0x11, 0x0e, - 0x8a, 0x56, 0x01, 0xff, 0x43, 0x93, 0xd0, 0x64, 0xf6, 0x01, 0x49, 0x31, - 0xc1, 0x5c, 0xf6, 0x41, 0x45, 0xce, 0x00, 0x9a, 0x27, 0x00, 0x09, 0x9c, - 0x01, 0x01, 0xff, 0x43, 0x93, 0xd0, 0x66, 0xf6, 0x01, 0x49, 0x31, 0xc1, - 0x5e, 0xf6, 0x41, 0x49, 0x89, 0x98, 0x96, 0x27, 0x00, 0x4f, 0x4d, 0x74, - 0x16, 0x27, 0x40, 0xa1, 0x44, 0x03, 0xc4, 0x00, 0x1f, 0x58, 0x31, 0x29, - 0x73, 0xf6, 0x01, 0x02, 0xd1, 0x00, 0x01, 0xff, 0x80, 0x06, 0x68, 0x9b, - 0x02, 0xad, 0x27, 0x40, 0x64, 0x0c, 0x05, 0x60, 0x27, 0x00, 0x64, 0xdf, - 0x09, 0x5f, 0x27, 0x40, 0x10, 0x8c, 0x0b, 0x11, 0x11, 0x38, 0x0c, 0x01, - 0xff, 0x55, 0xd5, 0x01, 0x18, 0xf8, 0x01, 0x5b, 0x43, 0x1c, 0x1c, 0xf8, - 0x41, 0x50, 0x63, 0x09, 0x70, 0x27, 0x00, 0x57, 0x19, 0x05, 0x6e, 0x27, - 0x40, 0x4a, 0x4e, 0xb0, 0x55, 0x2b, 0x00, 0x49, 0x6c, 0x9e, 0x47, 0xf5, - 0x41, 0x5e, 0xdb, 0x12, 0x63, 0x27, 0x00, 0x4e, 0x27, 0x6e, 0x97, 0xfb, - 0x41, 0x04, 0xd2, 0x05, 0x06, 0x5b, 0xe5, 0x1c, 0x24, 0x27, 0x40, 0x52, - 0x07, 0x2c, 0xca, 0xf7, 0x01, 0x4f, 0xf1, 0x1c, 0xb2, 0xf7, 0x41, 0x05, - 0xc9, 0x00, 0x17, 0x4a, 0x49, 0x13, 0xf0, 0xf7, 0x01, 0x10, 0xae, 0x00, - 0x01, 0xff, 0x48, 0x28, 0x05, 0x62, 0x27, 0x00, 0x46, 0x16, 0x08, 0x57, - 0x27, 0x40, 0x08, 0x33, 0x08, 0x0c, 0x4f, 0xf1, 0x1c, 0xbe, 0xf7, 0x01, - 0x62, 0x22, 0x0d, 0x4b, 0x27, 0x40, 0x4a, 0x0f, 0x2c, 0xcf, 0xf7, 0x01, - 0x4d, 0x28, 0x13, 0xd1, 0xf7, 0x01, 0x56, 0xc8, 0x36, 0x38, 0x27, 0x40, - 0x66, 0x8d, 0x06, 0xa0, 0x27, 0x00, 0x4c, 0xde, 0x32, 0x97, 0x27, 0x00, - 0xaf, 0x01, 0xff, 0x49, 0x2c, 0x0e, 0xb2, 0xf4, 0x01, 0x05, 0x3d, 0x01, - 0x11, 0x13, 0x36, 0x0c, 0x01, 0xff, 0x55, 0xd5, 0x01, 0x1b, 0xf8, 0x01, - 0x5b, 0x43, 0x1c, 0x1f, 0xf8, 0x41, 0x5d, 0x13, 0x05, 0x5e, 0x27, 0x00, - 0x64, 0x27, 0x0a, 0x5d, 0x27, 0x40, 0x02, 0xb0, 0x01, 0x23, 0x45, 0x13, - 0x03, 0x58, 0x2b, 0x80, 0x06, 0x65, 0x2c, 0x08, 0xa8, 0x27, 0x40, 0x06, - 0x50, 0x00, 0x06, 0x49, 0xbc, 0xb7, 0x59, 0x2b, 0x40, 0x4d, 0x88, 0x81, - 0x57, 0x2b, 0x00, 0x59, 0x75, 0x26, 0xe3, 0x26, 0x40, 0x47, 0xff, 0x07, - 0x14, 0x27, 0x00, 0x4e, 0xb4, 0x7e, 0x46, 0x27, 0x40, 0x47, 0xc7, 0xce, - 0x18, 0x27, 0x00, 0x04, 0x0d, 0x03, 0x01, 0xff, 0x80, 0x17, 0x0b, 0x27, - 0x1a, 0x01, 0xff, 0x50, 0xa9, 0x23, 0xb9, 0x27, 0x00, 0x50, 0xb3, 0x02, - 0xb8, 0x27, 0x00, 0x50, 0x97, 0x40, 0xb7, 0x27, 0x40, 0x07, 0x6f, 0x41, - 0x06, 0x45, 0xae, 0x21, 0x64, 0x27, 0x40, 0x5e, 0xbd, 0x12, 0xa5, 0x27, - 0x00, 0x5c, 0xba, 0x19, 0xa6, 0x27, 0x40, 0x51, 0x2e, 0x3e, 0x74, 0xf6, - 0x01, 0x11, 0x37, 0x50, 0x06, 0x47, 0x3d, 0x0d, 0x31, 0x27, 0x40, 0x43, - 0x0e, 0x0b, 0x9c, 0xf8, 0x81, 0x06, 0x4a, 0x74, 0xb2, 0x9d, 0xf8, 0x41, - 0x80, 0x01, 0xff, 0x44, 0x22, 0x00, 0x9e, 0xf8, 0x01, 0x45, 0xf5, 0x74, - 0x9f, 0xf8, 0x41, 0x4f, 0x39, 0x6a, 0x49, 0xf6, 0x01, 0x02, 0xc6, 0x00, - 0x01, 0xff, 0x4a, 0x80, 0x97, 0x9f, 0xf4, 0x01, 0x45, 0x7b, 0x0e, 0xf6, - 0xfa, 0x01, 0x05, 0x51, 0x00, 0x01, 0xff, 0x45, 0xce, 0x00, 0x98, 0xf4, - 0x01, 0x46, 0x14, 0x86, 0x9d, 0xf4, 0x01, 0x4f, 0xd5, 0x73, 0x94, 0xf3, - 0x41, 0x45, 0x35, 0x3d, 0xa7, 0xf3, 0x01, 0x45, 0xbd, 0xba, 0xa6, 0xfa, - 0xc1, 0x00, 0x51, 0x06, 0x57, 0xfc, 0x26, 0x40, 0x43, 0x11, 0x28, 0xe1, - 0x2b, 0x00, 0x02, 0x46, 0x00, 0x9a, 0x24, 0x08, 0xe9, 0xc7, 0xe1, 0x1e, - 0xad, 0xad, 0x1e, 0xae, 0xd8, 0x01, 0x5b, 0x36, 0x1d, 0x4b, 0xf6, 0x01, - 0xb2, 0xc5, 0x01, 0xb4, 0x06, 0x44, 0x9e, 0xa9, 0x7b, 0xf7, 0x41, 0x4b, - 0x3f, 0x9a, 0x23, 0xf4, 0x01, 0x04, 0x5e, 0xd2, 0x01, 0xff, 0x07, 0xec, - 0x05, 0x27, 0x07, 0x1a, 0x3a, 0x01, 0xff, 0x44, 0x80, 0x11, 0xfc, 0x08, - 0x01, 0x43, 0x0e, 0x0b, 0xfb, 0x08, 0x81, 0x0f, 0xb4, 0x01, 0xff, 0x42, - 0x92, 0x01, 0xfd, 0x08, 0x01, 0x45, 0x9a, 0x2c, 0xfe, 0x08, 0x41, 0x48, - 0x70, 0x11, 0xff, 0x08, 0x41, 0xa1, 0x79, 0x44, 0x61, 0xef, 0xe1, 0x08, - 0x01, 0x4b, 0xd9, 0x9a, 0xe3, 0x08, 0x01, 0x45, 0xfe, 0xaa, 0xe2, 0x08, - 0x01, 0x42, 0xb0, 0x01, 0xe4, 0x08, 0x81, 0x5a, 0x44, 0xed, 0xf0, 0xea, - 0x08, 0x01, 0x46, 0xb4, 0xdd, 0xeb, 0x08, 0x01, 0x43, 0xb4, 0x05, 0xec, - 0x08, 0x01, 0x43, 0xde, 0x22, 0xed, 0x08, 0x01, 0x42, 0x6f, 0x02, 0xf0, - 0x08, 0x01, 0x44, 0x6d, 0xc8, 0xf2, 0x08, 0x01, 0xb3, 0x20, 0xb4, 0x12, - 0x43, 0x9f, 0x8a, 0xe5, 0x08, 0x01, 0x44, 0xa8, 0x52, 0xe9, 0x08, 0x01, - 0x44, 0x7d, 0xf3, 0xe6, 0x08, 0x41, 0x42, 0xd2, 0x2d, 0xf5, 0x08, 0x01, - 0x43, 0xf5, 0x25, 0xe8, 0x08, 0x41, 0xa1, 0x06, 0x43, 0x7a, 0x16, 0xf4, - 0x08, 0x41, 0x43, 0xcd, 0xea, 0xf1, 0x08, 0x01, 0x44, 0x69, 0xe4, 0xee, - 0x08, 0x41, 0x42, 0x53, 0x00, 0xe7, 0x08, 0x41, 0x44, 0x33, 0x3d, 0xe0, - 0x08, 0x01, 0x42, 0x1f, 0x1d, 0xef, 0x08, 0x41, 0x46, 0xf0, 0xda, 0xb4, - 0xf5, 0x01, 0xf0, 0x89, 0xfa, 0x41, 0xa4, 0xab, 0x1c, 0xa7, 0xce, 0x03, - 0x0d, 0x12, 0x84, 0x82, 0x01, 0x05, 0x01, 0xec, 0x01, 0xff, 0x07, 0xec, - 0x05, 0x13, 0x4d, 0xcb, 0x88, 0x34, 0x17, 0x00, 0x0b, 0x55, 0x77, 0x01, - 0xff, 0xe9, 0x32, 0x17, 0x00, 0xf5, 0x33, 0x17, 0x40, 0xe1, 0x20, 0x17, - 0x00, 0x42, 0x16, 0x00, 0x2a, 0x17, 0x00, 0x42, 0xf0, 0x10, 0x27, 0x17, - 0x00, 0x42, 0x24, 0x02, 0x24, 0x17, 0x00, 0x42, 0x22, 0x00, 0x31, 0x17, - 0x00, 0xe9, 0x21, 0x17, 0x00, 0x42, 0x1b, 0x02, 0x23, 0x17, 0x00, 0x42, - 0x74, 0x00, 0x2e, 0x17, 0x00, 0x42, 0x6c, 0x00, 0x2b, 0x17, 0x00, 0xae, - 0x28, 0x42, 0xbb, 0x09, 0x29, 0x17, 0x00, 0x42, 0x71, 0x00, 0x2d, 0x17, - 0x00, 0x42, 0x40, 0x06, 0x30, 0x17, 0x00, 0x42, 0x12, 0x00, 0x26, 0x17, - 0x00, 0xf5, 0x22, 0x17, 0x00, 0x42, 0xa9, 0x01, 0x2f, 0x17, 0x00, 0x42, - 0xbe, 0x22, 0x2c, 0x17, 0x40, 0xe1, 0x28, 0x17, 0x00, 0x42, 0x24, 0x02, - 0x25, 0x17, 0x40, 0x06, 0xef, 0x06, 0x80, 0x02, 0x07, 0xec, 0x05, 0x4a, - 0x05, 0xb9, 0x00, 0x3a, 0x05, 0x5a, 0x03, 0x19, 0x06, 0x57, 0x39, 0x01, - 0xff, 0xe1, 0x1d, 0x0d, 0x01, 0xe5, 0x20, 0x0d, 0x01, 0xe9, 0x1e, 0x0d, - 0x01, 0xef, 0x21, 0x0d, 0x01, 0xf5, 0x1f, 0x0d, 0x41, 0x48, 0xc1, 0xc6, - 0x24, 0x0d, 0x01, 0x02, 0x12, 0x00, 0x01, 0xff, 0x44, 0xe7, 0x7c, 0x25, - 0x0d, 0x01, 0x42, 0x2a, 0x05, 0x26, 0x0d, 0x01, 0x43, 0x8a, 0x08, 0x27, - 0x0d, 0x41, 0x49, 0x45, 0xbc, 0x23, 0x0d, 0x01, 0x45, 0xd0, 0xea, 0x22, - 0x0d, 0x41, 0xe1, 0x00, 0x0d, 0x01, 0x42, 0x16, 0x00, 0x01, 0x0d, 0x01, - 0x42, 0x37, 0x00, 0x06, 0x0d, 0x01, 0xa4, 0x95, 0x01, 0x42, 0x0c, 0x08, - 0x09, 0x0d, 0x01, 0x42, 0x24, 0x02, 0x12, 0x0d, 0x01, 0x42, 0x22, 0x00, - 0x07, 0x0d, 0x01, 0x42, 0x72, 0x19, 0x05, 0x0d, 0x01, 0xab, 0x60, 0x42, - 0x74, 0x00, 0x13, 0x0d, 0x01, 0x42, 0x6c, 0x00, 0x14, 0x0d, 0x01, 0xae, - 0x42, 0x42, 0xbb, 0x09, 0x02, 0x0d, 0x01, 0xb2, 0x30, 0xb3, 0x24, 0xb4, - 0x18, 0x42, 0xf5, 0x0a, 0x1c, 0x0d, 0x01, 0x42, 0xa9, 0x01, 0x16, 0x0d, - 0x01, 0x42, 0xbe, 0x22, 0x18, 0x0d, 0x01, 0x42, 0x59, 0x00, 0x0e, 0x0d, - 0x41, 0xe1, 0x03, 0x0d, 0x01, 0x42, 0x12, 0x00, 0x04, 0x0d, 0x41, 0xe1, - 0x0f, 0x0d, 0x01, 0x42, 0x22, 0x00, 0x10, 0x0d, 0x41, 0xe1, 0x0c, 0x0d, - 0x01, 0x42, 0x71, 0x00, 0x0d, 0x0d, 0x41, 0xe1, 0x15, 0x0d, 0x01, 0x42, - 0x24, 0x02, 0x1a, 0x0d, 0x01, 0x42, 0xbe, 0x22, 0x1b, 0x0d, 0x41, 0xe1, - 0x11, 0x0d, 0x01, 0x42, 0x22, 0x00, 0x08, 0x0d, 0x01, 0x05, 0x9c, 0xe7, - 0x01, 0xff, 0x42, 0xa9, 0x01, 0x17, 0x0d, 0x01, 0x42, 0xbe, 0x22, 0x19, - 0x0d, 0x41, 0xe1, 0x0a, 0x0d, 0x01, 0x42, 0xf0, 0x10, 0x0b, 0x0d, 0x41, - 0x45, 0x12, 0x0b, 0x38, 0x0d, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x39, - 0x0d, 0x01, 0x43, 0x0e, 0x0b, 0x31, 0x0d, 0x01, 0xb3, 0x14, 0xb4, 0x06, - 0x44, 0x5f, 0x1e, 0x30, 0x0d, 0x41, 0x44, 0x25, 0x01, 0x33, 0x0d, 0x01, - 0x42, 0x15, 0x02, 0x32, 0x0d, 0x41, 0x44, 0xe5, 0x1d, 0x37, 0x0d, 0x01, - 0x42, 0x1c, 0x26, 0x36, 0x0d, 0x41, 0x43, 0xd2, 0x05, 0x35, 0x0d, 0x01, - 0x43, 0xf6, 0x06, 0x34, 0x0d, 0x41, 0x03, 0x90, 0x55, 0x57, 0x0d, 0x07, - 0x8b, 0x01, 0xff, 0x45, 0x12, 0x0b, 0x28, 0x30, 0x00, 0xa6, 0x3e, 0x44, - 0xea, 0x2a, 0x29, 0x30, 0x00, 0x43, 0x0e, 0x0b, 0x21, 0x30, 0x00, 0xb3, - 0x24, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x38, 0x30, 0x00, 0xa8, 0x0d, - 0xb7, 0x01, 0xff, 0x44, 0xe7, 0x1d, 0x39, 0x30, 0x00, 0xef, 0x22, 0x30, - 0x40, 0x44, 0x7b, 0x11, 0x3a, 0x30, 0x00, 0x43, 0x26, 0x01, 0x23, 0x30, - 0x40, 0x44, 0xe5, 0x1d, 0x27, 0x30, 0x00, 0x42, 0x1c, 0x26, 0x26, 0x30, - 0x40, 0x43, 0xd2, 0x05, 0x25, 0x30, 0x00, 0x43, 0xf6, 0x06, 0x24, 0x30, - 0x40, 0x09, 0x59, 0xb7, 0xf4, 0x10, 0x54, 0xbf, 0x41, 0x2f, 0x30, 0x00, - 0x46, 0xbc, 0x82, 0x64, 0x31, 0x00, 0xaa, 0xef, 0x04, 0x07, 0xec, 0x05, - 0x0f, 0xb3, 0x01, 0xff, 0x53, 0x7c, 0x4a, 0x2e, 0x30, 0x00, 0x48, 0x37, - 0x18, 0x00, 0xd8, 0x40, 0xe1, 0x4f, 0x31, 0x80, 0xc7, 0x04, 0xa3, 0xb8, - 0x04, 0xe5, 0x54, 0x31, 0x80, 0xaa, 0x04, 0x45, 0x92, 0xa5, 0x4e, 0x31, - 0x00, 0xe9, 0x63, 0x31, 0x80, 0x98, 0x04, 0xab, 0xe4, 0x03, 0x45, 0xc8, - 0xe8, 0x41, 0x31, 0x80, 0xc5, 0x03, 0x45, 0x3b, 0xe9, 0x34, 0x31, 0x80, - 0x9c, 0x03, 0xef, 0x57, 0x31, 0x80, 0x92, 0x03, 0xb0, 0xc8, 0x02, 0x45, - 0x85, 0xea, 0x39, 0x31, 0x80, 0xef, 0x01, 0xb3, 0x8f, 0x01, 0xb4, 0x80, - 0x01, 0xf5, 0x5c, 0x31, 0x00, 0xb7, 0x64, 0xb9, 0x01, 0xff, 0xe1, 0x51, - 0x31, 0x80, 0x58, 0xe5, 0x56, 0x31, 0x80, 0x32, 0xe9, 0x62, 0x31, 0x00, - 0xef, 0x5b, 0x31, 0x80, 0x17, 0xf5, 0x60, 0x31, 0xc0, 0x00, 0x8d, 0x01, - 0xff, 0xe9, 0x8c, 0x31, 0x00, 0x42, 0x4d, 0x00, 0x8b, 0x31, 0xc0, 0x00, - 0xef, 0x8a, 0x31, 0x40, 0x8d, 0x01, 0xff, 0xe9, 0x89, 0x31, 0x00, 0x42, - 0xbe, 0x22, 0x87, 0x31, 0xc0, 0x00, 0xe5, 0x88, 0x31, 0x40, 0xef, 0x55, - 0x31, 0x80, 0x16, 0x46, 0xfb, 0xcc, 0x81, 0x31, 0xc0, 0x00, 0x8d, 0x01, - 0xff, 0x47, 0xa1, 0xd4, 0x83, 0x31, 0x00, 0x44, 0x86, 0xbf, 0x82, 0x31, - 0x40, 0x48, 0x8f, 0xa5, 0x86, 0x31, 0x40, 0xe5, 0x52, 0x31, 0x40, 0xe1, - 0x58, 0x31, 0x80, 0x0d, 0xe5, 0x5e, 0x31, 0x80, 0x04, 0xe9, 0x5f, 0x31, - 0x40, 0xef, 0x5d, 0x31, 0x40, 0xe5, 0x59, 0x31, 0x40, 0x46, 0x77, 0xd6, - 0x4c, 0x31, 0x00, 0x45, 0xfe, 0xcd, 0x37, 0x31, 0x40, 0x43, 0x2a, 0x42, - 0x45, 0x31, 0x80, 0x35, 0x04, 0x47, 0x2d, 0x01, 0xff, 0x45, 0x62, 0xe5, - 0x49, 0x31, 0x00, 0x45, 0x92, 0xa5, 0x85, 0x31, 0x00, 0x45, 0x37, 0xcc, - 0x80, 0x31, 0x00, 0x46, 0xfd, 0xa2, 0x32, 0x31, 0x00, 0x45, 0x3b, 0xe9, - 0x65, 0x31, 0x00, 0x45, 0xf7, 0x84, 0x43, 0x31, 0x00, 0x44, 0x86, 0xbf, - 0x46, 0x31, 0x00, 0x46, 0xfd, 0xcd, 0x38, 0x31, 0x40, 0x8d, 0x01, 0xff, - 0x45, 0x62, 0xe5, 0x7e, 0x31, 0x00, 0x46, 0xfd, 0xa2, 0x7a, 0x31, 0x00, - 0x45, 0x3b, 0xe9, 0x7b, 0x31, 0x00, 0x45, 0xf7, 0x84, 0x7d, 0x31, 0x00, - 0x46, 0xfd, 0xcd, 0x7c, 0x31, 0x40, 0x8d, 0x01, 0xff, 0x45, 0x92, 0xa5, - 0x40, 0x31, 0x00, 0x46, 0xfd, 0xa2, 0x3a, 0x31, 0x80, 0x3b, 0x45, 0xc8, - 0xe8, 0x3b, 0x31, 0x00, 0xb0, 0x1a, 0x44, 0x86, 0xbf, 0x3d, 0x31, 0x00, - 0xb4, 0x06, 0x4b, 0x8c, 0xa5, 0x6d, 0x31, 0x40, 0x46, 0x77, 0xd6, 0x3e, - 0x31, 0x00, 0x45, 0xfe, 0xcd, 0x6a, 0x31, 0x40, 0x46, 0xa2, 0xd4, 0x6c, - 0x31, 0x00, 0x46, 0xf3, 0xc2, 0x3f, 0x31, 0x00, 0x44, 0xf8, 0x84, 0x3c, - 0x31, 0xc0, 0x00, 0x45, 0x15, 0xe2, 0x6b, 0x31, 0x40, 0x45, 0x15, 0xe2, - 0x69, 0x31, 0x40, 0x46, 0xa2, 0xd4, 0x7f, 0x31, 0x00, 0x46, 0xf3, 0xc2, - 0x4d, 0x31, 0x00, 0x44, 0xf8, 0x84, 0x42, 0x31, 0xc0, 0x00, 0x8d, 0x01, - 0xff, 0x45, 0x62, 0xe5, 0x76, 0x31, 0x00, 0x46, 0xfd, 0xa2, 0x72, 0x31, - 0x00, 0x44, 0x86, 0xbf, 0x44, 0x31, 0x80, 0x0f, 0xb4, 0x01, 0xff, 0x46, - 0x77, 0xd6, 0x77, 0x31, 0x00, 0x45, 0xfe, 0xcd, 0x73, 0x31, 0x40, 0x8d, - 0x01, 0xff, 0x46, 0xfd, 0xa2, 0x74, 0x31, 0x00, 0x46, 0xfd, 0xcd, 0x75, - 0x31, 0x40, 0xe5, 0x5a, 0x31, 0x40, 0x8d, 0x01, 0xff, 0x45, 0x62, 0xe5, - 0x35, 0x31, 0x00, 0x45, 0x92, 0xa5, 0x36, 0x31, 0x00, 0x47, 0xa1, 0xd4, - 0x68, 0x31, 0x00, 0x44, 0x86, 0xbf, 0x67, 0x31, 0x00, 0x46, 0xfd, 0xcd, - 0x66, 0x31, 0x40, 0x8d, 0x01, 0xff, 0xb0, 0x06, 0x44, 0x86, 0xbf, 0x6f, - 0x31, 0x40, 0x46, 0xa2, 0xd4, 0x70, 0x31, 0x00, 0x44, 0xf8, 0x84, 0x6e, - 0x31, 0x40, 0x07, 0xf0, 0x84, 0x13, 0x46, 0xeb, 0xc2, 0x4b, 0x31, 0x00, - 0x45, 0xfe, 0xa2, 0x31, 0x31, 0xc0, 0x00, 0x45, 0x15, 0xe2, 0x33, 0x31, - 0x40, 0x45, 0xc8, 0xe8, 0x71, 0x31, 0x00, 0xb0, 0x06, 0x4a, 0x66, 0xb1, - 0x79, 0x31, 0x40, 0x46, 0xf3, 0xc2, 0x84, 0x31, 0x00, 0x44, 0xf8, 0x84, - 0x78, 0x31, 0x40, 0x44, 0x38, 0xcc, 0x47, 0x31, 0x40, 0xef, 0x53, 0x31, - 0x00, 0xf5, 0x61, 0x31, 0x40, 0x46, 0x03, 0xd0, 0x4a, 0x31, 0x00, 0x44, - 0x04, 0xd0, 0x48, 0x31, 0x40, 0xe5, 0x50, 0x31, 0x00, 0x44, 0x62, 0xb1, - 0x8d, 0x31, 0xc0, 0x00, 0xe5, 0x8e, 0x31, 0x40, 0x09, 0x5c, 0xbd, 0xfb, - 0x03, 0x09, 0x7d, 0xc0, 0x01, 0xff, 0xe1, 0x61, 0x11, 0x80, 0xbd, 0x03, - 0xe5, 0x66, 0x11, 0x80, 0x80, 0x03, 0x46, 0xbc, 0x82, 0x60, 0x11, 0x00, - 0xe9, 0x75, 0x11, 0x80, 0xaa, 0x02, 0xef, 0x69, 0x11, 0x80, 0xf1, 0x01, - 0x4a, 0x5c, 0xb1, 0xa2, 0x11, 0x00, 0xf5, 0x6e, 0x11, 0x80, 0xbe, 0x01, - 0xb7, 0xa5, 0x01, 0xb9, 0x01, 0xff, 0xe1, 0x63, 0x11, 0x80, 0x88, 0x01, - 0xe5, 0x68, 0x11, 0x80, 0x6d, 0xe9, 0x74, 0x11, 0x80, 0x62, 0xef, 0x6d, - 0x11, 0x80, 0x31, 0xf5, 0x72, 0x11, 0xc0, 0x00, 0x8d, 0x01, 0xff, 0xe1, - 0x8e, 0x11, 0x80, 0x20, 0xe5, 0x90, 0x11, 0x80, 0x17, 0xe9, 0x94, 0x11, - 0x00, 0xef, 0xb8, 0xd7, 0x00, 0xf5, 0x93, 0x11, 0x00, 0x42, 0x4d, 0x00, - 0x92, 0x11, 0xc0, 0x00, 0xef, 0x91, 0x11, 0x40, 0xef, 0x8f, 0x11, 0x40, - 0xe5, 0xb7, 0xd7, 0x40, 0x8d, 0x01, 0xff, 0xe1, 0xb2, 0xd7, 0x80, 0x20, - 0x42, 0x40, 0x0b, 0xb4, 0xd7, 0x00, 0xe9, 0x88, 0x11, 0x00, 0xef, 0x87, - 0x11, 0x00, 0xb9, 0x01, 0xff, 0xe1, 0x84, 0x11, 0x80, 0x06, 0x42, 0x40, - 0x0b, 0x86, 0x11, 0x40, 0xe5, 0x85, 0x11, 0x40, 0xe5, 0xb3, 0xd7, 0x40, - 0x42, 0x8f, 0x08, 0x97, 0x11, 0x40, 0xef, 0x67, 0x11, 0xc0, 0x00, 0x8d, - 0x01, 0xff, 0xef, 0x7d, 0x11, 0x00, 0xf5, 0x7e, 0x11, 0x00, 0x42, 0xbe, - 0x22, 0xa5, 0x11, 0x40, 0x8d, 0x04, 0xe5, 0x64, 0x11, 0x40, 0xef, 0x78, - 0x11, 0x00, 0xf5, 0xa4, 0x11, 0x00, 0x42, 0xb0, 0x47, 0x79, 0x11, 0x40, - 0xe1, 0x6a, 0x11, 0x80, 0x0d, 0xe5, 0x70, 0x11, 0x80, 0x04, 0xe9, 0x71, - 0x11, 0x40, 0xef, 0x6f, 0x11, 0x40, 0xe5, 0x6b, 0x11, 0x40, 0x8d, 0x01, - 0xff, 0xe1, 0x89, 0x11, 0x80, 0x1b, 0x45, 0x2a, 0xe6, 0x8b, 0x11, 0x00, - 0x43, 0x79, 0xf4, 0xb6, 0xd7, 0x00, 0xf5, 0x8d, 0x11, 0x00, 0x42, 0x4d, - 0x00, 0x8c, 0x11, 0xc0, 0x00, 0xef, 0xb5, 0xd7, 0x40, 0xe5, 0x8a, 0x11, - 0x40, 0x8d, 0x04, 0xe5, 0x6c, 0x11, 0x40, 0xe5, 0x80, 0x11, 0x80, 0x24, - 0xef, 0x82, 0x11, 0x80, 0x19, 0xf5, 0x83, 0x11, 0x00, 0xb9, 0x01, 0xff, - 0xe1, 0xa6, 0x11, 0x80, 0x09, 0xe5, 0x81, 0x11, 0xc0, 0x00, 0xef, 0xb0, - 0xd7, 0x40, 0xe5, 0xa7, 0x11, 0x40, 0x42, 0xe8, 0x06, 0xb1, 0xd7, 0x40, - 0xef, 0x7f, 0x11, 0x40, 0x8d, 0x01, 0xff, 0xe1, 0x98, 0x11, 0x80, 0x3c, - 0x42, 0x97, 0x02, 0x9c, 0x11, 0x00, 0xe9, 0xc4, 0xd7, 0x00, 0xef, 0x9a, - 0x11, 0x80, 0x27, 0xf5, 0x9b, 0x11, 0x00, 0xb9, 0x01, 0xff, 0xe1, 0x99, - 0x11, 0x80, 0x11, 0xe5, 0xc0, 0xd7, 0x80, 0x08, 0xef, 0xc2, 0xd7, 0x00, - 0xf5, 0xc3, 0xd7, 0x40, 0xef, 0xbf, 0xd7, 0x40, 0x42, 0x51, 0x21, 0xbd, - 0xd7, 0x00, 0xe5, 0xbe, 0xd7, 0x40, 0x42, 0xe8, 0x06, 0xc1, 0xd7, 0x40, - 0x44, 0x62, 0xb1, 0x9d, 0x11, 0x40, 0xef, 0x65, 0x11, 0x80, 0x21, 0xf5, - 0x73, 0x11, 0xc0, 0x00, 0x8d, 0x01, 0xff, 0xe1, 0xb9, 0xd7, 0x00, 0xe5, - 0xbb, 0xd7, 0x80, 0x08, 0xef, 0xbc, 0xd7, 0x00, 0xf5, 0x95, 0x11, 0x40, - 0xef, 0xba, 0xd7, 0x00, 0xf5, 0x96, 0x11, 0x40, 0x8d, 0x01, 0xff, 0x42, - 0x97, 0x02, 0x7c, 0x11, 0x00, 0xef, 0x7a, 0x11, 0x00, 0xf5, 0x7b, 0x11, - 0x40, 0x8d, 0x23, 0xe5, 0x62, 0x11, 0x00, 0x44, 0x62, 0xb1, 0x9e, 0x11, - 0xc0, 0x00, 0x8d, 0x01, 0xff, 0xe1, 0xc5, 0xd7, 0x00, 0xe5, 0xc6, 0xd7, - 0x80, 0x08, 0xe9, 0xa1, 0x11, 0x00, 0xf5, 0xa0, 0x11, 0x40, 0xef, 0x9f, - 0x11, 0x40, 0x42, 0x97, 0x02, 0xa3, 0x11, 0x00, 0xef, 0x76, 0x11, 0x00, - 0xf5, 0x77, 0x11, 0x40, 0xa3, 0xd7, 0x07, 0x45, 0x92, 0xa5, 0xc2, 0x11, - 0x80, 0xb4, 0x07, 0x45, 0x37, 0xcc, 0xbc, 0x11, 0x80, 0x95, 0x07, 0xab, - 0xb3, 0x06, 0x45, 0xc8, 0xe8, 0xb7, 0x11, 0x80, 0xd3, 0x05, 0x45, 0x3b, - 0xe9, 0xab, 0x11, 0x80, 0x8d, 0x05, 0xb0, 0x8e, 0x04, 0x45, 0x85, 0xea, - 0xaf, 0x11, 0x80, 0xc0, 0x02, 0xb3, 0x89, 0x01, 0xb4, 0x44, 0x02, 0x4d, - 0x00, 0x01, 0xff, 0x49, 0x8e, 0xa5, 0xf9, 0x11, 0x00, 0x46, 0xfb, 0xcc, - 0xf0, 0x11, 0xc0, 0x00, 0x8d, 0x01, 0xff, 0x45, 0x92, 0xa5, 0xf6, 0xd7, - 0x00, 0xab, 0x1b, 0x45, 0xc8, 0xe8, 0xf5, 0xd7, 0x00, 0x47, 0xa1, 0xd4, - 0xf2, 0x11, 0x00, 0xb3, 0x01, 0xff, 0x43, 0x2a, 0x42, 0xf1, 0x11, 0x00, - 0x4a, 0xf9, 0xa2, 0xed, 0x11, 0x40, 0x46, 0xeb, 0xc2, 0xef, 0x11, 0x00, - 0x45, 0xfe, 0xa2, 0xec, 0x11, 0x40, 0x46, 0x77, 0xd6, 0xc0, 0x11, 0x00, - 0x45, 0xfe, 0xcd, 0xae, 0x11, 0xc0, 0x00, 0x8d, 0x01, 0xff, 0xa3, 0x25, - 0x46, 0xfd, 0xa2, 0xca, 0x11, 0x00, 0x45, 0xf7, 0x84, 0xcf, 0xd7, 0x00, - 0x45, 0x85, 0xea, 0xcb, 0x11, 0x00, 0x44, 0x86, 0xbf, 0xd0, 0xd7, 0x80, - 0x06, 0x47, 0x76, 0xd6, 0xd4, 0xd7, 0x40, 0x47, 0xd9, 0xcd, 0xd1, 0xd7, - 0x40, 0x46, 0x03, 0xd0, 0xd3, 0xd7, 0x00, 0x44, 0x04, 0xd0, 0xd2, 0xd7, - 0x40, 0x43, 0x2a, 0x42, 0xba, 0x11, 0x80, 0x5f, 0x04, 0x47, 0x2d, 0x01, - 0xff, 0x45, 0x62, 0xe5, 0xf9, 0xd7, 0x00, 0x45, 0x37, 0xcc, 0xee, 0x11, - 0x00, 0x46, 0xfd, 0xa2, 0xa9, 0x11, 0x00, 0x45, 0xc8, 0xe8, 0xe0, 0xd7, - 0x00, 0x45, 0x3b, 0xe9, 0xff, 0x11, 0x00, 0x45, 0xf7, 0x84, 0xe6, 0xd7, - 0x00, 0x45, 0x85, 0xea, 0xd0, 0x11, 0x80, 0x29, 0x44, 0x86, 0xbf, 0xbb, - 0x11, 0x80, 0x13, 0x46, 0xfd, 0xcd, 0xcd, 0xd7, 0x80, 0x06, 0x48, 0xf9, - 0xcc, 0xee, 0x11, 0x40, 0x46, 0x8c, 0xd8, 0xce, 0xd7, 0x40, 0x8d, 0x01, - 0xff, 0x46, 0xfd, 0xa2, 0xec, 0xd7, 0x00, 0x46, 0xfd, 0xcd, 0xed, 0xd7, - 0x40, 0x48, 0xe9, 0xc2, 0xd7, 0xd7, 0x40, 0x8d, 0x01, 0xff, 0xa3, 0x3d, - 0x45, 0x92, 0xa5, 0xf2, 0xd7, 0x00, 0xab, 0x29, 0x45, 0xc8, 0xe8, 0xea, - 0xd7, 0x00, 0xb0, 0x15, 0x45, 0x85, 0xea, 0xe9, 0x11, 0x00, 0xb4, 0x01, - 0xff, 0x46, 0x77, 0xd6, 0xf1, 0xd7, 0x00, 0x45, 0xfe, 0xcd, 0xe8, 0x11, - 0x40, 0x46, 0xa2, 0xd4, 0xee, 0xd7, 0x00, 0x44, 0xf8, 0x84, 0xea, 0x11, - 0x40, 0x4c, 0xf0, 0x84, 0xeb, 0xd7, 0x00, 0x45, 0xfe, 0xa2, 0xe7, 0x11, - 0x40, 0x46, 0x03, 0xd0, 0xf0, 0xd7, 0x00, 0x44, 0x04, 0xd0, 0xef, 0xd7, - 0x40, 0x8d, 0x01, 0xff, 0x45, 0x92, 0xa5, 0xb6, 0x11, 0x00, 0xab, 0x98, - 0x01, 0x45, 0xc8, 0xe8, 0xb1, 0x11, 0x80, 0x7c, 0x45, 0x3b, 0xe9, 0xcd, - 0x11, 0x00, 0xb0, 0x46, 0xb3, 0x2d, 0xb4, 0x18, 0x02, 0x4d, 0x00, 0x01, - 0xff, 0x49, 0x8e, 0xa5, 0xd9, 0x11, 0x80, 0x06, 0x46, 0xfb, 0xcc, 0xdb, - 0xd7, 0x40, 0x46, 0x7a, 0xd8, 0xdc, 0xd7, 0x40, 0x46, 0x77, 0xd6, 0xb4, - 0x11, 0x00, 0x45, 0xfe, 0xcd, 0xce, 0x11, 0xc0, 0x00, 0x46, 0x7a, 0xd8, - 0xcf, 0x11, 0x40, 0x43, 0x2a, 0x42, 0xb3, 0x11, 0x00, 0x04, 0x47, 0x2d, - 0x01, 0xff, 0x46, 0xfd, 0xa2, 0xd5, 0xd7, 0x00, 0x44, 0x86, 0xbf, 0xd6, - 0x11, 0x40, 0x46, 0xa2, 0xd4, 0xd7, 0x11, 0x00, 0x46, 0xf3, 0xc2, 0xb5, - 0x11, 0x00, 0x44, 0xf8, 0x84, 0xb2, 0x11, 0xc0, 0x00, 0x8d, 0x01, 0xff, - 0x45, 0x92, 0xa5, 0xd4, 0x11, 0x00, 0x47, 0xf2, 0xc2, 0xda, 0xd7, 0x00, - 0x44, 0x86, 0xbf, 0xd3, 0x11, 0x00, 0x46, 0xfd, 0xcd, 0xd9, 0xd7, 0x40, - 0x8d, 0x01, 0xff, 0x45, 0x92, 0xa5, 0xd8, 0xd7, 0x00, 0x46, 0xfd, 0xa2, - 0xd1, 0x11, 0x00, 0x44, 0x86, 0xbf, 0xd2, 0x11, 0x40, 0x4c, 0xf0, 0x84, - 0xd5, 0x11, 0x00, 0x46, 0xeb, 0xc2, 0xd8, 0x11, 0x00, 0x45, 0xfe, 0xa2, - 0xb0, 0x11, 0xc0, 0x00, 0x8d, 0x01, 0xff, 0x45, 0x92, 0xa5, 0xd6, 0xd7, - 0x00, 0x44, 0x86, 0xbf, 0xcc, 0x11, 0x40, 0x46, 0xa2, 0xd4, 0xeb, 0x11, - 0x80, 0x66, 0x46, 0xf3, 0xc2, 0xc1, 0x11, 0x80, 0x4a, 0x44, 0xf8, 0x84, - 0xb8, 0x11, 0xc0, 0x00, 0x8d, 0x01, 0xff, 0xa3, 0x32, 0x45, 0x92, 0xa5, - 0xe5, 0x11, 0x00, 0x45, 0xc8, 0xe8, 0xe5, 0xd7, 0x00, 0x47, 0xf2, 0xc2, - 0xe4, 0x11, 0x00, 0x45, 0x85, 0xea, 0xe3, 0x11, 0x80, 0x13, 0x44, 0x86, - 0xbf, 0xb9, 0x11, 0x80, 0x06, 0x46, 0xfd, 0xcd, 0xe3, 0xd7, 0x40, 0x47, - 0xfc, 0xcd, 0xe7, 0xd7, 0x40, 0x48, 0xf1, 0xc2, 0xe4, 0xd7, 0x40, 0x46, - 0x03, 0xd0, 0xe9, 0xd7, 0x00, 0x44, 0x04, 0xd0, 0xe8, 0xd7, 0x40, 0x8d, - 0x01, 0xff, 0x45, 0xf7, 0x84, 0xf3, 0x11, 0x00, 0x44, 0x86, 0xbf, 0xfa, - 0xd7, 0x00, 0x47, 0x76, 0xd6, 0xfb, 0xd7, 0x40, 0x8d, 0x01, 0xff, 0x4d, - 0xef, 0x84, 0xf4, 0xd7, 0x00, 0x45, 0xf7, 0x84, 0xf3, 0xd7, 0x40, 0x8d, - 0x01, 0xff, 0xa3, 0x2d, 0x45, 0x92, 0xa5, 0xad, 0x11, 0x00, 0x46, 0xfd, - 0xa2, 0xc5, 0x11, 0x00, 0x47, 0xa1, 0xd4, 0xc8, 0x11, 0x00, 0x45, 0x85, - 0xea, 0xcb, 0xd7, 0x00, 0x44, 0x86, 0xbf, 0xc7, 0x11, 0x00, 0xb4, 0x01, - 0xff, 0x46, 0x77, 0xd6, 0xc9, 0x11, 0x00, 0x45, 0xfe, 0xcd, 0xc6, 0x11, - 0x40, 0x46, 0x03, 0xd0, 0xcc, 0xd7, 0x00, 0x44, 0x04, 0xd0, 0xac, 0x11, - 0x40, 0x8d, 0x01, 0xff, 0xa3, 0x47, 0x45, 0x92, 0xa5, 0xe1, 0x11, 0x00, - 0x46, 0xfd, 0xa2, 0xda, 0x11, 0x00, 0x45, 0x3b, 0xe9, 0xde, 0xd7, 0x00, - 0xb0, 0x20, 0x45, 0x85, 0xea, 0xdb, 0x11, 0x00, 0xb3, 0x01, 0xff, 0x43, - 0x2a, 0x42, 0xdd, 0x11, 0x00, 0x04, 0x47, 0x2d, 0x01, 0xff, 0x45, 0x3b, - 0xe9, 0xdf, 0xd7, 0x00, 0x44, 0x86, 0xbf, 0xde, 0x11, 0x40, 0x46, 0xa2, - 0xd4, 0xdf, 0x11, 0x00, 0x44, 0xf8, 0x84, 0xdc, 0x11, 0xc0, 0x00, 0x45, - 0x15, 0xe2, 0xe1, 0xd7, 0x40, 0x46, 0x03, 0xd0, 0xe0, 0x11, 0x00, 0x44, - 0x04, 0xd0, 0xe2, 0xd7, 0x40, 0x07, 0xf0, 0x84, 0x41, 0x46, 0xeb, 0xc2, - 0xbf, 0x11, 0x00, 0x45, 0xfe, 0xa2, 0xa8, 0x11, 0xc0, 0x00, 0x8d, 0x01, - 0xff, 0x47, 0x02, 0xd0, 0xfc, 0x11, 0x00, 0x45, 0x92, 0xa5, 0xfe, 0x11, - 0x00, 0x47, 0xea, 0xc2, 0xfd, 0x11, 0x00, 0x45, 0x3b, 0xe9, 0xfa, 0x11, - 0x00, 0x45, 0xf7, 0x84, 0xfb, 0x11, 0x00, 0x45, 0x85, 0xea, 0xc3, 0x11, - 0x00, 0x44, 0x86, 0xbf, 0xaa, 0x11, 0xc0, 0x00, 0x47, 0xd9, 0xcd, 0xc4, - 0x11, 0x40, 0x45, 0xc8, 0xe8, 0xe2, 0x11, 0x00, 0xb0, 0x06, 0x45, 0x85, - 0xea, 0xdd, 0xd7, 0x40, 0x46, 0xf3, 0xc2, 0xf4, 0x11, 0x00, 0x44, 0xf8, - 0x84, 0xe6, 0x11, 0x40, 0x8d, 0x01, 0xff, 0xab, 0x06, 0x4b, 0xf8, 0xa2, - 0xed, 0x11, 0x40, 0x46, 0xeb, 0xc2, 0xef, 0x11, 0x00, 0x45, 0xfe, 0xa2, - 0xec, 0x11, 0x40, 0x8d, 0x01, 0xff, 0x45, 0xc8, 0xe8, 0xf7, 0x11, 0x00, - 0x45, 0x3b, 0xe9, 0xf5, 0x11, 0x00, 0x45, 0xf7, 0x84, 0xf8, 0x11, 0x00, - 0x45, 0x85, 0xea, 0xf6, 0x11, 0x40, 0x46, 0x03, 0xd0, 0xbe, 0x11, 0x00, - 0x44, 0x04, 0xd0, 0xbd, 0x11, 0xc0, 0x00, 0x8d, 0x01, 0xff, 0x45, 0xf7, - 0x84, 0xf7, 0xd7, 0x00, 0x4a, 0x66, 0xb1, 0xf8, 0xd7, 0x40, 0xa3, 0x83, - 0x06, 0x46, 0xbc, 0x82, 0x5f, 0x11, 0x00, 0x45, 0x92, 0xa5, 0x12, 0x11, - 0x80, 0xef, 0x05, 0x45, 0x37, 0xcc, 0x0b, 0x11, 0x80, 0x95, 0x05, 0xab, - 0xdb, 0x04, 0x45, 0xc8, 0xe8, 0x06, 0x11, 0x80, 0xb8, 0x04, 0x45, 0x3b, - 0xe9, 0x02, 0x11, 0x80, 0x89, 0x04, 0xb0, 0xf0, 0x02, 0x45, 0x85, 0xea, - 0x05, 0x11, 0x80, 0x8e, 0x02, 0xb3, 0x47, 0xb4, 0x11, 0x02, 0x4d, 0x00, - 0x01, 0xff, 0x49, 0x8e, 0xa5, 0x59, 0x11, 0x00, 0x46, 0xfb, 0xcc, 0x4c, - 0x11, 0x40, 0x46, 0x77, 0xd6, 0x10, 0x11, 0x00, 0x45, 0xfe, 0xcd, 0x03, - 0x11, 0xc0, 0x00, 0x8d, 0x01, 0xff, 0x45, 0x62, 0xe5, 0x63, 0xa9, 0x00, - 0x46, 0xfd, 0xa2, 0x17, 0x11, 0x00, 0x45, 0xc8, 0xe8, 0x60, 0xa9, 0x00, - 0x45, 0xf7, 0x84, 0x61, 0xa9, 0x00, 0x45, 0x85, 0xea, 0x5e, 0x11, 0x00, - 0x44, 0x86, 0xbf, 0x62, 0xa9, 0x40, 0x43, 0x2a, 0x42, 0x09, 0x11, 0x80, - 0x57, 0x04, 0x47, 0x2d, 0x01, 0xff, 0x45, 0x62, 0xe5, 0x0d, 0x11, 0x80, - 0x45, 0x45, 0x92, 0xa5, 0x58, 0x11, 0x00, 0x45, 0x37, 0xcc, 0x47, 0x11, - 0x00, 0x46, 0xfd, 0xa2, 0x01, 0x11, 0x00, 0x45, 0x3b, 0xe9, 0x14, 0x11, - 0x00, 0x45, 0xf7, 0x84, 0x08, 0x11, 0x00, 0x45, 0x85, 0xea, 0x19, 0x11, - 0x00, 0x44, 0x86, 0xbf, 0x0a, 0x11, 0x80, 0x14, 0xb4, 0x06, 0x4b, 0x8c, - 0xa5, 0x7c, 0xa9, 0x40, 0x46, 0x77, 0xd6, 0x79, 0xa9, 0x00, 0x45, 0xfe, - 0xcd, 0x04, 0x11, 0x40, 0x46, 0x8c, 0xd8, 0x75, 0xa9, 0x40, 0x46, 0x7a, - 0xd8, 0x78, 0xa9, 0x40, 0x8d, 0x01, 0xff, 0xa3, 0x56, 0x45, 0x92, 0xa5, - 0x3b, 0x11, 0x00, 0x45, 0x37, 0xcc, 0x35, 0x11, 0x00, 0xab, 0x3c, 0x45, - 0xc8, 0xe8, 0x31, 0x11, 0x00, 0x45, 0x3b, 0xe9, 0x2e, 0x11, 0x00, 0xb0, - 0x1b, 0x45, 0x85, 0xea, 0x30, 0x11, 0x00, 0x49, 0x81, 0xbf, 0x34, 0x11, - 0x00, 0xb4, 0x01, 0xff, 0x46, 0x77, 0xd6, 0x39, 0x11, 0x00, 0x45, 0xfe, - 0xcd, 0x2f, 0x11, 0x40, 0x46, 0xf3, 0xc2, 0x3a, 0x11, 0x00, 0x44, 0xf8, - 0x84, 0x32, 0x11, 0xc0, 0x00, 0x47, 0xd9, 0xcd, 0x33, 0x11, 0x40, 0x46, - 0xeb, 0xc2, 0x38, 0x11, 0x00, 0x45, 0xfe, 0xa2, 0x2d, 0x11, 0x40, 0x46, - 0x03, 0xd0, 0x37, 0x11, 0x00, 0x44, 0x04, 0xd0, 0x36, 0x11, 0x40, 0x8d, - 0x01, 0xff, 0x45, 0x62, 0xe5, 0x6d, 0xa9, 0x00, 0x45, 0x92, 0xa5, 0x1a, - 0x11, 0x00, 0xab, 0x37, 0x45, 0xc8, 0xe8, 0x68, 0xa9, 0x00, 0x45, 0x3b, - 0xe9, 0x18, 0x11, 0x00, 0x45, 0xf7, 0x84, 0x69, 0xa9, 0x00, 0xb3, 0x06, - 0x46, 0xfd, 0xcd, 0x66, 0xa9, 0x40, 0x43, 0x2a, 0x42, 0x6c, 0xa9, 0x00, - 0x04, 0x47, 0x2d, 0x01, 0xff, 0x46, 0xfd, 0xa2, 0x65, 0xa9, 0x00, 0x45, - 0xf7, 0x84, 0x6a, 0xa9, 0x00, 0x46, 0xfd, 0xcd, 0x67, 0xa9, 0x40, 0x4c, - 0xf0, 0x84, 0x6b, 0xa9, 0x00, 0x46, 0xeb, 0xc2, 0x6e, 0xa9, 0x00, 0x45, - 0xfe, 0xa2, 0x64, 0xa9, 0x40, 0x46, 0xa2, 0xd4, 0x40, 0x11, 0x00, 0x46, - 0xf3, 0xc2, 0x11, 0x11, 0x80, 0x7a, 0x44, 0xf8, 0x84, 0x07, 0x11, 0xc0, - 0x00, 0x8d, 0x01, 0xff, 0xa3, 0x62, 0x45, 0x92, 0xa5, 0x74, 0xa9, 0x00, - 0xab, 0x4e, 0x45, 0x3b, 0xe9, 0x1f, 0x11, 0x00, 0x47, 0xf2, 0xc2, 0x2a, - 0x11, 0x00, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x46, 0x77, 0xd6, 0x29, 0x11, - 0x00, 0x45, 0xfe, 0xcd, 0x20, 0x11, 0x40, 0x43, 0x2a, 0x42, 0x21, 0x11, - 0x80, 0x06, 0x48, 0x82, 0xbf, 0x25, 0x11, 0x40, 0x8d, 0x01, 0xff, 0x45, - 0x62, 0xe5, 0x26, 0x11, 0x00, 0x46, 0xfd, 0xa2, 0x22, 0x11, 0x00, 0x45, - 0xf7, 0x84, 0x24, 0x11, 0x00, 0xb4, 0x01, 0xff, 0x46, 0x77, 0xd6, 0x72, - 0xa9, 0x00, 0x45, 0xfe, 0xcd, 0x23, 0x11, 0x40, 0x46, 0xeb, 0xc2, 0x73, - 0xa9, 0x00, 0x45, 0xfe, 0xa2, 0x1e, 0x11, 0x40, 0x46, 0x03, 0xd0, 0x28, - 0x11, 0x00, 0x44, 0x04, 0xd0, 0x27, 0x11, 0x40, 0x8d, 0x01, 0xff, 0x45, - 0x92, 0xa5, 0x7a, 0xa9, 0x00, 0x45, 0xf7, 0x84, 0x56, 0x11, 0x40, 0x8d, - 0x01, 0xff, 0x45, 0x62, 0xe5, 0x5c, 0x11, 0x00, 0x45, 0x92, 0xa5, 0x5d, - 0x11, 0x00, 0x46, 0xfd, 0xa2, 0x13, 0x11, 0x00, 0x45, 0xf7, 0x84, 0x16, - 0x11, 0x00, 0x44, 0x86, 0xbf, 0x5b, 0x11, 0x00, 0x46, 0xfd, 0xcd, 0x15, - 0x11, 0x40, 0x8d, 0x01, 0xff, 0x46, 0xfd, 0xa2, 0x6f, 0xa9, 0x00, 0x45, - 0xf7, 0x84, 0x1c, 0x11, 0x00, 0x44, 0x86, 0xbf, 0x71, 0xa9, 0x00, 0x46, - 0xfd, 0xcd, 0x70, 0xa9, 0x40, 0x07, 0xf0, 0x84, 0x13, 0x46, 0xeb, 0xc2, - 0x0f, 0x11, 0x00, 0x45, 0xfe, 0xa2, 0x00, 0x11, 0xc0, 0x00, 0x47, 0xfc, - 0xcd, 0x5a, 0x11, 0x40, 0x45, 0xc8, 0xe8, 0x1d, 0x11, 0x00, 0xb0, 0x0c, - 0x45, 0x85, 0xea, 0x1b, 0x11, 0x00, 0x4a, 0x66, 0xb1, 0x2c, 0x11, 0x40, - 0x46, 0xf3, 0xc2, 0x57, 0x11, 0x00, 0x44, 0xf8, 0x84, 0x2b, 0x11, 0x40, - 0x8d, 0x01, 0xff, 0xa3, 0x41, 0x45, 0x92, 0xa5, 0x77, 0xa9, 0x00, 0x46, - 0xfd, 0xa2, 0x41, 0x11, 0x00, 0x45, 0xc8, 0xe8, 0x43, 0x11, 0x00, 0xb0, - 0x1b, 0x45, 0x85, 0xea, 0x76, 0xa9, 0x00, 0x44, 0x86, 0xbf, 0x45, 0x11, - 0x00, 0xb4, 0x01, 0xff, 0x46, 0x77, 0xd6, 0x4a, 0x11, 0x00, 0x45, 0xfe, - 0xcd, 0x42, 0x11, 0x40, 0x46, 0xa2, 0xd4, 0x46, 0x11, 0x00, 0x46, 0xf3, - 0xc2, 0x4b, 0x11, 0x00, 0x44, 0xf8, 0x84, 0x44, 0x11, 0x40, 0x46, 0x03, - 0xd0, 0x49, 0x11, 0x00, 0x44, 0x04, 0xd0, 0x48, 0x11, 0x40, 0x45, 0x15, - 0xe2, 0x7b, 0xa9, 0x40, 0x0a, 0x2c, 0xaa, 0x54, 0x02, 0x49, 0x00, 0x0d, - 0x44, 0x04, 0xd0, 0x0c, 0x11, 0xc0, 0x00, 0x46, 0x80, 0xd8, 0x4d, 0x11, - 0x40, 0x44, 0x05, 0xd0, 0x0e, 0x11, 0x80, 0x2d, 0x05, 0xbb, 0xeb, 0x01, - 0xff, 0xa3, 0x1a, 0xb3, 0x01, 0xff, 0x43, 0x2a, 0x42, 0x3c, 0x11, 0x00, - 0x04, 0x47, 0x2d, 0x01, 0xff, 0x45, 0x62, 0xe5, 0x4f, 0x11, 0x00, 0x44, - 0x86, 0xbf, 0x3d, 0x11, 0x40, 0x46, 0x03, 0xd0, 0x54, 0x11, 0x00, 0x44, - 0x04, 0xd0, 0x4e, 0x11, 0x40, 0x8d, 0x01, 0xff, 0x45, 0x92, 0xa5, 0x53, - 0x11, 0x00, 0x47, 0xea, 0xc2, 0x52, 0x11, 0x40, 0xa3, 0x1a, 0xb3, 0x01, - 0xff, 0x43, 0x2a, 0x42, 0x3e, 0x11, 0x00, 0x04, 0x47, 0x2d, 0x01, 0xff, - 0x45, 0x62, 0xe5, 0x51, 0x11, 0x00, 0x44, 0x86, 0xbf, 0x3f, 0x11, 0x40, - 0x46, 0x03, 0xd0, 0x55, 0x11, 0x00, 0x44, 0x04, 0xd0, 0x50, 0x11, 0x40, - 0x0c, 0xb0, 0x8b, 0x14, 0x02, 0x16, 0x00, 0x06, 0x45, 0xa2, 0xcd, 0x1d, - 0xf9, 0x41, 0xe7, 0x5c, 0xf4, 0x01, 0x42, 0x60, 0x07, 0x3e, 0xf9, 0x41, - 0x5a, 0x30, 0x1f, 0x1e, 0xf9, 0x01, 0x58, 0xd1, 0x28, 0xf0, 0xfa, 0x41, - 0x46, 0x6c, 0xda, 0x54, 0xf3, 0x01, 0x43, 0x16, 0x38, 0x28, 0xf5, 0x81, - 0x0d, 0xb3, 0x01, 0xff, 0xe1, 0xac, 0xfa, 0x01, 0x48, 0x91, 0xcb, 0x39, - 0xf4, 0x41, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0x40, 0xdf, 0x92, 0x26, - 0x00, 0x46, 0x00, 0xe0, 0x2d, 0x26, 0x00, 0x46, 0x7a, 0xe1, 0xe0, 0xf6, - 0x41, 0x4c, 0x42, 0x11, 0xed, 0xff, 0x00, 0x4f, 0x34, 0x0c, 0xec, 0xff, - 0x00, 0x54, 0x73, 0x42, 0xe8, 0xff, 0x00, 0x07, 0x91, 0xd1, 0xda, 0x02, - 0x0c, 0x4e, 0x20, 0xc9, 0x02, 0x08, 0x99, 0xc7, 0x2c, 0x04, 0xc3, 0x00, - 0x1c, 0x05, 0xc8, 0x00, 0x0c, 0x4d, 0xc3, 0x20, 0xea, 0xff, 0x00, 0x4c, - 0x32, 0x11, 0xee, 0xff, 0x40, 0x4f, 0x3a, 0x69, 0x63, 0xff, 0x00, 0x4b, - 0xb8, 0x02, 0xeb, 0xff, 0x40, 0x4f, 0x3a, 0x69, 0x62, 0xff, 0x00, 0x4b, - 0xb8, 0x02, 0xe9, 0xff, 0x40, 0x80, 0x06, 0x5e, 0x45, 0x12, 0x70, 0xff, - 0x40, 0x07, 0xec, 0x05, 0x12, 0x4a, 0xed, 0x45, 0x65, 0xff, 0x00, 0x56, - 0x36, 0x37, 0x9f, 0xff, 0x00, 0x51, 0x3b, 0x37, 0x9e, 0xff, 0x40, 0xe1, - 0x71, 0xff, 0x00, 0xe5, 0x74, 0xff, 0x00, 0xa8, 0xdc, 0x01, 0xe9, 0x72, - 0xff, 0x00, 0xab, 0xc1, 0x01, 0xad, 0xaa, 0x01, 0xee, 0x9d, 0xff, 0x80, - 0x90, 0x01, 0xef, 0x75, 0xff, 0x00, 0xb2, 0x76, 0xb3, 0x33, 0xb4, 0x1d, - 0xf5, 0x73, 0xff, 0x00, 0xb7, 0x0f, 0xb9, 0x01, 0xff, 0xe1, 0x94, 0xff, - 0x00, 0xef, 0x96, 0xff, 0x00, 0xf5, 0x95, 0xff, 0x40, 0xe1, 0x9c, 0xff, - 0x00, 0xef, 0x66, 0xff, 0x40, 0xe1, 0x80, 0xff, 0x00, 0xe5, 0x83, 0xff, - 0x00, 0xe9, 0x81, 0xff, 0x00, 0xef, 0x84, 0xff, 0x00, 0xf5, 0x82, 0xff, - 0x40, 0xe1, 0x7b, 0xff, 0x00, 0xe5, 0x7e, 0xff, 0x00, 0xe9, 0x7c, 0xff, - 0x00, 0x05, 0x5e, 0x07, 0x08, 0xef, 0x7f, 0xff, 0x00, 0xf5, 0x7d, 0xff, - 0x40, 0xe1, 0x67, 0xff, 0x00, 0xe5, 0x6a, 0xff, 0x00, 0xe9, 0x68, 0xff, - 0x00, 0xef, 0x6b, 0xff, 0x00, 0x42, 0x5c, 0x01, 0x6f, 0xff, 0x00, 0xf5, - 0x69, 0xff, 0x00, 0xb9, 0x01, 0xff, 0xe1, 0x6c, 0xff, 0x00, 0xef, 0x6e, - 0xff, 0x00, 0xf5, 0x6d, 0xff, 0x40, 0xe1, 0x97, 0xff, 0x00, 0xe5, 0x9a, - 0xff, 0x00, 0xe9, 0x98, 0xff, 0x00, 0xef, 0x9b, 0xff, 0x00, 0xf5, 0x99, - 0xff, 0x40, 0xe1, 0x85, 0xff, 0x00, 0xe5, 0x88, 0xff, 0x00, 0xe9, 0x86, - 0xff, 0x00, 0xef, 0x89, 0xff, 0x00, 0xf5, 0x87, 0xff, 0x40, 0xe1, 0x8f, - 0xff, 0x00, 0xe5, 0x92, 0xff, 0x00, 0xe9, 0x90, 0xff, 0x00, 0xef, 0x93, - 0xff, 0x00, 0xf5, 0x91, 0xff, 0x40, 0xe1, 0x76, 0xff, 0x00, 0xe5, 0x79, - 0xff, 0x00, 0xe9, 0x77, 0xff, 0x00, 0xef, 0x7a, 0xff, 0x00, 0xf5, 0x78, - 0xff, 0x40, 0xe1, 0x8a, 0xff, 0x00, 0xe5, 0x8d, 0xff, 0x00, 0xe9, 0x8b, - 0xff, 0x00, 0xef, 0x8e, 0xff, 0x00, 0xf5, 0x8c, 0xff, 0x40, 0x45, 0x13, - 0x05, 0x64, 0xff, 0x00, 0x49, 0x81, 0x16, 0x61, 0xff, 0x40, 0x46, 0xbc, - 0x82, 0xa0, 0xff, 0x00, 0x07, 0xec, 0x05, 0x01, 0xff, 0xe1, 0xc2, 0xff, - 0x80, 0xae, 0x02, 0xa3, 0x9f, 0x02, 0xe5, 0xc7, 0xff, 0x80, 0x91, 0x02, - 0x45, 0x92, 0xa5, 0xbe, 0xff, 0x00, 0xe9, 0xdc, 0xff, 0x80, 0xff, 0x01, - 0xab, 0xe9, 0x01, 0x45, 0xc8, 0xe8, 0xb1, 0xff, 0x00, 0x45, 0x3b, 0xe9, - 0xa4, 0xff, 0x80, 0xcc, 0x01, 0xef, 0xcc, 0xff, 0x80, 0xc2, 0x01, 0xb0, - 0xac, 0x01, 0x45, 0x85, 0xea, 0xa9, 0xff, 0x80, 0x76, 0xb3, 0x4b, 0xb4, - 0x3d, 0xf5, 0xd3, 0xff, 0x00, 0xb7, 0x21, 0xb9, 0x01, 0xff, 0xe1, 0xc4, - 0xff, 0x80, 0x15, 0xe5, 0xcb, 0xff, 0x80, 0x0c, 0xe9, 0xdb, 0xff, 0x00, - 0xef, 0xd2, 0xff, 0x00, 0xf5, 0xd7, 0xff, 0x40, 0xef, 0xca, 0xff, 0x40, - 0xe5, 0xc5, 0xff, 0x40, 0xe1, 0xcd, 0xff, 0x80, 0x0d, 0xe5, 0xd5, 0xff, - 0x80, 0x04, 0xe9, 0xd6, 0xff, 0x40, 0xef, 0xd4, 0xff, 0x40, 0xe5, 0xce, - 0xff, 0x40, 0x46, 0x77, 0xd6, 0xbc, 0xff, 0x00, 0x45, 0xfe, 0xcd, 0xa7, - 0xff, 0x40, 0x43, 0x2a, 0x42, 0xb5, 0xff, 0x00, 0x04, 0x47, 0x2d, 0x01, - 0xff, 0x45, 0x62, 0xe5, 0xb9, 0xff, 0x00, 0x46, 0xfd, 0xa2, 0xa2, 0xff, - 0x00, 0x45, 0xf7, 0x84, 0xb3, 0xff, 0x00, 0x44, 0x86, 0xbf, 0xb6, 0xff, - 0x00, 0x46, 0xfd, 0xcd, 0xa8, 0xff, 0x40, 0x8d, 0x01, 0xff, 0x45, 0x92, - 0xa5, 0xb0, 0xff, 0x00, 0x46, 0xfd, 0xa2, 0xaa, 0xff, 0x00, 0x45, 0xc8, - 0xe8, 0xab, 0xff, 0x00, 0xb0, 0x0c, 0x44, 0x86, 0xbf, 0xad, 0xff, 0x00, - 0x47, 0x76, 0xd6, 0xae, 0xff, 0x40, 0x46, 0xf3, 0xc2, 0xaf, 0xff, 0x00, - 0x44, 0xf8, 0x84, 0xac, 0xff, 0x40, 0x46, 0xf3, 0xc2, 0xbd, 0xff, 0x00, - 0x44, 0xf8, 0x84, 0xb2, 0xff, 0xc0, 0x00, 0x45, 0x15, 0xe2, 0xb4, 0xff, - 0x40, 0xe5, 0xcf, 0xff, 0x40, 0x8d, 0x01, 0xff, 0x45, 0x62, 0xe5, 0xa5, - 0xff, 0x00, 0x45, 0x92, 0xa5, 0xa6, 0xff, 0x40, 0x46, 0xeb, 0xc2, 0xbb, - 0xff, 0x00, 0x45, 0xfe, 0xa2, 0xa1, 0xff, 0xc0, 0x00, 0x45, 0x15, 0xe2, - 0xa3, 0xff, 0x40, 0x44, 0x38, 0xcc, 0xb7, 0xff, 0x40, 0xef, 0xc6, 0xff, - 0x00, 0xf5, 0xda, 0xff, 0x40, 0x46, 0x03, 0xd0, 0xba, 0xff, 0x00, 0x44, - 0x04, 0xd0, 0xb8, 0xff, 0x40, 0xe5, 0xc3, 0xff, 0x40, 0x80, 0x0c, 0x43, - 0xe6, 0x27, 0x87, 0xf4, 0x01, 0x4a, 0xfa, 0xb3, 0xc8, 0xfa, 0x41, 0x44, - 0x40, 0xdf, 0xae, 0xfa, 0x01, 0x45, 0xd7, 0x4c, 0x0a, 0x20, 0x40, 0xa1, - 0xd0, 0x43, 0xa5, 0xfe, 0x38, 0x44, 0xd5, 0x7c, 0x7b, 0xf4, 0x01, 0xa9, - 0xd5, 0x38, 0xac, 0x9f, 0x33, 0xaf, 0xba, 0x31, 0xb2, 0xdb, 0x0e, 0xf3, - 0x1d, 0x00, 0x00, 0xb5, 0x01, 0xff, 0x02, 0x17, 0x00, 0xc3, 0x0e, 0xa9, - 0xb4, 0x0e, 0x07, 0x47, 0xd2, 0xf9, 0x09, 0x0c, 0xc4, 0x92, 0xef, 0x06, - 0xb2, 0x01, 0xff, 0x06, 0x32, 0xde, 0xf4, 0x02, 0x0a, 0xce, 0xb2, 0x01, - 0xff, 0x16, 0x58, 0x33, 0xd2, 0x02, 0x06, 0xef, 0x06, 0x8b, 0x02, 0x07, - 0xec, 0x05, 0x52, 0x05, 0x5a, 0x03, 0x42, 0x06, 0x57, 0x39, 0x01, 0xff, - 0x4b, 0x5d, 0x39, 0x29, 0x61, 0x01, 0x05, 0x5a, 0x03, 0x01, 0xff, 0xa1, - 0x24, 0xe5, 0x23, 0x61, 0x81, 0x1b, 0xe9, 0x1f, 0x61, 0x81, 0x12, 0xef, - 0x26, 0x61, 0x81, 0x09, 0xf5, 0x21, 0x61, 0xc1, 0x00, 0xf5, 0x22, 0x61, - 0x41, 0xef, 0x27, 0x61, 0x41, 0xe9, 0x20, 0x61, 0x41, 0xe5, 0x24, 0x61, - 0x41, 0xe1, 0x1e, 0x61, 0x01, 0xe9, 0x25, 0x61, 0x01, 0xf5, 0x28, 0x61, - 0x41, 0x48, 0x3c, 0x16, 0x2d, 0x61, 0x01, 0x48, 0x99, 0xcb, 0x2f, 0x61, - 0x41, 0xe1, 0x00, 0x61, 0x01, 0xa2, 0xa4, 0x01, 0xa3, 0x97, 0x01, 0xa4, - 0x7f, 0xa7, 0x73, 0x42, 0x22, 0x00, 0x0a, 0x61, 0x01, 0xaa, 0x61, 0xab, - 0x55, 0x42, 0x74, 0x00, 0x1c, 0x61, 0x01, 0x42, 0x6c, 0x00, 0x19, 0x61, - 0x01, 0xae, 0x3d, 0xb0, 0x31, 0x42, 0x71, 0x00, 0x1b, 0x61, 0x01, 0x42, - 0x40, 0x06, 0x1d, 0x61, 0x01, 0xb4, 0x0c, 0x42, 0xf5, 0x0a, 0x0f, 0x61, - 0x01, 0x42, 0xbe, 0x22, 0x1a, 0x61, 0x41, 0xe1, 0x10, 0x61, 0x01, 0x42, - 0x22, 0x00, 0x11, 0x61, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x0b, 0x61, 0x01, - 0x42, 0x22, 0x00, 0x0c, 0x61, 0x41, 0xe1, 0x15, 0x61, 0x01, 0x42, 0x22, - 0x00, 0x16, 0x61, 0x41, 0xe1, 0x14, 0x61, 0x01, 0x42, 0x24, 0x02, 0x05, - 0x61, 0x41, 0xe1, 0x01, 0x61, 0x01, 0x42, 0x22, 0x00, 0x02, 0x61, 0x41, - 0xe1, 0x08, 0x61, 0x01, 0x42, 0x22, 0x00, 0x09, 0x61, 0x41, 0xe1, 0x03, - 0x61, 0x01, 0x42, 0x22, 0x00, 0x04, 0x61, 0x41, 0xe1, 0x12, 0x61, 0x01, - 0xa4, 0x06, 0x42, 0x22, 0x00, 0x13, 0x61, 0x41, 0xe1, 0x0d, 0x61, 0x01, - 0x42, 0x22, 0x00, 0x0e, 0x61, 0x41, 0xe1, 0x06, 0x61, 0x01, 0x42, 0x22, - 0x00, 0x07, 0x61, 0x41, 0xe1, 0x17, 0x61, 0x01, 0x42, 0x22, 0x00, 0x18, - 0x61, 0x41, 0x45, 0x12, 0x0b, 0x38, 0x61, 0x01, 0xa6, 0x2e, 0x44, 0xea, - 0x2a, 0x39, 0x61, 0x01, 0x43, 0x0e, 0x0b, 0x31, 0x61, 0x01, 0xb3, 0x14, - 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x30, 0x61, 0x41, 0x44, 0x25, 0x01, 0x33, - 0x61, 0x01, 0x42, 0x15, 0x02, 0x32, 0x61, 0x41, 0x44, 0xe5, 0x1d, 0x37, - 0x61, 0x01, 0x42, 0x1c, 0x26, 0x36, 0x61, 0x41, 0x43, 0xd2, 0x05, 0x35, - 0x61, 0x01, 0x43, 0xf6, 0x06, 0x34, 0x61, 0x41, 0x42, 0x22, 0x00, 0x2c, - 0x61, 0x01, 0x42, 0x71, 0x00, 0x2e, 0x61, 0x01, 0x42, 0xf5, 0x0a, 0x2b, - 0x61, 0x01, 0x42, 0xbe, 0x22, 0x2a, 0x61, 0x41, 0xa1, 0xe4, 0x03, 0x06, - 0xef, 0x06, 0x9d, 0x03, 0x48, 0xa9, 0xc5, 0x74, 0x0a, 0x00, 0x43, 0xe4, - 0x0a, 0x72, 0x0a, 0x00, 0x07, 0xec, 0x05, 0x6f, 0x05, 0x5a, 0x03, 0x3d, - 0x45, 0x6b, 0xeb, 0x70, 0x0a, 0x00, 0x43, 0x70, 0x00, 0x73, 0x0a, 0x00, - 0x0b, 0x55, 0x77, 0x01, 0xff, 0xa1, 0x1e, 0x42, 0x27, 0x01, 0x47, 0x0a, - 0x00, 0xe9, 0x3f, 0x0a, 0x80, 0x0f, 0x42, 0xcd, 0x02, 0x4b, 0x0a, 0x00, - 0xf5, 0x41, 0x0a, 0xc0, 0x00, 0xf5, 0x42, 0x0a, 0x40, 0xe9, 0x40, 0x0a, - 0x40, 0xe1, 0x3e, 0x0a, 0x00, 0xe9, 0x48, 0x0a, 0x00, 0xf5, 0x4c, 0x0a, - 0x40, 0x4a, 0x84, 0xa7, 0x01, 0x0a, 0x00, 0x45, 0x56, 0x6b, 0x02, 0x0a, - 0x00, 0x45, 0x5a, 0x3f, 0x3c, 0x0a, 0x00, 0x45, 0xde, 0xeb, 0x51, 0x0a, - 0x00, 0x02, 0x02, 0x00, 0x06, 0x46, 0x92, 0xe1, 0x75, 0x0a, 0x40, 0x44, - 0xe7, 0x23, 0x4d, 0x0a, 0x00, 0x45, 0xf3, 0x4b, 0x03, 0x0a, 0x40, 0xe1, - 0x05, 0x0a, 0x80, 0x8c, 0x02, 0xa2, 0xff, 0x01, 0xa3, 0xf2, 0x01, 0xa4, - 0xd9, 0x01, 0x42, 0x27, 0x01, 0x0f, 0x0a, 0x00, 0x42, 0x0c, 0x08, 0x5e, - 0x0a, 0x00, 0xa7, 0xb9, 0x01, 0x42, 0x22, 0x00, 0x39, 0x0a, 0x00, 0xe9, - 0x07, 0x0a, 0x80, 0xa9, 0x01, 0xaa, 0x9c, 0x01, 0xab, 0x88, 0x01, 0xac, - 0x7c, 0x42, 0x6c, 0x00, 0x2e, 0x0a, 0x00, 0xae, 0x5e, 0x42, 0xcd, 0x02, - 0x13, 0x0a, 0x00, 0xb0, 0x4c, 0xb2, 0x40, 0xb3, 0x34, 0xb4, 0x1b, 0xf5, - 0x09, 0x0a, 0x80, 0x12, 0x42, 0xf5, 0x0a, 0x35, 0x0a, 0x00, 0x42, 0xbe, - 0x22, 0x2f, 0x0a, 0x00, 0x42, 0x59, 0x00, 0x5b, 0x0a, 0x40, 0xf5, 0x0a, - 0x0a, 0x40, 0xe1, 0x24, 0x0a, 0x00, 0x42, 0x22, 0x00, 0x25, 0x0a, 0x00, - 0xb4, 0x01, 0xff, 0xe1, 0x1f, 0x0a, 0x00, 0x42, 0x22, 0x00, 0x20, 0x0a, - 0x40, 0xe1, 0x38, 0x0a, 0x00, 0x42, 0x22, 0x00, 0x36, 0x0a, 0x40, 0xe1, - 0x30, 0x0a, 0x00, 0x42, 0x71, 0x00, 0x5c, 0x0a, 0x40, 0xe1, 0x2a, 0x0a, - 0x00, 0x42, 0x22, 0x00, 0x2b, 0x0a, 0x40, 0xe1, 0x28, 0x0a, 0x00, 0x42, - 0x24, 0x02, 0x19, 0x0a, 0x00, 0x42, 0x2a, 0x05, 0x23, 0x0a, 0x00, 0x42, - 0xbe, 0x22, 0x1e, 0x0a, 0x40, 0xe1, 0x32, 0x0a, 0x00, 0x42, 0x74, 0x00, - 0x33, 0x0a, 0x40, 0xe1, 0x15, 0x0a, 0x00, 0xa8, 0x01, 0xff, 0xe1, 0x16, - 0x0a, 0x00, 0x42, 0x22, 0x00, 0x59, 0x0a, 0x40, 0xe1, 0x1c, 0x0a, 0x00, - 0x42, 0x22, 0x00, 0x1d, 0x0a, 0x40, 0xe9, 0x08, 0x0a, 0x40, 0xe1, 0x17, - 0x0a, 0x00, 0xa8, 0x01, 0xff, 0xe1, 0x18, 0x0a, 0x00, 0x42, 0x22, 0x00, - 0x5a, 0x0a, 0x40, 0xe1, 0x26, 0x0a, 0x00, 0xa4, 0x06, 0x42, 0x22, 0x00, - 0x27, 0x0a, 0x40, 0xe1, 0x21, 0x0a, 0x00, 0x42, 0x22, 0x00, 0x22, 0x0a, - 0x40, 0xe1, 0x1a, 0x0a, 0x00, 0x42, 0x22, 0x00, 0x1b, 0x0a, 0x40, 0xe1, - 0x2c, 0x0a, 0x00, 0x42, 0x22, 0x00, 0x2d, 0x0a, 0x40, 0xe1, 0x06, 0x0a, - 0x00, 0xe9, 0x10, 0x0a, 0x00, 0xf5, 0x14, 0x0a, 0x40, 0x45, 0x12, 0x0b, - 0x6e, 0x0a, 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x6f, 0x0a, 0x00, 0x43, - 0x0e, 0x0b, 0x67, 0x0a, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, - 0x66, 0x0a, 0x40, 0x44, 0x25, 0x01, 0x69, 0x0a, 0x00, 0x42, 0x15, 0x02, - 0x68, 0x0a, 0x40, 0x44, 0xe5, 0x1d, 0x6d, 0x0a, 0x00, 0x42, 0x1c, 0x26, - 0x6c, 0x0a, 0x40, 0x43, 0xd2, 0x05, 0x6b, 0x0a, 0x00, 0x43, 0xf6, 0x06, - 0x6a, 0x0a, 0x40, 0x50, 0xe4, 0x57, 0x76, 0x0a, 0x00, 0x44, 0x9d, 0xef, - 0x71, 0x0a, 0x40, 0x06, 0xef, 0x06, 0xbe, 0x02, 0x07, 0xec, 0x05, 0x50, - 0x42, 0x14, 0x05, 0x98, 0x1d, 0x01, 0x05, 0x5a, 0x03, 0x3a, 0xb6, 0x01, - 0xff, 0x45, 0xe6, 0x23, 0x97, 0x1d, 0x01, 0x0a, 0x56, 0x77, 0x01, 0xff, - 0xa1, 0x1e, 0x42, 0x27, 0x01, 0x90, 0x1d, 0x01, 0xe9, 0x8b, 0x1d, 0x81, - 0x0f, 0x42, 0xcd, 0x02, 0x93, 0x1d, 0x01, 0xf5, 0x8d, 0x1d, 0xc1, 0x00, - 0xf5, 0x8e, 0x1d, 0x41, 0xe9, 0x8c, 0x1d, 0x41, 0xe1, 0x8a, 0x1d, 0x01, - 0xe9, 0x91, 0x1d, 0x01, 0xf5, 0x94, 0x1d, 0x41, 0x48, 0x3c, 0x16, 0x95, - 0x1d, 0x01, 0x47, 0xf1, 0x4b, 0x96, 0x1d, 0x41, 0xe1, 0x60, 0x1d, 0x81, - 0xd8, 0x01, 0xa2, 0xcb, 0x01, 0xa3, 0xbe, 0x01, 0xa4, 0xa5, 0x01, 0x42, - 0x27, 0x01, 0x67, 0x1d, 0x01, 0xa7, 0x92, 0x01, 0x42, 0x22, 0x00, 0x87, - 0x1d, 0x01, 0xe9, 0x62, 0x1d, 0x81, 0x82, 0x01, 0xaa, 0x76, 0xab, 0x6a, - 0xac, 0x5e, 0x42, 0x6c, 0x00, 0x70, 0x1d, 0x01, 0xae, 0x4c, 0x42, 0xcd, - 0x02, 0x6a, 0x1d, 0x01, 0xb0, 0x3a, 0x42, 0x71, 0x00, 0x88, 0x1d, 0x01, - 0x42, 0x40, 0x06, 0x89, 0x1d, 0x01, 0xb4, 0x15, 0xf5, 0x64, 0x1d, 0x81, - 0x0c, 0x42, 0xf5, 0x0a, 0x6d, 0x1d, 0x01, 0x42, 0xbe, 0x22, 0x6c, 0x1d, - 0x41, 0xf5, 0x65, 0x1d, 0x41, 0xe1, 0x73, 0x1d, 0x01, 0x42, 0x22, 0x00, - 0x74, 0x1d, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x7d, 0x1d, 0x01, 0x42, 0x22, - 0x00, 0x7e, 0x1d, 0x41, 0xe1, 0x85, 0x1d, 0x01, 0x42, 0x22, 0x00, 0x86, - 0x1d, 0x41, 0xe1, 0x7a, 0x1d, 0x01, 0x42, 0x24, 0x02, 0x84, 0x1d, 0x41, - 0xe1, 0x75, 0x1d, 0x01, 0x42, 0x74, 0x00, 0x7f, 0x1d, 0x41, 0xe1, 0x71, - 0x1d, 0x01, 0x42, 0x22, 0x00, 0x72, 0x1d, 0x41, 0xe1, 0x80, 0x1d, 0x01, - 0x42, 0x22, 0x00, 0x81, 0x1d, 0x41, 0xe9, 0x63, 0x1d, 0x41, 0xe1, 0x76, - 0x1d, 0x01, 0x42, 0x22, 0x00, 0x77, 0x1d, 0x41, 0xe1, 0x78, 0x1d, 0x01, - 0xa4, 0x06, 0x42, 0x22, 0x00, 0x79, 0x1d, 0x41, 0xe1, 0x82, 0x1d, 0x01, - 0x42, 0x22, 0x00, 0x83, 0x1d, 0x41, 0xe1, 0x7b, 0x1d, 0x01, 0x42, 0x22, - 0x00, 0x7c, 0x1d, 0x41, 0xe1, 0x6e, 0x1d, 0x01, 0x42, 0x22, 0x00, 0x6f, - 0x1d, 0x41, 0xe1, 0x61, 0x1d, 0x01, 0xe9, 0x68, 0x1d, 0x01, 0xf5, 0x6b, - 0x1d, 0x41, 0x45, 0x12, 0x0b, 0xa8, 0x1d, 0x01, 0xa6, 0x2e, 0x44, 0xea, - 0x2a, 0xa9, 0x1d, 0x01, 0x43, 0x0e, 0x0b, 0xa1, 0x1d, 0x01, 0xb3, 0x14, - 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xa0, 0x1d, 0x41, 0x44, 0x25, 0x01, 0xa3, - 0x1d, 0x01, 0x42, 0x15, 0x02, 0xa2, 0x1d, 0x41, 0x44, 0xe5, 0x1d, 0xa7, - 0x1d, 0x01, 0x42, 0x1c, 0x26, 0xa6, 0x1d, 0x41, 0x43, 0xd2, 0x05, 0xa5, - 0x1d, 0x01, 0x43, 0xf6, 0x06, 0xa4, 0x1d, 0x41, 0x51, 0xe3, 0x57, 0xf0, - 0x0a, 0x00, 0x06, 0xef, 0x06, 0xe9, 0x03, 0x07, 0xec, 0x05, 0xc6, 0x01, - 0x42, 0x14, 0x05, 0xd0, 0x0a, 0x00, 0x4a, 0x7a, 0x80, 0xf1, 0x0a, 0x00, - 0x05, 0x5a, 0x03, 0x61, 0x06, 0x57, 0x39, 0x01, 0xff, 0x07, 0x3d, 0x61, - 0x50, 0x05, 0x5a, 0x03, 0x01, 0xff, 0xa1, 0x3d, 0x07, 0x3d, 0x61, 0x31, - 0xe5, 0xc7, 0x0a, 0x00, 0xe9, 0xbf, 0x0a, 0x80, 0x24, 0xef, 0xcb, 0x0a, - 0x00, 0xf5, 0xc1, 0x0a, 0x80, 0x17, 0x08, 0x43, 0xc1, 0x01, 0xff, 0xec, - 0xe2, 0x0a, 0x80, 0x09, 0xf2, 0xc3, 0x0a, 0xc0, 0x00, 0xf2, 0xc4, 0x0a, - 0x40, 0xec, 0xe3, 0x0a, 0x40, 0xf5, 0xc2, 0x0a, 0x40, 0xe9, 0xc0, 0x0a, - 0x40, 0xe5, 0xc5, 0x0a, 0x00, 0xef, 0xc9, 0x0a, 0x40, 0xe1, 0xbe, 0x0a, - 0x00, 0xe9, 0xc8, 0x0a, 0x00, 0xf5, 0xcc, 0x0a, 0x40, 0xe5, 0x8d, 0x0a, - 0x00, 0xef, 0x91, 0x0a, 0x40, 0xa1, 0x47, 0xa3, 0x39, 0x46, 0x08, 0xde, - 0xfc, 0x0a, 0x00, 0x45, 0x5a, 0x3f, 0xbc, 0x0a, 0x00, 0xb3, 0x1f, 0xb4, - 0x11, 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0xe7, 0x23, 0xcd, 0x0a, 0x00, - 0x45, 0xf3, 0x4b, 0x83, 0x0a, 0x40, 0x54, 0xff, 0x42, 0xfd, 0x0a, 0x00, - 0x55, 0x50, 0x3f, 0xff, 0x0a, 0x40, 0x45, 0xe8, 0xe6, 0xfb, 0x0a, 0x00, - 0x44, 0x44, 0xeb, 0xfa, 0x0a, 0x40, 0x4a, 0xda, 0x23, 0x81, 0x0a, 0x00, - 0x51, 0x54, 0x3f, 0xfe, 0x0a, 0x40, 0x47, 0x3d, 0x16, 0x82, 0x0a, 0x00, - 0x47, 0xc4, 0x88, 0xbd, 0x0a, 0x40, 0xe1, 0x85, 0x0a, 0x80, 0x8c, 0x02, - 0xa2, 0xff, 0x01, 0xa3, 0xf2, 0x01, 0xa4, 0xd9, 0x01, 0xe5, 0x8f, 0x0a, - 0x00, 0xa7, 0xc8, 0x01, 0x42, 0x22, 0x00, 0xb9, 0x0a, 0x00, 0xe9, 0x87, - 0x0a, 0x80, 0xb8, 0x01, 0xaa, 0xab, 0x01, 0xab, 0x9e, 0x01, 0xac, 0x91, - 0x01, 0x42, 0x6c, 0x00, 0xae, 0x0a, 0x00, 0xae, 0x73, 0xef, 0x93, 0x0a, - 0x00, 0xb0, 0x63, 0x42, 0x71, 0x00, 0xb0, 0x0a, 0x00, 0xb3, 0x4b, 0xb4, - 0x32, 0xf5, 0x89, 0x0a, 0x80, 0x29, 0xb6, 0x0c, 0x42, 0xbe, 0x22, 0xaf, - 0x0a, 0x00, 0x43, 0xec, 0xc0, 0xf9, 0x0a, 0x40, 0xe1, 0xb5, 0x0a, 0x00, - 0x07, 0x44, 0xc1, 0x01, 0xff, 0xec, 0x8c, 0x0a, 0x80, 0x09, 0xf2, 0x8b, - 0x0a, 0xc0, 0x00, 0xf2, 0xe0, 0x0a, 0x40, 0xec, 0xe1, 0x0a, 0x40, 0xf5, - 0x8a, 0x0a, 0x40, 0xe1, 0xa4, 0x0a, 0x00, 0x42, 0x22, 0x00, 0xa5, 0x0a, - 0x00, 0xb4, 0x01, 0xff, 0xe1, 0x9f, 0x0a, 0x00, 0x42, 0x22, 0x00, 0xa0, - 0x0a, 0x40, 0xe1, 0xb8, 0x0a, 0x00, 0x42, 0x22, 0x00, 0xb6, 0x0a, 0x00, - 0x42, 0x40, 0x06, 0xb7, 0x0a, 0x40, 0xe1, 0xaa, 0x0a, 0x00, 0x42, 0x22, - 0x00, 0xab, 0x0a, 0x40, 0xe1, 0xa8, 0x0a, 0x00, 0x42, 0x24, 0x02, 0x99, - 0x0a, 0x00, 0x42, 0x2a, 0x05, 0xa3, 0x0a, 0x00, 0x42, 0xbe, 0x22, 0x9e, - 0x0a, 0x40, 0xe1, 0xb2, 0x0a, 0x00, 0x42, 0x74, 0x00, 0xb3, 0x0a, 0x40, - 0xe1, 0x95, 0x0a, 0x00, 0x42, 0x22, 0x00, 0x96, 0x0a, 0x40, 0xe1, 0x9c, - 0x0a, 0x00, 0x42, 0x22, 0x00, 0x9d, 0x0a, 0x40, 0xe9, 0x88, 0x0a, 0x40, - 0xe1, 0x97, 0x0a, 0x00, 0x42, 0x22, 0x00, 0x98, 0x0a, 0x40, 0xe1, 0xa6, - 0x0a, 0x00, 0xa4, 0x06, 0x42, 0x22, 0x00, 0xa7, 0x0a, 0x40, 0xe1, 0xa1, - 0x0a, 0x00, 0x42, 0x22, 0x00, 0xa2, 0x0a, 0x40, 0xe1, 0x9a, 0x0a, 0x00, - 0x42, 0x22, 0x00, 0x9b, 0x0a, 0x40, 0xe1, 0xac, 0x0a, 0x00, 0x42, 0x22, - 0x00, 0xad, 0x0a, 0x40, 0xe1, 0x86, 0x0a, 0x00, 0xe9, 0x90, 0x0a, 0x00, - 0xf5, 0x94, 0x0a, 0x40, 0x45, 0x12, 0x0b, 0xee, 0x0a, 0x00, 0xa6, 0x2e, - 0x44, 0xea, 0x2a, 0xef, 0x0a, 0x00, 0x43, 0x0e, 0x0b, 0xe7, 0x0a, 0x00, - 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xe6, 0x0a, 0x40, 0x44, 0x25, - 0x01, 0xe9, 0x0a, 0x00, 0x42, 0x15, 0x02, 0xe8, 0x0a, 0x40, 0x44, 0xe5, - 0x1d, 0xed, 0x0a, 0x00, 0x42, 0x1c, 0x26, 0xec, 0x0a, 0x40, 0x43, 0xd2, - 0x05, 0xeb, 0x0a, 0x00, 0x43, 0xf6, 0x06, 0xea, 0x0a, 0x40, 0x46, 0xfc, - 0xda, 0xae, 0xf9, 0x01, 0x43, 0x32, 0x13, 0xb8, 0xf3, 0x41, 0x48, 0x31, - 0x9c, 0xb2, 0x20, 0x00, 0x45, 0xc6, 0xe5, 0x82, 0xf4, 0x41, 0xa1, 0x81, - 0x1f, 0xa5, 0x4d, 0xa9, 0x19, 0xaf, 0x01, 0xff, 0x03, 0x7d, 0x15, 0x06, - 0x4a, 0xaa, 0xb3, 0x97, 0xf4, 0x41, 0x44, 0xb9, 0x00, 0xd2, 0x2b, 0x00, - 0x49, 0xda, 0x20, 0x1d, 0x00, 0x40, 0x4b, 0x5c, 0x9f, 0x2c, 0xf6, 0x01, - 0x06, 0x8c, 0xa2, 0x01, 0xff, 0x5a, 0x64, 0x1f, 0x38, 0xf6, 0x01, 0x44, - 0x0c, 0x08, 0x00, 0xf6, 0xc1, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x5b, - 0xca, 0x1c, 0x2a, 0xf9, 0x01, 0xb3, 0x01, 0xff, 0x4b, 0x73, 0x1f, 0x01, - 0xf6, 0x01, 0x48, 0x81, 0xcb, 0x29, 0xf9, 0x41, 0x0a, 0x8a, 0x00, 0xce, - 0x1c, 0xa5, 0x06, 0x47, 0xdb, 0xd7, 0x76, 0xfa, 0x41, 0x02, 0xbc, 0x00, - 0x1d, 0x02, 0x92, 0x00, 0x01, 0xff, 0x45, 0x77, 0xe4, 0x4f, 0xf3, 0x01, - 0x44, 0x65, 0xef, 0xd7, 0xf4, 0x01, 0x45, 0xae, 0x21, 0x9a, 0xf4, 0x01, - 0x45, 0xda, 0xea, 0x57, 0xf9, 0x41, 0xa1, 0xde, 0x18, 0x4b, 0xbb, 0x99, - 0xd0, 0x03, 0x00, 0x08, 0xe4, 0x05, 0xbe, 0x10, 0xa4, 0xf7, 0x0f, 0xa6, - 0xe8, 0x0f, 0x4b, 0x9c, 0x9c, 0x88, 0x01, 0x01, 0x02, 0x9e, 0x01, 0xb8, - 0x0e, 0xab, 0x9b, 0x0e, 0xac, 0xa9, 0x0d, 0xad, 0x9a, 0x0d, 0x4c, 0x27, - 0x5d, 0x74, 0x03, 0x00, 0xaf, 0xe8, 0x0c, 0xb0, 0xaf, 0x0c, 0x4d, 0xc1, - 0x34, 0x7e, 0x03, 0x00, 0xb2, 0x8f, 0x0c, 0xb3, 0xf4, 0x01, 0xb4, 0xb5, - 0x01, 0x0d, 0xc2, 0x89, 0x9e, 0x01, 0xb6, 0x1a, 0x4b, 0x6b, 0xa5, 0x85, - 0x01, 0x01, 0xb9, 0x06, 0x49, 0xf7, 0xc1, 0x8a, 0x01, 0x41, 0x48, 0xb9, - 0xc1, 0x79, 0x01, 0x01, 0x4c, 0x40, 0x4f, 0x7a, 0x03, 0x40, 0x44, 0xb7, - 0x30, 0xef, 0x1f, 0x00, 0x15, 0x43, 0x3d, 0x01, 0xff, 0xd1, 0x00, 0xd2, - 0x81, 0x4a, 0xd2, 0x01, 0xd2, 0x81, 0x31, 0xd3, 0x02, 0xd2, 0x01, 0xd4, - 0x03, 0xd2, 0x01, 0xd5, 0x04, 0xd2, 0x81, 0x10, 0xd6, 0x05, 0xd2, 0x01, - 0xd7, 0x06, 0xd2, 0x01, 0xd8, 0x07, 0xd2, 0x01, 0xd9, 0x08, 0xd2, 0x41, - 0xd0, 0x18, 0xd2, 0x01, 0xd1, 0x19, 0xd2, 0x01, 0xd2, 0x1a, 0xd2, 0x01, - 0xd3, 0x1b, 0xd2, 0x01, 0xd4, 0x1c, 0xd2, 0x41, 0xd0, 0x13, 0xd2, 0x01, - 0xd1, 0x14, 0xd2, 0x01, 0xd2, 0x15, 0xd2, 0x01, 0xd3, 0x16, 0xd2, 0x01, - 0xd4, 0x17, 0xd2, 0x41, 0xd0, 0x09, 0xd2, 0x01, 0xd1, 0x0a, 0xd2, 0x01, - 0xd2, 0x0b, 0xd2, 0x01, 0xd3, 0x0c, 0xd2, 0x01, 0xd4, 0x0d, 0xd2, 0x01, - 0xd5, 0x0e, 0xd2, 0x01, 0xd6, 0x0f, 0xd2, 0x01, 0xd7, 0x10, 0xd2, 0x01, - 0xd8, 0x11, 0xd2, 0x01, 0xd9, 0x12, 0xd2, 0x41, 0x55, 0x14, 0x39, 0xd3, - 0x03, 0x00, 0x59, 0xb9, 0x23, 0xd4, 0x03, 0x00, 0x4b, 0xc7, 0x23, 0xd2, - 0x03, 0x40, 0x4a, 0xca, 0xa7, 0x7a, 0x01, 0x01, 0xa8, 0x1d, 0x44, 0x24, - 0x6c, 0x84, 0x03, 0x00, 0x51, 0xbb, 0x5d, 0x89, 0x01, 0x01, 0x03, 0x20, - 0x0a, 0x01, 0xff, 0x4a, 0x24, 0x79, 0x7d, 0x01, 0x01, 0x4b, 0x92, 0xa3, - 0x77, 0x01, 0x41, 0x4a, 0xea, 0x95, 0xd1, 0x03, 0x00, 0x04, 0x26, 0x01, - 0x01, 0xff, 0x4a, 0x24, 0x79, 0x7e, 0x01, 0x01, 0x4d, 0xba, 0x87, 0x78, - 0x01, 0x41, 0x4c, 0x60, 0x90, 0x8c, 0x01, 0x01, 0x05, 0x5e, 0x07, 0x28, - 0x16, 0xd0, 0x37, 0x06, 0x4d, 0xe0, 0x8a, 0xa0, 0x01, 0x41, 0x44, 0xbb, - 0x99, 0x66, 0x1d, 0x00, 0x43, 0x79, 0x16, 0x6a, 0x1d, 0x00, 0x45, 0x33, - 0x58, 0x67, 0x1d, 0x00, 0x43, 0xe1, 0x17, 0x69, 0x1d, 0x00, 0x43, 0xf6, - 0x49, 0x68, 0x1d, 0x40, 0x5a, 0xb2, 0x1f, 0x7c, 0x03, 0x00, 0x07, 0xec, - 0x05, 0x11, 0x09, 0xdd, 0x14, 0x01, 0xff, 0x5a, 0xb2, 0x1f, 0x7d, 0x03, - 0x00, 0x53, 0xb9, 0x1f, 0x7b, 0x03, 0x40, 0xa1, 0xf6, 0x07, 0x44, 0xbb, - 0x99, 0xb2, 0x03, 0x00, 0x43, 0x79, 0x16, 0xc7, 0x03, 0x00, 0xa4, 0xdb, - 0x07, 0xa5, 0xd6, 0x05, 0x4b, 0x39, 0x9c, 0xc2, 0x03, 0x00, 0x45, 0x33, - 0x58, 0xb3, 0x03, 0x00, 0x44, 0xe9, 0x95, 0x71, 0x03, 0x00, 0x44, 0xb4, - 0x2e, 0xb9, 0x03, 0x80, 0xac, 0x04, 0xab, 0x9d, 0x04, 0x45, 0x37, 0xe8, - 0xbb, 0x03, 0x00, 0x42, 0xc3, 0x16, 0xbc, 0x03, 0x00, 0x42, 0x3d, 0x16, - 0xbd, 0x03, 0x00, 0x02, 0x14, 0x05, 0x85, 0x02, 0xb0, 0xec, 0x01, 0x43, - 0xf6, 0x49, 0xc1, 0x03, 0x80, 0xd3, 0x01, 0xb3, 0xb2, 0x01, 0xb4, 0xa3, - 0x01, 0x47, 0xc2, 0x89, 0xc5, 0x03, 0x80, 0x0c, 0x42, 0xe2, 0x0c, 0xbe, - 0x03, 0x00, 0x44, 0x85, 0xf3, 0xb6, 0x03, 0x40, 0x06, 0x50, 0x00, 0x01, - 0xff, 0xa4, 0x47, 0x46, 0xb4, 0x70, 0xe1, 0x1f, 0x00, 0x44, 0x19, 0xf2, - 0x7b, 0x1f, 0x00, 0xb0, 0x15, 0x45, 0x23, 0x6c, 0xcd, 0x03, 0x00, 0xb6, - 0x01, 0xff, 0x44, 0xb7, 0x30, 0x7a, 0x1f, 0x00, 0x45, 0x49, 0xea, 0xe0, - 0x1f, 0x40, 0x4a, 0x62, 0xa1, 0xe6, 0x1f, 0x00, 0x44, 0xd8, 0x88, 0x50, - 0x1f, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, 0xf2, 0x54, - 0x1f, 0x00, 0x4b, 0x61, 0xa1, 0x56, 0x1f, 0x00, 0x45, 0xb6, 0x30, 0x52, - 0x1f, 0x40, 0x44, 0x4e, 0x61, 0x51, 0x1f, 0x80, 0x24, 0x48, 0x1a, 0x6c, - 0xcb, 0x03, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, 0xf2, - 0xe3, 0x1f, 0x00, 0x4b, 0x61, 0xa1, 0xe7, 0x1f, 0x00, 0x45, 0x23, 0x6c, - 0xb0, 0x03, 0x00, 0x45, 0xb6, 0x30, 0xe2, 0x1f, 0x40, 0x05, 0x19, 0x00, - 0x01, 0xff, 0x44, 0x19, 0xf2, 0x55, 0x1f, 0x00, 0x4b, 0x61, 0xa1, 0x57, - 0x1f, 0x00, 0x45, 0xb6, 0x30, 0x53, 0x1f, 0x40, 0x42, 0x61, 0x24, 0xc4, - 0x03, 0x00, 0x44, 0xe9, 0x95, 0xb8, 0x03, 0x40, 0xa1, 0x12, 0x42, 0x0b, - 0x00, 0xf8, 0x03, 0x00, 0x44, 0xc1, 0x1f, 0xc3, 0x03, 0x00, 0x45, 0x61, - 0xeb, 0xdb, 0x03, 0x40, 0x43, 0x59, 0x94, 0xe1, 0x03, 0x00, 0xee, 0xfb, - 0x03, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0xb8, 0x76, 0xe5, 0x1f, - 0x00, 0x45, 0x30, 0xea, 0xe4, 0x1f, 0x40, 0x51, 0x27, 0x58, 0x77, 0x03, - 0x00, 0x42, 0x49, 0x00, 0xc6, 0x03, 0x00, 0xe9, 0xc0, 0x03, 0x00, 0x42, - 0x5a, 0x03, 0xc8, 0x03, 0x40, 0x43, 0xce, 0x05, 0xc9, 0x03, 0x80, 0x4e, - 0x45, 0x6a, 0xe7, 0xbf, 0x03, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, - 0x45, 0xb8, 0x76, 0x41, 0x1f, 0x80, 0x2a, 0x44, 0x19, 0xf2, 0x79, 0x1f, - 0x00, 0x45, 0x30, 0xea, 0x40, 0x1f, 0x80, 0x0c, 0x45, 0x23, 0x6c, 0xcc, - 0x03, 0x00, 0x45, 0xb6, 0x30, 0x78, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, - 0xff, 0x44, 0x19, 0xf2, 0x44, 0x1f, 0x00, 0x45, 0xb6, 0x30, 0x42, 0x1f, - 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, 0xf2, 0x45, 0x1f, 0x00, - 0x45, 0xb6, 0x30, 0x43, 0x1f, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, - 0xb8, 0x76, 0x61, 0x1f, 0x80, 0x6e, 0x44, 0x19, 0xf2, 0x7d, 0x1f, 0x80, - 0x61, 0xb0, 0x19, 0x45, 0x23, 0x6c, 0xce, 0x03, 0x00, 0x45, 0xb6, 0x30, - 0x7c, 0x1f, 0x80, 0x06, 0x4d, 0x3f, 0x4f, 0xf3, 0x1f, 0x40, 0x52, 0x3a, - 0x4f, 0xf2, 0x1f, 0x40, 0x4a, 0x62, 0xa1, 0xf6, 0x1f, 0x80, 0x39, 0x44, - 0xd8, 0x88, 0x60, 0x1f, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, - 0x19, 0xf2, 0x64, 0x1f, 0x80, 0x20, 0x4b, 0x61, 0xa1, 0x66, 0x1f, 0x80, - 0x13, 0x45, 0xb6, 0x30, 0x62, 0x1f, 0x80, 0x06, 0x4d, 0x3f, 0x4f, 0xa0, - 0x1f, 0x40, 0x52, 0x3a, 0x4f, 0xa2, 0x1f, 0x40, 0x52, 0x3a, 0x4f, 0xa6, - 0x1f, 0x40, 0x52, 0x3a, 0x4f, 0xa4, 0x1f, 0x40, 0x52, 0x3a, 0x4f, 0xf7, - 0x1f, 0x40, 0x52, 0x3a, 0x4f, 0xf4, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, - 0xff, 0x44, 0x19, 0xf2, 0x65, 0x1f, 0x80, 0x20, 0x4b, 0x61, 0xa1, 0x67, - 0x1f, 0x80, 0x13, 0x45, 0xb6, 0x30, 0x63, 0x1f, 0x80, 0x06, 0x4d, 0x3f, - 0x4f, 0xa1, 0x1f, 0x40, 0x52, 0x3a, 0x4f, 0xa3, 0x1f, 0x40, 0x52, 0x3a, - 0x4f, 0xa7, 0x1f, 0x40, 0x52, 0x3a, 0x4f, 0xa5, 0x1f, 0x40, 0x44, 0xa9, - 0x90, 0xba, 0x03, 0x00, 0x44, 0xc1, 0x80, 0xdf, 0x03, 0x40, 0x06, 0x50, - 0x00, 0x01, 0xff, 0xa4, 0x47, 0x46, 0xb4, 0x70, 0xd1, 0x1f, 0x00, 0x44, - 0x19, 0xf2, 0x77, 0x1f, 0x00, 0xb0, 0x15, 0x45, 0x23, 0x6c, 0xaf, 0x03, - 0x00, 0xb6, 0x01, 0xff, 0x44, 0xb7, 0x30, 0x76, 0x1f, 0x00, 0x45, 0x49, - 0xea, 0xd0, 0x1f, 0x40, 0x4a, 0x62, 0xa1, 0xd6, 0x1f, 0x00, 0x44, 0xd8, - 0x88, 0x30, 0x1f, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, - 0xf2, 0x34, 0x1f, 0x00, 0x4b, 0x61, 0xa1, 0x36, 0x1f, 0x00, 0x45, 0xb6, - 0x30, 0x32, 0x1f, 0x40, 0x44, 0x4e, 0x61, 0x31, 0x1f, 0x80, 0x24, 0x48, - 0x1a, 0x6c, 0xca, 0x03, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, - 0x19, 0xf2, 0xd3, 0x1f, 0x00, 0x4b, 0x61, 0xa1, 0xd7, 0x1f, 0x00, 0x45, - 0x23, 0x6c, 0x90, 0x03, 0x00, 0x45, 0xb6, 0x30, 0xd2, 0x1f, 0x40, 0x05, - 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, 0xf2, 0x35, 0x1f, 0x00, 0x4b, 0x61, - 0xa1, 0x37, 0x1f, 0x00, 0x45, 0xb6, 0x30, 0x33, 0x1f, 0x40, 0x46, 0xcf, - 0x15, 0xb5, 0x03, 0x80, 0xb3, 0x01, 0x42, 0x12, 0x00, 0xb7, 0x03, 0xc0, - 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0xb8, 0x76, 0x21, 0x1f, 0x80, - 0x6e, 0x44, 0x19, 0xf2, 0x75, 0x1f, 0x80, 0x61, 0xb0, 0x19, 0x45, 0x23, - 0x6c, 0xae, 0x03, 0x00, 0x45, 0xb6, 0x30, 0x74, 0x1f, 0x80, 0x06, 0x4d, - 0x3f, 0x4f, 0xc3, 0x1f, 0x40, 0x52, 0x3a, 0x4f, 0xc2, 0x1f, 0x40, 0x4a, - 0x62, 0xa1, 0xc6, 0x1f, 0x80, 0x39, 0x44, 0xd8, 0x88, 0x20, 0x1f, 0xc0, - 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, 0xf2, 0x24, 0x1f, 0x80, - 0x20, 0x4b, 0x61, 0xa1, 0x26, 0x1f, 0x80, 0x13, 0x45, 0xb6, 0x30, 0x22, - 0x1f, 0x80, 0x06, 0x4d, 0x3f, 0x4f, 0x90, 0x1f, 0x40, 0x52, 0x3a, 0x4f, - 0x92, 0x1f, 0x40, 0x52, 0x3a, 0x4f, 0x96, 0x1f, 0x40, 0x52, 0x3a, 0x4f, - 0x94, 0x1f, 0x40, 0x52, 0x3a, 0x4f, 0xc7, 0x1f, 0x40, 0x52, 0x3a, 0x4f, - 0xc4, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, 0xf2, 0x25, - 0x1f, 0x80, 0x20, 0x4b, 0x61, 0xa1, 0x27, 0x1f, 0x80, 0x13, 0x45, 0xb6, - 0x30, 0x23, 0x1f, 0x80, 0x06, 0x4d, 0x3f, 0x4f, 0x91, 0x1f, 0x40, 0x52, - 0x3a, 0x4f, 0x93, 0x1f, 0x40, 0x52, 0x3a, 0x4f, 0x97, 0x1f, 0x40, 0x52, - 0x3a, 0x4f, 0x95, 0x1f, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0xb8, - 0x76, 0x11, 0x1f, 0x80, 0x2a, 0x44, 0x19, 0xf2, 0x73, 0x1f, 0x00, 0x45, - 0x30, 0xea, 0x10, 0x1f, 0x80, 0x0c, 0x45, 0x23, 0x6c, 0xad, 0x03, 0x00, - 0x45, 0xb6, 0x30, 0x72, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, - 0x19, 0xf2, 0x14, 0x1f, 0x00, 0x45, 0xb6, 0x30, 0x12, 0x1f, 0x40, 0x05, - 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, 0xf2, 0x15, 0x1f, 0x00, 0x45, 0xb6, - 0x30, 0x13, 0x1f, 0x40, 0x44, 0x58, 0xd6, 0xb4, 0x03, 0x00, 0x46, 0x32, - 0x58, 0xdd, 0x03, 0x40, 0x44, 0x5f, 0xe4, 0xb1, 0x03, 0x80, 0x11, 0x07, - 0xb9, 0x80, 0x01, 0xff, 0x45, 0xc0, 0x80, 0xd9, 0x03, 0x00, 0x45, 0x57, - 0x94, 0x73, 0x03, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0xb8, 0x76, - 0x01, 0x1f, 0x80, 0x7c, 0x46, 0xb4, 0x70, 0xb1, 0x1f, 0x00, 0x44, 0x19, - 0xf2, 0x71, 0x1f, 0x80, 0x69, 0xb0, 0x21, 0x45, 0x23, 0x6c, 0xac, 0x03, - 0x00, 0xb6, 0x06, 0x4d, 0x3f, 0x4f, 0xb3, 0x1f, 0x40, 0x44, 0xb7, 0x30, - 0x70, 0x1f, 0x80, 0x06, 0x45, 0x49, 0xea, 0xb0, 0x1f, 0x40, 0x52, 0x3a, - 0x4f, 0xb2, 0x1f, 0x40, 0x4a, 0x62, 0xa1, 0xb6, 0x1f, 0x80, 0x39, 0x44, - 0xd8, 0x88, 0x00, 0x1f, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, - 0x19, 0xf2, 0x04, 0x1f, 0x80, 0x20, 0x4b, 0x61, 0xa1, 0x06, 0x1f, 0x80, - 0x13, 0x45, 0xb6, 0x30, 0x02, 0x1f, 0x80, 0x06, 0x4d, 0x3f, 0x4f, 0x80, - 0x1f, 0x40, 0x52, 0x3a, 0x4f, 0x82, 0x1f, 0x40, 0x52, 0x3a, 0x4f, 0x86, - 0x1f, 0x40, 0x52, 0x3a, 0x4f, 0x84, 0x1f, 0x40, 0x52, 0x3a, 0x4f, 0xb7, - 0x1f, 0x40, 0x52, 0x3a, 0x4f, 0xb4, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, - 0xff, 0x44, 0x19, 0xf2, 0x05, 0x1f, 0x80, 0x20, 0x4b, 0x61, 0xa1, 0x07, - 0x1f, 0x80, 0x13, 0x45, 0xb6, 0x30, 0x03, 0x1f, 0x80, 0x06, 0x4d, 0x3f, - 0x4f, 0x81, 0x1f, 0x40, 0x52, 0x3a, 0x4f, 0x83, 0x1f, 0x40, 0x52, 0x3a, - 0x4f, 0x87, 0x1f, 0x40, 0x52, 0x3a, 0x4f, 0x85, 0x1f, 0x40, 0x5d, 0xbf, - 0x15, 0xf6, 0x03, 0x00, 0x03, 0xdb, 0x71, 0x01, 0xff, 0x46, 0x16, 0x08, - 0xf1, 0x03, 0x00, 0x52, 0xc0, 0x56, 0xfc, 0x03, 0x40, 0x4a, 0x62, 0xa1, - 0xc0, 0x1f, 0x00, 0x49, 0xb4, 0xb9, 0xd5, 0x03, 0x00, 0x48, 0x7c, 0xac, - 0xd6, 0x03, 0x00, 0x4d, 0x51, 0x47, 0xbe, 0x1f, 0x00, 0x44, 0xd8, 0x88, - 0xbf, 0x1f, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, 0xf2, - 0xce, 0x1f, 0x00, 0x4b, 0x61, 0xa1, 0xcf, 0x1f, 0x00, 0x45, 0xb6, 0x30, - 0xcd, 0x1f, 0x40, 0x48, 0x61, 0xc4, 0x7c, 0x01, 0x01, 0x03, 0xef, 0x07, - 0x0c, 0x4a, 0xd8, 0xb2, 0x84, 0x01, 0x01, 0x43, 0x62, 0x4b, 0xfd, 0x1f, - 0x40, 0x49, 0x87, 0xb9, 0x75, 0x01, 0x81, 0x06, 0x4c, 0x14, 0x94, 0x8b, - 0x01, 0x41, 0x4f, 0x0d, 0x69, 0x76, 0x01, 0x41, 0x4c, 0xc8, 0x8e, 0x81, - 0x01, 0x01, 0x4d, 0xf6, 0x89, 0x45, 0xd2, 0x41, 0x06, 0xed, 0x05, 0x1d, - 0x49, 0xe6, 0xba, 0x83, 0x01, 0x01, 0x51, 0x22, 0x5d, 0x75, 0x03, 0x00, - 0x06, 0xc8, 0x15, 0x01, 0xff, 0x4e, 0xce, 0x15, 0xf5, 0x03, 0x00, 0x4c, - 0xc0, 0x1f, 0xf2, 0x03, 0x40, 0x4d, 0xb8, 0x80, 0xd8, 0x03, 0x00, 0x47, - 0x31, 0x58, 0xdc, 0x03, 0x00, 0x45, 0xc0, 0x80, 0xde, 0x03, 0x00, 0xb3, - 0x06, 0x43, 0xfd, 0xf4, 0xf3, 0x03, 0x40, 0x44, 0x58, 0x94, 0xe0, 0x03, - 0x00, 0x0d, 0xe2, 0x3c, 0x06, 0x45, 0x61, 0xeb, 0xda, 0x03, 0x40, 0x45, - 0x33, 0x58, 0x26, 0x1d, 0x00, 0x45, 0x37, 0xe8, 0x27, 0x1d, 0x00, 0x45, - 0x59, 0xaf, 0x65, 0xab, 0x00, 0xb0, 0x06, 0x43, 0xf6, 0x49, 0x29, 0x1d, - 0x40, 0xe9, 0x28, 0x1d, 0x00, 0x42, 0x5a, 0x03, 0x2a, 0x1d, 0x40, 0xa1, - 0x0c, 0x46, 0xf7, 0x61, 0xbd, 0x1f, 0x00, 0x50, 0xed, 0x68, 0x82, 0x01, - 0x41, 0x48, 0x7c, 0xac, 0xd7, 0x03, 0x00, 0x4a, 0xaa, 0x90, 0xf0, 0x03, - 0x40, 0x4c, 0x08, 0x8e, 0x8d, 0x01, 0x01, 0x1b, 0xa2, 0x1d, 0x01, 0xff, - 0xd1, 0x1d, 0xd2, 0x81, 0x79, 0xd2, 0x1e, 0xd2, 0x81, 0x5c, 0x93, 0x42, - 0xd4, 0x1f, 0xd2, 0x81, 0x21, 0xd5, 0x20, 0xd2, 0x81, 0x08, 0xd7, 0x21, - 0xd2, 0x01, 0xd8, 0x22, 0xd2, 0x41, 0xd0, 0x3d, 0xd2, 0x01, 0xd1, 0x3e, - 0xd2, 0x01, 0xd2, 0x3f, 0xd2, 0x01, 0xd3, 0x40, 0xd2, 0x01, 0xd4, 0x41, - 0xd2, 0x41, 0xd0, 0x36, 0xd2, 0x01, 0xd2, 0x37, 0xd2, 0x01, 0xd3, 0x38, - 0xd2, 0x01, 0xd5, 0x39, 0xd2, 0x01, 0xd7, 0x3a, 0xd2, 0x01, 0xd8, 0x3b, - 0xd2, 0x01, 0xd9, 0x3c, 0xd2, 0x41, 0xd0, 0x30, 0xd2, 0x01, 0xd2, 0x31, - 0xd2, 0x01, 0xd6, 0x32, 0xd2, 0x01, 0xd7, 0x33, 0xd2, 0x01, 0xd8, 0x34, - 0xd2, 0x01, 0xd9, 0x35, 0xd2, 0x41, 0xd3, 0x2a, 0xd2, 0x01, 0xd4, 0x2b, - 0xd2, 0x01, 0xd5, 0x2c, 0xd2, 0x01, 0xd6, 0x2d, 0xd2, 0x01, 0xd7, 0x2e, - 0xd2, 0x01, 0xd9, 0x2f, 0xd2, 0x41, 0xd1, 0x23, 0xd2, 0x01, 0xd2, 0x24, - 0xd2, 0x01, 0xd3, 0x25, 0xd2, 0x01, 0xd4, 0x26, 0xd2, 0x01, 0xd7, 0x27, - 0xd2, 0x01, 0xd8, 0x28, 0xd2, 0x01, 0xd9, 0x29, 0xd2, 0x41, 0x4e, 0x20, - 0x79, 0x80, 0x01, 0x01, 0x4e, 0xe0, 0x7a, 0x7f, 0x01, 0x41, 0x44, 0x4e, - 0x61, 0xfe, 0x1f, 0x80, 0x26, 0x09, 0x1a, 0x6c, 0x06, 0x4b, 0xcf, 0xa1, - 0x7b, 0x01, 0x41, 0x04, 0x1a, 0x00, 0x06, 0x45, 0x23, 0x6c, 0x85, 0x03, - 0x40, 0x44, 0x19, 0xf2, 0xee, 0x1f, 0x00, 0x4b, 0x61, 0xa1, 0xc1, 0x1f, - 0x00, 0x45, 0xb6, 0x30, 0xed, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, - 0x44, 0x19, 0xf2, 0xde, 0x1f, 0x00, 0x4b, 0x61, 0xa1, 0xdf, 0x1f, 0x00, - 0x45, 0xb6, 0x30, 0xdd, 0x1f, 0x40, 0x5a, 0xb2, 0x1f, 0xfe, 0x03, 0x00, - 0x4a, 0x7a, 0xac, 0xcf, 0x03, 0x00, 0xac, 0x16, 0x09, 0xdd, 0x14, 0x06, - 0x4c, 0xe8, 0x95, 0xf4, 0x03, 0x40, 0x5a, 0xb2, 0x1f, 0xff, 0x03, 0x00, - 0x53, 0xb9, 0x1f, 0xfd, 0x03, 0x40, 0x06, 0xed, 0x05, 0x06, 0x52, 0xba, - 0x1f, 0xf9, 0x03, 0x40, 0xa1, 0xb3, 0x06, 0x44, 0xbb, 0x99, 0x92, 0x03, - 0x00, 0x43, 0x79, 0x16, 0xa7, 0x03, 0x00, 0x45, 0x9e, 0xe5, 0x94, 0x03, - 0x00, 0xa5, 0xb3, 0x04, 0x45, 0x33, 0x58, 0x93, 0x03, 0x00, 0x44, 0xe9, - 0x95, 0x70, 0x03, 0x00, 0x44, 0xb4, 0x2e, 0x99, 0x03, 0x80, 0xb5, 0x03, - 0x45, 0xa8, 0x90, 0x9a, 0x03, 0x00, 0x45, 0x37, 0xe8, 0x9b, 0x03, 0x00, - 0x42, 0xc3, 0x16, 0x9c, 0x03, 0x00, 0x42, 0x3d, 0x16, 0x9d, 0x03, 0x00, - 0x02, 0x14, 0x05, 0xae, 0x01, 0xb0, 0x95, 0x01, 0x43, 0xf6, 0x49, 0xa1, - 0x03, 0x80, 0x87, 0x01, 0xb3, 0x73, 0xb4, 0x65, 0x47, 0xc2, 0x89, 0xa5, - 0x03, 0x80, 0x12, 0x42, 0xe2, 0x0c, 0x9e, 0x03, 0x00, 0x43, 0xfd, 0xf4, - 0x7f, 0x03, 0x00, 0x44, 0x85, 0xf3, 0x96, 0x03, 0x40, 0x06, 0x50, 0x00, - 0x01, 0xff, 0xa4, 0x21, 0x46, 0xb4, 0x70, 0xe9, 0x1f, 0x00, 0x44, 0x19, - 0xf2, 0xeb, 0x1f, 0x00, 0x45, 0x23, 0x6c, 0x8e, 0x03, 0x00, 0xb6, 0x01, - 0xff, 0x44, 0xb7, 0x30, 0xea, 0x1f, 0x00, 0x45, 0x49, 0xea, 0xe8, 0x1f, - 0x40, 0x44, 0x4e, 0x61, 0x59, 0x1f, 0x80, 0x06, 0x48, 0x1a, 0x6c, 0xab, - 0x03, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, 0xf2, 0x5d, 0x1f, - 0x00, 0x4b, 0x61, 0xa1, 0x5f, 0x1f, 0x00, 0x45, 0xb6, 0x30, 0x5b, 0x1f, - 0x40, 0x42, 0x61, 0x24, 0xa4, 0x03, 0x00, 0x44, 0xe9, 0x95, 0x98, 0x03, - 0x40, 0x42, 0x1a, 0x00, 0xfa, 0x03, 0x00, 0x42, 0x0b, 0x00, 0xf7, 0x03, - 0x00, 0x44, 0xc1, 0x1f, 0xa3, 0x03, 0x40, 0x4b, 0x19, 0x98, 0xec, 0x1f, - 0x40, 0x51, 0x27, 0x58, 0x76, 0x03, 0x00, 0x42, 0x49, 0x00, 0xa6, 0x03, - 0x00, 0xe9, 0xa0, 0x03, 0x00, 0x42, 0x5a, 0x03, 0xa8, 0x03, 0x40, 0x43, - 0xce, 0x05, 0xa9, 0x03, 0x80, 0x4e, 0x45, 0x6a, 0xe7, 0x9f, 0x03, 0xc0, - 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0xb8, 0x76, 0x49, 0x1f, 0x80, - 0x2a, 0x44, 0x19, 0xf2, 0xf9, 0x1f, 0x00, 0x45, 0x30, 0xea, 0x48, 0x1f, - 0x80, 0x0c, 0x45, 0x23, 0x6c, 0x8c, 0x03, 0x00, 0x45, 0xb6, 0x30, 0xf8, - 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, 0xf2, 0x4c, 0x1f, - 0x00, 0x45, 0xb6, 0x30, 0x4a, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, - 0x44, 0x19, 0xf2, 0x4d, 0x1f, 0x00, 0x45, 0xb6, 0x30, 0x4b, 0x1f, 0x40, - 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0xb8, 0x76, 0x69, 0x1f, 0x80, 0x55, - 0x44, 0x19, 0xf2, 0xfb, 0x1f, 0x00, 0xb0, 0x0c, 0x45, 0x23, 0x6c, 0x8f, - 0x03, 0x00, 0x45, 0xb6, 0x30, 0xfa, 0x1f, 0x40, 0x4d, 0x51, 0x47, 0xfc, - 0x1f, 0x00, 0x44, 0xd8, 0x88, 0x68, 0x1f, 0xc0, 0x00, 0x05, 0x19, 0x00, - 0x01, 0xff, 0x44, 0x19, 0xf2, 0x6c, 0x1f, 0x80, 0x22, 0xb0, 0x0d, 0x45, - 0xb6, 0x30, 0x6a, 0x1f, 0xc0, 0x00, 0x53, 0x4b, 0x47, 0xaa, 0x1f, 0x40, - 0x4a, 0x62, 0xa1, 0x6e, 0x1f, 0x80, 0x06, 0x4d, 0x51, 0x47, 0xa8, 0x1f, - 0x40, 0x53, 0x4b, 0x47, 0xae, 0x1f, 0x40, 0x53, 0x4b, 0x47, 0xac, 0x1f, - 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, 0xf2, 0x6d, 0x1f, 0x80, - 0x22, 0xb0, 0x0d, 0x45, 0xb6, 0x30, 0x6b, 0x1f, 0xc0, 0x00, 0x53, 0x4b, - 0x47, 0xab, 0x1f, 0x40, 0x4a, 0x62, 0xa1, 0x6f, 0x1f, 0x80, 0x06, 0x4d, - 0x51, 0x47, 0xa9, 0x1f, 0x40, 0x53, 0x4b, 0x47, 0xaf, 0x1f, 0x40, 0x53, - 0x4b, 0x47, 0xad, 0x1f, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0xa4, 0x3f, - 0x46, 0xb4, 0x70, 0xd9, 0x1f, 0x00, 0x44, 0x19, 0xf2, 0xdb, 0x1f, 0x00, - 0x45, 0x30, 0xea, 0x38, 0x1f, 0x80, 0x15, 0x45, 0x23, 0x6c, 0x8a, 0x03, - 0x00, 0xb6, 0x01, 0xff, 0x44, 0xb7, 0x30, 0xda, 0x1f, 0x00, 0x45, 0x49, - 0xea, 0xd8, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, 0xf2, - 0x3c, 0x1f, 0x00, 0x4b, 0x61, 0xa1, 0x3e, 0x1f, 0x00, 0x45, 0xb6, 0x30, - 0x3a, 0x1f, 0x40, 0x44, 0x4e, 0x61, 0x39, 0x1f, 0x80, 0x06, 0x48, 0x1a, - 0x6c, 0xaa, 0x03, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, 0xf2, - 0x3d, 0x1f, 0x00, 0x4b, 0x61, 0xa1, 0x3f, 0x1f, 0x00, 0x45, 0xb6, 0x30, - 0x3b, 0x1f, 0x40, 0x46, 0xcf, 0x15, 0x95, 0x03, 0x80, 0x9c, 0x01, 0x42, - 0x12, 0x00, 0x97, 0x03, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, - 0xb8, 0x76, 0x29, 0x1f, 0x80, 0x55, 0x44, 0x19, 0xf2, 0xcb, 0x1f, 0x00, - 0xb0, 0x0c, 0x45, 0x23, 0x6c, 0x89, 0x03, 0x00, 0x45, 0xb6, 0x30, 0xca, - 0x1f, 0x40, 0x4d, 0x51, 0x47, 0xcc, 0x1f, 0x00, 0x44, 0xd8, 0x88, 0x28, - 0x1f, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, 0xf2, 0x2c, - 0x1f, 0x80, 0x22, 0xb0, 0x0d, 0x45, 0xb6, 0x30, 0x2a, 0x1f, 0xc0, 0x00, - 0x53, 0x4b, 0x47, 0x9a, 0x1f, 0x40, 0x4a, 0x62, 0xa1, 0x2e, 0x1f, 0x80, - 0x06, 0x4d, 0x51, 0x47, 0x98, 0x1f, 0x40, 0x53, 0x4b, 0x47, 0x9e, 0x1f, - 0x40, 0x53, 0x4b, 0x47, 0x9c, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, - 0x44, 0x19, 0xf2, 0x2d, 0x1f, 0x80, 0x22, 0xb0, 0x0d, 0x45, 0xb6, 0x30, - 0x2b, 0x1f, 0xc0, 0x00, 0x53, 0x4b, 0x47, 0x9b, 0x1f, 0x40, 0x4a, 0x62, - 0xa1, 0x2f, 0x1f, 0x80, 0x06, 0x4d, 0x51, 0x47, 0x99, 0x1f, 0x40, 0x53, - 0x4b, 0x47, 0x9f, 0x1f, 0x40, 0x53, 0x4b, 0x47, 0x9d, 0x1f, 0x40, 0x06, - 0x50, 0x00, 0x01, 0xff, 0x45, 0xb8, 0x76, 0x19, 0x1f, 0x80, 0x2a, 0x44, - 0x19, 0xf2, 0xc9, 0x1f, 0x00, 0x45, 0x30, 0xea, 0x18, 0x1f, 0x80, 0x0c, - 0x45, 0x23, 0x6c, 0x88, 0x03, 0x00, 0x45, 0xb6, 0x30, 0xc8, 0x1f, 0x40, - 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, 0xf2, 0x1c, 0x1f, 0x00, 0x45, - 0xb6, 0x30, 0x1a, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, - 0xf2, 0x1d, 0x1f, 0x00, 0x45, 0xb6, 0x30, 0x1b, 0x1f, 0x40, 0x44, 0x5f, - 0xe4, 0x91, 0x03, 0x80, 0x06, 0x4c, 0x50, 0x94, 0x72, 0x03, 0x40, 0x06, - 0x50, 0x00, 0x01, 0xff, 0x45, 0xb8, 0x76, 0x09, 0x1f, 0x80, 0x64, 0x46, - 0xb4, 0x70, 0xb9, 0x1f, 0x00, 0x44, 0x19, 0xf2, 0xbb, 0x1f, 0x00, 0xb0, - 0x15, 0x45, 0x23, 0x6c, 0x86, 0x03, 0x00, 0xb6, 0x01, 0xff, 0x44, 0xb7, - 0x30, 0xba, 0x1f, 0x00, 0x45, 0x49, 0xea, 0xb8, 0x1f, 0x40, 0x4d, 0x51, - 0x47, 0xbc, 0x1f, 0x00, 0x44, 0xd8, 0x88, 0x08, 0x1f, 0xc0, 0x00, 0x05, - 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, 0xf2, 0x0c, 0x1f, 0x80, 0x22, 0xb0, - 0x0d, 0x45, 0xb6, 0x30, 0x0a, 0x1f, 0xc0, 0x00, 0x53, 0x4b, 0x47, 0x8a, - 0x1f, 0x40, 0x4a, 0x62, 0xa1, 0x0e, 0x1f, 0x80, 0x06, 0x4d, 0x51, 0x47, - 0x88, 0x1f, 0x40, 0x53, 0x4b, 0x47, 0x8e, 0x1f, 0x40, 0x53, 0x4b, 0x47, - 0x8c, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0x19, 0xf2, 0x0d, - 0x1f, 0x80, 0x22, 0xb0, 0x0d, 0x45, 0xb6, 0x30, 0x0b, 0x1f, 0xc0, 0x00, - 0x53, 0x4b, 0x47, 0x8b, 0x1f, 0x40, 0x4a, 0x62, 0xa1, 0x0f, 0x1f, 0x80, - 0x06, 0x4d, 0x51, 0x47, 0x89, 0x1f, 0x40, 0x53, 0x4b, 0x47, 0x8f, 0x1f, - 0x40, 0x53, 0x4b, 0x47, 0x8d, 0x1f, 0x40, 0x0a, 0x00, 0xa9, 0x15, 0x49, - 0xb1, 0xbc, 0x87, 0x03, 0x00, 0xb2, 0x01, 0xff, 0x49, 0xad, 0xbd, 0x87, - 0x01, 0x01, 0x49, 0xb7, 0xbf, 0x86, 0x01, 0x41, 0x06, 0x1e, 0xda, 0xe6, - 0x01, 0xa3, 0xd7, 0x01, 0x51, 0xae, 0x59, 0x73, 0x01, 0x01, 0x0b, 0xf7, - 0x9b, 0xb9, 0x01, 0x03, 0x2c, 0x1a, 0x97, 0x01, 0x4d, 0xf3, 0x85, 0x63, - 0x01, 0x01, 0x53, 0x60, 0x4b, 0x70, 0x01, 0x01, 0x53, 0x4e, 0x4d, 0x74, - 0x01, 0x01, 0xb4, 0x01, 0xff, 0x08, 0xd1, 0xc6, 0x30, 0x0a, 0xa8, 0xb0, - 0x01, 0xff, 0x02, 0xf3, 0x02, 0x0d, 0x43, 0xdb, 0x06, 0x60, 0x01, 0xc1, - 0x00, 0x4f, 0x0d, 0x69, 0x61, 0x01, 0x41, 0x43, 0x59, 0x4d, 0x66, 0x01, - 0x81, 0x0d, 0x42, 0x32, 0x00, 0x5f, 0x01, 0xc1, 0x00, 0x48, 0x70, 0x11, - 0x6d, 0x01, 0x41, 0x4f, 0x0d, 0x69, 0x67, 0x01, 0x41, 0x02, 0xf3, 0x02, - 0x33, 0x43, 0x0e, 0x0b, 0x59, 0x01, 0x81, 0x1d, 0xb4, 0x01, 0xff, 0x42, - 0x92, 0x01, 0x64, 0x01, 0x01, 0xa8, 0x06, 0x42, 0x15, 0x02, 0x5c, 0x01, - 0x41, 0x44, 0x7b, 0x11, 0x65, 0x01, 0x01, 0x4b, 0x17, 0x18, 0x6b, 0x01, - 0x41, 0x80, 0x01, 0xff, 0x47, 0x71, 0x11, 0x6a, 0x01, 0x01, 0x48, 0x47, - 0x5e, 0x71, 0x01, 0x41, 0x43, 0x59, 0x4d, 0x69, 0x01, 0x01, 0x03, 0x5f, - 0x00, 0x01, 0xff, 0x47, 0x71, 0x11, 0x6e, 0x01, 0x01, 0x48, 0x47, 0x5e, - 0x72, 0x01, 0x41, 0x51, 0xf4, 0x57, 0x58, 0x01, 0x01, 0x08, 0x71, 0xc8, - 0x01, 0xff, 0x45, 0x57, 0x4d, 0x68, 0x01, 0x01, 0x43, 0x0e, 0x0b, 0x5a, - 0x01, 0x01, 0x43, 0xdb, 0x06, 0x62, 0x01, 0x41, 0x4c, 0x9b, 0x39, 0x6c, - 0x01, 0x01, 0x43, 0x1f, 0x0a, 0x5b, 0x01, 0xc1, 0x00, 0x49, 0x42, 0x47, - 0x5e, 0x01, 0x41, 0x55, 0x92, 0x39, 0x6f, 0x01, 0x01, 0x54, 0x37, 0x47, - 0x5d, 0x01, 0x41, 0x02, 0xf3, 0x02, 0x5a, 0x04, 0x0e, 0x0b, 0x20, 0x04, - 0x43, 0x5e, 0x01, 0xff, 0x44, 0x5d, 0x4d, 0x57, 0x01, 0x01, 0x47, 0x3d, - 0x6e, 0x50, 0x01, 0x01, 0xb4, 0x01, 0xff, 0x46, 0xbb, 0xc2, 0x49, 0x01, - 0x01, 0x4f, 0x35, 0x6e, 0x55, 0x01, 0x41, 0x47, 0x43, 0x47, 0x42, 0x01, - 0x01, 0xa8, 0x17, 0x47, 0x2a, 0x01, 0x40, 0x01, 0x01, 0x09, 0x47, 0x5e, - 0x01, 0xff, 0x47, 0x3d, 0x6e, 0x54, 0x01, 0x01, 0x47, 0xba, 0xc2, 0x4d, - 0x01, 0x41, 0x43, 0x23, 0x00, 0x41, 0x01, 0x01, 0x07, 0x72, 0x11, 0x01, - 0xff, 0x47, 0x3d, 0x6e, 0x52, 0x01, 0x01, 0x47, 0xba, 0xc2, 0x4b, 0x01, - 0x41, 0x43, 0x59, 0x4d, 0x44, 0x01, 0x81, 0x3c, 0x42, 0x32, 0x00, 0x43, - 0x01, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x47, 0x71, 0x11, 0x45, 0x01, 0x81, - 0x1c, 0x47, 0x3d, 0x6e, 0x4f, 0x01, 0x01, 0xb4, 0x01, 0xff, 0x46, 0xbb, - 0xc2, 0x48, 0x01, 0x01, 0x47, 0x08, 0x3c, 0x46, 0x01, 0xc1, 0x00, 0x48, - 0xb9, 0xc2, 0x4e, 0x01, 0x41, 0x80, 0x01, 0xff, 0x47, 0x3d, 0x6e, 0x53, - 0x01, 0x01, 0x47, 0xba, 0xc2, 0x4c, 0x01, 0x41, 0x80, 0x01, 0xff, 0x47, - 0x3d, 0x6e, 0x51, 0x01, 0x01, 0xb4, 0x01, 0xff, 0x46, 0xbb, 0xc2, 0x4a, - 0x01, 0x01, 0x47, 0x08, 0x3c, 0x47, 0x01, 0xc1, 0x00, 0x48, 0x3c, 0x6e, - 0x56, 0x01, 0x41, 0xa1, 0x9c, 0x01, 0xa2, 0x82, 0x01, 0x4f, 0xce, 0x6b, - 0xa7, 0x2a, 0x80, 0x75, 0x55, 0x0c, 0x3b, 0xdb, 0x22, 0x00, 0xaf, 0x1d, - 0x44, 0x5a, 0x03, 0x3e, 0x00, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4d, - 0x88, 0x81, 0x7a, 0x2a, 0x00, 0x43, 0x23, 0x0a, 0xd7, 0x22, 0x00, 0x53, - 0x57, 0x4c, 0x7c, 0x2a, 0x40, 0x02, 0x18, 0x00, 0x11, 0x03, 0x32, 0x00, - 0x01, 0xff, 0x49, 0xf7, 0x0c, 0x67, 0x22, 0x00, 0x51, 0xac, 0x5b, 0xa4, - 0x2a, 0x40, 0x4b, 0xcc, 0x1e, 0x86, 0x2a, 0x00, 0x03, 0x7b, 0x00, 0x25, - 0x49, 0xec, 0x00, 0x77, 0x22, 0x00, 0x50, 0x3d, 0x67, 0x7e, 0x2a, 0xc0, - 0x00, 0x0a, 0x90, 0x3b, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x82, 0x2a, 0x80, - 0x06, 0x46, 0xa7, 0x13, 0x80, 0x2a, 0x40, 0x45, 0xc2, 0x00, 0x84, 0x2a, - 0x40, 0x45, 0xfb, 0x0c, 0x65, 0x22, 0x00, 0x4a, 0xf1, 0x39, 0x73, 0x22, - 0x40, 0x54, 0x93, 0x00, 0xa9, 0x2a, 0x40, 0x4f, 0xcd, 0x6c, 0xa5, 0x2a, - 0x00, 0x0a, 0xe7, 0x39, 0x01, 0xff, 0x45, 0xfb, 0x0c, 0x69, 0x22, 0x00, - 0x4a, 0xf1, 0x39, 0xe7, 0x22, 0x40, 0x05, 0x5d, 0x00, 0x11, 0x03, 0x1b, - 0x00, 0x01, 0xff, 0x4f, 0xd8, 0x70, 0x8a, 0x2a, 0x00, 0x58, 0x11, 0x2b, - 0x88, 0x2a, 0x40, 0x61, 0xa8, 0x0d, 0x8c, 0x2a, 0x00, 0x61, 0x0b, 0x0e, - 0x92, 0x2a, 0x00, 0x50, 0xb3, 0x02, 0x78, 0x29, 0x00, 0xb3, 0x01, 0xff, - 0x07, 0x16, 0xd2, 0x06, 0x70, 0xd9, 0x00, 0x94, 0x2a, 0x40, 0x4f, 0xe6, - 0x00, 0x90, 0x2a, 0x00, 0x48, 0x0e, 0x29, 0x8e, 0x2a, 0x40, 0x4b, 0x73, - 0x9b, 0x93, 0xf3, 0x01, 0x05, 0x63, 0xe9, 0x0c, 0x43, 0x4a, 0x65, 0x47, - 0xf3, 0x01, 0x49, 0x1a, 0x23, 0x60, 0x00, 0x40, 0x4e, 0x1e, 0x76, 0x57, - 0x13, 0x01, 0x07, 0xec, 0x05, 0x8b, 0x01, 0x42, 0x14, 0x05, 0x50, 0x13, - 0x01, 0x05, 0x5a, 0x03, 0x48, 0x0b, 0x55, 0x77, 0x01, 0xff, 0xa1, 0x35, - 0x42, 0x27, 0x01, 0x47, 0x13, 0x01, 0xe9, 0x3f, 0x13, 0x81, 0x26, 0x42, - 0xcd, 0x02, 0x4b, 0x13, 0x01, 0xf5, 0x41, 0x13, 0x81, 0x17, 0x08, 0x43, - 0xc1, 0x01, 0xff, 0xec, 0x62, 0x13, 0x81, 0x09, 0xf2, 0x43, 0x13, 0xc1, - 0x00, 0xf2, 0x44, 0x13, 0x41, 0xec, 0x63, 0x13, 0x41, 0xf5, 0x42, 0x13, - 0x41, 0xe9, 0x40, 0x13, 0x41, 0xe1, 0x3e, 0x13, 0x01, 0xe9, 0x48, 0x13, - 0x01, 0xf5, 0x4c, 0x13, 0x41, 0xa1, 0x2b, 0xa3, 0x1d, 0x45, 0x5a, 0x3f, - 0x3c, 0x13, 0x01, 0x45, 0x12, 0xea, 0x5d, 0x13, 0x01, 0x02, 0x02, 0x00, - 0x01, 0xff, 0x44, 0xe7, 0x23, 0x4d, 0x13, 0x01, 0x45, 0xf3, 0x4b, 0x03, - 0x13, 0x41, 0x4a, 0xda, 0x23, 0x01, 0x13, 0x01, 0x57, 0x33, 0x16, 0x00, - 0x13, 0x41, 0x47, 0x3d, 0x16, 0x02, 0x13, 0x01, 0x47, 0xc4, 0x88, 0x3d, - 0x13, 0x41, 0xe1, 0x05, 0x13, 0x81, 0x9a, 0x02, 0xa2, 0x8d, 0x02, 0xa3, - 0x80, 0x02, 0xa4, 0xe7, 0x01, 0x42, 0x27, 0x01, 0x0f, 0x13, 0x01, 0xa7, - 0xd4, 0x01, 0x42, 0x22, 0x00, 0x39, 0x13, 0x01, 0xe9, 0x07, 0x13, 0x81, - 0xc4, 0x01, 0xaa, 0xb7, 0x01, 0xab, 0xaa, 0x01, 0xac, 0x9d, 0x01, 0x42, - 0x6c, 0x00, 0x2e, 0x13, 0x01, 0xae, 0x7f, 0x42, 0xcd, 0x02, 0x13, 0x13, - 0x01, 0xb0, 0x6d, 0x42, 0x71, 0x00, 0x30, 0x13, 0x01, 0xb3, 0x55, 0xb4, - 0x3c, 0xf5, 0x09, 0x13, 0x81, 0x33, 0xb6, 0x06, 0x42, 0xbe, 0x22, 0x2f, - 0x13, 0x41, 0xe1, 0x35, 0x13, 0x01, 0x05, 0xda, 0x0a, 0x17, 0x07, 0x44, - 0xc1, 0x01, 0xff, 0xec, 0x0c, 0x13, 0x81, 0x09, 0xf2, 0x0b, 0x13, 0xc1, - 0x00, 0xf2, 0x60, 0x13, 0x41, 0xec, 0x61, 0x13, 0x41, 0x48, 0x3c, 0x16, - 0x5e, 0x13, 0x01, 0x4f, 0x52, 0x17, 0x5f, 0x13, 0x41, 0xf5, 0x0a, 0x13, - 0x41, 0xe1, 0x24, 0x13, 0x01, 0x42, 0x22, 0x00, 0x25, 0x13, 0x01, 0xb4, - 0x01, 0xff, 0xe1, 0x1f, 0x13, 0x01, 0x42, 0x22, 0x00, 0x20, 0x13, 0x41, - 0xe1, 0x38, 0x13, 0x01, 0x42, 0x22, 0x00, 0x36, 0x13, 0x01, 0x42, 0x40, - 0x06, 0x37, 0x13, 0x41, 0xe1, 0x2a, 0x13, 0x01, 0x42, 0x22, 0x00, 0x2b, - 0x13, 0x41, 0xe1, 0x28, 0x13, 0x01, 0x42, 0x24, 0x02, 0x19, 0x13, 0x01, - 0x42, 0x2a, 0x05, 0x23, 0x13, 0x01, 0x42, 0xbe, 0x22, 0x1e, 0x13, 0x41, - 0xe1, 0x32, 0x13, 0x01, 0x42, 0x74, 0x00, 0x33, 0x13, 0x41, 0xe1, 0x15, - 0x13, 0x01, 0x42, 0x22, 0x00, 0x16, 0x13, 0x41, 0xe1, 0x1c, 0x13, 0x01, - 0x42, 0x22, 0x00, 0x1d, 0x13, 0x41, 0xe9, 0x08, 0x13, 0x41, 0xe1, 0x17, - 0x13, 0x01, 0x42, 0x22, 0x00, 0x18, 0x13, 0x41, 0xe1, 0x26, 0x13, 0x01, - 0xa4, 0x06, 0x42, 0x22, 0x00, 0x27, 0x13, 0x41, 0xe1, 0x21, 0x13, 0x01, - 0x42, 0x22, 0x00, 0x22, 0x13, 0x41, 0xe1, 0x1a, 0x13, 0x01, 0x42, 0x22, - 0x00, 0x1b, 0x13, 0x41, 0xe1, 0x2c, 0x13, 0x01, 0x42, 0x22, 0x00, 0x2d, - 0x13, 0x41, 0xe1, 0x06, 0x13, 0x01, 0xe9, 0x10, 0x13, 0x01, 0xf5, 0x14, - 0x13, 0x41, 0xa1, 0xd5, 0x01, 0x45, 0xef, 0xdc, 0x7d, 0xf9, 0x01, 0x44, - 0x1d, 0xf1, 0xcc, 0xf3, 0x01, 0x46, 0x68, 0xde, 0x7d, 0xf7, 0x01, 0x43, - 0xa4, 0x0d, 0xbf, 0xfa, 0x01, 0x45, 0x8a, 0xea, 0x8d, 0xf9, 0x01, 0x0c, - 0xf4, 0x95, 0x01, 0xff, 0xa1, 0xa3, 0x01, 0x47, 0x6f, 0xcf, 0x31, 0x03, - 0x01, 0x44, 0x95, 0xef, 0x33, 0x03, 0x01, 0x43, 0x29, 0xac, 0x39, 0x03, - 0x01, 0x45, 0x7a, 0xe6, 0x46, 0x03, 0x01, 0x44, 0x19, 0xf0, 0x32, 0x03, - 0x01, 0xa8, 0x77, 0xa9, 0x69, 0x43, 0x01, 0xbb, 0x3e, 0x03, 0x01, 0x45, - 0x0f, 0xe8, 0x3a, 0x03, 0x01, 0x45, 0x2d, 0xe8, 0x3b, 0x03, 0x01, 0x45, - 0xe0, 0x91, 0x3c, 0x03, 0x01, 0xae, 0x38, 0x45, 0xcc, 0xe9, 0x49, 0x03, - 0x01, 0x48, 0xd9, 0xc9, 0x40, 0x03, 0x01, 0x48, 0x29, 0xca, 0x35, 0x03, - 0x01, 0x45, 0x4e, 0xea, 0x42, 0x03, 0x01, 0x45, 0xe4, 0xea, 0x43, 0x03, - 0x01, 0xb4, 0x0c, 0x44, 0x05, 0xf3, 0x3f, 0x03, 0x01, 0x45, 0x7e, 0xec, - 0x45, 0x03, 0x41, 0x44, 0xc9, 0xef, 0x44, 0x03, 0x01, 0x45, 0x2e, 0xe7, - 0x38, 0x03, 0x41, 0x45, 0xa9, 0xe4, 0x3d, 0x03, 0x01, 0x03, 0xee, 0x07, - 0x01, 0xff, 0x48, 0x70, 0x11, 0x4a, 0x03, 0x01, 0x42, 0x7d, 0x11, 0x41, - 0x03, 0x41, 0x44, 0x0d, 0xf0, 0x47, 0x03, 0x01, 0x43, 0x75, 0xcb, 0x36, - 0x03, 0x41, 0x43, 0x96, 0x91, 0x37, 0x03, 0x01, 0x44, 0x45, 0xf3, 0x48, - 0x03, 0x41, 0x43, 0xac, 0xe4, 0x30, 0x03, 0x01, 0x45, 0x6f, 0xe7, 0x34, - 0x03, 0x41, 0x45, 0x19, 0xe8, 0x45, 0xf9, 0x01, 0xf4, 0x10, 0xf4, 0x41, - 0xa1, 0x1b, 0x4a, 0xf0, 0xa9, 0xe6, 0x29, 0x00, 0xaf, 0x01, 0xff, 0x51, - 0x8d, 0x58, 0x10, 0xf3, 0x01, 0x43, 0x3c, 0x4b, 0xe4, 0xf9, 0x01, 0x49, - 0x67, 0xc1, 0x1f, 0xf3, 0x41, 0x08, 0x8c, 0x5b, 0x06, 0x4a, 0x52, 0xb1, - 0x5b, 0xf9, 0x41, 0x0f, 0xe4, 0x05, 0xc6, 0x02, 0x0d, 0x76, 0x08, 0x01, - 0xff, 0x43, 0x16, 0xf4, 0x30, 0x2c, 0x00, 0xa2, 0xac, 0x02, 0xa3, 0x9d, - 0x02, 0xa4, 0x88, 0x02, 0xa6, 0xf9, 0x01, 0x47, 0x67, 0xd1, 0x33, 0x2c, - 0x00, 0x44, 0x4d, 0xf0, 0x48, 0x2c, 0x00, 0xe9, 0x3b, 0x2c, 0x80, 0xc2, - 0x01, 0x44, 0xe5, 0xf0, 0x3d, 0x2c, 0x00, 0xac, 0xad, 0x01, 0x47, 0x04, - 0x6b, 0x3f, 0x2c, 0x00, 0x45, 0x13, 0xe9, 0x40, 0x2c, 0x00, 0xaf, 0x92, - 0x01, 0xb0, 0x85, 0x01, 0x45, 0x8f, 0xea, 0x43, 0x2c, 0x00, 0xb3, 0x51, - 0xb4, 0x3d, 0x43, 0x2a, 0xd6, 0x46, 0x2c, 0x00, 0x44, 0x19, 0xf3, 0x32, - 0x2c, 0x00, 0xb9, 0x0f, 0xba, 0x01, 0xff, 0x45, 0x11, 0xe6, 0x38, 0x2c, - 0x00, 0x46, 0xac, 0xdc, 0x36, 0x2c, 0x40, 0x43, 0xb3, 0x00, 0x51, 0x2c, - 0x00, 0xa5, 0x08, 0xef, 0x56, 0x2c, 0x00, 0xf5, 0x53, 0x2c, 0x40, 0xb2, - 0x06, 0x43, 0x26, 0x0a, 0x35, 0x2c, 0x40, 0xe9, 0x50, 0x2c, 0x00, 0xf5, - 0x4f, 0x2c, 0x40, 0x4b, 0x5e, 0xa2, 0x5d, 0x2c, 0x00, 0x42, 0x5a, 0x03, - 0x4c, 0x2c, 0x00, 0x45, 0x47, 0xec, 0x45, 0x2c, 0x40, 0xa8, 0x19, 0x44, - 0x35, 0xf1, 0x44, 0x2c, 0x00, 0x48, 0x67, 0xbf, 0x54, 0x2c, 0x80, 0x06, - 0x49, 0x2b, 0xbe, 0x52, 0x2c, 0x40, 0x4a, 0xbc, 0xa6, 0x55, 0x2c, 0x40, - 0xe1, 0x4e, 0x2c, 0x00, 0x42, 0x12, 0x00, 0x4b, 0x2c, 0xc0, 0x00, 0x43, - 0x19, 0x8b, 0x5c, 0x2c, 0x40, 0xe5, 0x4a, 0x2c, 0x00, 0x45, 0x53, 0xdf, - 0x42, 0x2c, 0x40, 0x42, 0x3d, 0x16, 0x41, 0x2c, 0x00, 0x42, 0x5c, 0x01, - 0x49, 0x2c, 0x40, 0x4f, 0xfc, 0x6a, 0x5e, 0x2c, 0x00, 0x46, 0x13, 0xd3, - 0x3e, 0x2c, 0x40, 0x4b, 0x43, 0xa0, 0x3a, 0x2c, 0x00, 0x07, 0xa0, 0x21, - 0x0f, 0x02, 0x6f, 0x28, 0x01, 0xff, 0xe5, 0x39, 0x2c, 0x00, 0x44, 0xef, - 0x85, 0x5b, 0x2c, 0x40, 0x47, 0x99, 0xcf, 0x59, 0x2c, 0x00, 0x49, 0x66, - 0xbf, 0x57, 0x2c, 0x40, 0x43, 0xe7, 0x05, 0x5a, 0x2c, 0x00, 0x44, 0x7b, - 0xbf, 0x47, 0x2c, 0x40, 0x45, 0xc9, 0xe7, 0x3c, 0x2c, 0x00, 0x44, 0xdd, - 0xf1, 0x34, 0x2c, 0x00, 0x44, 0x81, 0xf3, 0x37, 0x2c, 0x40, 0x4d, 0xf9, - 0x80, 0x5f, 0x2c, 0x00, 0x45, 0x01, 0x81, 0x4d, 0x2c, 0x40, 0x46, 0x9a, - 0xcf, 0x58, 0x2c, 0x00, 0x43, 0xaf, 0xd2, 0x31, 0x2c, 0x40, 0x43, 0x16, - 0xf4, 0x00, 0x2c, 0x00, 0xa2, 0xac, 0x02, 0xa3, 0x9d, 0x02, 0xa4, 0x88, - 0x02, 0xa6, 0xf9, 0x01, 0x47, 0x67, 0xd1, 0x03, 0x2c, 0x00, 0x44, 0x4d, - 0xf0, 0x18, 0x2c, 0x00, 0xe9, 0x0b, 0x2c, 0x80, 0xc2, 0x01, 0x44, 0xe5, - 0xf0, 0x0d, 0x2c, 0x00, 0xac, 0xad, 0x01, 0x47, 0x04, 0x6b, 0x0f, 0x2c, - 0x00, 0x45, 0x13, 0xe9, 0x10, 0x2c, 0x00, 0xaf, 0x92, 0x01, 0xb0, 0x85, - 0x01, 0x45, 0x8f, 0xea, 0x13, 0x2c, 0x00, 0xb3, 0x51, 0xb4, 0x3d, 0x43, - 0x2a, 0xd6, 0x16, 0x2c, 0x00, 0x44, 0x19, 0xf3, 0x02, 0x2c, 0x00, 0xb9, - 0x0f, 0xba, 0x01, 0xff, 0x45, 0x11, 0xe6, 0x08, 0x2c, 0x00, 0x46, 0xac, - 0xdc, 0x06, 0x2c, 0x40, 0x43, 0xb3, 0x00, 0x21, 0x2c, 0x00, 0xa5, 0x08, - 0xef, 0x26, 0x2c, 0x00, 0xf5, 0x23, 0x2c, 0x40, 0xb2, 0x06, 0x43, 0x26, - 0x0a, 0x05, 0x2c, 0x40, 0xe9, 0x20, 0x2c, 0x00, 0xf5, 0x1f, 0x2c, 0x40, - 0x4b, 0x5e, 0xa2, 0x2d, 0x2c, 0x00, 0x42, 0x5a, 0x03, 0x1c, 0x2c, 0x00, - 0x45, 0x47, 0xec, 0x15, 0x2c, 0x40, 0xa8, 0x19, 0x44, 0x35, 0xf1, 0x14, - 0x2c, 0x00, 0x48, 0x67, 0xbf, 0x24, 0x2c, 0x80, 0x06, 0x49, 0x2b, 0xbe, - 0x22, 0x2c, 0x40, 0x4a, 0xbc, 0xa6, 0x25, 0x2c, 0x40, 0xe1, 0x1e, 0x2c, - 0x00, 0x42, 0x12, 0x00, 0x1b, 0x2c, 0xc0, 0x00, 0x43, 0x19, 0x8b, 0x2c, - 0x2c, 0x40, 0xe5, 0x1a, 0x2c, 0x00, 0x45, 0x53, 0xdf, 0x12, 0x2c, 0x40, - 0x42, 0x3d, 0x16, 0x11, 0x2c, 0x00, 0x42, 0x5c, 0x01, 0x19, 0x2c, 0x40, - 0x4f, 0xfc, 0x6a, 0x2e, 0x2c, 0x00, 0x46, 0x13, 0xd3, 0x0e, 0x2c, 0x40, - 0x4b, 0x43, 0xa0, 0x0a, 0x2c, 0x00, 0x07, 0xa0, 0x21, 0x0f, 0x02, 0x6f, - 0x28, 0x01, 0xff, 0xe5, 0x09, 0x2c, 0x00, 0x44, 0xef, 0x85, 0x2b, 0x2c, - 0x40, 0x47, 0x99, 0xcf, 0x29, 0x2c, 0x00, 0x49, 0x66, 0xbf, 0x27, 0x2c, - 0x40, 0x43, 0xe7, 0x05, 0x2a, 0x2c, 0x00, 0x44, 0x7b, 0xbf, 0x17, 0x2c, - 0x40, 0x45, 0xc9, 0xe7, 0x0c, 0x2c, 0x00, 0x44, 0xdd, 0xf1, 0x04, 0x2c, - 0x00, 0x44, 0x81, 0xf3, 0x07, 0x2c, 0x40, 0x4d, 0xf9, 0x80, 0x2f, 0x2c, - 0x00, 0x45, 0x01, 0x81, 0x1d, 0x2c, 0x40, 0x46, 0x9a, 0xcf, 0x28, 0x2c, - 0x00, 0x43, 0xaf, 0xd2, 0x01, 0x2c, 0x40, 0x4a, 0xf6, 0xad, 0x37, 0x21, - 0x00, 0x49, 0x72, 0xbc, 0xda, 0xfa, 0x01, 0xb2, 0x01, 0xff, 0x49, 0xdf, - 0xb5, 0x92, 0xf9, 0x01, 0xec, 0x67, 0xf4, 0xc1, 0x00, 0x48, 0x7e, 0x4b, - 0xca, 0xf6, 0x41, 0x42, 0x17, 0x00, 0x99, 0x26, 0x80, 0xb6, 0x0a, 0xad, - 0xa7, 0x0a, 0x43, 0x62, 0x7e, 0xde, 0xf9, 0x01, 0xaf, 0x0c, 0x4f, 0xc7, - 0x72, 0xb0, 0x20, 0x00, 0x47, 0x3e, 0xd6, 0x13, 0x30, 0x40, 0xad, 0x81, - 0x09, 0x06, 0xee, 0x9b, 0x01, 0xff, 0x0f, 0xe4, 0x05, 0xf3, 0x06, 0x07, - 0xec, 0x05, 0xc1, 0x04, 0x18, 0x39, 0x2a, 0x8f, 0x02, 0x53, 0x1e, 0x4c, - 0xfb, 0x10, 0x00, 0x0d, 0x76, 0x08, 0x01, 0xff, 0xa1, 0xf7, 0x01, 0x43, - 0x26, 0x16, 0x01, 0x2d, 0x00, 0xa3, 0xd4, 0x01, 0x43, 0x6c, 0x11, 0x03, - 0x2d, 0x00, 0x42, 0x92, 0x01, 0x04, 0x2d, 0x00, 0xa7, 0xb9, 0x01, 0xa8, - 0x9c, 0x01, 0x42, 0x9e, 0x01, 0x08, 0x2d, 0x00, 0xaa, 0x87, 0x01, 0xab, - 0x79, 0x43, 0x49, 0x0e, 0x0a, 0x2d, 0x00, 0x43, 0x5d, 0x18, 0x0b, 0x2d, - 0x00, 0x43, 0x38, 0x27, 0x0c, 0x2d, 0x00, 0x42, 0x10, 0x00, 0x0d, 0x2d, - 0x00, 0xb0, 0x53, 0x43, 0xaf, 0xf4, 0x17, 0x2d, 0x00, 0x43, 0x8a, 0x82, - 0x10, 0x2d, 0x00, 0xb3, 0x39, 0x02, 0x12, 0x00, 0x2d, 0x42, 0x42, 0x0b, - 0x13, 0x2d, 0x00, 0x43, 0x0c, 0x2b, 0x05, 0x2d, 0x00, 0x42, 0x15, 0x01, - 0x23, 0x2d, 0x00, 0x43, 0x24, 0xef, 0x1e, 0x2d, 0x00, 0x42, 0x1f, 0x1d, - 0x27, 0x2d, 0x00, 0xba, 0x01, 0xff, 0x42, 0x92, 0x01, 0x06, 0x2d, 0x00, - 0x43, 0xc9, 0x02, 0x0f, 0x2d, 0x40, 0xee, 0x07, 0x2d, 0x00, 0xf2, 0x12, - 0x2d, 0x40, 0x42, 0x1a, 0x00, 0x11, 0x2d, 0x00, 0x43, 0x7a, 0x16, 0x18, - 0x2d, 0x40, 0x42, 0x17, 0x00, 0x0e, 0x2d, 0x00, 0x43, 0xc9, 0x02, 0x14, - 0x2d, 0x40, 0x42, 0x1a, 0x00, 0x09, 0x2d, 0x00, 0x43, 0xc9, 0x02, 0x15, - 0x2d, 0x40, 0x43, 0x90, 0x00, 0x1f, 0x2d, 0x00, 0x42, 0x62, 0x01, 0x1b, - 0x2d, 0x40, 0xa1, 0x10, 0xe5, 0x21, 0x2d, 0x00, 0x42, 0xf4, 0x02, 0x22, - 0x2d, 0x00, 0x42, 0x67, 0x51, 0x25, 0x2d, 0x40, 0xe5, 0x20, 0x2d, 0x00, - 0xf2, 0x24, 0x2d, 0x40, 0x42, 0x1a, 0x00, 0x02, 0x2d, 0x00, 0x43, 0x90, - 0x00, 0x16, 0x2d, 0x40, 0x42, 0x1a, 0x00, 0x1a, 0x2d, 0x00, 0xa8, 0x06, - 0x42, 0x62, 0x01, 0x1c, 0x2d, 0x40, 0x42, 0x17, 0x00, 0x1d, 0x2d, 0x00, - 0x42, 0x9e, 0x01, 0x19, 0x2d, 0x40, 0x42, 0x92, 0x01, 0x2d, 0x2d, 0x00, - 0xee, 0x00, 0x2d, 0x40, 0xa1, 0x9a, 0x02, 0x43, 0x26, 0x16, 0x91, 0x1c, - 0x00, 0xa3, 0xf7, 0x01, 0x43, 0x6c, 0x11, 0x93, 0x1c, 0x00, 0xa5, 0xe4, - 0x01, 0x42, 0xf3, 0x02, 0xb6, 0x1c, 0x00, 0xa7, 0xcf, 0x01, 0xa8, 0xab, - 0x01, 0x42, 0x9e, 0x01, 0x98, 0x1c, 0x00, 0xaa, 0x96, 0x01, 0xab, 0x87, - 0x01, 0x02, 0x74, 0x00, 0x79, 0x43, 0x5d, 0x18, 0x9b, 0x1c, 0x00, 0x43, - 0x38, 0x27, 0x9c, 0x1c, 0x00, 0x42, 0x10, 0x00, 0x9d, 0x1c, 0x00, 0xb0, - 0x59, 0x43, 0xaf, 0xf4, 0xa7, 0x1c, 0x00, 0x43, 0x8a, 0x82, 0xa0, 0x1c, - 0x00, 0xb3, 0x3f, 0xb4, 0x2d, 0x42, 0x42, 0x0b, 0xa3, 0x1c, 0x00, 0x43, - 0x0c, 0x2b, 0x95, 0x1c, 0x00, 0x42, 0x15, 0x01, 0xb3, 0x1c, 0x00, 0x43, - 0x24, 0xef, 0xae, 0x1c, 0x00, 0x42, 0x1f, 0x1d, 0xb7, 0x1c, 0x00, 0xba, - 0x01, 0xff, 0x42, 0x92, 0x01, 0x96, 0x1c, 0x00, 0x43, 0xc9, 0x02, 0x9f, - 0x1c, 0x40, 0xa1, 0x06, 0x49, 0xc5, 0xc0, 0xb9, 0x1c, 0x40, 0xee, 0x97, - 0x1c, 0x00, 0xf2, 0xa2, 0x1c, 0x40, 0x42, 0x1a, 0x00, 0xa1, 0x1c, 0x00, - 0x43, 0x7a, 0x16, 0xa8, 0x1c, 0x40, 0x42, 0x17, 0x00, 0x9e, 0x1c, 0x00, - 0x43, 0xc9, 0x02, 0xa4, 0x1c, 0x40, 0x49, 0xb7, 0xb6, 0xbf, 0x1c, 0x00, - 0xf3, 0x9a, 0x1c, 0x40, 0x42, 0x1a, 0x00, 0x99, 0x1c, 0x00, 0x43, 0xc9, - 0x02, 0xa5, 0x1c, 0x40, 0x43, 0x90, 0x00, 0xaf, 0x1c, 0x00, 0x42, 0x62, - 0x01, 0xab, 0x1c, 0x40, 0xa1, 0x10, 0xe5, 0xb1, 0x1c, 0x00, 0x42, 0xf4, - 0x02, 0xb2, 0x1c, 0x00, 0x42, 0x67, 0x51, 0xb5, 0x1c, 0x40, 0xe5, 0xb0, - 0x1c, 0x00, 0xf2, 0xb4, 0x1c, 0xc0, 0x00, 0x46, 0xb7, 0x47, 0xbe, 0x1c, - 0x40, 0x42, 0x1a, 0x00, 0x92, 0x1c, 0x00, 0x43, 0x90, 0x00, 0xa6, 0x1c, - 0x40, 0x44, 0xe9, 0x88, 0xb8, 0x1c, 0x00, 0xee, 0x94, 0x1c, 0x40, 0x42, - 0x1a, 0x00, 0xaa, 0x1c, 0x00, 0xa8, 0x06, 0x42, 0x62, 0x01, 0xac, 0x1c, - 0x40, 0x42, 0x17, 0x00, 0xad, 0x1c, 0x00, 0x42, 0x9e, 0x01, 0xa9, 0x1c, - 0x40, 0x42, 0x92, 0x01, 0xbd, 0x1c, 0x00, 0x42, 0x9e, 0x01, 0xba, 0x1c, - 0x00, 0xee, 0x90, 0x1c, 0x40, 0xa1, 0x9a, 0x02, 0x43, 0x26, 0x16, 0xd1, - 0x10, 0x00, 0xa3, 0xf7, 0x01, 0x43, 0x6c, 0x11, 0xd3, 0x10, 0x00, 0xa5, - 0xe4, 0x01, 0x42, 0xf3, 0x02, 0xf6, 0x10, 0x00, 0xa7, 0xcf, 0x01, 0xa8, - 0xab, 0x01, 0x42, 0x9e, 0x01, 0xd8, 0x10, 0x00, 0xaa, 0x96, 0x01, 0xab, - 0x87, 0x01, 0x02, 0x74, 0x00, 0x79, 0x43, 0x5d, 0x18, 0xdb, 0x10, 0x00, - 0x43, 0x38, 0x27, 0xdc, 0x10, 0x00, 0x42, 0x10, 0x00, 0xdd, 0x10, 0x00, - 0xb0, 0x59, 0x43, 0xaf, 0xf4, 0xe7, 0x10, 0x00, 0x43, 0x8a, 0x82, 0xe0, - 0x10, 0x00, 0xb3, 0x3f, 0xb4, 0x2d, 0x42, 0x42, 0x0b, 0xe3, 0x10, 0x00, - 0x43, 0x0c, 0x2b, 0xd5, 0x10, 0x00, 0x42, 0x15, 0x01, 0xf3, 0x10, 0x00, - 0x43, 0x24, 0xef, 0xee, 0x10, 0x00, 0x42, 0x1f, 0x1d, 0xf7, 0x10, 0x00, - 0xba, 0x01, 0xff, 0x42, 0x92, 0x01, 0xd6, 0x10, 0x00, 0x43, 0xc9, 0x02, - 0xdf, 0x10, 0x40, 0xa1, 0x06, 0x49, 0xc5, 0xc0, 0xf9, 0x10, 0x40, 0xee, - 0xd7, 0x10, 0x00, 0xf2, 0xe2, 0x10, 0x40, 0x42, 0x1a, 0x00, 0xe1, 0x10, - 0x00, 0x43, 0x7a, 0x16, 0xe8, 0x10, 0x40, 0x42, 0x17, 0x00, 0xde, 0x10, - 0x00, 0x43, 0xc9, 0x02, 0xe4, 0x10, 0x40, 0x49, 0xb7, 0xb6, 0xff, 0x10, - 0x00, 0xf3, 0xda, 0x10, 0x40, 0x42, 0x1a, 0x00, 0xd9, 0x10, 0x00, 0x43, - 0xc9, 0x02, 0xe5, 0x10, 0x40, 0x43, 0x90, 0x00, 0xef, 0x10, 0x00, 0x42, - 0x62, 0x01, 0xeb, 0x10, 0x40, 0xa1, 0x10, 0xe5, 0xf1, 0x10, 0x00, 0x42, - 0xf4, 0x02, 0xf2, 0x10, 0x00, 0x42, 0x67, 0x51, 0xf5, 0x10, 0x40, 0xe5, - 0xf0, 0x10, 0x00, 0xf2, 0xf4, 0x10, 0xc0, 0x00, 0x46, 0xb7, 0x47, 0xfe, - 0x10, 0x40, 0x42, 0x1a, 0x00, 0xd2, 0x10, 0x00, 0x43, 0x90, 0x00, 0xe6, - 0x10, 0x40, 0x44, 0xe9, 0x88, 0xf8, 0x10, 0x00, 0xee, 0xd4, 0x10, 0x40, - 0x42, 0x1a, 0x00, 0xea, 0x10, 0x00, 0xa8, 0x06, 0x42, 0x62, 0x01, 0xec, - 0x10, 0x40, 0x42, 0x17, 0x00, 0xed, 0x10, 0x00, 0x42, 0x9e, 0x01, 0xe9, - 0x10, 0x40, 0x42, 0x92, 0x01, 0xfd, 0x10, 0x00, 0x42, 0x9e, 0x01, 0xfa, - 0x10, 0x00, 0xee, 0xd0, 0x10, 0x40, 0xa1, 0xf7, 0x01, 0x43, 0x26, 0x16, - 0xa1, 0x10, 0x00, 0xa3, 0xd4, 0x01, 0x43, 0x6c, 0x11, 0xa3, 0x10, 0x00, - 0x42, 0x92, 0x01, 0xa4, 0x10, 0x00, 0xa7, 0xb9, 0x01, 0xa8, 0x9c, 0x01, - 0x42, 0x9e, 0x01, 0xa8, 0x10, 0x00, 0xaa, 0x87, 0x01, 0xab, 0x79, 0x43, - 0x49, 0x0e, 0xaa, 0x10, 0x00, 0x43, 0x5d, 0x18, 0xab, 0x10, 0x00, 0x43, - 0x38, 0x27, 0xac, 0x10, 0x00, 0x42, 0x10, 0x00, 0xad, 0x10, 0x00, 0xb0, - 0x53, 0x43, 0xaf, 0xf4, 0xb7, 0x10, 0x00, 0x43, 0x8a, 0x82, 0xb0, 0x10, - 0x00, 0xb3, 0x39, 0x02, 0x12, 0x00, 0x2d, 0x42, 0x42, 0x0b, 0xb3, 0x10, - 0x00, 0x43, 0x0c, 0x2b, 0xa5, 0x10, 0x00, 0x42, 0x15, 0x01, 0xc3, 0x10, - 0x00, 0x43, 0x24, 0xef, 0xbe, 0x10, 0x00, 0x42, 0x1f, 0x1d, 0xc7, 0x10, - 0x00, 0xba, 0x01, 0xff, 0x42, 0x92, 0x01, 0xa6, 0x10, 0x00, 0x43, 0xc9, - 0x02, 0xaf, 0x10, 0x40, 0xee, 0xa7, 0x10, 0x00, 0xf2, 0xb2, 0x10, 0x40, - 0x42, 0x1a, 0x00, 0xb1, 0x10, 0x00, 0x43, 0x7a, 0x16, 0xb8, 0x10, 0x40, - 0x42, 0x17, 0x00, 0xae, 0x10, 0x00, 0x43, 0xc9, 0x02, 0xb4, 0x10, 0x40, - 0x42, 0x1a, 0x00, 0xa9, 0x10, 0x00, 0x43, 0xc9, 0x02, 0xb5, 0x10, 0x40, - 0x43, 0x90, 0x00, 0xbf, 0x10, 0x00, 0x42, 0x62, 0x01, 0xbb, 0x10, 0x40, - 0xa1, 0x10, 0xe5, 0xc1, 0x10, 0x00, 0x42, 0xf4, 0x02, 0xc2, 0x10, 0x00, - 0x42, 0x67, 0x51, 0xc5, 0x10, 0x40, 0xe5, 0xc0, 0x10, 0x00, 0xf2, 0xc4, - 0x10, 0x40, 0x42, 0x1a, 0x00, 0xa2, 0x10, 0x00, 0x43, 0x90, 0x00, 0xb6, - 0x10, 0x40, 0x42, 0x1a, 0x00, 0xba, 0x10, 0x00, 0xa8, 0x06, 0x42, 0x62, - 0x01, 0xbc, 0x10, 0x40, 0x42, 0x17, 0x00, 0xbd, 0x10, 0x00, 0x42, 0x9e, - 0x01, 0xb9, 0x10, 0x40, 0x42, 0x92, 0x01, 0xcd, 0x10, 0x00, 0xee, 0xa0, - 0x10, 0x40, 0x0d, 0x91, 0x80, 0x1c, 0x05, 0xa4, 0x55, 0x01, 0xff, 0x4b, - 0xd7, 0x97, 0x3a, 0x22, 0x00, 0x08, 0xf3, 0x0c, 0x01, 0xff, 0x45, 0xfb, - 0x0c, 0x51, 0x22, 0x00, 0x4a, 0xf1, 0x39, 0x4e, 0x22, 0x40, 0xa1, 0x5b, - 0xa3, 0x3f, 0x09, 0x2d, 0xb9, 0x2f, 0x48, 0xb9, 0xc7, 0xe8, 0xce, 0x01, - 0xb0, 0x12, 0x46, 0xdc, 0xdf, 0xe4, 0xce, 0x01, 0x49, 0x2c, 0xc0, 0xe1, - 0xce, 0x01, 0x43, 0x17, 0x50, 0xef, 0xce, 0x41, 0x46, 0x0a, 0xdf, 0xe0, - 0xce, 0x01, 0x02, 0xd6, 0x13, 0x01, 0xff, 0x43, 0x2c, 0x0e, 0xeb, 0xce, - 0x01, 0xf2, 0xed, 0xce, 0x41, 0x44, 0x0d, 0xef, 0xe3, 0xce, 0x01, 0x44, - 0xb5, 0xf0, 0xec, 0xce, 0x41, 0xa1, 0x06, 0x49, 0x65, 0xbd, 0xe6, 0xce, - 0x41, 0x4c, 0xfc, 0x93, 0xe7, 0xce, 0x01, 0x44, 0x61, 0xf2, 0xe9, 0xce, - 0x01, 0x4c, 0x54, 0x96, 0xee, 0xce, 0x41, 0x49, 0x8f, 0xb7, 0xe5, 0xce, - 0x01, 0x44, 0x19, 0xf1, 0xe2, 0xce, 0x01, 0x46, 0xa3, 0x30, 0xea, 0xce, - 0x41, 0x46, 0xbc, 0xba, 0x8e, 0xf4, 0x01, 0x43, 0x57, 0x07, 0x4a, 0x26, - 0x40, 0x05, 0x50, 0x00, 0x01, 0xff, 0x48, 0x29, 0xc2, 0xee, 0x26, 0x00, - 0x47, 0x54, 0xd4, 0xed, 0x26, 0x40, 0x46, 0x20, 0xde, 0xb2, 0xf3, 0x01, - 0xb2, 0x01, 0xff, 0x03, 0x07, 0x20, 0x06, 0x43, 0xbc, 0x04, 0xc4, 0xf9, - 0x41, 0xa3, 0x96, 0x02, 0x06, 0xef, 0x06, 0xcf, 0x01, 0x46, 0x9d, 0x63, - 0x6e, 0x0d, 0x01, 0x4a, 0x88, 0x98, 0x8f, 0x0d, 0x01, 0x49, 0xe6, 0x71, - 0x8e, 0x0d, 0x01, 0x52, 0xc8, 0x54, 0x6f, 0x0d, 0x01, 0xb3, 0x25, 0x06, - 0x57, 0x39, 0x01, 0xff, 0x4b, 0x5d, 0x39, 0x4e, 0x0d, 0x01, 0x05, 0x5a, - 0x03, 0x01, 0xff, 0xe1, 0x4a, 0x0d, 0x01, 0xe5, 0x69, 0x0d, 0x81, 0x08, - 0xe9, 0x4b, 0x0d, 0x01, 0xef, 0x4c, 0x0d, 0x41, 0xe5, 0x4d, 0x0d, 0x41, - 0x0c, 0x77, 0x08, 0x06, 0x44, 0x44, 0xeb, 0x4f, 0x0d, 0x41, 0xe1, 0x70, - 0x0d, 0x01, 0x42, 0x16, 0x00, 0x74, 0x0d, 0x01, 0x42, 0x37, 0x00, 0x71, - 0x0d, 0x01, 0x42, 0xf0, 0x10, 0x7a, 0x0d, 0x01, 0x42, 0x0c, 0x08, 0x80, - 0x0d, 0x01, 0x42, 0x24, 0x02, 0x79, 0x0d, 0x01, 0x42, 0x22, 0x00, 0x83, - 0x0d, 0x01, 0x42, 0x72, 0x19, 0x75, 0x0d, 0x01, 0x42, 0x1b, 0x02, 0x73, - 0x0d, 0x01, 0x42, 0x74, 0x00, 0x78, 0x0d, 0x01, 0x42, 0x6c, 0x00, 0x72, - 0x0d, 0x01, 0xae, 0x3a, 0x04, 0x49, 0x25, 0x2a, 0x42, 0xbb, 0x09, 0x82, - 0x0d, 0x01, 0x42, 0x71, 0x00, 0x7e, 0x0d, 0x01, 0x42, 0x40, 0x06, 0x76, - 0x0d, 0x01, 0x42, 0x12, 0x00, 0x7d, 0x0d, 0x01, 0x42, 0xa9, 0x01, 0x77, - 0x0d, 0x01, 0x42, 0x08, 0x27, 0x7b, 0x0d, 0x01, 0x42, 0xbe, 0x22, 0x7c, - 0x0d, 0x41, 0x42, 0x1b, 0x02, 0x84, 0x0d, 0x01, 0x42, 0x2a, 0x05, 0x85, - 0x0d, 0x41, 0xe1, 0x81, 0x0d, 0x01, 0x42, 0xbe, 0x22, 0x7f, 0x0d, 0x41, - 0x45, 0x12, 0x0b, 0x48, 0x0d, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x49, - 0x0d, 0x01, 0x43, 0x0e, 0x0b, 0x41, 0x0d, 0x01, 0xb3, 0x14, 0xb4, 0x06, - 0x44, 0x5f, 0x1e, 0x40, 0x0d, 0x41, 0x44, 0x25, 0x01, 0x43, 0x0d, 0x01, - 0x42, 0x15, 0x02, 0x42, 0x0d, 0x41, 0x44, 0xe5, 0x1d, 0x47, 0x0d, 0x01, - 0x42, 0x1c, 0x26, 0x46, 0x0d, 0x41, 0x43, 0xd2, 0x05, 0x45, 0x0d, 0x01, - 0x43, 0xf6, 0x06, 0x44, 0x0d, 0x41, 0x0e, 0xe5, 0x05, 0x24, 0xaf, 0x01, - 0xff, 0x0a, 0xd8, 0xad, 0x11, 0x08, 0x44, 0x33, 0x01, 0xff, 0x4f, 0x90, - 0x6d, 0x6a, 0x0d, 0x01, 0x51, 0x67, 0x5c, 0x6d, 0x0d, 0x41, 0x47, 0x58, - 0x1e, 0x6b, 0x0d, 0x01, 0x4e, 0x1f, 0x62, 0x6c, 0x0d, 0x41, 0xe1, 0x50, - 0x0d, 0x01, 0x42, 0x16, 0x00, 0x54, 0x0d, 0x01, 0x42, 0x37, 0x00, 0x51, - 0x0d, 0x01, 0x42, 0xf0, 0x10, 0x5a, 0x0d, 0x01, 0x42, 0x0c, 0x08, 0x60, - 0x0d, 0x01, 0x42, 0x24, 0x02, 0x59, 0x0d, 0x01, 0x42, 0x22, 0x00, 0x63, - 0x0d, 0x01, 0x42, 0x72, 0x19, 0x55, 0x0d, 0x01, 0x42, 0x1b, 0x02, 0x53, - 0x0d, 0x01, 0x42, 0x74, 0x00, 0x58, 0x0d, 0x01, 0x42, 0x6c, 0x00, 0x52, - 0x0d, 0x01, 0xae, 0x3a, 0x04, 0x49, 0x25, 0x2a, 0x42, 0xbb, 0x09, 0x62, - 0x0d, 0x01, 0x42, 0x71, 0x00, 0x5e, 0x0d, 0x01, 0x42, 0x40, 0x06, 0x56, - 0x0d, 0x01, 0x42, 0x12, 0x00, 0x5d, 0x0d, 0x01, 0x42, 0xa9, 0x01, 0x57, - 0x0d, 0x01, 0x42, 0x08, 0x27, 0x5b, 0x0d, 0x01, 0x42, 0xbe, 0x22, 0x5c, - 0x0d, 0x41, 0x42, 0x1b, 0x02, 0x64, 0x0d, 0x01, 0x42, 0x2a, 0x05, 0x65, - 0x0d, 0x41, 0xe1, 0x61, 0x0d, 0x01, 0x42, 0xbe, 0x22, 0x5f, 0x0d, 0x41, - 0xa1, 0xbb, 0x0b, 0xa5, 0x87, 0x0b, 0xe6, 0x0c, 0x00, 0x00, 0xa9, 0xa4, - 0x09, 0xac, 0xf7, 0x07, 0xaf, 0xb0, 0x06, 0xb2, 0xb9, 0x05, 0xf3, 0x1c, - 0x00, 0x80, 0xaf, 0x05, 0xb5, 0x15, 0x02, 0xb8, 0xf2, 0x01, 0xff, 0xd1, - 0x0b, 0x18, 0x00, 0xd2, 0x0c, 0x18, 0x00, 0xd3, 0x0d, 0x18, 0x00, 0xd4, - 0x0f, 0x18, 0x40, 0x47, 0xe2, 0xd0, 0xfd, 0x26, 0x00, 0x02, 0x60, 0x07, - 0x1a, 0xae, 0x06, 0x42, 0x46, 0x03, 0xdb, 0x23, 0x40, 0x51, 0x9d, 0x59, - 0x61, 0x20, 0x00, 0x48, 0xd9, 0xc5, 0xb1, 0x26, 0x00, 0x43, 0x17, 0xc8, - 0x08, 0xce, 0x41, 0x80, 0xcf, 0x04, 0x06, 0x42, 0x50, 0x01, 0xff, 0xa1, - 0xb5, 0x04, 0x4a, 0x7e, 0xa8, 0xe4, 0xff, 0x00, 0xa3, 0x88, 0x04, 0xa4, - 0xb9, 0x03, 0xa5, 0xaa, 0x03, 0x49, 0x81, 0x16, 0x0e, 0xff, 0x00, 0x02, - 0x87, 0x00, 0x93, 0x03, 0x4c, 0xdc, 0x8f, 0x0d, 0xff, 0x00, 0xac, 0x83, - 0x01, 0x46, 0xb4, 0x70, 0xe3, 0xff, 0x00, 0xae, 0x6f, 0xb0, 0x5b, 0x02, - 0x7c, 0x00, 0x4b, 0xb2, 0x26, 0xb3, 0x18, 0x45, 0x37, 0x23, 0x5e, 0xff, - 0x00, 0x4d, 0xcd, 0x0b, 0x5c, 0xff, 0x00, 0x48, 0xa9, 0xcc, 0xe6, 0xff, - 0x00, 0x48, 0x44, 0x7f, 0xe5, 0xff, 0x40, 0x48, 0xe1, 0x59, 0x1b, 0xff, - 0x00, 0x46, 0x6b, 0x31, 0x0f, 0xff, 0x40, 0x4e, 0x6e, 0x72, 0x3c, 0xff, - 0x00, 0x05, 0xc9, 0x00, 0x01, 0xff, 0x4d, 0x72, 0x0b, 0x5d, 0xff, 0x00, - 0x4b, 0xda, 0x21, 0x09, 0xff, 0x00, 0x4e, 0xe3, 0x26, 0x3d, 0xff, 0x00, - 0x51, 0x75, 0x5f, 0x60, 0xff, 0x40, 0x4b, 0xc3, 0x34, 0x1f, 0xff, 0x00, - 0x4c, 0x1b, 0x05, 0x02, 0xff, 0x40, 0x4b, 0x02, 0x9c, 0x05, 0xff, 0x00, - 0x48, 0xe7, 0x71, 0x0b, 0xff, 0x00, 0x49, 0xcd, 0xaf, 0xe1, 0xff, 0x40, - 0x47, 0x92, 0x73, 0xe2, 0xff, 0x00, 0x4a, 0x0d, 0x68, 0x03, 0xff, 0x40, - 0x05, 0xdf, 0x05, 0x2a, 0xa5, 0x06, 0x47, 0x8b, 0x8a, 0x3f, 0xff, 0x40, - 0x03, 0xc5, 0x00, 0x06, 0x4c, 0x88, 0x95, 0x1c, 0xff, 0x40, 0x4d, 0x72, - 0x0b, 0x5b, 0xff, 0x00, 0x4b, 0xda, 0x21, 0x08, 0xff, 0x00, 0x4e, 0xe3, - 0x26, 0x3b, 0xff, 0x00, 0x51, 0x75, 0x5f, 0x5f, 0xff, 0x40, 0x0f, 0xe4, - 0x05, 0x6d, 0x0d, 0x76, 0x08, 0x01, 0xff, 0xe1, 0x41, 0xff, 0x00, 0xe2, - 0x42, 0xff, 0x00, 0xe3, 0x43, 0xff, 0x00, 0xe4, 0x44, 0xff, 0x00, 0xe5, - 0x45, 0xff, 0x00, 0xe6, 0x46, 0xff, 0x00, 0xe7, 0x47, 0xff, 0x00, 0xe8, - 0x48, 0xff, 0x00, 0xe9, 0x49, 0xff, 0x00, 0xea, 0x4a, 0xff, 0x00, 0xeb, - 0x4b, 0xff, 0x00, 0xec, 0x4c, 0xff, 0x00, 0xed, 0x4d, 0xff, 0x00, 0xee, - 0x4e, 0xff, 0x00, 0xef, 0x4f, 0xff, 0x00, 0xf0, 0x50, 0xff, 0x00, 0xf1, - 0x51, 0xff, 0x00, 0xf2, 0x52, 0xff, 0x00, 0xf3, 0x53, 0xff, 0x00, 0xf4, - 0x54, 0xff, 0x00, 0xf5, 0x55, 0xff, 0x00, 0xf6, 0x56, 0xff, 0x00, 0xf7, - 0x57, 0xff, 0x00, 0xf8, 0x58, 0xff, 0x00, 0xf9, 0x59, 0xff, 0x00, 0xfa, - 0x5a, 0xff, 0x40, 0xe1, 0x21, 0xff, 0x00, 0xe2, 0x22, 0xff, 0x00, 0xe3, - 0x23, 0xff, 0x00, 0xe4, 0x24, 0xff, 0x00, 0xe5, 0x25, 0xff, 0x00, 0xe6, - 0x26, 0xff, 0x00, 0xe7, 0x27, 0xff, 0x00, 0xe8, 0x28, 0xff, 0x00, 0xe9, - 0x29, 0xff, 0x00, 0xea, 0x2a, 0xff, 0x00, 0xeb, 0x2b, 0xff, 0x00, 0xec, - 0x2c, 0xff, 0x00, 0xed, 0x2d, 0xff, 0x00, 0xee, 0x2e, 0xff, 0x00, 0xef, - 0x2f, 0xff, 0x00, 0xf0, 0x30, 0xff, 0x00, 0xf1, 0x31, 0xff, 0x00, 0xf2, - 0x32, 0xff, 0x00, 0xf3, 0x33, 0xff, 0x00, 0xf4, 0x34, 0xff, 0x00, 0xf5, - 0x35, 0xff, 0x00, 0xf6, 0x36, 0xff, 0x00, 0xf7, 0x37, 0xff, 0x00, 0xf8, - 0x38, 0xff, 0x00, 0xf9, 0x39, 0xff, 0x00, 0xfa, 0x3a, 0xff, 0x40, 0x4a, - 0x19, 0x23, 0x40, 0xff, 0x00, 0x4f, 0x6b, 0x5a, 0x1e, 0xff, 0x40, 0x4a, - 0x49, 0x13, 0x1d, 0xff, 0x00, 0x4f, 0xae, 0x00, 0x01, 0xff, 0x40, 0x05, - 0xf0, 0x06, 0x06, 0x4a, 0x32, 0x9b, 0x04, 0xff, 0x40, 0x45, 0x12, 0x0b, - 0x18, 0xff, 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x19, 0xff, 0x00, 0x43, - 0x0e, 0x0b, 0x11, 0xff, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, - 0x10, 0xff, 0x40, 0x44, 0x25, 0x01, 0x13, 0xff, 0x00, 0x42, 0x15, 0x02, - 0x12, 0xff, 0x40, 0x44, 0xe5, 0x1d, 0x17, 0xff, 0x00, 0x42, 0x1c, 0x26, - 0x16, 0xff, 0x40, 0x43, 0xd2, 0x05, 0x15, 0xff, 0x00, 0x43, 0xf6, 0x06, - 0x14, 0xff, 0x40, 0x48, 0x05, 0x9c, 0xe0, 0xff, 0x00, 0x50, 0xd0, 0x04, - 0x3e, 0xff, 0x00, 0xaf, 0x01, 0xff, 0x43, 0xd7, 0x02, 0x1a, 0xff, 0x00, - 0x02, 0x15, 0x05, 0x01, 0xff, 0xe1, 0x0c, 0xff, 0x00, 0x49, 0xa6, 0xb8, - 0x20, 0xff, 0x40, 0x48, 0x2e, 0x3e, 0x06, 0xff, 0x00, 0x49, 0x7d, 0x36, - 0x07, 0xff, 0x00, 0x47, 0x3d, 0x0d, 0x0a, 0xff, 0x40, 0x45, 0x33, 0x01, - 0x88, 0x25, 0x00, 0x05, 0xcb, 0x1b, 0x0c, 0x4a, 0x72, 0xaf, 0xd7, 0x27, - 0x00, 0x44, 0x55, 0x03, 0x2e, 0x00, 0x40, 0x46, 0x16, 0x08, 0x15, 0xf3, - 0x01, 0x49, 0x70, 0xc1, 0x1d, 0xf3, 0x41, 0xe9, 0x68, 0x20, 0x40, 0xa1, - 0x45, 0xa5, 0x2c, 0x4a, 0xa8, 0xab, 0x64, 0xf3, 0x01, 0xaf, 0x01, 0xff, - 0x46, 0x4b, 0x29, 0x38, 0xf4, 0x01, 0x03, 0x36, 0x10, 0x0d, 0x42, 0xa7, - 0x01, 0x22, 0x23, 0xc0, 0x00, 0x58, 0x49, 0x29, 0x26, 0xf6, 0x41, 0x51, - 0xf2, 0x59, 0x25, 0xf4, 0x01, 0x66, 0x59, 0x05, 0xac, 0x27, 0x40, 0x4a, - 0xb6, 0x9b, 0x76, 0xf9, 0x01, 0x06, 0x50, 0xde, 0x01, 0xff, 0x48, 0x71, - 0xc3, 0xa3, 0x20, 0x00, 0x43, 0x35, 0x9e, 0x5f, 0xf3, 0x41, 0x06, 0x06, - 0x17, 0x1d, 0x4b, 0x91, 0x9c, 0xba, 0xce, 0x01, 0x08, 0x61, 0xc8, 0x01, - 0xff, 0x44, 0x21, 0xef, 0xbe, 0xf5, 0x01, 0x47, 0x19, 0x8b, 0xbc, 0xf5, - 0x01, 0x45, 0xdf, 0xd5, 0xbd, 0xf5, 0x41, 0x4d, 0xa9, 0x86, 0x5f, 0x21, - 0x00, 0x45, 0x48, 0x0e, 0x44, 0x20, 0x40, 0xe7, 0x2b, 0xf3, 0x81, 0xb8, - 0x01, 0x02, 0xfe, 0x1a, 0xa7, 0x01, 0x44, 0x91, 0xf1, 0xd5, 0xfa, 0x01, - 0x42, 0x1b, 0x05, 0xb6, 0xf9, 0x81, 0x93, 0x01, 0xb2, 0x55, 0xb5, 0x06, - 0x46, 0x80, 0xe1, 0x8a, 0xf9, 0x41, 0x45, 0x54, 0x07, 0xf2, 0x26, 0x00, - 0xb2, 0x01, 0xff, 0x80, 0x0c, 0x4d, 0x43, 0x80, 0x05, 0x20, 0x00, 0x47, - 0x53, 0x9c, 0x1c, 0x22, 0x40, 0x57, 0xe9, 0x1c, 0x23, 0x27, 0x00, 0xa3, - 0x22, 0x04, 0x03, 0x0c, 0x12, 0x4b, 0x96, 0x9e, 0x40, 0xf3, 0x01, 0x52, - 0x07, 0x2c, 0xc6, 0xf7, 0x01, 0x58, 0x89, 0x2b, 0x22, 0x27, 0x40, 0x44, - 0xb9, 0x00, 0x5b, 0x20, 0x00, 0x4b, 0x07, 0x0c, 0x58, 0x20, 0x40, 0x53, - 0x27, 0x4b, 0x25, 0x27, 0x00, 0x63, 0x1e, 0x0b, 0x94, 0x2b, 0x40, 0x44, - 0xd8, 0x2d, 0x00, 0x22, 0x00, 0x43, 0x58, 0x7c, 0xa9, 0x22, 0x00, 0xab, - 0x15, 0x46, 0x8b, 0xc9, 0x0c, 0x00, 0x00, 0x03, 0xa7, 0x97, 0x01, 0xff, - 0xe1, 0xcc, 0xce, 0x01, 0x48, 0x79, 0xc5, 0x60, 0xf9, 0x41, 0x4a, 0xd6, - 0xa5, 0x74, 0xf3, 0x81, 0x0c, 0x4e, 0xc6, 0x51, 0x10, 0x2e, 0x00, 0x43, - 0xa1, 0x01, 0xdc, 0x2a, 0x40, 0x4b, 0x50, 0x98, 0x7d, 0xf3, 0x41, 0x46, - 0x7b, 0xcc, 0x63, 0xf4, 0x41, 0x42, 0x33, 0x00, 0xc0, 0xf5, 0x01, 0x4c, - 0x30, 0x90, 0xad, 0xfa, 0x41, 0x42, 0xd2, 0x35, 0x01, 0xf3, 0x41, 0xa1, - 0x80, 0x01, 0xa5, 0x72, 0xaf, 0x45, 0xb5, 0x37, 0xf9, 0xb0, 0xfa, 0xc1, - 0x00, 0x04, 0xa1, 0x01, 0x01, 0xff, 0x44, 0x43, 0x64, 0x4f, 0xf9, 0x01, - 0x48, 0x5e, 0x32, 0x85, 0xf5, 0x01, 0x46, 0xb6, 0x91, 0xf8, 0xf6, 0xc1, - 0x00, 0x80, 0x01, 0xff, 0x46, 0x16, 0x08, 0xfb, 0xcc, 0x01, 0x04, 0x51, - 0x00, 0x01, 0xff, 0x46, 0xb9, 0xbd, 0x4a, 0xcc, 0x01, 0x49, 0xb6, 0xbd, - 0x4b, 0xcc, 0x41, 0x49, 0x57, 0x93, 0x33, 0xf6, 0x01, 0x42, 0x77, 0x00, - 0x88, 0xfa, 0x41, 0x48, 0x75, 0x39, 0xbe, 0xf4, 0x01, 0x42, 0x71, 0x00, - 0xc2, 0xce, 0x81, 0x18, 0x43, 0x15, 0x01, 0x98, 0x26, 0xc0, 0x00, 0x02, - 0x9b, 0x01, 0x01, 0xff, 0x4c, 0xfc, 0x90, 0xb4, 0xf3, 0x01, 0x4f, 0x13, - 0x22, 0x55, 0x20, 0x40, 0x47, 0xac, 0x21, 0x66, 0x27, 0x40, 0x49, 0xa1, - 0xc0, 0x9c, 0x26, 0x00, 0x4a, 0xdc, 0xb3, 0xaa, 0xf4, 0x41, 0x49, 0x48, - 0xb9, 0xf3, 0x26, 0x00, 0x45, 0xd2, 0xe8, 0xa9, 0xf9, 0x01, 0x4a, 0xd6, - 0xaf, 0x96, 0xcc, 0x01, 0xb4, 0x01, 0xff, 0x45, 0xed, 0x97, 0x7f, 0xf9, - 0x01, 0x45, 0xe7, 0x77, 0xd3, 0xfa, 0x01, 0x44, 0x24, 0x24, 0xe5, 0x23, - 0x40, 0x59, 0x04, 0x24, 0xd1, 0xf3, 0x01, 0xa7, 0xbc, 0x01, 0xac, 0x92, - 0x01, 0xae, 0x83, 0x01, 0xb2, 0x30, 0xb3, 0x11, 0x07, 0x56, 0xd7, 0x01, - 0xff, 0x44, 0xb9, 0x00, 0x2d, 0x2e, 0x00, 0x4b, 0x07, 0x0c, 0x59, 0x20, - 0x40, 0xe8, 0x1f, 0xf4, 0x81, 0x06, 0x4d, 0x40, 0x89, 0x4a, 0xf4, 0x41, - 0x57, 0x79, 0x2c, 0x65, 0xf3, 0x01, 0x43, 0xe2, 0x1c, 0xc9, 0x25, 0x00, - 0x51, 0x24, 0x5b, 0xa3, 0xf3, 0x41, 0xe5, 0x25, 0xf5, 0x81, 0x27, 0x03, - 0x98, 0x18, 0x01, 0xff, 0x4b, 0x45, 0x71, 0x47, 0xf9, 0x01, 0x4c, 0x42, - 0x73, 0x3d, 0x26, 0x80, 0x06, 0x4e, 0xa0, 0x7c, 0x68, 0x20, 0x40, 0x80, - 0x01, 0xff, 0x46, 0x16, 0x08, 0x13, 0xf3, 0x01, 0x49, 0x70, 0xc1, 0x1b, - 0xf3, 0x41, 0x02, 0x7a, 0x00, 0x15, 0x47, 0x3a, 0xd0, 0xe8, 0xf9, 0x01, - 0x04, 0x9c, 0x4b, 0x01, 0xff, 0x49, 0xfe, 0xb4, 0x87, 0xf3, 0x01, 0xf3, - 0x86, 0xf3, 0x41, 0x45, 0x4a, 0x9c, 0x92, 0xf6, 0x01, 0x4b, 0x81, 0xa5, - 0xef, 0xf9, 0x41, 0x48, 0x89, 0xc6, 0xc6, 0xfa, 0x01, 0x51, 0x57, 0x5b, - 0x0d, 0x2a, 0x40, 0x02, 0x60, 0x00, 0x11, 0x02, 0x49, 0x04, 0x01, 0xff, - 0x46, 0xf8, 0xdb, 0x9e, 0xf3, 0x01, 0x49, 0x58, 0xbe, 0xfd, 0xf4, 0x41, - 0x47, 0xdf, 0xcf, 0xc4, 0xf5, 0x01, 0x46, 0xd4, 0xab, 0xc1, 0xf4, 0x01, - 0x49, 0xda, 0x20, 0x1c, 0x00, 0x40, 0x48, 0xf1, 0xc6, 0xef, 0xfa, 0x01, - 0x04, 0x91, 0x18, 0x01, 0xff, 0x44, 0x8f, 0x12, 0x12, 0x20, 0x00, 0x45, - 0xd7, 0x4c, 0x07, 0x20, 0x40, 0xa1, 0x23, 0xad, 0x15, 0x44, 0x89, 0xf1, - 0x3a, 0xf9, 0x01, 0x02, 0xcf, 0x00, 0x01, 0xff, 0x48, 0x59, 0xc7, 0xa1, - 0xf3, 0x01, 0xf9, 0xf4, 0x26, 0x40, 0x48, 0x64, 0x21, 0x40, 0x26, 0x00, - 0x57, 0x42, 0x2f, 0xaa, 0x00, 0x40, 0x49, 0xcd, 0xbe, 0x28, 0xf6, 0x01, - 0x44, 0x2b, 0x1a, 0xb6, 0xfa, 0x41, 0xa3, 0x55, 0x43, 0xc1, 0xe0, 0xda, - 0xf9, 0x01, 0xac, 0x23, 0x44, 0xd6, 0xdb, 0x6a, 0xf4, 0x01, 0x4a, 0xc6, - 0xb0, 0x2b, 0x26, 0x00, 0x4e, 0xf4, 0x7c, 0x85, 0xf3, 0x01, 0x02, 0xd8, - 0x04, 0x01, 0xff, 0x44, 0xdf, 0xe1, 0xb7, 0xf5, 0x01, 0x47, 0x87, 0x48, - 0xe0, 0xf4, 0x41, 0x44, 0x01, 0xef, 0xc6, 0xf9, 0x01, 0xac, 0x01, 0xff, - 0x47, 0xe9, 0xd0, 0x42, 0xf3, 0x01, 0x0d, 0x54, 0x31, 0x01, 0xff, 0x09, - 0x95, 0x10, 0x06, 0x5f, 0x2f, 0x11, 0xde, 0x26, 0x40, 0x50, 0xa9, 0x23, - 0x2f, 0x29, 0x00, 0x4f, 0x15, 0x3e, 0x2c, 0x29, 0x40, 0x02, 0x60, 0x00, - 0x0c, 0x4b, 0xc1, 0xa2, 0x3b, 0x21, 0x00, 0x44, 0xf3, 0x96, 0xed, 0xf3, - 0x41, 0x52, 0x52, 0x52, 0x79, 0xf9, 0x01, 0x47, 0x4a, 0xd3, 0x86, 0xf4, - 0x01, 0x44, 0xeb, 0x40, 0x26, 0xf9, 0x01, 0xb3, 0xcb, 0x01, 0x4f, 0xb7, - 0x73, 0x18, 0xf6, 0x01, 0x04, 0x51, 0x00, 0x01, 0xff, 0x80, 0x06, 0x49, - 0xbf, 0xbd, 0x36, 0xf6, 0x41, 0x4f, 0x0b, 0x6b, 0xe9, 0xfa, 0x01, 0x02, - 0x13, 0x05, 0xa1, 0x01, 0x4e, 0xd4, 0x76, 0xe4, 0xfa, 0x01, 0x5b, 0x6b, - 0x1b, 0x2b, 0xf9, 0x01, 0x4c, 0xb8, 0x8f, 0x15, 0xf9, 0x01, 0x4f, 0x06, - 0x70, 0x24, 0xf6, 0x01, 0xad, 0x7b, 0x4f, 0xba, 0x70, 0x45, 0xf6, 0x01, - 0xaf, 0x46, 0xb0, 0x32, 0x4c, 0xec, 0x94, 0x44, 0xf6, 0x01, 0x50, 0xad, - 0x67, 0x1b, 0xf6, 0x81, 0x14, 0xb4, 0x06, 0x5a, 0x70, 0x22, 0x74, 0xf9, - 0x41, 0x4b, 0xd1, 0x95, 0x02, 0xf6, 0x01, 0x4a, 0x4e, 0xab, 0x12, 0xf9, - 0x41, 0x05, 0x19, 0x00, 0x01, 0xff, 0x53, 0x9a, 0x4d, 0x1d, 0xf6, 0x01, - 0x4b, 0x3f, 0xa5, 0x1c, 0xf6, 0x41, 0x57, 0x76, 0x2d, 0x73, 0xf9, 0x01, - 0x4a, 0xe6, 0xa9, 0xe3, 0xfa, 0x01, 0x4c, 0x08, 0x91, 0x7a, 0xf9, 0x41, - 0x49, 0x0a, 0xbb, 0x46, 0xf6, 0x01, 0x51, 0x9a, 0x5c, 0x28, 0xf9, 0x01, - 0x04, 0xf7, 0x04, 0x01, 0xff, 0x58, 0xb9, 0x28, 0xe2, 0xfa, 0x01, 0x45, - 0x27, 0x08, 0x2e, 0xf6, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x4e, 0xf4, 0x75, - 0x30, 0xf6, 0x01, 0x48, 0x71, 0xcc, 0x2e, 0xf9, 0x41, 0x4b, 0xaa, 0x9b, - 0x37, 0xf6, 0x01, 0x46, 0xec, 0xde, 0xd0, 0xf9, 0x41, 0x48, 0xfa, 0x75, - 0x13, 0xf6, 0x01, 0x48, 0x89, 0xcc, 0x20, 0xf9, 0x41, 0x57, 0xbb, 0x2d, - 0x0b, 0xf6, 0x01, 0x50, 0xcd, 0x61, 0x31, 0xf6, 0x41, 0x4c, 0xd4, 0x8b, - 0xe7, 0xf4, 0x01, 0xa1, 0xef, 0x48, 0x50, 0xed, 0x61, 0x0e, 0x2e, 0x00, - 0xa7, 0xf1, 0x20, 0x04, 0xc9, 0x00, 0xa9, 0x20, 0x4b, 0xfc, 0x9d, 0xcf, - 0x23, 0x00, 0xac, 0x9f, 0x1c, 0xed, 0x19, 0x00, 0x80, 0xe8, 0x1a, 0xae, - 0xdc, 0x19, 0xaf, 0xcd, 0x19, 0x42, 0xbb, 0x09, 0x97, 0x00, 0x00, 0x02, - 0x7c, 0x00, 0x87, 0x18, 0xb2, 0xb2, 0x17, 0xb3, 0x91, 0x17, 0xb4, 0x8a, - 0x02, 0xb5, 0xd9, 0x01, 0x4d, 0x1d, 0x8a, 0x32, 0xf3, 0x01, 0xb8, 0x11, - 0x42, 0x4d, 0x00, 0x41, 0xf4, 0xc1, 0x00, 0x47, 0x76, 0xc0, 0x53, 0xf4, - 0x01, 0xf3, 0x40, 0xf4, 0x41, 0xa3, 0xa6, 0x01, 0xb0, 0x82, 0x01, 0xb4, - 0x01, 0xff, 0x19, 0xdc, 0x06, 0x39, 0xb2, 0x01, 0xff, 0x52, 0x6c, 0x50, - 0x7d, 0xf4, 0x01, 0x0c, 0x8c, 0x8e, 0x01, 0xff, 0x54, 0x5f, 0x42, 0xb4, - 0xf7, 0x01, 0x4b, 0x22, 0x61, 0xa7, 0xf7, 0x01, 0xb3, 0x11, 0x06, 0xad, - 0x02, 0x01, 0xff, 0x46, 0x12, 0x03, 0x89, 0xf7, 0x01, 0x46, 0xd6, 0x05, - 0x93, 0xf7, 0x41, 0x46, 0x2f, 0x19, 0xae, 0xf7, 0x01, 0x52, 0x06, 0x53, - 0xba, 0xf7, 0x41, 0x45, 0x12, 0x0b, 0xf8, 0x06, 0x00, 0xa6, 0x2e, 0x44, - 0xea, 0x2a, 0xf9, 0x06, 0x00, 0x43, 0x0e, 0x0b, 0xf1, 0x06, 0x00, 0xb3, - 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xf0, 0x06, 0x40, 0x44, 0x25, 0x01, - 0xf3, 0x06, 0x00, 0x42, 0x15, 0x02, 0xf2, 0x06, 0x40, 0x44, 0xe5, 0x1d, - 0xf7, 0x06, 0x00, 0x42, 0x1c, 0x26, 0xf6, 0x06, 0x40, 0x43, 0xd2, 0x05, - 0xf5, 0x06, 0x00, 0x43, 0xf6, 0x06, 0xf4, 0x06, 0x40, 0x07, 0x20, 0xd3, - 0x06, 0x50, 0x8d, 0x66, 0x11, 0xf6, 0x41, 0x4a, 0x1a, 0xa8, 0x02, 0xce, - 0x01, 0x06, 0x11, 0x44, 0x01, 0xff, 0xd1, 0xfd, 0xcd, 0x01, 0xd2, 0xfe, - 0xcd, 0x01, 0xd3, 0xff, 0xcd, 0x41, 0x43, 0xed, 0x00, 0x39, 0x22, 0x00, - 0x09, 0xb0, 0x00, 0x01, 0xff, 0x44, 0xb9, 0x00, 0x21, 0x00, 0x00, 0x4d, - 0xc1, 0x34, 0x49, 0x20, 0x40, 0x4c, 0x2c, 0x91, 0x07, 0x21, 0x00, 0x45, - 0x4f, 0xe9, 0xc8, 0xce, 0x01, 0x02, 0xd0, 0x00, 0x01, 0xff, 0x45, 0x59, - 0x03, 0xac, 0x20, 0x00, 0x4e, 0xa0, 0x75, 0xa0, 0x20, 0x00, 0x05, 0xea, - 0xe9, 0x01, 0xff, 0x46, 0x7e, 0xda, 0xf0, 0xf3, 0x01, 0x4b, 0x8d, 0xa1, - 0xe4, 0xf3, 0x41, 0xe2, 0x17, 0x00, 0x00, 0x07, 0xb4, 0xd1, 0x04, 0xf8, - 0x03, 0x00, 0x40, 0x02, 0x13, 0x05, 0xca, 0x14, 0x06, 0xef, 0x06, 0x88, - 0x14, 0x49, 0x81, 0x16, 0x62, 0x13, 0x00, 0x07, 0x1a, 0x3a, 0xb3, 0x13, - 0xb0, 0xa4, 0x13, 0x4d, 0xc1, 0x34, 0x67, 0x13, 0x00, 0xb3, 0x4b, 0x0b, - 0xbe, 0xa3, 0x06, 0x49, 0x79, 0xc1, 0x61, 0x13, 0x40, 0x46, 0xb4, 0xda, - 0x96, 0x13, 0x00, 0xa4, 0x26, 0x45, 0x75, 0xd8, 0x97, 0x13, 0x00, 0xab, - 0x12, 0x46, 0x5e, 0x95, 0x92, 0x13, 0x00, 0x4c, 0x58, 0x95, 0x93, 0x13, - 0x00, 0x45, 0xb5, 0xec, 0x90, 0x13, 0x40, 0x44, 0x7c, 0x50, 0x95, 0x13, - 0x00, 0x43, 0x12, 0x5d, 0x99, 0x13, 0x40, 0x44, 0x3e, 0xaa, 0x91, 0x13, - 0x80, 0x06, 0x44, 0x99, 0xf0, 0x94, 0x13, 0x40, 0x46, 0x74, 0xd8, 0x98, - 0x13, 0x40, 0xa5, 0xc2, 0x12, 0x08, 0x37, 0x18, 0x01, 0xff, 0xa2, 0xe3, - 0x11, 0xa3, 0xab, 0x10, 0xa4, 0x98, 0x0f, 0xa6, 0xde, 0x0e, 0xa7, 0x9c, - 0x0c, 0xa8, 0xa2, 0x0b, 0xaa, 0xf6, 0x0a, 0xab, 0xdc, 0x09, 0xac, 0xb0, - 0x09, 0xad, 0xf1, 0x08, 0xae, 0x99, 0x08, 0xb0, 0x91, 0x07, 0xb1, 0xf7, - 0x05, 0xb2, 0xc5, 0x05, 0xb3, 0x89, 0x04, 0xb4, 0xc4, 0x02, 0xb6, 0x9d, - 0x02, 0xb7, 0xf7, 0x01, 0xb8, 0x98, 0x01, 0xb9, 0x73, 0xba, 0x01, 0xff, - 0xe1, 0xd8, 0x12, 0x80, 0x67, 0xe5, 0xdd, 0x12, 0x80, 0x5e, 0xa8, 0x38, - 0xe9, 0xda, 0x12, 0x00, 0xef, 0xde, 0x12, 0x80, 0x2b, 0xf5, 0xd9, 0x12, - 0x00, 0x42, 0xa9, 0x01, 0xdf, 0x12, 0x00, 0xba, 0x01, 0xff, 0xe1, 0xb0, - 0x2d, 0x80, 0x15, 0xe5, 0xb5, 0x2d, 0x80, 0x0c, 0xe9, 0xb2, 0x2d, 0x00, - 0xef, 0xb6, 0x2d, 0x00, 0xf5, 0xb1, 0x2d, 0x40, 0xe5, 0xb4, 0x2d, 0x40, - 0xe1, 0xb3, 0x2d, 0x40, 0xe1, 0x8b, 0x2d, 0x40, 0xe1, 0xe0, 0x12, 0x80, - 0x1b, 0xe5, 0xe5, 0x12, 0x80, 0x12, 0xe9, 0xe2, 0x12, 0x00, 0xef, 0xe6, - 0x12, 0x00, 0xf5, 0xe1, 0x12, 0x00, 0x42, 0xa9, 0x01, 0xe7, 0x12, 0x40, - 0xe5, 0xe4, 0x12, 0x40, 0xe1, 0xe3, 0x12, 0x40, 0xe5, 0xdc, 0x12, 0x40, - 0xe1, 0xdb, 0x12, 0x40, 0xe1, 0xe8, 0x12, 0x80, 0x1a, 0xe5, 0xed, 0x12, - 0x80, 0x11, 0xe9, 0xea, 0x12, 0x00, 0xef, 0xee, 0x12, 0x80, 0x04, 0xf5, - 0xe9, 0x12, 0x40, 0xe1, 0xef, 0x12, 0x40, 0xe5, 0xec, 0x12, 0x40, 0xe1, - 0xeb, 0x12, 0x40, 0xe1, 0x80, 0x12, 0x80, 0x53, 0xe5, 0x85, 0x12, 0x80, - 0x4a, 0xe9, 0x82, 0x12, 0x00, 0xef, 0x86, 0x12, 0x80, 0x3d, 0xf5, 0x81, - 0x12, 0x00, 0xb7, 0x21, 0xb9, 0x01, 0xff, 0xe1, 0xd0, 0x2d, 0x80, 0x15, - 0xe5, 0xd5, 0x2d, 0x80, 0x0c, 0xe9, 0xd2, 0x2d, 0x00, 0xef, 0xd6, 0x2d, - 0x00, 0xf5, 0xd1, 0x2d, 0x40, 0xe5, 0xd4, 0x2d, 0x40, 0xe1, 0xd3, 0x2d, - 0x40, 0xe1, 0x88, 0x12, 0x80, 0x0d, 0xe5, 0x8d, 0x12, 0x80, 0x04, 0xe9, - 0x8a, 0x12, 0x40, 0xe5, 0x8c, 0x12, 0x40, 0xe1, 0x8b, 0x12, 0x40, 0xe1, - 0x87, 0x12, 0x40, 0xe5, 0x84, 0x12, 0x40, 0xe1, 0x83, 0x12, 0x40, 0xe1, - 0xc8, 0x12, 0x80, 0x1a, 0xe5, 0xcd, 0x12, 0x80, 0x11, 0xe9, 0xca, 0x12, - 0x00, 0xef, 0xce, 0x12, 0x80, 0x04, 0xf5, 0xc9, 0x12, 0x40, 0xe1, 0xcf, - 0x12, 0x40, 0xe5, 0xcc, 0x12, 0x40, 0xe1, 0xcb, 0x12, 0x40, 0xe1, 0x68, - 0x12, 0x80, 0x1b, 0xe5, 0x6d, 0x12, 0x80, 0x12, 0xe9, 0x6a, 0x12, 0x00, - 0xef, 0x6e, 0x12, 0x00, 0xf5, 0x69, 0x12, 0x00, 0x42, 0xa9, 0x01, 0x6f, - 0x12, 0x40, 0xe5, 0x6c, 0x12, 0x40, 0xe1, 0x6b, 0x12, 0x40, 0xe1, 0x70, - 0x12, 0x80, 0xb8, 0x01, 0xe5, 0x75, 0x12, 0x80, 0xae, 0x01, 0xa8, 0x82, - 0x01, 0xe9, 0x72, 0x12, 0x00, 0xef, 0x76, 0x12, 0x80, 0x75, 0xb3, 0x4f, - 0x02, 0x53, 0x00, 0x30, 0xf5, 0x71, 0x12, 0x00, 0x42, 0xa9, 0x01, 0x77, - 0x12, 0x00, 0xba, 0x01, 0xff, 0xe1, 0x40, 0x13, 0x80, 0x1a, 0xe5, 0x45, - 0x13, 0x80, 0x11, 0xe9, 0x42, 0x13, 0x00, 0xef, 0x46, 0x13, 0x80, 0x04, - 0xf5, 0x41, 0x13, 0x40, 0xe1, 0x47, 0x13, 0x40, 0xe5, 0x44, 0x13, 0x40, - 0xe1, 0x43, 0x13, 0x40, 0x42, 0x80, 0x12, 0x03, 0xab, 0x00, 0xe5, 0x05, - 0xab, 0x80, 0x0c, 0xe9, 0x02, 0xab, 0x00, 0xef, 0x06, 0xab, 0x00, 0xf5, - 0x01, 0xab, 0x40, 0xe5, 0x04, 0xab, 0x40, 0xe1, 0x38, 0x13, 0x80, 0x1b, - 0xe5, 0x3d, 0x13, 0x80, 0x12, 0xe9, 0x3a, 0x13, 0x00, 0xef, 0x3e, 0x13, - 0x00, 0xf5, 0x39, 0x13, 0x00, 0x42, 0xa9, 0x01, 0x3f, 0x13, 0x40, 0xe5, - 0x3c, 0x13, 0x40, 0xe1, 0x3b, 0x13, 0x40, 0xe1, 0x86, 0x2d, 0x40, 0xe1, - 0x20, 0x13, 0x80, 0x20, 0xe5, 0x25, 0x13, 0x80, 0x17, 0xe9, 0x22, 0x13, - 0x00, 0xef, 0x26, 0x13, 0x80, 0x0a, 0xf5, 0x21, 0x13, 0x00, 0x42, 0xa9, - 0x01, 0x27, 0x13, 0x40, 0xe1, 0x8f, 0x2d, 0x40, 0xe5, 0x24, 0x13, 0x40, - 0xe1, 0x23, 0x13, 0x40, 0xe5, 0x74, 0x12, 0x40, 0xe1, 0x73, 0x12, 0x40, - 0xe1, 0x30, 0x12, 0x80, 0xaf, 0x01, 0xe5, 0x35, 0x12, 0x80, 0x89, 0x01, - 0xa8, 0x5e, 0xe9, 0x32, 0x12, 0x00, 0xef, 0x36, 0x12, 0x80, 0x51, 0xb3, - 0x31, 0xf5, 0x31, 0x12, 0x00, 0x42, 0xa9, 0x01, 0x37, 0x12, 0x00, 0xba, - 0x01, 0xff, 0xe1, 0x20, 0x12, 0x80, 0x1b, 0xe5, 0x25, 0x12, 0x80, 0x12, - 0xe9, 0x22, 0x12, 0x00, 0xef, 0x26, 0x12, 0x00, 0xf5, 0x21, 0x12, 0x00, - 0x42, 0xa9, 0x01, 0x27, 0x12, 0x40, 0xe5, 0x24, 0x12, 0x40, 0xe1, 0x23, - 0x12, 0x40, 0xe1, 0xa0, 0x2d, 0x80, 0x15, 0xe5, 0xa5, 0x2d, 0x80, 0x0c, - 0xe9, 0xa2, 0x2d, 0x00, 0xef, 0xa6, 0x2d, 0x00, 0xf5, 0xa1, 0x2d, 0x40, - 0xe5, 0xa4, 0x2d, 0x40, 0xe1, 0xa3, 0x2d, 0x40, 0xe1, 0x83, 0x2d, 0x40, - 0xe1, 0x38, 0x12, 0x80, 0x20, 0xe5, 0x3d, 0x12, 0x80, 0x17, 0xe9, 0x3a, - 0x12, 0x00, 0xef, 0x3e, 0x12, 0x80, 0x0a, 0xf5, 0x39, 0x12, 0x00, 0x42, - 0xa9, 0x01, 0x3f, 0x12, 0x40, 0xe1, 0x84, 0x2d, 0x40, 0xe5, 0x3c, 0x12, - 0x40, 0xe1, 0x3b, 0x12, 0x40, 0x08, 0x19, 0xc4, 0x04, 0xe5, 0x34, 0x12, - 0x40, 0x43, 0x65, 0xd2, 0x84, 0x13, 0x00, 0x43, 0xf9, 0xef, 0x88, 0x13, - 0x00, 0x43, 0xa0, 0x94, 0x80, 0x13, 0x00, 0x43, 0x51, 0x02, 0x8c, 0x13, - 0x40, 0xe1, 0x33, 0x12, 0x40, 0xe1, 0x28, 0x12, 0x80, 0x26, 0xe5, 0x2d, - 0x12, 0x80, 0x1d, 0xe9, 0x2a, 0x12, 0x00, 0xef, 0x2e, 0x12, 0x80, 0x10, - 0xf5, 0x29, 0x12, 0x00, 0x42, 0xa9, 0x01, 0x2f, 0x12, 0x00, 0x42, 0xbe, - 0x22, 0x58, 0x13, 0x40, 0xe1, 0x82, 0x2d, 0x40, 0xe5, 0x2c, 0x12, 0x40, - 0xe1, 0x2b, 0x12, 0x40, 0xe1, 0x40, 0x12, 0x80, 0x8d, 0x01, 0xe5, 0x45, - 0x12, 0x80, 0x83, 0x01, 0xa8, 0x4a, 0xe9, 0x42, 0x12, 0x00, 0xef, 0x46, - 0x12, 0x80, 0x3d, 0xf5, 0x41, 0x12, 0x00, 0xb7, 0x21, 0xb9, 0x01, 0xff, - 0xe1, 0xc0, 0x2d, 0x80, 0x15, 0xe5, 0xc5, 0x2d, 0x80, 0x0c, 0xe9, 0xc2, - 0x2d, 0x00, 0xef, 0xc6, 0x2d, 0x00, 0xf5, 0xc1, 0x2d, 0x40, 0xe5, 0xc4, - 0x2d, 0x40, 0xe1, 0xc3, 0x2d, 0x40, 0xe1, 0x48, 0x12, 0x80, 0x0d, 0xe5, - 0x4d, 0x12, 0x80, 0x04, 0xe9, 0x4a, 0x12, 0x40, 0xe5, 0x4c, 0x12, 0x40, - 0xe1, 0x4b, 0x12, 0x40, 0xe1, 0x47, 0x12, 0x40, 0xe1, 0x50, 0x12, 0x80, - 0x2e, 0xe5, 0x55, 0x12, 0x80, 0x25, 0xe9, 0x52, 0x12, 0x00, 0xef, 0x56, - 0x12, 0x00, 0xf5, 0x51, 0x12, 0x00, 0xb7, 0x01, 0xff, 0xe1, 0x58, 0x12, - 0x80, 0x0d, 0xe5, 0x5d, 0x12, 0x80, 0x04, 0xe9, 0x5a, 0x12, 0x40, 0xe5, - 0x5c, 0x12, 0x40, 0xe1, 0x5b, 0x12, 0x40, 0xe5, 0x54, 0x12, 0x40, 0xe1, - 0x53, 0x12, 0x40, 0xe5, 0x44, 0x12, 0x40, 0xe1, 0x43, 0x12, 0x40, 0xe1, - 0x50, 0x13, 0x80, 0x7c, 0xe5, 0x55, 0x13, 0x80, 0x73, 0xa8, 0x25, 0xe9, - 0x52, 0x13, 0x00, 0xef, 0x56, 0x13, 0x80, 0x18, 0xf5, 0x51, 0x13, 0x00, - 0xb7, 0x01, 0xff, 0xe1, 0x57, 0x13, 0x00, 0xe5, 0x8f, 0x13, 0x80, 0x04, - 0xe9, 0x8d, 0x13, 0x40, 0xe5, 0x8e, 0x13, 0x40, 0xe1, 0x92, 0x2d, 0x40, - 0xe1, 0x30, 0x13, 0x80, 0x20, 0xe5, 0x35, 0x13, 0x80, 0x17, 0xe9, 0x32, - 0x13, 0x00, 0xef, 0x36, 0x13, 0x80, 0x0a, 0xf5, 0x31, 0x13, 0x00, 0x42, - 0xa9, 0x01, 0x37, 0x13, 0x40, 0xe1, 0x91, 0x2d, 0x40, 0xe5, 0x34, 0x13, - 0x40, 0xe1, 0x33, 0x13, 0x00, 0x08, 0x1e, 0x1d, 0x01, 0xff, 0xe1, 0xd0, - 0x12, 0x80, 0x15, 0xe5, 0xd5, 0x12, 0x80, 0x0c, 0xe9, 0xd2, 0x12, 0x00, - 0xef, 0xd6, 0x12, 0x00, 0xf5, 0xd1, 0x12, 0x40, 0xe5, 0xd4, 0x12, 0x40, - 0xe1, 0xd3, 0x12, 0x40, 0xe5, 0x54, 0x13, 0x40, 0xe1, 0x53, 0x13, 0x40, - 0xe1, 0x90, 0x12, 0x80, 0x4c, 0xe5, 0x95, 0x12, 0x80, 0x43, 0xe9, 0x92, - 0x12, 0x00, 0xef, 0x96, 0x12, 0x80, 0x36, 0xf5, 0x91, 0x12, 0x00, 0x42, - 0xa9, 0x01, 0x97, 0x12, 0x00, 0xb9, 0x01, 0xff, 0xe1, 0x98, 0x12, 0x80, - 0x20, 0xe5, 0x9d, 0x12, 0x80, 0x17, 0xe9, 0x9a, 0x12, 0x00, 0xef, 0x9e, - 0x12, 0x80, 0x0a, 0xf5, 0x99, 0x12, 0x00, 0x42, 0xa9, 0x01, 0x9f, 0x12, - 0x40, 0xe1, 0x89, 0x2d, 0x40, 0xe5, 0x9c, 0x12, 0x40, 0xe1, 0x9b, 0x12, - 0x40, 0xe1, 0x88, 0x2d, 0x40, 0xe5, 0x94, 0x12, 0x40, 0xe1, 0x93, 0x12, - 0x40, 0xe1, 0x18, 0x12, 0x80, 0x33, 0xe5, 0x1d, 0x12, 0x80, 0x2a, 0xe9, - 0x1a, 0x12, 0x00, 0xef, 0x1e, 0x12, 0x80, 0x1d, 0xf5, 0x19, 0x12, 0x00, - 0xb7, 0x06, 0x42, 0xbe, 0x22, 0x59, 0x13, 0x40, 0xe1, 0x1f, 0x12, 0x00, - 0xe5, 0x83, 0x13, 0x80, 0x04, 0xe9, 0x81, 0x13, 0x40, 0xe5, 0x82, 0x13, - 0x40, 0xe1, 0x81, 0x2d, 0x40, 0xe5, 0x1c, 0x12, 0x40, 0xe1, 0x1b, 0x12, - 0x40, 0xe1, 0x08, 0x12, 0x80, 0x20, 0xe5, 0x0d, 0x12, 0x80, 0x17, 0xe9, - 0x0a, 0x12, 0x00, 0xef, 0x0e, 0x12, 0x80, 0x0a, 0xf5, 0x09, 0x12, 0x00, - 0x42, 0xa9, 0x01, 0x0f, 0x12, 0x40, 0xe1, 0x80, 0x2d, 0x40, 0xe5, 0x0c, - 0x12, 0x40, 0xe1, 0x0b, 0x12, 0x40, 0xe1, 0xa8, 0x12, 0x80, 0x8d, 0x01, - 0xe5, 0xad, 0x12, 0x80, 0x83, 0x01, 0xe9, 0xaa, 0x12, 0x00, 0xef, 0xae, - 0x12, 0x80, 0x76, 0xf5, 0xa9, 0x12, 0x00, 0xb7, 0x5a, 0xb8, 0x21, 0xb9, - 0x01, 0xff, 0xe1, 0xc8, 0x2d, 0x80, 0x15, 0xe5, 0xcd, 0x2d, 0x80, 0x0c, - 0xe9, 0xca, 0x2d, 0x00, 0xef, 0xce, 0x2d, 0x00, 0xf5, 0xc9, 0x2d, 0x40, - 0xe5, 0xcc, 0x2d, 0x40, 0xe1, 0xcb, 0x2d, 0x40, 0xe1, 0xb8, 0x12, 0x80, - 0x2e, 0xe5, 0xbd, 0x12, 0x80, 0x25, 0xe9, 0xba, 0x12, 0x00, 0xef, 0xbe, - 0x12, 0x00, 0xf5, 0xb9, 0x12, 0x00, 0xb7, 0x01, 0xff, 0xe1, 0xc0, 0x12, - 0x80, 0x0d, 0xe5, 0xc5, 0x12, 0x80, 0x04, 0xe9, 0xc2, 0x12, 0x40, 0xe5, - 0xc4, 0x12, 0x40, 0xe1, 0xc3, 0x12, 0x40, 0xe5, 0xbc, 0x12, 0x40, 0xe1, - 0xbb, 0x12, 0x40, 0xe1, 0xb0, 0x12, 0x80, 0x0d, 0xe5, 0xb5, 0x12, 0x80, - 0x04, 0xe9, 0xb2, 0x12, 0x40, 0xe5, 0xb4, 0x12, 0x40, 0xe1, 0xb3, 0x12, - 0x40, 0xe1, 0xaf, 0x12, 0x40, 0xe5, 0xac, 0x12, 0x40, 0xe1, 0xab, 0x12, - 0x40, 0xe1, 0x00, 0x13, 0x80, 0x20, 0xe5, 0x05, 0x13, 0x80, 0x17, 0xe9, - 0x02, 0x13, 0x00, 0xef, 0x06, 0x13, 0x80, 0x0a, 0xf5, 0x01, 0x13, 0x00, - 0x42, 0xa9, 0x01, 0x07, 0x13, 0x40, 0xe1, 0x8e, 0x2d, 0x40, 0xe5, 0x04, - 0x13, 0x40, 0xe1, 0x03, 0x13, 0x40, 0xe1, 0x00, 0x12, 0x80, 0x6e, 0xe5, - 0x05, 0x12, 0x80, 0x65, 0xa8, 0x11, 0xe9, 0x02, 0x12, 0x00, 0xef, 0x06, - 0x12, 0x80, 0x04, 0xf5, 0x01, 0x12, 0x40, 0xe1, 0x07, 0x12, 0x40, 0xe1, - 0x10, 0x12, 0x80, 0x49, 0xe5, 0x15, 0x12, 0x80, 0x40, 0xe9, 0x12, 0x12, - 0x00, 0xef, 0x16, 0x12, 0x00, 0xf5, 0x11, 0x12, 0x00, 0xb7, 0x21, 0xb9, - 0x01, 0xff, 0xe1, 0xe0, 0xe7, 0x81, 0x15, 0xe5, 0xe5, 0xe7, 0x81, 0x0c, - 0xe9, 0xe2, 0xe7, 0x01, 0xef, 0xe6, 0xe7, 0x01, 0xf5, 0xe1, 0xe7, 0x41, - 0xe5, 0xe4, 0xe7, 0x41, 0xe1, 0xe3, 0xe7, 0x41, 0xe1, 0x17, 0x12, 0x00, - 0xe5, 0xeb, 0xe7, 0x81, 0x04, 0xe9, 0xe9, 0xe7, 0x41, 0xe5, 0xea, 0xe7, - 0x41, 0xe5, 0x14, 0x12, 0x40, 0xe1, 0x13, 0x12, 0x40, 0xe5, 0x04, 0x12, - 0x40, 0xe1, 0x03, 0x12, 0x40, 0xe1, 0x08, 0x13, 0x80, 0xb5, 0x02, 0xe5, - 0x0d, 0x13, 0x80, 0xab, 0x02, 0xa7, 0xf1, 0x01, 0xe9, 0x0a, 0x13, 0x00, - 0x07, 0xea, 0x28, 0xbf, 0x01, 0xef, 0x0e, 0x13, 0x80, 0xb5, 0x01, 0xf5, - 0x09, 0x13, 0x80, 0x39, 0xb7, 0x21, 0xb9, 0x01, 0xff, 0xe1, 0xd8, 0x2d, - 0x80, 0x15, 0xe5, 0xdd, 0x2d, 0x80, 0x0c, 0xe9, 0xda, 0x2d, 0x00, 0xef, - 0xde, 0x2d, 0x00, 0xf5, 0xd9, 0x2d, 0x40, 0xe5, 0xdc, 0x2d, 0x40, 0xe1, - 0xdb, 0x2d, 0x40, 0xe1, 0x10, 0x13, 0x80, 0x0d, 0xe5, 0x15, 0x13, 0x80, - 0x04, 0xe9, 0x12, 0x13, 0x40, 0xe5, 0x14, 0x13, 0x40, 0xe1, 0x13, 0x13, - 0x40, 0x05, 0x44, 0x5f, 0x01, 0xff, 0x02, 0x65, 0xd2, 0x64, 0x02, 0x9b, - 0x56, 0x56, 0x02, 0x95, 0xb3, 0x45, 0x44, 0x5d, 0xf0, 0xe8, 0xe7, 0x01, - 0x02, 0x3c, 0x0b, 0x2e, 0x02, 0x3d, 0x38, 0x20, 0x02, 0x51, 0x02, 0x12, - 0x02, 0x38, 0xf3, 0x01, 0xff, 0xe5, 0xf2, 0xe7, 0x81, 0x04, 0xe9, 0xf0, - 0xe7, 0x41, 0xe5, 0xf1, 0xe7, 0x41, 0x42, 0x27, 0x01, 0xfe, 0xe7, 0x01, - 0xe9, 0xfd, 0xe7, 0x41, 0x42, 0x27, 0x01, 0xee, 0xe7, 0x01, 0xe9, 0xed, - 0xe7, 0x41, 0xe5, 0xf7, 0xe7, 0x81, 0x04, 0xe9, 0xf5, 0xe7, 0x41, 0xe5, - 0xf6, 0xe7, 0x41, 0xe5, 0xfa, 0xe7, 0x81, 0x04, 0xe9, 0xf8, 0xe7, 0x41, - 0xe5, 0xf9, 0xe7, 0x41, 0x42, 0x27, 0x01, 0xfc, 0xe7, 0x01, 0xe9, 0xfb, - 0xe7, 0x41, 0x42, 0x27, 0x01, 0xf4, 0xe7, 0x01, 0xe9, 0xf3, 0xe7, 0x41, - 0xe1, 0x0f, 0x13, 0x40, 0xe1, 0xa0, 0x12, 0x80, 0x20, 0xe5, 0xa5, 0x12, - 0x80, 0x17, 0xe9, 0xa2, 0x12, 0x00, 0xef, 0xa6, 0x12, 0x80, 0x0a, 0xf5, - 0xa1, 0x12, 0x00, 0x42, 0xa9, 0x01, 0xa7, 0x12, 0x40, 0xe1, 0x8a, 0x2d, - 0x40, 0xe5, 0xa4, 0x12, 0x40, 0xe1, 0xa3, 0x12, 0x40, 0xe1, 0x18, 0x13, - 0x80, 0x2e, 0xe5, 0x1d, 0x13, 0x80, 0x25, 0xe9, 0x1a, 0x13, 0x00, 0xef, - 0x1e, 0x13, 0x00, 0xf5, 0x19, 0x13, 0x00, 0xb7, 0x01, 0xff, 0xe1, 0x93, - 0x2d, 0x80, 0x0d, 0xe5, 0x96, 0x2d, 0x80, 0x04, 0xe9, 0x94, 0x2d, 0x40, - 0xe5, 0x95, 0x2d, 0x40, 0xe1, 0x1f, 0x13, 0x40, 0xe5, 0x1c, 0x13, 0x40, - 0xe1, 0x1b, 0x13, 0x40, 0xe5, 0x0c, 0x13, 0x40, 0xe1, 0x0b, 0x13, 0x40, - 0xe1, 0x48, 0x13, 0x80, 0x2e, 0xe5, 0x4d, 0x13, 0x80, 0x25, 0xe9, 0x4a, - 0x13, 0x00, 0xef, 0x4e, 0x13, 0x00, 0xf5, 0x49, 0x13, 0x00, 0xb7, 0x06, - 0x42, 0xbe, 0x22, 0x5a, 0x13, 0x40, 0xe1, 0x4f, 0x13, 0x00, 0xe5, 0x8b, - 0x13, 0x80, 0x04, 0xe9, 0x89, 0x13, 0x40, 0xe5, 0x8a, 0x13, 0x40, 0xe5, - 0x4c, 0x13, 0x40, 0xe1, 0x4b, 0x13, 0x40, 0xe1, 0xf0, 0x12, 0x80, 0x86, - 0x01, 0xa4, 0x3e, 0xe5, 0xf5, 0x12, 0x80, 0x35, 0xe9, 0xf2, 0x12, 0x00, - 0xef, 0xf6, 0x12, 0x80, 0x28, 0xf5, 0xf1, 0x12, 0x00, 0x42, 0xa9, 0x01, - 0xf7, 0x12, 0x00, 0xba, 0x01, 0xff, 0x42, 0x80, 0x12, 0x13, 0xab, 0x00, - 0xe5, 0x15, 0xab, 0x80, 0x0c, 0xe9, 0x12, 0xab, 0x00, 0xef, 0x16, 0xab, - 0x00, 0xf5, 0x11, 0xab, 0x40, 0xe5, 0x14, 0xab, 0x40, 0xe1, 0x8c, 0x2d, - 0x40, 0xe5, 0xf4, 0x12, 0x40, 0xe1, 0xf8, 0x12, 0x80, 0x3d, 0xe5, 0xfd, - 0x12, 0x80, 0x34, 0xa8, 0x17, 0xe9, 0xfa, 0x12, 0x00, 0xef, 0xfe, 0x12, - 0x80, 0x0a, 0xf5, 0xf9, 0x12, 0x00, 0x42, 0xa9, 0x01, 0xff, 0x12, 0x40, - 0xe1, 0x8d, 0x2d, 0x40, 0x42, 0x80, 0x12, 0x0b, 0xab, 0x00, 0xe5, 0x0d, - 0xab, 0x80, 0x0c, 0xe9, 0x0a, 0xab, 0x00, 0xef, 0x0e, 0xab, 0x00, 0xf5, - 0x09, 0xab, 0x40, 0xe5, 0x0c, 0xab, 0x40, 0xe5, 0xfc, 0x12, 0x40, 0xe1, - 0xfb, 0x12, 0x40, 0xe1, 0xf3, 0x12, 0x40, 0xe1, 0x78, 0x12, 0x80, 0xab, - 0x01, 0xa3, 0x4b, 0xe5, 0x7d, 0x12, 0x80, 0x42, 0xa8, 0x17, 0xe9, 0x7a, - 0x12, 0x00, 0xef, 0x7e, 0x12, 0x80, 0x0a, 0xf5, 0x79, 0x12, 0x00, 0x42, - 0xa9, 0x01, 0x7f, 0x12, 0x40, 0xe1, 0x87, 0x2d, 0x40, 0xe1, 0x28, 0x13, - 0x80, 0x20, 0xe5, 0x2d, 0x13, 0x80, 0x17, 0xe9, 0x2a, 0x13, 0x00, 0xef, - 0x2e, 0x13, 0x80, 0x0a, 0xf5, 0x29, 0x13, 0x00, 0x42, 0xa9, 0x01, 0x2f, - 0x13, 0x40, 0xe1, 0x90, 0x2d, 0x40, 0xe5, 0x2c, 0x13, 0x40, 0xe1, 0x2b, - 0x13, 0x40, 0xe5, 0x7c, 0x12, 0x40, 0xe1, 0xa8, 0x2d, 0x80, 0x55, 0xe5, - 0xad, 0x2d, 0x80, 0x4c, 0xa8, 0x0c, 0xe9, 0xaa, 0x2d, 0x00, 0xef, 0xae, - 0x2d, 0x00, 0xf5, 0xa9, 0x2d, 0x40, 0xe1, 0xb8, 0x2d, 0x80, 0x35, 0xe5, - 0xbd, 0x2d, 0x80, 0x2c, 0xa8, 0x0c, 0xe9, 0xba, 0x2d, 0x00, 0xef, 0xbe, - 0x2d, 0x00, 0xf5, 0xb9, 0x2d, 0x40, 0xe1, 0x20, 0xab, 0x80, 0x15, 0xe5, - 0x25, 0xab, 0x80, 0x0c, 0xe9, 0x22, 0xab, 0x00, 0xef, 0x26, 0xab, 0x00, - 0xf5, 0x21, 0xab, 0x40, 0xe5, 0x24, 0xab, 0x40, 0xe1, 0x23, 0xab, 0x40, - 0xe5, 0xbc, 0x2d, 0x40, 0xe1, 0xbb, 0x2d, 0x40, 0xe5, 0xac, 0x2d, 0x40, - 0xe1, 0xab, 0x2d, 0x40, 0xe1, 0x7b, 0x12, 0x40, 0xe1, 0x60, 0x12, 0x80, - 0x4e, 0xa2, 0x2e, 0xe5, 0x65, 0x12, 0x80, 0x25, 0xe9, 0x62, 0x12, 0x00, - 0xef, 0x66, 0x12, 0x80, 0x18, 0xf5, 0x61, 0x12, 0x00, 0xb7, 0x01, 0xff, - 0xe1, 0x67, 0x12, 0x00, 0xe5, 0x87, 0x13, 0x80, 0x04, 0xe9, 0x85, 0x13, - 0x40, 0xe5, 0x86, 0x13, 0x40, 0xe1, 0x85, 0x2d, 0x40, 0xe5, 0x64, 0x12, - 0x40, 0xe1, 0x28, 0xab, 0x80, 0x15, 0xe5, 0x2d, 0xab, 0x80, 0x0c, 0xe9, - 0x2a, 0xab, 0x00, 0xef, 0x2e, 0xab, 0x00, 0xf5, 0x29, 0xab, 0x40, 0xe5, - 0x2c, 0xab, 0x40, 0xe1, 0x2b, 0xab, 0x40, 0xe1, 0x63, 0x12, 0x40, 0x4a, - 0x15, 0x27, 0x60, 0x13, 0x00, 0x47, 0xe2, 0x59, 0x64, 0x13, 0x40, 0x52, - 0x1f, 0x4c, 0x68, 0x13, 0x00, 0x4c, 0x68, 0x94, 0x66, 0x13, 0x40, 0x46, - 0x50, 0xdb, 0x79, 0x13, 0x00, 0xa6, 0x36, 0x47, 0x71, 0x11, 0x7b, 0x13, - 0x00, 0x46, 0xc7, 0x2c, 0x7a, 0x13, 0x00, 0xb3, 0x1c, 0xb4, 0x01, 0xff, - 0x42, 0x92, 0x01, 0x72, 0x13, 0x80, 0x0c, 0x45, 0x7a, 0x11, 0x74, 0x13, - 0x00, 0x45, 0x9a, 0x2c, 0x73, 0x13, 0x40, 0x49, 0x46, 0x5e, 0x7c, 0x13, - 0x40, 0x46, 0xe5, 0x1d, 0x78, 0x13, 0x00, 0x44, 0x66, 0xdd, 0x77, 0x13, - 0x40, 0x44, 0x58, 0x4d, 0x76, 0x13, 0x00, 0x44, 0xd5, 0x51, 0x75, 0x13, - 0x40, 0x45, 0x12, 0x0b, 0x70, 0x13, 0x00, 0xa6, 0x29, 0x44, 0xea, 0x2a, - 0x71, 0x13, 0x00, 0x43, 0x0e, 0x0b, 0x69, 0x13, 0x00, 0xb3, 0x0f, 0xb4, - 0x01, 0xff, 0x44, 0x25, 0x01, 0x6b, 0x13, 0x00, 0x42, 0x15, 0x02, 0x6a, - 0x13, 0x40, 0x44, 0xe5, 0x1d, 0x6f, 0x13, 0x00, 0x42, 0x1c, 0x26, 0x6e, - 0x13, 0x40, 0x43, 0xd2, 0x05, 0x6d, 0x13, 0x00, 0x43, 0xf6, 0x06, 0x6c, - 0x13, 0x40, 0x43, 0xd7, 0x02, 0x65, 0x13, 0x00, 0xad, 0x01, 0xff, 0x07, - 0x35, 0x16, 0x06, 0x42, 0x6c, 0x00, 0x63, 0x13, 0x40, 0x0b, 0x90, 0x6d, - 0x06, 0x51, 0x57, 0x39, 0x5e, 0x13, 0x40, 0x55, 0x53, 0x39, 0x5d, 0x13, - 0x00, 0x44, 0xb9, 0x00, 0x5f, 0x13, 0x40, 0xe1, 0x87, 0x00, 0x00, 0xe3, - 0x1b, 0x00, 0x80, 0x0f, 0x06, 0xba, 0xe0, 0x01, 0xff, 0x48, 0x7a, 0x20, - 0x2e, 0x21, 0x00, 0xf3, 0x59, 0x22, 0x40, 0x43, 0xfe, 0x29, 0x1b, 0x00, - 0x40, 0x0b, 0x63, 0x99, 0x42, 0x08, 0x51, 0xc7, 0x32, 0x0b, 0x74, 0xa2, - 0x01, 0xff, 0x06, 0x0c, 0x03, 0x17, 0x06, 0xad, 0x02, 0x01, 0xff, 0x46, - 0x12, 0x03, 0xf2, 0x29, 0x00, 0x47, 0x9c, 0x44, 0xf0, 0x29, 0x00, 0x46, - 0xd6, 0x05, 0xee, 0x29, 0x40, 0x46, 0x12, 0x03, 0xf3, 0x29, 0x00, 0x47, - 0x9c, 0x44, 0xf1, 0x29, 0x00, 0x46, 0xd6, 0x05, 0xef, 0x29, 0x40, 0x43, - 0x0e, 0x0b, 0xf0, 0x2b, 0x00, 0x43, 0x1f, 0x0a, 0xf1, 0x2b, 0x40, 0x44, - 0xc3, 0x00, 0x2b, 0x23, 0x00, 0x45, 0xc8, 0x00, 0x26, 0x23, 0x40, 0x02, - 0x13, 0x00, 0x1a, 0xa9, 0x01, 0xff, 0x4a, 0xf2, 0xa7, 0x5a, 0x22, 0x00, - 0x07, 0xf2, 0x39, 0x01, 0xff, 0x42, 0x1e, 0x00, 0x4d, 0x22, 0x00, 0x54, - 0xd3, 0x46, 0x78, 0x2a, 0x40, 0x80, 0x6d, 0x02, 0x31, 0x01, 0x01, 0xff, - 0x45, 0xaf, 0x3b, 0x55, 0x22, 0x00, 0x44, 0x5a, 0x03, 0x3d, 0x00, 0x80, - 0x06, 0x4d, 0xb9, 0x8a, 0x6e, 0x2a, 0x40, 0x80, 0x01, 0xff, 0xa1, 0x27, - 0x05, 0x51, 0x00, 0x01, 0xff, 0x4b, 0xe7, 0x99, 0xae, 0x2a, 0x00, 0x49, - 0x9f, 0x12, 0x66, 0x2a, 0x00, 0x09, 0x8c, 0xba, 0x06, 0x61, 0xf2, 0x0e, - 0x77, 0x2a, 0x40, 0x45, 0x5c, 0x00, 0x96, 0x2b, 0x00, 0x45, 0x20, 0x07, - 0xf9, 0x2b, 0x40, 0x05, 0x5d, 0x00, 0x0d, 0x53, 0x98, 0x38, 0xe3, 0x29, - 0xc0, 0x00, 0x51, 0x8e, 0x57, 0xe4, 0x29, 0x40, 0x4f, 0x69, 0x1a, 0x40, - 0x2b, 0x00, 0x49, 0xe6, 0x71, 0x71, 0x2a, 0x00, 0x50, 0xb3, 0x02, 0x71, - 0x29, 0x00, 0x4e, 0x93, 0x3e, 0x73, 0x2a, 0x40, 0x4f, 0xde, 0x6a, 0xd5, - 0x22, 0x00, 0x03, 0x7a, 0x02, 0x01, 0xff, 0x4d, 0x61, 0x81, 0x5d, 0x22, - 0x00, 0x03, 0xc8, 0x07, 0x01, 0xff, 0x4c, 0x87, 0x00, 0xdd, 0x22, 0x00, - 0x49, 0xec, 0x00, 0xdc, 0x22, 0x00, 0x48, 0x09, 0xca, 0xde, 0x22, 0x00, - 0x48, 0x51, 0xcb, 0xdf, 0x22, 0x40, 0xec, 0x0a, 0x00, 0x00, 0xed, 0x19, - 0x00, 0x00, 0xf4, 0x04, 0x00, 0x40, 0x80, 0x75, 0x02, 0x06, 0x00, 0x29, - 0xf1, 0x05, 0x00, 0x80, 0x1e, 0x4a, 0x25, 0x45, 0x86, 0x23, 0x00, 0x46, - 0x60, 0x32, 0x09, 0x27, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x55, - 0xa3, 0x3a, 0xe9, 0xf4, 0x01, 0x49, 0x88, 0xbb, 0x84, 0xf5, 0x41, 0x44, - 0x40, 0xea, 0x05, 0x00, 0x40, 0x03, 0xf4, 0x01, 0x06, 0x5a, 0xa4, 0x22, - 0x1a, 0xf5, 0x41, 0x4c, 0x7c, 0x8f, 0x97, 0x00, 0x00, 0x44, 0xed, 0x07, - 0x0a, 0x00, 0x00, 0x46, 0x44, 0x04, 0x19, 0x00, 0x00, 0x03, 0xdf, 0x0c, - 0x1c, 0x4d, 0x97, 0x88, 0x87, 0x00, 0x00, 0xb4, 0x01, 0xff, 0x43, 0xd9, - 0x06, 0x03, 0x00, 0x00, 0x4b, 0xe5, 0xa1, 0x04, 0x00, 0xc0, 0x00, 0x46, - 0x32, 0x01, 0x17, 0x00, 0x40, 0x42, 0xf4, 0x01, 0x0e, 0x22, 0x00, 0x4b, - 0x6f, 0x7b, 0x97, 0x00, 0x40, 0x44, 0x8f, 0x12, 0x13, 0x20, 0x00, 0x44, - 0x79, 0x0d, 0x00, 0x20, 0x00, 0x45, 0xd7, 0x4c, 0x02, 0x20, 0x40, 0x80, - 0x9c, 0x01, 0x04, 0xe9, 0xf1, 0x61, 0xb0, 0x01, 0xff, 0x4c, 0xac, 0x8f, - 0x83, 0x23, 0x00, 0x03, 0xe9, 0x1d, 0x01, 0xff, 0x48, 0x51, 0xc5, 0xcb, - 0xf5, 0x01, 0xae, 0x2f, 0x44, 0x9a, 0xa6, 0xcc, 0xf5, 0x81, 0x24, 0x43, - 0x9c, 0x12, 0x05, 0x22, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x50, - 0x7d, 0x64, 0xb4, 0x29, 0x00, 0x47, 0xfb, 0x7f, 0xb1, 0x29, 0x00, 0x51, - 0xc8, 0x00, 0xb3, 0x29, 0x00, 0x52, 0x7c, 0x55, 0xb2, 0x29, 0x40, 0xf3, - 0xcd, 0xf5, 0x41, 0x43, 0xdb, 0x1a, 0xb9, 0xfa, 0x01, 0x43, 0x25, 0x28, - 0xc5, 0xf5, 0xc1, 0x00, 0x03, 0xee, 0x0e, 0x01, 0xff, 0xe4, 0xc7, 0xf5, - 0x01, 0x42, 0xdb, 0x09, 0xc6, 0xf5, 0x41, 0x0a, 0xec, 0xa8, 0x1b, 0x1a, - 0x38, 0x21, 0x01, 0xff, 0x43, 0xaa, 0xf3, 0xfb, 0xf3, 0x01, 0xd3, 0xfc, - 0xf3, 0x01, 0xd4, 0xfd, 0xf3, 0x01, 0xd5, 0xfe, 0xf3, 0x01, 0xd6, 0xff, - 0xf3, 0x41, 0x44, 0x4d, 0xef, 0xb2, 0xf9, 0x01, 0x4a, 0x1e, 0xa9, 0xb1, - 0xf9, 0x01, 0x48, 0x71, 0xca, 0xb0, 0xf9, 0x01, 0x4a, 0x96, 0xb3, 0xb3, - 0xf9, 0x41, 0x44, 0x8f, 0x12, 0x14, 0x20, 0x00, 0x44, 0x79, 0x0d, 0x01, - 0x20, 0x00, 0x45, 0xd7, 0x4c, 0x03, 0x20, 0x40, 0x0d, 0x2d, 0x81, 0x96, - 0x02, 0xa5, 0xa0, 0x01, 0xe6, 0xdd, 0xf9, 0x01, 0x07, 0x05, 0xd8, 0x01, - 0xff, 0x06, 0xed, 0x05, 0x06, 0x52, 0x9a, 0x52, 0xf6, 0x0f, 0x41, 0xa1, - 0x7f, 0x44, 0x61, 0xef, 0xe1, 0x0f, 0x01, 0x46, 0x2a, 0x4a, 0xe3, 0x0f, - 0x01, 0x45, 0xfe, 0xaa, 0xe2, 0x0f, 0x01, 0x42, 0xb0, 0x01, 0xe4, 0x0f, - 0x81, 0x60, 0x44, 0xed, 0xf0, 0xea, 0x0f, 0x01, 0x46, 0xb4, 0xdd, 0xeb, - 0x0f, 0x01, 0x43, 0xb4, 0x05, 0xec, 0x0f, 0x01, 0x43, 0xde, 0x22, 0xed, - 0x0f, 0x01, 0x42, 0x6f, 0x02, 0xf0, 0x0f, 0x01, 0x44, 0x6d, 0xc8, 0xf2, - 0x0f, 0x01, 0x44, 0x7d, 0x66, 0xf3, 0x0f, 0x01, 0xb3, 0x20, 0xb4, 0x12, - 0x43, 0x9f, 0x8a, 0xe5, 0x0f, 0x01, 0x44, 0xa8, 0x52, 0xe9, 0x0f, 0x01, - 0x45, 0xa2, 0x52, 0xe6, 0x0f, 0x41, 0x42, 0xd2, 0x2d, 0xf5, 0x0f, 0x01, - 0x43, 0xf5, 0x25, 0xe8, 0x0f, 0x41, 0xa1, 0x06, 0x43, 0x7a, 0x16, 0xf4, - 0x0f, 0x41, 0x43, 0xcd, 0xea, 0xf1, 0x0f, 0x01, 0x44, 0x69, 0xe4, 0xee, - 0x0f, 0x41, 0x42, 0x53, 0x00, 0xe7, 0x0f, 0x41, 0x44, 0x33, 0x3d, 0xe0, - 0x0f, 0x01, 0x43, 0x9a, 0x1a, 0xef, 0x0f, 0x41, 0x05, 0x85, 0xe5, 0x4f, - 0x47, 0x69, 0x92, 0x08, 0x22, 0x80, 0x0c, 0x45, 0xb4, 0xc5, 0x18, 0xf4, - 0x01, 0x45, 0x38, 0xec, 0xd7, 0xf6, 0x41, 0x80, 0x01, 0xff, 0x08, 0x08, - 0x76, 0x29, 0x05, 0x51, 0x00, 0x01, 0xff, 0x49, 0x56, 0x1e, 0xf5, 0x22, - 0x00, 0x56, 0x94, 0x35, 0xf2, 0x22, 0x00, 0x47, 0xfb, 0x7f, 0xf6, 0x22, - 0x00, 0x56, 0xaa, 0x0b, 0xf9, 0x22, 0x00, 0x48, 0xea, 0x59, 0xf8, 0x22, - 0x00, 0x68, 0x30, 0x05, 0xf3, 0x22, 0x40, 0x49, 0xa5, 0x01, 0xd9, 0x2a, - 0x00, 0x47, 0x50, 0x02, 0xd2, 0x27, 0x40, 0x80, 0x06, 0x4f, 0x2f, 0x3c, - 0xe7, 0x23, 0x40, 0x45, 0xce, 0x00, 0x01, 0x23, 0x00, 0x4a, 0x2e, 0xad, - 0xa1, 0xf4, 0x01, 0x44, 0x39, 0xf2, 0x0c, 0xf5, 0x01, 0x45, 0x84, 0xeb, - 0x26, 0xf5, 0x41, 0xe1, 0x00, 0x05, 0x01, 0x42, 0xb7, 0x05, 0x01, 0x05, - 0x01, 0xa3, 0xcf, 0x01, 0xa4, 0xc2, 0x01, 0xe5, 0x08, 0x05, 0x81, 0xb8, - 0x01, 0x42, 0x28, 0x1a, 0x09, 0x05, 0x01, 0xa7, 0x99, 0x01, 0x42, 0xb0, - 0x01, 0x0c, 0x05, 0x01, 0xe9, 0x0d, 0x05, 0x01, 0x42, 0x82, 0x20, 0x0e, - 0x05, 0x01, 0xab, 0x7d, 0xac, 0x71, 0x42, 0x2a, 0x02, 0x12, 0x05, 0x01, - 0xae, 0x55, 0xef, 0x16, 0x05, 0x01, 0x42, 0x6f, 0x02, 0x17, 0x05, 0x01, - 0x42, 0xb9, 0xa2, 0x18, 0x05, 0x01, 0xb2, 0x39, 0xb3, 0x2d, 0xb4, 0x21, - 0xf5, 0x1f, 0x05, 0x01, 0x42, 0x32, 0x00, 0x20, 0x05, 0x01, 0x42, 0x74, - 0x43, 0x21, 0x05, 0x01, 0xf9, 0x22, 0x05, 0x01, 0xba, 0x01, 0xff, 0xe5, - 0x23, 0x05, 0x01, 0x42, 0xb0, 0x01, 0x24, 0x05, 0x41, 0xe5, 0x1d, 0x05, - 0x01, 0x42, 0xb0, 0x01, 0x1e, 0x05, 0x41, 0xe5, 0x1b, 0x05, 0x01, 0x42, - 0xb0, 0x01, 0x1c, 0x05, 0x41, 0xe5, 0x19, 0x05, 0x01, 0x42, 0x88, 0x00, - 0x1a, 0x05, 0x41, 0xe1, 0x14, 0x05, 0x01, 0x42, 0x04, 0x00, 0x05, 0x05, - 0x01, 0xe5, 0x13, 0x05, 0x01, 0x42, 0x82, 0x20, 0x15, 0x05, 0x41, 0xe5, - 0x10, 0x05, 0x01, 0x42, 0x68, 0x00, 0x11, 0x05, 0x41, 0xe5, 0x0f, 0x05, - 0x01, 0x42, 0xb0, 0x01, 0x27, 0x05, 0x41, 0xe5, 0x0a, 0x05, 0x01, 0xa8, - 0x06, 0x42, 0x82, 0x20, 0x0b, 0x05, 0x41, 0x44, 0x02, 0x21, 0x26, 0x05, - 0x01, 0xe5, 0x25, 0x05, 0x41, 0xe9, 0x07, 0x05, 0x41, 0xe5, 0x04, 0x05, - 0x01, 0x42, 0xb0, 0x01, 0x06, 0x05, 0x41, 0xe5, 0x02, 0x05, 0x01, 0x42, - 0xb0, 0x01, 0x03, 0x05, 0x41, 0x80, 0x06, 0x46, 0xd1, 0x63, 0x6a, 0x26, - 0x40, 0xb0, 0x1c, 0x05, 0x4d, 0x66, 0x0c, 0x4f, 0xf1, 0x1c, 0x33, 0x27, - 0x00, 0x62, 0x22, 0x0d, 0x4a, 0x27, 0x40, 0x46, 0x2a, 0xdd, 0x69, 0xcc, - 0x01, 0x47, 0x5b, 0xd4, 0x6a, 0xcc, 0x41, 0x5f, 0x10, 0x11, 0x41, 0x27, - 0x00, 0x07, 0x34, 0x08, 0x01, 0xff, 0x4a, 0x0f, 0x2c, 0x34, 0x27, 0x00, - 0x4d, 0x28, 0x13, 0x35, 0x27, 0x00, 0x56, 0xc8, 0x36, 0x37, 0x27, 0x40, - 0x44, 0x52, 0x5a, 0xc6, 0xce, 0x01, 0xe7, 0x5a, 0xf9, 0x01, 0x11, 0xec, - 0x5f, 0x01, 0xff, 0x80, 0x04, 0xcd, 0x02, 0xd8, 0x40, 0xa1, 0xe6, 0x23, - 0xa2, 0x9f, 0x23, 0x02, 0x35, 0xf5, 0xa1, 0x22, 0x02, 0x37, 0xf5, 0x8e, - 0x1f, 0xa5, 0xb1, 0x1d, 0xa6, 0x88, 0x1b, 0x02, 0x39, 0xf5, 0xeb, 0x18, - 0xa8, 0xa9, 0x18, 0xa9, 0x98, 0x17, 0x03, 0x85, 0xf4, 0xf3, 0x16, 0xac, - 0xbc, 0x16, 0xad, 0x9f, 0x13, 0xae, 0xe7, 0x0f, 0xaf, 0x93, 0x0d, 0x02, - 0x91, 0xd8, 0xd3, 0x0c, 0x03, 0xac, 0xf4, 0xb2, 0x0c, 0x02, 0x10, 0xce, - 0x9a, 0x0b, 0x02, 0x19, 0xe2, 0xaa, 0x09, 0xb4, 0xdd, 0x07, 0x02, 0x00, - 0xed, 0x8c, 0x06, 0xb6, 0xaf, 0x03, 0xb7, 0x96, 0x02, 0x03, 0xee, 0xf4, - 0xde, 0x01, 0x03, 0xfa, 0xf4, 0xb4, 0x01, 0x02, 0x49, 0xf5, 0x01, 0xff, - 0x90, 0x65, 0x91, 0x01, 0xff, 0xd0, 0xf5, 0x33, 0x01, 0xd1, 0xf6, 0x33, - 0x01, 0xd2, 0xf7, 0x33, 0x01, 0xd3, 0xf8, 0x33, 0x01, 0xd4, 0xf9, 0x33, - 0x01, 0xd5, 0xfa, 0x33, 0x81, 0x25, 0xd6, 0x04, 0x34, 0xc1, 0x00, 0xe1, - 0x05, 0x34, 0x01, 0xe2, 0x06, 0x34, 0x01, 0xe3, 0x07, 0x34, 0x01, 0xe4, - 0x08, 0x34, 0x01, 0xe5, 0x09, 0x34, 0x01, 0xe6, 0x0a, 0x34, 0x01, 0xe7, - 0x0b, 0x34, 0x01, 0xe8, 0x0c, 0x34, 0x41, 0xe1, 0xfb, 0x33, 0x01, 0xe2, - 0xfc, 0x33, 0x01, 0xe3, 0xfd, 0x33, 0x01, 0xe4, 0xfe, 0x33, 0x01, 0xe5, - 0xff, 0x33, 0x01, 0xe6, 0x00, 0x34, 0x01, 0xe7, 0x01, 0x34, 0x01, 0xe8, - 0x02, 0x34, 0x01, 0xe9, 0x03, 0x34, 0x41, 0xd1, 0xe4, 0x33, 0x01, 0xd2, - 0xe5, 0x33, 0x81, 0x2f, 0xd3, 0xea, 0x33, 0x81, 0x22, 0xd4, 0xed, 0x33, - 0x81, 0x19, 0xd5, 0xef, 0x33, 0x81, 0x10, 0xd6, 0xf1, 0x33, 0x01, 0xd7, - 0xf2, 0x33, 0x01, 0xd8, 0xf3, 0x33, 0x01, 0xd9, 0xf4, 0x33, 0x41, 0xe1, - 0xf0, 0x33, 0x41, 0xe1, 0xee, 0x33, 0x41, 0xe1, 0xeb, 0x33, 0x01, 0xe2, - 0xec, 0x33, 0x41, 0xe1, 0xe6, 0x33, 0x01, 0xe2, 0xe7, 0x33, 0x01, 0xe3, - 0xe8, 0x33, 0x01, 0xe4, 0xe9, 0x33, 0x41, 0xd1, 0xdb, 0x33, 0x81, 0x1c, - 0xd2, 0xdd, 0x33, 0x01, 0xd3, 0xde, 0x33, 0x01, 0xd4, 0xdf, 0x33, 0x01, - 0xd5, 0xe0, 0x33, 0x01, 0xd6, 0xe1, 0x33, 0x01, 0xd7, 0xe2, 0x33, 0x01, - 0xd8, 0xe3, 0x33, 0x41, 0xe1, 0xdc, 0x33, 0x41, 0xd1, 0xcf, 0x33, 0x01, - 0xd2, 0xd0, 0x33, 0x01, 0xd3, 0xd1, 0x33, 0x01, 0xd4, 0xd2, 0x33, 0x81, - 0x1a, 0xd5, 0xd5, 0x33, 0x01, 0xd6, 0xd6, 0x33, 0x81, 0x0d, 0xd7, 0xd8, - 0x33, 0x01, 0xd8, 0xd9, 0x33, 0xc1, 0x00, 0xe1, 0xda, 0x33, 0x41, 0xe1, - 0xd7, 0x33, 0x41, 0xe1, 0xd3, 0x33, 0x01, 0xe2, 0xd4, 0x33, 0x41, 0x90, - 0x06, 0x4d, 0x05, 0x84, 0x46, 0x34, 0x41, 0x90, 0x5e, 0x91, 0x20, 0x92, - 0x01, 0xff, 0xd0, 0xc8, 0x33, 0x01, 0xd1, 0xc9, 0x33, 0x01, 0xd2, 0xca, - 0x33, 0x01, 0xd3, 0xcb, 0x33, 0x01, 0xd4, 0xcc, 0x33, 0x81, 0x04, 0xd5, - 0xce, 0x33, 0x41, 0xe1, 0xcd, 0x33, 0x41, 0xd0, 0xba, 0x33, 0x81, 0x33, - 0xd1, 0xbc, 0x33, 0x01, 0xd2, 0xbd, 0x33, 0x01, 0xd3, 0xbe, 0x33, 0x01, - 0xd4, 0xbf, 0x33, 0x81, 0x1e, 0xd5, 0xc1, 0x33, 0x01, 0xd6, 0xc2, 0x33, - 0x01, 0xd7, 0xc3, 0x33, 0x81, 0x0d, 0xd8, 0xc5, 0x33, 0x81, 0x04, 0xd9, - 0xc7, 0x33, 0x41, 0xe1, 0xc6, 0x33, 0x41, 0xe1, 0xc4, 0x33, 0x41, 0xe1, - 0xc0, 0x33, 0x41, 0xe1, 0xbb, 0x33, 0x41, 0xd1, 0xaf, 0x33, 0x01, 0xd2, - 0xb0, 0x33, 0x01, 0xd3, 0xb1, 0x33, 0x81, 0x1d, 0xd4, 0xb3, 0x33, 0x01, - 0xd5, 0xb4, 0x33, 0x01, 0xd6, 0xb5, 0x33, 0x01, 0xd7, 0xb6, 0x33, 0x01, - 0xd8, 0xb7, 0x33, 0x01, 0xd9, 0xb8, 0x33, 0xc1, 0x00, 0xe1, 0xb9, 0x33, - 0x41, 0xe1, 0xb2, 0x33, 0x41, 0x90, 0x06, 0x4e, 0xa6, 0x77, 0x30, 0x34, - 0x41, 0x90, 0xf8, 0x01, 0x91, 0xb3, 0x01, 0x92, 0x49, 0x93, 0x0b, 0x42, - 0x1f, 0xf5, 0xad, 0x33, 0xc1, 0x00, 0xe1, 0xae, 0x33, 0x41, 0xd0, 0x9f, - 0x33, 0x81, 0x33, 0xd1, 0xa1, 0x33, 0x81, 0x2a, 0xd2, 0xa3, 0x33, 0x01, - 0xd3, 0xa4, 0x33, 0x81, 0x1d, 0xd4, 0xa6, 0x33, 0x01, 0xd5, 0xa7, 0x33, - 0x01, 0xd6, 0xa8, 0x33, 0x01, 0xd7, 0xa9, 0x33, 0x81, 0x08, 0xd8, 0xab, - 0x33, 0x01, 0xd9, 0xac, 0x33, 0x41, 0xe1, 0xaa, 0x33, 0x41, 0xe1, 0xa5, - 0x33, 0x41, 0xe1, 0xa2, 0x33, 0x41, 0xe1, 0xa0, 0x33, 0x41, 0xd0, 0x86, - 0x33, 0x81, 0x33, 0xd1, 0x93, 0x33, 0x01, 0xd2, 0x94, 0x33, 0x01, 0xd3, - 0x95, 0x33, 0x81, 0x22, 0xd4, 0x97, 0x33, 0x01, 0xd5, 0x98, 0x33, 0x01, - 0xd6, 0x99, 0x33, 0x01, 0xd7, 0x9a, 0x33, 0x01, 0xd8, 0x9b, 0x33, 0x81, - 0x09, 0xd9, 0x9d, 0x33, 0xc1, 0x00, 0xe1, 0x9e, 0x33, 0x41, 0xe1, 0x9c, - 0x33, 0x41, 0xe1, 0x96, 0x33, 0x41, 0xe1, 0x87, 0x33, 0x01, 0xe2, 0x88, - 0x33, 0x01, 0xe3, 0x89, 0x33, 0x01, 0xe4, 0x8a, 0x33, 0x01, 0xe5, 0x8b, - 0x33, 0x01, 0xe6, 0x8c, 0x33, 0x01, 0xe7, 0x8d, 0x33, 0x01, 0xe8, 0x8e, - 0x33, 0x01, 0xe9, 0x8f, 0x33, 0x01, 0xea, 0x90, 0x33, 0x01, 0xeb, 0x91, - 0x33, 0x01, 0xec, 0x92, 0x33, 0x41, 0xd0, 0x77, 0x33, 0x01, 0xd1, 0x78, - 0x33, 0x81, 0x29, 0xd2, 0x7c, 0x33, 0x81, 0x1c, 0xd3, 0x7f, 0x33, 0x01, - 0xd4, 0x80, 0x33, 0x01, 0xd5, 0x81, 0x33, 0x01, 0xd6, 0x82, 0x33, 0x01, - 0xd7, 0x83, 0x33, 0x01, 0xd8, 0x84, 0x33, 0x01, 0xd9, 0x85, 0x33, 0x41, - 0xe1, 0x7d, 0x33, 0x01, 0xe2, 0x7e, 0x33, 0x41, 0xe1, 0x79, 0x33, 0x01, - 0xe2, 0x7a, 0x33, 0x01, 0xe3, 0x7b, 0x33, 0x01, 0xe4, 0x2f, 0x34, 0x41, - 0xd1, 0x62, 0x33, 0x81, 0x2e, 0xd2, 0x6c, 0x33, 0x81, 0x25, 0xd3, 0x6e, - 0x33, 0x01, 0xd4, 0x6f, 0x33, 0x01, 0xd5, 0x70, 0x33, 0x01, 0xd6, 0x71, - 0x33, 0x01, 0xd7, 0x72, 0x33, 0x81, 0x08, 0xd8, 0x75, 0x33, 0x01, 0xd9, - 0x76, 0x33, 0x41, 0xe1, 0x73, 0x33, 0x01, 0xe2, 0x74, 0x33, 0x41, 0xe1, - 0x6d, 0x33, 0x41, 0xe1, 0x63, 0x33, 0x01, 0xe2, 0x64, 0x33, 0x01, 0xe3, - 0x65, 0x33, 0x01, 0xe4, 0x66, 0x33, 0x01, 0xe5, 0x67, 0x33, 0x01, 0xe6, - 0x68, 0x33, 0x01, 0xe7, 0x69, 0x33, 0x01, 0xe8, 0x6a, 0x33, 0x01, 0xe9, - 0x6b, 0x33, 0x41, 0x90, 0x9c, 0x01, 0x91, 0x72, 0x92, 0x3e, 0x93, 0x0f, - 0x94, 0x01, 0xff, 0xd0, 0x5f, 0x33, 0x01, 0xd1, 0x60, 0x33, 0x01, 0xd2, - 0x61, 0x33, 0x41, 0xd0, 0x54, 0x33, 0x01, 0xd1, 0x55, 0x33, 0x01, 0xd2, - 0x56, 0x33, 0x81, 0x1c, 0xd3, 0x58, 0x33, 0x01, 0xd4, 0x59, 0x33, 0x01, - 0xd5, 0x5a, 0x33, 0x01, 0xd6, 0x5b, 0x33, 0x01, 0xd7, 0x5c, 0x33, 0x01, - 0xd8, 0x5d, 0x33, 0x01, 0xd9, 0x5e, 0x33, 0x41, 0xe1, 0x57, 0x33, 0x41, - 0xd0, 0x48, 0x33, 0x01, 0xd1, 0x49, 0x33, 0x01, 0xd2, 0x4a, 0x33, 0x01, - 0xd3, 0x4b, 0x33, 0x81, 0x1d, 0xd4, 0x4d, 0x33, 0x01, 0xd5, 0x4e, 0x33, - 0x01, 0xd6, 0x4f, 0x33, 0x01, 0xd7, 0x50, 0x33, 0x01, 0xd8, 0x51, 0x33, - 0x01, 0xd9, 0x52, 0x33, 0xc1, 0x00, 0xe1, 0x53, 0x33, 0x41, 0xe1, 0x4c, - 0x33, 0x41, 0xd0, 0x3e, 0x33, 0x01, 0xd1, 0x3f, 0x33, 0x01, 0xd2, 0x40, - 0x33, 0x01, 0xd3, 0x41, 0x33, 0x01, 0xd4, 0x42, 0x33, 0x01, 0xd5, 0x43, - 0x33, 0x01, 0xd6, 0x44, 0x33, 0x01, 0xd7, 0x45, 0x33, 0x01, 0xd8, 0x46, - 0x33, 0x01, 0xd9, 0x47, 0x33, 0x41, 0xd1, 0x33, 0x33, 0x01, 0xd2, 0x34, - 0x33, 0x01, 0xd3, 0x35, 0x33, 0x01, 0xd4, 0x36, 0x33, 0x01, 0xd5, 0x37, - 0x33, 0x01, 0xd6, 0x38, 0x33, 0x81, 0x0c, 0xd7, 0x3b, 0x33, 0x01, 0xd8, - 0x3c, 0x33, 0x01, 0xd9, 0x3d, 0x33, 0x41, 0xe1, 0x39, 0x33, 0x01, 0xe2, - 0x3a, 0x33, 0x41, 0x90, 0x06, 0x4d, 0x5d, 0x80, 0x45, 0x34, 0x41, 0x90, - 0x87, 0x01, 0x91, 0x53, 0x92, 0x29, 0x93, 0x01, 0xff, 0xd0, 0x2a, 0x33, - 0x01, 0xd1, 0x2b, 0x33, 0x01, 0xd2, 0x2c, 0x33, 0x81, 0x15, 0xd3, 0x2e, - 0x33, 0x81, 0x0c, 0xd4, 0x30, 0x33, 0x01, 0xd5, 0x31, 0x33, 0x01, 0xd6, - 0x32, 0x33, 0x41, 0xe1, 0x2f, 0x33, 0x41, 0xe1, 0x2d, 0x33, 0x41, 0xd0, - 0x20, 0x33, 0x01, 0xd1, 0x21, 0x33, 0x01, 0xd2, 0x22, 0x33, 0x01, 0xd3, - 0x23, 0x33, 0x01, 0xd4, 0x24, 0x33, 0x01, 0xd5, 0x25, 0x33, 0x01, 0xd6, - 0x26, 0x33, 0x01, 0xd7, 0x27, 0x33, 0x01, 0xd8, 0x28, 0x33, 0x01, 0xd9, - 0x29, 0x33, 0x41, 0xd0, 0x14, 0x33, 0x01, 0xd1, 0x15, 0x33, 0x81, 0x25, - 0xd2, 0x17, 0x33, 0x01, 0xd3, 0x18, 0x33, 0x01, 0xd4, 0x19, 0x33, 0x01, - 0xd5, 0x1a, 0x33, 0x01, 0xd6, 0x1b, 0x33, 0x81, 0x0c, 0xd7, 0x1d, 0x33, - 0x01, 0xd8, 0x1e, 0x33, 0x01, 0xd9, 0x1f, 0x33, 0x41, 0xe1, 0x1c, 0x33, - 0x41, 0xe1, 0x16, 0x33, 0x41, 0xd1, 0x07, 0x33, 0x01, 0xd2, 0x08, 0x33, - 0x01, 0xd3, 0x09, 0x33, 0x81, 0x27, 0xd4, 0x0b, 0x33, 0x01, 0xd5, 0x0c, - 0x33, 0x01, 0xd6, 0x0d, 0x33, 0x01, 0xd7, 0x0e, 0x33, 0x81, 0x12, 0xd8, - 0x10, 0x33, 0x81, 0x09, 0xd9, 0x12, 0x33, 0xc1, 0x00, 0xe1, 0x13, 0x33, - 0x41, 0xe1, 0x11, 0x33, 0x41, 0xe1, 0x0f, 0x33, 0x41, 0xe1, 0x0a, 0x33, - 0x41, 0x90, 0xba, 0x01, 0x91, 0x81, 0x01, 0x92, 0x4e, 0x93, 0x1f, 0x94, - 0x01, 0xff, 0xd0, 0x00, 0x33, 0x01, 0xd1, 0x01, 0x33, 0x01, 0xd2, 0x02, - 0x33, 0x01, 0xd3, 0x03, 0x33, 0x01, 0xd4, 0x04, 0x33, 0x01, 0xd5, 0x05, - 0x33, 0x01, 0xd6, 0x06, 0x33, 0x41, 0xd0, 0xf5, 0x32, 0x01, 0xd1, 0xf6, - 0x32, 0x01, 0xd2, 0xf7, 0x32, 0x01, 0xd3, 0xf8, 0x32, 0x01, 0xd4, 0xf9, - 0x32, 0x01, 0xd5, 0xfa, 0x32, 0x81, 0x10, 0xd6, 0xfc, 0x32, 0x01, 0xd7, - 0xfd, 0x32, 0x01, 0xd8, 0xfe, 0x32, 0x01, 0xd9, 0xff, 0x32, 0x41, 0xe1, - 0xfb, 0x32, 0x41, 0xd0, 0xe9, 0x32, 0x01, 0xd1, 0xea, 0x32, 0x01, 0xd2, - 0xeb, 0x32, 0x01, 0xd3, 0xec, 0x32, 0x01, 0xd4, 0xed, 0x32, 0x01, 0xd5, - 0xee, 0x32, 0x01, 0xd6, 0xef, 0x32, 0x81, 0x0c, 0xd7, 0xf2, 0x32, 0x01, - 0xd8, 0xf3, 0x32, 0x01, 0xd9, 0xf4, 0x32, 0x41, 0xe1, 0xf0, 0x32, 0x01, - 0xe2, 0xf1, 0x32, 0x41, 0xd0, 0xdc, 0x32, 0x01, 0xd1, 0xdd, 0x32, 0x01, - 0xd2, 0xde, 0x32, 0x01, 0xd3, 0xdf, 0x32, 0x01, 0xd4, 0xe0, 0x32, 0x81, - 0x19, 0xd5, 0xe3, 0x32, 0x01, 0xd6, 0xe4, 0x32, 0x01, 0xd7, 0xe5, 0x32, - 0x81, 0x08, 0xd8, 0xe7, 0x32, 0x01, 0xd9, 0xe8, 0x32, 0x41, 0xe1, 0xe6, - 0x32, 0x41, 0xe1, 0xe1, 0x32, 0x01, 0xe2, 0xe2, 0x32, 0x41, 0xd1, 0xd1, - 0x32, 0x01, 0xd2, 0xd2, 0x32, 0x81, 0x21, 0xd3, 0xd4, 0x32, 0x01, 0xd4, - 0xd5, 0x32, 0x01, 0xd5, 0xd6, 0x32, 0x01, 0xd6, 0xd7, 0x32, 0x81, 0x0c, - 0xd7, 0xd9, 0x32, 0x01, 0xd8, 0xda, 0x32, 0x01, 0xd9, 0xdb, 0x32, 0x41, - 0xe1, 0xd8, 0x32, 0x41, 0xe1, 0xd3, 0x32, 0x41, 0x90, 0x5f, 0x91, 0x2b, - 0x92, 0x01, 0xff, 0xd0, 0xc7, 0x32, 0x01, 0xd1, 0xc8, 0x32, 0x01, 0xd2, - 0xc9, 0x32, 0x01, 0xd3, 0xca, 0x32, 0x01, 0xd4, 0xcb, 0x32, 0x01, 0xd5, - 0xcc, 0x32, 0x01, 0xd6, 0xcd, 0x32, 0x01, 0xd7, 0xce, 0x32, 0x01, 0xd8, - 0xcf, 0x32, 0x01, 0xd9, 0xd0, 0x32, 0x41, 0xd0, 0xbb, 0x32, 0x81, 0x29, - 0xd1, 0xbd, 0x32, 0x01, 0xd2, 0xbe, 0x32, 0x01, 0xd3, 0xbf, 0x32, 0x01, - 0xd4, 0xc0, 0x32, 0x01, 0xd5, 0xc1, 0x32, 0x01, 0xd6, 0xc2, 0x32, 0x81, - 0x0c, 0xd7, 0xc4, 0x32, 0x01, 0xd8, 0xc5, 0x32, 0x01, 0xd9, 0xc6, 0x32, - 0x41, 0xe1, 0xc3, 0x32, 0x41, 0xe1, 0xbc, 0x32, 0x41, 0xd1, 0xaf, 0x32, - 0x01, 0xd2, 0xb0, 0x32, 0x81, 0x25, 0xd3, 0xb2, 0x32, 0x81, 0x18, 0xd4, - 0xb5, 0x32, 0x01, 0xd5, 0xb6, 0x32, 0x01, 0xd6, 0xb7, 0x32, 0x01, 0xd7, - 0xb8, 0x32, 0x01, 0xd8, 0xb9, 0x32, 0x01, 0xd9, 0xba, 0x32, 0x41, 0xe1, - 0xb3, 0x32, 0x01, 0xe2, 0xb4, 0x32, 0x41, 0xe1, 0xb1, 0x32, 0x41, 0xd1, - 0xa8, 0x32, 0x01, 0xd2, 0xa9, 0x32, 0x01, 0xd3, 0xaa, 0x32, 0x01, 0xd4, - 0xab, 0x32, 0x01, 0xd5, 0xac, 0x32, 0x01, 0xd6, 0xad, 0x32, 0x01, 0xd7, - 0xae, 0x32, 0x41, 0x90, 0x0b, 0x91, 0x01, 0xff, 0xd0, 0xa6, 0x32, 0x01, - 0xd1, 0xa7, 0x32, 0x41, 0xd1, 0x9b, 0x32, 0x81, 0x25, 0xd2, 0x9d, 0x32, - 0x01, 0xd3, 0x9e, 0x32, 0x81, 0x18, 0xd4, 0xa0, 0x32, 0x01, 0xd5, 0xa1, - 0x32, 0x01, 0xd6, 0xa2, 0x32, 0x01, 0xd7, 0xa3, 0x32, 0x01, 0xd8, 0xa4, - 0x32, 0x01, 0xd9, 0xa5, 0x32, 0x41, 0xe1, 0x9f, 0x32, 0x41, 0xe1, 0x9c, - 0x32, 0x41, 0x90, 0x06, 0x4d, 0x2a, 0x8a, 0x36, 0x34, 0x41, 0x90, 0xff, - 0x01, 0x91, 0xc2, 0x01, 0x92, 0x83, 0x01, 0x93, 0x3e, 0x94, 0x14, 0x95, - 0x01, 0xff, 0xd0, 0x97, 0x32, 0x81, 0x04, 0xd1, 0x9a, 0x32, 0x41, 0xe1, - 0x98, 0x32, 0x01, 0xe2, 0x99, 0x32, 0x41, 0xd0, 0x8d, 0x32, 0x01, 0xd1, - 0x8e, 0x32, 0x01, 0xd2, 0x8f, 0x32, 0x01, 0xd3, 0x90, 0x32, 0x01, 0xd4, - 0x91, 0x32, 0x01, 0xd5, 0x92, 0x32, 0x01, 0xd6, 0x93, 0x32, 0x01, 0xd7, - 0x94, 0x32, 0x01, 0xd8, 0x95, 0x32, 0x01, 0xd9, 0x96, 0x32, 0x41, 0xd0, - 0x7d, 0x32, 0x81, 0x3a, 0xd1, 0x7f, 0x32, 0x01, 0xd2, 0x80, 0x32, 0x01, - 0xd3, 0x81, 0x32, 0x81, 0x29, 0xd4, 0x83, 0x32, 0x01, 0xd5, 0x84, 0x32, - 0x01, 0xd6, 0x85, 0x32, 0x81, 0x0c, 0xd7, 0x8a, 0x32, 0x01, 0xd8, 0x8b, - 0x32, 0x01, 0xd9, 0x8c, 0x32, 0x41, 0xe1, 0x86, 0x32, 0x01, 0xe2, 0x87, - 0x32, 0x01, 0xe3, 0x88, 0x32, 0x01, 0xe4, 0x89, 0x32, 0x41, 0xe1, 0x82, - 0x32, 0x41, 0xe1, 0x7e, 0x32, 0x41, 0xd0, 0x6f, 0x32, 0x81, 0x33, 0xd1, - 0x71, 0x32, 0x01, 0xd2, 0x72, 0x32, 0x01, 0xd3, 0x73, 0x32, 0x01, 0xd4, - 0x74, 0x32, 0x81, 0x1e, 0xd5, 0x76, 0x32, 0x81, 0x15, 0xd6, 0x78, 0x32, - 0x01, 0xd7, 0x79, 0x32, 0x01, 0xd8, 0x7a, 0x32, 0x01, 0xd9, 0x7b, 0x32, - 0xc1, 0x00, 0xe1, 0x7c, 0x32, 0x41, 0xe1, 0x77, 0x32, 0x41, 0xe1, 0x75, - 0x32, 0x41, 0xe1, 0x70, 0x32, 0x41, 0xd0, 0x61, 0x32, 0x81, 0x29, 0xd1, - 0x65, 0x32, 0x01, 0xd2, 0x66, 0x32, 0x01, 0xd3, 0x67, 0x32, 0x01, 0xd4, - 0x68, 0x32, 0x01, 0xd5, 0x69, 0x32, 0x01, 0xd6, 0x6a, 0x32, 0x01, 0xd7, - 0x6b, 0x32, 0x01, 0xd8, 0x6c, 0x32, 0x01, 0xd9, 0x6d, 0x32, 0xc1, 0x00, - 0xe1, 0x6e, 0x32, 0x41, 0xe1, 0x62, 0x32, 0x01, 0xe2, 0x63, 0x32, 0x01, - 0xe3, 0x64, 0x32, 0x41, 0xd1, 0x50, 0x32, 0x81, 0x3e, 0xd2, 0x52, 0x32, - 0x01, 0xd3, 0x53, 0x32, 0x01, 0xd4, 0x54, 0x32, 0x01, 0xd5, 0x55, 0x32, - 0x81, 0x29, 0xd6, 0x57, 0x32, 0x81, 0x0c, 0xd7, 0x5e, 0x32, 0x01, 0xd8, - 0x5f, 0x32, 0x01, 0xd9, 0x60, 0x32, 0x41, 0xe1, 0x58, 0x32, 0x01, 0xe2, - 0x59, 0x32, 0x01, 0xe3, 0x5a, 0x32, 0x01, 0xe4, 0x5b, 0x32, 0x01, 0xe5, - 0x5c, 0x32, 0x01, 0xe6, 0x5d, 0x32, 0x41, 0xe1, 0x56, 0x32, 0x41, 0xe1, - 0x51, 0x32, 0x41, 0x90, 0xdc, 0x01, 0x02, 0x9c, 0x98, 0x78, 0x02, 0x00, - 0xed, 0x01, 0xff, 0x90, 0x4d, 0x91, 0x14, 0x92, 0x01, 0xff, 0xd0, 0x4c, - 0x32, 0x01, 0xd1, 0x4d, 0x32, 0x01, 0xd2, 0x4e, 0x32, 0xc1, 0x00, 0xe1, - 0x4f, 0x32, 0x41, 0xd0, 0x3f, 0x32, 0x81, 0x2e, 0xd1, 0x41, 0x32, 0x81, - 0x25, 0xd2, 0x43, 0x32, 0x01, 0xd3, 0x44, 0x32, 0x01, 0xd4, 0x45, 0x32, - 0x01, 0xd5, 0x46, 0x32, 0x01, 0xd6, 0x47, 0x32, 0x01, 0xd7, 0x48, 0x32, - 0x01, 0xd8, 0x49, 0x32, 0x81, 0x04, 0xd9, 0x4b, 0x32, 0x41, 0xe1, 0x4a, - 0x32, 0x41, 0xe1, 0x42, 0x32, 0x41, 0xe1, 0x40, 0x32, 0x41, 0xd1, 0x36, - 0x32, 0x01, 0xd2, 0x37, 0x32, 0x01, 0xd3, 0x38, 0x32, 0x01, 0xd4, 0x39, - 0x32, 0x01, 0xd5, 0x3a, 0x32, 0x01, 0xd6, 0x3b, 0x32, 0x01, 0xd7, 0x3c, - 0x32, 0x01, 0xd8, 0x3d, 0x32, 0x01, 0xd9, 0x3e, 0x32, 0x41, 0x90, 0x35, - 0x91, 0x06, 0x42, 0xe0, 0xe7, 0x35, 0x32, 0x41, 0xd0, 0x2a, 0x32, 0x01, - 0xd1, 0x2b, 0x32, 0x01, 0xd2, 0x2c, 0x32, 0x01, 0xd3, 0x2d, 0x32, 0x01, - 0xd4, 0x2e, 0x32, 0x01, 0xd5, 0x2f, 0x32, 0x01, 0xd6, 0x30, 0x32, 0x01, - 0xd7, 0x31, 0x32, 0x81, 0x08, 0xd8, 0x33, 0x32, 0x01, 0xd9, 0x34, 0x32, - 0x41, 0xe1, 0x32, 0x32, 0x41, 0xd1, 0x20, 0x32, 0x01, 0xd2, 0x21, 0x32, - 0x01, 0xd3, 0x22, 0x32, 0x01, 0xd4, 0x23, 0x32, 0x01, 0xd5, 0x24, 0x32, - 0x81, 0x10, 0xd6, 0x26, 0x32, 0x01, 0xd7, 0x27, 0x32, 0x01, 0xd8, 0x28, - 0x32, 0x01, 0xd9, 0x29, 0x32, 0x41, 0xe1, 0x25, 0x32, 0x41, 0x90, 0xaf, - 0x01, 0x91, 0x7c, 0x92, 0x4d, 0x93, 0x0f, 0x94, 0x01, 0xff, 0xd0, 0x1d, - 0x32, 0x01, 0xd1, 0x1e, 0x32, 0x01, 0xd2, 0x1f, 0x32, 0x41, 0xd0, 0x0f, - 0x32, 0x01, 0xd1, 0x10, 0x32, 0x01, 0xd2, 0x11, 0x32, 0x01, 0xd3, 0x12, - 0x32, 0x81, 0x27, 0xd4, 0x14, 0x32, 0x81, 0x1e, 0xd5, 0x16, 0x32, 0x81, - 0x15, 0xd6, 0x18, 0x32, 0x01, 0xd7, 0x19, 0x32, 0x81, 0x08, 0xd8, 0x1b, - 0x32, 0x01, 0xd9, 0x1c, 0x32, 0x41, 0xe1, 0x1a, 0x32, 0x41, 0xe1, 0x17, - 0x32, 0x41, 0xe1, 0x15, 0x32, 0x41, 0xe1, 0x13, 0x32, 0x41, 0xd0, 0x04, - 0x32, 0x01, 0xd1, 0x05, 0x32, 0x01, 0xd2, 0x06, 0x32, 0x01, 0xd3, 0x07, - 0x32, 0x01, 0xd4, 0x08, 0x32, 0x01, 0xd5, 0x09, 0x32, 0x81, 0x10, 0xd6, - 0x0b, 0x32, 0x01, 0xd7, 0x0c, 0x32, 0x01, 0xd8, 0x0d, 0x32, 0x01, 0xd9, - 0x0e, 0x32, 0x41, 0xe1, 0x0a, 0x32, 0x41, 0xd0, 0xf8, 0x31, 0x01, 0xd1, - 0xf9, 0x31, 0x01, 0xd2, 0xfa, 0x31, 0x01, 0xd3, 0xfb, 0x31, 0x01, 0xd4, - 0xfc, 0x31, 0x01, 0xd5, 0xfd, 0x31, 0x01, 0xd6, 0xfe, 0x31, 0x01, 0xd7, - 0xff, 0x31, 0x01, 0xd8, 0x00, 0x32, 0x81, 0x04, 0xd9, 0x03, 0x32, 0x41, - 0xe1, 0x01, 0x32, 0x01, 0xe2, 0x02, 0x32, 0x41, 0xd1, 0xef, 0x31, 0x01, - 0xd2, 0xf0, 0x31, 0x01, 0xd3, 0xf1, 0x31, 0x01, 0xd4, 0xf2, 0x31, 0x01, - 0xd5, 0xf3, 0x31, 0x01, 0xd6, 0xf4, 0x31, 0x01, 0xd7, 0xf5, 0x31, 0x01, - 0xd8, 0xf6, 0x31, 0x01, 0xd9, 0xf7, 0x31, 0x41, 0x90, 0x76, 0x52, 0xe2, - 0x52, 0x40, 0x34, 0x01, 0x4f, 0xf6, 0x70, 0x55, 0x34, 0xc1, 0x00, 0x04, - 0x3c, 0x05, 0x01, 0xff, 0x46, 0xb5, 0x0a, 0x50, 0x34, 0x81, 0x41, 0x43, - 0x40, 0x05, 0x52, 0x34, 0x01, 0x45, 0x2f, 0xeb, 0x49, 0x34, 0x81, 0x23, - 0x43, 0x1e, 0x00, 0x4b, 0x34, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x47, 0xe3, - 0xce, 0x53, 0x34, 0x01, 0x43, 0x40, 0x05, 0x4a, 0x34, 0x01, 0x45, 0x2f, - 0xeb, 0x47, 0x34, 0xc1, 0x00, 0x4f, 0x1c, 0x69, 0x4f, 0x34, 0x41, 0x05, - 0x19, 0x00, 0x01, 0xff, 0x46, 0xb5, 0x0a, 0x51, 0x34, 0x01, 0x43, 0x1e, - 0x00, 0x4d, 0x34, 0x41, 0x80, 0x01, 0xff, 0x47, 0xe3, 0xce, 0x54, 0x34, - 0x01, 0x43, 0x40, 0x05, 0x4e, 0x34, 0x01, 0x45, 0x2f, 0xeb, 0x48, 0x34, - 0xc1, 0x00, 0x4c, 0x20, 0x8b, 0x4c, 0x34, 0x41, 0x90, 0xed, 0x01, 0x91, - 0x8d, 0x01, 0x92, 0x54, 0x93, 0x1c, 0x94, 0x01, 0xff, 0xd0, 0xe9, 0x31, - 0x81, 0x10, 0xd1, 0xeb, 0x31, 0x01, 0xd2, 0xec, 0x31, 0x01, 0xd3, 0xed, - 0x31, 0x01, 0xd4, 0xee, 0x31, 0x41, 0xe1, 0xea, 0x31, 0x41, 0xd0, 0xdc, - 0x31, 0x01, 0xd1, 0xdd, 0x31, 0x81, 0x29, 0xd2, 0xdf, 0x31, 0x01, 0xd3, - 0xe0, 0x31, 0x81, 0x18, 0xd4, 0xe3, 0x31, 0x01, 0xd5, 0xe4, 0x31, 0x01, - 0xd6, 0xe5, 0x31, 0x01, 0xd7, 0xe6, 0x31, 0x01, 0xd8, 0xe7, 0x31, 0x01, - 0xd9, 0xe8, 0x31, 0x41, 0xe1, 0xe1, 0x31, 0x01, 0xe2, 0xe2, 0x31, 0x41, - 0xe1, 0xde, 0x31, 0x41, 0xd0, 0xcf, 0x31, 0x01, 0xd1, 0xd0, 0x31, 0x01, - 0xd2, 0xd1, 0x31, 0x81, 0x26, 0xd3, 0xd3, 0x31, 0x01, 0xd4, 0xd4, 0x31, - 0x81, 0x19, 0xd5, 0xd6, 0x31, 0x01, 0xd6, 0xd7, 0x31, 0x01, 0xd7, 0xd8, - 0x31, 0x01, 0xd8, 0xd9, 0x31, 0x81, 0x04, 0xd9, 0xdb, 0x31, 0x41, 0xe1, - 0xda, 0x31, 0x41, 0xe1, 0xd5, 0x31, 0x41, 0xe1, 0xd2, 0x31, 0x41, 0xd0, - 0xb9, 0x31, 0x81, 0x54, 0xd1, 0xbb, 0x31, 0x01, 0xd2, 0xbc, 0x31, 0x81, - 0x2b, 0xd3, 0xc5, 0x31, 0x01, 0xd4, 0xc6, 0x31, 0x01, 0xd5, 0xc7, 0x31, - 0x81, 0x1a, 0xd6, 0xc9, 0x31, 0x81, 0x11, 0xd7, 0xcb, 0x31, 0x81, 0x08, - 0xd8, 0xcd, 0x31, 0x01, 0xd9, 0xce, 0x31, 0x41, 0xe1, 0xcc, 0x31, 0x41, - 0xe1, 0xca, 0x31, 0x41, 0xe1, 0xc8, 0x31, 0x41, 0xe1, 0xbd, 0x31, 0x01, - 0xe2, 0xbe, 0x31, 0x01, 0xe3, 0xbf, 0x31, 0x01, 0xe4, 0xc0, 0x31, 0x01, - 0xe5, 0xc1, 0x31, 0x01, 0xe6, 0xc2, 0x31, 0x01, 0xe7, 0xc3, 0x31, 0x01, - 0xe8, 0xc4, 0x31, 0x41, 0xe1, 0xba, 0x31, 0x41, 0xd1, 0xad, 0x31, 0x81, - 0x25, 0xd2, 0xb0, 0x31, 0x01, 0xd3, 0xb1, 0x31, 0x81, 0x18, 0xd4, 0xb3, - 0x31, 0x01, 0xd5, 0xb4, 0x31, 0x01, 0xd6, 0xb5, 0x31, 0x01, 0xd7, 0xb6, - 0x31, 0x01, 0xd8, 0xb7, 0x31, 0x01, 0xd9, 0xb8, 0x31, 0x41, 0xe1, 0xb2, - 0x31, 0x41, 0xe1, 0xae, 0x31, 0x01, 0xe2, 0xaf, 0x31, 0x41, 0x02, 0xaa, - 0xd8, 0x06, 0x48, 0x62, 0x80, 0x43, 0x34, 0x41, 0xd1, 0xa3, 0x31, 0x01, - 0xd2, 0xa4, 0x31, 0x81, 0x1d, 0xd3, 0xa6, 0x31, 0x01, 0xd4, 0xa7, 0x31, - 0x01, 0xd5, 0xa8, 0x31, 0x01, 0xd6, 0xa9, 0x31, 0x81, 0x08, 0xd7, 0xab, - 0x31, 0x01, 0xd8, 0xac, 0x31, 0x41, 0xe1, 0xaa, 0x31, 0x41, 0xe1, 0xa5, - 0x31, 0x41, 0xd1, 0x9b, 0x31, 0x01, 0xd2, 0x9c, 0x31, 0x01, 0xd3, 0x9d, - 0x31, 0x01, 0xd4, 0x9e, 0x31, 0x01, 0xd5, 0x9f, 0x31, 0x01, 0xd6, 0xa0, - 0x31, 0x01, 0xd7, 0xa1, 0x31, 0x01, 0xd8, 0xa2, 0x31, 0x41, 0x90, 0x37, - 0x09, 0xba, 0xbc, 0x01, 0xff, 0x46, 0xb5, 0x0a, 0x3b, 0x34, 0x81, 0x1c, - 0x46, 0x7d, 0x02, 0x39, 0x34, 0x01, 0x43, 0x1e, 0x00, 0x3a, 0x34, 0xc1, - 0x00, 0x80, 0x01, 0xff, 0x43, 0x40, 0x05, 0x34, 0x34, 0x01, 0x45, 0x2f, - 0xeb, 0x32, 0x34, 0x41, 0x80, 0x01, 0xff, 0x43, 0x40, 0x05, 0x35, 0x34, - 0x01, 0x45, 0x2f, 0xeb, 0x33, 0x34, 0x41, 0x90, 0x25, 0x91, 0x01, 0xff, - 0xd0, 0x93, 0x31, 0x81, 0x19, 0xd1, 0x95, 0x31, 0x81, 0x10, 0xd2, 0x97, - 0x31, 0x01, 0xd3, 0x98, 0x31, 0x01, 0xd4, 0x99, 0x31, 0x01, 0xd5, 0x9a, - 0x31, 0x41, 0xe1, 0x96, 0x31, 0x41, 0xe1, 0x94, 0x31, 0x41, 0xd1, 0x88, - 0x31, 0x01, 0xd2, 0x89, 0x31, 0x01, 0xd3, 0x8a, 0x31, 0x01, 0xd4, 0x8b, - 0x31, 0x01, 0xd5, 0x8c, 0x31, 0x81, 0x15, 0xd6, 0x8e, 0x31, 0x01, 0xd7, - 0x8f, 0x31, 0x01, 0xd8, 0x90, 0x31, 0x01, 0xd9, 0x91, 0x31, 0xc1, 0x00, - 0xe1, 0x92, 0x31, 0x41, 0xe1, 0x8d, 0x31, 0x41, 0x02, 0xaa, 0xd8, 0x16, - 0x04, 0x23, 0x00, 0x06, 0x50, 0xad, 0x65, 0x31, 0x34, 0x41, 0x45, 0x66, - 0xc0, 0x42, 0x34, 0x01, 0x49, 0x61, 0x80, 0x44, 0x34, 0x41, 0xd1, 0x7f, - 0x31, 0x01, 0xd2, 0x80, 0x31, 0x01, 0xd3, 0x81, 0x31, 0x01, 0xd4, 0x82, - 0x31, 0x01, 0xd5, 0x83, 0x31, 0x01, 0xd6, 0x84, 0x31, 0x81, 0x08, 0xd7, - 0x86, 0x31, 0x01, 0xd8, 0x87, 0x31, 0x41, 0xe1, 0x85, 0x31, 0x41, 0x90, - 0xe3, 0x01, 0x91, 0xb3, 0x01, 0x92, 0x7f, 0x93, 0x4b, 0x94, 0x17, 0x95, - 0x01, 0xff, 0xd0, 0x7a, 0x31, 0x01, 0xd1, 0x7b, 0x31, 0x01, 0xd2, 0x7c, - 0x31, 0x01, 0xd3, 0x7d, 0x31, 0x01, 0xd4, 0x7e, 0x31, 0x41, 0xd0, 0x6e, - 0x31, 0x01, 0xd1, 0x6f, 0x31, 0x01, 0xd2, 0x70, 0x31, 0x01, 0xd3, 0x71, - 0x31, 0x81, 0x1d, 0xd4, 0x73, 0x31, 0x01, 0xd5, 0x74, 0x31, 0x81, 0x10, - 0xd6, 0x76, 0x31, 0x01, 0xd7, 0x77, 0x31, 0x01, 0xd8, 0x78, 0x31, 0x01, - 0xd9, 0x79, 0x31, 0x41, 0xe1, 0x75, 0x31, 0x41, 0xe1, 0x72, 0x31, 0x41, - 0xd0, 0x62, 0x31, 0x01, 0xd1, 0x63, 0x31, 0x01, 0xd2, 0x64, 0x31, 0x01, - 0xd3, 0x65, 0x31, 0x01, 0xd4, 0x66, 0x31, 0x01, 0xd5, 0x67, 0x31, 0x01, - 0xd6, 0x68, 0x31, 0x81, 0x11, 0xd7, 0x6a, 0x31, 0x81, 0x08, 0xd8, 0x6c, - 0x31, 0x01, 0xd9, 0x6d, 0x31, 0x41, 0xe1, 0x6b, 0x31, 0x41, 0xe1, 0x69, - 0x31, 0x41, 0xd0, 0x56, 0x31, 0x81, 0x29, 0xd1, 0x58, 0x31, 0x01, 0xd2, - 0x59, 0x31, 0x01, 0xd3, 0x5a, 0x31, 0x01, 0xd4, 0x5b, 0x31, 0x01, 0xd5, - 0x5c, 0x31, 0x01, 0xd6, 0x5d, 0x31, 0x81, 0x0c, 0xd7, 0x5f, 0x31, 0x01, - 0xd8, 0x60, 0x31, 0x01, 0xd9, 0x61, 0x31, 0x41, 0xe1, 0x5e, 0x31, 0x41, - 0xe1, 0x57, 0x31, 0x41, 0xd0, 0x4b, 0x31, 0x01, 0xd1, 0x4c, 0x31, 0x81, - 0x20, 0xd2, 0x4e, 0x31, 0x01, 0xd3, 0x4f, 0x31, 0x01, 0xd4, 0x50, 0x31, - 0x01, 0xd5, 0x51, 0x31, 0x01, 0xd6, 0x52, 0x31, 0x01, 0xd7, 0x53, 0x31, - 0x01, 0xd8, 0x54, 0x31, 0x01, 0xd9, 0x55, 0x31, 0x41, 0xe1, 0x4d, 0x31, - 0x41, 0xd1, 0x3f, 0x31, 0x01, 0xd2, 0x40, 0x31, 0x01, 0xd3, 0x41, 0x31, - 0x01, 0xd4, 0x42, 0x31, 0x01, 0xd5, 0x43, 0x31, 0x01, 0xd6, 0x44, 0x31, - 0x81, 0x15, 0xd7, 0x46, 0x31, 0x81, 0x08, 0xd8, 0x49, 0x31, 0x01, 0xd9, - 0x4a, 0x31, 0x41, 0xe1, 0x47, 0x31, 0x01, 0xe2, 0x48, 0x31, 0x41, 0xe1, - 0x45, 0x31, 0x41, 0x90, 0x06, 0x49, 0x62, 0xc0, 0x41, 0x34, 0x41, 0x90, - 0xf2, 0x01, 0x91, 0xc2, 0x01, 0x92, 0x92, 0x01, 0x93, 0x59, 0x94, 0x20, - 0x95, 0x01, 0xff, 0xd0, 0x38, 0x31, 0x01, 0xd1, 0x39, 0x31, 0x81, 0x08, - 0xd2, 0x3d, 0x31, 0x01, 0xd3, 0x3e, 0x31, 0x41, 0xe1, 0x3a, 0x31, 0x01, - 0xe2, 0x3b, 0x31, 0x01, 0xe3, 0x3c, 0x31, 0x41, 0xd0, 0x2b, 0x31, 0x01, - 0xd1, 0x2c, 0x31, 0x01, 0xd2, 0x2d, 0x31, 0x01, 0xd3, 0x2e, 0x31, 0x01, - 0xd4, 0x2f, 0x31, 0x01, 0xd5, 0x30, 0x31, 0x81, 0x1a, 0xd6, 0x32, 0x31, - 0x81, 0x11, 0xd7, 0x34, 0x31, 0x81, 0x08, 0xd8, 0x36, 0x31, 0x01, 0xd9, - 0x37, 0x31, 0x41, 0xe1, 0x35, 0x31, 0x41, 0xe1, 0x33, 0x31, 0x41, 0xe1, - 0x31, 0x31, 0x41, 0xd0, 0x1e, 0x31, 0x01, 0xd1, 0x1f, 0x31, 0x81, 0x2a, - 0xd2, 0x21, 0x31, 0x01, 0xd3, 0x22, 0x31, 0x01, 0xd4, 0x23, 0x31, 0x01, - 0xd5, 0x24, 0x31, 0x01, 0xd6, 0x25, 0x31, 0x01, 0xd7, 0x26, 0x31, 0x81, - 0x0d, 0xd8, 0x28, 0x31, 0x81, 0x04, 0xd9, 0x2a, 0x31, 0x41, 0xe1, 0x29, - 0x31, 0x41, 0xe1, 0x27, 0x31, 0x41, 0xe1, 0x20, 0x31, 0x41, 0xd0, 0x13, - 0x31, 0x01, 0xd1, 0x14, 0x31, 0x81, 0x20, 0xd2, 0x16, 0x31, 0x01, 0xd3, - 0x17, 0x31, 0x01, 0xd4, 0x18, 0x31, 0x01, 0xd5, 0x19, 0x31, 0x01, 0xd6, - 0x1a, 0x31, 0x01, 0xd7, 0x1b, 0x31, 0x01, 0xd8, 0x1c, 0x31, 0x01, 0xd9, - 0x1d, 0x31, 0x41, 0xe1, 0x15, 0x31, 0x41, 0xd0, 0x08, 0x31, 0x01, 0xd1, - 0x09, 0x31, 0x01, 0xd2, 0x0a, 0x31, 0x01, 0xd3, 0x0b, 0x31, 0x81, 0x18, - 0xd4, 0x0d, 0x31, 0x01, 0xd5, 0x0e, 0x31, 0x01, 0xd6, 0x0f, 0x31, 0x01, - 0xd7, 0x10, 0x31, 0x01, 0xd8, 0x11, 0x31, 0x01, 0xd9, 0x12, 0x31, 0x41, - 0xe1, 0x0c, 0x31, 0x41, 0xd1, 0xfe, 0x30, 0x81, 0x20, 0xd2, 0x00, 0x31, - 0x01, 0xd3, 0x01, 0x31, 0x01, 0xd4, 0x02, 0x31, 0x01, 0xd5, 0x03, 0x31, - 0x01, 0xd6, 0x04, 0x31, 0x01, 0xd7, 0x05, 0x31, 0x01, 0xd8, 0x06, 0x31, - 0x01, 0xd9, 0x07, 0x31, 0x41, 0xe1, 0xff, 0x30, 0x41, 0x90, 0x17, 0x03, - 0x1b, 0x00, 0x01, 0xff, 0x49, 0xa4, 0x68, 0x3d, 0x34, 0x01, 0x47, 0x21, - 0x30, 0x38, 0x34, 0x01, 0x50, 0x9d, 0x68, 0x3f, 0x34, 0x41, 0x90, 0x90, - 0x01, 0x91, 0x5c, 0x92, 0x28, 0x93, 0x01, 0xff, 0xd0, 0xf5, 0x30, 0x01, - 0xd1, 0xf6, 0x30, 0x01, 0xd2, 0xf7, 0x30, 0x01, 0xd3, 0xf8, 0x30, 0x01, - 0xd4, 0xf9, 0x30, 0x81, 0x0c, 0xd6, 0xfb, 0x30, 0x01, 0xd7, 0xfc, 0x30, - 0x01, 0xd8, 0xfd, 0x30, 0x41, 0xe1, 0xfa, 0x30, 0x41, 0xd0, 0xe9, 0x30, - 0x81, 0x29, 0xd1, 0xeb, 0x30, 0x01, 0xd2, 0xec, 0x30, 0x01, 0xd3, 0xed, - 0x30, 0x01, 0xd4, 0xee, 0x30, 0x01, 0xd5, 0xef, 0x30, 0x01, 0xd6, 0xf0, - 0x30, 0x01, 0xd7, 0xf1, 0x30, 0x01, 0xd8, 0xf2, 0x30, 0x81, 0x04, 0xd9, - 0xf4, 0x30, 0x41, 0xe1, 0xf3, 0x30, 0x41, 0xe1, 0xea, 0x30, 0x41, 0xd0, - 0xdd, 0x30, 0x01, 0xd1, 0xde, 0x30, 0x01, 0xd2, 0xdf, 0x30, 0x01, 0xd3, - 0xe0, 0x30, 0x01, 0xd4, 0xe1, 0x30, 0x01, 0xd5, 0xe2, 0x30, 0x01, 0xd6, - 0xe3, 0x30, 0x81, 0x11, 0xd7, 0xe5, 0x30, 0x81, 0x08, 0xd8, 0xe7, 0x30, - 0x01, 0xd9, 0xe8, 0x30, 0x41, 0xe1, 0xe6, 0x30, 0x41, 0xe1, 0xe4, 0x30, - 0x41, 0xd1, 0xd2, 0x30, 0x01, 0xd2, 0xd3, 0x30, 0x01, 0xd3, 0xd4, 0x30, - 0x01, 0xd4, 0xd5, 0x30, 0x01, 0xd5, 0xd6, 0x30, 0x01, 0xd6, 0xd7, 0x30, - 0x01, 0xd7, 0xd8, 0x30, 0x01, 0xd8, 0xd9, 0x30, 0x81, 0x09, 0xd9, 0xdb, - 0x30, 0xc1, 0x00, 0xe1, 0xdc, 0x30, 0x41, 0xe1, 0xda, 0x30, 0x41, 0x90, - 0xe2, 0x02, 0x91, 0xb7, 0x02, 0x92, 0x87, 0x02, 0x93, 0xd2, 0x01, 0x94, - 0x9d, 0x01, 0x95, 0x44, 0x96, 0x01, 0xff, 0xd0, 0xc2, 0x30, 0x01, 0xd1, - 0xc3, 0x30, 0x01, 0xd2, 0xc4, 0x30, 0x01, 0xd3, 0xc5, 0x30, 0x01, 0xd4, - 0xc6, 0x30, 0x01, 0xd5, 0xc7, 0x30, 0x01, 0xd6, 0xc8, 0x30, 0x01, 0xd7, - 0xc9, 0x30, 0xc1, 0x00, 0xe1, 0xca, 0x30, 0x01, 0xe2, 0xcb, 0x30, 0x01, - 0xe3, 0xcc, 0x30, 0x01, 0xe4, 0xcd, 0x30, 0x01, 0xe5, 0xce, 0x30, 0x01, - 0xe6, 0xcf, 0x30, 0x01, 0xe7, 0xd0, 0x30, 0x01, 0xe8, 0xd1, 0x30, 0x41, - 0xd0, 0xad, 0x30, 0x81, 0x2e, 0xd1, 0xb7, 0x30, 0x01, 0xd2, 0xb8, 0x30, - 0x81, 0x21, 0xd3, 0xba, 0x30, 0x01, 0xd4, 0xbb, 0x30, 0x81, 0x14, 0xd5, - 0xbd, 0x30, 0x01, 0xd6, 0xbe, 0x30, 0x01, 0xd7, 0xbf, 0x30, 0x01, 0xd8, - 0xc0, 0x30, 0x01, 0xd9, 0xc1, 0x30, 0x41, 0xe1, 0xbc, 0x30, 0x41, 0xe1, - 0xb9, 0x30, 0x41, 0xe1, 0xae, 0x30, 0x01, 0xe2, 0xaf, 0x30, 0x01, 0xe3, - 0xb0, 0x30, 0x01, 0xe4, 0xb1, 0x30, 0x01, 0xe5, 0xb2, 0x30, 0x01, 0xe6, - 0xb3, 0x30, 0x01, 0xe7, 0xb4, 0x30, 0x01, 0xe8, 0xb5, 0x30, 0x01, 0xe9, - 0xb6, 0x30, 0x41, 0xd0, 0xa1, 0x30, 0x01, 0xd1, 0xa2, 0x30, 0x01, 0xd2, - 0xa3, 0x30, 0x01, 0xd3, 0xa4, 0x30, 0x01, 0xd4, 0xa5, 0x30, 0x01, 0xd5, - 0xa6, 0x30, 0x01, 0xd6, 0xa7, 0x30, 0x81, 0x11, 0xd7, 0xa9, 0x30, 0x01, - 0xd8, 0xaa, 0x30, 0x81, 0x04, 0xd9, 0xac, 0x30, 0x41, 0xe1, 0xab, 0x30, - 0x41, 0xe1, 0xa8, 0x30, 0x41, 0xd0, 0x95, 0x30, 0x01, 0xd1, 0x96, 0x30, - 0x81, 0x25, 0xd2, 0x98, 0x30, 0x01, 0xd3, 0x99, 0x30, 0x01, 0xd4, 0x9a, - 0x30, 0x81, 0x14, 0xd5, 0x9c, 0x30, 0x01, 0xd6, 0x9d, 0x30, 0x01, 0xd7, - 0x9e, 0x30, 0x01, 0xd8, 0x9f, 0x30, 0x01, 0xd9, 0xa0, 0x30, 0x41, 0xe1, - 0x9b, 0x30, 0x41, 0xe1, 0x97, 0x30, 0x41, 0xd0, 0x8a, 0x30, 0x01, 0xd1, - 0x8b, 0x30, 0x01, 0xd2, 0x8c, 0x30, 0x01, 0xd3, 0x8d, 0x30, 0x01, 0xd4, - 0x8e, 0x30, 0x01, 0xd5, 0x8f, 0x30, 0x01, 0xd6, 0x90, 0x30, 0x01, 0xd7, - 0x91, 0x30, 0x81, 0x08, 0xd8, 0x93, 0x30, 0x01, 0xd9, 0x94, 0x30, 0x41, - 0xe1, 0x92, 0x30, 0x41, 0xd0, 0x80, 0x30, 0x01, 0xd1, 0x81, 0x30, 0x01, - 0xd2, 0x82, 0x30, 0x01, 0xd3, 0x83, 0x30, 0x01, 0xd4, 0x84, 0x30, 0x01, - 0xd5, 0x85, 0x30, 0x01, 0xd6, 0x86, 0x30, 0x01, 0xd7, 0x87, 0x30, 0x01, - 0xd8, 0x88, 0x30, 0x01, 0xd9, 0x89, 0x30, 0x41, 0xd1, 0x76, 0x30, 0x01, - 0xd2, 0x77, 0x30, 0x01, 0xd3, 0x78, 0x30, 0x01, 0xd4, 0x79, 0x30, 0x01, - 0xd5, 0x7a, 0x30, 0x01, 0xd6, 0x7b, 0x30, 0x01, 0xd7, 0x7c, 0x30, 0x01, - 0xd8, 0x7d, 0x30, 0x81, 0x04, 0xd9, 0x7f, 0x30, 0x41, 0xe1, 0x7e, 0x30, - 0x41, 0x90, 0x46, 0x91, 0x17, 0x92, 0x01, 0xff, 0xd0, 0x71, 0x30, 0x01, - 0xd1, 0x72, 0x30, 0x01, 0xd2, 0x73, 0x30, 0x01, 0xd3, 0x74, 0x30, 0x01, - 0xd4, 0x75, 0x30, 0x41, 0xd0, 0x66, 0x30, 0x81, 0x24, 0xd1, 0x68, 0x30, - 0x01, 0xd2, 0x69, 0x30, 0x01, 0xd3, 0x6a, 0x30, 0x01, 0xd4, 0x6b, 0x30, - 0x01, 0xd5, 0x6c, 0x30, 0x01, 0xd6, 0x6d, 0x30, 0x01, 0xd7, 0x6e, 0x30, - 0x01, 0xd8, 0x6f, 0x30, 0x01, 0xd9, 0x70, 0x30, 0x41, 0xe1, 0x67, 0x30, - 0x41, 0xd1, 0x5a, 0x30, 0x01, 0xd2, 0x5b, 0x30, 0x81, 0x1c, 0xd3, 0x5f, - 0x30, 0x01, 0xd4, 0x60, 0x30, 0x01, 0xd5, 0x61, 0x30, 0x01, 0xd6, 0x62, - 0x30, 0x01, 0xd7, 0x63, 0x30, 0x01, 0xd8, 0x64, 0x30, 0x01, 0xd9, 0x65, - 0x30, 0x41, 0xe1, 0x5c, 0x30, 0x01, 0xe2, 0x5d, 0x30, 0x01, 0xe3, 0x5e, - 0x30, 0x41, 0x02, 0xaa, 0xd8, 0x17, 0x05, 0xb9, 0x3f, 0x01, 0xff, 0x49, - 0xa4, 0x68, 0x3c, 0x34, 0x01, 0x47, 0x21, 0x30, 0x37, 0x34, 0x01, 0x50, - 0x9d, 0x68, 0x3e, 0x34, 0x41, 0xd1, 0x50, 0x30, 0x01, 0xd2, 0x51, 0x30, - 0x01, 0xd3, 0x52, 0x30, 0x01, 0xd4, 0x53, 0x30, 0x01, 0xd5, 0x54, 0x30, - 0x81, 0x10, 0xd6, 0x56, 0x30, 0x01, 0xd7, 0x57, 0x30, 0x01, 0xd8, 0x58, - 0x30, 0x01, 0xd9, 0x59, 0x30, 0x41, 0xe1, 0x55, 0x30, 0x41, 0x90, 0x97, - 0x01, 0x02, 0x10, 0xed, 0x01, 0xff, 0x90, 0x63, 0x91, 0x39, 0x92, 0x0f, - 0x93, 0x01, 0xff, 0xd0, 0x2c, 0x34, 0x01, 0xd1, 0x2d, 0x34, 0x01, 0xd2, - 0x2e, 0x34, 0x41, 0xd0, 0x22, 0x34, 0x01, 0xd1, 0x23, 0x34, 0x01, 0xd2, - 0x24, 0x34, 0x01, 0xd3, 0x25, 0x34, 0x01, 0xd4, 0x26, 0x34, 0x01, 0xd5, - 0x27, 0x34, 0x01, 0xd6, 0x28, 0x34, 0x01, 0xd7, 0x29, 0x34, 0x01, 0xd8, - 0x2a, 0x34, 0x01, 0xd9, 0x2b, 0x34, 0x41, 0xd0, 0x18, 0x34, 0x01, 0xd1, - 0x19, 0x34, 0x01, 0xd2, 0x1a, 0x34, 0x01, 0xd3, 0x1b, 0x34, 0x01, 0xd4, - 0x1c, 0x34, 0x01, 0xd5, 0x1d, 0x34, 0x01, 0xd6, 0x1e, 0x34, 0x01, 0xd7, - 0x1f, 0x34, 0x01, 0xd8, 0x20, 0x34, 0x01, 0xd9, 0x21, 0x34, 0x41, 0xd1, - 0x0d, 0x34, 0x01, 0xd2, 0x0e, 0x34, 0x01, 0xd3, 0x0f, 0x34, 0x01, 0xd4, - 0x10, 0x34, 0x01, 0xd5, 0x11, 0x34, 0x01, 0xd6, 0x12, 0x34, 0x01, 0xd7, - 0x13, 0x34, 0x81, 0x08, 0xd8, 0x16, 0x34, 0x01, 0xd9, 0x17, 0x34, 0x41, - 0xe1, 0x14, 0x34, 0x01, 0xe2, 0x15, 0x34, 0x41, 0x90, 0xa8, 0x02, 0x91, - 0xf3, 0x01, 0x92, 0xc8, 0x01, 0x93, 0x98, 0x01, 0x94, 0x5a, 0x95, 0x30, - 0x96, 0x06, 0x42, 0x3b, 0xf4, 0x4f, 0x30, 0x41, 0xd0, 0x45, 0x30, 0x01, - 0xd1, 0x46, 0x30, 0x01, 0xd2, 0x47, 0x30, 0x01, 0xd3, 0x48, 0x30, 0x01, - 0xd4, 0x49, 0x30, 0x01, 0xd5, 0x4a, 0x30, 0x01, 0xd6, 0x4b, 0x30, 0x01, - 0xd7, 0x4c, 0x30, 0x01, 0xd8, 0x4d, 0x30, 0x01, 0xd9, 0x4e, 0x30, 0x41, - 0xd0, 0x3b, 0x30, 0x01, 0xd1, 0x3c, 0x30, 0x01, 0xd2, 0x3d, 0x30, 0x01, - 0xd3, 0x3e, 0x30, 0x01, 0xd4, 0x3f, 0x30, 0x01, 0xd5, 0x40, 0x30, 0x01, - 0xd6, 0x41, 0x30, 0x01, 0xd7, 0x42, 0x30, 0x01, 0xd8, 0x43, 0x30, 0x01, - 0xd9, 0x44, 0x30, 0x41, 0xd0, 0x2d, 0x30, 0x81, 0x33, 0xd1, 0x2f, 0x30, - 0x01, 0xd2, 0x30, 0x30, 0x81, 0x26, 0xd3, 0x32, 0x30, 0x81, 0x1d, 0xd4, - 0x34, 0x30, 0x01, 0xd5, 0x35, 0x30, 0x81, 0x10, 0xd6, 0x37, 0x30, 0x01, - 0xd7, 0x38, 0x30, 0x01, 0xd8, 0x39, 0x30, 0x01, 0xd9, 0x3a, 0x30, 0x41, - 0xe1, 0x36, 0x30, 0x41, 0xe1, 0x33, 0x30, 0x41, 0xe1, 0x31, 0x30, 0x41, - 0xe1, 0x2e, 0x30, 0x41, 0xd0, 0x22, 0x30, 0x01, 0xd1, 0x23, 0x30, 0x01, - 0xd2, 0x24, 0x30, 0x81, 0x1c, 0xd3, 0x26, 0x30, 0x01, 0xd4, 0x27, 0x30, - 0x01, 0xd5, 0x28, 0x30, 0x01, 0xd6, 0x29, 0x30, 0x01, 0xd7, 0x2a, 0x30, - 0x01, 0xd8, 0x2b, 0x30, 0x01, 0xd9, 0x2c, 0x30, 0x41, 0xe1, 0x25, 0x30, - 0x41, 0xd0, 0x18, 0x30, 0x01, 0xd1, 0x19, 0x30, 0x01, 0xd2, 0x1a, 0x30, - 0x01, 0xd3, 0x1b, 0x30, 0x01, 0xd4, 0x1c, 0x30, 0x01, 0xd5, 0x1d, 0x30, - 0x01, 0xd6, 0x1e, 0x30, 0x01, 0xd7, 0x1f, 0x30, 0x01, 0xd8, 0x20, 0x30, - 0x01, 0xd9, 0x21, 0x30, 0x41, 0xd0, 0x0c, 0x30, 0x01, 0xd1, 0x0d, 0x30, - 0x01, 0xd2, 0x0e, 0x30, 0x01, 0xd3, 0x0f, 0x30, 0x01, 0xd4, 0x10, 0x30, - 0x81, 0x19, 0xd5, 0x12, 0x30, 0x01, 0xd6, 0x13, 0x30, 0x01, 0xd7, 0x14, - 0x30, 0x81, 0x08, 0xd8, 0x16, 0x30, 0x01, 0xd9, 0x17, 0x30, 0x41, 0xe1, - 0x15, 0x30, 0x41, 0xe1, 0x11, 0x30, 0x41, 0xd1, 0x00, 0x30, 0x01, 0xd2, - 0x01, 0x30, 0x01, 0xd3, 0x02, 0x30, 0x01, 0xd4, 0x03, 0x30, 0x01, 0xd5, - 0x04, 0x30, 0x81, 0x19, 0xd6, 0x06, 0x30, 0x81, 0x0c, 0xd7, 0x09, 0x30, - 0x01, 0xd8, 0x0a, 0x30, 0x01, 0xd9, 0x0b, 0x30, 0x41, 0xe1, 0x07, 0x30, - 0x01, 0xe2, 0x08, 0x30, 0x41, 0xe1, 0x05, 0x30, 0x41, 0x43, 0x06, 0x02, - 0x85, 0xf9, 0x01, 0xf2, 0x42, 0xf4, 0x81, 0x06, 0x4f, 0x4e, 0x73, 0x71, - 0x26, 0x40, 0x80, 0x2a, 0x42, 0x53, 0x00, 0x41, 0x26, 0xc0, 0x00, 0x02, - 0x86, 0x00, 0x01, 0xff, 0x05, 0x03, 0x40, 0x06, 0x45, 0x9d, 0x16, 0xda, - 0x23, 0x40, 0xa1, 0x06, 0x4d, 0xcd, 0x82, 0x0d, 0xf3, 0x41, 0x47, 0x5f, - 0xd3, 0x0e, 0xf3, 0x01, 0x4d, 0xb1, 0x88, 0x0f, 0xf3, 0x41, 0x03, 0xf4, - 0x01, 0x06, 0x50, 0xcd, 0x68, 0xbb, 0xf9, 0x41, 0x45, 0x8c, 0xe8, 0x3d, - 0xf3, 0x01, 0x44, 0xf6, 0xb3, 0x3e, 0xf3, 0x41, 0xa1, 0xe0, 0x31, 0xa3, - 0xc9, 0x31, 0xa5, 0xfc, 0x23, 0xa9, 0x83, 0x1a, 0x42, 0x68, 0x00, 0x10, - 0x00, 0x00, 0x4f, 0x7e, 0x70, 0xec, 0xf9, 0x01, 0xaf, 0xb0, 0x07, 0xb2, - 0xe3, 0x06, 0xb5, 0x06, 0x42, 0x45, 0xf5, 0xc0, 0xf4, 0x41, 0x42, 0x36, - 0x01, 0x86, 0xf9, 0x01, 0x46, 0x2c, 0xde, 0x5f, 0xf9, 0x01, 0x07, 0xe0, - 0xd4, 0x01, 0xff, 0x06, 0xa6, 0xd9, 0xe3, 0x04, 0x4b, 0x52, 0x9b, 0x9e, - 0xbc, 0x01, 0x07, 0xec, 0x05, 0x12, 0x5d, 0x6d, 0x16, 0x9f, 0xbc, 0x01, - 0x51, 0xee, 0x5d, 0x9c, 0xbc, 0x01, 0x55, 0x7e, 0x3e, 0x9d, 0xbc, 0x41, - 0xe1, 0x41, 0xbc, 0x81, 0xbb, 0x04, 0xe2, 0x07, 0xbc, 0x01, 0xe4, 0x08, - 0xbc, 0x81, 0xa7, 0x04, 0xe5, 0x47, 0xbc, 0x81, 0x99, 0x04, 0xe6, 0x04, - 0xbc, 0x81, 0x8d, 0x04, 0xe7, 0x0a, 0xbc, 0x81, 0x81, 0x04, 0xe8, 0x00, - 0xbc, 0x81, 0xf7, 0x03, 0xe9, 0x46, 0xbc, 0x81, 0xed, 0x03, 0xea, 0x1b, - 0xbc, 0x81, 0xb6, 0x03, 0xeb, 0x05, 0xbc, 0x81, 0xa0, 0x03, 0xec, 0x06, - 0xbc, 0x81, 0x89, 0x03, 0xed, 0x19, 0xbc, 0x81, 0xeb, 0x02, 0xee, 0x1a, - 0xbc, 0x81, 0xb9, 0x02, 0xef, 0x44, 0xbc, 0x81, 0xa1, 0x02, 0xf0, 0x02, - 0xbc, 0x81, 0x88, 0x02, 0xf2, 0x0b, 0xbc, 0x81, 0xeb, 0x01, 0xf3, 0x1c, - 0xbc, 0x81, 0x68, 0xf4, 0x03, 0xbc, 0x81, 0x53, 0xf5, 0x51, 0xbc, 0x81, - 0x40, 0xf6, 0x09, 0xbc, 0x81, 0x35, 0xf7, 0x38, 0xbc, 0x81, 0x0f, 0xf8, - 0x01, 0xbc, 0x81, 0x06, 0x42, 0x4d, 0x00, 0x50, 0xbc, 0x41, 0xf7, 0x53, - 0xbc, 0x41, 0x42, 0xc7, 0x00, 0x3a, 0xbc, 0x01, 0xe1, 0x5c, 0xbc, 0x01, - 0x42, 0x12, 0x0b, 0x5f, 0xbc, 0x01, 0xe8, 0x39, 0xbc, 0x01, 0xe9, 0x5e, - 0xbc, 0x01, 0xef, 0x5d, 0xbc, 0xc1, 0x00, 0xf7, 0x60, 0xbc, 0x41, 0x48, - 0x19, 0xc9, 0x6a, 0xbc, 0x41, 0x42, 0xb3, 0x01, 0x54, 0xbc, 0x01, 0xe8, - 0x57, 0xbc, 0x01, 0xe9, 0x4a, 0xbc, 0x41, 0x80, 0x04, 0xe8, 0x11, 0xbc, - 0x41, 0x43, 0xab, 0x0c, 0x37, 0xbc, 0x01, 0xf3, 0x36, 0xbc, 0x41, 0x80, - 0x37, 0x46, 0xb8, 0xdc, 0x49, 0xbc, 0x01, 0x05, 0x50, 0xe8, 0x01, 0xff, - 0x42, 0x1a, 0x00, 0x68, 0xbc, 0x01, 0x42, 0xee, 0x4b, 0x12, 0xbc, 0x01, - 0xa5, 0x12, 0xea, 0x15, 0xbc, 0x01, 0xaf, 0x04, 0xf5, 0x58, 0xbc, 0x41, - 0xee, 0x69, 0xbc, 0x01, 0xf7, 0x42, 0xbc, 0x41, 0xe5, 0x4e, 0xbc, 0x01, - 0xe8, 0x4c, 0xbc, 0x01, 0xee, 0x67, 0xbc, 0x41, 0xea, 0x20, 0xbc, 0x81, - 0x3a, 0xeb, 0x3f, 0xbc, 0x81, 0x2f, 0xed, 0x3c, 0xbc, 0x01, 0xee, 0x3b, - 0xbc, 0x01, 0xf0, 0x34, 0xbc, 0x81, 0x1c, 0xf3, 0x2a, 0xbc, 0x01, 0xf4, - 0x32, 0xbc, 0x81, 0x0d, 0x48, 0x91, 0x3b, 0x25, 0xbc, 0xc1, 0x00, 0x46, - 0x1f, 0x07, 0x26, 0xbc, 0x41, 0x42, 0xc7, 0x00, 0x33, 0xbc, 0x41, 0x42, - 0xc7, 0x00, 0x35, 0xbc, 0x41, 0x42, 0xc7, 0x00, 0x40, 0xbc, 0x41, 0x42, - 0x99, 0x00, 0x2e, 0xbc, 0x41, 0x42, 0x99, 0x00, 0x10, 0xbc, 0x01, 0xe8, - 0x18, 0xbc, 0x01, 0x08, 0x51, 0xc9, 0x01, 0xff, 0xe9, 0x4d, 0xbc, 0x01, - 0xf5, 0x56, 0xbc, 0x41, 0x42, 0xb3, 0x01, 0x0c, 0xbc, 0x01, 0x07, 0xfe, - 0xd0, 0x01, 0xff, 0xed, 0x66, 0xbc, 0x01, 0xee, 0x65, 0xbc, 0x41, 0xe1, - 0x43, 0xbc, 0x01, 0x42, 0x18, 0x29, 0x59, 0xbc, 0x01, 0xf5, 0x5b, 0xbc, - 0x01, 0xf7, 0x5a, 0xbc, 0x41, 0x80, 0x15, 0x05, 0x3b, 0x4c, 0x01, 0xff, - 0xe1, 0x64, 0xbc, 0x01, 0xe9, 0x63, 0xbc, 0x01, 0xef, 0x62, 0xbc, 0x01, - 0xf5, 0x61, 0xbc, 0x41, 0xed, 0x1e, 0xbc, 0x81, 0x0a, 0xf3, 0x28, 0xbc, - 0x01, 0x48, 0x91, 0x3b, 0x22, 0xbc, 0x41, 0x42, 0x99, 0x00, 0x2c, 0xbc, - 0x41, 0x80, 0x01, 0xff, 0xee, 0x1d, 0xbc, 0x81, 0x0a, 0xf3, 0x27, 0xbc, - 0x01, 0x48, 0x91, 0x3b, 0x21, 0xbc, 0x41, 0x42, 0x99, 0x00, 0x2b, 0xbc, - 0x41, 0xe8, 0x17, 0xbc, 0x01, 0x04, 0xd8, 0x02, 0x01, 0xff, 0xe9, 0x4f, - 0xbc, 0x01, 0xf5, 0x55, 0xbc, 0x41, 0x80, 0x04, 0xeb, 0x14, 0xbc, 0x41, - 0xed, 0x0f, 0xbc, 0x01, 0x43, 0xab, 0x0c, 0x3d, 0xbc, 0x41, 0x80, 0x01, - 0xff, 0xed, 0x1f, 0xbc, 0x81, 0x23, 0xee, 0x30, 0xbc, 0x81, 0x18, 0xf3, - 0x29, 0xbc, 0x81, 0x0d, 0x48, 0x91, 0x3b, 0x23, 0xbc, 0xc1, 0x00, 0x52, - 0xfe, 0x54, 0x24, 0xbc, 0x41, 0x49, 0x90, 0x3b, 0x2f, 0xbc, 0x41, 0x42, - 0x99, 0x00, 0x31, 0xbc, 0x41, 0x42, 0x99, 0x00, 0x2d, 0xbc, 0x41, 0xe5, - 0x48, 0xbc, 0x41, 0xec, 0x16, 0xbc, 0x41, 0x44, 0xe5, 0xec, 0x3e, 0xbc, - 0x41, 0x42, 0xb3, 0x01, 0x0e, 0xbc, 0x41, 0xe5, 0x4b, 0xbc, 0x01, 0xf5, - 0x52, 0xbc, 0x41, 0x42, 0x99, 0x00, 0x0d, 0xbc, 0x01, 0xe8, 0x13, 0xbc, - 0x41, 0x42, 0x3c, 0x01, 0x45, 0xbc, 0x41, 0x09, 0x8a, 0xb6, 0xad, 0x01, - 0x05, 0x48, 0x0b, 0x6a, 0xac, 0x16, 0x04, 0x47, 0xb5, 0x06, 0x57, 0xe0, - 0x30, 0x72, 0xbc, 0x41, 0x51, 0xe6, 0x30, 0x71, 0xbc, 0x01, 0x4f, 0x89, - 0x74, 0x74, 0xbc, 0x41, 0x55, 0xb8, 0x3a, 0x70, 0xbc, 0x01, 0x03, 0xd1, - 0x00, 0x01, 0xff, 0xa1, 0x39, 0x46, 0x12, 0x03, 0x95, 0xbc, 0x01, 0x43, - 0x23, 0x0a, 0x94, 0xbc, 0x01, 0x45, 0x17, 0x23, 0x92, 0xbc, 0x01, 0xac, - 0x19, 0x4b, 0xb3, 0xa3, 0x91, 0xbc, 0x01, 0x48, 0x32, 0x00, 0x98, 0xbc, - 0x81, 0x06, 0x44, 0x89, 0x57, 0x97, 0xbc, 0x41, 0x47, 0xf0, 0x30, 0x73, - 0xbc, 0x41, 0x43, 0xee, 0x07, 0x96, 0xbc, 0x01, 0x49, 0x53, 0xbd, 0x93, - 0xbc, 0x41, 0x44, 0x15, 0x39, 0x90, 0xbc, 0x01, 0x44, 0xcf, 0x00, 0x99, - 0xbc, 0x41, 0x45, 0x14, 0x39, 0x80, 0xbc, 0x01, 0x46, 0x12, 0x03, 0x85, - 0xbc, 0x01, 0x43, 0x23, 0x0a, 0x84, 0xbc, 0x01, 0x45, 0x17, 0x23, 0x82, - 0xbc, 0x01, 0xac, 0x19, 0x4b, 0xb3, 0xa3, 0x81, 0xbc, 0x01, 0x48, 0x32, - 0x00, 0x88, 0xbc, 0x81, 0x06, 0x44, 0x89, 0x57, 0x87, 0xbc, 0x41, 0x47, - 0xf0, 0x30, 0x75, 0xbc, 0x41, 0x43, 0xee, 0x07, 0x86, 0xbc, 0x01, 0x49, - 0x53, 0xbd, 0x83, 0xbc, 0x41, 0x46, 0xb9, 0x9f, 0x7a, 0xbc, 0x01, 0x46, - 0xca, 0xdc, 0x7b, 0xbc, 0x01, 0x54, 0x53, 0x44, 0x77, 0xbc, 0x01, 0x46, - 0xf1, 0x30, 0x76, 0xbc, 0x01, 0x02, 0x12, 0x00, 0x01, 0xff, 0x42, 0x62, - 0x01, 0x79, 0xbc, 0x01, 0x45, 0x2c, 0xe9, 0x78, 0xbc, 0xc1, 0x00, 0x45, - 0xab, 0x0e, 0x7c, 0xbc, 0x41, 0xa1, 0x2f, 0x43, 0xed, 0x00, 0x57, 0xf4, - 0x01, 0x4d, 0xbb, 0x84, 0xda, 0x26, 0x00, 0xaf, 0x06, 0x52, 0x1e, 0x56, - 0x41, 0xf9, 0x41, 0x4c, 0xf8, 0x91, 0x2a, 0xf4, 0x01, 0x4a, 0xd2, 0xae, - 0x24, 0xf9, 0x01, 0xb0, 0x01, 0xff, 0x49, 0x89, 0xb4, 0x78, 0xfa, 0x01, - 0x43, 0xec, 0x05, 0xa7, 0xf4, 0x41, 0x49, 0xd1, 0xa1, 0xaf, 0x20, 0x00, - 0x5c, 0xc2, 0x17, 0x9b, 0x27, 0x00, 0x43, 0x06, 0x14, 0x09, 0xf4, 0xc1, - 0x00, 0x45, 0x0b, 0x08, 0x32, 0xf4, 0x41, 0x52, 0x5e, 0x4f, 0xaf, 0xf6, - 0x01, 0x46, 0x53, 0xc5, 0xce, 0xf5, 0x81, 0x9e, 0x12, 0x42, 0x3b, 0x01, - 0xa4, 0xf9, 0x01, 0x07, 0x1c, 0x77, 0xc5, 0x11, 0xe7, 0x15, 0xf4, 0x81, - 0xd1, 0x0e, 0xac, 0xc2, 0x0e, 0x0a, 0x0a, 0xae, 0xd5, 0x0a, 0xae, 0xc6, - 0x0a, 0x42, 0x0c, 0x00, 0xaa, 0xf6, 0x01, 0xb4, 0xe4, 0x09, 0xb5, 0x89, - 0x05, 0x4b, 0xe7, 0xa4, 0x4a, 0xf5, 0x01, 0x02, 0xa7, 0x01, 0x01, 0xff, - 0x80, 0xdc, 0x04, 0x8d, 0xf1, 0x03, 0x04, 0xa9, 0x01, 0x01, 0xff, 0x08, - 0x21, 0xc2, 0xcd, 0x03, 0x02, 0x31, 0x01, 0x01, 0xff, 0xa1, 0xcd, 0x02, - 0x06, 0x0c, 0x03, 0xb5, 0x02, 0x50, 0x8d, 0x61, 0x3f, 0xf8, 0x01, 0xa4, - 0xa0, 0x02, 0x51, 0x03, 0x5a, 0x37, 0xf8, 0x01, 0xa8, 0xc1, 0x01, 0x4d, - 0x79, 0x87, 0xca, 0x21, 0x00, 0x4f, 0x13, 0x72, 0xf1, 0x27, 0x00, 0x46, - 0xc4, 0xdf, 0x6f, 0xf6, 0x01, 0xb3, 0xa0, 0x01, 0xb4, 0x13, 0x4b, 0x49, - 0x10, 0xe9, 0x21, 0x80, 0x06, 0x4c, 0xfc, 0x33, 0xaf, 0x21, 0x40, 0x5a, - 0xe2, 0x1e, 0x97, 0xf8, 0x41, 0x02, 0x0d, 0x00, 0x11, 0x02, 0x15, 0x02, - 0x01, 0xff, 0x4d, 0x9a, 0x7f, 0xa1, 0x21, 0x00, 0x66, 0x1b, 0x06, 0xef, - 0x2b, 0x40, 0x05, 0x04, 0x02, 0x06, 0x49, 0x19, 0x72, 0x0b, 0x29, 0x40, - 0x4a, 0xe0, 0x01, 0x93, 0xf8, 0x01, 0x08, 0x09, 0x02, 0x01, 0xff, 0x45, - 0xce, 0x00, 0x63, 0x2b, 0x80, 0x12, 0x4c, 0xd8, 0x8d, 0x6d, 0x2b, 0x00, - 0x4d, 0x79, 0x87, 0x87, 0x2b, 0x00, 0x4c, 0xfc, 0x33, 0x4d, 0x2b, 0x40, - 0x80, 0x01, 0xff, 0x6a, 0x6c, 0x03, 0x83, 0x2b, 0x00, 0x46, 0xd1, 0x14, - 0x73, 0x2b, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4a, 0x74, 0xa8, 0x2b, - 0xf8, 0x01, 0x58, 0x41, 0x28, 0x7d, 0x2b, 0x00, 0x4b, 0x72, 0x68, 0x2f, - 0xf8, 0x01, 0x09, 0xd0, 0xbb, 0x12, 0x4c, 0x04, 0x92, 0x27, 0xf8, 0x01, - 0x4c, 0x70, 0x92, 0x23, 0xf8, 0x01, 0x50, 0x6d, 0x68, 0x33, 0xf8, 0x41, - 0x49, 0xea, 0x01, 0xa0, 0x2b, 0x00, 0x4a, 0xb3, 0x02, 0xa1, 0x2b, 0x40, - 0x4f, 0xee, 0x66, 0x53, 0xf8, 0x01, 0x4c, 0x08, 0x94, 0x3b, 0xf8, 0x41, - 0x11, 0x91, 0x05, 0x11, 0x05, 0x6e, 0x15, 0x01, 0xff, 0x45, 0xce, 0x00, - 0x47, 0xf8, 0x01, 0x50, 0x8d, 0x61, 0x43, 0xf8, 0x41, 0x04, 0xc3, 0x00, - 0x19, 0x05, 0xc8, 0x00, 0x01, 0xff, 0x80, 0x06, 0x45, 0xa9, 0x01, 0xc2, - 0x21, 0x40, 0x48, 0x78, 0xb4, 0x5d, 0x29, 0x00, 0x46, 0xd1, 0x14, 0x55, - 0x29, 0x40, 0x80, 0x06, 0x45, 0xa9, 0x01, 0xc3, 0x21, 0x40, 0x07, 0x92, - 0x0a, 0x0c, 0x48, 0x78, 0xb4, 0x61, 0x29, 0x00, 0x46, 0xd1, 0x14, 0x59, - 0x29, 0x40, 0x61, 0xc9, 0x0d, 0x65, 0x29, 0x00, 0x5f, 0x08, 0x12, 0x6f, - 0x29, 0x40, 0x4b, 0xd9, 0x8d, 0xe3, 0x21, 0x00, 0x4b, 0x45, 0x8e, 0xd3, - 0x21, 0x40, 0x45, 0xce, 0x00, 0x07, 0x2b, 0x80, 0x06, 0x53, 0xda, 0x48, - 0x8b, 0x2b, 0x40, 0x47, 0xd0, 0x14, 0xb3, 0xf8, 0x41, 0x45, 0x18, 0xe9, - 0x14, 0x2e, 0x00, 0x44, 0xcf, 0x00, 0x93, 0x21, 0xc0, 0x00, 0x80, 0x01, - 0xff, 0x5a, 0x4a, 0x1f, 0xb7, 0xfb, 0x01, 0x48, 0x78, 0xb4, 0xa7, 0x21, - 0x00, 0x5a, 0xb6, 0x20, 0xf5, 0x21, 0x00, 0x46, 0xd1, 0x14, 0x13, 0x29, - 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x50, 0xbd, 0x61, 0xb5, 0x21, 0x00, - 0x4d, 0x4b, 0x82, 0xdf, 0x21, 0x00, 0x55, 0xd5, 0x01, 0x17, 0xf8, 0x01, - 0x51, 0x47, 0x05, 0x08, 0x29, 0x00, 0x58, 0x91, 0x29, 0x0b, 0xf8, 0x01, - 0x59, 0xfe, 0x24, 0x07, 0xf8, 0x01, 0x4c, 0xe8, 0x92, 0x9b, 0xf8, 0x01, - 0x06, 0x5d, 0x07, 0x11, 0x04, 0x49, 0x0c, 0x01, 0xff, 0x49, 0xea, 0x01, - 0xb2, 0x21, 0x00, 0x4a, 0xb3, 0x02, 0xb3, 0x21, 0x40, 0x55, 0xd5, 0x01, - 0x13, 0xf8, 0x01, 0x52, 0x2e, 0x06, 0x03, 0xf8, 0x41, 0x44, 0xac, 0x0e, - 0x08, 0xf9, 0x81, 0x0d, 0x4c, 0xdc, 0x92, 0x09, 0xf9, 0xc1, 0x00, 0x49, - 0x90, 0x3b, 0x0b, 0xf9, 0x41, 0x49, 0x90, 0x3b, 0x0a, 0xf9, 0x41, 0x17, - 0x8a, 0x2e, 0x58, 0x09, 0x9c, 0x01, 0x01, 0xff, 0xa1, 0x45, 0x4b, 0xcb, - 0x9b, 0x7b, 0xcc, 0x01, 0x44, 0xf5, 0xef, 0xfc, 0xcd, 0x01, 0xb2, 0x1f, - 0xb3, 0x11, 0x0e, 0x80, 0x7d, 0x01, 0xff, 0x4f, 0x7f, 0x6f, 0xe8, 0x29, - 0x00, 0x50, 0xbd, 0x66, 0xe9, 0x29, 0x40, 0x51, 0xf0, 0x5b, 0x3d, 0xf5, - 0x01, 0x4b, 0x95, 0x95, 0x04, 0xcc, 0x41, 0x49, 0xbb, 0xb5, 0x9a, 0xcc, - 0x01, 0x4b, 0x90, 0x06, 0x3b, 0xf5, 0x01, 0x44, 0xe6, 0xac, 0x68, 0xcc, - 0x01, 0x4a, 0xbe, 0xae, 0x59, 0xcc, 0x41, 0x47, 0x2d, 0x34, 0xf8, 0xcd, - 0x01, 0x4a, 0x24, 0xb2, 0x63, 0xcc, 0x41, 0x4c, 0x90, 0x8d, 0x77, 0xcc, - 0x01, 0x4a, 0x57, 0x29, 0x73, 0xcc, 0x41, 0x49, 0xe1, 0x01, 0x04, 0x23, - 0x00, 0x49, 0x1b, 0xb9, 0x7f, 0x29, 0x00, 0x57, 0xc9, 0x30, 0xf1, 0x22, - 0x00, 0x44, 0x10, 0x39, 0xa4, 0x22, 0xc0, 0x00, 0x52, 0xb8, 0x4f, 0xf1, - 0x2a, 0x40, 0x03, 0x3e, 0x01, 0x06, 0x45, 0xc5, 0xe6, 0x69, 0xf3, 0x41, - 0x80, 0xba, 0x01, 0x8d, 0x17, 0x02, 0x06, 0x00, 0x01, 0xff, 0x4b, 0x2e, - 0x27, 0xa2, 0x26, 0x00, 0x49, 0x63, 0x21, 0xa3, 0x26, 0x00, 0x46, 0x16, - 0x08, 0xfc, 0x2b, 0x40, 0x4e, 0x6e, 0x77, 0xdf, 0x29, 0x00, 0x05, 0xed, - 0x07, 0x66, 0x07, 0x2f, 0x77, 0x01, 0xff, 0x08, 0xe4, 0x05, 0x36, 0x07, - 0x2b, 0xd2, 0x17, 0x4f, 0x6f, 0x70, 0x40, 0x21, 0x00, 0x06, 0x5d, 0x07, - 0x01, 0xff, 0x45, 0x33, 0x58, 0x3d, 0x21, 0x00, 0x42, 0xe6, 0x05, 0x3c, - 0x21, 0x40, 0x49, 0x23, 0xb7, 0x45, 0x21, 0x00, 0x06, 0x5d, 0x07, 0x01, - 0xff, 0xe4, 0x46, 0x21, 0x00, 0xe5, 0x47, 0x21, 0x00, 0xe9, 0x48, 0x21, - 0x00, 0xea, 0x49, 0x21, 0x40, 0xe3, 0x02, 0x21, 0x00, 0x45, 0x33, 0x58, - 0x3e, 0x21, 0x00, 0xe8, 0x0d, 0x21, 0x00, 0xee, 0x15, 0x21, 0x00, 0xf0, - 0x19, 0x21, 0x80, 0x0c, 0xf1, 0x1a, 0x21, 0x00, 0xf2, 0x1d, 0x21, 0x00, - 0xfa, 0x24, 0x21, 0x40, 0xe9, 0x3f, 0x21, 0x40, 0x0c, 0xa1, 0x28, 0x21, - 0x08, 0x9a, 0x00, 0x01, 0xff, 0x0c, 0xa1, 0x28, 0x0c, 0x58, 0x01, 0x29, - 0xfa, 0x2a, 0x00, 0x55, 0xc5, 0x3c, 0xf9, 0x2a, 0x40, 0x4c, 0x87, 0x00, - 0x9c, 0x2a, 0x00, 0x49, 0xec, 0x00, 0x9b, 0x2a, 0x40, 0x4c, 0x87, 0x00, - 0x9a, 0x2a, 0x00, 0x49, 0xec, 0x00, 0x99, 0x2a, 0x40, 0x4c, 0x10, 0x8c, - 0xdd, 0x02, 0x00, 0xa3, 0xb1, 0x02, 0xa4, 0xa2, 0x02, 0x50, 0xad, 0x00, - 0x3c, 0x20, 0x00, 0xa8, 0x8d, 0x02, 0x04, 0x35, 0x08, 0xfc, 0x01, 0xac, - 0xc8, 0x01, 0x07, 0x9e, 0xd3, 0xb0, 0x01, 0x4e, 0x46, 0x7a, 0x17, 0x2e, - 0x00, 0xb0, 0x8b, 0x01, 0x4d, 0xc1, 0x34, 0x47, 0x20, 0x00, 0x5b, 0x6c, - 0x1d, 0x96, 0x29, 0x00, 0xb3, 0x3e, 0xb5, 0x30, 0x09, 0x32, 0x00, 0x06, - 0x4d, 0x92, 0x8a, 0x4c, 0xfe, 0x40, 0x43, 0x16, 0x00, 0xf8, 0x23, 0x80, - 0x06, 0x44, 0xed, 0x07, 0x16, 0x20, 0x40, 0x80, 0x01, 0xff, 0x07, 0x3b, - 0x01, 0x06, 0x4e, 0x6b, 0x3a, 0xe3, 0x2a, 0x40, 0x4e, 0x6b, 0x3a, 0xe5, - 0x2a, 0x00, 0x4f, 0x56, 0x01, 0xab, 0x22, 0x40, 0x44, 0x4e, 0x17, 0xd3, - 0x22, 0x00, 0x46, 0x0a, 0xd7, 0xeb, 0x2a, 0x40, 0x4f, 0x23, 0x71, 0xfd, - 0x2a, 0x00, 0x06, 0xd7, 0x24, 0x29, 0xb4, 0x1b, 0xb5, 0x01, 0xff, 0x44, - 0x9b, 0x12, 0xd0, 0x22, 0x00, 0x46, 0x53, 0xcb, 0xbc, 0x2a, 0x00, 0x46, - 0x44, 0x36, 0xd1, 0x22, 0x00, 0x4d, 0x53, 0x7e, 0x44, 0x2e, 0x40, 0x4b, - 0xd4, 0x98, 0x49, 0x2e, 0x00, 0x4d, 0x8c, 0x73, 0xec, 0x2a, 0x40, 0x4c, - 0xa9, 0x0a, 0x4e, 0x2a, 0x00, 0x45, 0x4d, 0x17, 0x4f, 0x2a, 0x40, 0x43, - 0x74, 0x28, 0xfa, 0x29, 0x00, 0xb2, 0x01, 0xff, 0x46, 0x0b, 0xca, 0xbb, - 0x2a, 0x00, 0x43, 0x29, 0x02, 0x33, 0x20, 0xc0, 0x00, 0x4f, 0x18, 0x05, - 0x1e, 0x30, 0x40, 0x4c, 0x87, 0x00, 0xa2, 0x2a, 0x00, 0x49, 0xec, 0x00, - 0xa1, 0x2a, 0xc0, 0x00, 0x4e, 0x34, 0x5f, 0xa3, 0x2a, 0x40, 0x5c, 0xa6, - 0x17, 0x95, 0x29, 0x00, 0xaf, 0x01, 0xff, 0x06, 0x2f, 0x22, 0x18, 0xb7, - 0x01, 0xff, 0x45, 0xec, 0x07, 0x17, 0x20, 0x00, 0x8d, 0x01, 0xff, 0x50, - 0x61, 0x13, 0x1e, 0x20, 0x00, 0x59, 0x58, 0x13, 0x42, 0x2e, 0x40, 0x43, - 0x1a, 0x00, 0x53, 0x2a, 0x00, 0x42, 0x0c, 0x00, 0x54, 0x2a, 0x40, 0x44, - 0xb3, 0x26, 0x2c, 0x22, 0x00, 0x48, 0xad, 0x0a, 0xd2, 0x22, 0x40, 0x5d, - 0x54, 0x13, 0x1f, 0x20, 0x00, 0x45, 0x9e, 0x63, 0x40, 0x2e, 0x40, 0x45, - 0xf7, 0xda, 0x21, 0x20, 0x00, 0x48, 0x0c, 0x39, 0xea, 0x2a, 0x40, 0x07, - 0xf8, 0x22, 0x0c, 0x4a, 0xdc, 0xae, 0x74, 0x2a, 0x00, 0x49, 0xb3, 0xc0, - 0xbf, 0x27, 0x40, 0x06, 0xef, 0x06, 0x06, 0x4a, 0xaa, 0xae, 0xfe, 0x24, - 0x40, 0x45, 0x12, 0x0b, 0xfc, 0x24, 0x00, 0xa6, 0x29, 0x44, 0xea, 0x2a, - 0xfd, 0x24, 0x00, 0x43, 0x0e, 0x0b, 0xf5, 0x24, 0x00, 0xb3, 0x0f, 0xb4, + 0x44, 0x0c, 0x08, 0x34, 0xf4, 0x01, 0x46, 0x5e, 0xe5, 0xc7, 0xf3, 0x41, + 0xa2, 0xb7, 0x01, 0x49, 0x8a, 0xbc, 0x13, 0xcc, 0x01, 0x59, 0x25, 0x25, + 0xf8, 0xf7, 0x01, 0x48, 0x6c, 0x2b, 0x26, 0x20, 0x00, 0xac, 0x78, 0x55, + 0xf7, 0x3e, 0xa9, 0x26, 0x00, 0x11, 0x69, 0x5f, 0x50, 0xb2, 0x42, 0x0a, + 0x72, 0xb6, 0x2e, 0xb4, 0x06, 0x4b, 0xcc, 0xaa, 0xb0, 0xce, 0x41, 0x02, + 0x5c, 0x00, 0x06, 0x4c, 0xfc, 0x98, 0xa5, 0xf6, 0x41, 0x44, 0x08, 0x48, + 0x7e, 0x2b, 0x00, 0x47, 0x09, 0x3e, 0x09, 0x00, 0xc0, 0x00, 0x80, 0x01, + 0xff, 0x43, 0x6a, 0x13, 0x88, 0x00, 0x00, 0x52, 0x39, 0x59, 0x89, 0x00, + 0x40, 0xd1, 0xba, 0x23, 0x00, 0xd3, 0xbb, 0x23, 0x00, 0xd7, 0xbc, 0x23, + 0x00, 0xd9, 0xbd, 0x23, 0x40, 0x49, 0x22, 0xbb, 0x9b, 0xcc, 0x01, 0x4f, + 0xf9, 0x6f, 0x09, 0xcc, 0x41, 0x44, 0x28, 0xf3, 0x81, 0xfb, 0x01, 0xd2, + 0x76, 0xfb, 0x01, 0xd3, 0x77, 0xfb, 0x01, 0xd4, 0x78, 0xfb, 0x01, 0xd5, + 0x79, 0xfb, 0x01, 0xd6, 0x7a, 0xfb, 0x01, 0xd7, 0x7b, 0xfb, 0x41, 0x45, + 0x08, 0xea, 0x85, 0xcc, 0x01, 0x04, 0xee, 0x07, 0x01, 0xff, 0x49, 0x42, + 0x5b, 0xaf, 0x23, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4f, 0x80, 0x70, + 0x91, 0xcc, 0x01, 0xb4, 0x01, 0xff, 0x4f, 0xf8, 0x07, 0x12, 0xce, 0x01, + 0x48, 0xfe, 0x07, 0x0f, 0xce, 0x41, 0x42, 0x17, 0x00, 0x15, 0x20, 0x00, + 0x05, 0x0d, 0x03, 0x01, 0xff, 0x47, 0x5a, 0xd7, 0x23, 0x2b, 0x00, 0x47, + 0x8a, 0xd9, 0xc3, 0x2b, 0x40, 0x44, 0xa8, 0x52, 0x6f, 0xf3, 0x01, 0x43, + 0x1e, 0xbc, 0x1d, 0xf4, 0x41, 0xe5, 0x73, 0xf5, 0x01, 0x59, 0x1f, 0x26, + 0x68, 0xf6, 0xc1, 0x00, 0x50, 0x0c, 0x12, 0x69, 0xf6, 0x41, 0x46, 0x18, + 0xe0, 0x3a, 0xf3, 0x01, 0x02, 0x40, 0x00, 0xec, 0x03, 0x49, 0xcb, 0xc0, + 0x7e, 0xf9, 0x01, 0x4a, 0xde, 0xb3, 0xd5, 0xf6, 0x01, 0x4a, 0x5a, 0xb5, + 0x9b, 0xf9, 0x01, 0x07, 0x16, 0x13, 0x06, 0x4b, 0x38, 0xa8, 0xec, 0x26, + 0x40, 0x08, 0xe6, 0x4a, 0xbf, 0x03, 0x4e, 0x7b, 0x21, 0x9d, 0x30, 0x00, + 0x07, 0x13, 0x06, 0x06, 0x55, 0x19, 0x41, 0x9e, 0x30, 0x40, 0xe1, 0x42, + 0x30, 0x80, 0x98, 0x03, 0xa2, 0x81, 0x03, 0xa4, 0xea, 0x02, 0xe5, 0x48, + 0x30, 0x00, 0xa7, 0xcf, 0x02, 0xa8, 0xb8, 0x02, 0xe9, 0x44, 0x30, 0x00, + 0xab, 0x9d, 0x02, 0xad, 0x86, 0x02, 0xee, 0x93, 0x30, 0x80, 0xec, 0x01, + 0xef, 0x4a, 0x30, 0x00, 0xb0, 0xd1, 0x01, 0xb2, 0xba, 0x01, 0xb3, 0x57, + 0xb4, 0x41, 0xf5, 0x46, 0x30, 0x00, 0x42, 0x4b, 0x65, 0x94, 0x30, 0x00, + 0xb7, 0x25, 0xb9, 0x17, 0xba, 0x01, 0xff, 0xe1, 0x56, 0x30, 0x00, 0xe5, + 0x5c, 0x30, 0x00, 0xe9, 0x58, 0x30, 0x00, 0xef, 0x5e, 0x30, 0x00, 0xf5, + 0x5a, 0x30, 0x40, 0xe1, 0x84, 0x30, 0x00, 0xef, 0x88, 0x30, 0x00, 0xf5, + 0x86, 0x30, 0x40, 0xe1, 0x8f, 0x30, 0x00, 0xe5, 0x91, 0x30, 0x00, 0xe9, + 0x90, 0x30, 0x00, 0xef, 0x92, 0x30, 0x40, 0xe1, 0x5f, 0x30, 0x00, 0xe5, + 0x66, 0x30, 0x00, 0xe9, 0x61, 0x30, 0x00, 0xef, 0x68, 0x30, 0x00, 0xf5, + 0x64, 0x30, 0x40, 0xe1, 0x55, 0x30, 0x00, 0xe5, 0x5b, 0x30, 0x00, 0xe9, + 0x57, 0x30, 0x00, 0x05, 0x5e, 0x07, 0x08, 0xef, 0x5d, 0x30, 0x00, 0xf5, + 0x59, 0x30, 0x40, 0xe1, 0x41, 0x30, 0x00, 0xe5, 0x47, 0x30, 0x00, 0xe9, + 0x43, 0x30, 0x00, 0xab, 0x2f, 0xef, 0x49, 0x30, 0x00, 0x42, 0x5c, 0x01, + 0x63, 0x30, 0x00, 0xf5, 0x45, 0x30, 0x00, 0xb7, 0x0f, 0xb9, 0x01, 0xff, + 0xe1, 0x83, 0x30, 0x00, 0xef, 0x87, 0x30, 0x00, 0xf5, 0x85, 0x30, 0x40, + 0xe1, 0x8e, 0x30, 0x00, 0xe5, 0x51, 0xb1, 0x01, 0xe9, 0x50, 0xb1, 0x01, + 0xef, 0x52, 0xb1, 0x41, 0xe1, 0x95, 0x30, 0x00, 0xe5, 0x96, 0x30, 0x00, + 0xef, 0x32, 0xb1, 0x41, 0xe1, 0x89, 0x30, 0x00, 0xe5, 0x8c, 0x30, 0x00, + 0xe9, 0x8a, 0x30, 0x00, 0xef, 0x8d, 0x30, 0x00, 0xf5, 0x8b, 0x30, 0x40, + 0xe1, 0x71, 0x30, 0x00, 0xe5, 0x7a, 0x30, 0x00, 0xe9, 0x74, 0x30, 0x00, + 0xef, 0x7d, 0x30, 0x00, 0xf5, 0x77, 0x30, 0x40, 0xe1, 0x6a, 0x30, 0x00, + 0xe5, 0x6d, 0x30, 0x00, 0xe9, 0x6b, 0x30, 0x00, 0xef, 0x6e, 0x30, 0x00, + 0xf5, 0x6c, 0x30, 0x40, 0xe1, 0x7e, 0x30, 0x00, 0xe5, 0x81, 0x30, 0x00, + 0xe9, 0x7f, 0x30, 0x00, 0xef, 0x82, 0x30, 0x00, 0xf5, 0x80, 0x30, 0x40, + 0xe1, 0x4b, 0x30, 0x00, 0xe5, 0x51, 0x30, 0x00, 0xe9, 0x4d, 0x30, 0x00, + 0xef, 0x53, 0x30, 0x00, 0xf5, 0x4f, 0x30, 0x40, 0xe1, 0x6f, 0x30, 0x00, + 0xe5, 0x78, 0x30, 0x00, 0xe9, 0x72, 0x30, 0x00, 0xef, 0x7b, 0x30, 0x00, + 0xf5, 0x75, 0x30, 0x40, 0xe1, 0x4c, 0x30, 0x00, 0xe5, 0x52, 0x30, 0x00, + 0xe9, 0x4e, 0x30, 0x00, 0xef, 0x54, 0x30, 0x00, 0xf5, 0x50, 0x30, 0x40, + 0xe1, 0x60, 0x30, 0x00, 0xe5, 0x67, 0x30, 0x00, 0xe9, 0x62, 0x30, 0x00, + 0xef, 0x69, 0x30, 0x00, 0xf5, 0x65, 0x30, 0x40, 0xe1, 0x70, 0x30, 0x00, + 0xe5, 0x79, 0x30, 0x00, 0xe9, 0x73, 0x30, 0x00, 0xef, 0x7c, 0x30, 0x00, + 0xf5, 0x76, 0x30, 0x40, 0x07, 0xb4, 0x84, 0x01, 0xff, 0x42, 0x48, 0x33, + 0x1f, 0xb1, 0x01, 0x42, 0x4d, 0x00, 0x01, 0xb0, 0x41, 0x44, 0xd8, 0xf6, + 0x23, 0xb1, 0x01, 0x44, 0x40, 0xf9, 0x9f, 0x30, 0x40, 0x80, 0x16, 0x8d, + 0x01, 0xff, 0x4b, 0x13, 0xa2, 0x60, 0xf4, 0x01, 0x4b, 0xf6, 0xa7, 0x84, + 0xf6, 0xc1, 0x00, 0x51, 0xf7, 0x59, 0x85, 0xf6, 0x41, 0x51, 0x4b, 0x5b, + 0x06, 0xf5, 0x01, 0x4c, 0xc4, 0x97, 0x81, 0x00, 0x00, 0x4c, 0xd8, 0x9b, + 0xa1, 0x26, 0x40, 0xa1, 0x9c, 0x17, 0xa2, 0x8f, 0x0f, 0x46, 0xd2, 0xe0, + 0x94, 0xf9, 0x01, 0xac, 0xeb, 0x0e, 0x10, 0x6a, 0x68, 0xf0, 0x03, 0xb2, + 0xe3, 0x03, 0x0b, 0x8a, 0xaa, 0x01, 0xff, 0xa1, 0xc9, 0x03, 0xa2, 0xb4, + 0x03, 0x02, 0x13, 0x05, 0x9a, 0x03, 0xa4, 0xe9, 0x02, 0x4a, 0x60, 0xaf, + 0xcf, 0x4d, 0x00, 0xa6, 0xd4, 0x02, 0xa7, 0xa1, 0x02, 0x50, 0x7a, 0x66, + 0xc7, 0x4d, 0x00, 0x02, 0x9e, 0x01, 0xfb, 0x01, 0x4a, 0x94, 0xb2, 0xfb, + 0x4d, 0x00, 0x02, 0xc3, 0x07, 0xe4, 0x01, 0xaf, 0xca, 0x01, 0xb0, 0xb5, + 0x01, 0x02, 0x88, 0x00, 0x9c, 0x01, 0xb3, 0x7e, 0xb4, 0x14, 0xb7, 0x06, + 0x4e, 0xdc, 0x82, 0xc3, 0x4d, 0x40, 0x46, 0x76, 0x8d, 0xc4, 0x4d, 0x00, + 0x52, 0x7b, 0x56, 0xd1, 0x4d, 0x40, 0x03, 0x31, 0x0c, 0x06, 0x47, 0xc9, + 0x12, 0xc9, 0x4d, 0x40, 0xa1, 0x47, 0xa3, 0x33, 0x46, 0x9e, 0xe1, 0xe4, + 0x4d, 0x00, 0x4b, 0x84, 0xa1, 0xf8, 0x4d, 0x00, 0x4b, 0x1b, 0xa3, 0xf9, + 0x4d, 0x00, 0x56, 0xd7, 0x36, 0xf3, 0x4d, 0x00, 0x4f, 0x50, 0x73, 0xf5, + 0x4d, 0x00, 0x4f, 0x8a, 0x75, 0xc1, 0x4d, 0x00, 0xb7, 0x01, 0xff, 0x47, + 0x90, 0xd4, 0xf7, 0x4d, 0x00, 0x43, 0x84, 0x09, 0xef, 0x4d, 0x40, 0x47, + 0xf9, 0xd4, 0xf1, 0x4d, 0x00, 0x4c, 0xfc, 0x95, 0xdd, 0x4d, 0x00, 0x4e, + 0x4e, 0x7f, 0xc0, 0x4d, 0x40, 0x4c, 0xb8, 0x91, 0xdc, 0x4d, 0x00, 0xb2, + 0x01, 0xff, 0x42, 0x24, 0x5b, 0xc6, 0x4d, 0x00, 0x4e, 0xa6, 0x7e, 0xf2, + 0x4d, 0x40, 0x05, 0x5e, 0x07, 0x0c, 0x4e, 0x08, 0x7f, 0xd6, 0x4d, 0x00, + 0x49, 0x78, 0xc5, 0xcb, 0x4d, 0x40, 0x4d, 0x03, 0x8c, 0xfd, 0x4d, 0x00, + 0x46, 0x60, 0xe6, 0xc8, 0x4d, 0x40, 0xb4, 0x06, 0x48, 0x0f, 0xd2, 0xf0, + 0x4d, 0x40, 0x44, 0x88, 0x00, 0xe0, 0x4d, 0x00, 0x43, 0x5d, 0x01, 0xd7, + 0x4d, 0x40, 0x44, 0xe7, 0x17, 0xca, 0x4d, 0x00, 0x47, 0x51, 0xdb, 0xe2, + 0x4d, 0x00, 0x4d, 0x66, 0x8e, 0xed, 0x4d, 0x40, 0x4a, 0xc6, 0xad, 0xe6, + 0x4d, 0x00, 0x02, 0x6e, 0x02, 0x01, 0xff, 0x47, 0xf7, 0x17, 0xe5, 0x4d, + 0x00, 0x47, 0x9a, 0x69, 0xee, 0x4d, 0x40, 0x45, 0x84, 0xeb, 0xce, 0x4d, + 0x00, 0x4b, 0xda, 0xa9, 0xda, 0x4d, 0x40, 0x46, 0xa8, 0xe0, 0xe9, 0x4d, + 0x00, 0x47, 0xf8, 0xd6, 0xde, 0x4d, 0x00, 0xae, 0x01, 0xff, 0x48, 0x5f, + 0xcb, 0xfc, 0x4d, 0x00, 0x46, 0x98, 0xe4, 0xd8, 0x4d, 0x40, 0x51, 0xe5, + 0x5a, 0xec, 0x4d, 0x00, 0xb2, 0x01, 0xff, 0x43, 0x0d, 0x08, 0xd5, 0x4d, + 0x00, 0x04, 0xc7, 0x57, 0x01, 0xff, 0xb0, 0x06, 0x46, 0x60, 0xe6, 0xd9, + 0x4d, 0x40, 0xaf, 0x06, 0x4c, 0x04, 0x8c, 0xdb, 0x4d, 0x40, 0x48, 0x18, + 0x55, 0xcd, 0x4d, 0x00, 0x43, 0x15, 0x01, 0xe1, 0x4d, 0x40, 0x49, 0xe9, + 0xbd, 0xcc, 0x4d, 0x00, 0x48, 0xcf, 0xce, 0xd0, 0x4d, 0x40, 0x55, 0x9a, + 0x3b, 0xe3, 0x4d, 0x00, 0xa5, 0x14, 0xa9, 0x06, 0x47, 0xe0, 0xdc, 0xdf, + 0x4d, 0x40, 0x59, 0x89, 0x25, 0xc2, 0x4d, 0x00, 0x48, 0xdf, 0xd0, 0xfa, + 0x4d, 0x40, 0x46, 0xa8, 0xe0, 0xe8, 0x4d, 0x00, 0x49, 0x49, 0xc1, 0xe7, + 0x4d, 0x00, 0x49, 0xaa, 0xc6, 0xf4, 0x4d, 0x40, 0x4c, 0xe0, 0x96, 0xeb, + 0x4d, 0x00, 0xae, 0x01, 0xff, 0x45, 0x60, 0xec, 0xc5, 0x4d, 0x00, 0x4a, + 0x58, 0xb7, 0xd3, 0x4d, 0x40, 0x50, 0x7a, 0x65, 0xff, 0x4d, 0x00, 0x4d, + 0xa9, 0x88, 0xd4, 0x4d, 0x00, 0x4b, 0x0f, 0xa7, 0xea, 0x4d, 0x40, 0x48, + 0x0f, 0xca, 0xf6, 0x4d, 0x00, 0x4f, 0x9e, 0x70, 0xfe, 0x4d, 0x00, 0x47, + 0xbe, 0xda, 0xd2, 0x4d, 0x40, 0xe2, 0x3f, 0xf3, 0x01, 0x57, 0x4f, 0x31, + 0xb9, 0x22, 0x40, 0x02, 0x04, 0x2d, 0xdf, 0x0a, 0x02, 0x08, 0x02, 0xc2, + 0x0a, 0xa8, 0x99, 0x09, 0x02, 0x2c, 0x39, 0x84, 0x09, 0xab, 0xd3, 0x07, + 0xad, 0xcd, 0x06, 0xae, 0xa4, 0x05, 0x02, 0xd4, 0x33, 0x93, 0x05, 0xb2, + 0x8f, 0x04, 0xb3, 0xef, 0x02, 0xb4, 0xd2, 0x01, 0x02, 0xf5, 0x3b, 0xb9, + 0x01, 0xb7, 0x52, 0xb9, 0x01, 0xff, 0x02, 0x04, 0x2d, 0x31, 0x02, 0xd4, + 0x33, 0x15, 0x02, 0xf5, 0x3b, 0x01, 0xff, 0xd1, 0xe3, 0xb0, 0x01, 0xd2, + 0xe4, 0xb0, 0x01, 0xd3, 0xe5, 0xb0, 0x01, 0xd4, 0xe6, 0xb0, 0x41, 0xd1, + 0xe7, 0xb0, 0x01, 0xd2, 0xe8, 0xb0, 0x01, 0xd3, 0xe9, 0xb0, 0x01, 0xd4, + 0xea, 0xb0, 0x01, 0xd5, 0xeb, 0xb0, 0x01, 0xd6, 0xec, 0xb0, 0x41, 0xd1, + 0xdd, 0xb0, 0x01, 0xd2, 0xde, 0xb0, 0x01, 0xd3, 0xdf, 0xb0, 0x01, 0xd4, + 0xe0, 0xb0, 0x01, 0xd5, 0xe1, 0xb0, 0x01, 0x42, 0xe0, 0x49, 0xe2, 0xb0, + 0x41, 0x02, 0x04, 0x2d, 0x4d, 0x02, 0x08, 0x02, 0x39, 0x02, 0x2c, 0x39, + 0x21, 0x02, 0xd4, 0x33, 0x01, 0xff, 0xd1, 0x16, 0xb1, 0x01, 0xd2, 0x17, + 0xb1, 0x01, 0xd3, 0x18, 0xb1, 0x01, 0xd4, 0x19, 0xb1, 0x01, 0xd5, 0x1a, + 0xb1, 0x01, 0xd6, 0x1b, 0xb1, 0x01, 0xd7, 0x1c, 0xb1, 0x41, 0xd1, 0x0d, + 0xb1, 0x01, 0xd2, 0x0e, 0xb1, 0x01, 0xd3, 0x0f, 0xb1, 0x01, 0xd4, 0x10, + 0xb1, 0x01, 0xd5, 0x11, 0xb1, 0x41, 0xd1, 0x12, 0xb1, 0x01, 0xd2, 0x13, + 0xb1, 0x01, 0xd3, 0x14, 0xb1, 0x01, 0xd4, 0x15, 0xb1, 0x41, 0xd1, 0x08, + 0xb1, 0x01, 0xd2, 0x09, 0xb1, 0x01, 0xd3, 0x0a, 0xb1, 0x01, 0xd4, 0x0b, + 0xb1, 0x01, 0xd5, 0x0c, 0xb1, 0x41, 0xd1, 0x0a, 0xb0, 0x01, 0xd2, 0x0b, + 0xb0, 0x01, 0xd3, 0x0c, 0xb0, 0x01, 0xd4, 0x0d, 0xb0, 0x01, 0xd5, 0x0e, + 0xb0, 0x41, 0x02, 0x04, 0x2d, 0x85, 0x01, 0x02, 0x08, 0x02, 0x5d, 0x02, + 0x2c, 0x39, 0x3d, 0x02, 0xd4, 0x33, 0x1b, 0x02, 0xf5, 0x3b, 0x01, 0xff, + 0xd1, 0x69, 0xb0, 0x01, 0xd2, 0x6a, 0xb0, 0x01, 0xd3, 0x6b, 0xb0, 0x01, + 0xd4, 0x6c, 0xb0, 0x01, 0x42, 0x1e, 0x00, 0x6d, 0xb0, 0x41, 0xd1, 0x77, + 0xb0, 0x01, 0xd2, 0x78, 0xb0, 0x01, 0xd3, 0x79, 0xb0, 0x01, 0xd4, 0x7a, + 0xb0, 0x01, 0xd5, 0x7b, 0xb0, 0x01, 0xd6, 0x7c, 0xb0, 0x01, 0x42, 0x71, + 0x00, 0x7d, 0xb0, 0x41, 0xd1, 0x62, 0xb0, 0x01, 0xd2, 0x63, 0xb0, 0x01, + 0xd3, 0x64, 0xb0, 0x01, 0xd4, 0x65, 0xb0, 0x01, 0xd5, 0x66, 0xb0, 0x01, + 0xd6, 0x67, 0xb0, 0x01, 0xd7, 0x68, 0xb0, 0x41, 0xd1, 0x6e, 0xb0, 0x01, + 0xd2, 0x6f, 0xb0, 0x01, 0xd3, 0x70, 0xb0, 0x01, 0xd4, 0x71, 0xb0, 0x01, + 0xd5, 0x72, 0xb0, 0x01, 0xd6, 0x73, 0xb0, 0x01, 0xd7, 0x74, 0xb0, 0x01, + 0xd8, 0x75, 0xb0, 0x01, 0xd9, 0x76, 0xb0, 0x41, 0xd1, 0x5e, 0xb0, 0x01, + 0xd2, 0x5f, 0xb0, 0x01, 0xd3, 0x60, 0xb0, 0x01, 0xd4, 0x61, 0xb0, 0x41, + 0x02, 0x04, 0x2d, 0x79, 0x02, 0x08, 0x02, 0x61, 0x02, 0x2c, 0x39, 0x45, + 0x02, 0xd4, 0x33, 0x25, 0x02, 0xf5, 0x3b, 0x01, 0xff, 0xd1, 0x4a, 0xb0, + 0x01, 0xd2, 0x4b, 0xb0, 0x01, 0xd3, 0x4c, 0xb0, 0x01, 0xd4, 0x4d, 0xb0, + 0x01, 0xd5, 0x4e, 0xb0, 0x01, 0xd6, 0x4f, 0xb0, 0x01, 0xd7, 0x50, 0xb0, + 0x01, 0xd8, 0x51, 0xb0, 0x41, 0xd1, 0x57, 0xb0, 0x01, 0xd2, 0x58, 0xb0, + 0x01, 0xd3, 0x59, 0xb0, 0x01, 0xd4, 0x5a, 0xb0, 0x01, 0xd5, 0x5b, 0xb0, + 0x01, 0xd6, 0x5c, 0xb0, 0x01, 0xd7, 0x5d, 0xb0, 0x41, 0xd1, 0x44, 0xb0, + 0x01, 0xd2, 0x45, 0xb0, 0x01, 0xd3, 0x46, 0xb0, 0x01, 0xd4, 0x47, 0xb0, + 0x01, 0xd5, 0x48, 0xb0, 0x01, 0xd6, 0x49, 0xb0, 0x41, 0xd1, 0x52, 0xb0, + 0x01, 0xd2, 0x53, 0xb0, 0x01, 0xd3, 0x54, 0xb0, 0x01, 0xd4, 0x55, 0xb0, + 0x01, 0xd5, 0x56, 0xb0, 0x41, 0xd1, 0x3c, 0xb0, 0x01, 0xd2, 0x3d, 0xb0, + 0x01, 0xd3, 0x3e, 0xb0, 0x01, 0xd4, 0x3f, 0xb0, 0x01, 0xd5, 0x40, 0xb0, + 0x01, 0xd6, 0x41, 0xb0, 0x01, 0xd7, 0x42, 0xb0, 0x01, 0xd8, 0x43, 0xb0, + 0x41, 0x02, 0x04, 0x2d, 0x6d, 0x02, 0x08, 0x02, 0x59, 0x02, 0x2c, 0x39, + 0x39, 0x02, 0xd4, 0x33, 0x1d, 0x02, 0xf5, 0x3b, 0x01, 0xff, 0xd1, 0xf8, + 0xb0, 0x01, 0xd2, 0xf9, 0xb0, 0x01, 0xd3, 0xfa, 0xb0, 0x01, 0xd4, 0xfb, + 0xb0, 0x01, 0xd5, 0xfc, 0xb0, 0x01, 0xd6, 0xfd, 0xb0, 0x41, 0xd1, 0x02, + 0xb1, 0x01, 0xd2, 0x03, 0xb1, 0x01, 0xd3, 0x04, 0xb1, 0x01, 0xd4, 0x05, + 0xb1, 0x01, 0xd5, 0x06, 0xb1, 0x01, 0xd6, 0x07, 0xb1, 0x41, 0xd1, 0xf1, + 0xb0, 0x01, 0xd2, 0xf2, 0xb0, 0x01, 0xd3, 0xf3, 0xb0, 0x01, 0xd4, 0xf4, + 0xb0, 0x01, 0xd5, 0xf5, 0xb0, 0x01, 0xd6, 0xf6, 0xb0, 0x01, 0xd7, 0xf7, + 0xb0, 0x41, 0xd1, 0xfe, 0xb0, 0x01, 0xd2, 0xff, 0xb0, 0x01, 0xd3, 0x00, + 0xb1, 0x01, 0xd4, 0x01, 0xb1, 0x41, 0xd1, 0xed, 0xb0, 0x01, 0xd2, 0xee, + 0xb0, 0x01, 0xd3, 0xef, 0xb0, 0x01, 0xd4, 0xf0, 0xb0, 0x41, 0xd1, 0x14, + 0xb0, 0x01, 0xd2, 0x15, 0xb0, 0x01, 0xd3, 0x16, 0xb0, 0x41, 0x07, 0x8d, + 0xd3, 0x99, 0x01, 0x02, 0x04, 0x2d, 0x71, 0x02, 0x08, 0x02, 0x4f, 0x02, + 0x2c, 0x39, 0x29, 0x02, 0xd4, 0x33, 0x11, 0x02, 0xf5, 0x3b, 0x01, 0xff, + 0xd1, 0x8f, 0xb0, 0x01, 0xd2, 0x90, 0xb0, 0x01, 0xd3, 0x91, 0xb0, 0x41, + 0xd1, 0x99, 0xb0, 0x01, 0xd2, 0x9a, 0xb0, 0x01, 0xd3, 0x9b, 0xb0, 0x01, + 0xd4, 0x9c, 0xb0, 0x01, 0xd5, 0x9d, 0xb0, 0x41, 0xd1, 0x87, 0xb0, 0x01, + 0xd2, 0x88, 0xb0, 0x01, 0xd3, 0x89, 0xb0, 0x01, 0xd4, 0x8a, 0xb0, 0x01, + 0xd5, 0x8b, 0xb0, 0x01, 0xd6, 0x8c, 0xb0, 0x01, 0xd7, 0x8d, 0xb0, 0x01, + 0x42, 0x77, 0x00, 0x8e, 0xb0, 0x41, 0xd1, 0x92, 0xb0, 0x01, 0xd2, 0x93, + 0xb0, 0x01, 0xd3, 0x94, 0xb0, 0x01, 0xd4, 0x95, 0xb0, 0x01, 0xd5, 0x96, + 0xb0, 0x01, 0xd6, 0x97, 0xb0, 0x01, 0x42, 0x4d, 0x03, 0x98, 0xb0, 0x41, + 0xd1, 0x7e, 0xb0, 0x01, 0xd2, 0x7f, 0xb0, 0x01, 0xd3, 0x80, 0xb0, 0x01, + 0xd4, 0x81, 0xb0, 0x01, 0xd5, 0x82, 0xb0, 0x01, 0xd6, 0x83, 0xb0, 0x01, + 0xd7, 0x84, 0xb0, 0x01, 0xd8, 0x85, 0xb0, 0x01, 0xd9, 0x86, 0xb0, 0x41, + 0xd1, 0x1d, 0xb1, 0x01, 0xd2, 0x1e, 0xb1, 0x41, 0x02, 0x04, 0x2d, 0x63, + 0x02, 0x08, 0x02, 0x51, 0x02, 0x2c, 0x39, 0x31, 0x02, 0xd4, 0x33, 0x15, + 0x02, 0xf5, 0x3b, 0x01, 0xff, 0xd1, 0xd0, 0xb0, 0x01, 0xd2, 0xd1, 0xb0, + 0x01, 0xd3, 0xd2, 0xb0, 0x01, 0xd4, 0xd3, 0xb0, 0x41, 0xd1, 0xd7, 0xb0, + 0x01, 0xd2, 0xd8, 0xb0, 0x01, 0xd3, 0xd9, 0xb0, 0x01, 0xd4, 0xda, 0xb0, + 0x01, 0xd5, 0xdb, 0xb0, 0x01, 0xd6, 0xdc, 0xb0, 0x41, 0xd1, 0xc9, 0xb0, + 0x01, 0xd2, 0xca, 0xb0, 0x01, 0xd3, 0xcb, 0xb0, 0x01, 0xd4, 0xcc, 0xb0, + 0x01, 0xd5, 0xcd, 0xb0, 0x01, 0xd6, 0xce, 0xb0, 0x01, 0xd7, 0xcf, 0xb0, + 0x41, 0xd1, 0xd4, 0xb0, 0x01, 0xd2, 0xd5, 0xb0, 0x01, 0x42, 0x6c, 0x00, + 0xd6, 0xb0, 0x41, 0xd1, 0xc2, 0xb0, 0x01, 0xd2, 0xc3, 0xb0, 0x01, 0xd3, + 0xc4, 0xb0, 0x01, 0xd4, 0xc5, 0xb0, 0x01, 0xd5, 0xc6, 0xb0, 0x01, 0xd6, + 0xc7, 0xb0, 0x01, 0xd7, 0xc8, 0xb0, 0x41, 0x02, 0x04, 0x2d, 0x77, 0x02, + 0x08, 0x02, 0x5b, 0x02, 0x2c, 0x39, 0x37, 0x02, 0xd4, 0x33, 0x21, 0x02, + 0xf5, 0x3b, 0x01, 0xff, 0xd1, 0x2b, 0xb0, 0x01, 0xd2, 0x2c, 0xb0, 0x01, + 0xd3, 0x2d, 0xb0, 0x01, 0xd4, 0x2e, 0xb0, 0x01, 0xd5, 0x2f, 0xb0, 0x01, + 0xd6, 0x30, 0xb0, 0x01, 0xd7, 0x31, 0xb0, 0x41, 0xd1, 0x38, 0xb0, 0x01, + 0xd2, 0x39, 0xb0, 0x01, 0xd3, 0x3a, 0xb0, 0x01, 0x42, 0x45, 0x00, 0x3b, + 0xb0, 0x41, 0xd1, 0x23, 0xb0, 0x01, 0xd2, 0x24, 0xb0, 0x01, 0xd3, 0x25, + 0xb0, 0x01, 0xd4, 0x26, 0xb0, 0x01, 0xd5, 0x27, 0xb0, 0x01, 0xd6, 0x28, + 0xb0, 0x01, 0xd7, 0x29, 0xb0, 0x01, 0xd8, 0x2a, 0xb0, 0x41, 0xd1, 0x32, + 0xb0, 0x01, 0xd2, 0x33, 0xb0, 0x01, 0xd3, 0x34, 0xb0, 0x01, 0xd4, 0x35, + 0xb0, 0x01, 0xd5, 0x36, 0xb0, 0x01, 0xd6, 0x37, 0xb0, 0x41, 0xd1, 0x17, + 0xb0, 0x81, 0x26, 0xd2, 0x18, 0xb0, 0x01, 0xd3, 0x19, 0xb0, 0x01, 0xd4, + 0x1a, 0xb0, 0x01, 0xd5, 0x1b, 0xb0, 0x01, 0xd6, 0x1c, 0xb0, 0x01, 0xd7, + 0x1d, 0xb0, 0x01, 0xd8, 0x1e, 0xb0, 0x01, 0xd9, 0x1f, 0xb0, 0x01, 0x42, + 0x37, 0x01, 0x22, 0xb0, 0x41, 0xd0, 0x20, 0xb0, 0x01, 0xd1, 0x21, 0xb0, + 0x41, 0xd1, 0x06, 0xb0, 0x01, 0xd2, 0x07, 0xb0, 0x01, 0xd3, 0x08, 0xb0, + 0x01, 0xd4, 0x09, 0xb0, 0x41, 0x02, 0x04, 0x2d, 0x75, 0x02, 0x08, 0x02, + 0x55, 0x02, 0x2c, 0x39, 0x35, 0x02, 0xd4, 0x33, 0x11, 0x02, 0xf5, 0x3b, + 0x01, 0xff, 0xd1, 0xb0, 0xb0, 0x01, 0xd2, 0xb1, 0xb0, 0x01, 0xd3, 0xb2, + 0xb0, 0x41, 0xd1, 0xba, 0xb0, 0x01, 0xd2, 0xbb, 0xb0, 0x01, 0xd3, 0xbc, + 0xb0, 0x01, 0xd4, 0xbd, 0xb0, 0x01, 0xd5, 0xbe, 0xb0, 0x01, 0xd6, 0xbf, + 0xb0, 0x01, 0xd7, 0xc0, 0xb0, 0x01, 0xd8, 0xc1, 0xb0, 0x41, 0xd1, 0xa9, + 0xb0, 0x01, 0xd2, 0xaa, 0xb0, 0x01, 0xd3, 0xab, 0xb0, 0x01, 0xd4, 0xac, + 0xb0, 0x01, 0xd5, 0xad, 0xb0, 0x01, 0xd6, 0xae, 0xb0, 0x01, 0xd7, 0xaf, + 0xb0, 0x41, 0xd1, 0xb3, 0xb0, 0x01, 0xd2, 0xb4, 0xb0, 0x01, 0xd3, 0xb5, + 0xb0, 0x01, 0xd4, 0xb6, 0xb0, 0x01, 0xd5, 0xb7, 0xb0, 0x01, 0xd6, 0xb8, + 0xb0, 0x01, 0xd7, 0xb9, 0xb0, 0x41, 0xd1, 0x9e, 0xb0, 0x81, 0x20, 0xd2, + 0x9f, 0xb0, 0x01, 0xd3, 0xa0, 0xb0, 0x01, 0xd4, 0xa1, 0xb0, 0x01, 0xd5, + 0xa2, 0xb0, 0x01, 0xd6, 0xa3, 0xb0, 0x01, 0xd7, 0xa4, 0xb0, 0x01, 0xd8, + 0xa5, 0xb0, 0x01, 0xd9, 0xa6, 0xb0, 0x41, 0xd0, 0xa7, 0xb0, 0x01, 0xd1, + 0xa8, 0xb0, 0x41, 0xd1, 0x01, 0xb0, 0x01, 0xd2, 0x0f, 0xb0, 0x01, 0xd3, + 0x10, 0xb0, 0x01, 0xd4, 0x11, 0xb0, 0x01, 0xd5, 0x12, 0xb0, 0x01, 0xd6, + 0x13, 0xb0, 0x41, 0xd1, 0x02, 0xb0, 0x01, 0xd2, 0x03, 0xb0, 0x01, 0xd3, + 0x04, 0xb0, 0x01, 0x42, 0x15, 0x02, 0x05, 0xb0, 0x41, 0x47, 0xa7, 0xd7, + 0x81, 0xf6, 0x01, 0x57, 0x38, 0x31, 0xff, 0x2b, 0x00, 0xad, 0x01, 0xff, + 0x47, 0x15, 0x08, 0x88, 0x23, 0x00, 0x53, 0x8f, 0x4b, 0xd1, 0x26, 0x40, + 0xe5, 0xc0, 0xce, 0x01, 0x04, 0x3c, 0xf8, 0x01, 0xff, 0x07, 0x57, 0x24, + 0x9c, 0x06, 0xac, 0xe2, 0x01, 0x05, 0xb9, 0x00, 0xcb, 0x01, 0xb0, 0x06, + 0x4c, 0x44, 0x9c, 0xef, 0x05, 0x40, 0x05, 0xb3, 0x18, 0x2d, 0x0b, 0x3c, + 0x17, 0x01, 0xff, 0x03, 0x00, 0x0a, 0x18, 0x45, 0x68, 0xee, 0xbe, 0x05, + 0x00, 0x4b, 0x83, 0xa5, 0xc6, 0x05, 0x00, 0x45, 0xb2, 0xef, 0xc0, 0x05, + 0x00, 0x49, 0x1e, 0xc5, 0xc3, 0x05, 0x40, 0x43, 0x14, 0x5d, 0xf3, 0x05, + 0x00, 0x46, 0xd6, 0xe5, 0xf4, 0x05, 0x40, 0x07, 0x32, 0x90, 0x81, 0x01, + 0xa8, 0x56, 0x54, 0xcf, 0x45, 0x1e, 0xfb, 0x00, 0x45, 0x8b, 0xee, 0xbd, + 0x05, 0x00, 0x45, 0x58, 0x8f, 0xb7, 0x05, 0x00, 0xb1, 0x2f, 0x44, 0x30, + 0xf8, 0xbf, 0x05, 0x00, 0xb3, 0x06, 0x45, 0x74, 0xf1, 0xb5, 0x05, 0x40, + 0x44, 0xb2, 0xf0, 0xb6, 0x05, 0x00, 0xa8, 0x06, 0x46, 0x6f, 0x50, 0xc2, + 0x05, 0x40, 0x43, 0xc6, 0x48, 0xb0, 0x05, 0x80, 0x06, 0x46, 0x6f, 0x50, + 0xc1, 0x05, 0x40, 0x4b, 0x7d, 0x9c, 0xc8, 0x05, 0x40, 0x45, 0x4d, 0xe5, + 0xb8, 0x05, 0x80, 0x06, 0x45, 0x9c, 0xf1, 0xbb, 0x05, 0x40, 0x46, 0x2c, + 0xde, 0xc7, 0x05, 0x40, 0x05, 0x7b, 0xea, 0x13, 0x44, 0xf7, 0xec, 0xb4, + 0x05, 0x00, 0x44, 0x06, 0xed, 0xb9, 0x05, 0xc0, 0x00, 0x4e, 0xb0, 0x78, + 0xba, 0x05, 0x40, 0x45, 0x58, 0x8f, 0xb2, 0x05, 0x00, 0x46, 0x4c, 0xe5, + 0xb3, 0x05, 0x00, 0x45, 0xb1, 0xf0, 0xb1, 0x05, 0x40, 0x4d, 0xb2, 0x87, + 0xc9, 0x05, 0x00, 0x48, 0x0f, 0xcf, 0xbc, 0x05, 0x40, 0x49, 0x76, 0xc1, + 0xc5, 0x05, 0x00, 0x4d, 0xe1, 0x89, 0xaf, 0x05, 0x00, 0x49, 0x35, 0xc6, + 0xc4, 0x05, 0x40, 0x06, 0x14, 0x06, 0x2c, 0x08, 0xde, 0x11, 0x01, 0xff, + 0x4a, 0xe0, 0xac, 0x4f, 0xfb, 0x00, 0x08, 0xa7, 0xd2, 0x01, 0xff, 0x07, + 0x3b, 0x01, 0x0c, 0x47, 0x11, 0xdd, 0xf1, 0x05, 0x00, 0x4d, 0x50, 0x8f, + 0x1f, 0xfb, 0x40, 0x43, 0x28, 0x10, 0xf0, 0x05, 0x00, 0x43, 0xfd, 0x54, + 0xf2, 0x05, 0x40, 0xa1, 0xcd, 0x03, 0x43, 0xe5, 0x09, 0xd1, 0x05, 0x80, + 0xb4, 0x03, 0x45, 0x6d, 0x4c, 0xd3, 0x05, 0x80, 0xa6, 0x03, 0x06, 0x7c, + 0x2e, 0xf5, 0x02, 0x45, 0x5a, 0xb0, 0xd2, 0x05, 0x80, 0xe7, 0x02, 0x42, + 0xb0, 0x01, 0xd4, 0x05, 0x80, 0xd5, 0x02, 0x43, 0x15, 0x54, 0xdb, 0x05, + 0x80, 0xbc, 0x02, 0x45, 0xe5, 0xac, 0xdc, 0x05, 0x80, 0xae, 0x02, 0x43, + 0xb4, 0x05, 0xde, 0x05, 0x80, 0xa0, 0x02, 0x43, 0x18, 0x24, 0xe0, 0x05, + 0x80, 0x92, 0x02, 0x42, 0x6f, 0x02, 0xe4, 0x05, 0x80, 0xf9, 0x01, 0x43, + 0x8d, 0xfa, 0xe7, 0x05, 0x80, 0xeb, 0x01, 0x44, 0x8a, 0x69, 0xe8, 0x05, + 0x80, 0xdd, 0x01, 0xb3, 0x9a, 0x01, 0xb4, 0x71, 0x43, 0x28, 0x10, 0xd5, + 0x05, 0x80, 0x59, 0x05, 0x37, 0xf2, 0x25, 0x43, 0xfd, 0x54, 0xd9, 0x05, + 0x80, 0x0d, 0x45, 0xf7, 0x54, 0xd6, 0x05, 0xc0, 0x00, 0x4c, 0x2c, 0x90, + 0x36, 0xfb, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x46, 0x32, 0x90, 0x39, + 0xfb, 0x00, 0x45, 0xf6, 0xec, 0x1d, 0xfb, 0x40, 0x44, 0x67, 0x00, 0x21, + 0xfb, 0x00, 0x45, 0x6d, 0x4c, 0x22, 0xfb, 0x00, 0x49, 0x79, 0xbe, 0x26, + 0xfb, 0x00, 0x42, 0xb0, 0x01, 0x23, 0xfb, 0x00, 0x43, 0x15, 0x54, 0x24, + 0xfb, 0x00, 0x45, 0xe5, 0xac, 0x25, 0xfb, 0x00, 0x44, 0x8a, 0x69, 0x27, + 0xfb, 0x00, 0x43, 0xbd, 0x2b, 0x28, 0xfb, 0x40, 0x06, 0x50, 0x00, 0x01, + 0xff, 0x46, 0x32, 0x90, 0x35, 0xfb, 0x00, 0x45, 0x05, 0xed, 0x4b, 0xfb, + 0x40, 0x42, 0x2f, 0x08, 0xea, 0x05, 0x80, 0x1a, 0x42, 0x14, 0x06, 0xd8, + 0x05, 0x80, 0x0d, 0x44, 0x6b, 0xf1, 0xe6, 0x05, 0xc0, 0x00, 0x4c, 0x2c, + 0x90, 0x46, 0xfb, 0x40, 0x4c, 0x2c, 0x90, 0x38, 0xfb, 0x40, 0x4c, 0x2c, + 0x90, 0x4a, 0xfb, 0x40, 0x45, 0x49, 0xea, 0xe1, 0x05, 0x80, 0x33, 0x43, + 0x48, 0x17, 0xe9, 0x05, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x46, + 0x32, 0x90, 0x49, 0xfb, 0x80, 0x0f, 0xb3, 0x01, 0xff, 0x47, 0x6e, 0x50, + 0x2a, 0xfb, 0x00, 0x46, 0x6f, 0x50, 0x2b, 0xfb, 0x40, 0x06, 0xa7, 0x14, + 0x01, 0xff, 0x47, 0x6e, 0x50, 0x2c, 0xfb, 0x00, 0x46, 0x6f, 0x50, 0x2d, + 0xfb, 0x40, 0x4c, 0x2c, 0x90, 0x41, 0xfb, 0x40, 0x4c, 0x2c, 0x90, 0x48, + 0xfb, 0x40, 0x4c, 0x2c, 0x90, 0x47, 0xfb, 0x40, 0x06, 0x50, 0x00, 0x01, + 0xff, 0x46, 0x32, 0x90, 0x44, 0xfb, 0x00, 0x44, 0x30, 0xf8, 0x4e, 0xfb, + 0x40, 0x4c, 0x2c, 0x90, 0x40, 0xfb, 0x40, 0x4c, 0x2c, 0x90, 0x3e, 0xfb, + 0x40, 0x4c, 0x2c, 0x90, 0x3c, 0xfb, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, + 0x46, 0x32, 0x90, 0x3b, 0xfb, 0x00, 0x44, 0x30, 0xf8, 0x4d, 0xfb, 0x40, + 0x4b, 0x38, 0x9d, 0x34, 0xfb, 0x00, 0xf4, 0xd7, 0x05, 0x40, 0x4c, 0x2c, + 0x90, 0x32, 0xfb, 0x40, 0x43, 0x15, 0x54, 0xda, 0x05, 0x80, 0x1f, 0x43, + 0xb4, 0x05, 0xdd, 0x05, 0x00, 0x43, 0x18, 0x24, 0xdf, 0x05, 0x00, 0x42, + 0x6f, 0x02, 0xe3, 0x05, 0x80, 0x06, 0x45, 0x6a, 0xf1, 0xe5, 0x05, 0x40, + 0x4c, 0x2c, 0x90, 0x43, 0xfb, 0x40, 0x4c, 0x2c, 0x90, 0x3a, 0xfb, 0x40, + 0x4c, 0x2c, 0x90, 0x33, 0xfb, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x46, + 0x32, 0x90, 0x31, 0xfb, 0x00, 0x44, 0x30, 0xf8, 0x4c, 0xfb, 0x40, 0xac, + 0x06, 0x43, 0xa0, 0x1b, 0xe2, 0x05, 0x40, 0x42, 0x69, 0x00, 0xd0, 0x05, + 0x80, 0x11, 0x0a, 0x62, 0xb7, 0x01, 0xff, 0x44, 0x68, 0x4c, 0x20, 0xfb, + 0x00, 0x49, 0x21, 0x75, 0x29, 0xfb, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, + 0x45, 0x3e, 0x9d, 0x30, 0xfb, 0x00, 0x45, 0x58, 0x8f, 0x2e, 0xfb, 0x00, + 0x46, 0x4c, 0xe5, 0x2f, 0xfb, 0x40, 0x4c, 0x1c, 0x91, 0xa2, 0x05, 0x00, + 0xa4, 0xcb, 0x01, 0x47, 0xc0, 0xd6, 0x91, 0x05, 0x00, 0x03, 0x00, 0x0a, + 0xad, 0x01, 0x44, 0x70, 0xf6, 0xac, 0x05, 0x00, 0xad, 0x8b, 0x01, 0x43, + 0xa8, 0x16, 0xab, 0x05, 0x00, 0x02, 0xe0, 0x09, 0x75, 0x02, 0x11, 0x15, + 0x65, 0x45, 0x58, 0x52, 0x97, 0x05, 0x00, 0xb3, 0x51, 0xb4, 0x31, 0x02, + 0x4d, 0x00, 0x21, 0xba, 0x01, 0xff, 0xa1, 0x06, 0x44, 0x78, 0xf6, 0xae, + 0x05, 0x40, 0x04, 0x24, 0xf8, 0x06, 0x43, 0x10, 0x15, 0x98, 0x05, 0x40, + 0x45, 0x74, 0xec, 0x95, 0x05, 0x00, 0x45, 0x2d, 0xde, 0x94, 0x05, 0x40, + 0x4c, 0x08, 0x99, 0xaa, 0x05, 0x00, 0x43, 0xf8, 0x05, 0x9a, 0x05, 0x40, + 0xa5, 0x06, 0x45, 0x7d, 0xed, 0x96, 0x05, 0x40, 0x06, 0xb4, 0xe3, 0x06, + 0x43, 0x1f, 0x25, 0x9b, 0x05, 0x40, 0x46, 0xe0, 0xe1, 0xa0, 0x05, 0x00, + 0x46, 0x52, 0xe5, 0xa9, 0x05, 0x40, 0x44, 0xb2, 0xf0, 0x92, 0x05, 0x00, + 0x49, 0x09, 0xbf, 0x93, 0x05, 0x40, 0x43, 0x35, 0xbb, 0xa8, 0x05, 0x00, + 0x49, 0x97, 0xc4, 0x9f, 0x05, 0x40, 0x44, 0x9c, 0xf8, 0x99, 0x05, 0x00, + 0x43, 0x80, 0x1f, 0xa1, 0x05, 0x40, 0x47, 0x5f, 0xd4, 0xa4, 0x05, 0x00, + 0x45, 0x0b, 0xec, 0xa5, 0x05, 0x80, 0x06, 0x44, 0x5d, 0xd4, 0xa3, 0x05, + 0x40, 0x47, 0xfa, 0xd2, 0xa6, 0x05, 0x40, 0x43, 0x14, 0x5d, 0x9c, 0x05, + 0x80, 0x06, 0x46, 0xd6, 0xe5, 0x9e, 0x05, 0x40, 0x47, 0x24, 0xd3, 0x9d, + 0x05, 0x40, 0x44, 0x4a, 0x4e, 0xa7, 0x05, 0x00, 0x43, 0x94, 0x54, 0xad, + 0x05, 0x40, 0xa4, 0xdb, 0x06, 0xb2, 0xaa, 0x06, 0x03, 0x3e, 0x16, 0x01, + 0xff, 0xa1, 0xf6, 0x05, 0xa2, 0xb9, 0x05, 0xa3, 0x83, 0x05, 0xa4, 0xca, + 0x04, 0xa5, 0x8a, 0x04, 0xa6, 0xf1, 0x03, 0x4b, 0xef, 0x63, 0x1a, 0x27, + 0x00, 0xa8, 0xdc, 0x03, 0x54, 0xed, 0x16, 0x79, 0xf6, 0x01, 0xac, 0x81, + 0x03, 0xad, 0xf2, 0x02, 0x06, 0xb4, 0x01, 0xc1, 0x02, 0xaf, 0xac, 0x02, + 0x49, 0x21, 0x75, 0x95, 0x27, 0x00, 0xb2, 0xf1, 0x01, 0xb3, 0x81, 0x01, + 0xb4, 0x4d, 0x02, 0x50, 0x02, 0x32, 0x4c, 0x32, 0x00, 0x5a, 0x27, 0x00, + 0xb7, 0x01, 0xff, 0x5c, 0x74, 0x18, 0xbd, 0x27, 0x00, 0x05, 0xae, 0x02, + 0x06, 0x5b, 0xf8, 0x1c, 0x94, 0x27, 0x40, 0x46, 0x12, 0x03, 0x87, 0xf7, + 0x01, 0x56, 0x8d, 0x35, 0xdb, 0x26, 0x00, 0x46, 0xfd, 0x05, 0x91, 0xf7, + 0xc1, 0x00, 0x63, 0xb8, 0x0a, 0x05, 0xce, 0x41, 0x69, 0x9a, 0x02, 0xae, + 0x27, 0x00, 0x11, 0xa4, 0x0c, 0x01, 0xff, 0x55, 0xd5, 0x01, 0x19, 0xf8, + 0x01, 0x5b, 0x49, 0x1d, 0x1d, 0xf8, 0x41, 0x09, 0xb1, 0x0d, 0x17, 0x5f, + 0x94, 0x06, 0x9e, 0x27, 0x00, 0x0e, 0x84, 0x2d, 0x01, 0xff, 0x4a, 0x92, + 0x2d, 0xd3, 0xf7, 0x01, 0x4d, 0xf6, 0x13, 0xd4, 0xf7, 0x41, 0x57, 0x24, + 0x30, 0xbb, 0x27, 0x00, 0x06, 0xba, 0x0d, 0x01, 0xff, 0x48, 0xca, 0x0d, + 0x3d, 0x27, 0x00, 0x51, 0xcf, 0x5f, 0x43, 0x27, 0x40, 0xa1, 0x5f, 0x5a, + 0xb9, 0x20, 0x71, 0xf6, 0x01, 0xa9, 0x36, 0x05, 0xc5, 0x21, 0x06, 0x46, + 0x67, 0xba, 0x48, 0x27, 0x40, 0x05, 0xe4, 0x19, 0x11, 0x0e, 0x00, 0x0f, + 0x01, 0xff, 0x43, 0x39, 0xd6, 0x65, 0xf6, 0x01, 0x49, 0xe0, 0xc6, 0x5d, + 0xf6, 0x41, 0x45, 0xce, 0x00, 0x98, 0x27, 0x00, 0x09, 0x9c, 0x01, 0x01, + 0xff, 0x43, 0x39, 0xd6, 0x67, 0xf6, 0x01, 0x49, 0xe0, 0xc6, 0x5f, 0xf6, + 0x41, 0x05, 0x32, 0x06, 0x11, 0x02, 0xd8, 0x04, 0x01, 0xff, 0x52, 0x8a, + 0x2d, 0xcc, 0xf7, 0x01, 0x4f, 0xf7, 0x1d, 0xb8, 0xf7, 0x41, 0x5d, 0x13, + 0x05, 0x5c, 0x27, 0x00, 0x64, 0x70, 0x0a, 0x5b, 0x27, 0x40, 0x45, 0x36, + 0x1a, 0xac, 0xf7, 0x01, 0x5d, 0xe4, 0x16, 0x7b, 0xf6, 0x41, 0x04, 0xc9, + 0x00, 0x06, 0x5c, 0xfc, 0x19, 0x9c, 0x27, 0x40, 0x10, 0xf8, 0x0b, 0x18, + 0x4b, 0xb8, 0x02, 0x99, 0x27, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, + 0x55, 0xd5, 0x01, 0x1a, 0xf8, 0x01, 0x5b, 0x49, 0x1d, 0x1e, 0xf8, 0x41, + 0x50, 0x88, 0x09, 0x71, 0x27, 0x00, 0x57, 0x19, 0x05, 0x6f, 0x27, 0x40, + 0x50, 0xca, 0x68, 0x1c, 0x27, 0x00, 0x52, 0xdf, 0x58, 0x2e, 0x27, 0x00, + 0x54, 0xc7, 0x48, 0x56, 0x2b, 0x40, 0x05, 0xe4, 0x19, 0x11, 0x0e, 0x00, + 0x0f, 0x01, 0xff, 0x43, 0x39, 0xd6, 0x64, 0xf6, 0x01, 0x49, 0xe0, 0xc6, + 0x5c, 0xf6, 0x41, 0x45, 0xce, 0x00, 0x9a, 0x27, 0x00, 0x09, 0x9c, 0x01, + 0x01, 0xff, 0x43, 0x39, 0xd6, 0x66, 0xf6, 0x01, 0x49, 0xe0, 0xc6, 0x5e, + 0xf6, 0x41, 0x49, 0x7c, 0x9d, 0x96, 0x27, 0x00, 0x4f, 0x79, 0x77, 0x16, + 0x27, 0x40, 0xa1, 0x44, 0x03, 0xc4, 0x00, 0x1f, 0x58, 0xb4, 0x2a, 0x73, + 0xf6, 0x01, 0x02, 0xd1, 0x00, 0x01, 0xff, 0x80, 0x06, 0x68, 0x9b, 0x02, + 0xad, 0x27, 0x40, 0x64, 0x0c, 0x05, 0x60, 0x27, 0x00, 0x64, 0x04, 0x0a, + 0x5f, 0x27, 0x40, 0x10, 0xf8, 0x0b, 0x11, 0x11, 0xa4, 0x0c, 0x01, 0xff, + 0x55, 0xd5, 0x01, 0x18, 0xf8, 0x01, 0x5b, 0x49, 0x1d, 0x1c, 0xf8, 0x41, + 0x50, 0x88, 0x09, 0x70, 0x27, 0x00, 0x57, 0x19, 0x05, 0x6e, 0x27, 0x40, + 0x4a, 0xc8, 0xb5, 0x55, 0x2b, 0x00, 0x49, 0x75, 0xa3, 0x47, 0xf5, 0x41, + 0x5e, 0xa9, 0x13, 0x63, 0x27, 0x00, 0x4e, 0x44, 0x71, 0x97, 0xfb, 0x41, + 0x04, 0xf9, 0x05, 0x06, 0x5b, 0xeb, 0x1d, 0x24, 0x27, 0x40, 0x52, 0x8a, + 0x2d, 0xca, 0xf7, 0x01, 0x4f, 0xf7, 0x1d, 0xb2, 0xf7, 0x41, 0x05, 0xc9, + 0x00, 0x17, 0x4a, 0x17, 0x14, 0xf0, 0xf7, 0x01, 0x10, 0xae, 0x00, 0x01, + 0xff, 0x48, 0x28, 0x05, 0x62, 0x27, 0x00, 0x46, 0x16, 0x08, 0x57, 0x27, + 0x40, 0x08, 0x33, 0x08, 0x0c, 0x4f, 0xf7, 0x1d, 0xbe, 0xf7, 0x01, 0x62, + 0xb0, 0x0d, 0x4b, 0x27, 0x40, 0x4a, 0x92, 0x2d, 0xcf, 0xf7, 0x01, 0x4d, + 0xf6, 0x13, 0xd1, 0xf7, 0x01, 0x56, 0xbb, 0x38, 0x38, 0x27, 0x40, 0x66, + 0x8d, 0x06, 0xa0, 0x27, 0x00, 0x4c, 0x8f, 0x34, 0x97, 0x27, 0x00, 0xaf, + 0x01, 0xff, 0x49, 0xba, 0x0e, 0xb2, 0xf4, 0x01, 0x05, 0x3d, 0x01, 0x11, + 0x13, 0xa2, 0x0c, 0x01, 0xff, 0x55, 0xd5, 0x01, 0x1b, 0xf8, 0x01, 0x5b, + 0x49, 0x1d, 0x1f, 0xf8, 0x41, 0x5d, 0x13, 0x05, 0x5e, 0x27, 0x00, 0x64, + 0x70, 0x0a, 0x5d, 0x27, 0x40, 0x02, 0xb0, 0x01, 0x23, 0x45, 0x13, 0x03, + 0x58, 0x2b, 0x80, 0x06, 0x65, 0x2c, 0x08, 0xa8, 0x27, 0x40, 0x06, 0x50, + 0x00, 0x06, 0x49, 0x2c, 0xbd, 0x59, 0x2b, 0x40, 0x4d, 0x90, 0x85, 0x57, + 0x2b, 0x00, 0x59, 0xc8, 0x27, 0xe3, 0x26, 0x40, 0x47, 0xff, 0x07, 0x14, + 0x27, 0x00, 0x4e, 0x88, 0x82, 0x46, 0x27, 0x40, 0x47, 0x6d, 0xd4, 0x18, + 0x27, 0x00, 0x04, 0x0d, 0x03, 0x01, 0xff, 0x80, 0x17, 0x0b, 0x2d, 0x1b, + 0x01, 0xff, 0x50, 0xe3, 0x24, 0xb9, 0x27, 0x00, 0x50, 0xb3, 0x02, 0xb8, + 0x27, 0x00, 0x50, 0x9f, 0x42, 0xb7, 0x27, 0x40, 0x07, 0xb2, 0x30, 0x06, + 0x45, 0xcf, 0x22, 0x64, 0x27, 0x40, 0x5e, 0x8b, 0x13, 0xa5, 0x27, 0x00, + 0x5c, 0xc0, 0x1a, 0xa6, 0x27, 0x40, 0x51, 0x36, 0x40, 0x74, 0xf6, 0x01, + 0x11, 0x8c, 0x52, 0x06, 0x47, 0xcb, 0x0d, 0x31, 0x27, 0x40, 0x43, 0x7a, + 0x0b, 0x9c, 0xf8, 0x81, 0x06, 0x4a, 0xee, 0xb7, 0x9d, 0xf8, 0x41, 0x80, + 0x01, 0xff, 0x44, 0x22, 0x00, 0x9e, 0xf8, 0x01, 0x45, 0x21, 0x78, 0x9f, + 0xf8, 0x41, 0x4f, 0x56, 0x6d, 0x49, 0xf6, 0x01, 0x02, 0xc6, 0x00, 0x01, + 0xff, 0x4a, 0x68, 0x9c, 0x9f, 0xf4, 0x01, 0x45, 0x2a, 0x0f, 0xf6, 0xfa, + 0x01, 0x05, 0x51, 0x00, 0x01, 0xff, 0x45, 0xce, 0x00, 0x98, 0xf4, 0x01, + 0x46, 0x43, 0x8a, 0x9d, 0xf4, 0x01, 0x4f, 0x01, 0x77, 0x94, 0xf3, 0x41, + 0x45, 0x3d, 0x3f, 0xa7, 0xf3, 0x01, 0x45, 0x3f, 0xc0, 0xa6, 0xfa, 0xc1, + 0x00, 0x51, 0x91, 0x59, 0xfc, 0x26, 0x40, 0x43, 0x83, 0x08, 0xe1, 0x2b, + 0x00, 0x02, 0x46, 0x00, 0x9a, 0x24, 0x08, 0x77, 0xcd, 0xe1, 0x1e, 0xad, + 0xad, 0x1e, 0xae, 0xd8, 0x01, 0x5b, 0x3c, 0x1e, 0x4b, 0xf6, 0x01, 0xb2, + 0xc5, 0x01, 0xb4, 0x06, 0x44, 0xd2, 0xae, 0x7b, 0xf7, 0x41, 0x4b, 0x32, + 0x9f, 0x23, 0xf4, 0x01, 0x04, 0x19, 0xd8, 0x01, 0xff, 0x07, 0x13, 0x06, + 0x27, 0x07, 0x37, 0x3c, 0x01, 0xff, 0x44, 0x4e, 0x12, 0xfc, 0x08, 0x01, + 0x43, 0x7a, 0x0b, 0xfb, 0x08, 0x81, 0x0f, 0xb4, 0x01, 0xff, 0x42, 0x92, + 0x01, 0xfd, 0x08, 0x01, 0x45, 0xe8, 0x1e, 0xfe, 0x08, 0x41, 0x48, 0x3e, + 0x12, 0xff, 0x08, 0x41, 0xa1, 0x79, 0x44, 0x20, 0xf5, 0xe1, 0x08, 0x01, + 0x4b, 0xd7, 0x9f, 0xe3, 0x08, 0x01, 0x45, 0x5a, 0xb0, 0xe2, 0x08, 0x01, + 0x42, 0xb0, 0x01, 0xe4, 0x08, 0x81, 0x5a, 0x44, 0xb0, 0xf6, 0xea, 0x08, + 0x01, 0x46, 0x8a, 0xe3, 0xeb, 0x08, 0x01, 0x43, 0xb4, 0x05, 0xec, 0x08, + 0x01, 0x43, 0x18, 0x24, 0xed, 0x08, 0x01, 0x42, 0x6f, 0x02, 0xf0, 0x08, + 0x01, 0x44, 0xf3, 0xcd, 0xf2, 0x08, 0x01, 0xb3, 0x20, 0xb4, 0x12, 0x43, + 0x1c, 0x8f, 0xe5, 0x08, 0x01, 0x44, 0xfd, 0x54, 0xe9, 0x08, 0x01, 0x44, + 0x58, 0xf9, 0xe6, 0x08, 0x41, 0x42, 0x3e, 0x2f, 0xf5, 0x08, 0x01, 0x43, + 0x48, 0x27, 0xe8, 0x08, 0x41, 0xa1, 0x06, 0x43, 0x48, 0x17, 0xf4, 0x08, + 0x41, 0x43, 0x95, 0xf0, 0xf1, 0x08, 0x01, 0x44, 0x4a, 0xea, 0xee, 0x08, + 0x41, 0x42, 0x53, 0x00, 0xe7, 0x08, 0x41, 0x44, 0x3b, 0x3f, 0xe0, 0x08, + 0x01, 0x42, 0x25, 0x1e, 0xef, 0x08, 0x41, 0x46, 0xba, 0xe0, 0xb4, 0xf5, + 0x01, 0xf0, 0x89, 0xfa, 0x41, 0xa4, 0xab, 0x1c, 0xa7, 0xce, 0x03, 0x0d, + 0x1a, 0x88, 0x82, 0x01, 0x05, 0xc4, 0xf1, 0x01, 0xff, 0x07, 0x13, 0x06, + 0x13, 0x4d, 0x3b, 0x8d, 0x34, 0x17, 0x00, 0x0b, 0xc7, 0x7a, 0x01, 0xff, + 0xe9, 0x32, 0x17, 0x00, 0xf5, 0x33, 0x17, 0x40, 0xe1, 0x20, 0x17, 0x00, + 0x42, 0x16, 0x00, 0x2a, 0x17, 0x00, 0x42, 0x7b, 0x08, 0x27, 0x17, 0x00, + 0x42, 0x24, 0x02, 0x24, 0x17, 0x00, 0x42, 0x22, 0x00, 0x31, 0x17, 0x00, + 0xe9, 0x21, 0x17, 0x00, 0x42, 0x1b, 0x02, 0x23, 0x17, 0x00, 0x42, 0x74, + 0x00, 0x2e, 0x17, 0x00, 0x42, 0x6c, 0x00, 0x2b, 0x17, 0x00, 0xae, 0x28, + 0x42, 0xe0, 0x09, 0x29, 0x17, 0x00, 0x42, 0x71, 0x00, 0x2d, 0x17, 0x00, + 0x42, 0x40, 0x06, 0x30, 0x17, 0x00, 0x42, 0x12, 0x00, 0x26, 0x17, 0x00, + 0xf5, 0x22, 0x17, 0x00, 0x42, 0xa9, 0x01, 0x2f, 0x17, 0x00, 0x42, 0xdf, + 0x23, 0x2c, 0x17, 0x40, 0xe1, 0x28, 0x17, 0x00, 0x42, 0x24, 0x02, 0x25, + 0x17, 0x40, 0x06, 0xef, 0x06, 0x80, 0x02, 0x07, 0x13, 0x06, 0x4a, 0x05, + 0xb9, 0x00, 0x3a, 0x05, 0x5a, 0x03, 0x19, 0x06, 0x74, 0x3b, 0x01, 0xff, + 0xe1, 0x1d, 0x0d, 0x01, 0xe5, 0x20, 0x0d, 0x01, 0xe9, 0x1e, 0x0d, 0x01, + 0xef, 0x21, 0x0d, 0x01, 0xf5, 0x1f, 0x0d, 0x41, 0x48, 0x47, 0xcc, 0x24, + 0x0d, 0x01, 0x02, 0x12, 0x00, 0x01, 0xff, 0x44, 0xad, 0x80, 0x25, 0x0d, + 0x01, 0x42, 0x2a, 0x05, 0x26, 0x0d, 0x01, 0x43, 0x91, 0x08, 0x27, 0x0d, + 0x41, 0x49, 0xe2, 0xc1, 0x23, 0x0d, 0x01, 0x45, 0x98, 0xf0, 0x22, 0x0d, + 0x41, 0xe1, 0x00, 0x0d, 0x01, 0x42, 0x16, 0x00, 0x01, 0x0d, 0x01, 0x42, + 0x37, 0x00, 0x06, 0x0d, 0x01, 0xa4, 0x95, 0x01, 0x42, 0x0c, 0x08, 0x09, + 0x0d, 0x01, 0x42, 0x24, 0x02, 0x12, 0x0d, 0x01, 0x42, 0x22, 0x00, 0x07, + 0x0d, 0x01, 0x42, 0x78, 0x1a, 0x05, 0x0d, 0x01, 0xab, 0x60, 0x42, 0x74, + 0x00, 0x13, 0x0d, 0x01, 0x42, 0x6c, 0x00, 0x14, 0x0d, 0x01, 0xae, 0x42, + 0x42, 0xe0, 0x09, 0x02, 0x0d, 0x01, 0xb2, 0x30, 0xb3, 0x24, 0xb4, 0x18, + 0x42, 0x61, 0x0b, 0x1c, 0x0d, 0x01, 0x42, 0xa9, 0x01, 0x16, 0x0d, 0x01, + 0x42, 0xdf, 0x23, 0x18, 0x0d, 0x01, 0x42, 0x59, 0x00, 0x0e, 0x0d, 0x41, + 0xe1, 0x03, 0x0d, 0x01, 0x42, 0x12, 0x00, 0x04, 0x0d, 0x41, 0xe1, 0x0f, + 0x0d, 0x01, 0x42, 0x22, 0x00, 0x10, 0x0d, 0x41, 0xe1, 0x0c, 0x0d, 0x01, + 0x42, 0x71, 0x00, 0x0d, 0x0d, 0x41, 0xe1, 0x15, 0x0d, 0x01, 0x42, 0x24, + 0x02, 0x1a, 0x0d, 0x01, 0x42, 0xdf, 0x23, 0x1b, 0x0d, 0x41, 0xe1, 0x11, + 0x0d, 0x01, 0x42, 0x22, 0x00, 0x08, 0x0d, 0x01, 0x05, 0x73, 0xed, 0x01, + 0xff, 0x42, 0xa9, 0x01, 0x17, 0x0d, 0x01, 0x42, 0xdf, 0x23, 0x19, 0x0d, + 0x41, 0xe1, 0x0a, 0x0d, 0x01, 0x42, 0x7b, 0x08, 0x0b, 0x0d, 0x41, 0x45, + 0x7e, 0x0b, 0x38, 0x0d, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x39, 0x0d, + 0x01, 0x43, 0x7a, 0x0b, 0x31, 0x0d, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, + 0x80, 0x1f, 0x30, 0x0d, 0x41, 0x44, 0x25, 0x01, 0x33, 0x0d, 0x01, 0x42, + 0x15, 0x02, 0x32, 0x0d, 0x41, 0x44, 0x06, 0x1f, 0x37, 0x0d, 0x01, 0x42, + 0x09, 0x24, 0x36, 0x0d, 0x41, 0x43, 0xf9, 0x05, 0x35, 0x0d, 0x01, 0x43, + 0xf6, 0x06, 0x34, 0x0d, 0x41, 0x03, 0xf7, 0x57, 0x57, 0x0d, 0x77, 0x8f, + 0x01, 0xff, 0x45, 0x7e, 0x0b, 0x28, 0x30, 0x00, 0xa6, 0x3e, 0x44, 0x6d, + 0x2c, 0x29, 0x30, 0x00, 0x43, 0x7a, 0x0b, 0x21, 0x30, 0x00, 0xb3, 0x24, + 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x38, 0x30, 0x00, 0xa8, 0x0d, 0xb7, + 0x01, 0xff, 0x44, 0xe9, 0x1e, 0x39, 0x30, 0x00, 0xef, 0x22, 0x30, 0x40, + 0x44, 0x49, 0x12, 0x3a, 0x30, 0x00, 0x43, 0x26, 0x01, 0x23, 0x30, 0x40, + 0x44, 0x06, 0x1f, 0x27, 0x30, 0x00, 0x42, 0x09, 0x24, 0x26, 0x30, 0x40, + 0x43, 0xf9, 0x05, 0x25, 0x30, 0x00, 0x43, 0xf6, 0x06, 0x24, 0x30, 0x40, + 0x09, 0xc9, 0xbc, 0xf4, 0x10, 0x54, 0xdb, 0x43, 0x2f, 0x30, 0x00, 0x46, + 0xb7, 0x86, 0x64, 0x31, 0x00, 0xaa, 0xef, 0x04, 0x07, 0x13, 0x06, 0x0f, + 0xb3, 0x01, 0xff, 0x53, 0xbf, 0x4c, 0x2e, 0x30, 0x00, 0x48, 0x21, 0x19, + 0x00, 0xd8, 0x40, 0xe1, 0x4f, 0x31, 0x80, 0xc7, 0x04, 0xa3, 0xb8, 0x04, + 0xe5, 0x54, 0x31, 0x80, 0xaa, 0x04, 0x45, 0xbc, 0xaa, 0x4e, 0x31, 0x00, + 0xe9, 0x63, 0x31, 0x80, 0x98, 0x04, 0xab, 0xe4, 0x03, 0x45, 0x9a, 0xee, + 0x41, 0x31, 0x80, 0xc5, 0x03, 0x45, 0x0d, 0xef, 0x34, 0x31, 0x80, 0x9c, + 0x03, 0xef, 0x57, 0x31, 0x80, 0x92, 0x03, 0xb0, 0xc8, 0x02, 0x45, 0x52, + 0xf0, 0x39, 0x31, 0x80, 0xef, 0x01, 0xb3, 0x8f, 0x01, 0xb4, 0x80, 0x01, + 0xf5, 0x5c, 0x31, 0x00, 0xb7, 0x64, 0xb9, 0x01, 0xff, 0xe1, 0x51, 0x31, + 0x80, 0x58, 0xe5, 0x56, 0x31, 0x80, 0x32, 0xe9, 0x62, 0x31, 0x00, 0xef, + 0x5b, 0x31, 0x80, 0x17, 0xf5, 0x60, 0x31, 0xc0, 0x00, 0x8d, 0x01, 0xff, + 0xe9, 0x8c, 0x31, 0x00, 0x42, 0x4d, 0x00, 0x8b, 0x31, 0xc0, 0x00, 0xef, + 0x8a, 0x31, 0x40, 0x8d, 0x01, 0xff, 0xe9, 0x89, 0x31, 0x00, 0x42, 0xdf, + 0x23, 0x87, 0x31, 0xc0, 0x00, 0xe5, 0x88, 0x31, 0x40, 0xef, 0x55, 0x31, + 0x80, 0x16, 0x46, 0xa1, 0xd2, 0x81, 0x31, 0xc0, 0x00, 0x8d, 0x01, 0xff, + 0x47, 0x6a, 0xda, 0x83, 0x31, 0x00, 0x44, 0x35, 0xc5, 0x82, 0x31, 0x40, + 0x48, 0xb9, 0xaa, 0x86, 0x31, 0x40, 0xe5, 0x52, 0x31, 0x40, 0xe1, 0x58, + 0x31, 0x80, 0x0d, 0xe5, 0x5e, 0x31, 0x80, 0x04, 0xe9, 0x5f, 0x31, 0x40, + 0xef, 0x5d, 0x31, 0x40, 0xe5, 0x59, 0x31, 0x40, 0x46, 0x47, 0xdc, 0x4c, + 0x31, 0x00, 0x45, 0xa4, 0xd3, 0x37, 0x31, 0x40, 0x43, 0x46, 0x44, 0x45, + 0x31, 0x80, 0x35, 0x04, 0xb3, 0x2e, 0x01, 0xff, 0x45, 0x3e, 0xeb, 0x49, + 0x31, 0x00, 0x45, 0xbc, 0xaa, 0x85, 0x31, 0x00, 0x45, 0xdd, 0xd1, 0x80, + 0x31, 0x00, 0x46, 0x11, 0xa8, 0x32, 0x31, 0x00, 0x45, 0x0d, 0xef, 0x65, + 0x31, 0x00, 0x45, 0x0c, 0x89, 0x43, 0x31, 0x00, 0x44, 0x35, 0xc5, 0x46, + 0x31, 0x00, 0x46, 0xa3, 0xd3, 0x38, 0x31, 0x40, 0x8d, 0x01, 0xff, 0x45, + 0x3e, 0xeb, 0x7e, 0x31, 0x00, 0x46, 0x11, 0xa8, 0x7a, 0x31, 0x00, 0x45, + 0x0d, 0xef, 0x7b, 0x31, 0x00, 0x45, 0x0c, 0x89, 0x7d, 0x31, 0x00, 0x46, + 0xa3, 0xd3, 0x7c, 0x31, 0x40, 0x8d, 0x01, 0xff, 0x45, 0xbc, 0xaa, 0x40, + 0x31, 0x00, 0x46, 0x11, 0xa8, 0x3a, 0x31, 0x80, 0x3b, 0x45, 0x9a, 0xee, + 0x3b, 0x31, 0x00, 0xb0, 0x1a, 0x44, 0x35, 0xc5, 0x3d, 0x31, 0x00, 0xb4, + 0x06, 0x4b, 0xb6, 0xaa, 0x6d, 0x31, 0x40, 0x46, 0x47, 0xdc, 0x3e, 0x31, + 0x00, 0x45, 0xa4, 0xd3, 0x6a, 0x31, 0x40, 0x46, 0x6b, 0xda, 0x6c, 0x31, + 0x00, 0x46, 0x81, 0xc8, 0x3f, 0x31, 0x00, 0x44, 0x0d, 0x89, 0x3c, 0x31, + 0xc0, 0x00, 0x45, 0xf6, 0xe7, 0x6b, 0x31, 0x40, 0x45, 0xf6, 0xe7, 0x69, + 0x31, 0x40, 0x46, 0x6b, 0xda, 0x7f, 0x31, 0x00, 0x46, 0x81, 0xc8, 0x4d, + 0x31, 0x00, 0x44, 0x0d, 0x89, 0x42, 0x31, 0xc0, 0x00, 0x8d, 0x01, 0xff, + 0x45, 0x3e, 0xeb, 0x76, 0x31, 0x00, 0x46, 0x11, 0xa8, 0x72, 0x31, 0x00, + 0x44, 0x35, 0xc5, 0x44, 0x31, 0x80, 0x0f, 0xb4, 0x01, 0xff, 0x46, 0x47, + 0xdc, 0x77, 0x31, 0x00, 0x45, 0xa4, 0xd3, 0x73, 0x31, 0x40, 0x8d, 0x01, + 0xff, 0x46, 0x11, 0xa8, 0x74, 0x31, 0x00, 0x46, 0xa3, 0xd3, 0x75, 0x31, + 0x40, 0xe5, 0x5a, 0x31, 0x40, 0x8d, 0x01, 0xff, 0x45, 0x3e, 0xeb, 0x35, + 0x31, 0x00, 0x45, 0xbc, 0xaa, 0x36, 0x31, 0x00, 0x47, 0x6a, 0xda, 0x68, + 0x31, 0x00, 0x44, 0x35, 0xc5, 0x67, 0x31, 0x00, 0x46, 0xa3, 0xd3, 0x66, + 0x31, 0x40, 0x8d, 0x01, 0xff, 0xb0, 0x06, 0x44, 0x35, 0xc5, 0x6f, 0x31, + 0x40, 0x46, 0x6b, 0xda, 0x70, 0x31, 0x00, 0x44, 0x0d, 0x89, 0x6e, 0x31, + 0x40, 0x07, 0x05, 0x89, 0x13, 0x46, 0x79, 0xc8, 0x4b, 0x31, 0x00, 0x45, + 0x12, 0xa8, 0x31, 0x31, 0xc0, 0x00, 0x45, 0xf6, 0xe7, 0x33, 0x31, 0x40, + 0x45, 0x9a, 0xee, 0x71, 0x31, 0x00, 0xb0, 0x06, 0x4a, 0xea, 0xb6, 0x79, + 0x31, 0x40, 0x46, 0x81, 0xc8, 0x84, 0x31, 0x00, 0x44, 0x0d, 0x89, 0x78, + 0x31, 0x40, 0x44, 0xde, 0xd1, 0x47, 0x31, 0x40, 0xef, 0x53, 0x31, 0x00, + 0xf5, 0x61, 0x31, 0x40, 0x46, 0xa9, 0xd5, 0x4a, 0x31, 0x00, 0x44, 0xaa, + 0xd5, 0x48, 0x31, 0x40, 0xe5, 0x50, 0x31, 0x00, 0x44, 0xe6, 0xb6, 0x8d, + 0x31, 0xc0, 0x00, 0xe5, 0x8e, 0x31, 0x40, 0x09, 0xf9, 0xc2, 0xfb, 0x03, + 0x09, 0x2c, 0xc6, 0x01, 0xff, 0xe1, 0x61, 0x11, 0x80, 0xbd, 0x03, 0xe5, + 0x66, 0x11, 0x80, 0x80, 0x03, 0x46, 0xb7, 0x86, 0x60, 0x11, 0x00, 0xe9, + 0x75, 0x11, 0x80, 0xaa, 0x02, 0xef, 0x69, 0x11, 0x80, 0xf1, 0x01, 0x4a, + 0xe0, 0xb6, 0xa2, 0x11, 0x00, 0xf5, 0x6e, 0x11, 0x80, 0xbe, 0x01, 0xb7, + 0xa5, 0x01, 0xb9, 0x01, 0xff, 0xe1, 0x63, 0x11, 0x80, 0x88, 0x01, 0xe5, + 0x68, 0x11, 0x80, 0x6d, 0xe9, 0x74, 0x11, 0x80, 0x62, 0xef, 0x6d, 0x11, + 0x80, 0x31, 0xf5, 0x72, 0x11, 0xc0, 0x00, 0x8d, 0x01, 0xff, 0xe1, 0x8e, + 0x11, 0x80, 0x20, 0xe5, 0x90, 0x11, 0x80, 0x17, 0xe9, 0x94, 0x11, 0x00, + 0xef, 0xb8, 0xd7, 0x00, 0xf5, 0x93, 0x11, 0x00, 0x42, 0x4d, 0x00, 0x92, + 0x11, 0xc0, 0x00, 0xef, 0x91, 0x11, 0x40, 0xef, 0x8f, 0x11, 0x40, 0xe5, + 0xb7, 0xd7, 0x40, 0x8d, 0x01, 0xff, 0xe1, 0xb2, 0xd7, 0x80, 0x20, 0x42, + 0xac, 0x0b, 0xb4, 0xd7, 0x00, 0xe9, 0x88, 0x11, 0x00, 0xef, 0x87, 0x11, + 0x00, 0xb9, 0x01, 0xff, 0xe1, 0x84, 0x11, 0x80, 0x06, 0x42, 0xac, 0x0b, + 0x86, 0x11, 0x40, 0xe5, 0x85, 0x11, 0x40, 0xe5, 0xb3, 0xd7, 0x40, 0x42, + 0xb4, 0x08, 0x97, 0x11, 0x40, 0xef, 0x67, 0x11, 0xc0, 0x00, 0x8d, 0x01, + 0xff, 0xef, 0x7d, 0x11, 0x00, 0xf5, 0x7e, 0x11, 0x00, 0x42, 0xdf, 0x23, + 0xa5, 0x11, 0x40, 0x8d, 0x04, 0xe5, 0x64, 0x11, 0x40, 0xef, 0x78, 0x11, + 0x00, 0xf5, 0xa4, 0x11, 0x00, 0x42, 0xe0, 0x49, 0x79, 0x11, 0x40, 0xe1, + 0x6a, 0x11, 0x80, 0x0d, 0xe5, 0x70, 0x11, 0x80, 0x04, 0xe9, 0x71, 0x11, + 0x40, 0xef, 0x6f, 0x11, 0x40, 0xe5, 0x6b, 0x11, 0x40, 0x8d, 0x01, 0xff, + 0xe1, 0x89, 0x11, 0x80, 0x1b, 0x45, 0xfc, 0xeb, 0x8b, 0x11, 0x00, 0x43, + 0x4e, 0xfa, 0xb6, 0xd7, 0x00, 0xf5, 0x8d, 0x11, 0x00, 0x42, 0x4d, 0x00, + 0x8c, 0x11, 0xc0, 0x00, 0xef, 0xb5, 0xd7, 0x40, 0xe5, 0x8a, 0x11, 0x40, + 0x8d, 0x04, 0xe5, 0x6c, 0x11, 0x40, 0xe5, 0x80, 0x11, 0x80, 0x24, 0xef, + 0x82, 0x11, 0x80, 0x19, 0xf5, 0x83, 0x11, 0x00, 0xb9, 0x01, 0xff, 0xe1, + 0xa6, 0x11, 0x80, 0x09, 0xe5, 0x81, 0x11, 0xc0, 0x00, 0xef, 0xb0, 0xd7, + 0x40, 0xe5, 0xa7, 0x11, 0x40, 0x42, 0xe8, 0x06, 0xb1, 0xd7, 0x40, 0xef, + 0x7f, 0x11, 0x40, 0x8d, 0x01, 0xff, 0xe1, 0x98, 0x11, 0x80, 0x3c, 0x42, + 0x97, 0x02, 0x9c, 0x11, 0x00, 0xe9, 0xc4, 0xd7, 0x00, 0xef, 0x9a, 0x11, + 0x80, 0x27, 0xf5, 0x9b, 0x11, 0x00, 0xb9, 0x01, 0xff, 0xe1, 0x99, 0x11, + 0x80, 0x11, 0xe5, 0xc0, 0xd7, 0x80, 0x08, 0xef, 0xc2, 0xd7, 0x00, 0xf5, + 0xc3, 0xd7, 0x40, 0xef, 0xbf, 0xd7, 0x40, 0x42, 0x72, 0x22, 0xbd, 0xd7, + 0x00, 0xe5, 0xbe, 0xd7, 0x40, 0x42, 0xe8, 0x06, 0xc1, 0xd7, 0x40, 0x44, + 0xe6, 0xb6, 0x9d, 0x11, 0x40, 0xef, 0x65, 0x11, 0x80, 0x21, 0xf5, 0x73, + 0x11, 0xc0, 0x00, 0x8d, 0x01, 0xff, 0xe1, 0xb9, 0xd7, 0x00, 0xe5, 0xbb, + 0xd7, 0x80, 0x08, 0xef, 0xbc, 0xd7, 0x00, 0xf5, 0x95, 0x11, 0x40, 0xef, + 0xba, 0xd7, 0x00, 0xf5, 0x96, 0x11, 0x40, 0x8d, 0x01, 0xff, 0x42, 0x97, + 0x02, 0x7c, 0x11, 0x00, 0xef, 0x7a, 0x11, 0x00, 0xf5, 0x7b, 0x11, 0x40, + 0x8d, 0x23, 0xe5, 0x62, 0x11, 0x00, 0x44, 0xe6, 0xb6, 0x9e, 0x11, 0xc0, + 0x00, 0x8d, 0x01, 0xff, 0xe1, 0xc5, 0xd7, 0x00, 0xe5, 0xc6, 0xd7, 0x80, + 0x08, 0xe9, 0xa1, 0x11, 0x00, 0xf5, 0xa0, 0x11, 0x40, 0xef, 0x9f, 0x11, + 0x40, 0x42, 0x97, 0x02, 0xa3, 0x11, 0x00, 0xef, 0x76, 0x11, 0x00, 0xf5, + 0x77, 0x11, 0x40, 0xa3, 0xd7, 0x07, 0x45, 0xbc, 0xaa, 0xc2, 0x11, 0x80, + 0xb4, 0x07, 0x45, 0xdd, 0xd1, 0xbc, 0x11, 0x80, 0x95, 0x07, 0xab, 0xb3, + 0x06, 0x45, 0x9a, 0xee, 0xb7, 0x11, 0x80, 0xd3, 0x05, 0x45, 0x0d, 0xef, + 0xab, 0x11, 0x80, 0x8d, 0x05, 0xb0, 0x8e, 0x04, 0x45, 0x52, 0xf0, 0xaf, + 0x11, 0x80, 0xc0, 0x02, 0xb3, 0x89, 0x01, 0xb4, 0x44, 0x02, 0x4d, 0x00, + 0x01, 0xff, 0x49, 0xb8, 0xaa, 0xf9, 0x11, 0x00, 0x46, 0xa1, 0xd2, 0xf0, + 0x11, 0xc0, 0x00, 0x8d, 0x01, 0xff, 0x45, 0xbc, 0xaa, 0xf6, 0xd7, 0x00, + 0xab, 0x1b, 0x45, 0x9a, 0xee, 0xf5, 0xd7, 0x00, 0x47, 0x6a, 0xda, 0xf2, + 0x11, 0x00, 0xb3, 0x01, 0xff, 0x43, 0x46, 0x44, 0xf1, 0x11, 0x00, 0x4a, + 0x0d, 0xa8, 0xed, 0x11, 0x40, 0x46, 0x79, 0xc8, 0xef, 0x11, 0x00, 0x45, + 0x12, 0xa8, 0xec, 0x11, 0x40, 0x46, 0x47, 0xdc, 0xc0, 0x11, 0x00, 0x45, + 0xa4, 0xd3, 0xae, 0x11, 0xc0, 0x00, 0x8d, 0x01, 0xff, 0xa3, 0x25, 0x46, + 0x11, 0xa8, 0xca, 0x11, 0x00, 0x45, 0x0c, 0x89, 0xcf, 0xd7, 0x00, 0x45, + 0x52, 0xf0, 0xcb, 0x11, 0x00, 0x44, 0x35, 0xc5, 0xd0, 0xd7, 0x80, 0x06, + 0x47, 0x46, 0xdc, 0xd4, 0xd7, 0x40, 0x47, 0x7f, 0xd3, 0xd1, 0xd7, 0x40, + 0x46, 0xa9, 0xd5, 0xd3, 0xd7, 0x00, 0x44, 0xaa, 0xd5, 0xd2, 0xd7, 0x40, + 0x43, 0x46, 0x44, 0xba, 0x11, 0x80, 0x5f, 0x04, 0xb3, 0x2e, 0x01, 0xff, + 0x45, 0x3e, 0xeb, 0xf9, 0xd7, 0x00, 0x45, 0xdd, 0xd1, 0xee, 0x11, 0x00, + 0x46, 0x11, 0xa8, 0xa9, 0x11, 0x00, 0x45, 0x9a, 0xee, 0xe0, 0xd7, 0x00, + 0x45, 0x0d, 0xef, 0xff, 0x11, 0x00, 0x45, 0x0c, 0x89, 0xe6, 0xd7, 0x00, + 0x45, 0x52, 0xf0, 0xd0, 0x11, 0x80, 0x29, 0x44, 0x35, 0xc5, 0xbb, 0x11, + 0x80, 0x13, 0x46, 0xa3, 0xd3, 0xcd, 0xd7, 0x80, 0x06, 0x48, 0x9f, 0xd2, + 0xee, 0x11, 0x40, 0x46, 0x5c, 0xde, 0xce, 0xd7, 0x40, 0x8d, 0x01, 0xff, + 0x46, 0x11, 0xa8, 0xec, 0xd7, 0x00, 0x46, 0xa3, 0xd3, 0xed, 0xd7, 0x40, + 0x48, 0x77, 0xc8, 0xd7, 0xd7, 0x40, 0x8d, 0x01, 0xff, 0xa3, 0x3d, 0x45, + 0xbc, 0xaa, 0xf2, 0xd7, 0x00, 0xab, 0x29, 0x45, 0x9a, 0xee, 0xea, 0xd7, + 0x00, 0xb0, 0x15, 0x45, 0x52, 0xf0, 0xe9, 0x11, 0x00, 0xb4, 0x01, 0xff, + 0x46, 0x47, 0xdc, 0xf1, 0xd7, 0x00, 0x45, 0xa4, 0xd3, 0xe8, 0x11, 0x40, + 0x46, 0x6b, 0xda, 0xee, 0xd7, 0x00, 0x44, 0x0d, 0x89, 0xea, 0x11, 0x40, + 0x4c, 0x05, 0x89, 0xeb, 0xd7, 0x00, 0x45, 0x12, 0xa8, 0xe7, 0x11, 0x40, + 0x46, 0xa9, 0xd5, 0xf0, 0xd7, 0x00, 0x44, 0xaa, 0xd5, 0xef, 0xd7, 0x40, + 0x8d, 0x01, 0xff, 0x45, 0xbc, 0xaa, 0xb6, 0x11, 0x00, 0xab, 0x98, 0x01, + 0x45, 0x9a, 0xee, 0xb1, 0x11, 0x80, 0x7c, 0x45, 0x0d, 0xef, 0xcd, 0x11, + 0x00, 0xb0, 0x46, 0xb3, 0x2d, 0xb4, 0x18, 0x02, 0x4d, 0x00, 0x01, 0xff, + 0x49, 0xb8, 0xaa, 0xd9, 0x11, 0x80, 0x06, 0x46, 0xa1, 0xd2, 0xdb, 0xd7, + 0x40, 0x46, 0x4a, 0xde, 0xdc, 0xd7, 0x40, 0x46, 0x47, 0xdc, 0xb4, 0x11, + 0x00, 0x45, 0xa4, 0xd3, 0xce, 0x11, 0xc0, 0x00, 0x46, 0x4a, 0xde, 0xcf, + 0x11, 0x40, 0x43, 0x46, 0x44, 0xb3, 0x11, 0x00, 0x04, 0xb3, 0x2e, 0x01, + 0xff, 0x46, 0x11, 0xa8, 0xd5, 0xd7, 0x00, 0x44, 0x35, 0xc5, 0xd6, 0x11, + 0x40, 0x46, 0x6b, 0xda, 0xd7, 0x11, 0x00, 0x46, 0x81, 0xc8, 0xb5, 0x11, + 0x00, 0x44, 0x0d, 0x89, 0xb2, 0x11, 0xc0, 0x00, 0x8d, 0x01, 0xff, 0x45, + 0xbc, 0xaa, 0xd4, 0x11, 0x00, 0x47, 0x80, 0xc8, 0xda, 0xd7, 0x00, 0x44, + 0x35, 0xc5, 0xd3, 0x11, 0x00, 0x46, 0xa3, 0xd3, 0xd9, 0xd7, 0x40, 0x8d, + 0x01, 0xff, 0x45, 0xbc, 0xaa, 0xd8, 0xd7, 0x00, 0x46, 0x11, 0xa8, 0xd1, + 0x11, 0x00, 0x44, 0x35, 0xc5, 0xd2, 0x11, 0x40, 0x4c, 0x05, 0x89, 0xd5, + 0x11, 0x00, 0x46, 0x79, 0xc8, 0xd8, 0x11, 0x00, 0x45, 0x12, 0xa8, 0xb0, + 0x11, 0xc0, 0x00, 0x8d, 0x01, 0xff, 0x45, 0xbc, 0xaa, 0xd6, 0xd7, 0x00, + 0x44, 0x35, 0xc5, 0xcc, 0x11, 0x40, 0x46, 0x6b, 0xda, 0xeb, 0x11, 0x80, + 0x66, 0x46, 0x81, 0xc8, 0xc1, 0x11, 0x80, 0x4a, 0x44, 0x0d, 0x89, 0xb8, + 0x11, 0xc0, 0x00, 0x8d, 0x01, 0xff, 0xa3, 0x32, 0x45, 0xbc, 0xaa, 0xe5, + 0x11, 0x00, 0x45, 0x9a, 0xee, 0xe5, 0xd7, 0x00, 0x47, 0x80, 0xc8, 0xe4, + 0x11, 0x00, 0x45, 0x52, 0xf0, 0xe3, 0x11, 0x80, 0x13, 0x44, 0x35, 0xc5, + 0xb9, 0x11, 0x80, 0x06, 0x46, 0xa3, 0xd3, 0xe3, 0xd7, 0x40, 0x47, 0xa2, + 0xd3, 0xe7, 0xd7, 0x40, 0x48, 0x7f, 0xc8, 0xe4, 0xd7, 0x40, 0x46, 0xa9, + 0xd5, 0xe9, 0xd7, 0x00, 0x44, 0xaa, 0xd5, 0xe8, 0xd7, 0x40, 0x8d, 0x01, + 0xff, 0x45, 0x0c, 0x89, 0xf3, 0x11, 0x00, 0x44, 0x35, 0xc5, 0xfa, 0xd7, + 0x00, 0x47, 0x46, 0xdc, 0xfb, 0xd7, 0x40, 0x8d, 0x01, 0xff, 0x4d, 0x04, + 0x89, 0xf4, 0xd7, 0x00, 0x45, 0x0c, 0x89, 0xf3, 0xd7, 0x40, 0x8d, 0x01, + 0xff, 0xa3, 0x2d, 0x45, 0xbc, 0xaa, 0xad, 0x11, 0x00, 0x46, 0x11, 0xa8, + 0xc5, 0x11, 0x00, 0x47, 0x6a, 0xda, 0xc8, 0x11, 0x00, 0x45, 0x52, 0xf0, + 0xcb, 0xd7, 0x00, 0x44, 0x35, 0xc5, 0xc7, 0x11, 0x00, 0xb4, 0x01, 0xff, + 0x46, 0x47, 0xdc, 0xc9, 0x11, 0x00, 0x45, 0xa4, 0xd3, 0xc6, 0x11, 0x40, + 0x46, 0xa9, 0xd5, 0xcc, 0xd7, 0x00, 0x44, 0xaa, 0xd5, 0xac, 0x11, 0x40, + 0x8d, 0x01, 0xff, 0xa3, 0x47, 0x45, 0xbc, 0xaa, 0xe1, 0x11, 0x00, 0x46, + 0x11, 0xa8, 0xda, 0x11, 0x00, 0x45, 0x0d, 0xef, 0xde, 0xd7, 0x00, 0xb0, + 0x20, 0x45, 0x52, 0xf0, 0xdb, 0x11, 0x00, 0xb3, 0x01, 0xff, 0x43, 0x46, + 0x44, 0xdd, 0x11, 0x00, 0x04, 0xb3, 0x2e, 0x01, 0xff, 0x45, 0x0d, 0xef, + 0xdf, 0xd7, 0x00, 0x44, 0x35, 0xc5, 0xde, 0x11, 0x40, 0x46, 0x6b, 0xda, + 0xdf, 0x11, 0x00, 0x44, 0x0d, 0x89, 0xdc, 0x11, 0xc0, 0x00, 0x45, 0xf6, + 0xe7, 0xe1, 0xd7, 0x40, 0x46, 0xa9, 0xd5, 0xe0, 0x11, 0x00, 0x44, 0xaa, + 0xd5, 0xe2, 0xd7, 0x40, 0x07, 0x05, 0x89, 0x41, 0x46, 0x79, 0xc8, 0xbf, + 0x11, 0x00, 0x45, 0x12, 0xa8, 0xa8, 0x11, 0xc0, 0x00, 0x8d, 0x01, 0xff, + 0x47, 0xa8, 0xd5, 0xfc, 0x11, 0x00, 0x45, 0xbc, 0xaa, 0xfe, 0x11, 0x00, + 0x47, 0x78, 0xc8, 0xfd, 0x11, 0x00, 0x45, 0x0d, 0xef, 0xfa, 0x11, 0x00, + 0x45, 0x0c, 0x89, 0xfb, 0x11, 0x00, 0x45, 0x52, 0xf0, 0xc3, 0x11, 0x00, + 0x44, 0x35, 0xc5, 0xaa, 0x11, 0xc0, 0x00, 0x47, 0x7f, 0xd3, 0xc4, 0x11, + 0x40, 0x45, 0x9a, 0xee, 0xe2, 0x11, 0x00, 0xb0, 0x06, 0x45, 0x52, 0xf0, + 0xdd, 0xd7, 0x40, 0x46, 0x81, 0xc8, 0xf4, 0x11, 0x00, 0x44, 0x0d, 0x89, + 0xe6, 0x11, 0x40, 0x8d, 0x01, 0xff, 0xab, 0x06, 0x4b, 0x0c, 0xa8, 0xed, + 0x11, 0x40, 0x46, 0x79, 0xc8, 0xef, 0x11, 0x00, 0x45, 0x12, 0xa8, 0xec, + 0x11, 0x40, 0x8d, 0x01, 0xff, 0x45, 0x9a, 0xee, 0xf7, 0x11, 0x00, 0x45, + 0x0d, 0xef, 0xf5, 0x11, 0x00, 0x45, 0x0c, 0x89, 0xf8, 0x11, 0x00, 0x45, + 0x52, 0xf0, 0xf6, 0x11, 0x40, 0x46, 0xa9, 0xd5, 0xbe, 0x11, 0x00, 0x44, + 0xaa, 0xd5, 0xbd, 0x11, 0xc0, 0x00, 0x8d, 0x01, 0xff, 0x45, 0x0c, 0x89, + 0xf7, 0xd7, 0x00, 0x4a, 0xea, 0xb6, 0xf8, 0xd7, 0x40, 0xa3, 0x83, 0x06, + 0x46, 0xb7, 0x86, 0x5f, 0x11, 0x00, 0x45, 0xbc, 0xaa, 0x12, 0x11, 0x80, + 0xef, 0x05, 0x45, 0xdd, 0xd1, 0x0b, 0x11, 0x80, 0x95, 0x05, 0xab, 0xdb, + 0x04, 0x45, 0x9a, 0xee, 0x06, 0x11, 0x80, 0xb8, 0x04, 0x45, 0x0d, 0xef, + 0x02, 0x11, 0x80, 0x89, 0x04, 0xb0, 0xf0, 0x02, 0x45, 0x52, 0xf0, 0x05, + 0x11, 0x80, 0x8e, 0x02, 0xb3, 0x47, 0xb4, 0x11, 0x02, 0x4d, 0x00, 0x01, + 0xff, 0x49, 0xb8, 0xaa, 0x59, 0x11, 0x00, 0x46, 0xa1, 0xd2, 0x4c, 0x11, + 0x40, 0x46, 0x47, 0xdc, 0x10, 0x11, 0x00, 0x45, 0xa4, 0xd3, 0x03, 0x11, + 0xc0, 0x00, 0x8d, 0x01, 0xff, 0x45, 0x3e, 0xeb, 0x63, 0xa9, 0x00, 0x46, + 0x11, 0xa8, 0x17, 0x11, 0x00, 0x45, 0x9a, 0xee, 0x60, 0xa9, 0x00, 0x45, + 0x0c, 0x89, 0x61, 0xa9, 0x00, 0x45, 0x52, 0xf0, 0x5e, 0x11, 0x00, 0x44, + 0x35, 0xc5, 0x62, 0xa9, 0x40, 0x43, 0x46, 0x44, 0x09, 0x11, 0x80, 0x57, + 0x04, 0xb3, 0x2e, 0x01, 0xff, 0x45, 0x3e, 0xeb, 0x0d, 0x11, 0x80, 0x45, + 0x45, 0xbc, 0xaa, 0x58, 0x11, 0x00, 0x45, 0xdd, 0xd1, 0x47, 0x11, 0x00, + 0x46, 0x11, 0xa8, 0x01, 0x11, 0x00, 0x45, 0x0d, 0xef, 0x14, 0x11, 0x00, + 0x45, 0x0c, 0x89, 0x08, 0x11, 0x00, 0x45, 0x52, 0xf0, 0x19, 0x11, 0x00, + 0x44, 0x35, 0xc5, 0x0a, 0x11, 0x80, 0x14, 0xb4, 0x06, 0x4b, 0xb6, 0xaa, + 0x7c, 0xa9, 0x40, 0x46, 0x47, 0xdc, 0x79, 0xa9, 0x00, 0x45, 0xa4, 0xd3, + 0x04, 0x11, 0x40, 0x46, 0x5c, 0xde, 0x75, 0xa9, 0x40, 0x46, 0x4a, 0xde, + 0x78, 0xa9, 0x40, 0x8d, 0x01, 0xff, 0xa3, 0x56, 0x45, 0xbc, 0xaa, 0x3b, + 0x11, 0x00, 0x45, 0xdd, 0xd1, 0x35, 0x11, 0x00, 0xab, 0x3c, 0x45, 0x9a, + 0xee, 0x31, 0x11, 0x00, 0x45, 0x0d, 0xef, 0x2e, 0x11, 0x00, 0xb0, 0x1b, + 0x45, 0x52, 0xf0, 0x30, 0x11, 0x00, 0x49, 0x30, 0xc5, 0x34, 0x11, 0x00, + 0xb4, 0x01, 0xff, 0x46, 0x47, 0xdc, 0x39, 0x11, 0x00, 0x45, 0xa4, 0xd3, + 0x2f, 0x11, 0x40, 0x46, 0x81, 0xc8, 0x3a, 0x11, 0x00, 0x44, 0x0d, 0x89, + 0x32, 0x11, 0xc0, 0x00, 0x47, 0x7f, 0xd3, 0x33, 0x11, 0x40, 0x46, 0x79, + 0xc8, 0x38, 0x11, 0x00, 0x45, 0x12, 0xa8, 0x2d, 0x11, 0x40, 0x46, 0xa9, + 0xd5, 0x37, 0x11, 0x00, 0x44, 0xaa, 0xd5, 0x36, 0x11, 0x40, 0x8d, 0x01, + 0xff, 0x45, 0x3e, 0xeb, 0x6d, 0xa9, 0x00, 0x45, 0xbc, 0xaa, 0x1a, 0x11, + 0x00, 0xab, 0x37, 0x45, 0x9a, 0xee, 0x68, 0xa9, 0x00, 0x45, 0x0d, 0xef, + 0x18, 0x11, 0x00, 0x45, 0x0c, 0x89, 0x69, 0xa9, 0x00, 0xb3, 0x06, 0x46, + 0xa3, 0xd3, 0x66, 0xa9, 0x40, 0x43, 0x46, 0x44, 0x6c, 0xa9, 0x00, 0x04, + 0xb3, 0x2e, 0x01, 0xff, 0x46, 0x11, 0xa8, 0x65, 0xa9, 0x00, 0x45, 0x0c, + 0x89, 0x6a, 0xa9, 0x00, 0x46, 0xa3, 0xd3, 0x67, 0xa9, 0x40, 0x4c, 0x05, + 0x89, 0x6b, 0xa9, 0x00, 0x46, 0x79, 0xc8, 0x6e, 0xa9, 0x00, 0x45, 0x12, + 0xa8, 0x64, 0xa9, 0x40, 0x46, 0x6b, 0xda, 0x40, 0x11, 0x00, 0x46, 0x81, + 0xc8, 0x11, 0x11, 0x80, 0x7a, 0x44, 0x0d, 0x89, 0x07, 0x11, 0xc0, 0x00, + 0x8d, 0x01, 0xff, 0xa3, 0x62, 0x45, 0xbc, 0xaa, 0x74, 0xa9, 0x00, 0xab, + 0x4e, 0x45, 0x0d, 0xef, 0x1f, 0x11, 0x00, 0x47, 0x80, 0xc8, 0x2a, 0x11, + 0x00, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x46, 0x47, 0xdc, 0x29, 0x11, 0x00, + 0x45, 0xa4, 0xd3, 0x20, 0x11, 0x40, 0x43, 0x46, 0x44, 0x21, 0x11, 0x80, + 0x06, 0x48, 0x31, 0xc5, 0x25, 0x11, 0x40, 0x8d, 0x01, 0xff, 0x45, 0x3e, + 0xeb, 0x26, 0x11, 0x00, 0x46, 0x11, 0xa8, 0x22, 0x11, 0x00, 0x45, 0x0c, + 0x89, 0x24, 0x11, 0x00, 0xb4, 0x01, 0xff, 0x46, 0x47, 0xdc, 0x72, 0xa9, + 0x00, 0x45, 0xa4, 0xd3, 0x23, 0x11, 0x40, 0x46, 0x79, 0xc8, 0x73, 0xa9, + 0x00, 0x45, 0x12, 0xa8, 0x1e, 0x11, 0x40, 0x46, 0xa9, 0xd5, 0x28, 0x11, + 0x00, 0x44, 0xaa, 0xd5, 0x27, 0x11, 0x40, 0x8d, 0x01, 0xff, 0x45, 0xbc, + 0xaa, 0x7a, 0xa9, 0x00, 0x45, 0x0c, 0x89, 0x56, 0x11, 0x40, 0x8d, 0x01, + 0xff, 0x45, 0x3e, 0xeb, 0x5c, 0x11, 0x00, 0x45, 0xbc, 0xaa, 0x5d, 0x11, + 0x00, 0x46, 0x11, 0xa8, 0x13, 0x11, 0x00, 0x45, 0x0c, 0x89, 0x16, 0x11, + 0x00, 0x44, 0x35, 0xc5, 0x5b, 0x11, 0x00, 0x46, 0xa3, 0xd3, 0x15, 0x11, + 0x40, 0x8d, 0x01, 0xff, 0x46, 0x11, 0xa8, 0x6f, 0xa9, 0x00, 0x45, 0x0c, + 0x89, 0x1c, 0x11, 0x00, 0x44, 0x35, 0xc5, 0x71, 0xa9, 0x00, 0x46, 0xa3, + 0xd3, 0x70, 0xa9, 0x40, 0x07, 0x05, 0x89, 0x13, 0x46, 0x79, 0xc8, 0x0f, + 0x11, 0x00, 0x45, 0x12, 0xa8, 0x00, 0x11, 0xc0, 0x00, 0x47, 0xa2, 0xd3, + 0x5a, 0x11, 0x40, 0x45, 0x9a, 0xee, 0x1d, 0x11, 0x00, 0xb0, 0x0c, 0x45, + 0x52, 0xf0, 0x1b, 0x11, 0x00, 0x4a, 0xea, 0xb6, 0x2c, 0x11, 0x40, 0x46, + 0x81, 0xc8, 0x57, 0x11, 0x00, 0x44, 0x0d, 0x89, 0x2b, 0x11, 0x40, 0x8d, + 0x01, 0xff, 0xa3, 0x41, 0x45, 0xbc, 0xaa, 0x77, 0xa9, 0x00, 0x46, 0x11, + 0xa8, 0x41, 0x11, 0x00, 0x45, 0x9a, 0xee, 0x43, 0x11, 0x00, 0xb0, 0x1b, + 0x45, 0x52, 0xf0, 0x76, 0xa9, 0x00, 0x44, 0x35, 0xc5, 0x45, 0x11, 0x00, + 0xb4, 0x01, 0xff, 0x46, 0x47, 0xdc, 0x4a, 0x11, 0x00, 0x45, 0xa4, 0xd3, + 0x42, 0x11, 0x40, 0x46, 0x6b, 0xda, 0x46, 0x11, 0x00, 0x46, 0x81, 0xc8, + 0x4b, 0x11, 0x00, 0x44, 0x0d, 0x89, 0x44, 0x11, 0x40, 0x46, 0xa9, 0xd5, + 0x49, 0x11, 0x00, 0x44, 0xaa, 0xd5, 0x48, 0x11, 0x40, 0x45, 0xf6, 0xe7, + 0x7b, 0xa9, 0x40, 0x0a, 0x6a, 0xaf, 0x54, 0x02, 0x49, 0x00, 0x0d, 0x44, + 0xaa, 0xd5, 0x0c, 0x11, 0xc0, 0x00, 0x46, 0x50, 0xde, 0x4d, 0x11, 0x40, + 0x44, 0xab, 0xd5, 0x0e, 0x11, 0x80, 0x2d, 0x05, 0x83, 0xf1, 0x01, 0xff, + 0xa3, 0x1a, 0xb3, 0x01, 0xff, 0x43, 0x46, 0x44, 0x3c, 0x11, 0x00, 0x04, + 0xb3, 0x2e, 0x01, 0xff, 0x45, 0x3e, 0xeb, 0x4f, 0x11, 0x00, 0x44, 0x35, + 0xc5, 0x3d, 0x11, 0x40, 0x46, 0xa9, 0xd5, 0x54, 0x11, 0x00, 0x44, 0xaa, + 0xd5, 0x4e, 0x11, 0x40, 0x8d, 0x01, 0xff, 0x45, 0xbc, 0xaa, 0x53, 0x11, + 0x00, 0x47, 0x78, 0xc8, 0x52, 0x11, 0x40, 0xa3, 0x1a, 0xb3, 0x01, 0xff, + 0x43, 0x46, 0x44, 0x3e, 0x11, 0x00, 0x04, 0xb3, 0x2e, 0x01, 0xff, 0x45, + 0x3e, 0xeb, 0x51, 0x11, 0x00, 0x44, 0x35, 0xc5, 0x3f, 0x11, 0x40, 0x46, + 0xa9, 0xd5, 0x55, 0x11, 0x00, 0x44, 0xaa, 0xd5, 0x50, 0x11, 0x40, 0x0c, + 0x38, 0x90, 0x14, 0x02, 0x16, 0x00, 0x06, 0x45, 0x48, 0xd3, 0x1d, 0xf9, + 0x41, 0xe7, 0x5c, 0xf4, 0x01, 0x42, 0x60, 0x07, 0x3e, 0xf9, 0x41, 0x5a, + 0x51, 0x20, 0x1e, 0xf9, 0x01, 0x58, 0x24, 0x2a, 0xf0, 0xfa, 0x41, 0x46, + 0x3c, 0xe0, 0x54, 0xf3, 0x01, 0x43, 0x09, 0x3a, 0x28, 0xf5, 0x81, 0x0d, + 0xb3, 0x01, 0xff, 0xe1, 0xac, 0xfa, 0x01, 0x48, 0x2f, 0xd1, 0x39, 0xf4, + 0x41, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0x16, 0xe5, 0x92, 0x26, 0x00, + 0x46, 0xe2, 0xe5, 0x2d, 0x26, 0x00, 0x46, 0x56, 0xe7, 0xe0, 0xf6, 0x41, + 0x4c, 0x10, 0x12, 0xed, 0xff, 0x00, 0x4f, 0xa0, 0x0c, 0xec, 0xff, 0x00, + 0x54, 0x8f, 0x44, 0xe8, 0xff, 0x00, 0x07, 0x45, 0xd7, 0xda, 0x02, 0x0c, + 0x6f, 0x21, 0xc9, 0x02, 0x08, 0x27, 0xcd, 0x2c, 0x04, 0xc3, 0x00, 0x1c, + 0x05, 0xc8, 0x00, 0x0c, 0x4d, 0xe4, 0x21, 0xea, 0xff, 0x00, 0x4c, 0x00, + 0x12, 0xee, 0xff, 0x40, 0x4f, 0x66, 0x6c, 0x63, 0xff, 0x00, 0x4b, 0xb8, + 0x02, 0xeb, 0xff, 0x40, 0x4f, 0x66, 0x6c, 0x62, 0xff, 0x00, 0x4b, 0xb8, + 0x02, 0xe9, 0xff, 0x40, 0x80, 0x06, 0x5e, 0x13, 0x13, 0x70, 0xff, 0x40, + 0x07, 0x13, 0x06, 0x12, 0x4a, 0x1d, 0x48, 0x65, 0xff, 0x00, 0x56, 0x29, + 0x39, 0x9f, 0xff, 0x00, 0x51, 0x2e, 0x39, 0x9e, 0xff, 0x40, 0xe1, 0x71, + 0xff, 0x00, 0xe5, 0x74, 0xff, 0x00, 0xa8, 0xdc, 0x01, 0xe9, 0x72, 0xff, + 0x00, 0xab, 0xc1, 0x01, 0xad, 0xaa, 0x01, 0xee, 0x9d, 0xff, 0x80, 0x90, + 0x01, 0xef, 0x75, 0xff, 0x00, 0xb2, 0x76, 0xb3, 0x33, 0xb4, 0x1d, 0xf5, + 0x73, 0xff, 0x00, 0xb7, 0x0f, 0xb9, 0x01, 0xff, 0xe1, 0x94, 0xff, 0x00, + 0xef, 0x96, 0xff, 0x00, 0xf5, 0x95, 0xff, 0x40, 0xe1, 0x9c, 0xff, 0x00, + 0xef, 0x66, 0xff, 0x40, 0xe1, 0x80, 0xff, 0x00, 0xe5, 0x83, 0xff, 0x00, + 0xe9, 0x81, 0xff, 0x00, 0xef, 0x84, 0xff, 0x00, 0xf5, 0x82, 0xff, 0x40, + 0xe1, 0x7b, 0xff, 0x00, 0xe5, 0x7e, 0xff, 0x00, 0xe9, 0x7c, 0xff, 0x00, + 0x05, 0x5e, 0x07, 0x08, 0xef, 0x7f, 0xff, 0x00, 0xf5, 0x7d, 0xff, 0x40, + 0xe1, 0x67, 0xff, 0x00, 0xe5, 0x6a, 0xff, 0x00, 0xe9, 0x68, 0xff, 0x00, + 0xef, 0x6b, 0xff, 0x00, 0x42, 0x5c, 0x01, 0x6f, 0xff, 0x00, 0xf5, 0x69, + 0xff, 0x00, 0xb9, 0x01, 0xff, 0xe1, 0x6c, 0xff, 0x00, 0xef, 0x6e, 0xff, + 0x00, 0xf5, 0x6d, 0xff, 0x40, 0xe1, 0x97, 0xff, 0x00, 0xe5, 0x9a, 0xff, + 0x00, 0xe9, 0x98, 0xff, 0x00, 0xef, 0x9b, 0xff, 0x00, 0xf5, 0x99, 0xff, + 0x40, 0xe1, 0x85, 0xff, 0x00, 0xe5, 0x88, 0xff, 0x00, 0xe9, 0x86, 0xff, + 0x00, 0xef, 0x89, 0xff, 0x00, 0xf5, 0x87, 0xff, 0x40, 0xe1, 0x8f, 0xff, + 0x00, 0xe5, 0x92, 0xff, 0x00, 0xe9, 0x90, 0xff, 0x00, 0xef, 0x93, 0xff, + 0x00, 0xf5, 0x91, 0xff, 0x40, 0xe1, 0x76, 0xff, 0x00, 0xe5, 0x79, 0xff, + 0x00, 0xe9, 0x77, 0xff, 0x00, 0xef, 0x7a, 0xff, 0x00, 0xf5, 0x78, 0xff, + 0x40, 0xe1, 0x8a, 0xff, 0x00, 0xe5, 0x8d, 0xff, 0x00, 0xe9, 0x8b, 0xff, + 0x00, 0xef, 0x8e, 0xff, 0x00, 0xf5, 0x8c, 0xff, 0x40, 0x45, 0x13, 0x05, + 0x64, 0xff, 0x00, 0x49, 0x4f, 0x17, 0x61, 0xff, 0x40, 0x46, 0xb7, 0x86, + 0xa0, 0xff, 0x00, 0x07, 0x13, 0x06, 0x01, 0xff, 0xe1, 0xc2, 0xff, 0x80, + 0xae, 0x02, 0xa3, 0x9f, 0x02, 0xe5, 0xc7, 0xff, 0x80, 0x91, 0x02, 0x45, + 0xbc, 0xaa, 0xbe, 0xff, 0x00, 0xe9, 0xdc, 0xff, 0x80, 0xff, 0x01, 0xab, + 0xe9, 0x01, 0x45, 0x9a, 0xee, 0xb1, 0xff, 0x00, 0x45, 0x0d, 0xef, 0xa4, + 0xff, 0x80, 0xcc, 0x01, 0xef, 0xcc, 0xff, 0x80, 0xc2, 0x01, 0xb0, 0xac, + 0x01, 0x45, 0x52, 0xf0, 0xa9, 0xff, 0x80, 0x76, 0xb3, 0x4b, 0xb4, 0x3d, + 0xf5, 0xd3, 0xff, 0x00, 0xb7, 0x21, 0xb9, 0x01, 0xff, 0xe1, 0xc4, 0xff, + 0x80, 0x15, 0xe5, 0xcb, 0xff, 0x80, 0x0c, 0xe9, 0xdb, 0xff, 0x00, 0xef, + 0xd2, 0xff, 0x00, 0xf5, 0xd7, 0xff, 0x40, 0xef, 0xca, 0xff, 0x40, 0xe5, + 0xc5, 0xff, 0x40, 0xe1, 0xcd, 0xff, 0x80, 0x0d, 0xe5, 0xd5, 0xff, 0x80, + 0x04, 0xe9, 0xd6, 0xff, 0x40, 0xef, 0xd4, 0xff, 0x40, 0xe5, 0xce, 0xff, + 0x40, 0x46, 0x47, 0xdc, 0xbc, 0xff, 0x00, 0x45, 0xa4, 0xd3, 0xa7, 0xff, + 0x40, 0x43, 0x46, 0x44, 0xb5, 0xff, 0x00, 0x04, 0xb3, 0x2e, 0x01, 0xff, + 0x45, 0x3e, 0xeb, 0xb9, 0xff, 0x00, 0x46, 0x11, 0xa8, 0xa2, 0xff, 0x00, + 0x45, 0x0c, 0x89, 0xb3, 0xff, 0x00, 0x44, 0x35, 0xc5, 0xb6, 0xff, 0x00, + 0x46, 0xa3, 0xd3, 0xa8, 0xff, 0x40, 0x8d, 0x01, 0xff, 0x45, 0xbc, 0xaa, + 0xb0, 0xff, 0x00, 0x46, 0x11, 0xa8, 0xaa, 0xff, 0x00, 0x45, 0x9a, 0xee, + 0xab, 0xff, 0x00, 0xb0, 0x0c, 0x44, 0x35, 0xc5, 0xad, 0xff, 0x00, 0x47, + 0x46, 0xdc, 0xae, 0xff, 0x40, 0x46, 0x81, 0xc8, 0xaf, 0xff, 0x00, 0x44, + 0x0d, 0x89, 0xac, 0xff, 0x40, 0x46, 0x81, 0xc8, 0xbd, 0xff, 0x00, 0x44, + 0x0d, 0x89, 0xb2, 0xff, 0xc0, 0x00, 0x45, 0xf6, 0xe7, 0xb4, 0xff, 0x40, + 0xe5, 0xcf, 0xff, 0x40, 0x8d, 0x01, 0xff, 0x45, 0x3e, 0xeb, 0xa5, 0xff, + 0x00, 0x45, 0xbc, 0xaa, 0xa6, 0xff, 0x40, 0x46, 0x79, 0xc8, 0xbb, 0xff, + 0x00, 0x45, 0x12, 0xa8, 0xa1, 0xff, 0xc0, 0x00, 0x45, 0xf6, 0xe7, 0xa3, + 0xff, 0x40, 0x44, 0xde, 0xd1, 0xb7, 0xff, 0x40, 0xef, 0xc6, 0xff, 0x00, + 0xf5, 0xda, 0xff, 0x40, 0x46, 0xa9, 0xd5, 0xba, 0xff, 0x00, 0x44, 0xaa, + 0xd5, 0xb8, 0xff, 0x40, 0xe5, 0xc3, 0xff, 0x40, 0x80, 0x0c, 0x43, 0x39, + 0x29, 0x87, 0xf4, 0x01, 0x4a, 0x74, 0xb9, 0xc8, 0xfa, 0x41, 0x44, 0x16, + 0xe5, 0xae, 0xfa, 0x01, 0x45, 0x2d, 0x4f, 0x0a, 0x20, 0x40, 0xa1, 0xd0, + 0x43, 0xa5, 0xfe, 0x38, 0x44, 0x9b, 0x80, 0x7b, 0xf4, 0x01, 0xa9, 0xd5, + 0x38, 0xac, 0x9f, 0x33, 0xaf, 0xba, 0x31, 0xb2, 0xdb, 0x0e, 0xf3, 0x1d, + 0x00, 0x00, 0xb5, 0x01, 0xff, 0x02, 0x17, 0x00, 0xc3, 0x0e, 0xa9, 0xb4, + 0x0e, 0x07, 0x02, 0xd8, 0xf9, 0x09, 0x0c, 0x7c, 0x97, 0xef, 0x06, 0xb2, + 0x01, 0xff, 0x06, 0x08, 0xe4, 0xf4, 0x02, 0x0a, 0x48, 0xb8, 0x01, 0xff, + 0x16, 0x09, 0x35, 0xd2, 0x02, 0x06, 0xef, 0x06, 0x8b, 0x02, 0x07, 0x13, + 0x06, 0x52, 0x05, 0x5a, 0x03, 0x42, 0x06, 0x74, 0x3b, 0x01, 0xff, 0x4b, + 0x7a, 0x3b, 0x29, 0x61, 0x01, 0x05, 0x5a, 0x03, 0x01, 0xff, 0xa1, 0x24, + 0xe5, 0x23, 0x61, 0x81, 0x1b, 0xe9, 0x1f, 0x61, 0x81, 0x12, 0xef, 0x26, + 0x61, 0x81, 0x09, 0xf5, 0x21, 0x61, 0xc1, 0x00, 0xf5, 0x22, 0x61, 0x41, + 0xef, 0x27, 0x61, 0x41, 0xe9, 0x20, 0x61, 0x41, 0xe5, 0x24, 0x61, 0x41, + 0xe1, 0x1e, 0x61, 0x01, 0xe9, 0x25, 0x61, 0x01, 0xf5, 0x28, 0x61, 0x41, + 0x48, 0x0a, 0x17, 0x2d, 0x61, 0x01, 0x48, 0x37, 0xd1, 0x2f, 0x61, 0x41, + 0xe1, 0x00, 0x61, 0x01, 0xa2, 0xa4, 0x01, 0xa3, 0x97, 0x01, 0xa4, 0x7f, + 0xa7, 0x73, 0x42, 0x22, 0x00, 0x0a, 0x61, 0x01, 0xaa, 0x61, 0xab, 0x55, + 0x42, 0x74, 0x00, 0x1c, 0x61, 0x01, 0x42, 0x6c, 0x00, 0x19, 0x61, 0x01, + 0xae, 0x3d, 0xb0, 0x31, 0x42, 0x71, 0x00, 0x1b, 0x61, 0x01, 0x42, 0x40, + 0x06, 0x1d, 0x61, 0x01, 0xb4, 0x0c, 0x42, 0x61, 0x0b, 0x0f, 0x61, 0x01, + 0x42, 0xdf, 0x23, 0x1a, 0x61, 0x41, 0xe1, 0x10, 0x61, 0x01, 0x42, 0x22, + 0x00, 0x11, 0x61, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x0b, 0x61, 0x01, 0x42, + 0x22, 0x00, 0x0c, 0x61, 0x41, 0xe1, 0x15, 0x61, 0x01, 0x42, 0x22, 0x00, + 0x16, 0x61, 0x41, 0xe1, 0x14, 0x61, 0x01, 0x42, 0x24, 0x02, 0x05, 0x61, + 0x41, 0xe1, 0x01, 0x61, 0x01, 0x42, 0x22, 0x00, 0x02, 0x61, 0x41, 0xe1, + 0x08, 0x61, 0x01, 0x42, 0x22, 0x00, 0x09, 0x61, 0x41, 0xe1, 0x03, 0x61, + 0x01, 0x42, 0x22, 0x00, 0x04, 0x61, 0x41, 0xe1, 0x12, 0x61, 0x01, 0xa4, + 0x06, 0x42, 0x22, 0x00, 0x13, 0x61, 0x41, 0xe1, 0x0d, 0x61, 0x01, 0x42, + 0x22, 0x00, 0x0e, 0x61, 0x41, 0xe1, 0x06, 0x61, 0x01, 0x42, 0x22, 0x00, + 0x07, 0x61, 0x41, 0xe1, 0x17, 0x61, 0x01, 0x42, 0x22, 0x00, 0x18, 0x61, + 0x41, 0x45, 0x7e, 0x0b, 0x38, 0x61, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, + 0x39, 0x61, 0x01, 0x43, 0x7a, 0x0b, 0x31, 0x61, 0x01, 0xb3, 0x14, 0xb4, + 0x06, 0x44, 0x80, 0x1f, 0x30, 0x61, 0x41, 0x44, 0x25, 0x01, 0x33, 0x61, + 0x01, 0x42, 0x15, 0x02, 0x32, 0x61, 0x41, 0x44, 0x06, 0x1f, 0x37, 0x61, + 0x01, 0x42, 0x09, 0x24, 0x36, 0x61, 0x41, 0x43, 0xf9, 0x05, 0x35, 0x61, + 0x01, 0x43, 0xf6, 0x06, 0x34, 0x61, 0x41, 0x42, 0x22, 0x00, 0x2c, 0x61, + 0x01, 0x42, 0x71, 0x00, 0x2e, 0x61, 0x01, 0x42, 0x61, 0x0b, 0x2b, 0x61, + 0x01, 0x42, 0xdf, 0x23, 0x2a, 0x61, 0x41, 0xa1, 0xe4, 0x03, 0x06, 0xef, + 0x06, 0x9d, 0x03, 0x48, 0x37, 0xcb, 0x74, 0x0a, 0x00, 0x43, 0x50, 0x0b, + 0x72, 0x0a, 0x00, 0x07, 0x13, 0x06, 0x6f, 0x05, 0x5a, 0x03, 0x3d, 0x45, + 0x33, 0xf1, 0x70, 0x0a, 0x00, 0x43, 0x70, 0x00, 0x73, 0x0a, 0x00, 0x0b, + 0xc7, 0x7a, 0x01, 0xff, 0xa1, 0x1e, 0x42, 0x27, 0x01, 0x47, 0x0a, 0x00, + 0xe9, 0x3f, 0x0a, 0x80, 0x0f, 0x42, 0xcd, 0x02, 0x4b, 0x0a, 0x00, 0xf5, + 0x41, 0x0a, 0xc0, 0x00, 0xf5, 0x42, 0x0a, 0x40, 0xe9, 0x40, 0x0a, 0x40, + 0xe1, 0x3e, 0x0a, 0x00, 0xe9, 0x48, 0x0a, 0x00, 0xf5, 0x4c, 0x0a, 0x40, + 0x4a, 0xae, 0xac, 0x01, 0x0a, 0x00, 0x45, 0x82, 0x6e, 0x02, 0x0a, 0x00, + 0x45, 0x62, 0x41, 0x3c, 0x0a, 0x00, 0x45, 0xa1, 0xf1, 0x51, 0x0a, 0x00, + 0x02, 0x02, 0x00, 0x06, 0x46, 0x6e, 0xe7, 0x75, 0x0a, 0x40, 0x44, 0x21, + 0x25, 0x4d, 0x0a, 0x00, 0x45, 0x49, 0x4e, 0x03, 0x0a, 0x40, 0xe1, 0x05, + 0x0a, 0x80, 0x8c, 0x02, 0xa2, 0xff, 0x01, 0xa3, 0xf2, 0x01, 0xa4, 0xd9, + 0x01, 0x42, 0x27, 0x01, 0x0f, 0x0a, 0x00, 0x42, 0x0c, 0x08, 0x5e, 0x0a, + 0x00, 0xa7, 0xb9, 0x01, 0x42, 0x22, 0x00, 0x39, 0x0a, 0x00, 0xe9, 0x07, + 0x0a, 0x80, 0xa9, 0x01, 0xaa, 0x9c, 0x01, 0xab, 0x88, 0x01, 0xac, 0x7c, + 0x42, 0x6c, 0x00, 0x2e, 0x0a, 0x00, 0xae, 0x5e, 0x42, 0xcd, 0x02, 0x13, + 0x0a, 0x00, 0xb0, 0x4c, 0xb2, 0x40, 0xb3, 0x34, 0xb4, 0x1b, 0xf5, 0x09, + 0x0a, 0x80, 0x12, 0x42, 0x61, 0x0b, 0x35, 0x0a, 0x00, 0x42, 0xdf, 0x23, + 0x2f, 0x0a, 0x00, 0x42, 0x59, 0x00, 0x5b, 0x0a, 0x40, 0xf5, 0x0a, 0x0a, + 0x40, 0xe1, 0x24, 0x0a, 0x00, 0x42, 0x22, 0x00, 0x25, 0x0a, 0x00, 0xb4, + 0x01, 0xff, 0xe1, 0x1f, 0x0a, 0x00, 0x42, 0x22, 0x00, 0x20, 0x0a, 0x40, + 0xe1, 0x38, 0x0a, 0x00, 0x42, 0x22, 0x00, 0x36, 0x0a, 0x40, 0xe1, 0x30, + 0x0a, 0x00, 0x42, 0x71, 0x00, 0x5c, 0x0a, 0x40, 0xe1, 0x2a, 0x0a, 0x00, + 0x42, 0x22, 0x00, 0x2b, 0x0a, 0x40, 0xe1, 0x28, 0x0a, 0x00, 0x42, 0x24, + 0x02, 0x19, 0x0a, 0x00, 0x42, 0x2a, 0x05, 0x23, 0x0a, 0x00, 0x42, 0xdf, + 0x23, 0x1e, 0x0a, 0x40, 0xe1, 0x32, 0x0a, 0x00, 0x42, 0x74, 0x00, 0x33, + 0x0a, 0x40, 0xe1, 0x15, 0x0a, 0x00, 0xa8, 0x01, 0xff, 0xe1, 0x16, 0x0a, + 0x00, 0x42, 0x22, 0x00, 0x59, 0x0a, 0x40, 0xe1, 0x1c, 0x0a, 0x00, 0x42, + 0x22, 0x00, 0x1d, 0x0a, 0x40, 0xe9, 0x08, 0x0a, 0x40, 0xe1, 0x17, 0x0a, + 0x00, 0xa8, 0x01, 0xff, 0xe1, 0x18, 0x0a, 0x00, 0x42, 0x22, 0x00, 0x5a, + 0x0a, 0x40, 0xe1, 0x26, 0x0a, 0x00, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x27, + 0x0a, 0x40, 0xe1, 0x21, 0x0a, 0x00, 0x42, 0x22, 0x00, 0x22, 0x0a, 0x40, + 0xe1, 0x1a, 0x0a, 0x00, 0x42, 0x22, 0x00, 0x1b, 0x0a, 0x40, 0xe1, 0x2c, + 0x0a, 0x00, 0x42, 0x22, 0x00, 0x2d, 0x0a, 0x40, 0xe1, 0x06, 0x0a, 0x00, + 0xe9, 0x10, 0x0a, 0x00, 0xf5, 0x14, 0x0a, 0x40, 0x45, 0x7e, 0x0b, 0x6e, + 0x0a, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x6f, 0x0a, 0x00, 0x43, 0x7a, + 0x0b, 0x67, 0x0a, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x66, + 0x0a, 0x40, 0x44, 0x25, 0x01, 0x69, 0x0a, 0x00, 0x42, 0x15, 0x02, 0x68, + 0x0a, 0x40, 0x44, 0x06, 0x1f, 0x6d, 0x0a, 0x00, 0x42, 0x09, 0x24, 0x6c, + 0x0a, 0x40, 0x43, 0xf9, 0x05, 0x6b, 0x0a, 0x00, 0x43, 0xf6, 0x06, 0x6a, + 0x0a, 0x40, 0x50, 0x5e, 0x5a, 0x76, 0x0a, 0x00, 0x44, 0x60, 0xf5, 0x71, + 0x0a, 0x40, 0x06, 0xef, 0x06, 0xbe, 0x02, 0x07, 0x13, 0x06, 0x50, 0x42, + 0x14, 0x05, 0x98, 0x1d, 0x01, 0x05, 0x5a, 0x03, 0x3a, 0xb6, 0x01, 0xff, + 0x45, 0x20, 0x25, 0x97, 0x1d, 0x01, 0x0a, 0xc8, 0x7a, 0x01, 0xff, 0xa1, + 0x1e, 0x42, 0x27, 0x01, 0x90, 0x1d, 0x01, 0xe9, 0x8b, 0x1d, 0x81, 0x0f, + 0x42, 0xcd, 0x02, 0x93, 0x1d, 0x01, 0xf5, 0x8d, 0x1d, 0xc1, 0x00, 0xf5, + 0x8e, 0x1d, 0x41, 0xe9, 0x8c, 0x1d, 0x41, 0xe1, 0x8a, 0x1d, 0x01, 0xe9, + 0x91, 0x1d, 0x01, 0xf5, 0x94, 0x1d, 0x41, 0x48, 0x0a, 0x17, 0x95, 0x1d, + 0x01, 0x47, 0x47, 0x4e, 0x96, 0x1d, 0x41, 0xe1, 0x60, 0x1d, 0x81, 0xd8, + 0x01, 0xa2, 0xcb, 0x01, 0xa3, 0xbe, 0x01, 0xa4, 0xa5, 0x01, 0x42, 0x27, + 0x01, 0x67, 0x1d, 0x01, 0xa7, 0x92, 0x01, 0x42, 0x22, 0x00, 0x87, 0x1d, + 0x01, 0xe9, 0x62, 0x1d, 0x81, 0x82, 0x01, 0xaa, 0x76, 0xab, 0x6a, 0xac, + 0x5e, 0x42, 0x6c, 0x00, 0x70, 0x1d, 0x01, 0xae, 0x4c, 0x42, 0xcd, 0x02, + 0x6a, 0x1d, 0x01, 0xb0, 0x3a, 0x42, 0x71, 0x00, 0x88, 0x1d, 0x01, 0x42, + 0x40, 0x06, 0x89, 0x1d, 0x01, 0xb4, 0x15, 0xf5, 0x64, 0x1d, 0x81, 0x0c, + 0x42, 0x61, 0x0b, 0x6d, 0x1d, 0x01, 0x42, 0xdf, 0x23, 0x6c, 0x1d, 0x41, + 0xf5, 0x65, 0x1d, 0x41, 0xe1, 0x73, 0x1d, 0x01, 0x42, 0x22, 0x00, 0x74, + 0x1d, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x7d, 0x1d, 0x01, 0x42, 0x22, 0x00, + 0x7e, 0x1d, 0x41, 0xe1, 0x85, 0x1d, 0x01, 0x42, 0x22, 0x00, 0x86, 0x1d, + 0x41, 0xe1, 0x7a, 0x1d, 0x01, 0x42, 0x24, 0x02, 0x84, 0x1d, 0x41, 0xe1, + 0x75, 0x1d, 0x01, 0x42, 0x74, 0x00, 0x7f, 0x1d, 0x41, 0xe1, 0x71, 0x1d, + 0x01, 0x42, 0x22, 0x00, 0x72, 0x1d, 0x41, 0xe1, 0x80, 0x1d, 0x01, 0x42, + 0x22, 0x00, 0x81, 0x1d, 0x41, 0xe9, 0x63, 0x1d, 0x41, 0xe1, 0x76, 0x1d, + 0x01, 0x42, 0x22, 0x00, 0x77, 0x1d, 0x41, 0xe1, 0x78, 0x1d, 0x01, 0xa4, + 0x06, 0x42, 0x22, 0x00, 0x79, 0x1d, 0x41, 0xe1, 0x82, 0x1d, 0x01, 0x42, + 0x22, 0x00, 0x83, 0x1d, 0x41, 0xe1, 0x7b, 0x1d, 0x01, 0x42, 0x22, 0x00, + 0x7c, 0x1d, 0x41, 0xe1, 0x6e, 0x1d, 0x01, 0x42, 0x22, 0x00, 0x6f, 0x1d, + 0x41, 0xe1, 0x61, 0x1d, 0x01, 0xe9, 0x68, 0x1d, 0x01, 0xf5, 0x6b, 0x1d, + 0x41, 0x45, 0x7e, 0x0b, 0xa8, 0x1d, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, + 0xa9, 0x1d, 0x01, 0x43, 0x7a, 0x0b, 0xa1, 0x1d, 0x01, 0xb3, 0x14, 0xb4, + 0x06, 0x44, 0x80, 0x1f, 0xa0, 0x1d, 0x41, 0x44, 0x25, 0x01, 0xa3, 0x1d, + 0x01, 0x42, 0x15, 0x02, 0xa2, 0x1d, 0x41, 0x44, 0x06, 0x1f, 0xa7, 0x1d, + 0x01, 0x42, 0x09, 0x24, 0xa6, 0x1d, 0x41, 0x43, 0xf9, 0x05, 0xa5, 0x1d, + 0x01, 0x43, 0xf6, 0x06, 0xa4, 0x1d, 0x41, 0x51, 0x5d, 0x5a, 0xf0, 0x0a, + 0x00, 0x06, 0xef, 0x06, 0xe9, 0x03, 0x07, 0x13, 0x06, 0xc6, 0x01, 0x42, + 0x14, 0x05, 0xd0, 0x0a, 0x00, 0x4a, 0x68, 0x84, 0xf1, 0x0a, 0x00, 0x05, + 0x5a, 0x03, 0x61, 0x06, 0x74, 0x3b, 0x01, 0xff, 0x07, 0x0a, 0x64, 0x50, + 0x05, 0x5a, 0x03, 0x01, 0xff, 0xa1, 0x3d, 0x07, 0x0a, 0x64, 0x31, 0xe5, + 0xc7, 0x0a, 0x00, 0xe9, 0xbf, 0x0a, 0x80, 0x24, 0xef, 0xcb, 0x0a, 0x00, + 0xf5, 0xc1, 0x0a, 0x80, 0x17, 0x08, 0xf2, 0xc6, 0x01, 0xff, 0xec, 0xe2, + 0x0a, 0x80, 0x09, 0xf2, 0xc3, 0x0a, 0xc0, 0x00, 0xf2, 0xc4, 0x0a, 0x40, + 0xec, 0xe3, 0x0a, 0x40, 0xf5, 0xc2, 0x0a, 0x40, 0xe9, 0xc0, 0x0a, 0x40, + 0xe5, 0xc5, 0x0a, 0x00, 0xef, 0xc9, 0x0a, 0x40, 0xe1, 0xbe, 0x0a, 0x00, + 0xe9, 0xc8, 0x0a, 0x00, 0xf5, 0xcc, 0x0a, 0x40, 0xe5, 0x8d, 0x0a, 0x00, + 0xef, 0x91, 0x0a, 0x40, 0xa1, 0x47, 0xa3, 0x39, 0x46, 0xde, 0xe3, 0xfc, + 0x0a, 0x00, 0x45, 0x62, 0x41, 0xbc, 0x0a, 0x00, 0xb3, 0x1f, 0xb4, 0x11, + 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0x21, 0x25, 0xcd, 0x0a, 0x00, 0x45, + 0x49, 0x4e, 0x83, 0x0a, 0x40, 0x54, 0x1b, 0x45, 0xfd, 0x0a, 0x00, 0x55, + 0x58, 0x41, 0xff, 0x0a, 0x40, 0x45, 0xba, 0xec, 0xfb, 0x0a, 0x00, 0x44, + 0x0c, 0xf1, 0xfa, 0x0a, 0x40, 0x4a, 0x14, 0x25, 0x81, 0x0a, 0x00, 0x51, + 0x5c, 0x41, 0xfe, 0x0a, 0x40, 0x47, 0x0b, 0x17, 0x82, 0x0a, 0x00, 0x47, + 0x34, 0x8d, 0xbd, 0x0a, 0x40, 0xe1, 0x85, 0x0a, 0x80, 0x8c, 0x02, 0xa2, + 0xff, 0x01, 0xa3, 0xf2, 0x01, 0xa4, 0xd9, 0x01, 0xe5, 0x8f, 0x0a, 0x00, + 0xa7, 0xc8, 0x01, 0x42, 0x22, 0x00, 0xb9, 0x0a, 0x00, 0xe9, 0x87, 0x0a, + 0x80, 0xb8, 0x01, 0xaa, 0xab, 0x01, 0xab, 0x9e, 0x01, 0xac, 0x91, 0x01, + 0x42, 0x6c, 0x00, 0xae, 0x0a, 0x00, 0xae, 0x73, 0xef, 0x93, 0x0a, 0x00, + 0xb0, 0x63, 0x42, 0x71, 0x00, 0xb0, 0x0a, 0x00, 0xb3, 0x4b, 0xb4, 0x32, + 0xf5, 0x89, 0x0a, 0x80, 0x29, 0xb6, 0x0c, 0x42, 0xdf, 0x23, 0xaf, 0x0a, + 0x00, 0x43, 0x9b, 0xc6, 0xf9, 0x0a, 0x40, 0xe1, 0xb5, 0x0a, 0x00, 0x07, + 0xf3, 0xc6, 0x01, 0xff, 0xec, 0x8c, 0x0a, 0x80, 0x09, 0xf2, 0x8b, 0x0a, + 0xc0, 0x00, 0xf2, 0xe0, 0x0a, 0x40, 0xec, 0xe1, 0x0a, 0x40, 0xf5, 0x8a, + 0x0a, 0x40, 0xe1, 0xa4, 0x0a, 0x00, 0x42, 0x22, 0x00, 0xa5, 0x0a, 0x00, + 0xb4, 0x01, 0xff, 0xe1, 0x9f, 0x0a, 0x00, 0x42, 0x22, 0x00, 0xa0, 0x0a, + 0x40, 0xe1, 0xb8, 0x0a, 0x00, 0x42, 0x22, 0x00, 0xb6, 0x0a, 0x00, 0x42, + 0x40, 0x06, 0xb7, 0x0a, 0x40, 0xe1, 0xaa, 0x0a, 0x00, 0x42, 0x22, 0x00, + 0xab, 0x0a, 0x40, 0xe1, 0xa8, 0x0a, 0x00, 0x42, 0x24, 0x02, 0x99, 0x0a, + 0x00, 0x42, 0x2a, 0x05, 0xa3, 0x0a, 0x00, 0x42, 0xdf, 0x23, 0x9e, 0x0a, + 0x40, 0xe1, 0xb2, 0x0a, 0x00, 0x42, 0x74, 0x00, 0xb3, 0x0a, 0x40, 0xe1, + 0x95, 0x0a, 0x00, 0x42, 0x22, 0x00, 0x96, 0x0a, 0x40, 0xe1, 0x9c, 0x0a, + 0x00, 0x42, 0x22, 0x00, 0x9d, 0x0a, 0x40, 0xe9, 0x88, 0x0a, 0x40, 0xe1, + 0x97, 0x0a, 0x00, 0x42, 0x22, 0x00, 0x98, 0x0a, 0x40, 0xe1, 0xa6, 0x0a, + 0x00, 0xa4, 0x06, 0x42, 0x22, 0x00, 0xa7, 0x0a, 0x40, 0xe1, 0xa1, 0x0a, + 0x00, 0x42, 0x22, 0x00, 0xa2, 0x0a, 0x40, 0xe1, 0x9a, 0x0a, 0x00, 0x42, + 0x22, 0x00, 0x9b, 0x0a, 0x40, 0xe1, 0xac, 0x0a, 0x00, 0x42, 0x22, 0x00, + 0xad, 0x0a, 0x40, 0xe1, 0x86, 0x0a, 0x00, 0xe9, 0x90, 0x0a, 0x00, 0xf5, + 0x94, 0x0a, 0x40, 0x45, 0x7e, 0x0b, 0xee, 0x0a, 0x00, 0xa6, 0x2e, 0x44, + 0x6d, 0x2c, 0xef, 0x0a, 0x00, 0x43, 0x7a, 0x0b, 0xe7, 0x0a, 0x00, 0xb3, + 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xe6, 0x0a, 0x40, 0x44, 0x25, 0x01, + 0xe9, 0x0a, 0x00, 0x42, 0x15, 0x02, 0xe8, 0x0a, 0x40, 0x44, 0x06, 0x1f, + 0xed, 0x0a, 0x00, 0x42, 0x09, 0x24, 0xec, 0x0a, 0x40, 0x43, 0xf9, 0x05, + 0xeb, 0x0a, 0x00, 0x43, 0xf6, 0x06, 0xea, 0x0a, 0x40, 0x46, 0xc6, 0xe0, + 0xae, 0xf9, 0x01, 0x43, 0x00, 0x14, 0xb8, 0xf3, 0x41, 0x48, 0x3a, 0xa1, + 0xb2, 0x20, 0x00, 0x45, 0x9d, 0xeb, 0x82, 0xf4, 0x41, 0xa1, 0x81, 0x1f, + 0xa5, 0x4d, 0xa9, 0x19, 0xaf, 0x01, 0xff, 0x03, 0x4b, 0x16, 0x06, 0x4a, + 0x24, 0xb9, 0x97, 0xf4, 0x41, 0x44, 0xb9, 0x00, 0xd2, 0x2b, 0x00, 0x49, + 0xfb, 0x21, 0x1d, 0x00, 0x40, 0x4b, 0x65, 0xa4, 0x2c, 0xf6, 0x01, 0x06, + 0xa0, 0xa7, 0x01, 0xff, 0x5a, 0x85, 0x20, 0x38, 0xf6, 0x01, 0x44, 0x0c, + 0x08, 0x00, 0xf6, 0xc1, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x5b, 0xd0, + 0x1d, 0x2a, 0xf9, 0x01, 0xb3, 0x01, 0xff, 0x4b, 0x94, 0x20, 0x01, 0xf6, + 0x01, 0x48, 0x1f, 0xd1, 0x29, 0xf9, 0x41, 0x0a, 0x8a, 0x00, 0xce, 0x1c, + 0xa5, 0x06, 0x47, 0xab, 0xdd, 0x76, 0xfa, 0x41, 0x02, 0xbc, 0x00, 0x1d, + 0x02, 0x92, 0x00, 0x01, 0xff, 0x45, 0x58, 0xea, 0x4f, 0xf3, 0x01, 0x44, + 0x28, 0xf5, 0xd7, 0xf4, 0x01, 0x45, 0xcf, 0x22, 0x9a, 0xf4, 0x01, 0x45, + 0xa2, 0xf0, 0x57, 0xf9, 0x41, 0xa1, 0xde, 0x18, 0x4b, 0xa3, 0x9e, 0xd0, + 0x03, 0x00, 0x08, 0x0b, 0x06, 0xbe, 0x10, 0xa4, 0xf7, 0x0f, 0xa6, 0xe8, + 0x0f, 0x4b, 0xa5, 0xa1, 0x88, 0x01, 0x01, 0x02, 0x9e, 0x01, 0xb8, 0x0e, + 0xab, 0x9b, 0x0e, 0xac, 0xa9, 0x0d, 0xad, 0x9a, 0x0d, 0x4c, 0xb2, 0x5f, + 0x74, 0x03, 0x00, 0xaf, 0xe8, 0x0c, 0xb0, 0xaf, 0x0c, 0x4d, 0x88, 0x36, + 0x7e, 0x03, 0x00, 0xb2, 0x8f, 0x0c, 0xb3, 0xf4, 0x01, 0xb4, 0xb5, 0x01, + 0x0d, 0x3f, 0x8e, 0x9e, 0x01, 0xb6, 0x1a, 0x4b, 0x95, 0xaa, 0x85, 0x01, + 0x01, 0xb9, 0x06, 0x49, 0x9d, 0xc7, 0x8a, 0x01, 0x41, 0x48, 0x5f, 0xc7, + 0x79, 0x01, 0x01, 0x4c, 0x83, 0x51, 0x7a, 0x03, 0x40, 0x44, 0xba, 0x30, + 0xef, 0x1f, 0x00, 0x15, 0x4b, 0x3f, 0x01, 0xff, 0xd1, 0x00, 0xd2, 0x81, + 0x4a, 0xd2, 0x01, 0xd2, 0x81, 0x31, 0xd3, 0x02, 0xd2, 0x01, 0xd4, 0x03, + 0xd2, 0x01, 0xd5, 0x04, 0xd2, 0x81, 0x10, 0xd6, 0x05, 0xd2, 0x01, 0xd7, + 0x06, 0xd2, 0x01, 0xd8, 0x07, 0xd2, 0x01, 0xd9, 0x08, 0xd2, 0x41, 0xd0, + 0x18, 0xd2, 0x01, 0xd1, 0x19, 0xd2, 0x01, 0xd2, 0x1a, 0xd2, 0x01, 0xd3, + 0x1b, 0xd2, 0x01, 0xd4, 0x1c, 0xd2, 0x41, 0xd0, 0x13, 0xd2, 0x01, 0xd1, + 0x14, 0xd2, 0x01, 0xd2, 0x15, 0xd2, 0x01, 0xd3, 0x16, 0xd2, 0x01, 0xd4, + 0x17, 0xd2, 0x41, 0xd0, 0x09, 0xd2, 0x01, 0xd1, 0x0a, 0xd2, 0x01, 0xd2, + 0x0b, 0xd2, 0x01, 0xd3, 0x0c, 0xd2, 0x01, 0xd4, 0x0d, 0xd2, 0x01, 0xd5, + 0x0e, 0xd2, 0x01, 0xd6, 0x0f, 0xd2, 0x01, 0xd7, 0x10, 0xd2, 0x01, 0xd8, + 0x11, 0xd2, 0x01, 0xd9, 0x12, 0xd2, 0x41, 0x55, 0x1c, 0x3b, 0xd3, 0x03, + 0x00, 0x59, 0xf3, 0x24, 0xd4, 0x03, 0x00, 0x4b, 0x01, 0x25, 0xd2, 0x03, + 0x40, 0x4a, 0xf4, 0xac, 0x7a, 0x01, 0x01, 0xa8, 0x1d, 0x44, 0x41, 0x6f, + 0x84, 0x03, 0x00, 0x51, 0x57, 0x60, 0x89, 0x01, 0x01, 0x03, 0x45, 0x0a, + 0x01, 0xff, 0x4a, 0xa4, 0x7c, 0x7d, 0x01, 0x01, 0x4b, 0xbc, 0xa8, 0x77, + 0x01, 0x41, 0x4a, 0xc6, 0x9a, 0xd1, 0x03, 0x00, 0x04, 0x26, 0x01, 0x01, + 0xff, 0x4a, 0xa4, 0x7c, 0x7e, 0x01, 0x01, 0x4d, 0x1d, 0x8c, 0x78, 0x01, + 0x41, 0x4c, 0xf4, 0x94, 0x8c, 0x01, 0x01, 0x05, 0x5e, 0x07, 0x28, 0x16, + 0xc3, 0x39, 0x06, 0x4d, 0x43, 0x8f, 0xa0, 0x01, 0x41, 0x44, 0xa3, 0x9e, + 0x66, 0x1d, 0x00, 0x43, 0x47, 0x17, 0x6a, 0x1d, 0x00, 0x45, 0xad, 0x5a, + 0x67, 0x1d, 0x00, 0x43, 0xcb, 0x18, 0x69, 0x1d, 0x00, 0x43, 0x39, 0x4c, + 0x68, 0x1d, 0x40, 0x5a, 0xd3, 0x20, 0x7c, 0x03, 0x00, 0x07, 0x13, 0x06, + 0x11, 0x09, 0xab, 0x15, 0x01, 0xff, 0x5a, 0xd3, 0x20, 0x7d, 0x03, 0x00, + 0x53, 0xda, 0x20, 0x7b, 0x03, 0x40, 0xa1, 0xf6, 0x07, 0x44, 0xa3, 0x9e, + 0xb2, 0x03, 0x00, 0x43, 0x47, 0x17, 0xc7, 0x03, 0x00, 0xa4, 0xdb, 0x07, + 0xa5, 0xd6, 0x05, 0x4b, 0x42, 0xa1, 0xc2, 0x03, 0x00, 0x45, 0xad, 0x5a, + 0xb3, 0x03, 0x00, 0x44, 0xf8, 0x78, 0x71, 0x03, 0x00, 0x44, 0x20, 0x30, + 0xb9, 0x03, 0x80, 0xac, 0x04, 0xab, 0x9d, 0x04, 0x45, 0x0e, 0xee, 0xbb, + 0x03, 0x00, 0x42, 0x91, 0x17, 0xbc, 0x03, 0x00, 0x42, 0x0b, 0x17, 0xbd, + 0x03, 0x00, 0x02, 0x14, 0x05, 0x85, 0x02, 0xb0, 0xec, 0x01, 0x43, 0x39, + 0x4c, 0xc1, 0x03, 0x80, 0xd3, 0x01, 0xb3, 0xb2, 0x01, 0xb4, 0xa3, 0x01, + 0x47, 0x3f, 0x8e, 0xc5, 0x03, 0x80, 0x0c, 0x42, 0x70, 0x0d, 0xbe, 0x03, + 0x00, 0x44, 0x60, 0xf9, 0xb6, 0x03, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, + 0xa4, 0x47, 0x46, 0xd1, 0x73, 0xe1, 0x1f, 0x00, 0x44, 0xec, 0xf7, 0x7b, + 0x1f, 0x00, 0xb0, 0x15, 0x45, 0x40, 0x6f, 0xcd, 0x03, 0x00, 0xb6, 0x01, + 0xff, 0x44, 0xba, 0x30, 0x7a, 0x1f, 0x00, 0x45, 0x16, 0xf0, 0xe0, 0x1f, + 0x40, 0x4a, 0x76, 0xa6, 0xe6, 0x1f, 0x00, 0x44, 0x48, 0x8d, 0x50, 0x1f, + 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, 0x54, 0x1f, + 0x00, 0x4b, 0x75, 0xa6, 0x56, 0x1f, 0x00, 0x45, 0xb9, 0x30, 0x52, 0x1f, + 0x40, 0x44, 0x1b, 0x64, 0x51, 0x1f, 0x80, 0x24, 0x48, 0x37, 0x6f, 0xcb, + 0x03, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, 0xe3, + 0x1f, 0x00, 0x4b, 0x75, 0xa6, 0xe7, 0x1f, 0x00, 0x45, 0x40, 0x6f, 0xb0, + 0x03, 0x00, 0x45, 0xb9, 0x30, 0xe2, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, + 0xff, 0x44, 0xec, 0xf7, 0x55, 0x1f, 0x00, 0x4b, 0x75, 0xa6, 0x57, 0x1f, + 0x00, 0x45, 0xb9, 0x30, 0x53, 0x1f, 0x40, 0x42, 0xb4, 0x25, 0xc4, 0x03, + 0x00, 0x44, 0xf8, 0x78, 0xb8, 0x03, 0x40, 0xa1, 0x12, 0x42, 0x0b, 0x00, + 0xf8, 0x03, 0x00, 0x44, 0xe2, 0x20, 0xc3, 0x03, 0x00, 0x45, 0x29, 0xf1, + 0xdb, 0x03, 0x40, 0x43, 0xce, 0x5f, 0xe1, 0x03, 0x00, 0xee, 0xfb, 0x03, + 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0x2a, 0x7a, 0xe5, 0x1f, 0x00, + 0x45, 0xfd, 0xef, 0xe4, 0x1f, 0x40, 0x51, 0xa1, 0x5a, 0x77, 0x03, 0x00, + 0x42, 0x49, 0x00, 0xc6, 0x03, 0x00, 0xe9, 0xc0, 0x03, 0x00, 0x42, 0x5a, + 0x03, 0xc8, 0x03, 0x40, 0x43, 0xf5, 0x05, 0xc9, 0x03, 0x80, 0x4e, 0x45, + 0x3c, 0xed, 0xbf, 0x03, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, + 0x2a, 0x7a, 0x41, 0x1f, 0x80, 0x2a, 0x44, 0xec, 0xf7, 0x79, 0x1f, 0x00, + 0x45, 0xfd, 0xef, 0x40, 0x1f, 0x80, 0x0c, 0x45, 0x40, 0x6f, 0xcc, 0x03, + 0x00, 0x45, 0xb9, 0x30, 0x78, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, + 0x44, 0xec, 0xf7, 0x44, 0x1f, 0x00, 0x45, 0xb9, 0x30, 0x42, 0x1f, 0x40, + 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, 0x45, 0x1f, 0x00, 0x45, + 0xb9, 0x30, 0x43, 0x1f, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0x2a, + 0x7a, 0x61, 0x1f, 0x80, 0x6e, 0x44, 0xec, 0xf7, 0x7d, 0x1f, 0x80, 0x61, + 0xb0, 0x19, 0x45, 0x40, 0x6f, 0xce, 0x03, 0x00, 0x45, 0xb9, 0x30, 0x7c, + 0x1f, 0x80, 0x06, 0x4d, 0x82, 0x51, 0xf3, 0x1f, 0x40, 0x52, 0x7d, 0x51, + 0xf2, 0x1f, 0x40, 0x4a, 0x76, 0xa6, 0xf6, 0x1f, 0x80, 0x39, 0x44, 0x48, + 0x8d, 0x60, 0x1f, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, + 0xf7, 0x64, 0x1f, 0x80, 0x20, 0x4b, 0x75, 0xa6, 0x66, 0x1f, 0x80, 0x13, + 0x45, 0xb9, 0x30, 0x62, 0x1f, 0x80, 0x06, 0x4d, 0x82, 0x51, 0xa0, 0x1f, + 0x40, 0x52, 0x7d, 0x51, 0xa2, 0x1f, 0x40, 0x52, 0x7d, 0x51, 0xa6, 0x1f, + 0x40, 0x52, 0x7d, 0x51, 0xa4, 0x1f, 0x40, 0x52, 0x7d, 0x51, 0xf7, 0x1f, + 0x40, 0x52, 0x7d, 0x51, 0xf4, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, + 0x44, 0xec, 0xf7, 0x65, 0x1f, 0x80, 0x20, 0x4b, 0x75, 0xa6, 0x67, 0x1f, + 0x80, 0x13, 0x45, 0xb9, 0x30, 0x63, 0x1f, 0x80, 0x06, 0x4d, 0x82, 0x51, + 0xa1, 0x1f, 0x40, 0x52, 0x7d, 0x51, 0xa3, 0x1f, 0x40, 0x52, 0x7d, 0x51, + 0xa7, 0x1f, 0x40, 0x52, 0x7d, 0x51, 0xa5, 0x1f, 0x40, 0x44, 0x49, 0x95, + 0xba, 0x03, 0x00, 0x44, 0xbc, 0x84, 0xdf, 0x03, 0x40, 0x06, 0x50, 0x00, + 0x01, 0xff, 0xa4, 0x47, 0x46, 0xd1, 0x73, 0xd1, 0x1f, 0x00, 0x44, 0xec, + 0xf7, 0x77, 0x1f, 0x00, 0xb0, 0x15, 0x45, 0x40, 0x6f, 0xaf, 0x03, 0x00, + 0xb6, 0x01, 0xff, 0x44, 0xba, 0x30, 0x76, 0x1f, 0x00, 0x45, 0x16, 0xf0, + 0xd0, 0x1f, 0x40, 0x4a, 0x76, 0xa6, 0xd6, 0x1f, 0x00, 0x44, 0x48, 0x8d, + 0x30, 0x1f, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, + 0x34, 0x1f, 0x00, 0x4b, 0x75, 0xa6, 0x36, 0x1f, 0x00, 0x45, 0xb9, 0x30, + 0x32, 0x1f, 0x40, 0x44, 0x1b, 0x64, 0x31, 0x1f, 0x80, 0x24, 0x48, 0x37, + 0x6f, 0xca, 0x03, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, + 0xf7, 0xd3, 0x1f, 0x00, 0x4b, 0x75, 0xa6, 0xd7, 0x1f, 0x00, 0x45, 0x40, + 0x6f, 0x90, 0x03, 0x00, 0x45, 0xb9, 0x30, 0xd2, 0x1f, 0x40, 0x05, 0x19, + 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, 0x35, 0x1f, 0x00, 0x4b, 0x75, 0xa6, + 0x37, 0x1f, 0x00, 0x45, 0xb9, 0x30, 0x33, 0x1f, 0x40, 0x46, 0x9d, 0x16, + 0xb5, 0x03, 0x80, 0xb3, 0x01, 0x42, 0x12, 0x00, 0xb7, 0x03, 0xc0, 0x00, + 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0x2a, 0x7a, 0x21, 0x1f, 0x80, 0x6e, + 0x44, 0xec, 0xf7, 0x75, 0x1f, 0x80, 0x61, 0xb0, 0x19, 0x45, 0x40, 0x6f, + 0xae, 0x03, 0x00, 0x45, 0xb9, 0x30, 0x74, 0x1f, 0x80, 0x06, 0x4d, 0x82, + 0x51, 0xc3, 0x1f, 0x40, 0x52, 0x7d, 0x51, 0xc2, 0x1f, 0x40, 0x4a, 0x76, + 0xa6, 0xc6, 0x1f, 0x80, 0x39, 0x44, 0x48, 0x8d, 0x20, 0x1f, 0xc0, 0x00, + 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, 0x24, 0x1f, 0x80, 0x20, + 0x4b, 0x75, 0xa6, 0x26, 0x1f, 0x80, 0x13, 0x45, 0xb9, 0x30, 0x22, 0x1f, + 0x80, 0x06, 0x4d, 0x82, 0x51, 0x90, 0x1f, 0x40, 0x52, 0x7d, 0x51, 0x92, + 0x1f, 0x40, 0x52, 0x7d, 0x51, 0x96, 0x1f, 0x40, 0x52, 0x7d, 0x51, 0x94, + 0x1f, 0x40, 0x52, 0x7d, 0x51, 0xc7, 0x1f, 0x40, 0x52, 0x7d, 0x51, 0xc4, + 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, 0x25, 0x1f, + 0x80, 0x20, 0x4b, 0x75, 0xa6, 0x27, 0x1f, 0x80, 0x13, 0x45, 0xb9, 0x30, + 0x23, 0x1f, 0x80, 0x06, 0x4d, 0x82, 0x51, 0x91, 0x1f, 0x40, 0x52, 0x7d, + 0x51, 0x93, 0x1f, 0x40, 0x52, 0x7d, 0x51, 0x97, 0x1f, 0x40, 0x52, 0x7d, + 0x51, 0x95, 0x1f, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0x2a, 0x7a, + 0x11, 0x1f, 0x80, 0x2a, 0x44, 0xec, 0xf7, 0x73, 0x1f, 0x00, 0x45, 0xfd, + 0xef, 0x10, 0x1f, 0x80, 0x0c, 0x45, 0x40, 0x6f, 0xad, 0x03, 0x00, 0x45, + 0xb9, 0x30, 0x72, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, + 0xf7, 0x14, 0x1f, 0x00, 0x45, 0xb9, 0x30, 0x12, 0x1f, 0x40, 0x05, 0x19, + 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, 0x15, 0x1f, 0x00, 0x45, 0xb9, 0x30, + 0x13, 0x1f, 0x40, 0x44, 0x28, 0xdc, 0xb4, 0x03, 0x00, 0x46, 0xac, 0x5a, + 0xdd, 0x03, 0x40, 0x44, 0x40, 0xea, 0xb1, 0x03, 0x80, 0x11, 0x07, 0xb4, + 0x84, 0x01, 0xff, 0x45, 0xbb, 0x84, 0xd9, 0x03, 0x00, 0x45, 0x27, 0x99, + 0x73, 0x03, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0x2a, 0x7a, 0x01, + 0x1f, 0x80, 0x7c, 0x46, 0xd1, 0x73, 0xb1, 0x1f, 0x00, 0x44, 0xec, 0xf7, + 0x71, 0x1f, 0x80, 0x69, 0xb0, 0x21, 0x45, 0x40, 0x6f, 0xac, 0x03, 0x00, + 0xb6, 0x06, 0x4d, 0x82, 0x51, 0xb3, 0x1f, 0x40, 0x44, 0xba, 0x30, 0x70, + 0x1f, 0x80, 0x06, 0x45, 0x16, 0xf0, 0xb0, 0x1f, 0x40, 0x52, 0x7d, 0x51, + 0xb2, 0x1f, 0x40, 0x4a, 0x76, 0xa6, 0xb6, 0x1f, 0x80, 0x39, 0x44, 0x48, + 0x8d, 0x00, 0x1f, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, + 0xf7, 0x04, 0x1f, 0x80, 0x20, 0x4b, 0x75, 0xa6, 0x06, 0x1f, 0x80, 0x13, + 0x45, 0xb9, 0x30, 0x02, 0x1f, 0x80, 0x06, 0x4d, 0x82, 0x51, 0x80, 0x1f, + 0x40, 0x52, 0x7d, 0x51, 0x82, 0x1f, 0x40, 0x52, 0x7d, 0x51, 0x86, 0x1f, + 0x40, 0x52, 0x7d, 0x51, 0x84, 0x1f, 0x40, 0x52, 0x7d, 0x51, 0xb7, 0x1f, + 0x40, 0x52, 0x7d, 0x51, 0xb4, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, + 0x44, 0xec, 0xf7, 0x05, 0x1f, 0x80, 0x20, 0x4b, 0x75, 0xa6, 0x07, 0x1f, + 0x80, 0x13, 0x45, 0xb9, 0x30, 0x03, 0x1f, 0x80, 0x06, 0x4d, 0x82, 0x51, + 0x81, 0x1f, 0x40, 0x52, 0x7d, 0x51, 0x83, 0x1f, 0x40, 0x52, 0x7d, 0x51, + 0x87, 0x1f, 0x40, 0x52, 0x7d, 0x51, 0x85, 0x1f, 0x40, 0x5d, 0x8d, 0x16, + 0xf6, 0x03, 0x00, 0x03, 0x16, 0x75, 0x01, 0xff, 0x46, 0x16, 0x08, 0xf1, + 0x03, 0x00, 0x52, 0x4b, 0x59, 0xfc, 0x03, 0x40, 0x4a, 0x76, 0xa6, 0xc0, + 0x1f, 0x00, 0x49, 0x2d, 0xbf, 0xd5, 0x03, 0x00, 0x48, 0xbc, 0x97, 0xd6, + 0x03, 0x00, 0x4d, 0x81, 0x49, 0xbe, 0x1f, 0x00, 0x44, 0x48, 0x8d, 0xbf, + 0x1f, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, 0xce, + 0x1f, 0x00, 0x4b, 0x75, 0xa6, 0xcf, 0x1f, 0x00, 0x45, 0xb9, 0x30, 0xcd, + 0x1f, 0x40, 0x48, 0xef, 0xc9, 0x7c, 0x01, 0x01, 0x03, 0xef, 0x07, 0x0c, + 0x4a, 0x52, 0xb8, 0x84, 0x01, 0x01, 0x43, 0xb8, 0x4d, 0xfd, 0x1f, 0x40, + 0x49, 0x00, 0xbf, 0x75, 0x01, 0x81, 0x06, 0x4c, 0xe4, 0x98, 0x8b, 0x01, + 0x41, 0x4f, 0x2a, 0x6c, 0x76, 0x01, 0x41, 0x4c, 0x68, 0x93, 0x81, 0x01, + 0x01, 0x4d, 0x73, 0x8e, 0x45, 0xd2, 0x41, 0x06, 0x14, 0x06, 0x1d, 0x49, + 0x7a, 0xc0, 0x83, 0x01, 0x01, 0x51, 0xad, 0x5f, 0x75, 0x03, 0x00, 0x06, + 0x96, 0x16, 0x01, 0xff, 0x4e, 0x9c, 0x16, 0xf5, 0x03, 0x00, 0x4c, 0xe1, + 0x20, 0xf2, 0x03, 0x40, 0x4d, 0xb3, 0x84, 0xd8, 0x03, 0x00, 0x47, 0xab, + 0x5a, 0xdc, 0x03, 0x00, 0x45, 0xbb, 0x84, 0xde, 0x03, 0x00, 0xb3, 0x06, + 0x43, 0xd5, 0xfa, 0xf3, 0x03, 0x40, 0x44, 0x28, 0x99, 0xe0, 0x03, 0x00, + 0x0d, 0xea, 0x3e, 0x06, 0x45, 0x29, 0xf1, 0xda, 0x03, 0x40, 0x45, 0xad, + 0x5a, 0x26, 0x1d, 0x00, 0x45, 0x0e, 0xee, 0x27, 0x1d, 0x00, 0x45, 0x37, + 0x92, 0x65, 0xab, 0x00, 0xb0, 0x06, 0x43, 0x39, 0x4c, 0x29, 0x1d, 0x40, + 0xe9, 0x28, 0x1d, 0x00, 0x42, 0x5a, 0x03, 0x2a, 0x1d, 0x40, 0xa1, 0x0c, + 0x46, 0xc4, 0x64, 0xbd, 0x1f, 0x00, 0x50, 0x0a, 0x6c, 0x82, 0x01, 0x41, + 0x48, 0xbc, 0x97, 0xd7, 0x03, 0x00, 0x4a, 0x4a, 0x95, 0xf0, 0x03, 0x40, + 0x4c, 0xa8, 0x92, 0x8d, 0x01, 0x01, 0x1b, 0xa8, 0x1e, 0x01, 0xff, 0xd1, + 0x1d, 0xd2, 0x81, 0x79, 0xd2, 0x1e, 0xd2, 0x81, 0x5c, 0x93, 0x42, 0xd4, + 0x1f, 0xd2, 0x81, 0x21, 0xd5, 0x20, 0xd2, 0x81, 0x08, 0xd7, 0x21, 0xd2, + 0x01, 0xd8, 0x22, 0xd2, 0x41, 0xd0, 0x3d, 0xd2, 0x01, 0xd1, 0x3e, 0xd2, + 0x01, 0xd2, 0x3f, 0xd2, 0x01, 0xd3, 0x40, 0xd2, 0x01, 0xd4, 0x41, 0xd2, + 0x41, 0xd0, 0x36, 0xd2, 0x01, 0xd2, 0x37, 0xd2, 0x01, 0xd3, 0x38, 0xd2, + 0x01, 0xd5, 0x39, 0xd2, 0x01, 0xd7, 0x3a, 0xd2, 0x01, 0xd8, 0x3b, 0xd2, + 0x01, 0xd9, 0x3c, 0xd2, 0x41, 0xd0, 0x30, 0xd2, 0x01, 0xd2, 0x31, 0xd2, + 0x01, 0xd6, 0x32, 0xd2, 0x01, 0xd7, 0x33, 0xd2, 0x01, 0xd8, 0x34, 0xd2, + 0x01, 0xd9, 0x35, 0xd2, 0x41, 0xd3, 0x2a, 0xd2, 0x01, 0xd4, 0x2b, 0xd2, + 0x01, 0xd5, 0x2c, 0xd2, 0x01, 0xd6, 0x2d, 0xd2, 0x01, 0xd7, 0x2e, 0xd2, + 0x01, 0xd9, 0x2f, 0xd2, 0x41, 0xd1, 0x23, 0xd2, 0x01, 0xd2, 0x24, 0xd2, + 0x01, 0xd3, 0x25, 0xd2, 0x01, 0xd4, 0x26, 0xd2, 0x01, 0xd7, 0x27, 0xd2, + 0x01, 0xd8, 0x28, 0xd2, 0x01, 0xd9, 0x29, 0xd2, 0x41, 0x4e, 0xa0, 0x7c, + 0x80, 0x01, 0x01, 0x4e, 0x98, 0x7e, 0x7f, 0x01, 0x41, 0x44, 0x1b, 0x64, + 0xfe, 0x1f, 0x80, 0x26, 0x09, 0x37, 0x6f, 0x06, 0x4b, 0xe3, 0xa6, 0x7b, + 0x01, 0x41, 0x04, 0x1a, 0x00, 0x06, 0x45, 0x40, 0x6f, 0x85, 0x03, 0x40, + 0x44, 0xec, 0xf7, 0xee, 0x1f, 0x00, 0x4b, 0x75, 0xa6, 0xc1, 0x1f, 0x00, + 0x45, 0xb9, 0x30, 0xed, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, + 0xec, 0xf7, 0xde, 0x1f, 0x00, 0x4b, 0x75, 0xa6, 0xdf, 0x1f, 0x00, 0x45, + 0xb9, 0x30, 0xdd, 0x1f, 0x40, 0x5a, 0xd3, 0x20, 0xfe, 0x03, 0x00, 0x4a, + 0xd6, 0xb1, 0xcf, 0x03, 0x00, 0xac, 0x16, 0x09, 0xab, 0x15, 0x06, 0x4c, + 0xc4, 0x9a, 0xf4, 0x03, 0x40, 0x5a, 0xd3, 0x20, 0xff, 0x03, 0x00, 0x53, + 0xda, 0x20, 0xfd, 0x03, 0x40, 0x06, 0x14, 0x06, 0x06, 0x52, 0xdb, 0x20, + 0xf9, 0x03, 0x40, 0xa1, 0xb3, 0x06, 0x44, 0xa3, 0x9e, 0x92, 0x03, 0x00, + 0x43, 0x47, 0x17, 0xa7, 0x03, 0x00, 0x45, 0x7a, 0xeb, 0x94, 0x03, 0x00, + 0xa5, 0xb3, 0x04, 0x45, 0xad, 0x5a, 0x93, 0x03, 0x00, 0x44, 0xf8, 0x78, + 0x70, 0x03, 0x00, 0x44, 0x20, 0x30, 0x99, 0x03, 0x80, 0xb5, 0x03, 0x45, + 0x48, 0x95, 0x9a, 0x03, 0x00, 0x45, 0x0e, 0xee, 0x9b, 0x03, 0x00, 0x42, + 0x91, 0x17, 0x9c, 0x03, 0x00, 0x42, 0x0b, 0x17, 0x9d, 0x03, 0x00, 0x02, + 0x14, 0x05, 0xae, 0x01, 0xb0, 0x95, 0x01, 0x43, 0x39, 0x4c, 0xa1, 0x03, + 0x80, 0x87, 0x01, 0xb3, 0x73, 0xb4, 0x65, 0x47, 0x3f, 0x8e, 0xa5, 0x03, + 0x80, 0x12, 0x42, 0x70, 0x0d, 0x9e, 0x03, 0x00, 0x43, 0xd5, 0xfa, 0x7f, + 0x03, 0x00, 0x44, 0x60, 0xf9, 0x96, 0x03, 0x40, 0x06, 0x50, 0x00, 0x01, + 0xff, 0xa4, 0x21, 0x46, 0xd1, 0x73, 0xe9, 0x1f, 0x00, 0x44, 0xec, 0xf7, + 0xeb, 0x1f, 0x00, 0x45, 0x40, 0x6f, 0x8e, 0x03, 0x00, 0xb6, 0x01, 0xff, + 0x44, 0xba, 0x30, 0xea, 0x1f, 0x00, 0x45, 0x16, 0xf0, 0xe8, 0x1f, 0x40, + 0x44, 0x1b, 0x64, 0x59, 0x1f, 0x80, 0x06, 0x48, 0x37, 0x6f, 0xab, 0x03, + 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, 0x5d, 0x1f, 0x00, + 0x4b, 0x75, 0xa6, 0x5f, 0x1f, 0x00, 0x45, 0xb9, 0x30, 0x5b, 0x1f, 0x40, + 0x42, 0xb4, 0x25, 0xa4, 0x03, 0x00, 0x44, 0xf8, 0x78, 0x98, 0x03, 0x40, + 0x42, 0x1a, 0x00, 0xfa, 0x03, 0x00, 0x42, 0x0b, 0x00, 0xf7, 0x03, 0x00, + 0x44, 0xe2, 0x20, 0xa3, 0x03, 0x40, 0x4b, 0x17, 0x9d, 0xec, 0x1f, 0x40, + 0x51, 0xa1, 0x5a, 0x76, 0x03, 0x00, 0x42, 0x49, 0x00, 0xa6, 0x03, 0x00, + 0xe9, 0xa0, 0x03, 0x00, 0x42, 0x5a, 0x03, 0xa8, 0x03, 0x40, 0x43, 0xf5, + 0x05, 0xa9, 0x03, 0x80, 0x4e, 0x45, 0x3c, 0xed, 0x9f, 0x03, 0xc0, 0x00, + 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0x2a, 0x7a, 0x49, 0x1f, 0x80, 0x2a, + 0x44, 0xec, 0xf7, 0xf9, 0x1f, 0x00, 0x45, 0xfd, 0xef, 0x48, 0x1f, 0x80, + 0x0c, 0x45, 0x40, 0x6f, 0x8c, 0x03, 0x00, 0x45, 0xb9, 0x30, 0xf8, 0x1f, + 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, 0x4c, 0x1f, 0x00, + 0x45, 0xb9, 0x30, 0x4a, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, + 0xec, 0xf7, 0x4d, 0x1f, 0x00, 0x45, 0xb9, 0x30, 0x4b, 0x1f, 0x40, 0x06, + 0x50, 0x00, 0x01, 0xff, 0x45, 0x2a, 0x7a, 0x69, 0x1f, 0x80, 0x55, 0x44, + 0xec, 0xf7, 0xfb, 0x1f, 0x00, 0xb0, 0x0c, 0x45, 0x40, 0x6f, 0x8f, 0x03, + 0x00, 0x45, 0xb9, 0x30, 0xfa, 0x1f, 0x40, 0x4d, 0x81, 0x49, 0xfc, 0x1f, + 0x00, 0x44, 0x48, 0x8d, 0x68, 0x1f, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, + 0xff, 0x44, 0xec, 0xf7, 0x6c, 0x1f, 0x80, 0x22, 0xb0, 0x0d, 0x45, 0xb9, + 0x30, 0x6a, 0x1f, 0xc0, 0x00, 0x53, 0x7b, 0x49, 0xaa, 0x1f, 0x40, 0x4a, + 0x76, 0xa6, 0x6e, 0x1f, 0x80, 0x06, 0x4d, 0x81, 0x49, 0xa8, 0x1f, 0x40, + 0x53, 0x7b, 0x49, 0xae, 0x1f, 0x40, 0x53, 0x7b, 0x49, 0xac, 0x1f, 0x40, + 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, 0x6d, 0x1f, 0x80, 0x22, + 0xb0, 0x0d, 0x45, 0xb9, 0x30, 0x6b, 0x1f, 0xc0, 0x00, 0x53, 0x7b, 0x49, + 0xab, 0x1f, 0x40, 0x4a, 0x76, 0xa6, 0x6f, 0x1f, 0x80, 0x06, 0x4d, 0x81, + 0x49, 0xa9, 0x1f, 0x40, 0x53, 0x7b, 0x49, 0xaf, 0x1f, 0x40, 0x53, 0x7b, + 0x49, 0xad, 0x1f, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0xa4, 0x3f, 0x46, + 0xd1, 0x73, 0xd9, 0x1f, 0x00, 0x44, 0xec, 0xf7, 0xdb, 0x1f, 0x00, 0x45, + 0xfd, 0xef, 0x38, 0x1f, 0x80, 0x15, 0x45, 0x40, 0x6f, 0x8a, 0x03, 0x00, + 0xb6, 0x01, 0xff, 0x44, 0xba, 0x30, 0xda, 0x1f, 0x00, 0x45, 0x16, 0xf0, + 0xd8, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, 0x3c, + 0x1f, 0x00, 0x4b, 0x75, 0xa6, 0x3e, 0x1f, 0x00, 0x45, 0xb9, 0x30, 0x3a, + 0x1f, 0x40, 0x44, 0x1b, 0x64, 0x39, 0x1f, 0x80, 0x06, 0x48, 0x37, 0x6f, + 0xaa, 0x03, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, 0x3d, + 0x1f, 0x00, 0x4b, 0x75, 0xa6, 0x3f, 0x1f, 0x00, 0x45, 0xb9, 0x30, 0x3b, + 0x1f, 0x40, 0x46, 0x9d, 0x16, 0x95, 0x03, 0x80, 0x9c, 0x01, 0x42, 0x12, + 0x00, 0x97, 0x03, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0x2a, + 0x7a, 0x29, 0x1f, 0x80, 0x55, 0x44, 0xec, 0xf7, 0xcb, 0x1f, 0x00, 0xb0, + 0x0c, 0x45, 0x40, 0x6f, 0x89, 0x03, 0x00, 0x45, 0xb9, 0x30, 0xca, 0x1f, + 0x40, 0x4d, 0x81, 0x49, 0xcc, 0x1f, 0x00, 0x44, 0x48, 0x8d, 0x28, 0x1f, + 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, 0x2c, 0x1f, + 0x80, 0x22, 0xb0, 0x0d, 0x45, 0xb9, 0x30, 0x2a, 0x1f, 0xc0, 0x00, 0x53, + 0x7b, 0x49, 0x9a, 0x1f, 0x40, 0x4a, 0x76, 0xa6, 0x2e, 0x1f, 0x80, 0x06, + 0x4d, 0x81, 0x49, 0x98, 0x1f, 0x40, 0x53, 0x7b, 0x49, 0x9e, 0x1f, 0x40, + 0x53, 0x7b, 0x49, 0x9c, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, + 0xec, 0xf7, 0x2d, 0x1f, 0x80, 0x22, 0xb0, 0x0d, 0x45, 0xb9, 0x30, 0x2b, + 0x1f, 0xc0, 0x00, 0x53, 0x7b, 0x49, 0x9b, 0x1f, 0x40, 0x4a, 0x76, 0xa6, + 0x2f, 0x1f, 0x80, 0x06, 0x4d, 0x81, 0x49, 0x99, 0x1f, 0x40, 0x53, 0x7b, + 0x49, 0x9f, 0x1f, 0x40, 0x53, 0x7b, 0x49, 0x9d, 0x1f, 0x40, 0x06, 0x50, + 0x00, 0x01, 0xff, 0x45, 0x2a, 0x7a, 0x19, 0x1f, 0x80, 0x2a, 0x44, 0xec, + 0xf7, 0xc9, 0x1f, 0x00, 0x45, 0xfd, 0xef, 0x18, 0x1f, 0x80, 0x0c, 0x45, + 0x40, 0x6f, 0x88, 0x03, 0x00, 0x45, 0xb9, 0x30, 0xc8, 0x1f, 0x40, 0x05, + 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, 0x1c, 0x1f, 0x00, 0x45, 0xb9, + 0x30, 0x1a, 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, + 0x1d, 0x1f, 0x00, 0x45, 0xb9, 0x30, 0x1b, 0x1f, 0x40, 0x44, 0x40, 0xea, + 0x91, 0x03, 0x80, 0x06, 0x4c, 0x20, 0x99, 0x72, 0x03, 0x40, 0x06, 0x50, + 0x00, 0x01, 0xff, 0x45, 0x2a, 0x7a, 0x09, 0x1f, 0x80, 0x64, 0x46, 0xd1, + 0x73, 0xb9, 0x1f, 0x00, 0x44, 0xec, 0xf7, 0xbb, 0x1f, 0x00, 0xb0, 0x15, + 0x45, 0x40, 0x6f, 0x86, 0x03, 0x00, 0xb6, 0x01, 0xff, 0x44, 0xba, 0x30, + 0xba, 0x1f, 0x00, 0x45, 0x16, 0xf0, 0xb8, 0x1f, 0x40, 0x4d, 0x81, 0x49, + 0xbc, 0x1f, 0x00, 0x44, 0x48, 0x8d, 0x08, 0x1f, 0xc0, 0x00, 0x05, 0x19, + 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, 0x0c, 0x1f, 0x80, 0x22, 0xb0, 0x0d, + 0x45, 0xb9, 0x30, 0x0a, 0x1f, 0xc0, 0x00, 0x53, 0x7b, 0x49, 0x8a, 0x1f, + 0x40, 0x4a, 0x76, 0xa6, 0x0e, 0x1f, 0x80, 0x06, 0x4d, 0x81, 0x49, 0x88, + 0x1f, 0x40, 0x53, 0x7b, 0x49, 0x8e, 0x1f, 0x40, 0x53, 0x7b, 0x49, 0x8c, + 0x1f, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x44, 0xec, 0xf7, 0x0d, 0x1f, + 0x80, 0x22, 0xb0, 0x0d, 0x45, 0xb9, 0x30, 0x0b, 0x1f, 0xc0, 0x00, 0x53, + 0x7b, 0x49, 0x8b, 0x1f, 0x40, 0x4a, 0x76, 0xa6, 0x0f, 0x1f, 0x80, 0x06, + 0x4d, 0x81, 0x49, 0x89, 0x1f, 0x40, 0x53, 0x7b, 0x49, 0x8f, 0x1f, 0x40, + 0x53, 0x7b, 0x49, 0x8d, 0x1f, 0x40, 0x0a, 0x3e, 0xae, 0x15, 0x49, 0x4e, + 0xc2, 0x87, 0x03, 0x00, 0xb2, 0x01, 0xff, 0x49, 0x53, 0xc3, 0x87, 0x01, + 0x01, 0x49, 0x66, 0xc5, 0x86, 0x01, 0x41, 0x06, 0xee, 0xdf, 0xe6, 0x01, + 0xa3, 0xd7, 0x01, 0x51, 0x28, 0x5c, 0x73, 0x01, 0x01, 0x0b, 0xf5, 0xa0, + 0xb9, 0x01, 0x03, 0x32, 0x1b, 0x97, 0x01, 0x4d, 0x22, 0x8a, 0x63, 0x01, + 0x01, 0x53, 0xb6, 0x4d, 0x70, 0x01, 0x01, 0x53, 0xa4, 0x4f, 0x74, 0x01, + 0x01, 0xb4, 0x01, 0xff, 0x08, 0x57, 0xcc, 0x30, 0x0a, 0x22, 0xb6, 0x01, + 0xff, 0x02, 0xf3, 0x02, 0x0d, 0x43, 0xdb, 0x06, 0x60, 0x01, 0xc1, 0x00, + 0x4f, 0x2a, 0x6c, 0x61, 0x01, 0x41, 0x43, 0x04, 0x24, 0x66, 0x01, 0x81, + 0x0d, 0x42, 0x32, 0x00, 0x5f, 0x01, 0xc1, 0x00, 0x48, 0x3e, 0x12, 0x6d, + 0x01, 0x41, 0x4f, 0x2a, 0x6c, 0x67, 0x01, 0x41, 0x02, 0xf3, 0x02, 0x33, + 0x43, 0x7a, 0x0b, 0x59, 0x01, 0x81, 0x1d, 0xb4, 0x01, 0xff, 0x42, 0x92, + 0x01, 0x64, 0x01, 0x01, 0xa8, 0x06, 0x42, 0x15, 0x02, 0x5c, 0x01, 0x41, + 0x44, 0x49, 0x12, 0x65, 0x01, 0x01, 0x4b, 0x01, 0x19, 0x6b, 0x01, 0x41, + 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0x6a, 0x01, 0x01, 0x48, 0xde, 0x1e, + 0x71, 0x01, 0x41, 0x43, 0x04, 0x24, 0x69, 0x01, 0x01, 0x03, 0x5f, 0x00, + 0x01, 0xff, 0x47, 0x3f, 0x12, 0x6e, 0x01, 0x01, 0x48, 0xde, 0x1e, 0x72, + 0x01, 0x41, 0x51, 0x6e, 0x5a, 0x58, 0x01, 0x01, 0x08, 0xf7, 0xcd, 0x01, + 0xff, 0x45, 0x02, 0x24, 0x68, 0x01, 0x01, 0x43, 0x7a, 0x0b, 0x5a, 0x01, + 0x01, 0x43, 0xdb, 0x06, 0x62, 0x01, 0x41, 0x4c, 0xb8, 0x3b, 0x6c, 0x01, + 0x01, 0x43, 0x44, 0x0a, 0x5b, 0x01, 0xc1, 0x00, 0x49, 0x72, 0x49, 0x5e, + 0x01, 0x41, 0x55, 0xaf, 0x3b, 0x6f, 0x01, 0x01, 0x54, 0x67, 0x49, 0x5d, + 0x01, 0x41, 0x02, 0xf3, 0x02, 0x5a, 0x04, 0x7a, 0x0b, 0x20, 0x04, 0xdf, + 0x60, 0x01, 0xff, 0x44, 0xb3, 0x4f, 0x57, 0x01, 0x01, 0x47, 0x5a, 0x71, + 0x50, 0x01, 0x01, 0xb4, 0x01, 0xff, 0x46, 0x51, 0xc8, 0x49, 0x01, 0x01, + 0x4f, 0x52, 0x71, 0x55, 0x01, 0x41, 0x47, 0x73, 0x49, 0x42, 0x01, 0x01, + 0xa8, 0x17, 0x47, 0x2a, 0x01, 0x40, 0x01, 0x01, 0x09, 0xde, 0x1e, 0x01, + 0xff, 0x47, 0x5a, 0x71, 0x54, 0x01, 0x01, 0x47, 0x50, 0xc8, 0x4d, 0x01, + 0x41, 0x43, 0x23, 0x00, 0x41, 0x01, 0x01, 0x07, 0x40, 0x12, 0x01, 0xff, + 0x47, 0x5a, 0x71, 0x52, 0x01, 0x01, 0x47, 0x50, 0xc8, 0x4b, 0x01, 0x41, + 0x43, 0x04, 0x24, 0x44, 0x01, 0x81, 0x3c, 0x42, 0x32, 0x00, 0x43, 0x01, + 0xc1, 0x00, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0x45, 0x01, 0x81, 0x1c, + 0x47, 0x5a, 0x71, 0x4f, 0x01, 0x01, 0xb4, 0x01, 0xff, 0x46, 0x51, 0xc8, + 0x48, 0x01, 0x01, 0x47, 0xdf, 0x1e, 0x46, 0x01, 0xc1, 0x00, 0x48, 0x4f, + 0xc8, 0x4e, 0x01, 0x41, 0x80, 0x01, 0xff, 0x47, 0x5a, 0x71, 0x53, 0x01, + 0x01, 0x47, 0x50, 0xc8, 0x4c, 0x01, 0x41, 0x80, 0x01, 0xff, 0x47, 0x5a, + 0x71, 0x51, 0x01, 0x01, 0xb4, 0x01, 0xff, 0x46, 0x51, 0xc8, 0x4a, 0x01, + 0x01, 0x47, 0xdf, 0x1e, 0x47, 0x01, 0xc1, 0x00, 0x48, 0x59, 0x71, 0x56, + 0x01, 0x41, 0xa1, 0x9c, 0x01, 0xa2, 0x82, 0x01, 0x4f, 0xfa, 0x6e, 0xa7, + 0x2a, 0x80, 0x75, 0x55, 0x14, 0x3d, 0xdb, 0x22, 0x00, 0xaf, 0x1d, 0x44, + 0x5a, 0x03, 0x3e, 0x00, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4d, 0x90, + 0x85, 0x7a, 0x2a, 0x00, 0x43, 0x48, 0x0a, 0xd7, 0x22, 0x00, 0x53, 0xad, + 0x4e, 0x7c, 0x2a, 0x40, 0x02, 0x18, 0x00, 0x11, 0x03, 0x32, 0x00, 0x01, + 0xff, 0x49, 0x85, 0x0d, 0x67, 0x22, 0x00, 0x51, 0x26, 0x5e, 0xa4, 0x2a, + 0x40, 0x4b, 0xed, 0x1f, 0x86, 0x2a, 0x00, 0x03, 0x7b, 0x00, 0x25, 0x49, + 0xec, 0x00, 0x77, 0x22, 0x00, 0x50, 0x4a, 0x6a, 0x7e, 0x2a, 0xc0, 0x00, + 0x0a, 0x98, 0x3d, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x82, 0x2a, 0x80, 0x06, + 0x46, 0x75, 0x14, 0x80, 0x2a, 0x40, 0x45, 0xc2, 0x00, 0x84, 0x2a, 0x40, + 0x45, 0x89, 0x0d, 0x65, 0x22, 0x00, 0x4a, 0x0e, 0x3c, 0x73, 0x22, 0x40, + 0x54, 0x93, 0x00, 0xa9, 0x2a, 0x40, 0x4f, 0xea, 0x6f, 0xa5, 0x2a, 0x00, + 0x0a, 0x04, 0x3c, 0x01, 0xff, 0x45, 0x89, 0x0d, 0x69, 0x22, 0x00, 0x4a, + 0x0e, 0x3c, 0xe7, 0x22, 0x40, 0x05, 0x5d, 0x00, 0x11, 0x03, 0x1b, 0x00, + 0x01, 0xff, 0x4f, 0xf5, 0x73, 0x8a, 0x2a, 0x00, 0x58, 0x94, 0x2c, 0x88, + 0x2a, 0x40, 0x61, 0x36, 0x0e, 0x8c, 0x2a, 0x00, 0x61, 0x99, 0x0e, 0x92, + 0x2a, 0x00, 0x50, 0xb3, 0x02, 0x78, 0x29, 0x00, 0xb3, 0x01, 0xff, 0x07, + 0xca, 0xd7, 0x06, 0x70, 0xd9, 0x00, 0x94, 0x2a, 0x40, 0x4f, 0xe6, 0x00, + 0x90, 0x2a, 0x00, 0x48, 0x91, 0x2a, 0x8e, 0x2a, 0x40, 0x4b, 0x71, 0xa0, + 0x93, 0xf3, 0x01, 0x05, 0x35, 0xef, 0x0c, 0x43, 0x37, 0x68, 0x47, 0xf3, + 0x01, 0x49, 0x54, 0x24, 0x60, 0x00, 0x40, 0x4e, 0x90, 0x79, 0x57, 0x13, + 0x01, 0x07, 0x13, 0x06, 0x8b, 0x01, 0x42, 0x14, 0x05, 0x50, 0x13, 0x01, + 0x05, 0x5a, 0x03, 0x48, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xa1, 0x35, 0x42, + 0x27, 0x01, 0x47, 0x13, 0x01, 0xe9, 0x3f, 0x13, 0x81, 0x26, 0x42, 0xcd, + 0x02, 0x4b, 0x13, 0x01, 0xf5, 0x41, 0x13, 0x81, 0x17, 0x08, 0xf2, 0xc6, + 0x01, 0xff, 0xec, 0x62, 0x13, 0x81, 0x09, 0xf2, 0x43, 0x13, 0xc1, 0x00, + 0xf2, 0x44, 0x13, 0x41, 0xec, 0x63, 0x13, 0x41, 0xf5, 0x42, 0x13, 0x41, + 0xe9, 0x40, 0x13, 0x41, 0xe1, 0x3e, 0x13, 0x01, 0xe9, 0x48, 0x13, 0x01, + 0xf5, 0x4c, 0x13, 0x41, 0xa1, 0x2b, 0xa3, 0x1d, 0x45, 0x62, 0x41, 0x3c, + 0x13, 0x01, 0x45, 0xe4, 0xef, 0x5d, 0x13, 0x01, 0x02, 0x02, 0x00, 0x01, + 0xff, 0x44, 0x21, 0x25, 0x4d, 0x13, 0x01, 0x45, 0x49, 0x4e, 0x03, 0x13, + 0x41, 0x4a, 0x14, 0x25, 0x01, 0x13, 0x01, 0x57, 0x01, 0x17, 0x00, 0x13, + 0x41, 0x47, 0x0b, 0x17, 0x02, 0x13, 0x01, 0x47, 0x34, 0x8d, 0x3d, 0x13, + 0x41, 0xe1, 0x05, 0x13, 0x81, 0x9a, 0x02, 0xa2, 0x8d, 0x02, 0xa3, 0x80, + 0x02, 0xa4, 0xe7, 0x01, 0x42, 0x27, 0x01, 0x0f, 0x13, 0x01, 0xa7, 0xd4, + 0x01, 0x42, 0x22, 0x00, 0x39, 0x13, 0x01, 0xe9, 0x07, 0x13, 0x81, 0xc4, + 0x01, 0xaa, 0xb7, 0x01, 0xab, 0xaa, 0x01, 0xac, 0x9d, 0x01, 0x42, 0x6c, + 0x00, 0x2e, 0x13, 0x01, 0xae, 0x7f, 0x42, 0xcd, 0x02, 0x13, 0x13, 0x01, + 0xb0, 0x6d, 0x42, 0x71, 0x00, 0x30, 0x13, 0x01, 0xb3, 0x55, 0xb4, 0x3c, + 0xf5, 0x09, 0x13, 0x81, 0x33, 0xb6, 0x06, 0x42, 0xdf, 0x23, 0x2f, 0x13, + 0x41, 0xe1, 0x35, 0x13, 0x01, 0x05, 0x46, 0x0b, 0x17, 0x07, 0xf3, 0xc6, + 0x01, 0xff, 0xec, 0x0c, 0x13, 0x81, 0x09, 0xf2, 0x0b, 0x13, 0xc1, 0x00, + 0xf2, 0x60, 0x13, 0x41, 0xec, 0x61, 0x13, 0x41, 0x48, 0x0a, 0x17, 0x5e, + 0x13, 0x01, 0x4f, 0x3c, 0x18, 0x5f, 0x13, 0x41, 0xf5, 0x0a, 0x13, 0x41, + 0xe1, 0x24, 0x13, 0x01, 0x42, 0x22, 0x00, 0x25, 0x13, 0x01, 0xb4, 0x01, + 0xff, 0xe1, 0x1f, 0x13, 0x01, 0x42, 0x22, 0x00, 0x20, 0x13, 0x41, 0xe1, + 0x38, 0x13, 0x01, 0x42, 0x22, 0x00, 0x36, 0x13, 0x01, 0x42, 0x40, 0x06, + 0x37, 0x13, 0x41, 0xe1, 0x2a, 0x13, 0x01, 0x42, 0x22, 0x00, 0x2b, 0x13, + 0x41, 0xe1, 0x28, 0x13, 0x01, 0x42, 0x24, 0x02, 0x19, 0x13, 0x01, 0x42, + 0x2a, 0x05, 0x23, 0x13, 0x01, 0x42, 0xdf, 0x23, 0x1e, 0x13, 0x41, 0xe1, + 0x32, 0x13, 0x01, 0x42, 0x74, 0x00, 0x33, 0x13, 0x41, 0xe1, 0x15, 0x13, + 0x01, 0x42, 0x22, 0x00, 0x16, 0x13, 0x41, 0xe1, 0x1c, 0x13, 0x01, 0x42, + 0x22, 0x00, 0x1d, 0x13, 0x41, 0xe9, 0x08, 0x13, 0x41, 0xe1, 0x17, 0x13, + 0x01, 0x42, 0x22, 0x00, 0x18, 0x13, 0x41, 0xe1, 0x26, 0x13, 0x01, 0xa4, + 0x06, 0x42, 0x22, 0x00, 0x27, 0x13, 0x41, 0xe1, 0x21, 0x13, 0x01, 0x42, + 0x22, 0x00, 0x22, 0x13, 0x41, 0xe1, 0x1a, 0x13, 0x01, 0x42, 0x22, 0x00, + 0x1b, 0x13, 0x41, 0xe1, 0x2c, 0x13, 0x01, 0x42, 0x22, 0x00, 0x2d, 0x13, + 0x41, 0xe1, 0x06, 0x13, 0x01, 0xe9, 0x10, 0x13, 0x01, 0xf5, 0x14, 0x13, + 0x41, 0xa1, 0xd5, 0x01, 0x45, 0xbf, 0xe2, 0x7d, 0xf9, 0x01, 0x44, 0xe8, + 0xf6, 0xcc, 0xf3, 0x01, 0x46, 0x3e, 0xe4, 0x7d, 0xf7, 0x01, 0x43, 0x32, + 0x0e, 0xbf, 0xfa, 0x01, 0x45, 0x57, 0xf0, 0x8d, 0xf9, 0x01, 0x0c, 0xd0, + 0x9a, 0x01, 0xff, 0xa1, 0xa3, 0x01, 0x47, 0x15, 0xd5, 0x31, 0x03, 0x01, + 0x44, 0x58, 0xf5, 0x33, 0x03, 0x01, 0x43, 0x85, 0xb1, 0x39, 0x03, 0x01, + 0x45, 0x4c, 0xec, 0x46, 0x03, 0x01, 0x44, 0xdc, 0xf5, 0x32, 0x03, 0x01, + 0xa8, 0x77, 0xa9, 0x69, 0x43, 0x9e, 0xc0, 0x3e, 0x03, 0x01, 0x45, 0xe6, + 0xed, 0x3a, 0x03, 0x01, 0x45, 0x04, 0xee, 0x3b, 0x03, 0x01, 0x45, 0x98, + 0x96, 0x3c, 0x03, 0x01, 0xae, 0x38, 0x45, 0x9e, 0xef, 0x49, 0x03, 0x01, + 0x48, 0x6f, 0xcf, 0x40, 0x03, 0x01, 0x48, 0xc7, 0xcf, 0x35, 0x03, 0x01, + 0x45, 0x1b, 0xf0, 0x42, 0x03, 0x01, 0x45, 0xac, 0xf0, 0x43, 0x03, 0x01, + 0xb4, 0x0c, 0x44, 0xdc, 0xf8, 0x3f, 0x03, 0x01, 0x45, 0x41, 0xf2, 0x45, + 0x03, 0x41, 0x44, 0x8c, 0xf5, 0x44, 0x03, 0x01, 0x45, 0x00, 0xed, 0x38, + 0x03, 0x41, 0x45, 0x85, 0xea, 0x3d, 0x03, 0x01, 0x03, 0xf0, 0x05, 0x01, + 0xff, 0x48, 0x3e, 0x12, 0x4a, 0x03, 0x01, 0x42, 0x4b, 0x12, 0x41, 0x03, + 0x41, 0x44, 0xd0, 0xf5, 0x47, 0x03, 0x01, 0x43, 0x13, 0xd1, 0x36, 0x03, + 0x41, 0x43, 0x4e, 0x96, 0x37, 0x03, 0x01, 0x44, 0x1c, 0xf9, 0x48, 0x03, + 0x41, 0x43, 0x88, 0xea, 0x30, 0x03, 0x01, 0x45, 0x46, 0xed, 0x34, 0x03, + 0x41, 0x45, 0xf0, 0xed, 0x45, 0xf9, 0x01, 0xf4, 0x10, 0xf4, 0x41, 0xa1, + 0x1b, 0x4a, 0x24, 0xaf, 0xe6, 0x29, 0x00, 0xaf, 0x01, 0xff, 0x51, 0x07, + 0x5b, 0x10, 0xf3, 0x01, 0x43, 0x92, 0x4d, 0xe4, 0xf9, 0x01, 0x49, 0x16, + 0xc7, 0x1f, 0xf3, 0x41, 0x08, 0x06, 0x5e, 0x06, 0x4a, 0xd6, 0xb6, 0x5b, + 0xf9, 0x41, 0x0f, 0x0b, 0x06, 0xc6, 0x02, 0x0d, 0x9b, 0x08, 0x01, 0xff, + 0x43, 0xf4, 0xf9, 0x30, 0x2c, 0x00, 0xa2, 0xac, 0x02, 0xa3, 0x9d, 0x02, + 0xa4, 0x88, 0x02, 0xa6, 0xf9, 0x01, 0x47, 0x1b, 0xd7, 0x33, 0x2c, 0x00, + 0x44, 0x10, 0xf6, 0x48, 0x2c, 0x00, 0xe9, 0x3b, 0x2c, 0x80, 0xc2, 0x01, + 0x44, 0xa8, 0xf6, 0x3d, 0x2c, 0x00, 0xac, 0xad, 0x01, 0x47, 0x30, 0x6e, + 0x3f, 0x2c, 0x00, 0x45, 0xe5, 0xee, 0x40, 0x2c, 0x00, 0xaf, 0x92, 0x01, + 0xb0, 0x85, 0x01, 0x45, 0x5c, 0xf0, 0x43, 0x2c, 0x00, 0xb3, 0x51, 0xb4, + 0x3d, 0x43, 0xfa, 0xdb, 0x46, 0x2c, 0x00, 0x44, 0xf0, 0xf8, 0x32, 0x2c, + 0x00, 0xb9, 0x0f, 0xba, 0x01, 0xff, 0x45, 0xe3, 0xeb, 0x38, 0x2c, 0x00, + 0x46, 0x7c, 0xe2, 0x36, 0x2c, 0x40, 0x43, 0xb3, 0x00, 0x51, 0x2c, 0x00, + 0xa5, 0x08, 0xef, 0x56, 0x2c, 0x00, 0xf5, 0x53, 0x2c, 0x40, 0xb2, 0x06, + 0x43, 0xba, 0x6a, 0x35, 0x2c, 0x40, 0xe9, 0x50, 0x2c, 0x00, 0xf5, 0x4f, + 0x2c, 0x40, 0x4b, 0x72, 0xa7, 0x5d, 0x2c, 0x00, 0x42, 0x5a, 0x03, 0x4c, + 0x2c, 0x00, 0x45, 0x0a, 0xf2, 0x45, 0x2c, 0x40, 0xa8, 0x19, 0x44, 0x00, + 0xf7, 0x44, 0x2c, 0x00, 0x48, 0x16, 0xc5, 0x54, 0x2c, 0x80, 0x06, 0x49, + 0xd1, 0xc3, 0x52, 0x2c, 0x40, 0x4a, 0xe6, 0xab, 0x55, 0x2c, 0x40, 0xe1, + 0x4e, 0x2c, 0x00, 0x42, 0x12, 0x00, 0x4b, 0x2c, 0xc0, 0x00, 0x43, 0x89, + 0x8f, 0x5c, 0x2c, 0x40, 0xe5, 0x4a, 0x2c, 0x00, 0x45, 0x29, 0xe5, 0x42, + 0x2c, 0x40, 0x42, 0x0b, 0x17, 0x41, 0x2c, 0x00, 0x42, 0x5c, 0x01, 0x49, + 0x2c, 0x40, 0x4f, 0x28, 0x6e, 0x5e, 0x2c, 0x00, 0x46, 0xce, 0xd8, 0x3e, + 0x2c, 0x40, 0x4b, 0x4c, 0xa5, 0x3a, 0x2c, 0x00, 0x07, 0xc1, 0x22, 0x0f, + 0x02, 0xc2, 0x29, 0x01, 0xff, 0xe5, 0x39, 0x2c, 0x00, 0x44, 0x11, 0x8a, + 0x5b, 0x2c, 0x40, 0x47, 0x3f, 0xd5, 0x59, 0x2c, 0x00, 0x49, 0x15, 0xc5, + 0x57, 0x2c, 0x40, 0x43, 0x0e, 0x06, 0x5a, 0x2c, 0x00, 0x44, 0x2a, 0xc5, + 0x47, 0x2c, 0x40, 0x45, 0xa0, 0xed, 0x3c, 0x2c, 0x00, 0x44, 0xb0, 0xf7, + 0x34, 0x2c, 0x00, 0x44, 0x5c, 0xf9, 0x37, 0x2c, 0x40, 0x4d, 0xf4, 0x84, + 0x5f, 0x2c, 0x00, 0x45, 0xfc, 0x84, 0x4d, 0x2c, 0x40, 0x46, 0x40, 0xd5, + 0x58, 0x2c, 0x00, 0x43, 0x6a, 0xd8, 0x31, 0x2c, 0x40, 0x43, 0xf4, 0xf9, + 0x00, 0x2c, 0x00, 0xa2, 0xac, 0x02, 0xa3, 0x9d, 0x02, 0xa4, 0x88, 0x02, + 0xa6, 0xf9, 0x01, 0x47, 0x1b, 0xd7, 0x03, 0x2c, 0x00, 0x44, 0x10, 0xf6, + 0x18, 0x2c, 0x00, 0xe9, 0x0b, 0x2c, 0x80, 0xc2, 0x01, 0x44, 0xa8, 0xf6, + 0x0d, 0x2c, 0x00, 0xac, 0xad, 0x01, 0x47, 0x30, 0x6e, 0x0f, 0x2c, 0x00, + 0x45, 0xe5, 0xee, 0x10, 0x2c, 0x00, 0xaf, 0x92, 0x01, 0xb0, 0x85, 0x01, + 0x45, 0x5c, 0xf0, 0x13, 0x2c, 0x00, 0xb3, 0x51, 0xb4, 0x3d, 0x43, 0xfa, + 0xdb, 0x16, 0x2c, 0x00, 0x44, 0xf0, 0xf8, 0x02, 0x2c, 0x00, 0xb9, 0x0f, + 0xba, 0x01, 0xff, 0x45, 0xe3, 0xeb, 0x08, 0x2c, 0x00, 0x46, 0x7c, 0xe2, + 0x06, 0x2c, 0x40, 0x43, 0xb3, 0x00, 0x21, 0x2c, 0x00, 0xa5, 0x08, 0xef, + 0x26, 0x2c, 0x00, 0xf5, 0x23, 0x2c, 0x40, 0xb2, 0x06, 0x43, 0xba, 0x6a, + 0x05, 0x2c, 0x40, 0xe9, 0x20, 0x2c, 0x00, 0xf5, 0x1f, 0x2c, 0x40, 0x4b, + 0x72, 0xa7, 0x2d, 0x2c, 0x00, 0x42, 0x5a, 0x03, 0x1c, 0x2c, 0x00, 0x45, + 0x0a, 0xf2, 0x15, 0x2c, 0x40, 0xa8, 0x19, 0x44, 0x00, 0xf7, 0x14, 0x2c, + 0x00, 0x48, 0x16, 0xc5, 0x24, 0x2c, 0x80, 0x06, 0x49, 0xd1, 0xc3, 0x22, + 0x2c, 0x40, 0x4a, 0xe6, 0xab, 0x25, 0x2c, 0x40, 0xe1, 0x1e, 0x2c, 0x00, + 0x42, 0x12, 0x00, 0x1b, 0x2c, 0xc0, 0x00, 0x43, 0x89, 0x8f, 0x2c, 0x2c, + 0x40, 0xe5, 0x1a, 0x2c, 0x00, 0x45, 0x29, 0xe5, 0x12, 0x2c, 0x40, 0x42, + 0x0b, 0x17, 0x11, 0x2c, 0x00, 0x42, 0x5c, 0x01, 0x19, 0x2c, 0x40, 0x4f, + 0x28, 0x6e, 0x2e, 0x2c, 0x00, 0x46, 0xce, 0xd8, 0x0e, 0x2c, 0x40, 0x4b, + 0x4c, 0xa5, 0x0a, 0x2c, 0x00, 0x07, 0xc1, 0x22, 0x0f, 0x02, 0xc2, 0x29, + 0x01, 0xff, 0xe5, 0x09, 0x2c, 0x00, 0x44, 0x11, 0x8a, 0x2b, 0x2c, 0x40, + 0x47, 0x3f, 0xd5, 0x29, 0x2c, 0x00, 0x49, 0x15, 0xc5, 0x27, 0x2c, 0x40, + 0x43, 0x0e, 0x06, 0x2a, 0x2c, 0x00, 0x44, 0x2a, 0xc5, 0x17, 0x2c, 0x40, + 0x45, 0xa0, 0xed, 0x0c, 0x2c, 0x00, 0x44, 0xb0, 0xf7, 0x04, 0x2c, 0x00, + 0x44, 0x5c, 0xf9, 0x07, 0x2c, 0x40, 0x4d, 0xf4, 0x84, 0x2f, 0x2c, 0x00, + 0x45, 0xfc, 0x84, 0x1d, 0x2c, 0x40, 0x46, 0x40, 0xd5, 0x28, 0x2c, 0x00, + 0x43, 0x6a, 0xd8, 0x01, 0x2c, 0x40, 0x4a, 0x5c, 0xb3, 0x37, 0x21, 0x00, + 0x49, 0x0f, 0xc2, 0xda, 0xfa, 0x01, 0xb2, 0x01, 0xff, 0x49, 0x46, 0xbb, + 0x92, 0xf9, 0x01, 0xec, 0x67, 0xf4, 0xc1, 0x00, 0x48, 0xd4, 0x4d, 0xca, + 0xf6, 0x41, 0x42, 0x17, 0x00, 0x99, 0x26, 0x80, 0xb6, 0x0a, 0xad, 0xa7, + 0x0a, 0x43, 0x36, 0x82, 0xde, 0xf9, 0x01, 0xaf, 0x0c, 0x4f, 0x02, 0x76, + 0xb0, 0x20, 0x00, 0x47, 0x0e, 0xdc, 0x13, 0x30, 0x40, 0xad, 0x81, 0x09, + 0x06, 0xec, 0xa0, 0x01, 0xff, 0x0f, 0x0b, 0x06, 0xf3, 0x06, 0x07, 0x13, + 0x06, 0xc1, 0x04, 0x18, 0xbc, 0x2b, 0x8f, 0x02, 0x53, 0x74, 0x4e, 0xfb, + 0x10, 0x00, 0x0d, 0x9b, 0x08, 0x01, 0xff, 0xa1, 0xf7, 0x01, 0x43, 0xf4, + 0x16, 0x01, 0x2d, 0x00, 0xa3, 0xd4, 0x01, 0x43, 0x3a, 0x12, 0x03, 0x2d, + 0x00, 0x42, 0x92, 0x01, 0x04, 0x2d, 0x00, 0xa7, 0xb9, 0x01, 0xa8, 0x9c, + 0x01, 0x42, 0x9e, 0x01, 0x08, 0x2d, 0x00, 0xaa, 0x87, 0x01, 0xab, 0x79, + 0x43, 0xd7, 0x0e, 0x0a, 0x2d, 0x00, 0x43, 0x47, 0x19, 0x0b, 0x2d, 0x00, + 0x43, 0x8b, 0x28, 0x0c, 0x2d, 0x00, 0x42, 0x10, 0x00, 0x0d, 0x2d, 0x00, + 0xb0, 0x53, 0x43, 0x84, 0xfa, 0x17, 0x2d, 0x00, 0x43, 0x85, 0x86, 0x10, + 0x2d, 0x00, 0xb3, 0x39, 0x02, 0x12, 0x00, 0x2d, 0x42, 0x79, 0x08, 0x13, + 0x2d, 0x00, 0x43, 0x8f, 0x2c, 0x05, 0x2d, 0x00, 0x42, 0x15, 0x01, 0x23, + 0x2d, 0x00, 0x43, 0xe7, 0xf4, 0x1e, 0x2d, 0x00, 0x42, 0x25, 0x1e, 0x27, + 0x2d, 0x00, 0xba, 0x01, 0xff, 0x42, 0x92, 0x01, 0x06, 0x2d, 0x00, 0x43, + 0xc9, 0x02, 0x0f, 0x2d, 0x40, 0xee, 0x07, 0x2d, 0x00, 0xf2, 0x12, 0x2d, + 0x40, 0x42, 0x1a, 0x00, 0x11, 0x2d, 0x00, 0x43, 0x48, 0x17, 0x18, 0x2d, + 0x40, 0x42, 0x17, 0x00, 0x0e, 0x2d, 0x00, 0x43, 0xc9, 0x02, 0x14, 0x2d, + 0x40, 0x42, 0x1a, 0x00, 0x09, 0x2d, 0x00, 0x43, 0xc9, 0x02, 0x15, 0x2d, + 0x40, 0x43, 0x90, 0x00, 0x1f, 0x2d, 0x00, 0x42, 0x62, 0x01, 0x1b, 0x2d, + 0x40, 0xa1, 0x10, 0xe5, 0x21, 0x2d, 0x00, 0x42, 0xf4, 0x02, 0x22, 0x2d, + 0x00, 0x42, 0xce, 0x53, 0x25, 0x2d, 0x40, 0xe5, 0x20, 0x2d, 0x00, 0xf2, + 0x24, 0x2d, 0x40, 0x42, 0x1a, 0x00, 0x02, 0x2d, 0x00, 0x43, 0x90, 0x00, + 0x16, 0x2d, 0x40, 0x42, 0x1a, 0x00, 0x1a, 0x2d, 0x00, 0xa8, 0x06, 0x42, + 0x62, 0x01, 0x1c, 0x2d, 0x40, 0x42, 0x17, 0x00, 0x1d, 0x2d, 0x00, 0x42, + 0x9e, 0x01, 0x19, 0x2d, 0x40, 0x42, 0x92, 0x01, 0x2d, 0x2d, 0x00, 0xee, + 0x00, 0x2d, 0x40, 0xa1, 0x9a, 0x02, 0x43, 0xf4, 0x16, 0x91, 0x1c, 0x00, + 0xa3, 0xf7, 0x01, 0x43, 0x3a, 0x12, 0x93, 0x1c, 0x00, 0xa5, 0xe4, 0x01, + 0x42, 0xf3, 0x02, 0xb6, 0x1c, 0x00, 0xa7, 0xcf, 0x01, 0xa8, 0xab, 0x01, + 0x42, 0x9e, 0x01, 0x98, 0x1c, 0x00, 0xaa, 0x96, 0x01, 0xab, 0x87, 0x01, + 0x02, 0x74, 0x00, 0x79, 0x43, 0x47, 0x19, 0x9b, 0x1c, 0x00, 0x43, 0x8b, + 0x28, 0x9c, 0x1c, 0x00, 0x42, 0x10, 0x00, 0x9d, 0x1c, 0x00, 0xb0, 0x59, + 0x43, 0x84, 0xfa, 0xa7, 0x1c, 0x00, 0x43, 0x85, 0x86, 0xa0, 0x1c, 0x00, + 0xb3, 0x3f, 0xb4, 0x2d, 0x42, 0x79, 0x08, 0xa3, 0x1c, 0x00, 0x43, 0x8f, + 0x2c, 0x95, 0x1c, 0x00, 0x42, 0x15, 0x01, 0xb3, 0x1c, 0x00, 0x43, 0xe7, + 0xf4, 0xae, 0x1c, 0x00, 0x42, 0x25, 0x1e, 0xb7, 0x1c, 0x00, 0xba, 0x01, + 0xff, 0x42, 0x92, 0x01, 0x96, 0x1c, 0x00, 0x43, 0xc9, 0x02, 0x9f, 0x1c, + 0x40, 0xa1, 0x06, 0x49, 0x74, 0xc6, 0xb9, 0x1c, 0x40, 0xee, 0x97, 0x1c, + 0x00, 0xf2, 0xa2, 0x1c, 0x40, 0x42, 0x1a, 0x00, 0xa1, 0x1c, 0x00, 0x43, + 0x48, 0x17, 0xa8, 0x1c, 0x40, 0x42, 0x17, 0x00, 0x9e, 0x1c, 0x00, 0x43, + 0xc9, 0x02, 0xa4, 0x1c, 0x40, 0x49, 0x27, 0xbc, 0xbf, 0x1c, 0x00, 0xf3, + 0x9a, 0x1c, 0x40, 0x42, 0x1a, 0x00, 0x99, 0x1c, 0x00, 0x43, 0xc9, 0x02, + 0xa5, 0x1c, 0x40, 0x43, 0x90, 0x00, 0xaf, 0x1c, 0x00, 0x42, 0x62, 0x01, + 0xab, 0x1c, 0x40, 0xa1, 0x10, 0xe5, 0xb1, 0x1c, 0x00, 0x42, 0xf4, 0x02, + 0xb2, 0x1c, 0x00, 0x42, 0xce, 0x53, 0xb5, 0x1c, 0x40, 0xe5, 0xb0, 0x1c, + 0x00, 0xf2, 0xb4, 0x1c, 0xc0, 0x00, 0x46, 0xe7, 0x49, 0xbe, 0x1c, 0x40, + 0x42, 0x1a, 0x00, 0x92, 0x1c, 0x00, 0x43, 0x90, 0x00, 0xa6, 0x1c, 0x40, + 0x44, 0x59, 0x8d, 0xb8, 0x1c, 0x00, 0xee, 0x94, 0x1c, 0x40, 0x42, 0x1a, + 0x00, 0xaa, 0x1c, 0x00, 0xa8, 0x06, 0x42, 0x62, 0x01, 0xac, 0x1c, 0x40, + 0x42, 0x17, 0x00, 0xad, 0x1c, 0x00, 0x42, 0x9e, 0x01, 0xa9, 0x1c, 0x40, + 0x42, 0x92, 0x01, 0xbd, 0x1c, 0x00, 0x42, 0x9e, 0x01, 0xba, 0x1c, 0x00, + 0xee, 0x90, 0x1c, 0x40, 0xa1, 0x9a, 0x02, 0x43, 0xf4, 0x16, 0xd1, 0x10, + 0x00, 0xa3, 0xf7, 0x01, 0x43, 0x3a, 0x12, 0xd3, 0x10, 0x00, 0xa5, 0xe4, + 0x01, 0x42, 0xf3, 0x02, 0xf6, 0x10, 0x00, 0xa7, 0xcf, 0x01, 0xa8, 0xab, + 0x01, 0x42, 0x9e, 0x01, 0xd8, 0x10, 0x00, 0xaa, 0x96, 0x01, 0xab, 0x87, + 0x01, 0x02, 0x74, 0x00, 0x79, 0x43, 0x47, 0x19, 0xdb, 0x10, 0x00, 0x43, + 0x8b, 0x28, 0xdc, 0x10, 0x00, 0x42, 0x10, 0x00, 0xdd, 0x10, 0x00, 0xb0, + 0x59, 0x43, 0x84, 0xfa, 0xe7, 0x10, 0x00, 0x43, 0x85, 0x86, 0xe0, 0x10, + 0x00, 0xb3, 0x3f, 0xb4, 0x2d, 0x42, 0x79, 0x08, 0xe3, 0x10, 0x00, 0x43, + 0x8f, 0x2c, 0xd5, 0x10, 0x00, 0x42, 0x15, 0x01, 0xf3, 0x10, 0x00, 0x43, + 0xe7, 0xf4, 0xee, 0x10, 0x00, 0x42, 0x25, 0x1e, 0xf7, 0x10, 0x00, 0xba, + 0x01, 0xff, 0x42, 0x92, 0x01, 0xd6, 0x10, 0x00, 0x43, 0xc9, 0x02, 0xdf, + 0x10, 0x40, 0xa1, 0x06, 0x49, 0x74, 0xc6, 0xf9, 0x10, 0x40, 0xee, 0xd7, + 0x10, 0x00, 0xf2, 0xe2, 0x10, 0x40, 0x42, 0x1a, 0x00, 0xe1, 0x10, 0x00, + 0x43, 0x48, 0x17, 0xe8, 0x10, 0x40, 0x42, 0x17, 0x00, 0xde, 0x10, 0x00, + 0x43, 0xc9, 0x02, 0xe4, 0x10, 0x40, 0x49, 0x27, 0xbc, 0xff, 0x10, 0x00, + 0xf3, 0xda, 0x10, 0x40, 0x42, 0x1a, 0x00, 0xd9, 0x10, 0x00, 0x43, 0xc9, + 0x02, 0xe5, 0x10, 0x40, 0x43, 0x90, 0x00, 0xef, 0x10, 0x00, 0x42, 0x62, + 0x01, 0xeb, 0x10, 0x40, 0xa1, 0x10, 0xe5, 0xf1, 0x10, 0x00, 0x42, 0xf4, + 0x02, 0xf2, 0x10, 0x00, 0x42, 0xce, 0x53, 0xf5, 0x10, 0x40, 0xe5, 0xf0, + 0x10, 0x00, 0xf2, 0xf4, 0x10, 0xc0, 0x00, 0x46, 0xe7, 0x49, 0xfe, 0x10, + 0x40, 0x42, 0x1a, 0x00, 0xd2, 0x10, 0x00, 0x43, 0x90, 0x00, 0xe6, 0x10, + 0x40, 0x44, 0x59, 0x8d, 0xf8, 0x10, 0x00, 0xee, 0xd4, 0x10, 0x40, 0x42, + 0x1a, 0x00, 0xea, 0x10, 0x00, 0xa8, 0x06, 0x42, 0x62, 0x01, 0xec, 0x10, + 0x40, 0x42, 0x17, 0x00, 0xed, 0x10, 0x00, 0x42, 0x9e, 0x01, 0xe9, 0x10, + 0x40, 0x42, 0x92, 0x01, 0xfd, 0x10, 0x00, 0x42, 0x9e, 0x01, 0xfa, 0x10, + 0x00, 0xee, 0xd0, 0x10, 0x40, 0xa1, 0xf7, 0x01, 0x43, 0xf4, 0x16, 0xa1, + 0x10, 0x00, 0xa3, 0xd4, 0x01, 0x43, 0x3a, 0x12, 0xa3, 0x10, 0x00, 0x42, + 0x92, 0x01, 0xa4, 0x10, 0x00, 0xa7, 0xb9, 0x01, 0xa8, 0x9c, 0x01, 0x42, + 0x9e, 0x01, 0xa8, 0x10, 0x00, 0xaa, 0x87, 0x01, 0xab, 0x79, 0x43, 0xd7, + 0x0e, 0xaa, 0x10, 0x00, 0x43, 0x47, 0x19, 0xab, 0x10, 0x00, 0x43, 0x8b, + 0x28, 0xac, 0x10, 0x00, 0x42, 0x10, 0x00, 0xad, 0x10, 0x00, 0xb0, 0x53, + 0x43, 0x84, 0xfa, 0xb7, 0x10, 0x00, 0x43, 0x85, 0x86, 0xb0, 0x10, 0x00, + 0xb3, 0x39, 0x02, 0x12, 0x00, 0x2d, 0x42, 0x79, 0x08, 0xb3, 0x10, 0x00, + 0x43, 0x8f, 0x2c, 0xa5, 0x10, 0x00, 0x42, 0x15, 0x01, 0xc3, 0x10, 0x00, + 0x43, 0xe7, 0xf4, 0xbe, 0x10, 0x00, 0x42, 0x25, 0x1e, 0xc7, 0x10, 0x00, + 0xba, 0x01, 0xff, 0x42, 0x92, 0x01, 0xa6, 0x10, 0x00, 0x43, 0xc9, 0x02, + 0xaf, 0x10, 0x40, 0xee, 0xa7, 0x10, 0x00, 0xf2, 0xb2, 0x10, 0x40, 0x42, + 0x1a, 0x00, 0xb1, 0x10, 0x00, 0x43, 0x48, 0x17, 0xb8, 0x10, 0x40, 0x42, + 0x17, 0x00, 0xae, 0x10, 0x00, 0x43, 0xc9, 0x02, 0xb4, 0x10, 0x40, 0x42, + 0x1a, 0x00, 0xa9, 0x10, 0x00, 0x43, 0xc9, 0x02, 0xb5, 0x10, 0x40, 0x43, + 0x90, 0x00, 0xbf, 0x10, 0x00, 0x42, 0x62, 0x01, 0xbb, 0x10, 0x40, 0xa1, + 0x10, 0xe5, 0xc1, 0x10, 0x00, 0x42, 0xf4, 0x02, 0xc2, 0x10, 0x00, 0x42, + 0xce, 0x53, 0xc5, 0x10, 0x40, 0xe5, 0xc0, 0x10, 0x00, 0xf2, 0xc4, 0x10, + 0x40, 0x42, 0x1a, 0x00, 0xa2, 0x10, 0x00, 0x43, 0x90, 0x00, 0xb6, 0x10, + 0x40, 0x42, 0x1a, 0x00, 0xba, 0x10, 0x00, 0xa8, 0x06, 0x42, 0x62, 0x01, + 0xbc, 0x10, 0x40, 0x42, 0x17, 0x00, 0xbd, 0x10, 0x00, 0x42, 0x9e, 0x01, + 0xb9, 0x10, 0x40, 0x42, 0x92, 0x01, 0xcd, 0x10, 0x00, 0xee, 0xa0, 0x10, + 0x40, 0x0d, 0x8c, 0x84, 0x1c, 0x05, 0x0b, 0x58, 0x01, 0xff, 0x4b, 0xca, + 0x9c, 0x3a, 0x22, 0x00, 0x08, 0x81, 0x0d, 0x01, 0xff, 0x45, 0x89, 0x0d, + 0x51, 0x22, 0x00, 0x4a, 0x0e, 0x3c, 0x4e, 0x22, 0x40, 0xa1, 0x5b, 0xa3, + 0x3f, 0x09, 0xa6, 0xbe, 0x2f, 0x48, 0x47, 0xcd, 0xe8, 0xce, 0x01, 0xb0, + 0x12, 0x46, 0xbe, 0xe5, 0xe4, 0xce, 0x01, 0x49, 0xdb, 0xc5, 0xe1, 0xce, + 0x01, 0x43, 0x5a, 0x52, 0xef, 0xce, 0x41, 0x46, 0xe0, 0xe4, 0xe0, 0xce, + 0x01, 0x02, 0x5c, 0x0a, 0x01, 0xff, 0x43, 0xba, 0x0e, 0xeb, 0xce, 0x01, + 0xf2, 0xed, 0xce, 0x41, 0x44, 0xd0, 0xf4, 0xe3, 0xce, 0x01, 0x44, 0x78, + 0xf6, 0xec, 0xce, 0x41, 0xa1, 0x06, 0x49, 0x02, 0xc3, 0xe6, 0xce, 0x41, + 0x4c, 0xcc, 0x98, 0xe7, 0xce, 0x01, 0x44, 0x34, 0xf8, 0xe9, 0xce, 0x01, + 0x4c, 0x30, 0x9b, 0xee, 0xce, 0x41, 0x49, 0xff, 0xbc, 0xe5, 0xce, 0x01, + 0x44, 0xe0, 0xf6, 0xe2, 0xce, 0x01, 0x46, 0x26, 0x32, 0xea, 0xce, 0x41, + 0x46, 0x3e, 0xc0, 0x8e, 0xf4, 0x01, 0x43, 0x57, 0x07, 0x4a, 0x26, 0x40, + 0x05, 0x50, 0x00, 0x01, 0xff, 0x48, 0xc7, 0xc7, 0xee, 0x26, 0x00, 0x47, + 0x1d, 0xda, 0xed, 0x26, 0x40, 0x46, 0xf6, 0xe3, 0xb2, 0xf3, 0x01, 0xb2, + 0x01, 0xff, 0x03, 0x28, 0x21, 0x06, 0x43, 0xbc, 0x04, 0xc4, 0xf9, 0x41, + 0xa3, 0x96, 0x02, 0x06, 0xef, 0x06, 0xcf, 0x01, 0x46, 0x8a, 0x66, 0x6e, + 0x0d, 0x01, 0x4a, 0x7b, 0x9d, 0x8f, 0x0d, 0x01, 0x49, 0x21, 0x75, 0x8e, + 0x0d, 0x01, 0x52, 0x2f, 0x57, 0x6f, 0x0d, 0x01, 0xb3, 0x25, 0x06, 0x74, + 0x3b, 0x01, 0xff, 0x4b, 0x7a, 0x3b, 0x4e, 0x0d, 0x01, 0x05, 0x5a, 0x03, + 0x01, 0xff, 0xe1, 0x4a, 0x0d, 0x01, 0xe5, 0x69, 0x0d, 0x81, 0x08, 0xe9, + 0x4b, 0x0d, 0x01, 0xef, 0x4c, 0x0d, 0x41, 0xe5, 0x4d, 0x0d, 0x41, 0x0c, + 0x9c, 0x08, 0x06, 0x44, 0x0c, 0xf1, 0x4f, 0x0d, 0x41, 0xe1, 0x70, 0x0d, + 0x01, 0x42, 0x16, 0x00, 0x74, 0x0d, 0x01, 0x42, 0x37, 0x00, 0x71, 0x0d, + 0x01, 0x42, 0x7b, 0x08, 0x7a, 0x0d, 0x01, 0x42, 0x0c, 0x08, 0x80, 0x0d, + 0x01, 0x42, 0x24, 0x02, 0x79, 0x0d, 0x01, 0x42, 0x22, 0x00, 0x83, 0x0d, + 0x01, 0x42, 0x78, 0x1a, 0x75, 0x0d, 0x01, 0x42, 0x1b, 0x02, 0x73, 0x0d, + 0x01, 0x42, 0x74, 0x00, 0x78, 0x0d, 0x01, 0x42, 0x6c, 0x00, 0x72, 0x0d, + 0x01, 0xae, 0x3a, 0x04, 0x9c, 0x26, 0x2a, 0x42, 0xe0, 0x09, 0x82, 0x0d, + 0x01, 0x42, 0x71, 0x00, 0x7e, 0x0d, 0x01, 0x42, 0x40, 0x06, 0x76, 0x0d, + 0x01, 0x42, 0x12, 0x00, 0x7d, 0x0d, 0x01, 0x42, 0xa9, 0x01, 0x77, 0x0d, + 0x01, 0x42, 0x5b, 0x28, 0x7b, 0x0d, 0x01, 0x42, 0xdf, 0x23, 0x7c, 0x0d, + 0x41, 0x42, 0x1b, 0x02, 0x84, 0x0d, 0x01, 0x42, 0x2a, 0x05, 0x85, 0x0d, + 0x41, 0xe1, 0x81, 0x0d, 0x01, 0x42, 0xdf, 0x23, 0x7f, 0x0d, 0x41, 0x45, + 0x7e, 0x0b, 0x48, 0x0d, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x49, 0x0d, + 0x01, 0x43, 0x7a, 0x0b, 0x41, 0x0d, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, + 0x80, 0x1f, 0x40, 0x0d, 0x41, 0x44, 0x25, 0x01, 0x43, 0x0d, 0x01, 0x42, + 0x15, 0x02, 0x42, 0x0d, 0x41, 0x44, 0x06, 0x1f, 0x47, 0x0d, 0x01, 0x42, + 0x09, 0x24, 0x46, 0x0d, 0x41, 0x43, 0xf9, 0x05, 0x45, 0x0d, 0x01, 0x43, + 0xf6, 0x06, 0x44, 0x0d, 0x41, 0x0e, 0x0c, 0x06, 0x24, 0xaf, 0x01, 0xff, + 0x0a, 0x3e, 0xb3, 0x11, 0x08, 0xf5, 0x34, 0x01, 0xff, 0x4f, 0xad, 0x70, + 0x6a, 0x0d, 0x01, 0x51, 0xf2, 0x5e, 0x6d, 0x0d, 0x41, 0x47, 0x79, 0x1f, + 0x6b, 0x0d, 0x01, 0x4e, 0xec, 0x64, 0x6c, 0x0d, 0x41, 0xe1, 0x50, 0x0d, + 0x01, 0x42, 0x16, 0x00, 0x54, 0x0d, 0x01, 0x42, 0x37, 0x00, 0x51, 0x0d, + 0x01, 0x42, 0x7b, 0x08, 0x5a, 0x0d, 0x01, 0x42, 0x0c, 0x08, 0x60, 0x0d, + 0x01, 0x42, 0x24, 0x02, 0x59, 0x0d, 0x01, 0x42, 0x22, 0x00, 0x63, 0x0d, + 0x01, 0x42, 0x78, 0x1a, 0x55, 0x0d, 0x01, 0x42, 0x1b, 0x02, 0x53, 0x0d, + 0x01, 0x42, 0x74, 0x00, 0x58, 0x0d, 0x01, 0x42, 0x6c, 0x00, 0x52, 0x0d, + 0x01, 0xae, 0x3a, 0x04, 0x9c, 0x26, 0x2a, 0x42, 0xe0, 0x09, 0x62, 0x0d, + 0x01, 0x42, 0x71, 0x00, 0x5e, 0x0d, 0x01, 0x42, 0x40, 0x06, 0x56, 0x0d, + 0x01, 0x42, 0x12, 0x00, 0x5d, 0x0d, 0x01, 0x42, 0xa9, 0x01, 0x57, 0x0d, + 0x01, 0x42, 0x5b, 0x28, 0x5b, 0x0d, 0x01, 0x42, 0xdf, 0x23, 0x5c, 0x0d, + 0x41, 0x42, 0x1b, 0x02, 0x64, 0x0d, 0x01, 0x42, 0x2a, 0x05, 0x65, 0x0d, + 0x41, 0xe1, 0x61, 0x0d, 0x01, 0x42, 0xdf, 0x23, 0x5f, 0x0d, 0x41, 0xa1, + 0xbb, 0x0b, 0xa5, 0x87, 0x0b, 0xe6, 0x0c, 0x00, 0x00, 0xa9, 0xa4, 0x09, + 0xac, 0xf7, 0x07, 0xaf, 0xb0, 0x06, 0xb2, 0xb9, 0x05, 0xf3, 0x1c, 0x00, + 0x80, 0xaf, 0x05, 0xb5, 0x15, 0x02, 0x8f, 0xf8, 0x01, 0xff, 0xd1, 0x0b, + 0x18, 0x00, 0xd2, 0x0c, 0x18, 0x00, 0xd3, 0x0d, 0x18, 0x00, 0xd4, 0x0f, + 0x18, 0x40, 0x47, 0x8f, 0xd6, 0xfd, 0x26, 0x00, 0x02, 0x60, 0x07, 0x1a, + 0xae, 0x06, 0x42, 0x46, 0x03, 0xdb, 0x23, 0x40, 0x51, 0x17, 0x5c, 0x61, + 0x20, 0x00, 0x48, 0x67, 0xcb, 0xb1, 0x26, 0x00, 0x43, 0x9d, 0xcd, 0x08, + 0xce, 0x41, 0x80, 0xcf, 0x04, 0x06, 0x97, 0x52, 0x01, 0xff, 0xa1, 0xb5, + 0x04, 0x4a, 0xbc, 0xad, 0xe4, 0xff, 0x00, 0xa3, 0x88, 0x04, 0xa4, 0xb9, + 0x03, 0xa5, 0xaa, 0x03, 0x49, 0x4f, 0x17, 0x0e, 0xff, 0x00, 0x02, 0x87, + 0x00, 0x93, 0x03, 0x4c, 0x70, 0x94, 0x0d, 0xff, 0x00, 0xac, 0x83, 0x01, + 0x46, 0xd1, 0x73, 0xe3, 0xff, 0x00, 0xae, 0x6f, 0xb0, 0x5b, 0x02, 0x7c, + 0x00, 0x4b, 0xb2, 0x26, 0xb3, 0x18, 0x45, 0x71, 0x24, 0x5e, 0xff, 0x00, + 0x4d, 0x39, 0x0c, 0x5c, 0xff, 0x00, 0x48, 0x4f, 0xd2, 0xe6, 0xff, 0x00, + 0x48, 0x18, 0x83, 0xe5, 0xff, 0x40, 0x48, 0x5b, 0x5c, 0x1b, 0xff, 0x00, + 0x46, 0x1c, 0x33, 0x0f, 0xff, 0x40, 0x4e, 0xa9, 0x75, 0x3c, 0xff, 0x00, + 0x05, 0xc9, 0x00, 0x01, 0xff, 0x4d, 0xde, 0x0b, 0x5d, 0xff, 0x00, 0x4b, + 0xfb, 0x22, 0x09, 0xff, 0x00, 0x4e, 0x36, 0x28, 0x3d, 0xff, 0x00, 0x51, + 0x22, 0x62, 0x60, 0xff, 0x40, 0x4b, 0x8a, 0x36, 0x1f, 0xff, 0x00, 0x4c, + 0x1b, 0x05, 0x02, 0xff, 0x40, 0x4b, 0x00, 0xa1, 0x05, 0xff, 0x00, 0x48, + 0x22, 0x75, 0x0b, 0xff, 0x00, 0x49, 0x47, 0xb5, 0xe1, 0xff, 0x40, 0x47, + 0xbe, 0x76, 0xe2, 0xff, 0x00, 0x4a, 0x1a, 0x6b, 0x03, 0xff, 0x40, 0x05, + 0x06, 0x06, 0x2a, 0xa5, 0x06, 0x47, 0x08, 0x8f, 0x3f, 0xff, 0x40, 0x03, + 0xc5, 0x00, 0x06, 0x4c, 0x64, 0x9a, 0x1c, 0xff, 0x40, 0x4d, 0xde, 0x0b, + 0x5b, 0xff, 0x00, 0x4b, 0xfb, 0x22, 0x08, 0xff, 0x00, 0x4e, 0x36, 0x28, + 0x3b, 0xff, 0x00, 0x51, 0x22, 0x62, 0x5f, 0xff, 0x40, 0x0f, 0x0b, 0x06, + 0x6d, 0x0d, 0x9b, 0x08, 0x01, 0xff, 0xe1, 0x41, 0xff, 0x00, 0xe2, 0x42, + 0xff, 0x00, 0xe3, 0x43, 0xff, 0x00, 0xe4, 0x44, 0xff, 0x00, 0xe5, 0x45, + 0xff, 0x00, 0xe6, 0x46, 0xff, 0x00, 0xe7, 0x47, 0xff, 0x00, 0xe8, 0x48, + 0xff, 0x00, 0xe9, 0x49, 0xff, 0x00, 0xea, 0x4a, 0xff, 0x00, 0xeb, 0x4b, + 0xff, 0x00, 0xec, 0x4c, 0xff, 0x00, 0xed, 0x4d, 0xff, 0x00, 0xee, 0x4e, + 0xff, 0x00, 0xef, 0x4f, 0xff, 0x00, 0xf0, 0x50, 0xff, 0x00, 0xf1, 0x51, + 0xff, 0x00, 0xf2, 0x52, 0xff, 0x00, 0xf3, 0x53, 0xff, 0x00, 0xf4, 0x54, + 0xff, 0x00, 0xf5, 0x55, 0xff, 0x00, 0xf6, 0x56, 0xff, 0x00, 0xf7, 0x57, + 0xff, 0x00, 0xf8, 0x58, 0xff, 0x00, 0xf9, 0x59, 0xff, 0x00, 0xfa, 0x5a, + 0xff, 0x40, 0xe1, 0x21, 0xff, 0x00, 0xe2, 0x22, 0xff, 0x00, 0xe3, 0x23, + 0xff, 0x00, 0xe4, 0x24, 0xff, 0x00, 0xe5, 0x25, 0xff, 0x00, 0xe6, 0x26, + 0xff, 0x00, 0xe7, 0x27, 0xff, 0x00, 0xe8, 0x28, 0xff, 0x00, 0xe9, 0x29, + 0xff, 0x00, 0xea, 0x2a, 0xff, 0x00, 0xeb, 0x2b, 0xff, 0x00, 0xec, 0x2c, + 0xff, 0x00, 0xed, 0x2d, 0xff, 0x00, 0xee, 0x2e, 0xff, 0x00, 0xef, 0x2f, + 0xff, 0x00, 0xf0, 0x30, 0xff, 0x00, 0xf1, 0x31, 0xff, 0x00, 0xf2, 0x32, + 0xff, 0x00, 0xf3, 0x33, 0xff, 0x00, 0xf4, 0x34, 0xff, 0x00, 0xf5, 0x35, + 0xff, 0x00, 0xf6, 0x36, 0xff, 0x00, 0xf7, 0x37, 0xff, 0x00, 0xf8, 0x38, + 0xff, 0x00, 0xf9, 0x39, 0xff, 0x00, 0xfa, 0x3a, 0xff, 0x40, 0x4a, 0x53, + 0x24, 0x40, 0xff, 0x00, 0x4f, 0xe5, 0x5c, 0x1e, 0xff, 0x40, 0x4a, 0x17, + 0x14, 0x1d, 0xff, 0x00, 0x4f, 0xae, 0x00, 0x01, 0xff, 0x40, 0x05, 0xf0, + 0x06, 0x06, 0x4a, 0x30, 0xa0, 0x04, 0xff, 0x40, 0x45, 0x7e, 0x0b, 0x18, + 0xff, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x19, 0xff, 0x00, 0x43, 0x7a, + 0x0b, 0x11, 0xff, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x10, + 0xff, 0x40, 0x44, 0x25, 0x01, 0x13, 0xff, 0x00, 0x42, 0x15, 0x02, 0x12, + 0xff, 0x40, 0x44, 0x06, 0x1f, 0x17, 0xff, 0x00, 0x42, 0x09, 0x24, 0x16, + 0xff, 0x40, 0x43, 0xf9, 0x05, 0x15, 0xff, 0x00, 0x43, 0xf6, 0x06, 0x14, + 0xff, 0x40, 0x48, 0x03, 0xa1, 0xe0, 0xff, 0x00, 0x50, 0xd0, 0x04, 0x3e, + 0xff, 0x00, 0xaf, 0x01, 0xff, 0x43, 0xd7, 0x02, 0x1a, 0xff, 0x00, 0x02, + 0x15, 0x05, 0x01, 0xff, 0xe1, 0x0c, 0xff, 0x00, 0x49, 0x1f, 0xbe, 0x20, + 0xff, 0x40, 0x48, 0x36, 0x40, 0x06, 0xff, 0x00, 0x49, 0x5a, 0x38, 0x07, + 0xff, 0x00, 0x47, 0xcb, 0x0d, 0x0a, 0xff, 0x40, 0x45, 0x33, 0x01, 0x88, + 0x25, 0x00, 0x05, 0xd1, 0x1c, 0x0c, 0x4a, 0xec, 0xb4, 0xd7, 0x27, 0x00, + 0x44, 0x55, 0x03, 0x2e, 0x00, 0x40, 0x46, 0x16, 0x08, 0x15, 0xf3, 0x01, + 0x49, 0x1f, 0xc7, 0x1d, 0xf3, 0x41, 0xe9, 0x68, 0x20, 0x40, 0xa1, 0x45, + 0xa5, 0x2c, 0x4a, 0x04, 0xb1, 0x64, 0xf3, 0x01, 0xaf, 0x01, 0xff, 0x46, + 0xce, 0x2a, 0x38, 0xf4, 0x01, 0x03, 0xe5, 0x10, 0x0d, 0x42, 0xa7, 0x01, + 0x22, 0x23, 0xc0, 0x00, 0x58, 0xcc, 0x2a, 0x26, 0xf6, 0x41, 0x51, 0x6c, + 0x5c, 0x25, 0xf4, 0x01, 0x66, 0x59, 0x05, 0xac, 0x27, 0x40, 0x4a, 0xb4, + 0xa0, 0x76, 0xf9, 0x01, 0x06, 0x26, 0xe4, 0x01, 0xff, 0x48, 0xff, 0xc8, + 0xa3, 0x20, 0x00, 0x43, 0x3e, 0xa3, 0x5f, 0xf3, 0x41, 0x06, 0xf0, 0x17, + 0x1d, 0x4b, 0x9a, 0xa1, 0xba, 0xce, 0x01, 0x08, 0xe7, 0xcd, 0x01, 0xff, + 0x44, 0xe4, 0xf4, 0xbe, 0xf5, 0x01, 0x47, 0x89, 0x8f, 0xbc, 0xf5, 0x01, + 0x45, 0xaf, 0xdb, 0xbd, 0xf5, 0x41, 0x4d, 0xe5, 0x8a, 0x5f, 0x21, 0x00, + 0x45, 0xd6, 0x0e, 0x44, 0x20, 0x40, 0xe7, 0x2b, 0xf3, 0x81, 0xb8, 0x01, + 0x02, 0x04, 0x1c, 0xa7, 0x01, 0x44, 0x60, 0xf7, 0xd5, 0xfa, 0x01, 0x42, + 0x1b, 0x05, 0xb6, 0xf9, 0x81, 0x93, 0x01, 0xb2, 0x55, 0xb5, 0x06, 0x46, + 0x5c, 0xe7, 0x8a, 0xf9, 0x41, 0x45, 0x54, 0x07, 0xf2, 0x26, 0x00, 0xb2, + 0x01, 0xff, 0x80, 0x0c, 0x4d, 0x17, 0x84, 0x05, 0x20, 0x00, 0x47, 0x5c, + 0xa1, 0x1c, 0x22, 0x40, 0x57, 0xef, 0x1d, 0x23, 0x27, 0x00, 0xa3, 0x22, + 0x04, 0x6f, 0x0c, 0x12, 0x4b, 0x9f, 0xa3, 0x40, 0xf3, 0x01, 0x52, 0x8a, + 0x2d, 0xc6, 0xf7, 0x01, 0x58, 0x0c, 0x2d, 0x22, 0x27, 0x40, 0x44, 0xb9, + 0x00, 0x5b, 0x20, 0x00, 0x4b, 0x73, 0x0c, 0x58, 0x20, 0x40, 0x53, 0x7d, + 0x4d, 0x25, 0x27, 0x00, 0x63, 0x8a, 0x0b, 0x94, 0x2b, 0x40, 0x44, 0x44, + 0x2f, 0x00, 0x22, 0x00, 0x43, 0x23, 0x57, 0xa9, 0x22, 0x00, 0xab, 0x15, + 0x46, 0x21, 0xcf, 0x0c, 0x00, 0x00, 0x03, 0x78, 0x08, 0x01, 0xff, 0xe1, + 0xcc, 0xce, 0x01, 0x48, 0x07, 0xcb, 0x60, 0xf9, 0x41, 0x4a, 0x00, 0xab, + 0x74, 0xf3, 0x81, 0x0c, 0x4e, 0x2d, 0x54, 0x10, 0x2e, 0x00, 0x43, 0xa1, + 0x01, 0xdc, 0x2a, 0x40, 0x4b, 0x43, 0x9d, 0x7d, 0xf3, 0x41, 0x46, 0x21, + 0xd2, 0x63, 0xf4, 0x41, 0x42, 0x33, 0x00, 0xc0, 0xf5, 0x01, 0x4c, 0xc4, + 0x94, 0xad, 0xfa, 0x41, 0x42, 0xaf, 0x37, 0x01, 0xf3, 0x41, 0xa1, 0x80, + 0x01, 0xa5, 0x72, 0xaf, 0x45, 0xb5, 0x37, 0xf9, 0xb0, 0xfa, 0xc1, 0x00, + 0x04, 0xa1, 0x01, 0x01, 0xff, 0x44, 0x40, 0x67, 0x4f, 0xf9, 0x01, 0x48, + 0x0f, 0x34, 0x85, 0xf5, 0x01, 0x46, 0x6e, 0x96, 0xf8, 0xf6, 0xc1, 0x00, + 0x80, 0x01, 0xff, 0x46, 0x16, 0x08, 0xfb, 0xcc, 0x01, 0x04, 0x51, 0x00, + 0x01, 0xff, 0x46, 0x5f, 0xc3, 0x4a, 0xcc, 0x01, 0x49, 0x5c, 0xc3, 0x4b, + 0xcc, 0x41, 0x49, 0x1b, 0x98, 0x33, 0xf6, 0x01, 0x42, 0x77, 0x00, 0x88, + 0xfa, 0x41, 0x48, 0x92, 0x3b, 0xbe, 0xf4, 0x01, 0x42, 0x71, 0x00, 0xc2, + 0xce, 0x81, 0x18, 0x43, 0x15, 0x01, 0x98, 0x26, 0xc0, 0x00, 0x02, 0x9b, + 0x01, 0x01, 0xff, 0x4c, 0x9c, 0x95, 0xb4, 0xf3, 0x01, 0x4f, 0x34, 0x23, + 0x55, 0x20, 0x40, 0x47, 0xcd, 0x22, 0x66, 0x27, 0x40, 0x49, 0x50, 0xc6, + 0x9c, 0x26, 0x00, 0x4a, 0x56, 0xb9, 0xaa, 0xf4, 0x41, 0x49, 0xc1, 0xbe, + 0xf3, 0x26, 0x00, 0x45, 0xa4, 0xee, 0xa9, 0xf9, 0x01, 0x4a, 0x50, 0xb5, + 0x96, 0xcc, 0x01, 0xb4, 0x01, 0xff, 0x45, 0xe0, 0x9c, 0x7f, 0xf9, 0x01, + 0x45, 0x67, 0x7b, 0xd3, 0xfa, 0x01, 0x44, 0x77, 0x25, 0xe5, 0x23, 0x40, + 0x59, 0x57, 0x25, 0xd1, 0xf3, 0x01, 0xa7, 0xbc, 0x01, 0xac, 0x92, 0x01, + 0xae, 0x83, 0x01, 0xb2, 0x30, 0xb3, 0x11, 0x07, 0x1f, 0xdd, 0x01, 0xff, + 0x44, 0xb9, 0x00, 0x2d, 0x2e, 0x00, 0x4b, 0x73, 0x0c, 0x59, 0x20, 0x40, + 0xe8, 0x1f, 0xf4, 0x81, 0x06, 0x4d, 0xbd, 0x8d, 0x4a, 0xf4, 0x41, 0x57, + 0xfc, 0x2d, 0x65, 0xf3, 0x01, 0x43, 0xe8, 0x1d, 0xc9, 0x25, 0x00, 0x51, + 0x9e, 0x5d, 0xa3, 0xf3, 0x41, 0xe5, 0x25, 0xf5, 0x81, 0x27, 0x03, 0x02, + 0x0f, 0x01, 0xff, 0x4b, 0x71, 0x74, 0x47, 0xf9, 0x01, 0x4c, 0x6e, 0x76, + 0x3d, 0x26, 0x80, 0x06, 0x4e, 0x66, 0x80, 0x68, 0x20, 0x40, 0x80, 0x01, + 0xff, 0x46, 0x16, 0x08, 0x13, 0xf3, 0x01, 0x49, 0x1f, 0xc7, 0x1b, 0xf3, + 0x41, 0x02, 0x7a, 0x00, 0x15, 0x47, 0xe0, 0xd5, 0xe8, 0xf9, 0x01, 0x04, + 0xf2, 0x4d, 0x01, 0xff, 0x49, 0x65, 0xba, 0x87, 0xf3, 0x01, 0xf3, 0x86, + 0xf3, 0x41, 0x45, 0x53, 0xa1, 0x92, 0xf6, 0x01, 0x4b, 0xab, 0xaa, 0xef, + 0xf9, 0x41, 0x48, 0x17, 0xcc, 0xc6, 0xfa, 0x01, 0x51, 0xd1, 0x5d, 0x0d, + 0x2a, 0x40, 0x02, 0x60, 0x00, 0x11, 0x02, 0x49, 0x04, 0x01, 0xff, 0x46, + 0xc2, 0xe1, 0x9e, 0xf3, 0x01, 0x49, 0xfe, 0xc3, 0xfd, 0xf4, 0x41, 0x47, + 0x85, 0xd5, 0xc4, 0xf5, 0x01, 0x46, 0x30, 0xb1, 0xc1, 0xf4, 0x01, 0x49, + 0xfb, 0x21, 0x1c, 0x00, 0x40, 0x48, 0x77, 0xcc, 0xef, 0xfa, 0x01, 0x04, + 0xe2, 0x11, 0x01, 0xff, 0x44, 0x5d, 0x13, 0x12, 0x20, 0x00, 0x45, 0x2d, + 0x4f, 0x07, 0x20, 0x40, 0xa1, 0x23, 0xad, 0x15, 0x44, 0x58, 0xf7, 0x3a, + 0xf9, 0x01, 0x02, 0xcf, 0x00, 0x01, 0xff, 0x48, 0xe7, 0xcc, 0xa1, 0xf3, + 0x01, 0xf9, 0xf4, 0x26, 0x40, 0x48, 0x85, 0x22, 0x40, 0x26, 0x00, 0x57, + 0xc5, 0x30, 0xaa, 0x00, 0x40, 0x49, 0x7c, 0xc4, 0x28, 0xf6, 0x01, 0x44, + 0x31, 0x1b, 0xb6, 0xfa, 0x41, 0xa3, 0x55, 0x43, 0xa9, 0xe6, 0xda, 0xf9, + 0x01, 0xac, 0x23, 0x44, 0xa0, 0xe1, 0x6a, 0xf4, 0x01, 0x4a, 0x4a, 0xb6, + 0x2b, 0x26, 0x00, 0x4e, 0xba, 0x80, 0x85, 0xf3, 0x01, 0x02, 0xd8, 0x04, + 0x01, 0xff, 0x44, 0xc0, 0xe7, 0xb7, 0xf5, 0x01, 0x47, 0xb7, 0x4a, 0xe0, + 0xf4, 0x41, 0x44, 0xc4, 0xf4, 0xc6, 0xf9, 0x01, 0xac, 0x01, 0xff, 0x47, + 0x9d, 0xd6, 0x42, 0xf3, 0x01, 0x0d, 0x05, 0x33, 0x01, 0xff, 0x09, 0x8e, + 0x08, 0x06, 0x5f, 0xfd, 0x11, 0xde, 0x26, 0x40, 0x50, 0xe3, 0x24, 0x2f, + 0x29, 0x00, 0x4f, 0x1d, 0x40, 0x2c, 0x29, 0x40, 0x02, 0x60, 0x00, 0x12, + 0x49, 0x71, 0xc0, 0x1c, 0xdb, 0x01, 0x4b, 0xd5, 0xa7, 0x3b, 0x21, 0x00, + 0x44, 0xcf, 0x9b, 0xed, 0xf3, 0x41, 0x52, 0xa7, 0x54, 0x79, 0xf9, 0x01, + 0x47, 0x05, 0xd9, 0x86, 0xf4, 0x01, 0x44, 0xf3, 0x42, 0x26, 0xf9, 0x01, + 0xb3, 0xcb, 0x01, 0x4f, 0xe3, 0x76, 0x18, 0xf6, 0x01, 0x04, 0x51, 0x00, + 0x01, 0xff, 0x80, 0x06, 0x49, 0x65, 0xc3, 0x36, 0xf6, 0x41, 0x4f, 0x37, + 0x6e, 0xe9, 0xfa, 0x01, 0x02, 0x13, 0x05, 0xa1, 0x01, 0x4e, 0x46, 0x7a, + 0xe4, 0xfa, 0x01, 0x5b, 0x71, 0x1c, 0x2b, 0xf9, 0x01, 0x4c, 0x4c, 0x94, + 0x15, 0xf9, 0x01, 0x4f, 0x32, 0x73, 0x24, 0xf6, 0x01, 0xad, 0x7b, 0x4f, + 0xd7, 0x73, 0x45, 0xf6, 0x01, 0xaf, 0x46, 0xb0, 0x32, 0x4c, 0xbc, 0x99, + 0x44, 0xf6, 0x01, 0x50, 0xba, 0x6a, 0x1b, 0xf6, 0x81, 0x14, 0xb4, 0x06, + 0x5a, 0x91, 0x23, 0x74, 0xf9, 0x41, 0x4b, 0xad, 0x9a, 0x02, 0xf6, 0x01, + 0x4a, 0xaa, 0xb0, 0x12, 0xf9, 0x41, 0x05, 0x19, 0x00, 0x01, 0xff, 0x53, + 0xf0, 0x4f, 0x1d, 0xf6, 0x01, 0x4b, 0x69, 0xaa, 0x1c, 0xf6, 0x41, 0x57, + 0xe2, 0x2e, 0x73, 0xf9, 0x01, 0x4a, 0x1a, 0xaf, 0xe3, 0xfa, 0x01, 0x4c, + 0xa8, 0x95, 0x7a, 0xf9, 0x41, 0x49, 0xa7, 0xc0, 0x46, 0xf6, 0x01, 0x51, + 0x25, 0x5f, 0x28, 0xf9, 0x01, 0x04, 0xf7, 0x04, 0x01, 0xff, 0x58, 0x0c, + 0x2a, 0xe2, 0xfa, 0x01, 0x45, 0x27, 0x08, 0x2e, 0xf6, 0xc1, 0x00, 0x80, + 0x01, 0xff, 0x4e, 0x58, 0x79, 0x30, 0xf6, 0x01, 0x48, 0x17, 0xd2, 0x2e, + 0xf9, 0x41, 0x4b, 0xa8, 0xa0, 0x37, 0xf6, 0x01, 0x46, 0xc2, 0xe4, 0xd0, + 0xf9, 0x41, 0x48, 0x5e, 0x79, 0x13, 0xf6, 0x01, 0x48, 0x2f, 0xd2, 0x20, + 0xf9, 0x41, 0x57, 0x27, 0x2f, 0x0b, 0xf6, 0x01, 0x50, 0x9a, 0x64, 0x31, + 0xf6, 0x41, 0x4c, 0x5c, 0x90, 0xe7, 0xf4, 0x01, 0xa1, 0xf7, 0x48, 0x50, + 0xba, 0x64, 0x0e, 0x2e, 0x00, 0xa7, 0xf9, 0x20, 0x04, 0xc9, 0x00, 0xb1, + 0x20, 0x4b, 0x05, 0xa3, 0xcf, 0x23, 0x00, 0xac, 0xa7, 0x1c, 0xed, 0x19, + 0x00, 0x80, 0xf0, 0x1a, 0xae, 0xe4, 0x19, 0xaf, 0xd5, 0x19, 0x42, 0xe0, + 0x09, 0x97, 0x00, 0x00, 0x02, 0x7c, 0x00, 0x8f, 0x18, 0xb2, 0xb2, 0x17, + 0xb3, 0x91, 0x17, 0xb4, 0x8a, 0x02, 0xb5, 0xd9, 0x01, 0x4d, 0x9a, 0x8e, + 0x32, 0xf3, 0x01, 0xb8, 0x11, 0x42, 0x4d, 0x00, 0x41, 0xf4, 0xc1, 0x00, + 0x47, 0x25, 0xc6, 0x53, 0xf4, 0x01, 0xf3, 0x40, 0xf4, 0x41, 0xa3, 0xa6, + 0x01, 0xb0, 0x82, 0x01, 0xb4, 0x01, 0xff, 0x19, 0xdc, 0x06, 0x39, 0xb2, + 0x01, 0xff, 0x52, 0xc1, 0x52, 0x7d, 0xf4, 0x01, 0x0c, 0x2c, 0x93, 0x01, + 0xff, 0x54, 0x7b, 0x44, 0xb4, 0xf7, 0x01, 0x4b, 0xef, 0x63, 0xa7, 0xf7, + 0x01, 0xb3, 0x11, 0x06, 0xad, 0x02, 0x01, 0xff, 0x46, 0x12, 0x03, 0x89, + 0xf7, 0x01, 0x46, 0xfd, 0x05, 0x93, 0xf7, 0x41, 0x46, 0x35, 0x1a, 0xae, + 0xf7, 0x01, 0x52, 0x5b, 0x55, 0xba, 0xf7, 0x41, 0x45, 0x7e, 0x0b, 0xf8, + 0x06, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xf9, 0x06, 0x00, 0x43, 0x7a, + 0x0b, 0xf1, 0x06, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0xf0, + 0x06, 0x40, 0x44, 0x25, 0x01, 0xf3, 0x06, 0x00, 0x42, 0x15, 0x02, 0xf2, + 0x06, 0x40, 0x44, 0x06, 0x1f, 0xf7, 0x06, 0x00, 0x42, 0x09, 0x24, 0xf6, + 0x06, 0x40, 0x43, 0xf9, 0x05, 0xf5, 0x06, 0x00, 0x43, 0xf6, 0x06, 0xf4, + 0x06, 0x40, 0x07, 0xdb, 0xd8, 0x06, 0x50, 0x9a, 0x69, 0x11, 0xf6, 0x41, + 0x4a, 0x58, 0xad, 0x02, 0xce, 0x01, 0x06, 0x2d, 0x46, 0x01, 0xff, 0xd1, + 0xfd, 0xcd, 0x01, 0xd2, 0xfe, 0xcd, 0x01, 0xd3, 0xff, 0xcd, 0x41, 0x43, + 0xed, 0x00, 0x39, 0x22, 0x00, 0x09, 0xb0, 0x00, 0x01, 0xff, 0x44, 0xb9, + 0x00, 0x21, 0x00, 0x00, 0x4d, 0x88, 0x36, 0x49, 0x20, 0x40, 0x4c, 0xcc, + 0x95, 0x07, 0x21, 0x00, 0x45, 0x21, 0xef, 0xc8, 0xce, 0x01, 0x02, 0xd0, + 0x00, 0x01, 0xff, 0x45, 0x59, 0x03, 0xac, 0x20, 0x00, 0x4e, 0xda, 0x78, + 0xa0, 0x20, 0x00, 0x05, 0xc1, 0xef, 0x01, 0xff, 0x46, 0x48, 0xe0, 0xf0, + 0xf3, 0x01, 0x4b, 0xa1, 0xa6, 0xe4, 0xf3, 0x41, 0xe2, 0x17, 0x00, 0x00, + 0x07, 0x68, 0xd7, 0x04, 0xf8, 0x03, 0x00, 0x40, 0x02, 0x13, 0x05, 0xca, + 0x14, 0x06, 0xef, 0x06, 0x88, 0x14, 0x49, 0x4f, 0x17, 0x62, 0x13, 0x00, + 0x07, 0x37, 0x3c, 0xb3, 0x13, 0xb0, 0xa4, 0x13, 0x4d, 0x88, 0x36, 0x67, + 0x13, 0x00, 0xb3, 0x4b, 0x0b, 0xe8, 0xa8, 0x06, 0x49, 0x28, 0xc7, 0x61, + 0x13, 0x40, 0x46, 0x7e, 0xe0, 0x96, 0x13, 0x00, 0xa4, 0x26, 0x45, 0x45, + 0xde, 0x97, 0x13, 0x00, 0xab, 0x12, 0x46, 0x3a, 0x9a, 0x92, 0x13, 0x00, + 0x4c, 0x34, 0x9a, 0x93, 0x13, 0x00, 0x45, 0x78, 0xf2, 0x90, 0x13, 0x40, + 0x44, 0xd1, 0x52, 0x95, 0x13, 0x00, 0x43, 0xf0, 0x1e, 0x99, 0x13, 0x40, + 0x44, 0x7c, 0xaf, 0x91, 0x13, 0x80, 0x06, 0x44, 0x5c, 0xf6, 0x94, 0x13, + 0x40, 0x46, 0x44, 0xde, 0x98, 0x13, 0x40, 0xa5, 0xc2, 0x12, 0x08, 0x21, + 0x19, 0x01, 0xff, 0xa2, 0xe3, 0x11, 0xa3, 0xab, 0x10, 0xa4, 0x98, 0x0f, + 0xa6, 0xde, 0x0e, 0xa7, 0x9c, 0x0c, 0xa8, 0xa2, 0x0b, 0xaa, 0xf6, 0x0a, + 0xab, 0xdc, 0x09, 0xac, 0xb0, 0x09, 0xad, 0xf1, 0x08, 0xae, 0x99, 0x08, + 0xb0, 0x91, 0x07, 0xb1, 0xf7, 0x05, 0xb2, 0xc5, 0x05, 0xb3, 0x89, 0x04, + 0xb4, 0xc4, 0x02, 0xb6, 0x9d, 0x02, 0xb7, 0xf7, 0x01, 0xb8, 0x98, 0x01, + 0xb9, 0x73, 0xba, 0x01, 0xff, 0xe1, 0xd8, 0x12, 0x80, 0x67, 0xe5, 0xdd, + 0x12, 0x80, 0x5e, 0xa8, 0x38, 0xe9, 0xda, 0x12, 0x00, 0xef, 0xde, 0x12, + 0x80, 0x2b, 0xf5, 0xd9, 0x12, 0x00, 0x42, 0xa9, 0x01, 0xdf, 0x12, 0x00, + 0xba, 0x01, 0xff, 0xe1, 0xb0, 0x2d, 0x80, 0x15, 0xe5, 0xb5, 0x2d, 0x80, + 0x0c, 0xe9, 0xb2, 0x2d, 0x00, 0xef, 0xb6, 0x2d, 0x00, 0xf5, 0xb1, 0x2d, + 0x40, 0xe5, 0xb4, 0x2d, 0x40, 0xe1, 0xb3, 0x2d, 0x40, 0xe1, 0x8b, 0x2d, + 0x40, 0xe1, 0xe0, 0x12, 0x80, 0x1b, 0xe5, 0xe5, 0x12, 0x80, 0x12, 0xe9, + 0xe2, 0x12, 0x00, 0xef, 0xe6, 0x12, 0x00, 0xf5, 0xe1, 0x12, 0x00, 0x42, + 0xa9, 0x01, 0xe7, 0x12, 0x40, 0xe5, 0xe4, 0x12, 0x40, 0xe1, 0xe3, 0x12, + 0x40, 0xe5, 0xdc, 0x12, 0x40, 0xe1, 0xdb, 0x12, 0x40, 0xe1, 0xe8, 0x12, + 0x80, 0x1a, 0xe5, 0xed, 0x12, 0x80, 0x11, 0xe9, 0xea, 0x12, 0x00, 0xef, + 0xee, 0x12, 0x80, 0x04, 0xf5, 0xe9, 0x12, 0x40, 0xe1, 0xef, 0x12, 0x40, + 0xe5, 0xec, 0x12, 0x40, 0xe1, 0xeb, 0x12, 0x40, 0xe1, 0x80, 0x12, 0x80, + 0x53, 0xe5, 0x85, 0x12, 0x80, 0x4a, 0xe9, 0x82, 0x12, 0x00, 0xef, 0x86, + 0x12, 0x80, 0x3d, 0xf5, 0x81, 0x12, 0x00, 0xb7, 0x21, 0xb9, 0x01, 0xff, + 0xe1, 0xd0, 0x2d, 0x80, 0x15, 0xe5, 0xd5, 0x2d, 0x80, 0x0c, 0xe9, 0xd2, + 0x2d, 0x00, 0xef, 0xd6, 0x2d, 0x00, 0xf5, 0xd1, 0x2d, 0x40, 0xe5, 0xd4, + 0x2d, 0x40, 0xe1, 0xd3, 0x2d, 0x40, 0xe1, 0x88, 0x12, 0x80, 0x0d, 0xe5, + 0x8d, 0x12, 0x80, 0x04, 0xe9, 0x8a, 0x12, 0x40, 0xe5, 0x8c, 0x12, 0x40, + 0xe1, 0x8b, 0x12, 0x40, 0xe1, 0x87, 0x12, 0x40, 0xe5, 0x84, 0x12, 0x40, + 0xe1, 0x83, 0x12, 0x40, 0xe1, 0xc8, 0x12, 0x80, 0x1a, 0xe5, 0xcd, 0x12, + 0x80, 0x11, 0xe9, 0xca, 0x12, 0x00, 0xef, 0xce, 0x12, 0x80, 0x04, 0xf5, + 0xc9, 0x12, 0x40, 0xe1, 0xcf, 0x12, 0x40, 0xe5, 0xcc, 0x12, 0x40, 0xe1, + 0xcb, 0x12, 0x40, 0xe1, 0x68, 0x12, 0x80, 0x1b, 0xe5, 0x6d, 0x12, 0x80, + 0x12, 0xe9, 0x6a, 0x12, 0x00, 0xef, 0x6e, 0x12, 0x00, 0xf5, 0x69, 0x12, + 0x00, 0x42, 0xa9, 0x01, 0x6f, 0x12, 0x40, 0xe5, 0x6c, 0x12, 0x40, 0xe1, + 0x6b, 0x12, 0x40, 0xe1, 0x70, 0x12, 0x80, 0xb8, 0x01, 0xe5, 0x75, 0x12, + 0x80, 0xae, 0x01, 0xa8, 0x82, 0x01, 0xe9, 0x72, 0x12, 0x00, 0xef, 0x76, + 0x12, 0x80, 0x75, 0xb3, 0x4f, 0x02, 0x53, 0x00, 0x30, 0xf5, 0x71, 0x12, + 0x00, 0x42, 0xa9, 0x01, 0x77, 0x12, 0x00, 0xba, 0x01, 0xff, 0xe1, 0x40, + 0x13, 0x80, 0x1a, 0xe5, 0x45, 0x13, 0x80, 0x11, 0xe9, 0x42, 0x13, 0x00, + 0xef, 0x46, 0x13, 0x80, 0x04, 0xf5, 0x41, 0x13, 0x40, 0xe1, 0x47, 0x13, + 0x40, 0xe5, 0x44, 0x13, 0x40, 0xe1, 0x43, 0x13, 0x40, 0x42, 0x4e, 0x13, + 0x03, 0xab, 0x00, 0xe5, 0x05, 0xab, 0x80, 0x0c, 0xe9, 0x02, 0xab, 0x00, + 0xef, 0x06, 0xab, 0x00, 0xf5, 0x01, 0xab, 0x40, 0xe5, 0x04, 0xab, 0x40, + 0xe1, 0x38, 0x13, 0x80, 0x1b, 0xe5, 0x3d, 0x13, 0x80, 0x12, 0xe9, 0x3a, + 0x13, 0x00, 0xef, 0x3e, 0x13, 0x00, 0xf5, 0x39, 0x13, 0x00, 0x42, 0xa9, + 0x01, 0x3f, 0x13, 0x40, 0xe5, 0x3c, 0x13, 0x40, 0xe1, 0x3b, 0x13, 0x40, + 0xe1, 0x86, 0x2d, 0x40, 0xe1, 0x20, 0x13, 0x80, 0x20, 0xe5, 0x25, 0x13, + 0x80, 0x17, 0xe9, 0x22, 0x13, 0x00, 0xef, 0x26, 0x13, 0x80, 0x0a, 0xf5, + 0x21, 0x13, 0x00, 0x42, 0xa9, 0x01, 0x27, 0x13, 0x40, 0xe1, 0x8f, 0x2d, + 0x40, 0xe5, 0x24, 0x13, 0x40, 0xe1, 0x23, 0x13, 0x40, 0xe5, 0x74, 0x12, + 0x40, 0xe1, 0x73, 0x12, 0x40, 0xe1, 0x30, 0x12, 0x80, 0xaf, 0x01, 0xe5, + 0x35, 0x12, 0x80, 0x89, 0x01, 0xa8, 0x5e, 0xe9, 0x32, 0x12, 0x00, 0xef, + 0x36, 0x12, 0x80, 0x51, 0xb3, 0x31, 0xf5, 0x31, 0x12, 0x00, 0x42, 0xa9, + 0x01, 0x37, 0x12, 0x00, 0xba, 0x01, 0xff, 0xe1, 0x20, 0x12, 0x80, 0x1b, + 0xe5, 0x25, 0x12, 0x80, 0x12, 0xe9, 0x22, 0x12, 0x00, 0xef, 0x26, 0x12, + 0x00, 0xf5, 0x21, 0x12, 0x00, 0x42, 0xa9, 0x01, 0x27, 0x12, 0x40, 0xe5, + 0x24, 0x12, 0x40, 0xe1, 0x23, 0x12, 0x40, 0xe1, 0xa0, 0x2d, 0x80, 0x15, + 0xe5, 0xa5, 0x2d, 0x80, 0x0c, 0xe9, 0xa2, 0x2d, 0x00, 0xef, 0xa6, 0x2d, + 0x00, 0xf5, 0xa1, 0x2d, 0x40, 0xe5, 0xa4, 0x2d, 0x40, 0xe1, 0xa3, 0x2d, + 0x40, 0xe1, 0x83, 0x2d, 0x40, 0xe1, 0x38, 0x12, 0x80, 0x20, 0xe5, 0x3d, + 0x12, 0x80, 0x17, 0xe9, 0x3a, 0x12, 0x00, 0xef, 0x3e, 0x12, 0x80, 0x0a, + 0xf5, 0x39, 0x12, 0x00, 0x42, 0xa9, 0x01, 0x3f, 0x12, 0x40, 0xe1, 0x84, + 0x2d, 0x40, 0xe5, 0x3c, 0x12, 0x40, 0xe1, 0x3b, 0x12, 0x40, 0x08, 0xa7, + 0xc9, 0x04, 0xe5, 0x34, 0x12, 0x40, 0x43, 0x20, 0xd8, 0x84, 0x13, 0x00, + 0x43, 0xbc, 0xf5, 0x88, 0x13, 0x00, 0x43, 0x70, 0x99, 0x80, 0x13, 0x00, + 0x43, 0x51, 0x02, 0x8c, 0x13, 0x40, 0xe1, 0x33, 0x12, 0x40, 0xe1, 0x28, + 0x12, 0x80, 0x26, 0xe5, 0x2d, 0x12, 0x80, 0x1d, 0xe9, 0x2a, 0x12, 0x00, + 0xef, 0x2e, 0x12, 0x80, 0x10, 0xf5, 0x29, 0x12, 0x00, 0x42, 0xa9, 0x01, + 0x2f, 0x12, 0x00, 0x42, 0xdf, 0x23, 0x58, 0x13, 0x40, 0xe1, 0x82, 0x2d, + 0x40, 0xe5, 0x2c, 0x12, 0x40, 0xe1, 0x2b, 0x12, 0x40, 0xe1, 0x40, 0x12, + 0x80, 0x8d, 0x01, 0xe5, 0x45, 0x12, 0x80, 0x83, 0x01, 0xa8, 0x4a, 0xe9, + 0x42, 0x12, 0x00, 0xef, 0x46, 0x12, 0x80, 0x3d, 0xf5, 0x41, 0x12, 0x00, + 0xb7, 0x21, 0xb9, 0x01, 0xff, 0xe1, 0xc0, 0x2d, 0x80, 0x15, 0xe5, 0xc5, + 0x2d, 0x80, 0x0c, 0xe9, 0xc2, 0x2d, 0x00, 0xef, 0xc6, 0x2d, 0x00, 0xf5, + 0xc1, 0x2d, 0x40, 0xe5, 0xc4, 0x2d, 0x40, 0xe1, 0xc3, 0x2d, 0x40, 0xe1, + 0x48, 0x12, 0x80, 0x0d, 0xe5, 0x4d, 0x12, 0x80, 0x04, 0xe9, 0x4a, 0x12, + 0x40, 0xe5, 0x4c, 0x12, 0x40, 0xe1, 0x4b, 0x12, 0x40, 0xe1, 0x47, 0x12, + 0x40, 0xe1, 0x50, 0x12, 0x80, 0x2e, 0xe5, 0x55, 0x12, 0x80, 0x25, 0xe9, + 0x52, 0x12, 0x00, 0xef, 0x56, 0x12, 0x00, 0xf5, 0x51, 0x12, 0x00, 0xb7, + 0x01, 0xff, 0xe1, 0x58, 0x12, 0x80, 0x0d, 0xe5, 0x5d, 0x12, 0x80, 0x04, + 0xe9, 0x5a, 0x12, 0x40, 0xe5, 0x5c, 0x12, 0x40, 0xe1, 0x5b, 0x12, 0x40, + 0xe5, 0x54, 0x12, 0x40, 0xe1, 0x53, 0x12, 0x40, 0xe5, 0x44, 0x12, 0x40, + 0xe1, 0x43, 0x12, 0x40, 0xe1, 0x50, 0x13, 0x80, 0x7c, 0xe5, 0x55, 0x13, + 0x80, 0x73, 0xa8, 0x25, 0xe9, 0x52, 0x13, 0x00, 0xef, 0x56, 0x13, 0x80, + 0x18, 0xf5, 0x51, 0x13, 0x00, 0xb7, 0x01, 0xff, 0xe1, 0x57, 0x13, 0x00, + 0xe5, 0x8f, 0x13, 0x80, 0x04, 0xe9, 0x8d, 0x13, 0x40, 0xe5, 0x8e, 0x13, + 0x40, 0xe1, 0x92, 0x2d, 0x40, 0xe1, 0x30, 0x13, 0x80, 0x20, 0xe5, 0x35, + 0x13, 0x80, 0x17, 0xe9, 0x32, 0x13, 0x00, 0xef, 0x36, 0x13, 0x80, 0x0a, + 0xf5, 0x31, 0x13, 0x00, 0x42, 0xa9, 0x01, 0x37, 0x13, 0x40, 0xe1, 0x91, + 0x2d, 0x40, 0xe5, 0x34, 0x13, 0x40, 0xe1, 0x33, 0x13, 0x00, 0x08, 0x24, + 0x1e, 0x01, 0xff, 0xe1, 0xd0, 0x12, 0x80, 0x15, 0xe5, 0xd5, 0x12, 0x80, + 0x0c, 0xe9, 0xd2, 0x12, 0x00, 0xef, 0xd6, 0x12, 0x00, 0xf5, 0xd1, 0x12, + 0x40, 0xe5, 0xd4, 0x12, 0x40, 0xe1, 0xd3, 0x12, 0x40, 0xe5, 0x54, 0x13, + 0x40, 0xe1, 0x53, 0x13, 0x40, 0xe1, 0x90, 0x12, 0x80, 0x4c, 0xe5, 0x95, + 0x12, 0x80, 0x43, 0xe9, 0x92, 0x12, 0x00, 0xef, 0x96, 0x12, 0x80, 0x36, + 0xf5, 0x91, 0x12, 0x00, 0x42, 0xa9, 0x01, 0x97, 0x12, 0x00, 0xb9, 0x01, + 0xff, 0xe1, 0x98, 0x12, 0x80, 0x20, 0xe5, 0x9d, 0x12, 0x80, 0x17, 0xe9, + 0x9a, 0x12, 0x00, 0xef, 0x9e, 0x12, 0x80, 0x0a, 0xf5, 0x99, 0x12, 0x00, + 0x42, 0xa9, 0x01, 0x9f, 0x12, 0x40, 0xe1, 0x89, 0x2d, 0x40, 0xe5, 0x9c, + 0x12, 0x40, 0xe1, 0x9b, 0x12, 0x40, 0xe1, 0x88, 0x2d, 0x40, 0xe5, 0x94, + 0x12, 0x40, 0xe1, 0x93, 0x12, 0x40, 0xe1, 0x18, 0x12, 0x80, 0x33, 0xe5, + 0x1d, 0x12, 0x80, 0x2a, 0xe9, 0x1a, 0x12, 0x00, 0xef, 0x1e, 0x12, 0x80, + 0x1d, 0xf5, 0x19, 0x12, 0x00, 0xb7, 0x06, 0x42, 0xdf, 0x23, 0x59, 0x13, + 0x40, 0xe1, 0x1f, 0x12, 0x00, 0xe5, 0x83, 0x13, 0x80, 0x04, 0xe9, 0x81, + 0x13, 0x40, 0xe5, 0x82, 0x13, 0x40, 0xe1, 0x81, 0x2d, 0x40, 0xe5, 0x1c, + 0x12, 0x40, 0xe1, 0x1b, 0x12, 0x40, 0xe1, 0x08, 0x12, 0x80, 0x20, 0xe5, + 0x0d, 0x12, 0x80, 0x17, 0xe9, 0x0a, 0x12, 0x00, 0xef, 0x0e, 0x12, 0x80, + 0x0a, 0xf5, 0x09, 0x12, 0x00, 0x42, 0xa9, 0x01, 0x0f, 0x12, 0x40, 0xe1, + 0x80, 0x2d, 0x40, 0xe5, 0x0c, 0x12, 0x40, 0xe1, 0x0b, 0x12, 0x40, 0xe1, + 0xa8, 0x12, 0x80, 0x8d, 0x01, 0xe5, 0xad, 0x12, 0x80, 0x83, 0x01, 0xe9, + 0xaa, 0x12, 0x00, 0xef, 0xae, 0x12, 0x80, 0x76, 0xf5, 0xa9, 0x12, 0x00, + 0xb7, 0x5a, 0xb8, 0x21, 0xb9, 0x01, 0xff, 0xe1, 0xc8, 0x2d, 0x80, 0x15, + 0xe5, 0xcd, 0x2d, 0x80, 0x0c, 0xe9, 0xca, 0x2d, 0x00, 0xef, 0xce, 0x2d, + 0x00, 0xf5, 0xc9, 0x2d, 0x40, 0xe5, 0xcc, 0x2d, 0x40, 0xe1, 0xcb, 0x2d, + 0x40, 0xe1, 0xb8, 0x12, 0x80, 0x2e, 0xe5, 0xbd, 0x12, 0x80, 0x25, 0xe9, + 0xba, 0x12, 0x00, 0xef, 0xbe, 0x12, 0x00, 0xf5, 0xb9, 0x12, 0x00, 0xb7, + 0x01, 0xff, 0xe1, 0xc0, 0x12, 0x80, 0x0d, 0xe5, 0xc5, 0x12, 0x80, 0x04, + 0xe9, 0xc2, 0x12, 0x40, 0xe5, 0xc4, 0x12, 0x40, 0xe1, 0xc3, 0x12, 0x40, + 0xe5, 0xbc, 0x12, 0x40, 0xe1, 0xbb, 0x12, 0x40, 0xe1, 0xb0, 0x12, 0x80, + 0x0d, 0xe5, 0xb5, 0x12, 0x80, 0x04, 0xe9, 0xb2, 0x12, 0x40, 0xe5, 0xb4, + 0x12, 0x40, 0xe1, 0xb3, 0x12, 0x40, 0xe1, 0xaf, 0x12, 0x40, 0xe5, 0xac, + 0x12, 0x40, 0xe1, 0xab, 0x12, 0x40, 0xe1, 0x00, 0x13, 0x80, 0x20, 0xe5, + 0x05, 0x13, 0x80, 0x17, 0xe9, 0x02, 0x13, 0x00, 0xef, 0x06, 0x13, 0x80, + 0x0a, 0xf5, 0x01, 0x13, 0x00, 0x42, 0xa9, 0x01, 0x07, 0x13, 0x40, 0xe1, + 0x8e, 0x2d, 0x40, 0xe5, 0x04, 0x13, 0x40, 0xe1, 0x03, 0x13, 0x40, 0xe1, + 0x00, 0x12, 0x80, 0x6e, 0xe5, 0x05, 0x12, 0x80, 0x65, 0xa8, 0x11, 0xe9, + 0x02, 0x12, 0x00, 0xef, 0x06, 0x12, 0x80, 0x04, 0xf5, 0x01, 0x12, 0x40, + 0xe1, 0x07, 0x12, 0x40, 0xe1, 0x10, 0x12, 0x80, 0x49, 0xe5, 0x15, 0x12, + 0x80, 0x40, 0xe9, 0x12, 0x12, 0x00, 0xef, 0x16, 0x12, 0x00, 0xf5, 0x11, + 0x12, 0x00, 0xb7, 0x21, 0xb9, 0x01, 0xff, 0xe1, 0xe0, 0xe7, 0x81, 0x15, + 0xe5, 0xe5, 0xe7, 0x81, 0x0c, 0xe9, 0xe2, 0xe7, 0x01, 0xef, 0xe6, 0xe7, + 0x01, 0xf5, 0xe1, 0xe7, 0x41, 0xe5, 0xe4, 0xe7, 0x41, 0xe1, 0xe3, 0xe7, + 0x41, 0xe1, 0x17, 0x12, 0x00, 0xe5, 0xeb, 0xe7, 0x81, 0x04, 0xe9, 0xe9, + 0xe7, 0x41, 0xe5, 0xea, 0xe7, 0x41, 0xe5, 0x14, 0x12, 0x40, 0xe1, 0x13, + 0x12, 0x40, 0xe5, 0x04, 0x12, 0x40, 0xe1, 0x03, 0x12, 0x40, 0xe1, 0x08, + 0x13, 0x80, 0xb5, 0x02, 0xe5, 0x0d, 0x13, 0x80, 0xab, 0x02, 0xa7, 0xf1, + 0x01, 0xe9, 0x0a, 0x13, 0x00, 0x07, 0x6d, 0x2a, 0xbf, 0x01, 0xef, 0x0e, + 0x13, 0x80, 0xb5, 0x01, 0xf5, 0x09, 0x13, 0x80, 0x39, 0xb7, 0x21, 0xb9, + 0x01, 0xff, 0xe1, 0xd8, 0x2d, 0x80, 0x15, 0xe5, 0xdd, 0x2d, 0x80, 0x0c, + 0xe9, 0xda, 0x2d, 0x00, 0xef, 0xde, 0x2d, 0x00, 0xf5, 0xd9, 0x2d, 0x40, + 0xe5, 0xdc, 0x2d, 0x40, 0xe1, 0xdb, 0x2d, 0x40, 0xe1, 0x10, 0x13, 0x80, + 0x0d, 0xe5, 0x15, 0x13, 0x80, 0x04, 0xe9, 0x12, 0x13, 0x40, 0xe5, 0x14, + 0x13, 0x40, 0xe1, 0x13, 0x13, 0x40, 0x05, 0xf1, 0x61, 0x01, 0xff, 0x02, + 0x20, 0xd8, 0x64, 0x02, 0x26, 0x59, 0x56, 0x02, 0x0f, 0xb9, 0x45, 0x44, + 0x20, 0xf6, 0xe8, 0xe7, 0x01, 0x02, 0xa8, 0x0b, 0x2e, 0x02, 0x30, 0x3a, + 0x20, 0x02, 0x51, 0x02, 0x12, 0x02, 0x0f, 0xf9, 0x01, 0xff, 0xe5, 0xf2, + 0xe7, 0x81, 0x04, 0xe9, 0xf0, 0xe7, 0x41, 0xe5, 0xf1, 0xe7, 0x41, 0x42, + 0x27, 0x01, 0xfe, 0xe7, 0x01, 0xe9, 0xfd, 0xe7, 0x41, 0x42, 0x27, 0x01, + 0xee, 0xe7, 0x01, 0xe9, 0xed, 0xe7, 0x41, 0xe5, 0xf7, 0xe7, 0x81, 0x04, + 0xe9, 0xf5, 0xe7, 0x41, 0xe5, 0xf6, 0xe7, 0x41, 0xe5, 0xfa, 0xe7, 0x81, + 0x04, 0xe9, 0xf8, 0xe7, 0x41, 0xe5, 0xf9, 0xe7, 0x41, 0x42, 0x27, 0x01, + 0xfc, 0xe7, 0x01, 0xe9, 0xfb, 0xe7, 0x41, 0x42, 0x27, 0x01, 0xf4, 0xe7, + 0x01, 0xe9, 0xf3, 0xe7, 0x41, 0xe1, 0x0f, 0x13, 0x40, 0xe1, 0xa0, 0x12, + 0x80, 0x20, 0xe5, 0xa5, 0x12, 0x80, 0x17, 0xe9, 0xa2, 0x12, 0x00, 0xef, + 0xa6, 0x12, 0x80, 0x0a, 0xf5, 0xa1, 0x12, 0x00, 0x42, 0xa9, 0x01, 0xa7, + 0x12, 0x40, 0xe1, 0x8a, 0x2d, 0x40, 0xe5, 0xa4, 0x12, 0x40, 0xe1, 0xa3, + 0x12, 0x40, 0xe1, 0x18, 0x13, 0x80, 0x2e, 0xe5, 0x1d, 0x13, 0x80, 0x25, + 0xe9, 0x1a, 0x13, 0x00, 0xef, 0x1e, 0x13, 0x00, 0xf5, 0x19, 0x13, 0x00, + 0xb7, 0x01, 0xff, 0xe1, 0x93, 0x2d, 0x80, 0x0d, 0xe5, 0x96, 0x2d, 0x80, + 0x04, 0xe9, 0x94, 0x2d, 0x40, 0xe5, 0x95, 0x2d, 0x40, 0xe1, 0x1f, 0x13, + 0x40, 0xe5, 0x1c, 0x13, 0x40, 0xe1, 0x1b, 0x13, 0x40, 0xe5, 0x0c, 0x13, + 0x40, 0xe1, 0x0b, 0x13, 0x40, 0xe1, 0x48, 0x13, 0x80, 0x2e, 0xe5, 0x4d, + 0x13, 0x80, 0x25, 0xe9, 0x4a, 0x13, 0x00, 0xef, 0x4e, 0x13, 0x00, 0xf5, + 0x49, 0x13, 0x00, 0xb7, 0x06, 0x42, 0xdf, 0x23, 0x5a, 0x13, 0x40, 0xe1, + 0x4f, 0x13, 0x00, 0xe5, 0x8b, 0x13, 0x80, 0x04, 0xe9, 0x89, 0x13, 0x40, + 0xe5, 0x8a, 0x13, 0x40, 0xe5, 0x4c, 0x13, 0x40, 0xe1, 0x4b, 0x13, 0x40, + 0xe1, 0xf0, 0x12, 0x80, 0x86, 0x01, 0xa4, 0x3e, 0xe5, 0xf5, 0x12, 0x80, + 0x35, 0xe9, 0xf2, 0x12, 0x00, 0xef, 0xf6, 0x12, 0x80, 0x28, 0xf5, 0xf1, + 0x12, 0x00, 0x42, 0xa9, 0x01, 0xf7, 0x12, 0x00, 0xba, 0x01, 0xff, 0x42, + 0x4e, 0x13, 0x13, 0xab, 0x00, 0xe5, 0x15, 0xab, 0x80, 0x0c, 0xe9, 0x12, + 0xab, 0x00, 0xef, 0x16, 0xab, 0x00, 0xf5, 0x11, 0xab, 0x40, 0xe5, 0x14, + 0xab, 0x40, 0xe1, 0x8c, 0x2d, 0x40, 0xe5, 0xf4, 0x12, 0x40, 0xe1, 0xf8, + 0x12, 0x80, 0x3d, 0xe5, 0xfd, 0x12, 0x80, 0x34, 0xa8, 0x17, 0xe9, 0xfa, + 0x12, 0x00, 0xef, 0xfe, 0x12, 0x80, 0x0a, 0xf5, 0xf9, 0x12, 0x00, 0x42, + 0xa9, 0x01, 0xff, 0x12, 0x40, 0xe1, 0x8d, 0x2d, 0x40, 0x42, 0x4e, 0x13, + 0x0b, 0xab, 0x00, 0xe5, 0x0d, 0xab, 0x80, 0x0c, 0xe9, 0x0a, 0xab, 0x00, + 0xef, 0x0e, 0xab, 0x00, 0xf5, 0x09, 0xab, 0x40, 0xe5, 0x0c, 0xab, 0x40, + 0xe5, 0xfc, 0x12, 0x40, 0xe1, 0xfb, 0x12, 0x40, 0xe1, 0xf3, 0x12, 0x40, + 0xe1, 0x78, 0x12, 0x80, 0xab, 0x01, 0xa3, 0x4b, 0xe5, 0x7d, 0x12, 0x80, + 0x42, 0xa8, 0x17, 0xe9, 0x7a, 0x12, 0x00, 0xef, 0x7e, 0x12, 0x80, 0x0a, + 0xf5, 0x79, 0x12, 0x00, 0x42, 0xa9, 0x01, 0x7f, 0x12, 0x40, 0xe1, 0x87, + 0x2d, 0x40, 0xe1, 0x28, 0x13, 0x80, 0x20, 0xe5, 0x2d, 0x13, 0x80, 0x17, + 0xe9, 0x2a, 0x13, 0x00, 0xef, 0x2e, 0x13, 0x80, 0x0a, 0xf5, 0x29, 0x13, + 0x00, 0x42, 0xa9, 0x01, 0x2f, 0x13, 0x40, 0xe1, 0x90, 0x2d, 0x40, 0xe5, + 0x2c, 0x13, 0x40, 0xe1, 0x2b, 0x13, 0x40, 0xe5, 0x7c, 0x12, 0x40, 0xe1, + 0xa8, 0x2d, 0x80, 0x55, 0xe5, 0xad, 0x2d, 0x80, 0x4c, 0xa8, 0x0c, 0xe9, + 0xaa, 0x2d, 0x00, 0xef, 0xae, 0x2d, 0x00, 0xf5, 0xa9, 0x2d, 0x40, 0xe1, + 0xb8, 0x2d, 0x80, 0x35, 0xe5, 0xbd, 0x2d, 0x80, 0x2c, 0xa8, 0x0c, 0xe9, + 0xba, 0x2d, 0x00, 0xef, 0xbe, 0x2d, 0x00, 0xf5, 0xb9, 0x2d, 0x40, 0xe1, + 0x20, 0xab, 0x80, 0x15, 0xe5, 0x25, 0xab, 0x80, 0x0c, 0xe9, 0x22, 0xab, + 0x00, 0xef, 0x26, 0xab, 0x00, 0xf5, 0x21, 0xab, 0x40, 0xe5, 0x24, 0xab, + 0x40, 0xe1, 0x23, 0xab, 0x40, 0xe5, 0xbc, 0x2d, 0x40, 0xe1, 0xbb, 0x2d, + 0x40, 0xe5, 0xac, 0x2d, 0x40, 0xe1, 0xab, 0x2d, 0x40, 0xe1, 0x7b, 0x12, + 0x40, 0xe1, 0x60, 0x12, 0x80, 0x4e, 0xa2, 0x2e, 0xe5, 0x65, 0x12, 0x80, + 0x25, 0xe9, 0x62, 0x12, 0x00, 0xef, 0x66, 0x12, 0x80, 0x18, 0xf5, 0x61, + 0x12, 0x00, 0xb7, 0x01, 0xff, 0xe1, 0x67, 0x12, 0x00, 0xe5, 0x87, 0x13, + 0x80, 0x04, 0xe9, 0x85, 0x13, 0x40, 0xe5, 0x86, 0x13, 0x40, 0xe1, 0x85, + 0x2d, 0x40, 0xe5, 0x64, 0x12, 0x40, 0xe1, 0x28, 0xab, 0x80, 0x15, 0xe5, + 0x2d, 0xab, 0x80, 0x0c, 0xe9, 0x2a, 0xab, 0x00, 0xef, 0x2e, 0xab, 0x00, + 0xf5, 0x29, 0xab, 0x40, 0xe5, 0x2c, 0xab, 0x40, 0xe1, 0x2b, 0xab, 0x40, + 0xe1, 0x63, 0x12, 0x40, 0x4a, 0x68, 0x28, 0x60, 0x13, 0x00, 0x47, 0x5c, + 0x5c, 0x64, 0x13, 0x40, 0x52, 0x75, 0x4e, 0x68, 0x13, 0x00, 0x4c, 0x38, + 0x99, 0x66, 0x13, 0x40, 0x46, 0x1a, 0xe1, 0x79, 0x13, 0x00, 0xa6, 0x36, + 0x47, 0x3f, 0x12, 0x7b, 0x13, 0x00, 0x46, 0x33, 0x2e, 0x7a, 0x13, 0x00, + 0xb3, 0x1c, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x72, 0x13, 0x80, 0x0c, + 0x45, 0x48, 0x12, 0x74, 0x13, 0x00, 0x45, 0xe8, 0x1e, 0x73, 0x13, 0x40, + 0x49, 0xdd, 0x1e, 0x7c, 0x13, 0x40, 0x46, 0x06, 0x1f, 0x78, 0x13, 0x00, + 0x44, 0x36, 0xe3, 0x77, 0x13, 0x40, 0x44, 0x03, 0x24, 0x76, 0x13, 0x00, + 0x44, 0x3c, 0x54, 0x75, 0x13, 0x40, 0x45, 0x7e, 0x0b, 0x70, 0x13, 0x00, + 0xa6, 0x29, 0x44, 0x6d, 0x2c, 0x71, 0x13, 0x00, 0x43, 0x7a, 0x0b, 0x69, + 0x13, 0x00, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0x6b, 0x13, + 0x00, 0x42, 0x15, 0x02, 0x6a, 0x13, 0x40, 0x44, 0x06, 0x1f, 0x6f, 0x13, + 0x00, 0x42, 0x09, 0x24, 0x6e, 0x13, 0x40, 0x43, 0xf9, 0x05, 0x6d, 0x13, + 0x00, 0x43, 0xf6, 0x06, 0x6c, 0x13, 0x40, 0x43, 0xd7, 0x02, 0x65, 0x13, + 0x00, 0xad, 0x01, 0xff, 0x07, 0x03, 0x17, 0x06, 0x42, 0x6c, 0x00, 0x63, + 0x13, 0x40, 0x0b, 0xad, 0x70, 0x06, 0x51, 0x74, 0x3b, 0x5e, 0x13, 0x40, + 0x55, 0x70, 0x3b, 0x5d, 0x13, 0x00, 0x44, 0xb9, 0x00, 0x5f, 0x13, 0x40, + 0xe1, 0x87, 0x00, 0x00, 0xe3, 0x1b, 0x00, 0x80, 0x0f, 0x06, 0xa2, 0xe6, + 0x01, 0xff, 0x48, 0x9b, 0x21, 0x2e, 0x21, 0x00, 0xf3, 0x59, 0x22, 0x40, + 0x43, 0x81, 0x2b, 0x1b, 0x00, 0x40, 0x03, 0x92, 0x37, 0x42, 0x08, 0xdf, + 0xcc, 0x32, 0x0b, 0x88, 0xa7, 0x01, 0xff, 0x06, 0x0c, 0x03, 0x17, 0x06, + 0xad, 0x02, 0x01, 0xff, 0x46, 0x12, 0x03, 0xf2, 0x29, 0x00, 0x47, 0xcc, + 0x46, 0xf0, 0x29, 0x00, 0x46, 0xfd, 0x05, 0xee, 0x29, 0x40, 0x46, 0x12, + 0x03, 0xf3, 0x29, 0x00, 0x47, 0xcc, 0x46, 0xf1, 0x29, 0x00, 0x46, 0xfd, + 0x05, 0xef, 0x29, 0x40, 0x43, 0x7a, 0x0b, 0xf0, 0x2b, 0x00, 0x43, 0x44, + 0x0a, 0xf1, 0x2b, 0x40, 0x08, 0x2c, 0x0c, 0x04, 0xf2, 0x8c, 0xfa, 0x41, + 0x44, 0xc3, 0x00, 0x2b, 0x23, 0x00, 0x45, 0xc8, 0x00, 0x26, 0x23, 0x40, + 0x02, 0x13, 0x00, 0x1a, 0xa9, 0x01, 0xff, 0x4a, 0x1c, 0xad, 0x5a, 0x22, + 0x00, 0x07, 0x0f, 0x3c, 0x01, 0xff, 0x42, 0x1e, 0x00, 0x4d, 0x22, 0x00, + 0x54, 0x03, 0x49, 0x78, 0x2a, 0x40, 0x80, 0x6d, 0x02, 0x31, 0x01, 0x01, + 0xff, 0x45, 0xb7, 0x3d, 0x55, 0x22, 0x00, 0x44, 0x5a, 0x03, 0x3d, 0x00, + 0x80, 0x06, 0x4d, 0x29, 0x8f, 0x6e, 0x2a, 0x40, 0x80, 0x01, 0xff, 0xa1, + 0x27, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4b, 0xcf, 0x9e, 0xae, 0x2a, 0x00, + 0x49, 0x6d, 0x13, 0x66, 0x2a, 0x00, 0x09, 0x0e, 0xc0, 0x06, 0x61, 0xa1, + 0x0f, 0x77, 0x2a, 0x40, 0x45, 0x5c, 0x00, 0x96, 0x2b, 0x00, 0x45, 0x20, + 0x07, 0xf9, 0x2b, 0x40, 0x05, 0x5d, 0x00, 0x0d, 0x53, 0x8b, 0x3a, 0xe3, + 0x29, 0xc0, 0x00, 0x51, 0x19, 0x5a, 0xe4, 0x29, 0x40, 0x4f, 0x6f, 0x1b, + 0x40, 0x2b, 0x00, 0x49, 0x21, 0x75, 0x71, 0x2a, 0x00, 0x50, 0xb3, 0x02, + 0x71, 0x29, 0x00, 0x4e, 0x9b, 0x40, 0x73, 0x2a, 0x40, 0x4f, 0x0a, 0x6e, + 0xd5, 0x22, 0x00, 0x03, 0x7a, 0x02, 0x01, 0xff, 0x4d, 0x69, 0x85, 0x5d, + 0x22, 0x00, 0x03, 0xc8, 0x07, 0x01, 0xff, 0x4c, 0x87, 0x00, 0xdd, 0x22, + 0x00, 0x49, 0xec, 0x00, 0xdc, 0x22, 0x00, 0x48, 0xa7, 0xcf, 0xde, 0x22, + 0x00, 0x48, 0xef, 0xd0, 0xdf, 0x22, 0x40, 0xec, 0x0a, 0x00, 0x00, 0xed, + 0x19, 0x00, 0x00, 0xf4, 0x04, 0x00, 0x40, 0x80, 0x75, 0x02, 0x06, 0x00, + 0x29, 0xf1, 0x05, 0x00, 0x80, 0x1e, 0x4a, 0x55, 0x47, 0x86, 0x23, 0x00, + 0x46, 0x11, 0x34, 0x09, 0x27, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, + 0x55, 0xc0, 0x3c, 0xe9, 0xf4, 0x01, 0x49, 0x25, 0xc1, 0x84, 0xf5, 0x41, + 0x44, 0x0d, 0xf0, 0x05, 0x00, 0x40, 0x03, 0xf4, 0x01, 0x06, 0x5a, 0xc5, + 0x23, 0x1a, 0xf5, 0x41, 0x4c, 0x10, 0x94, 0x97, 0x00, 0x00, 0x44, 0xef, + 0x05, 0x0a, 0x00, 0x00, 0x46, 0x44, 0x04, 0x19, 0x00, 0x00, 0x03, 0x6d, + 0x0d, 0x1c, 0x4d, 0xfa, 0x8c, 0x87, 0x00, 0x00, 0xb4, 0x01, 0xff, 0x43, + 0xd9, 0x06, 0x03, 0x00, 0x00, 0x4b, 0xf9, 0xa6, 0x04, 0x00, 0xc0, 0x00, + 0x46, 0x32, 0x01, 0x17, 0x00, 0x40, 0x42, 0xf4, 0x01, 0x0e, 0x22, 0x00, + 0x4b, 0x27, 0x7f, 0x97, 0x00, 0x40, 0x44, 0x5d, 0x13, 0x13, 0x20, 0x00, + 0x44, 0x07, 0x0e, 0x00, 0x20, 0x00, 0x45, 0x2d, 0x4f, 0x02, 0x20, 0x40, + 0x80, 0x9c, 0x01, 0x04, 0xbc, 0xf7, 0x61, 0xb0, 0x01, 0xff, 0x4c, 0x40, + 0x94, 0x83, 0x23, 0x00, 0x03, 0x0a, 0x1f, 0x01, 0xff, 0x48, 0xdf, 0xca, + 0xcb, 0xf5, 0x01, 0xae, 0x2f, 0x44, 0xc4, 0xab, 0xcc, 0xf5, 0x81, 0x24, + 0x43, 0x6a, 0x13, 0x05, 0x22, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, + 0x50, 0x6a, 0x67, 0xb4, 0x29, 0x00, 0x47, 0xc2, 0x83, 0xb1, 0x29, 0x00, + 0x51, 0xc8, 0x00, 0xb3, 0x29, 0x00, 0x52, 0xe3, 0x57, 0xb2, 0x29, 0x40, + 0xf3, 0xcd, 0xf5, 0x41, 0x43, 0x01, 0x0f, 0xb9, 0xfa, 0x01, 0x43, 0x78, + 0x29, 0xc5, 0xf5, 0xc1, 0x00, 0x03, 0x9d, 0x0f, 0x01, 0xff, 0xe4, 0xc7, + 0xf5, 0x01, 0x42, 0x00, 0x0a, 0xc6, 0xf5, 0x41, 0x0a, 0x2a, 0xae, 0x1b, + 0x1a, 0x59, 0x22, 0x01, 0xff, 0x43, 0x85, 0xf9, 0xfb, 0xf3, 0x01, 0xd3, + 0xfc, 0xf3, 0x01, 0xd4, 0xfd, 0xf3, 0x01, 0xd5, 0xfe, 0xf3, 0x01, 0xd6, + 0xff, 0xf3, 0x41, 0x44, 0x0c, 0xf5, 0xb2, 0xf9, 0x01, 0x4a, 0x5c, 0xae, + 0xb1, 0xf9, 0x01, 0x48, 0x17, 0xd0, 0xb0, 0xf9, 0x01, 0x4a, 0x10, 0xb9, + 0xb3, 0xf9, 0x41, 0x44, 0x5d, 0x13, 0x14, 0x20, 0x00, 0x44, 0x07, 0x0e, + 0x01, 0x20, 0x00, 0x45, 0x2d, 0x4f, 0x03, 0x20, 0x40, 0x0d, 0x28, 0x85, + 0x96, 0x02, 0xa5, 0xa0, 0x01, 0xe6, 0xdd, 0xf9, 0x01, 0x07, 0xd5, 0xdd, + 0x01, 0xff, 0x06, 0x14, 0x06, 0x06, 0x52, 0xef, 0x54, 0xf6, 0x0f, 0x41, + 0xa1, 0x7f, 0x44, 0x20, 0xf5, 0xe1, 0x0f, 0x01, 0x46, 0x6d, 0x4c, 0xe3, + 0x0f, 0x01, 0x45, 0x5a, 0xb0, 0xe2, 0x0f, 0x01, 0x42, 0xb0, 0x01, 0xe4, + 0x0f, 0x81, 0x60, 0x44, 0xb0, 0xf6, 0xea, 0x0f, 0x01, 0x46, 0x8a, 0xe3, + 0xeb, 0x0f, 0x01, 0x43, 0xb4, 0x05, 0xec, 0x0f, 0x01, 0x43, 0x18, 0x24, + 0xed, 0x0f, 0x01, 0x42, 0x6f, 0x02, 0xf0, 0x0f, 0x01, 0x44, 0xf3, 0xcd, + 0xf2, 0x0f, 0x01, 0x44, 0x8a, 0x69, 0xf3, 0x0f, 0x01, 0xb3, 0x20, 0xb4, + 0x12, 0x43, 0x1c, 0x8f, 0xe5, 0x0f, 0x01, 0x44, 0xfd, 0x54, 0xe9, 0x0f, + 0x01, 0x45, 0xf7, 0x54, 0xe6, 0x0f, 0x41, 0x42, 0x3e, 0x2f, 0xf5, 0x0f, + 0x01, 0x43, 0x48, 0x27, 0xe8, 0x0f, 0x41, 0xa1, 0x06, 0x43, 0x48, 0x17, + 0xf4, 0x0f, 0x41, 0x43, 0x95, 0xf0, 0xf1, 0x0f, 0x01, 0x44, 0x4a, 0xea, + 0xee, 0x0f, 0x41, 0x42, 0x53, 0x00, 0xe7, 0x0f, 0x41, 0x44, 0x3b, 0x3f, + 0xe0, 0x0f, 0x01, 0x43, 0xa0, 0x1b, 0xef, 0x0f, 0x41, 0x05, 0x61, 0xeb, + 0x4f, 0x47, 0x21, 0x97, 0x08, 0x22, 0x80, 0x0c, 0x45, 0x42, 0xcb, 0x18, + 0xf4, 0x01, 0x45, 0xfb, 0xf1, 0xd7, 0xf6, 0x41, 0x80, 0x01, 0xff, 0x08, + 0x6c, 0x79, 0x29, 0x05, 0x51, 0x00, 0x01, 0xff, 0x49, 0x77, 0x1f, 0xf5, + 0x22, 0x00, 0x56, 0x71, 0x37, 0xf2, 0x22, 0x00, 0x47, 0xc2, 0x83, 0xf6, + 0x22, 0x00, 0x56, 0x16, 0x0c, 0xf9, 0x22, 0x00, 0x48, 0x64, 0x5c, 0xf8, + 0x22, 0x00, 0x68, 0x30, 0x05, 0xf3, 0x22, 0x40, 0x49, 0xa5, 0x01, 0xd9, + 0x2a, 0x00, 0x47, 0x50, 0x02, 0xd2, 0x27, 0x40, 0x80, 0x06, 0x4f, 0x37, + 0x3e, 0xe7, 0x23, 0x40, 0x45, 0xce, 0x00, 0x01, 0x23, 0x00, 0x4a, 0x8a, + 0xb2, 0xa1, 0xf4, 0x01, 0x44, 0x0c, 0xf8, 0x0c, 0xf5, 0x01, 0x45, 0x4c, + 0xf1, 0x26, 0xf5, 0x41, 0xe1, 0x00, 0x05, 0x01, 0x42, 0xb7, 0x05, 0x01, + 0x05, 0x01, 0xa3, 0xcf, 0x01, 0xa4, 0xc2, 0x01, 0xe5, 0x08, 0x05, 0x81, + 0xb8, 0x01, 0x42, 0x2e, 0x1b, 0x09, 0x05, 0x01, 0xa7, 0x99, 0x01, 0x42, + 0xb0, 0x01, 0x0c, 0x05, 0x01, 0xe9, 0x0d, 0x05, 0x01, 0x42, 0xa3, 0x21, + 0x0e, 0x05, 0x01, 0xab, 0x7d, 0xac, 0x71, 0x42, 0x2a, 0x02, 0x12, 0x05, + 0x01, 0xae, 0x55, 0xef, 0x16, 0x05, 0x01, 0x42, 0x6f, 0x02, 0x17, 0x05, + 0x01, 0x42, 0xcd, 0xa7, 0x18, 0x05, 0x01, 0xb2, 0x39, 0xb3, 0x2d, 0xb4, + 0x21, 0xf5, 0x1f, 0x05, 0x01, 0x42, 0x32, 0x00, 0x20, 0x05, 0x01, 0x42, + 0x90, 0x45, 0x21, 0x05, 0x01, 0xf9, 0x22, 0x05, 0x01, 0xba, 0x01, 0xff, + 0xe5, 0x23, 0x05, 0x01, 0x42, 0xb0, 0x01, 0x24, 0x05, 0x41, 0xe5, 0x1d, + 0x05, 0x01, 0x42, 0xb0, 0x01, 0x1e, 0x05, 0x41, 0xe5, 0x1b, 0x05, 0x01, + 0x42, 0xb0, 0x01, 0x1c, 0x05, 0x41, 0xe5, 0x19, 0x05, 0x01, 0x42, 0x88, + 0x00, 0x1a, 0x05, 0x41, 0xe1, 0x14, 0x05, 0x01, 0x42, 0x04, 0x00, 0x05, + 0x05, 0x01, 0xe5, 0x13, 0x05, 0x01, 0x42, 0xa3, 0x21, 0x15, 0x05, 0x41, + 0xe5, 0x10, 0x05, 0x01, 0x42, 0x68, 0x00, 0x11, 0x05, 0x41, 0xe5, 0x0f, + 0x05, 0x01, 0x42, 0xb0, 0x01, 0x27, 0x05, 0x41, 0xe5, 0x0a, 0x05, 0x01, + 0xa8, 0x06, 0x42, 0xa3, 0x21, 0x0b, 0x05, 0x41, 0x44, 0x23, 0x22, 0x26, + 0x05, 0x01, 0xe5, 0x25, 0x05, 0x41, 0xe9, 0x07, 0x05, 0x41, 0xe5, 0x04, + 0x05, 0x01, 0x42, 0xb0, 0x01, 0x06, 0x05, 0x41, 0xe5, 0x02, 0x05, 0x01, + 0x42, 0xb0, 0x01, 0x03, 0x05, 0x41, 0x80, 0x06, 0x46, 0xbe, 0x66, 0x6a, + 0x26, 0x40, 0xb0, 0x1c, 0x05, 0x5a, 0x69, 0x0c, 0x4f, 0xf7, 0x1d, 0x33, + 0x27, 0x00, 0x62, 0xb0, 0x0d, 0x4a, 0x27, 0x40, 0x46, 0xfa, 0xe2, 0x69, + 0xcc, 0x01, 0x47, 0x24, 0xda, 0x6a, 0xcc, 0x41, 0x5f, 0xbf, 0x11, 0x41, + 0x27, 0x00, 0x07, 0x34, 0x08, 0x01, 0xff, 0x4a, 0x92, 0x2d, 0x34, 0x27, + 0x00, 0x4d, 0xf6, 0x13, 0x35, 0x27, 0x00, 0x56, 0xbb, 0x38, 0x37, 0x27, + 0x40, 0x44, 0xcc, 0x5c, 0xc6, 0xce, 0x01, 0xe7, 0x5a, 0xf9, 0x01, 0x11, + 0x99, 0x62, 0x01, 0xff, 0x80, 0x04, 0xcd, 0x02, 0xd8, 0x40, 0xa1, 0xe6, + 0x23, 0xa2, 0x9f, 0x23, 0x02, 0x11, 0xfb, 0xa1, 0x22, 0x02, 0x13, 0xfb, + 0x8e, 0x1f, 0xa5, 0xb1, 0x1d, 0xa6, 0x88, 0x1b, 0x02, 0x3a, 0x5a, 0xeb, + 0x18, 0xa8, 0xa9, 0x18, 0xa9, 0x98, 0x17, 0x03, 0x5a, 0xfa, 0xf3, 0x16, + 0xac, 0xbc, 0x16, 0xad, 0x9f, 0x13, 0xae, 0xe7, 0x0f, 0xaf, 0x93, 0x0d, + 0x02, 0x61, 0xde, 0xd3, 0x0c, 0x03, 0x81, 0xfa, 0xb2, 0x0c, 0x02, 0xb6, + 0xd3, 0x9a, 0x0b, 0x02, 0xfa, 0xe7, 0xaa, 0x09, 0xb4, 0xdd, 0x07, 0x02, + 0xc3, 0xf2, 0x8c, 0x06, 0xb6, 0xaf, 0x03, 0xb7, 0x96, 0x02, 0x03, 0xc6, + 0xfa, 0xde, 0x01, 0x03, 0xd2, 0xfa, 0xb4, 0x01, 0x02, 0x21, 0xfb, 0x01, + 0xff, 0x90, 0x65, 0x91, 0x01, 0xff, 0xd0, 0xf5, 0x33, 0x01, 0xd1, 0xf6, + 0x33, 0x01, 0xd2, 0xf7, 0x33, 0x01, 0xd3, 0xf8, 0x33, 0x01, 0xd4, 0xf9, + 0x33, 0x01, 0xd5, 0xfa, 0x33, 0x81, 0x25, 0xd6, 0x04, 0x34, 0xc1, 0x00, + 0xe1, 0x05, 0x34, 0x01, 0xe2, 0x06, 0x34, 0x01, 0xe3, 0x07, 0x34, 0x01, + 0xe4, 0x08, 0x34, 0x01, 0xe5, 0x09, 0x34, 0x01, 0xe6, 0x0a, 0x34, 0x01, + 0xe7, 0x0b, 0x34, 0x01, 0xe8, 0x0c, 0x34, 0x41, 0xe1, 0xfb, 0x33, 0x01, + 0xe2, 0xfc, 0x33, 0x01, 0xe3, 0xfd, 0x33, 0x01, 0xe4, 0xfe, 0x33, 0x01, + 0xe5, 0xff, 0x33, 0x01, 0xe6, 0x00, 0x34, 0x01, 0xe7, 0x01, 0x34, 0x01, + 0xe8, 0x02, 0x34, 0x01, 0xe9, 0x03, 0x34, 0x41, 0xd1, 0xe4, 0x33, 0x01, + 0xd2, 0xe5, 0x33, 0x81, 0x2f, 0xd3, 0xea, 0x33, 0x81, 0x22, 0xd4, 0xed, + 0x33, 0x81, 0x19, 0xd5, 0xef, 0x33, 0x81, 0x10, 0xd6, 0xf1, 0x33, 0x01, + 0xd7, 0xf2, 0x33, 0x01, 0xd8, 0xf3, 0x33, 0x01, 0xd9, 0xf4, 0x33, 0x41, + 0xe1, 0xf0, 0x33, 0x41, 0xe1, 0xee, 0x33, 0x41, 0xe1, 0xeb, 0x33, 0x01, + 0xe2, 0xec, 0x33, 0x41, 0xe1, 0xe6, 0x33, 0x01, 0xe2, 0xe7, 0x33, 0x01, + 0xe3, 0xe8, 0x33, 0x01, 0xe4, 0xe9, 0x33, 0x41, 0xd1, 0xdb, 0x33, 0x81, + 0x1c, 0xd2, 0xdd, 0x33, 0x01, 0xd3, 0xde, 0x33, 0x01, 0xd4, 0xdf, 0x33, + 0x01, 0xd5, 0xe0, 0x33, 0x01, 0xd6, 0xe1, 0x33, 0x01, 0xd7, 0xe2, 0x33, + 0x01, 0xd8, 0xe3, 0x33, 0x41, 0xe1, 0xdc, 0x33, 0x41, 0xd1, 0xcf, 0x33, + 0x01, 0xd2, 0xd0, 0x33, 0x01, 0xd3, 0xd1, 0x33, 0x01, 0xd4, 0xd2, 0x33, + 0x81, 0x1a, 0xd5, 0xd5, 0x33, 0x01, 0xd6, 0xd6, 0x33, 0x81, 0x0d, 0xd7, + 0xd8, 0x33, 0x01, 0xd8, 0xd9, 0x33, 0xc1, 0x00, 0xe1, 0xda, 0x33, 0x41, + 0xe1, 0xd7, 0x33, 0x41, 0xe1, 0xd3, 0x33, 0x01, 0xe2, 0xd4, 0x33, 0x41, + 0x90, 0x06, 0x4d, 0x0d, 0x88, 0x46, 0x34, 0x41, 0x90, 0x5e, 0x91, 0x20, + 0x92, 0x01, 0xff, 0xd0, 0xc8, 0x33, 0x01, 0xd1, 0xc9, 0x33, 0x01, 0xd2, + 0xca, 0x33, 0x01, 0xd3, 0xcb, 0x33, 0x01, 0xd4, 0xcc, 0x33, 0x81, 0x04, + 0xd5, 0xce, 0x33, 0x41, 0xe1, 0xcd, 0x33, 0x41, 0xd0, 0xba, 0x33, 0x81, + 0x33, 0xd1, 0xbc, 0x33, 0x01, 0xd2, 0xbd, 0x33, 0x01, 0xd3, 0xbe, 0x33, + 0x01, 0xd4, 0xbf, 0x33, 0x81, 0x1e, 0xd5, 0xc1, 0x33, 0x01, 0xd6, 0xc2, + 0x33, 0x01, 0xd7, 0xc3, 0x33, 0x81, 0x0d, 0xd8, 0xc5, 0x33, 0x81, 0x04, + 0xd9, 0xc7, 0x33, 0x41, 0xe1, 0xc6, 0x33, 0x41, 0xe1, 0xc4, 0x33, 0x41, + 0xe1, 0xc0, 0x33, 0x41, 0xe1, 0xbb, 0x33, 0x41, 0xd1, 0xaf, 0x33, 0x01, + 0xd2, 0xb0, 0x33, 0x01, 0xd3, 0xb1, 0x33, 0x81, 0x1d, 0xd4, 0xb3, 0x33, + 0x01, 0xd5, 0xb4, 0x33, 0x01, 0xd6, 0xb5, 0x33, 0x01, 0xd7, 0xb6, 0x33, + 0x01, 0xd8, 0xb7, 0x33, 0x01, 0xd9, 0xb8, 0x33, 0xc1, 0x00, 0xe1, 0xb9, + 0x33, 0x41, 0xe1, 0xb2, 0x33, 0x41, 0x90, 0x06, 0x4e, 0x18, 0x7b, 0x30, + 0x34, 0x41, 0x90, 0xf8, 0x01, 0x91, 0xb3, 0x01, 0x92, 0x49, 0x93, 0x0b, + 0x42, 0xf7, 0xfa, 0xad, 0x33, 0xc1, 0x00, 0xe1, 0xae, 0x33, 0x41, 0xd0, + 0x9f, 0x33, 0x81, 0x33, 0xd1, 0xa1, 0x33, 0x81, 0x2a, 0xd2, 0xa3, 0x33, + 0x01, 0xd3, 0xa4, 0x33, 0x81, 0x1d, 0xd4, 0xa6, 0x33, 0x01, 0xd5, 0xa7, + 0x33, 0x01, 0xd6, 0xa8, 0x33, 0x01, 0xd7, 0xa9, 0x33, 0x81, 0x08, 0xd8, + 0xab, 0x33, 0x01, 0xd9, 0xac, 0x33, 0x41, 0xe1, 0xaa, 0x33, 0x41, 0xe1, + 0xa5, 0x33, 0x41, 0xe1, 0xa2, 0x33, 0x41, 0xe1, 0xa0, 0x33, 0x41, 0xd0, + 0x86, 0x33, 0x81, 0x33, 0xd1, 0x93, 0x33, 0x01, 0xd2, 0x94, 0x33, 0x01, + 0xd3, 0x95, 0x33, 0x81, 0x22, 0xd4, 0x97, 0x33, 0x01, 0xd5, 0x98, 0x33, + 0x01, 0xd6, 0x99, 0x33, 0x01, 0xd7, 0x9a, 0x33, 0x01, 0xd8, 0x9b, 0x33, + 0x81, 0x09, 0xd9, 0x9d, 0x33, 0xc1, 0x00, 0xe1, 0x9e, 0x33, 0x41, 0xe1, + 0x9c, 0x33, 0x41, 0xe1, 0x96, 0x33, 0x41, 0xe1, 0x87, 0x33, 0x01, 0xe2, + 0x88, 0x33, 0x01, 0xe3, 0x89, 0x33, 0x01, 0xe4, 0x8a, 0x33, 0x01, 0xe5, + 0x8b, 0x33, 0x01, 0xe6, 0x8c, 0x33, 0x01, 0xe7, 0x8d, 0x33, 0x01, 0xe8, + 0x8e, 0x33, 0x01, 0xe9, 0x8f, 0x33, 0x01, 0xea, 0x90, 0x33, 0x01, 0xeb, + 0x91, 0x33, 0x01, 0xec, 0x92, 0x33, 0x41, 0xd0, 0x77, 0x33, 0x01, 0xd1, + 0x78, 0x33, 0x81, 0x29, 0xd2, 0x7c, 0x33, 0x81, 0x1c, 0xd3, 0x7f, 0x33, + 0x01, 0xd4, 0x80, 0x33, 0x01, 0xd5, 0x81, 0x33, 0x01, 0xd6, 0x82, 0x33, + 0x01, 0xd7, 0x83, 0x33, 0x01, 0xd8, 0x84, 0x33, 0x01, 0xd9, 0x85, 0x33, + 0x41, 0xe1, 0x7d, 0x33, 0x01, 0xe2, 0x7e, 0x33, 0x41, 0xe1, 0x79, 0x33, + 0x01, 0xe2, 0x7a, 0x33, 0x01, 0xe3, 0x7b, 0x33, 0x01, 0xe4, 0x2f, 0x34, + 0x41, 0xd1, 0x62, 0x33, 0x81, 0x2e, 0xd2, 0x6c, 0x33, 0x81, 0x25, 0xd3, + 0x6e, 0x33, 0x01, 0xd4, 0x6f, 0x33, 0x01, 0xd5, 0x70, 0x33, 0x01, 0xd6, + 0x71, 0x33, 0x01, 0xd7, 0x72, 0x33, 0x81, 0x08, 0xd8, 0x75, 0x33, 0x01, + 0xd9, 0x76, 0x33, 0x41, 0xe1, 0x73, 0x33, 0x01, 0xe2, 0x74, 0x33, 0x41, + 0xe1, 0x6d, 0x33, 0x41, 0xe1, 0x63, 0x33, 0x01, 0xe2, 0x64, 0x33, 0x01, + 0xe3, 0x65, 0x33, 0x01, 0xe4, 0x66, 0x33, 0x01, 0xe5, 0x67, 0x33, 0x01, + 0xe6, 0x68, 0x33, 0x01, 0xe7, 0x69, 0x33, 0x01, 0xe8, 0x6a, 0x33, 0x01, + 0xe9, 0x6b, 0x33, 0x41, 0x90, 0x9c, 0x01, 0x91, 0x72, 0x92, 0x3e, 0x93, + 0x0f, 0x94, 0x01, 0xff, 0xd0, 0x5f, 0x33, 0x01, 0xd1, 0x60, 0x33, 0x01, + 0xd2, 0x61, 0x33, 0x41, 0xd0, 0x54, 0x33, 0x01, 0xd1, 0x55, 0x33, 0x01, + 0xd2, 0x56, 0x33, 0x81, 0x1c, 0xd3, 0x58, 0x33, 0x01, 0xd4, 0x59, 0x33, + 0x01, 0xd5, 0x5a, 0x33, 0x01, 0xd6, 0x5b, 0x33, 0x01, 0xd7, 0x5c, 0x33, + 0x01, 0xd8, 0x5d, 0x33, 0x01, 0xd9, 0x5e, 0x33, 0x41, 0xe1, 0x57, 0x33, + 0x41, 0xd0, 0x48, 0x33, 0x01, 0xd1, 0x49, 0x33, 0x01, 0xd2, 0x4a, 0x33, + 0x01, 0xd3, 0x4b, 0x33, 0x81, 0x1d, 0xd4, 0x4d, 0x33, 0x01, 0xd5, 0x4e, + 0x33, 0x01, 0xd6, 0x4f, 0x33, 0x01, 0xd7, 0x50, 0x33, 0x01, 0xd8, 0x51, + 0x33, 0x01, 0xd9, 0x52, 0x33, 0xc1, 0x00, 0xe1, 0x53, 0x33, 0x41, 0xe1, + 0x4c, 0x33, 0x41, 0xd0, 0x3e, 0x33, 0x01, 0xd1, 0x3f, 0x33, 0x01, 0xd2, + 0x40, 0x33, 0x01, 0xd3, 0x41, 0x33, 0x01, 0xd4, 0x42, 0x33, 0x01, 0xd5, + 0x43, 0x33, 0x01, 0xd6, 0x44, 0x33, 0x01, 0xd7, 0x45, 0x33, 0x01, 0xd8, + 0x46, 0x33, 0x01, 0xd9, 0x47, 0x33, 0x41, 0xd1, 0x33, 0x33, 0x01, 0xd2, + 0x34, 0x33, 0x01, 0xd3, 0x35, 0x33, 0x01, 0xd4, 0x36, 0x33, 0x01, 0xd5, + 0x37, 0x33, 0x01, 0xd6, 0x38, 0x33, 0x81, 0x0c, 0xd7, 0x3b, 0x33, 0x01, + 0xd8, 0x3c, 0x33, 0x01, 0xd9, 0x3d, 0x33, 0x41, 0xe1, 0x39, 0x33, 0x01, + 0xe2, 0x3a, 0x33, 0x41, 0x90, 0x06, 0x4d, 0x4b, 0x84, 0x45, 0x34, 0x41, + 0x90, 0x87, 0x01, 0x91, 0x53, 0x92, 0x29, 0x93, 0x01, 0xff, 0xd0, 0x2a, + 0x33, 0x01, 0xd1, 0x2b, 0x33, 0x01, 0xd2, 0x2c, 0x33, 0x81, 0x15, 0xd3, + 0x2e, 0x33, 0x81, 0x0c, 0xd4, 0x30, 0x33, 0x01, 0xd5, 0x31, 0x33, 0x01, + 0xd6, 0x32, 0x33, 0x41, 0xe1, 0x2f, 0x33, 0x41, 0xe1, 0x2d, 0x33, 0x41, + 0xd0, 0x20, 0x33, 0x01, 0xd1, 0x21, 0x33, 0x01, 0xd2, 0x22, 0x33, 0x01, + 0xd3, 0x23, 0x33, 0x01, 0xd4, 0x24, 0x33, 0x01, 0xd5, 0x25, 0x33, 0x01, + 0xd6, 0x26, 0x33, 0x01, 0xd7, 0x27, 0x33, 0x01, 0xd8, 0x28, 0x33, 0x01, + 0xd9, 0x29, 0x33, 0x41, 0xd0, 0x14, 0x33, 0x01, 0xd1, 0x15, 0x33, 0x81, + 0x25, 0xd2, 0x17, 0x33, 0x01, 0xd3, 0x18, 0x33, 0x01, 0xd4, 0x19, 0x33, + 0x01, 0xd5, 0x1a, 0x33, 0x01, 0xd6, 0x1b, 0x33, 0x81, 0x0c, 0xd7, 0x1d, + 0x33, 0x01, 0xd8, 0x1e, 0x33, 0x01, 0xd9, 0x1f, 0x33, 0x41, 0xe1, 0x1c, + 0x33, 0x41, 0xe1, 0x16, 0x33, 0x41, 0xd1, 0x07, 0x33, 0x01, 0xd2, 0x08, + 0x33, 0x01, 0xd3, 0x09, 0x33, 0x81, 0x27, 0xd4, 0x0b, 0x33, 0x01, 0xd5, + 0x0c, 0x33, 0x01, 0xd6, 0x0d, 0x33, 0x01, 0xd7, 0x0e, 0x33, 0x81, 0x12, + 0xd8, 0x10, 0x33, 0x81, 0x09, 0xd9, 0x12, 0x33, 0xc1, 0x00, 0xe1, 0x13, + 0x33, 0x41, 0xe1, 0x11, 0x33, 0x41, 0xe1, 0x0f, 0x33, 0x41, 0xe1, 0x0a, + 0x33, 0x41, 0x90, 0xba, 0x01, 0x91, 0x81, 0x01, 0x92, 0x4e, 0x93, 0x1f, + 0x94, 0x01, 0xff, 0xd0, 0x00, 0x33, 0x01, 0xd1, 0x01, 0x33, 0x01, 0xd2, + 0x02, 0x33, 0x01, 0xd3, 0x03, 0x33, 0x01, 0xd4, 0x04, 0x33, 0x01, 0xd5, + 0x05, 0x33, 0x01, 0xd6, 0x06, 0x33, 0x41, 0xd0, 0xf5, 0x32, 0x01, 0xd1, + 0xf6, 0x32, 0x01, 0xd2, 0xf7, 0x32, 0x01, 0xd3, 0xf8, 0x32, 0x01, 0xd4, + 0xf9, 0x32, 0x01, 0xd5, 0xfa, 0x32, 0x81, 0x10, 0xd6, 0xfc, 0x32, 0x01, + 0xd7, 0xfd, 0x32, 0x01, 0xd8, 0xfe, 0x32, 0x01, 0xd9, 0xff, 0x32, 0x41, + 0xe1, 0xfb, 0x32, 0x41, 0xd0, 0xe9, 0x32, 0x01, 0xd1, 0xea, 0x32, 0x01, + 0xd2, 0xeb, 0x32, 0x01, 0xd3, 0xec, 0x32, 0x01, 0xd4, 0xed, 0x32, 0x01, + 0xd5, 0xee, 0x32, 0x01, 0xd6, 0xef, 0x32, 0x81, 0x0c, 0xd7, 0xf2, 0x32, + 0x01, 0xd8, 0xf3, 0x32, 0x01, 0xd9, 0xf4, 0x32, 0x41, 0xe1, 0xf0, 0x32, + 0x01, 0xe2, 0xf1, 0x32, 0x41, 0xd0, 0xdc, 0x32, 0x01, 0xd1, 0xdd, 0x32, + 0x01, 0xd2, 0xde, 0x32, 0x01, 0xd3, 0xdf, 0x32, 0x01, 0xd4, 0xe0, 0x32, + 0x81, 0x19, 0xd5, 0xe3, 0x32, 0x01, 0xd6, 0xe4, 0x32, 0x01, 0xd7, 0xe5, + 0x32, 0x81, 0x08, 0xd8, 0xe7, 0x32, 0x01, 0xd9, 0xe8, 0x32, 0x41, 0xe1, + 0xe6, 0x32, 0x41, 0xe1, 0xe1, 0x32, 0x01, 0xe2, 0xe2, 0x32, 0x41, 0xd1, + 0xd1, 0x32, 0x01, 0xd2, 0xd2, 0x32, 0x81, 0x21, 0xd3, 0xd4, 0x32, 0x01, + 0xd4, 0xd5, 0x32, 0x01, 0xd5, 0xd6, 0x32, 0x01, 0xd6, 0xd7, 0x32, 0x81, + 0x0c, 0xd7, 0xd9, 0x32, 0x01, 0xd8, 0xda, 0x32, 0x01, 0xd9, 0xdb, 0x32, + 0x41, 0xe1, 0xd8, 0x32, 0x41, 0xe1, 0xd3, 0x32, 0x41, 0x90, 0x5f, 0x91, + 0x2b, 0x92, 0x01, 0xff, 0xd0, 0xc7, 0x32, 0x01, 0xd1, 0xc8, 0x32, 0x01, + 0xd2, 0xc9, 0x32, 0x01, 0xd3, 0xca, 0x32, 0x01, 0xd4, 0xcb, 0x32, 0x01, + 0xd5, 0xcc, 0x32, 0x01, 0xd6, 0xcd, 0x32, 0x01, 0xd7, 0xce, 0x32, 0x01, + 0xd8, 0xcf, 0x32, 0x01, 0xd9, 0xd0, 0x32, 0x41, 0xd0, 0xbb, 0x32, 0x81, + 0x29, 0xd1, 0xbd, 0x32, 0x01, 0xd2, 0xbe, 0x32, 0x01, 0xd3, 0xbf, 0x32, + 0x01, 0xd4, 0xc0, 0x32, 0x01, 0xd5, 0xc1, 0x32, 0x01, 0xd6, 0xc2, 0x32, + 0x81, 0x0c, 0xd7, 0xc4, 0x32, 0x01, 0xd8, 0xc5, 0x32, 0x01, 0xd9, 0xc6, + 0x32, 0x41, 0xe1, 0xc3, 0x32, 0x41, 0xe1, 0xbc, 0x32, 0x41, 0xd1, 0xaf, + 0x32, 0x01, 0xd2, 0xb0, 0x32, 0x81, 0x25, 0xd3, 0xb2, 0x32, 0x81, 0x18, + 0xd4, 0xb5, 0x32, 0x01, 0xd5, 0xb6, 0x32, 0x01, 0xd6, 0xb7, 0x32, 0x01, + 0xd7, 0xb8, 0x32, 0x01, 0xd8, 0xb9, 0x32, 0x01, 0xd9, 0xba, 0x32, 0x41, + 0xe1, 0xb3, 0x32, 0x01, 0xe2, 0xb4, 0x32, 0x41, 0xe1, 0xb1, 0x32, 0x41, + 0xd1, 0xa8, 0x32, 0x01, 0xd2, 0xa9, 0x32, 0x01, 0xd3, 0xaa, 0x32, 0x01, + 0xd4, 0xab, 0x32, 0x01, 0xd5, 0xac, 0x32, 0x01, 0xd6, 0xad, 0x32, 0x01, + 0xd7, 0xae, 0x32, 0x41, 0x90, 0x0b, 0x91, 0x01, 0xff, 0xd0, 0xa6, 0x32, + 0x01, 0xd1, 0xa7, 0x32, 0x41, 0xd1, 0x9b, 0x32, 0x81, 0x25, 0xd2, 0x9d, + 0x32, 0x01, 0xd3, 0x9e, 0x32, 0x81, 0x18, 0xd4, 0xa0, 0x32, 0x01, 0xd5, + 0xa1, 0x32, 0x01, 0xd6, 0xa2, 0x32, 0x01, 0xd7, 0xa3, 0x32, 0x01, 0xd8, + 0xa4, 0x32, 0x01, 0xd9, 0xa5, 0x32, 0x41, 0xe1, 0x9f, 0x32, 0x41, 0xe1, + 0x9c, 0x32, 0x41, 0x90, 0x06, 0x4d, 0xa7, 0x8e, 0x36, 0x34, 0x41, 0x90, + 0xff, 0x01, 0x91, 0xc2, 0x01, 0x92, 0x83, 0x01, 0x93, 0x3e, 0x94, 0x14, + 0x95, 0x01, 0xff, 0xd0, 0x97, 0x32, 0x81, 0x04, 0xd1, 0x9a, 0x32, 0x41, + 0xe1, 0x98, 0x32, 0x01, 0xe2, 0x99, 0x32, 0x41, 0xd0, 0x8d, 0x32, 0x01, + 0xd1, 0x8e, 0x32, 0x01, 0xd2, 0x8f, 0x32, 0x01, 0xd3, 0x90, 0x32, 0x01, + 0xd4, 0x91, 0x32, 0x01, 0xd5, 0x92, 0x32, 0x01, 0xd6, 0x93, 0x32, 0x01, + 0xd7, 0x94, 0x32, 0x01, 0xd8, 0x95, 0x32, 0x01, 0xd9, 0x96, 0x32, 0x41, + 0xd0, 0x7d, 0x32, 0x81, 0x3a, 0xd1, 0x7f, 0x32, 0x01, 0xd2, 0x80, 0x32, + 0x01, 0xd3, 0x81, 0x32, 0x81, 0x29, 0xd4, 0x83, 0x32, 0x01, 0xd5, 0x84, + 0x32, 0x01, 0xd6, 0x85, 0x32, 0x81, 0x0c, 0xd7, 0x8a, 0x32, 0x01, 0xd8, + 0x8b, 0x32, 0x01, 0xd9, 0x8c, 0x32, 0x41, 0xe1, 0x86, 0x32, 0x01, 0xe2, + 0x87, 0x32, 0x01, 0xe3, 0x88, 0x32, 0x01, 0xe4, 0x89, 0x32, 0x41, 0xe1, + 0x82, 0x32, 0x41, 0xe1, 0x7e, 0x32, 0x41, 0xd0, 0x6f, 0x32, 0x81, 0x33, + 0xd1, 0x71, 0x32, 0x01, 0xd2, 0x72, 0x32, 0x01, 0xd3, 0x73, 0x32, 0x01, + 0xd4, 0x74, 0x32, 0x81, 0x1e, 0xd5, 0x76, 0x32, 0x81, 0x15, 0xd6, 0x78, + 0x32, 0x01, 0xd7, 0x79, 0x32, 0x01, 0xd8, 0x7a, 0x32, 0x01, 0xd9, 0x7b, + 0x32, 0xc1, 0x00, 0xe1, 0x7c, 0x32, 0x41, 0xe1, 0x77, 0x32, 0x41, 0xe1, + 0x75, 0x32, 0x41, 0xe1, 0x70, 0x32, 0x41, 0xd0, 0x61, 0x32, 0x81, 0x29, + 0xd1, 0x65, 0x32, 0x01, 0xd2, 0x66, 0x32, 0x01, 0xd3, 0x67, 0x32, 0x01, + 0xd4, 0x68, 0x32, 0x01, 0xd5, 0x69, 0x32, 0x01, 0xd6, 0x6a, 0x32, 0x01, + 0xd7, 0x6b, 0x32, 0x01, 0xd8, 0x6c, 0x32, 0x01, 0xd9, 0x6d, 0x32, 0xc1, + 0x00, 0xe1, 0x6e, 0x32, 0x41, 0xe1, 0x62, 0x32, 0x01, 0xe2, 0x63, 0x32, + 0x01, 0xe3, 0x64, 0x32, 0x41, 0xd1, 0x50, 0x32, 0x81, 0x3e, 0xd2, 0x52, + 0x32, 0x01, 0xd3, 0x53, 0x32, 0x01, 0xd4, 0x54, 0x32, 0x01, 0xd5, 0x55, + 0x32, 0x81, 0x29, 0xd6, 0x57, 0x32, 0x81, 0x0c, 0xd7, 0x5e, 0x32, 0x01, + 0xd8, 0x5f, 0x32, 0x01, 0xd9, 0x60, 0x32, 0x41, 0xe1, 0x58, 0x32, 0x01, + 0xe2, 0x59, 0x32, 0x01, 0xe3, 0x5a, 0x32, 0x01, 0xe4, 0x5b, 0x32, 0x01, + 0xe5, 0x5c, 0x32, 0x01, 0xe6, 0x5d, 0x32, 0x41, 0xe1, 0x56, 0x32, 0x41, + 0xe1, 0x51, 0x32, 0x41, 0x90, 0xdc, 0x01, 0x02, 0x8f, 0x9d, 0x78, 0x02, + 0xc3, 0xf2, 0x01, 0xff, 0x90, 0x4d, 0x91, 0x14, 0x92, 0x01, 0xff, 0xd0, + 0x4c, 0x32, 0x01, 0xd1, 0x4d, 0x32, 0x01, 0xd2, 0x4e, 0x32, 0xc1, 0x00, + 0xe1, 0x4f, 0x32, 0x41, 0xd0, 0x3f, 0x32, 0x81, 0x2e, 0xd1, 0x41, 0x32, + 0x81, 0x25, 0xd2, 0x43, 0x32, 0x01, 0xd3, 0x44, 0x32, 0x01, 0xd4, 0x45, + 0x32, 0x01, 0xd5, 0x46, 0x32, 0x01, 0xd6, 0x47, 0x32, 0x01, 0xd7, 0x48, + 0x32, 0x01, 0xd8, 0x49, 0x32, 0x81, 0x04, 0xd9, 0x4b, 0x32, 0x41, 0xe1, + 0x4a, 0x32, 0x41, 0xe1, 0x42, 0x32, 0x41, 0xe1, 0x40, 0x32, 0x41, 0xd1, + 0x36, 0x32, 0x01, 0xd2, 0x37, 0x32, 0x01, 0xd3, 0x38, 0x32, 0x01, 0xd4, + 0x39, 0x32, 0x01, 0xd5, 0x3a, 0x32, 0x01, 0xd6, 0x3b, 0x32, 0x01, 0xd7, + 0x3c, 0x32, 0x01, 0xd8, 0x3d, 0x32, 0x01, 0xd9, 0x3e, 0x32, 0x41, 0x90, + 0x35, 0x91, 0x06, 0x42, 0xb7, 0xed, 0x35, 0x32, 0x41, 0xd0, 0x2a, 0x32, + 0x01, 0xd1, 0x2b, 0x32, 0x01, 0xd2, 0x2c, 0x32, 0x01, 0xd3, 0x2d, 0x32, + 0x01, 0xd4, 0x2e, 0x32, 0x01, 0xd5, 0x2f, 0x32, 0x01, 0xd6, 0x30, 0x32, + 0x01, 0xd7, 0x31, 0x32, 0x81, 0x08, 0xd8, 0x33, 0x32, 0x01, 0xd9, 0x34, + 0x32, 0x41, 0xe1, 0x32, 0x32, 0x41, 0xd1, 0x20, 0x32, 0x01, 0xd2, 0x21, + 0x32, 0x01, 0xd3, 0x22, 0x32, 0x01, 0xd4, 0x23, 0x32, 0x01, 0xd5, 0x24, + 0x32, 0x81, 0x10, 0xd6, 0x26, 0x32, 0x01, 0xd7, 0x27, 0x32, 0x01, 0xd8, + 0x28, 0x32, 0x01, 0xd9, 0x29, 0x32, 0x41, 0xe1, 0x25, 0x32, 0x41, 0x90, + 0xaf, 0x01, 0x91, 0x7c, 0x92, 0x4d, 0x93, 0x0f, 0x94, 0x01, 0xff, 0xd0, + 0x1d, 0x32, 0x01, 0xd1, 0x1e, 0x32, 0x01, 0xd2, 0x1f, 0x32, 0x41, 0xd0, + 0x0f, 0x32, 0x01, 0xd1, 0x10, 0x32, 0x01, 0xd2, 0x11, 0x32, 0x01, 0xd3, + 0x12, 0x32, 0x81, 0x27, 0xd4, 0x14, 0x32, 0x81, 0x1e, 0xd5, 0x16, 0x32, + 0x81, 0x15, 0xd6, 0x18, 0x32, 0x01, 0xd7, 0x19, 0x32, 0x81, 0x08, 0xd8, + 0x1b, 0x32, 0x01, 0xd9, 0x1c, 0x32, 0x41, 0xe1, 0x1a, 0x32, 0x41, 0xe1, + 0x17, 0x32, 0x41, 0xe1, 0x15, 0x32, 0x41, 0xe1, 0x13, 0x32, 0x41, 0xd0, + 0x04, 0x32, 0x01, 0xd1, 0x05, 0x32, 0x01, 0xd2, 0x06, 0x32, 0x01, 0xd3, + 0x07, 0x32, 0x01, 0xd4, 0x08, 0x32, 0x01, 0xd5, 0x09, 0x32, 0x81, 0x10, + 0xd6, 0x0b, 0x32, 0x01, 0xd7, 0x0c, 0x32, 0x01, 0xd8, 0x0d, 0x32, 0x01, + 0xd9, 0x0e, 0x32, 0x41, 0xe1, 0x0a, 0x32, 0x41, 0xd0, 0xf8, 0x31, 0x01, + 0xd1, 0xf9, 0x31, 0x01, 0xd2, 0xfa, 0x31, 0x01, 0xd3, 0xfb, 0x31, 0x01, + 0xd4, 0xfc, 0x31, 0x01, 0xd5, 0xfd, 0x31, 0x01, 0xd6, 0xfe, 0x31, 0x01, + 0xd7, 0xff, 0x31, 0x01, 0xd8, 0x00, 0x32, 0x81, 0x04, 0xd9, 0x03, 0x32, + 0x41, 0xe1, 0x01, 0x32, 0x01, 0xe2, 0x02, 0x32, 0x41, 0xd1, 0xef, 0x31, + 0x01, 0xd2, 0xf0, 0x31, 0x01, 0xd3, 0xf1, 0x31, 0x01, 0xd4, 0xf2, 0x31, + 0x01, 0xd5, 0xf3, 0x31, 0x01, 0xd6, 0xf4, 0x31, 0x01, 0xd7, 0xf5, 0x31, + 0x01, 0xd8, 0xf6, 0x31, 0x01, 0xd9, 0xf7, 0x31, 0x41, 0x90, 0x76, 0x52, + 0x37, 0x55, 0x40, 0x34, 0x01, 0x4f, 0x22, 0x74, 0x55, 0x34, 0xc1, 0x00, + 0x04, 0x3c, 0x05, 0x01, 0xff, 0x46, 0xfe, 0x0a, 0x50, 0x34, 0x81, 0x41, + 0x43, 0x40, 0x05, 0x52, 0x34, 0x01, 0x45, 0xf7, 0xf0, 0x49, 0x34, 0x81, + 0x23, 0x43, 0x1e, 0x00, 0x4b, 0x34, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x47, + 0x89, 0xd4, 0x53, 0x34, 0x01, 0x43, 0x40, 0x05, 0x4a, 0x34, 0x01, 0x45, + 0xf7, 0xf0, 0x47, 0x34, 0xc1, 0x00, 0x4f, 0x39, 0x6c, 0x4f, 0x34, 0x41, + 0x05, 0x19, 0x00, 0x01, 0xff, 0x46, 0xfe, 0x0a, 0x51, 0x34, 0x01, 0x43, + 0x1e, 0x00, 0x4d, 0x34, 0x41, 0x80, 0x01, 0xff, 0x47, 0x89, 0xd4, 0x54, + 0x34, 0x01, 0x43, 0x40, 0x05, 0x4e, 0x34, 0x01, 0x45, 0xf7, 0xf0, 0x48, + 0x34, 0xc1, 0x00, 0x4c, 0x90, 0x8f, 0x4c, 0x34, 0x41, 0x90, 0xed, 0x01, + 0x91, 0x8d, 0x01, 0x92, 0x54, 0x93, 0x1c, 0x94, 0x01, 0xff, 0xd0, 0xe9, + 0x31, 0x81, 0x10, 0xd1, 0xeb, 0x31, 0x01, 0xd2, 0xec, 0x31, 0x01, 0xd3, + 0xed, 0x31, 0x01, 0xd4, 0xee, 0x31, 0x41, 0xe1, 0xea, 0x31, 0x41, 0xd0, + 0xdc, 0x31, 0x01, 0xd1, 0xdd, 0x31, 0x81, 0x29, 0xd2, 0xdf, 0x31, 0x01, + 0xd3, 0xe0, 0x31, 0x81, 0x18, 0xd4, 0xe3, 0x31, 0x01, 0xd5, 0xe4, 0x31, + 0x01, 0xd6, 0xe5, 0x31, 0x01, 0xd7, 0xe6, 0x31, 0x01, 0xd8, 0xe7, 0x31, + 0x01, 0xd9, 0xe8, 0x31, 0x41, 0xe1, 0xe1, 0x31, 0x01, 0xe2, 0xe2, 0x31, + 0x41, 0xe1, 0xde, 0x31, 0x41, 0xd0, 0xcf, 0x31, 0x01, 0xd1, 0xd0, 0x31, + 0x01, 0xd2, 0xd1, 0x31, 0x81, 0x26, 0xd3, 0xd3, 0x31, 0x01, 0xd4, 0xd4, + 0x31, 0x81, 0x19, 0xd5, 0xd6, 0x31, 0x01, 0xd6, 0xd7, 0x31, 0x01, 0xd7, + 0xd8, 0x31, 0x01, 0xd8, 0xd9, 0x31, 0x81, 0x04, 0xd9, 0xdb, 0x31, 0x41, + 0xe1, 0xda, 0x31, 0x41, 0xe1, 0xd5, 0x31, 0x41, 0xe1, 0xd2, 0x31, 0x41, + 0xd0, 0xb9, 0x31, 0x81, 0x54, 0xd1, 0xbb, 0x31, 0x01, 0xd2, 0xbc, 0x31, + 0x81, 0x2b, 0xd3, 0xc5, 0x31, 0x01, 0xd4, 0xc6, 0x31, 0x01, 0xd5, 0xc7, + 0x31, 0x81, 0x1a, 0xd6, 0xc9, 0x31, 0x81, 0x11, 0xd7, 0xcb, 0x31, 0x81, + 0x08, 0xd8, 0xcd, 0x31, 0x01, 0xd9, 0xce, 0x31, 0x41, 0xe1, 0xcc, 0x31, + 0x41, 0xe1, 0xca, 0x31, 0x41, 0xe1, 0xc8, 0x31, 0x41, 0xe1, 0xbd, 0x31, + 0x01, 0xe2, 0xbe, 0x31, 0x01, 0xe3, 0xbf, 0x31, 0x01, 0xe4, 0xc0, 0x31, + 0x01, 0xe5, 0xc1, 0x31, 0x01, 0xe6, 0xc2, 0x31, 0x01, 0xe7, 0xc3, 0x31, + 0x01, 0xe8, 0xc4, 0x31, 0x41, 0xe1, 0xba, 0x31, 0x41, 0xd1, 0xad, 0x31, + 0x81, 0x25, 0xd2, 0xb0, 0x31, 0x01, 0xd3, 0xb1, 0x31, 0x81, 0x18, 0xd4, + 0xb3, 0x31, 0x01, 0xd5, 0xb4, 0x31, 0x01, 0xd6, 0xb5, 0x31, 0x01, 0xd7, + 0xb6, 0x31, 0x01, 0xd8, 0xb7, 0x31, 0x01, 0xd9, 0xb8, 0x31, 0x41, 0xe1, + 0xb2, 0x31, 0x41, 0xe1, 0xae, 0x31, 0x01, 0xe2, 0xaf, 0x31, 0x41, 0x02, + 0x7a, 0xde, 0x06, 0x48, 0x50, 0x84, 0x43, 0x34, 0x41, 0xd1, 0xa3, 0x31, + 0x01, 0xd2, 0xa4, 0x31, 0x81, 0x1d, 0xd3, 0xa6, 0x31, 0x01, 0xd4, 0xa7, + 0x31, 0x01, 0xd5, 0xa8, 0x31, 0x01, 0xd6, 0xa9, 0x31, 0x81, 0x08, 0xd7, + 0xab, 0x31, 0x01, 0xd8, 0xac, 0x31, 0x41, 0xe1, 0xaa, 0x31, 0x41, 0xe1, + 0xa5, 0x31, 0x41, 0xd1, 0x9b, 0x31, 0x01, 0xd2, 0x9c, 0x31, 0x01, 0xd3, + 0x9d, 0x31, 0x01, 0xd4, 0x9e, 0x31, 0x01, 0xd5, 0x9f, 0x31, 0x01, 0xd6, + 0xa0, 0x31, 0x01, 0xd7, 0xa1, 0x31, 0x01, 0xd8, 0xa2, 0x31, 0x41, 0x90, + 0x37, 0x09, 0x57, 0xc2, 0x01, 0xff, 0x46, 0xfe, 0x0a, 0x3b, 0x34, 0x81, + 0x1c, 0x46, 0x7d, 0x02, 0x39, 0x34, 0x01, 0x43, 0x1e, 0x00, 0x3a, 0x34, + 0xc1, 0x00, 0x80, 0x01, 0xff, 0x43, 0x40, 0x05, 0x34, 0x34, 0x01, 0x45, + 0xf7, 0xf0, 0x32, 0x34, 0x41, 0x80, 0x01, 0xff, 0x43, 0x40, 0x05, 0x35, + 0x34, 0x01, 0x45, 0xf7, 0xf0, 0x33, 0x34, 0x41, 0x90, 0x25, 0x91, 0x01, + 0xff, 0xd0, 0x93, 0x31, 0x81, 0x19, 0xd1, 0x95, 0x31, 0x81, 0x10, 0xd2, + 0x97, 0x31, 0x01, 0xd3, 0x98, 0x31, 0x01, 0xd4, 0x99, 0x31, 0x01, 0xd5, + 0x9a, 0x31, 0x41, 0xe1, 0x96, 0x31, 0x41, 0xe1, 0x94, 0x31, 0x41, 0xd1, + 0x88, 0x31, 0x01, 0xd2, 0x89, 0x31, 0x01, 0xd3, 0x8a, 0x31, 0x01, 0xd4, + 0x8b, 0x31, 0x01, 0xd5, 0x8c, 0x31, 0x81, 0x15, 0xd6, 0x8e, 0x31, 0x01, + 0xd7, 0x8f, 0x31, 0x01, 0xd8, 0x90, 0x31, 0x01, 0xd9, 0x91, 0x31, 0xc1, + 0x00, 0xe1, 0x92, 0x31, 0x41, 0xe1, 0x8d, 0x31, 0x41, 0x02, 0x7a, 0xde, + 0x16, 0x04, 0x23, 0x00, 0x06, 0x50, 0xba, 0x68, 0x31, 0x34, 0x41, 0x45, + 0x15, 0xc6, 0x42, 0x34, 0x01, 0x49, 0x4f, 0x84, 0x44, 0x34, 0x41, 0xd1, + 0x7f, 0x31, 0x01, 0xd2, 0x80, 0x31, 0x01, 0xd3, 0x81, 0x31, 0x01, 0xd4, + 0x82, 0x31, 0x01, 0xd5, 0x83, 0x31, 0x01, 0xd6, 0x84, 0x31, 0x81, 0x08, + 0xd7, 0x86, 0x31, 0x01, 0xd8, 0x87, 0x31, 0x41, 0xe1, 0x85, 0x31, 0x41, + 0x90, 0xe3, 0x01, 0x91, 0xb3, 0x01, 0x92, 0x7f, 0x93, 0x4b, 0x94, 0x17, + 0x95, 0x01, 0xff, 0xd0, 0x7a, 0x31, 0x01, 0xd1, 0x7b, 0x31, 0x01, 0xd2, + 0x7c, 0x31, 0x01, 0xd3, 0x7d, 0x31, 0x01, 0xd4, 0x7e, 0x31, 0x41, 0xd0, + 0x6e, 0x31, 0x01, 0xd1, 0x6f, 0x31, 0x01, 0xd2, 0x70, 0x31, 0x01, 0xd3, + 0x71, 0x31, 0x81, 0x1d, 0xd4, 0x73, 0x31, 0x01, 0xd5, 0x74, 0x31, 0x81, + 0x10, 0xd6, 0x76, 0x31, 0x01, 0xd7, 0x77, 0x31, 0x01, 0xd8, 0x78, 0x31, + 0x01, 0xd9, 0x79, 0x31, 0x41, 0xe1, 0x75, 0x31, 0x41, 0xe1, 0x72, 0x31, + 0x41, 0xd0, 0x62, 0x31, 0x01, 0xd1, 0x63, 0x31, 0x01, 0xd2, 0x64, 0x31, + 0x01, 0xd3, 0x65, 0x31, 0x01, 0xd4, 0x66, 0x31, 0x01, 0xd5, 0x67, 0x31, + 0x01, 0xd6, 0x68, 0x31, 0x81, 0x11, 0xd7, 0x6a, 0x31, 0x81, 0x08, 0xd8, + 0x6c, 0x31, 0x01, 0xd9, 0x6d, 0x31, 0x41, 0xe1, 0x6b, 0x31, 0x41, 0xe1, + 0x69, 0x31, 0x41, 0xd0, 0x56, 0x31, 0x81, 0x29, 0xd1, 0x58, 0x31, 0x01, + 0xd2, 0x59, 0x31, 0x01, 0xd3, 0x5a, 0x31, 0x01, 0xd4, 0x5b, 0x31, 0x01, + 0xd5, 0x5c, 0x31, 0x01, 0xd6, 0x5d, 0x31, 0x81, 0x0c, 0xd7, 0x5f, 0x31, + 0x01, 0xd8, 0x60, 0x31, 0x01, 0xd9, 0x61, 0x31, 0x41, 0xe1, 0x5e, 0x31, + 0x41, 0xe1, 0x57, 0x31, 0x41, 0xd0, 0x4b, 0x31, 0x01, 0xd1, 0x4c, 0x31, + 0x81, 0x20, 0xd2, 0x4e, 0x31, 0x01, 0xd3, 0x4f, 0x31, 0x01, 0xd4, 0x50, + 0x31, 0x01, 0xd5, 0x51, 0x31, 0x01, 0xd6, 0x52, 0x31, 0x01, 0xd7, 0x53, + 0x31, 0x01, 0xd8, 0x54, 0x31, 0x01, 0xd9, 0x55, 0x31, 0x41, 0xe1, 0x4d, + 0x31, 0x41, 0xd1, 0x3f, 0x31, 0x01, 0xd2, 0x40, 0x31, 0x01, 0xd3, 0x41, + 0x31, 0x01, 0xd4, 0x42, 0x31, 0x01, 0xd5, 0x43, 0x31, 0x01, 0xd6, 0x44, + 0x31, 0x81, 0x15, 0xd7, 0x46, 0x31, 0x81, 0x08, 0xd8, 0x49, 0x31, 0x01, + 0xd9, 0x4a, 0x31, 0x41, 0xe1, 0x47, 0x31, 0x01, 0xe2, 0x48, 0x31, 0x41, + 0xe1, 0x45, 0x31, 0x41, 0x90, 0x06, 0x49, 0x11, 0xc6, 0x41, 0x34, 0x41, + 0x90, 0xf2, 0x01, 0x91, 0xc2, 0x01, 0x92, 0x92, 0x01, 0x93, 0x59, 0x94, + 0x20, 0x95, 0x01, 0xff, 0xd0, 0x38, 0x31, 0x01, 0xd1, 0x39, 0x31, 0x81, + 0x08, 0xd2, 0x3d, 0x31, 0x01, 0xd3, 0x3e, 0x31, 0x41, 0xe1, 0x3a, 0x31, + 0x01, 0xe2, 0x3b, 0x31, 0x01, 0xe3, 0x3c, 0x31, 0x41, 0xd0, 0x2b, 0x31, + 0x01, 0xd1, 0x2c, 0x31, 0x01, 0xd2, 0x2d, 0x31, 0x01, 0xd3, 0x2e, 0x31, + 0x01, 0xd4, 0x2f, 0x31, 0x01, 0xd5, 0x30, 0x31, 0x81, 0x1a, 0xd6, 0x32, + 0x31, 0x81, 0x11, 0xd7, 0x34, 0x31, 0x81, 0x08, 0xd8, 0x36, 0x31, 0x01, + 0xd9, 0x37, 0x31, 0x41, 0xe1, 0x35, 0x31, 0x41, 0xe1, 0x33, 0x31, 0x41, + 0xe1, 0x31, 0x31, 0x41, 0xd0, 0x1e, 0x31, 0x01, 0xd1, 0x1f, 0x31, 0x81, + 0x2a, 0xd2, 0x21, 0x31, 0x01, 0xd3, 0x22, 0x31, 0x01, 0xd4, 0x23, 0x31, + 0x01, 0xd5, 0x24, 0x31, 0x01, 0xd6, 0x25, 0x31, 0x01, 0xd7, 0x26, 0x31, + 0x81, 0x0d, 0xd8, 0x28, 0x31, 0x81, 0x04, 0xd9, 0x2a, 0x31, 0x41, 0xe1, + 0x29, 0x31, 0x41, 0xe1, 0x27, 0x31, 0x41, 0xe1, 0x20, 0x31, 0x41, 0xd0, + 0x13, 0x31, 0x01, 0xd1, 0x14, 0x31, 0x81, 0x20, 0xd2, 0x16, 0x31, 0x01, + 0xd3, 0x17, 0x31, 0x01, 0xd4, 0x18, 0x31, 0x01, 0xd5, 0x19, 0x31, 0x01, + 0xd6, 0x1a, 0x31, 0x01, 0xd7, 0x1b, 0x31, 0x01, 0xd8, 0x1c, 0x31, 0x01, + 0xd9, 0x1d, 0x31, 0x41, 0xe1, 0x15, 0x31, 0x41, 0xd0, 0x08, 0x31, 0x01, + 0xd1, 0x09, 0x31, 0x01, 0xd2, 0x0a, 0x31, 0x01, 0xd3, 0x0b, 0x31, 0x81, + 0x18, 0xd4, 0x0d, 0x31, 0x01, 0xd5, 0x0e, 0x31, 0x01, 0xd6, 0x0f, 0x31, + 0x01, 0xd7, 0x10, 0x31, 0x01, 0xd8, 0x11, 0x31, 0x01, 0xd9, 0x12, 0x31, + 0x41, 0xe1, 0x0c, 0x31, 0x41, 0xd1, 0xfe, 0x30, 0x81, 0x20, 0xd2, 0x00, + 0x31, 0x01, 0xd3, 0x01, 0x31, 0x01, 0xd4, 0x02, 0x31, 0x01, 0xd5, 0x03, + 0x31, 0x01, 0xd6, 0x04, 0x31, 0x01, 0xd7, 0x05, 0x31, 0x01, 0xd8, 0x06, + 0x31, 0x01, 0xd9, 0x07, 0x31, 0x41, 0xe1, 0xff, 0x30, 0x41, 0x90, 0x17, + 0x03, 0x1b, 0x00, 0x01, 0xff, 0x49, 0xb1, 0x6b, 0x3d, 0x34, 0x01, 0x47, + 0xa4, 0x31, 0x38, 0x34, 0x01, 0x50, 0xaa, 0x6b, 0x3f, 0x34, 0x41, 0x90, + 0x90, 0x01, 0x91, 0x5c, 0x92, 0x28, 0x93, 0x01, 0xff, 0xd0, 0xf5, 0x30, + 0x01, 0xd1, 0xf6, 0x30, 0x01, 0xd2, 0xf7, 0x30, 0x01, 0xd3, 0xf8, 0x30, + 0x01, 0xd4, 0xf9, 0x30, 0x81, 0x0c, 0xd6, 0xfb, 0x30, 0x01, 0xd7, 0xfc, + 0x30, 0x01, 0xd8, 0xfd, 0x30, 0x41, 0xe1, 0xfa, 0x30, 0x41, 0xd0, 0xe9, + 0x30, 0x81, 0x29, 0xd1, 0xeb, 0x30, 0x01, 0xd2, 0xec, 0x30, 0x01, 0xd3, + 0xed, 0x30, 0x01, 0xd4, 0xee, 0x30, 0x01, 0xd5, 0xef, 0x30, 0x01, 0xd6, + 0xf0, 0x30, 0x01, 0xd7, 0xf1, 0x30, 0x01, 0xd8, 0xf2, 0x30, 0x81, 0x04, + 0xd9, 0xf4, 0x30, 0x41, 0xe1, 0xf3, 0x30, 0x41, 0xe1, 0xea, 0x30, 0x41, + 0xd0, 0xdd, 0x30, 0x01, 0xd1, 0xde, 0x30, 0x01, 0xd2, 0xdf, 0x30, 0x01, + 0xd3, 0xe0, 0x30, 0x01, 0xd4, 0xe1, 0x30, 0x01, 0xd5, 0xe2, 0x30, 0x01, + 0xd6, 0xe3, 0x30, 0x81, 0x11, 0xd7, 0xe5, 0x30, 0x81, 0x08, 0xd8, 0xe7, + 0x30, 0x01, 0xd9, 0xe8, 0x30, 0x41, 0xe1, 0xe6, 0x30, 0x41, 0xe1, 0xe4, + 0x30, 0x41, 0xd1, 0xd2, 0x30, 0x01, 0xd2, 0xd3, 0x30, 0x01, 0xd3, 0xd4, + 0x30, 0x01, 0xd4, 0xd5, 0x30, 0x01, 0xd5, 0xd6, 0x30, 0x01, 0xd6, 0xd7, + 0x30, 0x01, 0xd7, 0xd8, 0x30, 0x01, 0xd8, 0xd9, 0x30, 0x81, 0x09, 0xd9, + 0xdb, 0x30, 0xc1, 0x00, 0xe1, 0xdc, 0x30, 0x41, 0xe1, 0xda, 0x30, 0x41, + 0x90, 0xe2, 0x02, 0x91, 0xb7, 0x02, 0x92, 0x87, 0x02, 0x93, 0xd2, 0x01, + 0x94, 0x9d, 0x01, 0x95, 0x44, 0x96, 0x01, 0xff, 0xd0, 0xc2, 0x30, 0x01, + 0xd1, 0xc3, 0x30, 0x01, 0xd2, 0xc4, 0x30, 0x01, 0xd3, 0xc5, 0x30, 0x01, + 0xd4, 0xc6, 0x30, 0x01, 0xd5, 0xc7, 0x30, 0x01, 0xd6, 0xc8, 0x30, 0x01, + 0xd7, 0xc9, 0x30, 0xc1, 0x00, 0xe1, 0xca, 0x30, 0x01, 0xe2, 0xcb, 0x30, + 0x01, 0xe3, 0xcc, 0x30, 0x01, 0xe4, 0xcd, 0x30, 0x01, 0xe5, 0xce, 0x30, + 0x01, 0xe6, 0xcf, 0x30, 0x01, 0xe7, 0xd0, 0x30, 0x01, 0xe8, 0xd1, 0x30, + 0x41, 0xd0, 0xad, 0x30, 0x81, 0x2e, 0xd1, 0xb7, 0x30, 0x01, 0xd2, 0xb8, + 0x30, 0x81, 0x21, 0xd3, 0xba, 0x30, 0x01, 0xd4, 0xbb, 0x30, 0x81, 0x14, + 0xd5, 0xbd, 0x30, 0x01, 0xd6, 0xbe, 0x30, 0x01, 0xd7, 0xbf, 0x30, 0x01, + 0xd8, 0xc0, 0x30, 0x01, 0xd9, 0xc1, 0x30, 0x41, 0xe1, 0xbc, 0x30, 0x41, + 0xe1, 0xb9, 0x30, 0x41, 0xe1, 0xae, 0x30, 0x01, 0xe2, 0xaf, 0x30, 0x01, + 0xe3, 0xb0, 0x30, 0x01, 0xe4, 0xb1, 0x30, 0x01, 0xe5, 0xb2, 0x30, 0x01, + 0xe6, 0xb3, 0x30, 0x01, 0xe7, 0xb4, 0x30, 0x01, 0xe8, 0xb5, 0x30, 0x01, + 0xe9, 0xb6, 0x30, 0x41, 0xd0, 0xa1, 0x30, 0x01, 0xd1, 0xa2, 0x30, 0x01, + 0xd2, 0xa3, 0x30, 0x01, 0xd3, 0xa4, 0x30, 0x01, 0xd4, 0xa5, 0x30, 0x01, + 0xd5, 0xa6, 0x30, 0x01, 0xd6, 0xa7, 0x30, 0x81, 0x11, 0xd7, 0xa9, 0x30, + 0x01, 0xd8, 0xaa, 0x30, 0x81, 0x04, 0xd9, 0xac, 0x30, 0x41, 0xe1, 0xab, + 0x30, 0x41, 0xe1, 0xa8, 0x30, 0x41, 0xd0, 0x95, 0x30, 0x01, 0xd1, 0x96, + 0x30, 0x81, 0x25, 0xd2, 0x98, 0x30, 0x01, 0xd3, 0x99, 0x30, 0x01, 0xd4, + 0x9a, 0x30, 0x81, 0x14, 0xd5, 0x9c, 0x30, 0x01, 0xd6, 0x9d, 0x30, 0x01, + 0xd7, 0x9e, 0x30, 0x01, 0xd8, 0x9f, 0x30, 0x01, 0xd9, 0xa0, 0x30, 0x41, + 0xe1, 0x9b, 0x30, 0x41, 0xe1, 0x97, 0x30, 0x41, 0xd0, 0x8a, 0x30, 0x01, + 0xd1, 0x8b, 0x30, 0x01, 0xd2, 0x8c, 0x30, 0x01, 0xd3, 0x8d, 0x30, 0x01, + 0xd4, 0x8e, 0x30, 0x01, 0xd5, 0x8f, 0x30, 0x01, 0xd6, 0x90, 0x30, 0x01, + 0xd7, 0x91, 0x30, 0x81, 0x08, 0xd8, 0x93, 0x30, 0x01, 0xd9, 0x94, 0x30, + 0x41, 0xe1, 0x92, 0x30, 0x41, 0xd0, 0x80, 0x30, 0x01, 0xd1, 0x81, 0x30, + 0x01, 0xd2, 0x82, 0x30, 0x01, 0xd3, 0x83, 0x30, 0x01, 0xd4, 0x84, 0x30, + 0x01, 0xd5, 0x85, 0x30, 0x01, 0xd6, 0x86, 0x30, 0x01, 0xd7, 0x87, 0x30, + 0x01, 0xd8, 0x88, 0x30, 0x01, 0xd9, 0x89, 0x30, 0x41, 0xd1, 0x76, 0x30, + 0x01, 0xd2, 0x77, 0x30, 0x01, 0xd3, 0x78, 0x30, 0x01, 0xd4, 0x79, 0x30, + 0x01, 0xd5, 0x7a, 0x30, 0x01, 0xd6, 0x7b, 0x30, 0x01, 0xd7, 0x7c, 0x30, + 0x01, 0xd8, 0x7d, 0x30, 0x81, 0x04, 0xd9, 0x7f, 0x30, 0x41, 0xe1, 0x7e, + 0x30, 0x41, 0x90, 0x46, 0x91, 0x17, 0x92, 0x01, 0xff, 0xd0, 0x71, 0x30, + 0x01, 0xd1, 0x72, 0x30, 0x01, 0xd2, 0x73, 0x30, 0x01, 0xd3, 0x74, 0x30, + 0x01, 0xd4, 0x75, 0x30, 0x41, 0xd0, 0x66, 0x30, 0x81, 0x24, 0xd1, 0x68, + 0x30, 0x01, 0xd2, 0x69, 0x30, 0x01, 0xd3, 0x6a, 0x30, 0x01, 0xd4, 0x6b, + 0x30, 0x01, 0xd5, 0x6c, 0x30, 0x01, 0xd6, 0x6d, 0x30, 0x01, 0xd7, 0x6e, + 0x30, 0x01, 0xd8, 0x6f, 0x30, 0x01, 0xd9, 0x70, 0x30, 0x41, 0xe1, 0x67, + 0x30, 0x41, 0xd1, 0x5a, 0x30, 0x01, 0xd2, 0x5b, 0x30, 0x81, 0x1c, 0xd3, + 0x5f, 0x30, 0x01, 0xd4, 0x60, 0x30, 0x01, 0xd5, 0x61, 0x30, 0x01, 0xd6, + 0x62, 0x30, 0x01, 0xd7, 0x63, 0x30, 0x01, 0xd8, 0x64, 0x30, 0x01, 0xd9, + 0x65, 0x30, 0x41, 0xe1, 0x5c, 0x30, 0x01, 0xe2, 0x5d, 0x30, 0x01, 0xe3, + 0x5e, 0x30, 0x41, 0x02, 0x7a, 0xde, 0x17, 0x05, 0xc1, 0x41, 0x01, 0xff, + 0x49, 0xb1, 0x6b, 0x3c, 0x34, 0x01, 0x47, 0xa4, 0x31, 0x37, 0x34, 0x01, + 0x50, 0xaa, 0x6b, 0x3e, 0x34, 0x41, 0xd1, 0x50, 0x30, 0x01, 0xd2, 0x51, + 0x30, 0x01, 0xd3, 0x52, 0x30, 0x01, 0xd4, 0x53, 0x30, 0x01, 0xd5, 0x54, + 0x30, 0x81, 0x10, 0xd6, 0x56, 0x30, 0x01, 0xd7, 0x57, 0x30, 0x01, 0xd8, + 0x58, 0x30, 0x01, 0xd9, 0x59, 0x30, 0x41, 0xe1, 0x55, 0x30, 0x41, 0x90, + 0x97, 0x01, 0x02, 0xd3, 0xf2, 0x01, 0xff, 0x90, 0x63, 0x91, 0x39, 0x92, + 0x0f, 0x93, 0x01, 0xff, 0xd0, 0x2c, 0x34, 0x01, 0xd1, 0x2d, 0x34, 0x01, + 0xd2, 0x2e, 0x34, 0x41, 0xd0, 0x22, 0x34, 0x01, 0xd1, 0x23, 0x34, 0x01, + 0xd2, 0x24, 0x34, 0x01, 0xd3, 0x25, 0x34, 0x01, 0xd4, 0x26, 0x34, 0x01, + 0xd5, 0x27, 0x34, 0x01, 0xd6, 0x28, 0x34, 0x01, 0xd7, 0x29, 0x34, 0x01, + 0xd8, 0x2a, 0x34, 0x01, 0xd9, 0x2b, 0x34, 0x41, 0xd0, 0x18, 0x34, 0x01, + 0xd1, 0x19, 0x34, 0x01, 0xd2, 0x1a, 0x34, 0x01, 0xd3, 0x1b, 0x34, 0x01, + 0xd4, 0x1c, 0x34, 0x01, 0xd5, 0x1d, 0x34, 0x01, 0xd6, 0x1e, 0x34, 0x01, + 0xd7, 0x1f, 0x34, 0x01, 0xd8, 0x20, 0x34, 0x01, 0xd9, 0x21, 0x34, 0x41, + 0xd1, 0x0d, 0x34, 0x01, 0xd2, 0x0e, 0x34, 0x01, 0xd3, 0x0f, 0x34, 0x01, + 0xd4, 0x10, 0x34, 0x01, 0xd5, 0x11, 0x34, 0x01, 0xd6, 0x12, 0x34, 0x01, + 0xd7, 0x13, 0x34, 0x81, 0x08, 0xd8, 0x16, 0x34, 0x01, 0xd9, 0x17, 0x34, + 0x41, 0xe1, 0x14, 0x34, 0x01, 0xe2, 0x15, 0x34, 0x41, 0x90, 0xa8, 0x02, + 0x91, 0xf3, 0x01, 0x92, 0xc8, 0x01, 0x93, 0x98, 0x01, 0x94, 0x5a, 0x95, + 0x30, 0x96, 0x06, 0x42, 0x19, 0xfa, 0x4f, 0x30, 0x41, 0xd0, 0x45, 0x30, + 0x01, 0xd1, 0x46, 0x30, 0x01, 0xd2, 0x47, 0x30, 0x01, 0xd3, 0x48, 0x30, + 0x01, 0xd4, 0x49, 0x30, 0x01, 0xd5, 0x4a, 0x30, 0x01, 0xd6, 0x4b, 0x30, + 0x01, 0xd7, 0x4c, 0x30, 0x01, 0xd8, 0x4d, 0x30, 0x01, 0xd9, 0x4e, 0x30, + 0x41, 0xd0, 0x3b, 0x30, 0x01, 0xd1, 0x3c, 0x30, 0x01, 0xd2, 0x3d, 0x30, + 0x01, 0xd3, 0x3e, 0x30, 0x01, 0xd4, 0x3f, 0x30, 0x01, 0xd5, 0x40, 0x30, + 0x01, 0xd6, 0x41, 0x30, 0x01, 0xd7, 0x42, 0x30, 0x01, 0xd8, 0x43, 0x30, + 0x01, 0xd9, 0x44, 0x30, 0x41, 0xd0, 0x2d, 0x30, 0x81, 0x33, 0xd1, 0x2f, + 0x30, 0x01, 0xd2, 0x30, 0x30, 0x81, 0x26, 0xd3, 0x32, 0x30, 0x81, 0x1d, + 0xd4, 0x34, 0x30, 0x01, 0xd5, 0x35, 0x30, 0x81, 0x10, 0xd6, 0x37, 0x30, + 0x01, 0xd7, 0x38, 0x30, 0x01, 0xd8, 0x39, 0x30, 0x01, 0xd9, 0x3a, 0x30, + 0x41, 0xe1, 0x36, 0x30, 0x41, 0xe1, 0x33, 0x30, 0x41, 0xe1, 0x31, 0x30, + 0x41, 0xe1, 0x2e, 0x30, 0x41, 0xd0, 0x22, 0x30, 0x01, 0xd1, 0x23, 0x30, + 0x01, 0xd2, 0x24, 0x30, 0x81, 0x1c, 0xd3, 0x26, 0x30, 0x01, 0xd4, 0x27, + 0x30, 0x01, 0xd5, 0x28, 0x30, 0x01, 0xd6, 0x29, 0x30, 0x01, 0xd7, 0x2a, + 0x30, 0x01, 0xd8, 0x2b, 0x30, 0x01, 0xd9, 0x2c, 0x30, 0x41, 0xe1, 0x25, + 0x30, 0x41, 0xd0, 0x18, 0x30, 0x01, 0xd1, 0x19, 0x30, 0x01, 0xd2, 0x1a, + 0x30, 0x01, 0xd3, 0x1b, 0x30, 0x01, 0xd4, 0x1c, 0x30, 0x01, 0xd5, 0x1d, + 0x30, 0x01, 0xd6, 0x1e, 0x30, 0x01, 0xd7, 0x1f, 0x30, 0x01, 0xd8, 0x20, + 0x30, 0x01, 0xd9, 0x21, 0x30, 0x41, 0xd0, 0x0c, 0x30, 0x01, 0xd1, 0x0d, + 0x30, 0x01, 0xd2, 0x0e, 0x30, 0x01, 0xd3, 0x0f, 0x30, 0x01, 0xd4, 0x10, + 0x30, 0x81, 0x19, 0xd5, 0x12, 0x30, 0x01, 0xd6, 0x13, 0x30, 0x01, 0xd7, + 0x14, 0x30, 0x81, 0x08, 0xd8, 0x16, 0x30, 0x01, 0xd9, 0x17, 0x30, 0x41, + 0xe1, 0x15, 0x30, 0x41, 0xe1, 0x11, 0x30, 0x41, 0xd1, 0x00, 0x30, 0x01, + 0xd2, 0x01, 0x30, 0x01, 0xd3, 0x02, 0x30, 0x01, 0xd4, 0x03, 0x30, 0x01, + 0xd5, 0x04, 0x30, 0x81, 0x19, 0xd6, 0x06, 0x30, 0x81, 0x0c, 0xd7, 0x09, + 0x30, 0x01, 0xd8, 0x0a, 0x30, 0x01, 0xd9, 0x0b, 0x30, 0x41, 0xe1, 0x07, + 0x30, 0x01, 0xe2, 0x08, 0x30, 0x41, 0xe1, 0x05, 0x30, 0x41, 0x43, 0x06, + 0x02, 0x85, 0xf9, 0x01, 0xf2, 0x42, 0xf4, 0x81, 0x06, 0x4f, 0x7a, 0x76, + 0x71, 0x26, 0x40, 0x80, 0x2a, 0x42, 0x53, 0x00, 0x41, 0x26, 0xc0, 0x00, + 0x02, 0x86, 0x00, 0x01, 0xff, 0x05, 0x0b, 0x42, 0x06, 0x45, 0x6b, 0x17, + 0xda, 0x23, 0x40, 0xa1, 0x06, 0x4d, 0xc8, 0x86, 0x0d, 0xf3, 0x41, 0x47, + 0x1a, 0xd9, 0x0e, 0xf3, 0x01, 0x4d, 0x21, 0x8d, 0x0f, 0xf3, 0x41, 0x03, + 0xf4, 0x01, 0x06, 0x50, 0xda, 0x6b, 0xbb, 0xf9, 0x41, 0x45, 0x5e, 0xee, + 0x3d, 0xf3, 0x01, 0x44, 0x70, 0xb9, 0x3e, 0xf3, 0x41, 0xa1, 0xf1, 0x31, + 0xa3, 0xda, 0x31, 0xa5, 0x87, 0x24, 0xa9, 0x8e, 0x1a, 0x42, 0x68, 0x00, + 0x10, 0x00, 0x00, 0x4f, 0x9b, 0x73, 0xec, 0xf9, 0x01, 0xaf, 0xb0, 0x07, + 0xb2, 0xe3, 0x06, 0xb5, 0x06, 0x42, 0x1f, 0xfb, 0xc0, 0xf4, 0x41, 0x42, + 0x36, 0x01, 0x86, 0xf9, 0x01, 0x46, 0x02, 0xe4, 0x5f, 0xf9, 0x01, 0x07, + 0xa9, 0xda, 0x01, 0xff, 0x06, 0x76, 0xdf, 0xe3, 0x04, 0x4b, 0x50, 0xa0, + 0x9e, 0xbc, 0x01, 0x07, 0x13, 0x06, 0x12, 0x5d, 0x3b, 0x17, 0x9f, 0xbc, + 0x01, 0x51, 0x8a, 0x60, 0x9c, 0xbc, 0x01, 0x55, 0x86, 0x40, 0x9d, 0xbc, + 0x41, 0xe1, 0x41, 0xbc, 0x81, 0xbb, 0x04, 0xe2, 0x07, 0xbc, 0x01, 0xe4, + 0x08, 0xbc, 0x81, 0xa7, 0x04, 0xe5, 0x47, 0xbc, 0x81, 0x99, 0x04, 0xe6, + 0x04, 0xbc, 0x81, 0x8d, 0x04, 0xe7, 0x0a, 0xbc, 0x81, 0x81, 0x04, 0xe8, + 0x00, 0xbc, 0x81, 0xf7, 0x03, 0xe9, 0x46, 0xbc, 0x81, 0xed, 0x03, 0xea, + 0x1b, 0xbc, 0x81, 0xb6, 0x03, 0xeb, 0x05, 0xbc, 0x81, 0xa0, 0x03, 0xec, + 0x06, 0xbc, 0x81, 0x89, 0x03, 0xed, 0x19, 0xbc, 0x81, 0xeb, 0x02, 0xee, + 0x1a, 0xbc, 0x81, 0xb9, 0x02, 0xef, 0x44, 0xbc, 0x81, 0xa1, 0x02, 0xf0, + 0x02, 0xbc, 0x81, 0x88, 0x02, 0xf2, 0x0b, 0xbc, 0x81, 0xeb, 0x01, 0xf3, + 0x1c, 0xbc, 0x81, 0x68, 0xf4, 0x03, 0xbc, 0x81, 0x53, 0xf5, 0x51, 0xbc, + 0x81, 0x40, 0xf6, 0x09, 0xbc, 0x81, 0x35, 0xf7, 0x38, 0xbc, 0x81, 0x0f, + 0xf8, 0x01, 0xbc, 0x81, 0x06, 0x42, 0x4d, 0x00, 0x50, 0xbc, 0x41, 0xf7, + 0x53, 0xbc, 0x41, 0x42, 0xc7, 0x00, 0x3a, 0xbc, 0x01, 0xe1, 0x5c, 0xbc, + 0x01, 0x42, 0x7e, 0x0b, 0x5f, 0xbc, 0x01, 0xe8, 0x39, 0xbc, 0x01, 0xe9, + 0x5e, 0xbc, 0x01, 0xef, 0x5d, 0xbc, 0xc1, 0x00, 0xf7, 0x60, 0xbc, 0x41, + 0x48, 0xa7, 0xce, 0x6a, 0xbc, 0x41, 0x42, 0xb3, 0x01, 0x54, 0xbc, 0x01, + 0xe8, 0x57, 0xbc, 0x01, 0xe9, 0x4a, 0xbc, 0x41, 0x80, 0x04, 0xe8, 0x11, + 0xbc, 0x41, 0x43, 0x39, 0x0d, 0x37, 0xbc, 0x01, 0xf3, 0x36, 0xbc, 0x41, + 0x80, 0x37, 0x46, 0x88, 0xe2, 0x49, 0xbc, 0x01, 0x05, 0x27, 0xee, 0x01, + 0xff, 0x42, 0x1a, 0x00, 0x68, 0xbc, 0x01, 0x42, 0x44, 0x4e, 0x12, 0xbc, + 0x01, 0xa5, 0x12, 0xea, 0x15, 0xbc, 0x01, 0xaf, 0x04, 0xf5, 0x58, 0xbc, + 0x41, 0xee, 0x69, 0xbc, 0x01, 0xf7, 0x42, 0xbc, 0x41, 0xe5, 0x4e, 0xbc, + 0x01, 0xe8, 0x4c, 0xbc, 0x01, 0xee, 0x67, 0xbc, 0x41, 0xea, 0x20, 0xbc, + 0x81, 0x3a, 0xeb, 0x3f, 0xbc, 0x81, 0x2f, 0xed, 0x3c, 0xbc, 0x01, 0xee, + 0x3b, 0xbc, 0x01, 0xf0, 0x34, 0xbc, 0x81, 0x1c, 0xf3, 0x2a, 0xbc, 0x01, + 0xf4, 0x32, 0xbc, 0x81, 0x0d, 0x48, 0x99, 0x3d, 0x25, 0xbc, 0xc1, 0x00, + 0x46, 0x1f, 0x07, 0x26, 0xbc, 0x41, 0x42, 0xc7, 0x00, 0x33, 0xbc, 0x41, + 0x42, 0xc7, 0x00, 0x35, 0xbc, 0x41, 0x42, 0xc7, 0x00, 0x40, 0xbc, 0x41, + 0x42, 0x99, 0x00, 0x2e, 0xbc, 0x41, 0x42, 0x99, 0x00, 0x10, 0xbc, 0x01, + 0xe8, 0x18, 0xbc, 0x01, 0x08, 0xdf, 0xce, 0x01, 0xff, 0xe9, 0x4d, 0xbc, + 0x01, 0xf5, 0x56, 0xbc, 0x41, 0x42, 0xb3, 0x01, 0x0c, 0xbc, 0x01, 0x07, + 0xb2, 0xd6, 0x01, 0xff, 0xed, 0x66, 0xbc, 0x01, 0xee, 0x65, 0xbc, 0x41, + 0xe1, 0x43, 0xbc, 0x01, 0x42, 0x9b, 0x2a, 0x59, 0xbc, 0x01, 0xf5, 0x5b, + 0xbc, 0x01, 0xf7, 0x5a, 0xbc, 0x41, 0x80, 0x15, 0x05, 0x91, 0x4e, 0x01, + 0xff, 0xe1, 0x64, 0xbc, 0x01, 0xe9, 0x63, 0xbc, 0x01, 0xef, 0x62, 0xbc, + 0x01, 0xf5, 0x61, 0xbc, 0x41, 0xed, 0x1e, 0xbc, 0x81, 0x0a, 0xf3, 0x28, + 0xbc, 0x01, 0x48, 0x99, 0x3d, 0x22, 0xbc, 0x41, 0x42, 0x99, 0x00, 0x2c, + 0xbc, 0x41, 0x80, 0x01, 0xff, 0xee, 0x1d, 0xbc, 0x81, 0x0a, 0xf3, 0x27, + 0xbc, 0x01, 0x48, 0x99, 0x3d, 0x21, 0xbc, 0x41, 0x42, 0x99, 0x00, 0x2b, + 0xbc, 0x41, 0xe8, 0x17, 0xbc, 0x01, 0x04, 0xd8, 0x02, 0x01, 0xff, 0xe9, + 0x4f, 0xbc, 0x01, 0xf5, 0x55, 0xbc, 0x41, 0x80, 0x04, 0xeb, 0x14, 0xbc, + 0x41, 0xed, 0x0f, 0xbc, 0x01, 0x43, 0x39, 0x0d, 0x3d, 0xbc, 0x41, 0x80, + 0x01, 0xff, 0xed, 0x1f, 0xbc, 0x81, 0x23, 0xee, 0x30, 0xbc, 0x81, 0x18, + 0xf3, 0x29, 0xbc, 0x81, 0x0d, 0x48, 0x99, 0x3d, 0x23, 0xbc, 0xc1, 0x00, + 0x52, 0x65, 0x57, 0x24, 0xbc, 0x41, 0x49, 0x98, 0x3d, 0x2f, 0xbc, 0x41, + 0x42, 0x99, 0x00, 0x31, 0xbc, 0x41, 0x42, 0x99, 0x00, 0x2d, 0xbc, 0x41, + 0xe5, 0x48, 0xbc, 0x41, 0xec, 0x16, 0xbc, 0x41, 0x44, 0xa8, 0xf2, 0x3e, + 0xbc, 0x41, 0x42, 0xb3, 0x01, 0x0e, 0xbc, 0x41, 0xe5, 0x4b, 0xbc, 0x01, + 0xf5, 0x52, 0xbc, 0x41, 0x42, 0x99, 0x00, 0x0d, 0xbc, 0x01, 0xe8, 0x13, + 0xbc, 0x41, 0x42, 0x3c, 0x01, 0x45, 0xbc, 0x41, 0x09, 0xf1, 0xbb, 0xad, + 0x01, 0x05, 0xb4, 0x0b, 0x6a, 0xac, 0x16, 0x04, 0xae, 0xba, 0x06, 0x57, + 0x7a, 0x32, 0x72, 0xbc, 0x41, 0x51, 0x80, 0x32, 0x71, 0xbc, 0x01, 0x4f, + 0xc4, 0x77, 0x74, 0xbc, 0x41, 0x55, 0xd5, 0x3c, 0x70, 0xbc, 0x01, 0x03, + 0xd1, 0x00, 0x01, 0xff, 0xa1, 0x39, 0x46, 0x12, 0x03, 0x95, 0xbc, 0x01, + 0x43, 0x48, 0x0a, 0x94, 0xbc, 0x01, 0x45, 0x51, 0x24, 0x92, 0xbc, 0x01, + 0xac, 0x19, 0x4b, 0xdd, 0xa8, 0x91, 0xbc, 0x01, 0x48, 0x32, 0x00, 0x98, + 0xbc, 0x81, 0x06, 0x44, 0x14, 0x5a, 0x97, 0xbc, 0x41, 0x47, 0x8a, 0x32, + 0x73, 0xbc, 0x41, 0x43, 0xf0, 0x05, 0x96, 0xbc, 0x01, 0x49, 0xf0, 0xc2, + 0x93, 0xbc, 0x41, 0x44, 0x1d, 0x3b, 0x90, 0xbc, 0x01, 0x44, 0xcf, 0x00, + 0x99, 0xbc, 0x41, 0x45, 0x1c, 0x3b, 0x80, 0xbc, 0x01, 0x46, 0x12, 0x03, + 0x85, 0xbc, 0x01, 0x43, 0x48, 0x0a, 0x84, 0xbc, 0x01, 0x45, 0x51, 0x24, + 0x82, 0xbc, 0x01, 0xac, 0x19, 0x4b, 0xdd, 0xa8, 0x81, 0xbc, 0x01, 0x48, + 0x32, 0x00, 0x88, 0xbc, 0x81, 0x06, 0x44, 0x14, 0x5a, 0x87, 0xbc, 0x41, + 0x47, 0x8a, 0x32, 0x75, 0xbc, 0x41, 0x43, 0xf0, 0x05, 0x86, 0xbc, 0x01, + 0x49, 0xf0, 0xc2, 0x83, 0xbc, 0x41, 0x46, 0xc2, 0xa4, 0x7a, 0xbc, 0x01, + 0x46, 0x9a, 0xe2, 0x7b, 0xbc, 0x01, 0x54, 0x6f, 0x46, 0x77, 0xbc, 0x01, + 0x46, 0x8b, 0x32, 0x76, 0xbc, 0x01, 0x02, 0x12, 0x00, 0x01, 0xff, 0x42, + 0x62, 0x01, 0x79, 0xbc, 0x01, 0x45, 0xfe, 0xee, 0x78, 0xbc, 0xc1, 0x00, + 0x45, 0x5a, 0x0f, 0x7c, 0xbc, 0x41, 0xa1, 0x2f, 0x43, 0xed, 0x00, 0x57, + 0xf4, 0x01, 0x4d, 0xd0, 0x88, 0xda, 0x26, 0x00, 0xaf, 0x06, 0x52, 0xa9, + 0x58, 0x41, 0xf9, 0x41, 0x4c, 0xb0, 0x96, 0x2a, 0xf4, 0x01, 0x4a, 0x38, + 0xb4, 0x24, 0xf9, 0x01, 0xb0, 0x01, 0xff, 0x49, 0xf0, 0xb9, 0x78, 0xfa, + 0x01, 0x43, 0x13, 0x06, 0xa7, 0xf4, 0x41, 0x49, 0xe5, 0xa6, 0xaf, 0x20, + 0x00, 0x5c, 0xac, 0x18, 0x9b, 0x27, 0x00, 0x43, 0xd4, 0x14, 0x09, 0xf4, + 0xc1, 0x00, 0x45, 0x0b, 0x08, 0x32, 0xf4, 0x41, 0x52, 0xa1, 0x51, 0xaf, + 0xf6, 0x01, 0x46, 0xe1, 0xca, 0xce, 0xf5, 0x81, 0xa9, 0x12, 0x42, 0x3b, + 0x01, 0xa4, 0xf9, 0x01, 0x07, 0x8e, 0x7a, 0xd0, 0x11, 0xe7, 0x15, 0xf4, + 0x81, 0xdc, 0x0e, 0xac, 0xcd, 0x0e, 0x0a, 0x70, 0xb3, 0xe0, 0x0a, 0xae, + 0xd1, 0x0a, 0x42, 0x0c, 0x00, 0xaa, 0xf6, 0x01, 0xb4, 0xef, 0x09, 0xb5, + 0x89, 0x05, 0x4b, 0x11, 0xaa, 0x4a, 0xf5, 0x01, 0x02, 0xa7, 0x01, 0x01, + 0xff, 0x80, 0xdc, 0x04, 0x8d, 0xf1, 0x03, 0x04, 0xa9, 0x01, 0x01, 0xff, + 0x08, 0xbf, 0xc7, 0xcd, 0x03, 0x02, 0x31, 0x01, 0x01, 0xff, 0xa1, 0xcd, + 0x02, 0x06, 0x0c, 0x03, 0xb5, 0x02, 0x50, 0x5a, 0x64, 0x3f, 0xf8, 0x01, + 0xa4, 0xa0, 0x02, 0x51, 0x7d, 0x5c, 0x37, 0xf8, 0x01, 0xa8, 0xc1, 0x01, + 0x4d, 0xcf, 0x8b, 0xca, 0x21, 0x00, 0x4f, 0x4e, 0x75, 0xf1, 0x27, 0x00, + 0x46, 0xa6, 0xe5, 0x6f, 0xf6, 0x01, 0xb3, 0xa0, 0x01, 0xb4, 0x13, 0x4b, + 0xf8, 0x10, 0xe9, 0x21, 0x80, 0x06, 0x4c, 0xad, 0x35, 0xaf, 0x21, 0x40, + 0x5a, 0x03, 0x20, 0x97, 0xf8, 0x41, 0x02, 0x0d, 0x00, 0x11, 0x02, 0x15, + 0x02, 0x01, 0xff, 0x4d, 0x6e, 0x83, 0xa1, 0x21, 0x00, 0x66, 0x1b, 0x06, + 0xef, 0x2b, 0x40, 0x05, 0x04, 0x02, 0x06, 0x49, 0x54, 0x75, 0x0b, 0x29, + 0x40, 0x4a, 0xe0, 0x01, 0x93, 0xf8, 0x01, 0x08, 0x09, 0x02, 0x01, 0xff, + 0x45, 0xce, 0x00, 0x63, 0x2b, 0x80, 0x12, 0x4c, 0x78, 0x92, 0x6d, 0x2b, + 0x00, 0x4d, 0xcf, 0x8b, 0x87, 0x2b, 0x00, 0x4c, 0xad, 0x35, 0x4d, 0x2b, + 0x40, 0x80, 0x01, 0xff, 0x6a, 0x6c, 0x03, 0x83, 0x2b, 0x00, 0x46, 0x9f, + 0x15, 0x73, 0x2b, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4a, 0xb2, 0xad, + 0x2b, 0xf8, 0x01, 0x58, 0x94, 0x29, 0x7d, 0x2b, 0x00, 0x4b, 0x7f, 0x6b, + 0x2f, 0xf8, 0x01, 0x09, 0x6d, 0xc1, 0x12, 0x4c, 0xbc, 0x96, 0x27, 0xf8, + 0x01, 0x4c, 0x28, 0x97, 0x23, 0xf8, 0x01, 0x50, 0x7a, 0x6b, 0x33, 0xf8, + 0x41, 0x49, 0xea, 0x01, 0xa0, 0x2b, 0x00, 0x4a, 0xb3, 0x02, 0xa1, 0x2b, + 0x40, 0x4f, 0xfb, 0x69, 0x53, 0xf8, 0x01, 0x4c, 0xd8, 0x98, 0x3b, 0xf8, + 0x41, 0x11, 0x91, 0x05, 0x11, 0x05, 0x3c, 0x16, 0x01, 0xff, 0x45, 0xce, + 0x00, 0x47, 0xf8, 0x01, 0x50, 0x5a, 0x64, 0x43, 0xf8, 0x41, 0x04, 0xc3, + 0x00, 0x19, 0x05, 0xc8, 0x00, 0x01, 0xff, 0x80, 0x06, 0x45, 0xa9, 0x01, + 0xc2, 0x21, 0x40, 0x48, 0xdf, 0xb9, 0x5d, 0x29, 0x00, 0x46, 0x9f, 0x15, + 0x55, 0x29, 0x40, 0x80, 0x06, 0x45, 0xa9, 0x01, 0xc3, 0x21, 0x40, 0x07, + 0xdb, 0x0a, 0x0c, 0x48, 0xdf, 0xb9, 0x61, 0x29, 0x00, 0x46, 0x9f, 0x15, + 0x59, 0x29, 0x40, 0x61, 0x57, 0x0e, 0x65, 0x29, 0x00, 0x5f, 0xd6, 0x12, + 0x6f, 0x29, 0x40, 0x4b, 0x79, 0x92, 0xe3, 0x21, 0x00, 0x4b, 0xd9, 0x92, + 0xd3, 0x21, 0x40, 0x45, 0xce, 0x00, 0x07, 0x2b, 0x80, 0x06, 0x53, 0x0a, + 0x4b, 0x8b, 0x2b, 0x40, 0x47, 0x9e, 0x15, 0xb3, 0xf8, 0x41, 0x45, 0xea, + 0xee, 0x14, 0x2e, 0x00, 0x44, 0xcf, 0x00, 0x93, 0x21, 0xc0, 0x00, 0x80, + 0x01, 0xff, 0x5a, 0x6b, 0x20, 0xb7, 0xfb, 0x01, 0x48, 0xdf, 0xb9, 0xa7, + 0x21, 0x00, 0x5a, 0xd7, 0x21, 0xf5, 0x21, 0x00, 0x46, 0x9f, 0x15, 0x13, + 0x29, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x50, 0x8a, 0x64, 0xb5, 0x21, + 0x00, 0x4d, 0x46, 0x86, 0xdf, 0x21, 0x00, 0x55, 0xd5, 0x01, 0x17, 0xf8, + 0x01, 0x51, 0x47, 0x05, 0x08, 0x29, 0x00, 0x58, 0x14, 0x2b, 0x0b, 0xf8, + 0x01, 0x59, 0x51, 0x26, 0x07, 0xf8, 0x01, 0x4c, 0xa0, 0x97, 0x9b, 0xf8, + 0x01, 0x06, 0x5d, 0x07, 0x11, 0x04, 0xb5, 0x0c, 0x01, 0xff, 0x49, 0xea, + 0x01, 0xb2, 0x21, 0x00, 0x4a, 0xb3, 0x02, 0xb3, 0x21, 0x40, 0x55, 0xd5, + 0x01, 0x13, 0xf8, 0x01, 0x52, 0x2e, 0x06, 0x03, 0xf8, 0x41, 0x44, 0x5b, + 0x0f, 0x08, 0xf9, 0x81, 0x0d, 0x4c, 0x94, 0x97, 0x09, 0xf9, 0xc1, 0x00, + 0x49, 0x98, 0x3d, 0x0b, 0xf9, 0x41, 0x49, 0x98, 0x3d, 0x0a, 0xf9, 0x41, + 0x17, 0xf6, 0x2f, 0x58, 0x09, 0x9c, 0x01, 0x01, 0xff, 0xa1, 0x45, 0x4b, + 0xc9, 0xa0, 0x7b, 0xcc, 0x01, 0x44, 0xb8, 0xf5, 0xfc, 0xcd, 0x01, 0xb2, + 0x1f, 0xb3, 0x11, 0x0e, 0x46, 0x81, 0x01, 0xff, 0x4f, 0xab, 0x72, 0xe8, + 0x29, 0x00, 0x50, 0xca, 0x69, 0xe9, 0x29, 0x40, 0x51, 0x7b, 0x5e, 0x3d, + 0xf5, 0x01, 0x4b, 0x71, 0x9a, 0x04, 0xcc, 0x41, 0x49, 0x22, 0xbb, 0x9a, + 0xcc, 0x01, 0x4b, 0x90, 0x06, 0x3b, 0xf5, 0x01, 0x44, 0x42, 0xb2, 0x68, + 0xcc, 0x01, 0x4a, 0x24, 0xb4, 0x59, 0xcc, 0x41, 0x47, 0xde, 0x35, 0xf8, + 0xcd, 0x01, 0x4a, 0xa8, 0xb7, 0x63, 0xcc, 0x41, 0x4c, 0x24, 0x92, 0x77, + 0xcc, 0x01, 0x4a, 0xda, 0x2a, 0x73, 0xcc, 0x41, 0x49, 0xe1, 0x01, 0x04, + 0x23, 0x00, 0x49, 0x94, 0xbe, 0x7f, 0x29, 0x00, 0x57, 0x63, 0x32, 0xf1, + 0x22, 0x00, 0x44, 0x18, 0x3b, 0xa4, 0x22, 0xc0, 0x00, 0x52, 0xfb, 0x51, + 0xf1, 0x2a, 0x40, 0x03, 0x3e, 0x01, 0x06, 0x45, 0x97, 0xec, 0x69, 0xf3, + 0x41, 0x80, 0xba, 0x01, 0x8d, 0x17, 0x02, 0x06, 0x00, 0x01, 0xff, 0x4b, + 0x81, 0x28, 0xa2, 0x26, 0x00, 0x49, 0x84, 0x22, 0xa3, 0x26, 0x00, 0x46, + 0x16, 0x08, 0xfc, 0x2b, 0x40, 0x4e, 0xe0, 0x7a, 0xdf, 0x29, 0x00, 0x05, + 0xed, 0x07, 0x66, 0x07, 0xa1, 0x7a, 0x01, 0xff, 0x08, 0x0b, 0x06, 0x36, + 0x07, 0xe6, 0xd7, 0x17, 0x4f, 0x8c, 0x73, 0x40, 0x21, 0x00, 0x06, 0x5d, + 0x07, 0x01, 0xff, 0x45, 0xad, 0x5a, 0x3d, 0x21, 0x00, 0x42, 0x0d, 0x06, + 0x3c, 0x21, 0x40, 0x49, 0x93, 0xbc, 0x45, 0x21, 0x00, 0x06, 0x5d, 0x07, + 0x01, 0xff, 0xe4, 0x46, 0x21, 0x00, 0xe5, 0x47, 0x21, 0x00, 0xe9, 0x48, + 0x21, 0x00, 0xea, 0x49, 0x21, 0x40, 0xe3, 0x02, 0x21, 0x00, 0x45, 0xad, + 0x5a, 0x3e, 0x21, 0x00, 0xe8, 0x0d, 0x21, 0x00, 0xee, 0x15, 0x21, 0x00, + 0xf0, 0x19, 0x21, 0x80, 0x0c, 0xf1, 0x1a, 0x21, 0x00, 0xf2, 0x1d, 0x21, + 0x00, 0xfa, 0x24, 0x21, 0x40, 0xe9, 0x3f, 0x21, 0x40, 0x0c, 0xf4, 0x29, + 0x21, 0x08, 0x9a, 0x00, 0x01, 0xff, 0x0c, 0xf4, 0x29, 0x0c, 0x58, 0x84, + 0x2a, 0xfa, 0x2a, 0x00, 0x55, 0xcd, 0x3e, 0xf9, 0x2a, 0x40, 0x4c, 0x87, + 0x00, 0x9c, 0x2a, 0x00, 0x49, 0xec, 0x00, 0x9b, 0x2a, 0x40, 0x4c, 0x87, + 0x00, 0x9a, 0x2a, 0x00, 0x49, 0xec, 0x00, 0x99, 0x2a, 0x40, 0x4c, 0xa4, + 0x90, 0xdd, 0x02, 0x00, 0xa3, 0xb1, 0x02, 0xa4, 0xa2, 0x02, 0x50, 0xad, + 0x00, 0x3c, 0x20, 0x00, 0xa8, 0x8d, 0x02, 0x04, 0x35, 0x08, 0xfc, 0x01, + 0xac, 0xc8, 0x01, 0x07, 0x60, 0xd9, 0xb0, 0x01, 0x4e, 0xf0, 0x7d, 0x17, + 0x2e, 0x00, 0xb0, 0x8b, 0x01, 0x4d, 0x88, 0x36, 0x47, 0x20, 0x00, 0x5b, + 0x72, 0x1e, 0x96, 0x29, 0x00, 0xb3, 0x3e, 0xb5, 0x30, 0x09, 0x32, 0x00, + 0x06, 0x4d, 0x0f, 0x8f, 0x4c, 0xfe, 0x40, 0x43, 0x16, 0x00, 0xf8, 0x23, + 0x80, 0x06, 0x44, 0xef, 0x05, 0x16, 0x20, 0x40, 0x80, 0x01, 0xff, 0x07, + 0x3b, 0x01, 0x06, 0x4e, 0x88, 0x3c, 0xe3, 0x2a, 0x40, 0x4e, 0x88, 0x3c, + 0xe5, 0x2a, 0x00, 0x4f, 0x56, 0x01, 0xab, 0x22, 0x40, 0x44, 0x38, 0x18, + 0xd3, 0x22, 0x00, 0x46, 0xda, 0xdc, 0xeb, 0x2a, 0x40, 0x4f, 0x4f, 0x74, + 0xfd, 0x2a, 0x00, 0x06, 0x2a, 0x26, 0x29, 0xb4, 0x1b, 0xb5, 0x01, 0xff, + 0x44, 0x69, 0x13, 0xd0, 0x22, 0x00, 0x46, 0xf1, 0xd0, 0xbc, 0x2a, 0x00, + 0x46, 0x21, 0x38, 0xd1, 0x22, 0x00, 0x4d, 0x27, 0x82, 0x44, 0x2e, 0x40, + 0x4b, 0xc7, 0x9d, 0x49, 0x2e, 0x00, 0x4d, 0xb8, 0x76, 0xec, 0x2a, 0x40, + 0x4c, 0xf2, 0x0a, 0x4e, 0x2a, 0x00, 0x45, 0x37, 0x18, 0x4f, 0x2a, 0x40, + 0x43, 0xc7, 0x29, 0xfa, 0x29, 0x00, 0xb2, 0x01, 0xff, 0x46, 0xa9, 0xcf, + 0xbb, 0x2a, 0x00, 0x43, 0x29, 0x02, 0x33, 0x20, 0xc0, 0x00, 0x4f, 0x18, + 0x05, 0x1e, 0x30, 0x40, 0x4c, 0x87, 0x00, 0xa2, 0x2a, 0x00, 0x49, 0xec, + 0x00, 0xa1, 0x2a, 0xc0, 0x00, 0x4e, 0xe1, 0x61, 0xa3, 0x2a, 0x40, 0x5c, + 0x90, 0x18, 0x95, 0x29, 0x00, 0xaf, 0x01, 0xff, 0x06, 0x50, 0x23, 0x18, + 0xb7, 0x01, 0xff, 0x45, 0xee, 0x05, 0x17, 0x20, 0x00, 0x8d, 0x01, 0xff, + 0x50, 0x2f, 0x14, 0x1e, 0x20, 0x00, 0x59, 0x26, 0x14, 0x42, 0x2e, 0x40, + 0x43, 0x1a, 0x00, 0x53, 0x2a, 0x00, 0x42, 0x0c, 0x00, 0x54, 0x2a, 0x40, + 0x44, 0x06, 0x28, 0x2c, 0x22, 0x00, 0x48, 0xf6, 0x0a, 0xd2, 0x22, 0x40, + 0x5d, 0x22, 0x14, 0x1f, 0x20, 0x00, 0x45, 0x8b, 0x66, 0x40, 0x2e, 0x40, + 0x45, 0xc1, 0xe0, 0x21, 0x20, 0x00, 0x48, 0x14, 0x3b, 0xea, 0x2a, 0x40, + 0x05, 0x13, 0x03, 0x0c, 0x4a, 0x42, 0xb4, 0x74, 0x2a, 0x00, 0x49, 0x62, + 0xc6, 0xbf, 0x27, 0x40, 0x5c, 0xcc, 0x17, 0xf2, 0xf7, 0x01, 0x02, 0x06, + 0x00, 0x01, 0xff, 0x06, 0xef, 0x06, 0x06, 0x4a, 0x10, 0xb4, 0xfe, 0x24, + 0x40, 0x45, 0x7e, 0x0b, 0xfc, 0x24, 0x00, 0xa6, 0x29, 0x44, 0x6d, 0x2c, + 0xfd, 0x24, 0x00, 0x43, 0x7a, 0x0b, 0xf5, 0x24, 0x00, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0xf7, 0x24, 0x00, 0x42, 0x15, 0x02, 0xf6, - 0x24, 0x40, 0x44, 0xe5, 0x1d, 0xfb, 0x24, 0x00, 0x42, 0x1c, 0x26, 0xfa, - 0x24, 0x40, 0x43, 0xd2, 0x05, 0xf9, 0x24, 0x00, 0x43, 0xf6, 0x06, 0xf8, + 0x24, 0x40, 0x44, 0x06, 0x1f, 0xfb, 0x24, 0x00, 0x42, 0x09, 0x24, 0xfa, + 0x24, 0x40, 0x43, 0xf9, 0x05, 0xf9, 0x24, 0x00, 0x43, 0xf6, 0x06, 0xf8, 0x24, 0x40, 0x80, 0x3f, 0x04, 0x77, 0x00, 0x01, 0xff, 0xa3, 0x2c, 0x45, - 0x1b, 0x97, 0x99, 0x29, 0x00, 0x49, 0x91, 0xbb, 0xe5, 0xfa, 0x01, 0x46, - 0xbc, 0xde, 0x13, 0x2e, 0x00, 0x54, 0x87, 0x0b, 0x16, 0x2e, 0x00, 0xb3, - 0x06, 0x54, 0x47, 0x46, 0x08, 0x2e, 0x40, 0x46, 0x6b, 0x31, 0x4a, 0x2e, - 0x00, 0x45, 0xd7, 0x05, 0x1a, 0x2b, 0x40, 0x45, 0x13, 0x03, 0xcc, 0x25, - 0x00, 0x44, 0x96, 0x10, 0x5c, 0x20, 0x40, 0x45, 0x5c, 0x00, 0xd9, 0x02, - 0x00, 0x45, 0x93, 0x1f, 0x38, 0x22, 0x00, 0x48, 0x9a, 0x1d, 0xc5, 0x22, - 0x00, 0x44, 0x73, 0x28, 0x14, 0x22, 0x40, 0x46, 0xab, 0xbc, 0xab, 0x20, - 0x00, 0x43, 0x0b, 0x24, 0xcf, 0xfa, 0x41, 0x0a, 0x0b, 0x00, 0xf4, 0x01, - 0x08, 0x32, 0x00, 0x01, 0xff, 0x45, 0x43, 0x0e, 0x62, 0xf0, 0x01, 0x02, - 0x3a, 0x40, 0x01, 0xff, 0x03, 0x9b, 0xf3, 0xc3, 0x01, 0x03, 0xa7, 0xf3, - 0xa2, 0x01, 0x03, 0xb9, 0xf3, 0x81, 0x01, 0x03, 0xcb, 0xf3, 0x61, 0x03, - 0xd7, 0xf3, 0x41, 0x03, 0xdd, 0xf3, 0x21, 0x03, 0xe9, 0xf3, 0x01, 0xff, + 0xf7, 0x9b, 0x99, 0x29, 0x00, 0x49, 0x2e, 0xc1, 0xe5, 0xfa, 0x01, 0x46, + 0x92, 0xe4, 0x13, 0x2e, 0x00, 0x54, 0xf3, 0x0b, 0x16, 0x2e, 0x00, 0xb3, + 0x06, 0x54, 0x77, 0x48, 0x08, 0x2e, 0x40, 0x46, 0x1c, 0x33, 0x4a, 0x2e, + 0x00, 0x45, 0xfe, 0x05, 0x1a, 0x2b, 0x40, 0x45, 0x13, 0x03, 0xcc, 0x25, + 0x00, 0x44, 0x8f, 0x08, 0x5c, 0x20, 0x40, 0x45, 0x5c, 0x00, 0xd9, 0x02, + 0x00, 0x45, 0xb4, 0x20, 0x38, 0x22, 0x00, 0x48, 0xa0, 0x1e, 0xc5, 0x22, + 0x00, 0x44, 0xc6, 0x29, 0x14, 0x22, 0x40, 0x46, 0x48, 0xc2, 0xab, 0x20, + 0x00, 0x43, 0x5e, 0x25, 0xcf, 0xfa, 0x41, 0x0a, 0x0b, 0x00, 0xf4, 0x01, + 0x08, 0x32, 0x00, 0x01, 0xff, 0x45, 0xd1, 0x0e, 0x62, 0xf0, 0x01, 0x02, + 0x42, 0x42, 0x01, 0xff, 0x03, 0x76, 0xf9, 0xc3, 0x01, 0x03, 0x82, 0xf9, + 0xa2, 0x01, 0x03, 0x94, 0xf9, 0x81, 0x01, 0x03, 0xa6, 0xf9, 0x61, 0x03, + 0xb2, 0xf9, 0x41, 0x03, 0xb8, 0xf9, 0x21, 0x03, 0xc4, 0xf9, 0x01, 0xff, 0xd0, 0x8d, 0xf0, 0x01, 0xd1, 0x8e, 0xf0, 0x01, 0xd2, 0x8f, 0xf0, 0x01, 0xd3, 0x90, 0xf0, 0x01, 0xd4, 0x91, 0xf0, 0x01, 0xd5, 0x92, 0xf0, 0x01, 0xd6, 0x93, 0xf0, 0x41, 0xd0, 0x86, 0xf0, 0x01, 0xd1, 0x87, 0xf0, 0x01, @@ -13889,10 +14125,10 @@ static const unsigned char uname2c_tree[222744] = { 0xd4, 0x6e, 0xf0, 0x01, 0xd5, 0x6f, 0xf0, 0x01, 0xd6, 0x70, 0xf0, 0x41, 0xd0, 0x63, 0xf0, 0x01, 0xd1, 0x64, 0xf0, 0x01, 0xd2, 0x65, 0xf0, 0x01, 0xd3, 0x66, 0xf0, 0x01, 0xd4, 0x67, 0xf0, 0x01, 0xd5, 0x68, 0xf0, 0x01, - 0xd6, 0x69, 0xf0, 0x41, 0x45, 0x43, 0x0e, 0x30, 0xf0, 0x01, 0x02, 0x3a, - 0x40, 0x01, 0xff, 0x03, 0x9b, 0xf3, 0xc3, 0x01, 0x03, 0xa7, 0xf3, 0xa2, - 0x01, 0x03, 0xb9, 0xf3, 0x81, 0x01, 0x03, 0xcb, 0xf3, 0x61, 0x03, 0xd7, - 0xf3, 0x41, 0x03, 0xdd, 0xf3, 0x21, 0x03, 0xe9, 0xf3, 0x01, 0xff, 0xd0, + 0xd6, 0x69, 0xf0, 0x41, 0x45, 0xd1, 0x0e, 0x30, 0xf0, 0x01, 0x02, 0x42, + 0x42, 0x01, 0xff, 0x03, 0x76, 0xf9, 0xc3, 0x01, 0x03, 0x82, 0xf9, 0xa2, + 0x01, 0x03, 0x94, 0xf9, 0x81, 0x01, 0x03, 0xa6, 0xf9, 0x61, 0x03, 0xb2, + 0xf9, 0x41, 0x03, 0xb8, 0xf9, 0x21, 0x03, 0xc4, 0xf9, 0x01, 0xff, 0xd0, 0x5b, 0xf0, 0x01, 0xd1, 0x5c, 0xf0, 0x01, 0xd2, 0x5d, 0xf0, 0x01, 0xd3, 0x5e, 0xf0, 0x01, 0xd4, 0x5f, 0xf0, 0x01, 0xd5, 0x60, 0xf0, 0x01, 0xd6, 0x61, 0xf0, 0x41, 0xd0, 0x54, 0xf0, 0x01, 0xd1, 0x55, 0xf0, 0x01, 0xd2, @@ -13909,80 +14145,80 @@ static const unsigned char uname2c_tree[222744] = { 0x3c, 0xf0, 0x01, 0xd5, 0x3d, 0xf0, 0x01, 0xd6, 0x3e, 0xf0, 0x41, 0xd0, 0x31, 0xf0, 0x01, 0xd1, 0x32, 0xf0, 0x01, 0xd2, 0x33, 0xf0, 0x01, 0xd3, 0x34, 0xf0, 0x01, 0xd4, 0x35, 0xf0, 0x01, 0xd5, 0x36, 0xf0, 0x01, 0xd6, - 0x37, 0xf0, 0x41, 0x48, 0x2d, 0x0e, 0x24, 0x00, 0x00, 0x44, 0x35, 0xf2, + 0x37, 0xf0, 0x41, 0x48, 0xbb, 0x0e, 0x24, 0x00, 0x00, 0x44, 0x08, 0xf8, 0x2c, 0xf4, 0x41, 0x45, 0x0b, 0x08, 0x36, 0xf4, 0x01, 0x03, 0x71, 0x00, - 0x01, 0xff, 0x51, 0xe3, 0x57, 0x3b, 0x18, 0x01, 0x07, 0xec, 0x05, 0x59, - 0x05, 0x5a, 0x03, 0x38, 0x0b, 0x55, 0x77, 0x01, 0xff, 0xa1, 0x25, 0xe5, + 0x01, 0xff, 0x51, 0x5d, 0x5a, 0x3b, 0x18, 0x01, 0x07, 0x13, 0x06, 0x59, + 0x05, 0x5a, 0x03, 0x38, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xa1, 0x25, 0xe5, 0x33, 0x18, 0x01, 0xe9, 0x2d, 0x18, 0x81, 0x18, 0xef, 0x35, 0x18, 0x01, - 0xf5, 0x2f, 0x18, 0x81, 0x0b, 0x49, 0x43, 0xc1, 0x31, 0x18, 0xc1, 0x00, + 0xf5, 0x2f, 0x18, 0x81, 0x0b, 0x49, 0xf2, 0xc6, 0x31, 0x18, 0xc1, 0x00, 0xf2, 0x32, 0x18, 0x41, 0xf5, 0x30, 0x18, 0x41, 0xe9, 0x2e, 0x18, 0x41, 0xe1, 0x2c, 0x18, 0x01, 0xe9, 0x34, 0x18, 0x01, 0xf5, 0x36, 0x18, 0x41, - 0x48, 0x3c, 0x16, 0x37, 0x18, 0x01, 0x45, 0x5a, 0x3f, 0x3a, 0x18, 0x01, - 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0xe7, 0x23, 0x39, 0x18, 0x01, 0x45, - 0xf3, 0x4b, 0x38, 0x18, 0x41, 0xe1, 0x00, 0x18, 0x81, 0xee, 0x01, 0xa2, + 0x48, 0x0a, 0x17, 0x37, 0x18, 0x01, 0x45, 0x62, 0x41, 0x3a, 0x18, 0x01, + 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0x21, 0x25, 0x39, 0x18, 0x01, 0x45, + 0x49, 0x4e, 0x38, 0x18, 0x41, 0xe1, 0x00, 0x18, 0x81, 0xee, 0x01, 0xa2, 0xe1, 0x01, 0xa3, 0xd4, 0x01, 0xa4, 0xbb, 0x01, 0xe5, 0x06, 0x18, 0x01, 0xa7, 0xaa, 0x01, 0x42, 0x22, 0x00, 0x2a, 0x18, 0x01, 0xe9, 0x02, 0x18, 0x81, 0x9a, 0x01, 0xaa, 0x8d, 0x01, 0xab, 0x80, 0x01, 0x42, 0x74, 0x00, 0x25, 0x18, 0x01, 0x42, 0x6c, 0x00, 0x22, 0x18, 0x01, 0xae, 0x5c, 0xef, 0x08, 0x18, 0x01, 0xb0, 0x4c, 0xb2, 0x40, 0xb3, 0x2e, 0xb4, 0x15, 0xf5, - 0x04, 0x18, 0x81, 0x0c, 0x42, 0xf5, 0x0a, 0x26, 0x18, 0x01, 0x42, 0xbe, - 0x22, 0x23, 0x18, 0x41, 0xf5, 0x05, 0x18, 0x41, 0xe1, 0x19, 0x18, 0x01, + 0x04, 0x18, 0x81, 0x0c, 0x42, 0x61, 0x0b, 0x26, 0x18, 0x01, 0x42, 0xdf, + 0x23, 0x23, 0x18, 0x41, 0xf5, 0x05, 0x18, 0x41, 0xe1, 0x19, 0x18, 0x01, 0x42, 0x22, 0x00, 0x1a, 0x18, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x14, 0x18, 0x01, 0x42, 0x22, 0x00, 0x15, 0x18, 0x41, 0xe1, 0x29, 0x18, 0x01, 0x42, 0x22, 0x00, 0x27, 0x18, 0x01, 0x42, 0x40, 0x06, 0x28, 0x18, 0x41, 0xe1, 0x24, 0x18, 0x01, 0x42, 0x71, 0x00, 0x2b, 0x18, 0x41, 0xe1, 0x1e, 0x18, 0x01, 0x42, 0x22, 0x00, 0x1f, 0x18, 0x41, 0xe1, 0x1d, 0x18, 0x01, 0x42, 0x24, 0x02, 0x0e, 0x18, 0x01, 0x42, 0x2a, 0x05, 0x18, 0x18, 0x01, 0x42, - 0xbe, 0x22, 0x13, 0x18, 0x41, 0xe1, 0x0a, 0x18, 0x01, 0x42, 0x22, 0x00, + 0xdf, 0x23, 0x13, 0x18, 0x41, 0xe1, 0x0a, 0x18, 0x01, 0x42, 0x22, 0x00, 0x0b, 0x18, 0x41, 0xe1, 0x11, 0x18, 0x01, 0x42, 0x22, 0x00, 0x12, 0x18, 0x41, 0xe9, 0x03, 0x18, 0x41, 0xe1, 0x0c, 0x18, 0x01, 0x42, 0x22, 0x00, 0x0d, 0x18, 0x41, 0xe1, 0x1b, 0x18, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x1c, 0x18, 0x41, 0xe1, 0x16, 0x18, 0x01, 0x42, 0x22, 0x00, 0x17, 0x18, 0x41, 0xe1, 0x0f, 0x18, 0x01, 0x42, 0x22, 0x00, 0x10, 0x18, 0x41, 0xe1, 0x20, 0x18, 0x01, 0x42, 0x22, 0x00, 0x21, 0x18, 0x41, 0xe1, 0x01, 0x18, - 0x01, 0xe9, 0x07, 0x18, 0x01, 0xf5, 0x09, 0x18, 0x41, 0x0b, 0x6b, 0x9a, - 0x37, 0x46, 0x00, 0x00, 0x24, 0x22, 0x80, 0x2a, 0x45, 0x98, 0xe6, 0xae, - 0x22, 0x00, 0x02, 0xdf, 0x0c, 0x0d, 0x47, 0x51, 0xcb, 0x81, 0x22, 0xc0, - 0x00, 0x49, 0x0d, 0x29, 0xe1, 0x22, 0x40, 0x45, 0x72, 0x36, 0x80, 0x22, - 0x80, 0x06, 0x43, 0x5e, 0x00, 0xac, 0x22, 0x40, 0x49, 0x0d, 0x29, 0xe0, - 0x22, 0x40, 0x5d, 0xd7, 0x14, 0xee, 0x2a, 0x40, 0x46, 0xb4, 0x05, 0x0c, - 0x22, 0x00, 0x4f, 0xf0, 0x53, 0xeb, 0x22, 0xc0, 0x00, 0x49, 0x0d, 0x29, - 0xed, 0x22, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x47, 0x19, 0x8b, 0xbb, - 0xf5, 0x01, 0x44, 0x97, 0x30, 0xb9, 0xf5, 0xc1, 0x00, 0x4c, 0x14, 0x8b, - 0xba, 0xf5, 0x41, 0xa1, 0xaa, 0x09, 0xa5, 0x85, 0x09, 0x50, 0x3d, 0x63, - 0x4f, 0x22, 0x00, 0xa7, 0xc7, 0x06, 0x4e, 0xf2, 0x79, 0x31, 0x23, 0x00, - 0x06, 0x62, 0xde, 0xce, 0x04, 0x05, 0x89, 0x0d, 0xbd, 0x04, 0xb3, 0x8f, - 0x04, 0x48, 0xe9, 0xcb, 0x03, 0x30, 0x00, 0xb6, 0x17, 0x47, 0xe2, 0xd7, - 0x94, 0xfa, 0x01, 0x04, 0x91, 0xf3, 0x01, 0xff, 0x44, 0x0c, 0x08, 0x35, - 0xf6, 0x01, 0x46, 0x16, 0x08, 0xab, 0xf4, 0x41, 0x09, 0xb8, 0xb8, 0x2d, - 0xa9, 0x06, 0x4b, 0x09, 0xa1, 0xae, 0x26, 0x40, 0x43, 0x11, 0x28, 0x23, - 0x22, 0x00, 0x47, 0xa5, 0xd3, 0x3f, 0xf9, 0x01, 0x05, 0xa6, 0x30, 0x01, + 0x01, 0xe9, 0x07, 0x18, 0x01, 0xf5, 0x09, 0x18, 0x41, 0x0b, 0x69, 0x9f, + 0x37, 0x46, 0x00, 0x00, 0x24, 0x22, 0x80, 0x2a, 0x45, 0x6a, 0xec, 0xae, + 0x22, 0x00, 0x02, 0x6d, 0x0d, 0x0d, 0x47, 0xef, 0xd0, 0x81, 0x22, 0xc0, + 0x00, 0x49, 0x90, 0x2a, 0xe1, 0x22, 0x40, 0x45, 0x4f, 0x38, 0x80, 0x22, + 0x80, 0x06, 0x43, 0x5e, 0x00, 0xac, 0x22, 0x40, 0x49, 0x90, 0x2a, 0xe0, + 0x22, 0x40, 0x5d, 0xa5, 0x15, 0xee, 0x2a, 0x40, 0x46, 0xb4, 0x05, 0x0c, + 0x22, 0x00, 0x4f, 0x45, 0x56, 0xeb, 0x22, 0xc0, 0x00, 0x49, 0x90, 0x2a, + 0xed, 0x22, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x47, 0x89, 0x8f, 0xbb, + 0xf5, 0x01, 0x44, 0x1a, 0x32, 0xb9, 0xf5, 0xc1, 0x00, 0x4c, 0x84, 0x8f, + 0xba, 0xf5, 0x41, 0xa1, 0xaa, 0x09, 0xa5, 0x85, 0x09, 0x50, 0x1a, 0x66, + 0x4f, 0x22, 0x00, 0xa7, 0xc7, 0x06, 0x4e, 0x80, 0x7d, 0x31, 0x23, 0x00, + 0x06, 0x38, 0xe4, 0xce, 0x04, 0x05, 0x17, 0x0e, 0xbd, 0x04, 0xb3, 0x8f, + 0x04, 0x48, 0x87, 0xd1, 0x03, 0x30, 0x00, 0xb6, 0x17, 0x47, 0xb2, 0xdd, + 0x94, 0xfa, 0x01, 0x04, 0x6c, 0xf9, 0x01, 0xff, 0x44, 0x0c, 0x08, 0x35, + 0xf6, 0x01, 0x46, 0x16, 0x08, 0xab, 0xf4, 0x41, 0x09, 0x31, 0xbe, 0x2d, + 0xa9, 0x06, 0x4b, 0x12, 0xa6, 0xae, 0x26, 0x40, 0x43, 0x83, 0x08, 0x23, + 0x22, 0x00, 0x47, 0x67, 0xd9, 0x3f, 0xf9, 0x01, 0x05, 0x29, 0x32, 0x01, 0xff, 0xb3, 0x06, 0x45, 0x28, 0x02, 0xc7, 0x22, 0x40, 0x43, 0x5b, 0x03, - 0xf7, 0x00, 0x00, 0x44, 0x49, 0x0e, 0x15, 0x22, 0x40, 0xa4, 0xf0, 0x02, - 0x50, 0xbd, 0x62, 0x46, 0x19, 0x01, 0x4a, 0x5a, 0x9c, 0x45, 0x19, 0x01, - 0x4a, 0x0c, 0xac, 0x41, 0x19, 0x01, 0x07, 0xec, 0x05, 0x64, 0x07, 0x67, - 0x33, 0x54, 0x53, 0x31, 0x4c, 0x3f, 0x19, 0x01, 0x05, 0x5a, 0x03, 0x32, - 0xb6, 0x01, 0xff, 0x45, 0xe6, 0x23, 0x3e, 0x19, 0x01, 0x0a, 0x56, 0x77, + 0xf7, 0x00, 0x00, 0x44, 0xd7, 0x0e, 0x15, 0x22, 0x40, 0xa4, 0xf0, 0x02, + 0x50, 0x9a, 0x65, 0x46, 0x19, 0x01, 0x4a, 0x63, 0xa1, 0x45, 0x19, 0x01, + 0x4a, 0x68, 0xb1, 0x41, 0x19, 0x01, 0x07, 0x13, 0x06, 0x64, 0x07, 0x18, + 0x35, 0x54, 0x53, 0x87, 0x4e, 0x3f, 0x19, 0x01, 0x05, 0x5a, 0x03, 0x32, + 0xb6, 0x01, 0xff, 0x45, 0x20, 0x25, 0x3e, 0x19, 0x01, 0x0a, 0xc8, 0x7a, 0x01, 0xff, 0xa1, 0x1a, 0xe5, 0x35, 0x19, 0x01, 0xe9, 0x31, 0x19, 0x81, 0x0d, 0xef, 0x38, 0x19, 0x01, 0xf5, 0x33, 0x19, 0xc1, 0x00, 0xf5, 0x34, 0x19, 0x41, 0xe9, 0x32, 0x19, 0x41, 0xe1, 0x30, 0x19, 0x01, 0xe9, 0x37, - 0x19, 0x41, 0x48, 0x3c, 0x16, 0x3b, 0x19, 0x01, 0x4b, 0xd9, 0x23, 0x3c, - 0x19, 0x01, 0x47, 0x8a, 0xd1, 0x3d, 0x19, 0x01, 0x45, 0x5a, 0x3f, 0x43, - 0x19, 0x41, 0x42, 0x71, 0x00, 0x42, 0x19, 0x01, 0x42, 0xbe, 0x22, 0x40, + 0x19, 0x41, 0x48, 0x0a, 0x17, 0x3b, 0x19, 0x01, 0x4b, 0x13, 0x25, 0x3c, + 0x19, 0x01, 0x47, 0x3e, 0xd7, 0x3d, 0x19, 0x01, 0x45, 0x62, 0x41, 0x43, + 0x19, 0x41, 0x42, 0x71, 0x00, 0x42, 0x19, 0x01, 0x42, 0xdf, 0x23, 0x40, 0x19, 0x41, 0xe1, 0x00, 0x19, 0x81, 0xec, 0x01, 0xa2, 0xdf, 0x01, 0xa3, 0xd2, 0x01, 0xa4, 0xb9, 0x01, 0xe5, 0x06, 0x19, 0x01, 0xa7, 0xa8, 0x01, 0x42, 0x22, 0x00, 0x2d, 0x19, 0x01, 0xe9, 0x02, 0x19, 0x81, 0x98, 0x01, - 0x42, 0x72, 0x19, 0x13, 0x19, 0x01, 0xab, 0x85, 0x01, 0xac, 0x79, 0x42, + 0x42, 0x78, 0x1a, 0x13, 0x19, 0x01, 0xab, 0x85, 0x01, 0xac, 0x79, 0x42, 0x6c, 0x00, 0x24, 0x19, 0x01, 0xae, 0x5b, 0xef, 0x09, 0x19, 0x01, 0xb0, 0x4b, 0x42, 0x71, 0x00, 0x27, 0x19, 0x01, 0xb3, 0x33, 0xb4, 0x21, 0xf5, - 0x04, 0x19, 0x81, 0x18, 0x42, 0xf5, 0x0a, 0x29, 0x19, 0x01, 0xb9, 0x06, - 0x42, 0x59, 0x00, 0x2f, 0x19, 0x41, 0xe1, 0x25, 0x19, 0x01, 0x42, 0xbe, - 0x22, 0x26, 0x19, 0x41, 0xf5, 0x05, 0x19, 0x41, 0xe1, 0x1b, 0x19, 0x01, + 0x04, 0x19, 0x81, 0x18, 0x42, 0x61, 0x0b, 0x29, 0x19, 0x01, 0xb9, 0x06, + 0x42, 0x59, 0x00, 0x2f, 0x19, 0x41, 0xe1, 0x25, 0x19, 0x01, 0x42, 0xdf, + 0x23, 0x26, 0x19, 0x41, 0xf5, 0x05, 0x19, 0x41, 0xe1, 0x1b, 0x19, 0x01, 0x42, 0x22, 0x00, 0x1c, 0x19, 0x01, 0x42, 0x12, 0x00, 0x16, 0x19, 0x41, 0xe1, 0x2c, 0x19, 0x01, 0x42, 0x22, 0x00, 0x2a, 0x19, 0x01, 0x42, 0x40, 0x06, 0x2b, 0x19, 0x41, 0xe1, 0x20, 0x19, 0x01, 0x42, 0x22, 0x00, 0x21, 0x19, 0x41, 0xe1, 0x1f, 0x19, 0x01, 0x42, 0x24, 0x02, 0x10, 0x19, 0x01, - 0x42, 0x2a, 0x05, 0x1a, 0x19, 0x01, 0x42, 0xbe, 0x22, 0x15, 0x19, 0x41, + 0x42, 0x2a, 0x05, 0x1a, 0x19, 0x01, 0x42, 0xdf, 0x23, 0x15, 0x19, 0x41, 0xe1, 0x28, 0x19, 0x01, 0x42, 0x74, 0x00, 0x2e, 0x19, 0x41, 0xe1, 0x0c, 0x19, 0x01, 0x42, 0x22, 0x00, 0x0d, 0x19, 0x41, 0xe9, 0x03, 0x19, 0x41, 0xe1, 0x0e, 0x19, 0x01, 0x42, 0x22, 0x00, 0x0f, 0x19, 0x41, 0xe1, 0x1d, @@ -13990,119 +14226,119 @@ static const unsigned char uname2c_tree[222744] = { 0x19, 0x01, 0x42, 0x22, 0x00, 0x19, 0x19, 0x41, 0xe1, 0x11, 0x19, 0x01, 0x42, 0x22, 0x00, 0x12, 0x19, 0x41, 0xe1, 0x22, 0x19, 0x01, 0x42, 0x22, 0x00, 0x23, 0x19, 0x41, 0xe1, 0x01, 0x19, 0x41, 0x05, 0xf0, 0x06, 0x06, - 0x4b, 0x2a, 0xa1, 0x44, 0x19, 0x41, 0x45, 0x12, 0x0b, 0x58, 0x19, 0x01, - 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x59, 0x19, 0x01, 0x43, 0x0e, 0x0b, 0x51, - 0x19, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x50, 0x19, 0x41, + 0x4b, 0x33, 0xa6, 0x44, 0x19, 0x41, 0x45, 0x7e, 0x0b, 0x58, 0x19, 0x01, + 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x59, 0x19, 0x01, 0x43, 0x7a, 0x0b, 0x51, + 0x19, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x50, 0x19, 0x41, 0x44, 0x25, 0x01, 0x53, 0x19, 0x01, 0x42, 0x15, 0x02, 0x52, 0x19, 0x41, - 0x44, 0xe5, 0x1d, 0x57, 0x19, 0x01, 0x42, 0x1c, 0x26, 0x56, 0x19, 0x41, - 0x43, 0xd2, 0x05, 0x55, 0x19, 0x01, 0x43, 0xf6, 0x06, 0x54, 0x19, 0x41, - 0xa1, 0x12, 0x5b, 0xe4, 0x1a, 0x82, 0x23, 0x00, 0x4b, 0xbd, 0x9c, 0x78, - 0xf9, 0x01, 0x4b, 0xc9, 0xa3, 0xea, 0xfa, 0x41, 0x48, 0x51, 0xc4, 0xcd, - 0x26, 0x00, 0x09, 0x46, 0xbe, 0x01, 0xff, 0x51, 0xe2, 0x58, 0x25, 0xf6, - 0x01, 0x44, 0x0c, 0x08, 0x1e, 0xf6, 0x41, 0x57, 0x2e, 0x2e, 0x93, 0x23, - 0x00, 0x43, 0xae, 0x02, 0xaf, 0xf3, 0x41, 0x13, 0xc7, 0x48, 0x9d, 0x01, - 0x11, 0xab, 0x5c, 0x01, 0xff, 0x06, 0xef, 0x06, 0x57, 0x4a, 0xaa, 0xae, - 0x7f, 0x27, 0x00, 0x0b, 0xcf, 0x48, 0x01, 0xff, 0x06, 0xef, 0x06, 0x06, - 0x4a, 0xaa, 0xae, 0x93, 0x27, 0x40, 0x45, 0x12, 0x0b, 0x91, 0x27, 0x00, - 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x92, 0x27, 0x00, 0x43, 0x0e, 0x0b, 0x8a, - 0x27, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x0c, 0xf1, 0x41, + 0x44, 0x06, 0x1f, 0x57, 0x19, 0x01, 0x42, 0x09, 0x24, 0x56, 0x19, 0x41, + 0x43, 0xf9, 0x05, 0x55, 0x19, 0x01, 0x43, 0xf6, 0x06, 0x54, 0x19, 0x41, + 0xa1, 0x12, 0x5b, 0xea, 0x1b, 0x82, 0x23, 0x00, 0x4b, 0xc6, 0xa1, 0x78, + 0xf9, 0x01, 0x4b, 0xf3, 0xa8, 0xea, 0xfa, 0x41, 0x48, 0xdf, 0xc9, 0xcd, + 0x26, 0x00, 0x09, 0xec, 0xc3, 0x01, 0xff, 0x51, 0x5c, 0x5b, 0x25, 0xf6, + 0x01, 0x44, 0x0c, 0x08, 0x1e, 0xf6, 0x41, 0x57, 0x9a, 0x2f, 0x93, 0x23, + 0x00, 0x43, 0xae, 0x02, 0xaf, 0xf3, 0x41, 0x13, 0xf7, 0x4a, 0x9d, 0x01, + 0x11, 0x36, 0x5f, 0x01, 0xff, 0x06, 0xef, 0x06, 0x57, 0x4a, 0x10, 0xb4, + 0x7f, 0x27, 0x00, 0x0b, 0xff, 0x4a, 0x01, 0xff, 0x06, 0xef, 0x06, 0x06, + 0x4a, 0x10, 0xb4, 0x93, 0x27, 0x40, 0x45, 0x7e, 0x0b, 0x91, 0x27, 0x00, + 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x92, 0x27, 0x00, 0x43, 0x7a, 0x0b, 0x8a, + 0x27, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x0c, 0xf1, 0x41, 0x44, 0x25, 0x01, 0x8c, 0x27, 0x00, 0x42, 0x15, 0x02, 0x8b, 0x27, 0x40, - 0x44, 0xe5, 0x1d, 0x90, 0x27, 0x00, 0x42, 0x1c, 0x26, 0x8f, 0x27, 0x40, - 0x43, 0xd2, 0x05, 0x8e, 0x27, 0x00, 0x43, 0xf6, 0x06, 0x8d, 0x27, 0x40, - 0x45, 0x12, 0x0b, 0x7d, 0x27, 0x00, 0xa6, 0x29, 0x44, 0xea, 0x2a, 0x7e, - 0x27, 0x00, 0x43, 0x0e, 0x0b, 0x76, 0x27, 0x00, 0xb3, 0x0f, 0xb4, 0x01, + 0x44, 0x06, 0x1f, 0x90, 0x27, 0x00, 0x42, 0x09, 0x24, 0x8f, 0x27, 0x40, + 0x43, 0xf9, 0x05, 0x8e, 0x27, 0x00, 0x43, 0xf6, 0x06, 0x8d, 0x27, 0x40, + 0x45, 0x7e, 0x0b, 0x7d, 0x27, 0x00, 0xa6, 0x29, 0x44, 0x6d, 0x2c, 0x7e, + 0x27, 0x00, 0x43, 0x7a, 0x0b, 0x76, 0x27, 0x00, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0x78, 0x27, 0x00, 0x42, 0x15, 0x02, 0x77, 0x27, - 0x40, 0x44, 0xe5, 0x1d, 0x7c, 0x27, 0x00, 0x42, 0x1c, 0x26, 0x7b, 0x27, - 0x40, 0x43, 0xd2, 0x05, 0x7a, 0x27, 0x00, 0x43, 0xf6, 0x06, 0x79, 0x27, - 0x40, 0x06, 0xef, 0x06, 0x06, 0x4a, 0xaa, 0xae, 0x89, 0x27, 0x40, 0x45, - 0x12, 0x0b, 0x87, 0x27, 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x88, 0x27, - 0x00, 0x43, 0x0e, 0x0b, 0x80, 0x27, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, - 0x5f, 0x1e, 0x0b, 0xf1, 0x41, 0x44, 0x25, 0x01, 0x82, 0x27, 0x00, 0x42, - 0x15, 0x02, 0x81, 0x27, 0x40, 0x44, 0xe5, 0x1d, 0x86, 0x27, 0x00, 0x42, - 0x1c, 0x26, 0x85, 0x27, 0x40, 0x43, 0xd2, 0x05, 0x84, 0x27, 0x00, 0x43, - 0xf6, 0x06, 0x83, 0x27, 0x40, 0x03, 0xf2, 0x06, 0x4c, 0x08, 0x28, 0x96, - 0x01, 0xff, 0x45, 0x59, 0x72, 0x05, 0xd3, 0x81, 0x2f, 0x09, 0x5a, 0xb9, - 0x1f, 0xa8, 0x11, 0x08, 0xd9, 0xc7, 0x01, 0xff, 0x43, 0x1c, 0x01, 0x8e, - 0x26, 0x00, 0x42, 0x9e, 0x01, 0x8d, 0x26, 0x40, 0x4d, 0x65, 0x82, 0x01, - 0xd3, 0x01, 0x4a, 0xc4, 0xb2, 0x02, 0xd3, 0x41, 0x43, 0x1c, 0x01, 0x8c, - 0x26, 0x00, 0x42, 0x9e, 0x01, 0x8f, 0x26, 0x40, 0x04, 0x8f, 0x8e, 0x01, - 0xff, 0x45, 0x9f, 0x7b, 0x03, 0xd3, 0x01, 0x44, 0x6e, 0xa4, 0x04, 0xd3, - 0x41, 0x45, 0x12, 0x0b, 0x38, 0x00, 0x80, 0xce, 0x01, 0xa6, 0x9f, 0x01, - 0x44, 0xea, 0x2a, 0x39, 0x00, 0x80, 0x88, 0x01, 0x43, 0x0e, 0x0b, 0x31, - 0x00, 0x80, 0x72, 0xb3, 0x44, 0xb4, 0x16, 0x44, 0x5f, 0x1e, 0x30, 0x00, + 0x40, 0x44, 0x06, 0x1f, 0x7c, 0x27, 0x00, 0x42, 0x09, 0x24, 0x7b, 0x27, + 0x40, 0x43, 0xf9, 0x05, 0x7a, 0x27, 0x00, 0x43, 0xf6, 0x06, 0x79, 0x27, + 0x40, 0x06, 0xef, 0x06, 0x06, 0x4a, 0x10, 0xb4, 0x89, 0x27, 0x40, 0x45, + 0x7e, 0x0b, 0x87, 0x27, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x88, 0x27, + 0x00, 0x43, 0x7a, 0x0b, 0x80, 0x27, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, + 0x80, 0x1f, 0x0b, 0xf1, 0x41, 0x44, 0x25, 0x01, 0x82, 0x27, 0x00, 0x42, + 0x15, 0x02, 0x81, 0x27, 0x40, 0x44, 0x06, 0x1f, 0x86, 0x27, 0x00, 0x42, + 0x09, 0x24, 0x85, 0x27, 0x40, 0x43, 0xf9, 0x05, 0x84, 0x27, 0x00, 0x43, + 0xf6, 0x06, 0x83, 0x27, 0x40, 0x03, 0xf2, 0x06, 0x4c, 0x08, 0x04, 0x9b, + 0x01, 0xff, 0x45, 0x94, 0x75, 0x05, 0xd3, 0x81, 0x2f, 0x09, 0xd3, 0xbe, + 0x1f, 0xa8, 0x11, 0x08, 0x67, 0xcd, 0x01, 0xff, 0x43, 0x1c, 0x01, 0x8e, + 0x26, 0x00, 0x42, 0x9e, 0x01, 0x8d, 0x26, 0x40, 0x4d, 0x60, 0x86, 0x01, + 0xd3, 0x01, 0x4a, 0x3e, 0xb8, 0x02, 0xd3, 0x41, 0x43, 0x1c, 0x01, 0x8c, + 0x26, 0x00, 0x42, 0x9e, 0x01, 0x8f, 0x26, 0x40, 0x04, 0x2f, 0x93, 0x01, + 0xff, 0x45, 0x57, 0x7f, 0x03, 0xd3, 0x01, 0x44, 0x98, 0xa9, 0x04, 0xd3, + 0x41, 0x45, 0x7e, 0x0b, 0x38, 0x00, 0x80, 0xce, 0x01, 0xa6, 0x9f, 0x01, + 0x44, 0x6d, 0x2c, 0x39, 0x00, 0x80, 0x88, 0x01, 0x43, 0x7a, 0x0b, 0x31, + 0x00, 0x80, 0x72, 0xb3, 0x44, 0xb4, 0x16, 0x44, 0x80, 0x1f, 0x30, 0x00, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x45, 0x13, 0x05, 0x01, 0xf1, 0x01, 0x49, - 0x81, 0x16, 0x00, 0xf1, 0x41, 0x44, 0x25, 0x01, 0x33, 0x00, 0x80, 0x16, + 0x4f, 0x17, 0x00, 0xf1, 0x41, 0x44, 0x25, 0x01, 0x33, 0x00, 0x80, 0x16, 0x42, 0x15, 0x02, 0x32, 0x00, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x45, 0x13, - 0x05, 0x03, 0xf1, 0x01, 0x49, 0x81, 0x16, 0x89, 0x24, 0x40, 0x80, 0x01, - 0xff, 0x45, 0x13, 0x05, 0x04, 0xf1, 0x01, 0x49, 0x81, 0x16, 0x8a, 0x24, - 0x40, 0x44, 0xe5, 0x1d, 0x37, 0x00, 0x80, 0x16, 0x42, 0x1c, 0x26, 0x36, + 0x05, 0x03, 0xf1, 0x01, 0x49, 0x4f, 0x17, 0x89, 0x24, 0x40, 0x80, 0x01, + 0xff, 0x45, 0x13, 0x05, 0x04, 0xf1, 0x01, 0x49, 0x4f, 0x17, 0x8a, 0x24, + 0x40, 0x44, 0x06, 0x1f, 0x37, 0x00, 0x80, 0x16, 0x42, 0x09, 0x24, 0x36, 0x00, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x45, 0x13, 0x05, 0x07, 0xf1, 0x01, - 0x49, 0x81, 0x16, 0x8d, 0x24, 0x40, 0x80, 0x01, 0xff, 0x45, 0x13, 0x05, - 0x08, 0xf1, 0x01, 0x49, 0x81, 0x16, 0x8e, 0x24, 0x40, 0x80, 0x01, 0xff, - 0x45, 0x13, 0x05, 0x02, 0xf1, 0x01, 0x49, 0x81, 0x16, 0x88, 0x24, 0x40, - 0x80, 0x01, 0xff, 0x45, 0x13, 0x05, 0x0a, 0xf1, 0x01, 0x49, 0x81, 0x16, - 0x90, 0x24, 0x40, 0x43, 0xd2, 0x05, 0x35, 0x00, 0x80, 0x16, 0x43, 0xf6, + 0x49, 0x4f, 0x17, 0x8d, 0x24, 0x40, 0x80, 0x01, 0xff, 0x45, 0x13, 0x05, + 0x08, 0xf1, 0x01, 0x49, 0x4f, 0x17, 0x8e, 0x24, 0x40, 0x80, 0x01, 0xff, + 0x45, 0x13, 0x05, 0x02, 0xf1, 0x01, 0x49, 0x4f, 0x17, 0x88, 0x24, 0x40, + 0x80, 0x01, 0xff, 0x45, 0x13, 0x05, 0x0a, 0xf1, 0x01, 0x49, 0x4f, 0x17, + 0x90, 0x24, 0x40, 0x43, 0xf9, 0x05, 0x35, 0x00, 0x80, 0x16, 0x43, 0xf6, 0x06, 0x34, 0x00, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x45, 0x13, 0x05, 0x05, - 0xf1, 0x01, 0x49, 0x81, 0x16, 0x8b, 0x24, 0x40, 0x80, 0x01, 0xff, 0x45, - 0x13, 0x05, 0x06, 0xf1, 0x01, 0x49, 0x81, 0x16, 0x8c, 0x24, 0x40, 0x80, - 0x01, 0xff, 0x45, 0x13, 0x05, 0x09, 0xf1, 0x01, 0x49, 0x81, 0x16, 0x8f, - 0x24, 0x40, 0x06, 0x32, 0xd8, 0x06, 0x4e, 0x06, 0x7c, 0xf2, 0xf6, 0x41, + 0xf1, 0x01, 0x49, 0x4f, 0x17, 0x8b, 0x24, 0x40, 0x80, 0x01, 0xff, 0x45, + 0x13, 0x05, 0x06, 0xf1, 0x01, 0x49, 0x4f, 0x17, 0x8c, 0x24, 0x40, 0x80, + 0x01, 0xff, 0x45, 0x13, 0x05, 0x09, 0xf1, 0x01, 0x49, 0x4f, 0x17, 0x8f, + 0x24, 0x40, 0x06, 0x02, 0xde, 0x06, 0x4e, 0xcc, 0x7f, 0xf2, 0xf6, 0x41, 0xd1, 0x80, 0x26, 0x00, 0xd2, 0x81, 0x26, 0x00, 0xd3, 0x82, 0x26, 0x00, 0xd4, 0x83, 0x26, 0x00, 0xd5, 0x84, 0x26, 0x00, 0xd6, 0x85, 0x26, 0x40, - 0x46, 0xbc, 0x23, 0xa8, 0x00, 0x00, 0x55, 0x8b, 0x21, 0x43, 0xcc, 0x01, - 0xad, 0x01, 0xff, 0x49, 0xca, 0xb8, 0x00, 0x23, 0x00, 0x04, 0x69, 0x57, - 0x01, 0xff, 0x48, 0x9a, 0x1d, 0xc4, 0x22, 0x00, 0x57, 0x3c, 0x31, 0xa0, - 0xf4, 0x01, 0x46, 0x84, 0xe0, 0x9c, 0xf7, 0x01, 0x05, 0x51, 0x00, 0x01, - 0xff, 0x51, 0xaf, 0x58, 0x19, 0x2b, 0x00, 0x4f, 0x7f, 0x6f, 0x16, 0x2b, - 0x00, 0x50, 0xbd, 0x66, 0x17, 0x2b, 0x00, 0x4e, 0x48, 0x7d, 0x18, 0x2b, - 0x40, 0x49, 0xd6, 0xb5, 0xcf, 0xf9, 0x01, 0xa3, 0xa2, 0x0d, 0x42, 0x33, - 0x00, 0x8c, 0xf9, 0x01, 0x05, 0x12, 0xab, 0x85, 0x0d, 0xec, 0x7f, 0x00, - 0x80, 0xed, 0x0c, 0xae, 0xd8, 0x0b, 0x4e, 0x18, 0x7b, 0xec, 0xf3, 0x01, - 0x55, 0xc1, 0x3d, 0xda, 0xf3, 0x01, 0xb3, 0xe5, 0x07, 0xb6, 0x01, 0xff, - 0x08, 0xf3, 0xc0, 0x26, 0x0c, 0x5f, 0x8a, 0x01, 0xff, 0x44, 0xf5, 0x06, - 0x14, 0x00, 0x00, 0x43, 0x0e, 0x0b, 0x11, 0x00, 0x00, 0x46, 0x9d, 0x67, + 0x46, 0xf6, 0x24, 0xa8, 0x00, 0x00, 0x55, 0xac, 0x22, 0x43, 0xcc, 0x01, + 0xad, 0x01, 0xff, 0x49, 0x43, 0xbe, 0x00, 0x23, 0x00, 0x04, 0xf4, 0x59, + 0x01, 0xff, 0x48, 0xa0, 0x1e, 0xc4, 0x22, 0x00, 0x57, 0xed, 0x32, 0xa0, + 0xf4, 0x01, 0x46, 0x66, 0xe6, 0x9c, 0xf7, 0x01, 0x05, 0x51, 0x00, 0x01, + 0xff, 0x51, 0x29, 0x5b, 0x19, 0x2b, 0x00, 0x4f, 0xab, 0x72, 0x16, 0x2b, + 0x00, 0x50, 0xca, 0x69, 0x17, 0x2b, 0x00, 0x4e, 0x0e, 0x81, 0x18, 0x2b, + 0x40, 0x49, 0x3d, 0xbb, 0xcf, 0xf9, 0x01, 0xa3, 0xa8, 0x0d, 0x42, 0x33, + 0x00, 0x8c, 0xf9, 0x01, 0x05, 0x6e, 0xb0, 0x8b, 0x0d, 0xec, 0x7f, 0x00, + 0x80, 0xf3, 0x0c, 0xae, 0xde, 0x0b, 0x4e, 0xd0, 0x7e, 0xec, 0xf3, 0x01, + 0x55, 0xc9, 0x3f, 0xda, 0xf3, 0x01, 0xb3, 0xeb, 0x07, 0xb6, 0x01, 0xff, + 0x08, 0xa2, 0xc6, 0x26, 0x0c, 0xdc, 0x8e, 0x01, 0xff, 0x44, 0xf5, 0x06, + 0x14, 0x00, 0x00, 0x43, 0x7a, 0x0b, 0x11, 0x00, 0x00, 0x46, 0xaa, 0x6a, 0x90, 0x00, 0x00, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0x13, 0x00, 0x00, - 0x42, 0x15, 0x02, 0x12, 0x00, 0x40, 0xa1, 0xa9, 0x07, 0x45, 0x7b, 0x7d, - 0xfa, 0xa8, 0x00, 0xa4, 0xce, 0x06, 0xa7, 0xbf, 0x06, 0x04, 0xe6, 0x01, - 0xa7, 0x06, 0x47, 0x40, 0xd2, 0xfd, 0xa8, 0x00, 0x07, 0xec, 0x05, 0xc9, - 0x02, 0x42, 0x14, 0x05, 0x50, 0x09, 0x00, 0xb3, 0x84, 0x01, 0x0b, 0x55, - 0x77, 0x01, 0xff, 0xa1, 0x69, 0x07, 0x3d, 0x61, 0x57, 0xe5, 0x47, 0x09, + 0x42, 0x15, 0x02, 0x12, 0x00, 0x40, 0xa1, 0xaf, 0x07, 0x45, 0x41, 0x81, + 0xfa, 0xa8, 0x00, 0xa4, 0xd4, 0x06, 0xa7, 0xc5, 0x06, 0x04, 0xe6, 0x01, + 0xad, 0x06, 0x47, 0xfb, 0xd7, 0xfd, 0xa8, 0x00, 0x07, 0x13, 0x06, 0xc9, + 0x02, 0x42, 0x14, 0x05, 0x50, 0x09, 0x00, 0xb3, 0x84, 0x01, 0x0b, 0xc7, + 0x7a, 0x01, 0xff, 0xa1, 0x69, 0x07, 0x0a, 0x64, 0x57, 0xe5, 0x47, 0x09, 0x00, 0xe9, 0x3f, 0x09, 0x80, 0x4a, 0xef, 0x4b, 0x09, 0x80, 0x3b, 0x4f, - 0xf5, 0x71, 0x4e, 0x09, 0x00, 0x06, 0x33, 0x07, 0x29, 0xf5, 0x41, 0x09, - 0x80, 0x17, 0x08, 0x43, 0xc1, 0x01, 0xff, 0xec, 0x62, 0x09, 0x80, 0x09, + 0x30, 0x75, 0x4e, 0x09, 0x00, 0x06, 0x33, 0x07, 0x29, 0xf5, 0x41, 0x09, + 0x80, 0x17, 0x08, 0xf2, 0xc6, 0x01, 0xff, 0xec, 0x62, 0x09, 0x80, 0x09, 0xf2, 0x43, 0x09, 0xc0, 0x00, 0xf2, 0x44, 0x09, 0x40, 0xec, 0x63, 0x09, 0x40, 0xe5, 0x56, 0x09, 0x00, 0xf5, 0x42, 0x09, 0xc0, 0x00, 0xe5, 0x57, 0x09, 0x40, 0xe5, 0x46, 0x09, 0x00, 0xef, 0x4a, 0x09, 0x40, 0xe5, 0x3a, - 0x09, 0x00, 0x42, 0x67, 0x51, 0x3b, 0x09, 0x40, 0xe9, 0x40, 0x09, 0x40, - 0xe5, 0x45, 0x09, 0x00, 0x46, 0xf6, 0xdd, 0x55, 0x09, 0x00, 0xef, 0x49, + 0x09, 0x00, 0x42, 0xce, 0x53, 0x3b, 0x09, 0x40, 0xe9, 0x40, 0x09, 0x40, + 0xe5, 0x45, 0x09, 0x00, 0x46, 0xcc, 0xe3, 0x55, 0x09, 0x00, 0xef, 0x49, 0x09, 0x40, 0xe1, 0x3e, 0x09, 0x00, 0xe9, 0x48, 0x09, 0x00, 0xf5, 0x4c, 0x09, 0x00, 0xf7, 0x4f, 0x09, 0x00, 0xf9, 0xff, 0xa8, 0x40, 0x04, 0x5b, - 0x03, 0x11, 0x0b, 0xdf, 0xa3, 0x01, 0xff, 0x48, 0xde, 0x7c, 0x52, 0x09, - 0x00, 0x46, 0xe0, 0x7c, 0x51, 0x09, 0x40, 0xa1, 0x98, 0x01, 0x45, 0xf4, - 0x2a, 0x02, 0x1b, 0x81, 0x8a, 0x01, 0x4b, 0xd9, 0x23, 0x01, 0x09, 0x80, - 0x66, 0x59, 0xd2, 0x23, 0xf4, 0xa8, 0x00, 0x4e, 0xc2, 0x77, 0x04, 0x1b, - 0x81, 0x53, 0x50, 0x6d, 0x63, 0x71, 0x09, 0x00, 0x54, 0x8b, 0x43, 0x00, - 0x09, 0x00, 0x45, 0xcd, 0xe8, 0x09, 0x1b, 0x01, 0x45, 0x5a, 0x3f, 0x3c, - 0x09, 0x00, 0x48, 0x44, 0x7c, 0xf8, 0xa8, 0x00, 0x58, 0xe1, 0x2a, 0x08, - 0x1b, 0x01, 0xb3, 0x21, 0x02, 0x02, 0x00, 0x11, 0x08, 0xf4, 0x31, 0x01, - 0xff, 0x4f, 0x18, 0x6d, 0x06, 0x1b, 0x01, 0x4f, 0xea, 0x2a, 0x07, 0x1b, - 0x41, 0x44, 0xe7, 0x23, 0x4d, 0x09, 0x00, 0x45, 0xf3, 0x4b, 0x03, 0x09, - 0x40, 0x46, 0xf9, 0xd5, 0xfc, 0xa8, 0x00, 0x52, 0x80, 0x54, 0xf2, 0xa8, - 0x40, 0x4a, 0xc2, 0x24, 0x05, 0x1b, 0x41, 0x80, 0x01, 0xff, 0x48, 0xc3, - 0x88, 0xf7, 0xa8, 0x00, 0xb4, 0x06, 0x46, 0xe5, 0x23, 0xf3, 0xa8, 0x40, + 0x03, 0x11, 0x0b, 0x09, 0xa9, 0x01, 0xff, 0x48, 0xa4, 0x80, 0x52, 0x09, + 0x00, 0x46, 0xa6, 0x80, 0x51, 0x09, 0x40, 0xa1, 0x98, 0x01, 0x45, 0x77, + 0x2c, 0x02, 0x1b, 0x81, 0x8a, 0x01, 0x4b, 0x13, 0x25, 0x01, 0x09, 0x80, + 0x66, 0x59, 0x0c, 0x25, 0xf4, 0xa8, 0x00, 0x4e, 0x42, 0x7b, 0x04, 0x1b, + 0x81, 0x53, 0x50, 0x5a, 0x66, 0x71, 0x09, 0x00, 0x54, 0xa7, 0x45, 0x00, + 0x09, 0x00, 0x45, 0x9f, 0xee, 0x09, 0x1b, 0x01, 0x45, 0x62, 0x41, 0x3c, + 0x09, 0x00, 0x48, 0x0a, 0x80, 0xf8, 0xa8, 0x00, 0x58, 0x64, 0x2c, 0x08, + 0x1b, 0x01, 0xb3, 0x21, 0x02, 0x02, 0x00, 0x11, 0x08, 0x8e, 0x33, 0x01, + 0xff, 0x4f, 0x35, 0x70, 0x06, 0x1b, 0x01, 0x4f, 0x6d, 0x2c, 0x07, 0x1b, + 0x41, 0x44, 0x21, 0x25, 0x4d, 0x09, 0x00, 0x45, 0x49, 0x4e, 0x03, 0x09, + 0x40, 0x46, 0xc9, 0xdb, 0xfc, 0xa8, 0x00, 0x52, 0xd5, 0x56, 0xf2, 0xa8, + 0x40, 0x4a, 0x15, 0x26, 0x05, 0x1b, 0x41, 0x80, 0x01, 0xff, 0x48, 0x33, + 0x8d, 0xf7, 0xa8, 0x00, 0xb4, 0x06, 0x46, 0x1f, 0x25, 0xf3, 0xa8, 0x40, 0x44, 0x25, 0x01, 0xf6, 0xa8, 0x00, 0x42, 0x15, 0x02, 0xf5, 0xa8, 0x40, - 0x4a, 0xc2, 0x24, 0x03, 0x1b, 0x41, 0x47, 0x3d, 0x16, 0x02, 0x09, 0x00, - 0x47, 0xc4, 0x88, 0x3d, 0x09, 0x40, 0xe1, 0x05, 0x09, 0x80, 0xb9, 0x03, + 0x4a, 0x15, 0x26, 0x03, 0x1b, 0x41, 0x47, 0x0b, 0x17, 0x02, 0x09, 0x00, + 0x47, 0x34, 0x8d, 0x3d, 0x09, 0x40, 0xe1, 0x05, 0x09, 0x80, 0xb9, 0x03, 0xa2, 0xa6, 0x03, 0xa3, 0x87, 0x03, 0xa4, 0xe2, 0x02, 0xe5, 0x0f, 0x09, 0x00, 0x42, 0x0c, 0x08, 0x5e, 0x09, 0x00, 0xa7, 0xb9, 0x02, 0xa8, 0xac, 0x02, 0xe9, 0x07, 0x09, 0x80, 0xa2, 0x02, 0xaa, 0x8f, 0x02, 0xab, 0xfb, 0x01, 0xac, 0xe7, 0x01, 0x42, 0x6c, 0x00, 0x2e, 0x09, 0x80, 0xd9, 0x01, 0xae, 0xba, 0x01, 0xef, 0x13, 0x09, 0x80, 0xaa, 0x01, 0xb0, 0x9d, 0x01, - 0x42, 0x43, 0x14, 0x58, 0x09, 0x00, 0xb2, 0x84, 0x01, 0xb3, 0x61, 0xb4, + 0x42, 0x11, 0x15, 0x58, 0x09, 0x00, 0xb2, 0x84, 0x01, 0xb3, 0x61, 0xb4, 0x48, 0xf5, 0x09, 0x09, 0x80, 0x36, 0xb6, 0x19, 0xb9, 0x0d, 0xba, 0x01, 0xff, 0xe1, 0x5b, 0x09, 0x00, 0x42, 0x22, 0x00, 0x79, 0x09, 0x40, 0xe1, - 0x2f, 0x09, 0x00, 0x42, 0xbe, 0x22, 0x5f, 0x09, 0x40, 0xe1, 0x35, 0x09, - 0x00, 0x07, 0x44, 0xc1, 0x01, 0xff, 0xec, 0x0c, 0x09, 0x80, 0x09, 0xf2, + 0x2f, 0x09, 0x00, 0x42, 0xdf, 0x23, 0x5f, 0x09, 0x40, 0xe1, 0x35, 0x09, + 0x00, 0x07, 0xf3, 0xc6, 0x01, 0xff, 0xec, 0x0c, 0x09, 0x80, 0x09, 0xf2, 0x0b, 0x09, 0xc0, 0x00, 0xf2, 0x60, 0x09, 0x40, 0xec, 0x61, 0x09, 0x40, 0xe5, 0x76, 0x09, 0x00, 0xf5, 0x0a, 0x09, 0xc0, 0x00, 0xe5, 0x77, 0x09, 0x40, 0xe1, 0x24, 0x09, 0x00, 0x42, 0x22, 0x00, 0x25, 0x09, 0x00, 0xb4, @@ -14112,5327 +14348,5513 @@ static const unsigned char uname2c_tree[222744] = { 0x00, 0xe5, 0x0e, 0x09, 0x00, 0xef, 0x12, 0x09, 0x40, 0xe1, 0x30, 0x09, 0x00, 0x42, 0x22, 0x00, 0x5d, 0x09, 0x00, 0x42, 0x71, 0x00, 0x31, 0x09, 0x40, 0xe1, 0x2a, 0x09, 0x00, 0x42, 0x22, 0x00, 0x2b, 0x09, 0x40, 0xe5, - 0x73, 0x09, 0x00, 0x42, 0x67, 0x51, 0x74, 0x09, 0x40, 0xe1, 0x28, 0x09, - 0x00, 0x42, 0x24, 0x02, 0x19, 0x09, 0x00, 0xae, 0x06, 0x42, 0xbe, 0x22, + 0x73, 0x09, 0x00, 0x42, 0xce, 0x53, 0x74, 0x09, 0x40, 0xe1, 0x28, 0x09, + 0x00, 0x42, 0x24, 0x02, 0x19, 0x09, 0x00, 0xae, 0x06, 0x42, 0xdf, 0x23, 0x1e, 0x09, 0x40, 0xe1, 0x23, 0x09, 0x00, 0x42, 0x2a, 0x05, 0x29, 0x09, - 0x40, 0x49, 0x30, 0xbf, 0x78, 0x09, 0x40, 0xe1, 0x32, 0x09, 0x00, 0xac, + 0x40, 0x49, 0xdf, 0xc4, 0x78, 0x09, 0x40, 0xe1, 0x32, 0x09, 0x00, 0xac, 0x01, 0xff, 0xe1, 0x33, 0x09, 0x00, 0x42, 0x74, 0x00, 0x34, 0x09, 0x40, 0xe1, 0x15, 0x09, 0x00, 0xa8, 0x01, 0xff, 0xe1, 0x16, 0x09, 0x00, 0x42, 0x22, 0x00, 0x59, 0x09, 0x40, 0xe1, 0x1c, 0x09, 0x00, 0x42, 0x22, 0x00, - 0x1d, 0x09, 0x00, 0x42, 0x72, 0x19, 0x7c, 0x09, 0x40, 0xe9, 0x08, 0x09, - 0x40, 0xe1, 0x39, 0x09, 0x00, 0x47, 0xbf, 0xd0, 0x7a, 0x09, 0x40, 0xe1, + 0x1d, 0x09, 0x00, 0x42, 0x78, 0x1a, 0x7c, 0x09, 0x40, 0xe9, 0x08, 0x09, + 0x40, 0xe1, 0x39, 0x09, 0x00, 0x47, 0x65, 0xd6, 0x7a, 0x09, 0x40, 0xe1, 0x17, 0x09, 0x00, 0x42, 0x24, 0x02, 0x7b, 0x09, 0x00, 0xa8, 0x06, 0x4b, - 0xea, 0x28, 0x7d, 0x09, 0x40, 0xe1, 0x18, 0x09, 0x00, 0x42, 0x22, 0x00, + 0x6d, 0x2a, 0x7d, 0x09, 0x40, 0xe1, 0x18, 0x09, 0x00, 0x42, 0x22, 0x00, 0x5a, 0x09, 0x40, 0xe1, 0x26, 0x09, 0x00, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x27, 0x09, 0x40, 0xe1, 0x21, 0x09, 0x00, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x22, 0x09, 0x40, 0xe1, 0x7e, 0x09, 0x00, 0x42, 0x22, 0x00, 0x5c, 0x09, 0x40, 0xe1, 0x1a, 0x09, 0x80, 0x06, 0x42, 0x22, 0x00, 0x1b, 0x09, 0x40, - 0x05, 0x3f, 0x61, 0x01, 0xff, 0xe1, 0x72, 0x09, 0x00, 0xe5, 0x0d, 0x09, + 0x05, 0x0c, 0x64, 0x01, 0xff, 0xe1, 0x72, 0x09, 0x00, 0xe5, 0x0d, 0x09, 0x00, 0xef, 0x11, 0x09, 0x40, 0xe1, 0x2c, 0x09, 0x00, 0x42, 0x16, 0x00, 0x7f, 0x09, 0x00, 0x42, 0x22, 0x00, 0x2d, 0x09, 0x40, 0xe1, 0x06, 0x09, - 0x00, 0xe9, 0x10, 0x09, 0x00, 0xf5, 0x14, 0x09, 0x00, 0xf7, 0x75, 0x09, - 0x00, 0xf9, 0xfe, 0xa8, 0x40, 0x45, 0xb8, 0x00, 0x00, 0x1b, 0x81, 0x06, - 0x46, 0x52, 0x05, 0xfb, 0xa8, 0x40, 0x50, 0xbd, 0x60, 0x01, 0x1b, 0x41, - 0x49, 0x5b, 0x9c, 0xf9, 0xa8, 0x00, 0x4b, 0x18, 0x23, 0x53, 0x09, 0x40, - 0x44, 0x75, 0x20, 0x64, 0x09, 0x00, 0x05, 0xf0, 0x06, 0x06, 0x4b, 0x2a, - 0xa1, 0x65, 0x09, 0x40, 0x45, 0x12, 0x0b, 0x6e, 0x09, 0x00, 0xa6, 0x2e, - 0x44, 0xea, 0x2a, 0x6f, 0x09, 0x00, 0x43, 0x0e, 0x0b, 0x67, 0x09, 0x00, - 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x66, 0x09, 0x40, 0x44, 0x25, - 0x01, 0x69, 0x09, 0x00, 0x42, 0x15, 0x02, 0x68, 0x09, 0x40, 0x44, 0xe5, - 0x1d, 0x6d, 0x09, 0x00, 0x42, 0x1c, 0x26, 0x6c, 0x09, 0x40, 0x43, 0xd2, - 0x05, 0x6b, 0x09, 0x00, 0x43, 0xf6, 0x06, 0x6a, 0x09, 0x40, 0x50, 0xe4, - 0x57, 0x70, 0x09, 0x00, 0x4b, 0x11, 0x8c, 0x54, 0x09, 0x40, 0x4c, 0x48, - 0x8d, 0x0b, 0x26, 0x00, 0x02, 0x33, 0x00, 0x11, 0x05, 0x05, 0xe8, 0x01, - 0xff, 0x48, 0xa3, 0x4b, 0xa5, 0xf5, 0x01, 0x46, 0x5c, 0xe1, 0xd4, 0xf5, - 0x41, 0x03, 0x68, 0x09, 0x0b, 0xf4, 0xdc, 0xf3, 0xc1, 0x00, 0x47, 0x4d, - 0xcd, 0xdd, 0xf3, 0x41, 0x0f, 0xe4, 0x05, 0xdd, 0x01, 0x0d, 0x76, 0x08, - 0x01, 0xff, 0x42, 0xed, 0x10, 0x34, 0x04, 0x01, 0x43, 0xae, 0xb6, 0x3a, - 0x04, 0x01, 0x44, 0x48, 0x4b, 0x3d, 0x04, 0x01, 0x43, 0x5b, 0x81, 0x3c, - 0x04, 0x01, 0xa5, 0x91, 0x01, 0x43, 0x65, 0x9c, 0x40, 0x04, 0x01, 0xe8, - 0x38, 0x04, 0x01, 0x43, 0x59, 0x38, 0x3e, 0x04, 0x01, 0x43, 0x26, 0x7f, - 0x3f, 0x04, 0x01, 0x05, 0xd7, 0x02, 0x5d, 0xaf, 0x53, 0x43, 0x85, 0x7c, - 0x39, 0x04, 0x01, 0x06, 0x33, 0x07, 0x2f, 0xb4, 0x21, 0x43, 0xfd, 0x06, - 0x42, 0x04, 0x01, 0x42, 0x97, 0x31, 0x36, 0x04, 0x01, 0x43, 0xee, 0xa9, - 0x37, 0x04, 0x01, 0xba, 0x01, 0xff, 0x42, 0x27, 0x01, 0x46, 0x04, 0x01, - 0x43, 0x2c, 0x13, 0x48, 0x04, 0x41, 0x42, 0x27, 0x01, 0x3b, 0x04, 0x01, - 0x43, 0x2c, 0x13, 0x44, 0x04, 0x41, 0xe1, 0x30, 0x04, 0x81, 0x11, 0xe5, - 0x2f, 0x04, 0x01, 0xe9, 0x2e, 0x04, 0x01, 0xef, 0x32, 0x04, 0xc1, 0x00, - 0xef, 0x33, 0x04, 0x41, 0xe8, 0x31, 0x04, 0x41, 0xe9, 0x4e, 0x04, 0x01, - 0xf7, 0x35, 0x04, 0x41, 0xe1, 0x2a, 0x04, 0x81, 0x11, 0xe5, 0x29, 0x04, - 0x01, 0xe9, 0x28, 0x04, 0x01, 0xef, 0x2c, 0x04, 0xc1, 0x00, 0xef, 0x2d, - 0x04, 0x41, 0xe8, 0x2b, 0x04, 0x41, 0xe6, 0x41, 0x04, 0x01, 0xec, 0x4a, - 0x04, 0x01, 0xed, 0x4b, 0x04, 0x01, 0xee, 0x4c, 0x04, 0x81, 0x17, 0xf2, - 0x49, 0x04, 0x01, 0xf3, 0x45, 0x04, 0x81, 0x0a, 0x42, 0x53, 0x00, 0x43, - 0x04, 0x01, 0xf7, 0x4f, 0x04, 0x41, 0xe8, 0x47, 0x04, 0x41, 0xe7, 0x4d, - 0x04, 0x41, 0x42, 0xed, 0x10, 0x0c, 0x04, 0x01, 0x43, 0xae, 0xb6, 0x12, - 0x04, 0x01, 0x44, 0x48, 0x4b, 0x15, 0x04, 0x01, 0x43, 0x5b, 0x81, 0x14, - 0x04, 0x01, 0xa5, 0x91, 0x01, 0x43, 0x65, 0x9c, 0x18, 0x04, 0x01, 0xe8, - 0x10, 0x04, 0x01, 0x43, 0x59, 0x38, 0x16, 0x04, 0x01, 0x43, 0x26, 0x7f, - 0x17, 0x04, 0x01, 0x05, 0xd7, 0x02, 0x5d, 0xaf, 0x53, 0x43, 0x85, 0x7c, - 0x11, 0x04, 0x01, 0x06, 0x33, 0x07, 0x2f, 0xb4, 0x21, 0x43, 0xfd, 0x06, - 0x1a, 0x04, 0x01, 0x42, 0x97, 0x31, 0x0e, 0x04, 0x01, 0x43, 0xee, 0xa9, - 0x0f, 0x04, 0x01, 0xba, 0x01, 0xff, 0x42, 0x27, 0x01, 0x1e, 0x04, 0x01, - 0x43, 0x2c, 0x13, 0x20, 0x04, 0x41, 0x42, 0x27, 0x01, 0x13, 0x04, 0x01, - 0x43, 0x2c, 0x13, 0x1c, 0x04, 0x41, 0xe1, 0x08, 0x04, 0x81, 0x11, 0xe5, - 0x07, 0x04, 0x01, 0xe9, 0x06, 0x04, 0x01, 0xef, 0x0a, 0x04, 0xc1, 0x00, - 0xef, 0x0b, 0x04, 0x41, 0xe8, 0x09, 0x04, 0x41, 0xe9, 0x26, 0x04, 0x01, - 0xf7, 0x0d, 0x04, 0x41, 0xe1, 0x02, 0x04, 0x81, 0x11, 0xe5, 0x01, 0x04, - 0x01, 0xe9, 0x00, 0x04, 0x01, 0xef, 0x04, 0x04, 0xc1, 0x00, 0xef, 0x05, - 0x04, 0x41, 0xe8, 0x03, 0x04, 0x41, 0xe6, 0x19, 0x04, 0x01, 0xec, 0x22, - 0x04, 0x01, 0xed, 0x23, 0x04, 0x01, 0xee, 0x24, 0x04, 0x81, 0x17, 0xf2, - 0x21, 0x04, 0x01, 0xf3, 0x1d, 0x04, 0x81, 0x0a, 0x42, 0x53, 0x00, 0x1b, - 0x04, 0x01, 0xf7, 0x27, 0x04, 0x41, 0xe8, 0x1f, 0x04, 0x41, 0xe7, 0x25, - 0x04, 0x41, 0x03, 0x41, 0x04, 0x81, 0x01, 0x14, 0x33, 0x46, 0x01, 0xff, - 0x53, 0x13, 0x49, 0xc9, 0x23, 0x80, 0x5e, 0x51, 0xba, 0x5e, 0xca, 0x23, - 0x80, 0x40, 0x09, 0x32, 0x00, 0x01, 0xff, 0x04, 0x1a, 0x00, 0x11, 0x05, - 0x51, 0x00, 0x01, 0xff, 0x46, 0x12, 0x03, 0xc0, 0x23, 0x00, 0x48, 0x01, - 0x02, 0xc3, 0x23, 0x40, 0x07, 0x9b, 0x0d, 0x16, 0x04, 0x1e, 0x00, 0x06, - 0x44, 0x89, 0x57, 0xc6, 0x23, 0x40, 0x44, 0xc3, 0x00, 0xcb, 0x23, 0x00, - 0x45, 0xc8, 0x00, 0xbe, 0x23, 0x40, 0x44, 0xc3, 0x00, 0xcc, 0x23, 0x00, - 0x45, 0xc8, 0x00, 0xbf, 0x23, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x46, - 0x12, 0x03, 0xc2, 0x23, 0x00, 0x48, 0x01, 0x02, 0xc5, 0x23, 0x00, 0x44, - 0x89, 0x57, 0xc8, 0x23, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x46, 0x12, - 0x03, 0xc1, 0x23, 0x00, 0x48, 0x01, 0x02, 0xc4, 0x23, 0x00, 0x44, 0x89, - 0x57, 0xc7, 0x23, 0x40, 0x4f, 0x26, 0x6e, 0x45, 0xcc, 0x01, 0x4d, 0x44, - 0x8a, 0x44, 0xcc, 0x41, 0x43, 0x37, 0x31, 0x7f, 0x00, 0x00, 0x4b, 0xe6, - 0x9d, 0x9a, 0xf6, 0x01, 0x4b, 0x45, 0xa3, 0x5c, 0x22, 0x40, 0x47, 0xf4, - 0xcf, 0x03, 0x21, 0x00, 0x4a, 0x68, 0xaa, 0x09, 0x21, 0x00, 0x44, 0x5a, - 0x03, 0xb0, 0x00, 0x40, 0xa9, 0x06, 0x56, 0xb2, 0x36, 0xdb, 0xf5, 0x41, - 0x4a, 0x8c, 0xa9, 0x33, 0xf3, 0x01, 0x04, 0xd7, 0x0f, 0x01, 0xff, 0x4f, - 0x09, 0x6d, 0xe8, 0x23, 0x00, 0x54, 0xcf, 0x45, 0x96, 0x23, 0x40, 0xd1, - 0x11, 0x00, 0x00, 0xd2, 0x12, 0x00, 0x00, 0xd3, 0x13, 0x00, 0x00, 0xd4, - 0x14, 0x00, 0x00, 0xf3, 0x90, 0x00, 0x40, 0x44, 0xf8, 0xda, 0x20, 0x20, - 0x80, 0x53, 0x4a, 0x06, 0xad, 0x38, 0x21, 0x00, 0xae, 0x3f, 0x04, 0xa9, - 0x44, 0x2f, 0x02, 0xa4, 0x02, 0x06, 0x4e, 0xee, 0x6a, 0x10, 0x00, 0x40, - 0x80, 0x17, 0x03, 0x05, 0x00, 0x01, 0xff, 0x48, 0x8a, 0x8a, 0x4d, 0xfe, - 0x00, 0x48, 0x97, 0x8a, 0x49, 0xfe, 0x00, 0x60, 0x93, 0x06, 0x9f, 0x27, - 0x40, 0x46, 0x16, 0x08, 0xa8, 0xf4, 0x01, 0x50, 0xdd, 0x68, 0x43, 0x2e, - 0x40, 0x44, 0x4c, 0x04, 0x93, 0x25, 0x00, 0x49, 0x74, 0xc0, 0x76, 0xf5, - 0x41, 0x43, 0xf7, 0x17, 0x83, 0xf4, 0x01, 0x42, 0x06, 0x14, 0x61, 0xf3, - 0x41, 0x80, 0x01, 0xff, 0x45, 0xdb, 0xa5, 0xe1, 0xf5, 0x01, 0x05, 0x51, - 0x00, 0x01, 0xff, 0x4a, 0xc0, 0xac, 0x36, 0x2e, 0x00, 0x4b, 0x11, 0xa2, - 0x37, 0x2e, 0x40, 0xa1, 0x9f, 0xaf, 0x01, 0x42, 0x6d, 0x14, 0x94, 0x00, - 0x00, 0xa5, 0xd3, 0xae, 0x01, 0x42, 0x3f, 0xf5, 0x4f, 0x03, 0x00, 0xa8, - 0xb2, 0x9d, 0x01, 0xa9, 0xff, 0x8d, 0x01, 0x03, 0x2d, 0x33, 0xc7, 0x85, - 0x01, 0xac, 0xc9, 0x81, 0x01, 0xaf, 0x8d, 0x5c, 0xf2, 0x0d, 0x00, 0x80, - 0xd1, 0x5a, 0x42, 0x5a, 0x03, 0x9b, 0x00, 0x00, 0xb5, 0xaf, 0x1b, 0xb9, - 0x01, 0xff, 0x45, 0x76, 0xe5, 0x00, 0xf3, 0x01, 0x4a, 0x42, 0xad, 0x2d, - 0x23, 0x00, 0x02, 0xdf, 0x0c, 0xe0, 0x15, 0x07, 0x12, 0xcd, 0x01, 0xff, - 0x09, 0xe4, 0x05, 0xf2, 0x0b, 0x46, 0xf4, 0x4f, 0x7e, 0xa6, 0x00, 0x07, - 0xec, 0x05, 0xd5, 0x0b, 0x47, 0xb6, 0xd4, 0x7f, 0xa6, 0x00, 0xb3, 0x06, - 0x4e, 0x10, 0x7d, 0x82, 0x04, 0x40, 0x06, 0x77, 0x08, 0x99, 0x01, 0x16, - 0xd0, 0x37, 0x01, 0xff, 0xe1, 0x51, 0xe0, 0x01, 0xa2, 0x83, 0x01, 0x43, - 0x6d, 0x14, 0x63, 0xe0, 0x01, 0xa4, 0x6a, 0xa5, 0x5c, 0x43, 0x2d, 0x52, - 0x54, 0xe0, 0x81, 0x4f, 0x42, 0x22, 0x00, 0x61, 0xe0, 0x81, 0x42, 0xe9, - 0x59, 0xe0, 0x81, 0x39, 0x42, 0x1b, 0x02, 0x5a, 0xe0, 0x01, 0xef, 0x5c, - 0xe0, 0x01, 0x42, 0x6f, 0x02, 0x5d, 0xe0, 0x01, 0x43, 0xa4, 0x02, 0x64, - 0xe0, 0x01, 0x43, 0xdc, 0x5d, 0x62, 0xe0, 0x01, 0xf5, 0x5f, 0xe0, 0x01, - 0x42, 0x32, 0x00, 0x53, 0xe0, 0x01, 0x44, 0x28, 0xd7, 0x66, 0xe0, 0x01, - 0xba, 0x01, 0xff, 0xe5, 0x58, 0xe0, 0x01, 0x42, 0xb0, 0x01, 0x57, 0xe0, - 0x41, 0xe5, 0x56, 0xe0, 0x41, 0x47, 0x1d, 0x93, 0x65, 0xe0, 0x41, 0x4c, - 0xbc, 0x8b, 0x67, 0xe0, 0x41, 0xe6, 0x60, 0xe0, 0x01, 0xec, 0x5b, 0xe0, - 0x01, 0xf3, 0x5e, 0xe0, 0x41, 0xe5, 0x55, 0xe0, 0x01, 0xba, 0x01, 0xff, - 0xe5, 0x69, 0xe0, 0x01, 0x42, 0xb0, 0x01, 0x6a, 0xe0, 0x41, 0xe5, 0x52, - 0xe0, 0x01, 0x57, 0x84, 0x08, 0x68, 0xe0, 0x41, 0x06, 0xed, 0x05, 0x17, - 0x08, 0x9f, 0x1f, 0x01, 0xff, 0x44, 0xf5, 0xee, 0xd5, 0x04, 0x00, 0x46, - 0x68, 0xdb, 0xa5, 0x04, 0x00, 0x46, 0x96, 0xe0, 0xb5, 0x04, 0x40, 0xe1, - 0x30, 0x04, 0x80, 0xd5, 0x09, 0xa2, 0x99, 0x09, 0xa3, 0xe4, 0x08, 0xa4, - 0x8f, 0x08, 0xe5, 0x4d, 0x04, 0x80, 0x94, 0x07, 0x44, 0xf1, 0xef, 0x73, - 0x04, 0x00, 0xa7, 0xda, 0x06, 0xa8, 0xb0, 0x06, 0xe9, 0x38, 0x04, 0x80, - 0xc0, 0x05, 0x42, 0x82, 0x20, 0x58, 0x04, 0x00, 0xab, 0xc7, 0x04, 0xac, - 0xac, 0x04, 0x04, 0xda, 0x18, 0x9b, 0x04, 0xae, 0x86, 0x04, 0xef, 0x3e, - 0x04, 0x80, 0xe9, 0x03, 0xb0, 0xc4, 0x03, 0x42, 0x43, 0x14, 0x1b, 0x05, - 0x00, 0xb2, 0x88, 0x03, 0xb3, 0x99, 0x02, 0xb4, 0xba, 0x01, 0xf5, 0x43, - 0x04, 0x80, 0x8b, 0x01, 0x42, 0x32, 0x00, 0x32, 0x04, 0x00, 0xb7, 0x79, - 0xb9, 0x46, 0xba, 0x01, 0xff, 0xe5, 0x37, 0x04, 0x80, 0x28, 0xa8, 0x01, - 0xff, 0xe5, 0x36, 0x04, 0x80, 0x06, 0x42, 0x15, 0x01, 0x85, 0xa6, 0x40, - 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0x55, 0x23, 0xc2, 0x04, 0x00, 0xa4, - 0x01, 0xff, 0x48, 0x39, 0x2b, 0x97, 0x04, 0x00, 0x48, 0xba, 0x23, 0xdd, - 0x04, 0x40, 0x07, 0x82, 0x07, 0x06, 0x44, 0x59, 0xf1, 0x41, 0xa6, 0x40, - 0x48, 0x39, 0x2b, 0x99, 0x04, 0x00, 0x48, 0xba, 0x23, 0xdf, 0x04, 0x40, - 0xe1, 0x4f, 0x04, 0x80, 0x24, 0x43, 0xb7, 0x2b, 0x4b, 0x04, 0x80, 0x0c, - 0xe9, 0x57, 0x04, 0x00, 0xee, 0x5f, 0xa6, 0x00, 0xf5, 0x4e, 0x04, 0x40, - 0x06, 0x50, 0x00, 0x01, 0xff, 0x48, 0x8a, 0x75, 0x51, 0xa6, 0x00, 0x49, - 0xb9, 0x23, 0xf9, 0x04, 0x40, 0xe5, 0x19, 0x05, 0x00, 0xf4, 0x63, 0x04, - 0x40, 0xe5, 0x1d, 0x05, 0x00, 0x46, 0xe2, 0xdc, 0x83, 0x1c, 0x40, 0x06, - 0x50, 0x00, 0x11, 0xeb, 0x79, 0x04, 0x80, 0x06, 0x4b, 0x01, 0xa0, 0x88, - 0x1c, 0x40, 0x4a, 0x29, 0x9e, 0x54, 0x04, 0x40, 0xa4, 0x06, 0x46, 0xb4, - 0x70, 0xef, 0x04, 0x40, 0x48, 0xba, 0x23, 0xf1, 0x04, 0x00, 0x4b, 0x1f, - 0xa1, 0xf3, 0x04, 0x40, 0x04, 0x5f, 0x07, 0x46, 0x43, 0x6d, 0x14, 0x93, - 0xa6, 0x00, 0xe5, 0x42, 0x04, 0x80, 0x2a, 0x4e, 0x6a, 0x78, 0x85, 0x1c, - 0x00, 0x42, 0x82, 0x20, 0x8a, 0x1c, 0x00, 0xb3, 0x06, 0x42, 0x15, 0x01, - 0x8d, 0xa6, 0x40, 0xe5, 0x46, 0x04, 0x00, 0x42, 0xb0, 0x01, 0x5b, 0x04, - 0x00, 0x42, 0x46, 0x03, 0x91, 0xa6, 0x00, 0x42, 0x15, 0x01, 0x8f, 0xa6, - 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x49, 0x38, 0x2b, 0xad, 0x04, 0x00, - 0x4b, 0xb4, 0x9f, 0x8b, 0xa6, 0x40, 0x49, 0xa2, 0xb9, 0x86, 0x1c, 0x00, - 0x42, 0x77, 0x00, 0x84, 0x1c, 0x00, 0x43, 0xb8, 0x32, 0x87, 0x1c, 0x40, - 0x44, 0xca, 0x7b, 0xd9, 0x04, 0x80, 0x5f, 0x4c, 0x98, 0x8e, 0x8d, 0x04, - 0x00, 0xa8, 0x27, 0x04, 0x0a, 0x71, 0x0d, 0x49, 0x11, 0xc0, 0xaf, 0x04, - 0xc0, 0x00, 0x4c, 0xf5, 0x28, 0xb1, 0x04, 0x40, 0x42, 0x04, 0x00, 0x63, - 0xa6, 0x00, 0xa5, 0x06, 0x44, 0x5a, 0x03, 0x4c, 0x04, 0x40, 0xec, 0x65, - 0xa6, 0x00, 0xed, 0x67, 0xa6, 0x40, 0xe1, 0x48, 0x04, 0x00, 0x43, 0xe6, - 0x17, 0x49, 0x04, 0x00, 0x42, 0x22, 0x00, 0xbb, 0x04, 0x80, 0x19, 0x04, - 0x35, 0x07, 0x06, 0x42, 0x15, 0x01, 0x97, 0xa6, 0x40, 0xe9, 0x39, 0x04, - 0x80, 0x04, 0xf5, 0x5e, 0x04, 0x40, 0x4a, 0xbc, 0xa6, 0x8b, 0x04, 0x40, - 0x4f, 0xee, 0x69, 0x27, 0x05, 0x40, 0x4f, 0xfd, 0x69, 0xdb, 0x04, 0x40, - 0x08, 0xde, 0x14, 0x17, 0x42, 0x22, 0x00, 0x17, 0x05, 0x00, 0x04, 0x41, - 0x0b, 0x01, 0xff, 0x46, 0x58, 0xaf, 0x7b, 0x04, 0x00, 0x45, 0x29, 0x17, - 0x80, 0x1c, 0x40, 0x43, 0x4c, 0xf4, 0x45, 0xa6, 0x00, 0x43, 0xdc, 0x5d, - 0x61, 0xa6, 0x00, 0x42, 0x31, 0x4e, 0x55, 0xa6, 0x00, 0x42, 0x4b, 0x0a, - 0x11, 0x05, 0x40, 0x47, 0xea, 0xc9, 0xcf, 0x04, 0x00, 0xe5, 0x3f, 0x04, - 0x80, 0x06, 0x42, 0x5a, 0x03, 0x71, 0x04, 0x40, 0x06, 0x50, 0x00, 0x01, - 0xff, 0x49, 0x38, 0x2b, 0x25, 0x05, 0x00, 0x4b, 0xb4, 0x9f, 0xa7, 0x04, - 0x40, 0x4f, 0xfd, 0x69, 0xe7, 0x04, 0x00, 0x44, 0xe1, 0x7b, 0x61, 0x04, - 0x80, 0x04, 0xf4, 0x7f, 0x04, 0x40, 0x4b, 0x5b, 0x98, 0x7d, 0x04, 0x40, - 0x47, 0xe5, 0x03, 0x82, 0x1c, 0x00, 0x4a, 0x4a, 0xaa, 0x4f, 0xa6, 0x00, - 0x42, 0x82, 0x20, 0x5a, 0x04, 0x40, 0x47, 0x54, 0x86, 0x69, 0xa6, 0x00, - 0x48, 0x38, 0x92, 0x4b, 0xa6, 0x40, 0x42, 0x22, 0x00, 0x15, 0x05, 0x00, - 0x49, 0x3f, 0x59, 0x67, 0x04, 0x00, 0x42, 0x82, 0x20, 0x59, 0x04, 0x00, - 0x4d, 0x11, 0x87, 0x81, 0x1c, 0x40, 0xe1, 0x3a, 0x04, 0x80, 0x4e, 0x4d, - 0x9d, 0x83, 0xcc, 0x04, 0x00, 0x42, 0x82, 0x20, 0x5c, 0x04, 0x00, 0xaf, - 0x06, 0x42, 0x5a, 0x03, 0x6f, 0x04, 0x40, 0x03, 0xd6, 0xd1, 0x06, 0x43, - 0xc2, 0x80, 0x81, 0x04, 0x40, 0xa4, 0x1e, 0x43, 0x81, 0x20, 0x09, 0x05, - 0x00, 0x43, 0xc7, 0x84, 0x0b, 0x05, 0x00, 0x43, 0xfb, 0x9d, 0x0d, 0x05, - 0x00, 0x43, 0xc7, 0xf4, 0x0f, 0x05, 0x00, 0x43, 0x00, 0xf5, 0x05, 0x05, - 0x40, 0xe5, 0x01, 0x05, 0x00, 0x42, 0x82, 0x20, 0x03, 0x05, 0x00, 0x43, - 0x00, 0xf5, 0x07, 0x05, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x49, 0x38, - 0x2b, 0x9b, 0x04, 0x00, 0x44, 0xac, 0x0e, 0xc4, 0x04, 0x00, 0x46, 0x52, - 0x05, 0x9f, 0x04, 0x00, 0x4f, 0xb7, 0x33, 0x9d, 0x04, 0x40, 0x06, 0x50, - 0x00, 0x54, 0xe5, 0x35, 0x04, 0x80, 0x3e, 0xef, 0x51, 0x04, 0x80, 0x0d, - 0x46, 0xb0, 0xe1, 0x75, 0x04, 0xc0, 0x00, 0x59, 0x0a, 0x23, 0x77, 0x04, - 0x40, 0xb4, 0x01, 0xff, 0xe1, 0x47, 0xa6, 0x00, 0x06, 0xf2, 0x02, 0x01, - 0xff, 0xe1, 0x57, 0xa6, 0x00, 0x47, 0x99, 0xcf, 0x6d, 0x04, 0x00, 0x51, - 0x37, 0x59, 0x5d, 0xa6, 0x00, 0xe5, 0x65, 0x04, 0x00, 0x4a, 0x3e, 0x59, - 0x69, 0x04, 0x00, 0x43, 0xb8, 0x32, 0x53, 0xa6, 0x40, 0x06, 0x50, 0x00, - 0x01, 0xff, 0x45, 0x55, 0x23, 0xd7, 0x04, 0x00, 0x45, 0x17, 0x23, 0x50, - 0x04, 0x40, 0x49, 0xb9, 0x23, 0xe5, 0x04, 0x00, 0x45, 0x17, 0x23, 0x5d, - 0x04, 0x00, 0x46, 0xb4, 0x70, 0xe3, 0x04, 0x40, 0xe1, 0x45, 0x04, 0x80, - 0x06, 0x42, 0x15, 0x01, 0x95, 0xa6, 0x40, 0x06, 0x50, 0x00, 0x06, 0x47, - 0x1d, 0x93, 0x4a, 0x04, 0x40, 0x49, 0x38, 0x2b, 0xb3, 0x04, 0x00, 0x44, - 0xac, 0x0e, 0xfd, 0x04, 0x00, 0x46, 0x52, 0x05, 0xff, 0x04, 0x40, 0x42, - 0xb0, 0x01, 0x33, 0x04, 0x80, 0x06, 0x42, 0x82, 0x20, 0x53, 0x04, 0x40, - 0x06, 0x50, 0x00, 0x01, 0xff, 0x49, 0x38, 0x2b, 0xf7, 0x04, 0x00, 0x4b, - 0xb4, 0x9f, 0x95, 0x04, 0x00, 0x46, 0x52, 0x05, 0x93, 0x04, 0x80, 0x06, - 0x46, 0xe7, 0x68, 0x91, 0x04, 0x40, 0x49, 0xc2, 0x23, 0xfb, 0x04, 0x40, - 0x4f, 0xfd, 0x69, 0xed, 0x04, 0x00, 0xe6, 0x44, 0x04, 0x00, 0xec, 0x3b, - 0x04, 0x80, 0x49, 0xed, 0x3c, 0x04, 0x80, 0x3e, 0xee, 0x3d, 0x04, 0x80, - 0x16, 0xf2, 0x40, 0x04, 0x80, 0x0b, 0xf3, 0x41, 0x04, 0xc0, 0x00, 0x4f, - 0xee, 0x69, 0xab, 0x04, 0x40, 0x4a, 0xc6, 0xa6, 0x8f, 0x04, 0x40, 0x06, - 0x50, 0x00, 0x01, 0xff, 0x49, 0x38, 0x2b, 0xa3, 0x04, 0x00, 0x44, 0xac, - 0x0e, 0xc8, 0x04, 0x00, 0x49, 0xb8, 0x57, 0x29, 0x05, 0x00, 0x4b, 0xb4, - 0x9f, 0x23, 0x05, 0x00, 0x44, 0x8f, 0x17, 0xca, 0x04, 0x40, 0x4a, 0xbc, - 0xa6, 0xce, 0x04, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x49, 0x38, 0x2b, - 0x2f, 0x05, 0x00, 0x44, 0xac, 0x0e, 0x13, 0x05, 0x00, 0x4b, 0xb4, 0x9f, - 0x21, 0x05, 0x00, 0x44, 0x8f, 0x17, 0xc6, 0x04, 0x40, 0x43, 0x6d, 0x14, - 0x2d, 0x05, 0x00, 0xe5, 0x34, 0x04, 0x00, 0x42, 0x82, 0x20, 0x52, 0x04, - 0x80, 0x3b, 0x06, 0x3c, 0x01, 0x2d, 0x42, 0x15, 0x01, 0x81, 0xa6, 0x00, - 0xba, 0x01, 0xff, 0xe5, 0x55, 0x04, 0x80, 0x19, 0x42, 0xb0, 0x01, 0x5f, - 0x04, 0x00, 0x42, 0x15, 0x01, 0x83, 0xa6, 0x00, 0xba, 0x01, 0xff, 0xe5, - 0x89, 0xa6, 0x00, 0x42, 0xb0, 0x01, 0x2b, 0x05, 0x40, 0x42, 0x13, 0x01, - 0x43, 0xa6, 0x40, 0x4b, 0xca, 0x9f, 0x6d, 0xa6, 0x00, 0xef, 0x99, 0xa6, - 0x40, 0x42, 0x78, 0x0f, 0x49, 0xa6, 0x40, 0x43, 0x6d, 0x14, 0x87, 0xa6, - 0x00, 0x42, 0xb0, 0x01, 0x47, 0x04, 0x80, 0x0c, 0x50, 0x38, 0x59, 0x59, - 0xa6, 0x00, 0x48, 0xa1, 0xca, 0x9b, 0xa6, 0x40, 0x06, 0x50, 0x00, 0x01, - 0xff, 0xa4, 0x06, 0x4f, 0xb7, 0x33, 0xb9, 0x04, 0x40, 0x48, 0x39, 0x2b, - 0xb7, 0x04, 0x00, 0x48, 0xba, 0x23, 0xf5, 0x04, 0x40, 0xa1, 0x24, 0xe5, - 0x31, 0x04, 0x00, 0xa9, 0x12, 0x4a, 0xfc, 0xac, 0x5b, 0xa6, 0x00, 0x4a, - 0x9e, 0xb0, 0x4d, 0xa6, 0x00, 0x57, 0x84, 0x08, 0x56, 0x04, 0x40, 0x45, - 0x9b, 0xcf, 0x6b, 0x04, 0x00, 0x49, 0xcc, 0x9f, 0x6b, 0xa6, 0x40, 0x46, - 0x23, 0xcf, 0xe9, 0x04, 0x80, 0x06, 0x48, 0xf1, 0xca, 0xa1, 0x04, 0x40, - 0x4f, 0xfd, 0x69, 0xeb, 0x04, 0x40, 0x06, 0x50, 0x00, 0x23, 0x09, 0xdb, - 0xb6, 0x06, 0x47, 0xf6, 0xd2, 0x1f, 0x05, 0x40, 0x43, 0x6d, 0x14, 0xbd, - 0x04, 0x80, 0x0c, 0x43, 0x4c, 0xf4, 0xe1, 0x04, 0x00, 0x42, 0x22, 0x00, - 0xa9, 0x04, 0x40, 0x4f, 0xee, 0x69, 0xbf, 0x04, 0x40, 0x45, 0x55, 0x23, - 0xd1, 0x04, 0x00, 0x49, 0xb9, 0x23, 0xd3, 0x04, 0x40, 0x4d, 0x4e, 0x86, - 0x6e, 0xa6, 0x00, 0x48, 0xe9, 0xc9, 0xc0, 0x04, 0x00, 0x50, 0x4d, 0x67, - 0x2b, 0x1d, 0x40, 0x06, 0xed, 0x05, 0x17, 0x08, 0x9f, 0x1f, 0x01, 0xff, - 0x44, 0xf5, 0xee, 0xd4, 0x04, 0x00, 0x46, 0x68, 0xdb, 0xa4, 0x04, 0x00, - 0x46, 0x96, 0xe0, 0xb4, 0x04, 0x40, 0xe1, 0x10, 0x04, 0x80, 0x90, 0x09, - 0xa2, 0xd4, 0x08, 0xa3, 0x9f, 0x08, 0xa4, 0xca, 0x07, 0xe5, 0x2d, 0x04, - 0x80, 0xcf, 0x06, 0x44, 0xf1, 0xef, 0x72, 0x04, 0x00, 0xa7, 0x95, 0x06, - 0xa8, 0xeb, 0x05, 0xe9, 0x18, 0x04, 0x80, 0xfb, 0x04, 0x42, 0x82, 0x20, - 0x08, 0x04, 0x00, 0xab, 0x82, 0x04, 0xac, 0xed, 0x03, 0x04, 0xda, 0x18, - 0xdc, 0x03, 0xae, 0xcd, 0x03, 0xef, 0x1e, 0x04, 0x80, 0xb0, 0x03, 0xb0, - 0x91, 0x03, 0x42, 0x43, 0x14, 0x1a, 0x05, 0x00, 0xb2, 0xe0, 0x02, 0xb3, - 0xf1, 0x01, 0xb4, 0xae, 0x01, 0xf5, 0x23, 0x04, 0x80, 0x85, 0x01, 0x42, - 0x32, 0x00, 0x12, 0x04, 0x00, 0x42, 0x15, 0x01, 0x1c, 0x05, 0x00, 0xb9, - 0x46, 0xba, 0x01, 0xff, 0xe5, 0x17, 0x04, 0x80, 0x28, 0xa8, 0x01, 0xff, - 0xe5, 0x16, 0x04, 0x80, 0x06, 0x42, 0x15, 0x01, 0x84, 0xa6, 0x40, 0x06, - 0x50, 0x00, 0x01, 0xff, 0x45, 0x55, 0x23, 0xc1, 0x04, 0x00, 0xa4, 0x01, - 0xff, 0x48, 0x39, 0x2b, 0x96, 0x04, 0x00, 0x48, 0xba, 0x23, 0xdc, 0x04, - 0x40, 0x07, 0x82, 0x07, 0x06, 0x44, 0x59, 0xf1, 0x40, 0xa6, 0x40, 0x48, - 0x39, 0x2b, 0x98, 0x04, 0x00, 0x48, 0xba, 0x23, 0xde, 0x04, 0x40, 0xe1, - 0x2f, 0x04, 0x80, 0x24, 0x43, 0xb7, 0x2b, 0x2b, 0x04, 0x80, 0x0c, 0xe9, - 0x07, 0x04, 0x00, 0xee, 0x5e, 0xa6, 0x00, 0xf5, 0x2e, 0x04, 0x40, 0x06, - 0x50, 0x00, 0x01, 0xff, 0x48, 0x8a, 0x75, 0x50, 0xa6, 0x00, 0x49, 0xb9, - 0x23, 0xf8, 0x04, 0x40, 0xe5, 0x18, 0x05, 0x00, 0xf4, 0x62, 0x04, 0x40, - 0x06, 0x50, 0x00, 0x0b, 0xeb, 0x78, 0x04, 0xc0, 0x00, 0x4a, 0x29, 0x9e, - 0x04, 0x04, 0x40, 0xa4, 0x06, 0x46, 0xb4, 0x70, 0xee, 0x04, 0x40, 0x48, - 0xba, 0x23, 0xf0, 0x04, 0x00, 0x4b, 0x1f, 0xa1, 0xf2, 0x04, 0x40, 0x43, - 0x6d, 0x14, 0x92, 0xa6, 0x00, 0xe5, 0x22, 0x04, 0x80, 0x24, 0x42, 0x82, - 0x20, 0x89, 0x1c, 0x00, 0xb3, 0x06, 0x42, 0x15, 0x01, 0x8c, 0xa6, 0x40, - 0xe5, 0x26, 0x04, 0x00, 0x42, 0xb0, 0x01, 0x0b, 0x04, 0x00, 0x42, 0x46, - 0x03, 0x90, 0xa6, 0x00, 0x42, 0x15, 0x01, 0x8e, 0xa6, 0x40, 0x06, 0x50, - 0x00, 0x01, 0xff, 0x49, 0x38, 0x2b, 0xac, 0x04, 0x00, 0x4b, 0xb4, 0x9f, - 0x8a, 0xa6, 0x40, 0x44, 0xca, 0x7b, 0xd8, 0x04, 0x80, 0x5f, 0x4c, 0x98, - 0x8e, 0x8c, 0x04, 0x00, 0xa8, 0x27, 0x04, 0x0a, 0x71, 0x0d, 0x49, 0x11, - 0xc0, 0xae, 0x04, 0xc0, 0x00, 0x4c, 0xf5, 0x28, 0xb0, 0x04, 0x40, 0x42, - 0x04, 0x00, 0x62, 0xa6, 0x00, 0xa5, 0x06, 0x44, 0x5a, 0x03, 0x2c, 0x04, - 0x40, 0xec, 0x64, 0xa6, 0x00, 0xed, 0x66, 0xa6, 0x40, 0xe1, 0x28, 0x04, - 0x00, 0x43, 0xe6, 0x17, 0x29, 0x04, 0x00, 0x42, 0x22, 0x00, 0xba, 0x04, - 0x80, 0x19, 0x04, 0x35, 0x07, 0x06, 0x42, 0x15, 0x01, 0x96, 0xa6, 0x40, - 0xe9, 0x19, 0x04, 0x80, 0x04, 0xf5, 0x0e, 0x04, 0x40, 0x4a, 0xbc, 0xa6, - 0x8a, 0x04, 0x40, 0x4f, 0xee, 0x69, 0x26, 0x05, 0x40, 0x4f, 0xfd, 0x69, - 0xda, 0x04, 0x40, 0x08, 0xde, 0x14, 0x0c, 0x42, 0x22, 0x00, 0x16, 0x05, - 0x00, 0x4a, 0x54, 0xaf, 0x7a, 0x04, 0x40, 0x43, 0x4c, 0xf4, 0x44, 0xa6, - 0x00, 0x43, 0xdc, 0x5d, 0x60, 0xa6, 0x00, 0x42, 0x31, 0x4e, 0x54, 0xa6, - 0x00, 0x42, 0x4b, 0x0a, 0x10, 0x05, 0x40, 0xe5, 0x1f, 0x04, 0x80, 0x06, - 0x42, 0x5a, 0x03, 0x70, 0x04, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x49, - 0x38, 0x2b, 0x24, 0x05, 0x00, 0x4b, 0xb4, 0x9f, 0xa6, 0x04, 0x40, 0x4f, - 0xfd, 0x69, 0xe6, 0x04, 0x00, 0x44, 0xe1, 0x7b, 0x60, 0x04, 0x80, 0x04, - 0xf4, 0x7e, 0x04, 0x40, 0x4b, 0x5b, 0x98, 0x7c, 0x04, 0x40, 0x4a, 0x4a, - 0xaa, 0x4e, 0xa6, 0x00, 0x42, 0x82, 0x20, 0x0a, 0x04, 0x40, 0x47, 0x54, - 0x86, 0x68, 0xa6, 0x00, 0x48, 0x38, 0x92, 0x4a, 0xa6, 0x40, 0x42, 0x22, - 0x00, 0x14, 0x05, 0x00, 0x49, 0x3f, 0x59, 0x66, 0x04, 0x00, 0x42, 0x82, - 0x20, 0x09, 0x04, 0x40, 0xe1, 0x1a, 0x04, 0x80, 0x4e, 0x4d, 0x9d, 0x83, - 0xcb, 0x04, 0x00, 0x42, 0x82, 0x20, 0x0c, 0x04, 0x00, 0xaf, 0x06, 0x42, - 0x5a, 0x03, 0x6e, 0x04, 0x40, 0x03, 0xd6, 0xd1, 0x06, 0x43, 0xc2, 0x80, - 0x80, 0x04, 0x40, 0xa4, 0x1e, 0x43, 0x81, 0x20, 0x08, 0x05, 0x00, 0x43, - 0xc7, 0x84, 0x0a, 0x05, 0x00, 0x43, 0xfb, 0x9d, 0x0c, 0x05, 0x00, 0x43, - 0xc7, 0xf4, 0x0e, 0x05, 0x00, 0x43, 0x00, 0xf5, 0x04, 0x05, 0x40, 0xe5, - 0x00, 0x05, 0x00, 0x42, 0x82, 0x20, 0x02, 0x05, 0x00, 0x43, 0x00, 0xf5, - 0x06, 0x05, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x49, 0x38, 0x2b, 0x9a, - 0x04, 0x00, 0x44, 0xac, 0x0e, 0xc3, 0x04, 0x00, 0x46, 0x52, 0x05, 0x9e, - 0x04, 0x00, 0x4f, 0xb7, 0x33, 0x9c, 0x04, 0x40, 0x06, 0x50, 0x00, 0x54, - 0xe5, 0x15, 0x04, 0x80, 0x3e, 0xef, 0x01, 0x04, 0x80, 0x0d, 0x46, 0xb0, - 0xe1, 0x74, 0x04, 0xc0, 0x00, 0x59, 0x0a, 0x23, 0x76, 0x04, 0x40, 0xb4, - 0x01, 0xff, 0xe1, 0x46, 0xa6, 0x00, 0x06, 0xf2, 0x02, 0x01, 0xff, 0xe1, - 0x56, 0xa6, 0x00, 0x47, 0x99, 0xcf, 0x6c, 0x04, 0x00, 0x51, 0x37, 0x59, - 0x5c, 0xa6, 0x00, 0xe5, 0x64, 0x04, 0x00, 0x4a, 0x3e, 0x59, 0x68, 0x04, - 0x00, 0x43, 0xb8, 0x32, 0x52, 0xa6, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, - 0x45, 0x55, 0x23, 0xd6, 0x04, 0x00, 0x45, 0x17, 0x23, 0x00, 0x04, 0x40, - 0x49, 0xb9, 0x23, 0xe4, 0x04, 0x00, 0x45, 0x17, 0x23, 0x0d, 0x04, 0x00, - 0x46, 0xb4, 0x70, 0xe2, 0x04, 0x40, 0xe1, 0x25, 0x04, 0x80, 0x06, 0x42, - 0x15, 0x01, 0x94, 0xa6, 0x40, 0x06, 0x50, 0x00, 0x06, 0x47, 0x1d, 0x93, - 0x2a, 0x04, 0x40, 0x49, 0x38, 0x2b, 0xb2, 0x04, 0x00, 0x44, 0xac, 0x0e, - 0xfc, 0x04, 0x00, 0x46, 0x52, 0x05, 0xfe, 0x04, 0x40, 0x42, 0xb0, 0x01, - 0x13, 0x04, 0x80, 0x06, 0x42, 0x82, 0x20, 0x03, 0x04, 0x40, 0x06, 0x50, - 0x00, 0x01, 0xff, 0x49, 0x38, 0x2b, 0xf6, 0x04, 0x00, 0x4b, 0xb4, 0x9f, - 0x94, 0x04, 0x00, 0x46, 0x52, 0x05, 0x92, 0x04, 0x80, 0x06, 0x46, 0xe7, - 0x68, 0x90, 0x04, 0x40, 0x49, 0xc2, 0x23, 0xfa, 0x04, 0x40, 0x4f, 0xfd, - 0x69, 0xec, 0x04, 0x00, 0xe6, 0x24, 0x04, 0x00, 0xec, 0x1b, 0x04, 0x80, - 0x49, 0xed, 0x1c, 0x04, 0x80, 0x3e, 0xee, 0x1d, 0x04, 0x80, 0x16, 0xf2, - 0x20, 0x04, 0x80, 0x0b, 0xf3, 0x21, 0x04, 0xc0, 0x00, 0x4f, 0xee, 0x69, - 0xaa, 0x04, 0x40, 0x4a, 0xc6, 0xa6, 0x8e, 0x04, 0x40, 0x06, 0x50, 0x00, - 0x01, 0xff, 0x49, 0x38, 0x2b, 0xa2, 0x04, 0x00, 0x44, 0xac, 0x0e, 0xc7, - 0x04, 0x00, 0x49, 0xb8, 0x57, 0x28, 0x05, 0x00, 0x4b, 0xb4, 0x9f, 0x22, - 0x05, 0x00, 0x44, 0x8f, 0x17, 0xc9, 0x04, 0x40, 0x4a, 0xbc, 0xa6, 0xcd, - 0x04, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x49, 0x38, 0x2b, 0x2e, 0x05, - 0x00, 0x44, 0xac, 0x0e, 0x12, 0x05, 0x00, 0x4b, 0xb4, 0x9f, 0x20, 0x05, - 0x00, 0x44, 0x8f, 0x17, 0xc5, 0x04, 0x40, 0x43, 0x6d, 0x14, 0x2c, 0x05, - 0x00, 0xe5, 0x14, 0x04, 0x00, 0x42, 0x82, 0x20, 0x02, 0x04, 0x80, 0x3b, - 0x06, 0x3c, 0x01, 0x2d, 0x42, 0x15, 0x01, 0x80, 0xa6, 0x00, 0xba, 0x01, - 0xff, 0xe5, 0x05, 0x04, 0x80, 0x19, 0x42, 0xb0, 0x01, 0x0f, 0x04, 0x00, - 0x42, 0x15, 0x01, 0x82, 0xa6, 0x00, 0xba, 0x01, 0xff, 0xe5, 0x88, 0xa6, - 0x00, 0x42, 0xb0, 0x01, 0x2a, 0x05, 0x40, 0x42, 0x13, 0x01, 0x42, 0xa6, - 0x40, 0x4b, 0xca, 0x9f, 0x6c, 0xa6, 0x00, 0xef, 0x98, 0xa6, 0x40, 0x42, - 0x78, 0x0f, 0x48, 0xa6, 0x40, 0x43, 0x6d, 0x14, 0x86, 0xa6, 0x00, 0x42, - 0xb0, 0x01, 0x27, 0x04, 0x80, 0x0c, 0x50, 0x38, 0x59, 0x58, 0xa6, 0x00, - 0x48, 0xa1, 0xca, 0x9a, 0xa6, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0xa4, - 0x06, 0x4f, 0xb7, 0x33, 0xb8, 0x04, 0x40, 0x48, 0x39, 0x2b, 0xb6, 0x04, - 0x00, 0x48, 0xba, 0x23, 0xf4, 0x04, 0x40, 0xa1, 0x24, 0xe5, 0x11, 0x04, - 0x00, 0xa9, 0x12, 0x4a, 0xfc, 0xac, 0x5a, 0xa6, 0x00, 0x4a, 0x9e, 0xb0, - 0x4c, 0xa6, 0x00, 0x57, 0x84, 0x08, 0x06, 0x04, 0x40, 0x45, 0x9b, 0xcf, - 0x6a, 0x04, 0x00, 0x49, 0xcc, 0x9f, 0x6a, 0xa6, 0x40, 0x46, 0x23, 0xcf, - 0xe8, 0x04, 0x80, 0x06, 0x48, 0xf1, 0xca, 0xa0, 0x04, 0x40, 0x4f, 0xfd, - 0x69, 0xea, 0x04, 0x40, 0x06, 0x50, 0x00, 0x23, 0x09, 0xdb, 0xb6, 0x06, - 0x47, 0xf6, 0xd2, 0x1e, 0x05, 0x40, 0x43, 0x6d, 0x14, 0xbc, 0x04, 0x80, - 0x0c, 0x43, 0x4c, 0xf4, 0xe0, 0x04, 0x00, 0x42, 0x22, 0x00, 0xa8, 0x04, - 0x40, 0x4f, 0xee, 0x69, 0xbe, 0x04, 0x40, 0x45, 0x55, 0x23, 0xd0, 0x04, - 0x00, 0x49, 0xb9, 0x23, 0xd2, 0x04, 0x40, 0x0d, 0x7a, 0x84, 0xbc, 0x03, - 0x10, 0x7d, 0x65, 0x01, 0xff, 0x90, 0x44, 0x91, 0x0d, 0x02, 0xce, 0xf3, - 0x01, 0xff, 0xd1, 0xf1, 0x2f, 0x01, 0xd2, 0xf2, 0x2f, 0x41, 0x90, 0x0f, - 0x91, 0x01, 0xff, 0xd0, 0xee, 0x2f, 0x01, 0xd2, 0xef, 0x2f, 0x01, 0xd4, - 0xf0, 0x2f, 0x41, 0xd0, 0xe5, 0x2f, 0x01, 0xd1, 0xe6, 0x2f, 0x01, 0xd2, - 0xe7, 0x2f, 0x01, 0xd3, 0xe8, 0x2f, 0x01, 0xd4, 0xe9, 0x2f, 0x01, 0xd5, - 0xea, 0x2f, 0x01, 0xd7, 0xeb, 0x2f, 0x01, 0xd8, 0xec, 0x2f, 0x01, 0xd9, - 0xed, 0x2f, 0x41, 0x90, 0xce, 0x02, 0x91, 0xaa, 0x02, 0x92, 0x87, 0x02, - 0x93, 0xe4, 0x01, 0x94, 0xc9, 0x01, 0x95, 0xa2, 0x01, 0x96, 0x7c, 0x97, - 0x51, 0x98, 0x27, 0x99, 0x01, 0xff, 0xd0, 0xdc, 0x2f, 0x01, 0xd1, 0xdd, - 0x2f, 0x01, 0xd2, 0xde, 0x2f, 0x01, 0xd4, 0xdf, 0x2f, 0x01, 0xd5, 0xe0, - 0x2f, 0x01, 0xd6, 0xe1, 0x2f, 0x01, 0xd7, 0xe2, 0x2f, 0x01, 0xd8, 0xe3, - 0x2f, 0x01, 0xd9, 0xe4, 0x2f, 0x41, 0xd0, 0xd2, 0x2f, 0x01, 0xd1, 0xd3, - 0x2f, 0x01, 0xd2, 0xd4, 0x2f, 0x01, 0xd3, 0xd5, 0x2f, 0x01, 0xd4, 0xd6, - 0x2f, 0x01, 0xd5, 0xd7, 0x2f, 0x01, 0xd6, 0xd8, 0x2f, 0x01, 0xd7, 0xd9, - 0x2f, 0x01, 0xd8, 0xda, 0x2f, 0x01, 0xd9, 0xdb, 0x2f, 0x41, 0xd0, 0xc8, - 0x2f, 0x01, 0xd1, 0xc9, 0x2f, 0x01, 0xd2, 0xca, 0x2f, 0x01, 0xd3, 0xcb, - 0x2f, 0x01, 0xd4, 0xcc, 0x2f, 0x01, 0xd5, 0xcd, 0x2f, 0x81, 0x0c, 0xd6, - 0xcf, 0x2f, 0x01, 0xd8, 0xd0, 0x2f, 0x01, 0xd9, 0xd1, 0x2f, 0x41, 0xe2, - 0xce, 0x2f, 0x41, 0xd0, 0xbf, 0x2f, 0x01, 0xd1, 0xc0, 0x2f, 0x01, 0xd2, - 0xc1, 0x2f, 0x01, 0xd3, 0xc2, 0x2f, 0x01, 0xd4, 0xc3, 0x2f, 0x01, 0xd6, - 0xc4, 0x2f, 0x01, 0xd7, 0xc5, 0x2f, 0x01, 0xd8, 0xc6, 0x2f, 0x01, 0xd9, - 0xc7, 0x2f, 0x41, 0xd0, 0xb6, 0x2f, 0x01, 0xd1, 0xb7, 0x2f, 0x01, 0xd2, - 0xb8, 0x2f, 0x01, 0xd3, 0xb9, 0x2f, 0x01, 0xd4, 0xba, 0x2f, 0x01, 0xd5, - 0xbb, 0x2f, 0x01, 0xd6, 0xbc, 0x2f, 0x01, 0xd8, 0xbd, 0x2f, 0x01, 0xd9, - 0xbe, 0x2f, 0x41, 0xd0, 0xb0, 0x2f, 0x01, 0xd1, 0xb1, 0x2f, 0x01, 0xd4, - 0xb2, 0x2f, 0x01, 0xd6, 0xb3, 0x2f, 0x01, 0xd7, 0xb4, 0x2f, 0x01, 0xd9, - 0xb5, 0x2f, 0x41, 0xd0, 0xa8, 0x2f, 0x01, 0xd3, 0xa9, 0x2f, 0x01, 0xd4, - 0xaa, 0x2f, 0x01, 0xd5, 0xab, 0x2f, 0x01, 0xd6, 0xac, 0x2f, 0x01, 0xd7, - 0xad, 0x2f, 0x01, 0xd8, 0xae, 0x2f, 0x01, 0xd9, 0xaf, 0x2f, 0x41, 0xd1, - 0xa0, 0x2f, 0x01, 0xd3, 0xa1, 0x2f, 0x01, 0xd4, 0xa2, 0x2f, 0x01, 0xd5, - 0xa3, 0x2f, 0x01, 0xd6, 0xa4, 0x2f, 0x01, 0xd7, 0xa5, 0x2f, 0x01, 0xd8, - 0xa6, 0x2f, 0x01, 0xd9, 0xa7, 0x2f, 0x41, 0xd0, 0x98, 0x2f, 0x01, 0xd1, - 0x99, 0x2f, 0x01, 0xd2, 0x9a, 0x2f, 0x81, 0x10, 0xd3, 0x9c, 0x2f, 0x01, - 0xd5, 0x9d, 0x2f, 0x01, 0xd7, 0x9e, 0x2f, 0x01, 0xd9, 0x9f, 0x2f, 0x41, - 0xe2, 0x9b, 0x2f, 0x41, 0xd1, 0x90, 0x2f, 0x01, 0xd2, 0x91, 0x2f, 0x01, - 0xd4, 0x92, 0x2f, 0x01, 0xd5, 0x93, 0x2f, 0x01, 0xd6, 0x94, 0x2f, 0x01, - 0xd7, 0x95, 0x2f, 0x01, 0xd8, 0x96, 0x2f, 0x01, 0xd9, 0x97, 0x2f, 0x41, - 0xe1, 0x00, 0x08, 0x01, 0xe5, 0x01, 0x08, 0x01, 0xe9, 0x02, 0x08, 0x01, - 0xaa, 0xe3, 0x01, 0xab, 0xcc, 0x01, 0xac, 0xb5, 0x01, 0xad, 0x9e, 0x01, - 0xae, 0x87, 0x01, 0xef, 0x03, 0x08, 0x01, 0xb0, 0x6d, 0xb2, 0x57, 0xb3, - 0x41, 0xb4, 0x2b, 0xf5, 0x04, 0x08, 0x01, 0xb7, 0x15, 0xb8, 0x0b, 0xba, - 0x01, 0xff, 0xe1, 0x3c, 0x08, 0x01, 0xef, 0x3f, 0x08, 0x41, 0xe1, 0x37, - 0x08, 0x01, 0xe5, 0x38, 0x08, 0x41, 0xe1, 0x32, 0x08, 0x01, 0xe5, 0x33, - 0x08, 0x01, 0xe9, 0x34, 0x08, 0x01, 0xef, 0x35, 0x08, 0x41, 0xe1, 0x2d, - 0x08, 0x01, 0xe5, 0x2e, 0x08, 0x01, 0xe9, 0x2f, 0x08, 0x01, 0xef, 0x30, - 0x08, 0x01, 0xf5, 0x31, 0x08, 0x41, 0xe1, 0x28, 0x08, 0x01, 0xe5, 0x29, - 0x08, 0x01, 0xe9, 0x2a, 0x08, 0x01, 0xef, 0x2b, 0x08, 0x01, 0xf5, 0x2c, - 0x08, 0x41, 0xe1, 0x23, 0x08, 0x01, 0xe5, 0x24, 0x08, 0x01, 0xe9, 0x25, - 0x08, 0x01, 0xef, 0x26, 0x08, 0x01, 0xf5, 0x27, 0x08, 0x41, 0xe1, 0x1e, - 0x08, 0x01, 0xe5, 0x1f, 0x08, 0x01, 0xe9, 0x20, 0x08, 0x01, 0xef, 0x21, - 0x08, 0x01, 0xf5, 0x22, 0x08, 0x41, 0xe1, 0x19, 0x08, 0x01, 0xe5, 0x1a, - 0x08, 0x01, 0xe9, 0x1b, 0x08, 0x01, 0xef, 0x1c, 0x08, 0x01, 0xf5, 0x1d, - 0x08, 0x41, 0xe1, 0x14, 0x08, 0x01, 0xe5, 0x15, 0x08, 0x01, 0xe9, 0x16, - 0x08, 0x01, 0xef, 0x17, 0x08, 0x01, 0xf5, 0x18, 0x08, 0x41, 0xe1, 0x0f, - 0x08, 0x01, 0xe5, 0x10, 0x08, 0x01, 0xe9, 0x11, 0x08, 0x01, 0xef, 0x12, - 0x08, 0x01, 0xf5, 0x13, 0x08, 0x41, 0xe1, 0x0a, 0x08, 0x01, 0xe5, 0x0b, - 0x08, 0x01, 0xe9, 0x0c, 0x08, 0x01, 0xef, 0x0d, 0x08, 0x01, 0xf5, 0x0e, - 0x08, 0x41, 0xe1, 0x05, 0x08, 0x01, 0xef, 0x08, 0x08, 0x41, 0x47, 0xac, - 0xb7, 0x1b, 0x22, 0x00, 0x46, 0xe4, 0xda, 0x52, 0xf9, 0x01, 0x08, 0xc1, - 0xc8, 0x80, 0x01, 0xb0, 0x64, 0xb2, 0x16, 0x02, 0x60, 0x01, 0x06, 0x49, - 0xa5, 0xbf, 0x69, 0xf9, 0x41, 0x43, 0xaa, 0x01, 0x6e, 0xf3, 0x01, 0x43, - 0x0b, 0x67, 0xc3, 0xf6, 0x41, 0xac, 0x1e, 0xb2, 0x06, 0x60, 0x74, 0x10, - 0x61, 0x27, 0x40, 0x05, 0x5f, 0x41, 0x06, 0x4a, 0xf0, 0xb3, 0x5b, 0xf3, - 0x41, 0x48, 0x31, 0xc6, 0xb1, 0xf4, 0x01, 0x44, 0x5a, 0x03, 0xa4, 0x00, - 0x40, 0x49, 0xb9, 0xba, 0x4c, 0xf9, 0x01, 0x02, 0x09, 0x00, 0x01, 0xff, - 0x51, 0xc0, 0x58, 0xaa, 0x23, 0x00, 0x02, 0x13, 0x01, 0x01, 0xff, 0x06, - 0x2f, 0x22, 0x06, 0x42, 0x1f, 0x00, 0xb0, 0x27, 0x40, 0x43, 0x1a, 0x00, - 0xcf, 0x22, 0x00, 0x42, 0x0c, 0x00, 0xce, 0x22, 0x40, 0x80, 0x0c, 0x44, - 0x7a, 0x2c, 0xc1, 0xf9, 0x01, 0x43, 0x3f, 0x66, 0xe0, 0x2b, 0x40, 0x4f, - 0xcc, 0x5f, 0xfe, 0x26, 0x00, 0x4a, 0xbe, 0xb3, 0x64, 0xf9, 0x41, 0x0d, - 0xb6, 0x86, 0xfa, 0x37, 0x11, 0x66, 0x5d, 0xd3, 0x37, 0x05, 0x5a, 0x03, - 0x01, 0xff, 0xe1, 0x00, 0x20, 0x81, 0xf8, 0x33, 0xa2, 0xd1, 0x32, 0xa4, - 0x9b, 0x2e, 0xe5, 0x8a, 0x20, 0x81, 0x9f, 0x2b, 0xa7, 0xe1, 0x23, 0xa8, - 0xc2, 0x22, 0xe9, 0x3f, 0x21, 0x81, 0xb3, 0x21, 0xab, 0xad, 0x1c, 0xac, - 0x86, 0x13, 0xad, 0xab, 0x11, 0xae, 0xaa, 0x0d, 0xb0, 0xa0, 0x0c, 0xb2, - 0x8c, 0x0c, 0xb3, 0x95, 0x07, 0xb4, 0xb2, 0x05, 0xf5, 0x0b, 0x23, 0x81, - 0x77, 0xba, 0x01, 0xff, 0xe1, 0x5d, 0x23, 0x81, 0x53, 0x42, 0x94, 0x9b, - 0x62, 0x23, 0x01, 0xe9, 0x63, 0x23, 0x81, 0x29, 0xf5, 0x6a, 0x23, 0xc1, - 0x00, 0x51, 0x39, 0x57, 0x42, 0x25, 0x01, 0xd5, 0x6b, 0x23, 0x81, 0x0a, - 0x43, 0x22, 0x36, 0x6d, 0x23, 0x01, 0xed, 0x6e, 0x23, 0x41, 0x07, 0x27, - 0x02, 0x01, 0xff, 0xe1, 0x6c, 0x23, 0x01, 0x4f, 0xa8, 0x73, 0x43, 0x25, - 0x41, 0x48, 0x71, 0xc2, 0x64, 0x23, 0x01, 0xd3, 0x65, 0x23, 0x01, 0xe2, - 0x66, 0x23, 0x81, 0x0a, 0xe7, 0x68, 0x23, 0x01, 0x42, 0x8f, 0xf3, 0x69, - 0x23, 0x41, 0x4a, 0xf4, 0xa5, 0x67, 0x23, 0x41, 0x80, 0x0e, 0xd7, 0x41, - 0x25, 0x01, 0xe7, 0x60, 0x23, 0x01, 0x42, 0xd4, 0xf4, 0x61, 0x23, 0x41, - 0x51, 0xff, 0x5d, 0x5f, 0x23, 0x01, 0x44, 0x89, 0x60, 0x5e, 0x23, 0x41, - 0x80, 0x8c, 0x04, 0xd2, 0x11, 0x23, 0x01, 0xe2, 0x12, 0x23, 0x01, 0xe4, - 0x13, 0x23, 0x81, 0xbf, 0x03, 0xed, 0x1d, 0x23, 0x81, 0xfa, 0x02, 0xee, - 0x26, 0x23, 0x81, 0xee, 0x02, 0xf2, 0x28, 0x23, 0x81, 0x46, 0x42, 0xa4, - 0x02, 0x51, 0x23, 0x81, 0x18, 0x44, 0xe5, 0xf2, 0x59, 0x23, 0x01, 0xba, - 0x01, 0xff, 0xd3, 0x5a, 0x23, 0x81, 0x04, 0xf5, 0x5c, 0x23, 0x41, 0x4d, - 0xc1, 0x7f, 0x5b, 0x23, 0x41, 0x07, 0x27, 0x02, 0x0e, 0xd2, 0x57, 0x23, - 0x01, 0x43, 0xd3, 0xf4, 0x58, 0x23, 0x01, 0xf8, 0x56, 0x23, 0x41, 0xe1, - 0x52, 0x23, 0x01, 0x42, 0xfe, 0x03, 0x53, 0x23, 0x81, 0x06, 0x44, 0x17, - 0x45, 0x55, 0x23, 0x41, 0xf2, 0x54, 0x23, 0x41, 0x80, 0x94, 0x02, 0xd2, - 0x2b, 0x23, 0x81, 0xc1, 0x01, 0xd4, 0x34, 0x23, 0x01, 0xe9, 0x35, 0x23, - 0x81, 0xb3, 0x01, 0xf5, 0x37, 0x23, 0xc1, 0x00, 0x07, 0x27, 0x02, 0x0d, - 0x42, 0xf0, 0x10, 0x4f, 0x23, 0xc1, 0x00, 0x48, 0x27, 0x02, 0x50, 0x23, - 0x41, 0xe1, 0x38, 0x23, 0x81, 0x91, 0x01, 0x43, 0x16, 0x00, 0x3a, 0x23, - 0x01, 0xa4, 0x7d, 0xa7, 0x64, 0x42, 0x22, 0x00, 0x41, 0x23, 0x01, 0xa9, - 0x4c, 0x42, 0x45, 0x00, 0x45, 0x23, 0x01, 0xac, 0x33, 0x43, 0xcb, 0x13, - 0x47, 0x23, 0x01, 0x42, 0xbb, 0x09, 0x48, 0x23, 0x01, 0xb3, 0x19, 0x42, - 0x5c, 0x01, 0x4b, 0x23, 0x01, 0xb5, 0x01, 0xff, 0x49, 0xb6, 0xb4, 0x4c, - 0x23, 0x01, 0xe4, 0x4d, 0x23, 0x01, 0x44, 0x10, 0xcc, 0x4e, 0x23, 0x41, - 0x42, 0xb0, 0x01, 0x49, 0x23, 0x01, 0x43, 0x8c, 0x69, 0x4a, 0x23, 0x41, - 0x46, 0xc4, 0xd9, 0x3f, 0x25, 0x01, 0xb5, 0x01, 0xff, 0xd3, 0x40, 0x25, - 0x01, 0xed, 0x46, 0x23, 0x41, 0x42, 0xf1, 0x06, 0x42, 0x23, 0x01, 0xed, - 0x43, 0x23, 0x01, 0x42, 0xa4, 0x02, 0x44, 0x23, 0x41, 0xe1, 0x3c, 0x23, - 0x81, 0x04, 0xf5, 0x40, 0x23, 0x41, 0xec, 0x3d, 0x23, 0x01, 0x47, 0x96, - 0x60, 0x3e, 0x23, 0x01, 0xf2, 0x3f, 0x23, 0x41, 0x44, 0x31, 0xef, 0x3e, - 0x25, 0x01, 0x42, 0x42, 0x0b, 0x3b, 0x23, 0x41, 0x45, 0x0d, 0xda, 0x39, - 0x23, 0x41, 0xd3, 0x36, 0x23, 0x41, 0x80, 0x01, 0xff, 0x48, 0x60, 0x23, - 0x3c, 0x25, 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, 0xa1, 0x29, 0x42, 0x22, - 0x00, 0x2f, 0x23, 0x01, 0x43, 0xde, 0x22, 0x30, 0x23, 0x01, 0xb5, 0x01, - 0xff, 0xd2, 0x31, 0x23, 0x81, 0x04, 0xe4, 0x3d, 0x25, 0x41, 0x06, 0x72, - 0x28, 0x01, 0xff, 0x43, 0xf9, 0x03, 0x32, 0x23, 0x01, 0x42, 0xe5, 0x06, - 0x33, 0x23, 0x41, 0x06, 0x72, 0x28, 0x04, 0xec, 0x2e, 0x23, 0x41, 0x42, - 0x22, 0x00, 0x2c, 0x23, 0x01, 0x42, 0x2a, 0x05, 0x2d, 0x23, 0x41, 0x4b, - 0xad, 0x9a, 0x29, 0x23, 0x01, 0x47, 0x30, 0x7c, 0x2a, 0x23, 0x41, 0x45, - 0xd6, 0x3f, 0x27, 0x23, 0x41, 0x07, 0x27, 0x02, 0x1e, 0x43, 0x35, 0x16, - 0x22, 0x23, 0x01, 0x42, 0x48, 0x04, 0x23, 0x23, 0xc1, 0x00, 0x07, 0x27, - 0x02, 0x01, 0xff, 0x46, 0x1b, 0x02, 0x24, 0x23, 0x01, 0x42, 0xbb, 0x09, - 0x25, 0x23, 0x41, 0x45, 0x22, 0x02, 0x1e, 0x23, 0x01, 0x42, 0x2a, 0x02, - 0x98, 0x23, 0x81, 0x0a, 0x44, 0x50, 0x57, 0x20, 0x23, 0x01, 0xf5, 0x21, - 0x23, 0x41, 0x48, 0xdb, 0x57, 0x1f, 0x23, 0x41, 0x80, 0x06, 0x42, 0xd2, - 0x0e, 0x1c, 0x23, 0x41, 0x44, 0xd7, 0x3f, 0x19, 0x23, 0x01, 0x46, 0x9c, - 0xdd, 0x14, 0x23, 0x01, 0x47, 0x30, 0x7c, 0x1a, 0x23, 0x81, 0x1e, 0x06, - 0x28, 0x02, 0x01, 0xff, 0x43, 0xf0, 0x70, 0x15, 0x23, 0x01, 0x42, 0x7d, - 0x02, 0x16, 0x23, 0x01, 0x4f, 0x20, 0x74, 0x17, 0x23, 0xc1, 0x00, 0x45, - 0xd6, 0x3f, 0x18, 0x23, 0x41, 0x4a, 0x4d, 0x9d, 0x1b, 0x23, 0x41, 0x43, - 0x01, 0x7b, 0x0c, 0x23, 0x01, 0x07, 0x61, 0x22, 0x0b, 0xf5, 0x99, 0x23, - 0xc1, 0x00, 0x42, 0x2d, 0x02, 0x0d, 0x23, 0x41, 0x57, 0x6d, 0x30, 0x0e, - 0x23, 0x01, 0x4c, 0xa0, 0x95, 0x0f, 0x23, 0x01, 0x5a, 0x56, 0x22, 0x10, - 0x23, 0x41, 0xe1, 0xeb, 0x22, 0x81, 0x69, 0xe5, 0xfc, 0x22, 0x81, 0x5e, - 0xe9, 0xfe, 0x22, 0x81, 0x30, 0xf5, 0x05, 0x23, 0xc1, 0x00, 0x42, 0xd3, - 0x0e, 0x06, 0x23, 0x01, 0xeb, 0x07, 0x23, 0x01, 0xed, 0x08, 0x23, 0x81, - 0x0b, 0xf2, 0x09, 0x23, 0xc1, 0x00, 0x54, 0xdf, 0x3f, 0x0a, 0x23, 0x41, - 0x07, 0x27, 0x02, 0x01, 0xff, 0x49, 0x94, 0x60, 0x3a, 0x25, 0x01, 0x4a, - 0xa8, 0x73, 0x3b, 0x25, 0x41, 0x45, 0x88, 0x60, 0xff, 0x22, 0x01, 0xd2, - 0x97, 0x23, 0x01, 0xec, 0x00, 0x23, 0x01, 0xf2, 0x01, 0x23, 0xc1, 0x00, - 0x80, 0x01, 0xff, 0x48, 0xc9, 0xc9, 0x03, 0x23, 0x81, 0x06, 0x4a, 0x11, - 0x45, 0x02, 0x23, 0x41, 0x5a, 0x7a, 0x1e, 0x04, 0x23, 0x41, 0x45, 0xd6, - 0x3f, 0xfd, 0x22, 0x41, 0x80, 0x53, 0xe2, 0xf0, 0x22, 0x81, 0x3f, 0xe7, - 0xf3, 0x22, 0x81, 0x11, 0x42, 0x19, 0x45, 0xfa, 0x22, 0x81, 0x04, 0xf2, - 0xfb, 0x22, 0x41, 0x49, 0xd1, 0xb4, 0x39, 0x25, 0x41, 0x07, 0x27, 0x02, - 0x01, 0xff, 0x42, 0xe5, 0x06, 0xf4, 0x22, 0x01, 0x43, 0x01, 0x7b, 0xf5, - 0x22, 0x01, 0x02, 0xa4, 0x02, 0x0c, 0x44, 0xd1, 0x0e, 0xf8, 0x22, 0x01, - 0x42, 0xb2, 0x0c, 0xf9, 0x22, 0x41, 0xe5, 0xf6, 0x22, 0x01, 0xf5, 0xf7, - 0x22, 0x41, 0x80, 0x01, 0xff, 0x62, 0xbc, 0x0c, 0xf1, 0x22, 0x01, 0x47, - 0xd6, 0x05, 0xf2, 0x22, 0x41, 0x48, 0x3c, 0x0d, 0xec, 0x22, 0x01, 0x44, - 0xd7, 0x3f, 0xef, 0x22, 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, 0x42, 0x49, - 0x00, 0xed, 0x22, 0x01, 0x42, 0x7d, 0x02, 0xee, 0x22, 0x41, 0xe1, 0x93, - 0x22, 0x81, 0xb3, 0x03, 0xa8, 0x5d, 0xe9, 0xdb, 0x22, 0x81, 0x2e, 0xf5, - 0xe2, 0x22, 0xc1, 0x00, 0x48, 0xa3, 0x95, 0xe3, 0x22, 0x01, 0xe4, 0xe4, - 0x22, 0x81, 0x1a, 0x43, 0x41, 0x00, 0xe6, 0x22, 0x01, 0xed, 0xe7, 0x22, - 0x81, 0x09, 0xf2, 0xe9, 0x22, 0xc1, 0x00, 0xd9, 0xea, 0x22, 0x41, 0x43, - 0xf9, 0x03, 0xe8, 0x22, 0x41, 0xd2, 0xe5, 0x22, 0x41, 0x80, 0x1c, 0xe7, - 0xdd, 0x22, 0x81, 0x0c, 0x42, 0x66, 0xac, 0xe0, 0x22, 0x01, 0x43, 0x1d, - 0xeb, 0xe1, 0x22, 0x41, 0xd4, 0xde, 0x22, 0xc1, 0x00, 0x4f, 0x85, 0x69, - 0xdf, 0x22, 0x41, 0x44, 0xd7, 0x3f, 0xdc, 0x22, 0x01, 0x4a, 0x11, 0x45, - 0x38, 0x25, 0x41, 0xe1, 0xad, 0x22, 0x81, 0x80, 0x02, 0xe5, 0xba, 0x22, - 0x81, 0xaa, 0x01, 0xa9, 0x27, 0xf5, 0xd7, 0x22, 0xc1, 0x00, 0x52, 0x70, - 0x4f, 0xd8, 0x22, 0x01, 0xd2, 0xd9, 0x22, 0x81, 0x06, 0x43, 0x22, 0x36, - 0xda, 0x22, 0x41, 0x06, 0x72, 0x28, 0x01, 0xff, 0x4c, 0x68, 0x8e, 0x36, - 0x25, 0x01, 0x4b, 0x94, 0x9b, 0x37, 0x25, 0x41, 0xe4, 0xc3, 0x22, 0x81, - 0x6d, 0xed, 0xc6, 0x22, 0x81, 0x20, 0x43, 0x4e, 0x09, 0xd2, 0x22, 0x01, - 0xf2, 0xd3, 0x22, 0x81, 0x06, 0x42, 0x12, 0x00, 0xd6, 0x22, 0x41, 0x80, - 0x01, 0xff, 0x56, 0x2e, 0x36, 0xd5, 0x22, 0x01, 0x44, 0x89, 0x60, 0xd4, - 0x22, 0x41, 0x07, 0x27, 0x02, 0x01, 0xff, 0xe1, 0xc7, 0x22, 0x01, 0xa2, - 0x31, 0x43, 0x04, 0x06, 0xca, 0x22, 0x01, 0x43, 0x88, 0x1e, 0xcb, 0x22, - 0x01, 0x43, 0xf0, 0x06, 0xcc, 0x22, 0x81, 0x18, 0x46, 0x9c, 0xdd, 0xce, - 0x22, 0x01, 0x43, 0x97, 0xf4, 0xcf, 0x22, 0x01, 0x43, 0xb3, 0xb6, 0xd0, - 0x22, 0x01, 0x43, 0x65, 0x0d, 0xd1, 0x22, 0x41, 0x45, 0xd6, 0x3f, 0xcd, - 0x22, 0x41, 0x42, 0x13, 0x00, 0xc8, 0x22, 0x01, 0x44, 0xb2, 0x97, 0xc9, - 0x22, 0x41, 0x07, 0x27, 0x02, 0x01, 0xff, 0xe1, 0xc4, 0x22, 0x01, 0x42, - 0x29, 0x02, 0xc5, 0x22, 0x41, 0x80, 0x1b, 0x42, 0x3d, 0xf5, 0xbe, 0x22, - 0x01, 0xee, 0xbf, 0x22, 0x01, 0x42, 0xa4, 0x02, 0xc0, 0x22, 0xc1, 0x00, - 0xd2, 0xc1, 0x22, 0x01, 0x43, 0xb0, 0x00, 0xc2, 0x22, 0x41, 0x42, 0x41, - 0x00, 0xbb, 0x22, 0x01, 0x48, 0xc1, 0xc9, 0x32, 0x25, 0x81, 0x17, 0x05, - 0x73, 0x28, 0x01, 0xff, 0x44, 0x7d, 0xf0, 0x33, 0x25, 0x01, 0x44, 0x7d, - 0xf1, 0x34, 0x25, 0x01, 0x43, 0xf3, 0x4b, 0x35, 0x25, 0x41, 0x80, 0x01, - 0xff, 0x59, 0x7b, 0x1e, 0xbc, 0x22, 0x01, 0x59, 0x8e, 0x26, 0xbd, 0x22, - 0x41, 0xd3, 0xae, 0x22, 0x81, 0x17, 0xd6, 0xb7, 0x22, 0x81, 0x0c, 0x42, - 0xe7, 0xf3, 0xb8, 0x22, 0x01, 0x42, 0xc5, 0x42, 0xb9, 0x22, 0x41, 0x45, - 0x88, 0x60, 0x31, 0x25, 0x41, 0x07, 0x27, 0x02, 0x01, 0xff, 0xe1, 0xaf, - 0x22, 0x01, 0x43, 0xf0, 0x70, 0xb0, 0x22, 0x01, 0x44, 0x0c, 0x45, 0xb1, - 0x22, 0x01, 0x42, 0xcd, 0x05, 0xb2, 0x22, 0x01, 0x44, 0x0d, 0x67, 0xb3, - 0x22, 0x01, 0x43, 0x5c, 0x01, 0xb4, 0x22, 0x01, 0xf5, 0xb5, 0x22, 0xc1, - 0x00, 0x47, 0x72, 0x28, 0xb6, 0x22, 0x41, 0xe7, 0x95, 0x22, 0x81, 0x15, - 0xec, 0xa9, 0x22, 0x81, 0x0a, 0x44, 0x9d, 0xf1, 0xab, 0x22, 0x01, 0xf2, - 0xac, 0x22, 0x41, 0x51, 0x17, 0x57, 0xaa, 0x22, 0x41, 0x80, 0x01, 0xff, - 0x44, 0xd7, 0x3f, 0xa8, 0x22, 0x81, 0x90, 0x01, 0x47, 0x42, 0xc2, 0x94, - 0x22, 0x01, 0x48, 0xb9, 0xc9, 0xa7, 0x22, 0x01, 0x06, 0x28, 0x02, 0x01, - 0xff, 0xe1, 0x96, 0x22, 0x01, 0x42, 0x6c, 0x02, 0x97, 0x22, 0x81, 0x70, - 0x42, 0x92, 0x01, 0x2e, 0x25, 0x01, 0x42, 0x22, 0x00, 0x99, 0x22, 0x01, - 0x48, 0xd7, 0x69, 0x96, 0x23, 0x01, 0xab, 0x50, 0x43, 0xaa, 0xb4, 0x9c, - 0x22, 0x01, 0x42, 0x7d, 0x02, 0x9d, 0x22, 0x01, 0x43, 0xde, 0x22, 0x9e, - 0x22, 0x01, 0xb3, 0x27, 0x02, 0x12, 0x00, 0x19, 0xb5, 0x01, 0xff, 0xd2, - 0xa2, 0x22, 0x01, 0xe2, 0xa3, 0x22, 0x01, 0xed, 0xa4, 0x22, 0x01, 0xf2, - 0xa5, 0x22, 0x01, 0x42, 0xa4, 0x02, 0xa6, 0x22, 0x41, 0xe2, 0xa1, 0x22, - 0x01, 0x42, 0x19, 0x45, 0x30, 0x25, 0x41, 0x42, 0x13, 0x00, 0x9f, 0x22, - 0x01, 0xa8, 0x01, 0xff, 0x49, 0x16, 0xb8, 0x2f, 0x25, 0x01, 0x42, 0x03, - 0x00, 0xa0, 0x22, 0x41, 0x42, 0x6d, 0x00, 0x9a, 0x22, 0x01, 0x42, 0x42, - 0x00, 0x9b, 0x22, 0x41, 0xe2, 0x98, 0x22, 0x41, 0x49, 0x10, 0xb5, 0x2d, - 0x25, 0x41, 0xe1, 0x8f, 0x22, 0x81, 0x08, 0xe9, 0x91, 0x22, 0x01, 0xf5, - 0x92, 0x22, 0x41, 0xe2, 0x90, 0x22, 0x41, 0xe1, 0x7a, 0x22, 0x81, 0x76, - 0x44, 0x72, 0x75, 0x7e, 0x22, 0x81, 0x69, 0xe9, 0x7f, 0x22, 0xc1, 0x00, - 0x80, 0x2e, 0xb2, 0x01, 0xff, 0xd2, 0x95, 0x23, 0x01, 0x42, 0x3f, 0x00, - 0x8a, 0x22, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x4e, 0x8c, 0x7a, 0x8e, 0x22, - 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, 0x43, 0x1e, 0x02, 0x8b, 0x22, 0x01, - 0x42, 0xb2, 0x0c, 0x8c, 0x22, 0x01, 0x42, 0x59, 0x00, 0x8d, 0x22, 0x41, - 0x4b, 0xa2, 0x9a, 0x89, 0x22, 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, 0xe1, - 0x80, 0x22, 0x81, 0x20, 0xa2, 0x16, 0xe5, 0x84, 0x22, 0x01, 0xe9, 0x85, - 0x22, 0x81, 0x09, 0xf5, 0x87, 0x22, 0xc1, 0x00, 0xd2, 0x88, 0x22, 0x41, - 0xe2, 0x86, 0x22, 0x41, 0xe9, 0x82, 0x22, 0x01, 0xf5, 0x83, 0x22, 0x41, - 0xe2, 0x81, 0x22, 0x41, 0x49, 0x3b, 0x0d, 0x94, 0x23, 0x41, 0xe4, 0x7b, - 0x22, 0x01, 0xee, 0x7c, 0x22, 0x01, 0xf0, 0x7d, 0x22, 0x41, 0xe1, 0x3e, - 0x22, 0x81, 0xc2, 0x03, 0xe5, 0x48, 0x22, 0x81, 0xa4, 0x03, 0xe9, 0x4c, - 0x22, 0x81, 0xbc, 0x01, 0xf5, 0x61, 0x22, 0xc1, 0x00, 0x42, 0x1f, 0x36, - 0x62, 0x22, 0x81, 0x9a, 0x01, 0xee, 0x63, 0x22, 0xc1, 0x00, 0x80, 0x57, - 0x42, 0xb3, 0x52, 0x6d, 0x22, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x0a, 0x66, - 0xa7, 0x0d, 0x4f, 0x25, 0x6f, 0x78, 0x22, 0xc1, 0x00, 0x42, 0x2d, 0x02, - 0x79, 0x22, 0x41, 0x46, 0x0c, 0xda, 0x6e, 0x22, 0x01, 0x42, 0xe5, 0x06, - 0x6f, 0x22, 0x01, 0x43, 0x68, 0x8e, 0x70, 0x22, 0x01, 0x43, 0x01, 0x7b, - 0x71, 0x22, 0x01, 0x48, 0xd7, 0x69, 0x72, 0x22, 0x01, 0x44, 0xe1, 0xf0, - 0x73, 0x22, 0x01, 0x42, 0x74, 0x00, 0x74, 0x22, 0x01, 0x42, 0xcd, 0x05, - 0x75, 0x22, 0x01, 0x45, 0x1b, 0xeb, 0x76, 0x22, 0x01, 0x42, 0x0f, 0x67, - 0x77, 0x22, 0x41, 0x4c, 0xcc, 0x8d, 0x6b, 0x22, 0x81, 0x2f, 0x0c, 0xe2, - 0x22, 0x0c, 0x48, 0xd9, 0x22, 0x6a, 0x22, 0x01, 0x44, 0x89, 0x60, 0x69, - 0x22, 0x41, 0x43, 0x88, 0x1e, 0x64, 0x22, 0x01, 0x44, 0x8c, 0x06, 0x65, - 0x22, 0x01, 0x43, 0x65, 0x0d, 0x66, 0x22, 0x81, 0x06, 0x43, 0x45, 0x7c, - 0x68, 0x22, 0x41, 0x59, 0xd8, 0x22, 0x67, 0x22, 0x41, 0x51, 0x28, 0x57, - 0x6c, 0x22, 0x41, 0x80, 0x01, 0xff, 0x56, 0x18, 0x36, 0xd5, 0x22, 0x01, - 0x56, 0xbf, 0x2c, 0x93, 0x23, 0x01, 0x44, 0x89, 0x60, 0xd4, 0x22, 0x41, - 0x48, 0xf8, 0x97, 0x4d, 0x22, 0x01, 0xd2, 0x4e, 0x22, 0x01, 0xed, 0x4f, - 0x22, 0x81, 0xc1, 0x01, 0xee, 0x8f, 0x23, 0x81, 0x06, 0x43, 0x00, 0x89, - 0x60, 0x22, 0x41, 0xd9, 0x90, 0x23, 0x01, 0x43, 0x3d, 0xf4, 0x52, 0x22, - 0xc1, 0x00, 0x07, 0x27, 0x02, 0x01, 0xff, 0xa1, 0x92, 0x01, 0x43, 0xe9, - 0x1c, 0x91, 0x23, 0x01, 0x48, 0x41, 0xc5, 0x22, 0x25, 0x01, 0xa7, 0x6e, - 0x42, 0x49, 0x00, 0x25, 0x25, 0x01, 0x45, 0xf1, 0xe7, 0x26, 0x25, 0x01, - 0x47, 0xc5, 0xd2, 0x27, 0x25, 0x01, 0xad, 0x4e, 0xae, 0x42, 0x4c, 0x97, - 0x3d, 0x29, 0x25, 0x01, 0x43, 0x8e, 0x06, 0x5a, 0x22, 0x81, 0x1d, 0xf5, - 0x2a, 0x25, 0xc1, 0x00, 0x47, 0x21, 0x74, 0x2b, 0x25, 0x01, 0x4a, 0x0c, - 0xa7, 0x5e, 0x22, 0x01, 0x44, 0x10, 0xcc, 0x2c, 0x25, 0x01, 0x42, 0xa4, - 0x02, 0x5f, 0x22, 0x41, 0x07, 0x72, 0x28, 0x01, 0xff, 0x43, 0x19, 0x00, - 0x5b, 0x22, 0x01, 0x42, 0xa4, 0x02, 0x5c, 0x22, 0xc1, 0x00, 0x49, 0x1f, - 0x4d, 0x5d, 0x22, 0x41, 0xe5, 0x58, 0x22, 0x01, 0x42, 0x42, 0x0b, 0x59, - 0x22, 0x41, 0x43, 0xf9, 0x03, 0x28, 0x25, 0x01, 0x50, 0x7d, 0x62, 0x57, - 0x22, 0x41, 0xe9, 0x92, 0x23, 0x81, 0x0b, 0xb5, 0x01, 0xff, 0xe4, 0x56, - 0x22, 0x01, 0xec, 0x24, 0x25, 0x41, 0x42, 0xa4, 0x02, 0x23, 0x25, 0x41, - 0xee, 0x53, 0x22, 0x01, 0x42, 0xa4, 0x02, 0x54, 0x22, 0xc1, 0x00, 0x49, - 0x1f, 0x4d, 0x55, 0x22, 0x41, 0x09, 0xc7, 0x42, 0x01, 0xff, 0x47, 0x96, - 0x60, 0x50, 0x22, 0x01, 0x50, 0x2d, 0x66, 0x51, 0x22, 0x41, 0x80, 0x01, - 0xff, 0x47, 0x30, 0x7c, 0x4b, 0x22, 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, - 0xe1, 0x49, 0x22, 0x01, 0x42, 0xb2, 0x0c, 0x4a, 0x22, 0x41, 0xd2, 0x3f, - 0x22, 0x01, 0xd4, 0x8e, 0x23, 0x01, 0x42, 0x24, 0x02, 0x40, 0x22, 0x81, - 0x0f, 0xed, 0x46, 0x22, 0xc1, 0x00, 0x48, 0x41, 0xc2, 0x45, 0x22, 0x01, - 0xd2, 0x47, 0x22, 0x41, 0x80, 0x04, 0xf2, 0x44, 0x22, 0x41, 0x48, 0x60, - 0x23, 0x41, 0x22, 0x01, 0x4d, 0x38, 0x87, 0x43, 0x22, 0x01, 0x4e, 0x3a, - 0x7d, 0x42, 0x22, 0x41, 0xe1, 0x20, 0x22, 0x81, 0xad, 0x01, 0xe5, 0x28, - 0x22, 0x81, 0x9e, 0x01, 0xe9, 0x2a, 0x22, 0x81, 0x8e, 0x01, 0xf5, 0x2c, - 0x22, 0xc1, 0x00, 0x48, 0x69, 0xc2, 0x2d, 0x22, 0x01, 0xe7, 0x2e, 0x22, - 0x81, 0x78, 0x44, 0xbd, 0xf1, 0x30, 0x22, 0x01, 0x44, 0x6d, 0xf2, 0x31, - 0x22, 0x01, 0x42, 0xa4, 0x02, 0x32, 0x22, 0xc1, 0x00, 0x80, 0x2a, 0xd3, - 0x39, 0x22, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x44, 0xd7, 0x3f, 0x3d, 0x22, - 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, 0xe1, 0x3a, 0x22, 0x81, 0x0c, 0x42, - 0x00, 0x00, 0x3c, 0x22, 0x01, 0x42, 0x59, 0x00, 0x8d, 0x23, 0x41, 0x48, - 0x79, 0xc2, 0x3b, 0x22, 0x41, 0x4d, 0xd6, 0x81, 0x38, 0x22, 0x01, 0x49, - 0xda, 0xbd, 0x36, 0x22, 0x81, 0x15, 0x06, 0x28, 0x02, 0x01, 0xff, 0xe1, - 0x33, 0x22, 0x01, 0x43, 0x0d, 0x5e, 0x34, 0x22, 0x01, 0x42, 0x59, 0x00, - 0x35, 0x22, 0x41, 0x07, 0x27, 0x02, 0x01, 0xff, 0x49, 0xa0, 0xb5, 0x37, - 0x22, 0x01, 0x42, 0x24, 0x02, 0x20, 0x25, 0x01, 0x43, 0x63, 0x60, 0x21, - 0x25, 0x41, 0x45, 0xd6, 0x3f, 0x2f, 0x22, 0x41, 0x49, 0xe3, 0xb4, 0x1f, - 0x25, 0x01, 0xee, 0x2b, 0x22, 0x41, 0xf3, 0x29, 0x22, 0xc1, 0x00, 0xe8, - 0x8c, 0x23, 0x41, 0x80, 0x17, 0xd2, 0x23, 0x22, 0x01, 0xe8, 0x24, 0x22, - 0x01, 0xf2, 0x25, 0x22, 0x01, 0x42, 0xa4, 0x02, 0x26, 0x22, 0xc1, 0x00, - 0xd2, 0x27, 0x22, 0x41, 0x44, 0xd7, 0x3f, 0x22, 0x22, 0x01, 0x4a, 0x11, - 0x45, 0x21, 0x22, 0x41, 0xe1, 0xb7, 0x21, 0x81, 0xca, 0x02, 0xe9, 0xf7, - 0x21, 0x81, 0xb4, 0x02, 0xf5, 0xfb, 0x21, 0xc1, 0x00, 0x4a, 0x4d, 0x9d, - 0xfc, 0x21, 0x01, 0xd2, 0xfd, 0x21, 0x81, 0x3c, 0xd3, 0x16, 0x22, 0x01, - 0x43, 0xce, 0x42, 0x17, 0x22, 0x81, 0x1a, 0xe8, 0x1b, 0x22, 0x01, 0xec, - 0x1c, 0x22, 0x01, 0xed, 0x1d, 0x22, 0xc1, 0x00, 0x49, 0xa4, 0xb4, 0x1e, - 0x22, 0xc1, 0x00, 0x4d, 0x87, 0x1e, 0x1f, 0x22, 0x41, 0x80, 0x01, 0xff, - 0xaf, 0x06, 0x47, 0x30, 0x7c, 0x1a, 0x22, 0x41, 0x4d, 0xa0, 0x87, 0x19, - 0x22, 0x01, 0x49, 0x04, 0xc1, 0x18, 0x22, 0x41, 0x80, 0x01, 0xff, 0x4c, - 0xc0, 0x8d, 0x12, 0x22, 0x01, 0x4e, 0x32, 0x78, 0x19, 0x25, 0x01, 0x4c, - 0x78, 0x93, 0x13, 0x22, 0x01, 0xb3, 0xbd, 0x01, 0xb4, 0x01, 0xff, 0x43, - 0x8a, 0x60, 0x11, 0x22, 0x01, 0x05, 0x29, 0x02, 0x01, 0xff, 0x42, 0x13, - 0x00, 0xfe, 0x21, 0x01, 0x43, 0xf0, 0x70, 0xff, 0x21, 0x01, 0x44, 0xd0, - 0x0c, 0x1a, 0x25, 0x01, 0x44, 0x72, 0x75, 0x00, 0x22, 0x81, 0x86, 0x01, - 0x49, 0x94, 0x60, 0x02, 0x22, 0x01, 0xa8, 0x72, 0x42, 0x29, 0x02, 0x04, - 0x22, 0x01, 0xab, 0x53, 0x02, 0x74, 0x00, 0x43, 0x4a, 0xe2, 0xad, 0x0b, - 0x22, 0x01, 0xae, 0x33, 0x43, 0xef, 0x0e, 0x1c, 0x25, 0x81, 0x26, 0xb3, - 0x0f, 0xb4, 0x01, 0xff, 0x43, 0x18, 0x45, 0x1e, 0x25, 0x01, 0x43, 0xd2, - 0x0e, 0x10, 0x22, 0x41, 0x42, 0x41, 0x00, 0x8b, 0x23, 0x01, 0xa9, 0x01, - 0xff, 0x49, 0x1f, 0x4d, 0x0e, 0x22, 0x01, 0x4a, 0x66, 0xac, 0x0f, 0x22, - 0x41, 0x52, 0x9a, 0x3d, 0x1d, 0x25, 0x41, 0xe5, 0x0c, 0x22, 0x01, 0xf5, - 0x0d, 0x22, 0x41, 0x49, 0x1f, 0x4d, 0x09, 0x22, 0x01, 0x43, 0x24, 0x02, - 0x0a, 0x22, 0x41, 0x02, 0xe8, 0x01, 0x04, 0xe9, 0x08, 0x22, 0x41, 0xd2, - 0x05, 0x22, 0x01, 0xd3, 0x06, 0x22, 0xc1, 0x00, 0x49, 0x1f, 0x4d, 0x07, - 0x22, 0x41, 0x42, 0x13, 0x00, 0x1b, 0x25, 0x01, 0x4b, 0x4c, 0x9d, 0x03, - 0x22, 0x41, 0x80, 0x01, 0xff, 0x48, 0xc9, 0xb4, 0x8a, 0x23, 0x01, 0x44, - 0x89, 0x60, 0x01, 0x22, 0x41, 0x46, 0x31, 0x7c, 0x15, 0x22, 0x81, 0x06, - 0x46, 0xd7, 0x05, 0x14, 0x22, 0x41, 0x4a, 0x4d, 0x9d, 0x89, 0x23, 0x41, - 0xec, 0xf8, 0x21, 0x01, 0x44, 0x5d, 0xf1, 0xf9, 0x21, 0x01, 0x42, 0xa4, - 0x02, 0xfa, 0x21, 0x41, 0x02, 0x24, 0x02, 0xd0, 0x03, 0x44, 0x79, 0xf0, - 0xf1, 0x21, 0x01, 0x02, 0xb5, 0x10, 0x1d, 0xec, 0xf2, 0x21, 0x81, 0x12, - 0xed, 0xf4, 0x21, 0xc1, 0x00, 0x4a, 0x06, 0x5e, 0xf5, 0x21, 0xc1, 0x00, - 0x48, 0x89, 0xc2, 0xf6, 0x21, 0x41, 0x4a, 0x4a, 0x9e, 0xf3, 0x21, 0x41, - 0x90, 0xe8, 0x02, 0x91, 0xd9, 0x02, 0x92, 0xad, 0x02, 0x93, 0x8c, 0x02, - 0x94, 0xae, 0x01, 0x43, 0xe0, 0xf3, 0xff, 0x24, 0x01, 0x96, 0x0f, 0x97, - 0x01, 0xff, 0x42, 0x73, 0xb5, 0x17, 0x25, 0x01, 0x42, 0x23, 0xf5, 0x18, - 0x25, 0x41, 0x42, 0xb9, 0x75, 0x00, 0x25, 0x01, 0x42, 0x11, 0xf5, 0x01, - 0x25, 0x81, 0x4a, 0x42, 0x19, 0xf5, 0x0c, 0x25, 0x01, 0x42, 0x21, 0xf5, - 0x0d, 0x25, 0xc1, 0x00, 0x07, 0x27, 0x02, 0x01, 0xff, 0x43, 0x49, 0xf4, - 0x0e, 0x25, 0x01, 0x42, 0x24, 0x02, 0x0f, 0x25, 0x01, 0x43, 0xf0, 0x06, - 0x10, 0x25, 0x81, 0x1f, 0x42, 0x51, 0x03, 0x12, 0x25, 0x01, 0x55, 0x97, - 0x3d, 0x13, 0x25, 0x01, 0x4d, 0xa4, 0x88, 0x14, 0x25, 0x01, 0xb5, 0x01, - 0xff, 0xe4, 0x15, 0x25, 0x01, 0x44, 0x10, 0xcc, 0x16, 0x25, 0x41, 0x45, - 0xd6, 0x3f, 0x11, 0x25, 0x41, 0x07, 0x27, 0x02, 0x01, 0xff, 0x43, 0xf9, - 0x03, 0x02, 0x25, 0x01, 0x43, 0xf0, 0x70, 0x03, 0x25, 0x01, 0x4e, 0x36, - 0x77, 0x04, 0x25, 0x01, 0x43, 0xc5, 0xb4, 0x05, 0x25, 0x01, 0x42, 0x74, - 0x00, 0x06, 0x25, 0x01, 0xb4, 0x11, 0xb5, 0x01, 0xff, 0xd2, 0x09, 0x25, - 0x01, 0xe4, 0x0a, 0x25, 0x01, 0x44, 0x10, 0xcc, 0x0b, 0x25, 0x41, 0x42, - 0x17, 0x00, 0x07, 0x25, 0x01, 0xe5, 0x08, 0x25, 0x41, 0x94, 0x29, 0x95, - 0x1f, 0x42, 0x3b, 0xf4, 0xf9, 0x24, 0x01, 0x42, 0x1c, 0xf5, 0xfa, 0x24, - 0x01, 0x99, 0x01, 0xff, 0xd0, 0xfb, 0x24, 0x01, 0xd2, 0xfc, 0x24, 0x01, - 0xd3, 0xfd, 0x24, 0x01, 0xd5, 0xfe, 0x24, 0x41, 0xd0, 0xf7, 0x24, 0x01, - 0xd7, 0xf8, 0x24, 0x41, 0xd1, 0xf0, 0x24, 0x01, 0xd9, 0xf1, 0x24, 0xc1, - 0x00, 0x07, 0x27, 0x02, 0x01, 0xff, 0x42, 0x1e, 0x01, 0xf2, 0x24, 0x01, - 0x43, 0xf0, 0x06, 0xf3, 0x24, 0x01, 0x09, 0x97, 0x3d, 0x06, 0x4a, 0x92, - 0xb2, 0xf6, 0x24, 0x41, 0x43, 0xa9, 0x3d, 0xf4, 0x24, 0x01, 0x4c, 0xa0, - 0x3d, 0xf5, 0x24, 0x41, 0x94, 0x10, 0x98, 0x06, 0x42, 0x2d, 0xf5, 0xef, - 0x24, 0x41, 0xd3, 0xed, 0x24, 0x01, 0xd4, 0xee, 0x24, 0x41, 0xd3, 0xea, - 0x24, 0x01, 0xd7, 0xeb, 0x24, 0x01, 0xd8, 0xec, 0x24, 0x41, 0x91, 0x1f, - 0x92, 0x11, 0x42, 0x1b, 0xf5, 0xe7, 0x24, 0x01, 0x96, 0x01, 0xff, 0xd5, - 0xe8, 0x24, 0x01, 0xd6, 0xe9, 0x24, 0x41, 0xd0, 0xe4, 0x24, 0x01, 0xd5, - 0xe5, 0x24, 0x01, 0xd8, 0xe6, 0x24, 0x41, 0xd0, 0xe2, 0x24, 0x01, 0xd9, - 0xe3, 0x24, 0x41, 0x42, 0xce, 0xf3, 0xe0, 0x24, 0x01, 0x42, 0x38, 0xf4, - 0xe1, 0x24, 0x41, 0x42, 0xcd, 0xf3, 0xd5, 0x24, 0x01, 0x92, 0x2e, 0x42, - 0xce, 0xf3, 0xd8, 0x24, 0x01, 0x95, 0x1e, 0x42, 0xec, 0xf3, 0xdb, 0x24, - 0x01, 0x54, 0x2f, 0x40, 0xdc, 0x24, 0x01, 0x98, 0x06, 0x42, 0x2f, 0xf5, - 0xdf, 0x24, 0x41, 0xd0, 0xdd, 0x24, 0x01, 0x4e, 0xae, 0x75, 0xde, 0x24, - 0x41, 0xd0, 0xd9, 0x24, 0x01, 0xd1, 0xda, 0x24, 0x41, 0xd1, 0xd6, 0x24, - 0x01, 0xd5, 0xd7, 0x24, 0x41, 0xe2, 0xb8, 0x21, 0x81, 0x22, 0xf2, 0xec, - 0x21, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x44, 0xd7, 0x3f, 0xef, 0x21, 0x81, - 0x0d, 0x49, 0x59, 0xa6, 0xed, 0x21, 0xc1, 0x00, 0x49, 0x97, 0xa9, 0xee, - 0x21, 0x41, 0x54, 0xcb, 0x3f, 0xf0, 0x21, 0x41, 0x80, 0x01, 0xff, 0x47, - 0xd6, 0x05, 0xeb, 0x21, 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, 0xe1, 0xb9, - 0x21, 0x81, 0xa0, 0x02, 0xa2, 0x93, 0x02, 0x43, 0x43, 0x18, 0xc2, 0x21, - 0x01, 0x42, 0x92, 0x01, 0xc3, 0x21, 0x01, 0xa7, 0xea, 0x01, 0xa8, 0xd8, - 0x01, 0xa9, 0xb9, 0x01, 0xab, 0x9b, 0x01, 0xac, 0x83, 0x01, 0xad, 0x70, - 0x42, 0xcd, 0x05, 0xdb, 0x21, 0x01, 0xb3, 0x3d, 0xb4, 0x29, 0xf5, 0xe5, - 0x21, 0x81, 0x06, 0x4a, 0x40, 0xb4, 0xd4, 0x24, 0x41, 0x06, 0x72, 0x28, - 0x10, 0x4a, 0x0c, 0xa7, 0xe8, 0x21, 0x01, 0xe4, 0xe9, 0x21, 0x01, 0x42, - 0xa4, 0x02, 0xea, 0x21, 0x41, 0xe1, 0xe6, 0x21, 0x01, 0x48, 0x20, 0x74, - 0xe7, 0x21, 0x41, 0xa1, 0x06, 0x58, 0x71, 0x28, 0xe4, 0x21, 0x41, 0xe7, - 0xe2, 0x21, 0x01, 0x42, 0x19, 0x45, 0xe3, 0x21, 0x41, 0xa8, 0x06, 0x42, - 0x48, 0x04, 0xe1, 0x21, 0x41, 0x4a, 0x96, 0xa9, 0xdc, 0x21, 0x01, 0x0e, - 0x04, 0x79, 0x0d, 0x42, 0x0f, 0x67, 0xdf, 0x21, 0xc1, 0x00, 0x4a, 0x1c, - 0xa6, 0xe0, 0x21, 0x41, 0x4a, 0xae, 0xaf, 0xdd, 0x21, 0x01, 0x44, 0x89, - 0x60, 0xde, 0x21, 0x41, 0xe5, 0xd8, 0x21, 0x81, 0x06, 0x43, 0x45, 0x7c, - 0xda, 0x21, 0x41, 0x48, 0xe4, 0xad, 0xd9, 0x21, 0x41, 0x44, 0x23, 0x02, - 0xd4, 0x21, 0x01, 0x43, 0xd1, 0x0c, 0xd5, 0x21, 0x01, 0xf5, 0xd6, 0x21, - 0xc1, 0x00, 0xec, 0xd7, 0x21, 0x41, 0xe9, 0xcf, 0x21, 0x81, 0x12, 0xb5, - 0x01, 0xff, 0xd3, 0xd1, 0x21, 0x01, 0xec, 0xd2, 0x21, 0xc1, 0x00, 0x4f, - 0xa3, 0x69, 0xd3, 0x21, 0x41, 0xee, 0xd0, 0x21, 0x41, 0x47, 0xd8, 0x69, - 0xcb, 0x21, 0x01, 0xed, 0xcc, 0x21, 0xc1, 0x00, 0x06, 0x72, 0x28, 0x01, - 0xff, 0x42, 0x22, 0x00, 0xcd, 0x21, 0x01, 0x42, 0xc7, 0x15, 0xce, 0x21, - 0x41, 0xe1, 0xc8, 0x21, 0x81, 0x06, 0x4b, 0x57, 0x9d, 0xca, 0x21, 0x41, - 0xec, 0xc9, 0x21, 0x41, 0xe1, 0xc4, 0x21, 0x81, 0x11, 0xe9, 0x88, 0x23, - 0x01, 0x42, 0xb2, 0x0c, 0xc6, 0x21, 0xc1, 0x00, 0x49, 0xb6, 0xb4, 0xc7, - 0x21, 0x41, 0xf2, 0xc5, 0x21, 0x41, 0x42, 0xe8, 0x01, 0xc0, 0x21, 0x01, - 0xe9, 0xc1, 0x21, 0x41, 0x06, 0x72, 0x28, 0x0e, 0xec, 0xbd, 0x21, 0x01, - 0xee, 0xbe, 0x21, 0x01, 0x4c, 0x40, 0x95, 0xbf, 0x21, 0x41, 0x4a, 0x46, - 0xa9, 0xba, 0x21, 0x01, 0x43, 0x88, 0x1e, 0xbb, 0x21, 0x01, 0x43, 0xeb, - 0x20, 0xbc, 0x21, 0x41, 0xe1, 0x57, 0x21, 0x81, 0x84, 0x01, 0x44, 0x72, - 0x75, 0x9f, 0x21, 0x01, 0xe9, 0xa0, 0x21, 0x81, 0x44, 0xf5, 0xaa, 0x21, - 0x81, 0x06, 0x45, 0x88, 0xec, 0xb6, 0x21, 0x41, 0x69, 0xea, 0x03, 0xab, - 0x21, 0x01, 0xd3, 0xac, 0x21, 0x01, 0xd4, 0xad, 0x21, 0x81, 0x24, 0xd7, - 0xaf, 0x21, 0x01, 0xec, 0xb0, 0x21, 0x81, 0x15, 0xee, 0xb2, 0x21, 0x01, - 0xf2, 0xb3, 0x21, 0x81, 0x06, 0x44, 0x0d, 0x67, 0xb5, 0x21, 0x41, 0x4d, - 0xb4, 0x7f, 0xb4, 0x21, 0x41, 0x45, 0xd6, 0x3f, 0xb1, 0x21, 0x41, 0x4d, - 0xce, 0x7f, 0xae, 0x21, 0x41, 0x07, 0x27, 0x02, 0x22, 0xe4, 0xa4, 0x21, - 0x01, 0xee, 0xa5, 0x21, 0x01, 0xb3, 0x01, 0xff, 0x42, 0x13, 0x00, 0xa6, - 0x21, 0x01, 0xe8, 0xa7, 0x21, 0x01, 0x43, 0x28, 0x6f, 0xa8, 0x21, 0xc1, - 0x00, 0x4c, 0x74, 0x8b, 0xa9, 0x21, 0x41, 0x43, 0xf0, 0x70, 0xa1, 0x21, - 0x01, 0xf5, 0xa2, 0x21, 0xc1, 0x00, 0xe4, 0xa3, 0x21, 0x41, 0x07, 0x27, - 0x02, 0x72, 0xd2, 0x8d, 0x21, 0x81, 0x67, 0xe2, 0x8f, 0x21, 0x01, 0xa4, - 0x4a, 0xeb, 0x95, 0x21, 0x81, 0x3f, 0xec, 0x97, 0x21, 0x81, 0x26, 0xad, - 0x1c, 0x49, 0xf5, 0xbd, 0x6f, 0x23, 0x01, 0x44, 0x1d, 0x02, 0x9c, 0x21, - 0xc1, 0x00, 0x80, 0x01, 0xff, 0x60, 0x22, 0x02, 0x9d, 0x21, 0x01, 0x6c, - 0x16, 0x02, 0x9e, 0x21, 0x41, 0xd2, 0x9a, 0x21, 0x01, 0xd4, 0x9b, 0x21, - 0x41, 0x80, 0x06, 0x42, 0x57, 0x00, 0x27, 0x23, 0x41, 0x4c, 0xb4, 0x8d, - 0x99, 0x21, 0x01, 0x49, 0x4e, 0x9d, 0x98, 0x21, 0x41, 0x4f, 0xd0, 0x69, - 0x96, 0x21, 0x41, 0xd2, 0x90, 0x21, 0x01, 0xd3, 0x91, 0x21, 0x01, 0xd4, - 0x92, 0x21, 0x01, 0xd5, 0x93, 0x21, 0xc1, 0x00, 0x4a, 0x12, 0xa6, 0x94, - 0x21, 0x41, 0x4d, 0x73, 0x7f, 0x8e, 0x21, 0x41, 0xe1, 0x58, 0x21, 0x81, - 0xdf, 0x02, 0xa2, 0xc4, 0x02, 0xa5, 0xb5, 0x02, 0xa7, 0xe8, 0x01, 0x4d, - 0xf0, 0x03, 0x82, 0x23, 0x01, 0xa9, 0xd5, 0x01, 0xab, 0xc0, 0x01, 0xac, - 0xb0, 0x01, 0xad, 0x86, 0x01, 0xae, 0x7a, 0xb0, 0x70, 0x42, 0x3d, 0x00, - 0x7d, 0x21, 0x01, 0xb3, 0x3a, 0xb4, 0x2e, 0xf5, 0x87, 0x21, 0x81, 0x06, - 0x42, 0xfc, 0x33, 0x8c, 0x21, 0x41, 0x44, 0xcb, 0xeb, 0xd2, 0x24, 0x01, - 0xd2, 0x88, 0x21, 0x01, 0xe4, 0x89, 0x21, 0x01, 0x4c, 0x58, 0x92, 0x8a, - 0x21, 0x01, 0xf2, 0xd3, 0x24, 0x81, 0x06, 0x42, 0xa4, 0x02, 0x8b, 0x21, - 0x41, 0xd2, 0x87, 0x23, 0x41, 0x42, 0x17, 0x00, 0x86, 0x21, 0x01, 0xf5, - 0x86, 0x23, 0x41, 0xe1, 0x7e, 0x21, 0x81, 0x25, 0xa8, 0x0c, 0x42, 0x3f, - 0x00, 0x84, 0x21, 0x01, 0x44, 0xf5, 0xf2, 0x85, 0x21, 0x41, 0xe1, 0x80, - 0x21, 0x01, 0xe5, 0x81, 0x21, 0x01, 0x42, 0x03, 0x00, 0x82, 0x21, 0x01, - 0xf5, 0x83, 0x21, 0xc1, 0x00, 0xec, 0x85, 0x23, 0x41, 0xf2, 0x7f, 0x21, - 0x41, 0xe1, 0x84, 0x23, 0x01, 0xe9, 0x7c, 0x21, 0x41, 0xe5, 0x7a, 0x21, - 0x01, 0x42, 0x42, 0x0b, 0x7b, 0x21, 0x41, 0xe5, 0x74, 0x21, 0x81, 0x0b, - 0xe9, 0x78, 0x21, 0xc1, 0x00, 0x4b, 0xcc, 0x97, 0x79, 0x21, 0x41, 0x06, - 0x72, 0x28, 0x01, 0xff, 0x42, 0x6c, 0x02, 0x75, 0x21, 0x01, 0x42, 0xf1, - 0x06, 0x76, 0x21, 0x01, 0x42, 0x77, 0x00, 0x77, 0x21, 0x41, 0xe9, 0x72, - 0x21, 0x01, 0xf5, 0x73, 0x21, 0xc1, 0x00, 0xed, 0x83, 0x23, 0x41, 0xe1, - 0xd1, 0x24, 0x81, 0x09, 0xe9, 0x70, 0x21, 0xc1, 0x00, 0xe4, 0x71, 0x21, - 0x41, 0xeb, 0x6f, 0x21, 0x41, 0x42, 0xf1, 0x06, 0x6d, 0x21, 0x01, 0xed, - 0x6e, 0x21, 0x41, 0xe1, 0x62, 0x21, 0x81, 0x30, 0xe9, 0x67, 0x21, 0x81, - 0x0f, 0xf5, 0x6b, 0x21, 0xc1, 0x00, 0xe4, 0x81, 0x23, 0x01, 0x42, 0x43, - 0xf5, 0x6c, 0x21, 0x41, 0x42, 0xc5, 0x42, 0x68, 0x21, 0x01, 0x42, 0xa4, - 0x02, 0x80, 0x23, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x4d, 0x0f, 0x52, 0x6a, - 0x21, 0x01, 0x48, 0x42, 0x57, 0x69, 0x21, 0x41, 0xec, 0x63, 0x21, 0x01, - 0x47, 0x96, 0x60, 0x64, 0x21, 0x01, 0xf2, 0x65, 0x21, 0xc1, 0x00, 0x51, - 0x4a, 0x57, 0x66, 0x21, 0x41, 0x44, 0xb4, 0xaf, 0x60, 0x21, 0x01, 0x43, - 0xfa, 0x03, 0x61, 0x21, 0x41, 0xa1, 0x08, 0xe9, 0x5f, 0x21, 0x01, 0xf5, - 0xd0, 0x24, 0x41, 0xe4, 0x5c, 0x21, 0x01, 0x43, 0x22, 0x02, 0x5d, 0x21, - 0x01, 0xf2, 0x5e, 0x21, 0x41, 0xe4, 0x59, 0x21, 0x81, 0x13, 0x44, 0xb9, - 0xf1, 0x7e, 0x23, 0x01, 0x02, 0xa4, 0x02, 0x01, 0xff, 0xd2, 0x5b, 0x21, - 0x01, 0xd3, 0x7f, 0x23, 0x41, 0x49, 0xbf, 0xb4, 0x5a, 0x21, 0x41, 0x42, - 0x19, 0x00, 0x40, 0x21, 0x01, 0xe2, 0x41, 0x21, 0x01, 0x43, 0x81, 0x7f, - 0x42, 0x21, 0x81, 0x67, 0xe7, 0x45, 0x21, 0x81, 0x42, 0xec, 0x4b, 0x21, - 0x81, 0x33, 0xed, 0x4e, 0x21, 0x81, 0x0e, 0xee, 0x54, 0x21, 0x01, 0xf2, - 0x55, 0x21, 0x01, 0x42, 0xa4, 0x02, 0x56, 0x21, 0x41, 0x80, 0x06, 0x42, - 0x9e, 0x01, 0x53, 0x21, 0x41, 0x4b, 0x97, 0x9a, 0x50, 0x21, 0x01, 0x4b, - 0xf3, 0xa0, 0x51, 0x21, 0x01, 0x47, 0xd6, 0x05, 0x52, 0x21, 0x01, 0x4a, - 0x11, 0x45, 0x4f, 0x21, 0x41, 0x50, 0x8d, 0x60, 0x4c, 0x21, 0x01, 0xd2, - 0x4d, 0x21, 0x41, 0xe9, 0x46, 0x21, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x43, - 0x43, 0xf4, 0x47, 0x21, 0x01, 0x44, 0xd7, 0x3f, 0x4a, 0x21, 0x01, 0x62, - 0x9a, 0x0c, 0x49, 0x21, 0x01, 0x42, 0x0d, 0x00, 0x48, 0x21, 0x41, 0x0b, - 0xb6, 0x97, 0x01, 0xff, 0x43, 0x22, 0x36, 0x43, 0x21, 0x01, 0x47, 0xd6, - 0x05, 0x44, 0x21, 0x41, 0xe1, 0x29, 0x21, 0x81, 0x7e, 0xe9, 0x2d, 0x21, - 0x81, 0x3b, 0xf5, 0x37, 0x21, 0xc1, 0x00, 0x42, 0x0d, 0x61, 0x38, 0x21, - 0x81, 0x0c, 0x42, 0x73, 0xed, 0x3e, 0x21, 0x01, 0x42, 0xa4, 0x02, 0x7d, - 0x23, 0x41, 0x07, 0x27, 0x02, 0x01, 0xff, 0x42, 0x1a, 0x00, 0x39, 0x21, - 0x01, 0x43, 0x22, 0x00, 0x3a, 0x21, 0x01, 0x46, 0x1b, 0x02, 0x3b, 0x21, - 0x01, 0x44, 0xf0, 0x91, 0x3c, 0x21, 0x01, 0x42, 0xb2, 0x0c, 0x3d, 0x21, - 0x41, 0x07, 0x27, 0x02, 0x01, 0xff, 0x43, 0xf9, 0x03, 0x2e, 0x21, 0x81, - 0x28, 0x43, 0xf0, 0x70, 0x30, 0x21, 0x01, 0x44, 0xd0, 0x0c, 0x31, 0x21, - 0x01, 0x43, 0x7b, 0x1e, 0x32, 0x21, 0x01, 0x43, 0x3b, 0x04, 0x33, 0x21, - 0x01, 0x43, 0xde, 0x22, 0x34, 0x21, 0x01, 0x43, 0x8e, 0x06, 0x35, 0x21, - 0x01, 0xf5, 0x36, 0x21, 0x41, 0x52, 0xea, 0x03, 0xcf, 0x24, 0x01, 0xd2, - 0x2f, 0x21, 0x41, 0x80, 0x04, 0xec, 0x2c, 0x21, 0x41, 0x44, 0xd7, 0x3f, - 0x2b, 0x21, 0x01, 0x44, 0x89, 0x60, 0x2a, 0x21, 0xc1, 0x00, 0x45, 0xd6, - 0x3f, 0xce, 0x24, 0x41, 0xe1, 0xb5, 0x20, 0x81, 0xcc, 0x02, 0xa5, 0xad, - 0x02, 0xe9, 0x00, 0x21, 0x81, 0x87, 0x01, 0xf5, 0x16, 0x21, 0xc1, 0x00, - 0x4c, 0x2c, 0x8b, 0x17, 0x21, 0x01, 0xd2, 0x18, 0x21, 0x81, 0x4a, 0xe4, - 0x1e, 0x21, 0x81, 0x25, 0xec, 0x22, 0x21, 0x01, 0xed, 0x23, 0x21, 0x81, - 0x16, 0xf2, 0x25, 0x21, 0xc1, 0x00, 0xd7, 0x26, 0x21, 0x01, 0xb5, 0x01, - 0xff, 0xee, 0x27, 0x21, 0x01, 0x42, 0xa4, 0x02, 0x28, 0x21, 0x41, 0x4a, - 0x58, 0xa6, 0x24, 0x21, 0x41, 0x80, 0x01, 0xff, 0x4e, 0xfc, 0x7a, 0x21, - 0x21, 0x01, 0x54, 0x07, 0x45, 0xcd, 0x24, 0x01, 0x06, 0x28, 0x02, 0x01, - 0xff, 0x4a, 0x52, 0xa7, 0x1f, 0x21, 0x01, 0x43, 0x0d, 0x5e, 0x20, 0x21, - 0x41, 0x80, 0x01, 0xff, 0x44, 0xd7, 0x3f, 0x1d, 0x21, 0x01, 0x06, 0x28, - 0x02, 0x01, 0xff, 0x48, 0xd7, 0x69, 0xcc, 0x24, 0x01, 0x43, 0x63, 0x60, - 0x19, 0x21, 0x81, 0x0c, 0x43, 0xde, 0x22, 0x1b, 0x21, 0x01, 0x4d, 0x7d, - 0x88, 0x1c, 0x21, 0x41, 0x4f, 0xd0, 0x69, 0x1a, 0x21, 0x41, 0x80, 0x8a, - 0x01, 0xd4, 0x04, 0x21, 0x81, 0x76, 0x43, 0x81, 0x7f, 0x07, 0x21, 0x01, - 0xe7, 0x7c, 0x23, 0x01, 0xb2, 0x37, 0xb3, 0x01, 0xff, 0x42, 0x13, 0x00, - 0x10, 0x21, 0x01, 0xe8, 0x11, 0x21, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x4d, - 0x0f, 0x52, 0x12, 0x21, 0x01, 0xb4, 0x01, 0xff, 0x43, 0x8a, 0x60, 0x15, - 0x21, 0x01, 0x05, 0x29, 0x02, 0x01, 0xff, 0x43, 0xf0, 0x70, 0x13, 0x21, - 0x01, 0x52, 0x0a, 0x52, 0xcb, 0x24, 0x01, 0x44, 0x17, 0x45, 0x14, 0x21, - 0x41, 0xd2, 0x08, 0x21, 0x81, 0x28, 0xd3, 0x0a, 0x21, 0xc1, 0x00, 0x07, - 0x27, 0x02, 0x01, 0xff, 0x4a, 0x48, 0xa7, 0x0b, 0x21, 0x01, 0x49, 0x94, - 0x60, 0x0c, 0x21, 0x01, 0x43, 0xf0, 0x06, 0x0d, 0x21, 0x01, 0x4b, 0x46, - 0x9f, 0x0e, 0x21, 0x01, 0x42, 0xbb, 0x09, 0x0f, 0x21, 0x41, 0x45, 0xd6, - 0x3f, 0x09, 0x21, 0x41, 0x80, 0x01, 0xff, 0x4c, 0xa8, 0x8d, 0x06, 0x21, - 0x01, 0x48, 0xb1, 0xc9, 0x05, 0x21, 0x41, 0x4b, 0x0f, 0x52, 0x03, 0x21, - 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, 0xe5, 0x01, 0x21, 0x01, 0xf5, 0x02, - 0x21, 0x41, 0x42, 0x74, 0xed, 0x7b, 0x23, 0x01, 0x45, 0x11, 0xeb, 0xfe, - 0x20, 0xc1, 0x00, 0x07, 0x27, 0x02, 0x01, 0xff, 0x43, 0x0d, 0x5e, 0xff, - 0x20, 0x01, 0xf5, 0xca, 0x24, 0x41, 0x45, 0xd6, 0x3f, 0xb6, 0x20, 0x01, - 0xd2, 0xb7, 0x20, 0x81, 0x64, 0x42, 0x16, 0x00, 0xee, 0x20, 0x81, 0x4e, - 0xe4, 0xf0, 0x20, 0x81, 0x43, 0xec, 0xf2, 0x20, 0x81, 0x32, 0xed, 0xf5, - 0x20, 0x01, 0xee, 0xf6, 0x20, 0x81, 0x0f, 0xf2, 0xfb, 0x20, 0x81, 0x06, - 0x44, 0x51, 0x39, 0xfd, 0x20, 0x41, 0xd3, 0xfc, 0x20, 0x41, 0xd2, 0xf7, - 0x20, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x4d, 0xc9, 0x81, 0xfa, 0x20, 0x01, - 0x49, 0xd1, 0xbd, 0xf9, 0x20, 0x01, 0x44, 0x89, 0x60, 0xf8, 0x20, 0x41, - 0x5a, 0x7a, 0x1e, 0xf3, 0x20, 0x01, 0x42, 0x57, 0x00, 0xf4, 0x20, 0x41, - 0x56, 0x7e, 0x1e, 0xf1, 0x20, 0x41, 0x80, 0x01, 0xff, 0x4d, 0xbc, 0x81, - 0xef, 0x20, 0x01, 0x56, 0xbf, 0x2c, 0xc9, 0x24, 0x41, 0x80, 0x01, 0xff, - 0x48, 0xa9, 0xc9, 0xed, 0x20, 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, 0xa1, - 0xb0, 0x03, 0xa2, 0x8e, 0x03, 0xa4, 0xd9, 0x02, 0xa5, 0xba, 0x02, 0xa7, - 0x80, 0x02, 0xa8, 0xd6, 0x01, 0xa9, 0xc7, 0x01, 0xab, 0x9c, 0x01, 0xac, - 0x83, 0x01, 0xad, 0x71, 0xae, 0x4c, 0x42, 0xbb, 0x09, 0xe2, 0x20, 0x01, - 0xb3, 0x1c, 0x44, 0x17, 0x45, 0xe9, 0x20, 0x01, 0xf5, 0xea, 0x20, 0x81, - 0x06, 0x44, 0x8d, 0xf3, 0xc8, 0x24, 0x41, 0xe4, 0xeb, 0x20, 0xc1, 0x00, - 0x48, 0x81, 0xc2, 0xec, 0x20, 0x41, 0xa1, 0x1e, 0xa8, 0x06, 0x42, 0x48, - 0x04, 0xe8, 0x20, 0x41, 0xe5, 0xe5, 0x20, 0x81, 0x0b, 0xa9, 0x01, 0xff, - 0xe4, 0xe7, 0x20, 0x01, 0xed, 0xc7, 0x24, 0x41, 0x49, 0xda, 0xb4, 0xe6, - 0x20, 0x41, 0xec, 0xe3, 0x20, 0x01, 0xf2, 0xe4, 0x20, 0x41, 0xe5, 0xc4, - 0x24, 0x81, 0x0d, 0x42, 0x42, 0x0b, 0xe0, 0x20, 0xc1, 0x00, 0x49, 0xd8, - 0x22, 0xe1, 0x20, 0x41, 0x06, 0x72, 0x28, 0x01, 0xff, 0x42, 0x94, 0x9b, - 0xc5, 0x24, 0x01, 0x42, 0xf1, 0x06, 0xc6, 0x24, 0x41, 0x49, 0xe3, 0xad, - 0xde, 0x20, 0x01, 0xe9, 0xdf, 0x20, 0x01, 0x43, 0x45, 0x7c, 0xc3, 0x24, - 0x41, 0xe1, 0xdd, 0x20, 0x81, 0x06, 0x42, 0x23, 0x58, 0xc2, 0x24, 0x41, - 0xed, 0xc0, 0x24, 0xc1, 0x00, 0x4a, 0x06, 0x5e, 0xc1, 0x24, 0x41, 0xa1, - 0x1c, 0x42, 0x03, 0x00, 0xda, 0x20, 0x81, 0x0f, 0xb5, 0x01, 0xff, 0x49, - 0x7c, 0xb5, 0xdc, 0x20, 0x01, 0x50, 0x0d, 0x67, 0xbf, 0x24, 0x41, 0x49, - 0xc8, 0xb4, 0xdb, 0x20, 0x41, 0xeb, 0xd8, 0x20, 0x01, 0x44, 0x1d, 0x02, - 0xd9, 0x20, 0x41, 0x47, 0xd8, 0x69, 0xd6, 0x20, 0x01, 0x53, 0x15, 0x4d, - 0xd7, 0x20, 0x41, 0xa1, 0x0c, 0x49, 0xfc, 0xb9, 0xd4, 0x20, 0x01, 0x43, - 0x7e, 0xf0, 0xd5, 0x20, 0x41, 0x06, 0x72, 0x28, 0x0b, 0xec, 0xd2, 0x20, - 0xc1, 0x00, 0x48, 0xc8, 0xb4, 0xd3, 0x20, 0x41, 0xe1, 0xbe, 0x24, 0x01, - 0x4c, 0x98, 0x91, 0xd1, 0x20, 0x41, 0xe1, 0xbb, 0x24, 0x81, 0x16, 0xe9, - 0xcd, 0x20, 0xc1, 0x00, 0xd4, 0xce, 0x20, 0x81, 0x06, 0x4a, 0xfe, 0xaf, - 0xd0, 0x20, 0x41, 0x47, 0x72, 0x28, 0xcf, 0x20, 0x41, 0x47, 0x96, 0x60, - 0xcb, 0x20, 0x01, 0xf2, 0xcc, 0x20, 0xc1, 0x00, 0x06, 0x72, 0x28, 0x01, - 0xff, 0x42, 0x00, 0x00, 0xbc, 0x24, 0x01, 0x42, 0xcd, 0x05, 0xbd, 0x24, - 0x41, 0xec, 0xc7, 0x20, 0x81, 0x11, 0xee, 0xc9, 0x20, 0x81, 0x06, 0x43, - 0xdc, 0x21, 0xba, 0x24, 0x41, 0x50, 0x8d, 0x60, 0xca, 0x20, 0x41, 0x48, - 0xc8, 0xb4, 0xc8, 0x20, 0x41, 0xe1, 0xc3, 0x20, 0x01, 0xe9, 0xc4, 0x20, - 0x81, 0x18, 0xb5, 0x01, 0xff, 0xe2, 0xc6, 0x20, 0x01, 0x08, 0x36, 0x7c, - 0x01, 0xff, 0x48, 0xd7, 0x69, 0xb8, 0x24, 0x01, 0x46, 0x1b, 0x02, 0xb9, - 0x24, 0x41, 0x02, 0x49, 0x04, 0x01, 0xff, 0x44, 0xd7, 0x3f, 0xb7, 0x24, - 0x01, 0x49, 0x59, 0xa6, 0xc5, 0x20, 0x41, 0xa1, 0x0d, 0x42, 0x42, 0x00, - 0xc1, 0x20, 0xc1, 0x00, 0x48, 0x86, 0xbe, 0xc2, 0x20, 0x41, 0xe4, 0xbf, - 0x20, 0x01, 0x44, 0xc3, 0x42, 0xb6, 0x24, 0x01, 0x49, 0x85, 0xbe, 0xc0, - 0x20, 0x41, 0x06, 0x72, 0x28, 0x23, 0x50, 0x0d, 0x61, 0xbb, 0x20, 0x01, - 0xee, 0xbc, 0x20, 0x81, 0x12, 0x42, 0xa4, 0x02, 0xbd, 0x20, 0xc1, 0x00, - 0xd2, 0x7a, 0x23, 0xc1, 0x00, 0x49, 0xad, 0xb4, 0xbe, 0x20, 0x41, 0x50, - 0x5d, 0x60, 0x79, 0x23, 0x41, 0x4a, 0x46, 0xa9, 0xb8, 0x20, 0x01, 0x42, - 0x22, 0x00, 0xb9, 0x20, 0x01, 0x43, 0xf0, 0x06, 0xba, 0x20, 0x41, 0x80, - 0xe7, 0x02, 0xd2, 0x8d, 0x20, 0x81, 0xac, 0x02, 0x43, 0x04, 0x06, 0x94, - 0x20, 0x01, 0x43, 0xaf, 0xe7, 0x95, 0x20, 0x01, 0xec, 0x96, 0x20, 0x01, - 0xee, 0x97, 0x20, 0x81, 0xe9, 0x01, 0xb2, 0xd3, 0x01, 0x43, 0xfa, 0x03, - 0xa0, 0x20, 0x81, 0xc5, 0x01, 0x43, 0x4b, 0x0a, 0xa1, 0x20, 0xc1, 0x00, - 0x80, 0x01, 0xff, 0x0e, 0x30, 0x7c, 0x88, 0x01, 0x06, 0x28, 0x02, 0x01, - 0xff, 0xe1, 0xa2, 0x20, 0x81, 0x6d, 0x43, 0xf0, 0x70, 0xa6, 0x20, 0x01, - 0x49, 0x36, 0x77, 0xa7, 0x20, 0x81, 0x5a, 0x43, 0x01, 0x7b, 0x77, 0x23, - 0x01, 0x42, 0x22, 0x00, 0xa9, 0x20, 0x81, 0x47, 0x48, 0xd7, 0x69, 0xab, - 0x20, 0x01, 0xab, 0x2c, 0xac, 0x17, 0xb3, 0x0b, 0xb5, 0x01, 0xff, 0xd2, - 0xb3, 0x20, 0x01, 0xe4, 0xb4, 0x20, 0x41, 0x42, 0xb0, 0x01, 0x78, 0x23, - 0x01, 0xf5, 0xb5, 0x24, 0x41, 0xe1, 0xaf, 0x20, 0x81, 0x08, 0xe9, 0xb1, - 0x20, 0x01, 0xf5, 0xb2, 0x20, 0x41, 0x4b, 0x49, 0x9e, 0xb0, 0x20, 0x41, - 0x45, 0x1c, 0x02, 0xac, 0x20, 0x81, 0x06, 0x42, 0xaa, 0x3d, 0xae, 0x20, - 0x41, 0x48, 0xd5, 0x05, 0xad, 0x20, 0x41, 0x45, 0xd6, 0x3f, 0xaa, 0x20, - 0x41, 0x45, 0xd6, 0x3f, 0xa8, 0x20, 0x41, 0x49, 0xc8, 0xb4, 0xa3, 0x20, - 0x81, 0x04, 0xee, 0xa5, 0x20, 0x41, 0x4a, 0x4a, 0x9e, 0xa4, 0x20, 0x41, - 0x43, 0xf9, 0x03, 0xad, 0x24, 0x01, 0x42, 0x49, 0x00, 0xae, 0x24, 0x01, - 0x48, 0xd7, 0x69, 0xaf, 0x24, 0x01, 0x42, 0x74, 0x00, 0xb0, 0x24, 0x81, - 0x11, 0x42, 0x2a, 0x02, 0xb2, 0x24, 0x81, 0x06, 0x42, 0x6f, 0x00, 0xb4, - 0x24, 0x41, 0xf3, 0xb3, 0x24, 0x41, 0xec, 0xb1, 0x24, 0x41, 0x4e, 0x68, - 0x75, 0xac, 0x24, 0x41, 0x42, 0x92, 0x01, 0x9e, 0x20, 0x01, 0x43, 0xb5, - 0xaf, 0x9f, 0x20, 0xc1, 0x00, 0x42, 0x32, 0x64, 0xab, 0x24, 0x41, 0x80, - 0x01, 0xff, 0x4b, 0x8c, 0x9a, 0x9b, 0x20, 0x01, 0x4b, 0xe8, 0xa0, 0x9c, - 0x20, 0x01, 0x47, 0xd6, 0x05, 0x9d, 0x20, 0x01, 0x06, 0x28, 0x02, 0x01, - 0xff, 0x44, 0x94, 0x60, 0x98, 0x20, 0x81, 0x06, 0x42, 0x2a, 0x02, 0x9a, - 0x20, 0x41, 0x45, 0x88, 0x60, 0x99, 0x20, 0x41, 0x07, 0x27, 0x02, 0x01, - 0xff, 0x51, 0xd2, 0x57, 0x8e, 0x20, 0x01, 0x43, 0x88, 0x1e, 0x8f, 0x20, - 0x01, 0x43, 0x0d, 0x5e, 0xa9, 0x24, 0x01, 0x42, 0x7d, 0x02, 0x90, 0x20, - 0x01, 0x43, 0xef, 0x0e, 0xaa, 0x24, 0x01, 0xb3, 0x04, 0xf5, 0x93, 0x20, - 0x41, 0x42, 0x13, 0x00, 0x91, 0x20, 0x01, 0x42, 0xb0, 0x01, 0x92, 0x20, - 0x41, 0x53, 0xf8, 0x4b, 0x8c, 0x20, 0x01, 0x49, 0xf6, 0xbf, 0x8b, 0x20, - 0x41, 0xe1, 0x55, 0x20, 0x81, 0xe6, 0x02, 0xe9, 0x72, 0x20, 0x81, 0x9e, - 0x02, 0xf5, 0x7a, 0x20, 0xc1, 0x00, 0x80, 0x84, 0x02, 0xe2, 0x7e, 0x20, - 0x81, 0xea, 0x01, 0xe7, 0x81, 0x20, 0x81, 0x25, 0xe8, 0x83, 0x20, 0x01, - 0xee, 0x84, 0x20, 0x81, 0x06, 0x42, 0xc5, 0x42, 0x89, 0x20, 0x41, 0xd3, - 0x85, 0x20, 0x81, 0x04, 0xd4, 0x88, 0x20, 0x41, 0x45, 0xd6, 0x3f, 0x86, - 0x20, 0xc1, 0x00, 0x45, 0xd6, 0x3f, 0x87, 0x20, 0x41, 0x07, 0x27, 0x02, - 0x06, 0x42, 0xb2, 0x0c, 0x82, 0x20, 0x41, 0xa1, 0xa0, 0x01, 0xa4, 0x91, - 0x01, 0x45, 0xb3, 0xaf, 0x92, 0x24, 0x01, 0xa7, 0x74, 0xa8, 0x6a, 0x48, - 0xd7, 0x69, 0x99, 0x24, 0x01, 0xab, 0x48, 0xac, 0x2d, 0xad, 0x1b, 0x42, - 0x51, 0x03, 0xa5, 0x24, 0x01, 0x42, 0xe6, 0x05, 0xa6, 0x24, 0x01, 0xb3, - 0x01, 0xff, 0x42, 0xb0, 0x01, 0xa7, 0x24, 0x01, 0x46, 0xd9, 0x69, 0xa8, - 0x24, 0x41, 0x43, 0xf9, 0x03, 0xa2, 0x24, 0x01, 0x42, 0xed, 0x00, 0xa3, - 0x24, 0x01, 0xe9, 0xa4, 0x24, 0x41, 0xa1, 0x06, 0x4c, 0x6c, 0x96, 0xa1, - 0x24, 0x41, 0x45, 0xdd, 0xe7, 0x9e, 0x24, 0x01, 0xed, 0x9f, 0x24, 0xc1, - 0x00, 0x4a, 0x06, 0x5e, 0xa0, 0x24, 0x41, 0x45, 0x1c, 0x02, 0x9a, 0x24, - 0x01, 0xb5, 0x01, 0xff, 0xf2, 0x9b, 0x24, 0x01, 0x44, 0x0d, 0x67, 0x9c, - 0x24, 0xc1, 0x00, 0x4c, 0x11, 0x67, 0x9d, 0x24, 0x41, 0xe1, 0x97, 0x24, - 0x01, 0xe9, 0x98, 0x24, 0x41, 0xe1, 0x93, 0x24, 0x01, 0xe9, 0x94, 0x24, - 0xc1, 0x00, 0x47, 0x2d, 0xd5, 0x95, 0x24, 0x01, 0x42, 0xa4, 0x02, 0x96, - 0x24, 0x41, 0x42, 0x9e, 0x01, 0x90, 0x24, 0x01, 0x42, 0x42, 0x0b, 0x91, - 0x24, 0x41, 0x44, 0xb9, 0xf1, 0x8d, 0x24, 0x01, 0x42, 0xa4, 0x02, 0x8e, - 0x24, 0xc1, 0x00, 0x48, 0xf6, 0x16, 0x8f, 0x24, 0x41, 0x07, 0x27, 0x02, - 0x04, 0xd2, 0x80, 0x20, 0x41, 0x44, 0x72, 0x75, 0x7f, 0x20, 0x01, 0x43, - 0x8e, 0x06, 0x76, 0x23, 0x41, 0x44, 0xd7, 0x3f, 0x7c, 0x20, 0x01, 0x47, - 0x69, 0xd4, 0x7b, 0x20, 0x01, 0x47, 0x30, 0x7c, 0x7d, 0x20, 0x41, 0xe2, - 0x73, 0x20, 0x01, 0xed, 0x74, 0x20, 0x81, 0x18, 0xee, 0x77, 0x20, 0x81, - 0x0d, 0x42, 0xa4, 0x02, 0x79, 0x20, 0xc1, 0x00, 0x49, 0x1c, 0xa6, 0x75, - 0x23, 0x41, 0x53, 0x97, 0x47, 0x78, 0x20, 0x41, 0x07, 0x27, 0x02, 0x0b, - 0xd2, 0x76, 0x20, 0xc1, 0x00, 0x49, 0x19, 0xb5, 0x8c, 0x24, 0x41, 0x43, - 0xf0, 0x06, 0x8a, 0x24, 0x01, 0x43, 0x8e, 0x06, 0x75, 0x20, 0x01, 0x45, - 0xca, 0xeb, 0x8b, 0x24, 0x41, 0x4b, 0x10, 0x45, 0x88, 0x24, 0x01, 0xe7, - 0x56, 0x20, 0x81, 0x14, 0xed, 0x6e, 0x20, 0x01, 0xf2, 0x6f, 0x20, 0xc1, - 0x00, 0xa1, 0x01, 0xff, 0xd3, 0x70, 0x20, 0x01, 0xd4, 0x71, 0x20, 0x41, - 0x80, 0x04, 0xd3, 0x74, 0x23, 0x41, 0x0d, 0x25, 0x6f, 0x06, 0x49, 0x07, - 0x5e, 0x89, 0x24, 0x41, 0xa1, 0x89, 0x01, 0xa2, 0x7d, 0xa7, 0x5f, 0x42, - 0x22, 0x00, 0x60, 0x20, 0x01, 0x42, 0x46, 0x00, 0x61, 0x20, 0x81, 0x4c, - 0x43, 0x63, 0x60, 0x63, 0x20, 0x01, 0xac, 0x31, 0x42, 0xcd, 0x05, 0x68, - 0x20, 0x01, 0x4c, 0x97, 0x3d, 0x69, 0x20, 0x01, 0x42, 0x5a, 0x03, 0x6a, - 0x20, 0x01, 0x44, 0x17, 0x45, 0x6b, 0x20, 0x01, 0xb5, 0x01, 0xff, 0x07, - 0x10, 0x67, 0x06, 0x42, 0xa4, 0x02, 0x6d, 0x20, 0x41, 0x44, 0x25, 0xf0, - 0x6c, 0x20, 0x01, 0x44, 0x8c, 0x06, 0x73, 0x23, 0x41, 0xe1, 0x64, 0x20, - 0x01, 0xf5, 0x65, 0x20, 0xc1, 0x00, 0x4b, 0xc1, 0x97, 0x66, 0x20, 0x01, - 0xed, 0x67, 0x20, 0x41, 0x48, 0xa3, 0x3d, 0x62, 0x20, 0x41, 0xe1, 0x5b, - 0x20, 0x81, 0x11, 0xe9, 0x5d, 0x20, 0x81, 0x06, 0x42, 0xb2, 0x0c, 0x5f, - 0x20, 0x41, 0x42, 0xc5, 0x42, 0x5e, 0x20, 0x41, 0x4a, 0xc1, 0x97, 0x5c, - 0x20, 0x41, 0x44, 0xc3, 0xe4, 0x59, 0x20, 0x01, 0xe9, 0x5a, 0x20, 0x41, - 0x4a, 0xc1, 0x97, 0x57, 0x20, 0x01, 0x43, 0xb9, 0x00, 0x58, 0x20, 0x41, - 0xe1, 0x40, 0x20, 0x81, 0x54, 0xe9, 0x49, 0x20, 0x81, 0x3a, 0xf5, 0x4d, - 0x20, 0xc1, 0x00, 0x80, 0x16, 0x43, 0x05, 0x7b, 0x51, 0x20, 0x81, 0x09, - 0xf2, 0x53, 0x20, 0xc1, 0x00, 0xd2, 0x54, 0x20, 0x41, 0x4b, 0xab, 0x97, - 0x52, 0x20, 0x41, 0x4b, 0x81, 0x9a, 0x50, 0x20, 0x01, 0x08, 0xa1, 0xc9, - 0x01, 0xff, 0x42, 0x5c, 0x00, 0x4e, 0x20, 0x01, 0x49, 0xed, 0xbf, 0x87, - 0x24, 0x01, 0x42, 0x42, 0x0b, 0x4f, 0x20, 0x41, 0x07, 0x27, 0x02, 0x01, - 0xff, 0xe1, 0x4a, 0x20, 0x01, 0x43, 0x88, 0x1e, 0x4b, 0x20, 0x01, 0x48, - 0xd7, 0x69, 0x4c, 0x20, 0x41, 0xe4, 0x41, 0x20, 0x81, 0x40, 0x42, 0x3b, - 0xf5, 0x42, 0x20, 0x01, 0x44, 0xc3, 0x42, 0x43, 0x20, 0x81, 0x1c, 0xec, - 0x44, 0x20, 0x81, 0x0b, 0xf2, 0x47, 0x20, 0xc1, 0x00, 0x42, 0x7e, 0x7f, - 0x48, 0x20, 0x41, 0x49, 0x9b, 0xb4, 0x45, 0x20, 0x01, 0x42, 0x23, 0x02, - 0x46, 0x20, 0x41, 0x07, 0x27, 0x02, 0x01, 0xff, 0x43, 0x66, 0xa7, 0x84, - 0x24, 0x01, 0x42, 0x51, 0x03, 0x85, 0x24, 0x01, 0x42, 0x59, 0x00, 0x86, - 0x24, 0x41, 0x50, 0x7d, 0x60, 0x83, 0x24, 0x41, 0x07, 0x27, 0x02, 0x9d, - 0x03, 0xd2, 0x09, 0x20, 0x01, 0xe2, 0x0a, 0x20, 0x81, 0x83, 0x02, 0xe4, - 0x1c, 0x20, 0x81, 0xf7, 0x01, 0xeb, 0x1d, 0x20, 0x81, 0xe0, 0x01, 0xec, - 0x20, 0x20, 0x81, 0x9a, 0x01, 0x43, 0xb9, 0x00, 0x2b, 0x20, 0x81, 0x81, - 0x01, 0xee, 0x2d, 0x20, 0x81, 0x58, 0x43, 0x28, 0x13, 0x33, 0x20, 0x01, - 0xb2, 0x3d, 0xb3, 0x01, 0xff, 0x43, 0x0d, 0xf4, 0x37, 0x20, 0x01, 0xe8, - 0x38, 0x20, 0xc1, 0x00, 0x80, 0x0a, 0xd2, 0x3e, 0x20, 0x01, 0x43, 0x24, - 0x02, 0x3f, 0x20, 0x41, 0x49, 0xf5, 0xa5, 0x3a, 0x20, 0x01, 0x09, 0xa2, - 0x10, 0x06, 0x49, 0x43, 0x95, 0x39, 0x20, 0x41, 0x48, 0xa2, 0x10, 0x3c, - 0x20, 0x81, 0x06, 0x61, 0xd1, 0x0e, 0x3b, 0x20, 0x41, 0x5f, 0x94, 0x10, - 0x3d, 0x20, 0x41, 0x42, 0xe8, 0x01, 0x34, 0x20, 0x81, 0x06, 0x43, 0x3b, - 0x9e, 0x36, 0x20, 0x41, 0x4a, 0x06, 0x5e, 0x35, 0x20, 0x41, 0x80, 0x06, - 0x43, 0x8e, 0x06, 0x32, 0x20, 0x41, 0x47, 0x62, 0xd4, 0x2e, 0x20, 0x01, - 0x0a, 0xb8, 0xaf, 0x06, 0x4b, 0x9d, 0xa3, 0x2f, 0x20, 0x41, 0x55, 0x82, - 0x3d, 0x30, 0x20, 0x01, 0x47, 0xd6, 0x05, 0x31, 0x20, 0x41, 0x07, 0x27, - 0x02, 0x01, 0xff, 0x43, 0x8e, 0xf4, 0x72, 0x23, 0x01, 0x43, 0x8e, 0x06, - 0x2c, 0x20, 0x41, 0x07, 0x27, 0x02, 0x0c, 0x42, 0x1a, 0x00, 0x29, 0x20, - 0x01, 0x43, 0x34, 0x3d, 0x2a, 0x20, 0x41, 0x42, 0x13, 0x00, 0x21, 0x20, - 0x01, 0x44, 0xad, 0xef, 0x22, 0x20, 0x01, 0x44, 0x0c, 0x45, 0x23, 0x20, - 0x01, 0x42, 0x22, 0x00, 0x24, 0x20, 0x01, 0xab, 0x0c, 0x43, 0x8e, 0x06, - 0x27, 0x20, 0x01, 0x43, 0x45, 0x7c, 0x28, 0x20, 0x41, 0x43, 0xe2, 0xf0, - 0x25, 0x20, 0x01, 0xe9, 0x26, 0x20, 0x41, 0x07, 0x27, 0x02, 0x01, 0xff, - 0x45, 0xb3, 0xaf, 0x1e, 0x20, 0x01, 0x4f, 0x03, 0x73, 0x1f, 0x20, 0x41, - 0x4b, 0xf8, 0x97, 0x82, 0x24, 0x41, 0x80, 0x2c, 0xd2, 0x16, 0x20, 0xc1, - 0x00, 0x07, 0x27, 0x02, 0x01, 0xff, 0xe1, 0x71, 0x23, 0x01, 0x45, 0xc2, - 0xe4, 0x17, 0x20, 0x01, 0x49, 0x94, 0x60, 0x18, 0x20, 0x01, 0x4a, 0xe2, - 0xad, 0x19, 0x20, 0x01, 0x44, 0x50, 0x57, 0x1a, 0x20, 0x01, 0x44, 0x17, - 0x45, 0x1b, 0x20, 0x41, 0x44, 0xd7, 0x3f, 0x15, 0x20, 0x01, 0x06, 0x28, - 0x02, 0x01, 0xff, 0x44, 0xf9, 0x03, 0x0b, 0x20, 0x01, 0x49, 0x36, 0x77, - 0x0c, 0x20, 0x01, 0x02, 0x24, 0x02, 0x3d, 0x42, 0x22, 0x00, 0x0f, 0x20, - 0x01, 0xa9, 0x29, 0x45, 0x22, 0x02, 0x12, 0x20, 0x01, 0x43, 0xde, 0x22, - 0x70, 0x23, 0x81, 0x16, 0x02, 0xa4, 0x02, 0x06, 0x4f, 0x20, 0x74, 0x14, - 0x20, 0x41, 0x43, 0x9a, 0x5a, 0x13, 0x20, 0x01, 0x42, 0x0f, 0x67, 0x81, - 0x24, 0x41, 0x45, 0x88, 0x60, 0x80, 0x24, 0x41, 0x47, 0xd8, 0x69, 0x10, - 0x20, 0x01, 0x43, 0xcb, 0x13, 0x11, 0x20, 0x41, 0xec, 0x0d, 0x20, 0x01, - 0x47, 0x96, 0x60, 0x0e, 0x20, 0x41, 0xe1, 0x01, 0x20, 0x01, 0x43, 0xf0, - 0x70, 0x02, 0x20, 0x01, 0x49, 0x94, 0x60, 0x03, 0x20, 0x01, 0x42, 0x22, - 0x00, 0x04, 0x20, 0x01, 0x43, 0xf0, 0x06, 0x05, 0x20, 0x01, 0x4a, 0xd1, - 0x3f, 0x06, 0x20, 0x01, 0x44, 0xdf, 0x81, 0x07, 0x20, 0x01, 0x43, 0x00, - 0x89, 0x08, 0x20, 0x41, 0x09, 0xfe, 0x25, 0x0c, 0x59, 0x49, 0x25, 0x70, - 0x24, 0x01, 0x4e, 0x7c, 0x7e, 0x71, 0x24, 0x41, 0x45, 0xaf, 0x3b, 0x72, - 0x24, 0x01, 0x49, 0x61, 0xbe, 0x74, 0x24, 0x01, 0x48, 0xd9, 0xcb, 0x73, - 0x24, 0x41, 0xa5, 0xb5, 0x05, 0xa6, 0xf6, 0x03, 0x02, 0x51, 0x03, 0xa4, - 0x03, 0xaf, 0xb7, 0x02, 0xb3, 0xb5, 0x01, 0xb4, 0x01, 0xff, 0x05, 0x25, - 0x01, 0x4f, 0x03, 0x20, 0x0a, 0x01, 0xff, 0x43, 0xf9, 0x03, 0x00, 0x24, - 0x81, 0x3d, 0xa2, 0x2f, 0x45, 0x3e, 0xe6, 0x59, 0x24, 0x01, 0x04, 0xee, - 0x6b, 0x1d, 0x04, 0x7b, 0x19, 0x11, 0x07, 0xf5, 0x74, 0x01, 0xff, 0x44, - 0xd0, 0x0c, 0x5b, 0x24, 0x01, 0x4e, 0xfe, 0x5e, 0x5e, 0x24, 0x41, 0xd2, - 0x23, 0x24, 0x01, 0xf5, 0x2d, 0x24, 0x41, 0xd2, 0x16, 0x24, 0x01, 0xf5, - 0x1f, 0x24, 0x41, 0x43, 0x95, 0x60, 0x50, 0x24, 0x01, 0x43, 0xda, 0xaa, - 0x35, 0x24, 0x41, 0x45, 0x88, 0x60, 0x4a, 0x24, 0x41, 0x43, 0xf9, 0x03, - 0x01, 0x24, 0x81, 0x52, 0xa2, 0x3d, 0x44, 0xd0, 0x0c, 0x08, 0x24, 0x01, - 0x04, 0xee, 0x6b, 0x2b, 0x04, 0x7b, 0x19, 0x11, 0x10, 0x5d, 0x68, 0x01, - 0xff, 0x42, 0x0f, 0xf5, 0x3a, 0x24, 0x01, 0x42, 0xaf, 0xd8, 0x3b, 0x24, - 0x41, 0xd2, 0x24, 0x24, 0x81, 0x0b, 0xf5, 0x2e, 0x24, 0xc1, 0x00, 0x4d, - 0xce, 0x7f, 0x2f, 0x24, 0x41, 0x4d, 0xce, 0x7f, 0x25, 0x24, 0x41, 0xd2, - 0x17, 0x24, 0x01, 0xf5, 0x20, 0x24, 0x41, 0x43, 0x95, 0x60, 0x51, 0x24, - 0x01, 0x43, 0xda, 0xaa, 0x36, 0x24, 0xc1, 0x00, 0x4d, 0xce, 0x7f, 0x37, - 0x24, 0x41, 0x45, 0x88, 0x60, 0x4b, 0x24, 0x41, 0x05, 0x72, 0x22, 0x45, - 0x14, 0xc3, 0x42, 0x35, 0x03, 0x06, 0x53, 0x01, 0xff, 0x43, 0xf9, 0x03, - 0x04, 0x24, 0x81, 0x23, 0x44, 0xd0, 0x0c, 0x0b, 0x24, 0x01, 0x45, 0xc0, - 0xe6, 0x1a, 0x24, 0x01, 0x45, 0xf8, 0xea, 0x28, 0x24, 0x01, 0xf5, 0x11, - 0x24, 0x81, 0x06, 0x51, 0xfe, 0x5e, 0x40, 0x24, 0x41, 0x4d, 0xce, 0x7f, - 0x6b, 0x24, 0x41, 0x45, 0x88, 0x60, 0x4e, 0x24, 0x41, 0x44, 0xd0, 0x0c, - 0x32, 0x24, 0x01, 0x43, 0xcb, 0x13, 0x33, 0x24, 0x41, 0x43, 0xf9, 0x03, - 0x05, 0x24, 0x01, 0x44, 0xd0, 0x0c, 0x0c, 0x24, 0x01, 0x45, 0xc0, 0xe6, - 0x1b, 0x24, 0x01, 0x45, 0xf8, 0xea, 0x29, 0x24, 0x01, 0xf5, 0x12, 0x24, - 0x81, 0x13, 0x11, 0x0f, 0x5f, 0x01, 0xff, 0x80, 0x04, 0xd3, 0x41, 0x24, - 0x41, 0xe1, 0x42, 0x24, 0x01, 0xe2, 0x43, 0x24, 0x41, 0x4d, 0xce, 0x7f, - 0x6c, 0x24, 0x41, 0x10, 0x6d, 0x64, 0x5a, 0x03, 0xef, 0x07, 0x01, 0xff, - 0xa2, 0x47, 0xa5, 0x39, 0x04, 0xee, 0x6b, 0x2d, 0x48, 0xb1, 0xc6, 0x64, - 0x24, 0x01, 0x08, 0x04, 0x03, 0x17, 0x45, 0x02, 0xeb, 0x2c, 0x24, 0x01, - 0x06, 0x4d, 0x89, 0x01, 0xff, 0x44, 0xd0, 0x0c, 0x5a, 0x24, 0x01, 0x4e, - 0xfe, 0x5e, 0x5d, 0x24, 0x41, 0x43, 0xf9, 0x03, 0x60, 0x24, 0x01, 0x43, - 0x99, 0x80, 0x63, 0x24, 0x41, 0xd2, 0x15, 0x24, 0x01, 0xf5, 0x1e, 0x24, - 0x41, 0x49, 0x3b, 0xba, 0x5f, 0x24, 0x01, 0x44, 0x3f, 0xe6, 0x58, 0x24, - 0x41, 0x43, 0x95, 0x60, 0x4f, 0x24, 0x01, 0x43, 0xda, 0xaa, 0x34, 0x24, - 0x41, 0x47, 0x2a, 0x01, 0x62, 0x24, 0x01, 0x45, 0x06, 0xe0, 0x61, 0x24, - 0x41, 0x04, 0x1d, 0xf0, 0x3d, 0x03, 0xef, 0x07, 0x01, 0xff, 0x43, 0xf9, - 0x03, 0x07, 0x24, 0x01, 0x44, 0xd0, 0x0c, 0x0e, 0x24, 0x01, 0x45, 0xc0, - 0xe6, 0x1d, 0x24, 0x01, 0x45, 0xf8, 0xea, 0x2b, 0x24, 0x01, 0xf5, 0x14, - 0x24, 0x81, 0x15, 0x53, 0x6b, 0x4e, 0x46, 0x24, 0xc1, 0x00, 0x42, 0x19, - 0x00, 0x49, 0x24, 0x01, 0xd3, 0x47, 0x24, 0x01, 0xd4, 0x48, 0x24, 0x41, - 0x4d, 0xce, 0x7f, 0x6e, 0x24, 0x41, 0x43, 0x9a, 0x5a, 0x57, 0x24, 0x01, - 0x43, 0xcb, 0x13, 0x56, 0x24, 0x41, 0x04, 0xd2, 0x05, 0x65, 0x04, 0xf6, - 0x06, 0x01, 0xff, 0x43, 0xf9, 0x03, 0x02, 0x24, 0x81, 0x53, 0xa2, 0x3e, - 0x44, 0xd0, 0x0c, 0x09, 0x24, 0x01, 0x04, 0xee, 0x6b, 0x2c, 0x04, 0x7b, - 0x19, 0x20, 0xf5, 0x0f, 0x24, 0x81, 0x15, 0x52, 0x66, 0x56, 0x3c, 0x24, - 0xc1, 0x00, 0x80, 0x04, 0xd4, 0x3d, 0x24, 0x41, 0xe1, 0x3e, 0x24, 0x01, - 0xe2, 0x3f, 0x24, 0x41, 0x4d, 0xce, 0x7f, 0x69, 0x24, 0x41, 0xd2, 0x26, - 0x24, 0x01, 0xf5, 0x30, 0x24, 0x41, 0xd2, 0x18, 0x24, 0x01, 0xf5, 0x21, - 0x24, 0x41, 0x43, 0x95, 0x60, 0x52, 0x24, 0x81, 0x06, 0x43, 0xda, 0xaa, - 0x38, 0x24, 0x41, 0x4d, 0xce, 0x7f, 0x53, 0x24, 0x41, 0x45, 0x88, 0x60, - 0x4c, 0x24, 0x41, 0x43, 0xf9, 0x03, 0x03, 0x24, 0x81, 0x46, 0xa2, 0x31, - 0x44, 0xd0, 0x0c, 0x0a, 0x24, 0x01, 0x04, 0xee, 0x6b, 0x1f, 0xb3, 0x0b, - 0xf5, 0x10, 0x24, 0xc1, 0x00, 0x4d, 0xce, 0x7f, 0x6a, 0x24, 0x41, 0x03, - 0xc9, 0x02, 0x06, 0x4a, 0x48, 0xac, 0x5c, 0x24, 0x41, 0xd2, 0x27, 0x24, - 0x01, 0xf5, 0x31, 0x24, 0x41, 0xd2, 0x19, 0x24, 0x01, 0xf5, 0x22, 0x24, - 0x41, 0x43, 0x95, 0x60, 0x54, 0x24, 0x81, 0x06, 0x43, 0xda, 0xaa, 0x39, - 0x24, 0x41, 0x4d, 0xce, 0x7f, 0x55, 0x24, 0x41, 0x45, 0x88, 0x60, 0x4d, - 0x24, 0x41, 0x05, 0xc9, 0x00, 0x1f, 0x07, 0xcc, 0xd2, 0x01, 0xff, 0xa6, - 0x0c, 0x49, 0x4a, 0xbd, 0x65, 0x24, 0x01, 0x4a, 0x74, 0xb2, 0x66, 0x24, - 0x41, 0x44, 0x58, 0x4d, 0x68, 0x24, 0x01, 0x44, 0xd5, 0x51, 0x67, 0x24, - 0x41, 0x43, 0xf9, 0x03, 0x06, 0x24, 0x01, 0x44, 0xd0, 0x0c, 0x0d, 0x24, - 0x01, 0x45, 0xc0, 0xe6, 0x1c, 0x24, 0x01, 0x45, 0xf8, 0xea, 0x2a, 0x24, - 0x01, 0xf5, 0x13, 0x24, 0x81, 0x0b, 0x51, 0x20, 0x5f, 0x44, 0x24, 0xc1, - 0x00, 0xd3, 0x45, 0x24, 0x41, 0x4d, 0xce, 0x7f, 0x6d, 0x24, 0x41, 0x42, - 0x5c, 0x00, 0x80, 0xf9, 0x01, 0xa5, 0xa1, 0x01, 0x45, 0xfe, 0x78, 0x97, - 0xf9, 0x81, 0x93, 0x01, 0xaf, 0x27, 0xb5, 0x19, 0xb9, 0x01, 0xff, 0x04, - 0xa1, 0x01, 0x06, 0x49, 0x8a, 0xbf, 0x2e, 0xf5, 0x41, 0x48, 0x64, 0x1f, - 0x3f, 0xf6, 0x01, 0x44, 0x0c, 0x08, 0x22, 0xf6, 0x41, 0x43, 0x98, 0x21, - 0x7c, 0xfa, 0x01, 0x4a, 0x2c, 0xb4, 0xa2, 0x20, 0x40, 0x46, 0xd2, 0xda, - 0x0a, 0xf4, 0x01, 0x46, 0x36, 0xdd, 0x50, 0xf9, 0x01, 0x02, 0xee, 0x00, - 0x06, 0x42, 0xa7, 0x01, 0x51, 0xf4, 0x41, 0x80, 0x1c, 0x03, 0x05, 0x00, - 0x06, 0x49, 0xb0, 0xba, 0xcc, 0x26, 0x40, 0x45, 0x89, 0xe6, 0x8c, 0xf3, - 0x01, 0x67, 0xcd, 0x05, 0x8a, 0xf1, 0x01, 0x46, 0x60, 0xe0, 0x94, 0x26, - 0x40, 0x44, 0xb9, 0x00, 0x4c, 0x27, 0x00, 0x03, 0xf4, 0x01, 0x20, 0xb0, - 0x01, 0xff, 0x0a, 0x2e, 0xa8, 0x0d, 0x45, 0x5f, 0xdf, 0x42, 0xf5, 0xc1, - 0x00, 0x57, 0xd5, 0x2c, 0x41, 0xf5, 0x41, 0x4d, 0x16, 0x85, 0x51, 0x2e, - 0x00, 0x4e, 0xce, 0x7b, 0x50, 0x2e, 0x40, 0x49, 0x01, 0xbb, 0x29, 0x26, - 0x00, 0x48, 0x11, 0xc8, 0x28, 0x26, 0x40, 0x4d, 0x59, 0x7f, 0xcf, 0xf3, - 0x41, 0x48, 0x49, 0xc5, 0xb3, 0xf4, 0x01, 0x4a, 0x4a, 0x41, 0x19, 0xf3, - 0x41, 0x42, 0x8a, 0x00, 0xe5, 0xf9, 0x01, 0xa3, 0x9c, 0x25, 0x44, 0xe9, - 0xef, 0xb0, 0x26, 0x00, 0x42, 0x9e, 0x01, 0x99, 0xfa, 0x01, 0xac, 0xf1, - 0x24, 0xad, 0xbd, 0x0c, 0xae, 0xad, 0x0b, 0x02, 0x55, 0x05, 0x95, 0x0b, - 0xb0, 0xcb, 0x01, 0xb2, 0xb6, 0x01, 0xb5, 0x0b, 0xf7, 0x04, 0xf4, 0xc1, - 0x00, 0x45, 0x0b, 0x08, 0x2e, 0xf4, 0x41, 0x4b, 0x34, 0x9a, 0xcb, 0xf6, - 0x01, 0x02, 0x11, 0x00, 0x06, 0x4e, 0x34, 0x7b, 0x91, 0xf4, 0x41, 0x02, - 0x33, 0x00, 0x88, 0x01, 0x08, 0x41, 0xc7, 0x01, 0xff, 0x0b, 0x5b, 0xa3, - 0x42, 0x0b, 0x79, 0xa4, 0x01, 0xff, 0x45, 0x12, 0x0b, 0x67, 0xd3, 0x01, - 0xa6, 0x29, 0x44, 0xea, 0x2a, 0x68, 0xd3, 0x01, 0x43, 0x0e, 0x0b, 0x60, - 0xd3, 0x01, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0x62, 0xd3, - 0x01, 0x42, 0x15, 0x02, 0x61, 0xd3, 0x41, 0x44, 0xe5, 0x1d, 0x66, 0xd3, - 0x01, 0x42, 0x1c, 0x26, 0x65, 0xd3, 0x41, 0x43, 0xd2, 0x05, 0x64, 0xd3, - 0x01, 0x43, 0xf6, 0x06, 0x63, 0xd3, 0x41, 0x45, 0x12, 0x0b, 0x70, 0xd3, - 0x01, 0xa6, 0x29, 0x44, 0xea, 0x2a, 0x71, 0xd3, 0x01, 0x43, 0x0e, 0x0b, - 0x69, 0xd3, 0x01, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0x6b, - 0xd3, 0x01, 0x42, 0x15, 0x02, 0x6a, 0xd3, 0x41, 0x44, 0xe5, 0x1d, 0x6f, - 0xd3, 0x01, 0x42, 0x1c, 0x26, 0x6e, 0xd3, 0x41, 0x43, 0xd2, 0x05, 0x6d, - 0xd3, 0x01, 0x43, 0xf6, 0x06, 0x6c, 0xd3, 0x41, 0x44, 0x69, 0xef, 0x34, - 0x23, 0x00, 0x44, 0xd1, 0xf2, 0x35, 0x23, 0x40, 0x42, 0x13, 0x00, 0xb8, - 0xfa, 0x01, 0x52, 0xde, 0x53, 0x4f, 0x2e, 0x00, 0x4b, 0x06, 0xa2, 0x58, - 0x22, 0x40, 0x04, 0x28, 0x20, 0x0f, 0xb9, 0x01, 0xff, 0x4b, 0xc2, 0x9e, - 0x2f, 0xf1, 0x01, 0x4a, 0x76, 0xb0, 0xa9, 0x00, 0x40, 0xa3, 0xed, 0x05, - 0x06, 0x7a, 0xdb, 0x90, 0x04, 0xa6, 0x81, 0x04, 0x55, 0x19, 0x3d, 0xff, - 0x2c, 0x00, 0x0b, 0xbc, 0xa0, 0xde, 0x03, 0xb3, 0x01, 0xff, 0x0c, 0x77, - 0x08, 0x33, 0x06, 0x60, 0x16, 0x01, 0xff, 0xab, 0x20, 0x45, 0xc3, 0xe8, - 0xe5, 0x2c, 0x00, 0x45, 0x03, 0xea, 0xe6, 0x2c, 0x00, 0xb3, 0x06, 0x46, - 0x8a, 0xe0, 0xe8, 0x2c, 0x40, 0x49, 0xbd, 0xb9, 0xea, 0x2c, 0x00, 0x46, - 0x90, 0xe0, 0xe7, 0x2c, 0x40, 0x42, 0x56, 0x07, 0xe4, 0x2c, 0x00, 0x45, - 0x9e, 0xca, 0xe9, 0x2c, 0x40, 0xa1, 0x95, 0x03, 0x4d, 0x3a, 0x81, 0xf3, - 0x2c, 0x00, 0x02, 0x75, 0x06, 0xe7, 0x02, 0xa4, 0xbb, 0x02, 0x43, 0x55, - 0xf4, 0x89, 0x2c, 0x00, 0xa6, 0xa8, 0x02, 0x02, 0x24, 0x02, 0x97, 0x02, - 0xa8, 0x88, 0x02, 0x45, 0x60, 0xe7, 0x93, 0x2c, 0x00, 0xab, 0xe7, 0x01, - 0xac, 0xd8, 0x01, 0x42, 0x7d, 0x02, 0x99, 0x2c, 0x00, 0x42, 0x51, 0x03, - 0x9b, 0x2c, 0x00, 0xef, 0x9f, 0x2c, 0x80, 0x54, 0xb0, 0x48, 0x42, 0xd0, - 0x00, 0xa3, 0x2c, 0x00, 0xb3, 0x20, 0xb4, 0x12, 0x42, 0x7d, 0x00, 0xa9, - 0x2c, 0x00, 0x44, 0x29, 0xf3, 0x83, 0x2c, 0x00, 0x44, 0x79, 0xf3, 0x8d, - 0x2c, 0x40, 0x42, 0x61, 0x24, 0xa7, 0x2c, 0x00, 0x45, 0x1a, 0xe7, 0x91, - 0x2c, 0x40, 0x44, 0x58, 0x94, 0xc1, 0x2c, 0x00, 0xa8, 0x0c, 0x43, 0xe3, - 0x0c, 0xa5, 0x2c, 0x00, 0x42, 0x3c, 0x01, 0x8b, 0x2c, 0x40, 0x42, 0x12, - 0x0b, 0xe3, 0x03, 0x00, 0x43, 0xe3, 0x0c, 0xed, 0x03, 0x40, 0xe9, 0xa1, - 0x2c, 0x00, 0x42, 0x5a, 0x03, 0xaf, 0x2c, 0x40, 0x03, 0x05, 0x24, 0x06, - 0x42, 0x3c, 0x01, 0xb1, 0x2c, 0x40, 0x07, 0x33, 0xd0, 0x1f, 0x07, 0xc0, - 0xa0, 0x01, 0xff, 0xae, 0x0c, 0x45, 0x07, 0xeb, 0xdd, 0x2c, 0x00, 0x43, - 0x2a, 0xa4, 0xe3, 0x2c, 0x40, 0x42, 0xf1, 0x06, 0xdf, 0x2c, 0x00, 0x42, - 0x9a, 0x1a, 0xe1, 0x2c, 0x40, 0x43, 0x56, 0x07, 0xb5, 0x2c, 0x00, 0x43, - 0x46, 0xf4, 0xd9, 0x2c, 0x00, 0x43, 0x9a, 0x5a, 0xc7, 0x2c, 0x00, 0x46, - 0xfe, 0xdb, 0xd7, 0x2c, 0x00, 0xa8, 0x17, 0x43, 0x9b, 0x93, 0xbf, 0x2c, - 0x00, 0x02, 0xa4, 0x02, 0x01, 0xff, 0x42, 0x12, 0x0b, 0xc5, 0x2c, 0x00, - 0x43, 0xe3, 0x0c, 0xdb, 0x2c, 0x40, 0xe1, 0xcf, 0x2c, 0x80, 0x0c, 0x42, - 0x12, 0x0b, 0xd3, 0x2c, 0x00, 0x43, 0x0c, 0x00, 0xcd, 0x2c, 0x40, 0xf4, - 0xd5, 0x2c, 0x40, 0x4a, 0xda, 0xa6, 0xd1, 0x2c, 0x00, 0x44, 0x49, 0xef, - 0x97, 0x2c, 0x40, 0x43, 0x96, 0x3d, 0x95, 0x2c, 0x00, 0xa8, 0x06, 0x42, - 0x5a, 0x03, 0x9d, 0x2c, 0x40, 0x42, 0x12, 0x0b, 0xe7, 0x03, 0x00, 0xe9, - 0xad, 0x2c, 0x40, 0x43, 0x8a, 0x00, 0x8f, 0x2c, 0x00, 0x43, 0x0c, 0x00, - 0xe9, 0x03, 0x40, 0x43, 0x15, 0x05, 0x85, 0x2c, 0x00, 0x44, 0x00, 0xdc, - 0xeb, 0x03, 0x40, 0x42, 0x12, 0x0b, 0xe5, 0x03, 0x00, 0xe9, 0xab, 0x2c, - 0x40, 0x44, 0x15, 0xef, 0x87, 0x2c, 0x00, 0x42, 0x12, 0x0b, 0xef, 0x03, - 0x00, 0x09, 0x0e, 0xba, 0x01, 0xff, 0x44, 0x67, 0x00, 0xb3, 0x2c, 0x00, - 0x44, 0x0b, 0x00, 0xcb, 0x2c, 0x00, 0x44, 0xef, 0xc9, 0xb9, 0x2c, 0x00, - 0x42, 0x51, 0x03, 0xbb, 0x2c, 0x40, 0x4a, 0x36, 0xaf, 0xc3, 0x2c, 0x00, - 0x0c, 0xef, 0x24, 0x01, 0xff, 0x43, 0x55, 0xf4, 0xb7, 0x2c, 0x00, 0x46, - 0xfe, 0xdb, 0xee, 0x2c, 0x00, 0x42, 0x51, 0x03, 0xbd, 0x2c, 0x00, 0x44, - 0x3c, 0xaf, 0xec, 0x2c, 0x40, 0x4c, 0xc0, 0x90, 0xc9, 0x2c, 0x00, 0x43, - 0x91, 0xf4, 0x81, 0x2c, 0x40, 0x54, 0xba, 0x34, 0xfa, 0x2c, 0x00, 0x49, - 0x81, 0x16, 0xf9, 0x2c, 0x00, 0x56, 0xb8, 0x34, 0xfb, 0x2c, 0x00, 0x4d, - 0xe3, 0x53, 0xfc, 0x2c, 0x40, 0x50, 0x26, 0x5a, 0xfd, 0x2c, 0x00, 0x48, - 0x82, 0x16, 0xfe, 0x2c, 0x40, 0x06, 0xef, 0x06, 0x96, 0x01, 0x07, 0x1a, - 0x3a, 0x06, 0x4e, 0x02, 0x7d, 0xe0, 0x02, 0x41, 0x05, 0x12, 0x0b, 0x7e, - 0xa6, 0x5f, 0x04, 0xea, 0x2a, 0x4f, 0x4b, 0x6d, 0x11, 0xf3, 0x02, 0x01, - 0xb3, 0x26, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0xea, 0x02, 0x01, 0xa8, - 0x0f, 0xb7, 0x01, 0xff, 0x44, 0xe7, 0x1d, 0xeb, 0x02, 0x01, 0x49, 0xda, - 0x1d, 0xf4, 0x02, 0x41, 0x44, 0x7b, 0x11, 0xec, 0x02, 0x01, 0x4b, 0x17, - 0x18, 0xf5, 0x02, 0x41, 0x04, 0xe5, 0x1d, 0x11, 0x02, 0x1c, 0x26, 0x01, - 0xff, 0x48, 0x70, 0x11, 0xf8, 0x02, 0x01, 0x42, 0x7d, 0x11, 0xef, 0x02, - 0x41, 0x48, 0x70, 0x11, 0xf9, 0x02, 0x01, 0x42, 0x7d, 0x11, 0xf0, 0x02, - 0x41, 0x48, 0x70, 0x11, 0xfb, 0x02, 0x01, 0x42, 0x7d, 0x11, 0xf2, 0x02, - 0x41, 0xa9, 0x0f, 0xaf, 0x01, 0xff, 0x43, 0x7c, 0x11, 0xed, 0x02, 0x01, - 0x4a, 0x14, 0xb3, 0xf6, 0x02, 0x41, 0x43, 0x59, 0x4d, 0xee, 0x02, 0x01, - 0x4a, 0x9d, 0x39, 0xf7, 0x02, 0x41, 0x48, 0x70, 0x11, 0xfa, 0x02, 0x01, - 0xf9, 0xf1, 0x02, 0x41, 0x45, 0x12, 0x0b, 0xe8, 0x02, 0x01, 0xa6, 0x29, - 0x44, 0xea, 0x2a, 0xe9, 0x02, 0x01, 0x43, 0x0e, 0x0b, 0xe1, 0x02, 0x01, - 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0xe3, 0x02, 0x01, 0x42, - 0x15, 0x02, 0xe2, 0x02, 0x41, 0x44, 0xe5, 0x1d, 0xe7, 0x02, 0x01, 0x42, - 0x1c, 0x26, 0xe6, 0x02, 0x41, 0x43, 0xd2, 0x05, 0xe5, 0x02, 0x01, 0x43, - 0xf6, 0x06, 0xe4, 0x02, 0x41, 0x0e, 0xe5, 0x05, 0x1c, 0x09, 0x33, 0x16, - 0x01, 0xff, 0x48, 0xd1, 0xc8, 0xef, 0x2c, 0x00, 0x09, 0x78, 0xbf, 0x01, - 0xff, 0x45, 0x9a, 0xe4, 0xf0, 0x2c, 0x00, 0x45, 0x4b, 0xe8, 0xf1, 0x2c, - 0x40, 0xa1, 0x95, 0x03, 0x4d, 0x3a, 0x81, 0xf2, 0x2c, 0x00, 0x02, 0x75, - 0x06, 0xe7, 0x02, 0xa4, 0xbb, 0x02, 0x43, 0x55, 0xf4, 0x88, 0x2c, 0x00, - 0xa6, 0xa8, 0x02, 0x02, 0x24, 0x02, 0x97, 0x02, 0xa8, 0x88, 0x02, 0x45, - 0x60, 0xe7, 0x92, 0x2c, 0x00, 0xab, 0xe7, 0x01, 0xac, 0xd8, 0x01, 0x42, - 0x7d, 0x02, 0x98, 0x2c, 0x00, 0x42, 0x51, 0x03, 0x9a, 0x2c, 0x00, 0xef, - 0x9e, 0x2c, 0x80, 0x54, 0xb0, 0x48, 0x42, 0xd0, 0x00, 0xa2, 0x2c, 0x00, - 0xb3, 0x20, 0xb4, 0x12, 0x42, 0x7d, 0x00, 0xa8, 0x2c, 0x00, 0x44, 0x29, - 0xf3, 0x82, 0x2c, 0x00, 0x44, 0x79, 0xf3, 0x8c, 0x2c, 0x40, 0x42, 0x61, - 0x24, 0xa6, 0x2c, 0x00, 0x45, 0x1a, 0xe7, 0x90, 0x2c, 0x40, 0x44, 0x58, - 0x94, 0xc0, 0x2c, 0x00, 0xa8, 0x0c, 0x43, 0xe3, 0x0c, 0xa4, 0x2c, 0x00, - 0x42, 0x3c, 0x01, 0x8a, 0x2c, 0x40, 0x42, 0x12, 0x0b, 0xe2, 0x03, 0x00, - 0x43, 0xe3, 0x0c, 0xec, 0x03, 0x40, 0xe9, 0xa0, 0x2c, 0x00, 0x42, 0x5a, - 0x03, 0xae, 0x2c, 0x40, 0x03, 0x05, 0x24, 0x06, 0x42, 0x3c, 0x01, 0xb0, - 0x2c, 0x40, 0x07, 0x33, 0xd0, 0x1f, 0x07, 0xc0, 0xa0, 0x01, 0xff, 0xae, - 0x0c, 0x45, 0x07, 0xeb, 0xdc, 0x2c, 0x00, 0x43, 0x2a, 0xa4, 0xe2, 0x2c, - 0x40, 0x42, 0xf1, 0x06, 0xde, 0x2c, 0x00, 0x42, 0x9a, 0x1a, 0xe0, 0x2c, - 0x40, 0x43, 0x56, 0x07, 0xb4, 0x2c, 0x00, 0x43, 0x46, 0xf4, 0xd8, 0x2c, - 0x00, 0x43, 0x9a, 0x5a, 0xc6, 0x2c, 0x00, 0x46, 0xfe, 0xdb, 0xd6, 0x2c, - 0x00, 0xa8, 0x17, 0x43, 0x9b, 0x93, 0xbe, 0x2c, 0x00, 0x02, 0xa4, 0x02, - 0x01, 0xff, 0x42, 0x12, 0x0b, 0xc4, 0x2c, 0x00, 0x43, 0xe3, 0x0c, 0xda, - 0x2c, 0x40, 0xe1, 0xce, 0x2c, 0x80, 0x0c, 0x42, 0x12, 0x0b, 0xd2, 0x2c, - 0x00, 0x43, 0x0c, 0x00, 0xcc, 0x2c, 0x40, 0xf4, 0xd4, 0x2c, 0x40, 0x4a, - 0xda, 0xa6, 0xd0, 0x2c, 0x00, 0x44, 0x49, 0xef, 0x96, 0x2c, 0x40, 0x43, - 0x96, 0x3d, 0x94, 0x2c, 0x00, 0xa8, 0x06, 0x42, 0x5a, 0x03, 0x9c, 0x2c, - 0x40, 0x42, 0x12, 0x0b, 0xe6, 0x03, 0x00, 0xe9, 0xac, 0x2c, 0x40, 0x43, - 0x8a, 0x00, 0x8e, 0x2c, 0x00, 0x43, 0x0c, 0x00, 0xe8, 0x03, 0x40, 0x43, - 0x15, 0x05, 0x84, 0x2c, 0x00, 0x44, 0x00, 0xdc, 0xea, 0x03, 0x40, 0x42, - 0x12, 0x0b, 0xe4, 0x03, 0x00, 0xe9, 0xaa, 0x2c, 0x40, 0x44, 0x15, 0xef, - 0x86, 0x2c, 0x00, 0x42, 0x12, 0x0b, 0xee, 0x03, 0x00, 0x09, 0x0e, 0xba, - 0x01, 0xff, 0x44, 0x67, 0x00, 0xb2, 0x2c, 0x00, 0x44, 0x0b, 0x00, 0xca, - 0x2c, 0x00, 0x44, 0xef, 0xc9, 0xb8, 0x2c, 0x00, 0x42, 0x51, 0x03, 0xba, - 0x2c, 0x40, 0x4a, 0x36, 0xaf, 0xc2, 0x2c, 0x00, 0x0c, 0xef, 0x24, 0x01, - 0xff, 0x43, 0x55, 0xf4, 0xb6, 0x2c, 0x00, 0x46, 0xfe, 0xdb, 0xed, 0x2c, - 0x00, 0x42, 0x51, 0x03, 0xbc, 0x2c, 0x00, 0x44, 0x3c, 0xaf, 0xeb, 0x2c, - 0x40, 0x4c, 0xc0, 0x90, 0xc8, 0x2c, 0x00, 0x43, 0x91, 0xf4, 0x80, 0x2c, - 0x40, 0x47, 0xcd, 0xd0, 0x5a, 0xf3, 0x01, 0xa9, 0x01, 0xff, 0xe5, 0x6a, - 0xf3, 0x01, 0x42, 0x1d, 0x01, 0x73, 0xf3, 0x41, 0xa6, 0x79, 0x55, 0x8a, - 0x3b, 0x6d, 0x2a, 0x00, 0x4a, 0x8a, 0xab, 0x32, 0x23, 0x00, 0x48, 0x81, - 0xc7, 0x0c, 0x26, 0x00, 0x0a, 0x98, 0xb1, 0x57, 0xb4, 0x06, 0x4e, 0x60, - 0x7e, 0xea, 0xf3, 0x41, 0x05, 0x81, 0x69, 0x1d, 0x57, 0xe8, 0x1a, 0x81, - 0x23, 0x00, 0x4c, 0x62, 0x71, 0x2e, 0x22, 0x00, 0x04, 0x67, 0x8a, 0x01, - 0xff, 0x45, 0xfb, 0xe7, 0x9b, 0xf3, 0x01, 0x53, 0xef, 0x4c, 0x9b, 0x00, - 0x40, 0x03, 0x4a, 0x03, 0x17, 0x05, 0x51, 0x00, 0x01, 0xff, 0x56, 0x94, - 0x35, 0xfa, 0x22, 0x00, 0x47, 0xfb, 0x7f, 0xfd, 0x22, 0x00, 0x68, 0x30, - 0x05, 0xfb, 0x22, 0x40, 0x46, 0xb4, 0x05, 0x0b, 0x22, 0x00, 0x4f, 0xf0, - 0x53, 0xb3, 0x22, 0xc0, 0x00, 0x4c, 0x0d, 0x29, 0xb5, 0x22, 0x40, 0x44, - 0x5a, 0x03, 0xa7, 0xf6, 0x01, 0x46, 0x74, 0xe1, 0x77, 0xf4, 0x41, 0x49, - 0xdc, 0xb8, 0x8a, 0xf3, 0x01, 0x4b, 0x35, 0xa1, 0x16, 0xf6, 0x01, 0x49, - 0x2e, 0x99, 0x15, 0xf6, 0x41, 0x07, 0x35, 0x16, 0x38, 0x42, 0xed, 0x05, - 0x04, 0x26, 0x00, 0xad, 0x1b, 0xb0, 0x01, 0xff, 0x43, 0x1f, 0x20, 0xed, - 0xf9, 0x01, 0x46, 0x67, 0x92, 0x01, 0x22, 0x00, 0x4e, 0xb6, 0x7a, 0x84, - 0x23, 0x00, 0x47, 0x8d, 0x66, 0xdc, 0xf5, 0x41, 0xe1, 0x2c, 0x00, 0x00, - 0x07, 0xa6, 0xb8, 0x01, 0xff, 0x42, 0x8a, 0x00, 0x40, 0x00, 0x00, 0x4a, - 0x88, 0x98, 0x52, 0x20, 0x40, 0xa1, 0x8a, 0x17, 0xa2, 0xda, 0x16, 0xa3, - 0x8a, 0x13, 0xa4, 0xae, 0x0f, 0xa5, 0xe9, 0x0e, 0xa6, 0xd4, 0x0e, 0xa7, - 0x8f, 0x0b, 0x02, 0x0b, 0x00, 0xf8, 0x0a, 0xa9, 0xaf, 0x0a, 0x02, 0x1b, - 0x02, 0x89, 0x0a, 0xac, 0xed, 0x05, 0xad, 0x8e, 0x05, 0xae, 0xff, 0x04, - 0xaf, 0xc1, 0x04, 0xb0, 0x8e, 0x04, 0xb2, 0xda, 0x02, 0xb3, 0xfb, 0x01, - 0xb4, 0xb4, 0x01, 0xb5, 0x82, 0x01, 0x08, 0x32, 0x00, 0x41, 0x02, 0x51, - 0x00, 0x27, 0xb8, 0x11, 0x07, 0xfc, 0x33, 0x01, 0xff, 0x45, 0x5c, 0x00, - 0x5b, 0x03, 0x00, 0x45, 0x20, 0x07, 0xcf, 0x1d, 0x40, 0x80, 0x06, 0x48, - 0xf9, 0xc2, 0xb5, 0x1a, 0x40, 0x45, 0x5c, 0x00, 0x3d, 0x03, 0x00, 0x45, - 0x20, 0x07, 0x53, 0x03, 0x40, 0x03, 0x4e, 0x04, 0x06, 0x4f, 0x9f, 0x6d, - 0xb6, 0x1a, 0x40, 0x4c, 0x00, 0x8d, 0xe9, 0x20, 0x00, 0x55, 0x47, 0x3c, - 0xf9, 0x1d, 0x40, 0x80, 0x25, 0x06, 0x86, 0xd8, 0x01, 0xff, 0x45, 0x14, - 0x39, 0xd0, 0x1a, 0x80, 0x13, 0x45, 0x17, 0x23, 0xd2, 0x1a, 0x80, 0x06, - 0x46, 0xb4, 0x70, 0xd4, 0x1a, 0x40, 0x46, 0xac, 0x9c, 0xd7, 0x1a, 0x40, - 0x46, 0xef, 0x98, 0xd6, 0x1a, 0x40, 0x05, 0xed, 0x07, 0x06, 0x45, 0x37, - 0x23, 0x3e, 0x03, 0x40, 0x45, 0x5c, 0x00, 0x0d, 0x03, 0x00, 0x45, 0x20, - 0x07, 0x29, 0x03, 0x40, 0xb0, 0x0c, 0x47, 0xf8, 0x06, 0xd1, 0x1d, 0x00, - 0x47, 0xf9, 0x0e, 0xd2, 0x1d, 0x40, 0x06, 0x68, 0xd8, 0x11, 0x0c, 0xdf, - 0x03, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xea, 0x1a, 0x00, 0x45, 0x20, 0x07, - 0x4e, 0x03, 0x40, 0x45, 0x5c, 0x00, 0xf5, 0x1d, 0x00, 0x45, 0x20, 0x07, - 0x1d, 0x03, 0x40, 0x4f, 0xae, 0x12, 0xdb, 0x20, 0x00, 0x44, 0x38, 0x23, - 0x03, 0x03, 0x80, 0x1c, 0x06, 0x87, 0x1d, 0x06, 0x51, 0xdc, 0x5e, 0x12, - 0x03, 0x40, 0x4c, 0x10, 0x8c, 0xcb, 0x1a, 0x00, 0x43, 0x23, 0x0a, 0xb4, - 0x1a, 0x00, 0x48, 0x29, 0xcc, 0xe8, 0x20, 0x40, 0x80, 0x01, 0xff, 0x45, - 0x20, 0x07, 0x30, 0x03, 0x00, 0x4f, 0x70, 0x6f, 0x29, 0xfe, 0x00, 0x47, - 0x03, 0x23, 0x34, 0x03, 0x00, 0x50, 0xad, 0x66, 0x2a, 0xfe, 0x40, 0x07, - 0xb8, 0xd0, 0x4c, 0xa8, 0x2b, 0x4a, 0x50, 0xae, 0xc2, 0x1d, 0x00, 0x06, - 0xd7, 0x24, 0x0c, 0x61, 0xb0, 0x0e, 0xba, 0x1a, 0x00, 0x4e, 0x52, 0x7e, - 0xc3, 0x1d, 0x40, 0x45, 0x5c, 0x00, 0xe4, 0x1a, 0x00, 0xa2, 0x01, 0xff, - 0x44, 0x21, 0x07, 0x3b, 0x03, 0x00, 0x4d, 0xc7, 0x87, 0xc5, 0x1a, 0x40, - 0x48, 0x18, 0xb1, 0xd9, 0x1a, 0x00, 0x04, 0x35, 0x07, 0x01, 0xff, 0xb3, - 0x06, 0x55, 0xe7, 0x3e, 0xd3, 0x20, 0x40, 0x4e, 0xa2, 0x33, 0x37, 0x03, - 0x00, 0x4d, 0xfd, 0x49, 0x35, 0x03, 0x40, 0x45, 0x5c, 0x00, 0xe5, 0x1a, - 0x00, 0x45, 0x20, 0x07, 0x3c, 0x03, 0x40, 0xa5, 0x97, 0x01, 0xa9, 0x01, - 0xff, 0x03, 0xca, 0x00, 0x17, 0x03, 0xa2, 0x01, 0x01, 0xff, 0x45, 0x5c, - 0x00, 0x0a, 0x03, 0x00, 0x45, 0x20, 0x07, 0x25, 0x03, 0x00, 0x47, 0x03, - 0x23, 0xd8, 0x20, 0x40, 0x80, 0x06, 0x61, 0x13, 0x0f, 0xec, 0x20, 0x40, - 0x05, 0xce, 0x00, 0x3b, 0x02, 0x22, 0x00, 0x21, 0x0c, 0xda, 0x21, 0x11, - 0x05, 0x69, 0xd8, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xe1, 0x1a, 0x00, 0x45, - 0x20, 0x07, 0x19, 0x03, 0x40, 0x4b, 0x7f, 0x05, 0xc2, 0x1a, 0x00, 0x4b, - 0xb0, 0x99, 0xc4, 0x1a, 0x40, 0x08, 0xe1, 0xc7, 0x06, 0x4b, 0xcb, 0x02, - 0xd1, 0x20, 0x40, 0x45, 0x5c, 0x00, 0x57, 0x03, 0x00, 0x45, 0x20, 0x07, - 0x39, 0x03, 0x40, 0x80, 0x24, 0x05, 0xbc, 0x1b, 0x01, 0xff, 0xa1, 0x06, - 0x45, 0x20, 0x07, 0x55, 0x03, 0x40, 0x44, 0x5d, 0x00, 0x50, 0x03, 0x00, - 0x03, 0x1b, 0x00, 0x01, 0xff, 0x54, 0xd3, 0x41, 0xff, 0x1d, 0x00, 0x52, - 0x30, 0x56, 0x56, 0x03, 0x40, 0x45, 0x5c, 0x00, 0xd7, 0x20, 0x00, 0x45, - 0x20, 0x07, 0xef, 0x20, 0x40, 0x52, 0xe8, 0x55, 0x22, 0x03, 0x00, 0x05, - 0x3e, 0x04, 0x01, 0xff, 0x50, 0xa0, 0x33, 0xe5, 0x20, 0x00, 0x4d, 0xe0, - 0x5e, 0x14, 0x03, 0x40, 0xa1, 0x11, 0x09, 0xe7, 0x71, 0x01, 0xff, 0x45, - 0x5c, 0x00, 0xc8, 0x1a, 0x00, 0x45, 0x20, 0x07, 0x1f, 0x03, 0x40, 0x54, - 0x17, 0x44, 0x21, 0x03, 0x00, 0x0a, 0xfe, 0x60, 0x01, 0xff, 0x45, 0x5c, - 0x00, 0xbb, 0x1a, 0x00, 0x45, 0x20, 0x07, 0xbd, 0x1a, 0x00, 0x47, 0x03, - 0x23, 0xbe, 0x1a, 0x40, 0x45, 0xdb, 0xde, 0x28, 0x03, 0x80, 0x2e, 0x11, - 0xbd, 0x5b, 0x0c, 0x4e, 0x26, 0x7b, 0xb7, 0x1a, 0x00, 0x47, 0x98, 0x8a, - 0x05, 0x03, 0x40, 0x42, 0x1a, 0x00, 0x76, 0x03, 0x01, 0x43, 0x37, 0x6c, - 0x77, 0x03, 0x01, 0x45, 0x27, 0xe9, 0x79, 0x03, 0x01, 0x43, 0xc1, 0xf4, - 0x7a, 0x03, 0x01, 0x44, 0x79, 0xf3, 0x78, 0x03, 0x41, 0x46, 0x5b, 0x00, - 0xce, 0x1d, 0x40, 0x4e, 0xc4, 0x7a, 0x4a, 0x03, 0x00, 0x50, 0x0d, 0x68, - 0xc6, 0x1a, 0x40, 0x45, 0xb5, 0x70, 0x04, 0x03, 0x80, 0x11, 0x0a, 0x16, - 0xac, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xe2, 0x1a, 0x00, 0x45, 0x20, 0x07, - 0x20, 0x03, 0x40, 0x80, 0x22, 0x8d, 0x01, 0xff, 0x45, 0x14, 0x39, 0xc4, - 0x1d, 0x80, 0x12, 0x45, 0x55, 0x23, 0xcc, 0x1d, 0x00, 0x45, 0x17, 0x23, - 0xc6, 0x1d, 0x00, 0x4d, 0x51, 0x8a, 0xd5, 0x1a, 0x40, 0x46, 0xef, 0x98, - 0xd8, 0x1a, 0x40, 0x45, 0x20, 0x07, 0x31, 0x03, 0x00, 0x49, 0xf9, 0x13, - 0x24, 0xfe, 0x80, 0x0d, 0x4a, 0x55, 0x04, 0x25, 0xfe, 0xc0, 0x00, 0x46, - 0x1f, 0x07, 0x2c, 0xfe, 0x40, 0x46, 0x1f, 0x07, 0x2b, 0xfe, 0x40, 0x05, - 0xdf, 0x05, 0xed, 0x01, 0x03, 0xc4, 0x00, 0x4f, 0x02, 0x3f, 0x00, 0x27, - 0xaf, 0x01, 0xff, 0x03, 0xa2, 0x01, 0x06, 0x46, 0x8c, 0x8a, 0x32, 0x03, - 0x40, 0x56, 0x9a, 0x33, 0xeb, 0x20, 0x00, 0xb3, 0x06, 0x55, 0xe7, 0x3e, - 0xd2, 0x20, 0x40, 0x4e, 0xa2, 0x33, 0x38, 0x03, 0x00, 0x4d, 0xfd, 0x49, - 0x36, 0x03, 0x40, 0x06, 0xa1, 0x1f, 0x06, 0x5e, 0x71, 0x13, 0xb9, 0x1a, - 0x40, 0x49, 0xf9, 0x13, 0x20, 0xfe, 0x80, 0x0d, 0x4a, 0x55, 0x04, 0x21, - 0xfe, 0xc0, 0x00, 0x46, 0x1f, 0x07, 0x28, 0xfe, 0x40, 0x46, 0x1f, 0x07, - 0x27, 0xfe, 0x40, 0x80, 0x11, 0x06, 0xa9, 0x01, 0x01, 0xff, 0x4d, 0xec, - 0x80, 0xea, 0x20, 0x00, 0x5b, 0x19, 0x0f, 0xed, 0x20, 0x40, 0xa1, 0x4b, - 0x02, 0x22, 0x00, 0x31, 0x0c, 0xda, 0x21, 0x21, 0x0c, 0xc8, 0x00, 0x11, - 0x05, 0x69, 0xd8, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xe0, 0x1a, 0x00, 0x45, - 0x20, 0x07, 0x18, 0x03, 0x40, 0x45, 0x5c, 0x00, 0xe1, 0x20, 0x00, 0x45, - 0x20, 0x07, 0x4d, 0x03, 0x40, 0x4a, 0x41, 0x06, 0xc1, 0x1a, 0x00, 0x4a, - 0x56, 0xa8, 0xc3, 0x1a, 0x40, 0x08, 0xe1, 0xc7, 0x06, 0x4b, 0xcb, 0x02, - 0xd0, 0x20, 0x40, 0x45, 0x5c, 0x00, 0x51, 0x03, 0x00, 0x45, 0x20, 0x07, - 0x1c, 0x03, 0x40, 0x05, 0x32, 0x06, 0x24, 0x04, 0xcf, 0x00, 0x01, 0xff, - 0x80, 0x11, 0x05, 0xbc, 0x1b, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xfe, 0x1d, - 0x00, 0x45, 0x20, 0x07, 0x54, 0x03, 0x40, 0x45, 0x5c, 0x00, 0xd6, 0x20, - 0x00, 0x45, 0x20, 0x07, 0xee, 0x20, 0x40, 0x45, 0x5c, 0x00, 0x1a, 0x03, - 0x00, 0x45, 0x20, 0x07, 0x49, 0x03, 0x00, 0x4d, 0x6e, 0x81, 0xe9, 0x1a, - 0x40, 0x15, 0xda, 0x3c, 0x8e, 0x02, 0x0d, 0x76, 0x08, 0x01, 0xff, 0xe1, - 0x63, 0x03, 0x80, 0xeb, 0x01, 0xe2, 0xe8, 0x1d, 0x80, 0xdf, 0x01, 0xe3, - 0x68, 0x03, 0x80, 0xd3, 0x01, 0xe4, 0x69, 0x03, 0x00, 0xe5, 0x64, 0x03, - 0x80, 0xbd, 0x01, 0xe6, 0xeb, 0x1d, 0x80, 0xb1, 0x01, 0xe7, 0xda, 0x1d, - 0x00, 0xe8, 0x6a, 0x03, 0x00, 0xe9, 0x65, 0x03, 0x80, 0x8e, 0x01, 0xeb, - 0xdc, 0x1d, 0x00, 0xec, 0xdd, 0x1d, 0x80, 0x79, 0xed, 0x6b, 0x03, 0x00, - 0xee, 0xe0, 0x1d, 0x00, 0xef, 0x66, 0x03, 0x80, 0x5b, 0xf0, 0xee, 0x1d, - 0x00, 0xf2, 0x6c, 0x03, 0x80, 0x43, 0xf3, 0xe4, 0x1d, 0x80, 0x38, 0xf4, - 0x6d, 0x03, 0x80, 0x2d, 0xf5, 0x67, 0x03, 0x80, 0x17, 0xf6, 0x6e, 0x03, - 0x00, 0xf7, 0xf1, 0x1d, 0x80, 0x08, 0xf8, 0x6f, 0x03, 0x00, 0xfa, 0xe6, - 0x1d, 0x40, 0x46, 0x1f, 0x07, 0xbf, 0x1a, 0x40, 0x06, 0x50, 0x00, 0x01, - 0xff, 0x49, 0xb9, 0x23, 0xf4, 0x1d, 0x00, 0x5b, 0x79, 0x1c, 0xf0, 0x1d, - 0x40, 0x4d, 0xdc, 0x89, 0xc0, 0x1a, 0x40, 0x44, 0xca, 0x7b, 0xea, 0x1d, - 0x40, 0x80, 0x01, 0xff, 0x45, 0x20, 0x07, 0xca, 0x1d, 0x00, 0x47, 0xbd, - 0xb2, 0xe3, 0x1d, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x49, 0xb9, 0x23, - 0xf3, 0x1d, 0x00, 0x5b, 0x79, 0x1c, 0xed, 0x1d, 0x40, 0x59, 0x23, 0x23, - 0xec, 0x1d, 0x00, 0x45, 0x75, 0xad, 0xe5, 0x1d, 0x40, 0x07, 0x1c, 0x70, - 0x01, 0xff, 0xe4, 0xd8, 0x1d, 0x00, 0xe7, 0xcc, 0x1a, 0x00, 0xf2, 0xcd, - 0x1a, 0x00, 0xf4, 0xce, 0x1a, 0x40, 0x55, 0xb0, 0x3c, 0xd3, 0x1d, 0x40, - 0x42, 0xa4, 0x02, 0xef, 0x1d, 0x00, 0x42, 0x53, 0x00, 0xd9, 0x1d, 0x40, - 0x48, 0x19, 0xc2, 0xd7, 0x1d, 0x40, 0x43, 0x94, 0x0f, 0xe9, 0x1d, 0x40, - 0x4f, 0xfd, 0x69, 0xf2, 0x1d, 0x00, 0xe5, 0xd4, 0x1d, 0x00, 0x44, 0x5f, - 0xe4, 0xe7, 0x1d, 0x00, 0xef, 0xd5, 0x1d, 0x00, 0xf6, 0xd6, 0x1d, 0x40, - 0xe7, 0xdb, 0x1d, 0x00, 0xec, 0xde, 0x1d, 0x00, 0xed, 0xdf, 0x1d, 0x00, - 0xee, 0xe1, 0x1d, 0x00, 0xf2, 0xe2, 0x1d, 0x40, 0x10, 0xbd, 0x67, 0x11, - 0x0b, 0x08, 0xa5, 0x01, 0xff, 0x44, 0xc3, 0x00, 0xf7, 0x1d, 0x00, 0x45, - 0xc8, 0x00, 0xf6, 0x1d, 0x40, 0x56, 0x36, 0x37, 0x9a, 0x30, 0x00, 0x51, - 0x3b, 0x37, 0x99, 0x30, 0x40, 0xae, 0x06, 0x47, 0x0c, 0x0f, 0xd0, 0x1d, - 0x40, 0x46, 0x9a, 0x6c, 0xb2, 0x1a, 0x00, 0x07, 0x62, 0x23, 0x01, 0xff, - 0x02, 0x63, 0x09, 0x11, 0x0c, 0x38, 0x8e, 0x01, 0xff, 0x45, 0x5c, 0x00, - 0xc7, 0x1a, 0x00, 0x45, 0x20, 0x07, 0x2b, 0x03, 0x40, 0x43, 0x59, 0x13, - 0x11, 0x03, 0x80, 0x11, 0x05, 0x52, 0x3c, 0x01, 0xff, 0x45, 0x5c, 0x00, - 0xe3, 0x1a, 0x00, 0x45, 0x20, 0x07, 0x3a, 0x03, 0x40, 0x46, 0x1f, 0x07, - 0x2f, 0x03, 0x40, 0x4e, 0x0e, 0x7a, 0x4b, 0x03, 0x00, 0x48, 0x5a, 0xab, - 0x09, 0x03, 0x00, 0x42, 0x5e, 0x01, 0x1b, 0x03, 0x40, 0x11, 0x8a, 0x5b, - 0xc7, 0x01, 0xb2, 0x01, 0xff, 0xa1, 0x36, 0x04, 0xa3, 0x2e, 0x01, 0xff, - 0x4f, 0x19, 0x6c, 0x44, 0x03, 0x00, 0x47, 0x9b, 0xd2, 0x43, 0x03, 0x00, - 0x08, 0x1c, 0x28, 0x0c, 0x4b, 0x61, 0xa1, 0x42, 0x03, 0x00, 0x4d, 0x3f, - 0x4f, 0x45, 0x03, 0x40, 0x49, 0x22, 0xbe, 0x44, 0xd2, 0x01, 0xb4, 0x01, - 0xff, 0x48, 0x11, 0xc6, 0x43, 0xd2, 0x01, 0x46, 0xb8, 0xdf, 0x42, 0xd2, - 0x41, 0x05, 0x63, 0xe9, 0x35, 0x4c, 0xc0, 0x93, 0x4f, 0x03, 0x00, 0x02, - 0x32, 0x00, 0x01, 0xff, 0x80, 0x15, 0x8d, 0x01, 0xff, 0x4b, 0xea, 0x98, - 0xc8, 0x1d, 0x00, 0x46, 0xb4, 0x70, 0xc5, 0x1d, 0x00, 0x4d, 0x51, 0x8a, - 0xd1, 0x1a, 0x40, 0x46, 0xda, 0x04, 0x00, 0x03, 0x80, 0x06, 0x49, 0x56, - 0x2d, 0x40, 0x03, 0x40, 0x46, 0x1f, 0x07, 0x16, 0x03, 0x40, 0x06, 0xef, - 0x06, 0x21, 0x07, 0xec, 0x05, 0x01, 0xff, 0xe1, 0x70, 0x13, 0x01, 0x42, - 0x1b, 0x02, 0x71, 0x13, 0x01, 0x42, 0x2a, 0x05, 0x72, 0x13, 0x01, 0x42, - 0xbb, 0x09, 0x74, 0x13, 0x01, 0x42, 0x02, 0x00, 0x73, 0x13, 0x41, 0xa6, - 0x20, 0x43, 0x0e, 0x0b, 0x67, 0x13, 0x01, 0x43, 0x1b, 0x26, 0x6c, 0x13, - 0x01, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x66, 0x13, 0x41, 0x44, 0x25, 0x01, - 0x69, 0x13, 0x01, 0x42, 0x15, 0x02, 0x68, 0x13, 0x41, 0x43, 0xd2, 0x05, - 0x6b, 0x13, 0x01, 0x43, 0xf6, 0x06, 0x6a, 0x13, 0x41, 0x43, 0x16, 0xf4, - 0x00, 0xe0, 0x01, 0xa2, 0xe1, 0x01, 0x46, 0x00, 0x81, 0x1d, 0xe0, 0x01, - 0xa4, 0xcc, 0x01, 0xa6, 0xbd, 0x01, 0x47, 0x67, 0xd1, 0x03, 0xe0, 0x01, - 0x44, 0x4d, 0xf0, 0x18, 0xe0, 0x01, 0xe9, 0x0b, 0xe0, 0x81, 0x8f, 0x01, - 0x44, 0xe5, 0xf0, 0x0d, 0xe0, 0x01, 0x47, 0x12, 0xd3, 0x0e, 0xe0, 0x01, - 0x47, 0x04, 0x6b, 0x0f, 0xe0, 0x01, 0x45, 0x13, 0xe9, 0x10, 0xe0, 0x01, - 0x43, 0x7f, 0x31, 0x11, 0xe0, 0x01, 0x46, 0x52, 0xdf, 0x12, 0xe0, 0x01, - 0x45, 0x8f, 0xea, 0x13, 0xe0, 0x01, 0xb3, 0x4b, 0xb4, 0x3d, 0x43, 0x2a, - 0xd6, 0x16, 0xe0, 0x01, 0x44, 0x19, 0xf3, 0x02, 0xe0, 0x01, 0xb9, 0x0f, - 0xba, 0x01, 0xff, 0x45, 0x11, 0xe6, 0x08, 0xe0, 0x01, 0x46, 0xac, 0xdc, - 0x06, 0xe0, 0x41, 0x43, 0xb3, 0x00, 0x21, 0xe0, 0x01, 0xa5, 0x08, 0xef, - 0x26, 0xe0, 0x01, 0xf5, 0x23, 0xe0, 0x41, 0xb2, 0x06, 0x43, 0x26, 0x0a, - 0x05, 0xe0, 0x41, 0xe9, 0x20, 0xe0, 0x01, 0xf5, 0x1f, 0xe0, 0x41, 0x42, - 0x5a, 0x03, 0x1c, 0xe0, 0x01, 0x45, 0x47, 0xec, 0x15, 0xe0, 0x41, 0xa8, - 0x0c, 0x44, 0x35, 0xf1, 0x14, 0xe0, 0x01, 0x48, 0x67, 0xbf, 0x24, 0xe0, - 0x41, 0xe1, 0x1e, 0xe0, 0x01, 0x42, 0x12, 0x00, 0x1b, 0xe0, 0x41, 0x4b, - 0x43, 0xa0, 0x0a, 0xe0, 0x01, 0x07, 0xa0, 0x21, 0x06, 0x43, 0x6f, 0x28, - 0x09, 0xe0, 0x41, 0x47, 0x99, 0xcf, 0x29, 0xe0, 0x01, 0x49, 0x66, 0xbf, - 0x27, 0xe0, 0x41, 0x43, 0xe7, 0x05, 0x2a, 0xe0, 0x01, 0x44, 0x7b, 0xbf, - 0x17, 0xe0, 0x41, 0x45, 0xc9, 0xe7, 0x0c, 0xe0, 0x01, 0x44, 0xdd, 0xf1, - 0x04, 0xe0, 0x41, 0x46, 0x9a, 0xcf, 0x28, 0xe0, 0x01, 0x43, 0xaf, 0xd2, - 0x01, 0xe0, 0x41, 0x46, 0x80, 0xdb, 0x52, 0x03, 0x00, 0x48, 0x25, 0xb9, - 0xda, 0x1a, 0x00, 0x4e, 0xd9, 0x46, 0xdc, 0x20, 0x40, 0x09, 0x4e, 0xbc, - 0x11, 0x0b, 0xa3, 0xa1, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xe8, 0x1a, 0x00, - 0x45, 0x20, 0x07, 0x47, 0x03, 0x40, 0x46, 0x12, 0x03, 0xdd, 0x20, 0x80, - 0x20, 0x47, 0x9c, 0x44, 0xdf, 0x20, 0x00, 0x46, 0x7e, 0xdd, 0xe3, 0x20, - 0x00, 0xb3, 0x06, 0x58, 0xd1, 0x2b, 0xe4, 0x20, 0x40, 0x45, 0xd5, 0x59, - 0xe2, 0x20, 0x00, 0x45, 0xd7, 0x05, 0xde, 0x20, 0x40, 0x4a, 0x43, 0x0e, - 0xe0, 0x20, 0x40, 0xa5, 0xd5, 0x02, 0x48, 0xba, 0x23, 0x08, 0x03, 0x80, - 0xb9, 0x02, 0xaf, 0x01, 0xff, 0xb4, 0xf7, 0x01, 0x04, 0x3d, 0x01, 0x1b, - 0x02, 0xa7, 0x01, 0x01, 0xff, 0x06, 0x68, 0xd8, 0x06, 0x4b, 0xb8, 0x02, - 0xb3, 0x1a, 0x40, 0x45, 0x5c, 0x00, 0xdb, 0x1a, 0x00, 0x45, 0x20, 0x07, - 0x1e, 0x03, 0x40, 0x80, 0x06, 0x53, 0xed, 0x48, 0xb0, 0x1a, 0x40, 0xa1, - 0xb6, 0x01, 0x45, 0x55, 0x23, 0x5d, 0x03, 0x80, 0xa8, 0x01, 0xa3, 0x99, - 0x01, 0x4c, 0x17, 0x23, 0x0f, 0x03, 0x00, 0x4e, 0x60, 0x23, 0x61, 0x03, - 0x80, 0x85, 0x01, 0x48, 0x8a, 0x8a, 0x33, 0x03, 0x00, 0x46, 0xb4, 0x70, - 0x5e, 0x03, 0x80, 0x72, 0xaf, 0x64, 0xb0, 0x4b, 0x02, 0x0d, 0x00, 0x31, - 0x45, 0x37, 0x23, 0x60, 0x03, 0x80, 0x1b, 0x09, 0x32, 0x00, 0x01, 0xff, - 0x05, 0xed, 0x07, 0x06, 0x4e, 0xfc, 0x49, 0xe6, 0x20, 0x40, 0x45, 0x5c, - 0x00, 0x0e, 0x03, 0x00, 0x45, 0x20, 0x07, 0x48, 0x03, 0x40, 0x80, 0x01, - 0xff, 0x49, 0xf9, 0x13, 0x22, 0xfe, 0x00, 0x4a, 0x55, 0x04, 0x23, 0xfe, - 0x40, 0x0f, 0xdc, 0x03, 0x06, 0x48, 0x22, 0x6a, 0x5a, 0x03, 0x40, 0x45, - 0x5c, 0x00, 0xeb, 0x1a, 0x00, 0x45, 0x20, 0x07, 0x62, 0x03, 0x40, 0x50, - 0xfd, 0x60, 0xbc, 0x1a, 0x00, 0x09, 0xe7, 0x71, 0x01, 0xff, 0x45, 0x5c, - 0x00, 0xc9, 0x1a, 0x00, 0x45, 0x20, 0x07, 0xca, 0x1a, 0x40, 0x4e, 0x26, - 0x7b, 0xb8, 0x1a, 0x00, 0x47, 0x98, 0x8a, 0x3f, 0x03, 0x40, 0x46, 0x1f, - 0x07, 0x5f, 0x03, 0x40, 0x46, 0x1f, 0x07, 0xfc, 0x1d, 0x40, 0x44, 0xee, - 0x6c, 0xcf, 0x1a, 0x00, 0x4f, 0x83, 0x32, 0xcd, 0x1d, 0x40, 0x46, 0x1f, - 0x07, 0x5c, 0x03, 0x40, 0x4b, 0x11, 0x8c, 0x0b, 0x03, 0x00, 0x04, 0x40, - 0x8e, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xe7, 0x1a, 0x00, 0x45, 0x20, 0x07, - 0xe6, 0x1a, 0x40, 0x80, 0x17, 0x4f, 0x1b, 0x6a, 0xdd, 0x1a, 0x00, 0x04, - 0x77, 0x00, 0x01, 0xff, 0x4c, 0x10, 0x8c, 0xc1, 0x1d, 0x00, 0x4c, 0x17, - 0x23, 0xc0, 0x1d, 0x40, 0x45, 0x5c, 0x00, 0x07, 0x03, 0x80, 0x0d, 0x45, - 0x20, 0x07, 0x23, 0x03, 0xc0, 0x00, 0x45, 0xc2, 0x00, 0xfa, 0x1d, 0x40, - 0x80, 0x01, 0xff, 0x44, 0xc3, 0x00, 0xf8, 0x1d, 0x00, 0x45, 0xc8, 0x00, - 0x58, 0x03, 0x40, 0x80, 0x06, 0x45, 0x1f, 0x6a, 0xb1, 0x1a, 0x40, 0x45, - 0x20, 0x07, 0x24, 0x03, 0x00, 0x54, 0xe7, 0x46, 0xdc, 0x1a, 0x40, 0x4b, - 0xcd, 0x9e, 0xfb, 0x1d, 0x00, 0x09, 0xf2, 0xc0, 0x01, 0xff, 0x06, 0xef, - 0x06, 0x30, 0x07, 0xec, 0x05, 0x06, 0x4d, 0xbe, 0x88, 0xf1, 0xa8, 0x40, - 0xe1, 0xea, 0xa8, 0x00, 0x42, 0x1b, 0x02, 0xec, 0xa8, 0x00, 0x42, 0x2a, - 0x05, 0xed, 0xa8, 0x00, 0x42, 0xbb, 0x09, 0xee, 0xa8, 0x00, 0x42, 0x71, - 0x00, 0xef, 0xa8, 0x00, 0xf5, 0xeb, 0xa8, 0x00, 0x42, 0x02, 0x00, 0xf0, - 0xa8, 0x40, 0x45, 0x12, 0x0b, 0xe8, 0xa8, 0x00, 0xa6, 0x2e, 0x44, 0xea, - 0x2a, 0xe9, 0xa8, 0x00, 0x43, 0x0e, 0x0b, 0xe1, 0xa8, 0x00, 0xb3, 0x14, - 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xe0, 0xa8, 0x40, 0x44, 0x25, 0x01, 0xe3, - 0xa8, 0x00, 0x42, 0x15, 0x02, 0xe2, 0xa8, 0x40, 0x44, 0xe5, 0x1d, 0xe7, - 0xa8, 0x00, 0x42, 0x1c, 0x26, 0xe6, 0xa8, 0x40, 0x43, 0xd2, 0x05, 0xe5, - 0xa8, 0x00, 0x43, 0xf6, 0x06, 0xe4, 0xa8, 0x40, 0xa1, 0xb7, 0x03, 0x46, - 0x1b, 0xc2, 0x27, 0x03, 0x00, 0x50, 0xd0, 0x04, 0x02, 0x03, 0x80, 0xa3, - 0x03, 0x09, 0x66, 0x10, 0x92, 0x03, 0xaf, 0xeb, 0x02, 0x08, 0x11, 0xcd, - 0x01, 0xff, 0x4e, 0xb8, 0x76, 0x85, 0x04, 0x00, 0x08, 0x71, 0x11, 0xcf, - 0x02, 0x46, 0xf4, 0x4f, 0x7c, 0xa6, 0x00, 0x07, 0xec, 0x05, 0x52, 0x4d, - 0x10, 0x3c, 0x89, 0x04, 0x00, 0xb0, 0x30, 0x65, 0x76, 0x08, 0x8f, 0xe0, - 0x01, 0xb4, 0x06, 0x45, 0x4c, 0xec, 0x6f, 0xa6, 0x40, 0x50, 0xad, 0x62, - 0x70, 0xa6, 0x00, 0x55, 0x08, 0x3c, 0x72, 0xa6, 0x00, 0x44, 0x62, 0x98, - 0x83, 0x04, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x49, 0xf9, 0x13, 0x2e, 0xfe, - 0x00, 0x4a, 0x55, 0x04, 0x2f, 0xfe, 0x40, 0xa1, 0x0c, 0x47, 0xeb, 0xd3, - 0x87, 0x04, 0x00, 0x4d, 0xd8, 0x88, 0x86, 0x04, 0x40, 0x4c, 0xf0, 0x90, - 0x84, 0x04, 0x00, 0x45, 0xb8, 0xd4, 0x7d, 0xa6, 0x40, 0xe1, 0xf6, 0x2d, - 0x00, 0xa2, 0xe2, 0x01, 0x43, 0x6d, 0x14, 0xf1, 0x2d, 0x00, 0xa4, 0xcf, - 0x01, 0xa5, 0xad, 0x01, 0x44, 0xf1, 0xef, 0xf4, 0x2d, 0x00, 0x43, 0x2d, - 0x52, 0xe2, 0x2d, 0x00, 0x42, 0x22, 0x00, 0xef, 0x2d, 0x80, 0x93, 0x01, - 0xe9, 0x75, 0xa6, 0x80, 0x77, 0x42, 0x1b, 0x02, 0xe6, 0x2d, 0x00, 0x4a, - 0x3e, 0x59, 0xfd, 0x2d, 0x00, 0x4c, 0x34, 0x92, 0xf9, 0x2d, 0x00, 0xef, - 0xea, 0x2d, 0x80, 0x5a, 0x42, 0x6f, 0x02, 0xeb, 0x2d, 0x00, 0xb3, 0x40, - 0xb4, 0x34, 0xf5, 0x77, 0xa6, 0x80, 0x29, 0x42, 0x32, 0x00, 0xe1, 0x2d, - 0x00, 0xb9, 0x0d, 0xba, 0x01, 0xff, 0xe5, 0xe5, 0x2d, 0x00, 0x42, 0xb0, - 0x01, 0xe4, 0x2d, 0x40, 0x42, 0x8a, 0x00, 0xfa, 0x2d, 0x00, 0x43, 0xb7, - 0x2b, 0x79, 0xa6, 0x00, 0xe9, 0x76, 0xa6, 0x00, 0xf5, 0xfb, 0x2d, 0x40, - 0x4b, 0x28, 0x9e, 0x74, 0xa6, 0x40, 0xe5, 0xee, 0x2d, 0x00, 0x42, 0x46, - 0x03, 0xf0, 0x2d, 0x40, 0xa8, 0x06, 0x48, 0x9c, 0x8e, 0x7a, 0xa6, 0x40, - 0xe1, 0xf2, 0x2d, 0x00, 0x43, 0xe6, 0x17, 0xf3, 0x2d, 0x40, 0x44, 0xe1, - 0x7b, 0x7b, 0xa6, 0x40, 0xe5, 0xf7, 0x2d, 0x00, 0x08, 0x99, 0xc9, 0x01, - 0xff, 0xe1, 0xfc, 0x2d, 0x00, 0x47, 0x99, 0xcf, 0xff, 0x2d, 0x00, 0xe5, - 0x9f, 0xa6, 0x40, 0x47, 0x1d, 0x93, 0x78, 0xa6, 0x40, 0xe6, 0x9e, 0xa6, - 0x00, 0xec, 0xe7, 0x2d, 0x00, 0xed, 0xe8, 0x2d, 0x00, 0xee, 0xe9, 0x2d, - 0x00, 0xf2, 0xec, 0x2d, 0x00, 0xf3, 0xed, 0x2d, 0xc0, 0x00, 0x43, 0xc9, - 0x7c, 0xf5, 0x2d, 0x40, 0xe5, 0xe3, 0x2d, 0x00, 0x44, 0xc9, 0xe7, 0xf8, - 0x2d, 0x40, 0xe5, 0xe0, 0x2d, 0x00, 0x46, 0x9a, 0xcf, 0xfe, 0x2d, 0x40, - 0x4d, 0x10, 0x3c, 0x71, 0xa6, 0x00, 0x4e, 0x10, 0x7d, 0x88, 0x04, 0x40, - 0x04, 0x15, 0x05, 0x0d, 0x4f, 0xab, 0x70, 0x26, 0xfe, 0xc0, 0x00, 0x46, - 0x1f, 0x07, 0x2d, 0xfe, 0x40, 0x45, 0x5c, 0x00, 0x13, 0x03, 0x80, 0x06, - 0x45, 0x20, 0x07, 0x26, 0x03, 0x40, 0x46, 0xc7, 0x00, 0x15, 0x03, 0x40, - 0x4b, 0xce, 0x00, 0xd5, 0x20, 0x00, 0x4c, 0xbc, 0x94, 0xd9, 0x20, 0x40, - 0x46, 0x1f, 0x07, 0x2d, 0x03, 0x40, 0x49, 0xdb, 0x23, 0x10, 0x03, 0x00, - 0x43, 0xb1, 0x0e, 0x0c, 0x03, 0xc0, 0x00, 0x46, 0x1f, 0x07, 0x2c, 0x03, - 0x40, 0x4a, 0xe4, 0xab, 0x3b, 0x13, 0x01, 0xb2, 0x01, 0xff, 0x43, 0x59, - 0x13, 0x06, 0x03, 0x80, 0x11, 0x05, 0x52, 0x3c, 0x01, 0xff, 0x45, 0x5c, - 0x00, 0x46, 0x03, 0x00, 0x45, 0x20, 0x07, 0x2a, 0x03, 0x40, 0x46, 0x1f, - 0x07, 0x2e, 0x03, 0x00, 0x47, 0xe0, 0xcd, 0xcb, 0x1d, 0x40, 0x04, 0x15, - 0x39, 0x3a, 0x0f, 0xd9, 0x6f, 0x2a, 0xae, 0x11, 0x08, 0x6d, 0x67, 0x01, - 0xff, 0x45, 0x5c, 0x00, 0xf0, 0x20, 0x00, 0x45, 0x20, 0x07, 0x59, 0x03, - 0x40, 0x4c, 0xf4, 0x92, 0xe7, 0x20, 0x00, 0x0c, 0x63, 0x10, 0x01, 0xff, - 0x4b, 0xce, 0x00, 0xd4, 0x20, 0x00, 0x4c, 0xbc, 0x94, 0xda, 0x20, 0x40, - 0x45, 0x5c, 0x00, 0x4c, 0x03, 0x00, 0x45, 0x20, 0x07, 0xfd, 0x1d, 0x40, - 0x80, 0x15, 0x8d, 0x01, 0xff, 0x4b, 0xa7, 0x9c, 0xc9, 0x1d, 0x00, 0x46, - 0xb4, 0x70, 0xc7, 0x1d, 0x00, 0x4d, 0x51, 0x8a, 0xd3, 0x1a, 0x40, 0x46, - 0xda, 0x04, 0x01, 0x03, 0x80, 0x06, 0x49, 0x56, 0x2d, 0x41, 0x03, 0x40, - 0x46, 0x1f, 0x07, 0x17, 0x03, 0x40, 0x4d, 0x30, 0x85, 0xa5, 0xf4, 0x01, - 0x42, 0x10, 0x00, 0x3a, 0x00, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x46, 0x48, - 0x13, 0x54, 0x22, 0x00, 0x44, 0x5a, 0x03, 0xa1, 0x20, 0x40, 0xab, 0x06, - 0x44, 0xf5, 0xf1, 0x65, 0xf9, 0x41, 0x45, 0xf7, 0xd4, 0xb3, 0xfa, 0x01, - 0x4a, 0xb6, 0xb1, 0x78, 0xf3, 0x41, 0xa1, 0xdb, 0x03, 0x51, 0xd0, 0x59, - 0x9a, 0x23, 0x00, 0xa9, 0xbc, 0x03, 0xaf, 0x01, 0xff, 0x02, 0x36, 0x01, - 0x8f, 0x01, 0x02, 0x46, 0x03, 0x2a, 0x42, 0xb2, 0x0c, 0x01, 0x26, 0x80, - 0x06, 0x47, 0x53, 0x7c, 0x21, 0xf9, 0x41, 0x06, 0x50, 0x00, 0x01, 0xff, - 0x49, 0x88, 0xbb, 0x29, 0xf3, 0x01, 0x44, 0x92, 0x08, 0x27, 0xf3, 0x01, - 0x44, 0xf4, 0x2e, 0x28, 0xf3, 0x01, 0x47, 0x92, 0xd6, 0x2a, 0xf3, 0x41, - 0x43, 0x4f, 0x02, 0x50, 0x20, 0x00, 0x02, 0x06, 0x00, 0x01, 0xff, 0x44, - 0x65, 0xef, 0xd5, 0xf4, 0x01, 0x58, 0x61, 0x29, 0x4d, 0x2a, 0x00, 0x4d, - 0x4a, 0x85, 0x10, 0xf5, 0x01, 0x0d, 0x8b, 0x85, 0x34, 0x02, 0x6f, 0x00, - 0x16, 0xb5, 0x01, 0xff, 0x47, 0x66, 0x61, 0x02, 0xf3, 0x01, 0x50, 0x5d, - 0x65, 0x4c, 0x2a, 0xc0, 0x00, 0x52, 0x28, 0x4f, 0x50, 0x2a, 0x40, 0x44, - 0x9b, 0x12, 0xcf, 0x2a, 0x80, 0x0d, 0x46, 0x44, 0x36, 0xd0, 0x2a, 0xc0, - 0x00, 0x4c, 0x0d, 0x29, 0xd2, 0x2a, 0x40, 0x4c, 0x0d, 0x29, 0xd1, 0x2a, - 0x40, 0x4c, 0x8c, 0x91, 0xea, 0xf4, 0x01, 0x4b, 0xda, 0xa1, 0xeb, 0xf4, - 0x41, 0x06, 0x0b, 0x08, 0x51, 0x05, 0x6a, 0x10, 0x01, 0xff, 0xa3, 0x3e, - 0x68, 0xe0, 0x04, 0x03, 0xf5, 0x01, 0x53, 0xab, 0x49, 0xf3, 0x27, 0x00, - 0x48, 0xaf, 0x26, 0x31, 0x22, 0x00, 0x51, 0xf6, 0x04, 0xbb, 0x21, 0x00, - 0x05, 0xc8, 0x00, 0x0f, 0xb4, 0x01, 0xff, 0x53, 0xd2, 0x4b, 0xb7, 0x21, - 0x00, 0x60, 0xf4, 0x0f, 0x6e, 0x2b, 0x40, 0x5b, 0xd6, 0x19, 0xd8, 0xf5, - 0x01, 0x66, 0x97, 0x07, 0x01, 0xf5, 0xc1, 0x00, 0x59, 0xf1, 0x22, 0x02, - 0xf5, 0x41, 0x52, 0x84, 0x53, 0x41, 0x29, 0x00, 0x4f, 0x5f, 0x71, 0x32, - 0x22, 0x40, 0xa5, 0xac, 0x01, 0xa6, 0x88, 0x01, 0x04, 0xea, 0x2a, 0x78, - 0x03, 0x0e, 0x0b, 0x68, 0xb3, 0x45, 0xb4, 0x01, 0xff, 0x02, 0x92, 0x01, - 0x32, 0x04, 0x25, 0x01, 0x22, 0xb7, 0x01, 0xff, 0x04, 0x02, 0x2c, 0x0f, - 0xaf, 0x01, 0xff, 0x47, 0x85, 0xcd, 0x51, 0xf5, 0x01, 0x47, 0xf5, 0xcd, - 0x5d, 0xf5, 0x41, 0x47, 0x85, 0xcd, 0x5b, 0xf5, 0x01, 0x47, 0xf5, 0xcd, - 0x67, 0xf5, 0x41, 0x47, 0x85, 0xcd, 0x52, 0xf5, 0x01, 0x47, 0xf5, 0xcd, - 0x5e, 0xf5, 0x41, 0x47, 0x85, 0xcd, 0x59, 0xf5, 0x01, 0x47, 0xf5, 0xcd, - 0x65, 0xf5, 0x41, 0x04, 0xe5, 0x1d, 0x11, 0x02, 0x1c, 0x26, 0x01, 0xff, - 0x47, 0x85, 0xcd, 0x55, 0xf5, 0x01, 0x47, 0xf5, 0xcd, 0x61, 0xf5, 0x41, - 0x47, 0x85, 0xcd, 0x56, 0xf5, 0x01, 0x47, 0xf5, 0xcd, 0x62, 0xf5, 0x41, - 0x47, 0x85, 0xcd, 0x50, 0xf5, 0x01, 0x47, 0xf5, 0xcd, 0x5c, 0xf5, 0x41, - 0x47, 0x85, 0xcd, 0x58, 0xf5, 0x01, 0x47, 0xf5, 0xcd, 0x64, 0xf5, 0x41, - 0x03, 0xd2, 0x05, 0x11, 0x03, 0xf6, 0x06, 0x01, 0xff, 0x47, 0x85, 0xcd, - 0x53, 0xf5, 0x01, 0x47, 0xf5, 0xcd, 0x5f, 0xf5, 0x41, 0x47, 0x85, 0xcd, - 0x54, 0xf5, 0x01, 0x47, 0xf5, 0xcd, 0x60, 0xf5, 0x41, 0x04, 0xc9, 0x00, - 0x11, 0x05, 0xbb, 0x6f, 0x01, 0xff, 0x47, 0x85, 0xcd, 0x5a, 0xf5, 0x01, - 0x47, 0xf5, 0xcd, 0x66, 0xf5, 0x41, 0x47, 0x85, 0xcd, 0x57, 0xf5, 0x01, - 0x47, 0xf5, 0xcd, 0x63, 0xf5, 0x41, 0x06, 0x5e, 0x91, 0x06, 0x46, 0x22, - 0xdf, 0xcb, 0xf4, 0x41, 0x49, 0xae, 0xb6, 0x7b, 0xf3, 0x01, 0x47, 0x76, - 0xc0, 0x42, 0xf9, 0x41, 0x53, 0x4d, 0x4b, 0x81, 0xf5, 0x01, 0x02, 0x6e, - 0x02, 0x06, 0x4f, 0x30, 0x73, 0xdb, 0xf3, 0x41, 0x48, 0x72, 0x14, 0xac, - 0xf3, 0x01, 0x4e, 0x94, 0x78, 0x4f, 0xf4, 0x41, 0x58, 0xc9, 0x27, 0x06, - 0xd8, 0x00, 0x08, 0x79, 0xa5, 0xbb, 0x01, 0x07, 0xc5, 0x0e, 0x06, 0x52, - 0x30, 0x33, 0x01, 0xd8, 0x40, 0x43, 0x22, 0xf4, 0xc3, 0x31, 0x00, 0xe4, - 0xd4, 0x31, 0x00, 0xe8, 0xd0, 0x31, 0x80, 0x5f, 0xee, 0xcf, 0x31, 0x00, - 0xf0, 0xd2, 0x31, 0x80, 0x4a, 0xf1, 0xe3, 0x31, 0x00, 0xf3, 0xd1, 0x31, - 0x80, 0x15, 0xf4, 0xc0, 0x31, 0x80, 0x0c, 0x42, 0xdd, 0x17, 0xc1, 0x31, - 0x00, 0x42, 0x23, 0xf4, 0xc2, 0x31, 0x40, 0xee, 0xdd, 0x31, 0x40, 0xe7, - 0xda, 0x31, 0x00, 0xf0, 0xd3, 0x31, 0x00, 0xf4, 0xd9, 0x31, 0x00, 0xf7, - 0xc4, 0x31, 0x80, 0x13, 0xfa, 0xd7, 0x31, 0xc0, 0x00, 0xf0, 0xe5, 0x31, - 0x00, 0x42, 0xdd, 0x17, 0xc9, 0x31, 0x00, 0xfa, 0xde, 0x31, 0x40, 0xe7, - 0xdf, 0x31, 0x00, 0xfa, 0xd8, 0x31, 0x40, 0xe4, 0xdb, 0x31, 0x00, 0xe7, - 0xe2, 0x31, 0x00, 0xfa, 0xdc, 0x31, 0x40, 0xe7, 0xd6, 0x31, 0x00, 0xf0, - 0xc7, 0x31, 0x80, 0x34, 0xb8, 0x28, 0xfa, 0xd5, 0x31, 0xc0, 0x00, 0xe7, - 0xc6, 0x31, 0x00, 0xf4, 0xca, 0x31, 0x00, 0xf7, 0xcd, 0x31, 0x80, 0x12, - 0xfa, 0xc5, 0x31, 0xc0, 0x00, 0xf0, 0xcb, 0x31, 0x00, 0xfa, 0xce, 0x31, - 0xc0, 0x00, 0xe7, 0xe1, 0x31, 0x40, 0xe7, 0xc8, 0x31, 0x40, 0xe7, 0xe4, - 0x31, 0x00, 0x42, 0xdd, 0x17, 0xe0, 0x31, 0x40, 0x42, 0xdd, 0x17, 0xcc, - 0x31, 0x40, 0xa2, 0xba, 0x06, 0xa3, 0xfb, 0x04, 0xa4, 0xe6, 0x04, 0xa5, - 0xbe, 0x04, 0xa6, 0xaf, 0x04, 0xa7, 0x8c, 0x04, 0xa8, 0xe4, 0x03, 0xaa, - 0xbc, 0x03, 0x06, 0xdb, 0xa5, 0xab, 0x03, 0xac, 0xf8, 0x02, 0xad, 0xc1, - 0x02, 0x04, 0x4b, 0x49, 0xa1, 0x02, 0x43, 0xfd, 0x1a, 0xb9, 0x2e, 0x00, - 0xb0, 0x82, 0x02, 0xb2, 0xe9, 0x01, 0xb3, 0x51, 0xb4, 0x37, 0xb7, 0x01, - 0xff, 0xa1, 0x11, 0x04, 0xdb, 0x1a, 0x01, 0xff, 0x43, 0x0e, 0x0b, 0xc3, - 0x2e, 0x00, 0x43, 0x1f, 0x0a, 0xc4, 0x2e, 0x40, 0x03, 0x94, 0xf4, 0x11, - 0x04, 0x08, 0x03, 0x01, 0xff, 0x43, 0x0e, 0x0b, 0xa1, 0x2e, 0x00, 0x43, - 0x1f, 0x0a, 0xa2, 0x2e, 0x40, 0x43, 0x0e, 0x0b, 0xcd, 0x2e, 0x00, 0x43, - 0x1f, 0x0a, 0xce, 0x2e, 0x40, 0x44, 0x3a, 0x18, 0x87, 0x2e, 0x00, 0x45, - 0x44, 0x9e, 0x93, 0x2e, 0x00, 0x44, 0x9d, 0xf0, 0xc1, 0x2e, 0x00, 0x45, - 0x15, 0xec, 0xf1, 0x2e, 0x40, 0xa5, 0x74, 0x44, 0x45, 0xf0, 0xb6, 0x2e, - 0x00, 0xa9, 0x3f, 0x05, 0x5e, 0x07, 0x2f, 0xae, 0x16, 0x06, 0x4c, 0xdf, - 0x06, 0x42, 0x42, 0x0b, 0x9c, 0x2e, 0x40, 0x43, 0x0e, 0x0b, 0xac, 0x2e, - 0x00, 0x43, 0x1f, 0x0a, 0xad, 0x2e, 0x40, 0x43, 0xad, 0x27, 0x92, 0x2e, - 0x00, 0x04, 0x04, 0x51, 0x01, 0xff, 0x43, 0x0e, 0x0b, 0x94, 0x2e, 0x00, - 0x43, 0x1f, 0x0a, 0x95, 0x2e, 0x40, 0x43, 0x0e, 0x0b, 0x8c, 0x2e, 0x00, - 0x43, 0x1f, 0x0a, 0x8d, 0x2e, 0x40, 0x42, 0x67, 0x5b, 0xaf, 0x2e, 0x00, - 0x09, 0xe7, 0x88, 0x01, 0xff, 0xa8, 0x14, 0xb7, 0x06, 0x46, 0xfe, 0xd7, - 0xe9, 0x2e, 0x40, 0x43, 0x66, 0x5b, 0xcc, 0x2e, 0x00, 0x44, 0xe9, 0x9c, - 0xe8, 0x2e, 0x40, 0x4e, 0xca, 0x75, 0xa6, 0x2e, 0x00, 0x43, 0x28, 0x05, - 0xc6, 0x2e, 0x40, 0x42, 0x13, 0x00, 0x8b, 0x2e, 0x00, 0x05, 0xfa, 0x7b, - 0x01, 0xff, 0x43, 0x0e, 0x0b, 0x82, 0x2e, 0x00, 0xb4, 0x01, 0xff, 0x44, - 0x25, 0x01, 0x84, 0x2e, 0x00, 0x42, 0x15, 0x02, 0x83, 0x2e, 0x40, 0xa1, - 0x06, 0x45, 0xa5, 0x6c, 0x80, 0x2e, 0x40, 0x42, 0x9e, 0x01, 0xd7, 0x2e, - 0x00, 0xed, 0xb7, 0x2e, 0x00, 0xf0, 0x99, 0x2e, 0x40, 0x03, 0xae, 0x44, - 0x06, 0x45, 0x3b, 0x1d, 0x85, 0x2e, 0x40, 0x43, 0x0e, 0x0b, 0xa4, 0x2e, - 0x00, 0x43, 0x1f, 0x0a, 0xa5, 0x2e, 0x40, 0x44, 0xf5, 0x06, 0xb4, 0x2e, - 0x00, 0x43, 0x0e, 0x0b, 0xb1, 0x2e, 0x00, 0xb4, 0x01, 0xff, 0x44, 0x25, - 0x01, 0xb3, 0x2e, 0x00, 0x42, 0x15, 0x02, 0xb2, 0x2e, 0x40, 0xa5, 0x26, - 0xaf, 0x01, 0xff, 0x42, 0x10, 0x00, 0x9d, 0x2e, 0x00, 0x44, 0x73, 0x4d, - 0xbd, 0x2e, 0x00, 0x44, 0x2b, 0x1a, 0x9f, 0x2e, 0x00, 0x04, 0x5b, 0x12, - 0x01, 0xff, 0x43, 0x0e, 0x0b, 0xd5, 0x2e, 0x00, 0x43, 0x1f, 0x0a, 0xd6, - 0x2e, 0x40, 0x42, 0x8a, 0x00, 0xbc, 0x2e, 0x00, 0x42, 0xa4, 0x02, 0xb5, - 0x2e, 0x40, 0x04, 0xc3, 0xb8, 0x11, 0x04, 0xd8, 0x02, 0x01, 0xff, 0x43, - 0x0e, 0x0b, 0xd1, 0x2e, 0x00, 0x43, 0x1f, 0x0a, 0xd2, 0x2e, 0x40, 0x44, - 0xf5, 0x06, 0x91, 0x2e, 0x00, 0x43, 0x0e, 0x0b, 0x8e, 0x2e, 0x00, 0xb4, - 0x01, 0xff, 0x44, 0x25, 0x01, 0x90, 0x2e, 0x00, 0x42, 0x15, 0x02, 0x8f, - 0x2e, 0x40, 0x43, 0x0e, 0x0b, 0x88, 0x2e, 0x00, 0x43, 0x1f, 0x0a, 0x89, - 0x2e, 0x40, 0x0c, 0xec, 0x8b, 0x06, 0x43, 0x0c, 0x02, 0xa9, 0x2e, 0x40, - 0x46, 0x6a, 0x8f, 0xef, 0x2e, 0x00, 0x44, 0xe5, 0x1d, 0xeb, 0x2e, 0x00, - 0xb4, 0x01, 0xff, 0x44, 0xfd, 0xf1, 0xed, 0x2e, 0x00, 0x45, 0x15, 0xec, - 0xf2, 0x2e, 0x40, 0x43, 0x1a, 0x00, 0x98, 0x2e, 0x00, 0x02, 0x89, 0x00, - 0x06, 0x43, 0x28, 0x05, 0xc7, 0x2e, 0x40, 0xe4, 0xe1, 0x2e, 0x00, 0x03, - 0x36, 0x07, 0x01, 0xff, 0x43, 0x0e, 0x0b, 0x96, 0x2e, 0x00, 0x43, 0x1f, - 0x0a, 0x97, 0x2e, 0x40, 0x44, 0xd5, 0x7c, 0xe4, 0x2e, 0x00, 0x05, 0x1e, - 0x20, 0x01, 0xff, 0x43, 0x0e, 0x0b, 0xbe, 0x2e, 0x00, 0xb4, 0x01, 0xff, - 0x44, 0x25, 0x01, 0xc0, 0x2e, 0x00, 0x42, 0x15, 0x02, 0xbf, 0x2e, 0x40, - 0x43, 0x88, 0x0d, 0xa3, 0x2e, 0x00, 0x43, 0xc6, 0x6c, 0xca, 0x2e, 0x40, - 0x03, 0x3d, 0x05, 0x0c, 0x42, 0x15, 0x01, 0xb8, 0x2e, 0x00, 0x42, 0x4d, - 0x00, 0xab, 0x2e, 0x40, 0x43, 0x0e, 0x0b, 0xdd, 0x2e, 0x00, 0xb4, 0x01, - 0xff, 0x44, 0x25, 0x01, 0xdf, 0x2e, 0x00, 0x42, 0x15, 0x02, 0xde, 0x2e, - 0x40, 0x44, 0x73, 0x0f, 0x9e, 0x2e, 0x00, 0x49, 0xf8, 0xba, 0x8a, 0x2e, - 0x00, 0x42, 0xdd, 0x18, 0xa8, 0x2e, 0x40, 0x0c, 0xec, 0x8b, 0x28, 0x44, - 0x7c, 0xdd, 0x9b, 0x2e, 0x00, 0xa9, 0x14, 0xac, 0x06, 0x42, 0xd1, 0x00, - 0xa7, 0x2e, 0x40, 0x43, 0x5d, 0x48, 0x81, 0x2e, 0x00, 0x45, 0x5e, 0x88, - 0xc2, 0x2e, 0x40, 0x42, 0x7d, 0x11, 0xcf, 0x2e, 0x00, 0x46, 0x44, 0xe1, - 0xa0, 0x2e, 0x40, 0x44, 0xa8, 0xa7, 0xe6, 0x2e, 0x00, 0x44, 0x3d, 0x6c, - 0xcb, 0x2e, 0x00, 0x46, 0x6a, 0x8f, 0xf0, 0x2e, 0x00, 0xa5, 0x70, 0xa6, - 0x5c, 0xa7, 0x4e, 0x45, 0x41, 0xb3, 0xe2, 0x2e, 0x00, 0xac, 0x3a, 0xb3, - 0x1a, 0xb4, 0x06, 0x44, 0x8e, 0x13, 0xdb, 0x2e, 0x40, 0x4d, 0x84, 0x80, - 0xd9, 0x2e, 0x00, 0x44, 0xfd, 0xf1, 0xee, 0x2e, 0x00, 0x45, 0x15, 0xec, - 0xf3, 0x2e, 0x40, 0x43, 0xf1, 0x11, 0xe7, 0x2e, 0x00, 0x42, 0x27, 0x01, - 0xc5, 0x2e, 0x00, 0x44, 0x5e, 0x09, 0xc9, 0x2e, 0x00, 0x43, 0x59, 0xb1, - 0xb0, 0x2e, 0x00, 0x45, 0x85, 0x7c, 0xc8, 0x2e, 0x40, 0x43, 0x41, 0x51, - 0xda, 0x2e, 0x00, 0x43, 0xd8, 0x02, 0xd3, 0x2e, 0x40, 0x43, 0x8a, 0x00, - 0xd4, 0x2e, 0x00, 0x43, 0xfd, 0x1a, 0xd0, 0x2e, 0x40, 0x43, 0xd1, 0x0c, - 0xe5, 0x2e, 0x00, 0x42, 0x75, 0x0b, 0xdc, 0x2e, 0x00, 0x43, 0x06, 0x2f, - 0xea, 0x2e, 0x40, 0x42, 0x8a, 0x00, 0xe0, 0x2e, 0x00, 0x43, 0xe6, 0x1d, - 0xec, 0x2e, 0x40, 0x45, 0x77, 0xcf, 0xae, 0x2e, 0x00, 0x43, 0xe9, 0x8c, - 0xd8, 0x2e, 0x00, 0xaf, 0x11, 0x05, 0xc1, 0xea, 0x01, 0xff, 0x43, 0x0e, - 0x0b, 0xba, 0x2e, 0x00, 0x43, 0x1f, 0x0a, 0xbb, 0x2e, 0x40, 0x4b, 0x1a, - 0x9f, 0xaa, 0x2e, 0x00, 0x42, 0xcd, 0x05, 0xe3, 0x2e, 0x00, 0xf8, 0x86, - 0x2e, 0x40, 0x44, 0x95, 0xf1, 0xa6, 0xf3, 0x01, 0x02, 0x14, 0x03, 0x0d, - 0x47, 0xc3, 0xd6, 0xd9, 0xf3, 0xc1, 0x00, 0x48, 0x11, 0xc2, 0x06, 0xf3, - 0x41, 0x02, 0x68, 0x00, 0x15, 0xb5, 0x01, 0xff, 0x4f, 0x43, 0x6f, 0x10, - 0x2a, 0x00, 0x4c, 0xd4, 0x04, 0x5e, 0x00, 0x00, 0x46, 0xe8, 0xdf, 0xaa, - 0xf3, 0x41, 0x80, 0xa7, 0x0e, 0x02, 0x06, 0x00, 0x01, 0xff, 0xa1, 0x89, - 0x0e, 0xa2, 0xfa, 0x0d, 0xa3, 0xbe, 0x0d, 0xa4, 0xcd, 0x0c, 0x46, 0x48, - 0x13, 0x9c, 0x22, 0x00, 0x4c, 0x87, 0x00, 0xc1, 0x29, 0x00, 0xa8, 0xe1, - 0x0a, 0xa9, 0xc7, 0x07, 0xab, 0xdd, 0x05, 0xac, 0xf7, 0x03, 0xad, 0xe8, - 0x03, 0x07, 0x1a, 0x3a, 0x6f, 0x5e, 0x25, 0x14, 0x42, 0x27, 0x00, 0xb0, - 0x4f, 0xb2, 0x41, 0x46, 0xd6, 0x05, 0xd7, 0xf7, 0x01, 0xb4, 0x26, 0x4c, - 0x32, 0x00, 0xb6, 0x29, 0x00, 0xb7, 0x0a, 0xf8, 0xbe, 0x2b, 0x00, 0x4f, - 0x3d, 0x75, 0x0d, 0xf1, 0x41, 0x05, 0xae, 0x02, 0x04, 0xfa, 0x2e, 0xf1, - 0x41, 0x46, 0xb4, 0x21, 0xbe, 0x29, 0x00, 0x44, 0x31, 0x13, 0x2a, 0x27, - 0x40, 0x44, 0x29, 0x02, 0x97, 0x22, 0x00, 0x47, 0x02, 0x02, 0xd5, 0xf7, - 0xc1, 0x00, 0x45, 0xa4, 0x01, 0x8a, 0x23, 0x40, 0x4e, 0x6e, 0x72, 0xb8, - 0x29, 0x00, 0x4c, 0x48, 0x90, 0x9a, 0x22, 0x40, 0x47, 0xa4, 0x38, 0xb7, - 0x29, 0x00, 0x4c, 0xbc, 0x8e, 0xb9, 0x29, 0x00, 0x43, 0x74, 0x28, 0x95, - 0x22, 0x00, 0x4a, 0x40, 0xaf, 0x36, 0x30, 0x40, 0xa5, 0xdc, 0x02, 0xa6, - 0xec, 0x01, 0x48, 0xcc, 0x53, 0x72, 0x24, 0x00, 0xb3, 0xc2, 0x01, 0xb4, - 0x01, 0xff, 0x42, 0x92, 0x01, 0x69, 0x24, 0x80, 0xb1, 0x01, 0x04, 0x7a, - 0x11, 0x5a, 0x02, 0x15, 0x01, 0x01, 0xff, 0x43, 0x03, 0x2c, 0x6b, 0x24, - 0x00, 0x43, 0xe8, 0x1d, 0x73, 0x24, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x45, - 0x12, 0x0b, 0x58, 0x32, 0x00, 0xa6, 0x31, 0x44, 0xea, 0x2a, 0x59, 0x32, + 0x00, 0xe9, 0x10, 0x09, 0x00, 0x4d, 0x86, 0x89, 0x0a, 0x1b, 0x01, 0xf5, + 0x14, 0x09, 0x00, 0xf7, 0x75, 0x09, 0x00, 0xf9, 0xfe, 0xa8, 0x40, 0x45, + 0xb8, 0x00, 0x00, 0x1b, 0x81, 0x06, 0x46, 0x52, 0x05, 0xfb, 0xa8, 0x40, + 0x50, 0x6a, 0x63, 0x01, 0x1b, 0x41, 0x49, 0x64, 0xa1, 0xf9, 0xa8, 0x00, + 0x4b, 0x52, 0x24, 0x53, 0x09, 0x40, 0x44, 0x96, 0x21, 0x64, 0x09, 0x00, + 0x05, 0xf0, 0x06, 0x06, 0x4b, 0x33, 0xa6, 0x65, 0x09, 0x40, 0x45, 0x7e, + 0x0b, 0x6e, 0x09, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x6f, 0x09, 0x00, + 0x43, 0x7a, 0x0b, 0x67, 0x09, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, + 0x1f, 0x66, 0x09, 0x40, 0x44, 0x25, 0x01, 0x69, 0x09, 0x00, 0x42, 0x15, + 0x02, 0x68, 0x09, 0x40, 0x44, 0x06, 0x1f, 0x6d, 0x09, 0x00, 0x42, 0x09, + 0x24, 0x6c, 0x09, 0x40, 0x43, 0xf9, 0x05, 0x6b, 0x09, 0x00, 0x43, 0xf6, + 0x06, 0x6a, 0x09, 0x40, 0x50, 0x5e, 0x5a, 0x70, 0x09, 0x00, 0x4b, 0xa5, + 0x90, 0x54, 0x09, 0x40, 0x4c, 0xdc, 0x91, 0x0b, 0x26, 0x00, 0x02, 0x33, + 0x00, 0x11, 0x05, 0xdc, 0xed, 0x01, 0xff, 0x48, 0xf9, 0x4d, 0xa5, 0xf5, + 0x01, 0x46, 0x38, 0xe7, 0xd4, 0xf5, 0x41, 0x03, 0x8d, 0x09, 0x0b, 0xf4, + 0xdc, 0xf3, 0xc1, 0x00, 0x47, 0xf3, 0xd2, 0xdd, 0xf3, 0x41, 0x0f, 0x0b, + 0x06, 0xdd, 0x01, 0x0d, 0x9b, 0x08, 0x01, 0xff, 0x42, 0x9c, 0x11, 0x34, + 0x04, 0x01, 0x43, 0x1e, 0xbc, 0x3a, 0x04, 0x01, 0x44, 0x9e, 0x4d, 0x3d, + 0x04, 0x01, 0x43, 0x63, 0x85, 0x3c, 0x04, 0x01, 0xa5, 0x91, 0x01, 0x43, + 0x6e, 0xa1, 0x40, 0x04, 0x01, 0xe8, 0x38, 0x04, 0x01, 0x43, 0x4c, 0x3a, + 0x3e, 0x04, 0x01, 0x43, 0xfa, 0x82, 0x3f, 0x04, 0x01, 0x05, 0xd7, 0x02, + 0x5d, 0xaf, 0x53, 0x43, 0x4b, 0x80, 0x39, 0x04, 0x01, 0x06, 0x33, 0x07, + 0x2f, 0xb4, 0x21, 0x43, 0xfd, 0x06, 0x42, 0x04, 0x01, 0x42, 0x48, 0x33, + 0x36, 0x04, 0x01, 0x43, 0x22, 0xaf, 0x37, 0x04, 0x01, 0xba, 0x01, 0xff, + 0x42, 0x27, 0x01, 0x46, 0x04, 0x01, 0x43, 0xfa, 0x13, 0x48, 0x04, 0x41, + 0x42, 0x27, 0x01, 0x3b, 0x04, 0x01, 0x43, 0xfa, 0x13, 0x44, 0x04, 0x41, + 0xe1, 0x30, 0x04, 0x81, 0x11, 0xe5, 0x2f, 0x04, 0x01, 0xe9, 0x2e, 0x04, + 0x01, 0xef, 0x32, 0x04, 0xc1, 0x00, 0xef, 0x33, 0x04, 0x41, 0xe8, 0x31, + 0x04, 0x41, 0xe9, 0x4e, 0x04, 0x01, 0xf7, 0x35, 0x04, 0x41, 0xe1, 0x2a, + 0x04, 0x81, 0x11, 0xe5, 0x29, 0x04, 0x01, 0xe9, 0x28, 0x04, 0x01, 0xef, + 0x2c, 0x04, 0xc1, 0x00, 0xef, 0x2d, 0x04, 0x41, 0xe8, 0x2b, 0x04, 0x41, + 0xe6, 0x41, 0x04, 0x01, 0xec, 0x4a, 0x04, 0x01, 0xed, 0x4b, 0x04, 0x01, + 0xee, 0x4c, 0x04, 0x81, 0x17, 0xf2, 0x49, 0x04, 0x01, 0xf3, 0x45, 0x04, + 0x81, 0x0a, 0x42, 0x53, 0x00, 0x43, 0x04, 0x01, 0xf7, 0x4f, 0x04, 0x41, + 0xe8, 0x47, 0x04, 0x41, 0xe7, 0x4d, 0x04, 0x41, 0x42, 0x9c, 0x11, 0x0c, + 0x04, 0x01, 0x43, 0x1e, 0xbc, 0x12, 0x04, 0x01, 0x44, 0x9e, 0x4d, 0x15, + 0x04, 0x01, 0x43, 0x63, 0x85, 0x14, 0x04, 0x01, 0xa5, 0x91, 0x01, 0x43, + 0x6e, 0xa1, 0x18, 0x04, 0x01, 0xe8, 0x10, 0x04, 0x01, 0x43, 0x4c, 0x3a, + 0x16, 0x04, 0x01, 0x43, 0xfa, 0x82, 0x17, 0x04, 0x01, 0x05, 0xd7, 0x02, + 0x5d, 0xaf, 0x53, 0x43, 0x4b, 0x80, 0x11, 0x04, 0x01, 0x06, 0x33, 0x07, + 0x2f, 0xb4, 0x21, 0x43, 0xfd, 0x06, 0x1a, 0x04, 0x01, 0x42, 0x48, 0x33, + 0x0e, 0x04, 0x01, 0x43, 0x22, 0xaf, 0x0f, 0x04, 0x01, 0xba, 0x01, 0xff, + 0x42, 0x27, 0x01, 0x1e, 0x04, 0x01, 0x43, 0xfa, 0x13, 0x20, 0x04, 0x41, + 0x42, 0x27, 0x01, 0x13, 0x04, 0x01, 0x43, 0xfa, 0x13, 0x1c, 0x04, 0x41, + 0xe1, 0x08, 0x04, 0x81, 0x11, 0xe5, 0x07, 0x04, 0x01, 0xe9, 0x06, 0x04, + 0x01, 0xef, 0x0a, 0x04, 0xc1, 0x00, 0xef, 0x0b, 0x04, 0x41, 0xe8, 0x09, + 0x04, 0x41, 0xe9, 0x26, 0x04, 0x01, 0xf7, 0x0d, 0x04, 0x41, 0xe1, 0x02, + 0x04, 0x81, 0x11, 0xe5, 0x01, 0x04, 0x01, 0xe9, 0x00, 0x04, 0x01, 0xef, + 0x04, 0x04, 0xc1, 0x00, 0xef, 0x05, 0x04, 0x41, 0xe8, 0x03, 0x04, 0x41, + 0xe6, 0x19, 0x04, 0x01, 0xec, 0x22, 0x04, 0x01, 0xed, 0x23, 0x04, 0x01, + 0xee, 0x24, 0x04, 0x81, 0x17, 0xf2, 0x21, 0x04, 0x01, 0xf3, 0x1d, 0x04, + 0x81, 0x0a, 0x42, 0x53, 0x00, 0x1b, 0x04, 0x01, 0xf7, 0x27, 0x04, 0x41, + 0xe8, 0x1f, 0x04, 0x41, 0xe7, 0x25, 0x04, 0x41, 0x03, 0x41, 0x04, 0x81, + 0x01, 0x14, 0x63, 0x48, 0x01, 0xff, 0x53, 0x56, 0x4b, 0xc9, 0x23, 0x80, + 0x5e, 0x51, 0x67, 0x61, 0xca, 0x23, 0x80, 0x40, 0x09, 0x32, 0x00, 0x01, + 0xff, 0x04, 0x1a, 0x00, 0x11, 0x05, 0x51, 0x00, 0x01, 0xff, 0x46, 0x12, + 0x03, 0xc0, 0x23, 0x00, 0x48, 0x01, 0x02, 0xc3, 0x23, 0x40, 0x07, 0x29, + 0x0e, 0x16, 0x04, 0x1e, 0x00, 0x06, 0x44, 0x14, 0x5a, 0xc6, 0x23, 0x40, + 0x44, 0xc3, 0x00, 0xcb, 0x23, 0x00, 0x45, 0xc8, 0x00, 0xbe, 0x23, 0x40, + 0x44, 0xc3, 0x00, 0xcc, 0x23, 0x00, 0x45, 0xc8, 0x00, 0xbf, 0x23, 0x40, + 0x06, 0x50, 0x00, 0x01, 0xff, 0x46, 0x12, 0x03, 0xc2, 0x23, 0x00, 0x48, + 0x01, 0x02, 0xc5, 0x23, 0x00, 0x44, 0x14, 0x5a, 0xc8, 0x23, 0x40, 0x06, + 0x50, 0x00, 0x01, 0xff, 0x46, 0x12, 0x03, 0xc1, 0x23, 0x00, 0x48, 0x01, + 0x02, 0xc4, 0x23, 0x00, 0x44, 0x14, 0x5a, 0xc7, 0x23, 0x40, 0x4f, 0x43, + 0x71, 0x45, 0xcc, 0x01, 0x4d, 0xc1, 0x8e, 0x44, 0xcc, 0x41, 0x43, 0xe8, + 0x32, 0x7f, 0x00, 0x00, 0x4b, 0xef, 0xa2, 0x9a, 0xf6, 0x01, 0x4b, 0x6f, + 0xa8, 0x5c, 0x22, 0x40, 0x47, 0x9a, 0xd5, 0x03, 0x21, 0x00, 0x4a, 0xb0, + 0xaf, 0x09, 0x21, 0x00, 0x44, 0x5a, 0x03, 0xb0, 0x00, 0x40, 0xa9, 0x06, + 0x56, 0xa5, 0x38, 0xdb, 0xf5, 0x41, 0x4a, 0xc0, 0xae, 0x33, 0xf3, 0x01, + 0x04, 0x86, 0x10, 0x01, 0xff, 0x4f, 0x26, 0x70, 0xe8, 0x23, 0x00, 0x54, + 0xff, 0x47, 0x96, 0x23, 0x40, 0xd1, 0x11, 0x00, 0x00, 0xd2, 0x12, 0x00, + 0x00, 0xd3, 0x13, 0x00, 0x00, 0xd4, 0x14, 0x00, 0x00, 0xf3, 0x90, 0x00, + 0x40, 0x44, 0xc2, 0xe0, 0x20, 0x20, 0x80, 0x53, 0x4a, 0x62, 0xb2, 0x38, + 0x21, 0x00, 0xae, 0x3f, 0x04, 0xd9, 0x46, 0x2f, 0x02, 0xa4, 0x02, 0x06, + 0x4e, 0x1a, 0x6e, 0x10, 0x00, 0x40, 0x80, 0x17, 0x03, 0x05, 0x00, 0x01, + 0xff, 0x48, 0x07, 0x8f, 0x4d, 0xfe, 0x00, 0x48, 0x14, 0x8f, 0x49, 0xfe, + 0x00, 0x60, 0x93, 0x06, 0x9f, 0x27, 0x40, 0x46, 0x16, 0x08, 0xa8, 0xf4, + 0x01, 0x50, 0xea, 0x6b, 0x43, 0x2e, 0x40, 0x44, 0x4c, 0x04, 0x93, 0x25, + 0x00, 0x49, 0x23, 0xc6, 0x76, 0xf5, 0x41, 0x43, 0xe1, 0x18, 0x83, 0xf4, + 0x01, 0x42, 0xd4, 0x14, 0x61, 0xf3, 0x41, 0x80, 0x01, 0xff, 0x45, 0x05, + 0xab, 0xe1, 0xf5, 0x01, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4a, 0x1c, 0xb2, + 0x36, 0x2e, 0x00, 0x4b, 0x25, 0xa7, 0x37, 0x2e, 0x40, 0xa1, 0xed, 0xbd, + 0x01, 0x42, 0x3b, 0x15, 0x94, 0x00, 0x00, 0xa5, 0xa1, 0xbd, 0x01, 0x42, + 0x19, 0xfb, 0x4f, 0x03, 0x00, 0xa8, 0x80, 0xac, 0x01, 0xa9, 0xbf, 0x9c, + 0x01, 0x03, 0xde, 0x34, 0x87, 0x94, 0x01, 0xac, 0x89, 0x90, 0x01, 0xaf, + 0x8c, 0x6a, 0xf2, 0x0d, 0x00, 0x80, 0xc9, 0x68, 0x42, 0x5a, 0x03, 0x9b, + 0x00, 0x00, 0xb5, 0xaf, 0x1b, 0xb9, 0x01, 0xff, 0x45, 0x52, 0xeb, 0x00, + 0xf3, 0x01, 0x4a, 0x9e, 0xb2, 0x2d, 0x23, 0x00, 0x02, 0x6d, 0x0d, 0xe0, + 0x15, 0x07, 0xb8, 0xd2, 0x01, 0xff, 0x09, 0x0b, 0x06, 0xf2, 0x0b, 0x46, + 0x37, 0x52, 0x7e, 0xa6, 0x00, 0x07, 0x13, 0x06, 0xd5, 0x0b, 0x47, 0x7f, + 0xda, 0x7f, 0xa6, 0x00, 0xb3, 0x06, 0x4e, 0xd6, 0x80, 0x82, 0x04, 0x40, + 0x06, 0x9c, 0x08, 0x99, 0x01, 0x16, 0xc3, 0x39, 0x01, 0xff, 0xe1, 0x51, + 0xe0, 0x01, 0xa2, 0x83, 0x01, 0x43, 0x3b, 0x15, 0x63, 0xe0, 0x01, 0xa4, + 0x6a, 0xa5, 0x5c, 0x43, 0x82, 0x54, 0x54, 0xe0, 0x81, 0x4f, 0x42, 0x22, + 0x00, 0x61, 0xe0, 0x81, 0x42, 0xe9, 0x59, 0xe0, 0x81, 0x39, 0x42, 0x1b, + 0x02, 0x5a, 0xe0, 0x01, 0xef, 0x5c, 0xe0, 0x01, 0x42, 0x6f, 0x02, 0x5d, + 0xe0, 0x01, 0x43, 0xa4, 0x02, 0x64, 0xe0, 0x01, 0x43, 0x78, 0x60, 0x62, + 0xe0, 0x01, 0xf5, 0x5f, 0xe0, 0x01, 0x42, 0x32, 0x00, 0x53, 0xe0, 0x01, + 0x44, 0xf8, 0xdc, 0x66, 0xe0, 0x01, 0xba, 0x01, 0xff, 0xe5, 0x58, 0xe0, + 0x01, 0x42, 0xb0, 0x01, 0x57, 0xe0, 0x41, 0xe5, 0x56, 0xe0, 0x41, 0x47, + 0xe1, 0x97, 0x65, 0xe0, 0x41, 0x4c, 0x44, 0x90, 0x67, 0xe0, 0x41, 0xe6, + 0x60, 0xe0, 0x01, 0xec, 0x5b, 0xe0, 0x01, 0xf3, 0x5e, 0xe0, 0x41, 0xe5, + 0x55, 0xe0, 0x01, 0xba, 0x01, 0xff, 0xe5, 0x69, 0xe0, 0x01, 0x42, 0xb0, + 0x01, 0x6a, 0xe0, 0x41, 0xe5, 0x52, 0xe0, 0x01, 0x57, 0xa9, 0x08, 0x68, + 0xe0, 0x41, 0x06, 0x14, 0x06, 0x17, 0x08, 0xde, 0x11, 0x01, 0xff, 0x44, + 0xb8, 0xf4, 0xd5, 0x04, 0x00, 0x46, 0x32, 0xe1, 0xa5, 0x04, 0x00, 0x46, + 0x7e, 0xe6, 0xb5, 0x04, 0x40, 0xe1, 0x30, 0x04, 0x80, 0xd5, 0x09, 0xa2, + 0x99, 0x09, 0xa3, 0xe4, 0x08, 0xa4, 0x8f, 0x08, 0xe5, 0x4d, 0x04, 0x80, + 0x94, 0x07, 0x44, 0xb4, 0xf5, 0x73, 0x04, 0x00, 0xa7, 0xda, 0x06, 0xa8, + 0xb0, 0x06, 0xe9, 0x38, 0x04, 0x80, 0xc0, 0x05, 0x42, 0xa3, 0x21, 0x58, + 0x04, 0x00, 0xab, 0xc7, 0x04, 0xac, 0xac, 0x04, 0x04, 0xc4, 0x19, 0x9b, + 0x04, 0xae, 0x86, 0x04, 0xef, 0x3e, 0x04, 0x80, 0xe9, 0x03, 0xb0, 0xc4, + 0x03, 0x42, 0x11, 0x15, 0x1b, 0x05, 0x00, 0xb2, 0x88, 0x03, 0xb3, 0x99, + 0x02, 0xb4, 0xba, 0x01, 0xf5, 0x43, 0x04, 0x80, 0x8b, 0x01, 0x42, 0x32, + 0x00, 0x32, 0x04, 0x00, 0xb7, 0x79, 0xb9, 0x46, 0xba, 0x01, 0xff, 0xe5, + 0x37, 0x04, 0x80, 0x28, 0xa8, 0x01, 0xff, 0xe5, 0x36, 0x04, 0x80, 0x06, + 0x42, 0x15, 0x01, 0x85, 0xa6, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, + 0x8f, 0x24, 0xc2, 0x04, 0x00, 0xa4, 0x01, 0xff, 0x48, 0xf3, 0x11, 0x97, + 0x04, 0x00, 0x48, 0xf4, 0x24, 0xdd, 0x04, 0x40, 0x07, 0x82, 0x07, 0x06, + 0x44, 0x28, 0xf7, 0x41, 0xa6, 0x40, 0x48, 0xf3, 0x11, 0x99, 0x04, 0x00, + 0x48, 0xf4, 0x24, 0xdf, 0x04, 0x40, 0xe1, 0x4f, 0x04, 0x80, 0x24, 0x43, + 0x3a, 0x2d, 0x4b, 0x04, 0x80, 0x0c, 0xe9, 0x57, 0x04, 0x00, 0xee, 0x5f, + 0xa6, 0x00, 0xf5, 0x4e, 0x04, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x48, + 0xc4, 0x78, 0x51, 0xa6, 0x00, 0x49, 0xf3, 0x24, 0xf9, 0x04, 0x40, 0xe5, + 0x19, 0x05, 0x00, 0xf4, 0x63, 0x04, 0x40, 0xe5, 0x1d, 0x05, 0x00, 0x46, + 0xb2, 0xe2, 0x83, 0x1c, 0x40, 0x06, 0x50, 0x00, 0x11, 0xeb, 0x79, 0x04, + 0x80, 0x06, 0x4b, 0x0a, 0xa5, 0x88, 0x1c, 0x40, 0x4a, 0x32, 0xa3, 0x54, + 0x04, 0x40, 0xa4, 0x06, 0x46, 0xd1, 0x73, 0xef, 0x04, 0x40, 0x48, 0xf4, + 0x24, 0xf1, 0x04, 0x00, 0x4b, 0x28, 0xa6, 0xf3, 0x04, 0x40, 0x04, 0x5f, + 0x07, 0x46, 0x43, 0x3b, 0x15, 0x93, 0xa6, 0x00, 0xe5, 0x42, 0x04, 0x80, + 0x2a, 0x4e, 0xea, 0x7b, 0x85, 0x1c, 0x00, 0x42, 0xa3, 0x21, 0x8a, 0x1c, + 0x00, 0xb3, 0x06, 0x42, 0x15, 0x01, 0x8d, 0xa6, 0x40, 0xe5, 0x46, 0x04, + 0x00, 0x42, 0xb0, 0x01, 0x5b, 0x04, 0x00, 0x42, 0x46, 0x03, 0x91, 0xa6, + 0x00, 0x42, 0x15, 0x01, 0x8f, 0xa6, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, + 0x49, 0xf2, 0x11, 0xad, 0x04, 0x00, 0x4b, 0xbd, 0xa4, 0x8b, 0xa6, 0x40, + 0x49, 0x1b, 0xbf, 0x86, 0x1c, 0x00, 0x42, 0x77, 0x00, 0x84, 0x1c, 0x00, + 0x43, 0x69, 0x34, 0x87, 0x1c, 0x40, 0x44, 0x82, 0x7f, 0xd9, 0x04, 0x80, + 0x5f, 0x4c, 0x38, 0x93, 0x8d, 0x04, 0x00, 0xa8, 0x27, 0x04, 0x36, 0x74, + 0x0d, 0x49, 0xc0, 0xc5, 0xaf, 0x04, 0xc0, 0x00, 0x4c, 0x78, 0x2a, 0xb1, + 0x04, 0x40, 0x42, 0x04, 0x00, 0x63, 0xa6, 0x00, 0xa5, 0x06, 0x44, 0x5a, + 0x03, 0x4c, 0x04, 0x40, 0xec, 0x65, 0xa6, 0x00, 0xed, 0x67, 0xa6, 0x40, + 0xe1, 0x48, 0x04, 0x00, 0x43, 0xd0, 0x18, 0x49, 0x04, 0x00, 0x42, 0x22, + 0x00, 0xbb, 0x04, 0x80, 0x19, 0x04, 0x35, 0x07, 0x06, 0x42, 0x15, 0x01, + 0x97, 0xa6, 0x40, 0xe9, 0x39, 0x04, 0x80, 0x04, 0xf5, 0x5e, 0x04, 0x40, + 0x4a, 0xe6, 0xab, 0x8b, 0x04, 0x40, 0x4f, 0xec, 0x11, 0x27, 0x05, 0x40, + 0x4f, 0x29, 0x6d, 0xdb, 0x04, 0x40, 0x08, 0xac, 0x15, 0x17, 0x42, 0x22, + 0x00, 0x17, 0x05, 0x00, 0x04, 0xad, 0x0b, 0x01, 0xff, 0x46, 0x36, 0x92, + 0x7b, 0x04, 0x00, 0x45, 0x13, 0x18, 0x80, 0x1c, 0x40, 0x43, 0x27, 0xfa, + 0x45, 0xa6, 0x00, 0x43, 0x78, 0x60, 0x61, 0xa6, 0x00, 0x42, 0x87, 0x50, + 0x55, 0xa6, 0x00, 0x42, 0x94, 0x0a, 0x11, 0x05, 0x40, 0x47, 0x80, 0xcf, + 0xcf, 0x04, 0x00, 0xe5, 0x3f, 0x04, 0x80, 0x06, 0x42, 0x5a, 0x03, 0x71, + 0x04, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x49, 0xf2, 0x11, 0x25, 0x05, + 0x00, 0x4b, 0xbd, 0xa4, 0xa7, 0x04, 0x40, 0x4f, 0x29, 0x6d, 0xe7, 0x04, + 0x00, 0x44, 0x99, 0x7f, 0x61, 0x04, 0x80, 0x04, 0xf4, 0x7f, 0x04, 0x40, + 0x4b, 0x4e, 0x9d, 0x7d, 0x04, 0x40, 0x47, 0xe5, 0x03, 0x82, 0x1c, 0x00, + 0x4a, 0x88, 0xaf, 0x4f, 0xa6, 0x00, 0x42, 0xa3, 0x21, 0x5a, 0x04, 0x40, + 0x47, 0x83, 0x8a, 0x69, 0xa6, 0x00, 0x48, 0xf0, 0x96, 0x4b, 0xa6, 0x40, + 0x42, 0x22, 0x00, 0x15, 0x05, 0x00, 0x49, 0xb9, 0x5b, 0x67, 0x04, 0x00, + 0x42, 0xa3, 0x21, 0x59, 0x04, 0x00, 0x4d, 0x5a, 0x8b, 0x81, 0x1c, 0x40, + 0xe1, 0x3a, 0x04, 0x80, 0x4e, 0x4d, 0x98, 0x87, 0xcc, 0x04, 0x00, 0x42, + 0xa3, 0x21, 0x5c, 0x04, 0x00, 0xaf, 0x06, 0x42, 0x5a, 0x03, 0x6f, 0x04, + 0x40, 0x03, 0x8a, 0xd7, 0x06, 0x43, 0xbd, 0x84, 0x81, 0x04, 0x40, 0xa4, + 0x1e, 0x43, 0xa2, 0x21, 0x09, 0x05, 0x00, 0x43, 0xdc, 0x88, 0x0b, 0x05, + 0x00, 0x43, 0x04, 0xa3, 0x0d, 0x05, 0x00, 0x43, 0x9f, 0xfa, 0x0f, 0x05, + 0x00, 0x43, 0xd8, 0xfa, 0x05, 0x05, 0x40, 0xe5, 0x01, 0x05, 0x00, 0x42, + 0xa3, 0x21, 0x03, 0x05, 0x00, 0x43, 0xd8, 0xfa, 0x07, 0x05, 0x40, 0x06, + 0x50, 0x00, 0x01, 0xff, 0x49, 0xf2, 0x11, 0x9b, 0x04, 0x00, 0x44, 0x5b, + 0x0f, 0xc4, 0x04, 0x00, 0x46, 0x52, 0x05, 0x9f, 0x04, 0x00, 0x4f, 0x68, + 0x35, 0x9d, 0x04, 0x40, 0x06, 0x50, 0x00, 0x54, 0xe5, 0x35, 0x04, 0x80, + 0x3e, 0xef, 0x51, 0x04, 0x80, 0x0d, 0x46, 0x8c, 0xe7, 0x75, 0x04, 0xc0, + 0x00, 0x59, 0x44, 0x24, 0x77, 0x04, 0x40, 0xb4, 0x01, 0xff, 0xe1, 0x47, + 0xa6, 0x00, 0x06, 0xf2, 0x02, 0x01, 0xff, 0xe1, 0x57, 0xa6, 0x00, 0x47, + 0x3f, 0xd5, 0x6d, 0x04, 0x00, 0x51, 0xb1, 0x5b, 0x5d, 0xa6, 0x00, 0xe5, + 0x65, 0x04, 0x00, 0x4a, 0xb8, 0x5b, 0x69, 0x04, 0x00, 0x43, 0x69, 0x34, + 0x53, 0xa6, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0x8f, 0x24, 0xd7, + 0x04, 0x00, 0x45, 0x51, 0x24, 0x50, 0x04, 0x40, 0x49, 0xf3, 0x24, 0xe5, + 0x04, 0x00, 0x45, 0x51, 0x24, 0x5d, 0x04, 0x00, 0x46, 0xd1, 0x73, 0xe3, + 0x04, 0x40, 0xe1, 0x45, 0x04, 0x80, 0x06, 0x42, 0x15, 0x01, 0x95, 0xa6, + 0x40, 0x06, 0x50, 0x00, 0x06, 0x47, 0xe1, 0x97, 0x4a, 0x04, 0x40, 0x49, + 0xf2, 0x11, 0xb3, 0x04, 0x00, 0x44, 0x5b, 0x0f, 0xfd, 0x04, 0x00, 0x46, + 0x52, 0x05, 0xff, 0x04, 0x40, 0x42, 0xb0, 0x01, 0x33, 0x04, 0x80, 0x06, + 0x42, 0xa3, 0x21, 0x53, 0x04, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x49, + 0xf2, 0x11, 0xf7, 0x04, 0x00, 0x4b, 0xbd, 0xa4, 0x95, 0x04, 0x00, 0x46, + 0x52, 0x05, 0x93, 0x04, 0x80, 0x06, 0x46, 0xf4, 0x6b, 0x91, 0x04, 0x40, + 0x49, 0xfc, 0x24, 0xfb, 0x04, 0x40, 0x4f, 0x29, 0x6d, 0xed, 0x04, 0x00, + 0xe6, 0x44, 0x04, 0x00, 0xec, 0x3b, 0x04, 0x80, 0x49, 0xed, 0x3c, 0x04, + 0x80, 0x3e, 0xee, 0x3d, 0x04, 0x80, 0x16, 0xf2, 0x40, 0x04, 0x80, 0x0b, + 0xf3, 0x41, 0x04, 0xc0, 0x00, 0x4f, 0xec, 0x11, 0xab, 0x04, 0x40, 0x4a, + 0xf0, 0xab, 0x8f, 0x04, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x49, 0xf2, + 0x11, 0xa3, 0x04, 0x00, 0x44, 0x5b, 0x0f, 0xc8, 0x04, 0x00, 0x49, 0x8e, + 0x46, 0x29, 0x05, 0x00, 0x4b, 0xbd, 0xa4, 0x23, 0x05, 0x00, 0x44, 0x79, + 0x18, 0xca, 0x04, 0x40, 0x4a, 0xe6, 0xab, 0xce, 0x04, 0x40, 0x06, 0x50, + 0x00, 0x01, 0xff, 0x49, 0xf2, 0x11, 0x2f, 0x05, 0x00, 0x44, 0x5b, 0x0f, + 0x13, 0x05, 0x00, 0x4b, 0xbd, 0xa4, 0x21, 0x05, 0x00, 0x44, 0x79, 0x18, + 0xc6, 0x04, 0x40, 0x43, 0x3b, 0x15, 0x2d, 0x05, 0x00, 0xe5, 0x34, 0x04, + 0x00, 0x42, 0xa3, 0x21, 0x52, 0x04, 0x80, 0x3b, 0x06, 0x3c, 0x01, 0x2d, + 0x42, 0x15, 0x01, 0x81, 0xa6, 0x00, 0xba, 0x01, 0xff, 0xe5, 0x55, 0x04, + 0x80, 0x19, 0x42, 0xb0, 0x01, 0x5f, 0x04, 0x00, 0x42, 0x15, 0x01, 0x83, + 0xa6, 0x00, 0xba, 0x01, 0xff, 0xe5, 0x89, 0xa6, 0x00, 0x42, 0xb0, 0x01, + 0x2b, 0x05, 0x40, 0x42, 0x13, 0x01, 0x43, 0xa6, 0x40, 0x4b, 0xd3, 0xa4, + 0x6d, 0xa6, 0x00, 0xef, 0x99, 0xa6, 0x40, 0x42, 0x27, 0x10, 0x49, 0xa6, + 0x40, 0x43, 0x3b, 0x15, 0x87, 0xa6, 0x00, 0x42, 0xb0, 0x01, 0x47, 0x04, + 0x80, 0x0c, 0x50, 0xb2, 0x5b, 0x59, 0xa6, 0x00, 0x48, 0x47, 0xd0, 0x9b, + 0xa6, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0xa4, 0x06, 0x4f, 0x68, 0x35, + 0xb9, 0x04, 0x40, 0x48, 0xf3, 0x11, 0xb7, 0x04, 0x00, 0x48, 0xf4, 0x24, + 0xf5, 0x04, 0x40, 0xa1, 0x24, 0xe5, 0x31, 0x04, 0x00, 0xa9, 0x12, 0x4a, + 0x58, 0xb2, 0x5b, 0xa6, 0x00, 0x4a, 0x18, 0xb6, 0x4d, 0xa6, 0x00, 0x57, + 0xa9, 0x08, 0x56, 0x04, 0x40, 0x45, 0x41, 0xd5, 0x6b, 0x04, 0x00, 0x49, + 0xd5, 0xa4, 0x6b, 0xa6, 0x40, 0x46, 0xc9, 0xd4, 0xe9, 0x04, 0x80, 0x06, + 0x48, 0x8f, 0xd0, 0xa1, 0x04, 0x40, 0x4f, 0x29, 0x6d, 0xeb, 0x04, 0x40, + 0x06, 0x50, 0x00, 0x23, 0x09, 0x4b, 0xbc, 0x06, 0x47, 0xb1, 0xd8, 0x1f, + 0x05, 0x40, 0x43, 0x3b, 0x15, 0xbd, 0x04, 0x80, 0x0c, 0x43, 0x27, 0xfa, + 0xe1, 0x04, 0x00, 0x42, 0x22, 0x00, 0xa9, 0x04, 0x40, 0x4f, 0xec, 0x11, + 0xbf, 0x04, 0x40, 0x45, 0x8f, 0x24, 0xd1, 0x04, 0x00, 0x49, 0xf3, 0x24, + 0xd3, 0x04, 0x40, 0x4d, 0x7d, 0x8a, 0x6e, 0xa6, 0x00, 0x48, 0x7f, 0xcf, + 0xc0, 0x04, 0x00, 0x50, 0x5a, 0x6a, 0x2b, 0x1d, 0x40, 0x06, 0x14, 0x06, + 0x17, 0x08, 0xde, 0x11, 0x01, 0xff, 0x44, 0xb8, 0xf4, 0xd4, 0x04, 0x00, + 0x46, 0x32, 0xe1, 0xa4, 0x04, 0x00, 0x46, 0x7e, 0xe6, 0xb4, 0x04, 0x40, + 0xe1, 0x10, 0x04, 0x80, 0x90, 0x09, 0xa2, 0xd4, 0x08, 0xa3, 0x9f, 0x08, + 0xa4, 0xca, 0x07, 0xe5, 0x2d, 0x04, 0x80, 0xcf, 0x06, 0x44, 0xb4, 0xf5, + 0x72, 0x04, 0x00, 0xa7, 0x95, 0x06, 0xa8, 0xeb, 0x05, 0xe9, 0x18, 0x04, + 0x80, 0xfb, 0x04, 0x42, 0xa3, 0x21, 0x08, 0x04, 0x00, 0xab, 0x82, 0x04, + 0xac, 0xed, 0x03, 0x04, 0xc4, 0x19, 0xdc, 0x03, 0xae, 0xcd, 0x03, 0xef, + 0x1e, 0x04, 0x80, 0xb0, 0x03, 0xb0, 0x91, 0x03, 0x42, 0x11, 0x15, 0x1a, + 0x05, 0x00, 0xb2, 0xe0, 0x02, 0xb3, 0xf1, 0x01, 0xb4, 0xae, 0x01, 0xf5, + 0x23, 0x04, 0x80, 0x85, 0x01, 0x42, 0x32, 0x00, 0x12, 0x04, 0x00, 0x42, + 0x15, 0x01, 0x1c, 0x05, 0x00, 0xb9, 0x46, 0xba, 0x01, 0xff, 0xe5, 0x17, + 0x04, 0x80, 0x28, 0xa8, 0x01, 0xff, 0xe5, 0x16, 0x04, 0x80, 0x06, 0x42, + 0x15, 0x01, 0x84, 0xa6, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0x8f, + 0x24, 0xc1, 0x04, 0x00, 0xa4, 0x01, 0xff, 0x48, 0xf3, 0x11, 0x96, 0x04, + 0x00, 0x48, 0xf4, 0x24, 0xdc, 0x04, 0x40, 0x07, 0x82, 0x07, 0x06, 0x44, + 0x28, 0xf7, 0x40, 0xa6, 0x40, 0x48, 0xf3, 0x11, 0x98, 0x04, 0x00, 0x48, + 0xf4, 0x24, 0xde, 0x04, 0x40, 0xe1, 0x2f, 0x04, 0x80, 0x24, 0x43, 0x3a, + 0x2d, 0x2b, 0x04, 0x80, 0x0c, 0xe9, 0x07, 0x04, 0x00, 0xee, 0x5e, 0xa6, + 0x00, 0xf5, 0x2e, 0x04, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x48, 0xc4, + 0x78, 0x50, 0xa6, 0x00, 0x49, 0xf3, 0x24, 0xf8, 0x04, 0x40, 0xe5, 0x18, + 0x05, 0x00, 0xf4, 0x62, 0x04, 0x40, 0x06, 0x50, 0x00, 0x0b, 0xeb, 0x78, + 0x04, 0xc0, 0x00, 0x4a, 0x32, 0xa3, 0x04, 0x04, 0x40, 0xa4, 0x06, 0x46, + 0xd1, 0x73, 0xee, 0x04, 0x40, 0x48, 0xf4, 0x24, 0xf0, 0x04, 0x00, 0x4b, + 0x28, 0xa6, 0xf2, 0x04, 0x40, 0x43, 0x3b, 0x15, 0x92, 0xa6, 0x00, 0xe5, + 0x22, 0x04, 0x80, 0x24, 0x42, 0xa3, 0x21, 0x89, 0x1c, 0x00, 0xb3, 0x06, + 0x42, 0x15, 0x01, 0x8c, 0xa6, 0x40, 0xe5, 0x26, 0x04, 0x00, 0x42, 0xb0, + 0x01, 0x0b, 0x04, 0x00, 0x42, 0x46, 0x03, 0x90, 0xa6, 0x00, 0x42, 0x15, + 0x01, 0x8e, 0xa6, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x49, 0xf2, 0x11, + 0xac, 0x04, 0x00, 0x4b, 0xbd, 0xa4, 0x8a, 0xa6, 0x40, 0x44, 0x82, 0x7f, + 0xd8, 0x04, 0x80, 0x5f, 0x4c, 0x38, 0x93, 0x8c, 0x04, 0x00, 0xa8, 0x27, + 0x04, 0x36, 0x74, 0x0d, 0x49, 0xc0, 0xc5, 0xae, 0x04, 0xc0, 0x00, 0x4c, + 0x78, 0x2a, 0xb0, 0x04, 0x40, 0x42, 0x04, 0x00, 0x62, 0xa6, 0x00, 0xa5, + 0x06, 0x44, 0x5a, 0x03, 0x2c, 0x04, 0x40, 0xec, 0x64, 0xa6, 0x00, 0xed, + 0x66, 0xa6, 0x40, 0xe1, 0x28, 0x04, 0x00, 0x43, 0xd0, 0x18, 0x29, 0x04, + 0x00, 0x42, 0x22, 0x00, 0xba, 0x04, 0x80, 0x19, 0x04, 0x35, 0x07, 0x06, + 0x42, 0x15, 0x01, 0x96, 0xa6, 0x40, 0xe9, 0x19, 0x04, 0x80, 0x04, 0xf5, + 0x0e, 0x04, 0x40, 0x4a, 0xe6, 0xab, 0x8a, 0x04, 0x40, 0x4f, 0xec, 0x11, + 0x26, 0x05, 0x40, 0x4f, 0x29, 0x6d, 0xda, 0x04, 0x40, 0x08, 0xac, 0x15, + 0x0c, 0x42, 0x22, 0x00, 0x16, 0x05, 0x00, 0x4a, 0xce, 0xb4, 0x7a, 0x04, + 0x40, 0x43, 0x27, 0xfa, 0x44, 0xa6, 0x00, 0x43, 0x78, 0x60, 0x60, 0xa6, + 0x00, 0x42, 0x87, 0x50, 0x54, 0xa6, 0x00, 0x42, 0x94, 0x0a, 0x10, 0x05, + 0x40, 0xe5, 0x1f, 0x04, 0x80, 0x06, 0x42, 0x5a, 0x03, 0x70, 0x04, 0x40, + 0x06, 0x50, 0x00, 0x01, 0xff, 0x49, 0xf2, 0x11, 0x24, 0x05, 0x00, 0x4b, + 0xbd, 0xa4, 0xa6, 0x04, 0x40, 0x4f, 0x29, 0x6d, 0xe6, 0x04, 0x00, 0x44, + 0x99, 0x7f, 0x60, 0x04, 0x80, 0x04, 0xf4, 0x7e, 0x04, 0x40, 0x4b, 0x4e, + 0x9d, 0x7c, 0x04, 0x40, 0x4a, 0x88, 0xaf, 0x4e, 0xa6, 0x00, 0x42, 0xa3, + 0x21, 0x0a, 0x04, 0x40, 0x47, 0x83, 0x8a, 0x68, 0xa6, 0x00, 0x48, 0xf0, + 0x96, 0x4a, 0xa6, 0x40, 0x42, 0x22, 0x00, 0x14, 0x05, 0x00, 0x49, 0xb9, + 0x5b, 0x66, 0x04, 0x00, 0x42, 0xa3, 0x21, 0x09, 0x04, 0x40, 0xe1, 0x1a, + 0x04, 0x80, 0x4e, 0x4d, 0x98, 0x87, 0xcb, 0x04, 0x00, 0x42, 0xa3, 0x21, + 0x0c, 0x04, 0x00, 0xaf, 0x06, 0x42, 0x5a, 0x03, 0x6e, 0x04, 0x40, 0x03, + 0x8a, 0xd7, 0x06, 0x43, 0xbd, 0x84, 0x80, 0x04, 0x40, 0xa4, 0x1e, 0x43, + 0xa2, 0x21, 0x08, 0x05, 0x00, 0x43, 0xdc, 0x88, 0x0a, 0x05, 0x00, 0x43, + 0x04, 0xa3, 0x0c, 0x05, 0x00, 0x43, 0x9f, 0xfa, 0x0e, 0x05, 0x00, 0x43, + 0xd8, 0xfa, 0x04, 0x05, 0x40, 0xe5, 0x00, 0x05, 0x00, 0x42, 0xa3, 0x21, + 0x02, 0x05, 0x00, 0x43, 0xd8, 0xfa, 0x06, 0x05, 0x40, 0x06, 0x50, 0x00, + 0x01, 0xff, 0x49, 0xf2, 0x11, 0x9a, 0x04, 0x00, 0x44, 0x5b, 0x0f, 0xc3, + 0x04, 0x00, 0x46, 0x52, 0x05, 0x9e, 0x04, 0x00, 0x4f, 0x68, 0x35, 0x9c, + 0x04, 0x40, 0x06, 0x50, 0x00, 0x54, 0xe5, 0x15, 0x04, 0x80, 0x3e, 0xef, + 0x01, 0x04, 0x80, 0x0d, 0x46, 0x8c, 0xe7, 0x74, 0x04, 0xc0, 0x00, 0x59, + 0x44, 0x24, 0x76, 0x04, 0x40, 0xb4, 0x01, 0xff, 0xe1, 0x46, 0xa6, 0x00, + 0x06, 0xf2, 0x02, 0x01, 0xff, 0xe1, 0x56, 0xa6, 0x00, 0x47, 0x3f, 0xd5, + 0x6c, 0x04, 0x00, 0x51, 0xb1, 0x5b, 0x5c, 0xa6, 0x00, 0xe5, 0x64, 0x04, + 0x00, 0x4a, 0xb8, 0x5b, 0x68, 0x04, 0x00, 0x43, 0x69, 0x34, 0x52, 0xa6, + 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0x8f, 0x24, 0xd6, 0x04, 0x00, + 0x45, 0x51, 0x24, 0x00, 0x04, 0x40, 0x49, 0xf3, 0x24, 0xe4, 0x04, 0x00, + 0x45, 0x51, 0x24, 0x0d, 0x04, 0x00, 0x46, 0xd1, 0x73, 0xe2, 0x04, 0x40, + 0xe1, 0x25, 0x04, 0x80, 0x06, 0x42, 0x15, 0x01, 0x94, 0xa6, 0x40, 0x06, + 0x50, 0x00, 0x06, 0x47, 0xe1, 0x97, 0x2a, 0x04, 0x40, 0x49, 0xf2, 0x11, + 0xb2, 0x04, 0x00, 0x44, 0x5b, 0x0f, 0xfc, 0x04, 0x00, 0x46, 0x52, 0x05, + 0xfe, 0x04, 0x40, 0x42, 0xb0, 0x01, 0x13, 0x04, 0x80, 0x06, 0x42, 0xa3, + 0x21, 0x03, 0x04, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x49, 0xf2, 0x11, + 0xf6, 0x04, 0x00, 0x4b, 0xbd, 0xa4, 0x94, 0x04, 0x00, 0x46, 0x52, 0x05, + 0x92, 0x04, 0x80, 0x06, 0x46, 0xf4, 0x6b, 0x90, 0x04, 0x40, 0x49, 0xfc, + 0x24, 0xfa, 0x04, 0x40, 0x4f, 0x29, 0x6d, 0xec, 0x04, 0x00, 0xe6, 0x24, + 0x04, 0x00, 0xec, 0x1b, 0x04, 0x80, 0x49, 0xed, 0x1c, 0x04, 0x80, 0x3e, + 0xee, 0x1d, 0x04, 0x80, 0x16, 0xf2, 0x20, 0x04, 0x80, 0x0b, 0xf3, 0x21, + 0x04, 0xc0, 0x00, 0x4f, 0xec, 0x11, 0xaa, 0x04, 0x40, 0x4a, 0xf0, 0xab, + 0x8e, 0x04, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x49, 0xf2, 0x11, 0xa2, + 0x04, 0x00, 0x44, 0x5b, 0x0f, 0xc7, 0x04, 0x00, 0x49, 0x8e, 0x46, 0x28, + 0x05, 0x00, 0x4b, 0xbd, 0xa4, 0x22, 0x05, 0x00, 0x44, 0x79, 0x18, 0xc9, + 0x04, 0x40, 0x4a, 0xe6, 0xab, 0xcd, 0x04, 0x40, 0x06, 0x50, 0x00, 0x01, + 0xff, 0x49, 0xf2, 0x11, 0x2e, 0x05, 0x00, 0x44, 0x5b, 0x0f, 0x12, 0x05, + 0x00, 0x4b, 0xbd, 0xa4, 0x20, 0x05, 0x00, 0x44, 0x79, 0x18, 0xc5, 0x04, + 0x40, 0x43, 0x3b, 0x15, 0x2c, 0x05, 0x00, 0xe5, 0x14, 0x04, 0x00, 0x42, + 0xa3, 0x21, 0x02, 0x04, 0x80, 0x3b, 0x06, 0x3c, 0x01, 0x2d, 0x42, 0x15, + 0x01, 0x80, 0xa6, 0x00, 0xba, 0x01, 0xff, 0xe5, 0x05, 0x04, 0x80, 0x19, + 0x42, 0xb0, 0x01, 0x0f, 0x04, 0x00, 0x42, 0x15, 0x01, 0x82, 0xa6, 0x00, + 0xba, 0x01, 0xff, 0xe5, 0x88, 0xa6, 0x00, 0x42, 0xb0, 0x01, 0x2a, 0x05, + 0x40, 0x42, 0x13, 0x01, 0x42, 0xa6, 0x40, 0x4b, 0xd3, 0xa4, 0x6c, 0xa6, + 0x00, 0xef, 0x98, 0xa6, 0x40, 0x42, 0x27, 0x10, 0x48, 0xa6, 0x40, 0x43, + 0x3b, 0x15, 0x86, 0xa6, 0x00, 0x42, 0xb0, 0x01, 0x27, 0x04, 0x80, 0x0c, + 0x50, 0xb2, 0x5b, 0x58, 0xa6, 0x00, 0x48, 0x47, 0xd0, 0x9a, 0xa6, 0x40, + 0x06, 0x50, 0x00, 0x01, 0xff, 0xa4, 0x06, 0x4f, 0x68, 0x35, 0xb8, 0x04, + 0x40, 0x48, 0xf3, 0x11, 0xb6, 0x04, 0x00, 0x48, 0xf4, 0x24, 0xf4, 0x04, + 0x40, 0xa1, 0x24, 0xe5, 0x11, 0x04, 0x00, 0xa9, 0x12, 0x4a, 0x58, 0xb2, + 0x5a, 0xa6, 0x00, 0x4a, 0x18, 0xb6, 0x4c, 0xa6, 0x00, 0x57, 0xa9, 0x08, + 0x06, 0x04, 0x40, 0x45, 0x41, 0xd5, 0x6a, 0x04, 0x00, 0x49, 0xd5, 0xa4, + 0x6a, 0xa6, 0x40, 0x46, 0xc9, 0xd4, 0xe8, 0x04, 0x80, 0x06, 0x48, 0x8f, + 0xd0, 0xa0, 0x04, 0x40, 0x4f, 0x29, 0x6d, 0xea, 0x04, 0x40, 0x06, 0x50, + 0x00, 0x23, 0x09, 0x4b, 0xbc, 0x06, 0x47, 0xb1, 0xd8, 0x1e, 0x05, 0x40, + 0x43, 0x3b, 0x15, 0xbc, 0x04, 0x80, 0x0c, 0x43, 0x27, 0xfa, 0xe0, 0x04, + 0x00, 0x42, 0x22, 0x00, 0xa8, 0x04, 0x40, 0x4f, 0xec, 0x11, 0xbe, 0x04, + 0x40, 0x45, 0x8f, 0x24, 0xd0, 0x04, 0x00, 0x49, 0xf3, 0x24, 0xd2, 0x04, + 0x40, 0x0d, 0x82, 0x88, 0xbc, 0x03, 0x10, 0x7a, 0x68, 0x01, 0xff, 0x90, + 0x44, 0x91, 0x0d, 0x02, 0xa9, 0xf9, 0x01, 0xff, 0xd1, 0xf1, 0x2f, 0x01, + 0xd2, 0xf2, 0x2f, 0x41, 0x90, 0x0f, 0x91, 0x01, 0xff, 0xd0, 0xee, 0x2f, + 0x01, 0xd2, 0xef, 0x2f, 0x01, 0xd4, 0xf0, 0x2f, 0x41, 0xd0, 0xe5, 0x2f, + 0x01, 0xd1, 0xe6, 0x2f, 0x01, 0xd2, 0xe7, 0x2f, 0x01, 0xd3, 0xe8, 0x2f, + 0x01, 0xd4, 0xe9, 0x2f, 0x01, 0xd5, 0xea, 0x2f, 0x01, 0xd7, 0xeb, 0x2f, + 0x01, 0xd8, 0xec, 0x2f, 0x01, 0xd9, 0xed, 0x2f, 0x41, 0x90, 0xce, 0x02, + 0x91, 0xaa, 0x02, 0x92, 0x87, 0x02, 0x93, 0xe4, 0x01, 0x94, 0xc9, 0x01, + 0x95, 0xa2, 0x01, 0x96, 0x7c, 0x97, 0x51, 0x98, 0x27, 0x99, 0x01, 0xff, + 0xd0, 0xdc, 0x2f, 0x01, 0xd1, 0xdd, 0x2f, 0x01, 0xd2, 0xde, 0x2f, 0x01, + 0xd4, 0xdf, 0x2f, 0x01, 0xd5, 0xe0, 0x2f, 0x01, 0xd6, 0xe1, 0x2f, 0x01, + 0xd7, 0xe2, 0x2f, 0x01, 0xd8, 0xe3, 0x2f, 0x01, 0xd9, 0xe4, 0x2f, 0x41, + 0xd0, 0xd2, 0x2f, 0x01, 0xd1, 0xd3, 0x2f, 0x01, 0xd2, 0xd4, 0x2f, 0x01, + 0xd3, 0xd5, 0x2f, 0x01, 0xd4, 0xd6, 0x2f, 0x01, 0xd5, 0xd7, 0x2f, 0x01, + 0xd6, 0xd8, 0x2f, 0x01, 0xd7, 0xd9, 0x2f, 0x01, 0xd8, 0xda, 0x2f, 0x01, + 0xd9, 0xdb, 0x2f, 0x41, 0xd0, 0xc8, 0x2f, 0x01, 0xd1, 0xc9, 0x2f, 0x01, + 0xd2, 0xca, 0x2f, 0x01, 0xd3, 0xcb, 0x2f, 0x01, 0xd4, 0xcc, 0x2f, 0x01, + 0xd5, 0xcd, 0x2f, 0x81, 0x0c, 0xd6, 0xcf, 0x2f, 0x01, 0xd8, 0xd0, 0x2f, + 0x01, 0xd9, 0xd1, 0x2f, 0x41, 0xe2, 0xce, 0x2f, 0x41, 0xd0, 0xbf, 0x2f, + 0x01, 0xd1, 0xc0, 0x2f, 0x01, 0xd2, 0xc1, 0x2f, 0x01, 0xd3, 0xc2, 0x2f, + 0x01, 0xd4, 0xc3, 0x2f, 0x01, 0xd6, 0xc4, 0x2f, 0x01, 0xd7, 0xc5, 0x2f, + 0x01, 0xd8, 0xc6, 0x2f, 0x01, 0xd9, 0xc7, 0x2f, 0x41, 0xd0, 0xb6, 0x2f, + 0x01, 0xd1, 0xb7, 0x2f, 0x01, 0xd2, 0xb8, 0x2f, 0x01, 0xd3, 0xb9, 0x2f, + 0x01, 0xd4, 0xba, 0x2f, 0x01, 0xd5, 0xbb, 0x2f, 0x01, 0xd6, 0xbc, 0x2f, + 0x01, 0xd8, 0xbd, 0x2f, 0x01, 0xd9, 0xbe, 0x2f, 0x41, 0xd0, 0xb0, 0x2f, + 0x01, 0xd1, 0xb1, 0x2f, 0x01, 0xd4, 0xb2, 0x2f, 0x01, 0xd6, 0xb3, 0x2f, + 0x01, 0xd7, 0xb4, 0x2f, 0x01, 0xd9, 0xb5, 0x2f, 0x41, 0xd0, 0xa8, 0x2f, + 0x01, 0xd3, 0xa9, 0x2f, 0x01, 0xd4, 0xaa, 0x2f, 0x01, 0xd5, 0xab, 0x2f, + 0x01, 0xd6, 0xac, 0x2f, 0x01, 0xd7, 0xad, 0x2f, 0x01, 0xd8, 0xae, 0x2f, + 0x01, 0xd9, 0xaf, 0x2f, 0x41, 0xd1, 0xa0, 0x2f, 0x01, 0xd3, 0xa1, 0x2f, + 0x01, 0xd4, 0xa2, 0x2f, 0x01, 0xd5, 0xa3, 0x2f, 0x01, 0xd6, 0xa4, 0x2f, + 0x01, 0xd7, 0xa5, 0x2f, 0x01, 0xd8, 0xa6, 0x2f, 0x01, 0xd9, 0xa7, 0x2f, + 0x41, 0xd0, 0x98, 0x2f, 0x01, 0xd1, 0x99, 0x2f, 0x01, 0xd2, 0x9a, 0x2f, + 0x81, 0x10, 0xd3, 0x9c, 0x2f, 0x01, 0xd5, 0x9d, 0x2f, 0x01, 0xd7, 0x9e, + 0x2f, 0x01, 0xd9, 0x9f, 0x2f, 0x41, 0xe2, 0x9b, 0x2f, 0x41, 0xd1, 0x90, + 0x2f, 0x01, 0xd2, 0x91, 0x2f, 0x01, 0xd4, 0x92, 0x2f, 0x01, 0xd5, 0x93, + 0x2f, 0x01, 0xd6, 0x94, 0x2f, 0x01, 0xd7, 0x95, 0x2f, 0x01, 0xd8, 0x96, + 0x2f, 0x01, 0xd9, 0x97, 0x2f, 0x41, 0xe1, 0x00, 0x08, 0x01, 0xe5, 0x01, + 0x08, 0x01, 0xe9, 0x02, 0x08, 0x01, 0xaa, 0xe3, 0x01, 0xab, 0xcc, 0x01, + 0xac, 0xb5, 0x01, 0xad, 0x9e, 0x01, 0xae, 0x87, 0x01, 0xef, 0x03, 0x08, + 0x01, 0xb0, 0x6d, 0xb2, 0x57, 0xb3, 0x41, 0xb4, 0x2b, 0xf5, 0x04, 0x08, + 0x01, 0xb7, 0x15, 0xb8, 0x0b, 0xba, 0x01, 0xff, 0xe1, 0x3c, 0x08, 0x01, + 0xef, 0x3f, 0x08, 0x41, 0xe1, 0x37, 0x08, 0x01, 0xe5, 0x38, 0x08, 0x41, + 0xe1, 0x32, 0x08, 0x01, 0xe5, 0x33, 0x08, 0x01, 0xe9, 0x34, 0x08, 0x01, + 0xef, 0x35, 0x08, 0x41, 0xe1, 0x2d, 0x08, 0x01, 0xe5, 0x2e, 0x08, 0x01, + 0xe9, 0x2f, 0x08, 0x01, 0xef, 0x30, 0x08, 0x01, 0xf5, 0x31, 0x08, 0x41, + 0xe1, 0x28, 0x08, 0x01, 0xe5, 0x29, 0x08, 0x01, 0xe9, 0x2a, 0x08, 0x01, + 0xef, 0x2b, 0x08, 0x01, 0xf5, 0x2c, 0x08, 0x41, 0xe1, 0x23, 0x08, 0x01, + 0xe5, 0x24, 0x08, 0x01, 0xe9, 0x25, 0x08, 0x01, 0xef, 0x26, 0x08, 0x01, + 0xf5, 0x27, 0x08, 0x41, 0xe1, 0x1e, 0x08, 0x01, 0xe5, 0x1f, 0x08, 0x01, + 0xe9, 0x20, 0x08, 0x01, 0xef, 0x21, 0x08, 0x01, 0xf5, 0x22, 0x08, 0x41, + 0xe1, 0x19, 0x08, 0x01, 0xe5, 0x1a, 0x08, 0x01, 0xe9, 0x1b, 0x08, 0x01, + 0xef, 0x1c, 0x08, 0x01, 0xf5, 0x1d, 0x08, 0x41, 0xe1, 0x14, 0x08, 0x01, + 0xe5, 0x15, 0x08, 0x01, 0xe9, 0x16, 0x08, 0x01, 0xef, 0x17, 0x08, 0x01, + 0xf5, 0x18, 0x08, 0x41, 0xe1, 0x0f, 0x08, 0x01, 0xe5, 0x10, 0x08, 0x01, + 0xe9, 0x11, 0x08, 0x01, 0xef, 0x12, 0x08, 0x01, 0xf5, 0x13, 0x08, 0x41, + 0xe1, 0x0a, 0x08, 0x01, 0xe5, 0x0b, 0x08, 0x01, 0xe9, 0x0c, 0x08, 0x01, + 0xef, 0x0d, 0x08, 0x01, 0xf5, 0x0e, 0x08, 0x41, 0xe1, 0x05, 0x08, 0x01, + 0xef, 0x08, 0x08, 0x41, 0x47, 0x1c, 0xbd, 0x1b, 0x22, 0x00, 0x46, 0xae, + 0xe0, 0x52, 0xf9, 0x01, 0x08, 0x47, 0xce, 0x80, 0x01, 0xb0, 0x64, 0xb2, + 0x16, 0x02, 0x60, 0x01, 0x06, 0x49, 0x54, 0xc5, 0x69, 0xf9, 0x41, 0x43, + 0xaa, 0x01, 0x6e, 0xf3, 0x01, 0x43, 0x18, 0x6a, 0xc3, 0xf6, 0x41, 0xac, + 0x1e, 0xb2, 0x06, 0x60, 0x23, 0x11, 0x61, 0x27, 0x40, 0x05, 0x7b, 0x43, + 0x06, 0x4a, 0x6a, 0xb9, 0x5b, 0xf3, 0x41, 0x48, 0xbf, 0xcb, 0xb1, 0xf4, + 0x01, 0x44, 0x5a, 0x03, 0xa4, 0x00, 0x40, 0x49, 0x3b, 0xc0, 0x4c, 0xf9, + 0x01, 0x02, 0x09, 0x00, 0x01, 0xff, 0x51, 0x3a, 0x5b, 0xaa, 0x23, 0x00, + 0x02, 0x13, 0x01, 0x01, 0xff, 0x06, 0x50, 0x23, 0x06, 0x42, 0x1f, 0x00, + 0xb0, 0x27, 0x40, 0x43, 0x1a, 0x00, 0xcf, 0x22, 0x00, 0x42, 0x0c, 0x00, + 0xce, 0x22, 0x40, 0x80, 0x0c, 0x44, 0xfd, 0x2d, 0xc1, 0xf9, 0x01, 0x43, + 0x4c, 0x69, 0xe0, 0x2b, 0x40, 0x4f, 0x79, 0x62, 0xfe, 0x26, 0x00, 0x4a, + 0x38, 0xb9, 0x64, 0xf9, 0x41, 0x0d, 0xf2, 0x8a, 0xfa, 0x37, 0x11, 0x02, + 0x60, 0xd3, 0x37, 0x05, 0x5a, 0x03, 0x01, 0xff, 0xe1, 0x00, 0x20, 0x81, + 0xf8, 0x33, 0xa2, 0xd1, 0x32, 0xa4, 0x9b, 0x2e, 0xe5, 0x8a, 0x20, 0x81, + 0x9f, 0x2b, 0xa7, 0xe1, 0x23, 0xa8, 0xc2, 0x22, 0xe9, 0x3f, 0x21, 0x81, + 0xb3, 0x21, 0xab, 0xad, 0x1c, 0xac, 0x86, 0x13, 0xad, 0xab, 0x11, 0xae, + 0xaa, 0x0d, 0xb0, 0xa0, 0x0c, 0xb2, 0x8c, 0x0c, 0xb3, 0x95, 0x07, 0xb4, + 0xb2, 0x05, 0xf5, 0x0b, 0x23, 0x81, 0x77, 0xba, 0x01, 0xff, 0xe1, 0x5d, + 0x23, 0x81, 0x53, 0x42, 0x92, 0xa0, 0x62, 0x23, 0x01, 0xe9, 0x63, 0x23, + 0x81, 0x29, 0xf5, 0x6a, 0x23, 0xc1, 0x00, 0x51, 0xc4, 0x59, 0x42, 0x25, + 0x01, 0xd5, 0x6b, 0x23, 0x81, 0x0a, 0x43, 0xff, 0x37, 0x6d, 0x23, 0x01, + 0xed, 0x6e, 0x23, 0x41, 0x07, 0x27, 0x02, 0x01, 0xff, 0xe1, 0x6c, 0x23, + 0x01, 0x4f, 0xd4, 0x76, 0x43, 0x25, 0x41, 0x48, 0x07, 0xc8, 0x64, 0x23, + 0x01, 0xd3, 0x65, 0x23, 0x01, 0xe2, 0x66, 0x23, 0x81, 0x0a, 0xe7, 0x68, + 0x23, 0x01, 0x42, 0x6a, 0xf9, 0x69, 0x23, 0x41, 0x4a, 0x28, 0xab, 0x67, + 0x23, 0x41, 0x80, 0x0e, 0xd7, 0x41, 0x25, 0x01, 0xe7, 0x60, 0x23, 0x01, + 0x42, 0xac, 0xfa, 0x61, 0x23, 0x41, 0x51, 0x9b, 0x60, 0x5f, 0x23, 0x01, + 0x44, 0x36, 0x63, 0x5e, 0x23, 0x41, 0x80, 0x8c, 0x04, 0xd2, 0x11, 0x23, + 0x01, 0xe2, 0x12, 0x23, 0x01, 0xe4, 0x13, 0x23, 0x81, 0xbf, 0x03, 0xed, + 0x1d, 0x23, 0x81, 0xfa, 0x02, 0xee, 0x26, 0x23, 0x81, 0xee, 0x02, 0xf2, + 0x28, 0x23, 0x81, 0x46, 0x42, 0xa4, 0x02, 0x51, 0x23, 0x81, 0x18, 0x44, + 0xbc, 0xf8, 0x59, 0x23, 0x01, 0xba, 0x01, 0xff, 0xd3, 0x5a, 0x23, 0x81, + 0x04, 0xf5, 0x5c, 0x23, 0x41, 0x4d, 0x95, 0x83, 0x5b, 0x23, 0x41, 0x07, + 0x27, 0x02, 0x0e, 0xd2, 0x57, 0x23, 0x01, 0x43, 0xab, 0xfa, 0x58, 0x23, + 0x01, 0xf8, 0x56, 0x23, 0x41, 0xe1, 0x52, 0x23, 0x01, 0x42, 0xfe, 0x03, + 0x53, 0x23, 0x81, 0x06, 0x44, 0x47, 0x47, 0x55, 0x23, 0x41, 0xf2, 0x54, + 0x23, 0x41, 0x80, 0x94, 0x02, 0xd2, 0x2b, 0x23, 0x81, 0xc1, 0x01, 0xd4, + 0x34, 0x23, 0x01, 0xe9, 0x35, 0x23, 0x81, 0xb3, 0x01, 0xf5, 0x37, 0x23, + 0xc1, 0x00, 0x07, 0x27, 0x02, 0x0d, 0x42, 0x7b, 0x08, 0x4f, 0x23, 0xc1, + 0x00, 0x48, 0x27, 0x02, 0x50, 0x23, 0x41, 0xe1, 0x38, 0x23, 0x81, 0x91, + 0x01, 0x43, 0x16, 0x00, 0x3a, 0x23, 0x01, 0xa4, 0x7d, 0xa7, 0x64, 0x42, + 0x22, 0x00, 0x41, 0x23, 0x01, 0xa9, 0x4c, 0x42, 0x45, 0x00, 0x45, 0x23, + 0x01, 0xac, 0x33, 0x43, 0x99, 0x14, 0x47, 0x23, 0x01, 0x42, 0xe0, 0x09, + 0x48, 0x23, 0x01, 0xb3, 0x19, 0x42, 0x5c, 0x01, 0x4b, 0x23, 0x01, 0xb5, + 0x01, 0xff, 0x49, 0x1d, 0xba, 0x4c, 0x23, 0x01, 0xe4, 0x4d, 0x23, 0x01, + 0x44, 0xb6, 0xd1, 0x4e, 0x23, 0x41, 0x42, 0xb0, 0x01, 0x49, 0x23, 0x01, + 0x43, 0xc7, 0x6c, 0x4a, 0x23, 0x41, 0x46, 0x94, 0xdf, 0x3f, 0x25, 0x01, + 0xb5, 0x01, 0xff, 0xd3, 0x40, 0x25, 0x01, 0xed, 0x46, 0x23, 0x41, 0x42, + 0xf1, 0x06, 0x42, 0x23, 0x01, 0xed, 0x43, 0x23, 0x01, 0x42, 0xa4, 0x02, + 0x44, 0x23, 0x41, 0xe1, 0x3c, 0x23, 0x81, 0x04, 0xf5, 0x40, 0x23, 0x41, + 0xec, 0x3d, 0x23, 0x01, 0x47, 0x43, 0x63, 0x3e, 0x23, 0x01, 0xf2, 0x3f, + 0x23, 0x41, 0x44, 0xf4, 0xf4, 0x3e, 0x25, 0x01, 0x42, 0x79, 0x08, 0x3b, + 0x23, 0x41, 0x45, 0xdd, 0xdf, 0x39, 0x23, 0x41, 0xd3, 0x36, 0x23, 0x41, + 0x80, 0x01, 0xff, 0x48, 0x9a, 0x24, 0x3c, 0x25, 0x01, 0x06, 0x28, 0x02, + 0x01, 0xff, 0xa1, 0x29, 0x42, 0x22, 0x00, 0x2f, 0x23, 0x01, 0x43, 0x18, + 0x24, 0x30, 0x23, 0x01, 0xb5, 0x01, 0xff, 0xd2, 0x31, 0x23, 0x81, 0x04, + 0xe4, 0x3d, 0x25, 0x41, 0x06, 0xc5, 0x29, 0x01, 0xff, 0x43, 0xf9, 0x03, + 0x32, 0x23, 0x01, 0x42, 0xe5, 0x05, 0x33, 0x23, 0x41, 0x06, 0xc5, 0x29, + 0x04, 0xec, 0x2e, 0x23, 0x41, 0x42, 0x22, 0x00, 0x2c, 0x23, 0x01, 0x42, + 0x2a, 0x05, 0x2d, 0x23, 0x41, 0x4b, 0xab, 0x9f, 0x29, 0x23, 0x01, 0x47, + 0xf6, 0x7f, 0x2a, 0x23, 0x41, 0x45, 0xde, 0x41, 0x27, 0x23, 0x41, 0x07, + 0x27, 0x02, 0x1e, 0x43, 0x03, 0x17, 0x22, 0x23, 0x01, 0x42, 0x48, 0x04, + 0x23, 0x23, 0xc1, 0x00, 0x07, 0x27, 0x02, 0x01, 0xff, 0x46, 0x1b, 0x02, + 0x24, 0x23, 0x01, 0x42, 0xe0, 0x09, 0x25, 0x23, 0x41, 0x45, 0x22, 0x02, + 0x1e, 0x23, 0x01, 0x42, 0x2a, 0x02, 0x98, 0x23, 0x81, 0x0a, 0x44, 0xdb, + 0x59, 0x20, 0x23, 0x01, 0xf5, 0x21, 0x23, 0x41, 0x48, 0x55, 0x5a, 0x1f, + 0x23, 0x41, 0x80, 0x06, 0x42, 0x81, 0x0f, 0x1c, 0x23, 0x41, 0x44, 0xdf, + 0x41, 0x19, 0x23, 0x01, 0x46, 0x72, 0xe3, 0x14, 0x23, 0x01, 0x47, 0xf6, + 0x7f, 0x1a, 0x23, 0x81, 0x1e, 0x06, 0x28, 0x02, 0x01, 0xff, 0x43, 0x1c, + 0x74, 0x15, 0x23, 0x01, 0x42, 0x7d, 0x02, 0x16, 0x23, 0x01, 0x4f, 0x4c, + 0x77, 0x17, 0x23, 0xc1, 0x00, 0x45, 0xde, 0x41, 0x18, 0x23, 0x41, 0x4a, + 0x61, 0xa2, 0x1b, 0x23, 0x41, 0x43, 0xb9, 0x7e, 0x0c, 0x23, 0x01, 0x07, + 0x82, 0x23, 0x0b, 0xf5, 0x99, 0x23, 0xc1, 0x00, 0x42, 0x2d, 0x02, 0x0d, + 0x23, 0x41, 0x57, 0xf0, 0x31, 0x0e, 0x23, 0x01, 0x4c, 0x7c, 0x9a, 0x0f, + 0x23, 0x01, 0x5a, 0x77, 0x23, 0x10, 0x23, 0x41, 0xe1, 0xeb, 0x22, 0x81, + 0x69, 0xe5, 0xfc, 0x22, 0x81, 0x5e, 0xe9, 0xfe, 0x22, 0x81, 0x30, 0xf5, + 0x05, 0x23, 0xc1, 0x00, 0x42, 0x82, 0x0f, 0x06, 0x23, 0x01, 0xeb, 0x07, + 0x23, 0x01, 0xed, 0x08, 0x23, 0x81, 0x0b, 0xf2, 0x09, 0x23, 0xc1, 0x00, + 0x54, 0xe7, 0x41, 0x0a, 0x23, 0x41, 0x07, 0x27, 0x02, 0x01, 0xff, 0x49, + 0x41, 0x63, 0x3a, 0x25, 0x01, 0x4a, 0xd4, 0x76, 0x3b, 0x25, 0x41, 0x45, + 0x35, 0x63, 0xff, 0x22, 0x01, 0xd2, 0x97, 0x23, 0x01, 0xec, 0x00, 0x23, + 0x01, 0xf2, 0x01, 0x23, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x48, 0x5f, 0xcf, + 0x03, 0x23, 0x81, 0x06, 0x4a, 0x41, 0x47, 0x02, 0x23, 0x41, 0x5a, 0x9b, + 0x1f, 0x04, 0x23, 0x41, 0x45, 0xde, 0x41, 0xfd, 0x22, 0x41, 0x80, 0x53, + 0xe2, 0xf0, 0x22, 0x81, 0x3f, 0xe7, 0xf3, 0x22, 0x81, 0x11, 0x42, 0x49, + 0x47, 0xfa, 0x22, 0x81, 0x04, 0xf2, 0xfb, 0x22, 0x41, 0x49, 0x38, 0xba, + 0x39, 0x25, 0x41, 0x07, 0x27, 0x02, 0x01, 0xff, 0x42, 0xe5, 0x05, 0xf4, + 0x22, 0x01, 0x43, 0xb9, 0x7e, 0xf5, 0x22, 0x01, 0x02, 0xa4, 0x02, 0x0c, + 0x44, 0x80, 0x0f, 0xf8, 0x22, 0x01, 0x42, 0x40, 0x0d, 0xf9, 0x22, 0x41, + 0xe5, 0xf6, 0x22, 0x01, 0xf5, 0xf7, 0x22, 0x41, 0x80, 0x01, 0xff, 0x62, + 0x4a, 0x0d, 0xf1, 0x22, 0x01, 0x47, 0xfd, 0x05, 0xf2, 0x22, 0x41, 0x48, + 0xca, 0x0d, 0xec, 0x22, 0x01, 0x44, 0xdf, 0x41, 0xef, 0x22, 0x01, 0x06, + 0x28, 0x02, 0x01, 0xff, 0x42, 0x49, 0x00, 0xed, 0x22, 0x01, 0x42, 0x7d, + 0x02, 0xee, 0x22, 0x41, 0xe1, 0x93, 0x22, 0x81, 0xb3, 0x03, 0xa8, 0x5d, + 0xe9, 0xdb, 0x22, 0x81, 0x2e, 0xf5, 0xe2, 0x22, 0xc1, 0x00, 0x48, 0x7f, + 0x9a, 0xe3, 0x22, 0x01, 0xe4, 0xe4, 0x22, 0x81, 0x1a, 0x43, 0x41, 0x00, + 0xe6, 0x22, 0x01, 0xed, 0xe7, 0x22, 0x81, 0x09, 0xf2, 0xe9, 0x22, 0xc1, + 0x00, 0xd9, 0xea, 0x22, 0x41, 0x43, 0xf9, 0x03, 0xe8, 0x22, 0x41, 0xd2, + 0xe5, 0x22, 0x41, 0x80, 0x1c, 0xe7, 0xdd, 0x22, 0x81, 0x0c, 0x42, 0xc2, + 0xb1, 0xe0, 0x22, 0x01, 0x43, 0xe5, 0xf0, 0xe1, 0x22, 0x41, 0xd4, 0xde, + 0x22, 0xc1, 0x00, 0x4f, 0xc0, 0x6c, 0xdf, 0x22, 0x41, 0x44, 0xdf, 0x41, + 0xdc, 0x22, 0x01, 0x4a, 0x41, 0x47, 0x38, 0x25, 0x41, 0xe1, 0xad, 0x22, + 0x81, 0x80, 0x02, 0xe5, 0xba, 0x22, 0x81, 0xaa, 0x01, 0xa9, 0x27, 0xf5, + 0xd7, 0x22, 0xc1, 0x00, 0x52, 0xb3, 0x51, 0xd8, 0x22, 0x01, 0xd2, 0xd9, + 0x22, 0x81, 0x06, 0x43, 0xff, 0x37, 0xda, 0x22, 0x41, 0x06, 0xc5, 0x29, + 0x01, 0xff, 0x4c, 0x08, 0x93, 0x36, 0x25, 0x01, 0x4b, 0x92, 0xa0, 0x37, + 0x25, 0x41, 0xe4, 0xc3, 0x22, 0x81, 0x6d, 0xed, 0xc6, 0x22, 0x81, 0x20, + 0x43, 0x73, 0x09, 0xd2, 0x22, 0x01, 0xf2, 0xd3, 0x22, 0x81, 0x06, 0x42, + 0x12, 0x00, 0xd6, 0x22, 0x41, 0x80, 0x01, 0xff, 0x56, 0x0b, 0x38, 0xd5, + 0x22, 0x01, 0x44, 0x36, 0x63, 0xd4, 0x22, 0x41, 0x07, 0x27, 0x02, 0x01, + 0xff, 0xe1, 0xc7, 0x22, 0x01, 0xa2, 0x31, 0x43, 0x89, 0x08, 0xca, 0x22, + 0x01, 0x43, 0xa9, 0x1f, 0xcb, 0x22, 0x01, 0x43, 0xf0, 0x06, 0xcc, 0x22, + 0x81, 0x18, 0x46, 0x72, 0xe3, 0xce, 0x22, 0x01, 0x43, 0x6c, 0xfa, 0xcf, + 0x22, 0x01, 0x43, 0x23, 0xbc, 0xd0, 0x22, 0x01, 0x43, 0xf3, 0x0d, 0xd1, + 0x22, 0x41, 0x45, 0xde, 0x41, 0xcd, 0x22, 0x41, 0x42, 0x13, 0x00, 0xc8, + 0x22, 0x01, 0x44, 0xa5, 0x9c, 0xc9, 0x22, 0x41, 0x07, 0x27, 0x02, 0x01, + 0xff, 0xe1, 0xc4, 0x22, 0x01, 0x42, 0x29, 0x02, 0xc5, 0x22, 0x41, 0x80, + 0x1b, 0x42, 0x17, 0xfb, 0xbe, 0x22, 0x01, 0xee, 0xbf, 0x22, 0x01, 0x42, + 0xa4, 0x02, 0xc0, 0x22, 0xc1, 0x00, 0xd2, 0xc1, 0x22, 0x01, 0x43, 0xb0, + 0x00, 0xc2, 0x22, 0x41, 0x42, 0x41, 0x00, 0xbb, 0x22, 0x01, 0x48, 0x57, + 0xcf, 0x32, 0x25, 0x81, 0x17, 0x05, 0xc6, 0x29, 0x01, 0xff, 0x44, 0x40, + 0xf6, 0x33, 0x25, 0x01, 0x44, 0x4c, 0xf7, 0x34, 0x25, 0x01, 0x43, 0x49, + 0x4e, 0x35, 0x25, 0x41, 0x80, 0x01, 0xff, 0x59, 0x9c, 0x1f, 0xbc, 0x22, + 0x01, 0x59, 0xe1, 0x27, 0xbd, 0x22, 0x41, 0xd3, 0xae, 0x22, 0x81, 0x17, + 0xd6, 0xb7, 0x22, 0x81, 0x0c, 0x42, 0xc2, 0xf9, 0xb8, 0x22, 0x01, 0x42, + 0xe1, 0x44, 0xb9, 0x22, 0x41, 0x45, 0x35, 0x63, 0x31, 0x25, 0x41, 0x07, + 0x27, 0x02, 0x01, 0xff, 0xe1, 0xaf, 0x22, 0x01, 0x43, 0x1c, 0x74, 0xb0, + 0x22, 0x01, 0x44, 0x3c, 0x47, 0xb1, 0x22, 0x01, 0x42, 0xf1, 0x05, 0xb2, + 0x22, 0x01, 0x44, 0x1a, 0x6a, 0xb3, 0x22, 0x01, 0x43, 0x5c, 0x01, 0xb4, + 0x22, 0x01, 0xf5, 0xb5, 0x22, 0xc1, 0x00, 0x47, 0xc5, 0x29, 0xb6, 0x22, + 0x41, 0xe7, 0x95, 0x22, 0x81, 0x15, 0xec, 0xa9, 0x22, 0x81, 0x0a, 0x44, + 0x6c, 0xf7, 0xab, 0x22, 0x01, 0xf2, 0xac, 0x22, 0x41, 0x51, 0xa2, 0x59, + 0xaa, 0x22, 0x41, 0x80, 0x01, 0xff, 0x44, 0xdf, 0x41, 0xa8, 0x22, 0x81, + 0x90, 0x01, 0x47, 0xe0, 0xc7, 0x94, 0x22, 0x01, 0x48, 0x4f, 0xcf, 0xa7, + 0x22, 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, 0xe1, 0x96, 0x22, 0x01, 0x42, + 0x6c, 0x02, 0x97, 0x22, 0x81, 0x70, 0x42, 0x92, 0x01, 0x2e, 0x25, 0x01, + 0x42, 0x22, 0x00, 0x99, 0x22, 0x01, 0x48, 0x12, 0x6d, 0x96, 0x23, 0x01, + 0xab, 0x50, 0x43, 0x11, 0xba, 0x9c, 0x22, 0x01, 0x42, 0x7d, 0x02, 0x9d, + 0x22, 0x01, 0x43, 0x18, 0x24, 0x9e, 0x22, 0x01, 0xb3, 0x27, 0x02, 0x12, + 0x00, 0x19, 0xb5, 0x01, 0xff, 0xd2, 0xa2, 0x22, 0x01, 0xe2, 0xa3, 0x22, + 0x01, 0xed, 0xa4, 0x22, 0x01, 0xf2, 0xa5, 0x22, 0x01, 0x42, 0xa4, 0x02, + 0xa6, 0x22, 0x41, 0xe2, 0xa1, 0x22, 0x01, 0x42, 0x49, 0x47, 0x30, 0x25, + 0x41, 0x42, 0x13, 0x00, 0x9f, 0x22, 0x01, 0xa8, 0x01, 0xff, 0x49, 0x8f, + 0xbd, 0x2f, 0x25, 0x01, 0x42, 0x03, 0x00, 0xa0, 0x22, 0x41, 0x42, 0x6d, + 0x00, 0x9a, 0x22, 0x01, 0x42, 0x42, 0x00, 0x9b, 0x22, 0x41, 0xe2, 0x98, + 0x22, 0x41, 0x49, 0x77, 0xba, 0x2d, 0x25, 0x41, 0xe1, 0x8f, 0x22, 0x81, + 0x08, 0xe9, 0x91, 0x22, 0x01, 0xf5, 0x92, 0x22, 0x41, 0xe2, 0x90, 0x22, + 0x41, 0xe1, 0x7a, 0x22, 0x81, 0x76, 0x44, 0x9e, 0x78, 0x7e, 0x22, 0x81, + 0x69, 0xe9, 0x7f, 0x22, 0xc1, 0x00, 0x80, 0x2e, 0xb2, 0x01, 0xff, 0xd2, + 0x95, 0x23, 0x01, 0x42, 0x3f, 0x00, 0x8a, 0x22, 0xc1, 0x00, 0x80, 0x01, + 0xff, 0x4e, 0x44, 0x7e, 0x8e, 0x22, 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, + 0x43, 0x1e, 0x02, 0x8b, 0x22, 0x01, 0x42, 0x40, 0x0d, 0x8c, 0x22, 0x01, + 0x42, 0x59, 0x00, 0x8d, 0x22, 0x41, 0x4b, 0xa0, 0x9f, 0x89, 0x22, 0x01, + 0x06, 0x28, 0x02, 0x01, 0xff, 0xe1, 0x80, 0x22, 0x81, 0x20, 0xa2, 0x16, + 0xe5, 0x84, 0x22, 0x01, 0xe9, 0x85, 0x22, 0x81, 0x09, 0xf5, 0x87, 0x22, + 0xc1, 0x00, 0xd2, 0x88, 0x22, 0x41, 0xe2, 0x86, 0x22, 0x41, 0xe9, 0x82, + 0x22, 0x01, 0xf5, 0x83, 0x22, 0x41, 0xe2, 0x81, 0x22, 0x41, 0x49, 0xc9, + 0x0d, 0x94, 0x23, 0x41, 0xe4, 0x7b, 0x22, 0x01, 0xee, 0x7c, 0x22, 0x01, + 0xf0, 0x7d, 0x22, 0x41, 0xe1, 0x3e, 0x22, 0x81, 0xc2, 0x03, 0xe5, 0x48, + 0x22, 0x81, 0xa4, 0x03, 0xe9, 0x4c, 0x22, 0x81, 0xbc, 0x01, 0xf5, 0x61, + 0x22, 0xc1, 0x00, 0x42, 0xfc, 0x37, 0x62, 0x22, 0x81, 0x9a, 0x01, 0xee, + 0x63, 0x22, 0xc1, 0x00, 0x80, 0x57, 0x42, 0x08, 0x55, 0x6d, 0x22, 0xc1, + 0x00, 0x80, 0x01, 0xff, 0x0a, 0x90, 0xac, 0x0d, 0x4f, 0x42, 0x72, 0x78, + 0x22, 0xc1, 0x00, 0x42, 0x2d, 0x02, 0x79, 0x22, 0x41, 0x46, 0xdc, 0xdf, + 0x6e, 0x22, 0x01, 0x42, 0xe5, 0x05, 0x6f, 0x22, 0x01, 0x43, 0x08, 0x93, + 0x70, 0x22, 0x01, 0x43, 0xb9, 0x7e, 0x71, 0x22, 0x01, 0x48, 0x12, 0x6d, + 0x72, 0x22, 0x01, 0x44, 0xa4, 0xf6, 0x73, 0x22, 0x01, 0x42, 0x74, 0x00, + 0x74, 0x22, 0x01, 0x42, 0xf1, 0x05, 0x75, 0x22, 0x01, 0x45, 0xe3, 0xf0, + 0x76, 0x22, 0x01, 0x42, 0x1c, 0x6a, 0x77, 0x22, 0x41, 0x4c, 0x6c, 0x92, + 0x6b, 0x22, 0x81, 0x2f, 0x0c, 0x1c, 0x24, 0x0c, 0x48, 0x13, 0x24, 0x6a, + 0x22, 0x01, 0x44, 0x36, 0x63, 0x69, 0x22, 0x41, 0x43, 0xa9, 0x1f, 0x64, + 0x22, 0x01, 0x44, 0x8c, 0x06, 0x65, 0x22, 0x01, 0x43, 0xf3, 0x0d, 0x66, + 0x22, 0x81, 0x06, 0x43, 0x0b, 0x80, 0x68, 0x22, 0x41, 0x59, 0x12, 0x24, + 0x67, 0x22, 0x41, 0x51, 0xb3, 0x59, 0x6c, 0x22, 0x41, 0x80, 0x01, 0xff, + 0x56, 0xf5, 0x37, 0xd5, 0x22, 0x01, 0x56, 0x2b, 0x2e, 0x93, 0x23, 0x01, + 0x44, 0x36, 0x63, 0xd4, 0x22, 0x41, 0x48, 0xeb, 0x9c, 0x4d, 0x22, 0x01, + 0xd2, 0x4e, 0x22, 0x01, 0xed, 0x4f, 0x22, 0x81, 0xc1, 0x01, 0xee, 0x8f, + 0x23, 0x81, 0x06, 0x43, 0x70, 0x8d, 0x60, 0x22, 0x41, 0xd9, 0x90, 0x23, + 0x01, 0x43, 0x30, 0x4b, 0x52, 0x22, 0xc1, 0x00, 0x07, 0x27, 0x02, 0x01, + 0xff, 0xa1, 0x92, 0x01, 0x43, 0xef, 0x1d, 0x91, 0x23, 0x01, 0x48, 0xcf, + 0xca, 0x22, 0x25, 0x01, 0xa7, 0x6e, 0x42, 0x49, 0x00, 0x25, 0x25, 0x01, + 0x45, 0xc8, 0xed, 0x26, 0x25, 0x01, 0x47, 0x80, 0xd8, 0x27, 0x25, 0x01, + 0xad, 0x4e, 0xae, 0x42, 0x4c, 0x9f, 0x3f, 0x29, 0x25, 0x01, 0x43, 0x8e, + 0x06, 0x5a, 0x22, 0x81, 0x1d, 0xf5, 0x2a, 0x25, 0xc1, 0x00, 0x47, 0x4d, + 0x77, 0x2b, 0x25, 0x01, 0x4a, 0x36, 0xac, 0x5e, 0x22, 0x01, 0x44, 0xb6, + 0xd1, 0x2c, 0x25, 0x01, 0x42, 0xa4, 0x02, 0x5f, 0x22, 0x41, 0x07, 0xc5, + 0x29, 0x01, 0xff, 0x43, 0x19, 0x00, 0x5b, 0x22, 0x01, 0x42, 0xa4, 0x02, + 0x5c, 0x22, 0xc1, 0x00, 0x49, 0x75, 0x4f, 0x5d, 0x22, 0x41, 0xe5, 0x58, + 0x22, 0x01, 0x42, 0x79, 0x08, 0x59, 0x22, 0x41, 0x43, 0xf9, 0x03, 0x28, + 0x25, 0x01, 0x50, 0x5a, 0x65, 0x57, 0x22, 0x41, 0xe9, 0x92, 0x23, 0x81, + 0x0b, 0xb5, 0x01, 0xff, 0xe4, 0x56, 0x22, 0x01, 0xec, 0x24, 0x25, 0x41, + 0x42, 0xa4, 0x02, 0x23, 0x25, 0x41, 0xee, 0x53, 0x22, 0x01, 0x42, 0xa4, + 0x02, 0x54, 0x22, 0xc1, 0x00, 0x49, 0x75, 0x4f, 0x55, 0x22, 0x41, 0x09, + 0xe3, 0x44, 0x01, 0xff, 0x47, 0x43, 0x63, 0x50, 0x22, 0x01, 0x50, 0x3a, + 0x69, 0x51, 0x22, 0x41, 0x80, 0x01, 0xff, 0x47, 0xf6, 0x7f, 0x4b, 0x22, + 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, 0xe1, 0x49, 0x22, 0x01, 0x42, 0x40, + 0x0d, 0x4a, 0x22, 0x41, 0xd2, 0x3f, 0x22, 0x01, 0xd4, 0x8e, 0x23, 0x01, + 0x42, 0x24, 0x02, 0x40, 0x22, 0x81, 0x0f, 0xed, 0x46, 0x22, 0xc1, 0x00, + 0x48, 0xdf, 0xc7, 0x45, 0x22, 0x01, 0xd2, 0x47, 0x22, 0x41, 0x80, 0x04, + 0xf2, 0x44, 0x22, 0x41, 0x48, 0x9a, 0x24, 0x41, 0x22, 0x01, 0x4d, 0x81, + 0x8b, 0x43, 0x22, 0x01, 0x4e, 0x00, 0x81, 0x42, 0x22, 0x41, 0xe1, 0x20, + 0x22, 0x81, 0xad, 0x01, 0xe5, 0x28, 0x22, 0x81, 0x9e, 0x01, 0xe9, 0x2a, + 0x22, 0x81, 0x8e, 0x01, 0xf5, 0x2c, 0x22, 0xc1, 0x00, 0x48, 0xff, 0xc7, + 0x2d, 0x22, 0x01, 0xe7, 0x2e, 0x22, 0x81, 0x78, 0x44, 0x8c, 0xf7, 0x30, + 0x22, 0x01, 0x44, 0x40, 0xf8, 0x31, 0x22, 0x01, 0x42, 0xa4, 0x02, 0x32, + 0x22, 0xc1, 0x00, 0x80, 0x2a, 0xd3, 0x39, 0x22, 0xc1, 0x00, 0x80, 0x01, + 0xff, 0x44, 0xdf, 0x41, 0x3d, 0x22, 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, + 0xe1, 0x3a, 0x22, 0x81, 0x0c, 0x42, 0x00, 0x00, 0x3c, 0x22, 0x01, 0x42, + 0x59, 0x00, 0x8d, 0x23, 0x41, 0x48, 0x0f, 0xc8, 0x3b, 0x22, 0x41, 0x4d, + 0xde, 0x85, 0x38, 0x22, 0x01, 0x49, 0x80, 0xc3, 0x36, 0x22, 0x81, 0x15, + 0x06, 0x28, 0x02, 0x01, 0xff, 0xe1, 0x33, 0x22, 0x01, 0x43, 0xa9, 0x60, + 0x34, 0x22, 0x01, 0x42, 0x59, 0x00, 0x35, 0x22, 0x41, 0x07, 0x27, 0x02, + 0x01, 0xff, 0x49, 0x07, 0xbb, 0x37, 0x22, 0x01, 0x42, 0x24, 0x02, 0x20, + 0x25, 0x01, 0x43, 0x10, 0x63, 0x21, 0x25, 0x41, 0x45, 0xde, 0x41, 0x2f, + 0x22, 0x41, 0x49, 0x4a, 0xba, 0x1f, 0x25, 0x01, 0xee, 0x2b, 0x22, 0x41, + 0xf3, 0x29, 0x22, 0xc1, 0x00, 0xe8, 0x8c, 0x23, 0x41, 0x80, 0x17, 0xd2, + 0x23, 0x22, 0x01, 0xe8, 0x24, 0x22, 0x01, 0xf2, 0x25, 0x22, 0x01, 0x42, + 0xa4, 0x02, 0x26, 0x22, 0xc1, 0x00, 0xd2, 0x27, 0x22, 0x41, 0x44, 0xdf, + 0x41, 0x22, 0x22, 0x01, 0x4a, 0x41, 0x47, 0x21, 0x22, 0x41, 0xe1, 0xb7, + 0x21, 0x81, 0xca, 0x02, 0xe9, 0xf7, 0x21, 0x81, 0xb4, 0x02, 0xf5, 0xfb, + 0x21, 0xc1, 0x00, 0x4a, 0x61, 0xa2, 0xfc, 0x21, 0x01, 0xd2, 0xfd, 0x21, + 0x81, 0x3c, 0xd3, 0x16, 0x22, 0x01, 0x43, 0xea, 0x44, 0x17, 0x22, 0x81, + 0x1a, 0xe8, 0x1b, 0x22, 0x01, 0xec, 0x1c, 0x22, 0x01, 0xed, 0x1d, 0x22, + 0xc1, 0x00, 0x49, 0x0b, 0xba, 0x1e, 0x22, 0xc1, 0x00, 0x4d, 0xa8, 0x1f, + 0x1f, 0x22, 0x41, 0x80, 0x01, 0xff, 0xaf, 0x06, 0x47, 0xf6, 0x7f, 0x1a, + 0x22, 0x41, 0x4d, 0xf6, 0x8b, 0x19, 0x22, 0x01, 0x49, 0xb3, 0xc6, 0x18, + 0x22, 0x41, 0x80, 0x01, 0xff, 0x4c, 0x60, 0x92, 0x12, 0x22, 0x01, 0x4e, + 0xb2, 0x7b, 0x19, 0x25, 0x01, 0x4c, 0x48, 0x98, 0x13, 0x22, 0x01, 0xb3, + 0xbd, 0x01, 0xb4, 0x01, 0xff, 0x43, 0x37, 0x63, 0x11, 0x22, 0x01, 0x05, + 0x29, 0x02, 0x01, 0xff, 0x42, 0x13, 0x00, 0xfe, 0x21, 0x01, 0x43, 0x1c, + 0x74, 0xff, 0x21, 0x01, 0x44, 0x5e, 0x0d, 0x1a, 0x25, 0x01, 0x44, 0x9e, + 0x78, 0x00, 0x22, 0x81, 0x86, 0x01, 0x49, 0x41, 0x63, 0x02, 0x22, 0x01, + 0xa8, 0x72, 0x42, 0x29, 0x02, 0x04, 0x22, 0x01, 0xab, 0x53, 0x02, 0x74, + 0x00, 0x43, 0x4a, 0x48, 0xb3, 0x0b, 0x22, 0x01, 0xae, 0x33, 0x43, 0x9e, + 0x0f, 0x1c, 0x25, 0x81, 0x26, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x43, 0x48, + 0x47, 0x1e, 0x25, 0x01, 0x43, 0x81, 0x0f, 0x10, 0x22, 0x41, 0x42, 0x41, + 0x00, 0x8b, 0x23, 0x01, 0xa9, 0x01, 0xff, 0x49, 0x75, 0x4f, 0x0e, 0x22, + 0x01, 0x4a, 0xc2, 0xb1, 0x0f, 0x22, 0x41, 0x52, 0xa2, 0x3f, 0x1d, 0x25, + 0x41, 0xe5, 0x0c, 0x22, 0x01, 0xf5, 0x0d, 0x22, 0x41, 0x49, 0x75, 0x4f, + 0x09, 0x22, 0x01, 0x43, 0x24, 0x02, 0x0a, 0x22, 0x41, 0x02, 0xe8, 0x01, + 0x04, 0xe9, 0x08, 0x22, 0x41, 0xd2, 0x05, 0x22, 0x01, 0xd3, 0x06, 0x22, + 0xc1, 0x00, 0x49, 0x75, 0x4f, 0x07, 0x22, 0x41, 0x42, 0x13, 0x00, 0x1b, + 0x25, 0x01, 0x4b, 0x60, 0xa2, 0x03, 0x22, 0x41, 0x80, 0x01, 0xff, 0x48, + 0x30, 0xba, 0x8a, 0x23, 0x01, 0x44, 0x36, 0x63, 0x01, 0x22, 0x41, 0x46, + 0xf7, 0x7f, 0x15, 0x22, 0x81, 0x06, 0x46, 0xfe, 0x05, 0x14, 0x22, 0x41, + 0x4a, 0x61, 0xa2, 0x89, 0x23, 0x41, 0xec, 0xf8, 0x21, 0x01, 0x44, 0x2c, + 0xf7, 0xf9, 0x21, 0x01, 0x42, 0xa4, 0x02, 0xfa, 0x21, 0x41, 0x02, 0x24, + 0x02, 0xd0, 0x03, 0x44, 0x3c, 0xf6, 0xf1, 0x21, 0x01, 0x02, 0x64, 0x11, + 0x1d, 0xec, 0xf2, 0x21, 0x81, 0x12, 0xed, 0xf4, 0x21, 0xc1, 0x00, 0x4a, + 0xa2, 0x60, 0xf5, 0x21, 0xc1, 0x00, 0x48, 0x1f, 0xc8, 0xf6, 0x21, 0x41, + 0x4a, 0x53, 0xa3, 0xf3, 0x21, 0x41, 0x90, 0xe8, 0x02, 0x91, 0xd9, 0x02, + 0x92, 0xad, 0x02, 0x93, 0x8c, 0x02, 0x94, 0xae, 0x01, 0x43, 0xbb, 0xf9, + 0xff, 0x24, 0x01, 0x96, 0x0f, 0x97, 0x01, 0xff, 0x42, 0xda, 0xba, 0x17, + 0x25, 0x01, 0x42, 0xfd, 0xfa, 0x18, 0x25, 0x41, 0x42, 0x0f, 0x79, 0x00, + 0x25, 0x01, 0x42, 0xe9, 0xfa, 0x01, 0x25, 0x81, 0x4a, 0x42, 0xf1, 0xfa, + 0x0c, 0x25, 0x01, 0x42, 0xfb, 0xfa, 0x0d, 0x25, 0xc1, 0x00, 0x07, 0x27, + 0x02, 0x01, 0xff, 0x43, 0x24, 0xfa, 0x0e, 0x25, 0x01, 0x42, 0x24, 0x02, + 0x0f, 0x25, 0x01, 0x43, 0xf0, 0x06, 0x10, 0x25, 0x81, 0x1f, 0x42, 0x51, + 0x03, 0x12, 0x25, 0x01, 0x55, 0x9f, 0x3f, 0x13, 0x25, 0x01, 0x4d, 0x07, + 0x8d, 0x14, 0x25, 0x01, 0xb5, 0x01, 0xff, 0xe4, 0x15, 0x25, 0x01, 0x44, + 0xb6, 0xd1, 0x16, 0x25, 0x41, 0x45, 0xde, 0x41, 0x11, 0x25, 0x41, 0x07, + 0x27, 0x02, 0x01, 0xff, 0x43, 0xf9, 0x03, 0x02, 0x25, 0x01, 0x43, 0x1c, + 0x74, 0x03, 0x25, 0x01, 0x4e, 0xa8, 0x7a, 0x04, 0x25, 0x01, 0x43, 0x2c, + 0xba, 0x05, 0x25, 0x01, 0x42, 0x74, 0x00, 0x06, 0x25, 0x01, 0xb4, 0x11, + 0xb5, 0x01, 0xff, 0xd2, 0x09, 0x25, 0x01, 0xe4, 0x0a, 0x25, 0x01, 0x44, + 0xb6, 0xd1, 0x0b, 0x25, 0x41, 0x42, 0x17, 0x00, 0x07, 0x25, 0x01, 0xe5, + 0x08, 0x25, 0x41, 0x94, 0x29, 0x95, 0x1f, 0x42, 0x19, 0xfa, 0xf9, 0x24, + 0x01, 0x42, 0xf4, 0xfa, 0xfa, 0x24, 0x01, 0x99, 0x01, 0xff, 0xd0, 0xfb, + 0x24, 0x01, 0xd2, 0xfc, 0x24, 0x01, 0xd3, 0xfd, 0x24, 0x01, 0xd5, 0xfe, + 0x24, 0x41, 0xd0, 0xf7, 0x24, 0x01, 0xd7, 0xf8, 0x24, 0x41, 0xd1, 0xf0, + 0x24, 0x01, 0xd9, 0xf1, 0x24, 0xc1, 0x00, 0x07, 0x27, 0x02, 0x01, 0xff, + 0x42, 0x1e, 0x01, 0xf2, 0x24, 0x01, 0x43, 0xf0, 0x06, 0xf3, 0x24, 0x01, + 0x09, 0x9f, 0x3f, 0x06, 0x4a, 0x0c, 0xb8, 0xf6, 0x24, 0x41, 0x43, 0xb1, + 0x3f, 0xf4, 0x24, 0x01, 0x4c, 0xa8, 0x3f, 0xf5, 0x24, 0x41, 0x94, 0x10, + 0x98, 0x06, 0x42, 0x09, 0xfb, 0xef, 0x24, 0x41, 0xd3, 0xed, 0x24, 0x01, + 0xd4, 0xee, 0x24, 0x41, 0xd3, 0xea, 0x24, 0x01, 0xd7, 0xeb, 0x24, 0x01, + 0xd8, 0xec, 0x24, 0x41, 0x91, 0x1f, 0x92, 0x11, 0x42, 0xf3, 0xfa, 0xe7, + 0x24, 0x01, 0x96, 0x01, 0xff, 0xd5, 0xe8, 0x24, 0x01, 0xd6, 0xe9, 0x24, + 0x41, 0xd0, 0xe4, 0x24, 0x01, 0xd5, 0xe5, 0x24, 0x01, 0xd8, 0xe6, 0x24, + 0x41, 0xd0, 0xe2, 0x24, 0x01, 0xd9, 0xe3, 0x24, 0x41, 0x42, 0xa9, 0xf9, + 0xe0, 0x24, 0x01, 0x42, 0x16, 0xfa, 0xe1, 0x24, 0x41, 0x42, 0xa8, 0xf9, + 0xd5, 0x24, 0x01, 0x92, 0x2e, 0x42, 0xa9, 0xf9, 0xd8, 0x24, 0x01, 0x95, + 0x1e, 0x42, 0xc7, 0xf9, 0xdb, 0x24, 0x01, 0x54, 0x37, 0x42, 0xdc, 0x24, + 0x01, 0x98, 0x06, 0x42, 0x0b, 0xfb, 0xdf, 0x24, 0x41, 0xd0, 0xdd, 0x24, + 0x01, 0x4e, 0x04, 0x79, 0xde, 0x24, 0x41, 0xd0, 0xd9, 0x24, 0x01, 0xd1, + 0xda, 0x24, 0x41, 0xd1, 0xd6, 0x24, 0x01, 0xd5, 0xd7, 0x24, 0x41, 0xe2, + 0xb8, 0x21, 0x81, 0x22, 0xf2, 0xec, 0x21, 0xc1, 0x00, 0x80, 0x01, 0xff, + 0x44, 0xdf, 0x41, 0xef, 0x21, 0x81, 0x0d, 0x49, 0x34, 0x4b, 0xed, 0x21, + 0xc1, 0x00, 0x49, 0xcb, 0xae, 0xee, 0x21, 0x41, 0x54, 0xd3, 0x41, 0xf0, + 0x21, 0x41, 0x80, 0x01, 0xff, 0x47, 0xfd, 0x05, 0xeb, 0x21, 0x01, 0x06, + 0x28, 0x02, 0x01, 0xff, 0xe1, 0xb9, 0x21, 0x81, 0xa0, 0x02, 0xa2, 0x93, + 0x02, 0x43, 0x2d, 0x19, 0xc2, 0x21, 0x01, 0x42, 0x92, 0x01, 0xc3, 0x21, + 0x01, 0xa7, 0xea, 0x01, 0xa8, 0xd8, 0x01, 0xa9, 0xb9, 0x01, 0xab, 0x9b, + 0x01, 0xac, 0x83, 0x01, 0xad, 0x70, 0x42, 0xf1, 0x05, 0xdb, 0x21, 0x01, + 0xb3, 0x3d, 0xb4, 0x29, 0xf5, 0xe5, 0x21, 0x81, 0x06, 0x4a, 0xb0, 0xb9, + 0xd4, 0x24, 0x41, 0x06, 0xc5, 0x29, 0x10, 0x4a, 0x36, 0xac, 0xe8, 0x21, + 0x01, 0xe4, 0xe9, 0x21, 0x01, 0x42, 0xa4, 0x02, 0xea, 0x21, 0x41, 0xe1, + 0xe6, 0x21, 0x01, 0x48, 0x4c, 0x77, 0xe7, 0x21, 0x41, 0xa1, 0x06, 0x58, + 0xc4, 0x29, 0xe4, 0x21, 0x41, 0xe7, 0xe2, 0x21, 0x01, 0x42, 0x49, 0x47, + 0xe3, 0x21, 0x41, 0xa8, 0x06, 0x42, 0x48, 0x04, 0xe1, 0x21, 0x41, 0x4a, + 0xca, 0xae, 0xdc, 0x21, 0x01, 0x0e, 0x84, 0x7c, 0x0d, 0x42, 0x1c, 0x6a, + 0xdf, 0x21, 0xc1, 0x00, 0x4a, 0x50, 0xab, 0xe0, 0x21, 0x41, 0x4a, 0x28, + 0xb5, 0xdd, 0x21, 0x01, 0x44, 0x36, 0x63, 0xde, 0x21, 0x41, 0xe5, 0xd8, + 0x21, 0x81, 0x06, 0x43, 0x0b, 0x80, 0xda, 0x21, 0x41, 0x48, 0x4a, 0xb3, + 0xd9, 0x21, 0x41, 0x44, 0x23, 0x02, 0xd4, 0x21, 0x01, 0x43, 0x5f, 0x0d, + 0xd5, 0x21, 0x01, 0xf5, 0xd6, 0x21, 0xc1, 0x00, 0xec, 0xd7, 0x21, 0x41, + 0xe9, 0xcf, 0x21, 0x81, 0x12, 0xb5, 0x01, 0xff, 0xd3, 0xd1, 0x21, 0x01, + 0xec, 0xd2, 0x21, 0xc1, 0x00, 0x4f, 0xde, 0x6c, 0xd3, 0x21, 0x41, 0xee, + 0xd0, 0x21, 0x41, 0x47, 0x13, 0x6d, 0xcb, 0x21, 0x01, 0xed, 0xcc, 0x21, + 0xc1, 0x00, 0x06, 0xc5, 0x29, 0x01, 0xff, 0x42, 0x22, 0x00, 0xcd, 0x21, + 0x01, 0x42, 0x95, 0x16, 0xce, 0x21, 0x41, 0xe1, 0xc8, 0x21, 0x81, 0x06, + 0x4b, 0x6b, 0xa2, 0xca, 0x21, 0x41, 0xec, 0xc9, 0x21, 0x41, 0xe1, 0xc4, + 0x21, 0x81, 0x11, 0xe9, 0x88, 0x23, 0x01, 0x42, 0x40, 0x0d, 0xc6, 0x21, + 0xc1, 0x00, 0x49, 0x1d, 0xba, 0xc7, 0x21, 0x41, 0xf2, 0xc5, 0x21, 0x41, + 0x42, 0xe8, 0x01, 0xc0, 0x21, 0x01, 0xe9, 0xc1, 0x21, 0x41, 0x06, 0xc5, + 0x29, 0x0e, 0xec, 0xbd, 0x21, 0x01, 0xee, 0xbe, 0x21, 0x01, 0x4c, 0x1c, + 0x9a, 0xbf, 0x21, 0x41, 0x4a, 0x84, 0xae, 0xba, 0x21, 0x01, 0x43, 0xa9, + 0x1f, 0xbb, 0x21, 0x01, 0x43, 0x0c, 0x22, 0xbc, 0x21, 0x41, 0xe1, 0x57, + 0x21, 0x81, 0x84, 0x01, 0x44, 0x9e, 0x78, 0x9f, 0x21, 0x01, 0xe9, 0xa0, + 0x21, 0x81, 0x44, 0xf5, 0xaa, 0x21, 0x81, 0x06, 0x45, 0x4b, 0xf2, 0xb6, + 0x21, 0x41, 0x69, 0xea, 0x03, 0xab, 0x21, 0x01, 0xd3, 0xac, 0x21, 0x01, + 0xd4, 0xad, 0x21, 0x81, 0x24, 0xd7, 0xaf, 0x21, 0x01, 0xec, 0xb0, 0x21, + 0x81, 0x15, 0xee, 0xb2, 0x21, 0x01, 0xf2, 0xb3, 0x21, 0x81, 0x06, 0x44, + 0x1a, 0x6a, 0xb5, 0x21, 0x41, 0x4d, 0x88, 0x83, 0xb4, 0x21, 0x41, 0x45, + 0xde, 0x41, 0xb1, 0x21, 0x41, 0x4d, 0xb8, 0x30, 0xae, 0x21, 0x41, 0x07, + 0x27, 0x02, 0x22, 0xe4, 0xa4, 0x21, 0x01, 0xee, 0xa5, 0x21, 0x01, 0xb3, + 0x01, 0xff, 0x42, 0x13, 0x00, 0xa6, 0x21, 0x01, 0xe8, 0xa7, 0x21, 0x01, + 0x43, 0x45, 0x72, 0xa8, 0x21, 0xc1, 0x00, 0x4c, 0xe4, 0x8f, 0xa9, 0x21, + 0x41, 0x43, 0x1c, 0x74, 0xa1, 0x21, 0x01, 0xf5, 0xa2, 0x21, 0xc1, 0x00, + 0xe4, 0xa3, 0x21, 0x41, 0x07, 0x27, 0x02, 0x72, 0xd2, 0x8d, 0x21, 0x81, + 0x67, 0xe2, 0x8f, 0x21, 0x01, 0xa4, 0x4a, 0xeb, 0x95, 0x21, 0x81, 0x3f, + 0xec, 0x97, 0x21, 0x81, 0x26, 0xad, 0x1c, 0x49, 0x9b, 0xc3, 0x6f, 0x23, + 0x01, 0x44, 0x1d, 0x02, 0x9c, 0x21, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x60, + 0x22, 0x02, 0x9d, 0x21, 0x01, 0x6c, 0x16, 0x02, 0x9e, 0x21, 0x41, 0xd2, + 0x9a, 0x21, 0x01, 0xd4, 0x9b, 0x21, 0x41, 0x80, 0x06, 0x42, 0x57, 0x00, + 0x27, 0x23, 0x41, 0x4c, 0x54, 0x92, 0x99, 0x21, 0x01, 0x49, 0x62, 0xa2, + 0x98, 0x21, 0x41, 0x4f, 0x0b, 0x6d, 0x96, 0x21, 0x41, 0xd2, 0x90, 0x21, + 0x01, 0xd3, 0x91, 0x21, 0x01, 0xd4, 0x92, 0x21, 0x01, 0xd5, 0x93, 0x21, + 0xc1, 0x00, 0x4a, 0x46, 0xab, 0x94, 0x21, 0x41, 0x4d, 0x47, 0x83, 0x8e, + 0x21, 0x41, 0xe1, 0x58, 0x21, 0x81, 0xdf, 0x02, 0xa2, 0xc4, 0x02, 0xa5, + 0xb5, 0x02, 0xa7, 0xe8, 0x01, 0x4d, 0xf0, 0x03, 0x82, 0x23, 0x01, 0xa9, + 0xd5, 0x01, 0xab, 0xc0, 0x01, 0xac, 0xb0, 0x01, 0xad, 0x86, 0x01, 0xae, + 0x7a, 0xb0, 0x70, 0x42, 0x3d, 0x00, 0x7d, 0x21, 0x01, 0xb3, 0x3a, 0xb4, + 0x2e, 0xf5, 0x87, 0x21, 0x81, 0x06, 0x42, 0xad, 0x35, 0x8c, 0x21, 0x41, + 0x44, 0x93, 0xf1, 0xd2, 0x24, 0x01, 0xd2, 0x88, 0x21, 0x01, 0xe4, 0x89, + 0x21, 0x01, 0x4c, 0x10, 0x97, 0x8a, 0x21, 0x01, 0xf2, 0xd3, 0x24, 0x81, + 0x06, 0x42, 0xa4, 0x02, 0x8b, 0x21, 0x41, 0xd2, 0x87, 0x23, 0x41, 0x42, + 0x17, 0x00, 0x86, 0x21, 0x01, 0xf5, 0x86, 0x23, 0x41, 0xe1, 0x7e, 0x21, + 0x81, 0x25, 0xa8, 0x0c, 0x42, 0x3f, 0x00, 0x84, 0x21, 0x01, 0x44, 0xcc, + 0xf8, 0x85, 0x21, 0x41, 0xe1, 0x80, 0x21, 0x01, 0xe5, 0x81, 0x21, 0x01, + 0x42, 0x03, 0x00, 0x82, 0x21, 0x01, 0xf5, 0x83, 0x21, 0xc1, 0x00, 0xec, + 0x85, 0x23, 0x41, 0xf2, 0x7f, 0x21, 0x41, 0xe1, 0x84, 0x23, 0x01, 0xe9, + 0x7c, 0x21, 0x41, 0xe5, 0x7a, 0x21, 0x01, 0x42, 0x79, 0x08, 0x7b, 0x21, + 0x41, 0xe5, 0x74, 0x21, 0x81, 0x0b, 0xe9, 0x78, 0x21, 0xc1, 0x00, 0x4b, + 0xbf, 0x9c, 0x79, 0x21, 0x41, 0x06, 0xc5, 0x29, 0x01, 0xff, 0x42, 0x6c, + 0x02, 0x75, 0x21, 0x01, 0x42, 0xf1, 0x06, 0x76, 0x21, 0x01, 0x42, 0x77, + 0x00, 0x77, 0x21, 0x41, 0xe9, 0x72, 0x21, 0x01, 0xf5, 0x73, 0x21, 0xc1, + 0x00, 0xed, 0x83, 0x23, 0x41, 0xe1, 0xd1, 0x24, 0x81, 0x09, 0xe9, 0x70, + 0x21, 0xc1, 0x00, 0xe4, 0x71, 0x21, 0x41, 0xeb, 0x6f, 0x21, 0x41, 0x42, + 0xf1, 0x06, 0x6d, 0x21, 0x01, 0xed, 0x6e, 0x21, 0x41, 0xe1, 0x62, 0x21, + 0x81, 0x30, 0xe9, 0x67, 0x21, 0x81, 0x0f, 0xf5, 0x6b, 0x21, 0xc1, 0x00, + 0xe4, 0x81, 0x23, 0x01, 0x42, 0x1d, 0xfb, 0x6c, 0x21, 0x41, 0x42, 0xe1, + 0x44, 0x68, 0x21, 0x01, 0x42, 0xa4, 0x02, 0x80, 0x23, 0xc1, 0x00, 0x80, + 0x01, 0xff, 0x4d, 0x64, 0x54, 0x6a, 0x21, 0x01, 0x48, 0xcd, 0x59, 0x69, + 0x21, 0x41, 0xec, 0x63, 0x21, 0x01, 0x47, 0x43, 0x63, 0x64, 0x21, 0x01, + 0xf2, 0x65, 0x21, 0xc1, 0x00, 0x51, 0xd5, 0x59, 0x66, 0x21, 0x41, 0x44, + 0x2e, 0xb5, 0x60, 0x21, 0x01, 0x43, 0xfa, 0x03, 0x61, 0x21, 0x41, 0xa1, + 0x08, 0xe9, 0x5f, 0x21, 0x01, 0xf5, 0xd0, 0x24, 0x41, 0xe4, 0x5c, 0x21, + 0x01, 0x43, 0x22, 0x02, 0x5d, 0x21, 0x01, 0xf2, 0x5e, 0x21, 0x41, 0xe4, + 0x59, 0x21, 0x81, 0x13, 0x44, 0x88, 0xf7, 0x7e, 0x23, 0x01, 0x02, 0xa4, + 0x02, 0x01, 0xff, 0xd2, 0x5b, 0x21, 0x01, 0xd3, 0x7f, 0x23, 0x41, 0x49, + 0x26, 0xba, 0x5a, 0x21, 0x41, 0x42, 0x19, 0x00, 0x40, 0x21, 0x01, 0xe2, + 0x41, 0x21, 0x01, 0x43, 0x55, 0x83, 0x42, 0x21, 0x81, 0x67, 0xe7, 0x45, + 0x21, 0x81, 0x42, 0xec, 0x4b, 0x21, 0x81, 0x33, 0xed, 0x4e, 0x21, 0x81, + 0x0e, 0xee, 0x54, 0x21, 0x01, 0xf2, 0x55, 0x21, 0x01, 0x42, 0xa4, 0x02, + 0x56, 0x21, 0x41, 0x80, 0x06, 0x42, 0x9e, 0x01, 0x53, 0x21, 0x41, 0x4b, + 0x95, 0x9f, 0x50, 0x21, 0x01, 0x4b, 0xfc, 0xa5, 0x51, 0x21, 0x01, 0x47, + 0xfd, 0x05, 0x52, 0x21, 0x01, 0x4a, 0x41, 0x47, 0x4f, 0x21, 0x41, 0x50, + 0x3a, 0x63, 0x4c, 0x21, 0x01, 0xd2, 0x4d, 0x21, 0x41, 0xe9, 0x46, 0x21, + 0xc1, 0x00, 0x80, 0x01, 0xff, 0x43, 0x1e, 0xfa, 0x47, 0x21, 0x01, 0x44, + 0xdf, 0x41, 0x4a, 0x21, 0x01, 0x62, 0x28, 0x0d, 0x49, 0x21, 0x01, 0x42, + 0x0d, 0x00, 0x48, 0x21, 0x41, 0x0b, 0xa9, 0x9c, 0x01, 0xff, 0x43, 0xff, + 0x37, 0x43, 0x21, 0x01, 0x47, 0xfd, 0x05, 0x44, 0x21, 0x41, 0xe1, 0x29, + 0x21, 0x81, 0x7e, 0xe9, 0x2d, 0x21, 0x81, 0x3b, 0xf5, 0x37, 0x21, 0xc1, + 0x00, 0x42, 0xda, 0x63, 0x38, 0x21, 0x81, 0x0c, 0x42, 0x36, 0xf3, 0x3e, + 0x21, 0x01, 0x42, 0xa4, 0x02, 0x7d, 0x23, 0x41, 0x07, 0x27, 0x02, 0x01, + 0xff, 0x42, 0x1a, 0x00, 0x39, 0x21, 0x01, 0x43, 0x22, 0x00, 0x3a, 0x21, + 0x01, 0x46, 0x1b, 0x02, 0x3b, 0x21, 0x01, 0x44, 0xa8, 0x96, 0x3c, 0x21, + 0x01, 0x42, 0x40, 0x0d, 0x3d, 0x21, 0x41, 0x07, 0x27, 0x02, 0x01, 0xff, + 0x43, 0xf9, 0x03, 0x2e, 0x21, 0x81, 0x28, 0x43, 0x1c, 0x74, 0x30, 0x21, + 0x01, 0x44, 0x5e, 0x0d, 0x31, 0x21, 0x01, 0x43, 0x9c, 0x1f, 0x32, 0x21, + 0x01, 0x43, 0x3b, 0x04, 0x33, 0x21, 0x01, 0x43, 0x18, 0x24, 0x34, 0x21, + 0x01, 0x43, 0x8e, 0x06, 0x35, 0x21, 0x01, 0xf5, 0x36, 0x21, 0x41, 0x52, + 0xea, 0x03, 0xcf, 0x24, 0x01, 0xd2, 0x2f, 0x21, 0x41, 0x80, 0x04, 0xec, + 0x2c, 0x21, 0x41, 0x44, 0xdf, 0x41, 0x2b, 0x21, 0x01, 0x44, 0x36, 0x63, + 0x2a, 0x21, 0xc1, 0x00, 0x45, 0xde, 0x41, 0xce, 0x24, 0x41, 0xe1, 0xb5, + 0x20, 0x81, 0xcc, 0x02, 0xa5, 0xad, 0x02, 0xe9, 0x00, 0x21, 0x81, 0x87, + 0x01, 0xf5, 0x16, 0x21, 0xc1, 0x00, 0x4c, 0x9c, 0x8f, 0x17, 0x21, 0x01, + 0xd2, 0x18, 0x21, 0x81, 0x4a, 0xe4, 0x1e, 0x21, 0x81, 0x25, 0xec, 0x22, + 0x21, 0x01, 0xed, 0x23, 0x21, 0x81, 0x16, 0xf2, 0x25, 0x21, 0xc1, 0x00, + 0xd7, 0x26, 0x21, 0x01, 0xb5, 0x01, 0xff, 0xee, 0x27, 0x21, 0x01, 0x42, + 0xa4, 0x02, 0x28, 0x21, 0x41, 0x4a, 0x33, 0x4b, 0x24, 0x21, 0x41, 0x80, + 0x01, 0xff, 0x4e, 0xb4, 0x7e, 0x21, 0x21, 0x01, 0x54, 0x37, 0x47, 0xcd, + 0x24, 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, 0x4a, 0x7c, 0xac, 0x1f, 0x21, + 0x01, 0x43, 0xa9, 0x60, 0x20, 0x21, 0x41, 0x80, 0x01, 0xff, 0x44, 0xdf, + 0x41, 0x1d, 0x21, 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, 0x48, 0x12, 0x6d, + 0xcc, 0x24, 0x01, 0x43, 0x10, 0x63, 0x19, 0x21, 0x81, 0x0c, 0x43, 0x18, + 0x24, 0x1b, 0x21, 0x01, 0x4d, 0xe0, 0x8c, 0x1c, 0x21, 0x41, 0x4f, 0x0b, + 0x6d, 0x1a, 0x21, 0x41, 0x80, 0x8a, 0x01, 0xd4, 0x04, 0x21, 0x81, 0x76, + 0x43, 0x55, 0x83, 0x07, 0x21, 0x01, 0xe7, 0x7c, 0x23, 0x01, 0xb2, 0x37, + 0xb3, 0x01, 0xff, 0x42, 0x13, 0x00, 0x10, 0x21, 0x01, 0xe8, 0x11, 0x21, + 0xc1, 0x00, 0x80, 0x01, 0xff, 0x4d, 0x64, 0x54, 0x12, 0x21, 0x01, 0xb4, + 0x01, 0xff, 0x43, 0x37, 0x63, 0x15, 0x21, 0x01, 0x05, 0x29, 0x02, 0x01, + 0xff, 0x43, 0x1c, 0x74, 0x13, 0x21, 0x01, 0x52, 0x5f, 0x54, 0xcb, 0x24, + 0x01, 0x44, 0x47, 0x47, 0x14, 0x21, 0x41, 0xd2, 0x08, 0x21, 0x81, 0x28, + 0xd3, 0x0a, 0x21, 0xc1, 0x00, 0x07, 0x27, 0x02, 0x01, 0xff, 0x4a, 0x72, + 0xac, 0x0b, 0x21, 0x01, 0x49, 0x41, 0x63, 0x0c, 0x21, 0x01, 0x43, 0xf0, + 0x06, 0x0d, 0x21, 0x01, 0x4b, 0x4f, 0xa4, 0x0e, 0x21, 0x01, 0x42, 0xe0, + 0x09, 0x0f, 0x21, 0x41, 0x45, 0xde, 0x41, 0x09, 0x21, 0x41, 0x80, 0x01, + 0xff, 0x4c, 0x48, 0x92, 0x06, 0x21, 0x01, 0x48, 0x47, 0xcf, 0x05, 0x21, + 0x41, 0x4b, 0x64, 0x54, 0x03, 0x21, 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, + 0xe5, 0x01, 0x21, 0x01, 0xf5, 0x02, 0x21, 0x41, 0x42, 0x37, 0xf3, 0x7b, + 0x23, 0x01, 0x45, 0xd9, 0xf0, 0xfe, 0x20, 0xc1, 0x00, 0x07, 0x27, 0x02, + 0x01, 0xff, 0x43, 0xa9, 0x60, 0xff, 0x20, 0x01, 0xf5, 0xca, 0x24, 0x41, + 0x45, 0xde, 0x41, 0xb6, 0x20, 0x01, 0xd2, 0xb7, 0x20, 0x81, 0x64, 0x42, + 0x16, 0x00, 0xee, 0x20, 0x81, 0x4e, 0xe4, 0xf0, 0x20, 0x81, 0x43, 0xec, + 0xf2, 0x20, 0x81, 0x32, 0xed, 0xf5, 0x20, 0x01, 0xee, 0xf6, 0x20, 0x81, + 0x0f, 0xf2, 0xfb, 0x20, 0x81, 0x06, 0x44, 0x59, 0x3b, 0xfd, 0x20, 0x41, + 0xd3, 0xfc, 0x20, 0x41, 0xd2, 0xf7, 0x20, 0xc1, 0x00, 0x80, 0x01, 0xff, + 0x4d, 0xd1, 0x85, 0xfa, 0x20, 0x01, 0x49, 0x77, 0xc3, 0xf9, 0x20, 0x01, + 0x44, 0x36, 0x63, 0xf8, 0x20, 0x41, 0x5a, 0x9b, 0x1f, 0xf3, 0x20, 0x01, + 0x42, 0x57, 0x00, 0xf4, 0x20, 0x41, 0x56, 0x9f, 0x1f, 0xf1, 0x20, 0x41, + 0x80, 0x01, 0xff, 0x4d, 0xc4, 0x85, 0xef, 0x20, 0x01, 0x56, 0x2b, 0x2e, + 0xc9, 0x24, 0x41, 0x80, 0x01, 0xff, 0x48, 0x3f, 0xcf, 0xed, 0x20, 0x01, + 0x06, 0x28, 0x02, 0x01, 0xff, 0xa1, 0xb0, 0x03, 0xa2, 0x8e, 0x03, 0xa4, + 0xd9, 0x02, 0xa5, 0xba, 0x02, 0xa7, 0x80, 0x02, 0xa8, 0xd6, 0x01, 0xa9, + 0xc7, 0x01, 0xab, 0x9c, 0x01, 0xac, 0x83, 0x01, 0xad, 0x71, 0xae, 0x4c, + 0x42, 0xe0, 0x09, 0xe2, 0x20, 0x01, 0xb3, 0x1c, 0x44, 0x47, 0x47, 0xe9, + 0x20, 0x01, 0xf5, 0xea, 0x20, 0x81, 0x06, 0x44, 0x68, 0xf9, 0xc8, 0x24, + 0x41, 0xe4, 0xeb, 0x20, 0xc1, 0x00, 0x48, 0x17, 0xc8, 0xec, 0x20, 0x41, + 0xa1, 0x1e, 0xa8, 0x06, 0x42, 0x48, 0x04, 0xe8, 0x20, 0x41, 0xe5, 0xe5, + 0x20, 0x81, 0x0b, 0xa9, 0x01, 0xff, 0xe4, 0xe7, 0x20, 0x01, 0xed, 0xc7, + 0x24, 0x41, 0x49, 0x41, 0xba, 0xe6, 0x20, 0x41, 0xec, 0xe3, 0x20, 0x01, + 0xf2, 0xe4, 0x20, 0x41, 0xe5, 0xc4, 0x24, 0x81, 0x0d, 0x42, 0x79, 0x08, + 0xe0, 0x20, 0xc1, 0x00, 0x49, 0x12, 0x24, 0xe1, 0x20, 0x41, 0x06, 0xc5, + 0x29, 0x01, 0xff, 0x42, 0x92, 0xa0, 0xc5, 0x24, 0x01, 0x42, 0xf1, 0x06, + 0xc6, 0x24, 0x41, 0x49, 0x49, 0xb3, 0xde, 0x20, 0x01, 0xe9, 0xdf, 0x20, + 0x01, 0x43, 0x0b, 0x80, 0xc3, 0x24, 0x41, 0xe1, 0xdd, 0x20, 0x81, 0x06, + 0x42, 0x9d, 0x5a, 0xc2, 0x24, 0x41, 0xed, 0xc0, 0x24, 0xc1, 0x00, 0x4a, + 0xa2, 0x60, 0xc1, 0x24, 0x41, 0xa1, 0x1c, 0x42, 0x03, 0x00, 0xda, 0x20, + 0x81, 0x0f, 0xb5, 0x01, 0xff, 0x49, 0xe3, 0xba, 0xdc, 0x20, 0x01, 0x50, + 0x1a, 0x6a, 0xbf, 0x24, 0x41, 0x49, 0x2f, 0xba, 0xdb, 0x20, 0x41, 0xeb, + 0xd8, 0x20, 0x01, 0x44, 0x1d, 0x02, 0xd9, 0x20, 0x41, 0x47, 0x13, 0x6d, + 0xd6, 0x20, 0x01, 0x53, 0x6b, 0x4f, 0xd7, 0x20, 0x41, 0xa1, 0x0c, 0x49, + 0x75, 0xbf, 0xd4, 0x20, 0x01, 0x43, 0x41, 0xf6, 0xd5, 0x20, 0x41, 0x06, + 0xc5, 0x29, 0x0b, 0xec, 0xd2, 0x20, 0xc1, 0x00, 0x48, 0x2f, 0xba, 0xd3, + 0x20, 0x41, 0xe1, 0xbe, 0x24, 0x01, 0x4c, 0x50, 0x96, 0xd1, 0x20, 0x41, + 0xe1, 0xbb, 0x24, 0x81, 0x16, 0xe9, 0xcd, 0x20, 0xc1, 0x00, 0xd4, 0xce, + 0x20, 0x81, 0x06, 0x4a, 0x78, 0xb5, 0xd0, 0x20, 0x41, 0x47, 0xc5, 0x29, + 0xcf, 0x20, 0x41, 0x47, 0x43, 0x63, 0xcb, 0x20, 0x01, 0xf2, 0xcc, 0x20, + 0xc1, 0x00, 0x06, 0xc5, 0x29, 0x01, 0xff, 0x42, 0x00, 0x00, 0xbc, 0x24, + 0x01, 0x42, 0xf1, 0x05, 0xbd, 0x24, 0x41, 0xec, 0xc7, 0x20, 0x81, 0x11, + 0xee, 0xc9, 0x20, 0x81, 0x06, 0x43, 0xfd, 0x22, 0xba, 0x24, 0x41, 0x50, + 0x3a, 0x63, 0xca, 0x20, 0x41, 0x48, 0x2f, 0xba, 0xc8, 0x20, 0x41, 0xe1, + 0xc3, 0x20, 0x01, 0xe9, 0xc4, 0x20, 0x81, 0x18, 0xb5, 0x01, 0xff, 0xe2, + 0xc6, 0x20, 0x01, 0x08, 0xfc, 0x7f, 0x01, 0xff, 0x48, 0x12, 0x6d, 0xb8, + 0x24, 0x01, 0x46, 0x1b, 0x02, 0xb9, 0x24, 0x41, 0x02, 0x49, 0x04, 0x01, + 0xff, 0x44, 0xdf, 0x41, 0xb7, 0x24, 0x01, 0x49, 0x34, 0x4b, 0xc5, 0x20, + 0x41, 0xa1, 0x0d, 0x42, 0x42, 0x00, 0xc1, 0x20, 0xc1, 0x00, 0x48, 0x2c, + 0xc4, 0xc2, 0x20, 0x41, 0xe4, 0xbf, 0x20, 0x01, 0x44, 0xdf, 0x44, 0xb6, + 0x24, 0x01, 0x49, 0x2b, 0xc4, 0xc0, 0x20, 0x41, 0x06, 0xc5, 0x29, 0x23, + 0x50, 0xda, 0x63, 0xbb, 0x20, 0x01, 0xee, 0xbc, 0x20, 0x81, 0x12, 0x42, + 0xa4, 0x02, 0xbd, 0x20, 0xc1, 0x00, 0xd2, 0x7a, 0x23, 0xc1, 0x00, 0x49, + 0x14, 0xba, 0xbe, 0x20, 0x41, 0x50, 0x0a, 0x63, 0x79, 0x23, 0x41, 0x4a, + 0x84, 0xae, 0xb8, 0x20, 0x01, 0x42, 0x22, 0x00, 0xb9, 0x20, 0x01, 0x43, + 0xf0, 0x06, 0xba, 0x20, 0x41, 0x80, 0xe7, 0x02, 0xd2, 0x8d, 0x20, 0x81, + 0xac, 0x02, 0x43, 0x89, 0x08, 0x94, 0x20, 0x01, 0x43, 0x5e, 0xc0, 0x95, + 0x20, 0x01, 0xec, 0x96, 0x20, 0x01, 0xee, 0x97, 0x20, 0x81, 0xe9, 0x01, + 0xb2, 0xd3, 0x01, 0x43, 0xfa, 0x03, 0xa0, 0x20, 0x81, 0xc5, 0x01, 0x43, + 0x94, 0x0a, 0xa1, 0x20, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x0e, 0xf6, 0x7f, + 0x88, 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, 0xe1, 0xa2, 0x20, 0x81, 0x6d, + 0x43, 0x1c, 0x74, 0xa6, 0x20, 0x01, 0x49, 0xa8, 0x7a, 0xa7, 0x20, 0x81, + 0x5a, 0x43, 0xb9, 0x7e, 0x77, 0x23, 0x01, 0x42, 0x22, 0x00, 0xa9, 0x20, + 0x81, 0x47, 0x48, 0x12, 0x6d, 0xab, 0x20, 0x01, 0xab, 0x2c, 0xac, 0x17, + 0xb3, 0x0b, 0xb5, 0x01, 0xff, 0xd2, 0xb3, 0x20, 0x01, 0xe4, 0xb4, 0x20, + 0x41, 0x42, 0xb0, 0x01, 0x78, 0x23, 0x01, 0xf5, 0xb5, 0x24, 0x41, 0xe1, + 0xaf, 0x20, 0x81, 0x08, 0xe9, 0xb1, 0x20, 0x01, 0xf5, 0xb2, 0x20, 0x41, + 0x4b, 0x52, 0xa3, 0xb0, 0x20, 0x41, 0x45, 0x1c, 0x02, 0xac, 0x20, 0x81, + 0x06, 0x42, 0xb2, 0x3f, 0xae, 0x20, 0x41, 0x48, 0xfc, 0x05, 0xad, 0x20, + 0x41, 0x45, 0xde, 0x41, 0xaa, 0x20, 0x41, 0x45, 0xde, 0x41, 0xa8, 0x20, + 0x41, 0x49, 0x2f, 0xba, 0xa3, 0x20, 0x81, 0x04, 0xee, 0xa5, 0x20, 0x41, + 0x4a, 0x53, 0xa3, 0xa4, 0x20, 0x41, 0x43, 0xf9, 0x03, 0xad, 0x24, 0x01, + 0x42, 0x49, 0x00, 0xae, 0x24, 0x01, 0x48, 0x12, 0x6d, 0xaf, 0x24, 0x01, + 0x42, 0x74, 0x00, 0xb0, 0x24, 0x81, 0x11, 0x42, 0x2a, 0x02, 0xb2, 0x24, + 0x81, 0x06, 0x42, 0x6f, 0x00, 0xb4, 0x24, 0x41, 0xf3, 0xb3, 0x24, 0x41, + 0xec, 0xb1, 0x24, 0x41, 0x4e, 0x94, 0x78, 0xac, 0x24, 0x41, 0x42, 0x92, + 0x01, 0x9e, 0x20, 0x01, 0x43, 0x2f, 0xb5, 0x9f, 0x20, 0xc1, 0x00, 0x42, + 0x2f, 0x67, 0xab, 0x24, 0x41, 0x80, 0x01, 0xff, 0x4b, 0x8a, 0x9f, 0x9b, + 0x20, 0x01, 0x4b, 0xf1, 0xa5, 0x9c, 0x20, 0x01, 0x47, 0xfd, 0x05, 0x9d, + 0x20, 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, 0x44, 0x41, 0x63, 0x98, 0x20, + 0x81, 0x06, 0x42, 0x2a, 0x02, 0x9a, 0x20, 0x41, 0x45, 0x35, 0x63, 0x99, + 0x20, 0x41, 0x07, 0x27, 0x02, 0x01, 0xff, 0x51, 0x4c, 0x5a, 0x8e, 0x20, + 0x01, 0x43, 0xa9, 0x1f, 0x8f, 0x20, 0x01, 0x43, 0xa9, 0x60, 0xa9, 0x24, + 0x01, 0x42, 0x7d, 0x02, 0x90, 0x20, 0x01, 0x43, 0x9e, 0x0f, 0xaa, 0x24, + 0x01, 0xb3, 0x04, 0xf5, 0x93, 0x20, 0x41, 0x42, 0x13, 0x00, 0x91, 0x20, + 0x01, 0x42, 0xb0, 0x01, 0x92, 0x20, 0x41, 0x53, 0x4e, 0x4e, 0x8c, 0x20, + 0x01, 0x49, 0xa5, 0xc5, 0x8b, 0x20, 0x41, 0xe1, 0x55, 0x20, 0x81, 0xe6, + 0x02, 0xe9, 0x72, 0x20, 0x81, 0x9e, 0x02, 0xf5, 0x7a, 0x20, 0xc1, 0x00, + 0x80, 0x84, 0x02, 0xe2, 0x7e, 0x20, 0x81, 0xea, 0x01, 0xe7, 0x81, 0x20, + 0x81, 0x25, 0xe8, 0x83, 0x20, 0x01, 0xee, 0x84, 0x20, 0x81, 0x06, 0x42, + 0xe1, 0x44, 0x89, 0x20, 0x41, 0xd3, 0x85, 0x20, 0x81, 0x04, 0xd4, 0x88, + 0x20, 0x41, 0x45, 0xde, 0x41, 0x86, 0x20, 0xc1, 0x00, 0x45, 0xde, 0x41, + 0x87, 0x20, 0x41, 0x07, 0x27, 0x02, 0x06, 0x42, 0x40, 0x0d, 0x82, 0x20, + 0x41, 0xa1, 0xa0, 0x01, 0xa4, 0x91, 0x01, 0x45, 0x2d, 0xb5, 0x92, 0x24, + 0x01, 0xa7, 0x74, 0xa8, 0x6a, 0x48, 0x12, 0x6d, 0x99, 0x24, 0x01, 0xab, + 0x48, 0xac, 0x2d, 0xad, 0x1b, 0x42, 0x51, 0x03, 0xa5, 0x24, 0x01, 0x42, + 0x0d, 0x06, 0xa6, 0x24, 0x01, 0xb3, 0x01, 0xff, 0x42, 0xb0, 0x01, 0xa7, + 0x24, 0x01, 0x46, 0x14, 0x6d, 0xa8, 0x24, 0x41, 0x43, 0xf9, 0x03, 0xa2, + 0x24, 0x01, 0x42, 0xed, 0x00, 0xa3, 0x24, 0x01, 0xe9, 0xa4, 0x24, 0x41, + 0xa1, 0x06, 0x4c, 0x48, 0x9b, 0xa1, 0x24, 0x41, 0x45, 0xb4, 0xed, 0x9e, + 0x24, 0x01, 0xed, 0x9f, 0x24, 0xc1, 0x00, 0x4a, 0xa2, 0x60, 0xa0, 0x24, + 0x41, 0x45, 0x1c, 0x02, 0x9a, 0x24, 0x01, 0xb5, 0x01, 0xff, 0xf2, 0x9b, + 0x24, 0x01, 0x44, 0x1a, 0x6a, 0x9c, 0x24, 0xc1, 0x00, 0x4c, 0x1e, 0x6a, + 0x9d, 0x24, 0x41, 0xe1, 0x97, 0x24, 0x01, 0xe9, 0x98, 0x24, 0x41, 0xe1, + 0x93, 0x24, 0x01, 0xe9, 0x94, 0x24, 0xc1, 0x00, 0x47, 0xf6, 0xda, 0x95, + 0x24, 0x01, 0x42, 0xa4, 0x02, 0x96, 0x24, 0x41, 0x42, 0x9e, 0x01, 0x90, + 0x24, 0x01, 0x42, 0x79, 0x08, 0x91, 0x24, 0x41, 0x44, 0x88, 0xf7, 0x8d, + 0x24, 0x01, 0x42, 0xa4, 0x02, 0x8e, 0x24, 0xc1, 0x00, 0x48, 0xc4, 0x17, + 0x8f, 0x24, 0x41, 0x07, 0x27, 0x02, 0x04, 0xd2, 0x80, 0x20, 0x41, 0x44, + 0x9e, 0x78, 0x7f, 0x20, 0x01, 0x43, 0x8e, 0x06, 0x76, 0x23, 0x41, 0x44, + 0xdf, 0x41, 0x7c, 0x20, 0x01, 0x47, 0x32, 0xda, 0x7b, 0x20, 0x01, 0x47, + 0xf6, 0x7f, 0x7d, 0x20, 0x41, 0xe2, 0x73, 0x20, 0x01, 0xed, 0x74, 0x20, + 0x81, 0x18, 0xee, 0x77, 0x20, 0x81, 0x0d, 0x42, 0xa4, 0x02, 0x79, 0x20, + 0xc1, 0x00, 0x49, 0x50, 0xab, 0x75, 0x23, 0x41, 0x53, 0xc7, 0x49, 0x78, + 0x20, 0x41, 0x07, 0x27, 0x02, 0x0b, 0xd2, 0x76, 0x20, 0xc1, 0x00, 0x49, + 0x80, 0xba, 0x8c, 0x24, 0x41, 0x43, 0xf0, 0x06, 0x8a, 0x24, 0x01, 0x43, + 0x8e, 0x06, 0x75, 0x20, 0x01, 0x45, 0x92, 0xf1, 0x8b, 0x24, 0x41, 0x4b, + 0x40, 0x47, 0x88, 0x24, 0x01, 0xe7, 0x56, 0x20, 0x81, 0x14, 0xed, 0x6e, + 0x20, 0x01, 0xf2, 0x6f, 0x20, 0xc1, 0x00, 0xa1, 0x01, 0xff, 0xd3, 0x70, + 0x20, 0x01, 0xd4, 0x71, 0x20, 0x41, 0x80, 0x04, 0xd3, 0x74, 0x23, 0x41, + 0x0d, 0x42, 0x72, 0x06, 0x49, 0xa3, 0x60, 0x89, 0x24, 0x41, 0xa1, 0x89, + 0x01, 0xa2, 0x7d, 0xa7, 0x5f, 0x42, 0x22, 0x00, 0x60, 0x20, 0x01, 0x42, + 0x46, 0x00, 0x61, 0x20, 0x81, 0x4c, 0x43, 0x10, 0x63, 0x63, 0x20, 0x01, + 0xac, 0x31, 0x42, 0xf1, 0x05, 0x68, 0x20, 0x01, 0x4c, 0x9f, 0x3f, 0x69, + 0x20, 0x01, 0x42, 0x5a, 0x03, 0x6a, 0x20, 0x01, 0x44, 0x47, 0x47, 0x6b, + 0x20, 0x01, 0xb5, 0x01, 0xff, 0x07, 0x1d, 0x6a, 0x06, 0x42, 0xa4, 0x02, + 0x6d, 0x20, 0x41, 0x44, 0xe8, 0xf5, 0x6c, 0x20, 0x01, 0x44, 0x8c, 0x06, + 0x73, 0x23, 0x41, 0xe1, 0x64, 0x20, 0x01, 0xf5, 0x65, 0x20, 0xc1, 0x00, + 0x4b, 0xb4, 0x9c, 0x66, 0x20, 0x01, 0xed, 0x67, 0x20, 0x41, 0x48, 0xab, + 0x3f, 0x62, 0x20, 0x41, 0xe1, 0x5b, 0x20, 0x81, 0x11, 0xe9, 0x5d, 0x20, + 0x81, 0x06, 0x42, 0x40, 0x0d, 0x5f, 0x20, 0x41, 0x42, 0xe1, 0x44, 0x5e, + 0x20, 0x41, 0x4a, 0xb4, 0x9c, 0x5c, 0x20, 0x41, 0x44, 0x9f, 0xea, 0x59, + 0x20, 0x01, 0xe9, 0x5a, 0x20, 0x41, 0x4a, 0xb4, 0x9c, 0x57, 0x20, 0x01, + 0x43, 0xb9, 0x00, 0x58, 0x20, 0x41, 0xe1, 0x40, 0x20, 0x81, 0x54, 0xe9, + 0x49, 0x20, 0x81, 0x3a, 0xf5, 0x4d, 0x20, 0xc1, 0x00, 0x80, 0x16, 0x43, + 0xbd, 0x7e, 0x51, 0x20, 0x81, 0x09, 0xf2, 0x53, 0x20, 0xc1, 0x00, 0xd2, + 0x54, 0x20, 0x41, 0x4b, 0x9e, 0x9c, 0x52, 0x20, 0x41, 0x4b, 0x7f, 0x9f, + 0x50, 0x20, 0x01, 0x08, 0x37, 0xcf, 0x01, 0xff, 0x42, 0x5c, 0x00, 0x4e, + 0x20, 0x01, 0x49, 0x9c, 0xc5, 0x87, 0x24, 0x01, 0x42, 0x79, 0x08, 0x4f, + 0x20, 0x41, 0x07, 0x27, 0x02, 0x01, 0xff, 0xe1, 0x4a, 0x20, 0x01, 0x43, + 0xa9, 0x1f, 0x4b, 0x20, 0x01, 0x48, 0x12, 0x6d, 0x4c, 0x20, 0x41, 0xe4, + 0x41, 0x20, 0x81, 0x40, 0x42, 0x15, 0xfb, 0x42, 0x20, 0x01, 0x44, 0xdf, + 0x44, 0x43, 0x20, 0x81, 0x1c, 0xec, 0x44, 0x20, 0x81, 0x0b, 0xf2, 0x47, + 0x20, 0xc1, 0x00, 0x42, 0x31, 0x4b, 0x48, 0x20, 0x41, 0x49, 0x02, 0xba, + 0x45, 0x20, 0x01, 0x42, 0x23, 0x02, 0x46, 0x20, 0x41, 0x07, 0x27, 0x02, + 0x01, 0xff, 0x43, 0x90, 0xac, 0x84, 0x24, 0x01, 0x42, 0x51, 0x03, 0x85, + 0x24, 0x01, 0x42, 0x59, 0x00, 0x86, 0x24, 0x41, 0x50, 0x2a, 0x63, 0x83, + 0x24, 0x41, 0x07, 0x27, 0x02, 0x9d, 0x03, 0xd2, 0x09, 0x20, 0x01, 0xe2, + 0x0a, 0x20, 0x81, 0x83, 0x02, 0xe4, 0x1c, 0x20, 0x81, 0xf7, 0x01, 0xeb, + 0x1d, 0x20, 0x81, 0xe0, 0x01, 0xec, 0x20, 0x20, 0x81, 0x9a, 0x01, 0x43, + 0xb9, 0x00, 0x2b, 0x20, 0x81, 0x81, 0x01, 0xee, 0x2d, 0x20, 0x81, 0x58, + 0x43, 0xf6, 0x13, 0x33, 0x20, 0x01, 0xb2, 0x3d, 0xb3, 0x01, 0xff, 0x43, + 0xeb, 0xf9, 0x37, 0x20, 0x01, 0xe8, 0x38, 0x20, 0xc1, 0x00, 0x80, 0x0a, + 0xd2, 0x3e, 0x20, 0x01, 0x43, 0x24, 0x02, 0x3f, 0x20, 0x41, 0x49, 0x29, + 0xab, 0x3a, 0x20, 0x01, 0x09, 0x51, 0x11, 0x06, 0x49, 0x1f, 0x9a, 0x39, + 0x20, 0x41, 0x48, 0x51, 0x11, 0x3c, 0x20, 0x81, 0x06, 0x61, 0x80, 0x0f, + 0x3b, 0x20, 0x41, 0x5f, 0x43, 0x11, 0x3d, 0x20, 0x41, 0x42, 0xe8, 0x01, + 0x34, 0x20, 0x81, 0x06, 0x43, 0x44, 0xa3, 0x36, 0x20, 0x41, 0x4a, 0xa2, + 0x60, 0x35, 0x20, 0x41, 0x80, 0x06, 0x43, 0x8e, 0x06, 0x32, 0x20, 0x41, + 0x47, 0x2b, 0xda, 0x2e, 0x20, 0x01, 0x0a, 0x32, 0xb5, 0x06, 0x4b, 0xc7, + 0xa8, 0x2f, 0x20, 0x41, 0x55, 0x8a, 0x3f, 0x30, 0x20, 0x01, 0x47, 0xfd, + 0x05, 0x31, 0x20, 0x41, 0x07, 0x27, 0x02, 0x01, 0xff, 0x43, 0x63, 0xfa, + 0x72, 0x23, 0x01, 0x43, 0x8e, 0x06, 0x2c, 0x20, 0x41, 0x07, 0x27, 0x02, + 0x0c, 0x42, 0x1a, 0x00, 0x29, 0x20, 0x01, 0x43, 0x3c, 0x3f, 0x2a, 0x20, + 0x41, 0x42, 0x13, 0x00, 0x21, 0x20, 0x01, 0x44, 0x70, 0xf5, 0x22, 0x20, + 0x01, 0x44, 0x3c, 0x47, 0x23, 0x20, 0x01, 0x42, 0x22, 0x00, 0x24, 0x20, + 0x01, 0xab, 0x0c, 0x43, 0x8e, 0x06, 0x27, 0x20, 0x01, 0x43, 0x0b, 0x80, + 0x28, 0x20, 0x41, 0x43, 0xa5, 0xf6, 0x25, 0x20, 0x01, 0xe9, 0x26, 0x20, + 0x41, 0x07, 0x27, 0x02, 0x01, 0xff, 0x45, 0x2d, 0xb5, 0x1e, 0x20, 0x01, + 0x4f, 0x2f, 0x76, 0x1f, 0x20, 0x41, 0x4b, 0xeb, 0x9c, 0x82, 0x24, 0x41, + 0x80, 0x2c, 0xd2, 0x16, 0x20, 0xc1, 0x00, 0x07, 0x27, 0x02, 0x01, 0xff, + 0xe1, 0x71, 0x23, 0x01, 0x45, 0x9e, 0xea, 0x17, 0x20, 0x01, 0x49, 0x41, + 0x63, 0x18, 0x20, 0x01, 0x4a, 0x48, 0xb3, 0x19, 0x20, 0x01, 0x44, 0xdb, + 0x59, 0x1a, 0x20, 0x01, 0x44, 0x47, 0x47, 0x1b, 0x20, 0x41, 0x44, 0xdf, + 0x41, 0x15, 0x20, 0x01, 0x06, 0x28, 0x02, 0x01, 0xff, 0x44, 0xf9, 0x03, + 0x0b, 0x20, 0x01, 0x49, 0xa8, 0x7a, 0x0c, 0x20, 0x01, 0x02, 0x24, 0x02, + 0x3d, 0x42, 0x22, 0x00, 0x0f, 0x20, 0x01, 0xa9, 0x29, 0x45, 0x22, 0x02, + 0x12, 0x20, 0x01, 0x43, 0x18, 0x24, 0x70, 0x23, 0x81, 0x16, 0x02, 0xa4, + 0x02, 0x06, 0x4f, 0x4c, 0x77, 0x14, 0x20, 0x41, 0x43, 0x14, 0x5d, 0x13, + 0x20, 0x01, 0x42, 0x1c, 0x6a, 0x81, 0x24, 0x41, 0x45, 0x35, 0x63, 0x80, + 0x24, 0x41, 0x47, 0x13, 0x6d, 0x10, 0x20, 0x01, 0x43, 0x99, 0x14, 0x11, + 0x20, 0x41, 0xec, 0x0d, 0x20, 0x01, 0x47, 0x43, 0x63, 0x0e, 0x20, 0x41, + 0xe1, 0x01, 0x20, 0x01, 0x43, 0x1c, 0x74, 0x02, 0x20, 0x01, 0x49, 0x41, + 0x63, 0x03, 0x20, 0x01, 0x42, 0x22, 0x00, 0x04, 0x20, 0x01, 0x43, 0xf0, + 0x06, 0x05, 0x20, 0x01, 0x4a, 0xd9, 0x41, 0x06, 0x20, 0x01, 0x44, 0xe7, + 0x85, 0x07, 0x20, 0x01, 0x43, 0x70, 0x8d, 0x08, 0x20, 0x41, 0x09, 0x51, + 0x27, 0x0c, 0x59, 0x9c, 0x26, 0x70, 0x24, 0x01, 0x4e, 0x50, 0x82, 0x71, + 0x24, 0x41, 0x45, 0xb7, 0x3d, 0x72, 0x24, 0x01, 0x49, 0x07, 0xc4, 0x74, + 0x24, 0x01, 0x48, 0x77, 0xd1, 0x73, 0x24, 0x41, 0x0a, 0x3a, 0xad, 0xbf, + 0x13, 0xa5, 0xfd, 0x11, 0xa6, 0xd3, 0x0d, 0x02, 0x51, 0x03, 0xfe, 0x0b, + 0xaf, 0xd7, 0x07, 0xb3, 0xfe, 0x04, 0xb4, 0x01, 0xff, 0x05, 0x25, 0x01, + 0xc7, 0x02, 0x03, 0x45, 0x0a, 0x01, 0xff, 0x43, 0xf9, 0x03, 0x00, 0x24, + 0x81, 0xb4, 0x02, 0xa2, 0x97, 0x02, 0x45, 0x10, 0xec, 0x59, 0x24, 0x01, + 0x04, 0x34, 0x90, 0x84, 0x02, 0xae, 0x1d, 0x04, 0x81, 0x1a, 0x11, 0x07, + 0x21, 0x78, 0x01, 0xff, 0x44, 0x5e, 0x0d, 0x5b, 0x24, 0x01, 0x4e, 0xab, + 0x61, 0x5e, 0x24, 0x41, 0xd2, 0x23, 0x24, 0x01, 0xf5, 0x2d, 0x24, 0x41, + 0x90, 0xae, 0x01, 0x91, 0x8d, 0x01, 0x92, 0x78, 0x93, 0x54, 0x94, 0x1e, + 0x95, 0x01, 0xff, 0xd0, 0x83, 0x25, 0x01, 0xd1, 0x9b, 0x25, 0x81, 0x0c, + 0xd2, 0xe1, 0x25, 0x01, 0xd4, 0xa4, 0x25, 0x01, 0xd6, 0xa9, 0x25, 0x41, + 0x45, 0x67, 0x3d, 0x6d, 0x26, 0x41, 0xd0, 0xec, 0x25, 0x01, 0xd1, 0x03, + 0x26, 0x01, 0x92, 0x22, 0xd5, 0x7a, 0x25, 0x81, 0x17, 0xd6, 0x15, 0x26, + 0x81, 0x0c, 0xd7, 0x40, 0x26, 0x01, 0xd8, 0x75, 0x25, 0x01, 0xd9, 0x20, + 0x26, 0x41, 0x45, 0x67, 0x3d, 0x85, 0x26, 0x41, 0x45, 0x67, 0x3d, 0x69, + 0x26, 0x41, 0xe1, 0x2a, 0x26, 0x01, 0xe2, 0x2e, 0x26, 0x41, 0xd4, 0x6c, + 0x25, 0x81, 0x17, 0xd5, 0xcd, 0x25, 0x01, 0xd6, 0x17, 0x26, 0x01, 0xd7, + 0x42, 0x26, 0x01, 0x99, 0x01, 0xff, 0xe1, 0xb7, 0x25, 0x01, 0xe2, 0xbb, + 0x25, 0x41, 0x45, 0x67, 0x3d, 0x60, 0x26, 0x41, 0xd0, 0x37, 0x26, 0x01, + 0xd1, 0xdb, 0x25, 0x01, 0xd2, 0x8d, 0x25, 0xc1, 0x00, 0x45, 0x67, 0x3d, + 0x6b, 0x26, 0x41, 0xd4, 0x63, 0x25, 0x81, 0x13, 0xd5, 0xc8, 0x25, 0x01, + 0xd8, 0xf5, 0x25, 0x01, 0xd9, 0x0c, 0x26, 0xc1, 0x00, 0x45, 0x67, 0x3d, + 0x7c, 0x26, 0x41, 0x45, 0x67, 0x3d, 0x57, 0x26, 0x41, 0xd1, 0x51, 0x25, + 0x81, 0x29, 0xd2, 0xbf, 0x25, 0x01, 0xd3, 0xf0, 0x25, 0x01, 0xd4, 0x07, + 0x26, 0x81, 0x16, 0xd5, 0x32, 0x26, 0x01, 0xd6, 0xd2, 0x25, 0x01, 0x97, + 0x04, 0xd8, 0x5a, 0x25, 0x41, 0xe1, 0x47, 0x26, 0x01, 0xe2, 0x4a, 0x26, + 0x41, 0x45, 0x67, 0x3d, 0x77, 0x26, 0x41, 0x45, 0x67, 0x3d, 0x4d, 0x26, + 0x41, 0xd2, 0x16, 0x24, 0x01, 0xf5, 0x1f, 0x24, 0x41, 0x43, 0x42, 0x63, + 0x50, 0x24, 0x81, 0x0d, 0x43, 0x36, 0xb0, 0x35, 0x24, 0xc1, 0x00, 0x47, + 0xb1, 0x30, 0x8f, 0x25, 0x41, 0x47, 0xb1, 0x30, 0x94, 0x25, 0x41, 0x45, + 0x35, 0x63, 0x4a, 0x24, 0x41, 0x43, 0xf9, 0x03, 0x01, 0x24, 0x81, 0xa1, + 0x02, 0xa2, 0xfb, 0x01, 0x44, 0x5e, 0x0d, 0x08, 0x24, 0x01, 0x04, 0x34, + 0x90, 0xe8, 0x01, 0xae, 0x2b, 0x04, 0x81, 0x1a, 0x11, 0x10, 0x6a, 0x6b, + 0x01, 0xff, 0x42, 0xe7, 0xfa, 0x3a, 0x24, 0x01, 0x42, 0x7f, 0xde, 0x3b, + 0x24, 0x41, 0xd2, 0x24, 0x24, 0x81, 0x0b, 0xf5, 0x2e, 0x24, 0xc1, 0x00, + 0x4d, 0xb8, 0x30, 0x2f, 0x24, 0x41, 0x4d, 0xb8, 0x30, 0x25, 0x24, 0x41, + 0x90, 0x84, 0x01, 0x91, 0x64, 0x92, 0x5a, 0x93, 0x3a, 0x94, 0x1a, 0x95, + 0x01, 0xff, 0xd0, 0x84, 0x25, 0x01, 0xd1, 0x9c, 0x25, 0x81, 0x08, 0xd2, + 0xe2, 0x25, 0x01, 0xd4, 0xa5, 0x25, 0x41, 0x45, 0x67, 0x3d, 0x6e, 0x26, + 0x41, 0xd0, 0xed, 0x25, 0x01, 0xd1, 0x04, 0x26, 0x01, 0x92, 0x0c, 0xd5, + 0x7b, 0x25, 0x01, 0xd8, 0x76, 0x25, 0x01, 0xd9, 0x21, 0x26, 0x41, 0xe1, + 0x2b, 0x26, 0x01, 0xe2, 0x2f, 0x26, 0x41, 0xd4, 0x6d, 0x25, 0x81, 0x13, + 0xd5, 0xce, 0x25, 0x01, 0xd6, 0x18, 0x26, 0x01, 0x99, 0x01, 0xff, 0xe1, + 0xb8, 0x25, 0x01, 0xe2, 0xbc, 0x25, 0x41, 0x45, 0x67, 0x3d, 0x61, 0x26, + 0x41, 0xd0, 0x38, 0x26, 0x01, 0xd1, 0xdc, 0x25, 0x41, 0xd4, 0x64, 0x25, + 0x81, 0x13, 0xd5, 0xc9, 0x25, 0x01, 0xd8, 0xf6, 0x25, 0x01, 0xd9, 0x0d, + 0x26, 0xc1, 0x00, 0x45, 0x67, 0x3d, 0x7d, 0x26, 0x41, 0x45, 0x67, 0x3d, + 0x58, 0x26, 0x41, 0xd1, 0x52, 0x25, 0x81, 0x29, 0xd2, 0xc0, 0x25, 0x01, + 0xd3, 0xf1, 0x25, 0x01, 0xd4, 0x08, 0x26, 0x81, 0x16, 0xd5, 0x33, 0x26, + 0x01, 0xd6, 0xd3, 0x25, 0x01, 0x97, 0x04, 0xd8, 0x5b, 0x25, 0x41, 0xe1, + 0x48, 0x26, 0x01, 0xe2, 0x4b, 0x26, 0x41, 0x45, 0x67, 0x3d, 0x78, 0x26, + 0x41, 0x45, 0x67, 0x3d, 0x4e, 0x26, 0x41, 0xd2, 0x17, 0x24, 0x01, 0xf5, + 0x20, 0x24, 0x41, 0x43, 0x42, 0x63, 0x51, 0x24, 0x81, 0x16, 0x43, 0x36, + 0xb0, 0x36, 0x24, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x46, 0xb2, 0x30, 0x90, + 0x25, 0x01, 0x4c, 0xb9, 0x30, 0x37, 0x24, 0x41, 0x47, 0xb1, 0x30, 0x95, + 0x25, 0x41, 0x45, 0x35, 0x63, 0x4b, 0x24, 0x41, 0x05, 0x93, 0x23, 0xad, + 0x01, 0x14, 0xdf, 0x44, 0x9c, 0x01, 0x03, 0x5b, 0x55, 0x01, 0xff, 0x43, + 0xf9, 0x03, 0x04, 0x24, 0x81, 0x89, 0x01, 0x44, 0x5e, 0x0d, 0x0b, 0x24, + 0x01, 0x45, 0x92, 0xec, 0x1a, 0x24, 0x01, 0xae, 0x17, 0x45, 0xc0, 0xf0, + 0x28, 0x24, 0x01, 0xf5, 0x11, 0x24, 0x81, 0x06, 0x51, 0xab, 0x61, 0x40, + 0x24, 0x41, 0x4d, 0xb8, 0x30, 0x6b, 0x24, 0x41, 0x90, 0x4b, 0x91, 0x2f, + 0x42, 0xb7, 0xed, 0x3b, 0x26, 0x01, 0x93, 0x18, 0x42, 0xf9, 0xfa, 0x7e, + 0x25, 0x01, 0x95, 0x01, 0xff, 0xd1, 0x9f, 0x25, 0x81, 0x04, 0xd2, 0xe5, + 0x25, 0x41, 0x45, 0x67, 0x3d, 0x71, 0x26, 0x41, 0xd4, 0x70, 0x25, 0x81, + 0x04, 0xd6, 0x1b, 0x26, 0x41, 0x45, 0x67, 0x3d, 0x64, 0x26, 0x41, 0xd4, + 0x67, 0x25, 0x81, 0x0f, 0xd8, 0xf9, 0x25, 0x01, 0xd9, 0x10, 0x26, 0xc1, + 0x00, 0x45, 0x67, 0x3d, 0x80, 0x26, 0x41, 0x45, 0x67, 0x3d, 0x5b, 0x26, + 0x41, 0xd1, 0x55, 0x25, 0x81, 0x0c, 0xd2, 0xc3, 0x25, 0x01, 0xd6, 0xd6, + 0x25, 0x01, 0xd8, 0x5e, 0x25, 0x41, 0x45, 0x67, 0x3d, 0x51, 0x26, 0x41, + 0x45, 0x35, 0x63, 0x4e, 0x24, 0x41, 0x44, 0x5e, 0x0d, 0x32, 0x24, 0x01, + 0x43, 0x99, 0x14, 0x33, 0x24, 0x41, 0x43, 0xf9, 0x03, 0x05, 0x24, 0x81, + 0x96, 0x01, 0x44, 0x5e, 0x0d, 0x0c, 0x24, 0x01, 0x45, 0x92, 0xec, 0x1b, + 0x24, 0x01, 0xae, 0x24, 0x45, 0xc0, 0xf0, 0x29, 0x24, 0x01, 0xf5, 0x12, + 0x24, 0x81, 0x13, 0x11, 0xbc, 0x61, 0x01, 0xff, 0x80, 0x04, 0xd3, 0x41, + 0x24, 0x41, 0xe1, 0x42, 0x24, 0x01, 0xe2, 0x43, 0x24, 0x41, 0x4d, 0xb8, + 0x30, 0x6c, 0x24, 0x41, 0x90, 0x4b, 0x91, 0x2f, 0x42, 0xb7, 0xed, 0x3c, + 0x26, 0x01, 0x93, 0x18, 0x42, 0xf9, 0xfa, 0x7f, 0x25, 0x01, 0x95, 0x01, + 0xff, 0xd1, 0xa0, 0x25, 0x81, 0x04, 0xd2, 0xe6, 0x25, 0x41, 0x45, 0x67, + 0x3d, 0x72, 0x26, 0x41, 0xd4, 0x71, 0x25, 0x81, 0x04, 0xd6, 0x1c, 0x26, + 0x41, 0x45, 0x67, 0x3d, 0x65, 0x26, 0x41, 0xd4, 0x68, 0x25, 0x81, 0x0f, + 0xd8, 0xfa, 0x25, 0x01, 0xd9, 0x11, 0x26, 0xc1, 0x00, 0x45, 0x67, 0x3d, + 0x81, 0x26, 0x41, 0x45, 0x67, 0x3d, 0x5c, 0x26, 0x41, 0xd1, 0x56, 0x25, + 0x81, 0x0c, 0xd2, 0xc4, 0x25, 0x01, 0xd6, 0xd7, 0x25, 0x01, 0xd8, 0x5f, + 0x25, 0x41, 0x45, 0x67, 0x3d, 0x52, 0x26, 0x41, 0x45, 0x35, 0x63, 0x6f, + 0x24, 0x41, 0x10, 0x5a, 0x67, 0x93, 0x04, 0x03, 0xef, 0x07, 0x01, 0xff, + 0xa2, 0xf1, 0x03, 0xa5, 0xd1, 0x03, 0x04, 0x34, 0x90, 0xc4, 0x03, 0x05, + 0x22, 0x00, 0xb3, 0x03, 0xae, 0x2d, 0x08, 0x04, 0x03, 0x17, 0x45, 0xca, + 0xf0, 0x2c, 0x24, 0x01, 0x06, 0xca, 0x8d, 0x01, 0xff, 0x44, 0x5e, 0x0d, + 0x5a, 0x24, 0x01, 0x4e, 0xab, 0x61, 0x5d, 0x24, 0x41, 0x43, 0xf9, 0x03, + 0x60, 0x24, 0x01, 0x43, 0x94, 0x84, 0x63, 0x24, 0x01, 0x57, 0xae, 0x30, + 0x8a, 0x25, 0x41, 0x90, 0xb9, 0x02, 0x91, 0x90, 0x02, 0x92, 0xbb, 0x01, + 0x93, 0x5d, 0x94, 0x23, 0x95, 0x06, 0x42, 0x03, 0xfb, 0xe9, 0x25, 0x41, + 0xd0, 0x82, 0x25, 0x01, 0xd1, 0x9a, 0x25, 0x81, 0x0c, 0xd2, 0xe0, 0x25, + 0x01, 0xd4, 0xa3, 0x25, 0x01, 0xd6, 0xa8, 0x25, 0x41, 0x45, 0x67, 0x3d, + 0x6c, 0x26, 0x41, 0xd0, 0xeb, 0x25, 0x01, 0xd1, 0x02, 0x26, 0x01, 0x92, + 0x26, 0xd5, 0x79, 0x25, 0x81, 0x17, 0xd6, 0x14, 0x26, 0x81, 0x0c, 0xd7, + 0x3f, 0x26, 0x01, 0xd8, 0x74, 0x25, 0x01, 0xd9, 0x1f, 0x26, 0x41, 0x45, + 0x67, 0x3d, 0x84, 0x26, 0x41, 0x45, 0x67, 0x3d, 0x68, 0x26, 0x01, 0xe1, + 0xfd, 0x25, 0x41, 0xe1, 0x29, 0x26, 0x01, 0xe2, 0x2d, 0x26, 0x41, 0x90, + 0x40, 0xd1, 0xb3, 0x25, 0x01, 0xd2, 0xb4, 0x25, 0x01, 0xd3, 0xb5, 0x25, + 0x01, 0xd4, 0x6b, 0x25, 0x81, 0x22, 0xd5, 0xcc, 0x25, 0x01, 0xd6, 0x16, + 0x26, 0x81, 0x13, 0xd7, 0x41, 0x26, 0x01, 0xd8, 0xdf, 0x25, 0x01, 0x99, + 0x01, 0xff, 0xe1, 0xb6, 0x25, 0x01, 0xe2, 0xba, 0x25, 0x41, 0x45, 0x67, + 0x3d, 0x86, 0x26, 0x41, 0x45, 0x67, 0x3d, 0x5f, 0x26, 0xc1, 0x00, 0x45, + 0x35, 0x63, 0x75, 0x26, 0x41, 0xe1, 0xaf, 0x25, 0x81, 0x11, 0xe3, 0xb0, + 0x25, 0x81, 0x08, 0xe4, 0xb1, 0x25, 0x01, 0xe5, 0xb2, 0x25, 0x41, 0xe3, + 0x28, 0x26, 0x41, 0xe3, 0x27, 0x26, 0x41, 0xd0, 0x36, 0x26, 0x01, 0xd1, + 0xda, 0x25, 0x01, 0xd2, 0x8c, 0x25, 0x81, 0x3f, 0xd4, 0xaa, 0x25, 0x81, + 0x32, 0xd5, 0x23, 0x26, 0x01, 0xd6, 0xab, 0x25, 0x81, 0x25, 0xd7, 0x24, + 0x26, 0x01, 0xd8, 0xac, 0x25, 0x81, 0x14, 0x99, 0x01, 0xff, 0xe1, 0xad, + 0x25, 0x81, 0x04, 0xe2, 0xae, 0x25, 0x41, 0xe2, 0x01, 0x26, 0x01, 0xe3, + 0x26, 0x26, 0x41, 0xe2, 0x00, 0x26, 0x01, 0xe3, 0x25, 0x26, 0x41, 0xe2, + 0xff, 0x25, 0x41, 0xe1, 0xea, 0x25, 0x01, 0xe2, 0xfe, 0x25, 0x41, 0x45, + 0x67, 0x3d, 0x6a, 0x26, 0x41, 0xd1, 0x44, 0x26, 0x01, 0xd2, 0x45, 0x26, + 0x01, 0xd4, 0x62, 0x25, 0x81, 0x13, 0xd5, 0xc7, 0x25, 0x01, 0xd8, 0xf4, + 0x25, 0x01, 0xd9, 0x0b, 0x26, 0xc1, 0x00, 0x45, 0x67, 0x3d, 0x7b, 0x26, + 0x41, 0x45, 0x67, 0x3d, 0x56, 0x26, 0x41, 0xd1, 0x50, 0x25, 0x81, 0x34, + 0xd2, 0xbe, 0x25, 0x01, 0xd3, 0xef, 0x25, 0x01, 0xd4, 0x06, 0x26, 0x81, + 0x21, 0xd5, 0x31, 0x26, 0x01, 0xd6, 0xd1, 0x25, 0x01, 0x97, 0x0f, 0xd8, + 0x59, 0x25, 0x81, 0x04, 0xd9, 0x43, 0x26, 0x41, 0x45, 0x67, 0x3d, 0x55, + 0x26, 0x41, 0xe1, 0x46, 0x26, 0x01, 0xe2, 0x49, 0x26, 0x41, 0x45, 0x67, + 0x3d, 0x76, 0x26, 0x41, 0x80, 0x01, 0xff, 0x44, 0x3c, 0x2a, 0x4c, 0x26, + 0x01, 0x48, 0x26, 0x14, 0x89, 0x25, 0x41, 0x43, 0x94, 0x84, 0x64, 0x24, + 0x01, 0x57, 0xae, 0x30, 0x8b, 0x25, 0x41, 0xd2, 0x15, 0x24, 0x01, 0xf5, + 0x1e, 0x24, 0x41, 0x06, 0x7f, 0x0b, 0x06, 0x44, 0x11, 0xec, 0x58, 0x24, + 0x41, 0x43, 0xf9, 0x03, 0x5f, 0x24, 0x01, 0x4a, 0xae, 0x30, 0x87, 0x25, + 0xc1, 0x00, 0x4d, 0xb8, 0x30, 0x88, 0x25, 0x41, 0x43, 0x42, 0x63, 0x4f, + 0x24, 0x81, 0x0d, 0x43, 0x36, 0xb0, 0x34, 0x24, 0xc1, 0x00, 0x47, 0xb1, + 0x30, 0x8e, 0x25, 0x41, 0x47, 0xb1, 0x30, 0x93, 0x25, 0x41, 0x47, 0x2a, + 0x01, 0x62, 0x24, 0x01, 0x45, 0x08, 0x24, 0x61, 0x24, 0x41, 0x04, 0xe0, + 0xf5, 0xbf, 0x01, 0xae, 0x01, 0xff, 0x13, 0x30, 0x4b, 0xab, 0x01, 0x02, + 0x60, 0x00, 0x01, 0xff, 0x43, 0xf9, 0x03, 0x07, 0x24, 0x81, 0x98, 0x01, + 0x44, 0x5e, 0x0d, 0x0e, 0x24, 0x01, 0x45, 0x92, 0xec, 0x1d, 0x24, 0x01, + 0xae, 0x26, 0x45, 0xc0, 0xf0, 0x2b, 0x24, 0x01, 0xf5, 0x14, 0x24, 0x81, + 0x15, 0x53, 0xc1, 0x50, 0x46, 0x24, 0xc1, 0x00, 0x42, 0x19, 0x00, 0x49, + 0x24, 0x01, 0xd3, 0x47, 0x24, 0x01, 0xd4, 0x48, 0x24, 0x41, 0x4d, 0xb8, + 0x30, 0x6e, 0x24, 0x41, 0x90, 0x4b, 0x91, 0x2f, 0x42, 0xb7, 0xed, 0x3e, + 0x26, 0x01, 0x93, 0x18, 0x42, 0xf9, 0xfa, 0x81, 0x25, 0x01, 0x95, 0x01, + 0xff, 0xd1, 0xa2, 0x25, 0x81, 0x04, 0xd2, 0xe8, 0x25, 0x41, 0x45, 0x67, + 0x3d, 0x74, 0x26, 0x41, 0xd4, 0x73, 0x25, 0x81, 0x04, 0xd6, 0x1e, 0x26, + 0x41, 0x45, 0x67, 0x3d, 0x67, 0x26, 0x41, 0xd4, 0x6a, 0x25, 0x81, 0x0f, + 0xd8, 0xfc, 0x25, 0x01, 0xd9, 0x13, 0x26, 0xc1, 0x00, 0x45, 0x67, 0x3d, + 0x83, 0x26, 0x41, 0x45, 0x67, 0x3d, 0x5e, 0x26, 0x41, 0xd1, 0x58, 0x25, + 0x81, 0x0c, 0xd2, 0xc6, 0x25, 0x01, 0xd6, 0xd9, 0x25, 0x01, 0xd8, 0x61, + 0x25, 0x41, 0x45, 0x67, 0x3d, 0x54, 0x26, 0x41, 0x45, 0x35, 0x63, 0x76, + 0x24, 0x41, 0x4e, 0x0c, 0x7e, 0x98, 0x25, 0x01, 0x4e, 0x70, 0x81, 0x99, + 0x25, 0x41, 0x43, 0x14, 0x5d, 0x57, 0x24, 0x01, 0x43, 0x99, 0x14, 0x56, + 0x24, 0x41, 0x04, 0xf9, 0x05, 0xab, 0x02, 0x04, 0xf6, 0x06, 0x01, 0xff, + 0x43, 0xf9, 0x03, 0x02, 0x24, 0x81, 0x98, 0x02, 0xa2, 0xf2, 0x01, 0x44, + 0x5e, 0x0d, 0x09, 0x24, 0x01, 0x04, 0x34, 0x90, 0xdf, 0x01, 0xae, 0x2c, + 0x04, 0x81, 0x1a, 0x20, 0xf5, 0x0f, 0x24, 0x81, 0x15, 0x52, 0xf1, 0x58, + 0x3c, 0x24, 0xc1, 0x00, 0x80, 0x04, 0xd4, 0x3d, 0x24, 0x41, 0xe1, 0x3e, + 0x24, 0x01, 0xe2, 0x3f, 0x24, 0x41, 0x4d, 0xb8, 0x30, 0x69, 0x24, 0x41, + 0xd2, 0x26, 0x24, 0x01, 0xf5, 0x30, 0x24, 0x41, 0x90, 0x84, 0x01, 0x91, + 0x64, 0x92, 0x5a, 0x93, 0x3a, 0x94, 0x1a, 0x95, 0x01, 0xff, 0xd0, 0x85, + 0x25, 0x01, 0xd1, 0x9d, 0x25, 0x81, 0x08, 0xd2, 0xe3, 0x25, 0x01, 0xd4, + 0xa6, 0x25, 0x41, 0x45, 0x67, 0x3d, 0x6f, 0x26, 0x41, 0xd0, 0xee, 0x25, + 0x01, 0xd1, 0x05, 0x26, 0x01, 0x92, 0x0c, 0xd5, 0x7c, 0x25, 0x01, 0xd8, + 0x77, 0x25, 0x01, 0xd9, 0x22, 0x26, 0x41, 0xe1, 0x2c, 0x26, 0x01, 0xe2, + 0x30, 0x26, 0x41, 0xd4, 0x6e, 0x25, 0x81, 0x13, 0xd5, 0xcf, 0x25, 0x01, + 0xd6, 0x19, 0x26, 0x01, 0x99, 0x01, 0xff, 0xe1, 0xb9, 0x25, 0x01, 0xe2, + 0xbd, 0x25, 0x41, 0x45, 0x67, 0x3d, 0x62, 0x26, 0x41, 0xd0, 0x39, 0x26, + 0x01, 0xd1, 0xdd, 0x25, 0x41, 0xd4, 0x65, 0x25, 0x81, 0x13, 0xd5, 0xca, + 0x25, 0x01, 0xd8, 0xf7, 0x25, 0x01, 0xd9, 0x0e, 0x26, 0xc1, 0x00, 0x45, + 0x67, 0x3d, 0x7e, 0x26, 0x41, 0x45, 0x67, 0x3d, 0x59, 0x26, 0x41, 0xd1, + 0x53, 0x25, 0x81, 0x1f, 0xd2, 0xc1, 0x25, 0x01, 0xd3, 0xf2, 0x25, 0x01, + 0xd4, 0x09, 0x26, 0x81, 0x0c, 0xd5, 0x34, 0x26, 0x01, 0xd6, 0xd4, 0x25, + 0x01, 0xd8, 0x5c, 0x25, 0x41, 0x45, 0x67, 0x3d, 0x79, 0x26, 0x41, 0x45, + 0x67, 0x3d, 0x4f, 0x26, 0x41, 0xd2, 0x18, 0x24, 0x01, 0xf5, 0x21, 0x24, + 0x41, 0x43, 0x42, 0x63, 0x52, 0x24, 0x81, 0x0d, 0x43, 0x36, 0xb0, 0x38, + 0x24, 0xc1, 0x00, 0x47, 0xb1, 0x30, 0x91, 0x25, 0x41, 0x80, 0x01, 0xff, + 0x46, 0xb2, 0x30, 0x96, 0x25, 0x01, 0x4c, 0xb9, 0x30, 0x53, 0x24, 0x41, + 0x45, 0x35, 0x63, 0x4c, 0x24, 0x41, 0x43, 0xf9, 0x03, 0x03, 0x24, 0x81, + 0xe9, 0x01, 0xa2, 0xc3, 0x01, 0x44, 0x5e, 0x0d, 0x0a, 0x24, 0x01, 0x04, + 0x34, 0x90, 0xb0, 0x01, 0xae, 0x1f, 0xb3, 0x0b, 0xf5, 0x10, 0x24, 0xc1, + 0x00, 0x4d, 0xb8, 0x30, 0x6a, 0x24, 0x41, 0x03, 0xc9, 0x02, 0x06, 0x4a, + 0xa4, 0xb1, 0x5c, 0x24, 0x41, 0xd2, 0x27, 0x24, 0x01, 0xf5, 0x31, 0x24, + 0x41, 0x90, 0x63, 0x91, 0x43, 0x92, 0x39, 0x93, 0x24, 0x94, 0x1a, 0x95, + 0x01, 0xff, 0xd0, 0x86, 0x25, 0x01, 0xd1, 0x9e, 0x25, 0x81, 0x08, 0xd2, + 0xe4, 0x25, 0x01, 0xd4, 0xa7, 0x25, 0x41, 0x45, 0x67, 0x3d, 0x70, 0x26, + 0x41, 0xd5, 0x7d, 0x25, 0x01, 0xd8, 0x78, 0x25, 0x41, 0xd4, 0x6f, 0x25, + 0x81, 0x08, 0xd5, 0xd0, 0x25, 0x01, 0xd6, 0x1a, 0x26, 0x41, 0x45, 0x67, + 0x3d, 0x63, 0x26, 0x41, 0xd0, 0x3a, 0x26, 0x01, 0xd1, 0xde, 0x25, 0x41, + 0xd4, 0x66, 0x25, 0x81, 0x13, 0xd5, 0xcb, 0x25, 0x01, 0xd8, 0xf8, 0x25, + 0x01, 0xd9, 0x0f, 0x26, 0xc1, 0x00, 0x45, 0x67, 0x3d, 0x7f, 0x26, 0x41, + 0x45, 0x67, 0x3d, 0x5a, 0x26, 0x41, 0xd1, 0x54, 0x25, 0x81, 0x1f, 0xd2, + 0xc2, 0x25, 0x01, 0xd3, 0xf3, 0x25, 0x01, 0xd4, 0x0a, 0x26, 0x81, 0x0c, + 0xd5, 0x35, 0x26, 0x01, 0xd6, 0xd5, 0x25, 0x01, 0xd8, 0x5d, 0x25, 0x41, + 0x45, 0x67, 0x3d, 0x7a, 0x26, 0x41, 0x45, 0x67, 0x3d, 0x50, 0x26, 0x41, + 0xd2, 0x19, 0x24, 0x01, 0xf5, 0x22, 0x24, 0x41, 0x43, 0x42, 0x63, 0x54, + 0x24, 0x81, 0x0d, 0x43, 0x36, 0xb0, 0x39, 0x24, 0xc1, 0x00, 0x47, 0xb1, + 0x30, 0x92, 0x25, 0x41, 0x80, 0x01, 0xff, 0x46, 0xb2, 0x30, 0x97, 0x25, + 0x01, 0x4c, 0xb9, 0x30, 0x55, 0x24, 0x41, 0x45, 0x35, 0x63, 0x4d, 0x24, + 0x41, 0x05, 0xc9, 0x00, 0x1f, 0x07, 0x87, 0xd8, 0x01, 0xff, 0xa6, 0x0c, + 0x49, 0xe7, 0xc2, 0x65, 0x24, 0x01, 0x4a, 0xee, 0xb7, 0x66, 0x24, 0x41, + 0x44, 0x03, 0x24, 0x68, 0x24, 0x01, 0x44, 0x3c, 0x54, 0x67, 0x24, 0x41, + 0x43, 0xf9, 0x03, 0x06, 0x24, 0x81, 0x8e, 0x01, 0x44, 0x5e, 0x0d, 0x0d, + 0x24, 0x01, 0x45, 0x92, 0xec, 0x1c, 0x24, 0x01, 0xae, 0x1c, 0x45, 0xc0, + 0xf0, 0x2a, 0x24, 0x01, 0xf5, 0x13, 0x24, 0x81, 0x0b, 0x51, 0xcd, 0x61, + 0x44, 0x24, 0xc1, 0x00, 0xd3, 0x45, 0x24, 0x41, 0x4d, 0xb8, 0x30, 0x6d, + 0x24, 0x41, 0x90, 0x4b, 0x91, 0x2f, 0x42, 0xb7, 0xed, 0x3d, 0x26, 0x01, + 0x93, 0x18, 0x42, 0xf9, 0xfa, 0x80, 0x25, 0x01, 0x95, 0x01, 0xff, 0xd1, + 0xa1, 0x25, 0x81, 0x04, 0xd2, 0xe7, 0x25, 0x41, 0x45, 0x67, 0x3d, 0x73, + 0x26, 0x41, 0xd4, 0x72, 0x25, 0x81, 0x04, 0xd6, 0x1d, 0x26, 0x41, 0x45, + 0x67, 0x3d, 0x66, 0x26, 0x41, 0xd4, 0x69, 0x25, 0x81, 0x0f, 0xd8, 0xfb, + 0x25, 0x01, 0xd9, 0x12, 0x26, 0xc1, 0x00, 0x45, 0x67, 0x3d, 0x82, 0x26, + 0x41, 0x45, 0x67, 0x3d, 0x5d, 0x26, 0x41, 0xd1, 0x57, 0x25, 0x81, 0x0c, + 0xd2, 0xc5, 0x25, 0x01, 0xd6, 0xd8, 0x25, 0x01, 0xd8, 0x60, 0x25, 0x41, + 0x45, 0x67, 0x3d, 0x53, 0x26, 0x41, 0x45, 0x35, 0x63, 0x75, 0x24, 0x41, + 0x4f, 0xcc, 0x6f, 0x7e, 0x24, 0x01, 0xa6, 0x29, 0x4e, 0xc6, 0x7d, 0x7f, + 0x24, 0x01, 0x4d, 0x40, 0x8b, 0x77, 0x24, 0x01, 0xb3, 0x0f, 0xb4, 0x01, + 0xff, 0x4e, 0xd5, 0x76, 0x79, 0x24, 0x01, 0x4c, 0x08, 0x9c, 0x78, 0x24, + 0x41, 0x4e, 0x26, 0x7b, 0x7d, 0x24, 0x01, 0x4c, 0x30, 0x95, 0x7c, 0x24, + 0x41, 0x4d, 0xb6, 0x88, 0x7b, 0x24, 0x01, 0x4d, 0x9b, 0x8b, 0x7a, 0x24, + 0x41, 0xa1, 0xb0, 0x01, 0xa5, 0xa1, 0x01, 0x45, 0x7e, 0x7c, 0x97, 0xf9, + 0x81, 0x93, 0x01, 0xaf, 0x27, 0xb5, 0x19, 0xb9, 0x01, 0xff, 0x04, 0xa1, + 0x01, 0x06, 0x49, 0x39, 0xc5, 0x2e, 0xf5, 0x41, 0x48, 0x85, 0x20, 0x3f, + 0xf6, 0x01, 0x44, 0x0c, 0x08, 0x22, 0xf6, 0x41, 0x43, 0xb9, 0x22, 0x7c, + 0xfa, 0x01, 0x4a, 0xa6, 0xb9, 0xa2, 0x20, 0x40, 0x46, 0x9c, 0xe0, 0x0a, + 0xf4, 0x01, 0x46, 0x06, 0xe3, 0x50, 0xf9, 0x01, 0x02, 0xee, 0x00, 0x06, + 0x42, 0xa7, 0x01, 0x51, 0xf4, 0x41, 0x80, 0x1c, 0x03, 0x05, 0x00, 0x06, + 0x49, 0x32, 0xc0, 0xcc, 0x26, 0x40, 0x45, 0x5b, 0xec, 0x8c, 0xf3, 0x01, + 0x67, 0xf4, 0x05, 0x8a, 0xf1, 0x01, 0x46, 0x42, 0xe6, 0x94, 0x26, 0x40, + 0x44, 0xb9, 0x00, 0x4c, 0x27, 0x00, 0x03, 0xf4, 0x01, 0x20, 0xb0, 0x01, + 0xff, 0x0a, 0x6c, 0xad, 0x0d, 0x45, 0x35, 0xe5, 0x42, 0xf5, 0xc1, 0x00, + 0x57, 0x41, 0x2e, 0x41, 0xf5, 0x41, 0x4d, 0x2b, 0x89, 0x51, 0x2e, 0x00, + 0x4e, 0x86, 0x7f, 0x50, 0x2e, 0x40, 0x49, 0x9e, 0xc0, 0x29, 0x26, 0x00, + 0x48, 0x97, 0xcd, 0x28, 0x26, 0x40, 0x4d, 0x2d, 0x83, 0xcf, 0xf3, 0x41, + 0x48, 0xd7, 0xca, 0xb3, 0xf4, 0x01, 0x4a, 0x66, 0x43, 0x19, 0xf3, 0x41, + 0xe2, 0x80, 0xf9, 0x01, 0x4a, 0x16, 0xae, 0xeb, 0xfa, 0x41, 0x42, 0x8a, + 0x00, 0xe5, 0xf9, 0x01, 0xa3, 0xdd, 0x25, 0x44, 0xac, 0xf5, 0xb0, 0x26, + 0x00, 0x42, 0x9e, 0x01, 0x99, 0xfa, 0x01, 0xac, 0xb2, 0x25, 0xad, 0xbd, + 0x0c, 0xae, 0xad, 0x0b, 0x02, 0x55, 0x05, 0x95, 0x0b, 0xb0, 0xcb, 0x01, + 0xb2, 0xb6, 0x01, 0xb5, 0x0b, 0xf7, 0x04, 0xf4, 0xc1, 0x00, 0x45, 0x0b, + 0x08, 0x2e, 0xf4, 0x41, 0x4b, 0x27, 0x9f, 0xcb, 0xf6, 0x01, 0x02, 0x11, + 0x00, 0x06, 0x4e, 0xec, 0x7e, 0x91, 0xf4, 0x41, 0x02, 0x33, 0x00, 0x88, + 0x01, 0x08, 0xc7, 0xcc, 0x01, 0xff, 0x0b, 0x85, 0xa8, 0x42, 0x0b, 0xa3, + 0xa9, 0x01, 0xff, 0x45, 0x7e, 0x0b, 0x67, 0xd3, 0x01, 0xa6, 0x29, 0x44, + 0x6d, 0x2c, 0x68, 0xd3, 0x01, 0x43, 0x7a, 0x0b, 0x60, 0xd3, 0x01, 0xb3, + 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0x62, 0xd3, 0x01, 0x42, 0x15, + 0x02, 0x61, 0xd3, 0x41, 0x44, 0x06, 0x1f, 0x66, 0xd3, 0x01, 0x42, 0x09, + 0x24, 0x65, 0xd3, 0x41, 0x43, 0xf9, 0x05, 0x64, 0xd3, 0x01, 0x43, 0xf6, + 0x06, 0x63, 0xd3, 0x41, 0x45, 0x7e, 0x0b, 0x70, 0xd3, 0x01, 0xa6, 0x29, + 0x44, 0x6d, 0x2c, 0x71, 0xd3, 0x01, 0x43, 0x7a, 0x0b, 0x69, 0xd3, 0x01, + 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0x6b, 0xd3, 0x01, 0x42, + 0x15, 0x02, 0x6a, 0xd3, 0x41, 0x44, 0x06, 0x1f, 0x6f, 0xd3, 0x01, 0x42, + 0x09, 0x24, 0x6e, 0xd3, 0x41, 0x43, 0xf9, 0x05, 0x6d, 0xd3, 0x01, 0x43, + 0xf6, 0x06, 0x6c, 0xd3, 0x41, 0x44, 0x2c, 0xf5, 0x34, 0x23, 0x00, 0x44, + 0xa8, 0xf8, 0x35, 0x23, 0x40, 0x42, 0x13, 0x00, 0xb8, 0xfa, 0x01, 0x52, + 0x33, 0x56, 0x4f, 0x2e, 0x00, 0x4b, 0x1a, 0xa7, 0x58, 0x22, 0x40, 0x04, + 0x49, 0x21, 0x0f, 0xb9, 0x01, 0xff, 0x4b, 0xcb, 0xa3, 0x2f, 0xf1, 0x01, + 0x4a, 0xf0, 0xb5, 0xa9, 0x00, 0x40, 0xa3, 0xed, 0x05, 0x06, 0x44, 0xe1, + 0x90, 0x04, 0xa6, 0x81, 0x04, 0x55, 0x21, 0x3f, 0xff, 0x2c, 0x00, 0x0b, + 0xc5, 0xa5, 0xde, 0x03, 0xb3, 0x01, 0xff, 0x0c, 0x9c, 0x08, 0x33, 0x06, + 0x2e, 0x17, 0x01, 0xff, 0xab, 0x20, 0x45, 0x95, 0xee, 0xe5, 0x2c, 0x00, + 0x45, 0xda, 0xef, 0xe6, 0x2c, 0x00, 0xb3, 0x06, 0x46, 0x72, 0xe6, 0xe8, + 0x2c, 0x40, 0x49, 0x36, 0xbf, 0xea, 0x2c, 0x00, 0x46, 0x78, 0xe6, 0xe7, + 0x2c, 0x40, 0x42, 0x56, 0x07, 0xe4, 0x2c, 0x00, 0x45, 0x44, 0xd0, 0xe9, + 0x2c, 0x40, 0xa1, 0x95, 0x03, 0x4d, 0x42, 0x85, 0xf3, 0x2c, 0x00, 0x02, + 0x75, 0x06, 0xe7, 0x02, 0xa4, 0xbb, 0x02, 0x43, 0x30, 0xfa, 0x89, 0x2c, + 0x00, 0xa6, 0xa8, 0x02, 0x02, 0x24, 0x02, 0x97, 0x02, 0xa8, 0x88, 0x02, + 0x45, 0x32, 0xed, 0x93, 0x2c, 0x00, 0xab, 0xe7, 0x01, 0xac, 0xd8, 0x01, + 0x42, 0x7d, 0x02, 0x99, 0x2c, 0x00, 0x42, 0x51, 0x03, 0x9b, 0x2c, 0x00, + 0xef, 0x9f, 0x2c, 0x80, 0x54, 0xb0, 0x48, 0x42, 0xd0, 0x00, 0xa3, 0x2c, + 0x00, 0xb3, 0x20, 0xb4, 0x12, 0x42, 0x7d, 0x00, 0xa9, 0x2c, 0x00, 0x44, + 0x00, 0xf9, 0x83, 0x2c, 0x00, 0x44, 0x54, 0xf9, 0x8d, 0x2c, 0x40, 0x42, + 0xb4, 0x25, 0xa7, 0x2c, 0x00, 0x45, 0xec, 0xec, 0x91, 0x2c, 0x40, 0x44, + 0x28, 0x99, 0xc1, 0x2c, 0x00, 0xa8, 0x0c, 0x43, 0x71, 0x0d, 0xa5, 0x2c, + 0x00, 0x42, 0x3c, 0x01, 0x8b, 0x2c, 0x40, 0x42, 0x7e, 0x0b, 0xe3, 0x03, + 0x00, 0x43, 0x71, 0x0d, 0xed, 0x03, 0x40, 0xe9, 0xa1, 0x2c, 0x00, 0x42, + 0x5a, 0x03, 0xaf, 0x2c, 0x40, 0x03, 0x58, 0x25, 0x06, 0x42, 0x3c, 0x01, + 0xb1, 0x2c, 0x40, 0x07, 0xd9, 0xd5, 0x1f, 0x07, 0xc9, 0xa5, 0x01, 0xff, + 0xae, 0x0c, 0x45, 0xcf, 0xf0, 0xdd, 0x2c, 0x00, 0x43, 0x54, 0xa9, 0xe3, + 0x2c, 0x40, 0x42, 0xf1, 0x06, 0xdf, 0x2c, 0x00, 0x42, 0xa0, 0x1b, 0xe1, + 0x2c, 0x40, 0x43, 0x56, 0x07, 0xb5, 0x2c, 0x00, 0x43, 0x21, 0xfa, 0xd9, + 0x2c, 0x00, 0x43, 0x14, 0x5d, 0xc7, 0x2c, 0x00, 0x46, 0xce, 0xe1, 0xd7, + 0x2c, 0x00, 0xa8, 0x17, 0x43, 0x6b, 0x98, 0xbf, 0x2c, 0x00, 0x02, 0xa4, + 0x02, 0x01, 0xff, 0x42, 0x7e, 0x0b, 0xc5, 0x2c, 0x00, 0x43, 0x71, 0x0d, + 0xdb, 0x2c, 0x40, 0xe1, 0xcf, 0x2c, 0x80, 0x0c, 0x42, 0x7e, 0x0b, 0xd3, + 0x2c, 0x00, 0x43, 0x0c, 0x00, 0xcd, 0x2c, 0x40, 0xf4, 0xd5, 0x2c, 0x40, + 0x4a, 0x04, 0xac, 0xd1, 0x2c, 0x00, 0x44, 0x08, 0xf5, 0x97, 0x2c, 0x40, + 0x43, 0x9e, 0x3f, 0x95, 0x2c, 0x00, 0xa8, 0x06, 0x42, 0x5a, 0x03, 0x9d, + 0x2c, 0x40, 0x42, 0x7e, 0x0b, 0xe7, 0x03, 0x00, 0xe9, 0xad, 0x2c, 0x40, + 0x43, 0x8a, 0x00, 0x8f, 0x2c, 0x00, 0x43, 0x0c, 0x00, 0xe9, 0x03, 0x40, + 0x43, 0x15, 0x05, 0x85, 0x2c, 0x00, 0x44, 0xd0, 0xe1, 0xeb, 0x03, 0x40, + 0x42, 0x7e, 0x0b, 0xe5, 0x03, 0x00, 0xe9, 0xab, 0x2c, 0x40, 0x44, 0xd8, + 0xf4, 0x87, 0x2c, 0x00, 0x42, 0x7e, 0x0b, 0xef, 0x03, 0x00, 0x09, 0x87, + 0xbf, 0x01, 0xff, 0x44, 0x67, 0x00, 0xb3, 0x2c, 0x00, 0x44, 0x0b, 0x00, + 0xcb, 0x2c, 0x00, 0x44, 0x85, 0xcf, 0xb9, 0x2c, 0x00, 0x42, 0x51, 0x03, + 0xbb, 0x2c, 0x40, 0x4a, 0xb0, 0xb4, 0xc3, 0x2c, 0x00, 0x0c, 0x42, 0x26, + 0x01, 0xff, 0x43, 0x30, 0xfa, 0xb7, 0x2c, 0x00, 0x46, 0xce, 0xe1, 0xee, + 0x2c, 0x00, 0x42, 0x51, 0x03, 0xbd, 0x2c, 0x00, 0x44, 0xb6, 0xb4, 0xec, + 0x2c, 0x40, 0x4c, 0x60, 0x95, 0xc9, 0x2c, 0x00, 0x43, 0x66, 0xfa, 0x81, + 0x2c, 0x40, 0x54, 0x81, 0x36, 0xfa, 0x2c, 0x00, 0x49, 0x4f, 0x17, 0xf9, + 0x2c, 0x00, 0x56, 0x7f, 0x36, 0xfb, 0x2c, 0x00, 0x4d, 0x38, 0x56, 0xfc, + 0x2c, 0x40, 0x50, 0xa0, 0x5c, 0xfd, 0x2c, 0x00, 0x48, 0x50, 0x17, 0xfe, + 0x2c, 0x40, 0x06, 0xef, 0x06, 0x96, 0x01, 0x07, 0x37, 0x3c, 0x06, 0x4e, + 0xc8, 0x80, 0xe0, 0x02, 0x41, 0x05, 0x7e, 0x0b, 0x7e, 0xa6, 0x5f, 0x04, + 0x6d, 0x2c, 0x4f, 0x4b, 0x3b, 0x12, 0xf3, 0x02, 0x01, 0xb3, 0x26, 0xb4, + 0x01, 0xff, 0x42, 0x92, 0x01, 0xea, 0x02, 0x01, 0xa8, 0x0f, 0xb7, 0x01, + 0xff, 0x44, 0xe9, 0x1e, 0xeb, 0x02, 0x01, 0x49, 0xfb, 0x1e, 0xf4, 0x02, + 0x41, 0x44, 0x49, 0x12, 0xec, 0x02, 0x01, 0x4b, 0x01, 0x19, 0xf5, 0x02, + 0x41, 0x04, 0x06, 0x1f, 0x11, 0x02, 0x09, 0x24, 0x01, 0xff, 0x48, 0x3e, + 0x12, 0xf8, 0x02, 0x01, 0x42, 0x4b, 0x12, 0xef, 0x02, 0x41, 0x48, 0x3e, + 0x12, 0xf9, 0x02, 0x01, 0x42, 0x4b, 0x12, 0xf0, 0x02, 0x41, 0x48, 0x3e, + 0x12, 0xfb, 0x02, 0x01, 0x42, 0x4b, 0x12, 0xf2, 0x02, 0x41, 0xa9, 0x0f, + 0xaf, 0x01, 0xff, 0x43, 0x4a, 0x12, 0xed, 0x02, 0x01, 0x4a, 0x8e, 0xb8, + 0xf6, 0x02, 0x41, 0x43, 0x04, 0x24, 0xee, 0x02, 0x01, 0x4a, 0xba, 0x3b, + 0xf7, 0x02, 0x41, 0x48, 0x3e, 0x12, 0xfa, 0x02, 0x01, 0xf9, 0xf1, 0x02, + 0x41, 0x45, 0x7e, 0x0b, 0xe8, 0x02, 0x01, 0xa6, 0x29, 0x44, 0x6d, 0x2c, + 0xe9, 0x02, 0x01, 0x43, 0x7a, 0x0b, 0xe1, 0x02, 0x01, 0xb3, 0x0f, 0xb4, + 0x01, 0xff, 0x44, 0x25, 0x01, 0xe3, 0x02, 0x01, 0x42, 0x15, 0x02, 0xe2, + 0x02, 0x41, 0x44, 0x06, 0x1f, 0xe7, 0x02, 0x01, 0x42, 0x09, 0x24, 0xe6, + 0x02, 0x41, 0x43, 0xf9, 0x05, 0xe5, 0x02, 0x01, 0x43, 0xf6, 0x06, 0xe4, + 0x02, 0x41, 0x0e, 0x0c, 0x06, 0x1c, 0x09, 0x01, 0x17, 0x01, 0xff, 0x48, + 0x5f, 0xce, 0xef, 0x2c, 0x00, 0x09, 0x27, 0xc5, 0x01, 0xff, 0x45, 0x76, + 0xea, 0xf0, 0x2c, 0x00, 0x45, 0x22, 0xee, 0xf1, 0x2c, 0x40, 0xa1, 0x95, + 0x03, 0x4d, 0x42, 0x85, 0xf2, 0x2c, 0x00, 0x02, 0x75, 0x06, 0xe7, 0x02, + 0xa4, 0xbb, 0x02, 0x43, 0x30, 0xfa, 0x88, 0x2c, 0x00, 0xa6, 0xa8, 0x02, + 0x02, 0x24, 0x02, 0x97, 0x02, 0xa8, 0x88, 0x02, 0x45, 0x32, 0xed, 0x92, + 0x2c, 0x00, 0xab, 0xe7, 0x01, 0xac, 0xd8, 0x01, 0x42, 0x7d, 0x02, 0x98, + 0x2c, 0x00, 0x42, 0x51, 0x03, 0x9a, 0x2c, 0x00, 0xef, 0x9e, 0x2c, 0x80, + 0x54, 0xb0, 0x48, 0x42, 0xd0, 0x00, 0xa2, 0x2c, 0x00, 0xb3, 0x20, 0xb4, + 0x12, 0x42, 0x7d, 0x00, 0xa8, 0x2c, 0x00, 0x44, 0x00, 0xf9, 0x82, 0x2c, + 0x00, 0x44, 0x54, 0xf9, 0x8c, 0x2c, 0x40, 0x42, 0xb4, 0x25, 0xa6, 0x2c, + 0x00, 0x45, 0xec, 0xec, 0x90, 0x2c, 0x40, 0x44, 0x28, 0x99, 0xc0, 0x2c, + 0x00, 0xa8, 0x0c, 0x43, 0x71, 0x0d, 0xa4, 0x2c, 0x00, 0x42, 0x3c, 0x01, + 0x8a, 0x2c, 0x40, 0x42, 0x7e, 0x0b, 0xe2, 0x03, 0x00, 0x43, 0x71, 0x0d, + 0xec, 0x03, 0x40, 0xe9, 0xa0, 0x2c, 0x00, 0x42, 0x5a, 0x03, 0xae, 0x2c, + 0x40, 0x03, 0x58, 0x25, 0x06, 0x42, 0x3c, 0x01, 0xb0, 0x2c, 0x40, 0x07, + 0xd9, 0xd5, 0x1f, 0x07, 0xc9, 0xa5, 0x01, 0xff, 0xae, 0x0c, 0x45, 0xcf, + 0xf0, 0xdc, 0x2c, 0x00, 0x43, 0x54, 0xa9, 0xe2, 0x2c, 0x40, 0x42, 0xf1, + 0x06, 0xde, 0x2c, 0x00, 0x42, 0xa0, 0x1b, 0xe0, 0x2c, 0x40, 0x43, 0x56, + 0x07, 0xb4, 0x2c, 0x00, 0x43, 0x21, 0xfa, 0xd8, 0x2c, 0x00, 0x43, 0x14, + 0x5d, 0xc6, 0x2c, 0x00, 0x46, 0xce, 0xe1, 0xd6, 0x2c, 0x00, 0xa8, 0x17, + 0x43, 0x6b, 0x98, 0xbe, 0x2c, 0x00, 0x02, 0xa4, 0x02, 0x01, 0xff, 0x42, + 0x7e, 0x0b, 0xc4, 0x2c, 0x00, 0x43, 0x71, 0x0d, 0xda, 0x2c, 0x40, 0xe1, + 0xce, 0x2c, 0x80, 0x0c, 0x42, 0x7e, 0x0b, 0xd2, 0x2c, 0x00, 0x43, 0x0c, + 0x00, 0xcc, 0x2c, 0x40, 0xf4, 0xd4, 0x2c, 0x40, 0x4a, 0x04, 0xac, 0xd0, + 0x2c, 0x00, 0x44, 0x08, 0xf5, 0x96, 0x2c, 0x40, 0x43, 0x9e, 0x3f, 0x94, + 0x2c, 0x00, 0xa8, 0x06, 0x42, 0x5a, 0x03, 0x9c, 0x2c, 0x40, 0x42, 0x7e, + 0x0b, 0xe6, 0x03, 0x00, 0xe9, 0xac, 0x2c, 0x40, 0x43, 0x8a, 0x00, 0x8e, + 0x2c, 0x00, 0x43, 0x0c, 0x00, 0xe8, 0x03, 0x40, 0x43, 0x15, 0x05, 0x84, + 0x2c, 0x00, 0x44, 0xd0, 0xe1, 0xea, 0x03, 0x40, 0x42, 0x7e, 0x0b, 0xe4, + 0x03, 0x00, 0xe9, 0xaa, 0x2c, 0x40, 0x44, 0xd8, 0xf4, 0x86, 0x2c, 0x00, + 0x42, 0x7e, 0x0b, 0xee, 0x03, 0x00, 0x09, 0x87, 0xbf, 0x01, 0xff, 0x44, + 0x67, 0x00, 0xb2, 0x2c, 0x00, 0x44, 0x0b, 0x00, 0xca, 0x2c, 0x00, 0x44, + 0x85, 0xcf, 0xb8, 0x2c, 0x00, 0x42, 0x51, 0x03, 0xba, 0x2c, 0x40, 0x4a, + 0xb0, 0xb4, 0xc2, 0x2c, 0x00, 0x0c, 0x42, 0x26, 0x01, 0xff, 0x43, 0x30, + 0xfa, 0xb6, 0x2c, 0x00, 0x46, 0xce, 0xe1, 0xed, 0x2c, 0x00, 0x42, 0x51, + 0x03, 0xbc, 0x2c, 0x00, 0x44, 0xb6, 0xb4, 0xeb, 0x2c, 0x40, 0x4c, 0x60, + 0x95, 0xc8, 0x2c, 0x00, 0x43, 0x66, 0xfa, 0x80, 0x2c, 0x40, 0x47, 0x73, + 0xd6, 0x5a, 0xf3, 0x01, 0xa9, 0x01, 0xff, 0xe5, 0x6a, 0xf3, 0x01, 0x42, + 0x1d, 0x01, 0x73, 0xf3, 0x41, 0xa6, 0x79, 0x55, 0x92, 0x3d, 0x6d, 0x2a, + 0x00, 0x4a, 0xe6, 0xb0, 0x32, 0x23, 0x00, 0x48, 0x0f, 0xcd, 0x0c, 0x26, + 0x00, 0x0a, 0x1c, 0xb7, 0x57, 0xb4, 0x06, 0x4e, 0x34, 0x82, 0xea, 0xf3, + 0x41, 0x05, 0xbc, 0x6c, 0x1d, 0x57, 0xee, 0x1b, 0x81, 0x23, 0x00, 0x4c, + 0x8e, 0x74, 0x2e, 0x22, 0x00, 0x04, 0xe4, 0x8e, 0x01, 0xff, 0x45, 0xd2, + 0xed, 0x9b, 0xf3, 0x01, 0x53, 0x45, 0x4f, 0x9b, 0x00, 0x40, 0x03, 0x4a, + 0x03, 0x17, 0x05, 0x51, 0x00, 0x01, 0xff, 0x56, 0x71, 0x37, 0xfa, 0x22, + 0x00, 0x47, 0xc2, 0x83, 0xfd, 0x22, 0x00, 0x68, 0x30, 0x05, 0xfb, 0x22, + 0x40, 0x46, 0xb4, 0x05, 0x0b, 0x22, 0x00, 0x4f, 0x45, 0x56, 0xb3, 0x22, + 0xc0, 0x00, 0x4c, 0x90, 0x2a, 0xb5, 0x22, 0x40, 0x44, 0x5a, 0x03, 0xa7, + 0xf6, 0x01, 0x46, 0x50, 0xe7, 0x77, 0xf4, 0x41, 0x49, 0x55, 0xbe, 0x8a, + 0xf3, 0x01, 0x4b, 0x3e, 0xa6, 0x16, 0xf6, 0x01, 0x49, 0x21, 0x9e, 0x15, + 0xf6, 0x41, 0x07, 0x03, 0x17, 0x48, 0x42, 0x14, 0x06, 0x04, 0x26, 0x00, + 0xad, 0x1b, 0xb0, 0x01, 0xff, 0x43, 0x40, 0x21, 0xed, 0xf9, 0x01, 0x46, + 0x1f, 0x97, 0x01, 0x22, 0x00, 0x4e, 0x6e, 0x7e, 0x84, 0x23, 0x00, 0x47, + 0x9a, 0x69, 0xdc, 0xf5, 0x41, 0xe1, 0x2c, 0x00, 0x00, 0xa5, 0x01, 0xff, + 0x4b, 0x17, 0x8a, 0x0c, 0xdb, 0x81, 0x11, 0x06, 0x20, 0xbe, 0x01, 0xff, + 0x42, 0x8a, 0x00, 0x40, 0x00, 0x00, 0x4a, 0x7b, 0x9d, 0x52, 0x20, 0x40, + 0x4a, 0x1e, 0xab, 0x0e, 0xdb, 0x41, 0xa1, 0xbb, 0x17, 0xa2, 0x8b, 0x17, + 0xa3, 0xb5, 0x13, 0xa4, 0xba, 0x0f, 0xa5, 0xf5, 0x0e, 0xa6, 0xe0, 0x0e, + 0xa7, 0x95, 0x0b, 0x02, 0x0b, 0x00, 0xfe, 0x0a, 0xa9, 0xb5, 0x0a, 0x02, + 0x1b, 0x02, 0x8f, 0x0a, 0xac, 0xf3, 0x05, 0xad, 0x94, 0x05, 0xae, 0x85, + 0x05, 0xaf, 0xc7, 0x04, 0xb0, 0x94, 0x04, 0xb2, 0xe0, 0x02, 0xb3, 0x81, + 0x02, 0xb4, 0xba, 0x01, 0xb5, 0x88, 0x01, 0x08, 0x32, 0x00, 0x41, 0x02, + 0x51, 0x00, 0x27, 0xb8, 0x11, 0x07, 0xad, 0x35, 0x01, 0xff, 0x45, 0x5c, + 0x00, 0x5b, 0x03, 0x00, 0x45, 0x20, 0x07, 0xcf, 0x1d, 0x40, 0x80, 0x06, + 0x48, 0x87, 0xc8, 0xb5, 0x1a, 0x40, 0x45, 0x5c, 0x00, 0x3d, 0x03, 0x00, + 0x45, 0x20, 0x07, 0x53, 0x03, 0x40, 0x03, 0x4e, 0x04, 0x06, 0x4f, 0xbc, + 0x70, 0xb6, 0x1a, 0x40, 0x4c, 0x94, 0x91, 0xe9, 0x20, 0x00, 0x55, 0x4f, + 0x3e, 0xf9, 0x1d, 0x40, 0x80, 0x2b, 0x06, 0x56, 0xde, 0x01, 0xff, 0x45, + 0x1c, 0x3b, 0xd0, 0x1a, 0x80, 0x19, 0x4c, 0xe4, 0x92, 0xed, 0x1a, 0x00, + 0x45, 0x51, 0x24, 0xd2, 0x1a, 0x80, 0x06, 0x46, 0xd1, 0x73, 0xd4, 0x1a, + 0x40, 0x46, 0xea, 0x92, 0xd7, 0x1a, 0x40, 0x46, 0xe2, 0x9d, 0xd6, 0x1a, + 0x40, 0x05, 0xed, 0x07, 0x06, 0x45, 0x71, 0x24, 0x3e, 0x03, 0x40, 0x45, + 0x5c, 0x00, 0x0d, 0x03, 0x00, 0x45, 0x20, 0x07, 0x29, 0x03, 0x40, 0xb0, + 0x0c, 0x47, 0xf8, 0x06, 0xd1, 0x1d, 0x00, 0x47, 0xa8, 0x0f, 0xd2, 0x1d, + 0x40, 0x06, 0x38, 0xde, 0x11, 0x0c, 0xdf, 0x03, 0x01, 0xff, 0x45, 0x5c, + 0x00, 0xea, 0x1a, 0x00, 0x45, 0x20, 0x07, 0x4e, 0x03, 0x40, 0x45, 0x5c, + 0x00, 0xf5, 0x1d, 0x00, 0x45, 0x20, 0x07, 0x1d, 0x03, 0x40, 0x4f, 0x7c, + 0x13, 0xdb, 0x20, 0x00, 0x44, 0x72, 0x24, 0x03, 0x03, 0x80, 0x1c, 0x06, + 0x8d, 0x1e, 0x06, 0x51, 0x89, 0x61, 0x12, 0x03, 0x40, 0x4c, 0xa4, 0x90, + 0xcb, 0x1a, 0x00, 0x43, 0x48, 0x0a, 0xb4, 0x1a, 0x00, 0x48, 0xcf, 0xd1, + 0xe8, 0x20, 0x40, 0x80, 0x01, 0xff, 0x45, 0x20, 0x07, 0x30, 0x03, 0x00, + 0x4f, 0x9c, 0x72, 0x29, 0xfe, 0x00, 0x47, 0x3d, 0x24, 0x34, 0x03, 0x00, + 0x50, 0xba, 0x69, 0x2a, 0xfe, 0x40, 0x07, 0x5e, 0xd6, 0x4c, 0xa8, 0x2b, + 0x4a, 0xb6, 0xb3, 0xc2, 0x1d, 0x00, 0x06, 0x2a, 0x26, 0x0c, 0x61, 0x5f, + 0x0f, 0xba, 0x1a, 0x00, 0x4e, 0x26, 0x82, 0xc3, 0x1d, 0x40, 0x45, 0x5c, + 0x00, 0xe4, 0x1a, 0x00, 0xa2, 0x01, 0xff, 0x44, 0x21, 0x07, 0x3b, 0x03, + 0x00, 0x4d, 0x2a, 0x8c, 0xc5, 0x1a, 0x40, 0x48, 0x9c, 0xb6, 0xd9, 0x1a, + 0x00, 0x04, 0x35, 0x07, 0x01, 0xff, 0xb3, 0x06, 0x55, 0xef, 0x40, 0xd3, + 0x20, 0x40, 0x4e, 0x53, 0x35, 0x37, 0x03, 0x00, 0x4d, 0x40, 0x4c, 0x35, + 0x03, 0x40, 0x45, 0x5c, 0x00, 0xe5, 0x1a, 0x00, 0x45, 0x20, 0x07, 0x3c, + 0x03, 0x40, 0xa5, 0x97, 0x01, 0xa9, 0x01, 0xff, 0x03, 0xca, 0x00, 0x17, + 0x03, 0xa2, 0x01, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x0a, 0x03, 0x00, 0x45, + 0x20, 0x07, 0x25, 0x03, 0x00, 0x47, 0x3d, 0x24, 0xd8, 0x20, 0x40, 0x80, + 0x06, 0x61, 0xc2, 0x0f, 0xec, 0x20, 0x40, 0x05, 0xce, 0x00, 0x3b, 0x02, + 0x22, 0x00, 0x21, 0x0c, 0xfb, 0x22, 0x11, 0x05, 0x39, 0xde, 0x01, 0xff, + 0x45, 0x5c, 0x00, 0xe1, 0x1a, 0x00, 0x45, 0x20, 0x07, 0x19, 0x03, 0x40, + 0x4b, 0x7f, 0x05, 0xc2, 0x1a, 0x00, 0x4b, 0x98, 0x9e, 0xc4, 0x1a, 0x40, + 0x08, 0x6f, 0xcd, 0x06, 0x4b, 0xcb, 0x02, 0xd1, 0x20, 0x40, 0x45, 0x5c, + 0x00, 0x57, 0x03, 0x00, 0x45, 0x20, 0x07, 0x39, 0x03, 0x40, 0x80, 0x24, + 0x05, 0x13, 0x0f, 0x01, 0xff, 0xa1, 0x06, 0x45, 0x20, 0x07, 0x55, 0x03, + 0x40, 0x44, 0x5d, 0x00, 0x50, 0x03, 0x00, 0x03, 0x1b, 0x00, 0x01, 0xff, + 0x54, 0xef, 0x43, 0xff, 0x1d, 0x00, 0x52, 0xbb, 0x58, 0x56, 0x03, 0x40, + 0x45, 0x5c, 0x00, 0xd7, 0x20, 0x00, 0x45, 0x20, 0x07, 0xef, 0x20, 0x40, + 0x52, 0x73, 0x58, 0x22, 0x03, 0x00, 0x05, 0x3e, 0x04, 0x01, 0xff, 0x50, + 0x51, 0x35, 0xe5, 0x20, 0x00, 0x4d, 0x8d, 0x61, 0x14, 0x03, 0x40, 0xa1, + 0x11, 0x09, 0x22, 0x75, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xc8, 0x1a, 0x00, + 0x45, 0x20, 0x07, 0x1f, 0x03, 0x40, 0x54, 0x33, 0x46, 0x21, 0x03, 0x00, + 0x0a, 0xcb, 0x63, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xbb, 0x1a, 0x00, 0x45, + 0x20, 0x07, 0xbd, 0x1a, 0x00, 0x47, 0x3d, 0x24, 0xbe, 0x1a, 0x40, 0x45, + 0xb1, 0xe4, 0x28, 0x03, 0x80, 0x2e, 0x11, 0x37, 0x5e, 0x0c, 0x4e, 0xde, + 0x7e, 0xb7, 0x1a, 0x00, 0x47, 0x15, 0x8f, 0x05, 0x03, 0x40, 0x42, 0x1a, + 0x00, 0x76, 0x03, 0x01, 0x43, 0x54, 0x6f, 0x77, 0x03, 0x01, 0x45, 0xf9, + 0xee, 0x79, 0x03, 0x01, 0x43, 0x99, 0xfa, 0x7a, 0x03, 0x01, 0x44, 0x54, + 0xf9, 0x78, 0x03, 0x41, 0x46, 0x5b, 0x00, 0xce, 0x1d, 0x40, 0x4e, 0x7c, + 0x7e, 0x4a, 0x03, 0x00, 0x50, 0x1a, 0x6b, 0xc6, 0x1a, 0x40, 0x45, 0xd2, + 0x73, 0x04, 0x03, 0x80, 0x11, 0x0a, 0x72, 0xb1, 0x01, 0xff, 0x45, 0x5c, + 0x00, 0xe2, 0x1a, 0x00, 0x45, 0x20, 0x07, 0x20, 0x03, 0x40, 0x80, 0x22, + 0x8d, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0xc4, 0x1d, 0x80, 0x12, 0x45, 0x8f, + 0x24, 0xcc, 0x1d, 0x00, 0x45, 0x51, 0x24, 0xc6, 0x1d, 0x00, 0x4d, 0xce, + 0x8e, 0xd5, 0x1a, 0x40, 0x46, 0xe2, 0x9d, 0xd8, 0x1a, 0x40, 0x45, 0x20, + 0x07, 0x31, 0x03, 0x00, 0x49, 0xc7, 0x14, 0x24, 0xfe, 0x80, 0x0d, 0x4a, + 0x55, 0x04, 0x25, 0xfe, 0xc0, 0x00, 0x46, 0x1f, 0x07, 0x2c, 0xfe, 0x40, + 0x46, 0x1f, 0x07, 0x2b, 0xfe, 0x40, 0x05, 0x06, 0x06, 0xed, 0x01, 0x03, + 0xc4, 0x00, 0x4f, 0x02, 0x3f, 0x00, 0x27, 0xaf, 0x01, 0xff, 0x03, 0xa2, + 0x01, 0x06, 0x46, 0x09, 0x8f, 0x32, 0x03, 0x40, 0x56, 0x4b, 0x35, 0xeb, + 0x20, 0x00, 0xb3, 0x06, 0x55, 0xef, 0x40, 0xd2, 0x20, 0x40, 0x4e, 0x53, + 0x35, 0x38, 0x03, 0x00, 0x4d, 0x40, 0x4c, 0x36, 0x03, 0x40, 0x06, 0xe0, + 0x11, 0x06, 0x5e, 0x3f, 0x14, 0xb9, 0x1a, 0x40, 0x49, 0xc7, 0x14, 0x20, + 0xfe, 0x80, 0x0d, 0x4a, 0x55, 0x04, 0x21, 0xfe, 0xc0, 0x00, 0x46, 0x1f, + 0x07, 0x28, 0xfe, 0x40, 0x46, 0x1f, 0x07, 0x27, 0xfe, 0x40, 0x80, 0x11, + 0x06, 0xa9, 0x01, 0x01, 0xff, 0x4d, 0xe7, 0x84, 0xea, 0x20, 0x00, 0x5b, + 0xc8, 0x0f, 0xed, 0x20, 0x40, 0xa1, 0x4b, 0x02, 0x22, 0x00, 0x31, 0x0c, + 0xfb, 0x22, 0x21, 0x0c, 0xc8, 0x00, 0x11, 0x05, 0x39, 0xde, 0x01, 0xff, + 0x45, 0x5c, 0x00, 0xe0, 0x1a, 0x00, 0x45, 0x20, 0x07, 0x18, 0x03, 0x40, + 0x45, 0x5c, 0x00, 0xe1, 0x20, 0x00, 0x45, 0x20, 0x07, 0x4d, 0x03, 0x40, + 0x4a, 0x41, 0x06, 0xc1, 0x1a, 0x00, 0x4a, 0x94, 0xad, 0xc3, 0x1a, 0x40, + 0x08, 0x6f, 0xcd, 0x06, 0x4b, 0xcb, 0x02, 0xd0, 0x20, 0x40, 0x45, 0x5c, + 0x00, 0x51, 0x03, 0x00, 0x45, 0x20, 0x07, 0x1c, 0x03, 0x40, 0x05, 0x32, + 0x06, 0x24, 0x04, 0xcf, 0x00, 0x01, 0xff, 0x80, 0x11, 0x05, 0x13, 0x0f, + 0x01, 0xff, 0x45, 0x5c, 0x00, 0xfe, 0x1d, 0x00, 0x45, 0x20, 0x07, 0x54, + 0x03, 0x40, 0x45, 0x5c, 0x00, 0xd6, 0x20, 0x00, 0x45, 0x20, 0x07, 0xee, + 0x20, 0x40, 0x45, 0x5c, 0x00, 0x1a, 0x03, 0x00, 0x45, 0x20, 0x07, 0x49, + 0x03, 0x00, 0x4d, 0x76, 0x85, 0xe9, 0x1a, 0x40, 0x15, 0xe2, 0x3e, 0x8e, + 0x02, 0x0d, 0x9b, 0x08, 0x01, 0xff, 0xe1, 0x63, 0x03, 0x80, 0xeb, 0x01, + 0xe2, 0xe8, 0x1d, 0x80, 0xdf, 0x01, 0xe3, 0x68, 0x03, 0x80, 0xd3, 0x01, + 0xe4, 0x69, 0x03, 0x00, 0xe5, 0x64, 0x03, 0x80, 0xbd, 0x01, 0xe6, 0xeb, + 0x1d, 0x80, 0xb1, 0x01, 0xe7, 0xda, 0x1d, 0x00, 0xe8, 0x6a, 0x03, 0x00, + 0xe9, 0x65, 0x03, 0x80, 0x8e, 0x01, 0xeb, 0xdc, 0x1d, 0x00, 0xec, 0xdd, + 0x1d, 0x80, 0x79, 0xed, 0x6b, 0x03, 0x00, 0xee, 0xe0, 0x1d, 0x00, 0xef, + 0x66, 0x03, 0x80, 0x5b, 0xf0, 0xee, 0x1d, 0x00, 0xf2, 0x6c, 0x03, 0x80, + 0x43, 0xf3, 0xe4, 0x1d, 0x80, 0x38, 0xf4, 0x6d, 0x03, 0x80, 0x2d, 0xf5, + 0x67, 0x03, 0x80, 0x17, 0xf6, 0x6e, 0x03, 0x00, 0xf7, 0xf1, 0x1d, 0x80, + 0x08, 0xf8, 0x6f, 0x03, 0x00, 0xfa, 0xe6, 0x1d, 0x40, 0x46, 0x1f, 0x07, + 0xbf, 0x1a, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x49, 0xf3, 0x24, 0xf4, + 0x1d, 0x00, 0x5b, 0x7f, 0x1d, 0xf0, 0x1d, 0x40, 0x4d, 0x59, 0x8e, 0xc0, + 0x1a, 0x40, 0x44, 0x82, 0x7f, 0xea, 0x1d, 0x40, 0x80, 0x01, 0xff, 0x45, + 0x20, 0x07, 0xca, 0x1d, 0x00, 0x47, 0x76, 0x08, 0xe3, 0x1d, 0x40, 0x06, + 0x50, 0x00, 0x01, 0xff, 0x49, 0xf3, 0x24, 0xf3, 0x1d, 0x00, 0x5b, 0x7f, + 0x1d, 0xed, 0x1d, 0x40, 0x59, 0x5d, 0x24, 0xec, 0x1d, 0x00, 0x45, 0xe7, + 0x11, 0xe5, 0x1d, 0x40, 0x07, 0x57, 0xc0, 0x01, 0xff, 0xe4, 0xd8, 0x1d, + 0x00, 0xe7, 0xcc, 0x1a, 0x00, 0xf2, 0xcd, 0x1a, 0x00, 0xf4, 0xce, 0x1a, + 0x40, 0x55, 0xb8, 0x3e, 0xd3, 0x1d, 0x40, 0x42, 0xa4, 0x02, 0xef, 0x1d, + 0x00, 0x42, 0x53, 0x00, 0xd9, 0x1d, 0x40, 0x48, 0x28, 0x98, 0xd7, 0x1d, + 0x40, 0x43, 0x43, 0x10, 0xe9, 0x1d, 0x40, 0x4f, 0x29, 0x6d, 0xf2, 0x1d, + 0x00, 0xe5, 0xd4, 0x1d, 0x00, 0x44, 0x40, 0xea, 0xe7, 0x1d, 0x00, 0xef, + 0xd5, 0x1d, 0x00, 0xf6, 0xd6, 0x1d, 0x40, 0xe7, 0xdb, 0x1d, 0x00, 0xec, + 0xde, 0x1d, 0x00, 0xed, 0xdf, 0x1d, 0x00, 0xee, 0xe1, 0x1d, 0x00, 0xf2, + 0xe2, 0x1d, 0x40, 0x10, 0xca, 0x6a, 0x11, 0x0b, 0x32, 0xaa, 0x01, 0xff, + 0x44, 0xc3, 0x00, 0xf7, 0x1d, 0x00, 0x45, 0xc8, 0x00, 0xf6, 0x1d, 0x40, + 0x56, 0x29, 0x39, 0x9a, 0x30, 0x00, 0x51, 0x2e, 0x39, 0x99, 0x30, 0x40, + 0xae, 0x06, 0x47, 0xbb, 0x0f, 0xd0, 0x1d, 0x40, 0x46, 0xb7, 0x6f, 0xb2, + 0x1a, 0x00, 0x07, 0x9c, 0x24, 0x01, 0xff, 0x02, 0x88, 0x09, 0x11, 0x0c, + 0xcc, 0x92, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xc7, 0x1a, 0x00, 0x45, 0x20, + 0x07, 0x2b, 0x03, 0x40, 0x43, 0x27, 0x14, 0x11, 0x03, 0x80, 0x11, 0x05, + 0x5a, 0x3e, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xe3, 0x1a, 0x00, 0x45, 0x20, + 0x07, 0x3a, 0x03, 0x40, 0x46, 0x1f, 0x07, 0x2f, 0x03, 0x40, 0x4e, 0x9c, + 0x7d, 0x4b, 0x03, 0x00, 0x48, 0xb6, 0xb0, 0x09, 0x03, 0x00, 0x42, 0x5e, + 0x01, 0x1b, 0x03, 0x40, 0x11, 0x04, 0x5e, 0xcd, 0x01, 0xb2, 0x01, 0xff, + 0xa1, 0x36, 0x04, 0x0f, 0x30, 0x01, 0xff, 0x4f, 0x36, 0x6f, 0x44, 0x03, + 0x00, 0x47, 0x56, 0xd8, 0x43, 0x03, 0x00, 0x08, 0x6f, 0x29, 0x0c, 0x4b, + 0x75, 0xa6, 0x42, 0x03, 0x00, 0x4d, 0x82, 0x51, 0x45, 0x03, 0x40, 0x49, + 0xc8, 0xc3, 0x44, 0xd2, 0x01, 0xb4, 0x01, 0xff, 0x48, 0x9f, 0xcb, 0x43, + 0xd2, 0x01, 0x46, 0x9a, 0xe5, 0x42, 0xd2, 0x41, 0x05, 0x35, 0xef, 0x3b, + 0x4c, 0x90, 0x98, 0x4f, 0x03, 0x00, 0x02, 0x32, 0x00, 0x01, 0xff, 0x80, + 0x1b, 0x8d, 0x01, 0xff, 0x4b, 0xdd, 0x9d, 0xc8, 0x1d, 0x00, 0x43, 0x48, + 0x0a, 0xde, 0x1a, 0x00, 0x46, 0xd1, 0x73, 0xc5, 0x1d, 0x00, 0x4d, 0xce, + 0x8e, 0xd1, 0x1a, 0x40, 0x46, 0xda, 0x04, 0x00, 0x03, 0x80, 0x06, 0x49, + 0xc2, 0x2e, 0x40, 0x03, 0x40, 0x46, 0x1f, 0x07, 0x16, 0x03, 0x40, 0x06, + 0xef, 0x06, 0x21, 0x07, 0x13, 0x06, 0x01, 0xff, 0xe1, 0x70, 0x13, 0x01, + 0x42, 0x1b, 0x02, 0x71, 0x13, 0x01, 0x42, 0x2a, 0x05, 0x72, 0x13, 0x01, + 0x42, 0xe0, 0x09, 0x74, 0x13, 0x01, 0x42, 0x02, 0x00, 0x73, 0x13, 0x41, + 0xa6, 0x20, 0x43, 0x7a, 0x0b, 0x67, 0x13, 0x01, 0x43, 0x08, 0x24, 0x6c, + 0x13, 0x01, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x66, 0x13, 0x41, 0x44, 0x25, + 0x01, 0x69, 0x13, 0x01, 0x42, 0x15, 0x02, 0x68, 0x13, 0x41, 0x43, 0xf9, + 0x05, 0x6b, 0x13, 0x01, 0x43, 0xf6, 0x06, 0x6a, 0x13, 0x41, 0x43, 0xf4, + 0xf9, 0x00, 0xe0, 0x01, 0xa2, 0xe1, 0x01, 0x46, 0xfb, 0x84, 0x1d, 0xe0, + 0x01, 0xa4, 0xcc, 0x01, 0xa6, 0xbd, 0x01, 0x47, 0x1b, 0xd7, 0x03, 0xe0, + 0x01, 0x44, 0x10, 0xf6, 0x18, 0xe0, 0x01, 0xe9, 0x0b, 0xe0, 0x81, 0x8f, + 0x01, 0x44, 0xa8, 0xf6, 0x0d, 0xe0, 0x01, 0x47, 0xcd, 0xd8, 0x0e, 0xe0, + 0x01, 0x47, 0x30, 0x6e, 0x0f, 0xe0, 0x01, 0x45, 0xe5, 0xee, 0x10, 0xe0, + 0x01, 0x43, 0x30, 0x33, 0x11, 0xe0, 0x01, 0x46, 0x28, 0xe5, 0x12, 0xe0, + 0x01, 0x45, 0x5c, 0xf0, 0x13, 0xe0, 0x01, 0xb3, 0x4b, 0xb4, 0x3d, 0x43, + 0xfa, 0xdb, 0x16, 0xe0, 0x01, 0x44, 0xf0, 0xf8, 0x02, 0xe0, 0x01, 0xb9, + 0x0f, 0xba, 0x01, 0xff, 0x45, 0xe3, 0xeb, 0x08, 0xe0, 0x01, 0x46, 0x7c, + 0xe2, 0x06, 0xe0, 0x41, 0x43, 0xb3, 0x00, 0x21, 0xe0, 0x01, 0xa5, 0x08, + 0xef, 0x26, 0xe0, 0x01, 0xf5, 0x23, 0xe0, 0x41, 0xb2, 0x06, 0x43, 0xba, + 0x6a, 0x05, 0xe0, 0x41, 0xe9, 0x20, 0xe0, 0x01, 0xf5, 0x1f, 0xe0, 0x41, + 0x42, 0x5a, 0x03, 0x1c, 0xe0, 0x01, 0x45, 0x0a, 0xf2, 0x15, 0xe0, 0x41, + 0xa8, 0x0c, 0x44, 0x00, 0xf7, 0x14, 0xe0, 0x01, 0x48, 0x16, 0xc5, 0x24, + 0xe0, 0x41, 0xe1, 0x1e, 0xe0, 0x01, 0x42, 0x12, 0x00, 0x1b, 0xe0, 0x41, + 0x4b, 0x4c, 0xa5, 0x0a, 0xe0, 0x01, 0x07, 0xc1, 0x22, 0x06, 0x43, 0xc2, + 0x29, 0x09, 0xe0, 0x41, 0x47, 0x3f, 0xd5, 0x29, 0xe0, 0x01, 0x49, 0x15, + 0xc5, 0x27, 0xe0, 0x41, 0x43, 0x0e, 0x06, 0x2a, 0xe0, 0x01, 0x44, 0x2a, + 0xc5, 0x17, 0xe0, 0x41, 0x45, 0xa0, 0xed, 0x0c, 0xe0, 0x01, 0x44, 0xb0, + 0xf7, 0x04, 0xe0, 0x41, 0x46, 0x40, 0xd5, 0x28, 0xe0, 0x01, 0x43, 0x6a, + 0xd8, 0x01, 0xe0, 0x41, 0x46, 0x6d, 0x58, 0x52, 0x03, 0x00, 0x48, 0x9e, + 0xbe, 0xda, 0x1a, 0x00, 0x4e, 0x09, 0x49, 0xdc, 0x20, 0x40, 0x09, 0xeb, + 0xc1, 0x11, 0x0b, 0xb7, 0xa6, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xe8, 0x1a, + 0x00, 0x45, 0x20, 0x07, 0x47, 0x03, 0x40, 0x46, 0x12, 0x03, 0xdd, 0x20, + 0x80, 0x20, 0x47, 0xcc, 0x46, 0xdf, 0x20, 0x00, 0x46, 0x54, 0xe3, 0xe3, + 0x20, 0x00, 0xb3, 0x06, 0x58, 0x54, 0x2d, 0xe4, 0x20, 0x40, 0x45, 0x4f, + 0x5c, 0xe2, 0x20, 0x00, 0x45, 0xfe, 0x05, 0xde, 0x20, 0x40, 0x4a, 0xd1, + 0x0e, 0xe0, 0x20, 0x40, 0xa5, 0xf4, 0x02, 0x48, 0xf4, 0x24, 0x08, 0x03, + 0x80, 0xd8, 0x02, 0xaf, 0x01, 0xff, 0xb4, 0x8c, 0x02, 0x04, 0x3d, 0x01, + 0x1b, 0x02, 0xa7, 0x01, 0x01, 0xff, 0x06, 0x38, 0xde, 0x06, 0x4b, 0xb8, + 0x02, 0xb3, 0x1a, 0x40, 0x45, 0x5c, 0x00, 0xdb, 0x1a, 0x00, 0x45, 0x20, + 0x07, 0x1e, 0x03, 0x40, 0x80, 0x06, 0x53, 0x1d, 0x4b, 0xb0, 0x1a, 0x40, + 0xa1, 0xc4, 0x01, 0x45, 0x8f, 0x24, 0x5d, 0x03, 0x80, 0xb6, 0x01, 0xa3, + 0xa1, 0x01, 0x4c, 0x51, 0x24, 0x0f, 0x03, 0x80, 0x93, 0x01, 0x4e, 0x9a, + 0x24, 0x61, 0x03, 0x80, 0x85, 0x01, 0x48, 0x07, 0x8f, 0x33, 0x03, 0x00, + 0x46, 0xd1, 0x73, 0x5e, 0x03, 0x80, 0x72, 0xaf, 0x64, 0xb0, 0x4b, 0x02, + 0x0d, 0x00, 0x31, 0x45, 0x71, 0x24, 0x60, 0x03, 0x80, 0x1b, 0x09, 0x32, + 0x00, 0x01, 0xff, 0x05, 0xed, 0x07, 0x06, 0x4e, 0x3f, 0x4c, 0xe6, 0x20, + 0x40, 0x45, 0x5c, 0x00, 0x0e, 0x03, 0x00, 0x45, 0x20, 0x07, 0x48, 0x03, + 0x40, 0x80, 0x01, 0xff, 0x49, 0xc7, 0x14, 0x22, 0xfe, 0x00, 0x4a, 0x55, + 0x04, 0x23, 0xfe, 0x40, 0x0f, 0xdc, 0x03, 0x06, 0x48, 0x62, 0x77, 0x5a, + 0x03, 0x40, 0x45, 0x5c, 0x00, 0xeb, 0x1a, 0x00, 0x45, 0x20, 0x07, 0x62, + 0x03, 0x40, 0x50, 0xca, 0x63, 0xbc, 0x1a, 0x00, 0x09, 0x22, 0x75, 0x01, + 0xff, 0x45, 0x5c, 0x00, 0xc9, 0x1a, 0x00, 0x45, 0x20, 0x07, 0xca, 0x1a, + 0x40, 0x4e, 0xde, 0x7e, 0xb8, 0x1a, 0x00, 0x47, 0x15, 0x8f, 0x3f, 0x03, + 0x40, 0x46, 0x1f, 0x07, 0x5f, 0x03, 0x40, 0x46, 0x1f, 0x07, 0xfc, 0x1d, + 0x40, 0x46, 0x1f, 0x07, 0xee, 0x1a, 0x40, 0x44, 0x0b, 0x70, 0xcf, 0x1a, + 0x00, 0x4f, 0x34, 0x34, 0xcd, 0x1d, 0x00, 0x4a, 0x90, 0x61, 0xf0, 0x1a, + 0x40, 0x46, 0x1f, 0x07, 0x5c, 0x03, 0x40, 0x4b, 0xa5, 0x90, 0x0b, 0x03, + 0x80, 0x11, 0x04, 0x75, 0x79, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xe7, 0x1a, + 0x00, 0x45, 0x20, 0x07, 0xe6, 0x1a, 0x40, 0x46, 0x1f, 0x07, 0xef, 0x1a, + 0x40, 0x80, 0x21, 0x02, 0x3d, 0x27, 0x11, 0x04, 0x77, 0x00, 0x01, 0xff, + 0x4c, 0xa4, 0x90, 0xc1, 0x1d, 0x00, 0x4c, 0x51, 0x24, 0xc0, 0x1d, 0x40, + 0x44, 0x1d, 0x3b, 0xdf, 0x1a, 0x00, 0x4d, 0x97, 0x8a, 0xdd, 0x1a, 0x40, + 0x45, 0x5c, 0x00, 0x07, 0x03, 0x80, 0x0d, 0x45, 0x20, 0x07, 0x23, 0x03, + 0xc0, 0x00, 0x45, 0xc2, 0x00, 0xfa, 0x1d, 0x40, 0x80, 0x01, 0xff, 0x44, + 0xc3, 0x00, 0xf8, 0x1d, 0x00, 0x45, 0xc8, 0x00, 0x58, 0x03, 0x40, 0x80, + 0x06, 0x45, 0x99, 0x8a, 0xb1, 0x1a, 0x40, 0x45, 0x20, 0x07, 0x24, 0x03, + 0x00, 0x54, 0x17, 0x49, 0xdc, 0x1a, 0x40, 0x4b, 0xd6, 0xa3, 0xfb, 0x1d, + 0x00, 0x09, 0xa1, 0xc6, 0x01, 0xff, 0x06, 0xef, 0x06, 0x30, 0x07, 0x13, + 0x06, 0x06, 0x4d, 0x2e, 0x8d, 0xf1, 0xa8, 0x40, 0xe1, 0xea, 0xa8, 0x00, + 0x42, 0x1b, 0x02, 0xec, 0xa8, 0x00, 0x42, 0x2a, 0x05, 0xed, 0xa8, 0x00, + 0x42, 0xe0, 0x09, 0xee, 0xa8, 0x00, 0x42, 0x71, 0x00, 0xef, 0xa8, 0x00, + 0xf5, 0xeb, 0xa8, 0x00, 0x42, 0x02, 0x00, 0xf0, 0xa8, 0x40, 0x45, 0x7e, + 0x0b, 0xe8, 0xa8, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0xe9, 0xa8, 0x00, + 0x43, 0x7a, 0x0b, 0xe1, 0xa8, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, + 0x1f, 0xe0, 0xa8, 0x40, 0x44, 0x25, 0x01, 0xe3, 0xa8, 0x00, 0x42, 0x15, + 0x02, 0xe2, 0xa8, 0x40, 0x44, 0x06, 0x1f, 0xe7, 0xa8, 0x00, 0x42, 0x09, + 0x24, 0xe6, 0xa8, 0x40, 0x43, 0xf9, 0x05, 0xe5, 0xa8, 0x00, 0x43, 0xf6, + 0x06, 0xe4, 0xa8, 0x40, 0xa1, 0xb7, 0x03, 0x46, 0x2a, 0x98, 0x27, 0x03, + 0x00, 0x50, 0xd0, 0x04, 0x02, 0x03, 0x80, 0xa3, 0x03, 0x09, 0x15, 0x11, + 0x92, 0x03, 0xaf, 0xeb, 0x02, 0x08, 0xb7, 0xd2, 0x01, 0xff, 0x4e, 0x2a, + 0x7a, 0x85, 0x04, 0x00, 0x08, 0x3f, 0x12, 0xcf, 0x02, 0x46, 0x37, 0x52, + 0x7c, 0xa6, 0x00, 0x07, 0x13, 0x06, 0x52, 0x4d, 0x18, 0x3e, 0x89, 0x04, + 0x00, 0xb0, 0x30, 0x65, 0x9b, 0x08, 0x8f, 0xe0, 0x01, 0xb4, 0x06, 0x45, + 0x0f, 0xf2, 0x6f, 0xa6, 0x40, 0x50, 0x8a, 0x65, 0x70, 0xa6, 0x00, 0x55, + 0x10, 0x3e, 0x72, 0xa6, 0x00, 0x44, 0x55, 0x9d, 0x83, 0x04, 0xc0, 0x00, + 0x80, 0x01, 0xff, 0x49, 0xc7, 0x14, 0x2e, 0xfe, 0x00, 0x4a, 0x55, 0x04, + 0x2f, 0xfe, 0x40, 0xa1, 0x0c, 0x47, 0xb4, 0xd9, 0x87, 0x04, 0x00, 0x4d, + 0x48, 0x8d, 0x86, 0x04, 0x40, 0x4c, 0x90, 0x95, 0x84, 0x04, 0x00, 0x45, + 0x81, 0xda, 0x7d, 0xa6, 0x40, 0xe1, 0xf6, 0x2d, 0x00, 0xa2, 0xe2, 0x01, + 0x43, 0x3b, 0x15, 0xf1, 0x2d, 0x00, 0xa4, 0xcf, 0x01, 0xa5, 0xad, 0x01, + 0x44, 0xb4, 0xf5, 0xf4, 0x2d, 0x00, 0x43, 0x82, 0x54, 0xe2, 0x2d, 0x00, + 0x42, 0x22, 0x00, 0xef, 0x2d, 0x80, 0x93, 0x01, 0xe9, 0x75, 0xa6, 0x80, + 0x77, 0x42, 0x1b, 0x02, 0xe6, 0x2d, 0x00, 0x4a, 0xb8, 0x5b, 0xfd, 0x2d, + 0x00, 0x4c, 0xec, 0x96, 0xf9, 0x2d, 0x00, 0xef, 0xea, 0x2d, 0x80, 0x5a, + 0x42, 0x6f, 0x02, 0xeb, 0x2d, 0x00, 0xb3, 0x40, 0xb4, 0x34, 0xf5, 0x77, + 0xa6, 0x80, 0x29, 0x42, 0x32, 0x00, 0xe1, 0x2d, 0x00, 0xb9, 0x0d, 0xba, + 0x01, 0xff, 0xe5, 0xe5, 0x2d, 0x00, 0x42, 0xb0, 0x01, 0xe4, 0x2d, 0x40, + 0x42, 0x8a, 0x00, 0xfa, 0x2d, 0x00, 0x43, 0x3a, 0x2d, 0x79, 0xa6, 0x00, + 0xe9, 0x76, 0xa6, 0x00, 0xf5, 0xfb, 0x2d, 0x40, 0x4b, 0x31, 0xa3, 0x74, + 0xa6, 0x40, 0xe5, 0xee, 0x2d, 0x00, 0x42, 0x46, 0x03, 0xf0, 0x2d, 0x40, + 0xa8, 0x06, 0x48, 0x3c, 0x93, 0x7a, 0xa6, 0x40, 0xe1, 0xf2, 0x2d, 0x00, + 0x43, 0xd0, 0x18, 0xf3, 0x2d, 0x40, 0x44, 0x99, 0x7f, 0x7b, 0xa6, 0x40, + 0xe5, 0xf7, 0x2d, 0x00, 0x08, 0x2f, 0xcf, 0x01, 0xff, 0xe1, 0xfc, 0x2d, + 0x00, 0x47, 0x3f, 0xd5, 0xff, 0x2d, 0x00, 0xe5, 0x9f, 0xa6, 0x40, 0x47, + 0xe1, 0x97, 0x78, 0xa6, 0x40, 0xe6, 0x9e, 0xa6, 0x00, 0xec, 0xe7, 0x2d, + 0x00, 0xed, 0xe8, 0x2d, 0x00, 0xee, 0xe9, 0x2d, 0x00, 0xf2, 0xec, 0x2d, + 0x00, 0xf3, 0xed, 0x2d, 0xc0, 0x00, 0x43, 0x8f, 0x80, 0xf5, 0x2d, 0x40, + 0xe5, 0xe3, 0x2d, 0x00, 0x44, 0xa0, 0xed, 0xf8, 0x2d, 0x40, 0xe5, 0xe0, + 0x2d, 0x00, 0x46, 0x40, 0xd5, 0xfe, 0x2d, 0x40, 0x4d, 0x18, 0x3e, 0x71, + 0xa6, 0x00, 0x4e, 0xd6, 0x80, 0x88, 0x04, 0x40, 0x04, 0x15, 0x05, 0x0d, + 0x4f, 0xc8, 0x73, 0x26, 0xfe, 0xc0, 0x00, 0x46, 0x1f, 0x07, 0x2d, 0xfe, + 0x40, 0x45, 0x5c, 0x00, 0x13, 0x03, 0x80, 0x06, 0x45, 0x20, 0x07, 0x26, + 0x03, 0x40, 0x46, 0xc7, 0x00, 0x15, 0x03, 0x40, 0x4b, 0xce, 0x00, 0xd5, + 0x20, 0x00, 0x4c, 0x8c, 0x99, 0xd9, 0x20, 0x40, 0x46, 0x1f, 0x07, 0x2d, + 0x03, 0x40, 0x49, 0x15, 0x25, 0x10, 0x03, 0x00, 0x43, 0x60, 0x0f, 0x0c, + 0x03, 0xc0, 0x00, 0x46, 0x1f, 0x07, 0x2c, 0x03, 0x00, 0x46, 0xea, 0x92, + 0xec, 0x1a, 0x40, 0x4a, 0x40, 0xb1, 0x3b, 0x13, 0x01, 0xb2, 0x01, 0xff, + 0x43, 0x27, 0x14, 0x06, 0x03, 0x80, 0x11, 0x05, 0x5a, 0x3e, 0x01, 0xff, + 0x45, 0x5c, 0x00, 0x46, 0x03, 0x00, 0x45, 0x20, 0x07, 0x2a, 0x03, 0x40, + 0x46, 0x1f, 0x07, 0x2e, 0x03, 0x00, 0x47, 0x86, 0xd3, 0xcb, 0x1d, 0x40, + 0x04, 0x1d, 0x3b, 0x3a, 0x0f, 0x05, 0x73, 0x2a, 0xae, 0x11, 0x08, 0x7a, + 0x6a, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xf0, 0x20, 0x00, 0x45, 0x20, 0x07, + 0x59, 0x03, 0x40, 0x4c, 0xac, 0x97, 0xe7, 0x20, 0x00, 0x0c, 0x12, 0x11, + 0x01, 0xff, 0x4b, 0xce, 0x00, 0xd4, 0x20, 0x00, 0x4c, 0x8c, 0x99, 0xda, + 0x20, 0x40, 0x45, 0x5c, 0x00, 0x4c, 0x03, 0x00, 0x45, 0x20, 0x07, 0xfd, + 0x1d, 0x40, 0x80, 0x15, 0x8d, 0x01, 0xff, 0x4b, 0xb0, 0xa1, 0xc9, 0x1d, + 0x00, 0x46, 0xd1, 0x73, 0xc7, 0x1d, 0x00, 0x4d, 0xce, 0x8e, 0xd3, 0x1a, + 0x40, 0x46, 0xda, 0x04, 0x01, 0x03, 0x80, 0x06, 0x49, 0xc2, 0x2e, 0x41, + 0x03, 0x40, 0x46, 0x1f, 0x07, 0x17, 0x03, 0x40, 0x4d, 0x45, 0x89, 0xa5, + 0xf4, 0x01, 0x42, 0x10, 0x00, 0x3a, 0x00, 0xc0, 0x00, 0x80, 0x01, 0xff, + 0x46, 0x16, 0x14, 0x54, 0x22, 0x00, 0x44, 0x5a, 0x03, 0xa1, 0x20, 0x40, + 0xab, 0x06, 0x44, 0xc8, 0xf7, 0x65, 0xf9, 0x41, 0x45, 0xc0, 0xda, 0xb3, + 0xfa, 0x01, 0x4a, 0x3a, 0xb7, 0x78, 0xf3, 0x41, 0xa1, 0xdb, 0x03, 0x51, + 0x4a, 0x5c, 0x9a, 0x23, 0x00, 0xa9, 0xbc, 0x03, 0xaf, 0x01, 0xff, 0x02, + 0x36, 0x01, 0x8f, 0x01, 0x02, 0x46, 0x03, 0x2a, 0x42, 0x40, 0x0d, 0x01, + 0x26, 0x80, 0x06, 0x47, 0x19, 0x80, 0x21, 0xf9, 0x41, 0x06, 0x50, 0x00, + 0x01, 0xff, 0x49, 0x25, 0xc1, 0x29, 0xf3, 0x01, 0x44, 0xb7, 0x08, 0x27, + 0xf3, 0x01, 0x44, 0x60, 0x30, 0x28, 0xf3, 0x01, 0x47, 0x62, 0xdc, 0x2a, + 0xf3, 0x41, 0x43, 0x4f, 0x02, 0x50, 0x20, 0x00, 0x02, 0x06, 0x00, 0x01, + 0xff, 0x44, 0x28, 0xf5, 0xd5, 0xf4, 0x01, 0x58, 0xe4, 0x2a, 0x4d, 0x2a, + 0x00, 0x4d, 0x5f, 0x89, 0x10, 0xf5, 0x01, 0x0d, 0xad, 0x89, 0x34, 0x02, + 0x6f, 0x00, 0x16, 0xb5, 0x01, 0xff, 0x47, 0x33, 0x64, 0x02, 0xf3, 0x01, + 0x50, 0x5a, 0x68, 0x4c, 0x2a, 0xc0, 0x00, 0x52, 0x6b, 0x51, 0x50, 0x2a, + 0x40, 0x44, 0x69, 0x13, 0xcf, 0x2a, 0x80, 0x0d, 0x46, 0x21, 0x38, 0xd0, + 0x2a, 0xc0, 0x00, 0x4c, 0x90, 0x2a, 0xd2, 0x2a, 0x40, 0x4c, 0x90, 0x2a, + 0xd1, 0x2a, 0x40, 0x4c, 0x44, 0x96, 0xea, 0xf4, 0x01, 0x4b, 0xee, 0xa6, + 0xeb, 0xf4, 0x41, 0x06, 0x0b, 0x08, 0x51, 0x05, 0x19, 0x11, 0x01, 0xff, + 0xa3, 0x3e, 0x68, 0xe0, 0x04, 0x03, 0xf5, 0x01, 0x53, 0xee, 0x4b, 0xf3, + 0x27, 0x00, 0x48, 0x02, 0x28, 0x31, 0x22, 0x00, 0x51, 0xf6, 0x04, 0xbb, + 0x21, 0x00, 0x05, 0xc8, 0x00, 0x0f, 0xb4, 0x01, 0xff, 0x53, 0x28, 0x4e, + 0xb7, 0x21, 0x00, 0x60, 0xa3, 0x10, 0x6e, 0x2b, 0x40, 0x5b, 0xdc, 0x1a, + 0xd8, 0xf5, 0x01, 0x66, 0x97, 0x07, 0x01, 0xf5, 0xc1, 0x00, 0x59, 0x2b, + 0x24, 0x02, 0xf5, 0x41, 0x52, 0xd9, 0x55, 0x41, 0x29, 0x00, 0x4f, 0x8b, + 0x74, 0x32, 0x22, 0x40, 0xa5, 0xac, 0x01, 0xa6, 0x88, 0x01, 0x04, 0x6d, + 0x2c, 0x78, 0x03, 0x7a, 0x0b, 0x68, 0xb3, 0x45, 0xb4, 0x01, 0xff, 0x02, + 0x92, 0x01, 0x32, 0x04, 0x25, 0x01, 0x22, 0xb7, 0x01, 0xff, 0x04, 0x85, + 0x2d, 0x0f, 0xaf, 0x01, 0xff, 0x47, 0x2b, 0xd3, 0x51, 0xf5, 0x01, 0x47, + 0x9b, 0xd3, 0x5d, 0xf5, 0x41, 0x47, 0x2b, 0xd3, 0x5b, 0xf5, 0x01, 0x47, + 0x9b, 0xd3, 0x67, 0xf5, 0x41, 0x47, 0x2b, 0xd3, 0x52, 0xf5, 0x01, 0x47, + 0x9b, 0xd3, 0x5e, 0xf5, 0x41, 0x47, 0x2b, 0xd3, 0x59, 0xf5, 0x01, 0x47, + 0x9b, 0xd3, 0x65, 0xf5, 0x41, 0x04, 0x06, 0x1f, 0x11, 0x02, 0x09, 0x24, + 0x01, 0xff, 0x47, 0x2b, 0xd3, 0x55, 0xf5, 0x01, 0x47, 0x9b, 0xd3, 0x61, + 0xf5, 0x41, 0x47, 0x2b, 0xd3, 0x56, 0xf5, 0x01, 0x47, 0x9b, 0xd3, 0x62, + 0xf5, 0x41, 0x47, 0x2b, 0xd3, 0x50, 0xf5, 0x01, 0x47, 0x9b, 0xd3, 0x5c, + 0xf5, 0x41, 0x47, 0x2b, 0xd3, 0x58, 0xf5, 0x01, 0x47, 0x9b, 0xd3, 0x64, + 0xf5, 0x41, 0x03, 0xf9, 0x05, 0x11, 0x03, 0xf6, 0x06, 0x01, 0xff, 0x47, + 0x2b, 0xd3, 0x53, 0xf5, 0x01, 0x47, 0x9b, 0xd3, 0x5f, 0xf5, 0x41, 0x47, + 0x2b, 0xd3, 0x54, 0xf5, 0x01, 0x47, 0x9b, 0xd3, 0x60, 0xf5, 0x41, 0x04, + 0xc9, 0x00, 0x11, 0x05, 0xe7, 0x72, 0x01, 0xff, 0x47, 0x2b, 0xd3, 0x5a, + 0xf5, 0x01, 0x47, 0x9b, 0xd3, 0x66, 0xf5, 0x41, 0x47, 0x2b, 0xd3, 0x57, + 0xf5, 0x01, 0x47, 0x9b, 0xd3, 0x63, 0xf5, 0x41, 0x06, 0x0a, 0x96, 0x06, + 0x46, 0xf8, 0xe4, 0xcb, 0xf4, 0x41, 0x49, 0x1e, 0xbc, 0x7b, 0xf3, 0x01, + 0x47, 0x25, 0xc6, 0x42, 0xf9, 0x41, 0x53, 0xa3, 0x4d, 0x81, 0xf5, 0x01, + 0x02, 0x6e, 0x02, 0x06, 0x4f, 0x5c, 0x76, 0xdb, 0xf3, 0x41, 0x48, 0x40, + 0x15, 0xac, 0xf3, 0x01, 0x4e, 0x14, 0x7c, 0x4f, 0xf4, 0x41, 0x58, 0x1c, + 0x29, 0x08, 0xd8, 0x00, 0x08, 0xa3, 0xaa, 0xbb, 0x01, 0x07, 0x74, 0x0f, + 0x06, 0x52, 0xe1, 0x34, 0x01, 0xd8, 0x40, 0x43, 0x00, 0xfa, 0xc3, 0x31, + 0x00, 0xe4, 0xd4, 0x31, 0x00, 0xe8, 0xd0, 0x31, 0x80, 0x5f, 0xee, 0xcf, + 0x31, 0x00, 0xf0, 0xd2, 0x31, 0x80, 0x4a, 0xf1, 0xe3, 0x31, 0x00, 0xf3, + 0xd1, 0x31, 0x80, 0x15, 0xf4, 0xc0, 0x31, 0x80, 0x0c, 0x42, 0xc7, 0x18, + 0xc1, 0x31, 0x00, 0x42, 0x01, 0xfa, 0xc2, 0x31, 0x40, 0xee, 0xdd, 0x31, + 0x40, 0xe7, 0xda, 0x31, 0x00, 0xf0, 0xd3, 0x31, 0x00, 0xf4, 0xd9, 0x31, + 0x00, 0xf7, 0xc4, 0x31, 0x80, 0x13, 0xfa, 0xd7, 0x31, 0xc0, 0x00, 0xf0, + 0xe5, 0x31, 0x00, 0x42, 0xc7, 0x18, 0xc9, 0x31, 0x00, 0xfa, 0xde, 0x31, + 0x40, 0xe7, 0xdf, 0x31, 0x00, 0xfa, 0xd8, 0x31, 0x40, 0xe4, 0xdb, 0x31, + 0x00, 0xe7, 0xe2, 0x31, 0x00, 0xfa, 0xdc, 0x31, 0x40, 0xe7, 0xd6, 0x31, + 0x00, 0xf0, 0xc7, 0x31, 0x80, 0x34, 0xb8, 0x28, 0xfa, 0xd5, 0x31, 0xc0, + 0x00, 0xe7, 0xc6, 0x31, 0x00, 0xf4, 0xca, 0x31, 0x00, 0xf7, 0xcd, 0x31, + 0x80, 0x12, 0xfa, 0xc5, 0x31, 0xc0, 0x00, 0xf0, 0xcb, 0x31, 0x00, 0xfa, + 0xce, 0x31, 0xc0, 0x00, 0xe7, 0xe1, 0x31, 0x40, 0xe7, 0xc8, 0x31, 0x40, + 0xe7, 0xe4, 0x31, 0x00, 0x42, 0xc7, 0x18, 0xe0, 0x31, 0x40, 0x42, 0xc7, + 0x18, 0xcc, 0x31, 0x40, 0xa2, 0xba, 0x06, 0xa3, 0xfb, 0x04, 0xa4, 0xe6, + 0x04, 0xa5, 0xbe, 0x04, 0xa6, 0xaf, 0x04, 0xa7, 0x8c, 0x04, 0xa8, 0xe4, + 0x03, 0xaa, 0xbc, 0x03, 0x06, 0x05, 0xab, 0xab, 0x03, 0xac, 0xf8, 0x02, + 0xad, 0xc1, 0x02, 0x04, 0x8e, 0x4b, 0xa1, 0x02, 0x43, 0x03, 0x1c, 0xb9, + 0x2e, 0x00, 0xb0, 0x82, 0x02, 0xb2, 0xe9, 0x01, 0xb3, 0x51, 0xb4, 0x37, + 0xb7, 0x01, 0xff, 0xa1, 0x11, 0x04, 0x01, 0x0f, 0x01, 0xff, 0x43, 0x7a, + 0x0b, 0xc3, 0x2e, 0x00, 0x43, 0x44, 0x0a, 0xc4, 0x2e, 0x40, 0x03, 0x69, + 0xfa, 0x11, 0x04, 0x08, 0x03, 0x01, 0xff, 0x43, 0x7a, 0x0b, 0xa1, 0x2e, + 0x00, 0x43, 0x44, 0x0a, 0xa2, 0x2e, 0x40, 0x43, 0x7a, 0x0b, 0xcd, 0x2e, + 0x00, 0x43, 0x44, 0x0a, 0xce, 0x2e, 0x40, 0x44, 0x24, 0x19, 0x87, 0x2e, + 0x00, 0x45, 0x4d, 0xa3, 0x93, 0x2e, 0x00, 0x44, 0x60, 0xf6, 0xc1, 0x2e, + 0x00, 0x45, 0xd8, 0xf1, 0xf1, 0x2e, 0x40, 0xa5, 0x74, 0x44, 0x08, 0xf6, + 0xb6, 0x2e, 0x00, 0xa9, 0x3f, 0x05, 0x5e, 0x07, 0x2f, 0xae, 0x16, 0x06, + 0x22, 0xe5, 0x06, 0x42, 0x79, 0x08, 0x9c, 0x2e, 0x40, 0x43, 0x7a, 0x0b, + 0xac, 0x2e, 0x00, 0x43, 0x44, 0x0a, 0xad, 0x2e, 0x40, 0x43, 0x00, 0x29, + 0x92, 0x2e, 0x00, 0x04, 0x6b, 0x53, 0x01, 0xff, 0x43, 0x7a, 0x0b, 0x94, + 0x2e, 0x00, 0x43, 0x44, 0x0a, 0x95, 0x2e, 0x40, 0x43, 0x7a, 0x0b, 0x8c, + 0x2e, 0x00, 0x43, 0x44, 0x0a, 0x8d, 0x2e, 0x40, 0x42, 0xe1, 0x5d, 0xaf, + 0x2e, 0x00, 0x09, 0x57, 0x8d, 0x01, 0xff, 0xa8, 0x14, 0xb7, 0x06, 0x46, + 0xce, 0xdd, 0xe9, 0x2e, 0x40, 0x43, 0xe0, 0x5d, 0xcc, 0x2e, 0x00, 0x44, + 0xfd, 0xa1, 0xe8, 0x2e, 0x40, 0x4e, 0x2e, 0x79, 0xa6, 0x2e, 0x00, 0x43, + 0x28, 0x05, 0xc6, 0x2e, 0x40, 0x42, 0x13, 0x00, 0x8b, 0x2e, 0x00, 0x05, + 0xc0, 0x7f, 0x01, 0xff, 0x43, 0x7a, 0x0b, 0x82, 0x2e, 0x00, 0xb4, 0x01, + 0xff, 0x44, 0x25, 0x01, 0x84, 0x2e, 0x00, 0x42, 0x15, 0x02, 0x83, 0x2e, + 0x40, 0xa1, 0x06, 0x45, 0xc2, 0x6f, 0x80, 0x2e, 0x40, 0x42, 0x9e, 0x01, + 0xd7, 0x2e, 0x00, 0xed, 0xb7, 0x2e, 0x00, 0xf0, 0x99, 0x2e, 0x40, 0x03, + 0xde, 0x46, 0x06, 0x45, 0x41, 0x1e, 0x85, 0x2e, 0x40, 0x43, 0x7a, 0x0b, + 0xa4, 0x2e, 0x00, 0x43, 0x44, 0x0a, 0xa5, 0x2e, 0x40, 0x44, 0xf5, 0x06, + 0xb4, 0x2e, 0x00, 0x43, 0x7a, 0x0b, 0xb1, 0x2e, 0x00, 0xb4, 0x01, 0xff, + 0x44, 0x25, 0x01, 0xb3, 0x2e, 0x00, 0x42, 0x15, 0x02, 0xb2, 0x2e, 0x40, + 0xa5, 0x26, 0xaf, 0x01, 0xff, 0x42, 0x10, 0x00, 0x9d, 0x2e, 0x00, 0x44, + 0xc9, 0x4f, 0xbd, 0x2e, 0x00, 0x44, 0x31, 0x1b, 0x9f, 0x2e, 0x00, 0x04, + 0x29, 0x13, 0x01, 0xff, 0x43, 0x7a, 0x0b, 0xd5, 0x2e, 0x00, 0x43, 0x44, + 0x0a, 0xd6, 0x2e, 0x40, 0x42, 0x8a, 0x00, 0xbc, 0x2e, 0x00, 0x42, 0xa4, + 0x02, 0xb5, 0x2e, 0x40, 0x04, 0x3c, 0xbe, 0x11, 0x04, 0xd8, 0x02, 0x01, + 0xff, 0x43, 0x7a, 0x0b, 0xd1, 0x2e, 0x00, 0x43, 0x44, 0x0a, 0xd2, 0x2e, + 0x40, 0x44, 0xf5, 0x06, 0x91, 0x2e, 0x00, 0x43, 0x7a, 0x0b, 0x8e, 0x2e, + 0x00, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0x90, 0x2e, 0x00, 0x42, 0x15, + 0x02, 0x8f, 0x2e, 0x40, 0x43, 0x7a, 0x0b, 0x88, 0x2e, 0x00, 0x43, 0x44, + 0x0a, 0x89, 0x2e, 0x40, 0x0c, 0x74, 0x90, 0x06, 0x43, 0x0c, 0x02, 0xa9, + 0x2e, 0x40, 0x46, 0xfe, 0x93, 0xef, 0x2e, 0x00, 0x44, 0x06, 0x1f, 0xeb, + 0x2e, 0x00, 0xb4, 0x01, 0xff, 0x44, 0xd0, 0xf7, 0xed, 0x2e, 0x00, 0x45, + 0xd8, 0xf1, 0xf2, 0x2e, 0x40, 0x43, 0x1a, 0x00, 0x98, 0x2e, 0x00, 0x02, + 0x89, 0x00, 0x06, 0x43, 0x28, 0x05, 0xc7, 0x2e, 0x40, 0xe4, 0xe1, 0x2e, + 0x00, 0x03, 0x36, 0x07, 0x01, 0xff, 0x43, 0x7a, 0x0b, 0x96, 0x2e, 0x00, + 0x43, 0x44, 0x0a, 0x97, 0x2e, 0x40, 0x44, 0x9b, 0x80, 0xe4, 0x2e, 0x00, + 0x05, 0x3f, 0x21, 0x01, 0xff, 0x43, 0x7a, 0x0b, 0xbe, 0x2e, 0x00, 0xb4, + 0x01, 0xff, 0x44, 0x25, 0x01, 0xc0, 0x2e, 0x00, 0x42, 0x15, 0x02, 0xbf, + 0x2e, 0x40, 0x43, 0x16, 0x0e, 0xa3, 0x2e, 0x00, 0x43, 0x9f, 0x6c, 0xca, + 0x2e, 0x40, 0x03, 0x3d, 0x05, 0x0c, 0x42, 0x15, 0x01, 0xb8, 0x2e, 0x00, + 0x42, 0x4d, 0x00, 0xab, 0x2e, 0x40, 0x43, 0x7a, 0x0b, 0xdd, 0x2e, 0x00, + 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0xdf, 0x2e, 0x00, 0x42, 0x15, 0x02, + 0xde, 0x2e, 0x40, 0x44, 0x22, 0x10, 0x9e, 0x2e, 0x00, 0x49, 0x95, 0xc0, + 0x8a, 0x2e, 0x00, 0x42, 0xc7, 0x19, 0xa8, 0x2e, 0x40, 0x0c, 0x74, 0x90, + 0x28, 0x44, 0x52, 0xe3, 0x9b, 0x2e, 0x00, 0xa9, 0x14, 0xac, 0x06, 0x42, + 0xd1, 0x00, 0xa7, 0x2e, 0x40, 0x43, 0x8d, 0x4a, 0x81, 0x2e, 0x00, 0x45, + 0xc1, 0x8c, 0xc2, 0x2e, 0x40, 0x42, 0x4b, 0x12, 0xcf, 0x2e, 0x00, 0x46, + 0x20, 0xe7, 0xa0, 0x2e, 0x40, 0x44, 0xd2, 0xac, 0xe6, 0x2e, 0x00, 0x44, + 0x5a, 0x6f, 0xcb, 0x2e, 0x00, 0x46, 0xfe, 0x93, 0xf0, 0x2e, 0x00, 0xa5, + 0x70, 0xa6, 0x5c, 0xa7, 0x4e, 0x45, 0xbb, 0xb8, 0xe2, 0x2e, 0x00, 0xac, + 0x3a, 0xb3, 0x1a, 0xb4, 0x06, 0x44, 0x5c, 0x14, 0xdb, 0x2e, 0x40, 0x4d, + 0x7f, 0x84, 0xd9, 0x2e, 0x00, 0x44, 0xd0, 0xf7, 0xee, 0x2e, 0x00, 0x45, + 0xd8, 0xf1, 0xf3, 0x2e, 0x40, 0x43, 0xbf, 0x12, 0xe7, 0x2e, 0x00, 0x42, + 0x27, 0x01, 0xc5, 0x2e, 0x00, 0x44, 0x83, 0x09, 0xc9, 0x2e, 0x00, 0x43, + 0xdd, 0xb6, 0xb0, 0x2e, 0x00, 0x45, 0x4b, 0x80, 0xc8, 0x2e, 0x40, 0x43, + 0xa8, 0x53, 0xda, 0x2e, 0x00, 0x43, 0xd8, 0x02, 0xd3, 0x2e, 0x40, 0x43, + 0x8a, 0x00, 0xd4, 0x2e, 0x00, 0x43, 0x03, 0x1c, 0xd0, 0x2e, 0x40, 0x43, + 0x5f, 0x0d, 0xe5, 0x2e, 0x00, 0x42, 0xe1, 0x0b, 0xdc, 0x2e, 0x00, 0x43, + 0x72, 0x30, 0xea, 0x2e, 0x40, 0x42, 0x8a, 0x00, 0xe0, 0x2e, 0x00, 0x43, + 0x07, 0x1f, 0xec, 0x2e, 0x40, 0x45, 0x1d, 0xd5, 0xae, 0x2e, 0x00, 0x43, + 0x7d, 0x91, 0xd8, 0x2e, 0x00, 0xaf, 0x11, 0x05, 0x89, 0xf0, 0x01, 0xff, + 0x43, 0x7a, 0x0b, 0xba, 0x2e, 0x00, 0x43, 0x44, 0x0a, 0xbb, 0x2e, 0x40, + 0x4b, 0x23, 0xa4, 0xaa, 0x2e, 0x00, 0x42, 0xf1, 0x05, 0xe3, 0x2e, 0x00, + 0xf8, 0x86, 0x2e, 0x40, 0x44, 0x64, 0xf7, 0xa6, 0xf3, 0x01, 0x02, 0x14, + 0x03, 0x0d, 0x47, 0x93, 0xdc, 0xd9, 0xf3, 0xc1, 0x00, 0x48, 0xb7, 0xc7, + 0x06, 0xf3, 0x41, 0x02, 0x68, 0x00, 0x15, 0xb5, 0x01, 0xff, 0x4f, 0x6f, + 0x72, 0x10, 0x2a, 0x00, 0x4c, 0xd4, 0x04, 0x5e, 0x00, 0x00, 0x46, 0xca, + 0xe5, 0xaa, 0xf3, 0x41, 0x80, 0xaf, 0x0e, 0x02, 0x06, 0x00, 0x01, 0xff, + 0xa1, 0x91, 0x0e, 0xa2, 0xfa, 0x0d, 0xa3, 0xbe, 0x0d, 0xa4, 0xcd, 0x0c, + 0x46, 0x16, 0x14, 0x9c, 0x22, 0x00, 0x4c, 0x87, 0x00, 0xc1, 0x29, 0x00, + 0xa8, 0xe1, 0x0a, 0xa9, 0xc7, 0x07, 0xab, 0xdd, 0x05, 0xac, 0xf7, 0x03, + 0xad, 0xe8, 0x03, 0x07, 0x37, 0x3c, 0x6f, 0x5e, 0xf3, 0x14, 0x42, 0x27, + 0x00, 0xb0, 0x4f, 0xb2, 0x41, 0x46, 0xfd, 0x05, 0xd7, 0xf7, 0x01, 0xb4, + 0x26, 0x4c, 0x32, 0x00, 0xb6, 0x29, 0x00, 0xb7, 0x0a, 0xf8, 0xbe, 0x2b, + 0x00, 0x4f, 0x69, 0x78, 0x0d, 0xf1, 0x41, 0x05, 0xae, 0x02, 0x04, 0xfa, + 0x2e, 0xf1, 0x41, 0x46, 0xd5, 0x22, 0xbe, 0x29, 0x00, 0x44, 0xff, 0x13, + 0x2a, 0x27, 0x40, 0x44, 0x29, 0x02, 0x97, 0x22, 0x00, 0x47, 0x02, 0x02, + 0xd5, 0xf7, 0xc1, 0x00, 0x45, 0xa4, 0x01, 0x8a, 0x23, 0x40, 0x4e, 0xa9, + 0x75, 0xb8, 0x29, 0x00, 0x4c, 0xdc, 0x94, 0x9a, 0x22, 0x40, 0x47, 0x97, + 0x3a, 0xb7, 0x29, 0x00, 0x4c, 0x5c, 0x93, 0xb9, 0x29, 0x00, 0x43, 0xc7, + 0x29, 0x95, 0x22, 0x00, 0x4a, 0xba, 0xb4, 0x36, 0x30, 0x40, 0xa5, 0xdc, + 0x02, 0xa6, 0xec, 0x01, 0x48, 0x21, 0x56, 0x72, 0x24, 0x00, 0xb3, 0xc2, + 0x01, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x69, 0x24, 0x80, 0xb1, 0x01, + 0x04, 0x48, 0x12, 0x5a, 0x02, 0x15, 0x01, 0x01, 0xff, 0x43, 0x86, 0x2d, + 0x6b, 0x24, 0x00, 0x43, 0xea, 0x1e, 0x73, 0x24, 0xc0, 0x00, 0x80, 0x01, + 0xff, 0x45, 0x7e, 0x0b, 0x58, 0x32, 0x00, 0xa6, 0x31, 0x44, 0x6d, 0x2c, + 0x59, 0x32, 0x00, 0x02, 0x10, 0x00, 0x1d, 0xb3, 0x0f, 0xb4, 0x01, 0xff, + 0x44, 0x25, 0x01, 0x53, 0x32, 0x00, 0x42, 0x15, 0x02, 0x52, 0x32, 0x40, + 0x44, 0x06, 0x1f, 0x57, 0x32, 0x00, 0x42, 0x09, 0x24, 0x56, 0x32, 0x40, + 0x4d, 0x0f, 0x12, 0x49, 0x32, 0x00, 0xe5, 0x51, 0x32, 0x40, 0x43, 0xf9, + 0x05, 0x55, 0x32, 0x00, 0x43, 0xf6, 0x06, 0x54, 0x32, 0x40, 0x43, 0xe9, + 0x09, 0x6c, 0x24, 0x00, 0xf9, 0x5a, 0x32, 0xc0, 0x00, 0x80, 0x01, 0xff, + 0x45, 0x7e, 0x0b, 0xb3, 0x32, 0x00, 0xa6, 0x31, 0x44, 0x6d, 0x2c, 0xb4, + 0x32, 0x00, 0x02, 0x10, 0x00, 0x1d, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, + 0x25, 0x01, 0x5d, 0x32, 0x00, 0x42, 0x15, 0x02, 0x5c, 0x32, 0x40, 0x44, + 0x06, 0x1f, 0xb2, 0x32, 0x00, 0x42, 0x09, 0x24, 0xb1, 0x32, 0x40, 0x4d, + 0x0f, 0x12, 0x4a, 0x32, 0x00, 0xe5, 0x5b, 0x32, 0x40, 0x43, 0xf9, 0x05, + 0x5f, 0x32, 0x00, 0x43, 0xf6, 0x06, 0x5e, 0x32, 0x40, 0x50, 0x78, 0x62, + 0x48, 0x32, 0x40, 0x05, 0x06, 0x1f, 0x11, 0x03, 0x09, 0x24, 0x01, 0xff, + 0x43, 0xe9, 0x09, 0x6f, 0x24, 0x00, 0x51, 0x77, 0x62, 0x4d, 0x32, 0x40, + 0x43, 0xe9, 0x09, 0x70, 0x24, 0x00, 0x51, 0x77, 0x62, 0x4e, 0x32, 0x40, + 0x03, 0x0e, 0x19, 0x58, 0xaf, 0x01, 0xff, 0x43, 0x4a, 0x12, 0xb5, 0x32, + 0x80, 0x06, 0x46, 0x9d, 0x5f, 0x6d, 0x24, 0x40, 0x80, 0x01, 0xff, 0x45, + 0x7e, 0x0b, 0xbd, 0x32, 0x00, 0xa6, 0x31, 0x44, 0x6d, 0x2c, 0xbe, 0x32, 0x00, 0x02, 0x10, 0x00, 0x1d, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, - 0x01, 0x53, 0x32, 0x00, 0x42, 0x15, 0x02, 0x52, 0x32, 0x40, 0x44, 0xe5, - 0x1d, 0x57, 0x32, 0x00, 0x42, 0x1c, 0x26, 0x56, 0x32, 0x40, 0x4d, 0x41, - 0x11, 0x49, 0x32, 0x00, 0xe5, 0x51, 0x32, 0x40, 0x43, 0xd2, 0x05, 0x55, - 0x32, 0x00, 0x43, 0xf6, 0x06, 0x54, 0x32, 0x40, 0x43, 0xc4, 0x09, 0x6c, - 0x24, 0x00, 0xf9, 0x5a, 0x32, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x45, 0x12, - 0x0b, 0xb3, 0x32, 0x00, 0xa6, 0x31, 0x44, 0xea, 0x2a, 0xb4, 0x32, 0x00, - 0x02, 0x10, 0x00, 0x1d, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, - 0x5d, 0x32, 0x00, 0x42, 0x15, 0x02, 0x5c, 0x32, 0x40, 0x44, 0xe5, 0x1d, - 0xb2, 0x32, 0x00, 0x42, 0x1c, 0x26, 0xb1, 0x32, 0x40, 0x4d, 0x41, 0x11, - 0x4a, 0x32, 0x00, 0xe5, 0x5b, 0x32, 0x40, 0x43, 0xd2, 0x05, 0x5f, 0x32, - 0x00, 0x43, 0xf6, 0x06, 0x5e, 0x32, 0x40, 0x50, 0xcb, 0x5f, 0x48, 0x32, - 0x40, 0x05, 0xe5, 0x1d, 0x11, 0x03, 0x1c, 0x26, 0x01, 0xff, 0x43, 0xc4, - 0x09, 0x6f, 0x24, 0x00, 0x51, 0xca, 0x5f, 0x4d, 0x32, 0x40, 0x43, 0xc4, - 0x09, 0x70, 0x24, 0x00, 0x51, 0xca, 0x5f, 0x4e, 0x32, 0x40, 0x03, 0x24, - 0x18, 0x58, 0xaf, 0x01, 0xff, 0x43, 0x7c, 0x11, 0xb5, 0x32, 0x80, 0x06, - 0x46, 0x12, 0x5d, 0x6d, 0x24, 0x40, 0x80, 0x01, 0xff, 0x45, 0x12, 0x0b, - 0xbd, 0x32, 0x00, 0xa6, 0x31, 0x44, 0xea, 0x2a, 0xbe, 0x32, 0x00, 0x02, - 0x10, 0x00, 0x1d, 0xb3, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, 0x01, 0xb8, - 0x32, 0x00, 0x42, 0x15, 0x02, 0xb7, 0x32, 0x40, 0x44, 0xe5, 0x1d, 0xbc, - 0x32, 0x00, 0x42, 0x1c, 0x26, 0xbb, 0x32, 0x40, 0x4d, 0x41, 0x11, 0x4b, - 0x32, 0x00, 0xe5, 0xb6, 0x32, 0x40, 0x43, 0xd2, 0x05, 0xba, 0x32, 0x00, - 0x43, 0xf6, 0x06, 0xb9, 0x32, 0x40, 0x43, 0xc4, 0x09, 0x6e, 0x24, 0x00, - 0xf9, 0xbf, 0x32, 0xc0, 0x00, 0x50, 0xcb, 0x5f, 0x4c, 0x32, 0x40, 0x04, - 0xc9, 0x00, 0x06, 0x45, 0xbb, 0x6f, 0x6a, 0x24, 0x40, 0x43, 0xc4, 0x09, - 0x71, 0x24, 0x00, 0x51, 0xca, 0x5f, 0x4f, 0x32, 0x40, 0x44, 0x94, 0x1f, - 0x96, 0x22, 0x00, 0x69, 0xb7, 0x04, 0x36, 0x2a, 0x40, 0x05, 0xdf, 0x05, - 0x06, 0x48, 0xed, 0x00, 0xc0, 0x29, 0x40, 0x0f, 0xe4, 0x05, 0x6d, 0x0d, - 0x76, 0x08, 0x01, 0xff, 0xe1, 0xd0, 0x24, 0x00, 0xe2, 0xd1, 0x24, 0x00, - 0xe3, 0xd2, 0x24, 0x00, 0xe4, 0xd3, 0x24, 0x00, 0xe5, 0xd4, 0x24, 0x00, - 0xe6, 0xd5, 0x24, 0x00, 0xe7, 0xd6, 0x24, 0x00, 0xe8, 0xd7, 0x24, 0x00, - 0xe9, 0xd8, 0x24, 0x00, 0xea, 0xd9, 0x24, 0x00, 0xeb, 0xda, 0x24, 0x00, - 0xec, 0xdb, 0x24, 0x00, 0xed, 0xdc, 0x24, 0x00, 0xee, 0xdd, 0x24, 0x00, - 0xef, 0xde, 0x24, 0x00, 0xf0, 0xdf, 0x24, 0x00, 0xf1, 0xe0, 0x24, 0x00, - 0xf2, 0xe1, 0x24, 0x00, 0xf3, 0xe2, 0x24, 0x00, 0xf4, 0xe3, 0x24, 0x00, - 0xf5, 0xe4, 0x24, 0x00, 0xf6, 0xe5, 0x24, 0x00, 0xf7, 0xe6, 0x24, 0x00, - 0xf8, 0xe7, 0x24, 0x00, 0xf9, 0xe8, 0x24, 0x00, 0xfa, 0xe9, 0x24, 0x40, - 0xe1, 0xb6, 0x24, 0x00, 0xe2, 0xb7, 0x24, 0x00, 0xe3, 0xb8, 0x24, 0x00, - 0xe4, 0xb9, 0x24, 0x00, 0xe5, 0xba, 0x24, 0x00, 0xe6, 0xbb, 0x24, 0x00, - 0xe7, 0xbc, 0x24, 0x00, 0xe8, 0xbd, 0x24, 0x00, 0xe9, 0xbe, 0x24, 0x00, - 0xea, 0xbf, 0x24, 0x00, 0xeb, 0xc0, 0x24, 0x00, 0xec, 0xc1, 0x24, 0x00, - 0xed, 0xc2, 0x24, 0x00, 0xee, 0xc3, 0x24, 0x00, 0xef, 0xc4, 0x24, 0x00, - 0xf0, 0xc5, 0x24, 0x00, 0xf1, 0xc6, 0x24, 0x00, 0xf2, 0xc7, 0x24, 0x00, - 0xf3, 0xc8, 0x24, 0x00, 0xf4, 0xc9, 0x24, 0x00, 0xf5, 0xca, 0x24, 0x00, - 0xf6, 0xcb, 0x24, 0x00, 0xf7, 0xcc, 0x24, 0x00, 0xf8, 0xcd, 0x24, 0x00, - 0xf9, 0xce, 0x24, 0x00, 0xfa, 0xcf, 0x24, 0x40, 0x08, 0xd1, 0xc3, 0x11, - 0x10, 0x4f, 0x53, 0x01, 0xff, 0x46, 0x96, 0xda, 0x7c, 0x32, 0x00, 0x45, - 0xd8, 0xe7, 0x7d, 0x32, 0x40, 0xe1, 0xd0, 0x32, 0x00, 0xe5, 0xd3, 0x32, - 0x00, 0xa8, 0xb3, 0x01, 0xe9, 0xd1, 0x32, 0x00, 0xab, 0x98, 0x01, 0xad, - 0x81, 0x01, 0xae, 0x6b, 0xef, 0xd4, 0x32, 0x00, 0xb2, 0x51, 0xb3, 0x3b, - 0xb4, 0x25, 0xf5, 0xd2, 0x32, 0x00, 0xb7, 0x0f, 0xb9, 0x01, 0xff, 0xe1, - 0xf3, 0x32, 0x00, 0xef, 0xf5, 0x32, 0x00, 0xf5, 0xf4, 0x32, 0x40, 0xe1, - 0xfb, 0x32, 0x00, 0xe5, 0xfd, 0x32, 0x00, 0xe9, 0xfc, 0x32, 0x00, 0xef, - 0xfe, 0x32, 0x40, 0xe1, 0xdf, 0x32, 0x00, 0xe5, 0xe2, 0x32, 0x00, 0xe9, - 0xe0, 0x32, 0x00, 0xef, 0xe3, 0x32, 0x00, 0xf5, 0xe1, 0x32, 0x40, 0xe1, - 0xda, 0x32, 0x00, 0xe5, 0xdd, 0x32, 0x00, 0xe9, 0xdb, 0x32, 0x00, 0xef, - 0xde, 0x32, 0x00, 0xf5, 0xdc, 0x32, 0x40, 0xe1, 0xf6, 0x32, 0x00, 0xe5, - 0xf9, 0x32, 0x00, 0xe9, 0xf7, 0x32, 0x00, 0xef, 0xfa, 0x32, 0x00, 0xf5, - 0xf8, 0x32, 0x40, 0xe1, 0xe4, 0x32, 0x00, 0xe5, 0xe7, 0x32, 0x00, 0xe9, - 0xe5, 0x32, 0x00, 0xef, 0xe8, 0x32, 0x00, 0xf5, 0xe6, 0x32, 0x40, 0xe1, - 0xee, 0x32, 0x00, 0xe5, 0xf1, 0x32, 0x00, 0xe9, 0xef, 0x32, 0x00, 0xef, - 0xf2, 0x32, 0x00, 0xf5, 0xf0, 0x32, 0x40, 0xe1, 0xd5, 0x32, 0x00, 0xe5, - 0xd8, 0x32, 0x00, 0xe9, 0xd6, 0x32, 0x00, 0xef, 0xd9, 0x32, 0x00, 0xf5, - 0xd7, 0x32, 0x40, 0xe1, 0xe9, 0x32, 0x00, 0xe5, 0xec, 0x32, 0x00, 0xe9, - 0xea, 0x32, 0x00, 0xef, 0xed, 0x32, 0x00, 0xf5, 0xeb, 0x32, 0x40, 0x09, - 0x9f, 0xab, 0x13, 0x51, 0xbc, 0x5c, 0xc8, 0xf6, 0x01, 0x1b, 0xbd, 0x1d, - 0x01, 0xff, 0xe3, 0x2b, 0xf1, 0x01, 0xf2, 0x2c, 0xf1, 0x41, 0xa1, 0xe5, - 0x02, 0xa3, 0xc7, 0x02, 0xa5, 0xac, 0x02, 0xa6, 0x89, 0x02, 0xa8, 0xfa, - 0x01, 0x44, 0x96, 0xc1, 0xa0, 0x32, 0x00, 0xab, 0xe5, 0x01, 0xac, 0xd0, - 0x01, 0xad, 0xb3, 0x01, 0xae, 0x9b, 0x01, 0x43, 0x0e, 0x0b, 0x80, 0x32, - 0x00, 0x45, 0x8c, 0xc6, 0x9e, 0x32, 0x00, 0x48, 0xc1, 0x34, 0x44, 0x32, - 0x00, 0xb2, 0x6c, 0xb3, 0x23, 0xb4, 0x0f, 0xb7, 0x01, 0xff, 0x44, 0x8a, - 0x00, 0x8c, 0x32, 0x00, 0x43, 0xcf, 0x2d, 0x8d, 0x32, 0x40, 0x42, 0x92, - 0x01, 0x89, 0x32, 0x00, 0x44, 0x25, 0x01, 0x82, 0x32, 0x00, 0x42, 0x15, - 0x02, 0x81, 0x32, 0x40, 0x45, 0x53, 0xe5, 0x46, 0x32, 0x00, 0xa5, 0x33, - 0x42, 0x1c, 0x26, 0x85, 0x32, 0x00, 0x46, 0xc8, 0xde, 0x93, 0x32, 0x00, - 0x46, 0x2e, 0xdf, 0x95, 0x32, 0x00, 0xb4, 0x13, 0xb5, 0x01, 0xff, 0x46, - 0x48, 0xdd, 0x9c, 0x32, 0x00, 0xee, 0x90, 0x32, 0x00, 0x47, 0xd2, 0xd4, - 0xac, 0x32, 0x40, 0x43, 0x35, 0x01, 0x91, 0x32, 0x00, 0x43, 0xcd, 0xf4, - 0xab, 0x32, 0x40, 0x44, 0x8d, 0xef, 0x99, 0x32, 0x00, 0x43, 0xe6, 0x1d, - 0x86, 0x32, 0x40, 0xa5, 0x06, 0x44, 0xc9, 0x00, 0xa8, 0x32, 0x40, 0x46, - 0xd2, 0xdd, 0xaa, 0x32, 0x00, 0xb3, 0x01, 0xff, 0x45, 0xc8, 0x5c, 0xae, - 0x32, 0x00, 0xf4, 0xa1, 0x32, 0x40, 0x43, 0x2b, 0x05, 0x94, 0x32, 0x00, - 0xa9, 0x01, 0xff, 0x43, 0xca, 0x00, 0xb0, 0x32, 0x00, 0x42, 0xcd, 0x05, - 0x88, 0x32, 0x40, 0x43, 0x67, 0x00, 0x9a, 0x32, 0x00, 0xa5, 0x06, 0x43, - 0xcd, 0x02, 0x8a, 0x32, 0x40, 0x46, 0x0e, 0xdb, 0xa9, 0x32, 0x00, 0x43, - 0x12, 0x00, 0x8e, 0x32, 0x40, 0x44, 0x29, 0xe8, 0x98, 0x32, 0x00, 0x43, - 0xc4, 0x00, 0xa7, 0x32, 0x00, 0x42, 0xd1, 0x00, 0xa6, 0x32, 0x40, 0x4b, - 0xa4, 0x9d, 0x45, 0x32, 0x00, 0x43, 0x1d, 0x8e, 0x47, 0x32, 0x40, 0x43, - 0x2f, 0x08, 0x92, 0x32, 0x00, 0x43, 0x3f, 0x00, 0xa4, 0x32, 0x40, 0x45, - 0x59, 0x21, 0x9b, 0x32, 0x00, 0xa9, 0x06, 0x43, 0xf6, 0x06, 0x83, 0x32, - 0x40, 0x47, 0x89, 0xd3, 0x96, 0x32, 0x00, 0x42, 0x88, 0x00, 0x8b, 0x32, - 0x00, 0x42, 0x32, 0x00, 0x84, 0x32, 0x40, 0x44, 0x5a, 0x72, 0x8f, 0x32, - 0x00, 0x44, 0xc9, 0x00, 0x87, 0x32, 0x00, 0x49, 0xc3, 0xbc, 0xad, 0x32, - 0x00, 0x48, 0xc1, 0xcc, 0x9d, 0x32, 0x40, 0x45, 0x74, 0x02, 0xa5, 0x32, - 0x00, 0xaf, 0x01, 0xff, 0x4c, 0x1f, 0x87, 0x97, 0x32, 0x00, 0x42, 0x37, - 0x1d, 0xa2, 0x32, 0x00, 0x45, 0x96, 0xd5, 0xa3, 0x32, 0x40, 0x45, 0x26, - 0xe5, 0x51, 0xf2, 0x01, 0x48, 0x69, 0xc5, 0x50, 0xf2, 0x01, 0x47, 0x62, - 0xc3, 0xaf, 0x32, 0x00, 0x48, 0xe1, 0xcb, 0x9f, 0x32, 0x40, 0x06, 0x92, - 0xd1, 0x12, 0x5b, 0x1a, 0x1b, 0xb2, 0x27, 0x00, 0x58, 0x69, 0x2a, 0x89, - 0x23, 0x00, 0x4b, 0x6e, 0xa4, 0x6f, 0xf1, 0x41, 0xa3, 0xaa, 0x01, 0x45, - 0x92, 0xa5, 0x6d, 0x32, 0x80, 0x9c, 0x01, 0x45, 0x37, 0xcc, 0x67, 0x32, - 0x80, 0x89, 0x01, 0xab, 0x6d, 0x45, 0xc8, 0xe8, 0x64, 0x32, 0x80, 0x60, - 0x45, 0x3b, 0xe9, 0x61, 0x32, 0x80, 0x53, 0xb0, 0x37, 0x45, 0x85, 0xea, - 0x63, 0x32, 0x80, 0x2a, 0x44, 0x86, 0xbf, 0x66, 0x32, 0x80, 0x1d, 0xb4, - 0x01, 0xff, 0x46, 0x77, 0xd6, 0x6b, 0x32, 0x80, 0x0d, 0x45, 0xfe, 0xcd, - 0x62, 0x32, 0xc0, 0x00, 0x42, 0x19, 0x00, 0x70, 0x32, 0x40, 0x42, 0x19, - 0x00, 0x79, 0x32, 0x40, 0x42, 0x19, 0x00, 0x74, 0x32, 0x40, 0x42, 0x19, - 0x00, 0x71, 0x32, 0x40, 0x46, 0xf3, 0xc2, 0x6c, 0x32, 0x80, 0x0d, 0x44, - 0xf8, 0x84, 0x65, 0x32, 0xc0, 0x00, 0x42, 0x19, 0x00, 0x73, 0x32, 0x40, - 0x42, 0x19, 0x00, 0x7a, 0x32, 0x40, 0x42, 0x19, 0x00, 0x6f, 0x32, 0x40, - 0x42, 0x19, 0x00, 0x72, 0x32, 0x40, 0x46, 0xeb, 0xc2, 0x6a, 0x32, 0x80, - 0x0d, 0x45, 0xfe, 0xa2, 0x60, 0x32, 0xc0, 0x00, 0x42, 0x19, 0x00, 0x6e, - 0x32, 0x40, 0x42, 0x19, 0x00, 0x78, 0x32, 0x40, 0x80, 0x01, 0xff, 0xe1, - 0x75, 0x32, 0x00, 0xf5, 0x7e, 0x32, 0x40, 0x42, 0x19, 0x00, 0x7b, 0x32, - 0x40, 0x46, 0x03, 0xd0, 0x69, 0x32, 0x80, 0x0d, 0x44, 0x04, 0xd0, 0x68, - 0x32, 0xc0, 0x00, 0x42, 0x19, 0x00, 0x76, 0x32, 0x40, 0x42, 0x19, 0x00, - 0x77, 0x32, 0x40, 0x43, 0xf9, 0x03, 0x9d, 0x22, 0x00, 0xa9, 0x0f, 0xaf, - 0x01, 0xff, 0x61, 0x2c, 0x0e, 0x0f, 0xf1, 0x01, 0x4a, 0x16, 0x37, 0x99, - 0x22, 0x40, 0x04, 0xf1, 0x06, 0x11, 0x08, 0xdf, 0x32, 0x01, 0xff, 0x43, - 0x5b, 0x03, 0x38, 0x2a, 0x00, 0x44, 0x49, 0x0e, 0x98, 0x22, 0x40, 0x45, - 0x12, 0x0b, 0x67, 0x24, 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x68, 0x24, - 0x00, 0x43, 0x0e, 0x0b, 0x60, 0x24, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, - 0x5f, 0x1e, 0xea, 0x24, 0x40, 0x44, 0x25, 0x01, 0x62, 0x24, 0x00, 0x42, - 0x15, 0x02, 0x61, 0x24, 0x40, 0x44, 0xe5, 0x1d, 0x66, 0x24, 0x00, 0x42, - 0x1c, 0x26, 0x65, 0x24, 0x40, 0x43, 0xd2, 0x05, 0x64, 0x24, 0x00, 0x43, - 0xf6, 0x06, 0x63, 0x24, 0x40, 0x58, 0x35, 0x0e, 0x6e, 0xf1, 0x01, 0xe3, - 0x6d, 0xf1, 0x01, 0xe4, 0x2d, 0xf1, 0x01, 0x04, 0x96, 0x10, 0x01, 0xff, - 0x80, 0x06, 0x49, 0xb0, 0xba, 0xd2, 0x26, 0x40, 0x46, 0xec, 0xdb, 0x02, - 0xf9, 0x81, 0x06, 0x46, 0x5e, 0xdf, 0x40, 0xf5, 0x41, 0x06, 0x50, 0x00, - 0x01, 0xff, 0x49, 0xd8, 0x46, 0x00, 0xf9, 0x01, 0x48, 0x1f, 0x0a, 0x01, - 0xf9, 0x41, 0x45, 0xa9, 0xe9, 0xbf, 0x2b, 0x00, 0x45, 0xb5, 0x21, 0xbf, - 0x29, 0x40, 0x0c, 0x35, 0x0b, 0x06, 0x50, 0x6d, 0x67, 0x9b, 0x22, 0x40, - 0x46, 0xcd, 0x00, 0x0e, 0xf1, 0x01, 0x56, 0xd4, 0x32, 0xbc, 0x29, 0x40, - 0x7e, 0x00, 0x00, 0xba, 0x29, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x61, - 0x66, 0x0d, 0xd5, 0x25, 0x00, 0x4e, 0x0b, 0x00, 0xb5, 0x29, 0x00, 0xac, - 0x30, 0x50, 0xbd, 0x66, 0xd1, 0x25, 0x00, 0xb3, 0x1c, 0x63, 0xaa, 0x0b, - 0xc3, 0x29, 0x00, 0x06, 0x6d, 0x02, 0x06, 0x4d, 0x44, 0x8a, 0xcd, 0x25, - 0x40, 0x4a, 0x07, 0x26, 0xd3, 0x25, 0x00, 0x54, 0x6b, 0x45, 0xd4, 0x25, - 0x40, 0x58, 0x09, 0x2a, 0xc2, 0x29, 0x00, 0x4d, 0xa8, 0x89, 0xbb, 0x29, - 0x40, 0x4e, 0x80, 0x6f, 0xd0, 0x25, 0x00, 0x4f, 0xaa, 0x71, 0xd2, 0x25, - 0x40, 0xa1, 0xfa, 0x08, 0xa5, 0x92, 0x02, 0xa9, 0xda, 0x01, 0xaf, 0x0c, - 0x4c, 0xd4, 0x94, 0x84, 0xf3, 0x01, 0x44, 0xc2, 0xda, 0xea, 0x26, 0x40, - 0x4a, 0xe2, 0xa8, 0x6b, 0xf3, 0x01, 0x47, 0x03, 0xd5, 0x62, 0xf9, 0x01, - 0x08, 0x49, 0xca, 0x01, 0xff, 0x07, 0xec, 0x05, 0x34, 0x07, 0x1a, 0x3a, - 0x01, 0xff, 0x44, 0xf5, 0x06, 0xc8, 0x0f, 0x01, 0x43, 0x0e, 0x0b, 0xc5, - 0x0f, 0x81, 0x1c, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0xc9, 0x0f, 0x01, - 0x44, 0x25, 0x01, 0xc7, 0x0f, 0x01, 0xb7, 0x01, 0xff, 0x44, 0xe7, 0x1d, - 0xca, 0x0f, 0x01, 0xef, 0xc6, 0x0f, 0x41, 0x48, 0x70, 0x11, 0xcb, 0x0f, - 0x41, 0xa1, 0x75, 0x44, 0x61, 0xef, 0xb2, 0x0f, 0x01, 0x4a, 0x14, 0xa9, - 0xb7, 0x0f, 0x01, 0x46, 0x2a, 0x4a, 0xb4, 0x0f, 0x01, 0x45, 0xfe, 0xaa, - 0xb3, 0x0f, 0x01, 0x42, 0xb0, 0x01, 0xb5, 0x0f, 0x81, 0x50, 0x44, 0xed, - 0xf0, 0xbb, 0x0f, 0x01, 0x46, 0xb4, 0xdd, 0xbc, 0x0f, 0x01, 0x43, 0xb4, - 0x05, 0xbd, 0x0f, 0x01, 0x43, 0xde, 0x22, 0xbe, 0x0f, 0x01, 0x42, 0x6f, - 0x02, 0xc1, 0x0f, 0x01, 0x44, 0x7d, 0x66, 0xc2, 0x0f, 0x01, 0xb3, 0x18, - 0x43, 0xc5, 0xc4, 0xc4, 0x0f, 0x01, 0x43, 0x9f, 0x8a, 0xb6, 0x0f, 0x01, - 0x44, 0xa8, 0x52, 0xba, 0x0f, 0x01, 0x45, 0xa2, 0x52, 0xb8, 0x0f, 0x41, - 0x45, 0x68, 0xe4, 0xbf, 0x0f, 0x01, 0x43, 0x7a, 0x16, 0xc3, 0x0f, 0x01, - 0x4a, 0xce, 0xad, 0xb1, 0x0f, 0x41, 0x42, 0x53, 0x00, 0xb9, 0x0f, 0x41, - 0x44, 0x33, 0x3d, 0xb0, 0x0f, 0x01, 0x43, 0x9a, 0x1a, 0xc0, 0x0f, 0x41, - 0x44, 0xe9, 0x8a, 0x27, 0x26, 0x00, 0x44, 0x90, 0x01, 0x14, 0xf4, 0x01, - 0x42, 0xfe, 0x1a, 0xd2, 0xf9, 0x81, 0x1c, 0x0b, 0x22, 0xa0, 0x0c, 0x45, - 0x1c, 0xea, 0x3f, 0xf4, 0x01, 0x43, 0xb1, 0x0e, 0xb7, 0x26, 0x40, 0x4d, - 0xe5, 0x88, 0xf2, 0x6f, 0x01, 0x4e, 0x56, 0x7d, 0xf3, 0x6f, 0x41, 0x4c, - 0x74, 0x94, 0xb8, 0xf6, 0x41, 0x02, 0x36, 0x01, 0xcd, 0x06, 0xa5, 0xbe, - 0x06, 0x4b, 0xae, 0xa1, 0xc1, 0xf3, 0x01, 0xb2, 0x06, 0x45, 0x39, 0xeb, - 0x30, 0xf3, 0x41, 0x05, 0xa4, 0xe9, 0x1a, 0xb2, 0x01, 0xff, 0x43, 0x35, - 0x9e, 0x52, 0xf3, 0x01, 0x02, 0x09, 0x00, 0x01, 0xff, 0x47, 0xa7, 0xcf, - 0x38, 0xf3, 0x01, 0x46, 0x16, 0x08, 0xbe, 0xce, 0x41, 0x07, 0xec, 0x05, - 0x89, 0x03, 0x0d, 0x76, 0x08, 0x01, 0xff, 0xe1, 0x70, 0xab, 0x00, 0xa4, - 0xdf, 0x02, 0xe5, 0x71, 0xab, 0x00, 0xa7, 0xc0, 0x02, 0xa8, 0x9f, 0x02, - 0xe9, 0x72, 0xab, 0x00, 0x42, 0x1b, 0x02, 0x77, 0xab, 0x00, 0xac, 0xfa, - 0x01, 0xad, 0xdf, 0x01, 0xae, 0xbf, 0x01, 0xef, 0x73, 0xab, 0x00, 0x02, - 0x7c, 0x00, 0x9e, 0x01, 0xf3, 0x9d, 0xab, 0x80, 0x80, 0x01, 0xb4, 0x3d, - 0xf5, 0x74, 0xab, 0x00, 0xf6, 0x75, 0xab, 0x00, 0xb7, 0x1b, 0xb9, 0x01, - 0xff, 0xe1, 0xbf, 0xab, 0x00, 0xe5, 0xf8, 0x13, 0x00, 0xe9, 0xf9, 0x13, - 0x00, 0xef, 0xfa, 0x13, 0x00, 0xf5, 0xfb, 0x13, 0x00, 0xf6, 0xfc, 0x13, - 0x40, 0xe1, 0xb9, 0xab, 0x00, 0xe5, 0xba, 0xab, 0x00, 0xe9, 0xbb, 0xab, - 0x00, 0xef, 0xbc, 0xab, 0x00, 0xf5, 0xbd, 0xab, 0x00, 0xf6, 0xbe, 0xab, - 0x40, 0xe1, 0xa4, 0xab, 0x00, 0xe5, 0xa6, 0xab, 0x00, 0xe9, 0xa8, 0xab, - 0x00, 0xac, 0x1b, 0xb3, 0x01, 0xff, 0xe1, 0xb3, 0xab, 0x00, 0xe5, 0xb4, - 0xab, 0x00, 0xe9, 0xb5, 0xab, 0x00, 0xef, 0xb6, 0xab, 0x00, 0xf5, 0xb7, - 0xab, 0x00, 0xf6, 0xb8, 0xab, 0x40, 0xe1, 0xad, 0xab, 0x00, 0xe5, 0xae, - 0xab, 0x00, 0xe9, 0xaf, 0xab, 0x00, 0xef, 0xb0, 0xab, 0x00, 0xf5, 0xb1, - 0xab, 0x00, 0xf6, 0xb2, 0xab, 0x40, 0xe1, 0x9c, 0xab, 0x00, 0xe5, 0x9e, - 0xab, 0x00, 0xe9, 0x9f, 0xab, 0x00, 0xef, 0xa0, 0xab, 0x00, 0xf5, 0xa1, - 0xab, 0x00, 0xf6, 0xa2, 0xab, 0x40, 0xe1, 0x96, 0xab, 0x00, 0xe5, 0x97, - 0xab, 0x00, 0xe9, 0x98, 0xab, 0x00, 0xef, 0x99, 0xab, 0x00, 0xf5, 0x9a, - 0xab, 0x00, 0xf6, 0x9b, 0xab, 0x40, 0xe1, 0x8e, 0xab, 0x80, 0x14, 0xe5, - 0x91, 0xab, 0x00, 0xe9, 0x92, 0xab, 0x00, 0xef, 0x93, 0xab, 0x00, 0xf5, - 0x94, 0xab, 0x00, 0xf6, 0x95, 0xab, 0x40, 0xe8, 0x90, 0xab, 0x40, 0xe1, - 0x89, 0xab, 0x00, 0xe5, 0x8a, 0xab, 0x00, 0xe9, 0x8b, 0xab, 0x00, 0xef, - 0x8c, 0xab, 0x00, 0xf5, 0x8d, 0xab, 0x00, 0xf6, 0xfd, 0x13, 0x40, 0xe1, - 0x83, 0xab, 0x00, 0xe5, 0x84, 0xab, 0x00, 0xe9, 0x85, 0xab, 0x00, 0xef, - 0x86, 0xab, 0x00, 0xf5, 0x87, 0xab, 0x00, 0xf6, 0x88, 0xab, 0x40, 0xe1, - 0x7d, 0xab, 0x00, 0xe5, 0x7e, 0xab, 0x00, 0xe9, 0x7f, 0xab, 0x00, 0x42, - 0x2a, 0x05, 0x8f, 0xab, 0x00, 0xef, 0x80, 0xab, 0x00, 0xf5, 0x81, 0xab, - 0x00, 0xf6, 0x82, 0xab, 0x40, 0xe1, 0x76, 0xab, 0x00, 0xe5, 0x78, 0xab, - 0x00, 0xe9, 0x79, 0xab, 0x00, 0xef, 0x7a, 0xab, 0x00, 0xf5, 0x7b, 0xab, - 0x00, 0xf6, 0x7c, 0xab, 0x40, 0xe1, 0xa3, 0xab, 0x00, 0xe5, 0xa5, 0xab, - 0x00, 0xe9, 0xa7, 0xab, 0x00, 0x42, 0x74, 0x00, 0xac, 0xab, 0x00, 0xef, - 0xa9, 0xab, 0x00, 0xf5, 0xaa, 0xab, 0x00, 0xf6, 0xab, 0xab, 0x40, 0xe1, - 0xa0, 0x13, 0x00, 0xa4, 0xdf, 0x02, 0xe5, 0xa1, 0x13, 0x00, 0xa7, 0xc0, - 0x02, 0xa8, 0x9f, 0x02, 0xe9, 0xa2, 0x13, 0x00, 0x42, 0x1b, 0x02, 0xa7, - 0x13, 0x00, 0xac, 0xfa, 0x01, 0xad, 0xdf, 0x01, 0xae, 0xbf, 0x01, 0xef, - 0xa3, 0x13, 0x00, 0x02, 0x7c, 0x00, 0x9e, 0x01, 0xf3, 0xcd, 0x13, 0x80, - 0x80, 0x01, 0xb4, 0x3d, 0xf5, 0xa4, 0x13, 0x00, 0xf6, 0xa5, 0x13, 0x00, - 0xb7, 0x1b, 0xb9, 0x01, 0xff, 0xe1, 0xef, 0x13, 0x00, 0xe5, 0xf0, 0x13, - 0x00, 0xe9, 0xf1, 0x13, 0x00, 0xef, 0xf2, 0x13, 0x00, 0xf5, 0xf3, 0x13, - 0x00, 0xf6, 0xf4, 0x13, 0x40, 0xe1, 0xe9, 0x13, 0x00, 0xe5, 0xea, 0x13, - 0x00, 0xe9, 0xeb, 0x13, 0x00, 0xef, 0xec, 0x13, 0x00, 0xf5, 0xed, 0x13, - 0x00, 0xf6, 0xee, 0x13, 0x40, 0xe1, 0xd4, 0x13, 0x00, 0xe5, 0xd6, 0x13, - 0x00, 0xe9, 0xd8, 0x13, 0x00, 0xac, 0x1b, 0xb3, 0x01, 0xff, 0xe1, 0xe3, - 0x13, 0x00, 0xe5, 0xe4, 0x13, 0x00, 0xe9, 0xe5, 0x13, 0x00, 0xef, 0xe6, - 0x13, 0x00, 0xf5, 0xe7, 0x13, 0x00, 0xf6, 0xe8, 0x13, 0x40, 0xe1, 0xdd, - 0x13, 0x00, 0xe5, 0xde, 0x13, 0x00, 0xe9, 0xdf, 0x13, 0x00, 0xef, 0xe0, - 0x13, 0x00, 0xf5, 0xe1, 0x13, 0x00, 0xf6, 0xe2, 0x13, 0x40, 0xe1, 0xcc, - 0x13, 0x00, 0xe5, 0xce, 0x13, 0x00, 0xe9, 0xcf, 0x13, 0x00, 0xef, 0xd0, - 0x13, 0x00, 0xf5, 0xd1, 0x13, 0x00, 0xf6, 0xd2, 0x13, 0x40, 0xe1, 0xc6, - 0x13, 0x00, 0xe5, 0xc7, 0x13, 0x00, 0xe9, 0xc8, 0x13, 0x00, 0xef, 0xc9, - 0x13, 0x00, 0xf5, 0xca, 0x13, 0x00, 0xf6, 0xcb, 0x13, 0x40, 0xe1, 0xbe, - 0x13, 0x80, 0x14, 0xe5, 0xc1, 0x13, 0x00, 0xe9, 0xc2, 0x13, 0x00, 0xef, - 0xc3, 0x13, 0x00, 0xf5, 0xc4, 0x13, 0x00, 0xf6, 0xc5, 0x13, 0x40, 0xe8, - 0xc0, 0x13, 0x40, 0xe1, 0xb9, 0x13, 0x00, 0xe5, 0xba, 0x13, 0x00, 0xe9, - 0xbb, 0x13, 0x00, 0xef, 0xbc, 0x13, 0x00, 0xf5, 0xbd, 0x13, 0x00, 0xf6, - 0xf5, 0x13, 0x40, 0xe1, 0xb3, 0x13, 0x00, 0xe5, 0xb4, 0x13, 0x00, 0xe9, - 0xb5, 0x13, 0x00, 0xef, 0xb6, 0x13, 0x00, 0xf5, 0xb7, 0x13, 0x00, 0xf6, - 0xb8, 0x13, 0x40, 0xe1, 0xad, 0x13, 0x00, 0xe5, 0xae, 0x13, 0x00, 0xe9, - 0xaf, 0x13, 0x00, 0x42, 0x2a, 0x05, 0xbf, 0x13, 0x00, 0xef, 0xb0, 0x13, - 0x00, 0xf5, 0xb1, 0x13, 0x00, 0xf6, 0xb2, 0x13, 0x40, 0xe1, 0xa6, 0x13, - 0x00, 0xe5, 0xa8, 0x13, 0x00, 0xe9, 0xa9, 0x13, 0x00, 0xef, 0xaa, 0x13, - 0x00, 0xf5, 0xab, 0x13, 0x00, 0xf6, 0xac, 0x13, 0x40, 0xe1, 0xd3, 0x13, - 0x00, 0xe5, 0xd5, 0x13, 0x00, 0xe9, 0xd7, 0x13, 0x00, 0x42, 0x74, 0x00, - 0xdc, 0x13, 0x00, 0xef, 0xd9, 0x13, 0x00, 0xf5, 0xda, 0x13, 0x00, 0xf6, - 0xdb, 0x13, 0x40, 0x4e, 0xdc, 0x7b, 0xe3, 0xf4, 0x01, 0x48, 0xd9, 0xca, - 0xc0, 0xf9, 0x41, 0x45, 0xb8, 0x00, 0x13, 0x27, 0x00, 0x48, 0x72, 0x14, - 0x7e, 0xf6, 0xc1, 0x00, 0x45, 0x56, 0x0b, 0x95, 0xfb, 0x41, 0xa9, 0x8d, - 0x08, 0x04, 0x01, 0xf1, 0xb5, 0x04, 0x02, 0x49, 0x04, 0x3b, 0xb2, 0x01, - 0xff, 0x07, 0x9d, 0xce, 0x18, 0x07, 0x94, 0x0d, 0x01, 0xff, 0x4f, 0x64, - 0x6c, 0xc9, 0xf4, 0x01, 0x4d, 0xcf, 0x89, 0xc8, 0xf4, 0xc1, 0x00, 0x4d, - 0x3f, 0x7f, 0xb9, 0xf4, 0x41, 0x49, 0xff, 0x3b, 0x09, 0x00, 0x80, 0x06, - 0x42, 0xf4, 0x02, 0x40, 0x20, 0x40, 0x80, 0x01, 0xff, 0x43, 0x9c, 0x12, - 0x88, 0x00, 0x00, 0x52, 0xae, 0x56, 0x89, 0x00, 0x40, 0x0f, 0x58, 0x33, - 0xc7, 0x03, 0x06, 0xef, 0x06, 0x80, 0x03, 0x07, 0xec, 0x05, 0x52, 0x0c, - 0x6d, 0x16, 0x34, 0x0b, 0x55, 0x77, 0x01, 0xff, 0xa1, 0x21, 0x42, 0x12, - 0x0b, 0x2c, 0xaa, 0x00, 0xe9, 0x2a, 0xaa, 0x80, 0x12, 0xef, 0x2f, 0xaa, - 0x80, 0x09, 0xf5, 0x2d, 0xaa, 0xc0, 0x00, 0xe5, 0x32, 0xaa, 0x40, 0xe5, - 0x2e, 0xaa, 0x40, 0xe9, 0x2b, 0xaa, 0x40, 0xe1, 0x29, 0xaa, 0x00, 0xe9, - 0x30, 0xaa, 0x00, 0xf5, 0x31, 0xaa, 0x40, 0xa4, 0x0c, 0x46, 0x6b, 0x85, - 0x5c, 0xaa, 0x00, 0x4c, 0x30, 0x96, 0x5f, 0xaa, 0x40, 0x44, 0x75, 0x20, - 0x5d, 0xaa, 0x00, 0x4b, 0x2a, 0xa1, 0x5e, 0xaa, 0x40, 0xe1, 0x00, 0xaa, - 0x80, 0xa0, 0x02, 0xa2, 0x8d, 0x02, 0x02, 0x6d, 0x14, 0xfe, 0x01, 0xa4, - 0xeb, 0x01, 0xe5, 0x03, 0xaa, 0x00, 0x06, 0x10, 0x2d, 0xb1, 0x01, 0xa7, - 0xa4, 0x01, 0x42, 0x22, 0x00, 0x28, 0xaa, 0x00, 0xe9, 0x01, 0xaa, 0x00, - 0xaa, 0x8d, 0x01, 0xab, 0x80, 0x01, 0x42, 0x74, 0x00, 0x24, 0xaa, 0x00, - 0xad, 0x6e, 0xae, 0x44, 0xef, 0x05, 0xaa, 0x00, 0xb0, 0x2e, 0x42, 0x71, - 0x00, 0x23, 0xaa, 0x00, 0xb3, 0x1c, 0xb4, 0x10, 0xf5, 0x02, 0xaa, 0x00, - 0x42, 0xf5, 0x0a, 0x25, 0xaa, 0x00, 0x42, 0xbe, 0x22, 0x22, 0xaa, 0x40, - 0xe1, 0x13, 0xaa, 0x00, 0x42, 0x22, 0x00, 0x14, 0xaa, 0x40, 0xe1, 0x27, - 0xaa, 0x00, 0x42, 0x40, 0x06, 0x26, 0xaa, 0x40, 0xe1, 0x1a, 0xaa, 0x00, - 0x42, 0x22, 0x00, 0x1c, 0xaa, 0x00, 0x42, 0xbb, 0x09, 0x1b, 0xaa, 0x40, - 0xe1, 0x18, 0xaa, 0x00, 0xa7, 0x18, 0xa8, 0x06, 0x42, 0xd6, 0x13, 0x17, - 0xaa, 0x40, 0xe1, 0x11, 0xaa, 0x00, 0x42, 0x72, 0x19, 0x12, 0xaa, 0x00, - 0x42, 0xd6, 0x13, 0x10, 0xaa, 0x40, 0xe1, 0x0b, 0xaa, 0x00, 0x42, 0xd6, - 0x13, 0x0a, 0xaa, 0x40, 0xe1, 0x20, 0xaa, 0x00, 0x42, 0xd6, 0x13, 0x1f, - 0xaa, 0x40, 0xe1, 0x06, 0xaa, 0x00, 0x42, 0x22, 0x00, 0x07, 0xaa, 0x40, - 0xe1, 0x0e, 0xaa, 0x00, 0x42, 0x22, 0x00, 0x0f, 0xaa, 0x40, 0xe1, 0x08, - 0xaa, 0x00, 0x42, 0x22, 0x00, 0x09, 0xaa, 0x40, 0x42, 0x6d, 0x14, 0x44, - 0xaa, 0x00, 0xe7, 0x41, 0xaa, 0x00, 0xeb, 0x40, 0xaa, 0x00, 0xec, 0x4a, - 0xaa, 0x00, 0xee, 0x46, 0xaa, 0x80, 0x16, 0xf0, 0x47, 0xaa, 0x00, 0xf2, - 0x49, 0xaa, 0x00, 0x42, 0xee, 0x00, 0x4b, 0xaa, 0x00, 0xf4, 0x45, 0xaa, - 0x00, 0xf9, 0x48, 0xaa, 0x40, 0xe7, 0x42, 0xaa, 0x40, 0xe1, 0x15, 0xaa, - 0x00, 0x42, 0xf0, 0x10, 0x19, 0xaa, 0x00, 0x42, 0x22, 0x00, 0x16, 0xaa, - 0x40, 0xe1, 0x0c, 0xaa, 0x00, 0x42, 0x22, 0x00, 0x0d, 0xaa, 0x40, 0xe1, - 0x1d, 0xaa, 0x00, 0x42, 0x16, 0x00, 0x21, 0xaa, 0x00, 0x42, 0x22, 0x00, - 0x1e, 0xaa, 0x40, 0xe9, 0x04, 0xaa, 0x40, 0x45, 0x12, 0x0b, 0x58, 0xaa, - 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x59, 0xaa, 0x00, 0x43, 0x0e, 0x0b, - 0x51, 0xaa, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x50, 0xaa, - 0x40, 0x44, 0x25, 0x01, 0x53, 0xaa, 0x00, 0x42, 0x15, 0x02, 0x52, 0xaa, - 0x40, 0x44, 0xe5, 0x1d, 0x57, 0xaa, 0x00, 0x42, 0x1c, 0x26, 0x56, 0xaa, - 0x40, 0x43, 0xd2, 0x05, 0x55, 0xaa, 0x00, 0x43, 0xf6, 0x06, 0x54, 0xaa, - 0x40, 0x06, 0x10, 0x2d, 0x18, 0x42, 0x74, 0x00, 0x35, 0xaa, 0x00, 0x42, - 0x71, 0x00, 0x34, 0xaa, 0x00, 0x42, 0xa9, 0x01, 0x36, 0xaa, 0x00, 0x42, - 0xbe, 0x22, 0x33, 0xaa, 0x40, 0xe8, 0x4d, 0xaa, 0x00, 0xed, 0x4c, 0xaa, - 0x00, 0x42, 0x1d, 0x01, 0x43, 0xaa, 0x40, 0x47, 0x4c, 0xcf, 0x32, 0x11, - 0x01, 0xa4, 0xf8, 0x02, 0x07, 0xec, 0x05, 0x74, 0x47, 0x2e, 0xd3, 0x34, - 0x11, 0x01, 0x46, 0xeb, 0xcb, 0x31, 0x11, 0x01, 0x4d, 0xc1, 0x34, 0x43, - 0x11, 0x01, 0xb3, 0x43, 0xb6, 0x01, 0xff, 0x45, 0xe6, 0x23, 0x33, 0x11, - 0x01, 0x0a, 0x56, 0x77, 0x01, 0xff, 0xe1, 0x27, 0x11, 0x81, 0x24, 0xe5, - 0x2c, 0x11, 0x81, 0x1b, 0xe9, 0x28, 0x11, 0x81, 0x12, 0xef, 0x2e, 0x11, - 0x81, 0x09, 0xf5, 0x2a, 0x11, 0xc1, 0x00, 0xf5, 0x2b, 0x11, 0x41, 0xe9, - 0x30, 0x11, 0x41, 0xe9, 0x29, 0x11, 0x41, 0xe9, 0x46, 0x11, 0x41, 0xe1, - 0x45, 0x11, 0x01, 0xe9, 0x2d, 0x11, 0x01, 0xf5, 0x2f, 0x11, 0x41, 0x4b, - 0x14, 0x27, 0x40, 0x11, 0x01, 0x04, 0x5b, 0x03, 0x01, 0xff, 0x48, 0x3c, - 0x16, 0x01, 0x11, 0x01, 0x4b, 0xd9, 0x23, 0x00, 0x11, 0x01, 0x47, 0xf1, - 0x4b, 0x02, 0x11, 0x41, 0x42, 0x80, 0x12, 0x03, 0x11, 0x01, 0xa2, 0xeb, - 0x01, 0xa3, 0xdc, 0x01, 0xa4, 0xbf, 0x01, 0xe5, 0x06, 0x11, 0x01, 0xa7, - 0xac, 0x01, 0x43, 0x42, 0x41, 0x26, 0x11, 0x01, 0xe9, 0x04, 0x11, 0x01, - 0xaa, 0x93, 0x01, 0xab, 0x84, 0x01, 0xac, 0x76, 0x43, 0x36, 0x58, 0x1f, - 0x11, 0x01, 0xae, 0x56, 0xb0, 0x48, 0x43, 0xb0, 0x95, 0x22, 0x11, 0x01, - 0x43, 0xee, 0xdf, 0x25, 0x11, 0x01, 0xb4, 0x1f, 0xf5, 0x05, 0x11, 0x01, - 0x43, 0x2e, 0xec, 0x47, 0x11, 0x01, 0x43, 0x26, 0x8c, 0x24, 0x11, 0x01, - 0xb9, 0x01, 0xff, 0x42, 0x80, 0x12, 0x21, 0x11, 0x01, 0x43, 0xd2, 0xb9, - 0x20, 0x11, 0x41, 0x42, 0x80, 0x12, 0x16, 0x11, 0x01, 0x43, 0x42, 0x41, - 0x17, 0x11, 0x01, 0xb4, 0x01, 0xff, 0x42, 0x80, 0x12, 0x11, 0x11, 0x01, - 0x43, 0x42, 0x41, 0x12, 0x11, 0x41, 0x42, 0x80, 0x12, 0x1b, 0x11, 0x01, - 0x43, 0x42, 0x41, 0x1c, 0x11, 0x41, 0x42, 0x80, 0x12, 0x1a, 0x11, 0x01, - 0x43, 0xa0, 0x57, 0x0b, 0x11, 0x01, 0x43, 0x79, 0x48, 0x15, 0x11, 0x01, - 0x43, 0xd2, 0xb9, 0x10, 0x11, 0x41, 0x42, 0x80, 0x12, 0x23, 0x11, 0x01, - 0x43, 0x42, 0x41, 0x44, 0x11, 0x41, 0x42, 0x80, 0x12, 0x07, 0x11, 0x01, - 0x43, 0x42, 0x41, 0x08, 0x11, 0x41, 0x42, 0x80, 0x12, 0x0e, 0x11, 0x01, - 0x43, 0x42, 0x41, 0x0f, 0x11, 0x41, 0x42, 0x80, 0x12, 0x09, 0x11, 0x01, - 0x43, 0x42, 0x41, 0x0a, 0x11, 0x41, 0x42, 0x80, 0x12, 0x18, 0x11, 0x01, - 0xa4, 0x06, 0x43, 0x42, 0x41, 0x19, 0x11, 0x41, 0x42, 0x80, 0x12, 0x13, - 0x11, 0x01, 0x43, 0x42, 0x41, 0x14, 0x11, 0x41, 0x42, 0x80, 0x12, 0x0c, - 0x11, 0x01, 0x43, 0x42, 0x41, 0x0d, 0x11, 0x41, 0x42, 0x80, 0x12, 0x1d, - 0x11, 0x01, 0x43, 0x42, 0x41, 0x1e, 0x11, 0x41, 0x44, 0x75, 0x20, 0x41, - 0x11, 0x01, 0x05, 0xf0, 0x06, 0x06, 0x4b, 0x2a, 0xa1, 0x42, 0x11, 0x41, - 0x45, 0x12, 0x0b, 0x3e, 0x11, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x3f, - 0x11, 0x01, 0x43, 0x0e, 0x0b, 0x37, 0x11, 0x01, 0xb3, 0x14, 0xb4, 0x06, - 0x44, 0x5f, 0x1e, 0x36, 0x11, 0x41, 0x44, 0x25, 0x01, 0x39, 0x11, 0x01, - 0x42, 0x15, 0x02, 0x38, 0x11, 0x41, 0x44, 0xe5, 0x1d, 0x3d, 0x11, 0x01, - 0x42, 0x1c, 0x26, 0x3c, 0x11, 0x41, 0x43, 0xd2, 0x05, 0x3b, 0x11, 0x01, - 0x43, 0xf6, 0x06, 0x3a, 0x11, 0x41, 0x42, 0x5f, 0x01, 0xd3, 0x26, 0x00, - 0xf2, 0x91, 0xfa, 0x41, 0x02, 0x00, 0x00, 0x32, 0x4a, 0xb0, 0xad, 0x48, - 0xf5, 0x01, 0x02, 0x11, 0x00, 0x06, 0x43, 0xbd, 0x23, 0xb3, 0x26, 0x40, - 0x45, 0x59, 0x03, 0xa2, 0x00, 0x00, 0x02, 0x88, 0x00, 0x01, 0xff, 0x4c, - 0x50, 0x8b, 0x04, 0x21, 0x00, 0x05, 0xed, 0x07, 0x01, 0xff, 0x48, 0x8a, - 0x8a, 0x4e, 0xfe, 0x00, 0x48, 0x97, 0x8a, 0x4a, 0xfe, 0x40, 0x45, 0x59, - 0x03, 0xb5, 0x20, 0x00, 0x43, 0x2c, 0x0e, 0xb8, 0x00, 0x40, 0x44, 0x99, - 0xd5, 0x35, 0xf3, 0x01, 0xa4, 0xfe, 0x22, 0xac, 0xef, 0x22, 0xad, 0xd9, - 0x22, 0xee, 0x18, 0x00, 0x80, 0xf4, 0x05, 0xb0, 0xe5, 0x05, 0xb2, 0x9a, - 0x03, 0x44, 0xbc, 0x01, 0xeb, 0x26, 0x00, 0xf4, 0x08, 0xf4, 0x81, 0xf6, - 0x02, 0xb5, 0x01, 0xff, 0x10, 0x4d, 0x61, 0x06, 0x49, 0xc0, 0x04, 0x21, - 0x26, 0x40, 0x4d, 0x95, 0x81, 0x6f, 0x05, 0x01, 0x07, 0xec, 0x05, 0x01, - 0xff, 0xa1, 0xcf, 0x02, 0x43, 0xc0, 0x09, 0x31, 0x05, 0x01, 0xa3, 0x98, - 0x02, 0xa4, 0xfa, 0x01, 0xa5, 0xed, 0x01, 0x43, 0xd4, 0xdb, 0x54, 0x05, - 0x01, 0xa7, 0xd8, 0x01, 0x44, 0x59, 0xf0, 0x46, 0x05, 0x01, 0xa9, 0xbd, - 0x01, 0xaa, 0xae, 0x01, 0xab, 0x9f, 0x01, 0xac, 0x90, 0x01, 0x43, 0x96, - 0xe8, 0x4c, 0x05, 0x01, 0x44, 0xad, 0xf1, 0x4e, 0x05, 0x01, 0x42, 0x10, - 0x00, 0x52, 0x05, 0x01, 0xb0, 0x70, 0x02, 0x43, 0x14, 0x64, 0x43, 0x89, - 0x0e, 0x59, 0x05, 0x01, 0xb3, 0x44, 0xb4, 0x30, 0x44, 0x25, 0xf3, 0x5b, - 0x05, 0x01, 0x44, 0x59, 0xf3, 0x40, 0x05, 0x01, 0xb9, 0x16, 0xba, 0x01, - 0xff, 0x43, 0x50, 0x35, 0x35, 0x05, 0x01, 0xa8, 0x01, 0xff, 0xe1, 0x3b, - 0x05, 0x01, 0x42, 0x62, 0x01, 0x37, 0x05, 0x41, 0x43, 0xae, 0x33, 0x61, - 0x05, 0x01, 0x43, 0xb7, 0x23, 0x3a, 0x05, 0x41, 0x42, 0xbb, 0x01, 0x38, - 0x05, 0x01, 0x43, 0x7f, 0xf4, 0x5c, 0x05, 0x01, 0x43, 0x38, 0x53, 0x53, - 0x05, 0x41, 0x43, 0x58, 0xf4, 0x5a, 0x05, 0x01, 0xa8, 0x01, 0xff, 0xe1, - 0x3d, 0x05, 0x81, 0x06, 0x42, 0x5f, 0x69, 0x5d, 0x05, 0x41, 0xeb, 0x50, - 0x05, 0x41, 0xf2, 0x4d, 0x05, 0x01, 0xf9, 0x47, 0x05, 0x41, 0x42, 0x92, - 0x01, 0x57, 0x05, 0x01, 0x43, 0x7f, 0xf4, 0x62, 0x05, 0x41, 0x42, 0x1a, - 0x00, 0x3e, 0x05, 0x01, 0x43, 0xf3, 0x52, 0x45, 0x05, 0x41, 0x42, 0x17, - 0x00, 0x44, 0x05, 0x01, 0x42, 0x4f, 0x3f, 0x63, 0x05, 0x41, 0x43, 0x72, - 0x80, 0x51, 0x05, 0x01, 0x43, 0x76, 0xf4, 0x43, 0x05, 0x41, 0x43, 0xc1, - 0x35, 0x3f, 0x05, 0x01, 0x42, 0x9f, 0x05, 0x3c, 0x05, 0x01, 0x42, 0xa7, - 0x01, 0x5e, 0x05, 0x41, 0x44, 0x55, 0xf0, 0x58, 0x05, 0x01, 0x42, 0x29, - 0x02, 0x32, 0x05, 0x41, 0xe2, 0x34, 0x05, 0x01, 0x42, 0x1f, 0x1d, 0x36, - 0x05, 0x41, 0x42, 0x8a, 0x00, 0x33, 0x05, 0x01, 0x43, 0xd3, 0x35, 0x41, - 0x05, 0x01, 0xba, 0x01, 0xff, 0x42, 0xed, 0x10, 0x55, 0x05, 0x01, 0x43, - 0x38, 0x53, 0x4f, 0x05, 0x41, 0xa1, 0x22, 0xa8, 0x0d, 0x02, 0xbe, 0x22, - 0x01, 0xff, 0xf7, 0x5f, 0x05, 0x01, 0xf9, 0x4b, 0x05, 0x41, 0xe1, 0x39, - 0x05, 0x81, 0x0a, 0xe9, 0x4a, 0x05, 0x01, 0x42, 0x5f, 0x69, 0x49, 0x05, - 0x41, 0xf4, 0x56, 0x05, 0x41, 0xf2, 0x42, 0x05, 0x01, 0x42, 0x1f, 0x1d, - 0x60, 0x05, 0x41, 0x42, 0xb8, 0x04, 0x30, 0x05, 0x01, 0x42, 0x0c, 0x00, - 0x48, 0x05, 0x41, 0x45, 0x0b, 0x08, 0x31, 0xf4, 0xc1, 0x00, 0x06, 0x50, - 0x00, 0x01, 0xff, 0x4c, 0xd0, 0x95, 0x39, 0xf6, 0x01, 0x49, 0x8b, 0xc1, - 0x3c, 0xf6, 0x41, 0x48, 0xb1, 0xc2, 0xd0, 0x26, 0x00, 0x02, 0x06, 0x00, - 0xaa, 0x02, 0xa5, 0x96, 0x02, 0x0b, 0x61, 0x8d, 0x29, 0xaf, 0x1d, 0xb0, - 0x0f, 0xb2, 0x01, 0xff, 0x4b, 0x3e, 0x88, 0x0d, 0x00, 0x00, 0x42, 0x1b, - 0x05, 0x55, 0xf9, 0x41, 0x49, 0x07, 0xb5, 0x8f, 0xf3, 0x01, 0x49, 0x94, - 0xb8, 0x9a, 0xfa, 0x41, 0xee, 0xc7, 0x02, 0x00, 0x4a, 0x3c, 0xb3, 0xa0, - 0xf3, 0x41, 0xe1, 0xa0, 0x02, 0x81, 0xdf, 0x01, 0xe2, 0xa9, 0x02, 0x01, - 0x02, 0xe7, 0x06, 0xca, 0x01, 0xe4, 0xa2, 0x02, 0x81, 0xc0, 0x01, 0xe5, - 0xba, 0x02, 0x81, 0xb6, 0x01, 0xe7, 0xc0, 0x02, 0x81, 0xac, 0x01, 0xe9, - 0xb9, 0x02, 0x81, 0xa2, 0x01, 0xeb, 0xbc, 0x02, 0x81, 0x98, 0x01, 0xec, - 0xa3, 0x02, 0x81, 0x89, 0x01, 0xed, 0xaa, 0x02, 0x81, 0x73, 0xee, 0xb5, - 0x02, 0x81, 0x62, 0xef, 0xab, 0x02, 0x01, 0xf0, 0xb7, 0x02, 0x81, 0x55, - 0xf1, 0xa8, 0x02, 0x01, 0xf2, 0xa5, 0x02, 0x81, 0x48, 0xf3, 0xb0, 0x02, - 0x81, 0x2d, 0xf4, 0xad, 0x02, 0x81, 0x1f, 0xf5, 0xb2, 0x02, 0x81, 0x04, - 0xf8, 0xb4, 0x02, 0x41, 0xf5, 0xbf, 0x02, 0xc1, 0x00, 0xf5, 0xa4, 0x02, - 0xc1, 0x00, 0xd2, 0xc8, 0x02, 0x01, 0xd3, 0xd0, 0x02, 0x01, 0xf5, 0xbb, - 0x02, 0x41, 0xf4, 0xc7, 0x02, 0xc1, 0x00, 0xd2, 0xb6, 0x02, 0x41, 0xe8, - 0xae, 0x02, 0x81, 0x0d, 0xf3, 0xb8, 0x02, 0x01, 0xf4, 0xc2, 0x02, 0xc1, - 0x00, 0xd2, 0xc3, 0x02, 0x41, 0xd2, 0xaf, 0x02, 0x41, 0xf2, 0xc9, 0x02, - 0x41, 0xd2, 0xa1, 0x02, 0x41, 0xe4, 0xbe, 0x02, 0x01, 0xe7, 0xc4, 0x02, - 0x01, 0xee, 0xb3, 0x02, 0x41, 0xe2, 0xca, 0x02, 0xc1, 0x00, 0xd2, 0xcb, - 0x02, 0x01, 0xd3, 0xcc, 0x02, 0x01, 0xd4, 0xcd, 0x02, 0x41, 0xe4, 0xa6, - 0x02, 0xc1, 0x00, 0xd2, 0xce, 0x02, 0x41, 0xd2, 0xbd, 0x02, 0x41, 0xe9, - 0xc5, 0x02, 0x41, 0xd2, 0xc1, 0x02, 0x41, 0xd2, 0xcf, 0x02, 0x41, 0xd2, - 0xac, 0x02, 0x41, 0x42, 0x79, 0xe2, 0xb1, 0x02, 0x01, 0x42, 0x1d, 0xf5, - 0xc6, 0x02, 0x41, 0xd2, 0xa7, 0x02, 0x41, 0x43, 0xf3, 0x01, 0x05, 0x21, - 0x00, 0xf4, 0x38, 0x20, 0xc0, 0x00, 0x50, 0x2d, 0x60, 0x41, 0x20, 0x40, - 0x48, 0x41, 0xc6, 0xc3, 0xf5, 0x01, 0x45, 0x8f, 0x13, 0xc7, 0xf4, 0xc1, - 0x00, 0x49, 0x6e, 0xb4, 0xc2, 0xf5, 0x41, 0x46, 0x5a, 0xdd, 0x3f, 0x2e, - 0x00, 0x46, 0xac, 0xdf, 0x51, 0x26, 0x40, 0x10, 0xcd, 0x60, 0x39, 0x02, - 0x73, 0x02, 0x18, 0xa4, 0x0c, 0x48, 0xb9, 0xc8, 0x6b, 0xf9, 0x01, 0x42, - 0x67, 0x51, 0xf6, 0xf6, 0x41, 0x42, 0x68, 0x00, 0x6f, 0xf5, 0x01, 0xf9, - 0x6c, 0xf3, 0x41, 0xec, 0x18, 0x00, 0x80, 0x04, 0xf2, 0x4b, 0x26, 0x40, - 0x80, 0x06, 0x48, 0xc1, 0xc7, 0xd9, 0xf5, 0x41, 0x49, 0xe6, 0x17, 0x94, - 0x00, 0x00, 0x43, 0xb6, 0x1b, 0x7f, 0x00, 0x4e, 0xe1, 0x0a, 0x14, 0x80, - 0xf0, 0x1b, 0xa2, 0x89, 0x1b, 0xe3, 0xa1, 0x14, 0x80, 0xe0, 0x13, 0xe5, - 0x01, 0x14, 0x80, 0xd0, 0x13, 0xe6, 0x5d, 0x15, 0x80, 0xb1, 0x12, 0x4c, - 0xe9, 0x28, 0x1e, 0x14, 0x00, 0xa8, 0x9e, 0x12, 0xe9, 0x03, 0x14, 0x80, - 0x90, 0x12, 0xeb, 0x83, 0x14, 0x80, 0xba, 0x11, 0xec, 0xea, 0x14, 0x80, - 0xca, 0x10, 0xed, 0xbb, 0x14, 0x80, 0xe1, 0x0f, 0xee, 0xd0, 0x14, 0x80, - 0xd6, 0x0c, 0xef, 0x05, 0x14, 0x80, 0x89, 0x0c, 0xf0, 0x49, 0x14, 0x80, - 0xb1, 0x0b, 0xf1, 0x85, 0x15, 0x80, 0x87, 0x0b, 0xf2, 0x50, 0x15, 0x80, - 0xa7, 0x0a, 0xf3, 0x05, 0x15, 0x80, 0xf5, 0x07, 0xf4, 0x66, 0x14, 0x80, - 0xe0, 0x05, 0xb7, 0x9f, 0x01, 0xf9, 0x3e, 0x15, 0xc0, 0x00, 0x06, 0x66, - 0x9d, 0x4e, 0xe1, 0x2d, 0x15, 0x80, 0x3c, 0xe5, 0x26, 0x15, 0x00, 0xe9, - 0x28, 0x15, 0x80, 0x2f, 0xef, 0x2a, 0x15, 0x80, 0x22, 0xb7, 0x01, 0xff, - 0xe1, 0x39, 0x15, 0x80, 0x16, 0xe5, 0x2f, 0x15, 0x00, 0xe9, 0x31, 0x15, - 0x80, 0x09, 0xef, 0x35, 0x15, 0xc0, 0x00, 0xef, 0x37, 0x15, 0x40, 0xe9, - 0x33, 0x15, 0x40, 0xe1, 0x3b, 0x15, 0x40, 0xef, 0x2b, 0x15, 0x00, 0xf9, - 0xc3, 0x18, 0x40, 0xe9, 0x29, 0x15, 0x40, 0xe1, 0x2e, 0x15, 0x80, 0x04, - 0xf9, 0xc4, 0x18, 0x40, 0xe9, 0x27, 0x15, 0x40, 0x43, 0x7b, 0xc5, 0x8f, - 0x14, 0x00, 0x43, 0x52, 0xe3, 0x71, 0x14, 0x00, 0x43, 0xec, 0x1c, 0xd9, - 0x14, 0x00, 0x43, 0xcb, 0x1b, 0xa9, 0x14, 0x00, 0x43, 0x7c, 0x16, 0xc6, - 0x14, 0x00, 0x42, 0xcd, 0x02, 0x07, 0x14, 0x00, 0xb0, 0x16, 0x43, 0x61, - 0xe3, 0xf3, 0x14, 0x00, 0x43, 0x0f, 0x30, 0x52, 0x14, 0x00, 0xf7, 0x1d, - 0x14, 0x00, 0x43, 0x09, 0x54, 0x2c, 0x15, 0x40, 0x42, 0xcd, 0x02, 0x35, - 0x14, 0x00, 0x43, 0x26, 0x8c, 0x48, 0x14, 0x40, 0xe1, 0x17, 0x14, 0x80, - 0xb0, 0x04, 0xe5, 0x0c, 0x14, 0x80, 0x59, 0xe9, 0x0e, 0x14, 0x80, 0x50, - 0xef, 0x12, 0x14, 0xc0, 0x00, 0xef, 0x14, 0x14, 0xc0, 0x00, 0x08, 0x59, - 0xc5, 0x01, 0xff, 0x48, 0x49, 0xc6, 0x7e, 0x16, 0x00, 0x42, 0x53, 0x00, - 0x9f, 0x15, 0xc0, 0x00, 0xe1, 0x9e, 0x15, 0x00, 0xe5, 0x9b, 0x15, 0x00, - 0xe9, 0x9c, 0x15, 0x00, 0xef, 0x9d, 0x15, 0x00, 0xb7, 0x01, 0xff, 0xe1, - 0x7c, 0x16, 0x80, 0x18, 0x42, 0x27, 0x01, 0x77, 0x16, 0x00, 0xe9, 0x78, - 0x16, 0x80, 0x09, 0xef, 0x7a, 0x16, 0xc0, 0x00, 0xef, 0x7b, 0x16, 0x40, - 0xe9, 0x79, 0x16, 0x40, 0xe1, 0x7d, 0x16, 0x40, 0xe9, 0x10, 0x14, 0x40, - 0x02, 0x60, 0x01, 0x01, 0xff, 0x06, 0x66, 0x9d, 0x06, 0x45, 0xcc, 0xc3, - 0xdd, 0x18, 0x40, 0x02, 0x91, 0xef, 0x9f, 0x03, 0x44, 0xf9, 0xef, 0x5c, - 0x15, 0x00, 0x02, 0x3c, 0x0b, 0xf5, 0x02, 0xec, 0xeb, 0x14, 0x80, 0xb7, - 0x02, 0xed, 0xbc, 0x14, 0x80, 0x8f, 0x02, 0x02, 0xa8, 0x01, 0xfd, 0x01, - 0xf0, 0x4a, 0x14, 0x80, 0xd5, 0x01, 0xf2, 0x51, 0x15, 0x80, 0xb9, 0x01, - 0xb3, 0x72, 0xb4, 0x48, 0xb7, 0x27, 0xf9, 0x40, 0x15, 0xc0, 0x00, 0xb7, - 0x01, 0xff, 0xe1, 0x3a, 0x15, 0x80, 0x16, 0xe5, 0x30, 0x15, 0x00, 0xe9, - 0x32, 0x15, 0x80, 0x09, 0xef, 0x36, 0x15, 0xc0, 0x00, 0xef, 0x38, 0x15, - 0x40, 0xe9, 0x34, 0x15, 0x40, 0xe1, 0x3c, 0x15, 0x40, 0xe1, 0x18, 0x14, - 0x80, 0x16, 0xe5, 0x0d, 0x14, 0x00, 0xe9, 0x0f, 0x14, 0x80, 0x09, 0xef, - 0x13, 0x14, 0xc0, 0x00, 0xef, 0x15, 0x14, 0x40, 0xe9, 0x11, 0x14, 0x40, - 0xe1, 0x1a, 0x14, 0x40, 0x44, 0x89, 0xf0, 0x69, 0x15, 0x00, 0xb7, 0x01, - 0xff, 0xe1, 0x62, 0x14, 0x80, 0x16, 0xe5, 0x58, 0x14, 0x00, 0xe9, 0x5a, - 0x14, 0x80, 0x09, 0xef, 0x5e, 0x14, 0xc0, 0x00, 0xef, 0x60, 0x14, 0x40, - 0xe9, 0x5c, 0x14, 0x40, 0xe1, 0x64, 0x14, 0x40, 0x02, 0xd9, 0x1a, 0x22, - 0xb7, 0x01, 0xff, 0xe1, 0x01, 0x15, 0x80, 0x16, 0xe5, 0xf7, 0x14, 0x00, - 0xe9, 0xf9, 0x14, 0x80, 0x09, 0xef, 0xfd, 0x14, 0xc0, 0x00, 0xef, 0xff, - 0x14, 0x40, 0xe9, 0xfb, 0x14, 0x40, 0xe1, 0x03, 0x15, 0x40, 0xe1, 0x22, - 0x15, 0x80, 0x16, 0xe5, 0x18, 0x15, 0x00, 0xe9, 0x1a, 0x15, 0x80, 0x09, - 0xef, 0x1e, 0x15, 0xc0, 0x00, 0xef, 0x20, 0x15, 0x40, 0xe9, 0x1c, 0x15, - 0x40, 0xe1, 0x24, 0x15, 0x40, 0xe1, 0x8d, 0x15, 0x00, 0xe5, 0x8a, 0x15, - 0x00, 0xe9, 0x8b, 0x15, 0x00, 0xef, 0x8c, 0x15, 0x00, 0x43, 0x26, 0x8c, - 0x4f, 0x15, 0x40, 0xb7, 0x01, 0xff, 0xe1, 0x45, 0x14, 0x80, 0x16, 0xe5, - 0x3b, 0x14, 0x00, 0xe9, 0x3d, 0x14, 0x80, 0x09, 0xef, 0x41, 0x14, 0xc0, - 0x00, 0xef, 0x43, 0x14, 0x40, 0xe9, 0x3f, 0x14, 0x40, 0xe1, 0x47, 0x14, - 0x40, 0xe1, 0xcc, 0x14, 0x80, 0x04, 0xe5, 0xca, 0x14, 0x40, 0xe1, 0xce, - 0x14, 0x40, 0xb7, 0x01, 0xff, 0xe1, 0xb7, 0x14, 0x80, 0x16, 0xe5, 0xad, - 0x14, 0x00, 0xe9, 0xaf, 0x14, 0x80, 0x09, 0xef, 0xb3, 0x14, 0xc0, 0x00, - 0xef, 0xb5, 0x14, 0x40, 0xe9, 0xb1, 0x14, 0x40, 0xe1, 0xb9, 0x14, 0x40, - 0xe1, 0x4d, 0x15, 0x80, 0x2f, 0xe5, 0x44, 0x15, 0x00, 0xef, 0x4a, 0x15, - 0x80, 0x22, 0xb7, 0x01, 0xff, 0xe1, 0xe7, 0x14, 0x80, 0x16, 0xe5, 0xdd, - 0x14, 0x00, 0xe9, 0xdf, 0x14, 0x80, 0x09, 0xef, 0xe3, 0x14, 0xc0, 0x00, - 0xef, 0xe5, 0x14, 0x40, 0xe9, 0xe1, 0x14, 0x40, 0xe1, 0xe9, 0x14, 0x40, - 0xef, 0xe1, 0x18, 0x40, 0xe1, 0xe2, 0x18, 0x40, 0xe1, 0x7f, 0x14, 0x80, - 0x16, 0xe5, 0x75, 0x14, 0x00, 0xe9, 0x77, 0x14, 0x80, 0x09, 0xef, 0x7b, - 0x14, 0xc0, 0x00, 0xef, 0x7d, 0x14, 0x40, 0xe9, 0x79, 0x14, 0x40, 0xe1, - 0x81, 0x14, 0x40, 0xe1, 0x9d, 0x14, 0x80, 0x16, 0xe5, 0x93, 0x14, 0x00, - 0xe9, 0x95, 0x14, 0x80, 0x09, 0xef, 0x99, 0x14, 0xc0, 0x00, 0xef, 0x9b, - 0x14, 0x40, 0xe9, 0x97, 0x14, 0x40, 0xe1, 0x9f, 0x14, 0x40, 0xe1, 0x19, - 0x14, 0x00, 0xf9, 0xb3, 0x18, 0x40, 0xe1, 0x55, 0x14, 0x80, 0xfc, 0x01, - 0xe5, 0x4c, 0x14, 0x00, 0xe8, 0x6a, 0x15, 0x80, 0x9d, 0x01, 0xe9, 0x4e, - 0x14, 0x80, 0x93, 0x01, 0x02, 0x2a, 0x09, 0x74, 0xef, 0x50, 0x14, 0x80, - 0x6b, 0xb4, 0x34, 0xb7, 0x13, 0xb9, 0x01, 0xff, 0xe1, 0x73, 0x15, 0x00, - 0xe5, 0x70, 0x15, 0x00, 0xe9, 0x71, 0x15, 0x00, 0xef, 0x72, 0x15, 0x40, - 0xe1, 0x61, 0x14, 0x80, 0x16, 0xe5, 0x57, 0x14, 0x00, 0xe9, 0x59, 0x14, - 0x80, 0x09, 0xef, 0x5d, 0x14, 0xc0, 0x00, 0xef, 0x5f, 0x14, 0x40, 0xe9, - 0x5b, 0x14, 0x40, 0xe1, 0x63, 0x14, 0x40, 0xe1, 0x6a, 0x14, 0x00, 0xe5, - 0x67, 0x14, 0x00, 0xe8, 0x6f, 0x15, 0x80, 0x08, 0xe9, 0x68, 0x14, 0x00, - 0xef, 0x69, 0x14, 0x40, 0xe1, 0x6e, 0x15, 0x80, 0x17, 0xe5, 0x6b, 0x15, - 0x00, 0xe9, 0x6c, 0x15, 0x00, 0xef, 0x6d, 0x15, 0x80, 0x06, 0x42, 0x15, - 0x01, 0xe5, 0x18, 0x40, 0xef, 0xe6, 0x18, 0x40, 0xe1, 0xe7, 0x18, 0x40, - 0xef, 0x51, 0x14, 0x40, 0xe1, 0x89, 0x15, 0x00, 0xe5, 0x86, 0x15, 0x00, - 0xe9, 0x87, 0x15, 0x00, 0xef, 0x88, 0x15, 0x80, 0x06, 0x42, 0x15, 0x01, - 0xe8, 0x18, 0x40, 0xef, 0xe9, 0x18, 0x40, 0xe9, 0x4f, 0x14, 0x40, 0x48, - 0xd9, 0xc2, 0xae, 0x15, 0x80, 0x2f, 0xe1, 0x66, 0x15, 0x80, 0x26, 0xe5, - 0x5e, 0x15, 0x00, 0xe9, 0x60, 0x15, 0x80, 0x19, 0xef, 0x64, 0x15, 0x80, - 0x10, 0xb7, 0x01, 0xff, 0xe1, 0xe4, 0x18, 0x80, 0x04, 0xe5, 0xe3, 0x18, - 0x40, 0xe1, 0x68, 0x15, 0x40, 0xef, 0x65, 0x15, 0x40, 0xe9, 0x62, 0x15, - 0x40, 0xe1, 0x67, 0x15, 0x40, 0xe1, 0xac, 0x15, 0x80, 0x16, 0xe5, 0xa7, - 0x15, 0x00, 0xe9, 0xa8, 0x15, 0x80, 0x09, 0xef, 0xaa, 0x15, 0xc0, 0x00, - 0xef, 0xab, 0x15, 0x40, 0xe9, 0xa9, 0x15, 0x40, 0xe1, 0xad, 0x15, 0x40, - 0xe1, 0x56, 0x14, 0x80, 0x04, 0xf9, 0xb7, 0x18, 0x40, 0xe9, 0x4d, 0x14, - 0x40, 0xe1, 0xf4, 0x14, 0x80, 0xbe, 0x01, 0xe5, 0xed, 0x14, 0x00, 0xe8, - 0x25, 0x15, 0x80, 0x68, 0xe9, 0xef, 0x14, 0x80, 0x5f, 0xef, 0xf1, 0x14, - 0x80, 0x36, 0xb0, 0x24, 0xf7, 0x07, 0x15, 0xc0, 0x00, 0xe1, 0x00, 0x15, - 0x80, 0x16, 0xe5, 0xf6, 0x14, 0x00, 0xe9, 0xf8, 0x14, 0x80, 0x09, 0xef, - 0xfc, 0x14, 0xc0, 0x00, 0xef, 0xfe, 0x14, 0x40, 0xe9, 0xfa, 0x14, 0x40, - 0xe1, 0x02, 0x15, 0x40, 0xe1, 0xbf, 0x1a, 0x01, 0xe5, 0xbc, 0x1a, 0x01, - 0xe9, 0xbd, 0x1a, 0x01, 0xef, 0xbe, 0x1a, 0x41, 0xef, 0xf2, 0x14, 0x00, - 0x0c, 0xcc, 0x96, 0x04, 0xf9, 0xbe, 0x18, 0x40, 0x42, 0x18, 0x0a, 0x88, - 0x14, 0x00, 0x42, 0x4e, 0x00, 0x85, 0x14, 0x00, 0x42, 0xf5, 0x2c, 0x86, - 0x14, 0x00, 0x42, 0x18, 0x29, 0x87, 0x14, 0x40, 0xe9, 0xf0, 0x14, 0x40, - 0xe1, 0x15, 0x15, 0x80, 0x40, 0xe5, 0x10, 0x15, 0x00, 0xe9, 0x11, 0x15, - 0x80, 0x33, 0xef, 0x13, 0x15, 0x80, 0x26, 0xb7, 0x01, 0xff, 0xe1, 0x21, - 0x15, 0x80, 0x1a, 0xe5, 0x17, 0x15, 0x00, 0xe9, 0x19, 0x15, 0x80, 0x0d, - 0xef, 0x1d, 0x15, 0xc0, 0x00, 0xef, 0x1f, 0x15, 0x00, 0xf9, 0xc2, 0x18, - 0x40, 0xe9, 0x1b, 0x15, 0x40, 0xe1, 0x23, 0x15, 0x40, 0xef, 0x14, 0x15, - 0x00, 0xf9, 0xc0, 0x18, 0x40, 0xe9, 0x12, 0x15, 0x40, 0xe1, 0x16, 0x15, - 0x00, 0xf9, 0xc1, 0x18, 0x40, 0xe1, 0xf5, 0x14, 0x80, 0x5f, 0xf9, 0xbf, - 0x18, 0xc0, 0x00, 0x04, 0xc9, 0xf0, 0x01, 0xff, 0xa8, 0x3e, 0xaa, 0x2f, - 0xed, 0xbf, 0x14, 0x00, 0x02, 0xa4, 0x02, 0x0c, 0x42, 0x53, 0x00, 0xa2, - 0x14, 0x00, 0x42, 0x9a, 0x1a, 0x41, 0x15, 0x40, 0xe1, 0x9a, 0x15, 0x00, - 0xe5, 0x97, 0x15, 0x00, 0xe9, 0x98, 0x15, 0x00, 0xef, 0x99, 0x15, 0x80, - 0x06, 0x42, 0x15, 0x01, 0xea, 0x18, 0x40, 0xef, 0xeb, 0x18, 0x40, 0xe9, - 0x1a, 0x16, 0x00, 0xf5, 0x15, 0x16, 0xc0, 0x00, 0xf5, 0xf1, 0x18, 0x40, - 0xe1, 0xc3, 0x15, 0x00, 0xe5, 0xc0, 0x15, 0x00, 0xe9, 0xc1, 0x15, 0x00, - 0xef, 0xc2, 0x15, 0xc0, 0x00, 0xef, 0xec, 0x18, 0x40, 0xe9, 0xee, 0x14, - 0x40, 0x07, 0xd2, 0xcd, 0x4c, 0xe1, 0x4b, 0x15, 0x80, 0x3a, 0xe5, 0x42, - 0x15, 0x00, 0xe9, 0x46, 0x15, 0x80, 0x2d, 0xef, 0x48, 0x15, 0x80, 0x24, - 0xb7, 0x01, 0xff, 0xe1, 0xd3, 0x18, 0x80, 0x18, 0x42, 0x27, 0x01, 0xce, - 0x18, 0x00, 0xe9, 0xcf, 0x18, 0x80, 0x09, 0xef, 0xd1, 0x18, 0xc0, 0x00, - 0xef, 0xd2, 0x18, 0x40, 0xe9, 0xd0, 0x18, 0x40, 0xe1, 0x4e, 0x15, 0x40, - 0xef, 0x49, 0x15, 0x40, 0xe9, 0x47, 0x15, 0x40, 0xe1, 0x4c, 0x15, 0x80, - 0x04, 0xf9, 0xc5, 0x18, 0x40, 0xe9, 0x45, 0x15, 0x40, 0xe5, 0x43, 0x15, - 0x00, 0x42, 0x15, 0x01, 0xe0, 0x18, 0x40, 0xe1, 0x83, 0x15, 0x80, 0x12, - 0xe9, 0x7f, 0x15, 0x80, 0x09, 0xef, 0x81, 0x15, 0xc0, 0x00, 0xef, 0x82, - 0x15, 0x40, 0xe9, 0x80, 0x15, 0x40, 0xe1, 0x84, 0x15, 0x80, 0x04, 0xe9, - 0x6f, 0x16, 0x40, 0xe9, 0x7e, 0x15, 0x40, 0xe1, 0x38, 0x14, 0x80, 0x40, - 0xe5, 0x2f, 0x14, 0x00, 0xe9, 0x31, 0x14, 0x80, 0x33, 0xef, 0x33, 0x14, - 0x80, 0x26, 0xb7, 0x01, 0xff, 0xe1, 0x44, 0x14, 0x80, 0x1a, 0xe5, 0x3a, - 0x14, 0x00, 0xe9, 0x3c, 0x14, 0x80, 0x0d, 0xef, 0x40, 0x14, 0xc0, 0x00, - 0xef, 0x42, 0x14, 0x00, 0xf9, 0xb6, 0x18, 0x40, 0xe9, 0x3e, 0x14, 0x40, - 0xe1, 0x46, 0x14, 0x40, 0xef, 0x34, 0x14, 0x00, 0xf9, 0xb4, 0x18, 0x40, - 0xe9, 0x32, 0x14, 0x40, 0xe1, 0x39, 0x14, 0x80, 0x04, 0xf9, 0xb5, 0x18, - 0x40, 0xe9, 0x30, 0x14, 0x40, 0x07, 0x63, 0xd2, 0x0c, 0xee, 0x2d, 0x14, - 0x00, 0xef, 0x06, 0x14, 0x00, 0xf9, 0xb0, 0x18, 0x40, 0xe3, 0xd7, 0x18, - 0x00, 0xeb, 0xd6, 0x18, 0x00, 0xed, 0xd8, 0x18, 0x00, 0xee, 0xd9, 0x18, - 0x80, 0x11, 0xf0, 0xd4, 0x18, 0x00, 0xf3, 0xda, 0x18, 0x80, 0x04, 0xf4, - 0xd5, 0x18, 0x40, 0xe8, 0xdb, 0x18, 0x40, 0xb7, 0x01, 0xff, 0xe9, 0xc7, - 0x18, 0x80, 0x09, 0xef, 0xcb, 0x18, 0xc0, 0x00, 0xef, 0xcd, 0x18, 0x40, - 0xe9, 0xc9, 0x18, 0x40, 0x08, 0xd9, 0xc2, 0xf3, 0x02, 0xe1, 0xc7, 0x14, - 0x80, 0xbd, 0x01, 0xe5, 0xc0, 0x14, 0x00, 0xe7, 0x95, 0x15, 0x80, 0x8f, - 0x01, 0xe8, 0xd2, 0x14, 0x00, 0xe9, 0xc2, 0x14, 0x80, 0x81, 0x01, 0x42, - 0x1d, 0x01, 0x96, 0x15, 0x80, 0x5f, 0xef, 0xc4, 0x14, 0x80, 0x52, 0x04, - 0xfd, 0xf2, 0x22, 0xb7, 0x01, 0xff, 0xe1, 0xcb, 0x14, 0x80, 0x16, 0xe5, - 0xc9, 0x14, 0x00, 0xe9, 0xc6, 0x18, 0x80, 0x09, 0xef, 0xca, 0x18, 0xc0, - 0x00, 0xef, 0xcc, 0x18, 0x40, 0xe9, 0xc8, 0x18, 0x40, 0xe1, 0xcd, 0x14, - 0x40, 0x44, 0xa5, 0xf0, 0x7b, 0x15, 0x80, 0x06, 0x44, 0x05, 0x51, 0x7c, - 0x15, 0x40, 0xe1, 0x79, 0x15, 0x80, 0x16, 0xe5, 0x74, 0x15, 0x00, 0xe9, - 0x75, 0x15, 0x80, 0x09, 0xef, 0x77, 0x15, 0xc0, 0x00, 0xef, 0x78, 0x15, - 0x40, 0xe9, 0x76, 0x15, 0x40, 0xe1, 0x7a, 0x15, 0x40, 0xef, 0xc5, 0x14, - 0x00, 0xf9, 0xbb, 0x18, 0x40, 0xe1, 0x75, 0x16, 0x80, 0x12, 0xe9, 0x71, - 0x16, 0x80, 0x09, 0xef, 0x73, 0x16, 0xc0, 0x00, 0xef, 0x74, 0x16, 0x40, - 0xe9, 0x72, 0x16, 0x40, 0xe1, 0x76, 0x16, 0x40, 0xe9, 0xc3, 0x14, 0x40, - 0xe1, 0x93, 0x15, 0x80, 0x12, 0xe9, 0x8f, 0x15, 0x80, 0x09, 0xef, 0x91, - 0x15, 0xc0, 0x00, 0xef, 0x92, 0x15, 0x40, 0xe9, 0x90, 0x15, 0x40, 0xe1, - 0x94, 0x15, 0x80, 0x04, 0xe9, 0x70, 0x16, 0x40, 0xe9, 0x8e, 0x15, 0x40, - 0xe1, 0xc8, 0x14, 0x80, 0xa6, 0x01, 0x06, 0x0c, 0xe0, 0x45, 0x07, 0xbc, - 0xd6, 0x04, 0xf9, 0xbc, 0x18, 0x40, 0xa8, 0x20, 0x03, 0x86, 0x5d, 0x01, - 0xff, 0xe1, 0xba, 0x1a, 0x81, 0x12, 0xe9, 0xb6, 0x1a, 0x81, 0x09, 0xef, - 0xb8, 0x1a, 0xc1, 0x00, 0xef, 0xb9, 0x1a, 0x41, 0xe9, 0xb7, 0x1a, 0x41, - 0xe1, 0xbb, 0x1a, 0x41, 0xe1, 0xb4, 0x1a, 0x81, 0x12, 0xe9, 0xb0, 0x1a, - 0x81, 0x09, 0xef, 0xb2, 0x1a, 0xc1, 0x00, 0xef, 0xb3, 0x1a, 0x41, 0xe9, - 0xb1, 0x1a, 0x41, 0xe1, 0xb5, 0x1a, 0x41, 0x44, 0x91, 0xef, 0xa0, 0x14, - 0x00, 0x44, 0x15, 0xf1, 0x82, 0x14, 0x00, 0x44, 0x71, 0xf1, 0xba, 0x14, - 0x00, 0x44, 0xd1, 0xf1, 0xcf, 0x14, 0x00, 0xb3, 0x1a, 0x44, 0x50, 0xec, - 0x65, 0x14, 0x00, 0xb7, 0x06, 0x44, 0x75, 0xf3, 0x3d, 0x15, 0x40, 0x42, - 0x80, 0x12, 0x1b, 0x14, 0x00, 0x42, 0xcd, 0x02, 0x16, 0x14, 0x40, 0x42, - 0x05, 0x20, 0x0b, 0x15, 0x00, 0x43, 0x91, 0xef, 0x0f, 0x15, 0x00, 0x42, - 0x3c, 0x0b, 0x0a, 0x15, 0x80, 0x12, 0x43, 0x51, 0x02, 0x0c, 0x15, 0x00, - 0x43, 0xed, 0x01, 0x0d, 0x15, 0x00, 0x43, 0x26, 0x8c, 0x04, 0x15, 0x40, - 0xe1, 0x0e, 0x15, 0x40, 0xe9, 0xc1, 0x14, 0x40, 0xe5, 0x5f, 0x15, 0x00, - 0xe9, 0x61, 0x15, 0xc0, 0x00, 0xe9, 0x63, 0x15, 0x40, 0xe1, 0xaa, 0x14, - 0x80, 0x51, 0xe5, 0xa3, 0x14, 0x80, 0x3f, 0xe8, 0xbd, 0x14, 0x00, 0xe9, - 0xa5, 0x14, 0x80, 0x32, 0xef, 0xa7, 0x14, 0x80, 0x22, 0xb7, 0x01, 0xff, - 0xe1, 0xb6, 0x14, 0x80, 0x16, 0xe5, 0xac, 0x14, 0x00, 0xe9, 0xae, 0x14, - 0x80, 0x09, 0xef, 0xb2, 0x14, 0xc0, 0x00, 0xef, 0xb4, 0x14, 0x40, 0xe9, - 0xb0, 0x14, 0x40, 0xe1, 0xb8, 0x14, 0x40, 0xef, 0xa8, 0x14, 0xc0, 0x00, - 0x4a, 0xf8, 0xb0, 0x09, 0x15, 0x40, 0xe9, 0xa6, 0x14, 0x40, 0x05, 0x69, - 0x33, 0x01, 0xff, 0xec, 0xec, 0x14, 0x00, 0xf2, 0x52, 0x15, 0x40, 0xe1, - 0xab, 0x14, 0x80, 0x04, 0xf9, 0xba, 0x18, 0x40, 0xe9, 0xa4, 0x14, 0x40, - 0xe1, 0xda, 0x14, 0x80, 0x58, 0xe5, 0xd3, 0x14, 0x00, 0xe8, 0xa6, 0x15, - 0x80, 0x34, 0xe9, 0xd5, 0x14, 0x80, 0x2b, 0xef, 0xd7, 0x14, 0x80, 0x22, - 0xb7, 0x01, 0xff, 0xe1, 0xe6, 0x14, 0x80, 0x16, 0xe5, 0xdc, 0x14, 0x00, - 0xe9, 0xde, 0x14, 0x80, 0x09, 0xef, 0xe2, 0x14, 0xc0, 0x00, 0xef, 0xe4, - 0x14, 0x40, 0xe9, 0xe0, 0x14, 0x40, 0xe1, 0xe8, 0x14, 0x40, 0xef, 0xd8, - 0x14, 0x40, 0xe9, 0xd6, 0x14, 0x40, 0xe1, 0xa4, 0x15, 0x80, 0x12, 0xe9, - 0xa0, 0x15, 0x80, 0x09, 0xef, 0xa2, 0x15, 0xc0, 0x00, 0xef, 0xa3, 0x15, - 0x40, 0xe9, 0xa1, 0x15, 0x40, 0xe1, 0xa5, 0x15, 0x40, 0xe1, 0xdb, 0x14, - 0x80, 0x04, 0xf9, 0xbd, 0x18, 0x40, 0xe9, 0xd4, 0x14, 0x40, 0xe1, 0x72, - 0x14, 0x80, 0x3e, 0xe5, 0x6b, 0x14, 0x00, 0xe9, 0x6d, 0x14, 0x80, 0x31, - 0xef, 0x6f, 0x14, 0x80, 0x28, 0xf7, 0x84, 0x14, 0xc0, 0x00, 0xe1, 0x7e, - 0x14, 0x80, 0x16, 0xe5, 0x74, 0x14, 0x00, 0xe9, 0x76, 0x14, 0x80, 0x09, - 0xef, 0x7a, 0x14, 0xc0, 0x00, 0xef, 0x7c, 0x14, 0x40, 0xe9, 0x78, 0x14, - 0x40, 0xe1, 0x80, 0x14, 0x00, 0xf9, 0xb9, 0x18, 0x40, 0xef, 0x70, 0x14, - 0x40, 0xe9, 0x6e, 0x14, 0x40, 0xe1, 0x73, 0x14, 0x80, 0x04, 0xf9, 0xb8, - 0x18, 0x40, 0xe9, 0x6c, 0x14, 0x40, 0xe9, 0x04, 0x14, 0x00, 0xee, 0x2c, - 0x14, 0x40, 0xeb, 0x7d, 0x15, 0x00, 0x45, 0x9e, 0x63, 0x00, 0x14, 0x40, - 0xe1, 0x59, 0x15, 0x80, 0x8a, 0x01, 0xe5, 0x53, 0x15, 0x00, 0xe9, 0x55, - 0x15, 0x80, 0x15, 0xef, 0x57, 0x15, 0x80, 0x0c, 0x48, 0x82, 0x16, 0x6e, - 0x16, 0x00, 0x43, 0x26, 0x8c, 0x5b, 0x15, 0x40, 0xef, 0x58, 0x15, 0x40, - 0xe9, 0x56, 0x15, 0x00, 0x04, 0x66, 0x06, 0x01, 0xff, 0x45, 0x14, 0x39, - 0x1f, 0x14, 0x00, 0x50, 0x2d, 0x61, 0x21, 0x14, 0x00, 0x02, 0x3b, 0x01, - 0x3d, 0x45, 0x17, 0x23, 0x20, 0x14, 0x00, 0x4a, 0xed, 0x45, 0x27, 0x14, - 0x00, 0x44, 0x73, 0x28, 0x29, 0x14, 0x00, 0xb2, 0x14, 0xb3, 0x06, 0x4d, - 0x67, 0x89, 0x22, 0x14, 0x40, 0x56, 0x60, 0x34, 0x28, 0x14, 0x00, 0x49, - 0xfd, 0xbb, 0xde, 0x18, 0x40, 0x49, 0xf1, 0xb5, 0xdf, 0x18, 0x00, 0xa9, - 0x01, 0xff, 0x4d, 0x8d, 0x72, 0x23, 0x14, 0x00, 0x42, 0x1d, 0x01, 0x24, - 0x14, 0x40, 0x05, 0x3d, 0x01, 0x06, 0x47, 0x0d, 0x39, 0x2a, 0x14, 0x40, - 0x45, 0x14, 0x39, 0x25, 0x14, 0x00, 0x56, 0x62, 0x37, 0x26, 0x14, 0x40, - 0xe1, 0x5a, 0x15, 0xc0, 0x00, 0xe9, 0x54, 0x15, 0x40, 0x48, 0xc9, 0xc3, - 0xdc, 0x18, 0x00, 0xee, 0x2b, 0x14, 0x40, 0xe1, 0x90, 0x14, 0x80, 0x3e, - 0xe5, 0x89, 0x14, 0x00, 0x47, 0xad, 0xd1, 0x6d, 0x16, 0x00, 0xe9, 0x8b, - 0x14, 0x80, 0x2b, 0xef, 0x8d, 0x14, 0x80, 0x22, 0xb7, 0x01, 0xff, 0xe1, - 0x9c, 0x14, 0x80, 0x16, 0xe5, 0x92, 0x14, 0x00, 0xe9, 0x94, 0x14, 0x80, - 0x09, 0xef, 0x98, 0x14, 0xc0, 0x00, 0xef, 0x9a, 0x14, 0x40, 0xe9, 0x96, - 0x14, 0x40, 0xe1, 0x9e, 0x14, 0x40, 0xef, 0x8e, 0x14, 0x40, 0xe9, 0x8c, - 0x14, 0x40, 0xe1, 0x91, 0x14, 0x80, 0xd6, 0x06, 0x06, 0x2d, 0x6a, 0x01, - 0xff, 0x02, 0x6d, 0x14, 0xb3, 0x06, 0xa4, 0xe0, 0x05, 0x42, 0x27, 0x01, - 0x08, 0x14, 0x00, 0xa7, 0x93, 0x05, 0xe8, 0x4b, 0x14, 0x80, 0xe7, 0x04, - 0xe9, 0x09, 0x14, 0x80, 0xdb, 0x04, 0xaa, 0x9e, 0x04, 0xab, 0xe2, 0x03, - 0xac, 0xab, 0x03, 0xad, 0x8f, 0x03, 0xae, 0xef, 0x02, 0xf0, 0xee, 0x15, - 0x80, 0xd0, 0x02, 0xb2, 0xb4, 0x02, 0xb3, 0xfa, 0x01, 0xb4, 0x54, 0xb7, - 0x39, 0xb9, 0x1e, 0xfa, 0x46, 0x16, 0xc0, 0x00, 0xe1, 0x45, 0x16, 0x00, - 0xe5, 0x42, 0x16, 0x80, 0x0c, 0xe9, 0x44, 0x16, 0x00, 0xef, 0x41, 0x16, - 0x00, 0xf5, 0x40, 0x16, 0x40, 0xe5, 0x43, 0x16, 0x40, 0xe1, 0x13, 0x16, - 0x00, 0xe5, 0x10, 0x16, 0x80, 0x0c, 0xe9, 0x12, 0x16, 0x00, 0xef, 0x0f, - 0x16, 0x00, 0xf5, 0x0e, 0x16, 0x40, 0xe5, 0x11, 0x16, 0x40, 0xe1, 0xd5, - 0x15, 0x00, 0xe5, 0xd2, 0x15, 0x80, 0x0c, 0xe9, 0xd4, 0x15, 0x00, 0xef, - 0xd1, 0x15, 0x00, 0xf5, 0xd0, 0x15, 0x40, 0xe5, 0xd3, 0x15, 0x40, 0xa8, - 0x88, 0x01, 0xac, 0x52, 0xb3, 0x37, 0xb4, 0x01, 0xff, 0xe1, 0xe7, 0x15, - 0x00, 0xe5, 0xe4, 0x15, 0x80, 0x27, 0xe9, 0xe6, 0x15, 0x00, 0xef, 0xe3, - 0x15, 0x00, 0xb3, 0x04, 0xf5, 0xe2, 0x15, 0x40, 0xe1, 0x6c, 0x16, 0x00, - 0xe5, 0x69, 0x16, 0x80, 0x0c, 0xe9, 0x6b, 0x16, 0x00, 0xef, 0x68, 0x16, - 0x00, 0xf5, 0x67, 0x16, 0x40, 0xe5, 0x6a, 0x16, 0x40, 0xe5, 0xe5, 0x15, - 0x40, 0xe1, 0x60, 0x16, 0x00, 0xe5, 0x5d, 0x16, 0x80, 0x0c, 0xe9, 0x5f, - 0x16, 0x00, 0xef, 0x5c, 0x16, 0x00, 0xf5, 0x5b, 0x16, 0x40, 0xe5, 0x5e, - 0x16, 0x40, 0xe1, 0x3f, 0x16, 0x00, 0xe5, 0x3c, 0x16, 0x80, 0x27, 0xa8, - 0x0c, 0xe9, 0x3e, 0x16, 0x00, 0xef, 0x3b, 0x16, 0x00, 0xf5, 0x3a, 0x16, - 0x40, 0xe1, 0x39, 0x16, 0x00, 0xe5, 0x36, 0x16, 0x80, 0x0c, 0xe9, 0x38, - 0x16, 0x00, 0xef, 0x35, 0x16, 0x00, 0xf5, 0x34, 0x16, 0x40, 0xe5, 0x37, - 0x16, 0x40, 0xe5, 0x3d, 0x16, 0x40, 0xe1, 0xe1, 0x15, 0x00, 0xe5, 0xde, - 0x15, 0x80, 0x0c, 0xe9, 0xe0, 0x15, 0x00, 0xef, 0xdd, 0x15, 0x00, 0xf5, - 0xdc, 0x15, 0x40, 0xe5, 0xdf, 0x15, 0x40, 0xe1, 0x53, 0x16, 0x00, 0xe5, - 0x50, 0x16, 0x80, 0x2a, 0xe8, 0x5a, 0x16, 0x80, 0x0c, 0xe9, 0x52, 0x16, - 0x00, 0xef, 0x4f, 0x16, 0x00, 0xf5, 0x4e, 0x16, 0x40, 0xe1, 0x59, 0x16, - 0x00, 0xe5, 0x56, 0x16, 0x80, 0x0c, 0xe9, 0x58, 0x16, 0x00, 0xef, 0x55, - 0x16, 0x00, 0xf5, 0x54, 0x16, 0x40, 0xe5, 0x57, 0x16, 0x40, 0xe5, 0x51, - 0x16, 0x40, 0xe1, 0xcf, 0x15, 0x00, 0xe5, 0xcc, 0x15, 0x80, 0x0c, 0xe9, - 0xce, 0x15, 0x00, 0xef, 0xcb, 0x15, 0x00, 0xf5, 0xca, 0x15, 0x40, 0xe5, - 0xcd, 0x15, 0x40, 0xe1, 0xed, 0x15, 0x00, 0xe5, 0xea, 0x15, 0x80, 0x0c, - 0xe9, 0xec, 0x15, 0x00, 0xef, 0xe9, 0x15, 0x00, 0xf5, 0xe8, 0x15, 0x40, - 0xe5, 0xeb, 0x15, 0x40, 0xe1, 0x07, 0x16, 0x00, 0xe5, 0x04, 0x16, 0x80, - 0x10, 0xe7, 0xd1, 0x14, 0x00, 0xe9, 0x06, 0x16, 0x00, 0xef, 0x03, 0x16, - 0x00, 0xf5, 0x02, 0x16, 0x40, 0xe5, 0x05, 0x16, 0x40, 0xe1, 0x0d, 0x16, - 0x00, 0xe5, 0x0a, 0x16, 0x80, 0x0c, 0xe9, 0x0c, 0x16, 0x00, 0xef, 0x09, - 0x16, 0x00, 0xf5, 0x08, 0x16, 0x40, 0xe5, 0x0b, 0x16, 0x40, 0xe1, 0x27, - 0x16, 0x00, 0xe5, 0x24, 0x16, 0x80, 0x27, 0xa8, 0x0c, 0xe9, 0x26, 0x16, - 0x00, 0xef, 0x23, 0x16, 0x00, 0xf5, 0x22, 0x16, 0x40, 0xe1, 0x33, 0x16, - 0x00, 0xe5, 0x30, 0x16, 0x80, 0x0c, 0xe9, 0x32, 0x16, 0x00, 0xef, 0x2f, - 0x16, 0x00, 0xf5, 0x2e, 0x16, 0x40, 0xe5, 0x31, 0x16, 0x40, 0xe5, 0x25, - 0x16, 0x40, 0xa8, 0x1e, 0xeb, 0x01, 0x16, 0xc0, 0x00, 0xe1, 0x00, 0x16, - 0x00, 0xe5, 0xfd, 0x15, 0x80, 0x0c, 0xe9, 0xff, 0x15, 0x00, 0xef, 0xfc, - 0x15, 0x00, 0xf5, 0xfb, 0x15, 0x40, 0xe5, 0xfe, 0x15, 0x40, 0xe1, 0xfa, - 0x15, 0x00, 0xe5, 0xf7, 0x15, 0x80, 0x0c, 0xe9, 0xf9, 0x15, 0x00, 0xef, - 0xf6, 0x15, 0x00, 0xf5, 0xf5, 0x15, 0x40, 0xe5, 0xf8, 0x15, 0x40, 0xe1, - 0x1b, 0x16, 0x00, 0xe5, 0x17, 0x16, 0x80, 0x2d, 0xe9, 0x19, 0x16, 0x00, - 0xaa, 0x0e, 0xef, 0x16, 0x16, 0x00, 0xf5, 0x14, 0x16, 0x00, 0x42, 0xa9, - 0x01, 0xf2, 0x18, 0x40, 0xe1, 0x21, 0x16, 0x00, 0xe5, 0x1e, 0x16, 0x80, - 0x0c, 0xe9, 0x20, 0x16, 0x00, 0xef, 0x1d, 0x16, 0x00, 0xf5, 0x1c, 0x16, - 0x40, 0xe5, 0x1f, 0x16, 0x40, 0xe5, 0x18, 0x16, 0x40, 0x48, 0xe1, 0xc8, - 0x47, 0x16, 0x40, 0x42, 0x27, 0x01, 0x36, 0x14, 0x00, 0xe9, 0x37, 0x14, - 0x00, 0xb7, 0x01, 0xff, 0xe1, 0xdb, 0x15, 0x00, 0xe5, 0xd8, 0x15, 0x80, - 0x0c, 0xe9, 0xda, 0x15, 0x00, 0xef, 0xd7, 0x15, 0x00, 0xf5, 0xd6, 0x15, - 0x40, 0xe5, 0xd9, 0x15, 0x40, 0xe1, 0xf4, 0x15, 0x80, 0x3b, 0xe5, 0xf1, - 0x15, 0x80, 0x32, 0xa8, 0x17, 0xe9, 0xf3, 0x15, 0x00, 0xef, 0xf0, 0x15, - 0x00, 0xf5, 0xef, 0x15, 0x00, 0xb7, 0x01, 0xff, 0xe1, 0xf0, 0x18, 0x00, - 0xf5, 0xed, 0x18, 0x40, 0xe1, 0xc9, 0x15, 0x00, 0xe5, 0xc6, 0x15, 0x80, - 0x0c, 0xe9, 0xc8, 0x15, 0x00, 0xef, 0xc5, 0x15, 0x00, 0xf5, 0xc4, 0x15, - 0x40, 0xe5, 0xc7, 0x15, 0x40, 0xe5, 0xf2, 0x15, 0x40, 0xe1, 0xef, 0x18, - 0x40, 0xa5, 0x3b, 0xe9, 0x54, 0x14, 0x00, 0xac, 0x1c, 0xba, 0x01, 0xff, - 0xe1, 0x4d, 0x16, 0x00, 0xe5, 0x4a, 0x16, 0x80, 0x0c, 0xe9, 0x4c, 0x16, - 0x00, 0xef, 0x49, 0x16, 0x00, 0xf5, 0x48, 0x16, 0x40, 0xe5, 0x4b, 0x16, - 0x40, 0xe1, 0x2d, 0x16, 0x00, 0xe5, 0x2a, 0x16, 0x80, 0x0c, 0xe9, 0x2c, - 0x16, 0x00, 0xef, 0x29, 0x16, 0x00, 0xf5, 0x28, 0x16, 0x40, 0xe5, 0x2b, - 0x16, 0x40, 0xe5, 0x53, 0x14, 0x00, 0xae, 0x01, 0xff, 0x45, 0xd0, 0xe5, - 0xee, 0x18, 0x00, 0x45, 0x4e, 0x05, 0xf5, 0x18, 0x40, 0xe1, 0x66, 0x16, - 0x00, 0xe5, 0x63, 0x16, 0x80, 0x0c, 0xe9, 0x65, 0x16, 0x00, 0xef, 0x62, - 0x16, 0x00, 0xf5, 0x61, 0x16, 0x40, 0xe5, 0x64, 0x16, 0x40, 0xe9, 0x8a, - 0x14, 0x40, 0x0b, 0x9f, 0x9b, 0x58, 0x4b, 0x62, 0x9d, 0x3f, 0x15, 0x00, - 0x09, 0x5b, 0xbb, 0x01, 0xff, 0xe1, 0xb3, 0x15, 0x00, 0xe5, 0xb0, 0x15, - 0x00, 0xe9, 0xb1, 0x15, 0x00, 0xab, 0x2f, 0xae, 0x1d, 0xef, 0xb2, 0x15, - 0x00, 0xf3, 0x08, 0x15, 0x00, 0xf7, 0x7f, 0x16, 0xc0, 0x00, 0xe1, 0xb7, - 0x15, 0x00, 0xe5, 0xb4, 0x15, 0x00, 0xe9, 0xb5, 0x15, 0x00, 0xef, 0xb6, - 0x15, 0x40, 0xe1, 0xbb, 0x15, 0x00, 0xe5, 0xb8, 0x15, 0x00, 0xe9, 0xb9, - 0x15, 0x00, 0xef, 0xba, 0x15, 0x40, 0xe1, 0xbf, 0x15, 0x00, 0xe5, 0xbc, - 0x15, 0x00, 0xe9, 0xbd, 0x15, 0x00, 0xef, 0xbe, 0x15, 0x40, 0xec, 0xf3, - 0x18, 0x00, 0xf2, 0xf4, 0x18, 0x40, 0xe1, 0x0b, 0x14, 0x80, 0x1f, 0xe9, - 0x1c, 0x14, 0x80, 0x14, 0xee, 0x2e, 0x14, 0x00, 0x0a, 0xf2, 0xb1, 0x04, - 0xf9, 0xb1, 0x18, 0x40, 0xed, 0xbe, 0x14, 0x00, 0xf3, 0x06, 0x15, 0x40, - 0x47, 0x6b, 0xd7, 0xaf, 0x15, 0x40, 0xe9, 0x02, 0x14, 0x00, 0xf9, 0xb2, - 0x18, 0x40, 0x43, 0xdc, 0x01, 0xf7, 0xf4, 0x81, 0x06, 0x44, 0x46, 0x30, - 0xd5, 0xf3, 0x41, 0x4b, 0x24, 0x98, 0xf8, 0xf4, 0x41, 0x45, 0x31, 0x80, - 0xc5, 0xf4, 0x01, 0x49, 0x52, 0xbb, 0x19, 0xf9, 0x41, 0x45, 0x0e, 0xe4, - 0x06, 0x21, 0x00, 0x45, 0x27, 0xdb, 0x24, 0x26, 0x40, 0xa1, 0xd4, 0x58, - 0xa5, 0xdc, 0x4f, 0x09, 0x75, 0xb9, 0xf0, 0x4a, 0xa9, 0x92, 0x4a, 0xac, - 0x9a, 0x34, 0xaf, 0xe9, 0x22, 0x42, 0x84, 0x10, 0x82, 0x00, 0x00, 0xb2, - 0xed, 0x12, 0xf3, 0x08, 0x00, 0x00, 0xb5, 0xc0, 0x0f, 0xb9, 0x01, 0xff, - 0x4d, 0x33, 0x89, 0xff, 0xfe, 0x00, 0x17, 0x39, 0x32, 0x01, 0xff, 0xa1, - 0xba, 0x0d, 0x02, 0x6d, 0x14, 0x80, 0x0d, 0xa4, 0xd9, 0x0b, 0xa5, 0xa0, - 0x0b, 0xa6, 0xf4, 0x09, 0xa7, 0x91, 0x09, 0xa9, 0xcc, 0x08, 0xab, 0xf4, - 0x06, 0xac, 0xbe, 0x06, 0xad, 0xc9, 0x05, 0x44, 0x81, 0xf1, 0x40, 0xd0, - 0x01, 0xaf, 0xfb, 0x04, 0xb0, 0xd4, 0x03, 0xb2, 0xc5, 0x03, 0xb3, 0xa3, - 0x02, 0xb4, 0x8b, 0x01, 0x02, 0xf5, 0x0a, 0x63, 0x4c, 0x2c, 0x97, 0x6a, - 0xd0, 0x01, 0xb9, 0x01, 0xff, 0x02, 0x28, 0x1a, 0x1e, 0xb0, 0x01, 0xff, - 0xaf, 0x06, 0x44, 0xd8, 0x88, 0x50, 0xd0, 0x41, 0x46, 0x90, 0xdd, 0x0a, - 0xd0, 0x81, 0x06, 0x44, 0x8d, 0xf2, 0x53, 0xd0, 0x41, 0x46, 0x20, 0xd8, - 0x0b, 0xd0, 0x41, 0x02, 0x92, 0x00, 0x28, 0x04, 0xe2, 0x21, 0x01, 0xff, - 0x51, 0x49, 0x58, 0xd4, 0xd0, 0x01, 0x55, 0x4f, 0x3a, 0xd6, 0xd0, 0x01, - 0x5c, 0xda, 0x18, 0xd5, 0xd0, 0x01, 0x03, 0x19, 0x01, 0x01, 0xff, 0x55, - 0x75, 0x3b, 0xd7, 0xd0, 0x01, 0x48, 0x84, 0x34, 0xcd, 0xd0, 0x41, 0x43, - 0x29, 0x7a, 0x7d, 0xd0, 0x01, 0x44, 0xf0, 0x9f, 0x7c, 0xd0, 0x41, 0x04, - 0x65, 0xf2, 0x06, 0x43, 0x07, 0x54, 0x19, 0xd0, 0x41, 0x80, 0x06, 0x4a, - 0x80, 0xab, 0x21, 0xd0, 0x41, 0x45, 0x21, 0xd8, 0x06, 0xd0, 0x01, 0x4b, - 0xfd, 0x7e, 0x05, 0xd0, 0x01, 0x43, 0x6c, 0x54, 0x58, 0xd0, 0x41, 0xa5, - 0x80, 0x01, 0xa8, 0x52, 0x46, 0x00, 0xdd, 0x27, 0xd0, 0x01, 0xb2, 0x01, - 0xff, 0xa9, 0x37, 0x05, 0x25, 0xb5, 0x01, 0xff, 0x47, 0x27, 0xd3, 0x6d, - 0xd0, 0x01, 0x02, 0x92, 0x00, 0x14, 0xb0, 0x06, 0x47, 0x30, 0xd6, 0x70, - 0xd0, 0x41, 0x4a, 0x57, 0xa1, 0x6e, 0xd0, 0x01, 0x48, 0x09, 0xcb, 0x6b, - 0xd0, 0x41, 0xa1, 0x06, 0x43, 0x6c, 0x54, 0x63, 0xd0, 0x41, 0x43, 0xeb, - 0x1c, 0x43, 0xd0, 0x01, 0x47, 0x83, 0xab, 0x36, 0xd0, 0x41, 0xe1, 0x30, - 0xd0, 0x01, 0x46, 0x46, 0xdc, 0x96, 0xd0, 0x01, 0x43, 0xbb, 0x04, 0x87, - 0xd0, 0x41, 0xa5, 0x06, 0x43, 0xe7, 0x05, 0x14, 0xd0, 0x41, 0x42, 0x6c, - 0x00, 0x2d, 0xd0, 0x81, 0x06, 0x4d, 0x56, 0x88, 0x79, 0xd0, 0x41, 0x47, - 0x31, 0xcd, 0x78, 0xd0, 0x01, 0x08, 0xb9, 0xcb, 0x01, 0xff, 0x42, 0x60, - 0x03, 0x76, 0xd0, 0x01, 0x42, 0xe2, 0x2f, 0x77, 0xd0, 0x41, 0x44, 0xcd, - 0x5a, 0x0f, 0xd0, 0x01, 0x45, 0xe8, 0x18, 0x31, 0xd0, 0x01, 0x46, 0xcc, - 0xe0, 0x88, 0xd0, 0x41, 0x47, 0x61, 0xcf, 0x1d, 0xd0, 0x01, 0x45, 0xfd, - 0xe5, 0x29, 0xd0, 0x81, 0x8b, 0x01, 0x08, 0x19, 0xc7, 0x49, 0xb4, 0x2e, - 0xb9, 0x01, 0xff, 0xae, 0x0d, 0x43, 0x8b, 0x06, 0x66, 0xd0, 0xc1, 0x00, - 0x44, 0xe6, 0xdd, 0x08, 0xd0, 0x41, 0x05, 0x40, 0xe4, 0x06, 0x44, 0x2c, - 0xd4, 0x13, 0xd0, 0x41, 0x48, 0x82, 0xab, 0x2a, 0xd0, 0x01, 0x4c, 0x10, - 0x92, 0x2b, 0xd0, 0x01, 0x43, 0x6c, 0x54, 0x65, 0xd0, 0x41, 0x45, 0xae, - 0xe4, 0x7e, 0xd0, 0x81, 0x0c, 0x44, 0xc1, 0x1f, 0xe8, 0xd0, 0x01, 0x4a, - 0x08, 0xb0, 0x44, 0xd0, 0x41, 0x49, 0x65, 0xb4, 0x1f, 0xd0, 0x41, 0x46, - 0x06, 0xda, 0xe2, 0xd0, 0x81, 0x1f, 0x47, 0x6f, 0xd6, 0xde, 0xd0, 0xc1, - 0x00, 0x80, 0x01, 0xff, 0x47, 0x80, 0xd0, 0xdf, 0xd0, 0x01, 0xb4, 0x01, - 0xff, 0x49, 0xd3, 0xb8, 0xe1, 0xd0, 0x01, 0x47, 0x81, 0xd5, 0xe0, 0xd0, - 0x41, 0x80, 0x01, 0xff, 0x47, 0x80, 0xd0, 0xe3, 0xd0, 0x01, 0xb4, 0x01, - 0xff, 0x49, 0xd3, 0xb8, 0xe5, 0xd0, 0x01, 0x47, 0x81, 0xd5, 0xe4, 0xd0, - 0x41, 0x44, 0x2f, 0x89, 0x69, 0xd0, 0x41, 0x46, 0xe8, 0xd9, 0x3c, 0xd0, - 0x01, 0x44, 0x2c, 0xd4, 0x25, 0xd0, 0x41, 0x02, 0x17, 0x00, 0x70, 0xa5, - 0x43, 0x06, 0xd6, 0xdc, 0x33, 0x02, 0x5a, 0x03, 0x01, 0xff, 0x05, 0x0b, - 0xcb, 0x0d, 0xac, 0x01, 0xff, 0xe9, 0x00, 0xd0, 0x01, 0x42, 0x10, 0x00, - 0x17, 0xd0, 0x41, 0x47, 0x27, 0xd3, 0x6c, 0xd0, 0x01, 0xee, 0x39, 0xd0, - 0x81, 0x0c, 0x4b, 0x56, 0xa1, 0x6f, 0xd0, 0x01, 0x47, 0x30, 0xd6, 0x71, - 0xd0, 0x41, 0x44, 0x2f, 0x89, 0x5a, 0xd0, 0x41, 0x48, 0x82, 0xab, 0x26, - 0xd0, 0x01, 0x43, 0x6c, 0x54, 0x59, 0xd0, 0x41, 0x46, 0xc0, 0xdd, 0x38, - 0xd0, 0x81, 0x1e, 0x49, 0x63, 0xa1, 0x02, 0xd0, 0x01, 0x03, 0x8c, 0x2d, - 0x01, 0xff, 0x42, 0x6c, 0x00, 0x41, 0xd0, 0x01, 0xb4, 0x01, 0xff, 0xe9, - 0x49, 0xd0, 0x01, 0x49, 0x1d, 0xbd, 0x4b, 0xd0, 0x41, 0x44, 0x2f, 0x89, - 0x4d, 0xd0, 0x41, 0x02, 0x6d, 0x00, 0x06, 0x45, 0x65, 0xe7, 0x1e, 0xd0, - 0x41, 0x07, 0xc0, 0xce, 0x16, 0x46, 0xe4, 0xdd, 0x09, 0xd0, 0xc1, 0x00, - 0x80, 0x01, 0xff, 0x48, 0x82, 0xab, 0x3e, 0xd0, 0x01, 0x43, 0x6c, 0x54, - 0x5e, 0xd0, 0x41, 0x48, 0x82, 0xab, 0x3d, 0xd0, 0x01, 0x43, 0x6c, 0x54, - 0x5f, 0xd0, 0x41, 0x06, 0xd8, 0xdd, 0x35, 0x45, 0x91, 0xe8, 0x5b, 0xd0, - 0x01, 0x04, 0x55, 0xf3, 0x11, 0x09, 0xca, 0xc1, 0x01, 0xff, 0x48, 0x82, - 0xab, 0x2c, 0xd0, 0x01, 0x43, 0x6c, 0x54, 0x75, 0xd0, 0x41, 0x80, 0x06, - 0x4a, 0x80, 0xab, 0x20, 0xd0, 0x41, 0x45, 0x21, 0xd8, 0x04, 0xd0, 0x01, - 0x4b, 0xfd, 0x7e, 0x03, 0xd0, 0x01, 0x43, 0x6c, 0x54, 0x48, 0xd0, 0x41, - 0x48, 0x82, 0xab, 0x15, 0xd0, 0x01, 0x43, 0x6c, 0x54, 0x47, 0xd0, 0x41, - 0x08, 0xb9, 0xc3, 0x06, 0x4a, 0xc6, 0xab, 0x57, 0xd0, 0x41, 0x05, 0x54, - 0xe4, 0x58, 0x4e, 0xc6, 0x76, 0xa4, 0xd0, 0x01, 0x4d, 0x23, 0x85, 0xaa, - 0xd0, 0x01, 0xb0, 0x29, 0xb4, 0x06, 0x4b, 0xdc, 0xa4, 0xb1, 0xd0, 0x41, - 0x08, 0xcb, 0x7c, 0x11, 0x02, 0x0d, 0x00, 0x01, 0xff, 0x46, 0x6b, 0xa3, - 0xa7, 0xd0, 0x01, 0x49, 0xcf, 0x7c, 0xa6, 0xd0, 0x41, 0x45, 0xcf, 0x76, - 0xa8, 0xd0, 0x01, 0x4d, 0x23, 0x85, 0xa9, 0xd0, 0x41, 0x07, 0xbe, 0xd2, - 0x11, 0x04, 0xf1, 0x93, 0x01, 0xff, 0x47, 0xcd, 0x76, 0xa2, 0xd0, 0x01, - 0x4b, 0xdc, 0xa4, 0xb2, 0xd0, 0x41, 0x45, 0xcf, 0x76, 0xab, 0xd0, 0x01, - 0x4e, 0xca, 0x7c, 0xb3, 0xd0, 0x41, 0x4e, 0xc6, 0x76, 0xa5, 0xd0, 0x01, - 0x4c, 0xf0, 0x93, 0xa3, 0xd0, 0x41, 0xa5, 0x06, 0x46, 0x28, 0xd3, 0x5d, - 0xd0, 0x41, 0x05, 0x8d, 0xe7, 0x06, 0x43, 0x13, 0xc7, 0x2e, 0xd0, 0x41, - 0x4b, 0x7e, 0x9b, 0x8b, 0xd0, 0x01, 0x4c, 0xb0, 0x8e, 0x8a, 0xd0, 0x01, - 0x4f, 0x8f, 0x6e, 0x8e, 0xd0, 0x01, 0xb4, 0x01, 0xff, 0x4f, 0xeb, 0x6c, - 0x8d, 0xd0, 0x01, 0x4c, 0xc8, 0x94, 0x8c, 0xd0, 0x41, 0x02, 0x8a, 0x00, - 0xba, 0x01, 0x06, 0x74, 0xdb, 0x70, 0x45, 0x33, 0x97, 0x24, 0xd0, 0x81, - 0x5a, 0xaf, 0x3f, 0xb2, 0x06, 0x46, 0xb1, 0xd2, 0x61, 0xd0, 0x41, 0x04, - 0x41, 0xef, 0x06, 0x46, 0x5c, 0xdb, 0x0c, 0xd0, 0x41, 0xa1, 0x0f, 0xaf, - 0x01, 0xff, 0x48, 0x1e, 0xbd, 0x4c, 0xd0, 0x01, 0x48, 0x09, 0xcd, 0x54, - 0xd0, 0x41, 0x80, 0x06, 0x42, 0x12, 0x00, 0x32, 0xd0, 0x41, 0xa1, 0x06, - 0x43, 0x6c, 0x54, 0x83, 0xd0, 0x41, 0x43, 0xeb, 0x1c, 0x82, 0xd0, 0x01, - 0x47, 0x83, 0xab, 0x81, 0xd0, 0x41, 0x46, 0xaa, 0xde, 0x3a, 0xd0, 0x81, - 0x0c, 0x45, 0xf8, 0x61, 0x89, 0xd0, 0x01, 0x46, 0x20, 0xbd, 0x4a, 0xd0, - 0x41, 0x45, 0xc6, 0xce, 0x42, 0xd0, 0x41, 0x80, 0x01, 0xff, 0x43, 0x29, - 0x7a, 0x7f, 0xd0, 0x01, 0x44, 0xf0, 0x9f, 0xf4, 0xd0, 0x41, 0x80, 0x27, - 0x42, 0x12, 0x00, 0x10, 0xd0, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x48, 0x82, - 0xab, 0x1c, 0xd0, 0x01, 0x04, 0x99, 0xf1, 0x01, 0xff, 0x43, 0x29, 0x7a, - 0x4e, 0xd0, 0x01, 0x44, 0xf0, 0x9f, 0xf2, 0xd0, 0x01, 0x44, 0x49, 0xf1, - 0xf0, 0xd0, 0x41, 0x48, 0x82, 0xab, 0x1b, 0xd0, 0x01, 0x04, 0x99, 0xf1, - 0x01, 0xff, 0x43, 0x29, 0x7a, 0x4f, 0xd0, 0x01, 0x44, 0xf0, 0x9f, 0xf3, - 0xd0, 0x01, 0x44, 0x49, 0xf1, 0xf1, 0xd0, 0x41, 0x03, 0x67, 0x12, 0x06, - 0x45, 0x29, 0xe7, 0x07, 0xd0, 0x41, 0x49, 0x22, 0xb5, 0x37, 0xd0, 0x01, - 0x43, 0x5d, 0x07, 0x7a, 0xd0, 0x41, 0x46, 0x90, 0xda, 0x3f, 0xd0, 0x01, - 0x02, 0x7d, 0x02, 0x1a, 0xb3, 0x01, 0xff, 0x55, 0x29, 0x39, 0xac, 0xd0, - 0x01, 0x03, 0xb6, 0x00, 0x01, 0xff, 0x48, 0x82, 0xab, 0x1a, 0xd0, 0x01, - 0x43, 0x6c, 0x54, 0x46, 0xd0, 0x41, 0x47, 0x72, 0xd0, 0x98, 0xd0, 0x01, - 0xa6, 0x01, 0xff, 0x44, 0xf6, 0x6c, 0xb7, 0xd0, 0x01, 0x04, 0x67, 0x2a, - 0x01, 0xff, 0xe1, 0x35, 0xd0, 0x01, 0x42, 0x10, 0x00, 0xb8, 0xd0, 0x41, - 0x06, 0x6e, 0xdb, 0x50, 0x02, 0x0c, 0x00, 0x06, 0x4b, 0x69, 0xa2, 0x45, - 0xd0, 0x41, 0x02, 0x06, 0x14, 0x11, 0x0a, 0x06, 0xb2, 0x01, 0xff, 0x46, - 0x32, 0xcd, 0xb4, 0xd0, 0x01, 0x47, 0x79, 0xd0, 0xb5, 0xd0, 0x41, 0x02, - 0x92, 0x00, 0x06, 0x49, 0xc9, 0x80, 0x72, 0xd0, 0x41, 0x48, 0x82, 0xab, - 0x16, 0xd0, 0x01, 0x04, 0x99, 0xf1, 0x11, 0x0e, 0x95, 0x69, 0x01, 0xff, - 0x48, 0x6f, 0xb6, 0x90, 0xd0, 0x01, 0x45, 0x69, 0xb4, 0x91, 0xd0, 0x41, - 0x43, 0x29, 0x7a, 0x8f, 0xd0, 0x01, 0x44, 0xf0, 0x9f, 0xf5, 0xd0, 0x41, - 0x46, 0x14, 0xdb, 0xd8, 0xd0, 0x01, 0x46, 0x78, 0x34, 0xd9, 0xd0, 0x41, - 0x09, 0x27, 0xb6, 0x92, 0x01, 0x5a, 0x34, 0x20, 0xc5, 0xd0, 0x01, 0x06, - 0xda, 0x40, 0x01, 0xff, 0x48, 0x82, 0xab, 0x34, 0xd0, 0x81, 0x7a, 0x0a, - 0x64, 0xa9, 0x45, 0x54, 0x23, 0x42, 0xcc, 0xd0, 0x01, 0x56, 0x76, 0x34, - 0xcb, 0xd0, 0x01, 0x0f, 0x24, 0x70, 0x29, 0xae, 0x1b, 0x08, 0x3a, 0x20, - 0x01, 0xff, 0x07, 0x42, 0x20, 0x06, 0x4b, 0x1b, 0x9b, 0xbe, 0xd0, 0x41, - 0x46, 0x66, 0xe0, 0xc6, 0xd0, 0x01, 0x45, 0x49, 0x20, 0xc5, 0xd0, 0x41, - 0x49, 0x5d, 0xb6, 0xbc, 0xd0, 0x01, 0x45, 0x16, 0xe6, 0xc7, 0xd0, 0x41, - 0x48, 0x39, 0xc5, 0xc3, 0xd0, 0x01, 0x4a, 0x14, 0xae, 0xc4, 0xd0, 0x41, - 0x42, 0x00, 0x00, 0xbd, 0xd0, 0x01, 0x42, 0x37, 0x01, 0xbf, 0xd0, 0x01, - 0xae, 0x0c, 0x42, 0xbb, 0x09, 0xba, 0xd0, 0x01, 0x42, 0x0f, 0x00, 0xc0, - 0xd0, 0x41, 0x43, 0x4b, 0x12, 0xbb, 0xd0, 0x01, 0x02, 0xf1, 0x03, 0x01, - 0xff, 0x43, 0x29, 0x7a, 0xc2, 0xd0, 0x01, 0x44, 0xf0, 0x9f, 0xc1, 0xd0, - 0x41, 0x4f, 0x49, 0x69, 0xb9, 0xd0, 0x41, 0x48, 0x39, 0xc5, 0xb0, 0xd0, - 0x01, 0x4a, 0x14, 0xae, 0xaf, 0xd0, 0x01, 0x4b, 0x66, 0xa3, 0xae, 0xd0, - 0x41, 0x49, 0x37, 0xbb, 0x64, 0xd0, 0x01, 0x46, 0xa8, 0xdd, 0x55, 0xd0, - 0x01, 0xae, 0x1c, 0x47, 0xc4, 0xd4, 0x68, 0xd0, 0x01, 0x06, 0xa2, 0xe0, - 0x06, 0x4e, 0xfa, 0x7e, 0x0e, 0xd0, 0x41, 0x4d, 0xc5, 0x80, 0x74, 0xd0, - 0x01, 0x4b, 0x56, 0xa1, 0x60, 0xd0, 0x41, 0x54, 0xcf, 0x40, 0xb6, 0xd0, - 0x01, 0x47, 0x87, 0xd0, 0x7b, 0xd0, 0x41, 0x45, 0x95, 0xe4, 0x01, 0xd0, - 0x01, 0xa9, 0x06, 0x42, 0xb0, 0x47, 0x2f, 0xd0, 0x41, 0xa1, 0x6d, 0x05, - 0xe1, 0x21, 0x3d, 0x4a, 0xa4, 0xaa, 0xe7, 0xd0, 0x01, 0xa7, 0x0d, 0x43, - 0xbb, 0x04, 0x86, 0xd0, 0xc1, 0x00, 0x49, 0x81, 0xab, 0x80, 0xd0, 0x41, - 0x45, 0x47, 0xdc, 0x92, 0xd0, 0x81, 0x06, 0x48, 0x41, 0xca, 0xe6, 0xd0, - 0x41, 0x0f, 0x94, 0x69, 0x01, 0xff, 0x09, 0x6f, 0xb6, 0x06, 0x45, 0x69, - 0xb4, 0x95, 0xd0, 0x41, 0x43, 0x29, 0x7a, 0x94, 0xd0, 0x01, 0x44, 0xf0, - 0x9f, 0x93, 0xd0, 0x41, 0x51, 0x49, 0x58, 0xd0, 0xd0, 0x01, 0x55, 0x4f, - 0x3a, 0xd2, 0xd0, 0x01, 0x5c, 0xda, 0x18, 0xd1, 0xd0, 0x01, 0xb4, 0x01, - 0xff, 0x4c, 0x80, 0x34, 0xcf, 0xd0, 0x01, 0x02, 0x0d, 0x00, 0x01, 0xff, - 0x55, 0x75, 0x3b, 0xd3, 0xd0, 0x01, 0x48, 0x84, 0x34, 0xce, 0xd0, 0x41, - 0x44, 0x75, 0xd0, 0x99, 0xd0, 0x01, 0x06, 0x42, 0xe0, 0x01, 0xff, 0x06, - 0xee, 0xd9, 0x0c, 0x45, 0x21, 0xd8, 0xdc, 0xd0, 0x01, 0x47, 0x6f, 0xd6, - 0xdd, 0xd0, 0x41, 0x45, 0xe9, 0xe5, 0xdb, 0xd0, 0x01, 0x44, 0x5f, 0x95, - 0xda, 0xd0, 0x41, 0x04, 0x92, 0x65, 0x27, 0x07, 0x2a, 0xd4, 0x17, 0x04, - 0x79, 0xf2, 0x01, 0xff, 0x46, 0x8a, 0xdd, 0xc9, 0xd0, 0x01, 0x46, 0x1e, - 0xe0, 0xca, 0xd0, 0x01, 0x45, 0xd8, 0xec, 0xc8, 0xd0, 0x41, 0x48, 0x82, - 0xab, 0x3b, 0xd0, 0x01, 0x43, 0x6c, 0x54, 0x67, 0xd0, 0x41, 0xe9, 0x56, - 0xd0, 0x01, 0x42, 0x10, 0x00, 0x18, 0xd0, 0x41, 0x05, 0xcf, 0xe6, 0xb3, - 0x01, 0xae, 0x99, 0x01, 0xb0, 0x40, 0xb2, 0x01, 0xff, 0x02, 0x06, 0x14, - 0x2f, 0x06, 0x96, 0xdd, 0x01, 0xff, 0x42, 0x00, 0x00, 0xec, 0xd0, 0x01, - 0x42, 0x24, 0x02, 0xeb, 0xd0, 0x01, 0x42, 0x37, 0x01, 0xed, 0xd0, 0x01, - 0x42, 0x51, 0x03, 0xef, 0xd0, 0x01, 0x42, 0xbb, 0x09, 0xe9, 0xd0, 0x01, - 0x43, 0xbc, 0x2d, 0xea, 0xd0, 0x01, 0x42, 0x0f, 0x00, 0xee, 0xd0, 0x41, - 0xee, 0x97, 0xd0, 0x01, 0x49, 0xc9, 0x80, 0x73, 0xd0, 0x41, 0x05, 0x43, - 0xe6, 0x47, 0x42, 0xc3, 0x01, 0x85, 0xd0, 0x01, 0xaf, 0x01, 0xff, 0x06, - 0x02, 0xdb, 0x2e, 0x06, 0x48, 0xe0, 0x06, 0x45, 0xaa, 0x53, 0x23, 0xd0, - 0x41, 0x02, 0xf1, 0x03, 0x14, 0xf3, 0x11, 0xd0, 0xc1, 0x00, 0x80, 0x01, - 0xff, 0x45, 0x21, 0xd8, 0x12, 0xd0, 0x01, 0x43, 0x6c, 0x54, 0x51, 0xd0, - 0x41, 0x4d, 0x26, 0x89, 0x52, 0xd0, 0x01, 0x50, 0x2e, 0x39, 0xad, 0xd0, - 0x41, 0x48, 0x82, 0xab, 0x22, 0xd0, 0x01, 0x43, 0x6c, 0x54, 0x84, 0xd0, - 0x41, 0x4a, 0xfe, 0x7e, 0x0d, 0xd0, 0x01, 0x46, 0x8c, 0xe1, 0x33, 0xd0, - 0x41, 0x4a, 0x24, 0xa8, 0x28, 0xd0, 0x01, 0x06, 0xb4, 0xe0, 0x01, 0xff, - 0x47, 0xb0, 0xd2, 0x62, 0xd0, 0x01, 0x42, 0x6c, 0x00, 0x5c, 0xd0, 0x41, - 0x03, 0x33, 0x13, 0x2f, 0x04, 0x46, 0xdc, 0x21, 0x02, 0x2a, 0x02, 0x11, - 0x05, 0x21, 0xea, 0x01, 0xff, 0x44, 0x35, 0xef, 0x9a, 0xd0, 0x01, 0x45, - 0xd4, 0xe6, 0xa1, 0xd0, 0x41, 0x42, 0x5a, 0x03, 0x9e, 0xd0, 0x01, 0x44, - 0x19, 0x01, 0x9d, 0xd0, 0x41, 0xe9, 0x9f, 0xd0, 0x01, 0x45, 0xc7, 0xe9, - 0xa0, 0xd0, 0x41, 0xe9, 0x9c, 0xd0, 0x01, 0x45, 0xc7, 0xe9, 0x9b, 0xd0, - 0x41, 0x04, 0x8d, 0x7c, 0x97, 0x03, 0x44, 0x66, 0x09, 0xa3, 0xfa, 0x01, - 0xe7, 0x1b, 0xf4, 0x81, 0xd2, 0x01, 0x04, 0x61, 0xf0, 0x57, 0x53, 0x30, - 0x4a, 0xd7, 0xf3, 0x01, 0x02, 0x60, 0x07, 0x2d, 0x45, 0xa8, 0xea, 0x2f, - 0xf3, 0x01, 0xf3, 0x8c, 0xf6, 0x81, 0x0d, 0x44, 0xee, 0x05, 0xc8, 0xf9, - 0xc1, 0x00, 0x43, 0x67, 0xf4, 0x8b, 0xf9, 0x41, 0x45, 0x54, 0x03, 0x8f, - 0xf6, 0x01, 0xb4, 0x01, 0xff, 0x4e, 0xd6, 0x34, 0x64, 0xf4, 0x01, 0x4f, - 0xf4, 0x72, 0x65, 0xf4, 0x41, 0x42, 0xed, 0x05, 0x22, 0x20, 0x80, 0x13, - 0x44, 0x7b, 0x2d, 0x6b, 0xf5, 0x81, 0x06, 0x44, 0xc1, 0xf2, 0xce, 0x25, - 0x40, 0x51, 0x7d, 0x57, 0x6c, 0xf5, 0x41, 0x49, 0x99, 0x1d, 0x19, 0x22, - 0x40, 0x07, 0xec, 0x05, 0x0d, 0x0b, 0x55, 0x77, 0x01, 0xff, 0xe9, 0x52, - 0x17, 0x00, 0xf5, 0x53, 0x17, 0x40, 0xe1, 0x40, 0x17, 0x00, 0x42, 0x16, - 0x00, 0x4a, 0x17, 0x00, 0x42, 0xf0, 0x10, 0x47, 0x17, 0x00, 0x42, 0x24, - 0x02, 0x44, 0x17, 0x00, 0x42, 0x22, 0x00, 0x51, 0x17, 0x00, 0xe9, 0x41, - 0x17, 0x00, 0x42, 0x1b, 0x02, 0x43, 0x17, 0x00, 0x42, 0x74, 0x00, 0x4e, - 0x17, 0x00, 0x42, 0x6c, 0x00, 0x4b, 0x17, 0x00, 0xae, 0x28, 0x42, 0xbb, - 0x09, 0x49, 0x17, 0x00, 0x42, 0x71, 0x00, 0x4d, 0x17, 0x00, 0x42, 0x40, - 0x06, 0x50, 0x17, 0x00, 0x42, 0x12, 0x00, 0x46, 0x17, 0x00, 0xf5, 0x42, - 0x17, 0x00, 0x42, 0xa9, 0x01, 0x4f, 0x17, 0x00, 0x42, 0xbe, 0x22, 0x4c, - 0x17, 0x40, 0xe1, 0x48, 0x17, 0x00, 0x42, 0x24, 0x02, 0x45, 0x17, 0x40, - 0x06, 0xd2, 0x83, 0x01, 0xff, 0x4e, 0x60, 0x77, 0x1f, 0x1a, 0x00, 0x07, - 0xec, 0x05, 0x21, 0x47, 0x93, 0xd4, 0x1e, 0x1a, 0x00, 0x0b, 0x55, 0x77, - 0x01, 0xff, 0x42, 0x93, 0x0f, 0x1b, 0x1a, 0x00, 0xe5, 0x19, 0x1a, 0x00, - 0xe9, 0x17, 0x1a, 0x00, 0xef, 0x1a, 0x1a, 0x00, 0xf5, 0x18, 0x1a, 0x40, - 0xe1, 0x15, 0x1a, 0x00, 0x42, 0x16, 0x00, 0x05, 0x1a, 0x00, 0x42, 0x37, - 0x00, 0x0c, 0x1a, 0x00, 0x42, 0xf0, 0x10, 0x09, 0x1a, 0x00, 0x42, 0x24, - 0x02, 0x01, 0x1a, 0x00, 0x42, 0x22, 0x00, 0x16, 0x1a, 0x00, 0x42, 0x72, - 0x19, 0x0d, 0x1a, 0x00, 0x42, 0x1b, 0x02, 0x00, 0x1a, 0x00, 0x42, 0x74, - 0x00, 0x12, 0x1a, 0x00, 0xad, 0x49, 0xae, 0x24, 0x42, 0xbb, 0x09, 0x04, - 0x1a, 0x00, 0x42, 0x71, 0x00, 0x11, 0x1a, 0x00, 0x42, 0x40, 0x06, 0x14, - 0x1a, 0x00, 0x42, 0x12, 0x00, 0x08, 0x1a, 0x00, 0x42, 0xf5, 0x0a, 0x13, - 0x1a, 0x00, 0x42, 0xbe, 0x22, 0x10, 0x1a, 0x40, 0xe1, 0x0a, 0x1a, 0x00, - 0xa7, 0x13, 0x42, 0x71, 0x00, 0x0b, 0x1a, 0x00, 0xb9, 0x01, 0xff, 0xe1, - 0x0e, 0x1a, 0x00, 0x42, 0x37, 0x00, 0x0f, 0x1a, 0x40, 0xe1, 0x02, 0x1a, - 0x00, 0x42, 0x1b, 0x02, 0x03, 0x1a, 0x40, 0xe1, 0x06, 0x1a, 0x00, 0x42, - 0xbb, 0x09, 0x07, 0x1a, 0x40, 0x44, 0x5e, 0x52, 0xcb, 0xf9, 0x01, 0xf3, - 0xe7, 0xfa, 0x41, 0xa1, 0x6a, 0xa5, 0x50, 0xa9, 0x2b, 0xaf, 0x01, 0xff, - 0x45, 0x2b, 0xe5, 0x66, 0xf9, 0x01, 0x04, 0x81, 0xa8, 0x0c, 0x42, 0x14, - 0x05, 0xf9, 0xf9, 0x01, 0x48, 0x91, 0xcc, 0x0e, 0xf9, 0x41, 0x43, 0x16, - 0x00, 0xa6, 0x00, 0x00, 0x5b, 0xc9, 0x1a, 0x8b, 0x23, 0x00, 0x45, 0xae, - 0x21, 0x94, 0xf4, 0x41, 0x42, 0x36, 0x01, 0xf1, 0xf9, 0x01, 0xa4, 0x0f, - 0x02, 0x69, 0x00, 0x01, 0xff, 0x44, 0x79, 0xef, 0xbc, 0xf4, 0x01, 0xf3, - 0x72, 0xfa, 0x41, 0x4b, 0x89, 0x9b, 0x70, 0xf4, 0x01, 0x4b, 0x70, 0x9c, - 0x09, 0xf3, 0x41, 0xa1, 0x06, 0x42, 0x32, 0x00, 0xd8, 0x02, 0x40, 0xe4, - 0x5e, 0xf3, 0x01, 0x50, 0x5d, 0x64, 0x82, 0x00, 0x00, 0x4a, 0x7a, 0xb1, - 0x31, 0xf9, 0x41, 0x04, 0x69, 0xf0, 0x98, 0x09, 0xa9, 0x01, 0xff, 0x0c, - 0x74, 0x91, 0x04, 0xee, 0xe0, 0xf9, 0x41, 0x45, 0x66, 0xc0, 0x00, 0x28, - 0x00, 0x05, 0xc1, 0xe5, 0x01, 0xff, 0xd1, 0x01, 0x28, 0x80, 0xbe, 0x04, - 0xd2, 0x02, 0x28, 0x80, 0x9c, 0x02, 0xd3, 0x04, 0x28, 0x80, 0x8b, 0x01, - 0xd4, 0x08, 0x28, 0x80, 0x43, 0xd5, 0x10, 0x28, 0x80, 0x1f, 0xd6, 0x20, - 0x28, 0x80, 0x0d, 0xd7, 0x40, 0x28, 0x80, 0x04, 0xd8, 0x80, 0x28, 0x40, - 0xd8, 0xc0, 0x28, 0x40, 0xd7, 0x60, 0x28, 0x80, 0x04, 0xd8, 0xa0, 0x28, - 0x40, 0xd8, 0xe0, 0x28, 0x40, 0xd6, 0x30, 0x28, 0x80, 0x0d, 0xd7, 0x50, - 0x28, 0x80, 0x04, 0xd8, 0x90, 0x28, 0x40, 0xd8, 0xd0, 0x28, 0x40, 0xd7, - 0x70, 0x28, 0x80, 0x04, 0xd8, 0xb0, 0x28, 0x40, 0xd8, 0xf0, 0x28, 0x40, - 0xd5, 0x18, 0x28, 0x80, 0x1f, 0xd6, 0x28, 0x28, 0x80, 0x0d, 0xd7, 0x48, - 0x28, 0x80, 0x04, 0xd8, 0x88, 0x28, 0x40, 0xd8, 0xc8, 0x28, 0x40, 0xd7, - 0x68, 0x28, 0x80, 0x04, 0xd8, 0xa8, 0x28, 0x40, 0xd8, 0xe8, 0x28, 0x40, - 0xd6, 0x38, 0x28, 0x80, 0x0d, 0xd7, 0x58, 0x28, 0x80, 0x04, 0xd8, 0x98, - 0x28, 0x40, 0xd8, 0xd8, 0x28, 0x40, 0xd7, 0x78, 0x28, 0x80, 0x04, 0xd8, - 0xb8, 0x28, 0x40, 0xd8, 0xf8, 0x28, 0x40, 0xd4, 0x0c, 0x28, 0x80, 0x43, - 0xd5, 0x14, 0x28, 0x80, 0x1f, 0xd6, 0x24, 0x28, 0x80, 0x0d, 0xd7, 0x44, - 0x28, 0x80, 0x04, 0xd8, 0x84, 0x28, 0x40, 0xd8, 0xc4, 0x28, 0x40, 0xd7, - 0x64, 0x28, 0x80, 0x04, 0xd8, 0xa4, 0x28, 0x40, 0xd8, 0xe4, 0x28, 0x40, - 0xd6, 0x34, 0x28, 0x80, 0x0d, 0xd7, 0x54, 0x28, 0x80, 0x04, 0xd8, 0x94, - 0x28, 0x40, 0xd8, 0xd4, 0x28, 0x40, 0xd7, 0x74, 0x28, 0x80, 0x04, 0xd8, - 0xb4, 0x28, 0x40, 0xd8, 0xf4, 0x28, 0x40, 0xd5, 0x1c, 0x28, 0x80, 0x1f, - 0xd6, 0x2c, 0x28, 0x80, 0x0d, 0xd7, 0x4c, 0x28, 0x80, 0x04, 0xd8, 0x8c, - 0x28, 0x40, 0xd8, 0xcc, 0x28, 0x40, 0xd7, 0x6c, 0x28, 0x80, 0x04, 0xd8, - 0xac, 0x28, 0x40, 0xd8, 0xec, 0x28, 0x40, 0xd6, 0x3c, 0x28, 0x80, 0x0d, - 0xd7, 0x5c, 0x28, 0x80, 0x04, 0xd8, 0x9c, 0x28, 0x40, 0xd8, 0xdc, 0x28, - 0x40, 0xd7, 0x7c, 0x28, 0x80, 0x04, 0xd8, 0xbc, 0x28, 0x40, 0xd8, 0xfc, - 0x28, 0x40, 0xd3, 0x06, 0x28, 0x80, 0x8b, 0x01, 0xd4, 0x0a, 0x28, 0x80, - 0x43, 0xd5, 0x12, 0x28, 0x80, 0x1f, 0xd6, 0x22, 0x28, 0x80, 0x0d, 0xd7, - 0x42, 0x28, 0x80, 0x04, 0xd8, 0x82, 0x28, 0x40, 0xd8, 0xc2, 0x28, 0x40, - 0xd7, 0x62, 0x28, 0x80, 0x04, 0xd8, 0xa2, 0x28, 0x40, 0xd8, 0xe2, 0x28, - 0x40, 0xd6, 0x32, 0x28, 0x80, 0x0d, 0xd7, 0x52, 0x28, 0x80, 0x04, 0xd8, - 0x92, 0x28, 0x40, 0xd8, 0xd2, 0x28, 0x40, 0xd7, 0x72, 0x28, 0x80, 0x04, - 0xd8, 0xb2, 0x28, 0x40, 0xd8, 0xf2, 0x28, 0x40, 0xd5, 0x1a, 0x28, 0x80, - 0x1f, 0xd6, 0x2a, 0x28, 0x80, 0x0d, 0xd7, 0x4a, 0x28, 0x80, 0x04, 0xd8, - 0x8a, 0x28, 0x40, 0xd8, 0xca, 0x28, 0x40, 0xd7, 0x6a, 0x28, 0x80, 0x04, - 0xd8, 0xaa, 0x28, 0x40, 0xd8, 0xea, 0x28, 0x40, 0xd6, 0x3a, 0x28, 0x80, - 0x0d, 0xd7, 0x5a, 0x28, 0x80, 0x04, 0xd8, 0x9a, 0x28, 0x40, 0xd8, 0xda, - 0x28, 0x40, 0xd7, 0x7a, 0x28, 0x80, 0x04, 0xd8, 0xba, 0x28, 0x40, 0xd8, - 0xfa, 0x28, 0x40, 0xd4, 0x0e, 0x28, 0x80, 0x43, 0xd5, 0x16, 0x28, 0x80, - 0x1f, 0xd6, 0x26, 0x28, 0x80, 0x0d, 0xd7, 0x46, 0x28, 0x80, 0x04, 0xd8, - 0x86, 0x28, 0x40, 0xd8, 0xc6, 0x28, 0x40, 0xd7, 0x66, 0x28, 0x80, 0x04, - 0xd8, 0xa6, 0x28, 0x40, 0xd8, 0xe6, 0x28, 0x40, 0xd6, 0x36, 0x28, 0x80, - 0x0d, 0xd7, 0x56, 0x28, 0x80, 0x04, 0xd8, 0x96, 0x28, 0x40, 0xd8, 0xd6, - 0x28, 0x40, 0xd7, 0x76, 0x28, 0x80, 0x04, 0xd8, 0xb6, 0x28, 0x40, 0xd8, - 0xf6, 0x28, 0x40, 0xd5, 0x1e, 0x28, 0x80, 0x1f, 0xd6, 0x2e, 0x28, 0x80, - 0x0d, 0xd7, 0x4e, 0x28, 0x80, 0x04, 0xd8, 0x8e, 0x28, 0x40, 0xd8, 0xce, - 0x28, 0x40, 0xd7, 0x6e, 0x28, 0x80, 0x04, 0xd8, 0xae, 0x28, 0x40, 0xd8, - 0xee, 0x28, 0x40, 0xd6, 0x3e, 0x28, 0x80, 0x0d, 0xd7, 0x5e, 0x28, 0x80, - 0x04, 0xd8, 0x9e, 0x28, 0x40, 0xd8, 0xde, 0x28, 0x40, 0xd7, 0x7e, 0x28, - 0x80, 0x04, 0xd8, 0xbe, 0x28, 0x40, 0xd8, 0xfe, 0x28, 0x40, 0xd2, 0x03, - 0x28, 0x80, 0x9c, 0x02, 0xd3, 0x05, 0x28, 0x80, 0x8b, 0x01, 0xd4, 0x09, - 0x28, 0x80, 0x43, 0xd5, 0x11, 0x28, 0x80, 0x1f, 0xd6, 0x21, 0x28, 0x80, - 0x0d, 0xd7, 0x41, 0x28, 0x80, 0x04, 0xd8, 0x81, 0x28, 0x40, 0xd8, 0xc1, - 0x28, 0x40, 0xd7, 0x61, 0x28, 0x80, 0x04, 0xd8, 0xa1, 0x28, 0x40, 0xd8, - 0xe1, 0x28, 0x40, 0xd6, 0x31, 0x28, 0x80, 0x0d, 0xd7, 0x51, 0x28, 0x80, - 0x04, 0xd8, 0x91, 0x28, 0x40, 0xd8, 0xd1, 0x28, 0x40, 0xd7, 0x71, 0x28, - 0x80, 0x04, 0xd8, 0xb1, 0x28, 0x40, 0xd8, 0xf1, 0x28, 0x40, 0xd5, 0x19, - 0x28, 0x80, 0x1f, 0xd6, 0x29, 0x28, 0x80, 0x0d, 0xd7, 0x49, 0x28, 0x80, - 0x04, 0xd8, 0x89, 0x28, 0x40, 0xd8, 0xc9, 0x28, 0x40, 0xd7, 0x69, 0x28, - 0x80, 0x04, 0xd8, 0xa9, 0x28, 0x40, 0xd8, 0xe9, 0x28, 0x40, 0xd6, 0x39, - 0x28, 0x80, 0x0d, 0xd7, 0x59, 0x28, 0x80, 0x04, 0xd8, 0x99, 0x28, 0x40, - 0xd8, 0xd9, 0x28, 0x40, 0xd7, 0x79, 0x28, 0x80, 0x04, 0xd8, 0xb9, 0x28, - 0x40, 0xd8, 0xf9, 0x28, 0x40, 0xd4, 0x0d, 0x28, 0x80, 0x43, 0xd5, 0x15, - 0x28, 0x80, 0x1f, 0xd6, 0x25, 0x28, 0x80, 0x0d, 0xd7, 0x45, 0x28, 0x80, - 0x04, 0xd8, 0x85, 0x28, 0x40, 0xd8, 0xc5, 0x28, 0x40, 0xd7, 0x65, 0x28, - 0x80, 0x04, 0xd8, 0xa5, 0x28, 0x40, 0xd8, 0xe5, 0x28, 0x40, 0xd6, 0x35, - 0x28, 0x80, 0x0d, 0xd7, 0x55, 0x28, 0x80, 0x04, 0xd8, 0x95, 0x28, 0x40, - 0xd8, 0xd5, 0x28, 0x40, 0xd7, 0x75, 0x28, 0x80, 0x04, 0xd8, 0xb5, 0x28, - 0x40, 0xd8, 0xf5, 0x28, 0x40, 0xd5, 0x1d, 0x28, 0x80, 0x1f, 0xd6, 0x2d, - 0x28, 0x80, 0x0d, 0xd7, 0x4d, 0x28, 0x80, 0x04, 0xd8, 0x8d, 0x28, 0x40, - 0xd8, 0xcd, 0x28, 0x40, 0xd7, 0x6d, 0x28, 0x80, 0x04, 0xd8, 0xad, 0x28, - 0x40, 0xd8, 0xed, 0x28, 0x40, 0xd6, 0x3d, 0x28, 0x80, 0x0d, 0xd7, 0x5d, - 0x28, 0x80, 0x04, 0xd8, 0x9d, 0x28, 0x40, 0xd8, 0xdd, 0x28, 0x40, 0xd7, - 0x7d, 0x28, 0x80, 0x04, 0xd8, 0xbd, 0x28, 0x40, 0xd8, 0xfd, 0x28, 0x40, - 0xd3, 0x07, 0x28, 0x80, 0x8b, 0x01, 0xd4, 0x0b, 0x28, 0x80, 0x43, 0xd5, - 0x13, 0x28, 0x80, 0x1f, 0xd6, 0x23, 0x28, 0x80, 0x0d, 0xd7, 0x43, 0x28, - 0x80, 0x04, 0xd8, 0x83, 0x28, 0x40, 0xd8, 0xc3, 0x28, 0x40, 0xd7, 0x63, - 0x28, 0x80, 0x04, 0xd8, 0xa3, 0x28, 0x40, 0xd8, 0xe3, 0x28, 0x40, 0xd6, - 0x33, 0x28, 0x80, 0x0d, 0xd7, 0x53, 0x28, 0x80, 0x04, 0xd8, 0x93, 0x28, - 0x40, 0xd8, 0xd3, 0x28, 0x40, 0xd7, 0x73, 0x28, 0x80, 0x04, 0xd8, 0xb3, - 0x28, 0x40, 0xd8, 0xf3, 0x28, 0x40, 0xd5, 0x1b, 0x28, 0x80, 0x1f, 0xd6, - 0x2b, 0x28, 0x80, 0x0d, 0xd7, 0x4b, 0x28, 0x80, 0x04, 0xd8, 0x8b, 0x28, - 0x40, 0xd8, 0xcb, 0x28, 0x40, 0xd7, 0x6b, 0x28, 0x80, 0x04, 0xd8, 0xab, - 0x28, 0x40, 0xd8, 0xeb, 0x28, 0x40, 0xd6, 0x3b, 0x28, 0x80, 0x0d, 0xd7, - 0x5b, 0x28, 0x80, 0x04, 0xd8, 0x9b, 0x28, 0x40, 0xd8, 0xdb, 0x28, 0x40, - 0xd7, 0x7b, 0x28, 0x80, 0x04, 0xd8, 0xbb, 0x28, 0x40, 0xd8, 0xfb, 0x28, - 0x40, 0xd4, 0x0f, 0x28, 0x80, 0x43, 0xd5, 0x17, 0x28, 0x80, 0x1f, 0xd6, - 0x27, 0x28, 0x80, 0x0d, 0xd7, 0x47, 0x28, 0x80, 0x04, 0xd8, 0x87, 0x28, - 0x40, 0xd8, 0xc7, 0x28, 0x40, 0xd7, 0x67, 0x28, 0x80, 0x04, 0xd8, 0xa7, - 0x28, 0x40, 0xd8, 0xe7, 0x28, 0x40, 0xd6, 0x37, 0x28, 0x80, 0x0d, 0xd7, - 0x57, 0x28, 0x80, 0x04, 0xd8, 0x97, 0x28, 0x40, 0xd8, 0xd7, 0x28, 0x40, - 0xd7, 0x77, 0x28, 0x80, 0x04, 0xd8, 0xb7, 0x28, 0x40, 0xd8, 0xf7, 0x28, - 0x40, 0xd5, 0x1f, 0x28, 0x80, 0x1f, 0xd6, 0x2f, 0x28, 0x80, 0x0d, 0xd7, - 0x4f, 0x28, 0x80, 0x04, 0xd8, 0x8f, 0x28, 0x40, 0xd8, 0xcf, 0x28, 0x40, - 0xd7, 0x6f, 0x28, 0x80, 0x04, 0xd8, 0xaf, 0x28, 0x40, 0xd8, 0xef, 0x28, - 0x40, 0xd6, 0x3f, 0x28, 0x80, 0x0d, 0xd7, 0x5f, 0x28, 0x80, 0x04, 0xd8, - 0x9f, 0x28, 0x40, 0xd8, 0xdf, 0x28, 0x40, 0xd7, 0x7f, 0x28, 0x80, 0x04, - 0xd8, 0xbf, 0x28, 0x40, 0xd8, 0xff, 0x28, 0x40, 0xa4, 0x95, 0x05, 0x07, - 0xec, 0x05, 0xca, 0x02, 0x07, 0x1a, 0x3a, 0xb1, 0x01, 0x0c, 0x6d, 0x16, - 0x89, 0x01, 0x05, 0x5a, 0x03, 0x61, 0xb6, 0x01, 0xff, 0x45, 0xe6, 0x23, - 0x46, 0x10, 0x01, 0x0a, 0x56, 0x77, 0x01, 0xff, 0xa1, 0x45, 0x4e, 0x3a, - 0x76, 0x39, 0x10, 0x01, 0xe5, 0x42, 0x10, 0x01, 0xe9, 0x3a, 0x10, 0x81, - 0x32, 0xef, 0x44, 0x10, 0x81, 0x20, 0xf5, 0x3c, 0x10, 0x81, 0x17, 0x08, - 0x43, 0xc1, 0x01, 0xff, 0xec, 0x40, 0x10, 0x81, 0x09, 0xf2, 0x3e, 0x10, - 0xc1, 0x00, 0xf2, 0x3f, 0x10, 0x41, 0xec, 0x41, 0x10, 0x41, 0xf5, 0x3d, - 0x10, 0x41, 0x0f, 0x52, 0x6f, 0x01, 0xff, 0xe5, 0x73, 0x10, 0x01, 0xef, - 0x74, 0x10, 0x41, 0xe9, 0x3b, 0x10, 0x41, 0xe1, 0x38, 0x10, 0x01, 0xe9, - 0x43, 0x10, 0x01, 0xf5, 0x45, 0x10, 0x41, 0x48, 0x3c, 0x16, 0x01, 0x10, - 0x01, 0x4b, 0xd9, 0x23, 0x00, 0x10, 0x01, 0x4b, 0x07, 0x9e, 0x03, 0x10, - 0x01, 0x50, 0x8d, 0x65, 0x70, 0x10, 0x01, 0x4b, 0x8f, 0xa4, 0x04, 0x10, - 0x01, 0x47, 0xf1, 0x4b, 0x02, 0x10, 0x41, 0x4c, 0x9c, 0x8d, 0x4c, 0x10, - 0x01, 0x02, 0x3b, 0x01, 0x0f, 0xac, 0x01, 0xff, 0x43, 0xee, 0x07, 0x4b, - 0x10, 0x01, 0x44, 0xbb, 0x79, 0x4d, 0x10, 0x41, 0xf4, 0x49, 0x10, 0x01, - 0x48, 0xc1, 0x41, 0x4a, 0x10, 0x41, 0x45, 0x12, 0x0b, 0x59, 0x10, 0x81, - 0x88, 0x01, 0xa6, 0x69, 0x46, 0xa7, 0x61, 0x7f, 0x10, 0x01, 0x44, 0xea, - 0x2a, 0x5a, 0x10, 0x81, 0x56, 0x43, 0x0e, 0x0b, 0x52, 0x10, 0x81, 0x40, - 0xb3, 0x24, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x5b, 0x10, 0x01, 0xa8, - 0x0d, 0xb7, 0x01, 0xff, 0x44, 0xe7, 0x1d, 0x5c, 0x10, 0x01, 0xef, 0x53, - 0x10, 0x41, 0x44, 0x7b, 0x11, 0x5d, 0x10, 0x01, 0x43, 0x26, 0x01, 0x54, - 0x10, 0x41, 0x44, 0xe5, 0x1d, 0x58, 0x10, 0x81, 0x0d, 0x42, 0x1c, 0x26, - 0x57, 0x10, 0xc1, 0x00, 0x42, 0x7d, 0x11, 0x60, 0x10, 0x41, 0x42, 0x7d, - 0x11, 0x61, 0x10, 0x41, 0x80, 0x01, 0xff, 0x47, 0x71, 0x11, 0x64, 0x10, - 0x01, 0x48, 0x47, 0x5e, 0x65, 0x10, 0x41, 0x42, 0x7d, 0x11, 0x63, 0x10, - 0x41, 0xa9, 0x0f, 0xaf, 0x01, 0xff, 0x43, 0x7c, 0x11, 0x5e, 0x10, 0x01, - 0x42, 0x42, 0x00, 0x55, 0x10, 0x41, 0x43, 0x59, 0x4d, 0x5f, 0x10, 0x01, - 0x42, 0x32, 0x00, 0x56, 0x10, 0x41, 0xf9, 0x62, 0x10, 0x41, 0xe1, 0x05, - 0x10, 0x81, 0xb4, 0x02, 0xa2, 0xa7, 0x02, 0xa3, 0x9a, 0x02, 0xa4, 0x81, - 0x02, 0xe5, 0x0f, 0x10, 0x01, 0xa7, 0xf0, 0x01, 0x42, 0x22, 0x00, 0x33, - 0x10, 0x01, 0xe9, 0x07, 0x10, 0x81, 0xe0, 0x01, 0xaa, 0xd3, 0x01, 0xab, - 0xc6, 0x01, 0xac, 0xb9, 0x01, 0x42, 0x6c, 0x00, 0x2b, 0x10, 0x01, 0xae, - 0x9a, 0x01, 0xef, 0x11, 0x10, 0x81, 0x69, 0xb0, 0x5d, 0x42, 0x71, 0x00, - 0x2d, 0x10, 0x01, 0xb3, 0x45, 0xb4, 0x2c, 0xf5, 0x09, 0x10, 0x81, 0x23, - 0xb6, 0x06, 0x42, 0xbe, 0x22, 0x2c, 0x10, 0x41, 0xe1, 0x2f, 0x10, 0x01, - 0x07, 0x44, 0xc1, 0x01, 0xff, 0xec, 0x0d, 0x10, 0x81, 0x09, 0xf2, 0x0b, - 0x10, 0xc1, 0x00, 0xf2, 0x0c, 0x10, 0x41, 0xec, 0x0e, 0x10, 0x41, 0xf5, - 0x0a, 0x10, 0x41, 0xe1, 0x22, 0x10, 0x01, 0x42, 0x22, 0x00, 0x23, 0x10, - 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x1d, 0x10, 0x01, 0x42, 0x22, 0x00, 0x1e, - 0x10, 0x41, 0xe1, 0x32, 0x10, 0x01, 0x42, 0x22, 0x00, 0x30, 0x10, 0x01, - 0x42, 0x40, 0x06, 0x31, 0x10, 0x41, 0xe1, 0x27, 0x10, 0x01, 0x42, 0x22, - 0x00, 0x28, 0x10, 0x41, 0x09, 0x8e, 0x65, 0x01, 0xff, 0x02, 0x60, 0x07, - 0x19, 0x44, 0xa9, 0xf1, 0x37, 0x10, 0x01, 0x43, 0x93, 0x41, 0x36, 0x10, - 0x01, 0x06, 0x33, 0x07, 0x01, 0xff, 0xe5, 0x71, 0x10, 0x01, 0xef, 0x72, - 0x10, 0x41, 0xe1, 0x75, 0x10, 0x01, 0x42, 0x74, 0x00, 0x35, 0x10, 0x41, - 0xe1, 0x26, 0x10, 0x01, 0x42, 0x24, 0x02, 0x17, 0x10, 0x01, 0x42, 0x2a, - 0x05, 0x21, 0x10, 0x01, 0x42, 0xbe, 0x22, 0x1c, 0x10, 0x41, 0xe1, 0x2e, - 0x10, 0x01, 0x42, 0x74, 0x00, 0x34, 0x10, 0x41, 0xe1, 0x13, 0x10, 0x01, - 0x42, 0x22, 0x00, 0x14, 0x10, 0x41, 0xe1, 0x1a, 0x10, 0x01, 0x42, 0x22, - 0x00, 0x1b, 0x10, 0x41, 0xe9, 0x08, 0x10, 0x41, 0xe1, 0x15, 0x10, 0x01, - 0x42, 0x22, 0x00, 0x16, 0x10, 0x41, 0xe1, 0x24, 0x10, 0x01, 0xa4, 0x06, - 0x42, 0x22, 0x00, 0x25, 0x10, 0x41, 0xe1, 0x1f, 0x10, 0x01, 0x42, 0x22, - 0x00, 0x20, 0x10, 0x41, 0xe1, 0x18, 0x10, 0x01, 0x42, 0x22, 0x00, 0x19, - 0x10, 0x41, 0xe1, 0x29, 0x10, 0x01, 0x42, 0x22, 0x00, 0x2a, 0x10, 0x41, - 0xe1, 0x06, 0x10, 0x01, 0xe9, 0x10, 0x10, 0x01, 0xf5, 0x12, 0x10, 0x41, - 0x44, 0x75, 0x20, 0x47, 0x10, 0x01, 0x05, 0xf0, 0x06, 0x06, 0x4b, 0x2a, - 0xa1, 0x48, 0x10, 0x41, 0x45, 0x12, 0x0b, 0x6e, 0x10, 0x01, 0xa6, 0x2e, - 0x44, 0xea, 0x2a, 0x6f, 0x10, 0x01, 0x43, 0x0e, 0x0b, 0x67, 0x10, 0x01, - 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x66, 0x10, 0x41, 0x44, 0x25, - 0x01, 0x69, 0x10, 0x01, 0x42, 0x15, 0x02, 0x68, 0x10, 0x41, 0x44, 0xe5, - 0x1d, 0x6d, 0x10, 0x01, 0x42, 0x1c, 0x26, 0x6c, 0x10, 0x41, 0x43, 0xd2, - 0x05, 0x6b, 0x10, 0x01, 0x43, 0xf6, 0x06, 0x6a, 0x10, 0x41, 0x42, 0x17, - 0x00, 0x17, 0xf4, 0x01, 0x03, 0x05, 0x24, 0xf2, 0x10, 0xed, 0xff, 0xfe, - 0x80, 0xe8, 0x10, 0x42, 0xcd, 0x05, 0xb4, 0xf9, 0x01, 0xaf, 0xc3, 0x10, - 0x07, 0xe7, 0xd4, 0xe0, 0x0d, 0x02, 0xee, 0x05, 0xe6, 0x0b, 0x45, 0x06, - 0xec, 0x90, 0xf4, 0x81, 0xd8, 0x0b, 0xb7, 0xa1, 0x0b, 0xb8, 0x0b, 0xf9, - 0x66, 0xf4, 0xc1, 0x00, 0x48, 0x7e, 0x4b, 0xc9, 0xf6, 0x41, 0x0a, 0xea, - 0xa5, 0x06, 0x49, 0xa7, 0xba, 0x4a, 0xf9, 0x41, 0x02, 0x3b, 0x01, 0xf6, - 0x08, 0x06, 0x6d, 0x15, 0xc2, 0x07, 0xac, 0xae, 0x02, 0x06, 0xc8, 0x00, - 0xf1, 0x01, 0x03, 0x7d, 0x15, 0x5e, 0x09, 0x32, 0x00, 0x01, 0xff, 0x0b, - 0x47, 0x9b, 0x43, 0x0a, 0x6d, 0x15, 0x2d, 0x0a, 0x9d, 0x64, 0x17, 0x0b, - 0xcc, 0xa2, 0x01, 0xff, 0x51, 0xad, 0x5a, 0x6a, 0x25, 0x00, 0x4b, 0xac, - 0x9e, 0x61, 0x25, 0x00, 0x4c, 0xa4, 0x94, 0x5e, 0x25, 0x40, 0x50, 0x7e, - 0x3a, 0x3f, 0x25, 0x00, 0x4a, 0xca, 0xac, 0x25, 0x25, 0x00, 0x4b, 0x1c, - 0xa2, 0x1d, 0x25, 0x40, 0x50, 0x93, 0x3a, 0x42, 0x25, 0x00, 0x4a, 0xd4, - 0xac, 0x28, 0x25, 0x00, 0x4b, 0xa7, 0x64, 0x20, 0x25, 0x40, 0x51, 0xbe, - 0x5a, 0x6b, 0x25, 0x00, 0x4b, 0xb7, 0x9e, 0x62, 0x25, 0x00, 0x4c, 0xb0, - 0x94, 0x5f, 0x25, 0x40, 0x0b, 0x47, 0x9b, 0x79, 0x0a, 0x6d, 0x15, 0x48, - 0x0a, 0x9d, 0x64, 0x17, 0x0b, 0xcc, 0xa2, 0x01, 0xff, 0x51, 0xad, 0x5a, - 0x67, 0x25, 0x00, 0x4b, 0xac, 0x9e, 0x5b, 0x25, 0x00, 0x4c, 0xa4, 0x94, - 0x58, 0x25, 0x40, 0x55, 0x79, 0x3a, 0x48, 0x25, 0x00, 0x50, 0x7e, 0x3a, - 0x37, 0x25, 0x00, 0x05, 0xc3, 0x00, 0x11, 0x06, 0xc8, 0x00, 0x01, 0xff, - 0x4a, 0x68, 0x15, 0x22, 0x25, 0x00, 0x45, 0x6d, 0x15, 0x15, 0x25, 0x40, - 0x4a, 0x68, 0x15, 0x2a, 0x25, 0x00, 0x45, 0x6d, 0x15, 0x19, 0x25, 0x40, - 0x55, 0x8e, 0x3a, 0x40, 0x25, 0x00, 0x50, 0x93, 0x3a, 0x38, 0x25, 0x00, - 0x05, 0xc3, 0x00, 0x11, 0x06, 0xc8, 0x00, 0x01, 0xff, 0x4a, 0xd7, 0x16, - 0x1e, 0x25, 0x00, 0x45, 0xc3, 0x01, 0x16, 0x25, 0x40, 0x4a, 0xd7, 0x16, - 0x26, 0x25, 0x00, 0x45, 0xc3, 0x01, 0x1a, 0x25, 0x40, 0x51, 0xbe, 0x5a, - 0x68, 0x25, 0x00, 0x4b, 0xb7, 0x9e, 0x5c, 0x25, 0x00, 0x4c, 0xb0, 0x94, - 0x59, 0x25, 0x40, 0x5c, 0x6e, 0x17, 0x46, 0x25, 0x00, 0x0f, 0x73, 0x17, - 0x1c, 0x0f, 0xca, 0x6f, 0x06, 0x5c, 0x82, 0x19, 0x44, 0x25, 0x40, 0x4a, - 0x68, 0x15, 0x31, 0x25, 0x00, 0x48, 0xc4, 0x16, 0x39, 0x25, 0x00, 0x4e, - 0x8a, 0x7e, 0x49, 0x25, 0x40, 0x4a, 0xd7, 0x16, 0x2e, 0x25, 0x00, 0x48, - 0x7d, 0x15, 0x36, 0x25, 0x00, 0x4e, 0x98, 0x7e, 0x3e, 0x25, 0x40, 0x04, - 0xc4, 0x00, 0xd4, 0x04, 0x05, 0xc9, 0x00, 0x01, 0xff, 0x04, 0xaa, 0x17, - 0xa9, 0x04, 0x55, 0xbc, 0x39, 0x1e, 0xcc, 0x01, 0xa4, 0xc4, 0x01, 0x4a, - 0x0b, 0x00, 0x00, 0x25, 0x80, 0xa3, 0x01, 0x44, 0xc3, 0x00, 0x74, 0x25, - 0x80, 0x95, 0x01, 0x0f, 0x22, 0x72, 0x84, 0x01, 0x45, 0xc8, 0x00, 0x76, - 0x25, 0x00, 0xb4, 0x65, 0x42, 0x50, 0x02, 0x75, 0x25, 0x80, 0x3f, 0x48, - 0x32, 0x00, 0x02, 0x25, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x07, - 0x9b, 0x0d, 0x23, 0x4a, 0x0b, 0x00, 0x3c, 0x25, 0x00, 0x44, 0xc3, 0x00, - 0x24, 0x25, 0x00, 0x45, 0xc8, 0x00, 0x1c, 0x25, 0x00, 0x04, 0x1e, 0x00, - 0x01, 0xff, 0x44, 0xc3, 0x00, 0x18, 0xce, 0x01, 0x45, 0xc8, 0x00, 0x16, - 0xce, 0x41, 0x44, 0xc3, 0x00, 0x19, 0xce, 0x01, 0x45, 0xc8, 0x00, 0x17, - 0xce, 0x41, 0x05, 0x19, 0x00, 0x01, 0xff, 0xa8, 0x0c, 0x44, 0xc3, 0x00, - 0x18, 0x25, 0x00, 0x45, 0xc8, 0x00, 0x14, 0x25, 0x40, 0x49, 0x1f, 0xb8, - 0x7d, 0x25, 0x00, 0x49, 0x0c, 0x00, 0x34, 0x25, 0x40, 0x51, 0xef, 0x5c, - 0x1d, 0xcc, 0x01, 0x0b, 0x8f, 0x37, 0x01, 0xff, 0x4a, 0x0b, 0x00, 0x04, - 0x25, 0x00, 0x48, 0x32, 0x00, 0x06, 0x25, 0x40, 0x4a, 0x0b, 0x00, 0x08, - 0x25, 0x00, 0x48, 0x32, 0x00, 0x0a, 0x25, 0x40, 0x50, 0xfd, 0x5f, 0x7c, - 0x25, 0x40, 0x80, 0x01, 0xff, 0x04, 0x1a, 0x00, 0x06, 0x54, 0xc1, 0x38, - 0xaf, 0xfb, 0x41, 0x4b, 0xf8, 0x02, 0x1c, 0xcc, 0x01, 0x4b, 0x98, 0x02, - 0x1b, 0xcc, 0x41, 0x08, 0xff, 0x25, 0x31, 0xaf, 0x01, 0xff, 0x0a, 0xb0, - 0xb2, 0x1e, 0x42, 0xa7, 0x01, 0x77, 0x25, 0xc0, 0x00, 0x05, 0x19, 0x00, - 0x01, 0xff, 0x4a, 0x0b, 0x00, 0x2c, 0x25, 0x00, 0x44, 0xc3, 0x00, 0x10, - 0x25, 0x00, 0x45, 0xc8, 0x00, 0x0c, 0x25, 0x40, 0x4a, 0x0b, 0x00, 0x4c, - 0x25, 0x00, 0x48, 0x32, 0x00, 0x4e, 0x25, 0x40, 0x45, 0x95, 0x10, 0x73, - 0x25, 0x00, 0x47, 0x9c, 0x44, 0xae, 0xfb, 0x01, 0x0e, 0x96, 0x03, 0x8a, - 0x02, 0x07, 0x7d, 0x02, 0xc2, 0x01, 0x06, 0x6d, 0x02, 0x01, 0xff, 0x0a, - 0x73, 0x02, 0x6a, 0x08, 0x84, 0x02, 0x2d, 0x09, 0x5f, 0x0f, 0x01, 0xff, - 0x06, 0x13, 0x01, 0x18, 0x07, 0x7d, 0x02, 0x01, 0xff, 0x55, 0xab, 0x03, - 0xd9, 0xfb, 0x01, 0x44, 0xc3, 0x00, 0xd1, 0xfb, 0xc1, 0x00, 0x4f, 0xb1, - 0x03, 0xdd, 0xfb, 0x41, 0x46, 0x73, 0x02, 0xd6, 0xfb, 0x01, 0x44, 0xc3, - 0x00, 0x71, 0x25, 0x40, 0x06, 0x13, 0x01, 0x22, 0x07, 0x7d, 0x02, 0x01, - 0xff, 0x0a, 0x73, 0x02, 0x0d, 0x45, 0xc8, 0x00, 0xd2, 0xfb, 0xc1, 0x00, - 0x4e, 0xbb, 0x4c, 0xdf, 0xfb, 0x41, 0x4a, 0x96, 0x03, 0xdb, 0xfb, 0x01, - 0x4b, 0x98, 0x02, 0xd8, 0xfb, 0x41, 0x46, 0x73, 0x02, 0xd4, 0xfb, 0x81, - 0x06, 0x45, 0xc8, 0x00, 0x72, 0x25, 0x40, 0x4f, 0xaf, 0x18, 0xdc, 0xfb, - 0x41, 0x06, 0x13, 0x01, 0x3f, 0x07, 0x7d, 0x02, 0x01, 0xff, 0x44, 0xc3, - 0x00, 0xa0, 0xfb, 0x81, 0x1d, 0x45, 0xc8, 0x00, 0xa1, 0xfb, 0xc1, 0x00, - 0x80, 0x01, 0xff, 0x5f, 0xf1, 0x10, 0xa9, 0xfb, 0x01, 0x4f, 0x89, 0x02, - 0xa5, 0xfb, 0xc1, 0x00, 0x4f, 0x79, 0x02, 0xaa, 0xfb, 0x41, 0x80, 0x01, - 0xff, 0x60, 0x54, 0x0f, 0xa8, 0xfb, 0x01, 0x4f, 0x89, 0x02, 0xa4, 0xfb, - 0xc1, 0x00, 0x50, 0xaa, 0x19, 0xab, 0xfb, 0x41, 0x44, 0xc3, 0x00, 0xd7, - 0xfb, 0x01, 0x45, 0xc8, 0x00, 0xd5, 0xfb, 0x41, 0x08, 0x84, 0x02, 0x1b, - 0x09, 0x5f, 0x0f, 0x01, 0xff, 0x06, 0x13, 0x01, 0x06, 0x6b, 0x6d, 0x02, - 0xad, 0xfb, 0x41, 0x46, 0x73, 0x02, 0xa3, 0xfb, 0x01, 0x44, 0xc3, 0x00, - 0xd0, 0xfb, 0x41, 0x06, 0x13, 0x01, 0x0d, 0x5c, 0x9e, 0x19, 0xa7, 0xfb, - 0xc1, 0x00, 0x50, 0x88, 0x02, 0xac, 0xfb, 0x41, 0x46, 0x73, 0x02, 0xa2, - 0xfb, 0x81, 0x06, 0x45, 0xc8, 0x00, 0xd3, 0xfb, 0x41, 0x50, 0xaa, 0x19, - 0xa6, 0xfb, 0x41, 0x5c, 0xa4, 0x03, 0xda, 0xfb, 0x01, 0x5b, 0xf3, 0x1d, - 0xde, 0xfb, 0x41, 0x09, 0x13, 0x49, 0x11, 0x07, 0xba, 0x5e, 0x01, 0xff, - 0x44, 0xc3, 0x00, 0x6f, 0x25, 0x00, 0x45, 0xc8, 0x00, 0x70, 0x25, 0x40, - 0x44, 0xc3, 0x00, 0x6e, 0x25, 0x00, 0x45, 0xc8, 0x00, 0x6d, 0x25, 0x40, - 0x5d, 0x68, 0x15, 0x45, 0x25, 0x00, 0x10, 0x6d, 0x15, 0x1c, 0x10, 0x9d, - 0x64, 0x06, 0x5d, 0xc4, 0x16, 0x43, 0x25, 0x40, 0x4a, 0x68, 0x15, 0x32, - 0x25, 0x00, 0x48, 0xc4, 0x16, 0x3a, 0x25, 0x00, 0x4e, 0x8a, 0x7e, 0x4a, - 0x25, 0x40, 0x4a, 0xd7, 0x16, 0x2d, 0x25, 0x00, 0x48, 0x7d, 0x15, 0x35, - 0x25, 0x00, 0x4e, 0x98, 0x7e, 0x3d, 0x25, 0x40, 0x02, 0x3b, 0x01, 0x7d, - 0x4a, 0x0b, 0x00, 0x01, 0x25, 0x00, 0x44, 0xc3, 0x00, 0x78, 0x25, 0x80, - 0x6a, 0x0f, 0x22, 0x72, 0x5a, 0x45, 0xc8, 0x00, 0x7a, 0x25, 0x00, 0x0c, - 0x8e, 0x37, 0x44, 0x42, 0x50, 0x02, 0x79, 0x25, 0x80, 0x1e, 0x48, 0x32, - 0x00, 0x03, 0x25, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x4a, 0x0b, - 0x00, 0x4b, 0x25, 0x00, 0x44, 0xc3, 0x00, 0x2b, 0x25, 0x00, 0x45, 0xc8, - 0x00, 0x23, 0x25, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x4a, 0x0b, 0x00, - 0x3b, 0x25, 0x00, 0xac, 0x06, 0x45, 0xc8, 0x00, 0x17, 0x25, 0x40, 0x43, - 0xc4, 0x00, 0x1b, 0x25, 0x00, 0x49, 0xd2, 0x16, 0x7f, 0x25, 0x40, 0x4a, - 0x0b, 0x00, 0x05, 0x25, 0x00, 0x48, 0x32, 0x00, 0x07, 0x25, 0x40, 0x4a, - 0x0b, 0x00, 0x09, 0x25, 0x00, 0x48, 0x32, 0x00, 0x0b, 0x25, 0x40, 0x50, - 0x0d, 0x60, 0x7e, 0x25, 0x40, 0x0a, 0xb0, 0xb2, 0x1e, 0x42, 0xa7, 0x01, - 0x7b, 0x25, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x4a, 0x0b, 0x00, - 0x33, 0x25, 0x00, 0x44, 0xc3, 0x00, 0x13, 0x25, 0x00, 0x45, 0xc8, 0x00, - 0x0f, 0x25, 0x40, 0x4a, 0x0b, 0x00, 0x4d, 0x25, 0x00, 0x48, 0x32, 0x00, - 0x4f, 0x25, 0x40, 0x05, 0x3d, 0x01, 0x92, 0x01, 0x03, 0xa0, 0x14, 0x01, - 0xff, 0x0b, 0x47, 0x9b, 0x77, 0x0a, 0x6d, 0x15, 0x47, 0x0a, 0x9d, 0x64, - 0x17, 0x0b, 0xcc, 0xa2, 0x01, 0xff, 0x51, 0xad, 0x5a, 0x64, 0x25, 0x00, - 0x4b, 0xac, 0x9e, 0x55, 0x25, 0x00, 0x4c, 0xa4, 0x94, 0x52, 0x25, 0x40, - 0x50, 0x7e, 0x3a, 0x2f, 0x25, 0x00, 0x05, 0xc3, 0x00, 0x16, 0x06, 0xc8, - 0x00, 0x06, 0x53, 0x1f, 0x4e, 0x47, 0x25, 0x40, 0x45, 0x6d, 0x15, 0x0d, - 0x25, 0x00, 0x48, 0xc4, 0x16, 0x21, 0x25, 0x40, 0x45, 0x6d, 0x15, 0x11, - 0x25, 0x00, 0x48, 0xc4, 0x16, 0x29, 0x25, 0x40, 0x50, 0x93, 0x3a, 0x30, - 0x25, 0x00, 0x05, 0xc3, 0x00, 0x16, 0x06, 0xc8, 0x00, 0x06, 0x53, 0x32, - 0x4e, 0x41, 0x25, 0x40, 0x45, 0xc3, 0x01, 0x0e, 0x25, 0x00, 0x48, 0x7d, - 0x15, 0x1f, 0x25, 0x40, 0x45, 0xc3, 0x01, 0x12, 0x25, 0x00, 0x48, 0x7d, - 0x15, 0x27, 0x25, 0x40, 0x51, 0xbe, 0x5a, 0x65, 0x25, 0x00, 0x4b, 0xb7, - 0x9e, 0x56, 0x25, 0x00, 0x4c, 0xb0, 0x94, 0x53, 0x25, 0x40, 0xa4, 0x3a, - 0x4a, 0x0b, 0x00, 0x50, 0x25, 0x00, 0x07, 0xba, 0x5e, 0x1e, 0x48, 0x32, - 0x00, 0x51, 0x25, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x4a, 0x0b, - 0x00, 0x6c, 0x25, 0x00, 0x44, 0xc3, 0x00, 0x63, 0x25, 0x00, 0x45, 0xc8, - 0x00, 0x60, 0x25, 0x40, 0x4a, 0x0b, 0x00, 0x69, 0x25, 0x00, 0x44, 0xc3, - 0x00, 0x5d, 0x25, 0x00, 0x45, 0xc8, 0x00, 0x5a, 0x25, 0x40, 0x08, 0xff, - 0x25, 0x17, 0x08, 0x14, 0x49, 0x01, 0xff, 0x4a, 0x0b, 0x00, 0x66, 0x25, - 0x00, 0x44, 0xc3, 0x00, 0x57, 0x25, 0x00, 0x45, 0xc8, 0x00, 0x54, 0x25, - 0x40, 0x6a, 0x96, 0x03, 0x09, 0xce, 0x01, 0x06, 0x6d, 0x02, 0x01, 0xff, - 0x08, 0x84, 0x02, 0x06, 0x53, 0xb6, 0x4c, 0x1f, 0xcc, 0x41, 0x4b, 0xf8, - 0x02, 0x20, 0xcc, 0x01, 0x5c, 0xa2, 0x18, 0x0a, 0xce, 0x41, 0x4a, 0xc2, - 0xa5, 0xf9, 0xf3, 0x01, 0xac, 0x18, 0x43, 0xf3, 0x25, 0xc8, 0x22, 0xc0, - 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4f, 0x7f, 0x6f, 0xd1, 0x29, 0x00, - 0x50, 0xbd, 0x66, 0xd2, 0x29, 0x40, 0x80, 0x06, 0x43, 0xa1, 0x01, 0xb3, - 0xf3, 0x41, 0x4a, 0xc8, 0xae, 0x4f, 0xf5, 0x01, 0x4a, 0xb4, 0xb3, 0x63, - 0xf9, 0x41, 0x4b, 0x95, 0x97, 0x95, 0xf3, 0x41, 0x54, 0x2b, 0x44, 0x7e, - 0xf3, 0x01, 0x03, 0xac, 0x05, 0x01, 0xff, 0x57, 0xdb, 0x1b, 0x3b, 0x29, - 0x00, 0x4d, 0x72, 0x0b, 0xdf, 0x23, 0x00, 0x05, 0x22, 0x00, 0x65, 0x15, - 0x9b, 0x3c, 0x55, 0x05, 0xc3, 0x00, 0x37, 0x4b, 0xda, 0x21, 0xdd, 0x23, - 0x00, 0x06, 0xc8, 0x00, 0x13, 0x4e, 0xe3, 0x26, 0xb5, 0x23, 0x80, 0x06, - 0x56, 0x54, 0x09, 0xe1, 0x23, 0x40, 0x58, 0xd9, 0x26, 0xb6, 0x23, 0x40, - 0xa3, 0x0c, 0x4c, 0x94, 0x8f, 0x25, 0x2e, 0x00, 0x69, 0x8e, 0x04, 0xee, - 0xfb, 0x41, 0x45, 0x1e, 0x0b, 0x1f, 0x23, 0x00, 0x43, 0x27, 0x0d, 0x0c, - 0x23, 0x40, 0xa3, 0x0c, 0x4c, 0x94, 0x8f, 0x24, 0x2e, 0x00, 0x6a, 0x18, - 0x03, 0xed, 0xfb, 0x41, 0x45, 0x1e, 0x0b, 0x1e, 0x23, 0x00, 0x43, 0x27, - 0x0d, 0x0d, 0x23, 0x40, 0x4c, 0x0c, 0x03, 0xea, 0xfb, 0x01, 0x4c, 0x32, - 0x11, 0xe2, 0xfb, 0x41, 0x4c, 0x0c, 0x03, 0xcb, 0x2b, 0x00, 0x10, 0x5d, - 0x63, 0x50, 0x48, 0xaf, 0x26, 0x21, 0x23, 0x00, 0x04, 0xc3, 0x00, 0x28, - 0x05, 0xc8, 0x00, 0x06, 0x4f, 0x6c, 0x73, 0xe7, 0xcd, 0x41, 0x4c, 0xd9, - 0x21, 0x5c, 0x2e, 0x00, 0x09, 0x64, 0x63, 0x01, 0xff, 0x44, 0x0c, 0x44, - 0x5f, 0xcc, 0x01, 0x0c, 0x9c, 0x96, 0x01, 0xff, 0xd1, 0xe9, 0xcd, 0x01, - 0xd2, 0xeb, 0xcd, 0x41, 0x4c, 0xd9, 0x21, 0x5b, 0x2e, 0x00, 0x09, 0x64, - 0x63, 0x01, 0xff, 0x44, 0x0c, 0x44, 0x5d, 0xcc, 0x01, 0x0c, 0x9c, 0x96, - 0x01, 0xff, 0xd1, 0xed, 0xcd, 0x01, 0xd2, 0xef, 0xcd, 0x41, 0x44, 0x0c, - 0x44, 0x5e, 0xcc, 0x01, 0x0c, 0x9c, 0x96, 0x01, 0xff, 0xd1, 0xf1, 0xcd, - 0x01, 0xd2, 0xf2, 0xcd, 0x01, 0xd3, 0xf3, 0xcd, 0x01, 0xd4, 0xf4, 0xcd, - 0x41, 0x0d, 0xf4, 0x82, 0xc5, 0x02, 0x07, 0xec, 0x05, 0x01, 0xff, 0xe1, - 0x1a, 0x31, 0x80, 0x8f, 0x02, 0xe2, 0x05, 0x31, 0x80, 0x85, 0x02, 0xe3, - 0x18, 0x31, 0x80, 0xfb, 0x01, 0xe4, 0x09, 0x31, 0x00, 0xe5, 0x1c, 0x31, - 0x80, 0xd4, 0x01, 0xe6, 0x08, 0x31, 0x00, 0xe7, 0x0d, 0x31, 0x80, 0xba, - 0x01, 0xe8, 0x0f, 0x31, 0x00, 0xe9, 0x27, 0x31, 0x80, 0x95, 0x01, 0xea, - 0x10, 0x31, 0x80, 0x8b, 0x01, 0xeb, 0x0e, 0x31, 0x80, 0x81, 0x01, 0xec, - 0x0c, 0x31, 0x80, 0x78, 0xed, 0x07, 0x31, 0x00, 0xee, 0x0b, 0x31, 0x80, - 0x62, 0xef, 0x1b, 0x31, 0x80, 0x3d, 0xf0, 0x06, 0x31, 0x00, 0xf1, 0x11, - 0x31, 0x00, 0xf2, 0x16, 0x31, 0x00, 0xf3, 0x19, 0x31, 0x80, 0x28, 0xf4, - 0x0a, 0x31, 0x00, 0xf5, 0x28, 0x31, 0x80, 0x19, 0xf6, 0x2a, 0x31, 0x00, - 0xf8, 0x12, 0x31, 0x00, 0xfa, 0x17, 0x31, 0xc0, 0x00, 0xe8, 0x13, 0x31, - 0x00, 0xe9, 0xa1, 0x31, 0x00, 0xf9, 0xba, 0x31, 0x40, 0x42, 0x4a, 0x24, - 0xab, 0x31, 0x40, 0xe8, 0x15, 0x31, 0x40, 0x4f, 0x90, 0x3b, 0x2e, 0x31, - 0x00, 0xe5, 0xbe, 0x31, 0x00, 0xed, 0xb1, 0x31, 0x00, 0xae, 0x08, 0xef, - 0xa6, 0x31, 0x00, 0xf5, 0x21, 0x31, 0x40, 0xe7, 0xb2, 0x31, 0x00, 0xee, - 0xa7, 0x31, 0x40, 0xe7, 0x2b, 0x31, 0x80, 0x04, 0xee, 0x2f, 0x31, 0x40, - 0xe7, 0xad, 0x31, 0x40, 0xe8, 0xb9, 0x31, 0x40, 0xf7, 0xbd, 0x31, 0x40, - 0xe9, 0xa2, 0x31, 0x40, 0xe8, 0x2d, 0x31, 0x00, 0xed, 0xac, 0x31, 0x00, - 0x42, 0x4a, 0x24, 0xaa, 0x31, 0x80, 0x08, 0xf2, 0xa8, 0x31, 0x00, 0xf5, - 0x29, 0x31, 0x40, 0xee, 0xb3, 0x31, 0x40, 0xe8, 0xb8, 0x31, 0x00, 0xee, - 0x2c, 0x31, 0x00, 0xf5, 0xa3, 0x31, 0x00, 0xf7, 0xbc, 0x31, 0x40, 0xe5, - 0xa4, 0x31, 0x00, 0xe8, 0x1d, 0x31, 0x00, 0xe9, 0x1f, 0x31, 0x00, 0xee, - 0x23, 0x31, 0x80, 0x04, 0xf2, 0x26, 0x31, 0x40, 0xe7, 0x25, 0x31, 0x00, - 0xee, 0xa5, 0x31, 0x40, 0xe8, 0x14, 0x31, 0x40, 0xf5, 0xa0, 0x31, 0x40, - 0xe8, 0xbf, 0x31, 0x00, 0xe9, 0x1e, 0x31, 0x80, 0x1c, 0xed, 0xb0, 0x31, - 0x00, 0xee, 0x22, 0x31, 0x80, 0x0b, 0xf5, 0x20, 0x31, 0xc0, 0x00, 0x42, - 0x4a, 0x24, 0xaf, 0x31, 0x40, 0xe7, 0x24, 0x31, 0x00, 0xee, 0xa9, 0x31, - 0x40, 0x42, 0x4a, 0x24, 0xae, 0x31, 0x40, 0xe7, 0xbb, 0x31, 0x00, 0xe8, - 0xb7, 0x31, 0x00, 0xeb, 0xb6, 0x31, 0x00, 0xf0, 0xb4, 0x31, 0x00, 0xf4, - 0xb5, 0x31, 0x40, 0xeb, 0x6e, 0xf5, 0x81, 0x06, 0x46, 0xfa, 0xd3, 0x83, - 0xfa, 0x41, 0x44, 0xb9, 0x00, 0x16, 0xf5, 0x81, 0x04, 0xf3, 0xda, 0xf4, - 0x41, 0x45, 0x01, 0xe2, 0xd1, 0xf4, 0x41, 0xe2, 0xa3, 0xf4, 0x41, 0x55, - 0xe2, 0x3a, 0xbd, 0xf7, 0x01, 0x54, 0x5f, 0x42, 0xb1, 0xf7, 0x01, 0x4b, - 0x22, 0x61, 0xa4, 0xf7, 0x01, 0xb3, 0x11, 0x06, 0xad, 0x02, 0x01, 0xff, - 0x46, 0x12, 0x03, 0x86, 0xf7, 0x01, 0x46, 0xd6, 0x05, 0x90, 0xf7, 0x41, - 0x46, 0x2f, 0x19, 0xab, 0xf7, 0x01, 0x52, 0x06, 0x53, 0xb7, 0xf7, 0x41, - 0xa1, 0xe8, 0x0a, 0xaf, 0x19, 0x02, 0xd6, 0x13, 0x01, 0xff, 0x80, 0x06, - 0x47, 0x92, 0xcf, 0xd0, 0xfa, 0x41, 0x44, 0x65, 0xef, 0xd8, 0xf4, 0x01, - 0x45, 0xae, 0x21, 0x99, 0xf4, 0x41, 0x03, 0x0f, 0x03, 0x0c, 0x44, 0xaa, - 0xcf, 0x3c, 0xf3, 0x01, 0x45, 0x6a, 0xec, 0x21, 0xf4, 0x41, 0x07, 0xc8, - 0xd3, 0x95, 0x02, 0x08, 0xe9, 0xca, 0x01, 0xff, 0xd1, 0x00, 0xfb, 0x81, - 0x87, 0x01, 0xd2, 0x01, 0xfb, 0x81, 0x43, 0xd3, 0x03, 0xfb, 0x81, 0x1f, - 0xd4, 0x07, 0xfb, 0x81, 0x0d, 0xd5, 0x0f, 0xfb, 0x81, 0x04, 0xd6, 0x1e, - 0xfb, 0x41, 0xd6, 0x2d, 0xfb, 0x41, 0xd5, 0x16, 0xfb, 0x81, 0x04, 0xd6, - 0x26, 0xfb, 0x41, 0xd6, 0x35, 0xfb, 0x41, 0xd4, 0x0b, 0xfb, 0x81, 0x0d, - 0xd5, 0x13, 0xfb, 0x81, 0x04, 0xd6, 0x22, 0xfb, 0x41, 0xd6, 0x31, 0xfb, - 0x41, 0xd5, 0x1a, 0xfb, 0x81, 0x04, 0xd6, 0x29, 0xfb, 0x41, 0xd6, 0x39, - 0xfb, 0x41, 0xd3, 0x05, 0xfb, 0x81, 0x1b, 0xd4, 0x09, 0xfb, 0x81, 0x0d, - 0xd5, 0x11, 0xfb, 0x81, 0x04, 0xd6, 0x20, 0xfb, 0x41, 0xd6, 0x2f, 0xfb, - 0x41, 0xd5, 0x18, 0xfb, 0xc1, 0x00, 0xd6, 0x37, 0xfb, 0x41, 0xd4, 0x0d, - 0xfb, 0x81, 0x0d, 0xd5, 0x14, 0xfb, 0x81, 0x04, 0xd6, 0x24, 0xfb, 0x41, - 0xd6, 0x33, 0xfb, 0x41, 0xd5, 0x1c, 0xfb, 0x81, 0x04, 0xd6, 0x2b, 0xfb, - 0x41, 0xd6, 0x3b, 0xfb, 0x41, 0xd2, 0x02, 0xfb, 0x81, 0x40, 0xd3, 0x04, - 0xfb, 0x81, 0x1f, 0xd4, 0x08, 0xfb, 0x81, 0x0d, 0xd5, 0x10, 0xfb, 0x81, - 0x04, 0xd6, 0x1f, 0xfb, 0x41, 0xd6, 0x2e, 0xfb, 0x41, 0xd5, 0x17, 0xfb, - 0x81, 0x04, 0xd6, 0x27, 0xfb, 0x41, 0xd6, 0x36, 0xfb, 0x41, 0xd4, 0x0c, - 0xfb, 0x81, 0x0a, 0x42, 0x21, 0xc3, 0x32, 0xfb, 0x01, 0xd6, 0x23, 0xfb, - 0x41, 0xd5, 0x1b, 0xfb, 0x81, 0x04, 0xd6, 0x2a, 0xfb, 0x41, 0xd6, 0x3a, - 0xfb, 0x41, 0xd3, 0x06, 0xfb, 0x81, 0x1f, 0xd4, 0x0a, 0xfb, 0x81, 0x0d, - 0xd5, 0x12, 0xfb, 0x81, 0x04, 0xd6, 0x21, 0xfb, 0x41, 0xd6, 0x30, 0xfb, - 0x41, 0xd5, 0x19, 0xfb, 0x81, 0x04, 0xd6, 0x28, 0xfb, 0x41, 0xd6, 0x38, - 0xfb, 0x41, 0xd4, 0x0e, 0xfb, 0x81, 0x0d, 0xd5, 0x15, 0xfb, 0x81, 0x04, - 0xd6, 0x25, 0xfb, 0x41, 0xd6, 0x34, 0xfb, 0x41, 0xd5, 0x1d, 0xfb, 0x01, - 0xd6, 0x2c, 0xfb, 0x41, 0x91, 0x86, 0x04, 0x92, 0xf7, 0x01, 0xd3, 0x00, - 0xcd, 0x81, 0x6f, 0xd4, 0x03, 0xcd, 0x81, 0x2a, 0xd5, 0x09, 0xcd, 0x81, - 0x0e, 0xd6, 0x18, 0xcd, 0xc1, 0x00, 0xd7, 0x51, 0xcd, 0xc1, 0x00, 0xd8, - 0xcb, 0xcd, 0x41, 0xd6, 0x27, 0xcd, 0x81, 0x0a, 0x42, 0x2b, 0xf5, 0xbb, - 0xcd, 0x01, 0xd8, 0x80, 0xcd, 0x41, 0xd7, 0x61, 0xcd, 0x01, 0xd8, 0x9c, - 0xcd, 0x41, 0xd5, 0x10, 0xcd, 0x81, 0x1c, 0x96, 0x0d, 0xd7, 0x3d, 0xcd, - 0x81, 0x04, 0xd8, 0x78, 0xcd, 0x41, 0xd8, 0xb3, 0xcd, 0x41, 0xd7, 0x59, - 0xcd, 0x81, 0x04, 0xd8, 0x96, 0xcd, 0x41, 0xd8, 0xd3, 0xcd, 0x41, 0xd6, - 0x2f, 0xcd, 0x81, 0x0d, 0xd7, 0x4b, 0xcd, 0x81, 0x04, 0xd8, 0x88, 0xcd, - 0x41, 0xd8, 0xc3, 0xcd, 0x41, 0xd7, 0x69, 0xcd, 0x81, 0x04, 0xd8, 0xa4, - 0xcd, 0x41, 0xd8, 0xe1, 0xcd, 0x41, 0xd4, 0x06, 0xcd, 0x81, 0x40, 0x95, - 0x1f, 0xd6, 0x1c, 0xcd, 0x81, 0x0d, 0xd7, 0x39, 0xcd, 0x81, 0x04, 0xd8, - 0x74, 0xcd, 0x41, 0xd8, 0xaf, 0xcd, 0x41, 0xd7, 0x55, 0xcd, 0x81, 0x04, - 0xd8, 0x93, 0xcd, 0x41, 0xd8, 0xcf, 0xcd, 0x41, 0xd6, 0x2b, 0xcd, 0x81, - 0x0d, 0xd7, 0x48, 0xcd, 0x81, 0x04, 0xd8, 0x84, 0xcd, 0x41, 0xd8, 0xbf, - 0xcd, 0x41, 0xd7, 0x65, 0xcd, 0x81, 0x04, 0xd8, 0xa0, 0xcd, 0x41, 0xd8, - 0xde, 0xcd, 0x41, 0xd5, 0x14, 0xcd, 0x81, 0x1f, 0xd6, 0x23, 0xcd, 0x81, - 0x0d, 0xd7, 0x41, 0xcd, 0x81, 0x04, 0xd8, 0x7c, 0xcd, 0x41, 0xd8, 0xb7, - 0xcd, 0x41, 0xd7, 0x5d, 0xcd, 0x81, 0x04, 0xd8, 0x99, 0xcd, 0x41, 0xd8, - 0xd7, 0xcd, 0x41, 0xd6, 0x33, 0xcd, 0x81, 0x0d, 0xd7, 0x4e, 0xcd, 0x81, - 0x04, 0xd8, 0x8c, 0xcd, 0x41, 0xd8, 0xc7, 0xcd, 0x41, 0xd7, 0x6d, 0xcd, - 0x01, 0xd8, 0xa8, 0xcd, 0x41, 0xd3, 0x01, 0xcd, 0x81, 0x7c, 0x94, 0x43, - 0xd5, 0x0b, 0xcd, 0x81, 0x1f, 0xd6, 0x1a, 0xcd, 0x81, 0x0d, 0xd7, 0x37, - 0xcd, 0x81, 0x04, 0xd8, 0x72, 0xcd, 0x41, 0xd8, 0xad, 0xcd, 0x41, 0xd7, - 0x53, 0xcd, 0x81, 0x04, 0xd8, 0x91, 0xcd, 0x41, 0xd8, 0xcd, 0xcd, 0x41, - 0xd6, 0x29, 0xcd, 0x81, 0x0d, 0xd7, 0x46, 0xcd, 0x81, 0x04, 0xd8, 0x82, - 0xcd, 0x41, 0xd8, 0xbd, 0xcd, 0x41, 0xd7, 0x63, 0xcd, 0x81, 0x04, 0xd8, - 0x9e, 0xcd, 0x41, 0xd8, 0xdc, 0xcd, 0x41, 0xd5, 0x12, 0xcd, 0x81, 0x1b, - 0xd6, 0x21, 0xcd, 0x81, 0x0d, 0xd7, 0x3f, 0xcd, 0x81, 0x04, 0xd8, 0x7a, - 0xcd, 0x41, 0xd8, 0xb5, 0xcd, 0x41, 0xd7, 0x5b, 0xcd, 0xc1, 0x00, 0xd8, - 0xd5, 0xcd, 0x41, 0xd6, 0x31, 0xcd, 0x81, 0x0a, 0x42, 0x2b, 0xf5, 0xc5, - 0xcd, 0x01, 0xd8, 0x8a, 0xcd, 0x41, 0xd7, 0x6b, 0xcd, 0x01, 0xd8, 0xa6, - 0xcd, 0x41, 0xd4, 0x08, 0xcd, 0x81, 0x43, 0xd5, 0x0e, 0xcd, 0x81, 0x1f, - 0xd6, 0x1e, 0xcd, 0x81, 0x0d, 0xd7, 0x3b, 0xcd, 0x81, 0x04, 0xd8, 0x76, - 0xcd, 0x41, 0xd8, 0xb1, 0xcd, 0x41, 0xd7, 0x57, 0xcd, 0x81, 0x04, 0xd8, - 0x94, 0xcd, 0x41, 0xd8, 0xd1, 0xcd, 0x41, 0xd6, 0x2d, 0xcd, 0x81, 0x0d, - 0xd7, 0x49, 0xcd, 0x81, 0x04, 0xd8, 0x86, 0xcd, 0x41, 0xd8, 0xc1, 0xcd, - 0x41, 0xd7, 0x67, 0xcd, 0x81, 0x04, 0xd8, 0xa2, 0xcd, 0x41, 0xd8, 0xdf, - 0xcd, 0x41, 0xd5, 0x16, 0xcd, 0x81, 0x1f, 0xd6, 0x25, 0xcd, 0x81, 0x0d, - 0xd7, 0x43, 0xcd, 0x81, 0x04, 0xd8, 0x7e, 0xcd, 0x41, 0xd8, 0xb9, 0xcd, - 0x41, 0xd7, 0x5f, 0xcd, 0x81, 0x04, 0xd8, 0x9b, 0xcd, 0x41, 0xd8, 0xd9, - 0xcd, 0x41, 0xd6, 0x35, 0xcd, 0x81, 0x0d, 0xd7, 0x50, 0xcd, 0x81, 0x04, - 0xd8, 0x8e, 0xcd, 0x41, 0xd8, 0xc9, 0xcd, 0x41, 0xd7, 0x6f, 0xcd, 0x81, - 0x04, 0xd8, 0xaa, 0xcd, 0x41, 0xd8, 0xe5, 0xcd, 0x41, 0x92, 0x8d, 0x02, - 0x93, 0x8b, 0x01, 0xd4, 0x04, 0xcd, 0x81, 0x43, 0xd5, 0x0a, 0xcd, 0x81, - 0x1f, 0xd6, 0x19, 0xcd, 0x81, 0x0d, 0xd7, 0x36, 0xcd, 0x81, 0x04, 0xd8, - 0x71, 0xcd, 0x41, 0xd8, 0xac, 0xcd, 0x41, 0xd7, 0x52, 0xcd, 0x81, 0x04, - 0xd8, 0x90, 0xcd, 0x41, 0xd8, 0xcc, 0xcd, 0x41, 0xd6, 0x28, 0xcd, 0x81, - 0x0d, 0xd7, 0x45, 0xcd, 0x81, 0x04, 0xd8, 0x81, 0xcd, 0x41, 0xd8, 0xbc, - 0xcd, 0x41, 0xd7, 0x62, 0xcd, 0x81, 0x04, 0xd8, 0x9d, 0xcd, 0x41, 0xd8, - 0xdb, 0xcd, 0x41, 0xd5, 0x11, 0xcd, 0x81, 0x1f, 0xd6, 0x20, 0xcd, 0x81, - 0x0d, 0xd7, 0x3e, 0xcd, 0x81, 0x04, 0xd8, 0x79, 0xcd, 0x41, 0xd8, 0xb4, - 0xcd, 0x41, 0xd7, 0x5a, 0xcd, 0x81, 0x04, 0xd8, 0x97, 0xcd, 0x41, 0xd8, - 0xd4, 0xcd, 0x41, 0xd6, 0x30, 0xcd, 0x81, 0x0d, 0xd7, 0x4c, 0xcd, 0x81, - 0x04, 0xd8, 0x89, 0xcd, 0x41, 0xd8, 0xc4, 0xcd, 0x41, 0xd7, 0x6a, 0xcd, - 0x81, 0x04, 0xd8, 0xa5, 0xcd, 0x41, 0xd8, 0xe2, 0xcd, 0x41, 0xd4, 0x07, - 0xcd, 0x81, 0x37, 0xd5, 0x0d, 0xcd, 0x81, 0x1b, 0xd6, 0x1d, 0xcd, 0x81, - 0x0d, 0xd7, 0x3a, 0xcd, 0x81, 0x04, 0xd8, 0x75, 0xcd, 0x41, 0xd8, 0xb0, - 0xcd, 0x41, 0xd7, 0x56, 0xcd, 0xc1, 0x00, 0xd8, 0xd0, 0xcd, 0x41, 0xd6, - 0x2c, 0xcd, 0x81, 0x0a, 0x42, 0x2b, 0xf5, 0xc0, 0xcd, 0x01, 0xd8, 0x85, - 0xcd, 0x41, 0xd7, 0x66, 0xcd, 0x01, 0xd8, 0xa1, 0xcd, 0x41, 0xd5, 0x15, - 0xcd, 0x81, 0x1f, 0xd6, 0x24, 0xcd, 0x81, 0x0d, 0xd7, 0x42, 0xcd, 0x81, - 0x04, 0xd8, 0x7d, 0xcd, 0x41, 0xd8, 0xb8, 0xcd, 0x41, 0xd7, 0x5e, 0xcd, - 0x81, 0x04, 0xd8, 0x9a, 0xcd, 0x41, 0xd8, 0xd8, 0xcd, 0x41, 0xd6, 0x34, - 0xcd, 0x81, 0x0d, 0xd7, 0x4f, 0xcd, 0x81, 0x04, 0xd8, 0x8d, 0xcd, 0x41, - 0xd8, 0xc8, 0xcd, 0x41, 0xd7, 0x6e, 0xcd, 0x81, 0x04, 0xd8, 0xa9, 0xcd, - 0x41, 0xd8, 0xe4, 0xcd, 0x41, 0xd3, 0x02, 0xcd, 0x81, 0x8b, 0x01, 0xd4, - 0x05, 0xcd, 0x81, 0x43, 0xd5, 0x0c, 0xcd, 0x81, 0x1f, 0xd6, 0x1b, 0xcd, - 0x81, 0x0d, 0xd7, 0x38, 0xcd, 0x81, 0x04, 0xd8, 0x73, 0xcd, 0x41, 0xd8, - 0xae, 0xcd, 0x41, 0xd7, 0x54, 0xcd, 0x81, 0x04, 0xd8, 0x92, 0xcd, 0x41, - 0xd8, 0xce, 0xcd, 0x41, 0xd6, 0x2a, 0xcd, 0x81, 0x0d, 0xd7, 0x47, 0xcd, - 0x81, 0x04, 0xd8, 0x83, 0xcd, 0x41, 0xd8, 0xbe, 0xcd, 0x41, 0xd7, 0x64, - 0xcd, 0x81, 0x04, 0xd8, 0x9f, 0xcd, 0x41, 0xd8, 0xdd, 0xcd, 0x41, 0xd5, - 0x13, 0xcd, 0x81, 0x1f, 0xd6, 0x22, 0xcd, 0x81, 0x0d, 0xd7, 0x40, 0xcd, - 0x81, 0x04, 0xd8, 0x7b, 0xcd, 0x41, 0xd8, 0xb6, 0xcd, 0x41, 0xd7, 0x5c, - 0xcd, 0x81, 0x04, 0xd8, 0x98, 0xcd, 0x41, 0xd8, 0xd6, 0xcd, 0x41, 0xd6, - 0x32, 0xcd, 0x81, 0x0d, 0xd7, 0x4d, 0xcd, 0x81, 0x04, 0xd8, 0x8b, 0xcd, - 0x41, 0xd8, 0xc6, 0xcd, 0x41, 0xd7, 0x6c, 0xcd, 0x81, 0x04, 0xd8, 0xa7, - 0xcd, 0x41, 0xd8, 0xe3, 0xcd, 0x41, 0x94, 0x43, 0xd5, 0x0f, 0xcd, 0x81, - 0x1f, 0xd6, 0x1f, 0xcd, 0x81, 0x0d, 0xd7, 0x3c, 0xcd, 0x81, 0x04, 0xd8, - 0x77, 0xcd, 0x41, 0xd8, 0xb2, 0xcd, 0x41, 0xd7, 0x58, 0xcd, 0x81, 0x04, - 0xd8, 0x95, 0xcd, 0x41, 0xd8, 0xd2, 0xcd, 0x41, 0xd6, 0x2e, 0xcd, 0x81, - 0x0d, 0xd7, 0x4a, 0xcd, 0x81, 0x04, 0xd8, 0x87, 0xcd, 0x41, 0xd8, 0xc2, - 0xcd, 0x41, 0xd7, 0x68, 0xcd, 0x81, 0x04, 0xd8, 0xa3, 0xcd, 0x41, 0xd8, - 0xe0, 0xcd, 0x41, 0xd5, 0x17, 0xcd, 0x81, 0x1b, 0xd6, 0x26, 0xcd, 0x81, - 0x0d, 0xd7, 0x44, 0xcd, 0x81, 0x04, 0xd8, 0x7f, 0xcd, 0x41, 0xd8, 0xba, - 0xcd, 0x41, 0xd7, 0x60, 0xcd, 0xc1, 0x00, 0xd8, 0xda, 0xcd, 0x41, 0x96, - 0x0a, 0x42, 0x2b, 0xf5, 0xca, 0xcd, 0x01, 0xd8, 0x8f, 0xcd, 0x41, 0xd7, - 0x70, 0xcd, 0x01, 0xd8, 0xab, 0xcd, 0x41, 0x02, 0x36, 0x01, 0x06, 0x49, - 0x9c, 0x99, 0x22, 0x24, 0x40, 0x80, 0x32, 0x8d, 0x01, 0xff, 0x0a, 0x28, - 0x1a, 0x19, 0x0f, 0x9d, 0x6f, 0x01, 0xff, 0xe3, 0x2d, 0x21, 0x00, 0xe8, - 0x0c, 0x21, 0x00, 0xe9, 0x11, 0x21, 0x00, 0xf2, 0x1c, 0x21, 0x00, 0xfa, - 0x28, 0x21, 0x40, 0x50, 0xa9, 0x23, 0xb6, 0x27, 0x00, 0x50, 0xb3, 0x02, - 0xb5, 0x27, 0x00, 0x50, 0x97, 0x40, 0xb4, 0x27, 0x40, 0x46, 0x60, 0xda, - 0xd3, 0x29, 0x00, 0xa3, 0xb4, 0x07, 0xa4, 0xc4, 0x06, 0xa6, 0xa4, 0x06, - 0xa8, 0xf7, 0x05, 0xac, 0xd4, 0x04, 0xad, 0xe5, 0x03, 0xae, 0xd6, 0x03, - 0x47, 0xc1, 0xd3, 0xc4, 0x2b, 0x00, 0xb0, 0xb1, 0x03, 0x56, 0x9c, 0x36, - 0x53, 0x27, 0x00, 0xb2, 0xaa, 0x02, 0xb3, 0x9f, 0x01, 0xb4, 0x6f, 0xb5, - 0x2c, 0x03, 0x32, 0x00, 0x01, 0xff, 0x06, 0x35, 0x00, 0x17, 0x08, 0x84, - 0x0a, 0x01, 0xff, 0x47, 0x9c, 0x44, 0x98, 0xf7, 0x01, 0x47, 0x68, 0x0a, - 0x9e, 0xf7, 0x01, 0x46, 0xd6, 0x05, 0x1d, 0x2b, 0x40, 0x47, 0xe6, 0x66, - 0x2e, 0x2b, 0x00, 0x49, 0x8a, 0x47, 0xae, 0x25, 0x40, 0x59, 0x30, 0x25, - 0x7b, 0x26, 0x00, 0xb0, 0x01, 0xff, 0x58, 0xf1, 0x26, 0xa2, 0xf5, 0x01, - 0x0a, 0x8c, 0x0b, 0x16, 0x04, 0x6f, 0x02, 0x06, 0x5b, 0xcf, 0x01, 0x9d, - 0x2b, 0x40, 0x4d, 0x68, 0x35, 0xe4, 0x25, 0x00, 0x4e, 0x83, 0x29, 0xe5, - 0x25, 0x40, 0x4f, 0x46, 0x6c, 0xeb, 0x23, 0x00, 0x58, 0x79, 0x29, 0x81, - 0xf7, 0x01, 0x4e, 0x26, 0x0c, 0xb4, 0x25, 0x00, 0x48, 0x01, 0x02, 0xb2, - 0x25, 0x40, 0x48, 0x32, 0x3d, 0x0e, 0x26, 0x00, 0x04, 0xb9, 0xf0, 0x12, - 0x52, 0x5c, 0x54, 0x7f, 0xf5, 0x01, 0x44, 0x31, 0x77, 0xdf, 0x26, 0x00, - 0x57, 0x22, 0x32, 0xd6, 0x26, 0x40, 0x47, 0x9c, 0x44, 0x97, 0xf7, 0x01, - 0x47, 0x68, 0x0a, 0x9d, 0xf7, 0x01, 0x46, 0xd6, 0x05, 0x8c, 0xf7, 0x41, - 0x4e, 0xbc, 0x75, 0x00, 0x27, 0x00, 0x47, 0x62, 0x3e, 0x02, 0x27, 0x00, - 0x4a, 0x8d, 0x5f, 0x17, 0x26, 0x00, 0x53, 0xc8, 0x4a, 0x71, 0xf5, 0x01, - 0x0e, 0x9e, 0x79, 0x60, 0xad, 0x34, 0x46, 0x92, 0xde, 0xc7, 0x26, 0x00, - 0x49, 0x07, 0xbe, 0x60, 0x26, 0x00, 0x45, 0xd7, 0x05, 0xa0, 0x25, 0x80, - 0x0c, 0x43, 0x32, 0x13, 0x05, 0x26, 0x00, 0x4c, 0x90, 0x96, 0x00, 0x26, - 0x40, 0x80, 0x01, 0xff, 0x46, 0x18, 0x8d, 0x32, 0xf5, 0x01, 0x47, 0xc2, - 0x68, 0xc0, 0x2b, 0x00, 0x48, 0x59, 0xc6, 0xf9, 0x23, 0x40, 0x04, 0x5f, - 0x07, 0x06, 0x4a, 0x7e, 0x95, 0x3b, 0x26, 0x40, 0x47, 0x9c, 0x44, 0x29, - 0x2b, 0x00, 0x47, 0x68, 0x0a, 0x2a, 0x2b, 0x00, 0xb3, 0x06, 0x53, 0x45, - 0x4e, 0xcd, 0xfb, 0x41, 0x45, 0xd7, 0x05, 0xaa, 0x25, 0x00, 0x43, 0x32, - 0x13, 0x51, 0x2b, 0x40, 0x46, 0x12, 0x03, 0x84, 0xf7, 0x01, 0x46, 0xd6, - 0x05, 0x8d, 0xf7, 0x41, 0x48, 0x8b, 0x47, 0xac, 0x25, 0x00, 0x04, 0xc9, - 0x00, 0x06, 0x46, 0x10, 0xdf, 0xf6, 0xf3, 0x41, 0x80, 0x56, 0x0a, 0x8c, - 0x0b, 0x1e, 0x06, 0xa9, 0x01, 0x01, 0xff, 0x45, 0xce, 0x00, 0xa1, 0x27, - 0x80, 0x0c, 0x46, 0xb4, 0x21, 0x4d, 0x20, 0x00, 0x55, 0xd5, 0x01, 0x9e, - 0x2b, 0x40, 0x44, 0xe6, 0x01, 0xa4, 0x27, 0x40, 0x4f, 0x46, 0x6c, 0xe9, - 0x23, 0x80, 0x27, 0x58, 0x79, 0x29, 0x82, 0xf7, 0x01, 0xb0, 0x13, 0x4e, - 0x26, 0x0c, 0xb8, 0x25, 0x00, 0x48, 0x01, 0x02, 0xb6, 0x25, 0xc0, 0x00, - 0x59, 0x3c, 0x23, 0xef, 0x23, 0x40, 0x47, 0x02, 0xca, 0x53, 0x2b, 0x00, - 0x46, 0xf1, 0x49, 0xba, 0x25, 0x40, 0x52, 0xb6, 0x1e, 0xed, 0x23, 0x40, - 0x09, 0x9c, 0x01, 0x06, 0x4e, 0x72, 0x7d, 0xb3, 0xce, 0x41, 0x4e, 0xfb, - 0x26, 0x9d, 0xf5, 0x01, 0x45, 0x8f, 0x13, 0x1b, 0x26, 0x40, 0x4c, 0x7c, - 0x8c, 0xb0, 0x25, 0x00, 0x02, 0x92, 0x01, 0x06, 0x46, 0x19, 0xd5, 0x88, - 0xf5, 0x41, 0x44, 0x47, 0x33, 0xf2, 0xf3, 0x01, 0x45, 0x04, 0xca, 0x1f, - 0x2b, 0x40, 0x4b, 0xad, 0x92, 0x6f, 0xcc, 0x01, 0x42, 0x32, 0x18, 0x12, - 0x27, 0x40, 0x06, 0x45, 0x04, 0x06, 0x4a, 0xfa, 0xae, 0xb8, 0x26, 0x40, - 0xa4, 0x4d, 0xac, 0x38, 0x57, 0x0e, 0x31, 0xf5, 0x23, 0x80, 0x2b, 0xb3, - 0x0d, 0x54, 0x83, 0x46, 0xf6, 0x23, 0xc0, 0x00, 0x48, 0xc1, 0x68, 0xc5, - 0x2b, 0x40, 0x05, 0x5e, 0x07, 0x06, 0x45, 0xd7, 0x05, 0xfc, 0x25, 0x40, - 0x47, 0x9c, 0x44, 0x99, 0xf7, 0x01, 0x47, 0x68, 0x0a, 0x9f, 0xf7, 0x01, - 0x46, 0xd6, 0x05, 0xfe, 0x25, 0x40, 0x48, 0xc1, 0x68, 0xc8, 0x2b, 0x40, - 0x55, 0x7f, 0x35, 0xf4, 0x23, 0x80, 0x06, 0x46, 0x69, 0x0a, 0x27, 0x2b, - 0x40, 0x48, 0xc1, 0x68, 0xc7, 0x2b, 0x40, 0x46, 0x9d, 0x44, 0x25, 0x2b, - 0x00, 0x55, 0xdd, 0x33, 0xf7, 0x23, 0xc0, 0x00, 0x48, 0xc1, 0x68, 0xc6, - 0x2b, 0x40, 0x05, 0x44, 0x1c, 0x70, 0x03, 0xc4, 0x00, 0x19, 0xaf, 0x01, - 0xff, 0x04, 0x15, 0x01, 0x06, 0x45, 0x4b, 0x0a, 0xeb, 0x29, 0x40, 0x4d, - 0x68, 0x35, 0xe3, 0x25, 0x00, 0x4e, 0x83, 0x29, 0xe2, 0x25, 0x40, 0x80, - 0x3a, 0x0a, 0x8c, 0x0b, 0x11, 0x06, 0xa9, 0x01, 0x01, 0xff, 0x46, 0xb4, - 0x21, 0x4c, 0x20, 0x00, 0x55, 0xd5, 0x01, 0x9c, 0x2b, 0x40, 0x4f, 0x46, - 0x6c, 0xea, 0x23, 0x80, 0x18, 0x58, 0x79, 0x29, 0x80, 0xf7, 0x01, 0x47, - 0xf0, 0x49, 0xc4, 0x25, 0x00, 0x4e, 0x26, 0x0c, 0xc2, 0x25, 0x00, 0x48, - 0x01, 0x02, 0xc0, 0x25, 0x40, 0x52, 0xb6, 0x1e, 0xee, 0x23, 0x40, 0x4a, - 0xa2, 0xac, 0xd8, 0x26, 0x00, 0x09, 0x9c, 0x01, 0x01, 0xff, 0x4e, 0xfb, - 0x26, 0x9c, 0xf5, 0x01, 0x45, 0x8f, 0x13, 0x1a, 0x26, 0x40, 0x46, 0x12, - 0x03, 0x24, 0x2b, 0x80, 0x06, 0x46, 0xd6, 0x05, 0x1b, 0x2b, 0x40, 0x07, - 0x70, 0xcd, 0x01, 0xff, 0xac, 0x0c, 0x55, 0x00, 0x3e, 0x6d, 0xcc, 0x01, - 0x55, 0xd2, 0x3e, 0x6c, 0xcc, 0x41, 0x53, 0x39, 0x49, 0x6b, 0xcc, 0x01, - 0x54, 0xf3, 0x44, 0x6e, 0xcc, 0x41, 0x55, 0x68, 0x39, 0xaa, 0xf5, 0x01, - 0xa5, 0x0f, 0xaf, 0x01, 0xff, 0x50, 0xdd, 0x66, 0x2c, 0x2b, 0x00, 0x47, - 0x1e, 0xd7, 0xd7, 0x29, 0x40, 0x43, 0x2c, 0x01, 0xa4, 0xf5, 0x81, 0x06, - 0x45, 0xa8, 0xd1, 0x22, 0x2b, 0x40, 0x45, 0xb9, 0x27, 0x65, 0x26, 0x40, - 0xac, 0x0f, 0xaf, 0x01, 0xff, 0x44, 0x37, 0x1e, 0xbf, 0xf5, 0x01, 0x4f, - 0x6b, 0x74, 0x26, 0x27, 0x40, 0x42, 0x23, 0x02, 0x91, 0x26, 0x00, 0x46, - 0xae, 0x0f, 0x3f, 0x27, 0x40, 0x46, 0x9d, 0x44, 0xc6, 0x25, 0x80, 0x45, - 0x03, 0xa6, 0x01, 0x19, 0xb2, 0x01, 0xff, 0x07, 0x5a, 0xca, 0x06, 0x45, - 0xb8, 0xe9, 0x22, 0xf3, 0x41, 0x44, 0xcd, 0x34, 0xc3, 0x26, 0x00, 0x43, - 0x5d, 0x18, 0xc2, 0x26, 0x40, 0x58, 0xf1, 0x26, 0xa3, 0xf5, 0x01, 0x0a, - 0x8c, 0x0b, 0x06, 0x5b, 0xcf, 0x01, 0x9f, 0x2b, 0x40, 0x4f, 0x46, 0x6c, - 0xec, 0x23, 0x00, 0x58, 0x79, 0x29, 0x83, 0xf7, 0x01, 0x4e, 0x26, 0x0c, - 0xbe, 0x25, 0x00, 0x48, 0x01, 0x02, 0xbc, 0x25, 0x40, 0x80, 0x01, 0xff, - 0x47, 0xc2, 0x68, 0xc1, 0x2b, 0x00, 0x4d, 0x27, 0x86, 0x56, 0x27, 0x00, - 0x48, 0x61, 0xc9, 0xde, 0x2b, 0x00, 0x44, 0xba, 0x27, 0x66, 0x26, 0x00, - 0x4f, 0xd4, 0x74, 0xea, 0x29, 0x40, 0x50, 0xcd, 0x62, 0x2c, 0x27, 0x00, - 0x05, 0x60, 0x88, 0x79, 0x45, 0x13, 0x03, 0xcf, 0x25, 0x80, 0x52, 0x48, - 0x31, 0xc8, 0x63, 0x26, 0x00, 0x4e, 0xea, 0x7b, 0xe8, 0x26, 0x00, 0x06, - 0x70, 0x41, 0x01, 0xff, 0x0e, 0xe0, 0x04, 0x31, 0x0e, 0x58, 0x79, 0x21, - 0x0f, 0xa9, 0x72, 0x11, 0x0c, 0xba, 0x19, 0x01, 0xff, 0x4f, 0x69, 0x1a, - 0xaa, 0x2b, 0x00, 0x50, 0xb3, 0x02, 0xab, 0x2b, 0x40, 0x4f, 0x34, 0x0c, - 0xaf, 0x2b, 0x00, 0x4d, 0xc3, 0x20, 0xad, 0x2b, 0x40, 0x4f, 0x34, 0x0c, - 0xae, 0x2b, 0x00, 0x4d, 0xc3, 0x20, 0xac, 0x2b, 0x40, 0x4f, 0x69, 0x1a, - 0xa8, 0x2b, 0x00, 0x50, 0xb3, 0x02, 0xa9, 0x2b, 0x40, 0x80, 0x01, 0xff, - 0x4a, 0x86, 0xaa, 0xfa, 0x23, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4a, - 0xd3, 0x41, 0xed, 0x29, 0x00, 0x4e, 0xc6, 0x7d, 0x89, 0x26, 0x00, 0x4f, - 0xc5, 0x74, 0x88, 0x26, 0x40, 0x45, 0x45, 0xe4, 0x57, 0xfa, 0x01, 0x46, - 0x4e, 0xda, 0x5d, 0x26, 0x80, 0xed, 0x01, 0x4a, 0x36, 0xaa, 0x49, 0xfa, - 0x81, 0xdf, 0x01, 0x44, 0xdd, 0xef, 0x56, 0xfa, 0x01, 0xab, 0x73, 0x44, - 0x21, 0xf2, 0x5f, 0x26, 0x80, 0x5b, 0x45, 0x73, 0xbe, 0x5b, 0x26, 0x80, - 0x43, 0x44, 0x81, 0xf2, 0x5c, 0x26, 0x80, 0x2b, 0x07, 0x27, 0x0a, 0x01, - 0xff, 0x46, 0x4e, 0xda, 0x27, 0xfa, 0x01, 0xab, 0x12, 0x44, 0x21, 0xf2, - 0x29, 0xfa, 0x01, 0x45, 0x73, 0xbe, 0x25, 0xfa, 0x01, 0x44, 0x81, 0xf2, - 0x26, 0xfa, 0x41, 0x43, 0xa1, 0x01, 0x24, 0xfa, 0x01, 0x45, 0x4e, 0x09, - 0x28, 0xfa, 0x41, 0x09, 0xbe, 0x2c, 0x01, 0xff, 0x4e, 0xc7, 0x2c, 0x11, - 0xfa, 0x01, 0x5b, 0xd8, 0x1d, 0x3b, 0xfa, 0x41, 0x09, 0xbe, 0x2c, 0x01, - 0xff, 0x4e, 0xc7, 0x2c, 0x10, 0xfa, 0x01, 0x5b, 0xd8, 0x1d, 0x3a, 0xfa, - 0x41, 0x09, 0xbe, 0x2c, 0x01, 0xff, 0x4e, 0xc7, 0x2c, 0x14, 0xfa, 0x01, - 0x5b, 0xd8, 0x1d, 0x3e, 0xfa, 0x41, 0x43, 0xa1, 0x01, 0x5a, 0x26, 0x80, - 0x4c, 0x45, 0x4e, 0x09, 0x5e, 0x26, 0xc0, 0x00, 0x09, 0xbe, 0x2c, 0x15, - 0x8d, 0x01, 0xff, 0x46, 0x4e, 0xda, 0x53, 0xfa, 0x01, 0x45, 0x73, 0xbe, - 0x51, 0xfa, 0x01, 0x44, 0x81, 0xf2, 0x52, 0xfa, 0x41, 0x52, 0xd4, 0x51, - 0x07, 0xfa, 0x01, 0x4e, 0xc7, 0x2c, 0x13, 0xfa, 0x01, 0x5f, 0x6d, 0x11, - 0x1c, 0xfa, 0x01, 0xb4, 0x01, 0xff, 0x5c, 0x16, 0x18, 0x46, 0xfa, 0x01, - 0x0b, 0xd9, 0x1d, 0x01, 0xff, 0x4f, 0xe4, 0x1d, 0x3d, 0xfa, 0x01, 0x53, - 0xf9, 0x4d, 0x31, 0xfa, 0x41, 0x09, 0xbe, 0x2c, 0x01, 0xff, 0x4e, 0xc7, - 0x2c, 0x0f, 0xfa, 0x01, 0x5b, 0xd8, 0x1d, 0x39, 0xfa, 0x41, 0x57, 0xbe, - 0x2c, 0x4c, 0xfa, 0x41, 0x09, 0xbe, 0x2c, 0x01, 0xff, 0x4e, 0xc7, 0x2c, - 0x12, 0xfa, 0x01, 0x5b, 0xd8, 0x1d, 0x3c, 0xfa, 0x41, 0x04, 0x3b, 0x25, - 0x4d, 0x02, 0xa3, 0x01, 0x3d, 0x44, 0xfd, 0xf0, 0x59, 0xf4, 0x01, 0x02, - 0x60, 0x07, 0x27, 0x4c, 0x18, 0x93, 0x23, 0x26, 0x00, 0xb2, 0x15, 0x43, - 0x3d, 0x1d, 0xac, 0xf9, 0x01, 0xb4, 0x01, 0xff, 0x49, 0x6b, 0xb7, 0xbf, - 0x20, 0x00, 0x47, 0x3c, 0x91, 0xe6, 0xfa, 0x41, 0xe4, 0x26, 0xf4, 0x01, - 0x4a, 0xfc, 0xb1, 0x82, 0xf3, 0x41, 0x46, 0x3e, 0xdb, 0xe2, 0xf9, 0x01, - 0x45, 0x5b, 0xe7, 0xb1, 0xf3, 0x41, 0x4f, 0x6d, 0x72, 0xf9, 0x29, 0x00, - 0x47, 0x6a, 0x31, 0xf8, 0x29, 0x40, 0xe5, 0xb2, 0xf6, 0x01, 0x43, 0x2d, - 0x24, 0xb4, 0xf6, 0x41, 0xa4, 0x92, 0x04, 0x0b, 0x5a, 0x9c, 0x85, 0x04, - 0x52, 0x88, 0x52, 0x6c, 0x1c, 0x01, 0x07, 0xec, 0x05, 0xee, 0x01, 0x07, - 0x1a, 0x3a, 0x6d, 0x05, 0x5a, 0x03, 0x44, 0x0b, 0x55, 0x77, 0x06, 0x4e, - 0xec, 0x7e, 0x43, 0x1c, 0x41, 0xa1, 0x2c, 0xe5, 0x38, 0x1c, 0x01, 0xe9, - 0x30, 0x1c, 0x81, 0x1f, 0xef, 0x3a, 0x1c, 0x01, 0xf5, 0x32, 0x1c, 0x81, - 0x12, 0x08, 0x43, 0xc1, 0x01, 0xff, 0xec, 0x36, 0x1c, 0x01, 0xf2, 0x34, - 0x1c, 0xc1, 0x00, 0xf2, 0x35, 0x1c, 0x41, 0xf5, 0x33, 0x1c, 0x41, 0xe9, - 0x31, 0x1c, 0x41, 0xe1, 0x2f, 0x1c, 0x01, 0xe9, 0x39, 0x1c, 0x01, 0xf5, - 0x3b, 0x1c, 0x41, 0xa1, 0x17, 0x4b, 0xd9, 0x23, 0x3c, 0x1c, 0x01, 0x02, - 0x02, 0x00, 0x01, 0xff, 0x44, 0xe7, 0x23, 0x3f, 0x1c, 0x01, 0x45, 0xf3, - 0x4b, 0x3e, 0x1c, 0x41, 0x47, 0x3d, 0x16, 0x3d, 0x1c, 0x01, 0x47, 0xc4, - 0x88, 0x40, 0x1c, 0x41, 0x45, 0x12, 0x0b, 0x61, 0x1c, 0x81, 0x72, 0xa6, - 0x53, 0x44, 0xea, 0x2a, 0x62, 0x1c, 0x81, 0x46, 0x43, 0x0e, 0x0b, 0x5a, - 0x1c, 0x01, 0xb3, 0x24, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x63, 0x1c, - 0x01, 0xa8, 0x0d, 0xb7, 0x01, 0xff, 0x44, 0xe7, 0x1d, 0x64, 0x1c, 0x01, - 0xef, 0x5b, 0x1c, 0x41, 0x44, 0x7b, 0x11, 0x65, 0x1c, 0x01, 0x43, 0x26, - 0x01, 0x5c, 0x1c, 0x41, 0x44, 0xe5, 0x1d, 0x60, 0x1c, 0x81, 0x0d, 0x42, - 0x1c, 0x26, 0x5f, 0x1c, 0xc1, 0x00, 0x42, 0x7d, 0x11, 0x68, 0x1c, 0x41, - 0x42, 0x7d, 0x11, 0x69, 0x1c, 0x41, 0x42, 0x7d, 0x11, 0x6b, 0x1c, 0x41, - 0xa9, 0x0f, 0xaf, 0x01, 0xff, 0x43, 0x7c, 0x11, 0x66, 0x1c, 0x01, 0x42, - 0x42, 0x00, 0x5d, 0x1c, 0x41, 0x43, 0x59, 0x4d, 0x67, 0x1c, 0x01, 0x42, - 0x32, 0x00, 0x5e, 0x1c, 0x41, 0xf9, 0x6a, 0x1c, 0x41, 0xe1, 0x00, 0x1c, - 0x81, 0xfa, 0x01, 0xa2, 0xed, 0x01, 0xa3, 0xe0, 0x01, 0xa4, 0xc7, 0x01, - 0xe5, 0x0a, 0x1c, 0x01, 0xa7, 0xb6, 0x01, 0x42, 0x22, 0x00, 0x2e, 0x1c, - 0x01, 0xe9, 0x02, 0x1c, 0x81, 0xa6, 0x01, 0xaa, 0x99, 0x01, 0xab, 0x8c, - 0x01, 0x42, 0x74, 0x00, 0x29, 0x1c, 0x01, 0x42, 0x6c, 0x00, 0x26, 0x1c, - 0x01, 0xae, 0x68, 0xef, 0x0c, 0x1c, 0x01, 0xb0, 0x58, 0x42, 0x71, 0x00, - 0x28, 0x1c, 0x01, 0xb3, 0x40, 0xb4, 0x27, 0xf5, 0x04, 0x1c, 0x81, 0x1e, - 0xb6, 0x06, 0x42, 0xbe, 0x22, 0x27, 0x1c, 0x41, 0xe1, 0x2a, 0x1c, 0x01, - 0x07, 0x44, 0xc1, 0x01, 0xff, 0xec, 0x08, 0x1c, 0x01, 0xf2, 0x06, 0x1c, - 0xc1, 0x00, 0xf2, 0x07, 0x1c, 0x41, 0xf5, 0x05, 0x1c, 0x41, 0xe1, 0x1d, - 0x1c, 0x01, 0x42, 0x22, 0x00, 0x1e, 0x1c, 0x01, 0xb4, 0x01, 0xff, 0xe1, - 0x18, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x19, 0x1c, 0x41, 0xe1, 0x2d, 0x1c, - 0x01, 0x42, 0x22, 0x00, 0x2b, 0x1c, 0x01, 0x42, 0x40, 0x06, 0x2c, 0x1c, - 0x41, 0xe1, 0x22, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x23, 0x1c, 0x41, 0xe1, - 0x21, 0x1c, 0x01, 0x42, 0x24, 0x02, 0x12, 0x1c, 0x01, 0x42, 0x2a, 0x05, - 0x1c, 0x1c, 0x01, 0x42, 0xbe, 0x22, 0x17, 0x1c, 0x41, 0xe1, 0x0e, 0x1c, - 0x01, 0x42, 0x22, 0x00, 0x0f, 0x1c, 0x41, 0xe1, 0x15, 0x1c, 0x01, 0x42, - 0x22, 0x00, 0x16, 0x1c, 0x41, 0xe9, 0x03, 0x1c, 0x41, 0xe1, 0x10, 0x1c, - 0x01, 0x42, 0x22, 0x00, 0x11, 0x1c, 0x41, 0xe1, 0x1f, 0x1c, 0x01, 0xa4, - 0x06, 0x42, 0x22, 0x00, 0x20, 0x1c, 0x41, 0xe1, 0x1a, 0x1c, 0x01, 0x42, - 0x22, 0x00, 0x1b, 0x1c, 0x41, 0xe1, 0x13, 0x1c, 0x01, 0x42, 0x22, 0x00, - 0x14, 0x1c, 0x41, 0xe1, 0x24, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x25, 0x1c, - 0x41, 0xe1, 0x01, 0x1c, 0x01, 0xe9, 0x0b, 0x1c, 0x01, 0xf5, 0x0d, 0x1c, - 0x41, 0xd1, 0x44, 0x1c, 0x01, 0xd2, 0x45, 0x1c, 0x41, 0x44, 0x75, 0x20, - 0x41, 0x1c, 0x01, 0x05, 0xf0, 0x06, 0x06, 0x4b, 0x2a, 0xa1, 0x42, 0x1c, - 0x41, 0x45, 0x12, 0x0b, 0x58, 0x1c, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, - 0x59, 0x1c, 0x01, 0x43, 0x0e, 0x0b, 0x51, 0x1c, 0x01, 0xb3, 0x14, 0xb4, - 0x06, 0x44, 0x5f, 0x1e, 0x50, 0x1c, 0x41, 0x44, 0x25, 0x01, 0x53, 0x1c, - 0x01, 0x42, 0x15, 0x02, 0x52, 0x1c, 0x41, 0x44, 0xe5, 0x1d, 0x57, 0x1c, - 0x01, 0x42, 0x1c, 0x26, 0x56, 0x1c, 0x41, 0x43, 0xd2, 0x05, 0x55, 0x1c, - 0x01, 0x43, 0xf6, 0x06, 0x54, 0x1c, 0x41, 0xa1, 0xb0, 0x08, 0x45, 0x21, - 0xe5, 0x35, 0x22, 0x00, 0xe4, 0xcf, 0xf6, 0x01, 0xa5, 0x97, 0x08, 0xec, - 0x07, 0x00, 0x80, 0xec, 0x07, 0xae, 0xde, 0x02, 0x09, 0xd6, 0xbe, 0x14, - 0xb4, 0x06, 0x4a, 0x64, 0xb3, 0xc3, 0xf9, 0x41, 0x47, 0x15, 0x08, 0x36, - 0x21, 0x00, 0x44, 0xc3, 0x09, 0x6c, 0x22, 0x40, 0x0f, 0xe4, 0x05, 0xa3, - 0x01, 0x0d, 0x76, 0x08, 0x01, 0xff, 0xa1, 0x91, 0x01, 0x47, 0x84, 0xcf, - 0xbc, 0x6e, 0x01, 0xa4, 0x7d, 0xa5, 0x6a, 0x45, 0x84, 0xe6, 0xbf, 0x6e, - 0x01, 0xa7, 0x56, 0x48, 0xd9, 0xc6, 0xc1, 0x6e, 0x01, 0xe9, 0xc2, 0x6e, - 0x01, 0x44, 0xf2, 0xe4, 0xc4, 0x6e, 0x01, 0x45, 0x32, 0xe8, 0xc5, 0x6e, - 0x01, 0x44, 0x95, 0x58, 0xc6, 0x6e, 0x01, 0xae, 0x2c, 0x42, 0x9d, 0x01, - 0xca, 0x6e, 0x01, 0x42, 0xe6, 0x05, 0xcb, 0x6e, 0x01, 0xb3, 0x12, 0x48, - 0x89, 0xcb, 0xd0, 0x6e, 0x01, 0x42, 0x3e, 0x00, 0xd1, 0x6e, 0x01, 0x45, - 0x5b, 0xec, 0xd2, 0x6e, 0x41, 0x43, 0x21, 0x08, 0xce, 0x6e, 0x01, 0x43, - 0x84, 0x36, 0xcf, 0x6e, 0x41, 0x43, 0x65, 0x9c, 0xc9, 0x6e, 0x01, 0x43, - 0x57, 0x07, 0xc7, 0x6e, 0x41, 0x42, 0x2a, 0x05, 0xc8, 0x6e, 0x01, 0x44, - 0x15, 0xf2, 0xc0, 0x6e, 0x41, 0xe8, 0xbe, 0x6e, 0x01, 0x44, 0x97, 0x7a, - 0xcc, 0x6e, 0xc1, 0x00, 0x47, 0xb6, 0xcd, 0xcd, 0x6e, 0x41, 0x45, 0x81, - 0xe4, 0xbd, 0x6e, 0x01, 0x43, 0x40, 0xd2, 0xc3, 0x6e, 0x41, 0x44, 0x75, - 0xf2, 0xbb, 0x6e, 0x01, 0xf9, 0xd3, 0x6e, 0x41, 0xa1, 0x91, 0x01, 0x47, - 0x84, 0xcf, 0xa1, 0x6e, 0x01, 0xa4, 0x7d, 0xa5, 0x6a, 0x45, 0x84, 0xe6, - 0xa4, 0x6e, 0x01, 0xa7, 0x56, 0x48, 0xd9, 0xc6, 0xa6, 0x6e, 0x01, 0xe9, - 0xa7, 0x6e, 0x01, 0x44, 0xf2, 0xe4, 0xa9, 0x6e, 0x01, 0x45, 0x32, 0xe8, - 0xaa, 0x6e, 0x01, 0x44, 0x95, 0x58, 0xab, 0x6e, 0x01, 0xae, 0x2c, 0x42, - 0x9d, 0x01, 0xaf, 0x6e, 0x01, 0x42, 0xe6, 0x05, 0xb0, 0x6e, 0x01, 0xb3, - 0x12, 0x48, 0x89, 0xcb, 0xb5, 0x6e, 0x01, 0x42, 0x3e, 0x00, 0xb6, 0x6e, - 0x01, 0x45, 0x5b, 0xec, 0xb7, 0x6e, 0x41, 0x43, 0x21, 0x08, 0xb3, 0x6e, - 0x01, 0x43, 0x84, 0x36, 0xb4, 0x6e, 0x41, 0x43, 0x65, 0x9c, 0xae, 0x6e, - 0x01, 0x43, 0x57, 0x07, 0xac, 0x6e, 0x41, 0x42, 0x2a, 0x05, 0xad, 0x6e, - 0x01, 0x44, 0x15, 0xf2, 0xa5, 0x6e, 0x41, 0xe8, 0xa3, 0x6e, 0x01, 0x44, - 0x97, 0x7a, 0xb1, 0x6e, 0xc1, 0x00, 0x47, 0xb6, 0xcd, 0xb2, 0x6e, 0x41, - 0x45, 0x81, 0xe4, 0xa2, 0x6e, 0x01, 0x43, 0x40, 0xd2, 0xa8, 0x6e, 0x41, - 0x44, 0x75, 0xf2, 0xa0, 0x6e, 0x01, 0xf9, 0xb8, 0x6e, 0x41, 0x05, 0x19, - 0xb6, 0x1b, 0xb4, 0x0d, 0x49, 0xee, 0xc1, 0x2c, 0x23, 0xc0, 0x00, 0x4c, - 0xf1, 0x22, 0xe3, 0x23, 0x40, 0x69, 0x95, 0x01, 0x5e, 0x2b, 0x00, 0x45, - 0x7c, 0xe9, 0x71, 0xf3, 0x41, 0xa1, 0xd7, 0x04, 0x09, 0x5b, 0x41, 0xa5, - 0x04, 0x06, 0xef, 0x06, 0xde, 0x03, 0x4a, 0xc2, 0xaa, 0xfb, 0x09, 0x00, - 0x46, 0x3c, 0xdd, 0xfa, 0x09, 0x00, 0x07, 0xec, 0x05, 0x8c, 0x01, 0x06, - 0x7a, 0x80, 0x7c, 0xb3, 0x44, 0x0b, 0x55, 0x77, 0x01, 0xff, 0xa1, 0x31, - 0xe5, 0xc7, 0x09, 0x00, 0xe9, 0xbf, 0x09, 0x80, 0x24, 0xef, 0xcb, 0x09, - 0x00, 0xf5, 0xc1, 0x09, 0x80, 0x17, 0x08, 0x43, 0xc1, 0x01, 0xff, 0xec, - 0xe2, 0x09, 0x80, 0x09, 0xf2, 0xc3, 0x09, 0xc0, 0x00, 0xf2, 0xc4, 0x09, - 0x40, 0xec, 0xe3, 0x09, 0x40, 0xf5, 0xc2, 0x09, 0x40, 0xe9, 0xc0, 0x09, - 0x40, 0xe1, 0xbe, 0x09, 0x00, 0xe9, 0xc8, 0x09, 0x00, 0xf5, 0xcc, 0x09, - 0x40, 0x4a, 0xde, 0xa7, 0xfe, 0x09, 0x00, 0x04, 0x5b, 0x03, 0x01, 0xff, - 0xa1, 0x1d, 0x4b, 0xd9, 0x23, 0x81, 0x09, 0x00, 0x45, 0x5a, 0x3f, 0xbc, - 0x09, 0x00, 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0xe7, 0x23, 0xcd, 0x09, - 0x00, 0x45, 0xf3, 0x4b, 0x83, 0x09, 0x40, 0x47, 0x3d, 0x16, 0x82, 0x09, - 0x00, 0x47, 0xc4, 0x88, 0xbd, 0x09, 0x40, 0x44, 0xb9, 0x00, 0xf2, 0x09, - 0x00, 0x44, 0x5a, 0x03, 0xf3, 0x09, 0x40, 0xe1, 0x85, 0x09, 0x80, 0xaf, - 0x02, 0xa2, 0xa2, 0x02, 0xa3, 0x95, 0x02, 0xa4, 0xfc, 0x01, 0xe5, 0x8f, - 0x09, 0x00, 0xa7, 0xeb, 0x01, 0x42, 0x22, 0x00, 0xb9, 0x09, 0x00, 0xe9, - 0x87, 0x09, 0x80, 0xdb, 0x01, 0xaa, 0xce, 0x01, 0xab, 0xba, 0x01, 0x42, - 0x74, 0x00, 0xb2, 0x09, 0x00, 0x42, 0x6c, 0x00, 0xae, 0x09, 0x00, 0xae, - 0x95, 0x01, 0xef, 0x93, 0x09, 0x00, 0xb0, 0x84, 0x01, 0xb2, 0x60, 0xb3, - 0x4e, 0xb4, 0x35, 0xf5, 0x89, 0x09, 0x80, 0x2c, 0xb6, 0x0d, 0xb9, 0x01, - 0xff, 0xe1, 0xaf, 0x09, 0x00, 0x42, 0xbe, 0x22, 0xdf, 0x09, 0x40, 0x4d, - 0x7f, 0x82, 0xfc, 0x09, 0x00, 0x07, 0x44, 0xc1, 0x01, 0xff, 0xec, 0x8c, - 0x09, 0x80, 0x09, 0xf2, 0x8b, 0x09, 0xc0, 0x00, 0xf2, 0xe0, 0x09, 0x40, - 0xec, 0xe1, 0x09, 0x40, 0xf5, 0x8a, 0x09, 0x40, 0xe1, 0xa4, 0x09, 0x00, - 0x42, 0x22, 0x00, 0xa5, 0x09, 0x00, 0xb4, 0x01, 0xff, 0xe1, 0x9f, 0x09, - 0x00, 0x42, 0x22, 0x00, 0xa0, 0x09, 0x40, 0xe1, 0xb8, 0x09, 0x00, 0x42, - 0x22, 0x00, 0xb6, 0x09, 0x00, 0x42, 0x40, 0x06, 0xb7, 0x09, 0x40, 0xe1, - 0xb0, 0x09, 0x80, 0x0c, 0x42, 0x22, 0x00, 0xdd, 0x09, 0x00, 0x42, 0x71, - 0x00, 0xdc, 0x09, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4e, 0xc8, 0x79, - 0xf1, 0x09, 0x00, 0x4f, 0x51, 0x70, 0xf0, 0x09, 0x40, 0xe1, 0xaa, 0x09, - 0x00, 0x42, 0x22, 0x00, 0xab, 0x09, 0x40, 0xe1, 0xa8, 0x09, 0x00, 0x42, - 0x24, 0x02, 0x99, 0x09, 0x00, 0x42, 0x2a, 0x05, 0xa3, 0x09, 0x00, 0x42, - 0xbe, 0x22, 0x9e, 0x09, 0x40, 0xe1, 0x95, 0x09, 0x00, 0x42, 0x22, 0x00, - 0x96, 0x09, 0xc0, 0x00, 0x46, 0x56, 0xde, 0xce, 0x09, 0x40, 0xe1, 0x9c, - 0x09, 0x00, 0x42, 0x22, 0x00, 0x9d, 0x09, 0x40, 0xe9, 0x88, 0x09, 0x40, - 0xe1, 0x97, 0x09, 0x00, 0x42, 0x22, 0x00, 0x98, 0x09, 0x40, 0xe1, 0xa6, - 0x09, 0x00, 0xa4, 0x06, 0x42, 0x22, 0x00, 0xa7, 0x09, 0x40, 0xe1, 0xa1, - 0x09, 0x00, 0x42, 0x22, 0x00, 0xa2, 0x09, 0x40, 0xe1, 0x9a, 0x09, 0x00, - 0x42, 0x22, 0x00, 0x9b, 0x09, 0x40, 0xe1, 0xac, 0x09, 0x00, 0x42, 0x22, - 0x00, 0xad, 0x09, 0x40, 0xe1, 0x86, 0x09, 0x00, 0xe9, 0x90, 0x09, 0x00, - 0xf5, 0x94, 0x09, 0x40, 0x45, 0x12, 0x0b, 0xee, 0x09, 0x00, 0xa6, 0x2e, - 0x44, 0xea, 0x2a, 0xef, 0x09, 0x00, 0x43, 0x0e, 0x0b, 0xe7, 0x09, 0x00, - 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0xe6, 0x09, 0x40, 0x44, 0x25, - 0x01, 0xe9, 0x09, 0x00, 0x42, 0x15, 0x02, 0xe8, 0x09, 0x40, 0x44, 0xe5, - 0x1d, 0xed, 0x09, 0x00, 0x42, 0x1c, 0x26, 0xec, 0x09, 0x40, 0x43, 0xd2, - 0x05, 0xeb, 0x09, 0x00, 0x43, 0xf6, 0x06, 0xea, 0x09, 0x40, 0x53, 0x00, - 0x49, 0xf9, 0x09, 0x00, 0x0a, 0xa9, 0x86, 0x01, 0xff, 0x44, 0xf5, 0x06, - 0xf7, 0x09, 0x00, 0x43, 0x0e, 0x0b, 0xf4, 0x09, 0x80, 0x0f, 0xb4, 0x01, - 0xff, 0x44, 0x25, 0x01, 0xf6, 0x09, 0x00, 0x42, 0x15, 0x02, 0xf5, 0x09, - 0x40, 0x5a, 0x94, 0x1e, 0xf8, 0x09, 0x40, 0x50, 0xe4, 0x57, 0xfd, 0x09, - 0x00, 0x43, 0x6f, 0x87, 0x80, 0x09, 0x00, 0x4d, 0x1f, 0x76, 0xd7, 0x09, - 0x40, 0xec, 0x14, 0xf5, 0xc1, 0x00, 0x80, 0x0c, 0x48, 0xe1, 0xc6, 0xce, - 0xf6, 0x01, 0x43, 0x50, 0x16, 0xce, 0xce, 0x41, 0x46, 0x3a, 0xdf, 0xd1, - 0xfa, 0x01, 0x46, 0x16, 0x08, 0x7e, 0x23, 0x00, 0x58, 0x19, 0x2c, 0x15, - 0xf5, 0x41, 0x45, 0xb1, 0xb6, 0x7a, 0xf3, 0x01, 0x43, 0xbd, 0x01, 0xb2, - 0xfa, 0x41, 0x50, 0x5d, 0x61, 0xd6, 0xf3, 0x01, 0x04, 0x88, 0x9f, 0x20, - 0x42, 0x5f, 0x01, 0xd8, 0xfa, 0x01, 0xb2, 0x0c, 0x4a, 0x1a, 0xb2, 0x93, - 0xf4, 0x01, 0x43, 0x32, 0x00, 0xab, 0xf9, 0x41, 0x45, 0x0b, 0x08, 0x3b, - 0xf4, 0x01, 0x4a, 0x5a, 0xa9, 0xd4, 0xf9, 0x41, 0x57, 0x8d, 0x2d, 0x9c, - 0xf3, 0x01, 0x58, 0x11, 0x28, 0x9d, 0xf3, 0x01, 0x4c, 0x80, 0x8e, 0x6b, - 0x26, 0x00, 0x4f, 0x21, 0x73, 0x6c, 0x26, 0x40, 0x42, 0x08, 0x00, 0x76, - 0xf4, 0x81, 0xa9, 0x30, 0xa3, 0xeb, 0x2f, 0xa4, 0xdc, 0x2f, 0xa7, 0xc7, - 0x2f, 0xac, 0xa9, 0x27, 0x04, 0x58, 0x92, 0xca, 0x05, 0xae, 0x99, 0x05, - 0xb2, 0x82, 0x05, 0xb3, 0x80, 0x03, 0xf4, 0x87, 0xf9, 0xc1, 0x00, 0x03, - 0xd4, 0x4c, 0x11, 0xe8, 0xc0, 0xf6, 0x81, 0x06, 0x44, 0x1a, 0xda, 0x0b, - 0xf5, 0x41, 0x43, 0x8b, 0xb5, 0xc1, 0xf6, 0x41, 0x0f, 0x58, 0x33, 0xd7, - 0x02, 0x07, 0xec, 0x05, 0x6b, 0x03, 0xba, 0x43, 0x5b, 0xb3, 0x33, 0x0b, - 0x55, 0x77, 0x01, 0xff, 0xe5, 0xe7, 0x1b, 0x80, 0x25, 0xe9, 0xea, 0x1b, - 0x00, 0x05, 0x6a, 0xd2, 0x15, 0xef, 0xec, 0x1b, 0x00, 0x48, 0xe1, 0xc9, - 0xe8, 0x1b, 0x00, 0xf5, 0xee, 0x1b, 0xc0, 0x00, 0x52, 0x4c, 0x4f, 0xef, - 0x1b, 0x40, 0xe9, 0xeb, 0x1b, 0x00, 0xef, 0xed, 0x1b, 0x40, 0xe5, 0xe9, - 0x1b, 0x40, 0x49, 0x56, 0xba, 0xe6, 0x1b, 0x00, 0x0c, 0x44, 0x97, 0x01, - 0xff, 0x45, 0xd3, 0xe7, 0xfe, 0x1b, 0x00, 0x48, 0x99, 0xc8, 0xfc, 0x1b, - 0x00, 0xb0, 0x01, 0xff, 0x47, 0x06, 0xcf, 0xff, 0x1b, 0x00, 0x49, 0x83, - 0xba, 0xfd, 0x1b, 0x40, 0x45, 0x08, 0xcf, 0xf2, 0x1b, 0x00, 0x47, 0x0e, - 0xd4, 0xf3, 0x1b, 0x40, 0xe1, 0xc0, 0x1b, 0x00, 0x42, 0x16, 0x00, 0xc5, - 0x1b, 0x00, 0x42, 0x37, 0x00, 0xe1, 0x1b, 0x00, 0x42, 0xf0, 0x10, 0xd1, - 0x1b, 0x00, 0x42, 0x24, 0x02, 0xce, 0x1b, 0x00, 0x42, 0x22, 0x00, 0xc2, - 0x1b, 0x00, 0xe9, 0xe4, 0x1b, 0x00, 0x42, 0x72, 0x19, 0xd0, 0x1b, 0x00, - 0x47, 0x6a, 0xd2, 0xc6, 0x1b, 0x00, 0x42, 0x74, 0x00, 0xde, 0x1b, 0x00, - 0xad, 0x8b, 0x01, 0xae, 0x6d, 0x42, 0xbb, 0x09, 0xc7, 0x1b, 0x80, 0x60, - 0x42, 0x71, 0x00, 0xd2, 0x1b, 0x00, 0xb3, 0x10, 0xf5, 0xe5, 0x1b, 0x00, - 0x42, 0xa9, 0x01, 0xcb, 0x1b, 0x00, 0x42, 0xbe, 0x22, 0xdb, 0x1b, 0x40, - 0xe1, 0xd8, 0x1b, 0x00, 0x0a, 0x52, 0x4f, 0x06, 0x4a, 0x7c, 0xaf, 0xd6, - 0x1b, 0x40, 0xe1, 0xc1, 0x1b, 0x00, 0x42, 0x24, 0x02, 0xcf, 0x1b, 0x00, - 0x42, 0x22, 0x00, 0xc3, 0x1b, 0x00, 0x42, 0x74, 0x00, 0xdf, 0x1b, 0x00, - 0x42, 0x6c, 0x00, 0xd5, 0x1b, 0x00, 0x42, 0xbb, 0x09, 0xc8, 0x1b, 0x00, - 0x42, 0x71, 0x00, 0xd3, 0x1b, 0x00, 0x42, 0x40, 0x06, 0xd9, 0x1b, 0x00, - 0x42, 0xa9, 0x01, 0xcc, 0x1b, 0x00, 0x42, 0xbe, 0x22, 0xdc, 0x1b, 0x40, - 0x47, 0xa2, 0xd2, 0xcd, 0x1b, 0x40, 0xe1, 0xc9, 0x1b, 0x00, 0x42, 0xf0, - 0x10, 0xe2, 0x1b, 0x00, 0x42, 0x24, 0x02, 0xdd, 0x1b, 0x00, 0x4a, 0x2c, - 0xaf, 0xd7, 0x1b, 0x00, 0x42, 0xbe, 0x22, 0xe0, 0x1b, 0x40, 0xe1, 0xd4, - 0x1b, 0x80, 0x06, 0x42, 0x16, 0x00, 0xe3, 0x1b, 0x40, 0x09, 0x57, 0xbc, - 0x01, 0xff, 0x42, 0x22, 0x00, 0xc4, 0x1b, 0x00, 0x42, 0x2a, 0x05, 0xca, - 0x1b, 0x00, 0x42, 0x40, 0x06, 0xda, 0x1b, 0x40, 0xe8, 0xf1, 0x1b, 0x00, - 0x42, 0x1d, 0x01, 0xf0, 0x1b, 0x40, 0x45, 0xdf, 0xe5, 0xbe, 0x26, 0x00, - 0x43, 0x67, 0x09, 0xfa, 0xf9, 0x81, 0xeb, 0x01, 0x07, 0xb2, 0xd5, 0x01, - 0xff, 0x0a, 0x48, 0x59, 0xbb, 0x01, 0x49, 0x81, 0x16, 0xf5, 0x6a, 0x01, - 0x07, 0xec, 0x05, 0x01, 0xff, 0xe1, 0xe7, 0x6a, 0x01, 0x42, 0x16, 0x00, - 0xe2, 0x6a, 0x01, 0x42, 0x73, 0x02, 0xdf, 0x6a, 0x01, 0xa4, 0x93, 0x01, - 0xe5, 0xec, 0x6a, 0x81, 0x83, 0x01, 0x42, 0x0c, 0x08, 0xd3, 0x6a, 0x01, - 0xa7, 0x6f, 0x44, 0x5e, 0xf0, 0xda, 0x6a, 0x01, 0xe9, 0xed, 0x6a, 0x01, - 0x42, 0x9d, 0x0a, 0xd9, 0x6a, 0x01, 0xab, 0x53, 0x43, 0xb6, 0x05, 0xd4, - 0x6a, 0x01, 0xef, 0xe8, 0x6a, 0x81, 0x44, 0x42, 0xbb, 0x09, 0xe5, 0x6a, - 0x01, 0x42, 0x46, 0x03, 0xd2, 0x6a, 0x01, 0x42, 0x1e, 0x00, 0xe1, 0x6a, - 0x01, 0xf5, 0xea, 0x6a, 0x81, 0x27, 0x42, 0x6e, 0x62, 0xe3, 0x6a, 0x01, - 0x42, 0xa9, 0x01, 0xdb, 0x6a, 0x81, 0x14, 0xb9, 0x06, 0x42, 0x0f, 0x00, - 0xdc, 0x6a, 0x41, 0x43, 0x2e, 0x11, 0xe4, 0x6a, 0x01, 0x42, 0xf4, 0x02, - 0xd5, 0x6a, 0x41, 0x43, 0x95, 0x36, 0xe6, 0x6a, 0x41, 0x42, 0x97, 0x31, - 0xe0, 0x6a, 0x41, 0xef, 0xe9, 0x6a, 0x41, 0xe1, 0xd1, 0x6a, 0x01, 0x43, - 0xe9, 0x42, 0xd8, 0x6a, 0x41, 0x42, 0x18, 0x0a, 0xd6, 0x6a, 0x01, 0x42, - 0x6a, 0x0d, 0xdd, 0x6a, 0x41, 0xe5, 0xeb, 0x6a, 0x01, 0x43, 0x4a, 0x24, - 0xd0, 0x6a, 0x41, 0x43, 0x65, 0xf0, 0xd7, 0x6a, 0x01, 0xef, 0xde, 0x6a, - 0x41, 0x04, 0x48, 0x0b, 0x16, 0x03, 0x13, 0x01, 0x06, 0x48, 0x47, 0xb5, - 0xf2, 0x6a, 0x41, 0x45, 0x55, 0x2d, 0xf1, 0x6a, 0x01, 0x49, 0x46, 0xb5, - 0xf3, 0x6a, 0x41, 0x45, 0x55, 0x2d, 0xf0, 0x6a, 0x01, 0x49, 0x3d, 0xb5, - 0xf4, 0x6a, 0x41, 0x4d, 0x20, 0x81, 0xc0, 0xf3, 0x41, 0x80, 0x06, 0x48, - 0x21, 0xc4, 0x88, 0xf4, 0x41, 0x45, 0xd4, 0xc4, 0xca, 0xf4, 0x01, 0x47, - 0xd6, 0xd3, 0xfc, 0xf9, 0x41, 0x43, 0x4b, 0x12, 0x4c, 0xf3, 0x01, 0x42, - 0x9d, 0x0a, 0x95, 0xfa, 0x01, 0xeb, 0xe6, 0xf3, 0xc1, 0x00, 0x0a, 0x8c, - 0xae, 0x01, 0xff, 0x4b, 0x31, 0x9b, 0xb5, 0xf4, 0x01, 0x49, 0xe5, 0xb8, - 0xb6, 0xf4, 0x01, 0x4a, 0xcc, 0xaf, 0xb7, 0xf4, 0x01, 0x48, 0x44, 0x7f, - 0xb4, 0xf4, 0x41, 0x02, 0x13, 0x05, 0xb6, 0x21, 0x49, 0x81, 0x16, 0xf3, - 0xa6, 0x00, 0x07, 0xec, 0x05, 0x12, 0x47, 0xb3, 0xd3, 0xf2, 0xa6, 0x00, - 0x4d, 0xc1, 0x34, 0xf7, 0xa6, 0x00, 0x49, 0x42, 0xbf, 0xf6, 0xa6, 0x40, - 0xe1, 0xa0, 0xa6, 0x00, 0x42, 0x27, 0x01, 0xa4, 0xa6, 0x00, 0xa6, 0xf7, - 0x20, 0xe9, 0xa9, 0xa6, 0x00, 0xab, 0xb7, 0x20, 0xac, 0x9c, 0x20, 0xed, - 0xb3, 0xa6, 0x80, 0xec, 0x1f, 0xae, 0x90, 0x1f, 0xef, 0xa7, 0xa6, 0x00, - 0xb0, 0x93, 0x01, 0xb2, 0x6b, 0xb3, 0x3d, 0xb4, 0x23, 0xf5, 0xa2, 0xa6, - 0x00, 0xb7, 0x13, 0xb9, 0x01, 0xff, 0xe1, 0xc2, 0xa6, 0x00, 0x42, 0x84, - 0x93, 0xbf, 0xa6, 0x00, 0x42, 0x2c, 0x9c, 0xc1, 0xa6, 0x40, 0xe1, 0xda, - 0xa6, 0x00, 0x42, 0xd6, 0x13, 0xc9, 0xa6, 0x40, 0xa1, 0x0e, 0xa5, 0x04, - 0xe9, 0xe4, 0xa6, 0x40, 0xee, 0xea, 0xa6, 0x00, 0xf4, 0xe8, 0xa6, 0x40, - 0xe1, 0xb0, 0xa6, 0x00, 0xe5, 0xa6, 0xa6, 0x40, 0x44, 0x9c, 0xcd, 0xec, - 0xa6, 0x00, 0x43, 0x1c, 0xec, 0xb9, 0xa6, 0x00, 0xa8, 0x0a, 0xe9, 0xb7, - 0xa6, 0x00, 0x42, 0x2e, 0x74, 0xb4, 0xa6, 0x40, 0x43, 0x1c, 0xec, 0xb8, - 0xa6, 0x00, 0x42, 0x6d, 0x28, 0xb6, 0xa6, 0x00, 0xef, 0xd6, 0xa6, 0x00, - 0xf5, 0xc0, 0xa6, 0x40, 0x42, 0x93, 0x0f, 0xd1, 0xa6, 0x00, 0xa5, 0x10, - 0xa9, 0x04, 0xf5, 0xcc, 0xa6, 0x40, 0x42, 0x27, 0x01, 0xad, 0xa6, 0x00, - 0xe9, 0xac, 0xa6, 0x40, 0xe5, 0xa5, 0xa6, 0x00, 0xee, 0xe1, 0xa6, 0x00, - 0x42, 0xdf, 0xe0, 0xd0, 0xa6, 0x40, 0xe1, 0xab, 0xa6, 0x00, 0xa5, 0xe5, - 0x1d, 0x05, 0x06, 0xe7, 0x11, 0xe9, 0xdd, 0xa6, 0x00, 0xb5, 0x01, 0xff, - 0x42, 0x93, 0x0f, 0xd7, 0xa6, 0x00, 0xe5, 0xc8, 0xa6, 0x40, 0x02, 0x5a, - 0x00, 0xdf, 0x18, 0x02, 0x26, 0x02, 0xb8, 0x15, 0x02, 0x53, 0x03, 0x94, - 0x10, 0x02, 0x06, 0x00, 0x96, 0x0a, 0x02, 0x60, 0x00, 0xc2, 0x02, 0x02, - 0x25, 0x00, 0x01, 0xff, 0x42, 0x27, 0x01, 0x06, 0x6a, 0x01, 0x43, 0x6a, - 0xf4, 0x2b, 0x6a, 0x01, 0xab, 0x8c, 0x02, 0xac, 0xfb, 0x01, 0xed, 0x11, - 0x6a, 0x81, 0xd9, 0x01, 0xae, 0x93, 0x01, 0xb0, 0x7f, 0xb2, 0x5d, 0xb3, - 0x35, 0xb4, 0x23, 0xf5, 0x04, 0x6a, 0x01, 0x44, 0x35, 0xf3, 0x38, 0x6a, - 0x01, 0xb7, 0x0d, 0xb9, 0x01, 0xff, 0xe1, 0x1d, 0x6a, 0x01, 0x42, 0x84, - 0x93, 0x1b, 0x6a, 0x41, 0xe1, 0x2c, 0x6a, 0x01, 0x42, 0xd6, 0x13, 0x21, - 0x6a, 0x41, 0xa1, 0x06, 0x42, 0xed, 0x05, 0x35, 0x6a, 0x41, 0xe1, 0x0e, - 0x6a, 0x01, 0xe5, 0x08, 0x6a, 0x41, 0x44, 0x9c, 0xcd, 0x37, 0x6a, 0x01, - 0x43, 0x1c, 0xec, 0x15, 0x6a, 0x01, 0xa8, 0x0a, 0xe9, 0x14, 0x6a, 0x01, - 0x42, 0x2e, 0x74, 0x12, 0x6a, 0x41, 0x42, 0x6d, 0x28, 0x13, 0x6a, 0x01, - 0xef, 0x29, 0x6a, 0x01, 0xf5, 0x1c, 0x6a, 0x41, 0xa5, 0x10, 0xa9, 0x04, - 0xf5, 0x23, 0x6a, 0x41, 0x42, 0x27, 0x01, 0x0c, 0x6a, 0x01, 0xe9, 0x0b, - 0x6a, 0x41, 0xe5, 0x07, 0x6a, 0x01, 0xee, 0x31, 0x6a, 0x01, 0x42, 0xdf, - 0xe0, 0x25, 0x6a, 0x41, 0xa5, 0x06, 0x43, 0xc0, 0x95, 0x2a, 0x6a, 0x41, - 0xe5, 0x22, 0x6a, 0x01, 0x42, 0xdf, 0xe0, 0x1f, 0x6a, 0x41, 0x43, 0xac, - 0x57, 0x0f, 0x6a, 0x01, 0xa7, 0x2f, 0xe9, 0x24, 0x6a, 0x01, 0xaa, 0x1d, - 0x43, 0xa4, 0x02, 0x1e, 0x6a, 0x01, 0x43, 0x26, 0x18, 0x20, 0x6a, 0x01, - 0xf5, 0x19, 0x6a, 0x81, 0x06, 0x42, 0x9a, 0x1a, 0x09, 0x6a, 0x41, 0x42, - 0x93, 0x0f, 0x18, 0x6a, 0x41, 0x43, 0x76, 0x87, 0x10, 0x6a, 0x01, 0x43, - 0xc0, 0x95, 0x1a, 0x6a, 0x41, 0x42, 0x24, 0x02, 0x28, 0x6a, 0x01, 0x45, - 0x14, 0xe8, 0x27, 0x6a, 0x41, 0xe1, 0x32, 0x6a, 0x01, 0xa2, 0x0a, 0x44, - 0xb8, 0xef, 0x0d, 0x6a, 0x01, 0xef, 0x33, 0x6a, 0x41, 0x42, 0x80, 0x12, - 0x34, 0x6a, 0x01, 0x42, 0x92, 0x01, 0x30, 0x6a, 0x41, 0xe1, 0x0a, 0x6a, - 0x01, 0xe9, 0x2d, 0x6a, 0x01, 0x42, 0x84, 0x93, 0x2e, 0x6a, 0x41, 0xe1, - 0x03, 0x6a, 0x01, 0xa5, 0x14, 0xef, 0x2f, 0x6a, 0x01, 0x42, 0xbb, 0x09, - 0x36, 0x6a, 0x01, 0xf5, 0x05, 0x6a, 0x01, 0x43, 0xee, 0xa9, 0x16, 0x6a, - 0x41, 0xee, 0x26, 0x6a, 0x01, 0xf4, 0x17, 0x6a, 0x41, 0xe1, 0xd5, 0x69, - 0x01, 0xa6, 0x95, 0x07, 0xa7, 0xde, 0x06, 0xe9, 0xd8, 0x69, 0x01, 0xab, - 0xa3, 0x06, 0xac, 0xf2, 0x05, 0xad, 0x94, 0x05, 0xae, 0x81, 0x03, 0xef, - 0xd7, 0x69, 0x01, 0xb0, 0x98, 0x02, 0xb2, 0xff, 0x01, 0xb3, 0xc9, 0x01, - 0xb4, 0x7a, 0xb6, 0x66, 0xb7, 0x53, 0xb9, 0x01, 0xff, 0x42, 0xe5, 0x05, - 0xac, 0x69, 0x01, 0x02, 0x97, 0x02, 0x33, 0xa9, 0x27, 0x03, 0x84, 0x93, - 0x17, 0xb5, 0x01, 0xff, 0x43, 0x22, 0x42, 0xe1, 0x69, 0x01, 0x42, 0x7b, - 0x00, 0xb2, 0x69, 0x01, 0xee, 0xe5, 0x69, 0x01, 0xf1, 0xe4, 0x69, 0x41, - 0x45, 0x1e, 0x08, 0xe3, 0x69, 0x01, 0x48, 0x61, 0xcb, 0xe2, 0x69, 0x41, - 0x42, 0x27, 0x01, 0x94, 0x69, 0x01, 0xf4, 0xae, 0x69, 0x41, 0x42, 0x93, - 0x0f, 0x97, 0x69, 0x81, 0x08, 0xed, 0xbe, 0x69, 0x01, 0xf8, 0xdf, 0x69, - 0x41, 0xf4, 0xcf, 0x69, 0x41, 0x43, 0x1c, 0xec, 0x9e, 0x69, 0x01, 0xb5, - 0x01, 0xff, 0xe5, 0xea, 0x69, 0x01, 0xef, 0x75, 0x69, 0x41, 0xa5, 0x06, - 0x42, 0x14, 0x05, 0x6a, 0x69, 0x41, 0xe5, 0xec, 0x69, 0x01, 0x43, 0xc0, - 0x95, 0x9d, 0x69, 0x41, 0xa1, 0x34, 0xa5, 0x23, 0xaf, 0x14, 0xb5, 0x01, - 0xff, 0x42, 0x93, 0x0f, 0x96, 0x69, 0x01, 0xed, 0xaa, 0x69, 0xc1, 0x00, - 0x42, 0x93, 0x0f, 0x99, 0x69, 0x41, 0xef, 0x79, 0x69, 0x81, 0x04, 0xf1, - 0xd6, 0x69, 0x41, 0xee, 0x67, 0x69, 0x41, 0xee, 0x00, 0x6a, 0x01, 0xf5, - 0xfd, 0x69, 0xc1, 0x00, 0x43, 0xc1, 0x95, 0x9c, 0x69, 0x41, 0xe1, 0xdb, - 0x69, 0x81, 0x0e, 0x48, 0xb9, 0xc5, 0x8f, 0x69, 0x01, 0xed, 0x72, 0x69, - 0x01, 0xf1, 0xdc, 0x69, 0x41, 0xf1, 0xa1, 0x69, 0x41, 0x42, 0x80, 0x12, - 0x85, 0x69, 0x01, 0xa5, 0x23, 0xa8, 0x0c, 0x42, 0x14, 0x05, 0x6d, 0x69, - 0x01, 0x44, 0x18, 0xc1, 0x9b, 0x69, 0x41, 0x45, 0xbf, 0x95, 0xa4, 0x69, - 0x01, 0x42, 0x87, 0x18, 0xde, 0x69, 0x01, 0xef, 0xf3, 0x69, 0xc1, 0x00, - 0xf1, 0xf4, 0x69, 0x41, 0xe5, 0x76, 0x69, 0x01, 0xf4, 0x90, 0x69, 0x41, - 0xa1, 0x0c, 0x43, 0x1c, 0xec, 0xef, 0x69, 0x01, 0x45, 0x88, 0xe7, 0x82, - 0x69, 0x41, 0xe5, 0xf0, 0x69, 0x01, 0xf1, 0x6e, 0x69, 0x41, 0xa1, 0x47, - 0xa5, 0x34, 0xe9, 0xf7, 0x69, 0x81, 0x22, 0xef, 0x98, 0x69, 0x81, 0x17, - 0xf5, 0xa0, 0x69, 0xc1, 0x00, 0xa1, 0x08, 0xe5, 0xe9, 0x69, 0x01, 0xed, - 0x91, 0x69, 0x41, 0xe5, 0x71, 0x69, 0x01, 0xf1, 0xca, 0x69, 0x41, 0x42, - 0x10, 0x00, 0xc2, 0x69, 0x41, 0xa5, 0x01, 0xff, 0x42, 0x7b, 0x00, 0xb1, - 0x69, 0x01, 0xf4, 0xcd, 0x69, 0x41, 0x42, 0xb5, 0x05, 0x84, 0x69, 0x01, - 0xb5, 0x01, 0xff, 0xf4, 0xbd, 0x69, 0x01, 0xf8, 0xe7, 0x69, 0x41, 0x02, - 0x9b, 0x01, 0x09, 0xe1, 0x6c, 0x69, 0xc1, 0x00, 0xed, 0x78, 0x69, 0x41, - 0x45, 0x2f, 0xe6, 0xd1, 0x69, 0x01, 0x45, 0x64, 0xe8, 0xda, 0x69, 0x41, - 0xe1, 0xf6, 0x69, 0x81, 0x86, 0x02, 0xa4, 0xdb, 0x01, 0xa7, 0x66, 0xaa, - 0x4a, 0x43, 0xb6, 0xca, 0xa8, 0x69, 0x01, 0x02, 0xa4, 0x02, 0x2d, 0xb4, - 0x1f, 0x03, 0x39, 0x7a, 0x0f, 0xba, 0x01, 0xff, 0x42, 0x9b, 0x36, 0xa7, - 0x69, 0x01, 0x42, 0x2c, 0x9c, 0xc1, 0x69, 0x41, 0x47, 0xc0, 0x09, 0xc0, - 0x69, 0x01, 0x47, 0x10, 0xd0, 0xad, 0x69, 0x41, 0x42, 0xe5, 0x05, 0xce, - 0x69, 0x01, 0x42, 0x48, 0x04, 0xbc, 0x69, 0x41, 0x43, 0x73, 0x8e, 0x7c, - 0x69, 0x01, 0xb5, 0x01, 0xff, 0xe5, 0x81, 0x69, 0x01, 0x42, 0x1f, 0x00, - 0x6f, 0x69, 0x41, 0x45, 0xb5, 0xd3, 0x8a, 0x69, 0x01, 0xa5, 0x01, 0xff, - 0xe5, 0xd4, 0x69, 0x81, 0x06, 0x42, 0xdf, 0xe0, 0x83, 0x69, 0x41, 0x46, - 0x26, 0xd8, 0xe8, 0x69, 0x41, 0xe1, 0xf2, 0x69, 0x01, 0x46, 0xaa, 0xdb, - 0xa3, 0x69, 0x01, 0xa7, 0x3b, 0xab, 0x15, 0xaf, 0x0b, 0x43, 0xc0, 0x95, - 0xe0, 0x69, 0xc1, 0x00, 0xf4, 0xf1, 0x69, 0x41, 0xf0, 0x7d, 0x69, 0x01, - 0xf1, 0x80, 0x69, 0x41, 0xe1, 0x73, 0x69, 0x81, 0x19, 0x02, 0x97, 0x02, - 0x0b, 0xb5, 0x01, 0xff, 0xed, 0xcb, 0x69, 0x01, 0xf0, 0xb6, 0x69, 0x41, - 0x43, 0x76, 0x87, 0x89, 0x69, 0x01, 0xf8, 0x7f, 0x69, 0x41, 0x43, 0xd0, - 0x61, 0xb9, 0x69, 0x41, 0xa5, 0x19, 0x42, 0x1f, 0x00, 0x7d, 0x69, 0x01, - 0xb5, 0x01, 0xff, 0x4b, 0x00, 0x99, 0x93, 0x69, 0x01, 0xf0, 0xd0, 0x69, - 0x01, 0x43, 0x8a, 0x82, 0x86, 0x69, 0x41, 0x43, 0x94, 0xa9, 0x8d, 0x69, - 0x01, 0x43, 0xc0, 0x95, 0xbf, 0x69, 0xc1, 0x00, 0xf4, 0x77, 0x69, 0x41, - 0xa1, 0x12, 0xa9, 0x06, 0x42, 0x42, 0x0b, 0x70, 0x69, 0x41, 0x42, 0x9b, - 0x36, 0xb0, 0x69, 0x01, 0xf1, 0x8e, 0x69, 0x41, 0x02, 0x5a, 0x00, 0x04, - 0xf0, 0x66, 0x69, 0x41, 0x48, 0x89, 0xc8, 0xdd, 0x69, 0x01, 0x48, 0x39, - 0xcb, 0x92, 0x69, 0x41, 0xe5, 0xc5, 0x69, 0x41, 0xe1, 0xfb, 0x69, 0x81, - 0x45, 0x02, 0xb7, 0x05, 0x37, 0x42, 0x92, 0x01, 0xfa, 0x69, 0x01, 0x44, - 0xe5, 0xef, 0xaf, 0x69, 0x01, 0x02, 0xa0, 0x48, 0x1d, 0xe9, 0xee, 0x69, - 0x81, 0x12, 0x42, 0x10, 0x00, 0xff, 0x69, 0x01, 0x43, 0xc0, 0x95, 0xc6, - 0x69, 0x01, 0x42, 0x02, 0x00, 0xc9, 0x69, 0x41, 0x42, 0x27, 0x01, 0xc3, - 0x69, 0x41, 0xe1, 0x87, 0x69, 0x01, 0x42, 0x92, 0x01, 0xa5, 0x69, 0x41, - 0xe5, 0xa6, 0x69, 0x01, 0x42, 0x48, 0x04, 0x68, 0x69, 0x41, 0xe5, 0xb8, - 0x69, 0x81, 0x08, 0xf0, 0x8b, 0x69, 0x01, 0xf1, 0xfc, 0x69, 0x41, 0xed, - 0x7e, 0x69, 0x41, 0xa1, 0x1e, 0x45, 0x52, 0xe6, 0xb3, 0x69, 0x01, 0xaf, - 0x04, 0xf5, 0xed, 0x69, 0x41, 0xed, 0x7b, 0x69, 0x01, 0xaf, 0x04, 0xf1, - 0xf8, 0x69, 0x41, 0xee, 0x6b, 0x69, 0x01, 0xf4, 0x8c, 0x69, 0x41, 0x42, - 0x57, 0x00, 0x9f, 0x69, 0x01, 0xf0, 0x69, 0x69, 0x01, 0xf1, 0xd9, 0x69, - 0x41, 0xa5, 0x21, 0xe9, 0xfe, 0x69, 0x01, 0xef, 0xf9, 0x69, 0x01, 0x44, - 0x2d, 0xf2, 0x74, 0x69, 0x01, 0xb5, 0x01, 0xff, 0x42, 0xed, 0x05, 0xab, - 0x69, 0x01, 0x42, 0x1f, 0x00, 0x7a, 0x69, 0x01, 0xf4, 0xcc, 0x69, 0x41, - 0xf4, 0xb7, 0x69, 0x01, 0xb5, 0x01, 0xff, 0x42, 0x93, 0x0f, 0x9a, 0x69, - 0x01, 0xf8, 0xe6, 0x69, 0x41, 0x02, 0xb7, 0x05, 0x26, 0xa8, 0x01, 0xff, - 0x45, 0x1d, 0xe4, 0xa2, 0x69, 0x01, 0xa5, 0x06, 0x42, 0x14, 0x05, 0x02, - 0x6a, 0x41, 0xf4, 0xba, 0x69, 0x01, 0xb5, 0x01, 0xff, 0x42, 0x93, 0x0f, - 0xc7, 0x69, 0x01, 0xee, 0x95, 0x69, 0x01, 0xf8, 0x88, 0x69, 0x41, 0xf4, - 0xa9, 0x69, 0x01, 0x42, 0xdf, 0xe0, 0xb5, 0x69, 0x41, 0xe1, 0xbb, 0x69, - 0x81, 0x2a, 0x42, 0x27, 0x01, 0xeb, 0x69, 0x01, 0x42, 0x14, 0x05, 0xd3, - 0x69, 0x01, 0xb5, 0x01, 0xff, 0x80, 0x09, 0xe5, 0xb4, 0x69, 0xc1, 0x00, - 0xf4, 0xc4, 0x69, 0x41, 0x44, 0x31, 0x17, 0xd2, 0x69, 0x01, 0xe9, 0xc8, - 0x69, 0x01, 0x46, 0xa0, 0xdf, 0xf5, 0x69, 0x41, 0xf1, 0x01, 0x6a, 0x41, - 0xa6, 0xea, 0x05, 0x02, 0x40, 0x00, 0xd9, 0x05, 0xab, 0x9a, 0x05, 0xac, - 0xec, 0x04, 0xed, 0x51, 0x69, 0x81, 0xeb, 0x03, 0xae, 0xfb, 0x01, 0xb0, - 0xd3, 0x01, 0xb2, 0xb4, 0x01, 0xb3, 0x66, 0xb4, 0x30, 0xb7, 0x22, 0xb9, - 0x01, 0xff, 0x46, 0x9a, 0xd9, 0x05, 0x69, 0x01, 0x42, 0x92, 0x01, 0x0d, - 0x69, 0x01, 0xb5, 0x01, 0xff, 0xaf, 0x06, 0x43, 0xeb, 0xf4, 0x25, 0x69, - 0x41, 0xed, 0x34, 0x69, 0x01, 0xf0, 0x36, 0x69, 0x41, 0x42, 0xe5, 0x05, - 0xf2, 0x68, 0x01, 0x44, 0x18, 0xc1, 0xfb, 0x68, 0x41, 0x42, 0x93, 0x0f, - 0x4b, 0x69, 0x01, 0xa5, 0x15, 0xe9, 0x61, 0x69, 0x01, 0x42, 0x84, 0x93, - 0x4c, 0x69, 0x01, 0xf5, 0x11, 0x69, 0xc1, 0x00, 0x42, 0x1b, 0x05, 0x3d, - 0x69, 0x41, 0x43, 0x94, 0xa9, 0x28, 0x69, 0x01, 0xb5, 0x01, 0xff, 0x43, - 0x22, 0x42, 0x23, 0x69, 0x01, 0xee, 0x41, 0x69, 0x01, 0xf4, 0x00, 0x69, - 0x41, 0xa1, 0x42, 0x45, 0xbf, 0x95, 0x0c, 0x69, 0x01, 0xa8, 0x17, 0x42, - 0x1b, 0x05, 0x24, 0x69, 0x01, 0xb5, 0x01, 0xff, 0x42, 0x93, 0x0f, 0x39, - 0x69, 0x01, 0xe5, 0x03, 0x69, 0x01, 0xf5, 0x52, 0x69, 0x41, 0xa5, 0x10, - 0x42, 0x6d, 0x28, 0x54, 0x69, 0x01, 0x42, 0x84, 0x93, 0x5c, 0x69, 0x01, - 0xf5, 0x58, 0x69, 0x41, 0xe5, 0xfd, 0x68, 0x01, 0xb5, 0x01, 0xff, 0x42, - 0x93, 0x0f, 0x01, 0x69, 0x01, 0xf8, 0x55, 0x69, 0x41, 0xf0, 0x07, 0x69, - 0x01, 0xf1, 0x64, 0x69, 0x41, 0x43, 0x76, 0x87, 0x27, 0x69, 0x01, 0x03, - 0xb1, 0x01, 0x06, 0x42, 0x6d, 0x28, 0x4e, 0x69, 0x41, 0x44, 0xf5, 0xe8, - 0x60, 0x69, 0x01, 0x43, 0xfd, 0x1a, 0x4a, 0x69, 0x41, 0x42, 0xe5, 0x05, - 0x35, 0x69, 0x01, 0xa5, 0x13, 0x42, 0xba, 0x04, 0x2d, 0x69, 0x01, 0xb5, - 0x01, 0xff, 0xf1, 0x5d, 0x69, 0x01, 0x42, 0x29, 0x08, 0x1b, 0x69, 0x41, - 0xe5, 0x5a, 0x69, 0x01, 0x44, 0x0d, 0xf3, 0x2e, 0x69, 0x41, 0xa4, 0xd2, - 0x01, 0xa7, 0x7e, 0xe9, 0x5b, 0x69, 0x01, 0xaa, 0x53, 0xb3, 0x31, 0xb4, - 0x1d, 0xf5, 0x57, 0x69, 0x01, 0xb9, 0x01, 0xff, 0x42, 0x57, 0x00, 0xfa, - 0x68, 0x01, 0x42, 0xed, 0x05, 0x22, 0x69, 0x01, 0xe9, 0x4d, 0x69, 0x01, - 0x42, 0xd6, 0x13, 0x2f, 0x69, 0x41, 0xa5, 0x06, 0x42, 0x2e, 0x74, 0x62, - 0x69, 0x41, 0xe5, 0x59, 0x69, 0x01, 0x42, 0x48, 0x04, 0x38, 0x69, 0x41, - 0xa8, 0x12, 0x03, 0x73, 0x8e, 0x06, 0x42, 0x48, 0x04, 0x40, 0x69, 0x41, - 0xf0, 0x1f, 0x69, 0x01, 0xf4, 0x2b, 0x69, 0x41, 0x42, 0x27, 0x01, 0xf8, - 0x68, 0x01, 0x42, 0x29, 0x08, 0x46, 0x69, 0x41, 0x42, 0xe5, 0x05, 0x02, - 0x69, 0x01, 0x02, 0x97, 0x02, 0x11, 0xe9, 0xf3, 0x68, 0x81, 0x06, 0x43, - 0x36, 0xf3, 0x47, 0x69, 0x41, 0x42, 0x27, 0x01, 0xf5, 0x68, 0x41, 0x43, - 0x76, 0x87, 0x0e, 0x69, 0x01, 0xf4, 0xf7, 0x68, 0x41, 0xa7, 0x2b, 0xab, - 0x01, 0xff, 0x42, 0xe5, 0x05, 0xfe, 0x68, 0x01, 0x02, 0x97, 0x02, 0x12, - 0x43, 0x73, 0x8e, 0x3c, 0x69, 0x01, 0x42, 0x42, 0x0b, 0xfc, 0x68, 0x01, - 0x43, 0xee, 0xa9, 0x13, 0x69, 0x41, 0x43, 0xc1, 0x95, 0x29, 0x69, 0x01, - 0x42, 0x0d, 0x00, 0x10, 0x69, 0x41, 0xa1, 0x12, 0x43, 0x1c, 0xec, 0x3b, - 0x69, 0x01, 0x43, 0x79, 0xcd, 0x45, 0x69, 0x01, 0x44, 0xbb, 0xd7, 0x33, - 0x69, 0x41, 0x42, 0x57, 0x00, 0x31, 0x69, 0x81, 0x04, 0xf0, 0x43, 0x69, - 0x41, 0x42, 0x93, 0x0f, 0xf9, 0x68, 0x41, 0x42, 0x57, 0x00, 0x37, 0x69, - 0x01, 0xa5, 0x06, 0x42, 0x10, 0x00, 0x18, 0x69, 0x41, 0xe5, 0x15, 0x69, - 0x01, 0x42, 0xdf, 0xe0, 0x09, 0x69, 0x41, 0xa1, 0x6d, 0xa2, 0x58, 0xa5, - 0x45, 0xa6, 0x26, 0x02, 0xa0, 0x48, 0x10, 0x43, 0x49, 0x07, 0x19, 0x69, - 0x01, 0xf5, 0x53, 0x69, 0x01, 0x43, 0x8b, 0xac, 0x5e, 0x69, 0x41, 0x43, - 0x0a, 0x69, 0x1a, 0x69, 0x01, 0x43, 0x73, 0x8e, 0x1c, 0x69, 0x01, 0x44, - 0xe5, 0xf1, 0x16, 0x69, 0x41, 0x02, 0x97, 0x02, 0x0f, 0x43, 0x73, 0x8e, - 0x32, 0x69, 0x01, 0xef, 0x1d, 0x69, 0xc1, 0x00, 0xee, 0xf4, 0x68, 0x41, - 0x42, 0x93, 0x0f, 0x2a, 0x69, 0x01, 0xf4, 0x08, 0x69, 0x41, 0x43, 0x94, - 0xa9, 0x50, 0x69, 0x01, 0xb5, 0x01, 0xff, 0xee, 0x3e, 0x69, 0x01, 0xf4, - 0x0b, 0x69, 0x41, 0x42, 0x80, 0x12, 0x20, 0x69, 0x81, 0x06, 0x42, 0x1a, - 0x05, 0xf1, 0x68, 0x41, 0x46, 0xe3, 0x1d, 0x63, 0x69, 0x41, 0x45, 0x25, - 0xe6, 0x42, 0x69, 0x01, 0x45, 0x32, 0xe6, 0x0a, 0x69, 0x41, 0xa5, 0x12, - 0x43, 0x73, 0x8e, 0xf6, 0x68, 0x01, 0x42, 0x84, 0x93, 0x5f, 0x69, 0x01, - 0x42, 0x48, 0x04, 0x1e, 0x69, 0x41, 0x43, 0x94, 0xa9, 0x4f, 0x69, 0x01, - 0xf4, 0x30, 0x69, 0x01, 0xb5, 0x01, 0xff, 0x43, 0x79, 0xdb, 0x17, 0x69, - 0x01, 0xed, 0x44, 0x69, 0x41, 0xa5, 0x1f, 0xf5, 0x49, 0x69, 0x81, 0x0c, - 0x44, 0x3d, 0xf3, 0x21, 0x69, 0x01, 0x43, 0xee, 0xa9, 0x56, 0x69, 0x41, - 0xee, 0x3a, 0x69, 0x01, 0x42, 0x14, 0x05, 0x06, 0x69, 0x01, 0xf1, 0x3f, - 0x69, 0x41, 0xf4, 0x04, 0x69, 0x01, 0xb5, 0x01, 0xff, 0x47, 0xb2, 0xce, - 0xff, 0x68, 0x01, 0xed, 0x26, 0x69, 0x01, 0x48, 0x91, 0xc9, 0x0f, 0x69, - 0x01, 0xf0, 0x2c, 0x69, 0x41, 0x42, 0x80, 0x12, 0x12, 0x69, 0x01, 0x44, - 0xbf, 0x95, 0x48, 0x69, 0x41, 0x42, 0x80, 0x12, 0x65, 0x69, 0x01, 0x48, - 0x19, 0xc6, 0x14, 0x69, 0x41, 0x44, 0x6d, 0xef, 0xc0, 0x68, 0x01, 0x43, - 0x6d, 0xf4, 0xbc, 0x68, 0x01, 0xa7, 0xfb, 0x04, 0xab, 0xad, 0x04, 0xac, - 0x96, 0x04, 0xad, 0x93, 0x03, 0xae, 0xa9, 0x01, 0xb0, 0x93, 0x01, 0x42, - 0x3d, 0x00, 0xc3, 0x68, 0x01, 0xb3, 0x63, 0xb4, 0x3e, 0x03, 0xeb, 0x5e, - 0x30, 0xb7, 0x22, 0xb9, 0x01, 0xff, 0x42, 0x80, 0x12, 0xd9, 0x68, 0x01, - 0x43, 0x2b, 0x9c, 0xa7, 0x68, 0x01, 0xb5, 0x01, 0xff, 0x47, 0x77, 0xcd, - 0xa2, 0x68, 0x01, 0xed, 0x91, 0x68, 0x01, 0x43, 0xeb, 0xf4, 0xe4, 0x68, - 0x41, 0x47, 0xf1, 0xce, 0x92, 0x68, 0x01, 0x42, 0x50, 0x02, 0xd1, 0x68, - 0x41, 0x45, 0x36, 0xe4, 0xc1, 0x68, 0x01, 0xf8, 0xb1, 0x68, 0x41, 0x46, - 0x8e, 0xd9, 0xac, 0x68, 0x01, 0xa5, 0x11, 0x02, 0x52, 0x00, 0x01, 0xff, - 0x45, 0x13, 0xe4, 0xae, 0x68, 0x01, 0x44, 0x9c, 0xdc, 0xc6, 0x68, 0x41, - 0xf4, 0xf0, 0x68, 0x01, 0x45, 0x1a, 0xec, 0xba, 0x68, 0x41, 0xa5, 0x1a, - 0xa8, 0x06, 0x44, 0x4c, 0xae, 0xaf, 0x68, 0x41, 0x45, 0x4d, 0xe6, 0xdc, - 0x68, 0x01, 0x42, 0x87, 0x18, 0xe8, 0x68, 0x01, 0x43, 0x36, 0xf3, 0xdb, - 0x68, 0x41, 0x44, 0x4e, 0xe6, 0xdc, 0x68, 0x01, 0x42, 0xdf, 0xe0, 0xaa, - 0x68, 0x41, 0x42, 0x92, 0x01, 0xef, 0x68, 0x01, 0xa9, 0x01, 0xff, 0xee, - 0xee, 0x68, 0x01, 0x45, 0x80, 0xea, 0x9c, 0x68, 0x41, 0xa1, 0xda, 0x01, - 0xa4, 0xb3, 0x01, 0xa7, 0x74, 0xaa, 0x52, 0xb3, 0x2d, 0xb4, 0x13, 0x50, - 0xfd, 0x68, 0x99, 0x68, 0x01, 0xba, 0x01, 0xff, 0xe1, 0x90, 0x68, 0x01, - 0x43, 0xf5, 0x57, 0xa3, 0x68, 0x41, 0x42, 0x80, 0x12, 0xb4, 0x68, 0x01, - 0xa5, 0x06, 0x46, 0xe4, 0xe0, 0x9a, 0x68, 0x41, 0xee, 0xd4, 0x68, 0x01, - 0x45, 0xf2, 0xeb, 0xb9, 0x68, 0x41, 0xe1, 0xbe, 0x68, 0x01, 0x45, 0x17, - 0xc1, 0xa5, 0x68, 0x01, 0x43, 0x70, 0xf4, 0xbf, 0x68, 0x01, 0x42, 0x14, - 0x05, 0xd3, 0x68, 0x01, 0xb5, 0x01, 0xff, 0xee, 0xd6, 0x68, 0x01, 0x47, - 0x3f, 0xd4, 0xc7, 0x68, 0x41, 0xa1, 0x14, 0xa5, 0x06, 0x43, 0x36, 0xf3, - 0xad, 0x68, 0x41, 0x43, 0x94, 0xa9, 0xc8, 0x68, 0x01, 0x42, 0xdf, 0xe0, - 0xe5, 0x68, 0x41, 0x42, 0xb5, 0x05, 0xc4, 0x68, 0x01, 0xed, 0xcf, 0x68, - 0x41, 0x42, 0x9b, 0x36, 0xeb, 0x68, 0x01, 0xa7, 0x14, 0xab, 0x06, 0x42, - 0x14, 0x05, 0xd0, 0x68, 0x41, 0x42, 0x9b, 0x36, 0x95, 0x68, 0x01, 0x49, - 0x59, 0xc0, 0x8f, 0x68, 0x41, 0x42, 0x92, 0x01, 0x93, 0x68, 0x01, 0xf5, - 0xca, 0x68, 0xc1, 0x00, 0x48, 0x51, 0xc3, 0xb0, 0x68, 0x01, 0x43, 0x0f, - 0x11, 0xd2, 0x68, 0x01, 0xed, 0xbb, 0x68, 0x01, 0x42, 0x10, 0x00, 0xb5, - 0x68, 0x41, 0xa1, 0x1a, 0x02, 0x97, 0x02, 0x0c, 0x43, 0x44, 0x95, 0xab, - 0x68, 0x01, 0x44, 0x8e, 0xd2, 0x9d, 0x68, 0x41, 0x45, 0x3b, 0xe4, 0x94, - 0x68, 0x01, 0xf4, 0xbd, 0x68, 0x41, 0xed, 0xd7, 0x68, 0x01, 0xf0, 0xda, - 0x68, 0x41, 0x46, 0x9e, 0xde, 0xb2, 0x68, 0x01, 0xf1, 0xec, 0x68, 0x41, - 0xa1, 0x61, 0xa2, 0x12, 0x46, 0x04, 0xdc, 0xb8, 0x68, 0x01, 0x43, 0x73, - 0x8e, 0xe6, 0x68, 0x01, 0x43, 0xc0, 0x95, 0xe7, 0x68, 0x41, 0xa1, 0x35, - 0xa5, 0x1c, 0xe9, 0xdd, 0x68, 0x81, 0x0d, 0xb5, 0x01, 0xff, 0x43, 0x76, - 0x87, 0xcc, 0x68, 0x01, 0xe5, 0xa4, 0x68, 0x41, 0x45, 0x80, 0xea, 0xb7, - 0x68, 0x01, 0xf4, 0xa6, 0x68, 0x41, 0x45, 0x02, 0xe6, 0x97, 0x68, 0x01, - 0x43, 0x8a, 0x82, 0xc2, 0x68, 0x01, 0xb5, 0x01, 0xff, 0xed, 0x9b, 0x68, - 0x01, 0xf8, 0xe1, 0x68, 0x41, 0x02, 0x5a, 0x00, 0x06, 0x43, 0x99, 0x1a, - 0xdf, 0x68, 0x41, 0x4c, 0x30, 0x8d, 0x9e, 0x68, 0x01, 0x46, 0x40, 0xdf, - 0xe3, 0x68, 0x41, 0x80, 0x0f, 0xa5, 0x01, 0xff, 0x43, 0x67, 0x9f, 0xde, - 0x68, 0x01, 0x42, 0x5a, 0x03, 0xcb, 0x68, 0x41, 0x47, 0x78, 0xd2, 0xb3, - 0x68, 0x01, 0x45, 0x54, 0xe9, 0xd8, 0x68, 0x41, 0xa1, 0x0a, 0x42, 0x87, - 0x18, 0xed, 0x68, 0x01, 0xf5, 0xcd, 0x68, 0x41, 0xed, 0xc5, 0x68, 0x01, - 0xf0, 0xb6, 0x68, 0x41, 0x42, 0x80, 0x12, 0xa9, 0x68, 0x01, 0xa5, 0x13, - 0x45, 0x03, 0x69, 0xa8, 0x68, 0x01, 0xb5, 0x01, 0xff, 0x4a, 0x0e, 0xaf, - 0xd5, 0x68, 0x01, 0xf4, 0xce, 0x68, 0x41, 0x02, 0x92, 0x00, 0x20, 0xf4, - 0xc9, 0x68, 0x01, 0xb5, 0x01, 0xff, 0x43, 0x88, 0xf4, 0xa1, 0x68, 0x01, - 0xed, 0xe2, 0x68, 0x01, 0xb3, 0x01, 0xff, 0x43, 0x1c, 0xec, 0xe0, 0x68, - 0x01, 0x46, 0x9a, 0xdc, 0x9f, 0x68, 0x41, 0x47, 0x28, 0xd1, 0xea, 0x68, - 0x01, 0x43, 0x96, 0xd4, 0xe9, 0x68, 0x41, 0x44, 0x55, 0xef, 0x98, 0x68, - 0x01, 0x02, 0x22, 0x00, 0x01, 0xff, 0xf0, 0xa0, 0x68, 0x01, 0x43, 0x8a, - 0x82, 0x96, 0x68, 0x41, 0x02, 0x28, 0x1a, 0x93, 0x03, 0x07, 0x60, 0xd1, - 0x84, 0x03, 0xab, 0xd8, 0x02, 0xac, 0xbb, 0x02, 0xad, 0xde, 0x01, 0xae, - 0x83, 0x01, 0xb0, 0x5e, 0xb3, 0x34, 0xb4, 0x1b, 0x44, 0x1d, 0xf3, 0x73, - 0x68, 0x01, 0x45, 0x8d, 0xec, 0x76, 0x68, 0x01, 0xb9, 0x01, 0xff, 0x4c, - 0x1c, 0x8c, 0x62, 0x68, 0x01, 0x45, 0x57, 0xe6, 0x5e, 0x68, 0x41, 0x43, - 0x7e, 0x89, 0x78, 0x68, 0x01, 0x02, 0x2e, 0x02, 0x01, 0xff, 0x49, 0xf4, - 0xbb, 0x58, 0x68, 0x01, 0x45, 0x54, 0xe9, 0x68, 0x68, 0x41, 0x46, 0x77, - 0xd2, 0x77, 0x68, 0x01, 0x45, 0x48, 0xe6, 0x5a, 0x68, 0x01, 0x02, 0xb0, - 0x01, 0x0c, 0x43, 0x73, 0x8e, 0x59, 0x68, 0x01, 0x42, 0xd6, 0x13, 0x7d, - 0x68, 0x41, 0x46, 0x72, 0xe0, 0x69, 0x68, 0x01, 0x46, 0xea, 0xe0, 0x6a, - 0x68, 0x41, 0x44, 0x3d, 0xef, 0x72, 0x68, 0x01, 0x45, 0xe4, 0xe5, 0x61, - 0x68, 0x01, 0x42, 0x52, 0x00, 0x67, 0x68, 0x01, 0x03, 0xb1, 0x45, 0x01, - 0xff, 0x43, 0x7e, 0x89, 0x81, 0x68, 0x01, 0x44, 0xfd, 0xef, 0x81, 0x68, - 0x41, 0x47, 0x95, 0xd0, 0x65, 0x68, 0x01, 0xa7, 0x23, 0xb3, 0x15, 0x4b, - 0xa8, 0xa3, 0x64, 0x68, 0x01, 0xb9, 0x01, 0xff, 0x45, 0x31, 0xe4, 0x80, - 0x68, 0x01, 0x47, 0xd0, 0xd1, 0x6d, 0x68, 0x41, 0x42, 0x92, 0x01, 0x8b, - 0x68, 0x01, 0x44, 0xf3, 0xd0, 0x57, 0x68, 0x41, 0xa7, 0x0c, 0x4a, 0x84, - 0xac, 0x74, 0x68, 0x01, 0x42, 0x14, 0x05, 0x8e, 0x68, 0x41, 0x43, 0x7e, - 0x89, 0x8a, 0x68, 0x01, 0x46, 0x98, 0xdb, 0x75, 0x68, 0x01, 0x42, 0x14, - 0x05, 0x8e, 0x68, 0x01, 0x43, 0xb0, 0xa3, 0x7a, 0x68, 0xc1, 0x00, 0x46, - 0xcd, 0x1c, 0x7b, 0x68, 0x41, 0xe1, 0x8c, 0x68, 0x81, 0x44, 0xa2, 0x22, - 0x02, 0x97, 0x02, 0x14, 0xa6, 0x06, 0x47, 0x15, 0xd4, 0x7f, 0x68, 0x41, - 0x44, 0x99, 0x36, 0x7c, 0x68, 0x01, 0x49, 0x38, 0xbd, 0x6b, 0x68, 0x41, - 0xf1, 0x79, 0x68, 0x01, 0x48, 0x69, 0xcb, 0x82, 0x68, 0x41, 0xa1, 0x12, - 0x44, 0x0f, 0xec, 0x7e, 0x68, 0x01, 0x4a, 0x34, 0xac, 0x6c, 0x68, 0x01, - 0x43, 0xb0, 0xa3, 0x84, 0x68, 0x41, 0x47, 0x62, 0xcd, 0x5c, 0x68, 0x01, - 0x44, 0x89, 0x82, 0x5f, 0x68, 0x41, 0x03, 0x6e, 0x87, 0x01, 0xff, 0x46, - 0x9e, 0xdb, 0x87, 0x68, 0x01, 0x43, 0xd9, 0xf4, 0x88, 0x68, 0x41, 0xa1, - 0x0c, 0x42, 0xed, 0x05, 0x89, 0x68, 0x01, 0x48, 0x49, 0xc9, 0x5b, 0x68, - 0x41, 0x44, 0x25, 0xef, 0x71, 0x68, 0x01, 0x4c, 0xbc, 0x91, 0x63, 0x68, - 0x41, 0x42, 0x57, 0x00, 0x60, 0x68, 0x01, 0x02, 0x97, 0x02, 0x0d, 0xa9, - 0x01, 0xff, 0x43, 0x67, 0x18, 0x5d, 0x68, 0x01, 0xf1, 0x8d, 0x68, 0x41, - 0x43, 0x76, 0x87, 0x86, 0x68, 0x01, 0x43, 0xa9, 0xf4, 0x6e, 0x68, 0x01, - 0x44, 0x65, 0xf3, 0x70, 0x68, 0x41, 0xee, 0x6f, 0x68, 0x01, 0x44, 0x53, - 0xe6, 0x66, 0x68, 0x41, 0xe5, 0x85, 0x68, 0x01, 0x42, 0xdf, 0xe0, 0x83, - 0x68, 0x41, 0x44, 0xed, 0xef, 0x39, 0x68, 0x01, 0xa7, 0xcc, 0x04, 0xab, - 0xa5, 0x04, 0xac, 0x85, 0x04, 0xad, 0x8a, 0x03, 0xae, 0xdc, 0x01, 0xb0, - 0x88, 0x01, 0x43, 0xab, 0x05, 0x3a, 0x68, 0x01, 0xb3, 0x3b, 0xb4, 0x14, - 0xb5, 0x06, 0x43, 0xfd, 0x06, 0x52, 0x68, 0x41, 0x48, 0xd1, 0xc2, 0x20, - 0x68, 0x01, 0x46, 0x80, 0xde, 0x44, 0x68, 0x41, 0x02, 0x97, 0x02, 0x15, - 0x48, 0x69, 0xc7, 0x06, 0x68, 0x01, 0xb5, 0x01, 0xff, 0x47, 0x5b, 0xc0, - 0x0c, 0x68, 0x01, 0x43, 0x79, 0xdb, 0x2e, 0x68, 0x41, 0x43, 0x22, 0x42, - 0x4a, 0x68, 0x01, 0x46, 0xa8, 0xe0, 0x31, 0x68, 0x41, 0x46, 0xa4, 0xdb, - 0x11, 0x68, 0x01, 0xa8, 0x1c, 0x43, 0x0d, 0x4a, 0x23, 0x68, 0x01, 0xaf, - 0x06, 0x42, 0x2e, 0x74, 0x15, 0x68, 0x41, 0x44, 0xa5, 0xf1, 0x30, 0x68, - 0x01, 0xf1, 0x3c, 0x68, 0x01, 0xf4, 0x4b, 0x68, 0x41, 0xa9, 0x13, 0x4c, - 0x84, 0x93, 0x40, 0x68, 0x01, 0xb5, 0x01, 0xff, 0x47, 0xf0, 0xd0, 0x05, - 0x68, 0x01, 0xed, 0x37, 0x68, 0x41, 0x4a, 0x6e, 0xae, 0x08, 0x68, 0x01, - 0x43, 0x8a, 0x82, 0x3e, 0x68, 0x41, 0xa1, 0x31, 0x42, 0xed, 0x05, 0x2a, - 0x68, 0x01, 0x03, 0xb6, 0x00, 0x06, 0x42, 0x50, 0x02, 0x2d, 0x68, 0x41, - 0x0b, 0x93, 0x9f, 0x11, 0x0d, 0x6c, 0x87, 0x01, 0xff, 0x42, 0x16, 0x00, - 0x0a, 0x68, 0x01, 0x45, 0xf8, 0xbb, 0x09, 0x68, 0x41, 0x42, 0x16, 0x00, - 0x03, 0x68, 0x01, 0x45, 0xf8, 0xbb, 0x02, 0x68, 0x41, 0x49, 0x1f, 0x8c, - 0x28, 0x68, 0x01, 0xa1, 0x0c, 0x45, 0xf0, 0xe8, 0x1d, 0x68, 0x01, 0x44, - 0x02, 0x99, 0x1b, 0x68, 0x41, 0xed, 0x4c, 0x68, 0x01, 0x43, 0x8a, 0x82, - 0x42, 0x68, 0x41, 0xa1, 0x9e, 0x01, 0x02, 0xf0, 0x10, 0x8d, 0x01, 0x42, - 0x92, 0x01, 0x54, 0x68, 0x01, 0xa7, 0x68, 0x43, 0xc4, 0x43, 0x2c, 0x68, - 0x01, 0x43, 0xa6, 0xf1, 0x47, 0x68, 0x01, 0xab, 0x4e, 0x02, 0xa4, 0x02, - 0x40, 0xb4, 0x22, 0xb9, 0x0f, 0xba, 0x01, 0xff, 0x46, 0x6b, 0xc7, 0x07, - 0x68, 0x01, 0x47, 0xe6, 0xd6, 0x1f, 0x68, 0x41, 0x42, 0xed, 0x05, 0x49, - 0x68, 0x01, 0xe9, 0x4f, 0x68, 0xc1, 0x00, 0x4c, 0xb8, 0x95, 0x41, 0x68, - 0x41, 0x42, 0xe5, 0x05, 0x3f, 0x68, 0x81, 0x06, 0x45, 0xbd, 0xe9, 0x12, - 0x68, 0x41, 0x80, 0x01, 0xff, 0x44, 0x4d, 0xf1, 0x19, 0x68, 0x01, 0x44, - 0xc1, 0xf1, 0x22, 0x68, 0x41, 0xe1, 0x51, 0x68, 0x01, 0x43, 0x73, 0x8e, - 0x4d, 0x68, 0x41, 0x45, 0x13, 0xaf, 0x43, 0x68, 0x01, 0x44, 0xe9, 0x06, - 0x14, 0x68, 0x41, 0x44, 0x1c, 0x01, 0x0d, 0x68, 0x01, 0x43, 0x47, 0x5a, - 0x45, 0x68, 0x01, 0x03, 0x8b, 0xf4, 0x01, 0xff, 0x45, 0x6c, 0xc7, 0x00, - 0x68, 0x01, 0x45, 0x72, 0xe9, 0x16, 0x68, 0x41, 0x49, 0x1f, 0x8c, 0x29, - 0x68, 0x01, 0x49, 0x39, 0xb6, 0x34, 0x68, 0x41, 0x46, 0x6b, 0xc7, 0x04, - 0x68, 0x01, 0xf1, 0x55, 0x68, 0x41, 0xa1, 0x39, 0x02, 0x16, 0x00, 0x2b, - 0x4b, 0x23, 0x9c, 0x25, 0x68, 0x01, 0x45, 0x04, 0xdc, 0x24, 0x68, 0x01, - 0xaf, 0x06, 0x49, 0x16, 0xc1, 0x10, 0x68, 0x41, 0x4a, 0x46, 0xae, 0x1e, - 0x68, 0x01, 0x02, 0x14, 0x05, 0x01, 0xff, 0x43, 0x62, 0x8e, 0x36, 0x68, - 0x01, 0x43, 0xa9, 0xf4, 0x26, 0x68, 0x41, 0x43, 0x99, 0x1a, 0x48, 0x68, - 0x01, 0xf1, 0x56, 0x68, 0x41, 0xa5, 0x0c, 0x45, 0x59, 0xe9, 0x0f, 0x68, - 0x01, 0x47, 0x8c, 0xd4, 0x3d, 0x68, 0x41, 0x44, 0xf5, 0xf0, 0x1a, 0x68, - 0x01, 0xed, 0x4e, 0x68, 0x81, 0x0c, 0x43, 0x99, 0x1a, 0x32, 0x68, 0x01, - 0x42, 0x5a, 0x03, 0x46, 0x68, 0x41, 0x46, 0x42, 0xda, 0x0b, 0x68, 0x01, - 0x45, 0xf8, 0xbb, 0x0b, 0x68, 0x01, 0x44, 0xb8, 0x71, 0x2b, 0x68, 0x01, - 0x44, 0x21, 0xf3, 0x0e, 0x68, 0x41, 0x44, 0x29, 0xef, 0x17, 0x68, 0x01, - 0x46, 0x92, 0xdb, 0x18, 0x68, 0x01, 0x45, 0xb3, 0xe9, 0x38, 0x68, 0x01, - 0xf5, 0x53, 0x68, 0xc1, 0x00, 0x43, 0x79, 0xdb, 0x2f, 0x68, 0x41, 0xa1, - 0x18, 0xa5, 0x0c, 0x43, 0xa6, 0xf4, 0x3b, 0x68, 0x01, 0x43, 0xb0, 0xa3, - 0x35, 0x68, 0x41, 0xf4, 0x33, 0x68, 0x01, 0x48, 0x19, 0xcc, 0x13, 0x68, - 0x41, 0x42, 0x0c, 0x08, 0x27, 0x68, 0x01, 0xf1, 0x50, 0x68, 0x41, 0x48, - 0x31, 0xc4, 0x01, 0x68, 0x01, 0x05, 0x29, 0xdc, 0x01, 0xff, 0x46, 0x28, - 0xdc, 0x21, 0x68, 0x01, 0x43, 0x8a, 0x82, 0x1c, 0x68, 0x41, 0xe5, 0xca, - 0xa6, 0x00, 0x42, 0xdf, 0xe0, 0xc5, 0xa6, 0x40, 0xe1, 0xdb, 0xa6, 0x00, - 0x43, 0xac, 0x57, 0xb1, 0xa6, 0x00, 0xa7, 0x3d, 0xe9, 0xcf, 0xa6, 0x00, - 0xaa, 0x25, 0x43, 0xa4, 0x02, 0xc3, 0xa6, 0x00, 0xb4, 0x11, 0xf5, 0xbd, - 0xa6, 0x80, 0x06, 0x42, 0x9a, 0x1a, 0xa8, 0xa6, 0x40, 0x42, 0x93, 0x0f, - 0xbc, 0xa6, 0x40, 0x42, 0x27, 0x01, 0xc7, 0xa6, 0x00, 0x42, 0x2e, 0x74, - 0xeb, 0xa6, 0x40, 0x43, 0x76, 0x87, 0xb2, 0xa6, 0x00, 0x42, 0x27, 0x01, - 0xc6, 0xa6, 0x00, 0x43, 0xc0, 0x95, 0xbe, 0xa6, 0x40, 0xe1, 0xd5, 0xa6, - 0x00, 0x42, 0x24, 0x02, 0xd4, 0xa6, 0x00, 0x45, 0x14, 0xe8, 0xd3, 0xa6, - 0x40, 0xe1, 0xe3, 0xa6, 0x00, 0xa2, 0x18, 0xa5, 0x0c, 0xe9, 0xce, 0xa6, - 0x00, 0xef, 0xe6, 0xa6, 0x00, 0xf5, 0xb5, 0xa6, 0x40, 0x43, 0x94, 0xa9, - 0xaf, 0xa6, 0x00, 0xee, 0xe2, 0xa6, 0x40, 0x42, 0x80, 0x12, 0xe7, 0xa6, - 0x00, 0x42, 0x92, 0x01, 0xe0, 0xa6, 0x40, 0xe1, 0xaa, 0xa6, 0x00, 0x44, - 0xb9, 0xef, 0xae, 0xa6, 0x00, 0xe9, 0xdc, 0xa6, 0x00, 0x42, 0x84, 0x93, - 0xde, 0xa6, 0x00, 0xf5, 0xcd, 0xa6, 0x40, 0xe1, 0xa1, 0xa6, 0x00, 0xa5, - 0x25, 0xe9, 0xe5, 0xa6, 0x00, 0xef, 0xdf, 0xa6, 0x80, 0x10, 0x42, 0xbb, - 0x09, 0xe9, 0xa6, 0x00, 0xf5, 0xa3, 0xa6, 0x00, 0x43, 0xee, 0xa9, 0xba, - 0xa6, 0x40, 0x44, 0x11, 0xf0, 0xef, 0xa6, 0x00, 0x43, 0xe8, 0xf4, 0xee, - 0xa6, 0x40, 0xee, 0xd2, 0xa6, 0x00, 0xf4, 0xbb, 0xa6, 0x00, 0x42, 0xdf, - 0xe0, 0xc4, 0xa6, 0x40, 0x45, 0x1d, 0xe4, 0xed, 0xa6, 0x00, 0x42, 0x27, - 0x01, 0xcb, 0xa6, 0x00, 0x42, 0x14, 0x05, 0xd9, 0xa6, 0x00, 0xf5, 0xd8, - 0xa6, 0x40, 0x43, 0xd7, 0x02, 0xf4, 0xa6, 0x00, 0xad, 0x01, 0xff, 0x0c, - 0xd0, 0x8c, 0x06, 0x42, 0x6c, 0x00, 0xf5, 0xa6, 0x40, 0x47, 0x94, 0xd2, - 0xf0, 0xa6, 0x00, 0x49, 0x3e, 0xc0, 0xf1, 0xa6, 0x40, 0x06, 0xd2, 0x83, - 0x71, 0xac, 0x01, 0xff, 0x48, 0x49, 0xc2, 0xf6, 0xf9, 0x01, 0x48, 0x01, - 0xc6, 0x70, 0xfa, 0x01, 0xaf, 0x01, 0xff, 0x42, 0x10, 0x00, 0x88, 0xf3, - 0x81, 0x52, 0x02, 0xc6, 0x00, 0x01, 0xff, 0x02, 0x5d, 0x00, 0x0a, 0x48, - 0x8e, 0x9e, 0xf4, 0xf5, 0x01, 0xf8, 0x17, 0x27, 0x40, 0x4b, 0x8b, 0x9e, - 0xf6, 0xf5, 0x01, 0xf8, 0x10, 0x26, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, - 0xff, 0xa2, 0x16, 0x45, 0x6d, 0x14, 0x11, 0x26, 0x00, 0x47, 0x0b, 0xd3, - 0xbd, 0x2b, 0x00, 0x48, 0x8e, 0x9e, 0xf5, 0xf5, 0x01, 0xf8, 0x12, 0x26, - 0x40, 0x45, 0xc7, 0xce, 0xf3, 0xf5, 0x01, 0x04, 0x49, 0x25, 0x01, 0xff, - 0x45, 0x6d, 0x14, 0xf9, 0xf5, 0x01, 0x48, 0x8e, 0x9e, 0xf7, 0xf5, 0x41, - 0x50, 0xf0, 0x1c, 0x49, 0x27, 0x40, 0x49, 0xc4, 0xb5, 0x44, 0x1b, 0x00, - 0x06, 0xd4, 0x6e, 0x85, 0x07, 0x06, 0xef, 0x06, 0xbe, 0x06, 0x0f, 0xcb, - 0x6e, 0xad, 0x06, 0x07, 0xec, 0x05, 0xaa, 0x03, 0x0f, 0x41, 0x32, 0xcd, - 0x01, 0x02, 0xbb, 0x09, 0x9d, 0x01, 0x05, 0x5a, 0x03, 0x70, 0x0b, 0x55, - 0x77, 0x06, 0x45, 0x79, 0xec, 0x5c, 0x1b, 0x40, 0x48, 0xb1, 0xc7, 0x3c, - 0x1b, 0x80, 0x59, 0x45, 0xfe, 0xe9, 0x42, 0x1b, 0x80, 0x4c, 0x47, 0x34, - 0xd5, 0x3a, 0x1b, 0x80, 0x3f, 0x44, 0x29, 0xd6, 0x38, 0x1b, 0x80, 0x32, - 0xb4, 0x0d, 0x43, 0xb2, 0x97, 0x36, 0x1b, 0xc0, 0x00, 0x45, 0xfc, 0xe1, - 0x37, 0x1b, 0x40, 0x45, 0x5f, 0x28, 0x3e, 0x1b, 0x80, 0x06, 0x45, 0xbf, - 0xcd, 0x35, 0x1b, 0x40, 0x80, 0x01, 0xff, 0x44, 0x37, 0xce, 0x3f, 0x1b, - 0x80, 0x06, 0x46, 0xbe, 0xcd, 0x40, 0x1b, 0x40, 0x47, 0xbd, 0xcd, 0x41, - 0x1b, 0x40, 0x45, 0xe3, 0xe1, 0x39, 0x1b, 0x40, 0x47, 0xbd, 0xcd, 0x3b, - 0x1b, 0x40, 0x47, 0xbd, 0xcd, 0x43, 0x1b, 0x40, 0x47, 0xbd, 0xcd, 0x3d, - 0x1b, 0x40, 0x45, 0xea, 0xe4, 0x04, 0x1b, 0x00, 0x45, 0x35, 0xe5, 0x02, - 0x1b, 0x00, 0x47, 0x6c, 0xd5, 0x34, 0x1b, 0x00, 0x46, 0x54, 0xe0, 0x03, - 0x1b, 0x00, 0x04, 0xf9, 0xf2, 0x01, 0xff, 0x46, 0xd9, 0x23, 0x01, 0x1b, - 0x00, 0x45, 0x7b, 0xea, 0x00, 0x1b, 0x40, 0xad, 0x16, 0x43, 0x9f, 0x01, - 0x5a, 0x1b, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x45, 0xd1, 0xe4, 0x7f, 0x1b, - 0x00, 0x47, 0x3a, 0xc2, 0x7d, 0x1b, 0x40, 0x43, 0xfa, 0x1e, 0x5b, 0x1b, - 0x80, 0x06, 0x45, 0x20, 0xe6, 0x60, 0x1b, 0x40, 0x48, 0x39, 0xc2, 0x7e, - 0x1b, 0x40, 0x0a, 0x48, 0x59, 0x97, 0x01, 0xa4, 0x51, 0x0a, 0xe8, 0xac, - 0x26, 0x0b, 0x27, 0xa2, 0x01, 0xff, 0x08, 0x7d, 0x61, 0x11, 0x06, 0xf8, - 0xde, 0x01, 0xff, 0x42, 0x23, 0x02, 0x75, 0x1b, 0x00, 0x42, 0xd2, 0x0e, - 0x74, 0x1b, 0x40, 0x42, 0x6d, 0x00, 0x77, 0x1b, 0x00, 0x42, 0x90, 0x08, - 0x76, 0x1b, 0x40, 0x09, 0x62, 0xb7, 0x17, 0x06, 0xfe, 0xde, 0x01, 0xff, - 0x43, 0x1c, 0x01, 0x78, 0x1b, 0x00, 0x43, 0xa1, 0x01, 0x7c, 0x1b, 0x00, - 0x43, 0xb1, 0x45, 0x79, 0x1b, 0x40, 0x42, 0x6d, 0x00, 0x7a, 0x1b, 0x00, - 0x42, 0x90, 0x08, 0x7b, 0x1b, 0x40, 0xa1, 0x20, 0xa5, 0x12, 0x43, 0xa1, - 0x01, 0x66, 0x1b, 0x00, 0x43, 0xd8, 0x02, 0x61, 0x1b, 0x00, 0x43, 0xb1, - 0x45, 0x63, 0x1b, 0x40, 0x42, 0x1d, 0x01, 0x62, 0x1b, 0x00, 0x43, 0xb1, - 0x45, 0x68, 0x1b, 0x40, 0x43, 0x4c, 0x0a, 0x67, 0x1b, 0x00, 0x43, 0xa1, - 0x01, 0x69, 0x1b, 0x00, 0x42, 0x1d, 0x01, 0x64, 0x1b, 0xc0, 0x00, 0x80, - 0x01, 0xff, 0x44, 0x09, 0xf0, 0x6a, 0x1b, 0x00, 0x46, 0x54, 0xe0, 0x65, - 0x1b, 0x40, 0x45, 0xdb, 0xe4, 0x72, 0x1b, 0x00, 0x45, 0x1b, 0xe6, 0x6c, - 0x1b, 0x00, 0x44, 0x10, 0x87, 0x73, 0x1b, 0x00, 0x47, 0xee, 0x7f, 0x6f, - 0x1b, 0x00, 0x04, 0x25, 0xbb, 0x06, 0x45, 0x52, 0xeb, 0x6b, 0x1b, 0x40, - 0x42, 0xc3, 0x01, 0x6e, 0x1b, 0x80, 0x0d, 0x42, 0x1f, 0x01, 0x6d, 0x1b, - 0xc0, 0x00, 0x4d, 0xe8, 0x7f, 0x70, 0x1b, 0x40, 0x4d, 0xe8, 0x7f, 0x71, - 0x1b, 0x40, 0xa1, 0xdc, 0x02, 0x42, 0x16, 0x00, 0x29, 0x1b, 0x80, 0xce, - 0x02, 0x42, 0x37, 0x00, 0x18, 0x1b, 0x80, 0xc0, 0x02, 0x42, 0xf0, 0x10, - 0x24, 0x1b, 0x80, 0x9c, 0x02, 0xa5, 0x8d, 0x02, 0x42, 0x24, 0x02, 0x15, - 0x1b, 0x80, 0xff, 0x01, 0x42, 0x22, 0x00, 0x33, 0x1b, 0x00, 0x45, 0x74, - 0xe7, 0x07, 0x1b, 0x80, 0xeb, 0x01, 0x42, 0x72, 0x19, 0x1a, 0x1b, 0x80, - 0xdd, 0x01, 0xab, 0xc3, 0x01, 0x42, 0x74, 0x00, 0x2e, 0x1b, 0x80, 0xae, - 0x01, 0x42, 0x6c, 0x00, 0x2b, 0x1b, 0x00, 0xae, 0x8e, 0x01, 0x45, 0x9f, - 0xe9, 0x11, 0x1b, 0x80, 0x80, 0x01, 0x42, 0xbb, 0x09, 0x27, 0x1b, 0x80, - 0x73, 0x42, 0x71, 0x00, 0x2d, 0x1b, 0x80, 0x5f, 0x42, 0x40, 0x06, 0x32, - 0x1b, 0x80, 0x47, 0xb4, 0x25, 0x45, 0xe8, 0xeb, 0x09, 0x1b, 0x80, 0x18, - 0x48, 0x51, 0xcc, 0x49, 0x1b, 0x00, 0x42, 0xa9, 0x01, 0x2f, 0x1b, 0x00, - 0x42, 0xbe, 0x22, 0x2c, 0x1b, 0x00, 0x49, 0xe5, 0xc1, 0x4a, 0x1b, 0x40, - 0x47, 0xbd, 0xcd, 0x0a, 0x1b, 0x40, 0xe1, 0x22, 0x1b, 0x80, 0x06, 0x49, - 0x00, 0xc2, 0x47, 0x1b, 0x40, 0x80, 0x01, 0xff, 0x45, 0x3c, 0xe8, 0x1d, - 0x1b, 0x00, 0x4f, 0x60, 0x70, 0x1e, 0x1b, 0x00, 0x44, 0xc5, 0xc4, 0x23, - 0x1b, 0x40, 0x03, 0xed, 0x22, 0x01, 0xff, 0x42, 0x24, 0x02, 0x30, 0x1b, - 0x00, 0x42, 0xbb, 0x09, 0x31, 0x1b, 0x40, 0x45, 0x36, 0xd5, 0x0b, 0x1b, - 0xc0, 0x00, 0x47, 0xbd, 0xcd, 0x0c, 0x1b, 0x40, 0x46, 0x3e, 0xd8, 0x28, - 0x1b, 0x40, 0x47, 0xbd, 0xcd, 0x12, 0x1b, 0x40, 0xe1, 0x26, 0x1b, 0x80, - 0x0c, 0x42, 0x24, 0x02, 0x17, 0x1b, 0x00, 0x42, 0xbe, 0x22, 0x1c, 0x1b, - 0x40, 0x47, 0x9a, 0xcd, 0x21, 0x1b, 0x40, 0x46, 0xb3, 0xc7, 0x0d, 0x1b, - 0xc0, 0x00, 0x47, 0xbd, 0xcd, 0x0e, 0x1b, 0x40, 0xe1, 0x13, 0x1b, 0x80, - 0x06, 0x49, 0xe1, 0xb9, 0x46, 0x1b, 0x40, 0x4a, 0x65, 0x70, 0x14, 0x1b, - 0x00, 0x47, 0x21, 0xd1, 0x45, 0x1b, 0x40, 0x45, 0xe8, 0xe1, 0x1b, 0x1b, - 0x40, 0x47, 0xbd, 0xcd, 0x08, 0x1b, 0x40, 0x45, 0xd4, 0xe1, 0x16, 0x1b, - 0x40, 0x47, 0x21, 0xd1, 0x48, 0x1b, 0x00, 0x44, 0x5e, 0x2d, 0x0f, 0x1b, - 0x40, 0x02, 0x6b, 0x00, 0x01, 0xff, 0x43, 0x6b, 0x02, 0x25, 0x1b, 0x00, - 0x05, 0x61, 0x70, 0x01, 0xff, 0x49, 0x1e, 0xb6, 0x1f, 0x1b, 0x00, 0x49, - 0x66, 0x70, 0x20, 0x1b, 0x40, 0x45, 0xf2, 0xe1, 0x19, 0x1b, 0x40, 0x48, - 0x31, 0xc2, 0x2a, 0x1b, 0x40, 0x45, 0x74, 0xe7, 0x10, 0x1b, 0x00, 0x44, - 0x5e, 0x2d, 0x05, 0x1b, 0x80, 0x0c, 0x4b, 0xf0, 0xa1, 0x4c, 0x1b, 0x00, - 0x4b, 0x2f, 0xa3, 0x4b, 0x1b, 0x40, 0x47, 0xbd, 0xcd, 0x06, 0x1b, 0x40, - 0x47, 0xa8, 0xd4, 0x4f, 0x1b, 0x00, 0x44, 0x79, 0xad, 0x4e, 0x1b, 0x40, - 0x45, 0x12, 0x0b, 0x58, 0x1b, 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x59, - 0x1b, 0x00, 0x43, 0x0e, 0x0b, 0x51, 0x1b, 0x00, 0xb3, 0x14, 0xb4, 0x06, - 0x44, 0x5f, 0x1e, 0x50, 0x1b, 0x40, 0x44, 0x25, 0x01, 0x53, 0x1b, 0x00, - 0x42, 0x15, 0x02, 0x52, 0x1b, 0x40, 0x44, 0xe5, 0x1d, 0x57, 0x1b, 0x00, - 0x42, 0x1c, 0x26, 0x56, 0x1b, 0x40, 0x43, 0xd2, 0x05, 0x55, 0x1b, 0x00, - 0x43, 0xf6, 0x06, 0x54, 0x1b, 0x40, 0x02, 0xbb, 0x09, 0x06, 0x44, 0x79, - 0xad, 0x5e, 0x1b, 0x40, 0x47, 0x82, 0xd3, 0x5d, 0x1b, 0x00, 0x45, 0xa0, - 0x72, 0x5f, 0x1b, 0x40, 0x42, 0xd8, 0x00, 0x6f, 0xf9, 0x01, 0x4a, 0xb8, - 0xaa, 0xc4, 0xf6, 0x01, 0x4b, 0x42, 0xa4, 0x56, 0xf9, 0x41, 0x43, 0xdb, - 0x09, 0xa1, 0xf9, 0x01, 0x5e, 0xcb, 0x13, 0xf8, 0xf3, 0x41, 0xab, 0x0c, - 0x42, 0x10, 0x00, 0x53, 0xf9, 0x01, 0x4b, 0xf5, 0xa3, 0x2b, 0xf4, 0x41, - 0x80, 0x1f, 0x67, 0x58, 0x05, 0xab, 0x27, 0x00, 0xb3, 0x01, 0xff, 0x1a, - 0x9c, 0x20, 0x06, 0x44, 0xd8, 0x4c, 0x08, 0x00, 0x40, 0x49, 0x14, 0xbd, - 0x5b, 0x2b, 0x00, 0x4d, 0x08, 0x88, 0x5d, 0x2b, 0x40, 0x4b, 0x9b, 0xa0, - 0x82, 0xf5, 0x01, 0x5a, 0xa4, 0x22, 0x19, 0xf5, 0x41, 0x80, 0x01, 0xff, - 0x45, 0x6d, 0xe4, 0x7c, 0xf4, 0x01, 0x46, 0x6b, 0x5b, 0x7c, 0xf3, 0x01, - 0x45, 0xfe, 0x59, 0x24, 0xf4, 0x01, 0x46, 0x16, 0x08, 0xbc, 0xf6, 0x41, - 0x45, 0xbd, 0xe4, 0xee, 0xf9, 0x01, 0xa3, 0xa0, 0x8d, 0x01, 0xa4, 0xb9, - 0x88, 0x01, 0xa5, 0x84, 0x85, 0x01, 0x4b, 0x2e, 0x9c, 0x0b, 0x06, 0x00, - 0x04, 0x6d, 0xf0, 0xd5, 0x81, 0x01, 0x47, 0x2d, 0x34, 0x08, 0x27, 0x80, - 0xbd, 0x81, 0x01, 0x4b, 0x33, 0x9e, 0x4d, 0x21, 0x00, 0xac, 0xaa, 0x79, - 0xad, 0xfd, 0x78, 0xae, 0xc8, 0x63, 0xb0, 0xe1, 0x5e, 0x47, 0x1f, 0xd5, - 0x52, 0x26, 0x00, 0xb2, 0xe1, 0x03, 0xb3, 0x88, 0x03, 0xb4, 0xf9, 0x02, - 0xb5, 0xd0, 0x02, 0xb6, 0x06, 0x42, 0x74, 0x43, 0x93, 0xfa, 0x41, 0x06, - 0x8c, 0xdb, 0x06, 0x45, 0x95, 0xe9, 0x51, 0xf9, 0x41, 0x51, 0x12, 0x50, - 0x39, 0x0b, 0x01, 0x07, 0xec, 0x05, 0x01, 0xff, 0xe1, 0x00, 0x0b, 0x81, - 0x8f, 0x02, 0xa2, 0x82, 0x02, 0x42, 0x73, 0x02, 0x17, 0x0b, 0x01, 0xa4, - 0xef, 0x01, 0xe5, 0x08, 0x0b, 0x81, 0xe5, 0x01, 0x42, 0x28, 0x1a, 0x1f, - 0x0b, 0x01, 0xa7, 0xcc, 0x01, 0xa8, 0xbf, 0x01, 0xe9, 0x0c, 0x0b, 0x81, - 0xb5, 0x01, 0x42, 0x82, 0x20, 0x18, 0x0b, 0x01, 0x42, 0x37, 0x01, 0x10, - 0x0b, 0x01, 0x42, 0x68, 0x00, 0x2e, 0x0b, 0x01, 0x42, 0x2a, 0x02, 0x28, - 0x0b, 0x01, 0xae, 0x79, 0xef, 0x0a, 0x0b, 0x81, 0x70, 0x42, 0x6f, 0x02, - 0x1e, 0x0b, 0x01, 0x42, 0x88, 0x00, 0x2d, 0x0b, 0x01, 0xb3, 0x4c, 0xb4, - 0x3a, 0xf5, 0x0e, 0x0b, 0x81, 0x31, 0x42, 0x32, 0x00, 0x2c, 0x0b, 0x01, - 0xb8, 0x19, 0xb9, 0x0d, 0xba, 0x01, 0xff, 0xe5, 0x30, 0x0b, 0x01, 0x42, - 0xb0, 0x01, 0x32, 0x0b, 0x41, 0xe5, 0x2b, 0x0b, 0x01, 0x42, 0x4d, 0x00, - 0x2a, 0x0b, 0x41, 0xe5, 0x11, 0x0b, 0x01, 0x42, 0x32, 0x00, 0x13, 0x0b, - 0x01, 0x42, 0x4d, 0x00, 0x12, 0x0b, 0x41, 0xf5, 0x0f, 0x0b, 0x41, 0xe5, - 0x19, 0x0b, 0x01, 0x42, 0xb0, 0x01, 0x1a, 0x0b, 0x01, 0x42, 0x77, 0x00, - 0x1d, 0x0b, 0x41, 0xe5, 0x2f, 0x0b, 0x01, 0xa8, 0x06, 0x43, 0x8e, 0x06, - 0x34, 0x0b, 0x41, 0xe5, 0x31, 0x0b, 0x01, 0x42, 0x4d, 0x00, 0x33, 0x0b, - 0x41, 0xef, 0x0b, 0x0b, 0x41, 0xe5, 0x25, 0x0b, 0x01, 0xa7, 0x0c, 0x42, - 0xcd, 0x05, 0x27, 0x0b, 0x01, 0x42, 0x4d, 0x00, 0x26, 0x0b, 0x41, 0xe5, - 0x22, 0x0b, 0x01, 0x42, 0x32, 0x00, 0x24, 0x0b, 0x01, 0x42, 0x4d, 0x00, - 0x23, 0x0b, 0x41, 0xe9, 0x0d, 0x0b, 0x41, 0xe5, 0x35, 0x0b, 0x01, 0x42, - 0x2a, 0x02, 0x29, 0x0b, 0x41, 0xe5, 0x14, 0x0b, 0x01, 0x42, 0xdb, 0x09, - 0x15, 0x0b, 0x01, 0x42, 0xb0, 0x01, 0x16, 0x0b, 0x41, 0xe5, 0x09, 0x0b, - 0x41, 0xe5, 0x1b, 0x0b, 0x01, 0x42, 0xb0, 0x01, 0x1c, 0x0b, 0x41, 0xe5, - 0x20, 0x0b, 0x01, 0x42, 0xb0, 0x01, 0x21, 0x0b, 0x41, 0xe1, 0x01, 0x0b, - 0x81, 0x11, 0xe5, 0x06, 0x0b, 0x81, 0x08, 0xee, 0x04, 0x0b, 0x01, 0xef, - 0x02, 0x0b, 0x41, 0xe5, 0x07, 0x0b, 0x41, 0xee, 0x05, 0x0b, 0x01, 0xef, - 0x03, 0x0b, 0x41, 0x47, 0x8b, 0xcf, 0x46, 0xf3, 0x01, 0x4a, 0x84, 0xb1, - 0xb3, 0x20, 0x00, 0x02, 0x1e, 0x00, 0x01, 0xff, 0x49, 0xf5, 0xb4, 0xfa, - 0xf6, 0x01, 0xad, 0x01, 0xff, 0x53, 0x7b, 0x48, 0xe7, 0xf3, 0x01, 0x45, - 0x55, 0x4b, 0x97, 0xf6, 0x41, 0x4b, 0x20, 0x9d, 0x5f, 0xf4, 0x01, 0x49, - 0x26, 0xbd, 0x9b, 0x26, 0x40, 0xa3, 0x48, 0x47, 0x30, 0x60, 0xa6, 0x22, - 0x00, 0xb4, 0x06, 0x55, 0x79, 0x37, 0x43, 0x22, 0x40, 0x04, 0x3f, 0x0d, - 0x27, 0x4c, 0x54, 0x93, 0x32, 0xf6, 0x01, 0xb2, 0x01, 0xff, 0x43, 0x88, - 0x28, 0xd9, 0x2b, 0x80, 0x11, 0x14, 0xb7, 0x44, 0x01, 0xff, 0x53, 0x68, - 0x48, 0xcd, 0xce, 0x01, 0x46, 0x20, 0xe1, 0xe2, 0x26, 0x40, 0x49, 0x3c, - 0x2e, 0x78, 0xf7, 0x41, 0xeb, 0x2a, 0x00, 0x80, 0x04, 0xed, 0x42, 0x20, - 0x40, 0x49, 0x99, 0x1d, 0x17, 0x22, 0x40, 0x4b, 0x49, 0x8d, 0x0a, 0x26, - 0x00, 0x49, 0x05, 0xba, 0x9c, 0x01, 0x41, 0x04, 0xe4, 0x06, 0xbd, 0x05, - 0xe3, 0x12, 0x23, 0x00, 0x43, 0x35, 0x9e, 0x48, 0x26, 0x00, 0x07, 0x02, - 0x33, 0x4b, 0x03, 0xd0, 0x00, 0x11, 0x02, 0x35, 0x00, 0x01, 0xff, 0x4d, - 0xe3, 0x81, 0x9b, 0xf6, 0x01, 0x4a, 0x70, 0xb1, 0xa8, 0xf3, 0x41, 0x0a, - 0x9b, 0x01, 0x06, 0x53, 0xe4, 0x49, 0xb0, 0xfb, 0x41, 0x17, 0x5c, 0x2e, - 0x1c, 0x18, 0xf9, 0x2a, 0x06, 0x57, 0xc6, 0x31, 0xb0, 0xf8, 0x41, 0x49, - 0xa5, 0x01, 0x35, 0x29, 0x00, 0x4a, 0xab, 0x40, 0xb1, 0xf8, 0x01, 0x47, - 0x50, 0x02, 0x34, 0x29, 0x40, 0x49, 0xea, 0x01, 0x36, 0x29, 0x00, 0x4a, - 0xb3, 0x02, 0x37, 0x29, 0x40, 0xa1, 0xd5, 0x04, 0xa3, 0xdc, 0x02, 0x49, - 0x04, 0xb8, 0x8f, 0x05, 0x00, 0xa5, 0xc7, 0x02, 0x49, 0x81, 0x16, 0x89, - 0x05, 0x00, 0x46, 0x9d, 0x63, 0x8a, 0x05, 0x00, 0x5e, 0xe9, 0x13, 0x59, - 0x05, 0x00, 0x4d, 0xc1, 0x34, 0x5e, 0x05, 0x00, 0x07, 0x76, 0x08, 0x01, - 0xff, 0x06, 0xed, 0x05, 0x2d, 0x08, 0x9f, 0x1f, 0x01, 0xff, 0x48, 0x91, - 0xc5, 0x87, 0x05, 0x00, 0x04, 0x05, 0x4f, 0x06, 0x47, 0x64, 0xd7, 0x16, - 0xfb, 0x40, 0x43, 0x1e, 0x41, 0x14, 0xfb, 0x00, 0x43, 0x57, 0x07, 0x15, - 0xfb, 0x00, 0x43, 0xf5, 0x2e, 0x13, 0xfb, 0x00, 0x43, 0xf4, 0xf4, 0x17, - 0xfb, 0x40, 0x43, 0xc2, 0xc0, 0x61, 0x05, 0x00, 0x43, 0x9d, 0x1b, 0x62, - 0x05, 0x00, 0xa3, 0xd6, 0x01, 0x42, 0xf0, 0x10, 0x64, 0x05, 0x00, 0xa5, - 0xbf, 0x01, 0x43, 0xf7, 0xb8, 0x86, 0x05, 0x00, 0xa7, 0xaa, 0x01, 0x42, - 0x0b, 0x00, 0x70, 0x05, 0x00, 0x43, 0x57, 0x07, 0x6b, 0x05, 0x00, 0xaa, - 0x91, 0x01, 0x02, 0x37, 0x01, 0x84, 0x01, 0x44, 0x2d, 0xf1, 0x6c, 0x05, - 0x00, 0x43, 0x2c, 0x05, 0x74, 0x05, 0x00, 0x43, 0xf5, 0x2e, 0x76, 0x05, - 0x00, 0x42, 0x18, 0x29, 0x85, 0x05, 0x00, 0xb0, 0x5e, 0xb2, 0x52, 0xb3, - 0x44, 0xb4, 0x32, 0xb6, 0x26, 0x43, 0xf4, 0xf4, 0x6d, 0x05, 0x00, 0x42, - 0x9a, 0x1a, 0x75, 0x05, 0x80, 0x0d, 0xba, 0x01, 0xff, 0xe1, 0x66, 0x05, - 0x00, 0x42, 0xb0, 0x01, 0x6a, 0x05, 0x40, 0x4c, 0xf5, 0x28, 0x88, 0x05, - 0x00, 0x42, 0xa7, 0x01, 0x82, 0x05, 0x40, 0x42, 0x43, 0x1e, 0x7e, 0x05, - 0x00, 0xef, 0x78, 0x05, 0x40, 0x43, 0x96, 0xc5, 0x7f, 0x05, 0x00, 0xef, - 0x69, 0x05, 0x00, 0x49, 0xbc, 0xc0, 0x60, 0x05, 0x40, 0x42, 0x4e, 0x00, - 0x7d, 0x05, 0x00, 0x42, 0x22, 0x00, 0x77, 0x05, 0x40, 0xe1, 0x7c, 0x05, - 0x00, 0x42, 0x4e, 0x00, 0x80, 0x05, 0x40, 0x42, 0x4e, 0x00, 0x7a, 0x05, - 0x00, 0x43, 0x7f, 0xf4, 0x83, 0x05, 0x40, 0xe8, 0x84, 0x05, 0x00, 0xee, - 0x6f, 0x05, 0x40, 0xe1, 0x71, 0x05, 0x00, 0x43, 0xfd, 0x42, 0x7b, 0x05, - 0x40, 0x43, 0xa5, 0x02, 0x72, 0x05, 0x00, 0x42, 0x29, 0x02, 0x63, 0x05, - 0x40, 0x42, 0x6d, 0x14, 0x65, 0x05, 0x00, 0xe8, 0x67, 0x05, 0x00, 0xf4, - 0x68, 0x05, 0x40, 0xe1, 0x6e, 0x05, 0x00, 0xa8, 0x04, 0xef, 0x81, 0x05, - 0x40, 0xe1, 0x79, 0x05, 0x00, 0x42, 0x4e, 0x00, 0x73, 0x05, 0x40, 0x4c, - 0x40, 0x92, 0x5b, 0x05, 0x00, 0x4f, 0xae, 0x00, 0x5c, 0x05, 0x40, 0x0e, - 0xe5, 0x05, 0x06, 0x44, 0x14, 0x05, 0x5d, 0x05, 0x40, 0x43, 0xc2, 0xc0, - 0x31, 0x05, 0x00, 0x43, 0x9d, 0x1b, 0x32, 0x05, 0x00, 0xa3, 0xc9, 0x01, - 0x42, 0xf0, 0x10, 0x34, 0x05, 0x00, 0xa5, 0xb2, 0x01, 0x43, 0xf7, 0xb8, - 0x56, 0x05, 0x00, 0xa7, 0x9d, 0x01, 0x42, 0x0b, 0x00, 0x40, 0x05, 0x00, - 0x43, 0x57, 0x07, 0x3b, 0x05, 0x00, 0xaa, 0x84, 0x01, 0x02, 0x37, 0x01, - 0x78, 0x44, 0x2d, 0xf1, 0x3c, 0x05, 0x00, 0x43, 0x2c, 0x05, 0x44, 0x05, - 0x00, 0x43, 0xf5, 0x2e, 0x46, 0x05, 0x00, 0x42, 0x18, 0x29, 0x55, 0x05, - 0x00, 0xb0, 0x52, 0xb2, 0x46, 0xb3, 0x38, 0xb4, 0x2c, 0xb6, 0x20, 0x43, - 0xf4, 0xf4, 0x3d, 0x05, 0x00, 0x42, 0x9a, 0x1a, 0x45, 0x05, 0x80, 0x0d, - 0xba, 0x01, 0xff, 0xe1, 0x36, 0x05, 0x00, 0x42, 0xb0, 0x01, 0x3a, 0x05, - 0x40, 0x42, 0xa7, 0x01, 0x52, 0x05, 0x40, 0x42, 0x43, 0x1e, 0x4e, 0x05, - 0x00, 0xef, 0x48, 0x05, 0x40, 0x43, 0x96, 0xc5, 0x4f, 0x05, 0x00, 0xef, - 0x39, 0x05, 0x40, 0x42, 0x4e, 0x00, 0x4d, 0x05, 0x00, 0x42, 0x22, 0x00, - 0x47, 0x05, 0x40, 0xe1, 0x4c, 0x05, 0x00, 0x42, 0x4e, 0x00, 0x50, 0x05, - 0x40, 0x42, 0x4e, 0x00, 0x4a, 0x05, 0x00, 0x43, 0x7f, 0xf4, 0x53, 0x05, - 0x40, 0xe8, 0x54, 0x05, 0x00, 0xee, 0x3f, 0x05, 0x40, 0xe1, 0x41, 0x05, - 0x00, 0x43, 0xfd, 0x42, 0x4b, 0x05, 0x40, 0x43, 0xa5, 0x02, 0x42, 0x05, - 0x00, 0x42, 0x29, 0x02, 0x33, 0x05, 0x40, 0x42, 0x6d, 0x14, 0x35, 0x05, - 0x00, 0xe8, 0x37, 0x05, 0x00, 0xf4, 0x38, 0x05, 0x40, 0xe1, 0x3e, 0x05, - 0x00, 0xa8, 0x04, 0xef, 0x51, 0x05, 0x40, 0xe1, 0x49, 0x05, 0x00, 0x42, - 0x4e, 0x00, 0x43, 0x05, 0x40, 0x50, 0x13, 0x50, 0x5f, 0x05, 0x00, 0x49, - 0x7d, 0x36, 0x5a, 0x05, 0x40, 0x80, 0x68, 0x07, 0xe8, 0x06, 0x01, 0xff, - 0x49, 0xaa, 0xb7, 0x06, 0x06, 0x00, 0x06, 0xef, 0x06, 0x17, 0x4b, 0x4f, - 0x9c, 0x07, 0x06, 0x00, 0x04, 0x6f, 0x02, 0x01, 0xff, 0x4a, 0x00, 0xae, - 0x09, 0x06, 0x00, 0x51, 0x43, 0x5e, 0x0a, 0x06, 0x40, 0x45, 0x12, 0x0b, - 0x68, 0x06, 0x00, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x69, 0x06, 0x00, 0x43, - 0x0e, 0x0b, 0x61, 0x06, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, - 0x60, 0x06, 0x40, 0x44, 0x25, 0x01, 0x63, 0x06, 0x00, 0x42, 0x15, 0x02, - 0x62, 0x06, 0x40, 0x44, 0xe5, 0x1d, 0x67, 0x06, 0x00, 0x42, 0x1c, 0x26, - 0x66, 0x06, 0x40, 0x43, 0xd2, 0x05, 0x65, 0x06, 0x00, 0x43, 0xf6, 0x06, - 0x64, 0x06, 0x40, 0xa2, 0xbc, 0x54, 0xa3, 0xfd, 0x53, 0xa4, 0x9e, 0x53, - 0xa5, 0xfa, 0x52, 0xa6, 0xac, 0x52, 0x02, 0x22, 0x00, 0x90, 0x52, 0x4e, - 0xcc, 0x78, 0x57, 0x06, 0x00, 0x45, 0xaf, 0x50, 0x50, 0x06, 0x80, 0xe1, - 0x51, 0xac, 0xf6, 0x0f, 0x02, 0x6c, 0x00, 0xf9, 0x07, 0x07, 0x1a, 0x3a, - 0xe8, 0x07, 0x05, 0xf6, 0x04, 0xd1, 0x07, 0xb0, 0xa5, 0x07, 0x4d, 0xc1, - 0x34, 0x1f, 0x06, 0x00, 0xb2, 0xed, 0x06, 0xb3, 0xa4, 0x01, 0xb4, 0x2b, - 0xb6, 0x0c, 0x50, 0xad, 0x68, 0x5f, 0x06, 0x00, 0x48, 0x21, 0xcd, 0x59, - 0x06, 0x40, 0x4c, 0xd7, 0x47, 0x8e, 0x08, 0x00, 0x0a, 0x56, 0x77, 0x01, - 0xff, 0x49, 0x9f, 0x12, 0x5c, 0x06, 0x00, 0x56, 0xe4, 0x34, 0x5b, 0x06, - 0x00, 0x4d, 0xed, 0x34, 0x5a, 0x06, 0x40, 0xa1, 0x47, 0x52, 0x76, 0x52, - 0x6c, 0x06, 0x00, 0x04, 0x0e, 0x0b, 0x0c, 0x5a, 0x08, 0x22, 0x1e, 0x06, - 0x00, 0x51, 0xed, 0x5e, 0xe3, 0x08, 0x40, 0x05, 0x5a, 0xe8, 0x21, 0x08, - 0xff, 0x0b, 0x11, 0x09, 0xf1, 0x0b, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xeb, - 0x08, 0x00, 0x45, 0x20, 0x07, 0xee, 0x08, 0x40, 0x45, 0x5c, 0x00, 0xea, - 0x08, 0x00, 0x45, 0x20, 0x07, 0xed, 0x08, 0x40, 0x45, 0x5c, 0x00, 0xec, - 0x08, 0x00, 0x45, 0x20, 0x07, 0xef, 0x08, 0x40, 0x4b, 0x6d, 0x9d, 0x73, - 0xfe, 0x00, 0x45, 0x33, 0x21, 0x40, 0x06, 0xc0, 0x00, 0x06, 0x50, 0x00, - 0x01, 0xff, 0x4e, 0xd0, 0x77, 0x71, 0xfe, 0x00, 0x0b, 0x4b, 0xa1, 0x06, - 0x4e, 0x05, 0x0f, 0x85, 0x08, 0x40, 0x45, 0x56, 0x00, 0x83, 0x08, 0x00, - 0x43, 0x9f, 0x8a, 0x84, 0x08, 0x40, 0x48, 0xe1, 0x59, 0x1b, 0x06, 0x00, - 0x45, 0xe8, 0xe6, 0x51, 0x06, 0x80, 0xa9, 0x05, 0x04, 0x5b, 0x03, 0xd5, - 0x04, 0x05, 0x5e, 0x07, 0xc1, 0x01, 0x53, 0x74, 0x4d, 0xde, 0x06, 0x00, - 0xb5, 0x90, 0x01, 0x06, 0x60, 0x16, 0x01, 0xff, 0x02, 0x3b, 0x01, 0x71, - 0x0a, 0xd8, 0x46, 0x61, 0x44, 0x22, 0x08, 0xbf, 0xfb, 0x00, 0x0a, 0x5f, - 0x75, 0x4b, 0xb4, 0x06, 0x4b, 0x13, 0xa5, 0xc2, 0xfb, 0x40, 0x0a, 0xae, - 0x12, 0x22, 0x08, 0xf2, 0x0b, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xb4, 0xfb, - 0x00, 0x45, 0x20, 0x07, 0xb5, 0xfb, 0x00, 0x0b, 0x51, 0x2c, 0x01, 0xff, - 0x45, 0x5c, 0x00, 0xbd, 0xfb, 0x00, 0x45, 0x20, 0x07, 0xbe, 0xfb, 0x40, - 0x45, 0x5c, 0x00, 0xb6, 0xfb, 0x00, 0x45, 0x20, 0x07, 0xb7, 0xfb, 0x00, - 0x13, 0x9c, 0x01, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xb8, 0xfb, 0x00, 0x45, - 0x20, 0x07, 0xb9, 0xfb, 0x40, 0x45, 0x5c, 0x00, 0xc0, 0xfb, 0x00, 0x45, - 0x20, 0x07, 0xc1, 0xfb, 0x40, 0x45, 0x5c, 0x00, 0xba, 0xfb, 0x00, 0x45, - 0x20, 0x07, 0xbb, 0xfb, 0x40, 0x02, 0xc6, 0x00, 0x06, 0x57, 0x81, 0x31, - 0xbc, 0xfb, 0x40, 0x45, 0x5c, 0x00, 0xb2, 0xfb, 0x00, 0x45, 0x20, 0x07, - 0xb3, 0xfb, 0x40, 0x4c, 0x0c, 0x8d, 0x56, 0x06, 0x00, 0x43, 0x92, 0x36, - 0x52, 0x06, 0x80, 0x06, 0x58, 0xb1, 0x2a, 0x9d, 0x08, 0x40, 0x80, 0x01, - 0xff, 0x45, 0x20, 0x07, 0xd0, 0x08, 0x00, 0x4d, 0x5f, 0x03, 0x7e, 0xfe, - 0x00, 0x4b, 0xfd, 0x6d, 0x7f, 0xfe, 0x40, 0x45, 0xf3, 0x5e, 0x19, 0x06, - 0x00, 0x02, 0x0c, 0x08, 0xf8, 0x02, 0x05, 0x48, 0x0b, 0x6a, 0x45, 0xaf, - 0x50, 0x1a, 0x06, 0x00, 0x04, 0x08, 0x05, 0x13, 0x43, 0x9f, 0x8a, 0xe5, - 0x06, 0x00, 0x43, 0x4d, 0x00, 0xe6, 0x06, 0xc0, 0x00, 0x5b, 0xf1, 0x19, - 0xc5, 0x0e, 0x41, 0x44, 0x1e, 0x21, 0xed, 0x06, 0x00, 0x44, 0x00, 0x46, - 0xfb, 0x0e, 0x81, 0x3a, 0x44, 0xb1, 0xf2, 0xe3, 0x06, 0x00, 0xb7, 0x01, - 0xff, 0x42, 0xd2, 0x2d, 0xd3, 0x08, 0x00, 0x04, 0x57, 0x25, 0x01, 0xff, - 0xa9, 0x18, 0x45, 0x17, 0x4b, 0xff, 0x0e, 0x01, 0x44, 0x4d, 0xf2, 0xfe, - 0x0e, 0x01, 0x45, 0xd5, 0xea, 0xfd, 0x0e, 0x01, 0x47, 0x53, 0xd6, 0x9b, - 0x08, 0x40, 0x45, 0x78, 0xe8, 0x9a, 0x08, 0x00, 0x46, 0xfa, 0xdf, 0x99, - 0x08, 0x40, 0x4b, 0x3a, 0x98, 0xd9, 0x08, 0x40, 0x43, 0x56, 0x07, 0xd6, - 0x08, 0x00, 0x54, 0x97, 0x41, 0xe1, 0x06, 0x00, 0xa6, 0xef, 0x01, 0x44, - 0x59, 0x38, 0xda, 0x06, 0x00, 0xac, 0xbf, 0x01, 0xad, 0xa5, 0x01, 0x44, - 0x00, 0x46, 0xe8, 0x06, 0x80, 0x97, 0x01, 0x43, 0x43, 0x14, 0xd7, 0x08, - 0x00, 0x4c, 0xf8, 0x94, 0xdf, 0x06, 0x00, 0xb3, 0x77, 0xb4, 0x69, 0x58, - 0xb9, 0x2b, 0xe0, 0x06, 0x00, 0xb7, 0x1c, 0x43, 0x4d, 0x00, 0xe7, 0x06, + 0x01, 0xb8, 0x32, 0x00, 0x42, 0x15, 0x02, 0xb7, 0x32, 0x40, 0x44, 0x06, + 0x1f, 0xbc, 0x32, 0x00, 0x42, 0x09, 0x24, 0xbb, 0x32, 0x40, 0x4d, 0x0f, + 0x12, 0x4b, 0x32, 0x00, 0xe5, 0xb6, 0x32, 0x40, 0x43, 0xf9, 0x05, 0xba, + 0x32, 0x00, 0x43, 0xf6, 0x06, 0xb9, 0x32, 0x40, 0x43, 0xe9, 0x09, 0x6e, + 0x24, 0x00, 0xf9, 0xbf, 0x32, 0xc0, 0x00, 0x50, 0x78, 0x62, 0x4c, 0x32, + 0x40, 0x04, 0xc9, 0x00, 0x06, 0x45, 0xe7, 0x72, 0x6a, 0x24, 0x40, 0x43, + 0xe9, 0x09, 0x71, 0x24, 0x00, 0x51, 0x77, 0x62, 0x4f, 0x32, 0x40, 0x44, + 0xb5, 0x20, 0x96, 0x22, 0x00, 0x69, 0xb7, 0x04, 0x36, 0x2a, 0x40, 0x05, + 0x06, 0x06, 0x06, 0x48, 0xed, 0x00, 0xc0, 0x29, 0x40, 0x0f, 0x0b, 0x06, + 0x6d, 0x0d, 0x9b, 0x08, 0x01, 0xff, 0xe1, 0xd0, 0x24, 0x00, 0xe2, 0xd1, + 0x24, 0x00, 0xe3, 0xd2, 0x24, 0x00, 0xe4, 0xd3, 0x24, 0x00, 0xe5, 0xd4, + 0x24, 0x00, 0xe6, 0xd5, 0x24, 0x00, 0xe7, 0xd6, 0x24, 0x00, 0xe8, 0xd7, + 0x24, 0x00, 0xe9, 0xd8, 0x24, 0x00, 0xea, 0xd9, 0x24, 0x00, 0xeb, 0xda, + 0x24, 0x00, 0xec, 0xdb, 0x24, 0x00, 0xed, 0xdc, 0x24, 0x00, 0xee, 0xdd, + 0x24, 0x00, 0xef, 0xde, 0x24, 0x00, 0xf0, 0xdf, 0x24, 0x00, 0xf1, 0xe0, + 0x24, 0x00, 0xf2, 0xe1, 0x24, 0x00, 0xf3, 0xe2, 0x24, 0x00, 0xf4, 0xe3, + 0x24, 0x00, 0xf5, 0xe4, 0x24, 0x00, 0xf6, 0xe5, 0x24, 0x00, 0xf7, 0xe6, + 0x24, 0x00, 0xf8, 0xe7, 0x24, 0x00, 0xf9, 0xe8, 0x24, 0x00, 0xfa, 0xe9, + 0x24, 0x40, 0xe1, 0xb6, 0x24, 0x00, 0xe2, 0xb7, 0x24, 0x00, 0xe3, 0xb8, + 0x24, 0x00, 0xe4, 0xb9, 0x24, 0x00, 0xe5, 0xba, 0x24, 0x00, 0xe6, 0xbb, + 0x24, 0x00, 0xe7, 0xbc, 0x24, 0x00, 0xe8, 0xbd, 0x24, 0x00, 0xe9, 0xbe, + 0x24, 0x00, 0xea, 0xbf, 0x24, 0x00, 0xeb, 0xc0, 0x24, 0x00, 0xec, 0xc1, + 0x24, 0x00, 0xed, 0xc2, 0x24, 0x00, 0xee, 0xc3, 0x24, 0x00, 0xef, 0xc4, + 0x24, 0x00, 0xf0, 0xc5, 0x24, 0x00, 0xf1, 0xc6, 0x24, 0x00, 0xf2, 0xc7, + 0x24, 0x00, 0xf3, 0xc8, 0x24, 0x00, 0xf4, 0xc9, 0x24, 0x00, 0xf5, 0xca, + 0x24, 0x00, 0xf6, 0xcb, 0x24, 0x00, 0xf7, 0xcc, 0x24, 0x00, 0xf8, 0xcd, + 0x24, 0x00, 0xf9, 0xce, 0x24, 0x00, 0xfa, 0xcf, 0x24, 0x40, 0x08, 0x67, + 0xc9, 0x11, 0x10, 0xa4, 0x55, 0x01, 0xff, 0x46, 0x60, 0xe0, 0x7c, 0x32, + 0x00, 0x45, 0xaf, 0xed, 0x7d, 0x32, 0x40, 0xe1, 0xd0, 0x32, 0x00, 0xe5, + 0xd3, 0x32, 0x00, 0xa8, 0xb3, 0x01, 0xe9, 0xd1, 0x32, 0x00, 0xab, 0x98, + 0x01, 0xad, 0x81, 0x01, 0xae, 0x6b, 0xef, 0xd4, 0x32, 0x00, 0xb2, 0x51, + 0xb3, 0x3b, 0xb4, 0x25, 0xf5, 0xd2, 0x32, 0x00, 0xb7, 0x0f, 0xb9, 0x01, + 0xff, 0xe1, 0xf3, 0x32, 0x00, 0xef, 0xf5, 0x32, 0x00, 0xf5, 0xf4, 0x32, + 0x40, 0xe1, 0xfb, 0x32, 0x00, 0xe5, 0xfd, 0x32, 0x00, 0xe9, 0xfc, 0x32, + 0x00, 0xef, 0xfe, 0x32, 0x40, 0xe1, 0xdf, 0x32, 0x00, 0xe5, 0xe2, 0x32, + 0x00, 0xe9, 0xe0, 0x32, 0x00, 0xef, 0xe3, 0x32, 0x00, 0xf5, 0xe1, 0x32, + 0x40, 0xe1, 0xda, 0x32, 0x00, 0xe5, 0xdd, 0x32, 0x00, 0xe9, 0xdb, 0x32, + 0x00, 0xef, 0xde, 0x32, 0x00, 0xf5, 0xdc, 0x32, 0x40, 0xe1, 0xf6, 0x32, + 0x00, 0xe5, 0xf9, 0x32, 0x00, 0xe9, 0xf7, 0x32, 0x00, 0xef, 0xfa, 0x32, + 0x00, 0xf5, 0xf8, 0x32, 0x40, 0xe1, 0xe4, 0x32, 0x00, 0xe5, 0xe7, 0x32, + 0x00, 0xe9, 0xe5, 0x32, 0x00, 0xef, 0xe8, 0x32, 0x00, 0xf5, 0xe6, 0x32, + 0x40, 0xe1, 0xee, 0x32, 0x00, 0xe5, 0xf1, 0x32, 0x00, 0xe9, 0xef, 0x32, + 0x00, 0xef, 0xf2, 0x32, 0x00, 0xf5, 0xf0, 0x32, 0x40, 0xe1, 0xd5, 0x32, + 0x00, 0xe5, 0xd8, 0x32, 0x00, 0xe9, 0xd6, 0x32, 0x00, 0xef, 0xd9, 0x32, + 0x00, 0xf5, 0xd7, 0x32, 0x40, 0xe1, 0xe9, 0x32, 0x00, 0xe5, 0xec, 0x32, + 0x00, 0xe9, 0xea, 0x32, 0x00, 0xef, 0xed, 0x32, 0x00, 0xf5, 0xeb, 0x32, + 0x40, 0x09, 0xfb, 0xb0, 0x13, 0x51, 0x47, 0x5f, 0xc8, 0xf6, 0x01, 0x1b, + 0xc3, 0x1e, 0x01, 0xff, 0xe3, 0x2b, 0xf1, 0x01, 0xf2, 0x2c, 0xf1, 0x41, + 0xa1, 0xe5, 0x02, 0xa3, 0xc7, 0x02, 0xa5, 0xac, 0x02, 0xa6, 0x89, 0x02, + 0xa8, 0xfa, 0x01, 0x44, 0x45, 0xc7, 0xa0, 0x32, 0x00, 0xab, 0xe5, 0x01, + 0xac, 0xd0, 0x01, 0xad, 0xb3, 0x01, 0xae, 0x9b, 0x01, 0x43, 0x7a, 0x0b, + 0x80, 0x32, 0x00, 0x45, 0x1a, 0xcc, 0x9e, 0x32, 0x00, 0x48, 0x88, 0x36, + 0x44, 0x32, 0x00, 0xb2, 0x6c, 0xb3, 0x23, 0xb4, 0x0f, 0xb7, 0x01, 0xff, + 0x44, 0x8a, 0x00, 0x8c, 0x32, 0x00, 0x43, 0x3b, 0x2f, 0x8d, 0x32, 0x40, + 0x42, 0x92, 0x01, 0x89, 0x32, 0x00, 0x44, 0x25, 0x01, 0x82, 0x32, 0x00, + 0x42, 0x15, 0x02, 0x81, 0x32, 0x40, 0x45, 0x2a, 0xeb, 0x46, 0x32, 0x00, + 0xa5, 0x33, 0x42, 0x09, 0x24, 0x85, 0x32, 0x00, 0x46, 0x9e, 0xe4, 0x93, + 0x32, 0x00, 0x46, 0x04, 0xe5, 0x95, 0x32, 0x00, 0xb4, 0x13, 0xb5, 0x01, + 0xff, 0x46, 0x18, 0xe3, 0x9c, 0x32, 0x00, 0xee, 0x90, 0x32, 0x00, 0x47, + 0x9b, 0xda, 0xac, 0x32, 0x40, 0x43, 0x35, 0x01, 0x91, 0x32, 0x00, 0x43, + 0xa5, 0xfa, 0xab, 0x32, 0x40, 0x44, 0x50, 0xf5, 0x99, 0x32, 0x00, 0x43, + 0x07, 0x1f, 0x86, 0x32, 0x40, 0xa5, 0x06, 0x44, 0xc9, 0x00, 0xa8, 0x32, + 0x40, 0x46, 0xa8, 0xe3, 0xaa, 0x32, 0x00, 0xb3, 0x01, 0xff, 0x45, 0x53, + 0x5f, 0xae, 0x32, 0x00, 0xf4, 0xa1, 0x32, 0x40, 0x43, 0x2b, 0x05, 0x94, + 0x32, 0x00, 0xa9, 0x01, 0xff, 0x43, 0xca, 0x00, 0xb0, 0x32, 0x00, 0x42, + 0xf1, 0x05, 0x88, 0x32, 0x40, 0x43, 0x67, 0x00, 0x9a, 0x32, 0x00, 0xa5, + 0x06, 0x43, 0xcd, 0x02, 0x8a, 0x32, 0x40, 0x46, 0xd8, 0xe0, 0xa9, 0x32, + 0x00, 0x43, 0x12, 0x00, 0x8e, 0x32, 0x40, 0x44, 0x00, 0xee, 0x98, 0x32, + 0x00, 0x43, 0xc4, 0x00, 0xa7, 0x32, 0x00, 0x42, 0xd1, 0x00, 0xa6, 0x32, + 0x40, 0x4b, 0xb8, 0xa2, 0x45, 0x32, 0x00, 0x43, 0xc2, 0x98, 0x47, 0x32, + 0x40, 0x43, 0x2f, 0x08, 0x92, 0x32, 0x00, 0x43, 0x3f, 0x00, 0xa4, 0x32, + 0x40, 0x45, 0x7a, 0x22, 0x9b, 0x32, 0x00, 0xa9, 0x06, 0x43, 0xf6, 0x06, + 0x83, 0x32, 0x40, 0x47, 0x44, 0xd9, 0x96, 0x32, 0x00, 0x42, 0x88, 0x00, + 0x8b, 0x32, 0x00, 0x42, 0x32, 0x00, 0x84, 0x32, 0x40, 0x44, 0x95, 0x75, + 0x8f, 0x32, 0x00, 0x44, 0xc9, 0x00, 0x87, 0x32, 0x00, 0x49, 0x60, 0xc2, + 0xad, 0x32, 0x00, 0x48, 0x67, 0xd2, 0x9d, 0x32, 0x40, 0x45, 0x74, 0x02, + 0xa5, 0x32, 0x00, 0xaf, 0x01, 0xff, 0x4c, 0x68, 0x8b, 0x97, 0x32, 0x00, + 0x42, 0x3d, 0x1e, 0xa2, 0x32, 0x00, 0x45, 0x5f, 0xdb, 0xa3, 0x32, 0x40, + 0x45, 0xfd, 0xea, 0x51, 0xf2, 0x01, 0x48, 0xf7, 0xca, 0x50, 0xf2, 0x01, + 0x47, 0xf0, 0xc8, 0xaf, 0x32, 0x00, 0x48, 0x7f, 0xd1, 0x9f, 0x32, 0x40, + 0x06, 0x46, 0xd7, 0x12, 0x5b, 0x20, 0x1c, 0xb2, 0x27, 0x00, 0x58, 0xec, + 0x2b, 0x89, 0x23, 0x00, 0x4b, 0x98, 0xa9, 0x6f, 0xf1, 0x41, 0xa3, 0xaa, + 0x01, 0x45, 0xbc, 0xaa, 0x6d, 0x32, 0x80, 0x9c, 0x01, 0x45, 0xdd, 0xd1, + 0x67, 0x32, 0x80, 0x89, 0x01, 0xab, 0x6d, 0x45, 0x9a, 0xee, 0x64, 0x32, + 0x80, 0x60, 0x45, 0x0d, 0xef, 0x61, 0x32, 0x80, 0x53, 0xb0, 0x37, 0x45, + 0x52, 0xf0, 0x63, 0x32, 0x80, 0x2a, 0x44, 0x35, 0xc5, 0x66, 0x32, 0x80, + 0x1d, 0xb4, 0x01, 0xff, 0x46, 0x47, 0xdc, 0x6b, 0x32, 0x80, 0x0d, 0x45, + 0xa4, 0xd3, 0x62, 0x32, 0xc0, 0x00, 0x42, 0x19, 0x00, 0x70, 0x32, 0x40, + 0x42, 0x19, 0x00, 0x79, 0x32, 0x40, 0x42, 0x19, 0x00, 0x74, 0x32, 0x40, + 0x42, 0x19, 0x00, 0x71, 0x32, 0x40, 0x46, 0x81, 0xc8, 0x6c, 0x32, 0x80, + 0x0d, 0x44, 0x0d, 0x89, 0x65, 0x32, 0xc0, 0x00, 0x42, 0x19, 0x00, 0x73, + 0x32, 0x40, 0x42, 0x19, 0x00, 0x7a, 0x32, 0x40, 0x42, 0x19, 0x00, 0x6f, + 0x32, 0x40, 0x42, 0x19, 0x00, 0x72, 0x32, 0x40, 0x46, 0x79, 0xc8, 0x6a, + 0x32, 0x80, 0x0d, 0x45, 0x12, 0xa8, 0x60, 0x32, 0xc0, 0x00, 0x42, 0x19, + 0x00, 0x6e, 0x32, 0x40, 0x42, 0x19, 0x00, 0x78, 0x32, 0x40, 0x80, 0x01, + 0xff, 0xe1, 0x75, 0x32, 0x00, 0xf5, 0x7e, 0x32, 0x40, 0x42, 0x19, 0x00, + 0x7b, 0x32, 0x40, 0x46, 0xa9, 0xd5, 0x69, 0x32, 0x80, 0x0d, 0x44, 0xaa, + 0xd5, 0x68, 0x32, 0xc0, 0x00, 0x42, 0x19, 0x00, 0x76, 0x32, 0x40, 0x42, + 0x19, 0x00, 0x77, 0x32, 0x40, 0x43, 0xf9, 0x03, 0x9d, 0x22, 0x00, 0xa9, + 0x0f, 0xaf, 0x01, 0xff, 0x61, 0xba, 0x0e, 0x0f, 0xf1, 0x01, 0x4a, 0x09, + 0x39, 0x99, 0x22, 0x40, 0x04, 0xf1, 0x06, 0x11, 0x08, 0x90, 0x34, 0x01, + 0xff, 0x43, 0x5b, 0x03, 0x38, 0x2a, 0x00, 0x44, 0xd7, 0x0e, 0x98, 0x22, + 0x40, 0x45, 0x7e, 0x0b, 0x67, 0x24, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, + 0x68, 0x24, 0x00, 0x43, 0x7a, 0x0b, 0x60, 0x24, 0x00, 0xb3, 0x14, 0xb4, + 0x06, 0x44, 0x80, 0x1f, 0xea, 0x24, 0x40, 0x44, 0x25, 0x01, 0x62, 0x24, + 0x00, 0x42, 0x15, 0x02, 0x61, 0x24, 0x40, 0x44, 0x06, 0x1f, 0x66, 0x24, + 0x00, 0x42, 0x09, 0x24, 0x65, 0x24, 0x40, 0x43, 0xf9, 0x05, 0x64, 0x24, + 0x00, 0x43, 0xf6, 0x06, 0x63, 0x24, 0x40, 0x58, 0xc3, 0x0e, 0x6e, 0xf1, + 0x01, 0xe3, 0x6d, 0xf1, 0x01, 0xe4, 0x2d, 0xf1, 0x01, 0x04, 0x8f, 0x08, + 0x01, 0xff, 0x80, 0x06, 0x49, 0x32, 0xc0, 0xd2, 0x26, 0x40, 0x46, 0xb6, + 0xe1, 0x02, 0xf9, 0x81, 0x06, 0x46, 0x34, 0xe5, 0x40, 0xf5, 0x41, 0x06, + 0x50, 0x00, 0x01, 0xff, 0x49, 0x08, 0x49, 0x00, 0xf9, 0x01, 0x48, 0x44, + 0x0a, 0x01, 0xf9, 0x41, 0xaf, 0x06, 0x45, 0xd6, 0x22, 0xbf, 0x29, 0x40, + 0x44, 0xe4, 0xf6, 0xbf, 0x2b, 0x00, 0x64, 0x4c, 0x0a, 0xf3, 0xf7, 0x41, + 0x0c, 0xa1, 0x0b, 0x06, 0x50, 0x7a, 0x6a, 0x9b, 0x22, 0x40, 0x46, 0xcd, + 0x00, 0x0e, 0xf1, 0x01, 0x56, 0x85, 0x34, 0xbc, 0x29, 0x40, 0x7e, 0x00, + 0x00, 0xba, 0x29, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x61, 0xf4, 0x0d, + 0xd5, 0x25, 0x00, 0x63, 0x21, 0x0b, 0xf1, 0xf7, 0x01, 0x4e, 0x0b, 0x00, + 0xb5, 0x29, 0x00, 0xac, 0x30, 0x50, 0xca, 0x69, 0xd1, 0x25, 0x00, 0xb3, + 0x1c, 0x63, 0x16, 0x0c, 0xc3, 0x29, 0x00, 0x06, 0x6d, 0x02, 0x06, 0x4d, + 0xc1, 0x8e, 0xcd, 0x25, 0x40, 0x4a, 0x5f, 0x0a, 0xd3, 0x25, 0x00, 0x54, + 0x9b, 0x47, 0xd4, 0x25, 0x40, 0x58, 0x8c, 0x2b, 0xc2, 0x29, 0x00, 0x4d, + 0x25, 0x8e, 0xbb, 0x29, 0x40, 0x4e, 0xac, 0x72, 0xd0, 0x25, 0x00, 0x4f, + 0xe5, 0x74, 0xd2, 0x25, 0x40, 0xa1, 0xfa, 0x08, 0xa5, 0x92, 0x02, 0xa9, + 0xda, 0x01, 0xaf, 0x0c, 0x4c, 0xa4, 0x99, 0x84, 0xf3, 0x01, 0x44, 0x8c, + 0xe0, 0xea, 0x26, 0x40, 0x4a, 0x20, 0xae, 0x6b, 0xf3, 0x01, 0x47, 0xcc, + 0xda, 0x62, 0xf9, 0x01, 0x08, 0xef, 0xcf, 0x01, 0xff, 0x07, 0x13, 0x06, + 0x34, 0x07, 0x37, 0x3c, 0x01, 0xff, 0x44, 0xf5, 0x06, 0xc8, 0x0f, 0x01, + 0x43, 0x7a, 0x0b, 0xc5, 0x0f, 0x81, 0x1c, 0xb4, 0x01, 0xff, 0x42, 0x92, + 0x01, 0xc9, 0x0f, 0x01, 0x44, 0x25, 0x01, 0xc7, 0x0f, 0x01, 0xb7, 0x01, + 0xff, 0x44, 0xe9, 0x1e, 0xca, 0x0f, 0x01, 0xef, 0xc6, 0x0f, 0x41, 0x48, + 0x3e, 0x12, 0xcb, 0x0f, 0x41, 0xa1, 0x75, 0x44, 0x20, 0xf5, 0xb2, 0x0f, + 0x01, 0x4a, 0x52, 0xae, 0xb7, 0x0f, 0x01, 0x46, 0x6d, 0x4c, 0xb4, 0x0f, + 0x01, 0x45, 0x5a, 0xb0, 0xb3, 0x0f, 0x01, 0x42, 0xb0, 0x01, 0xb5, 0x0f, + 0x81, 0x50, 0x44, 0xb0, 0xf6, 0xbb, 0x0f, 0x01, 0x46, 0x8a, 0xe3, 0xbc, + 0x0f, 0x01, 0x43, 0xb4, 0x05, 0xbd, 0x0f, 0x01, 0x43, 0x18, 0x24, 0xbe, + 0x0f, 0x01, 0x42, 0x6f, 0x02, 0xc1, 0x0f, 0x01, 0x44, 0x8a, 0x69, 0xc2, + 0x0f, 0x01, 0xb3, 0x18, 0x43, 0x53, 0xca, 0xc4, 0x0f, 0x01, 0x43, 0x1c, + 0x8f, 0xb6, 0x0f, 0x01, 0x44, 0xfd, 0x54, 0xba, 0x0f, 0x01, 0x45, 0xf7, + 0x54, 0xb8, 0x0f, 0x41, 0x45, 0x49, 0xea, 0xbf, 0x0f, 0x01, 0x43, 0x48, + 0x17, 0xc3, 0x0f, 0x01, 0x4a, 0x34, 0xb3, 0xb1, 0x0f, 0x41, 0x42, 0x53, + 0x00, 0xb9, 0x0f, 0x41, 0x44, 0x3b, 0x3f, 0xb0, 0x0f, 0x01, 0x43, 0xa0, + 0x1b, 0xc0, 0x0f, 0x41, 0x44, 0x4c, 0x8f, 0x27, 0x26, 0x00, 0x44, 0x90, + 0x01, 0x14, 0xf4, 0x01, 0x42, 0x04, 0x1c, 0xd2, 0xf9, 0x81, 0x1c, 0x0b, + 0x2b, 0xa5, 0x0c, 0x45, 0xe9, 0xef, 0x3f, 0xf4, 0x01, 0x43, 0x60, 0x0f, + 0xb7, 0x26, 0x40, 0x4d, 0x55, 0x8d, 0xf2, 0x6f, 0x01, 0x4e, 0x1c, 0x81, + 0xf3, 0x6f, 0x41, 0x4c, 0x44, 0x99, 0xb8, 0xf6, 0x41, 0x02, 0x36, 0x01, + 0xcd, 0x06, 0xa5, 0xbe, 0x06, 0x4b, 0xc2, 0xa6, 0xc1, 0xf3, 0x01, 0xb2, + 0x06, 0x45, 0x01, 0xf1, 0x30, 0xf3, 0x41, 0x05, 0x76, 0xef, 0x1a, 0xb2, + 0x01, 0xff, 0x43, 0x3e, 0xa3, 0x52, 0xf3, 0x01, 0x02, 0x09, 0x00, 0x01, + 0xff, 0x47, 0x4d, 0xd5, 0x38, 0xf3, 0x01, 0x46, 0x16, 0x08, 0xbe, 0xce, + 0x41, 0x07, 0x13, 0x06, 0x89, 0x03, 0x0d, 0x9b, 0x08, 0x01, 0xff, 0xe1, + 0x70, 0xab, 0x00, 0xa4, 0xdf, 0x02, 0xe5, 0x71, 0xab, 0x00, 0xa7, 0xc0, + 0x02, 0xa8, 0x9f, 0x02, 0xe9, 0x72, 0xab, 0x00, 0x42, 0x1b, 0x02, 0x77, + 0xab, 0x00, 0xac, 0xfa, 0x01, 0xad, 0xdf, 0x01, 0xae, 0xbf, 0x01, 0xef, + 0x73, 0xab, 0x00, 0x02, 0x7c, 0x00, 0x9e, 0x01, 0xf3, 0x9d, 0xab, 0x80, + 0x80, 0x01, 0xb4, 0x3d, 0xf5, 0x74, 0xab, 0x00, 0xf6, 0x75, 0xab, 0x00, + 0xb7, 0x1b, 0xb9, 0x01, 0xff, 0xe1, 0xbf, 0xab, 0x00, 0xe5, 0xf8, 0x13, + 0x00, 0xe9, 0xf9, 0x13, 0x00, 0xef, 0xfa, 0x13, 0x00, 0xf5, 0xfb, 0x13, + 0x00, 0xf6, 0xfc, 0x13, 0x40, 0xe1, 0xb9, 0xab, 0x00, 0xe5, 0xba, 0xab, + 0x00, 0xe9, 0xbb, 0xab, 0x00, 0xef, 0xbc, 0xab, 0x00, 0xf5, 0xbd, 0xab, + 0x00, 0xf6, 0xbe, 0xab, 0x40, 0xe1, 0xa4, 0xab, 0x00, 0xe5, 0xa6, 0xab, + 0x00, 0xe9, 0xa8, 0xab, 0x00, 0xac, 0x1b, 0xb3, 0x01, 0xff, 0xe1, 0xb3, + 0xab, 0x00, 0xe5, 0xb4, 0xab, 0x00, 0xe9, 0xb5, 0xab, 0x00, 0xef, 0xb6, + 0xab, 0x00, 0xf5, 0xb7, 0xab, 0x00, 0xf6, 0xb8, 0xab, 0x40, 0xe1, 0xad, + 0xab, 0x00, 0xe5, 0xae, 0xab, 0x00, 0xe9, 0xaf, 0xab, 0x00, 0xef, 0xb0, + 0xab, 0x00, 0xf5, 0xb1, 0xab, 0x00, 0xf6, 0xb2, 0xab, 0x40, 0xe1, 0x9c, + 0xab, 0x00, 0xe5, 0x9e, 0xab, 0x00, 0xe9, 0x9f, 0xab, 0x00, 0xef, 0xa0, + 0xab, 0x00, 0xf5, 0xa1, 0xab, 0x00, 0xf6, 0xa2, 0xab, 0x40, 0xe1, 0x96, + 0xab, 0x00, 0xe5, 0x97, 0xab, 0x00, 0xe9, 0x98, 0xab, 0x00, 0xef, 0x99, + 0xab, 0x00, 0xf5, 0x9a, 0xab, 0x00, 0xf6, 0x9b, 0xab, 0x40, 0xe1, 0x8e, + 0xab, 0x80, 0x14, 0xe5, 0x91, 0xab, 0x00, 0xe9, 0x92, 0xab, 0x00, 0xef, + 0x93, 0xab, 0x00, 0xf5, 0x94, 0xab, 0x00, 0xf6, 0x95, 0xab, 0x40, 0xe8, + 0x90, 0xab, 0x40, 0xe1, 0x89, 0xab, 0x00, 0xe5, 0x8a, 0xab, 0x00, 0xe9, + 0x8b, 0xab, 0x00, 0xef, 0x8c, 0xab, 0x00, 0xf5, 0x8d, 0xab, 0x00, 0xf6, + 0xfd, 0x13, 0x40, 0xe1, 0x83, 0xab, 0x00, 0xe5, 0x84, 0xab, 0x00, 0xe9, + 0x85, 0xab, 0x00, 0xef, 0x86, 0xab, 0x00, 0xf5, 0x87, 0xab, 0x00, 0xf6, + 0x88, 0xab, 0x40, 0xe1, 0x7d, 0xab, 0x00, 0xe5, 0x7e, 0xab, 0x00, 0xe9, + 0x7f, 0xab, 0x00, 0x42, 0x2a, 0x05, 0x8f, 0xab, 0x00, 0xef, 0x80, 0xab, + 0x00, 0xf5, 0x81, 0xab, 0x00, 0xf6, 0x82, 0xab, 0x40, 0xe1, 0x76, 0xab, + 0x00, 0xe5, 0x78, 0xab, 0x00, 0xe9, 0x79, 0xab, 0x00, 0xef, 0x7a, 0xab, + 0x00, 0xf5, 0x7b, 0xab, 0x00, 0xf6, 0x7c, 0xab, 0x40, 0xe1, 0xa3, 0xab, + 0x00, 0xe5, 0xa5, 0xab, 0x00, 0xe9, 0xa7, 0xab, 0x00, 0x42, 0x74, 0x00, + 0xac, 0xab, 0x00, 0xef, 0xa9, 0xab, 0x00, 0xf5, 0xaa, 0xab, 0x00, 0xf6, + 0xab, 0xab, 0x40, 0xe1, 0xa0, 0x13, 0x00, 0xa4, 0xdf, 0x02, 0xe5, 0xa1, + 0x13, 0x00, 0xa7, 0xc0, 0x02, 0xa8, 0x9f, 0x02, 0xe9, 0xa2, 0x13, 0x00, + 0x42, 0x1b, 0x02, 0xa7, 0x13, 0x00, 0xac, 0xfa, 0x01, 0xad, 0xdf, 0x01, + 0xae, 0xbf, 0x01, 0xef, 0xa3, 0x13, 0x00, 0x02, 0x7c, 0x00, 0x9e, 0x01, + 0xf3, 0xcd, 0x13, 0x80, 0x80, 0x01, 0xb4, 0x3d, 0xf5, 0xa4, 0x13, 0x00, + 0xf6, 0xa5, 0x13, 0x00, 0xb7, 0x1b, 0xb9, 0x01, 0xff, 0xe1, 0xef, 0x13, + 0x00, 0xe5, 0xf0, 0x13, 0x00, 0xe9, 0xf1, 0x13, 0x00, 0xef, 0xf2, 0x13, + 0x00, 0xf5, 0xf3, 0x13, 0x00, 0xf6, 0xf4, 0x13, 0x40, 0xe1, 0xe9, 0x13, + 0x00, 0xe5, 0xea, 0x13, 0x00, 0xe9, 0xeb, 0x13, 0x00, 0xef, 0xec, 0x13, + 0x00, 0xf5, 0xed, 0x13, 0x00, 0xf6, 0xee, 0x13, 0x40, 0xe1, 0xd4, 0x13, + 0x00, 0xe5, 0xd6, 0x13, 0x00, 0xe9, 0xd8, 0x13, 0x00, 0xac, 0x1b, 0xb3, + 0x01, 0xff, 0xe1, 0xe3, 0x13, 0x00, 0xe5, 0xe4, 0x13, 0x00, 0xe9, 0xe5, + 0x13, 0x00, 0xef, 0xe6, 0x13, 0x00, 0xf5, 0xe7, 0x13, 0x00, 0xf6, 0xe8, + 0x13, 0x40, 0xe1, 0xdd, 0x13, 0x00, 0xe5, 0xde, 0x13, 0x00, 0xe9, 0xdf, + 0x13, 0x00, 0xef, 0xe0, 0x13, 0x00, 0xf5, 0xe1, 0x13, 0x00, 0xf6, 0xe2, + 0x13, 0x40, 0xe1, 0xcc, 0x13, 0x00, 0xe5, 0xce, 0x13, 0x00, 0xe9, 0xcf, + 0x13, 0x00, 0xef, 0xd0, 0x13, 0x00, 0xf5, 0xd1, 0x13, 0x00, 0xf6, 0xd2, + 0x13, 0x40, 0xe1, 0xc6, 0x13, 0x00, 0xe5, 0xc7, 0x13, 0x00, 0xe9, 0xc8, + 0x13, 0x00, 0xef, 0xc9, 0x13, 0x00, 0xf5, 0xca, 0x13, 0x00, 0xf6, 0xcb, + 0x13, 0x40, 0xe1, 0xbe, 0x13, 0x80, 0x14, 0xe5, 0xc1, 0x13, 0x00, 0xe9, + 0xc2, 0x13, 0x00, 0xef, 0xc3, 0x13, 0x00, 0xf5, 0xc4, 0x13, 0x00, 0xf6, + 0xc5, 0x13, 0x40, 0xe8, 0xc0, 0x13, 0x40, 0xe1, 0xb9, 0x13, 0x00, 0xe5, + 0xba, 0x13, 0x00, 0xe9, 0xbb, 0x13, 0x00, 0xef, 0xbc, 0x13, 0x00, 0xf5, + 0xbd, 0x13, 0x00, 0xf6, 0xf5, 0x13, 0x40, 0xe1, 0xb3, 0x13, 0x00, 0xe5, + 0xb4, 0x13, 0x00, 0xe9, 0xb5, 0x13, 0x00, 0xef, 0xb6, 0x13, 0x00, 0xf5, + 0xb7, 0x13, 0x00, 0xf6, 0xb8, 0x13, 0x40, 0xe1, 0xad, 0x13, 0x00, 0xe5, + 0xae, 0x13, 0x00, 0xe9, 0xaf, 0x13, 0x00, 0x42, 0x2a, 0x05, 0xbf, 0x13, + 0x00, 0xef, 0xb0, 0x13, 0x00, 0xf5, 0xb1, 0x13, 0x00, 0xf6, 0xb2, 0x13, + 0x40, 0xe1, 0xa6, 0x13, 0x00, 0xe5, 0xa8, 0x13, 0x00, 0xe9, 0xa9, 0x13, + 0x00, 0xef, 0xaa, 0x13, 0x00, 0xf5, 0xab, 0x13, 0x00, 0xf6, 0xac, 0x13, + 0x40, 0xe1, 0xd3, 0x13, 0x00, 0xe5, 0xd5, 0x13, 0x00, 0xe9, 0xd7, 0x13, + 0x00, 0x42, 0x74, 0x00, 0xdc, 0x13, 0x00, 0xef, 0xd9, 0x13, 0x00, 0xf5, + 0xda, 0x13, 0x00, 0xf6, 0xdb, 0x13, 0x40, 0x4e, 0x94, 0x7f, 0xe3, 0xf4, + 0x01, 0x48, 0x77, 0xd0, 0xc0, 0xf9, 0x41, 0x45, 0xb8, 0x00, 0x13, 0x27, + 0x00, 0x48, 0x40, 0x15, 0x7e, 0xf6, 0xc1, 0x00, 0x45, 0xc2, 0x0b, 0x95, + 0xfb, 0x41, 0xa9, 0x8d, 0x08, 0x04, 0xc4, 0xf6, 0xb5, 0x04, 0x02, 0x49, + 0x04, 0x3b, 0xb2, 0x01, 0xff, 0x07, 0x43, 0xd4, 0x18, 0x07, 0x22, 0x0e, + 0x01, 0xff, 0x4f, 0x81, 0x6f, 0xc9, 0xf4, 0x01, 0x4d, 0x4c, 0x8e, 0xc8, + 0xf4, 0xc1, 0x00, 0x4d, 0x13, 0x83, 0xb9, 0xf4, 0x41, 0x49, 0x07, 0x3e, + 0x09, 0x00, 0x80, 0x06, 0x42, 0xf4, 0x02, 0x40, 0x20, 0x40, 0x80, 0x01, + 0xff, 0x43, 0x6a, 0x13, 0x88, 0x00, 0x00, 0x52, 0x39, 0x59, 0x89, 0x00, + 0x40, 0x0f, 0x09, 0x35, 0xc7, 0x03, 0x06, 0xef, 0x06, 0x80, 0x03, 0x07, + 0x13, 0x06, 0x52, 0x0c, 0x3b, 0x17, 0x34, 0x0b, 0xc7, 0x7a, 0x01, 0xff, + 0xa1, 0x21, 0x42, 0x7e, 0x0b, 0x2c, 0xaa, 0x00, 0xe9, 0x2a, 0xaa, 0x80, + 0x12, 0xef, 0x2f, 0xaa, 0x80, 0x09, 0xf5, 0x2d, 0xaa, 0xc0, 0x00, 0xe5, + 0x32, 0xaa, 0x40, 0xe5, 0x2e, 0xaa, 0x40, 0xe9, 0x2b, 0xaa, 0x40, 0xe1, + 0x29, 0xaa, 0x00, 0xe9, 0x30, 0xaa, 0x00, 0xf5, 0x31, 0xaa, 0x40, 0xa4, + 0x0c, 0x46, 0x80, 0x89, 0x5c, 0xaa, 0x00, 0x4c, 0x0c, 0x9b, 0x5f, 0xaa, + 0x40, 0x44, 0x96, 0x21, 0x5d, 0xaa, 0x00, 0x4b, 0x33, 0xa6, 0x5e, 0xaa, + 0x40, 0xe1, 0x00, 0xaa, 0x80, 0xa0, 0x02, 0xa2, 0x8d, 0x02, 0x02, 0x3b, + 0x15, 0xfe, 0x01, 0xa4, 0xeb, 0x01, 0xe5, 0x03, 0xaa, 0x00, 0x06, 0x7c, + 0x2e, 0xb1, 0x01, 0xa7, 0xa4, 0x01, 0x42, 0x22, 0x00, 0x28, 0xaa, 0x00, + 0xe9, 0x01, 0xaa, 0x00, 0xaa, 0x8d, 0x01, 0xab, 0x80, 0x01, 0x42, 0x74, + 0x00, 0x24, 0xaa, 0x00, 0xad, 0x6e, 0xae, 0x44, 0xef, 0x05, 0xaa, 0x00, + 0xb0, 0x2e, 0x42, 0x71, 0x00, 0x23, 0xaa, 0x00, 0xb3, 0x1c, 0xb4, 0x10, + 0xf5, 0x02, 0xaa, 0x00, 0x42, 0x61, 0x0b, 0x25, 0xaa, 0x00, 0x42, 0xdf, + 0x23, 0x22, 0xaa, 0x40, 0xe1, 0x13, 0xaa, 0x00, 0x42, 0x22, 0x00, 0x14, + 0xaa, 0x40, 0xe1, 0x27, 0xaa, 0x00, 0x42, 0x40, 0x06, 0x26, 0xaa, 0x40, + 0xe1, 0x1a, 0xaa, 0x00, 0x42, 0x22, 0x00, 0x1c, 0xaa, 0x00, 0x42, 0xe0, + 0x09, 0x1b, 0xaa, 0x40, 0xe1, 0x18, 0xaa, 0x00, 0xa7, 0x18, 0xa8, 0x06, + 0x42, 0x5c, 0x0a, 0x17, 0xaa, 0x40, 0xe1, 0x11, 0xaa, 0x00, 0x42, 0x78, + 0x1a, 0x12, 0xaa, 0x00, 0x42, 0x5c, 0x0a, 0x10, 0xaa, 0x40, 0xe1, 0x0b, + 0xaa, 0x00, 0x42, 0x5c, 0x0a, 0x0a, 0xaa, 0x40, 0xe1, 0x20, 0xaa, 0x00, + 0x42, 0x5c, 0x0a, 0x1f, 0xaa, 0x40, 0xe1, 0x06, 0xaa, 0x00, 0x42, 0x22, + 0x00, 0x07, 0xaa, 0x40, 0xe1, 0x0e, 0xaa, 0x00, 0x42, 0x22, 0x00, 0x0f, + 0xaa, 0x40, 0xe1, 0x08, 0xaa, 0x00, 0x42, 0x22, 0x00, 0x09, 0xaa, 0x40, + 0x42, 0x3b, 0x15, 0x44, 0xaa, 0x00, 0xe7, 0x41, 0xaa, 0x00, 0xeb, 0x40, + 0xaa, 0x00, 0xec, 0x4a, 0xaa, 0x00, 0xee, 0x46, 0xaa, 0x80, 0x16, 0xf0, + 0x47, 0xaa, 0x00, 0xf2, 0x49, 0xaa, 0x00, 0x42, 0xee, 0x00, 0x4b, 0xaa, + 0x00, 0xf4, 0x45, 0xaa, 0x00, 0xf9, 0x48, 0xaa, 0x40, 0xe7, 0x42, 0xaa, + 0x40, 0xe1, 0x15, 0xaa, 0x00, 0x42, 0x7b, 0x08, 0x19, 0xaa, 0x00, 0x42, + 0x22, 0x00, 0x16, 0xaa, 0x40, 0xe1, 0x0c, 0xaa, 0x00, 0x42, 0x22, 0x00, + 0x0d, 0xaa, 0x40, 0xe1, 0x1d, 0xaa, 0x00, 0x42, 0x16, 0x00, 0x21, 0xaa, + 0x00, 0x42, 0x22, 0x00, 0x1e, 0xaa, 0x40, 0xe9, 0x04, 0xaa, 0x40, 0x45, + 0x7e, 0x0b, 0x58, 0xaa, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x59, 0xaa, + 0x00, 0x43, 0x7a, 0x0b, 0x51, 0xaa, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, + 0x80, 0x1f, 0x50, 0xaa, 0x40, 0x44, 0x25, 0x01, 0x53, 0xaa, 0x00, 0x42, + 0x15, 0x02, 0x52, 0xaa, 0x40, 0x44, 0x06, 0x1f, 0x57, 0xaa, 0x00, 0x42, + 0x09, 0x24, 0x56, 0xaa, 0x40, 0x43, 0xf9, 0x05, 0x55, 0xaa, 0x00, 0x43, + 0xf6, 0x06, 0x54, 0xaa, 0x40, 0x06, 0x7c, 0x2e, 0x18, 0x42, 0x74, 0x00, + 0x35, 0xaa, 0x00, 0x42, 0x71, 0x00, 0x34, 0xaa, 0x00, 0x42, 0xa9, 0x01, + 0x36, 0xaa, 0x00, 0x42, 0xdf, 0x23, 0x33, 0xaa, 0x40, 0xe8, 0x4d, 0xaa, + 0x00, 0xed, 0x4c, 0xaa, 0x00, 0x42, 0x1d, 0x01, 0x43, 0xaa, 0x40, 0x47, + 0xf2, 0xd4, 0x32, 0x11, 0x01, 0xa4, 0xf8, 0x02, 0x07, 0x13, 0x06, 0x74, + 0x47, 0xe9, 0xd8, 0x34, 0x11, 0x01, 0x46, 0x89, 0xd1, 0x31, 0x11, 0x01, + 0x4d, 0x88, 0x36, 0x43, 0x11, 0x01, 0xb3, 0x43, 0xb6, 0x01, 0xff, 0x45, + 0x20, 0x25, 0x33, 0x11, 0x01, 0x0a, 0xc8, 0x7a, 0x01, 0xff, 0xe1, 0x27, + 0x11, 0x81, 0x24, 0xe5, 0x2c, 0x11, 0x81, 0x1b, 0xe9, 0x28, 0x11, 0x81, + 0x12, 0xef, 0x2e, 0x11, 0x81, 0x09, 0xf5, 0x2a, 0x11, 0xc1, 0x00, 0xf5, + 0x2b, 0x11, 0x41, 0xe9, 0x30, 0x11, 0x41, 0xe9, 0x29, 0x11, 0x41, 0xe9, + 0x46, 0x11, 0x41, 0xe1, 0x45, 0x11, 0x01, 0xe9, 0x2d, 0x11, 0x01, 0xf5, + 0x2f, 0x11, 0x41, 0x4b, 0x67, 0x28, 0x40, 0x11, 0x01, 0x04, 0x5b, 0x03, + 0x01, 0xff, 0x48, 0x0a, 0x17, 0x01, 0x11, 0x01, 0x4b, 0x13, 0x25, 0x00, + 0x11, 0x01, 0x47, 0x47, 0x4e, 0x02, 0x11, 0x41, 0x42, 0x4e, 0x13, 0x03, + 0x11, 0x01, 0xa2, 0xeb, 0x01, 0xa3, 0xdc, 0x01, 0xa4, 0xbf, 0x01, 0xe5, + 0x06, 0x11, 0x01, 0xa7, 0xac, 0x01, 0x43, 0x5e, 0x43, 0x26, 0x11, 0x01, + 0xe9, 0x04, 0x11, 0x01, 0xaa, 0x93, 0x01, 0xab, 0x84, 0x01, 0xac, 0x76, + 0x43, 0xb0, 0x5a, 0x1f, 0x11, 0x01, 0xae, 0x56, 0xb0, 0x48, 0x43, 0x8c, + 0x9a, 0x22, 0x11, 0x01, 0x43, 0xd0, 0xe5, 0x25, 0x11, 0x01, 0xb4, 0x1f, + 0xf5, 0x05, 0x11, 0x01, 0x43, 0xf1, 0xf1, 0x47, 0x11, 0x01, 0x43, 0xba, + 0x90, 0x24, 0x11, 0x01, 0xb9, 0x01, 0xff, 0x42, 0x4e, 0x13, 0x21, 0x11, + 0x01, 0x43, 0xd0, 0xaf, 0x20, 0x11, 0x41, 0x42, 0x4e, 0x13, 0x16, 0x11, + 0x01, 0x43, 0x5e, 0x43, 0x17, 0x11, 0x01, 0xb4, 0x01, 0xff, 0x42, 0x4e, + 0x13, 0x11, 0x11, 0x01, 0x43, 0x5e, 0x43, 0x12, 0x11, 0x41, 0x42, 0x4e, + 0x13, 0x1b, 0x11, 0x01, 0x43, 0x5e, 0x43, 0x1c, 0x11, 0x41, 0x42, 0x4e, + 0x13, 0x1a, 0x11, 0x01, 0x43, 0x2b, 0x5a, 0x0b, 0x11, 0x01, 0x43, 0xa9, + 0x4a, 0x15, 0x11, 0x01, 0x43, 0xd0, 0xaf, 0x10, 0x11, 0x41, 0x42, 0x4e, + 0x13, 0x23, 0x11, 0x01, 0x43, 0x5e, 0x43, 0x44, 0x11, 0x41, 0x42, 0x4e, + 0x13, 0x07, 0x11, 0x01, 0x43, 0x5e, 0x43, 0x08, 0x11, 0x41, 0x42, 0x4e, + 0x13, 0x0e, 0x11, 0x01, 0x43, 0x5e, 0x43, 0x0f, 0x11, 0x41, 0x42, 0x4e, + 0x13, 0x09, 0x11, 0x01, 0x43, 0x5e, 0x43, 0x0a, 0x11, 0x41, 0x42, 0x4e, + 0x13, 0x18, 0x11, 0x01, 0xa4, 0x06, 0x43, 0x5e, 0x43, 0x19, 0x11, 0x41, + 0x42, 0x4e, 0x13, 0x13, 0x11, 0x01, 0x43, 0x5e, 0x43, 0x14, 0x11, 0x41, + 0x42, 0x4e, 0x13, 0x0c, 0x11, 0x01, 0x43, 0x5e, 0x43, 0x0d, 0x11, 0x41, + 0x42, 0x4e, 0x13, 0x1d, 0x11, 0x01, 0x43, 0x5e, 0x43, 0x1e, 0x11, 0x41, + 0x44, 0x96, 0x21, 0x41, 0x11, 0x01, 0x05, 0xf0, 0x06, 0x06, 0x4b, 0x33, + 0xa6, 0x42, 0x11, 0x41, 0x45, 0x7e, 0x0b, 0x3e, 0x11, 0x01, 0xa6, 0x2e, + 0x44, 0x6d, 0x2c, 0x3f, 0x11, 0x01, 0x43, 0x7a, 0x0b, 0x37, 0x11, 0x01, + 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x36, 0x11, 0x41, 0x44, 0x25, + 0x01, 0x39, 0x11, 0x01, 0x42, 0x15, 0x02, 0x38, 0x11, 0x41, 0x44, 0x06, + 0x1f, 0x3d, 0x11, 0x01, 0x42, 0x09, 0x24, 0x3c, 0x11, 0x41, 0x43, 0xf9, + 0x05, 0x3b, 0x11, 0x01, 0x43, 0xf6, 0x06, 0x3a, 0x11, 0x41, 0x42, 0x5f, + 0x01, 0xd3, 0x26, 0x00, 0xf2, 0x91, 0xfa, 0x41, 0x02, 0x00, 0x00, 0x32, + 0x4a, 0x16, 0xb3, 0x48, 0xf5, 0x01, 0x02, 0x11, 0x00, 0x06, 0x43, 0xf5, + 0x1e, 0xb3, 0x26, 0x40, 0x45, 0x59, 0x03, 0xa2, 0x00, 0x00, 0x02, 0x88, + 0x00, 0x01, 0xff, 0x4c, 0xc0, 0x8f, 0x04, 0x21, 0x00, 0x05, 0xed, 0x07, + 0x01, 0xff, 0x48, 0x07, 0x8f, 0x4e, 0xfe, 0x00, 0x48, 0x14, 0x8f, 0x4a, + 0xfe, 0x40, 0x45, 0x59, 0x03, 0xb5, 0x20, 0x00, 0x43, 0xba, 0x0e, 0xb8, + 0x00, 0x40, 0x44, 0x62, 0xdb, 0x35, 0xf3, 0x01, 0xa4, 0x83, 0x23, 0xac, + 0xf4, 0x22, 0xad, 0xde, 0x22, 0xee, 0x18, 0x00, 0x80, 0xf9, 0x05, 0xb0, + 0xea, 0x05, 0xb2, 0x9a, 0x03, 0x44, 0xbc, 0x01, 0xeb, 0x26, 0x00, 0xf4, + 0x08, 0xf4, 0x81, 0xf6, 0x02, 0xb5, 0x01, 0xff, 0x10, 0x1a, 0x64, 0x06, + 0x49, 0xc0, 0x04, 0x21, 0x26, 0x40, 0x4d, 0x9d, 0x85, 0x6f, 0x05, 0x01, + 0x07, 0x13, 0x06, 0x01, 0xff, 0xa1, 0xcf, 0x02, 0x43, 0xe5, 0x09, 0x31, + 0x05, 0x01, 0xa3, 0x98, 0x02, 0xa4, 0xfa, 0x01, 0xa5, 0xed, 0x01, 0x43, + 0x9e, 0xe1, 0x54, 0x05, 0x01, 0xa7, 0xd8, 0x01, 0x44, 0x1c, 0xf6, 0x46, + 0x05, 0x01, 0xa9, 0xbd, 0x01, 0xaa, 0xae, 0x01, 0xab, 0x9f, 0x01, 0xac, + 0x90, 0x01, 0x43, 0x68, 0xee, 0x4c, 0x05, 0x01, 0x44, 0x7c, 0xf7, 0x4e, + 0x05, 0x01, 0x42, 0x10, 0x00, 0x52, 0x05, 0x01, 0xb0, 0x70, 0x02, 0x11, + 0x15, 0x64, 0x43, 0x38, 0x0f, 0x59, 0x05, 0x01, 0xb3, 0x44, 0xb4, 0x30, + 0x44, 0xfc, 0xf8, 0x5b, 0x05, 0x01, 0x44, 0x30, 0xf9, 0x40, 0x05, 0x01, + 0xb9, 0x16, 0xba, 0x01, 0xff, 0x43, 0x17, 0x37, 0x35, 0x05, 0x01, 0xa8, + 0x01, 0xff, 0xe1, 0x3b, 0x05, 0x01, 0x42, 0x62, 0x01, 0x37, 0x05, 0x41, + 0x43, 0x5f, 0x35, 0x61, 0x05, 0x01, 0x43, 0xf1, 0x24, 0x3a, 0x05, 0x41, + 0x42, 0xbb, 0x01, 0x38, 0x05, 0x01, 0x43, 0x54, 0xfa, 0x5c, 0x05, 0x01, + 0x43, 0x8d, 0x55, 0x53, 0x05, 0x41, 0x43, 0x33, 0xfa, 0x5a, 0x05, 0x01, + 0xa8, 0x01, 0xff, 0xe1, 0x3d, 0x05, 0x81, 0x06, 0x42, 0x8b, 0x6c, 0x5d, + 0x05, 0x41, 0xeb, 0x50, 0x05, 0x41, 0xf2, 0x4d, 0x05, 0x01, 0xf9, 0x47, + 0x05, 0x41, 0x42, 0x92, 0x01, 0x57, 0x05, 0x01, 0x43, 0x54, 0xfa, 0x62, + 0x05, 0x41, 0x42, 0x1a, 0x00, 0x3e, 0x05, 0x01, 0x43, 0x48, 0x55, 0x45, + 0x05, 0x41, 0x42, 0x17, 0x00, 0x44, 0x05, 0x01, 0x42, 0x57, 0x41, 0x63, + 0x05, 0x41, 0x43, 0x60, 0x84, 0x51, 0x05, 0x01, 0x43, 0x4b, 0xfa, 0x43, + 0x05, 0x41, 0x43, 0x9e, 0x37, 0x3f, 0x05, 0x01, 0x42, 0x9f, 0x05, 0x3c, + 0x05, 0x01, 0x42, 0xa7, 0x01, 0x5e, 0x05, 0x41, 0x44, 0x18, 0xf6, 0x58, + 0x05, 0x01, 0x42, 0x29, 0x02, 0x32, 0x05, 0x41, 0xe2, 0x34, 0x05, 0x01, + 0x42, 0x25, 0x1e, 0x36, 0x05, 0x41, 0x42, 0x8a, 0x00, 0x33, 0x05, 0x01, + 0x43, 0xb0, 0x37, 0x41, 0x05, 0x01, 0xba, 0x01, 0xff, 0x42, 0x9c, 0x11, + 0x55, 0x05, 0x01, 0x43, 0x8d, 0x55, 0x4f, 0x05, 0x41, 0xa1, 0x22, 0xa8, + 0x0d, 0x02, 0xdf, 0x23, 0x01, 0xff, 0xf7, 0x5f, 0x05, 0x01, 0xf9, 0x4b, + 0x05, 0x41, 0xe1, 0x39, 0x05, 0x81, 0x0a, 0xe9, 0x4a, 0x05, 0x01, 0x42, + 0x8b, 0x6c, 0x49, 0x05, 0x41, 0xf4, 0x56, 0x05, 0x41, 0xf2, 0x42, 0x05, + 0x01, 0x42, 0x25, 0x1e, 0x60, 0x05, 0x41, 0x42, 0xb8, 0x04, 0x30, 0x05, + 0x01, 0x42, 0x0c, 0x00, 0x48, 0x05, 0x41, 0x45, 0x0b, 0x08, 0x31, 0xf4, + 0xc1, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4c, 0xac, 0x9a, 0x39, 0xf6, + 0x01, 0x49, 0x3a, 0xc7, 0x3c, 0xf6, 0x41, 0x48, 0x47, 0xc8, 0xd0, 0x26, + 0x00, 0x02, 0x06, 0x00, 0xaf, 0x02, 0xa5, 0x9b, 0x02, 0x0b, 0xf5, 0x91, + 0x2e, 0xaf, 0x22, 0xb0, 0x14, 0xb2, 0x06, 0x52, 0x19, 0x58, 0x10, 0xdb, + 0x41, 0x4b, 0xa1, 0x8c, 0x0d, 0x00, 0x00, 0x42, 0x1b, 0x05, 0x55, 0xf9, + 0x41, 0x49, 0x6e, 0xba, 0x8f, 0xf3, 0x01, 0x49, 0x0d, 0xbe, 0x9a, 0xfa, + 0x41, 0xee, 0xc7, 0x02, 0x00, 0x4a, 0xb6, 0xb8, 0xa0, 0xf3, 0x41, 0xe1, + 0xa0, 0x02, 0x81, 0xdf, 0x01, 0xe2, 0xa9, 0x02, 0x01, 0x02, 0xe7, 0x06, + 0xca, 0x01, 0xe4, 0xa2, 0x02, 0x81, 0xc0, 0x01, 0xe5, 0xba, 0x02, 0x81, + 0xb6, 0x01, 0xe7, 0xc0, 0x02, 0x81, 0xac, 0x01, 0xe9, 0xb9, 0x02, 0x81, + 0xa2, 0x01, 0xeb, 0xbc, 0x02, 0x81, 0x98, 0x01, 0xec, 0xa3, 0x02, 0x81, + 0x89, 0x01, 0xed, 0xaa, 0x02, 0x81, 0x73, 0xee, 0xb5, 0x02, 0x81, 0x62, + 0xef, 0xab, 0x02, 0x01, 0xf0, 0xb7, 0x02, 0x81, 0x55, 0xf1, 0xa8, 0x02, + 0x01, 0xf2, 0xa5, 0x02, 0x81, 0x48, 0xf3, 0xb0, 0x02, 0x81, 0x2d, 0xf4, + 0xad, 0x02, 0x81, 0x1f, 0xf5, 0xb2, 0x02, 0x81, 0x04, 0xf8, 0xb4, 0x02, + 0x41, 0xf5, 0xbf, 0x02, 0xc1, 0x00, 0xf5, 0xa4, 0x02, 0xc1, 0x00, 0xd2, + 0xc8, 0x02, 0x01, 0xd3, 0xd0, 0x02, 0x01, 0xf5, 0xbb, 0x02, 0x41, 0xf4, + 0xc7, 0x02, 0xc1, 0x00, 0xd2, 0xb6, 0x02, 0x41, 0xe8, 0xae, 0x02, 0x81, + 0x0d, 0xf3, 0xb8, 0x02, 0x01, 0xf4, 0xc2, 0x02, 0xc1, 0x00, 0xd2, 0xc3, + 0x02, 0x41, 0xd2, 0xaf, 0x02, 0x41, 0xf2, 0xc9, 0x02, 0x41, 0xd2, 0xa1, + 0x02, 0x41, 0xe4, 0xbe, 0x02, 0x01, 0xe7, 0xc4, 0x02, 0x01, 0xee, 0xb3, + 0x02, 0x41, 0xe2, 0xca, 0x02, 0xc1, 0x00, 0xd2, 0xcb, 0x02, 0x01, 0xd3, + 0xcc, 0x02, 0x01, 0xd4, 0xcd, 0x02, 0x41, 0xe4, 0xa6, 0x02, 0xc1, 0x00, + 0xd2, 0xce, 0x02, 0x41, 0xd2, 0xbd, 0x02, 0x41, 0xe9, 0xc5, 0x02, 0x41, + 0xd2, 0xc1, 0x02, 0x41, 0xd2, 0xcf, 0x02, 0x41, 0xd2, 0xac, 0x02, 0x41, + 0x42, 0x5a, 0xe8, 0xb1, 0x02, 0x01, 0x42, 0xf5, 0xfa, 0xc6, 0x02, 0x41, + 0xd2, 0xa7, 0x02, 0x41, 0x43, 0xf3, 0x01, 0x05, 0x21, 0x00, 0xf4, 0x38, + 0x20, 0xc0, 0x00, 0x50, 0xda, 0x62, 0x41, 0x20, 0x40, 0x48, 0xcf, 0xcb, + 0xc3, 0xf5, 0x01, 0x45, 0x5d, 0x14, 0xc7, 0xf4, 0xc1, 0x00, 0x49, 0xd5, + 0xb9, 0xc2, 0xf5, 0x41, 0x46, 0x2a, 0xe3, 0x3f, 0x2e, 0x00, 0x46, 0x88, + 0xe5, 0x51, 0x26, 0x40, 0x10, 0x7a, 0x63, 0x39, 0x02, 0x73, 0x02, 0x18, + 0xa4, 0x0c, 0x48, 0x3f, 0xce, 0x6b, 0xf9, 0x01, 0x42, 0xce, 0x53, 0xf6, + 0xf6, 0x41, 0x42, 0x68, 0x00, 0x6f, 0xf5, 0x01, 0xf9, 0x6c, 0xf3, 0x41, + 0xec, 0x18, 0x00, 0x80, 0x04, 0xf2, 0x4b, 0x26, 0x40, 0x80, 0x06, 0x48, + 0x4f, 0xcd, 0xd9, 0xf5, 0x41, 0x49, 0xd0, 0x18, 0x94, 0x00, 0x00, 0x43, + 0xbc, 0x1c, 0x7f, 0x00, 0x4e, 0xe1, 0x0a, 0x14, 0x80, 0xf0, 0x1b, 0xa2, + 0x89, 0x1b, 0xe3, 0xa1, 0x14, 0x80, 0xe0, 0x13, 0xe5, 0x01, 0x14, 0x80, + 0xd0, 0x13, 0xe6, 0x5d, 0x15, 0x80, 0xb1, 0x12, 0x4c, 0x6c, 0x2a, 0x1e, + 0x14, 0x00, 0xa8, 0x9e, 0x12, 0xe9, 0x03, 0x14, 0x80, 0x90, 0x12, 0xeb, + 0x83, 0x14, 0x80, 0xba, 0x11, 0xec, 0xea, 0x14, 0x80, 0xca, 0x10, 0xed, + 0xbb, 0x14, 0x80, 0xe1, 0x0f, 0xee, 0xd0, 0x14, 0x80, 0xd6, 0x0c, 0xef, + 0x05, 0x14, 0x80, 0x89, 0x0c, 0xf0, 0x49, 0x14, 0x80, 0xb1, 0x0b, 0xf1, + 0x85, 0x15, 0x80, 0x87, 0x0b, 0xf2, 0x50, 0x15, 0x80, 0xa7, 0x0a, 0xf3, + 0x05, 0x15, 0x80, 0xf5, 0x07, 0xf4, 0x66, 0x14, 0x80, 0xe0, 0x05, 0xb7, + 0x9f, 0x01, 0xf9, 0x3e, 0x15, 0xc0, 0x00, 0x06, 0x7a, 0xa2, 0x4e, 0xe1, + 0x2d, 0x15, 0x80, 0x3c, 0xe5, 0x26, 0x15, 0x00, 0xe9, 0x28, 0x15, 0x80, + 0x2f, 0xef, 0x2a, 0x15, 0x80, 0x22, 0xb7, 0x01, 0xff, 0xe1, 0x39, 0x15, + 0x80, 0x16, 0xe5, 0x2f, 0x15, 0x00, 0xe9, 0x31, 0x15, 0x80, 0x09, 0xef, + 0x35, 0x15, 0xc0, 0x00, 0xef, 0x37, 0x15, 0x40, 0xe9, 0x33, 0x15, 0x40, + 0xe1, 0x3b, 0x15, 0x40, 0xef, 0x2b, 0x15, 0x00, 0xf9, 0xc3, 0x18, 0x40, + 0xe9, 0x29, 0x15, 0x40, 0xe1, 0x2e, 0x15, 0x80, 0x04, 0xf9, 0xc4, 0x18, + 0x40, 0xe9, 0x27, 0x15, 0x40, 0x43, 0x09, 0xcb, 0x8f, 0x14, 0x00, 0x43, + 0x33, 0xe9, 0x71, 0x14, 0x00, 0x43, 0x97, 0x08, 0xd9, 0x14, 0x00, 0x43, + 0xd1, 0x1c, 0xa9, 0x14, 0x00, 0x43, 0x4a, 0x17, 0xc6, 0x14, 0x00, 0x42, + 0xcd, 0x02, 0x07, 0x14, 0x00, 0xb0, 0x16, 0x43, 0x42, 0xe9, 0xf3, 0x14, + 0x00, 0x43, 0x92, 0x31, 0x52, 0x14, 0x00, 0xf7, 0x1d, 0x14, 0x00, 0x43, + 0x5e, 0x56, 0x2c, 0x15, 0x40, 0x42, 0xcd, 0x02, 0x35, 0x14, 0x00, 0x43, + 0xba, 0x90, 0x48, 0x14, 0x40, 0xe1, 0x17, 0x14, 0x80, 0xb0, 0x04, 0xe5, + 0x0c, 0x14, 0x80, 0x59, 0xe9, 0x0e, 0x14, 0x80, 0x50, 0xef, 0x12, 0x14, + 0xc0, 0x00, 0xef, 0x14, 0x14, 0xc0, 0x00, 0x08, 0xe7, 0xca, 0x01, 0xff, + 0x48, 0xd7, 0xcb, 0x7e, 0x16, 0x00, 0x42, 0x53, 0x00, 0x9f, 0x15, 0xc0, + 0x00, 0xe1, 0x9e, 0x15, 0x00, 0xe5, 0x9b, 0x15, 0x00, 0xe9, 0x9c, 0x15, + 0x00, 0xef, 0x9d, 0x15, 0x00, 0xb7, 0x01, 0xff, 0xe1, 0x7c, 0x16, 0x80, + 0x18, 0x42, 0x27, 0x01, 0x77, 0x16, 0x00, 0xe9, 0x78, 0x16, 0x80, 0x09, + 0xef, 0x7a, 0x16, 0xc0, 0x00, 0xef, 0x7b, 0x16, 0x40, 0xe9, 0x79, 0x16, + 0x40, 0xe1, 0x7d, 0x16, 0x40, 0xe9, 0x10, 0x14, 0x40, 0x02, 0x60, 0x01, + 0x01, 0xff, 0x06, 0x7a, 0xa2, 0x06, 0x45, 0x62, 0xc9, 0xdd, 0x18, 0x40, + 0x02, 0x54, 0xf5, 0x9f, 0x03, 0x44, 0xbc, 0xf5, 0x5c, 0x15, 0x00, 0x02, + 0xa8, 0x0b, 0xf5, 0x02, 0xec, 0xeb, 0x14, 0x80, 0xb7, 0x02, 0xed, 0xbc, + 0x14, 0x80, 0x8f, 0x02, 0x02, 0xa8, 0x01, 0xfd, 0x01, 0xf0, 0x4a, 0x14, + 0x80, 0xd5, 0x01, 0xf2, 0x51, 0x15, 0x80, 0xb9, 0x01, 0xb3, 0x72, 0xb4, + 0x48, 0xb7, 0x27, 0xf9, 0x40, 0x15, 0xc0, 0x00, 0xb7, 0x01, 0xff, 0xe1, + 0x3a, 0x15, 0x80, 0x16, 0xe5, 0x30, 0x15, 0x00, 0xe9, 0x32, 0x15, 0x80, + 0x09, 0xef, 0x36, 0x15, 0xc0, 0x00, 0xef, 0x38, 0x15, 0x40, 0xe9, 0x34, + 0x15, 0x40, 0xe1, 0x3c, 0x15, 0x40, 0xe1, 0x18, 0x14, 0x80, 0x16, 0xe5, + 0x0d, 0x14, 0x00, 0xe9, 0x0f, 0x14, 0x80, 0x09, 0xef, 0x13, 0x14, 0xc0, + 0x00, 0xef, 0x15, 0x14, 0x40, 0xe9, 0x11, 0x14, 0x40, 0xe1, 0x1a, 0x14, + 0x40, 0x44, 0x4c, 0xf6, 0x69, 0x15, 0x00, 0xb7, 0x01, 0xff, 0xe1, 0x62, + 0x14, 0x80, 0x16, 0xe5, 0x58, 0x14, 0x00, 0xe9, 0x5a, 0x14, 0x80, 0x09, + 0xef, 0x5e, 0x14, 0xc0, 0x00, 0xef, 0x60, 0x14, 0x40, 0xe9, 0x5c, 0x14, + 0x40, 0xe1, 0x64, 0x14, 0x40, 0x02, 0xff, 0x0e, 0x22, 0xb7, 0x01, 0xff, + 0xe1, 0x01, 0x15, 0x80, 0x16, 0xe5, 0xf7, 0x14, 0x00, 0xe9, 0xf9, 0x14, + 0x80, 0x09, 0xef, 0xfd, 0x14, 0xc0, 0x00, 0xef, 0xff, 0x14, 0x40, 0xe9, + 0xfb, 0x14, 0x40, 0xe1, 0x03, 0x15, 0x40, 0xe1, 0x22, 0x15, 0x80, 0x16, + 0xe5, 0x18, 0x15, 0x00, 0xe9, 0x1a, 0x15, 0x80, 0x09, 0xef, 0x1e, 0x15, + 0xc0, 0x00, 0xef, 0x20, 0x15, 0x40, 0xe9, 0x1c, 0x15, 0x40, 0xe1, 0x24, + 0x15, 0x40, 0xe1, 0x8d, 0x15, 0x00, 0xe5, 0x8a, 0x15, 0x00, 0xe9, 0x8b, + 0x15, 0x00, 0xef, 0x8c, 0x15, 0x00, 0x43, 0xba, 0x90, 0x4f, 0x15, 0x40, + 0xb7, 0x01, 0xff, 0xe1, 0x45, 0x14, 0x80, 0x16, 0xe5, 0x3b, 0x14, 0x00, + 0xe9, 0x3d, 0x14, 0x80, 0x09, 0xef, 0x41, 0x14, 0xc0, 0x00, 0xef, 0x43, + 0x14, 0x40, 0xe9, 0x3f, 0x14, 0x40, 0xe1, 0x47, 0x14, 0x40, 0xe1, 0xcc, + 0x14, 0x80, 0x04, 0xe5, 0xca, 0x14, 0x40, 0xe1, 0xce, 0x14, 0x40, 0xb7, + 0x01, 0xff, 0xe1, 0xb7, 0x14, 0x80, 0x16, 0xe5, 0xad, 0x14, 0x00, 0xe9, + 0xaf, 0x14, 0x80, 0x09, 0xef, 0xb3, 0x14, 0xc0, 0x00, 0xef, 0xb5, 0x14, + 0x40, 0xe9, 0xb1, 0x14, 0x40, 0xe1, 0xb9, 0x14, 0x40, 0xe1, 0x4d, 0x15, + 0x80, 0x2f, 0xe5, 0x44, 0x15, 0x00, 0xef, 0x4a, 0x15, 0x80, 0x22, 0xb7, + 0x01, 0xff, 0xe1, 0xe7, 0x14, 0x80, 0x16, 0xe5, 0xdd, 0x14, 0x00, 0xe9, + 0xdf, 0x14, 0x80, 0x09, 0xef, 0xe3, 0x14, 0xc0, 0x00, 0xef, 0xe5, 0x14, + 0x40, 0xe9, 0xe1, 0x14, 0x40, 0xe1, 0xe9, 0x14, 0x40, 0xef, 0xe1, 0x18, + 0x40, 0xe1, 0xe2, 0x18, 0x40, 0xe1, 0x7f, 0x14, 0x80, 0x16, 0xe5, 0x75, + 0x14, 0x00, 0xe9, 0x77, 0x14, 0x80, 0x09, 0xef, 0x7b, 0x14, 0xc0, 0x00, + 0xef, 0x7d, 0x14, 0x40, 0xe9, 0x79, 0x14, 0x40, 0xe1, 0x81, 0x14, 0x40, + 0xe1, 0x9d, 0x14, 0x80, 0x16, 0xe5, 0x93, 0x14, 0x00, 0xe9, 0x95, 0x14, + 0x80, 0x09, 0xef, 0x99, 0x14, 0xc0, 0x00, 0xef, 0x9b, 0x14, 0x40, 0xe9, + 0x97, 0x14, 0x40, 0xe1, 0x9f, 0x14, 0x40, 0xe1, 0x19, 0x14, 0x00, 0xf9, + 0xb3, 0x18, 0x40, 0xe1, 0x55, 0x14, 0x80, 0xfc, 0x01, 0xe5, 0x4c, 0x14, + 0x00, 0xe8, 0x6a, 0x15, 0x80, 0x9d, 0x01, 0xe9, 0x4e, 0x14, 0x80, 0x93, + 0x01, 0x02, 0xcc, 0x05, 0x74, 0xef, 0x50, 0x14, 0x80, 0x6b, 0xb4, 0x34, + 0xb7, 0x13, 0xb9, 0x01, 0xff, 0xe1, 0x73, 0x15, 0x00, 0xe5, 0x70, 0x15, + 0x00, 0xe9, 0x71, 0x15, 0x00, 0xef, 0x72, 0x15, 0x40, 0xe1, 0x61, 0x14, + 0x80, 0x16, 0xe5, 0x57, 0x14, 0x00, 0xe9, 0x59, 0x14, 0x80, 0x09, 0xef, + 0x5d, 0x14, 0xc0, 0x00, 0xef, 0x5f, 0x14, 0x40, 0xe9, 0x5b, 0x14, 0x40, + 0xe1, 0x63, 0x14, 0x40, 0xe1, 0x6a, 0x14, 0x00, 0xe5, 0x67, 0x14, 0x00, + 0xe8, 0x6f, 0x15, 0x80, 0x08, 0xe9, 0x68, 0x14, 0x00, 0xef, 0x69, 0x14, + 0x40, 0xe1, 0x6e, 0x15, 0x80, 0x17, 0xe5, 0x6b, 0x15, 0x00, 0xe9, 0x6c, + 0x15, 0x00, 0xef, 0x6d, 0x15, 0x80, 0x06, 0x42, 0x15, 0x01, 0xe5, 0x18, + 0x40, 0xef, 0xe6, 0x18, 0x40, 0xe1, 0xe7, 0x18, 0x40, 0xef, 0x51, 0x14, + 0x40, 0xe1, 0x89, 0x15, 0x00, 0xe5, 0x86, 0x15, 0x00, 0xe9, 0x87, 0x15, + 0x00, 0xef, 0x88, 0x15, 0x80, 0x06, 0x42, 0x15, 0x01, 0xe8, 0x18, 0x40, + 0xef, 0xe9, 0x18, 0x40, 0xe9, 0x4f, 0x14, 0x40, 0x48, 0x6f, 0xc8, 0xae, + 0x15, 0x80, 0x2f, 0xe1, 0x66, 0x15, 0x80, 0x26, 0xe5, 0x5e, 0x15, 0x00, + 0xe9, 0x60, 0x15, 0x80, 0x19, 0xef, 0x64, 0x15, 0x80, 0x10, 0xb7, 0x01, + 0xff, 0xe1, 0xe4, 0x18, 0x80, 0x04, 0xe5, 0xe3, 0x18, 0x40, 0xe1, 0x68, + 0x15, 0x40, 0xef, 0x65, 0x15, 0x40, 0xe9, 0x62, 0x15, 0x40, 0xe1, 0x67, + 0x15, 0x40, 0xe1, 0xac, 0x15, 0x80, 0x16, 0xe5, 0xa7, 0x15, 0x00, 0xe9, + 0xa8, 0x15, 0x80, 0x09, 0xef, 0xaa, 0x15, 0xc0, 0x00, 0xef, 0xab, 0x15, + 0x40, 0xe9, 0xa9, 0x15, 0x40, 0xe1, 0xad, 0x15, 0x40, 0xe1, 0x56, 0x14, + 0x80, 0x04, 0xf9, 0xb7, 0x18, 0x40, 0xe9, 0x4d, 0x14, 0x40, 0xe1, 0xf4, + 0x14, 0x80, 0xbe, 0x01, 0xe5, 0xed, 0x14, 0x00, 0xe8, 0x25, 0x15, 0x80, + 0x68, 0xe9, 0xef, 0x14, 0x80, 0x5f, 0xef, 0xf1, 0x14, 0x80, 0x36, 0xb0, + 0x24, 0xf7, 0x07, 0x15, 0xc0, 0x00, 0xe1, 0x00, 0x15, 0x80, 0x16, 0xe5, + 0xf6, 0x14, 0x00, 0xe9, 0xf8, 0x14, 0x80, 0x09, 0xef, 0xfc, 0x14, 0xc0, + 0x00, 0xef, 0xfe, 0x14, 0x40, 0xe9, 0xfa, 0x14, 0x40, 0xe1, 0x02, 0x15, + 0x40, 0xe1, 0xbf, 0x1a, 0x01, 0xe5, 0xbc, 0x1a, 0x01, 0xe9, 0xbd, 0x1a, + 0x01, 0xef, 0xbe, 0x1a, 0x41, 0xef, 0xf2, 0x14, 0x00, 0x0c, 0xa8, 0x9b, + 0x04, 0xf9, 0xbe, 0x18, 0x40, 0x42, 0x3d, 0x0a, 0x88, 0x14, 0x00, 0x42, + 0x4e, 0x00, 0x85, 0x14, 0x00, 0x42, 0x61, 0x2e, 0x86, 0x14, 0x00, 0x42, + 0x9b, 0x2a, 0x87, 0x14, 0x40, 0xe9, 0xf0, 0x14, 0x40, 0xe1, 0x15, 0x15, + 0x80, 0x40, 0xe5, 0x10, 0x15, 0x00, 0xe9, 0x11, 0x15, 0x80, 0x33, 0xef, + 0x13, 0x15, 0x80, 0x26, 0xb7, 0x01, 0xff, 0xe1, 0x21, 0x15, 0x80, 0x1a, + 0xe5, 0x17, 0x15, 0x00, 0xe9, 0x19, 0x15, 0x80, 0x0d, 0xef, 0x1d, 0x15, + 0xc0, 0x00, 0xef, 0x1f, 0x15, 0x00, 0xf9, 0xc2, 0x18, 0x40, 0xe9, 0x1b, + 0x15, 0x40, 0xe1, 0x23, 0x15, 0x40, 0xef, 0x14, 0x15, 0x00, 0xf9, 0xc0, + 0x18, 0x40, 0xe9, 0x12, 0x15, 0x40, 0xe1, 0x16, 0x15, 0x00, 0xf9, 0xc1, + 0x18, 0x40, 0xe1, 0xf5, 0x14, 0x80, 0x5f, 0xf9, 0xbf, 0x18, 0xc0, 0x00, + 0x04, 0x8c, 0xf6, 0x01, 0xff, 0xa8, 0x3e, 0xaa, 0x2f, 0xed, 0xbf, 0x14, + 0x00, 0x02, 0xa4, 0x02, 0x0c, 0x42, 0x53, 0x00, 0xa2, 0x14, 0x00, 0x42, + 0xa0, 0x1b, 0x41, 0x15, 0x40, 0xe1, 0x9a, 0x15, 0x00, 0xe5, 0x97, 0x15, + 0x00, 0xe9, 0x98, 0x15, 0x00, 0xef, 0x99, 0x15, 0x80, 0x06, 0x42, 0x15, + 0x01, 0xea, 0x18, 0x40, 0xef, 0xeb, 0x18, 0x40, 0xe9, 0x1a, 0x16, 0x00, + 0xf5, 0x15, 0x16, 0xc0, 0x00, 0xf5, 0xf1, 0x18, 0x40, 0xe1, 0xc3, 0x15, + 0x00, 0xe5, 0xc0, 0x15, 0x00, 0xe9, 0xc1, 0x15, 0x00, 0xef, 0xc2, 0x15, + 0xc0, 0x00, 0xef, 0xec, 0x18, 0x40, 0xe9, 0xee, 0x14, 0x40, 0x07, 0x78, + 0xd3, 0x4c, 0xe1, 0x4b, 0x15, 0x80, 0x3a, 0xe5, 0x42, 0x15, 0x00, 0xe9, + 0x46, 0x15, 0x80, 0x2d, 0xef, 0x48, 0x15, 0x80, 0x24, 0xb7, 0x01, 0xff, + 0xe1, 0xd3, 0x18, 0x80, 0x18, 0x42, 0x27, 0x01, 0xce, 0x18, 0x00, 0xe9, + 0xcf, 0x18, 0x80, 0x09, 0xef, 0xd1, 0x18, 0xc0, 0x00, 0xef, 0xd2, 0x18, + 0x40, 0xe9, 0xd0, 0x18, 0x40, 0xe1, 0x4e, 0x15, 0x40, 0xef, 0x49, 0x15, + 0x40, 0xe9, 0x47, 0x15, 0x40, 0xe1, 0x4c, 0x15, 0x80, 0x04, 0xf9, 0xc5, + 0x18, 0x40, 0xe9, 0x45, 0x15, 0x40, 0xe5, 0x43, 0x15, 0x00, 0x42, 0x15, + 0x01, 0xe0, 0x18, 0x40, 0xe1, 0x83, 0x15, 0x80, 0x12, 0xe9, 0x7f, 0x15, + 0x80, 0x09, 0xef, 0x81, 0x15, 0xc0, 0x00, 0xef, 0x82, 0x15, 0x40, 0xe9, + 0x80, 0x15, 0x40, 0xe1, 0x84, 0x15, 0x80, 0x04, 0xe9, 0x6f, 0x16, 0x40, + 0xe9, 0x7e, 0x15, 0x40, 0xe1, 0x38, 0x14, 0x80, 0x40, 0xe5, 0x2f, 0x14, + 0x00, 0xe9, 0x31, 0x14, 0x80, 0x33, 0xef, 0x33, 0x14, 0x80, 0x26, 0xb7, + 0x01, 0xff, 0xe1, 0x44, 0x14, 0x80, 0x1a, 0xe5, 0x3a, 0x14, 0x00, 0xe9, + 0x3c, 0x14, 0x80, 0x0d, 0xef, 0x40, 0x14, 0xc0, 0x00, 0xef, 0x42, 0x14, + 0x00, 0xf9, 0xb6, 0x18, 0x40, 0xe9, 0x3e, 0x14, 0x40, 0xe1, 0x46, 0x14, + 0x40, 0xef, 0x34, 0x14, 0x00, 0xf9, 0xb4, 0x18, 0x40, 0xe9, 0x32, 0x14, + 0x40, 0xe1, 0x39, 0x14, 0x80, 0x04, 0xf9, 0xb5, 0x18, 0x40, 0xe9, 0x30, + 0x14, 0x40, 0x07, 0x1e, 0xd8, 0x0c, 0xee, 0x2d, 0x14, 0x00, 0xef, 0x06, + 0x14, 0x00, 0xf9, 0xb0, 0x18, 0x40, 0xe3, 0xd7, 0x18, 0x00, 0xeb, 0xd6, + 0x18, 0x00, 0xed, 0xd8, 0x18, 0x00, 0xee, 0xd9, 0x18, 0x80, 0x11, 0xf0, + 0xd4, 0x18, 0x00, 0xf3, 0xda, 0x18, 0x80, 0x04, 0xf4, 0xd5, 0x18, 0x40, + 0xe8, 0xdb, 0x18, 0x40, 0xb7, 0x01, 0xff, 0xe9, 0xc7, 0x18, 0x80, 0x09, + 0xef, 0xcb, 0x18, 0xc0, 0x00, 0xef, 0xcd, 0x18, 0x40, 0xe9, 0xc9, 0x18, + 0x40, 0x08, 0x6f, 0xc8, 0xf3, 0x02, 0xe1, 0xc7, 0x14, 0x80, 0xbd, 0x01, + 0xe5, 0xc0, 0x14, 0x00, 0xe7, 0x95, 0x15, 0x80, 0x8f, 0x01, 0xe8, 0xd2, + 0x14, 0x00, 0xe9, 0xc2, 0x14, 0x80, 0x81, 0x01, 0x42, 0x1d, 0x01, 0x96, + 0x15, 0x80, 0x5f, 0xef, 0xc4, 0x14, 0x80, 0x52, 0x04, 0xd4, 0xf8, 0x22, + 0xb7, 0x01, 0xff, 0xe1, 0xcb, 0x14, 0x80, 0x16, 0xe5, 0xc9, 0x14, 0x00, + 0xe9, 0xc6, 0x18, 0x80, 0x09, 0xef, 0xca, 0x18, 0xc0, 0x00, 0xef, 0xcc, + 0x18, 0x40, 0xe9, 0xc8, 0x18, 0x40, 0xe1, 0xcd, 0x14, 0x40, 0x44, 0x68, + 0xf6, 0x7b, 0x15, 0x80, 0x06, 0x44, 0x6c, 0x53, 0x7c, 0x15, 0x40, 0xe1, + 0x79, 0x15, 0x80, 0x16, 0xe5, 0x74, 0x15, 0x00, 0xe9, 0x75, 0x15, 0x80, + 0x09, 0xef, 0x77, 0x15, 0xc0, 0x00, 0xef, 0x78, 0x15, 0x40, 0xe9, 0x76, + 0x15, 0x40, 0xe1, 0x7a, 0x15, 0x40, 0xef, 0xc5, 0x14, 0x00, 0xf9, 0xbb, + 0x18, 0x40, 0xe1, 0x75, 0x16, 0x80, 0x12, 0xe9, 0x71, 0x16, 0x80, 0x09, + 0xef, 0x73, 0x16, 0xc0, 0x00, 0xef, 0x74, 0x16, 0x40, 0xe9, 0x72, 0x16, + 0x40, 0xe1, 0x76, 0x16, 0x40, 0xe9, 0xc3, 0x14, 0x40, 0xe1, 0x93, 0x15, + 0x80, 0x12, 0xe9, 0x8f, 0x15, 0x80, 0x09, 0xef, 0x91, 0x15, 0xc0, 0x00, + 0xef, 0x92, 0x15, 0x40, 0xe9, 0x90, 0x15, 0x40, 0xe1, 0x94, 0x15, 0x80, + 0x04, 0xe9, 0x70, 0x16, 0x40, 0xe9, 0x8e, 0x15, 0x40, 0xe1, 0xc8, 0x14, + 0x80, 0xa6, 0x01, 0x06, 0xee, 0xe5, 0x45, 0x07, 0x8c, 0xdc, 0x04, 0xf9, + 0xbc, 0x18, 0x40, 0xa8, 0x20, 0x03, 0x22, 0x60, 0x01, 0xff, 0xe1, 0xba, + 0x1a, 0x81, 0x12, 0xe9, 0xb6, 0x1a, 0x81, 0x09, 0xef, 0xb8, 0x1a, 0xc1, + 0x00, 0xef, 0xb9, 0x1a, 0x41, 0xe9, 0xb7, 0x1a, 0x41, 0xe1, 0xbb, 0x1a, + 0x41, 0xe1, 0xb4, 0x1a, 0x81, 0x12, 0xe9, 0xb0, 0x1a, 0x81, 0x09, 0xef, + 0xb2, 0x1a, 0xc1, 0x00, 0xef, 0xb3, 0x1a, 0x41, 0xe9, 0xb1, 0x1a, 0x41, + 0xe1, 0xb5, 0x1a, 0x41, 0x44, 0x54, 0xf5, 0xa0, 0x14, 0x00, 0x44, 0xdc, + 0xf6, 0x82, 0x14, 0x00, 0x44, 0x40, 0xf7, 0xba, 0x14, 0x00, 0x44, 0xa0, + 0xf7, 0xcf, 0x14, 0x00, 0xb3, 0x1a, 0x44, 0x13, 0xf2, 0x65, 0x14, 0x00, + 0xb7, 0x06, 0x44, 0x50, 0xf9, 0x3d, 0x15, 0x40, 0x42, 0x4e, 0x13, 0x1b, + 0x14, 0x00, 0x42, 0xcd, 0x02, 0x16, 0x14, 0x40, 0x42, 0x26, 0x21, 0x0b, + 0x15, 0x00, 0x43, 0x54, 0xf5, 0x0f, 0x15, 0x00, 0x42, 0xa8, 0x0b, 0x0a, + 0x15, 0x80, 0x12, 0x43, 0x51, 0x02, 0x0c, 0x15, 0x00, 0x43, 0xed, 0x01, + 0x0d, 0x15, 0x00, 0x43, 0xba, 0x90, 0x04, 0x15, 0x40, 0xe1, 0x0e, 0x15, + 0x40, 0xe9, 0xc1, 0x14, 0x40, 0xe5, 0x5f, 0x15, 0x00, 0xe9, 0x61, 0x15, + 0xc0, 0x00, 0xe9, 0x63, 0x15, 0x40, 0xe1, 0xaa, 0x14, 0x80, 0x51, 0xe5, + 0xa3, 0x14, 0x80, 0x3f, 0xe8, 0xbd, 0x14, 0x00, 0xe9, 0xa5, 0x14, 0x80, + 0x32, 0xef, 0xa7, 0x14, 0x80, 0x22, 0xb7, 0x01, 0xff, 0xe1, 0xb6, 0x14, + 0x80, 0x16, 0xe5, 0xac, 0x14, 0x00, 0xe9, 0xae, 0x14, 0x80, 0x09, 0xef, + 0xb2, 0x14, 0xc0, 0x00, 0xef, 0xb4, 0x14, 0x40, 0xe9, 0xb0, 0x14, 0x40, + 0xe1, 0xb8, 0x14, 0x40, 0xef, 0xa8, 0x14, 0xc0, 0x00, 0x4a, 0x7c, 0xb6, + 0x09, 0x15, 0x40, 0xe9, 0xa6, 0x14, 0x40, 0x05, 0x1a, 0x35, 0x01, 0xff, + 0xec, 0xec, 0x14, 0x00, 0xf2, 0x52, 0x15, 0x40, 0xe1, 0xab, 0x14, 0x80, + 0x04, 0xf9, 0xba, 0x18, 0x40, 0xe9, 0xa4, 0x14, 0x40, 0xe1, 0xda, 0x14, + 0x80, 0x58, 0xe5, 0xd3, 0x14, 0x00, 0xe8, 0xa6, 0x15, 0x80, 0x34, 0xe9, + 0xd5, 0x14, 0x80, 0x2b, 0xef, 0xd7, 0x14, 0x80, 0x22, 0xb7, 0x01, 0xff, + 0xe1, 0xe6, 0x14, 0x80, 0x16, 0xe5, 0xdc, 0x14, 0x00, 0xe9, 0xde, 0x14, + 0x80, 0x09, 0xef, 0xe2, 0x14, 0xc0, 0x00, 0xef, 0xe4, 0x14, 0x40, 0xe9, + 0xe0, 0x14, 0x40, 0xe1, 0xe8, 0x14, 0x40, 0xef, 0xd8, 0x14, 0x40, 0xe9, + 0xd6, 0x14, 0x40, 0xe1, 0xa4, 0x15, 0x80, 0x12, 0xe9, 0xa0, 0x15, 0x80, + 0x09, 0xef, 0xa2, 0x15, 0xc0, 0x00, 0xef, 0xa3, 0x15, 0x40, 0xe9, 0xa1, + 0x15, 0x40, 0xe1, 0xa5, 0x15, 0x40, 0xe1, 0xdb, 0x14, 0x80, 0x04, 0xf9, + 0xbd, 0x18, 0x40, 0xe9, 0xd4, 0x14, 0x40, 0xe1, 0x72, 0x14, 0x80, 0x3e, + 0xe5, 0x6b, 0x14, 0x00, 0xe9, 0x6d, 0x14, 0x80, 0x31, 0xef, 0x6f, 0x14, + 0x80, 0x28, 0xf7, 0x84, 0x14, 0xc0, 0x00, 0xe1, 0x7e, 0x14, 0x80, 0x16, + 0xe5, 0x74, 0x14, 0x00, 0xe9, 0x76, 0x14, 0x80, 0x09, 0xef, 0x7a, 0x14, + 0xc0, 0x00, 0xef, 0x7c, 0x14, 0x40, 0xe9, 0x78, 0x14, 0x40, 0xe1, 0x80, + 0x14, 0x00, 0xf9, 0xb9, 0x18, 0x40, 0xef, 0x70, 0x14, 0x40, 0xe9, 0x6e, + 0x14, 0x40, 0xe1, 0x73, 0x14, 0x80, 0x04, 0xf9, 0xb8, 0x18, 0x40, 0xe9, + 0x6c, 0x14, 0x40, 0xe9, 0x04, 0x14, 0x00, 0xee, 0x2c, 0x14, 0x40, 0xeb, + 0x7d, 0x15, 0x00, 0x45, 0x8b, 0x66, 0x00, 0x14, 0x40, 0xe1, 0x59, 0x15, + 0x80, 0x8a, 0x01, 0xe5, 0x53, 0x15, 0x00, 0xe9, 0x55, 0x15, 0x80, 0x15, + 0xef, 0x57, 0x15, 0x80, 0x0c, 0x48, 0x50, 0x17, 0x6e, 0x16, 0x00, 0x43, + 0xba, 0x90, 0x5b, 0x15, 0x40, 0xef, 0x58, 0x15, 0x40, 0xe9, 0x56, 0x15, + 0x00, 0x04, 0x66, 0x06, 0x01, 0xff, 0x45, 0x1c, 0x3b, 0x1f, 0x14, 0x00, + 0x50, 0xfa, 0x63, 0x21, 0x14, 0x00, 0x02, 0x3b, 0x01, 0x3d, 0x45, 0x51, + 0x24, 0x20, 0x14, 0x00, 0x4a, 0x1d, 0x48, 0x27, 0x14, 0x00, 0x44, 0xc6, + 0x29, 0x29, 0x14, 0x00, 0xb2, 0x14, 0xb3, 0x06, 0x4d, 0xe4, 0x8d, 0x22, + 0x14, 0x40, 0x56, 0x11, 0x36, 0x28, 0x14, 0x00, 0x49, 0x9a, 0xc1, 0xde, + 0x18, 0x40, 0x49, 0x58, 0xbb, 0xdf, 0x18, 0x00, 0xa9, 0x01, 0xff, 0x4d, + 0xc8, 0x75, 0x23, 0x14, 0x00, 0x42, 0x1d, 0x01, 0x24, 0x14, 0x40, 0x05, + 0x3d, 0x01, 0x06, 0x47, 0x15, 0x3b, 0x2a, 0x14, 0x40, 0x45, 0x1c, 0x3b, + 0x25, 0x14, 0x00, 0x56, 0x55, 0x39, 0x26, 0x14, 0x40, 0xe1, 0x5a, 0x15, + 0xc0, 0x00, 0xe9, 0x54, 0x15, 0x40, 0x48, 0x5f, 0xc9, 0xdc, 0x18, 0x00, + 0xee, 0x2b, 0x14, 0x40, 0xe1, 0x90, 0x14, 0x80, 0x3e, 0xe5, 0x89, 0x14, + 0x00, 0x47, 0x61, 0xd7, 0x6d, 0x16, 0x00, 0xe9, 0x8b, 0x14, 0x80, 0x2b, + 0xef, 0x8d, 0x14, 0x80, 0x22, 0xb7, 0x01, 0xff, 0xe1, 0x9c, 0x14, 0x80, + 0x16, 0xe5, 0x92, 0x14, 0x00, 0xe9, 0x94, 0x14, 0x80, 0x09, 0xef, 0x98, + 0x14, 0xc0, 0x00, 0xef, 0x9a, 0x14, 0x40, 0xe9, 0x96, 0x14, 0x40, 0xe1, + 0x9e, 0x14, 0x40, 0xef, 0x8e, 0x14, 0x40, 0xe9, 0x8c, 0x14, 0x40, 0xe1, + 0x91, 0x14, 0x80, 0xd6, 0x06, 0x06, 0x4a, 0x6d, 0x01, 0xff, 0x02, 0x3b, + 0x15, 0xb3, 0x06, 0xa4, 0xe0, 0x05, 0x42, 0x27, 0x01, 0x08, 0x14, 0x00, + 0xa7, 0x93, 0x05, 0xe8, 0x4b, 0x14, 0x80, 0xe7, 0x04, 0xe9, 0x09, 0x14, + 0x80, 0xdb, 0x04, 0xaa, 0x9e, 0x04, 0xab, 0xe2, 0x03, 0xac, 0xab, 0x03, + 0xad, 0x8f, 0x03, 0xae, 0xef, 0x02, 0xf0, 0xee, 0x15, 0x80, 0xd0, 0x02, + 0xb2, 0xb4, 0x02, 0xb3, 0xfa, 0x01, 0xb4, 0x54, 0xb7, 0x39, 0xb9, 0x1e, + 0xfa, 0x46, 0x16, 0xc0, 0x00, 0xe1, 0x45, 0x16, 0x00, 0xe5, 0x42, 0x16, + 0x80, 0x0c, 0xe9, 0x44, 0x16, 0x00, 0xef, 0x41, 0x16, 0x00, 0xf5, 0x40, + 0x16, 0x40, 0xe5, 0x43, 0x16, 0x40, 0xe1, 0x13, 0x16, 0x00, 0xe5, 0x10, + 0x16, 0x80, 0x0c, 0xe9, 0x12, 0x16, 0x00, 0xef, 0x0f, 0x16, 0x00, 0xf5, + 0x0e, 0x16, 0x40, 0xe5, 0x11, 0x16, 0x40, 0xe1, 0xd5, 0x15, 0x00, 0xe5, + 0xd2, 0x15, 0x80, 0x0c, 0xe9, 0xd4, 0x15, 0x00, 0xef, 0xd1, 0x15, 0x00, + 0xf5, 0xd0, 0x15, 0x40, 0xe5, 0xd3, 0x15, 0x40, 0xa8, 0x88, 0x01, 0xac, + 0x52, 0xb3, 0x37, 0xb4, 0x01, 0xff, 0xe1, 0xe7, 0x15, 0x00, 0xe5, 0xe4, + 0x15, 0x80, 0x27, 0xe9, 0xe6, 0x15, 0x00, 0xef, 0xe3, 0x15, 0x00, 0xb3, + 0x04, 0xf5, 0xe2, 0x15, 0x40, 0xe1, 0x6c, 0x16, 0x00, 0xe5, 0x69, 0x16, + 0x80, 0x0c, 0xe9, 0x6b, 0x16, 0x00, 0xef, 0x68, 0x16, 0x00, 0xf5, 0x67, + 0x16, 0x40, 0xe5, 0x6a, 0x16, 0x40, 0xe5, 0xe5, 0x15, 0x40, 0xe1, 0x60, + 0x16, 0x00, 0xe5, 0x5d, 0x16, 0x80, 0x0c, 0xe9, 0x5f, 0x16, 0x00, 0xef, + 0x5c, 0x16, 0x00, 0xf5, 0x5b, 0x16, 0x40, 0xe5, 0x5e, 0x16, 0x40, 0xe1, + 0x3f, 0x16, 0x00, 0xe5, 0x3c, 0x16, 0x80, 0x27, 0xa8, 0x0c, 0xe9, 0x3e, + 0x16, 0x00, 0xef, 0x3b, 0x16, 0x00, 0xf5, 0x3a, 0x16, 0x40, 0xe1, 0x39, + 0x16, 0x00, 0xe5, 0x36, 0x16, 0x80, 0x0c, 0xe9, 0x38, 0x16, 0x00, 0xef, + 0x35, 0x16, 0x00, 0xf5, 0x34, 0x16, 0x40, 0xe5, 0x37, 0x16, 0x40, 0xe5, + 0x3d, 0x16, 0x40, 0xe1, 0xe1, 0x15, 0x00, 0xe5, 0xde, 0x15, 0x80, 0x0c, + 0xe9, 0xe0, 0x15, 0x00, 0xef, 0xdd, 0x15, 0x00, 0xf5, 0xdc, 0x15, 0x40, + 0xe5, 0xdf, 0x15, 0x40, 0xe1, 0x53, 0x16, 0x00, 0xe5, 0x50, 0x16, 0x80, + 0x2a, 0xe8, 0x5a, 0x16, 0x80, 0x0c, 0xe9, 0x52, 0x16, 0x00, 0xef, 0x4f, + 0x16, 0x00, 0xf5, 0x4e, 0x16, 0x40, 0xe1, 0x59, 0x16, 0x00, 0xe5, 0x56, + 0x16, 0x80, 0x0c, 0xe9, 0x58, 0x16, 0x00, 0xef, 0x55, 0x16, 0x00, 0xf5, + 0x54, 0x16, 0x40, 0xe5, 0x57, 0x16, 0x40, 0xe5, 0x51, 0x16, 0x40, 0xe1, + 0xcf, 0x15, 0x00, 0xe5, 0xcc, 0x15, 0x80, 0x0c, 0xe9, 0xce, 0x15, 0x00, + 0xef, 0xcb, 0x15, 0x00, 0xf5, 0xca, 0x15, 0x40, 0xe5, 0xcd, 0x15, 0x40, + 0xe1, 0xed, 0x15, 0x00, 0xe5, 0xea, 0x15, 0x80, 0x0c, 0xe9, 0xec, 0x15, + 0x00, 0xef, 0xe9, 0x15, 0x00, 0xf5, 0xe8, 0x15, 0x40, 0xe5, 0xeb, 0x15, + 0x40, 0xe1, 0x07, 0x16, 0x00, 0xe5, 0x04, 0x16, 0x80, 0x10, 0xe7, 0xd1, + 0x14, 0x00, 0xe9, 0x06, 0x16, 0x00, 0xef, 0x03, 0x16, 0x00, 0xf5, 0x02, + 0x16, 0x40, 0xe5, 0x05, 0x16, 0x40, 0xe1, 0x0d, 0x16, 0x00, 0xe5, 0x0a, + 0x16, 0x80, 0x0c, 0xe9, 0x0c, 0x16, 0x00, 0xef, 0x09, 0x16, 0x00, 0xf5, + 0x08, 0x16, 0x40, 0xe5, 0x0b, 0x16, 0x40, 0xe1, 0x27, 0x16, 0x00, 0xe5, + 0x24, 0x16, 0x80, 0x27, 0xa8, 0x0c, 0xe9, 0x26, 0x16, 0x00, 0xef, 0x23, + 0x16, 0x00, 0xf5, 0x22, 0x16, 0x40, 0xe1, 0x33, 0x16, 0x00, 0xe5, 0x30, + 0x16, 0x80, 0x0c, 0xe9, 0x32, 0x16, 0x00, 0xef, 0x2f, 0x16, 0x00, 0xf5, + 0x2e, 0x16, 0x40, 0xe5, 0x31, 0x16, 0x40, 0xe5, 0x25, 0x16, 0x40, 0xa8, + 0x1e, 0xeb, 0x01, 0x16, 0xc0, 0x00, 0xe1, 0x00, 0x16, 0x00, 0xe5, 0xfd, + 0x15, 0x80, 0x0c, 0xe9, 0xff, 0x15, 0x00, 0xef, 0xfc, 0x15, 0x00, 0xf5, + 0xfb, 0x15, 0x40, 0xe5, 0xfe, 0x15, 0x40, 0xe1, 0xfa, 0x15, 0x00, 0xe5, + 0xf7, 0x15, 0x80, 0x0c, 0xe9, 0xf9, 0x15, 0x00, 0xef, 0xf6, 0x15, 0x00, + 0xf5, 0xf5, 0x15, 0x40, 0xe5, 0xf8, 0x15, 0x40, 0xe1, 0x1b, 0x16, 0x00, + 0xe5, 0x17, 0x16, 0x80, 0x2d, 0xe9, 0x19, 0x16, 0x00, 0xaa, 0x0e, 0xef, + 0x16, 0x16, 0x00, 0xf5, 0x14, 0x16, 0x00, 0x42, 0xa9, 0x01, 0xf2, 0x18, + 0x40, 0xe1, 0x21, 0x16, 0x00, 0xe5, 0x1e, 0x16, 0x80, 0x0c, 0xe9, 0x20, + 0x16, 0x00, 0xef, 0x1d, 0x16, 0x00, 0xf5, 0x1c, 0x16, 0x40, 0xe5, 0x1f, + 0x16, 0x40, 0xe5, 0x18, 0x16, 0x40, 0x48, 0x6f, 0xce, 0x47, 0x16, 0x40, + 0x42, 0x27, 0x01, 0x36, 0x14, 0x00, 0xe9, 0x37, 0x14, 0x00, 0xb7, 0x01, + 0xff, 0xe1, 0xdb, 0x15, 0x00, 0xe5, 0xd8, 0x15, 0x80, 0x0c, 0xe9, 0xda, + 0x15, 0x00, 0xef, 0xd7, 0x15, 0x00, 0xf5, 0xd6, 0x15, 0x40, 0xe5, 0xd9, + 0x15, 0x40, 0xe1, 0xf4, 0x15, 0x80, 0x3b, 0xe5, 0xf1, 0x15, 0x80, 0x32, + 0xa8, 0x17, 0xe9, 0xf3, 0x15, 0x00, 0xef, 0xf0, 0x15, 0x00, 0xf5, 0xef, + 0x15, 0x00, 0xb7, 0x01, 0xff, 0xe1, 0xf0, 0x18, 0x00, 0xf5, 0xed, 0x18, + 0x40, 0xe1, 0xc9, 0x15, 0x00, 0xe5, 0xc6, 0x15, 0x80, 0x0c, 0xe9, 0xc8, + 0x15, 0x00, 0xef, 0xc5, 0x15, 0x00, 0xf5, 0xc4, 0x15, 0x40, 0xe5, 0xc7, + 0x15, 0x40, 0xe5, 0xf2, 0x15, 0x40, 0xe1, 0xef, 0x18, 0x40, 0xa5, 0x3b, + 0xe9, 0x54, 0x14, 0x00, 0xac, 0x1c, 0xba, 0x01, 0xff, 0xe1, 0x4d, 0x16, + 0x00, 0xe5, 0x4a, 0x16, 0x80, 0x0c, 0xe9, 0x4c, 0x16, 0x00, 0xef, 0x49, + 0x16, 0x00, 0xf5, 0x48, 0x16, 0x40, 0xe5, 0x4b, 0x16, 0x40, 0xe1, 0x2d, + 0x16, 0x00, 0xe5, 0x2a, 0x16, 0x80, 0x0c, 0xe9, 0x2c, 0x16, 0x00, 0xef, + 0x29, 0x16, 0x00, 0xf5, 0x28, 0x16, 0x40, 0xe5, 0x2b, 0x16, 0x40, 0xe5, + 0x53, 0x14, 0x00, 0xae, 0x01, 0xff, 0x45, 0xa7, 0xeb, 0xee, 0x18, 0x00, + 0x45, 0x4e, 0x05, 0xf5, 0x18, 0x40, 0xe1, 0x66, 0x16, 0x00, 0xe5, 0x63, + 0x16, 0x80, 0x0c, 0xe9, 0x65, 0x16, 0x00, 0xef, 0x62, 0x16, 0x00, 0xf5, + 0x61, 0x16, 0x40, 0xe5, 0x64, 0x16, 0x40, 0xe9, 0x8a, 0x14, 0x40, 0x0b, + 0x9d, 0xa0, 0x58, 0x4b, 0x76, 0xa2, 0x3f, 0x15, 0x00, 0x09, 0xf8, 0xc0, + 0x01, 0xff, 0xe1, 0xb3, 0x15, 0x00, 0xe5, 0xb0, 0x15, 0x00, 0xe9, 0xb1, + 0x15, 0x00, 0xab, 0x2f, 0xae, 0x1d, 0xef, 0xb2, 0x15, 0x00, 0xf3, 0x08, + 0x15, 0x00, 0xf7, 0x7f, 0x16, 0xc0, 0x00, 0xe1, 0xb7, 0x15, 0x00, 0xe5, + 0xb4, 0x15, 0x00, 0xe9, 0xb5, 0x15, 0x00, 0xef, 0xb6, 0x15, 0x40, 0xe1, + 0xbb, 0x15, 0x00, 0xe5, 0xb8, 0x15, 0x00, 0xe9, 0xb9, 0x15, 0x00, 0xef, + 0xba, 0x15, 0x40, 0xe1, 0xbf, 0x15, 0x00, 0xe5, 0xbc, 0x15, 0x00, 0xe9, + 0xbd, 0x15, 0x00, 0xef, 0xbe, 0x15, 0x40, 0xec, 0xf3, 0x18, 0x00, 0xf2, + 0xf4, 0x18, 0x40, 0xe1, 0x0b, 0x14, 0x80, 0x1f, 0xe9, 0x1c, 0x14, 0x80, + 0x14, 0xee, 0x2e, 0x14, 0x00, 0x0a, 0x76, 0xb7, 0x04, 0xf9, 0xb1, 0x18, + 0x40, 0xed, 0xbe, 0x14, 0x00, 0xf3, 0x06, 0x15, 0x40, 0x47, 0x34, 0xdd, + 0xaf, 0x15, 0x40, 0xe9, 0x02, 0x14, 0x00, 0xf9, 0xb2, 0x18, 0x40, 0x43, + 0xdc, 0x01, 0xf7, 0xf4, 0x81, 0x06, 0x44, 0xc9, 0x31, 0xd5, 0xf3, 0x41, + 0x4b, 0x22, 0x9d, 0xf8, 0xf4, 0x41, 0x45, 0x05, 0x84, 0xc5, 0xf4, 0x01, + 0x49, 0xef, 0xc0, 0x19, 0xf9, 0x41, 0x45, 0xef, 0xe9, 0x06, 0x21, 0x00, + 0x45, 0xf1, 0xe0, 0x24, 0x26, 0x40, 0xa1, 0xf8, 0x58, 0xa5, 0xf1, 0x4f, + 0x09, 0xee, 0xbe, 0x85, 0x4b, 0xa9, 0xa7, 0x4a, 0xac, 0xa3, 0x34, 0xaf, + 0xf2, 0x22, 0x42, 0x33, 0x11, 0x82, 0x00, 0x00, 0xb2, 0xf6, 0x12, 0xf3, + 0x08, 0x00, 0x00, 0xb5, 0xc0, 0x0f, 0xb9, 0x01, 0xff, 0x4d, 0xb0, 0x8d, + 0xff, 0xfe, 0x00, 0x17, 0xea, 0x33, 0x01, 0xff, 0xa1, 0xba, 0x0d, 0x02, + 0x3b, 0x15, 0x80, 0x0d, 0xa4, 0xd9, 0x0b, 0xa5, 0xa0, 0x0b, 0xa6, 0xf4, + 0x09, 0xa7, 0x91, 0x09, 0xa9, 0xcc, 0x08, 0xab, 0xf4, 0x06, 0xac, 0xbe, + 0x06, 0xad, 0xc9, 0x05, 0x44, 0x50, 0xf7, 0x40, 0xd0, 0x01, 0xaf, 0xfb, + 0x04, 0xb0, 0xd4, 0x03, 0xb2, 0xc5, 0x03, 0xb3, 0xa3, 0x02, 0xb4, 0x8b, + 0x01, 0x02, 0x61, 0x0b, 0x63, 0x4c, 0x14, 0x9c, 0x6a, 0xd0, 0x01, 0xb9, + 0x01, 0xff, 0x02, 0x2e, 0x1b, 0x1e, 0xb0, 0x01, 0xff, 0xaf, 0x06, 0x44, + 0x48, 0x8d, 0x50, 0xd0, 0x41, 0x46, 0x66, 0xe3, 0x0a, 0xd0, 0x81, 0x06, + 0x44, 0x64, 0xf8, 0x53, 0xd0, 0x41, 0x46, 0xf0, 0xdd, 0x0b, 0xd0, 0x41, + 0x02, 0x92, 0x00, 0x28, 0x04, 0x03, 0x23, 0x01, 0xff, 0x51, 0xc3, 0x5a, + 0xd4, 0xd0, 0x01, 0x55, 0x6c, 0x3c, 0xd6, 0xd0, 0x01, 0x5c, 0xc4, 0x19, + 0xd5, 0xd0, 0x01, 0x03, 0x19, 0x01, 0x01, 0xff, 0x55, 0x7d, 0x3d, 0xd7, + 0xd0, 0x01, 0x48, 0x4b, 0x36, 0xcd, 0xd0, 0x41, 0x43, 0xdc, 0xd9, 0x7d, + 0xd0, 0x01, 0x44, 0xf9, 0xa4, 0x7c, 0xd0, 0x41, 0x04, 0x38, 0xf8, 0x06, + 0x43, 0x5c, 0x56, 0x19, 0xd0, 0x41, 0x80, 0x06, 0x4a, 0xdc, 0xb0, 0x21, + 0xd0, 0x41, 0x45, 0xf1, 0xdd, 0x06, 0xd0, 0x01, 0x4b, 0xd1, 0x82, 0x05, + 0xd0, 0x01, 0x43, 0xc1, 0x56, 0x58, 0xd0, 0x41, 0xa5, 0x80, 0x01, 0xa8, + 0x52, 0x46, 0xd0, 0xe2, 0x27, 0xd0, 0x01, 0xb2, 0x01, 0xff, 0xa9, 0x37, + 0x05, 0x8c, 0xba, 0x01, 0xff, 0x47, 0xe2, 0xd8, 0x6d, 0xd0, 0x01, 0x02, + 0x92, 0x00, 0x14, 0xb0, 0x06, 0x47, 0x00, 0xdc, 0x70, 0xd0, 0x41, 0x4a, + 0x6b, 0xa6, 0x6e, 0xd0, 0x01, 0x48, 0xa7, 0xd0, 0x6b, 0xd0, 0x41, 0xa1, + 0x06, 0x43, 0xc1, 0x56, 0x63, 0xd0, 0x41, 0x43, 0xf1, 0x1d, 0x43, 0xd0, + 0x01, 0x47, 0xdf, 0xb0, 0x36, 0xd0, 0x41, 0xe1, 0x30, 0xd0, 0x01, 0x46, + 0x16, 0xe2, 0x96, 0xd0, 0x01, 0x43, 0xbb, 0x04, 0x87, 0xd0, 0x41, 0xa5, + 0x06, 0x43, 0x0e, 0x06, 0x14, 0xd0, 0x41, 0x42, 0x6c, 0x00, 0x2d, 0xd0, + 0x81, 0x06, 0x4d, 0xb9, 0x8c, 0x79, 0xd0, 0x41, 0x47, 0xd7, 0xd2, 0x78, + 0xd0, 0x01, 0x08, 0x4f, 0xd1, 0x01, 0xff, 0x42, 0x60, 0x03, 0x76, 0xd0, + 0x01, 0x42, 0x65, 0x31, 0x77, 0xd0, 0x41, 0x44, 0x47, 0x5d, 0x0f, 0xd0, + 0x01, 0x45, 0xd2, 0x19, 0x31, 0xd0, 0x01, 0x46, 0xae, 0xe6, 0x88, 0xd0, + 0x41, 0x47, 0x07, 0xd5, 0x1d, 0xd0, 0x01, 0x45, 0xcf, 0xeb, 0x29, 0xd0, + 0x81, 0x8b, 0x01, 0x08, 0x9f, 0xcc, 0x49, 0xb4, 0x2e, 0xb9, 0x01, 0xff, + 0xae, 0x0d, 0x43, 0x8b, 0x06, 0x66, 0xd0, 0xc1, 0x00, 0x44, 0xbc, 0xe3, + 0x08, 0xd0, 0x41, 0x05, 0x21, 0xea, 0x06, 0x44, 0xf5, 0xd9, 0x13, 0xd0, + 0x41, 0x48, 0xde, 0xb0, 0x2a, 0xd0, 0x01, 0x4c, 0xc8, 0x96, 0x2b, 0xd0, + 0x01, 0x43, 0xc1, 0x56, 0x65, 0xd0, 0x41, 0x45, 0x8a, 0xea, 0x7e, 0xd0, + 0x81, 0x0c, 0x44, 0xe2, 0x20, 0xe8, 0xd0, 0x01, 0x4a, 0x82, 0xb5, 0x44, + 0xd0, 0x41, 0x49, 0xcc, 0xb9, 0x1f, 0xd0, 0x41, 0x46, 0xd6, 0xdf, 0xe2, + 0xd0, 0x81, 0x1f, 0x47, 0x3f, 0xdc, 0xde, 0xd0, 0xc1, 0x00, 0x80, 0x01, + 0xff, 0x47, 0x26, 0xd6, 0xdf, 0xd0, 0x01, 0xb4, 0x01, 0xff, 0x49, 0x4c, + 0xbe, 0xe1, 0xd0, 0x01, 0x47, 0x4a, 0xdb, 0xe0, 0xd0, 0x41, 0x80, 0x01, + 0xff, 0x47, 0x26, 0xd6, 0xe3, 0xd0, 0x01, 0xb4, 0x01, 0xff, 0x49, 0x4c, + 0xbe, 0xe5, 0xd0, 0x01, 0x47, 0x4a, 0xdb, 0xe4, 0xd0, 0x41, 0x44, 0x9f, + 0x8d, 0x69, 0xd0, 0x41, 0x46, 0xb8, 0xdf, 0x3c, 0xd0, 0x01, 0x44, 0xf5, + 0xd9, 0x25, 0xd0, 0x41, 0x02, 0x17, 0x00, 0x70, 0xa5, 0x43, 0x06, 0xa6, + 0xe2, 0x33, 0x02, 0x5a, 0x03, 0x01, 0xff, 0x05, 0xa9, 0xd0, 0x0d, 0xac, + 0x01, 0xff, 0xe9, 0x00, 0xd0, 0x01, 0x42, 0x10, 0x00, 0x17, 0xd0, 0x41, + 0x47, 0xe2, 0xd8, 0x6c, 0xd0, 0x01, 0xee, 0x39, 0xd0, 0x81, 0x0c, 0x4b, + 0x6a, 0xa6, 0x6f, 0xd0, 0x01, 0x47, 0x00, 0xdc, 0x71, 0xd0, 0x41, 0x44, + 0x9f, 0x8d, 0x5a, 0xd0, 0x41, 0x48, 0xde, 0xb0, 0x26, 0xd0, 0x01, 0x43, + 0xc1, 0x56, 0x59, 0xd0, 0x41, 0x46, 0x96, 0xe3, 0x38, 0xd0, 0x81, 0x1e, + 0x49, 0x77, 0xa6, 0x02, 0xd0, 0x01, 0x03, 0xf8, 0x2e, 0x01, 0xff, 0x42, + 0x6c, 0x00, 0x41, 0xd0, 0x01, 0xb4, 0x01, 0xff, 0xe9, 0x49, 0xd0, 0x01, + 0x49, 0xba, 0xc2, 0x4b, 0xd0, 0x41, 0x44, 0x9f, 0x8d, 0x4d, 0xd0, 0x41, + 0x02, 0x6d, 0x00, 0x06, 0x45, 0x37, 0xed, 0x1e, 0xd0, 0x41, 0x07, 0x66, + 0xd4, 0x16, 0x46, 0xba, 0xe3, 0x09, 0xd0, 0xc1, 0x00, 0x80, 0x01, 0xff, + 0x48, 0xde, 0xb0, 0x3e, 0xd0, 0x01, 0x43, 0xc1, 0x56, 0x5e, 0xd0, 0x41, + 0x48, 0xde, 0xb0, 0x3d, 0xd0, 0x01, 0x43, 0xc1, 0x56, 0x5f, 0xd0, 0x41, + 0x06, 0xae, 0xe3, 0x35, 0x45, 0x63, 0xee, 0x5b, 0xd0, 0x01, 0x04, 0x2c, + 0xf9, 0x11, 0x09, 0x70, 0xc7, 0x01, 0xff, 0x48, 0xde, 0xb0, 0x2c, 0xd0, + 0x01, 0x43, 0xc1, 0x56, 0x75, 0xd0, 0x41, 0x80, 0x06, 0x4a, 0xdc, 0xb0, + 0x20, 0xd0, 0x41, 0x45, 0xf1, 0xdd, 0x04, 0xd0, 0x01, 0x4b, 0xd1, 0x82, + 0x03, 0xd0, 0x01, 0x43, 0xc1, 0x56, 0x48, 0xd0, 0x41, 0x48, 0xde, 0xb0, + 0x15, 0xd0, 0x01, 0x43, 0xc1, 0x56, 0x47, 0xd0, 0x41, 0x08, 0x4f, 0xc9, + 0x06, 0x4a, 0x22, 0xb1, 0x57, 0xd0, 0x41, 0x05, 0x35, 0xea, 0x58, 0x4e, + 0x38, 0x7a, 0xa4, 0xd0, 0x01, 0x4d, 0x38, 0x89, 0xaa, 0xd0, 0x01, 0xb0, + 0x29, 0xb4, 0x06, 0x4b, 0x06, 0xaa, 0xb1, 0xd0, 0x41, 0x08, 0x91, 0x80, + 0x11, 0x02, 0x0d, 0x00, 0x01, 0xff, 0x46, 0x95, 0xa8, 0xa7, 0xd0, 0x01, + 0x49, 0x95, 0x80, 0xa6, 0xd0, 0x41, 0x45, 0x41, 0x7a, 0xa8, 0xd0, 0x01, + 0x4d, 0x38, 0x89, 0xa9, 0xd0, 0x41, 0x07, 0x79, 0xd8, 0x11, 0x04, 0xc1, + 0x98, 0x01, 0xff, 0x47, 0x3f, 0x7a, 0xa2, 0xd0, 0x01, 0x4b, 0x06, 0xaa, + 0xb2, 0xd0, 0x41, 0x45, 0x41, 0x7a, 0xab, 0xd0, 0x01, 0x4e, 0x90, 0x80, + 0xb3, 0xd0, 0x41, 0x4e, 0x38, 0x7a, 0xa5, 0xd0, 0x01, 0x4c, 0xc0, 0x98, + 0xa3, 0xd0, 0x41, 0xa5, 0x06, 0x46, 0xe3, 0xd8, 0x5d, 0xd0, 0x41, 0x05, + 0x64, 0xed, 0x06, 0x43, 0x99, 0xcc, 0x2e, 0xd0, 0x41, 0x4b, 0x7c, 0xa0, + 0x8b, 0xd0, 0x01, 0x4c, 0x50, 0x93, 0x8a, 0xd0, 0x01, 0x4f, 0xac, 0x71, + 0x8e, 0xd0, 0x01, 0xb4, 0x01, 0xff, 0x4f, 0x08, 0x70, 0x8d, 0xd0, 0x01, + 0x4c, 0x98, 0x99, 0x8c, 0xd0, 0x41, 0x02, 0x8a, 0x00, 0xba, 0x01, 0x06, + 0x3e, 0xe1, 0x70, 0x45, 0x1b, 0x9c, 0x24, 0xd0, 0x81, 0x5a, 0xaf, 0x3f, + 0xb2, 0x06, 0x46, 0x6c, 0xd8, 0x61, 0xd0, 0x41, 0x04, 0x00, 0xf5, 0x06, + 0x46, 0x26, 0xe1, 0x0c, 0xd0, 0x41, 0xa1, 0x0f, 0xaf, 0x01, 0xff, 0x48, + 0xbb, 0xc2, 0x4c, 0xd0, 0x01, 0x48, 0xaf, 0xd2, 0x54, 0xd0, 0x41, 0x80, + 0x06, 0x42, 0x12, 0x00, 0x32, 0xd0, 0x41, 0xa1, 0x06, 0x43, 0xc1, 0x56, + 0x83, 0xd0, 0x41, 0x43, 0xf1, 0x1d, 0x82, 0xd0, 0x01, 0x47, 0xdf, 0xb0, + 0x81, 0xd0, 0x41, 0x46, 0x80, 0xe4, 0x3a, 0xd0, 0x81, 0x0c, 0x45, 0xc5, + 0x64, 0x89, 0xd0, 0x01, 0x46, 0xbd, 0xc2, 0x4a, 0xd0, 0x41, 0x45, 0x6c, + 0xd4, 0x42, 0xd0, 0x41, 0x80, 0x01, 0xff, 0x43, 0xdc, 0xd9, 0x7f, 0xd0, + 0x01, 0x44, 0xf9, 0xa4, 0xf4, 0xd0, 0x41, 0x80, 0x27, 0x42, 0x12, 0x00, + 0x10, 0xd0, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x48, 0xde, 0xb0, 0x1c, 0xd0, + 0x01, 0x04, 0x68, 0xf7, 0x01, 0xff, 0x43, 0xdc, 0xd9, 0x4e, 0xd0, 0x01, + 0x44, 0xf9, 0xa4, 0xf2, 0xd0, 0x01, 0x44, 0x18, 0xf7, 0xf0, 0xd0, 0x41, + 0x48, 0xde, 0xb0, 0x1b, 0xd0, 0x01, 0x04, 0x68, 0xf7, 0x01, 0xff, 0x43, + 0xdc, 0xd9, 0x4f, 0xd0, 0x01, 0x44, 0xf9, 0xa4, 0xf3, 0xd0, 0x01, 0x44, + 0x18, 0xf7, 0xf1, 0xd0, 0x41, 0x03, 0x35, 0x13, 0x06, 0x45, 0xfb, 0xec, + 0x07, 0xd0, 0x41, 0x49, 0x89, 0xba, 0x37, 0xd0, 0x01, 0x43, 0x5d, 0x07, + 0x7a, 0xd0, 0x41, 0x46, 0x5a, 0xe0, 0x3f, 0xd0, 0x01, 0x02, 0x7d, 0x02, + 0x1a, 0xb3, 0x01, 0xff, 0x55, 0x31, 0x3b, 0xac, 0xd0, 0x01, 0x03, 0xb6, + 0x00, 0x01, 0xff, 0x48, 0xde, 0xb0, 0x1a, 0xd0, 0x01, 0x43, 0xc1, 0x56, + 0x46, 0xd0, 0x41, 0x47, 0x18, 0xd6, 0x98, 0xd0, 0x01, 0xa6, 0x01, 0xff, + 0x44, 0x13, 0x70, 0xb7, 0xd0, 0x01, 0x04, 0xea, 0x2b, 0x01, 0xff, 0xe1, + 0x35, 0xd0, 0x01, 0x42, 0x10, 0x00, 0xb8, 0xd0, 0x41, 0x06, 0x38, 0xe1, + 0x50, 0x02, 0x0c, 0x00, 0x06, 0x4b, 0x7d, 0xa7, 0x45, 0xd0, 0x41, 0x02, + 0xd4, 0x14, 0x11, 0x0a, 0x8a, 0xb7, 0x01, 0xff, 0x46, 0xd8, 0xd2, 0xb4, + 0xd0, 0x01, 0x47, 0x1f, 0xd6, 0xb5, 0xd0, 0x41, 0x02, 0x92, 0x00, 0x06, + 0x49, 0xc4, 0x84, 0x72, 0xd0, 0x41, 0x48, 0xde, 0xb0, 0x16, 0xd0, 0x01, + 0x04, 0x68, 0xf7, 0x11, 0x0e, 0xd0, 0x6c, 0x01, 0xff, 0x48, 0xd6, 0xbb, + 0x90, 0xd0, 0x01, 0x45, 0xd0, 0xb9, 0x91, 0xd0, 0x41, 0x43, 0xdc, 0xd9, + 0x8f, 0xd0, 0x01, 0x44, 0xf9, 0xa4, 0xf5, 0xd0, 0x41, 0x46, 0xde, 0xe0, + 0xd8, 0xd0, 0x01, 0x46, 0x3f, 0x36, 0xd9, 0xd0, 0x41, 0x09, 0x8e, 0xbb, + 0x92, 0x01, 0x5a, 0x55, 0x21, 0xc5, 0xd0, 0x01, 0x06, 0xe2, 0x42, 0x01, + 0xff, 0x48, 0xde, 0xb0, 0x34, 0xd0, 0x81, 0x7a, 0x0a, 0xa2, 0xae, 0x45, + 0x54, 0x3f, 0x44, 0xcc, 0xd0, 0x01, 0x56, 0x3d, 0x36, 0xcb, 0xd0, 0x01, + 0x0f, 0x41, 0x73, 0x29, 0xae, 0x1b, 0x08, 0x5b, 0x21, 0x01, 0xff, 0x07, + 0x63, 0x21, 0x06, 0x4b, 0x19, 0xa0, 0xbe, 0xd0, 0x41, 0x46, 0x48, 0xe6, + 0xc6, 0xd0, 0x01, 0x45, 0x6a, 0x21, 0xc5, 0xd0, 0x41, 0x49, 0xc4, 0xbb, + 0xbc, 0xd0, 0x01, 0x45, 0xe8, 0xeb, 0xc7, 0xd0, 0x41, 0x48, 0xc7, 0xca, + 0xc3, 0xd0, 0x01, 0x4a, 0x7a, 0xb3, 0xc4, 0xd0, 0x41, 0x42, 0x00, 0x00, + 0xbd, 0xd0, 0x01, 0x42, 0x37, 0x01, 0xbf, 0xd0, 0x01, 0xae, 0x0c, 0x42, + 0xe0, 0x09, 0xba, 0xd0, 0x01, 0x42, 0x0f, 0x00, 0xc0, 0xd0, 0x41, 0x43, + 0x19, 0x13, 0xbb, 0xd0, 0x01, 0x02, 0xf1, 0x03, 0x01, 0xff, 0x43, 0xdc, + 0xd9, 0xc2, 0xd0, 0x01, 0x44, 0xf9, 0xa4, 0xc1, 0xd0, 0x41, 0x4f, 0x75, + 0x6c, 0xb9, 0xd0, 0x41, 0x48, 0xc7, 0xca, 0xb0, 0xd0, 0x01, 0x4a, 0x7a, + 0xb3, 0xaf, 0xd0, 0x01, 0x4b, 0x90, 0xa8, 0xae, 0xd0, 0x41, 0x49, 0xd4, + 0xc0, 0x64, 0xd0, 0x01, 0x46, 0x7e, 0xe3, 0x55, 0xd0, 0x01, 0xae, 0x1c, + 0x47, 0x8d, 0xda, 0x68, 0xd0, 0x01, 0x06, 0x8a, 0xe6, 0x06, 0x4e, 0xce, + 0x82, 0x0e, 0xd0, 0x41, 0x4d, 0xc0, 0x84, 0x74, 0xd0, 0x01, 0x4b, 0x6a, + 0xa6, 0x60, 0xd0, 0x41, 0x54, 0xd7, 0x42, 0xb6, 0xd0, 0x01, 0x47, 0x2d, + 0xd6, 0x7b, 0xd0, 0x41, 0x45, 0x71, 0xea, 0x01, 0xd0, 0x01, 0xa9, 0x06, + 0x42, 0xe0, 0x49, 0x2f, 0xd0, 0x41, 0xa1, 0x6d, 0x05, 0x02, 0x23, 0x3d, + 0x4a, 0xf6, 0xaf, 0xe7, 0xd0, 0x01, 0xa7, 0x0d, 0x43, 0xbb, 0x04, 0x86, + 0xd0, 0xc1, 0x00, 0x49, 0xdd, 0xb0, 0x80, 0xd0, 0x41, 0x45, 0x17, 0xe2, + 0x92, 0xd0, 0x81, 0x06, 0x48, 0xe7, 0xcf, 0xe6, 0xd0, 0x41, 0x0f, 0xcf, + 0x6c, 0x01, 0xff, 0x09, 0xd6, 0xbb, 0x06, 0x45, 0xd0, 0xb9, 0x95, 0xd0, + 0x41, 0x43, 0xdc, 0xd9, 0x94, 0xd0, 0x01, 0x44, 0xf9, 0xa4, 0x93, 0xd0, + 0x41, 0x51, 0xc3, 0x5a, 0xd0, 0xd0, 0x01, 0x55, 0x6c, 0x3c, 0xd2, 0xd0, + 0x01, 0x5c, 0xc4, 0x19, 0xd1, 0xd0, 0x01, 0xb4, 0x01, 0xff, 0x4c, 0x47, + 0x36, 0xcf, 0xd0, 0x01, 0x02, 0x0d, 0x00, 0x01, 0xff, 0x55, 0x7d, 0x3d, + 0xd3, 0xd0, 0x01, 0x48, 0x4b, 0x36, 0xce, 0xd0, 0x41, 0x44, 0x1b, 0xd6, + 0x99, 0xd0, 0x01, 0x06, 0x24, 0xe6, 0x01, 0xff, 0x06, 0xbe, 0xdf, 0x0c, + 0x45, 0xf1, 0xdd, 0xdc, 0xd0, 0x01, 0x47, 0x3f, 0xdc, 0xdd, 0xd0, 0x41, + 0x45, 0xbb, 0xeb, 0xdb, 0xd0, 0x01, 0x44, 0x3b, 0x9a, 0xda, 0xd0, 0x41, + 0x04, 0x8f, 0x68, 0x27, 0x07, 0xf3, 0xd9, 0x17, 0x04, 0x50, 0xf8, 0x01, + 0xff, 0x46, 0x60, 0xe3, 0xc9, 0xd0, 0x01, 0x46, 0x00, 0xe6, 0xca, 0xd0, + 0x01, 0x45, 0x9b, 0xf2, 0xc8, 0xd0, 0x41, 0x48, 0xde, 0xb0, 0x3b, 0xd0, + 0x01, 0x43, 0xc1, 0x56, 0x67, 0xd0, 0x41, 0xe9, 0x56, 0xd0, 0x01, 0x42, + 0x10, 0x00, 0x18, 0xd0, 0x41, 0x05, 0xa1, 0xec, 0xb3, 0x01, 0xae, 0x99, + 0x01, 0xb0, 0x40, 0xb2, 0x01, 0xff, 0x02, 0xd4, 0x14, 0x2f, 0x06, 0x6c, + 0xe3, 0x01, 0xff, 0x42, 0x00, 0x00, 0xec, 0xd0, 0x01, 0x42, 0x24, 0x02, + 0xeb, 0xd0, 0x01, 0x42, 0x37, 0x01, 0xed, 0xd0, 0x01, 0x42, 0x51, 0x03, + 0xef, 0xd0, 0x01, 0x42, 0xe0, 0x09, 0xe9, 0xd0, 0x01, 0x43, 0x28, 0x2f, + 0xea, 0xd0, 0x01, 0x42, 0x0f, 0x00, 0xee, 0xd0, 0x41, 0xee, 0x97, 0xd0, + 0x01, 0x49, 0xc4, 0x84, 0x73, 0xd0, 0x41, 0x05, 0x15, 0xec, 0x47, 0x42, + 0xc3, 0x01, 0x85, 0xd0, 0x01, 0xaf, 0x01, 0xff, 0x06, 0xcc, 0xe0, 0x2e, + 0x06, 0x2a, 0xe6, 0x06, 0x45, 0xff, 0x55, 0x23, 0xd0, 0x41, 0x02, 0xf1, + 0x03, 0x14, 0xf3, 0x11, 0xd0, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x45, 0xf1, + 0xdd, 0x12, 0xd0, 0x01, 0x43, 0xc1, 0x56, 0x51, 0xd0, 0x41, 0x4d, 0x96, + 0x8d, 0x52, 0xd0, 0x01, 0x50, 0x36, 0x3b, 0xad, 0xd0, 0x41, 0x48, 0xde, + 0xb0, 0x22, 0xd0, 0x01, 0x43, 0xc1, 0x56, 0x84, 0xd0, 0x41, 0x4a, 0xd2, + 0x82, 0x0d, 0xd0, 0x01, 0x46, 0x68, 0xe7, 0x33, 0xd0, 0x41, 0x4a, 0x62, + 0xad, 0x28, 0xd0, 0x01, 0x06, 0x9c, 0xe6, 0x01, 0xff, 0x47, 0x6b, 0xd8, + 0x62, 0xd0, 0x01, 0x42, 0x6c, 0x00, 0x5c, 0xd0, 0x41, 0x03, 0x01, 0x14, + 0x2f, 0x04, 0x16, 0xe2, 0x21, 0x02, 0x2a, 0x02, 0x11, 0x05, 0xee, 0xef, + 0x01, 0xff, 0x44, 0x74, 0x4d, 0x9a, 0xd0, 0x01, 0x45, 0xa6, 0xec, 0xa1, + 0xd0, 0x41, 0x42, 0x5a, 0x03, 0x9e, 0xd0, 0x01, 0x44, 0x19, 0x01, 0x9d, + 0xd0, 0x41, 0xe9, 0x9f, 0xd0, 0x01, 0x45, 0x99, 0xef, 0xa0, 0xd0, 0x41, + 0xe9, 0x9c, 0xd0, 0x01, 0x45, 0x99, 0xef, 0x9b, 0xd0, 0x41, 0x04, 0x53, + 0x80, 0xa0, 0x03, 0x44, 0x8b, 0x09, 0xa3, 0xfa, 0x01, 0xe7, 0x1b, 0xf4, + 0x81, 0xdb, 0x01, 0x04, 0x24, 0xf6, 0x60, 0x53, 0x73, 0x4c, 0xd7, 0xf3, + 0x01, 0x02, 0x60, 0x07, 0x2d, 0x45, 0x70, 0xf0, 0x2f, 0xf3, 0x01, 0xf3, + 0x8c, 0xf6, 0x81, 0x0d, 0x44, 0x15, 0x06, 0xc8, 0xf9, 0xc1, 0x00, 0x43, + 0x7f, 0x79, 0x8b, 0xf9, 0x41, 0x45, 0x54, 0x03, 0x8f, 0xf6, 0x01, 0xb4, + 0x01, 0xff, 0x4e, 0x9d, 0x36, 0x64, 0xf4, 0x01, 0x4f, 0x20, 0x76, 0x65, + 0xf4, 0x41, 0x42, 0x14, 0x06, 0x22, 0x20, 0x80, 0x13, 0x44, 0xe7, 0x2e, + 0x6b, 0xf5, 0x81, 0x06, 0x44, 0x98, 0xf8, 0xce, 0x25, 0x40, 0x51, 0x08, + 0x5a, 0x6c, 0xf5, 0x41, 0x80, 0x01, 0xff, 0x50, 0xda, 0x66, 0xdb, 0xf7, + 0x01, 0x48, 0xa0, 0x1e, 0x19, 0x22, 0x40, 0x07, 0x13, 0x06, 0x0d, 0x0b, + 0xc7, 0x7a, 0x01, 0xff, 0xe9, 0x52, 0x17, 0x00, 0xf5, 0x53, 0x17, 0x40, + 0xe1, 0x40, 0x17, 0x00, 0x42, 0x16, 0x00, 0x4a, 0x17, 0x00, 0x42, 0x7b, + 0x08, 0x47, 0x17, 0x00, 0x42, 0x24, 0x02, 0x44, 0x17, 0x00, 0x42, 0x22, + 0x00, 0x51, 0x17, 0x00, 0xe9, 0x41, 0x17, 0x00, 0x42, 0x1b, 0x02, 0x43, + 0x17, 0x00, 0x42, 0x74, 0x00, 0x4e, 0x17, 0x00, 0x42, 0x6c, 0x00, 0x4b, + 0x17, 0x00, 0xae, 0x28, 0x42, 0xe0, 0x09, 0x49, 0x17, 0x00, 0x42, 0x71, + 0x00, 0x4d, 0x17, 0x00, 0x42, 0x40, 0x06, 0x50, 0x17, 0x00, 0x42, 0x12, + 0x00, 0x46, 0x17, 0x00, 0xf5, 0x42, 0x17, 0x00, 0x42, 0xa9, 0x01, 0x4f, + 0x17, 0x00, 0x42, 0xdf, 0x23, 0x4c, 0x17, 0x40, 0xe1, 0x48, 0x17, 0x00, + 0x42, 0x24, 0x02, 0x45, 0x17, 0x40, 0x06, 0xda, 0x87, 0x01, 0xff, 0x4e, + 0xd2, 0x7a, 0x1f, 0x1a, 0x00, 0x07, 0x13, 0x06, 0x21, 0x47, 0x5c, 0xda, + 0x1e, 0x1a, 0x00, 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0x42, 0x42, 0x10, 0x1b, + 0x1a, 0x00, 0xe5, 0x19, 0x1a, 0x00, 0xe9, 0x17, 0x1a, 0x00, 0xef, 0x1a, + 0x1a, 0x00, 0xf5, 0x18, 0x1a, 0x40, 0xe1, 0x15, 0x1a, 0x00, 0x42, 0x16, + 0x00, 0x05, 0x1a, 0x00, 0x42, 0x37, 0x00, 0x0c, 0x1a, 0x00, 0x42, 0x7b, + 0x08, 0x09, 0x1a, 0x00, 0x42, 0x24, 0x02, 0x01, 0x1a, 0x00, 0x42, 0x22, + 0x00, 0x16, 0x1a, 0x00, 0x42, 0x78, 0x1a, 0x0d, 0x1a, 0x00, 0x42, 0x1b, + 0x02, 0x00, 0x1a, 0x00, 0x42, 0x74, 0x00, 0x12, 0x1a, 0x00, 0xad, 0x49, + 0xae, 0x24, 0x42, 0xe0, 0x09, 0x04, 0x1a, 0x00, 0x42, 0x71, 0x00, 0x11, + 0x1a, 0x00, 0x42, 0x40, 0x06, 0x14, 0x1a, 0x00, 0x42, 0x12, 0x00, 0x08, + 0x1a, 0x00, 0x42, 0x61, 0x0b, 0x13, 0x1a, 0x00, 0x42, 0xdf, 0x23, 0x10, + 0x1a, 0x40, 0xe1, 0x0a, 0x1a, 0x00, 0xa7, 0x13, 0x42, 0x71, 0x00, 0x0b, + 0x1a, 0x00, 0xb9, 0x01, 0xff, 0xe1, 0x0e, 0x1a, 0x00, 0x42, 0x37, 0x00, + 0x0f, 0x1a, 0x40, 0xe1, 0x02, 0x1a, 0x00, 0x42, 0x1b, 0x02, 0x03, 0x1a, + 0x40, 0xe1, 0x06, 0x1a, 0x00, 0x42, 0xe0, 0x09, 0x07, 0x1a, 0x40, 0x44, + 0xb3, 0x54, 0xcb, 0xf9, 0x01, 0xf3, 0xe7, 0xfa, 0x41, 0xa1, 0x6a, 0xa5, + 0x50, 0xa9, 0x2b, 0xaf, 0x01, 0xff, 0x45, 0x02, 0xeb, 0x66, 0xf9, 0x01, + 0x04, 0xbf, 0xad, 0x0c, 0x42, 0x14, 0x05, 0xf9, 0xf9, 0x01, 0x48, 0x37, + 0xd2, 0x0e, 0xf9, 0x41, 0x43, 0x16, 0x00, 0xa6, 0x00, 0x00, 0x5b, 0xcf, + 0x1b, 0x8b, 0x23, 0x00, 0x45, 0xcf, 0x22, 0x94, 0xf4, 0x41, 0x42, 0x36, + 0x01, 0xf1, 0xf9, 0x01, 0xa4, 0x0f, 0x02, 0x69, 0x00, 0x01, 0xff, 0x44, + 0x3c, 0xf5, 0xbc, 0xf4, 0x01, 0xf3, 0x72, 0xfa, 0x41, 0x4b, 0x87, 0xa0, + 0x70, 0xf4, 0x01, 0x4b, 0x79, 0xa1, 0x09, 0xf3, 0x41, 0xa1, 0x06, 0x42, + 0x32, 0x00, 0xd8, 0x02, 0x40, 0xe4, 0x5e, 0xf3, 0x01, 0x50, 0x4a, 0x67, + 0x82, 0x00, 0x00, 0x4a, 0xfe, 0xb6, 0x31, 0xf9, 0x41, 0x04, 0x2c, 0xf6, + 0x98, 0x09, 0xa9, 0x01, 0xff, 0x0c, 0x20, 0x96, 0x04, 0xee, 0xe0, 0xf9, + 0x41, 0x45, 0x15, 0xc6, 0x00, 0x28, 0x00, 0x05, 0x98, 0xeb, 0x01, 0xff, + 0xd1, 0x01, 0x28, 0x80, 0xbe, 0x04, 0xd2, 0x02, 0x28, 0x80, 0x9c, 0x02, + 0xd3, 0x04, 0x28, 0x80, 0x8b, 0x01, 0xd4, 0x08, 0x28, 0x80, 0x43, 0xd5, + 0x10, 0x28, 0x80, 0x1f, 0xd6, 0x20, 0x28, 0x80, 0x0d, 0xd7, 0x40, 0x28, + 0x80, 0x04, 0xd8, 0x80, 0x28, 0x40, 0xd8, 0xc0, 0x28, 0x40, 0xd7, 0x60, + 0x28, 0x80, 0x04, 0xd8, 0xa0, 0x28, 0x40, 0xd8, 0xe0, 0x28, 0x40, 0xd6, + 0x30, 0x28, 0x80, 0x0d, 0xd7, 0x50, 0x28, 0x80, 0x04, 0xd8, 0x90, 0x28, + 0x40, 0xd8, 0xd0, 0x28, 0x40, 0xd7, 0x70, 0x28, 0x80, 0x04, 0xd8, 0xb0, + 0x28, 0x40, 0xd8, 0xf0, 0x28, 0x40, 0xd5, 0x18, 0x28, 0x80, 0x1f, 0xd6, + 0x28, 0x28, 0x80, 0x0d, 0xd7, 0x48, 0x28, 0x80, 0x04, 0xd8, 0x88, 0x28, + 0x40, 0xd8, 0xc8, 0x28, 0x40, 0xd7, 0x68, 0x28, 0x80, 0x04, 0xd8, 0xa8, + 0x28, 0x40, 0xd8, 0xe8, 0x28, 0x40, 0xd6, 0x38, 0x28, 0x80, 0x0d, 0xd7, + 0x58, 0x28, 0x80, 0x04, 0xd8, 0x98, 0x28, 0x40, 0xd8, 0xd8, 0x28, 0x40, + 0xd7, 0x78, 0x28, 0x80, 0x04, 0xd8, 0xb8, 0x28, 0x40, 0xd8, 0xf8, 0x28, + 0x40, 0xd4, 0x0c, 0x28, 0x80, 0x43, 0xd5, 0x14, 0x28, 0x80, 0x1f, 0xd6, + 0x24, 0x28, 0x80, 0x0d, 0xd7, 0x44, 0x28, 0x80, 0x04, 0xd8, 0x84, 0x28, + 0x40, 0xd8, 0xc4, 0x28, 0x40, 0xd7, 0x64, 0x28, 0x80, 0x04, 0xd8, 0xa4, + 0x28, 0x40, 0xd8, 0xe4, 0x28, 0x40, 0xd6, 0x34, 0x28, 0x80, 0x0d, 0xd7, + 0x54, 0x28, 0x80, 0x04, 0xd8, 0x94, 0x28, 0x40, 0xd8, 0xd4, 0x28, 0x40, + 0xd7, 0x74, 0x28, 0x80, 0x04, 0xd8, 0xb4, 0x28, 0x40, 0xd8, 0xf4, 0x28, + 0x40, 0xd5, 0x1c, 0x28, 0x80, 0x1f, 0xd6, 0x2c, 0x28, 0x80, 0x0d, 0xd7, + 0x4c, 0x28, 0x80, 0x04, 0xd8, 0x8c, 0x28, 0x40, 0xd8, 0xcc, 0x28, 0x40, + 0xd7, 0x6c, 0x28, 0x80, 0x04, 0xd8, 0xac, 0x28, 0x40, 0xd8, 0xec, 0x28, + 0x40, 0xd6, 0x3c, 0x28, 0x80, 0x0d, 0xd7, 0x5c, 0x28, 0x80, 0x04, 0xd8, + 0x9c, 0x28, 0x40, 0xd8, 0xdc, 0x28, 0x40, 0xd7, 0x7c, 0x28, 0x80, 0x04, + 0xd8, 0xbc, 0x28, 0x40, 0xd8, 0xfc, 0x28, 0x40, 0xd3, 0x06, 0x28, 0x80, + 0x8b, 0x01, 0xd4, 0x0a, 0x28, 0x80, 0x43, 0xd5, 0x12, 0x28, 0x80, 0x1f, + 0xd6, 0x22, 0x28, 0x80, 0x0d, 0xd7, 0x42, 0x28, 0x80, 0x04, 0xd8, 0x82, + 0x28, 0x40, 0xd8, 0xc2, 0x28, 0x40, 0xd7, 0x62, 0x28, 0x80, 0x04, 0xd8, + 0xa2, 0x28, 0x40, 0xd8, 0xe2, 0x28, 0x40, 0xd6, 0x32, 0x28, 0x80, 0x0d, + 0xd7, 0x52, 0x28, 0x80, 0x04, 0xd8, 0x92, 0x28, 0x40, 0xd8, 0xd2, 0x28, + 0x40, 0xd7, 0x72, 0x28, 0x80, 0x04, 0xd8, 0xb2, 0x28, 0x40, 0xd8, 0xf2, + 0x28, 0x40, 0xd5, 0x1a, 0x28, 0x80, 0x1f, 0xd6, 0x2a, 0x28, 0x80, 0x0d, + 0xd7, 0x4a, 0x28, 0x80, 0x04, 0xd8, 0x8a, 0x28, 0x40, 0xd8, 0xca, 0x28, + 0x40, 0xd7, 0x6a, 0x28, 0x80, 0x04, 0xd8, 0xaa, 0x28, 0x40, 0xd8, 0xea, + 0x28, 0x40, 0xd6, 0x3a, 0x28, 0x80, 0x0d, 0xd7, 0x5a, 0x28, 0x80, 0x04, + 0xd8, 0x9a, 0x28, 0x40, 0xd8, 0xda, 0x28, 0x40, 0xd7, 0x7a, 0x28, 0x80, + 0x04, 0xd8, 0xba, 0x28, 0x40, 0xd8, 0xfa, 0x28, 0x40, 0xd4, 0x0e, 0x28, + 0x80, 0x43, 0xd5, 0x16, 0x28, 0x80, 0x1f, 0xd6, 0x26, 0x28, 0x80, 0x0d, + 0xd7, 0x46, 0x28, 0x80, 0x04, 0xd8, 0x86, 0x28, 0x40, 0xd8, 0xc6, 0x28, + 0x40, 0xd7, 0x66, 0x28, 0x80, 0x04, 0xd8, 0xa6, 0x28, 0x40, 0xd8, 0xe6, + 0x28, 0x40, 0xd6, 0x36, 0x28, 0x80, 0x0d, 0xd7, 0x56, 0x28, 0x80, 0x04, + 0xd8, 0x96, 0x28, 0x40, 0xd8, 0xd6, 0x28, 0x40, 0xd7, 0x76, 0x28, 0x80, + 0x04, 0xd8, 0xb6, 0x28, 0x40, 0xd8, 0xf6, 0x28, 0x40, 0xd5, 0x1e, 0x28, + 0x80, 0x1f, 0xd6, 0x2e, 0x28, 0x80, 0x0d, 0xd7, 0x4e, 0x28, 0x80, 0x04, + 0xd8, 0x8e, 0x28, 0x40, 0xd8, 0xce, 0x28, 0x40, 0xd7, 0x6e, 0x28, 0x80, + 0x04, 0xd8, 0xae, 0x28, 0x40, 0xd8, 0xee, 0x28, 0x40, 0xd6, 0x3e, 0x28, + 0x80, 0x0d, 0xd7, 0x5e, 0x28, 0x80, 0x04, 0xd8, 0x9e, 0x28, 0x40, 0xd8, + 0xde, 0x28, 0x40, 0xd7, 0x7e, 0x28, 0x80, 0x04, 0xd8, 0xbe, 0x28, 0x40, + 0xd8, 0xfe, 0x28, 0x40, 0xd2, 0x03, 0x28, 0x80, 0x9c, 0x02, 0xd3, 0x05, + 0x28, 0x80, 0x8b, 0x01, 0xd4, 0x09, 0x28, 0x80, 0x43, 0xd5, 0x11, 0x28, + 0x80, 0x1f, 0xd6, 0x21, 0x28, 0x80, 0x0d, 0xd7, 0x41, 0x28, 0x80, 0x04, + 0xd8, 0x81, 0x28, 0x40, 0xd8, 0xc1, 0x28, 0x40, 0xd7, 0x61, 0x28, 0x80, + 0x04, 0xd8, 0xa1, 0x28, 0x40, 0xd8, 0xe1, 0x28, 0x40, 0xd6, 0x31, 0x28, + 0x80, 0x0d, 0xd7, 0x51, 0x28, 0x80, 0x04, 0xd8, 0x91, 0x28, 0x40, 0xd8, + 0xd1, 0x28, 0x40, 0xd7, 0x71, 0x28, 0x80, 0x04, 0xd8, 0xb1, 0x28, 0x40, + 0xd8, 0xf1, 0x28, 0x40, 0xd5, 0x19, 0x28, 0x80, 0x1f, 0xd6, 0x29, 0x28, + 0x80, 0x0d, 0xd7, 0x49, 0x28, 0x80, 0x04, 0xd8, 0x89, 0x28, 0x40, 0xd8, + 0xc9, 0x28, 0x40, 0xd7, 0x69, 0x28, 0x80, 0x04, 0xd8, 0xa9, 0x28, 0x40, + 0xd8, 0xe9, 0x28, 0x40, 0xd6, 0x39, 0x28, 0x80, 0x0d, 0xd7, 0x59, 0x28, + 0x80, 0x04, 0xd8, 0x99, 0x28, 0x40, 0xd8, 0xd9, 0x28, 0x40, 0xd7, 0x79, + 0x28, 0x80, 0x04, 0xd8, 0xb9, 0x28, 0x40, 0xd8, 0xf9, 0x28, 0x40, 0xd4, + 0x0d, 0x28, 0x80, 0x43, 0xd5, 0x15, 0x28, 0x80, 0x1f, 0xd6, 0x25, 0x28, + 0x80, 0x0d, 0xd7, 0x45, 0x28, 0x80, 0x04, 0xd8, 0x85, 0x28, 0x40, 0xd8, + 0xc5, 0x28, 0x40, 0xd7, 0x65, 0x28, 0x80, 0x04, 0xd8, 0xa5, 0x28, 0x40, + 0xd8, 0xe5, 0x28, 0x40, 0xd6, 0x35, 0x28, 0x80, 0x0d, 0xd7, 0x55, 0x28, + 0x80, 0x04, 0xd8, 0x95, 0x28, 0x40, 0xd8, 0xd5, 0x28, 0x40, 0xd7, 0x75, + 0x28, 0x80, 0x04, 0xd8, 0xb5, 0x28, 0x40, 0xd8, 0xf5, 0x28, 0x40, 0xd5, + 0x1d, 0x28, 0x80, 0x1f, 0xd6, 0x2d, 0x28, 0x80, 0x0d, 0xd7, 0x4d, 0x28, + 0x80, 0x04, 0xd8, 0x8d, 0x28, 0x40, 0xd8, 0xcd, 0x28, 0x40, 0xd7, 0x6d, + 0x28, 0x80, 0x04, 0xd8, 0xad, 0x28, 0x40, 0xd8, 0xed, 0x28, 0x40, 0xd6, + 0x3d, 0x28, 0x80, 0x0d, 0xd7, 0x5d, 0x28, 0x80, 0x04, 0xd8, 0x9d, 0x28, + 0x40, 0xd8, 0xdd, 0x28, 0x40, 0xd7, 0x7d, 0x28, 0x80, 0x04, 0xd8, 0xbd, + 0x28, 0x40, 0xd8, 0xfd, 0x28, 0x40, 0xd3, 0x07, 0x28, 0x80, 0x8b, 0x01, + 0xd4, 0x0b, 0x28, 0x80, 0x43, 0xd5, 0x13, 0x28, 0x80, 0x1f, 0xd6, 0x23, + 0x28, 0x80, 0x0d, 0xd7, 0x43, 0x28, 0x80, 0x04, 0xd8, 0x83, 0x28, 0x40, + 0xd8, 0xc3, 0x28, 0x40, 0xd7, 0x63, 0x28, 0x80, 0x04, 0xd8, 0xa3, 0x28, + 0x40, 0xd8, 0xe3, 0x28, 0x40, 0xd6, 0x33, 0x28, 0x80, 0x0d, 0xd7, 0x53, + 0x28, 0x80, 0x04, 0xd8, 0x93, 0x28, 0x40, 0xd8, 0xd3, 0x28, 0x40, 0xd7, + 0x73, 0x28, 0x80, 0x04, 0xd8, 0xb3, 0x28, 0x40, 0xd8, 0xf3, 0x28, 0x40, + 0xd5, 0x1b, 0x28, 0x80, 0x1f, 0xd6, 0x2b, 0x28, 0x80, 0x0d, 0xd7, 0x4b, + 0x28, 0x80, 0x04, 0xd8, 0x8b, 0x28, 0x40, 0xd8, 0xcb, 0x28, 0x40, 0xd7, + 0x6b, 0x28, 0x80, 0x04, 0xd8, 0xab, 0x28, 0x40, 0xd8, 0xeb, 0x28, 0x40, + 0xd6, 0x3b, 0x28, 0x80, 0x0d, 0xd7, 0x5b, 0x28, 0x80, 0x04, 0xd8, 0x9b, + 0x28, 0x40, 0xd8, 0xdb, 0x28, 0x40, 0xd7, 0x7b, 0x28, 0x80, 0x04, 0xd8, + 0xbb, 0x28, 0x40, 0xd8, 0xfb, 0x28, 0x40, 0xd4, 0x0f, 0x28, 0x80, 0x43, + 0xd5, 0x17, 0x28, 0x80, 0x1f, 0xd6, 0x27, 0x28, 0x80, 0x0d, 0xd7, 0x47, + 0x28, 0x80, 0x04, 0xd8, 0x87, 0x28, 0x40, 0xd8, 0xc7, 0x28, 0x40, 0xd7, + 0x67, 0x28, 0x80, 0x04, 0xd8, 0xa7, 0x28, 0x40, 0xd8, 0xe7, 0x28, 0x40, + 0xd6, 0x37, 0x28, 0x80, 0x0d, 0xd7, 0x57, 0x28, 0x80, 0x04, 0xd8, 0x97, + 0x28, 0x40, 0xd8, 0xd7, 0x28, 0x40, 0xd7, 0x77, 0x28, 0x80, 0x04, 0xd8, + 0xb7, 0x28, 0x40, 0xd8, 0xf7, 0x28, 0x40, 0xd5, 0x1f, 0x28, 0x80, 0x1f, + 0xd6, 0x2f, 0x28, 0x80, 0x0d, 0xd7, 0x4f, 0x28, 0x80, 0x04, 0xd8, 0x8f, + 0x28, 0x40, 0xd8, 0xcf, 0x28, 0x40, 0xd7, 0x6f, 0x28, 0x80, 0x04, 0xd8, + 0xaf, 0x28, 0x40, 0xd8, 0xef, 0x28, 0x40, 0xd6, 0x3f, 0x28, 0x80, 0x0d, + 0xd7, 0x5f, 0x28, 0x80, 0x04, 0xd8, 0x9f, 0x28, 0x40, 0xd8, 0xdf, 0x28, + 0x40, 0xd7, 0x7f, 0x28, 0x80, 0x04, 0xd8, 0xbf, 0x28, 0x40, 0xd8, 0xff, + 0x28, 0x40, 0xa4, 0x95, 0x05, 0x07, 0x13, 0x06, 0xca, 0x02, 0x07, 0x37, + 0x3c, 0xb1, 0x01, 0x0c, 0x3b, 0x17, 0x89, 0x01, 0x05, 0x5a, 0x03, 0x61, + 0xb6, 0x01, 0xff, 0x45, 0x20, 0x25, 0x46, 0x10, 0x01, 0x0a, 0xc8, 0x7a, + 0x01, 0xff, 0xa1, 0x45, 0x4e, 0xac, 0x79, 0x39, 0x10, 0x01, 0xe5, 0x42, + 0x10, 0x01, 0xe9, 0x3a, 0x10, 0x81, 0x32, 0xef, 0x44, 0x10, 0x81, 0x20, + 0xf5, 0x3c, 0x10, 0x81, 0x17, 0x08, 0xf2, 0xc6, 0x01, 0xff, 0xec, 0x40, + 0x10, 0x81, 0x09, 0xf2, 0x3e, 0x10, 0xc1, 0x00, 0xf2, 0x3f, 0x10, 0x41, + 0xec, 0x41, 0x10, 0x41, 0xf5, 0x3d, 0x10, 0x41, 0x0f, 0x7e, 0x72, 0x01, + 0xff, 0xe5, 0x73, 0x10, 0x01, 0xef, 0x74, 0x10, 0x41, 0xe9, 0x3b, 0x10, + 0x41, 0xe1, 0x38, 0x10, 0x01, 0xe9, 0x43, 0x10, 0x01, 0xf5, 0x45, 0x10, + 0x41, 0x48, 0x0a, 0x17, 0x01, 0x10, 0x01, 0x4b, 0x13, 0x25, 0x00, 0x10, + 0x01, 0x4b, 0x10, 0xa3, 0x03, 0x10, 0x01, 0x50, 0x8a, 0x68, 0x70, 0x10, + 0x01, 0x4b, 0xb9, 0xa9, 0x04, 0x10, 0x01, 0x47, 0x47, 0x4e, 0x02, 0x10, + 0x41, 0x4c, 0x3c, 0x92, 0x4c, 0x10, 0x01, 0x02, 0x3b, 0x01, 0x0f, 0xac, + 0x01, 0xff, 0x43, 0xf0, 0x05, 0x4b, 0x10, 0x01, 0x44, 0x49, 0x7d, 0x4d, + 0x10, 0x41, 0xf4, 0x49, 0x10, 0x01, 0x48, 0xdd, 0x43, 0x4a, 0x10, 0x41, + 0x45, 0x7e, 0x0b, 0x59, 0x10, 0x81, 0x88, 0x01, 0xa6, 0x69, 0x46, 0x74, + 0x64, 0x7f, 0x10, 0x01, 0x44, 0x6d, 0x2c, 0x5a, 0x10, 0x81, 0x56, 0x43, + 0x7a, 0x0b, 0x52, 0x10, 0x81, 0x40, 0xb3, 0x24, 0xb4, 0x01, 0xff, 0x42, + 0x92, 0x01, 0x5b, 0x10, 0x01, 0xa8, 0x0d, 0xb7, 0x01, 0xff, 0x44, 0xe9, + 0x1e, 0x5c, 0x10, 0x01, 0xef, 0x53, 0x10, 0x41, 0x44, 0x49, 0x12, 0x5d, + 0x10, 0x01, 0x43, 0x26, 0x01, 0x54, 0x10, 0x41, 0x44, 0x06, 0x1f, 0x58, + 0x10, 0x81, 0x0d, 0x42, 0x09, 0x24, 0x57, 0x10, 0xc1, 0x00, 0x42, 0x4b, + 0x12, 0x60, 0x10, 0x41, 0x42, 0x4b, 0x12, 0x61, 0x10, 0x41, 0x80, 0x01, + 0xff, 0x47, 0x3f, 0x12, 0x64, 0x10, 0x01, 0x48, 0xde, 0x1e, 0x65, 0x10, + 0x41, 0x42, 0x4b, 0x12, 0x63, 0x10, 0x41, 0xa9, 0x0f, 0xaf, 0x01, 0xff, + 0x43, 0x4a, 0x12, 0x5e, 0x10, 0x01, 0x42, 0x42, 0x00, 0x55, 0x10, 0x41, + 0x43, 0x04, 0x24, 0x5f, 0x10, 0x01, 0x42, 0x32, 0x00, 0x56, 0x10, 0x41, + 0xf9, 0x62, 0x10, 0x41, 0xe1, 0x05, 0x10, 0x81, 0xb4, 0x02, 0xa2, 0xa7, + 0x02, 0xa3, 0x9a, 0x02, 0xa4, 0x81, 0x02, 0xe5, 0x0f, 0x10, 0x01, 0xa7, + 0xf0, 0x01, 0x42, 0x22, 0x00, 0x33, 0x10, 0x01, 0xe9, 0x07, 0x10, 0x81, + 0xe0, 0x01, 0xaa, 0xd3, 0x01, 0xab, 0xc6, 0x01, 0xac, 0xb9, 0x01, 0x42, + 0x6c, 0x00, 0x2b, 0x10, 0x01, 0xae, 0x9a, 0x01, 0xef, 0x11, 0x10, 0x81, + 0x69, 0xb0, 0x5d, 0x42, 0x71, 0x00, 0x2d, 0x10, 0x01, 0xb3, 0x45, 0xb4, + 0x2c, 0xf5, 0x09, 0x10, 0x81, 0x23, 0xb6, 0x06, 0x42, 0xdf, 0x23, 0x2c, + 0x10, 0x41, 0xe1, 0x2f, 0x10, 0x01, 0x07, 0xf3, 0xc6, 0x01, 0xff, 0xec, + 0x0d, 0x10, 0x81, 0x09, 0xf2, 0x0b, 0x10, 0xc1, 0x00, 0xf2, 0x0c, 0x10, + 0x41, 0xec, 0x0e, 0x10, 0x41, 0xf5, 0x0a, 0x10, 0x41, 0xe1, 0x22, 0x10, + 0x01, 0x42, 0x22, 0x00, 0x23, 0x10, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x1d, + 0x10, 0x01, 0x42, 0x22, 0x00, 0x1e, 0x10, 0x41, 0xe1, 0x32, 0x10, 0x01, + 0x42, 0x22, 0x00, 0x30, 0x10, 0x01, 0x42, 0x40, 0x06, 0x31, 0x10, 0x41, + 0xe1, 0x27, 0x10, 0x01, 0x42, 0x22, 0x00, 0x28, 0x10, 0x41, 0x09, 0x8b, + 0x68, 0x01, 0xff, 0x02, 0x60, 0x07, 0x19, 0x44, 0x78, 0xf7, 0x37, 0x10, + 0x01, 0x43, 0xaf, 0x43, 0x36, 0x10, 0x01, 0x06, 0x33, 0x07, 0x01, 0xff, + 0xe5, 0x71, 0x10, 0x01, 0xef, 0x72, 0x10, 0x41, 0xe1, 0x75, 0x10, 0x01, + 0x42, 0x74, 0x00, 0x35, 0x10, 0x41, 0xe1, 0x26, 0x10, 0x01, 0x42, 0x24, + 0x02, 0x17, 0x10, 0x01, 0x42, 0x2a, 0x05, 0x21, 0x10, 0x01, 0x42, 0xdf, + 0x23, 0x1c, 0x10, 0x41, 0xe1, 0x2e, 0x10, 0x01, 0x42, 0x74, 0x00, 0x34, + 0x10, 0x41, 0xe1, 0x13, 0x10, 0x01, 0x42, 0x22, 0x00, 0x14, 0x10, 0x41, + 0xe1, 0x1a, 0x10, 0x01, 0x42, 0x22, 0x00, 0x1b, 0x10, 0x41, 0xe9, 0x08, + 0x10, 0x41, 0xe1, 0x15, 0x10, 0x01, 0x42, 0x22, 0x00, 0x16, 0x10, 0x41, + 0xe1, 0x24, 0x10, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x25, 0x10, 0x41, + 0xe1, 0x1f, 0x10, 0x01, 0x42, 0x22, 0x00, 0x20, 0x10, 0x41, 0xe1, 0x18, + 0x10, 0x01, 0x42, 0x22, 0x00, 0x19, 0x10, 0x41, 0xe1, 0x29, 0x10, 0x01, + 0x42, 0x22, 0x00, 0x2a, 0x10, 0x41, 0xe1, 0x06, 0x10, 0x01, 0xe9, 0x10, + 0x10, 0x01, 0xf5, 0x12, 0x10, 0x41, 0x44, 0x96, 0x21, 0x47, 0x10, 0x01, + 0x05, 0xf0, 0x06, 0x06, 0x4b, 0x33, 0xa6, 0x48, 0x10, 0x41, 0x45, 0x7e, + 0x0b, 0x6e, 0x10, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x6f, 0x10, 0x01, + 0x43, 0x7a, 0x0b, 0x67, 0x10, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, + 0x1f, 0x66, 0x10, 0x41, 0x44, 0x25, 0x01, 0x69, 0x10, 0x01, 0x42, 0x15, + 0x02, 0x68, 0x10, 0x41, 0x44, 0x06, 0x1f, 0x6d, 0x10, 0x01, 0x42, 0x09, + 0x24, 0x6c, 0x10, 0x41, 0x43, 0xf9, 0x05, 0x6b, 0x10, 0x01, 0x43, 0xf6, + 0x06, 0x6a, 0x10, 0x41, 0x42, 0x17, 0x00, 0x17, 0xf4, 0x01, 0x03, 0x58, + 0x25, 0xf2, 0x10, 0xed, 0xff, 0xfe, 0x80, 0xe8, 0x10, 0x42, 0xf1, 0x05, + 0xb4, 0xf9, 0x01, 0xaf, 0xc3, 0x10, 0x07, 0xb0, 0xda, 0xe0, 0x0d, 0x02, + 0x15, 0x06, 0xe6, 0x0b, 0x45, 0xc9, 0xf1, 0x90, 0xf4, 0x81, 0xd8, 0x0b, + 0xb7, 0xa1, 0x0b, 0xb8, 0x0b, 0xf9, 0x66, 0xf4, 0xc1, 0x00, 0x48, 0xd4, + 0x4d, 0xc9, 0xf6, 0x41, 0x0a, 0x14, 0xab, 0x06, 0x49, 0x29, 0xc0, 0x4a, + 0xf9, 0x41, 0x02, 0x3b, 0x01, 0xf6, 0x08, 0x06, 0x3b, 0x16, 0xc2, 0x07, + 0xac, 0xae, 0x02, 0x06, 0xc8, 0x00, 0xf1, 0x01, 0x03, 0x4b, 0x16, 0x5e, + 0x09, 0x32, 0x00, 0x01, 0xff, 0x0b, 0x45, 0xa0, 0x43, 0x0a, 0x3b, 0x16, + 0x2d, 0x0a, 0x8a, 0x67, 0x17, 0x0b, 0xe0, 0xa7, 0x01, 0xff, 0x51, 0x27, + 0x5d, 0x6a, 0x25, 0x00, 0x4b, 0xb5, 0xa3, 0x61, 0x25, 0x00, 0x4c, 0x74, + 0x99, 0x5e, 0x25, 0x40, 0x50, 0x9b, 0x3c, 0x3f, 0x25, 0x00, 0x4a, 0x26, + 0xb2, 0x25, 0x25, 0x00, 0x4b, 0x30, 0xa7, 0x1d, 0x25, 0x40, 0x50, 0xb0, + 0x3c, 0x42, 0x25, 0x00, 0x4a, 0x30, 0xb2, 0x28, 0x25, 0x00, 0x4b, 0x94, + 0x67, 0x20, 0x25, 0x40, 0x51, 0x38, 0x5d, 0x6b, 0x25, 0x00, 0x4b, 0xc0, + 0xa3, 0x62, 0x25, 0x00, 0x4c, 0x80, 0x99, 0x5f, 0x25, 0x40, 0x0b, 0x45, + 0xa0, 0x79, 0x0a, 0x3b, 0x16, 0x48, 0x0a, 0x8a, 0x67, 0x17, 0x0b, 0xe0, + 0xa7, 0x01, 0xff, 0x51, 0x27, 0x5d, 0x67, 0x25, 0x00, 0x4b, 0xb5, 0xa3, + 0x5b, 0x25, 0x00, 0x4c, 0x74, 0x99, 0x58, 0x25, 0x40, 0x55, 0x96, 0x3c, + 0x48, 0x25, 0x00, 0x50, 0x9b, 0x3c, 0x37, 0x25, 0x00, 0x05, 0xc3, 0x00, + 0x11, 0x06, 0xc8, 0x00, 0x01, 0xff, 0x4a, 0x36, 0x16, 0x22, 0x25, 0x00, + 0x45, 0x3b, 0x16, 0x15, 0x25, 0x40, 0x4a, 0x36, 0x16, 0x2a, 0x25, 0x00, + 0x45, 0x3b, 0x16, 0x19, 0x25, 0x40, 0x55, 0xab, 0x3c, 0x40, 0x25, 0x00, + 0x50, 0xb0, 0x3c, 0x38, 0x25, 0x00, 0x05, 0xc3, 0x00, 0x11, 0x06, 0xc8, + 0x00, 0x01, 0xff, 0x4a, 0xa5, 0x17, 0x1e, 0x25, 0x00, 0x45, 0xc3, 0x01, + 0x16, 0x25, 0x40, 0x4a, 0xa5, 0x17, 0x26, 0x25, 0x00, 0x45, 0xc3, 0x01, + 0x1a, 0x25, 0x40, 0x51, 0x38, 0x5d, 0x68, 0x25, 0x00, 0x4b, 0xc0, 0xa3, + 0x5c, 0x25, 0x00, 0x4c, 0x80, 0x99, 0x59, 0x25, 0x40, 0x5c, 0x58, 0x18, + 0x46, 0x25, 0x00, 0x0f, 0x5d, 0x18, 0x1c, 0x0f, 0xf6, 0x72, 0x06, 0x5c, + 0x88, 0x1a, 0x44, 0x25, 0x40, 0x4a, 0x36, 0x16, 0x31, 0x25, 0x00, 0x48, + 0x92, 0x17, 0x39, 0x25, 0x00, 0x4e, 0x5e, 0x82, 0x49, 0x25, 0x40, 0x4a, + 0xa5, 0x17, 0x2e, 0x25, 0x00, 0x48, 0x4b, 0x16, 0x36, 0x25, 0x00, 0x4e, + 0x6c, 0x82, 0x3e, 0x25, 0x40, 0x04, 0xc4, 0x00, 0xd4, 0x04, 0x05, 0xc9, + 0x00, 0x01, 0xff, 0x04, 0x94, 0x18, 0xa9, 0x04, 0x55, 0xd9, 0x3b, 0x1e, + 0xcc, 0x01, 0xa4, 0xc4, 0x01, 0x4a, 0x0b, 0x00, 0x00, 0x25, 0x80, 0xa3, + 0x01, 0x44, 0xc3, 0x00, 0x74, 0x25, 0x80, 0x95, 0x01, 0x0f, 0x5d, 0x75, + 0x84, 0x01, 0x45, 0xc8, 0x00, 0x76, 0x25, 0x00, 0xb4, 0x65, 0x42, 0x50, + 0x02, 0x75, 0x25, 0x80, 0x3f, 0x48, 0x32, 0x00, 0x02, 0x25, 0xc0, 0x00, + 0x05, 0x19, 0x00, 0x01, 0xff, 0x07, 0x29, 0x0e, 0x23, 0x4a, 0x0b, 0x00, + 0x3c, 0x25, 0x00, 0x44, 0xc3, 0x00, 0x24, 0x25, 0x00, 0x45, 0xc8, 0x00, + 0x1c, 0x25, 0x00, 0x04, 0x1e, 0x00, 0x01, 0xff, 0x44, 0xc3, 0x00, 0x18, + 0xce, 0x01, 0x45, 0xc8, 0x00, 0x16, 0xce, 0x41, 0x44, 0xc3, 0x00, 0x19, + 0xce, 0x01, 0x45, 0xc8, 0x00, 0x17, 0xce, 0x41, 0x05, 0x19, 0x00, 0x01, + 0xff, 0xa8, 0x0c, 0x44, 0xc3, 0x00, 0x18, 0x25, 0x00, 0x45, 0xc8, 0x00, + 0x14, 0x25, 0x40, 0x49, 0x98, 0xbd, 0x7d, 0x25, 0x00, 0x49, 0x0c, 0x00, + 0x34, 0x25, 0x40, 0x51, 0x7a, 0x5f, 0x1d, 0xcc, 0x01, 0x0b, 0x82, 0x39, + 0x01, 0xff, 0x4a, 0x0b, 0x00, 0x04, 0x25, 0x00, 0x48, 0x32, 0x00, 0x06, + 0x25, 0x40, 0x4a, 0x0b, 0x00, 0x08, 0x25, 0x00, 0x48, 0x32, 0x00, 0x0a, + 0x25, 0x40, 0x50, 0xaa, 0x62, 0x7c, 0x25, 0x40, 0x80, 0x01, 0xff, 0x04, + 0x1a, 0x00, 0x06, 0x54, 0xc9, 0x3a, 0xaf, 0xfb, 0x41, 0x4b, 0xf8, 0x02, + 0x1c, 0xcc, 0x01, 0x4b, 0x98, 0x02, 0x1b, 0xcc, 0x41, 0x08, 0x52, 0x27, + 0x31, 0xaf, 0x01, 0xff, 0x0a, 0x2a, 0xb8, 0x1e, 0x42, 0xa7, 0x01, 0x77, + 0x25, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x4a, 0x0b, 0x00, 0x2c, + 0x25, 0x00, 0x44, 0xc3, 0x00, 0x10, 0x25, 0x00, 0x45, 0xc8, 0x00, 0x0c, + 0x25, 0x40, 0x4a, 0x0b, 0x00, 0x4c, 0x25, 0x00, 0x48, 0x32, 0x00, 0x4e, + 0x25, 0x40, 0x45, 0x8e, 0x08, 0x73, 0x25, 0x00, 0x47, 0xcc, 0x46, 0xae, + 0xfb, 0x01, 0x0e, 0x96, 0x03, 0x8a, 0x02, 0x07, 0x7d, 0x02, 0xc2, 0x01, + 0x06, 0x6d, 0x02, 0x01, 0xff, 0x0a, 0x73, 0x02, 0x6a, 0x08, 0x84, 0x02, + 0x2d, 0x09, 0x0e, 0x10, 0x01, 0xff, 0x06, 0x13, 0x01, 0x18, 0x07, 0x7d, + 0x02, 0x01, 0xff, 0x55, 0xab, 0x03, 0xd9, 0xfb, 0x01, 0x44, 0xc3, 0x00, + 0xd1, 0xfb, 0xc1, 0x00, 0x4f, 0xb1, 0x03, 0xdd, 0xfb, 0x41, 0x46, 0x73, + 0x02, 0xd6, 0xfb, 0x01, 0x44, 0xc3, 0x00, 0x71, 0x25, 0x40, 0x06, 0x13, + 0x01, 0x22, 0x07, 0x7d, 0x02, 0x01, 0xff, 0x0a, 0x73, 0x02, 0x0d, 0x45, + 0xc8, 0x00, 0xd2, 0xfb, 0xc1, 0x00, 0x4e, 0x11, 0x4f, 0xdf, 0xfb, 0x41, + 0x4a, 0x96, 0x03, 0xdb, 0xfb, 0x01, 0x4b, 0x98, 0x02, 0xd8, 0xfb, 0x41, + 0x46, 0x73, 0x02, 0xd4, 0xfb, 0x81, 0x06, 0x45, 0xc8, 0x00, 0x72, 0x25, + 0x40, 0x4f, 0x99, 0x19, 0xdc, 0xfb, 0x41, 0x06, 0x13, 0x01, 0x3f, 0x07, + 0x7d, 0x02, 0x01, 0xff, 0x44, 0xc3, 0x00, 0xa0, 0xfb, 0x81, 0x1d, 0x45, + 0xc8, 0x00, 0xa1, 0xfb, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x5f, 0xa0, 0x11, + 0xa9, 0xfb, 0x01, 0x4f, 0x89, 0x02, 0xa5, 0xfb, 0xc1, 0x00, 0x4f, 0x79, + 0x02, 0xaa, 0xfb, 0x41, 0x80, 0x01, 0xff, 0x60, 0x03, 0x10, 0xa8, 0xfb, + 0x01, 0x4f, 0x89, 0x02, 0xa4, 0xfb, 0xc1, 0x00, 0x50, 0xb0, 0x1a, 0xab, + 0xfb, 0x41, 0x44, 0xc3, 0x00, 0xd7, 0xfb, 0x01, 0x45, 0xc8, 0x00, 0xd5, + 0xfb, 0x41, 0x08, 0x84, 0x02, 0x1b, 0x09, 0x0e, 0x10, 0x01, 0xff, 0x06, + 0x13, 0x01, 0x06, 0x6b, 0x6d, 0x02, 0xad, 0xfb, 0x41, 0x46, 0x73, 0x02, + 0xa3, 0xfb, 0x01, 0x44, 0xc3, 0x00, 0xd0, 0xfb, 0x41, 0x06, 0x13, 0x01, + 0x0d, 0x5c, 0xa4, 0x1a, 0xa7, 0xfb, 0xc1, 0x00, 0x50, 0x88, 0x02, 0xac, + 0xfb, 0x41, 0x46, 0x73, 0x02, 0xa2, 0xfb, 0x81, 0x06, 0x45, 0xc8, 0x00, + 0xd3, 0xfb, 0x41, 0x50, 0xb0, 0x1a, 0xa6, 0xfb, 0x41, 0x5c, 0xa4, 0x03, + 0xda, 0xfb, 0x01, 0x5b, 0x14, 0x1f, 0xde, 0xfb, 0x41, 0x09, 0x56, 0x4b, + 0x11, 0x07, 0x67, 0x61, 0x01, 0xff, 0x44, 0xc3, 0x00, 0x6f, 0x25, 0x00, + 0x45, 0xc8, 0x00, 0x70, 0x25, 0x40, 0x44, 0xc3, 0x00, 0x6e, 0x25, 0x00, + 0x45, 0xc8, 0x00, 0x6d, 0x25, 0x40, 0x5d, 0x36, 0x16, 0x45, 0x25, 0x00, + 0x10, 0x3b, 0x16, 0x1c, 0x10, 0x8a, 0x67, 0x06, 0x5d, 0x92, 0x17, 0x43, + 0x25, 0x40, 0x4a, 0x36, 0x16, 0x32, 0x25, 0x00, 0x48, 0x92, 0x17, 0x3a, + 0x25, 0x00, 0x4e, 0x5e, 0x82, 0x4a, 0x25, 0x40, 0x4a, 0xa5, 0x17, 0x2d, + 0x25, 0x00, 0x48, 0x4b, 0x16, 0x35, 0x25, 0x00, 0x4e, 0x6c, 0x82, 0x3d, + 0x25, 0x40, 0x02, 0x3b, 0x01, 0x7d, 0x4a, 0x0b, 0x00, 0x01, 0x25, 0x00, + 0x44, 0xc3, 0x00, 0x78, 0x25, 0x80, 0x6a, 0x0f, 0x5d, 0x75, 0x5a, 0x45, + 0xc8, 0x00, 0x7a, 0x25, 0x00, 0x0c, 0x81, 0x39, 0x44, 0x42, 0x50, 0x02, + 0x79, 0x25, 0x80, 0x1e, 0x48, 0x32, 0x00, 0x03, 0x25, 0xc0, 0x00, 0x05, + 0x19, 0x00, 0x01, 0xff, 0x4a, 0x0b, 0x00, 0x4b, 0x25, 0x00, 0x44, 0xc3, + 0x00, 0x2b, 0x25, 0x00, 0x45, 0xc8, 0x00, 0x23, 0x25, 0x40, 0x05, 0x19, + 0x00, 0x01, 0xff, 0x4a, 0x0b, 0x00, 0x3b, 0x25, 0x00, 0xac, 0x06, 0x45, + 0xc8, 0x00, 0x17, 0x25, 0x40, 0x43, 0xc4, 0x00, 0x1b, 0x25, 0x00, 0x49, + 0xa0, 0x17, 0x7f, 0x25, 0x40, 0x4a, 0x0b, 0x00, 0x05, 0x25, 0x00, 0x48, + 0x32, 0x00, 0x07, 0x25, 0x40, 0x4a, 0x0b, 0x00, 0x09, 0x25, 0x00, 0x48, + 0x32, 0x00, 0x0b, 0x25, 0x40, 0x50, 0xba, 0x62, 0x7e, 0x25, 0x40, 0x0a, + 0x2a, 0xb8, 0x1e, 0x42, 0xa7, 0x01, 0x7b, 0x25, 0xc0, 0x00, 0x05, 0x19, + 0x00, 0x01, 0xff, 0x4a, 0x0b, 0x00, 0x33, 0x25, 0x00, 0x44, 0xc3, 0x00, + 0x13, 0x25, 0x00, 0x45, 0xc8, 0x00, 0x0f, 0x25, 0x40, 0x4a, 0x0b, 0x00, + 0x4d, 0x25, 0x00, 0x48, 0x32, 0x00, 0x4f, 0x25, 0x40, 0x05, 0x3d, 0x01, + 0x92, 0x01, 0x03, 0x6e, 0x15, 0x01, 0xff, 0x0b, 0x45, 0xa0, 0x77, 0x0a, + 0x3b, 0x16, 0x47, 0x0a, 0x8a, 0x67, 0x17, 0x0b, 0xe0, 0xa7, 0x01, 0xff, + 0x51, 0x27, 0x5d, 0x64, 0x25, 0x00, 0x4b, 0xb5, 0xa3, 0x55, 0x25, 0x00, + 0x4c, 0x74, 0x99, 0x52, 0x25, 0x40, 0x50, 0x9b, 0x3c, 0x2f, 0x25, 0x00, + 0x05, 0xc3, 0x00, 0x16, 0x06, 0xc8, 0x00, 0x06, 0x53, 0x75, 0x50, 0x47, + 0x25, 0x40, 0x45, 0x3b, 0x16, 0x0d, 0x25, 0x00, 0x48, 0x92, 0x17, 0x21, + 0x25, 0x40, 0x45, 0x3b, 0x16, 0x11, 0x25, 0x00, 0x48, 0x92, 0x17, 0x29, + 0x25, 0x40, 0x50, 0xb0, 0x3c, 0x30, 0x25, 0x00, 0x05, 0xc3, 0x00, 0x16, + 0x06, 0xc8, 0x00, 0x06, 0x53, 0x88, 0x50, 0x41, 0x25, 0x40, 0x45, 0xc3, + 0x01, 0x0e, 0x25, 0x00, 0x48, 0x4b, 0x16, 0x1f, 0x25, 0x40, 0x45, 0xc3, + 0x01, 0x12, 0x25, 0x00, 0x48, 0x4b, 0x16, 0x27, 0x25, 0x40, 0x51, 0x38, + 0x5d, 0x65, 0x25, 0x00, 0x4b, 0xc0, 0xa3, 0x56, 0x25, 0x00, 0x4c, 0x80, + 0x99, 0x53, 0x25, 0x40, 0xa4, 0x3a, 0x4a, 0x0b, 0x00, 0x50, 0x25, 0x00, + 0x07, 0x67, 0x61, 0x1e, 0x48, 0x32, 0x00, 0x51, 0x25, 0xc0, 0x00, 0x05, + 0x19, 0x00, 0x01, 0xff, 0x4a, 0x0b, 0x00, 0x6c, 0x25, 0x00, 0x44, 0xc3, + 0x00, 0x63, 0x25, 0x00, 0x45, 0xc8, 0x00, 0x60, 0x25, 0x40, 0x4a, 0x0b, + 0x00, 0x69, 0x25, 0x00, 0x44, 0xc3, 0x00, 0x5d, 0x25, 0x00, 0x45, 0xc8, + 0x00, 0x5a, 0x25, 0x40, 0x08, 0x52, 0x27, 0x17, 0x08, 0x57, 0x4b, 0x01, + 0xff, 0x4a, 0x0b, 0x00, 0x66, 0x25, 0x00, 0x44, 0xc3, 0x00, 0x57, 0x25, + 0x00, 0x45, 0xc8, 0x00, 0x54, 0x25, 0x40, 0x6a, 0x96, 0x03, 0x09, 0xce, + 0x01, 0x06, 0x6d, 0x02, 0x01, 0xff, 0x08, 0x84, 0x02, 0x06, 0x53, 0x0c, + 0x4f, 0x1f, 0xcc, 0x41, 0x4b, 0xf8, 0x02, 0x20, 0xcc, 0x01, 0x5c, 0x8c, + 0x19, 0x0a, 0xce, 0x41, 0x4a, 0xec, 0xaa, 0xf9, 0xf3, 0x01, 0xac, 0x18, + 0x43, 0x46, 0x27, 0xc8, 0x22, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, + 0x4f, 0xab, 0x72, 0xd1, 0x29, 0x00, 0x50, 0xca, 0x69, 0xd2, 0x29, 0x40, + 0x80, 0x06, 0x43, 0xa1, 0x01, 0xb3, 0xf3, 0x41, 0x4a, 0x2e, 0xb4, 0x4f, + 0xf5, 0x01, 0x4a, 0x2e, 0xb9, 0x63, 0xf9, 0x41, 0x4b, 0x88, 0x9c, 0x95, + 0xf3, 0x41, 0x54, 0x47, 0x46, 0x7e, 0xf3, 0x01, 0x03, 0xac, 0x05, 0x01, + 0xff, 0x57, 0xe1, 0x1c, 0x3b, 0x29, 0x00, 0x4d, 0xde, 0x0b, 0xdf, 0x23, + 0x00, 0x05, 0x22, 0x00, 0x65, 0x15, 0xa3, 0x3e, 0x55, 0x05, 0xc3, 0x00, + 0x37, 0x4b, 0xfb, 0x22, 0xdd, 0x23, 0x00, 0x06, 0xc8, 0x00, 0x13, 0x4e, + 0x36, 0x28, 0xb5, 0x23, 0x80, 0x06, 0x56, 0x79, 0x09, 0xe1, 0x23, 0x40, + 0x58, 0x2c, 0x28, 0xb6, 0x23, 0x40, 0xa3, 0x0c, 0x4c, 0x28, 0x94, 0x25, + 0x2e, 0x00, 0x69, 0x8e, 0x04, 0xee, 0xfb, 0x41, 0x45, 0x8a, 0x0b, 0x1f, + 0x23, 0x00, 0x43, 0xb5, 0x0d, 0x0c, 0x23, 0x40, 0xa3, 0x0c, 0x4c, 0x28, + 0x94, 0x24, 0x2e, 0x00, 0x6a, 0x18, 0x03, 0xed, 0xfb, 0x41, 0x45, 0x8a, + 0x0b, 0x1e, 0x23, 0x00, 0x43, 0xb5, 0x0d, 0x0d, 0x23, 0x40, 0x4c, 0x0c, + 0x03, 0xea, 0xfb, 0x01, 0x4c, 0x00, 0x12, 0xe2, 0xfb, 0x41, 0x4c, 0x0c, + 0x03, 0xcb, 0x2b, 0x00, 0x10, 0x3a, 0x66, 0x50, 0x48, 0x02, 0x28, 0x21, + 0x23, 0x00, 0x04, 0xc3, 0x00, 0x28, 0x05, 0xc8, 0x00, 0x06, 0x4f, 0x98, + 0x76, 0xe7, 0xcd, 0x41, 0x4c, 0xfa, 0x22, 0x5c, 0x2e, 0x00, 0x09, 0x41, + 0x66, 0x01, 0xff, 0x44, 0x28, 0x46, 0x5f, 0xcc, 0x01, 0x0c, 0x78, 0x9b, + 0x01, 0xff, 0xd1, 0xe9, 0xcd, 0x01, 0xd2, 0xeb, 0xcd, 0x41, 0x4c, 0xfa, + 0x22, 0x5b, 0x2e, 0x00, 0x09, 0x41, 0x66, 0x01, 0xff, 0x44, 0x28, 0x46, + 0x5d, 0xcc, 0x01, 0x0c, 0x78, 0x9b, 0x01, 0xff, 0xd1, 0xed, 0xcd, 0x01, + 0xd2, 0xef, 0xcd, 0x41, 0x44, 0x28, 0x46, 0x5e, 0xcc, 0x01, 0x0c, 0x78, + 0x9b, 0x01, 0xff, 0xd1, 0xf1, 0xcd, 0x01, 0xd2, 0xf2, 0xcd, 0x01, 0xd3, + 0xf3, 0xcd, 0x01, 0xd4, 0xf4, 0xcd, 0x41, 0x0d, 0xef, 0x86, 0xc5, 0x02, + 0x07, 0x13, 0x06, 0x01, 0xff, 0xe1, 0x1a, 0x31, 0x80, 0x8f, 0x02, 0xe2, + 0x05, 0x31, 0x80, 0x85, 0x02, 0xe3, 0x18, 0x31, 0x80, 0xfb, 0x01, 0xe4, + 0x09, 0x31, 0x00, 0xe5, 0x1c, 0x31, 0x80, 0xd4, 0x01, 0xe6, 0x08, 0x31, + 0x00, 0xe7, 0x0d, 0x31, 0x80, 0xba, 0x01, 0xe8, 0x0f, 0x31, 0x00, 0xe9, + 0x27, 0x31, 0x80, 0x95, 0x01, 0xea, 0x10, 0x31, 0x80, 0x8b, 0x01, 0xeb, + 0x0e, 0x31, 0x80, 0x81, 0x01, 0xec, 0x0c, 0x31, 0x80, 0x78, 0xed, 0x07, + 0x31, 0x00, 0xee, 0x0b, 0x31, 0x80, 0x62, 0xef, 0x1b, 0x31, 0x80, 0x3d, + 0xf0, 0x06, 0x31, 0x00, 0xf1, 0x11, 0x31, 0x00, 0xf2, 0x16, 0x31, 0x00, + 0xf3, 0x19, 0x31, 0x80, 0x28, 0xf4, 0x0a, 0x31, 0x00, 0xf5, 0x28, 0x31, + 0x80, 0x19, 0xf6, 0x2a, 0x31, 0x00, 0xf8, 0x12, 0x31, 0x00, 0xfa, 0x17, + 0x31, 0xc0, 0x00, 0xe8, 0x13, 0x31, 0x00, 0xe9, 0xa1, 0x31, 0x00, 0xf9, + 0xba, 0x31, 0x40, 0x42, 0x9d, 0x25, 0xab, 0x31, 0x40, 0xe8, 0x15, 0x31, + 0x40, 0x4f, 0x98, 0x3d, 0x2e, 0x31, 0x00, 0xe5, 0xbe, 0x31, 0x00, 0xed, + 0xb1, 0x31, 0x00, 0xae, 0x08, 0xef, 0xa6, 0x31, 0x00, 0xf5, 0x21, 0x31, + 0x40, 0xe7, 0xb2, 0x31, 0x00, 0xee, 0xa7, 0x31, 0x40, 0xe7, 0x2b, 0x31, + 0x80, 0x04, 0xee, 0x2f, 0x31, 0x40, 0xe7, 0xad, 0x31, 0x40, 0xe8, 0xb9, + 0x31, 0x40, 0xf7, 0xbd, 0x31, 0x40, 0xe9, 0xa2, 0x31, 0x40, 0xe8, 0x2d, + 0x31, 0x00, 0xed, 0xac, 0x31, 0x00, 0x42, 0x9d, 0x25, 0xaa, 0x31, 0x80, + 0x08, 0xf2, 0xa8, 0x31, 0x00, 0xf5, 0x29, 0x31, 0x40, 0xee, 0xb3, 0x31, + 0x40, 0xe8, 0xb8, 0x31, 0x00, 0xee, 0x2c, 0x31, 0x00, 0xf5, 0xa3, 0x31, + 0x00, 0xf7, 0xbc, 0x31, 0x40, 0xe5, 0xa4, 0x31, 0x00, 0xe8, 0x1d, 0x31, + 0x00, 0xe9, 0x1f, 0x31, 0x00, 0xee, 0x23, 0x31, 0x80, 0x04, 0xf2, 0x26, + 0x31, 0x40, 0xe7, 0x25, 0x31, 0x00, 0xee, 0xa5, 0x31, 0x40, 0xe8, 0x14, + 0x31, 0x40, 0xf5, 0xa0, 0x31, 0x40, 0xe8, 0xbf, 0x31, 0x00, 0xe9, 0x1e, + 0x31, 0x80, 0x1c, 0xed, 0xb0, 0x31, 0x00, 0xee, 0x22, 0x31, 0x80, 0x0b, + 0xf5, 0x20, 0x31, 0xc0, 0x00, 0x42, 0x9d, 0x25, 0xaf, 0x31, 0x40, 0xe7, + 0x24, 0x31, 0x00, 0xee, 0xa9, 0x31, 0x40, 0x42, 0x9d, 0x25, 0xae, 0x31, + 0x40, 0xe7, 0xbb, 0x31, 0x00, 0xe8, 0xb7, 0x31, 0x00, 0xeb, 0xb6, 0x31, + 0x00, 0xf0, 0xb4, 0x31, 0x00, 0xf4, 0xb5, 0x31, 0x40, 0xeb, 0x6e, 0xf5, + 0x81, 0x06, 0x46, 0xc3, 0xd9, 0x83, 0xfa, 0x41, 0x44, 0xb9, 0x00, 0x16, + 0xf5, 0x81, 0x04, 0xf3, 0xda, 0xf4, 0x41, 0x45, 0xe2, 0xe7, 0xd1, 0xf4, + 0x41, 0xe2, 0xa3, 0xf4, 0x41, 0x55, 0xea, 0x3c, 0xbd, 0xf7, 0x01, 0x54, + 0x7b, 0x44, 0xb1, 0xf7, 0x01, 0x4b, 0xef, 0x63, 0xa4, 0xf7, 0x01, 0xb3, + 0x11, 0x06, 0xad, 0x02, 0x01, 0xff, 0x46, 0x12, 0x03, 0x86, 0xf7, 0x01, + 0x46, 0xfd, 0x05, 0x90, 0xf7, 0x41, 0x46, 0x35, 0x1a, 0xab, 0xf7, 0x01, + 0x52, 0x5b, 0x55, 0xb7, 0xf7, 0x41, 0xa1, 0xe8, 0x0a, 0xaf, 0x19, 0x02, + 0x5c, 0x0a, 0x01, 0xff, 0x80, 0x06, 0x47, 0x38, 0xd5, 0xd0, 0xfa, 0x41, + 0x44, 0x28, 0xf5, 0xd8, 0xf4, 0x01, 0x45, 0xcf, 0x22, 0x99, 0xf4, 0x41, + 0x03, 0x0f, 0x03, 0x0c, 0x44, 0x50, 0xd5, 0x3c, 0xf3, 0x01, 0x45, 0x2d, + 0xf2, 0x21, 0xf4, 0x41, 0x07, 0x91, 0xd9, 0x95, 0x02, 0x08, 0x87, 0xd0, + 0x01, 0xff, 0xd1, 0x00, 0xfb, 0x81, 0x87, 0x01, 0xd2, 0x01, 0xfb, 0x81, + 0x43, 0xd3, 0x03, 0xfb, 0x81, 0x1f, 0xd4, 0x07, 0xfb, 0x81, 0x0d, 0xd5, + 0x0f, 0xfb, 0x81, 0x04, 0xd6, 0x1e, 0xfb, 0x41, 0xd6, 0x2d, 0xfb, 0x41, + 0xd5, 0x16, 0xfb, 0x81, 0x04, 0xd6, 0x26, 0xfb, 0x41, 0xd6, 0x35, 0xfb, + 0x41, 0xd4, 0x0b, 0xfb, 0x81, 0x0d, 0xd5, 0x13, 0xfb, 0x81, 0x04, 0xd6, + 0x22, 0xfb, 0x41, 0xd6, 0x31, 0xfb, 0x41, 0xd5, 0x1a, 0xfb, 0x81, 0x04, + 0xd6, 0x29, 0xfb, 0x41, 0xd6, 0x39, 0xfb, 0x41, 0xd3, 0x05, 0xfb, 0x81, + 0x1b, 0xd4, 0x09, 0xfb, 0x81, 0x0d, 0xd5, 0x11, 0xfb, 0x81, 0x04, 0xd6, + 0x20, 0xfb, 0x41, 0xd6, 0x2f, 0xfb, 0x41, 0xd5, 0x18, 0xfb, 0xc1, 0x00, + 0xd6, 0x37, 0xfb, 0x41, 0xd4, 0x0d, 0xfb, 0x81, 0x0d, 0xd5, 0x14, 0xfb, + 0x81, 0x04, 0xd6, 0x24, 0xfb, 0x41, 0xd6, 0x33, 0xfb, 0x41, 0xd5, 0x1c, + 0xfb, 0x81, 0x04, 0xd6, 0x2b, 0xfb, 0x41, 0xd6, 0x3b, 0xfb, 0x41, 0xd2, + 0x02, 0xfb, 0x81, 0x40, 0xd3, 0x04, 0xfb, 0x81, 0x1f, 0xd4, 0x08, 0xfb, + 0x81, 0x0d, 0xd5, 0x10, 0xfb, 0x81, 0x04, 0xd6, 0x1f, 0xfb, 0x41, 0xd6, + 0x2e, 0xfb, 0x41, 0xd5, 0x17, 0xfb, 0x81, 0x04, 0xd6, 0x27, 0xfb, 0x41, + 0xd6, 0x36, 0xfb, 0x41, 0xd4, 0x0c, 0xfb, 0x81, 0x0a, 0x42, 0xaf, 0xc8, + 0x32, 0xfb, 0x01, 0xd6, 0x23, 0xfb, 0x41, 0xd5, 0x1b, 0xfb, 0x81, 0x04, + 0xd6, 0x2a, 0xfb, 0x41, 0xd6, 0x3a, 0xfb, 0x41, 0xd3, 0x06, 0xfb, 0x81, + 0x1f, 0xd4, 0x0a, 0xfb, 0x81, 0x0d, 0xd5, 0x12, 0xfb, 0x81, 0x04, 0xd6, + 0x21, 0xfb, 0x41, 0xd6, 0x30, 0xfb, 0x41, 0xd5, 0x19, 0xfb, 0x81, 0x04, + 0xd6, 0x28, 0xfb, 0x41, 0xd6, 0x38, 0xfb, 0x41, 0xd4, 0x0e, 0xfb, 0x81, + 0x0d, 0xd5, 0x15, 0xfb, 0x81, 0x04, 0xd6, 0x25, 0xfb, 0x41, 0xd6, 0x34, + 0xfb, 0x41, 0xd5, 0x1d, 0xfb, 0x01, 0xd6, 0x2c, 0xfb, 0x41, 0x91, 0x86, + 0x04, 0x92, 0xf7, 0x01, 0xd3, 0x00, 0xcd, 0x81, 0x6f, 0xd4, 0x03, 0xcd, + 0x81, 0x2a, 0xd5, 0x09, 0xcd, 0x81, 0x0e, 0xd6, 0x18, 0xcd, 0xc1, 0x00, + 0xd7, 0x51, 0xcd, 0xc1, 0x00, 0xd8, 0xcb, 0xcd, 0x41, 0xd6, 0x27, 0xcd, + 0x81, 0x0a, 0x42, 0x07, 0xfb, 0xbb, 0xcd, 0x01, 0xd8, 0x80, 0xcd, 0x41, + 0xd7, 0x61, 0xcd, 0x01, 0xd8, 0x9c, 0xcd, 0x41, 0xd5, 0x10, 0xcd, 0x81, + 0x1c, 0x96, 0x0d, 0xd7, 0x3d, 0xcd, 0x81, 0x04, 0xd8, 0x78, 0xcd, 0x41, + 0xd8, 0xb3, 0xcd, 0x41, 0xd7, 0x59, 0xcd, 0x81, 0x04, 0xd8, 0x96, 0xcd, + 0x41, 0xd8, 0xd3, 0xcd, 0x41, 0xd6, 0x2f, 0xcd, 0x81, 0x0d, 0xd7, 0x4b, + 0xcd, 0x81, 0x04, 0xd8, 0x88, 0xcd, 0x41, 0xd8, 0xc3, 0xcd, 0x41, 0xd7, + 0x69, 0xcd, 0x81, 0x04, 0xd8, 0xa4, 0xcd, 0x41, 0xd8, 0xe1, 0xcd, 0x41, + 0xd4, 0x06, 0xcd, 0x81, 0x40, 0x95, 0x1f, 0xd6, 0x1c, 0xcd, 0x81, 0x0d, + 0xd7, 0x39, 0xcd, 0x81, 0x04, 0xd8, 0x74, 0xcd, 0x41, 0xd8, 0xaf, 0xcd, + 0x41, 0xd7, 0x55, 0xcd, 0x81, 0x04, 0xd8, 0x93, 0xcd, 0x41, 0xd8, 0xcf, + 0xcd, 0x41, 0xd6, 0x2b, 0xcd, 0x81, 0x0d, 0xd7, 0x48, 0xcd, 0x81, 0x04, + 0xd8, 0x84, 0xcd, 0x41, 0xd8, 0xbf, 0xcd, 0x41, 0xd7, 0x65, 0xcd, 0x81, + 0x04, 0xd8, 0xa0, 0xcd, 0x41, 0xd8, 0xde, 0xcd, 0x41, 0xd5, 0x14, 0xcd, + 0x81, 0x1f, 0xd6, 0x23, 0xcd, 0x81, 0x0d, 0xd7, 0x41, 0xcd, 0x81, 0x04, + 0xd8, 0x7c, 0xcd, 0x41, 0xd8, 0xb7, 0xcd, 0x41, 0xd7, 0x5d, 0xcd, 0x81, + 0x04, 0xd8, 0x99, 0xcd, 0x41, 0xd8, 0xd7, 0xcd, 0x41, 0xd6, 0x33, 0xcd, + 0x81, 0x0d, 0xd7, 0x4e, 0xcd, 0x81, 0x04, 0xd8, 0x8c, 0xcd, 0x41, 0xd8, + 0xc7, 0xcd, 0x41, 0xd7, 0x6d, 0xcd, 0x01, 0xd8, 0xa8, 0xcd, 0x41, 0xd3, + 0x01, 0xcd, 0x81, 0x7c, 0x94, 0x43, 0xd5, 0x0b, 0xcd, 0x81, 0x1f, 0xd6, + 0x1a, 0xcd, 0x81, 0x0d, 0xd7, 0x37, 0xcd, 0x81, 0x04, 0xd8, 0x72, 0xcd, + 0x41, 0xd8, 0xad, 0xcd, 0x41, 0xd7, 0x53, 0xcd, 0x81, 0x04, 0xd8, 0x91, + 0xcd, 0x41, 0xd8, 0xcd, 0xcd, 0x41, 0xd6, 0x29, 0xcd, 0x81, 0x0d, 0xd7, + 0x46, 0xcd, 0x81, 0x04, 0xd8, 0x82, 0xcd, 0x41, 0xd8, 0xbd, 0xcd, 0x41, + 0xd7, 0x63, 0xcd, 0x81, 0x04, 0xd8, 0x9e, 0xcd, 0x41, 0xd8, 0xdc, 0xcd, + 0x41, 0xd5, 0x12, 0xcd, 0x81, 0x1b, 0xd6, 0x21, 0xcd, 0x81, 0x0d, 0xd7, + 0x3f, 0xcd, 0x81, 0x04, 0xd8, 0x7a, 0xcd, 0x41, 0xd8, 0xb5, 0xcd, 0x41, + 0xd7, 0x5b, 0xcd, 0xc1, 0x00, 0xd8, 0xd5, 0xcd, 0x41, 0xd6, 0x31, 0xcd, + 0x81, 0x0a, 0x42, 0x07, 0xfb, 0xc5, 0xcd, 0x01, 0xd8, 0x8a, 0xcd, 0x41, + 0xd7, 0x6b, 0xcd, 0x01, 0xd8, 0xa6, 0xcd, 0x41, 0xd4, 0x08, 0xcd, 0x81, + 0x43, 0xd5, 0x0e, 0xcd, 0x81, 0x1f, 0xd6, 0x1e, 0xcd, 0x81, 0x0d, 0xd7, + 0x3b, 0xcd, 0x81, 0x04, 0xd8, 0x76, 0xcd, 0x41, 0xd8, 0xb1, 0xcd, 0x41, + 0xd7, 0x57, 0xcd, 0x81, 0x04, 0xd8, 0x94, 0xcd, 0x41, 0xd8, 0xd1, 0xcd, + 0x41, 0xd6, 0x2d, 0xcd, 0x81, 0x0d, 0xd7, 0x49, 0xcd, 0x81, 0x04, 0xd8, + 0x86, 0xcd, 0x41, 0xd8, 0xc1, 0xcd, 0x41, 0xd7, 0x67, 0xcd, 0x81, 0x04, + 0xd8, 0xa2, 0xcd, 0x41, 0xd8, 0xdf, 0xcd, 0x41, 0xd5, 0x16, 0xcd, 0x81, + 0x1f, 0xd6, 0x25, 0xcd, 0x81, 0x0d, 0xd7, 0x43, 0xcd, 0x81, 0x04, 0xd8, + 0x7e, 0xcd, 0x41, 0xd8, 0xb9, 0xcd, 0x41, 0xd7, 0x5f, 0xcd, 0x81, 0x04, + 0xd8, 0x9b, 0xcd, 0x41, 0xd8, 0xd9, 0xcd, 0x41, 0xd6, 0x35, 0xcd, 0x81, + 0x0d, 0xd7, 0x50, 0xcd, 0x81, 0x04, 0xd8, 0x8e, 0xcd, 0x41, 0xd8, 0xc9, + 0xcd, 0x41, 0xd7, 0x6f, 0xcd, 0x81, 0x04, 0xd8, 0xaa, 0xcd, 0x41, 0xd8, + 0xe5, 0xcd, 0x41, 0x92, 0x8d, 0x02, 0x93, 0x8b, 0x01, 0xd4, 0x04, 0xcd, + 0x81, 0x43, 0xd5, 0x0a, 0xcd, 0x81, 0x1f, 0xd6, 0x19, 0xcd, 0x81, 0x0d, + 0xd7, 0x36, 0xcd, 0x81, 0x04, 0xd8, 0x71, 0xcd, 0x41, 0xd8, 0xac, 0xcd, + 0x41, 0xd7, 0x52, 0xcd, 0x81, 0x04, 0xd8, 0x90, 0xcd, 0x41, 0xd8, 0xcc, + 0xcd, 0x41, 0xd6, 0x28, 0xcd, 0x81, 0x0d, 0xd7, 0x45, 0xcd, 0x81, 0x04, + 0xd8, 0x81, 0xcd, 0x41, 0xd8, 0xbc, 0xcd, 0x41, 0xd7, 0x62, 0xcd, 0x81, + 0x04, 0xd8, 0x9d, 0xcd, 0x41, 0xd8, 0xdb, 0xcd, 0x41, 0xd5, 0x11, 0xcd, + 0x81, 0x1f, 0xd6, 0x20, 0xcd, 0x81, 0x0d, 0xd7, 0x3e, 0xcd, 0x81, 0x04, + 0xd8, 0x79, 0xcd, 0x41, 0xd8, 0xb4, 0xcd, 0x41, 0xd7, 0x5a, 0xcd, 0x81, + 0x04, 0xd8, 0x97, 0xcd, 0x41, 0xd8, 0xd4, 0xcd, 0x41, 0xd6, 0x30, 0xcd, + 0x81, 0x0d, 0xd7, 0x4c, 0xcd, 0x81, 0x04, 0xd8, 0x89, 0xcd, 0x41, 0xd8, + 0xc4, 0xcd, 0x41, 0xd7, 0x6a, 0xcd, 0x81, 0x04, 0xd8, 0xa5, 0xcd, 0x41, + 0xd8, 0xe2, 0xcd, 0x41, 0xd4, 0x07, 0xcd, 0x81, 0x37, 0xd5, 0x0d, 0xcd, + 0x81, 0x1b, 0xd6, 0x1d, 0xcd, 0x81, 0x0d, 0xd7, 0x3a, 0xcd, 0x81, 0x04, + 0xd8, 0x75, 0xcd, 0x41, 0xd8, 0xb0, 0xcd, 0x41, 0xd7, 0x56, 0xcd, 0xc1, + 0x00, 0xd8, 0xd0, 0xcd, 0x41, 0xd6, 0x2c, 0xcd, 0x81, 0x0a, 0x42, 0x07, + 0xfb, 0xc0, 0xcd, 0x01, 0xd8, 0x85, 0xcd, 0x41, 0xd7, 0x66, 0xcd, 0x01, + 0xd8, 0xa1, 0xcd, 0x41, 0xd5, 0x15, 0xcd, 0x81, 0x1f, 0xd6, 0x24, 0xcd, + 0x81, 0x0d, 0xd7, 0x42, 0xcd, 0x81, 0x04, 0xd8, 0x7d, 0xcd, 0x41, 0xd8, + 0xb8, 0xcd, 0x41, 0xd7, 0x5e, 0xcd, 0x81, 0x04, 0xd8, 0x9a, 0xcd, 0x41, + 0xd8, 0xd8, 0xcd, 0x41, 0xd6, 0x34, 0xcd, 0x81, 0x0d, 0xd7, 0x4f, 0xcd, + 0x81, 0x04, 0xd8, 0x8d, 0xcd, 0x41, 0xd8, 0xc8, 0xcd, 0x41, 0xd7, 0x6e, + 0xcd, 0x81, 0x04, 0xd8, 0xa9, 0xcd, 0x41, 0xd8, 0xe4, 0xcd, 0x41, 0xd3, + 0x02, 0xcd, 0x81, 0x8b, 0x01, 0xd4, 0x05, 0xcd, 0x81, 0x43, 0xd5, 0x0c, + 0xcd, 0x81, 0x1f, 0xd6, 0x1b, 0xcd, 0x81, 0x0d, 0xd7, 0x38, 0xcd, 0x81, + 0x04, 0xd8, 0x73, 0xcd, 0x41, 0xd8, 0xae, 0xcd, 0x41, 0xd7, 0x54, 0xcd, + 0x81, 0x04, 0xd8, 0x92, 0xcd, 0x41, 0xd8, 0xce, 0xcd, 0x41, 0xd6, 0x2a, + 0xcd, 0x81, 0x0d, 0xd7, 0x47, 0xcd, 0x81, 0x04, 0xd8, 0x83, 0xcd, 0x41, + 0xd8, 0xbe, 0xcd, 0x41, 0xd7, 0x64, 0xcd, 0x81, 0x04, 0xd8, 0x9f, 0xcd, + 0x41, 0xd8, 0xdd, 0xcd, 0x41, 0xd5, 0x13, 0xcd, 0x81, 0x1f, 0xd6, 0x22, + 0xcd, 0x81, 0x0d, 0xd7, 0x40, 0xcd, 0x81, 0x04, 0xd8, 0x7b, 0xcd, 0x41, + 0xd8, 0xb6, 0xcd, 0x41, 0xd7, 0x5c, 0xcd, 0x81, 0x04, 0xd8, 0x98, 0xcd, + 0x41, 0xd8, 0xd6, 0xcd, 0x41, 0xd6, 0x32, 0xcd, 0x81, 0x0d, 0xd7, 0x4d, + 0xcd, 0x81, 0x04, 0xd8, 0x8b, 0xcd, 0x41, 0xd8, 0xc6, 0xcd, 0x41, 0xd7, + 0x6c, 0xcd, 0x81, 0x04, 0xd8, 0xa7, 0xcd, 0x41, 0xd8, 0xe3, 0xcd, 0x41, + 0x94, 0x43, 0xd5, 0x0f, 0xcd, 0x81, 0x1f, 0xd6, 0x1f, 0xcd, 0x81, 0x0d, + 0xd7, 0x3c, 0xcd, 0x81, 0x04, 0xd8, 0x77, 0xcd, 0x41, 0xd8, 0xb2, 0xcd, + 0x41, 0xd7, 0x58, 0xcd, 0x81, 0x04, 0xd8, 0x95, 0xcd, 0x41, 0xd8, 0xd2, + 0xcd, 0x41, 0xd6, 0x2e, 0xcd, 0x81, 0x0d, 0xd7, 0x4a, 0xcd, 0x81, 0x04, + 0xd8, 0x87, 0xcd, 0x41, 0xd8, 0xc2, 0xcd, 0x41, 0xd7, 0x68, 0xcd, 0x81, + 0x04, 0xd8, 0xa3, 0xcd, 0x41, 0xd8, 0xe0, 0xcd, 0x41, 0xd5, 0x17, 0xcd, + 0x81, 0x1b, 0xd6, 0x26, 0xcd, 0x81, 0x0d, 0xd7, 0x44, 0xcd, 0x81, 0x04, + 0xd8, 0x7f, 0xcd, 0x41, 0xd8, 0xba, 0xcd, 0x41, 0xd7, 0x60, 0xcd, 0xc1, + 0x00, 0xd8, 0xda, 0xcd, 0x41, 0x96, 0x0a, 0x42, 0x07, 0xfb, 0xca, 0xcd, + 0x01, 0xd8, 0x8f, 0xcd, 0x41, 0xd7, 0x70, 0xcd, 0x01, 0xd8, 0xab, 0xcd, + 0x41, 0x02, 0x36, 0x01, 0x06, 0x49, 0x84, 0x9e, 0x22, 0x24, 0x40, 0x80, + 0x32, 0x8d, 0x01, 0xff, 0x0a, 0x2e, 0x1b, 0x19, 0x0f, 0xc9, 0x72, 0x01, + 0xff, 0xe3, 0x2d, 0x21, 0x00, 0xe8, 0x0c, 0x21, 0x00, 0xe9, 0x11, 0x21, + 0x00, 0xf2, 0x1c, 0x21, 0x00, 0xfa, 0x28, 0x21, 0x40, 0x50, 0xe3, 0x24, + 0xb6, 0x27, 0x00, 0x50, 0xb3, 0x02, 0xb5, 0x27, 0x00, 0x50, 0x9f, 0x42, + 0xb4, 0x27, 0x40, 0x46, 0x30, 0xe0, 0xd3, 0x29, 0x00, 0xa3, 0xb4, 0x07, + 0xa4, 0xc4, 0x06, 0xa6, 0xa4, 0x06, 0xa8, 0xf7, 0x05, 0xac, 0xd4, 0x04, + 0xad, 0xe5, 0x03, 0xae, 0xd6, 0x03, 0x47, 0x8a, 0xd9, 0xc4, 0x2b, 0x00, + 0xb0, 0xb1, 0x03, 0x56, 0x8f, 0x38, 0x53, 0x27, 0x00, 0xb2, 0xaa, 0x02, + 0xb3, 0x9f, 0x01, 0xb4, 0x6f, 0xb5, 0x2c, 0x03, 0x32, 0x00, 0x01, 0xff, + 0x06, 0x35, 0x00, 0x17, 0x08, 0xcd, 0x0a, 0x01, 0xff, 0x47, 0xcc, 0x46, + 0x98, 0xf7, 0x01, 0x47, 0xb1, 0x0a, 0x9e, 0xf7, 0x01, 0x46, 0xfd, 0x05, + 0x1d, 0x2b, 0x40, 0x47, 0xf3, 0x69, 0x2e, 0x2b, 0x00, 0x49, 0xba, 0x49, + 0xae, 0x25, 0x40, 0x59, 0x83, 0x26, 0x7b, 0x26, 0x00, 0xb0, 0x01, 0xff, + 0x58, 0x44, 0x28, 0xa2, 0xf5, 0x01, 0x0a, 0xf8, 0x0b, 0x16, 0x04, 0x6f, + 0x02, 0x06, 0x5b, 0xcf, 0x01, 0x9d, 0x2b, 0x40, 0x4d, 0x45, 0x37, 0xe4, + 0x25, 0x00, 0x4e, 0x46, 0x2a, 0xe5, 0x25, 0x40, 0x4f, 0x63, 0x6f, 0xeb, + 0x23, 0x00, 0x58, 0xfc, 0x2a, 0x81, 0xf7, 0x01, 0x4e, 0x92, 0x0c, 0xb4, + 0x25, 0x00, 0x48, 0x01, 0x02, 0xb2, 0x25, 0x40, 0x48, 0x3a, 0x3f, 0x0e, + 0x26, 0x00, 0x04, 0x7c, 0xf6, 0x12, 0x52, 0xb1, 0x56, 0x7f, 0xf5, 0x01, + 0x44, 0xa3, 0x7a, 0xdf, 0x26, 0x00, 0x57, 0xd3, 0x33, 0xd6, 0x26, 0x40, + 0x47, 0xcc, 0x46, 0x97, 0xf7, 0x01, 0x47, 0xb1, 0x0a, 0x9d, 0xf7, 0x01, + 0x46, 0xfd, 0x05, 0x8c, 0xf7, 0x41, 0x4e, 0x20, 0x79, 0x00, 0x27, 0x00, + 0x47, 0x6a, 0x40, 0x02, 0x27, 0x00, 0x4a, 0x3a, 0x62, 0x17, 0x26, 0x00, + 0x53, 0x0b, 0x4d, 0x71, 0xf5, 0x01, 0x0e, 0x2c, 0x7d, 0x60, 0xad, 0x34, + 0x46, 0x68, 0xe4, 0xc7, 0x26, 0x00, 0x49, 0xad, 0xc3, 0x60, 0x26, 0x00, + 0x45, 0xfe, 0x05, 0xa0, 0x25, 0x80, 0x0c, 0x43, 0x00, 0x14, 0x05, 0x26, + 0x00, 0x4c, 0x6c, 0x9b, 0x00, 0x26, 0x40, 0x80, 0x01, 0xff, 0x46, 0xac, + 0x91, 0x32, 0xf5, 0x01, 0x47, 0xcf, 0x6b, 0xc0, 0x2b, 0x00, 0x48, 0xe7, + 0xcb, 0xf9, 0x23, 0x40, 0x04, 0x5f, 0x07, 0x06, 0x4a, 0x5a, 0x9a, 0x3b, + 0x26, 0x40, 0x47, 0xcc, 0x46, 0x29, 0x2b, 0x00, 0x47, 0xb1, 0x0a, 0x2a, + 0x2b, 0x00, 0xb3, 0x06, 0x53, 0x9b, 0x50, 0xcd, 0xfb, 0x41, 0x45, 0xfe, + 0x05, 0xaa, 0x25, 0x00, 0x43, 0x00, 0x14, 0x51, 0x2b, 0x40, 0x46, 0x12, + 0x03, 0x84, 0xf7, 0x01, 0x46, 0xfd, 0x05, 0x8d, 0xf7, 0x41, 0x48, 0xbb, + 0x49, 0xac, 0x25, 0x00, 0x04, 0xc9, 0x00, 0x06, 0x46, 0xe6, 0xe4, 0xf6, + 0xf3, 0x41, 0x80, 0x56, 0x0a, 0xf8, 0x0b, 0x1e, 0x06, 0xa9, 0x01, 0x01, + 0xff, 0x45, 0xce, 0x00, 0xa1, 0x27, 0x80, 0x0c, 0x46, 0xd5, 0x22, 0x4d, + 0x20, 0x00, 0x55, 0xd5, 0x01, 0x9e, 0x2b, 0x40, 0x44, 0xe6, 0x01, 0xa4, + 0x27, 0x40, 0x4f, 0x63, 0x6f, 0xe9, 0x23, 0x80, 0x27, 0x58, 0xfc, 0x2a, + 0x82, 0xf7, 0x01, 0xb0, 0x13, 0x4e, 0x92, 0x0c, 0xb8, 0x25, 0x00, 0x48, + 0x01, 0x02, 0xb6, 0x25, 0xc0, 0x00, 0x59, 0x76, 0x24, 0xef, 0x23, 0x40, + 0x47, 0x98, 0xcf, 0x53, 0x2b, 0x00, 0x46, 0x34, 0x4c, 0xba, 0x25, 0x40, + 0x52, 0xd7, 0x1f, 0xed, 0x23, 0x40, 0x09, 0x9c, 0x01, 0x06, 0x4e, 0x38, + 0x81, 0xb3, 0xce, 0x41, 0x4e, 0x4e, 0x28, 0x9d, 0xf5, 0x01, 0x45, 0x5d, + 0x14, 0x1b, 0x26, 0x40, 0x4c, 0x10, 0x91, 0xb0, 0x25, 0x00, 0x02, 0x92, + 0x01, 0x06, 0x46, 0xe2, 0xda, 0x88, 0xf5, 0x41, 0x44, 0xf8, 0x34, 0xf2, + 0xf3, 0x01, 0x45, 0x9a, 0xcf, 0x1f, 0x2b, 0x40, 0x4b, 0x65, 0x97, 0x6f, + 0xcc, 0x01, 0x42, 0x1c, 0x19, 0x12, 0x27, 0x40, 0x06, 0x45, 0x04, 0x06, + 0x4a, 0x6a, 0xb4, 0xb8, 0x26, 0x40, 0xa4, 0x4d, 0xac, 0x38, 0x57, 0xbf, + 0x32, 0xf5, 0x23, 0x80, 0x2b, 0xb3, 0x0d, 0x54, 0xb3, 0x48, 0xf6, 0x23, + 0xc0, 0x00, 0x48, 0xce, 0x6b, 0xc5, 0x2b, 0x40, 0x05, 0x5e, 0x07, 0x06, + 0x45, 0xfe, 0x05, 0xfc, 0x25, 0x40, 0x47, 0xcc, 0x46, 0x99, 0xf7, 0x01, + 0x47, 0xb1, 0x0a, 0x9f, 0xf7, 0x01, 0x46, 0xfd, 0x05, 0xfe, 0x25, 0x40, + 0x48, 0xce, 0x6b, 0xc8, 0x2b, 0x40, 0x55, 0x5c, 0x37, 0xf4, 0x23, 0x80, + 0x06, 0x46, 0xb2, 0x0a, 0x27, 0x2b, 0x40, 0x48, 0xce, 0x6b, 0xc7, 0x2b, + 0x40, 0x46, 0xcd, 0x46, 0x25, 0x2b, 0x00, 0x55, 0x8e, 0x35, 0xf7, 0x23, + 0xc0, 0x00, 0x48, 0xce, 0x6b, 0xc6, 0x2b, 0x40, 0x05, 0x4a, 0x1d, 0x70, + 0x03, 0xc4, 0x00, 0x19, 0xaf, 0x01, 0xff, 0x04, 0x15, 0x01, 0x06, 0x45, + 0x94, 0x0a, 0xeb, 0x29, 0x40, 0x4d, 0x45, 0x37, 0xe3, 0x25, 0x00, 0x4e, + 0x46, 0x2a, 0xe2, 0x25, 0x40, 0x80, 0x3a, 0x0a, 0xf8, 0x0b, 0x11, 0x06, + 0xa9, 0x01, 0x01, 0xff, 0x46, 0xd5, 0x22, 0x4c, 0x20, 0x00, 0x55, 0xd5, + 0x01, 0x9c, 0x2b, 0x40, 0x4f, 0x63, 0x6f, 0xea, 0x23, 0x80, 0x18, 0x58, + 0xfc, 0x2a, 0x80, 0xf7, 0x01, 0x47, 0x33, 0x4c, 0xc4, 0x25, 0x00, 0x4e, + 0x92, 0x0c, 0xc2, 0x25, 0x00, 0x48, 0x01, 0x02, 0xc0, 0x25, 0x40, 0x52, + 0xd7, 0x1f, 0xee, 0x23, 0x40, 0x4a, 0xfe, 0xb1, 0xd8, 0x26, 0x00, 0x09, + 0x9c, 0x01, 0x01, 0xff, 0x4e, 0x4e, 0x28, 0x9c, 0xf5, 0x01, 0x45, 0x5d, + 0x14, 0x1a, 0x26, 0x40, 0x46, 0x12, 0x03, 0x24, 0x2b, 0x80, 0x06, 0x46, + 0xfd, 0x05, 0x1b, 0x2b, 0x40, 0x07, 0x16, 0xd3, 0x01, 0xff, 0xac, 0x0c, + 0x55, 0x08, 0x40, 0x6d, 0xcc, 0x01, 0x55, 0xda, 0x40, 0x6c, 0xcc, 0x41, + 0x53, 0x7c, 0x4b, 0x6b, 0xcc, 0x01, 0x54, 0x23, 0x47, 0x6e, 0xcc, 0x41, + 0x55, 0x85, 0x3b, 0xaa, 0xf5, 0x01, 0xa5, 0x0f, 0xaf, 0x01, 0xff, 0x50, + 0xea, 0x69, 0x2c, 0x2b, 0x00, 0x47, 0xee, 0xdc, 0xd7, 0x29, 0x40, 0x43, + 0x2c, 0x01, 0xa4, 0xf5, 0x81, 0x06, 0x45, 0x5c, 0xd7, 0x22, 0x2b, 0x40, + 0x45, 0x0c, 0x29, 0x65, 0x26, 0x40, 0xac, 0x0f, 0xaf, 0x01, 0xff, 0x44, + 0x58, 0x1f, 0xbf, 0xf5, 0x01, 0x4f, 0x97, 0x77, 0x26, 0x27, 0x40, 0x42, + 0x23, 0x02, 0x91, 0x26, 0x00, 0x46, 0x5d, 0x10, 0x3f, 0x27, 0x40, 0x46, + 0xcd, 0x46, 0xc6, 0x25, 0x80, 0x45, 0x03, 0xa6, 0x01, 0x19, 0xb2, 0x01, + 0xff, 0x07, 0x00, 0xd0, 0x06, 0x45, 0x8a, 0xef, 0x22, 0xf3, 0x41, 0x44, + 0x94, 0x36, 0xc3, 0x26, 0x00, 0x43, 0x47, 0x19, 0xc2, 0x26, 0x40, 0x58, + 0x44, 0x28, 0xa3, 0xf5, 0x01, 0x0a, 0xf8, 0x0b, 0x06, 0x5b, 0xcf, 0x01, + 0x9f, 0x2b, 0x40, 0x4f, 0x63, 0x6f, 0xec, 0x23, 0x00, 0x58, 0xfc, 0x2a, + 0x83, 0xf7, 0x01, 0x4e, 0x92, 0x0c, 0xbe, 0x25, 0x00, 0x48, 0x01, 0x02, + 0xbc, 0x25, 0x40, 0x80, 0x01, 0xff, 0x47, 0xcf, 0x6b, 0xc1, 0x2b, 0x00, + 0x4d, 0x56, 0x8a, 0x56, 0x27, 0x00, 0x48, 0xef, 0xce, 0xde, 0x2b, 0x00, + 0x44, 0x0d, 0x29, 0x66, 0x26, 0x00, 0x4f, 0x00, 0x78, 0xea, 0x29, 0x40, + 0x50, 0xaa, 0x65, 0x2c, 0x27, 0x00, 0x05, 0xc3, 0x8c, 0x84, 0x01, 0x45, + 0x13, 0x03, 0xcf, 0x25, 0x80, 0x52, 0x48, 0xb7, 0xcd, 0x63, 0x26, 0x00, + 0x4e, 0xb0, 0x7f, 0xe8, 0x26, 0x00, 0x06, 0xb3, 0x30, 0x01, 0xff, 0x0e, + 0xe0, 0x04, 0x31, 0x0e, 0xe6, 0x7c, 0x21, 0x0f, 0xe4, 0x75, 0x11, 0x0c, + 0xc0, 0x1a, 0x01, 0xff, 0x4f, 0x6f, 0x1b, 0xaa, 0x2b, 0x00, 0x50, 0xb3, + 0x02, 0xab, 0x2b, 0x40, 0x4f, 0xa0, 0x0c, 0xaf, 0x2b, 0x00, 0x4d, 0xe4, + 0x21, 0xad, 0x2b, 0x40, 0x4f, 0xa0, 0x0c, 0xae, 0x2b, 0x00, 0x4d, 0xe4, + 0x21, 0xac, 0x2b, 0x40, 0x4f, 0x6f, 0x1b, 0xa8, 0x2b, 0x00, 0x50, 0xb3, + 0x02, 0xa9, 0x2b, 0x40, 0x80, 0x01, 0xff, 0x4a, 0xd8, 0xaf, 0xfa, 0x23, + 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4a, 0xef, 0x43, 0xed, 0x29, 0x00, + 0x4e, 0x9a, 0x81, 0x89, 0x26, 0x00, 0x06, 0xad, 0x02, 0x01, 0xff, 0x49, + 0x50, 0xbd, 0x88, 0x26, 0x00, 0x4c, 0x32, 0x00, 0xda, 0xf7, 0x41, 0x45, + 0x26, 0xea, 0x57, 0xfa, 0x01, 0x46, 0x1e, 0xe0, 0x5d, 0x26, 0x80, 0xed, + 0x01, 0x4a, 0x74, 0xaf, 0x49, 0xfa, 0x81, 0xdf, 0x01, 0x44, 0xa0, 0xf5, + 0x56, 0xfa, 0x01, 0xab, 0x73, 0x44, 0xf4, 0xf7, 0x5f, 0x26, 0x80, 0x5b, + 0x45, 0x19, 0xc4, 0x5b, 0x26, 0x80, 0x43, 0x44, 0x58, 0xf8, 0x5c, 0x26, + 0x80, 0x2b, 0x07, 0x70, 0x0a, 0x01, 0xff, 0x46, 0x1e, 0xe0, 0x27, 0xfa, + 0x01, 0xab, 0x12, 0x44, 0xf4, 0xf7, 0x29, 0xfa, 0x01, 0x45, 0x19, 0xc4, + 0x25, 0xfa, 0x01, 0x44, 0x58, 0xf8, 0x26, 0xfa, 0x41, 0x43, 0xa1, 0x01, + 0x24, 0xfa, 0x01, 0x45, 0x73, 0x09, 0x28, 0xfa, 0x41, 0x09, 0x2a, 0x2e, + 0x01, 0xff, 0x4e, 0x33, 0x2e, 0x11, 0xfa, 0x01, 0x5b, 0xf9, 0x1e, 0x3b, + 0xfa, 0x41, 0x09, 0x2a, 0x2e, 0x01, 0xff, 0x4e, 0x33, 0x2e, 0x10, 0xfa, + 0x01, 0x5b, 0xf9, 0x1e, 0x3a, 0xfa, 0x41, 0x09, 0x2a, 0x2e, 0x01, 0xff, + 0x4e, 0x33, 0x2e, 0x14, 0xfa, 0x01, 0x5b, 0xf9, 0x1e, 0x3e, 0xfa, 0x41, + 0x43, 0xa1, 0x01, 0x5a, 0x26, 0x80, 0x4c, 0x45, 0x73, 0x09, 0x5e, 0x26, + 0xc0, 0x00, 0x09, 0x2a, 0x2e, 0x15, 0x8d, 0x01, 0xff, 0x46, 0x1e, 0xe0, + 0x53, 0xfa, 0x01, 0x45, 0x19, 0xc4, 0x51, 0xfa, 0x01, 0x44, 0x58, 0xf8, + 0x52, 0xfa, 0x41, 0x52, 0x3b, 0x54, 0x07, 0xfa, 0x01, 0x4e, 0x33, 0x2e, + 0x13, 0xfa, 0x01, 0x5f, 0x3b, 0x12, 0x1c, 0xfa, 0x01, 0xb4, 0x01, 0xff, + 0x5c, 0x00, 0x19, 0x46, 0xfa, 0x01, 0x0b, 0xfa, 0x1e, 0x01, 0xff, 0x4f, + 0x05, 0x1f, 0x3d, 0xfa, 0x01, 0x53, 0x4f, 0x50, 0x31, 0xfa, 0x41, 0x09, + 0x2a, 0x2e, 0x01, 0xff, 0x4e, 0x33, 0x2e, 0x0f, 0xfa, 0x01, 0x5b, 0xf9, + 0x1e, 0x39, 0xfa, 0x41, 0x57, 0x2a, 0x2e, 0x4c, 0xfa, 0x41, 0x09, 0x2a, + 0x2e, 0x01, 0xff, 0x4e, 0x33, 0x2e, 0x12, 0xfa, 0x01, 0x5b, 0xf9, 0x1e, + 0x3c, 0xfa, 0x41, 0x04, 0x8e, 0x26, 0x4d, 0x02, 0xa3, 0x01, 0x3d, 0x44, + 0xc0, 0xf6, 0x59, 0xf4, 0x01, 0x02, 0x60, 0x07, 0x27, 0x4c, 0xdc, 0x97, + 0x23, 0x26, 0x00, 0xb2, 0x15, 0x43, 0x43, 0x1e, 0xac, 0xf9, 0x01, 0xb4, + 0x01, 0xff, 0x49, 0xdb, 0xbc, 0xbf, 0x20, 0x00, 0x47, 0xe8, 0x95, 0xe6, + 0xfa, 0x41, 0xe4, 0x26, 0xf4, 0x01, 0x4a, 0x80, 0xb7, 0x82, 0xf3, 0x41, + 0x46, 0x08, 0xe1, 0xe2, 0xf9, 0x01, 0x45, 0x2d, 0xed, 0xb1, 0xf3, 0x41, + 0x4f, 0xa8, 0x75, 0xf9, 0x29, 0x00, 0x47, 0x1b, 0x33, 0xf8, 0x29, 0x40, + 0xe5, 0xb2, 0xf6, 0x01, 0x43, 0x80, 0x25, 0xb4, 0xf6, 0x41, 0xa4, 0x92, + 0x04, 0x0b, 0x63, 0xa1, 0x85, 0x04, 0x52, 0xdd, 0x54, 0x6c, 0x1c, 0x01, + 0x07, 0x13, 0x06, 0xee, 0x01, 0x07, 0x37, 0x3c, 0x6d, 0x05, 0x5a, 0x03, + 0x44, 0x0b, 0xc7, 0x7a, 0x06, 0x4e, 0xc0, 0x82, 0x43, 0x1c, 0x41, 0xa1, + 0x2c, 0xe5, 0x38, 0x1c, 0x01, 0xe9, 0x30, 0x1c, 0x81, 0x1f, 0xef, 0x3a, + 0x1c, 0x01, 0xf5, 0x32, 0x1c, 0x81, 0x12, 0x08, 0xf2, 0xc6, 0x01, 0xff, + 0xec, 0x36, 0x1c, 0x01, 0xf2, 0x34, 0x1c, 0xc1, 0x00, 0xf2, 0x35, 0x1c, + 0x41, 0xf5, 0x33, 0x1c, 0x41, 0xe9, 0x31, 0x1c, 0x41, 0xe1, 0x2f, 0x1c, + 0x01, 0xe9, 0x39, 0x1c, 0x01, 0xf5, 0x3b, 0x1c, 0x41, 0xa1, 0x17, 0x4b, + 0x13, 0x25, 0x3c, 0x1c, 0x01, 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0x21, + 0x25, 0x3f, 0x1c, 0x01, 0x45, 0x49, 0x4e, 0x3e, 0x1c, 0x41, 0x47, 0x0b, + 0x17, 0x3d, 0x1c, 0x01, 0x47, 0x34, 0x8d, 0x40, 0x1c, 0x41, 0x45, 0x7e, + 0x0b, 0x61, 0x1c, 0x81, 0x72, 0xa6, 0x53, 0x44, 0x6d, 0x2c, 0x62, 0x1c, + 0x81, 0x46, 0x43, 0x7a, 0x0b, 0x5a, 0x1c, 0x01, 0xb3, 0x24, 0xb4, 0x01, + 0xff, 0x42, 0x92, 0x01, 0x63, 0x1c, 0x01, 0xa8, 0x0d, 0xb7, 0x01, 0xff, + 0x44, 0xe9, 0x1e, 0x64, 0x1c, 0x01, 0xef, 0x5b, 0x1c, 0x41, 0x44, 0x49, + 0x12, 0x65, 0x1c, 0x01, 0x43, 0x26, 0x01, 0x5c, 0x1c, 0x41, 0x44, 0x06, + 0x1f, 0x60, 0x1c, 0x81, 0x0d, 0x42, 0x09, 0x24, 0x5f, 0x1c, 0xc1, 0x00, + 0x42, 0x4b, 0x12, 0x68, 0x1c, 0x41, 0x42, 0x4b, 0x12, 0x69, 0x1c, 0x41, + 0x42, 0x4b, 0x12, 0x6b, 0x1c, 0x41, 0xa9, 0x0f, 0xaf, 0x01, 0xff, 0x43, + 0x4a, 0x12, 0x66, 0x1c, 0x01, 0x42, 0x42, 0x00, 0x5d, 0x1c, 0x41, 0x43, + 0x04, 0x24, 0x67, 0x1c, 0x01, 0x42, 0x32, 0x00, 0x5e, 0x1c, 0x41, 0xf9, + 0x6a, 0x1c, 0x41, 0xe1, 0x00, 0x1c, 0x81, 0xfa, 0x01, 0xa2, 0xed, 0x01, + 0xa3, 0xe0, 0x01, 0xa4, 0xc7, 0x01, 0xe5, 0x0a, 0x1c, 0x01, 0xa7, 0xb6, + 0x01, 0x42, 0x22, 0x00, 0x2e, 0x1c, 0x01, 0xe9, 0x02, 0x1c, 0x81, 0xa6, + 0x01, 0xaa, 0x99, 0x01, 0xab, 0x8c, 0x01, 0x42, 0x74, 0x00, 0x29, 0x1c, + 0x01, 0x42, 0x6c, 0x00, 0x26, 0x1c, 0x01, 0xae, 0x68, 0xef, 0x0c, 0x1c, + 0x01, 0xb0, 0x58, 0x42, 0x71, 0x00, 0x28, 0x1c, 0x01, 0xb3, 0x40, 0xb4, + 0x27, 0xf5, 0x04, 0x1c, 0x81, 0x1e, 0xb6, 0x06, 0x42, 0xdf, 0x23, 0x27, + 0x1c, 0x41, 0xe1, 0x2a, 0x1c, 0x01, 0x07, 0xf3, 0xc6, 0x01, 0xff, 0xec, + 0x08, 0x1c, 0x01, 0xf2, 0x06, 0x1c, 0xc1, 0x00, 0xf2, 0x07, 0x1c, 0x41, + 0xf5, 0x05, 0x1c, 0x41, 0xe1, 0x1d, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x1e, + 0x1c, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x18, 0x1c, 0x01, 0x42, 0x22, 0x00, + 0x19, 0x1c, 0x41, 0xe1, 0x2d, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x2b, 0x1c, + 0x01, 0x42, 0x40, 0x06, 0x2c, 0x1c, 0x41, 0xe1, 0x22, 0x1c, 0x01, 0x42, + 0x22, 0x00, 0x23, 0x1c, 0x41, 0xe1, 0x21, 0x1c, 0x01, 0x42, 0x24, 0x02, + 0x12, 0x1c, 0x01, 0x42, 0x2a, 0x05, 0x1c, 0x1c, 0x01, 0x42, 0xdf, 0x23, + 0x17, 0x1c, 0x41, 0xe1, 0x0e, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x0f, 0x1c, + 0x41, 0xe1, 0x15, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x16, 0x1c, 0x41, 0xe9, + 0x03, 0x1c, 0x41, 0xe1, 0x10, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x11, 0x1c, + 0x41, 0xe1, 0x1f, 0x1c, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x20, 0x1c, + 0x41, 0xe1, 0x1a, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x1b, 0x1c, 0x41, 0xe1, + 0x13, 0x1c, 0x01, 0x42, 0x22, 0x00, 0x14, 0x1c, 0x41, 0xe1, 0x24, 0x1c, + 0x01, 0x42, 0x22, 0x00, 0x25, 0x1c, 0x41, 0xe1, 0x01, 0x1c, 0x01, 0xe9, + 0x0b, 0x1c, 0x01, 0xf5, 0x0d, 0x1c, 0x41, 0xd1, 0x44, 0x1c, 0x01, 0xd2, + 0x45, 0x1c, 0x41, 0x44, 0x96, 0x21, 0x41, 0x1c, 0x01, 0x05, 0xf0, 0x06, + 0x06, 0x4b, 0x33, 0xa6, 0x42, 0x1c, 0x41, 0x45, 0x7e, 0x0b, 0x58, 0x1c, + 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x59, 0x1c, 0x01, 0x43, 0x7a, 0x0b, + 0x51, 0x1c, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x50, 0x1c, + 0x41, 0x44, 0x25, 0x01, 0x53, 0x1c, 0x01, 0x42, 0x15, 0x02, 0x52, 0x1c, + 0x41, 0x44, 0x06, 0x1f, 0x57, 0x1c, 0x01, 0x42, 0x09, 0x24, 0x56, 0x1c, + 0x41, 0x43, 0xf9, 0x05, 0x55, 0x1c, 0x01, 0x43, 0xf6, 0x06, 0x54, 0x1c, + 0x41, 0xa1, 0xbf, 0x08, 0x45, 0xf8, 0xea, 0x35, 0x22, 0x00, 0xe4, 0xcf, + 0xf6, 0x01, 0xa5, 0xa6, 0x08, 0xec, 0x07, 0x00, 0x80, 0xfb, 0x07, 0xae, + 0xde, 0x02, 0x09, 0x85, 0xc4, 0x14, 0xb4, 0x06, 0x4a, 0xde, 0xb8, 0xc3, + 0xf9, 0x41, 0x47, 0x15, 0x08, 0x36, 0x21, 0x00, 0x44, 0xe8, 0x09, 0x6c, + 0x22, 0x40, 0x0f, 0x0b, 0x06, 0xa3, 0x01, 0x0d, 0x9b, 0x08, 0x01, 0xff, + 0xa1, 0x91, 0x01, 0x47, 0x2a, 0xd5, 0xbc, 0x6e, 0x01, 0xa4, 0x7d, 0xa5, + 0x6a, 0x45, 0x56, 0xec, 0xbf, 0x6e, 0x01, 0xa7, 0x56, 0x48, 0x5f, 0xcc, + 0xc1, 0x6e, 0x01, 0xe9, 0xc2, 0x6e, 0x01, 0x44, 0xc9, 0xea, 0xc4, 0x6e, + 0x01, 0x45, 0x09, 0xee, 0xc5, 0x6e, 0x01, 0x44, 0x0f, 0x5b, 0xc6, 0x6e, + 0x01, 0xae, 0x2c, 0x42, 0x9d, 0x01, 0xca, 0x6e, 0x01, 0x42, 0x0d, 0x06, + 0xcb, 0x6e, 0x01, 0xb3, 0x12, 0x48, 0x27, 0xd1, 0xd0, 0x6e, 0x01, 0x42, + 0x3e, 0x00, 0xd1, 0x6e, 0x01, 0x45, 0x1e, 0xf2, 0xd2, 0x6e, 0x41, 0x43, + 0x21, 0x08, 0xce, 0x6e, 0x01, 0x43, 0x61, 0x38, 0xcf, 0x6e, 0x41, 0x43, + 0x6e, 0xa1, 0xc9, 0x6e, 0x01, 0x43, 0x57, 0x07, 0xc7, 0x6e, 0x41, 0x42, + 0x2a, 0x05, 0xc8, 0x6e, 0x01, 0x44, 0xe8, 0xf7, 0xc0, 0x6e, 0x41, 0xe8, + 0xbe, 0x6e, 0x01, 0x44, 0x4f, 0x7e, 0xcc, 0x6e, 0xc1, 0x00, 0x47, 0x5c, + 0xd3, 0xcd, 0x6e, 0x41, 0x45, 0x62, 0xea, 0xbd, 0x6e, 0x01, 0x43, 0xfb, + 0xd7, 0xc3, 0x6e, 0x41, 0x44, 0x48, 0xf8, 0xbb, 0x6e, 0x01, 0xf9, 0xd3, + 0x6e, 0x41, 0xa1, 0x91, 0x01, 0x47, 0x2a, 0xd5, 0xa1, 0x6e, 0x01, 0xa4, + 0x7d, 0xa5, 0x6a, 0x45, 0x56, 0xec, 0xa4, 0x6e, 0x01, 0xa7, 0x56, 0x48, + 0x5f, 0xcc, 0xa6, 0x6e, 0x01, 0xe9, 0xa7, 0x6e, 0x01, 0x44, 0xc9, 0xea, + 0xa9, 0x6e, 0x01, 0x45, 0x09, 0xee, 0xaa, 0x6e, 0x01, 0x44, 0x0f, 0x5b, + 0xab, 0x6e, 0x01, 0xae, 0x2c, 0x42, 0x9d, 0x01, 0xaf, 0x6e, 0x01, 0x42, + 0x0d, 0x06, 0xb0, 0x6e, 0x01, 0xb3, 0x12, 0x48, 0x27, 0xd1, 0xb5, 0x6e, + 0x01, 0x42, 0x3e, 0x00, 0xb6, 0x6e, 0x01, 0x45, 0x1e, 0xf2, 0xb7, 0x6e, + 0x41, 0x43, 0x21, 0x08, 0xb3, 0x6e, 0x01, 0x43, 0x61, 0x38, 0xb4, 0x6e, + 0x41, 0x43, 0x6e, 0xa1, 0xae, 0x6e, 0x01, 0x43, 0x57, 0x07, 0xac, 0x6e, + 0x41, 0x42, 0x2a, 0x05, 0xad, 0x6e, 0x01, 0x44, 0xe8, 0xf7, 0xa5, 0x6e, + 0x41, 0xe8, 0xa3, 0x6e, 0x01, 0x44, 0x4f, 0x7e, 0xb1, 0x6e, 0xc1, 0x00, + 0x47, 0x5c, 0xd3, 0xb2, 0x6e, 0x41, 0x45, 0x62, 0xea, 0xa2, 0x6e, 0x01, + 0x43, 0xfb, 0xd7, 0xa8, 0x6e, 0x41, 0x44, 0x48, 0xf8, 0xa0, 0x6e, 0x01, + 0xf9, 0xb8, 0x6e, 0x41, 0x05, 0x80, 0xbb, 0x1b, 0xb4, 0x0d, 0x49, 0x94, + 0xc7, 0x2c, 0x23, 0xc0, 0x00, 0x4c, 0x2b, 0x24, 0xe3, 0x23, 0x40, 0x69, + 0x95, 0x01, 0x5e, 0x2b, 0x00, 0x45, 0x4e, 0xef, 0x71, 0xf3, 0x41, 0xa1, + 0xe6, 0x04, 0x09, 0x77, 0x43, 0xb4, 0x04, 0x06, 0xef, 0x06, 0xed, 0x03, + 0x4a, 0x1e, 0xb0, 0xfb, 0x09, 0x00, 0x46, 0x0c, 0xe3, 0xfa, 0x09, 0x00, + 0x07, 0x13, 0x06, 0x95, 0x01, 0x06, 0x68, 0x84, 0x84, 0x01, 0xb3, 0x44, + 0x0b, 0xc7, 0x7a, 0x01, 0xff, 0xa1, 0x31, 0xe5, 0xc7, 0x09, 0x00, 0xe9, + 0xbf, 0x09, 0x80, 0x24, 0xef, 0xcb, 0x09, 0x00, 0xf5, 0xc1, 0x09, 0x80, + 0x17, 0x08, 0xf2, 0xc6, 0x01, 0xff, 0xec, 0xe2, 0x09, 0x80, 0x09, 0xf2, + 0xc3, 0x09, 0xc0, 0x00, 0xf2, 0xc4, 0x09, 0x40, 0xec, 0xe3, 0x09, 0x40, + 0xf5, 0xc2, 0x09, 0x40, 0xe9, 0xc0, 0x09, 0x40, 0xe1, 0xbe, 0x09, 0x00, + 0xe9, 0xc8, 0x09, 0x00, 0xf5, 0xcc, 0x09, 0x40, 0x4a, 0x08, 0xad, 0xfe, + 0x09, 0x00, 0x04, 0x5b, 0x03, 0x01, 0xff, 0xa1, 0x25, 0xa3, 0x17, 0x45, + 0x62, 0x41, 0xbc, 0x09, 0x00, 0x02, 0x02, 0x00, 0x01, 0xff, 0x44, 0x21, + 0x25, 0xcd, 0x09, 0x00, 0x45, 0x49, 0x4e, 0x83, 0x09, 0x40, 0x4a, 0x14, + 0x25, 0x81, 0x09, 0x00, 0x57, 0x01, 0x17, 0xf0, 0x1d, 0x41, 0x47, 0x0b, + 0x17, 0x82, 0x09, 0x00, 0x47, 0x34, 0x8d, 0xbd, 0x09, 0x40, 0x44, 0xb9, + 0x00, 0xf2, 0x09, 0x00, 0x44, 0x5a, 0x03, 0xf3, 0x09, 0x40, 0xe1, 0x85, + 0x09, 0x80, 0xaf, 0x02, 0xa2, 0xa2, 0x02, 0xa3, 0x95, 0x02, 0xa4, 0xfc, + 0x01, 0xe5, 0x8f, 0x09, 0x00, 0xa7, 0xeb, 0x01, 0x42, 0x22, 0x00, 0xb9, + 0x09, 0x00, 0xe9, 0x87, 0x09, 0x80, 0xdb, 0x01, 0xaa, 0xce, 0x01, 0xab, + 0xba, 0x01, 0x42, 0x74, 0x00, 0xb2, 0x09, 0x00, 0x42, 0x6c, 0x00, 0xae, + 0x09, 0x00, 0xae, 0x95, 0x01, 0xef, 0x93, 0x09, 0x00, 0xb0, 0x84, 0x01, + 0xb2, 0x60, 0xb3, 0x4e, 0xb4, 0x35, 0xf5, 0x89, 0x09, 0x80, 0x2c, 0xb6, + 0x0d, 0xb9, 0x01, 0xff, 0xe1, 0xaf, 0x09, 0x00, 0x42, 0xdf, 0x23, 0xdf, + 0x09, 0x40, 0x4d, 0x7a, 0x86, 0xfc, 0x09, 0x00, 0x07, 0xf3, 0xc6, 0x01, + 0xff, 0xec, 0x8c, 0x09, 0x80, 0x09, 0xf2, 0x8b, 0x09, 0xc0, 0x00, 0xf2, + 0xe0, 0x09, 0x40, 0xec, 0xe1, 0x09, 0x40, 0xf5, 0x8a, 0x09, 0x40, 0xe1, + 0xa4, 0x09, 0x00, 0x42, 0x22, 0x00, 0xa5, 0x09, 0x00, 0xb4, 0x01, 0xff, + 0xe1, 0x9f, 0x09, 0x00, 0x42, 0x22, 0x00, 0xa0, 0x09, 0x40, 0xe1, 0xb8, + 0x09, 0x00, 0x42, 0x22, 0x00, 0xb6, 0x09, 0x00, 0x42, 0x40, 0x06, 0xb7, + 0x09, 0x40, 0xe1, 0xb0, 0x09, 0x80, 0x0c, 0x42, 0x22, 0x00, 0xdd, 0x09, + 0x00, 0x42, 0x71, 0x00, 0xdc, 0x09, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, + 0x4e, 0x56, 0x7d, 0xf1, 0x09, 0x00, 0x4f, 0x6e, 0x73, 0xf0, 0x09, 0x40, + 0xe1, 0xaa, 0x09, 0x00, 0x42, 0x22, 0x00, 0xab, 0x09, 0x40, 0xe1, 0xa8, + 0x09, 0x00, 0x42, 0x24, 0x02, 0x99, 0x09, 0x00, 0x42, 0x2a, 0x05, 0xa3, + 0x09, 0x00, 0x42, 0xdf, 0x23, 0x9e, 0x09, 0x40, 0xe1, 0x95, 0x09, 0x00, + 0x42, 0x22, 0x00, 0x96, 0x09, 0xc0, 0x00, 0x46, 0x2c, 0xe4, 0xce, 0x09, + 0x40, 0xe1, 0x9c, 0x09, 0x00, 0x42, 0x22, 0x00, 0x9d, 0x09, 0x40, 0xe9, + 0x88, 0x09, 0x40, 0xe1, 0x97, 0x09, 0x00, 0x42, 0x22, 0x00, 0x98, 0x09, + 0x40, 0xe1, 0xa6, 0x09, 0x00, 0xa4, 0x06, 0x42, 0x22, 0x00, 0xa7, 0x09, + 0x40, 0xe1, 0xa1, 0x09, 0x00, 0x42, 0x22, 0x00, 0xa2, 0x09, 0x40, 0xe1, + 0x9a, 0x09, 0x00, 0x42, 0x22, 0x00, 0x9b, 0x09, 0x40, 0xe1, 0xac, 0x09, + 0x00, 0x42, 0x22, 0x00, 0xad, 0x09, 0x40, 0xe1, 0x86, 0x09, 0x00, 0xe9, + 0x90, 0x09, 0x00, 0x53, 0x6a, 0x4d, 0xf1, 0x1d, 0x01, 0xf5, 0x94, 0x09, + 0x40, 0x45, 0x7e, 0x0b, 0xee, 0x09, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, + 0xef, 0x09, 0x00, 0x43, 0x7a, 0x0b, 0xe7, 0x09, 0x00, 0xb3, 0x14, 0xb4, + 0x06, 0x44, 0x80, 0x1f, 0xe6, 0x09, 0x40, 0x44, 0x25, 0x01, 0xe9, 0x09, + 0x00, 0x42, 0x15, 0x02, 0xe8, 0x09, 0x40, 0x44, 0x06, 0x1f, 0xed, 0x09, + 0x00, 0x42, 0x09, 0x24, 0xec, 0x09, 0x40, 0x43, 0xf9, 0x05, 0xeb, 0x09, + 0x00, 0x43, 0xf6, 0x06, 0xea, 0x09, 0x40, 0x53, 0x43, 0x4b, 0xf9, 0x09, + 0x00, 0x0a, 0xe5, 0x8a, 0x01, 0xff, 0x44, 0xf5, 0x06, 0xf7, 0x09, 0x00, + 0x43, 0x7a, 0x0b, 0xf4, 0x09, 0x80, 0x0f, 0xb4, 0x01, 0xff, 0x44, 0x25, + 0x01, 0xf6, 0x09, 0x00, 0x42, 0x15, 0x02, 0xf5, 0x09, 0x40, 0x5a, 0xb5, + 0x1f, 0xf8, 0x09, 0x40, 0x50, 0x5e, 0x5a, 0xfd, 0x09, 0x00, 0x43, 0xc5, + 0x8b, 0x80, 0x09, 0x00, 0x4d, 0x91, 0x79, 0xd7, 0x09, 0x40, 0xec, 0x14, + 0xf5, 0xc1, 0x00, 0x80, 0x0c, 0x48, 0x67, 0xcc, 0xce, 0xf6, 0x01, 0x43, + 0x1e, 0x17, 0xce, 0xce, 0x41, 0x46, 0x10, 0xe5, 0xd1, 0xfa, 0x01, 0x46, + 0x16, 0x08, 0x7e, 0x23, 0x00, 0x58, 0x9c, 0x2d, 0x15, 0xf5, 0x41, 0x45, + 0x21, 0xbc, 0x7a, 0xf3, 0x01, 0x43, 0xbd, 0x01, 0xb2, 0xfa, 0x41, 0x50, + 0x2a, 0x64, 0xd6, 0xf3, 0x01, 0x04, 0x91, 0xa4, 0x20, 0x42, 0x5f, 0x01, + 0xd8, 0xfa, 0x01, 0xb2, 0x0c, 0x4a, 0x9e, 0xb7, 0x93, 0xf4, 0x01, 0x43, + 0x32, 0x00, 0xab, 0xf9, 0x41, 0x45, 0x0b, 0x08, 0x3b, 0xf4, 0x01, 0x4a, + 0x98, 0xae, 0xd4, 0xf9, 0x41, 0x57, 0xf9, 0x2e, 0x9c, 0xf3, 0x01, 0x58, + 0x64, 0x29, 0x9d, 0xf3, 0x01, 0x4c, 0x20, 0x93, 0x6b, 0x26, 0x00, 0x4f, + 0x4d, 0x76, 0x6c, 0x26, 0x40, 0x42, 0x08, 0x00, 0x76, 0xf4, 0x81, 0xa9, + 0x30, 0xa3, 0xeb, 0x2f, 0xa4, 0xdc, 0x2f, 0xa7, 0xc7, 0x2f, 0xac, 0xa9, + 0x27, 0x04, 0x10, 0x97, 0xca, 0x05, 0xae, 0x99, 0x05, 0xb2, 0x82, 0x05, + 0xb3, 0x80, 0x03, 0xf4, 0x87, 0xf9, 0xc1, 0x00, 0x03, 0x2a, 0x4f, 0x11, + 0xe8, 0xc0, 0xf6, 0x81, 0x06, 0x44, 0xea, 0xdf, 0x0b, 0xf5, 0x41, 0x43, + 0xf2, 0xba, 0xc1, 0xf6, 0x41, 0x0f, 0x09, 0x35, 0xd7, 0x02, 0x07, 0x13, + 0x06, 0x6b, 0x03, 0xd6, 0x45, 0x5b, 0xb3, 0x33, 0x0b, 0xc7, 0x7a, 0x01, + 0xff, 0xe5, 0xe7, 0x1b, 0x80, 0x25, 0xe9, 0xea, 0x1b, 0x00, 0x05, 0x25, + 0xd8, 0x15, 0xef, 0xec, 0x1b, 0x00, 0x48, 0x77, 0xcf, 0xe8, 0x1b, 0x00, + 0xf5, 0xee, 0x1b, 0xc0, 0x00, 0x52, 0x8f, 0x51, 0xef, 0x1b, 0x40, 0xe9, + 0xeb, 0x1b, 0x00, 0xef, 0xed, 0x1b, 0x40, 0xe5, 0xe9, 0x1b, 0x40, 0x49, + 0xd8, 0xbf, 0xe6, 0x1b, 0x00, 0x0c, 0x2c, 0x9c, 0x01, 0xff, 0x45, 0xaa, + 0xed, 0xfe, 0x1b, 0x00, 0x48, 0x1f, 0xce, 0xfc, 0x1b, 0x00, 0xb0, 0x01, + 0xff, 0x47, 0xac, 0xd4, 0xff, 0x1b, 0x00, 0x49, 0xfc, 0xbf, 0xfd, 0x1b, + 0x40, 0x45, 0xae, 0xd4, 0xf2, 0x1b, 0x00, 0x47, 0xd7, 0xd9, 0xf3, 0x1b, + 0x40, 0xe1, 0xc0, 0x1b, 0x00, 0x42, 0x16, 0x00, 0xc5, 0x1b, 0x00, 0x42, + 0x37, 0x00, 0xe1, 0x1b, 0x00, 0x42, 0x7b, 0x08, 0xd1, 0x1b, 0x00, 0x42, + 0x24, 0x02, 0xce, 0x1b, 0x00, 0x42, 0x22, 0x00, 0xc2, 0x1b, 0x00, 0xe9, + 0xe4, 0x1b, 0x00, 0x42, 0x78, 0x1a, 0xd0, 0x1b, 0x00, 0x47, 0x25, 0xd8, + 0xc6, 0x1b, 0x00, 0x42, 0x74, 0x00, 0xde, 0x1b, 0x00, 0xad, 0x8b, 0x01, + 0xae, 0x6d, 0x42, 0xe0, 0x09, 0xc7, 0x1b, 0x80, 0x60, 0x42, 0x71, 0x00, + 0xd2, 0x1b, 0x00, 0xb3, 0x10, 0xf5, 0xe5, 0x1b, 0x00, 0x42, 0xa9, 0x01, + 0xcb, 0x1b, 0x00, 0x42, 0xdf, 0x23, 0xdb, 0x1b, 0x40, 0xe1, 0xd8, 0x1b, + 0x00, 0x0a, 0x95, 0x51, 0x06, 0x4a, 0xf6, 0xb4, 0xd6, 0x1b, 0x40, 0xe1, + 0xc1, 0x1b, 0x00, 0x42, 0x24, 0x02, 0xcf, 0x1b, 0x00, 0x42, 0x22, 0x00, + 0xc3, 0x1b, 0x00, 0x42, 0x74, 0x00, 0xdf, 0x1b, 0x00, 0x42, 0x6c, 0x00, + 0xd5, 0x1b, 0x00, 0x42, 0xe0, 0x09, 0xc8, 0x1b, 0x00, 0x42, 0x71, 0x00, + 0xd3, 0x1b, 0x00, 0x42, 0x40, 0x06, 0xd9, 0x1b, 0x00, 0x42, 0xa9, 0x01, + 0xcc, 0x1b, 0x00, 0x42, 0xdf, 0x23, 0xdc, 0x1b, 0x40, 0x47, 0x5d, 0xd8, + 0xcd, 0x1b, 0x40, 0xe1, 0xc9, 0x1b, 0x00, 0x42, 0x7b, 0x08, 0xe2, 0x1b, + 0x00, 0x42, 0x24, 0x02, 0xdd, 0x1b, 0x00, 0x4a, 0xa6, 0xb4, 0xd7, 0x1b, + 0x00, 0x42, 0xdf, 0x23, 0xe0, 0x1b, 0x40, 0xe1, 0xd4, 0x1b, 0x80, 0x06, + 0x42, 0x16, 0x00, 0xe3, 0x1b, 0x40, 0x09, 0xf4, 0xc1, 0x01, 0xff, 0x42, + 0x22, 0x00, 0xc4, 0x1b, 0x00, 0x42, 0x2a, 0x05, 0xca, 0x1b, 0x00, 0x42, + 0x40, 0x06, 0xda, 0x1b, 0x40, 0xe8, 0xf1, 0x1b, 0x00, 0x42, 0x1d, 0x01, + 0xf0, 0x1b, 0x40, 0x45, 0xb1, 0xeb, 0xbe, 0x26, 0x00, 0x43, 0x8c, 0x09, + 0xfa, 0xf9, 0x81, 0xeb, 0x01, 0x07, 0x7b, 0xdb, 0x01, 0xff, 0x0a, 0xc2, + 0x5b, 0xbb, 0x01, 0x49, 0x4f, 0x17, 0xf5, 0x6a, 0x01, 0x07, 0x13, 0x06, + 0x01, 0xff, 0xe1, 0xe7, 0x6a, 0x01, 0x42, 0x16, 0x00, 0xe2, 0x6a, 0x01, + 0x42, 0x73, 0x02, 0xdf, 0x6a, 0x01, 0xa4, 0x93, 0x01, 0xe5, 0xec, 0x6a, + 0x81, 0x83, 0x01, 0x42, 0x0c, 0x08, 0xd3, 0x6a, 0x01, 0xa7, 0x6f, 0x44, + 0x21, 0xf6, 0xda, 0x6a, 0x01, 0xe9, 0xed, 0x6a, 0x01, 0x42, 0xe6, 0x0a, + 0xd9, 0x6a, 0x01, 0xab, 0x53, 0x43, 0xb6, 0x05, 0xd4, 0x6a, 0x01, 0xef, + 0xe8, 0x6a, 0x81, 0x44, 0x42, 0xe0, 0x09, 0xe5, 0x6a, 0x01, 0x42, 0x46, + 0x03, 0xd2, 0x6a, 0x01, 0x42, 0x1e, 0x00, 0xe1, 0x6a, 0x01, 0xf5, 0xea, + 0x6a, 0x81, 0x27, 0x42, 0x4b, 0x65, 0xe3, 0x6a, 0x01, 0x42, 0xa9, 0x01, + 0xdb, 0x6a, 0x81, 0x14, 0xb9, 0x06, 0x42, 0x0f, 0x00, 0xdc, 0x6a, 0x41, + 0x43, 0xaa, 0x36, 0xe4, 0x6a, 0x01, 0x42, 0xf4, 0x02, 0xd5, 0x6a, 0x41, + 0x43, 0x88, 0x38, 0xe6, 0x6a, 0x41, 0x42, 0x48, 0x33, 0xe0, 0x6a, 0x41, + 0xef, 0xe9, 0x6a, 0x41, 0xe1, 0xd1, 0x6a, 0x01, 0x43, 0x05, 0x45, 0xd8, + 0x6a, 0x41, 0x42, 0x3d, 0x0a, 0xd6, 0x6a, 0x01, 0x42, 0xf8, 0x0d, 0xdd, + 0x6a, 0x41, 0xe5, 0xeb, 0x6a, 0x01, 0x43, 0x9d, 0x25, 0xd0, 0x6a, 0x41, + 0x43, 0x28, 0xf6, 0xd7, 0x6a, 0x01, 0xef, 0xde, 0x6a, 0x41, 0x04, 0xb4, + 0x0b, 0x16, 0x03, 0x13, 0x01, 0x06, 0x48, 0xae, 0xba, 0xf2, 0x6a, 0x41, + 0x45, 0xc1, 0x2e, 0xf1, 0x6a, 0x01, 0x49, 0xad, 0xba, 0xf3, 0x6a, 0x41, + 0x45, 0xc1, 0x2e, 0xf0, 0x6a, 0x01, 0x49, 0xa4, 0xba, 0xf4, 0x6a, 0x41, + 0x4d, 0x1b, 0x85, 0xc0, 0xf3, 0x41, 0x80, 0x06, 0x48, 0xaf, 0xc9, 0x88, + 0xf4, 0x41, 0x45, 0x62, 0xca, 0xca, 0xf4, 0x01, 0x47, 0x9f, 0xd9, 0xfc, + 0xf9, 0x41, 0x43, 0x19, 0x13, 0x4c, 0xf3, 0x01, 0x42, 0xe6, 0x0a, 0x95, + 0xfa, 0x01, 0xeb, 0xe6, 0xf3, 0xc1, 0x00, 0x0a, 0xf2, 0xb3, 0x01, 0xff, + 0x4b, 0x2f, 0xa0, 0xb5, 0xf4, 0x01, 0x49, 0x5e, 0xbe, 0xb6, 0xf4, 0x01, + 0x4a, 0x46, 0xb5, 0xb7, 0xf4, 0x01, 0x48, 0x18, 0x83, 0xb4, 0xf4, 0x41, + 0x02, 0x13, 0x05, 0xb6, 0x21, 0x49, 0x4f, 0x17, 0xf3, 0xa6, 0x00, 0x07, + 0x13, 0x06, 0x12, 0x47, 0x75, 0xd9, 0xf2, 0xa6, 0x00, 0x4d, 0x88, 0x36, + 0xf7, 0xa6, 0x00, 0x49, 0xf1, 0xc4, 0xf6, 0xa6, 0x40, 0xe1, 0xa0, 0xa6, + 0x00, 0x42, 0x27, 0x01, 0xa4, 0xa6, 0x00, 0xa6, 0xf7, 0x20, 0xe9, 0xa9, + 0xa6, 0x00, 0xab, 0xb7, 0x20, 0xac, 0x9c, 0x20, 0xed, 0xb3, 0xa6, 0x80, + 0xec, 0x1f, 0xae, 0x90, 0x1f, 0xef, 0xa7, 0xa6, 0x00, 0xb0, 0x93, 0x01, + 0xb2, 0x6b, 0xb3, 0x3d, 0xb4, 0x23, 0xf5, 0xa2, 0xa6, 0x00, 0xb7, 0x13, + 0xb9, 0x01, 0xff, 0xe1, 0xc2, 0xa6, 0x00, 0x42, 0x54, 0x98, 0xbf, 0xa6, + 0x00, 0x42, 0x35, 0xa1, 0xc1, 0xa6, 0x40, 0xe1, 0xda, 0xa6, 0x00, 0x42, + 0x5c, 0x0a, 0xc9, 0xa6, 0x40, 0xa1, 0x0e, 0xa5, 0x04, 0xe9, 0xe4, 0xa6, + 0x40, 0xee, 0xea, 0xa6, 0x00, 0xf4, 0xe8, 0xa6, 0x40, 0xe1, 0xb0, 0xa6, + 0x00, 0xe5, 0xa6, 0xa6, 0x40, 0x44, 0x42, 0xd3, 0xec, 0xa6, 0x00, 0x43, + 0xdf, 0xf1, 0xb9, 0xa6, 0x00, 0xa8, 0x0a, 0xe9, 0xb7, 0xa6, 0x00, 0x42, + 0x5a, 0x77, 0xb4, 0xa6, 0x40, 0x43, 0xdf, 0xf1, 0xb8, 0xa6, 0x00, 0x42, + 0xc0, 0x29, 0xb6, 0xa6, 0x00, 0xef, 0xd6, 0xa6, 0x00, 0xf5, 0xc0, 0xa6, + 0x40, 0x42, 0x42, 0x10, 0xd1, 0xa6, 0x00, 0xa5, 0x10, 0xa9, 0x04, 0xf5, + 0xcc, 0xa6, 0x40, 0x42, 0x27, 0x01, 0xad, 0xa6, 0x00, 0xe9, 0xac, 0xa6, + 0x40, 0xe5, 0xa5, 0xa6, 0x00, 0xee, 0xe1, 0xa6, 0x00, 0x42, 0x13, 0x9c, + 0xd0, 0xa6, 0x40, 0xe1, 0xab, 0xa6, 0x00, 0xa5, 0xe5, 0x1d, 0x05, 0xd8, + 0xec, 0x11, 0xe9, 0xdd, 0xa6, 0x00, 0xb5, 0x01, 0xff, 0x42, 0x42, 0x10, + 0xd7, 0xa6, 0x00, 0xe5, 0xc8, 0xa6, 0x40, 0x02, 0x5a, 0x00, 0xdf, 0x18, + 0x02, 0x26, 0x02, 0xb8, 0x15, 0x02, 0x53, 0x03, 0x94, 0x10, 0x02, 0x06, + 0x00, 0x96, 0x0a, 0x02, 0x60, 0x00, 0xc2, 0x02, 0x02, 0x25, 0x00, 0x01, + 0xff, 0x42, 0x27, 0x01, 0x06, 0x6a, 0x01, 0x43, 0x3f, 0xfa, 0x2b, 0x6a, + 0x01, 0xab, 0x8c, 0x02, 0xac, 0xfb, 0x01, 0xed, 0x11, 0x6a, 0x81, 0xd9, + 0x01, 0xae, 0x93, 0x01, 0xb0, 0x7f, 0xb2, 0x5d, 0xb3, 0x35, 0xb4, 0x23, + 0xf5, 0x04, 0x6a, 0x01, 0x44, 0x0c, 0xf9, 0x38, 0x6a, 0x01, 0xb7, 0x0d, + 0xb9, 0x01, 0xff, 0xe1, 0x1d, 0x6a, 0x01, 0x42, 0x54, 0x98, 0x1b, 0x6a, + 0x41, 0xe1, 0x2c, 0x6a, 0x01, 0x42, 0x5c, 0x0a, 0x21, 0x6a, 0x41, 0xa1, + 0x06, 0x42, 0x14, 0x06, 0x35, 0x6a, 0x41, 0xe1, 0x0e, 0x6a, 0x01, 0xe5, + 0x08, 0x6a, 0x41, 0x44, 0x42, 0xd3, 0x37, 0x6a, 0x01, 0x43, 0xdf, 0xf1, + 0x15, 0x6a, 0x01, 0xa8, 0x0a, 0xe9, 0x14, 0x6a, 0x01, 0x42, 0x5a, 0x77, + 0x12, 0x6a, 0x41, 0x42, 0xc0, 0x29, 0x13, 0x6a, 0x01, 0xef, 0x29, 0x6a, + 0x01, 0xf5, 0x1c, 0x6a, 0x41, 0xa5, 0x10, 0xa9, 0x04, 0xf5, 0x23, 0x6a, + 0x41, 0x42, 0x27, 0x01, 0x0c, 0x6a, 0x01, 0xe9, 0x0b, 0x6a, 0x41, 0xe5, + 0x07, 0x6a, 0x01, 0xee, 0x31, 0x6a, 0x01, 0x42, 0x13, 0x9c, 0x25, 0x6a, + 0x41, 0xa5, 0x06, 0x43, 0x9c, 0x9a, 0x2a, 0x6a, 0x41, 0xe5, 0x22, 0x6a, + 0x01, 0x42, 0x13, 0x9c, 0x1f, 0x6a, 0x41, 0x43, 0x37, 0x5a, 0x0f, 0x6a, + 0x01, 0xa7, 0x2f, 0xe9, 0x24, 0x6a, 0x01, 0xaa, 0x1d, 0x43, 0xa4, 0x02, + 0x1e, 0x6a, 0x01, 0x43, 0x10, 0x19, 0x20, 0x6a, 0x01, 0xf5, 0x19, 0x6a, + 0x81, 0x06, 0x42, 0xa0, 0x1b, 0x09, 0x6a, 0x41, 0x42, 0x42, 0x10, 0x18, + 0x6a, 0x41, 0x43, 0xcc, 0x8b, 0x10, 0x6a, 0x01, 0x43, 0x9c, 0x9a, 0x1a, + 0x6a, 0x41, 0x42, 0x24, 0x02, 0x28, 0x6a, 0x01, 0x45, 0xeb, 0xed, 0x27, + 0x6a, 0x41, 0xe1, 0x32, 0x6a, 0x01, 0xa2, 0x0a, 0x44, 0x7b, 0xf5, 0x0d, + 0x6a, 0x01, 0xef, 0x33, 0x6a, 0x41, 0x42, 0x4e, 0x13, 0x34, 0x6a, 0x01, + 0x42, 0x92, 0x01, 0x30, 0x6a, 0x41, 0xe1, 0x0a, 0x6a, 0x01, 0xe9, 0x2d, + 0x6a, 0x01, 0x42, 0x54, 0x98, 0x2e, 0x6a, 0x41, 0xe1, 0x03, 0x6a, 0x01, + 0xa5, 0x14, 0xef, 0x2f, 0x6a, 0x01, 0x42, 0xe0, 0x09, 0x36, 0x6a, 0x01, + 0xf5, 0x05, 0x6a, 0x01, 0x43, 0x22, 0xaf, 0x16, 0x6a, 0x41, 0xee, 0x26, + 0x6a, 0x01, 0xf4, 0x17, 0x6a, 0x41, 0xe1, 0xd5, 0x69, 0x01, 0xa6, 0x95, + 0x07, 0xa7, 0xde, 0x06, 0xe9, 0xd8, 0x69, 0x01, 0xab, 0xa3, 0x06, 0xac, + 0xf2, 0x05, 0xad, 0x94, 0x05, 0xae, 0x81, 0x03, 0xef, 0xd7, 0x69, 0x01, + 0xb0, 0x98, 0x02, 0xb2, 0xff, 0x01, 0xb3, 0xc9, 0x01, 0xb4, 0x7a, 0xb6, + 0x66, 0xb7, 0x53, 0xb9, 0x01, 0xff, 0x42, 0x0c, 0x06, 0xac, 0x69, 0x01, + 0x02, 0x97, 0x02, 0x33, 0xa9, 0x27, 0x03, 0x54, 0x98, 0x17, 0xb5, 0x01, + 0xff, 0x43, 0x3e, 0x44, 0xe1, 0x69, 0x01, 0x42, 0x7b, 0x00, 0xb2, 0x69, + 0x01, 0xee, 0xe5, 0x69, 0x01, 0xf1, 0xe4, 0x69, 0x41, 0x45, 0x1e, 0x08, + 0xe3, 0x69, 0x01, 0x48, 0xff, 0xd0, 0xe2, 0x69, 0x41, 0x42, 0x27, 0x01, + 0x94, 0x69, 0x01, 0xf4, 0xae, 0x69, 0x41, 0x42, 0x42, 0x10, 0x97, 0x69, + 0x81, 0x08, 0xed, 0xbe, 0x69, 0x01, 0xf8, 0xdf, 0x69, 0x41, 0xf4, 0xcf, + 0x69, 0x41, 0x43, 0xdf, 0xf1, 0x9e, 0x69, 0x01, 0xb5, 0x01, 0xff, 0xe5, + 0xea, 0x69, 0x01, 0xef, 0x75, 0x69, 0x41, 0xa5, 0x06, 0x42, 0x14, 0x05, + 0x6a, 0x69, 0x41, 0xe5, 0xec, 0x69, 0x01, 0x43, 0x9c, 0x9a, 0x9d, 0x69, + 0x41, 0xa1, 0x34, 0xa5, 0x23, 0xaf, 0x14, 0xb5, 0x01, 0xff, 0x42, 0x42, + 0x10, 0x96, 0x69, 0x01, 0xed, 0xaa, 0x69, 0xc1, 0x00, 0x42, 0x42, 0x10, + 0x99, 0x69, 0x41, 0xef, 0x79, 0x69, 0x81, 0x04, 0xf1, 0xd6, 0x69, 0x41, + 0xee, 0x67, 0x69, 0x41, 0xee, 0x00, 0x6a, 0x01, 0xf5, 0xfd, 0x69, 0xc1, + 0x00, 0x43, 0x9d, 0x9a, 0x9c, 0x69, 0x41, 0xe1, 0xdb, 0x69, 0x81, 0x0e, + 0x48, 0x47, 0xcb, 0x8f, 0x69, 0x01, 0xed, 0x72, 0x69, 0x01, 0xf1, 0xdc, + 0x69, 0x41, 0xf1, 0xa1, 0x69, 0x41, 0x42, 0x4e, 0x13, 0x85, 0x69, 0x01, + 0xa5, 0x23, 0xa8, 0x0c, 0x42, 0x14, 0x05, 0x6d, 0x69, 0x01, 0x44, 0xc7, + 0xc6, 0x9b, 0x69, 0x41, 0x45, 0x9b, 0x9a, 0xa4, 0x69, 0x01, 0x42, 0x5a, + 0x0a, 0xde, 0x69, 0x01, 0xef, 0xf3, 0x69, 0xc1, 0x00, 0xf1, 0xf4, 0x69, + 0x41, 0xe5, 0x76, 0x69, 0x01, 0xf4, 0x90, 0x69, 0x41, 0xa1, 0x0c, 0x43, + 0xdf, 0xf1, 0xef, 0x69, 0x01, 0x45, 0x5f, 0xed, 0x82, 0x69, 0x41, 0xe5, + 0xf0, 0x69, 0x01, 0xf1, 0x6e, 0x69, 0x41, 0xa1, 0x47, 0xa5, 0x34, 0xe9, + 0xf7, 0x69, 0x81, 0x22, 0xef, 0x98, 0x69, 0x81, 0x17, 0xf5, 0xa0, 0x69, + 0xc1, 0x00, 0xa1, 0x08, 0xe5, 0xe9, 0x69, 0x01, 0xed, 0x91, 0x69, 0x41, + 0xe5, 0x71, 0x69, 0x01, 0xf1, 0xca, 0x69, 0x41, 0x42, 0x10, 0x00, 0xc2, + 0x69, 0x41, 0xa5, 0x01, 0xff, 0x42, 0x7b, 0x00, 0xb1, 0x69, 0x01, 0xf4, + 0xcd, 0x69, 0x41, 0x42, 0xb5, 0x05, 0x84, 0x69, 0x01, 0xb5, 0x01, 0xff, + 0xf4, 0xbd, 0x69, 0x01, 0xf8, 0xe7, 0x69, 0x41, 0x02, 0x9b, 0x01, 0x09, + 0xe1, 0x6c, 0x69, 0xc1, 0x00, 0xed, 0x78, 0x69, 0x41, 0x45, 0x01, 0xec, + 0xd1, 0x69, 0x01, 0x45, 0x36, 0xee, 0xda, 0x69, 0x41, 0xe1, 0xf6, 0x69, + 0x81, 0x86, 0x02, 0xa4, 0xdb, 0x01, 0xa7, 0x66, 0xaa, 0x4a, 0x43, 0x5c, + 0xd0, 0xa8, 0x69, 0x01, 0x02, 0xa4, 0x02, 0x2d, 0xb4, 0x1f, 0x03, 0xe3, + 0x7d, 0x0f, 0xba, 0x01, 0xff, 0x42, 0x8e, 0x38, 0xa7, 0x69, 0x01, 0x42, + 0x35, 0xa1, 0xc1, 0x69, 0x41, 0x47, 0xe5, 0x09, 0xc0, 0x69, 0x01, 0x47, + 0xb6, 0xd5, 0xad, 0x69, 0x41, 0x42, 0x0c, 0x06, 0xce, 0x69, 0x01, 0x42, + 0x48, 0x04, 0xbc, 0x69, 0x41, 0x43, 0x13, 0x93, 0x7c, 0x69, 0x01, 0xb5, + 0x01, 0xff, 0xe5, 0x81, 0x69, 0x01, 0x42, 0x1f, 0x00, 0x6f, 0x69, 0x41, + 0x45, 0x77, 0xd9, 0x8a, 0x69, 0x01, 0xa5, 0x01, 0xff, 0xe5, 0xd4, 0x69, + 0x81, 0x06, 0x42, 0x13, 0x9c, 0x83, 0x69, 0x41, 0x46, 0xf6, 0xdd, 0xe8, + 0x69, 0x41, 0xe1, 0xf2, 0x69, 0x01, 0x46, 0x74, 0xe1, 0xa3, 0x69, 0x01, + 0xa7, 0x3b, 0xab, 0x15, 0xaf, 0x0b, 0x43, 0x9c, 0x9a, 0xe0, 0x69, 0xc1, + 0x00, 0xf4, 0xf1, 0x69, 0x41, 0xf0, 0x7d, 0x69, 0x01, 0xf1, 0x80, 0x69, + 0x41, 0xe1, 0x73, 0x69, 0x81, 0x19, 0x02, 0x97, 0x02, 0x0b, 0xb5, 0x01, + 0xff, 0xed, 0xcb, 0x69, 0x01, 0xf0, 0xb6, 0x69, 0x41, 0x43, 0xcc, 0x8b, + 0x89, 0x69, 0x01, 0xf8, 0x7f, 0x69, 0x41, 0x43, 0x9d, 0x64, 0xb9, 0x69, + 0x41, 0xa5, 0x19, 0x42, 0x1f, 0x00, 0x7d, 0x69, 0x01, 0xb5, 0x01, 0xff, + 0x4b, 0xf3, 0x9d, 0x93, 0x69, 0x01, 0xf0, 0xd0, 0x69, 0x01, 0x43, 0x85, + 0x86, 0x86, 0x69, 0x41, 0x43, 0xc8, 0xae, 0x8d, 0x69, 0x01, 0x43, 0x9c, + 0x9a, 0xbf, 0x69, 0xc1, 0x00, 0xf4, 0x77, 0x69, 0x41, 0xa1, 0x12, 0xa9, + 0x06, 0x42, 0x79, 0x08, 0x70, 0x69, 0x41, 0x42, 0x8e, 0x38, 0xb0, 0x69, + 0x01, 0xf1, 0x8e, 0x69, 0x41, 0x02, 0x5a, 0x00, 0x04, 0xf0, 0x66, 0x69, + 0x41, 0x48, 0x0f, 0xce, 0xdd, 0x69, 0x01, 0x48, 0xd7, 0xd0, 0x92, 0x69, + 0x41, 0xe5, 0xc5, 0x69, 0x41, 0xe1, 0xfb, 0x69, 0x81, 0x45, 0x02, 0xb7, + 0x05, 0x37, 0x42, 0x92, 0x01, 0xfa, 0x69, 0x01, 0x44, 0xa8, 0xf5, 0xaf, + 0x69, 0x01, 0x02, 0xd0, 0x4a, 0x1d, 0xe9, 0xee, 0x69, 0x81, 0x12, 0x42, + 0x10, 0x00, 0xff, 0x69, 0x01, 0x43, 0x9c, 0x9a, 0xc6, 0x69, 0x01, 0x42, + 0x02, 0x00, 0xc9, 0x69, 0x41, 0x42, 0x27, 0x01, 0xc3, 0x69, 0x41, 0xe1, + 0x87, 0x69, 0x01, 0x42, 0x92, 0x01, 0xa5, 0x69, 0x41, 0xe5, 0xa6, 0x69, + 0x01, 0x42, 0x48, 0x04, 0x68, 0x69, 0x41, 0xe5, 0xb8, 0x69, 0x81, 0x08, + 0xf0, 0x8b, 0x69, 0x01, 0xf1, 0xfc, 0x69, 0x41, 0xed, 0x7e, 0x69, 0x41, + 0xa1, 0x1e, 0x45, 0x24, 0xec, 0xb3, 0x69, 0x01, 0xaf, 0x04, 0xf5, 0xed, + 0x69, 0x41, 0xed, 0x7b, 0x69, 0x01, 0xaf, 0x04, 0xf1, 0xf8, 0x69, 0x41, + 0xee, 0x6b, 0x69, 0x01, 0xf4, 0x8c, 0x69, 0x41, 0x42, 0x57, 0x00, 0x9f, + 0x69, 0x01, 0xf0, 0x69, 0x69, 0x01, 0xf1, 0xd9, 0x69, 0x41, 0xa5, 0x21, + 0xe9, 0xfe, 0x69, 0x01, 0xef, 0xf9, 0x69, 0x01, 0x44, 0x00, 0xf8, 0x74, + 0x69, 0x01, 0xb5, 0x01, 0xff, 0x42, 0x14, 0x06, 0xab, 0x69, 0x01, 0x42, + 0x1f, 0x00, 0x7a, 0x69, 0x01, 0xf4, 0xcc, 0x69, 0x41, 0xf4, 0xb7, 0x69, + 0x01, 0xb5, 0x01, 0xff, 0x42, 0x42, 0x10, 0x9a, 0x69, 0x01, 0xf8, 0xe6, + 0x69, 0x41, 0x02, 0xb7, 0x05, 0x26, 0xa8, 0x01, 0xff, 0x45, 0xfe, 0xe9, + 0xa2, 0x69, 0x01, 0xa5, 0x06, 0x42, 0x14, 0x05, 0x02, 0x6a, 0x41, 0xf4, + 0xba, 0x69, 0x01, 0xb5, 0x01, 0xff, 0x42, 0x42, 0x10, 0xc7, 0x69, 0x01, + 0xee, 0x95, 0x69, 0x01, 0xf8, 0x88, 0x69, 0x41, 0xf4, 0xa9, 0x69, 0x01, + 0x42, 0x13, 0x9c, 0xb5, 0x69, 0x41, 0xe1, 0xbb, 0x69, 0x81, 0x2a, 0x42, + 0x27, 0x01, 0xeb, 0x69, 0x01, 0x42, 0x14, 0x05, 0xd3, 0x69, 0x01, 0xb5, + 0x01, 0xff, 0x80, 0x09, 0xe5, 0xb4, 0x69, 0xc1, 0x00, 0xf4, 0xc4, 0x69, + 0x41, 0x44, 0x1b, 0x18, 0xd2, 0x69, 0x01, 0xe9, 0xc8, 0x69, 0x01, 0x46, + 0x7c, 0xe5, 0xf5, 0x69, 0x41, 0xf1, 0x01, 0x6a, 0x41, 0xa6, 0xea, 0x05, + 0x02, 0x40, 0x00, 0xd9, 0x05, 0xab, 0x9a, 0x05, 0xac, 0xec, 0x04, 0xed, + 0x51, 0x69, 0x81, 0xeb, 0x03, 0xae, 0xfb, 0x01, 0xb0, 0xd3, 0x01, 0xb2, + 0xb4, 0x01, 0xb3, 0x66, 0xb4, 0x30, 0xb7, 0x22, 0xb9, 0x01, 0xff, 0x46, + 0x6a, 0xdf, 0x05, 0x69, 0x01, 0x42, 0x92, 0x01, 0x0d, 0x69, 0x01, 0xb5, + 0x01, 0xff, 0xaf, 0x06, 0x43, 0xc3, 0xfa, 0x25, 0x69, 0x41, 0xed, 0x34, + 0x69, 0x01, 0xf0, 0x36, 0x69, 0x41, 0x42, 0x0c, 0x06, 0xf2, 0x68, 0x01, + 0x44, 0xc7, 0xc6, 0xfb, 0x68, 0x41, 0x42, 0x42, 0x10, 0x4b, 0x69, 0x01, + 0xa5, 0x15, 0xe9, 0x61, 0x69, 0x01, 0x42, 0x54, 0x98, 0x4c, 0x69, 0x01, + 0xf5, 0x11, 0x69, 0xc1, 0x00, 0x42, 0x1b, 0x05, 0x3d, 0x69, 0x41, 0x43, + 0xc8, 0xae, 0x28, 0x69, 0x01, 0xb5, 0x01, 0xff, 0x43, 0x3e, 0x44, 0x23, + 0x69, 0x01, 0xee, 0x41, 0x69, 0x01, 0xf4, 0x00, 0x69, 0x41, 0xa1, 0x42, + 0x45, 0x9b, 0x9a, 0x0c, 0x69, 0x01, 0xa8, 0x17, 0x42, 0x1b, 0x05, 0x24, + 0x69, 0x01, 0xb5, 0x01, 0xff, 0x42, 0x42, 0x10, 0x39, 0x69, 0x01, 0xe5, + 0x03, 0x69, 0x01, 0xf5, 0x52, 0x69, 0x41, 0xa5, 0x10, 0x42, 0xc0, 0x29, + 0x54, 0x69, 0x01, 0x42, 0x54, 0x98, 0x5c, 0x69, 0x01, 0xf5, 0x58, 0x69, + 0x41, 0xe5, 0xfd, 0x68, 0x01, 0xb5, 0x01, 0xff, 0x42, 0x42, 0x10, 0x01, + 0x69, 0x01, 0xf8, 0x55, 0x69, 0x41, 0xf0, 0x07, 0x69, 0x01, 0xf1, 0x64, + 0x69, 0x41, 0x43, 0xcc, 0x8b, 0x27, 0x69, 0x01, 0x03, 0xb1, 0x01, 0x06, + 0x42, 0xc0, 0x29, 0x4e, 0x69, 0x41, 0x44, 0xc7, 0xee, 0x60, 0x69, 0x01, + 0x43, 0x03, 0x1c, 0x4a, 0x69, 0x41, 0x42, 0x0c, 0x06, 0x35, 0x69, 0x01, + 0xa5, 0x13, 0x42, 0xba, 0x04, 0x2d, 0x69, 0x01, 0xb5, 0x01, 0xff, 0xf1, + 0x5d, 0x69, 0x01, 0x42, 0x29, 0x08, 0x1b, 0x69, 0x41, 0xe5, 0x5a, 0x69, + 0x01, 0x44, 0xe4, 0xf8, 0x2e, 0x69, 0x41, 0xa4, 0xd2, 0x01, 0xa7, 0x7e, + 0xe9, 0x5b, 0x69, 0x01, 0xaa, 0x53, 0xb3, 0x31, 0xb4, 0x1d, 0xf5, 0x57, + 0x69, 0x01, 0xb9, 0x01, 0xff, 0x42, 0x57, 0x00, 0xfa, 0x68, 0x01, 0x42, + 0x14, 0x06, 0x22, 0x69, 0x01, 0xe9, 0x4d, 0x69, 0x01, 0x42, 0x5c, 0x0a, + 0x2f, 0x69, 0x41, 0xa5, 0x06, 0x42, 0x5a, 0x77, 0x62, 0x69, 0x41, 0xe5, + 0x59, 0x69, 0x01, 0x42, 0x48, 0x04, 0x38, 0x69, 0x41, 0xa8, 0x12, 0x03, + 0x13, 0x93, 0x06, 0x42, 0x48, 0x04, 0x40, 0x69, 0x41, 0xf0, 0x1f, 0x69, + 0x01, 0xf4, 0x2b, 0x69, 0x41, 0x42, 0x27, 0x01, 0xf8, 0x68, 0x01, 0x42, + 0x29, 0x08, 0x46, 0x69, 0x41, 0x42, 0x0c, 0x06, 0x02, 0x69, 0x01, 0x02, + 0x97, 0x02, 0x11, 0xe9, 0xf3, 0x68, 0x81, 0x06, 0x43, 0x0d, 0xf9, 0x47, + 0x69, 0x41, 0x42, 0x27, 0x01, 0xf5, 0x68, 0x41, 0x43, 0xcc, 0x8b, 0x0e, + 0x69, 0x01, 0xf4, 0xf7, 0x68, 0x41, 0xa7, 0x2b, 0xab, 0x01, 0xff, 0x42, + 0x0c, 0x06, 0xfe, 0x68, 0x01, 0x02, 0x97, 0x02, 0x12, 0x43, 0x13, 0x93, + 0x3c, 0x69, 0x01, 0x42, 0x79, 0x08, 0xfc, 0x68, 0x01, 0x43, 0x22, 0xaf, + 0x13, 0x69, 0x41, 0x43, 0x9d, 0x9a, 0x29, 0x69, 0x01, 0x42, 0x0d, 0x00, + 0x10, 0x69, 0x41, 0xa1, 0x12, 0x43, 0xdf, 0xf1, 0x3b, 0x69, 0x01, 0x43, + 0x1f, 0xd3, 0x45, 0x69, 0x01, 0x44, 0x8b, 0xdd, 0x33, 0x69, 0x41, 0x42, + 0x57, 0x00, 0x31, 0x69, 0x81, 0x04, 0xf0, 0x43, 0x69, 0x41, 0x42, 0x42, + 0x10, 0xf9, 0x68, 0x41, 0x42, 0x57, 0x00, 0x37, 0x69, 0x01, 0xa5, 0x06, + 0x42, 0x10, 0x00, 0x18, 0x69, 0x41, 0xe5, 0x15, 0x69, 0x01, 0x42, 0x13, + 0x9c, 0x09, 0x69, 0x41, 0xa1, 0x6d, 0xa2, 0x58, 0xa5, 0x45, 0xa6, 0x26, + 0x02, 0xd0, 0x4a, 0x10, 0x43, 0x49, 0x07, 0x19, 0x69, 0x01, 0xf5, 0x53, + 0x69, 0x01, 0x43, 0xe7, 0xb1, 0x5e, 0x69, 0x41, 0x43, 0x27, 0x6c, 0x1a, + 0x69, 0x01, 0x43, 0x13, 0x93, 0x1c, 0x69, 0x01, 0x44, 0xb8, 0xf7, 0x16, + 0x69, 0x41, 0x02, 0x97, 0x02, 0x0f, 0x43, 0x13, 0x93, 0x32, 0x69, 0x01, + 0xef, 0x1d, 0x69, 0xc1, 0x00, 0xee, 0xf4, 0x68, 0x41, 0x42, 0x42, 0x10, + 0x2a, 0x69, 0x01, 0xf4, 0x08, 0x69, 0x41, 0x43, 0xc8, 0xae, 0x50, 0x69, + 0x01, 0xb5, 0x01, 0xff, 0xee, 0x3e, 0x69, 0x01, 0xf4, 0x0b, 0x69, 0x41, + 0x42, 0x4e, 0x13, 0x20, 0x69, 0x81, 0x06, 0x42, 0x1a, 0x05, 0xf1, 0x68, + 0x41, 0x46, 0x04, 0x1f, 0x63, 0x69, 0x41, 0x45, 0xf7, 0xeb, 0x42, 0x69, + 0x01, 0x45, 0x04, 0xec, 0x0a, 0x69, 0x41, 0xa5, 0x12, 0x43, 0x13, 0x93, + 0xf6, 0x68, 0x01, 0x42, 0x54, 0x98, 0x5f, 0x69, 0x01, 0x42, 0x48, 0x04, + 0x1e, 0x69, 0x41, 0x43, 0xc8, 0xae, 0x4f, 0x69, 0x01, 0xf4, 0x30, 0x69, + 0x01, 0xb5, 0x01, 0xff, 0x43, 0x43, 0xe1, 0x17, 0x69, 0x01, 0xed, 0x44, + 0x69, 0x41, 0xa5, 0x1f, 0xf5, 0x49, 0x69, 0x81, 0x0c, 0x44, 0x14, 0xf9, + 0x21, 0x69, 0x01, 0x43, 0x22, 0xaf, 0x56, 0x69, 0x41, 0xee, 0x3a, 0x69, + 0x01, 0x42, 0x14, 0x05, 0x06, 0x69, 0x01, 0xf1, 0x3f, 0x69, 0x41, 0xf4, + 0x04, 0x69, 0x01, 0xb5, 0x01, 0xff, 0x47, 0x58, 0xd4, 0xff, 0x68, 0x01, + 0xed, 0x26, 0x69, 0x01, 0x48, 0x27, 0xcf, 0x0f, 0x69, 0x01, 0xf0, 0x2c, + 0x69, 0x41, 0x42, 0x4e, 0x13, 0x12, 0x69, 0x01, 0x44, 0x9b, 0x9a, 0x48, + 0x69, 0x41, 0x42, 0x4e, 0x13, 0x65, 0x69, 0x01, 0x48, 0xa7, 0xcb, 0x14, + 0x69, 0x41, 0x44, 0x30, 0xf5, 0xc0, 0x68, 0x01, 0x43, 0x42, 0xfa, 0xbc, + 0x68, 0x01, 0xa7, 0xfb, 0x04, 0xab, 0xad, 0x04, 0xac, 0x96, 0x04, 0xad, + 0x93, 0x03, 0xae, 0xa9, 0x01, 0xb0, 0x93, 0x01, 0x42, 0x3d, 0x00, 0xc3, + 0x68, 0x01, 0xb3, 0x63, 0xb4, 0x3e, 0x03, 0x98, 0x61, 0x30, 0xb7, 0x22, + 0xb9, 0x01, 0xff, 0x42, 0x4e, 0x13, 0xd9, 0x68, 0x01, 0x43, 0x34, 0xa1, + 0xa7, 0x68, 0x01, 0xb5, 0x01, 0xff, 0x47, 0x1d, 0xd3, 0xa2, 0x68, 0x01, + 0xed, 0x91, 0x68, 0x01, 0x43, 0xc3, 0xfa, 0xe4, 0x68, 0x41, 0x47, 0x97, + 0xd4, 0x92, 0x68, 0x01, 0x42, 0x50, 0x02, 0xd1, 0x68, 0x41, 0x45, 0x17, + 0xea, 0xc1, 0x68, 0x01, 0xf8, 0xb1, 0x68, 0x41, 0x46, 0x5e, 0xdf, 0xac, + 0x68, 0x01, 0xa5, 0x11, 0x02, 0x52, 0x00, 0x01, 0xff, 0x45, 0xf4, 0xe9, + 0xae, 0x68, 0x01, 0x44, 0x6c, 0xe2, 0xc6, 0x68, 0x41, 0xf4, 0xf0, 0x68, + 0x01, 0x45, 0xdd, 0xf1, 0xba, 0x68, 0x41, 0xa5, 0x1a, 0xa8, 0x06, 0x44, + 0xb2, 0xb3, 0xaf, 0x68, 0x41, 0x45, 0x1f, 0xec, 0xdc, 0x68, 0x01, 0x42, + 0x5a, 0x0a, 0xe8, 0x68, 0x01, 0x43, 0x0d, 0xf9, 0xdb, 0x68, 0x41, 0x44, + 0x20, 0xec, 0xdc, 0x68, 0x01, 0x42, 0x13, 0x9c, 0xaa, 0x68, 0x41, 0x42, + 0x92, 0x01, 0xef, 0x68, 0x01, 0xa9, 0x01, 0xff, 0xee, 0xee, 0x68, 0x01, + 0x45, 0x4d, 0xf0, 0x9c, 0x68, 0x41, 0xa1, 0xda, 0x01, 0xa4, 0xb3, 0x01, + 0xa7, 0x74, 0xaa, 0x52, 0xb3, 0x2d, 0xb4, 0x13, 0x50, 0x1a, 0x6c, 0x99, + 0x68, 0x01, 0xba, 0x01, 0xff, 0xe1, 0x90, 0x68, 0x01, 0x43, 0x6f, 0x5a, + 0xa3, 0x68, 0x41, 0x42, 0x4e, 0x13, 0xb4, 0x68, 0x01, 0xa5, 0x06, 0x46, + 0xc6, 0xe6, 0x9a, 0x68, 0x41, 0xee, 0xd4, 0x68, 0x01, 0x45, 0xb5, 0xf1, + 0xb9, 0x68, 0x41, 0xe1, 0xbe, 0x68, 0x01, 0x45, 0xc6, 0xc6, 0xa5, 0x68, + 0x01, 0x43, 0x45, 0xfa, 0xbf, 0x68, 0x01, 0x42, 0x14, 0x05, 0xd3, 0x68, + 0x01, 0xb5, 0x01, 0xff, 0xee, 0xd6, 0x68, 0x01, 0x47, 0x08, 0xda, 0xc7, + 0x68, 0x41, 0xa1, 0x14, 0xa5, 0x06, 0x43, 0x0d, 0xf9, 0xad, 0x68, 0x41, + 0x43, 0xc8, 0xae, 0xc8, 0x68, 0x01, 0x42, 0x13, 0x9c, 0xe5, 0x68, 0x41, + 0x42, 0xb5, 0x05, 0xc4, 0x68, 0x01, 0xed, 0xcf, 0x68, 0x41, 0x42, 0x8e, + 0x38, 0xeb, 0x68, 0x01, 0xa7, 0x14, 0xab, 0x06, 0x42, 0x14, 0x05, 0xd0, + 0x68, 0x41, 0x42, 0x8e, 0x38, 0x95, 0x68, 0x01, 0x49, 0x08, 0xc6, 0x8f, + 0x68, 0x41, 0x42, 0x92, 0x01, 0x93, 0x68, 0x01, 0xf5, 0xca, 0x68, 0xc1, + 0x00, 0x48, 0xdf, 0xc8, 0xb0, 0x68, 0x01, 0x43, 0xbe, 0x11, 0xd2, 0x68, + 0x01, 0xed, 0xbb, 0x68, 0x01, 0x42, 0x10, 0x00, 0xb5, 0x68, 0x41, 0xa1, + 0x1a, 0x02, 0x97, 0x02, 0x0c, 0x43, 0x20, 0x9a, 0xab, 0x68, 0x01, 0x44, + 0x49, 0xd8, 0x9d, 0x68, 0x41, 0x45, 0x1c, 0xea, 0x94, 0x68, 0x01, 0xf4, + 0xbd, 0x68, 0x41, 0xed, 0xd7, 0x68, 0x01, 0xf0, 0xda, 0x68, 0x41, 0x46, + 0x74, 0xe4, 0xb2, 0x68, 0x01, 0xf1, 0xec, 0x68, 0x41, 0xa1, 0x61, 0xa2, + 0x12, 0x46, 0xd4, 0xe1, 0xb8, 0x68, 0x01, 0x43, 0x13, 0x93, 0xe6, 0x68, + 0x01, 0x43, 0x9c, 0x9a, 0xe7, 0x68, 0x41, 0xa1, 0x35, 0xa5, 0x1c, 0xe9, + 0xdd, 0x68, 0x81, 0x0d, 0xb5, 0x01, 0xff, 0x43, 0xcc, 0x8b, 0xcc, 0x68, + 0x01, 0xe5, 0xa4, 0x68, 0x41, 0x45, 0x4d, 0xf0, 0xb7, 0x68, 0x01, 0xf4, + 0xa6, 0x68, 0x41, 0x45, 0xd4, 0xeb, 0x97, 0x68, 0x01, 0x43, 0x85, 0x86, + 0xc2, 0x68, 0x01, 0xb5, 0x01, 0xff, 0xed, 0x9b, 0x68, 0x01, 0xf8, 0xe1, + 0x68, 0x41, 0x02, 0x5a, 0x00, 0x06, 0x43, 0x9f, 0x1b, 0xdf, 0x68, 0x41, + 0x4c, 0xc4, 0x91, 0x9e, 0x68, 0x01, 0x46, 0x16, 0xe5, 0xe3, 0x68, 0x41, + 0x80, 0x0f, 0xa5, 0x01, 0xff, 0x43, 0x70, 0xa4, 0xde, 0x68, 0x01, 0x42, + 0x5a, 0x03, 0xcb, 0x68, 0x41, 0x47, 0x33, 0xd8, 0xb3, 0x68, 0x01, 0x45, + 0x26, 0xef, 0xd8, 0x68, 0x41, 0xa1, 0x0a, 0x42, 0x5a, 0x0a, 0xed, 0x68, + 0x01, 0xf5, 0xcd, 0x68, 0x41, 0xed, 0xc5, 0x68, 0x01, 0xf0, 0xb6, 0x68, + 0x41, 0x42, 0x4e, 0x13, 0xa9, 0x68, 0x01, 0xa5, 0x13, 0x45, 0x20, 0x6c, + 0xa8, 0x68, 0x01, 0xb5, 0x01, 0xff, 0x4a, 0x7e, 0xb4, 0xd5, 0x68, 0x01, + 0xf4, 0xce, 0x68, 0x41, 0x02, 0x92, 0x00, 0x20, 0xf4, 0xc9, 0x68, 0x01, + 0xb5, 0x01, 0xff, 0x43, 0x5d, 0xfa, 0xa1, 0x68, 0x01, 0xed, 0xe2, 0x68, + 0x01, 0xb3, 0x01, 0xff, 0x43, 0xdf, 0xf1, 0xe0, 0x68, 0x01, 0x46, 0x6a, + 0xe2, 0x9f, 0x68, 0x41, 0x47, 0xdc, 0xd6, 0xea, 0x68, 0x01, 0x43, 0x5f, + 0xda, 0xe9, 0x68, 0x41, 0x44, 0x14, 0xf5, 0x98, 0x68, 0x01, 0x02, 0x22, + 0x00, 0x01, 0xff, 0xf0, 0xa0, 0x68, 0x01, 0x43, 0x85, 0x86, 0x96, 0x68, + 0x41, 0x02, 0x2e, 0x1b, 0x93, 0x03, 0x07, 0x14, 0xd7, 0x84, 0x03, 0xab, + 0xd8, 0x02, 0xac, 0xbb, 0x02, 0xad, 0xde, 0x01, 0xae, 0x83, 0x01, 0xb0, + 0x5e, 0xb3, 0x34, 0xb4, 0x1b, 0x44, 0xf4, 0xf8, 0x73, 0x68, 0x01, 0x45, + 0x50, 0xf2, 0x76, 0x68, 0x01, 0xb9, 0x01, 0xff, 0x4c, 0xb0, 0x90, 0x62, + 0x68, 0x01, 0x45, 0x29, 0xec, 0x5e, 0x68, 0x41, 0x43, 0xfb, 0x8d, 0x78, + 0x68, 0x01, 0x02, 0x2e, 0x02, 0x01, 0xff, 0x49, 0x91, 0xc1, 0x58, 0x68, + 0x01, 0x45, 0x26, 0xef, 0x68, 0x68, 0x41, 0x46, 0x32, 0xd8, 0x77, 0x68, + 0x01, 0x45, 0x1a, 0xec, 0x5a, 0x68, 0x01, 0x02, 0xb0, 0x01, 0x0c, 0x43, + 0x13, 0x93, 0x59, 0x68, 0x01, 0x42, 0x5c, 0x0a, 0x7d, 0x68, 0x41, 0x46, + 0x54, 0xe6, 0x69, 0x68, 0x01, 0x46, 0xcc, 0xe6, 0x6a, 0x68, 0x41, 0x44, + 0xfc, 0xf4, 0x72, 0x68, 0x01, 0x45, 0xb6, 0xeb, 0x61, 0x68, 0x01, 0x42, + 0x52, 0x00, 0x67, 0x68, 0x01, 0x03, 0xe1, 0x47, 0x01, 0xff, 0x43, 0xfb, + 0x8d, 0x81, 0x68, 0x01, 0x44, 0xc0, 0xf5, 0x81, 0x68, 0x41, 0x47, 0x3b, + 0xd6, 0x65, 0x68, 0x01, 0xa7, 0x23, 0xb3, 0x15, 0x4b, 0xd2, 0xa8, 0x64, + 0x68, 0x01, 0xb9, 0x01, 0xff, 0x45, 0x12, 0xea, 0x80, 0x68, 0x01, 0x47, + 0x84, 0xd7, 0x6d, 0x68, 0x41, 0x42, 0x92, 0x01, 0x8b, 0x68, 0x01, 0x44, + 0xa7, 0xd6, 0x57, 0x68, 0x41, 0xa7, 0x0c, 0x4a, 0xe0, 0xb1, 0x74, 0x68, + 0x01, 0x42, 0x14, 0x05, 0x8e, 0x68, 0x41, 0x43, 0xfb, 0x8d, 0x8a, 0x68, + 0x01, 0x46, 0x62, 0xe1, 0x75, 0x68, 0x01, 0x42, 0x14, 0x05, 0x8e, 0x68, + 0x01, 0x43, 0xda, 0xa8, 0x7a, 0x68, 0xc1, 0x00, 0x46, 0xd3, 0x1d, 0x7b, + 0x68, 0x41, 0xe1, 0x8c, 0x68, 0x81, 0x44, 0xa2, 0x22, 0x02, 0x97, 0x02, + 0x14, 0xa6, 0x06, 0x47, 0xde, 0xd9, 0x7f, 0x68, 0x41, 0x44, 0x8c, 0x38, + 0x7c, 0x68, 0x01, 0x49, 0xd5, 0xc2, 0x6b, 0x68, 0x41, 0xf1, 0x79, 0x68, + 0x01, 0x48, 0x07, 0xd1, 0x82, 0x68, 0x41, 0xa1, 0x12, 0x44, 0xd2, 0xf1, + 0x7e, 0x68, 0x01, 0x4a, 0x90, 0xb1, 0x6c, 0x68, 0x01, 0x43, 0xda, 0xa8, + 0x84, 0x68, 0x41, 0x47, 0x08, 0xd3, 0x5c, 0x68, 0x01, 0x44, 0x84, 0x86, + 0x5f, 0x68, 0x41, 0x03, 0xc4, 0x8b, 0x01, 0xff, 0x46, 0x68, 0xe1, 0x87, + 0x68, 0x01, 0x43, 0xb1, 0xfa, 0x88, 0x68, 0x41, 0xa1, 0x0c, 0x42, 0x14, + 0x06, 0x89, 0x68, 0x01, 0x48, 0xd7, 0xce, 0x5b, 0x68, 0x41, 0x44, 0xe8, + 0xf4, 0x71, 0x68, 0x01, 0x4c, 0x74, 0x96, 0x63, 0x68, 0x41, 0x42, 0x57, + 0x00, 0x60, 0x68, 0x01, 0x02, 0x97, 0x02, 0x0d, 0xa9, 0x01, 0xff, 0x43, + 0x51, 0x19, 0x5d, 0x68, 0x01, 0xf1, 0x8d, 0x68, 0x41, 0x43, 0xcc, 0x8b, + 0x86, 0x68, 0x01, 0x43, 0x7e, 0xfa, 0x6e, 0x68, 0x01, 0x44, 0x3c, 0xf9, + 0x70, 0x68, 0x41, 0xee, 0x6f, 0x68, 0x01, 0x44, 0x25, 0xec, 0x66, 0x68, + 0x41, 0xe5, 0x85, 0x68, 0x01, 0x42, 0x13, 0x9c, 0x83, 0x68, 0x41, 0x44, + 0xb0, 0xf5, 0x39, 0x68, 0x01, 0xa7, 0xcc, 0x04, 0xab, 0xa5, 0x04, 0xac, + 0x85, 0x04, 0xad, 0x8a, 0x03, 0xae, 0xdc, 0x01, 0xb0, 0x88, 0x01, 0x43, + 0xab, 0x05, 0x3a, 0x68, 0x01, 0xb3, 0x3b, 0xb4, 0x14, 0xb5, 0x06, 0x43, + 0xfd, 0x06, 0x52, 0x68, 0x41, 0x48, 0x67, 0xc8, 0x20, 0x68, 0x01, 0x46, + 0x56, 0xe4, 0x44, 0x68, 0x41, 0x02, 0x97, 0x02, 0x15, 0x48, 0xf7, 0xcc, + 0x06, 0x68, 0x01, 0xb5, 0x01, 0xff, 0x47, 0x0a, 0xc6, 0x0c, 0x68, 0x01, + 0x43, 0x43, 0xe1, 0x2e, 0x68, 0x41, 0x43, 0x3e, 0x44, 0x4a, 0x68, 0x01, + 0x46, 0x90, 0xe6, 0x31, 0x68, 0x41, 0x46, 0x6e, 0xe1, 0x11, 0x68, 0x01, + 0xa8, 0x1c, 0x43, 0x50, 0x4c, 0x23, 0x68, 0x01, 0xaf, 0x06, 0x42, 0x5a, + 0x77, 0x15, 0x68, 0x41, 0x44, 0x74, 0xf7, 0x30, 0x68, 0x01, 0xf1, 0x3c, + 0x68, 0x01, 0xf4, 0x4b, 0x68, 0x41, 0xa9, 0x13, 0x4c, 0x54, 0x98, 0x40, + 0x68, 0x01, 0xb5, 0x01, 0xff, 0x47, 0xa4, 0xd6, 0x05, 0x68, 0x01, 0xed, + 0x37, 0x68, 0x41, 0x4a, 0xd4, 0xb3, 0x08, 0x68, 0x01, 0x43, 0x85, 0x86, + 0x3e, 0x68, 0x41, 0xa1, 0x31, 0x42, 0x14, 0x06, 0x2a, 0x68, 0x01, 0x03, + 0xb6, 0x00, 0x06, 0x42, 0x50, 0x02, 0x2d, 0x68, 0x41, 0x0b, 0x9c, 0xa4, + 0x11, 0x0d, 0xc2, 0x8b, 0x01, 0xff, 0x42, 0x16, 0x00, 0x0a, 0x68, 0x01, + 0x45, 0x95, 0xc1, 0x09, 0x68, 0x41, 0x42, 0x16, 0x00, 0x03, 0x68, 0x01, + 0x45, 0x95, 0xc1, 0x02, 0x68, 0x41, 0x49, 0xb3, 0x90, 0x28, 0x68, 0x01, + 0xa1, 0x0c, 0x45, 0xc2, 0xee, 0x1d, 0x68, 0x01, 0x44, 0xf5, 0x9d, 0x1b, + 0x68, 0x41, 0xed, 0x4c, 0x68, 0x01, 0x43, 0x85, 0x86, 0x42, 0x68, 0x41, + 0xa1, 0x9e, 0x01, 0x02, 0x7b, 0x08, 0x8d, 0x01, 0x42, 0x92, 0x01, 0x54, + 0x68, 0x01, 0xa7, 0x68, 0x43, 0xe0, 0x45, 0x2c, 0x68, 0x01, 0x43, 0x75, + 0xf7, 0x47, 0x68, 0x01, 0xab, 0x4e, 0x02, 0xa4, 0x02, 0x40, 0xb4, 0x22, + 0xb9, 0x0f, 0xba, 0x01, 0xff, 0x46, 0xf9, 0xcc, 0x07, 0x68, 0x01, 0x47, + 0xb6, 0xdc, 0x1f, 0x68, 0x41, 0x42, 0x14, 0x06, 0x49, 0x68, 0x01, 0xe9, + 0x4f, 0x68, 0xc1, 0x00, 0x4c, 0x94, 0x9a, 0x41, 0x68, 0x41, 0x42, 0x0c, + 0x06, 0x3f, 0x68, 0x81, 0x06, 0x45, 0x8f, 0xef, 0x12, 0x68, 0x41, 0x80, + 0x01, 0xff, 0x44, 0x1c, 0xf7, 0x19, 0x68, 0x01, 0x44, 0x90, 0xf7, 0x22, + 0x68, 0x41, 0xe1, 0x51, 0x68, 0x01, 0x43, 0x13, 0x93, 0x4d, 0x68, 0x41, + 0x45, 0x83, 0xb4, 0x43, 0x68, 0x01, 0x44, 0xe9, 0x06, 0x14, 0x68, 0x41, + 0x44, 0x1c, 0x01, 0x0d, 0x68, 0x01, 0x43, 0xc1, 0x5c, 0x45, 0x68, 0x01, + 0x03, 0x60, 0xfa, 0x01, 0xff, 0x45, 0xfa, 0xcc, 0x00, 0x68, 0x01, 0x45, + 0x44, 0xef, 0x16, 0x68, 0x41, 0x49, 0xb3, 0x90, 0x29, 0x68, 0x01, 0x49, + 0xa0, 0xbb, 0x34, 0x68, 0x41, 0x46, 0xf9, 0xcc, 0x04, 0x68, 0x01, 0xf1, + 0x55, 0x68, 0x41, 0xa1, 0x39, 0x02, 0x16, 0x00, 0x2b, 0x4b, 0x2c, 0xa1, + 0x25, 0x68, 0x01, 0x45, 0xd4, 0xe1, 0x24, 0x68, 0x01, 0xaf, 0x06, 0x49, + 0xc5, 0xc6, 0x10, 0x68, 0x41, 0x4a, 0xac, 0xb3, 0x1e, 0x68, 0x01, 0x02, + 0x14, 0x05, 0x01, 0xff, 0x43, 0x02, 0x93, 0x36, 0x68, 0x01, 0x43, 0x7e, + 0xfa, 0x26, 0x68, 0x41, 0x43, 0x9f, 0x1b, 0x48, 0x68, 0x01, 0xf1, 0x56, + 0x68, 0x41, 0xa5, 0x0c, 0x45, 0x2b, 0xef, 0x0f, 0x68, 0x01, 0x47, 0x55, + 0xda, 0x3d, 0x68, 0x41, 0x44, 0xb8, 0xf6, 0x1a, 0x68, 0x01, 0xed, 0x4e, + 0x68, 0x81, 0x0c, 0x43, 0x9f, 0x1b, 0x32, 0x68, 0x01, 0x42, 0x5a, 0x03, + 0x46, 0x68, 0x41, 0x46, 0x12, 0xe0, 0x0b, 0x68, 0x01, 0x45, 0x95, 0xc1, + 0x0b, 0x68, 0x01, 0x44, 0xf3, 0x74, 0x2b, 0x68, 0x01, 0x44, 0xf8, 0xf8, + 0x0e, 0x68, 0x41, 0x44, 0xec, 0xf4, 0x17, 0x68, 0x01, 0x46, 0x5c, 0xe1, + 0x18, 0x68, 0x01, 0x45, 0x85, 0xef, 0x38, 0x68, 0x01, 0xf5, 0x53, 0x68, + 0xc1, 0x00, 0x43, 0x43, 0xe1, 0x2f, 0x68, 0x41, 0xa1, 0x18, 0xa5, 0x0c, + 0x43, 0x7b, 0xfa, 0x3b, 0x68, 0x01, 0x43, 0xda, 0xa8, 0x35, 0x68, 0x41, + 0xf4, 0x33, 0x68, 0x01, 0x48, 0xbf, 0xd1, 0x13, 0x68, 0x41, 0x42, 0x0c, + 0x08, 0x27, 0x68, 0x01, 0xf1, 0x50, 0x68, 0x41, 0x48, 0xbf, 0xc9, 0x01, + 0x68, 0x01, 0x05, 0xf9, 0xe1, 0x01, 0xff, 0x46, 0xf8, 0xe1, 0x21, 0x68, + 0x01, 0x43, 0x85, 0x86, 0x1c, 0x68, 0x41, 0xe5, 0xca, 0xa6, 0x00, 0x42, + 0x13, 0x9c, 0xc5, 0xa6, 0x40, 0xe1, 0xdb, 0xa6, 0x00, 0x43, 0x37, 0x5a, + 0xb1, 0xa6, 0x00, 0xa7, 0x3d, 0xe9, 0xcf, 0xa6, 0x00, 0xaa, 0x25, 0x43, + 0xa4, 0x02, 0xc3, 0xa6, 0x00, 0xb4, 0x11, 0xf5, 0xbd, 0xa6, 0x80, 0x06, + 0x42, 0xa0, 0x1b, 0xa8, 0xa6, 0x40, 0x42, 0x42, 0x10, 0xbc, 0xa6, 0x40, + 0x42, 0x27, 0x01, 0xc7, 0xa6, 0x00, 0x42, 0x5a, 0x77, 0xeb, 0xa6, 0x40, + 0x43, 0xcc, 0x8b, 0xb2, 0xa6, 0x00, 0x42, 0x27, 0x01, 0xc6, 0xa6, 0x00, + 0x43, 0x9c, 0x9a, 0xbe, 0xa6, 0x40, 0xe1, 0xd5, 0xa6, 0x00, 0x42, 0x24, + 0x02, 0xd4, 0xa6, 0x00, 0x45, 0xeb, 0xed, 0xd3, 0xa6, 0x40, 0xe1, 0xe3, + 0xa6, 0x00, 0xa2, 0x18, 0xa5, 0x0c, 0xe9, 0xce, 0xa6, 0x00, 0xef, 0xe6, + 0xa6, 0x00, 0xf5, 0xb5, 0xa6, 0x40, 0x43, 0xc8, 0xae, 0xaf, 0xa6, 0x00, + 0xee, 0xe2, 0xa6, 0x40, 0x42, 0x4e, 0x13, 0xe7, 0xa6, 0x00, 0x42, 0x92, + 0x01, 0xe0, 0xa6, 0x40, 0xe1, 0xaa, 0xa6, 0x00, 0x44, 0x7c, 0xf5, 0xae, + 0xa6, 0x00, 0xe9, 0xdc, 0xa6, 0x00, 0x42, 0x54, 0x98, 0xde, 0xa6, 0x00, + 0xf5, 0xcd, 0xa6, 0x40, 0xe1, 0xa1, 0xa6, 0x00, 0xa5, 0x25, 0xe9, 0xe5, + 0xa6, 0x00, 0xef, 0xdf, 0xa6, 0x80, 0x10, 0x42, 0xe0, 0x09, 0xe9, 0xa6, + 0x00, 0xf5, 0xa3, 0xa6, 0x00, 0x43, 0x22, 0xaf, 0xba, 0xa6, 0x40, 0x44, + 0xd4, 0xf5, 0xef, 0xa6, 0x00, 0x43, 0xc0, 0xfa, 0xee, 0xa6, 0x40, 0xee, + 0xd2, 0xa6, 0x00, 0xf4, 0xbb, 0xa6, 0x00, 0x42, 0x13, 0x9c, 0xc4, 0xa6, + 0x40, 0x45, 0xfe, 0xe9, 0xed, 0xa6, 0x00, 0x42, 0x27, 0x01, 0xcb, 0xa6, + 0x00, 0x42, 0x14, 0x05, 0xd9, 0xa6, 0x00, 0xf5, 0xd8, 0xa6, 0x40, 0x43, + 0xd7, 0x02, 0xf4, 0xa6, 0x00, 0xad, 0x01, 0xff, 0x0c, 0x64, 0x91, 0x06, + 0x42, 0x6c, 0x00, 0xf5, 0xa6, 0x40, 0x47, 0x4f, 0xd8, 0xf0, 0xa6, 0x00, + 0x49, 0xed, 0xc5, 0xf1, 0xa6, 0x40, 0x06, 0xda, 0x87, 0x71, 0xac, 0x01, + 0xff, 0x48, 0xe7, 0xc7, 0xf6, 0xf9, 0x01, 0x48, 0x8f, 0xcb, 0x70, 0xfa, + 0x01, 0xaf, 0x01, 0xff, 0x42, 0x10, 0x00, 0x88, 0xf3, 0x81, 0x52, 0x02, + 0xc6, 0x00, 0x01, 0xff, 0x02, 0x5d, 0x00, 0x0a, 0x48, 0x97, 0xa3, 0xf4, + 0xf5, 0x01, 0xf8, 0x17, 0x27, 0x40, 0x4b, 0x94, 0xa3, 0xf6, 0xf5, 0x01, + 0xf8, 0x10, 0x26, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0xa2, 0x16, + 0x45, 0x3b, 0x15, 0x11, 0x26, 0x00, 0x47, 0xc6, 0xd8, 0xbd, 0x2b, 0x00, + 0x48, 0x97, 0xa3, 0xf5, 0xf5, 0x01, 0xf8, 0x12, 0x26, 0x40, 0x45, 0x6d, + 0xd4, 0xf3, 0xf5, 0x01, 0x04, 0x9c, 0x26, 0x01, 0xff, 0x45, 0x3b, 0x15, + 0xf9, 0xf5, 0x01, 0x48, 0x97, 0xa3, 0xf7, 0xf5, 0x41, 0x50, 0xf6, 0x1d, + 0x49, 0x27, 0x40, 0x49, 0x2b, 0xbb, 0x44, 0x1b, 0x00, 0x06, 0xf1, 0x71, + 0x85, 0x07, 0x06, 0xef, 0x06, 0xbe, 0x06, 0x0f, 0xe8, 0x71, 0xad, 0x06, + 0x07, 0x13, 0x06, 0xaa, 0x03, 0x0f, 0xf2, 0x33, 0xcd, 0x01, 0x02, 0xe0, + 0x09, 0x9d, 0x01, 0x05, 0x5a, 0x03, 0x70, 0x0b, 0xc7, 0x7a, 0x06, 0x45, + 0x3c, 0xf2, 0x5c, 0x1b, 0x40, 0x48, 0x3f, 0xcd, 0x3c, 0x1b, 0x80, 0x59, + 0x45, 0xd5, 0xef, 0x42, 0x1b, 0x80, 0x4c, 0x47, 0xfd, 0xda, 0x3a, 0x1b, + 0x80, 0x3f, 0x44, 0xf9, 0xdb, 0x38, 0x1b, 0x80, 0x32, 0xb4, 0x0d, 0x43, + 0xa5, 0x9c, 0x36, 0x1b, 0xc0, 0x00, 0x45, 0xdd, 0xe7, 0x37, 0x1b, 0x40, + 0x45, 0xb2, 0x29, 0x3e, 0x1b, 0x80, 0x06, 0x45, 0x65, 0xd3, 0x35, 0x1b, + 0x40, 0x80, 0x01, 0xff, 0x44, 0xdd, 0xd3, 0x3f, 0x1b, 0x80, 0x06, 0x46, + 0x64, 0xd3, 0x40, 0x1b, 0x40, 0x47, 0x63, 0xd3, 0x41, 0x1b, 0x40, 0x45, + 0xc4, 0xe7, 0x39, 0x1b, 0x40, 0x47, 0x63, 0xd3, 0x3b, 0x1b, 0x40, 0x47, + 0x63, 0xd3, 0x43, 0x1b, 0x40, 0x47, 0x63, 0xd3, 0x3d, 0x1b, 0x40, 0x45, + 0xc1, 0xea, 0x04, 0x1b, 0x00, 0x45, 0x0c, 0xeb, 0x02, 0x1b, 0x00, 0x47, + 0x35, 0xdb, 0x34, 0x1b, 0x00, 0x46, 0x36, 0xe6, 0x03, 0x1b, 0x00, 0x04, + 0xd0, 0xf8, 0x01, 0xff, 0x46, 0x13, 0x25, 0x01, 0x1b, 0x00, 0x45, 0x48, + 0xf0, 0x00, 0x1b, 0x40, 0xad, 0x16, 0x43, 0x9f, 0x01, 0x5a, 0x1b, 0xc0, + 0x00, 0x80, 0x01, 0xff, 0x45, 0xa8, 0xea, 0x7f, 0x1b, 0x00, 0x47, 0xd8, + 0xc7, 0x7d, 0x1b, 0x40, 0x43, 0x1b, 0x20, 0x5b, 0x1b, 0x80, 0x06, 0x45, + 0xf2, 0xeb, 0x60, 0x1b, 0x40, 0x48, 0xd7, 0xc7, 0x7e, 0x1b, 0x40, 0x0a, + 0xc2, 0x5b, 0x97, 0x01, 0xa4, 0x51, 0x0a, 0x44, 0xb2, 0x26, 0x0b, 0x3b, + 0xa7, 0x01, 0xff, 0x08, 0x4a, 0x64, 0x11, 0x06, 0xce, 0xe4, 0x01, 0xff, + 0x42, 0x23, 0x02, 0x75, 0x1b, 0x00, 0x42, 0x81, 0x0f, 0x74, 0x1b, 0x40, + 0x42, 0x6d, 0x00, 0x77, 0x1b, 0x00, 0x42, 0xb5, 0x08, 0x76, 0x1b, 0x40, + 0x09, 0xd2, 0xbc, 0x17, 0x06, 0xd4, 0xe4, 0x01, 0xff, 0x43, 0x1c, 0x01, + 0x78, 0x1b, 0x00, 0x43, 0xa1, 0x01, 0x7c, 0x1b, 0x00, 0x43, 0xe1, 0x47, + 0x79, 0x1b, 0x40, 0x42, 0x6d, 0x00, 0x7a, 0x1b, 0x00, 0x42, 0xb5, 0x08, + 0x7b, 0x1b, 0x40, 0xa1, 0x20, 0xa5, 0x12, 0x43, 0xa1, 0x01, 0x66, 0x1b, + 0x00, 0x43, 0xd8, 0x02, 0x61, 0x1b, 0x00, 0x43, 0xe1, 0x47, 0x63, 0x1b, + 0x40, 0x42, 0x1d, 0x01, 0x62, 0x1b, 0x00, 0x43, 0xe1, 0x47, 0x68, 0x1b, + 0x40, 0x43, 0x95, 0x0a, 0x67, 0x1b, 0x00, 0x43, 0xa1, 0x01, 0x69, 0x1b, + 0x00, 0x42, 0x1d, 0x01, 0x64, 0x1b, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x44, + 0xcc, 0xf5, 0x6a, 0x1b, 0x00, 0x46, 0x36, 0xe6, 0x65, 0x1b, 0x40, 0x45, + 0xb2, 0xea, 0x72, 0x1b, 0x00, 0x45, 0xed, 0xeb, 0x6c, 0x1b, 0x00, 0x44, + 0x59, 0x8b, 0x73, 0x1b, 0x00, 0x47, 0xb5, 0x83, 0x6f, 0x1b, 0x00, 0x04, + 0xc2, 0xc0, 0x06, 0x45, 0x1a, 0xf1, 0x6b, 0x1b, 0x40, 0x42, 0xc3, 0x01, + 0x6e, 0x1b, 0x80, 0x0d, 0x42, 0x1f, 0x01, 0x6d, 0x1b, 0xc0, 0x00, 0x4d, + 0xaf, 0x83, 0x70, 0x1b, 0x40, 0x4d, 0xaf, 0x83, 0x71, 0x1b, 0x40, 0xa1, + 0xdc, 0x02, 0x42, 0x16, 0x00, 0x29, 0x1b, 0x80, 0xce, 0x02, 0x42, 0x37, + 0x00, 0x18, 0x1b, 0x80, 0xc0, 0x02, 0x42, 0x7b, 0x08, 0x24, 0x1b, 0x80, + 0x9c, 0x02, 0xa5, 0x8d, 0x02, 0x42, 0x24, 0x02, 0x15, 0x1b, 0x80, 0xff, + 0x01, 0x42, 0x22, 0x00, 0x33, 0x1b, 0x00, 0x45, 0x4b, 0xed, 0x07, 0x1b, + 0x80, 0xeb, 0x01, 0x42, 0x78, 0x1a, 0x1a, 0x1b, 0x80, 0xdd, 0x01, 0xab, + 0xc3, 0x01, 0x42, 0x74, 0x00, 0x2e, 0x1b, 0x80, 0xae, 0x01, 0x42, 0x6c, + 0x00, 0x2b, 0x1b, 0x00, 0xae, 0x8e, 0x01, 0x45, 0x71, 0xef, 0x11, 0x1b, + 0x80, 0x80, 0x01, 0x42, 0xe0, 0x09, 0x27, 0x1b, 0x80, 0x73, 0x42, 0x71, + 0x00, 0x2d, 0x1b, 0x80, 0x5f, 0x42, 0x40, 0x06, 0x32, 0x1b, 0x80, 0x47, + 0xb4, 0x25, 0x45, 0xab, 0xf1, 0x09, 0x1b, 0x80, 0x18, 0x48, 0xf7, 0xd1, + 0x49, 0x1b, 0x00, 0x42, 0xa9, 0x01, 0x2f, 0x1b, 0x00, 0x42, 0xdf, 0x23, + 0x2c, 0x1b, 0x00, 0x49, 0x8b, 0xc7, 0x4a, 0x1b, 0x40, 0x47, 0x63, 0xd3, + 0x0a, 0x1b, 0x40, 0xe1, 0x22, 0x1b, 0x80, 0x06, 0x49, 0xa6, 0xc7, 0x47, + 0x1b, 0x40, 0x80, 0x01, 0xff, 0x45, 0x13, 0xee, 0x1d, 0x1b, 0x00, 0x4f, + 0x7d, 0x73, 0x1e, 0x1b, 0x00, 0x44, 0x53, 0xca, 0x23, 0x1b, 0x40, 0x03, + 0x27, 0x24, 0x01, 0xff, 0x42, 0x24, 0x02, 0x30, 0x1b, 0x00, 0x42, 0xe0, + 0x09, 0x31, 0x1b, 0x40, 0x45, 0xff, 0xda, 0x0b, 0x1b, 0xc0, 0x00, 0x47, + 0x63, 0xd3, 0x0c, 0x1b, 0x40, 0x46, 0x0e, 0xde, 0x28, 0x1b, 0x40, 0x47, + 0x63, 0xd3, 0x12, 0x1b, 0x40, 0xe1, 0x26, 0x1b, 0x80, 0x0c, 0x42, 0x24, + 0x02, 0x17, 0x1b, 0x00, 0x42, 0xdf, 0x23, 0x1c, 0x1b, 0x40, 0x47, 0x40, + 0xd3, 0x21, 0x1b, 0x40, 0x46, 0x41, 0xcd, 0x0d, 0x1b, 0xc0, 0x00, 0x47, + 0x63, 0xd3, 0x0e, 0x1b, 0x40, 0xe1, 0x13, 0x1b, 0x80, 0x06, 0x49, 0x51, + 0xbf, 0x46, 0x1b, 0x40, 0x4a, 0x82, 0x73, 0x14, 0x1b, 0x00, 0x47, 0xd5, + 0xd6, 0x45, 0x1b, 0x40, 0x45, 0xc9, 0xe7, 0x1b, 0x1b, 0x40, 0x47, 0x63, + 0xd3, 0x08, 0x1b, 0x40, 0x45, 0xb5, 0xe7, 0x16, 0x1b, 0x40, 0x47, 0xd5, + 0xd6, 0x48, 0x1b, 0x00, 0x44, 0xca, 0x2e, 0x0f, 0x1b, 0x40, 0x02, 0x6b, + 0x00, 0x01, 0xff, 0x43, 0x6b, 0x02, 0x25, 0x1b, 0x00, 0x05, 0x7e, 0x73, + 0x01, 0xff, 0x49, 0x85, 0xbb, 0x1f, 0x1b, 0x00, 0x49, 0x83, 0x73, 0x20, + 0x1b, 0x40, 0x45, 0xd3, 0xe7, 0x19, 0x1b, 0x40, 0x48, 0xcf, 0xc7, 0x2a, + 0x1b, 0x40, 0x45, 0x4b, 0xed, 0x10, 0x1b, 0x00, 0x44, 0xca, 0x2e, 0x05, + 0x1b, 0x80, 0x0c, 0x4b, 0x04, 0xa7, 0x4c, 0x1b, 0x00, 0x4b, 0x4e, 0xa8, + 0x4b, 0x1b, 0x40, 0x47, 0x63, 0xd3, 0x06, 0x1b, 0x40, 0x47, 0x71, 0xda, + 0x4f, 0x1b, 0x00, 0x44, 0xd5, 0xb2, 0x4e, 0x1b, 0x40, 0x45, 0x7e, 0x0b, + 0x58, 0x1b, 0x00, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x59, 0x1b, 0x00, 0x43, + 0x7a, 0x0b, 0x51, 0x1b, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, + 0x50, 0x1b, 0x40, 0x44, 0x25, 0x01, 0x53, 0x1b, 0x00, 0x42, 0x15, 0x02, + 0x52, 0x1b, 0x40, 0x44, 0x06, 0x1f, 0x57, 0x1b, 0x00, 0x42, 0x09, 0x24, + 0x56, 0x1b, 0x40, 0x43, 0xf9, 0x05, 0x55, 0x1b, 0x00, 0x43, 0xf6, 0x06, + 0x54, 0x1b, 0x40, 0x02, 0xe0, 0x09, 0x06, 0x44, 0xd5, 0xb2, 0x5e, 0x1b, + 0x40, 0x47, 0x3d, 0xd9, 0x5d, 0x1b, 0x00, 0x45, 0xdb, 0x75, 0x5f, 0x1b, + 0x40, 0x42, 0xd8, 0x00, 0x6f, 0xf9, 0x01, 0x4a, 0x0a, 0xb0, 0xc4, 0xf6, + 0x01, 0x4b, 0x6c, 0xa9, 0x56, 0xf9, 0x41, 0x43, 0x00, 0x0a, 0xa1, 0xf9, + 0x01, 0x5e, 0x99, 0x14, 0xf8, 0xf3, 0x41, 0xab, 0x0c, 0x42, 0x10, 0x00, + 0x53, 0xf9, 0x01, 0x4b, 0x1f, 0xa9, 0x2b, 0xf4, 0x41, 0x80, 0x1f, 0x67, + 0x58, 0x05, 0xab, 0x27, 0x00, 0xb3, 0x01, 0xff, 0x1a, 0xbd, 0x21, 0x06, + 0x44, 0x2e, 0x4f, 0x08, 0x00, 0x40, 0x49, 0xb1, 0xc2, 0x5b, 0x2b, 0x00, + 0x4d, 0x6b, 0x8c, 0x5d, 0x2b, 0x40, 0x4b, 0xa4, 0xa5, 0x82, 0xf5, 0x01, + 0x5a, 0xc5, 0x23, 0x19, 0xf5, 0x41, 0x80, 0x01, 0xff, 0x45, 0x4e, 0xea, + 0x7c, 0xf4, 0x01, 0x46, 0xe5, 0x5d, 0x7c, 0xf3, 0x01, 0x45, 0x78, 0x5c, + 0x24, 0xf4, 0x01, 0x46, 0x16, 0x08, 0xbc, 0xf6, 0x41, 0x45, 0x99, 0xea, + 0xee, 0xf9, 0x01, 0xa3, 0xd4, 0x8f, 0x01, 0xa4, 0xed, 0x8a, 0x01, 0xa5, + 0xb8, 0x87, 0x01, 0x4b, 0x37, 0xa1, 0x0b, 0x06, 0x00, 0x04, 0x30, 0xf6, + 0x89, 0x84, 0x01, 0x47, 0xde, 0x35, 0x08, 0x27, 0x80, 0xf1, 0x83, 0x01, + 0x4b, 0x3c, 0xa3, 0x4d, 0x21, 0x00, 0xac, 0xc7, 0x7b, 0xad, 0x9a, 0x7b, + 0xae, 0xdc, 0x65, 0xb0, 0xf5, 0x60, 0x47, 0xe8, 0xda, 0x52, 0x26, 0x00, + 0xb2, 0xe1, 0x03, 0xb3, 0x88, 0x03, 0xb4, 0xf9, 0x02, 0xb5, 0xd0, 0x02, + 0xb6, 0x06, 0x42, 0x90, 0x45, 0x93, 0xfa, 0x41, 0x06, 0x56, 0xe1, 0x06, + 0x45, 0x67, 0xef, 0x51, 0xf9, 0x41, 0x51, 0x55, 0x52, 0x39, 0x0b, 0x01, + 0x07, 0x13, 0x06, 0x01, 0xff, 0xe1, 0x00, 0x0b, 0x81, 0x8f, 0x02, 0xa2, + 0x82, 0x02, 0x42, 0x73, 0x02, 0x17, 0x0b, 0x01, 0xa4, 0xef, 0x01, 0xe5, + 0x08, 0x0b, 0x81, 0xe5, 0x01, 0x42, 0x2e, 0x1b, 0x1f, 0x0b, 0x01, 0xa7, + 0xcc, 0x01, 0xa8, 0xbf, 0x01, 0xe9, 0x0c, 0x0b, 0x81, 0xb5, 0x01, 0x42, + 0xa3, 0x21, 0x18, 0x0b, 0x01, 0x42, 0x37, 0x01, 0x10, 0x0b, 0x01, 0x42, + 0x68, 0x00, 0x2e, 0x0b, 0x01, 0x42, 0x2a, 0x02, 0x28, 0x0b, 0x01, 0xae, + 0x79, 0xef, 0x0a, 0x0b, 0x81, 0x70, 0x42, 0x6f, 0x02, 0x1e, 0x0b, 0x01, + 0x42, 0x88, 0x00, 0x2d, 0x0b, 0x01, 0xb3, 0x4c, 0xb4, 0x3a, 0xf5, 0x0e, + 0x0b, 0x81, 0x31, 0x42, 0x32, 0x00, 0x2c, 0x0b, 0x01, 0xb8, 0x19, 0xb9, + 0x0d, 0xba, 0x01, 0xff, 0xe5, 0x30, 0x0b, 0x01, 0x42, 0xb0, 0x01, 0x32, + 0x0b, 0x41, 0xe5, 0x2b, 0x0b, 0x01, 0x42, 0x4d, 0x00, 0x2a, 0x0b, 0x41, + 0xe5, 0x11, 0x0b, 0x01, 0x42, 0x32, 0x00, 0x13, 0x0b, 0x01, 0x42, 0x4d, + 0x00, 0x12, 0x0b, 0x41, 0xf5, 0x0f, 0x0b, 0x41, 0xe5, 0x19, 0x0b, 0x01, + 0x42, 0xb0, 0x01, 0x1a, 0x0b, 0x01, 0x42, 0x77, 0x00, 0x1d, 0x0b, 0x41, + 0xe5, 0x2f, 0x0b, 0x01, 0xa8, 0x06, 0x43, 0x8e, 0x06, 0x34, 0x0b, 0x41, + 0xe5, 0x31, 0x0b, 0x01, 0x42, 0x4d, 0x00, 0x33, 0x0b, 0x41, 0xef, 0x0b, + 0x0b, 0x41, 0xe5, 0x25, 0x0b, 0x01, 0xa7, 0x0c, 0x42, 0xf1, 0x05, 0x27, + 0x0b, 0x01, 0x42, 0x4d, 0x00, 0x26, 0x0b, 0x41, 0xe5, 0x22, 0x0b, 0x01, + 0x42, 0x32, 0x00, 0x24, 0x0b, 0x01, 0x42, 0x4d, 0x00, 0x23, 0x0b, 0x41, + 0xe9, 0x0d, 0x0b, 0x41, 0xe5, 0x35, 0x0b, 0x01, 0x42, 0x2a, 0x02, 0x29, + 0x0b, 0x41, 0xe5, 0x14, 0x0b, 0x01, 0x42, 0x00, 0x0a, 0x15, 0x0b, 0x01, + 0x42, 0xb0, 0x01, 0x16, 0x0b, 0x41, 0xe5, 0x09, 0x0b, 0x41, 0xe5, 0x1b, + 0x0b, 0x01, 0x42, 0xb0, 0x01, 0x1c, 0x0b, 0x41, 0xe5, 0x20, 0x0b, 0x01, + 0x42, 0xb0, 0x01, 0x21, 0x0b, 0x41, 0xe1, 0x01, 0x0b, 0x81, 0x11, 0xe5, + 0x06, 0x0b, 0x81, 0x08, 0xee, 0x04, 0x0b, 0x01, 0xef, 0x02, 0x0b, 0x41, + 0xe5, 0x07, 0x0b, 0x41, 0xee, 0x05, 0x0b, 0x01, 0xef, 0x03, 0x0b, 0x41, + 0x47, 0x31, 0xd5, 0x46, 0xf3, 0x01, 0x4a, 0x08, 0xb7, 0xb3, 0x20, 0x00, + 0x02, 0x1e, 0x00, 0x01, 0xff, 0x49, 0x5c, 0xba, 0xfa, 0xf6, 0x01, 0xad, + 0x01, 0xff, 0x53, 0xab, 0x4a, 0xe7, 0xf3, 0x01, 0x45, 0xab, 0x4d, 0x97, + 0xf6, 0x41, 0x4b, 0x34, 0xa2, 0x5f, 0xf4, 0x01, 0x49, 0xc3, 0xc2, 0x9b, + 0x26, 0x40, 0xa3, 0x48, 0x47, 0xdd, 0x62, 0xa6, 0x22, 0x00, 0xb4, 0x06, + 0x55, 0x6c, 0x39, 0x43, 0x22, 0x40, 0x04, 0xcd, 0x0d, 0x27, 0x4c, 0x18, + 0x98, 0x32, 0xf6, 0x01, 0xb2, 0x01, 0xff, 0x43, 0xdb, 0x29, 0xd9, 0x2b, + 0x80, 0x11, 0x14, 0xe7, 0x46, 0x01, 0xff, 0x53, 0x98, 0x4a, 0xcd, 0xce, + 0x01, 0x46, 0xfc, 0xe6, 0xe2, 0x26, 0x40, 0x49, 0xa8, 0x2f, 0x78, 0xf7, + 0x41, 0xeb, 0x2a, 0x00, 0x80, 0x04, 0xed, 0x42, 0x20, 0x40, 0x49, 0x9f, + 0x1e, 0x17, 0x22, 0x40, 0x4b, 0xdd, 0x91, 0x0a, 0x26, 0x00, 0x49, 0x7e, + 0xbf, 0x9c, 0x01, 0x41, 0x04, 0xe4, 0x06, 0xbd, 0x05, 0xe3, 0x12, 0x23, + 0x00, 0x43, 0x3e, 0xa3, 0x48, 0x26, 0x00, 0x07, 0xb3, 0x34, 0x4b, 0x03, + 0xd0, 0x00, 0x11, 0x02, 0x35, 0x00, 0x01, 0xff, 0x4d, 0xeb, 0x85, 0x9b, + 0xf6, 0x01, 0x4a, 0xf4, 0xb6, 0xa8, 0xf3, 0x41, 0x0a, 0x9b, 0x01, 0x06, + 0x53, 0x27, 0x4c, 0xb0, 0xfb, 0x41, 0x17, 0xc8, 0x2f, 0x1c, 0x18, 0x7c, + 0x2c, 0x06, 0x57, 0x77, 0x33, 0xb0, 0xf8, 0x41, 0x49, 0xa5, 0x01, 0x35, + 0x29, 0x00, 0x4a, 0xb3, 0x42, 0xb1, 0xf8, 0x01, 0x47, 0x50, 0x02, 0x34, + 0x29, 0x40, 0x49, 0xea, 0x01, 0x36, 0x29, 0x00, 0x4a, 0xb3, 0x02, 0x37, + 0x29, 0x40, 0xa1, 0xd5, 0x04, 0xa3, 0xdc, 0x02, 0x49, 0x7d, 0xbd, 0x8f, + 0x05, 0x00, 0xa5, 0xc7, 0x02, 0x49, 0x4f, 0x17, 0x89, 0x05, 0x00, 0x46, + 0x8a, 0x66, 0x8a, 0x05, 0x00, 0x5e, 0xb7, 0x14, 0x59, 0x05, 0x00, 0x4d, + 0x88, 0x36, 0x5e, 0x05, 0x00, 0x07, 0x9b, 0x08, 0x01, 0xff, 0x06, 0x14, + 0x06, 0x2d, 0x08, 0xde, 0x11, 0x01, 0xff, 0x48, 0x1f, 0xcb, 0x87, 0x05, + 0x00, 0x04, 0x48, 0x51, 0x06, 0x47, 0x2d, 0xdd, 0x16, 0xfb, 0x40, 0x43, + 0x3a, 0x43, 0x14, 0xfb, 0x00, 0x43, 0x57, 0x07, 0x15, 0xfb, 0x00, 0x43, + 0x61, 0x30, 0x13, 0xfb, 0x00, 0x43, 0xcc, 0xfa, 0x17, 0xfb, 0x40, 0x43, + 0x71, 0xc6, 0x61, 0x05, 0x00, 0x43, 0xa3, 0x1c, 0x62, 0x05, 0x00, 0xa3, + 0xd6, 0x01, 0x42, 0x7b, 0x08, 0x64, 0x05, 0x00, 0xa5, 0xbf, 0x01, 0x43, + 0x70, 0xbe, 0x86, 0x05, 0x00, 0xa7, 0xaa, 0x01, 0x42, 0x0b, 0x00, 0x70, + 0x05, 0x00, 0x43, 0x57, 0x07, 0x6b, 0x05, 0x00, 0xaa, 0x91, 0x01, 0x02, + 0x37, 0x01, 0x84, 0x01, 0x44, 0xf8, 0xf6, 0x6c, 0x05, 0x00, 0x43, 0x2c, + 0x05, 0x74, 0x05, 0x00, 0x43, 0x61, 0x30, 0x76, 0x05, 0x00, 0x42, 0x9b, + 0x2a, 0x85, 0x05, 0x00, 0xb0, 0x5e, 0xb2, 0x52, 0xb3, 0x44, 0xb4, 0x32, + 0xb6, 0x26, 0x43, 0xcc, 0xfa, 0x6d, 0x05, 0x00, 0x42, 0xa0, 0x1b, 0x75, + 0x05, 0x80, 0x0d, 0xba, 0x01, 0xff, 0xe1, 0x66, 0x05, 0x00, 0x42, 0xb0, + 0x01, 0x6a, 0x05, 0x40, 0x4c, 0x78, 0x2a, 0x88, 0x05, 0x00, 0x42, 0xa7, + 0x01, 0x82, 0x05, 0x40, 0x42, 0x64, 0x1f, 0x7e, 0x05, 0x00, 0xef, 0x78, + 0x05, 0x40, 0x43, 0x24, 0xcb, 0x7f, 0x05, 0x00, 0xef, 0x69, 0x05, 0x00, + 0x49, 0x6b, 0xc6, 0x60, 0x05, 0x40, 0x42, 0x4e, 0x00, 0x7d, 0x05, 0x00, + 0x42, 0x22, 0x00, 0x77, 0x05, 0x40, 0xe1, 0x7c, 0x05, 0x00, 0x42, 0x4e, + 0x00, 0x80, 0x05, 0x40, 0x42, 0x4e, 0x00, 0x7a, 0x05, 0x00, 0x43, 0x54, + 0xfa, 0x83, 0x05, 0x40, 0xe8, 0x84, 0x05, 0x00, 0xee, 0x6f, 0x05, 0x40, + 0xe1, 0x71, 0x05, 0x00, 0x43, 0x19, 0x45, 0x7b, 0x05, 0x40, 0x43, 0xa5, + 0x02, 0x72, 0x05, 0x00, 0x42, 0x29, 0x02, 0x63, 0x05, 0x40, 0x42, 0x3b, + 0x15, 0x65, 0x05, 0x00, 0xe8, 0x67, 0x05, 0x00, 0xf4, 0x68, 0x05, 0x40, + 0xe1, 0x6e, 0x05, 0x00, 0xa8, 0x04, 0xef, 0x81, 0x05, 0x40, 0xe1, 0x79, + 0x05, 0x00, 0x42, 0x4e, 0x00, 0x73, 0x05, 0x40, 0x4c, 0xf8, 0x96, 0x5b, + 0x05, 0x00, 0x4f, 0xae, 0x00, 0x5c, 0x05, 0x40, 0x0e, 0x0c, 0x06, 0x06, + 0x44, 0x14, 0x05, 0x5d, 0x05, 0x40, 0x43, 0x71, 0xc6, 0x31, 0x05, 0x00, + 0x43, 0xa3, 0x1c, 0x32, 0x05, 0x00, 0xa3, 0xc9, 0x01, 0x42, 0x7b, 0x08, + 0x34, 0x05, 0x00, 0xa5, 0xb2, 0x01, 0x43, 0x70, 0xbe, 0x56, 0x05, 0x00, + 0xa7, 0x9d, 0x01, 0x42, 0x0b, 0x00, 0x40, 0x05, 0x00, 0x43, 0x57, 0x07, + 0x3b, 0x05, 0x00, 0xaa, 0x84, 0x01, 0x02, 0x37, 0x01, 0x78, 0x44, 0xf8, + 0xf6, 0x3c, 0x05, 0x00, 0x43, 0x2c, 0x05, 0x44, 0x05, 0x00, 0x43, 0x61, + 0x30, 0x46, 0x05, 0x00, 0x42, 0x9b, 0x2a, 0x55, 0x05, 0x00, 0xb0, 0x52, + 0xb2, 0x46, 0xb3, 0x38, 0xb4, 0x2c, 0xb6, 0x20, 0x43, 0xcc, 0xfa, 0x3d, + 0x05, 0x00, 0x42, 0xa0, 0x1b, 0x45, 0x05, 0x80, 0x0d, 0xba, 0x01, 0xff, + 0xe1, 0x36, 0x05, 0x00, 0x42, 0xb0, 0x01, 0x3a, 0x05, 0x40, 0x42, 0xa7, + 0x01, 0x52, 0x05, 0x40, 0x42, 0x64, 0x1f, 0x4e, 0x05, 0x00, 0xef, 0x48, + 0x05, 0x40, 0x43, 0x24, 0xcb, 0x4f, 0x05, 0x00, 0xef, 0x39, 0x05, 0x40, + 0x42, 0x4e, 0x00, 0x4d, 0x05, 0x00, 0x42, 0x22, 0x00, 0x47, 0x05, 0x40, + 0xe1, 0x4c, 0x05, 0x00, 0x42, 0x4e, 0x00, 0x50, 0x05, 0x40, 0x42, 0x4e, + 0x00, 0x4a, 0x05, 0x00, 0x43, 0x54, 0xfa, 0x53, 0x05, 0x40, 0xe8, 0x54, + 0x05, 0x00, 0xee, 0x3f, 0x05, 0x40, 0xe1, 0x41, 0x05, 0x00, 0x43, 0x19, + 0x45, 0x4b, 0x05, 0x40, 0x43, 0xa5, 0x02, 0x42, 0x05, 0x00, 0x42, 0x29, + 0x02, 0x33, 0x05, 0x40, 0x42, 0x3b, 0x15, 0x35, 0x05, 0x00, 0xe8, 0x37, + 0x05, 0x00, 0xf4, 0x38, 0x05, 0x40, 0xe1, 0x3e, 0x05, 0x00, 0xa8, 0x04, + 0xef, 0x51, 0x05, 0x40, 0xe1, 0x49, 0x05, 0x00, 0x42, 0x4e, 0x00, 0x43, + 0x05, 0x40, 0x50, 0x56, 0x52, 0x5f, 0x05, 0x00, 0x49, 0x5a, 0x38, 0x5a, + 0x05, 0x40, 0x80, 0x68, 0x07, 0xe8, 0x06, 0x01, 0xff, 0x49, 0x1a, 0xbd, + 0x06, 0x06, 0x00, 0x06, 0xef, 0x06, 0x17, 0x4b, 0x58, 0xa1, 0x07, 0x06, + 0x00, 0x04, 0x6f, 0x02, 0x01, 0xff, 0x4a, 0x66, 0xb3, 0x09, 0x06, 0x00, + 0x51, 0xdf, 0x60, 0x0a, 0x06, 0x40, 0x45, 0x7e, 0x0b, 0x68, 0x06, 0x00, + 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x69, 0x06, 0x00, 0x43, 0x7a, 0x0b, 0x61, + 0x06, 0x00, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x60, 0x06, 0x40, + 0x44, 0x25, 0x01, 0x63, 0x06, 0x00, 0x42, 0x15, 0x02, 0x62, 0x06, 0x40, + 0x44, 0x06, 0x1f, 0x67, 0x06, 0x00, 0x42, 0x09, 0x24, 0x66, 0x06, 0x40, + 0x43, 0xf9, 0x05, 0x65, 0x06, 0x00, 0x43, 0xf6, 0x06, 0x64, 0x06, 0x40, + 0xa2, 0xd0, 0x56, 0xa3, 0x80, 0x55, 0xa4, 0xa1, 0x54, 0xa5, 0xfd, 0x53, + 0xa6, 0xa7, 0x53, 0x02, 0x22, 0x00, 0x8b, 0x53, 0x4e, 0x4c, 0x7c, 0x57, + 0x06, 0x00, 0x45, 0x16, 0x53, 0x50, 0x06, 0x80, 0xdc, 0x52, 0xac, 0xe7, + 0x10, 0x02, 0x6c, 0x00, 0xe4, 0x08, 0xae, 0xc0, 0x08, 0x05, 0xf6, 0x04, + 0xa9, 0x08, 0xb0, 0xfd, 0x07, 0x4d, 0x88, 0x36, 0x1f, 0x06, 0x00, 0xb2, + 0xc5, 0x07, 0xb3, 0xa4, 0x01, 0xb4, 0x2b, 0xb6, 0x0c, 0x50, 0xba, 0x6b, + 0x5f, 0x06, 0x00, 0x48, 0xc7, 0xd2, 0x59, 0x06, 0x40, 0x4c, 0x07, 0x4a, + 0x8e, 0x08, 0x00, 0x0a, 0xc8, 0x7a, 0x01, 0xff, 0x49, 0x6d, 0x13, 0x5c, + 0x06, 0x00, 0x56, 0xab, 0x36, 0x5b, 0x06, 0x00, 0x4d, 0xb4, 0x36, 0x5a, + 0x06, 0x40, 0xa1, 0x47, 0x52, 0xcb, 0x54, 0x6c, 0x06, 0x00, 0x04, 0x7a, + 0x0b, 0x0c, 0x5a, 0x29, 0x23, 0x1e, 0x06, 0x00, 0x51, 0x9a, 0x61, 0xe3, + 0x08, 0x40, 0x05, 0xba, 0xab, 0x21, 0x08, 0x6b, 0x0c, 0x11, 0x09, 0x5d, + 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xeb, 0x08, 0x00, 0x45, 0x20, 0x07, + 0xee, 0x08, 0x40, 0x45, 0x5c, 0x00, 0xea, 0x08, 0x00, 0x45, 0x20, 0x07, + 0xed, 0x08, 0x40, 0x45, 0x5c, 0x00, 0xec, 0x08, 0x00, 0x45, 0x20, 0x07, + 0xef, 0x08, 0x40, 0x4b, 0x81, 0xa2, 0x73, 0xfe, 0x00, 0x45, 0x54, 0x22, + 0x40, 0x06, 0xc0, 0x00, 0x06, 0x50, 0x00, 0x01, 0xff, 0x4e, 0x50, 0x7b, + 0x71, 0xfe, 0x00, 0x0b, 0x5f, 0xa6, 0x06, 0x4e, 0xb4, 0x0f, 0x85, 0x08, + 0x40, 0x45, 0x56, 0x00, 0x83, 0x08, 0x00, 0x43, 0x1c, 0x8f, 0x84, 0x08, + 0x40, 0x48, 0x5b, 0x5c, 0x1b, 0x06, 0x00, 0x45, 0xba, 0xec, 0x51, 0x06, + 0x80, 0x81, 0x06, 0x04, 0x5b, 0x03, 0xad, 0x05, 0x05, 0x5e, 0x07, 0xcd, + 0x01, 0x61, 0xfc, 0x0e, 0xcd, 0x0e, 0x01, 0x4b, 0x70, 0x5e, 0xf1, 0x0e, + 0x01, 0x53, 0xca, 0x4f, 0xde, 0x06, 0x00, 0xb5, 0x90, 0x01, 0x06, 0x2e, + 0x17, 0x01, 0xff, 0x02, 0x3b, 0x01, 0x71, 0x0a, 0x08, 0x49, 0x61, 0x44, + 0x22, 0x08, 0xbf, 0xfb, 0x00, 0x0a, 0x8b, 0x78, 0x4b, 0xb4, 0x06, 0x4b, + 0x3d, 0xaa, 0xc2, 0xfb, 0x40, 0x0a, 0x7c, 0x13, 0x22, 0x08, 0x5e, 0x0c, + 0x01, 0xff, 0x45, 0x5c, 0x00, 0xb4, 0xfb, 0x00, 0x45, 0x20, 0x07, 0xb5, + 0xfb, 0x00, 0x0b, 0xd4, 0x2d, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xbd, 0xfb, + 0x00, 0x45, 0x20, 0x07, 0xbe, 0xfb, 0x40, 0x45, 0x5c, 0x00, 0xb6, 0xfb, + 0x00, 0x45, 0x20, 0x07, 0xb7, 0xfb, 0x00, 0x13, 0x9c, 0x01, 0x01, 0xff, + 0x45, 0x5c, 0x00, 0xb8, 0xfb, 0x00, 0x45, 0x20, 0x07, 0xb9, 0xfb, 0x40, + 0x45, 0x5c, 0x00, 0xc0, 0xfb, 0x00, 0x45, 0x20, 0x07, 0xc1, 0xfb, 0x40, + 0x45, 0x5c, 0x00, 0xba, 0xfb, 0x00, 0x45, 0x20, 0x07, 0xbb, 0xfb, 0x40, + 0x02, 0xc6, 0x00, 0x06, 0x57, 0x32, 0x33, 0xbc, 0xfb, 0x40, 0x45, 0x5c, + 0x00, 0xb2, 0xfb, 0x00, 0x45, 0x20, 0x07, 0xb3, 0xfb, 0x40, 0x4c, 0xa0, + 0x91, 0x56, 0x06, 0x00, 0x43, 0x85, 0x38, 0x52, 0x06, 0x80, 0x06, 0x58, + 0x34, 0x2c, 0x9d, 0x08, 0x40, 0x80, 0x01, 0xff, 0x45, 0x20, 0x07, 0xd0, + 0x08, 0x00, 0x4d, 0x5f, 0x03, 0x7e, 0xfe, 0x00, 0x4b, 0x1a, 0x71, 0x7f, + 0xfe, 0x40, 0x09, 0x15, 0xbc, 0xca, 0x03, 0x4c, 0xef, 0x51, 0xce, 0x0e, + 0x01, 0x45, 0xa0, 0x61, 0x19, 0x06, 0x00, 0x02, 0x0c, 0x08, 0xad, 0x03, + 0x05, 0xb4, 0x0b, 0x81, 0x01, 0x45, 0x16, 0x53, 0x1a, 0x06, 0x00, 0x04, + 0x08, 0x05, 0x13, 0x43, 0x1c, 0x8f, 0xe5, 0x06, 0x00, 0x43, 0x4d, 0x00, + 0xe6, 0x06, 0xc0, 0x00, 0x5b, 0xf7, 0x1a, 0xc5, 0x0e, 0x41, 0x44, 0x3f, + 0x22, 0xed, 0x06, 0x00, 0x44, 0x30, 0x48, 0xfb, 0x0e, 0x81, 0x40, 0x44, + 0x88, 0xf8, 0xe3, 0x06, 0x00, 0x58, 0x3c, 0x2d, 0xf0, 0x0e, 0x01, 0xb7, + 0x01, 0xff, 0x42, 0x3e, 0x2f, 0xd3, 0x08, 0x00, 0x04, 0xaa, 0x26, 0x01, + 0xff, 0xa9, 0x18, 0x45, 0x5a, 0x4d, 0xff, 0x0e, 0x01, 0x44, 0x20, 0xf8, + 0xfe, 0x0e, 0x01, 0x45, 0x9d, 0xf0, 0xfd, 0x0e, 0x01, 0x47, 0x23, 0xdc, + 0x9b, 0x08, 0x40, 0x45, 0x4a, 0xee, 0x9a, 0x08, 0x00, 0x46, 0xdc, 0xe5, + 0x99, 0x08, 0x40, 0x06, 0x50, 0x00, 0x01, 0xff, 0x45, 0xa0, 0x61, 0xf6, + 0x0e, 0x01, 0x45, 0x1a, 0x77, 0xf4, 0x0e, 0x01, 0x45, 0x16, 0x53, 0xd9, + 0x08, 0x40, 0x43, 0x56, 0x07, 0xd6, 0x08, 0x00, 0x54, 0xb3, 0x43, 0xe1, + 0x06, 0x00, 0xa6, 0x8c, 0x02, 0x50, 0x4a, 0x66, 0xf7, 0x0e, 0x01, 0x44, + 0x4c, 0x3a, 0xda, 0x06, 0x00, 0xac, 0xd6, 0x01, 0xad, 0xbc, 0x01, 0x44, + 0x30, 0x48, 0xe8, 0x06, 0x80, 0x9d, 0x01, 0x43, 0x11, 0x15, 0xd7, 0x08, + 0x00, 0x4c, 0xc8, 0x99, 0xdf, 0x06, 0x00, 0xb3, 0x7d, 0xb4, 0x6f, 0x58, + 0x3c, 0x2d, 0xe0, 0x06, 0x00, 0xb7, 0x1c, 0x43, 0x4d, 0x00, 0xe7, 0x06, 0x80, 0x0f, 0x02, 0x59, 0x00, 0x01, 0xff, 0xe8, 0xcd, 0x08, 0x00, 0x42, - 0x9e, 0x01, 0x17, 0x06, 0x40, 0x5b, 0xf1, 0x19, 0xcb, 0x08, 0x40, 0x42, - 0xd2, 0x2d, 0xf3, 0x08, 0x00, 0x04, 0x57, 0x25, 0x01, 0xff, 0xa1, 0x1a, - 0x43, 0xb2, 0xf4, 0xde, 0x08, 0x00, 0x02, 0x40, 0x06, 0x06, 0x45, 0x56, - 0xec, 0xdf, 0x08, 0x40, 0xe8, 0xcc, 0x08, 0x00, 0x43, 0x5c, 0x3f, 0xdd, - 0x08, 0x40, 0x45, 0x1e, 0xe8, 0x98, 0x08, 0x00, 0x46, 0x44, 0xde, 0xdc, - 0x08, 0x00, 0x45, 0x44, 0xea, 0xd4, 0x08, 0x00, 0x47, 0xab, 0xd5, 0xdb, - 0x08, 0x00, 0x4b, 0x71, 0xa3, 0xda, 0x08, 0x40, 0x42, 0x18, 0x0a, 0x15, - 0x06, 0x00, 0x49, 0x2b, 0x10, 0xdb, 0x06, 0x40, 0x42, 0xe8, 0x01, 0xd5, - 0x08, 0x00, 0x43, 0xc4, 0x09, 0xdc, 0x06, 0x00, 0x49, 0x4d, 0xba, 0xe1, - 0x08, 0x40, 0x4b, 0x3a, 0x98, 0xd8, 0x08, 0x40, 0x44, 0x18, 0x4b, 0xe4, - 0x06, 0x00, 0x05, 0x5a, 0x38, 0x01, 0xff, 0x4b, 0xb9, 0x16, 0xd8, 0x06, - 0x00, 0x4c, 0x60, 0x03, 0xe2, 0x06, 0x40, 0x47, 0xd5, 0xce, 0xd9, 0x06, - 0x00, 0x08, 0x9f, 0x1f, 0x01, 0xff, 0x0a, 0xc0, 0xa7, 0x0c, 0x5e, 0x43, - 0x14, 0xd7, 0x06, 0x00, 0x5e, 0x7f, 0x14, 0xd6, 0x06, 0x40, 0x4c, 0xcc, - 0x90, 0x16, 0x06, 0x00, 0x4a, 0x04, 0xb4, 0x16, 0x06, 0x40, 0x48, 0xb1, - 0xc3, 0xca, 0x08, 0x00, 0x4e, 0x70, 0x7a, 0xe0, 0x08, 0x40, 0x47, 0xb2, - 0xc3, 0xc9, 0x08, 0x00, 0x43, 0x8f, 0x00, 0x18, 0x06, 0x40, 0x4f, 0x84, - 0x6a, 0x11, 0x06, 0x00, 0x45, 0xd7, 0xe8, 0x0f, 0x06, 0x00, 0x02, 0x71, - 0x00, 0x33, 0xb3, 0x06, 0x49, 0xc0, 0xbf, 0x14, 0x06, 0x40, 0xa1, 0x11, - 0x06, 0x0c, 0xdd, 0x01, 0xff, 0x49, 0x2d, 0x3e, 0xfd, 0x06, 0x00, 0x50, - 0xed, 0x65, 0xfe, 0x06, 0x40, 0x43, 0x53, 0xba, 0x03, 0x06, 0x00, 0x5a, - 0xea, 0x20, 0x10, 0x06, 0x00, 0x44, 0x6d, 0xf1, 0x04, 0x06, 0x00, 0x43, - 0x60, 0x46, 0x01, 0x06, 0x40, 0x4f, 0x0a, 0x6c, 0x13, 0x06, 0x00, 0x50, - 0x7d, 0x63, 0x12, 0x06, 0x40, 0x80, 0x01, 0xff, 0x4d, 0x5f, 0x03, 0x7c, - 0xfe, 0x00, 0x4b, 0xfd, 0x6d, 0x7d, 0xfe, 0x40, 0xa1, 0x23, 0x4d, 0xda, - 0x82, 0x5d, 0x06, 0x00, 0x0f, 0xec, 0x3d, 0x06, 0x63, 0x41, 0x0b, 0xec, - 0x06, 0x40, 0x45, 0x5c, 0x00, 0xf8, 0x08, 0x80, 0x06, 0x45, 0x20, 0x07, - 0xfa, 0x08, 0x40, 0x49, 0x90, 0x3b, 0xfd, 0x08, 0x40, 0x4e, 0xe8, 0x78, - 0x88, 0x08, 0x00, 0xf9, 0x08, 0x06, 0x40, 0xa5, 0x1b, 0x51, 0xcf, 0x5a, - 0x91, 0x08, 0x00, 0x4e, 0x4a, 0x79, 0xe9, 0x06, 0x00, 0xaf, 0x01, 0xff, - 0x4f, 0xfa, 0x6c, 0x0e, 0x06, 0x00, 0x4e, 0xf0, 0x7d, 0x90, 0x08, 0x40, - 0x43, 0x4c, 0x2b, 0x97, 0x08, 0x00, 0x4a, 0x03, 0x9c, 0x6a, 0x06, 0x40, - 0x48, 0x19, 0xc5, 0xf1, 0x08, 0x00, 0x48, 0xd0, 0x77, 0xf0, 0x08, 0x00, - 0x48, 0x91, 0xc7, 0xf2, 0x08, 0x40, 0x4a, 0x60, 0x4c, 0x05, 0x06, 0x00, - 0x44, 0x5a, 0x03, 0x00, 0x06, 0x40, 0x03, 0x95, 0x36, 0xe7, 0x07, 0x03, - 0xbb, 0x00, 0xd6, 0x07, 0x0b, 0xaa, 0x53, 0x01, 0xff, 0xa1, 0xc2, 0x07, - 0x43, 0xb8, 0x8c, 0x01, 0xee, 0x01, 0xa4, 0xe8, 0x05, 0x43, 0xf7, 0xb8, - 0x10, 0xee, 0x01, 0x45, 0x86, 0x9c, 0x1b, 0xee, 0x01, 0x43, 0x28, 0x21, - 0x07, 0xee, 0x01, 0x08, 0xb8, 0x16, 0xd1, 0x04, 0x44, 0x59, 0x38, 0x02, - 0xee, 0x01, 0xab, 0xbc, 0x04, 0xac, 0xfc, 0x02, 0x44, 0x1e, 0x21, 0x0c, - 0xee, 0x01, 0x44, 0x00, 0x46, 0x0d, 0xee, 0x01, 0x09, 0x99, 0x3e, 0xdf, - 0x02, 0x43, 0x43, 0x14, 0x12, 0xee, 0x01, 0x43, 0x3e, 0x52, 0x13, 0xee, - 0x01, 0xb3, 0xa0, 0x01, 0xb4, 0x1b, 0x43, 0x9f, 0x8a, 0x05, 0xee, 0x01, - 0x43, 0x4d, 0x00, 0x09, 0xee, 0x01, 0x02, 0x59, 0x00, 0x01, 0xff, 0xe8, - 0x1a, 0xee, 0x01, 0x42, 0x9e, 0x01, 0x06, 0xee, 0x41, 0xa1, 0x15, 0x42, - 0x4e, 0x00, 0x15, 0xee, 0x01, 0xa8, 0x01, 0xff, 0x42, 0x13, 0x00, 0x18, - 0xee, 0x01, 0x42, 0x4e, 0x00, 0x16, 0xee, 0x41, 0xe8, 0x08, 0xee, 0x01, - 0x05, 0x91, 0x17, 0x01, 0xff, 0x43, 0x56, 0x07, 0x4f, 0xee, 0x01, 0xa4, - 0x44, 0x45, 0x86, 0x9c, 0x5b, 0xee, 0x01, 0x43, 0x28, 0x21, 0x47, 0xee, - 0x01, 0x44, 0x59, 0x38, 0x42, 0xee, 0x01, 0x44, 0xa7, 0x41, 0x57, 0xee, - 0x01, 0x43, 0xb0, 0x00, 0x4b, 0xee, 0x01, 0x44, 0x00, 0x46, 0x4d, 0xee, - 0x01, 0x43, 0x43, 0x14, 0x52, 0xee, 0x01, 0xb3, 0x06, 0x43, 0x4d, 0x00, - 0x49, 0xee, 0x41, 0x42, 0xe8, 0x01, 0x51, 0xee, 0x01, 0x43, 0xc4, 0x09, - 0x4e, 0xee, 0x01, 0x44, 0x6c, 0xdb, 0x54, 0xee, 0x41, 0x42, 0xe8, 0x01, - 0x59, 0xee, 0x01, 0x07, 0x98, 0x41, 0x01, 0xff, 0x44, 0x00, 0x46, 0x5d, - 0xee, 0x01, 0x43, 0x43, 0x14, 0x5f, 0xee, 0x41, 0x42, 0xe8, 0x01, 0x11, - 0xee, 0x01, 0x43, 0xc4, 0x09, 0x0e, 0xee, 0x01, 0x44, 0x6c, 0xdb, 0x14, - 0xee, 0x01, 0x09, 0x4c, 0xb2, 0x01, 0xff, 0x43, 0x56, 0x07, 0x6f, 0xee, - 0x01, 0x43, 0xb8, 0x8c, 0x61, 0xee, 0x01, 0xa4, 0x74, 0x43, 0xf7, 0xb8, - 0x70, 0xee, 0x01, 0x45, 0x86, 0x9c, 0x7b, 0xee, 0x01, 0xa8, 0x5a, 0x44, - 0x59, 0x38, 0x62, 0xee, 0x01, 0xab, 0x46, 0x44, 0x1e, 0x21, 0x6c, 0xee, - 0x01, 0x44, 0x00, 0x46, 0x6d, 0xee, 0x01, 0x43, 0x43, 0x14, 0x72, 0xee, - 0x01, 0xb3, 0x20, 0xb4, 0x0c, 0x43, 0x4d, 0x00, 0x69, 0xee, 0x01, 0x43, - 0x16, 0x7f, 0x7a, 0xee, 0x41, 0x42, 0x18, 0x0a, 0x68, 0xee, 0x01, 0x42, - 0x4e, 0x00, 0x75, 0xee, 0x01, 0x43, 0xfd, 0x42, 0x76, 0xee, 0x41, 0x42, - 0xe8, 0x01, 0x71, 0xee, 0x01, 0x43, 0xc4, 0x09, 0x6e, 0xee, 0x01, 0x44, - 0x6c, 0xdb, 0x74, 0xee, 0x41, 0x42, 0x44, 0x14, 0x6a, 0xee, 0x01, 0x43, - 0x28, 0x21, 0x77, 0xee, 0x41, 0x42, 0x18, 0x0a, 0x67, 0xee, 0x01, 0x42, - 0x4e, 0x00, 0x64, 0xee, 0x41, 0x42, 0xe8, 0x01, 0x79, 0xee, 0x01, 0x07, - 0x98, 0x41, 0x01, 0xff, 0x43, 0xb8, 0x8c, 0x7c, 0xee, 0x01, 0x43, 0xf7, - 0xb8, 0x7e, 0xee, 0x41, 0x4c, 0x88, 0x8f, 0xf1, 0xee, 0x01, 0x5a, 0x1e, - 0x21, 0xf0, 0xee, 0x41, 0x42, 0x57, 0x00, 0x0b, 0xee, 0x01, 0x06, 0x58, - 0x85, 0x01, 0xff, 0xa1, 0xa3, 0x01, 0x43, 0xb8, 0x8c, 0x81, 0xee, 0x01, - 0x02, 0xf0, 0x10, 0x90, 0x01, 0x43, 0xf7, 0xb8, 0x90, 0xee, 0x01, 0x45, - 0x86, 0x9c, 0x9b, 0xee, 0x01, 0xa8, 0x76, 0x44, 0x59, 0x38, 0x82, 0xee, - 0x01, 0x44, 0xa7, 0x41, 0x97, 0xee, 0x01, 0x43, 0xb0, 0x00, 0x8b, 0xee, - 0x01, 0x44, 0x1e, 0x21, 0x8c, 0xee, 0x01, 0x44, 0x00, 0x46, 0x8d, 0xee, - 0x01, 0x43, 0x43, 0x14, 0x92, 0xee, 0x01, 0x43, 0x3e, 0x52, 0x93, 0xee, - 0x01, 0xb3, 0x38, 0xb4, 0x1b, 0x43, 0x9f, 0x8a, 0x85, 0xee, 0x01, 0x43, - 0x4d, 0x00, 0x89, 0xee, 0x01, 0x02, 0x59, 0x00, 0x01, 0xff, 0xe8, 0x9a, - 0xee, 0x01, 0x42, 0x9e, 0x01, 0x86, 0xee, 0x41, 0x42, 0x18, 0x0a, 0x88, - 0xee, 0x01, 0x42, 0x4e, 0x00, 0x95, 0xee, 0x01, 0xa8, 0x01, 0xff, 0x42, - 0x13, 0x00, 0x98, 0xee, 0x01, 0x42, 0x4e, 0x00, 0x96, 0xee, 0x41, 0x42, - 0xe8, 0x01, 0x91, 0xee, 0x01, 0x43, 0xc4, 0x09, 0x8e, 0xee, 0x01, 0x44, - 0x6c, 0xdb, 0x94, 0xee, 0x41, 0x42, 0x18, 0x0a, 0x87, 0xee, 0x01, 0x42, - 0x4e, 0x00, 0x84, 0xee, 0x41, 0xe4, 0x99, 0xee, 0x01, 0xec, 0x83, 0xee, - 0x41, 0x42, 0x9e, 0x01, 0x8f, 0xee, 0x01, 0x43, 0x68, 0x00, 0x80, 0xee, - 0x41, 0x42, 0x44, 0x14, 0x0a, 0xee, 0x01, 0x43, 0x28, 0x21, 0x17, 0xee, - 0x41, 0x43, 0x56, 0x07, 0x2f, 0xee, 0x01, 0x43, 0xb8, 0x8c, 0x21, 0xee, - 0x01, 0x43, 0x46, 0xd0, 0x39, 0xee, 0x01, 0x43, 0xf7, 0xb8, 0x30, 0xee, - 0x01, 0x45, 0x86, 0x9c, 0x3b, 0xee, 0x01, 0xa8, 0x54, 0x44, 0x59, 0x38, - 0x22, 0xee, 0x01, 0xab, 0x40, 0x43, 0xb0, 0x00, 0x2b, 0xee, 0x01, 0x44, - 0x1e, 0x21, 0x2c, 0xee, 0x01, 0x44, 0x00, 0x46, 0x2d, 0xee, 0x01, 0x43, - 0x43, 0x14, 0x32, 0xee, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x43, 0x4d, 0x00, - 0x29, 0xee, 0x41, 0x42, 0x4e, 0x00, 0x35, 0xee, 0x01, 0x43, 0xfd, 0x42, - 0x36, 0xee, 0x41, 0x42, 0xe8, 0x01, 0x31, 0xee, 0x01, 0x43, 0xc4, 0x09, - 0x2e, 0xee, 0x01, 0x44, 0x6c, 0xdb, 0x34, 0xee, 0x41, 0x42, 0x44, 0x14, - 0x2a, 0xee, 0x01, 0x43, 0x28, 0x21, 0x37, 0xee, 0x41, 0x42, 0x18, 0x0a, - 0x27, 0xee, 0x01, 0x42, 0x4e, 0x00, 0x24, 0xee, 0x41, 0xa1, 0xc6, 0x01, - 0xaf, 0x01, 0xff, 0x06, 0x99, 0x41, 0xa6, 0x01, 0x0c, 0x2a, 0x77, 0x01, - 0xff, 0x43, 0x56, 0x07, 0xaf, 0xee, 0x01, 0x43, 0xb8, 0x8c, 0xa1, 0xee, - 0x01, 0x02, 0xf0, 0x10, 0x88, 0x01, 0x43, 0xf7, 0xb8, 0xb0, 0xee, 0x01, - 0x45, 0x86, 0x9c, 0xbb, 0xee, 0x01, 0x43, 0x28, 0x21, 0xa7, 0xee, 0x01, - 0x44, 0x59, 0x38, 0xa2, 0xee, 0x01, 0x44, 0xa7, 0x41, 0xb7, 0xee, 0x01, - 0x43, 0xb0, 0x00, 0xab, 0xee, 0x01, 0x44, 0x1e, 0x21, 0xac, 0xee, 0x01, - 0x44, 0x00, 0x46, 0xad, 0xee, 0x01, 0x43, 0x43, 0x14, 0xb2, 0xee, 0x01, - 0x43, 0x3e, 0x52, 0xb3, 0xee, 0x01, 0xb3, 0x38, 0xb4, 0x1b, 0x43, 0x9f, - 0x8a, 0xa5, 0xee, 0x01, 0x43, 0x4d, 0x00, 0xa9, 0xee, 0x01, 0x02, 0x59, - 0x00, 0x01, 0xff, 0xe8, 0xba, 0xee, 0x01, 0x42, 0x9e, 0x01, 0xa6, 0xee, - 0x41, 0x42, 0x18, 0x0a, 0xa8, 0xee, 0x01, 0x42, 0x4e, 0x00, 0xb5, 0xee, - 0x01, 0xa8, 0x01, 0xff, 0x42, 0x13, 0x00, 0xb8, 0xee, 0x01, 0x42, 0x4e, - 0x00, 0xb6, 0xee, 0x41, 0x42, 0xe8, 0x01, 0xb1, 0xee, 0x01, 0x43, 0xc4, - 0x09, 0xae, 0xee, 0x01, 0x44, 0x6c, 0xdb, 0xb4, 0xee, 0x41, 0xe4, 0xb9, - 0xee, 0x01, 0xec, 0xa3, 0xee, 0x41, 0x43, 0xb8, 0x8c, 0x1c, 0xee, 0x01, - 0x43, 0xf7, 0xb8, 0x1e, 0xee, 0x01, 0x44, 0x00, 0x46, 0x1d, 0xee, 0x01, - 0x43, 0x43, 0x14, 0x1f, 0xee, 0x41, 0xe4, 0x19, 0xee, 0x01, 0xec, 0x03, - 0xee, 0x41, 0x42, 0x9e, 0x01, 0x0f, 0xee, 0x01, 0x43, 0x68, 0x00, 0x00, - 0xee, 0x41, 0x4b, 0x00, 0x46, 0x58, 0x06, 0x00, 0x54, 0xf7, 0x45, 0xff, - 0x08, 0x40, 0x47, 0xc4, 0xcd, 0x9c, 0x08, 0x00, 0x47, 0x6f, 0x2d, 0x53, - 0x06, 0x40, 0x05, 0x44, 0x1c, 0xc6, 0x41, 0xa5, 0xdf, 0x22, 0x08, 0x9f, - 0x1f, 0x01, 0xff, 0xa1, 0xbd, 0x20, 0xa2, 0x8c, 0x1f, 0x02, 0xf0, 0x10, - 0xe4, 0x1d, 0x09, 0xf7, 0xb8, 0xe3, 0x1c, 0x0b, 0x86, 0x9c, 0x84, 0x1c, - 0xa8, 0xb4, 0x1a, 0xaa, 0xa5, 0x19, 0xab, 0x8f, 0x17, 0x09, 0x4c, 0x14, - 0xc8, 0x14, 0xad, 0x85, 0x13, 0xae, 0x85, 0x11, 0xb1, 0xea, 0x0f, 0xb2, - 0xc5, 0x0e, 0xb3, 0x83, 0x08, 0xb4, 0x92, 0x04, 0x36, 0x3e, 0x00, 0xf8, - 0x03, 0x56, 0x28, 0x38, 0xf8, 0xfd, 0x00, 0x09, 0x4d, 0x00, 0x19, 0x0e, - 0x16, 0x7f, 0x01, 0xff, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, 0x3b, 0xfd, 0x40, - 0x4b, 0xb9, 0x16, 0xb9, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x28, 0xfc, 0x40, - 0x0d, 0x67, 0x00, 0xc4, 0x03, 0xa8, 0x83, 0x01, 0x05, 0x59, 0x38, 0x6b, - 0x06, 0x79, 0x5b, 0x5b, 0x05, 0x1e, 0x21, 0x22, 0x4f, 0xc9, 0x70, 0x94, - 0xfc, 0x00, 0x4e, 0xb2, 0x7b, 0x91, 0xfc, 0x00, 0x04, 0x4d, 0x00, 0x06, - 0x4f, 0x2e, 0x75, 0x92, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x96, 0xfc, 0x00, - 0x4d, 0x5f, 0x03, 0x5a, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x93, 0xfc, 0x00, - 0xa9, 0x21, 0x4b, 0xfd, 0x6d, 0xf0, 0xfc, 0x00, 0x05, 0x51, 0x00, 0x01, - 0xff, 0x05, 0x1e, 0x21, 0x06, 0x4e, 0xf5, 0x4e, 0xb0, 0xfd, 0x40, 0x4a, - 0x10, 0x2d, 0x9c, 0xfd, 0x00, 0x4c, 0xb8, 0x16, 0x9d, 0xfd, 0x40, 0x4b, - 0xb9, 0x16, 0xdd, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x58, 0xfc, 0x40, 0x4b, - 0xb9, 0x16, 0xdc, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x57, 0xfc, 0x40, 0xa9, - 0x06, 0x53, 0xf0, 0x4e, 0xaf, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xda, 0xfc, - 0x00, 0x4c, 0x60, 0x03, 0x55, 0xfc, 0x40, 0xa1, 0x11, 0x03, 0x4e, 0x00, - 0x01, 0xff, 0x4c, 0xb8, 0x16, 0xde, 0xfc, 0x00, 0x4b, 0xfd, 0x6d, 0xf1, - 0xfc, 0x40, 0x02, 0x4f, 0x00, 0x92, 0x02, 0x0f, 0x58, 0x00, 0x01, 0xff, - 0xa1, 0xd8, 0x01, 0x02, 0x60, 0x00, 0xbe, 0x01, 0xa8, 0x9a, 0x01, 0x06, - 0x59, 0x38, 0x89, 0x01, 0x51, 0x79, 0x5b, 0x99, 0xfc, 0x00, 0x05, 0x1e, - 0x21, 0x65, 0x4f, 0xc9, 0x70, 0x67, 0xfc, 0x00, 0x03, 0xf0, 0x97, 0x4f, - 0x4e, 0xb2, 0x7b, 0x64, 0xfc, 0x00, 0x02, 0x2e, 0x02, 0x39, 0x04, 0x49, - 0xf3, 0x29, 0xb9, 0x06, 0x4f, 0x2e, 0x75, 0x65, 0xfc, 0x40, 0x03, 0x4e, - 0x00, 0x11, 0x02, 0x2e, 0x02, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0xf5, 0xfb, - 0x00, 0x4d, 0x5f, 0x03, 0xf4, 0xfb, 0x40, 0x4a, 0x10, 0x2d, 0x69, 0xfc, - 0x00, 0x4d, 0x5f, 0x03, 0x04, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0xef, 0xfb, - 0x00, 0x4d, 0x5f, 0x03, 0xee, 0xfb, 0x40, 0x4a, 0x10, 0x2d, 0xf1, 0xfb, - 0x00, 0x4d, 0x5f, 0x03, 0xf0, 0xfb, 0x40, 0x4a, 0x10, 0x2d, 0xf3, 0xfb, - 0x00, 0x4d, 0x5f, 0x03, 0xf2, 0xfb, 0x40, 0x4a, 0x10, 0x2d, 0x66, 0xfc, - 0x00, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, 0xdf, 0xfc, 0x40, 0x4b, 0xb9, 0x16, - 0x9a, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x02, 0xfc, 0x40, 0x4b, 0xb9, 0x16, - 0x97, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x00, 0xfc, 0x40, 0x04, 0x7b, 0x5a, - 0x11, 0x03, 0x4e, 0x00, 0x01, 0xff, 0x4c, 0xb8, 0x16, 0x9b, 0xfc, 0x00, - 0x4b, 0xfd, 0x6d, 0xe0, 0xfc, 0x40, 0x4b, 0xb9, 0x16, 0x98, 0xfc, 0x00, - 0x4c, 0x60, 0x03, 0x01, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0xf7, 0xfb, 0x00, - 0xa9, 0x01, 0xff, 0x4b, 0xb9, 0x16, 0xf8, 0xfb, 0x00, 0x4c, 0x60, 0x03, - 0xf6, 0xfb, 0x40, 0x02, 0x60, 0x00, 0x22, 0x04, 0x68, 0x00, 0x01, 0xff, - 0x4a, 0x10, 0x2d, 0xeb, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0xea, 0xfb, 0x00, - 0x08, 0x6c, 0x00, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x68, 0xfc, 0x00, 0x4d, - 0x5f, 0x03, 0x03, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0xed, 0xfb, 0x00, 0x4d, - 0x5f, 0x03, 0xec, 0xfb, 0x40, 0xa9, 0x06, 0x53, 0xf0, 0x4e, 0xae, 0xfd, - 0x40, 0x4b, 0xb9, 0x16, 0xdb, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x56, 0xfc, - 0x40, 0x4a, 0x10, 0x2d, 0x95, 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x59, 0xfc, - 0x40, 0x4a, 0x10, 0x2d, 0xfa, 0xfb, 0x00, 0xa9, 0x01, 0xff, 0x4b, 0xb9, - 0x16, 0xfb, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0xf9, 0xfb, 0x40, 0xa1, 0xf6, - 0x02, 0x08, 0x4e, 0x00, 0x6a, 0xa8, 0x01, 0xff, 0x66, 0x67, 0x06, 0x5b, - 0xfc, 0x00, 0x08, 0x4e, 0x00, 0x01, 0xff, 0x0d, 0x67, 0x00, 0x4c, 0x4f, - 0xf9, 0x6d, 0xe6, 0xfc, 0x00, 0x52, 0x18, 0x53, 0x11, 0xfc, 0x00, 0x05, - 0x1e, 0x21, 0x22, 0x4f, 0xc9, 0x70, 0x79, 0xfc, 0x00, 0x4e, 0xb2, 0x7b, - 0x76, 0xfc, 0x00, 0x04, 0x4d, 0x00, 0x06, 0x4f, 0x2e, 0x75, 0x77, 0xfc, - 0x40, 0x4a, 0x10, 0x2d, 0x7b, 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x14, 0xfc, - 0x40, 0x4a, 0x10, 0x2d, 0x78, 0xfc, 0x00, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, - 0xe5, 0xfc, 0x40, 0x4b, 0xb9, 0x16, 0xa6, 0xfc, 0x00, 0x4c, 0x60, 0x03, - 0x12, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x7a, 0xfc, 0x00, 0x4d, 0x5f, 0x03, - 0x13, 0xfc, 0x40, 0x0d, 0x67, 0x00, 0xf7, 0x01, 0xa8, 0xb6, 0x01, 0x05, - 0x59, 0x38, 0x8c, 0x01, 0x05, 0x79, 0x5b, 0x63, 0x05, 0x1e, 0x21, 0x22, - 0x4f, 0xc9, 0x70, 0x73, 0xfc, 0x00, 0x4e, 0xb2, 0x7b, 0x70, 0xfc, 0x00, - 0x04, 0x4d, 0x00, 0x06, 0x4f, 0x2e, 0x75, 0x71, 0xfc, 0x40, 0x4a, 0x10, - 0x2d, 0x75, 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x10, 0xfc, 0x40, 0x4a, 0x10, - 0x2d, 0x72, 0xfc, 0x00, 0xa9, 0x29, 0x4b, 0xfd, 0x6d, 0xe3, 0xfc, 0x00, - 0x05, 0x51, 0x00, 0x01, 0xff, 0x57, 0x03, 0x2d, 0xa4, 0xfd, 0x00, 0x50, - 0x7a, 0x5b, 0x56, 0xfd, 0x00, 0x51, 0x59, 0x38, 0x55, 0xfd, 0x00, 0x51, - 0x79, 0x5b, 0x57, 0xfd, 0x00, 0x4e, 0xf5, 0x4e, 0xa3, 0xfd, 0x40, 0x4b, - 0xb9, 0x16, 0xa4, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x0e, 0xfc, 0x40, 0xa9, - 0x17, 0x05, 0x51, 0x00, 0x01, 0xff, 0x57, 0x03, 0x2d, 0xa2, 0xfd, 0x00, - 0x51, 0x45, 0x5c, 0x54, 0xfd, 0x00, 0x4e, 0xf5, 0x4e, 0xa1, 0xfd, 0x40, - 0x4b, 0xb9, 0x16, 0xa3, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x0d, 0xfc, 0x40, - 0xa9, 0x17, 0x05, 0x51, 0x00, 0x01, 0xff, 0x57, 0x03, 0x2d, 0xa0, 0xfd, - 0x00, 0x51, 0x45, 0x5c, 0x50, 0xfd, 0x00, 0x4e, 0xf5, 0x4e, 0x9f, 0xfd, - 0x40, 0x4b, 0xb9, 0x16, 0xa1, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x0b, 0xfc, - 0x40, 0x03, 0x18, 0x0a, 0x11, 0x03, 0x4e, 0x00, 0x01, 0xff, 0x4c, 0xb8, - 0x16, 0xa5, 0xfc, 0x00, 0x4b, 0xfd, 0x6d, 0xe4, 0xfc, 0x40, 0xa9, 0x1b, - 0x05, 0x51, 0x00, 0x01, 0xff, 0x05, 0x59, 0x38, 0x06, 0x51, 0x45, 0x5c, - 0x53, 0xfd, 0x40, 0x4a, 0x10, 0x2d, 0x51, 0xfd, 0x00, 0x4c, 0xb8, 0x16, - 0x52, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xa2, 0xfc, 0x00, 0x4c, 0x60, 0x03, - 0x0c, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x74, 0xfc, 0x00, 0x4d, 0x5f, 0x03, - 0x0f, 0xfc, 0x40, 0x52, 0x90, 0x50, 0x4e, 0xfd, 0x00, 0x07, 0x4f, 0x00, - 0x01, 0xff, 0x0d, 0x67, 0x00, 0x5a, 0x05, 0x7a, 0x5a, 0x4a, 0x05, 0x1e, - 0x21, 0x11, 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x12, 0xfd, - 0x00, 0x4d, 0x5f, 0x03, 0xf6, 0xfc, 0x40, 0xa9, 0x27, 0x4b, 0xfd, 0x6d, - 0x3a, 0xfd, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x04, 0x28, 0x21, 0x0c, - 0x51, 0x45, 0x5c, 0x73, 0xfd, 0x00, 0x4e, 0xf5, 0x4e, 0x74, 0xfd, 0x40, - 0x4a, 0x10, 0x2d, 0x71, 0xfd, 0x00, 0x4c, 0xb8, 0x16, 0x72, 0xfd, 0x40, - 0x4b, 0xb9, 0x16, 0x33, 0xfd, 0x00, 0x4c, 0x60, 0x03, 0x27, 0xfc, 0x40, - 0x4b, 0xb9, 0x16, 0xb8, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x26, 0xfc, 0x40, - 0x4a, 0x10, 0x2d, 0x11, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0xf5, 0xfc, 0x40, - 0xa1, 0xde, 0x04, 0x09, 0x43, 0xb8, 0xde, 0x02, 0xa8, 0x06, 0x54, 0x5b, - 0x46, 0xfe, 0xfd, 0x40, 0x0a, 0x8e, 0xa7, 0x8b, 0x02, 0x09, 0x43, 0xb8, - 0x01, 0xff, 0x0d, 0x67, 0x00, 0xf5, 0x01, 0xa8, 0xa8, 0x01, 0x05, 0x59, - 0x38, 0x83, 0x01, 0x05, 0x79, 0x5b, 0x65, 0x05, 0x1e, 0x21, 0x21, 0x04, - 0xb2, 0x7b, 0x11, 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x1a, - 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0xfe, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x29, - 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0x0d, 0xfd, 0x40, 0x4a, 0x10, 0x2d, 0x28, - 0xfd, 0x00, 0xa9, 0x2c, 0x4b, 0xfd, 0x6d, 0xe9, 0xfc, 0x00, 0x05, 0x51, - 0x00, 0x01, 0xff, 0x05, 0x79, 0x5b, 0x11, 0x05, 0x1e, 0x21, 0x01, 0xff, - 0x4a, 0x10, 0x2d, 0x6c, 0xfd, 0x00, 0x4c, 0xb8, 0x16, 0x6d, 0xfd, 0x40, - 0x4a, 0x10, 0x2d, 0x6a, 0xfd, 0x00, 0x4c, 0xb8, 0x16, 0x6b, 0xfd, 0x40, - 0x4b, 0xb9, 0x16, 0x30, 0xfd, 0x00, 0x4c, 0x60, 0x03, 0x0c, 0xfd, 0x40, - 0x4a, 0x10, 0x2d, 0x27, 0xfd, 0x00, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, 0x39, - 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0x2f, 0xfd, 0x00, 0x4c, 0x60, 0x03, 0x0b, - 0xfd, 0x40, 0x4a, 0x10, 0x2d, 0x25, 0xfd, 0x00, 0xa9, 0x0c, 0x4b, 0xfd, - 0x6d, 0x37, 0xfd, 0x00, 0x53, 0xf0, 0x4e, 0x69, 0xfd, 0x40, 0x4b, 0xb9, - 0x16, 0x2d, 0xfd, 0x00, 0x4c, 0x60, 0x03, 0x09, 0xfd, 0x40, 0x03, 0x18, - 0x0a, 0x11, 0x03, 0x4e, 0x00, 0x01, 0xff, 0x4c, 0xb8, 0x16, 0x32, 0xfd, - 0x00, 0x4b, 0xfd, 0x6d, 0xea, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x26, 0xfd, - 0x00, 0xa9, 0x21, 0x4b, 0xfd, 0x6d, 0x38, 0xfd, 0x00, 0x05, 0x51, 0x00, - 0x01, 0xff, 0x05, 0x1e, 0x21, 0x06, 0x4e, 0xf5, 0x4e, 0xaa, 0xfd, 0x40, - 0x4a, 0x10, 0x2d, 0x67, 0xfd, 0x00, 0x4c, 0xb8, 0x16, 0x68, 0xfd, 0x40, - 0x4b, 0xb9, 0x16, 0x2e, 0xfd, 0x00, 0x4c, 0x60, 0x03, 0x0a, 0xfd, 0x40, - 0x4a, 0x10, 0x2d, 0x19, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0xfd, 0xfc, 0x40, - 0x05, 0xf3, 0x5e, 0x2e, 0x06, 0xda, 0xdb, 0x1e, 0x05, 0xaf, 0x50, 0x06, - 0x5e, 0x6f, 0x06, 0x63, 0xfc, 0x40, 0x80, 0x06, 0x51, 0x21, 0x5e, 0x5f, - 0xfc, 0x40, 0x4d, 0x5f, 0x03, 0x62, 0xfc, 0x00, 0x4b, 0xfd, 0x6d, 0xf4, - 0xfc, 0x40, 0x4d, 0x5f, 0x03, 0x60, 0xfc, 0x00, 0x4b, 0xfd, 0x6d, 0xf2, - 0xfc, 0x40, 0x80, 0x06, 0x51, 0x21, 0x5e, 0x5e, 0xfc, 0x40, 0x4d, 0x5f, - 0x03, 0x61, 0xfc, 0x00, 0x4b, 0xfd, 0x6d, 0xf3, 0xfc, 0x40, 0x0d, 0x67, - 0x00, 0xea, 0x01, 0xa8, 0xb8, 0x01, 0x05, 0x59, 0x38, 0x8e, 0x01, 0x05, - 0x79, 0x5b, 0x65, 0x05, 0x1e, 0x21, 0x21, 0x04, 0xb2, 0x7b, 0x11, 0x04, - 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x18, 0xfd, 0x00, 0x4d, 0x5f, - 0x03, 0xfc, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x2a, 0xfd, 0x00, 0x4d, 0x5f, - 0x03, 0x0e, 0xfd, 0x40, 0xa9, 0x32, 0x4b, 0xfd, 0x6d, 0xe7, 0xfc, 0x00, - 0x05, 0x51, 0x00, 0x01, 0xff, 0x04, 0x28, 0x21, 0x17, 0x51, 0x59, 0x38, - 0x61, 0xfd, 0x00, 0x05, 0x1e, 0x21, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x62, - 0xfd, 0x00, 0x4c, 0xb8, 0x16, 0x63, 0xfd, 0x40, 0x4a, 0x10, 0x2d, 0x5f, - 0xfd, 0x00, 0x4c, 0xb8, 0x16, 0x60, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xb0, - 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x1f, 0xfc, 0x40, 0xa9, 0x17, 0x4b, 0xfd, - 0x6d, 0x36, 0xfd, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x57, 0x03, 0x2d, - 0xa8, 0xfd, 0x00, 0x4e, 0xf5, 0x4e, 0xc6, 0xfd, 0x40, 0x4b, 0xb9, 0x16, - 0xaf, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x1e, 0xfc, 0x40, 0xa9, 0x17, 0x4b, - 0xfd, 0x6d, 0x34, 0xfd, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x57, 0x03, - 0x2d, 0x5e, 0xfd, 0x00, 0x50, 0x7a, 0x5b, 0x5d, 0xfd, 0x40, 0x4b, 0xb9, - 0x16, 0xad, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x1c, 0xfc, 0x40, 0x03, 0x18, - 0x0a, 0x11, 0x03, 0x4e, 0x00, 0x01, 0xff, 0x4c, 0xb8, 0x16, 0x31, 0xfd, - 0x00, 0x4b, 0xfd, 0x6d, 0xe8, 0xfc, 0x40, 0xa9, 0x0c, 0x4b, 0xfd, 0x6d, - 0x35, 0xfd, 0x00, 0x56, 0x54, 0x38, 0x5c, 0xfd, 0x40, 0x4b, 0xb9, 0x16, - 0xae, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x1d, 0xfc, 0x40, 0x4a, 0x10, 0x2d, - 0x17, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0xfb, 0xfc, 0x40, 0x07, 0xa2, 0x0a, - 0x53, 0xac, 0x01, 0xff, 0xa1, 0x42, 0x02, 0x74, 0x00, 0x01, 0xff, 0x80, - 0x2f, 0x03, 0x2c, 0x0e, 0x01, 0xff, 0x04, 0x73, 0x19, 0x1a, 0xa8, 0x01, - 0xff, 0x52, 0x4a, 0x54, 0xfa, 0xfd, 0x00, 0x0b, 0x21, 0xa4, 0x01, 0xff, - 0x57, 0xec, 0x2c, 0xcc, 0xfd, 0x00, 0x51, 0xf2, 0x2c, 0x4c, 0xfd, 0x40, - 0x4f, 0x93, 0x6a, 0x46, 0xfd, 0x00, 0x58, 0x71, 0x2b, 0xd0, 0xfb, 0x40, - 0x4d, 0x5f, 0x03, 0xf9, 0xfd, 0x00, 0x67, 0x45, 0x03, 0xf0, 0xfd, 0x40, - 0x4d, 0x6a, 0x80, 0xcf, 0xfd, 0x00, 0x4f, 0x2f, 0x38, 0xf5, 0xfd, 0x40, - 0x0d, 0x67, 0x00, 0x77, 0x04, 0x28, 0x21, 0x4a, 0x51, 0x79, 0x5b, 0xb2, - 0xfc, 0x00, 0x05, 0x1e, 0x21, 0x21, 0x04, 0xb2, 0x7b, 0x11, 0x04, 0x4d, - 0x00, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x22, 0xfd, 0x00, 0x4d, 0x5f, 0x03, - 0x06, 0xfd, 0x40, 0x4a, 0x10, 0x2d, 0x2b, 0xfd, 0x00, 0x4d, 0x5f, 0x03, - 0x0f, 0xfd, 0x40, 0xa9, 0x11, 0x0a, 0x1a, 0x7f, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0x66, 0xfd, 0x00, 0x4c, 0xb8, 0x16, 0xc5, 0xfd, 0x40, 0x4b, 0xb9, - 0x16, 0xb3, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x21, 0xfc, 0x40, 0xa9, 0x1b, - 0x05, 0x51, 0x00, 0x01, 0xff, 0x04, 0x28, 0x21, 0x06, 0x4e, 0xf5, 0x4e, - 0xa9, 0xfd, 0x40, 0x4a, 0x10, 0x2d, 0x64, 0xfd, 0x00, 0x4c, 0xb8, 0x16, - 0x65, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xb1, 0xfc, 0x00, 0x4c, 0x60, 0x03, - 0x20, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x21, 0xfd, 0x00, 0x4d, 0x5f, 0x03, - 0x05, 0xfd, 0x40, 0xa1, 0x06, 0x66, 0xb3, 0x06, 0x5c, 0xfc, 0x40, 0x0b, - 0x10, 0x9b, 0x5b, 0xa8, 0x06, 0x52, 0x8e, 0x55, 0xf6, 0xfd, 0x40, 0x05, - 0x83, 0xe7, 0x25, 0x0d, 0xcc, 0x85, 0x01, 0xff, 0x45, 0xf4, 0x20, 0x90, - 0xfd, 0x80, 0x06, 0x4d, 0x71, 0x2b, 0xc5, 0xfb, 0x40, 0x42, 0x80, 0x12, - 0x91, 0xfd, 0x00, 0x42, 0x29, 0x02, 0xc6, 0xfb, 0xc0, 0x00, 0x42, 0x80, - 0x12, 0xc7, 0xfb, 0x40, 0x47, 0xd8, 0x2d, 0x40, 0xfd, 0x80, 0x1d, 0xad, - 0x01, 0xff, 0x47, 0xd8, 0x2d, 0x4f, 0xfd, 0x80, 0x0d, 0x49, 0x00, 0x50, - 0xc9, 0xfb, 0xc0, 0x00, 0x49, 0x09, 0x50, 0xca, 0xfb, 0x40, 0x49, 0x09, - 0x50, 0xc8, 0xfb, 0x40, 0x48, 0x67, 0x46, 0xc8, 0xfd, 0x40, 0x43, 0x15, - 0x6c, 0x41, 0xfd, 0x80, 0x1a, 0x4b, 0x50, 0xa3, 0xc9, 0xfd, 0xc0, 0x00, - 0x42, 0x80, 0x12, 0xca, 0xfd, 0x00, 0x42, 0x48, 0x04, 0xcb, 0xfb, 0xc0, - 0x00, 0x42, 0x80, 0x12, 0xcb, 0xfd, 0x40, 0x42, 0x80, 0x12, 0x42, 0xfd, - 0x00, 0xb5, 0x01, 0xff, 0xed, 0x43, 0xfd, 0x80, 0x06, 0x43, 0x08, 0x46, - 0x45, 0xfd, 0x40, 0x42, 0x80, 0x12, 0x44, 0xfd, 0x40, 0xa1, 0x22, 0x06, - 0x08, 0xe1, 0x01, 0xff, 0x05, 0x90, 0x41, 0x06, 0x4c, 0xac, 0x95, 0xd7, - 0x0e, 0x41, 0x42, 0x18, 0x0a, 0x4b, 0xfd, 0x00, 0x44, 0x23, 0x58, 0xd5, - 0x0e, 0xc1, 0x00, 0x42, 0x80, 0x12, 0xd6, 0x0e, 0x41, 0x54, 0x83, 0x41, - 0xd4, 0x0e, 0x01, 0x07, 0x45, 0x14, 0x06, 0x6a, 0x42, 0x03, 0xf1, 0xfd, - 0x40, 0x0d, 0x67, 0x00, 0x54, 0x05, 0x7a, 0x5a, 0x44, 0x05, 0x1e, 0x21, - 0x11, 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x7f, 0xfc, 0x00, - 0x4d, 0x5f, 0x03, 0x36, 0xfc, 0x40, 0xa9, 0x21, 0x05, 0x51, 0x00, 0x01, - 0xff, 0x04, 0x28, 0x21, 0x0c, 0x4f, 0x42, 0x70, 0x7f, 0xfd, 0x00, 0x4e, - 0xf5, 0x4e, 0xb2, 0xfd, 0x40, 0x4a, 0x10, 0x2d, 0x7e, 0xfd, 0x00, 0x4c, - 0xb8, 0x16, 0xb4, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xc3, 0xfc, 0x00, 0x4c, - 0x60, 0x03, 0x34, 0xfc, 0x40, 0x4b, 0xb9, 0x16, 0xc2, 0xfc, 0x00, 0x4c, - 0x60, 0x03, 0x33, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x7e, 0xfc, 0x00, 0x4d, - 0x5f, 0x03, 0x35, 0xfc, 0x40, 0x57, 0xd2, 0x2d, 0xd8, 0x0e, 0x01, 0x09, - 0x94, 0x05, 0x01, 0xff, 0x0d, 0x67, 0x00, 0xe1, 0x01, 0xa8, 0xa4, 0x01, - 0x05, 0x59, 0x38, 0x61, 0x06, 0x79, 0x5b, 0x51, 0x05, 0x1e, 0x21, 0x22, - 0x4f, 0xc9, 0x70, 0x8d, 0xfc, 0x00, 0x4e, 0xb2, 0x7b, 0x8a, 0xfc, 0x00, - 0x04, 0x4d, 0x00, 0x06, 0x4f, 0x2e, 0x75, 0x8b, 0xfc, 0x40, 0x4a, 0x10, - 0x2d, 0x8f, 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x50, 0xfc, 0x40, 0x4a, 0x10, - 0x2d, 0x8c, 0xfc, 0x00, 0xa9, 0x17, 0x4b, 0xfd, 0x6d, 0xee, 0xfc, 0x00, - 0x05, 0x51, 0x00, 0x01, 0xff, 0x57, 0x03, 0x2d, 0x9b, 0xfd, 0x00, 0x4e, - 0xf5, 0x4e, 0x9a, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xd5, 0xfc, 0x00, 0x4c, - 0x60, 0x03, 0x4e, 0xfc, 0x40, 0x4b, 0xb9, 0x16, 0xd4, 0xfc, 0x00, 0x4c, - 0x60, 0x03, 0x4d, 0xfc, 0x40, 0xa9, 0x31, 0x05, 0x51, 0x00, 0x01, 0xff, - 0x57, 0x03, 0x2d, 0x99, 0xfd, 0x00, 0x04, 0x28, 0x21, 0x16, 0x05, 0x1e, - 0x21, 0x06, 0x4e, 0xf5, 0x4e, 0xc7, 0xfd, 0x40, 0x4a, 0x10, 0x2d, 0x97, - 0xfd, 0x00, 0x4c, 0xb8, 0x16, 0x98, 0xfd, 0x40, 0x4a, 0x10, 0x2d, 0xbd, - 0xfd, 0x00, 0x4c, 0xb8, 0x16, 0xb8, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xd2, - 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x4b, 0xfc, 0x40, 0x03, 0x18, 0x0a, 0x11, - 0x03, 0x4e, 0x00, 0x01, 0xff, 0x4c, 0xb8, 0x16, 0xd6, 0xfc, 0x00, 0x4b, - 0xfd, 0x6d, 0xef, 0xfc, 0x40, 0xa9, 0x17, 0x05, 0x51, 0x00, 0x01, 0xff, - 0x57, 0x03, 0x2d, 0x96, 0xfd, 0x00, 0x51, 0x45, 0x5c, 0x95, 0xfd, 0x00, - 0x4e, 0xf5, 0x4e, 0xb3, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xd3, 0xfc, 0x00, - 0x4c, 0x60, 0x03, 0x4c, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x8e, 0xfc, 0x00, - 0x4d, 0x5f, 0x03, 0x4f, 0xfc, 0x40, 0x09, 0x1f, 0x21, 0x06, 0x55, 0x58, - 0x3d, 0xf4, 0xfd, 0x40, 0x05, 0x67, 0x00, 0xa5, 0x01, 0x04, 0x28, 0x21, - 0x7c, 0x05, 0x59, 0x38, 0x4d, 0x05, 0x79, 0x5b, 0x24, 0x05, 0x1e, 0x21, - 0x06, 0x51, 0xdb, 0x5f, 0x4a, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x89, 0xfc, - 0x00, 0xa9, 0x06, 0x53, 0xf0, 0x4e, 0xb1, 0xfd, 0x40, 0x4b, 0xb9, 0x16, - 0xd1, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x48, 0xfc, 0x40, 0xa9, 0x17, 0x05, - 0x51, 0x00, 0x01, 0xff, 0x51, 0x59, 0x38, 0x8e, 0xfd, 0x00, 0x51, 0x45, - 0x5c, 0x8f, 0xfd, 0x00, 0x4e, 0xf5, 0x4e, 0xb9, 0xfd, 0x40, 0x4b, 0xb9, - 0x16, 0xd0, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x47, 0xfc, 0x40, 0xa9, 0x1d, - 0x05, 0x51, 0x00, 0x01, 0xff, 0x50, 0x7a, 0x5b, 0x8c, 0xfd, 0x00, 0x51, - 0x79, 0x5b, 0x92, 0xfd, 0x00, 0x51, 0x45, 0x5c, 0x8d, 0xfd, 0x00, 0x4e, - 0xf5, 0x4e, 0xc0, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xce, 0xfc, 0x00, 0x4c, - 0x60, 0x03, 0x45, 0xfc, 0x40, 0xa9, 0x17, 0x05, 0x51, 0x00, 0x01, 0xff, - 0x51, 0x59, 0x38, 0x89, 0xfd, 0x00, 0x51, 0x45, 0x5c, 0x8a, 0xfd, 0x00, - 0x4e, 0xf5, 0x4e, 0x8b, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xcf, 0xfc, 0x00, - 0x4c, 0x60, 0x03, 0x46, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x88, 0xfc, 0x00, - 0x55, 0x01, 0x1f, 0x49, 0xfc, 0x40, 0x05, 0x67, 0x00, 0xe6, 0x01, 0xa8, - 0xaa, 0x01, 0x05, 0x59, 0x38, 0x6d, 0x05, 0x79, 0x5b, 0x4a, 0x05, 0x1e, - 0x21, 0x11, 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x87, 0xfc, - 0x00, 0x4d, 0x5f, 0x03, 0x44, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x85, 0xfc, - 0x00, 0xa9, 0x21, 0x4b, 0xfd, 0x6d, 0xed, 0xfc, 0x00, 0x05, 0x51, 0x00, - 0x01, 0xff, 0x04, 0x28, 0x21, 0x06, 0x4e, 0xf5, 0x4e, 0xad, 0xfd, 0x40, - 0x4a, 0x10, 0x2d, 0x87, 0xfd, 0x00, 0x4c, 0xb8, 0x16, 0x88, 0xfd, 0x40, - 0x4b, 0xb9, 0x16, 0xcc, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x42, 0xfc, 0x40, - 0xa9, 0x11, 0x0a, 0x1a, 0x7f, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x85, 0xfd, - 0x00, 0x4c, 0xb8, 0x16, 0x86, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xcb, 0xfc, - 0x00, 0x4c, 0x60, 0x03, 0x41, 0xfc, 0x40, 0xa9, 0x2b, 0x05, 0x51, 0x00, - 0x01, 0xff, 0x05, 0x59, 0x38, 0x16, 0x05, 0x1e, 0x21, 0x06, 0x4e, 0xf5, - 0x4e, 0xac, 0xfd, 0x40, 0x4a, 0x10, 0x2d, 0xbc, 0xfd, 0x00, 0x4c, 0xb8, - 0x16, 0xba, 0xfd, 0x40, 0x4a, 0x10, 0x2d, 0x84, 0xfd, 0x00, 0x4c, 0xb8, - 0x16, 0x83, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xc9, 0xfc, 0x00, 0x4c, 0x60, - 0x03, 0x3f, 0xfc, 0x40, 0x03, 0x18, 0x0a, 0x06, 0x4f, 0xaf, 0x6c, 0xcd, - 0xfc, 0x40, 0xa9, 0x21, 0x05, 0x51, 0x00, 0x01, 0xff, 0x57, 0x03, 0x2d, - 0x82, 0xfd, 0x00, 0x05, 0x1e, 0x21, 0x06, 0x4e, 0xf5, 0x4e, 0x81, 0xfd, - 0x40, 0x4a, 0x10, 0x2d, 0x80, 0xfd, 0x00, 0x4c, 0xb8, 0x16, 0xb5, 0xfd, - 0x40, 0x4b, 0xb9, 0x16, 0xca, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x40, 0xfc, - 0x40, 0x4a, 0x10, 0x2d, 0xfc, 0xfe, 0x00, 0x4d, 0x5f, 0x03, 0xfb, 0xfe, - 0x00, 0x08, 0x6c, 0x00, 0x3b, 0x05, 0x51, 0x00, 0x01, 0xff, 0x06, 0x56, - 0x00, 0x11, 0x0c, 0xc8, 0x91, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0xf6, 0xfe, - 0x00, 0x4d, 0x5f, 0x03, 0xf5, 0xfe, 0x40, 0x06, 0x5c, 0x00, 0x11, 0x06, - 0xa3, 0x12, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0xfa, 0xfe, 0x00, 0x4d, 0x5f, - 0x03, 0xf9, 0xfe, 0x40, 0x4a, 0x10, 0x2d, 0xf8, 0xfe, 0x00, 0x4d, 0x5f, - 0x03, 0xf7, 0xfe, 0x40, 0x4a, 0x10, 0x2d, 0x86, 0xfc, 0x00, 0x4d, 0x5f, - 0x03, 0x43, 0xfc, 0x40, 0xa1, 0x4c, 0x09, 0x28, 0x21, 0x01, 0xff, 0x0d, - 0x67, 0x00, 0x37, 0x51, 0x7a, 0x5a, 0x1a, 0xfc, 0x00, 0x06, 0x59, 0x38, - 0x21, 0x06, 0x45, 0x5c, 0x11, 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0x20, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0x04, 0xfd, 0x40, 0x4b, 0xb9, - 0x16, 0xac, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x1b, 0xfc, 0x40, 0x4b, 0xb9, - 0x16, 0xab, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x19, 0xfc, 0x40, 0x4a, 0x10, - 0x2d, 0x1f, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0x03, 0xfd, 0x40, 0x07, 0x45, - 0x14, 0x06, 0x54, 0x93, 0x45, 0xce, 0xfd, 0x40, 0x05, 0x67, 0x00, 0x99, - 0x01, 0x05, 0x7a, 0x5a, 0x88, 0x01, 0x06, 0x59, 0x38, 0x78, 0x06, 0x79, - 0x5b, 0x68, 0x04, 0x4c, 0x14, 0x4a, 0x05, 0x1e, 0x21, 0x11, 0x04, 0x4d, - 0x00, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x84, 0xfc, 0x00, 0x4d, 0x5f, 0x03, - 0x3e, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x82, 0xfc, 0x00, 0xa9, 0x21, 0x4b, - 0xfd, 0x6d, 0xec, 0xfc, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x05, 0x1e, - 0x21, 0x06, 0x4e, 0xf5, 0x4e, 0xb7, 0xfd, 0x40, 0x4a, 0x10, 0x2d, 0xbb, - 0xfd, 0x00, 0x4c, 0xb8, 0x16, 0xc3, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xc8, - 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x3c, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x81, - 0xfc, 0x00, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, 0xeb, 0xfc, 0x40, 0x4b, 0xb9, - 0x16, 0xc7, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x3b, 0xfc, 0x40, 0x4b, 0xb9, - 0x16, 0xc6, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x3a, 0xfc, 0x40, 0x4b, 0xb9, - 0x16, 0xc4, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x38, 0xfc, 0x40, 0x4b, 0xb9, - 0x16, 0xc5, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x39, 0xfc, 0x40, 0x4a, 0x10, - 0x2d, 0x80, 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x37, 0xfc, 0x00, 0x08, 0x6c, - 0x00, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x83, 0xfc, 0x00, 0x4d, 0x5f, 0x03, - 0x3d, 0xfc, 0x40, 0x04, 0xec, 0x20, 0x7c, 0x09, 0x1f, 0x21, 0x01, 0xff, - 0x0d, 0x67, 0x00, 0x67, 0x04, 0x28, 0x21, 0x44, 0x05, 0x1e, 0x21, 0x11, - 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x1e, 0xfd, 0x00, 0x4d, - 0x5f, 0x03, 0x02, 0xfd, 0x40, 0xa9, 0x21, 0x05, 0x51, 0x00, 0x01, 0xff, - 0x57, 0x03, 0x2d, 0xa7, 0xfd, 0x00, 0x04, 0x28, 0x21, 0x06, 0x4e, 0xf5, - 0x4e, 0xa5, 0xfd, 0x40, 0x4a, 0x10, 0x2d, 0x58, 0xfd, 0x00, 0x4c, 0xb8, - 0x16, 0x59, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xa8, 0xfc, 0x00, 0x4c, 0x60, - 0x03, 0x16, 0xfc, 0x40, 0xa9, 0x11, 0x05, 0x51, 0x00, 0x01, 0xff, 0x57, - 0x03, 0x2d, 0xa6, 0xfd, 0x00, 0x4e, 0xf5, 0x4e, 0xbe, 0xfd, 0x40, 0x4b, - 0xb9, 0x16, 0xa7, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x15, 0xfc, 0x40, 0x4a, - 0x10, 0x2d, 0x1d, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0x01, 0xfd, 0x40, 0x48, - 0xc9, 0xc2, 0xc3, 0xfb, 0x00, 0x4a, 0x52, 0xac, 0xfb, 0xfd, 0x40, 0xa1, - 0x4a, 0x08, 0x4e, 0x00, 0x01, 0xff, 0x5a, 0xfc, 0x1e, 0x53, 0xfc, 0x00, - 0x06, 0x59, 0x38, 0x2f, 0x05, 0x1e, 0x21, 0x0c, 0x5d, 0xa7, 0x16, 0xd9, - 0xfc, 0x00, 0x51, 0xdb, 0x5f, 0x54, 0xfc, 0x40, 0xa9, 0x11, 0x05, 0x51, - 0x00, 0x01, 0xff, 0x51, 0x59, 0x38, 0x93, 0xfd, 0x00, 0x51, 0x45, 0x5c, - 0x94, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xd8, 0xfc, 0x00, 0x4c, 0x60, 0x03, - 0x52, 0xfc, 0x40, 0x4b, 0xb9, 0x16, 0xd7, 0xfc, 0x00, 0x4c, 0x60, 0x03, - 0x51, 0xfc, 0x40, 0x06, 0xe6, 0xdb, 0x61, 0x07, 0x4f, 0x00, 0x01, 0xff, - 0x0d, 0x67, 0x00, 0x4c, 0x05, 0x59, 0x38, 0x34, 0x05, 0x1e, 0x21, 0x11, - 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x1c, 0xfd, 0x00, 0x4d, - 0x5f, 0x03, 0x00, 0xfd, 0x40, 0xa9, 0x11, 0x05, 0x51, 0x00, 0x01, 0xff, - 0x57, 0x03, 0x2d, 0x5b, 0xfd, 0x00, 0x4e, 0xf5, 0x4e, 0x5a, 0xfd, 0x40, - 0x4b, 0xb9, 0x16, 0xaa, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x18, 0xfc, 0x40, - 0xa9, 0x06, 0x53, 0xf0, 0x4e, 0xbf, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xa9, - 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x17, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x1b, - 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0xff, 0xfc, 0x40, 0x47, 0xd8, 0x2d, 0xcc, - 0xfb, 0x80, 0x0f, 0xad, 0x01, 0xff, 0x50, 0x02, 0x50, 0xce, 0xfb, 0x00, - 0x52, 0x00, 0x50, 0xcf, 0xfb, 0x40, 0x49, 0x09, 0x50, 0xcd, 0xfb, 0x40, - 0x0d, 0x67, 0x00, 0x4a, 0x06, 0x59, 0x38, 0x3a, 0x05, 0x1e, 0x21, 0x11, - 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x16, 0xfd, 0x00, 0x4d, - 0x5f, 0x03, 0xfa, 0xfc, 0x40, 0xa9, 0x17, 0x05, 0x51, 0x00, 0x01, 0xff, - 0x57, 0x03, 0x2d, 0x7b, 0xfd, 0x00, 0x4f, 0x42, 0x70, 0x79, 0xfd, 0x00, - 0x4e, 0xf5, 0x4e, 0x7a, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xbd, 0xfc, 0x00, - 0x4c, 0x60, 0x03, 0x2c, 0xfc, 0x40, 0x4b, 0xb9, 0x16, 0xbc, 0xfc, 0x00, - 0x4c, 0x60, 0x03, 0x2b, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x15, 0xfd, 0x00, - 0x4d, 0x5f, 0x03, 0xf9, 0xfc, 0x40, 0x0d, 0x67, 0x00, 0x6c, 0x05, 0x7a, - 0x5a, 0x5c, 0x06, 0x59, 0x38, 0x4c, 0x05, 0x79, 0x5b, 0x29, 0x05, 0x1e, - 0x21, 0x11, 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x7d, 0xfc, - 0x00, 0x4d, 0x5f, 0x03, 0x32, 0xfc, 0x40, 0xa9, 0x06, 0x53, 0xf0, 0x4e, - 0xc1, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xc1, 0xfc, 0x00, 0x4c, 0x60, 0x03, - 0x30, 0xfc, 0x40, 0xa9, 0x11, 0x0a, 0x1a, 0x7f, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0x7c, 0xfd, 0x00, 0x4c, 0xb8, 0x16, 0x7d, 0xfd, 0x40, 0x4b, 0xb9, - 0x16, 0xc0, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x2f, 0xfc, 0x40, 0x4b, 0xb9, - 0x16, 0xbe, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x2d, 0xfc, 0x40, 0x4b, 0xb9, - 0x16, 0xbf, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x2e, 0xfc, 0x40, 0x4a, 0x10, - 0x2d, 0x7c, 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x31, 0xfc, 0x40, 0x51, 0x16, - 0x58, 0xc4, 0xfb, 0x00, 0x07, 0xa2, 0x0a, 0x01, 0xff, 0x0d, 0x67, 0x00, - 0x87, 0x01, 0x04, 0x28, 0x21, 0x64, 0x06, 0x59, 0x38, 0x54, 0x05, 0x79, - 0x5b, 0x31, 0x06, 0x45, 0x5c, 0x21, 0x04, 0xb2, 0x7b, 0x11, 0x04, 0x4d, - 0x00, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x24, 0xfd, 0x00, 0x4d, 0x5f, 0x03, - 0x08, 0xfd, 0x40, 0x4a, 0x10, 0x2d, 0x2c, 0xfd, 0x00, 0x4d, 0x5f, 0x03, - 0x10, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xb7, 0xfc, 0x00, 0x4c, 0x60, 0x03, - 0x25, 0xfc, 0x40, 0xa9, 0x11, 0x0a, 0x1a, 0x7f, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0x6f, 0xfd, 0x00, 0x4c, 0xb8, 0x16, 0x70, 0xfd, 0x40, 0x4b, 0xb9, - 0x16, 0xb6, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x24, 0xfc, 0x40, 0x4b, 0xb9, - 0x16, 0xb4, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x22, 0xfc, 0x40, 0xa9, 0x11, - 0x05, 0x51, 0x00, 0x01, 0xff, 0x57, 0x03, 0x2d, 0x6e, 0xfd, 0x00, 0x4e, - 0xf5, 0x4e, 0xab, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xb5, 0xfc, 0x00, 0x4c, - 0x60, 0x03, 0x23, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x23, 0xfd, 0x00, 0x4d, - 0x5f, 0x03, 0x07, 0xfd, 0x40, 0x08, 0x4e, 0x00, 0x06, 0x5c, 0x4e, 0x18, - 0xfd, 0xfd, 0x40, 0x0d, 0x67, 0x00, 0x93, 0x01, 0xa8, 0x68, 0x06, 0x59, - 0x38, 0x58, 0x05, 0x79, 0x5b, 0x40, 0x05, 0x1e, 0x21, 0x22, 0x4f, 0xc9, - 0x70, 0x6d, 0xfc, 0x00, 0x4e, 0xb2, 0x7b, 0x6a, 0xfc, 0x00, 0x04, 0x4d, - 0x00, 0x06, 0x4f, 0x2e, 0x75, 0x6b, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x6f, - 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x0a, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x6c, - 0xfc, 0x00, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, 0xe1, 0xfc, 0x40, 0x4b, 0xb9, - 0x16, 0x9f, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x08, 0xfc, 0x40, 0xa9, 0x06, - 0x53, 0xf0, 0x4e, 0x9e, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0x9e, 0xfc, 0x00, - 0x4c, 0x60, 0x03, 0x07, 0xfc, 0x40, 0x4b, 0xb9, 0x16, 0x9c, 0xfc, 0x00, - 0x4c, 0x60, 0x03, 0x05, 0xfc, 0x40, 0x03, 0x18, 0x0a, 0x11, 0x03, 0x4e, - 0x00, 0x01, 0xff, 0x4c, 0xb8, 0x16, 0xa0, 0xfc, 0x00, 0x4b, 0xfd, 0x6d, - 0xe2, 0xfc, 0x40, 0xa9, 0x06, 0x53, 0xf0, 0x4e, 0xc2, 0xfd, 0x40, 0x4b, - 0xb9, 0x16, 0x9d, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x06, 0xfc, 0x40, 0x4a, - 0x10, 0x2d, 0x6e, 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x09, 0xfc, 0x40, 0x08, - 0x89, 0x9c, 0x9e, 0x01, 0x0d, 0xd5, 0x84, 0x8d, 0x01, 0x52, 0x3c, 0x53, - 0xf3, 0xfd, 0x00, 0xac, 0x06, 0x4b, 0xad, 0xa5, 0xff, 0xfd, 0x40, 0x03, - 0xf6, 0x20, 0x2b, 0x03, 0x69, 0x00, 0x06, 0x51, 0x9b, 0x5b, 0xf2, 0xfd, - 0x40, 0x1e, 0xad, 0x13, 0x11, 0x0e, 0xd0, 0x7e, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0x3c, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0x3d, 0xfd, 0x40, 0x4a, 0x10, - 0x2d, 0x90, 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x5d, 0xfc, 0x40, 0x0b, 0xc9, - 0x98, 0x42, 0x4f, 0x73, 0x6c, 0xf7, 0xfd, 0x00, 0xa9, 0x01, 0xff, 0x02, - 0x19, 0x00, 0x20, 0xad, 0x01, 0xff, 0x09, 0xcb, 0x98, 0x0f, 0x0b, 0xc9, - 0x98, 0x01, 0xff, 0xed, 0x49, 0xfd, 0x00, 0x4d, 0x74, 0x89, 0xd3, 0x0e, - 0x41, 0xed, 0x48, 0xfd, 0x00, 0x4d, 0x74, 0x89, 0xd2, 0x0e, 0x41, 0x48, - 0x39, 0xca, 0xd2, 0xfb, 0x00, 0x07, 0x79, 0x89, 0x01, 0xff, 0xed, 0x47, - 0xfd, 0x00, 0x4d, 0x74, 0x89, 0x4a, 0xfd, 0x40, 0xed, 0x4d, 0xfd, 0x00, - 0x4d, 0x74, 0x89, 0xd1, 0x0e, 0x41, 0x54, 0x6e, 0x19, 0xd1, 0xfb, 0x00, - 0x5c, 0x66, 0x19, 0xcd, 0xfd, 0x40, 0x0d, 0x67, 0x00, 0x67, 0x05, 0x59, - 0x38, 0x44, 0x05, 0x1e, 0x21, 0x11, 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, - 0x10, 0x2d, 0x14, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0xf8, 0xfc, 0x40, 0xa9, - 0x21, 0x05, 0x51, 0x00, 0x01, 0xff, 0x57, 0x03, 0x2d, 0x78, 0xfd, 0x00, - 0x05, 0x1e, 0x21, 0x06, 0x4e, 0xf5, 0x4e, 0xb6, 0xfd, 0x40, 0x4a, 0x10, - 0x2d, 0x76, 0xfd, 0x00, 0x4c, 0xb8, 0x16, 0x77, 0xfd, 0x40, 0x4b, 0xb9, - 0x16, 0xbb, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x2a, 0xfc, 0x40, 0xa9, 0x11, - 0x0a, 0x1a, 0x7f, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x75, 0xfd, 0x00, 0x4c, - 0xb8, 0x16, 0xc4, 0xfd, 0x40, 0x4b, 0xb9, 0x16, 0xba, 0xfc, 0x00, 0x4c, - 0x60, 0x03, 0x29, 0xfc, 0x40, 0x4a, 0x10, 0x2d, 0x13, 0xfd, 0x00, 0x4d, - 0x5f, 0x03, 0xf7, 0xfc, 0x40, 0x0d, 0x35, 0x83, 0xd3, 0x1e, 0x05, 0xee, - 0x05, 0x01, 0xff, 0xa1, 0x8d, 0x1b, 0x02, 0xb7, 0x05, 0xd2, 0x19, 0xa4, - 0xb1, 0x17, 0xe5, 0xd0, 0x06, 0x80, 0x8e, 0x17, 0xa6, 0xdb, 0x15, 0xa7, - 0xb5, 0x14, 0xa8, 0xfe, 0x11, 0x02, 0x82, 0x20, 0xa6, 0x11, 0xab, 0x8f, - 0x0f, 0xac, 0xa8, 0x0e, 0xad, 0xe0, 0x0d, 0xae, 0xfe, 0x0b, 0x42, 0x67, - 0x51, 0xc6, 0x06, 0x80, 0xe7, 0x0b, 0x43, 0x92, 0xdc, 0x7e, 0x06, 0x80, - 0x90, 0x0b, 0x43, 0x43, 0x14, 0x42, 0x06, 0x80, 0xc9, 0x0a, 0xb2, 0x8c, - 0x09, 0xb3, 0xb0, 0x07, 0xb4, 0xe1, 0x03, 0xf5, 0xc7, 0x06, 0x80, 0xaf, - 0x03, 0x42, 0x32, 0x00, 0xcb, 0x06, 0x80, 0xf7, 0x02, 0x43, 0x9f, 0x8a, - 0x48, 0x06, 0x80, 0x99, 0x02, 0xb9, 0x43, 0x02, 0x59, 0x00, 0x01, 0xff, - 0xe8, 0x38, 0x06, 0x80, 0x1c, 0x42, 0x9e, 0x01, 0x32, 0x06, 0xc0, 0x00, - 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0xb0, 0xfe, 0x00, 0x4d, 0x5f, 0x03, - 0xaf, 0xfe, 0x00, 0x55, 0x26, 0x3f, 0xb2, 0x08, 0x40, 0x80, 0x01, 0xff, - 0x4a, 0x10, 0x2d, 0xc6, 0xfe, 0x00, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, 0xc8, - 0xfe, 0x40, 0x4b, 0xb9, 0x16, 0xc7, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xc5, - 0xfe, 0x40, 0x42, 0x4e, 0x00, 0x4a, 0x06, 0x80, 0x14, 0xf5, 0xc8, 0x06, - 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0xdc, 0xfb, 0x00, 0x4d, - 0x5f, 0x03, 0xdb, 0xfb, 0x40, 0x80, 0x01, 0xff, 0x46, 0xf2, 0x19, 0xd2, - 0x06, 0x80, 0x75, 0x4a, 0x10, 0x2d, 0xf2, 0xfe, 0x00, 0xa9, 0x61, 0x4b, - 0xfd, 0x6d, 0xf4, 0xfe, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4f, 0x36, - 0x6d, 0xc7, 0x0e, 0x01, 0x4b, 0x56, 0x00, 0x26, 0x06, 0x80, 0x2c, 0x47, - 0xed, 0x34, 0xce, 0x06, 0x00, 0xb4, 0x01, 0xff, 0x43, 0x90, 0x17, 0xcd, - 0x06, 0x00, 0x4f, 0x44, 0x6e, 0xd1, 0x06, 0x00, 0x12, 0x44, 0x1e, 0x01, - 0xff, 0x49, 0x56, 0x1e, 0xa9, 0x08, 0x00, 0x4b, 0x56, 0x00, 0xa8, 0x08, - 0x00, 0x50, 0x5d, 0x67, 0xba, 0x08, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0x8a, 0xfe, 0x00, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, 0x8c, 0xfe, 0x40, - 0x4b, 0xb9, 0x16, 0x8b, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0x89, 0xfe, 0x40, - 0x4b, 0xb9, 0x16, 0xf3, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xf1, 0xfe, 0x40, - 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0xaf, 0xfb, 0x00, 0x4d, 0x5f, 0x03, - 0xae, 0xfb, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x1d, 0xdc, 0x15, 0x16, - 0x4b, 0x56, 0x00, 0xd3, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0xb1, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0xb0, 0xfb, 0x40, 0x4a, 0x6c, - 0xab, 0x7b, 0x07, 0x00, 0x48, 0x99, 0xcc, 0x7a, 0x07, 0x40, 0x80, 0x01, - 0xff, 0x4a, 0x10, 0x2d, 0xee, 0xfe, 0x00, 0x4d, 0x5f, 0x03, 0xed, 0xfe, - 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x04, 0x03, 0x0c, 0x32, 0x1d, 0xdc, - 0x15, 0x22, 0x4b, 0x56, 0x00, 0x24, 0x06, 0x80, 0x0c, 0x44, 0x22, 0x08, - 0xc4, 0x06, 0x00, 0x4e, 0xf2, 0x0e, 0xca, 0x06, 0x40, 0x80, 0x01, 0xff, - 0x4a, 0x10, 0x2d, 0x86, 0xfe, 0x00, 0x4d, 0x5f, 0x03, 0x85, 0xfe, 0x40, - 0x4a, 0x6c, 0xab, 0x79, 0x07, 0x00, 0x48, 0x99, 0xcc, 0x78, 0x07, 0x40, - 0x45, 0x5c, 0x00, 0xcf, 0x06, 0x00, 0x46, 0xe3, 0x1e, 0xab, 0x08, 0x40, - 0x80, 0x22, 0xe8, 0xa4, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0x6b, 0xfb, 0x00, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, 0x6d, 0xfb, 0x40, - 0x4b, 0xb9, 0x16, 0x6c, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x6a, 0xfb, 0x40, - 0x4a, 0x10, 0x2d, 0xdf, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0xde, 0xfb, 0x40, - 0x80, 0x11, 0x22, 0x56, 0x0c, 0x01, 0xff, 0x4c, 0xb8, 0x16, 0xe8, 0xfb, - 0x00, 0x4b, 0xfd, 0x6d, 0xe9, 0xfb, 0x40, 0x4a, 0x10, 0x2d, 0xd8, 0xfb, - 0x00, 0x4d, 0x5f, 0x03, 0xd7, 0xfb, 0x00, 0x50, 0x51, 0x00, 0x77, 0x06, - 0xc0, 0x00, 0x4e, 0x5e, 0x03, 0xdd, 0xfb, 0x40, 0x42, 0x18, 0x0a, 0x37, - 0x06, 0x80, 0xf8, 0x02, 0x44, 0xa7, 0x83, 0x86, 0x06, 0x80, 0x9f, 0x02, - 0x42, 0x4e, 0x00, 0x2a, 0x06, 0x80, 0x9a, 0x01, 0xa8, 0x4d, 0x43, 0xb2, - 0x0f, 0x79, 0x06, 0xc0, 0x00, 0x80, 0x24, 0x42, 0x4e, 0x00, 0x7a, 0x06, - 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x5f, 0xfb, 0x00, 0xa9, - 0x06, 0x4b, 0xfd, 0x6d, 0x61, 0xfb, 0x40, 0x4b, 0xb9, 0x16, 0x60, 0xfb, - 0x00, 0x4c, 0x60, 0x03, 0x5e, 0xfb, 0x40, 0x4a, 0x10, 0x2d, 0x67, 0xfb, - 0x00, 0xa9, 0x0c, 0x4b, 0xfd, 0x6d, 0x69, 0xfb, 0x00, 0x4c, 0x20, 0x97, - 0xc0, 0x08, 0x40, 0x4b, 0xb9, 0x16, 0x68, 0xfb, 0x00, 0x4c, 0x60, 0x03, - 0x66, 0xfb, 0x40, 0x42, 0x13, 0x00, 0x30, 0x06, 0x80, 0x35, 0x42, 0x4e, - 0x00, 0x2b, 0x06, 0x80, 0x11, 0x03, 0xe1, 0x05, 0x01, 0xff, 0x44, 0x00, - 0x46, 0xc6, 0x0e, 0x01, 0x43, 0x4d, 0x00, 0x86, 0x08, 0x40, 0x80, 0x01, - 0xff, 0x4a, 0x10, 0x2d, 0x9a, 0xfe, 0x00, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, - 0x9c, 0xfe, 0x40, 0x4b, 0xb9, 0x16, 0x9b, 0xfe, 0x00, 0x4c, 0x60, 0x03, - 0x99, 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0xac, 0xfe, 0x00, - 0x4d, 0x5f, 0x03, 0xab, 0xfe, 0x40, 0x80, 0x24, 0x42, 0x4e, 0x00, 0x7f, - 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x63, 0xfb, 0x00, - 0xa9, 0x06, 0x4b, 0xfd, 0x6d, 0x65, 0xfb, 0x40, 0x4b, 0xb9, 0x16, 0x64, - 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x62, 0xfb, 0x40, 0x4a, 0x10, 0x2d, 0x96, - 0xfe, 0x00, 0xa9, 0x43, 0xad, 0x1f, 0x05, 0x51, 0x00, 0x01, 0xff, 0x44, - 0x22, 0x08, 0x7c, 0x06, 0x00, 0x06, 0x5d, 0x07, 0x06, 0x5a, 0x3c, 0x22, - 0x7d, 0x06, 0x40, 0x49, 0xdb, 0xbf, 0xb8, 0x08, 0x00, 0xf6, 0xbf, 0x08, - 0x40, 0x46, 0x00, 0xda, 0x29, 0x06, 0x80, 0x06, 0x4a, 0xfe, 0x6d, 0x98, - 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x94, 0xfe, 0x00, 0x44, - 0x29, 0xf0, 0xc3, 0x06, 0x00, 0x4d, 0x5f, 0x03, 0x93, 0xfe, 0x40, 0x4b, - 0xb9, 0x16, 0x97, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0x95, 0xfe, 0x40, 0x80, - 0x24, 0x42, 0x4e, 0x00, 0x87, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, - 0x10, 0x2d, 0x7f, 0xfb, 0x00, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, 0x81, 0xfb, - 0x40, 0x4b, 0xb9, 0x16, 0x80, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x7e, 0xfb, - 0x40, 0x4a, 0x10, 0x2d, 0x7b, 0xfb, 0x00, 0xa9, 0x17, 0x4b, 0xfd, 0x6d, - 0x7d, 0xfb, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x49, 0x56, 0x1e, 0xbf, - 0x06, 0x00, 0x47, 0xed, 0x34, 0xc1, 0x08, 0x40, 0x4b, 0xb9, 0x16, 0x7c, - 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x7a, 0xfb, 0x40, 0x80, 0x01, 0xff, 0x4a, - 0x10, 0x2d, 0xc2, 0xfe, 0x00, 0xa9, 0x35, 0x4b, 0xfd, 0x6d, 0xc4, 0xfe, - 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x49, 0x9f, 0x12, 0x8b, 0x08, 0x00, - 0xb4, 0x01, 0xff, 0x0a, 0xae, 0x12, 0x11, 0x08, 0xf2, 0x0b, 0x01, 0xff, - 0x45, 0x5c, 0x00, 0xa3, 0x08, 0x00, 0x50, 0x69, 0x2c, 0xc3, 0x0e, 0x41, - 0x45, 0x5c, 0x00, 0x9f, 0x06, 0x00, 0x45, 0x20, 0x07, 0x8c, 0x08, 0x40, - 0x4b, 0xb9, 0x16, 0xc3, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xc1, 0xfe, 0x40, - 0x42, 0xe8, 0x01, 0x35, 0x06, 0x80, 0x99, 0x01, 0x43, 0xc4, 0x09, 0x33, - 0x06, 0x80, 0x3c, 0x44, 0x6c, 0xdb, 0x34, 0x06, 0x80, 0x12, 0x4b, 0xd4, - 0xa3, 0xb1, 0x08, 0x00, 0x4f, 0x70, 0x06, 0x70, 0x06, 0x00, 0x48, 0x81, - 0xcc, 0xaa, 0x06, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0xb6, 0xfe, - 0x00, 0xa9, 0x0c, 0x4b, 0xfd, 0x6d, 0xb8, 0xfe, 0x00, 0x4e, 0xc2, 0x7e, - 0xfa, 0x06, 0x40, 0x4b, 0xb9, 0x16, 0xb7, 0xfe, 0x00, 0x4c, 0x60, 0x03, - 0xb5, 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0xb2, 0xfe, 0x00, - 0xa9, 0x3f, 0x4b, 0xfd, 0x6d, 0xb4, 0xfe, 0x00, 0x05, 0x51, 0x00, 0x01, - 0xff, 0x57, 0x45, 0x2e, 0x9a, 0x06, 0x00, 0x66, 0xd9, 0x06, 0x7d, 0x07, - 0x00, 0x4f, 0xd8, 0x46, 0x5c, 0x07, 0x00, 0x4a, 0x2b, 0x3f, 0x7e, 0x07, - 0x00, 0x64, 0x03, 0x0a, 0x70, 0x07, 0x00, 0xb4, 0x01, 0xff, 0x4f, 0x44, - 0x6e, 0x9b, 0x06, 0x80, 0x06, 0x58, 0x49, 0x2c, 0x6d, 0x07, 0x40, 0x55, - 0xa8, 0x12, 0x9c, 0x06, 0x40, 0x4b, 0xb9, 0x16, 0xb3, 0xfe, 0x00, 0x4c, - 0x60, 0x03, 0xb1, 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0xba, - 0xfe, 0x00, 0xa9, 0x21, 0x4b, 0xfd, 0x6d, 0xbc, 0xfe, 0x00, 0x06, 0x29, - 0x06, 0x01, 0xff, 0x0a, 0xae, 0x12, 0x06, 0x4d, 0x06, 0x0f, 0x9d, 0x06, - 0x40, 0x45, 0x5c, 0x00, 0x9e, 0x06, 0x00, 0x45, 0x20, 0x07, 0xaf, 0x08, - 0x40, 0x4b, 0xb9, 0x16, 0xbb, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xb9, 0xfe, - 0x40, 0x42, 0x4e, 0x00, 0x31, 0x06, 0x80, 0x40, 0x44, 0x00, 0x46, 0xbb, - 0x06, 0x80, 0x1c, 0x4b, 0xb1, 0xa0, 0xac, 0x08, 0x00, 0x43, 0x3e, 0x52, - 0x91, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x8d, 0xfb, - 0x00, 0x4d, 0x5f, 0x03, 0x8c, 0xfb, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0xa1, 0xfb, 0x00, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, 0xa3, 0xfb, 0x40, - 0x4b, 0xb9, 0x16, 0xa2, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0xa0, 0xfb, 0x40, - 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0xae, 0xfe, 0x00, 0x4d, 0x5f, 0x03, - 0xad, 0xfe, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x49, 0x9f, 0x12, 0x94, - 0x06, 0x80, 0x52, 0x4f, 0xd8, 0x46, 0x99, 0x06, 0x00, 0x4b, 0x56, 0x00, - 0x6c, 0x07, 0x00, 0x4a, 0x2b, 0x3f, 0xef, 0x06, 0x00, 0x44, 0x57, 0x85, - 0xaa, 0x08, 0x00, 0x44, 0x22, 0x08, 0x93, 0x06, 0x00, 0xb3, 0x11, 0x09, - 0xf1, 0x0b, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x97, 0x06, 0x00, 0x50, 0x51, - 0x2c, 0x6b, 0x07, 0x40, 0x05, 0x5e, 0x07, 0x06, 0x45, 0x53, 0x05, 0x5b, - 0x07, 0x40, 0x5e, 0x09, 0x0a, 0x71, 0x07, 0x00, 0x4a, 0x63, 0x67, 0xb9, - 0x08, 0x00, 0xf6, 0x92, 0x06, 0xc0, 0x00, 0x46, 0x1f, 0x07, 0x95, 0x06, - 0x40, 0x4e, 0x51, 0x1e, 0x96, 0x06, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0xd6, 0xfe, 0x00, 0xa9, 0x28, 0x4b, 0xfd, 0x6d, 0xd8, 0xfe, 0x00, - 0x05, 0x51, 0x00, 0x01, 0xff, 0x04, 0x03, 0x0c, 0x06, 0x50, 0xad, 0x12, - 0xa8, 0x06, 0x40, 0x45, 0x5c, 0x00, 0xa7, 0x06, 0x00, 0x45, 0x20, 0x07, - 0xa5, 0x08, 0xc0, 0x00, 0x52, 0x16, 0x4f, 0xb5, 0x08, 0x40, 0x4b, 0xb9, - 0x16, 0xd7, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xd5, 0xfe, 0x40, 0x80, 0x24, - 0x42, 0x4e, 0x00, 0xa6, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0x6f, 0xfb, 0x00, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, 0x71, 0xfb, 0x40, - 0x4b, 0xb9, 0x16, 0x70, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x6e, 0xfb, 0x40, - 0x4a, 0x10, 0x2d, 0x57, 0xfb, 0x00, 0xa9, 0x15, 0x4b, 0xfd, 0x6d, 0x59, - 0xfb, 0x00, 0x0b, 0x20, 0x97, 0x01, 0xff, 0x4a, 0xec, 0xad, 0xb7, 0x08, - 0x00, 0xf6, 0xbe, 0x08, 0x40, 0x4b, 0xb9, 0x16, 0x58, 0xfb, 0x00, 0x4c, - 0x60, 0x03, 0x56, 0xfb, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0xda, - 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0xd9, 0xfb, 0x40, 0xe7, 0xad, 0x06, 0x80, - 0x99, 0x01, 0x43, 0xcd, 0x02, 0x46, 0x06, 0x80, 0x24, 0x43, 0x4d, 0x00, - 0x83, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x77, 0xfb, - 0x00, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, 0x79, 0xfb, 0x40, 0x4b, 0xb9, 0x16, - 0x78, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x76, 0xfb, 0x40, 0x80, 0x01, 0xff, - 0x4a, 0x10, 0x2d, 0xe6, 0xfe, 0x00, 0x46, 0x05, 0x46, 0xba, 0x06, 0x80, - 0x4f, 0xa9, 0x41, 0x4b, 0xfd, 0x6d, 0xe8, 0xfe, 0x00, 0x05, 0x51, 0x00, - 0x01, 0xff, 0x49, 0x9f, 0x12, 0xb9, 0x06, 0x00, 0x50, 0xe4, 0x34, 0x89, - 0x08, 0x00, 0x44, 0x22, 0x08, 0xbc, 0x06, 0x80, 0x1d, 0x06, 0x5d, 0x07, - 0x0f, 0xb4, 0x01, 0xff, 0x4f, 0xae, 0x12, 0xbd, 0x06, 0x00, 0x4d, 0x06, - 0x0f, 0x67, 0x07, 0x40, 0x43, 0x17, 0x0a, 0x68, 0x07, 0x00, 0xf6, 0x69, - 0x07, 0x40, 0x46, 0x5b, 0x00, 0x8f, 0x08, 0x40, 0x4b, 0xb9, 0x16, 0xe7, - 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xe5, 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, - 0x10, 0x2d, 0x9f, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0x9e, 0xfb, 0x40, 0x80, - 0x24, 0x43, 0x08, 0x9d, 0xb1, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, - 0x10, 0x2d, 0x9b, 0xfb, 0x00, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, 0x9d, 0xfb, - 0x40, 0x4b, 0xb9, 0x16, 0x9c, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x9a, 0xfb, - 0x40, 0x4a, 0x10, 0x2d, 0xd4, 0xfb, 0x00, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, - 0xd6, 0xfb, 0x40, 0x4b, 0xb9, 0x16, 0xd5, 0xfb, 0x00, 0x4c, 0x60, 0x03, - 0xd3, 0xfb, 0x40, 0x43, 0xba, 0x00, 0x1c, 0x06, 0x00, 0x43, 0x67, 0x18, - 0x45, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0xe2, 0xfe, - 0x00, 0xa9, 0x21, 0x4b, 0xfd, 0x6d, 0xe4, 0xfe, 0x00, 0x05, 0x51, 0x00, - 0x01, 0xff, 0x04, 0x03, 0x0c, 0x06, 0x50, 0xad, 0x12, 0xa7, 0x08, 0x40, - 0x45, 0x5c, 0x00, 0x65, 0x07, 0x00, 0x45, 0x20, 0x07, 0x66, 0x07, 0x40, - 0x4b, 0xb9, 0x16, 0xe3, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xe1, 0xfe, 0x40, - 0x42, 0x57, 0x00, 0x44, 0x06, 0x80, 0x06, 0x47, 0x70, 0xd4, 0xad, 0x08, - 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0xde, 0xfe, 0x00, 0xa9, 0x40, - 0x4b, 0xfd, 0x6d, 0xe0, 0xfe, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x43, - 0x16, 0x00, 0x6a, 0x07, 0x00, 0x02, 0x3b, 0x01, 0x1f, 0x06, 0x5d, 0x07, - 0x11, 0x0b, 0xad, 0x12, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xb7, 0x06, 0x00, - 0x45, 0x20, 0x07, 0xb8, 0x06, 0x40, 0x57, 0x5f, 0x2d, 0xc7, 0x08, 0x00, - 0xf6, 0xb5, 0x06, 0x40, 0x47, 0x58, 0x1e, 0xb6, 0x06, 0x00, 0x48, 0x84, - 0xa9, 0xa6, 0x08, 0x40, 0x4b, 0xb9, 0x16, 0xdf, 0xfe, 0x00, 0x4c, 0x60, - 0x03, 0xdd, 0xfe, 0x40, 0xa1, 0xb4, 0x01, 0x44, 0xc1, 0xef, 0xa9, 0x06, - 0x80, 0x55, 0x43, 0x28, 0x21, 0x2e, 0x06, 0x80, 0x31, 0x07, 0x46, 0x00, - 0x01, 0xff, 0x42, 0x67, 0x51, 0xc5, 0x06, 0x80, 0x16, 0x42, 0x31, 0x4e, - 0xc9, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0xe3, 0xfb, - 0x00, 0x4d, 0x5f, 0x03, 0xe2, 0xfb, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0xe1, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0xe0, 0xfb, 0x40, 0x80, 0x01, - 0xff, 0x4a, 0x10, 0x2d, 0xa6, 0xfe, 0x00, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, - 0xa8, 0xfe, 0x40, 0x4b, 0xb9, 0x16, 0xa7, 0xfe, 0x00, 0x4c, 0x60, 0x03, - 0xa5, 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x8f, 0xfb, 0x00, - 0xa9, 0x41, 0x4b, 0xfd, 0x6d, 0x91, 0xfb, 0x00, 0x05, 0x51, 0x00, 0x01, - 0xff, 0x49, 0x56, 0x1e, 0x62, 0x07, 0x00, 0x47, 0xed, 0x34, 0xc2, 0x08, - 0x00, 0xb4, 0x01, 0xff, 0x0a, 0xae, 0x12, 0x11, 0x08, 0xf2, 0x0b, 0x01, - 0xff, 0x45, 0x5c, 0x00, 0x3b, 0x06, 0x00, 0x50, 0x69, 0x2c, 0x8d, 0x08, - 0x40, 0x45, 0x5c, 0x00, 0x63, 0x07, 0x00, 0x45, 0x20, 0x07, 0x3c, 0x06, - 0x00, 0x56, 0x5a, 0x36, 0x64, 0x07, 0x40, 0x4b, 0xb9, 0x16, 0x90, 0xfb, - 0x00, 0x4c, 0x60, 0x03, 0x8e, 0xfb, 0x40, 0xe6, 0x43, 0x06, 0x80, 0x06, - 0x4a, 0x20, 0xb1, 0x20, 0x06, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, - 0xda, 0xfe, 0x00, 0xa9, 0x3b, 0x4b, 0xfd, 0x6d, 0xdc, 0xfe, 0x00, 0x05, - 0x51, 0x00, 0x01, 0xff, 0x04, 0x03, 0x0c, 0x20, 0x44, 0x22, 0x08, 0xab, - 0x06, 0x00, 0xb4, 0x01, 0xff, 0x4f, 0x44, 0x6e, 0xae, 0x06, 0x00, 0x08, - 0xf2, 0x0b, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x7f, 0x07, 0x00, 0x50, 0x69, - 0x2c, 0xc4, 0x0e, 0x41, 0x45, 0x5c, 0x00, 0xac, 0x06, 0x00, 0x45, 0x20, - 0x07, 0xb4, 0x08, 0x40, 0x4b, 0xb9, 0x16, 0xdb, 0xfe, 0x00, 0x4c, 0x60, - 0x03, 0xd9, 0xfe, 0x40, 0x42, 0xb5, 0x05, 0x2c, 0x06, 0x80, 0x14, 0xe8, - 0x98, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x8b, 0xfb, - 0x00, 0x4d, 0x5f, 0x03, 0x8a, 0xfb, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0x9e, 0xfe, 0x00, 0xa9, 0x21, 0x4b, 0xfd, 0x6d, 0xa0, 0xfe, 0x00, - 0x06, 0x29, 0x06, 0x01, 0xff, 0x0a, 0xae, 0x12, 0x06, 0x4d, 0xf3, 0x0e, - 0xa2, 0x08, 0x40, 0x45, 0x5c, 0x00, 0xc5, 0x08, 0x00, 0x45, 0x20, 0x07, - 0xc6, 0x08, 0x40, 0x4b, 0xb9, 0x16, 0x9f, 0xfe, 0x00, 0x4c, 0x60, 0x03, - 0x9d, 0xfe, 0x40, 0xa1, 0xaf, 0x01, 0x42, 0x4e, 0x00, 0x47, 0x06, 0x80, - 0x1c, 0x49, 0x32, 0xba, 0x74, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x44, - 0x67, 0x00, 0x75, 0x06, 0x00, 0x43, 0x9f, 0x8a, 0x76, 0x06, 0x00, 0x43, - 0x4d, 0x00, 0x78, 0x06, 0x40, 0x80, 0x01, 0xff, 0x4b, 0x26, 0x9b, 0xbe, - 0x06, 0x80, 0x65, 0x4a, 0x10, 0x2d, 0xea, 0xfe, 0x00, 0x44, 0x29, 0xf0, - 0xc1, 0x06, 0x80, 0x35, 0xa9, 0x27, 0x4b, 0xfd, 0x6d, 0xec, 0xfe, 0x00, - 0x05, 0x51, 0x00, 0x01, 0xff, 0x4a, 0x2b, 0x3f, 0xff, 0x06, 0x00, 0x49, - 0xc1, 0xc1, 0xc0, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, - 0xa5, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0xa4, 0xfb, 0x40, 0x4b, 0xb9, 0x16, - 0xeb, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xe9, 0xfe, 0x40, 0x80, 0x01, 0xff, - 0x4a, 0x10, 0x2d, 0xa7, 0xfb, 0x00, 0xa9, 0x0c, 0x4b, 0xfd, 0x6d, 0xa9, - 0xfb, 0x00, 0x50, 0x51, 0x00, 0xc2, 0x06, 0x40, 0x4b, 0xb9, 0x16, 0xa8, - 0xfb, 0x00, 0x4c, 0x60, 0x03, 0xa6, 0xfb, 0x40, 0x80, 0x01, 0xff, 0x4a, - 0x10, 0x2d, 0xab, 0xfb, 0x00, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, 0xad, 0xfb, - 0x40, 0x4b, 0xb9, 0x16, 0xac, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0xaa, 0xfb, - 0x40, 0xe8, 0x2d, 0x06, 0x80, 0x0d, 0x43, 0x58, 0x00, 0x21, 0x06, 0xc0, - 0x00, 0x4e, 0x5e, 0x03, 0x80, 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0xa2, 0xfe, 0x00, 0xa9, 0x59, 0x4b, 0xfd, 0x6d, 0xa4, 0xfe, 0x00, - 0x05, 0x51, 0x00, 0x01, 0xff, 0x66, 0xff, 0x06, 0x7c, 0x07, 0x00, 0x4b, - 0x56, 0x00, 0x81, 0x06, 0x00, 0x56, 0xfa, 0x34, 0x8a, 0x08, 0x00, 0x18, - 0x03, 0x0a, 0x24, 0xb4, 0x01, 0xff, 0x0a, 0xae, 0x12, 0x11, 0x08, 0xf2, - 0x0b, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x57, 0x07, 0x00, 0x4e, 0x6e, 0x7e, - 0x82, 0x06, 0x40, 0x45, 0x5c, 0x00, 0x85, 0x06, 0x00, 0x56, 0x5a, 0x36, - 0x58, 0x07, 0x40, 0xa1, 0x06, 0x45, 0x20, 0x07, 0x6e, 0x07, 0x40, 0x44, - 0x5d, 0x00, 0x72, 0x07, 0x00, 0x4b, 0x1c, 0x0a, 0x6f, 0x07, 0x40, 0x4b, - 0xb9, 0x16, 0xa3, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xa1, 0xfe, 0x40, 0x42, - 0x44, 0x14, 0xaf, 0x06, 0x80, 0x5f, 0x44, 0x87, 0x9c, 0x3a, 0x06, 0x80, - 0x2a, 0x43, 0x14, 0x20, 0xc8, 0x08, 0x00, 0x43, 0xc0, 0xef, 0xb3, 0x06, - 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x97, 0xfb, 0x00, 0xa9, - 0x06, 0x4b, 0xfd, 0x6d, 0x99, 0xfb, 0x40, 0x4b, 0xb9, 0x16, 0x98, 0xfb, - 0x00, 0x4c, 0x60, 0x03, 0x96, 0xfb, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0xce, 0xfe, 0x00, 0xa9, 0x17, 0x4b, 0xfd, 0x6d, 0xd0, 0xfe, 0x00, - 0x05, 0x51, 0x00, 0x01, 0xff, 0x49, 0x9f, 0x12, 0xfc, 0x06, 0x00, 0x50, - 0xad, 0x12, 0xc3, 0x08, 0x40, 0x4b, 0xb9, 0x16, 0xcf, 0xfe, 0x00, 0x4c, - 0x60, 0x03, 0xcd, 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x93, - 0xfb, 0x00, 0xa9, 0x26, 0x4b, 0xfd, 0x6d, 0x95, 0xfb, 0x00, 0x05, 0x51, - 0x00, 0x01, 0xff, 0x4f, 0xe9, 0x6e, 0xb0, 0x08, 0x00, 0x44, 0x22, 0x08, - 0xb0, 0x06, 0x00, 0xb4, 0x01, 0xff, 0x4f, 0xae, 0x12, 0xb4, 0x06, 0x00, - 0x4d, 0x06, 0x0f, 0xb2, 0x06, 0x40, 0x4b, 0xb9, 0x16, 0x94, 0xfb, 0x00, - 0x4c, 0x60, 0x03, 0x92, 0xfb, 0x40, 0x48, 0xb1, 0xc3, 0xcc, 0x06, 0x80, - 0x59, 0x42, 0x4e, 0x00, 0x41, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, - 0x10, 0x2d, 0xd2, 0xfe, 0x00, 0xa9, 0x3b, 0x4b, 0xfd, 0x6d, 0xd4, 0xfe, - 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x04, 0x03, 0x0c, 0x19, 0xb4, 0x01, - 0xff, 0x0a, 0xae, 0x12, 0x06, 0x4d, 0x06, 0x0f, 0x60, 0x07, 0x40, 0x45, - 0x20, 0x07, 0xa5, 0x06, 0x00, 0x56, 0x5a, 0x36, 0x61, 0x07, 0x40, 0x45, - 0x20, 0x07, 0xa3, 0x06, 0x80, 0x06, 0x4b, 0xd5, 0x9f, 0xa2, 0x06, 0x40, - 0x55, 0xa8, 0x12, 0xa4, 0x08, 0x40, 0x4b, 0xb9, 0x16, 0xd3, 0xfe, 0x00, - 0x4c, 0x60, 0x03, 0xd1, 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, - 0xfd, 0xfb, 0x00, 0xa9, 0x39, 0x4b, 0xfd, 0x6d, 0xff, 0xfb, 0x00, 0x05, - 0x51, 0x00, 0x01, 0xff, 0x1c, 0xd9, 0x06, 0x15, 0x4a, 0x2b, 0x3f, 0x3d, - 0x06, 0x00, 0xb4, 0x01, 0xff, 0x4f, 0xae, 0x12, 0x3f, 0x06, 0x00, 0x4d, - 0xf3, 0x0e, 0x3e, 0x06, 0x40, 0x4a, 0x1b, 0x07, 0x77, 0x07, 0x00, 0xb4, - 0x01, 0xff, 0x4a, 0x6c, 0xab, 0x76, 0x07, 0x00, 0x48, 0x99, 0xcc, 0x75, - 0x07, 0x40, 0x4b, 0xb9, 0x16, 0xfe, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0xfc, - 0xfb, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0xe5, 0xfb, 0x00, 0xa9, - 0x06, 0x4b, 0xfd, 0x6d, 0xe7, 0xfb, 0x40, 0x4b, 0xb9, 0x16, 0xe6, 0xfb, - 0x00, 0x4c, 0x60, 0x03, 0xe4, 0xfb, 0x40, 0xa1, 0x7e, 0x02, 0xf0, 0x10, - 0x50, 0x07, 0x98, 0x41, 0x3a, 0x42, 0x1f, 0x01, 0x8e, 0x06, 0x80, 0x24, - 0x43, 0x4d, 0x00, 0x84, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0x73, 0xfb, 0x00, 0xa9, 0x06, 0x4b, 0xfd, 0x6d, 0x75, 0xfb, 0x40, - 0x4b, 0xb9, 0x16, 0x74, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x72, 0xfb, 0x40, - 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x87, 0xfb, 0x00, 0x4d, 0x5f, 0x03, - 0x86, 0xfb, 0x40, 0x43, 0xb8, 0x8c, 0x6e, 0x06, 0x00, 0x43, 0xf7, 0xb8, - 0xa1, 0x06, 0x00, 0x43, 0x43, 0x14, 0x6f, 0x06, 0x40, 0x43, 0x22, 0x00, - 0x8d, 0x06, 0x80, 0x14, 0xec, 0x88, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, - 0x4a, 0x10, 0x2d, 0x89, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0x88, 0xfb, 0x40, - 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x83, 0xfb, 0x00, 0x4d, 0x5f, 0x03, - 0x82, 0xfb, 0x40, 0xe4, 0x36, 0x06, 0x80, 0x76, 0x43, 0x22, 0x00, 0x8c, - 0x06, 0x80, 0x60, 0xec, 0x2f, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, - 0x10, 0x2d, 0xaa, 0xfe, 0x00, 0x4d, 0x5f, 0x03, 0xa9, 0xfe, 0x00, 0x05, - 0x51, 0x00, 0x01, 0xff, 0x49, 0x9f, 0x12, 0x8a, 0x06, 0x80, 0x3a, 0x4f, - 0xd8, 0x46, 0x90, 0x06, 0x00, 0x09, 0x60, 0x23, 0x26, 0x44, 0x22, 0x08, - 0x89, 0x06, 0x00, 0xb4, 0x01, 0xff, 0x0a, 0xae, 0x12, 0x0d, 0x58, 0x61, - 0x2c, 0xc2, 0x0e, 0xc1, 0x00, 0x4e, 0x5a, 0x75, 0x59, 0x07, 0x40, 0x4f, - 0x47, 0x22, 0x8f, 0x06, 0x00, 0x45, 0x20, 0x07, 0xae, 0x08, 0x40, 0x4d, - 0x03, 0x35, 0x5a, 0x07, 0x00, 0xf6, 0xee, 0x06, 0x40, 0x4e, 0x5a, 0x75, - 0x8b, 0x06, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x85, 0xfb, 0x00, - 0x4d, 0x5f, 0x03, 0x84, 0xfb, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, - 0xbe, 0xfe, 0x00, 0xa9, 0x0c, 0x4b, 0xfd, 0x6d, 0xc0, 0xfe, 0x00, 0x4e, - 0xc2, 0x7e, 0xfb, 0x06, 0x40, 0x4b, 0xb9, 0x16, 0xbf, 0xfe, 0x00, 0x4c, - 0x60, 0x03, 0xbd, 0xfe, 0x40, 0x42, 0x4e, 0x00, 0x7b, 0x06, 0x80, 0x91, - 0x01, 0xe8, 0x28, 0x06, 0xc0, 0x00, 0x80, 0x24, 0x42, 0x4e, 0x00, 0x80, - 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x5b, 0xfb, 0x00, - 0xa9, 0x06, 0x4b, 0xfd, 0x6d, 0x5d, 0xfb, 0x40, 0x4b, 0xb9, 0x16, 0x5c, - 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x5a, 0xfb, 0x40, 0x4a, 0x10, 0x2d, 0x90, - 0xfe, 0x00, 0xa9, 0x52, 0x4b, 0xfd, 0x6d, 0x92, 0xfe, 0x00, 0x05, 0x51, - 0x00, 0x01, 0xff, 0x5e, 0x9f, 0x12, 0x51, 0x07, 0x00, 0x4b, 0x56, 0x00, - 0xa1, 0x08, 0x00, 0x56, 0xfa, 0x34, 0x55, 0x07, 0x00, 0x06, 0x5d, 0x07, - 0x20, 0xb4, 0x01, 0xff, 0x0a, 0xae, 0x12, 0x06, 0x5b, 0x44, 0x1e, 0x54, - 0x07, 0x40, 0x52, 0x64, 0x52, 0x50, 0x07, 0x00, 0x56, 0x5a, 0x36, 0x52, - 0x07, 0xc0, 0x00, 0x53, 0x7b, 0x26, 0x53, 0x07, 0x40, 0x4a, 0xec, 0xad, - 0xb6, 0x08, 0x00, 0xf6, 0x56, 0x07, 0xc0, 0x00, 0x46, 0x1f, 0x07, 0xa0, - 0x08, 0x40, 0x4b, 0xb9, 0x16, 0x91, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0x8f, - 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x53, 0xfb, 0x00, 0xa9, - 0x06, 0x4b, 0xfd, 0x6d, 0x55, 0xfb, 0x40, 0x4b, 0xb9, 0x16, 0x54, 0xfb, - 0x00, 0x4c, 0x60, 0x03, 0x52, 0xfb, 0x40, 0xe5, 0xd5, 0x06, 0x00, 0x07, - 0x69, 0xc6, 0x9c, 0x03, 0x42, 0x9e, 0x01, 0x39, 0x06, 0x80, 0xcb, 0x02, - 0x43, 0x68, 0x00, 0x27, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0x8e, 0xfe, 0x00, 0x4d, 0x5f, 0x03, 0x8d, 0xfe, 0x00, 0x47, 0x6c, - 0x00, 0x49, 0x06, 0x80, 0x9e, 0x02, 0xb7, 0x01, 0xff, 0x44, 0x14, 0xa5, - 0x71, 0x06, 0x80, 0x84, 0x02, 0x04, 0x52, 0x00, 0x01, 0xff, 0x09, 0x8a, - 0xb6, 0x8b, 0x01, 0x49, 0x56, 0x1e, 0x7a, 0x08, 0x00, 0x1d, 0xdc, 0x15, - 0x75, 0x06, 0x56, 0x00, 0x45, 0x52, 0x60, 0x53, 0x73, 0x08, 0x00, 0x4b, - 0xc8, 0x91, 0x22, 0x06, 0x80, 0x29, 0x53, 0xa3, 0x4c, 0x72, 0x08, 0x80, - 0x11, 0x0b, 0xad, 0x68, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x72, 0x06, 0x00, - 0x45, 0x20, 0x07, 0x73, 0x06, 0x40, 0x05, 0x19, 0x00, 0x01, 0xff, 0x49, - 0x56, 0x1e, 0x7c, 0x08, 0x00, 0x49, 0x76, 0xbb, 0x7f, 0x08, 0x40, 0x80, - 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x82, 0xfe, 0x00, 0x4d, 0x5f, 0x03, 0x81, - 0xfe, 0x40, 0x45, 0x5c, 0x00, 0x23, 0x06, 0x80, 0x16, 0x45, 0x20, 0x07, - 0x25, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x88, 0xfe, - 0x00, 0x4d, 0x5f, 0x03, 0x87, 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0x84, 0xfe, 0x00, 0x4d, 0x5f, 0x03, 0x83, 0xfe, 0x40, 0x4a, 0x6c, - 0xab, 0x74, 0x07, 0x00, 0x48, 0x99, 0xcc, 0x73, 0x07, 0x40, 0x52, 0xa2, - 0x50, 0x75, 0x08, 0x80, 0x57, 0x45, 0xee, 0x73, 0x70, 0x08, 0x00, 0x45, - 0xaf, 0x50, 0x74, 0x08, 0x00, 0x05, 0xc3, 0x00, 0x3b, 0xb2, 0x18, 0x4f, - 0xe4, 0x73, 0x71, 0x08, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, 0xff, 0x49, - 0x56, 0x1e, 0x7b, 0x08, 0x00, 0x49, 0x76, 0xbb, 0x7e, 0x08, 0x40, 0x05, - 0xc9, 0x00, 0x11, 0x09, 0xb3, 0xb0, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x76, - 0x08, 0x00, 0x45, 0x20, 0x07, 0x79, 0x08, 0x40, 0x45, 0x56, 0x00, 0x81, - 0x08, 0x00, 0x49, 0x62, 0x58, 0x77, 0x08, 0x40, 0x45, 0x56, 0x00, 0x82, - 0x08, 0x00, 0x49, 0x62, 0x58, 0x78, 0x08, 0x40, 0x05, 0x19, 0x00, 0x01, - 0xff, 0x49, 0x56, 0x1e, 0x7d, 0x08, 0x00, 0x49, 0x76, 0xbb, 0x80, 0x08, - 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0x51, 0xfb, 0x00, 0x4d, 0x5f, - 0x03, 0x50, 0xfb, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, 0x2d, 0xf0, 0xfe, - 0x00, 0x4d, 0x5f, 0x03, 0xef, 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x10, - 0x2d, 0xca, 0xfe, 0x00, 0xa9, 0x32, 0x4b, 0xfd, 0x6d, 0xcc, 0xfe, 0x00, - 0x06, 0x29, 0x06, 0x01, 0xff, 0x0a, 0xae, 0x12, 0x11, 0x08, 0xf2, 0x0b, - 0x01, 0xff, 0x45, 0x5c, 0x00, 0x5d, 0x07, 0x00, 0x50, 0x51, 0x2c, 0x5f, - 0x07, 0x40, 0x45, 0x5c, 0x00, 0xa0, 0x06, 0x00, 0x45, 0x20, 0x07, 0xb3, - 0x08, 0x00, 0x58, 0xc9, 0x2a, 0x5e, 0x07, 0x40, 0x4b, 0xb9, 0x16, 0xcb, - 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xc9, 0xfe, 0x40, 0x43, 0xf7, 0xb8, 0xbb, - 0x08, 0x00, 0x44, 0x00, 0x46, 0xbd, 0x08, 0x00, 0x43, 0x43, 0x14, 0xbc, - 0x08, 0xc0, 0x00, 0x56, 0xbe, 0x32, 0xc4, 0x08, 0x40, 0x45, 0x5c, 0x00, - 0xf7, 0x08, 0x00, 0x45, 0x20, 0x07, 0xf9, 0x08, 0x40, 0x4c, 0xe0, 0x2c, - 0xd1, 0x08, 0x00, 0x0a, 0xb2, 0xb0, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xce, - 0x08, 0x00, 0x45, 0x20, 0x07, 0xcf, 0x08, 0x00, 0x53, 0x8f, 0x4a, 0xd2, - 0x08, 0x40, 0x80, 0x0d, 0x43, 0xf9, 0x0a, 0x4d, 0x06, 0xc0, 0x00, 0x4e, + 0x9e, 0x01, 0x17, 0x06, 0x40, 0x5b, 0xf7, 0x1a, 0xcb, 0x08, 0x40, 0x42, + 0x3e, 0x2f, 0xf3, 0x08, 0x00, 0x04, 0xaa, 0x26, 0x01, 0xff, 0xa1, 0x20, + 0x46, 0x42, 0xe3, 0xf8, 0x0e, 0x01, 0x43, 0x87, 0xfa, 0xde, 0x08, 0x00, + 0x02, 0x40, 0x06, 0x06, 0x45, 0x19, 0xf2, 0xdf, 0x08, 0x40, 0xe8, 0xcc, + 0x08, 0x00, 0x43, 0x64, 0x41, 0xdd, 0x08, 0x40, 0x45, 0xf5, 0xed, 0x98, + 0x08, 0x00, 0x46, 0x1a, 0xe4, 0xdc, 0x08, 0x00, 0x45, 0x11, 0xf0, 0xd4, + 0x08, 0x00, 0x47, 0x74, 0xdb, 0xdb, 0x08, 0x00, 0x4b, 0x9b, 0xa8, 0xda, + 0x08, 0x40, 0x42, 0x3d, 0x0a, 0x15, 0x06, 0x00, 0x49, 0xda, 0x10, 0xdb, + 0x06, 0x40, 0x42, 0xe8, 0x01, 0xd5, 0x08, 0x00, 0x43, 0xe9, 0x09, 0xdc, + 0x06, 0x00, 0x49, 0xcf, 0xbf, 0xe1, 0x08, 0x40, 0x06, 0x50, 0x00, 0x01, + 0xff, 0x45, 0xa0, 0x61, 0xf5, 0x0e, 0x01, 0x45, 0x1a, 0x77, 0xf3, 0x0e, + 0x01, 0x45, 0x16, 0x53, 0xd8, 0x08, 0x40, 0x44, 0x5b, 0x4d, 0xe4, 0x06, + 0x00, 0x05, 0x4d, 0x3a, 0x01, 0xff, 0x4b, 0x87, 0x17, 0xd8, 0x06, 0x00, + 0x4c, 0x60, 0x03, 0xe2, 0x06, 0x40, 0x47, 0x7b, 0xd4, 0xd9, 0x06, 0x00, + 0x08, 0xde, 0x11, 0x01, 0xff, 0x0a, 0xea, 0xac, 0x0c, 0x5e, 0x11, 0x15, + 0xd7, 0x06, 0x00, 0x5e, 0x4d, 0x15, 0xd6, 0x06, 0x40, 0x4c, 0x6c, 0x95, + 0x16, 0x06, 0x00, 0x4a, 0x7e, 0xb9, 0x16, 0x06, 0x40, 0x48, 0x47, 0xc9, + 0xca, 0x08, 0x00, 0x4e, 0x28, 0x7e, 0xe0, 0x08, 0x40, 0x47, 0x48, 0xc9, + 0xc9, 0x08, 0x00, 0x43, 0x8f, 0x00, 0x18, 0x06, 0x40, 0x54, 0xb3, 0x43, + 0xca, 0x0e, 0x01, 0x45, 0x1a, 0x77, 0xc9, 0x0e, 0x41, 0x4f, 0xa1, 0x6d, + 0x11, 0x06, 0x00, 0x45, 0xa9, 0xee, 0x0f, 0x06, 0x00, 0x02, 0x71, 0x00, + 0x33, 0xb3, 0x06, 0x49, 0x6f, 0xc5, 0x14, 0x06, 0x40, 0xa1, 0x11, 0x06, + 0xdc, 0xe2, 0x01, 0xff, 0x49, 0x35, 0x40, 0xfd, 0x06, 0x00, 0x50, 0xfa, + 0x68, 0xfe, 0x06, 0x40, 0x43, 0xd5, 0xbf, 0x03, 0x06, 0x00, 0x5a, 0x0b, + 0x22, 0x10, 0x06, 0x00, 0x44, 0x3c, 0xf7, 0x04, 0x06, 0x00, 0x43, 0x90, + 0x48, 0x01, 0x06, 0x40, 0x4f, 0x27, 0x6f, 0x13, 0x06, 0x00, 0x50, 0x6a, + 0x66, 0x12, 0x06, 0x40, 0x80, 0x01, 0xff, 0x4d, 0x5f, 0x03, 0x7c, 0xfe, + 0x00, 0x4b, 0x1a, 0x71, 0x7d, 0xfe, 0x40, 0xa1, 0x23, 0x4d, 0xd5, 0x86, + 0x5d, 0x06, 0x00, 0x0f, 0xf4, 0x3f, 0x06, 0x63, 0xad, 0x0b, 0xec, 0x06, + 0x40, 0x45, 0x5c, 0x00, 0xf8, 0x08, 0x80, 0x06, 0x45, 0x20, 0x07, 0xfa, + 0x08, 0x40, 0x49, 0x98, 0x3d, 0xfd, 0x08, 0x40, 0x4e, 0x68, 0x7c, 0x88, + 0x08, 0x00, 0xf9, 0x08, 0x06, 0x40, 0xa5, 0x1b, 0x51, 0x49, 0x5d, 0x91, + 0x08, 0x00, 0x4e, 0xd8, 0x7c, 0xe9, 0x06, 0x00, 0xaf, 0x01, 0xff, 0x4f, + 0x17, 0x70, 0x0e, 0x06, 0x00, 0x4e, 0xc4, 0x81, 0x90, 0x08, 0x40, 0x43, + 0xcf, 0x2c, 0x97, 0x08, 0x00, 0x4a, 0x01, 0xa1, 0x6a, 0x06, 0x40, 0x48, + 0xa7, 0xca, 0xf1, 0x08, 0x00, 0x48, 0x50, 0x7b, 0xf0, 0x08, 0x00, 0x48, + 0x1f, 0xcd, 0xf2, 0x08, 0x40, 0x1c, 0xe0, 0x19, 0x11, 0x06, 0x38, 0x3c, + 0x01, 0xff, 0x4a, 0xb6, 0x4e, 0x05, 0x06, 0x00, 0x44, 0x5a, 0x03, 0x00, + 0x06, 0x40, 0x45, 0x5c, 0x00, 0xcb, 0x0e, 0x01, 0x45, 0x20, 0x07, 0xcc, + 0x0e, 0x41, 0x03, 0x88, 0x38, 0xed, 0x07, 0x03, 0xbb, 0x00, 0xd6, 0x07, + 0x0b, 0xff, 0x55, 0x01, 0xff, 0xa1, 0xc2, 0x07, 0x43, 0x35, 0x85, 0x01, + 0xee, 0x01, 0xa4, 0xe8, 0x05, 0x43, 0x70, 0xbe, 0x10, 0xee, 0x01, 0x45, + 0x8f, 0xa1, 0x1b, 0xee, 0x01, 0x43, 0x49, 0x22, 0x07, 0xee, 0x01, 0x08, + 0x86, 0x17, 0xd1, 0x04, 0x44, 0x4c, 0x3a, 0x02, 0xee, 0x01, 0xab, 0xbc, + 0x04, 0xac, 0xfc, 0x02, 0x44, 0x3f, 0x22, 0x0c, 0xee, 0x01, 0x44, 0x30, + 0x48, 0x0d, 0xee, 0x01, 0x09, 0xa1, 0x40, 0xdf, 0x02, 0x43, 0x11, 0x15, + 0x12, 0xee, 0x01, 0x43, 0x93, 0x54, 0x13, 0xee, 0x01, 0xb3, 0xa0, 0x01, + 0xb4, 0x1b, 0x43, 0x1c, 0x8f, 0x05, 0xee, 0x01, 0x43, 0x4d, 0x00, 0x09, + 0xee, 0x01, 0x02, 0x59, 0x00, 0x01, 0xff, 0xe8, 0x1a, 0xee, 0x01, 0x42, + 0x9e, 0x01, 0x06, 0xee, 0x41, 0xa1, 0x15, 0x42, 0x4e, 0x00, 0x15, 0xee, + 0x01, 0xa8, 0x01, 0xff, 0x42, 0x13, 0x00, 0x18, 0xee, 0x01, 0x42, 0x4e, + 0x00, 0x16, 0xee, 0x41, 0xe8, 0x08, 0xee, 0x01, 0x05, 0x7b, 0x18, 0x01, + 0xff, 0x43, 0x56, 0x07, 0x4f, 0xee, 0x01, 0xa4, 0x44, 0x45, 0x8f, 0xa1, + 0x5b, 0xee, 0x01, 0x43, 0x49, 0x22, 0x47, 0xee, 0x01, 0x44, 0x4c, 0x3a, + 0x42, 0xee, 0x01, 0x44, 0xc3, 0x43, 0x57, 0xee, 0x01, 0x43, 0xb0, 0x00, + 0x4b, 0xee, 0x01, 0x44, 0x30, 0x48, 0x4d, 0xee, 0x01, 0x43, 0x11, 0x15, + 0x52, 0xee, 0x01, 0xb3, 0x06, 0x43, 0x4d, 0x00, 0x49, 0xee, 0x41, 0x42, + 0xe8, 0x01, 0x51, 0xee, 0x01, 0x43, 0xe9, 0x09, 0x4e, 0xee, 0x01, 0x44, + 0x36, 0xe1, 0x54, 0xee, 0x41, 0x42, 0xe8, 0x01, 0x59, 0xee, 0x01, 0x07, + 0xb4, 0x43, 0x01, 0xff, 0x44, 0x30, 0x48, 0x5d, 0xee, 0x01, 0x43, 0x11, + 0x15, 0x5f, 0xee, 0x41, 0x42, 0xe8, 0x01, 0x11, 0xee, 0x01, 0x43, 0xe9, + 0x09, 0x0e, 0xee, 0x01, 0x44, 0x36, 0xe1, 0x14, 0xee, 0x01, 0x09, 0xc6, + 0xb7, 0x01, 0xff, 0x43, 0x56, 0x07, 0x6f, 0xee, 0x01, 0x43, 0x35, 0x85, + 0x61, 0xee, 0x01, 0xa4, 0x74, 0x43, 0x70, 0xbe, 0x70, 0xee, 0x01, 0x45, + 0x8f, 0xa1, 0x7b, 0xee, 0x01, 0xa8, 0x5a, 0x44, 0x4c, 0x3a, 0x62, 0xee, + 0x01, 0xab, 0x46, 0x44, 0x3f, 0x22, 0x6c, 0xee, 0x01, 0x44, 0x30, 0x48, + 0x6d, 0xee, 0x01, 0x43, 0x11, 0x15, 0x72, 0xee, 0x01, 0xb3, 0x20, 0xb4, + 0x0c, 0x43, 0x4d, 0x00, 0x69, 0xee, 0x01, 0x43, 0xea, 0x82, 0x7a, 0xee, + 0x41, 0x42, 0x3d, 0x0a, 0x68, 0xee, 0x01, 0x42, 0x4e, 0x00, 0x75, 0xee, + 0x01, 0x43, 0x19, 0x45, 0x76, 0xee, 0x41, 0x42, 0xe8, 0x01, 0x71, 0xee, + 0x01, 0x43, 0xe9, 0x09, 0x6e, 0xee, 0x01, 0x44, 0x36, 0xe1, 0x74, 0xee, + 0x41, 0x42, 0x12, 0x15, 0x6a, 0xee, 0x01, 0x43, 0x49, 0x22, 0x77, 0xee, + 0x41, 0x42, 0x3d, 0x0a, 0x67, 0xee, 0x01, 0x42, 0x4e, 0x00, 0x64, 0xee, + 0x41, 0x42, 0xe8, 0x01, 0x79, 0xee, 0x01, 0x07, 0xb4, 0x43, 0x01, 0xff, + 0x43, 0x35, 0x85, 0x7c, 0xee, 0x01, 0x43, 0x70, 0xbe, 0x7e, 0xee, 0x41, + 0x4c, 0x1c, 0x94, 0xf1, 0xee, 0x01, 0x5a, 0x3f, 0x22, 0xf0, 0xee, 0x41, + 0x42, 0x57, 0x00, 0x0b, 0xee, 0x01, 0x06, 0x6d, 0x89, 0x01, 0xff, 0xa1, + 0xa3, 0x01, 0x43, 0x35, 0x85, 0x81, 0xee, 0x01, 0x02, 0x7b, 0x08, 0x90, + 0x01, 0x43, 0x70, 0xbe, 0x90, 0xee, 0x01, 0x45, 0x8f, 0xa1, 0x9b, 0xee, + 0x01, 0xa8, 0x76, 0x44, 0x4c, 0x3a, 0x82, 0xee, 0x01, 0x44, 0xc3, 0x43, + 0x97, 0xee, 0x01, 0x43, 0xb0, 0x00, 0x8b, 0xee, 0x01, 0x44, 0x3f, 0x22, + 0x8c, 0xee, 0x01, 0x44, 0x30, 0x48, 0x8d, 0xee, 0x01, 0x43, 0x11, 0x15, + 0x92, 0xee, 0x01, 0x43, 0x93, 0x54, 0x93, 0xee, 0x01, 0xb3, 0x38, 0xb4, + 0x1b, 0x43, 0x1c, 0x8f, 0x85, 0xee, 0x01, 0x43, 0x4d, 0x00, 0x89, 0xee, + 0x01, 0x02, 0x59, 0x00, 0x01, 0xff, 0xe8, 0x9a, 0xee, 0x01, 0x42, 0x9e, + 0x01, 0x86, 0xee, 0x41, 0x42, 0x3d, 0x0a, 0x88, 0xee, 0x01, 0x42, 0x4e, + 0x00, 0x95, 0xee, 0x01, 0xa8, 0x01, 0xff, 0x42, 0x13, 0x00, 0x98, 0xee, + 0x01, 0x42, 0x4e, 0x00, 0x96, 0xee, 0x41, 0x42, 0xe8, 0x01, 0x91, 0xee, + 0x01, 0x43, 0xe9, 0x09, 0x8e, 0xee, 0x01, 0x44, 0x36, 0xe1, 0x94, 0xee, + 0x41, 0x42, 0x3d, 0x0a, 0x87, 0xee, 0x01, 0x42, 0x4e, 0x00, 0x84, 0xee, + 0x41, 0xe4, 0x99, 0xee, 0x01, 0xec, 0x83, 0xee, 0x41, 0x42, 0x9e, 0x01, + 0x8f, 0xee, 0x01, 0x43, 0x68, 0x00, 0x80, 0xee, 0x41, 0x42, 0x12, 0x15, + 0x0a, 0xee, 0x01, 0x43, 0x49, 0x22, 0x17, 0xee, 0x41, 0x43, 0x56, 0x07, + 0x2f, 0xee, 0x01, 0x43, 0x35, 0x85, 0x21, 0xee, 0x01, 0x43, 0xec, 0xd5, + 0x39, 0xee, 0x01, 0x43, 0x70, 0xbe, 0x30, 0xee, 0x01, 0x45, 0x8f, 0xa1, + 0x3b, 0xee, 0x01, 0xa8, 0x54, 0x44, 0x4c, 0x3a, 0x22, 0xee, 0x01, 0xab, + 0x40, 0x43, 0xb0, 0x00, 0x2b, 0xee, 0x01, 0x44, 0x3f, 0x22, 0x2c, 0xee, + 0x01, 0x44, 0x30, 0x48, 0x2d, 0xee, 0x01, 0x43, 0x11, 0x15, 0x32, 0xee, + 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x43, 0x4d, 0x00, 0x29, 0xee, 0x41, 0x42, + 0x4e, 0x00, 0x35, 0xee, 0x01, 0x43, 0x19, 0x45, 0x36, 0xee, 0x41, 0x42, + 0xe8, 0x01, 0x31, 0xee, 0x01, 0x43, 0xe9, 0x09, 0x2e, 0xee, 0x01, 0x44, + 0x36, 0xe1, 0x34, 0xee, 0x41, 0x42, 0x12, 0x15, 0x2a, 0xee, 0x01, 0x43, + 0x49, 0x22, 0x37, 0xee, 0x41, 0x42, 0x3d, 0x0a, 0x27, 0xee, 0x01, 0x42, + 0x4e, 0x00, 0x24, 0xee, 0x41, 0xa1, 0xc6, 0x01, 0xaf, 0x01, 0xff, 0x06, + 0xb5, 0x43, 0xa6, 0x01, 0x0c, 0x9c, 0x7a, 0x01, 0xff, 0x43, 0x56, 0x07, + 0xaf, 0xee, 0x01, 0x43, 0x35, 0x85, 0xa1, 0xee, 0x01, 0x02, 0x7b, 0x08, + 0x88, 0x01, 0x43, 0x70, 0xbe, 0xb0, 0xee, 0x01, 0x45, 0x8f, 0xa1, 0xbb, + 0xee, 0x01, 0x43, 0x49, 0x22, 0xa7, 0xee, 0x01, 0x44, 0x4c, 0x3a, 0xa2, + 0xee, 0x01, 0x44, 0xc3, 0x43, 0xb7, 0xee, 0x01, 0x43, 0xb0, 0x00, 0xab, + 0xee, 0x01, 0x44, 0x3f, 0x22, 0xac, 0xee, 0x01, 0x44, 0x30, 0x48, 0xad, + 0xee, 0x01, 0x43, 0x11, 0x15, 0xb2, 0xee, 0x01, 0x43, 0x93, 0x54, 0xb3, + 0xee, 0x01, 0xb3, 0x38, 0xb4, 0x1b, 0x43, 0x1c, 0x8f, 0xa5, 0xee, 0x01, + 0x43, 0x4d, 0x00, 0xa9, 0xee, 0x01, 0x02, 0x59, 0x00, 0x01, 0xff, 0xe8, + 0xba, 0xee, 0x01, 0x42, 0x9e, 0x01, 0xa6, 0xee, 0x41, 0x42, 0x3d, 0x0a, + 0xa8, 0xee, 0x01, 0x42, 0x4e, 0x00, 0xb5, 0xee, 0x01, 0xa8, 0x01, 0xff, + 0x42, 0x13, 0x00, 0xb8, 0xee, 0x01, 0x42, 0x4e, 0x00, 0xb6, 0xee, 0x41, + 0x42, 0xe8, 0x01, 0xb1, 0xee, 0x01, 0x43, 0xe9, 0x09, 0xae, 0xee, 0x01, + 0x44, 0x36, 0xe1, 0xb4, 0xee, 0x41, 0xe4, 0xb9, 0xee, 0x01, 0xec, 0xa3, + 0xee, 0x41, 0x43, 0x35, 0x85, 0x1c, 0xee, 0x01, 0x43, 0x70, 0xbe, 0x1e, + 0xee, 0x01, 0x44, 0x30, 0x48, 0x1d, 0xee, 0x01, 0x43, 0x11, 0x15, 0x1f, + 0xee, 0x41, 0xe4, 0x19, 0xee, 0x01, 0xec, 0x03, 0xee, 0x41, 0x42, 0x9e, + 0x01, 0x0f, 0xee, 0x01, 0x43, 0x68, 0x00, 0x00, 0xee, 0x41, 0x45, 0x5c, + 0xeb, 0xf9, 0x0e, 0x01, 0x4b, 0x30, 0x48, 0x58, 0x06, 0x00, 0x54, 0x27, + 0x48, 0xff, 0x08, 0x40, 0x47, 0x6a, 0xd3, 0x9c, 0x08, 0x00, 0x47, 0xdb, + 0x2e, 0x53, 0x06, 0x40, 0x05, 0x4a, 0x1d, 0xc6, 0x41, 0xa5, 0xdf, 0x22, + 0x08, 0xde, 0x11, 0x01, 0xff, 0xa1, 0xbd, 0x20, 0xa2, 0x8c, 0x1f, 0x02, + 0x7b, 0x08, 0xe4, 0x1d, 0x09, 0x70, 0xbe, 0xe3, 0x1c, 0x0b, 0x8f, 0xa1, + 0x84, 0x1c, 0xa8, 0xb4, 0x1a, 0xaa, 0xa5, 0x19, 0xab, 0x8f, 0x17, 0x09, + 0x1a, 0x15, 0xc8, 0x14, 0xad, 0x85, 0x13, 0xae, 0x85, 0x11, 0xb1, 0xea, + 0x0f, 0xb2, 0xc5, 0x0e, 0xb3, 0x83, 0x08, 0xb4, 0x92, 0x04, 0x36, 0x3e, + 0x00, 0xf8, 0x03, 0x56, 0x1b, 0x3a, 0xf8, 0xfd, 0x00, 0x09, 0x4d, 0x00, + 0x19, 0x0e, 0xea, 0x82, 0x01, 0xff, 0xa9, 0x06, 0x4b, 0x1a, 0x71, 0x3b, + 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xb9, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x28, + 0xfc, 0x40, 0x0d, 0x67, 0x00, 0xc4, 0x03, 0xa8, 0x83, 0x01, 0x05, 0x4c, + 0x3a, 0x6b, 0x06, 0xf3, 0x5d, 0x5b, 0x05, 0x3f, 0x22, 0x22, 0x4f, 0xe6, + 0x73, 0x94, 0xfc, 0x00, 0x4e, 0x6a, 0x7f, 0x91, 0xfc, 0x00, 0x04, 0x4d, + 0x00, 0x06, 0x4f, 0x5a, 0x78, 0x92, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0x96, + 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x5a, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0x93, + 0xfc, 0x00, 0xa9, 0x21, 0x4b, 0x1a, 0x71, 0xf0, 0xfc, 0x00, 0x05, 0x51, + 0x00, 0x01, 0xff, 0x05, 0x3f, 0x22, 0x06, 0x4e, 0x38, 0x51, 0xb0, 0xfd, + 0x40, 0x4a, 0x7c, 0x2e, 0x9c, 0xfd, 0x00, 0x4c, 0x86, 0x17, 0x9d, 0xfd, + 0x40, 0x4b, 0x87, 0x17, 0xdd, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x58, 0xfc, + 0x40, 0x4b, 0x87, 0x17, 0xdc, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x57, 0xfc, + 0x40, 0xa9, 0x06, 0x53, 0x33, 0x51, 0xaf, 0xfd, 0x40, 0x4b, 0x87, 0x17, + 0xda, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x55, 0xfc, 0x40, 0xa1, 0x11, 0x03, + 0x4e, 0x00, 0x01, 0xff, 0x4c, 0x86, 0x17, 0xde, 0xfc, 0x00, 0x4b, 0x1a, + 0x71, 0xf1, 0xfc, 0x40, 0x02, 0x4f, 0x00, 0x92, 0x02, 0x0f, 0x58, 0x00, + 0x01, 0xff, 0xa1, 0xd8, 0x01, 0x02, 0x60, 0x00, 0xbe, 0x01, 0xa8, 0x9a, + 0x01, 0x06, 0x4c, 0x3a, 0x89, 0x01, 0x51, 0xf3, 0x5d, 0x99, 0xfc, 0x00, + 0x05, 0x3f, 0x22, 0x65, 0x4f, 0xe6, 0x73, 0x67, 0xfc, 0x00, 0x03, 0xe3, + 0x9c, 0x4f, 0x4e, 0x6a, 0x7f, 0x64, 0xfc, 0x00, 0x02, 0x2e, 0x02, 0x39, + 0x04, 0x20, 0xf9, 0x29, 0xb9, 0x06, 0x4f, 0x5a, 0x78, 0x65, 0xfc, 0x40, + 0x03, 0x4e, 0x00, 0x11, 0x02, 0x2e, 0x02, 0x01, 0xff, 0x4a, 0x7c, 0x2e, + 0xf5, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0xf4, 0xfb, 0x40, 0x4a, 0x7c, 0x2e, + 0x69, 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x04, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, + 0xef, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0xee, 0xfb, 0x40, 0x4a, 0x7c, 0x2e, + 0xf1, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0xf0, 0xfb, 0x40, 0x4a, 0x7c, 0x2e, + 0xf3, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0xf2, 0xfb, 0x40, 0x4a, 0x7c, 0x2e, + 0x66, 0xfc, 0x00, 0xa9, 0x06, 0x4b, 0x1a, 0x71, 0xdf, 0xfc, 0x40, 0x4b, + 0x87, 0x17, 0x9a, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x02, 0xfc, 0x40, 0x4b, + 0x87, 0x17, 0x97, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x00, 0xfc, 0x40, 0x04, + 0xf5, 0x5c, 0x11, 0x03, 0x4e, 0x00, 0x01, 0xff, 0x4c, 0x86, 0x17, 0x9b, + 0xfc, 0x00, 0x4b, 0x1a, 0x71, 0xe0, 0xfc, 0x40, 0x4b, 0x87, 0x17, 0x98, + 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x01, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0xf7, + 0xfb, 0x00, 0xa9, 0x01, 0xff, 0x4b, 0x87, 0x17, 0xf8, 0xfb, 0x00, 0x4c, + 0x60, 0x03, 0xf6, 0xfb, 0x40, 0x02, 0x60, 0x00, 0x22, 0x04, 0x68, 0x00, + 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0xeb, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0xea, + 0xfb, 0x00, 0x08, 0x6c, 0x00, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x68, 0xfc, + 0x00, 0x4d, 0x5f, 0x03, 0x03, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0xed, 0xfb, + 0x00, 0x4d, 0x5f, 0x03, 0xec, 0xfb, 0x40, 0xa9, 0x06, 0x53, 0x33, 0x51, + 0xae, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xdb, 0xfc, 0x00, 0x4c, 0x60, 0x03, + 0x56, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0x95, 0xfc, 0x00, 0x4d, 0x5f, 0x03, + 0x59, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0xfa, 0xfb, 0x00, 0xa9, 0x01, 0xff, + 0x4b, 0x87, 0x17, 0xfb, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0xf9, 0xfb, 0x40, + 0xa1, 0xf6, 0x02, 0x08, 0x4e, 0x00, 0x6a, 0xa8, 0x01, 0xff, 0x66, 0x67, + 0x06, 0x5b, 0xfc, 0x00, 0x08, 0x4e, 0x00, 0x01, 0xff, 0x0d, 0x67, 0x00, + 0x4c, 0x4f, 0x16, 0x71, 0xe6, 0xfc, 0x00, 0x52, 0x6d, 0x55, 0x11, 0xfc, + 0x00, 0x05, 0x3f, 0x22, 0x22, 0x4f, 0xe6, 0x73, 0x79, 0xfc, 0x00, 0x4e, + 0x6a, 0x7f, 0x76, 0xfc, 0x00, 0x04, 0x4d, 0x00, 0x06, 0x4f, 0x5a, 0x78, + 0x77, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0x7b, 0xfc, 0x00, 0x4d, 0x5f, 0x03, + 0x14, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0x78, 0xfc, 0x00, 0xa9, 0x06, 0x4b, + 0x1a, 0x71, 0xe5, 0xfc, 0x40, 0x4b, 0x87, 0x17, 0xa6, 0xfc, 0x00, 0x4c, + 0x60, 0x03, 0x12, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0x7a, 0xfc, 0x00, 0x4d, + 0x5f, 0x03, 0x13, 0xfc, 0x40, 0x0d, 0x67, 0x00, 0xf7, 0x01, 0xa8, 0xb6, + 0x01, 0x05, 0x4c, 0x3a, 0x8c, 0x01, 0x05, 0xf3, 0x5d, 0x63, 0x05, 0x3f, + 0x22, 0x22, 0x4f, 0xe6, 0x73, 0x73, 0xfc, 0x00, 0x4e, 0x6a, 0x7f, 0x70, + 0xfc, 0x00, 0x04, 0x4d, 0x00, 0x06, 0x4f, 0x5a, 0x78, 0x71, 0xfc, 0x40, + 0x4a, 0x7c, 0x2e, 0x75, 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x10, 0xfc, 0x40, + 0x4a, 0x7c, 0x2e, 0x72, 0xfc, 0x00, 0xa9, 0x29, 0x4b, 0x1a, 0x71, 0xe3, + 0xfc, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x57, 0x6f, 0x2e, 0xa4, 0xfd, + 0x00, 0x50, 0xf4, 0x5d, 0x56, 0xfd, 0x00, 0x51, 0x4c, 0x3a, 0x55, 0xfd, + 0x00, 0x51, 0xf3, 0x5d, 0x57, 0xfd, 0x00, 0x4e, 0x38, 0x51, 0xa3, 0xfd, + 0x40, 0x4b, 0x87, 0x17, 0xa4, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x0e, 0xfc, + 0x40, 0xa9, 0x17, 0x05, 0x51, 0x00, 0x01, 0xff, 0x57, 0x6f, 0x2e, 0xa2, + 0xfd, 0x00, 0x51, 0xd0, 0x5e, 0x54, 0xfd, 0x00, 0x4e, 0x38, 0x51, 0xa1, + 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xa3, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x0d, + 0xfc, 0x40, 0xa9, 0x17, 0x05, 0x51, 0x00, 0x01, 0xff, 0x57, 0x6f, 0x2e, + 0xa0, 0xfd, 0x00, 0x51, 0xd0, 0x5e, 0x50, 0xfd, 0x00, 0x4e, 0x38, 0x51, + 0x9f, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xa1, 0xfc, 0x00, 0x4c, 0x60, 0x03, + 0x0b, 0xfc, 0x40, 0x03, 0x3d, 0x0a, 0x11, 0x03, 0x4e, 0x00, 0x01, 0xff, + 0x4c, 0x86, 0x17, 0xa5, 0xfc, 0x00, 0x4b, 0x1a, 0x71, 0xe4, 0xfc, 0x40, + 0xa9, 0x1b, 0x05, 0x51, 0x00, 0x01, 0xff, 0x05, 0x4c, 0x3a, 0x06, 0x51, + 0xd0, 0x5e, 0x53, 0xfd, 0x40, 0x4a, 0x7c, 0x2e, 0x51, 0xfd, 0x00, 0x4c, + 0x86, 0x17, 0x52, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xa2, 0xfc, 0x00, 0x4c, + 0x60, 0x03, 0x0c, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0x74, 0xfc, 0x00, 0x4d, + 0x5f, 0x03, 0x0f, 0xfc, 0x40, 0x52, 0xf7, 0x52, 0x4e, 0xfd, 0x00, 0x07, + 0x4f, 0x00, 0x01, 0xff, 0x0d, 0x67, 0x00, 0x5a, 0x05, 0xf4, 0x5c, 0x4a, + 0x05, 0x3f, 0x22, 0x11, 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x7c, 0x2e, + 0x12, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0xf6, 0xfc, 0x40, 0xa9, 0x27, 0x4b, + 0x1a, 0x71, 0x3a, 0xfd, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x04, 0x49, + 0x22, 0x0c, 0x51, 0xd0, 0x5e, 0x73, 0xfd, 0x00, 0x4e, 0x38, 0x51, 0x74, + 0xfd, 0x40, 0x4a, 0x7c, 0x2e, 0x71, 0xfd, 0x00, 0x4c, 0x86, 0x17, 0x72, + 0xfd, 0x40, 0x4b, 0x87, 0x17, 0x33, 0xfd, 0x00, 0x4c, 0x60, 0x03, 0x27, + 0xfc, 0x40, 0x4b, 0x87, 0x17, 0xb8, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x26, + 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0x11, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0xf5, + 0xfc, 0x40, 0xa1, 0xde, 0x04, 0x09, 0xbc, 0xbd, 0xde, 0x02, 0xa8, 0x06, + 0x54, 0x8b, 0x48, 0xfe, 0xfd, 0x40, 0x0a, 0xb8, 0xac, 0x8b, 0x02, 0x09, + 0xbc, 0xbd, 0x01, 0xff, 0x0d, 0x67, 0x00, 0xf5, 0x01, 0xa8, 0xa8, 0x01, + 0x05, 0x4c, 0x3a, 0x83, 0x01, 0x05, 0xf3, 0x5d, 0x65, 0x05, 0x3f, 0x22, + 0x21, 0x04, 0x6a, 0x7f, 0x11, 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x7c, + 0x2e, 0x1a, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0xfe, 0xfc, 0x40, 0x4a, 0x7c, + 0x2e, 0x29, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0x0d, 0xfd, 0x40, 0x4a, 0x7c, + 0x2e, 0x28, 0xfd, 0x00, 0xa9, 0x2c, 0x4b, 0x1a, 0x71, 0xe9, 0xfc, 0x00, + 0x05, 0x51, 0x00, 0x01, 0xff, 0x05, 0xf3, 0x5d, 0x11, 0x05, 0x3f, 0x22, + 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x6c, 0xfd, 0x00, 0x4c, 0x86, 0x17, 0x6d, + 0xfd, 0x40, 0x4a, 0x7c, 0x2e, 0x6a, 0xfd, 0x00, 0x4c, 0x86, 0x17, 0x6b, + 0xfd, 0x40, 0x4b, 0x87, 0x17, 0x30, 0xfd, 0x00, 0x4c, 0x60, 0x03, 0x0c, + 0xfd, 0x40, 0x4a, 0x7c, 0x2e, 0x27, 0xfd, 0x00, 0xa9, 0x06, 0x4b, 0x1a, + 0x71, 0x39, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0x2f, 0xfd, 0x00, 0x4c, 0x60, + 0x03, 0x0b, 0xfd, 0x40, 0x4a, 0x7c, 0x2e, 0x25, 0xfd, 0x00, 0xa9, 0x0c, + 0x4b, 0x1a, 0x71, 0x37, 0xfd, 0x00, 0x53, 0x33, 0x51, 0x69, 0xfd, 0x40, + 0x4b, 0x87, 0x17, 0x2d, 0xfd, 0x00, 0x4c, 0x60, 0x03, 0x09, 0xfd, 0x40, + 0x03, 0x3d, 0x0a, 0x11, 0x03, 0x4e, 0x00, 0x01, 0xff, 0x4c, 0x86, 0x17, + 0x32, 0xfd, 0x00, 0x4b, 0x1a, 0x71, 0xea, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, + 0x26, 0xfd, 0x00, 0xa9, 0x21, 0x4b, 0x1a, 0x71, 0x38, 0xfd, 0x00, 0x05, + 0x51, 0x00, 0x01, 0xff, 0x05, 0x3f, 0x22, 0x06, 0x4e, 0x38, 0x51, 0xaa, + 0xfd, 0x40, 0x4a, 0x7c, 0x2e, 0x67, 0xfd, 0x00, 0x4c, 0x86, 0x17, 0x68, + 0xfd, 0x40, 0x4b, 0x87, 0x17, 0x2e, 0xfd, 0x00, 0x4c, 0x60, 0x03, 0x0a, + 0xfd, 0x40, 0x4a, 0x7c, 0x2e, 0x19, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0xfd, + 0xfc, 0x40, 0x05, 0xa0, 0x61, 0x2e, 0x06, 0xa4, 0xe1, 0x1e, 0x05, 0x16, + 0x53, 0x06, 0x5e, 0x6f, 0x06, 0x63, 0xfc, 0x40, 0x80, 0x06, 0x51, 0xbd, + 0x60, 0x5f, 0xfc, 0x40, 0x4d, 0x5f, 0x03, 0x62, 0xfc, 0x00, 0x4b, 0x1a, + 0x71, 0xf4, 0xfc, 0x40, 0x4d, 0x5f, 0x03, 0x60, 0xfc, 0x00, 0x4b, 0x1a, + 0x71, 0xf2, 0xfc, 0x40, 0x80, 0x06, 0x51, 0xbd, 0x60, 0x5e, 0xfc, 0x40, + 0x4d, 0x5f, 0x03, 0x61, 0xfc, 0x00, 0x4b, 0x1a, 0x71, 0xf3, 0xfc, 0x40, + 0x0d, 0x67, 0x00, 0xea, 0x01, 0xa8, 0xb8, 0x01, 0x05, 0x4c, 0x3a, 0x8e, + 0x01, 0x05, 0xf3, 0x5d, 0x65, 0x05, 0x3f, 0x22, 0x21, 0x04, 0x6a, 0x7f, + 0x11, 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x18, 0xfd, 0x00, + 0x4d, 0x5f, 0x03, 0xfc, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0x2a, 0xfd, 0x00, + 0x4d, 0x5f, 0x03, 0x0e, 0xfd, 0x40, 0xa9, 0x32, 0x4b, 0x1a, 0x71, 0xe7, + 0xfc, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x04, 0x49, 0x22, 0x17, 0x51, + 0x4c, 0x3a, 0x61, 0xfd, 0x00, 0x05, 0x3f, 0x22, 0x01, 0xff, 0x4a, 0x7c, + 0x2e, 0x62, 0xfd, 0x00, 0x4c, 0x86, 0x17, 0x63, 0xfd, 0x40, 0x4a, 0x7c, + 0x2e, 0x5f, 0xfd, 0x00, 0x4c, 0x86, 0x17, 0x60, 0xfd, 0x40, 0x4b, 0x87, + 0x17, 0xb0, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x1f, 0xfc, 0x40, 0xa9, 0x17, + 0x4b, 0x1a, 0x71, 0x36, 0xfd, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x57, + 0x6f, 0x2e, 0xa8, 0xfd, 0x00, 0x4e, 0x38, 0x51, 0xc6, 0xfd, 0x40, 0x4b, + 0x87, 0x17, 0xaf, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x1e, 0xfc, 0x40, 0xa9, + 0x17, 0x4b, 0x1a, 0x71, 0x34, 0xfd, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, + 0x57, 0x6f, 0x2e, 0x5e, 0xfd, 0x00, 0x50, 0xf4, 0x5d, 0x5d, 0xfd, 0x40, + 0x4b, 0x87, 0x17, 0xad, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x1c, 0xfc, 0x40, + 0x03, 0x3d, 0x0a, 0x11, 0x03, 0x4e, 0x00, 0x01, 0xff, 0x4c, 0x86, 0x17, + 0x31, 0xfd, 0x00, 0x4b, 0x1a, 0x71, 0xe8, 0xfc, 0x40, 0xa9, 0x0c, 0x4b, + 0x1a, 0x71, 0x35, 0xfd, 0x00, 0x56, 0x47, 0x3a, 0x5c, 0xfd, 0x40, 0x4b, + 0x87, 0x17, 0xae, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x1d, 0xfc, 0x40, 0x4a, + 0x7c, 0x2e, 0x17, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0xfb, 0xfc, 0x40, 0x07, + 0xeb, 0x0a, 0x53, 0xac, 0x01, 0xff, 0xa1, 0x42, 0x02, 0x74, 0x00, 0x01, + 0xff, 0x80, 0x2f, 0x03, 0xba, 0x0e, 0x01, 0xff, 0x04, 0x79, 0x1a, 0x1a, + 0xa8, 0x01, 0xff, 0x52, 0x9f, 0x56, 0xfa, 0xfd, 0x00, 0x0b, 0x4b, 0xa9, + 0x01, 0xff, 0x57, 0x58, 0x2e, 0xcc, 0xfd, 0x00, 0x51, 0x5e, 0x2e, 0x4c, + 0xfd, 0x40, 0x4f, 0xb0, 0x6d, 0x46, 0xfd, 0x00, 0x58, 0xf4, 0x2c, 0xd0, + 0xfb, 0x40, 0x4d, 0x5f, 0x03, 0xf9, 0xfd, 0x00, 0x67, 0x45, 0x03, 0xf0, + 0xfd, 0x40, 0x4d, 0x58, 0x84, 0xcf, 0xfd, 0x00, 0x4f, 0x22, 0x3a, 0xf5, + 0xfd, 0x40, 0x0d, 0x67, 0x00, 0x77, 0x04, 0x49, 0x22, 0x4a, 0x51, 0xf3, + 0x5d, 0xb2, 0xfc, 0x00, 0x05, 0x3f, 0x22, 0x21, 0x04, 0x6a, 0x7f, 0x11, + 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x22, 0xfd, 0x00, 0x4d, + 0x5f, 0x03, 0x06, 0xfd, 0x40, 0x4a, 0x7c, 0x2e, 0x2b, 0xfd, 0x00, 0x4d, + 0x5f, 0x03, 0x0f, 0xfd, 0x40, 0xa9, 0x11, 0x0a, 0xee, 0x82, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0x66, 0xfd, 0x00, 0x4c, 0x86, 0x17, 0xc5, 0xfd, 0x40, + 0x4b, 0x87, 0x17, 0xb3, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x21, 0xfc, 0x40, + 0xa9, 0x1b, 0x05, 0x51, 0x00, 0x01, 0xff, 0x04, 0x49, 0x22, 0x06, 0x4e, + 0x38, 0x51, 0xa9, 0xfd, 0x40, 0x4a, 0x7c, 0x2e, 0x64, 0xfd, 0x00, 0x4c, + 0x86, 0x17, 0x65, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xb1, 0xfc, 0x00, 0x4c, + 0x60, 0x03, 0x20, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0x21, 0xfd, 0x00, 0x4d, + 0x5f, 0x03, 0x05, 0xfd, 0x40, 0xa1, 0x06, 0x66, 0xb3, 0x06, 0x5c, 0xfc, + 0x40, 0x0b, 0x0e, 0xa0, 0x5b, 0xa8, 0x06, 0x52, 0xf5, 0x57, 0xf6, 0xfd, + 0x40, 0x05, 0x5a, 0xed, 0x25, 0x0d, 0xee, 0x89, 0x01, 0xff, 0x45, 0x15, + 0x22, 0x90, 0xfd, 0x80, 0x06, 0x4d, 0xf4, 0x2c, 0xc5, 0xfb, 0x40, 0x42, + 0x4e, 0x13, 0x91, 0xfd, 0x00, 0x42, 0x29, 0x02, 0xc6, 0xfb, 0xc0, 0x00, + 0x42, 0x4e, 0x13, 0xc7, 0xfb, 0x40, 0x47, 0x44, 0x2f, 0x40, 0xfd, 0x80, + 0x1d, 0xad, 0x01, 0xff, 0x47, 0x44, 0x2f, 0x4f, 0xfd, 0x80, 0x0d, 0x49, + 0x43, 0x52, 0xc9, 0xfb, 0xc0, 0x00, 0x49, 0x4c, 0x52, 0xca, 0xfb, 0x40, + 0x49, 0x4c, 0x52, 0xc8, 0xfb, 0x40, 0x48, 0x97, 0x48, 0xc8, 0xfd, 0x40, + 0x43, 0x32, 0x6f, 0x41, 0xfd, 0x80, 0x1a, 0x4b, 0x7a, 0xa8, 0xc9, 0xfd, + 0xc0, 0x00, 0x42, 0x4e, 0x13, 0xca, 0xfd, 0x00, 0x42, 0x48, 0x04, 0xcb, + 0xfb, 0xc0, 0x00, 0x42, 0x4e, 0x13, 0xcb, 0xfd, 0x40, 0x42, 0x4e, 0x13, + 0x42, 0xfd, 0x00, 0xb5, 0x01, 0xff, 0xed, 0x43, 0xfd, 0x80, 0x06, 0x43, + 0x38, 0x48, 0x45, 0xfd, 0x40, 0x42, 0x4e, 0x13, 0x44, 0xfd, 0x40, 0xa1, + 0x22, 0x06, 0xea, 0xe6, 0x01, 0xff, 0x05, 0xac, 0x43, 0x06, 0x4c, 0x88, + 0x9a, 0xd7, 0x0e, 0x41, 0x42, 0x3d, 0x0a, 0x4b, 0xfd, 0x00, 0x44, 0x9d, + 0x5a, 0xd5, 0x0e, 0xc1, 0x00, 0x42, 0x4e, 0x13, 0xd6, 0x0e, 0x41, 0x54, + 0x9f, 0x43, 0xd4, 0x0e, 0x01, 0x07, 0x13, 0x15, 0x06, 0x6a, 0x42, 0x03, + 0xf1, 0xfd, 0x40, 0x0d, 0x67, 0x00, 0x54, 0x05, 0xf4, 0x5c, 0x44, 0x05, + 0x3f, 0x22, 0x11, 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x7f, + 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x36, 0xfc, 0x40, 0xa9, 0x21, 0x05, 0x51, + 0x00, 0x01, 0xff, 0x04, 0x49, 0x22, 0x0c, 0x4f, 0x5f, 0x73, 0x7f, 0xfd, + 0x00, 0x4e, 0x38, 0x51, 0xb2, 0xfd, 0x40, 0x4a, 0x7c, 0x2e, 0x7e, 0xfd, + 0x00, 0x4c, 0x86, 0x17, 0xb4, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xc3, 0xfc, + 0x00, 0x4c, 0x60, 0x03, 0x34, 0xfc, 0x40, 0x4b, 0x87, 0x17, 0xc2, 0xfc, + 0x00, 0x4c, 0x60, 0x03, 0x33, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0x7e, 0xfc, + 0x00, 0x4d, 0x5f, 0x03, 0x35, 0xfc, 0x40, 0x57, 0x3e, 0x2f, 0xd8, 0x0e, + 0x01, 0x09, 0x94, 0x05, 0x01, 0xff, 0x0d, 0x67, 0x00, 0xe1, 0x01, 0xa8, + 0xa4, 0x01, 0x05, 0x4c, 0x3a, 0x61, 0x06, 0xf3, 0x5d, 0x51, 0x05, 0x3f, + 0x22, 0x22, 0x4f, 0xe6, 0x73, 0x8d, 0xfc, 0x00, 0x4e, 0x6a, 0x7f, 0x8a, + 0xfc, 0x00, 0x04, 0x4d, 0x00, 0x06, 0x4f, 0x5a, 0x78, 0x8b, 0xfc, 0x40, + 0x4a, 0x7c, 0x2e, 0x8f, 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x50, 0xfc, 0x40, + 0x4a, 0x7c, 0x2e, 0x8c, 0xfc, 0x00, 0xa9, 0x17, 0x4b, 0x1a, 0x71, 0xee, + 0xfc, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x57, 0x6f, 0x2e, 0x9b, 0xfd, + 0x00, 0x4e, 0x38, 0x51, 0x9a, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xd5, 0xfc, + 0x00, 0x4c, 0x60, 0x03, 0x4e, 0xfc, 0x40, 0x4b, 0x87, 0x17, 0xd4, 0xfc, + 0x00, 0x4c, 0x60, 0x03, 0x4d, 0xfc, 0x40, 0xa9, 0x31, 0x05, 0x51, 0x00, + 0x01, 0xff, 0x57, 0x6f, 0x2e, 0x99, 0xfd, 0x00, 0x04, 0x49, 0x22, 0x16, + 0x05, 0x3f, 0x22, 0x06, 0x4e, 0x38, 0x51, 0xc7, 0xfd, 0x40, 0x4a, 0x7c, + 0x2e, 0x97, 0xfd, 0x00, 0x4c, 0x86, 0x17, 0x98, 0xfd, 0x40, 0x4a, 0x7c, + 0x2e, 0xbd, 0xfd, 0x00, 0x4c, 0x86, 0x17, 0xb8, 0xfd, 0x40, 0x4b, 0x87, + 0x17, 0xd2, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x4b, 0xfc, 0x40, 0x03, 0x3d, + 0x0a, 0x11, 0x03, 0x4e, 0x00, 0x01, 0xff, 0x4c, 0x86, 0x17, 0xd6, 0xfc, + 0x00, 0x4b, 0x1a, 0x71, 0xef, 0xfc, 0x40, 0xa9, 0x17, 0x05, 0x51, 0x00, + 0x01, 0xff, 0x57, 0x6f, 0x2e, 0x96, 0xfd, 0x00, 0x51, 0xd0, 0x5e, 0x95, + 0xfd, 0x00, 0x4e, 0x38, 0x51, 0xb3, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xd3, + 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x4c, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0x8e, + 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x4f, 0xfc, 0x40, 0x09, 0x40, 0x22, 0x06, + 0x55, 0x60, 0x3f, 0xf4, 0xfd, 0x40, 0x05, 0x67, 0x00, 0xa5, 0x01, 0x04, + 0x49, 0x22, 0x7c, 0x05, 0x4c, 0x3a, 0x4d, 0x05, 0xf3, 0x5d, 0x24, 0x05, + 0x3f, 0x22, 0x06, 0x51, 0x88, 0x62, 0x4a, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, + 0x89, 0xfc, 0x00, 0xa9, 0x06, 0x53, 0x33, 0x51, 0xb1, 0xfd, 0x40, 0x4b, + 0x87, 0x17, 0xd1, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x48, 0xfc, 0x40, 0xa9, + 0x17, 0x05, 0x51, 0x00, 0x01, 0xff, 0x51, 0x4c, 0x3a, 0x8e, 0xfd, 0x00, + 0x51, 0xd0, 0x5e, 0x8f, 0xfd, 0x00, 0x4e, 0x38, 0x51, 0xb9, 0xfd, 0x40, + 0x4b, 0x87, 0x17, 0xd0, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x47, 0xfc, 0x40, + 0xa9, 0x1d, 0x05, 0x51, 0x00, 0x01, 0xff, 0x50, 0xf4, 0x5d, 0x8c, 0xfd, + 0x00, 0x51, 0xf3, 0x5d, 0x92, 0xfd, 0x00, 0x51, 0xd0, 0x5e, 0x8d, 0xfd, + 0x00, 0x4e, 0x38, 0x51, 0xc0, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xce, 0xfc, + 0x00, 0x4c, 0x60, 0x03, 0x45, 0xfc, 0x40, 0xa9, 0x17, 0x05, 0x51, 0x00, + 0x01, 0xff, 0x51, 0x4c, 0x3a, 0x89, 0xfd, 0x00, 0x51, 0xd0, 0x5e, 0x8a, + 0xfd, 0x00, 0x4e, 0x38, 0x51, 0x8b, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xcf, + 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x46, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0x88, + 0xfc, 0x00, 0x55, 0x22, 0x20, 0x49, 0xfc, 0x40, 0x05, 0x67, 0x00, 0xe6, + 0x01, 0xa8, 0xaa, 0x01, 0x05, 0x4c, 0x3a, 0x6d, 0x05, 0xf3, 0x5d, 0x4a, + 0x05, 0x3f, 0x22, 0x11, 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x7c, 0x2e, + 0x87, 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x44, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, + 0x85, 0xfc, 0x00, 0xa9, 0x21, 0x4b, 0x1a, 0x71, 0xed, 0xfc, 0x00, 0x05, + 0x51, 0x00, 0x01, 0xff, 0x04, 0x49, 0x22, 0x06, 0x4e, 0x38, 0x51, 0xad, + 0xfd, 0x40, 0x4a, 0x7c, 0x2e, 0x87, 0xfd, 0x00, 0x4c, 0x86, 0x17, 0x88, + 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xcc, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x42, + 0xfc, 0x40, 0xa9, 0x11, 0x0a, 0xee, 0x82, 0x01, 0xff, 0x4a, 0x7c, 0x2e, + 0x85, 0xfd, 0x00, 0x4c, 0x86, 0x17, 0x86, 0xfd, 0x40, 0x4b, 0x87, 0x17, + 0xcb, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x41, 0xfc, 0x40, 0xa9, 0x2b, 0x05, + 0x51, 0x00, 0x01, 0xff, 0x05, 0x4c, 0x3a, 0x16, 0x05, 0x3f, 0x22, 0x06, + 0x4e, 0x38, 0x51, 0xac, 0xfd, 0x40, 0x4a, 0x7c, 0x2e, 0xbc, 0xfd, 0x00, + 0x4c, 0x86, 0x17, 0xba, 0xfd, 0x40, 0x4a, 0x7c, 0x2e, 0x84, 0xfd, 0x00, + 0x4c, 0x86, 0x17, 0x83, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xc9, 0xfc, 0x00, + 0x4c, 0x60, 0x03, 0x3f, 0xfc, 0x40, 0x03, 0x3d, 0x0a, 0x06, 0x4f, 0x4b, + 0x66, 0xcd, 0xfc, 0x40, 0xa9, 0x21, 0x05, 0x51, 0x00, 0x01, 0xff, 0x57, + 0x6f, 0x2e, 0x82, 0xfd, 0x00, 0x05, 0x3f, 0x22, 0x06, 0x4e, 0x38, 0x51, + 0x81, 0xfd, 0x40, 0x4a, 0x7c, 0x2e, 0x80, 0xfd, 0x00, 0x4c, 0x86, 0x17, + 0xb5, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xca, 0xfc, 0x00, 0x4c, 0x60, 0x03, + 0x40, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0xfc, 0xfe, 0x00, 0x4d, 0x5f, 0x03, + 0xfb, 0xfe, 0x00, 0x08, 0x6c, 0x00, 0x3b, 0x05, 0x51, 0x00, 0x01, 0xff, + 0x06, 0x56, 0x00, 0x11, 0x0c, 0x80, 0x96, 0x01, 0xff, 0x4a, 0x7c, 0x2e, + 0xf6, 0xfe, 0x00, 0x4d, 0x5f, 0x03, 0xf5, 0xfe, 0x40, 0x06, 0x5c, 0x00, + 0x11, 0x06, 0x71, 0x13, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0xfa, 0xfe, 0x00, + 0x4d, 0x5f, 0x03, 0xf9, 0xfe, 0x40, 0x4a, 0x7c, 0x2e, 0xf8, 0xfe, 0x00, + 0x4d, 0x5f, 0x03, 0xf7, 0xfe, 0x40, 0x4a, 0x7c, 0x2e, 0x86, 0xfc, 0x00, + 0x4d, 0x5f, 0x03, 0x43, 0xfc, 0x40, 0xa1, 0x4c, 0x09, 0x49, 0x22, 0x01, + 0xff, 0x0d, 0x67, 0x00, 0x37, 0x51, 0xf4, 0x5c, 0x1a, 0xfc, 0x00, 0x06, + 0x4c, 0x3a, 0x21, 0x06, 0xd0, 0x5e, 0x11, 0x04, 0x4d, 0x00, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0x20, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0x04, 0xfd, 0x40, + 0x4b, 0x87, 0x17, 0xac, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x1b, 0xfc, 0x40, + 0x4b, 0x87, 0x17, 0xab, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x19, 0xfc, 0x40, + 0x4a, 0x7c, 0x2e, 0x1f, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0x03, 0xfd, 0x40, + 0x07, 0x13, 0x15, 0x06, 0x54, 0xc3, 0x47, 0xce, 0xfd, 0x40, 0x05, 0x67, + 0x00, 0x99, 0x01, 0x05, 0xf4, 0x5c, 0x88, 0x01, 0x06, 0x4c, 0x3a, 0x78, + 0x06, 0xf3, 0x5d, 0x68, 0x04, 0x1a, 0x15, 0x4a, 0x05, 0x3f, 0x22, 0x11, + 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x84, 0xfc, 0x00, 0x4d, + 0x5f, 0x03, 0x3e, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0x82, 0xfc, 0x00, 0xa9, + 0x21, 0x4b, 0x1a, 0x71, 0xec, 0xfc, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, + 0x05, 0x3f, 0x22, 0x06, 0x4e, 0x38, 0x51, 0xb7, 0xfd, 0x40, 0x4a, 0x7c, + 0x2e, 0xbb, 0xfd, 0x00, 0x4c, 0x86, 0x17, 0xc3, 0xfd, 0x40, 0x4b, 0x87, + 0x17, 0xc8, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x3c, 0xfc, 0x40, 0x4a, 0x7c, + 0x2e, 0x81, 0xfc, 0x00, 0xa9, 0x06, 0x4b, 0x1a, 0x71, 0xeb, 0xfc, 0x40, + 0x4b, 0x87, 0x17, 0xc7, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x3b, 0xfc, 0x40, + 0x4b, 0x87, 0x17, 0xc6, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x3a, 0xfc, 0x40, + 0x4b, 0x87, 0x17, 0xc4, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x38, 0xfc, 0x40, + 0x4b, 0x87, 0x17, 0xc5, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x39, 0xfc, 0x40, + 0x4a, 0x7c, 0x2e, 0x80, 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x37, 0xfc, 0x00, + 0x08, 0x6c, 0x00, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x83, 0xfc, 0x00, 0x4d, + 0x5f, 0x03, 0x3d, 0xfc, 0x40, 0x04, 0x0d, 0x22, 0x7c, 0x09, 0x40, 0x22, + 0x01, 0xff, 0x0d, 0x67, 0x00, 0x67, 0x04, 0x49, 0x22, 0x44, 0x05, 0x3f, + 0x22, 0x11, 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x1e, 0xfd, + 0x00, 0x4d, 0x5f, 0x03, 0x02, 0xfd, 0x40, 0xa9, 0x21, 0x05, 0x51, 0x00, + 0x01, 0xff, 0x57, 0x6f, 0x2e, 0xa7, 0xfd, 0x00, 0x04, 0x49, 0x22, 0x06, + 0x4e, 0x38, 0x51, 0xa5, 0xfd, 0x40, 0x4a, 0x7c, 0x2e, 0x58, 0xfd, 0x00, + 0x4c, 0x86, 0x17, 0x59, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xa8, 0xfc, 0x00, + 0x4c, 0x60, 0x03, 0x16, 0xfc, 0x40, 0xa9, 0x11, 0x05, 0x51, 0x00, 0x01, + 0xff, 0x57, 0x6f, 0x2e, 0xa6, 0xfd, 0x00, 0x4e, 0x38, 0x51, 0xbe, 0xfd, + 0x40, 0x4b, 0x87, 0x17, 0xa7, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x15, 0xfc, + 0x40, 0x4a, 0x7c, 0x2e, 0x1d, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0x01, 0xfd, + 0x40, 0x48, 0x5f, 0xc8, 0xc3, 0xfb, 0x00, 0x4a, 0xae, 0xb1, 0xfb, 0xfd, + 0x40, 0xa1, 0x4a, 0x08, 0x4e, 0x00, 0x01, 0xff, 0x5a, 0x1d, 0x20, 0x53, + 0xfc, 0x00, 0x06, 0x4c, 0x3a, 0x2f, 0x05, 0x3f, 0x22, 0x0c, 0x5d, 0x75, + 0x17, 0xd9, 0xfc, 0x00, 0x51, 0x88, 0x62, 0x54, 0xfc, 0x40, 0xa9, 0x11, + 0x05, 0x51, 0x00, 0x01, 0xff, 0x51, 0x4c, 0x3a, 0x93, 0xfd, 0x00, 0x51, + 0xd0, 0x5e, 0x94, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xd8, 0xfc, 0x00, 0x4c, + 0x60, 0x03, 0x52, 0xfc, 0x40, 0x4b, 0x87, 0x17, 0xd7, 0xfc, 0x00, 0x4c, + 0x60, 0x03, 0x51, 0xfc, 0x40, 0x06, 0xb0, 0xe1, 0x61, 0x07, 0x4f, 0x00, + 0x01, 0xff, 0x0d, 0x67, 0x00, 0x4c, 0x05, 0x4c, 0x3a, 0x34, 0x05, 0x3f, + 0x22, 0x11, 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x1c, 0xfd, + 0x00, 0x4d, 0x5f, 0x03, 0x00, 0xfd, 0x40, 0xa9, 0x11, 0x05, 0x51, 0x00, + 0x01, 0xff, 0x57, 0x6f, 0x2e, 0x5b, 0xfd, 0x00, 0x4e, 0x38, 0x51, 0x5a, + 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xaa, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x18, + 0xfc, 0x40, 0xa9, 0x06, 0x53, 0x33, 0x51, 0xbf, 0xfd, 0x40, 0x4b, 0x87, + 0x17, 0xa9, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x17, 0xfc, 0x40, 0x4a, 0x7c, + 0x2e, 0x1b, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0xff, 0xfc, 0x40, 0x47, 0x44, + 0x2f, 0xcc, 0xfb, 0x80, 0x0f, 0xad, 0x01, 0xff, 0x50, 0x45, 0x52, 0xce, + 0xfb, 0x00, 0x52, 0x43, 0x52, 0xcf, 0xfb, 0x40, 0x49, 0x4c, 0x52, 0xcd, + 0xfb, 0x40, 0x0d, 0x67, 0x00, 0x4a, 0x06, 0x4c, 0x3a, 0x3a, 0x05, 0x3f, + 0x22, 0x11, 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x16, 0xfd, + 0x00, 0x4d, 0x5f, 0x03, 0xfa, 0xfc, 0x40, 0xa9, 0x17, 0x05, 0x51, 0x00, + 0x01, 0xff, 0x57, 0x6f, 0x2e, 0x7b, 0xfd, 0x00, 0x4f, 0x5f, 0x73, 0x79, + 0xfd, 0x00, 0x4e, 0x38, 0x51, 0x7a, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xbd, + 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x2c, 0xfc, 0x40, 0x4b, 0x87, 0x17, 0xbc, + 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x2b, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0x15, + 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0xf9, 0xfc, 0x40, 0x0d, 0x67, 0x00, 0x6c, + 0x05, 0xf4, 0x5c, 0x5c, 0x06, 0x4c, 0x3a, 0x4c, 0x05, 0xf3, 0x5d, 0x29, + 0x05, 0x3f, 0x22, 0x11, 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x7c, 0x2e, + 0x7d, 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x32, 0xfc, 0x40, 0xa9, 0x06, 0x53, + 0x33, 0x51, 0xc1, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xc1, 0xfc, 0x00, 0x4c, + 0x60, 0x03, 0x30, 0xfc, 0x40, 0xa9, 0x11, 0x0a, 0xee, 0x82, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0x7c, 0xfd, 0x00, 0x4c, 0x86, 0x17, 0x7d, 0xfd, 0x40, + 0x4b, 0x87, 0x17, 0xc0, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x2f, 0xfc, 0x40, + 0x4b, 0x87, 0x17, 0xbe, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x2d, 0xfc, 0x40, + 0x4b, 0x87, 0x17, 0xbf, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x2e, 0xfc, 0x40, + 0x4a, 0x7c, 0x2e, 0x7c, 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x31, 0xfc, 0x40, + 0x51, 0x90, 0x5a, 0xc4, 0xfb, 0x00, 0x07, 0xeb, 0x0a, 0x01, 0xff, 0x0d, + 0x67, 0x00, 0x87, 0x01, 0x04, 0x49, 0x22, 0x64, 0x06, 0x4c, 0x3a, 0x54, + 0x05, 0xf3, 0x5d, 0x31, 0x06, 0xd0, 0x5e, 0x21, 0x04, 0x6a, 0x7f, 0x11, + 0x04, 0x4d, 0x00, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x24, 0xfd, 0x00, 0x4d, + 0x5f, 0x03, 0x08, 0xfd, 0x40, 0x4a, 0x7c, 0x2e, 0x2c, 0xfd, 0x00, 0x4d, + 0x5f, 0x03, 0x10, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xb7, 0xfc, 0x00, 0x4c, + 0x60, 0x03, 0x25, 0xfc, 0x40, 0xa9, 0x11, 0x0a, 0xee, 0x82, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0x6f, 0xfd, 0x00, 0x4c, 0x86, 0x17, 0x70, 0xfd, 0x40, + 0x4b, 0x87, 0x17, 0xb6, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x24, 0xfc, 0x40, + 0x4b, 0x87, 0x17, 0xb4, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x22, 0xfc, 0x40, + 0xa9, 0x11, 0x05, 0x51, 0x00, 0x01, 0xff, 0x57, 0x6f, 0x2e, 0x6e, 0xfd, + 0x00, 0x4e, 0x38, 0x51, 0xab, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xb5, 0xfc, + 0x00, 0x4c, 0x60, 0x03, 0x23, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0x23, 0xfd, + 0x00, 0x4d, 0x5f, 0x03, 0x07, 0xfd, 0x40, 0x08, 0x4e, 0x00, 0x06, 0x5c, + 0x38, 0x19, 0xfd, 0xfd, 0x40, 0x0d, 0x67, 0x00, 0x93, 0x01, 0xa8, 0x68, + 0x06, 0x4c, 0x3a, 0x58, 0x05, 0xf3, 0x5d, 0x40, 0x05, 0x3f, 0x22, 0x22, + 0x4f, 0xe6, 0x73, 0x6d, 0xfc, 0x00, 0x4e, 0x6a, 0x7f, 0x6a, 0xfc, 0x00, + 0x04, 0x4d, 0x00, 0x06, 0x4f, 0x5a, 0x78, 0x6b, 0xfc, 0x40, 0x4a, 0x7c, + 0x2e, 0x6f, 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x0a, 0xfc, 0x40, 0x4a, 0x7c, + 0x2e, 0x6c, 0xfc, 0x00, 0xa9, 0x06, 0x4b, 0x1a, 0x71, 0xe1, 0xfc, 0x40, + 0x4b, 0x87, 0x17, 0x9f, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x08, 0xfc, 0x40, + 0xa9, 0x06, 0x53, 0x33, 0x51, 0x9e, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0x9e, + 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x07, 0xfc, 0x40, 0x4b, 0x87, 0x17, 0x9c, + 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x05, 0xfc, 0x40, 0x03, 0x3d, 0x0a, 0x11, + 0x03, 0x4e, 0x00, 0x01, 0xff, 0x4c, 0x86, 0x17, 0xa0, 0xfc, 0x00, 0x4b, + 0x1a, 0x71, 0xe2, 0xfc, 0x40, 0xa9, 0x06, 0x53, 0x33, 0x51, 0xc2, 0xfd, + 0x40, 0x4b, 0x87, 0x17, 0x9d, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x06, 0xfc, + 0x40, 0x4a, 0x7c, 0x2e, 0x6e, 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x09, 0xfc, + 0x40, 0x08, 0x92, 0xa1, 0x9e, 0x01, 0x0d, 0xea, 0x88, 0x8d, 0x01, 0x52, + 0x91, 0x55, 0xf3, 0xfd, 0x00, 0xac, 0x06, 0x4b, 0xd7, 0xaa, 0xff, 0xfd, + 0x40, 0x03, 0x17, 0x22, 0x2b, 0x03, 0x69, 0x00, 0x06, 0x51, 0x15, 0x5e, + 0xf2, 0xfd, 0x40, 0x1e, 0x7b, 0x14, 0x11, 0x0e, 0xa4, 0x82, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0x3c, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0x3d, 0xfd, 0x40, + 0x4a, 0x7c, 0x2e, 0x90, 0xfc, 0x00, 0x4d, 0x5f, 0x03, 0x5d, 0xfc, 0x40, + 0x0b, 0xbc, 0x9d, 0x42, 0x4f, 0x90, 0x6f, 0xf7, 0xfd, 0x00, 0xa9, 0x01, + 0xff, 0x02, 0x19, 0x00, 0x20, 0xad, 0x01, 0xff, 0x09, 0xbe, 0x9d, 0x0f, + 0x0b, 0xbc, 0x9d, 0x01, 0xff, 0xed, 0x49, 0xfd, 0x00, 0x4d, 0xf1, 0x8d, + 0xd3, 0x0e, 0x41, 0xed, 0x48, 0xfd, 0x00, 0x4d, 0xf1, 0x8d, 0xd2, 0x0e, + 0x41, 0x48, 0xd7, 0xcf, 0xd2, 0xfb, 0x00, 0x07, 0xf6, 0x8d, 0x01, 0xff, + 0xed, 0x47, 0xfd, 0x00, 0x4d, 0xf1, 0x8d, 0x4a, 0xfd, 0x40, 0xed, 0x4d, + 0xfd, 0x00, 0x4d, 0xf1, 0x8d, 0xd1, 0x0e, 0x41, 0x54, 0x74, 0x1a, 0xd1, + 0xfb, 0x00, 0x5c, 0x6c, 0x1a, 0xcd, 0xfd, 0x40, 0x0d, 0x67, 0x00, 0x67, + 0x05, 0x4c, 0x3a, 0x44, 0x05, 0x3f, 0x22, 0x11, 0x04, 0x4d, 0x00, 0x01, + 0xff, 0x4a, 0x7c, 0x2e, 0x14, 0xfd, 0x00, 0x4d, 0x5f, 0x03, 0xf8, 0xfc, + 0x40, 0xa9, 0x21, 0x05, 0x51, 0x00, 0x01, 0xff, 0x57, 0x6f, 0x2e, 0x78, + 0xfd, 0x00, 0x05, 0x3f, 0x22, 0x06, 0x4e, 0x38, 0x51, 0xb6, 0xfd, 0x40, + 0x4a, 0x7c, 0x2e, 0x76, 0xfd, 0x00, 0x4c, 0x86, 0x17, 0x77, 0xfd, 0x40, + 0x4b, 0x87, 0x17, 0xbb, 0xfc, 0x00, 0x4c, 0x60, 0x03, 0x2a, 0xfc, 0x40, + 0xa9, 0x11, 0x0a, 0xee, 0x82, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x75, 0xfd, + 0x00, 0x4c, 0x86, 0x17, 0xc4, 0xfd, 0x40, 0x4b, 0x87, 0x17, 0xba, 0xfc, + 0x00, 0x4c, 0x60, 0x03, 0x29, 0xfc, 0x40, 0x4a, 0x7c, 0x2e, 0x13, 0xfd, + 0x00, 0x4d, 0x5f, 0x03, 0xf7, 0xfc, 0x40, 0x0d, 0x30, 0x87, 0xd3, 0x1e, + 0x05, 0x15, 0x06, 0x01, 0xff, 0xa1, 0x8d, 0x1b, 0x02, 0xb7, 0x05, 0xd2, + 0x19, 0xa4, 0xb1, 0x17, 0xe5, 0xd0, 0x06, 0x80, 0x8e, 0x17, 0xa6, 0xdb, + 0x15, 0xa7, 0xb5, 0x14, 0xa8, 0xfe, 0x11, 0x02, 0xa3, 0x21, 0xa6, 0x11, + 0xab, 0x8f, 0x0f, 0xac, 0xa8, 0x0e, 0xad, 0xe0, 0x0d, 0xae, 0xfe, 0x0b, + 0x42, 0xce, 0x53, 0xc6, 0x06, 0x80, 0xe7, 0x0b, 0x43, 0x62, 0xe2, 0x7e, + 0x06, 0x80, 0x90, 0x0b, 0x43, 0x11, 0x15, 0x42, 0x06, 0x80, 0xc9, 0x0a, + 0xb2, 0x8c, 0x09, 0xb3, 0xb0, 0x07, 0xb4, 0xe1, 0x03, 0xf5, 0xc7, 0x06, + 0x80, 0xaf, 0x03, 0x42, 0x32, 0x00, 0xcb, 0x06, 0x80, 0xf7, 0x02, 0x43, + 0x1c, 0x8f, 0x48, 0x06, 0x80, 0x99, 0x02, 0xb9, 0x43, 0x02, 0x59, 0x00, + 0x01, 0xff, 0xe8, 0x38, 0x06, 0x80, 0x1c, 0x42, 0x9e, 0x01, 0x32, 0x06, + 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0xb0, 0xfe, 0x00, 0x4d, + 0x5f, 0x03, 0xaf, 0xfe, 0x00, 0x55, 0x2e, 0x41, 0xb2, 0x08, 0x40, 0x80, + 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0xc6, 0xfe, 0x00, 0xa9, 0x06, 0x4b, 0x1a, + 0x71, 0xc8, 0xfe, 0x40, 0x4b, 0x87, 0x17, 0xc7, 0xfe, 0x00, 0x4c, 0x60, + 0x03, 0xc5, 0xfe, 0x40, 0x42, 0x4e, 0x00, 0x4a, 0x06, 0x80, 0x14, 0xf5, + 0xc8, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0xdc, 0xfb, + 0x00, 0x4d, 0x5f, 0x03, 0xdb, 0xfb, 0x40, 0x80, 0x01, 0xff, 0x46, 0xf8, + 0x1a, 0xd2, 0x06, 0x80, 0x75, 0x4a, 0x7c, 0x2e, 0xf2, 0xfe, 0x00, 0xa9, + 0x61, 0x4b, 0x1a, 0x71, 0xf4, 0xfe, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, + 0x4f, 0x53, 0x70, 0xc7, 0x0e, 0x01, 0x4b, 0x56, 0x00, 0x26, 0x06, 0x80, + 0x2c, 0x47, 0xb4, 0x36, 0xce, 0x06, 0x00, 0xb4, 0x01, 0xff, 0x43, 0x7a, + 0x18, 0xcd, 0x06, 0x00, 0x4f, 0x61, 0x71, 0xd1, 0x06, 0x00, 0x12, 0x65, + 0x1f, 0x01, 0xff, 0x49, 0x77, 0x1f, 0xa9, 0x08, 0x00, 0x4b, 0x56, 0x00, + 0xa8, 0x08, 0x00, 0x50, 0x6a, 0x6a, 0xba, 0x08, 0x40, 0x80, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0x8a, 0xfe, 0x00, 0xa9, 0x06, 0x4b, 0x1a, 0x71, 0x8c, + 0xfe, 0x40, 0x4b, 0x87, 0x17, 0x8b, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0x89, + 0xfe, 0x40, 0x4b, 0x87, 0x17, 0xf3, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xf1, + 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0xaf, 0xfb, 0x00, 0x4d, + 0x5f, 0x03, 0xae, 0xfb, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x1d, 0xaa, + 0x16, 0x16, 0x4b, 0x56, 0x00, 0xd3, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0xb1, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0xb0, 0xfb, 0x40, + 0x4a, 0xc8, 0xb0, 0x7b, 0x07, 0x00, 0x48, 0x3f, 0xd2, 0x7a, 0x07, 0x40, + 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0xee, 0xfe, 0x00, 0x4d, 0x5f, 0x03, + 0xed, 0xfe, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x04, 0x6f, 0x0c, 0x32, + 0x1d, 0xaa, 0x16, 0x22, 0x4b, 0x56, 0x00, 0x24, 0x06, 0x80, 0x0c, 0x44, + 0x22, 0x08, 0xc4, 0x06, 0x00, 0x4e, 0xa1, 0x0f, 0xca, 0x06, 0x40, 0x80, + 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x86, 0xfe, 0x00, 0x4d, 0x5f, 0x03, 0x85, + 0xfe, 0x40, 0x4a, 0xc8, 0xb0, 0x79, 0x07, 0x00, 0x48, 0x3f, 0xd2, 0x78, + 0x07, 0x40, 0x45, 0x5c, 0x00, 0xcf, 0x06, 0x00, 0x46, 0x04, 0x20, 0xab, + 0x08, 0x40, 0x80, 0x22, 0xe8, 0xa4, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0x6b, 0xfb, 0x00, 0xa9, 0x06, 0x4b, 0x1a, 0x71, 0x6d, + 0xfb, 0x40, 0x4b, 0x87, 0x17, 0x6c, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x6a, + 0xfb, 0x40, 0x4a, 0x7c, 0x2e, 0xdf, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0xde, + 0xfb, 0x40, 0x80, 0x11, 0x22, 0xc2, 0x0c, 0x01, 0xff, 0x4c, 0x86, 0x17, + 0xe8, 0xfb, 0x00, 0x4b, 0x1a, 0x71, 0xe9, 0xfb, 0x40, 0x4a, 0x7c, 0x2e, + 0xd8, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0xd7, 0xfb, 0x00, 0x50, 0x51, 0x00, + 0x77, 0x06, 0xc0, 0x00, 0x4e, 0x5e, 0x03, 0xdd, 0xfb, 0x40, 0x42, 0x3d, + 0x0a, 0x37, 0x06, 0x80, 0xf8, 0x02, 0x44, 0xa2, 0x87, 0x86, 0x06, 0x80, + 0x9f, 0x02, 0x42, 0x4e, 0x00, 0x2a, 0x06, 0x80, 0x9a, 0x01, 0xa8, 0x4d, + 0x43, 0x61, 0x10, 0x79, 0x06, 0xc0, 0x00, 0x80, 0x24, 0x42, 0x4e, 0x00, + 0x7a, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x5f, 0xfb, + 0x00, 0xa9, 0x06, 0x4b, 0x1a, 0x71, 0x61, 0xfb, 0x40, 0x4b, 0x87, 0x17, + 0x60, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x5e, 0xfb, 0x40, 0x4a, 0x7c, 0x2e, + 0x67, 0xfb, 0x00, 0xa9, 0x0c, 0x4b, 0x1a, 0x71, 0x69, 0xfb, 0x00, 0x4c, + 0xfc, 0x9b, 0xc0, 0x08, 0x40, 0x4b, 0x87, 0x17, 0x68, 0xfb, 0x00, 0x4c, + 0x60, 0x03, 0x66, 0xfb, 0x40, 0x42, 0x13, 0x00, 0x30, 0x06, 0x80, 0x35, + 0x42, 0x4e, 0x00, 0x2b, 0x06, 0x80, 0x11, 0x03, 0x08, 0x06, 0x01, 0xff, + 0x44, 0x30, 0x48, 0xc6, 0x0e, 0x01, 0x43, 0x4d, 0x00, 0x86, 0x08, 0x40, + 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x9a, 0xfe, 0x00, 0xa9, 0x06, 0x4b, + 0x1a, 0x71, 0x9c, 0xfe, 0x40, 0x4b, 0x87, 0x17, 0x9b, 0xfe, 0x00, 0x4c, + 0x60, 0x03, 0x99, 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0xac, + 0xfe, 0x00, 0x4d, 0x5f, 0x03, 0xab, 0xfe, 0x40, 0x80, 0x24, 0x42, 0x4e, + 0x00, 0x7f, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x63, + 0xfb, 0x00, 0xa9, 0x06, 0x4b, 0x1a, 0x71, 0x65, 0xfb, 0x40, 0x4b, 0x87, + 0x17, 0x64, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x62, 0xfb, 0x40, 0x4a, 0x7c, + 0x2e, 0x96, 0xfe, 0x00, 0xa9, 0x43, 0xad, 0x1f, 0x05, 0x51, 0x00, 0x01, + 0xff, 0x44, 0x22, 0x08, 0x7c, 0x06, 0x00, 0x06, 0x5d, 0x07, 0x06, 0x5a, + 0x5d, 0x23, 0x7d, 0x06, 0x40, 0x49, 0x8a, 0xc5, 0xb8, 0x08, 0x00, 0xf6, + 0xbf, 0x08, 0x40, 0x46, 0xd0, 0xdf, 0x29, 0x06, 0x80, 0x06, 0x4a, 0x1b, + 0x71, 0x98, 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x94, 0xfe, + 0x00, 0x44, 0xec, 0xf5, 0xc3, 0x06, 0x00, 0x4d, 0x5f, 0x03, 0x93, 0xfe, + 0x40, 0x4b, 0x87, 0x17, 0x97, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0x95, 0xfe, + 0x40, 0x80, 0x24, 0x42, 0x4e, 0x00, 0x87, 0x06, 0xc0, 0x00, 0x80, 0x01, + 0xff, 0x4a, 0x7c, 0x2e, 0x7f, 0xfb, 0x00, 0xa9, 0x06, 0x4b, 0x1a, 0x71, + 0x81, 0xfb, 0x40, 0x4b, 0x87, 0x17, 0x80, 0xfb, 0x00, 0x4c, 0x60, 0x03, + 0x7e, 0xfb, 0x40, 0x4a, 0x7c, 0x2e, 0x7b, 0xfb, 0x00, 0xa9, 0x17, 0x4b, + 0x1a, 0x71, 0x7d, 0xfb, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x49, 0x77, + 0x1f, 0xbf, 0x06, 0x00, 0x47, 0xb4, 0x36, 0xc1, 0x08, 0x40, 0x4b, 0x87, + 0x17, 0x7c, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x7a, 0xfb, 0x40, 0x80, 0x01, + 0xff, 0x4a, 0x7c, 0x2e, 0xc2, 0xfe, 0x00, 0xa9, 0x35, 0x4b, 0x1a, 0x71, + 0xc4, 0xfe, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x49, 0x6d, 0x13, 0x8b, + 0x08, 0x00, 0xb4, 0x01, 0xff, 0x0a, 0x7c, 0x13, 0x11, 0x08, 0x5e, 0x0c, + 0x01, 0xff, 0x45, 0x5c, 0x00, 0xa3, 0x08, 0x00, 0x50, 0xec, 0x2d, 0xc3, + 0x0e, 0x41, 0x45, 0x5c, 0x00, 0x9f, 0x06, 0x00, 0x45, 0x20, 0x07, 0x8c, + 0x08, 0x40, 0x4b, 0x87, 0x17, 0xc3, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xc1, + 0xfe, 0x40, 0x42, 0xe8, 0x01, 0x35, 0x06, 0x80, 0x99, 0x01, 0x43, 0xe9, + 0x09, 0x33, 0x06, 0x80, 0x3c, 0x44, 0x36, 0xe1, 0x34, 0x06, 0x80, 0x12, + 0x4b, 0xfe, 0xa8, 0xb1, 0x08, 0x00, 0x4f, 0x70, 0x06, 0x70, 0x06, 0x00, + 0x48, 0x27, 0xd2, 0xaa, 0x06, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, + 0xb6, 0xfe, 0x00, 0xa9, 0x0c, 0x4b, 0x1a, 0x71, 0xb8, 0xfe, 0x00, 0x4e, + 0x96, 0x82, 0xfa, 0x06, 0x40, 0x4b, 0x87, 0x17, 0xb7, 0xfe, 0x00, 0x4c, + 0x60, 0x03, 0xb5, 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0xb2, + 0xfe, 0x00, 0xa9, 0x3f, 0x4b, 0x1a, 0x71, 0xb4, 0xfe, 0x00, 0x05, 0x51, + 0x00, 0x01, 0xff, 0x57, 0xb1, 0x2f, 0x9a, 0x06, 0x00, 0x66, 0xd9, 0x06, + 0x7d, 0x07, 0x00, 0x4f, 0x08, 0x49, 0x5c, 0x07, 0x00, 0x4a, 0x33, 0x41, + 0x7e, 0x07, 0x00, 0x64, 0x28, 0x0a, 0x70, 0x07, 0x00, 0xb4, 0x01, 0xff, + 0x4f, 0x61, 0x71, 0x9b, 0x06, 0x80, 0x06, 0x58, 0xcc, 0x2d, 0x6d, 0x07, + 0x40, 0x55, 0x76, 0x13, 0x9c, 0x06, 0x40, 0x4b, 0x87, 0x17, 0xb3, 0xfe, + 0x00, 0x4c, 0x60, 0x03, 0xb1, 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, + 0x2e, 0xba, 0xfe, 0x00, 0xa9, 0x21, 0x4b, 0x1a, 0x71, 0xbc, 0xfe, 0x00, + 0x06, 0x29, 0x06, 0x01, 0xff, 0x0a, 0x7c, 0x13, 0x06, 0x4d, 0xb5, 0x0f, + 0x9d, 0x06, 0x40, 0x45, 0x5c, 0x00, 0x9e, 0x06, 0x00, 0x45, 0x20, 0x07, + 0xaf, 0x08, 0x40, 0x4b, 0x87, 0x17, 0xbb, 0xfe, 0x00, 0x4c, 0x60, 0x03, + 0xb9, 0xfe, 0x40, 0x42, 0x4e, 0x00, 0x31, 0x06, 0x80, 0x40, 0x44, 0x30, + 0x48, 0xbb, 0x06, 0x80, 0x1c, 0x4b, 0xba, 0xa5, 0xac, 0x08, 0x00, 0x43, + 0x93, 0x54, 0x91, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, + 0x8d, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0x8c, 0xfb, 0x40, 0x80, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0xa1, 0xfb, 0x00, 0xa9, 0x06, 0x4b, 0x1a, 0x71, 0xa3, + 0xfb, 0x40, 0x4b, 0x87, 0x17, 0xa2, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0xa0, + 0xfb, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0xae, 0xfe, 0x00, 0x4d, + 0x5f, 0x03, 0xad, 0xfe, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x49, 0x6d, + 0x13, 0x94, 0x06, 0x80, 0x52, 0x4f, 0x08, 0x49, 0x99, 0x06, 0x00, 0x4b, + 0x56, 0x00, 0x6c, 0x07, 0x00, 0x4a, 0x33, 0x41, 0xef, 0x06, 0x00, 0x44, + 0x97, 0x08, 0xaa, 0x08, 0x00, 0x44, 0x22, 0x08, 0x93, 0x06, 0x00, 0xb3, + 0x11, 0x09, 0x5d, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x97, 0x06, 0x00, + 0x50, 0xd4, 0x2d, 0x6b, 0x07, 0x40, 0x05, 0x5e, 0x07, 0x06, 0x45, 0x53, + 0x05, 0x5b, 0x07, 0x40, 0x5e, 0x2e, 0x0a, 0x71, 0x07, 0x00, 0x4a, 0x70, + 0x6a, 0xb9, 0x08, 0x00, 0xf6, 0x92, 0x06, 0xc0, 0x00, 0x46, 0x1f, 0x07, + 0x95, 0x06, 0x40, 0x4e, 0x72, 0x1f, 0x96, 0x06, 0x40, 0x80, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0xd6, 0xfe, 0x00, 0xa9, 0x28, 0x4b, 0x1a, 0x71, 0xd8, + 0xfe, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x04, 0x6f, 0x0c, 0x06, 0x50, + 0x7b, 0x13, 0xa8, 0x06, 0x40, 0x45, 0x5c, 0x00, 0xa7, 0x06, 0x00, 0x45, + 0x20, 0x07, 0xa5, 0x08, 0xc0, 0x00, 0x52, 0x59, 0x51, 0xb5, 0x08, 0x40, + 0x4b, 0x87, 0x17, 0xd7, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xd5, 0xfe, 0x40, + 0x80, 0x24, 0x42, 0x4e, 0x00, 0xa6, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0x6f, 0xfb, 0x00, 0xa9, 0x06, 0x4b, 0x1a, 0x71, 0x71, + 0xfb, 0x40, 0x4b, 0x87, 0x17, 0x70, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x6e, + 0xfb, 0x40, 0x4a, 0x7c, 0x2e, 0x57, 0xfb, 0x00, 0xa9, 0x15, 0x4b, 0x1a, + 0x71, 0x59, 0xfb, 0x00, 0x0b, 0xca, 0x83, 0x01, 0xff, 0x4a, 0x52, 0xb3, + 0xb7, 0x08, 0x00, 0xf6, 0xbe, 0x08, 0x40, 0x4b, 0x87, 0x17, 0x58, 0xfb, + 0x00, 0x4c, 0x60, 0x03, 0x56, 0xfb, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, + 0x2e, 0xda, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0xd9, 0xfb, 0x40, 0xe7, 0xad, + 0x06, 0x80, 0x99, 0x01, 0x43, 0xcd, 0x02, 0x46, 0x06, 0x80, 0x24, 0x43, + 0x4d, 0x00, 0x83, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, + 0x77, 0xfb, 0x00, 0xa9, 0x06, 0x4b, 0x1a, 0x71, 0x79, 0xfb, 0x40, 0x4b, + 0x87, 0x17, 0x78, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x76, 0xfb, 0x40, 0x80, + 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0xe6, 0xfe, 0x00, 0x46, 0x35, 0x48, 0xba, + 0x06, 0x80, 0x4f, 0xa9, 0x41, 0x4b, 0x1a, 0x71, 0xe8, 0xfe, 0x00, 0x05, + 0x51, 0x00, 0x01, 0xff, 0x49, 0x6d, 0x13, 0xb9, 0x06, 0x00, 0x50, 0xab, + 0x36, 0x89, 0x08, 0x00, 0x44, 0x22, 0x08, 0xbc, 0x06, 0x80, 0x1d, 0x06, + 0x5d, 0x07, 0x0f, 0xb4, 0x01, 0xff, 0x4f, 0x7c, 0x13, 0xbd, 0x06, 0x00, + 0x4d, 0xb5, 0x0f, 0x67, 0x07, 0x40, 0x43, 0x3c, 0x0a, 0x68, 0x07, 0x00, + 0xf6, 0x69, 0x07, 0x40, 0x46, 0x5b, 0x00, 0x8f, 0x08, 0x40, 0x4b, 0x87, + 0x17, 0xe7, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xe5, 0xfe, 0x40, 0x80, 0x01, + 0xff, 0x4a, 0x7c, 0x2e, 0x9f, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0x9e, 0xfb, + 0x40, 0x80, 0x24, 0x43, 0x1c, 0xa2, 0xb1, 0x06, 0xc0, 0x00, 0x80, 0x01, + 0xff, 0x4a, 0x7c, 0x2e, 0x9b, 0xfb, 0x00, 0xa9, 0x06, 0x4b, 0x1a, 0x71, + 0x9d, 0xfb, 0x40, 0x4b, 0x87, 0x17, 0x9c, 0xfb, 0x00, 0x4c, 0x60, 0x03, + 0x9a, 0xfb, 0x40, 0x4a, 0x7c, 0x2e, 0xd4, 0xfb, 0x00, 0xa9, 0x06, 0x4b, + 0x1a, 0x71, 0xd6, 0xfb, 0x40, 0x4b, 0x87, 0x17, 0xd5, 0xfb, 0x00, 0x4c, + 0x60, 0x03, 0xd3, 0xfb, 0x40, 0x43, 0xba, 0x00, 0x1c, 0x06, 0x00, 0x43, + 0x51, 0x19, 0x45, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, + 0xe2, 0xfe, 0x00, 0xa9, 0x21, 0x4b, 0x1a, 0x71, 0xe4, 0xfe, 0x00, 0x05, + 0x51, 0x00, 0x01, 0xff, 0x04, 0x6f, 0x0c, 0x06, 0x50, 0x7b, 0x13, 0xa7, + 0x08, 0x40, 0x45, 0x5c, 0x00, 0x65, 0x07, 0x00, 0x45, 0x20, 0x07, 0x66, + 0x07, 0x40, 0x4b, 0x87, 0x17, 0xe3, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xe1, + 0xfe, 0x40, 0x42, 0x57, 0x00, 0x44, 0x06, 0x80, 0x06, 0x47, 0x39, 0xda, + 0xad, 0x08, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0xde, 0xfe, 0x00, + 0xa9, 0x40, 0x4b, 0x1a, 0x71, 0xe0, 0xfe, 0x00, 0x05, 0x51, 0x00, 0x01, + 0xff, 0x43, 0x16, 0x00, 0x6a, 0x07, 0x00, 0x02, 0x3b, 0x01, 0x1f, 0x06, + 0x5d, 0x07, 0x11, 0x0b, 0x7b, 0x13, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xb7, + 0x06, 0x00, 0x45, 0x20, 0x07, 0xb8, 0x06, 0x40, 0x57, 0xcb, 0x2e, 0xc7, + 0x08, 0x00, 0xf6, 0xb5, 0x06, 0x40, 0x47, 0x79, 0x1f, 0xb6, 0x06, 0x00, + 0x48, 0xeb, 0x52, 0xa6, 0x08, 0x40, 0x4b, 0x87, 0x17, 0xdf, 0xfe, 0x00, + 0x4c, 0x60, 0x03, 0xdd, 0xfe, 0x40, 0xa1, 0xb4, 0x01, 0x44, 0x84, 0xf5, + 0xa9, 0x06, 0x80, 0x55, 0x43, 0x49, 0x22, 0x2e, 0x06, 0x80, 0x31, 0x07, + 0x46, 0x00, 0x01, 0xff, 0x42, 0xce, 0x53, 0xc5, 0x06, 0x80, 0x16, 0x42, + 0x87, 0x50, 0xc9, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, + 0xe3, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0xe2, 0xfb, 0x40, 0x80, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0xe1, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0xe0, 0xfb, 0x40, + 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0xa6, 0xfe, 0x00, 0xa9, 0x06, 0x4b, + 0x1a, 0x71, 0xa8, 0xfe, 0x40, 0x4b, 0x87, 0x17, 0xa7, 0xfe, 0x00, 0x4c, + 0x60, 0x03, 0xa5, 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x8f, + 0xfb, 0x00, 0xa9, 0x41, 0x4b, 0x1a, 0x71, 0x91, 0xfb, 0x00, 0x05, 0x51, + 0x00, 0x01, 0xff, 0x49, 0x77, 0x1f, 0x62, 0x07, 0x00, 0x47, 0xb4, 0x36, + 0xc2, 0x08, 0x00, 0xb4, 0x01, 0xff, 0x0a, 0x7c, 0x13, 0x11, 0x08, 0x5e, + 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x3b, 0x06, 0x00, 0x50, 0xec, 0x2d, + 0x8d, 0x08, 0x40, 0x45, 0x5c, 0x00, 0x63, 0x07, 0x00, 0x45, 0x20, 0x07, + 0x3c, 0x06, 0x00, 0x56, 0x37, 0x38, 0x64, 0x07, 0x40, 0x4b, 0x87, 0x17, + 0x90, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x8e, 0xfb, 0x40, 0xe6, 0x43, 0x06, + 0x80, 0x06, 0x4a, 0xa4, 0xb6, 0x20, 0x06, 0x40, 0x80, 0x01, 0xff, 0x4a, + 0x7c, 0x2e, 0xda, 0xfe, 0x00, 0xa9, 0x3b, 0x4b, 0x1a, 0x71, 0xdc, 0xfe, + 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x04, 0x6f, 0x0c, 0x20, 0x44, 0x22, + 0x08, 0xab, 0x06, 0x00, 0xb4, 0x01, 0xff, 0x4f, 0x61, 0x71, 0xae, 0x06, + 0x00, 0x08, 0x5e, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x7f, 0x07, 0x00, + 0x50, 0xec, 0x2d, 0xc4, 0x0e, 0x41, 0x45, 0x5c, 0x00, 0xac, 0x06, 0x00, + 0x45, 0x20, 0x07, 0xb4, 0x08, 0x40, 0x4b, 0x87, 0x17, 0xdb, 0xfe, 0x00, + 0x4c, 0x60, 0x03, 0xd9, 0xfe, 0x40, 0x42, 0xb5, 0x05, 0x2c, 0x06, 0x80, + 0x14, 0xe8, 0x98, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, + 0x8b, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0x8a, 0xfb, 0x40, 0x80, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0x9e, 0xfe, 0x00, 0xa9, 0x21, 0x4b, 0x1a, 0x71, 0xa0, + 0xfe, 0x00, 0x06, 0x29, 0x06, 0x01, 0xff, 0x0a, 0x7c, 0x13, 0x06, 0x4d, + 0xa2, 0x0f, 0xa2, 0x08, 0x40, 0x45, 0x5c, 0x00, 0xc5, 0x08, 0x00, 0x45, + 0x20, 0x07, 0xc6, 0x08, 0x40, 0x4b, 0x87, 0x17, 0x9f, 0xfe, 0x00, 0x4c, + 0x60, 0x03, 0x9d, 0xfe, 0x40, 0xa1, 0xaf, 0x01, 0x42, 0x4e, 0x00, 0x47, + 0x06, 0x80, 0x1c, 0x49, 0xb4, 0xbf, 0x74, 0x06, 0xc0, 0x00, 0x80, 0x01, + 0xff, 0x44, 0x67, 0x00, 0x75, 0x06, 0x00, 0x43, 0x1c, 0x8f, 0x76, 0x06, + 0x00, 0x43, 0x4d, 0x00, 0x78, 0x06, 0x40, 0x80, 0x01, 0xff, 0x4b, 0x24, + 0xa0, 0xbe, 0x06, 0x80, 0x65, 0x4a, 0x7c, 0x2e, 0xea, 0xfe, 0x00, 0x44, + 0xec, 0xf5, 0xc1, 0x06, 0x80, 0x35, 0xa9, 0x27, 0x4b, 0x1a, 0x71, 0xec, + 0xfe, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x4a, 0x33, 0x41, 0xff, 0x06, + 0x00, 0x49, 0x67, 0xc7, 0xc0, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, + 0x7c, 0x2e, 0xa5, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0xa4, 0xfb, 0x40, 0x4b, + 0x87, 0x17, 0xeb, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xe9, 0xfe, 0x40, 0x80, + 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0xa7, 0xfb, 0x00, 0xa9, 0x0c, 0x4b, 0x1a, + 0x71, 0xa9, 0xfb, 0x00, 0x50, 0x51, 0x00, 0xc2, 0x06, 0x40, 0x4b, 0x87, + 0x17, 0xa8, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0xa6, 0xfb, 0x40, 0x80, 0x01, + 0xff, 0x4a, 0x7c, 0x2e, 0xab, 0xfb, 0x00, 0xa9, 0x06, 0x4b, 0x1a, 0x71, + 0xad, 0xfb, 0x40, 0x4b, 0x87, 0x17, 0xac, 0xfb, 0x00, 0x4c, 0x60, 0x03, + 0xaa, 0xfb, 0x40, 0xe8, 0x2d, 0x06, 0x80, 0x0d, 0x43, 0x58, 0x00, 0x21, + 0x06, 0xc0, 0x00, 0x4e, 0x5e, 0x03, 0x80, 0xfe, 0x40, 0x80, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0xa2, 0xfe, 0x00, 0xa9, 0x59, 0x4b, 0x1a, 0x71, 0xa4, + 0xfe, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x66, 0xff, 0x06, 0x7c, 0x07, + 0x00, 0x4b, 0x56, 0x00, 0x81, 0x06, 0x00, 0x56, 0xc1, 0x36, 0x8a, 0x08, + 0x00, 0x18, 0x28, 0x0a, 0x24, 0xb4, 0x01, 0xff, 0x0a, 0x7c, 0x13, 0x11, + 0x08, 0x5e, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x57, 0x07, 0x00, 0x4e, + 0x42, 0x82, 0x82, 0x06, 0x40, 0x45, 0x5c, 0x00, 0x85, 0x06, 0x00, 0x56, + 0x37, 0x38, 0x58, 0x07, 0x40, 0xa1, 0x06, 0x45, 0x20, 0x07, 0x6e, 0x07, + 0x40, 0x44, 0x5d, 0x00, 0x72, 0x07, 0x00, 0x4b, 0x41, 0x0a, 0x6f, 0x07, + 0x40, 0x4b, 0x87, 0x17, 0xa3, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xa1, 0xfe, + 0x40, 0x42, 0x12, 0x15, 0xaf, 0x06, 0x80, 0x5f, 0x44, 0x90, 0xa1, 0x3a, + 0x06, 0x80, 0x2a, 0x43, 0x35, 0x21, 0xc8, 0x08, 0x00, 0x43, 0x83, 0xf5, + 0xb3, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x97, 0xfb, + 0x00, 0xa9, 0x06, 0x4b, 0x1a, 0x71, 0x99, 0xfb, 0x40, 0x4b, 0x87, 0x17, + 0x98, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x96, 0xfb, 0x40, 0x80, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0xce, 0xfe, 0x00, 0xa9, 0x17, 0x4b, 0x1a, 0x71, 0xd0, + 0xfe, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x49, 0x6d, 0x13, 0xfc, 0x06, + 0x00, 0x50, 0x7b, 0x13, 0xc3, 0x08, 0x40, 0x4b, 0x87, 0x17, 0xcf, 0xfe, + 0x00, 0x4c, 0x60, 0x03, 0xcd, 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, + 0x2e, 0x93, 0xfb, 0x00, 0xa9, 0x26, 0x4b, 0x1a, 0x71, 0x95, 0xfb, 0x00, + 0x05, 0x51, 0x00, 0x01, 0xff, 0x4f, 0x06, 0x72, 0xb0, 0x08, 0x00, 0x44, + 0x22, 0x08, 0xb0, 0x06, 0x00, 0xb4, 0x01, 0xff, 0x4f, 0x7c, 0x13, 0xb4, + 0x06, 0x00, 0x4d, 0xb5, 0x0f, 0xb2, 0x06, 0x40, 0x4b, 0x87, 0x17, 0x94, + 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x92, 0xfb, 0x40, 0x48, 0x47, 0xc9, 0xcc, + 0x06, 0x80, 0x59, 0x42, 0x4e, 0x00, 0x41, 0x06, 0xc0, 0x00, 0x80, 0x01, + 0xff, 0x4a, 0x7c, 0x2e, 0xd2, 0xfe, 0x00, 0xa9, 0x3b, 0x4b, 0x1a, 0x71, + 0xd4, 0xfe, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x04, 0x6f, 0x0c, 0x19, + 0xb4, 0x01, 0xff, 0x0a, 0x7c, 0x13, 0x06, 0x4d, 0xb5, 0x0f, 0x60, 0x07, + 0x40, 0x45, 0x20, 0x07, 0xa5, 0x06, 0x00, 0x56, 0x37, 0x38, 0x61, 0x07, + 0x40, 0x45, 0x20, 0x07, 0xa3, 0x06, 0x80, 0x06, 0x4b, 0xde, 0xa4, 0xa2, + 0x06, 0x40, 0x55, 0x76, 0x13, 0xa4, 0x08, 0x40, 0x4b, 0x87, 0x17, 0xd3, + 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xd1, 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, + 0x7c, 0x2e, 0xfd, 0xfb, 0x00, 0xa9, 0x39, 0x4b, 0x1a, 0x71, 0xff, 0xfb, + 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x1c, 0xd9, 0x06, 0x15, 0x4a, 0x33, + 0x41, 0x3d, 0x06, 0x00, 0xb4, 0x01, 0xff, 0x4f, 0x7c, 0x13, 0x3f, 0x06, + 0x00, 0x4d, 0xa2, 0x0f, 0x3e, 0x06, 0x40, 0x4a, 0x1b, 0x07, 0x77, 0x07, + 0x00, 0xb4, 0x01, 0xff, 0x4a, 0xc8, 0xb0, 0x76, 0x07, 0x00, 0x48, 0x3f, + 0xd2, 0x75, 0x07, 0x40, 0x4b, 0x87, 0x17, 0xfe, 0xfb, 0x00, 0x4c, 0x60, + 0x03, 0xfc, 0xfb, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0xe5, 0xfb, + 0x00, 0xa9, 0x06, 0x4b, 0x1a, 0x71, 0xe7, 0xfb, 0x40, 0x4b, 0x87, 0x17, + 0xe6, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0xe4, 0xfb, 0x40, 0xa1, 0x7e, 0x02, + 0x7b, 0x08, 0x50, 0x07, 0xb4, 0x43, 0x3a, 0x42, 0x1f, 0x01, 0x8e, 0x06, + 0x80, 0x24, 0x43, 0x4d, 0x00, 0x84, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0x73, 0xfb, 0x00, 0xa9, 0x06, 0x4b, 0x1a, 0x71, 0x75, + 0xfb, 0x40, 0x4b, 0x87, 0x17, 0x74, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x72, + 0xfb, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x87, 0xfb, 0x00, 0x4d, + 0x5f, 0x03, 0x86, 0xfb, 0x40, 0x43, 0x35, 0x85, 0x6e, 0x06, 0x00, 0x43, + 0x70, 0xbe, 0xa1, 0x06, 0x00, 0x43, 0x11, 0x15, 0x6f, 0x06, 0x40, 0x43, + 0x22, 0x00, 0x8d, 0x06, 0x80, 0x14, 0xec, 0x88, 0x06, 0xc0, 0x00, 0x80, + 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x89, 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0x88, + 0xfb, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x83, 0xfb, 0x00, 0x4d, + 0x5f, 0x03, 0x82, 0xfb, 0x40, 0xe4, 0x36, 0x06, 0x80, 0x76, 0x43, 0x22, + 0x00, 0x8c, 0x06, 0x80, 0x60, 0xec, 0x2f, 0x06, 0xc0, 0x00, 0x80, 0x01, + 0xff, 0x4a, 0x7c, 0x2e, 0xaa, 0xfe, 0x00, 0x4d, 0x5f, 0x03, 0xa9, 0xfe, + 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x49, 0x6d, 0x13, 0x8a, 0x06, 0x80, + 0x3a, 0x4f, 0x08, 0x49, 0x90, 0x06, 0x00, 0x09, 0x9a, 0x24, 0x26, 0x44, + 0x22, 0x08, 0x89, 0x06, 0x00, 0xb4, 0x01, 0xff, 0x0a, 0x7c, 0x13, 0x0d, + 0x58, 0xe4, 0x2d, 0xc2, 0x0e, 0xc1, 0x00, 0x4e, 0x86, 0x78, 0x59, 0x07, + 0x40, 0x4f, 0x68, 0x23, 0x8f, 0x06, 0x00, 0x45, 0x20, 0x07, 0xae, 0x08, + 0x40, 0x4d, 0xca, 0x36, 0x5a, 0x07, 0x00, 0xf6, 0xee, 0x06, 0x40, 0x4e, + 0x86, 0x78, 0x8b, 0x06, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x85, + 0xfb, 0x00, 0x4d, 0x5f, 0x03, 0x84, 0xfb, 0x40, 0x80, 0x01, 0xff, 0x4a, + 0x7c, 0x2e, 0xbe, 0xfe, 0x00, 0xa9, 0x0c, 0x4b, 0x1a, 0x71, 0xc0, 0xfe, + 0x00, 0x4e, 0x96, 0x82, 0xfb, 0x06, 0x40, 0x4b, 0x87, 0x17, 0xbf, 0xfe, + 0x00, 0x4c, 0x60, 0x03, 0xbd, 0xfe, 0x40, 0x42, 0x4e, 0x00, 0x7b, 0x06, + 0x80, 0x91, 0x01, 0xe8, 0x28, 0x06, 0xc0, 0x00, 0x80, 0x24, 0x42, 0x4e, + 0x00, 0x80, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x5b, + 0xfb, 0x00, 0xa9, 0x06, 0x4b, 0x1a, 0x71, 0x5d, 0xfb, 0x40, 0x4b, 0x87, + 0x17, 0x5c, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x5a, 0xfb, 0x40, 0x4a, 0x7c, + 0x2e, 0x90, 0xfe, 0x00, 0xa9, 0x52, 0x4b, 0x1a, 0x71, 0x92, 0xfe, 0x00, + 0x05, 0x51, 0x00, 0x01, 0xff, 0x5e, 0x6d, 0x13, 0x51, 0x07, 0x00, 0x4b, + 0x56, 0x00, 0xa1, 0x08, 0x00, 0x56, 0xc1, 0x36, 0x55, 0x07, 0x00, 0x06, + 0x5d, 0x07, 0x20, 0xb4, 0x01, 0xff, 0x0a, 0x7c, 0x13, 0x06, 0x5b, 0x65, + 0x1f, 0x54, 0x07, 0x40, 0x52, 0xb9, 0x54, 0x50, 0x07, 0x00, 0x56, 0x37, + 0x38, 0x52, 0x07, 0xc0, 0x00, 0x53, 0xce, 0x27, 0x53, 0x07, 0x40, 0x4a, + 0x52, 0xb3, 0xb6, 0x08, 0x00, 0xf6, 0x56, 0x07, 0xc0, 0x00, 0x46, 0x1f, + 0x07, 0xa0, 0x08, 0x40, 0x4b, 0x87, 0x17, 0x91, 0xfe, 0x00, 0x4c, 0x60, + 0x03, 0x8f, 0xfe, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x53, 0xfb, + 0x00, 0xa9, 0x06, 0x4b, 0x1a, 0x71, 0x55, 0xfb, 0x40, 0x4b, 0x87, 0x17, + 0x54, 0xfb, 0x00, 0x4c, 0x60, 0x03, 0x52, 0xfb, 0x40, 0xe5, 0xd5, 0x06, + 0x00, 0x07, 0xf7, 0xcb, 0x9c, 0x03, 0x42, 0x9e, 0x01, 0x39, 0x06, 0x80, + 0xcb, 0x02, 0x43, 0x68, 0x00, 0x27, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0x8e, 0xfe, 0x00, 0x4d, 0x5f, 0x03, 0x8d, 0xfe, 0x00, + 0x47, 0x6c, 0x00, 0x49, 0x06, 0x80, 0x9e, 0x02, 0xb7, 0x01, 0xff, 0x44, + 0x3e, 0xaa, 0x71, 0x06, 0x80, 0x84, 0x02, 0x04, 0x52, 0x00, 0x01, 0xff, + 0x09, 0xf1, 0xbb, 0x8b, 0x01, 0x49, 0x77, 0x1f, 0x7a, 0x08, 0x00, 0x1d, + 0xaa, 0x16, 0x75, 0x06, 0x56, 0x00, 0x45, 0x52, 0xb5, 0x55, 0x73, 0x08, + 0x00, 0x4b, 0x80, 0x96, 0x22, 0x06, 0x80, 0x29, 0x53, 0xf9, 0x4e, 0x72, + 0x08, 0x80, 0x11, 0x0b, 0xba, 0x6b, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x72, + 0x06, 0x00, 0x45, 0x20, 0x07, 0x73, 0x06, 0x40, 0x05, 0x19, 0x00, 0x01, + 0xff, 0x49, 0x77, 0x1f, 0x7c, 0x08, 0x00, 0x49, 0x13, 0xc1, 0x7f, 0x08, + 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x82, 0xfe, 0x00, 0x4d, 0x5f, + 0x03, 0x81, 0xfe, 0x40, 0x45, 0x5c, 0x00, 0x23, 0x06, 0x80, 0x16, 0x45, + 0x20, 0x07, 0x25, 0x06, 0xc0, 0x00, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, + 0x88, 0xfe, 0x00, 0x4d, 0x5f, 0x03, 0x87, 0xfe, 0x40, 0x80, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0x84, 0xfe, 0x00, 0x4d, 0x5f, 0x03, 0x83, 0xfe, 0x40, + 0x4a, 0xc8, 0xb0, 0x74, 0x07, 0x00, 0x48, 0x3f, 0xd2, 0x73, 0x07, 0x40, + 0x52, 0x09, 0x53, 0x75, 0x08, 0x80, 0x57, 0x45, 0x1a, 0x77, 0x70, 0x08, + 0x00, 0x45, 0x16, 0x53, 0x74, 0x08, 0x00, 0x05, 0xc3, 0x00, 0x3b, 0xb2, + 0x18, 0x4f, 0x10, 0x77, 0x71, 0x08, 0xc0, 0x00, 0x05, 0x19, 0x00, 0x01, + 0xff, 0x49, 0x77, 0x1f, 0x7b, 0x08, 0x00, 0x49, 0x13, 0xc1, 0x7e, 0x08, + 0x40, 0x05, 0xc9, 0x00, 0x11, 0x09, 0x2d, 0xb6, 0x01, 0xff, 0x45, 0x5c, + 0x00, 0x76, 0x08, 0x00, 0x45, 0x20, 0x07, 0x79, 0x08, 0x40, 0x45, 0x56, + 0x00, 0x81, 0x08, 0x00, 0x49, 0xdc, 0x5a, 0x77, 0x08, 0x40, 0x45, 0x56, + 0x00, 0x82, 0x08, 0x00, 0x49, 0xdc, 0x5a, 0x78, 0x08, 0x40, 0x05, 0x19, + 0x00, 0x01, 0xff, 0x49, 0x77, 0x1f, 0x7d, 0x08, 0x00, 0x49, 0x13, 0xc1, + 0x80, 0x08, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, 0x51, 0xfb, 0x00, + 0x4d, 0x5f, 0x03, 0x50, 0xfb, 0x40, 0x80, 0x01, 0xff, 0x4a, 0x7c, 0x2e, + 0xf0, 0xfe, 0x00, 0x4d, 0x5f, 0x03, 0xef, 0xfe, 0x40, 0x80, 0x01, 0xff, + 0x4a, 0x7c, 0x2e, 0xca, 0xfe, 0x00, 0xa9, 0x32, 0x4b, 0x1a, 0x71, 0xcc, + 0xfe, 0x00, 0x06, 0x29, 0x06, 0x01, 0xff, 0x0a, 0x7c, 0x13, 0x11, 0x08, + 0x5e, 0x0c, 0x01, 0xff, 0x45, 0x5c, 0x00, 0x5d, 0x07, 0x00, 0x50, 0xd4, + 0x2d, 0x5f, 0x07, 0x40, 0x45, 0x5c, 0x00, 0xa0, 0x06, 0x00, 0x45, 0x20, + 0x07, 0xb3, 0x08, 0x00, 0x58, 0x4c, 0x2c, 0x5e, 0x07, 0x40, 0x4b, 0x87, + 0x17, 0xcb, 0xfe, 0x00, 0x4c, 0x60, 0x03, 0xc9, 0xfe, 0x40, 0x43, 0x70, + 0xbe, 0xbb, 0x08, 0x00, 0x44, 0x30, 0x48, 0xbd, 0x08, 0x00, 0x43, 0x11, + 0x15, 0xbc, 0x08, 0xc0, 0x00, 0x56, 0x6f, 0x34, 0xc4, 0x08, 0x40, 0x45, + 0x5c, 0x00, 0xf7, 0x08, 0x00, 0x45, 0x20, 0x07, 0xf9, 0x08, 0x40, 0x07, + 0xfb, 0x04, 0x17, 0x0a, 0x2c, 0xb6, 0x01, 0xff, 0x45, 0x5c, 0x00, 0xce, + 0x08, 0x00, 0x45, 0x20, 0x07, 0xcf, 0x08, 0x00, 0x53, 0xd2, 0x4c, 0xd2, + 0x08, 0x40, 0x45, 0x5c, 0x00, 0xcf, 0x0e, 0x01, 0x45, 0x20, 0x07, 0xd1, + 0x08, 0x40, 0x80, 0x0d, 0x43, 0x65, 0x0b, 0x4d, 0x06, 0xc0, 0x00, 0x4e, 0x5e, 0x03, 0x74, 0xfe, 0x40, 0x4d, 0x5f, 0x03, 0x7a, 0xfe, 0x00, 0x4b, - 0xfd, 0x6d, 0x7b, 0xfe, 0x00, 0x4e, 0xc2, 0x7e, 0xf6, 0x08, 0x40, 0x53, - 0x14, 0x4b, 0x9f, 0x08, 0x00, 0x04, 0x58, 0x00, 0x01, 0xff, 0x45, 0x5c, - 0x00, 0x54, 0x06, 0x00, 0x45, 0x20, 0x07, 0x55, 0x06, 0x40, 0x44, 0x74, - 0x0f, 0x4e, 0x06, 0x80, 0x12, 0x50, 0x4d, 0x64, 0x6d, 0x06, 0x00, 0x4e, - 0x70, 0x7a, 0x02, 0x06, 0x00, 0x48, 0x82, 0x16, 0xd4, 0x06, 0x40, 0x80, - 0x0d, 0x43, 0xf9, 0x0a, 0x4b, 0x06, 0xc0, 0x00, 0x4e, 0x5e, 0x03, 0x70, - 0xfe, 0x40, 0x4d, 0x5f, 0x03, 0x76, 0xfe, 0x00, 0x4b, 0xfd, 0x6d, 0x77, - 0xfe, 0x00, 0x05, 0x51, 0x00, 0x01, 0xff, 0x49, 0x56, 0x1e, 0xf5, 0x08, - 0x00, 0x44, 0x22, 0x08, 0xf4, 0x08, 0x00, 0x48, 0x1f, 0x0a, 0x5e, 0x06, - 0x40, 0x0c, 0x4c, 0x92, 0x11, 0x06, 0x41, 0x05, 0x01, 0xff, 0x44, 0xb1, - 0x4a, 0xdd, 0x06, 0x00, 0x49, 0xc4, 0x62, 0x1d, 0x06, 0x40, 0x49, 0x48, - 0x0b, 0xeb, 0x06, 0x00, 0x48, 0x19, 0xc8, 0xea, 0x06, 0x40, 0xa1, 0x2c, - 0x50, 0x8d, 0x62, 0x6b, 0x06, 0x00, 0x53, 0xa2, 0x4a, 0xe2, 0x08, 0x00, - 0x05, 0x3c, 0x01, 0x01, 0xff, 0x80, 0x06, 0x47, 0x41, 0xd0, 0x9e, 0x08, - 0x40, 0x55, 0xeb, 0x3d, 0xfb, 0x08, 0x80, 0x06, 0x52, 0x86, 0x31, 0xfa, - 0x0e, 0x41, 0x49, 0x90, 0x3b, 0xfc, 0x08, 0x40, 0x43, 0x15, 0x05, 0x4f, - 0x06, 0x80, 0x06, 0x4c, 0xc4, 0x95, 0x0d, 0x06, 0x40, 0x80, 0x0d, 0x43, - 0xf9, 0x0a, 0x4c, 0x06, 0xc0, 0x00, 0x4e, 0x5e, 0x03, 0x72, 0xfe, 0x40, - 0x4d, 0x5f, 0x03, 0x78, 0xfe, 0x00, 0x4b, 0xfd, 0x6d, 0x79, 0xfe, 0x00, - 0x48, 0x91, 0x3b, 0xfe, 0x08, 0x40, 0x02, 0x14, 0x05, 0x2c, 0x05, 0x73, - 0x0b, 0x01, 0xff, 0x45, 0xf3, 0x5e, 0xe5, 0x08, 0x80, 0x1a, 0x45, 0xee, - 0x73, 0xe4, 0x08, 0x80, 0x0d, 0x45, 0xaf, 0x50, 0xe6, 0x08, 0xc0, 0x00, - 0x43, 0xf9, 0x0a, 0xe9, 0x08, 0x40, 0x43, 0xf9, 0x0a, 0xe7, 0x08, 0x40, - 0x43, 0xf9, 0x0a, 0xe8, 0x08, 0x40, 0x53, 0xa1, 0x48, 0xfc, 0x0e, 0x01, - 0x42, 0x6c, 0x00, 0x0c, 0x06, 0x40, 0x51, 0x5a, 0x58, 0x87, 0x08, 0x00, - 0x54, 0x13, 0x43, 0xd0, 0x0e, 0x41, 0xe3, 0x9f, 0x00, 0x00, 0x14, 0xef, - 0x43, 0x4d, 0xaf, 0x3f, 0xb0, 0x01, 0xff, 0xac, 0x2e, 0x02, 0xd0, 0x00, - 0x01, 0xff, 0x4f, 0x66, 0x6a, 0x50, 0x22, 0x00, 0x09, 0xe2, 0x0c, 0x01, - 0xff, 0x59, 0x6e, 0x23, 0x46, 0x22, 0x00, 0x06, 0x7b, 0x00, 0x01, 0xff, - 0x4b, 0x0e, 0x29, 0x70, 0x2a, 0x00, 0x42, 0x1e, 0x00, 0x45, 0x22, 0xc0, - 0x00, 0x50, 0x4d, 0x60, 0x52, 0x22, 0x40, 0x48, 0x5e, 0x19, 0xbd, 0xce, - 0x01, 0x57, 0xfd, 0x2e, 0x9f, 0x00, 0x40, 0x44, 0x8d, 0x44, 0xe4, 0x2b, - 0x00, 0x47, 0x7f, 0x36, 0x27, 0x00, 0x40, 0x45, 0x5e, 0xe4, 0x7a, 0x23, - 0x80, 0x81, 0x04, 0x4d, 0x13, 0x81, 0x40, 0x23, 0x00, 0xa3, 0xc6, 0x03, - 0xa4, 0xea, 0x02, 0x50, 0xed, 0x62, 0x77, 0x23, 0x00, 0x56, 0x34, 0x34, - 0x69, 0x23, 0x00, 0xa9, 0xc8, 0x02, 0x04, 0xd5, 0xf0, 0xb7, 0x02, 0x04, - 0xc3, 0x00, 0xa6, 0x02, 0x45, 0x59, 0xaf, 0x75, 0x23, 0x80, 0x98, 0x02, - 0x02, 0x7c, 0x00, 0x6c, 0xb2, 0x5e, 0xb3, 0x3b, 0x4f, 0xc6, 0x73, 0x68, - 0x23, 0x00, 0x02, 0x50, 0x02, 0x06, 0x45, 0xce, 0xec, 0x6c, 0x23, 0x40, - 0x80, 0x06, 0x4a, 0x7c, 0x78, 0x4f, 0x23, 0x40, 0x4b, 0x08, 0x9a, 0x72, - 0x23, 0x00, 0x48, 0xf9, 0xca, 0x5d, 0x23, 0x00, 0x05, 0x69, 0xd8, 0x01, - 0xff, 0x49, 0xb9, 0x23, 0x61, 0x23, 0x00, 0x43, 0xfe, 0xca, 0x55, 0x23, - 0x00, 0x47, 0xfb, 0x7f, 0x51, 0x23, 0x40, 0x51, 0xe1, 0x59, 0x6e, 0x23, - 0x00, 0x48, 0x18, 0x81, 0x3f, 0x23, 0x00, 0x4a, 0xf4, 0xaf, 0x37, 0x23, - 0x00, 0xb4, 0x01, 0xff, 0x4c, 0x70, 0x8c, 0x63, 0x23, 0x00, 0x49, 0x5f, - 0xba, 0x6d, 0x23, 0x40, 0x42, 0x0b, 0x00, 0x74, 0x23, 0x00, 0x4e, 0x78, - 0x78, 0x46, 0x23, 0x40, 0x42, 0xe8, 0x01, 0x95, 0x23, 0x80, 0x11, 0x04, - 0xbf, 0x54, 0x01, 0xff, 0x44, 0x79, 0x0d, 0x5e, 0x23, 0x00, 0x48, 0xea, - 0x59, 0x58, 0x23, 0x40, 0x80, 0x01, 0xff, 0x49, 0x44, 0x0e, 0x42, 0x23, - 0x00, 0xa3, 0x79, 0xa4, 0x4b, 0x45, 0x7b, 0x00, 0x38, 0x23, 0x00, 0x4c, - 0x87, 0x00, 0x44, 0x23, 0x00, 0x43, 0xfe, 0xca, 0x3b, 0x23, 0x00, 0x02, - 0x68, 0x00, 0x29, 0x49, 0x1d, 0x2b, 0x6f, 0x23, 0x00, 0x48, 0xc1, 0x34, - 0x70, 0x23, 0x00, 0x50, 0xb3, 0x02, 0x48, 0x23, 0x00, 0x45, 0x48, 0x0e, - 0x41, 0x23, 0x00, 0x02, 0x50, 0x02, 0x01, 0xff, 0x46, 0x7a, 0x7d, 0x53, - 0x23, 0x00, 0x4b, 0xb8, 0x02, 0x50, 0x23, 0x40, 0x4d, 0x6b, 0x1a, 0x47, - 0x23, 0x00, 0x47, 0xee, 0x00, 0x43, 0x23, 0x40, 0x42, 0xd8, 0x00, 0x54, - 0x23, 0x80, 0x1f, 0xa9, 0x11, 0x03, 0xa6, 0x01, 0x01, 0xff, 0x46, 0x7a, - 0x7d, 0x4c, 0x23, 0x00, 0x4b, 0xb8, 0x02, 0x57, 0x23, 0x40, 0x45, 0x9e, - 0x44, 0x3a, 0x23, 0x00, 0x44, 0x02, 0x00, 0x39, 0x23, 0x40, 0x42, 0x12, - 0x00, 0x4d, 0x23, 0x40, 0x45, 0x13, 0x03, 0x3c, 0x23, 0x00, 0x44, 0x51, - 0x12, 0x60, 0x23, 0x40, 0x49, 0xe9, 0x59, 0x79, 0x23, 0x40, 0x4b, 0xed, - 0x97, 0x67, 0x23, 0x00, 0x4a, 0x7c, 0x78, 0x45, 0x23, 0x40, 0x49, 0xb9, - 0x23, 0x64, 0x23, 0x00, 0x48, 0xea, 0x59, 0x5b, 0x23, 0x40, 0x45, 0x10, - 0xe2, 0x36, 0x23, 0x00, 0x43, 0x1b, 0x05, 0x73, 0x23, 0xc0, 0x00, 0x49, - 0xe9, 0x59, 0x78, 0x23, 0x40, 0x02, 0xd8, 0x00, 0x30, 0x4f, 0x62, 0x6e, - 0x5a, 0x23, 0x00, 0x03, 0xa6, 0x01, 0x01, 0xff, 0x80, 0x06, 0x4a, 0x7c, - 0x78, 0x56, 0x23, 0x40, 0x4b, 0x08, 0x9a, 0x71, 0x23, 0x00, 0x4a, 0xee, - 0x97, 0x66, 0x23, 0x00, 0x05, 0x69, 0xd8, 0x01, 0xff, 0x43, 0xfe, 0xca, - 0x4e, 0x23, 0x00, 0x48, 0xea, 0x59, 0x4a, 0x23, 0x40, 0x80, 0x11, 0x03, - 0xd6, 0x22, 0x01, 0xff, 0x45, 0x60, 0x01, 0x4b, 0x23, 0x00, 0x48, 0xea, - 0x59, 0x59, 0x23, 0x40, 0x49, 0xb9, 0x23, 0x62, 0x23, 0x00, 0x45, 0x60, - 0x01, 0x52, 0x23, 0x00, 0x45, 0x37, 0x23, 0x6b, 0x23, 0x40, 0x06, 0xfc, - 0x04, 0x06, 0x48, 0x59, 0xc9, 0x6a, 0x23, 0x40, 0x49, 0x44, 0x0e, 0x49, - 0x23, 0x00, 0x49, 0xb9, 0x23, 0x65, 0x23, 0x00, 0x43, 0xfe, 0xca, 0x3e, - 0x23, 0x00, 0x02, 0x60, 0x01, 0x06, 0x48, 0xea, 0x59, 0x5c, 0x23, 0x40, - 0x42, 0x17, 0x00, 0x5f, 0x23, 0x00, 0x43, 0x62, 0x01, 0x3d, 0x23, 0x40, - 0x49, 0xe9, 0x59, 0x76, 0x23, 0x40, 0x03, 0x5a, 0x16, 0xad, 0x01, 0x44, - 0xd2, 0xd9, 0x93, 0x26, 0x00, 0x4a, 0x3c, 0xa9, 0xd1, 0x27, 0x00, 0xa7, - 0x6f, 0x42, 0x60, 0x0c, 0x25, 0x26, 0x00, 0xf4, 0x1c, 0xf4, 0xc1, 0x00, - 0x44, 0x0d, 0xc2, 0x08, 0xcc, 0x81, 0x57, 0x0b, 0x64, 0x10, 0x01, 0xff, - 0xa3, 0x44, 0x68, 0xe0, 0x04, 0x04, 0xf5, 0x01, 0x53, 0xab, 0x49, 0xf2, - 0x27, 0x00, 0x4b, 0x54, 0x90, 0x11, 0x2a, 0x00, 0x51, 0xf6, 0x04, 0xba, - 0x21, 0x00, 0xb4, 0x01, 0xff, 0x53, 0xd2, 0x4b, 0xb6, 0x21, 0x00, 0x0f, - 0x02, 0x02, 0x01, 0xff, 0x55, 0xd1, 0x39, 0x8d, 0x2b, 0x00, 0x53, 0x01, - 0x4b, 0x8e, 0x2b, 0x00, 0x51, 0xf6, 0x04, 0x6f, 0x2b, 0x00, 0x54, 0x7f, - 0x45, 0x8c, 0x2b, 0x00, 0x52, 0xd6, 0x55, 0x8f, 0x2b, 0x40, 0x52, 0x84, - 0x53, 0x40, 0x29, 0x00, 0x4f, 0x5f, 0x71, 0x33, 0x22, 0x40, 0x4a, 0x62, - 0xa6, 0xf6, 0xf4, 0x41, 0x49, 0x00, 0x2a, 0xa2, 0xf4, 0x01, 0x42, 0x68, - 0x00, 0x20, 0x22, 0x80, 0x12, 0x47, 0xa4, 0xd5, 0x20, 0xf6, 0x01, 0x4a, - 0x8e, 0xb1, 0x2b, 0x21, 0x00, 0x4b, 0x58, 0xa4, 0x27, 0xf6, 0x41, 0x06, - 0x50, 0x00, 0x01, 0xff, 0x48, 0xfe, 0x54, 0x9e, 0x29, 0x00, 0x48, 0xea, - 0x59, 0xa4, 0x29, 0x40, 0x11, 0xdf, 0x5b, 0x06, 0x4b, 0x9e, 0x9f, 0xc0, - 0xfa, 0x41, 0x90, 0x92, 0x10, 0x91, 0x9a, 0x0c, 0x92, 0xb5, 0x08, 0x93, - 0xbd, 0x04, 0x94, 0x83, 0x01, 0x95, 0x01, 0xff, 0x90, 0x5a, 0x91, 0x30, - 0x92, 0x06, 0x42, 0xce, 0xf3, 0x46, 0x46, 0x41, 0xd0, 0x3c, 0x46, 0x01, - 0xd1, 0x3d, 0x46, 0x01, 0xd2, 0x3e, 0x46, 0x01, 0xd3, 0x3f, 0x46, 0x01, - 0xd4, 0x40, 0x46, 0x01, 0xd5, 0x41, 0x46, 0x01, 0xd6, 0x42, 0x46, 0x01, - 0xd7, 0x43, 0x46, 0x01, 0xd8, 0x44, 0x46, 0x01, 0xd9, 0x45, 0x46, 0x41, - 0xd0, 0x32, 0x46, 0x01, 0xd1, 0x33, 0x46, 0x01, 0xd2, 0x34, 0x46, 0x01, - 0xd3, 0x35, 0x46, 0x01, 0xd4, 0x36, 0x46, 0x01, 0xd5, 0x37, 0x46, 0x01, - 0xd6, 0x38, 0x46, 0x01, 0xd7, 0x39, 0x46, 0x01, 0xd8, 0x3a, 0x46, 0x01, - 0xd9, 0x3b, 0x46, 0x41, 0xd1, 0x29, 0x46, 0x01, 0xd2, 0x2a, 0x46, 0x01, - 0xd3, 0x2b, 0x46, 0x01, 0xd4, 0x2c, 0x46, 0x01, 0xd5, 0x2d, 0x46, 0x01, - 0xd6, 0x2e, 0x46, 0x01, 0xd7, 0x2f, 0x46, 0x01, 0xd8, 0x30, 0x46, 0x01, - 0xd9, 0x31, 0x46, 0x41, 0x90, 0x8c, 0x03, 0x91, 0xd7, 0x02, 0x92, 0xac, - 0x02, 0x93, 0x81, 0x02, 0x94, 0xd6, 0x01, 0x95, 0xa1, 0x01, 0x96, 0x77, - 0x97, 0x4d, 0x98, 0x23, 0x99, 0x01, 0xff, 0xd0, 0x21, 0x46, 0x01, 0xd1, - 0x22, 0x46, 0x01, 0xd2, 0x23, 0x46, 0x01, 0xd3, 0x24, 0x46, 0x01, 0xd4, - 0x25, 0x46, 0x01, 0xd5, 0x26, 0x46, 0x01, 0xd6, 0x27, 0x46, 0x01, 0xd7, - 0x28, 0x46, 0x41, 0xd0, 0x17, 0x46, 0x01, 0xd1, 0x18, 0x46, 0x01, 0xd2, - 0x19, 0x46, 0x01, 0xd3, 0x1a, 0x46, 0x01, 0xd4, 0x1b, 0x46, 0x01, 0xd5, - 0x1c, 0x46, 0x01, 0xd6, 0x1d, 0x46, 0x01, 0xd7, 0x1e, 0x46, 0x01, 0xd8, - 0x1f, 0x46, 0x01, 0xd9, 0x20, 0x46, 0x41, 0xd0, 0x0d, 0x46, 0x01, 0xd1, - 0x0e, 0x46, 0x01, 0xd2, 0x0f, 0x46, 0x01, 0xd3, 0x10, 0x46, 0x01, 0xd4, - 0x11, 0x46, 0x01, 0xd5, 0x12, 0x46, 0x01, 0xd6, 0x13, 0x46, 0x01, 0xd7, - 0x14, 0x46, 0x01, 0xd8, 0x15, 0x46, 0x01, 0xd9, 0x16, 0x46, 0x41, 0xd0, - 0x03, 0x46, 0x01, 0xd1, 0x04, 0x46, 0x01, 0xd2, 0x05, 0x46, 0x01, 0xd3, - 0x06, 0x46, 0x01, 0xd4, 0x07, 0x46, 0x01, 0xd5, 0x08, 0x46, 0x01, 0xd6, - 0x09, 0x46, 0x01, 0xd7, 0x0a, 0x46, 0x01, 0xd8, 0x0b, 0x46, 0x01, 0xd9, - 0x0c, 0x46, 0x41, 0xd0, 0xf7, 0x45, 0x81, 0x29, 0xd1, 0xf9, 0x45, 0x01, - 0xd2, 0xfa, 0x45, 0x01, 0xd3, 0xfb, 0x45, 0x01, 0xd4, 0xfc, 0x45, 0x01, - 0xd5, 0xfd, 0x45, 0x01, 0xd6, 0xfe, 0x45, 0x01, 0xd7, 0xff, 0x45, 0x81, - 0x08, 0xd8, 0x01, 0x46, 0x01, 0xd9, 0x02, 0x46, 0x41, 0xe1, 0x00, 0x46, - 0x41, 0xe1, 0xf8, 0x45, 0x41, 0xd0, 0xed, 0x45, 0x01, 0xd1, 0xee, 0x45, - 0x01, 0xd2, 0xef, 0x45, 0x01, 0xd3, 0xf0, 0x45, 0x01, 0xd4, 0xf1, 0x45, - 0x01, 0xd5, 0xf2, 0x45, 0x01, 0xd6, 0xf3, 0x45, 0x01, 0xd7, 0xf4, 0x45, - 0x01, 0xd8, 0xf5, 0x45, 0x01, 0xd9, 0xf6, 0x45, 0x41, 0xd0, 0xe3, 0x45, - 0x01, 0xd1, 0xe4, 0x45, 0x01, 0xd2, 0xe5, 0x45, 0x01, 0xd3, 0xe6, 0x45, - 0x01, 0xd4, 0xe7, 0x45, 0x01, 0xd5, 0xe8, 0x45, 0x01, 0xd6, 0xe9, 0x45, - 0x01, 0xd7, 0xea, 0x45, 0x01, 0xd8, 0xeb, 0x45, 0x01, 0xd9, 0xec, 0x45, - 0x41, 0xd0, 0xd9, 0x45, 0x01, 0xd1, 0xda, 0x45, 0x01, 0xd2, 0xdb, 0x45, - 0x01, 0xd3, 0xdc, 0x45, 0x01, 0xd4, 0xdd, 0x45, 0x01, 0xd5, 0xde, 0x45, - 0x01, 0xd6, 0xdf, 0x45, 0x01, 0xd7, 0xe0, 0x45, 0x01, 0xd8, 0xe1, 0x45, - 0x01, 0xd9, 0xe2, 0x45, 0x41, 0x90, 0x24, 0xd1, 0xd0, 0x45, 0x01, 0xd2, - 0xd1, 0x45, 0x01, 0xd3, 0xd2, 0x45, 0x01, 0xd4, 0xd3, 0x45, 0x01, 0xd5, - 0xd4, 0x45, 0x01, 0xd6, 0xd5, 0x45, 0x01, 0xd7, 0xd6, 0x45, 0x01, 0xd8, - 0xd7, 0x45, 0x01, 0xd9, 0xd8, 0x45, 0x41, 0x54, 0xb7, 0x3f, 0xce, 0x45, - 0x01, 0x53, 0xe3, 0x47, 0xcf, 0x45, 0x41, 0xd0, 0xc4, 0x45, 0x01, 0xd1, - 0xc5, 0x45, 0x01, 0xd2, 0xc6, 0x45, 0x01, 0xd3, 0xc7, 0x45, 0x01, 0xd4, - 0xc8, 0x45, 0x01, 0xd5, 0xc9, 0x45, 0x01, 0xd6, 0xca, 0x45, 0x01, 0xd7, - 0xcb, 0x45, 0x01, 0xd8, 0xcc, 0x45, 0x01, 0xd9, 0xcd, 0x45, 0x41, 0x90, - 0xc5, 0x03, 0x91, 0x9a, 0x03, 0x92, 0xea, 0x02, 0x93, 0xa8, 0x02, 0x94, - 0xfd, 0x01, 0x95, 0xcd, 0x01, 0x96, 0x98, 0x01, 0x97, 0x69, 0x98, 0x2d, - 0x99, 0x01, 0xff, 0xd0, 0xba, 0x45, 0x01, 0xd1, 0xbb, 0x45, 0x01, 0xd2, - 0xbc, 0x45, 0x01, 0x47, 0x3b, 0xce, 0xbd, 0x45, 0x01, 0xd4, 0xbe, 0x45, - 0x01, 0xd5, 0xbf, 0x45, 0x01, 0xd6, 0xc0, 0x45, 0x01, 0xd7, 0xc1, 0x45, - 0x01, 0xd8, 0xc2, 0x45, 0x01, 0xd9, 0xc3, 0x45, 0x41, 0xd0, 0xad, 0x45, - 0x01, 0xd1, 0xae, 0x45, 0x81, 0x2d, 0xd2, 0xb0, 0x45, 0x01, 0x93, 0x1d, - 0xd4, 0xb3, 0x45, 0x01, 0xd5, 0xb4, 0x45, 0x01, 0xd6, 0xb5, 0x45, 0x81, - 0x0c, 0xd7, 0xb7, 0x45, 0x01, 0xd8, 0xb8, 0x45, 0x01, 0xd9, 0xb9, 0x45, - 0x41, 0xe1, 0xb6, 0x45, 0x41, 0x49, 0xec, 0xb4, 0xb1, 0x45, 0x01, 0xe1, - 0xb2, 0x45, 0x41, 0xe1, 0xaf, 0x45, 0x41, 0xd0, 0xa2, 0x45, 0x01, 0xd1, - 0xa3, 0x45, 0x81, 0x20, 0xd2, 0xa5, 0x45, 0x01, 0xd3, 0xa6, 0x45, 0x01, - 0xd4, 0xa7, 0x45, 0x01, 0xd5, 0xa8, 0x45, 0x01, 0xd6, 0xa9, 0x45, 0x01, - 0xd7, 0xaa, 0x45, 0x01, 0xd8, 0xab, 0x45, 0x01, 0xd9, 0xac, 0x45, 0x41, - 0xe1, 0xa4, 0x45, 0x41, 0xd0, 0x96, 0x45, 0x01, 0xd1, 0x97, 0x45, 0x01, - 0xd2, 0x98, 0x45, 0x01, 0xd3, 0x99, 0x45, 0x01, 0xd4, 0x9a, 0x45, 0x81, - 0x19, 0xd5, 0x9c, 0x45, 0x01, 0xd6, 0x9d, 0x45, 0x01, 0xd7, 0x9e, 0x45, - 0x01, 0xd8, 0x9f, 0x45, 0x81, 0x04, 0xd9, 0xa1, 0x45, 0x41, 0xe1, 0xa0, - 0x45, 0x41, 0xe1, 0x9b, 0x45, 0x41, 0xd0, 0x8b, 0x45, 0x01, 0xd1, 0x8c, - 0x45, 0x01, 0xd2, 0x8d, 0x45, 0x01, 0xd3, 0x8e, 0x45, 0x01, 0xd4, 0x8f, - 0x45, 0x01, 0xd5, 0x90, 0x45, 0x01, 0xd6, 0x91, 0x45, 0x01, 0xd7, 0x92, - 0x45, 0x01, 0xd8, 0x93, 0x45, 0x01, 0xd9, 0x94, 0x45, 0xc1, 0x00, 0xe1, - 0x95, 0x45, 0x41, 0xd0, 0x81, 0x45, 0x01, 0xd1, 0x82, 0x45, 0x01, 0xd2, - 0x83, 0x45, 0x01, 0xd3, 0x84, 0x45, 0x01, 0xd4, 0x85, 0x45, 0x01, 0xd5, - 0x86, 0x45, 0x01, 0xd6, 0x87, 0x45, 0x01, 0xd7, 0x88, 0x45, 0x01, 0xd8, - 0x89, 0x45, 0x01, 0xd9, 0x8a, 0x45, 0x41, 0xd0, 0x72, 0x45, 0x01, 0xd1, - 0x73, 0x45, 0x01, 0x92, 0x29, 0xd3, 0x77, 0x45, 0x01, 0xd4, 0x78, 0x45, - 0x01, 0xd5, 0x79, 0x45, 0x01, 0xd6, 0x7a, 0x45, 0x81, 0x0c, 0xd7, 0x7e, - 0x45, 0x01, 0xd8, 0x7f, 0x45, 0x01, 0xd9, 0x80, 0x45, 0x41, 0xe1, 0x7b, - 0x45, 0x01, 0xe2, 0x7c, 0x45, 0x01, 0xe3, 0x7d, 0x45, 0x41, 0xe1, 0x74, - 0x45, 0x01, 0xe2, 0x75, 0x45, 0x01, 0xe3, 0x76, 0x45, 0x41, 0xd0, 0x67, - 0x45, 0x01, 0xd1, 0x68, 0x45, 0x01, 0xd2, 0x69, 0x45, 0x01, 0xd3, 0x6a, - 0x45, 0x01, 0xd4, 0x6b, 0x45, 0x01, 0xd5, 0x6c, 0x45, 0x01, 0xd6, 0x6d, - 0x45, 0x01, 0xd7, 0x6e, 0x45, 0x01, 0xd8, 0x6f, 0x45, 0x01, 0xd9, 0x70, - 0x45, 0xc1, 0x00, 0xe1, 0x71, 0x45, 0x41, 0xd0, 0x5d, 0x45, 0x01, 0xd1, - 0x5e, 0x45, 0x01, 0xd2, 0x5f, 0x45, 0x01, 0xd3, 0x60, 0x45, 0x01, 0xd4, - 0x61, 0x45, 0x01, 0xd5, 0x62, 0x45, 0x01, 0xd6, 0x63, 0x45, 0x01, 0xd7, - 0x64, 0x45, 0x01, 0xd8, 0x65, 0x45, 0x01, 0xd9, 0x66, 0x45, 0x41, 0xd0, - 0x52, 0x45, 0x01, 0xd1, 0x53, 0x45, 0x01, 0xd2, 0x54, 0x45, 0x01, 0xd3, - 0x55, 0x45, 0x01, 0xd4, 0x56, 0x45, 0x01, 0xd5, 0x57, 0x45, 0x01, 0xd6, - 0x58, 0x45, 0x01, 0xd7, 0x59, 0x45, 0x01, 0xd8, 0x5a, 0x45, 0x01, 0xd9, - 0x5b, 0x45, 0xc1, 0x00, 0xe1, 0x5c, 0x45, 0x41, 0x90, 0xa4, 0x03, 0x91, - 0xef, 0x02, 0x92, 0xbf, 0x02, 0x93, 0x94, 0x02, 0x94, 0xe9, 0x01, 0x95, - 0xbe, 0x01, 0x96, 0x8e, 0x01, 0x97, 0x64, 0x98, 0x35, 0x99, 0x01, 0xff, - 0xd0, 0x46, 0x45, 0x01, 0xd1, 0x47, 0x45, 0x01, 0xd2, 0x48, 0x45, 0x01, - 0xd3, 0x49, 0x45, 0x01, 0xd4, 0x4a, 0x45, 0x81, 0x19, 0xd5, 0x4c, 0x45, - 0x01, 0xd6, 0x4d, 0x45, 0x01, 0xd7, 0x4e, 0x45, 0x01, 0xd8, 0x4f, 0x45, - 0x01, 0xd9, 0x50, 0x45, 0xc1, 0x00, 0xe1, 0x51, 0x45, 0x41, 0xe1, 0x4b, - 0x45, 0x41, 0xd0, 0x3b, 0x45, 0x01, 0xd1, 0x3c, 0x45, 0x01, 0xd2, 0x3d, - 0x45, 0x01, 0xd3, 0x3e, 0x45, 0x01, 0xd4, 0x3f, 0x45, 0x01, 0xd5, 0x40, - 0x45, 0x01, 0xd6, 0x41, 0x45, 0x01, 0xd7, 0x42, 0x45, 0x01, 0xd8, 0x43, - 0x45, 0x01, 0xd9, 0x44, 0x45, 0xc1, 0x00, 0xe1, 0x45, 0x45, 0x41, 0xd0, - 0x31, 0x45, 0x01, 0xd1, 0x32, 0x45, 0x01, 0xd2, 0x33, 0x45, 0x01, 0xd3, - 0x34, 0x45, 0x01, 0xd4, 0x35, 0x45, 0x01, 0xd5, 0x36, 0x45, 0x01, 0xd6, - 0x37, 0x45, 0x01, 0xd7, 0x38, 0x45, 0x01, 0xd8, 0x39, 0x45, 0x01, 0xd9, - 0x3a, 0x45, 0x41, 0xd0, 0x26, 0x45, 0x01, 0xd1, 0x27, 0x45, 0x01, 0xd2, - 0x28, 0x45, 0x01, 0xd3, 0x29, 0x45, 0x01, 0xd4, 0x2a, 0x45, 0x01, 0xd5, - 0x2b, 0x45, 0x01, 0xd6, 0x2c, 0x45, 0x01, 0xd7, 0x2d, 0x45, 0x81, 0x08, - 0xd8, 0x2f, 0x45, 0x01, 0xd9, 0x30, 0x45, 0x41, 0xe1, 0x2e, 0x45, 0x41, - 0xd0, 0x1c, 0x45, 0x01, 0xd1, 0x1d, 0x45, 0x01, 0xd2, 0x1e, 0x45, 0x01, - 0xd3, 0x1f, 0x45, 0x01, 0xd4, 0x20, 0x45, 0x01, 0xd5, 0x21, 0x45, 0x01, - 0xd6, 0x22, 0x45, 0x01, 0xd7, 0x23, 0x45, 0x01, 0xd8, 0x24, 0x45, 0x01, - 0xd9, 0x25, 0x45, 0x41, 0xd0, 0x12, 0x45, 0x01, 0xd1, 0x13, 0x45, 0x01, - 0xd2, 0x14, 0x45, 0x01, 0xd3, 0x15, 0x45, 0x01, 0xd4, 0x16, 0x45, 0x01, - 0xd5, 0x17, 0x45, 0x01, 0xd6, 0x18, 0x45, 0x01, 0xd7, 0x19, 0x45, 0x01, - 0xd8, 0x1a, 0x45, 0x01, 0xd9, 0x1b, 0x45, 0x41, 0xd0, 0x08, 0x45, 0x01, - 0xd1, 0x09, 0x45, 0x01, 0xd2, 0x0a, 0x45, 0x01, 0xd3, 0x0b, 0x45, 0x01, - 0xd4, 0x0c, 0x45, 0x01, 0xd5, 0x0d, 0x45, 0x01, 0xd6, 0x0e, 0x45, 0x01, - 0xd7, 0x0f, 0x45, 0x01, 0xd8, 0x10, 0x45, 0x01, 0xd9, 0x11, 0x45, 0x41, - 0xd0, 0xfd, 0x44, 0x01, 0xd1, 0xfe, 0x44, 0x01, 0xd2, 0xff, 0x44, 0x01, - 0xd3, 0x00, 0x45, 0x01, 0xd4, 0x01, 0x45, 0x01, 0xd5, 0x02, 0x45, 0x01, - 0xd6, 0x03, 0x45, 0x01, 0xd7, 0x04, 0x45, 0x81, 0x08, 0xd8, 0x06, 0x45, - 0x01, 0xd9, 0x07, 0x45, 0x41, 0xe1, 0x05, 0x45, 0x41, 0xd0, 0xf1, 0x44, - 0x01, 0xd1, 0xf2, 0x44, 0x01, 0xd2, 0xf3, 0x44, 0x01, 0xd3, 0xf4, 0x44, - 0x01, 0xd4, 0xf5, 0x44, 0x01, 0xd5, 0xf6, 0x44, 0x81, 0x15, 0xd6, 0xf8, - 0x44, 0x81, 0x0c, 0xd7, 0xfa, 0x44, 0x01, 0xd8, 0xfb, 0x44, 0x01, 0xd9, - 0xfc, 0x44, 0x41, 0xe1, 0xf9, 0x44, 0x41, 0xe1, 0xf7, 0x44, 0x41, 0xd0, - 0xe3, 0x44, 0x01, 0xd1, 0xe4, 0x44, 0x01, 0xd2, 0xe5, 0x44, 0x81, 0x26, - 0xd3, 0xe8, 0x44, 0x01, 0xd4, 0xe9, 0x44, 0x01, 0xd5, 0xea, 0x44, 0x01, - 0xd6, 0xeb, 0x44, 0x01, 0xd7, 0xec, 0x44, 0x81, 0x0d, 0xd8, 0xee, 0x44, - 0x01, 0xd9, 0xef, 0x44, 0xc1, 0x00, 0xe1, 0xf0, 0x44, 0x41, 0xe1, 0xed, - 0x44, 0x41, 0xe1, 0xe6, 0x44, 0x01, 0xe2, 0xe7, 0x44, 0x41, 0x90, 0x98, - 0x03, 0x91, 0xdf, 0x02, 0x92, 0xaf, 0x02, 0x93, 0xff, 0x01, 0x94, 0xd4, - 0x01, 0x95, 0xa9, 0x01, 0x96, 0x7f, 0x97, 0x55, 0x98, 0x2b, 0x99, 0x01, - 0xff, 0xd0, 0xd9, 0x44, 0x01, 0xd1, 0xda, 0x44, 0x01, 0xd2, 0xdb, 0x44, - 0x01, 0xd3, 0xdc, 0x44, 0x01, 0xd4, 0xdd, 0x44, 0x01, 0xd5, 0xde, 0x44, - 0x01, 0xd6, 0xdf, 0x44, 0x01, 0xd7, 0xe0, 0x44, 0x01, 0xd8, 0xe1, 0x44, - 0x01, 0xd9, 0xe2, 0x44, 0x41, 0xd0, 0xcf, 0x44, 0x01, 0xd1, 0xd0, 0x44, - 0x01, 0xd2, 0xd1, 0x44, 0x01, 0xd3, 0xd2, 0x44, 0x01, 0xd4, 0xd3, 0x44, - 0x01, 0xd5, 0xd4, 0x44, 0x01, 0xd6, 0xd5, 0x44, 0x01, 0xd7, 0xd6, 0x44, - 0x01, 0xd8, 0xd7, 0x44, 0x01, 0xd9, 0xd8, 0x44, 0x41, 0xd0, 0xc5, 0x44, - 0x01, 0xd1, 0xc6, 0x44, 0x01, 0xd2, 0xc7, 0x44, 0x01, 0xd3, 0xc8, 0x44, - 0x01, 0xd4, 0xc9, 0x44, 0x01, 0xd5, 0xca, 0x44, 0x01, 0xd6, 0xcb, 0x44, - 0x01, 0xd7, 0xcc, 0x44, 0x01, 0xd8, 0xcd, 0x44, 0x01, 0xd9, 0xce, 0x44, - 0x41, 0xd0, 0xbb, 0x44, 0x01, 0xd1, 0xbc, 0x44, 0x01, 0xd2, 0xbd, 0x44, - 0x01, 0xd3, 0xbe, 0x44, 0x01, 0xd4, 0xbf, 0x44, 0x01, 0xd5, 0xc0, 0x44, - 0x01, 0xd6, 0xc1, 0x44, 0x01, 0xd7, 0xc2, 0x44, 0x01, 0xd8, 0xc3, 0x44, - 0x01, 0xd9, 0xc4, 0x44, 0x41, 0xd0, 0xb1, 0x44, 0x01, 0xd1, 0xb2, 0x44, - 0x01, 0xd2, 0xb3, 0x44, 0x01, 0xd3, 0xb4, 0x44, 0x01, 0xd4, 0xb5, 0x44, - 0x01, 0xd5, 0xb6, 0x44, 0x01, 0xd6, 0xb7, 0x44, 0x01, 0xd7, 0xb8, 0x44, - 0x01, 0xd8, 0xb9, 0x44, 0x01, 0xd9, 0xba, 0x44, 0x41, 0xd0, 0xa7, 0x44, - 0x01, 0xd1, 0xa8, 0x44, 0x01, 0xd2, 0xa9, 0x44, 0x01, 0xd3, 0xaa, 0x44, - 0x01, 0xd4, 0xab, 0x44, 0x01, 0xd5, 0xac, 0x44, 0x01, 0xd6, 0xad, 0x44, - 0x01, 0xd7, 0xae, 0x44, 0x01, 0xd8, 0xaf, 0x44, 0x01, 0xd9, 0xb0, 0x44, - 0x41, 0xd0, 0x9c, 0x44, 0x01, 0xd1, 0x9d, 0x44, 0x01, 0xd2, 0x9e, 0x44, - 0x01, 0xd3, 0x9f, 0x44, 0x01, 0xd4, 0xa0, 0x44, 0x01, 0xd5, 0xa1, 0x44, - 0x81, 0x10, 0xd6, 0xa3, 0x44, 0x01, 0xd7, 0xa4, 0x44, 0x01, 0xd8, 0xa5, - 0x44, 0x01, 0xd9, 0xa6, 0x44, 0x41, 0xe1, 0xa2, 0x44, 0x41, 0xd0, 0x91, - 0x44, 0x01, 0xd1, 0x92, 0x44, 0x01, 0xd2, 0x93, 0x44, 0x01, 0xd3, 0x94, - 0x44, 0x01, 0xd4, 0x95, 0x44, 0x01, 0xd5, 0x96, 0x44, 0x81, 0x10, 0xd6, - 0x98, 0x44, 0x01, 0xd7, 0x99, 0x44, 0x01, 0xd8, 0x9a, 0x44, 0x01, 0xd9, - 0x9b, 0x44, 0x41, 0xe1, 0x97, 0x44, 0x41, 0xd0, 0x84, 0x44, 0x81, 0x29, - 0xd1, 0x87, 0x44, 0x01, 0xd2, 0x88, 0x44, 0x01, 0xd3, 0x89, 0x44, 0x01, - 0xd4, 0x8a, 0x44, 0x01, 0xd5, 0x8b, 0x44, 0x81, 0x10, 0xd6, 0x8d, 0x44, - 0x01, 0xd7, 0x8e, 0x44, 0x01, 0xd8, 0x8f, 0x44, 0x01, 0xd9, 0x90, 0x44, - 0x41, 0xe1, 0x8c, 0x44, 0x41, 0xe1, 0x85, 0x44, 0x01, 0xe2, 0x86, 0x44, - 0x41, 0xd0, 0x6f, 0x44, 0x81, 0x51, 0xd1, 0x71, 0x44, 0x81, 0x48, 0xd2, - 0x73, 0x44, 0x81, 0x3f, 0xd3, 0x75, 0x44, 0x01, 0xd4, 0x76, 0x44, 0x81, - 0x2a, 0xd5, 0x7a, 0x44, 0x81, 0x1d, 0xd6, 0x7d, 0x44, 0x01, 0xd7, 0x7e, - 0x44, 0x81, 0x08, 0xd8, 0x82, 0x44, 0x01, 0xd9, 0x83, 0x44, 0x41, 0xe1, - 0x7f, 0x44, 0x01, 0xe2, 0x80, 0x44, 0x01, 0xe3, 0x81, 0x44, 0x41, 0xe1, - 0x7b, 0x44, 0x01, 0xe2, 0x7c, 0x44, 0x41, 0xe1, 0x77, 0x44, 0x01, 0xe2, - 0x78, 0x44, 0x01, 0xe3, 0x79, 0x44, 0x41, 0xe1, 0x74, 0x44, 0x41, 0xe1, - 0x72, 0x44, 0x41, 0xe1, 0x70, 0x44, 0x41, 0x90, 0xba, 0x03, 0x91, 0x8a, - 0x03, 0x92, 0xda, 0x02, 0x93, 0xaa, 0x02, 0x94, 0xec, 0x01, 0x95, 0xc1, - 0x01, 0x96, 0x89, 0x01, 0x97, 0x5f, 0x98, 0x35, 0x99, 0x01, 0xff, 0xd0, - 0x63, 0x44, 0x01, 0xd1, 0x64, 0x44, 0x01, 0xd2, 0x65, 0x44, 0x01, 0xd3, - 0x66, 0x44, 0x01, 0xd4, 0x67, 0x44, 0x01, 0xd5, 0x68, 0x44, 0x01, 0xd6, - 0x69, 0x44, 0x01, 0xd7, 0x6a, 0x44, 0x81, 0x0d, 0xd8, 0x6c, 0x44, 0x81, - 0x04, 0xd9, 0x6e, 0x44, 0x41, 0xe1, 0x6d, 0x44, 0x41, 0xe1, 0x6b, 0x44, - 0x41, 0xd0, 0x59, 0x44, 0x01, 0xd1, 0x5a, 0x44, 0x01, 0xd2, 0x5b, 0x44, - 0x01, 0xd3, 0x5c, 0x44, 0x01, 0xd4, 0x5d, 0x44, 0x01, 0xd5, 0x5e, 0x44, - 0x01, 0xd6, 0x5f, 0x44, 0x01, 0xd7, 0x60, 0x44, 0x01, 0xd8, 0x61, 0x44, - 0x01, 0xd9, 0x62, 0x44, 0x41, 0xd0, 0x4f, 0x44, 0x01, 0xd1, 0x50, 0x44, - 0x01, 0xd2, 0x51, 0x44, 0x01, 0xd3, 0x52, 0x44, 0x01, 0xd4, 0x53, 0x44, - 0x01, 0xd5, 0x54, 0x44, 0x01, 0xd6, 0x55, 0x44, 0x01, 0xd7, 0x56, 0x44, - 0x01, 0xd8, 0x57, 0x44, 0x01, 0xd9, 0x58, 0x44, 0x41, 0xd0, 0x42, 0x44, - 0x01, 0xd1, 0x43, 0x44, 0x01, 0xd2, 0x44, 0x44, 0x01, 0xd3, 0x45, 0x44, - 0x01, 0xd4, 0x46, 0x44, 0x01, 0xd5, 0x47, 0x44, 0x01, 0xd6, 0x48, 0x44, - 0x81, 0x0c, 0xd7, 0x4c, 0x44, 0x01, 0xd8, 0x4d, 0x44, 0x01, 0xd9, 0x4e, - 0x44, 0x41, 0xe1, 0x49, 0x44, 0x01, 0xe2, 0x4a, 0x44, 0x01, 0xe3, 0x4b, - 0x44, 0x41, 0xd0, 0x38, 0x44, 0x01, 0xd1, 0x39, 0x44, 0x01, 0xd2, 0x3a, - 0x44, 0x01, 0xd3, 0x3b, 0x44, 0x01, 0xd4, 0x3c, 0x44, 0x01, 0xd5, 0x3d, - 0x44, 0x01, 0xd6, 0x3e, 0x44, 0x01, 0xd7, 0x3f, 0x44, 0x01, 0xd8, 0x40, - 0x44, 0x01, 0xd9, 0x41, 0x44, 0x41, 0xd0, 0x2a, 0x44, 0x01, 0xd1, 0x2b, - 0x44, 0x81, 0x2e, 0xd2, 0x2d, 0x44, 0x01, 0xd3, 0x2e, 0x44, 0x01, 0xd4, - 0x2f, 0x44, 0x01, 0xd5, 0x30, 0x44, 0x81, 0x19, 0xd6, 0x32, 0x44, 0x81, - 0x0c, 0xd7, 0x35, 0x44, 0x01, 0xd8, 0x36, 0x44, 0x01, 0xd9, 0x37, 0x44, - 0x41, 0xe1, 0x33, 0x44, 0x01, 0xe2, 0x34, 0x44, 0x41, 0xe1, 0x31, 0x44, - 0x41, 0xe1, 0x2c, 0x44, 0x41, 0xd0, 0x1f, 0x44, 0x01, 0xd1, 0x20, 0x44, - 0x01, 0xd2, 0x21, 0x44, 0x01, 0xd3, 0x22, 0x44, 0x01, 0xd4, 0x23, 0x44, - 0x01, 0xd5, 0x24, 0x44, 0x01, 0xd6, 0x25, 0x44, 0x01, 0xd7, 0x26, 0x44, - 0x01, 0xd8, 0x27, 0x44, 0x01, 0xd9, 0x28, 0x44, 0xc1, 0x00, 0xe1, 0x29, - 0x44, 0x41, 0xd0, 0x14, 0x44, 0x01, 0xd1, 0x15, 0x44, 0x01, 0xd2, 0x16, - 0x44, 0x01, 0xd3, 0x17, 0x44, 0x01, 0xd4, 0x18, 0x44, 0x01, 0xd5, 0x19, - 0x44, 0x01, 0xd6, 0x1a, 0x44, 0x81, 0x0c, 0xd7, 0x1c, 0x44, 0x01, 0xd8, - 0x1d, 0x44, 0x01, 0xd9, 0x1e, 0x44, 0x41, 0xe1, 0x1b, 0x44, 0x41, 0xd0, - 0x09, 0x44, 0x81, 0x24, 0xd1, 0x0b, 0x44, 0x01, 0xd2, 0x0c, 0x44, 0x01, - 0xd3, 0x0d, 0x44, 0x01, 0xd4, 0x0e, 0x44, 0x01, 0xd5, 0x0f, 0x44, 0x01, - 0xd6, 0x10, 0x44, 0x01, 0xd7, 0x11, 0x44, 0x01, 0xd8, 0x12, 0x44, 0x01, - 0xd9, 0x13, 0x44, 0x41, 0xe1, 0x0a, 0x44, 0x41, 0xd1, 0x00, 0x44, 0x01, - 0xd2, 0x01, 0x44, 0x01, 0xd3, 0x02, 0x44, 0x01, 0xd4, 0x03, 0x44, 0x01, - 0xd5, 0x04, 0x44, 0x01, 0xd6, 0x05, 0x44, 0x01, 0xd7, 0x06, 0x44, 0x01, - 0xd8, 0x07, 0x44, 0x01, 0xd9, 0x08, 0x44, 0x41, 0x57, 0x1a, 0x2d, 0x3f, - 0x2a, 0x00, 0x47, 0xd8, 0xcf, 0x91, 0xf6, 0x01, 0x4f, 0xbe, 0x6c, 0xc8, - 0xf3, 0x01, 0xb0, 0x01, 0xff, 0x46, 0x30, 0x3e, 0x26, 0x00, 0x00, 0xa8, - 0x01, 0xff, 0x46, 0x54, 0xdd, 0xcf, 0xce, 0x01, 0x43, 0x4e, 0x03, 0xfa, - 0xf3, 0x41, 0x04, 0xfe, 0x05, 0xf9, 0x07, 0x14, 0x1f, 0x41, 0xae, 0x01, - 0xa5, 0x99, 0x01, 0x04, 0x95, 0xf0, 0x3e, 0x02, 0x14, 0x00, 0x2e, 0xed, - 0x1c, 0x06, 0x80, 0x11, 0x06, 0xf3, 0x11, 0x01, 0xff, 0x5a, 0x00, 0x20, - 0xd5, 0x26, 0x00, 0x4e, 0x12, 0x79, 0x87, 0x23, 0x40, 0x0a, 0xb4, 0x6a, - 0x01, 0xff, 0x4b, 0x0e, 0x29, 0x4a, 0x22, 0x00, 0x42, 0x1e, 0x00, 0x48, - 0x22, 0xc0, 0x00, 0x57, 0xc9, 0x04, 0x6f, 0x2a, 0x40, 0x4e, 0x10, 0x76, - 0x2e, 0x23, 0x00, 0x48, 0xf8, 0x0c, 0x4c, 0x22, 0x40, 0x0e, 0x8e, 0x76, - 0x47, 0x47, 0x74, 0xd3, 0x7e, 0xf4, 0x81, 0x24, 0xb3, 0x01, 0xff, 0x06, - 0x46, 0xdf, 0x11, 0x05, 0x88, 0x18, 0x01, 0xff, 0x50, 0x7d, 0x61, 0x4f, - 0xcc, 0x01, 0x4e, 0x7e, 0x7a, 0x4e, 0xcc, 0x41, 0x49, 0xa1, 0xb7, 0x52, - 0xcc, 0x01, 0x46, 0x7c, 0x2f, 0x53, 0xcc, 0x41, 0x80, 0x01, 0xff, 0x4b, - 0x4a, 0x9a, 0x4d, 0xcc, 0x01, 0x49, 0x89, 0xbd, 0x4c, 0xcc, 0x01, 0x05, - 0x34, 0xeb, 0x01, 0xff, 0xd1, 0x54, 0xcc, 0x01, 0xd2, 0x55, 0xcc, 0x41, - 0x44, 0xc3, 0x00, 0x51, 0xcc, 0x01, 0x45, 0xc8, 0x00, 0x50, 0xcc, 0x41, - 0x48, 0x95, 0x98, 0x35, 0x21, 0x00, 0x44, 0x0d, 0xe6, 0x97, 0x26, 0x00, - 0x42, 0x34, 0x00, 0x07, 0x00, 0x40, 0xa1, 0xde, 0x05, 0xa2, 0xa7, 0x05, - 0xa3, 0xc6, 0x04, 0xa4, 0xa5, 0x04, 0x45, 0x59, 0x72, 0x03, 0xf7, 0x01, - 0x44, 0x58, 0x91, 0x02, 0xf7, 0x01, 0xa7, 0x8a, 0x04, 0xa8, 0xe8, 0x03, - 0x04, 0x3d, 0x20, 0xd0, 0x03, 0xac, 0xc1, 0x03, 0xad, 0xa0, 0x03, 0x02, - 0x51, 0x03, 0x8f, 0x03, 0x43, 0x49, 0xe2, 0x46, 0xf7, 0x01, 0xb0, 0xd6, - 0x02, 0x03, 0xd6, 0x01, 0xc5, 0x02, 0xb2, 0xf3, 0x01, 0xb3, 0x70, 0xb4, - 0x45, 0x45, 0x0b, 0xec, 0x55, 0xf7, 0x01, 0xb6, 0x0f, 0x02, 0xa9, 0x01, - 0x01, 0xff, 0x43, 0x8b, 0x00, 0x04, 0xf7, 0x01, 0xf8, 0x4a, 0xf7, 0x41, - 0x48, 0xe1, 0xc5, 0x28, 0xf7, 0x01, 0xa9, 0x01, 0xff, 0x45, 0x1d, 0xe9, - 0x0a, 0xf7, 0x81, 0x0d, 0x45, 0x9d, 0xeb, 0x16, 0xf7, 0xc1, 0x00, 0x42, - 0xab, 0xf3, 0x17, 0xf7, 0x41, 0x4c, 0x5c, 0x8b, 0x2f, 0xf7, 0x01, 0x8d, - 0x01, 0xff, 0xd2, 0x0b, 0xf7, 0x01, 0xd3, 0x0c, 0xf7, 0x41, 0x45, 0x8b, - 0xe4, 0x3f, 0xf7, 0x81, 0x1c, 0x02, 0x9e, 0x01, 0x0c, 0x46, 0xe6, 0x80, - 0x51, 0xf7, 0x01, 0x44, 0x15, 0xf3, 0x4d, 0xf7, 0x41, 0x44, 0x83, 0x98, - 0x29, 0xf7, 0x01, 0x45, 0x1b, 0x8b, 0x48, 0xf7, 0x41, 0x42, 0xab, 0xf3, - 0x40, 0xf7, 0x41, 0x02, 0x13, 0x00, 0x61, 0x4e, 0x64, 0x76, 0x4f, 0xf7, - 0x01, 0x45, 0x7e, 0xe7, 0x1b, 0xf7, 0x01, 0x43, 0xda, 0xd3, 0x54, 0xf7, - 0x01, 0x45, 0x79, 0xbf, 0x47, 0xf7, 0x01, 0xb4, 0x34, 0xb5, 0x01, 0xff, - 0x06, 0x06, 0x63, 0x06, 0x44, 0x4e, 0x52, 0x0d, 0xf7, 0x41, 0x05, 0x2b, - 0x43, 0x06, 0x43, 0xb5, 0x00, 0x5e, 0xf7, 0x41, 0x48, 0x60, 0x8b, 0x2c, - 0xf7, 0x01, 0x46, 0xd8, 0x50, 0x22, 0xf7, 0x01, 0x08, 0xb9, 0xca, 0x01, - 0xff, 0x48, 0x60, 0x8b, 0x2e, 0xf7, 0x01, 0x46, 0xd8, 0x50, 0x27, 0xf7, - 0x41, 0x4d, 0xdf, 0x80, 0x52, 0xf7, 0x01, 0x53, 0x7d, 0x4c, 0x5c, 0xf7, - 0xc1, 0x00, 0x42, 0xab, 0xf3, 0x5d, 0xf7, 0x41, 0x49, 0x2b, 0xb5, 0x39, - 0xf7, 0x01, 0xf4, 0x14, 0xf7, 0xc1, 0x00, 0x04, 0xf3, 0x01, 0x01, 0xff, - 0x48, 0x60, 0x8b, 0x2d, 0xf7, 0x01, 0x52, 0xd8, 0x50, 0x26, 0xf7, 0x41, - 0xa5, 0x0d, 0x48, 0x21, 0xc9, 0x18, 0xf7, 0xc1, 0x00, 0x42, 0xab, 0xf3, - 0x19, 0xf7, 0x41, 0x45, 0x4a, 0xe4, 0x3b, 0xf7, 0x81, 0x33, 0x45, 0xd9, - 0xe6, 0x32, 0xf7, 0x81, 0x06, 0x44, 0x54, 0x09, 0x6d, 0xf7, 0x41, 0x04, - 0xf3, 0x01, 0x0f, 0x8d, 0x01, 0xff, 0xd2, 0x33, 0xf7, 0x01, 0xd3, 0x34, - 0xf7, 0x01, 0xd4, 0x35, 0xf7, 0x41, 0x48, 0x60, 0x8b, 0x30, 0xf7, 0x81, - 0x06, 0x44, 0x3d, 0x20, 0x1f, 0xf7, 0x41, 0x42, 0xab, 0xf3, 0x31, 0xf7, - 0x41, 0x42, 0xab, 0xf3, 0x3c, 0xf7, 0x41, 0x47, 0x09, 0xd0, 0x41, 0xf7, - 0x01, 0x49, 0xcc, 0xbc, 0x00, 0xf7, 0x41, 0x52, 0x40, 0x52, 0x0e, 0xf7, - 0x01, 0xaf, 0x15, 0x4a, 0x26, 0xb0, 0x5f, 0xf7, 0x01, 0xb5, 0x01, 0xff, - 0x44, 0x71, 0xf2, 0x63, 0xf7, 0x01, 0x4a, 0x38, 0xb2, 0x64, 0xf7, 0x41, - 0x47, 0x37, 0xd6, 0x58, 0xf7, 0x01, 0x44, 0x4d, 0xf3, 0x4b, 0xf7, 0xc1, - 0x00, 0x48, 0x99, 0xc5, 0x5a, 0xf7, 0x41, 0x43, 0xca, 0x00, 0x6f, 0xf7, - 0x01, 0x43, 0x76, 0x02, 0x15, 0xf7, 0x41, 0x48, 0x99, 0xc3, 0x38, 0xf7, - 0x01, 0x50, 0xfd, 0x62, 0x10, 0xf7, 0x81, 0x06, 0x44, 0x6a, 0xa2, 0x71, - 0xf7, 0x41, 0x8d, 0x01, 0xff, 0xd2, 0x11, 0xf7, 0x01, 0xd3, 0x12, 0xf7, - 0x41, 0x47, 0xb1, 0xd0, 0x2a, 0xf7, 0x01, 0x48, 0x31, 0xc9, 0x53, 0xf7, - 0x41, 0x44, 0x83, 0x98, 0x1c, 0xf7, 0x81, 0x06, 0x4b, 0x7c, 0x98, 0x21, - 0xf7, 0x41, 0x42, 0xab, 0xf3, 0x1d, 0xf7, 0x41, 0x04, 0x23, 0x00, 0x0f, - 0xaf, 0x01, 0xff, 0x48, 0xa9, 0xca, 0x56, 0xf7, 0x01, 0x42, 0x42, 0x00, - 0x6e, 0xf7, 0x41, 0x44, 0x04, 0xb8, 0x72, 0xf7, 0x01, 0x45, 0xd6, 0xe9, - 0x73, 0xf7, 0x41, 0x43, 0xfd, 0x1a, 0x1a, 0xf7, 0x01, 0x42, 0x48, 0x04, - 0x49, 0xf7, 0x41, 0x48, 0xf9, 0xc3, 0x70, 0xf7, 0x01, 0x02, 0x5f, 0x03, - 0x01, 0xff, 0x45, 0x25, 0xeb, 0x61, 0xf7, 0x81, 0x06, 0x44, 0x19, 0x35, - 0x60, 0xf7, 0x41, 0x42, 0xab, 0xf3, 0x62, 0xf7, 0x41, 0xa1, 0x4a, 0x47, - 0x1d, 0xd2, 0x13, 0xf7, 0x01, 0x06, 0xd9, 0x50, 0x34, 0xb2, 0x01, 0xff, - 0x08, 0x29, 0xc9, 0x1a, 0x46, 0xfc, 0xe0, 0x65, 0xf7, 0xc1, 0x00, 0x8d, - 0x01, 0xff, 0xd2, 0x66, 0xf7, 0x01, 0xd3, 0x67, 0xf7, 0x01, 0xd4, 0x68, - 0xf7, 0x01, 0xd5, 0x69, 0xf7, 0x41, 0x46, 0xd8, 0x50, 0x23, 0xf7, 0x81, - 0x06, 0x44, 0x3d, 0x20, 0x1e, 0xf7, 0x41, 0x42, 0xab, 0xf3, 0x24, 0xf7, - 0x41, 0x4b, 0xdf, 0x50, 0x25, 0xf7, 0x01, 0x43, 0xae, 0x0f, 0x20, 0xf7, - 0x41, 0x46, 0x26, 0xdb, 0x50, 0xf7, 0x01, 0x42, 0x41, 0xf5, 0x4c, 0xf7, - 0x01, 0x4b, 0x98, 0xa1, 0x4e, 0xf7, 0x41, 0x07, 0x45, 0xcf, 0x24, 0x4a, - 0x2a, 0xac, 0x3e, 0xf7, 0x01, 0x4b, 0x54, 0x9e, 0x0f, 0xf7, 0x01, 0x44, - 0x09, 0xf2, 0x42, 0xf7, 0x81, 0x06, 0x44, 0x48, 0x21, 0x59, 0xf7, 0x41, - 0x8d, 0x01, 0xff, 0xd2, 0x43, 0xf7, 0x01, 0xd3, 0x44, 0xf7, 0x41, 0x44, - 0x45, 0xf1, 0x6b, 0xf7, 0x01, 0x47, 0x41, 0xd7, 0x6c, 0xf7, 0x41, 0x42, - 0x46, 0x00, 0x01, 0xf7, 0x01, 0xac, 0x44, 0x46, 0x19, 0x2d, 0x5b, 0xf7, - 0x01, 0x4b, 0x59, 0xa0, 0x2b, 0xf7, 0x01, 0x03, 0x7c, 0x00, 0x12, 0x46, - 0xca, 0xdf, 0x3a, 0xf7, 0x01, 0x44, 0x30, 0x7c, 0x57, 0xf7, 0x01, 0x4a, - 0x28, 0xb3, 0x3d, 0xf7, 0x41, 0x80, 0x06, 0x46, 0xf2, 0xdb, 0x05, 0xf7, - 0x41, 0x45, 0x62, 0xea, 0x06, 0xf7, 0x81, 0x0d, 0x45, 0x42, 0xec, 0x08, - 0xf7, 0xc1, 0x00, 0x42, 0xab, 0xf3, 0x09, 0xf7, 0x41, 0x42, 0xab, 0xf3, - 0x07, 0xf7, 0x41, 0x45, 0x0c, 0xe6, 0x6a, 0xf7, 0x01, 0x44, 0xe9, 0xf0, - 0x36, 0xf7, 0x81, 0x06, 0x42, 0x48, 0x04, 0x45, 0xf7, 0x41, 0x42, 0xab, - 0xf3, 0x37, 0xf7, 0x41, 0x4b, 0xa5, 0x99, 0xfa, 0xfb, 0x01, 0x45, 0x38, - 0x0b, 0xf0, 0x23, 0x40, 0x80, 0x01, 0xff, 0x48, 0xa9, 0xc3, 0xec, 0xf6, - 0x01, 0x49, 0xce, 0xb7, 0xeb, 0xf6, 0x41, 0x16, 0x58, 0x33, 0x8c, 0x03, - 0x06, 0xef, 0x06, 0xc5, 0x02, 0x07, 0xec, 0x05, 0x6b, 0x08, 0xaa, 0xae, - 0x5b, 0xb3, 0x34, 0x0b, 0x55, 0x77, 0x01, 0xff, 0xe1, 0x20, 0x17, 0x81, - 0x1a, 0xe5, 0x26, 0x17, 0x01, 0xe9, 0x22, 0x17, 0x81, 0x0d, 0xef, 0x28, - 0x17, 0x01, 0xf5, 0x24, 0x17, 0xc1, 0x00, 0xf5, 0x25, 0x17, 0x41, 0xe9, - 0x23, 0x17, 0x41, 0xe1, 0x21, 0x17, 0x01, 0xe9, 0x29, 0x17, 0x01, 0xed, - 0x2a, 0x17, 0x01, 0xf7, 0x27, 0x17, 0x41, 0x04, 0x5b, 0x03, 0x06, 0x48, - 0x25, 0xa3, 0x3f, 0x17, 0x41, 0x46, 0x84, 0xdd, 0x2b, 0x17, 0x01, 0x45, - 0xb7, 0xea, 0x3e, 0x17, 0x01, 0xb3, 0x01, 0xff, 0x46, 0xaf, 0x0a, 0x3d, - 0x17, 0x01, 0x4c, 0xd4, 0x91, 0x3c, 0x17, 0x41, 0x42, 0x92, 0x01, 0x3a, - 0x17, 0x01, 0x45, 0x9a, 0x2c, 0x3b, 0x17, 0x41, 0xe1, 0x12, 0x17, 0x81, - 0xb9, 0x01, 0xa2, 0xac, 0x01, 0xa3, 0x9f, 0x01, 0xa4, 0x86, 0x01, 0xa7, - 0x7a, 0x42, 0x22, 0x00, 0x11, 0x17, 0x01, 0xaa, 0x68, 0xab, 0x5c, 0xac, - 0x50, 0x42, 0x6c, 0x00, 0x09, 0x17, 0x01, 0xae, 0x32, 0xb0, 0x26, 0x42, - 0x71, 0x00, 0x0d, 0x17, 0x01, 0x42, 0x40, 0x06, 0x0f, 0x17, 0x01, 0xb4, - 0x01, 0xff, 0xe1, 0x04, 0x17, 0x01, 0x42, 0x22, 0x00, 0x0c, 0x17, 0x01, - 0xb4, 0x01, 0xff, 0xe1, 0x41, 0x17, 0x01, 0x42, 0x22, 0x00, 0x42, 0x17, - 0x41, 0xe1, 0x06, 0x17, 0x01, 0x42, 0x22, 0x00, 0x07, 0x17, 0x41, 0xe1, - 0x03, 0x17, 0x01, 0x42, 0x24, 0x02, 0x02, 0x17, 0x01, 0x42, 0x2a, 0x05, - 0x45, 0x17, 0x01, 0x42, 0xbe, 0x22, 0x10, 0x17, 0x41, 0xe1, 0x0e, 0x17, - 0x01, 0x42, 0x74, 0x00, 0x46, 0x17, 0x41, 0xe1, 0x00, 0x17, 0x01, 0x42, - 0x22, 0x00, 0x01, 0x17, 0x41, 0xe1, 0x0a, 0x17, 0x01, 0x42, 0x22, 0x00, - 0x19, 0x17, 0x41, 0xe1, 0x15, 0x17, 0x01, 0x42, 0x22, 0x00, 0x17, 0x17, - 0x41, 0xe1, 0x13, 0x17, 0x01, 0xa4, 0x06, 0x42, 0x22, 0x00, 0x14, 0x17, - 0x41, 0xe1, 0x43, 0x17, 0x01, 0x42, 0x22, 0x00, 0x44, 0x17, 0x41, 0xe1, - 0x40, 0x17, 0x01, 0x42, 0x22, 0x00, 0x0b, 0x17, 0x41, 0xe1, 0x08, 0x17, - 0x01, 0x42, 0x22, 0x00, 0x18, 0x17, 0x41, 0x09, 0xf2, 0x11, 0x01, 0xff, - 0x42, 0x16, 0x00, 0x1a, 0x17, 0x01, 0x42, 0x24, 0x02, 0x16, 0x17, 0x01, - 0x42, 0x12, 0x00, 0x05, 0x17, 0x41, 0x45, 0x12, 0x0b, 0x38, 0x17, 0x01, - 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x39, 0x17, 0x01, 0x43, 0x0e, 0x0b, 0x31, - 0x17, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x5f, 0x1e, 0x30, 0x17, 0x41, - 0x44, 0x25, 0x01, 0x33, 0x17, 0x01, 0x42, 0x15, 0x02, 0x32, 0x17, 0x41, - 0x44, 0xe5, 0x1d, 0x37, 0x17, 0x01, 0x42, 0x1c, 0x26, 0x36, 0x17, 0x41, - 0x43, 0xd2, 0x05, 0x35, 0x17, 0x01, 0x43, 0xf6, 0x06, 0x34, 0x17, 0x41, - 0xac, 0x06, 0x42, 0x71, 0x00, 0x1e, 0x17, 0x41, 0xe1, 0x1d, 0x17, 0x01, - 0x4a, 0xb2, 0xab, 0x1f, 0x17, 0x41, 0x05, 0xbb, 0xe6, 0x06, 0x4c, 0x98, - 0x94, 0xa1, 0xf6, 0x41, 0x4a, 0xc4, 0xa8, 0x02, 0x01, 0x01, 0x59, 0xeb, - 0x23, 0x3c, 0x01, 0x01, 0x5c, 0x86, 0x18, 0x3d, 0x01, 0x01, 0x08, 0x8d, - 0x18, 0x84, 0x03, 0x07, 0x1a, 0x3a, 0x38, 0xb7, 0x01, 0xff, 0x06, 0x31, - 0x14, 0x11, 0x0e, 0xa8, 0x7a, 0x01, 0xff, 0x43, 0x23, 0x0a, 0x01, 0x01, - 0x01, 0x44, 0xed, 0x07, 0x00, 0x01, 0x41, 0x49, 0xa5, 0xb6, 0x37, 0x01, - 0x01, 0xa6, 0x0c, 0x4e, 0xf8, 0x7b, 0x39, 0x01, 0x01, 0x4d, 0x4d, 0x89, - 0x3a, 0x01, 0x41, 0x4c, 0x96, 0x18, 0x38, 0x01, 0x01, 0x4d, 0x52, 0x87, - 0x3b, 0x01, 0x41, 0x45, 0x12, 0x0b, 0x0e, 0x01, 0x81, 0xa7, 0x02, 0xa6, - 0xd9, 0x01, 0x44, 0xea, 0x2a, 0x0f, 0x01, 0x81, 0xb6, 0x01, 0x43, 0x0e, - 0x0b, 0x07, 0x01, 0x81, 0x9f, 0x01, 0xb3, 0x59, 0xb4, 0x01, 0xff, 0x42, - 0x92, 0x01, 0x10, 0x01, 0x81, 0x49, 0xa8, 0x24, 0xb7, 0x01, 0xff, 0x44, - 0xe7, 0x1d, 0x11, 0x01, 0x81, 0x14, 0xef, 0x08, 0x01, 0xc1, 0x00, 0x80, - 0x01, 0xff, 0x47, 0x71, 0x11, 0x1a, 0x01, 0x01, 0x48, 0x47, 0x5e, 0x23, - 0x01, 0x41, 0x49, 0x46, 0x5e, 0x2c, 0x01, 0x41, 0x44, 0x7b, 0x11, 0x12, - 0x01, 0x81, 0x16, 0x43, 0x26, 0x01, 0x09, 0x01, 0xc1, 0x00, 0x80, 0x01, - 0xff, 0x47, 0x71, 0x11, 0x1b, 0x01, 0x01, 0x48, 0x47, 0x5e, 0x24, 0x01, - 0x41, 0x49, 0x46, 0x5e, 0x2d, 0x01, 0x41, 0x49, 0x46, 0x5e, 0x2b, 0x01, - 0x41, 0x44, 0xe5, 0x1d, 0x0d, 0x01, 0x81, 0x22, 0x42, 0x1c, 0x26, 0x0c, - 0x01, 0xc1, 0x00, 0x80, 0x0d, 0x42, 0x7d, 0x11, 0x15, 0x01, 0xc1, 0x00, - 0x49, 0x46, 0x5e, 0x30, 0x01, 0x41, 0x47, 0x71, 0x11, 0x1e, 0x01, 0x01, - 0x48, 0x47, 0x5e, 0x27, 0x01, 0x41, 0x80, 0x0d, 0x42, 0x7d, 0x11, 0x16, - 0x01, 0xc1, 0x00, 0x49, 0x46, 0x5e, 0x31, 0x01, 0x41, 0x47, 0x71, 0x11, - 0x1f, 0x01, 0x01, 0x48, 0x47, 0x5e, 0x28, 0x01, 0x41, 0x80, 0x01, 0xff, - 0x47, 0x71, 0x11, 0x19, 0x01, 0x01, 0x48, 0x47, 0x5e, 0x22, 0x01, 0x41, - 0x80, 0x0d, 0x42, 0x7d, 0x11, 0x18, 0x01, 0xc1, 0x00, 0x49, 0x46, 0x5e, - 0x33, 0x01, 0x41, 0x47, 0x71, 0x11, 0x21, 0x01, 0x01, 0x48, 0x47, 0x5e, - 0x2a, 0x01, 0x41, 0xa9, 0x26, 0xaf, 0x01, 0xff, 0x43, 0x7c, 0x11, 0x13, - 0x01, 0x81, 0x16, 0x42, 0x42, 0x00, 0x0a, 0x01, 0xc1, 0x00, 0x80, 0x01, - 0xff, 0x47, 0x71, 0x11, 0x1c, 0x01, 0x01, 0x48, 0x47, 0x5e, 0x25, 0x01, - 0x41, 0x49, 0x46, 0x5e, 0x2e, 0x01, 0x41, 0x43, 0x59, 0x4d, 0x14, 0x01, - 0x81, 0x16, 0x42, 0x32, 0x00, 0x0b, 0x01, 0xc1, 0x00, 0x80, 0x01, 0xff, - 0x47, 0x71, 0x11, 0x1d, 0x01, 0x01, 0x48, 0x47, 0x5e, 0x26, 0x01, 0x41, - 0x49, 0x46, 0x5e, 0x2f, 0x01, 0x41, 0x80, 0x0b, 0xf9, 0x17, 0x01, 0xc1, - 0x00, 0x49, 0x46, 0x5e, 0x32, 0x01, 0x41, 0x47, 0x71, 0x11, 0x20, 0x01, - 0x01, 0x48, 0x47, 0x5e, 0x29, 0x01, 0x41, 0x4e, 0xf8, 0x7b, 0x3e, 0x01, - 0x01, 0x4d, 0x4d, 0x89, 0x3f, 0x01, 0x41, 0x56, 0x08, 0x34, 0x01, 0x21, - 0x00, 0x4e, 0x4e, 0x78, 0x79, 0xfa, 0x01, 0x48, 0xf9, 0xc6, 0x2c, 0x26, - 0x00, 0x04, 0x4c, 0x14, 0x14, 0xad, 0x06, 0x43, 0xb7, 0x04, 0xd1, 0xf9, - 0x41, 0x44, 0x26, 0x85, 0xe5, 0x2b, 0x00, 0x4e, 0xf6, 0x78, 0x9f, 0xf3, - 0x41, 0x4f, 0xa2, 0x6a, 0x44, 0xe9, 0x01, 0xa3, 0xd7, 0x02, 0x06, 0xef, - 0x06, 0x90, 0x02, 0x07, 0x90, 0x6d, 0xff, 0x01, 0x45, 0x56, 0x00, 0x47, - 0xe9, 0x01, 0x08, 0xb8, 0x16, 0xe8, 0x01, 0xae, 0xd9, 0x01, 0x0d, 0x76, - 0x08, 0x06, 0x50, 0x8d, 0x68, 0x45, 0xe9, 0x41, 0x44, 0xa2, 0x6a, 0x22, - 0xe9, 0x01, 0xa2, 0xbc, 0x01, 0x43, 0x79, 0x16, 0x37, 0xe9, 0x01, 0xa4, - 0xa7, 0x01, 0xe5, 0x2b, 0xe9, 0x01, 0x42, 0x0c, 0x08, 0x2c, 0xe9, 0x01, - 0xa7, 0x90, 0x01, 0x42, 0x22, 0x00, 0x38, 0xe9, 0x01, 0xe9, 0x2d, 0xe9, - 0x01, 0x44, 0xd1, 0xf0, 0x36, 0xe9, 0x01, 0xab, 0x6c, 0x44, 0x7d, 0x89, - 0x24, 0xe9, 0x01, 0x44, 0x51, 0xf1, 0x25, 0xe9, 0x01, 0xae, 0x4c, 0xef, - 0x2e, 0xe9, 0x01, 0x42, 0x6f, 0x02, 0x28, 0xe9, 0x01, 0x44, 0x3a, 0xea, - 0x39, 0xe9, 0x01, 0x42, 0x71, 0x00, 0x2a, 0xe9, 0x01, 0xb3, 0x28, 0x42, - 0x5c, 0x01, 0x3c, 0xe9, 0x01, 0xf5, 0x35, 0xe9, 0x01, 0x42, 0xf5, 0x0a, - 0x3e, 0xe9, 0x01, 0x43, 0x9f, 0x8a, 0x31, 0xe9, 0x01, 0xb9, 0x06, 0x43, - 0xe5, 0xc1, 0x41, 0xe9, 0x41, 0xe1, 0x34, 0xe9, 0x01, 0x42, 0xb0, 0x01, - 0x30, 0xe9, 0x41, 0x42, 0x22, 0x00, 0x43, 0xe9, 0x01, 0x49, 0xcb, 0xba, - 0x27, 0xe9, 0x41, 0x42, 0x22, 0x00, 0x3d, 0xe9, 0x01, 0x42, 0x42, 0x0b, - 0x32, 0xe9, 0x01, 0x42, 0xbe, 0x22, 0x3b, 0xe9, 0x41, 0x42, 0x44, 0x14, - 0x33, 0xe9, 0x01, 0x42, 0x22, 0x00, 0x3f, 0xe9, 0x01, 0x42, 0x9c, 0x01, - 0x42, 0xe9, 0x41, 0xe1, 0x3a, 0xe9, 0x01, 0x42, 0xb7, 0x05, 0x40, 0xe9, - 0x41, 0x44, 0xf2, 0x2c, 0x23, 0xe9, 0x01, 0x42, 0x22, 0x00, 0x2f, 0xe9, - 0x41, 0xe1, 0x26, 0xe9, 0x01, 0x42, 0xb0, 0x01, 0x29, 0xe9, 0x41, 0x50, - 0x68, 0x5c, 0x4b, 0xe9, 0x01, 0x44, 0x5b, 0x3f, 0x4a, 0xe9, 0x41, 0x50, - 0xad, 0x00, 0x5e, 0xe9, 0x01, 0x4d, 0xc1, 0x34, 0x5f, 0xe9, 0x41, 0x54, - 0xe7, 0x41, 0x49, 0xe9, 0x01, 0x48, 0xb5, 0x00, 0x46, 0xe9, 0x41, 0x45, - 0x12, 0x0b, 0x58, 0xe9, 0x01, 0xa6, 0x2e, 0x44, 0xea, 0x2a, 0x59, 0xe9, - 0x01, 0x43, 0x0e, 0x0b, 0x51, 0xe9, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, - 0x5f, 0x1e, 0x50, 0xe9, 0x41, 0x44, 0x25, 0x01, 0x53, 0xe9, 0x01, 0x42, - 0x15, 0x02, 0x52, 0xe9, 0x41, 0x44, 0xe5, 0x1d, 0x57, 0xe9, 0x01, 0x42, - 0x1c, 0x26, 0x56, 0xe9, 0x41, 0x43, 0xd2, 0x05, 0x55, 0xe9, 0x01, 0x43, - 0xf6, 0x06, 0x54, 0xe9, 0x41, 0x0e, 0xe5, 0x05, 0x06, 0x51, 0x43, 0x33, - 0x48, 0xe9, 0x41, 0x44, 0xa2, 0x6a, 0x00, 0xe9, 0x01, 0xa2, 0xbc, 0x01, - 0x43, 0x79, 0x16, 0x15, 0xe9, 0x01, 0xa4, 0xa7, 0x01, 0xe5, 0x09, 0xe9, - 0x01, 0x42, 0x0c, 0x08, 0x0a, 0xe9, 0x01, 0xa7, 0x90, 0x01, 0x42, 0x22, - 0x00, 0x16, 0xe9, 0x01, 0xe9, 0x0b, 0xe9, 0x01, 0x44, 0xd1, 0xf0, 0x14, - 0xe9, 0x01, 0xab, 0x6c, 0x44, 0x7d, 0x89, 0x02, 0xe9, 0x01, 0x44, 0x51, - 0xf1, 0x03, 0xe9, 0x01, 0xae, 0x4c, 0xef, 0x0c, 0xe9, 0x01, 0x42, 0x6f, - 0x02, 0x06, 0xe9, 0x01, 0x44, 0x3a, 0xea, 0x17, 0xe9, 0x01, 0x42, 0x71, - 0x00, 0x08, 0xe9, 0x01, 0xb3, 0x28, 0x42, 0x5c, 0x01, 0x1a, 0xe9, 0x01, - 0xf5, 0x13, 0xe9, 0x01, 0x42, 0xf5, 0x0a, 0x1c, 0xe9, 0x01, 0x43, 0x9f, - 0x8a, 0x0f, 0xe9, 0x01, 0xb9, 0x06, 0x43, 0xe5, 0xc1, 0x1f, 0xe9, 0x41, - 0xe1, 0x12, 0xe9, 0x01, 0x42, 0xb0, 0x01, 0x0e, 0xe9, 0x41, 0x42, 0x22, - 0x00, 0x21, 0xe9, 0x01, 0x49, 0xcb, 0xba, 0x05, 0xe9, 0x41, 0x42, 0x22, - 0x00, 0x1b, 0xe9, 0x01, 0x42, 0x42, 0x0b, 0x10, 0xe9, 0x01, 0x42, 0xbe, - 0x22, 0x19, 0xe9, 0x41, 0x42, 0x44, 0x14, 0x11, 0xe9, 0x01, 0x42, 0x22, - 0x00, 0x1d, 0xe9, 0x01, 0x42, 0x9c, 0x01, 0x20, 0xe9, 0x41, 0xe1, 0x18, - 0xe9, 0x01, 0x42, 0xb7, 0x05, 0x1e, 0xe9, 0x41, 0x44, 0xf2, 0x2c, 0x01, - 0xe9, 0x01, 0x42, 0x22, 0x00, 0x0d, 0xe9, 0x41, 0xe1, 0x04, 0xe9, 0x01, - 0x42, 0xb0, 0x01, 0x07, 0xe9, 0x41, 0x48, 0x2d, 0x2e, 0xe6, 0x23, 0x00, - 0x02, 0x13, 0x05, 0x2c, 0xeb, 0x06, 0x00, 0x80, 0x21, 0x07, 0x8b, 0xd6, - 0x11, 0x05, 0x16, 0x39, 0x01, 0xff, 0x45, 0xdb, 0x04, 0xb4, 0x00, 0x00, - 0x44, 0x05, 0x02, 0x9f, 0x29, 0x40, 0x53, 0x2f, 0x48, 0x6d, 0x20, 0x00, - 0x52, 0xa0, 0x55, 0x6b, 0x20, 0x40, 0x48, 0xf0, 0x51, 0x06, 0x00, 0x40, - 0x45, 0x5d, 0xea, 0x97, 0xfa, 0x01, 0x46, 0xd2, 0x6a, 0x00, 0x21, 0x40 }; + 0x1a, 0x71, 0x7b, 0xfe, 0x00, 0x4e, 0x96, 0x82, 0xf6, 0x08, 0x40, 0x53, + 0x57, 0x4d, 0x9f, 0x08, 0x00, 0x04, 0x58, 0x00, 0x01, 0xff, 0x45, 0x5c, + 0x00, 0x54, 0x06, 0x00, 0x45, 0x20, 0x07, 0x55, 0x06, 0x40, 0x44, 0x23, + 0x10, 0x4e, 0x06, 0x80, 0x1a, 0xa9, 0x0c, 0x4e, 0x28, 0x7e, 0x02, 0x06, + 0x00, 0x48, 0x50, 0x17, 0xd4, 0x06, 0x40, 0x51, 0x6a, 0x5e, 0xf2, 0x0e, + 0x01, 0x4f, 0xb5, 0x77, 0x6d, 0x06, 0x40, 0x80, 0x0d, 0x43, 0x65, 0x0b, + 0x4b, 0x06, 0xc0, 0x00, 0x4e, 0x5e, 0x03, 0x70, 0xfe, 0x40, 0x4d, 0x5f, + 0x03, 0x76, 0xfe, 0x00, 0x4b, 0x1a, 0x71, 0x77, 0xfe, 0x00, 0x05, 0x51, + 0x00, 0x01, 0xff, 0x49, 0x77, 0x1f, 0xf5, 0x08, 0x00, 0x44, 0x22, 0x08, + 0xf4, 0x08, 0x00, 0x48, 0x44, 0x0a, 0x5e, 0x06, 0x40, 0x0c, 0x04, 0x97, + 0x11, 0x06, 0x41, 0x05, 0x01, 0xff, 0x44, 0xf4, 0x4c, 0xdd, 0x06, 0x00, + 0x49, 0xa1, 0x65, 0x1d, 0x06, 0x40, 0x49, 0xb4, 0x0b, 0xeb, 0x06, 0x00, + 0x48, 0x9f, 0xcd, 0xea, 0x06, 0x40, 0xa1, 0x2c, 0x50, 0x6a, 0x65, 0x6b, + 0x06, 0x00, 0x53, 0xe5, 0x4c, 0xe2, 0x08, 0x00, 0x05, 0x3c, 0x01, 0x01, + 0xff, 0x80, 0x06, 0x47, 0xe7, 0xd5, 0x9e, 0x08, 0x40, 0x55, 0xf3, 0x3f, + 0xfb, 0x08, 0x80, 0x06, 0x52, 0x37, 0x33, 0xfa, 0x0e, 0x41, 0x49, 0x98, + 0x3d, 0xfc, 0x08, 0x40, 0x43, 0x15, 0x05, 0x4f, 0x06, 0x80, 0x06, 0x4c, + 0xa0, 0x9a, 0x0d, 0x06, 0x40, 0x80, 0x0d, 0x43, 0x65, 0x0b, 0x4c, 0x06, + 0xc0, 0x00, 0x4e, 0x5e, 0x03, 0x72, 0xfe, 0x40, 0x4d, 0x5f, 0x03, 0x78, + 0xfe, 0x00, 0x4b, 0x1a, 0x71, 0x79, 0xfe, 0x00, 0x48, 0x99, 0x3d, 0xfe, + 0x08, 0x40, 0x02, 0x14, 0x05, 0xbc, 0x01, 0x0c, 0xd4, 0x99, 0x2c, 0x05, + 0xdf, 0x0b, 0x01, 0xff, 0x45, 0xa0, 0x61, 0xe5, 0x08, 0x80, 0x1a, 0x45, + 0x1a, 0x77, 0xe4, 0x08, 0x80, 0x0d, 0x45, 0x16, 0x53, 0xe6, 0x08, 0xc0, + 0x00, 0x43, 0x65, 0x0b, 0xe9, 0x08, 0x40, 0x43, 0x65, 0x0b, 0xe7, 0x08, + 0x40, 0x43, 0x65, 0x0b, 0xe8, 0x08, 0x40, 0x43, 0x56, 0x07, 0xe6, 0x0e, + 0x01, 0x43, 0x35, 0x85, 0xd9, 0x0e, 0x01, 0x43, 0xec, 0xd5, 0xe3, 0x0e, + 0x01, 0x43, 0x70, 0xbe, 0xe8, 0x0e, 0x01, 0x45, 0x8f, 0xa1, 0xe7, 0x0e, + 0x01, 0xa8, 0x60, 0x44, 0x4c, 0x3a, 0xdd, 0x0e, 0x01, 0xab, 0x4c, 0x44, + 0x3f, 0x22, 0xeb, 0x0e, 0x01, 0x44, 0x30, 0x48, 0xec, 0x0e, 0x01, 0x43, + 0x62, 0xe2, 0xda, 0x0e, 0x01, 0x43, 0x11, 0x15, 0xe9, 0x0e, 0x01, 0xb3, + 0x20, 0xb4, 0x0c, 0x43, 0x4d, 0x00, 0xee, 0x0e, 0x01, 0x43, 0xea, 0x82, + 0xe5, 0x0e, 0x41, 0x42, 0x3d, 0x0a, 0xe4, 0x0e, 0x01, 0x42, 0x4e, 0x00, + 0xdb, 0x0e, 0x01, 0x43, 0x19, 0x45, 0xdc, 0x0e, 0x41, 0x42, 0xe8, 0x01, + 0xe2, 0x0e, 0x01, 0x43, 0xe9, 0x09, 0xe0, 0x0e, 0x01, 0x44, 0x36, 0xe1, + 0xe1, 0x0e, 0x41, 0x42, 0x12, 0x15, 0xea, 0x0e, 0x01, 0x43, 0x49, 0x22, + 0xdf, 0x0e, 0x41, 0x42, 0x3d, 0x0a, 0xde, 0x0e, 0x01, 0x42, 0x4e, 0x00, + 0xed, 0x0e, 0x41, 0x53, 0xd1, 0x4a, 0xfc, 0x0e, 0x01, 0x42, 0x6c, 0x00, + 0x0c, 0x06, 0x40, 0x51, 0xd4, 0x5a, 0x87, 0x08, 0x00, 0x54, 0x2f, 0x45, + 0xd0, 0x0e, 0x41, 0xe3, 0x9f, 0x00, 0x00, 0x14, 0x0b, 0x46, 0x4d, 0xaf, + 0x3f, 0xb0, 0x01, 0xff, 0xac, 0x2e, 0x02, 0xd0, 0x00, 0x01, 0xff, 0x4f, + 0x83, 0x6d, 0x50, 0x22, 0x00, 0x09, 0x70, 0x0d, 0x01, 0xff, 0x59, 0xa8, + 0x24, 0x46, 0x22, 0x00, 0x06, 0x7b, 0x00, 0x01, 0xff, 0x4b, 0x91, 0x2a, + 0x70, 0x2a, 0x00, 0x42, 0x1e, 0x00, 0x45, 0x22, 0xc0, 0x00, 0x50, 0xfa, + 0x62, 0x52, 0x22, 0x40, 0x48, 0x64, 0x1a, 0xbd, 0xce, 0x01, 0x57, 0x69, + 0x30, 0x9f, 0x00, 0x40, 0x44, 0xbd, 0x46, 0xe4, 0x2b, 0x00, 0x47, 0x5c, + 0x38, 0x27, 0x00, 0x40, 0x45, 0x3f, 0xea, 0x7a, 0x23, 0x80, 0x81, 0x04, + 0x4d, 0x0e, 0x85, 0x40, 0x23, 0x00, 0xa3, 0xc6, 0x03, 0xa4, 0xea, 0x02, + 0x50, 0xca, 0x65, 0x77, 0x23, 0x00, 0x56, 0xe5, 0x35, 0x69, 0x23, 0x00, + 0xa9, 0xc8, 0x02, 0x04, 0x98, 0xf6, 0xb7, 0x02, 0x04, 0xc3, 0x00, 0xa6, + 0x02, 0x45, 0x37, 0x92, 0x75, 0x23, 0x80, 0x98, 0x02, 0x02, 0x7c, 0x00, + 0x6c, 0xb2, 0x5e, 0xb3, 0x3b, 0x4f, 0xf2, 0x76, 0x68, 0x23, 0x00, 0x02, + 0x50, 0x02, 0x06, 0x45, 0x91, 0xf2, 0x6c, 0x23, 0x40, 0x80, 0x06, 0x4a, + 0xfc, 0x7b, 0x4f, 0x23, 0x40, 0x4b, 0xfb, 0x9e, 0x72, 0x23, 0x00, 0x48, + 0x97, 0xd0, 0x5d, 0x23, 0x00, 0x05, 0x39, 0xde, 0x01, 0xff, 0x49, 0xf3, + 0x24, 0x61, 0x23, 0x00, 0x43, 0x9c, 0xd0, 0x55, 0x23, 0x00, 0x47, 0xc2, + 0x83, 0x51, 0x23, 0x40, 0x51, 0x5b, 0x5c, 0x6e, 0x23, 0x00, 0x48, 0x13, + 0x85, 0x3f, 0x23, 0x00, 0x4a, 0x6e, 0xb5, 0x37, 0x23, 0x00, 0xb4, 0x01, + 0xff, 0x4c, 0x04, 0x91, 0x63, 0x23, 0x00, 0x49, 0xe1, 0xbf, 0x6d, 0x23, + 0x40, 0x42, 0x0b, 0x00, 0x74, 0x23, 0x00, 0x4e, 0xf8, 0x7b, 0x46, 0x23, + 0x40, 0x42, 0xe8, 0x01, 0x95, 0x23, 0x80, 0x11, 0x04, 0x14, 0x57, 0x01, + 0xff, 0x44, 0x07, 0x0e, 0x5e, 0x23, 0x00, 0x48, 0x64, 0x5c, 0x58, 0x23, + 0x40, 0x80, 0x01, 0xff, 0x49, 0xd2, 0x0e, 0x42, 0x23, 0x00, 0xa3, 0x79, + 0xa4, 0x4b, 0x45, 0x7b, 0x00, 0x38, 0x23, 0x00, 0x4c, 0x87, 0x00, 0x44, + 0x23, 0x00, 0x43, 0x9c, 0xd0, 0x3b, 0x23, 0x00, 0x02, 0x68, 0x00, 0x29, + 0x49, 0xa0, 0x2c, 0x6f, 0x23, 0x00, 0x48, 0x88, 0x36, 0x70, 0x23, 0x00, + 0x50, 0xb3, 0x02, 0x48, 0x23, 0x00, 0x45, 0xd6, 0x0e, 0x41, 0x23, 0x00, + 0x02, 0x50, 0x02, 0x01, 0xff, 0x46, 0x40, 0x81, 0x53, 0x23, 0x00, 0x4b, + 0xb8, 0x02, 0x50, 0x23, 0x40, 0x4d, 0x71, 0x1b, 0x47, 0x23, 0x00, 0x47, + 0xee, 0x00, 0x43, 0x23, 0x40, 0x42, 0xd8, 0x00, 0x54, 0x23, 0x80, 0x1f, + 0xa9, 0x11, 0x03, 0xa6, 0x01, 0x01, 0xff, 0x46, 0x40, 0x81, 0x4c, 0x23, + 0x00, 0x4b, 0xb8, 0x02, 0x57, 0x23, 0x40, 0x45, 0xce, 0x46, 0x3a, 0x23, + 0x00, 0x44, 0x02, 0x00, 0x39, 0x23, 0x40, 0x42, 0x12, 0x00, 0x4d, 0x23, + 0x40, 0x45, 0x13, 0x03, 0x3c, 0x23, 0x00, 0x44, 0x1f, 0x13, 0x60, 0x23, + 0x40, 0x49, 0x63, 0x5c, 0x79, 0x23, 0x40, 0x4b, 0xe0, 0x9c, 0x67, 0x23, + 0x00, 0x4a, 0xfc, 0x7b, 0x45, 0x23, 0x40, 0x49, 0xf3, 0x24, 0x64, 0x23, + 0x00, 0x48, 0x64, 0x5c, 0x5b, 0x23, 0x40, 0x45, 0xf1, 0xe7, 0x36, 0x23, + 0x00, 0x43, 0x1b, 0x05, 0x73, 0x23, 0xc0, 0x00, 0x49, 0x63, 0x5c, 0x78, + 0x23, 0x40, 0x02, 0xd8, 0x00, 0x30, 0x4f, 0x7f, 0x71, 0x5a, 0x23, 0x00, + 0x03, 0xa6, 0x01, 0x01, 0xff, 0x80, 0x06, 0x4a, 0xfc, 0x7b, 0x56, 0x23, + 0x40, 0x4b, 0xfb, 0x9e, 0x71, 0x23, 0x00, 0x4a, 0xe1, 0x9c, 0x66, 0x23, + 0x00, 0x05, 0x39, 0xde, 0x01, 0xff, 0x43, 0x9c, 0xd0, 0x4e, 0x23, 0x00, + 0x48, 0x64, 0x5c, 0x4a, 0x23, 0x40, 0x80, 0x11, 0x03, 0xf7, 0x23, 0x01, + 0xff, 0x45, 0x60, 0x01, 0x4b, 0x23, 0x00, 0x48, 0x64, 0x5c, 0x59, 0x23, + 0x40, 0x49, 0xf3, 0x24, 0x62, 0x23, 0x00, 0x45, 0x60, 0x01, 0x52, 0x23, + 0x00, 0x45, 0x71, 0x24, 0x6b, 0x23, 0x40, 0x06, 0xfc, 0x04, 0x06, 0x48, + 0xe7, 0xce, 0x6a, 0x23, 0x40, 0x49, 0xd2, 0x0e, 0x49, 0x23, 0x00, 0x49, + 0xf3, 0x24, 0x65, 0x23, 0x00, 0x43, 0x9c, 0xd0, 0x3e, 0x23, 0x00, 0x02, + 0x60, 0x01, 0x06, 0x48, 0x64, 0x5c, 0x5c, 0x23, 0x40, 0x42, 0x17, 0x00, + 0x5f, 0x23, 0x00, 0x43, 0x62, 0x01, 0x3d, 0x23, 0x40, 0x49, 0x63, 0x5c, + 0x76, 0x23, 0x40, 0x03, 0x28, 0x17, 0xb6, 0x01, 0x44, 0xa2, 0xdf, 0x93, + 0x26, 0x00, 0x4a, 0x7a, 0xae, 0xd1, 0x27, 0x00, 0xa7, 0x6f, 0x42, 0xcc, + 0x0c, 0x25, 0x26, 0x00, 0xf4, 0x1c, 0xf4, 0xc1, 0x00, 0x44, 0xb3, 0xc7, + 0x08, 0xcc, 0x81, 0x57, 0x0b, 0x13, 0x11, 0x01, 0xff, 0xa3, 0x44, 0x68, + 0xe0, 0x04, 0x04, 0xf5, 0x01, 0x53, 0xee, 0x4b, 0xf2, 0x27, 0x00, 0x4b, + 0xe8, 0x94, 0x11, 0x2a, 0x00, 0x51, 0xf6, 0x04, 0xba, 0x21, 0x00, 0xb4, + 0x01, 0xff, 0x53, 0x28, 0x4e, 0xb6, 0x21, 0x00, 0x0f, 0x02, 0x02, 0x01, + 0xff, 0x55, 0xee, 0x3b, 0x8d, 0x2b, 0x00, 0x53, 0x44, 0x4d, 0x8e, 0x2b, + 0x00, 0x51, 0xf6, 0x04, 0x6f, 0x2b, 0x00, 0x54, 0xaf, 0x47, 0x8c, 0x2b, + 0x00, 0x52, 0x4f, 0x58, 0x8f, 0x2b, 0x40, 0x52, 0xd9, 0x55, 0x40, 0x29, + 0x00, 0x4f, 0x8b, 0x74, 0x33, 0x22, 0x40, 0x4a, 0x8c, 0xab, 0xf6, 0xf4, + 0x41, 0x49, 0x83, 0x2b, 0xa2, 0xf4, 0x01, 0x42, 0x68, 0x00, 0x20, 0x22, + 0x80, 0x12, 0x47, 0x6d, 0xdb, 0x20, 0xf6, 0x01, 0x4a, 0x12, 0xb7, 0x2b, + 0x21, 0x00, 0x4b, 0x82, 0xa9, 0x27, 0xf6, 0x41, 0x80, 0x01, 0xff, 0x4a, + 0x92, 0xb4, 0xfc, 0xce, 0x01, 0x05, 0x51, 0x00, 0x01, 0xff, 0x48, 0x65, + 0x57, 0x9e, 0x29, 0x00, 0x48, 0x64, 0x5c, 0xa4, 0x29, 0x40, 0x11, 0x59, + 0x5e, 0x06, 0x4b, 0xa7, 0xa4, 0xc0, 0xfa, 0x41, 0x90, 0x92, 0x10, 0x91, + 0x9a, 0x0c, 0x92, 0xb5, 0x08, 0x93, 0xbd, 0x04, 0x94, 0x83, 0x01, 0x95, + 0x01, 0xff, 0x90, 0x5a, 0x91, 0x30, 0x92, 0x06, 0x42, 0xa9, 0xf9, 0x46, + 0x46, 0x41, 0xd0, 0x3c, 0x46, 0x01, 0xd1, 0x3d, 0x46, 0x01, 0xd2, 0x3e, + 0x46, 0x01, 0xd3, 0x3f, 0x46, 0x01, 0xd4, 0x40, 0x46, 0x01, 0xd5, 0x41, + 0x46, 0x01, 0xd6, 0x42, 0x46, 0x01, 0xd7, 0x43, 0x46, 0x01, 0xd8, 0x44, + 0x46, 0x01, 0xd9, 0x45, 0x46, 0x41, 0xd0, 0x32, 0x46, 0x01, 0xd1, 0x33, + 0x46, 0x01, 0xd2, 0x34, 0x46, 0x01, 0xd3, 0x35, 0x46, 0x01, 0xd4, 0x36, + 0x46, 0x01, 0xd5, 0x37, 0x46, 0x01, 0xd6, 0x38, 0x46, 0x01, 0xd7, 0x39, + 0x46, 0x01, 0xd8, 0x3a, 0x46, 0x01, 0xd9, 0x3b, 0x46, 0x41, 0xd1, 0x29, + 0x46, 0x01, 0xd2, 0x2a, 0x46, 0x01, 0xd3, 0x2b, 0x46, 0x01, 0xd4, 0x2c, + 0x46, 0x01, 0xd5, 0x2d, 0x46, 0x01, 0xd6, 0x2e, 0x46, 0x01, 0xd7, 0x2f, + 0x46, 0x01, 0xd8, 0x30, 0x46, 0x01, 0xd9, 0x31, 0x46, 0x41, 0x90, 0x8c, + 0x03, 0x91, 0xd7, 0x02, 0x92, 0xac, 0x02, 0x93, 0x81, 0x02, 0x94, 0xd6, + 0x01, 0x95, 0xa1, 0x01, 0x96, 0x77, 0x97, 0x4d, 0x98, 0x23, 0x99, 0x01, + 0xff, 0xd0, 0x21, 0x46, 0x01, 0xd1, 0x22, 0x46, 0x01, 0xd2, 0x23, 0x46, + 0x01, 0xd3, 0x24, 0x46, 0x01, 0xd4, 0x25, 0x46, 0x01, 0xd5, 0x26, 0x46, + 0x01, 0xd6, 0x27, 0x46, 0x01, 0xd7, 0x28, 0x46, 0x41, 0xd0, 0x17, 0x46, + 0x01, 0xd1, 0x18, 0x46, 0x01, 0xd2, 0x19, 0x46, 0x01, 0xd3, 0x1a, 0x46, + 0x01, 0xd4, 0x1b, 0x46, 0x01, 0xd5, 0x1c, 0x46, 0x01, 0xd6, 0x1d, 0x46, + 0x01, 0xd7, 0x1e, 0x46, 0x01, 0xd8, 0x1f, 0x46, 0x01, 0xd9, 0x20, 0x46, + 0x41, 0xd0, 0x0d, 0x46, 0x01, 0xd1, 0x0e, 0x46, 0x01, 0xd2, 0x0f, 0x46, + 0x01, 0xd3, 0x10, 0x46, 0x01, 0xd4, 0x11, 0x46, 0x01, 0xd5, 0x12, 0x46, + 0x01, 0xd6, 0x13, 0x46, 0x01, 0xd7, 0x14, 0x46, 0x01, 0xd8, 0x15, 0x46, + 0x01, 0xd9, 0x16, 0x46, 0x41, 0xd0, 0x03, 0x46, 0x01, 0xd1, 0x04, 0x46, + 0x01, 0xd2, 0x05, 0x46, 0x01, 0xd3, 0x06, 0x46, 0x01, 0xd4, 0x07, 0x46, + 0x01, 0xd5, 0x08, 0x46, 0x01, 0xd6, 0x09, 0x46, 0x01, 0xd7, 0x0a, 0x46, + 0x01, 0xd8, 0x0b, 0x46, 0x01, 0xd9, 0x0c, 0x46, 0x41, 0xd0, 0xf7, 0x45, + 0x81, 0x29, 0xd1, 0xf9, 0x45, 0x01, 0xd2, 0xfa, 0x45, 0x01, 0xd3, 0xfb, + 0x45, 0x01, 0xd4, 0xfc, 0x45, 0x01, 0xd5, 0xfd, 0x45, 0x01, 0xd6, 0xfe, + 0x45, 0x01, 0xd7, 0xff, 0x45, 0x81, 0x08, 0xd8, 0x01, 0x46, 0x01, 0xd9, + 0x02, 0x46, 0x41, 0xe1, 0x00, 0x46, 0x41, 0xe1, 0xf8, 0x45, 0x41, 0xd0, + 0xed, 0x45, 0x01, 0xd1, 0xee, 0x45, 0x01, 0xd2, 0xef, 0x45, 0x01, 0xd3, + 0xf0, 0x45, 0x01, 0xd4, 0xf1, 0x45, 0x01, 0xd5, 0xf2, 0x45, 0x01, 0xd6, + 0xf3, 0x45, 0x01, 0xd7, 0xf4, 0x45, 0x01, 0xd8, 0xf5, 0x45, 0x01, 0xd9, + 0xf6, 0x45, 0x41, 0xd0, 0xe3, 0x45, 0x01, 0xd1, 0xe4, 0x45, 0x01, 0xd2, + 0xe5, 0x45, 0x01, 0xd3, 0xe6, 0x45, 0x01, 0xd4, 0xe7, 0x45, 0x01, 0xd5, + 0xe8, 0x45, 0x01, 0xd6, 0xe9, 0x45, 0x01, 0xd7, 0xea, 0x45, 0x01, 0xd8, + 0xeb, 0x45, 0x01, 0xd9, 0xec, 0x45, 0x41, 0xd0, 0xd9, 0x45, 0x01, 0xd1, + 0xda, 0x45, 0x01, 0xd2, 0xdb, 0x45, 0x01, 0xd3, 0xdc, 0x45, 0x01, 0xd4, + 0xdd, 0x45, 0x01, 0xd5, 0xde, 0x45, 0x01, 0xd6, 0xdf, 0x45, 0x01, 0xd7, + 0xe0, 0x45, 0x01, 0xd8, 0xe1, 0x45, 0x01, 0xd9, 0xe2, 0x45, 0x41, 0x90, + 0x24, 0xd1, 0xd0, 0x45, 0x01, 0xd2, 0xd1, 0x45, 0x01, 0xd3, 0xd2, 0x45, + 0x01, 0xd4, 0xd3, 0x45, 0x01, 0xd5, 0xd4, 0x45, 0x01, 0xd6, 0xd5, 0x45, + 0x01, 0xd7, 0xd6, 0x45, 0x01, 0xd8, 0xd7, 0x45, 0x01, 0xd9, 0xd8, 0x45, + 0x41, 0x54, 0xbf, 0x41, 0xce, 0x45, 0x01, 0x53, 0x13, 0x4a, 0xcf, 0x45, + 0x41, 0xd0, 0xc4, 0x45, 0x01, 0xd1, 0xc5, 0x45, 0x01, 0xd2, 0xc6, 0x45, + 0x01, 0xd3, 0xc7, 0x45, 0x01, 0xd4, 0xc8, 0x45, 0x01, 0xd5, 0xc9, 0x45, + 0x01, 0xd6, 0xca, 0x45, 0x01, 0xd7, 0xcb, 0x45, 0x01, 0xd8, 0xcc, 0x45, + 0x01, 0xd9, 0xcd, 0x45, 0x41, 0x90, 0xc5, 0x03, 0x91, 0x9a, 0x03, 0x92, + 0xea, 0x02, 0x93, 0xa8, 0x02, 0x94, 0xfd, 0x01, 0x95, 0xcd, 0x01, 0x96, + 0x98, 0x01, 0x97, 0x69, 0x98, 0x2d, 0x99, 0x01, 0xff, 0xd0, 0xba, 0x45, + 0x01, 0xd1, 0xbb, 0x45, 0x01, 0xd2, 0xbc, 0x45, 0x01, 0x47, 0xe1, 0xd3, + 0xbd, 0x45, 0x01, 0xd4, 0xbe, 0x45, 0x01, 0xd5, 0xbf, 0x45, 0x01, 0xd6, + 0xc0, 0x45, 0x01, 0xd7, 0xc1, 0x45, 0x01, 0xd8, 0xc2, 0x45, 0x01, 0xd9, + 0xc3, 0x45, 0x41, 0xd0, 0xad, 0x45, 0x01, 0xd1, 0xae, 0x45, 0x81, 0x2d, + 0xd2, 0xb0, 0x45, 0x01, 0x93, 0x1d, 0xd4, 0xb3, 0x45, 0x01, 0xd5, 0xb4, + 0x45, 0x01, 0xd6, 0xb5, 0x45, 0x81, 0x0c, 0xd7, 0xb7, 0x45, 0x01, 0xd8, + 0xb8, 0x45, 0x01, 0xd9, 0xb9, 0x45, 0x41, 0xe1, 0xb6, 0x45, 0x41, 0x49, + 0x53, 0xba, 0xb1, 0x45, 0x01, 0xe1, 0xb2, 0x45, 0x41, 0xe1, 0xaf, 0x45, + 0x41, 0xd0, 0xa2, 0x45, 0x01, 0xd1, 0xa3, 0x45, 0x81, 0x20, 0xd2, 0xa5, + 0x45, 0x01, 0xd3, 0xa6, 0x45, 0x01, 0xd4, 0xa7, 0x45, 0x01, 0xd5, 0xa8, + 0x45, 0x01, 0xd6, 0xa9, 0x45, 0x01, 0xd7, 0xaa, 0x45, 0x01, 0xd8, 0xab, + 0x45, 0x01, 0xd9, 0xac, 0x45, 0x41, 0xe1, 0xa4, 0x45, 0x41, 0xd0, 0x96, + 0x45, 0x01, 0xd1, 0x97, 0x45, 0x01, 0xd2, 0x98, 0x45, 0x01, 0xd3, 0x99, + 0x45, 0x01, 0xd4, 0x9a, 0x45, 0x81, 0x19, 0xd5, 0x9c, 0x45, 0x01, 0xd6, + 0x9d, 0x45, 0x01, 0xd7, 0x9e, 0x45, 0x01, 0xd8, 0x9f, 0x45, 0x81, 0x04, + 0xd9, 0xa1, 0x45, 0x41, 0xe1, 0xa0, 0x45, 0x41, 0xe1, 0x9b, 0x45, 0x41, + 0xd0, 0x8b, 0x45, 0x01, 0xd1, 0x8c, 0x45, 0x01, 0xd2, 0x8d, 0x45, 0x01, + 0xd3, 0x8e, 0x45, 0x01, 0xd4, 0x8f, 0x45, 0x01, 0xd5, 0x90, 0x45, 0x01, + 0xd6, 0x91, 0x45, 0x01, 0xd7, 0x92, 0x45, 0x01, 0xd8, 0x93, 0x45, 0x01, + 0xd9, 0x94, 0x45, 0xc1, 0x00, 0xe1, 0x95, 0x45, 0x41, 0xd0, 0x81, 0x45, + 0x01, 0xd1, 0x82, 0x45, 0x01, 0xd2, 0x83, 0x45, 0x01, 0xd3, 0x84, 0x45, + 0x01, 0xd4, 0x85, 0x45, 0x01, 0xd5, 0x86, 0x45, 0x01, 0xd6, 0x87, 0x45, + 0x01, 0xd7, 0x88, 0x45, 0x01, 0xd8, 0x89, 0x45, 0x01, 0xd9, 0x8a, 0x45, + 0x41, 0xd0, 0x72, 0x45, 0x01, 0xd1, 0x73, 0x45, 0x01, 0x92, 0x29, 0xd3, + 0x77, 0x45, 0x01, 0xd4, 0x78, 0x45, 0x01, 0xd5, 0x79, 0x45, 0x01, 0xd6, + 0x7a, 0x45, 0x81, 0x0c, 0xd7, 0x7e, 0x45, 0x01, 0xd8, 0x7f, 0x45, 0x01, + 0xd9, 0x80, 0x45, 0x41, 0xe1, 0x7b, 0x45, 0x01, 0xe2, 0x7c, 0x45, 0x01, + 0xe3, 0x7d, 0x45, 0x41, 0xe1, 0x74, 0x45, 0x01, 0xe2, 0x75, 0x45, 0x01, + 0xe3, 0x76, 0x45, 0x41, 0xd0, 0x67, 0x45, 0x01, 0xd1, 0x68, 0x45, 0x01, + 0xd2, 0x69, 0x45, 0x01, 0xd3, 0x6a, 0x45, 0x01, 0xd4, 0x6b, 0x45, 0x01, + 0xd5, 0x6c, 0x45, 0x01, 0xd6, 0x6d, 0x45, 0x01, 0xd7, 0x6e, 0x45, 0x01, + 0xd8, 0x6f, 0x45, 0x01, 0xd9, 0x70, 0x45, 0xc1, 0x00, 0xe1, 0x71, 0x45, + 0x41, 0xd0, 0x5d, 0x45, 0x01, 0xd1, 0x5e, 0x45, 0x01, 0xd2, 0x5f, 0x45, + 0x01, 0xd3, 0x60, 0x45, 0x01, 0xd4, 0x61, 0x45, 0x01, 0xd5, 0x62, 0x45, + 0x01, 0xd6, 0x63, 0x45, 0x01, 0xd7, 0x64, 0x45, 0x01, 0xd8, 0x65, 0x45, + 0x01, 0xd9, 0x66, 0x45, 0x41, 0xd0, 0x52, 0x45, 0x01, 0xd1, 0x53, 0x45, + 0x01, 0xd2, 0x54, 0x45, 0x01, 0xd3, 0x55, 0x45, 0x01, 0xd4, 0x56, 0x45, + 0x01, 0xd5, 0x57, 0x45, 0x01, 0xd6, 0x58, 0x45, 0x01, 0xd7, 0x59, 0x45, + 0x01, 0xd8, 0x5a, 0x45, 0x01, 0xd9, 0x5b, 0x45, 0xc1, 0x00, 0xe1, 0x5c, + 0x45, 0x41, 0x90, 0xa4, 0x03, 0x91, 0xef, 0x02, 0x92, 0xbf, 0x02, 0x93, + 0x94, 0x02, 0x94, 0xe9, 0x01, 0x95, 0xbe, 0x01, 0x96, 0x8e, 0x01, 0x97, + 0x64, 0x98, 0x35, 0x99, 0x01, 0xff, 0xd0, 0x46, 0x45, 0x01, 0xd1, 0x47, + 0x45, 0x01, 0xd2, 0x48, 0x45, 0x01, 0xd3, 0x49, 0x45, 0x01, 0xd4, 0x4a, + 0x45, 0x81, 0x19, 0xd5, 0x4c, 0x45, 0x01, 0xd6, 0x4d, 0x45, 0x01, 0xd7, + 0x4e, 0x45, 0x01, 0xd8, 0x4f, 0x45, 0x01, 0xd9, 0x50, 0x45, 0xc1, 0x00, + 0xe1, 0x51, 0x45, 0x41, 0xe1, 0x4b, 0x45, 0x41, 0xd0, 0x3b, 0x45, 0x01, + 0xd1, 0x3c, 0x45, 0x01, 0xd2, 0x3d, 0x45, 0x01, 0xd3, 0x3e, 0x45, 0x01, + 0xd4, 0x3f, 0x45, 0x01, 0xd5, 0x40, 0x45, 0x01, 0xd6, 0x41, 0x45, 0x01, + 0xd7, 0x42, 0x45, 0x01, 0xd8, 0x43, 0x45, 0x01, 0xd9, 0x44, 0x45, 0xc1, + 0x00, 0xe1, 0x45, 0x45, 0x41, 0xd0, 0x31, 0x45, 0x01, 0xd1, 0x32, 0x45, + 0x01, 0xd2, 0x33, 0x45, 0x01, 0xd3, 0x34, 0x45, 0x01, 0xd4, 0x35, 0x45, + 0x01, 0xd5, 0x36, 0x45, 0x01, 0xd6, 0x37, 0x45, 0x01, 0xd7, 0x38, 0x45, + 0x01, 0xd8, 0x39, 0x45, 0x01, 0xd9, 0x3a, 0x45, 0x41, 0xd0, 0x26, 0x45, + 0x01, 0xd1, 0x27, 0x45, 0x01, 0xd2, 0x28, 0x45, 0x01, 0xd3, 0x29, 0x45, + 0x01, 0xd4, 0x2a, 0x45, 0x01, 0xd5, 0x2b, 0x45, 0x01, 0xd6, 0x2c, 0x45, + 0x01, 0xd7, 0x2d, 0x45, 0x81, 0x08, 0xd8, 0x2f, 0x45, 0x01, 0xd9, 0x30, + 0x45, 0x41, 0xe1, 0x2e, 0x45, 0x41, 0xd0, 0x1c, 0x45, 0x01, 0xd1, 0x1d, + 0x45, 0x01, 0xd2, 0x1e, 0x45, 0x01, 0xd3, 0x1f, 0x45, 0x01, 0xd4, 0x20, + 0x45, 0x01, 0xd5, 0x21, 0x45, 0x01, 0xd6, 0x22, 0x45, 0x01, 0xd7, 0x23, + 0x45, 0x01, 0xd8, 0x24, 0x45, 0x01, 0xd9, 0x25, 0x45, 0x41, 0xd0, 0x12, + 0x45, 0x01, 0xd1, 0x13, 0x45, 0x01, 0xd2, 0x14, 0x45, 0x01, 0xd3, 0x15, + 0x45, 0x01, 0xd4, 0x16, 0x45, 0x01, 0xd5, 0x17, 0x45, 0x01, 0xd6, 0x18, + 0x45, 0x01, 0xd7, 0x19, 0x45, 0x01, 0xd8, 0x1a, 0x45, 0x01, 0xd9, 0x1b, + 0x45, 0x41, 0xd0, 0x08, 0x45, 0x01, 0xd1, 0x09, 0x45, 0x01, 0xd2, 0x0a, + 0x45, 0x01, 0xd3, 0x0b, 0x45, 0x01, 0xd4, 0x0c, 0x45, 0x01, 0xd5, 0x0d, + 0x45, 0x01, 0xd6, 0x0e, 0x45, 0x01, 0xd7, 0x0f, 0x45, 0x01, 0xd8, 0x10, + 0x45, 0x01, 0xd9, 0x11, 0x45, 0x41, 0xd0, 0xfd, 0x44, 0x01, 0xd1, 0xfe, + 0x44, 0x01, 0xd2, 0xff, 0x44, 0x01, 0xd3, 0x00, 0x45, 0x01, 0xd4, 0x01, + 0x45, 0x01, 0xd5, 0x02, 0x45, 0x01, 0xd6, 0x03, 0x45, 0x01, 0xd7, 0x04, + 0x45, 0x81, 0x08, 0xd8, 0x06, 0x45, 0x01, 0xd9, 0x07, 0x45, 0x41, 0xe1, + 0x05, 0x45, 0x41, 0xd0, 0xf1, 0x44, 0x01, 0xd1, 0xf2, 0x44, 0x01, 0xd2, + 0xf3, 0x44, 0x01, 0xd3, 0xf4, 0x44, 0x01, 0xd4, 0xf5, 0x44, 0x01, 0xd5, + 0xf6, 0x44, 0x81, 0x15, 0xd6, 0xf8, 0x44, 0x81, 0x0c, 0xd7, 0xfa, 0x44, + 0x01, 0xd8, 0xfb, 0x44, 0x01, 0xd9, 0xfc, 0x44, 0x41, 0xe1, 0xf9, 0x44, + 0x41, 0xe1, 0xf7, 0x44, 0x41, 0xd0, 0xe3, 0x44, 0x01, 0xd1, 0xe4, 0x44, + 0x01, 0xd2, 0xe5, 0x44, 0x81, 0x26, 0xd3, 0xe8, 0x44, 0x01, 0xd4, 0xe9, + 0x44, 0x01, 0xd5, 0xea, 0x44, 0x01, 0xd6, 0xeb, 0x44, 0x01, 0xd7, 0xec, + 0x44, 0x81, 0x0d, 0xd8, 0xee, 0x44, 0x01, 0xd9, 0xef, 0x44, 0xc1, 0x00, + 0xe1, 0xf0, 0x44, 0x41, 0xe1, 0xed, 0x44, 0x41, 0xe1, 0xe6, 0x44, 0x01, + 0xe2, 0xe7, 0x44, 0x41, 0x90, 0x98, 0x03, 0x91, 0xdf, 0x02, 0x92, 0xaf, + 0x02, 0x93, 0xff, 0x01, 0x94, 0xd4, 0x01, 0x95, 0xa9, 0x01, 0x96, 0x7f, + 0x97, 0x55, 0x98, 0x2b, 0x99, 0x01, 0xff, 0xd0, 0xd9, 0x44, 0x01, 0xd1, + 0xda, 0x44, 0x01, 0xd2, 0xdb, 0x44, 0x01, 0xd3, 0xdc, 0x44, 0x01, 0xd4, + 0xdd, 0x44, 0x01, 0xd5, 0xde, 0x44, 0x01, 0xd6, 0xdf, 0x44, 0x01, 0xd7, + 0xe0, 0x44, 0x01, 0xd8, 0xe1, 0x44, 0x01, 0xd9, 0xe2, 0x44, 0x41, 0xd0, + 0xcf, 0x44, 0x01, 0xd1, 0xd0, 0x44, 0x01, 0xd2, 0xd1, 0x44, 0x01, 0xd3, + 0xd2, 0x44, 0x01, 0xd4, 0xd3, 0x44, 0x01, 0xd5, 0xd4, 0x44, 0x01, 0xd6, + 0xd5, 0x44, 0x01, 0xd7, 0xd6, 0x44, 0x01, 0xd8, 0xd7, 0x44, 0x01, 0xd9, + 0xd8, 0x44, 0x41, 0xd0, 0xc5, 0x44, 0x01, 0xd1, 0xc6, 0x44, 0x01, 0xd2, + 0xc7, 0x44, 0x01, 0xd3, 0xc8, 0x44, 0x01, 0xd4, 0xc9, 0x44, 0x01, 0xd5, + 0xca, 0x44, 0x01, 0xd6, 0xcb, 0x44, 0x01, 0xd7, 0xcc, 0x44, 0x01, 0xd8, + 0xcd, 0x44, 0x01, 0xd9, 0xce, 0x44, 0x41, 0xd0, 0xbb, 0x44, 0x01, 0xd1, + 0xbc, 0x44, 0x01, 0xd2, 0xbd, 0x44, 0x01, 0xd3, 0xbe, 0x44, 0x01, 0xd4, + 0xbf, 0x44, 0x01, 0xd5, 0xc0, 0x44, 0x01, 0xd6, 0xc1, 0x44, 0x01, 0xd7, + 0xc2, 0x44, 0x01, 0xd8, 0xc3, 0x44, 0x01, 0xd9, 0xc4, 0x44, 0x41, 0xd0, + 0xb1, 0x44, 0x01, 0xd1, 0xb2, 0x44, 0x01, 0xd2, 0xb3, 0x44, 0x01, 0xd3, + 0xb4, 0x44, 0x01, 0xd4, 0xb5, 0x44, 0x01, 0xd5, 0xb6, 0x44, 0x01, 0xd6, + 0xb7, 0x44, 0x01, 0xd7, 0xb8, 0x44, 0x01, 0xd8, 0xb9, 0x44, 0x01, 0xd9, + 0xba, 0x44, 0x41, 0xd0, 0xa7, 0x44, 0x01, 0xd1, 0xa8, 0x44, 0x01, 0xd2, + 0xa9, 0x44, 0x01, 0xd3, 0xaa, 0x44, 0x01, 0xd4, 0xab, 0x44, 0x01, 0xd5, + 0xac, 0x44, 0x01, 0xd6, 0xad, 0x44, 0x01, 0xd7, 0xae, 0x44, 0x01, 0xd8, + 0xaf, 0x44, 0x01, 0xd9, 0xb0, 0x44, 0x41, 0xd0, 0x9c, 0x44, 0x01, 0xd1, + 0x9d, 0x44, 0x01, 0xd2, 0x9e, 0x44, 0x01, 0xd3, 0x9f, 0x44, 0x01, 0xd4, + 0xa0, 0x44, 0x01, 0xd5, 0xa1, 0x44, 0x81, 0x10, 0xd6, 0xa3, 0x44, 0x01, + 0xd7, 0xa4, 0x44, 0x01, 0xd8, 0xa5, 0x44, 0x01, 0xd9, 0xa6, 0x44, 0x41, + 0xe1, 0xa2, 0x44, 0x41, 0xd0, 0x91, 0x44, 0x01, 0xd1, 0x92, 0x44, 0x01, + 0xd2, 0x93, 0x44, 0x01, 0xd3, 0x94, 0x44, 0x01, 0xd4, 0x95, 0x44, 0x01, + 0xd5, 0x96, 0x44, 0x81, 0x10, 0xd6, 0x98, 0x44, 0x01, 0xd7, 0x99, 0x44, + 0x01, 0xd8, 0x9a, 0x44, 0x01, 0xd9, 0x9b, 0x44, 0x41, 0xe1, 0x97, 0x44, + 0x41, 0xd0, 0x84, 0x44, 0x81, 0x29, 0xd1, 0x87, 0x44, 0x01, 0xd2, 0x88, + 0x44, 0x01, 0xd3, 0x89, 0x44, 0x01, 0xd4, 0x8a, 0x44, 0x01, 0xd5, 0x8b, + 0x44, 0x81, 0x10, 0xd6, 0x8d, 0x44, 0x01, 0xd7, 0x8e, 0x44, 0x01, 0xd8, + 0x8f, 0x44, 0x01, 0xd9, 0x90, 0x44, 0x41, 0xe1, 0x8c, 0x44, 0x41, 0xe1, + 0x85, 0x44, 0x01, 0xe2, 0x86, 0x44, 0x41, 0xd0, 0x6f, 0x44, 0x81, 0x51, + 0xd1, 0x71, 0x44, 0x81, 0x48, 0xd2, 0x73, 0x44, 0x81, 0x3f, 0xd3, 0x75, + 0x44, 0x01, 0xd4, 0x76, 0x44, 0x81, 0x2a, 0xd5, 0x7a, 0x44, 0x81, 0x1d, + 0xd6, 0x7d, 0x44, 0x01, 0xd7, 0x7e, 0x44, 0x81, 0x08, 0xd8, 0x82, 0x44, + 0x01, 0xd9, 0x83, 0x44, 0x41, 0xe1, 0x7f, 0x44, 0x01, 0xe2, 0x80, 0x44, + 0x01, 0xe3, 0x81, 0x44, 0x41, 0xe1, 0x7b, 0x44, 0x01, 0xe2, 0x7c, 0x44, + 0x41, 0xe1, 0x77, 0x44, 0x01, 0xe2, 0x78, 0x44, 0x01, 0xe3, 0x79, 0x44, + 0x41, 0xe1, 0x74, 0x44, 0x41, 0xe1, 0x72, 0x44, 0x41, 0xe1, 0x70, 0x44, + 0x41, 0x90, 0xba, 0x03, 0x91, 0x8a, 0x03, 0x92, 0xda, 0x02, 0x93, 0xaa, + 0x02, 0x94, 0xec, 0x01, 0x95, 0xc1, 0x01, 0x96, 0x89, 0x01, 0x97, 0x5f, + 0x98, 0x35, 0x99, 0x01, 0xff, 0xd0, 0x63, 0x44, 0x01, 0xd1, 0x64, 0x44, + 0x01, 0xd2, 0x65, 0x44, 0x01, 0xd3, 0x66, 0x44, 0x01, 0xd4, 0x67, 0x44, + 0x01, 0xd5, 0x68, 0x44, 0x01, 0xd6, 0x69, 0x44, 0x01, 0xd7, 0x6a, 0x44, + 0x81, 0x0d, 0xd8, 0x6c, 0x44, 0x81, 0x04, 0xd9, 0x6e, 0x44, 0x41, 0xe1, + 0x6d, 0x44, 0x41, 0xe1, 0x6b, 0x44, 0x41, 0xd0, 0x59, 0x44, 0x01, 0xd1, + 0x5a, 0x44, 0x01, 0xd2, 0x5b, 0x44, 0x01, 0xd3, 0x5c, 0x44, 0x01, 0xd4, + 0x5d, 0x44, 0x01, 0xd5, 0x5e, 0x44, 0x01, 0xd6, 0x5f, 0x44, 0x01, 0xd7, + 0x60, 0x44, 0x01, 0xd8, 0x61, 0x44, 0x01, 0xd9, 0x62, 0x44, 0x41, 0xd0, + 0x4f, 0x44, 0x01, 0xd1, 0x50, 0x44, 0x01, 0xd2, 0x51, 0x44, 0x01, 0xd3, + 0x52, 0x44, 0x01, 0xd4, 0x53, 0x44, 0x01, 0xd5, 0x54, 0x44, 0x01, 0xd6, + 0x55, 0x44, 0x01, 0xd7, 0x56, 0x44, 0x01, 0xd8, 0x57, 0x44, 0x01, 0xd9, + 0x58, 0x44, 0x41, 0xd0, 0x42, 0x44, 0x01, 0xd1, 0x43, 0x44, 0x01, 0xd2, + 0x44, 0x44, 0x01, 0xd3, 0x45, 0x44, 0x01, 0xd4, 0x46, 0x44, 0x01, 0xd5, + 0x47, 0x44, 0x01, 0xd6, 0x48, 0x44, 0x81, 0x0c, 0xd7, 0x4c, 0x44, 0x01, + 0xd8, 0x4d, 0x44, 0x01, 0xd9, 0x4e, 0x44, 0x41, 0xe1, 0x49, 0x44, 0x01, + 0xe2, 0x4a, 0x44, 0x01, 0xe3, 0x4b, 0x44, 0x41, 0xd0, 0x38, 0x44, 0x01, + 0xd1, 0x39, 0x44, 0x01, 0xd2, 0x3a, 0x44, 0x01, 0xd3, 0x3b, 0x44, 0x01, + 0xd4, 0x3c, 0x44, 0x01, 0xd5, 0x3d, 0x44, 0x01, 0xd6, 0x3e, 0x44, 0x01, + 0xd7, 0x3f, 0x44, 0x01, 0xd8, 0x40, 0x44, 0x01, 0xd9, 0x41, 0x44, 0x41, + 0xd0, 0x2a, 0x44, 0x01, 0xd1, 0x2b, 0x44, 0x81, 0x2e, 0xd2, 0x2d, 0x44, + 0x01, 0xd3, 0x2e, 0x44, 0x01, 0xd4, 0x2f, 0x44, 0x01, 0xd5, 0x30, 0x44, + 0x81, 0x19, 0xd6, 0x32, 0x44, 0x81, 0x0c, 0xd7, 0x35, 0x44, 0x01, 0xd8, + 0x36, 0x44, 0x01, 0xd9, 0x37, 0x44, 0x41, 0xe1, 0x33, 0x44, 0x01, 0xe2, + 0x34, 0x44, 0x41, 0xe1, 0x31, 0x44, 0x41, 0xe1, 0x2c, 0x44, 0x41, 0xd0, + 0x1f, 0x44, 0x01, 0xd1, 0x20, 0x44, 0x01, 0xd2, 0x21, 0x44, 0x01, 0xd3, + 0x22, 0x44, 0x01, 0xd4, 0x23, 0x44, 0x01, 0xd5, 0x24, 0x44, 0x01, 0xd6, + 0x25, 0x44, 0x01, 0xd7, 0x26, 0x44, 0x01, 0xd8, 0x27, 0x44, 0x01, 0xd9, + 0x28, 0x44, 0xc1, 0x00, 0xe1, 0x29, 0x44, 0x41, 0xd0, 0x14, 0x44, 0x01, + 0xd1, 0x15, 0x44, 0x01, 0xd2, 0x16, 0x44, 0x01, 0xd3, 0x17, 0x44, 0x01, + 0xd4, 0x18, 0x44, 0x01, 0xd5, 0x19, 0x44, 0x01, 0xd6, 0x1a, 0x44, 0x81, + 0x0c, 0xd7, 0x1c, 0x44, 0x01, 0xd8, 0x1d, 0x44, 0x01, 0xd9, 0x1e, 0x44, + 0x41, 0xe1, 0x1b, 0x44, 0x41, 0xd0, 0x09, 0x44, 0x81, 0x24, 0xd1, 0x0b, + 0x44, 0x01, 0xd2, 0x0c, 0x44, 0x01, 0xd3, 0x0d, 0x44, 0x01, 0xd4, 0x0e, + 0x44, 0x01, 0xd5, 0x0f, 0x44, 0x01, 0xd6, 0x10, 0x44, 0x01, 0xd7, 0x11, + 0x44, 0x01, 0xd8, 0x12, 0x44, 0x01, 0xd9, 0x13, 0x44, 0x41, 0xe1, 0x0a, + 0x44, 0x41, 0xd1, 0x00, 0x44, 0x01, 0xd2, 0x01, 0x44, 0x01, 0xd3, 0x02, + 0x44, 0x01, 0xd4, 0x03, 0x44, 0x01, 0xd5, 0x04, 0x44, 0x01, 0xd6, 0x05, + 0x44, 0x01, 0xd7, 0x06, 0x44, 0x01, 0xd8, 0x07, 0x44, 0x01, 0xd9, 0x08, + 0x44, 0x41, 0x57, 0x86, 0x2e, 0x3f, 0x2a, 0x00, 0x47, 0x7e, 0xd5, 0x91, + 0xf6, 0x01, 0x4f, 0xdb, 0x6f, 0xc8, 0xf3, 0x01, 0xb0, 0x01, 0xff, 0x46, + 0x38, 0x40, 0x26, 0x00, 0x00, 0xa8, 0x01, 0xff, 0x46, 0x24, 0xe3, 0xcf, + 0xce, 0x01, 0x43, 0x4e, 0x03, 0xfa, 0xf3, 0x41, 0x04, 0x0b, 0x0d, 0x90, + 0x08, 0x14, 0x3b, 0x43, 0xae, 0x01, 0xa5, 0x99, 0x01, 0x04, 0x58, 0xf6, + 0x3e, 0x02, 0x14, 0x00, 0x2e, 0xed, 0x1c, 0x06, 0x80, 0x11, 0x06, 0xc1, + 0x12, 0x01, 0xff, 0x5a, 0x21, 0x21, 0xd5, 0x26, 0x00, 0x4e, 0x92, 0x7c, + 0x87, 0x23, 0x40, 0x0a, 0xd1, 0x6d, 0x01, 0xff, 0x4b, 0x91, 0x2a, 0x4a, + 0x22, 0x00, 0x42, 0x1e, 0x00, 0x48, 0x22, 0xc0, 0x00, 0x57, 0xc9, 0x04, + 0x6f, 0x2a, 0x40, 0x4e, 0x82, 0x79, 0x2e, 0x23, 0x00, 0x48, 0x86, 0x0d, + 0x4c, 0x22, 0x40, 0x0e, 0x00, 0x7a, 0x47, 0x47, 0x2f, 0xd9, 0x7e, 0xf4, + 0x81, 0x24, 0xb3, 0x01, 0xff, 0x06, 0x1c, 0xe5, 0x11, 0x05, 0x72, 0x19, + 0x01, 0xff, 0x50, 0x4a, 0x64, 0x4f, 0xcc, 0x01, 0x4e, 0x36, 0x7e, 0x4e, + 0xcc, 0x41, 0x49, 0x11, 0xbd, 0x52, 0xcc, 0x01, 0x46, 0xff, 0x30, 0x53, + 0xcc, 0x41, 0x80, 0x01, 0xff, 0x4b, 0x3d, 0x9f, 0x4d, 0xcc, 0x01, 0x49, + 0x2f, 0xc3, 0x4c, 0xcc, 0x01, 0x05, 0xfc, 0xf0, 0x01, 0xff, 0xd1, 0x54, + 0xcc, 0x01, 0xd2, 0x55, 0xcc, 0x41, 0x44, 0xc3, 0x00, 0x51, 0xcc, 0x01, + 0x45, 0xc8, 0x00, 0x50, 0xcc, 0x41, 0x48, 0x88, 0x9d, 0x35, 0x21, 0x00, + 0x44, 0xdf, 0xeb, 0x97, 0x26, 0x00, 0x42, 0x34, 0x00, 0x07, 0x00, 0x40, + 0xa1, 0xf5, 0x05, 0xa2, 0xbe, 0x05, 0xa3, 0xdd, 0x04, 0xa4, 0xbc, 0x04, + 0x45, 0x94, 0x75, 0x03, 0xf7, 0x01, 0x44, 0x04, 0x96, 0x02, 0xf7, 0x01, + 0xa7, 0xa1, 0x04, 0xa8, 0xff, 0x03, 0x04, 0x5e, 0x21, 0xe7, 0x03, 0xac, + 0xd8, 0x03, 0xad, 0xae, 0x03, 0x02, 0x51, 0x03, 0x9d, 0x03, 0x43, 0x2a, + 0xe8, 0x46, 0xf7, 0x81, 0x8f, 0x03, 0xb0, 0xdc, 0x02, 0x03, 0xd6, 0x01, + 0xcb, 0x02, 0xb2, 0xf9, 0x01, 0xb3, 0x70, 0xb4, 0x45, 0x45, 0xce, 0xf1, + 0x55, 0xf7, 0x01, 0xb6, 0x0f, 0x02, 0xa9, 0x01, 0x01, 0xff, 0x43, 0x8b, + 0x00, 0x04, 0xf7, 0x01, 0xf8, 0x4a, 0xf7, 0x41, 0x48, 0x6f, 0xcb, 0x28, + 0xf7, 0x01, 0xa9, 0x01, 0xff, 0x45, 0xef, 0xee, 0x0a, 0xf7, 0x81, 0x0d, + 0x45, 0x65, 0xf1, 0x16, 0xf7, 0xc1, 0x00, 0x42, 0x86, 0xf9, 0x17, 0xf7, + 0x41, 0x4c, 0xcc, 0x8f, 0x2f, 0xf7, 0x01, 0x8d, 0x01, 0xff, 0xd2, 0x0b, + 0xf7, 0x01, 0xd3, 0x0c, 0xf7, 0x41, 0x45, 0x6d, 0xe6, 0x3f, 0xf7, 0x81, + 0x1c, 0x02, 0x9e, 0x01, 0x0c, 0x46, 0xe1, 0x84, 0x51, 0xf7, 0x01, 0x44, + 0xec, 0xf8, 0x4d, 0xf7, 0x41, 0x44, 0x76, 0x9d, 0x29, 0xf7, 0x01, 0x45, + 0x8b, 0x8f, 0x48, 0xf7, 0x41, 0x42, 0x86, 0xf9, 0x40, 0xf7, 0x41, 0x02, + 0x13, 0x00, 0x61, 0x4e, 0xd6, 0x79, 0x4f, 0xf7, 0x01, 0x45, 0x55, 0xed, + 0x1b, 0xf7, 0x01, 0x43, 0xa3, 0xd9, 0x54, 0xf7, 0x01, 0x45, 0x28, 0xc5, + 0x47, 0xf7, 0x01, 0xb4, 0x34, 0xb5, 0x01, 0xff, 0x06, 0xe3, 0x65, 0x06, + 0x44, 0xa3, 0x54, 0x0d, 0xf7, 0x41, 0x05, 0x47, 0x45, 0x06, 0x43, 0xb5, + 0x00, 0x5e, 0xf7, 0x41, 0x48, 0xd0, 0x8f, 0x2c, 0xf7, 0x01, 0x46, 0x3f, + 0x53, 0x22, 0xf7, 0x01, 0x08, 0x5f, 0xd0, 0x01, 0xff, 0x48, 0xd0, 0x8f, + 0x2e, 0xf7, 0x01, 0x46, 0x3f, 0x53, 0x27, 0xf7, 0x41, 0x4d, 0xda, 0x84, + 0x52, 0xf7, 0x01, 0x53, 0xd3, 0x4e, 0x5c, 0xf7, 0xc1, 0x00, 0x42, 0x86, + 0xf9, 0x5d, 0xf7, 0x41, 0x49, 0x92, 0xba, 0x39, 0xf7, 0x01, 0xf4, 0x14, + 0xf7, 0xc1, 0x00, 0x04, 0xf3, 0x01, 0x01, 0xff, 0x48, 0xd0, 0x8f, 0x2d, + 0xf7, 0x01, 0x52, 0x3f, 0x53, 0x26, 0xf7, 0x01, 0x46, 0x6c, 0xe6, 0xd4, + 0xce, 0x41, 0xa5, 0x0d, 0x48, 0xaf, 0xce, 0x18, 0xf7, 0xc1, 0x00, 0x42, + 0x86, 0xf9, 0x19, 0xf7, 0x41, 0x45, 0x2b, 0xea, 0x3b, 0xf7, 0x81, 0x33, + 0x45, 0xab, 0xec, 0x32, 0xf7, 0x81, 0x06, 0x44, 0x79, 0x09, 0x6d, 0xf7, + 0x41, 0x04, 0xf3, 0x01, 0x0f, 0x8d, 0x01, 0xff, 0xd2, 0x33, 0xf7, 0x01, + 0xd3, 0x34, 0xf7, 0x01, 0xd4, 0x35, 0xf7, 0x41, 0x48, 0xd0, 0x8f, 0x30, + 0xf7, 0x81, 0x06, 0x44, 0x5e, 0x21, 0x1f, 0xf7, 0x41, 0x42, 0x86, 0xf9, + 0x31, 0xf7, 0x41, 0x42, 0x86, 0xf9, 0x3c, 0xf7, 0x41, 0x47, 0xaf, 0xd5, + 0x41, 0xf7, 0x01, 0x49, 0x69, 0xc2, 0x00, 0xf7, 0x41, 0x52, 0x95, 0x54, + 0x0e, 0xf7, 0x01, 0xaf, 0x15, 0x4a, 0xa0, 0xb5, 0x5f, 0xf7, 0x01, 0xb5, + 0x01, 0xff, 0x44, 0x44, 0xf8, 0x63, 0xf7, 0x01, 0x4a, 0xbc, 0xb7, 0x64, + 0xf7, 0x41, 0x47, 0x07, 0xdc, 0x58, 0xf7, 0x01, 0x44, 0x24, 0xf9, 0x4b, + 0xf7, 0xc1, 0x00, 0x48, 0x27, 0xcb, 0x5a, 0xf7, 0x41, 0x49, 0x99, 0x24, + 0xd2, 0xce, 0x41, 0x43, 0xca, 0x00, 0x6f, 0xf7, 0x01, 0x43, 0x76, 0x02, + 0x15, 0xf7, 0x41, 0x48, 0x2f, 0xc9, 0x38, 0xf7, 0x01, 0x50, 0xda, 0x65, + 0x10, 0xf7, 0x81, 0x0f, 0xaf, 0x01, 0xff, 0x43, 0xa5, 0x1c, 0x71, 0xf7, + 0x01, 0x4a, 0x60, 0xb4, 0xd3, 0xce, 0x41, 0x8d, 0x01, 0xff, 0xd2, 0x11, + 0xf7, 0x01, 0xd3, 0x12, 0xf7, 0x41, 0x47, 0x57, 0xd6, 0x2a, 0xf7, 0x01, + 0x48, 0xbf, 0xce, 0x53, 0xf7, 0x41, 0x44, 0x76, 0x9d, 0x1c, 0xf7, 0x81, + 0x06, 0x4b, 0x6f, 0x9d, 0x21, 0xf7, 0x41, 0x42, 0x86, 0xf9, 0x1d, 0xf7, + 0x41, 0x04, 0x23, 0x00, 0x0f, 0xaf, 0x01, 0xff, 0x48, 0x4f, 0xd0, 0x56, + 0xf7, 0x01, 0x42, 0x42, 0x00, 0x6e, 0xf7, 0x41, 0x44, 0x7d, 0xbd, 0x72, + 0xf7, 0x01, 0x45, 0xa8, 0xef, 0x73, 0xf7, 0x41, 0x43, 0x03, 0x1c, 0x1a, + 0xf7, 0x01, 0x42, 0x48, 0x04, 0x49, 0xf7, 0x41, 0x48, 0x87, 0xc9, 0x70, + 0xf7, 0x01, 0x02, 0x5f, 0x03, 0x01, 0xff, 0x45, 0xed, 0xf0, 0x61, 0xf7, + 0x81, 0x06, 0x44, 0xe0, 0x36, 0x60, 0xf7, 0x41, 0x42, 0x86, 0xf9, 0x62, + 0xf7, 0x41, 0xa1, 0x4a, 0x47, 0xd1, 0xd7, 0x13, 0xf7, 0x01, 0x06, 0x40, + 0x53, 0x34, 0xb2, 0x01, 0xff, 0x08, 0xb7, 0xce, 0x1a, 0x46, 0xde, 0xe6, + 0x65, 0xf7, 0xc1, 0x00, 0x8d, 0x01, 0xff, 0xd2, 0x66, 0xf7, 0x01, 0xd3, + 0x67, 0xf7, 0x01, 0xd4, 0x68, 0xf7, 0x01, 0xd5, 0x69, 0xf7, 0x41, 0x46, + 0x3f, 0x53, 0x23, 0xf7, 0x81, 0x06, 0x44, 0x5e, 0x21, 0x1e, 0xf7, 0x41, + 0x42, 0x86, 0xf9, 0x24, 0xf7, 0x41, 0x4b, 0x46, 0x53, 0x25, 0xf7, 0x01, + 0x43, 0x5d, 0x10, 0x20, 0xf7, 0x41, 0x46, 0xf0, 0xe0, 0x50, 0xf7, 0x01, + 0x42, 0x1b, 0xfb, 0x4c, 0xf7, 0x01, 0x4b, 0xac, 0xa6, 0x4e, 0xf7, 0x41, + 0x07, 0xeb, 0xd4, 0x24, 0x4a, 0x86, 0xb1, 0x3e, 0xf7, 0x01, 0x4b, 0x5d, + 0xa3, 0x0f, 0xf7, 0x01, 0x44, 0xdc, 0xf7, 0x42, 0xf7, 0x81, 0x06, 0x44, + 0x69, 0x22, 0x59, 0xf7, 0x41, 0x8d, 0x01, 0xff, 0xd2, 0x43, 0xf7, 0x01, + 0xd3, 0x44, 0xf7, 0x41, 0x44, 0x14, 0xf7, 0x6b, 0xf7, 0x01, 0x47, 0x0a, + 0xdd, 0x6c, 0xf7, 0x41, 0x42, 0x46, 0x00, 0x01, 0xf7, 0x01, 0xac, 0x44, + 0x46, 0x85, 0x2e, 0x5b, 0xf7, 0x01, 0x4b, 0x62, 0xa5, 0x2b, 0xf7, 0x01, + 0x03, 0x7c, 0x00, 0x12, 0x46, 0xac, 0xe5, 0x3a, 0xf7, 0x01, 0x44, 0xf6, + 0x7f, 0x57, 0xf7, 0x01, 0x4a, 0xa2, 0xb8, 0x3d, 0xf7, 0x41, 0x80, 0x06, + 0x46, 0xbc, 0xe1, 0x05, 0xf7, 0x41, 0x45, 0x2f, 0xf0, 0x06, 0xf7, 0x81, + 0x0d, 0x45, 0x05, 0xf2, 0x08, 0xf7, 0xc1, 0x00, 0x42, 0x86, 0xf9, 0x09, + 0xf7, 0x41, 0x42, 0x86, 0xf9, 0x07, 0xf7, 0x41, 0x45, 0xde, 0xeb, 0x6a, + 0xf7, 0x01, 0x44, 0xac, 0xf6, 0x36, 0xf7, 0x81, 0x06, 0x42, 0x48, 0x04, + 0x45, 0xf7, 0x41, 0x42, 0x86, 0xf9, 0x37, 0xf7, 0x41, 0x4b, 0x8d, 0x9e, + 0xfa, 0xfb, 0x01, 0x45, 0xa4, 0x0b, 0xf0, 0x23, 0x40, 0x80, 0x01, 0xff, + 0x48, 0x3f, 0xc9, 0xec, 0xf6, 0x01, 0x49, 0x3e, 0xbd, 0xeb, 0xf6, 0x41, + 0x16, 0x09, 0x35, 0x8c, 0x03, 0x06, 0xef, 0x06, 0xc5, 0x02, 0x07, 0x13, + 0x06, 0x6b, 0x08, 0x10, 0xb4, 0x5b, 0xb3, 0x34, 0x0b, 0xc7, 0x7a, 0x01, + 0xff, 0xe1, 0x20, 0x17, 0x81, 0x1a, 0xe5, 0x26, 0x17, 0x01, 0xe9, 0x22, + 0x17, 0x81, 0x0d, 0xef, 0x28, 0x17, 0x01, 0xf5, 0x24, 0x17, 0xc1, 0x00, + 0xf5, 0x25, 0x17, 0x41, 0xe9, 0x23, 0x17, 0x41, 0xe1, 0x21, 0x17, 0x01, + 0xe9, 0x29, 0x17, 0x01, 0xed, 0x2a, 0x17, 0x01, 0xf7, 0x27, 0x17, 0x41, + 0x04, 0x5b, 0x03, 0x06, 0x48, 0x44, 0xa8, 0x3f, 0x17, 0x41, 0x46, 0x5a, + 0xe3, 0x2b, 0x17, 0x01, 0x45, 0x7f, 0xf0, 0x3e, 0x17, 0x01, 0xb3, 0x01, + 0xff, 0x46, 0xf8, 0x0a, 0x3d, 0x17, 0x01, 0x4c, 0x8c, 0x96, 0x3c, 0x17, + 0x41, 0x42, 0x92, 0x01, 0x3a, 0x17, 0x01, 0x45, 0xe8, 0x1e, 0x3b, 0x17, + 0x41, 0xe1, 0x12, 0x17, 0x81, 0xb9, 0x01, 0xa2, 0xac, 0x01, 0xa3, 0x9f, + 0x01, 0xa4, 0x86, 0x01, 0xa7, 0x7a, 0x42, 0x22, 0x00, 0x11, 0x17, 0x01, + 0xaa, 0x68, 0xab, 0x5c, 0xac, 0x50, 0x42, 0x6c, 0x00, 0x09, 0x17, 0x01, + 0xae, 0x32, 0xb0, 0x26, 0x42, 0x71, 0x00, 0x0d, 0x17, 0x01, 0x42, 0x40, + 0x06, 0x0f, 0x17, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x04, 0x17, 0x01, 0x42, + 0x22, 0x00, 0x0c, 0x17, 0x01, 0xb4, 0x01, 0xff, 0xe1, 0x41, 0x17, 0x01, + 0x42, 0x22, 0x00, 0x42, 0x17, 0x41, 0xe1, 0x06, 0x17, 0x01, 0x42, 0x22, + 0x00, 0x07, 0x17, 0x41, 0xe1, 0x03, 0x17, 0x01, 0x42, 0x24, 0x02, 0x02, + 0x17, 0x01, 0x42, 0x2a, 0x05, 0x45, 0x17, 0x01, 0x42, 0xdf, 0x23, 0x10, + 0x17, 0x41, 0xe1, 0x0e, 0x17, 0x01, 0x42, 0x74, 0x00, 0x46, 0x17, 0x41, + 0xe1, 0x00, 0x17, 0x01, 0x42, 0x22, 0x00, 0x01, 0x17, 0x41, 0xe1, 0x0a, + 0x17, 0x01, 0x42, 0x22, 0x00, 0x19, 0x17, 0x41, 0xe1, 0x15, 0x17, 0x01, + 0x42, 0x22, 0x00, 0x17, 0x17, 0x41, 0xe1, 0x13, 0x17, 0x01, 0xa4, 0x06, + 0x42, 0x22, 0x00, 0x14, 0x17, 0x41, 0xe1, 0x43, 0x17, 0x01, 0x42, 0x22, + 0x00, 0x44, 0x17, 0x41, 0xe1, 0x40, 0x17, 0x01, 0x42, 0x22, 0x00, 0x0b, + 0x17, 0x41, 0xe1, 0x08, 0x17, 0x01, 0x42, 0x22, 0x00, 0x18, 0x17, 0x41, + 0x09, 0xc0, 0x12, 0x01, 0xff, 0x42, 0x16, 0x00, 0x1a, 0x17, 0x01, 0x42, + 0x24, 0x02, 0x16, 0x17, 0x01, 0x42, 0x12, 0x00, 0x05, 0x17, 0x41, 0x45, + 0x7e, 0x0b, 0x38, 0x17, 0x01, 0xa6, 0x2e, 0x44, 0x6d, 0x2c, 0x39, 0x17, + 0x01, 0x43, 0x7a, 0x0b, 0x31, 0x17, 0x01, 0xb3, 0x14, 0xb4, 0x06, 0x44, + 0x80, 0x1f, 0x30, 0x17, 0x41, 0x44, 0x25, 0x01, 0x33, 0x17, 0x01, 0x42, + 0x15, 0x02, 0x32, 0x17, 0x41, 0x44, 0x06, 0x1f, 0x37, 0x17, 0x01, 0x42, + 0x09, 0x24, 0x36, 0x17, 0x41, 0x43, 0xf9, 0x05, 0x35, 0x17, 0x01, 0x43, + 0xf6, 0x06, 0x34, 0x17, 0x41, 0xac, 0x06, 0x42, 0x71, 0x00, 0x1e, 0x17, + 0x41, 0xe1, 0x1d, 0x17, 0x01, 0x4a, 0x0e, 0xb1, 0x1f, 0x17, 0x41, 0x05, + 0x8d, 0xec, 0x06, 0x4c, 0x68, 0x99, 0xa1, 0xf6, 0x41, 0x4a, 0xf8, 0xad, + 0x02, 0x01, 0x01, 0x59, 0x3e, 0x25, 0x3c, 0x01, 0x01, 0x5c, 0x70, 0x19, + 0x3d, 0x01, 0x01, 0x08, 0x77, 0x19, 0x84, 0x03, 0x07, 0x37, 0x3c, 0x38, + 0xb7, 0x01, 0xff, 0x06, 0xff, 0x14, 0x11, 0x0e, 0x60, 0x7e, 0x01, 0xff, + 0x43, 0x48, 0x0a, 0x01, 0x01, 0x01, 0x44, 0xef, 0x05, 0x00, 0x01, 0x41, + 0x49, 0x0c, 0xbc, 0x37, 0x01, 0x01, 0xa6, 0x0c, 0x4e, 0xbe, 0x7f, 0x39, + 0x01, 0x01, 0x4d, 0xca, 0x8d, 0x3a, 0x01, 0x41, 0x4c, 0x80, 0x19, 0x38, + 0x01, 0x01, 0x4d, 0xa8, 0x8b, 0x3b, 0x01, 0x41, 0x45, 0x7e, 0x0b, 0x0e, + 0x01, 0x81, 0xa7, 0x02, 0xa6, 0xd9, 0x01, 0x44, 0x6d, 0x2c, 0x0f, 0x01, + 0x81, 0xb6, 0x01, 0x43, 0x7a, 0x0b, 0x07, 0x01, 0x81, 0x9f, 0x01, 0xb3, + 0x59, 0xb4, 0x01, 0xff, 0x42, 0x92, 0x01, 0x10, 0x01, 0x81, 0x49, 0xa8, + 0x24, 0xb7, 0x01, 0xff, 0x44, 0xe9, 0x1e, 0x11, 0x01, 0x81, 0x14, 0xef, + 0x08, 0x01, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0x1a, 0x01, + 0x01, 0x48, 0xde, 0x1e, 0x23, 0x01, 0x41, 0x49, 0xdd, 0x1e, 0x2c, 0x01, + 0x41, 0x44, 0x49, 0x12, 0x12, 0x01, 0x81, 0x16, 0x43, 0x26, 0x01, 0x09, + 0x01, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0x1b, 0x01, 0x01, + 0x48, 0xde, 0x1e, 0x24, 0x01, 0x41, 0x49, 0xdd, 0x1e, 0x2d, 0x01, 0x41, + 0x49, 0xdd, 0x1e, 0x2b, 0x01, 0x41, 0x44, 0x06, 0x1f, 0x0d, 0x01, 0x81, + 0x22, 0x42, 0x09, 0x24, 0x0c, 0x01, 0xc1, 0x00, 0x80, 0x0d, 0x42, 0x4b, + 0x12, 0x15, 0x01, 0xc1, 0x00, 0x49, 0xdd, 0x1e, 0x30, 0x01, 0x41, 0x47, + 0x3f, 0x12, 0x1e, 0x01, 0x01, 0x48, 0xde, 0x1e, 0x27, 0x01, 0x41, 0x80, + 0x0d, 0x42, 0x4b, 0x12, 0x16, 0x01, 0xc1, 0x00, 0x49, 0xdd, 0x1e, 0x31, + 0x01, 0x41, 0x47, 0x3f, 0x12, 0x1f, 0x01, 0x01, 0x48, 0xde, 0x1e, 0x28, + 0x01, 0x41, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0x19, 0x01, 0x01, 0x48, + 0xde, 0x1e, 0x22, 0x01, 0x41, 0x80, 0x0d, 0x42, 0x4b, 0x12, 0x18, 0x01, + 0xc1, 0x00, 0x49, 0xdd, 0x1e, 0x33, 0x01, 0x41, 0x47, 0x3f, 0x12, 0x21, + 0x01, 0x01, 0x48, 0xde, 0x1e, 0x2a, 0x01, 0x41, 0xa9, 0x26, 0xaf, 0x01, + 0xff, 0x43, 0x4a, 0x12, 0x13, 0x01, 0x81, 0x16, 0x42, 0x42, 0x00, 0x0a, + 0x01, 0xc1, 0x00, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0x1c, 0x01, 0x01, + 0x48, 0xde, 0x1e, 0x25, 0x01, 0x41, 0x49, 0xdd, 0x1e, 0x2e, 0x01, 0x41, + 0x43, 0x04, 0x24, 0x14, 0x01, 0x81, 0x16, 0x42, 0x32, 0x00, 0x0b, 0x01, + 0xc1, 0x00, 0x80, 0x01, 0xff, 0x47, 0x3f, 0x12, 0x1d, 0x01, 0x01, 0x48, + 0xde, 0x1e, 0x26, 0x01, 0x41, 0x49, 0xdd, 0x1e, 0x2f, 0x01, 0x41, 0x80, + 0x0b, 0xf9, 0x17, 0x01, 0xc1, 0x00, 0x49, 0xdd, 0x1e, 0x32, 0x01, 0x41, + 0x47, 0x3f, 0x12, 0x20, 0x01, 0x01, 0x48, 0xde, 0x1e, 0x29, 0x01, 0x41, + 0x4e, 0xbe, 0x7f, 0x3e, 0x01, 0x01, 0x4d, 0xca, 0x8d, 0x3f, 0x01, 0x41, + 0x56, 0xb9, 0x35, 0x01, 0x21, 0x00, 0x4e, 0xce, 0x7b, 0x79, 0xfa, 0x01, + 0x48, 0x7f, 0xcc, 0x2c, 0x26, 0x00, 0x04, 0x1a, 0x15, 0x14, 0xad, 0x06, + 0x43, 0xb7, 0x04, 0xd1, 0xf9, 0x41, 0x44, 0x3b, 0x89, 0xe5, 0x2b, 0x00, + 0x4e, 0x76, 0x7c, 0x9f, 0xf3, 0x41, 0x4f, 0xbf, 0x6d, 0x44, 0xe9, 0x01, + 0xa3, 0xd7, 0x02, 0x06, 0xef, 0x06, 0x90, 0x02, 0x07, 0xad, 0x70, 0xff, + 0x01, 0x45, 0x56, 0x00, 0x47, 0xe9, 0x01, 0x08, 0x86, 0x17, 0xe8, 0x01, + 0xae, 0xd9, 0x01, 0x0d, 0x9b, 0x08, 0x06, 0x50, 0x9a, 0x6b, 0x45, 0xe9, + 0x41, 0x44, 0xbf, 0x6d, 0x22, 0xe9, 0x01, 0xa2, 0xbc, 0x01, 0x43, 0x47, + 0x17, 0x37, 0xe9, 0x01, 0xa4, 0xa7, 0x01, 0xe5, 0x2b, 0xe9, 0x01, 0x42, + 0x0c, 0x08, 0x2c, 0xe9, 0x01, 0xa7, 0x90, 0x01, 0x42, 0x22, 0x00, 0x38, + 0xe9, 0x01, 0xe9, 0x2d, 0xe9, 0x01, 0x44, 0x94, 0xf6, 0x36, 0xe9, 0x01, + 0xab, 0x6c, 0x44, 0xfa, 0x8d, 0x24, 0xe9, 0x01, 0x44, 0x20, 0xf7, 0x25, + 0xe9, 0x01, 0xae, 0x4c, 0xef, 0x2e, 0xe9, 0x01, 0x42, 0x6f, 0x02, 0x28, + 0xe9, 0x01, 0x44, 0x07, 0xf0, 0x39, 0xe9, 0x01, 0x42, 0x71, 0x00, 0x2a, + 0xe9, 0x01, 0xb3, 0x28, 0x42, 0x5c, 0x01, 0x3c, 0xe9, 0x01, 0xf5, 0x35, + 0xe9, 0x01, 0x42, 0x61, 0x0b, 0x3e, 0xe9, 0x01, 0x43, 0x1c, 0x8f, 0x31, + 0xe9, 0x01, 0xb9, 0x06, 0x43, 0x8b, 0xc7, 0x41, 0xe9, 0x41, 0xe1, 0x34, + 0xe9, 0x01, 0x42, 0xb0, 0x01, 0x30, 0xe9, 0x41, 0x42, 0x22, 0x00, 0x43, + 0xe9, 0x01, 0x49, 0x4d, 0xc0, 0x27, 0xe9, 0x41, 0x42, 0x22, 0x00, 0x3d, + 0xe9, 0x01, 0x42, 0x79, 0x08, 0x32, 0xe9, 0x01, 0x42, 0xdf, 0x23, 0x3b, + 0xe9, 0x41, 0x42, 0x12, 0x15, 0x33, 0xe9, 0x01, 0x42, 0x22, 0x00, 0x3f, + 0xe9, 0x01, 0x42, 0x9c, 0x01, 0x42, 0xe9, 0x41, 0xe1, 0x3a, 0xe9, 0x01, + 0x42, 0xb7, 0x05, 0x40, 0xe9, 0x41, 0x44, 0x5e, 0x2e, 0x23, 0xe9, 0x01, + 0x42, 0x22, 0x00, 0x2f, 0xe9, 0x41, 0xe1, 0x26, 0xe9, 0x01, 0x42, 0xb0, + 0x01, 0x29, 0xe9, 0x41, 0x50, 0xf3, 0x5e, 0x4b, 0xe9, 0x01, 0x44, 0x63, + 0x41, 0x4a, 0xe9, 0x41, 0x50, 0xad, 0x00, 0x5e, 0xe9, 0x01, 0x4d, 0x88, + 0x36, 0x5f, 0xe9, 0x41, 0x54, 0x03, 0x44, 0x49, 0xe9, 0x01, 0x48, 0xb5, + 0x00, 0x46, 0xe9, 0x41, 0x45, 0x7e, 0x0b, 0x58, 0xe9, 0x01, 0xa6, 0x2e, + 0x44, 0x6d, 0x2c, 0x59, 0xe9, 0x01, 0x43, 0x7a, 0x0b, 0x51, 0xe9, 0x01, + 0xb3, 0x14, 0xb4, 0x06, 0x44, 0x80, 0x1f, 0x50, 0xe9, 0x41, 0x44, 0x25, + 0x01, 0x53, 0xe9, 0x01, 0x42, 0x15, 0x02, 0x52, 0xe9, 0x41, 0x44, 0x06, + 0x1f, 0x57, 0xe9, 0x01, 0x42, 0x09, 0x24, 0x56, 0xe9, 0x41, 0x43, 0xf9, + 0x05, 0x55, 0xe9, 0x01, 0x43, 0xf6, 0x06, 0x54, 0xe9, 0x41, 0x0e, 0x0c, + 0x06, 0x06, 0x51, 0xf4, 0x34, 0x48, 0xe9, 0x41, 0x44, 0xbf, 0x6d, 0x00, + 0xe9, 0x01, 0xa2, 0xbc, 0x01, 0x43, 0x47, 0x17, 0x15, 0xe9, 0x01, 0xa4, + 0xa7, 0x01, 0xe5, 0x09, 0xe9, 0x01, 0x42, 0x0c, 0x08, 0x0a, 0xe9, 0x01, + 0xa7, 0x90, 0x01, 0x42, 0x22, 0x00, 0x16, 0xe9, 0x01, 0xe9, 0x0b, 0xe9, + 0x01, 0x44, 0x94, 0xf6, 0x14, 0xe9, 0x01, 0xab, 0x6c, 0x44, 0xfa, 0x8d, + 0x02, 0xe9, 0x01, 0x44, 0x20, 0xf7, 0x03, 0xe9, 0x01, 0xae, 0x4c, 0xef, + 0x0c, 0xe9, 0x01, 0x42, 0x6f, 0x02, 0x06, 0xe9, 0x01, 0x44, 0x07, 0xf0, + 0x17, 0xe9, 0x01, 0x42, 0x71, 0x00, 0x08, 0xe9, 0x01, 0xb3, 0x28, 0x42, + 0x5c, 0x01, 0x1a, 0xe9, 0x01, 0xf5, 0x13, 0xe9, 0x01, 0x42, 0x61, 0x0b, + 0x1c, 0xe9, 0x01, 0x43, 0x1c, 0x8f, 0x0f, 0xe9, 0x01, 0xb9, 0x06, 0x43, + 0x8b, 0xc7, 0x1f, 0xe9, 0x41, 0xe1, 0x12, 0xe9, 0x01, 0x42, 0xb0, 0x01, + 0x0e, 0xe9, 0x41, 0x42, 0x22, 0x00, 0x21, 0xe9, 0x01, 0x49, 0x4d, 0xc0, + 0x05, 0xe9, 0x41, 0x42, 0x22, 0x00, 0x1b, 0xe9, 0x01, 0x42, 0x79, 0x08, + 0x10, 0xe9, 0x01, 0x42, 0xdf, 0x23, 0x19, 0xe9, 0x41, 0x42, 0x12, 0x15, + 0x11, 0xe9, 0x01, 0x42, 0x22, 0x00, 0x1d, 0xe9, 0x01, 0x42, 0x9c, 0x01, + 0x20, 0xe9, 0x41, 0xe1, 0x18, 0xe9, 0x01, 0x42, 0xb7, 0x05, 0x1e, 0xe9, + 0x41, 0x44, 0x5e, 0x2e, 0x01, 0xe9, 0x01, 0x42, 0x22, 0x00, 0x0d, 0xe9, + 0x41, 0xe1, 0x04, 0xe9, 0x01, 0x42, 0xb0, 0x01, 0x07, 0xe9, 0x41, 0x48, + 0x99, 0x2f, 0xe6, 0x23, 0x00, 0x02, 0x13, 0x05, 0x2c, 0xeb, 0x06, 0x00, + 0x80, 0x21, 0x07, 0x5b, 0xdc, 0x11, 0x05, 0x1e, 0x3b, 0x01, 0xff, 0x45, + 0xdb, 0x04, 0xb4, 0x00, 0x00, 0x44, 0x05, 0x02, 0x9f, 0x29, 0x40, 0x53, + 0x5f, 0x4a, 0x6d, 0x20, 0x00, 0x52, 0x07, 0x58, 0x6b, 0x20, 0x40, 0x48, + 0x57, 0x54, 0x06, 0x00, 0x40, 0x45, 0x2a, 0xf0, 0x97, 0xfa, 0x01, 0x46, + 0xfe, 0x6d, 0x00, 0x21, 0x40 }; static const cppchar_t uname2c_pairs[] = { 0xac00, 0xd7a3 /* HANGUL SYLLABLE */, 0, @@ -19440,7 +19862,7 @@ static const cppchar_t uname2c_pairs[] = { 0x4e00, 0x9fff /* CJK UNIFIED IDEOGRAPH- */, 0x20000, 0x2a6df /* CJK UNIFIED IDEOGRAPH- */, 0x2a700, 0x2b73f /* CJK UNIFIED IDEOGRAPH- */, - 0x2b740, 0x2b81d /* CJK UNIFIED IDEOGRAPH- */, + 0x2b740, 0x2b81e /* CJK UNIFIED IDEOGRAPH- */, 0x2b820, 0x2cead /* CJK UNIFIED IDEOGRAPH- */, 0x2ceb0, 0x2ebe0 /* CJK UNIFIED IDEOGRAPH- */, 0x2ebf0, 0x2ee5d /* CJK UNIFIED IDEOGRAPH- */, @@ -19449,9 +19871,11 @@ static const cppchar_t uname2c_pairs[] = { 0x323b0, 0x33479 /* CJK UNIFIED IDEOGRAPH- */, 0, 0x13460, 0x143fa /* EGYPTIAN HIEROGLYPH- */, 0, 0x17000, 0x187ff /* TANGUT IDEOGRAPH- */, - 0x18d00, 0x18d1e /* TANGUT IDEOGRAPH- */, 0, - 0x18b00, 0x18cd5 /* KHITAN SMALL SCRIPT CHARACTER- */, 0, + 0x18d00, 0x18d20 /* TANGUT IDEOGRAPH- */, 0, + 0x18b00, 0x18cda /* KHITAN SMALL SCRIPT CHARACTER- */, 0, + 0x18e00, 0x19191 /* JURCHEN CHARACTER- */, 0, 0x1b170, 0x1b2fb /* NUSHU CHARACTER- */, 0, + 0x3d000, 0x3fc3f /* SMALL SEAL CHARACTER- */, 0, 0xf900, 0xfa6d /* CJK COMPATIBILITY IDEOGRAPH- */, 0xfa70, 0xfad9 /* CJK COMPATIBILITY IDEOGRAPH- */, 0x2f800, 0x2fa1d /* CJK COMPATIBILITY IDEOGRAPH- */, 0 }; @@ -19462,8 +19886,10 @@ static const unsigned char uname2c_generated[] = { 26 /* EGYPTIAN HIEROGLYPH- */, 29 /* TANGUT IDEOGRAPH- */, 34 /* KHITAN SMALL SCRIPT CHARACTER- */, - 37 /* NUSHU CHARACTER- */, - 40 /* CJK COMPATIBILITY IDEOGRAPH- */ }; + 37 /* JURCHEN CHARACTER- */, + 40 /* NUSHU CHARACTER- */, + 43 /* SMALL SEAL CHARACTER- */, + 46 /* CJK COMPATIBILITY IDEOGRAPH- */ }; static const unsigned int uname2c_max_name_len = 88; diff --git a/libstdc++-v3/include/bits/unicode-data.h b/libstdc++-v3/include/bits/unicode-data.h index 45a68de3edb7..ede2614bf803 100644 --- a/libstdc++-v3/include/bits/unicode-data.h +++ b/libstdc++-v3/include/bits/unicode-data.h @@ -29,7 +29,7 @@ #ifndef _GLIBCXX_GET_UNICODE_DATA # error "This is not a public header, do not include it directly" -#elif _GLIBCXX_GET_UNICODE_DATA != 160000 +#elif _GLIBCXX_GET_UNICODE_DATA != 180000 # error "Version mismatch for Unicode static data" #endif @@ -51,17 +51,18 @@ 0x3250, 0xa48d, 0xa490, 0xa4c7, 0xa960, 0xa97d, 0xac00, 0xd7a4, 0xf900, 0xfb00, 0xfe10, 0xfe1a, 0xfe30, 0xfe53, 0xfe54, 0xfe67, 0xfe68, 0xfe6c, 0xff01, 0xff61, 0xffe0, 0xffe7, 0x16fe0, 0x16fe5, - 0x16ff0, 0x16ff7, 0x17000, 0x18cd6, 0x18cff, 0x18d1f, 0x18d80, 0x18df3, - 0x1aff0, 0x1aff4, 0x1aff5, 0x1affc, 0x1affd, 0x1afff, 0x1b000, 0x1b123, - 0x1b132, 0x1b133, 0x1b150, 0x1b153, 0x1b155, 0x1b156, 0x1b164, 0x1b168, - 0x1b170, 0x1b2fc, 0x1d300, 0x1d357, 0x1d360, 0x1d377, 0x1f004, 0x1f005, - 0x1f0cf, 0x1f0d0, 0x1f18e, 0x1f18f, 0x1f191, 0x1f19b, 0x1f200, 0x1f203, - 0x1f210, 0x1f23c, 0x1f240, 0x1f249, 0x1f250, 0x1f252, 0x1f260, 0x1f266, - 0x1f300, 0x1f650, 0x1f680, 0x1f6c6, 0x1f6cc, 0x1f6cd, 0x1f6d0, 0x1f6d3, - 0x1f6d5, 0x1f6d9, 0x1f6dc, 0x1f6e0, 0x1f6eb, 0x1f6ed, 0x1f6f4, 0x1f6fd, + 0x16ff0, 0x16ff7, 0x17000, 0x18cdb, 0x18cff, 0x18d21, 0x18d80, 0x18df3, + 0x18e00, 0x19192, 0x191a0, 0x191d3, 0x1aff0, 0x1aff4, 0x1aff5, 0x1affc, + 0x1affd, 0x1afff, 0x1b000, 0x1b129, 0x1b132, 0x1b133, 0x1b150, 0x1b153, + 0x1b155, 0x1b156, 0x1b164, 0x1b169, 0x1b170, 0x1b2fc, 0x1d300, 0x1d357, + 0x1d360, 0x1d377, 0x1f004, 0x1f005, 0x1f0cf, 0x1f0d0, 0x1f18e, 0x1f18f, + 0x1f191, 0x1f19b, 0x1f1ae, 0x1f1af, 0x1f200, 0x1f203, 0x1f210, 0x1f23c, + 0x1f240, 0x1f249, 0x1f250, 0x1f252, 0x1f260, 0x1f266, 0x1f300, 0x1f650, + 0x1f680, 0x1f6c6, 0x1f6cc, 0x1f6cd, 0x1f6d0, 0x1f6d3, 0x1f6d5, 0x1f6da, + 0x1f6dc, 0x1f6e0, 0x1f6eb, 0x1f6ed, 0x1f6f4, 0x1f6fd, 0x1f7da, 0x1f7db, 0x1f7e0, 0x1f7ec, 0x1f7f0, 0x1f7f1, 0x1f900, 0x1fa00, 0x1fa70, 0x1fa7d, - 0x1fa80, 0x1fa8b, 0x1fa8e, 0x1fac7, 0x1fac8, 0x1fac9, 0x1facd, 0x1fadd, - 0x1fadf, 0x1faeb, 0x1faef, 0x1faf9, 0x20000, 0x2fffe, 0x30000, 0x3fffe, + 0x1fa80, 0x1fac7, 0x1fac8, 0x1fac9, 0x1facc, 0x1fade, 0x1fadf, 0x1faec, + 0x1faef, 0x1fafb, 0x20000, 0x2fffe, 0x30000, 0x3fffe, }; // Values generated by contrib/unicode/gen_libstdcxx_unicode_data.py, @@ -632,7 +633,7 @@ }; inline constexpr char32_t __incb_linkers[] = { - 0x094d, 0x09cd, 0x0acd, 0x0b4d, 0x0c4d, 0x0d4d, 0x1039, 0x17d2, 0x1a60, 0x1b44, 0x1bab, 0xa9c0, 0xaaf6, 0x10a3f, 0x11133, 0x113d0, 0x1193e, 0x11a47, 0x11a99, 0x11f42, + 0x094d, 0x09cd, 0x0acd, 0x0b4d, 0x0c4d, 0x0d4d, 0x1039, 0x17d2, 0x1a60, 0x1b44, 0x1bab, 0x1cf5, 0x1cf6, 0xa9c0, 0xaaf6, 0x10a3f, 0x11133, 0x113d0, 0x1193e, 0x11a3a, 0x11a47, 0x11a99, 0x11f42, }; enum class _InCB { _Consonant = 1, _Extend = 2 }; @@ -643,7 +644,7 @@ inline constexpr uint32_t __incb_edges[] = { 0xc02, 0xdc0, 0x120e, 0x1228, 0x1646, 0x16f8, 0x16fe, 0x1700, 0x1706, 0x170c, 0x1712, 0x1718, - 0x171e, 0x1720, 0x1842, 0x186c, 0x192e, 0x1980, + 0x171e, 0x1728, 0x1842, 0x186c, 0x192e, 0x1980, 0x19c2, 0x19c4, 0x1b5a, 0x1b74, 0x1b7e, 0x1b94, 0x1b9e, 0x1ba4, 0x1baa, 0x1bb8, 0x1c46, 0x1c48, 0x1cc2, 0x1d2c, 0x1e9a, 0x1ec4, 0x1fae, 0x1fd0, @@ -665,7 +666,7 @@ 0x2b1e, 0x2b24, 0x2b8a, 0x2b90, 0x2be5, 0x2bea, 0x2c00, 0x2c06, 0x2c08, 0x2c55, 0x2ca4, 0x2ca9, 0x2cc4, 0x2cc9, 0x2cd0, 0x2cd5, 0x2ce8, 0x2cf2, - 0x2cf4, 0x2cfa, 0x2d00, 0x2d06, 0x2d14, 0x2d56, + 0x2cf4, 0x2cfa, 0x2d00, 0x2d06, 0x2d14, 0x2d4e, 0x2d60, 0x2d71, 0x2d78, 0x2d7d, 0x2d80, 0x2d8a, 0x2d90, 0x2dc5, 0x2dc8, 0x2e0a, 0x2e0c, 0x2efa, 0x2efc, 0x2f02, 0x2f04, 0x2f36, 0x2f38, 0x2f5e, @@ -700,39 +701,39 @@ 0x6864, 0x686e, 0x6870, 0x6881, 0x6954, 0x695a, 0x695c, 0x6962, 0x697c, 0x698a, 0x698c, 0x6996, 0x69b4, 0x69ce, 0x69f4, 0x69fe, 0x6a00, 0x6ac2, - 0x6b78, 0x6b82, 0x6bb0, 0x6c02, 0x6c10, 0x6c2d, - 0x6c34, 0x6c4d, 0x6cd2, 0x6cf8, 0x6d0a, 0x6d10, - 0x6d15, 0x6d34, 0x6dae, 0x6dd0, 0x6e02, 0x6e08, - 0x6e0d, 0x6e84, 0x6e8a, 0x6e98, 0x6ea2, 0x6eac, - 0x6eb2, 0x6eb9, 0x6ec0, 0x6eed, 0x6ef8, 0x6f9a, - 0x6f9c, 0x6fa2, 0x6fa8, 0x6fb6, 0x6fb8, 0x6fbe, - 0x6fd0, 0x70b2, 0x70d0, 0x70da, 0x70e0, 0x7342, - 0x734c, 0x7352, 0x7384, 0x738a, 0x73a4, 0x73b6, - 0x73b8, 0x73d2, 0x73d4, 0x73e2, 0x73e8, 0x7702, - 0x7800, 0x8036, 0x8038, 0x8342, 0x83c4, 0xb3be, - 0xb3c8, 0xb5fe, 0xb600, 0xb782, 0xb800, 0xc0aa, - 0xc0c0, 0xc266, 0xc26c, 0x299be, 0x299cc, 0x299d2, - 0x299f8, 0x29a7a, 0x29a80, 0x29bc2, 0x29bc8, 0x2a00a, - 0x2a00c, 0x2a01a, 0x2a01c, 0x2a02e, 0x2a030, 0x2a096, - 0x2a09c, 0x2a0b2, 0x2a0b4, 0x2a312, 0x2a318, 0x2a382, - 0x2a3c8, 0x2a3fe, 0x2a400, 0x2a49a, 0x2a4b8, 0x2a51e, - 0x2a548, 0x2a54e, 0x2a550, 0x2a602, 0x2a60c, 0x2a625, - 0x2a630, 0x2a63d, 0x2a6ce, 0x2a6d0, 0x2a6da, 0x2a6e8, - 0x2a6f2, 0x2a6f8, 0x2a781, 0x2a796, 0x2a798, 0x2a79d, - 0x2a7c0, 0x2a7e9, 0x2a7fc, 0x2a8a6, 0x2a8bc, 0x2a8c6, - 0x2a8cc, 0x2a8d6, 0x2a8dc, 0x2a90e, 0x2a910, 0x2a932, - 0x2a934, 0x2a981, 0x2a9c0, 0x2a9c5, 0x2a9d0, 0x2a9e9, - 0x2a9ec, 0x2a9f2, 0x2a9f4, 0x2a9f9, 0x2aa00, 0x2aac2, - 0x2aac4, 0x2aaca, 0x2aad4, 0x2aade, 0x2aae4, 0x2aafa, - 0x2ab00, 0x2ab06, 0x2ab08, 0x2ab81, 0x2abac, 0x2abb2, - 0x2abb8, 0x2af01, 0x2af6c, 0x2af96, 0x2af98, 0x2afa2, - 0x2afa4, 0x2afb6, 0x2afb8, 0x3ec7a, 0x3ec7c, 0x3f802, - 0x3f840, 0x3f882, 0x3f8c0, 0x3fe7a, 0x3fe80, 0x407f6, - 0x407f8, 0x40b82, 0x40b84, 0x40dda, 0x40dec, 0x42801, - 0x42806, 0x42810, 0x42816, 0x4281c, 0x42832, 0x42841, - 0x42850, 0x42855, 0x42860, 0x42865, 0x428d8, 0x428e2, - 0x428ec, 0x42b96, 0x42b9c, 0x43492, 0x434a0, 0x435a6, - 0x435b8, 0x43aae, 0x43ab4, 0x43bea, 0x43c00, 0x43d1a, + 0x6bc4, 0x6c02, 0x6c10, 0x6c2d, 0x6c34, 0x6c4d, + 0x6cd2, 0x6cf8, 0x6d0a, 0x6d10, 0x6d15, 0x6d34, + 0x6dae, 0x6dd0, 0x6e02, 0x6e08, 0x6e0d, 0x6e84, + 0x6e8a, 0x6e98, 0x6ea2, 0x6eac, 0x6eb2, 0x6eb9, + 0x6ec0, 0x6eed, 0x6ef8, 0x6f9a, 0x6f9c, 0x6fa2, + 0x6fa8, 0x6fb6, 0x6fb8, 0x6fbe, 0x6fd0, 0x70b2, + 0x70d0, 0x70da, 0x70e0, 0x7342, 0x734c, 0x7352, + 0x7384, 0x738a, 0x73a4, 0x73b6, 0x73b8, 0x73d2, + 0x73d4, 0x73e2, 0x73e8, 0x7702, 0x7800, 0x8036, + 0x8038, 0x8342, 0x83c4, 0xb3be, 0xb3c8, 0xb5fe, + 0xb600, 0xb782, 0xb800, 0xc0aa, 0xc0c0, 0xc266, + 0xc26c, 0x299be, 0x299cc, 0x299d2, 0x299f8, 0x29a7a, + 0x29a80, 0x29bc2, 0x29bc8, 0x2a00a, 0x2a00c, 0x2a01a, + 0x2a01c, 0x2a02e, 0x2a030, 0x2a096, 0x2a09c, 0x2a0b2, + 0x2a0b4, 0x2a312, 0x2a318, 0x2a382, 0x2a3c8, 0x2a3fe, + 0x2a400, 0x2a49a, 0x2a4b8, 0x2a51e, 0x2a548, 0x2a54e, + 0x2a550, 0x2a602, 0x2a60c, 0x2a625, 0x2a630, 0x2a63d, + 0x2a6ce, 0x2a6d0, 0x2a6da, 0x2a6e8, 0x2a6f2, 0x2a6f8, + 0x2a781, 0x2a796, 0x2a798, 0x2a79d, 0x2a7c0, 0x2a7e9, + 0x2a7fc, 0x2a8a6, 0x2a8bc, 0x2a8c6, 0x2a8cc, 0x2a8d6, + 0x2a8dc, 0x2a90e, 0x2a910, 0x2a932, 0x2a934, 0x2a981, + 0x2a9c0, 0x2a9c5, 0x2a9d0, 0x2a9e9, 0x2a9ec, 0x2a9f2, + 0x2a9f4, 0x2a9f9, 0x2aa00, 0x2aac2, 0x2aac4, 0x2aaca, + 0x2aad4, 0x2aade, 0x2aae4, 0x2aafa, 0x2ab00, 0x2ab06, + 0x2ab08, 0x2ab81, 0x2abac, 0x2abb2, 0x2abb8, 0x2af01, + 0x2af6c, 0x2af96, 0x2af98, 0x2afa2, 0x2afa4, 0x2afb6, + 0x2afb8, 0x3ec7a, 0x3ec7c, 0x3f802, 0x3f840, 0x3f882, + 0x3f8c0, 0x3fe7a, 0x3fe80, 0x407f6, 0x407f8, 0x40b82, + 0x40b84, 0x40dda, 0x40dec, 0x42801, 0x42806, 0x42810, + 0x42816, 0x4281c, 0x42832, 0x42841, 0x42850, 0x42855, + 0x42860, 0x42865, 0x428d8, 0x428e2, 0x428ec, 0x42b96, + 0x42b9c, 0x43492, 0x434a0, 0x435a6, 0x435b8, 0x43aae, + 0x43ab4, 0x43b2e, 0x43b40, 0x43bc2, 0x43c00, 0x43d1a, 0x43d44, 0x43e0a, 0x43e18, 0x44006, 0x44008, 0x440e2, 0x4411c, 0x441c2, 0x441c4, 0x441ce, 0x441d4, 0x441fe, 0x44208, 0x442ce, 0x442dc, 0x442e6, 0x442ec, 0x4430a, @@ -764,30 +765,32 @@ 0x46782, 0x46784, 0x46801, 0x46806, 0x4682d, 0x468ce, 0x468e4, 0x468ee, 0x468fc, 0x46941, 0x46946, 0x4695c, 0x46966, 0x46971, 0x46a10, 0x46a2a, 0x46a5c, 0x46a62, - 0x46a64, 0x46d82, 0x46d84, 0x46d8a, 0x46d94, 0x46d9a, - 0x46d9c, 0x470c2, 0x470dc, 0x470e2, 0x470f8, 0x470fe, - 0x47100, 0x4724a, 0x472a0, 0x472aa, 0x472c4, 0x472ca, - 0x472d0, 0x472d6, 0x472dc, 0x474c6, 0x474dc, 0x474ea, - 0x474ec, 0x474f2, 0x474f8, 0x474fe, 0x47518, 0x4751e, - 0x47520, 0x47642, 0x47648, 0x47656, 0x47658, 0x4765e, - 0x47660, 0x47bce, 0x47bd4, 0x47c02, 0x47c08, 0x47c11, - 0x47c44, 0x47c49, 0x47cd0, 0x47cda, 0x47cec, 0x47d02, - 0x47d08, 0x47d6a, 0x47d6c, 0x4d102, 0x4d104, 0x4d11e, - 0x4d158, 0x5847a, 0x584a8, 0x584b6, 0x584c0, 0x5abc2, - 0x5abd4, 0x5acc2, 0x5acdc, 0x5bd3e, 0x5bd40, 0x5be3e, - 0x5be4c, 0x5bf92, 0x5bf94, 0x5bfc2, 0x5bfc8, 0x6f276, - 0x6f27c, 0x73c02, 0x73cb8, 0x73cc2, 0x73d1c, 0x74596, - 0x745a8, 0x745b6, 0x745cc, 0x745ee, 0x7460c, 0x74616, - 0x74630, 0x746aa, 0x746b8, 0x7490a, 0x74914, 0x76802, - 0x768dc, 0x768ee, 0x769b4, 0x769d6, 0x769d8, 0x76a12, - 0x76a14, 0x76a6e, 0x76a80, 0x76a86, 0x76ac0, 0x78002, - 0x7801c, 0x78022, 0x78064, 0x7806e, 0x78088, 0x7808e, - 0x78094, 0x7809a, 0x780ac, 0x7823e, 0x78240, 0x784c2, - 0x784dc, 0x78aba, 0x78abc, 0x78bb2, 0x78bc0, 0x793b2, - 0x793c0, 0x797ba, 0x797c0, 0x79b8e, 0x79b90, 0x79b9a, - 0x79b9c, 0x79bba, 0x79bc0, 0x79bd6, 0x79bd8, 0x7a342, - 0x7a35c, 0x7a512, 0x7a52c, 0x7cfee, 0x7d000, 0x380082, - 0x380200, 0x380402, 0x3807c0, + 0x46a64, 0x46c29, 0x46c2c, 0x46d82, 0x46d84, 0x46d8a, + 0x46d94, 0x46d9a, 0x46d9c, 0x470c2, 0x470dc, 0x470e2, + 0x470f8, 0x470fe, 0x47100, 0x4724a, 0x472a0, 0x472aa, + 0x472c4, 0x472ca, 0x472d0, 0x472d6, 0x472dc, 0x474c6, + 0x474dc, 0x474ea, 0x474ec, 0x474f2, 0x474f8, 0x474fe, + 0x47518, 0x4751e, 0x47520, 0x47642, 0x47648, 0x47656, + 0x47658, 0x4765e, 0x47660, 0x477c2, 0x477c5, 0x477c8, + 0x47bce, 0x47bd4, 0x47c02, 0x47c08, 0x47c11, 0x47c44, + 0x47c49, 0x47cd0, 0x47cda, 0x47cec, 0x47d02, 0x47d08, + 0x47d6a, 0x47d6c, 0x4d102, 0x4d104, 0x4d11e, 0x4d158, + 0x5847a, 0x584a8, 0x584b6, 0x584c0, 0x5abc2, 0x5abd4, + 0x5acc2, 0x5acdc, 0x5bd3e, 0x5bd40, 0x5be3e, 0x5be4c, + 0x5bf92, 0x5bf94, 0x5bfc2, 0x5bfc8, 0x6f276, 0x6f27c, + 0x73c02, 0x73cb8, 0x73cc2, 0x73d1c, 0x7449e, 0x744a4, + 0x74596, 0x745a8, 0x745b6, 0x745cc, 0x745ee, 0x7460c, + 0x74616, 0x74630, 0x746aa, 0x746b8, 0x7490a, 0x74914, + 0x74942, 0x7494c, 0x7496e, 0x74974, 0x7497e, 0x74980, + 0x74a02, 0x74a08, 0x76802, 0x768dc, 0x768ee, 0x769b4, + 0x769d6, 0x769d8, 0x76a12, 0x76a14, 0x76a6e, 0x76a80, + 0x76a86, 0x76ac0, 0x78002, 0x7801c, 0x78022, 0x78064, + 0x7806e, 0x78088, 0x7808e, 0x78094, 0x7809a, 0x780ac, + 0x7823e, 0x78240, 0x784c2, 0x784dc, 0x78aba, 0x78abc, + 0x78bb2, 0x78bc0, 0x793b2, 0x793c0, 0x797ba, 0x797c0, + 0x79b8e, 0x79b90, 0x79b9a, 0x79b9c, 0x79bba, 0x79bc0, + 0x79bd6, 0x79bd8, 0x7a342, 0x7a35c, 0x7a512, 0x7a52c, + 0x7cfee, 0x7d000, 0x380082, 0x380200, 0x380402, 0x3807c0, }; // Table generated by contrib/unicode/gen_libstdcxx_unicode_data.py, @@ -817,7 +820,7 @@ 0x303d, 0x303e, 0x3297, 0x3298, 0x3299, 0x329a, 0x1f004, 0x1f005, 0x1f02c, 0x1f030, 0x1f094, 0x1f0a0, 0x1f0af, 0x1f0b1, 0x1f0c0, 0x1f0c1, 0x1f0cf, 0x1f0d1, 0x1f0f6, 0x1f100, 0x1f170, 0x1f172, 0x1f17e, 0x1f180, - 0x1f18e, 0x1f18f, 0x1f191, 0x1f19b, 0x1f1ae, 0x1f1e6, 0x1f201, 0x1f210, + 0x1f18e, 0x1f18f, 0x1f191, 0x1f19b, 0x1f1af, 0x1f1e6, 0x1f201, 0x1f210, 0x1f21a, 0x1f21b, 0x1f22f, 0x1f230, 0x1f232, 0x1f23b, 0x1f23c, 0x1f240, 0x1f249, 0x1f260, 0x1f266, 0x1f322, 0x1f324, 0x1f394, 0x1f396, 0x1f398, 0x1f399, 0x1f39c, 0x1f39e, 0x1f3f1, 0x1f3f3, 0x1f3f6, 0x1f3f7, 0x1f3fb, @@ -828,7 +831,7 @@ 0x1f5dc, 0x1f5df, 0x1f5e1, 0x1f5e2, 0x1f5e3, 0x1f5e4, 0x1f5e8, 0x1f5e9, 0x1f5ef, 0x1f5f0, 0x1f5f3, 0x1f5f4, 0x1f5fa, 0x1f650, 0x1f680, 0x1f6c6, 0x1f6cb, 0x1f6d3, 0x1f6d5, 0x1f6e6, 0x1f6e9, 0x1f6ea, 0x1f6eb, 0x1f6f1, - 0x1f6f3, 0x1f700, 0x1f7da, 0x1f800, 0x1f80c, 0x1f810, 0x1f848, 0x1f850, + 0x1f6f3, 0x1f700, 0x1f7dc, 0x1f7f1, 0x1f80c, 0x1f810, 0x1f848, 0x1f850, 0x1f85a, 0x1f860, 0x1f888, 0x1f890, 0x1f8ae, 0x1f8b0, 0x1f8bc, 0x1f8c0, 0x1f8c2, 0x1f8d0, 0x1f8d9, 0x1f900, 0x1f90c, 0x1f93b, 0x1f93c, 0x1f946, 0x1f947, 0x1fa00, 0x1fa58, 0x1fa60, 0x1fa6e, 0x1fb00, 0x1fc00, 0x1fffe, diff --git a/libstdc++-v3/include/bits/unicode.h b/libstdc++-v3/include/bits/unicode.h index 8f414f1091e7..2444cb268e61 100644 --- a/libstdc++-v3/include/bits/unicode.h +++ b/libstdc++-v3/include/bits/unicode.h @@ -753,9 +753,9 @@ namespace __unicode template using _Utf32_view = _Utf_view; -inline namespace __v16_0_0 +inline namespace __v18_0_0 { -#define _GLIBCXX_GET_UNICODE_DATA 160000 +#define _GLIBCXX_GET_UNICODE_DATA 180000 #include "unicode-data.h" #ifdef _GLIBCXX_GET_UNICODE_DATA # error "Invalid unicode data" @@ -1118,7 +1118,7 @@ inline namespace __v16_0_0 _Iterator _M_begin; }; -} // namespace __v16_0_0 +} // namespace __v18_0_0 // Return the field width of a string. template diff --git a/libstdc++-v3/testsuite/ext/unicode/properties.cc b/libstdc++-v3/testsuite/ext/unicode/properties.cc index 120192d59f5c..1c107a2cc5d9 100644 --- a/libstdc++-v3/testsuite/ext/unicode/properties.cc +++ b/libstdc++-v3/testsuite/ext/unicode/properties.cc @@ -53,7 +53,7 @@ static_assert( uc::__field_width(U'\U0001FA00') == 1 ); static_assert( uc::__field_width(U'\U0001FA69') == 1 ); static_assert( uc::__field_width(U'\U0001FA70') == 2 ); static_assert( uc::__field_width(U'\U0001FAF8') == 2 ); -static_assert( uc::__field_width(U'\U0001FAF9') == 1 ); +static_assert( uc::__field_width(U'\U0001FAF9') == 2 ); using enum uc::_Gcb_property; static_assert( uc::__grapheme_cluster_break_property(U'\0') == _Gcb_Control ); From bca597522679903c66f28afff49971663a37ab37 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Fri, 18 Sep 2026 09:18:15 +0200 Subject: [PATCH 177/584] tree-optimization/126306 - delay BB vectorization SLP discovery soft fail The following delays SLP discovery failure due to required unrolling when doing BB vectorization to after we have also analyzed the defs which can provide indication for where to best split the group. This does not add meaningful to compile-time or eats from the SLP discovery budget and can handle simple cases as shown in the testcase. The case in the PR requires a followup which does have such downside. PR tree-optimization/126306 * tree-vect-slp.cc (vect_build_slp_tree_1): Remove soft-failing. (vect_build_slp_tree_2): Add soft-failing here, delayed to after vect_get_and_check_slp_defs. (vect_get_and_check_slp_defs): When we'll soft-fail do not fall back to vect_external_def on mismatches. * gcc.dg/vect/bb-slp-pr126306-1.c: New testcase. --- gcc/testsuite/gcc.dg/vect/bb-slp-pr126306-1.c | 17 +++++ gcc/tree-vect-slp.cc | 73 ++++++++++++++----- 2 files changed, 71 insertions(+), 19 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/vect/bb-slp-pr126306-1.c diff --git a/gcc/testsuite/gcc.dg/vect/bb-slp-pr126306-1.c b/gcc/testsuite/gcc.dg/vect/bb-slp-pr126306-1.c new file mode 100644 index 000000000000..a385c7560396 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/bb-slp-pr126306-1.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target vect_int } */ +/* { dg-additional-options "-fopt-info-vec" } */ + +int x[8], y[4]; + +void foo (void) +{ + /* We want to split the store group after the first two elements, not + after the first four. */ + x[2] = 1; /* { dg-optimized "basic block part vectorized using 8 byte vectors" { target vect64 } } */ + x[3] = 2; + x[4] = y[0]; /* { dg-optimized "basic block part vectorized using 16 byte vectors" { target vect128 } } */ + x[5] = y[1]; + x[6] = y[2]; + x[7] = y[3]; +} diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc index 06c241a75624..88368b5b86c2 100644 --- a/gcc/tree-vect-slp.cc +++ b/gcc/tree-vect-slp.cc @@ -698,7 +698,8 @@ static int vect_get_and_check_slp_defs (vec_info *vinfo, tree vectype, unsigned char swap, bool *skip_args, vec stmts, unsigned stmt_num, - vec *oprnds_info) + vec *oprnds_info, + bool soft_fail) { stmt_vec_info stmt_info = stmts[stmt_num]; tree oprnd; @@ -991,7 +992,8 @@ vect_get_and_check_slp_defs (vec_info *vinfo, tree vectype, unsigned char swap, if (is_a (vinfo) && !oprnd_info->any_pattern - && number_of_oprnds > 1) + && number_of_oprnds > 1 + && !soft_fail) { /* Now for commutative ops we should see whether we can make the other operand matching. */ @@ -1730,24 +1732,22 @@ vect_build_slp_tree_1 (vec_info *vinfo, unsigned char *swap, /* Check nunits required but continue analysis, producing matches[] as if nunits was not an issue. This allows splitting of groups to happen. */ - bool maybe_soft_fail = false; unsigned HOST_WIDE_INT const_nunits = 0; if (vectype && is_a (vinfo) && !multiple_p (group_size, TYPE_VECTOR_SUBPARTS (vectype))) { - if (dump_enabled_p ()) - dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, - "Build SLP failed: unrolling required " - "in basic block SLP\n"); if (!TYPE_VECTOR_SUBPARTS (vectype).is_constant (&const_nunits) || const_nunits > group_size) { + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "Build SLP failed: unrolling required " + "in basic block SLP\n"); /* Fatal mismatch. */ matches[0] = -1; return false; } - maybe_soft_fail = true; } gcc_assert (vectype || !gimple_get_lhs (first_stmt_info->stmt)); @@ -1781,16 +1781,6 @@ vect_build_slp_tree_1 (vec_info *vinfo, unsigned char *swap, if (!res) return false; - if (maybe_soft_fail) - { - /* With constant vector elements simulate a mismatch at the - point we need to split. But indicate the tail is isomorphic. */ - unsigned tail = group_size & (const_nunits - 1); - for (unsigned i = group_size - tail; i < group_size; ++i) - matches[i] = (int)(group_size - tail); - return false; - } - return true; } @@ -2084,6 +2074,25 @@ vect_slp_build_two_operator_nodes (slp_tree perm, tree vectype, SLP_TREE_CHILDREN (perm).quick_push (child2); } +/* For isomorphic matches[], indicate a splitting point according to + CONST_NUNITS. */ + +static void +force_split_matches (match_elt_t *matches, unsigned group_size, + unsigned const_nunits) +{ + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "Build SLP failed: unrolling required " + "in basic block SLP\n"); + + /* With constant vector elements simulate a mismatch at the + point we need to split. But indicate the tail is isomorphic. */ + unsigned tail = group_size & (const_nunits - 1); + for (unsigned i = group_size - tail; i < group_size; ++i) + matches[i] = (int)(group_size - tail); +} + /* Recursively build an SLP tree starting from NODE. Fail (and return a value not equal to zero) if def-stmts are not isomorphic, require data permutation or are of unsupported types of @@ -2185,10 +2194,20 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, &vectype)) return NULL; + bool soft_fail + = (is_a (vinfo) + && !multiple_p (group_size, TYPE_VECTOR_SUBPARTS (vectype))); + /* If the SLP node is a load, terminate the recursion unless masked. */ if (STMT_VINFO_DATA_REF (stmt_info) && DR_IS_READ (STMT_VINFO_DATA_REF (stmt_info))) { + if (soft_fail) + { + force_split_matches (matches, group_size, + TYPE_VECTOR_SUBPARTS (vectype).to_constant ()); + return NULL; + } if (STMT_VINFO_GATHER_SCATTER_P (stmt_info)) gcc_assert (DR_IS_READ (STMT_VINFO_DATA_REF (stmt_info))); else @@ -2319,6 +2338,12 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, && !gimple_vuse (stmt_info->stmt) && gimple_assign_rhs_code (stmt_info->stmt) == BIT_FIELD_REF) { + if (soft_fail) + { + force_split_matches (matches, group_size, + TYPE_VECTOR_SUBPARTS (vectype).to_constant ()); + return NULL; + } /* vect_build_slp_tree_2 determined all BIT_FIELD_REFs reference the same SSA name vector of a compatible type to vectype. */ vec > lperm = vNULL; @@ -2766,7 +2791,8 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, { int res = vect_get_and_check_slp_defs (vinfo, vectype, swap[i], skip_args, - stmts, i, &oprnds_info); + stmts, i, &oprnds_info, + soft_fail); if (res != 0) /* ??? This puts -1 back into matches[] and the cache. */ matches[(res == -1) ? 0 : i] = -1; @@ -2781,6 +2807,15 @@ vect_build_slp_tree_2 (vec_info *vinfo, slp_tree node, } swap = NULL; + /* Perform delayed soft-failing only here so we can factor in mismatches + determined by vect_get_and_check_slp_defs. */ + if (soft_fail) + { + force_split_matches (matches, group_size, + TYPE_VECTOR_SUBPARTS (vectype).to_constant ()); + return NULL; + } + bool has_two_operators_perm = false; auto_vec two_op_perm_indices[2]; vec two_op_scalar_stmts[2] = {vNULL, vNULL}; From d9d078c216150bbe0397ded72f035c35b476e88e Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Fri, 18 Sep 2026 11:03:28 +0200 Subject: [PATCH 178/584] bitintlower: Fix big-endian separate_ext loop condition [PR127378] On the following testcase on powerpc64-linux (both -m32 and -m64) we emit incorrect loop condition in the separate_ext loop. For little endian, we do the addition on the least significant 3 limbs (straight line code), 2 lowest limbs regular, the third on 7 bits and then sign extension, and then a separate_ext loop [local count: 1073741824]: # _34 = PHI <3(2), _35(3)> VIEW_CONVERT_EXPR(a)[_34] = _33; _35 = _34 + 1; if (_35 != 8) goto ; [0.05%] else goto ; [99.95%] to copy the sign extension into the remaining 5 limbs. On big endian, we do the least significant 3 limbs similarly (of course, the result is 512-bit, so with 56, 48, 40 instead of 0, 8, 16 on LE) and then do the separate_ext loop: [local count: 1073741824]: # _35 = PHI <4(2), _36(3)> VIEW_CONVERT_EXPR(a)[_35] = _34; _36 = _35 + 18446744073709551615; if (_36 != 0) goto ; [0.05%] else goto ; [99.95%] That is wrong, we start on limb 4 (i.e. offset 32) and go down until 1 (i.e. offset 8) rather than 0 (i.e. offset 0), because like in LE in this case we compare idx_next (idx + increment, in BE case -1) instead of idx. There was already code to handle specially BE rem != 0 case. Note, the starting offset is else if (i == (bo_shift != 0)) idx = create_loop (size_int (bo_idx + (bitint_big_endian ? total - 1 - start - i : start + i)), &idx_next); and we want to perform the same number of iterations on LE and BE, just the LE offsets bo_idx + start + i + I for I going from 0 up until bo_idx + start + i + I == bo_idx + end - 1 inclusive, while for BE they should be bo_idx + total - 1 - start - i - I for I going from 0 up until bo_idx + total - 1 - start - i - I == bo_idx + total - 1 - end + 1 inclusive. So, the BE correction is to add total - 1 and subtract instead of add the start + i up to end - 1 values. So, this patch uses the exact same BE correction, with one exception. If bo_idx + total - 1 - end + 1 is 0 (which is quite the common case, when bo_idx is 0 (e.g. whenever it is not a bit-field store) and bo_shift isn't non-zero either (again, e.g. no bit-field store) and rem == 0), I think comparing idx != 0 instead of idx_next != (size_t) -1 is faster (plus we'd in the evaluation need to care about types of all the addends, do everything say in unsigned HOST_WIDE_INT and then map all ones in UHWI to all ones in target size_t). 2026-09-18 Jakub Jelinek Manjunath Matti PR middle-end/127378 * gimple-lower-bitint.cc (bitint_large_huge::lower_mergeable_stmt): On big endian, compare idx_next in separate_ext loop against bo_idx + total - 1 - end, and if that wraps around, compare idx against 0 instead. * gcc.dg/bitint-145.c: New test. Reviewed-by: Richard Biener --- gcc/gimple-lower-bitint.cc | 11 ++++++---- gcc/testsuite/gcc.dg/bitint-145.c | 35 +++++++++++++++++++++++++++++++ 2 files changed, 42 insertions(+), 4 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/bitint-145.c diff --git a/gcc/gimple-lower-bitint.cc b/gcc/gimple-lower-bitint.cc index a4a27aa4360c..a63a06791fb3 100644 --- a/gcc/gimple-lower-bitint.cc +++ b/gcc/gimple-lower-bitint.cc @@ -3271,15 +3271,18 @@ bitint_large_huge::lower_mergeable_stmt (gimple *stmt, tree_code &cmp_code, bitint_big_endian ? size_int (-1) : size_one_node); insert_before (g); - if (bitint_big_endian && rem != 0) - g = gimple_build_cond (NE_EXPR, idx, - size_int (bo_idx + 1), + /* For big-endian, if bo_idx + total - 1 - end is all ones, then + compare idx (which is equal to idx_next + 1) against 0 + instead. */ + if (bitint_big_endian && bo_idx + total - end == 0) + g = gimple_build_cond (NE_EXPR, idx, size_zero_node, NULL_TREE, NULL_TREE); else g = gimple_build_cond (NE_EXPR, idx_next, size_int (bo_idx + (bitint_big_endian - ? 0 : end)), + ? total - 1 - end + : end)), NULL_TREE, NULL_TREE); insert_before (g); m_gsi = gsi_for_stmt (stmt); diff --git a/gcc/testsuite/gcc.dg/bitint-145.c b/gcc/testsuite/gcc.dg/bitint-145.c new file mode 100644 index 000000000000..8434f5173864 --- /dev/null +++ b/gcc/testsuite/gcc.dg/bitint-145.c @@ -0,0 +1,35 @@ +/* PR middle-end/127378 */ +/* { dg-do run { target bitint } } */ +/* { dg-options "-std=c23 -O2" } */ + +#if __BITINT_MAXWIDTH__ >= 768 +unsigned _BitInt(512) a; +unsigned _BitInt(768) b = -1; + +__attribute__((noipa)) void +foo (unsigned _BitInt(135) *p) +{ + a = (_BitInt(135)) (p[0] + p[1]); +} + +__attribute__((noipa)) void +bar (unsigned _BitInt(200) *p) +{ + b = p[0] + p[1]; +} +#endif + +int +main () +{ +#if __BITINT_MAXWIDTH__ >= 768 + static unsigned _BitInt(135) p[2] = { -1, 0 }; + static unsigned _BitInt(200) q[2] = { 1, 2 }; + foo (p); + if (a != (unsigned _BitInt(512)) -1) + __builtin_abort (); + bar (q); + if (b != 3) + __builtin_abort (); +#endif +} From 3c5f42d64a7318745a712ef1cc53e8853e32961b Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Fri, 18 Sep 2026 11:04:56 +0200 Subject: [PATCH 179/584] testsuite: Fix up g++.dg/cpp29/std-floating1.C on powerpc64-linux Two spots in this test (which has been added to make sure we handle floating-point overflow, underflow and other cases as per https://wg21.link/P3899R3 during constant evaluation) fail when long double is IBM double double. The problem is that our real.cc emulation of this type is imprecise, we handle it basically as fixed 106 bit mantissa and exponent range of double, when it actually is an addition of two double values with some rules (the main one is that the upper double should be always equal to the whole value rounded to double). So, it is effectively dynamic precision from 53 bits (for denormals) up to some 1000 something bits depending on the exact values. Until we rewrite the real.cc emulation of this mode as operations on a pair of doubles (if ever), we have cases like /* Don't constant fold this floating point operation if the result may dependent upon the run-time rounding mode and flag_rounding_math is set, or if GCC's software emulation is unable to accurately represent the result. */ if ((flag_rounding_math || (MODE_COMPOSITE_P (mode) && !flag_unsafe_math_optimizations)) && (inexact || !real_identical (&result, &value))) return NULL_TREE; and so instead of getting wrong results we choose not to constant evaluate it in some cases, in this testcase the minld/maxld and minld*minld cases are inexact and so we punt. The following patch makes those dg-bogus xfailed on IBM double double long double targets to make it clear that it is a bug, but expected one. 2026-09-18 Jakub Jelinek * g++.dg/cpp29/std-floating1.C: Add 2 dg-bogus directives xfailed for long_double_is_ibm128 effective targets. Reviewed-by: Richard Biener --- gcc/testsuite/g++.dg/cpp29/std-floating1.C | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/gcc/testsuite/g++.dg/cpp29/std-floating1.C b/gcc/testsuite/g++.dg/cpp29/std-floating1.C index 504f76e4085e..4e8293b54fe3 100644 --- a/gcc/testsuite/g++.dg/cpp29/std-floating1.C +++ b/gcc/testsuite/g++.dg/cpp29/std-floating1.C @@ -46,11 +46,12 @@ constexpr long double snanld = __builtin_nansl (""); constexpr long double inf2ld = infld * 2.0L; // OK, also positive infinity constexpr long double zerold = minld / maxld; // OK, result cannot be represented, and is rounded to zero + // { dg-bogus "is not a constant expression" "" { xfail long_double_is_ibm128 } .-1 } constexpr long double oflold = maxld * 2.0L; // { dg-error "is not a constant expression" } constexpr long double nan2ld = nanld * 2.0L; // OK, propagating a NaN constexpr long double udefld = infld * 0.0L; // { dg-error "is not a constant expression" } constexpr long double div0ld = maxld / 0.0L; // { dg-error "is not a constant expression" } -constexpr long double zero2ld = minld * minld; +constexpr long double zero2ld = minld * minld; // { dg-bogus "is not a constant expression" "" { xfail long_double_is_ibm128 } } constexpr bool nancmpld = nanld < 0.0L; constexpr long double snan2ld = snanld * 2.0L; constexpr long double div02ld = 1.0L / 0.0L; // { dg-error "is not a constant expression" } From 3b99fd4bdc7005333b0c760630f5db6ceeb81e5a Mon Sep 17 00:00:00 2001 From: Alfie Richards Date: Wed, 16 Sep 2026 11:26:54 +0000 Subject: [PATCH 180/584] machmode: Add parse_machine_mode function Use function to replace manual machine_mode parsing. gcc/ChangeLog: * machmode.h (parse_machine_mode): New function. * read-rtl.cc (find_mode): Use parse_machine_mode. * config/riscv/riscv-v.cc (autovectorize_vector_modes): Likewise. gcc/c-family/ChangeLog: * c-attribs.cc (handle_mode_attribute): Use parse_machine_mode. --- gcc/c-family/c-attribs.cc | 8 +------- gcc/config/riscv/riscv-v.cc | 10 ++++------ gcc/machmode.h | 15 +++++++++++++++ gcc/read-rtl.cc | 10 ++++------ 4 files changed, 24 insertions(+), 19 deletions(-) diff --git a/gcc/c-family/c-attribs.cc b/gcc/c-family/c-attribs.cc index ae5c2743ce6b..3c0e780669b4 100644 --- a/gcc/c-family/c-attribs.cc +++ b/gcc/c-family/c-attribs.cc @@ -2429,7 +2429,6 @@ handle_mode_attribute (tree *node, tree name, tree args, warning (OPT_Wattributes, "%qE attribute ignored", name); else { - int j; const char *p = IDENTIFIER_POINTER (ident); int len = strlen (p); machine_mode mode = VOIDmode; @@ -2461,12 +2460,7 @@ handle_mode_attribute (tree *node, tree name, tree args, else if (!strcmp (p, "unwind_word")) mode = targetm.unwind_word_mode (); else - for (j = 0; j < NUM_MACHINE_MODES; j++) - if (!strcmp (p, GET_MODE_NAME (j))) - { - mode = (machine_mode) j; - break; - } + parse_machine_mode (p, &mode); if (mode == VOIDmode) { diff --git a/gcc/config/riscv/riscv-v.cc b/gcc/config/riscv/riscv-v.cc index 398a1003a1d1..1cf53c7841c9 100644 --- a/gcc/config/riscv/riscv-v.cc +++ b/gcc/config/riscv/riscv-v.cc @@ -3068,13 +3068,11 @@ autovectorize_vector_modes (vector_modes *modes, bool) ms.safe_splice (*modes); modes->truncate (0); - for (machine_mode mode : ms) + machine_mode mode; + if (parse_machine_mode (riscv_autovec_mode, &mode)) { - if (!strcmp (GET_MODE_NAME (mode), riscv_autovec_mode)) - { - modes->safe_push (mode); - return 0; - } + modes->safe_push (mode); + return 0; } /* Nothing found, fall back to regular handling. */ diff --git a/gcc/machmode.h b/gcc/machmode.h index b92b1572d8d4..bc564d6bc132 100644 --- a/gcc/machmode.h +++ b/gcc/machmode.h @@ -926,6 +926,21 @@ smallest_int_mode_for_size (poly_uint64 size) return dyn_cast (smallest_mode_for_size (size, MODE_INT)); } +/* Parses a machine mode from NAME. If successful the machine mode is stored + into RESULT and true is returned. Otherwise false is returned. */ + +inline bool +parse_machine_mode (const char *name, machine_mode *result) +{ + for (unsigned i = 0; i < NUM_MACHINE_MODES; i++) + if (strcmp (GET_MODE_NAME (i), name) == 0) + { + *result = (machine_mode) i; + return true; + } + return false; +} + extern opt_scalar_int_mode int_mode_for_mode (machine_mode); extern opt_machine_mode bitwise_mode_for_mode (machine_mode); extern opt_machine_mode mode_for_vector (scalar_mode, poly_uint64); diff --git a/gcc/read-rtl.cc b/gcc/read-rtl.cc index be9f2da37e19..de95d859f785 100644 --- a/gcc/read-rtl.cc +++ b/gcc/read-rtl.cc @@ -197,13 +197,11 @@ atoll (const char *p) static HOST_WIDE_INT find_mode (const char *name) { - int i; - - for (i = 0; i < NUM_MACHINE_MODES; i++) - if (strcmp (GET_MODE_NAME (i), name) == 0) - return i; + machine_mode mode; + if (!parse_machine_mode (name, &mode)) + fatal_with_file_and_line ("unknown mode `%s'", name); - fatal_with_file_and_line ("unknown mode `%s'", name); + return (HOST_WIDE_INT) mode; } static void From 6fc7ff484d354ee4e85ca7e4f555063a06800c6a Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Fri, 18 Sep 2026 11:36:43 +0200 Subject: [PATCH 181/584] testsuite: Fix up gcc.dg/bitint-142.c test The whole excersise here is to set the padding bits (if any) of the x elements and keep the non-padding bits as is. B here is unsigned _BitInt(7) type. On targets with bitint_ext_undef this works well, z = ~0 aka z = -1 sets the 0x7f bits, __builtin_clear_padding clears the remaining bit (which is 0 anyway but pedantically undefined) and ~*(unsigned char *) &z is 0x80. On targets with bitint_ext_full (or bitint_ext_partial), z = ~0 still sets the 0x7f bits, __builtin_clear_padding doesn't do anything (is optimized away as there are no padding bits), but we still get 0x80, which is not what I wanted, I wanted 0 on such targets. The problem is that I chose an unsigned _BitInt(7) type for z. One possibility would be to use signed _BitInt(7) instead, in that case z = ~0 aka z = -1 on bitint_ext_undef targets sets 0x7f bits and probably the upper bit too and __builtin_clear_padding then clears that bit, while on other targets it sets all 0xff bits (because it is sign extended) and __builtin_clear_padding does nothing. The following patch instead uses memset to set all bits and then clear padding. gcc.dg/vect/vect-bitint-1.c test doesn't need fixing, because it uses a signed _BitInt(17) type already: _BitInt(17) z = ~0; __builtin_clear_padding (&z); 2026-09-18 Jakub Jelinek * gcc.dg/bitint-142.c (main): Don't set z to ~0, instead memset it to ~0. Reviewed-by: Richard Biener --- gcc/testsuite/gcc.dg/bitint-142.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/testsuite/gcc.dg/bitint-142.c b/gcc/testsuite/gcc.dg/bitint-142.c index 4dac4723f09b..5ff5b80904b0 100644 --- a/gcc/testsuite/gcc.dg/bitint-142.c +++ b/gcc/testsuite/gcc.dg/bitint-142.c @@ -26,7 +26,7 @@ main () B f[16] = { 8, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0 }; for (unsigned i = 0; i < 16; ++i) x[i] = i; - z = ~0; + __builtin_memset (&z, ~0, sizeof (z)); __builtin_clear_padding (&z); for (unsigned i = 0; i < 16; ++i) ((unsigned char *) &x[0])[i] |= ~*(unsigned char *) &z; From 46ee9bbc9a7d92eb3435999b59c3d8b42254f88a Mon Sep 17 00:00:00 2001 From: Kael Andrew Alonzo Franco Date: Fri, 18 Sep 2026 06:50:31 -0400 Subject: [PATCH 182/584] tree-optimization: Restrict (X {+,-} M*N) / N optimization. [PR127406] When X is INT_MIN and N is -1, then r14-3644 converts ((X {+,-} M*N) / N) to ((X / N) {+,-} M). But INT_MIN / -1 overflows where ((X {+,-} M*N) / N) does not. Add a check for ((X {+,-} M*N) / N) via X > INT_MIN and N != -1. Bootstrapped and regtested on x86_64-pc-linux-gnu. PR tree-optimization/127406 gcc/ChangeLog: * match.pd: Restrict (X {+,-} M*N) / N optimization. gcc/testsuite/ChangeLog: * gcc.dg/torture/pr127406.c: New test. Signed-off-by: Kael Andrew Franco --- gcc/match.pd | 10 +++++++-- gcc/testsuite/gcc.dg/torture/pr127406.c | 28 +++++++++++++++++++++++++ 2 files changed, 36 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/torture/pr127406.c diff --git a/gcc/match.pd b/gcc/match.pd index 1c0393d11cde..e59c11d5d131 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -1200,7 +1200,10 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) /* "X+N*M" is not with opposite sign as "X". */ && (TYPE_UNSIGNED (type) || (vr0.nonnegative_p () && vr4.nonnegative_p ()) - || (vr0.nonpositive_p () && vr4.nonpositive_p ()))) + || (vr0.nonpositive_p () && vr4.nonpositive_p () + /* X = INT_MIN and N = -1 causes overflow. */ + && (!vr0.contains_p (wi::min_value (TYPE_PRECISION (type), SIGNED)) + || !vr2.contains_p (wi::minus_one (TYPE_PRECISION (type))))))) (plus (div @0 @2) @1)))) /* Simplify (X - M*N) / N -> X / N - M. */ @@ -1220,7 +1223,10 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) /* "X-N*M" is not with opposite sign as "X". */ && (TYPE_UNSIGNED (type) || (vr0.nonnegative_p () && vr4.nonnegative_p ()) - || (vr0.nonpositive_p () && vr4.nonpositive_p ()))) + || (vr0.nonpositive_p () && vr4.nonpositive_p () + /* X = INT_MIN and N = -1 causes overflow. */ + && (!vr0.contains_p (wi::min_value (TYPE_PRECISION (type), SIGNED)) + || !vr2.contains_p (wi::minus_one (TYPE_PRECISION (type))))))) (minus (div @0 @2) @1))))) /* Simplify diff --git a/gcc/testsuite/gcc.dg/torture/pr127406.c b/gcc/testsuite/gcc.dg/torture/pr127406.c new file mode 100644 index 000000000000..4cc48a320646 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr127406.c @@ -0,0 +1,28 @@ +/* { dg-do run } */ + +__attribute__((noipa)) +int +fplus (int x, int m, int n) +{ + if (x > -6 || m < -3 || m > -2 || n < -2 || n > -1) + return 0; + return (x + m * n) / n; +} + +__attribute__((noipa)) +int +fminus (int x, int m, int n) +{ + if (x > -6 || m < 2 || m > 3 || n < -2 || n > -1) + return 0; + return (x - m * n) / n; +} + +int +main (void) +{ + if (fplus (-2147483647 - 1, -2, -1) != 2147483646 + || fminus (-2147483647 - 1, 2, -1) != 2147483646) + __builtin_abort (); + return 0; +} From 2aacce1cff758599467a44c6538d5b3f6a7ac3d2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A9o=20Hardt?= Date: Wed, 16 Sep 2026 00:11:44 -0300 Subject: [PATCH 183/584] clean(imports): Remove Unused Includes and Downgrade Others MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Good evening, This is a trivial patch containing only either removals of include directives or their substitution by more specific alternatives. No behaviour was changed. Notice that tree-pretty-print.h only includes pretty-print.h and declares functions. Therefore, including pretty-print.h directly is more succinct when only pretty-print's declarations are needed. This is a follow-up to: https://gcc.gnu.org/pipermail/gcc-patches/2026-September/731230.html Successfully bootstrapped on my Intel machine. gcc/ChangeLog: * asan.cc: Remove include that already came from ssa.h. * gimple-ssa-pta-constraints.cc: Remove unused include. * tree-ssa-loop-unswitch.cc: Likewise. * ubsan.cc: Change an include to a more specific file. * value-query.cc: Remove unused import. * value-range-storage.cc: Likewise. * value-range.cc: Change an include to a more specific file. Signed-off-by: Léo Hardt --- gcc/asan.cc | 1 - gcc/gimple-ssa-pta-constraints.cc | 1 - gcc/tree-ssa-loop-unswitch.cc | 1 - gcc/ubsan.cc | 2 +- gcc/value-query.cc | 1 - gcc/value-range-storage.cc | 1 - gcc/value-range.cc | 2 +- 7 files changed, 2 insertions(+), 7 deletions(-) diff --git a/gcc/asan.cc b/gcc/asan.cc index 6feeae30e35b..278c414c0dab 100644 --- a/gcc/asan.cc +++ b/gcc/asan.cc @@ -34,7 +34,6 @@ along with GCC; see the file COPYING3. If not see #include "tm_p.h" #include "ssa.h" #include "stringpool.h" -#include "tree-ssanames.h" #include "optabs.h" #include "emit-rtl.h" #include "cgraph.h" diff --git a/gcc/gimple-ssa-pta-constraints.cc b/gcc/gimple-ssa-pta-constraints.cc index b433aee8243f..fe8bd738f338 100644 --- a/gcc/gimple-ssa-pta-constraints.cc +++ b/gcc/gimple-ssa-pta-constraints.cc @@ -29,7 +29,6 @@ #include "tree-pass.h" #include "ssa.h" #include "cgraph.h" -#include "tree-pretty-print.h" #include "diagnostic-core.h" #include "fold-const.h" #include "stor-layout.h" diff --git a/gcc/tree-ssa-loop-unswitch.cc b/gcc/tree-ssa-loop-unswitch.cc index e1650c1f9ae3..0f600a3701f3 100644 --- a/gcc/tree-ssa-loop-unswitch.cc +++ b/gcc/tree-ssa-loop-unswitch.cc @@ -37,7 +37,6 @@ along with GCC; see the file COPYING3. If not see #include "cfghooks.h" #include "tree-ssa-loop-manip.h" #include "tree-vectorizer.h" -#include "tree-pretty-print.h" #include "gimple-range.h" #include "dbgcnt.h" #include "cfganal.h" diff --git a/gcc/ubsan.cc b/gcc/ubsan.cc index 79a863b46ce6..fb5ddc026709 100644 --- a/gcc/ubsan.cc +++ b/gcc/ubsan.cc @@ -31,7 +31,7 @@ along with GCC; see the file COPYING3. If not see #include "tm_p.h" #include "ssa.h" #include "cgraph.h" -#include "tree-pretty-print.h" +#include "pretty-print.h" #include "stor-layout.h" #include "cfganal.h" #include "gimple-iterator.h" diff --git a/gcc/value-query.cc b/gcc/value-query.cc index 337f66d9a794..78976e21f250 100644 --- a/gcc/value-query.cc +++ b/gcc/value-query.cc @@ -26,7 +26,6 @@ along with GCC; see the file COPYING3. If not see #include "tree.h" #include "gimple.h" #include "ssa.h" -#include "tree-pretty-print.h" #include "tree-ssanames.h" #include "fold-const.h" #include "value-query.h" diff --git a/gcc/value-range-storage.cc b/gcc/value-range-storage.cc index 14fa6e29a9f9..08c85a8880b5 100644 --- a/gcc/value-range-storage.cc +++ b/gcc/value-range-storage.cc @@ -26,7 +26,6 @@ along with GCC; see the file COPYING3. If not see #include "gimple.h" #include "gimplify.h" #include "ssa.h" -#include "tree-pretty-print.h" #include "fold-const.h" #include "gimple-range.h" #include "value-range-storage.h" diff --git a/gcc/value-range.cc b/gcc/value-range.cc index 8c0d418f6144..6fb1e801f2be 100644 --- a/gcc/value-range.cc +++ b/gcc/value-range.cc @@ -26,7 +26,7 @@ along with GCC; see the file COPYING3. If not see #include "tree.h" #include "gimple.h" #include "ssa.h" -#include "tree-pretty-print.h" +#include "pretty-print.h" #include "value-range-pretty-print.h" #include "value-range-storage.h" #include "fold-const.h" From 37846b229e14a54d74bcf77ee8bbfceb6e0b9bbe Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Fri, 18 Sep 2026 13:53:34 +0200 Subject: [PATCH 184/584] tree-optimization/127468 - ICE with SLP discovery dumping When trapping_stmt is NULL printing it via %G ICEs. PR tree-optimization/127468 * tree-vect-slp.cc (vect_build_slp_tree_3): Print the correct trapping stmt. --- gcc/tree-vect-slp.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc index 88368b5b86c2..13267c6c22d0 100644 --- a/gcc/tree-vect-slp.cc +++ b/gcc/tree-vect-slp.cc @@ -1530,7 +1530,7 @@ vect_build_slp_tree_3 (vec_info *vinfo, vec stmts, dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, "Build SLP failed: not all stmts in same " "BB but possibly trapping operation in %G", - trapping_stmt); + trapping_stmt ? trapping_stmt : stmt); continue; } } From db655b1fdce54adaf3d983ad73dd02db6cbdedf8 Mon Sep 17 00:00:00 2001 From: Andrew Stubbs Date: Thu, 17 Sep 2026 11:27:25 +0000 Subject: [PATCH 185/584] amdgcn: handle xnack in pre-split mov insns This has been a latent bug for a while, apparently. The load instructions must be restartable when xnack is enabled, and therefore must be no-clobber, even when they'll get split later. gcc/ChangeLog: * config/gcn/gcn-valu.md (mov_exec): Add xnack alternatives. (@mov_sgprbase): Likewise. --- gcc/config/gcn/gcn-valu.md | 80 +++++++++++++++++++++----------------- 1 file changed, 44 insertions(+), 36 deletions(-) diff --git a/gcc/config/gcn/gcn-valu.md b/gcc/config/gcn/gcn-valu.md index cd8ad9521a45..4764c34ff89f 100644 --- a/gcc/config/gcn/gcn-valu.md +++ b/gcc/config/gcn/gcn-valu.md @@ -500,13 +500,14 @@ (match_operand:DI 3 "register_operand"))) (clobber (match_scratch: 4))] "!MEM_P (operands[0]) || REG_P (operands[1])" - {@ [cons: =0, 1, 2, 3, =4; attrs: type, length] - [v,vA,U0,e ,X ;vop1 ,4 ] v_mov_b32\t%0, %1 - [v,B ,U0,e ,X ;vop1 ,8 ] v_mov_b32\t%0, %1 - [v,v ,vA,cV,X ;vop2 ,4 ] v_cndmask_b32\t%0, %2, %1, vcc - [v,vA,vA,Sv,X ;vop3a,8 ] v_cndmask_b32\t%0, %2, %1, %3 - [v,m ,U0,e ,&v;* ,16] # - [m,v ,U0,e ,&v;* ,16] # + {@ [cons: =0, 1, 2, 3, =4; attrs: type, length, xnack] + [v ,vA,U0,e ,X ;vop1 ,4 ,* ] v_mov_b32\t%0, %1 + [v ,B ,U0,e ,X ;vop1 ,8 ,* ] v_mov_b32\t%0, %1 + [v ,v ,vA,cV,X ;vop2 ,4 ,* ] v_cndmask_b32\t%0, %2, %1, vcc + [v ,vA,vA,Sv,X ;vop3a,8 ,* ] v_cndmask_b32\t%0, %2, %1, %3 + [v ,m ,U0,e ,&v;* ,16,off] # + [&v,m ,U0,e ,&v;* ,16,on ] # + [m ,v ,U0,e ,&v;* ,16,* ] # }) (define_insn "*mov" @@ -529,12 +530,13 @@ (match_operand:DI 3 "register_operand"))) (clobber (match_scratch: 4))] "!MEM_P (operands[0]) || REG_P (operands[1])" - {@ [cons: =0, 1, 2, 3, =4; attrs: type, length] - [v,vDB,U0 ,e ,X ;vmult,16] v_mov_b32\t%L0, %L1\;v_mov_b32\t%H0, %H1 - [v,v0 ,vDA0,cV,X ;vmult,16] v_cndmask_b32\t%L0, %L2, %L1, vcc\;v_cndmask_b32\t%H0, %H2, %H1, vcc - [v,v0 ,vDA0,Sv,X ;vmult,16] v_cndmask_b32\t%L0, %L2, %L1, %3\;v_cndmask_b32\t%H0, %H2, %H1, %3 - [v,m ,U0 ,e ,&v;* ,16] # - [m,v ,U0 ,e ,&v;* ,16] # + {@ [cons: =0, 1, 2, 3, =4; attrs: type, length, xnack] + [v ,vDB,U0 ,e ,X ;vmult,16,* ] v_mov_b32\t%L0, %L1\;v_mov_b32\t%H0, %H1 + [v ,v0 ,vDA0,cV,X ;vmult,16,* ] v_cndmask_b32\t%L0, %L2, %L1, vcc\;v_cndmask_b32\t%H0, %H2, %H1, vcc + [v ,v0 ,vDA0,Sv,X ;vmult,16,* ] v_cndmask_b32\t%L0, %L2, %L1, %3\;v_cndmask_b32\t%H0, %H2, %H1, %3 + [v ,m ,U0 ,e ,&v;* ,16,off] # + [&v,m ,U0 ,e ,&v;* ,16,on ] # + [m ,v ,U0 ,e ,&v;* ,16,* ] # }) (define_insn "*mov_4reg" @@ -556,12 +558,13 @@ (match_operand:DI 3 "register_operand"))) (clobber (match_scratch: 4))] "!MEM_P (operands[0]) || REG_P (operands[1])" - {@ [cons: =0, 1, 2, 3, =4; attrs: type, length] - [v,vDB,U0 ,e ,X ;vmult,32] v_mov_b32\t%L0, %L1\;v_mov_b32\t%H0, %H1\;v_mov_b32\t%J0, %J1\;v_mov_b32\t%K0, %K1 - [v,v0 ,vDA0,cV,X ;vmult,32] v_cndmask_b32\t%L0, %L2, %L1, vcc\;v_cndmask_b32\t%H0, %H2, %H1, vcc\;v_cndmask_b32\t%J0, %J2, %J1, vcc\;v_cndmask_b32\t%K0, %K2, %K1, vcc - [v,v0 ,vDA0,Sv,X ;vmult,32] v_cndmask_b32\t%L0, %L2, %L1, %3\;v_cndmask_b32\t%H0, %H2, %H1, %3\;v_cndmask_b32\t%J0, %J2, %J1, %3\;v_cndmask_b32\t%K0, %K2, %K1, %3 - [v,m ,U0 ,e ,&v;* ,32] # - [m,v ,U0 ,e ,&v;* ,32] # + {@ [cons: =0, 1, 2, 3, =4; attrs: type, length, xnack] + [v ,vDB,U0 ,e ,X ;vmult,32,* ] v_mov_b32\t%L0, %L1\;v_mov_b32\t%H0, %H1\;v_mov_b32\t%J0, %J1\;v_mov_b32\t%K0, %K1 + [v ,v0 ,vDA0,cV,X ;vmult,32,* ] v_cndmask_b32\t%L0, %L2, %L1, vcc\;v_cndmask_b32\t%H0, %H2, %H1, vcc\;v_cndmask_b32\t%J0, %J2, %J1, vcc\;v_cndmask_b32\t%K0, %K2, %K1, vcc + [v ,v0 ,vDA0,Sv,X ;vmult,32,* ] v_cndmask_b32\t%L0, %L2, %L1, %3\;v_cndmask_b32\t%H0, %H2, %H1, %3\;v_cndmask_b32\t%J0, %J2, %J1, %3\;v_cndmask_b32\t%K0, %K2, %K1, %3 + [v ,m ,U0 ,e ,&v;* ,32,off] # + [&v,m ,U0 ,e ,&v;* ,32,on ] # + [m ,v ,U0 ,e ,&v;* ,32,* ] # }) ; A SGPR-base load looks like: @@ -583,13 +586,15 @@ UNSPEC_SGPRBASE)) (clobber (match_operand: 2 "register_operand"))] "lra_in_progress || reload_completed" - {@ [cons: =0, 1, =2; attrs: type, length, cdna] - [v,vA,&v;vop1,4 ,* ] v_mov_b32\t%0, %1 - [v,vB,&v;vop1,8 ,* ] ^ - [v,m ,&v;* ,12,* ] # - [m,v ,&v;* ,12,* ] # - [a,m ,&v;* ,12,cdna2] # - [m,a ,&v;* ,12,cdna2] # + {@ [cons: =0, 1, =2; attrs: type, length, cdna, xnack] + [v ,vA,&v;vop1,4 ,* ,* ] v_mov_b32\t%0, %1 + [v ,vB,&v;vop1,8 ,* ,* ] ^ + [v ,m ,&v;* ,12,* ,off] # + [&v,m ,&v;* ,12,* ,on ] # + [m ,v ,&v;* ,12,* ,* ] # + [a ,m ,&v;* ,12,cdna2,off] # + [&a,m ,&v;* ,12,cdna2,on ] # + [m ,a ,&v;* ,12,cdna2,* ] # }) (define_insn "@mov_sgprbase" @@ -599,12 +604,14 @@ UNSPEC_SGPRBASE)) (clobber (match_operand: 2 "register_operand"))] "lra_in_progress || reload_completed" - {@ [cons: =0, 1, =2; attrs: type, length, cdna] - [v,vDB,&v;vmult,8 ,* ] v_mov_b32\t%L0, %L1\;v_mov_b32\t%H0, %H1 - [v,m ,&v;* ,12,* ] # - [m,v ,&v;* ,12,* ] # - [a,m ,&v;* ,12,cdna2] # - [m,a ,&v;* ,12,cdna2] # + {@ [cons: =0, 1, =2; attrs: type, length, cdna, xnack] + [v ,vDB,&v;vmult,8 ,* ,* ] v_mov_b32\t%L0, %L1\;v_mov_b32\t%H0, %H1 + [v ,m ,&v;* ,12,* ,off] # + [&v,m ,&v;* ,12,* ,on ] # + [m ,v ,&v;* ,12,* ,* ] # + [a ,m ,&v;* ,12,cdna2,off] # + [&a,m ,&v;* ,12,cdna2,on ] # + [m ,a ,&v;* ,12,cdna2,* ] # }) (define_insn "@mov_sgprbase" @@ -614,10 +621,11 @@ UNSPEC_SGPRBASE)) (clobber (match_operand: 2 "register_operand"))] "lra_in_progress || reload_completed" - {@ [cons: =0, 1, =2; attrs: type, length] - [v,vDB,&v;vmult,8 ] v_mov_b32\t%L0, %L1\;v_mov_b32\t%H0, %H1\;v_mov_b32\t%J0, %J1\;v_mov_b32\t%K0, %K1 - [v,m ,&v;* ,12] # - [m,v ,&v;* ,12] # + {@ [cons: =0, 1, =2; attrs: type, length, xnack] + [v ,vDB,&v;vmult,8 ,* ] v_mov_b32\t%L0, %L1\;v_mov_b32\t%H0, %H1\;v_mov_b32\t%J0, %J1\;v_mov_b32\t%K0, %K1 + [v ,m ,&v;* ,12,off] # + [&v,m ,&v;* ,12,on ] # + [m ,v ,&v;* ,12,* ] # }) ; Expand scalar addresses into gather/scatter patterns From d6e5d79340fc1e95b01a2b59a6e8060685c9d494 Mon Sep 17 00:00:00 2001 From: Paul Thomas Date: Fri, 18 Sep 2026 16:12:40 +0100 Subject: [PATCH 186/584] Fortran: Fix a number of issues with parameterized strings [PR127146] 2026-09-18 Paul Thomas gcc/fortran PR fortran/127146 * primary.cc (gfc_match_rvalue): At two points: if the entry in the parameter list has a name, use that in preference to the component name. gcc/testsuite PR fortran/127146 * gfortran.dg/pdt_96.f03: New test. --- gcc/fortran/primary.cc | 6 ++++-- gcc/testsuite/gfortran.dg/pdt_96.f03 | 32 ++++++++++++++++++++++++++++ 2 files changed, 36 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/gfortran.dg/pdt_96.f03 diff --git a/gcc/fortran/primary.cc b/gcc/fortran/primary.cc index d167036b8086..f3708f125d70 100644 --- a/gcc/fortran/primary.cc +++ b/gcc/fortran/primary.cc @@ -4225,7 +4225,8 @@ gfc_match_rvalue (gfc_expr **result) { if (c->attr.pdt_kind || c->attr.pdt_len) continue; - tmp->name = c->name; + if (!tmp->name) + tmp->name = c->name; tmp = tmp->next; } @@ -4251,7 +4252,8 @@ gfc_match_rvalue (gfc_expr **result) /* Can now add all the component names. */ for (c = pdt_sym->components; c && tmp; c = c->next) { - tmp->name = c->name; + if (!tmp->name) + tmp->name = c->name; tmp = tmp->next; } } diff --git a/gcc/testsuite/gfortran.dg/pdt_96.f03 b/gcc/testsuite/gfortran.dg/pdt_96.f03 new file mode 100644 index 000000000000..6aa9b6e5a50c --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pdt_96.f03 @@ -0,0 +1,32 @@ +! { dg-do run } +! Test the fix for PR127146, where the structure constructors caused errors as +! shown below. +! +! Contributed by Amir Shamoradi +! +module mod_pdt + implicit none + integer, parameter :: IK = kind(1) + integer, parameter :: IK8 = kind(1_8) + type :: pdt_parent(IKP) + integer, kind :: IKP + integer(IKP) :: ivalp + end type + type, extends(pdt_parent) :: pdt_child(IKC) + integer, kind :: IKC + integer(IKC) :: ivalc + end type +end module mod_pdt + + use mod_pdt + implicit none + type(pdt_child(IKP = IK, IKC = IK)) :: child1 = pdt_child(IKP = IK, IKC = IK)(ivalp = 1, ivalc = 2) + !! double free or corruption (fasttop) + + type(pdt_child(IKP = IK, IKC = IK8)) :: child2 + + child2 = pdt_child(IKP = IK, IKC = IK8)(ivalp = 3, ivalc = 4) + !! Error: Component 'ivalc' is initialized twice in the structure constructor at (1) + if ((child1%ivalp /= 1) .or. (child1%ivalc /= 2)) stop 1 + if ((child2%ivalp /= 3) .or. (child2%ivalc /= 4) .or. (kind (child2%ivalc) /= kind (1_8))) stop 2 +end From fce59fc4a405721468cd02eb0eba48a684e378e4 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Fri, 18 Sep 2026 16:41:24 +0200 Subject: [PATCH 187/584] tree-optimization/127473 - avoid starting a group with unvectorizable load The following avoids starting a group during SLP discovery with an unvectorizable load by refactoring the BB specific not grouped load handling to apply before selecting the first match. PR tree-optimization/127473 * tree-vect-slp.cc (vect_build_slp_tree_3): Duplicate the BB case of rejecting a not grouped load early to avoid assiging the first_match to it. --- gcc/tree-vect-slp.cc | 58 ++++++++++++++++++++++++++++++-------------- 1 file changed, 40 insertions(+), 18 deletions(-) diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc index 13267c6c22d0..26215d23dcf7 100644 --- a/gcc/tree-vect-slp.cc +++ b/gcc/tree-vect-slp.cc @@ -1301,6 +1301,29 @@ vect_build_slp_tree_3 (vec_info *vinfo, vec stmts, return false; } + /* Non-grouped store or load. */ + if (ldst_p + && !STMT_VINFO_GROUPED_ACCESS (stmt_info) + && DR_IS_READ (STMT_VINFO_DATA_REF (stmt_info)) + && rhs_code != CFN_GATHER_LOAD + && rhs_code != CFN_MASK_GATHER_LOAD + && rhs_code != CFN_MASK_LEN_GATHER_LOAD + && rhs_code != CFN_SCATTER_STORE + && rhs_code != CFN_MASK_SCATTER_STORE + && rhs_code != CFN_MASK_LEN_SCATTER_STORE + && !STMT_VINFO_GATHER_SCATTER_P (stmt_info) + /* Not grouped loads are handled as externals for BB + vectorization. Treat them as not vectorizable. */ + && is_a (vinfo)) + { + /* Not grouped load. */ + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "Build SLP failed: not grouped load %G", stmt); + matches[i] = -2; + continue; + } + if (!ldst_p && rhs_code == BIT_FIELD_REF) { tree vec = TREE_OPERAND (gimple_assign_rhs1 (stmt), 0); @@ -1581,25 +1604,24 @@ vect_build_slp_tree_3 (vec_info *vinfo, vec stmts, && rhs_code != CFN_SCATTER_STORE && rhs_code != CFN_MASK_SCATTER_STORE && rhs_code != CFN_MASK_LEN_SCATTER_STORE - && !STMT_VINFO_GATHER_SCATTER_P (stmt_info) - /* Not grouped loads are handled as externals for BB - vectorization. For loop vectorization we can handle - splats the same we handle single element interleaving. - Likewise we can handle a collection of invariant refs. */ - && (is_a (vinfo) - || (stmt_info != first_stmt_info - && !(integer_zerop (DR_STEP (STMT_VINFO_DATA_REF (stmt_info))) - && integer_zerop (DR_STEP (STMT_VINFO_DATA_REF - (first_stmt_info))))))) + && !STMT_VINFO_GATHER_SCATTER_P (stmt_info)) { - /* Not grouped load. */ - if (dump_enabled_p ()) - dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, - "Build SLP failed: not grouped load %G", stmt); - - if (is_a (vinfo)) - matches[i] = -2; - continue; + gcc_assert (!is_a (vinfo)); + /* For loop vectorization we can handle splats the same we + handle single element interleaving. Likewise we can handle + a collection of invariant refs. */ + if (stmt_info != first_stmt_info + && !(integer_zerop (DR_STEP (STMT_VINFO_DATA_REF (stmt_info))) + && integer_zerop (DR_STEP (STMT_VINFO_DATA_REF + (first_stmt_info))))) + { + /* Not grouped load. */ + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "Build SLP failed: not grouped load %G", + stmt); + continue; + } } } /* Not memory operation. */ From 78250307c37523f8814639e1cecb2117f50f546d Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Fri, 18 Sep 2026 10:27:19 +0200 Subject: [PATCH 188/584] Assert we properly soft-fail SLP nodes during discovery With delaying soft-failing of SLP discovery we should make sure the SLP discovery cache never ends up with non-failed nodes that would need splitting. * tree-vect-slp.cc (vect_build_slp_tree): Assert successful discovered nodes do not require splitting. --- gcc/tree-vect-slp.cc | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/gcc/tree-vect-slp.cc b/gcc/tree-vect-slp.cc index 26215d23dcf7..12b1abe3d786 100644 --- a/gcc/tree-vect-slp.cc +++ b/gcc/tree-vect-slp.cc @@ -2052,6 +2052,10 @@ vect_build_slp_tree (vec_info *vinfo, gcc_assert (res_ == res); /* Keep a reference for the bst_map use. */ SLP_TREE_REF_COUNT (res)++; + /* For BB vectorization nodes that need splitting should be failed. */ + gcc_assert (!is_a (vinfo) + || multiple_p (group_size, + TYPE_VECTOR_SUBPARTS (res->vectype))); } return res_; } From 6e12032523264f479f1594e894a4ae9db4d691c3 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 22:08:44 +0200 Subject: [PATCH 189/584] cobol: Copy missing posix-close.cpy to build dir libgcobol/ChangeLog: * Makefile.am: Add missing posix-close.cpy --- libgcobol/Makefile.am | 1 + 1 file changed, 1 insertion(+) diff --git a/libgcobol/Makefile.am b/libgcobol/Makefile.am index 18f04bad0d38..77ba271c3518 100644 --- a/libgcobol/Makefile.am +++ b/libgcobol/Makefile.am @@ -168,6 +168,7 @@ LP_COPYBOOKS = \ $(LP_COPYDIR_BUILD)/posix-localtime.cpy \ $(LP_COPYDIR_BUILD)/posix-lseek.cpy \ $(LP_COPYDIR_BUILD)/posix-mkdir.cpy \ + $(LP_COPYDIR_BUILD)/posix-close.cpy \ $(LP_COPYDIR_BUILD)/posix-open.cpy \ $(LP_COPYDIR_BUILD)/posix-read.cpy \ $(LP_COPYDIR_BUILD)/posix-stat.cpy \ From 38898f9bdae4dc7db4db537a503c995b06a3f16b Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 22:36:18 +0200 Subject: [PATCH 190/584] cobol: Revert "cobol: Correct CBL_CREATE_FILE and improve parameter validation for ANY LENGTH." CBL_CREATE_FILE was creating files with a trailing '0', and this is an actual bug. For example, it created files such as "myfile.txt0" or "anotherfile0", instead of "myfile.txt" or "anotherfile". While it is assumed the intention was to null-terminate the input string instead, this is in fact redundant since posix-open already performs this operation. On the other hand, the string length validation logic should not rely on hardcoded values such as filename-max. Maximum filename length is already handled by the kernel e.g.: by returning ENAMETOOLONG from open(2). gcc/cobol/ChangeLog: * parse.y: Revert. * symbols.h: Likewise. libgcobol/ChangeLog: * compat/gnu/lib/CBL_CREATE_FILE.cbl: Likewise. --- gcc/cobol/parse.y | 11 +++----- gcc/cobol/symbols.h | 6 ----- libgcobol/compat/gnu/lib/CBL_CREATE_FILE.cbl | 28 +++++--------------- 3 files changed, 10 insertions(+), 35 deletions(-) diff --git a/gcc/cobol/parse.y b/gcc/cobol/parse.y index aa53e5f259f9..8219342856d8 100644 --- a/gcc/cobol/parse.y +++ b/gcc/cobol/parse.y @@ -12979,7 +12979,7 @@ cbl_ffi_arg_t::matches( const cbl_ffi_arg_t& that ) const { case by_reference_e: if( crv == by_reference_e ) { if( (formal->attr & mask) == (actual->attr & mask) ) { - if( capacity_ok(formal, actual) ) { + if( formal->data.capacity() == actual->data.capacity() ) { if( formal->type == actual->type ) { // captures USAGE except COMP-X return true; } @@ -12988,17 +12988,13 @@ cbl_ffi_arg_t::matches( const cbl_ffi_arg_t& that ) const { return true; } } - // If actual is by reference, so must the formal be. - dbgmsg("%s:%d: failed, reference feature mismatch", __func__, __LINE__); + // If actual is by reference, so must the formal be. return false; break; case by_content_e: break; case by_value_e: - if( crv != by_value_e ) { - dbgmsg("%s:%d: failed, actual %s not by value", __func__, __LINE__, actual->name); - return false; - } + if( crv != by_value_e ) return false; if( formal->type == FldPointer && that.refer.is_pointer() ) return true; break; } @@ -13015,7 +13011,6 @@ cbl_ffi_arg_t::matches( const cbl_ffi_arg_t& that ) const { return actual->data.capacity() == formal->data.capacity() && actual->codeset.encoding == formal->codeset.encoding; } - dbgmsg("%s:%d: failed, for some reason", __func__, __LINE__); return false; } diff --git a/gcc/cobol/symbols.h b/gcc/cobol/symbols.h index 6c6142ed1a93..3887b275b7b0 100644 --- a/gcc/cobol/symbols.h +++ b/gcc/cobol/symbols.h @@ -1444,12 +1444,6 @@ struct cbl_ffi_arg_t { if( crv == by_reference_e ) return false; return refer.field != NULL; } - static bool capacity_ok( const cbl_field_t *formal, const cbl_field_t *actual ) { - if( formal->data.capacity() == actual->data.capacity() ) return true; - if( formal->data.capacity() == 1 && formal->has_attr(any_length_e) ) return true; - if( actual->data.capacity() == 1 && actual->has_attr(any_length_e) ) return true; - return false; - } }; // In support of serial/linear search: diff --git a/libgcobol/compat/gnu/lib/CBL_CREATE_FILE.cbl b/libgcobol/compat/gnu/lib/CBL_CREATE_FILE.cbl index c1d6c5ebb378..911bde060fa4 100644 --- a/libgcobol/compat/gnu/lib/CBL_CREATE_FILE.cbl +++ b/libgcobol/compat/gnu/lib/CBL_CREATE_FILE.cbl @@ -47,20 +47,18 @@ 77 func-ret Binary-Long. 77 errno-val Binary-Long. 77 lk-mode PIC 9(8) COMP-5. - 01 filename-max CONSTANT AS 8 * 1024. - 01 filename PIC X(filename-max). 77 filename-len PIC 9(4) BINARY VALUE ZERO. 01 ws-access-mode PIC 9(8) COMP-5. LINKAGE SECTION. 77 RETCODE PIC X(2) COMP-5. - 01 Lk-filename PIC X ANY LENGTH. + 01 filename PIC X ANY LENGTH. 01 access-mode PIC x COMP-x. 01 deny-mode PIC x comp-x. *> Not supported (must be 0). 01 device PIC x comp-x. *> Not supported (must be 0). 01 file-handle PIC X(4) COMP-5. - PROCEDURE DIVISION USING Lk-filename, + PROCEDURE DIVISION USING filename, By Reference access-mode, By Reference deny-mode, By Reference device, @@ -74,7 +72,8 @@ END-IF. COMPUTE filename-len = - FUNCTION LENGTH(FUNCTION TRIM(Lk-filename)). + FUNCTION LENGTH(FUNCTION TRIM(filename)). + MOVE X"00" TO filename(filename-len + 1:1). D Display 'CBL_CREATE_FILE: filename: [' filename ']' D Display 'ws-access-mode: ' ws-access-mode ', ' D Display 'deny-mode: ' deny-mode. @@ -95,31 +94,18 @@ Compute ws-access-mode = ws-access-mode + O_CREAT + O_TRUNC. Compute Lk-mode = S_IRUSR + S_IWUSR + S_IRGRP + S_IWGRP. - IF Lk-filename(filename-len:1) = ZERO - MOVE FUNCTION posix-open(Lk-filename, - ws-access-mode, lk-mode) - TO func-ret - ELSE - IF filename-max < filename-len + 1 - MOVE 30 to RETCODE - GOBACK - END-IF - MOVE Lk-filename to filename - MOVE ZERO TO filename(filename-len + 1:1) - MOVE FUNCTION posix-open(filename, ws-access-mode, lk-mode) - TO func-ret - END-IF + MOVE FUNCTION posix-open(filename, ws-access-mode, lk-mode) + TO func-ret. If func-ret is < 0 Then Move Function COBRT-FILE-STATUS() to RETCODE D Display 'COBRT-FILE-STATUS returned: ' RETCODE - D ' for errno ' func-ret else Move func-ret to file-handle Move 0 to RETCODE end-if. - + END PROGRAM CBL_CREATE_FILE. >> POP SOURCE FORMAT From 7aa771dc011669f4f8ac40f1b89b61fa36a477c8 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 22:38:46 +0200 Subject: [PATCH 191/584] cobol: Revert "cobol: NUL-terminate OS filename" This commit is in fact redundant since posix-open already performs this operation. On the other hand, the string length validation logic should not rely on hardcoded values such as filename-max. Maximum filename length is already handled by the kernel e.g.: by returning ENAMETOOLONG from open(2). libgcobol/ChangeLog: * compat/gnu/lib/CBL_OPEN_FILE.cbl: Revert. --- libgcobol/compat/gnu/lib/CBL_OPEN_FILE.cbl | 29 +++------------------- 1 file changed, 4 insertions(+), 25 deletions(-) diff --git a/libgcobol/compat/gnu/lib/CBL_OPEN_FILE.cbl b/libgcobol/compat/gnu/lib/CBL_OPEN_FILE.cbl index 2c9a83085075..0cc616453ae1 100644 --- a/libgcobol/compat/gnu/lib/CBL_OPEN_FILE.cbl +++ b/libgcobol/compat/gnu/lib/CBL_OPEN_FILE.cbl @@ -48,21 +48,18 @@ WORKING-STORAGE SECTION. 77 errno-val Binary-Long. 01 ws-access-mode PIC 9(8) comp-5. - 01 filename-max CONSTANT AS 8 * 1024. - 01 filename PIC X(filename-max). - 77 filename-len PIC 9(4) BINARY VALUE ZERO. LINKAGE SECTION. 01 RETCODE PIC X(2) COMP-5 VALUE 0. 01 REDEFINES RETCODE. 03 MSB PIC X. 03 LSB BINARY-CHAR. - 01 Lk-filename PIC X ANY LENGTH. + 01 filename PIC X ANY LENGTH. 01 access-mode PIC X COMP-X. 01 deny-mode PIC X COMP-X. *> Not supported (must be 0). 01 device PIC X COMP-X. *> Not supported (must be 0). 01 file-handle PIC X(4) COMP-5. - PROCEDURE DIVISION USING Lk-filename, + PROCEDURE DIVISION USING filename, By Reference access-mode, By Reference deny-mode, By Reference device, @@ -91,26 +88,8 @@ GOBACK END-EVALUATE. - COMPUTE filename-len = - FUNCTION LENGTH(FUNCTION TRIM(Lk-filename)). - - * If Lk-filename ends in NUL, use it ... - IF Lk-filename(filename-len:1) = ZERO - MOVE FUNCTION posix-open(Lk-filename, - ws-access-mode, deny-mode) - TO errno-val - * ... else make a copy and terminate it with a NUL, unless it's too long. - ELSE - IF filename-max < filename-len + 1 - MOVE 30 to RETCODE - GOBACK - END-IF - MOVE Lk-filename to filename - MOVE ZERO TO filename(filename-len + 1:1) - MOVE FUNCTION posix-open(filename, - ws-access-mode, deny-mode) - TO errno-val - END-IF. + MOVE FUNCTION posix-open(filename, ws-access-mode, deny-mode) + TO errno-val. D Display 'CBL_OPEN_FILE: RETCODE: ' RETCODE. If errno-val is < 0 then From 116cd7bce6b5f6cd43324a48f7a12a20198f1c13 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 22:43:26 +0200 Subject: [PATCH 192/584] cobol: Make consistent use of RETURN-CODE and return variables The documentation for the CBL_* family of functions makes inconsistent use of RETURN-CODE and return variables, to the point where functions such as CBL_DELETE_FILE are documented to rely on a return variable [1], but their own examples rely on RETURN-CODE instead. [2] Whereas our implementation used to define a RETURNING clause for all functions in the family, test code used to rely on the RETURN-CODE register instead. Therefore, this commit attempts to play safe by strictly following the official documentation, and documents whether RETURN-CODE or a return variable should be used for each case. [1]: https://docs.rocketsoftware.com/bundle/visualcobolvs2022_ug_110/page/nuc1742953321767_1.html [2]: https://docs.rocketsoftware.com/bundle/visualcoboleclux_ug_110/page/mzy1742953323607.html# libgcobol/ChangeLog: * compat/gnu/cpy/cblproto.cpy: Use RETURN-CODE. * compat/gnu/lib/CBL_CLOSE_FILE.cbl: Likewise. * compat/gnu/lib/CBL_CREATE_FILE.cbl: Likewise. * compat/gnu/lib/CBL_OPEN_FILE.cbl: Likewise. * compat/gnu/lib/CBL_READ_FILE.cbl: Likewise. * compat/gnu/lib/CBL_WRITE_FILE.cbl: Likewise. * compat/gnu/lib/cbl_close_file.3: Document use of RETURN-CODE. * compat/gnu/lib/cbl_create_file.3: Likewise. * compat/gnu/lib/cbl_open_file.3: Likewise. * compat/gnu/lib/cbl_read_file.3: Likewise. * compat/gnu/lib/cbl_write_file.3: Likewise. --- libgcobol/compat/gnu/cpy/cblproto.cpy | 20 +++++--------------- libgcobol/compat/gnu/lib/CBL_CLOSE_FILE.cbl | 8 +++----- libgcobol/compat/gnu/lib/CBL_CREATE_FILE.cbl | 12 +++++------- libgcobol/compat/gnu/lib/CBL_OPEN_FILE.cbl | 16 ++++++++-------- libgcobol/compat/gnu/lib/CBL_READ_FILE.cbl | 10 ++++------ libgcobol/compat/gnu/lib/CBL_WRITE_FILE.cbl | 16 +++++++--------- libgcobol/compat/gnu/lib/cbl_close_file.3 | 8 ++++---- libgcobol/compat/gnu/lib/cbl_create_file.3 | 8 ++++---- libgcobol/compat/gnu/lib/cbl_open_file.3 | 8 ++++---- libgcobol/compat/gnu/lib/cbl_read_file.3 | 10 ++++------ libgcobol/compat/gnu/lib/cbl_write_file.3 | 10 ++++------ 11 files changed, 52 insertions(+), 74 deletions(-) diff --git a/libgcobol/compat/gnu/cpy/cblproto.cpy b/libgcobol/compat/gnu/cpy/cblproto.cpy index 4268b2341306..42435ab00d13 100644 --- a/libgcobol/compat/gnu/cpy/cblproto.cpy +++ b/libgcobol/compat/gnu/cpy/cblproto.cpy @@ -33,13 +33,11 @@ 01 deny-mode pic x comp-x. 01 device pic x comp-x. 01 file-handle pic x(4) comp-5. - 77 status-code pic x(2) comp-5. procedure division using filename access-mode deny-mode device - file-handle - returning status-code. + file-handle. end program CBL_CREATE_FILE. identification division. @@ -61,13 +59,11 @@ 01 deny-mode pic x comp-x. 01 device pic x comp-x. 01 file-handle pic x(4) comp-5. - 77 retcode pic x(2) comp-5. procedure division using filename access-mode deny-mode device - file-handle - returning retcode. + file-handle. end program CBL_OPEN_FILE. identification division. @@ -79,13 +75,11 @@ 01 byte-count pic x(4) comp-x. 01 flags pic x comp-x. 01 buffer pic x any length. - 77 retcode pic x(2) comp-5. procedure division using file-handle file-offset byte-count flags - buffer - returning retcode. + buffer. end program CBL_READ_FILE. identification division. @@ -97,13 +91,11 @@ 01 byte-count pic x(4) comp-x. 01 flags pic x comp-x. 01 buffer pic x any length. - 77 retcode pic x(2) comp-5. procedure division using file-handle file-offset byte-count flags - buffer - returning retcode. + buffer. end program CBL_WRITE_FILE. identification division. @@ -111,9 +103,7 @@ data division. linkage section. 01 file-handle pic x(4) comp-5. - 77 retcode pic x(2) comp-5. - procedure division using file-handle - returning retcode. + procedure division using file-handle. end program CBL_CLOSE_FILE. identification division. diff --git a/libgcobol/compat/gnu/lib/CBL_CLOSE_FILE.cbl b/libgcobol/compat/gnu/lib/CBL_CLOSE_FILE.cbl index e5e3410378f2..8379d356f54f 100644 --- a/libgcobol/compat/gnu/lib/CBL_CLOSE_FILE.cbl +++ b/libgcobol/compat/gnu/lib/CBL_CLOSE_FILE.cbl @@ -47,20 +47,18 @@ 77 errno-val Binary-Long. LINKAGE SECTION. - 77 RETCODE PIC X(2) COMP-5. 01 file-handle PIC X(4) COMP-5. PROCEDURE DIVISION USING - By Reference file-handle - RETURNING RETCODE. + By Reference file-handle. MOVE FUNCTION posix-close(file-handle) TO FUNC-RETURN-VALUE. IF FUNC-RETURN-VALUE < 0 - Move Function COBRT-FILE-STATUS() to RETCODE + Move Function COBRT-FILE-STATUS() to RETURN-CODE ELSE - MOVE 0 TO RETCODE + MOVE 0 TO RETURN-CODE END-IF. D Display 'CBL_CLOSE_FILE fd: ' file-handle ', rc: ' RETCODE. diff --git a/libgcobol/compat/gnu/lib/CBL_CREATE_FILE.cbl b/libgcobol/compat/gnu/lib/CBL_CREATE_FILE.cbl index 911bde060fa4..80fbef21a1ab 100644 --- a/libgcobol/compat/gnu/lib/CBL_CREATE_FILE.cbl +++ b/libgcobol/compat/gnu/lib/CBL_CREATE_FILE.cbl @@ -51,7 +51,6 @@ 01 ws-access-mode PIC 9(8) COMP-5. LINKAGE SECTION. - 77 RETCODE PIC X(2) COMP-5. 01 filename PIC X ANY LENGTH. 01 access-mode PIC x COMP-x. 01 deny-mode PIC x comp-x. *> Not supported (must be 0). @@ -62,8 +61,7 @@ By Reference access-mode, By Reference deny-mode, By Reference device, - By Reference file-handle - RETURNING RETCODE. + By Reference file-handle. MOVE access-mode TO ws-access-mode. @@ -86,7 +84,7 @@ Move O_RDWR to ws-access-mode WHEN OTHER Display 'CBL_CREATE_FILE invalid mode: ' ws-access-mode - Move -1 to RETCODE + Move -1 to RETURN-CODE GOBACK END-EVALUATE. @@ -99,11 +97,11 @@ If func-ret is < 0 Then - Move Function COBRT-FILE-STATUS() to RETCODE - D Display 'COBRT-FILE-STATUS returned: ' RETCODE + Move Function COBRT-FILE-STATUS() to RETURN-CODE + D Display 'COBRT-FILE-STATUS returned: ' RETURN-CODE else Move func-ret to file-handle - Move 0 to RETCODE + Move 0 to RETURN-CODE end-if. END PROGRAM CBL_CREATE_FILE. diff --git a/libgcobol/compat/gnu/lib/CBL_OPEN_FILE.cbl b/libgcobol/compat/gnu/lib/CBL_OPEN_FILE.cbl index 0cc616453ae1..e2c5245acbfd 100644 --- a/libgcobol/compat/gnu/lib/CBL_OPEN_FILE.cbl +++ b/libgcobol/compat/gnu/lib/CBL_OPEN_FILE.cbl @@ -49,8 +49,8 @@ 77 errno-val Binary-Long. 01 ws-access-mode PIC 9(8) comp-5. LINKAGE SECTION. - 01 RETCODE PIC X(2) COMP-5 VALUE 0. - 01 REDEFINES RETCODE. + 01 FILE-STATUS PIC X(2) COMP-5 VALUE 0. + 01 REDEFINES FILE-STATUS. 03 MSB PIC X. 03 LSB BINARY-CHAR. 01 filename PIC X ANY LENGTH. @@ -63,8 +63,7 @@ By Reference access-mode, By Reference deny-mode, By Reference device, - By Reference file-handle - RETURNING RETCODE. + By Reference file-handle. MOVE access-mode TO ws-access-mode. @@ -85,19 +84,20 @@ MOVE "9" TO MSB *> COBRT022 Illegal or impossible access mode for OPEN MOVE 22 TO LSB + MOVE FILE-STATUS TO RETURN-CODE GOBACK END-EVALUATE. MOVE FUNCTION posix-open(filename, ws-access-mode, deny-mode) TO errno-val. - D Display 'CBL_OPEN_FILE: RETCODE: ' RETCODE. + D Display 'CBL_OPEN_FILE: RETURN-CODE: ' RETURN-CODE. If errno-val is < 0 then - Move Function COBRT-FILE-STATUS() to RETCODE - D Display 'COBRT-FILE-STATUS returned: ' RETCODE + Move Function COBRT-FILE-STATUS() to RETURN-CODE + D Display 'COBRT-FILE-STATUS returned: ' RETURN-CODE else Move errno-val to file-handle - Move 0 to RETCODE + Move 0 to RETURN-CODE end-if. END PROGRAM CBL_OPEN_FILE. diff --git a/libgcobol/compat/gnu/lib/CBL_READ_FILE.cbl b/libgcobol/compat/gnu/lib/CBL_READ_FILE.cbl index 7593a596d178..b3f5309160d9 100644 --- a/libgcobol/compat/gnu/lib/CBL_READ_FILE.cbl +++ b/libgcobol/compat/gnu/lib/CBL_READ_FILE.cbl @@ -55,7 +55,6 @@ COPY statbuf. LINKAGE SECTION. - 01 RETCODE PIC X(2) COMP-5 VALUE 0. 01 file-handle PIC X(4) COMP-5. 01 file-offset PIC X(8) COMP-5. 01 byte-count pic x(4) comp-x. @@ -67,8 +66,7 @@ By Reference file-offset, By Reference byte-count, By Reference flags, - By Reference buffer - RETURNING RETCODE. + By Reference buffer. MAIN SECTION. IF flags = 0 @@ -95,7 +93,7 @@ IF FUNC-RETURN-VALUE = 0 THEN MOVE st_size OF statbuf TO file-offset - MOVE 0 TO RETCODE + MOVE 0 TO RETURN-CODE ELSE PERFORM RETURN-ERROR GOBACK @@ -125,11 +123,11 @@ END-IF END-PERFORM. - MOVE 0 TO RETCODE. + MOVE 0 TO RETURN-CODE. EXIT. RETURN-ERROR SECTION. - Move Function COBRT-FILE-STATUS() to RETCODE. + Move Function COBRT-FILE-STATUS() to RETURN-CODE. EXIT PARAGRAPH. END PROGRAM CBL_READ_FILE. diff --git a/libgcobol/compat/gnu/lib/CBL_WRITE_FILE.cbl b/libgcobol/compat/gnu/lib/CBL_WRITE_FILE.cbl index 0d2557d84e66..c875b1e8ca11 100644 --- a/libgcobol/compat/gnu/lib/CBL_WRITE_FILE.cbl +++ b/libgcobol/compat/gnu/lib/CBL_WRITE_FILE.cbl @@ -55,7 +55,6 @@ 77 bytes-written Binary-Long. LINKAGE SECTION. - 77 RETCODE Binary-Long value 0. 01 file-handle PIC X(4) COMP-5. 01 file-offset PIC X(8) COMP-x. 01 byte-count pic x(4) comp-x. @@ -67,8 +66,7 @@ By Reference file-offset, By Reference byte-count, By Reference flags, - By Reference buffer - RETURNING RETCODE. + By Reference buffer. MAIN SECTION. *> special processing to truncate or extend the file If byte-count = 0 @@ -130,22 +128,22 @@ PERFORM UNTIL bytes-written >= byte-count MOVE FUNCTION posix-write(file-handle, buffer (bytes-written + 1 : remaining-bytes), - remaining-bytes) TO RETCODE + remaining-bytes) TO RETURN-CODE - IF RETCODE < 0 + IF RETURN-CODE < 0 PERFORM RETURN-ERROR GOBACK ELSE - SUBTRACT RETCODE FROM remaining-bytes - ADD RETCODE TO bytes-written + SUBTRACT RETURN-CODE FROM remaining-bytes + ADD RETURN-CODE TO bytes-written END-IF END-PERFORM. - MOVE 0 TO RETCODE. + MOVE 0 TO RETURN-CODE. EXIT PARAGRAPH. RETURN-ERROR SECTION. - Move Function COBRT-FILE-STATUS() to RETCODE. + Move Function COBRT-FILE-STATUS() to RETURN-CODE. EXIT PARAGRAPH. >> POP SOURCE FORMAT diff --git a/libgcobol/compat/gnu/lib/cbl_close_file.3 b/libgcobol/compat/gnu/lib/cbl_close_file.3 index d83c5ac7f24a..0fa5f9f9284d 100644 --- a/libgcobol/compat/gnu/lib/cbl_close_file.3 +++ b/libgcobol/compat/gnu/lib/cbl_close_file.3 @@ -27,10 +27,10 @@ or .El . .Sh RETURN STATUS -.Nm -returns -.Sy "PIC X(2) COMP-5" . -The return status is 0 on success, else nonzero. +The return status is 0 on success, else nonzero, +and can be checked by reading the +.Sy RETURN-CODE +register. .Sh SEE ALSO .Xr CBL_CHECK_FILE_EXIST .\" CBL_CLOSE_FILE diff --git a/libgcobol/compat/gnu/lib/cbl_create_file.3 b/libgcobol/compat/gnu/lib/cbl_create_file.3 index 7dc6a6004697..d7e5d2c74469 100644 --- a/libgcobol/compat/gnu/lib/cbl_create_file.3 +++ b/libgcobol/compat/gnu/lib/cbl_create_file.3 @@ -50,10 +50,10 @@ be used for other byte-stream operations. .El . .Sh RETURN STATUS -.Nm -returns -.Sy "PIC X(2) COMP-5" . -The return status is 0 on success, else nonzero. +The return status is 0 on success, else nonzero, +and can be checked by reading the +.Sy RETURN-CODE +register. . .Sh SEE ALSO .Xr CBL_CHECK_FILE_EXIST diff --git a/libgcobol/compat/gnu/lib/cbl_open_file.3 b/libgcobol/compat/gnu/lib/cbl_open_file.3 index 2a7c6694dba5..d08e9acbcc55 100644 --- a/libgcobol/compat/gnu/lib/cbl_open_file.3 +++ b/libgcobol/compat/gnu/lib/cbl_open_file.3 @@ -50,10 +50,10 @@ be used for other byte-stream operations. .El . .Sh RETURN STATUS -.Nm -returns -.Sy "PIC X(2) COMP-5" . -The return status is 0 on success, else nonzero. +The return status is 0 on success, else nonzero, +and can be checked by reading the +.Sy RETURN-CODE +register. . .Sh SEE ALSO .Xr CBL_CHECK_FILE_EXIST diff --git a/libgcobol/compat/gnu/lib/cbl_read_file.3 b/libgcobol/compat/gnu/lib/cbl_read_file.3 index cec29176e14d..99bc57af7b00 100644 --- a/libgcobol/compat/gnu/lib/cbl_read_file.3 +++ b/libgcobol/compat/gnu/lib/cbl_read_file.3 @@ -18,8 +18,6 @@ using .Ar byte-count .Ar flags .Ar buffer -returning -.Ar status . .Sh DESCRIPTION Parameters: @@ -57,10 +55,10 @@ bytes. .El . .Sh RETURN STATUS -.Nm -returns -.Sy "PIC X(2) COMP-5" . -The return status is 0 on success, else nonzero. +The return status is 0 on success, else nonzero, +and can be checked by reading the +.Sy RETURN-CODE +register. . .Sh SEE ALSO .Xr CBL_CHECK_FILE_EXIST diff --git a/libgcobol/compat/gnu/lib/cbl_write_file.3 b/libgcobol/compat/gnu/lib/cbl_write_file.3 index e33e238d5f7e..837521f6a65e 100644 --- a/libgcobol/compat/gnu/lib/cbl_write_file.3 +++ b/libgcobol/compat/gnu/lib/cbl_write_file.3 @@ -18,8 +18,6 @@ using .Ar byte-count .Ar flags .Ar buffer -returning -.Ar status . .Sh DESCRIPTION Parameters: @@ -50,10 +48,10 @@ bytes. .El . .Sh RETURN STATUS -.Nm -returns -.Sy "PIC X(2) COMP-5" . -The return status is 0 on success, else nonzero. +The return status is 0 on success, else nonzero, +and can be checked by reading the +.Sy RETURN-CODE +register. . .Sh SEE ALSO .Xr CBL_CHECK_FILE_EXIST From 8faef9e741d5e11e4146067a4bbbe1fdfb100178 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 22:47:40 +0200 Subject: [PATCH 193/584] cobol: Do not null-terminate original string in CBL_CREATE_FILE.cbl This can cause undefined behaviour if the string supplied by the caller cannot be modified e.g.: string literals. libgcobol/ChangeLog: * compat/gnu/lib/CBL_CREATE_FILE.cbl: Do not null-terminate original string. --- libgcobol/compat/gnu/lib/CBL_CREATE_FILE.cbl | 4 ---- 1 file changed, 4 deletions(-) diff --git a/libgcobol/compat/gnu/lib/CBL_CREATE_FILE.cbl b/libgcobol/compat/gnu/lib/CBL_CREATE_FILE.cbl index 80fbef21a1ab..15b44cd3c85f 100644 --- a/libgcobol/compat/gnu/lib/CBL_CREATE_FILE.cbl +++ b/libgcobol/compat/gnu/lib/CBL_CREATE_FILE.cbl @@ -47,7 +47,6 @@ 77 func-ret Binary-Long. 77 errno-val Binary-Long. 77 lk-mode PIC 9(8) COMP-5. - 77 filename-len PIC 9(4) BINARY VALUE ZERO. 01 ws-access-mode PIC 9(8) COMP-5. LINKAGE SECTION. @@ -69,9 +68,6 @@ SUBTRACT 64 FROM ws-access-mode *> Remove large file bit if set END-IF. - COMPUTE filename-len = - FUNCTION LENGTH(FUNCTION TRIM(filename)). - MOVE X"00" TO filename(filename-len + 1:1). D Display 'CBL_CREATE_FILE: filename: [' filename ']' D Display 'ws-access-mode: ' ws-access-mode ', ' D Display 'deny-mode: ' deny-mode. From 111c680dc8e2bbcb82c3ffb5bf2d65d6f71c000e Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 22:56:46 +0200 Subject: [PATCH 194/584] cobol: Remove trailing pipe on time_fmt_b This invalid regular expression was somehow tolerated by glibc's implementation for regcomp(3), but was rejected by other implementations, such as those found in FreeBSD and OpenBSD. gcc/cobol/ChangeLog: PR cobol/127074 * scan_post.h (datetime_format_of): Remove trailing pipe. --- gcc/cobol/scan_post.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/cobol/scan_post.h b/gcc/cobol/scan_post.h index 967d81662f4d..d7cf5abbe5bf 100644 --- a/gcc/cobol/scan_post.h +++ b/gcc/cobol/scan_post.h @@ -87,7 +87,7 @@ datetime_format_of( const char input[] ) { static const char date_fmt_e[] = "YYYY-MM-DD|YYYY-DDD|YYYY-Www-D"; static const char time_fmt_b[] = - "hhmmss([.,]s+)?|hhmmss([.,]s+)?Z|hhmmss([.,]s+)?[+]hhmm|"; + "hhmmss([.,]s+)?|hhmmss([.,]s+)?Z|hhmmss([.,]s+)?[+]hhmm"; static const char time_fmt_e[] = "hh:mm:ss([.,]s+)?|hh:mm:ss([.,]s+)?Z|hh:mm:ss([.,]s+)?[+]hh:mm"; From 422810aa9c9c6a43af786da31333c814042cd61c Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 23:06:13 +0200 Subject: [PATCH 195/584] cobol: Print passing method on error Otherwise, under some circumstances an error message would be displayed to the developer where data types are in fact compatible (i.e., same signedness, same size, same type), but no information about the passing method, thus potentially causing confusion. gcc/cobol/ChangeLog: * parse.y: Print passing method on error. --- gcc/cobol/parse.y | 24 ++++++++++++++++++++++-- 1 file changed, 22 insertions(+), 2 deletions(-) diff --git a/gcc/cobol/parse.y b/gcc/cobol/parse.y index 8219342856d8..97795c4cdffa 100644 --- a/gcc/cobol/parse.y +++ b/gcc/cobol/parse.y @@ -13059,6 +13059,24 @@ bad_arg( const char name[], return ok; } +static const char * +passby_str(int mask) +{ + switch( mask ) { + case by_default_e: + case by_reference_e: + return "BY REFERENCE"; + case by_content_e: + return "BY CONTENT"; + case by_value_e: + return "BY VALUE"; + default: + break; + } + + return "UNKNOWN PASSING METHOD"; +} + // Verify provided actual parameters against formals. static void verify_args( const YYLTYPE& loc, @@ -13079,14 +13097,16 @@ verify_args( const YYLTYPE& loc, */ if( ord < narg ) { if( ord < formals.size() ) { - error_msg( loc, "parameter %zu %qs (%s, capacity %u, %s) " - "invalid for %qs parameter %qs (%s, capacity %u, %s)", + error_msg( loc, "parameter %zu %s %qs (%s, capacity %u, %s) " + "invalid for %qs parameter %s %qs (%s, capacity %u, %s)", 1 + ord, + passby_str(parg->crv), nice_name_of(parg->field()), cbl_field_type_name(parg->field()->type), parg->field()->data.capacity(), parg->field()->attr & signable_e ? "signed" : "unsigned", name, + passby_str(formals[ord].crv), nice_name_of(formals[ord].refer.field), cbl_field_type_name(formals[ord].refer.field->type), formals[ord].refer.field->data.capacity(), From 09626b3d0d5a380f94037cd2c4db23f21711302d Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 23:08:01 +0200 Subject: [PATCH 196/584] cobol: Fix wrong diagnostic on numeric literals MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit For some reason, $1->data.initial expanded to a whitespace (i.e., " ") rather than the expected numeric literal (e.g.: "18"). Before: num-reference.cbl:4:42: error: cannot pass ‘ ’ BY REFERENCE [-Wcall-literal] 4 | call "prog" using by reference 0. | ^~ num-reference.cbl:4:42: error: ‘BY CONTENT expression’ requires ‘-dialect ibm or mf or gnu’ [-Wcontent-expr] Now: num-reference.cbl:4:42: error: cannot pass ‘0’ BY REFERENCE [-Wcall-literal] 4 | call "prog" using by reference 0. | ^~ num-reference.cbl:4:42: error: ‘BY CONTENT expression’ requires ‘-dialect ibm or mf or gnu’ [-Wcontent-expr] gcc/cobol/ChangeLog: * parse.y: Fix wrong diagnostic on numeric literals. --- gcc/cobol/parse.y | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/gcc/cobol/parse.y b/gcc/cobol/parse.y index 97795c4cdffa..8e6b0d9a28b3 100644 --- a/gcc/cobol/parse.y +++ b/gcc/cobol/parse.y @@ -10907,7 +10907,8 @@ ffi_by_ref: scalar_arg[refer] | num_literal { cbl_message(@1, MfCallLiteral, - "cannot pass %qs BY REFERENCE", $1->data.initial); + "cannot pass %qs BY REFERENCE", + $1->data.original()); cbl_refer_t *r = new_reference($1); $$ = new cbl_ffi_arg_t(by_content_e, r); } From b2647ee4e0c3a4a55feb27d0d1e40fd2bba8a983 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 23:10:57 +0200 Subject: [PATCH 197/584] cobol: cdf-copy.cc: Report on COPY directory Otherwise, the compiler would fail to mmap(2) the directory and lead to a rather confusing diagnostic, when information about the file path is already lost, thus making it difficult to pinpoint the root cause. For example, the following diagnostic could be triggered previously: cobol1: fatal error: No such device: map_file: could not map fd 6 Now, a more descriptive error message is shown: dir.cbl:5:1: error: copybook 'thisisadir.cpy' is a directory gcc/cobol/ChangeLog: * cdf-copy.cc (copybook_elem_t::open_file): Use fstat(2). --- gcc/cobol/cdf-copy.cc | 34 ++++++++++++++++++++++++++++------ 1 file changed, 28 insertions(+), 6 deletions(-) diff --git a/gcc/cobol/cdf-copy.cc b/gcc/cobol/cdf-copy.cc index 02c6240eaa35..978896650464 100644 --- a/gcc/cobol/cdf-copy.cc +++ b/gcc/cobol/cdf-copy.cc @@ -280,14 +280,21 @@ copybook_elem_t::open_file( const char directory[], bool literally ) { dbgmsg("could not open %s: %s", path, xstrerror(errno)); return fd; } + struct stat sb; + if (fstat(fd, &sb)) { + error_msg(source.loc, "fstat %qs failed: %s", path, xstrerror(errno)); + goto failure; + } + else if (S_ISDIR(sb.st_mode)) { + error_msg(source.loc, "copybook %qs is a directory", path); + goto failure; + } this->source.name = path; if( ! cobol_filename(this->source.name, inode_of(fd)) ) { error_msg(source.loc, "recursive copybook: '%s' includes itself", path); - (void)! close(fd); - fd = -1; - } else { - cbl_message(LexInputN, "opening %qs for input", source.name); + goto failure; } + cbl_message(LexInputN, "opening %qs for input", source.name); return fd; } gcc_assert( ! literally ); @@ -314,17 +321,32 @@ copybook_elem_t::open_file( const char directory[], bool literally ) { auto filename = pattern.c_str(); if( (this->fd = open(filename, O_RDONLY)) != -1 ) { + struct stat sb; + if (fstat(fd, &sb)) { + error_msg(source.loc, "fstat %qs failed: %s", filename, + xstrerror(errno)); + goto failure; + } + else if (S_ISDIR(sb.st_mode)) { + error_msg(source.loc, "copybook %qs is a directory", filename); + goto failure; + } this->source.name = xstrdup(filename); if( ! cobol_filename(this->source.name, inode_of(fd)) ) { error_msg(source.loc, "recursive copybook: '%s' includes itself", this->source.name); - (void)! close(fd); - fd = -1; + + goto failure; } dbgmsg("%s: opened %s as fd %d", __func__, source.name, fd); return fd; } } +failure: + if (fd >= 0) { + (void)! close(fd); + } + return -1; } From 9d7e388013abe9463020e11462be43c25373f63a Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 23:12:54 +0200 Subject: [PATCH 198/584] cobol: Use %qs for path The documentation for GCC suggests the use of %qs for file paths. [1] [1]: https://gcc.gnu.org/onlinedocs/libgdiagnostics/topics/message-formatting.html gcc/cobol/ChangeLog: * cdf-copy.cc (copybook_elem_t::open_file): Use %qs. --- gcc/cobol/cdf-copy.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/cobol/cdf-copy.cc b/gcc/cobol/cdf-copy.cc index 978896650464..6c52b6aeeedc 100644 --- a/gcc/cobol/cdf-copy.cc +++ b/gcc/cobol/cdf-copy.cc @@ -291,7 +291,7 @@ copybook_elem_t::open_file( const char directory[], bool literally ) { } this->source.name = path; if( ! cobol_filename(this->source.name, inode_of(fd)) ) { - error_msg(source.loc, "recursive copybook: '%s' includes itself", path); + error_msg(source.loc, "recursive copybook: %qs includes itself", path); goto failure; } cbl_message(LexInputN, "opening %qs for input", source.name); From 628c2b735f489d75a24a2c280e318951544350f0 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 23:15:02 +0200 Subject: [PATCH 199/584] cobol: Print arg loc rather than rule loc MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Before: cbl-get-program-info.cbl:17:45: error: ‘BY CONTENT expression’ requires ‘-dialect ibm’ [-Wcontent-expr] 17 | call "CBL_GET_PROGRAM_INFO" using by value fn | ^~~~~~~~~~~ 18 | by reference param-block | ~~~~~~~~~~~~~~~~~~~~~~~~ 19 | by reference buf | ~~~~~~~~~~~~~~~~ 20 | by reference 0 | ~~~~~~~~~~~~~~ Now: cbl-get-program-info.cbl:20:46: error: ‘BY CONTENT expression’ requires ‘-dialect ibm’ [-Wcontent-expr] 20 | by reference 0 | ^ gcc/cobol/ChangeLog: * parse_ante.h (by_content_ok): Use temporary symbol location. --- gcc/cobol/parse_ante.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/gcc/cobol/parse_ante.h b/gcc/cobol/parse_ante.h index b8db55e49184..df48210d6b60 100644 --- a/gcc/cobol/parse_ante.h +++ b/gcc/cobol/parse_ante.h @@ -3273,7 +3273,8 @@ by_content_ok( const cbl_loc_t& loc, if( arg.by_content() && field->has_attr(intermediate_e) ) { auto e = symbol_program( 0, field->name, true ); // seek prototoype if( ! e ) { - dialect_ok(loc, IbmContentExpr, "BY CONTENT expression"); + auto argloc = symbol_temporary_location(arg.field()); + dialect_ok(argloc, IbmContentExpr, "BY CONTENT expression"); } } if( arg.crv == by_value_e && From 175b499a706229543b00d338a75a3e8f32ac0f43 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 23:17:02 +0200 Subject: [PATCH 200/584] cobol: Fix undefined loc for CALL args MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Otherwise, a diagnostic could be printed with undefined line/column numbers. Given an example program where 252127536 would be an invalid line number, the following diagnostic was issued: argloc.cbl:252127536: error: parameter 2 BY REFERENCE ‘0’ (NUMERIC LITERAL, capacity 1, unsigned) invalid for ‘foo’ parameter BY REFERENCE ‘param-b’ (COMPUTATIONAL-5, capacity 4, signed) gcc/cobol/ChangeLog: * parse.y: Fix undefined loc for CALL args. --- gcc/cobol/parse.y | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/gcc/cobol/parse.y b/gcc/cobol/parse.y index 8e6b0d9a28b3..1e0bbbcb663d 100644 --- a/gcc/cobol/parse.y +++ b/gcc/cobol/parse.y @@ -10802,6 +10802,7 @@ end_call: %empty %prec CALL call_body: ffi_name { statement_begin(@1, CALL); + $$.loc = @1; $$.ffi_name = $ffi_name; $$.using_params = NULL; $$.ffi_returning = cbl_refer_t::empty(); @@ -10809,6 +10810,7 @@ call_body: ffi_name | ffi_name USING parameters { statement_begin(@1, CALL); + $$.loc = @1; $$.ffi_name = $ffi_name; $$.using_params = $parameters; $$.ffi_returning = cbl_refer_t::empty(); @@ -10816,12 +10818,14 @@ call_body: ffi_name } | ffi_name call_returning scalar[ret] { statement_begin(@1, CALL); + $$.loc = @1; $$.ffi_name = $ffi_name; $$.using_params = NULL; $$.ffi_returning = $ret; } | ffi_name USING parameters call_returning scalar[ret] { statement_begin(@1, CALL); + $$.loc = @1; $$.ffi_name = $ffi_name; $$.using_params = $parameters; $$.ffi_returning = $ret; From aa4345370bf4fb1077b1559c0f8a17e6b90b2b41 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 23:18:55 +0200 Subject: [PATCH 201/584] cobol: Set loc also for numeric literals BY REFERENCE MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Otherwise, diagnostics could be printed with invalid or missing location data. For example, location data is missing from the following diagnostic: argloc.cbl: error: parameter 2 BY REFERENCE ‘0’ (NUMERIC LITERAL, capacity 1, unsigned) invalid for ‘foo’ parameter BY REFERENCE ‘param-b’ (COMPUTATIONAL-5, capacity 4, signed) gcc/cobol/ChangeLog: * parse.y: Set loc also for numeric literals BY REFERENCE. --- gcc/cobol/parse.y | 1 + 1 file changed, 1 insertion(+) diff --git a/gcc/cobol/parse.y b/gcc/cobol/parse.y index 1e0bbbcb663d..0552f77f6193 100644 --- a/gcc/cobol/parse.y +++ b/gcc/cobol/parse.y @@ -10914,6 +10914,7 @@ ffi_by_ref: scalar_arg[refer] "cannot pass %qs BY REFERENCE", $1->data.original()); cbl_refer_t *r = new_reference($1); + r->loc = @1; $$ = new cbl_ffi_arg_t(by_content_e, r); } | ADDRESS OF scalar_arg[refer] From 64f2dcffc34274ac9877630d33d776745952a90a Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 23:20:29 +0200 Subject: [PATCH 202/584] cobol: Show location for invalid arg in CALL MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Previously, in such situation gcobol would print the location for the PROCEDURE DIVISION where the mismatch occurred, rather than the actual location of the invalid argument. For example: Before: argloc.cbl:8:55: error: parameter 2 BY VALUE ‘0’ (NUMERIC LITERAL, capacity 1, unsigned) invalid for ‘foo’ parameter BY REFERENCE ‘param-b’ (COMPUTATIONAL-5, capacity 4, signed) 8 | procedure division using param-a by reference param-b. | ^~~~~~~~ Now: argloc.cbl:18:37: error: parameter 2 BY VALUE ‘0’ (NUMERIC LITERAL, capacity 1, unsigned) invalid for ‘foo’ parameter BY REFERENCE ‘param-b’ (COMPUTATIONAL-5, capacity 4, signed) 18 | by value 0. | ^~ gcc/cobol/ChangeLog: * parse.y: Show location for invalid arg in CALL. --- gcc/cobol/parse.y | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/cobol/parse.y b/gcc/cobol/parse.y index 0552f77f6193..24b870f8dd68 100644 --- a/gcc/cobol/parse.y +++ b/gcc/cobol/parse.y @@ -13103,7 +13103,7 @@ verify_args( const YYLTYPE& loc, */ if( ord < narg ) { if( ord < formals.size() ) { - error_msg( loc, "parameter %zu %s %qs (%s, capacity %u, %s) " + error_msg( parg->refer.loc, "parameter %zu %s %qs (%s, capacity %u, %s) " "invalid for %qs parameter %s %qs (%s, capacity %u, %s)", 1 + ord, passby_str(parg->crv), From fdaa1a57862e313b20c7bb7e134cd02683d3f2be Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 23:23:21 +0200 Subject: [PATCH 203/584] cobol: Set loc for numeric literals BY VALUE MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Otherwise, diagnostics could be printed with invalid or missing location data. For example, location data is missing from the following diagnostic: argloc.cbl: error: parameter 2 BY VALUE ‘0’ (NUMERIC LITERAL, capacity 1, unsigned) invalid for ‘foo’ parameter BY REFERENCE ‘param-b’ (COMPUTATIONAL-5, capacity 4, signed) gcc/cobol/ChangeLog: * parse.y: Set loc for numeric literals BY VALUE. --- gcc/cobol/parse.y | 1 + 1 file changed, 1 insertion(+) diff --git a/gcc/cobol/parse.y b/gcc/cobol/parse.y index 24b870f8dd68..14e11e82c5a7 100644 --- a/gcc/cobol/parse.y +++ b/gcc/cobol/parse.y @@ -10953,6 +10953,7 @@ ffi_by_val: by_value_arg { const char *s = $1.s? $1.s : string_of($1.r); auto r = new_reference(new_literal(@1, s)); + r->loc = @1; $$ = new cbl_ffi_arg_t(by_value_e, r); } | ADDRESS OF scalar From f2a73defb7bd6705d99075c1fd066d43356c0e73 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 23:25:51 +0200 Subject: [PATCH 204/584] cobol: Accept arbitrarily-sized PIC X for ANY LENGTH Under -dialect mf, when the formal parameter is a PIC X ANY LENGTH, it should accept any kind of PIC X(n) defined by the caller. gcc/cobol/ChangeLog: * parse.y: Accept arbitrarily-sized PIC X for ANY LENGTH. --- gcc/cobol/parse.y | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/cobol/parse.y b/gcc/cobol/parse.y index 14e11e82c5a7..2766b07f1718 100644 --- a/gcc/cobol/parse.y +++ b/gcc/cobol/parse.y @@ -12991,7 +12991,7 @@ cbl_ffi_arg_t::matches( const cbl_ffi_arg_t& that ) const { return true; } } - else if (actual->attr & any_length_e) + else if (actual->attr & any_length_e || formal->attr & any_length_e) return true; } } From bcbf6bfa83dbd0c3d3885062db2f7162dd22e9dd Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 23:27:09 +0200 Subject: [PATCH 205/584] cobol: Fix cblte-fe-month for CBL_CHECK_FILE_EXIST The tm_mon member in struct tm contains values from 0 to 11, rather than 1 to 12. [1] [1]: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/time.h.html libgcobol/ChangeLog: * compat/gnu/lib/CBL_CHECK_FILE_EXIST.cbl: Add 1 to cblte-fe-month. --- libgcobol/compat/gnu/lib/CBL_CHECK_FILE_EXIST.cbl | 1 + 1 file changed, 1 insertion(+) diff --git a/libgcobol/compat/gnu/lib/CBL_CHECK_FILE_EXIST.cbl b/libgcobol/compat/gnu/lib/CBL_CHECK_FILE_EXIST.cbl index 1b601be37aa4..f2b0be9d1e42 100644 --- a/libgcobol/compat/gnu/lib/CBL_CHECK_FILE_EXIST.cbl +++ b/libgcobol/compat/gnu/lib/CBL_CHECK_FILE_EXIST.cbl @@ -76,6 +76,7 @@ ADD 1900 TO tm_year. MOVE tm_year TO cblte-fe-year. MOVE tm_mon TO cblte-fe-month. + ADD 1 TO cblte-fe-month. MOVE tm_mday TO cblte-fe-day. MOVE tm_hour TO cblte-fe-hours. From 1975cac5df24c7acd8696f7093a4ff05a1548341 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 23:29:31 +0200 Subject: [PATCH 206/584] cobol: Use st_mtime for CBL_CHECK_FILE_EXIST According to the documentation [1], CBL_CHECK_FILE_EXIST updates the cblt-fileexist-buf instance according to the last modification date, which equals st_mtime on POSIX systems. Instead, st_ctim refers to the last file status change. [2] [1]: https://docs.rocketsoftware.com/bundle/visualcobolvs2022_ug_110/page/hxj1742953321498_1.html [2]: https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_stat.h.html libgcobol/ChangeLog: * compat/gnu/lib/CBL_CHECK_FILE_EXIST.cbl: Use st_mtime. --- libgcobol/compat/gnu/lib/CBL_CHECK_FILE_EXIST.cbl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libgcobol/compat/gnu/lib/CBL_CHECK_FILE_EXIST.cbl b/libgcobol/compat/gnu/lib/CBL_CHECK_FILE_EXIST.cbl index f2b0be9d1e42..b6183a070419 100644 --- a/libgcobol/compat/gnu/lib/CBL_CHECK_FILE_EXIST.cbl +++ b/libgcobol/compat/gnu/lib/CBL_CHECK_FILE_EXIST.cbl @@ -65,7 +65,7 @@ MOVE st_size TO cblte-fe-filesize. - MOVE FUNCTION posix-localtime(address of st_ctime, TM-BUFFER) + MOVE FUNCTION posix-localtime(address of st_mtime, TM-BUFFER) TO FUNC-RETURN-VALUE. IF FUNC-RETURN-VALUE <> ZERO From e127633017a61b26b0be7f14c53e0f5b68fd129e Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Fri, 18 Sep 2026 16:13:31 +0200 Subject: [PATCH 207/584] cobol: Synchronise changes between libgcobol/Makefile.{am,in} libgcobol/ChangeLog: * Makefile.in: Update with autoreconf2.69. --- libgcobol/Makefile.in | 1 + 1 file changed, 1 insertion(+) diff --git a/libgcobol/Makefile.in b/libgcobol/Makefile.in index 67b0282834b2..949ee42d8a43 100644 --- a/libgcobol/Makefile.in +++ b/libgcobol/Makefile.in @@ -580,6 +580,7 @@ gcc_version := $(shell @get_gcc_base_ver@ $(top_srcdir)/../gcc/BASE-VER) @BUILD_LIBGCOBOL_TRUE@ $(LP_COPYDIR_BUILD)/posix-localtime.cpy \ @BUILD_LIBGCOBOL_TRUE@ $(LP_COPYDIR_BUILD)/posix-lseek.cpy \ @BUILD_LIBGCOBOL_TRUE@ $(LP_COPYDIR_BUILD)/posix-mkdir.cpy \ +@BUILD_LIBGCOBOL_TRUE@ $(LP_COPYDIR_BUILD)/posix-close.cpy \ @BUILD_LIBGCOBOL_TRUE@ $(LP_COPYDIR_BUILD)/posix-open.cpy \ @BUILD_LIBGCOBOL_TRUE@ $(LP_COPYDIR_BUILD)/posix-read.cpy \ @BUILD_LIBGCOBOL_TRUE@ $(LP_COPYDIR_BUILD)/posix-stat.cpy \ From 8a9c1bc7169b3e47cdad519f66532365a9176eff Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Tue, 15 Sep 2026 20:50:32 +0200 Subject: [PATCH 208/584] cobol: Introduce __gg__get_module_names libgcobol/ChangeLog: * libgcobol.cc (__gg__get_module_names): New function. --- libgcobol/libgcobol.cc | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/libgcobol/libgcobol.cc b/libgcobol/libgcobol.cc index 7291c8fa296b..fdc80fd95beb 100644 --- a/libgcobol/libgcobol.cc +++ b/libgcobol/libgcobol.cc @@ -11625,6 +11625,12 @@ __gg__module_name_pop() module_name_stack.pop_back(); } +const std::vector & +__gg__get_module_names() + { + return module_name_stack; + } + extern "C" void __gg__module_name(cblc_field_t *dest, module_type_t type) From 895cab8f290dc120200f58ce6736f8e5f8234c30 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Fri, 18 Sep 2026 15:59:30 +0200 Subject: [PATCH 209/584] cobol: Partially implement CBL_GET_PROGRAM_INFO Only functions 0 and 2 are implemented, and only partially - only returning the program name is supported. libgcobol/ChangeLog: * Makefile.am: Add CBL_GET_PROGRAM_INFO.cbl and cbl_gpi.cc. * Makefile.in: Likewise. * compat/gnu/cpy/cblproto.cpy: Add CBL_GET_PROGRAM_INFO. * compat/gnu/cpy/cbltypes.cpy: Add cblt-prog-info-params. * compat/gnu/lib/CBL_GET_PROGRAM_INFO.cbl: New file. * compat/gnu/lib/cbl_get_program_info.3: New file. * compat/gnu/lib/cbl_gpi.cc: New file. --- libgcobol/Makefile.am | 4 +- libgcobol/Makefile.in | 18 +- libgcobol/compat/gnu/cpy/cblproto.cpy | 18 + libgcobol/compat/gnu/cpy/cbltypes.cpy | 7 + .../compat/gnu/lib/CBL_GET_PROGRAM_INFO.cbl | 57 +++ .../compat/gnu/lib/cbl_get_program_info.3 | 150 ++++++++ libgcobol/compat/gnu/lib/cbl_gpi.cc | 364 ++++++++++++++++++ 7 files changed, 613 insertions(+), 5 deletions(-) create mode 100644 libgcobol/compat/gnu/lib/CBL_GET_PROGRAM_INFO.cbl create mode 100644 libgcobol/compat/gnu/lib/cbl_get_program_info.3 create mode 100644 libgcobol/compat/gnu/lib/cbl_gpi.cc diff --git a/libgcobol/Makefile.am b/libgcobol/Makefile.am index 77ba271c3518..d557e1456806 100644 --- a/libgcobol/Makefile.am +++ b/libgcobol/Makefile.am @@ -80,9 +80,11 @@ libgcobol_compat_gnu_la_SOURCES = \ compat/gnu/lib/CBL_CREATE_FILE.cbl \ compat/gnu/lib/CBL_DELETE_FILE.cbl \ compat/gnu/lib/CBL_FREE_MEM.cbl \ + compat/gnu/lib/CBL_GET_PROGRAM_INFO.cbl \ compat/gnu/lib/CBL_OPEN_FILE.cbl \ compat/gnu/lib/CBL_READ_FILE.cbl \ - compat/gnu/lib/CBL_WRITE_FILE.cbl + compat/gnu/lib/CBL_WRITE_FILE.cbl \ + compat/gnu/lib/cbl_gpi.cc libgcobol_posix_la_SOURCES = \ posix/udf/posix-close.cbl \ diff --git a/libgcobol/Makefile.in b/libgcobol/Makefile.in index 949ee42d8a43..9d65a567ea98 100644 --- a/libgcobol/Makefile.in +++ b/libgcobol/Makefile.in @@ -201,9 +201,11 @@ libgcobol_compat_gnu_la_LIBADD = @BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_CREATE_FILE.lo \ @BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_DELETE_FILE.lo \ @BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_FREE_MEM.lo \ +@BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_GET_PROGRAM_INFO.lo \ @BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_OPEN_FILE.lo \ @BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_READ_FILE.lo \ -@BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_WRITE_FILE.lo +@BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_WRITE_FILE.lo \ +@BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/cbl_gpi.lo libgcobol_compat_gnu_la_OBJECTS = \ $(am_libgcobol_compat_gnu_la_OBJECTS) @BUILD_LIBGCOBOL_TRUE@am_libgcobol_compat_gnu_la_rpath = -rpath \ @@ -504,9 +506,11 @@ gcc_version := $(shell @get_gcc_base_ver@ $(top_srcdir)/../gcc/BASE-VER) @BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_CREATE_FILE.cbl \ @BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_DELETE_FILE.cbl \ @BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_FREE_MEM.cbl \ +@BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_GET_PROGRAM_INFO.cbl \ @BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_OPEN_FILE.cbl \ @BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_READ_FILE.cbl \ -@BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_WRITE_FILE.cbl +@BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_WRITE_FILE.cbl \ +@BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/cbl_gpi.cc @BUILD_LIBGCOBOL_TRUE@libgcobol_posix_la_SOURCES = \ @BUILD_LIBGCOBOL_TRUE@ posix/udf/posix-close.cbl \ @@ -764,12 +768,17 @@ compat/gnu/lib/CBL_DELETE_FILE.lo: compat/gnu/lib/$(am__dirstamp) \ compat/gnu/lib/$(DEPDIR)/$(am__dirstamp) compat/gnu/lib/CBL_FREE_MEM.lo: compat/gnu/lib/$(am__dirstamp) \ compat/gnu/lib/$(DEPDIR)/$(am__dirstamp) +compat/gnu/lib/CBL_GET_PROGRAM_INFO.lo: \ + compat/gnu/lib/$(am__dirstamp) \ + compat/gnu/lib/$(DEPDIR)/$(am__dirstamp) compat/gnu/lib/CBL_OPEN_FILE.lo: compat/gnu/lib/$(am__dirstamp) \ compat/gnu/lib/$(DEPDIR)/$(am__dirstamp) compat/gnu/lib/CBL_READ_FILE.lo: compat/gnu/lib/$(am__dirstamp) \ compat/gnu/lib/$(DEPDIR)/$(am__dirstamp) compat/gnu/lib/CBL_WRITE_FILE.lo: compat/gnu/lib/$(am__dirstamp) \ compat/gnu/lib/$(DEPDIR)/$(am__dirstamp) +compat/gnu/lib/cbl_gpi.lo: compat/gnu/lib/$(am__dirstamp) \ + compat/gnu/lib/$(DEPDIR)/$(am__dirstamp) libgcobol_compat_gnu.la: $(libgcobol_compat_gnu_la_OBJECTS) $(libgcobol_compat_gnu_la_DEPENDENCIES) $(EXTRA_libgcobol_compat_gnu_la_DEPENDENCIES) $(AM_V_GEN)$(libgcobol_compat_gnu_la_LINK) $(am_libgcobol_compat_gnu_la_rpath) $(libgcobol_compat_gnu_la_OBJECTS) $(libgcobol_compat_gnu_la_LIBADD) $(LIBS) @@ -835,6 +844,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/unstring.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/valconv.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmlparse.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@compat/gnu/lib/$(DEPDIR)/cbl_gpi.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@posix/shim/$(DEPDIR)/errno.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@posix/shim/$(DEPDIR)/fstat.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@posix/shim/$(DEPDIR)/localtime.Plo@am__quote@ @@ -1034,7 +1044,7 @@ clean-am: clean-generic clean-libtool clean-toolexeclibLTLIBRARIES \ distclean: distclean-am -rm -f $(am__CONFIG_DISTCLEAN_FILES) - -rm -rf ./$(DEPDIR) posix/shim/$(DEPDIR) + -rm -rf ./$(DEPDIR) compat/gnu/lib/$(DEPDIR) posix/shim/$(DEPDIR) -rm -f Makefile distclean-am: clean-am distclean-compile distclean-generic \ distclean-hdr distclean-libtool distclean-tags @@ -1083,7 +1093,7 @@ installcheck-am: maintainer-clean: maintainer-clean-am -rm -f $(am__CONFIG_DISTCLEAN_FILES) -rm -rf $(top_srcdir)/autom4te.cache - -rm -rf ./$(DEPDIR) posix/shim/$(DEPDIR) + -rm -rf ./$(DEPDIR) compat/gnu/lib/$(DEPDIR) posix/shim/$(DEPDIR) -rm -f Makefile maintainer-clean-am: distclean-am maintainer-clean-generic diff --git a/libgcobol/compat/gnu/cpy/cblproto.cpy b/libgcobol/compat/gnu/cpy/cblproto.cpy index 42435ab00d13..b63a44c7bac1 100644 --- a/libgcobol/compat/gnu/cpy/cblproto.cpy +++ b/libgcobol/compat/gnu/cpy/cblproto.cpy @@ -118,6 +118,24 @@ file-details returning status-code. end program CBL_CHECK_FILE_EXIST. + + IDENTIFICATION DIVISION. + PROGRAM-ID. CBL_GET_PROGRAM_INFO PROTOTYPE. + DATA DIVISION. + LINKAGE SECTION. + COPY "cbltypes.cpy". + 01 fn pic x(4) comp-5. + 01 param-block type cblt-prog-info-params. + 01 return-buf pic x any length. + 01 return-buf-len pic x(4) comp-5. + 77 status-code pic x(2) comp-5. + procedure division using by value fn + by reference param-block + by reference return-buf + by reference return-buf-len + returning status-code. + + END PROGRAM CBL_GET_PROGRAM_INFO. >>POP SOURCE FORMAT >>PUSH SOURCE FORMAT diff --git a/libgcobol/compat/gnu/cpy/cbltypes.cpy b/libgcobol/compat/gnu/cpy/cbltypes.cpy index 384bc0bdb172..bd9b1221fdda 100644 --- a/libgcobol/compat/gnu/cpy/cbltypes.cpy +++ b/libgcobol/compat/gnu/cpy/cbltypes.cpy @@ -16,4 +16,11 @@ 05 cblte-fe-seconds PIC X COMP-X. 05 cblte-fe-hundreths PIC X COMP-X. + 01 cblt-prog-info-params typedef. + 03 cblte-gpi-size pic x(4) comp-5. + 03 cblte-gpi-flags pic x(4) comp-5. + 03 cblte-gpi-handle usage pointer. + 03 cblte-gpi-prog-id usage pointer. + 03 cblte-gpi-attrs pic x(4) comp-5. + >> POP source format diff --git a/libgcobol/compat/gnu/lib/CBL_GET_PROGRAM_INFO.cbl b/libgcobol/compat/gnu/lib/CBL_GET_PROGRAM_INFO.cbl new file mode 100644 index 000000000000..393f6bc98e60 --- /dev/null +++ b/libgcobol/compat/gnu/lib/CBL_GET_PROGRAM_INFO.cbl @@ -0,0 +1,57 @@ + >>PUSH source format + >>SOURCE format is fixed + * Copyright (c) 2021-2026 Symas Corporation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of the Symas Corporation nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + COPY "cblproto.cpy". + + IDENTIFICATION DIVISION. + PROGRAM-ID. CBL_GET_PROGRAM_INFO. + DATA DIVISION. + LINKAGE SECTION. + COPY "cbltypes.cpy". + 01 fn pic x(4) comp-5. + 01 param-block type cblt-prog-info-params. + 01 return-buf pic x any length. + 01 return-buf-len pic x(4) comp-5. + 77 retcode pic x(2) comp-5. + procedure division using by value fn + by reference param-block + by reference return-buf + by reference return-buf-len + returning retcode. + + call "cbl_gpi" using by value fn + by reference param-block + return-buf + return-buf-len + returning retcode. + + END PROGRAM CBL_GET_PROGRAM_INFO. + + >>POP source format \ No newline at end of file diff --git a/libgcobol/compat/gnu/lib/cbl_get_program_info.3 b/libgcobol/compat/gnu/lib/cbl_get_program_info.3 new file mode 100644 index 000000000000..d6b9a38b9bfb --- /dev/null +++ b/libgcobol/compat/gnu/lib/cbl_get_program_info.3 @@ -0,0 +1,150 @@ +.ds lang COBOL +.ds gcobol GCC\ \*[lang]\ Front-end +.Dd \& September 2026 +.Dt CBL_GET_PROGRAM_INFO 3\& "\&GNU Compatibility Library" +.Os Linux +.Sh NAME +.Nm CBL_GET_PROGRAM_INFO +.Nd Get metadata from a given program. +.Sh LIBRARY +libgcobol_compat_gnu +. +.Sh SYNOPSIS +.Ic COPY CBL_GET_PROGRAM_INFO +.Pp +.Ic call Dq "CBL_GET_PROGRAM_INFO" +using +by value +.Ar fn +by reference +.Ar param-block +.Ar return-buf +.Ar return-buf-len +returning +.Ar status-code +. +.Sh DESCRIPTION +Parameters: +.Pp +.Bl -tag -compact -width fn +.It Ar fn +is the function number to execute, from 0 to 10. +The list of supported functions is shown below: + +.Ar 0 : +Return the program name for the innermost program in the call stack above +.Nm +and assign +.Ar cblte-gpi-handle . + +.Ar 2 : +Return the program name associated with a +.Ar cblte-gpi-handle +instance previously allocated by function 0. + +.Ar 3 : +close a +.Ar cblte-gpi-handle +instance previously allocated by function 0. + +.It Ar param-block +an instance of type +.Ar cblt-prog-info-params , +defined in the +.Ar cbltypes +copybook as: +.Bd -literal: + 01 cblt-prog-info-params typedef. + 03 cblte-gpi-size pic x(4) comp-5. + 03 cblte-gpi-flags pic x(4) comp-5. + 03 cblte-gpi-handle usage pointer. + 03 cblte-gpi-prog-id usage pointer. + 03 cblte-gpi-attrs pic x(4) comp-5. + +.Ar cblte-gpi-flags +can further modify the behaviour of the 11 functions inside +.Nm . +A list of the currently supported bits is shown below: + +.Ar 0 : +assign +.Ar cblte-gpi-handle . +This bit is only relevant for function +.Ar 0 , +and is ignored by all other functions. + +.Ar 1 : +fill +.Ar return-buf +with the program name. +.Ar return-buf-len +therefore indicates the length of the +.Ar return-buf +buffer. If the program name is longer than +.Ar return-buf-len , +the result is truncated. +This bit is only relevant for functions +.Ar 0 +and +.Ar 2 . + +.Ar 2 : +if set, the program name stored into +.Ar return-buf +shall be null-terminated, +or space-terminated otherwise. + +.It Ar return-buf +points to a buffer to be filled by +.Nm . + +.It Ar return-buf-len +determines the length for the +.Ar return-buf +buffer. + +.Sh RETURN STATUS +.Nm +returns +.Sy "PIC X(2) COMP-5" . +The return status is 0 on success, else nonzero. +. +.Sh SEE ALSO +.Xr CBL_CLOSE_FILE +.Xr CBL_CREATE_FILE +.Xr CBL_DELETE_FILE +.Xr CBL_OPEN_FILE +.Xr CBL_READ_FILE +.Xr CBL_WRITE_FILE +.Xr CBL_CHECK_FILE_EXIST +. +.Sh COPYRIGHT +.Bd -unfilled -indent +Copyright (c) 2021-2026 Symas Corporation + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +* Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. +* Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. +* Neither the name of the Symas Corporation nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +.Ed diff --git a/libgcobol/compat/gnu/lib/cbl_gpi.cc b/libgcobol/compat/gnu/lib/cbl_gpi.cc new file mode 100644 index 000000000000..5e02ac4bd584 --- /dev/null +++ b/libgcobol/compat/gnu/lib/cbl_gpi.cc @@ -0,0 +1,364 @@ +/* + * Copyright (c) 2021-2026 Symas Corporation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of the Symas Corporation nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +struct gpi_priv + { + gpi_priv(const std::string &name) : name(name){} + std::string name; + }; + +/* From the COBOL side, we add no padding bytes at all for groups. */ +struct gpi_param_t + { + uint32_t size, flags; + struct gpi_priv *handle; + void *prog_id; + uint32_t attrs; + } __attribute__ ((packed)); + +struct retbuf_gpiai + { + uint32_t size, argc; + void *reserved1, *reserved2; + } __attribute__ ((packed)); + +enum + { + /* return cblte-gpi-handle. */ + GPI_PARAM_RET_HANDLE = 1 << 0, + /* return program basename in name-buf. */ + GPI_PARAM_RET_BASENAME = 1 << 1, + /* 0: space-terminated, 1: null-terminated. */ + GPI_PARAM_NULL_TERM = 1 << 2, + /* return in cblte-gpi-attr */ + GPI_PARAM_RET_PRGATTR = 1 << 3, + /* return for all programs */ + GPI_PARAM_ALL_PROG = 1 << 4, + /* 0: return full path, 1: return program name. */ + GPI_PARAM_RET_PRGNAME = 1 << 5 + }; + +union retbuf + { + char *basename; + struct retbuf_gpiai *gpiai ; + }; + +enum cbl_backtrace_flags + { + CBL_BACKTRACE_AMODE24 = 1 << 0, + CBL_BACKTRACE_AMODE31 = 1 << 1, + CBL_BACKTRACE_EBCDIC = 1 << 2, + CBL_BACKTRACE_ANS85 = 1 << 3, + CBL_BACKTRACE_VCS2 = 1 << 4, + CBL_BACKTRACE_OSVS = 1 << 5, + CBL_BACKTRACE_DATA24 = 1 << 6, + CBL_BACKTRACE_DATACONTEXT = 1 << 7, + CBL_BACKTRACE_PLI = 1 << 8, + /* bits 9-10 reserved */ + CBL_BACKTRACE_BIGENDIAN = 1 << 11, + /* bits 12-22 reserved */ + CBL_BACKTRACE_AMODE64 = 1 << 23, + CBL_BACKTRACE_DATA31 = 1 << 24 + }; + +static std::string +getlastprog() + { + const std::vector &__gg__get_module_names(), + &names = __gg__get_module_names(); + const char *s = NULL; + std::string ret; + + for (const auto &name : names) + { + /* libgcobol.cc stores module names with a leading character + * e.g.: 'T', 'N' or 'M'. */ + const char *cname = name.c_str() + 1; + + if (strcasecmp(cname, "CBL_GET_PROGRAM_INFO")) + s = cname; + else + break; + } + + if (s) + ret = s; + + return ret; + } + +static void +setbasename(const std::string &src, const gpi_param_t &p, char *dst, unsigned n) + { + strncpy(dst, src.c_str(), n); + + if (n) + { + dst[n - 1] = '\0'; + + if (!(p.flags & GPI_PARAM_NULL_TERM)) + dst[strlen(dst)] = ' '; + } + } + +int16_t +cbl_gpi_cur_status(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) + { + std::string prog = getlastprog(); + + if (prog.empty()) + return -1; + else if (params.flags & GPI_PARAM_RET_BASENAME) + setbasename(prog, params, buf.basename, buflen); + + if (params.flags & GPI_PARAM_RET_HANDLE) + params.handle = new gpi_priv(prog); + + /* TODO: set status bits */ + return 0; + } + +int16_t +cbl_gpi_named_status(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) + { + /* TODO: how are we supposed to return for a "named program" + * if no name is given?*/ + fprintf(stderr, "%s: TODO\n", __func__); + return -1; + } + +int16_t +cbl_gpi_handle_status(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) + { + const gpi_priv *prv = static_cast(params.handle); + + if (params.flags & GPI_PARAM_RET_BASENAME) + setbasename(prv->name.c_str(), params, buf.basename, buflen); + + /* TODO: set status bits */ + return 0; + } + +int16_t +cbl_gpi_close_handle(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) + { + delete static_cast(params.handle); + /* TODO: set status bits */ + return 0; + } + +int16_t +cbl_gpi_first_ep(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) + { + fprintf(stderr, "%s: TODO\n", __func__); + return -1; + } + +int16_t +cbl_gpi_next_ep(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) + { + fprintf(stderr, "%s: TODO\n", __func__); + return -1; + } + +int16_t +cbl_gpi_cancel_search_ep(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) + { + fprintf(stderr, "%s: TODO\n", __func__); + return -1; + } + +int16_t +cbl_gpi_prg_name(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) + { + fprintf(stderr, "%s: TODO\n", __func__); + return -1; + } + +int16_t +cbl_gpi_nargs(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) + { + fprintf(stderr, "%s: TODO\n", __func__); + return -1; + } + +int16_t +cbl_gpi_reserved(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) + { + fprintf(stderr, "%s: TODO\n", __func__); + return -1; + } + +int16_t +cbl_gpi_path_prg_name(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) + { + fprintf(stderr, "%s: TODO\n", __func__); + return -1; + } + +typedef int16_t (*gpi_func_t)(gpi_param_t ¶ms, union retbuf buf, + unsigned buflen); + +static const struct func + { + gpi_func_t func; + int accept, ignore, unimplemented; + } funcs[11] = + { + { + cbl_gpi_cur_status, + GPI_PARAM_RET_HANDLE | GPI_PARAM_RET_BASENAME | GPI_PARAM_NULL_TERM + | GPI_PARAM_RET_PRGATTR + }, + + { + cbl_gpi_named_status, + GPI_PARAM_RET_HANDLE | GPI_PARAM_RET_PRGATTR + }, + + { + cbl_gpi_handle_status, + GPI_PARAM_RET_BASENAME | GPI_PARAM_RET_PRGATTR | GPI_PARAM_NULL_TERM + | GPI_PARAM_ALL_PROG, + GPI_PARAM_RET_HANDLE + }, + + { + cbl_gpi_close_handle, + 0, + GPI_PARAM_RET_HANDLE + }, + + { + cbl_gpi_first_ep, + 0, + GPI_PARAM_RET_HANDLE + }, + + { + cbl_gpi_next_ep, + 0, + GPI_PARAM_RET_HANDLE + }, + + { + cbl_gpi_cancel_search_ep, + 0, + GPI_PARAM_RET_HANDLE + }, + + { + cbl_gpi_prg_name, + 0, + GPI_PARAM_RET_HANDLE + }, + + { + cbl_gpi_nargs, + 0, + GPI_PARAM_RET_HANDLE + }, + + { + cbl_gpi_reserved, + 0, + GPI_PARAM_RET_HANDLE + }, + + { + cbl_gpi_path_prg_name, + GPI_PARAM_RET_PRGNAME, + GPI_PARAM_RET_HANDLE + } + }; + +static int checkflags(uint32_t fn, uint32_t flags) + { + const struct func &f = funcs[fn]; + + for (uint32_t i = 0; i < 8 * sizeof flags; i++) + { + uint32_t mask = 1 << i; + + if (flags & mask) + { + if (!(f.accept & mask) && !(f.ignore & mask)) + { + fprintf(stderr, "bit %" PRIu32 " not allowed for function %" PRIu32 + "\n", i, fn); + return -1; + } + else if (f.unimplemented & mask) + { + fprintf(stderr, "bit %" PRIu32 " unimplemented for function %" PRIu32 + "\n", i, fn); + return -1; + } + } + } + + return 0; + } + +extern "C" +int16_t cbl_gpi(uint32_t fn, struct gpi_param_t ¶ms, union retbuf buf, + uint32_t *buflen) + { + if (fn >= sizeof funcs / sizeof *funcs) + { + fprintf(stderr, "invalid function number %u\n", fn); + return -1; + } + + if (params.size != sizeof params) + { + fprintf(stderr, "invalid cblte-gpi-size, expected %zu, got %u\n", + sizeof params, params.size); + assert(params.size == sizeof params); + } + + if (checkflags(fn, params.flags)) + { + fprintf(stderr, "invalid bits\n"); + return -1; + } + + return funcs[fn].func(params, buf, *buflen); + } From e92c2026f59ebfa4582beb4cda784bada7efb0b5 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Fri, 18 Sep 2026 11:44:41 +0200 Subject: [PATCH 210/584] cobol: Replace redundant passby_str with cbl_ffi_crv_str gcc/cobol/ChangeLog: * parse.y: Replace redundant passby_str with cbl_ffi_crv_str. --- gcc/cobol/parse.y | 26 ++++---------------------- 1 file changed, 4 insertions(+), 22 deletions(-) diff --git a/gcc/cobol/parse.y b/gcc/cobol/parse.y index 2766b07f1718..2de650c70b85 100644 --- a/gcc/cobol/parse.y +++ b/gcc/cobol/parse.y @@ -13066,24 +13066,6 @@ bad_arg( const char name[], return ok; } -static const char * -passby_str(int mask) -{ - switch( mask ) { - case by_default_e: - case by_reference_e: - return "BY REFERENCE"; - case by_content_e: - return "BY CONTENT"; - case by_value_e: - return "BY VALUE"; - default: - break; - } - - return "UNKNOWN PASSING METHOD"; -} - // Verify provided actual parameters against formals. static void verify_args( const YYLTYPE& loc, @@ -13104,16 +13086,16 @@ verify_args( const YYLTYPE& loc, */ if( ord < narg ) { if( ord < formals.size() ) { - error_msg( parg->refer.loc, "parameter %zu %s %qs (%s, capacity %u, %s) " - "invalid for %qs parameter %s %qs (%s, capacity %u, %s)", + error_msg( parg->refer.loc, "parameter %zu BY %s %qs (%s, capacity %u, %s) " + "invalid for %qs parameter BY %s %qs (%s, capacity %u, %s)", 1 + ord, - passby_str(parg->crv), + cbl_ffi_crv_str(parg->crv), nice_name_of(parg->field()), cbl_field_type_name(parg->field()->type), parg->field()->data.capacity(), parg->field()->attr & signable_e ? "signed" : "unsigned", name, - passby_str(formals[ord].crv), + cbl_ffi_crv_str(formals[ord].crv), nice_name_of(formals[ord].refer.field), cbl_field_type_name(formals[ord].refer.field->type), formals[ord].refer.field->data.capacity(), From c1b0d255ab0ee9850f5753afdcdb772f039137f2 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Fri, 18 Sep 2026 12:27:24 +0200 Subject: [PATCH 211/584] cobol: Reapply "cobol: Correct CBL_CREATE_FILE and improve parameter validation for ANY LENGTH." The "improve parameter validation for ANY LENGTH" part of this commit was valid from the beginning and should have not been reverted. This partly reverts commit 65c058c33c276d87cc6f4b233c5bd1b84cb5b6a8. gcc/cobol/ChangeLog: * parse.y: Reapply. * symbols.h: Likewise. --- gcc/cobol/parse.y | 11 ++++++++--- gcc/cobol/symbols.h | 6 ++++++ 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/gcc/cobol/parse.y b/gcc/cobol/parse.y index 2de650c70b85..9b07e9c46c8e 100644 --- a/gcc/cobol/parse.y +++ b/gcc/cobol/parse.y @@ -12986,7 +12986,7 @@ cbl_ffi_arg_t::matches( const cbl_ffi_arg_t& that ) const { case by_reference_e: if( crv == by_reference_e ) { if( (formal->attr & mask) == (actual->attr & mask) ) { - if( formal->data.capacity() == actual->data.capacity() ) { + if( capacity_ok(formal, actual) ) { if( formal->type == actual->type ) { // captures USAGE except COMP-X return true; } @@ -12995,13 +12995,17 @@ cbl_ffi_arg_t::matches( const cbl_ffi_arg_t& that ) const { return true; } } - // If actual is by reference, so must the formal be. + // If actual is by reference, so must the formal be. + dbgmsg("%s:%d: failed, reference feature mismatch", __func__, __LINE__); return false; break; case by_content_e: break; case by_value_e: - if( crv != by_value_e ) return false; + if( crv != by_value_e ) { + dbgmsg("%s:%d: failed, actual %s not by value", __func__, __LINE__, actual->name); + return false; + } if( formal->type == FldPointer && that.refer.is_pointer() ) return true; break; } @@ -13018,6 +13022,7 @@ cbl_ffi_arg_t::matches( const cbl_ffi_arg_t& that ) const { return actual->data.capacity() == formal->data.capacity() && actual->codeset.encoding == formal->codeset.encoding; } + dbgmsg("%s:%d: failed, for some reason", __func__, __LINE__); return false; } diff --git a/gcc/cobol/symbols.h b/gcc/cobol/symbols.h index 3887b275b7b0..6c6142ed1a93 100644 --- a/gcc/cobol/symbols.h +++ b/gcc/cobol/symbols.h @@ -1444,6 +1444,12 @@ struct cbl_ffi_arg_t { if( crv == by_reference_e ) return false; return refer.field != NULL; } + static bool capacity_ok( const cbl_field_t *formal, const cbl_field_t *actual ) { + if( formal->data.capacity() == actual->data.capacity() ) return true; + if( formal->data.capacity() == 1 && formal->has_attr(any_length_e) ) return true; + if( actual->data.capacity() == 1 && actual->has_attr(any_length_e) ) return true; + return false; + } }; // In support of serial/linear search: From 91b6b3371109346ac54e95f895b479d0b1657a75 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Fri, 18 Sep 2026 13:19:05 +0200 Subject: [PATCH 212/584] cobol: Do not error out on fstat(2) failure or S_ISDIR It is preferred to defer errors to the posterior call to mmap(2). gcc/cobol/ChangeLog: * cdf-copy.cc (copybook_elem_t::open_file): Do not error out on failure. --- gcc/cobol/cdf-copy.cc | 2 -- 1 file changed, 2 deletions(-) diff --git a/gcc/cobol/cdf-copy.cc b/gcc/cobol/cdf-copy.cc index 6c52b6aeeedc..e2878b33bbe3 100644 --- a/gcc/cobol/cdf-copy.cc +++ b/gcc/cobol/cdf-copy.cc @@ -283,11 +283,9 @@ copybook_elem_t::open_file( const char directory[], bool literally ) { struct stat sb; if (fstat(fd, &sb)) { error_msg(source.loc, "fstat %qs failed: %s", path, xstrerror(errno)); - goto failure; } else if (S_ISDIR(sb.st_mode)) { error_msg(source.loc, "copybook %qs is a directory", path); - goto failure; } this->source.name = path; if( ! cobol_filename(this->source.name, inode_of(fd)) ) { From 7f405dfaa29e4c9d8c7b4e6ada13fa44ff053a0c Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Fri, 18 Sep 2026 14:50:31 +0200 Subject: [PATCH 213/584] cobol: Move compat udf to libgcobol/compat/gnu/lib These functions are meant to work as part of the library, rather than intrinsic functions. gcc/cobol/ChangeLog: * cobol1.cc (libcompat_copybook): Remove "udf" from the search list. libgcobol/ChangeLog: PR cobol/126633 * Makefile.am: Replace udf with lib. * Makefile.in: Likewise. * compat/gnu/udf/cobrt-file-status.cbl: Move to... * compat/gnu/lib/cobrt-file-status.cbl: ...here. * compat/gnu/udf/stored-char-length.cbl: Move to... * compat/gnu/lib/stored-char-length.cbl: ...here. --- gcc/cobol/cobol1.cc | 1 - libgcobol/Makefile.am | 4 +-- libgcobol/Makefile.in | 27 ++++++------------- .../gnu/{udf => lib}/cobrt-file-status.cbl | 0 .../gnu/{udf => lib}/stored-char-length.cbl | 0 5 files changed, 10 insertions(+), 22 deletions(-) rename libgcobol/compat/gnu/{udf => lib}/cobrt-file-status.cbl (100%) rename libgcobol/compat/gnu/{udf => lib}/stored-char-length.cbl (100%) diff --git a/gcc/cobol/cobol1.cc b/gcc/cobol/cobol1.cc index 77671c94416c..4cc024c8b0f1 100644 --- a/gcc/cobol/cobol1.cc +++ b/gcc/cobol/cobol1.cc @@ -381,7 +381,6 @@ libcompat_copybook(const char *dir) { concat(gnu, dir_separator, "lib", NULL), concat(gnu, dir_separator, "cpy", NULL), - concat(gnu, dir_separator, "udf", NULL) }; for (size_t i = 0; i < sizeof paths / sizeof *paths; i++) diff --git a/libgcobol/Makefile.am b/libgcobol/Makefile.am index d557e1456806..86921dd12ae4 100644 --- a/libgcobol/Makefile.am +++ b/libgcobol/Makefile.am @@ -72,8 +72,8 @@ libgcobol_la_SOURCES = \ xmlparse.cc libgcobol_compat_gnu_la_SOURCES = \ - compat/gnu/udf/cobrt-file-status.cbl \ - compat/gnu/udf/stored-char-length.cbl \ + compat/gnu/lib/cobrt-file-status.cbl \ + compat/gnu/lib/stored-char-length.cbl \ compat/gnu/lib/CBL_ALLOC_MEM.cbl \ compat/gnu/lib/CBL_CHECK_FILE_EXIST.cbl \ compat/gnu/lib/CBL_CLOSE_FILE.cbl \ diff --git a/libgcobol/Makefile.in b/libgcobol/Makefile.in index 9d65a567ea98..42f91137ee8d 100644 --- a/libgcobol/Makefile.in +++ b/libgcobol/Makefile.in @@ -193,8 +193,8 @@ libgcobol_la_OBJECTS = $(am_libgcobol_la_OBJECTS) @BUILD_LIBGCOBOL_TRUE@am_libgcobol_la_rpath = -rpath $(toolexeclibdir) libgcobol_compat_gnu_la_LIBADD = @BUILD_LIBGCOBOL_TRUE@am_libgcobol_compat_gnu_la_OBJECTS = \ -@BUILD_LIBGCOBOL_TRUE@ compat/gnu/udf/cobrt-file-status.lo \ -@BUILD_LIBGCOBOL_TRUE@ compat/gnu/udf/stored-char-length.lo \ +@BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/cobrt-file-status.lo \ +@BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/stored-char-length.lo \ @BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_ALLOC_MEM.lo \ @BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_CHECK_FILE_EXIST.lo \ @BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_CLOSE_FILE.lo \ @@ -498,8 +498,8 @@ gcc_version := $(shell @get_gcc_base_ver@ $(top_srcdir)/../gcc/BASE-VER) @BUILD_LIBGCOBOL_TRUE@ xmlparse.cc @BUILD_LIBGCOBOL_TRUE@libgcobol_compat_gnu_la_SOURCES = \ -@BUILD_LIBGCOBOL_TRUE@ compat/gnu/udf/cobrt-file-status.cbl \ -@BUILD_LIBGCOBOL_TRUE@ compat/gnu/udf/stored-char-length.cbl \ +@BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/cobrt-file-status.cbl \ +@BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/stored-char-length.cbl \ @BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_ALLOC_MEM.cbl \ @BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_CHECK_FILE_EXIST.cbl \ @BUILD_LIBGCOBOL_TRUE@ compat/gnu/lib/CBL_CLOSE_FILE.cbl \ @@ -739,22 +739,16 @@ posix/shim/stat.lo: posix/shim/$(am__dirstamp) \ libgcobol.la: $(libgcobol_la_OBJECTS) $(libgcobol_la_DEPENDENCIES) $(EXTRA_libgcobol_la_DEPENDENCIES) $(AM_V_GEN)$(libgcobol_la_LINK) $(am_libgcobol_la_rpath) $(libgcobol_la_OBJECTS) $(libgcobol_la_LIBADD) $(LIBS) -compat/gnu/udf/$(am__dirstamp): - @$(MKDIR_P) compat/gnu/udf - @: > compat/gnu/udf/$(am__dirstamp) -compat/gnu/udf/$(DEPDIR)/$(am__dirstamp): - @$(MKDIR_P) compat/gnu/udf/$(DEPDIR) - @: > compat/gnu/udf/$(DEPDIR)/$(am__dirstamp) -compat/gnu/udf/cobrt-file-status.lo: compat/gnu/udf/$(am__dirstamp) \ - compat/gnu/udf/$(DEPDIR)/$(am__dirstamp) -compat/gnu/udf/stored-char-length.lo: compat/gnu/udf/$(am__dirstamp) \ - compat/gnu/udf/$(DEPDIR)/$(am__dirstamp) compat/gnu/lib/$(am__dirstamp): @$(MKDIR_P) compat/gnu/lib @: > compat/gnu/lib/$(am__dirstamp) compat/gnu/lib/$(DEPDIR)/$(am__dirstamp): @$(MKDIR_P) compat/gnu/lib/$(DEPDIR) @: > compat/gnu/lib/$(DEPDIR)/$(am__dirstamp) +compat/gnu/lib/cobrt-file-status.lo: compat/gnu/lib/$(am__dirstamp) \ + compat/gnu/lib/$(DEPDIR)/$(am__dirstamp) +compat/gnu/lib/stored-char-length.lo: compat/gnu/lib/$(am__dirstamp) \ + compat/gnu/lib/$(DEPDIR)/$(am__dirstamp) compat/gnu/lib/CBL_ALLOC_MEM.lo: compat/gnu/lib/$(am__dirstamp) \ compat/gnu/lib/$(DEPDIR)/$(am__dirstamp) compat/gnu/lib/CBL_CHECK_FILE_EXIST.lo: \ @@ -822,8 +816,6 @@ mostlyclean-compile: -rm -f *.$(OBJEXT) -rm -f compat/gnu/lib/*.$(OBJEXT) -rm -f compat/gnu/lib/*.lo - -rm -f compat/gnu/udf/*.$(OBJEXT) - -rm -f compat/gnu/udf/*.lo -rm -f posix/shim/*.$(OBJEXT) -rm -f posix/shim/*.lo -rm -f posix/udf/*.$(OBJEXT) @@ -882,7 +874,6 @@ mostlyclean-libtool: clean-libtool: -rm -rf .libs _libs -rm -rf compat/gnu/lib/.libs compat/gnu/lib/_libs - -rm -rf compat/gnu/udf/.libs compat/gnu/udf/_libs -rm -rf posix/shim/.libs posix/shim/_libs -rm -rf posix/udf/.libs posix/udf/_libs @@ -1027,8 +1018,6 @@ distclean-generic: -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) -rm -f compat/gnu/lib/$(DEPDIR)/$(am__dirstamp) -rm -f compat/gnu/lib/$(am__dirstamp) - -rm -f compat/gnu/udf/$(DEPDIR)/$(am__dirstamp) - -rm -f compat/gnu/udf/$(am__dirstamp) -rm -f posix/shim/$(DEPDIR)/$(am__dirstamp) -rm -f posix/shim/$(am__dirstamp) -rm -f posix/udf/$(DEPDIR)/$(am__dirstamp) diff --git a/libgcobol/compat/gnu/udf/cobrt-file-status.cbl b/libgcobol/compat/gnu/lib/cobrt-file-status.cbl similarity index 100% rename from libgcobol/compat/gnu/udf/cobrt-file-status.cbl rename to libgcobol/compat/gnu/lib/cobrt-file-status.cbl diff --git a/libgcobol/compat/gnu/udf/stored-char-length.cbl b/libgcobol/compat/gnu/lib/stored-char-length.cbl similarity index 100% rename from libgcobol/compat/gnu/udf/stored-char-length.cbl rename to libgcobol/compat/gnu/lib/stored-char-length.cbl From 339e65f9cc590e496d24acacaab1f16bd7be4da6 Mon Sep 17 00:00:00 2001 From: John David Anglin Date: Fri, 18 Sep 2026 14:43:10 -0400 Subject: [PATCH 214/584] Fix/skip tests that fail on hpux due to missing library functions hppa*-*-hpux* lacks complex.h header file. 2026-09-18 John David Anglin gcc/testsuite/ChangeLog: * gcc.dg/analyzer/atoi-1.c: Skip atoll hunk on hpux. * gcc.dg/analyzer/fd-mktemp-family.c: Skip on hpux. * gcc.dg/analyzer/mkdtemp-1.c: Likewise. * gcc.dg/analyzer/mkostemp-1.c: Likewise. * gcc.dg/analyzer/mkostemps-1.c: Likewise. * gcc.dg/analyzer/mkstemps-1.c: Likewise. --- gcc/testsuite/gcc.dg/analyzer/atoi-1.c | 2 +- gcc/testsuite/gcc.dg/analyzer/fd-mktemp-family.c | 2 +- gcc/testsuite/gcc.dg/analyzer/mkdtemp-1.c | 2 +- gcc/testsuite/gcc.dg/analyzer/mkostemp-1.c | 2 +- gcc/testsuite/gcc.dg/analyzer/mkostemps-1.c | 2 +- gcc/testsuite/gcc.dg/analyzer/mkstemps-1.c | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/gcc/testsuite/gcc.dg/analyzer/atoi-1.c b/gcc/testsuite/gcc.dg/analyzer/atoi-1.c index aa2cfe97f75e..5772f5c915c1 100644 --- a/gcc/testsuite/gcc.dg/analyzer/atoi-1.c +++ b/gcc/testsuite/gcc.dg/analyzer/atoi-1.c @@ -22,7 +22,7 @@ void test_valid_atol(void) { long val = atol("123"); /* Should be fine. */ } -#ifndef __AVR__ +#if !defined(__AVR__) && !defined(__hpux__) void test_valid_atoll(void) { long long val = atoll("123"); /* Should be fine. */ } diff --git a/gcc/testsuite/gcc.dg/analyzer/fd-mktemp-family.c b/gcc/testsuite/gcc.dg/analyzer/fd-mktemp-family.c index 67a5cfcf695b..57213c306457 100644 --- a/gcc/testsuite/gcc.dg/analyzer/fd-mktemp-family.c +++ b/gcc/testsuite/gcc.dg/analyzer/fd-mktemp-family.c @@ -1,4 +1,4 @@ -/* { dg-skip-if "fcntl,unistd" { avr-*-* } } */ +/* { dg-skip-if "fcntl,unistd" { avr-*-* *-*-hpux* } } */ /* Tests for fd leak and errno handling of mktemp-family functions. */ /* { dg-additional-options "-Wno-analyzer-null-argument" } */ diff --git a/gcc/testsuite/gcc.dg/analyzer/mkdtemp-1.c b/gcc/testsuite/gcc.dg/analyzer/mkdtemp-1.c index 061b75d291d6..a9522eb15da1 100644 --- a/gcc/testsuite/gcc.dg/analyzer/mkdtemp-1.c +++ b/gcc/testsuite/gcc.dg/analyzer/mkdtemp-1.c @@ -1,5 +1,5 @@ /* { dg-additional-options "-Wno-analyzer-null-argument" } */ -/* { dg-skip-if "incomplete stdio" { avr-*-* } } */ +/* { dg-skip-if "incomplete stdio" { avr-*-* *-*-hpux* } } */ #include #include diff --git a/gcc/testsuite/gcc.dg/analyzer/mkostemp-1.c b/gcc/testsuite/gcc.dg/analyzer/mkostemp-1.c index a7e0edb3441a..3f3bad238193 100644 --- a/gcc/testsuite/gcc.dg/analyzer/mkostemp-1.c +++ b/gcc/testsuite/gcc.dg/analyzer/mkostemp-1.c @@ -1,6 +1,6 @@ /* { dg-additional-options "-Wno-analyzer-null-argument" } */ /* { dg-prune-output "leak of file descriptor" } */ -/* { dg-skip-if "incomplete stdio" { avr-*-* } } */ +/* { dg-skip-if "incomplete stdio" { avr-*-* *-*-hpux* } } */ #include #include diff --git a/gcc/testsuite/gcc.dg/analyzer/mkostemps-1.c b/gcc/testsuite/gcc.dg/analyzer/mkostemps-1.c index 727da62a4ed5..3ef0247ea480 100644 --- a/gcc/testsuite/gcc.dg/analyzer/mkostemps-1.c +++ b/gcc/testsuite/gcc.dg/analyzer/mkostemps-1.c @@ -1,6 +1,6 @@ /* { dg-additional-options "-Wno-analyzer-null-argument" } */ /* { dg-prune-output "leak of file descriptor" } */ -/* { dg-skip-if "incomplete stdio" { avr-*-* } } */ +/* { dg-skip-if "incomplete stdio" { avr-*-* *-*-hpux* } } */ #include #include diff --git a/gcc/testsuite/gcc.dg/analyzer/mkstemps-1.c b/gcc/testsuite/gcc.dg/analyzer/mkstemps-1.c index 18c0d8cd9dd1..7f252bf247b5 100644 --- a/gcc/testsuite/gcc.dg/analyzer/mkstemps-1.c +++ b/gcc/testsuite/gcc.dg/analyzer/mkstemps-1.c @@ -1,6 +1,6 @@ /* { dg-additional-options "-Wno-analyzer-null-argument" } */ /* { dg-prune-output "leak of file descriptor" } */ -/* { dg-skip-if "incomplete stdio" { avr-*-* } } */ +/* { dg-skip-if "incomplete stdio" { avr-*-* *-*-hpux* } } */ #include #include From d5a076158aa3da594bc845b8363264d8fcec4a5e Mon Sep 17 00:00:00 2001 From: Richard Ball Date: Fri, 18 Sep 2026 20:06:44 +0100 Subject: [PATCH 215/584] aarch64: Add support for FEAT_CMH atomic store intrinsics This patch alters the exisiting atomic_store_with_stshh to a generic version atomic_store_with_hint this has allowed for the new hints added by FEAT_CMH to be added to this function as well. gcc/ChangeLog: * config/aarch64/aarch64-builtins.cc (enum aarch64_builtins): Change Function/Builtin names. (aarch64_init_pcdphint_builtins): Likewise. (aarch64_init_atomic_hints_builtins): Likewise. (aarch64_general_init_builtins): Likewise. (aarch64_expand_stshh_builtin): Likewise. (aarch64_expand_atomic_hints_builtins): Likewise. (aarch64_general_expand_builtin): Likewise. (aarch64_resolve_overloaded_builtin_stshh): Likewise. (aarch64_resolve_overloaded_builtin_atomic_hint_store): Likewise (aarch64_resolve_overloaded_builtin_general): Likewise. * config/aarch64/arm_acle.h (__atomic_store_with_stshh): Likewise. (__arm_atomic_store_with_hint): Likewise. * config/aarch64/atomics.md (@aarch64_atomic_store_stshh): Add new hints to pattern (@aarch64_atomic_hints_store): Likewise. * config/aarch64/iterators.md: Add Unspec for new hints. gcc/testsuite/ChangeLog: * g++.target/aarch64/atomic_store_with_stshh.C: Change Function name. * gcc.target/aarch64/atomic_store_with_stshh.c: Likewise. * gcc.target/aarch64/atomic_store_with_shuh.c: New test. * gcc.target/aarch64/atomic_store_with_stcph.c: New test. --- gcc/config/aarch64/aarch64-builtins.cc | 133 +++++++------ gcc/config/aarch64/arm_acle.h | 6 +- gcc/config/aarch64/atomics.md | 28 ++- gcc/config/aarch64/iterators.md | 2 +- .../aarch64/atomic_store_with_stshh.C | 22 +-- .../aarch64/atomic_store_with_shuh.c | 186 ++++++++++++++++++ .../aarch64/atomic_store_with_stcph.c | 186 ++++++++++++++++++ .../aarch64/atomic_store_with_stshh.c | 22 +-- 8 files changed, 490 insertions(+), 95 deletions(-) create mode 100644 gcc/testsuite/gcc.target/aarch64/atomic_store_with_shuh.c create mode 100644 gcc/testsuite/gcc.target/aarch64/atomic_store_with_stcph.c diff --git a/gcc/config/aarch64/aarch64-builtins.cc b/gcc/config/aarch64/aarch64-builtins.cc index 8a82b131b72c..5b1f9485d352 100644 --- a/gcc/config/aarch64/aarch64-builtins.cc +++ b/gcc/config/aarch64/aarch64-builtins.cc @@ -743,14 +743,14 @@ enum aarch64_builtins AARCH64_BUILTIN_GCSPOPM, AARCH64_BUILTIN_GCSSS, /* Armv9.6-A builtins. */ - AARCH64_BUILTIN_STSHH, - AARCH64_BUILTIN_STSHH_QI, - AARCH64_BUILTIN_STSHH_HI, - AARCH64_BUILTIN_STSHH_SI, - AARCH64_BUILTIN_STSHH_DI, - AARCH64_BUILTIN_STSHH_SF, - AARCH64_BUILTIN_STSHH_DF, - AARCH64_BUILTIN_STSHH_PTR, + AARCH64_BUILTIN_ATOMIC_HINTS_STORE, + AARCH64_BUILTIN_ATOMIC_HINTS_STORE_QI, + AARCH64_BUILTIN_ATOMIC_HINTS_STORE_HI, + AARCH64_BUILTIN_ATOMIC_HINTS_STORE_SI, + AARCH64_BUILTIN_ATOMIC_HINTS_STORE_DI, + AARCH64_BUILTIN_ATOMIC_HINTS_STORE_SF, + AARCH64_BUILTIN_ATOMIC_HINTS_STORE_DF, + AARCH64_BUILTIN_ATOMIC_HINTS_STORE_PTR, /* System Hint Operation builtins. */ AARCH64_BUILTIN_YIELD, AARCH64_BUILTIN_WFE, @@ -2287,10 +2287,10 @@ aarch64_init_gcs_builtins (void) AARCH64_BUILTIN_GCSSS); } -/* Add builtins for FEAT_PCDPHINT. */ +/* Add builtins for atomic hints. */ static void -aarch64_init_pcdphint_builtins (void) +aarch64_init_atomic_hints_builtins (void) { tree ftype; @@ -2298,65 +2298,72 @@ aarch64_init_pcdphint_builtins (void) void_type_node, unsigned_type_node, unsigned_type_node, NULL_TREE); - aarch64_builtin_decls[AARCH64_BUILTIN_STSHH] - = aarch64_general_add_builtin ("__builtin_aarch64_stshh", ftype, - AARCH64_BUILTIN_STSHH); + aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_STORE] + = aarch64_general_add_builtin ("__builtin_aarch64_atomic_hints_store", + ftype, AARCH64_BUILTIN_ATOMIC_HINTS_STORE); ftype = build_function_type_list (void_type_node, ptr_type_node, unsigned_char_type_node, unsigned_type_node, unsigned_type_node, NULL_TREE); - aarch64_builtin_decls[AARCH64_BUILTIN_STSHH_QI] - = aarch64_general_add_builtin ("__builtin_aarch64_stshh_qi", ftype, - AARCH64_BUILTIN_STSHH_QI); + aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_STORE_QI] + = aarch64_general_add_builtin ("__builtin_aarch64_atomic_hints_store_qi", + ftype, + AARCH64_BUILTIN_ATOMIC_HINTS_STORE_QI); ftype = build_function_type_list (void_type_node, ptr_type_node, short_unsigned_type_node, unsigned_type_node, unsigned_type_node, NULL_TREE); - aarch64_builtin_decls[AARCH64_BUILTIN_STSHH_HI] - = aarch64_general_add_builtin ("__builtin_aarch64_stshh_hi", ftype, - AARCH64_BUILTIN_STSHH_HI); + aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_STORE_HI] + = aarch64_general_add_builtin ("__builtin_aarch64_atomic_hints_store_hi", + ftype, + AARCH64_BUILTIN_ATOMIC_HINTS_STORE_HI); ftype = build_function_type_list (void_type_node, ptr_type_node, unsigned_type_node, unsigned_type_node, unsigned_type_node, NULL_TREE); - aarch64_builtin_decls[AARCH64_BUILTIN_STSHH_SI] - = aarch64_general_add_builtin ("__builtin_aarch64_stshh_si", ftype, - AARCH64_BUILTIN_STSHH_SI); + aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_STORE_SI] + = aarch64_general_add_builtin ("__builtin_aarch64_atomic_hints_store_si", + ftype, + AARCH64_BUILTIN_ATOMIC_HINTS_STORE_SI); ftype = build_function_type_list (void_type_node, ptr_type_node, long_long_unsigned_type_node, unsigned_type_node, unsigned_type_node, NULL_TREE); - aarch64_builtin_decls[AARCH64_BUILTIN_STSHH_DI] - = aarch64_general_add_builtin ("__builtin_aarch64_stshh_di", ftype, - AARCH64_BUILTIN_STSHH_DI); + aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_STORE_DI] + = aarch64_general_add_builtin ("__builtin_aarch64_atomic_hints_store_di", + ftype, + AARCH64_BUILTIN_ATOMIC_HINTS_STORE_DI); ftype = build_function_type_list (void_type_node, ptr_type_node, float_type_node, unsigned_type_node, unsigned_type_node, NULL_TREE); - aarch64_builtin_decls[AARCH64_BUILTIN_STSHH_SF] - = aarch64_general_add_builtin ("__builtin_aarch64_stshh_sf", ftype, - AARCH64_BUILTIN_STSHH_SF); + aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_STORE_SF] + = aarch64_general_add_builtin ("__builtin_aarch64_atomic_hints_store_sf", + ftype, + AARCH64_BUILTIN_ATOMIC_HINTS_STORE_SF); ftype = build_function_type_list (void_type_node, ptr_type_node, double_type_node, unsigned_type_node, unsigned_type_node, NULL_TREE); - aarch64_builtin_decls[AARCH64_BUILTIN_STSHH_DF] - = aarch64_general_add_builtin ("__builtin_aarch64_stshh_df", ftype, - AARCH64_BUILTIN_STSHH_DF); + aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_STORE_DF] + = aarch64_general_add_builtin ("__builtin_aarch64_atomic_hints_store_df", + ftype, + AARCH64_BUILTIN_ATOMIC_HINTS_STORE_DF); ftype = build_function_type_list (void_type_node, ptr_type_node, ptr_type_node, unsigned_type_node, unsigned_type_node, NULL_TREE); - aarch64_builtin_decls[AARCH64_BUILTIN_STSHH_PTR] - = aarch64_general_add_builtin ("__builtin_aarch64_stshh_ptr", ftype, - AARCH64_BUILTIN_STSHH_PTR); + aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_STORE_PTR] + = aarch64_general_add_builtin ("__builtin_aarch64_atomic_hints_store_ptr", + ftype, + AARCH64_BUILTIN_ATOMIC_HINTS_STORE_PTR); } @@ -2407,7 +2414,7 @@ aarch64_general_init_builtins (void) AARCH64_BUILTIN_CHKFEAT); aarch64_init_gcs_builtins (); - aarch64_init_pcdphint_builtins (); + aarch64_init_atomic_hints_builtins (); if (in_lto_p) handle_arm_acle_h (); @@ -3940,27 +3947,27 @@ aarch64_expand_tbl_tbx (vec &ops, unspec unspec) } void -aarch64_expand_stshh_builtin (tree exp, int fcode) +aarch64_expand_atomic_hints_builtins (tree exp, int fcode) { machine_mode mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1))); rtx val = expand_normal (CALL_EXPR_ARG (exp, 1)); rtx mem_order = expand_normal (CALL_EXPR_ARG (exp, 2)); - rtx ret = expand_normal (CALL_EXPR_ARG (exp, 3)); + rtx hint = expand_normal (CALL_EXPR_ARG (exp, 3)); - require_const_argument (exp, 3, 0, 2); + require_const_argument (exp, 3, 0, 5); require_const_argument (exp, 2, 0, 6); if (seen_error ()) return; switch (fcode) { - case AARCH64_BUILTIN_STSHH_SF: + case AARCH64_BUILTIN_ATOMIC_HINTS_STORE_SF: { val = force_lowpart_subreg (SImode, val, SFmode); mode = SImode; break; } - case AARCH64_BUILTIN_STSHH_DF: + case AARCH64_BUILTIN_ATOMIC_HINTS_STORE_DF: { val = force_lowpart_subreg (DImode, val, DFmode); mode = DImode; @@ -3980,12 +3987,12 @@ aarch64_expand_stshh_builtin (tree exp, int fcode) set_mem_align (mem, GET_MODE_ALIGNMENT (mode)); expand_operand ops[4]; - enum insn_code icode = code_for_aarch64_atomic_store_stshh (mode); + enum insn_code icode; create_output_operand (&ops[0], mem, mode); create_input_operand (&ops[1], val, mode); create_input_operand (&ops[2], mem_order, SImode); - create_input_operand (&ops[3], ret, SImode); - + create_input_operand (&ops[3], hint, SImode); + icode = code_for_aarch64_atomic_hints_store (mode); expand_insn (icode, 4, ops); } @@ -4457,14 +4464,14 @@ aarch64_general_expand_builtin (unsigned int fcode, tree exp, rtx target, case AARCH64_BUILTIN_GCSSS: return aarch64_expand_gcs_builtin (exp, target, fcode, ignore); - case AARCH64_BUILTIN_STSHH_QI: - case AARCH64_BUILTIN_STSHH_HI: - case AARCH64_BUILTIN_STSHH_SI: - case AARCH64_BUILTIN_STSHH_DI: - case AARCH64_BUILTIN_STSHH_SF: - case AARCH64_BUILTIN_STSHH_DF: - case AARCH64_BUILTIN_STSHH_PTR: - aarch64_expand_stshh_builtin (exp, fcode); + case AARCH64_BUILTIN_ATOMIC_HINTS_STORE_QI: + case AARCH64_BUILTIN_ATOMIC_HINTS_STORE_HI: + case AARCH64_BUILTIN_ATOMIC_HINTS_STORE_SI: + case AARCH64_BUILTIN_ATOMIC_HINTS_STORE_DI: + case AARCH64_BUILTIN_ATOMIC_HINTS_STORE_SF: + case AARCH64_BUILTIN_ATOMIC_HINTS_STORE_DF: + case AARCH64_BUILTIN_ATOMIC_HINTS_STORE_PTR: + aarch64_expand_atomic_hints_builtins (exp, fcode); return target; } @@ -5442,11 +5449,9 @@ aarch64_resolve_overloaded_memtag (location_t loc, } static tree -aarch64_resolve_overloaded_builtin_stshh (void *pass_params) +aarch64_resolve_overloaded_builtin_atomic_hints (void *pass_params) { vec *params = static_cast *> (pass_params); - if (vec_safe_length (params) != 4) - return NULL_TREE; tree addr = (*params)[0]; tree val = (*params)[1]; @@ -5459,23 +5464,25 @@ aarch64_resolve_overloaded_builtin_stshh (void *pass_params) tree ptr_type = TYPE_MAIN_VARIANT (TREE_TYPE (addr_type)); + if (vec_safe_length (params) != 4) + return NULL_TREE; if (POINTER_TYPE_P (ptr_type)) - return aarch64_builtin_decls[AARCH64_BUILTIN_STSHH_PTR]; + return aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_STORE_PTR]; switch (TYPE_MODE (ptr_type)) { case QImode: - return aarch64_builtin_decls[AARCH64_BUILTIN_STSHH_QI]; + return aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_STORE_QI]; case HImode: - return aarch64_builtin_decls[AARCH64_BUILTIN_STSHH_HI]; + return aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_STORE_HI]; case SImode: - return aarch64_builtin_decls[AARCH64_BUILTIN_STSHH_SI]; + return aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_STORE_SI]; case DImode: - return aarch64_builtin_decls[AARCH64_BUILTIN_STSHH_DI]; + return aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_STORE_DI]; case SFmode: - return aarch64_builtin_decls[AARCH64_BUILTIN_STSHH_SF]; + return aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_STORE_SF]; case DFmode: - return aarch64_builtin_decls[AARCH64_BUILTIN_STSHH_DF]; + return aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_STORE_DF]; default: return NULL_TREE; } @@ -5492,8 +5499,8 @@ aarch64_resolve_overloaded_builtin_general (location_t loc, tree function, && fcode <= AARCH64_MEMTAG_BUILTIN_END) return aarch64_resolve_overloaded_memtag(loc, function, pass_params); - if (fcode == AARCH64_BUILTIN_STSHH) - return aarch64_resolve_overloaded_builtin_stshh (pass_params); + if (fcode == AARCH64_BUILTIN_ATOMIC_HINTS_STORE) + return aarch64_resolve_overloaded_builtin_atomic_hints (pass_params); return NULL_TREE; } diff --git a/gcc/config/aarch64/arm_acle.h b/gcc/config/aarch64/arm_acle.h index b31e23e6cbae..9317f1d2371c 100644 --- a/gcc/config/aarch64/arm_acle.h +++ b/gcc/config/aarch64/arm_acle.h @@ -102,9 +102,9 @@ __sqrtf (float __x) return __builtin_aarch64_sqrtsf (__x); } -#define __atomic_store_with_stshh(__addr, __value, __memory_order, __ret) \ - __builtin_aarch64_stshh ((__addr), (__value), \ - (__memory_order), (__ret)) +#define __arm_atomic_store_with_hint(__addr, __value, __memory_order, __hint) \ + __builtin_aarch64_atomic_hints_store ((__addr), (__value), \ + (__memory_order), (__hint)) #pragma GCC push_options #pragma GCC target ("+nothing+jscvt") diff --git a/gcc/config/aarch64/atomics.md b/gcc/config/aarch64/atomics.md index 2316fea8135a..dca36242cb01 100644 --- a/gcc/config/aarch64/atomics.md +++ b/gcc/config/aarch64/atomics.md @@ -751,19 +751,35 @@ [(set_attr "arch" "*,rcpc8_4")] ) -(define_insn "@aarch64_atomic_store_stshh" +(define_insn "@aarch64_atomic_hints_store" [(set (match_operand:ALLI 0 "aarch64_rcpc_memory_operand" "=Q,Ust") (unspec_volatile:ALLI [(match_operand:ALLI 1 "aarch64_reg_or_zero" "rZ,rZ") (match_operand:SI 2 "const_int_operand") ;; model (match_operand:SI 3 "const_int_operand")] ;; ret_policy - UNSPECV_STSHH))] + UNSPECV_ATOMIC_HINTS_STORE))] "" { - if (INTVAL (operands[3]) == 0) - output_asm_insn ("stshh\tkeep", operands); - else - output_asm_insn ("stshh\tstrm", operands); + switch (INTVAL (operands[3])) + { + case 0: + output_asm_insn ("stshh\tkeep", operands); + break; + case 1: + output_asm_insn ("stshh\tstrm", operands); + break; + case 2: + output_asm_insn ("stcph", operands); + break; + case 3: + output_asm_insn ("shuh", operands); + break; + case 4: + output_asm_insn ("shuh\tph", operands); + break; + default: + gcc_unreachable (); + } enum memmodel model = memmodel_from_int (INTVAL (operands[2])); if (is_mm_relaxed (model) || is_mm_consume (model) || is_mm_acquire (model)) return "str\t%1, %0"; diff --git a/gcc/config/aarch64/iterators.md b/gcc/config/aarch64/iterators.md index 8ed91d021f07..eea783ffc081 100644 --- a/gcc/config/aarch64/iterators.md +++ b/gcc/config/aarch64/iterators.md @@ -1478,7 +1478,7 @@ UNSPECV_LDA ; Represent an atomic load or load-acquire. UNSPECV_LDAP ; Represent an atomic acquire load with RCpc semantics. UNSPECV_STL ; Represent an atomic store or store-release. - UNSPECV_STSHH ; Represent an atomic store with an stshh hint. + UNSPECV_ATOMIC_HINTS_STORE ; Represent an atomic store with a hint. UNSPECV_ATOMIC_CMPSW ; Represent an atomic compare swap. UNSPECV_ATOMIC_EXCHG ; Represent an atomic exchange. UNSPECV_ATOMIC_CAS ; Represent an atomic CAS. diff --git a/gcc/testsuite/g++.target/aarch64/atomic_store_with_stshh.C b/gcc/testsuite/g++.target/aarch64/atomic_store_with_stshh.C index d22412369ef8..5553c5d67df5 100644 --- a/gcc/testsuite/g++.target/aarch64/atomic_store_with_stshh.C +++ b/gcc/testsuite/g++.target/aarch64/atomic_store_with_stshh.C @@ -18,7 +18,7 @@ testFun1 () char* ptr1 = &item1; char test1 = 1; - __atomic_store_with_stshh (ptr1, test1, __ATOMIC_RELAXED, 0); + __arm_atomic_store_with_hint (ptr1, test1, __ATOMIC_RELAXED, 0); } /* @@ -34,7 +34,7 @@ testFun2 () short item2 = 10; short* ptr2 = &item2; short test2 = 11; - __atomic_store_with_stshh (ptr2, test2, __ATOMIC_RELEASE, 0); + __arm_atomic_store_with_hint (ptr2, test2, __ATOMIC_RELEASE, 0); } /* @@ -50,7 +50,7 @@ testFun3 () unsigned int item3 = 10; unsigned int* ptr3 = &item3; unsigned int test3 = 11; - __atomic_store_with_stshh (ptr3, test3, __ATOMIC_SEQ_CST, 1); + __arm_atomic_store_with_hint (ptr3, test3, __ATOMIC_SEQ_CST, 1); } /* @@ -66,7 +66,7 @@ testFun4 () long item4 = 10; long* ptr4 = &item4; long test4 = 11; - __atomic_store_with_stshh (ptr4, test4, __ATOMIC_RELAXED, 1); + __arm_atomic_store_with_hint (ptr4, test4, __ATOMIC_RELAXED, 1); } /* @@ -84,7 +84,7 @@ testFun5 () long **ptr5 = &ptritem; long test5item = 11; long *test5 = &test5item; - __atomic_store_with_stshh (ptr5, test5, __ATOMIC_SEQ_CST, 0); + __arm_atomic_store_with_hint (ptr5, test5, __ATOMIC_SEQ_CST, 0); } /* @@ -100,7 +100,7 @@ testFun6 () float item6 = 10; float* ptr6 = &item6; float test6 = 11; - __atomic_store_with_stshh (ptr6, test6, __ATOMIC_SEQ_CST, 0); + __arm_atomic_store_with_hint (ptr6, test6, __ATOMIC_SEQ_CST, 0); } /* @@ -116,7 +116,7 @@ testFun7 () double item7 = 10; double* ptr7 = &item7; double test7 = 11; - __atomic_store_with_stshh (ptr7, test7, __ATOMIC_RELAXED, 1); + __arm_atomic_store_with_hint (ptr7, test7, __ATOMIC_RELAXED, 1); } /* @@ -133,7 +133,7 @@ testFun8 () char* ptr8 = &item8; long test8 = 1; - __atomic_store_with_stshh (ptr8, test8, __ATOMIC_RELAXED, 0); + __arm_atomic_store_with_hint (ptr8, test8, __ATOMIC_RELAXED, 0); } /* @@ -150,7 +150,7 @@ testFun9 () int* ptr9 = &item9; float test9 = 1; - __atomic_store_with_stshh (ptr9, test9, __ATOMIC_RELAXED, 1); + __arm_atomic_store_with_hint (ptr9, test9, __ATOMIC_RELAXED, 1); } /* @@ -166,7 +166,7 @@ static char buf[8]; void testFun10 (void) { - __atomic_store_with_stshh((buf + 1), (char)7, __ATOMIC_RELAXED, 1); + __arm_atomic_store_with_hint((buf + 1), (char)7, __ATOMIC_RELAXED, 1); } /* @@ -182,5 +182,5 @@ testFun11 () int item11 = 10; int* ptr11 = &item11; - __atomic_store_with_stshh (ptr11, 0, __ATOMIC_RELAXED, 1); + __arm_atomic_store_with_hint (ptr11, 0, __ATOMIC_RELAXED, 1); } diff --git a/gcc/testsuite/gcc.target/aarch64/atomic_store_with_shuh.c b/gcc/testsuite/gcc.target/aarch64/atomic_store_with_shuh.c new file mode 100644 index 000000000000..ce457a85568f --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/atomic_store_with_shuh.c @@ -0,0 +1,186 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=armv8-a -save-temps" } */ +/* { dg-final { check-function-bodies "**" "" } } */ + +#include + +/* +** testFun1: +** ... +** shuh +** strb w[0-9]+, \[x[0-9]+\] +** ... +*/ +void +testFun1 () +{ + char item1 = 0; + char* ptr1 = &item1; + char test1 = 1; + + __arm_atomic_store_with_hint (ptr1, test1, __ATOMIC_RELAXED, 3); +} + +/* +** testFun2: +** ... +** shuh ph +** stlrh w[0-9]+, \[x[0-9]+\] +** ... +*/ +void +testFun2 () +{ + short item2 = 10; + short* ptr2 = &item2; + short test2 = 11; + __arm_atomic_store_with_hint (ptr2, test2, __ATOMIC_RELEASE, 4); +} + +/* +** testFun3: +** ... +** shuh +** stlr w[0-9]+, \[x[0-9]+\] +** ... +*/ +void +testFun3 () +{ + unsigned int item3 = 10; + unsigned int* ptr3 = &item3; + unsigned int test3 = 11; + __arm_atomic_store_with_hint (ptr3, test3, __ATOMIC_SEQ_CST, 3); +} + +/* +** testFun4: +** ... +** shuh +** str x[0-9]+, \[x[0-9]+\] +** ... +*/ +void +testFun4 () +{ + long item4 = 10; + long* ptr4 = &item4; + long test4 = 11; + __arm_atomic_store_with_hint (ptr4, test4, __ATOMIC_RELAXED, 3); +} + +/* +** testFun5: +** ... +** shuh ph +** stlr x[0-9]+, \[x[0-9]+\] +** ... +*/ +void +testFun5 () +{ + long item5 = 10; + long *ptritem = &item5; + long **ptr5 = &ptritem; + long test5item = 11; + long *test5 = &test5item; + __arm_atomic_store_with_hint (ptr5, test5, __ATOMIC_SEQ_CST, 4); +} + +/* +** testFun6: +** ... +** shuh +** stlr w[0-9]+, \[x[0-9]+\] +** ... +*/ +void +testFun6 () +{ + float item6 = 10; + float* ptr6 = &item6; + float test6 = 11; + __arm_atomic_store_with_hint (ptr6, test6, __ATOMIC_SEQ_CST, 3); +} + +/* +** testFun7: +** ... +** shuh ph +** str x[0-9]+, \[x[0-9]+\] +** ... +*/ +void +testFun7 () +{ + double item7 = 10; + double* ptr7 = &item7; + double test7 = 11; + __arm_atomic_store_with_hint (ptr7, test7, __ATOMIC_RELAXED, 4); +} + +/* +** testFun8: +** ... +** shuh ph +** strb w[0-9]+, \[x[0-9]+\] +** ... +*/ +void +testFun8 () +{ + char item8 = 0; + char* ptr8 = &item8; + long test8 = 1; + + __arm_atomic_store_with_hint (ptr8, test8, __ATOMIC_RELAXED, 4); +} + +/* +** testFun9: +** ... +** shuh +** str w[0-9]+, \[x[0-9]+\] +** ... +*/ +void +testFun9 () +{ + int item9 = 0; + int* ptr9 = &item9; + float test9 = 1; + + __arm_atomic_store_with_hint (ptr9, test9, __ATOMIC_RELAXED, 3); +} + +/* +** testFun10: +** ... +** add (x[0-9]+), \1, 1 +** mov (w[0-9]+), 7 +** shuh +** strb \2, \[\1\] +** ... +*/ +static char buf[8]; +void +testFun10 (void) +{ + __arm_atomic_store_with_hint((buf + 1), (char)7, __ATOMIC_RELAXED, 3); +} + +/* +** testFun11: +** ... +** shuh +** str wzr, \[x[0-9]+\] +** ... +*/ +void +testFun11 () +{ + int item11 = 10; + int* ptr11 = &item11; + + __arm_atomic_store_with_hint (ptr11, 0, __ATOMIC_RELAXED, 3); +} diff --git a/gcc/testsuite/gcc.target/aarch64/atomic_store_with_stcph.c b/gcc/testsuite/gcc.target/aarch64/atomic_store_with_stcph.c new file mode 100644 index 000000000000..a762da3e1f61 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/atomic_store_with_stcph.c @@ -0,0 +1,186 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=armv8-a -save-temps" } */ +/* { dg-final { check-function-bodies "**" "" } } */ + +#include + +/* +** testFun1: +** ... +** stcph +** strb w[0-9]+, \[x[0-9]+\] +** ... +*/ +void +testFun1 () +{ + char item1 = 0; + char* ptr1 = &item1; + char test1 = 1; + + __arm_atomic_store_with_hint (ptr1, test1, __ATOMIC_RELAXED, 2); +} + +/* +** testFun2: +** ... +** stcph +** stlrh w[0-9]+, \[x[0-9]+\] +** ... +*/ +void +testFun2 () +{ + short item2 = 10; + short* ptr2 = &item2; + short test2 = 11; + __arm_atomic_store_with_hint (ptr2, test2, __ATOMIC_RELEASE, 2); +} + +/* +** testFun3: +** ... +** stcph +** stlr w[0-9]+, \[x[0-9]+\] +** ... +*/ +void +testFun3 () +{ + unsigned int item3 = 10; + unsigned int* ptr3 = &item3; + unsigned int test3 = 11; + __arm_atomic_store_with_hint (ptr3, test3, __ATOMIC_SEQ_CST, 2); +} + +/* +** testFun4: +** ... +** stcph +** str x[0-9]+, \[x[0-9]+\] +** ... +*/ +void +testFun4 () +{ + long item4 = 10; + long* ptr4 = &item4; + long test4 = 11; + __arm_atomic_store_with_hint (ptr4, test4, __ATOMIC_RELAXED, 2); +} + +/* +** testFun5: +** ... +** stcph +** stlr x[0-9]+, \[x[0-9]+\] +** ... +*/ +void +testFun5 () +{ + long item5 = 10; + long *ptritem = &item5; + long **ptr5 = &ptritem; + long test5item = 11; + long *test5 = &test5item; + __arm_atomic_store_with_hint (ptr5, test5, __ATOMIC_SEQ_CST, 2); +} + +/* +** testFun6: +** ... +** stcph +** stlr w[0-9]+, \[x[0-9]+\] +** ... +*/ +void +testFun6 () +{ + float item6 = 10; + float* ptr6 = &item6; + float test6 = 11; + __arm_atomic_store_with_hint (ptr6, test6, __ATOMIC_SEQ_CST, 2); +} + +/* +** testFun7: +** ... +** stcph +** str x[0-9]+, \[x[0-9]+\] +** ... +*/ +void +testFun7 () +{ + double item7 = 10; + double* ptr7 = &item7; + double test7 = 11; + __arm_atomic_store_with_hint (ptr7, test7, __ATOMIC_RELAXED, 2); +} + +/* +** testFun8: +** ... +** stcph +** strb w[0-9]+, \[x[0-9]+\] +** ... +*/ +void +testFun8 () +{ + char item8 = 0; + char* ptr8 = &item8; + long test8 = 1; + + __arm_atomic_store_with_hint (ptr8, test8, __ATOMIC_RELAXED, 2); +} + +/* +** testFun9: +** ... +** stcph +** str w[0-9]+, \[x[0-9]+\] +** ... +*/ +void +testFun9 () +{ + int item9 = 0; + int* ptr9 = &item9; + float test9 = 1; + + __arm_atomic_store_with_hint (ptr9, test9, __ATOMIC_RELAXED, 2); +} + +/* +** testFun10: +** ... +** add (x[0-9]+), \1, 1 +** mov (w[0-9]+), 7 +** stcph +** strb \2, \[\1\] +** ... +*/ +static char buf[8]; +void +testFun10 (void) +{ + __arm_atomic_store_with_hint((buf + 1), (char)7, __ATOMIC_RELAXED, 2); +} + +/* +** testFun11: +** ... +** stcph +** str wzr, \[x[0-9]+\] +** ... +*/ +void +testFun11 () +{ + int item11 = 10; + int* ptr11 = &item11; + + __arm_atomic_store_with_hint (ptr11, 0, __ATOMIC_RELAXED, 2); +} diff --git a/gcc/testsuite/gcc.target/aarch64/atomic_store_with_stshh.c b/gcc/testsuite/gcc.target/aarch64/atomic_store_with_stshh.c index 516a45aa7811..3948ffcef280 100644 --- a/gcc/testsuite/gcc.target/aarch64/atomic_store_with_stshh.c +++ b/gcc/testsuite/gcc.target/aarch64/atomic_store_with_stshh.c @@ -18,7 +18,7 @@ testFun1 () char* ptr1 = &item1; char test1 = 1; - __atomic_store_with_stshh (ptr1, test1, __ATOMIC_RELAXED, 0); + __arm_atomic_store_with_hint (ptr1, test1, __ATOMIC_RELAXED, 0); } /* @@ -34,7 +34,7 @@ testFun2 () short item2 = 10; short* ptr2 = &item2; short test2 = 11; - __atomic_store_with_stshh (ptr2, test2, __ATOMIC_RELEASE, 0); + __arm_atomic_store_with_hint (ptr2, test2, __ATOMIC_RELEASE, 0); } /* @@ -50,7 +50,7 @@ testFun3 () unsigned int item3 = 10; unsigned int* ptr3 = &item3; unsigned int test3 = 11; - __atomic_store_with_stshh (ptr3, test3, __ATOMIC_SEQ_CST, 1); + __arm_atomic_store_with_hint (ptr3, test3, __ATOMIC_SEQ_CST, 1); } /* @@ -66,7 +66,7 @@ testFun4 () long item4 = 10; long* ptr4 = &item4; long test4 = 11; - __atomic_store_with_stshh (ptr4, test4, __ATOMIC_RELAXED, 1); + __arm_atomic_store_with_hint (ptr4, test4, __ATOMIC_RELAXED, 1); } /* @@ -84,7 +84,7 @@ testFun5 () long **ptr5 = &ptritem; long test5item = 11; long *test5 = &test5item; - __atomic_store_with_stshh (ptr5, test5, __ATOMIC_SEQ_CST, 0); + __arm_atomic_store_with_hint (ptr5, test5, __ATOMIC_SEQ_CST, 0); } /* @@ -100,7 +100,7 @@ testFun6 () float item6 = 10; float* ptr6 = &item6; float test6 = 11; - __atomic_store_with_stshh (ptr6, test6, __ATOMIC_SEQ_CST, 0); + __arm_atomic_store_with_hint (ptr6, test6, __ATOMIC_SEQ_CST, 0); } /* @@ -116,7 +116,7 @@ testFun7 () double item7 = 10; double* ptr7 = &item7; double test7 = 11; - __atomic_store_with_stshh (ptr7, test7, __ATOMIC_RELAXED, 1); + __arm_atomic_store_with_hint (ptr7, test7, __ATOMIC_RELAXED, 1); } /* @@ -133,7 +133,7 @@ testFun8 () char* ptr8 = &item8; long test8 = 1; - __atomic_store_with_stshh (ptr8, test8, __ATOMIC_RELAXED, 0); + __arm_atomic_store_with_hint (ptr8, test8, __ATOMIC_RELAXED, 0); } /* @@ -150,7 +150,7 @@ testFun9 () int* ptr9 = &item9; float test9 = 1; - __atomic_store_with_stshh (ptr9, test9, __ATOMIC_RELAXED, 1); + __arm_atomic_store_with_hint (ptr9, test9, __ATOMIC_RELAXED, 1); } /* @@ -166,7 +166,7 @@ static char buf[8]; void testFun10 (void) { - __atomic_store_with_stshh((buf + 1), (char)7, __ATOMIC_RELAXED, 1); + __arm_atomic_store_with_hint((buf + 1), (char)7, __ATOMIC_RELAXED, 1); } /* @@ -182,5 +182,5 @@ testFun11 () int item11 = 10; int* ptr11 = &item11; - __atomic_store_with_stshh (ptr11, 0, __ATOMIC_RELAXED, 1); + __arm_atomic_store_with_hint (ptr11, 0, __ATOMIC_RELAXED, 1); } From 4015b65b038bea050c7892aa4535020493cd7c66 Mon Sep 17 00:00:00 2001 From: Richard Ball Date: Fri, 18 Sep 2026 20:06:44 +0100 Subject: [PATCH 216/584] aarch64: Add support for FEAT_CMH atomic_fetch intrinsics This patch adds support for a new atomic_fetch_with_hint intrinsic. This intrinsic will make use of a new hint added by FEAT_CMH which is SHUH and SHUH PH. gcc/ChangeLog: * config/aarch64/aarch64-builtins.cc (enum aarch64_builtins): Add new builtins. (aarch64_init_atomic_hints_builtins): Likewise. (aarch64_expand_atomic_hints_builtins_fetch): Handle Fetch intrinsics. (aarch64_general_expand_builtin): Add call for new builtins. (aarch64_resolve_overloaded_builtin_atomic_hint_fetch): Handle Fetch intrinsics. (aarch64_resolve_overloaded_builtin_general): Add new call. * config/aarch64/arm_acle.h (enum atomic_fetch): Store different Fetch types. (__arm_atomic_fetch_add_with_hint): Add new builtin. (__arm_atomic_fetch_sub_with_hint): Likewise. (__arm_atomic_fetch_and_with_hint): Likewise. (__arm_atomic_fetch_xor_with_hint): Likewise. (__arm_atomic_fetch_or_with_hint): Likewise. * config/aarch64/atomics.md (aarch64_atomic_fetch__atomic_hint): New pattern for atomic_fetch. (@aarch64_atomic_hints_fetch): Likewise. * config/aarch64/iterators.md: New unspecs. gcc/testsuite/ChangeLog: * gcc.target/aarch64/atomic_fetch_add_with_shuh.c: New test. * gcc.target/aarch64/atomic_fetch_and_with_shuh.c: New test. * gcc.target/aarch64/atomic_fetch_or_with_shuh.c: New test. * gcc.target/aarch64/atomic_fetch_sub_with_shuh.c: New test. * gcc.target/aarch64/atomic_fetch_xor_with_shuh.c: New test. --- gcc/config/aarch64/aarch64-builtins.cc | 220 +++++++++++++++++- gcc/config/aarch64/arm_acle.h | 39 ++++ gcc/config/aarch64/atomics.md | 77 ++++++ gcc/config/aarch64/iterators.md | 2 + .../aarch64/atomic_fetch_add_with_shuh.c | 151 ++++++++++++ .../aarch64/atomic_fetch_and_with_shuh.c | 150 ++++++++++++ .../aarch64/atomic_fetch_or_with_shuh.c | 150 ++++++++++++ .../aarch64/atomic_fetch_sub_with_shuh.c | 162 +++++++++++++ .../aarch64/atomic_fetch_xor_with_shuh.c | 150 ++++++++++++ 9 files changed, 1099 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/gcc.target/aarch64/atomic_fetch_add_with_shuh.c create mode 100644 gcc/testsuite/gcc.target/aarch64/atomic_fetch_and_with_shuh.c create mode 100644 gcc/testsuite/gcc.target/aarch64/atomic_fetch_or_with_shuh.c create mode 100644 gcc/testsuite/gcc.target/aarch64/atomic_fetch_sub_with_shuh.c create mode 100644 gcc/testsuite/gcc.target/aarch64/atomic_fetch_xor_with_shuh.c diff --git a/gcc/config/aarch64/aarch64-builtins.cc b/gcc/config/aarch64/aarch64-builtins.cc index 5b1f9485d352..3389fc93af73 100644 --- a/gcc/config/aarch64/aarch64-builtins.cc +++ b/gcc/config/aarch64/aarch64-builtins.cc @@ -751,6 +751,16 @@ enum aarch64_builtins AARCH64_BUILTIN_ATOMIC_HINTS_STORE_SF, AARCH64_BUILTIN_ATOMIC_HINTS_STORE_DF, AARCH64_BUILTIN_ATOMIC_HINTS_STORE_PTR, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_QI, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_HI, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SI, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_DI, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_QI, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_HI, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_SI, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_DI, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_PTR, /* System Hint Operation builtins. */ AARCH64_BUILTIN_YIELD, AARCH64_BUILTIN_WFE, @@ -2365,6 +2375,106 @@ aarch64_init_atomic_hints_builtins (void) ftype, AARCH64_BUILTIN_ATOMIC_HINTS_STORE_PTR); + ftype = build_function_type_list (void_type_node, ptr_type_node, + void_type_node, + unsigned_type_node, + unsigned_type_node, + unsigned_type_node, NULL_TREE); + aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH] + = aarch64_general_add_builtin ("__builtin_aarch64_atomic_hints_fetch", + ftype, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH); + + ftype = build_function_type_list (unsigned_char_type_node, ptr_type_node, + unsigned_char_type_node, + unsigned_type_node, + unsigned_type_node, + unsigned_type_node, NULL_TREE); + aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_QI] + = aarch64_general_add_builtin ("__builtin_aarch64_atomic_hints_fetch_qi", + ftype, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_QI); + + ftype = build_function_type_list (short_unsigned_type_node, ptr_type_node, + short_unsigned_type_node, + unsigned_type_node, + unsigned_type_node, + unsigned_type_node, NULL_TREE); + aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_HI] + = aarch64_general_add_builtin ("__builtin_aarch64_atomic_hints_fetch_hi", + ftype, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_HI); + + ftype = build_function_type_list (unsigned_type_node, ptr_type_node, + unsigned_type_node, + unsigned_type_node, + unsigned_type_node, + unsigned_type_node, NULL_TREE); + aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SI] + = aarch64_general_add_builtin ("__builtin_aarch64_atomic_hints_fetch_si", + ftype, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SI); + + ftype = build_function_type_list (long_long_unsigned_type_node, ptr_type_node, + long_long_unsigned_type_node, + unsigned_type_node, + unsigned_type_node, + unsigned_type_node, NULL_TREE); + aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_DI] + = aarch64_general_add_builtin ("__builtin_aarch64_atomic_hints_fetch_di", + ftype, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_DI); + + ftype = build_function_type_list (char_type_node, ptr_type_node, + char_type_node, + unsigned_type_node, + unsigned_type_node, + unsigned_type_node, NULL_TREE); + aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_QI] + = aarch64_general_add_builtin ("__builtin_aarch64_atomic_hints_fetch_signed_qi", + ftype, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_QI); + + ftype = build_function_type_list (short_integer_type_node, ptr_type_node, + short_integer_type_node, + unsigned_type_node, + unsigned_type_node, + unsigned_type_node, NULL_TREE); + aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_HI] + = aarch64_general_add_builtin ("__builtin_aarch64_atomic_hints_fetch_signed_hi", + ftype, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_HI); + + ftype = build_function_type_list (integer_type_node, ptr_type_node, + integer_type_node, + unsigned_type_node, + unsigned_type_node, + unsigned_type_node, NULL_TREE); + aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_SI] + = aarch64_general_add_builtin ("__builtin_aarch64_atomic_hints_fetch_signed_si", + ftype, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_SI); + + ftype = build_function_type_list (long_long_integer_type_node, ptr_type_node, + long_long_integer_type_node, + unsigned_type_node, + unsigned_type_node, + unsigned_type_node, NULL_TREE); + aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_DI] + = aarch64_general_add_builtin ("__builtin_aarch64_atomic_hints_fetch_signed_di", + ftype, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_DI); + + ftype = build_function_type_list (ptr_type_node, ptr_type_node, + ptr_type_node, + unsigned_type_node, + unsigned_type_node, + unsigned_type_node, NULL_TREE); + aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_PTR] + = aarch64_general_add_builtin ("__builtin_aarch64_atomic_hints_fetch_ptr", + ftype, + AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_PTR); + } /* Initialize all builtins in the AARCH64_BUILTIN_GENERAL group. */ @@ -3996,6 +4106,47 @@ aarch64_expand_atomic_hints_builtins (tree exp, int fcode) expand_insn (icode, 4, ops); } +static rtx +aarch64_expand_atomic_hints_builtins_fetch (tree exp) +{ + machine_mode mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1))); + rtx val = expand_normal (CALL_EXPR_ARG (exp, 1)); + rtx mem_order = expand_normal (CALL_EXPR_ARG (exp, 2)); + rtx hint = expand_normal (CALL_EXPR_ARG (exp, 3)); + rtx fetch_type = expand_normal (CALL_EXPR_ARG (exp, 4)); + + require_const_argument (exp, 3, 0, 2); + require_const_argument (exp, 2, 0, 6); + require_const_argument (exp, 4, 0, 6); + if (seen_error ()) + return const0_rtx; + + if (!TARGET_LSE) + { + error_at (EXPR_LOCATION (exp), + "%qs must be enabled for this builtin", "TARGET_LSE"); + return const0_rtx; + } + + val = force_reg (mode, val); + rtx addr = expand_normal (CALL_EXPR_ARG (exp, 0)); + addr = force_reg (Pmode, addr); + rtx mem = gen_rtx_MEM (mode, addr); + + rtx return_val = gen_reg_rtx (mode); + expand_operand ops[6]; + enum insn_code icode; + create_output_operand (&ops[0], return_val, mode); + create_input_operand (&ops[1], mem, mode); + create_input_operand (&ops[2], val, mode); + create_input_operand (&ops[3], mem_order, SImode); + create_input_operand (&ops[4], hint, SImode); + create_input_operand (&ops[5], fetch_type, SImode); + icode = code_for_aarch64_atomic_hints_fetch (mode); + expand_insn (icode, 6, ops); + return (ops[0].value); +} + void aarch64_expand_pldir_builtin (tree exp) { @@ -4473,6 +4624,17 @@ aarch64_general_expand_builtin (unsigned int fcode, tree exp, rtx target, case AARCH64_BUILTIN_ATOMIC_HINTS_STORE_PTR: aarch64_expand_atomic_hints_builtins (exp, fcode); return target; + + case AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_QI: + case AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_HI: + case AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SI: + case AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_DI: + case AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_QI: + case AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_HI: + case AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_SI: + case AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_DI: + case AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_PTR: + return aarch64_expand_atomic_hints_builtins_fetch (exp); } if (fcode >= AARCH64_SIMD_BUILTIN_BASE && fcode <= AARCH64_SIMD_BUILTIN_MAX) @@ -5449,7 +5611,7 @@ aarch64_resolve_overloaded_memtag (location_t loc, } static tree -aarch64_resolve_overloaded_builtin_atomic_hints (void *pass_params) +aarch64_resolve_overloaded_builtin_atomic_hint_store (void *pass_params) { vec *params = static_cast *> (pass_params); @@ -5488,6 +5650,57 @@ aarch64_resolve_overloaded_builtin_atomic_hints (void *pass_params) } } +static tree +aarch64_resolve_overloaded_builtin_atomic_hint_fetch (void *pass_params) +{ + vec *params = static_cast *> (pass_params); + + tree addr = (*params)[0]; + + tree addr_type = TREE_TYPE (addr); + if (!POINTER_TYPE_P (addr_type)) + return NULL_TREE; + + tree ptr_type = TYPE_MAIN_VARIANT (TREE_TYPE (addr_type)); + + if (vec_safe_length (params) != 5) + return NULL_TREE; + if (POINTER_TYPE_P (ptr_type)) + return aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_PTR]; + if (TYPE_UNSIGNED (ptr_type)) + { + switch (TYPE_MODE (ptr_type)) + { + case QImode: + return aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_QI]; + case HImode: + return aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_HI]; + case SImode: + return aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SI]; + case DImode: + return aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_DI]; + default: + return NULL_TREE; + } + } + else + { + switch (TYPE_MODE (ptr_type)) + { + case QImode: + return aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_QI]; + case HImode: + return aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_HI]; + case SImode: + return aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_SI]; + case DImode: + return aarch64_builtin_decls[AARCH64_BUILTIN_ATOMIC_HINTS_FETCH_SIGNED_DI]; + default: + return NULL_TREE; + } + } +} + /* Called at aarch64_resolve_overloaded_builtin in aarch64-c.cc. */ tree aarch64_resolve_overloaded_builtin_general (location_t loc, tree function, @@ -5500,7 +5713,10 @@ aarch64_resolve_overloaded_builtin_general (location_t loc, tree function, return aarch64_resolve_overloaded_memtag(loc, function, pass_params); if (fcode == AARCH64_BUILTIN_ATOMIC_HINTS_STORE) - return aarch64_resolve_overloaded_builtin_atomic_hints (pass_params); + return aarch64_resolve_overloaded_builtin_atomic_hint_store (pass_params); + + if (fcode == AARCH64_BUILTIN_ATOMIC_HINTS_FETCH) + return aarch64_resolve_overloaded_builtin_atomic_hint_fetch (pass_params); return NULL_TREE; } diff --git a/gcc/config/aarch64/arm_acle.h b/gcc/config/aarch64/arm_acle.h index 9317f1d2371c..84ba62e33189 100644 --- a/gcc/config/aarch64/arm_acle.h +++ b/gcc/config/aarch64/arm_acle.h @@ -46,6 +46,15 @@ NAME (TYPE __value, uint32_t __rotate) \ return __value >> __rotate | __value << ((__size - __rotate) % __size); \ } +enum atomic_fetch +{ + FETCH_ADD, + FETCH_SUB, + FETCH_AND, + FETCH_XOR, + FETCH_OR, +}; + _GCC_ARM_ACLE_ROR_FN (__ror, uint32_t) _GCC_ARM_ACLE_ROR_FN (__rorl, unsigned long) _GCC_ARM_ACLE_ROR_FN (__rorll, uint64_t) @@ -106,6 +115,36 @@ __sqrtf (float __x) __builtin_aarch64_atomic_hints_store ((__addr), (__value), \ (__memory_order), (__hint)) +#define __arm_atomic_fetch_add_with_hint(__addr, __value, __memory_order, \ + __hint) \ + __builtin_aarch64_atomic_hints_fetch ((__addr), (__value), \ + (__memory_order), (__hint), \ + (FETCH_ADD)) + +#define __arm_atomic_fetch_sub_with_hint(__addr, __value, __memory_order, \ + __hint) \ + __builtin_aarch64_atomic_hints_fetch ((__addr), (__value), \ + (__memory_order), (__hint), \ + (FETCH_SUB)) + +#define __arm_atomic_fetch_and_with_hint(__addr, __value, __memory_order, \ + __hint) \ + __builtin_aarch64_atomic_hints_fetch ((__addr), (__value), \ + (__memory_order), (__hint), \ + (FETCH_AND)) + +#define __arm_atomic_fetch_xor_with_hint(__addr, __value, __memory_order, \ + __hint) \ + __builtin_aarch64_atomic_hints_fetch ((__addr), (__value), \ + (__memory_order), (__hint), \ + (FETCH_XOR)) + +#define __arm_atomic_fetch_or_with_hint(__addr, __value, __memory_order, \ + __hint) \ + __builtin_aarch64_atomic_hints_fetch ((__addr), (__value), \ + (__memory_order), (__hint), \ + (FETCH_OR)) + #pragma GCC push_options #pragma GCC target ("+nothing+jscvt") __extension__ extern __inline int32_t diff --git a/gcc/config/aarch64/atomics.md b/gcc/config/aarch64/atomics.md index dca36242cb01..940aa15ac718 100644 --- a/gcc/config/aarch64/atomics.md +++ b/gcc/config/aarch64/atomics.md @@ -791,6 +791,83 @@ [(set_attr "arch" "*,rcpc8_4")] ) +(define_insn "aarch64_atomic_fetch__atomic_hint" + [(set (match_operand:ALLI 0 "register_operand" "=r") + (match_operand:ALLI 1 "aarch64_sync_memory_operand" "+Q")) + (set (match_dup 1) + (unspec_volatile:ALLI + [(match_dup 1) + (match_operand:ALLI 2 "register_operand" "r") + (match_operand:SI 3 "const_int_operand") + (match_operand:SI 4 "const_int_operand")] + ATOMIC_LDOP))] + "TARGET_LSE" + { + switch (INTVAL (operands[4])) + { + case 0: + output_asm_insn ("shuh", operands); + break; + case 1: + output_asm_insn ("shuh\tph", operands); + break; + default: + gcc_unreachable (); + } + enum memmodel model = memmodel_from_int (INTVAL (operands[3])); + if (is_mm_relaxed (model)) + return "ld\t%2, %0, %1"; + else if (is_mm_acquire (model) || is_mm_consume (model)) + return "lda\t%2, %0, %1"; + else if (is_mm_release (model)) + return "ldl\t%2, %0, %1"; + else + return "ldal\t%2, %0, %1"; + } +) + +(define_expand "@aarch64_atomic_hints_fetch" +[(set (match_operand:ALLI 0 "register_operand") + (unspec_volatile:ALLI + [(match_operand:ALLI 1 "aarch64_sync_memory_operand") + (match_operand:ALLI 2 "aarch64_reg_or_zero") + (match_operand:SI 3 "const_int_operand") ;; model + (match_operand:SI 4 "const_int_operand") ;; hint + (match_operand:SI 5 "const_int_operand")] ;; fetch_type + UNSPECV_ATOMIC_HINTS_FETCH))] + "TARGET_LSE" + { + rtx (*gen) (rtx, rtx, rtx, rtx, rtx); + switch (INTVAL (operands[5])) + { + case 1: + operands[2] = expand_simple_unop (mode, NEG, operands[2], + NULL, 1); + /* fallthrough. */ + case 0: + gen = gen_aarch64_atomic_fetch_add_atomic_hint; + break; + case 2: + operands[2] = expand_simple_unop (mode, NOT, operands[2], + NULL, 1); + gen = gen_aarch64_atomic_fetch_bic_atomic_hint; + break; + case 3: + gen = gen_aarch64_atomic_fetch_xor_atomic_hint; + break; + case 4: + gen = gen_aarch64_atomic_fetch_ior_atomic_hint; + break; + default: + gcc_unreachable (); + } + operands[2] = force_reg (mode, operands[2]); + emit_insn (gen (operands[0], operands[1], operands[2], operands[3], + operands[4])); + DONE; + } +) + (define_insn "@aarch64_load_exclusive" [(set (match_operand:SI 0 "register_operand" "=r") (zero_extend:SI diff --git a/gcc/config/aarch64/iterators.md b/gcc/config/aarch64/iterators.md index eea783ffc081..d41c8921d162 100644 --- a/gcc/config/aarch64/iterators.md +++ b/gcc/config/aarch64/iterators.md @@ -1479,6 +1479,8 @@ UNSPECV_LDAP ; Represent an atomic acquire load with RCpc semantics. UNSPECV_STL ; Represent an atomic store or store-release. UNSPECV_ATOMIC_HINTS_STORE ; Represent an atomic store with a hint. + UNSPECV_ATOMIC_HINTS_FETCH ; Represent an atomic fetch with a hint. + UNSPECV_HINTS_FETCH ; Likewise. UNSPECV_ATOMIC_CMPSW ; Represent an atomic compare swap. UNSPECV_ATOMIC_EXCHG ; Represent an atomic exchange. UNSPECV_ATOMIC_CAS ; Represent an atomic CAS. diff --git a/gcc/testsuite/gcc.target/aarch64/atomic_fetch_add_with_shuh.c b/gcc/testsuite/gcc.target/aarch64/atomic_fetch_add_with_shuh.c new file mode 100644 index 000000000000..9844979848c6 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/atomic_fetch_add_with_shuh.c @@ -0,0 +1,151 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=armv8.1-a -save-temps" } */ +/* { dg-final { check-function-bodies "**" "" } } */ + +#include + +/* +** testFun1: +** ... +** shuh +** ldaddb (w[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +char +testFun1 () +{ + char item1 = 0; + char* ptr1 = &item1; + char test1 = 1; + + return __arm_atomic_fetch_add_with_hint (ptr1, test1, __ATOMIC_RELAXED, 0); +} + +/* +** testFun2: +** ... +** shuh +** ldaddlh (w[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +short +testFun2 () +{ + short item2 = 10; + short* ptr2 = &item2; + short test2 = 11; + return __arm_atomic_fetch_add_with_hint (ptr2, test2, __ATOMIC_RELEASE, 0); +} + +/* +** testFun3: +** ... +** shuh ph +** ldaddal (w[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +int +testFun3 () +{ + unsigned int item3 = 10; + unsigned int* ptr3 = &item3; + unsigned int test3 = 11; + return __arm_atomic_fetch_add_with_hint (ptr3, test3, __ATOMIC_SEQ_CST, 1); +} + +/* +** testFun4: +** ... +** shuh ph +** ldadd (x[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +void +testFun4 () +{ + long item4 = 10; + long* ptr4 = &item4; + long test4 = 11; + __arm_atomic_fetch_add_with_hint (ptr4, test4, __ATOMIC_RELAXED, 1); +} + +/* +** testFun5: +** ... +** shuh +** ldaddal (x[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +void +testFun5 () +{ + long item5 = 10; + long *ptritem = &item5; + long **ptr5 = &ptritem; + long test5item = 11; + long *test5 = &test5item; + __arm_atomic_fetch_add_with_hint (ptr5, test5, __ATOMIC_SEQ_CST, 0); +} + +/* +** testFun6: +** ... +** shuh +** ldaddb (w[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +void +testFun6 () +{ + char item8 = 0; + char* ptr8 = &item8; + long test8 = 1; + + __arm_atomic_fetch_add_with_hint (ptr8, test8, __ATOMIC_RELAXED, 0); +} + +/* +** testFun7: +** ... +** add (x[0-9]+), \1, 1 +** mov (w[0-9]+), 7 +** shuh ph +** ldaddb \2, \2, \[x[0-9]+\] +** ... +*/ +static char buf[8]; +void +testFun7 (void) +{ + __arm_atomic_fetch_add_with_hint((buf + 1), (char)7, __ATOMIC_RELAXED, 1); +} + + +/* +** signed_fetch_add_hint: +** ... +** shuh ph +** ldadd (w[0-9]+), \1, \[x[0-9]+\] +** sxtw x[0-9]+, \1 +** ... +*/ +long +signed_fetch_add_hint (int x, int *p) +{ + return __arm_atomic_fetch_add_with_hint (p, x, __ATOMIC_RELAXED, 1); +} + + +/* +** unsigned_fetch_add_hint: +** ... +** shuh ph +** ldadd (w[0-9]+), \1, \[x[0-9]+\] +** uxtw x[0-9]+, \1 +** ... +*/ +long +unsigned_fetch_add_hint (unsigned int x, unsigned int *p) +{ + return __arm_atomic_fetch_add_with_hint (p, x, __ATOMIC_RELAXED, 1); +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.target/aarch64/atomic_fetch_and_with_shuh.c b/gcc/testsuite/gcc.target/aarch64/atomic_fetch_and_with_shuh.c new file mode 100644 index 000000000000..35c919ca7698 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/atomic_fetch_and_with_shuh.c @@ -0,0 +1,150 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=armv8.1-a -save-temps" } */ +/* { dg-final { check-function-bodies "**" "" } } */ + +#include + +/* +** testFun1: +** ... +** shuh +** ldclrb (w[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +char +testFun1 () +{ + char item1 = 0; + char* ptr1 = &item1; + char test1 = 1; + + return __arm_atomic_fetch_and_with_hint (ptr1, test1, __ATOMIC_RELAXED, 0); +} + +/* +** testFun2: +** ... +** shuh +** ldclrlh (w[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +short +testFun2 () +{ + short item2 = 10; + short* ptr2 = &item2; + short test2 = 11; + return __arm_atomic_fetch_and_with_hint (ptr2, test2, __ATOMIC_RELEASE, 0); +} + +/* +** testFun3: +** ... +** shuh ph +** ldclral (w[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +int +testFun3 () +{ + unsigned int item3 = 10; + unsigned int* ptr3 = &item3; + unsigned int test3 = 11; + return __arm_atomic_fetch_and_with_hint (ptr3, test3, __ATOMIC_SEQ_CST, 1); +} + +/* +** testFun4: +** ... +** shuh ph +** ldclr (x[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +void +testFun4 () +{ + long item4 = 10; + long* ptr4 = &item4; + long test4 = 11; + __arm_atomic_fetch_and_with_hint (ptr4, test4, __ATOMIC_RELAXED, 1); +} + +/* +** testFun5: +** ... +** shuh +** ldclral (x[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +void +testFun5 () +{ + long item5 = 10; + long *ptritem = &item5; + long **ptr5 = &ptritem; + long test5item = 11; + long *test5 = &test5item; + __arm_atomic_fetch_and_with_hint (ptr5, test5, __ATOMIC_SEQ_CST, 0); +} + +/* +** testFun6: +** ... +** shuh +** ldclrb (w[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +void +testFun6 () +{ + char item8 = 0; + char* ptr8 = &item8; + long test8 = 1; + + __arm_atomic_fetch_and_with_hint (ptr8, test8, __ATOMIC_RELAXED, 0); +} + +/* +** testFun7: +** ... +** add (x[0-9]+), \1, 1 +** mov (w[0-9]+), -8 +** shuh ph +** ldclrb \2, \2, \[x[0-9]+\] +** ... +*/ +static char buf[8]; +void +testFun7 (void) +{ + __arm_atomic_fetch_and_with_hint((buf + 1), (char)7, __ATOMIC_RELAXED, 1); +} + +/* +** signed_fetch_and_hint: +** ... +** shuh ph +** ldclr (w[0-9]+), \1, \[x[0-9]+\] +** sxtw x[0-9]+, \1 +** ... +*/ +long +signed_fetch_and_hint (int x, int *p) +{ + return __arm_atomic_fetch_and_with_hint (p, x, __ATOMIC_RELAXED, 1); +} + + +/* +** unsigned_fetch_and_hint: +** ... +** shuh ph +** ldclr (w[0-9]+), \1, \[x[0-9]+\] +** uxtw x[0-9]+, \1 +** ... +*/ +long +unsigned_fetch_and_hint (unsigned int x, unsigned int *p) +{ + return __arm_atomic_fetch_and_with_hint (p, x, __ATOMIC_RELAXED, 1); +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.target/aarch64/atomic_fetch_or_with_shuh.c b/gcc/testsuite/gcc.target/aarch64/atomic_fetch_or_with_shuh.c new file mode 100644 index 000000000000..02661254ad0f --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/atomic_fetch_or_with_shuh.c @@ -0,0 +1,150 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=armv8.1-a -save-temps" } */ +/* { dg-final { check-function-bodies "**" "" } } */ + +#include + +/* +** testFun1: +** ... +** shuh +** ldsetb (w[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +char +testFun1 () +{ + char item1 = 0; + char* ptr1 = &item1; + char test1 = 1; + + return __arm_atomic_fetch_or_with_hint (ptr1, test1, __ATOMIC_RELAXED, 0); +} + +/* +** testFun2: +** ... +** shuh +** ldsetlh (w[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +short +testFun2 () +{ + short item2 = 10; + short* ptr2 = &item2; + short test2 = 11; + return __arm_atomic_fetch_or_with_hint (ptr2, test2, __ATOMIC_RELEASE, 0); +} + +/* +** testFun3: +** ... +** shuh ph +** ldsetal (w[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +int +testFun3 () +{ + unsigned int item3 = 10; + unsigned int* ptr3 = &item3; + unsigned int test3 = 11; + return __arm_atomic_fetch_or_with_hint (ptr3, test3, __ATOMIC_SEQ_CST, 1); +} + +/* +** testFun4: +** ... +** shuh ph +** ldset (x[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +void +testFun4 () +{ + long item4 = 10; + long* ptr4 = &item4; + long test4 = 11; + __arm_atomic_fetch_or_with_hint (ptr4, test4, __ATOMIC_RELAXED, 1); +} + +/* +** testFun5: +** ... +** shuh +** ldsetal (x[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +void +testFun5 () +{ + long item5 = 10; + long *ptritem = &item5; + long **ptr5 = &ptritem; + long test5item = 11; + long *test5 = &test5item; + __arm_atomic_fetch_or_with_hint (ptr5, test5, __ATOMIC_SEQ_CST, 0); +} + +/* +** testFun6: +** ... +** shuh +** ldsetb (w[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +void +testFun6 () +{ + char item8 = 0; + char* ptr8 = &item8; + long test8 = 1; + + __arm_atomic_fetch_or_with_hint (ptr8, test8, __ATOMIC_RELAXED, 0); +} + +/* +** testFun7: +** ... +** add (x[0-9]+), \1, 1 +** mov (w[0-9]+), 7 +** shuh ph +** ldsetb \2, \2, \[x[0-9]+\] +** ... +*/ +static char buf[8]; +void +testFun7 (void) +{ + __arm_atomic_fetch_or_with_hint((buf + 1), (char)7, __ATOMIC_RELAXED, 1); +} + +/* +** signed_fetch_or_hint: +** ... +** shuh ph +** ldset (w[0-9]+), \1, \[x[0-9]+\] +** sxtw x[0-9]+, \1 +** ... +*/ +long +signed_fetch_or_hint (int x, int *p) +{ + return __arm_atomic_fetch_or_with_hint (p, x, __ATOMIC_RELAXED, 1); +} + + +/* +** unsigned_fetch_or_hint: +** ... +** shuh ph +** ldset (w[0-9]+), \1, \[x[0-9]+\] +** uxtw x[0-9]+, \1 +** ... +*/ +long +unsigned_fetch_or_hint (unsigned int x, unsigned int *p) +{ + return __arm_atomic_fetch_or_with_hint (p, x, __ATOMIC_RELAXED, 1); +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.target/aarch64/atomic_fetch_sub_with_shuh.c b/gcc/testsuite/gcc.target/aarch64/atomic_fetch_sub_with_shuh.c new file mode 100644 index 000000000000..04b400fe7b36 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/atomic_fetch_sub_with_shuh.c @@ -0,0 +1,162 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=armv8.1-a -save-temps" } */ +/* { dg-final { check-function-bodies "**" "" } } */ + +#include + +/* +** testFun1: +** ... +** mov (w[0-9]+), -1 +** add (x[0-9]+), sp, 15 +** strb wzr, \[sp, 15\] +** shuh +** ldaddb \1, \1, \[\2\] +** ... +*/ +char +testFun1 () +{ + char item1 = 0; + char* ptr1 = &item1; + char test1 = 1; + + return __arm_atomic_fetch_sub_with_hint (ptr1, test1, __ATOMIC_RELAXED, 0); +} + +/* +** testFun2: +** ... +** mov (w[0-9]+), -11 +** shuh +** ldaddlh (w[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +short +testFun2 () +{ + short item2 = 10; + short* ptr2 = &item2; + short test2 = 11; + return __arm_atomic_fetch_sub_with_hint (ptr2, test2, __ATOMIC_RELEASE, 0); +} + +/* +** testFun3: +** ... +** mov (w[0-9]+), -11 +** shuh ph +** ldaddal (w[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +int +testFun3 () +{ + unsigned int item3 = 10; + unsigned int* ptr3 = &item3; + unsigned int test3 = 11; + return __arm_atomic_fetch_sub_with_hint (ptr3, test3, __ATOMIC_SEQ_CST, 1); +} + +/* +** testFun4: +** ... +** mov (x[0-9]+), -11 +** str (x[0-9]+), \[sp, 8\] +** add \2, sp, 8 +** shuh ph +** ldadd \1, \1, \[\2\] +** ... +*/ +void +testFun4 () +{ + long item4 = 10; + long* ptr4 = &item4; + long test4 = 11; + __arm_atomic_fetch_sub_with_hint (ptr4, test4, __ATOMIC_RELAXED, 1); +} + +/* +** testFun5: +** ... +** neg (x[0-9]+), \1 +** shuh +** ldaddal \1, \1, \[x[0-9]+\] +** ... +*/ +void +testFun5 () +{ + long item5 = 10; + long *ptritem = &item5; + long **ptr5 = &ptritem; + long test5item = 11; + long *test5 = &test5item; + __arm_atomic_fetch_sub_with_hint (ptr5, test5, __ATOMIC_SEQ_CST, 0); +} + +/* +** testFun6: +** ... +** mov (w[0-9]+), -1 +** add (x[0-9]+), sp, 15 +** strb wzr, \[sp, 15\] +** shuh +** ldaddb (w[0-9]+), \1, \[\2\] +** ... +*/ +void +testFun6 () +{ + char item8 = 0; + char* ptr8 = &item8; + long test8 = 1; + + __arm_atomic_fetch_sub_with_hint (ptr8, test8, __ATOMIC_RELAXED, 0); +} + +/* +** testFun7: +** ... +** add (x[0-9]+), \1, 1 +** mov (w[0-9]+), -7 +** shuh ph +** ldaddb \2, \2, \[\1\] +** ... +*/ +static char buf[8]; +void +testFun7 (void) +{ + __arm_atomic_fetch_sub_with_hint((buf + 1), (char)7, __ATOMIC_RELAXED, 1); +} + +/* +** signed_fetch_sub_hint: +** ... +** shuh ph +** ldadd (w[0-9]+), \1, \[x[0-9]+\] +** sxtw x[0-9]+, \1 +** ... +*/ +long +signed_fetch_sub_hint (int x, int *p) +{ + return __arm_atomic_fetch_sub_with_hint (p, x, __ATOMIC_RELAXED, 1); +} + + +/* +** unsigned_fetch_sub_hint: +** ... +** shuh ph +** ldadd (w[0-9]+), \1, \[x[0-9]+\] +** uxtw x[0-9]+, \1 +** ... +*/ +long +unsigned_fetch_sub_hint (unsigned int x, unsigned int *p) +{ + return __arm_atomic_fetch_sub_with_hint (p, x, __ATOMIC_RELAXED, 1); +} \ No newline at end of file diff --git a/gcc/testsuite/gcc.target/aarch64/atomic_fetch_xor_with_shuh.c b/gcc/testsuite/gcc.target/aarch64/atomic_fetch_xor_with_shuh.c new file mode 100644 index 000000000000..2aa4f8daee25 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/atomic_fetch_xor_with_shuh.c @@ -0,0 +1,150 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=armv8.1-a -save-temps" } */ +/* { dg-final { check-function-bodies "**" "" } } */ + +#include + +/* +** testFun1: +** ... +** shuh +** ldeorb (w[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +char +testFun1 () +{ + char item1 = 0; + char* ptr1 = &item1; + char test1 = 1; + + return __arm_atomic_fetch_xor_with_hint (ptr1, test1, __ATOMIC_RELAXED, 0); +} + +/* +** testFun2: +** ... +** shuh +** ldeorlh (w[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +short +testFun2 () +{ + short item2 = 10; + short* ptr2 = &item2; + short test2 = 11; + return __arm_atomic_fetch_xor_with_hint (ptr2, test2, __ATOMIC_RELEASE, 0); +} + +/* +** testFun3: +** ... +** shuh ph +** ldeoral (w[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +int +testFun3 () +{ + unsigned int item3 = 10; + unsigned int* ptr3 = &item3; + unsigned int test3 = 11; + return __arm_atomic_fetch_xor_with_hint (ptr3, test3, __ATOMIC_SEQ_CST, 1); +} + +/* +** testFun4: +** ... +** shuh ph +** ldeor (x[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +void +testFun4 () +{ + long item4 = 10; + long* ptr4 = &item4; + long test4 = 11; + __arm_atomic_fetch_xor_with_hint (ptr4, test4, __ATOMIC_RELAXED, 1); +} + +/* +** testFun5: +** ... +** shuh +** ldeoral (x[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +void +testFun5 () +{ + long item5 = 10; + long *ptritem = &item5; + long **ptr5 = &ptritem; + long test5item = 11; + long *test5 = &test5item; + __arm_atomic_fetch_xor_with_hint (ptr5, test5, __ATOMIC_SEQ_CST, 0); +} + +/* +** testFun6: +** ... +** shuh +** ldeorb (w[0-9]+), \1, \[x[0-9]+\] +** ... +*/ +void +testFun6 () +{ + char item8 = 0; + char* ptr8 = &item8; + long test8 = 1; + + __arm_atomic_fetch_xor_with_hint (ptr8, test8, __ATOMIC_RELAXED, 0); +} + +/* +** testFun7: +** ... +** add (x[0-9]+), \1, 1 +** mov (w[0-9]+), 7 +** shuh ph +** ldeorb \2, \2, \[x[0-9]+\] +** ... +*/ +static char buf[8]; +void +testFun7 (void) +{ + __arm_atomic_fetch_xor_with_hint((buf + 1), (char)7, __ATOMIC_RELAXED, 1); +} + +/* +** signed_fetch_xor_hint: +** ... +** shuh ph +** ldeor (w[0-9]+), \1, \[x[0-9]+\] +** sxtw x[0-9]+, \1 +** ... +*/ +long +signed_fetch_xor_hint (int x, int *p) +{ + return __arm_atomic_fetch_xor_with_hint (p, x, __ATOMIC_RELAXED, 1); +} + + +/* +** unsigned_fetch_xor_hint: +** ... +** shuh ph +** ldeor (w[0-9]+), \1, \[x[0-9]+\] +** uxtw x[0-9]+, \1 +** ... +*/ +long +unsigned_fetch_xor_hint (unsigned int x, unsigned int *p) +{ + return __arm_atomic_fetch_xor_with_hint (p, x, __ATOMIC_RELAXED, 1); +} \ No newline at end of file From db54bfba3a0afb93257b9e30ff7fa70207367045 Mon Sep 17 00:00:00 2001 From: Robert Dubner Date: Fri, 18 Sep 2026 16:36:02 -0400 Subject: [PATCH 217/584] cobol: Change policy for finding .so files. [PR127412] This patch partially addresses PR127412 by changing "cp1140" to "ibm1140" in the DejaGNU tests. "ibm1140", unlike "cp1140", is recognized not just on glibc systems, but FreeBSD and NetBSD systems as well. Some necessary changes to charmaps.cc have not yet been made. The main purpose of this patch is to modify the policy used to search for shared-object .so files that contain a desired symbol. gcc/cobol/ChangeLog: * gcobol.1: Documentation for the .so search. * move.cc: Fix typo. * parse.y: Data capacity test. * symbols.cc (expand_picture): Fix off-by-one error; handle corner case where 'B' is the final character of a numeric-edited PICTURE string. * symbols.h: Remove unnecessary test. libgcobol/ChangeLog: * libgcobol.cc (do_the_dl_thing): New .so policy. (find_in_dirs): Likewise. (__gg__function_handle_from_cobpath): Likewise. gcc/testsuite/ChangeLog: PR cobol/127412 * cobol.dg/group2/CBL_DELETE_FILE.cob: Minor logic change. * cobol.dg/group2/CBL_DELETE_FILE.out: Likewise. * cobol.dg/group2/CBL_OPEN_FILE___CBL_CLOSE_FILE.cob: Likewise. * cobol.dg/group2/CBL_OPEN_FILE___CBL_CLOSE_FILE.out: Likewise. * cobol.dg/group2/CBL_READ_FILE__check_file_size_with_flags___128.cob: Likewise. * cobol.dg/group2/CDF_Feature_.cob: Switch to "ibm1140". * cobol.dg/group2/CHAR_and_ORD_with_COLLATING_sequence_-_EBCDIC.cob: Likewise. * cobol.dg/group2/FIND-STRING__forward_.cob: Likewise. * cobol.dg/group2/FIND-STRING__reverse_.cob: Likewise. * cobol.dg/group2/FUNCTION_CONVERT.cob: Likewise. * cobol.dg/group2/CBL_CHECK_FILE_EXIST__known_timestamp_.cob: New test. * cobol.dg/group2/MF__identifier_as_PIC_X_ANY_LENGTH.cob: New test. --- gcc/cobol/gcobol.1 | 31 ++--- gcc/cobol/move.cc | 2 +- gcc/cobol/parse.y | 29 +++-- gcc/cobol/symbols.cc | 25 ++-- gcc/cobol/symbols.h | 6 - ...CBL_CHECK_FILE_EXIST__known_timestamp_.cob | 45 +++++++ .../cobol.dg/group2/CBL_DELETE_FILE.cob | 8 +- .../cobol.dg/group2/CBL_DELETE_FILE.out | 2 +- .../group2/CBL_OPEN_FILE___CBL_CLOSE_FILE.cob | 8 +- .../group2/CBL_OPEN_FILE___CBL_CLOSE_FILE.out | 4 +- ...FILE__check_file_size_with_flags___128.cob | 2 +- .../cobol.dg/group2/CDF_Feature_.cob | 2 +- ...d_ORD_with_COLLATING_sequence_-_EBCDIC.cob | 2 +- .../cobol.dg/group2/FIND-STRING__forward_.cob | 2 +- .../cobol.dg/group2/FIND-STRING__reverse_.cob | 2 +- .../cobol.dg/group2/FUNCTION_CONVERT.cob | 2 +- .../MF__identifier_as_PIC_X_ANY_LENGTH.cob | 30 +++++ libgcobol/libgcobol.cc | 118 +++++++++++------- 18 files changed, 216 insertions(+), 104 deletions(-) create mode 100644 gcc/testsuite/cobol.dg/group2/CBL_CHECK_FILE_EXIST__known_timestamp_.cob create mode 100644 gcc/testsuite/cobol.dg/group2/MF__identifier_as_PIC_X_ANY_LENGTH.cob diff --git a/gcc/cobol/gcobol.1 b/gcc/cobol/gcobol.1 index 21438c0568b0..cdcb71468109 100644 --- a/gcc/cobol/gcobol.1 +++ b/gcc/cobol/gcobol.1 @@ -1954,22 +1954,22 @@ precisely match the behavior of other \*[lang] compilers. You have been warned. . .Sh ENVIRONMENT -.Bl -tag -width COBPATH -.It Ev COBPATH +.Bl -tag -width GCOBOL_LIBRARY_PATH +.It Ev GCOBOL_LIBRARY_PATH If defined, specifies the directory paths to be used by the .Nm runtime library, .Pa libgcobol.so , -to locate shared objects. +to locate entry points in shared objects. Like .Ev LD_LIBRARY_PATH , it may contain several directory names separated by a colon .Pq Ql \&: . -.Ev COBPATH +.Ev GCOBOL_LIBRARY_PATH is searched first, followed by .Ev LD_LIBRARY_PATH . Note that -.Ev COBPATH does not change where the runtime linker looks for +.Ev GCOBOL_LIBRARY_PATH does not change where the runtime linker looks for .Pa libgcobol.so itself. How the runtime linker searches for @@ -1978,16 +1978,19 @@ when the executable loads is controlled by .Xr ld.so 8 , not libgcobol. .Pp -Each directory is searched for files whose name ends in -.Ql ".so" . -For each such file, +Each directory is searched for a file whose name is based on the desired +symbol. The literal name, with +.Ql ".so" +appended, is tried first. For each such file, .Xr dlopen 3 -is attempted, and, if successful -.Xr dlsym 3 . -No relationship is defined between the symbol's name and the filename. -.Pp -Without -.Ev COBPATH , +is attempted, and if successful, +.Xr dlsym 3 is used to search for the +symbol. If either fails, a second attempt is made after converting +the desired symbol to lowercase. +.Pp +When +.Ev GCOBOL_LIBRARY_PATH and +.Ev LD_LIBRARY_PATH are not explicitly used, binaries produced by .Nm behave as one might expect of any program compiled with gcc. Any diff --git a/gcc/cobol/move.cc b/gcc/cobol/move.cc index 44df3e4f2405..685fee287056 100644 --- a/gcc/cobol/move.cc +++ b/gcc/cobol/move.cc @@ -15,7 +15,7 @@ * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORSdf + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT diff --git a/gcc/cobol/parse.y b/gcc/cobol/parse.y index 9b07e9c46c8e..3bbf60e17e75 100644 --- a/gcc/cobol/parse.y +++ b/gcc/cobol/parse.y @@ -12986,7 +12986,7 @@ cbl_ffi_arg_t::matches( const cbl_ffi_arg_t& that ) const { case by_reference_e: if( crv == by_reference_e ) { if( (formal->attr & mask) == (actual->attr & mask) ) { - if( capacity_ok(formal, actual) ) { + if( formal->data.capacity() == actual->data.capacity() ) { if( formal->type == actual->type ) { // captures USAGE except COMP-X return true; } @@ -12995,17 +12995,13 @@ cbl_ffi_arg_t::matches( const cbl_ffi_arg_t& that ) const { return true; } } - // If actual is by reference, so must the formal be. - dbgmsg("%s:%d: failed, reference feature mismatch", __func__, __LINE__); + // If actual is by reference, so must the formal be. return false; break; case by_content_e: break; case by_value_e: - if( crv != by_value_e ) { - dbgmsg("%s:%d: failed, actual %s not by value", __func__, __LINE__, actual->name); - return false; - } + if( crv != by_value_e ) return false; if( formal->type == FldPointer && that.refer.is_pointer() ) return true; break; } @@ -13022,7 +13018,6 @@ cbl_ffi_arg_t::matches( const cbl_ffi_arg_t& that ) const { return actual->data.capacity() == formal->data.capacity() && actual->codeset.encoding == formal->codeset.encoding; } - dbgmsg("%s:%d: failed, for some reason", __func__, __LINE__); return false; } @@ -13071,6 +13066,24 @@ bad_arg( const char name[], return ok; } +static const char * +passby_str(int mask) +{ + switch( mask ) { + case by_default_e: + case by_reference_e: + return "BY REFERENCE"; + case by_content_e: + return "BY CONTENT"; + case by_value_e: + return "BY VALUE"; + default: + break; + } + + return "UNKNOWN PASSING METHOD"; +} + // Verify provided actual parameters against formals. static void verify_args( const YYLTYPE& loc, diff --git a/gcc/cobol/symbols.cc b/gcc/cobol/symbols.cc index 5f6752ef7461..6d96ba311b6a 100644 --- a/gcc/cobol/symbols.cc +++ b/gcc/cobol/symbols.cc @@ -4807,7 +4807,7 @@ expand_picture(const char *picture) long repeat; int currency_symbol = NULLCH; - while( (ch = (*p++ & 0xFF) ) ) + while( (ch = ((*p++) & 0xFF) ) ) { if( ch == ascii_oparen ) { @@ -4863,7 +4863,7 @@ expand_picture(const char *picture) dest_length += sign_length; } } - retval[dest_length++] = NULLCH; + retval[dest_length] = NULLCH; // To ease the workload on interpreting the PICTURE string at run time, we // are going to convert everything we can to upper case. We also convert @@ -4875,11 +4875,9 @@ expand_picture(const char *picture) switch(retval[i]) { case ascii_a: - case ascii_c: case ascii_e: case ascii_n: case ascii_p: - case ascii_r: case ascii_s: case ascii_x: case ascii_z: @@ -4897,13 +4895,18 @@ expand_picture(const char *picture) case ascii_B: case ascii_b: - if( i < dest_length-1 ) - { - retval[i] = TOUPPER(retval[i]); - } - - - + if( i < dest_length-1 ) + { + retval[i] = ascii_B; + } + else + { + if( i>=1 && retval[i-1] != ascii_D && retval[i-1] != ascii_d ) + { + retval[i] = ascii_B; + } + } + break; } } return retval; diff --git a/gcc/cobol/symbols.h b/gcc/cobol/symbols.h index 6c6142ed1a93..3887b275b7b0 100644 --- a/gcc/cobol/symbols.h +++ b/gcc/cobol/symbols.h @@ -1444,12 +1444,6 @@ struct cbl_ffi_arg_t { if( crv == by_reference_e ) return false; return refer.field != NULL; } - static bool capacity_ok( const cbl_field_t *formal, const cbl_field_t *actual ) { - if( formal->data.capacity() == actual->data.capacity() ) return true; - if( formal->data.capacity() == 1 && formal->has_attr(any_length_e) ) return true; - if( actual->data.capacity() == 1 && actual->has_attr(any_length_e) ) return true; - return false; - } }; // In support of serial/linear search: diff --git a/gcc/testsuite/cobol.dg/group2/CBL_CHECK_FILE_EXIST__known_timestamp_.cob b/gcc/testsuite/cobol.dg/group2/CBL_CHECK_FILE_EXIST__known_timestamp_.cob new file mode 100644 index 000000000000..849c3e4f7d23 --- /dev/null +++ b/gcc/testsuite/cobol.dg/group2/CBL_CHECK_FILE_EXIST__known_timestamp_.cob @@ -0,0 +1,45 @@ + *> Do not edit this generated file. See README.txt + *> { dg-do run } + *> { dg-options "-dialect mf" } + + copy "cblproto.cpy". + identification division. + program-id. prog. + data division. + working-storage section. + copy "cbltypes.cpy". + 77 filename pic x(5) value "file". + 01 buf type cblt-fileexist-buf. + 01 year constant 2026. + 01 month constant 9. + 01 cday constant 16. + 01 hours constant 15. + 01 minutes constant 18. + 01 seconds constant 0. + 01 status-code pic x(2) comp-5. + 01 status-bits redefines status-code. + 03 msb pic x. + 03 lsb pic x comp-x. + procedure division. + call "CBL_CHECK_FILE_EXIST" using filename buf + returning status-code. + if status-code <> 0 + display "CBL_CHECK_FILE_EXIST failed with " + "[" msb ", " lsb "]" + else if cblte-fe-year <> year + display "expected year " year ", got " cblte-fe-year + else if cblte-fe-month <> month + display "expected month " month ", got " cblte-fe-month + else if cblte-fe-day <> cday + display "expected day " cday ", got " cblte-fe-day + else if cblte-fe-hours <> hours + display "expected hours " hours ", got " cblte-fe-hours + else if cblte-fe-minutes <> minutes + display "expected minutes " minutes + ", got " cblte-fe-minutes + else if cblte-fe-seconds <> seconds + display "expected seconds " seconds + ", got " cblte-fe-seconds + end-if. + end program prog. + diff --git a/gcc/testsuite/cobol.dg/group2/CBL_DELETE_FILE.cob b/gcc/testsuite/cobol.dg/group2/CBL_DELETE_FILE.cob index d924a4c90303..499d9d836faa 100644 --- a/gcc/testsuite/cobol.dg/group2/CBL_DELETE_FILE.cob +++ b/gcc/testsuite/cobol.dg/group2/CBL_DELETE_FILE.cob @@ -6,8 +6,8 @@ identification division. program-id. test_delete_file. data division. - >>define filename as "/tmp/test_delete_file.cbl.txt" - >>define invalid-path as "/tmp/thisfileshouldnotexist.txt" + >>define filename as "test_delete_file.cbl.txt" + >>define invalid-path as "thisfileshouldnotexist.txt" working-storage section. 01 file-status pic x(2) comp-5. 01 fs redefines file-status. @@ -47,10 +47,10 @@ exit paragraph. delete-file section. - call "CBL_DELETE_FILE" using filename. + call "CBL_DELETE_FILE" using filename returning file-status. if file-status <> 0 - display "CBL_DELETE_FILE failed with " return-code + display "CBL_DELETE_FILE failed with " file-status end-if. exit paragraph. diff --git a/gcc/testsuite/cobol.dg/group2/CBL_DELETE_FILE.out b/gcc/testsuite/cobol.dg/group2/CBL_DELETE_FILE.out index 55a5fe10c98a..314d1d184eaf 100644 --- a/gcc/testsuite/cobol.dg/group2/CBL_DELETE_FILE.out +++ b/gcc/testsuite/cobol.dg/group2/CBL_DELETE_FILE.out @@ -1,4 +1,4 @@ -Expected failure when deleting /tmp/thisfileshouldnotexist.txt +Expected failure when deleting thisfileshouldnotexist.txt File status MSB: 9 File status LSB: 013 diff --git a/gcc/testsuite/cobol.dg/group2/CBL_OPEN_FILE___CBL_CLOSE_FILE.cob b/gcc/testsuite/cobol.dg/group2/CBL_OPEN_FILE___CBL_CLOSE_FILE.cob index 0c0a43cb0510..0f7ec298389a 100644 --- a/gcc/testsuite/cobol.dg/group2/CBL_OPEN_FILE___CBL_CLOSE_FILE.cob +++ b/gcc/testsuite/cobol.dg/group2/CBL_OPEN_FILE___CBL_CLOSE_FILE.cob @@ -15,7 +15,7 @@ . object-computer. Posix. - >>define FILE_NAME as "/tmp/thisfileshouldneverexist.txt" + >>define FILE_NAME as "thisfileshouldneverexist.txt" data division. working-storage section. @@ -65,9 +65,9 @@ access-mode deny-mode device - file-handle - returning file-status. - if file-status <> 0 + file-handle. + if return-code <> 0 + move return-code to file-status display "Expected failure when opening " FILE_NAME display "File status MSB: " msb display "File status LSB: " lsb diff --git a/gcc/testsuite/cobol.dg/group2/CBL_OPEN_FILE___CBL_CLOSE_FILE.out b/gcc/testsuite/cobol.dg/group2/CBL_OPEN_FILE___CBL_CLOSE_FILE.out index 67a56adcfa57..bec7477035e4 100644 --- a/gcc/testsuite/cobol.dg/group2/CBL_OPEN_FILE___CBL_CLOSE_FILE.out +++ b/gcc/testsuite/cobol.dg/group2/CBL_OPEN_FILE___CBL_CLOSE_FILE.out @@ -1,6 +1,6 @@ Opening /dev/null as read-only -Opening /tmp/thisfileshouldneverexist.txt as read-only -Expected failure when opening /tmp/thisfileshouldneverexist.txt +Opening thisfileshouldneverexist.txt as read-only +Expected failure when opening thisfileshouldneverexist.txt File status MSB: 9 File status LSB: 013 diff --git a/gcc/testsuite/cobol.dg/group2/CBL_READ_FILE__check_file_size_with_flags___128.cob b/gcc/testsuite/cobol.dg/group2/CBL_READ_FILE__check_file_size_with_flags___128.cob index 68e863f65cbc..aac046ccde13 100644 --- a/gcc/testsuite/cobol.dg/group2/CBL_READ_FILE__check_file_size_with_flags___128.cob +++ b/gcc/testsuite/cobol.dg/group2/CBL_READ_FILE__check_file_size_with_flags___128.cob @@ -15,7 +15,7 @@ object-computer. Posix. data division. - >>define filename as "/tmp/test_file_size.cbl.txt" + >>define filename as "test_file_size.cbl.txt" >>define buffer as "hi, this text is exactly 38 bytes long" working-storage section. 01 file-handle pic x(4) comp-5. diff --git a/gcc/testsuite/cobol.dg/group2/CDF_Feature_.cob b/gcc/testsuite/cobol.dg/group2/CDF_Feature_.cob index 9150dd5d7210..fa701da6c522 100644 --- a/gcc/testsuite/cobol.dg/group2/CDF_Feature_.cob +++ b/gcc/testsuite/cobol.dg/group2/CDF_Feature_.cob @@ -1,6 +1,6 @@ *> Do not edit this generated file. See README.txt *> { dg-do run } - *> { dg-options "-fexec-charset=cp1140 -dialect ibm" } + *> { dg-options "-fexec-charset=ibm1140 -dialect ibm" } *> { dg-output-file "group2/CDF_Feature_.out" } id division. diff --git a/gcc/testsuite/cobol.dg/group2/CHAR_and_ORD_with_COLLATING_sequence_-_EBCDIC.cob b/gcc/testsuite/cobol.dg/group2/CHAR_and_ORD_with_COLLATING_sequence_-_EBCDIC.cob index 346f393777c2..0cde1ff859ac 100644 --- a/gcc/testsuite/cobol.dg/group2/CHAR_and_ORD_with_COLLATING_sequence_-_EBCDIC.cob +++ b/gcc/testsuite/cobol.dg/group2/CHAR_and_ORD_with_COLLATING_sequence_-_EBCDIC.cob @@ -1,6 +1,6 @@ *> Do not edit this generated file. See README.txt *> { dg-do run } - *> { dg-options "-fexec-charset=cp1140" } + *> { dg-options "-fexec-charset=ibm1140" } *> { dg-output-file "group2/CHAR_and_ORD_with_COLLATING_sequence_-_EBCDIC.out" } IDENTIFICATION DIVISION. PROGRAM-ID. prog. diff --git a/gcc/testsuite/cobol.dg/group2/FIND-STRING__forward_.cob b/gcc/testsuite/cobol.dg/group2/FIND-STRING__forward_.cob index 1cc5ae599420..f007d7093443 100644 --- a/gcc/testsuite/cobol.dg/group2/FIND-STRING__forward_.cob +++ b/gcc/testsuite/cobol.dg/group2/FIND-STRING__forward_.cob @@ -1,6 +1,6 @@ *> Do not edit this generated file. See README.txt *> { dg-do run } - *> { dg-options "-fexec-charset=cp1140" } + *> { dg-options "-fexec-charset=ibm1140" } *> { dg-output-file "group2/FIND-STRING__forward_.out" } IDENTIFICATION DIVISION. PROGRAM-ID. prog. diff --git a/gcc/testsuite/cobol.dg/group2/FIND-STRING__reverse_.cob b/gcc/testsuite/cobol.dg/group2/FIND-STRING__reverse_.cob index 831822cd1d2f..e30011e2800a 100644 --- a/gcc/testsuite/cobol.dg/group2/FIND-STRING__reverse_.cob +++ b/gcc/testsuite/cobol.dg/group2/FIND-STRING__reverse_.cob @@ -1,6 +1,6 @@ *> Do not edit this generated file. See README.txt *> { dg-do run } - *> { dg-options "-fexec-charset=cp1140" } + *> { dg-options "-fexec-charset=ibm1140" } *> { dg-output-file "group2/FIND-STRING__reverse_.out" } IDENTIFICATION DIVISION. PROGRAM-ID. prog. diff --git a/gcc/testsuite/cobol.dg/group2/FUNCTION_CONVERT.cob b/gcc/testsuite/cobol.dg/group2/FUNCTION_CONVERT.cob index 48c4c0bfd9b1..7bad2fdaed56 100644 --- a/gcc/testsuite/cobol.dg/group2/FUNCTION_CONVERT.cob +++ b/gcc/testsuite/cobol.dg/group2/FUNCTION_CONVERT.cob @@ -7,7 +7,7 @@ configuration section. special-names. locale sbc is "cp1252" - locale ebcd is "cp1140". + locale ebcd is "ibm1140". object-computer. gnu-linux classification diff --git a/gcc/testsuite/cobol.dg/group2/MF__identifier_as_PIC_X_ANY_LENGTH.cob b/gcc/testsuite/cobol.dg/group2/MF__identifier_as_PIC_X_ANY_LENGTH.cob new file mode 100644 index 000000000000..e5ca6e66c55a --- /dev/null +++ b/gcc/testsuite/cobol.dg/group2/MF__identifier_as_PIC_X_ANY_LENGTH.cob @@ -0,0 +1,30 @@ + *> Do not edit this generated file. See README.txt + *> { dg-do run } + *> { dg-options "-dialect mf" } +[ + identification division. + program-id. foo prototype. + data division. + linkage section. + 01 buf pic x any length. + procedure division using buf. + end program foo. + + identification division. + program-id. prog. + data division. + working-storage section. + 77 buf pic x(64) value "hello". + procedure division. + call "foo" using buf. + end program prog. + + identification division. + program-id. foo. + data division. + linkage section. + 01 buf pic x any length. + procedure division using buf. + display "buf is " buf. + end program foo. +] diff --git a/libgcobol/libgcobol.cc b/libgcobol/libgcobol.cc index fdc80fd95beb..f436e822889d 100644 --- a/libgcobol/libgcobol.cc +++ b/libgcobol/libgcobol.cc @@ -10901,12 +10901,60 @@ __gg__set_program_list( int program_id, } static std::unordered_map already_found; +static void * +do_the_dl_thing(const char *directory, + const char *unmangled_name, + const char *mangled_name) + { + // Using the GnuCOBOL convention, this code looks first for a file + // named unmangled_name.so. It checks for a function unmangled_name + // in that file. When not found, it checks for mangled_name. + void *retval = NULL; + void *handle; + std::string file; + if( directory ) + { + file = directory; + file += '/'; + } + file += unmangled_name; + file += ".so"; + handle = dlopen(file.c_str(), RTLD_LAZY|RTLD_NODELETE ); + if( handle ) + { + retval = dlsym(handle, unmangled_name); + if( retval ) + { + already_found[unmangled_name] = retval; + } + } + if( !retval ) + { + file.clear(); + if( directory ) + { + file = directory; + file += '/'; + } + file += mangled_name; + file += ".so"; + handle = dlopen(file.c_str(), RTLD_LAZY|RTLD_NODELETE ); + if( handle ) + { + retval = dlsym(handle, mangled_name); + if( retval ) + { + already_found[mangled_name] = retval; + } + } + } + return retval; + } static void * find_in_dirs(const char *dirs, char *unmangled_name, char *mangled_name) { - std::unordered_map::const_iterator it = already_found.find(unmangled_name); @@ -10923,65 +10971,36 @@ find_in_dirs(const char *dirs, char *unmangled_name, char *mangled_name) void *retval = NULL; if( dirs ) { - char directory[1024]; - char file[1024]; + std::string directory; const char *p = dirs; while( !retval && *p ) { - size_t index = 0; - while( index < sizeof(directory)-1 && *p && *p != ':' ) + directory.clear(); + while( *p && *p != ':' ) { - directory[index++] = *p++; + directory += *p++; } - directory[index++] = '\0'; if( *p == ':' ) { p += 1; } // directory is the next one for us to check: - DIR *dir = opendir(directory); + DIR *dir = opendir(directory.c_str()); if( dir ) { - while( !retval ) - { - const dirent *entry = readdir(dir); - if( !entry ) - { - break; - } - size_t len = strlen(entry->d_name); - if( len > 3 - && entry->d_name[len-3] == '.' - && entry->d_name[len-2] == 's' - && entry->d_name[len-1] == 'o' - ) - { - strcpy(file, directory); - strcat(file, "/"); - strcat(file, entry->d_name); - void *handle = dlopen(file, RTLD_LAZY|RTLD_NODELETE ); - if( handle ) - { - retval = dlsym(handle, unmangled_name); - if( retval ) - { - already_found[unmangled_name] = retval; - break; - } - retval = dlsym(handle, mangled_name); - if( retval ) - { - already_found[mangled_name] = retval; - break; - } - dlclose(handle); - } - } - } + retval = do_the_dl_thing(directory.c_str(), + unmangled_name, + mangled_name); closedir(dir); } } } + else + { + retval = do_the_dl_thing(nullptr, + unmangled_name, + mangled_name); + } return retval; } @@ -10993,7 +11012,8 @@ __gg__function_handle_from_cobpath( char *unmangled_name, char *mangled_name) // We search for a function. We check first for the unmangled name, and then // the mangled name. We do this first for the executable, then for .so - // files in COBPATH, and then for files in LD_LIBRARY_PATH + // files in GCOBOL_LIBRARY_PATH, and then we allow dlopen to use its default + // behavior. static void *handle_executable = NULL; if( !handle_executable ) @@ -11012,8 +11032,12 @@ __gg__function_handle_from_cobpath( char *unmangled_name, char *mangled_name) } if( !retval ) { - const char *LD_LIBRARY_PATH = getenv("LD_LIBRARY_PATH"); - retval = find_in_dirs(LD_LIBRARY_PATH, unmangled_name, mangled_name); + const char *COBPATH = getenv("LD_LIBRARY_PATH"); + retval = find_in_dirs(COBPATH, unmangled_name, mangled_name); + } + if( !retval ) + { + retval = find_in_dirs(nullptr, unmangled_name, mangled_name); } return retval; From bed30881182b1497c5d8468441a3ea6e1f80d0f6 Mon Sep 17 00:00:00 2001 From: Michiel Derhaeg Date: Fri, 18 Sep 2026 15:40:39 -0600 Subject: [PATCH 218/584] [PATCH] testsuite: Fix gcc.dg/tree-ssa/predcom-10.c test From: Michiel Derhaeg Embedded platforms don't always initialize `argc` to be 1 Verified the test still reproduces the issue when the fix for PR127405 is reverted. gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/predcom-10.c: Pass in expected value explicitly instead of deriving it from argc. Signed-off-by: Michiel Derhaeg --- gcc/testsuite/gcc.dg/tree-ssa/predcom-10.c | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/gcc/testsuite/gcc.dg/tree-ssa/predcom-10.c b/gcc/testsuite/gcc.dg/tree-ssa/predcom-10.c index b6d87a62c34f..b9bd1cca3922 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/predcom-10.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/predcom-10.c @@ -20,12 +20,9 @@ test (unsigned long n, int *a, int *b) a[i + 2] = b[i + 2] - a[i + 3] - a[i + 5] + (int) (i + 2); } -int -main (int argc, char **argv) +int __attribute__ ((noipa)) +check (unsigned long n) { - /* N is 6, but not known to the compiler. */ - unsigned long n = argc + 5; - for (int i = 0; i < 12; i++) { a[i] = 0; @@ -40,3 +37,9 @@ main (int argc, char **argv) return 0; } + +int +main () +{ + return check (6); +} From f0551dea5fba27ba06c6900391eccf0d0a5661ba Mon Sep 17 00:00:00 2001 From: Bohan Lei Date: Fri, 18 Sep 2026 15:45:29 -0600 Subject: [PATCH 219/584] [PATCH v2 1/2] RISC-V: Compare costs under -mrvv-max-lmul=dynamic Compared to v1, the patch now removes the early VLS rejection completely, and considers scenarios where `this` has spills while `other` does not, which can happen when VLS is legal for unknown-iters loops. It is also different from the early implementation in that we now don't trigger the early return when both main loops have spills. It has caused several vect dump expectation changes in some testcases, but the final assembly for them remains identical. --- When the iteration count is unknown, actually compare the costs of different VLA modes instead of blindly choosing the bigger LMUL as long as there's no unexpected spill. This can prevent some cases when -mrvv-max-lmul=dynamic emits worse code than -mrvv-max-lmul=m8, and consistent with the current implementation of check_vectorise_memory_operation in riscv-string.cc, which chooses the smallest possible LMUL, instead of m8 for all cases. This patch used to be a part of the m1-dynamic patch I proposed earlier, but as this can be justified independently, I split this out. As I changed the `else if` branch to an independent if-clause, it can now affect both dynamic and conv-dynamic. I am not quite sure but I guess avoiding a VLS loop for unknown niter cases would be reasonable as well for conv-dynamic when neither is preferred by the conv-dynamic heuristics. When running the regression tests, I found several testcases, including vec_sat_u_sub_zip.c, contain multiline DejaGnu directives that are not supported by the DejaGnu framework. I plan to fix them in a separate testsuite-only patch. gcc/ChangeLog: * config/riscv/riscv-vector-costs.cc (costs::better_main_loop_than_p): Compare VLA costs under -mrvv-max-lmul=dynamic. gcc/testsuite/ChangeLog: * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul-mixed-1.c: Update expectation. * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-1.c: Ditto. * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-2.c: Ditto. * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-3.c: Ditto. * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-4.c: Ditto. * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-5.c: Ditto. * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-6.c: Ditto. * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-7.c: Ditto. * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-1.c: Ditto. * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-3.c: Ditto. * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-4.c: Ditto. * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-5.c: Ditto. * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-6.c: Ditto. * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-6.c: Ditto. * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-12.c: Ditto. * gcc.dg/vect/costmodel/riscv/rvv/pr111848.c: Ditto. * gcc.target/riscv/rvv/autovec/partial/slp-16.c: Ditto. * gcc.target/riscv/rvv/autovec/sat/vec_sat_u_sub_zip.c: Ditto. --- gcc/config/riscv/riscv-vector-costs.cc | 21 ++----------------- .../riscv/rvv/dynamic-lmul-mixed-1.c | 2 +- .../costmodel/riscv/rvv/dynamic-lmul1-1.c | 2 +- .../costmodel/riscv/rvv/dynamic-lmul1-2.c | 2 +- .../costmodel/riscv/rvv/dynamic-lmul1-3.c | 2 +- .../costmodel/riscv/rvv/dynamic-lmul1-4.c | 2 +- .../costmodel/riscv/rvv/dynamic-lmul1-5.c | 2 +- .../costmodel/riscv/rvv/dynamic-lmul1-6.c | 2 +- .../costmodel/riscv/rvv/dynamic-lmul1-7.c | 2 +- .../costmodel/riscv/rvv/dynamic-lmul2-1.c | 2 +- .../costmodel/riscv/rvv/dynamic-lmul2-3.c | 2 +- .../costmodel/riscv/rvv/dynamic-lmul2-4.c | 2 +- .../costmodel/riscv/rvv/dynamic-lmul2-5.c | 2 +- .../costmodel/riscv/rvv/dynamic-lmul2-6.c | 2 +- .../costmodel/riscv/rvv/dynamic-lmul4-6.c | 4 ++-- .../costmodel/riscv/rvv/dynamic-lmul8-12.c | 4 ++-- .../vect/costmodel/riscv/rvv/pr111848.c | 2 +- .../riscv/rvv/autovec/partial/slp-16.c | 4 ++-- .../riscv/rvv/autovec/sat/vec_sat_u_sub_zip.c | 2 +- 19 files changed, 23 insertions(+), 40 deletions(-) diff --git a/gcc/config/riscv/riscv-vector-costs.cc b/gcc/config/riscv/riscv-vector-costs.cc index 8e5e55dde8a5..02c2039afd0c 100644 --- a/gcc/config/riscv/riscv-vector-costs.cc +++ b/gcc/config/riscv/riscv-vector-costs.cc @@ -1239,13 +1239,13 @@ costs::better_main_loop_than_p (const vector_costs *uncast_other) const } else if (rvv_max_lmul == RVV_DYNAMIC) { - if (other->m_has_unexpected_spills_p) + if (this->m_has_unexpected_spills_p != other->m_has_unexpected_spills_p) { if (dump_enabled_p ()) dump_printf_loc (MSG_NOTE, vect_location, "Preferring smaller LMUL loop because" " it has unexpected spills\n"); - return true; + return !this->m_has_unexpected_spills_p; } else if (riscv_vla_mode_p (other_loop_vinfo->vector_mode)) { @@ -1261,25 +1261,8 @@ costs::better_main_loop_than_p (const vector_costs *uncast_other) const return false; } } - else - { - if (dump_enabled_p ()) - dump_printf_loc (MSG_NOTE, vect_location, - "Keep current LMUL loop because" - " it is unknown NITERS\n"); - return false; - } } } - /* If NITERS is unknown, we should not use VLS modes to vectorize - the loop since we don't support partial vectors for VLS modes, - that is, we will have full vectors (VLSmodes) on loop body - and partial vectors (VLAmodes) on loop epilogue which is very - inefficient. Instead, we should apply partial vectors (VLAmodes) - on loop body without an epilogue on unknown NITERS loop. */ - else if (!LOOP_VINFO_NITERS_KNOWN_P (this_loop_vinfo) - && m_cost_type == VLS_VECTOR_COST) - return false; /* Fall back to generic costing if either iteration count is unknown. For known iteration counts, include loop overhead when comparing different diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul-mixed-1.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul-mixed-1.c index 8d0002805db7..47ca3074b409 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul-mixed-1.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul-mixed-1.c @@ -44,4 +44,4 @@ foo (int32_t *__restrict a, int32_t *__restrict b, int32_t *__restrict c, /* { dg-final { scan-assembler {e32,m2} } } */ /* { dg-final { scan-assembler {e32,m8} } } */ /* { dg-final { scan-assembler-not {csrr} } } */ -/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 2 "vect" } } */ +/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-1.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-1.c index d5fd0f2e3206..b40b467651a2 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-1.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-1.c @@ -85,7 +85,7 @@ foo (int32_t *__restrict a, int32_t *__restrict b, int32_t *__restrict c, /* { dg-final { scan-assembler {e32,m1} } } */ /* { dg-final { scan-assembler-not {csrr} } } */ -/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 3 "vect" } } */ +/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 8" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 4" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 2" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-2.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-2.c index a0e61303e80f..e1fb4b385a75 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-2.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-2.c @@ -57,7 +57,7 @@ foo (int32_t *__restrict a, int32_t *__restrict b, int32_t *__restrict c, /* FIXME: Choosing LMUL = 1 is not the optimal since it can be LMUL = 2 if we apply instruction scheduler. */ /* { dg-final { scan-assembler {e32,m1} } } */ /* { dg-final { scan-assembler-not {csrr} } } */ -/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 3 "vect" } } */ +/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 8" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 4" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 2" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-3.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-3.c index 2111c0bbc9a2..08f202f8602e 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-3.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-3.c @@ -85,7 +85,7 @@ foo (int8_t *__restrict a, int8_t *__restrict b, int8_t *__restrict c, /* { dg-final { scan-assembler {e8,m1} } } */ /* { dg-final { scan-assembler-not {csrr} } } */ -/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 3 "vect" } } */ +/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 8" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 4" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 2" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-4.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-4.c index c47a4c4ceb17..d6c8faaf8f78 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-4.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-4.c @@ -115,7 +115,7 @@ foo (int32_t *__restrict a, int32_t *__restrict b, int32_t *__restrict c, /* { dg-final { scan-assembler {e32,m1} } } */ /* { dg-final { scan-assembler-not {csrr} } } */ -/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 3 "vect" } } */ +/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 8" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 4" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 2" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-5.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-5.c index e4b74f037e3b..d006918c4104 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-5.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-5.c @@ -143,7 +143,7 @@ foo (int32_t *__restrict a, int32_t *__restrict b, int32_t *__restrict c, /* { dg-final { scan-assembler {e32,m1} } } */ /* { dg-final { scan-assembler-not {csrr} } } */ -/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 3 "vect" } } */ +/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 8" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 4" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 2" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-6.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-6.c index 73d16dab7324..f8b0283252f2 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-6.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-6.c @@ -144,7 +144,7 @@ foo (int8_t *__restrict a, int8_t *__restrict b, int8_t *__restrict c, /* { dg-final { scan-assembler {e8,m1} } } */ /* { dg-final { scan-assembler-not {csrr} } } */ -/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 3 "vect" } } */ +/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 8" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 4" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 2" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-7.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-7.c index b76bb4b06b4b..a1f9ad0fa71e 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-7.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-7.c @@ -42,7 +42,7 @@ foo (int32_t *__restrict a, int32_t *__restrict b, int32_t *__restrict c, /* { dg-final { scan-assembler {e32,m1} } } */ /* { dg-final { scan-assembler-not {csrr} { xfail "*-*-*" } } } */ -/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 3 "vect" } } */ +/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 8" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 4" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 2" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-1.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-1.c index 6637f3c3e3f4..9eac4cc92219 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-1.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-1.c @@ -45,7 +45,7 @@ foo (int32_t *__restrict a, int32_t *__restrict b, int32_t *__restrict c, /* { dg-final { scan-assembler {e32,m2} } } */ /* { dg-final { scan-assembler-not {csrr} } } */ -/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 2 "vect" } } */ +/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 8" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 4" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 2" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-3.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-3.c index 6637f3c3e3f4..9eac4cc92219 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-3.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-3.c @@ -45,7 +45,7 @@ foo (int32_t *__restrict a, int32_t *__restrict b, int32_t *__restrict c, /* { dg-final { scan-assembler {e32,m2} } } */ /* { dg-final { scan-assembler-not {csrr} } } */ -/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 2 "vect" } } */ +/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 8" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 4" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 2" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-4.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-4.c index a8e603f90f36..49cbbdb2420a 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-4.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-4.c @@ -43,7 +43,7 @@ foo (int32_t *__restrict a, int32_t *__restrict b, int32_t *__restrict c, /* { dg-final { scan-assembler {e32,m2} } } */ /* { dg-final { scan-assembler-not {csrr} } } */ -/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 2 "vect" } } */ +/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 8" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 4" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 2" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-5.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-5.c index dcb20a302c83..75d3ecddc598 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-5.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-5.c @@ -46,7 +46,7 @@ foo (int32_t *__restrict a, int32_t *__restrict b, int32_t *__restrict c, /* { dg-final { scan-assembler {e32,m2} } } */ /* { dg-final { scan-assembler {e8,m8} } } */ /* { dg-final { scan-assembler-not {csrr} } } */ -/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 2 "vect" } } */ +/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 8" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 4" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 2" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-6.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-6.c index f5d1a02736a7..5bcffff7524e 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-6.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-6.c @@ -48,4 +48,4 @@ foo (int32_t *__restrict a, int32_t *__restrict b, int32_t *__restrict c, /* { dg-final { scan-assembler {e32,m2} } } */ /* { dg-final { scan-assembler {e8,m8} } } */ /* { dg-final { scan-assembler-not {csrr} } } */ -/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 2 "vect" } } */ +/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-6.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-6.c index 365fdf2a7498..ba2eacaccd27 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-6.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-6.c @@ -20,8 +20,8 @@ foo (uint8_t *restrict a, uint8_t *restrict b, int n) } } -/* { dg-final { scan-assembler {e8,m4} } } */ -/* { dg-final { scan-assembler-times {csrr} 1 } } */ +/* { dg-final { scan-assembler {e8,m1} } } */ +/* { dg-final { scan-assembler-times {csrr} 0 } } */ /* Since we don't support VLA SLP for LMUL = 8, dynamic LMUL cost model start from LMUL = 4. */ /* { dg-final { scan-tree-dump-not "Preferring smaller LMUL loop because it has unexpected spills" "vect" } } */ /* { dg-final { scan-tree-dump-not "Maximum lmul = 8" "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-12.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-12.c index c55546394deb..0f75505f1de6 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-12.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-12.c @@ -17,8 +17,8 @@ foo (int *restrict a, int *restrict b, int n) } } -/* { dg-final { scan-assembler {e32,m8} } } */ -/* { dg-final { scan-assembler-times {csrr} 1 } } */ +/* { dg-final { scan-assembler {e32,m1} } } */ +/* { dg-final { scan-assembler-times {csrr} 0 } } */ /* { dg-final { scan-tree-dump-not "Preferring smaller LMUL loop because it has unexpected spills" "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 4" 1 "vect" { xfail *-*-* } } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 2" 1 "vect" { xfail *-*-* } } } */ diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/pr111848.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/pr111848.c index 339c80f8805a..2801ef499256 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/pr111848.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/pr111848.c @@ -28,7 +28,7 @@ f3 (uint8_t *restrict a, uint8_t *restrict b, } } -/* { dg-final { scan-assembler {e8,m4} } } */ +/* { dg-final { scan-assembler {e8,m1} } } */ /* { dg-final { scan-assembler-not {jr} } } */ /* { dg-final { scan-assembler-times {ret} 1 } } */ /* { dg-final { scan-tree-dump-not "Preferring smaller LMUL loop because it has unexpected spills" "vect" } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/partial/slp-16.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/partial/slp-16.c index b31453852b23..bf1bed97551c 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/autovec/partial/slp-16.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/partial/slp-16.c @@ -20,6 +20,6 @@ f (uint8_t *restrict a, uint8_t *restrict b, int n) } /* FIXME: Since we don't have VECT cost model yet, LOAD_LANES/STORE_LANES are chosen instead of SLP. */ -/* { dg-final { scan-tree-dump-times "\.VEC_PERM" 1 "optimized" { xfail { any-opts "-mrvv-max-lmul=m1" "-mrvv-max-lmul=m2" "-mrvv-max-lmul=m4" "-mrvv-max-lmul=m8" } } } } */ -/* { dg-final { scan-assembler {\tvid\.v} { xfail { any-opts "-mrvv-max-lmul=m1" "-mrvv-max-lmul=m2" "-mrvv-max-lmul=m4" "-mrvv-max-lmul=m8" } } } } */ +/* { dg-final { scan-tree-dump-times "\.VEC_PERM" 1 "optimized" { xfail *-*-* } } } */ +/* { dg-final { scan-assembler {\tvid\.v} { xfail *-*-* } } } */ /* { dg-final { scan-assembler-not {\tvmul} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/sat/vec_sat_u_sub_zip.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/sat/vec_sat_u_sub_zip.c index 5988df689d01..2a632838d30e 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/autovec/sat/vec_sat_u_sub_zip.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/sat/vec_sat_u_sub_zip.c @@ -17,4 +17,4 @@ DEF_VEC_SAT_U_SUB_ZIP_WRAP(uint16_t, uint32_t) /* { dg-final { scan-assembler-times {vssubu\.vv} 1 { target { any-ops "-mrvv-vector-bits=zvl" } } } } */ -/* { dg-final { scan-assembler-times {vnclipu\.wi} 2 } } */ +/* { dg-final { scan-assembler {vnclipu\.wi} } } */ From a87de1ad7ab071584907f123ffd7940b3f74f17c Mon Sep 17 00:00:00 2001 From: Zhongyao Chen Date: Fri, 18 Sep 2026 15:57:01 -0600 Subject: [PATCH 220/584] [PATCH] ext-dce: Mark all spanned hard registers live for multi-reg references [PR127367] In pr127367, ext-dce sees multi-reg hard regs like (reg:TI a0) in call fusage on riscv64. It fails to record a1 in livenow, so the preceding extensions are wrongly eliminated. This patch uses an iteration over all spanned hard registers (via end_hard_regno) to mark their chunks live for HARD_REGISTER_P. PR rtl-optimization/127367 gcc/ChangeLog: * ext-dce.cc: Include regs.h. (ext_dce_process_uses): Handle multi-register hard regs. gcc/testsuite/ChangeLog: * gcc.dg/torture/pr127367.c: New test. Signed-off-by: Zhongyao Chen --- gcc/ext-dce.cc | 12 +++++++++++- gcc/testsuite/gcc.dg/torture/pr127367.c | 26 +++++++++++++++++++++++++ 2 files changed, 37 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.dg/torture/pr127367.c diff --git a/gcc/ext-dce.cc b/gcc/ext-dce.cc index 02e7348bf156..1a3e624e7653 100644 --- a/gcc/ext-dce.cc +++ b/gcc/ext-dce.cc @@ -37,6 +37,7 @@ along with GCC; see the file COPYING3. If not see #include "dbgcnt.h" #include "diagnostic-core.h" #include "target.h" +#include "regs.h" /* These should probably move into a C++ class. */ static vec livein; @@ -1426,7 +1427,16 @@ ext_dce_process_uses (rtx_insn *insn, rtx obj, /* If we have a register reference that is not otherwise handled, just assume all the chunks are live. */ else if (REG_P (x)) - bitmap_set_range (livenow, REGNO (x) * 4, group_limit (x)); + { + if (HARD_REGISTER_P (x)) + { + unsigned int end = end_hard_regno (GET_MODE (x), REGNO (x)); + for (unsigned int r = REGNO (x); r < end; r++) + bitmap_set_range (livenow, r * 4, 4); + } + else + bitmap_set_range (livenow, REGNO (x) * 4, group_limit (x)); + } } } diff --git a/gcc/testsuite/gcc.dg/torture/pr127367.c b/gcc/testsuite/gcc.dg/torture/pr127367.c new file mode 100644 index 000000000000..ed87f45e6f85 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr127367.c @@ -0,0 +1,26 @@ +/* PR rtl-optimization/127367 */ +/* { dg-do run { target bitint } } */ + +#if __BITINT_MAXWIDTH__ >= 96 +_BitInt(5) g; +_BitInt(65) prod; + +__attribute__((noipa)) void +foo (void) +{ + _BitInt(6) t = ~g; + _BitInt(96) m = t % (unsigned _BitInt(96))362; + _BitInt(5) r = __builtin_mul_overflow(t, m, &prod) ?: prod; + if ((long long)m != 297 || (int)r != -9 || (long long)prod != -297) + __builtin_abort (); +} +#endif + +int +main (void) +{ +#if __BITINT_MAXWIDTH__ >= 96 + foo (); +#endif + return 0; +} From 4a2a0a4360fa37a30b8c00a29095ad9fdb63c2f3 Mon Sep 17 00:00:00 2001 From: Michiel Derhaeg Date: Fri, 18 Sep 2026 17:15:50 -0600 Subject: [PATCH 221/584] [PATCH] RISC-V: Avoid emitting shNadd with a virtual register base From: Loeka Rogge A shNadd whose base is a virtual register prevents the frame offset from being folded in later, leaving a long sequence behind. gcc.target/riscv/zba-shNadd-11.c, compiled with -march=rv64i_zba -mabi=lp64 -O2, produced: li a5,514 sh3add t0,a5,sp li a0,-513 sh3add a0,a0,t0 and now produces: addi a0,sp,8 Regtested on rv32gc and rv64gc. gcc/ChangeLog: * config/riscv/riscv.cc (synthesize_add): Do not form shNadd when the base register is a virtual register. gcc/testsuite/ChangeLog: * gcc.target/riscv/zba-shNadd-11.c: New test. Signed-off-by: Michiel Derhaeg Signed-off-by: Loeka Rogge --- gcc/config/riscv/riscv.cc | 6 ++++- .../gcc.target/riscv/zba-shNadd-11.c | 22 +++++++++++++++++++ 2 files changed, 27 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.target/riscv/zba-shNadd-11.c diff --git a/gcc/config/riscv/riscv.cc b/gcc/config/riscv/riscv.cc index 49e7476b8322..f20f2a6bd3e1 100644 --- a/gcc/config/riscv/riscv.cc +++ b/gcc/config/riscv/riscv.cc @@ -16635,9 +16635,13 @@ synthesize_add (rtx operands[3]) } /* If we can shift the constant by 1, 2, or 3 bit positions - and the result is a cheaper constant, then do so. */ + and the result is a cheaper constant, then do so. + Virtual registers are later eliminated to FP/SP + a constant. + Putting them inside a shNadd prevents that folding. */ ival = INTVAL (operands[2]); if (TARGET_ZBA + && !(REG_P (operands[1]) + && VIRTUAL_REGISTER_P (operands[1])) && (((ival % 2) == 0 && budget1 > riscv_integer_cost (ival >> 1, true)) || ((ival % 4) == 0 && budget1 diff --git a/gcc/testsuite/gcc.target/riscv/zba-shNadd-11.c b/gcc/testsuite/gcc.target/riscv/zba-shNadd-11.c new file mode 100644 index 000000000000..1e920ef685b2 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/zba-shNadd-11.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv32i_zba -mabi=ilp32 -O2" { target rv32 } } */ +/* { dg-options "-march=rv64i_zba -mabi=lp64 -O2" { target rv64 } } */ +/* { dg-skip-if "" { *-*-* } { "-flto" } } */ +/* { dg-final { check-function-bodies "**" "" } } */ + +void bar (void *); + +/* +** foo: +** ... +** addi a0,sp,8 +** call bar +** ... +*/ + +void +foo () +{ + char baz[4104]; + bar (baz); +} From 3e9f78adbf13e146ec2194eece60f5d09457a99c Mon Sep 17 00:00:00 2001 From: "Jose E. Marchesi" Date: Thu, 17 Sep 2026 13:22:07 +0200 Subject: [PATCH 222/584] a68: introduce parser pass for static properties This commit introduces a new pass for the Algol 68 parser, that computes a set of static properties of certain source constructs, namely the ones yielding values. The resulting static properties are then to be used by the lowerer pass in order to avoid unnecessary copies and implement certain other optimizations. At the moment two static properties are implemented: the "origin" and the "access". The first reflects static information about the original value conforming the source construct, as well as keeping track of certain transformations; this makes it possible, for example, to determine whether certain values have been ever dereferenced. The second reflects the access in which the value yielded by the source construct is to be accessed once lowered. Signed-off-by: Jose E. Marchesi gcc/algol68/ChangeLog * a68.h: Add prototypes for a68_sprops, a68_yields_value and a68_is_declaration. * a68-types.h (a68_access): New type. (a68_kindo): Likewise. (ORIGIN_T): Likewise. (ACCESS_T): Likewise. (NODE_T): Add fields origin and access. (TAG_T): Likewise. (ACCESS_NIHIL): Remove. (ACCESS_CONSTANT): Likewise. (ACCESS_DIRIDEN): Likewise. (ACCESS_INDIDEN): Likewise. (ACCESS_DIRWOST): Likewise. (DEFLEX): Likewise. (FLEXO): Likewise. (BNO): Define. (DEFLEX): Likewise. (DIAGO): Likewise. * a68-parser-sprops.cc: New file. * a68-parser-attrs.def: New comment. * a68-parser-bottom-up.cc (reduce_enquiry_clauses): Add a few comments to improve readability. * a68-parser.cc (a68_is_declaration): New function. (a68_yields_value): Likewise. (a68_parser): Run the sprops pass. (a68_new_node): Initialize ORIGIN and ACCESS. (a68_new_tag): Likewise, for tags. * Make-lang.in (ALGOL68_OBJS): Build algol68/a68-parser-sprops.o. * a68-parser-debug.cc (a68_dump_parse_tree_1): Show static properties whenever requested. * a68-low-clauses.cc: Fix grammar for initialiser series and closed clause in comments. * a68-low.cc (a68_low_assignation): Fix comment. --- gcc/algol68/Make-lang.in | 1 + gcc/algol68/a68-low-clauses.cc | 19 +- gcc/algol68/a68-low.cc | 2 +- gcc/algol68/a68-parser-attrs.def | 3 + gcc/algol68/a68-parser-bottom-up.cc | 2 + gcc/algol68/a68-parser-debug.cc | 49 +- gcc/algol68/a68-parser-sprops.cc | 1362 +++++++++++++++++++++++++++ gcc/algol68/a68-parser.cc | 89 ++ gcc/algol68/a68-types.h | 120 +-- gcc/algol68/a68.h | 9 +- 10 files changed, 1582 insertions(+), 74 deletions(-) create mode 100644 gcc/algol68/a68-parser-sprops.cc diff --git a/gcc/algol68/Make-lang.in b/gcc/algol68/Make-lang.in index 5ad6bec3a20d..bf71433911e6 100644 --- a/gcc/algol68/Make-lang.in +++ b/gcc/algol68/Make-lang.in @@ -82,6 +82,7 @@ ALGOL68_OBJS = algol68/a68-lang.o \ algol68/a68-parser-scanner.o \ algol68/a68-parser-scope.o \ algol68/a68-parser-serial-dsa.o \ + algol68/a68-parser-sprops.o \ algol68/a68-parser-taxes.o \ algol68/a68-parser-top-down.o \ algol68/a68-parser-victal.o \ diff --git a/gcc/algol68/a68-low-clauses.cc b/gcc/algol68/a68-low-clauses.cc index e67318100125..683755217d4c 100644 --- a/gcc/algol68/a68-low-clauses.cc +++ b/gcc/algol68/a68-low-clauses.cc @@ -164,10 +164,9 @@ a68_lower_completer (NODE_T *p ATTRIBUTE_UNUSED, LOW_CTX_T ctx ATTRIBUTE_UNUSED) Parse tree: - initialiser series : serial clause, semi symbol, declaration list; - initialiser series, declaration list; - initialiser series, semi symbol, unit; - initialiser series, semi symbol, labeled unit; + initialiser series : declaration list; + serial clause, semi symbol, declaration list; + enquiry clause, semi symbol, declaration list; initialiser series, semi symbol, declaration list. GENERIC: @@ -196,7 +195,6 @@ a68_lower_initialiser_series (NODE_T *p, LOW_CTX_T ctx) unit; serial clause, semi symbol, unit; serial clause, exit symbol, labeled unit; - serial clause, semi_symbol, declaration list; initialiser series, semi symbol, unit; initialiser series, semi symbol, labeled unit. @@ -230,8 +228,7 @@ a68_lower_serial_clause (NODE_T *p, LOW_CTX_T ctx) } else { - /* Append the result of either the unit or the declarations list in - the current statements list. */ + /* Append the result of the unit in the current statements list. */ a68_add_stmt (a68_lower_tree (NEXT (NEXT (SUB (p))), ctx)); } } @@ -240,8 +237,8 @@ a68_lower_serial_clause (NODE_T *p, LOW_CTX_T ctx) /* Traverse down for side-effects. */ (void) a68_lower_tree (SUB (p), ctx); - /* Append the result of either the unit or the declarations list in the - current statements list. */ + /* Append the result of the unit or labeled unit in the current + statements list. */ a68_add_stmt (a68_lower_tree (NEXT (NEXT (SUB (p))), ctx)); } else @@ -1369,9 +1366,7 @@ a68_lower_parallel_clause (NODE_T *p ATTRIBUTE_UNUSED, /* Lower a closed clause. closed clause : open symbol, serial clause, close symbol; - open symbol, initialiser series, close symbol; - begin symbol, serial clause, end symbol; - begin symbol, initialiser series, end symbol; + begin symbol, serial clause, end symbol. This function returns a BIND_EXPR. */ diff --git a/gcc/algol68/a68-low.cc b/gcc/algol68/a68-low.cc index ea69206c5cc1..8fc112cd76f6 100644 --- a/gcc/algol68/a68-low.cc +++ b/gcc/algol68/a68-low.cc @@ -1051,7 +1051,7 @@ a68_low_assignation (NODE_T *p, else { /* The name at the lhs is either a variable or a component ref as - a l-value. It is ok to evaluate it as an r-value as well as + an l-value. It is ok to evaluate it as an r-value as well as doing so introduces no side-effects. */ effective_lhs = lhs; } diff --git a/gcc/algol68/a68-parser-attrs.def b/gcc/algol68/a68-parser-attrs.def index 2d615409da1b..c474a2653dbf 100644 --- a/gcc/algol68/a68-parser-attrs.def +++ b/gcc/algol68/a68-parser-attrs.def @@ -20,6 +20,9 @@ messages and debug dumps. Please make sure to write them in a way you would expect to be used in statements like "[...] near ATT". */ +/* If you add a new entry, please update the a68_is_* classifier functions in + a68-parser.cc. */ + A68_ATTR(A68_PATTERN, "transput pattern") A68_ATTR(ACCESS_CLAUSE, "access clause") A68_ATTR(ACCESS_SYMBOL, "access-symbol") diff --git a/gcc/algol68/a68-parser-bottom-up.cc b/gcc/algol68/a68-parser-bottom-up.cc index ccbcba93211d..c17436536b35 100644 --- a/gcc/algol68/a68-parser-bottom-up.cc +++ b/gcc/algol68/a68-parser-bottom-up.cc @@ -2416,6 +2416,7 @@ reduce_enquiry_clauses (NODE_T *p) ENQUIRY_CLAUSE, ENQUIRY_CLAUSE, SEMI_SYMBOL, UNIT, STOP); reduce (q, NO_NOTE, &siga, INITIALISER_SERIES, ENQUIRY_CLAUSE, SEMI_SYMBOL, DECLARATION_LIST, STOP); + /* Errors */ reduce (q, strange_separator, &siga, ENQUIRY_CLAUSE, ENQUIRY_CLAUSE, COMMA_SYMBOL, UNIT, STOP); reduce (q, strange_separator, &siga, @@ -2435,6 +2436,7 @@ reduce_enquiry_clauses (NODE_T *p) ENQUIRY_CLAUSE, INITIALISER_SERIES, SEMI_SYMBOL, UNIT, STOP); reduce (q, NO_NOTE, &siga, INITIALISER_SERIES, INITIALISER_SERIES, SEMI_SYMBOL, DECLARATION_LIST, STOP); + /* Errors */ reduce (q, strange_separator, &siga, ENQUIRY_CLAUSE, INITIALISER_SERIES, COMMA_SYMBOL, UNIT, STOP); reduce (q, strange_separator, &siga, diff --git a/gcc/algol68/a68-parser-debug.cc b/gcc/algol68/a68-parser-debug.cc index 28646b3f31ad..a44c48f8912f 100644 --- a/gcc/algol68/a68-parser-debug.cc +++ b/gcc/algol68/a68-parser-debug.cc @@ -36,7 +36,8 @@ static void a68_dump_parse_tree_1 (NODE_T *p, const text_art::dump_widget_info &dwi, - text_art::tree_widget &widget, bool tables, bool levels) + text_art::tree_widget &widget, bool tables, bool levels, + bool sprops) { for (; p != NO_NODE; FORWARD (p)) { @@ -63,6 +64,40 @@ a68_dump_parse_tree_1 (NODE_T *p, const text_art::dump_widget_info &dwi, else levelsinfo = xstrdup (""); + char *spropsinfo; + if (sprops && a68_yields_value (p)) + { + const char *kindo, *access; + + switch (KINDO (p)) + { + case KINDO_NIL: kindo = "nil"; break; + case KINDO_CST: kindo = "cst"; break; + case KINDO_IDE: kindo = "ide"; break; + case KINDO_VAR: kindo = "var"; break; + case KINDO_GEN: kindo = "gen"; break; + default: + gcc_unreachable (); + } + + switch (ACCESS (p)) + { + case NO_ACCESS: access = "voided"; break; + case ACCESS_DIR: access = "dir"; break; + case ACCESS_IND: access = "ind"; break; + case ACCESS_VAR: access = "var"; break; + default: + gcc_unreachable (); + } + + spropsinfo = xasprintf ("(%s,%d,%d,%d) %s", + kindo, BNO (p), + DEREFO (p), GENO (p), + access); + } + else + spropsinfo = xstrdup (""); + char mode[BUFFER_SIZE]; mode[0] = '\0'; if (MOID (p) != NO_MOID) @@ -87,7 +122,7 @@ a68_dump_parse_tree_1 (NODE_T *p, const text_art::dump_widget_info &dwi, location_t loc = a68_get_node_location (p); std::unique_ptr cwidget = text_art::tree_widget::from_fmt (dwi, nullptr, - "%s:%d:%d [%d] %s%s%s%s%s", + "%s:%d:%d [%d] %s%s%s%s%s%s", LOCATION_FILE (loc), LOCATION_LINE (loc), LOCATION_COLUMN (loc), @@ -96,18 +131,20 @@ a68_dump_parse_tree_1 (NODE_T *p, const text_art::dump_widget_info &dwi, symbol, mode, tableinfo, - levelsinfo); + levelsinfo, + spropsinfo); free (symbol); free (tableinfo); free (levelsinfo); + free (spropsinfo); - a68_dump_parse_tree_1 (SUB (p), dwi, *cwidget, tables, levels); + a68_dump_parse_tree_1 (SUB (p), dwi, *cwidget, tables, levels, sprops); widget.add_child (std::move (cwidget)); } } void -a68_dump_parse_tree (NODE_T *p, bool tables, bool levels) +a68_dump_parse_tree (NODE_T *p, bool tables, bool levels, bool sprops) { text_art::style_manager sm; text_art::style::id_t default_style_id (sm.get_or_create_id (text_art::style ())); @@ -116,7 +153,7 @@ a68_dump_parse_tree (NODE_T *p, bool tables, bool levels) std::unique_ptr widget = text_art::tree_widget::from_fmt (dwi, nullptr, "Parse Tree"); - a68_dump_parse_tree_1 (p, dwi, *widget, tables, levels); + a68_dump_parse_tree_1 (p, dwi, *widget, tables, levels, sprops); text_art::canvas c (widget->to_canvas (sm)); pretty_printer *const pp = global_dc->get_reference_printer (); diff --git a/gcc/algol68/a68-parser-sprops.cc b/gcc/algol68/a68-parser-sprops.cc new file mode 100644 index 000000000000..dc82ffd53937 --- /dev/null +++ b/gcc/algol68/a68-parser-sprops.cc @@ -0,0 +1,1362 @@ +/* Compute some static properties of values. + Copyright (C) 2026 Jose E. Marchesi. + + Written by Jose E. Marchesi. + + 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 + . */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "options.h" + +#include "a68.h" + +/* This parser pass computes a set of static properties of certain parse tree + nodes and symtab entries representing source constructs. It is somewhat + inspired on the treatment of static properties described in + + An Optimized Translation Process and Its Application to ALGOL 68 + P. Branquart et al. + + However, the compilation system described in Branquart et al translates + constructs to an IR which is considerably lower in abstraction compared to + GENERIC, and therefore our management of static properties is different. + The underlying ideas, however, are very similar. */ + +/* The origin + ────────── + + The "origin" is a static property of source constructs that yield values. + Its purpose is to record the properties of the original value from which the + construct is derived, as well as the transformations the value has been + submitted to before appearing in the construct. This static property is + composed by several fields described below. + + kindo is the "kind of the origin". + ───── + + It keeps track of the fact that a value is issued from + + ╭─────────╮ + │KINDO_IDE│ an identifier in a VAR_DECL, + ╰─────────╯ + ╭─────────╮ + │KINDO_VAR│ a variable in a VAR_DECL, + ╰─────────╯ + ╭─────────╮ + │KINDO_CST│ a constant in a VAR_DECL with TREE_CONSTANT=1, + ╰─────────╯ + ╭─────────╮ + │KINDO_GEN│ a generator i.e. a malloc or alloca, + ╰─────────╯ + ╭─────────╮ + │KINDO_NIL│ or another construct. + ╰─────────╯ + + This property remains invariant through the static elaboration of a number + of actions such as slices, selection and dereferencings. + + bno is the "block number of the origin". + ─── + + Its meaning for a particular construct is to be interpreted along with its + kindo. For KINDO_IDE and KINDO_VAR, bno indicates the depth number of + the block where the identifier or the variable is declared. For + KINDO_GEN, when it corresponds to a local generator, bno indicates the + depth number of the block where the generator appears. For + KINDO_CONSTANT, and for KINDO_GEN when it corresponds to a heap generator, + bno is always zero. + + derefo is the "flag dereferencing of the origin". + ────── + + This flag indicates whether a dereferencing action has taken place + starting from the construct in whcih kindo has been set up. This + information allows, in some cases, to statically detect the absence of + side-effects, and subsequently to avoid some copies of values. + + geno is the "flag local generator of the origin". + ──── + + This flag indicates whether a local generator is involved in the + construction of this value. + + diago contains the "diagnostics of the origin". + ───── + + This property contains location information of the construct originating + the value. It is useful in order to emit good diagnostic messages in + dynamic checks pointing to the source program construct giving rise to the + value involved in the dynamic check. */ + +/* The access + ────────── + + In the "low" pass parse tree nodes denoting units will be lowered to GCC + GENERIC trees. These trees compute the values yielded by the units. For + example, a DENOTATION node for an integral value may be lowered to an + INTEGER_CST tree, a FORMULA node to a PLUS_EXPR tree, an applied IDENTIFIER + to a VAR_DECL, and a DEREFERENCING node to an INDIRECT_REF tree. + + In principle, it would be expected for the resulting trees to directly + compute the value denoted by the parse nodes originating them. However, for + reasons of efficiency, this is not always the case. + + Parse nodes lowering to trees that directly compute the value yielded by the + unit are said to have "direct access". Examples: + + ● Consider a denotation "10". The parser builds a parse node DENOTATION + with the value 10 for it, and the "low" pass lowers that parse node into a + GENERIC tree consisting in a single INTEGER_CST tree node, with value 10. + In this case, the tree indeed computes the value yielded by the DENOTATION + node. + + ● An applied IDENTIFIER "maxint" with mode int that has been declared via an + identity declaration, with some integral value ascribed to it. The "low" + pass lowers it into a VAR_DECL with TREE_TYPE int. Again, this node has + "direct access", because the VAR_DECL in a GENERIC r-value position + computes the value ascribed to the IDENTIFIER. + + Parse nodes denoting units that yield names, lowering to VAR_DECL trees + whose address is the value yielded by the unit are said to have "variable + access". Examples: + + ● Suppose that another applied IDENTIFIER "count" with mode int has been + declared, this time via a variable declaration. The value ascribed to the + identifier is in this case a name with mode "ref int". Such a name would + generally be lowered to a tree of type *int, i.e. the address of the + variable, but in this case the node will be lowered to a VAR_DECL with + type int instead. This is an optimization whose goal is to avoid + unnecessary indirect addressing. The tree represents the name and can be + moved around as-is, but when it comes to access the actual value of the + name, i.e. the address of the integral value referenced by the name, it + becomes necessary to take the address of the VAR_DECL. + + Parse nodes lowering to trees that need to be indirected in order to compute + the value yielded by the unit are said to have "indirect access". Examples: + + ● Consider what happens when a DEREFERENCING node has a coercend with + "variable access" which is of mode "ref int", or alternatively a coercend + with "direct access" also of mode "ref int". In the first case, the + coercend will be lowered to a VAR_DECL with type int, as an optimization. + In the second case, the coercend will be lowered to some tree with type + *int. It would make sense for the DEREFERENCING node to be of "direct + class" and be lowered to an INDIRECT_REF tree taking as argument the + address of the VAR_DECL in the first case, and just the value of the + VAR_DECL in the second case. However, as an optimization, the + dereferencing of nodes with "direct class" or "variable class" doesn't + require any run-time action (other than perhaps checking for nil) and the + DEREFERENCING node is lowered to the coercend tree without any + modification. Only when the dereferenced value is actually used, + indirection will be performed. + + ● The value yielded by the last unit in a serial clause doesn't need to be + copied into the outer range if the yielded value is accessible in that + range. Instead, the unit gets lowered to a tree computing the address of + the value, and is given indirect access. + + The different access classes are summarized below: + + ╭──────────╮ + │ACCESS_IND│ indirect access. + ╰──────────╯ + ╭──────────╮ + │ACCESS_DIR│ direct access. + ╰──────────╯ + ╭──────────╮ + │ACCESS_VAR│ variable access. + ╰──────────╯ + + + IND DIR VAR + ─── ─── ─── + node mode: int int ref int + tree type: *int int int + + + The purpose of this static property is thus to guide the lowering pass, but + there is certain level of circularity, as the calculation of the access is + also influenced by the behavior of the lowering pass. + + It is important to remember that the access static property only makes sense + for constructs that yield values, i.e. units. Nodes that are not units are + annotated with NO_ACCESS, which denotes no access. */ + +/* Handling of choice constructs + ───────────────────────────── + + Choice constructs include: + + ● Serial clauses with completers. + ● Conditional clauses. + ● Conformity clauses. + ● Case clauses. + + The characteristic of these constructs is that they need to perform + balancing on a set of alternatives, like the values yielded by the then-part + and the else-part of a conditional clause, in order to determine the static + properties of the value yielded by the choice construct. + + Given a choice construct involving sub-values V1, V2, .. Vn, with their + respective "a priori" static properties, the "a posteriori" static + properties of the resulting value Vr are derived as follows: + + ● The mode of Vr (which is a static property, albeit not handled here) is + determined from the balancing of the modes of V1, V2, ... Vn. This has + already been done by the parser at this stage and the parse tree nodes are + annotated with the "a posteriori" mode of the choice construct. Suitable + coercions are also in the parse tree. + + ● If all sub-values have the same "a priori" origin, then that's the origin + of Vr. Otherwise, we act conservatively by setting KINDO (Vr) to + KINDO_NIL, DEREFO to true iff any of the sub-values have DEREFO set, and + GENO to true iff any of the sub-values have GENO set. + + + ● If all sub-values have the same "a priori" access, then that's the access + of Vr. Otherwise, use direct access. + + These rules are implemented in the corresponding handlers for choice + constructs, below. */ + +/* Allocate a new origin and return it. The particular properties used to + initialize the value are arbitrary and the user should not rely on them. */ + +static ORIGIN_T * +make_origin (void) +{ + ORIGIN_T *ori = ggc_alloc (); + ori->kindo = KINDO_NIL; + ori->bno = 0; + ori->derefo = false; + ori->geno = false; + ori->diago = UNKNOWN_LOCATION; + return ori; +} + +/* Allocate a copy of ORI and return it. */ + +static ORIGIN_T * +dup_origin (ORIGIN_T *ori) +{ + ORIGIN_T *res = ggc_alloc (); + *res = *ori; + return res; +} + +/* Determine whether ORI1 and ORI2 reflect the same origin. */ + +static bool +origin_equal_p (ORIGIN_T *ori1, ORIGIN_T *ori2) +{ + return (ori1 != NO_ORIGIN + && ori2 != NO_ORIGIN + && (ori1 == ori2 + || (ori1->kindo == ori2->kindo + && ori1->derefo == ori2->derefo + && ori1->geno == ori2->geno + && ori1->diago == ori2->diago))); +} + +/* Denotations + ─────────── + + Denotations of any mode introduce their own constant origin, and always have + direct access. */ + +static void +sprops_for_denotation (NODE_T *p) +{ + ORIGIN (p) = make_origin (); + KINDO (p) = KINDO_CST; + DIAGO (p) = a68_get_node_location (p); + BNO (p) = 0; + DEREFO (p) = false; + ACCESS (p) = ACCESS_DIR; +} + +/* Widening coercion + ───────────────── + + Widening of integral and real values result into direct real and complex + values. The widening of bits and bytes result into direct multiple values. + This is a kernel invariant operation, so the origin stays unchanged. */ + +static void +sprops_for_widening (NODE_T *p) +{ + ORIGIN (p) = ORIGIN (SUB (p)); + ACCESS (p) = ACCESS_DIR; +} + +/* Voiding coercion + ──────────────── + + The origin of the voiding construct is the origin of the voided value. The + resulting voided voided value has acess NIL, denoting the absence of value. + This is a kernel invariant operation, so the origin stays unchanged. */ + +static void +sprops_for_voiding (NODE_T *p) +{ + ORIGIN (p) = ORIGIN (SUB (p)); + ACCESS (p) = ACCESS_NIL; +} + +/* Dereferencing coercion + ────────────────────── + + The origin of the dereferenced value is like the origin of the coercend but + with DEREFO set. We always use an indirect access for the coercee so we + delay actual indirection for when (and if) the dereferenced value actually + gets used. */ + +static void +sprops_for_dereferencing (NODE_T *p) +{ + ORIGIN (p) = dup_origin (ORIGIN (SUB (p))); + DEREFO (p) = true; + ACCESS (p) = ACCESS_IND; +} + +/* Deproceduring coercion + ────────────────────── + + It is not possible to detemine the origin of the value yielded by the + elaboration of the procedure, so we create a new one with KINDO_NIL. The + access of the yielded value is always direct. */ + +static void +sprops_for_deproceduring (NODE_T *p) +{ + ORIGIN (p) = make_origin (); + KINDO (p) = KINDO_NIL; + DIAGO (p) = a68_get_node_location (p); + BNO (p) = 0; + DEREFO (p) = false; + ACCESS (p) = ACCESS_DIR; +} + +/* Proceduring + ─────────── + + Procedured jumps result into a proc value. The origin is new and is of + KINDO_NIL. The access for the resulting procedure is always direct. */ + +static void +sprops_for_proceduring (NODE_T *p) +{ + ORIGIN (p) = make_origin (); + KINDO (p) = KINDO_NIL; + DIAGO (p) = a68_get_node_location (p); + BNO (p) = 0; + DEREFO (p) = false; + ACCESS (p) = ACCESS_DIR; +} + +/* Rowing coercion + ─────────────── + + The origin of the coercee is the origin of the coercend. The access of the + resulting value is always direct: reals, complex or multiples of bools or + chars. This is a kernel invariant operation, so the origin stays + unchanged. */ + +static void +sprops_for_rowing (NODE_T *p) +{ + ORIGIN (p) = ORIGIN (SUB (p)); + ACCESS (p) = ACCESS_DIR; +} + +/* Uniting coercion + ──────────────── + + The origin of the coercee is the origin of the coercend. XXX this is a sort + of multiple choices problem as well. This is a kernel invariant operation, + so the origin stays unchanged. */ + +static void +sprops_for_uniting (NODE_T *p) +{ + ORIGIN (p) = ORIGIN (SUB (p)); + ACCESS (p) = ACCESS_DIR; /* XXX */ +} + +/* Loop clauses + ──────────── + + The loop clause effectively acts like voiding, so it has its own origin. We + use NIL access, which denotes the absence of value. */ + +static void +sprops_for_loop_clause (NODE_T *p) +{ + ORIGIN (p) = make_origin (); + KINDO (p) = KINDO_NIL; + DIAGO (p) = a68_get_node_location (p); + BNO (p) = 0; + DEREFO (p) = false; + ACCESS (p) = ACCESS_NIL; +} + +/* Enclosed clauses + ──────────────── + + The origin and access of the value of an enclosed clause is the origin and + access of the value of its enclosed clause :-O */ + +static void +sprops_for_enclosed_clause (NODE_T *p) +{ + NODE_T *enclosed_clause = SUB (p); + ORIGIN (p) = ORIGIN (enclosed_clause); + ACCESS (p) = ACCESS (enclosed_clause); +} + +/* Access clauses + ────────────── + + The origin/access of the access clause is the origin/access of the + controlled clause. */ + +static void +sprops_for_access_clause (NODE_T *p) +{ + ORIGIN (p) = ORIGIN (NEXT_SUB (p)); +} + +/* Enquiry clauses + ─────────────── + + The origin of the enquiry clause is the origin of the unit yielded by the + underlying serial clause, which is assured to not have choices. The enquiry + clause always yields a boolean value, which much have direct access. */ + +static void +sprops_for_enquiry_clause (NODE_T *p) +{ + if (IS (SUB (p), UNIT)) + ORIGIN (p) = ORIGIN (SUB (p)); + else if (IS (SUB (p), ENQUIRY_CLAUSE) || IS (SUB (p), INITIALISER_SERIES)) + ORIGIN (p) = ORIGIN (NEXT (NEXT_SUB (p))); + else + gcc_unreachable (); + ACCESS (p) = ACCESS_DIR; +} + +/* Serial clauses + ────────────── + + Serial clauses that have completers are choice constructs, in the sense they + yield one of several units determined at run-time, and therefore it becomes + necessary to do some "balancing" at compile-time. See the comment "Handling + of choice constructs" above for a description of the strategy we follow for + the "origin" and "access" static properties in such constructs. */ + +static void +sprops_for_serial_clause (NODE_T *p) +{ + NODE_T *last_unit = NO_NODE, *completer = NO_NODE; + + if (IS (SUB (p), UNIT)) + last_unit = SUB (p); + else if (IS (SUB (p), LABELED_UNIT)) + last_unit = NEXT_SUB (SUB (p)); + else + { + gcc_assert (IS (SUB (p), SERIAL_CLAUSE) || IS (SUB (p), INITIALISER_SERIES)); + + if (IS (NEXT_SUB (p), EXIT_SYMBOL)) + completer = SUB (p); + + NODE_T *q = NEXT (NEXT_SUB (p)); + if (IS (q, UNIT)) + last_unit = q; + else + { + gcc_assert (IS (q, LABELED_UNIT)); + last_unit = NEXT_SUB (q); + } + } + + gcc_assert (last_unit != NO_NODE); + gcc_assert (ORIGIN (last_unit) != NO_ORIGIN); + + if (completer == NO_NODE) + { + ORIGIN (p) = ORIGIN (last_unit); + ACCESS (p) = ACCESS (last_unit); + } + else + { + /* Balance origin. */ + if (origin_equal_p (ORIGIN (completer), ORIGIN (last_unit))) + ORIGIN (p) = ORIGIN (completer); + else + { + bool found_derefo = DEREFO (last_unit) | DEREFO (completer); + bool found_geno = GENO (last_unit) | GENO (completer); + ORIGIN (p) = make_origin (); + KINDO (p) = KINDO_NIL; + DEREFO (p) = found_derefo; + GENO (p) = found_geno; + BNO (p) = 0; + } + + /* Balance access. */ + if (ACCESS (completer) == ACCESS (last_unit)) + ACCESS (p) = ACCESS (completer); + else + ACCESS (p) = ACCESS_DIR; + } +} + +/* Parallel clauses + ──────────────── + + A parallel clause yields void, thus we create a fresh origin with KINDO_NIL. + The access is NIL. */ + +static void +sprops_for_parallel_clause (NODE_T *p) +{ + ORIGIN (p) = make_origin (); + KINDO (p) = KINDO_NIL; + BNO (p) = 0; + DEREFO (p) = false; + GENO (p) = false; + ACCESS (p) = ACCESS_NIL; +} + +/* Closed clauses + ────────────── + + The origin/access of a closed clause is the origin/access of its contained + serial clause. */ + +static void +sprops_for_closed_clause (NODE_T *p) +{ + ORIGIN (p) = ORIGIN (NEXT_SUB (p)); +} + +/* Conditional clauses + ─────────────────── + + The if-part and else-part of the conditional clause makes it a choice + construct in terms of static properties propagation. See "Handling of + choice constructs" above. */ + +static void +sprops_for_conditional_clause (NODE_T *p) +{ + NODE_T *then_part = NO_NODE, *else_part = NO_NODE; + + /* IF or ELIF part,SUB is an enquiry clause. */ + NODE_T *s = SUB (p); + + /* THEN part, SUB is a serial clause. */ + FORWARD (s); + then_part = NEXT_SUB (s); + + /* ELSE part. */ + FORWARD (s); + if (IS (s, CHOICE) || IS (s, ELSE_PART)) + else_part = NEXT (NEXT_SUB (s)); + else if (IS (s, CLOSE_SYMBOL) || IS (s, FI_SYMBOL)) + ; + else + { + /* ELIF part. Recurse. */ + sprops_for_conditional_clause (s); + else_part = s; + } + + if (else_part == NO_NODE) + { + ORIGIN (p) = ORIGIN (then_part); + ACCESS (p) = ACCESS (then_part); + } + else + { + /* Balance origin. */ + if (origin_equal_p (ORIGIN (then_part), ORIGIN (else_part))) + ORIGIN (p) = ORIGIN (else_part); + else + { + bool found_derefo = DEREFO (then_part) | DEREFO (else_part); + bool found_geno = GENO (then_part) | GENO (else_part); + + ORIGIN (p) = make_origin (); + KINDO (p) = KINDO_NIL; + DEREFO (p) = found_derefo; + GENO (p) = found_geno; + BNO (p) = 0; + } + + /* Balance access. */ + if (ACCESS (then_part) == ACCESS (else_part)) + ACCESS (p) = ACCESS (else_part); + else + ACCESS (p) = ACCESS_DIR; + } +} + +/* Case clauses + ──────────── + + The existence of several alterantives in a case clause makes it a choice + construct in terms of static properties propagation. See "Handling of + choice constructs" above. */ + +static void +sprops_for_case_unit (NODE_T *p, + bool found_mismatch, + ORIGIN_T **postulated_origin, + bool *found_derefo, bool *found_geno, + ACCESS_T *postulated_access) +{ + for (; p != NO_NODE; FORWARD (p)) + { + if (IS (p, UNIT)) + { + *found_derefo |= DEREFO (p); + *found_geno |= GENO (p); + + if (*postulated_origin == NO_ORIGIN && !found_mismatch) + *postulated_origin = ORIGIN (p); + else if (!origin_equal_p (ORIGIN (p), *postulated_origin)) + { + *postulated_origin = NO_ORIGIN; + found_mismatch = true; + } + } + else + sprops_for_case_unit (SUB (p), + found_mismatch, + postulated_origin, + found_derefo, found_geno, + postulated_access); + } +} + +static void +sprops_for_case_clause (NODE_T *p) +{ + NODE_T *out_part = NO_NODE; + + /* CASE or OUSE. */ + NODE_T *s = SUB (p); + + /* IN. */ + NODE_T *in_parts = FORWARD (s); + + /* OUT. */ + FORWARD (s); + if (IS (s, CHOICE) || IS (s, OUT_PART)) + out_part = NEXT (NEXT_SUB (s)); + else if (IS (s, CLOSE_SYMBOL) || IS (s, ESAC_SYMBOL)) + ; + else + { + /* Recurse. */ + sprops_for_case_clause (s); + out_part = s; + } + + /* We start by postulating the properties of the out-part, if it exists, then + go through all the in-parts. */ + + ORIGIN_T *postulated_origin = NO_ORIGIN; + ACCESS_T postulated_access = NO_ACCESS; + + bool found_derefo = false, found_geno = false; + + if (out_part != NO_NODE) + postulated_origin = ORIGIN (out_part); + + sprops_for_case_unit (in_parts, false, + &postulated_origin, + &found_derefo, &found_geno, + &postulated_access); + + /* Balance origin. */ + if (postulated_origin != NO_ORIGIN) + ORIGIN (p) = postulated_origin; + else + { + ORIGIN (p) = make_origin (); + KINDO (p) = KINDO_NIL; + DEREFO (p) = found_derefo; + GENO (p) = found_geno; + BNO (p) = 0; + } + + /* Balance access. */ + if (postulated_access != NO_ACCESS) + ACCESS (p) = postulated_access; + else + ACCESS (p) = ACCESS_DIR; + +} + +/* Collateral clauses + ────────────────── + + We distinguish between two cases when handling the static properties of + collateral clauses: + + ● VOID-collateral-clauses yield void, and therefore they have origin of kind + NIL and access NIL. + + ● Row- and struct-displays yield a multiple value, with origin constant and + direct access. */ + +static void +sprops_for_collateral_clause (NODE_T *p) +{ + ORIGIN (p) = make_origin (); + BNO (p) = 0; + GENO (p) = 0; + DEREFO (p) = 0; + + if (MOID (p) == M_VOID) + { + KINDO (p) = KINDO_NIL; + ACCESS (p) = ACCESS_NIL; + } + else + { + KINDO (p) = KINDO_CST; + ACCESS (p) = ACCESS_DIR; + } +} + +/* Conformity clauses + ────────────────── + + The existence of several alterantives in a conformity clause makes it a + choice construct in terms of static properties propagation. See "Handling + of choice constructs" above. */ + +static void +sprops_for_unite_case_unit (NODE_T *p, + bool found_mismatch, + ORIGIN_T **postulated_origin, + bool *found_derefo, bool *found_geno, + ACCESS_T *postulated_access) +{ + for (; p != NO_NODE; FORWARD (p)) + { + if (IS (p, SPECIFIER)) + { + NODE_T *spec_unit = NEXT_NEXT (p); + + *found_derefo |= DEREFO (spec_unit); + *found_geno |= GENO (spec_unit); + + if (*postulated_origin == NO_ORIGIN && !found_mismatch) + *postulated_origin = ORIGIN (spec_unit); + else if (!origin_equal_p (ORIGIN (spec_unit), *postulated_origin)) + { + *postulated_origin = NO_ORIGIN; + found_mismatch = true; + } + + FORWARD (p); /* Skip specifier. */ + FORWARD (p); /* Skip unit. */ + /* The unit is skipped in the for loop post-action. */ + } + else + sprops_for_unite_case_unit (SUB (p), + found_mismatch, + postulated_origin, + found_derefo, found_geno, + postulated_access); + } +} + +static void +sprops_for_conformity_clause (NODE_T *p) +{ + NODE_T *out_part = NO_NODE; + + /* CASE or OUSE. */ + NODE_T *s = SUB (p); + + /* IN. */ + NODE_T *in_parts = FORWARD (s); + + /* OUT. */ + FORWARD (s); + if (IS (s, CHOICE) || IS (s, OUT_PART)) + out_part = NEXT (NEXT_SUB (s)); + else if (IS (s, CLOSE_SYMBOL) || IS (s, ESAC_SYMBOL)) + ; + else + { + /* Recurse. */ + sprops_for_conformity_clause (s); + out_part = s; + } + + /* We start by postulating the properties of the out-part, if it exists, then + go through all the in-parts. */ + + ORIGIN_T *postulated_origin = NO_ORIGIN; + ACCESS_T postulated_access = NO_ACCESS; + + bool found_derefo = false, found_geno = false; + + if (out_part != NO_NODE) + postulated_origin = ORIGIN (out_part); + + sprops_for_unite_case_unit (in_parts, false, + &postulated_origin, + &found_derefo, &found_geno, + &postulated_access); + + /* Balance origin. */ + if (postulated_origin != NO_ORIGIN) + ORIGIN (p) = postulated_origin; + else + { + ORIGIN (p) = make_origin (); + KINDO (p) = KINDO_NIL; + DEREFO (p) = found_derefo; + GENO (p) = found_geno; + BNO (p) = 0; + } + + /* Balance access. */ + if (postulated_access != NO_ACCESS) + ACCESS (p) = postulated_access; + else + ACCESS (p) = ACCESS_DIR; +} + +/* Identity relations + ────────────────── + + The identity relation yields a new boolean value with a fresh origin. Its + access is always direct. */ + +static void +sprops_for_identity_relation (NODE_T *p) +{ + ORIGIN (p) = make_origin (); + KINDO (p) = KINDO_NIL; + BNO (p) = 0; + DEREFO (p) = false; + GENO (p) = false; + ACCESS (p) = ACCESS_DIR; +} + +/* Assignations + ──────────── + + If according to previsions the assignation is immediately dereferenced, the + dereferencing is combined with the assignation by the lowerer, and we use + the static properties of the source instaed of those of the destination. */ + +static void +sprops_for_assignation (NODE_T *p) +{ + NODE_T *destination = SUB (p); + ORIGIN (p) = ORIGIN (destination); + /* XXX implement prevision. */ + ACCESS (p) = ACCESS_DIR; +} + +/* Slices + ────── + + The origin of a slice is the origin of the primary being sliced. The access + is alwyas direct. This is a kernel invariant operation, so the origin stays + unchanged. */ + +static void +sprops_for_slice (NODE_T *p) +{ + NODE_T *primary = SUB (p); + ORIGIN (p) = ORIGIN (primary); + ACCESS (p) = ACCESS_DIR; +} + +/* Selections + ────────── + + The origin of a selection is the origin of the secondary being selected. + The access is always direct. This is a kernel invariant operation, so the + origin stays unchanged. */ + +static void +sprops_for_selection (NODE_T *p) +{ + NODE_T *secondary; + + if (IS (SUB (p), SELECTOR)) + secondary = NEXT_SUB (p); + else + { + gcc_assert (IS (SUB (p), SECONDARY)); + secondary = SUB (p); + } + ORIGIN (p) = ORIGIN (secondary); + ACCESS (p) = ACCESS_DIR; +} + +/* Logical functions + ───────────────── + + The logical function constructs (or_function, and_function) introduce a new + origin, which is of class KINDO_NIL. The value yielded by these constructs + is a boolean and its access is always direct. */ + +static void +sprops_for_logical_function (NODE_T *p) +{ + ORIGIN (p) = make_origin (); + DIAGO (p) = a68_get_node_location (p); + KINDO (p) = KINDO_NIL; + BNO (p) = 0; + DEREFO (p) = false; + ACCESS (p) = ACCESS_DIR; +} + +/* Casts + ───── + + Both origin and access of the coercee are the same origin and access o the + coercend in the strong context introduced by the cast. This is a kernel + invariant operation, so the origin stays unchanged. */ + +static void +sprops_for_cast (NODE_T *p) +{ + NODE_T *coercend = NEXT_SUB (p); + ORIGIN (p) = ORIGIN (coercend); + ACCESS (p) = ACCESS (coercend); +} + +/* Calls + ───── + + The value yielded by a call has a fresh origin of class NIL. The access is + always direct. */ + +static void +sprops_for_call (NODE_T *p) +{ + ORIGIN (p) = make_origin (); + DIAGO (p) = a68_get_node_location (p); + KINDO (p) = KINDO_NIL; + BNO (p) = 0; + DEREFO (p) = false; +} + +/* Generators + ────────── + + Generators introduce a fresh origin of class GEN, and appropriate + attributes. The access is always IND. */ + +static void +sprops_for_generator (NODE_T *p) +{ + ORIGIN (p) = make_origin (); + DIAGO (p) = a68_get_node_location (p); + KINDO (p) = KINDO_GEN; + DEREFO (p) = false; + if (IS (SUB (p), LOC_SYMBOL)) + { + BNO (p) = 0; /* XXX */ + GENO (p) = true; + } + else + { + BNO (p) = 0; + GENO (p) = false; + } +} + +/* Monadic formulas + ──────────────── + + The value yielded by a monadic formula has the same origin than the single + operand. The access is always direct. */ + +static void +sprops_for_monadic_formula (NODE_T *p) +{ + ORIGIN (p) = ORIGIN (NEXT (SUB (p))); + ACCESS (p) = ACCESS_DIR; +} + +/* Dyadic formulas + ─────────────── + + If both operands of the formula have the same origin, then that is the + origin of the value yielded by the formula. Otherwise a fresh origin is + created with class NIL. The value yielded by the formula always have direct + access. */ + +static void +sprops_for_formula (NODE_T *p) +{ + if (IS (SUB (p), MONADIC_FORMULA) && NEXT_SUB (p) == NO_NODE) + ORIGIN (p) = ORIGIN (SUB (p)); + else + { + NODE_T *arg1 = SUB (p); + NODE_T *arg2 = NEXT (NEXT (SUB (p))); + + if (origin_equal_p (ORIGIN (arg1), ORIGIN (arg2))) + ORIGIN (p) = ORIGIN (arg1); + else + { + ORIGIN (p) = make_origin (); + DIAGO (p) = a68_get_node_location (p); + KINDO (p) = KINDO_NIL; + DEREFO (p) = 0; + BNO (p) = 0; + GENO (p) = false; + } + } + ACCESS (p) = ACCESS_DIR; +} + +/* Identifiers + ─────────── + + Both the access and origin of the value yielded by an applied identifier is + obtained from the symtab. If the applied identifier appears before its + declaration, the symtab will not have the properties installed; in that + case, an origin is allocated in the symtab. XXX we need to install a + pointer to the access in the symtab. */ + +static void +sprops_for_applied_identifier (NODE_T *p) +{ + if (ORIGIN (TAX (p)) == NO_ORIGIN) + ORIGIN (TAX (p)) = make_origin (); + ORIGIN (p) = ORIGIN (TAX (p)); + ACCESS (p) = ACCESS (TAX (p)); +} + +/* Assertions + ────────── + + Assertions introduce a fresh origin of class NIL. The access is also + NIL. */ + +static void +sprops_for_assertion (NODE_T *p) +{ + ORIGIN (p) = make_origin (); + DIAGO (p) = a68_get_node_location (p); + KINDO (p) = KINDO_NIL; + BNO (p) = 0; + DEREFO (p) = false; + ACCESS (p) = ACCESS_NIL; +} + +/* Fill in the static properties for the symtab entry for the identifier + declared in P, which is a parse node for a declaration. This function shall + handle all node types for which a68_is_declaration returns `true'. */ + +static void +sprops_for_decl (NODE_T *p) +{ + /* Declarations do not yield values themselves, but we set the origin and + access of their defining identifiers in their symtab entries. */ + + ORIGIN (p) = NO_ORIGIN; + ACCESS (p) = NO_ACCESS; + + /* Get the defining identifier. */ + NODE_T *defining_identifier = NO_NODE; + + switch (ATTRIBUTE (p)) + { + case IDENTITY_DECLARATION: + if (IS (SUB (p), IDENTITY_DECLARATION)) + defining_identifier = NEXT (NEXT_SUB (p)); + else if (IS (SUB (p), PUBLIC_SYMBOL)) + defining_identifier = NEXT (NEXT_SUB (p)); + else if (IS (SUB (p), DECLARER)) + defining_identifier = NEXT_SUB (p); + else + gcc_unreachable (); + break; + case PROCEDURE_DECLARATION: + if (IS (SUB (p), PROCEDURE_DECLARATION)) + defining_identifier = NEXT (NEXT_SUB (p)); + else if (IS (SUB (p), PUBLIC_SYMBOL)) + defining_identifier = NEXT (NEXT_SUB (p)); + else if (IS (SUB (p), PROC_SYMBOL)) + defining_identifier = NEXT_SUB (p); + else + gcc_unreachable (); + break; + case BRIEF_OPERATOR_DECLARATION: + if (IS (SUB (p), BRIEF_OPERATOR_DECLARATION)) + defining_identifier = NEXT (NEXT_SUB (p)); + else if (IS (SUB (p), PUBLIC_SYMBOL)) + defining_identifier = NEXT (NEXT_SUB (p)); + else + defining_identifier = NEXT_SUB (p); + break; + case OPERATOR_DECLARATION: + if (IS (SUB (p), OPERATOR_DECLARATION)) + defining_identifier = NEXT (NEXT_SUB (p)); + else if (IS (SUB (p), PUBLIC_SYMBOL)) + defining_identifier = NEXT (NEXT_SUB (p)); + else + defining_identifier = NEXT_SUB (p); + break; + case VARIABLE_DECLARATION: + if (IS (SUB (p), VARIABLE_DECLARATION)) + defining_identifier = NEXT (NEXT_SUB (p)); + else + { + NODE_T *q = SUB (p); + + if (IS (q, PUBLIC_SYMBOL)) + FORWARD (q); + + if (IS (q, QUALIFIER)) + defining_identifier = NEXT (NEXT (q)); + else if (IS (q, DECLARER)) + defining_identifier = NEXT (q); + else + gcc_unreachable (); + } + break; + case PROCEDURE_VARIABLE_DECLARATION: + if (IS (SUB (p), PROCEDURE_VARIABLE_DECLARATION)) + defining_identifier = NEXT (NEXT_SUB (p)); + else + { + NODE_T *q = SUB (p); + + if (IS (q, PUBLIC_SYMBOL)) + FORWARD (q); + + if (IS (q, PROC_SYMBOL)) + defining_identifier = NEXT (q); + else if (IS (q, QUALIFIER)) + defining_identifier = NEXT (NEXT (q)); + else + gcc_unreachable (); + } + break; + default: + break; + } + + /* Set the static attributes in the symtab for the defining identifier. */ + if (defining_identifier != NO_NODE) + { + switch (ATTRIBUTE (p)) + { + case IDENTITY_DECLARATION: + case PROCEDURE_DECLARATION: + { + TAG_T *tax = TAX (defining_identifier); + if (ORIGIN (tax) == NO_ORIGIN) + ORIGIN (tax) = make_origin (); + DIAGO (tax) = a68_get_node_location (p); + KINDO (tax) = KINDO_IDE; + ACCESS (tax) = ACCESS_DIR; + break; + } + case VARIABLE_DECLARATION: + case PROCEDURE_VARIABLE_DECLARATION: + { + TAG_T *tax = TAX (defining_identifier); + if (ORIGIN (tax) == NO_ORIGIN) + ORIGIN (tax) = make_origin (); + DIAGO (tax) = a68_get_node_location (p); + KINDO (tax) = KINDO_VAR; + ACCESS (tax) = ACCESS_VAR; + break; + } + case MODE_DECLARATION: + case PRIORITY_DECLARATION: + case BRIEF_OPERATOR_DECLARATION: + case OPERATOR_DECLARATION: + /* These declarations do not ascribe values to identifiers so there + is nothing to do. */ + break; + default: + gcc_unreachable (); + } + } +} + +/* Fill in the static properties for P, which is a parse node for a construct + yielding some value. This function shall handle all node types for which + a68_yields_value returns `true'. */ + +static void +sprops_for_unit (NODE_T *p) +{ + switch (ATTRIBUTE (p)) + { + case UNIT: + case PRIMARY: + case SECONDARY: + case TERTIARY: + ORIGIN (p) = ORIGIN (SUB (p)); + break; + case FORMAL_HOLE: + case JUMP: + case SKIP: + case NIHIL: + case EMPTY_SYMBOL: + case ROUTINE_TEXT: + ORIGIN (p) = make_origin (); + DIAGO (p) = a68_get_node_location (p); + KINDO (p) = KINDO_NIL; + DEREFO (p) = false; + BNO (p) = 0; + ACCESS (p) = ACCESS_DIR; + break; + case DENOTATION: + sprops_for_denotation (p); + break; + case IDENTIFIER: + sprops_for_applied_identifier (p); + break; + case MONADIC_FORMULA: + sprops_for_monadic_formula (p); + break; + case FORMULA: + sprops_for_formula (p); + break; + case GENERATOR: + sprops_for_generator (p); + break; + case SELECTION: + sprops_for_selection (p); + break; + case DEREFERENCING: + sprops_for_dereferencing (p); + break; + case DEPROCEDURING: + sprops_for_deproceduring (p); + break; + case PROCEDURING: + sprops_for_proceduring (p); + break; + case SLICE: + sprops_for_slice (p); + break; + case WIDENING: + sprops_for_widening (p); + break; + case UNITING: + sprops_for_uniting (p); + break; + case ROWING: + sprops_for_rowing (p); + break; + case VOIDING: + sprops_for_voiding (p); + break; + case ASSIGNATION: + sprops_for_assignation (p); + break; + case IDENTITY_RELATION: + sprops_for_identity_relation (p); + break; + case ACCESS_CLAUSE: + sprops_for_access_clause (p); + break; + case ENQUIRY_CLAUSE: + sprops_for_enquiry_clause (p); + break; + case LOOP_CLAUSE: + sprops_for_loop_clause (p); + break; + case ENCLOSED_CLAUSE: + sprops_for_enclosed_clause (p); + break; + case SERIAL_CLAUSE: + sprops_for_serial_clause (p); + break; + case CLOSED_CLAUSE: + sprops_for_closed_clause (p); + break; + case PARALLEL_CLAUSE: + sprops_for_parallel_clause (p); + break; + case CONDITIONAL_CLAUSE: + sprops_for_conditional_clause (p); + break; + case CONFORMITY_CLAUSE: + sprops_for_conformity_clause (p); + break; + case CASE_CLAUSE: + sprops_for_case_clause (p); + break; + case COLLATERAL_CLAUSE: + sprops_for_collateral_clause (p); + break; + case CALL: + sprops_for_call (p); + break; + case AND_FUNCTION: + case OR_FUNCTION: + sprops_for_logical_function (p); + break; + case ASSERTION: + sprops_for_assertion (p); + break; + case CAST: + sprops_for_cast (p); + break; + default: + gcc_unreachable (); + } + + /* Sanity check. */ + gcc_assert (ACCESS (p) != NO_ACCESS); + gcc_assert (ORIGIN (p) != NO_ORIGIN); +} + +/* Entry point for the sprops parser pass. */ + +void +a68_sprops (NODE_T *p) +{ + for (; p != NO_NODE; FORWARD (p)) + { + a68_sprops (SUB (p)); + + if (a68_yields_value (p)) + sprops_for_unit (p); + else if (a68_is_declaration (p)) + sprops_for_decl (p); + else + { + ORIGIN (p) = NO_ORIGIN; + ACCESS (p) = NO_ACCESS; + } + } +} diff --git a/gcc/algol68/a68-parser.cc b/gcc/algol68/a68-parser.cc index 40ebe507492a..2f64b0a86289 100644 --- a/gcc/algol68/a68-parser.cc +++ b/gcc/algol68/a68-parser.cc @@ -298,6 +298,82 @@ a68_is_loop_keyword (NODE_T *p) } } +/* Whether the construct denoted by P is a declaration that introduces some + defining identifier or indicant. */ + +bool +a68_is_declaration (NODE_T *p) +{ + switch (ATTRIBUTE (p)) + { + case IDENTITY_DECLARATION: + case VARIABLE_DECLARATION: + case PROCEDURE_DECLARATION: + case PROCEDURE_VARIABLE_DECLARATION: + case PRIORITY_DECLARATION: + case BRIEF_OPERATOR_DECLARATION: + case OPERATOR_DECLARATION: + case MODE_DECLARATION: + return true; + default: + return false; + } +} + +/* Whether the construct denoted by P yields a value. */ + +bool +a68_yields_value (NODE_T *p) +{ + switch (ATTRIBUTE (p)) + { + case ACCESS_CLAUSE: + case ASSERTION: + case UNIT: + case ROUTINE_TEXT: + case ASSIGNATION: + case TERTIARY: + case MONADIC_FORMULA: + case FORMULA: + case SECONDARY: + case SLICE: + case SELECTION: + case PRIMARY: + case GENERATOR: + case CALL: + case CAST: + case AND_FUNCTION: + case OR_FUNCTION: + case FORMAL_HOLE: + case IDENTITY_RELATION: + case EMPTY_SYMBOL: + case NIHIL: + case SKIP: + case PARALLEL_CLAUSE: + case SERIAL_CLAUSE: + case CLOSED_CLAUSE: + case ENCLOSED_CLAUSE: + case LOOP_CLAUSE: + case CONDITIONAL_CLAUSE: + case CASE_CLAUSE: + case CONFORMITY_CLAUSE: + case COLLATERAL_CLAUSE: + case DENOTATION: + case IDENTIFIER: + case DEREFERENCING: + case DEPROCEDURING: + case PROCEDURING: + case WIDENING: + case UNITING: + case ROWING: + case VOIDING: + case JUMP: + return true; + default: + return false; + } +} + /* Get good attribute. */ enum a68_attribute @@ -599,6 +675,15 @@ a68_parser (const char *filename) a68_serial_dsa (TOP_NODE (&A68_JOB)); } + /* Static properties. */ + if (ERROR_COUNT (&A68_JOB) == 0) + { + a68_sprops (TOP_NODE (&A68_JOB)); + } + + // XXX + // a68_dump_parse_tree (TOP_NODE (&A68_JOB), false, false, true); + /* Finalise syntax tree. */ if (ERROR_COUNT (&A68_JOB) == 0) { @@ -671,6 +756,8 @@ a68_new_node (void) DYNAMIC_STACK_ALLOCS (z) = false; PUBLICIZED (z) = false; NEGATED (z) = false; + ORIGIN (z) = NO_ORIGIN; + ACCESS (z) = ACCESS_DIR; return z; } @@ -791,6 +878,8 @@ a68_new_tag (void) PUBLICIZED (z) = false; ASCRIBED_ROUTINE_TEXT (z) = false; LOWERER (z) = NO_LOWERER; + ORIGIN (z) = NO_ORIGIN; + ACCESS (z) = ACCESS_DIR; TAX_TREE_DECL (z) = NULL_TREE; MOIF (z) = NO_MOIF; EXTERN_SYMBOL (z) = NO_TEXT; diff --git a/gcc/algol68/a68-types.h b/gcc/algol68/a68-types.h index 472a8bb29ef1..e34817cd1232 100644 --- a/gcc/algol68/a68-types.h +++ b/gcc/algol68/a68-types.h @@ -69,6 +69,28 @@ enum a68_tree_index ATI_MAX }; +enum a68_access +{ + /* Access. See a68-parser-sprops.cc. */ + NO_ACCESS = 0, + ACCESS_NIL, + ACCESS_DIR, + ACCESS_IND, + ACCESS_VAR +}; + +typedef enum a68_access ACCESS_T; + +enum a68_kindo +{ + /* Kind of origin. See a68-parser-sprops.cc. */ + KINDO_NIL = 0, + KINDO_CST, + KINDO_IDE, + KINDO_VAR, + KINDO_GEN +}; + /* * Type definitions. */ @@ -318,52 +340,25 @@ struct GTY(()) OPTIONS_T bool nil_checking; }; -/* The access class static property of a stored value determines how the value - can be reached at run-time. It is used by the lowering pass in order to - minimize copies at run-time. - - CONSTANT is for constant literals. At run-time these literals will either - reside in operand instructions or in space allocated in CONSTAB%. - - DIRIDEN (direct identifier) means that the value is stored on IDST% at some - static address. This is the access class used for values ascribed to - identifiers as long as the block in hich they are declared has not been - left. It is also used for values resulting from actions such as the - selection from a value possessed by an identifier or the dereferencing fo a - name corespodning to a variable. - - VARIDEN (variable identifier) is used for values which are names/variables. - The name is stored on IDST%. The static elaboration of the dereferencing of - a variable with access VARIDEN results in a value with access DIRIDEN, not - requiring any run-time action. Same happens with selections of variables of - access VARIDEN. - - INDIDEN (indirect identifier) is used for values that are stored in a memory - location in IDST%. The static elaboration of a dereferencing applied to a - value of access DIRIDEN. - - DIRWOST (direct working stack) is very much like DIRIDEN, except that the - value is stored in WOST% rather than in IDST%. This access is used for the - result of an action when this result does not preexist in memory and hence - has to be constructed in WOST%. - - INDWOST (indirect working stack) is very similar to INDIDEN. Such an access - can be obtained for example through the static elaboration of the - dereferencing of a name the access of which is DIRWOST. - - NIHIL is used to characterize the absence of value. This is used in the - static elaboration of a jump, a voiding and a call ith a void result. - - Note that in all these classes we assume as run-time the intermediate - language level we are lowering to, i.e. GENERIC. A DIRIDEN value, for - example, can very well stored in a register depending on further compiler - optimizations. */ - -#define ACCESS_NIHIL 0 -#define ACCESS_CONSTANT 1 -#define ACCESS_DIRIDEN 2 -#define ACCESS_INDIDEN 3 -#define ACCESS_DIRWOST 4 +/* An ORIGIN_T is a set of static properties that keep track of the story of + the value represented by an AST node, i.e. the way it has been obtained. + + KINDO is the kind of the origin. + BNO is the block number of the origin. + DEREFO is the flag dereferencing of the origin. + GENO is the flag local generator of the origin. + DIAGO is the location of the origin. */ + +#define NO_ORIGIN ((ORIGIN_T *) 0) + +struct GTY(()) ORIGIN_T +{ + enum a68_kindo kindo; + int bno; + bool derefo; + bool geno; + location_t diago; +}; /* A NODE_T is a node in the A68 Syntax tree produced by the lexer-scanner and later expanded by the Mailloux parser. @@ -424,7 +419,11 @@ struct GTY(()) OPTIONS_T pass. ORIGIN is a static property that describes the history of the entity denoted - by the node. This is only used in nodes denoting values. + by the node. This is only used in nodes denoting constructs that yield a + value, i.e. units. + + ACCESS is a static property that describes how to compute the value yielded + by the node given the GENERIC tree it lowers to. DYNAMIC_STACK_ALLOCS is a flag used in serial clause nodes. It determines whether the elaboration of the phrases in the serial clause may involve @@ -459,6 +458,8 @@ struct GTY((chain_next ("%h.next"), chain_prev ("%h.previous"))) NODE_T bool dynamic_stack_allocs; bool publicized; bool negated; + ORIGIN_T *origin; + enum a68_access access; }; #define NO_NODE ((NODE_T *) 0) @@ -620,7 +621,13 @@ struct GTY(()) TABLE_T module declaration. This is only used in entries where MOIF is not NO_MOIF. LOWERER is a lowering routine defined in a68-low-prelude.cc. These are used - in taxes that denote some pre-defined operator. */ + in taxes that denote some pre-defined operator. + + ORIGIN is a static property that describes the history of the value being + ascribed to the identifier. + + ACCESS is a static property that describes how to compute the value yielded + by the identifier given the GENERIC tree it lowers to. */ struct GTY((chain_next ("%h.next"))) TAG_T { @@ -635,6 +642,8 @@ struct GTY((chain_next ("%h.next"))) TAG_T tree tree_decl; MOIF_T *moif; LOWERER_T lowerer; + ORIGIN_T *origin; + enum a68_access access; TAG_T *next, *body; const char *extern_symbol; }; @@ -911,16 +920,16 @@ struct GTY(()) A68_T * in order to achieve a nice ALGOL-like field OF struct style. */ +#define ACCESS(p) ((p)->access) #define ASM_LABEL(m) ((m)->asm_label) #define BACKWARD(p) (p = PREVIOUS (p)) -#define DEFLEX(p) (DEFLEXED (p) != NO_MOID ? DEFLEXED(p) : (p)) -#define FORWARD(p) ((p) = NEXT (p)) #define A(p) ((p)->a) #define ANNOTATION(p) ((p)->annotation) #define ANONYMOUS(p) ((p)->anonymous) #define ATTRIBUTE(p) ((p)->attribute) #define ASCRIBED_ROUTINE_TEXT(p) ((p)->ascribed_routine_text) #define B(p) ((p)->b) +#define BNO(p) ((p)->origin->bno) #define BODY(p) ((p)->body) #define CAST(p) ((p)->cast) #define CHAR_IN_LINE(p) ((p)->char_in_line) @@ -931,9 +940,11 @@ struct GTY(()) A68_T #define COMMENT_LINE(p) ((p)->comment_line) #define COMMENT_TYPE(p) ((p)->comment_type) #define CTYPE(p) ((p)->ctype) +#define DEFLEX(p) (DEFLEXED (p) != NO_MOID ? DEFLEXED(p) : (p)) #define DEFLEXED(p) ((p)->deflexed_mode) -#define DEREFO(p) ((p).derefo) +#define DEREFO(p) ((p)->origin->derefo) #define DERIVATE(p) ((p)->derivate) +#define DIAGO(p) ((p)->origin->diago) #define DIM(p) ((p)->dim) #define DYNAMIC_STACK_ALLOCS(p) ((p)->dynamic_stack_allocs) #define EQUIVALENT(p) ((p)->equivalent_mode) @@ -950,11 +961,10 @@ struct GTY(()) A68_T #define F(p) ((p)->f) #define FILE_SOURCE_FD(p) ((p)->file_source_fd) #define FILE_SOURCE_NAME(p) ((p)->file_source_name) -#define FLEXO(p) ((p).flexo) -#define FLEXO_KNOWN(p) ((p).flexo_known) +#define FORWARD(p) ((p) = NEXT (p)) #define G(p) ((p)->g) #define GINFO(p) ((p)->genie) -#define GENO(p) ((p).geno) +#define GENO(p) ((p)->origin->geno) #define GET(p) ((p)->get) #define GPARENT(p) (PARENT (GINFO (p))) #define GREEN(p) ((p)->green) @@ -986,6 +996,7 @@ struct GTY(()) A68_T #define JUMP_STAT(p) ((p)->jump_stat) #define JUMP_TO(p) ((p)->jump_to) #define K(q) ((q)->k) +#define KINDO(p) ((p)->origin->kindo) #define LABELS(p) ((p)->labels) #define LAST(p) ((p)->last) #define LAST_LINE(p) ((p)->last_line) @@ -1059,6 +1070,7 @@ struct GTY(()) A68_T #define OPTION_LIST(p) (OPTIONS (p).list) #define OPTION_LOCAL(p) (OPTIONS (p).local) #define OPTION_NODEMASK(p) (OPTIONS (p).nodemask) +#define ORIGIN(p) ((p)->origin) #define OUT(p) ((p)->out) #define OUTER(p) ((p)->outer) #define P(q) ((q)->p) diff --git a/gcc/algol68/a68.h b/gcc/algol68/a68.h index bf0e00e6d84d..16642c6e0bda 100644 --- a/gcc/algol68/a68.h +++ b/gcc/algol68/a68.h @@ -340,6 +340,8 @@ char *a68_new_string (const char *t, ...); const char *a68_attribute_name (enum a68_attribute attr); location_t a68_get_node_location (NODE_T *p); location_t a68_get_line_location (LINE_T *line, const char *pos); +bool a68_yields_value (NODE_T *p); +bool a68_is_declaration (NODE_T *p); /* a68-parser-top-down.cc */ @@ -523,6 +525,10 @@ void a68_scope_checker (NODE_T *p); void a68_serial_dsa (NODE_T *p); +/* a68-parser-sprops.cc */ + +void a68_sprops (NODE_T *p); + /* a68-parser-pragmat.cc */ void a68_handle_pragmats (NODE_T *p); @@ -1096,7 +1102,8 @@ char *a68_find_archive_export_data (const char *filename, int fd, size_t *size); /* a68-parser-debug.cc */ -void a68_dump_parse_tree (NODE_T *p, bool tables = false, bool levels = false); +void a68_dump_parse_tree (NODE_T *p, bool tables = false, bool levels = false, + bool sprops = false); void a68_dump_modes (MOID_T *m); void a68_dump_moif (MOIF_T *moif); From b1dcde565577e8ae1b6297e4a230f040e6aa6547 Mon Sep 17 00:00:00 2001 From: Andrea Pinski Date: Wed, 16 Sep 2026 00:01:13 -0700 Subject: [PATCH 223/584] phiopt: Better pre-vect heurstics for factoring out loads [PR125945] Currently we reject most commonalization of loads in factor_out_conditional_load before the vectorizer. This was done as the easiest and simpliest herustics at the time I was writing the code. We can do better than that. This inproves the heurstics by allowing pointers which don't analyize via scalar evolution. This means loads which are from other loads can be factored out earlier than the loop optimizers. This changes 2 testcases which are now factored out in phiopt2 and one testcase where we don't want the factoring out before the vectorizer as we want to be able to vectorize the code (derived from eembc's telecom/viterb00data_1 benchmark). Bootstrapped and tested on x86_64-linux-gnu. PR tree-optimization/125945 gcc/ChangeLog: * tree-ssa-phiopt.cc (induction_based): New function. (factor_out_conditional_load): Allow some factoring out with early and/or before_vect. (factor_out_all): Set before_vect to false when not vectorizing. (pass_phiopt::execute): Initialize scev in some cases. gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/scc-diamond-1.c: Update to look at phiopt2 rather than phiopt4. * gcc.dg/tree-ssa/scc-diamond-3.c: Likewise. * gcc.dg/tree-ssa/factor_op_phi-load-vect-1.c: New test. Signed-off-by: Andrea Pinski --- .../tree-ssa/factor_op_phi-load-vect-1.c | 64 ++++++++++++++++++ gcc/testsuite/gcc.dg/tree-ssa/scc-diamond-1.c | 4 +- gcc/testsuite/gcc.dg/tree-ssa/scc-diamond-3.c | 4 +- gcc/tree-ssa-phiopt.cc | 66 ++++++++++++++++--- 4 files changed, 124 insertions(+), 14 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/factor_op_phi-load-vect-1.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/factor_op_phi-load-vect-1.c b/gcc/testsuite/gcc.dg/tree-ssa/factor_op_phi-load-vect-1.c new file mode 100644 index 000000000000..c26ea907f2e1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/factor_op_phi-load-vect-1.c @@ -0,0 +1,64 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fstrict-aliasing -fdump-tree-phiopt-details" } */ +/* PR tree-optimization/125945 */ +/* These factoring out of loads should happen only after the vectorizer for this code. */ +typedef short s16; +struct S { s16 tag; s16 key; }; +void f(s16 *dst, const struct S *a, const struct S *b, int n) +{ + for (int i = 0; i < n; i++) { + s16 ka = a[i].key; + s16 kb = b[i].key; + if (ka >= kb) + dst[i] = a[i].tag; + else + dst[i] = b[i].tag; + } +} +void f1(s16 *dst, const struct S *a, const struct S *b, int n) +{ + for (int i = 0; i < n; i++) { + s16 ka = a[i].key; + s16 kb = b[i].key; + s16 t; + if (ka >= kb) + t = a[i].tag; + else + t = b[i].tag; + dst[i] = t; + } +} +void f2(s16 *dst, const struct S *a, const struct S *b, int n) +{ + for (int i = 0; i < n; i++) { + s16 ka = a[i].key; + s16 kb = b[i].key; + s16 t; + const struct S *tt = &a[i]; + const struct S *tt1 = &b[i]; + if (ka >= kb) + t = tt->tag; + else + t = tt1->tag; + dst[i] = t; + } +} +void f3(s16 *dst, const struct S *a, const struct S *b, int n) +{ + for (int i = 0; i < n; i++) { + s16 ka = a[i].key; + s16 kb = b[i].key; + s16 t; + const s16 *tt = &a[i].tag; + const s16 *tt1 = &b[i].tag; + if (ka >= kb) + t = *tt; + else + t = *tt1; + dst[i] = t; + } +} + +/* { dg-final { scan-tree-dump-not "changed to factor out load from" "phiopt3" } } */ +/* { dg-final { scan-tree-dump-not "changed to factor out load from" "phiopt2" } } */ +/* { dg-final { scan-tree-dump-times "changed to factor out load from" 4 "phiopt4" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/scc-diamond-1.c b/gcc/testsuite/gcc.dg/tree-ssa/scc-diamond-1.c index de4f003bcf31..f6206273d141 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/scc-diamond-1.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/scc-diamond-1.c @@ -35,6 +35,6 @@ advance (const uint8_t *ip, size_t tag, const uint8_t *end) } /* The diamond is if-converted (branchless): one selected-offset load remains. */ -/* { dg-final { scan-tree-dump-times "changed to factor out load from" 1 "phiopt4" } } */ -/* { dg-final { scan-tree-dump-times "changed to factor operation out from" 1 "phiopt4" } } */ +/* { dg-final { scan-tree-dump-times "changed to factor out load from" 1 "phiopt2" } } */ +/* { dg-final { scan-tree-dump-times "changed to factor operation out from" 1 "phiopt2" } } */ /* { dg-final { scan-tree-dump-times "changed to factor operation out from" 2 "phiopt1" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/scc-diamond-3.c b/gcc/testsuite/gcc.dg/tree-ssa/scc-diamond-3.c index 8f9f6a4deada..00c8dd278bc1 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/scc-diamond-3.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/scc-diamond-3.c @@ -46,6 +46,6 @@ advance (const uint8_t *ip, size_t tag, const uint8_t *end) /* The mismatched alias types are merged to the alias-everything type, so the loads are commoned and the diamond is if-converted. */ -/* { dg-final { scan-tree-dump-times "changed to factor out load from" 1 "phiopt4" } } */ -/* { dg-final { scan-tree-dump-times "changed to factor operation out from" 1 "phiopt4" } } */ +/* { dg-final { scan-tree-dump-times "changed to factor out load from" 1 "phiopt2" } } */ +/* { dg-final { scan-tree-dump-times "changed to factor operation out from" 1 "phiopt2" } } */ /* { dg-final { scan-tree-dump-times "changed to factor operation out from" 2 "phiopt1" } } */ diff --git a/gcc/tree-ssa-phiopt.cc b/gcc/tree-ssa-phiopt.cc index fbb4ec545e6f..84a7949583d6 100644 --- a/gcc/tree-ssa-phiopt.cc +++ b/gcc/tree-ssa-phiopt.cc @@ -4063,6 +4063,22 @@ cond_if_else_store_replacement (basic_block then_bb, basic_block else_bb, return ok; } +/* Returns true when P is based on an induction variable + inside MERGE's inner most loop. */ +static bool +induction_based (tree p, basic_block merge) +{ + if (TREE_CODE (p) != SSA_NAME) + return false; + tree ev = analyze_scalar_evolution (merge->loop_father, p); + if (chrec_contains_undetermined (ev) + || chrec_contains_symbols_defined_in_loop (ev, merge->loop_father->num)) + return false; + if (tree_does_not_contain_chrecs (ev)) + return false; + return true; +} + /* If PHI at MERGE is a "load PHI", PHI <*P, *Q> whose two arguments are single-use, non-volatile scalar MEM_REF loads reading the same memory state (same VUSE), factor the load out: introduce P' = PHI and a single @@ -4078,15 +4094,6 @@ static bool factor_out_conditional_load (edge e0, edge e1, basic_block merge, gphi *phi, bool early_p, bool before_vect) { - /* Factoring out a load during the first phi means we can't - trust if this is inside a loop or not; due to before inlining. */ - if (early_p) - return false; - - /* Before vectorization, we don't want to factor out loads unless not inside a loop. */ - if (before_vect && bb_loop_depth (merge) != 0) - return false; - /* Not a virtual operand. */ if (virtual_operand_p (gimple_phi_result (phi)) /* can only handle the merge bb having 2 predecessors. */ @@ -4204,6 +4211,23 @@ factor_out_conditional_load (edge e0, edge e1, basic_block merge, gphi *phi, gimple_stmt_iterator gsi; gsi = gsi_after_labels (merge); + // factoring of the same pointer should be allowed + // irrespect to loops. + if (p0 == p1 && operand_equal_p (index0, index1)) + ; + // Before inlining, we can't tell if different + // pointers are going to be induction variable based + // or not. + else if (early_p) + return false; + // Before vectorization, don't factor out + // pointers which are based on induction variables. + else if (before_vect + && bb_loop_depth (merge) != 0 + && (induction_based (p0, merge) + || induction_based (p1, merge))) + return false; + /* Try to handle different indices. */ if (operand_equal_p (index0, index1)) newindex = fold_convert (atype, index0); @@ -4354,6 +4378,11 @@ factor_out_all (edge e1, edge e2, basic_block merge, { bool changed = false; bool do_over; + bool before_vect = !fold_before_rtl_expansion_p (); + // If vectorization is disable, then we are never before the vectorizer. + if (!flag_tree_loop_vectorize + && !merge->loop_father->force_vectorize) + before_vect = false; basic_block bb1 = e1->src; basic_block bb2 = e2->src; do @@ -4385,7 +4414,7 @@ factor_out_all (edge e1, edge e2, basic_block merge, /* Conditional load elimination can only be on a diamond. */ if ((diamond_p && factor_out_conditional_load (e1, e2, merge, phi, early_p, - !fold_before_rtl_expansion_p ())) + before_vect)) || factor_out_conditional_operation (e1, e2, merge, phi, cond_stmt, early_p)) { @@ -4973,6 +5002,18 @@ pass_phiopt::execute (function *) { bool do_hoist_loads = !early_p ? gate_hoist_loads () : false; bool cfgchanged = false; + bool need_loop_finalize = false; + + if (!early_p + && !fold_before_rtl_expansion_p () + && (flag_tree_loop_vectorize + || cfun->has_force_vectorize_loops) + && number_of_loops (cfun) > 1) + { + loop_optimizer_init (LOOPS_NORMAL); + scev_initialize (); + need_loop_finalize = true; + } calculate_dominance_info (CDI_DOMINATORS); mark_ssa_maybe_undefs (); @@ -5063,6 +5104,11 @@ pass_phiopt::execute (function *) execute_over_cond_phis (phiopt_exec); + if (need_loop_finalize) + { + loop_optimizer_finalize (); + scev_finalize (); + } if (replicate_conds_over_phis ()) { free_dominance_info (CDI_DOMINATORS); From 8c93f20be26ebbf04041dc40d667949d2e0d5c8c Mon Sep 17 00:00:00 2001 From: GCC Administrator Date: Sat, 19 Sep 2026 00:16:44 +0000 Subject: [PATCH 224/584] Daily bump. --- contrib/ChangeLog | 14 ++++ gcc/ChangeLog | 162 ++++++++++++++++++++++++++++++++++++++ gcc/DATESTAMP | 2 +- gcc/algol68/ChangeLog | 36 +++++++++ gcc/c-family/ChangeLog | 4 + gcc/cobol/ChangeLog | 77 ++++++++++++++++++ gcc/fortran/ChangeLog | 7 ++ gcc/testsuite/ChangeLog | 168 ++++++++++++++++++++++++++++++++++++++++ libcpp/ChangeLog | 11 +++ libgcobol/ChangeLog | 74 ++++++++++++++++++ libstdc++-v3/ChangeLog | 10 +++ 11 files changed, 564 insertions(+), 1 deletion(-) diff --git a/contrib/ChangeLog b/contrib/ChangeLog index 06b808611afa..59d6c14f1b82 100644 --- a/contrib/ChangeLog +++ b/contrib/ChangeLog @@ -1,3 +1,17 @@ +2026-09-18 Jakub Jelinek + + * unicode/README: Replace Unicode 17 version with 18. + * unicode/gen_libstdcxx_unicode_data.py: Use 180000 instead of + 160000 in _GLIBCXX_GET_UNICODE_DATA test. + * unicode/DerivedCoreProperties.txt: Updated from Unicode 18.0. + * unicode/emoji-data.txt: Likewise. + * unicode/PropList.txt: Likewise. + * unicode/HangulSyllableType.txt: Likewise. + * unicode/DerivedNormalizationProps.txt: Likewise. + * unicode/NameAliases.txt: Likewise. + * unicode/UnicodeData.txt: Likewise. + * unicode/EastAsianWidth.txt: Likewise. + 2026-09-15 Kyrylo Tkachov * filter-clang-warnings.py (skip_warning): Match numbered attribute diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 2c1213ac1723..469fe772ff7d 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,165 @@ +2026-09-18 Andrea Pinski + + PR tree-optimization/125945 + * tree-ssa-phiopt.cc (induction_based): New function. + (factor_out_conditional_load): Allow some factoring out + with early and/or before_vect. + (factor_out_all): Set before_vect to false when not vectorizing. + (pass_phiopt::execute): Initialize scev in some cases. + +2026-09-18 Michiel Derhaeg + + * config/riscv/riscv.cc (synthesize_add): Do not form shNadd + when the base register is a virtual register. + +2026-09-18 Zhongyao Chen + + PR rtl-optimization/127367 + * ext-dce.cc: Include regs.h. + (ext_dce_process_uses): Handle multi-register hard regs. + +2026-09-18 Bohan Lei + + * config/riscv/riscv-vector-costs.cc (costs::better_main_loop_than_p): + Compare VLA costs under -mrvv-max-lmul=dynamic. + +2026-09-18 Richard Ball + + * config/aarch64/aarch64-builtins.cc + (enum aarch64_builtins): Add new builtins. + (aarch64_init_atomic_hints_builtins): Likewise. + (aarch64_expand_atomic_hints_builtins_fetch): Handle Fetch intrinsics. + (aarch64_general_expand_builtin): Add call for new builtins. + (aarch64_resolve_overloaded_builtin_atomic_hint_fetch): Handle Fetch intrinsics. + (aarch64_resolve_overloaded_builtin_general): Add new call. + * config/aarch64/arm_acle.h + (enum atomic_fetch): Store different Fetch types. + (__arm_atomic_fetch_add_with_hint): Add new builtin. + (__arm_atomic_fetch_sub_with_hint): Likewise. + (__arm_atomic_fetch_and_with_hint): Likewise. + (__arm_atomic_fetch_xor_with_hint): Likewise. + (__arm_atomic_fetch_or_with_hint): Likewise. + * config/aarch64/atomics.md + (aarch64_atomic_fetch__atomic_hint): New pattern for atomic_fetch. + (@aarch64_atomic_hints_fetch): Likewise. + * config/aarch64/iterators.md: New unspecs. + +2026-09-18 Richard Ball + + * config/aarch64/aarch64-builtins.cc + (enum aarch64_builtins): Change Function/Builtin names. + (aarch64_init_pcdphint_builtins): Likewise. + (aarch64_init_atomic_hints_builtins): Likewise. + (aarch64_general_init_builtins): Likewise. + (aarch64_expand_stshh_builtin): Likewise. + (aarch64_expand_atomic_hints_builtins): Likewise. + (aarch64_general_expand_builtin): Likewise. + (aarch64_resolve_overloaded_builtin_stshh): Likewise. + (aarch64_resolve_overloaded_builtin_atomic_hint_store): Likewise + (aarch64_resolve_overloaded_builtin_general): Likewise. + * config/aarch64/arm_acle.h + (__atomic_store_with_stshh): Likewise. + (__arm_atomic_store_with_hint): Likewise. + * config/aarch64/atomics.md + (@aarch64_atomic_store_stshh): Add new hints to pattern + (@aarch64_atomic_hints_store): Likewise. + * config/aarch64/iterators.md: Add Unspec for new hints. + +2026-09-18 Richard Biener + + * tree-vect-slp.cc (vect_build_slp_tree): Assert successful + discovered nodes do not require splitting. + +2026-09-18 Richard Biener + + PR tree-optimization/127473 + * tree-vect-slp.cc (vect_build_slp_tree_3): Duplicate the BB + case of rejecting a not grouped load early to avoid assiging + the first_match to it. + +2026-09-18 Andrew Stubbs + + * config/gcn/gcn-valu.md (mov_exec): Add xnack alternatives. + (@mov_sgprbase): Likewise. + +2026-09-18 Richard Biener + + PR tree-optimization/127468 + * tree-vect-slp.cc (vect_build_slp_tree_3): Print the correct + trapping stmt. + +2026-09-18 Léo Hardt + + * asan.cc: Remove include that already came from ssa.h. + * gimple-ssa-pta-constraints.cc: Remove unused include. + * tree-ssa-loop-unswitch.cc: Likewise. + * ubsan.cc: Change an include to a more specific file. + * value-query.cc: Remove unused import. + * value-range-storage.cc: Likewise. + * value-range.cc: Change an include to a more specific file. + +2026-09-18 Kael Andrew Alonzo Franco + + PR tree-optimization/127406 + * match.pd: Restrict (X {+,-} M*N) / N optimization. + +2026-09-18 Alfie Richards + + * machmode.h (parse_machine_mode): New function. + * read-rtl.cc (find_mode): Use parse_machine_mode. + * config/riscv/riscv-v.cc (autovectorize_vector_modes): Likewise. + +2026-09-18 Jakub Jelinek + Manjunath Matti + + PR middle-end/127378 + * gimple-lower-bitint.cc (bitint_large_huge::lower_mergeable_stmt): On + big endian, compare idx_next in separate_ext loop against + bo_idx + total - 1 - end, and if that wraps around, compare idx + against 0 instead. + +2026-09-18 Richard Biener + + PR tree-optimization/126306 + * tree-vect-slp.cc (vect_build_slp_tree_1): Remove soft-failing. + (vect_build_slp_tree_2): Add soft-failing here, delayed + to after vect_get_and_check_slp_defs. + (vect_get_and_check_slp_defs): When we'll soft-fail do not + fall back to vect_external_def on mismatches. + +2026-09-18 Pan Li + + * config/riscv/constraints.md (Wn3): New constraint for the + vector register which doesn't overlap the register group of + the operand 3. + * config/riscv/riscv-protos.h (riscv_v_widen_non_overlap_constraint_ok): + New function declaration. + * config/riscv/riscv-v.cc (riscv_v_reg_group_overlap_p): New + function to tell if two vector register groups overlap. + (riscv_v_widen_constraint_ok): Leverage the above function for + the register group overlap check. + (riscv_v_widen_non_overlap_constraint_ok): New function to tell + if the register doesn't overlap the reference register group. + * config/riscv/vector.md: Take the Wn3 constraint for the + operand 4 of the widening integer reduction. + +2026-09-18 Yongqiang Tian + + PR rtl-optimization/127421 + * reorg.cc (redundant_insn): Use NONDEBUG_INSN_P in both bounded + backward walks. Remove redundant debug-instruction checks. + +2026-09-18 Yongqiang Tian + + PR rtl-optimization/127422 + * combine.cc (can_combine_p): Ignore debug instructions when scanning + for intervening volatile references. + +2026-09-18 Xi Ruoyao + + * config/loongarch/loongarch.md (bitreverseqi2): Disable on + LA32R. + 2026-09-17 Andrew MacLeod * value-relation.cc (dom_oracle::query): Prefer a normal diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index 215e40c73af3..35f33f31d1bf 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20260918 +20260919 diff --git a/gcc/algol68/ChangeLog b/gcc/algol68/ChangeLog index 25b7607febdb..7f546983a366 100644 --- a/gcc/algol68/ChangeLog +++ b/gcc/algol68/ChangeLog @@ -1,3 +1,39 @@ +2026-09-18 Jose E. Marchesi + + * a68.h: Add prototypes for a68_sprops, a68_yields_value and + a68_is_declaration. + * a68-types.h (a68_access): New type. + (a68_kindo): Likewise. + (ORIGIN_T): Likewise. + (ACCESS_T): Likewise. + (NODE_T): Add fields origin and access. + (TAG_T): Likewise. + (ACCESS_NIHIL): Remove. + (ACCESS_CONSTANT): Likewise. + (ACCESS_DIRIDEN): Likewise. + (ACCESS_INDIDEN): Likewise. + (ACCESS_DIRWOST): Likewise. + (DEFLEX): Likewise. + (FLEXO): Likewise. + (BNO): Define. + (DEFLEX): Likewise. + (DIAGO): Likewise. + * a68-parser-sprops.cc: New file. + * a68-parser-attrs.def: New comment. + * a68-parser-bottom-up.cc (reduce_enquiry_clauses): Add a few + comments to improve readability. + * a68-parser.cc (a68_is_declaration): New function. + (a68_yields_value): Likewise. + (a68_parser): Run the sprops pass. + (a68_new_node): Initialize ORIGIN and ACCESS. + (a68_new_tag): Likewise, for tags. + * Make-lang.in (ALGOL68_OBJS): Build algol68/a68-parser-sprops.o. + * a68-parser-debug.cc (a68_dump_parse_tree_1): Show static + properties whenever requested. + * a68-low-clauses.cc: Fix grammar for initialiser series and + closed clause in comments. + * a68-low.cc (a68_low_assignation): Fix comment. + 2026-09-16 Pietro Monteiro * a68-parser.cc (a68_get_node_location): Return a location diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog index 59575b2accb5..9f39aef89187 100644 --- a/gcc/c-family/ChangeLog +++ b/gcc/c-family/ChangeLog @@ -1,3 +1,7 @@ +2026-09-18 Alfie Richards + + * c-attribs.cc (handle_mode_attribute): Use parse_machine_mode. + 2026-09-10 Jakub Jelinek P3726R2 diff --git a/gcc/cobol/ChangeLog b/gcc/cobol/ChangeLog index fbaacaa14a55..2caca01f8657 100644 --- a/gcc/cobol/ChangeLog +++ b/gcc/cobol/ChangeLog @@ -1,3 +1,80 @@ +2026-09-18 Robert Dubner + + * gcobol.1: Documentation for the .so search. + * move.cc: Fix typo. + * parse.y: Data capacity test. + * symbols.cc (expand_picture): Fix off-by-one error; handle corner + case where 'B' is the final character of a numeric-edited PICTURE + string. + * symbols.h: Remove unnecessary test. + +2026-09-18 Xavier Del Campo Romero + + * cobol1.cc (libcompat_copybook): Remove "udf" from the search list. + +2026-09-18 Xavier Del Campo Romero + + * cdf-copy.cc (copybook_elem_t::open_file): Do not error out on failure. + +2026-09-18 Xavier Del Campo Romero + + * parse.y: Reapply. + * symbols.h: Likewise. + +2026-09-18 Xavier Del Campo Romero + + * parse.y: Replace redundant passby_str with cbl_ffi_crv_str. + +2026-09-18 Xavier Del Campo Romero + + * parse.y: Accept arbitrarily-sized PIC X for ANY LENGTH. + +2026-09-18 Xavier Del Campo Romero + + * parse.y: Set loc for numeric literals BY VALUE. + +2026-09-18 Xavier Del Campo Romero + + * parse.y: Show location for invalid arg in CALL. + +2026-09-18 Xavier Del Campo Romero + + * parse.y: Set loc also for numeric literals BY REFERENCE. + +2026-09-18 Xavier Del Campo Romero + + * parse.y: Fix undefined loc for CALL args. + +2026-09-18 Xavier Del Campo Romero + + * parse_ante.h (by_content_ok): Use temporary symbol location. + +2026-09-18 Xavier Del Campo Romero + + * cdf-copy.cc (copybook_elem_t::open_file): Use %qs. + +2026-09-18 Xavier Del Campo Romero + + * cdf-copy.cc (copybook_elem_t::open_file): Use fstat(2). + +2026-09-18 Xavier Del Campo Romero + + * parse.y: Fix wrong diagnostic on numeric literals. + +2026-09-18 Xavier Del Campo Romero + + * parse.y: Print passing method on error. + +2026-09-18 Xavier Del Campo Romero + + PR cobol/127074 + * scan_post.h (datetime_format_of): Remove trailing pipe. + +2026-09-18 Xavier Del Campo Romero + + * parse.y: Revert. + * symbols.h: Likewise. + 2026-09-17 Robert Dubner * genapi.cc (actually_create_the_static_field): Use expanded PICTURE diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog index 6414556af7c2..428e94186a12 100644 --- a/gcc/fortran/ChangeLog +++ b/gcc/fortran/ChangeLog @@ -1,3 +1,10 @@ +2026-09-18 Paul Thomas + + PR fortran/127146 + * primary.cc (gfc_match_rvalue): At two points: if the entry in + the parameter list has a name, use that in preference to the + component name. + 2026-09-17 Paul Thomas PR fortran/125690 diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 1905d5e6eb0e..bf4607722821 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,171 @@ +2026-09-18 Andrea Pinski + + PR tree-optimization/125945 + * gcc.dg/tree-ssa/scc-diamond-1.c: Update to look at phiopt2 + rather than phiopt4. + * gcc.dg/tree-ssa/scc-diamond-3.c: Likewise. + * gcc.dg/tree-ssa/factor_op_phi-load-vect-1.c: New test. + +2026-09-18 Michiel Derhaeg + + * gcc.target/riscv/zba-shNadd-11.c: New test. + +2026-09-18 Zhongyao Chen + + PR rtl-optimization/127367 + * gcc.dg/torture/pr127367.c: New test. + +2026-09-18 Bohan Lei + + * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul-mixed-1.c: Update + expectation. + * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-1.c: Ditto. + * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-2.c: Ditto. + * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-3.c: Ditto. + * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-4.c: Ditto. + * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-5.c: Ditto. + * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-6.c: Ditto. + * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul1-7.c: Ditto. + * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-1.c: Ditto. + * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-3.c: Ditto. + * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-4.c: Ditto. + * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-5.c: Ditto. + * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul2-6.c: Ditto. + * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-6.c: Ditto. + * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-12.c: Ditto. + * gcc.dg/vect/costmodel/riscv/rvv/pr111848.c: Ditto. + * gcc.target/riscv/rvv/autovec/partial/slp-16.c: Ditto. + * gcc.target/riscv/rvv/autovec/sat/vec_sat_u_sub_zip.c: Ditto. + +2026-09-18 Michiel Derhaeg + + * gcc.dg/tree-ssa/predcom-10.c: Pass in expected value + explicitly instead of deriving it from argc. + +2026-09-18 Robert Dubner + + PR cobol/127412 + * cobol.dg/group2/CBL_DELETE_FILE.cob: Minor logic change. + * cobol.dg/group2/CBL_DELETE_FILE.out: Likewise. + * cobol.dg/group2/CBL_OPEN_FILE___CBL_CLOSE_FILE.cob: Likewise. + * cobol.dg/group2/CBL_OPEN_FILE___CBL_CLOSE_FILE.out: Likewise. + * cobol.dg/group2/CBL_READ_FILE__check_file_size_with_flags___128.cob: + Likewise. + * cobol.dg/group2/CDF_Feature_.cob: Switch to "ibm1140". + * cobol.dg/group2/CHAR_and_ORD_with_COLLATING_sequence_-_EBCDIC.cob: + Likewise. + * cobol.dg/group2/FIND-STRING__forward_.cob: Likewise. + * cobol.dg/group2/FIND-STRING__reverse_.cob: Likewise. + * cobol.dg/group2/FUNCTION_CONVERT.cob: Likewise. + * cobol.dg/group2/CBL_CHECK_FILE_EXIST__known_timestamp_.cob: New test. + * cobol.dg/group2/MF__identifier_as_PIC_X_ANY_LENGTH.cob: New test. + +2026-09-18 Richard Ball + + * gcc.target/aarch64/atomic_fetch_add_with_shuh.c: New test. + * gcc.target/aarch64/atomic_fetch_and_with_shuh.c: New test. + * gcc.target/aarch64/atomic_fetch_or_with_shuh.c: New test. + * gcc.target/aarch64/atomic_fetch_sub_with_shuh.c: New test. + * gcc.target/aarch64/atomic_fetch_xor_with_shuh.c: New test. + +2026-09-18 Richard Ball + + * g++.target/aarch64/atomic_store_with_stshh.C: Change Function name. + * gcc.target/aarch64/atomic_store_with_stshh.c: Likewise. + * gcc.target/aarch64/atomic_store_with_shuh.c: New test. + * gcc.target/aarch64/atomic_store_with_stcph.c: New test. + +2026-09-18 John David Anglin + + * gcc.dg/analyzer/atoi-1.c: Skip atoll hunk on hpux. + * gcc.dg/analyzer/fd-mktemp-family.c: Skip on hpux. + * gcc.dg/analyzer/mkdtemp-1.c: Likewise. + * gcc.dg/analyzer/mkostemp-1.c: Likewise. + * gcc.dg/analyzer/mkostemps-1.c: Likewise. + * gcc.dg/analyzer/mkstemps-1.c: Likewise. + +2026-09-18 Paul Thomas + + PR fortran/127146 + * gfortran.dg/pdt_96.f03: New test. + +2026-09-18 Kael Andrew Alonzo Franco + + PR tree-optimization/127406 + * gcc.dg/torture/pr127406.c: New test. + +2026-09-18 Jakub Jelinek + + * gcc.dg/bitint-142.c (main): Don't set z to ~0, instead memset + it to ~0. + +2026-09-18 Jakub Jelinek + + * g++.dg/cpp29/std-floating1.C: Add 2 dg-bogus directives xfailed + for long_double_is_ibm128 effective targets. + +2026-09-18 Jakub Jelinek + Manjunath Matti + + PR middle-end/127378 + * gcc.dg/bitint-145.c: New test. + +2026-09-18 Richard Biener + + PR tree-optimization/126306 + * gcc.dg/vect/bb-slp-pr126306-1.c: New testcase. + +2026-09-18 Jakub Jelinek + + * c-c++-common/cpp/named-universal-char-escape-1.c: Add tests + for some Unicode 18.0 characters, both normal and generated. + +2026-09-18 Pan Li + + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m1.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m2.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m4.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u16-m8.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m1.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m2.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m4.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u32-m8.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m1.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m2.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m4.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsumu_vs-u8-m8.c: New test. + +2026-09-18 Pan Li + + * gcc.target/riscv/rvv/autovec/group_overlap/group_overlap.h: + Add test helper macros. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m1.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m2.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m4.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i16-m8.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m1.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m2.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m4.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i32-m8.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m1.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m2.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m4.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vwredsum_vs-i8-m8.c: New test. + +2026-09-18 Yongqiang Tian + + PR rtl-optimization/127421 + * gcc.target/sparc/pr127421.c: New test. + +2026-09-18 Yongqiang Tian + + PR rtl-optimization/127422 + * gcc.dg/pr127422.c: New test. + +2026-09-18 Xi Ruoyao + + * gcc.target/loongarch/bitreverse-la32r.c: New test. + 2026-09-17 Andrew MacLeod * gcc.dg/tree-ssa/vrp-rel3.c: New. diff --git a/libcpp/ChangeLog b/libcpp/ChangeLog index 2cad336b1e3e..abca2c09a0e7 100644 --- a/libcpp/ChangeLog +++ b/libcpp/ChangeLog @@ -1,3 +1,14 @@ +2026-09-18 Jakub Jelinek + + * makeucnid.cc (write_copyright): Update Unicode Copyright years. + * makeuname2c.cc (generated_ranges): Adjust Unicode version from 17.0 + to 18.0. Add JURCHEN CHARACTER- and SMALL SEAL CHARACTER- generated + ranges, adjust indexes in following entries. + (write_copyright): Update Unicode Copyright years. + * generated_cpp_wcwidth.h: Regenerated. + * ucnid.h: Regenerated. + * uname2c.h: Regenerated. + 2026-09-02 Wilco Dijkstra * lex.cc (search_line_fast): Optimized Arm implementation. diff --git a/libgcobol/ChangeLog b/libgcobol/ChangeLog index 7f448d0b60fb..9a28f34f0116 100644 --- a/libgcobol/ChangeLog +++ b/libgcobol/ChangeLog @@ -1,3 +1,77 @@ +2026-09-18 Robert Dubner + + * libgcobol.cc (do_the_dl_thing): New .so policy. + (find_in_dirs): Likewise. + (__gg__function_handle_from_cobpath): Likewise. + +2026-09-18 Xavier Del Campo Romero + + PR cobol/126633 + * Makefile.am: Replace udf with lib. + * Makefile.in: Likewise. + * compat/gnu/udf/cobrt-file-status.cbl: Move to... + * compat/gnu/lib/cobrt-file-status.cbl: ...here. + * compat/gnu/udf/stored-char-length.cbl: Move to... + * compat/gnu/lib/stored-char-length.cbl: ...here. + +2026-09-18 Xavier Del Campo Romero + + * Makefile.am: Add CBL_GET_PROGRAM_INFO.cbl and cbl_gpi.cc. + * Makefile.in: Likewise. + * compat/gnu/cpy/cblproto.cpy: Add CBL_GET_PROGRAM_INFO. + * compat/gnu/cpy/cbltypes.cpy: Add cblt-prog-info-params. + * compat/gnu/lib/CBL_GET_PROGRAM_INFO.cbl: New file. + * compat/gnu/lib/cbl_get_program_info.3: New file. + * compat/gnu/lib/cbl_gpi.cc: New file. + +2026-09-18 Xavier Del Campo Romero + + * libgcobol.cc (__gg__get_module_names): New function. + +2026-09-18 Xavier Del Campo Romero + + * Makefile.in: Update with autoreconf2.69. + +2026-09-18 Xavier Del Campo Romero + + * compat/gnu/lib/CBL_CHECK_FILE_EXIST.cbl: Use st_mtime. + +2026-09-18 Xavier Del Campo Romero + + * compat/gnu/lib/CBL_CHECK_FILE_EXIST.cbl: Add 1 to + cblte-fe-month. + +2026-09-18 Xavier Del Campo Romero + + * compat/gnu/lib/CBL_CREATE_FILE.cbl: Do not null-terminate + original string. + +2026-09-18 Xavier Del Campo Romero + + * compat/gnu/cpy/cblproto.cpy: Use RETURN-CODE. + * compat/gnu/lib/CBL_CLOSE_FILE.cbl: Likewise. + * compat/gnu/lib/CBL_CREATE_FILE.cbl: Likewise. + * compat/gnu/lib/CBL_OPEN_FILE.cbl: Likewise. + * compat/gnu/lib/CBL_READ_FILE.cbl: Likewise. + * compat/gnu/lib/CBL_WRITE_FILE.cbl: Likewise. + * compat/gnu/lib/cbl_close_file.3: Document use of RETURN-CODE. + * compat/gnu/lib/cbl_create_file.3: Likewise. + * compat/gnu/lib/cbl_open_file.3: Likewise. + * compat/gnu/lib/cbl_read_file.3: Likewise. + * compat/gnu/lib/cbl_write_file.3: Likewise. + +2026-09-18 Xavier Del Campo Romero + + * compat/gnu/lib/CBL_OPEN_FILE.cbl: Revert. + +2026-09-18 Xavier Del Campo Romero + + * compat/gnu/lib/CBL_CREATE_FILE.cbl: Likewise. + +2026-09-18 Xavier Del Campo Romero + + * Makefile.am: Add missing posix-close.cpy + 2026-09-17 Robert Dubner * gmath.cc (__gg__int128_to_int128_rounded): Change error handling. diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index edc243d51f8b..1730495eda32 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,13 @@ +2026-09-18 Jakub Jelinek + + * include/bits/unicode.h (std::__unicode::__v16_0_0): Rename inline + namespace to ... + (std::__unicode::__v18_0_0): ... this. + (_GLIBCXX_GET_UNICODE_DATA): Change from 160000 to 180000. + * testsuite/ext/unicode/properties.cc: Expect 2 rather than 1 for + uc::__field_width(U'\U0001FAF9'). + * include/bits/unicode-data.h: Regenerated. + 2026-09-17 Jonathan Wakely * testsuite/lib/libstdc++.exp (v3_check_preprocessor_condition): From b3500de28d2c73219c04a13e968f94f887b0b536 Mon Sep 17 00:00:00 2001 From: "Jose E. Marchesi" Date: Sat, 19 Sep 2026 11:54:20 +0200 Subject: [PATCH 225/584] a68: fix comment in a68-parser-scope.cc The scope pass is no longer the last pass in the parser. Signed-off-by: Jose E. Marchesi gcc/algol68/ChangeLog * a68-parser-scope.cc: Do not claim the scope pass finishes the parser. --- gcc/algol68/a68-parser-scope.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/algol68/a68-parser-scope.cc b/gcc/algol68/a68-parser-scope.cc index bf7ab10361c8..3e1048358c55 100644 --- a/gcc/algol68/a68-parser-scope.cc +++ b/gcc/algol68/a68-parser-scope.cc @@ -20,7 +20,7 @@ . */ /* A static scope checker inspects the source. Note that ALGOL 68 also needs - dynamic scope checking. This phase concludes the parser. */ + dynamic scope checking. */ #include "config.h" #include "system.h" From eb65d86356c09223c960abce7603d92ec7944c27 Mon Sep 17 00:00:00 2001 From: "Jose E. Marchesi" Date: Sat, 19 Sep 2026 13:07:15 +0200 Subject: [PATCH 226/584] a68: clarify roles of SCOPE, SCOPE_ASSIGNED and LEVEL in tags Signed-off-by: Jose E. Marchesi gcc/algol68/ChangeLog * a68-types.h: Clarify roles of field set by the scope checker in TAG_T. --- gcc/algol68/a68-types.h | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/gcc/algol68/a68-types.h b/gcc/algol68/a68-types.h index e34817cd1232..ebe74ca8a801 100644 --- a/gcc/algol68/a68-types.h +++ b/gcc/algol68/a68-types.h @@ -569,12 +569,20 @@ struct GTY(()) TABLE_T NODE is the defining identifier associated to the declaration. - SCOPE is the lexical depth of the tag. Zero corresponds to the primal - scope. It is set by the static scope checker. + SCOPE is the lexical depth of the scope of the value ascribed to the tag. + Zero corresponds to the primal scope. Only valid when SCOPE_ASSIGNED is + set. This field is set by the static scope checker. SCOPE_ASSIGNED determines whether a SCOPE has been actually assigned to the - tag. It is set by the static scope checker. The entities which get - assigned scopes are identities of format texts and routine texts. + tag. This field is set by the static scope checker. + + YOUNGEST_ENVIRON is used when NODE is either a ROUTINE_TEXT or a + FORMAT_TEXT, and contains the youngest (higher) lexical level of any object + directly declared in the routine or format body. This is filled in and used + by the scope checker. + + LEVEL is the lexical depth of the declaration in which tag was introduced. + It is set by the symbol table management. PORTABLE determines whether the construction associated with the tag is Algol 68 or some extension. @@ -605,11 +613,6 @@ struct GTY(()) TABLE_T These declarations are optimized in a similar way than variable declarations in order to avoid indirect addressing. - YOUNGEST_ENVIRON is used when NODE is either a ROUTINE_TEXT or a - FORMAT_TEXT, and contains the youngest (higher) lexical level of any object - directly declared in the routine or format body. This is filled in and used - by the scope checker. - TREE_DECL is the GENERIC declaration for the definition of this symbol. This is set and used by the lower pass. For mode indicants, it contains a function that generates a pointer to the given mode, and is used by From fbc365cc1e229254cd6173bbad6f67620fcacc66 Mon Sep 17 00:00:00 2001 From: "Jose E. Marchesi" Date: Sat, 19 Sep 2026 13:43:25 +0200 Subject: [PATCH 227/584] a68: fill in BNO static properties in the sprop pass Signed-off-by: Jose E. Marchesi gcc/algol68/ChangeLog * a68-parser-sprops.cc (sprops_for_deproceduring): Set BNO. (sprops_for_proceduring): Likewise. (sprops_for_loop_clause): Likewise. (sprops_for_serial_clause): Likewise. (sprops_for_parallel_clause): Likewise. (sprops_for_conditional_clause): Likewise. (sprops_for_case_clause): Likewise. (sprops_for_collateral_clause): Likewise. (sprops_for_conformity_clause): Likewise. (sprops_for_identity_relation): Likewise. (sprops_for_logical_function): Likewise. (sprops_for_call): Likewise. (sprops_for_generator): Likewise. (sprops_for_formula): Likewise. (sprops_for_assertion): Likewise. (sprops_for_decl): Likewise. (sprops_for_decl): Likewise. (sprops_for_unit): Likewise. --- gcc/algol68/a68-parser-sprops.cc | 55 +++++++++++++++++++------------- 1 file changed, 33 insertions(+), 22 deletions(-) diff --git a/gcc/algol68/a68-parser-sprops.cc b/gcc/algol68/a68-parser-sprops.cc index dc82ffd53937..e8a131625901 100644 --- a/gcc/algol68/a68-parser-sprops.cc +++ b/gcc/algol68/a68-parser-sprops.cc @@ -73,12 +73,21 @@ ─── Its meaning for a particular construct is to be interpreted along with its - kindo. For KINDO_IDE and KINDO_VAR, bno indicates the depth number of - the block where the identifier or the variable is declared. For - KINDO_GEN, when it corresponds to a local generator, bno indicates the - depth number of the block where the generator appears. For - KINDO_CONSTANT, and for KINDO_GEN when it corresponds to a heap generator, - bno is always zero. + kindo. + + ● For KINDO_IDE and KINDO_VAR, bno indicates the depth number of the block + where the identifier or the variable is declared. This is not to be + confused with the scope of the value ascribed to the identifier or + stored in the variable. + + ● For KINDO_GEN, when it corresponds to a local generator, bno indicates + the depth number of the block where the generator appears. + + ● For KINDO_CST, and for KINDO_GEN when it corresponds to a heap + generator, bno is always zero. + + ● For KINDO_NIL, bno indicates the depth number of the construct issuing + the value. derefo is the "flag dereferencing of the origin". ────── @@ -345,7 +354,7 @@ sprops_for_deproceduring (NODE_T *p) ORIGIN (p) = make_origin (); KINDO (p) = KINDO_NIL; DIAGO (p) = a68_get_node_location (p); - BNO (p) = 0; + BNO (p) = LEX_LEVEL (p); DEREFO (p) = false; ACCESS (p) = ACCESS_DIR; } @@ -362,7 +371,7 @@ sprops_for_proceduring (NODE_T *p) ORIGIN (p) = make_origin (); KINDO (p) = KINDO_NIL; DIAGO (p) = a68_get_node_location (p); - BNO (p) = 0; + BNO (p) = LEX_LEVEL (p); DEREFO (p) = false; ACCESS (p) = ACCESS_DIR; } @@ -408,7 +417,7 @@ sprops_for_loop_clause (NODE_T *p) ORIGIN (p) = make_origin (); KINDO (p) = KINDO_NIL; DIAGO (p) = a68_get_node_location (p); - BNO (p) = 0; + BNO (p) = LEX_LEVEL (p); DEREFO (p) = false; ACCESS (p) = ACCESS_NIL; } @@ -514,7 +523,7 @@ sprops_for_serial_clause (NODE_T *p) KINDO (p) = KINDO_NIL; DEREFO (p) = found_derefo; GENO (p) = found_geno; - BNO (p) = 0; + BNO (p) = LEX_LEVEL (p); } /* Balance access. */ @@ -536,7 +545,7 @@ sprops_for_parallel_clause (NODE_T *p) { ORIGIN (p) = make_origin (); KINDO (p) = KINDO_NIL; - BNO (p) = 0; + BNO (p) = LEX_LEVEL (p); DEREFO (p) = false; GENO (p) = false; ACCESS (p) = ACCESS_NIL; @@ -605,7 +614,7 @@ sprops_for_conditional_clause (NODE_T *p) KINDO (p) = KINDO_NIL; DEREFO (p) = found_derefo; GENO (p) = found_geno; - BNO (p) = 0; + BNO (p) = LEX_LEVEL (p); } /* Balance access. */ @@ -703,7 +712,7 @@ sprops_for_case_clause (NODE_T *p) KINDO (p) = KINDO_NIL; DEREFO (p) = found_derefo; GENO (p) = found_geno; - BNO (p) = 0; + BNO (p) = LEX_LEVEL (p); } /* Balance access. */ @@ -730,7 +739,7 @@ static void sprops_for_collateral_clause (NODE_T *p) { ORIGIN (p) = make_origin (); - BNO (p) = 0; + BNO (p) = LEX_LEVEL (p); GENO (p) = 0; DEREFO (p) = 0; @@ -839,7 +848,7 @@ sprops_for_conformity_clause (NODE_T *p) KINDO (p) = KINDO_NIL; DEREFO (p) = found_derefo; GENO (p) = found_geno; - BNO (p) = 0; + BNO (p) = LEX_LEVEL (p); } /* Balance access. */ @@ -860,7 +869,7 @@ sprops_for_identity_relation (NODE_T *p) { ORIGIN (p) = make_origin (); KINDO (p) = KINDO_NIL; - BNO (p) = 0; + BNO (p) = LEX_LEVEL (p); DEREFO (p) = false; GENO (p) = false; ACCESS (p) = ACCESS_DIR; @@ -933,7 +942,7 @@ sprops_for_logical_function (NODE_T *p) ORIGIN (p) = make_origin (); DIAGO (p) = a68_get_node_location (p); KINDO (p) = KINDO_NIL; - BNO (p) = 0; + BNO (p) = LEX_LEVEL (p); DEREFO (p) = false; ACCESS (p) = ACCESS_DIR; } @@ -965,7 +974,7 @@ sprops_for_call (NODE_T *p) ORIGIN (p) = make_origin (); DIAGO (p) = a68_get_node_location (p); KINDO (p) = KINDO_NIL; - BNO (p) = 0; + BNO (p) = LEX_LEVEL (p); DEREFO (p) = false; } @@ -984,7 +993,7 @@ sprops_for_generator (NODE_T *p) DEREFO (p) = false; if (IS (SUB (p), LOC_SYMBOL)) { - BNO (p) = 0; /* XXX */ + BNO (p) = LEX_LEVEL (p); GENO (p) = true; } else @@ -1033,7 +1042,7 @@ sprops_for_formula (NODE_T *p) DIAGO (p) = a68_get_node_location (p); KINDO (p) = KINDO_NIL; DEREFO (p) = 0; - BNO (p) = 0; + BNO (p) = LEX_LEVEL (p); GENO (p) = false; } } @@ -1070,7 +1079,7 @@ sprops_for_assertion (NODE_T *p) ORIGIN (p) = make_origin (); DIAGO (p) = a68_get_node_location (p); KINDO (p) = KINDO_NIL; - BNO (p) = 0; + BNO (p) = LEX_LEVEL (p); DEREFO (p) = false; ACCESS (p) = ACCESS_NIL; } @@ -1182,6 +1191,7 @@ sprops_for_decl (NODE_T *p) ORIGIN (tax) = make_origin (); DIAGO (tax) = a68_get_node_location (p); KINDO (tax) = KINDO_IDE; + BNO (tax) = LEX_LEVEL (defining_identifier); ACCESS (tax) = ACCESS_DIR; break; } @@ -1193,6 +1203,7 @@ sprops_for_decl (NODE_T *p) ORIGIN (tax) = make_origin (); DIAGO (tax) = a68_get_node_location (p); KINDO (tax) = KINDO_VAR; + BNO (tax) = LEX_LEVEL (defining_identifier); ACCESS (tax) = ACCESS_VAR; break; } @@ -1234,7 +1245,7 @@ sprops_for_unit (NODE_T *p) DIAGO (p) = a68_get_node_location (p); KINDO (p) = KINDO_NIL; DEREFO (p) = false; - BNO (p) = 0; + BNO (p) = LEX_LEVEL (p); ACCESS (p) = ACCESS_DIR; break; case DENOTATION: From b7e0a2cdd6a9376d6a7db0bdbbe9d8a0fd525cf7 Mon Sep 17 00:00:00 2001 From: "Jose E. Marchesi" Date: Sat, 19 Sep 2026 15:05:45 +0200 Subject: [PATCH 228/584] a68: factor origin handling in sprops into make_origin Signed-off-by: Jose E. Marchesi gcc/algol68/ChangeLog * a68-parser-sprops.cc (make_origin): Initialize properties of the new origin from a parse node. (sprops_for_denotation): Pass parse node to make_origin and remove now superfluous code. (sprops_for_deproceduring): Likewise. (sprops_for_proceduring): Likewise. (sprops_for_loop_clause): Likewise. (sprops_for_serial_clause): Likewise. (sprops_for_parallel_clause): Likewise. (sprops_for_conditional_clause): Likewise. (sprops_for_case_clause): Likewise. (sprops_for_collateral_clause): Likewise. (sprops_for_conformity_clause): Likewise. (sprops_for_identity_relation): Likewise. (sprops_for_logical_function): Likewise. (sprops_for_call): Likewise. (sprops_for_generator): Likewise. (sprops_for_formula): Likewise. (sprops_for_applied_identifier): Likewise. (sprops_for_assertion): Likewise. (sprops_for_decl): Likewise. (sprops_for_unit): Likewise. --- gcc/algol68/a68-parser-sprops.cc | 113 ++++++++----------------------- 1 file changed, 27 insertions(+), 86 deletions(-) diff --git a/gcc/algol68/a68-parser-sprops.cc b/gcc/algol68/a68-parser-sprops.cc index e8a131625901..19af22456a89 100644 --- a/gcc/algol68/a68-parser-sprops.cc +++ b/gcc/algol68/a68-parser-sprops.cc @@ -241,18 +241,18 @@ These rules are implemented in the corresponding handlers for choice constructs, below. */ -/* Allocate a new origin and return it. The particular properties used to - initialize the value are arbitrary and the user should not rely on them. */ +/* Allocate a new origin and return it. The new origin is of kind NIL, and its + properties are derived from the given parse node P. */ static ORIGIN_T * -make_origin (void) +make_origin (NODE_T *p) { ORIGIN_T *ori = ggc_alloc (); ori->kindo = KINDO_NIL; - ori->bno = 0; + ori->diago = a68_get_node_location (p); + ori->bno = LEX_LEVEL (p); ori->derefo = false; ori->geno = false; - ori->diago = UNKNOWN_LOCATION; return ori; } @@ -289,11 +289,8 @@ origin_equal_p (ORIGIN_T *ori1, ORIGIN_T *ori2) static void sprops_for_denotation (NODE_T *p) { - ORIGIN (p) = make_origin (); + ORIGIN (p) = make_origin (p); KINDO (p) = KINDO_CST; - DIAGO (p) = a68_get_node_location (p); - BNO (p) = 0; - DEREFO (p) = false; ACCESS (p) = ACCESS_DIR; } @@ -351,11 +348,7 @@ sprops_for_dereferencing (NODE_T *p) static void sprops_for_deproceduring (NODE_T *p) { - ORIGIN (p) = make_origin (); - KINDO (p) = KINDO_NIL; - DIAGO (p) = a68_get_node_location (p); - BNO (p) = LEX_LEVEL (p); - DEREFO (p) = false; + ORIGIN (p) = make_origin (p); ACCESS (p) = ACCESS_DIR; } @@ -368,11 +361,7 @@ sprops_for_deproceduring (NODE_T *p) static void sprops_for_proceduring (NODE_T *p) { - ORIGIN (p) = make_origin (); - KINDO (p) = KINDO_NIL; - DIAGO (p) = a68_get_node_location (p); - BNO (p) = LEX_LEVEL (p); - DEREFO (p) = false; + ORIGIN (p) = make_origin (p); ACCESS (p) = ACCESS_DIR; } @@ -414,11 +403,7 @@ sprops_for_uniting (NODE_T *p) static void sprops_for_loop_clause (NODE_T *p) { - ORIGIN (p) = make_origin (); - KINDO (p) = KINDO_NIL; - DIAGO (p) = a68_get_node_location (p); - BNO (p) = LEX_LEVEL (p); - DEREFO (p) = false; + ORIGIN (p) = make_origin (p); ACCESS (p) = ACCESS_NIL; } @@ -519,11 +504,9 @@ sprops_for_serial_clause (NODE_T *p) { bool found_derefo = DEREFO (last_unit) | DEREFO (completer); bool found_geno = GENO (last_unit) | GENO (completer); - ORIGIN (p) = make_origin (); - KINDO (p) = KINDO_NIL; + ORIGIN (p) = make_origin (p); DEREFO (p) = found_derefo; GENO (p) = found_geno; - BNO (p) = LEX_LEVEL (p); } /* Balance access. */ @@ -543,11 +526,7 @@ sprops_for_serial_clause (NODE_T *p) static void sprops_for_parallel_clause (NODE_T *p) { - ORIGIN (p) = make_origin (); - KINDO (p) = KINDO_NIL; - BNO (p) = LEX_LEVEL (p); - DEREFO (p) = false; - GENO (p) = false; + ORIGIN (p) = make_origin (p); ACCESS (p) = ACCESS_NIL; } @@ -610,11 +589,9 @@ sprops_for_conditional_clause (NODE_T *p) bool found_derefo = DEREFO (then_part) | DEREFO (else_part); bool found_geno = GENO (then_part) | GENO (else_part); - ORIGIN (p) = make_origin (); - KINDO (p) = KINDO_NIL; + ORIGIN (p) = make_origin (p); DEREFO (p) = found_derefo; GENO (p) = found_geno; - BNO (p) = LEX_LEVEL (p); } /* Balance access. */ @@ -708,11 +685,9 @@ sprops_for_case_clause (NODE_T *p) ORIGIN (p) = postulated_origin; else { - ORIGIN (p) = make_origin (); - KINDO (p) = KINDO_NIL; + ORIGIN (p) = make_origin (p); DEREFO (p) = found_derefo; GENO (p) = found_geno; - BNO (p) = LEX_LEVEL (p); } /* Balance access. */ @@ -738,10 +713,7 @@ sprops_for_case_clause (NODE_T *p) static void sprops_for_collateral_clause (NODE_T *p) { - ORIGIN (p) = make_origin (); - BNO (p) = LEX_LEVEL (p); - GENO (p) = 0; - DEREFO (p) = 0; + ORIGIN (p) = make_origin (p); if (MOID (p) == M_VOID) { @@ -844,11 +816,9 @@ sprops_for_conformity_clause (NODE_T *p) ORIGIN (p) = postulated_origin; else { - ORIGIN (p) = make_origin (); - KINDO (p) = KINDO_NIL; + ORIGIN (p) = make_origin (p); DEREFO (p) = found_derefo; GENO (p) = found_geno; - BNO (p) = LEX_LEVEL (p); } /* Balance access. */ @@ -867,11 +837,7 @@ sprops_for_conformity_clause (NODE_T *p) static void sprops_for_identity_relation (NODE_T *p) { - ORIGIN (p) = make_origin (); - KINDO (p) = KINDO_NIL; - BNO (p) = LEX_LEVEL (p); - DEREFO (p) = false; - GENO (p) = false; + ORIGIN (p) = make_origin (p); ACCESS (p) = ACCESS_DIR; } @@ -939,11 +905,7 @@ sprops_for_selection (NODE_T *p) static void sprops_for_logical_function (NODE_T *p) { - ORIGIN (p) = make_origin (); - DIAGO (p) = a68_get_node_location (p); - KINDO (p) = KINDO_NIL; - BNO (p) = LEX_LEVEL (p); - DEREFO (p) = false; + ORIGIN (p) = make_origin (p); ACCESS (p) = ACCESS_DIR; } @@ -971,11 +933,8 @@ sprops_for_cast (NODE_T *p) static void sprops_for_call (NODE_T *p) { - ORIGIN (p) = make_origin (); - DIAGO (p) = a68_get_node_location (p); - KINDO (p) = KINDO_NIL; - BNO (p) = LEX_LEVEL (p); - DEREFO (p) = false; + ORIGIN (p) = make_origin (p); + ACCESS (p) = ACCESS_DIR; } /* Generators @@ -987,10 +946,9 @@ sprops_for_call (NODE_T *p) static void sprops_for_generator (NODE_T *p) { - ORIGIN (p) = make_origin (); - DIAGO (p) = a68_get_node_location (p); + ORIGIN (p) = make_origin (p); KINDO (p) = KINDO_GEN; - DEREFO (p) = false; + if (IS (SUB (p), LOC_SYMBOL)) { BNO (p) = LEX_LEVEL (p); @@ -1037,14 +995,7 @@ sprops_for_formula (NODE_T *p) if (origin_equal_p (ORIGIN (arg1), ORIGIN (arg2))) ORIGIN (p) = ORIGIN (arg1); else - { - ORIGIN (p) = make_origin (); - DIAGO (p) = a68_get_node_location (p); - KINDO (p) = KINDO_NIL; - DEREFO (p) = 0; - BNO (p) = LEX_LEVEL (p); - GENO (p) = false; - } + ORIGIN (p) = make_origin (p); } ACCESS (p) = ACCESS_DIR; } @@ -1062,7 +1013,7 @@ static void sprops_for_applied_identifier (NODE_T *p) { if (ORIGIN (TAX (p)) == NO_ORIGIN) - ORIGIN (TAX (p)) = make_origin (); + ORIGIN (TAX (p)) = make_origin (p); ORIGIN (p) = ORIGIN (TAX (p)); ACCESS (p) = ACCESS (TAX (p)); } @@ -1076,11 +1027,7 @@ sprops_for_applied_identifier (NODE_T *p) static void sprops_for_assertion (NODE_T *p) { - ORIGIN (p) = make_origin (); - DIAGO (p) = a68_get_node_location (p); - KINDO (p) = KINDO_NIL; - BNO (p) = LEX_LEVEL (p); - DEREFO (p) = false; + ORIGIN (p) = make_origin (p); ACCESS (p) = ACCESS_NIL; } @@ -1188,8 +1135,7 @@ sprops_for_decl (NODE_T *p) { TAG_T *tax = TAX (defining_identifier); if (ORIGIN (tax) == NO_ORIGIN) - ORIGIN (tax) = make_origin (); - DIAGO (tax) = a68_get_node_location (p); + ORIGIN (tax) = make_origin (p); KINDO (tax) = KINDO_IDE; BNO (tax) = LEX_LEVEL (defining_identifier); ACCESS (tax) = ACCESS_DIR; @@ -1200,8 +1146,7 @@ sprops_for_decl (NODE_T *p) { TAG_T *tax = TAX (defining_identifier); if (ORIGIN (tax) == NO_ORIGIN) - ORIGIN (tax) = make_origin (); - DIAGO (tax) = a68_get_node_location (p); + ORIGIN (tax) = make_origin (p); KINDO (tax) = KINDO_VAR; BNO (tax) = LEX_LEVEL (defining_identifier); ACCESS (tax) = ACCESS_VAR; @@ -1241,11 +1186,7 @@ sprops_for_unit (NODE_T *p) case NIHIL: case EMPTY_SYMBOL: case ROUTINE_TEXT: - ORIGIN (p) = make_origin (); - DIAGO (p) = a68_get_node_location (p); - KINDO (p) = KINDO_NIL; - DEREFO (p) = false; - BNO (p) = LEX_LEVEL (p); + ORIGIN (p) = make_origin (p); ACCESS (p) = ACCESS_DIR; break; case DENOTATION: From f95a1c7f4e4b1f4c41e40d2eab8cbde258292962 Mon Sep 17 00:00:00 2001 From: Milan Tripkovic Date: Sat, 19 Sep 2026 07:55:27 -0600 Subject: [PATCH 229/584] [PATCH] RISC-V: PR target/126074 - Missing cases for constant synthesis on RISC-V MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This patch implements the shNadd.uw case from the PR. The instruction shNadd.uw a0, a0, a0 computes: ((a0 & 0xffffffff) << N) + a0 If a0 holds a value sign extended from bit 31, with u being its low 32 bits, this formula evaluates to: u * (2^N + 1) - 2^32 This allows us to build certain 64-bit constants using just a lui and a single shNadd.uw. To find u, riscv_build_integer_1 reverses the formula: it adds 2^32 to the constant and divide it by 3, 5, or 9. If the quotient fits in 32 bits with bit 31 set, and the new sequence is cheaper, we emit an FMA entry with use_uw set. For 0x180005000, before:       li a0,1572864       addi t0,a0,5       slli a0,t0,12 after:       li    a0,-715821056       sh1add.uw   a0,a0,a0 Finally, in riscv_move_integer, the FMA check is moved above the use_uw check. Since our shNadd.uw case sets use_uw = true, checking use_uw first would mistakenly treat the operation as a plain zero-extended shift instead of shNadd.uw. PR target/126074 gcc/ChangeLog: * config/riscv/riscv.cc (riscv_build_integer_1): Add logic to synthesize constants using shNadd.uw. (riscv_move_integer): Handle FMA with use_uw for RTL emission. gcc/testsuite/ChangeLog: * gcc.target/riscv/pr126074.c: New test. --- gcc/config/riscv/riscv.cc | 62 ++++++++++++++++++++--- gcc/testsuite/gcc.target/riscv/pr126074.c | 36 +++++++++++++ 2 files changed, 90 insertions(+), 8 deletions(-) create mode 100644 gcc/testsuite/gcc.target/riscv/pr126074.c diff --git a/gcc/config/riscv/riscv.cc b/gcc/config/riscv/riscv.cc index f20f2a6bd3e1..9fca2f679a07 100644 --- a/gcc/config/riscv/riscv.cc +++ b/gcc/config/riscv/riscv.cc @@ -1580,6 +1580,42 @@ riscv_build_integer_1 (struct riscv_integer_op codes[RISCV_MAX_INTEGER_OPS], memcpy (codes, alt_codes, sizeof (alt_codes)); cost = alt_cost; } + if (cost > 2 && mode == DImode) + { + unsigned HOST_WIDE_INT uval = value; + + if (uval < (HOST_WIDE_INT_UC (1) << 35)) + { + unsigned HOST_WIDE_INT d = uval + (HOST_WIDE_INT_UC (1) << 32); + + for (int n = 1; n <= 3; n++) + { + unsigned HOST_WIDE_INT mult = (HOST_WIDE_INT_UC (1) << n) + 1; + + if (d % mult) + continue; + unsigned HOST_WIDE_INT u = d / mult; + + /* With bit 31 clear there is no sign extension, the result + is u * (2^N + 1), and the plain shNadd case above already + handles it. */ + if (u >= (HOST_WIDE_INT_UC (1) << 32) + || (u & HOST_WIDE_INT_UC (0x80000000)) == 0) + continue; + alt_cost = 1 + riscv_build_integer_1 (alt_codes, + sext_hwi (u, 32), mode); + + if (alt_cost >= cost) + continue; + alt_codes[alt_cost - 1].code = FMA; + alt_codes[alt_cost - 1].value = mult; + alt_codes[alt_cost - 1].use_uw = true; + alt_codes[alt_cost - 1].save_temporary = false; + memcpy (codes, alt_codes, sizeof (alt_codes)); + cost = alt_cost; + } + } + } } /* We might be able to generate a constant close to our target @@ -3616,6 +3652,24 @@ riscv_move_integer (rtx temp, rtx dest, HOST_WIDE_INT value) /* UNKNOWN means load the constant value into X. */ x = GEN_INT (codes[i].value); } + else if (codes[i].code == FMA) + { + int value = exact_log2 (codes[i].value - 1); + rtx t = can_create_pseudo_p () ? gen_reg_rtx (mode) : temp; + rtx op; + gcc_assert (value >= 1 && value <= 3); + + /* This case is for shNadd.uw. */ + if (codes[i].use_uw) + op = gen_rtx_AND (mode, + gen_rtx_ASHIFT (mode, x, GEN_INT (value)), + GEN_INT (HOST_WIDE_INT_UC (0xffffffff) + << value)); + else + op = gen_rtx_ASHIFT (mode, x, GEN_INT (value)); + + x = riscv_emit_set (t, gen_rtx_PLUS (mode, op, x)); + } else if (codes[i].use_uw) { /* If the sequence requires using a "uw" form of an insn, we're @@ -3636,14 +3690,6 @@ riscv_move_integer (rtx temp, rtx dest, HOST_WIDE_INT value) x = gen_rtx_fmt_ee (AND, mode, x, GEN_INT (value)); x = riscv_emit_set (t, x); } - else if (codes[i].code == FMA) - { - HOST_WIDE_INT value = exact_log2 (codes[i].value - 1); - rtx ashift = gen_rtx_fmt_ee (ASHIFT, mode, x, GEN_INT (value)); - x = gen_rtx_fmt_ee (PLUS, mode, ashift, x); - rtx t = can_create_pseudo_p () ? gen_reg_rtx (mode) : temp; - x = riscv_emit_set (t, x); - } else if (codes[i].code == CONCAT || codes[i].code == VEC_MERGE) { if (codes[i].code == CONCAT && !TARGET_ZBKB) diff --git a/gcc/testsuite/gcc.target/riscv/pr126074.c b/gcc/testsuite/gcc.target/riscv/pr126074.c new file mode 100644 index 000000000000..6a5886f3ce89 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/pr126074.c @@ -0,0 +1,36 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target rv64 } */ +/* { dg-options "-march=rv64gc_zba_zbb_zbs" } */ + +unsigned long foo_sh1add_0x180011000 (void) { return 0x180011000UL; } +unsigned long foo_sh1add_0x180017000 (void) { return 0x180017000UL; } +unsigned long foo_sh1add_0x18001d000 (void) { return 0x18001d000UL; } +unsigned long foo_sh1add_0x180005000 (void) { return 0x180005000UL; } + +unsigned long foo_sh2add_0x18000f000 (void) { return 0x18000f000UL; } +unsigned long foo_sh2add_0x180019000 (void) { return 0x180019000UL; } +unsigned long foo_sh2add_0x3c82b3000 (void) { return 0x3c82b3000UL; } + +unsigned long foo_sh3add_0x380009000 (void) { return 0x380009000UL; } +unsigned long foo_sh3add_0x38001b000 (void) { return 0x38001b000UL; } +unsigned long foo_sh3add_0x5914a6000 (void) { return 0x5914a6000UL; } +unsigned long foo_sh3add_0x7cf04c000 (void) { return 0x7cf04c000UL; } + +unsigned long foo_sh1add_0x1ffffd000 (void) { return 0x1ffffd000UL; } +unsigned long foo_sh2add_0x3ffffb000 (void) { return 0x3ffffb000UL; } +unsigned long foo_sh3add_0x7ffff7000 (void) { return 0x7ffff7000UL; } + +unsigned long foo_neg_0x80000000 (void) { return 0x80000000UL; } +unsigned long foo_neg_0x180000000 (void) { return 0x180000000UL; } +unsigned long foo_neg_0x380000000 (void) { return 0x380000000UL; } + +unsigned long foo_neg_0x400000000 (void) { return 0x400000000UL; } + +unsigned long foo_neg_0x800000000 (void) { return 0x800000000UL; } +unsigned long foo_neg_0x1800050000000 (void) { return 0x1800050000000UL; } + +unsigned long foo_neg_0x7ffffffff (void) { return 0x7ffffffffUL; } + +unsigned long foo_neg_0x37fff7000 (void) { return 0x37fff7000UL; } + +/* { dg-final { scan-assembler-times {\msh[123]add\.uw\M} 14 } } */ From d2e62fc9640620227dbb71955cb428f0ee35bba1 Mon Sep 17 00:00:00 2001 From: Jeff Law Date: Sat, 19 Sep 2026 08:06:13 -0600 Subject: [PATCH 230/584] [RISC-V] Fix RISC-V test expectation after recent saturation/clamping work Some of the recent work recognizing saturating the clamping resulted in vec_sat_u_sub_trunc-1-u8 starting to fail: Tests that now fail, but worked before (10 tests): unix/-march=rv64gc_zba_zbb_zbs_zicond: gcc: gcc.target/riscv/rvv/autovec/sat/vec_sat_u_sub_trunc-1-u8.c -ftree-vectorize -O2 -mrvv-vector-bits=scalable -mrvv-max-lmul=dynamic -ffast-math scan-tree-dump-times optimized ".SAT_SUB " 1 [ ... ] I bisected and compared the before/after for the identified patch (already forgot which patch it was). The code with the patch was clearly better in gimple as it eliminated another branchy sequence and replaced it with saturating arithmetic, throwing off the dump check for this test. So the right thing to do is adjust the test expectation. Interestingly enough this allows us simplify the test expectations as the test previously expected different results for -O2 vs -O3. Pushing to the trunk. gcc/testsuite * gcc.target/riscv/rvv/autovec/sat/vec_sat_u_sub_trunc-1-u8.c: Update test expectations. --- .../riscv/rvv/autovec/sat/vec_sat_u_sub_trunc-1-u8.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/sat/vec_sat_u_sub_trunc-1-u8.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/sat/vec_sat_u_sub_trunc-1-u8.c index c5947d92fe96..b3638bd5d5a5 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/autovec/sat/vec_sat_u_sub_trunc-1-u8.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/sat/vec_sat_u_sub_trunc-1-u8.c @@ -5,7 +5,6 @@ DEF_VEC_SAT_U_SUB_TRUNC_FMT_1(uint8_t, uint16_t) -/* { dg-final { scan-tree-dump-times ".SAT_SUB " 2 "optimized" { target { no-opts "-O2" } } } } */ -/* { dg-final { scan-tree-dump-times ".SAT_SUB " 1 "optimized" { target { no-opts "-O3" } } } } */ +/* { dg-final { scan-tree-dump-times ".SAT_SUB " 2 "optimized" } } */ /* { dg-final { scan-assembler-times {vssubu\.vv} 1 } } */ /* { dg-final { scan-assembler-times {vnsrl\.wi} 1 } } */ From e03a2c4527648bd5bc21a452a1e44d51ec3c2f89 Mon Sep 17 00:00:00 2001 From: Dominic P Date: Sat, 19 Sep 2026 10:46:18 -0600 Subject: [PATCH 231/584] [PATCH] postreload: recover the branch condition through the cc register reload_cse_regs_1 records an implicit set on the edges of a conditional branch that tests an equality, so cselib knows the compared register holds the compared value in the block the edge enters (PR107455). It reads the condition out of the jump pattern, so it works only where the jump carries the comparison: riscv and mips branches, aarch64 cbz, Thumb-1 cbz (gcc.target/riscv/pr107455-1.c and -2.c). Where the comparison is a separate insn the jump tests a MODE_CC register and no implicit set is made. Use get_condition, which finds the comparison through the cc register, and take the edge polarity from the returned code. get_condition reverses the condition only for a LABEL_REF else arm, so a jump with a return in one arm (frv and ia64 *return_false) would give the other edge's condition; reject jumps whose target is not a label. Record the equivalence only where the block sets the register to that value, the redundancy the implicit set exists to remove. That is a profitability choice, not a correctness condition: every equivalence is true, but unguarded it also reaches reload_cse_simplify_set, which at equal cost prefers a register to a constant (postreload.cc:452); with a register known to hold the constant that rewrites literal operands, and the lost fusions and cross-jumps cost more than the removed sets save: a bcmrpi_defconfig kernel at -O2 for arm1176 grows 3128 bytes of .text unguarded and shrinks 224 guarded. Of the 783 kernel objects the unguarded change alters, 42 still change with the guard. Teaching that tie-break to ignore a value known only through an implicit set would remove the guard, but it changes the rule for every target, so it belongs in a separate patch. On Arm the re-materialised value in a shared early-exit block goes away and the exit becomes a conditional return: subs r3, r0, #0 subs r3, r0, #0 bne .L14 bxeq lr mov r0, #0 bx lr The core_list_find loop of gcc.target/riscv/pr107455-2.c gets the same treatment on arm1176. Bootstrapped and regression tested on x86_64-pc-linux-gnu, where dg.exp and tree-ssa.exp are identical with and without the patch. Cross tested like-for-like, the patched cc1 against one relinked from the unpatched source in the same tree: arm-none-eabi with arm.exp, simd.exp, mve.exp, advsimd-intrinsics.exp, acle.exp and cmse.exp on the default board and with -mthumb -mfloat-abi=hard -mtune=cortex-a9 -march=armv7-a -mfpu=neon-fp-armv8; aarch64-linux-gnu under qemu with aarch64.exp, vect.exp and tree-ssa.exp. Only the new tests change. gcc.c-torture/execute under qemu on arm1176 with and without the patch: 1564 tests, same results. Assisted-by: Claude Opus 5 (Anthropic) gcc/ChangeLog: * postreload.cc (reload_cse_regs_1): Find the condition of the predecessor's conditional branch with get_condition, so a comparison held in the condition-code register is seen. Reject a jump whose target is not a label. Record the implicit set only where the block sets the register to that value. gcc/testsuite/ChangeLog: * gcc.target/aarch64/postreload-implicit-set-1.c: New test. * gcc.target/arm/postreload-implicit-set-1.c: New test. * gcc.target/arm/postreload-implicit-set-2.c: New test. * gcc.target/i386/postreload-implicit-set-1.c: New test. Signed-off-by: Dominic P --- gcc/postreload.cc | 44 ++++++++++---- .../aarch64/postreload-implicit-set-1.c | 36 ++++++++++++ .../arm/postreload-implicit-set-1.c | 57 +++++++++++++++++++ .../arm/postreload-implicit-set-2.c | 34 +++++++++++ .../i386/postreload-implicit-set-1.c | 27 +++++++++ 5 files changed, 188 insertions(+), 10 deletions(-) create mode 100644 gcc/testsuite/gcc.target/aarch64/postreload-implicit-set-1.c create mode 100644 gcc/testsuite/gcc.target/arm/postreload-implicit-set-1.c create mode 100644 gcc/testsuite/gcc.target/arm/postreload-implicit-set-2.c create mode 100644 gcc/testsuite/gcc.target/i386/postreload-implicit-set-1.c diff --git a/gcc/postreload.cc b/gcc/postreload.cc index 576456c79d56..475b58896298 100644 --- a/gcc/postreload.cc +++ b/gcc/postreload.cc @@ -249,18 +249,22 @@ reload_cse_regs_1 (void) if (!condjump || ! any_condjump_p (condjump)) break; + /* get_condition reverses the condition only when the else arm + is a LABEL_REF, so a jump that returns in one arm would give + the condition of the other edge. */ + if (!JUMP_LABEL (condjump) || !LABEL_P (JUMP_LABEL (condjump))) + break; + /* This predecessor ends with a possible equivalence producing conditional branch. Extract the condition and try to use it to create an equivalence. */ - rtx pat = pc_set (condjump); - rtx i_t_e = SET_SRC (pat); - gcc_assert (GET_CODE (i_t_e) == IF_THEN_ELSE); - rtx cond = XEXP (i_t_e, 0); - - if ((((e->flags & EDGE_FALLTHRU) != 0) - == (XEXP (i_t_e, 1) == pc_rtx)) - ? GET_CODE (cond) == EQ - : GET_CODE (cond) == NE) + rtx cond = get_condition (condjump, NULL, false, true); + if (!cond) + break; + + if ((e->flags & EDGE_FALLTHRU) != 0 + ? GET_CODE (cond) == NE + : GET_CODE (cond) == EQ) { /* If this is the first time through record the source and destination. */ @@ -300,7 +304,27 @@ reload_cse_regs_1 (void) It will be entered into the cselib tables before we process the first real insn in this block. */ if (dest && ei_end_p (ei)) - implicit_set = make_insn_raw (gen_rtx_SET (dest, src)); + { + rtx_insn *i; + bool useful = false; + FOR_BB_INSNS (bb, i) + { + if (!NONDEBUG_INSN_P (i)) + continue; + rtx s = single_set (i); + if (s + && rtx_equal_p (SET_DEST (s), dest) + && rtx_equal_p (SET_SRC (s), src)) + { + useful = true; + break; + } + if (reg_set_p (dest, i)) + break; + } + if (useful) + implicit_set = make_insn_raw (gen_rtx_SET (dest, src)); + } } FOR_BB_INSNS (bb, insn) diff --git a/gcc/testsuite/gcc.target/aarch64/postreload-implicit-set-1.c b/gcc/testsuite/gcc.target/aarch64/postreload-implicit-set-1.c new file mode 100644 index 000000000000..6faf6f7ba5eb --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/postreload-implicit-set-1.c @@ -0,0 +1,36 @@ +/* As gcc.target/i386/postreload-implicit-set-1.c. The zero case is already + handled without this, because cbz carries the comparison in the branch; + this covers the cmp form. */ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ +/* { dg-add-options check_function_bodies } */ +/* { dg-final { check-function-bodies "**" "" "" } } */ + +int g (int); +int h (int); + +/* +** seven: +** cmp w0, 7 +** beq \.L[0-9]+ +** stp x29, x30, \[sp, -16\]! +** mov x29, sp +** bl g +** cmp w0, 7 +** beq \.L[0-9]+ +** ldp x29, x30, \[sp\], 16 +** b h +** ldp x29, x30, \[sp\], 16 +** ret +** ret +*/ +int +seven (int x) +{ + if (x == 7) + return 7; + x = g (x); + if (x == 7) + return 7; + return h (x); +} diff --git a/gcc/testsuite/gcc.target/arm/postreload-implicit-set-1.c b/gcc/testsuite/gcc.target/arm/postreload-implicit-set-1.c new file mode 100644 index 000000000000..d38d2dd7c7b0 --- /dev/null +++ b/gcc/testsuite/gcc.target/arm/postreload-implicit-set-1.c @@ -0,0 +1,57 @@ +/* The equality a conditional branch tests holds on one of its edges; reload + CSE must see it through the condition-code register, so that re-creating + the same value in the target block is dropped and the exit can become a + conditional return. */ +/* { dg-do compile } */ +/* { dg-options "-O2 -marm" } */ +/* { dg-require-effective-target arm_arch_v6_arm_ok } */ +/* { dg-add-options arm_arch_v6 } */ +/* { dg-add-options check_function_bodies } */ +/* { dg-final { check-function-bodies "**" "" "" } } */ + +int g (int); +int h (int); + +/* +** zero: +** subs r3, r0, #0 +** bxeq lr +** push {r4, lr} +** bl g +** cmp r0, #0 +** popeq {r4, pc} +** pop {r4, lr} +** b h +*/ +int +zero (int x) +{ + if (x == 0) + return 0; + x = g (x); + if (x == 0) + return 0; + return h (x); +} + +/* +** nonzero: +** cmp r0, #7 +** bxeq lr +** push {r4, lr} +** bl g +** cmp r0, #7 +** popeq {r4, pc} +** pop {r4, lr} +** b h +*/ +int +nonzero (int x) +{ + if (x == 7) + return 7; + x = g (x); + if (x == 7) + return 7; + return h (x); +} diff --git a/gcc/testsuite/gcc.target/arm/postreload-implicit-set-2.c b/gcc/testsuite/gcc.target/arm/postreload-implicit-set-2.c new file mode 100644 index 000000000000..75bbc6f18085 --- /dev/null +++ b/gcc/testsuite/gcc.target/arm/postreload-implicit-set-2.c @@ -0,0 +1,34 @@ +/* As postreload-implicit-set-1.c, in Thumb-2 state. */ +/* { dg-do compile } */ +/* { dg-options "-O2 -mthumb" } */ +/* { dg-require-effective-target arm_arch_v7a_ok } */ +/* { dg-add-options arm_arch_v7a } */ +/* { dg-add-options check_function_bodies } */ +/* { dg-final { check-function-bodies "**" "" "" } } */ + +int g (int); +int h (int); + +/* +** nonzero: +** cmp r0, #7 +** beq \.L[0-9]+ +** push {r3, lr} +** bl g +** cmp r0, #7 +** beq \.L[0-9]+ +** pop {r3, lr} +** b h +** pop {r3, pc} +** bx lr +*/ +int +nonzero (int x) +{ + if (x == 7) + return 7; + x = g (x); + if (x == 7) + return 7; + return h (x); +} diff --git a/gcc/testsuite/gcc.target/i386/postreload-implicit-set-1.c b/gcc/testsuite/gcc.target/i386/postreload-implicit-set-1.c new file mode 100644 index 000000000000..f5714aedef0b --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/postreload-implicit-set-1.c @@ -0,0 +1,27 @@ +/* The equality a conditional branch tests holds on one of its edges; reload + CSE must see it through the flags register, so that re-creating the same + value in the target block goes away. */ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ +/* { dg-require-effective-target lp64 } */ +/* { dg-add-options check_function_bodies } */ +/* { dg-final { check-function-bodies "**" "" "" } } */ + +void f1 (double); +void f2 (int); + +/* +** foo: +** testl %edi, %edi +** je \.L[0-9]+ +** jmp f1 +** jmp f2 +*/ +void +foo (int type, double xx) +{ + if (type) + f1 (xx); + else + f2 (type); +} From ccd787ce79a0ed6ee2c0881821076773048dd334 Mon Sep 17 00:00:00 2001 From: Milan Tripkovic Date: Sat, 19 Sep 2026 10:56:04 -0600 Subject: [PATCH 232/584] [PATCH] RISC-V: PR target/127374 - Zicond improvement for RISC-V MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fix a missed optimization where conditional zeroes based on less-than-or-equal and greater-than comparisons against immediates generate redundant Immediate loads. Add define_split patterns to optimize these if_then_else operations. Introduce the gt_to_le code attribute to map greater-than conditions to Less-than-or-equal. This enables the patterns to utilize the sle_operand predicate, safely splitting the operations into slti or sltiu evaluations followed by czero.nez or czero.eqz Instructions. ASM Before:     li a5,100     sgt a0,a0,a5 // sgtu a0,a0,a5     czero.nez a0,a1,a0 // czero.eqz a0,a1,a0 ASM after:     slti a0,a0,101 // sltiu a0,a0,101     czero.eqz a0,a1,a0 // czero.nez a0,a1,a0 Also, add a new regression test to cover this optimization and update an existing test to prevent false alarms due to the new instruction sequence. PR target/127374 gcc/ChangeLog: * config/riscv/iterators.md (leu): Map gt to le * config/riscv/zicond.md: Add define_split patterns gcc/testsuite/ChangeLog: * gcc.target/riscv/czero-bext.c: Change scan assembler * gcc.target/riscv/pr127374.c: New test. --- gcc/config/riscv/iterators.md | 3 ++ gcc/config/riscv/zicond.md | 34 +++++++++++++++++++++ gcc/testsuite/gcc.target/riscv/czero-bext.c | 4 +-- gcc/testsuite/gcc.target/riscv/pr127374.c | 20 ++++++++++++ 4 files changed, 59 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/gcc.target/riscv/pr127374.c diff --git a/gcc/config/riscv/iterators.md b/gcc/config/riscv/iterators.md index dc25dfd2e99d..d8869810de76 100644 --- a/gcc/config/riscv/iterators.md +++ b/gcc/config/riscv/iterators.md @@ -268,6 +268,9 @@ (define_code_iterator any_le [le leu]) (define_code_iterator any_eq [eq ne]) +;; Maps GT/GTU to LE/LE. +(define_code_attr gt_to_le [(gt "le") (gtu "leu")]) + ;; Iterators for conditions we can emit a sCC against 0 or a reg directly (define_code_iterator scc_0 [any_eq any_gt any_lt]) diff --git a/gcc/config/riscv/zicond.md b/gcc/config/riscv/zicond.md index b0152cb773f4..a69f55e82d18 100644 --- a/gcc/config/riscv/zicond.md +++ b/gcc/config/riscv/zicond.md @@ -487,3 +487,37 @@ [(set (match_dup 4) (any_le:X (match_dup 1) (match_dup 2))) (set (match_dup 0) (ashift:X (match_dup 4) (match_dup 5)))] { operands[5] = GEN_INT (exact_log2 (INTVAL (operands[3]))); }) + +(define_split + [(set (match_operand:GPR 0 "register_operand") + (if_then_else:GPR + (any_le:X (match_operand:X 1 "register_operand") + (match_operand:X 2 "sle_operand")) + (match_operand:GPR 3 "register_operand") + (const_int 0)))] + "TARGET_ZICOND_LIKE && can_create_pseudo_p ()" + [(set (match_dup 4) (any_le:X (match_dup 1) (match_dup 2))) + (set (match_dup 0) + (if_then_else:GPR (ne:X (match_dup 4) (const_int 0)) + (match_dup 3) + (const_int 0)))] +{ + operands[4] = gen_reg_rtx (mode); +}) + +(define_split + [(set (match_operand:GPR 0 "register_operand") + (if_then_else:GPR + (any_gt:X (match_operand:X 1 "register_operand") + (match_operand:X 2 "sle_operand")) + (match_operand:GPR 3 "register_operand") + (const_int 0)))] + "TARGET_ZICOND_LIKE && can_create_pseudo_p ()" + [(set (match_dup 4) (:X (match_dup 1) (match_dup 2))) + (set (match_dup 0) + (if_then_else:GPR (eq:X (match_dup 4) (const_int 0)) + (match_dup 3) + (const_int 0)))] +{ + operands[4] = gen_reg_rtx (mode); +}) diff --git a/gcc/testsuite/gcc.target/riscv/czero-bext.c b/gcc/testsuite/gcc.target/riscv/czero-bext.c index 54a6d6f175f9..8ffeb4263329 100644 --- a/gcc/testsuite/gcc.target/riscv/czero-bext.c +++ b/gcc/testsuite/gcc.target/riscv/czero-bext.c @@ -11,7 +11,7 @@ bool isValidAncestorType(int type) { -/* { dg-final { scan-assembler "czero.nez\t" } } */ -/* { dg-final { scan-assembler "sgtu\t" } } */ +/* { dg-final { scan-assembler "czero.eqz\t" } } */ +/* { dg-final { scan-assembler "sltiu\t" } } */ /* { dg-final { scan-assembler-not "bgtu\t" } } */ diff --git a/gcc/testsuite/gcc.target/riscv/pr127374.c b/gcc/testsuite/gcc.target/riscv/pr127374.c new file mode 100644 index 000000000000..ccb93cdff122 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/pr127374.c @@ -0,0 +1,20 @@ +/* PR target/127374 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=rv64gcb_zicond -mabi=lp64d" { target { rv64 } } } */ +/* { dg-options "-O2 -march=rv32gcb_zicond -mabi=ilp32d" { target { rv32 } } } */ + +int sel_le_s (int x, int y) { return x <= 100 ? y : 0; } +int sel_gt_s (int x, int y) { return x > 100 ? y : 0; } +int sel_le_u (unsigned x, int y) { return x <= 100 ? y : 0; } +int sel_gt_u (unsigned x, int y) { return x > 100 ? y : 0; } + +int clr_le_s (int x, int y) { return x <= 100 ? 0 : y; } +int clr_gt_s (int x, int y) { return x > 100 ? 0 : y; } +int clr_le_u (unsigned x, int y) { return x <= 100 ? 0 : y; } +int clr_gt_u (unsigned x, int y) { return x > 100 ? 0 : y; } + +/* { dg-final { scan-assembler-times {\mslti\s+\w+,\w+,101\M} 4 } } */ +/* { dg-final { scan-assembler-times {\msltiu\s+\w+,\w+,101\M} 4 } } */ +/* { dg-final { scan-assembler-times {\mczero\.eqz\M} 4 } } */ +/* { dg-final { scan-assembler-times {\mczero\.nez\M} 4 } } */ +/* { dg-final { scan-assembler-not {\mli\M} } } */ From d3779873a231a723aee979f9a5f24edcd6911091 Mon Sep 17 00:00:00 2001 From: panciyan Date: Sat, 19 Sep 2026 11:02:36 -0600 Subject: [PATCH 233/584] [PATCH] Fix alignment of partially-passed stack arguments For a partially-passed argument (part in registers, part on the stack), assign_parm_find_stack_rtl reconstructs the full value by spilling the register part just below the aligned stack slot. The resulting address is therefore only aligned to the largest power of two dividing the size of the register part, not to the full argument boundary. The function currently sets align to data->locate.boundary whenever data->entry_parm is non-null, which includes the partial-arg case, so the reconstructed MEM is wrongly marked with the full boundary alignment (e.g. A64 on RV32 for a DImode argument split between a register and the stack). Clamp the alignment to the partial size. This is the root cause of a RISC-V zilsd issue where a single misaligned zilsd "ld"/"sd" was emitted for a split stack argument because riscv_zilsd_valid_mem_p trusted the over-stated MEM_ALIGN. With the slot now marked with the correct alignment the access is split into two 32-bit loads. Signed-off-by: Ciyan Pan gcc/ChangeLog: * function.cc (assign_parm_find_stack_rtl): When data->partial is nonzero, limit the stack slot alignment to the largest power of two dividing the partial size. gcc/testsuite/ChangeLog: * gcc.target/riscv/zilsd-align-split-arg-1.c: New test. * gcc.target/riscv/zilsd-align-split-arg-2.c: New test. * gcc.target/riscv/zilsd-align-split-arg-3.c: New test. * gcc.target/riscv/zilsd-align-split-arg-4.c: New test. --- gcc/function.cc | 10 +++++ .../riscv/zilsd-align-split-arg-1.c | 37 +++++++++++++++++++ .../riscv/zilsd-align-split-arg-2.c | 22 +++++++++++ .../riscv/zilsd-align-split-arg-3.c | 25 +++++++++++++ .../riscv/zilsd-align-split-arg-4.c | 25 +++++++++++++ 5 files changed, 119 insertions(+) create mode 100644 gcc/testsuite/gcc.target/riscv/zilsd-align-split-arg-1.c create mode 100644 gcc/testsuite/gcc.target/riscv/zilsd-align-split-arg-2.c create mode 100644 gcc/testsuite/gcc.target/riscv/zilsd-align-split-arg-3.c create mode 100644 gcc/testsuite/gcc.target/riscv/zilsd-align-split-arg-4.c diff --git a/gcc/function.cc b/gcc/function.cc index fd9da3003cdb..a563bccaff36 100644 --- a/gcc/function.cc +++ b/gcc/function.cc @@ -2728,6 +2728,16 @@ assign_parm_find_stack_rtl (tree parm, struct assign_parm_data_one *data) if (offset_align != 0) align = MIN (align, offset_align); } + + /* If part of the argument is passed in registers and the rest on the + stack, the value is reconstructed by spilling the register part just + below the aligned stack slot. The full value therefore starts at an + address that is only aligned to the largest power of two dividing the + size of the register part, not to FUNCTION_ARG_BOUNDARY. */ + if (data->partial) + align = MIN (align, + least_bit_hwi (data->partial) * BITS_PER_UNIT); + set_mem_align (stack_parm, align); if (data->entry_parm) diff --git a/gcc/testsuite/gcc.target/riscv/zilsd-align-split-arg-1.c b/gcc/testsuite/gcc.target/riscv/zilsd-align-split-arg-1.c new file mode 100644 index 000000000000..78331658a086 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/zilsd-align-split-arg-1.c @@ -0,0 +1,37 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=rv32gcv_zilsd -mabi=ilp32d -mrvv-vector-bits=scalable -fno-vect-cost-model" } */ +/* { dg-additional-options "-mzilsd-strict-align" } */ + +#include + +/* On RV32 an int64_t argument passed after seven pointer arguments is + split: the low word lands in the last available argument register (a7) + and the high word on the incoming stack. When the vectoriser later + spills the low word of n to a 4-byte-aligned stack slot, the backend + must not reload that value with a single misaligned zilsd "ld" under + -mzilsd-strict-align; it must split the reload into two 32-bit loads + instead, otherwise the access faults on targets that trap on misaligned + 64-bit loads. */ + +void __attribute__ ((noinline, noclone)) +f6 (uint64_t *__restrict a, uint64_t *__restrict b, uint64_t *__restrict c, + uint64_t *__restrict d, uint64_t *__restrict e, uint64_t *__restrict f, + uint64_t *__restrict g, int64_t n) +{ + for (int64_t i = 0; i < n; ++i) + { + a[i] = g[i * 6]; + b[i] = g[i * 6 + 1]; + c[i] = g[i * 6 + 2]; + d[i] = g[i * 6 + 3]; + e[i] = g[i * 6 + 4]; + f[i] = g[i * 6 + 5]; + } +} + +/* The spilled low word of n sits at a 4-byte-aligned stack offset (76); + it must be reloaded with "lw", never with a single misaligned zilsd + "ld". The vector loop counter, in contrast, lives at an 8-byte-aligned + offset (8) and may legitimately use ld/sd. */ +/* { dg-final { scan-assembler-not {ld\t[a-z0-9]+,76\(sp\)} } } */ +/* { dg-final { scan-assembler-not {sd\t[a-z0-9]+,76\(sp\)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/zilsd-align-split-arg-2.c b/gcc/testsuite/gcc.target/riscv/zilsd-align-split-arg-2.c new file mode 100644 index 000000000000..ba04a90de209 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/zilsd-align-split-arg-2.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=rv32i_zilsd -mabi=ilp32" } */ +/* { dg-additional-options "-mzilsd-strict-align" } */ + +/* On RV32 an int64_t argument passed after seven pointer arguments is + split between registers and the stack: the low word lands in the last + available argument register (a7) and the high word on the incoming + stack. The middle-end reconstructs the value starting at a + 4-byte-aligned stack slot (offset 12), so under -mzilsd-strict-align + the backend must not access it with a single misaligned zilsd "ld"; it + must split the access into two 32-bit loads instead. */ + +long long +f7 (long long *a, long long *b, long long *c, long long *d, + long long *e, long long *f, long long *g, long long n) +{ + return n; +} + +/* The misaligned access must use two 32-bit "lw", never a single zilsd + "ld" from the 4-byte-aligned stack offset 12. */ +/* { dg-final { scan-assembler-not {ld\t[a-z0-9]+,12\(sp\)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/zilsd-align-split-arg-3.c b/gcc/testsuite/gcc.target/riscv/zilsd-align-split-arg-3.c new file mode 100644 index 000000000000..6852643e9630 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/zilsd-align-split-arg-3.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=rv32i_zilsd -mabi=ilp32" } */ +/* { dg-additional-options "-mzilsd-strict-align" } */ + +/* Same split-argument reconstruction as zilsd-align-split-arg-2.c, but with + a large stack frame so the stack offset of the spilled high word of n no + longer fits in a single I-type immediate and address legitimization + materializes it into a register before the access. The middle-end still + marks the reconstructed slot as only 4-byte aligned, so under + -mzilsd-strict-align the backend must split the access into two 32-bit + loads. */ + +long long +f7 (long long *a, long long *b, long long *c, long long *d, + long long *e, long long *f, long long *g, long long n) +{ + volatile char buf[4096]; + buf[0] = 1; + return n; +} + +/* The only doubleword access in this function is the misaligned access of + n, so no zilsd ld/sd may appear at all; the access must use two lw. */ +/* { dg-final { scan-assembler-not {ld\t} } } */ +/* { dg-final { scan-assembler-not {sd\t} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/zilsd-align-split-arg-4.c b/gcc/testsuite/gcc.target/riscv/zilsd-align-split-arg-4.c new file mode 100644 index 000000000000..5061bb9efedf --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/zilsd-align-split-arg-4.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=rv32i_zilsd -mabi=ilp32" } */ +/* { dg-additional-options "-mzilsd-strict-align" } */ + +/* Same split-argument reconstruction as zilsd-align-split-arg-2.c, but with + a frame whose stack offset of the spilled high word of n no longer fits in + a single I-type immediate, yet is still small enough to be formed from two + 12-bit adds (unlike zilsd-align-split-arg-3.c, which needs a LUI high + part). The middle-end still marks the reconstructed slot as only + 4-byte aligned, so under -mzilsd-strict-align the backend must split the + access into two 32-bit loads. */ + +long long +f7 (long long *a, long long *b, long long *c, long long *d, + long long *e, long long *f, long long *g, long long n) +{ + volatile char buf[2040]; + buf[0] = 1; + return n; +} + +/* The only doubleword access in this function is the misaligned access of + n, so no zilsd ld/sd may appear at all; the access must use two lw. */ +/* { dg-final { scan-assembler-not {ld\t} } } */ +/* { dg-final { scan-assembler-not {sd\t} } } */ From 0eea1e39af146d98d8bce3d93ede34ea13196899 Mon Sep 17 00:00:00 2001 From: Yongqiang Tian Date: Fri, 18 Sep 2026 23:03:54 +1000 Subject: [PATCH 234/584] pru: Ignore debug insns when padding repeat loops [PR127460] pru_insert_loop_label_last walks backward over the final two opcodes of a repeat loop to determine how much padding to add. INSN_P also accepts debug instructions, so a surviving DEBUG_INSN can be treated as an unrecognized opcode and stop the walk early. This causes the function to add an extra NOP. Use NONDEBUG_INSN_P so debug instructions do not affect the opcode count. Add a regression test for the extra padding observed with -g -fno-var-tracking. Tested for pru-unknown-elf. The new test fails before the fix and passes after it. The complete PRU testsuite has no new failures. Also bootstrapped and regression-tested on x86_64-pc-linux-gnu with no new failures. gcc/ChangeLog: PR target/127460 * config/pru/pru.cc (pru_insert_loop_label_last): Ignore debug instructions while counting final loop opcodes. gcc/testsuite/ChangeLog: PR target/127460 * gcc.target/pru/pr127460.c: New test. Signed-off-by: Yongqiang Tian --- gcc/config/pru/pru.cc | 2 +- gcc/testsuite/gcc.target/pru/pr127460.c | 20 ++++++++++++++++++++ 2 files changed, 21 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.target/pru/pr127460.c diff --git a/gcc/config/pru/pru.cc b/gcc/config/pru/pru.cc index 01e703942469..80101b0f1a9b 100644 --- a/gcc/config/pru/pru.cc +++ b/gcc/config/pru/pru.cc @@ -2560,7 +2560,7 @@ pru_insert_loop_label_last (rtx_insn *last_insn, rtx_code_label *label, if (code == CALL_INSN || code == CODE_LABEL || code == BARRIER) break; - if (INSN_P (prev)) + if (NONDEBUG_INSN_P (prev)) { if (GET_CODE (PATTERN (prev)) == SEQUENCE) prev = as_a (XVECEXP (PATTERN (prev), 0, 1)); diff --git a/gcc/testsuite/gcc.target/pru/pr127460.c b/gcc/testsuite/gcc.target/pru/pr127460.c new file mode 100644 index 000000000000..eba621b9aff7 --- /dev/null +++ b/gcc/testsuite/gcc.target/pru/pr127460.c @@ -0,0 +1,20 @@ +/* Verify that debug instructions do not affect repeat-loop padding. */ + +/* { dg-options "-O1 -mloop -g -fno-var-tracking" } */ + +unsigned int +test_loop (unsigned int n, unsigned int x) +{ + unsigned int i; + + if (n >= 0x10000) + return 0; + if (!n) + return 0; + + /* { dg-final { scan-assembler "loop\\t.L\[0-9\]*, r\[0-9\]*" } } */ + /* { dg-final { scan-assembler-times {\tnop} 1 } } */ + for (i = 0; i < n; i++) + x <<= 2; + return x; +} From 04815bbd69f0527c8a04297229859398417712b5 Mon Sep 17 00:00:00 2001 From: John David Anglin Date: Sat, 19 Sep 2026 15:41:11 -0400 Subject: [PATCH 235/584] Xfail cswtch-6.c and cswtch-7.c on hppa*-*-hpux* hppa*-*-hpux* doesn't use ".rodata.cst16" section. 2026-09-19 John David Anglin gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/cswtch-6.c: xfail on hppa*-*-hpux*. * gcc.dg/tree-ssa/cswtch-7.c: Likewise. --- gcc/testsuite/gcc.dg/tree-ssa/cswtch-6.c | 2 +- gcc/testsuite/gcc.dg/tree-ssa/cswtch-7.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/gcc/testsuite/gcc.dg/tree-ssa/cswtch-6.c b/gcc/testsuite/gcc.dg/tree-ssa/cswtch-6.c index b8ebddba3614..a0175c1fb1e6 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/cswtch-6.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/cswtch-6.c @@ -40,4 +40,4 @@ f1 (int v, int w) foo (i, j); } -/* { dg-final { scan-assembler ".rodata.cst16" { xfail { sparc*-*-* && solaris_as } } } } */ +/* { dg-final { scan-assembler ".rodata.cst16" { xfail { { sparc*-*-* && solaris_as } || { hppa*-*-hpux* } } } } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/cswtch-7.c b/gcc/testsuite/gcc.dg/tree-ssa/cswtch-7.c index 209d9955c844..7465696758de 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/cswtch-7.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/cswtch-7.c @@ -45,4 +45,4 @@ f1 (int v, int w) foo (i, j); } -/* { dg-final { scan-assembler ".rodata.cst32" { xfail { sparc*-*-* && solaris_as } } } } */ +/* { dg-final { scan-assembler ".rodata.cst32" { xfail { { sparc*-*-* && solaris_as } || { hppa*-*-hpux* } } } } } */ From e35b8dad030bc4164fdaa81dc0a5bfca8c1bbfc3 Mon Sep 17 00:00:00 2001 From: Andrea Pinski Date: Tue, 25 Aug 2026 14:47:38 -0700 Subject: [PATCH 236/584] cselim: cond_if_else_store_replacement_limited support skipping on store one either side [PR127053] I noticed this while working on std::optional, the full blown cselim with data references hanldes the case where there are a few stores on either side of the branch that don't interfer with the other stores. We could just support clobbers but that would have a similar code except for an extra check for clobbers. So let's just add support for skipping on store on either side of the conditional too. The change to trailing_store_in_bb simplifies some things as already the other side would check on the store being a simple assign, this does not change anything. Note cselim-1.c was reduced from a draft version of this patch which was miscompiling isl. In the whole testsuite the only regressions were in graphite. So I thought it would be a good idea to have a testcase to be added for the miscompiling case. I had forgot some stores could also be loads so another check was needed in that case. This was found by looking into std::optional::reset code gen. Changes since v1: * v2: skip stores and not just clobbers Bootstrapped and tested on x86_64-linux-gnu. PR tree-optimization/127053 gcc/ChangeLog: * tree-ssa-phiopt.cc (trailing_store_in_bb): Rename vphi to vuse_only. (cond_if_else_store_replacement_limited): Add case if cond_if_else_store_replacement_1 failed, allowing for skipping one store on each side. (trailing_store_in_bb): Require the store stmt to be a gimple simple assign. gcc/testsuite/ChangeLog: * g++.dg/tree-ssa/cselim-2.C: New test. * gcc.dg/torture/cselim-1.c: New test. Signed-off-by: Andrea Pinski --- gcc/testsuite/g++.dg/tree-ssa/cselim-2.C | 23 ++++++++++ gcc/testsuite/gcc.dg/torture/cselim-1.c | 34 ++++++++++++++ gcc/tree-ssa-phiopt.cc | 56 +++++++++++++++++++++--- 3 files changed, 107 insertions(+), 6 deletions(-) create mode 100644 gcc/testsuite/g++.dg/tree-ssa/cselim-2.C create mode 100644 gcc/testsuite/gcc.dg/torture/cselim-1.c diff --git a/gcc/testsuite/g++.dg/tree-ssa/cselim-2.C b/gcc/testsuite/g++.dg/tree-ssa/cselim-2.C new file mode 100644 index 000000000000..9c040f9d1839 --- /dev/null +++ b/gcc/testsuite/g++.dg/tree-ssa/cselim-2.C @@ -0,0 +1,23 @@ +// PR tree-optimization/127053 +// { dg-do compile } +// { dg-options "-O2 -ftree-cselim -fdump-tree-phiopt1-details" } +// testcase reduced from std::optional::reset. + +void sink(int*); +typedef int T; + +int f(int b, T *c) +{ + int a; + sink(&a); + if (b) + { + a = 0; + c->~T(); + } + else + a = 0; + return a; +} + +// { dg-final { scan-tree-dump "factoring out stores" "phiopt1" } } diff --git a/gcc/testsuite/gcc.dg/torture/cselim-1.c b/gcc/testsuite/gcc.dg/torture/cselim-1.c new file mode 100644 index 000000000000..4133f627b26f --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/cselim-1.c @@ -0,0 +1,34 @@ +/* { dg-do run } */ + +/* CS-ELIM was miscompiling this + by moving the store of v1.t across + the load of v1 in `v2 = v1`. */ + +/* This was reduced from isl manually. */ + +struct s1 { + int t; +}; + +struct s1 v1, v2; + +[[gnu::noipa]] +void f(int a) { + if (a) { + v1.t = 1; + v2 = v1; + } else { + v1.t = 2; + v2 = v1; + } +} + +int main() +{ + f(1); + if (v2.t != 1) + __builtin_abort (); + f(0); + if (v2.t != 2) + __builtin_abort (); +} diff --git a/gcc/tree-ssa-phiopt.cc b/gcc/tree-ssa-phiopt.cc index 84a7949583d6..7e13c8ff129f 100644 --- a/gcc/tree-ssa-phiopt.cc +++ b/gcc/tree-ssa-phiopt.cc @@ -3503,12 +3503,12 @@ cond_if_else_store_replacement_1 (basic_block then_bb, basic_block else_bb, } /* Return the last store in BB with VDEF or NULL if there are - loads following the store. VPHI is where the only use of the + loads following the store. VUSE_ONLY is where the only use of the vdef should be. If ONLYONESTORE is true, then the store is the only store in the BB. */ static gimple * -trailing_store_in_bb (basic_block bb, tree vdef, gphi *vphi, bool onlyonestore) +trailing_store_in_bb (basic_block bb, tree vdef, gimple *vuse_only, bool onlyonestore) { if (SSA_NAME_IS_DEFAULT_DEF (vdef)) return NULL; @@ -3524,14 +3524,17 @@ trailing_store_in_bb (basic_block bb, tree vdef, gphi *vphi, bool onlyonestore) && gimple_code (SSA_NAME_DEF_STMT (gimple_vuse (store))) != GIMPLE_PHI) return NULL; + // Needs to be an simple store and not a call. + if (!gimple_assign_single_p (store)) + return NULL; /* Verify there is no load or store after the store, the vdef of the store - should only be used by the vphi joining the 2 bbs. */ + should only be used by the vuse_only. */ use_operand_p use_p; gimple *use_stmt; if (!single_imm_use (gimple_vdef (store), &use_p, &use_stmt)) return NULL; - if (use_stmt != vphi) + if (use_stmt != vuse_only) return NULL; return store; @@ -3854,8 +3857,49 @@ cond_if_else_store_replacement_limited (basic_block then_bb, basic_block else_bb if (!else_assign) return false; - return cond_if_else_store_replacement_1 (then_bb, else_bb, join_bb, - then_assign, else_assign, vphi); + if (!cond_if_else_store_replacement_1 (then_bb, else_bb, join_bb, + then_assign, else_assign, vphi)) + { + gimple *then_n, *else_n; + + // Try to see if one "store" can be skipped on either side. + if (!flag_expensive_optimizations) + return false; + then_n = trailing_store_in_bb (then_bb, gimple_vuse (then_assign), + then_assign, true); + if (then_n) + { + ao_ref then_ref_n; + ao_ref_init (&then_ref_n, gimple_assign_lhs (then_n)); + if (stmt_may_clobber_ref_p_1 (then_assign, &then_ref_n, false) + || ref_maybe_used_by_stmt_p (then_assign, &then_ref_n, false)) + then_n = nullptr; + } + else_n = trailing_store_in_bb (else_bb, gimple_vuse (else_assign), + else_assign, true); + if (else_n) + { + ao_ref else_ref_n; + ao_ref_init (&else_ref_n, gimple_assign_lhs (else_n)); + if (stmt_may_clobber_ref_p_1 (else_assign, &else_ref_n, false) + || ref_maybe_used_by_stmt_p (else_assign, &else_ref_n, false)) + else_n = nullptr; + } + if (then_n + && cond_if_else_store_replacement_1 (then_bb, else_bb, join_bb, + then_n, else_assign, vphi)) + return true; + if (else_n + && cond_if_else_store_replacement_1 (then_bb, else_bb, join_bb, + then_assign, else_n, vphi)) + return true; + if (else_n && then_n + && cond_if_else_store_replacement_1 (then_bb, else_bb, join_bb, + then_n, else_n, vphi)) + return true; + return false; + } + return true; } /* Conditional store replacement. We already know From e741ce45698e48d376fa50e474935adaa55efaf8 Mon Sep 17 00:00:00 2001 From: John David Anglin Date: Sat, 19 Sep 2026 15:50:36 -0400 Subject: [PATCH 237/584] Xfail pr125734.c on hppa*-*-hpux* hppa*-*-hpux* doesn't use CLZ. 2026-09-19 John David Anglin gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/pr125734.c: xfail on hppa*-*-hpux*. --- gcc/testsuite/gcc.dg/tree-ssa/pr125734.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr125734.c b/gcc/testsuite/gcc.dg/tree-ssa/pr125734.c index f8d76c4599c9..0b9ec012528e 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/pr125734.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr125734.c @@ -29,4 +29,4 @@ nlz32_negative (int b) return c; } -/* { dg-final { scan-tree-dump-times "\\.CLZ" 1 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "\\.CLZ" 1 "optimized" { xfail hppa*-*-hpux* } } } */ From de4b2b0c4e4f19b007b5d31c9f0d7dc1f1ed5a5d Mon Sep 17 00:00:00 2001 From: Michiel Derhaeg Date: Sat, 19 Sep 2026 21:57:25 +0200 Subject: [PATCH 238/584] MAINTAINERS: Add myself to write after approval ChangeLog: * MAINTAINERS: Regenerate. * MAINTAINERS.yml: Add myself. --- MAINTAINERS | 1 + MAINTAINERS.yml | 11 +++++++++++ 2 files changed, 12 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 51c5eb206514..8b033d98aaf7 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -465,6 +465,7 @@ Bud Davis bdavis Jerry DeLisle jvdelisle DJ Delorie dj Chris Demetriou cgd +Michiel Derhaeg michiel Sameera Deshpande sameerad Wilco Dijkstra wilco Dimitar Dimitrov dimitar diff --git a/MAINTAINERS.yml b/MAINTAINERS.yml index 8fd8456ea967..01497c627f29 100644 --- a/MAINTAINERS.yml +++ b/MAINTAINERS.yml @@ -1337,6 +1337,17 @@ users: inactive: true inactive_email: - jdennett@google.com +- sn: Derhaeg + cn: Michiel Derhaeg + email: + - michiel.derhaeg@globalfoundries.com + - michiel@derhaeg.be + - michiel@gcc.gnu.org + roles: + - WriteAfter + account: michiel + inactive_email: + - michiel@synopsys.com - sn: Deshpande cn: Sameera Deshpande email: From a566f9efe1652b294e424e21e9910de2a011f4f1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B8rgen=20Kvalsvik?= Date: Sat, 19 Sep 2026 21:48:34 +0200 Subject: [PATCH 239/584] Fix function summaries with suppressed blocks I found these while writing a test case for function summaries. The coverage.paths field was updated with the wrong count, which would for function summaries lead obviously wrong output like: 'Prime paths covered:0.00% of -1 (2 of 1 suppressed)' The numbers in the gcov report itself were fine. The missing else cause 'No conditions' to be output when it shouldn't: Calls executed:50.00% of 2 Condition outcomes covered:50.00% of 4 No conditions I apparently never tried these exact combinations with function summaries, which are occasionally useful, but I mostly used the detailed reports. gcc/ChangeLog: * gcov.cc (add_path_counts): Read the right field paths.size. (function_summary): Add missing else. --- gcc/gcov.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/gcc/gcov.cc b/gcc/gcov.cc index ceed689c1c98..bab0f893f034 100644 --- a/gcc/gcov.cc +++ b/gcc/gcov.cc @@ -3315,7 +3315,7 @@ add_condition_counts (coverage_info *coverage, const block_info *block) static void add_path_counts (coverage_info &coverage, const function_info &fn) { - coverage.paths += fn.paths.path_count (); + coverage.paths += fn.paths.paths.size (); coverage.paths_covered += fn.paths.covered_paths (); coverage.paths_suppressed += fn.paths.suppressed_count (); } @@ -3441,7 +3441,7 @@ function_summary (const coverage_info *coverage) format_gcov (coverage->conditions_covered, coverage->conditions, 2), coverage->conditions); - if (coverage->conditions && coverage->conditions_suppressed > 0) + else if (coverage->conditions && coverage->conditions_suppressed > 0) fnotice (stdout, "Condition outcomes covered:%s of %d" " (%d of %d suppressed)\n", format_gcov (coverage->conditions_covered, From 311dfcad0ed8164e944921f8cdf61a3e059cb89b Mon Sep 17 00:00:00 2001 From: Robert Dubner Date: Sat, 19 Sep 2026 18:07:29 -0400 Subject: [PATCH 240/584] cobol: Eliminate -Werror failure. A -Werror failure was caused by an unused static function. This patch comments it out. gcc/cobol/ChangeLog: * parse.y: Comment out unused passby_str() function. --- gcc/cobol/parse.y | 3 +++ 1 file changed, 3 insertions(+) diff --git a/gcc/cobol/parse.y b/gcc/cobol/parse.y index 3bbf60e17e75..575a27276009 100644 --- a/gcc/cobol/parse.y +++ b/gcc/cobol/parse.y @@ -13066,6 +13066,7 @@ bad_arg( const char name[], return ok; } +#if 0 static const char * passby_str(int mask) { @@ -13083,6 +13084,8 @@ passby_str(int mask) return "UNKNOWN PASSING METHOD"; } +#endif + // Verify provided actual parameters against formals. static void From 206056398d9410e12a0110787b4f37d0451e513d Mon Sep 17 00:00:00 2001 From: "Jose E. Marchesi" Date: Sun, 20 Sep 2026 00:48:56 +0200 Subject: [PATCH 241/584] a68: several fixes in ga68.vw Signed-off-by: Jose E. Marchesi gcc/algol68/ChangeLog * ga68.vw: Typos fixed, section 8.0.1 added, consistent {x} style to refer to rules within pragmatics. --- gcc/algol68/ga68.vw | 52 +++++++++++++++++++++++++++------------------ 1 file changed, 31 insertions(+), 21 deletions(-) diff --git a/gcc/algol68/ga68.vw b/gcc/algol68/ga68.vw index 2f3ef144da0f..d5fcab775465 100644 --- a/gcc/algol68/ga68.vw +++ b/gcc/algol68/ga68.vw @@ -272,7 +272,7 @@ f) *NEST range : "variables". The former are either a denotation or an identifier of some mode. The second are identifiers of a "reference to" mode. } -{ The rule f introduces a paranotion for all the constructs that +{ The rule {f} introduces a paranotion for all the constructs that introduce new ranges. } 3.1 Closed clauses @@ -539,7 +539,7 @@ i) WHETHER NEST filters EMPTY out of EMPTY{h} : WHETHER true. d) A PUB B } -{ In rule b, the 'invoke TAU's enveloped by 'INKS' represent those +{ In rule {b}, the 'invoke TAU's enveloped by 'INKS' represent those modules which might need to be invoked at any module-call whose applied-module-indication identified a particular defining-module-indication, whereas those enveloped by 'INKSETY' @@ -550,13 +550,13 @@ i) WHETHER NEST filters EMPTY out of EMPTY{h} : WHETHER true. that all modules now invoked will never be invoked again within those descendents. } -{ Rule f ensures the independence of declarations revealed by one +{ Rule {f} ensures the independence of declarations revealed by one revelation; thus MODULE A = DEF PUB REAL x FED, B = DEF PUB REAL x FED; ACCESS A, B (x) - is not produced. However, rule e allows a given declaration to be + is not produced. However, rule {e} allows a given declaration to be revealed by two public accesses of the same module, as in MODULE A = DEF PUB REAL x FED; @@ -634,11 +634,11 @@ e) NEST declaration with DECSETY without DECSETY1{49e} : and also{94f} token, NEST declaration with DECSETY3 without DECSETY1{e}. -{ Rule e determines how a "NEST declaration with DECSETY without +{ Rule {e} determines how a "NEST declaration with DECSETY without DECSETY1" results into two groups of declarations. The declarations in 'DECSETY' are public and syntactically preceded by PUB. The - declarations in 'DECSETY1 are non-public and are not marked by - PUB. } + declarations in 'DECSETY1 are non-public and are not marked by PUB. + } 4.2 Mode declarations @@ -838,12 +838,12 @@ g) WHETHER MOIDS ravels to MOODS{g,46s} : mode if they have the same number of fields with the same tags and their modes deflex. } -{ The hyperrule f) implements a predicate that determines whether two +{ The hyperrule {f} implements a predicate that determines whether two provided sets of moods are incestuous, i.e. whether they contain modes which are firmly related. } -{ The hyperrule g) determines whether a set of moods and - united modes may be ravelled. } +{ The hyperrule {g} determines whether a set of moods and united modes + may be ravelled. } 4.8 Indicators and field selectors @@ -968,11 +968,11 @@ g) *module text : f) POSTLUDE close (f) } -{ Note that the EMPTY (for PROPSETY) in rule f enforces that a module - postlude cannot contain declarations, labels or module accesses. - Only units are allowed. } +{ Note that the EMPTY (for PROPSETY) in rule {f} enforces that a + module postlude cannot contain declarations, labels or module + accesses. Only units are allowed. } -{ Rule b ensures that a unique 'TAU' is associated with each +{ Rule {b} ensures that a unique 'TAU' is associated with each module-text accessible from any given point in the program. This is used to ensure that an invoke ATU' can be identified in the nest of all descendent constructs of any access-clause or module-text which @@ -1391,7 +1391,7 @@ b) widened to{61A} structured with SIZETY real field letter r letter e SIZETY real field letter i letter m mode FORM : MEEK{61C} SIZETY real FORM ; widened to{a} SIZETY real FORM. -c) widened to{61A} row of boolean FORM : MEEK{61C} BIT FORM. +c) widened to{61A} row of boolean FORM : MEEK{61C} BITS FORM. d) widened to{61A} row of character FORM : MEEK{61C} BYTES FORM. { Examples: @@ -1631,6 +1631,12 @@ d) WHETHER (procedure with) shields SAFE to yin yang SAFE{73c} : 8 Denotations +8.0.1 Syntax + +a) MOID NEST denoter{5D,A341i} : + pragment{92a} sequence option, + MOID denotation{810a,811a,812a,813a,814a,815a,82a,b,c,83a,-}. + 8.1 Plain denotations 8.1.0.1 Syntax @@ -1640,7 +1646,7 @@ B) *NUMERAL :: fixed point numeral ; variable point numeral ; floating point numeral. a) SIZE INTREAL denotation{a,80a} : - SIZE symbol{94d}, INTREAL, denotation{a,811a,812a}. + SIZE symbol{94d}, INTREAL denotation{a,811a,812a}. b) *plain denotation : PLAIN denotation{a,811a,812a,813a,814a} ; void denotation{815a}. @@ -1648,6 +1654,10 @@ b) *plain denotation : { Example: a) LONG 0 } +{ Note how rule {a} might lead to situations like `long short integral + denotation' but these will eventually result in a blind alley + in {80a} due to MOID not generating `long short integral'. } + 8.1.1 Integral denotations 8.1.1.1 Syntax @@ -1700,7 +1710,7 @@ j) plusminus{i} : plus symbol{94c} ; mius symbol{94c}. 8.1.3.1 Syntax -a) boolean denotation{80a} : true{94b} symbol ; false{94b} smbol. +a) boolean denotation{80a} : true{94b} symbol ; false{94b} symbol. { Examples: a) TRUE @@ -1754,7 +1764,7 @@ a) structured with row of boolean field long{94d} symbol, structured with row of boolean field LENGTHETY letter aleph mode denotation{a,c}. b) structured with row of boolean field - SHORT SHORTHTETY letter aleph mode denotation{b,80a} : + SHORT SHORTHETY letter aleph mode denotation{b,80a} : short{94d} symbol, structured with row of boolean field SHORTHETY letter aleph mode denotation{b,c}. c) structured wih row of boolean field @@ -1974,12 +1984,12 @@ k) *digit symbol : DIGIT symbol{94b}. packets when taken in conjunction with the particular-program BEGIN NEST "abc" END } -{ In rule a above, 'MODSETY' envelops the 'MOD's defined by al the +{ In rule {a} above, 'MODSETY' envelops the 'MOD's defined by al the definition-module-packets that are being stuffed along with the stuffing-packet. - In rules c and d, 'MODSETY1' need only envelop the 'MOD's for those - modules actually accessed from within that packet. + In rules {c} and {d}, 'MODSETY1' need only envelop the 'MOD's for + those modules actually accessed from within that packet. The semantics related to packets are only defined if, for a collection of packets being stuffed together, all the 'MOD's From 1d34a925554d036e159abb87418d86d59feadc07 Mon Sep 17 00:00:00 2001 From: GCC Administrator Date: Sun, 20 Sep 2026 00:16:29 +0000 Subject: [PATCH 242/584] Daily bump. --- ChangeLog | 5 ++++ gcc/ChangeLog | 49 +++++++++++++++++++++++++++++++++ gcc/DATESTAMP | 2 +- gcc/algol68/ChangeLog | 61 +++++++++++++++++++++++++++++++++++++++++ gcc/cobol/ChangeLog | 4 +++ gcc/testsuite/ChangeLog | 50 +++++++++++++++++++++++++++++++++ 6 files changed, 170 insertions(+), 1 deletion(-) diff --git a/ChangeLog b/ChangeLog index d3f15ca7059d..a594f7ea5c30 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,8 @@ +2026-09-19 Michiel Derhaeg + + * MAINTAINERS: Regenerate. + * MAINTAINERS.yml: Add myself. + 2026-09-10 Rohith Kapelli * MAINTAINERS.yml: Add myself to Write After Approval and DCO. diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 469fe772ff7d..c3742144078c 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,52 @@ +2026-09-19 Jørgen Kvalsvik + + * gcov.cc (add_path_counts): Read the right field paths.size. + (function_summary): Add missing else. + +2026-09-19 Andrea Pinski + + PR tree-optimization/127053 + * tree-ssa-phiopt.cc (trailing_store_in_bb): Rename vphi to + vuse_only. + (cond_if_else_store_replacement_limited): Add case if + cond_if_else_store_replacement_1 failed, allowing + for skipping one store on each side. + (trailing_store_in_bb): Require the store stmt + to be a gimple simple assign. + +2026-09-19 Yongqiang Tian + + PR target/127460 + * config/pru/pru.cc (pru_insert_loop_label_last): Ignore debug + instructions while counting final loop opcodes. + +2026-09-19 panciyan + + * function.cc (assign_parm_find_stack_rtl): When data->partial is + nonzero, limit the stack slot alignment to the largest power of + two dividing the partial size. + +2026-09-19 Milan Tripkovic + + PR target/127374 + * config/riscv/iterators.md (leu): Map gt to le + * config/riscv/zicond.md: Add define_split patterns + +2026-09-19 Dominic P + + * postreload.cc (reload_cse_regs_1): Find the condition of the + predecessor's conditional branch with get_condition, so a comparison + held in the condition-code register is seen. Reject a jump whose + target is not a label. Record the implicit set only where the block + sets the register to that value. + +2026-09-19 Milan Tripkovic + + PR target/126074 + * config/riscv/riscv.cc (riscv_build_integer_1): Add logic to + synthesize constants using shNadd.uw. + (riscv_move_integer): Handle FMA with use_uw for RTL emission. + 2026-09-18 Andrea Pinski PR tree-optimization/125945 diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index 35f33f31d1bf..1abdca3b21ef 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20260919 +20260920 diff --git a/gcc/algol68/ChangeLog b/gcc/algol68/ChangeLog index 7f546983a366..aeae9acb0f19 100644 --- a/gcc/algol68/ChangeLog +++ b/gcc/algol68/ChangeLog @@ -1,3 +1,64 @@ +2026-09-19 Jose E. Marchesi + + * ga68.vw: Typos fixed, section 8.0.1 added, consistent {x} style + to refer to rules within pragmatics. + +2026-09-19 Jose E. Marchesi + + * a68-parser-sprops.cc (make_origin): Initialize properties of the + new origin from a parse node. + (sprops_for_denotation): Pass parse node to make_origin and remove + now superfluous code. + (sprops_for_deproceduring): Likewise. + (sprops_for_proceduring): Likewise. + (sprops_for_loop_clause): Likewise. + (sprops_for_serial_clause): Likewise. + (sprops_for_parallel_clause): Likewise. + (sprops_for_conditional_clause): Likewise. + (sprops_for_case_clause): Likewise. + (sprops_for_collateral_clause): Likewise. + (sprops_for_conformity_clause): Likewise. + (sprops_for_identity_relation): Likewise. + (sprops_for_logical_function): Likewise. + (sprops_for_call): Likewise. + (sprops_for_generator): Likewise. + (sprops_for_formula): Likewise. + (sprops_for_applied_identifier): Likewise. + (sprops_for_assertion): Likewise. + (sprops_for_decl): Likewise. + (sprops_for_unit): Likewise. + +2026-09-19 Jose E. Marchesi + + * a68-parser-sprops.cc (sprops_for_deproceduring): Set BNO. + (sprops_for_proceduring): Likewise. + (sprops_for_loop_clause): Likewise. + (sprops_for_serial_clause): Likewise. + (sprops_for_parallel_clause): Likewise. + (sprops_for_conditional_clause): Likewise. + (sprops_for_case_clause): Likewise. + (sprops_for_collateral_clause): Likewise. + (sprops_for_conformity_clause): Likewise. + (sprops_for_identity_relation): Likewise. + (sprops_for_logical_function): Likewise. + (sprops_for_call): Likewise. + (sprops_for_generator): Likewise. + (sprops_for_formula): Likewise. + (sprops_for_assertion): Likewise. + (sprops_for_decl): Likewise. + (sprops_for_decl): Likewise. + (sprops_for_unit): Likewise. + +2026-09-19 Jose E. Marchesi + + * a68-types.h: Clarify roles of field set by the scope checker in + TAG_T. + +2026-09-19 Jose E. Marchesi + + * a68-parser-scope.cc: Do not claim the scope pass finishes the + parser. + 2026-09-18 Jose E. Marchesi * a68.h: Add prototypes for a68_sprops, a68_yields_value and diff --git a/gcc/cobol/ChangeLog b/gcc/cobol/ChangeLog index 2caca01f8657..66461a148bc7 100644 --- a/gcc/cobol/ChangeLog +++ b/gcc/cobol/ChangeLog @@ -1,3 +1,7 @@ +2026-09-19 Robert Dubner + + * parse.y: Comment out unused passby_str() function. + 2026-09-18 Robert Dubner * gcobol.1: Documentation for the .so search. diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index bf4607722821..4474d21ff3d4 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,53 @@ +2026-09-19 John David Anglin + + * gcc.dg/tree-ssa/pr125734.c: xfail on hppa*-*-hpux*. + +2026-09-19 Andrea Pinski + + PR tree-optimization/127053 + * g++.dg/tree-ssa/cselim-2.C: New test. + * gcc.dg/torture/cselim-1.c: New test. + +2026-09-19 John David Anglin + + * gcc.dg/tree-ssa/cswtch-6.c: xfail on hppa*-*-hpux*. + * gcc.dg/tree-ssa/cswtch-7.c: Likewise. + +2026-09-19 Yongqiang Tian + + PR target/127460 + * gcc.target/pru/pr127460.c: New test. + +2026-09-19 panciyan + + * gcc.target/riscv/zilsd-align-split-arg-1.c: New test. + * gcc.target/riscv/zilsd-align-split-arg-2.c: New test. + * gcc.target/riscv/zilsd-align-split-arg-3.c: New test. + * gcc.target/riscv/zilsd-align-split-arg-4.c: New test. + +2026-09-19 Milan Tripkovic + + PR target/127374 + * gcc.target/riscv/czero-bext.c: Change scan assembler + * gcc.target/riscv/pr127374.c: New test. + +2026-09-19 Dominic P + + * gcc.target/aarch64/postreload-implicit-set-1.c: New test. + * gcc.target/arm/postreload-implicit-set-1.c: New test. + * gcc.target/arm/postreload-implicit-set-2.c: New test. + * gcc.target/i386/postreload-implicit-set-1.c: New test. + +2026-09-19 Jeff Law + + * gcc.target/riscv/rvv/autovec/sat/vec_sat_u_sub_trunc-1-u8.c: Update + test expectations. + +2026-09-19 Milan Tripkovic + + PR target/126074 + * gcc.target/riscv/pr126074.c: New test. + 2026-09-18 Andrea Pinski PR tree-optimization/125945 From 2b6d3cd7aee5cabacc35962e48ed4d96c6cb48d4 Mon Sep 17 00:00:00 2001 From: "Jose E. Marchesi" Date: Sun, 20 Sep 2026 05:13:33 +0200 Subject: [PATCH 243/584] a68: fix overflow detection in long bits denotations Signed-off-by: Jose E. Marchesi gcc/algol68/ChangeLog * a68-low-units.cc (a68_lower_denotation): strtoul can return errno /= 0 in overflow. gcc/testsuite/ChangeLog * algol68/compile/error-bits-denotation-1.a68: Test for overflow of bits and long bits. --- gcc/algol68/a68-low-units.cc | 3 +-- gcc/testsuite/algol68/compile/error-bits-denotation-1.a68 | 5 +++++ 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/gcc/algol68/a68-low-units.cc b/gcc/algol68/a68-low-units.cc index ed92a1fd5178..ac7accd9051a 100644 --- a/gcc/algol68/a68-low-units.cc +++ b/gcc/algol68/a68-low-units.cc @@ -301,8 +301,7 @@ a68_lower_denotation (NODE_T *p, LOW_CTX_T ctx) #else uint64_t val = strtoull (end, &end, radix); #endif - gcc_assert (errno == 0 && end[0] == '\0'); - + gcc_assert (end[0] == '\0'); uint64_t max_positive = uint64_t (wi::max_value (type).to_uhwi ()); if (errno == ERANGE || val > max_positive) { diff --git a/gcc/testsuite/algol68/compile/error-bits-denotation-1.a68 b/gcc/testsuite/algol68/compile/error-bits-denotation-1.a68 index 455007c29056..75bf07bf3b08 100644 --- a/gcc/testsuite/algol68/compile/error-bits-denotation-1.a68 +++ b/gcc/testsuite/algol68/compile/error-bits-denotation-1.a68 @@ -2,5 +2,10 @@ begin short short bits a = short short 10r256; { dg-error "denotation is too large for short short bits" } short bits b = short 16rffff1; { dg-error "denotation is too large for short bits" } + bits c + = 16rffffffff1; { dg-error "denotation is too large for bits" } + long bits d + = long 16rffffffffffffffff1; { dg-error "denotation is too large for long bits" } + skip end From 5dc4ab23e0d01a1fd20c1365bdb2de039d831ff9 Mon Sep 17 00:00:00 2001 From: Stefan Schulze Frielinghaus Date: Sun, 20 Sep 2026 09:19:50 +0200 Subject: [PATCH 244/584] expand_mult: Look through vector mode When expand_mult handles a constant vector multiplier where the scalar operand is a CONST_WIDE_INT, then also look through the vector mode while determining the shift amount since here we need the scalar mode. Note, when we call later on into expand_shift we need the vector mode, i.e., only for the shift amount we need the scalar mode. PR middle-end/127474 gcc/ChangeLog: * expmed.cc (expand_mult): Look through vector mode. gcc/testsuite/ChangeLog: * gcc.dg/torture/pr127474.c: New test. --- gcc/expmed.cc | 4 +++- gcc/testsuite/gcc.dg/torture/pr127474.c | 12 ++++++++++++ 2 files changed, 15 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.dg/torture/pr127474.c diff --git a/gcc/expmed.cc b/gcc/expmed.cc index c6494484251f..b82c0bb10db1 100644 --- a/gcc/expmed.cc +++ b/gcc/expmed.cc @@ -3633,7 +3633,9 @@ expand_mult (machine_mode mode, rtx op0, rtx op1, rtx target, else if (CONST_DOUBLE_AS_INT_P (scalar_op1)) #endif { - int shift = wi::exact_log2 (rtx_mode_t (scalar_op1, mode)); + machine_mode scalar_mode = VECTOR_MODE_P (mode) + ? GET_MODE_INNER (mode) : mode; + int shift = wi::exact_log2 (rtx_mode_t (scalar_op1, scalar_mode)); /* Perfect power of 2 (other than 1, which is handled above). */ if (shift > 0) return expand_shift (LSHIFT_EXPR, mode, op0, diff --git a/gcc/testsuite/gcc.dg/torture/pr127474.c b/gcc/testsuite/gcc.dg/torture/pr127474.c new file mode 100644 index 000000000000..b0f63fda042b --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr127474.c @@ -0,0 +1,12 @@ +/* { dg-do compile } */ +/* { dg-require-effective-target int128 } */ +/* { dg-additional-options "-march=z17" { target s390x-*-* } } */ + +/* Previously we ICE'd in expand_mult when dealing with a CONST_WIDE_INT. */ + +typedef __int128 v1ti __attribute__ ((vector_size (16))); + +v1ti foo (v1ti x) +{ + return x * (v1ti){(__int128)123456789 << 64 | (__int128)123456789}; +} From b197afc3746ffd256ec1839bbd8b51d7bfe4e594 Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Sat, 15 Aug 2026 16:38:56 +0200 Subject: [PATCH 245/584] match-sat-alu.pd: Allow wider ranges for signed saturating truncation Signed saturating truncation currently requires the unsigned range type to have the same precision as the signed input. This rejects a wider range type even though it preserves every input value. Allow the range type to be at least as wide as the input. Continue to require a result narrower than the input. Construct the offset and limit constants at the range precision. Use wide-int operations that do not depend on host-width shifts. Tests cover a valid 16-bit input with a 32-bit range and an 8-bit result. They also verify that a 17-bit range for a 32-bit input remains rejected because it can discard input bits. With AArch64 -O3 -march=armv8-a -mmax-vectorization and --param=vect-epilogues-nomask=0: before, 16 elements per iteration: ldp q28, q27, [x3], 32 uzp1 v26.16b, v28.16b, v27.16b saddl v0.4s, v28.4h, v31.4h saddl2 v24.4s, v28.8h, v31.8h saddl v23.4s, v27.4h, v31.4h saddl2 v25.4s, v27.8h, v31.8h ushr v28.8h, v28.8h, 15 ushr v27.8h, v27.8h, 15 cmhi v0.4s, v0.4s, v30.4s cmhi v24.4s, v24.4s, v30.4s cmhi v23.4s, v23.4s, v30.4s cmhi v25.4s, v25.4s, v30.4s uzp1 v27.16b, v28.16b, v27.16b uzp1 v24.8h, v0.8h, v24.8h uzp1 v25.8h, v23.8h, v25.8h neg v27.16b, v27.16b uzp1 v25.16b, v24.16b, v25.16b eor v27.16b, v27.16b, v29.16b bif v27.16b, v26.16b, v25.16b str q27, [x4], 16 after, 8 elements per iteration: ldr q31, [x1, x4] sqxtn v31.8b, v31.8h str d31, [x0, x3] Bootstrapped and tested on aarch64-none-linux-gnu. Tested on x86_64-pc-linux-gnu. gcc/ChangeLog: * match-sat-alu.pd (signed_integer_sat_trunc): Allow a wider lossless unsigned range type. Continue to require a narrowing result. Construct the expected constants at the range precision. gcc/testsuite/ChangeLog: * gcc.dg/vect/vect-sat-trunc-range-precision-1.c: New test. * gcc.target/aarch64/vect-sat-trunc-range-precision-1.c: Likewise. * gcc.target/aarch64/vect-sat-trunc-range-precision-negative-1.c: Likewise. Signed-off-by: Kyrylo Tkachov --- gcc/match-sat-alu.pd | 29 ++--- .../vect/vect-sat-trunc-range-precision-1.c | 121 ++++++++++++++++++ .../vect-sat-trunc-range-precision-1.c | 7 + ...ect-sat-trunc-range-precision-negative-1.c | 24 ++++ 4 files changed, 166 insertions(+), 15 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/vect/vect-sat-trunc-range-precision-1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-range-precision-1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-range-precision-negative-1.c diff --git a/gcc/match-sat-alu.pd b/gcc/match-sat-alu.pd index 9cbea1e668bb..58dd8696b603 100644 --- a/gcc/match-sat-alu.pd +++ b/gcc/match-sat-alu.pd @@ -490,25 +490,24 @@ along with GCC; see the file COPYING3. If not see (negate (nop_convert? (convert (lt @0 integer_zerop))))) INTEGER_CST@3) (convert @0)) - /* The comparison has to be the unsigned reinterpretation of X, and the - conversion has to narrow, otherwise the constants below do not have the - precision the comparison is carried out at. */ - (if (!TYPE_UNSIGNED (TREE_TYPE (@0)) && TYPE_UNSIGNED (TREE_TYPE (@4)) - && TYPE_PRECISION (TREE_TYPE (@4)) == TYPE_PRECISION (TREE_TYPE (@0)) - && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (@0))) + /* The comparison type has to be unsigned and at least as wide as X. A + narrower type would examine only the low bits of X. The result + conversion has to narrow X. */ + (if (!TYPE_UNSIGNED (TREE_TYPE (@0)) + && TYPE_UNSIGNED (TREE_TYPE (@4)) + && (TYPE_PRECISION (TREE_TYPE (@4)) + >= TYPE_PRECISION (TREE_TYPE (@0))) + && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (@0))) (with { - unsigned itype_prec = TYPE_PRECISION (TREE_TYPE (@0)); unsigned otype_prec = TYPE_PRECISION (type); - wide_int offset = wi::uhwi (HOST_WIDE_INT_1U << (otype_prec - 1), - itype_prec); // Aka 128 for int8_t - wide_int limit_0 = wi::mask (otype_prec, false, itype_prec); // Aka 255 - wide_int limit_1 = wi::uhwi ((HOST_WIDE_INT_1U << otype_prec) - 3, - itype_prec); // Aka 253 - wide_int limit_2 = wi::uhwi ((HOST_WIDE_INT_1U << otype_prec) - 2, - itype_prec); // Aka 254 + unsigned range_prec = TYPE_PRECISION (TREE_TYPE (@4)); + wide_int offset = wi::set_bit_in_zero (otype_prec - 1, range_prec); + wide_int limit_0 = wi::mask (otype_prec, false, range_prec); // Aka 255 + wide_int limit_1 = limit_0 - 2; // Aka 253 + wide_int limit_2 = limit_0 - 1; // Aka 254 wide_int otype_max = wi::mask (otype_prec - 1, false, otype_prec); - wide_int itype_max = wi::mask (otype_prec - 1, false, itype_prec); + wide_int itype_max = wi::mask (otype_prec - 1, false, range_prec); wide_int int_cst_1 = wi::to_wide (@1); wide_int int_cst_2 = wi::to_wide (@2); wide_int int_cst_3 = wi::to_wide (@3); diff --git a/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-range-precision-1.c b/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-range-precision-1.c new file mode 100644 index 000000000000..33649e9a2840 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-range-precision-1.c @@ -0,0 +1,121 @@ +/* { dg-do run { target bitint } } */ +/* { dg-additional-options "-O3 -fvect-cost-model=unlimited" } */ + +typedef __INT8_TYPE__ int8_t; +typedef __INT16_TYPE__ int16_t; +typedef __INT32_TYPE__ int32_t; +typedef __UINT16_TYPE__ uint16_t; +typedef __UINT32_TYPE__ uint32_t; +typedef signed _BitInt(16) int16b_t; +typedef unsigned _BitInt(17) uint17_t; + +#define N 259 +#define SAT_VALUE(OUT, X, MAX) ((OUT) (-((OUT) ((X) < 0)) ^ (OUT) MAX)) + +__attribute__((noipa)) +static void +wide_range (int8_t *__restrict out, const int16b_t *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + int16b_t source = in[i]; + uint32_t range = (uint32_t) source + 128U; + out[i] = (range > 255U + ? SAT_VALUE (int8_t, source, 127) : (int8_t) source); + } +} + +__attribute__((noipa)) +static void +narrow_range (int16_t *__restrict out, const int32_t *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + int32_t source = in[i]; + uint17_t range = (uint17_t) source + (uint17_t) 32768; + out[i] = (range > (uint17_t) 65535 + ? SAT_VALUE (int16_t, source, 32767) : (int16_t) source); + } +} + +__attribute__((noipa, optimize ("O0"))) +static void +wide_range_ref (int8_t *out, const int16b_t *in, int n) +{ + for (int i = 0; i < n; ++i) + { + int16b_t source = in[i]; + if (source < -128) + out[i] = -128; + else if (source > 127) + out[i] = 127; + else + out[i] = (int8_t) source; + } +} + +__attribute__((noipa, optimize ("O0"))) +static void +narrow_range_ref (int16_t *out, const int32_t *in, int n) +{ + for (int i = 0; i < n; ++i) + { + int32_t source = in[i]; + uint17_t range = (uint17_t) source + (uint17_t) 32768; + out[i] = (range > (uint17_t) 65535 + ? SAT_VALUE (int16_t, source, 32767) : (int16_t) source); + } +} + +static void +check_wide_range (void) +{ + int8_t out[N]; + int8_t ref[N]; + int16b_t in[N]; + + for (int i = 0; i < N; ++i) + in[i] = (uint16_t) i * 40503U + 97U; + + for (int n = 0; n <= N; ++n) + { + for (int i = 0; i < N; ++i) + out[i] = ref[i] = 23; + wide_range (out, in, n); + wide_range_ref (ref, in, n); + for (int i = 0; i < N; ++i) + if (out[i] != ref[i]) + __builtin_abort (); + } +} + +static void +check_narrow_range (void) +{ + int16_t out[N]; + int16_t ref[N]; + int32_t in[N]; + + for (int i = 0; i < N; ++i) + in[i] = (int32_t) ((uint32_t) i * 2654435761U + 1013904223U); + in[0] = 131072; + + for (int n = 0; n <= N; ++n) + { + for (int i = 0; i < N; ++i) + out[i] = ref[i] = 23; + narrow_range (out, in, n); + narrow_range_ref (ref, in, n); + for (int i = 0; i < N; ++i) + if (out[i] != ref[i]) + __builtin_abort (); + } +} + +int +main (void) +{ + check_wide_range (); + check_narrow_range (); + return 0; +} diff --git a/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-range-precision-1.c b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-range-precision-1.c new file mode 100644 index 000000000000..c52b309cbe1d --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-range-precision-1.c @@ -0,0 +1,7 @@ +/* { dg-do compile { target bitint } } */ +/* { dg-options "-O3 -march=armv8-a" } */ +/* { dg-additional-options "-mmax-vectorization --param=vect-epilogues-nomask=0 -fdump-tree-vect-details" } */ + +#include "../../gcc.dg/vect/vect-sat-trunc-range-precision-1.c" + +/* { dg-final { scan-tree-dump-times "sat_trunc pattern recognized" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-range-precision-negative-1.c b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-range-precision-negative-1.c new file mode 100644 index 000000000000..8c30f8d76329 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-range-precision-negative-1.c @@ -0,0 +1,24 @@ +/* { dg-do compile { target bitint } } */ +/* { dg-options "-O3 -march=armv8-a" } */ +/* { dg-additional-options "-mmax-vectorization --param=vect-epilogues-nomask=0 -fdump-tree-vect-details" } */ + +typedef __INT16_TYPE__ int16_t; +typedef __INT32_TYPE__ int32_t; +typedef unsigned _BitInt(17) uint17_t; + +#define SAT_VALUE(X) ((int16_t) (-((int16_t) ((X) < 0)) ^ 32767)) + +__attribute__((noipa)) +void +narrow_range (int16_t *__restrict out, const int32_t *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + int32_t source = in[i]; + uint17_t range = (uint17_t) source + (uint17_t) 32768; + out[i] = (range > (uint17_t) 65535 + ? SAT_VALUE (source) : (int16_t) source); + } +} + +/* { dg-final { scan-tree-dump-not "sat_trunc pattern recognized" "vect" } } */ From 0c6332c9fff5a0cb3dcf541e2b0f9c82c61ea182 Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Thu, 30 Jul 2026 18:13:07 +0200 Subject: [PATCH 246/584] match-sat-alu.pd: Recognize signed saturation clamps Signed saturating addition and subtraction can use a wider intermediate that is clamped to the result type bounds: (T) MIN (MAX ((WT) X + (WT) Y, T_MIN), T_MAX) -> .SAT_ADD (X, Y) Recognize addition and subtraction in both clamp nesting orders. Require a signed intermediate that is strictly wider than the result type. This keeps the arithmetic exact before the clamp. Require the outer clamp to have one use so that the replacement removes it. Check signed saturation subtraction when the clamp is rooted at a conversion. AArch64 -O2: before: sxtw x1, w1 add x0, x1, w0, sxtw mov x1, -2147483648 cmp x0, x1 csel x0, x0, x1, ge mov w1, 2147483647 cmp x0, x1 csel x0, x0, x1, le after: fmov s31, w0 fmov s30, w1 sqadd s31, s31, s30 fmov w0, s31 The other clamp forms have the same reduction. Bootstrapped and tested on aarch64-none-linux-gnu. gcc/ChangeLog: * match-sat-alu.pd (signed_integer_sat_add): Add the two sided clamp on a wider intermediate, in both nesting orders. (signed_integer_sat_sub): Likewise. * tree-ssa-math-opts.cc (match_unsigned_saturation_sub): Rename to ... (match_saturation_sub_with_assign): ... this, and ask the signed predicate as well. (math_opts_dom_walker::after_dom_children): Update the callers, and call it for NOP_EXPR. gcc/testsuite/ChangeLog: * gcc.target/aarch64/sat_s_clamp-1.c: New test. * gcc.target/aarch64/sat_s_clamp-2.c: New test. Signed-off-by: Kyrylo Tkachov --- gcc/match-sat-alu.pd | 87 ++++++++++++++++++- .../gcc.target/aarch64/sat_s_clamp-1.c | 78 +++++++++++++++++ .../gcc.target/aarch64/sat_s_clamp-2.c | 43 +++++++++ gcc/tree-ssa-math-opts.cc | 14 +-- 4 files changed, 214 insertions(+), 8 deletions(-) create mode 100644 gcc/testsuite/gcc.target/aarch64/sat_s_clamp-1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/sat_s_clamp-2.c diff --git a/gcc/match-sat-alu.pd b/gcc/match-sat-alu.pd index 58dd8696b603..2f6b842d86e6 100644 --- a/gcc/match-sat-alu.pd +++ b/gcc/match-sat-alu.pd @@ -442,7 +442,52 @@ along with GCC; see the file COPYING3. If not see integer_zerop) (signed_integer_sat_val @0) @2) - (if (wi::eq_p (wi::to_wide (@1), wi::to_wide (@3)))))) + (if (wi::eq_p (wi::to_wide (@1), wi::to_wide (@3))))) + + /* A signed saturating add written as a two sided clamp on a wider + intermediate, which is a common source form and what the integer + promotions leave for a narrow type. Both nesting orders occur: + an if followed by an if or an else if gives MAX then MIN, while + max (min (t, HI), LO) gives MIN then MAX. */ + (match (signed_integer_sat_add @0 @1) + /* WT SUM = (WT)X + (WT)Y + SAT_S_ADD = (T)MIN (MAX (SUM, T_MIN), T_MAX) */ + (convert (min@4 (max (plus (convert @0) (convert @1)) INTEGER_CST@2) + INTEGER_CST@3)) + (if (types_match (type, @0, @1) && single_use (@4)) + (with + { + unsigned precision = TYPE_PRECISION (type); + tree wide_type = TREE_TYPE (@2); + unsigned wide_precision = TYPE_PRECISION (wide_type); + wide_int lo = wide_int::from (wi::min_value (precision, SIGNED), + wide_precision, SIGNED); + wide_int hi = wide_int::from (wi::max_value (precision, SIGNED), + wide_precision, SIGNED); + } + /* One extra bit is enough for a sum of two values of the narrow type, + and at equal precision the clamp is not a saturating add at all. */ + (if (wide_precision > precision && !TYPE_UNSIGNED (wide_type) + && wi::eq_p (wi::to_wide (@2), lo) + && wi::eq_p (wi::to_wide (@3), hi)))))) + (match (signed_integer_sat_add @0 @1) + /* SAT_S_ADD = (T)MAX (MIN (SUM, T_MAX), T_MIN) */ + (convert (max@4 (min (plus (convert @0) (convert @1)) INTEGER_CST@3) + INTEGER_CST@2)) + (if (types_match (type, @0, @1) && single_use (@4)) + (with + { + unsigned precision = TYPE_PRECISION (type); + tree wide_type = TREE_TYPE (@2); + unsigned wide_precision = TYPE_PRECISION (wide_type); + wide_int lo = wide_int::from (wi::min_value (precision, SIGNED), + wide_precision, SIGNED); + wide_int hi = wide_int::from (wi::max_value (precision, SIGNED), + wide_precision, SIGNED); + } + (if (wide_precision > precision && !TYPE_UNSIGNED (wide_type) + && wi::eq_p (wi::to_wide (@2), lo) + && wi::eq_p (wi::to_wide (@3), hi))))))) /* Saturation sub for signed integer. */ (if (INTEGRAL_TYPE_P (type) && !TYPE_UNSIGNED (type)) @@ -479,7 +524,45 @@ along with GCC; see the file COPYING3. If not see (cond^ (ne (imagpart (IFN_SUB_OVERFLOW@2 @0 @1)) integer_zerop) (signed_integer_sat_val @0) (realpart @2)) - (if (types_match (type, @0, @1))))) + (if (types_match (type, @0, @1)))) + /* The same two sided clamp on a wider intermediate, for a subtraction. */ + (match (signed_integer_sat_sub @0 @1) + /* WT DIFF = (WT)X - (WT)Y + SAT_S_SUB = (T)MIN (MAX (DIFF, T_MIN), T_MAX) */ + (convert (min@4 (max (minus (convert @0) (convert @1)) INTEGER_CST@2) + INTEGER_CST@3)) + (if (types_match (type, @0, @1) && single_use (@4)) + (with + { + unsigned precision = TYPE_PRECISION (type); + tree wide_type = TREE_TYPE (@2); + unsigned wide_precision = TYPE_PRECISION (wide_type); + wide_int lo = wide_int::from (wi::min_value (precision, SIGNED), + wide_precision, SIGNED); + wide_int hi = wide_int::from (wi::max_value (precision, SIGNED), + wide_precision, SIGNED); + } + (if (wide_precision > precision && !TYPE_UNSIGNED (wide_type) + && wi::eq_p (wi::to_wide (@2), lo) + && wi::eq_p (wi::to_wide (@3), hi)))))) + (match (signed_integer_sat_sub @0 @1) + /* SAT_S_SUB = (T)MAX (MIN (DIFF, T_MAX), T_MIN) */ + (convert (max@4 (min (minus (convert @0) (convert @1)) INTEGER_CST@3) + INTEGER_CST@2)) + (if (types_match (type, @0, @1) && single_use (@4)) + (with + { + unsigned precision = TYPE_PRECISION (type); + tree wide_type = TREE_TYPE (@2); + unsigned wide_precision = TYPE_PRECISION (wide_type); + wide_int lo = wide_int::from (wi::min_value (precision, SIGNED), + wide_precision, SIGNED); + wide_int hi = wide_int::from (wi::max_value (precision, SIGNED), + wide_precision, SIGNED); + } + (if (wide_precision > precision && !TYPE_UNSIGNED (wide_type) + && wi::eq_p (wi::to_wide (@2), lo) + && wi::eq_p (wi::to_wide (@3), hi))))))) /* Saturation truncate for signed integer. */ (if (INTEGRAL_TYPE_P (type) && !TYPE_UNSIGNED (type)) diff --git a/gcc/testsuite/gcc.target/aarch64/sat_s_clamp-1.c b/gcc/testsuite/gcc.target/aarch64/sat_s_clamp-1.c new file mode 100644 index 000000000000..a8790699ac88 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/sat_s_clamp-1.c @@ -0,0 +1,78 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-optimized" } */ + +#include + +static inline int imin (int a, int b) { return a < b ? a : b; } +static inline int imax (int a, int b) { return a > b ? a : b; } + +/* A signed saturating add or subtract written as a two sided clamp on a + wider intermediate. Both nesting orders appear, and the narrow types + reach this shape through the integer promotions. */ + +int +add_ll (int x, int y) +{ + long long t = (long long) x + y; + if (t > INT_MAX) t = INT_MAX; + if (t < INT_MIN) t = INT_MIN; + return (int) t; +} + +int +add_ll_else (int x, int y) +{ + long long t = (long long) x + y; + if (t > INT_MAX) t = INT_MAX; + else if (t < INT_MIN) t = INT_MIN; + return (int) t; +} + +int +sub_ll (int x, int y) +{ + long long t = (long long) x - y; + if (t > INT_MAX) t = INT_MAX; + if (t < INT_MIN) t = INT_MIN; + return (int) t; +} + +short +add_hi (short x, short y) +{ + int t = x + y; + return (short) imax (imin (t, 32767), -32768); +} + +short +sub_hi (short x, short y) +{ + int t = x - y; + return (short) imin (imax (t, -32768), 32767); +} + +signed char +add_qi (signed char x, signed char y) +{ + int t = x + y; + return (signed char) imax (imin (t, 127), -128); +} + +signed char +sub_qi (signed char x, signed char y) +{ + int t = x - y; + return (signed char) imin (imax (t, -128), 127); +} + +signed char +add_qi_shared (signed char x, signed char y, int *p) +{ + int t = x + y; + int lo = imax (t, -128); + *p = lo; + return (signed char) imin (lo, 127); +} + +/* { dg-final { scan-tree-dump-times "\\.SAT_ADD " 5 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "\\.SAT_SUB " 3 "optimized" } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/sat_s_clamp-2.c b/gcc/testsuite/gcc.target/aarch64/sat_s_clamp-2.c new file mode 100644 index 000000000000..5bdde16fb257 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/sat_s_clamp-2.c @@ -0,0 +1,43 @@ +/* { dg-do compile } */ +/* { dg-options "-O3 -fdump-tree-optimized" } */ + +#include + +static inline int imin (int a, int b) { return a < b ? a : b; } +static inline int imax (int a, int b) { return a > b ? a : b; } + +void +add_loop (short *__restrict d, short *__restrict a, short *__restrict b, int n) +{ + for (int i = 0; i < n; i++) + { + int t = a[i] + b[i]; + d[i] = (short) imax (imin (t, 32767), -32768); + } +} + +void +sat_loop (int *__restrict d, int *__restrict a, int *__restrict b, int n) +{ + for (int i = 0; i < n; i++) + { + long long t = (long long) a[i] + b[i]; + if (t > INT_MAX) t = INT_MAX; + if (t < INT_MIN) t = INT_MIN; + d[i] = (int) t; + } +} + +/* The clamp of an equal precision sum is not a saturating add: the + comparisons are dead and the whole thing is a plain addition. */ + +int +not_saturating (int x, int y) +{ + int t = x + y; + return t > INT_MAX ? INT_MAX : t < INT_MIN ? INT_MIN : t; +} + +/* { dg-final { scan-tree-dump "\\.SAT_ADD " "optimized" } } */ +/* { dg-final { scan-assembler "sqadd\tv\[0-9\]+\.8h" } } */ +/* { dg-final { scan-assembler "sqadd\tv\[0-9\]+\.4s" } } */ diff --git a/gcc/tree-ssa-math-opts.cc b/gcc/tree-ssa-math-opts.cc index 9c959cc84508..2efd70f27f64 100644 --- a/gcc/tree-ssa-math-opts.cc +++ b/gcc/tree-ssa-math-opts.cc @@ -4258,7 +4258,7 @@ match_saturation_add (gimple_stmt_iterator *gsi, gphi *phi) } /* - * Try to match saturation unsigned sub. + * Try to match saturation sub with assign. * _1 = _4 >= _5; * _3 = _4 - _5; * _6 = _1 ? _3 : 0; @@ -4267,12 +4267,13 @@ match_saturation_add (gimple_stmt_iterator *gsi, gphi *phi) * Return true if the statement was replaced. */ static bool -match_unsigned_saturation_sub (gimple_stmt_iterator *gsi, gassign *stmt) +match_saturation_sub_with_assign (gimple_stmt_iterator *gsi, gassign *stmt) { tree ops[2]; tree lhs = gimple_assign_lhs (stmt); - if (gimple_unsigned_integer_sat_sub (lhs, ops, NULL)) + if (gimple_unsigned_integer_sat_sub (lhs, ops, NULL) + || gimple_signed_integer_sat_sub (lhs, ops, NULL)) return build_saturation_binary_arith_call_and_replace (gsi, IFN_SAT_SUB, lhs, ops[0], ops[1]); @@ -7340,7 +7341,7 @@ math_opts_dom_walker::after_dom_children (basic_block bb) continue; } match_arith_overflow (&gsi, stmt, code, m_cfg_changed_p); - match_unsigned_saturation_sub (&gsi, as_a (stmt)); + match_saturation_sub_with_assign (&gsi, as_a (stmt)); break; case PLUS_EXPR: @@ -7349,7 +7350,7 @@ math_opts_dom_walker::after_dom_children (basic_block bb) break; /* fall-through */ case MINUS_EXPR: - if (!match_unsigned_saturation_sub (&gsi, + if (!match_saturation_sub_with_assign (&gsi, as_a (stmt)) && !convert_plusminus_to_widen (&gsi, stmt, code)) { @@ -7390,13 +7391,14 @@ math_opts_dom_walker::after_dom_children (basic_block bb) case COND_EXPR: case BIT_AND_EXPR: - match_unsigned_saturation_sub (&gsi, as_a (stmt)); + match_saturation_sub_with_assign (&gsi, as_a (stmt)); break; case NOP_EXPR: match_unsigned_saturation_mul (&gsi, as_a (stmt)); match_unsigned_saturation_trunc (&gsi, as_a (stmt)); match_saturation_add_with_assign (&gsi, as_a (stmt)); + match_saturation_sub_with_assign (&gsi, as_a (stmt)); /* fall-through */ case CONVERT_EXPR: /* The long-multiply recognizer's high-part emit ends in an From 6833708b4eaf3ce1c22313bc173ff4253becc86b Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Thu, 30 Jul 2026 18:13:06 +0200 Subject: [PATCH 247/584] match-sat-alu.pd: Recognize strict widened unsigned saturation clamps A widened saturating addition can clamp the sum with either of these forms: SUM <= MAX ? SUM : MAX SUM < MAX ? SUM : MAX The strict comparison is canonicalized to SUM <= MAX - 1. It is equivalent because equality makes both arms produce MAX. Accept MAX and MAX - 1 as the comparison limit. AArch64 -O2: before: uxtw x2, w1 add x2, x2, w0, uxtw add w0, w0, w1 mov w1, 4294967294 cmp x2, x1 csinv w0, w0, wzr, ls after: adds w0, w0, w1 csinv w0, w0, wzr, cc Bootstrapped and tested on aarch64-none-linux-gnu. gcc/ChangeLog: * match-sat-alu.pd (unsigned_integer_sat_add): Accept a compare against MAX - 1 in the widened form. gcc/testsuite/ChangeLog: * gcc.target/aarch64/sat_u_add_widen_lt-1.c: New test. Signed-off-by: Kyrylo Tkachov --- gcc/match-sat-alu.pd | 6 +++- .../gcc.target/aarch64/sat_u_add_widen_lt-1.c | 32 +++++++++++++++++++ 2 files changed, 37 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.target/aarch64/sat_u_add_widen_lt-1.c diff --git a/gcc/match-sat-alu.pd b/gcc/match-sat-alu.pd index 2f6b842d86e6..42a4e49e00e6 100644 --- a/gcc/match-sat-alu.pd +++ b/gcc/match-sat-alu.pd @@ -138,8 +138,12 @@ along with GCC; see the file COPYING3. If not see unsigned widen_precision = TYPE_PRECISION (TREE_TYPE (@2)); wide_int max = wi::mask (precision, false, widen_precision); wide_int c4 = wi::to_wide (@4); + /* A source written with < rather than <= puts MAX - 1 in the compare. + The sum equal to MAX then takes the other arm, which is also MAX. */ + wide_int c4_add_1 = wi::add (c4, wi::uhwi (1, widen_precision)); } - (if (wi::eq_p (c4, max) && widen_precision > precision)))))) + (if ((wi::eq_p (c4, max) || wi::eq_p (c4_add_1, max)) + && widen_precision > precision)))))) /* Saturation sub for unsigned integer. */ (if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)) diff --git a/gcc/testsuite/gcc.target/aarch64/sat_u_add_widen_lt-1.c b/gcc/testsuite/gcc.target/aarch64/sat_u_add_widen_lt-1.c new file mode 100644 index 000000000000..114602e2f8fb --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/sat_u_add_widen_lt-1.c @@ -0,0 +1,32 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-optimized" } */ + +typedef unsigned int u32; +typedef unsigned short u16; +typedef unsigned long long u64; + +/* Written with < rather than <=, so the compare holds MAX - 1. The sum + equal to MAX takes the other arm, which is MAX as well. */ + +u32 +lt32 (u32 a, u32 b) +{ + u64 t = (u64) a + b; + return (u32) (t < 0xffffffffull ? t : 0xffffffffull); +} + +u32 +le32 (u32 a, u32 b) +{ + u64 t = (u64) a + b; + return (u32) (t <= 0xffffffffull ? t : 0xffffffffull); +} + +u16 +lt16 (u16 a, u16 b) +{ + u32 t = (u32) a + b; + return (u16) (t < 0xffffu ? t : 0xffffu); +} + +/* { dg-final { scan-tree-dump-times "\\.SAT_ADD " 3 "optimized" } } */ From 49e640dc4675de1f48166906a11950cb6698e77f Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Fri, 21 Aug 2026 15:33:25 +0200 Subject: [PATCH 248/584] match-sat-alu.pd: Recognize signed saturating truncation after a shift An arithmetic right shift preserves its input sign. The range test and conversion can therefore use the shifted value while the saturation value uses the original input: shifted = x >> 8; range = (unsigned int) shifted + 32768; out = range > 65535 ? (short int) (x >> 31) ^ 32767 : (short int) shifted; This is equivalent to .SAT_TRUNC (shifted). Recognize a precision-minus-one sign shift and allow the saturation value to use the original input sign. The sign shift produces zero or minus one, so its optional signed conversion can narrow or extend the value exactly. Require the data shift to be a constant smaller than the input precision. Require the range type to be at least as wide as the shifted value and the output type, so the conversion and clamp constants do not lose bits. With AArch64 -O2 -march=armv8-a -fopenmp-simd: before: ldp d0, d30, [x1] movi v27.2s, 0x80, lsl 8 movi v25.2s, 0xff, msl 8 mvni v31.4h, 0x80, lsl 8 sshr v29.2s, v0.2s, 8 sshr v28.2s, v30.2s, 8 cmlt v0.2s, v0.2s, #0 cmlt v30.2s, v30.2s, #0 add v26.2s, v29.2s, v27.2s add v27.2s, v28.2s, v27.2s uzp1 v30.4h, v0.4h, v30.4h uzp1 v28.4h, v29.4h, v28.4h cmhi v26.2s, v26.2s, v25.2s cmhi v27.2s, v27.2s, v25.2s eor v31.8b, v30.8b, v31.8b uzp1 v27.4h, v26.4h, v27.4h bit v28.8b, v31.8b, v27.8b str d28, [x0] ret after: ldr q31, [x1] sqshrn v31.4h, v31.4s, 8 str d31, [x0] ret The vector sequence becomes one SQSHRN. Runtime tests cover valid and wrapping forms. Target tests cover valid forms, rejected forms, and the related signed saturating addition and subtraction forms. Bootstrapped and tested on aarch64-none-linux-gnu. Tested on x86_64-pc-linux-gnu. gcc/ChangeLog: * match-sat-alu.pd (signed_integer_sat_val): Recognize an arithmetic sign shift. (signed_integer_sat_trunc): Use signed_integer_sat_val in the existing form. Recognize a shifted value with an equivalent pre-shift sign source. gcc/testsuite/ChangeLog: * gcc.dg/vect/vect-sat-trunc-shift-sign-source-1.c: New test. * gcc.target/aarch64/sat_s_val_ashr-1.c: Likewise. * gcc.target/aarch64/vect-sat-trunc-shift-sign-source-1.c: Likewise. * gcc.target/aarch64/vect-sat-trunc-shift-sign-source-negative-1.c: Likewise. Signed-off-by: Kyrylo Tkachov --- gcc/match-sat-alu.pd | 69 +++++- .../vect/vect-sat-trunc-shift-sign-source-1.c | 220 ++++++++++++++++++ .../gcc.target/aarch64/sat_s_val_ashr-1.c | 30 +++ .../vect-sat-trunc-shift-sign-source-1.c | 7 + ...t-sat-trunc-shift-sign-source-negative-1.c | 122 ++++++++++ 5 files changed, 437 insertions(+), 11 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/vect/vect-sat-trunc-shift-sign-source-1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/sat_s_val_ashr-1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-shift-sign-source-1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-shift-sign-source-negative-1.c diff --git a/gcc/match-sat-alu.pd b/gcc/match-sat-alu.pd index 42a4e49e00e6..5a5ed52d40de 100644 --- a/gcc/match-sat-alu.pd +++ b/gcc/match-sat-alu.pd @@ -353,7 +353,15 @@ along with GCC; see the file COPYING3. If not see (match (signed_integer_sat_val @0) (bit_xor:c (nop_convert? (negate (nop_convert? (convert (lt @0 integer_zerop))))) - max_value))) + max_value)) + /* SAT_VAL = ((T)(X >> (PRECISION (X) - 1)) ^ MAX). + The shift produces zero or minus one. A signed conversion can narrow or + extend either value exactly. */ + (match (signed_integer_sat_val @0) + (bit_xor:c (convert? (rshift @0 INTEGER_CST@1)) max_value) + (if (!TYPE_UNSIGNED (TREE_TYPE (@0)) + && (wi::to_wide (@1) + == TYPE_PRECISION (TREE_TYPE (@0)) - 1))))) /* Saturation add for signed integer. */ (if (INTEGRAL_TYPE_P (type) && !TYPE_UNSIGNED (type)) @@ -573,9 +581,7 @@ along with GCC; see the file COPYING3. If not see (match (signed_integer_sat_trunc @0) /* SAT_S_TRUNC(X) = (unsigned)X + NT_MAX + 1 > Unsigned_MAX ? (NT)X */ (cond^ (gt (plus:c (convert@4 @0) INTEGER_CST@1) INTEGER_CST@2) - (bit_xor:c (nop_convert? - (negate (nop_convert? (convert (lt @0 integer_zerop))))) - INTEGER_CST@3) + (signed_integer_sat_val @0) (convert @0)) /* The comparison type has to be unsigned and at least as wide as X. A narrower type would examine only the low bits of X. The result @@ -593,17 +599,58 @@ along with GCC; see the file COPYING3. If not see wide_int limit_0 = wi::mask (otype_prec, false, range_prec); // Aka 255 wide_int limit_1 = limit_0 - 2; // Aka 253 wide_int limit_2 = limit_0 - 1; // Aka 254 - wide_int otype_max = wi::mask (otype_prec - 1, false, otype_prec); - wide_int itype_max = wi::mask (otype_prec - 1, false, range_prec); + wide_int otype_max_in_range + = wi::mask (otype_prec - 1, false, range_prec); wide_int int_cst_1 = wi::to_wide (@1); wide_int int_cst_2 = wi::to_wide (@2); - wide_int int_cst_3 = wi::to_wide (@3); } - (if (((wi::eq_p (int_cst_1, offset) && wi::eq_p (int_cst_2, limit_0)) - || (wi::eq_p (int_cst_1, itype_max) && wi::eq_p (int_cst_2, limit_2)) + (if ((wi::eq_p (int_cst_1, offset) + && wi::eq_p (int_cst_2, limit_0)) + || (wi::eq_p (int_cst_1, otype_max_in_range) + && wi::eq_p (int_cst_2, limit_2)) || (wi::eq_p (int_cst_1, offset) && wi::eq_p (int_cst_2, limit_2)) - || (wi::eq_p (int_cst_1, itype_max) && wi::eq_p (int_cst_2, limit_1))) - && wi::eq_p (int_cst_3, otype_max))))))) + || (wi::eq_p (int_cst_1, otype_max_in_range) + && wi::eq_p (int_cst_2, limit_1)))))))) + +/* An arithmetic right shift preserves the sign of its signed input. The + saturation value can therefore use the input sign while the range check + and truncated result use the shifted value. */ +(if (INTEGRAL_TYPE_P (type) && !TYPE_UNSIGNED (type)) + (match (signed_integer_sat_trunc @0) + (cond^ (gt (plus:c (convert@4 + (rshift@0 @5 INTEGER_CST@6)) INTEGER_CST@1) + INTEGER_CST@2) + (signed_integer_sat_val @5) + (convert @0)) + (if (!TYPE_UNSIGNED (TREE_TYPE (@0)) + && TYPE_UNSIGNED (TREE_TYPE (@4)) + && tree_fits_uhwi_p (@6) + && TYPE_PRECISION (type) < TYPE_PRECISION (TREE_TYPE (@0)) + && tree_to_uhwi (@6) < TYPE_PRECISION (TREE_TYPE (@0)) + && TYPE_PRECISION (TREE_TYPE (@4)) >= TYPE_PRECISION (type) + && (TYPE_PRECISION (TREE_TYPE (@4)) + >= TYPE_PRECISION (TREE_TYPE (@0)) - tree_to_uhwi (@6))) + (with + { + unsigned otype_prec = TYPE_PRECISION (type); + unsigned range_prec = TYPE_PRECISION (TREE_TYPE (@4)); + wide_int offset = wi::set_bit_in_zero (otype_prec - 1, range_prec); + wide_int limit_0 = wi::mask (otype_prec, false, range_prec); // Aka 255 + wide_int limit_1 = limit_0 - 2; // Aka 253 + wide_int limit_2 = limit_0 - 1; // Aka 254 + wide_int otype_max_in_range + = wi::mask (otype_prec - 1, false, range_prec); + wide_int int_cst_1 = wi::to_wide (@1); + wide_int int_cst_2 = wi::to_wide (@2); + } + (if ((wi::eq_p (int_cst_1, offset) + && wi::eq_p (int_cst_2, limit_0)) + || (wi::eq_p (int_cst_1, otype_max_in_range) + && wi::eq_p (int_cst_2, limit_2)) + || (wi::eq_p (int_cst_1, offset) + && wi::eq_p (int_cst_2, limit_2)) + || (wi::eq_p (int_cst_1, otype_max_in_range) + && wi::eq_p (int_cst_2, limit_1)))))))) /* Saturation mult for unsigned integer. */ (if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)) diff --git a/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-shift-sign-source-1.c b/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-shift-sign-source-1.c new file mode 100644 index 000000000000..5d3fcf3ba3bb --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-shift-sign-source-1.c @@ -0,0 +1,220 @@ +/* { dg-do run { target bitint } } */ +/* { dg-additional-options "-O3 -fvect-cost-model=unlimited" } */ + +typedef __INT8_TYPE__ int8_t; +typedef __INT16_TYPE__ int16_t; +typedef __INT32_TYPE__ int32_t; +typedef __INT64_TYPE__ int64_t; +typedef __UINT32_TYPE__ uint32_t; +typedef __UINT64_TYPE__ uint64_t; +typedef signed _BitInt(16) int16b_t; +typedef unsigned _BitInt(12) uint12b_t; +typedef unsigned _BitInt(16) uint16b_t; +typedef unsigned _BitInt(17) uint17b_t; +typedef unsigned _BitInt(24) uint24b_t; + +#define N 259 + +#define SHIFT_SAT_VALUE(OUT, X, SHIFT, MAX) \ + ((OUT) ((OUT) ((X) >> (SHIFT)) ^ (OUT) (MAX))) +#define COMPARE_SAT_VALUE(OUT, X, SHIFT, MAX) \ + ((OUT) (-((OUT) ((X) < 0)) ^ (OUT) (MAX))) + +#define DEF_CLIP(NAME, SAT, OUT, IN, UIN, SHIFT, SIGN_SHIFT, OFFSET, LIMIT, \ + MAX) \ + __attribute__((noipa)) \ + static void \ + NAME (OUT *__restrict out, const IN *__restrict in, int n) \ + { \ + for (int i = 0; i < n; ++i) \ + { \ + IN source = in[i]; \ + IN shifted = source >> SHIFT; \ + UIN range = (UIN) shifted + (UIN) OFFSET; \ + out[i] = (range > (UIN) LIMIT \ + ? SAT (OUT, source, SIGN_SHIFT, MAX) : (OUT) shifted); \ + } \ + } + +#define DEF_REF(NAME, OUT, IN, SHIFT, MIN, MAX) \ + __attribute__((noipa, optimize ("O0"))) \ + static void \ + NAME (OUT *out, const IN *in, int n) \ + { \ + for (int i = 0; i < n; ++i) \ + { \ + IN shifted = in[i] >> SHIFT; \ + if (shifted < (IN) MIN) \ + out[i] = (OUT) MIN; \ + else if (shifted > (IN) MAX) \ + out[i] = (OUT) MAX; \ + else \ + out[i] = (OUT) shifted; \ + } \ + } + +DEF_CLIP (clip_s16_s8, SHIFT_SAT_VALUE, int8_t, int16b_t, uint16b_t, + 3, 15, 128, 255, 127) +DEF_CLIP (clip_s32_s16, COMPARE_SAT_VALUE, int16_t, int32_t, uint32_t, + 8, 31, 32768U, 65535U, 32767) +DEF_CLIP (clip_s64_s32, SHIFT_SAT_VALUE, int32_t, int64_t, uint64_t, + 13, 63, 2147483648ULL, 4294967295ULL, 2147483647) +DEF_CLIP (clip_s16_s8_wide_unshifted, SHIFT_SAT_VALUE, int8_t, int16b_t, + uint32_t, 0, 15, 128, 255, 127) +DEF_CLIP (clip_s16_s8_wide_shifted, SHIFT_SAT_VALUE, int8_t, int16b_t, + uint32_t, 3, 15, 128, 255, 127) +DEF_CLIP (clip_s32_s16_reduced_range, SHIFT_SAT_VALUE, int16_t, int32_t, + uint24b_t, 8, 31, 32768, 65535, 32767) + +DEF_REF (ref_s16_s8, int8_t, int16b_t, 3, -128, 127) +DEF_REF (ref_s32_s16, int16_t, int32_t, 8, -32768, 32767) +DEF_REF (ref_s64_s32, int32_t, int64_t, 13, + -2147483647 - 1, 2147483647) +DEF_REF (ref_s16_s8_wide_unshifted, int8_t, int16b_t, 0, -128, 127) +DEF_REF (ref_s16_s8_wide_shifted, int8_t, int16b_t, 3, -128, 127) +DEF_REF (ref_s32_s16_reduced_range, int16_t, int32_t, 8, -32768, 32767) + +/* This range calculation can wrap a shifted value that still fits in the + shifted input type. */ + +__attribute__((noipa)) +static void +narrow_range (int16_t *__restrict out, const int32_t *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + int32_t source = in[i]; + int32_t shifted = source >> 1; + uint17b_t range = (uint17b_t) shifted + (uint17b_t) 32768; + out[i] = (range > (uint17b_t) 65535 + ? (int16_t) (source >> 31) ^ 32767 : (int16_t) shifted); + } +} + +__attribute__((noipa, optimize ("O0"))) +static void +ref_narrow_range (int16_t *out, const int32_t *in, int n) +{ + for (int i = 0; i < n; ++i) + { + int32_t source = in[i]; + int32_t shifted = source >> 1; + uint17b_t range = (uint17b_t) shifted + (uint17b_t) 32768; + out[i] = (range > (uint17b_t) 65535 + ? (int16_t) (source >> 31) ^ 32767 : (int16_t) shifted); + } +} + +/* These wrapped constants do not describe a saturating truncation. */ + +__attribute__((noipa)) +static void +wrapped_output_range (int16_t *__restrict out, const int32_t *__restrict in, + int n) +{ + for (int i = 0; i < n; ++i) + { + int32_t source = in[i]; + int32_t shifted = source >> 20; + uint12b_t range = (uint12b_t) shifted + (uint12b_t) 32767; + out[i] = (range > (uint12b_t) 65534 + ? (int16_t) (source >> 31) ^ 32767 : (int16_t) shifted); + } +} + +__attribute__((noipa, optimize ("O0"))) +static void +ref_wrapped_output_range (int16_t *out, const int32_t *in, int n) +{ + for (int i = 0; i < n; ++i) + { + int32_t source = in[i]; + int32_t shifted = source >> 20; + uint12b_t range = (uint12b_t) shifted + (uint12b_t) 32767; + out[i] = (range > (uint12b_t) 65534 + ? (int16_t) (source >> 31) ^ 32767 : (int16_t) shifted); + } +} + +typedef void (*clip_fn) (int16_t *, const int32_t *, int); + +static void +check_invalid (clip_fn fn, clip_fn ref_fn, int32_t special) +{ + int16_t out[N]; + int16_t ref[N]; + int32_t in[N]; + + for (int i = 0; i < N; ++i) + in[i] = (int32_t) ((uint32_t) i * 2654435761U + 1013904223U); + in[0] = special; + + for (int n = 0; n <= N; ++n) + { + for (int i = 0; i < N; ++i) + out[i] = ref[i] = 23; + fn (out, in, n); + ref_fn (ref, in, n); + for (int i = 0; i < N; ++i) + if (out[i] != ref[i]) + __builtin_abort (); + } +} + +#define CHECK(NAME, REF, OUT, IN, INIT, SHIFT, MIN, MAX) \ + do \ + { \ + OUT out[N]; \ + OUT ref[N]; \ + IN in[N]; \ + IN scale = (IN) 1 << (SHIFT); \ + for (int i = 0; i < N; ++i) \ + in[i] = (IN) (INIT); \ + in[0] = ((IN) (MIN) - 1) * scale; \ + in[1] = (IN) (MIN) * scale; \ + in[2] = (IN) -1 * scale; \ + in[3] = 0; \ + in[4] = (IN) (MAX) * scale; \ + in[5] = ((IN) (MAX) + 1) * scale; \ + for (int n = 0; n <= N; ++n) \ + { \ + for (int i = 0; i < N; ++i) \ + out[i] = ref[i] = (OUT) 23; \ + NAME (out, in, n); \ + REF (ref, in, n); \ + for (int i = 0; i < N; ++i) \ + if (out[i] != ref[i]) \ + __builtin_abort (); \ + } \ + } \ + while (0) + +int +main (void) +{ + CHECK (clip_s16_s8, ref_s16_s8, int8_t, int16b_t, + (uint16b_t) i * (uint16b_t) 40503 + (uint16b_t) 97, + 3, -128, 127); + CHECK (clip_s32_s16, ref_s32_s16, int16_t, int32_t, + (uint32_t) i * 2654435761U + 1013904223U, + 8, -32768, 32767); + CHECK (clip_s64_s32, ref_s64_s32, int32_t, int64_t, + (uint64_t) i * 11400714819323198485ULL + + 13787848793156543929ULL, + 13, -2147483647 - 1, 2147483647); + CHECK (clip_s16_s8_wide_unshifted, ref_s16_s8_wide_unshifted, + int8_t, int16b_t, + (uint16b_t) i * (uint16b_t) 40503 + (uint16b_t) 97, + 0, -128, 127); + CHECK (clip_s16_s8_wide_shifted, ref_s16_s8_wide_shifted, + int8_t, int16b_t, + (uint16b_t) i * (uint16b_t) 40503 + (uint16b_t) 97, + 3, -128, 127); + CHECK (clip_s32_s16_reduced_range, ref_s32_s16_reduced_range, + int16_t, int32_t, + (uint32_t) i * 2654435761U + 1013904223U, + 8, -32768, 32767); + check_invalid (narrow_range, ref_narrow_range, 196608); + check_invalid (wrapped_output_range, ref_wrapped_output_range, 0); + return 0; +} diff --git a/gcc/testsuite/gcc.target/aarch64/sat_s_val_ashr-1.c b/gcc/testsuite/gcc.target/aarch64/sat_s_val_ashr-1.c new file mode 100644 index 000000000000..62ce0378d0da --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/sat_s_val_ashr-1.c @@ -0,0 +1,30 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-optimized" } */ + +#include + +/* Write the saturation value of a signed overflow as + (X >> (PREC - 1)) ^ MAX. */ + +#define DEF(N, T, MX, SH) \ + T f1_##N (T x, T y) \ + { \ + T s = (T) ((uint64_t) x + (uint64_t) y); \ + return ((x ^ s) & ~(x ^ y)) < 0 ? ((x >> SH) ^ MX) : s; \ + } \ + T f2_##N (T x, T y) \ + { \ + T r; \ + return __builtin_add_overflow (x, y, &r) ? ((x >> SH) ^ MX) : r; \ + } \ + T f3_##N (T x, T y) \ + { \ + T r; \ + return __builtin_sub_overflow (x, y, &r) ? ((x >> SH) ^ MX) : r; \ + } + +DEF (32, int32_t, INT32_MAX, 31) +DEF (64, int64_t, INT64_MAX, 63) + +/* { dg-final { scan-tree-dump-times "\\.SAT_ADD " 4 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "\\.SAT_SUB " 2 "optimized" } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-shift-sign-source-1.c b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-shift-sign-source-1.c new file mode 100644 index 000000000000..b3256db7b6ed --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-shift-sign-source-1.c @@ -0,0 +1,7 @@ +/* { dg-do compile { target bitint } } */ +/* { dg-options "-O3 -march=armv8-a" } */ +/* { dg-additional-options "-mmax-vectorization --param=vect-epilogues-nomask=0 -fdump-tree-vect-details" } */ + +#include "../../gcc.dg/vect/vect-sat-trunc-shift-sign-source-1.c" + +/* { dg-final { scan-tree-dump-times "sat_trunc pattern recognized" 6 "vect" } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-shift-sign-source-negative-1.c b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-shift-sign-source-negative-1.c new file mode 100644 index 000000000000..25925c967590 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-shift-sign-source-negative-1.c @@ -0,0 +1,122 @@ +/* { dg-do compile { target bitint } } */ +/* { dg-options "-O3 -march=armv8-a" } */ +/* { dg-additional-options "-mmax-vectorization --param=vect-epilogues-nomask=0 -fdump-tree-vect-details" } */ + +typedef __INT16_TYPE__ int16_t; +typedef __INT32_TYPE__ int32_t; +typedef __UINT16_TYPE__ uint16_t; +typedef __UINT32_TYPE__ uint32_t; +typedef unsigned _BitInt(12) uint12b_t; +typedef unsigned _BitInt(17) uint17b_t; + +__attribute__((noipa)) +void +different_source (int16_t *__restrict out, const int32_t *__restrict in, + const int32_t *__restrict signs, int n) +{ + for (int i = 0; i < n; ++i) + { + int32_t source = in[i]; + int32_t shifted = source >> 8; + uint32_t range = (uint32_t) shifted + 32768U; + int32_t sign_source = signs[i]; + out[i] = (range > 65535U + ? (int16_t) (sign_source >> 31) ^ 32767 + : (int16_t) shifted); + } +} + +__attribute__((noipa)) +void +logical_shift (int16_t *__restrict out, const uint32_t *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + uint32_t source = in[i]; + uint32_t shifted = source >> 8; + uint32_t range = shifted + 32768U; + out[i] = (range > 65535U + ? (int16_t) ((int32_t) source >> 31) ^ 32767 + : (int16_t) shifted); + } +} + +__attribute__((noipa)) +void +variable_count (int16_t *__restrict out, const int32_t *__restrict in, + const uint16_t *__restrict counts, int n) +{ + for (int i = 0; i < n; ++i) + { + int32_t source = in[i]; + int32_t shifted = source >> (counts[i] & 31); + uint32_t range = (uint32_t) shifted + 32768U; + out[i] = (range > 65535U + ? (int16_t) (source >> 31) ^ 32767 + : (int16_t) shifted); + } +} + +__attribute__((noipa)) +void +wrong_sign_count (int16_t *__restrict out, const int32_t *__restrict in, + int n) +{ + for (int i = 0; i < n; ++i) + { + int32_t source = in[i]; + int32_t shifted = source >> 8; + uint32_t range = (uint32_t) shifted + 32768U; + out[i] = (range > 65535U + ? (int16_t) (source >> 30) ^ 32767 + : (int16_t) shifted); + } +} + +__attribute__((noipa)) +void +wrong_range (int16_t *__restrict out, const int32_t *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + int32_t source = in[i]; + int32_t shifted = source >> 8; + uint32_t range = (uint32_t) shifted + 32767U; + out[i] = (range > 65535U + ? (int16_t) (source >> 31) ^ 32767 + : (int16_t) shifted); + } +} + +__attribute__((noipa)) +void +narrow_range (int16_t *__restrict out, const int32_t *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + int32_t source = in[i]; + int32_t shifted = source >> 1; + uint17b_t range = (uint17b_t) shifted + (uint17b_t) 32768; + out[i] = (range > (uint17b_t) 65535 + ? (int16_t) (source >> 31) ^ 32767 + : (int16_t) shifted); + } +} + +__attribute__((noipa)) +void +wrapped_output_range (int16_t *__restrict out, + const int32_t *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + int32_t source = in[i]; + int32_t shifted = source >> 20; + uint12b_t range = (uint12b_t) shifted + (uint12b_t) 32767; + out[i] = (range > (uint12b_t) 65534 + ? (int16_t) (source >> 31) ^ 32767 + : (int16_t) shifted); + } +} + +/* { dg-final { scan-tree-dump-not "sat_trunc pattern recognized" "vect" } } */ From 02b0226f9f8ac1face83c096b6e783e5c8956f6a Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Mon, 14 Sep 2026 09:24:22 +0200 Subject: [PATCH 249/584] match-sat-alu.pd: Recognize unsigned constant-clamp truncation A signed value clamped to the range of a narrower unsigned type is unsigned saturating truncation. Recognize nested MIN and MAX operations in either order. Keep the clamp match independent of use count. At this use, require an exact zero lower bound, the maximum upper bound, and one use of the outer clamp. The inner clamp can have other uses. With AArch64 -O2 -march=armv8-a -fopenmp-simd: before: clamp_u16_4: ldr q0, [x1] movi v30.4s, 0xff, msl 8 movi v31.4s, 0 smin v30.4s, v0.4s, v30.4s smax v30.4s, v30.4s, v31.4s xtn v30.4h, v30.4s str d30, [x0] ret after: clamp_u16_4: ldr q31, [x1] movi v30.4s, 0 smax v30.4s, v31.4s, v30.4s uqxtn v30.4h, v30.4s str d30, [x0] ret Runtime tests cover both clamp orders, two widths, and LTO. Target tests cover valid bounds, invalid bounds, and extra uses of each clamp. Bootstrapped and tested on aarch64-none-linux-gnu. gcc/ChangeLog: * match-sat-alu.pd (integer_constant_clamp): New match. (unsigned_integer_narrow_clip): Add the constant-clamp form. gcc/testsuite/ChangeLog: * gcc.dg/vect/vect-sat-trunc-clamp-1.c: New test. * gcc.target/aarch64/vect-sat-trunc-clamp-inner-use-1.c: Likewise. * gcc.target/aarch64/vect-sat-trunc-clamp-multi-use-1.c: Likewise. * gcc.target/aarch64/vect-sat-trunc-clamp-u-1.c: Likewise. * gcc.target/aarch64/vect-sat-trunc-clamp-u-negative-1.c: Likewise. Signed-off-by: Kyrylo Tkachov --- gcc/match-sat-alu.pd | 23 +++- .../gcc.dg/vect/vect-sat-trunc-clamp-1.c | 121 ++++++++++++++++++ .../vect-sat-trunc-clamp-inner-use-1.c | 22 ++++ .../vect-sat-trunc-clamp-multi-use-1.c | 21 +++ .../aarch64/vect-sat-trunc-clamp-u-1.c | 7 + .../vect-sat-trunc-clamp-u-negative-1.c | 30 +++++ 6 files changed, 223 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.dg/vect/vect-sat-trunc-clamp-1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-inner-use-1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-multi-use-1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-u-1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-u-negative-1.c diff --git a/gcc/match-sat-alu.pd b/gcc/match-sat-alu.pd index 5a5ed52d40de..c4b24dfab11a 100644 --- a/gcc/match-sat-alu.pd +++ b/gcc/match-sat-alu.pd @@ -23,6 +23,13 @@ along with GCC; see the file COPYING3. If not see . */ +/* Clamp @0 between the constant bounds @1 and @2. The source can put the + MIN or the MAX first. */ +(match (integer_constant_clamp @0 @1 @2) + (max (min @0 INTEGER_CST@2) INTEGER_CST@1)) +(match (integer_constant_clamp @0 @1 @2) + (min (max @0 INTEGER_CST@1) INTEGER_CST@2)) + /* Saturation add for unsigned integer. */ (if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)) (match (usadd_overflow_mask @0 @1) @@ -293,7 +300,21 @@ along with GCC; see the file COPYING3. If not see && wi::eq_p (trunc_max, int_cst_1) && cmp >= 0 && expr_not_equal_to (@0, wi::min_value (itype_precision, - SIGNED)))))))) + SIGNED))))))) + (match (unsigned_integer_narrow_clip @0) + /* SAT_US_TRUNC = (NT)MAX (MIN (X, NT_MAX), 0). */ + (convert (integer_constant_clamp@3 @0 integer_zerop@1 @2)) + (if (!TYPE_UNSIGNED (TREE_TYPE (@0)) + && single_use (@3)) + (with + { + unsigned itype_precision = TYPE_PRECISION (TREE_TYPE (@0)); + unsigned otype_precision = TYPE_PRECISION (type); + wide_int trunc_max = wi::mask (otype_precision, false, itype_precision); + wide_int hi_cst = wi::to_wide (@2, itype_precision); + } + (if (otype_precision < itype_precision + && wi::eq_p (hi_cst, trunc_max))))))) /* Saturation truncate for unsigned integer. */ (if (INTEGRAL_TYPE_P (type) && TYPE_UNSIGNED (type)) diff --git a/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-clamp-1.c b/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-clamp-1.c new file mode 100644 index 000000000000..06a4428d0d24 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-clamp-1.c @@ -0,0 +1,121 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vect_int } */ +/* { dg-additional-options "-O3 -fvect-cost-model=unlimited" } */ + +#include "tree-vect.h" + +typedef __UINT16_TYPE__ u16; +typedef __UINT32_TYPE__ u32; +typedef __UINT64_TYPE__ u64; +typedef __INT32_TYPE__ i32; +typedef __INT64_TYPE__ i64; + +#define N 259 + +static i32 in32[N]; +static i64 in64[N]; +static u16 out16[N]; +static u32 out32[N]; + +__attribute__((noipa)) static void +clamp_u16_lo (u16 *__restrict out, const i32 *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + i32 x = in[i]; + out[i] = x < 0 ? 0 : (x > 65535 ? 65535 : x); + } +} + +__attribute__((noipa)) static void +clamp_u16_hi (u16 *__restrict out, const i32 *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + i32 x = in[i]; + out[i] = x > 65535 ? 65535 : (x < 0 ? 0 : x); + } +} + +__attribute__((noipa)) static void +clamp_u32_lo (u32 *__restrict out, const i64 *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + i64 x = in[i]; + out[i] = x < 0 ? 0 : (x > 4294967295LL ? 4294967295LL : x); + } +} + +__attribute__((noipa)) static void +clamp_u32_hi (u32 *__restrict out, const i64 *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + i64 x = in[i]; + out[i] = x > 4294967295LL ? 4294967295LL : (x < 0 ? 0 : x); + } +} + +static u16 +ref_u16 (i32 x) +{ + return x < 0 ? 0 : (x > 65535 ? 65535 : x); +} + +static u32 +ref_u32 (i64 x) +{ + return x < 0 ? 0 : (x > 4294967295LL ? 4294967295LL : x); +} + +static void +check_u16 (void) +{ +#pragma GCC novector + for (int i = 0; i < N; ++i) + if (out16[i] != ref_u16 (in32[i])) + __builtin_abort (); +} + +static void +check_u32 (void) +{ +#pragma GCC novector + for (int i = 0; i < N; ++i) + if (out32[i] != ref_u32 (in64[i])) + __builtin_abort (); +} + +int +main (void) +{ + check_vect (); + + for (int i = 0; i < N; ++i) + { + in32[i] = (i32) ((u32) i * 2654435761U + 1013904223U); + in64[i] = (i64) ((u64) i * 11400714819323198485ULL + + 13787848793156543929ULL); + } + + in32[0] = -1; + in32[1] = 0; + in32[2] = 65535; + in32[3] = 65536; + in64[0] = -1; + in64[1] = 0; + in64[2] = 4294967295LL; + in64[3] = 4294967296LL; + + clamp_u16_lo (out16, in32, N); + check_u16 (); + clamp_u16_hi (out16, in32, N); + check_u16 (); + clamp_u32_lo (out32, in64, N); + check_u32 (); + clamp_u32_hi (out32, in64, N); + check_u32 (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-inner-use-1.c b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-inner-use-1.c new file mode 100644 index 000000000000..b93bc56188e6 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-inner-use-1.c @@ -0,0 +1,22 @@ +/* { dg-do compile } */ +/* { dg-options "-O3 -march=armv8-a" } */ +/* { dg-additional-options "-mmax-vectorization --param=vect-epilogues-nomask=0 -fdump-tree-vect-details" } */ + +typedef __UINT16_TYPE__ u16; +typedef __INT32_TYPE__ i32; + +void +clip (u16 *__restrict out, i32 *__restrict copy, + const i32 *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + i32 x = in[i]; + i32 inner = x > 65535 ? 65535 : x; + i32 outer = inner < 0 ? 0 : inner; + out[i] = outer; + copy[i] = inner; + } +} + +/* { dg-final { scan-tree-dump-times "sat_trunc pattern recognized" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-multi-use-1.c b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-multi-use-1.c new file mode 100644 index 000000000000..0b82d40ff2f9 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-multi-use-1.c @@ -0,0 +1,21 @@ +/* { dg-do compile } */ +/* { dg-options "-O3 -march=armv8-a" } */ +/* { dg-additional-options "-mmax-vectorization --param=vect-epilogues-nomask=0 -fdump-tree-vect-details" } */ + +typedef __UINT16_TYPE__ u16; +typedef __INT32_TYPE__ i32; + +void +clip (u16 *__restrict out, i32 *__restrict copy, + const i32 *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + i32 x = in[i]; + i32 clamped = x < 0 ? 0 : (x > 65535 ? 65535 : x); + out[i] = clamped; + copy[i] = clamped; + } +} + +/* { dg-final { scan-tree-dump-not "sat_trunc pattern recognized" "vect" } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-u-1.c b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-u-1.c new file mode 100644 index 000000000000..f159a8f4dac7 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-u-1.c @@ -0,0 +1,7 @@ +/* { dg-do compile } */ +/* { dg-options "-O3 -march=armv8-a" } */ +/* { dg-additional-options "-mmax-vectorization --param=vect-epilogues-nomask=0 -fdump-tree-vect-details" } */ + +#include "../../gcc.dg/vect/vect-sat-trunc-clamp-1.c" + +/* { dg-final { scan-tree-dump-times "sat_trunc pattern recognized" 4 "vect" } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-u-negative-1.c b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-u-negative-1.c new file mode 100644 index 000000000000..aa283f176ad8 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-u-negative-1.c @@ -0,0 +1,30 @@ +/* { dg-do compile } */ +/* { dg-options "-O3 -march=armv8-a" } */ +/* { dg-additional-options "-mmax-vectorization --param=vect-epilogues-nomask=0 -fdump-tree-vect-details" } */ + +typedef __UINT16_TYPE__ u16; +typedef __INT32_TYPE__ i32; + +__attribute__((noipa)) +void +bad_low (u16 *__restrict out, const i32 *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + i32 x = in[i]; + out[i] = x < 1 ? 1 : (x > 65535 ? 65535 : x); + } +} + +__attribute__((noipa)) +void +bad_high (u16 *__restrict out, const i32 *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + i32 x = in[i]; + out[i] = x > 65534 ? 65534 : (x < 0 ? 0 : x); + } +} + +/* { dg-final { scan-tree-dump-not "sat_trunc pattern recognized" "vect" } } */ From 7f02676a414e4a96c498c0b3e58487aca3c45185 Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Mon, 14 Sep 2026 09:25:13 +0200 Subject: [PATCH 250/584] match-sat-alu.pd: Recognize signed constant-clamp truncation A signed value clamped to the bounds of a narrower signed type is signed saturating truncation. Recognize both nesting orders of the MIN and MAX operations. Require exact bounds at the input precision, signed input and output types, a narrowing conversion, and one use of the outer clamp. With AArch64 -O2 -march=armv8-a -fopenmp-simd: before: clamp_i16_4: ldr q0, [x1] movi v30.4s, 0x7f, msl 8 mvni v31.4s, 0x7f, msl 8 smin v30.4s, v0.4s, v30.4s smax v30.4s, v30.4s, v31.4s xtn v30.4h, v30.4s str d30, [x0] ret after: clamp_i16_4: ldr q31, [x1] sqxtn v31.4h, v31.4s str d31, [x0] ret Runtime tests cover both clamp orders, two widths, and LTO. Target tests cover valid forms and inexact bounds. Bootstrapped and tested on aarch64-none-linux-gnu. gcc/ChangeLog: * match-sat-alu.pd (signed_integer_sat_trunc): Add the constant-clamp form. gcc/testsuite/ChangeLog: * gcc.dg/vect/vect-sat-trunc-clamp-2.c: New test. * gcc.target/aarch64/vect-sat-trunc-clamp-s-1.c: Likewise. * gcc.target/aarch64/vect-sat-trunc-clamp-s-negative-1.c: Likewise. Signed-off-by: Kyrylo Tkachov --- gcc/match-sat-alu.pd | 21 ++- .../gcc.dg/vect/vect-sat-trunc-clamp-2.c | 126 ++++++++++++++++++ .../aarch64/vect-sat-trunc-clamp-s-1.c | 7 + .../vect-sat-trunc-clamp-s-negative-1.c | 30 +++++ 4 files changed, 183 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.dg/vect/vect-sat-trunc-clamp-2.c create mode 100644 gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-s-1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-s-negative-1.c diff --git a/gcc/match-sat-alu.pd b/gcc/match-sat-alu.pd index c4b24dfab11a..d8b4d9bb6b83 100644 --- a/gcc/match-sat-alu.pd +++ b/gcc/match-sat-alu.pd @@ -631,7 +631,26 @@ along with GCC; see the file COPYING3. If not see && wi::eq_p (int_cst_2, limit_2)) || (wi::eq_p (int_cst_1, offset) && wi::eq_p (int_cst_2, limit_2)) || (wi::eq_p (int_cst_1, otype_max_in_range) - && wi::eq_p (int_cst_2, limit_1)))))))) + && wi::eq_p (int_cst_2, limit_1))))))) + (match (signed_integer_sat_trunc @0) + /* SAT_S_TRUNC = (NT)MAX (MIN (X, NT_MAX), NT_MIN). */ + (convert (integer_constant_clamp@3 @0 @1 @2)) + (if (!TYPE_UNSIGNED (TREE_TYPE (@0)) + && single_use (@3)) + (with + { + unsigned itype_precision = TYPE_PRECISION (TREE_TYPE (@0)); + unsigned otype_precision = TYPE_PRECISION (type); + wide_int otype_min = wi::mask (otype_precision - 1, true, + itype_precision); + wide_int otype_max = wi::mask (otype_precision - 1, false, + itype_precision); + wide_int lo_cst = wi::to_wide (@1, itype_precision); + wide_int hi_cst = wi::to_wide (@2, itype_precision); + } + (if (otype_precision < itype_precision + && wi::eq_p (lo_cst, otype_min) + && wi::eq_p (hi_cst, otype_max))))))) /* An arithmetic right shift preserves the sign of its signed input. The saturation value can therefore use the input sign while the range check diff --git a/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-clamp-2.c b/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-clamp-2.c new file mode 100644 index 000000000000..193979587b87 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-clamp-2.c @@ -0,0 +1,126 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vect_int } */ +/* { dg-additional-options "-O3 -fvect-cost-model=unlimited" } */ + +#include "tree-vect.h" + +typedef __UINT32_TYPE__ u32; +typedef __UINT64_TYPE__ u64; +typedef __INT16_TYPE__ i16; +typedef __INT32_TYPE__ i32; +typedef __INT64_TYPE__ i64; + +#define N 259 + +static i32 in32[N]; +static i64 in64[N]; +static i16 out16[N]; +static i32 out32[N]; + +__attribute__((noipa)) static void +clamp_s16_lo (i16 *__restrict out, const i32 *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + i32 x = in[i]; + out[i] = x < -32768 ? -32768 : (x > 32767 ? 32767 : x); + } +} + +__attribute__((noipa)) static void +clamp_s16_hi (i16 *__restrict out, const i32 *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + i32 x = in[i]; + out[i] = x > 32767 ? 32767 : (x < -32768 ? -32768 : x); + } +} + +__attribute__((noipa)) static void +clamp_s32_lo (i32 *__restrict out, const i64 *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + i64 x = in[i]; + out[i] = (x < -2147483647LL - 1 + ? -2147483647LL - 1 : (x > 2147483647LL + ? 2147483647LL : x)); + } +} + +__attribute__((noipa)) static void +clamp_s32_hi (i32 *__restrict out, const i64 *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + i64 x = in[i]; + out[i] = (x > 2147483647LL + ? 2147483647LL : (x < -2147483647LL - 1 + ? -2147483647LL - 1 : x)); + } +} + +static i16 +ref_s16 (i32 x) +{ + return x < -32768 ? -32768 : (x > 32767 ? 32767 : x); +} + +static i32 +ref_s32 (i64 x) +{ + return (x < -2147483647LL - 1 + ? -2147483647LL - 1 : (x > 2147483647LL ? 2147483647LL : x)); +} + +static void +check_s16 (void) +{ +#pragma GCC novector + for (int i = 0; i < N; ++i) + if (out16[i] != ref_s16 (in32[i])) + __builtin_abort (); +} + +static void +check_s32 (void) +{ +#pragma GCC novector + for (int i = 0; i < N; ++i) + if (out32[i] != ref_s32 (in64[i])) + __builtin_abort (); +} + +int +main (void) +{ + check_vect (); + + for (int i = 0; i < N; ++i) + { + in32[i] = (i32) ((u32) i * 2654435761U + 1013904223U); + in64[i] = (i64) ((u64) i * 11400714819323198485ULL + + 13787848793156543929ULL); + } + + in32[0] = -32769; + in32[1] = -32768; + in32[2] = 32767; + in32[3] = 32768; + in64[0] = -2147483647LL - 2; + in64[1] = -2147483647LL - 1; + in64[2] = 2147483647LL; + in64[3] = 2147483648LL; + + clamp_s16_lo (out16, in32, N); + check_s16 (); + clamp_s16_hi (out16, in32, N); + check_s16 (); + clamp_s32_lo (out32, in64, N); + check_s32 (); + clamp_s32_hi (out32, in64, N); + check_s32 (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-s-1.c b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-s-1.c new file mode 100644 index 000000000000..3a603ca18ef8 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-s-1.c @@ -0,0 +1,7 @@ +/* { dg-do compile } */ +/* { dg-options "-O3 -march=armv8-a" } */ +/* { dg-additional-options "-mmax-vectorization --param=vect-epilogues-nomask=0 -fdump-tree-vect-details" } */ + +#include "../../gcc.dg/vect/vect-sat-trunc-clamp-2.c" + +/* { dg-final { scan-tree-dump-times "sat_trunc pattern recognized" 4 "vect" } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-s-negative-1.c b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-s-negative-1.c new file mode 100644 index 000000000000..b0f86653554d --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-clamp-s-negative-1.c @@ -0,0 +1,30 @@ +/* { dg-do compile } */ +/* { dg-options "-O3 -march=armv8-a" } */ +/* { dg-additional-options "-mmax-vectorization --param=vect-epilogues-nomask=0 -fdump-tree-vect-details" } */ + +typedef __INT16_TYPE__ i16; +typedef __INT32_TYPE__ i32; + +__attribute__((noipa)) +void +bad_low (i16 *__restrict out, const i32 *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + i32 x = in[i]; + out[i] = x < -32767 ? -32767 : (x > 32767 ? 32767 : x); + } +} + +__attribute__((noipa)) +void +bad_high (i16 *__restrict out, const i32 *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + i32 x = in[i]; + out[i] = x > 32766 ? 32766 : (x < -32768 ? -32768 : x); + } +} + +/* { dg-final { scan-tree-dump-not "sat_trunc pattern recognized" "vect" } } */ From b627bfa76649bb65ccab8d9aad9c1b1f1d45cdde Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Sun, 23 Aug 2026 12:13:13 +0200 Subject: [PATCH 251/584] match-sat-alu.pd: Recognize complement masks for unsigned saturating truncation Unsigned saturating truncation can form its sign mask from ~X instead of -X. This avoids negating the minimum signed value. For negative X, ~X is nonnegative and its top-bit shift is zero. For positive X above the result range, ~X is negative and its top-bit shift is all ones. Recognize this form. Keep the unsigned range comparison because a signed comparison does not clamp negative inputs. With AArch64 -O2 -march=armv8-a -fopenmp-simd: before: complement_clip4: ldr q31, [x1] movi v30.4s, 0xff, msl 8 not v29.16b, v31.16b cmhi v30.4s, v31.4s, v30.4s cmlt v29.4s, v29.4s, #0 bif v29.16b, v31.16b, v30.16b xtn v29.4h, v29.4s str d29, [x0] ret after: complement_clip4: ldr q31, [x1] movi v30.4s, 0 smax v30.4s, v31.4s, v30.4s uqxtn v30.4h, v30.4s str d30, [x0] ret Tests cover both widths, extrema, bounds, LTO, and a signed-comparison counterexample. The AArch64 test covers both valid forms. Bootstrapped and tested on aarch64-none-linux-gnu. gcc/ChangeLog: * match-sat-alu.pd (unsigned_integer_narrow_clip): Add the complement form. gcc/testsuite/ChangeLog: * gcc.dg/sat-trunc-signed-cmp-2.c: New test. * gcc.dg/vect/vect-sat-trunc-complement-1.c: Likewise. * gcc.target/aarch64/vect-sat-trunc-complement-1.c: Likewise. Signed-off-by: Kyrylo Tkachov --- gcc/match-sat-alu.pd | 24 +++++++ gcc/testsuite/gcc.dg/sat-trunc-signed-cmp-2.c | 42 +++++++++++ .../gcc.dg/vect/vect-sat-trunc-complement-1.c | 70 +++++++++++++++++++ .../aarch64/vect-sat-trunc-complement-1.c | 30 ++++++++ 4 files changed, 166 insertions(+) create mode 100644 gcc/testsuite/gcc.dg/sat-trunc-signed-cmp-2.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-sat-trunc-complement-1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-complement-1.c diff --git a/gcc/match-sat-alu.pd b/gcc/match-sat-alu.pd index d8b4d9bb6b83..c79f8986ff50 100644 --- a/gcc/match-sat-alu.pd +++ b/gcc/match-sat-alu.pd @@ -301,6 +301,30 @@ along with GCC; see the file COPYING3. If not see && cmp >= 0 && expr_not_equal_to (@0, wi::min_value (itype_precision, SIGNED))))))) + (match (unsigned_integer_narrow_clip @0) + /* Use the sign of ~X for a source that avoids negating the minimum signed + value. For a negative X, ~X is nonnegative and gives zero. For a + positive X above the result range, ~X is negative and gives all ones. */ + (convert (cond^ (gt (nop_convert@3 @0) INTEGER_CST@1) + (rshift:s (bit_not @0) INTEGER_CST@2) + @0)) + (if (!TYPE_UNSIGNED (TREE_TYPE (@0)) + && TYPE_UNSIGNED (TREE_TYPE (@3))) + (with + { + unsigned itype_precision = TYPE_PRECISION (TREE_TYPE (@0)); + unsigned otype_precision = TYPE_PRECISION (type); + wide_int trunc_max = wi::mask (otype_precision, false, itype_precision); + wide_int int_cst_1 = wi::to_wide (@1, itype_precision); + wide_int int_cst_2 = wi::to_wide (@2, itype_precision); + wide_int shift_amount = wi::uhwi (itype_precision - 1, + itype_precision); + int cmp = wi::cmp (int_cst_2, shift_amount, + TYPE_SIGN (TREE_TYPE (@0))); + } + (if (otype_precision < itype_precision + && wi::eq_p (trunc_max, int_cst_1) + && cmp >= 0))))) (match (unsigned_integer_narrow_clip @0) /* SAT_US_TRUNC = (NT)MAX (MIN (X, NT_MAX), 0). */ (convert (integer_constant_clamp@3 @0 integer_zerop@1 @2)) diff --git a/gcc/testsuite/gcc.dg/sat-trunc-signed-cmp-2.c b/gcc/testsuite/gcc.dg/sat-trunc-signed-cmp-2.c new file mode 100644 index 000000000000..a06588ccedc0 --- /dev/null +++ b/gcc/testsuite/gcc.dg/sat-trunc-signed-cmp-2.c @@ -0,0 +1,42 @@ +/* The complement spelling of the narrow-clip idiom is only a clamp when the + comparison that selects the saturated arm is unsigned. With a signed + comparison a negative value takes the fall-through arm and keeps its low + bits, so it must not be turned into a saturating truncation. */ + +/* { dg-do run } */ +/* { dg-options "-O1 -ftree-vectorize -fdump-tree-vect-details" } */ + +typedef __UINT16_TYPE__ u16; +typedef __INT32_TYPE__ i32; + +#define N 32 + +static i32 a[N]; +static u16 r[N]; + +__attribute__((noipa)) static void +clip (u16 *__restrict d, const i32 *__restrict s, int n) +{ + for (int i = 0; i < n; i++) + { + i32 v = s[i]; + d[i] = v > 65535 ? (~v) >> 31 : v; + } +} + +int +main (void) +{ + for (int i = 0; i < N; i++) + a[i] = -1; + + clip (r, a, N); + + for (int i = 0; i < N; i++) + if (r[i] != (u16) -1) + __builtin_abort (); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "sat_trunc pattern recognized" "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-complement-1.c b/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-complement-1.c new file mode 100644 index 000000000000..f7bb1656a5d4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-complement-1.c @@ -0,0 +1,70 @@ +/* { dg-do run } */ +/* { dg-require-effective-target vect_int } */ +/* { dg-additional-options "-O3 -fvect-cost-model=unlimited" } */ + +#include "tree-vect.h" + +typedef __UINT16_TYPE__ u16; +typedef __UINT32_TYPE__ u32; +typedef __INT32_TYPE__ i32; +typedef __INT64_TYPE__ i64; + +#define N 96 + +static i32 in32[N]; +static i64 in64[N]; +static u16 out16[N]; +static u32 out32[N]; + +__attribute__((noipa)) static void +clip_u16 (u16 *__restrict out, const i32 *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + i32 x = in[i]; + out[i] = (x & ~65535) ? (~x) >> 31 : x; + } +} + +__attribute__((noipa)) static void +clip_u32 (u32 *__restrict out, const i64 *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + i64 x = in[i]; + out[i] = (x & ~(i64) 0xffffffff) ? (~x) >> 63 : x; + } +} + +int +main (void) +{ + static const i32 values32[6] = + { (-2147483647 - 1), -1, 0, 65535, 65536, 2147483647 }; + static const u16 expected16[6] = + { 0, 0, 0, 65535, 65535, 65535 }; + static const i64 values64[6] = + { (-9223372036854775807LL - 1), -1, 0, 4294967295LL, + 4294967296LL, 9223372036854775807LL }; + static const u32 expected32[6] = + { 0, 0, 0, (u32) -1, (u32) -1, (u32) -1 }; + + check_vect (); + + for (int i = 0; i < N; ++i) + { + in32[i] = values32[i % 6]; + in64[i] = values64[i % 6]; + } + + clip_u16 (out16, in32, N); + clip_u32 (out32, in64, N); + +#pragma GCC novector + for (int i = 0; i < N; ++i) + if (out16[i] != expected16[i % 6] + || out32[i] != expected32[i % 6]) + __builtin_abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-complement-1.c b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-complement-1.c new file mode 100644 index 000000000000..9c18ee063e00 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-complement-1.c @@ -0,0 +1,30 @@ +/* { dg-do compile } */ +/* { dg-options "-O3 -march=armv8-a" } */ +/* { dg-additional-options "-mmax-vectorization --param=vect-epilogues-nomask=0 -fdump-tree-vect-details" } */ + +typedef __UINT16_TYPE__ u16; +typedef __UINT32_TYPE__ u32; +typedef __INT32_TYPE__ i32; +typedef __INT64_TYPE__ i64; + +void +clip_u16 (u16 *__restrict out, const i32 *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + i32 x = in[i]; + out[i] = (x & ~65535) ? (~x) >> 31 : x; + } +} + +void +clip_u32 (u32 *__restrict out, const i64 *__restrict in, int n) +{ + for (int i = 0; i < n; ++i) + { + i64 x = in[i]; + out[i] = (x & ~(i64) 4294967295LL) ? (~x) >> 63 : x; + } +} + +/* { dg-final { scan-tree-dump-times "sat_trunc pattern recognized" 2 "vect" } } */ From fc96e933de8d29f91ad7ab9cf982ad498bc5c9d0 Mon Sep 17 00:00:00 2001 From: Konstantinos Eleftheriou Date: Tue, 1 Sep 2026 16:04:28 +0200 Subject: [PATCH 252/584] fold-mem-offsets: Group changes by shared fold insns [PR126412] Once a fold insn's constant is folded into the memory offsets computed from it, the pass zeroes that constant. This is only correct if every root reached through the insn takes the compensating offset, so roots whose def-chains share a fold insn must be committed, or cancelled, as a unit. The changes were grouped by the register defined by the last fold insn of the def-chain, which misses a base add shared between chains that end in different registers. In the testcase, g_13, g_590 and g_253 are all reached through one section-anchor add, r0 = r7 + 976. The g_590 loads reach it via a second add and are grouped under r3, so committing them zeroes the shared add. The g_253 load is grouped under r0 and needs offset 1008, outside LDRSB's range, so its group is cancelled, but the zeroing survives: the g_13 and g_253 accesses are left at r7 + {4, 32} instead of r7 + {980, 1008}. Group the changes by the connected components of the roots that share a fold insn, maintained as a union-find, so that a root that cannot be updated rolls back its whole component. Also commit all surviving groups in one change_insns call, which removes the sort over the group keys. PR rtl-optimization/126412 gcc/ChangeLog: * fold-mem-offsets.cc (change_in_vec_p): Move before fold_groups. (changes_map_t): New type. (class fold_groups): New class. (struct regno_changes): Remove. (sort_pairs): Likewise. (cancel_changes_for_group): Take the fold group to cancel. (find_groups_to_cancel): Rename from find_keys_to_remove. (update_insns): Group the changes by fold group instead of by the register defined by the last fold insn of the def-chain. (fold_mem_offsets_1): Use fold_groups and commit all groups in a single change_insns call. gcc/testsuite/ChangeLog: * gcc.target/arm/pr126412.c: New test. --- gcc/fold-mem-offsets.cc | 299 +++++++++++++----------- gcc/testsuite/gcc.target/arm/pr126412.c | 79 +++++++ 2 files changed, 242 insertions(+), 136 deletions(-) create mode 100644 gcc/testsuite/gcc.target/arm/pr126412.c diff --git a/gcc/fold-mem-offsets.cc b/gcc/fold-mem-offsets.cc index 5b326fa31141..0b7d6420a820 100644 --- a/gcc/fold-mem-offsets.cc +++ b/gcc/fold-mem-offsets.cc @@ -166,6 +166,113 @@ class change_info { } }; +/* Check if CHANGE exists in CHANGES. */ + +static bool +change_in_vec_p (const auto_vec &changes, + const change_info &change) +{ + for (const change_info *other_change : changes) + if (other_change->change->insn () == change.change->insn ()) + return true; + + return false; +} + +/* Instruction changes that are going to be committed, keyed by the id of the + fold group that they belong to (see fold_groups). */ +using changes_map_t + = hash_map, auto_vec>; + +/* Zeroing the constant of a fold insn is only correct if every fold-mem-offset + root that addresses memory through it is updated with the compensating + offset. Roots that share fold insns, directly or through another root, + therefore form a group, which has to be committed, or cancelled, as one + unit. */ + +class fold_groups +{ +public: + /* Put the def-chain FOLD_INSNS in one group and return its id. Insns that + already belong to a group merge that group into the result, so chains + sharing a fold insn end up in the same group. */ + unsigned add_chain (const vec &fold_insns) + { + unsigned group = 0; + bool found = false; + for (insn_info *insn : fold_insns) + if (unsigned *seen = m_insn_group.get (insn)) + { + group = found ? merge (group, *seen) : find (*seen); + found = true; + } + + if (!found) + { + group = m_parent.length (); + m_parent.safe_push (group); + } + + for (insn_info *insn : fold_insns) + m_insn_group.put (insn, group); + + return group; + } + + /* Changes to commit, per group. */ + changes_map_t changes; + + /* Groups whose changes have been cancelled; no further changes may be + attempted for them. */ + auto_bitmap cancelled; + +private: + /* Resolve ID to the id of the group that it now belongs to. */ + unsigned find (unsigned id) + { + while (m_parent[id] != id) + id = m_parent[id]; + return id; + } + + /* Merge the groups holding A and B and return the surviving id, which + takes over the changes and the cancelled state of the absorbed group. */ + unsigned merge (unsigned a, unsigned b) + { + a = find (a); + b = find (b); + if (a == b) + return a; + + /* Canonicalize on the smaller id, so that the surviving key does not + depend on the order in which the chains were processed. */ + if (b < a) + std::swap (a, b); + m_parent[b] = a; + + /* Take A's entry first: get_or_insert can resize the map, which would + invalidate a pointer to B's entry taken before it. The groups were + disjoint, so the lists cannot overlap. */ + auto_vec &a_changes = changes.get_or_insert (a); + if (auto_vec *b_changes = changes.get (b)) + { + a_changes.safe_splice (*b_changes); + changes.remove (b); + } + + if (bitmap_clear_bit (cancelled, b)) + bitmap_set_bit (cancelled, a); + + return a; + } + + /* Union-find parent of every group id. */ + auto_vec m_parent; + + /* The group of each fold insn seen so far. */ + hash_map m_insn_group; +}; + /* Test if INSN is a memory load / store that can have an offset folded to it. Return true when INSN is such an instruction and return through MEM, REG and OFFSET the RTX that has a MEM code, the register that is @@ -819,30 +926,6 @@ sort_changes (insn_change *a, insn_change *b) return a->insn ()->compare_with (b->insn ()) < 0; } -/* A changes_map entry copied out for deterministic, regno-ordered traversal: - REGNO is the map key and CHANGES the insn_change list for it. */ - -struct regno_changes -{ - unsigned regno; - auto_vec *changes; -}; - -/* qsort comparator that orders regno_changes entries by ascending regno. */ - -static int -sort_pairs (const void *p1, const void *p2) -{ - const regno_changes *a = (const regno_changes *) p1; - const regno_changes *b = (const regno_changes *) p2; - - if (a->regno < b->regno) - return -1; - if (a->regno > b->regno) - return 1; - return 0; -} - /* Find and return the last definition of INSN. */ static def_info * @@ -870,39 +953,25 @@ move_uses_to_prev_def (def_info *def) } } -/* Check if CHANGE exists in CHANGES. */ - -static bool -change_in_vec_p (const auto_vec &changes, - const change_info &change) -{ - for (const change_info *other_change : changes) - if (other_change->change->insn () == change.change->insn ()) - return true; - - return false; -} - -/* Cancel current changes, clear CHANGES vector and update REMOVED_REGNOS. */ +/* Cancel GROUP, lowering MIN_INDEX to CHANGE_INDEX so that cancel_changes + drops everything the group has validated so far. */ static void -cancel_changes_for_group (int change_index, bitmap removed_regnos, - unsigned regno, int *min_index) +cancel_changes_for_group (int change_index, bitmap cancelled_groups, + unsigned group, int *min_index) { if (*min_index == -1 || change_index < *min_index) *min_index = change_index; - bitmap_set_bit (removed_regnos, regno); + bitmap_set_bit (cancelled_groups, group); } -/* Find the keys in CHANGES_MAP that need to be removed, based on - CANCEL_MIN_INDEX and store them in KEYS_TO_REMOVE. We do this by iterating - the entries of the map recalculating the minimum index, until reaching a - fixed-point. */ +/* Store in GROUPS_TO_CANCEL the groups of CHANGES_MAP that have a change at + or after CANCEL_MIN_INDEX, lowering it to the minimum index of each such + group until reaching a fixed-point. */ static void -find_keys_to_remove (const hash_map, - auto_vec> &changes_map, - bitmap keys_to_remove, - int *cancel_min_index) +find_groups_to_cancel (const changes_map_t &changes_map, + bitmap groups_to_cancel, + int *cancel_min_index) { bool index_changed; do { @@ -910,7 +979,7 @@ find_keys_to_remove (const hash_map, for (const auto &entry : changes_map) { int min_index = INT_MAX; - bool cancelled_group = bitmap_bit_p (keys_to_remove, entry.first); + bool cancelled_group = bitmap_bit_p (groups_to_cancel, entry.first); for (change_info *change : entry.second) { int change_index = change->change_index; @@ -919,7 +988,7 @@ find_keys_to_remove (const hash_map, if (!cancelled_group && change_index >= *cancel_min_index) { - bitmap_set_bit (keys_to_remove, entry.first); + bitmap_set_bit (groups_to_cancel, entry.first); cancelled_group = true; } } @@ -950,17 +1019,12 @@ free_changes_info (auto_vec &changes_info) } /* Update the memory offsets and constants in fold insns based on the analysis - done in fold_mem_offsets_1, using RTL SSA. ATTEMPT is the attempt object - for the current changes. CHANGES_MAP holds the changes that are going - to performed and is updated inside the function. REMOVED_REGNOS holds the - keys of the map that have been removed, in order to prevent new attempts - on these. */ + done in fold_mem_offsets_1. ATTEMPT is the attempt object for the current + changes, which are recorded in GROUPS. */ static unsigned int update_insns (fold_mem_info *info, obstack_watermark *attempt, - hash_map, auto_vec> - *changes_map, - bitmap removed_regnos, + fold_groups *groups, int *cancel_min_index) { insn_info *insn = info->insn; @@ -979,20 +1043,13 @@ update_insns (fold_mem_info *info, return stats_fold_count; } - const rtx_insn *last_fold_insn_rtl = info->fold_insns.last ()->rtl (); - rtx last_set = single_set (last_fold_insn_rtl); - if (!last_set) - { - free_changes_info (changes_info); - return stats_fold_count; - } - unsigned regno_key = REGNO (SET_DEST (last_set)); - auto_vec *prev_changes = changes_map->get (regno_key); + unsigned group = groups->add_chain (info->fold_insns); + auto_vec *prev_changes = groups->changes.get (group); - /* Abort if changes for this key have been cancelled before. */ - if (bitmap_bit_p (removed_regnos, regno_key)) + /* Abort if changes for this group have been cancelled before. */ + if (bitmap_bit_p (groups->cancelled, group)) { - cancel_changes_for_group (change_index, removed_regnos, regno_key, + cancel_changes_for_group (change_index, groups->cancelled, group, cancel_min_index); free_changes_info (changes_info); return stats_fold_count; @@ -1009,7 +1066,7 @@ update_insns (fold_mem_info *info, if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, "Restrict movement: Cannot update INSN %u.\n", insn->uid ()); - cancel_changes_for_group (change_index, removed_regnos, regno_key, + cancel_changes_for_group (change_index, groups->cancelled, group, cancel_min_index); free_changes_info (changes_info); return stats_fold_count; @@ -1033,7 +1090,7 @@ update_insns (fold_mem_info *info, if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, "Recog/verify: Cannot update INSN %u.\n", insn->uid ()); - cancel_changes_for_group (change_index, removed_regnos, regno_key, + cancel_changes_for_group (change_index, groups->cancelled, group, cancel_min_index); free_changes_info (changes_info); return stats_fold_count; @@ -1064,7 +1121,7 @@ update_insns (fold_mem_info *info, if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, "Restrict movement: Cannot update INSN %u.\n", fold_insn->uid ()); - cancel_changes_for_group (change_index, removed_regnos, regno_key, + cancel_changes_for_group (change_index, groups->cancelled, group, cancel_min_index); free_changes_info (changes_info); return 0; @@ -1076,7 +1133,7 @@ update_insns (fold_mem_info *info, if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, "Verify: Cannot update INSN %u.\n", fold_insn->uid ()); - cancel_changes_for_group (change_index, removed_regnos, regno_key, + cancel_changes_for_group (change_index, groups->cancelled, group, cancel_min_index); free_changes_info (changes_info); return 0; @@ -1100,7 +1157,7 @@ update_insns (fold_mem_info *info, if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, "Recog: Cannot update INSN %u.\n", fold_insn->uid ()); - cancel_changes_for_group (change_index, removed_regnos, regno_key, + cancel_changes_for_group (change_index, groups->cancelled, group, cancel_min_index); free_changes_info (changes_info); return 0; @@ -1121,7 +1178,7 @@ update_insns (fold_mem_info *info, stats_fold_count++; } - /* Add new changes to changes_map. */ + /* Add new changes to the group. */ if (prev_changes) { for (change_info *change : changes_info) @@ -1137,7 +1194,7 @@ update_insns (fold_mem_info *info, for (change_info *change : changes_info) { auto_vec &change_vect - = changes_map->get_or_insert (regno_key); + = groups->changes.get_or_insert (group); if (!change_in_vec_p (change_vect, *change)) change_vect.safe_push (change); @@ -1159,20 +1216,14 @@ fold_mem_offsets_1 (bool single_use) { unsigned int stats_fold_count = 0; - /* This maps the instruction changes to the register defined by the last - fold_insn of the def-chain (the one nearest the fold-mem-offset root). - We use this so that we can group interdependent instructions. In this - way, we can restrict the change cancellation in a group only, if anything - goes wrong. */ - hash_map, auto_vec> changes_map; + /* This collects the instruction changes into groups of interdependent + def-chains, so that the change cancellation can be restricted to a single + group if anything goes wrong. */ + fold_groups groups; auto attempt = crtl->ssa->new_change_attempt (); insn_change_watermark watermark; - /* Set of removed reg numbers (keys to changes_map). If a change for a reg - number has been cancelled, we need to invalidate any future changes. */ - auto_bitmap removed_regnos; - int cancel_min_index = -1; /* Iterate over all nondebug INSNs get our candidates and fold them. */ @@ -1212,8 +1263,8 @@ fold_mem_offsets_1 (bool single_use) if (single_use) { - stats_fold_count += update_insns (info, &attempt, &changes_map, - removed_regnos, &cancel_min_index); + stats_fold_count += update_insns (info, &attempt, &groups, + &cancel_min_index); delete info; } else @@ -1230,8 +1281,8 @@ fold_mem_offsets_1 (bool single_use) while (!worklist.is_empty ()) { fold_mem_info *info = worklist.pop (); - stats_fold_count += update_insns (info, &attempt, &changes_map, - removed_regnos, &cancel_min_index); + stats_fold_count += update_insns (info, &attempt, &groups, + &cancel_min_index); delete info; } } @@ -1241,13 +1292,14 @@ fold_mem_offsets_1 (bool single_use) cancel_changes. */ if (cancel_min_index != -1) { - find_keys_to_remove (changes_map, removed_regnos, &cancel_min_index); + find_groups_to_cancel (groups.changes, groups.cancelled, + &cancel_min_index); bitmap_iterator bi; unsigned int key; - EXECUTE_IF_SET_IN_BITMAP (removed_regnos, 0, key, bi) + EXECUTE_IF_SET_IN_BITMAP (groups.cancelled, 0, key, bi) { - auto_vec *changes = changes_map.get (key); + auto_vec *changes = groups.changes.get (key); if (changes) { for (change_info *change : *changes) @@ -1259,7 +1311,7 @@ fold_mem_offsets_1 (bool single_use) delete change; } } - changes_map.remove (key); + groups.changes.remove (key); } cancel_changes (cancel_min_index); @@ -1268,51 +1320,26 @@ fold_mem_offsets_1 (bool single_use) if (cancel_min_index != 0) confirm_change_group (); - /* Copy the map into a vector and sort it for traversal. */ - unsigned int map_entries_num = changes_map.elements (); - auto_vec regno_changes_vec (map_entries_num); - - for (auto entry : changes_map) - { - auto_vec *changes_vec - = new auto_vec (entry.second.length ()); - - for (change_info *change : entry.second) - changes_vec->quick_push (change->change); - - regno_changes rc; - rc.regno = static_cast (entry.first); - rc.changes = changes_vec; - regno_changes_vec.quick_push (rc); - } - - regno_changes_vec.qsort (sort_pairs); - - for (const auto &rc : regno_changes_vec) - { - auto_vec &changes = *rc.changes; - - /* Skip already deleted instructions. */ - auto_vec live_changes (changes.length ()); - for (insn_change *change : changes) - if (change->insn ()->has_been_deleted ()) - delete change; - else - live_changes.quick_push (change); - - std::sort (live_changes.begin (), live_changes.end (), sort_changes); - crtl->ssa->change_insns (live_changes); + /* change_insns wants the changes in program order, which also makes the + result independent of the map's traversal order. */ + auto_vec live_changes; + for (auto entry : groups.changes) + for (change_info *ci : entry.second) + if (ci->change->insn ()->has_been_deleted ()) + delete ci->change; + else + live_changes.safe_push (ci->change); - for (insn_change *change : live_changes) - delete change; + std::sort (live_changes.begin (), live_changes.end (), sort_changes); + crtl->ssa->change_insns (live_changes); - delete rc.changes; - } + for (insn_change *change : live_changes) + delete change; /* Free the change_info wrappers for successful (non-cancelled) entries. Their inner insn_change has already been deleted above. Cancelled - entries were removed from changes_map and freed earlier. */ - for (auto entry : changes_map) + entries were removed from the map and freed earlier. */ + for (auto entry : groups.changes) for (change_info *ci : entry.second) delete ci; diff --git a/gcc/testsuite/gcc.target/arm/pr126412.c b/gcc/testsuite/gcc.target/arm/pr126412.c new file mode 100644 index 000000000000..914565f7e4fb --- /dev/null +++ b/gcc/testsuite/gcc.target/arm/pr126412.c @@ -0,0 +1,79 @@ +/* PR rtl-optimization/126412 */ +/* { dg-do run } */ +/* { dg-require-effective-target arm_arch_v7a_arm_multilib } */ +/* { dg-options "-O3 -fno-strict-aliasing" } */ +/* { dg-add-options arm_arch_v7a_arm } */ + +int crc32_tab[256]; +int crc32_context = -1, main_i, main_j; +long long g_9 = -9145554599436640560, g_13 = 5807806182820080170; +short g_44 = 6; +int *g_70; +static int **g_69 = &g_70; +int g_112[240] = {3}; +char g_126; +static int g_170; +signed char g_253 = 10; +short **g_486; +static long long g_590 = 1; +static long long g_609 = 1; +long func_51___trans_tmp_28; +unsigned main_crc; +void crc32_byte(char b) { + crc32_context = + crc32_context >> 8 & 16777215 ^ crc32_tab[(crc32_context ^ b) & 255]; +} +void crc32_8bytes(long long val) { + crc32_context = + crc32_context >> 8 & 16777215 ^ crc32_tab[(crc32_context ^ val) & 255]; + crc32_byte(val >> 8); + crc32_byte(val >> 16); + crc32_byte(val >> 24); + crc32_byte(val >> 32); + crc32_byte(val >> 40); + crc32_byte(val >> 48); + crc32_byte(val >> 56); +} +static int func_51() { + long __trans_tmp_26; + for (;;) { + int *l_247_1_1_4 = &g_112[8]; + signed char *l_634 = &g_253; + *g_69 = l_247_1_1_4; + if (__trans_tmp_26) + for (; g_170; g_170 -= 1) { + if (g_253) + g_126 = 0; + } + else if (func_51___trans_tmp_28) { + *g_486 = 0; + g_590 &= --g_609; + } + *l_634 |= 2; + if ((short)(__INTPTR_TYPE__)*g_69) + return 0; + } +} +int main(void) { + for (; main_i < 256; main_i++) { + main_crc = main_i; + main_j = 8; + for (; main_j; main_j--) + if (main_crc & 1) + main_crc = main_crc >> 1 ^ 3988292384; + else + main_crc >>= 1; + crc32_tab[main_i] = main_crc; + } + long long *l_8 = &g_9, *l_12 = &g_13; + *l_12 ^= ++*l_8; + g_44 = 0; + for (; g_44 != 21; ++g_44) + func_51(); + crc32_8bytes(0); + crc32_8bytes(g_9); + crc32_8bytes(g_13); + if ((unsigned)(crc32_context ^ -1) != 0xe841b57e) + __builtin_abort(); + return 0; +} From a7a38a0ca2a9a7bb9991103fe715cc69e532f91c Mon Sep 17 00:00:00 2001 From: Iain Sandoe Date: Sat, 19 Sep 2026 10:45:12 +0100 Subject: [PATCH 253/584] fixincludes, Darwin: Allow for math.h in sub-dirs of include. In some Darwin SDKs the math.h that needs fixincludes resides in an arch-specific sub-directory of /usr/include. Allow for that in the math.h fixincludes. fixincludes/ChangeLog: * fixincl.x: Regenerate. * inclhack.def: Allow for math.h in architecture/ in SDKs. Signed-off-by: Iain Sandoe --- fixincludes/fixincl.x | 6 +++--- fixincludes/inclhack.def | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/fixincludes/fixincl.x b/fixincludes/fixincl.x index 9db4d376a2e3..2045fad33afc 100644 --- a/fixincludes/fixincl.x +++ b/fixincludes/fixincl.x @@ -2,11 +2,11 @@ * * DO NOT EDIT THIS FILE (fixincl.x) * - * It has been AutoGen-ed February 15, 2026 at 11:11:08 PM by AutoGen 5.18.12 + * It has been AutoGen-ed September 19, 2026 at 10:38:43 AM by AutoGen 5.18.16 * From the definitions inclhack.def * and the template file fixincl */ -/* DO NOT MERGE THIS FILE, EITHER Sun Feb 15 23:11:08 CET 2026 +/* DO NOT MERGE THIS FILE, EITHER Sat Sep 19 10:38:43 BST 2026 * * You must regenerate it. Use the ./genfixes script. * @@ -3665,7 +3665,7 @@ tSCC zDarwin_Flt_Eval_MethodName[] = * File name selection pattern */ tSCC zDarwin_Flt_Eval_MethodList[] = - "math.h\0"; + "math.h\0architecture/i386/math.h\0architecture/ppc/math.h\0"; /* * Machine/OS name selection pattern */ diff --git a/fixincludes/inclhack.def b/fixincludes/inclhack.def index 20a7e8ef9772..3bbcb2ce25e3 100644 --- a/fixincludes/inclhack.def +++ b/fixincludes/inclhack.def @@ -1806,7 +1806,7 @@ fix = { fix = { hackname = darwin_flt_eval_method; mach = "*-*-darwin*"; - files = math.h; + files = math.h, architecture/i386/math.h, architecture/ppc/math.h; select = "^#if __FLT_EVAL_METHOD__ == 0( \\|\\| __FLT_EVAL_METHOD__ == -1)?$"; c_fix = format; c_fix_arg = "%0 || __FLT_EVAL_METHOD__ == 16"; From 3e589dedaba135625ee58ab02cecf6ed419c411c Mon Sep 17 00:00:00 2001 From: Gerald Pfeifer Date: Sun, 20 Sep 2026 17:25:27 +0200 Subject: [PATCH 254/584] libstdc++: Update URL for Josuttis' "The C++ Standard Library" This is now under a domain of its own and uses https. libstdc++-v3: * doc/xml/manual/io.xml: New URL for Josuttis' "The C++ Standard Library". * doc/html/manual/streambufs.html: Regenerate. --- libstdc++-v3/doc/html/manual/streambufs.html | 2 +- libstdc++-v3/doc/xml/manual/io.xml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/libstdc++-v3/doc/html/manual/streambufs.html b/libstdc++-v3/doc/html/manual/streambufs.html index 8ae046c294d3..a77cd09df3bf 100644 --- a/libstdc++-v3/doc/html/manual/streambufs.html +++ b/libstdc++-v3/doc/html/manual/streambufs.html @@ -8,7 +8,7 @@ excellent books: Standard C++ IOStreams and Locales by Langer and Kreft, ISBN 0-201-18395-1, and - The C++ Standard Library + The C++ Standard Library by Nicolai Josuttis, ISBN 0-201-37926-0. Both are published by Addison-Wesley, who isn't paying us a cent for saying that, honest.

    Here is a simple example, io/outbuf1, from the Josuttis text. It diff --git a/libstdc++-v3/doc/xml/manual/io.xml b/libstdc++-v3/doc/xml/manual/io.xml index adc37cd84880..3407f65ffad4 100644 --- a/libstdc++-v3/doc/xml/manual/io.xml +++ b/libstdc++-v3/doc/xml/manual/io.xml @@ -192,7 +192,7 @@ excellent books: Standard C++ IOStreams and Locales by Langer and Kreft, ISBN 0-201-18395-1, and - The C++ Standard Library + The C++ Standard Library by Nicolai Josuttis, ISBN 0-201-37926-0. Both are published by Addison-Wesley, who isn't paying us a cent for saying that, honest. From bf53cf53af96a6d976bf7d154d4db2704a74abd4 Mon Sep 17 00:00:00 2001 From: Andrea Pinski Date: Sat, 19 Sep 2026 14:40:04 -0700 Subject: [PATCH 255/584] match: Don't use for loop for maybe_cmp This does not change the output of genmatch (except for line numbers) but it simplifies the pattern in match.pd for easier understanding. Bootstrapped and tested on x86_64-linux-gnu. gcc/ChangeLog: * match.pd (maybe_cmp): Use tcc_comparison directly instead of for loop. Signed-off-by: Andrea Pinski --- gcc/match.pd | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/gcc/match.pd b/gcc/match.pd index e59c11d5d131..0dc0abe454f6 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -172,13 +172,12 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) (if (tree_nop_conversion_p (type, TREE_TYPE (@0))))) (match (bit_xor_cst @0 @1) (bit_xor @0 uniform_integer_cst_p@1)) -(for cmp (tcc_comparison) - (match (maybe_cmp @0) - (cmp@0 @1 @2)) - (match (maybe_cmp @0) - (convert (cmp@0 @1 @2)) - (if (tree_nop_conversion_p (type, TREE_TYPE (@0))))) -) +(match (maybe_cmp @0) + (tcc_comparison@0 @1 @2)) +(match (maybe_cmp @0) + (convert (tcc_comparison@0 @1 @2)) + (if (tree_nop_conversion_p (type, TREE_TYPE (@0))))) + /* `a ^ b` is another form of `a != b` when the type is a 1bit precision integer. */ (match (maybe_cmp @0) From 5feba8293972ebc07251a0251b21f8644000334a Mon Sep 17 00:00:00 2001 From: Andrea Pinski Date: Sat, 19 Sep 2026 14:43:53 -0700 Subject: [PATCH 256/584] match: Use tcc_comparison directly in one more place Instead of a for loop for, we can just use tcc_comparison directly. This changes the output of genmatch slightly but no functional changes are here. This simplifies the pattern to easier to understand really. Bootstrapped and tested on x86_64-linux-gnu. gcc/ChangeLog: * match.pd (`CMP * a`): Use tcc_comparison directly. (`(type)CMP * a`): Likewise. Signed-off-by: Andrea Pinski --- gcc/match.pd | 22 ++++++++++------------ 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/gcc/match.pd b/gcc/match.pd index 0dc0abe454f6..0e96727083f7 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -3035,19 +3035,17 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) /* (m1 CMP m2) * d -> (m1 CMP m2) ? d : 0 */ (if (fold_before_rtl_expansion_p ()) - (for cmp (tcc_comparison) - (simplify - (mult:c (convert (cmp@0 @1 @2)) @3) - (if (INTEGRAL_TYPE_P (type) - && INTEGRAL_TYPE_P (TREE_TYPE (@0))) - (cond @0 @3 { build_zero_cst (type); }))) + (simplify + (mult:c (convert (tcc_comparison@0 @1 @2)) @3) + (if (INTEGRAL_TYPE_P (type) + && INTEGRAL_TYPE_P (TREE_TYPE (@0))) + (cond @0 @3 { build_zero_cst (type); }))) /* (-(m1 CMP m2)) & d -> (m1 CMP m2) ? d : 0 */ - (simplify - (bit_and:c (negate (convert (cmp@0 @1 @2))) @3) - (if (INTEGRAL_TYPE_P (type) - && INTEGRAL_TYPE_P (TREE_TYPE (@0))) - (cond @0 @3 { build_zero_cst (type); }))) - ) + (simplify + (bit_and:c (negate (convert (tcc_comparison@0 @1 @2))) @3) + (if (INTEGRAL_TYPE_P (type) + && INTEGRAL_TYPE_P (TREE_TYPE (@0))) + (cond @0 @3 { build_zero_cst (type); }))) ) /* Canonicalize `(type) (a CMP b)` to `(a CMP b) ? (type) true : (type) false` From d1b4bf7c25ca1a57bb438b91439c0484eb73ac64 Mon Sep 17 00:00:00 2001 From: Andrea Pinski Date: Sat, 19 Sep 2026 14:57:03 -0700 Subject: [PATCH 257/584] match: Remove comparison check for a vec_cond pattern This pattern is currently: `((VCE (a cmp b ? -1 : 0)) < 0) ? c : d` But the inner comparison does not matter for VEC_COND so let's remove it to reduce generated code from genmatch. It might also optimize things that used `a & b` rather than a comparison. Though in the original case does not matter. Note this pattern can be simplified more but I am not handling that right now. Bootstrapped and tested on x86_64-linux-gnu. gcc/ChangeLog: * match.pd (`((VCE (a cmp b ? -1 : 0)) < 0) ? c : d`): Remove `(a cmp b)` match part. Signed-off-by: Andrea Pinski --- gcc/match.pd | 36 ++++++++++++++++-------------------- 1 file changed, 16 insertions(+), 20 deletions(-) diff --git a/gcc/match.pd b/gcc/match.pd index 0e96727083f7..341962a3faac 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -6850,27 +6850,23 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) (if (optimize_vectors_before_lowering_p () && types_match (@0, @3)) (vec_cond (bit_and @0 (bit_not @3)) @2 @1))) -/* ((VCE (a cmp b ? -1 : 0)) < 0) ? c : d is just - (VCE ((a cmp b) ? (VCE c) : (VCE d))) when TYPE_PRECISION of the +/* ((VCE (a ? -1 : 0)) < 0) ? c : d is just + (VCE (a ? (VCE c) : (VCE d))) when TYPE_PRECISION of the component type of the outer vec_cond is greater equal the inner one. */ -(for cmp (simple_comparison) - (simplify - (vec_cond - (lt (view_convert@5 (vec_cond@6 (cmp@4 @0 @1) - integer_all_onesp - integer_zerop)) - integer_zerop) @2 @3) - (if (VECTOR_INTEGER_TYPE_P (TREE_TYPE (@0)) - && VECTOR_INTEGER_TYPE_P (TREE_TYPE (@5)) - && !TYPE_UNSIGNED (TREE_TYPE (@5)) - && VECTOR_TYPE_P (TREE_TYPE (@6)) - && VECTOR_TYPE_P (type) - && tree_int_cst_le (TYPE_SIZE (TREE_TYPE (type)), - TYPE_SIZE (TREE_TYPE (TREE_TYPE (@6)))) - && TYPE_SIZE (type) == TYPE_SIZE (TREE_TYPE (@6))) - (with { tree vtype = TREE_TYPE (@6);} - (view_convert:type - (vec_cond @4 (view_convert:vtype @2) (view_convert:vtype @3))))))) +(simplify + (vec_cond + (lt (view_convert@5 (vec_cond@6 @4 integer_all_onesp integer_zerop)) + integer_zerop) @2 @3) + (if (VECTOR_INTEGER_TYPE_P (TREE_TYPE (@5)) + && !TYPE_UNSIGNED (TREE_TYPE (@5)) + && VECTOR_TYPE_P (TREE_TYPE (@6)) + && VECTOR_TYPE_P (type) + && tree_int_cst_le (TYPE_SIZE (TREE_TYPE (type)), + TYPE_SIZE (TREE_TYPE (TREE_TYPE (@6)))) + && TYPE_SIZE (type) == TYPE_SIZE (TREE_TYPE (@6))) + (with { tree vtype = TREE_TYPE (@6);} + (view_convert:type + (vec_cond @4 (view_convert:vtype @2) (view_convert:vtype @3)))))) /* c1 ? c2 ? a : b : b --> (c1 & c2) ? a : b */ (simplify From 02535f61b977d5886b5e176406d0ff307dadbb15 Mon Sep 17 00:00:00 2001 From: Filip Kastl Date: Sun, 20 Sep 2026 18:10:30 +0200 Subject: [PATCH 258/584] gimple: switch lowering: State that the bit test algorithm is optimal A comment regarding the bit test finding algorithm says that the algorithm "...tries to end up with as few clusters as possible". It not only tries, it actually achieves the fewest possible clusters. For people reading this code, I think it is more helpful to state that the algorithm is optimal in this regard. That's what this patch addresses. Committing as obvious. gcc/ChangeLog: * tree-switch-conversion.cc (bit_test_cluster::find_bit_tests): State that the bit test algorithm is optimal. Signed-off-by: Filip Kastl --- gcc/tree-switch-conversion.cc | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/gcc/tree-switch-conversion.cc b/gcc/tree-switch-conversion.cc index f3e77647daae..16564e5ee017 100644 --- a/gcc/tree-switch-conversion.cc +++ b/gcc/tree-switch-conversion.cc @@ -1803,8 +1803,9 @@ bit_test_cluster::find_bit_tests (vec &clusters, int max_c) Out: List of simple clusters and bit test clusters such that each bit test cluster can_be_handled() and is_beneficial() - Tries to merge consecutive clusters into bigger (bit test) ones. Tries to - end up with as few clusters as possible. */ + Merges consecutive clusters into bigger (bit test) clusters. Produces the + optimal solution -- the number of clusters in the output list is + minimal. */ unsigned l = clusters.length (); From 82112166c1be0cb29d346f5c5aa0b0c0c14db3df Mon Sep 17 00:00:00 2001 From: Dominic P Date: Sun, 20 Sep 2026 10:58:43 -0600 Subject: [PATCH 259/584] [PATCH v6] tree-optimization: hoist a shift by an out-of-range count, reducing the count Extend movement_possibility_1 to shift counts that are not known to be in range, following up on r17-3550: rather than proving the count in range, hoist the shift and reduce the count where it lands. gimple_needing_rewrite_undefined reports a shift or rotate whose count may be out of range, and rewrite_to_defined_unconditional masks it with precision - 1, or clamps it as unsigned where the precision is not a power of two. Such a shift costs 1 rather than LIM_EXPENSIVE, so it moves only with an expensive statement that depends on it. v5 asked that of every caller of the predicate, which was wrong. if-conversion rewrites the statements it makes unconditional too, so the mask reached vectorised loops as a vector BIT_AND_EXPR: one instruction per iteration, and a pack and two unpacks at 64 bits. Nine scans in gcc.target/i386/cond_op_shift_{q,ud,uq}-1.c fail on that, and the mask buys nothing, since the shift feeds a select on the original predicate. The predicate now takes a SHIFT_COUNT parameter, false by default, that only the three loop-im callers pass. Bootstrapped and regression tested on x86_64-pc-linux-gnu. Assisted-by: Claude Opus 5 (Anthropic) gcc/ChangeLog: * gimple-fold.h (gimple_needing_rewrite_undefined): Add a SHIFT_COUNT parameter defaulting to false. * gimple-fold.cc (gimple_needing_rewrite_undefined): Return true for a shift or rotate whose count may be out of range, only when SHIFT_COUNT. (rewrite_to_defined_unconditional): Reduce such a count into range. * tree-ssa-loop-im.cc (shift_needs_mask_p): New function. (determine_max_movement): Cost a shift whose count would need masking as cheap. (movement_possibility_1): Require preserved execution for a possibly out-of-range count only when the rewrite cannot reduce it or the loop is optimized for size. gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/loop-im-shift-2.c: Expect every chain but a lone shift's to move; check the masks. * gcc.dg/tree-ssa/loop-im-shift-3.c: New test. * gcc.dg/tree-ssa/loop-im-shift-4.c: New test. * gcc.dg/tree-ssa/loop-im-shift-5.c: New test. * gcc.dg/tree-ssa/loop-im-shift-6.c: New test. Signed-off-by: Dominic P --- gcc/gimple-fold.cc | 54 +++++++++++++++-- gcc/gimple-fold.h | 2 +- .../gcc.dg/tree-ssa/loop-im-shift-2.c | 58 +++++++++++++++++++ .../gcc.dg/tree-ssa/loop-im-shift-3.c | 44 ++++++++++++++ .../gcc.dg/tree-ssa/loop-im-shift-4.c | 28 +++++++++ .../gcc.dg/tree-ssa/loop-im-shift-5.c | 13 +++++ .../gcc.dg/tree-ssa/loop-im-shift-6.c | 48 +++++++++++++++ gcc/tree-ssa-loop-im.cc | 38 ++++++++++-- 8 files changed, 273 insertions(+), 12 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-2.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-3.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-4.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-5.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-6.c diff --git a/gcc/gimple-fold.cc b/gcc/gimple-fold.cc index e3df0d1163c7..3f4c979793bc 100644 --- a/gcc/gimple-fold.cc +++ b/gcc/gimple-fold.cc @@ -10960,10 +10960,12 @@ arith_code_with_undefined_signed_overflow (tree_code code) integer types involves undefined behavior on overflow and the operation can be expressed with unsigned arithmetic. Also returns true if STMT is a VCE that needs to be rewritten - if moved to be executed unconditionally. */ + if moved to be executed unconditionally. + SHIFT_COUNT additionally asks for a shift or rotate whose count may be + out of range; rewrite_to_defined_unconditional reduces such a count. */ bool -gimple_needing_rewrite_undefined (gimple *stmt) +gimple_needing_rewrite_undefined (gimple *stmt, bool shift_count) { if (!is_gimple_assign (stmt)) return false; @@ -10998,10 +11000,22 @@ gimple_needing_rewrite_undefined (gimple *stmt) && TYPE_PRECISION (lhs_type) < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (rhs, 0)))) return true; + /* A shift or rotate by a count that may be out of range; the count can + be reduced into range. */ + enum tree_code code = gimple_assign_rhs_code (stmt); + if (shift_count + && (code == LSHIFT_EXPR + || code == RSHIFT_EXPR + || code == LROTATE_EXPR + || code == RROTATE_EXPR) + && INTEGRAL_TYPE_P (lhs_type) + && (TREE_CODE (gimple_assign_rhs2 (stmt)) != INTEGER_CST + || wi::geu_p (wi::to_wide (gimple_assign_rhs2 (stmt)), + TYPE_PRECISION (lhs_type)))) + return true; if (!TYPE_OVERFLOW_UNDEFINED (lhs_type)) return false; - if (!arith_code_with_undefined_signed_overflow - (gimple_assign_rhs_code (stmt))) + if (!arith_code_with_undefined_signed_overflow (code)) return false; return true; } @@ -11020,7 +11034,7 @@ static gimple_seq rewrite_to_defined_unconditional (gimple_stmt_iterator *gsi, gimple *stmt, bool in_place) { - gcc_assert (gimple_needing_rewrite_undefined (stmt)); + gcc_assert (gimple_needing_rewrite_undefined (stmt, true)); if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, "rewriting stmt for being unconditional defined"); @@ -11099,6 +11113,36 @@ rewrite_to_defined_unconditional (gimple_stmt_iterator *gsi, gimple *stmt, } return stmts; } + /* Reduce a shift or rotate count into range. The mask keeps the count's + own type where that holds PREC - 1, so that a SHIFT_COUNT_TRUNCATED + target folds it away; MIN needs an unsigned count so a negative one + clamps. */ + enum tree_code code = gimple_assign_rhs_code (stmt); + if (code == LSHIFT_EXPR + || code == RSHIFT_EXPR + || code == LROTATE_EXPR + || code == RROTATE_EXPR) + { + unsigned prec = TYPE_PRECISION (TREE_TYPE (lhs)); + bool pow2 = pow2p_hwi (prec); + tree count = gimple_assign_rhs2 (stmt); + tree type = TREE_TYPE (count); + if (!pow2 || wi::ltu_p (wi::max_value (type), prec - 1)) + type = unsigned_type_node; + count = gimple_convert (&stmts, type, count); + count = gimple_build (&stmts, pow2 ? BIT_AND_EXPR : MIN_EXPR, type, + count, build_int_cst (type, prec - 1)); + gimple_assign_set_rhs2 (stmt, count); + gimple_set_modified (stmt, true); + if (in_place) + { + gsi_insert_seq_before (gsi, stmts, GSI_SAME_STMT); + update_stmt (stmt); + return NULL; + } + gimple_seq_add_stmt (&stmts, stmt); + return stmts; + } tree type = unsigned_type_for (TREE_TYPE (lhs)); if (gimple_assign_rhs_code (stmt) == ABS_EXPR) gimple_assign_set_rhs_code (stmt, ABSU_EXPR); diff --git a/gcc/gimple-fold.h b/gcc/gimple-fold.h index f18535607791..febc15330c82 100644 --- a/gcc/gimple-fold.h +++ b/gcc/gimple-fold.h @@ -61,7 +61,7 @@ extern tree gimple_fold_indirect_ref (tree); extern bool gimple_fold_builtin_sprintf (gimple_stmt_iterator *); extern bool gimple_fold_builtin_snprintf (gimple_stmt_iterator *); extern bool arith_code_with_undefined_signed_overflow (tree_code); -extern bool gimple_needing_rewrite_undefined (gimple *); +extern bool gimple_needing_rewrite_undefined (gimple *, bool = false); extern void rewrite_to_defined_unconditional (gimple_stmt_iterator *); extern gimple_seq rewrite_to_defined_unconditional (gimple *); extern void replace_call_with_value (gimple_stmt_iterator *, tree); diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-2.c b/gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-2.c new file mode 100644 index 000000000000..15c3f7b5e0db --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-2.c @@ -0,0 +1,58 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-lim2-details -fdump-tree-optimized" } */ + +/* The count is already in range: hoisted without a further mask. */ + +void f (int *p, int n, int a, unsigned int s, int c, int *q) +{ + s &= 7; + for (int i = 0; i < n; i++) + if (p[i] > c) + q[i] = ((a << s) * 5) / 7; +} + +/* An unconstrained count is masked at the hoisted shift. */ + +void g (int *p, int n, int a, unsigned int s, int c, int *q) +{ + for (int i = 0; i < n; i++) + if (p[i] > c) + q[i] = ((a << s) * 5) / 7; +} + +/* A mask that does not bound the count below the precision is refined. */ + +void h (int *p, int n, int a, unsigned int s, int c, int *q) +{ + s &= 63; + for (int i = 0; i < n; i++) + if (p[i] > c) + q[i] = ((a << s) * 5) / 7; +} + +/* The guard's range is exported as global by VRP, so no mask survives. */ + +void k (int *p, int n, int a, unsigned int s, int c, int *q) +{ + for (int i = 0; i < n; i++) + if (p[i] > c) + { + if (s > 7) __builtin_unreachable (); + q[i] = ((a << s) * 5) / 7; + } +} + +/* A lone shift that would need a mask is not worth moving by itself. */ + +void m (int *p, int n, int a, unsigned int s, int c, int *q) +{ + for (int i = 0; i < n; i++) + if (p[i] > c) + q[i] = a << s; +} + +/* Every chain but m's moves: the shift, the multiply and the divide. */ +/* { dg-final { scan-tree-dump-times "Moving statement" 12 "lim2" } } */ +/* { dg-final { scan-tree-dump-times "Moving statement \[^\\r\\n\]*<<" 4 "lim2" } } */ +/* f's count was masked by 7 already; g and h get a mask of 31. */ +/* { dg-final { scan-tree-dump-times " & 31;" 2 "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-3.c b/gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-3.c new file mode 100644 index 000000000000..03250059e583 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-3.c @@ -0,0 +1,44 @@ +/* { dg-do run } */ +/* { dg-options "-O2" } */ + +/* The shift is hoisted with its count masked; a count out of range on an + iteration that never reaches the shift must not affect the result. */ + +__attribute__ ((noipa)) void +k (int *p, int n, int a, unsigned int s, int c, int *q) +{ + for (int i = 0; i < n; i++) + if (p[i] > c) + { + if (s > 7) __builtin_unreachable (); + q[i] = ((a << s) * 5) / 7; + } +} + +__attribute__ ((noipa)) void +g (int *p, int n, int a, unsigned int s, int c, int *q) +{ + for (int i = 0; i < n; i++) + if (p[i] > c) + q[i] = (a << s) * 5; +} + +int +main (void) +{ + int p[4] = { 1, 5, 2, 9 }; + int q[4] = { -1, -1, -1, -1 }; + k (p, 4, 3, 40u, 100, q); + g (p, 4, 3, 77u, 100, q); + for (int i = 0; i < 4; i++) + if (q[i] != -1) + __builtin_abort (); + k (p, 4, 3, 2u, 4, q); + if (q[0] != -1 || q[1] != (3 << 2) * 5 / 7 || q[2] != -1 + || q[3] != (3 << 2) * 5 / 7) + __builtin_abort (); + g (p, 4, 3, 3u, 4, q); + if (q[1] != (3 << 3) * 5 || q[3] != (3 << 3) * 5) + __builtin_abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-4.c b/gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-4.c new file mode 100644 index 000000000000..a580c5a53b6b --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-4.c @@ -0,0 +1,28 @@ +/* { dg-do run { target bitint } } */ +/* { dg-options "-O2 -std=c23 -fdump-tree-optimized" } */ + +/* A non-power-of-two precision clamps the count to the precision - 1. */ + +__attribute__ ((noipa)) void +f (int *p, int n, _BitInt(24) a, unsigned int s, int c, _BitInt(24) *q) +{ + for (int i = 0; i < n; i++) + if (p[i] > c) + q[i] = ((a << s) * 5) / 7; +} + +int +main (void) +{ + int p[2] = { 1, 9 }; + _BitInt(24) q[2] = { 0, 0 }; + f (p, 2, 1, 40u, 100, q); + if (q[0] != 0 || q[1] != 0) + __builtin_abort (); + f (p, 2, 1, 8u, 4, q); + if (q[0] != 0 || q[1] != ((_BitInt(24)) 1 << 8) * 5 / 7) + __builtin_abort (); + return 0; +} + +/* { dg-final { scan-tree-dump "MIN_EXPR <\[^,\]*, 23>" "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-5.c b/gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-5.c new file mode 100644 index 000000000000..859ff3d3625f --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-5.c @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-options "-Os -fdump-tree-lim2-details" } */ + +/* When optimizing for size a shift that would need a mask stays put. */ + +void g (int *p, int n, int a, unsigned int s, int c, int *q) +{ + for (int i = 0; i < n; i++) + if (p[i] > c) + q[i] = ((a << s) * 5) / 7; +} + +/* { dg-final { scan-tree-dump-not "Moving statement" "lim2" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-6.c b/gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-6.c new file mode 100644 index 000000000000..866c02625c50 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/loop-im-shift-6.c @@ -0,0 +1,48 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fgimple -fdump-tree-lim2-details" } */ + +/* An out-of-range constant count is reduced into range where the shift + lands, as a non-constant one is. */ + +int __GIMPLE (ssa, startwith ("lim")) +f (int x, int n) +{ + int i; + int r; + int _1; + int _2; + + __BB(2): + goto __BB6; + + __BB(3): + _1 = i_5 & 1; + if (_1 != 0) + goto __BB4; + else + goto __BB5; + + __BB(4): + _2 = x_8(D) << 33; + r_9 = _2 / 5; + goto __BB5; + + __BB(5): + r_3 = __PHI (__BB4: r_9, __BB3: r_4); + i_10 = i_5 + 1; + goto __BB6; + + __BB(6,loop_header(1)): + r_4 = __PHI (__BB2: 1, __BB5: r_3); + i_5 = __PHI (__BB2: 0, __BB5: i_10); + if (i_5 < n_7(D)) + goto __BB3; + else + goto __BB7; + + __BB(7): + return r_4; +} + +/* { dg-final { scan-tree-dump-times "Moving statement" 2 "lim2" } } */ +/* { dg-final { scan-tree-dump " << 1;" "lim2" } } */ diff --git a/gcc/tree-ssa-loop-im.cc b/gcc/tree-ssa-loop-im.cc index f38a5831b585..162b30ad2859 100644 --- a/gcc/tree-ssa-loop-im.cc +++ b/gcc/tree-ssa-loop-im.cc @@ -416,9 +416,9 @@ movement_possibility_1 (gimple *stmt) { auto code = gimple_assign_rhs_code (stmt); tree type = TREE_TYPE (gimple_assign_rhs1 (stmt)); - /* For shifts and rotates and possibly out-of-bound shift operands - we currently cannot rewrite them into something unconditionally - well-defined. */ + /* A shift or rotate by a possibly out-of-bound count moves only where + rewrite_to_defined_unconditional can reduce the count, and not at + all when optimizing for size. */ if ((code == LSHIFT_EXPR || code == RSHIFT_EXPR || code == LROTATE_EXPR @@ -426,7 +426,9 @@ movement_possibility_1 (gimple *stmt) && (TREE_CODE (gimple_assign_rhs2 (stmt)) != INTEGER_CST /* We cannot use ranges at 'stmt' here. */ || wi::geu_p (wi::to_wide (gimple_assign_rhs2 (stmt)), - element_precision (type)))) + element_precision (type))) + && (!gimple_needing_rewrite_undefined (stmt, true) + || optimize_loop_for_size_p (loop_containing_stmt (stmt)))) ret = MOVE_PRESERVE_EXECUTION; } @@ -780,6 +782,26 @@ extract_true_false_args_from_phi (basic_block dom, gphi *phi, return true; } +/* Return true if STMT is a shift or rotate whose count would have to be + masked when moved out of LOOP, because STMT is not always executed + when LOOP is entered. An out-of-range constant count folds instead. */ + +static bool +shift_needs_mask_p (gimple *stmt, class loop *loop) +{ + if (!gimple_needing_rewrite_undefined (stmt, true)) + return false; + enum tree_code code = gimple_assign_rhs_code (stmt); + if ((code != LSHIFT_EXPR + && code != RSHIFT_EXPR + && code != LROTATE_EXPR + && code != RROTATE_EXPR) + || TREE_CODE (gimple_assign_rhs2 (stmt)) == INTEGER_CST) + return false; + class loop *always = get_lim_data (stmt)->always_executed_in; + return !always || !(always == loop || flow_loop_nested_p (always, loop)); +} + /* Determine the outermost loop to that it is possible to hoist a statement STMT and store it to LIM_DATA (STMT)->max_loop. To do this we determine the outermost loop in that the value computed by STMT is invariant. @@ -929,7 +951,11 @@ determine_max_movement (gimple *stmt, bool must_preserve_exec) return false; } - lim_data->cost += stmt_cost (stmt); + /* A shift that needs its count masked is not worth moving on its own. */ + unsigned cost = stmt_cost (stmt); + if (cost >= LIM_EXPENSIVE && shift_needs_mask_p (stmt, lim_data->max_loop)) + cost = 1; + lim_data->cost += cost; return true; } @@ -1427,7 +1453,7 @@ move_computations_worker (basic_block bb) when the target loop header is executed and the stmt may invoke undefined integer or pointer overflow rewrite it to unsigned arithmetic. */ - if (gimple_needing_rewrite_undefined (stmt) + if (gimple_needing_rewrite_undefined (stmt, true) && (!ALWAYS_EXECUTED_IN (bb) || !(ALWAYS_EXECUTED_IN (bb) == level || flow_loop_nested_p (ALWAYS_EXECUTED_IN (bb), level)))) From 2d2e355b89367711f549b1277a537e2c0a4de58d Mon Sep 17 00:00:00 2001 From: Philipp Tomsich Date: Mon, 24 Aug 2026 17:13:40 +0200 Subject: [PATCH 260/584] widening_mul: Emit zero high-half partials for operands that fit [PR127042] build_long_mul_partials splits both operands into halves regardless of what is known about them. An operand provably within the half width still gets a shift and two partial products against its high half, which is zero. They reach expand, and the carry arithmetic built on top of them survives into the final code. Reuse the recognizer's fits test: a provably-fitting operand keeps its low half unmasked and contributes literal zeros as high-half partials, so the cross sum, carry test and accumulate fold as the sequence is built. The u16-operand high part comes out as the two multiplies it needs. Bootstrapped and regtested on AArch64, x86-64 and ARM. Regtested on AVR. PR tree-optimization/127042 gcc/ChangeLog: * tree-ssa-math-opts.cc (build_long_mul_partials): Emit zero high-half partial products, and skip the high-half split and the low-half mask, for an operand that provably fits the half width. gcc/testsuite/ChangeLog: * gcc.target/arm/pr127042.c: New test. * gcc.target/avr/mmcu/pr127042.c: New test. Co-authored-by: Konstantinos Eleftheriou --- gcc/testsuite/gcc.target/arm/pr127042.c | 23 ++++++++++++ gcc/testsuite/gcc.target/avr/mmcu/pr127042.c | 22 +++++++++++ gcc/tree-ssa-math-opts.cc | 39 +++++++++++++++----- 3 files changed, 74 insertions(+), 10 deletions(-) create mode 100644 gcc/testsuite/gcc.target/arm/pr127042.c create mode 100644 gcc/testsuite/gcc.target/avr/mmcu/pr127042.c diff --git a/gcc/testsuite/gcc.target/arm/pr127042.c b/gcc/testsuite/gcc.target/arm/pr127042.c new file mode 100644 index 000000000000..66368c8bb349 --- /dev/null +++ b/gcc/testsuite/gcc.target/arm/pr127042.c @@ -0,0 +1,23 @@ +/* PR tree-optimization/127042 */ +/* { dg-do compile } */ +/* { dg-require-effective-target arm_thumb1_ok } */ +/* { dg-options "-O2 -mthumb -mcpu=cortex-m0 -fdump-tree-widening_mul" } */ + +typedef __UINT16_TYPE__ uint16_t; +typedef __UINT32_TYPE__ uint32_t; +typedef __UINT64_TYPE__ uint64_t; + +/* x fits 16 bits: only x * 0xaaab and x * 0xaaaa remain. */ +uint16_t fits (uint16_t x) +{ + return ((uint64_t) x * 0xaaaaaaab) >> 32; +} + +/* Neither operand fits: the full four-partial longhand stays. */ +uint32_t nofit (uint32_t x, uint32_t y) +{ + return ((uint64_t) x * (uint64_t) y) >> 32; +} + +/* Two multiplies from fits, four from nofit. */ +/* { dg-final { scan-tree-dump-times " \\* " 6 "widening_mul" } } */ diff --git a/gcc/testsuite/gcc.target/avr/mmcu/pr127042.c b/gcc/testsuite/gcc.target/avr/mmcu/pr127042.c new file mode 100644 index 000000000000..b047ce92aa69 --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/mmcu/pr127042.c @@ -0,0 +1,22 @@ +/* PR tree-optimization/127042 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -mmcu=avr2 -fdump-tree-widening_mul" } */ + +typedef __UINT16_TYPE__ uint16_t; +typedef __UINT32_TYPE__ uint32_t; +typedef __UINT64_TYPE__ uint64_t; + +/* x fits 16 bits: only x * 0xaaab and x * 0xaaaa remain. */ +uint16_t fits (uint16_t x) +{ + return ((uint64_t) x * 0xaaaaaaab) >> 32; +} + +/* Neither operand fits: the full four-partial longhand stays. */ +uint32_t nofit (uint32_t x, uint32_t y) +{ + return ((uint64_t) x * (uint64_t) y) >> 32; +} + +/* Two multiplies from fits, four from nofit. */ +/* { dg-final { scan-tree-dump-times " \\* " 6 "widening_mul" } } */ diff --git a/gcc/tree-ssa-math-opts.cc b/gcc/tree-ssa-math-opts.cc index 2efd70f27f64..450116add1d3 100644 --- a/gcc/tree-ssa-math-opts.cc +++ b/gcc/tree-ssa-math-opts.cc @@ -6569,12 +6569,16 @@ can_widen_to_narrow_p (scalar_int_mode narrow_mode, unsigned int half_width, != CODE_FOR_nothing; } +static bool long_mul_op_fits_p (tree, unsigned, bitmap); + /* Append to *SEQ the operand split and partial products for an unsigned long multiply of OP1 by OP2 at the precision of TREE_TYPE (OP1). HALF_TYPE is the (N/2)-bit unsigned type; HALF_AMT is the integer-typed shift constant equal to N/2. Outputs the four partial products via *LOLO, *HILO, *LOHI, *HIHI. + An operand provably within N/2 bits contributes literal-zero high + partials. USE_WIDEN selects the partial-product form: true - cast halves to HALF_TYPE and use WIDEN_MULT_EXPR (needs @@ -6590,8 +6594,16 @@ build_long_mul_partials (gimple_seq *seq, location_t loc, tree op1, tree op2, bool use_widen) { tree acc_type = TREE_TYPE (op1); - tree op1_hi = gimple_build (seq, loc, RSHIFT_EXPR, acc_type, op1, half_amt); - tree op2_hi = gimple_build (seq, loc, RSHIFT_EXPR, acc_type, op2, half_amt); + unsigned int half_prec = TYPE_PRECISION (half_type); + auto_bitmap phi_seen1, phi_seen2; + bool op1_fits = long_mul_op_fits_p (op1, half_prec, phi_seen1); + bool op2_fits = long_mul_op_fits_p (op2, half_prec, phi_seen2); + tree zero = build_zero_cst (acc_type); + tree op1_hi = NULL_TREE, op2_hi = NULL_TREE; + if (!op1_fits) + op1_hi = gimple_build (seq, loc, RSHIFT_EXPR, acc_type, op1, half_amt); + if (!op2_fits) + op2_hi = gimple_build (seq, loc, RSHIFT_EXPR, acc_type, op2, half_amt); tree op1_lo, op2_lo; tree_code mul_code; @@ -6599,24 +6611,31 @@ build_long_mul_partials (gimple_seq *seq, location_t loc, tree op1, tree op2, { op1_lo = gimple_build (seq, loc, NOP_EXPR, half_type, op1); op2_lo = gimple_build (seq, loc, NOP_EXPR, half_type, op2); - op1_hi = gimple_build (seq, loc, NOP_EXPR, half_type, op1_hi); - op2_hi = gimple_build (seq, loc, NOP_EXPR, half_type, op2_hi); + if (op1_hi) + op1_hi = gimple_build (seq, loc, NOP_EXPR, half_type, op1_hi); + if (op2_hi) + op2_hi = gimple_build (seq, loc, NOP_EXPR, half_type, op2_hi); mul_code = WIDEN_MULT_EXPR; } else { tree mask = wide_int_to_tree (acc_type, - wi::mask (TYPE_PRECISION (half_type), false, + wi::mask (half_prec, false, TYPE_PRECISION (acc_type))); - op1_lo = gimple_build (seq, loc, BIT_AND_EXPR, acc_type, op1, mask); - op2_lo = gimple_build (seq, loc, BIT_AND_EXPR, acc_type, op2, mask); + op1_lo = op1_fits ? op1 + : gimple_build (seq, loc, BIT_AND_EXPR, acc_type, op1, mask); + op2_lo = op2_fits ? op2 + : gimple_build (seq, loc, BIT_AND_EXPR, acc_type, op2, mask); mul_code = MULT_EXPR; } *lolo = gimple_build (seq, loc, mul_code, acc_type, op1_lo, op2_lo); - *hilo = gimple_build (seq, loc, mul_code, acc_type, op1_hi, op2_lo); - *lohi = gimple_build (seq, loc, mul_code, acc_type, op1_lo, op2_hi); - *hihi = gimple_build (seq, loc, mul_code, acc_type, op1_hi, op2_hi); + *hilo = op1_fits ? zero + : gimple_build (seq, loc, mul_code, acc_type, op1_hi, op2_lo); + *lohi = op2_fits ? zero + : gimple_build (seq, loc, mul_code, acc_type, op1_lo, op2_hi); + *hihi = op1_fits || op2_fits ? zero + : gimple_build (seq, loc, mul_code, acc_type, op1_hi, op2_hi); } /* Emit into *SEQ the high N bits of the unsigned product A * B, where A and B From 178835acba38205ffec57ce01af1b26e440f06b3 Mon Sep 17 00:00:00 2001 From: Konstantinos Eleftheriou Date: Tue, 25 Aug 2026 16:28:15 +0200 Subject: [PATCH 261/584] widening_mul: Factor the long-mul operand split into a helper build_long_mul_partials handled the two operands with duplicated inline code. Move the per-operand half split into build_long_mul_partial_operand. No functional change. Only the order in which the two operands' halves are emitted differs. gcc/ChangeLog: * tree-ssa-math-opts.cc (build_long_mul_partial_operand): New function. (build_long_mul_partials): Use it. --- gcc/tree-ssa-math-opts.cc | 85 ++++++++++++++++++++++----------------- 1 file changed, 47 insertions(+), 38 deletions(-) diff --git a/gcc/tree-ssa-math-opts.cc b/gcc/tree-ssa-math-opts.cc index 450116add1d3..df418435d0be 100644 --- a/gcc/tree-ssa-math-opts.cc +++ b/gcc/tree-ssa-math-opts.cc @@ -6571,6 +6571,41 @@ can_widen_to_narrow_p (scalar_int_mode narrow_mode, unsigned int half_width, static bool long_mul_op_fits_p (tree, unsigned, bitmap); +/* Build into *SEQ the (N/2)-bit halves *LO and *HI of OP, in the form + USE_WIDEN selects. An operand provably within N/2 bits has a zero + high half: *HI is left null. */ + +static void +build_long_mul_partial_operand (gimple_seq *seq, location_t loc, tree op, + tree half_type, tree half_amt, bool use_widen, + tree *lo, tree *hi) +{ + tree acc_type = TREE_TYPE (op); + unsigned int half_prec = TYPE_PRECISION (half_type); + auto_bitmap phi_seen; + bool fits = long_mul_op_fits_p (op, half_prec, phi_seen); + + *hi = NULL_TREE; + if (!fits) + *hi = gimple_build (seq, loc, RSHIFT_EXPR, acc_type, op, half_amt); + + if (use_widen) + { + *lo = gimple_build (seq, loc, NOP_EXPR, half_type, op); + if (*hi) + *hi = gimple_build (seq, loc, NOP_EXPR, half_type, *hi); + } + else if (fits) + *lo = op; + else + { + tree mask = wide_int_to_tree (acc_type, + wi::mask (half_prec, false, + TYPE_PRECISION (acc_type))); + *lo = gimple_build (seq, loc, BIT_AND_EXPR, acc_type, op, mask); + } +} + /* Append to *SEQ the operand split and partial products for an unsigned long multiply of OP1 by OP2 at the precision of TREE_TYPE (OP1). HALF_TYPE is the (N/2)-bit unsigned type; HALF_AMT is the integer-typed @@ -6594,48 +6629,22 @@ build_long_mul_partials (gimple_seq *seq, location_t loc, tree op1, tree op2, bool use_widen) { tree acc_type = TREE_TYPE (op1); - unsigned int half_prec = TYPE_PRECISION (half_type); - auto_bitmap phi_seen1, phi_seen2; - bool op1_fits = long_mul_op_fits_p (op1, half_prec, phi_seen1); - bool op2_fits = long_mul_op_fits_p (op2, half_prec, phi_seen2); tree zero = build_zero_cst (acc_type); - tree op1_hi = NULL_TREE, op2_hi = NULL_TREE; - if (!op1_fits) - op1_hi = gimple_build (seq, loc, RSHIFT_EXPR, acc_type, op1, half_amt); - if (!op2_fits) - op2_hi = gimple_build (seq, loc, RSHIFT_EXPR, acc_type, op2, half_amt); - tree op1_lo, op2_lo; - tree_code mul_code; + tree_code mul_code = use_widen ? WIDEN_MULT_EXPR : MULT_EXPR; + tree op1_lo, op1_hi, op2_lo, op2_hi; - if (use_widen) - { - op1_lo = gimple_build (seq, loc, NOP_EXPR, half_type, op1); - op2_lo = gimple_build (seq, loc, NOP_EXPR, half_type, op2); - if (op1_hi) - op1_hi = gimple_build (seq, loc, NOP_EXPR, half_type, op1_hi); - if (op2_hi) - op2_hi = gimple_build (seq, loc, NOP_EXPR, half_type, op2_hi); - mul_code = WIDEN_MULT_EXPR; - } - else - { - tree mask = wide_int_to_tree (acc_type, - wi::mask (half_prec, false, - TYPE_PRECISION (acc_type))); - op1_lo = op1_fits ? op1 - : gimple_build (seq, loc, BIT_AND_EXPR, acc_type, op1, mask); - op2_lo = op2_fits ? op2 - : gimple_build (seq, loc, BIT_AND_EXPR, acc_type, op2, mask); - mul_code = MULT_EXPR; - } + build_long_mul_partial_operand (seq, loc, op1, half_type, half_amt, use_widen, + &op1_lo, &op1_hi); + build_long_mul_partial_operand (seq, loc, op2, half_type, half_amt, use_widen, + &op2_lo, &op2_hi); *lolo = gimple_build (seq, loc, mul_code, acc_type, op1_lo, op2_lo); - *hilo = op1_fits ? zero - : gimple_build (seq, loc, mul_code, acc_type, op1_hi, op2_lo); - *lohi = op2_fits ? zero - : gimple_build (seq, loc, mul_code, acc_type, op1_lo, op2_hi); - *hihi = op1_fits || op2_fits ? zero - : gimple_build (seq, loc, mul_code, acc_type, op1_hi, op2_hi); + *hilo = op1_hi + ? gimple_build (seq, loc, mul_code, acc_type, op1_hi, op2_lo) : zero; + *lohi = op2_hi + ? gimple_build (seq, loc, mul_code, acc_type, op1_lo, op2_hi) : zero; + *hihi = op1_hi && op2_hi + ? gimple_build (seq, loc, mul_code, acc_type, op1_hi, op2_hi) : zero; } /* Emit into *SEQ the high N bits of the unsigned product A * B, where A and B From 4bcae7a19c18b2212c503c836088749e56238336 Mon Sep 17 00:00:00 2001 From: Yongqiang Tian Date: Sun, 20 Sep 2026 12:18:36 -0600 Subject: [PATCH 262/584] [PATCH v2] ifcvt: Ignore debug insns in noce lifetime check [PR127423] A DEBUG_INSN VAR_LOCATION can mention if_info->x without representing an ordinary use. Exclude debug instructions from the overlap scan so that debug-only payloads do not suppress min/max if-conversion. Assisted-by: OpenAI Codex 5.6 Sol, co-reviewed by Claude and Yongqiang Tian. --- Thanks for pointing this out. I checked the RTL immediately after `ce2`, rather than relying only on what var-tracking eventually produces. For the reported case, the transformed sequence first binds `xghost` to the old value of `if_info->x`, then defines `if_info->x` with `smin`, and only then binds `result` to the new value. The register is already defined at the first debug bind, and no ordinary instruction changes it before that program point. This ordering also follows from the interval involved here: the check scans `(cond_earliest, jump]`, while the merged definition is emitted at the former jump position. Ignoring the debug instruction in this membership check does not move the bind across the new definition. As a secondary check, var-tracking represents `xghost` using the entry value when that value is recoverable. In an additional variant where an opaque read-write asm operand prevents recovery of the old value, var-tracking makes `xghost` unavailable instead of associating it with the new minimum. Based on these checks, I do not think an explicit reset is needed in `noce_get_alt_condition` for this transformation. I also strengthened the regression test. `-fcompare-debug` alone can pass vacuously if `ce2` stops performing the conversion in both compilations. The test now compiles explicitly with `-g`, retains `-fcompare-debug`, and checks that the resulting assembly contains exactly one `min`. The strengthened test produces 14 expected passes with the patched compiler. The pristine compiler reports seven `-fcompare-debug failure (length)` failures, and a separate control with `ce2` disabled fails the assembly check. Thank you very much for your help. Any further suggestions would be greatly appreciated. Changes in v2: - Compile the regression test explicitly with `-g`. - Retain `-fcompare-debug` to check debug/no-debug convergence. - Require exactly one RISC-V `min` instruction so the test cannot pass without exercising the intended if-conversion. PR rtl-optimization/127423 gcc/ChangeLog: * ifcvt.cc (noce_get_alt_condition): Ignore debug instructions when checking whether if_info->x is mentioned in the interval. gcc/testsuite/ChangeLog: * gcc.target/riscv/pr127423.c: New test. Signed-off-by: Yongqiang Tian --- gcc/ifcvt.cc | 3 ++- gcc/testsuite/gcc.target/riscv/pr127423.c | 18 ++++++++++++++++++ 2 files changed, 20 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.target/riscv/pr127423.c diff --git a/gcc/ifcvt.cc b/gcc/ifcvt.cc index 7d23ce115bdb..618c2976c5d7 100644 --- a/gcc/ifcvt.cc +++ b/gcc/ifcvt.cc @@ -3038,7 +3038,8 @@ noce_get_alt_condition (noce_if_info *if_info, rtx target, /* X may not be mentioned in the range (cond_earliest, jump]. */ for (insn = if_info->jump; insn != *earliest; insn = PREV_INSN (insn)) - if (INSN_P (insn) && reg_overlap_mentioned_p (if_info->x, PATTERN (insn))) + if (NONDEBUG_INSN_P (insn) + && reg_overlap_mentioned_p (if_info->x, PATTERN (insn))) return NULL; /* A and B may not be modified in the range [cond_earliest, jump). */ diff --git a/gcc/testsuite/gcc.target/riscv/pr127423.c b/gcc/testsuite/gcc.target/riscv/pr127423.c new file mode 100644 index 000000000000..7c1e25bf6400 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/pr127423.c @@ -0,0 +1,18 @@ +/* PR rtl-optimization/127423 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -g -fno-tree-forwprop -fdisable-tree-phiopt1 -fdisable-tree-phiopt2 -fdisable-tree-phiopt3 -fdisable-tree-phiopt4 -march=rv64gc_zbb -mabi=lp64d -ffunction-sections -fcompare-debug" } */ +/* { dg-final { scan-assembler-times {\mmin\t} 1 } } */ + +#define ATTR __attribute__ ((noinline, noclone)) + +ATTR int +debug_payload_min (int a, int b) +{ + _Bool pred = a < b; + asm volatile ("" : : "r" (pred)); + int result = b; + int xghost = a; + if (pred) + result = a; + return result; +} From 1e804ce1c82809ce573217f0c675a0f3731d9199 Mon Sep 17 00:00:00 2001 From: Iain Sandoe Date: Sat, 12 Sep 2026 18:03:19 +0100 Subject: [PATCH 263/584] common, x86, Darwin: Query kernel for avx512 support. Darwin enables the avx512 state in XCR0 lazily which means that a constructor querying it is unreliable. However, the kernel will correctly report the availability, so query that. gcc/ChangeLog: * common/config/i386/cpuinfo.h (darwin_get_kernel_bool): New. (get_available_features): Query kernel for avx512 availability on Darwin. Signed-off-by: Iain Sandoe --- gcc/common/config/i386/cpuinfo.h | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/gcc/common/config/i386/cpuinfo.h b/gcc/common/config/i386/cpuinfo.h index a689afabd3d1..f433810457b9 100644 --- a/gcc/common/config/i386/cpuinfo.h +++ b/gcc/common/config/i386/cpuinfo.h @@ -782,6 +782,17 @@ get_zhaoxin_cpu (struct __processor_model *cpu_model, return cpu; } +#ifdef __APPLE__ +#include +/* Will return false if the queried state is either absent or 0. */ +static inline int +darwin_get_kernel_bool (const char *name) +{ + int val = 0; size_t len = sizeof (val); + return sysctlbyname (name, &val, &len, NULL, 0) == 0 && val != 0; +} +#endif + /* ECX and EDX are output of CPUID at level one. */ static inline void get_available_features (struct __processor_model *cpu_model, @@ -840,8 +851,14 @@ get_available_features (struct __processor_model *cpu_model, if ((xcrlow & XCR_AVX_ENABLED_MASK) == XCR_AVX_ENABLED_MASK) { avx_usable = 1; +#ifdef __APPLE__ + /* Darwin enables the avx512 XSAVE state lazily, so a constructor + that reads XCR0 is not reliable - query the kernel instead. */ + avx512_usable = darwin_get_kernel_bool ("hw.optional.avx512f"); +#else avx512_usable = ((xcrlow & XCR_AVX512F_ENABLED_MASK) == XCR_AVX512F_ENABLED_MASK); +#endif } amx_usable = ((xcrlow & XCR_AMX_ENABLED_MASK) == XCR_AMX_ENABLED_MASK); From 549ec717abb79c26186af06e01c937b4613c79ba Mon Sep 17 00:00:00 2001 From: Iain Sandoe Date: Mon, 14 Sep 2026 09:24:04 +0100 Subject: [PATCH 264/584] testsuite, x86, Darwin: Read avx512 availability from the kernel. Darwin enables the avx512 XSAVE state lazily; reading XCR0 is not reliable - query the kernel instead. gcc/testsuite/ChangeLog: * lib/target-supports.exp (check_avx512_os_support_available): Query the kernel for avx512 availability on Darwin. Signed-off-by: Iain Sandoe --- gcc/testsuite/lib/target-supports.exp | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp index cbd39301a8bd..5eb44cb3ee42 100644 --- a/gcc/testsuite/lib/target-supports.exp +++ b/gcc/testsuite/lib/target-supports.exp @@ -2896,6 +2896,20 @@ proc check_avx512_os_support_available { } { } else { # Check that OS has AVX512, AVX and SSE saving enabled. check_runtime_nocache avx512_os_support_available { + #ifdef __APPLE__ + #include + int main () + { + int val = 0; + size_t len = sizeof (val); + /* Darwin enables the avx512 XSAVE state lazily; reading XCR0 + is not reliable - query the kernel instead. */ + if (sysctlbyname ("hw.optional.avx512f", &val, &len, 0, 0) + != 0 || val == 0) + return 1; + return 0; + } + #else int main () { unsigned int eax, edx; @@ -2903,6 +2917,7 @@ proc check_avx512_os_support_available { } { asm ("xgetbv" : "=a" (eax), "=d" (edx) : "c" (0)); return (eax & 0xe6) != 0xe6; } + #endif } "" } }] From 3bd34f8936c7edb25d35bc2816a863ca902938bf Mon Sep 17 00:00:00 2001 From: Joshua Berne Date: Mon, 21 Sep 2026 00:09:58 +0100 Subject: [PATCH 265/584] c++/contracts: fix handling of __contract_assert [PR127295] PR c++/127295 - [c++26][contracts] ICE in grok_contract on the __contract_assert extension spelling The gcc-specific spelling of contract_assert, __contract_assert, was untested and just didn't work. Changed uses of the raw string "contract_assert" to identify the token based on what was parsed (which identifies both contract_assert and __contract_assert as a reserved identifier with the code RID_CONTASSERT). Add one use of the alternate spelling in a test, as well as a test of the previously untested diagnostic that includes the keyword spelling in its output. PR c++/127295 gcc/cp/ChangeLog: * contracts.cc (grok_contract): Identify assertion statements by keyword and not string comparison. * parser.cc (cp_parser_contract_assert): Include keyword used on token in diagnostics. gcc/testsuite/ChangeLog: * g++.dg/contracts/cpp26/assertion-statement.C: Add use of __contract_assert. * g++.dg/contracts/cpp26/assertion-statement-errors.C: Test attribute warning with __contract_assert. * g++.dg/contracts/cpp26/no_contracts.C: Check keyword errors with -fno-contracts. Signed-off-by: Joshua Berne --- gcc/cp/contracts.cc | 3 ++- gcc/cp/parser.cc | 12 ++++++------ .../contracts/cpp26/assertion-statement-errors.C | 1 + .../g++.dg/contracts/cpp26/assertion-statement.C | 2 ++ gcc/testsuite/g++.dg/contracts/cpp26/no_contracts.C | 7 +++++++ 5 files changed, 18 insertions(+), 7 deletions(-) create mode 100644 gcc/testsuite/g++.dg/contracts/cpp26/no_contracts.C diff --git a/gcc/cp/contracts.cc b/gcc/cp/contracts.cc index cca568fa343c..f509424fd7c0 100644 --- a/gcc/cp/contracts.cc +++ b/gcc/cp/contracts.cc @@ -2083,7 +2083,8 @@ grok_contract (tree contract_spec, tree mode, tree result, cp_expr condition, tree_code code; contract_assertion_kind kind = CAK_INVALID; - if (id_equal (contract_spec, "contract_assert")) + if (IDENTIFIER_KEYWORD_P (contract_spec) + && C_RID_CODE (contract_spec) == RID_CONTASSERT) { code = ASSERTION_STMT; kind = CAK_ASSERT; diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc index 720dec6841eb..9c4245bc3f5e 100644 --- a/gcc/cp/parser.cc +++ b/gcc/cp/parser.cc @@ -33897,16 +33897,16 @@ cp_parser_late_contracts (cp_parser *parser, tree fndecl) static tree cp_parser_contract_assert (cp_parser *parser, cp_token *token) { + tree cont_assert = token->u.value; + if (!flag_contracts) { - error_at (token->location, "%qs is only available with %qs", - "contract_assert", "-fcontracts"); + error_at (token->location, "%qE is only available with %qs", + cont_assert, "-fcontracts"); cp_parser_skip_to_end_of_statement (parser); return error_mark_node; } - tree cont_assert = token->u.value; - token = cp_lexer_consume_token (parser->lexer); location_t loc = token->location; @@ -33915,8 +33915,8 @@ cp_parser_contract_assert (cp_parser *parser, cp_token *token) if (std_attrs) { attrs_loc = make_location (attrs_loc, attrs_loc, input_location); - warning_at (attrs_loc, OPT_Wattributes, "attributes are ignored on %qs", - "contract_assert"); + warning_at (attrs_loc, OPT_Wattributes, "attributes are ignored on %qE", + cont_assert); std_attrs = NULL_TREE; } diff --git a/gcc/testsuite/g++.dg/contracts/cpp26/assertion-statement-errors.C b/gcc/testsuite/g++.dg/contracts/cpp26/assertion-statement-errors.C index ef711368404f..32204cbf8caf 100644 --- a/gcc/testsuite/g++.dg/contracts/cpp26/assertion-statement-errors.C +++ b/gcc/testsuite/g++.dg/contracts/cpp26/assertion-statement-errors.C @@ -36,6 +36,7 @@ int main() g(); contract_assert [[deprecated]] (i == 3); // { dg-warning {attributes are ignored on 'contract_assert'} } + __contract_assert [[deprecated]] (i == 3); // { dg-warning {attributes are ignored on '__contract_assert'} } return 0; } diff --git a/gcc/testsuite/g++.dg/contracts/cpp26/assertion-statement.C b/gcc/testsuite/g++.dg/contracts/cpp26/assertion-statement.C index c4ec7f887214..d2d089ac1361 100644 --- a/gcc/testsuite/g++.dg/contracts/cpp26/assertion-statement.C +++ b/gcc/testsuite/g++.dg/contracts/cpp26/assertion-statement.C @@ -11,6 +11,8 @@ int main() { int x; + __contract_assert( x >= 0); + contract_assert( x >= 0); contract_assert( x < 0); contract_assert( x == 0); diff --git a/gcc/testsuite/g++.dg/contracts/cpp26/no_contracts.C b/gcc/testsuite/g++.dg/contracts/cpp26/no_contracts.C new file mode 100644 index 000000000000..2162b8e05b95 --- /dev/null +++ b/gcc/testsuite/g++.dg/contracts/cpp26/no_contracts.C @@ -0,0 +1,7 @@ +// { dg-options "-fno-contracts -std=c++26" } + +void f() +{ + contract_assert(false); // { dg-error "'contract_assert' is only available with '-fcontracts'" } + __contract_assert(false); // { dg-error "'__contract_assert' is only available with '-fcontracts'" } +} From e8207be46a6ebbbc079adc72c763b648de5c2da5 Mon Sep 17 00:00:00 2001 From: Joshua Berne Date: Mon, 21 Sep 2026 00:09:58 +0100 Subject: [PATCH 266/584] c++: fix return object cleanup for functions with contracts [PR127281] PR c++/127281 - [c++26][contracts] a contract emits the return-value cleanup twice: returned object destroyed twice, and an ICE in gimple_add_tmp_var In maybe_apply_function_contracts we create an artificial block that will contain the contract assertion evaluations, much like a function try block. This, however, runs after the function body has already been processed, a declaration for the return value sentinel has already been added (if needed), and cleanup code for the return value is already in place. Running maybe_splice_retval_cleanup again when the artificial block completes will crash due to multiple declarations of the sentinel, and if that is fixed it will double-destroy a non-trivial return value. Tests that hit this bug were added to an existing test case that handles non-trivial return types, and that test was generally enhanced to also execute at runtime (with no violations of any contract assertions, just code generation for them) in order to identify the cases where objects are double-destroyed (or leaked). To fix this, override current_retval_sentinel for the contracts artificial block. Note that there is still a lingering issue (PR c++/127414) involving destruction of the return value when the postcondition evaluations exit via an exception, but that fix is more involved and depends on this one rather than overlapping it. PR c++/127281 gcc/cp/ChangeLog: * contracts.cc (maybe_apply_function_contracts): Override current_retval_sentinel for the artificial block containing contracts. gcc/testsuite/ChangeLog: * g++.dg/contracts/cpp26/dcl.contract.res.p1-NT.C: Added runtime testing, along with tests of NRVO and exceptions from local variables. Signed-off-by: Joshua Berne --- gcc/cp/contracts.cc | 13 +- .../contracts/cpp26/dcl.contract.res.p1-NT.C | 134 +++++++++++++----- 2 files changed, 108 insertions(+), 39 deletions(-) diff --git a/gcc/cp/contracts.cc b/gcc/cp/contracts.cc index f509424fd7c0..cd5f0bdbb16a 100644 --- a/gcc/cp/contracts.cc +++ b/gcc/cp/contracts.cc @@ -1390,7 +1390,18 @@ maybe_apply_function_contracts (tree fndecl) } /* Now add the pre and post conditions to the existing function body. - This copies the approach used for function try blocks. */ + This approach mostly copies that of function try blocks, but also stops + maybe_splice_retval_cleanup from acting on sk_function_parms again and + introducing another DECL_EXPR for the same sentinel, or a second cleanup + statement, both of which would be broken. + + FIXME: This means no cleanup statement will be emitted to clean up the + return object if the postcondition evaluations themselves throw an + exception (from the contract-violation handler), and this suppression + might need to be removed when that is addressed (PR c++/127414). */ + auto retval_sentinel_ovr = make_temp_override (current_retval_sentinel, + NULL_TREE); + tree compound_stmt = begin_compound_stmt (0); current_binding_level->artificial = true; diff --git a/gcc/testsuite/g++.dg/contracts/cpp26/dcl.contract.res.p1-NT.C b/gcc/testsuite/g++.dg/contracts/cpp26/dcl.contract.res.p1-NT.C index 5cbfb6117584..af7304b77b03 100644 --- a/gcc/testsuite/g++.dg/contracts/cpp26/dcl.contract.res.p1-NT.C +++ b/gcc/testsuite/g++.dg/contracts/cpp26/dcl.contract.res.p1-NT.C @@ -6,40 +6,63 @@ // // Various tests with non trivial return value identifier // -// { dg-do compile { target c++23 } } -// { dg-additional-options "-fcontracts" } +// { dg-do compile { target { c++23 && { ! hostedlib } } } } +// { dg-do run { target { c++23 && hostedlib } } } +// { dg-additional-options "-fcontracts -fcontract-evaluation-semantic=enforce" } +int live = 0; struct NonTrivial{ - NonTrivial(){}; - NonTrivial(const NonTrivial&){} - ~NonTrivial(){}; + NonTrivial(){ ++live; }; + NonTrivial(const NonTrivial&){ ++live;} + NonTrivial(NonTrivial&&){ ++live;} + ~NonTrivial(){ --live; }; int x = 0; }; +struct ThrowOnDestroy { + bool armed = true; + ~ThrowOnDestroy() noexcept(false) { if (armed) throw 17; } +}; + template bool check(T t){ return true; } struct S{ - NonTrivial f1(const NonTrivial i) post(r: i.x > 0 ) { return NonTrivial{};} + NonTrivial f1(const NonTrivial i) post(r: check(i.x > 0) ) { return NonTrivial{};} template - NonTrivial f2(const T i) post(r: i.x > 0 ) { return NonTrivial{};} + NonTrivial f2(const T i) post(r: check(i.x > 0) ) { return NonTrivial{};} - auto f3(const NonTrivial i) post(r: i.x > 0 ) { return NonTrivial{};} + auto f3(const NonTrivial i) post(r: check(i.x > 0) ) { return NonTrivial{};} template - T f4(const T i) post(r: i.x > 0 ) { return NonTrivial{};} + T f4(const T i) post(r: check(i.x > 0) ) { return NonTrivial{};} template - auto f5(const T i) post(r: i.x > 0 ) { return i;} + auto f5(const T i) post(r: check(i.x > 0) ) { return i;} template auto f6(const T i) post(r: check(i) ) { return i;} auto f7(const NonTrivial i) post(r: check(r) ) { return i;} + NonTrivial f8(bool flag) pre(check(flag)) + { NonTrivial result; + if (flag) { + return result; + } + int other; // force a new block + return result; + } + + NonTrivial f9(bool arm) pre(check(arm)) + { ThrowOnDestroy guard{arm}; + NonTrivial result; + return result; + } + }; template @@ -49,42 +72,42 @@ struct S1 struct S2 { NonTrivial - f1 (const NonTrivial i) post(r: i.x > 0 ) + f1 (const NonTrivial i) post(r: check(i.x > 0) ) { return NonTrivial {}; } template NonTrivial - f2 (const T i) post(r: i.x > 0 ) + f2 (const T i) post(r: check(i.x > 0) ) { return NonTrivial {}; } auto f3 (const NonTrivial i) - post(r: i.x > 0 ) + post(r: check(i.x > 0) ) { return NonTrivial {};} template T f4 (const T i) - post(r: i.x > 0 ) + post(r: check(i.x > 0) ) { return NonTrivial {};} template auto f5 (const T i) - post(r: i.x > 0 ) + post(r: check(i.x > 0) ) { return i;} }; NonTrivial f1 (const NonTrivial i) - post(r: i.x > 0 ) + post(r: check(i.x > 0) ) { S2 s; return s.f1(i); } @@ -92,14 +115,14 @@ struct S1 template NonTrivial f2 (const T i) - post(r: i.x > 0 ) + post(r: check(i.x > 0) ) { S2 s; return s.f2(i); } auto f3 (const NonTrivial i) - post(r: i.x > 0 ) + post(r: check(i.x > 0) ) { S2 s; return s.f3(i); } @@ -107,7 +130,7 @@ struct S1 template T f4 (const T i) - post(r: i.x > 0 ) + post(r: check(i.x > 0) ) { S2 s; return s.f4(i); } @@ -115,32 +138,67 @@ struct S1 template auto f5 (const T i) - post(r: i.x > 0 ) + post(r: check(i.x > 0) ) { S2 s; return s.f5(i); } + template + auto f6(T flag) pre(check(flag)) + { NonTrivial result; + if (flag) { + return result; + } + int other; // force a new block + return result; + } + + template + auto f7(T arm) pre(check(arm)) + { ThrowOnDestroy guard{arm}; + NonTrivial result; + return result; + } + + }; int main() { - S s; - NonTrivial n; - s.f1(NonTrivial{}); - - s.f2(n); - s.f3(n); - s.f4(n); - s.f5(n); - s.f6(n); - s.f7(n); - - - S1 s1; - s1.f1(n); - s1.f2(n); - s1.f3(n); - s1.f4(n); - s1.f5(n); + { + S s; + NonTrivial n; + s.f1(NonTrivial{}); + + s.f2(n); + s.f3(n); + s.f4(n); + s.f5(n); + s.f6(n); + s.f7(n); + s.f8(true); + s.f8(false); + + try { + s.f9(true); + } catch (int) { } + } + + { + S1 s1; + NonTrivial n; + s1.f1(n); + s1.f2(n); + s1.f3(n); + s1.f4(n); + s1.f5(n); + s1.f6(true); + s1.f6(false); + try { + s1.f7(true); + } catch (int) { } + } + + if (live != 0) __builtin_abort(); } From ed9f5bf1c1288168b14edd3e35f4d32330bef66d Mon Sep 17 00:00:00 2001 From: Samarth Tandale Date: Sun, 20 Sep 2026 17:18:25 -0600 Subject: [PATCH 267/584] [PATCH v2] match: Simplify value-range guarded min/max expressions [PR125700] For MIN_EXPR, if x is TYPE_MAX_VALUE, then min (x, y) is y. So: x == TYPE_MAX_VALUE ? y : min (x, y) can be simplified to: min (x, y) Similarly for MAX_EXPR, if x is TYPE_MIN_VALUE, then max (x, y) is y. So: x == TYPE_MIN_VALUE ? y : max (x, y) can be simplified to: max (x, y) This adds a combined match.pd pattern for MIN_EXPR and MAX_EXPR. Changes since v1: - Extended the optimization beyond fixed type limits. It now handles constants when Ranger proves their relationship with y's value range and conservatively falls back when no useful range is available. - Added positive and negative test cases for Ranger-derived ranges. PR tree-optimization/125700 gcc/ChangeLog: * match.pd: Fold type-bound guarded min/max expressions. gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/pr125700.c: New test. * gcc.dg/tree-ssa/pr125700-int-width.c: New test. * gcc.dg/tree-ssa/pr125700-negative.c: New test. * gcc.dg/tree-ssa/pr125700-range.c: New test. Signed-off-by: Samarth Tandale --- gcc/match.pd | 25 +++ .../gcc.dg/tree-ssa/pr125700-int-width.c | 51 +++++++ .../gcc.dg/tree-ssa/pr125700-negative.c | 70 +++++++++ .../gcc.dg/tree-ssa/pr125700-range.c | 144 ++++++++++++++++++ gcc/testsuite/gcc.dg/tree-ssa/pr125700.c | 117 ++++++++++++++ 5 files changed, 407 insertions(+) create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr125700-int-width.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr125700-negative.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr125700-range.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr125700.c diff --git a/gcc/match.pd b/gcc/match.pd index 341962a3faac..e5ffd6b0d991 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -13589,3 +13589,28 @@ and, (if (INTEGRAL_TYPE_P (type)) (with { tree itype = TREE_TYPE (@2); } (convert (minus @2 (convert:itype @1)))))) + +#if GIMPLE +/* Replace (x == C) ? y : MIN (x, y) -> MIN (x, y) when C >= upper_bound (y), + and (x == C) ? y : MAX (x, y) -> MAX (x, y) when C <= lower_bound (y), + because in both cases the guarded arm equals the min/max expression. */ +(for minmax (min max) + (simplify + (cond (eq @0 INTEGER_CST@1) @2 (minmax:c@3 @0 @2)) + (if (INTEGRAL_TYPE_P (type)) + (with { + int_range_max r; + if (!gimple_match_range_of_expr (r, @2, @2)) + r.set_varying (TREE_TYPE (@2)); + wide_int bound; + if (minmax == MIN_EXPR) + bound = r.upper_bound (); + else + bound = r.lower_bound (); + } + (if ((minmax == MIN_EXPR + && wi::ge_p (wi::to_wide (@1), bound, TYPE_SIGN (type))) + || (minmax == MAX_EXPR + && wi::le_p (wi::to_wide (@1), bound, TYPE_SIGN (type)))) + @3))))) +#endif diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr125700-int-width.c b/gcc/testsuite/gcc.dg/tree-ssa/pr125700-int-width.c new file mode 100644 index 000000000000..a203fdb01189 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr125700-int-width.c @@ -0,0 +1,51 @@ +/* PR tree-optimization/125700 */ +/* Integer width variants to cover non-int widths and both signed/unsigned. */ + +/* { dg-do compile } */ +/* { dg-options "-O1 -fdump-tree-optimized" } */ + +#include + +#define GEN_FUNCS(TAG, UTYPE, STYPE, UMAX, SMAX, SMIN) \ +UTYPE \ +fumin_##TAG (UTYPE x, UTYPE y) \ +{ \ + if (x == (UMAX)) \ + return y; \ + return x < y ? x : y; \ +} \ +\ +STYPE \ +fsmin_##TAG (STYPE x, STYPE y) \ +{ \ + if (x == (SMAX)) \ + return y; \ + return x < y ? x : y; \ +} \ +\ +UTYPE \ +fumax_##TAG (UTYPE x, UTYPE y) \ +{ \ + if (x == 0) \ + return y; \ + return x > y ? x : y; \ +} \ +\ +STYPE \ +fsmax_##TAG (STYPE x, STYPE y) \ +{ \ + if (x == (SMIN)) \ + return y; \ + return x > y ? x : y; \ +} + +GEN_FUNCS (char, unsigned char, signed char, UCHAR_MAX, SCHAR_MAX, SCHAR_MIN) +GEN_FUNCS (short, unsigned short, short, USHRT_MAX, SHRT_MAX, SHRT_MIN) +GEN_FUNCS (long, unsigned long, long, ULONG_MAX, LONG_MAX, LONG_MIN) +GEN_FUNCS (long_long, unsigned long long, long long, ULLONG_MAX, LLONG_MAX, + LLONG_MIN) + +/* { dg-final { scan-tree-dump-not {if \(} "optimized" } } */ +/* { dg-final { scan-tree-dump-not " == " "optimized" } } */ +/* { dg-final { scan-tree-dump-times "MIN_EXPR" 8 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "MAX_EXPR" 8 "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr125700-negative.c b/gcc/testsuite/gcc.dg/tree-ssa/pr125700-negative.c new file mode 100644 index 000000000000..2cfa280a138b --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr125700-negative.c @@ -0,0 +1,70 @@ +/* PR tree-optimization/125700 */ +/* Negative test cases, should not transform. */ + +/* { dg-do compile } */ +/* { dg-options "-O1 -fdump-tree-optimized" } */ + +unsigned +fumin_negative (unsigned x, unsigned y) +{ + if (x == 0) + return y; + return x < y ? x : y; +} + +unsigned +fumax_negative (unsigned x, unsigned y) +{ + if (x == -1u) + return y; + return x > y ? x : y; +} + +signed +fsmin_negative (signed x, signed y) +{ + if (x == -__INT_MAX__ - 1) + return y; + return x < y ? x : y; +} + +signed +fsmax_negative (signed x, signed y) +{ + if (x == __INT_MAX__) + return y; + return x > y ? x : y; +} + +/* Unsigned char widened to unsigned int. */ +unsigned +fumin_range_negative (unsigned char a, unsigned int b) +{ + unsigned aa = a; + if (aa == 255) + return b; + return aa < b ? aa : b; +} + +/* Signed char widened to int. */ +int +fsmin_range_negative (signed char a, signed int b) +{ + int aa = a; + if (aa == 127) + return b; + return aa < b ? aa : b; +} + +int +fsmax_range_negative (signed char a, signed int b) +{ + int aa = a; + if (aa == -128) + return b; + return aa > b ? aa : b; +} + +/* None of the if and '==' comparisons should be eliminated. */ +/* { dg-final { scan-tree-dump-times {if \(} 7 "optimized" } } */ +/* { dg-final { scan-tree-dump-times " == " 7 "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr125700-range.c b/gcc/testsuite/gcc.dg/tree-ssa/pr125700-range.c new file mode 100644 index 000000000000..d474162d5ceb --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr125700-range.c @@ -0,0 +1,144 @@ +/* PR tree-optimization/125700 */ +/* Test that the optimization fires using Ranger-derived value ranges, + including ranges from widened types and range-limiting operations. */ + +/* { dg-do compile } */ +/* { dg-options "-O1 -fdump-tree-optimized" } */ + +/* Unsigned char widened to unsigned int. */ +unsigned +fumin_char_range (unsigned char a, unsigned char b) +{ + unsigned aa = a; + unsigned bb = b; + if (aa == 255) + return bb; + return aa < bb ? aa : bb; +} + +unsigned +fumax_char_range (unsigned char a, unsigned char b) +{ + unsigned aa = a; + unsigned bb = b; + if (aa == 0) + return bb; + return aa > bb ? aa : bb; +} + +/* Signed char widened to int. */ +int +fsmin_char_range (signed char a, signed char b) +{ + int aa = a; + int bb = b; + if (aa == 127) + return bb; + return aa < bb ? aa : bb; +} + +int +fsmax_char_range (signed char a, signed char b) +{ + int aa = a; + int bb = b; + if (aa == -128) + return bb; + return aa > bb ? aa : bb; +} + +/* C is strictly above the upper bound of y's value range for MIN, + and strictly below the lower bound for MAX. */ +unsigned +fumin_range_above_bound (unsigned x, unsigned y) +{ + if (y > 100) + y = 100; + if (x == 120) + return y; + return x < y ? x : y; +} + +unsigned +fumax_range_below_bound (unsigned x, unsigned y) +{ + y &= 127; + if (y < 27) + y = 27; + if (x == 10) + return y; + return x > y ? x : y; +} + +int +fsmin_range_above_bound (int x, int y) +{ + y &= 127; + if (y > 100) + y = 100; + if (x == 120) + return y; + return x < y ? x : y; +} + +int +fsmax_range_below_bound (int x, int y) +{ + y &= 127; + if (y < 27) + y = 27; + if (x == 10) + return y; + return x > y ? x : y; +} + +/* C is equal to the upper bound of y's value range for MIN, + and equal to the lower bound for MAX. */ +unsigned +fumin_range_at_bound (unsigned x, unsigned y) +{ + y &= 127; + if (y > 100) + y = 100; + if (x == 100) + return y; + return x < y ? x : y; +} + +unsigned +fumax_range_at_bound (unsigned x, unsigned y) +{ + y &= 127; + if (y < 27) + y = 27; + if (x == 27) + return y; + return x > y ? x : y; +} + +int +fsmin_range_at_bound (int x, int y) +{ + y &= 127; + if (y > 100) + y = 100; + if (x == 100) + return y; + return x < y ? x : y; +} + +int +fsmax_range_at_bound (int x, int y) +{ + y &= 127; + if (y < 27) + y = 27; + if (x == 27) + return y; + return x > y ? x : y; +} + +/* { dg-final { scan-tree-dump-not {if \(} "optimized" } } */ +/* { dg-final { scan-tree-dump-not " == " "optimized" } } */ +/* { dg-final { scan-tree-dump-times "MIN_EXPR" 10 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "MAX_EXPR" 10 "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr125700.c b/gcc/testsuite/gcc.dg/tree-ssa/pr125700.c new file mode 100644 index 000000000000..397c72544355 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr125700.c @@ -0,0 +1,117 @@ +/* PR tree-optimization/125700 */ +/* Test the original cases, alternative condition forms and reversed + minimum/maximum operand orders. */ + +/* { dg-do compile } */ +/* { dg-options "-O1 -fdump-tree-optimized" } */ + +/* Base test cases. */ +unsigned +fumin (unsigned x, unsigned y) +{ + if (x == -1u) + return y; + return x < y ? x : y; +} + +signed +fsmin (signed x, signed y) +{ + if (x == __INT_MAX__) + return y; + return x < y ? x : y; +} + +unsigned +fumax (unsigned x, unsigned y) +{ + if (x == 0) + return y; + return x > y ? x : y; +} + +signed +fsmax (signed x, signed y) +{ + if (x == -__INT_MAX__ - 1) + return y; + return x > y ? x : y; +} + +/* Conditional operator variants. */ +unsigned +fumin_ne (unsigned x, unsigned y) +{ + if (x != -1u) + return x < y ? x : y; + return y; +} + +unsigned +fumax_ne (unsigned x, unsigned y) +{ + if (x != 0) + return x > y ? x : y; + return y; +} + +unsigned +fumin_ge (unsigned x, unsigned y) +{ + if (x >= -1u) + return y; + return x < y ? x : y; +} + +unsigned +fumax_le (unsigned x, unsigned y) +{ + if (x <= 0) + return y; + return x > y ? x : y; +} + +unsigned +fumin_lt (unsigned x, unsigned y) +{ + if (!(x < -1u)) + return y; + return x < y ? x : y; +} + +unsigned +fumax_gt (unsigned x, unsigned y) +{ + if (!(x > 0)) + return y; + return x > y ? x : y; +} + +/* Commutativity tests for min/max operator. */ +unsigned +fumin_flip (unsigned x, unsigned y) +{ + if (x == -1u) + return y; + return y > x ? x : y; +} + +unsigned +fumax_flip (unsigned x, unsigned y) +{ + if (x == 0) + return y; + return y < x ? x : y; +} + +/* The if and all conditional operators should be removed + from the optimized dump output. */ +/* { dg-final { scan-tree-dump-not {if \(} "optimized" } } */ +/* { dg-final { scan-tree-dump-not " == " "optimized" } } */ +/* { dg-final { scan-tree-dump-not " != " "optimized" } } */ +/* { dg-final { scan-tree-dump-not " <= " "optimized" } } */ +/* { dg-final { scan-tree-dump-not " >= " "optimized" } } */ +/* { dg-final { scan-tree-dump-not " < " "optimized" } } */ +/* { dg-final { scan-tree-dump-not " > " "optimized" } } */ +/* { dg-final { scan-tree-dump-times "MIN_EXPR" 6 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "MAX_EXPR" 6 "optimized" } } */ From 21ba2767ffb57effeb2c105b5069fd176284e7e9 Mon Sep 17 00:00:00 2001 From: Matt Turner Date: Sun, 20 Sep 2026 17:30:21 -0600 Subject: [PATCH 268/584] [PATCH] alpha: Provide movmisalign patterns for scalar integer modes Only the 8-byte vector modes had movmisalign patterns, so for scalar modes gimple_fold_builtin_memory_op refused to fold a small memcpy into a plain load or store: STRICT_ALIGNMENT is set and no unaligned move was available. The call survived to expand and was handled either by move_by_pieces or by alpha_expand_block_move, and in both cases the destination or the source had to stay addressable, so it got a stack slot. For a 4-byte load on a BWX target this produced four ldbu, four stb into that slot and a final ldl, which is worse than the ldq_u/extll/extlh sequence a pre-BWX target gets, because MOVE_RATIO is 7 with BWX and by-pieces then copies a byte at a time. Even on a pre-BWX target the now-dead stack slot kept a 16-byte frame alive in what is otherwise a leaf function needing no frame at all. Extend the movmisalign mode iterator to HImode, SImode and DImode and derive the access size from the mode rather than hardcoding 8. The memcpy is then folded at gimple time into a load or a store of a type with reduced alignment, which expands to the unaligned sequence directly, with no stack slot, no frame, and no by-pieces byte copy. -msafe-partial keeps emitting byte stores for the store case. gcc/ChangeLog: * config/alpha/alpha.cc (alpha_expand_movmisalign): Derive the access size from MODE rather than assuming 8 bytes. * config/alpha/alpha.md (MISALIGN): New mode iterator. (movmisalign): Use it in place of VEC. gcc/testsuite/ChangeLog: * gcc.target/alpha/movmisalign-si.c: New test. * gcc.target/alpha/movmisalign-si-bwx.c: New test. * gcc.target/alpha/movmisalign-hi-bwx.c: New test. * gcc.target/alpha/movmisalign-run.c: New test. --- gcc/config/alpha/alpha.cc | 11 ++- gcc/config/alpha/alpha.md | 10 ++- .../gcc.target/alpha/movmisalign-hi-bwx.c | 19 +++++ .../gcc.target/alpha/movmisalign-run.c | 79 +++++++++++++++++++ .../gcc.target/alpha/movmisalign-si-bwx.c | 8 ++ .../gcc.target/alpha/movmisalign-si.c | 30 +++++++ 6 files changed, 151 insertions(+), 6 deletions(-) create mode 100644 gcc/testsuite/gcc.target/alpha/movmisalign-hi-bwx.c create mode 100644 gcc/testsuite/gcc.target/alpha/movmisalign-run.c create mode 100644 gcc/testsuite/gcc.target/alpha/movmisalign-si-bwx.c create mode 100644 gcc/testsuite/gcc.target/alpha/movmisalign-si.c diff --git a/gcc/config/alpha/alpha.cc b/gcc/config/alpha/alpha.cc index f70eebc8f18e..15b4a074f21c 100644 --- a/gcc/config/alpha/alpha.cc +++ b/gcc/config/alpha/alpha.cc @@ -2471,7 +2471,7 @@ alpha_expand_mov_safe_bwa (machine_mode mode, rtx *operands) } /* Implement the movmisalign patterns. One of the operands is a memory - that is not naturally aligned. Emit instructions to load it. */ + that is not naturally aligned. Emit instructions to load or store it. */ void alpha_expand_movmisalign (machine_mode mode, rtx *operands) @@ -2486,7 +2486,8 @@ alpha_expand_movmisalign (machine_mode mode, rtx *operands) else tmp = gen_reg_rtx (mode); - alpha_expand_unaligned_load (tmp, operands[1], 8, 0, 0); + alpha_expand_unaligned_load (tmp, operands[1], GET_MODE_SIZE (mode), + 0, 0); if (tmp != operands[0]) emit_move_insn (operands[0], tmp); } @@ -2496,9 +2497,11 @@ alpha_expand_movmisalign (machine_mode mode, rtx *operands) operands[1] = force_reg (mode, operands[1]); if (TARGET_SAFE_PARTIAL) alpha_expand_unaligned_store_safe_partial (operands[0], operands[1], - 8, 0, BITS_PER_UNIT); + GET_MODE_SIZE (mode), 0, + BITS_PER_UNIT); else - alpha_expand_unaligned_store (operands[0], operands[1], 8, 0); + alpha_expand_unaligned_store (operands[0], operands[1], + GET_MODE_SIZE (mode), 0); } else gcc_unreachable (); diff --git a/gcc/config/alpha/alpha.md b/gcc/config/alpha/alpha.md index a0235c61325d..880654b36a28 100644 --- a/gcc/config/alpha/alpha.md +++ b/gcc/config/alpha/alpha.md @@ -4674,9 +4674,15 @@ }) +; Modes for which we implement misaligned accesses with the ldq_u/stq_u +; and extract/insert/mask instruction sequences. QImode is excluded as +; a byte can never be misaligned. + +(define_mode_iterator MISALIGN [HI SI DI V8QI V4HI V2SI]) + (define_expand "movmisalign" - [(set (match_operand:VEC 0 "nonimmediate_operand") - (match_operand:VEC 1 "general_operand"))] + [(set (match_operand:MISALIGN 0 "nonimmediate_operand") + (match_operand:MISALIGN 1 "general_operand"))] "" { alpha_expand_movmisalign (mode, operands); diff --git a/gcc/testsuite/gcc.target/alpha/movmisalign-hi-bwx.c b/gcc/testsuite/gcc.target/alpha/movmisalign-hi-bwx.c new file mode 100644 index 000000000000..b6d2d9caa7d6 --- /dev/null +++ b/gcc/testsuite/gcc.target/alpha/movmisalign-hi-bwx.c @@ -0,0 +1,19 @@ +/* Verify that a misaligned 2-byte load on a BWX target is expanded inline + rather than being copied a byte at a time through a stack slot. */ + +/* { dg-do compile } */ +/* { dg-options "-O2 -mno-safe-partial -mbwx" } */ +/* { dg-skip-if "" { *-*-* } { "-O0" } } */ + +unsigned short +load_hi (const unsigned char *p) +{ + unsigned short v; + + __builtin_memcpy (&v, p, sizeof v); + return v; +} + +/* { dg-final { scan-assembler-times "\\sldbu\\s" 2 } } */ +/* { dg-final { scan-assembler-not "\\sstb\\s" } } */ +/* { dg-final { scan-assembler-not "\\slda\\s\\\$30," } } */ diff --git a/gcc/testsuite/gcc.target/alpha/movmisalign-run.c b/gcc/testsuite/gcc.target/alpha/movmisalign-run.c new file mode 100644 index 000000000000..d98cff372c11 --- /dev/null +++ b/gcc/testsuite/gcc.target/alpha/movmisalign-run.c @@ -0,0 +1,79 @@ +/* Verify that misaligned loads and stores of all sizes produce correct + results at every alignment. */ + +/* { dg-do run } */ +/* { dg-options "" } */ + +static unsigned char buf[64]; +static unsigned char ref[64]; +static unsigned char exp[64]; + +#define DEFINE_ACCESSORS(SUFFIX, TYPE) \ + __attribute__ ((noipa)) static TYPE \ + load_##SUFFIX (const unsigned char *p) \ + { \ + TYPE v; \ + \ + __builtin_memcpy (&v, p, sizeof v); \ + return v; \ + } \ + \ + __attribute__ ((noipa)) static void \ + store_##SUFFIX (unsigned char *p, TYPE v) \ + { \ + __builtin_memcpy (p, &v, sizeof v); \ + } + +DEFINE_ACCESSORS (hi, unsigned short) +DEFINE_ACCESSORS (si, unsigned int) +DEFINE_ACCESSORS (di, unsigned long) + +#define CHECK_LOAD(SUFFIX, TYPE, OFS) \ + do \ + { \ + TYPE v; \ + \ + __builtin_memcpy (&v, ref + (OFS), sizeof v); \ + if (load_##SUFFIX (buf + (OFS)) != v) \ + __builtin_abort (); \ + } \ + while (0) + +#define CHECK_STORE(SUFFIX, TYPE, OFS, VAL) \ + do \ + { \ + TYPE v = (VAL); \ + \ + __builtin_memcpy (buf, ref, sizeof buf); \ + __builtin_memcpy (exp, ref, sizeof exp); \ + store_##SUFFIX (buf + (OFS), v); \ + __builtin_memcpy (exp + (OFS), &v, sizeof v); \ + if (__builtin_memcmp (buf, exp, sizeof buf) != 0) \ + __builtin_abort (); \ + } \ + while (0) + +int +main (void) +{ + int i; + + for (i = 0; i < (int) sizeof ref; i++) + ref[i] = buf[i] = i * 7 + 3; + + for (i = 0; i < 16; i++) + { + CHECK_LOAD (hi, unsigned short, i); + CHECK_LOAD (si, unsigned int, i); + CHECK_LOAD (di, unsigned long, i); + } + + for (i = 0; i < 16; i++) + { + CHECK_STORE (hi, unsigned short, i, 0x1234); + CHECK_STORE (si, unsigned int, i, 0xdeadbeef); + CHECK_STORE (di, unsigned long, i, 0x0123456789abcdef); + } + + return 0; +} diff --git a/gcc/testsuite/gcc.target/alpha/movmisalign-si-bwx.c b/gcc/testsuite/gcc.target/alpha/movmisalign-si-bwx.c new file mode 100644 index 000000000000..5e851258d7f5 --- /dev/null +++ b/gcc/testsuite/gcc.target/alpha/movmisalign-si-bwx.c @@ -0,0 +1,8 @@ +/* Same as movmisalign-si.c, but for a BWX target, where the copy used to be + made one byte at a time via a stack slot. */ + +/* { dg-do compile } */ +/* { dg-options "-O2 -mno-safe-partial -mbwx" } */ +/* { dg-skip-if "" { *-*-* } { "-O0" } } */ + +#include "movmisalign-si.c" diff --git a/gcc/testsuite/gcc.target/alpha/movmisalign-si.c b/gcc/testsuite/gcc.target/alpha/movmisalign-si.c new file mode 100644 index 000000000000..4fc8d3466c18 --- /dev/null +++ b/gcc/testsuite/gcc.target/alpha/movmisalign-si.c @@ -0,0 +1,30 @@ +/* Verify that a misaligned 4-byte load and store are expanded inline with + the ldq_u/extXl/extXh and ldq_u/mskXl/insXl/stq_u sequences rather than + being copied a byte at a time through a stack slot. */ + +/* { dg-do compile } */ +/* { dg-options "-O2 -mno-safe-partial" } */ +/* { dg-skip-if "" { *-*-* } { "-O0" } } */ + +unsigned int +load_si (const unsigned char *p) +{ + unsigned int v; + + __builtin_memcpy (&v, p, sizeof v); + return v; +} + +void +store_si (unsigned char *p, unsigned int v) +{ + __builtin_memcpy (p, &v, sizeof v); +} + +/* { dg-final { scan-assembler-times "\\sldq_u\\s" 4 } } */ +/* { dg-final { scan-assembler-times "\\sextll\\s" 1 } } */ +/* { dg-final { scan-assembler-times "\\sextlh\\s" 1 } } */ +/* { dg-final { scan-assembler-times "\\sstq_u\\s" 2 } } */ +/* { dg-final { scan-assembler-not "\\sldbu\\s" } } */ +/* { dg-final { scan-assembler-not "\\sstb\\s" } } */ +/* { dg-final { scan-assembler-not "\\slda\\s\\\$30," } } */ From b6ae4436d518de6b1a4ed0d9ddb65ac40a325658 Mon Sep 17 00:00:00 2001 From: GCC Administrator Date: Mon, 21 Sep 2026 00:18:18 +0000 Subject: [PATCH 269/584] Daily bump. --- fixincludes/ChangeLog | 5 ++ gcc/ChangeLog | 140 ++++++++++++++++++++++++++++++++++++++++ gcc/DATESTAMP | 2 +- gcc/algol68/ChangeLog | 5 ++ gcc/cp/ChangeLog | 15 +++++ gcc/testsuite/ChangeLog | 117 +++++++++++++++++++++++++++++++++ libstdc++-v3/ChangeLog | 6 ++ 7 files changed, 289 insertions(+), 1 deletion(-) diff --git a/fixincludes/ChangeLog b/fixincludes/ChangeLog index 107692d75083..d926935ba13b 100644 --- a/fixincludes/ChangeLog +++ b/fixincludes/ChangeLog @@ -1,3 +1,8 @@ +2026-09-20 Iain Sandoe + + * fixincl.x: Regenerate. + * inclhack.def: Allow for math.h in architecture/ in SDKs. + 2026-06-29 Pietro Monteiro PR bootstrap/103459 diff --git a/gcc/ChangeLog b/gcc/ChangeLog index c3742144078c..c7190a9517a5 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,143 @@ +2026-09-20 Matt Turner + + * config/alpha/alpha.cc (alpha_expand_movmisalign): Derive the + access size from MODE rather than assuming 8 bytes. + * config/alpha/alpha.md (MISALIGN): New mode iterator. + (movmisalign): Use it in place of VEC. + +2026-09-20 Samarth Tandale + + PR tree-optimization/125700 + * match.pd: Fold type-bound guarded min/max expressions. + +2026-09-20 Iain Sandoe + + * common/config/i386/cpuinfo.h (darwin_get_kernel_bool): New. + (get_available_features): Query kernel for avx512 availability + on Darwin. + +2026-09-20 Yongqiang Tian + + PR rtl-optimization/127423 + * ifcvt.cc (noce_get_alt_condition): Ignore debug instructions when + checking whether if_info->x is mentioned in the interval. + +2026-09-20 Konstantinos Eleftheriou + + * tree-ssa-math-opts.cc (build_long_mul_partial_operand): New + function. + (build_long_mul_partials): Use it. + +2026-09-20 Philipp Tomsich + Konstantinos Eleftheriou + + PR tree-optimization/127042 + * tree-ssa-math-opts.cc (build_long_mul_partials): Emit zero + high-half partial products, and skip the high-half split and + the low-half mask, for an operand that provably fits the half + width. + +2026-09-20 Dominic P + + * gimple-fold.h (gimple_needing_rewrite_undefined): Add a + SHIFT_COUNT parameter defaulting to false. + * gimple-fold.cc (gimple_needing_rewrite_undefined): Return true + for a shift or rotate whose count may be out of range, only when + SHIFT_COUNT. + (rewrite_to_defined_unconditional): Reduce such a count into range. + * tree-ssa-loop-im.cc (shift_needs_mask_p): New function. + (determine_max_movement): Cost a shift whose count would need + masking as cheap. + (movement_possibility_1): Require preserved execution for a + possibly out-of-range count only when the rewrite cannot reduce it + or the loop is optimized for size. + +2026-09-20 Filip Kastl + + * tree-switch-conversion.cc (bit_test_cluster::find_bit_tests): + State that the bit test algorithm is optimal. + +2026-09-20 Andrea Pinski + + * match.pd (`((VCE (a cmp b ? -1 : 0)) < 0) ? c : d`): Remove + `(a cmp b)` match part. + +2026-09-20 Andrea Pinski + + * match.pd (`CMP * a`): Use tcc_comparison directly. + (`(type)CMP * a`): Likewise. + +2026-09-20 Andrea Pinski + + * match.pd (maybe_cmp): Use tcc_comparison directly instead + of for loop. + +2026-09-20 Konstantinos Eleftheriou + + PR rtl-optimization/126412 + * fold-mem-offsets.cc (change_in_vec_p): Move before fold_groups. + (changes_map_t): New type. + (class fold_groups): New class. + (struct regno_changes): Remove. + (sort_pairs): Likewise. + (cancel_changes_for_group): Take the fold group to cancel. + (find_groups_to_cancel): Rename from find_keys_to_remove. + (update_insns): Group the changes by fold group instead of by the + register defined by the last fold insn of the def-chain. + (fold_mem_offsets_1): Use fold_groups and commit all groups in a + single change_insns call. + +2026-09-20 Kyrylo Tkachov + + * match-sat-alu.pd (unsigned_integer_narrow_clip): Add the complement + form. + +2026-09-20 Kyrylo Tkachov + + * match-sat-alu.pd (signed_integer_sat_trunc): Add the constant-clamp + form. + +2026-09-20 Kyrylo Tkachov + + * match-sat-alu.pd (integer_constant_clamp): New match. + (unsigned_integer_narrow_clip): Add the constant-clamp form. + +2026-09-20 Kyrylo Tkachov + + * match-sat-alu.pd (signed_integer_sat_val): Recognize an arithmetic + sign shift. + (signed_integer_sat_trunc): Use signed_integer_sat_val in the existing + form. Recognize a shifted value with an equivalent pre-shift sign + source. + +2026-09-20 Kyrylo Tkachov + + * match-sat-alu.pd (unsigned_integer_sat_add): Accept a compare + against MAX - 1 in the widened form. + +2026-09-20 Kyrylo Tkachov + + * match-sat-alu.pd (signed_integer_sat_add): Add the two sided + clamp on a wider intermediate, in both nesting orders. + (signed_integer_sat_sub): Likewise. + * tree-ssa-math-opts.cc (match_unsigned_saturation_sub): Rename + to ... + (match_saturation_sub_with_assign): ... this, and ask the signed + predicate as well. + (math_opts_dom_walker::after_dom_children): Update the callers, + and call it for NOP_EXPR. + +2026-09-20 Kyrylo Tkachov + + * match-sat-alu.pd (signed_integer_sat_trunc): Allow a wider lossless + unsigned range type. Continue to require a narrowing result. Construct + the expected constants at the range precision. + +2026-09-20 Stefan Schulze Frielinghaus + + PR middle-end/127474 + * expmed.cc (expand_mult): Look through vector mode. + 2026-09-19 Jørgen Kvalsvik * gcov.cc (add_path_counts): Read the right field paths.size. diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index 1abdca3b21ef..286689204f27 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20260920 +20260921 diff --git a/gcc/algol68/ChangeLog b/gcc/algol68/ChangeLog index aeae9acb0f19..f9cb2823c7a9 100644 --- a/gcc/algol68/ChangeLog +++ b/gcc/algol68/ChangeLog @@ -1,3 +1,8 @@ +2026-09-20 Jose E. Marchesi + + * a68-low-units.cc (a68_lower_denotation): strtoul can return + errno /= 0 in overflow. + 2026-09-19 Jose E. Marchesi * ga68.vw: Typos fixed, section 8.0.1 added, consistent {x} style diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 43b5c5339503..de3b8ac93e5e 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,18 @@ +2026-09-20 Joshua Berne + + PR c++/127281 + * contracts.cc (maybe_apply_function_contracts): Override + current_retval_sentinel for the artificial block containing + contracts. + +2026-09-20 Joshua Berne + + PR c++/127295 + * contracts.cc (grok_contract): Identify assertion statements + by keyword and not string comparison. + * parser.cc (cp_parser_contract_assert): Include keyword used + on token in diagnostics. + 2026-09-14 Joshua Berne PR c++/127282 diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 4474d21ff3d4..2814823fae42 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,120 @@ +2026-09-20 Matt Turner + + * gcc.target/alpha/movmisalign-si.c: New test. + * gcc.target/alpha/movmisalign-si-bwx.c: New test. + * gcc.target/alpha/movmisalign-hi-bwx.c: New test. + * gcc.target/alpha/movmisalign-run.c: New test. + +2026-09-20 Samarth Tandale + + PR tree-optimization/125700 + * gcc.dg/tree-ssa/pr125700.c: New test. + * gcc.dg/tree-ssa/pr125700-int-width.c: New test. + * gcc.dg/tree-ssa/pr125700-negative.c: New test. + * gcc.dg/tree-ssa/pr125700-range.c: New test. + +2026-09-20 Joshua Berne + + PR c++/127281 + * g++.dg/contracts/cpp26/dcl.contract.res.p1-NT.C: Added runtime + testing, along with tests of NRVO and exceptions from local + variables. + +2026-09-20 Joshua Berne + + PR c++/127295 + * g++.dg/contracts/cpp26/assertion-statement.C: Add use of + __contract_assert. + * g++.dg/contracts/cpp26/assertion-statement-errors.C: Test + attribute warning with __contract_assert. + * g++.dg/contracts/cpp26/no_contracts.C: Check keyword errors with + -fno-contracts. + +2026-09-20 Iain Sandoe + + * lib/target-supports.exp (check_avx512_os_support_available): + Query the kernel for avx512 availability on Darwin. + +2026-09-20 Yongqiang Tian + + PR rtl-optimization/127423 + * gcc.target/riscv/pr127423.c: New test. + +2026-09-20 Philipp Tomsich + Konstantinos Eleftheriou + + PR tree-optimization/127042 + * gcc.target/arm/pr127042.c: New test. + * gcc.target/avr/mmcu/pr127042.c: New test. + +2026-09-20 Dominic P + + * gcc.dg/tree-ssa/loop-im-shift-2.c: Expect every chain but a lone + shift's to move; check the masks. + * gcc.dg/tree-ssa/loop-im-shift-3.c: New test. + * gcc.dg/tree-ssa/loop-im-shift-4.c: New test. + * gcc.dg/tree-ssa/loop-im-shift-5.c: New test. + * gcc.dg/tree-ssa/loop-im-shift-6.c: New test. + +2026-09-20 Konstantinos Eleftheriou + + PR rtl-optimization/126412 + * gcc.target/arm/pr126412.c: New test. + +2026-09-20 Kyrylo Tkachov + + * gcc.dg/sat-trunc-signed-cmp-2.c: New test. + * gcc.dg/vect/vect-sat-trunc-complement-1.c: Likewise. + * gcc.target/aarch64/vect-sat-trunc-complement-1.c: Likewise. + +2026-09-20 Kyrylo Tkachov + + * gcc.dg/vect/vect-sat-trunc-clamp-2.c: New test. + * gcc.target/aarch64/vect-sat-trunc-clamp-s-1.c: Likewise. + * gcc.target/aarch64/vect-sat-trunc-clamp-s-negative-1.c: Likewise. + +2026-09-20 Kyrylo Tkachov + + * gcc.dg/vect/vect-sat-trunc-clamp-1.c: New test. + * gcc.target/aarch64/vect-sat-trunc-clamp-inner-use-1.c: Likewise. + * gcc.target/aarch64/vect-sat-trunc-clamp-multi-use-1.c: Likewise. + * gcc.target/aarch64/vect-sat-trunc-clamp-u-1.c: Likewise. + * gcc.target/aarch64/vect-sat-trunc-clamp-u-negative-1.c: Likewise. + +2026-09-20 Kyrylo Tkachov + + * gcc.dg/vect/vect-sat-trunc-shift-sign-source-1.c: New test. + * gcc.target/aarch64/sat_s_val_ashr-1.c: Likewise. + * gcc.target/aarch64/vect-sat-trunc-shift-sign-source-1.c: Likewise. + * gcc.target/aarch64/vect-sat-trunc-shift-sign-source-negative-1.c: + Likewise. + +2026-09-20 Kyrylo Tkachov + + * gcc.target/aarch64/sat_u_add_widen_lt-1.c: New test. + +2026-09-20 Kyrylo Tkachov + + * gcc.target/aarch64/sat_s_clamp-1.c: New test. + * gcc.target/aarch64/sat_s_clamp-2.c: New test. + +2026-09-20 Kyrylo Tkachov + + * gcc.dg/vect/vect-sat-trunc-range-precision-1.c: New test. + * gcc.target/aarch64/vect-sat-trunc-range-precision-1.c: Likewise. + * gcc.target/aarch64/vect-sat-trunc-range-precision-negative-1.c: + Likewise. + +2026-09-20 Stefan Schulze Frielinghaus + + PR middle-end/127474 + * gcc.dg/torture/pr127474.c: New test. + +2026-09-20 Jose E. Marchesi + + * algol68/compile/error-bits-denotation-1.a68: Test for overflow + of bits and long bits. + 2026-09-19 John David Anglin * gcc.dg/tree-ssa/pr125734.c: xfail on hppa*-*-hpux*. diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 1730495eda32..fd9e2983d55d 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,9 @@ +2026-09-20 Gerald Pfeifer + + * doc/xml/manual/io.xml: New URL for Josuttis' "The C++ Standard + Library". + * doc/html/manual/streambufs.html: Regenerate. + 2026-09-18 Jakub Jelinek * include/bits/unicode.h (std::__unicode::__v16_0_0): Rename inline From d0e28326d4254e4824096a7331c8600455c22f73 Mon Sep 17 00:00:00 2001 From: Naveen Date: Sun, 20 Sep 2026 22:06:57 -0700 Subject: [PATCH 270/584] tree-optimization: Fold redundant integer-float-integer conversions [PR98984] GCC eliminates an integer-to-floating-point-to-integer conversion when the intermediate floating-point type can represent every value of the input integer type. This misses cases where it can represent every value of the final integer type. Extend the existing PR66211 folding pattern to use the final integer precision as an alternative condition when -fno-trapping-math is enabled. Values in range are represented exactly while out-of-range conversions are already undefined or invalid, so removing the intermediate conversion is safe. gcc/ChangeLog: PR tree-optimization/98984 * match.pd: Fold integer-float-integer conversions when the intermediate floating-point significand covers the final integer precision under -fno-trapping-math. gcc/testsuite/ChangeLog: PR tree-optimization/98984 * gcc.dg/tree-ssa/pr98984.c: New test. * gcc.dg/tree-ssa/pr98984-2.c: New test. Signed-off-by: Naveen --- gcc/match.pd | 11 ++++--- gcc/testsuite/gcc.dg/tree-ssa/pr98984-2.c | 12 ++++++++ gcc/testsuite/gcc.dg/tree-ssa/pr98984.c | 37 +++++++++++++++++++++++ 3 files changed, 56 insertions(+), 4 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr98984-2.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr98984.c diff --git a/gcc/match.pd b/gcc/match.pd index e5ffd6b0d991..88533dcf77a8 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -6210,12 +6210,15 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) /* If we are converting an integer to a floating-point that can represent it exactly and back to an integer, we can skip the - floating-point conversion. */ - (if (GIMPLE /* PR66211 */ + floating-point conversion. PR66211, PR98984. */ + (if (GIMPLE && inside_int && inter_float && final_int && ! is_vec - && ((unsigned) significand_size (TYPE_MODE (inter_type)) - >= inside_prec - !inside_unsignedp)) + && (((unsigned) significand_size (TYPE_MODE (inter_type)) + >= inside_prec - !inside_unsignedp) + || (! flag_trapping_math + && ((unsigned) significand_size (TYPE_MODE (inter_type)) + >= final_prec)))) (convert @0))))))) /* (float_type)(integer_type) x -> trunc (x) if the type of x matches diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr98984-2.c b/gcc/testsuite/gcc.dg/tree-ssa/pr98984-2.c new file mode 100644 index 000000000000..caf882d11c1a --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr98984-2.c @@ -0,0 +1,12 @@ +/* PR tree-optimization/98984 */ +/* { dg-do compile { target bitint } } */ +/* { dg-require-effective-target float32 } */ +/* { dg-options "-O2 -std=c23 -fno-trapping-math -fdump-tree-optimized" } */ +/* { dg-add-options float32 } */ + +signed _BitInt(25) +f (long long n) +{ + return (_Float32) n; +} + diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr98984.c b/gcc/testsuite/gcc.dg/tree-ssa/pr98984.c new file mode 100644 index 000000000000..51f84c9669b6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr98984.c @@ -0,0 +1,37 @@ +/* PR tree-optimization/98984 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -fno-trapping-math -fdump-tree-optimized" } */ + + +signed char +f1 (unsigned long long n) +{ + return (float)n; +} + +signed char +f2 (long long n) +{ + return (float)n; +} + +unsigned char +f3 (unsigned int n) +{ + return (float)n; +} + +short +f4 (unsigned long long n) +{ + return (float)n; +} + +unsigned short +f5 (unsigned long long n) +{ + return (double)n; +} + +/* { dg-final { scan-tree-dump-not "\\(float\\)" "optimized" } } */ +/* { dg-final { scan-tree-dump-not "\\(double\\)" "optimized" } } */ From f416e737d8463f81eb894fba0507e0f44c0a872d Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Sun, 20 Sep 2026 19:44:28 +0200 Subject: [PATCH 271/584] testsuite: Do not force execution of saturation tests vect.exp selects compile-only testing when a target can generate vector code but cannot execute it. These tests override that choice with dg-do run whenever _BitInt is available. On arm-eabi Cortex-M3, the vector options select Armv7-A NEON, but the link uses M-profile runtime objects. The linker rejects the mixed architecture profiles. Require _BitInt without forcing execution. This lets vect.exp compile the tests on targets without runnable vector hardware and run them on targets that have it. Apply the same fix to the shifted truncation test, which has the same latent problem. Bootstrapped and tested on aarch64-unknown-linux-gnu. Tested on arm-eabi with Cortex-M3 options. gcc/testsuite/ChangeLog: * gcc.dg/vect/vect-sat-trunc-range-precision-1.c: Do not force execution. * gcc.dg/vect/vect-sat-trunc-shift-sign-source-1.c: Likewise. Signed-off-by: Kyrylo Tkachov --- gcc/testsuite/gcc.dg/vect/vect-sat-trunc-range-precision-1.c | 2 +- gcc/testsuite/gcc.dg/vect/vect-sat-trunc-shift-sign-source-1.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-range-precision-1.c b/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-range-precision-1.c index 33649e9a2840..1de56c3b4efc 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-range-precision-1.c +++ b/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-range-precision-1.c @@ -1,4 +1,4 @@ -/* { dg-do run { target bitint } } */ +/* { dg-require-effective-target bitint } */ /* { dg-additional-options "-O3 -fvect-cost-model=unlimited" } */ typedef __INT8_TYPE__ int8_t; diff --git a/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-shift-sign-source-1.c b/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-shift-sign-source-1.c index 5d3fcf3ba3bb..3aca3d4b58ed 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-shift-sign-source-1.c +++ b/gcc/testsuite/gcc.dg/vect/vect-sat-trunc-shift-sign-source-1.c @@ -1,4 +1,4 @@ -/* { dg-do run { target bitint } } */ +/* { dg-require-effective-target bitint } */ /* { dg-additional-options "-O3 -fvect-cost-model=unlimited" } */ typedef __INT8_TYPE__ int8_t; From 21d783552e49650b6dab5e062842f491dbcfb2d6 Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Wed, 16 Sep 2026 23:55:02 -0700 Subject: [PATCH 272/584] middle-end: rescan calls after inserting call-used register zeroing [PR127445] gen_call_used_regs_seq adds the registers it zeroes to crtl->must_be_zero_on_return. df_epilogue_uses_p reports those registers as used by the epilogue, so they join the exit block use set. That set in turn decides which registers a sibling call is recorded as clobbering: df_get_call_refs skips the clobber def of any register that the exit block uses. Growing the set therefore invalidates the recorded defs of every sibling call in the function, but pass_zero_call_used_regs only refreshed the artificial refs, through df_update_exit_block_uses. To hit this a function needs one return path that is a sibling call and another that is a plain return. The zeroing sequence goes on the plain return path while the sibling call keeps its stale defs. The next pass to run df_analyze then ICEs in a df checking compiler. On aarch64 that pass is narrow_gp_writes: during RTL pass: narrow_gp_writes internal compiler error: in df_refs_verify, at df-scan.cc:4012 0x87315f df_refs_verify 0xed6b66 df_insn_refs_verify 0xed8b63 df_bb_verify 0xed8ee7 df_scan_verify() 0xec2161 df_verify() For the sibling call insn the recorded chain holds 65 defs while a fresh scan collects 57, the difference being x0 to x7: (call_insn/j:TI 82 147 83 5 (parallel [ (call (mem:DI (symbol_ref:DI ("bar"))) (const_int 0 [0])) (unspec:DI [(const_int 2 [0x2])] UNSPEC_CALLEE_ABI) (return) ]) 110 {*sibcall_insn} recorded defs { 0 1 2 3 4 5 6 7 8 ... 18 32 ... 86 16 17 } fresh defs { 8 ... 18 32 ... 86 16 17 } Call df_update_entry_exit_and_calls once after all return blocks have been handled. This is the same fix that PR rtl-optimization/78400 applied to shrink-wrapping, and thread_prologue_and_epilogue_insns already does it for the same reason. The df_update_exit_block_uses call being replaced came from PR middle-end/100775, which covered only the artificial refs of the exit block. df_compute_regs_ever_live also calls df_update_entry_exit_and_calls whenever regs_ever_live changed, which is why the bug usually hides: when zeroing a register makes it ever-live for the first time, the next df_analyze repairs the refs by accident. The testcase uses -fzero-call-used-regs=used-arg so that every zeroed register is already live. The original report used -finstrument-functions-once, which supplies the two return paths through the tail call to __cyg_profile_func_exit. Bootstrapped and tested on aarch64-none-linux-gnu. gcc/ChangeLog: PR rtl-optimization/127445 * function.cc (gen_call_used_regs_seq): Return whether a zeroing sequence was emitted. Do not update the exit block uses here. (pass_zero_call_used_regs::execute): Call df_update_entry_exit_and_calls once when a sequence was emitted. gcc/testsuite/ChangeLog: PR rtl-optimization/127445 * gcc.target/aarch64/pr127445.c: New test. Signed-off-by: Kyrylo Tkachov --- gcc/function.cc | 47 ++++++++++++--------- gcc/testsuite/gcc.target/aarch64/pr127445.c | 23 ++++++++++ 2 files changed, 51 insertions(+), 19 deletions(-) create mode 100644 gcc/testsuite/gcc.target/aarch64/pr127445.c diff --git a/gcc/function.cc b/gcc/function.cc index a563bccaff36..0a0e83badae1 100644 --- a/gcc/function.cc +++ b/gcc/function.cc @@ -5908,9 +5908,11 @@ make_prologue_seq (void) } /* Emit a sequence of insns to zero the call-used registers before RET - according to ZERO_REGS_TYPE. */ + according to ZERO_REGS_TYPE. Return true if a sequence was emitted, in + which case crtl->must_be_zero_on_return has grown and the caller has to + refresh the data flow information. */ -static void +static bool gen_call_used_regs_seq (rtx_insn *ret, unsigned int zero_regs_type) { bool only_gpr = true; @@ -5919,12 +5921,12 @@ gen_call_used_regs_seq (rtx_insn *ret, unsigned int zero_regs_type) /* No need to zero call-used-regs in main (). */ if (MAIN_NAME_P (DECL_NAME (current_function_decl))) - return; + return false; /* No need to zero call-used-regs if __builtin_eh_return is called since it isn't a normal function return. */ if (crtl->calls_eh_return) - return; + return false; /* If only_gpr is true, only zero call-used registers that are general-purpose registers; if only_used is true, only zero @@ -5988,7 +5990,7 @@ gen_call_used_regs_seq (rtx_insn *ret, unsigned int zero_regs_type) } if (hard_reg_set_empty_p (selected_hardregs)) - return; + return false; /* Now that we have a hard register set that needs to be zeroed, pass it to target to generate zeroing sequence. */ @@ -6005,21 +6007,20 @@ gen_call_used_regs_seq (rtx_insn *ret, unsigned int zero_regs_type) gcc_assert (hard_reg_set_subset_p (zeroed_hardregs, all_call_used_regs)); rtx_insn *seq = end_sequence (); - if (seq) - { - /* Emit the memory blockage and register clobber asm volatile before - the whole sequence. */ - start_sequence (); - expand_asm_reg_clobber_mem_blockage (zeroed_hardregs); - rtx_insn *seq_barrier = end_sequence (); + if (!seq) + return false; - emit_insn_before (seq_barrier, ret); - emit_insn_before (seq, ret); + /* Emit the memory blockage and register clobber asm volatile before + the whole sequence. */ + start_sequence (); + expand_asm_reg_clobber_mem_blockage (zeroed_hardregs); + rtx_insn *seq_barrier = end_sequence (); - /* Update the data flow information. */ - crtl->must_be_zero_on_return |= zeroed_hardregs; - df_update_exit_block_uses (); - } + emit_insn_before (seq_barrier, ret); + emit_insn_before (seq, ret); + + crtl->must_be_zero_on_return |= zeroed_hardregs; + return true; } @@ -6846,13 +6847,21 @@ pass_zero_call_used_regs::execute (function *fun) /* Iterate over the function's return instructions and insert any register zeroing required by the -fzero-call-used-regs command-line option or the "zero_call_used_regs" function attribute. */ + bool zeroed = false; FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds) { rtx_insn *insn = BB_END (e->src); if (JUMP_P (insn) && ANY_RETURN_P (JUMP_LABEL (insn))) - gen_call_used_regs_seq (insn, zero_regs_type); + zeroed |= gen_call_used_regs_seq (insn, zero_regs_type); } + /* The registers in must_be_zero_on_return are uses of the exit block, see + df_epilogue_uses_p. Growing that set also changes which registers a + sibling call is recorded as clobbering, see df_get_call_refs, so the + calls have to be rescanned as well. */ + if (zeroed) + df_update_entry_exit_and_calls (); + return 0; } diff --git a/gcc/testsuite/gcc.target/aarch64/pr127445.c b/gcc/testsuite/gcc.target/aarch64/pr127445.c new file mode 100644 index 000000000000..cc0974c91804 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/pr127445.c @@ -0,0 +1,23 @@ +/* PR rtl-optimization/127445 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -mnarrow-gp-writes -fzero-call-used-regs=used-arg" } */ + +/* One return path of foo is a sibling call and the other is a plain return. + The zeroing sequence emitted on the plain return path adds the argument + registers to the exit block use set, which changes the set of registers + that the sibling call is recorded as clobbering. used-arg only zeroes + registers that are already live, so nothing else forces a rescan of the + call to keep its data flow information correct. + + The stale refs are only diagnosed by a compiler configured with + --enable-checking=df, which verifies them in df_analyze. */ + +int bar (int, int, int, int, int, int, int, int); + +int +foo (int a, int b, int c, int d, int e, int f, int g, int h) +{ + if (a) + return bar (a, b, c, d, e, f, g, h); + return a + b + c + d + e + f + g + h; +} From b28a16af7fa7fea6a16f4c45024efdd863d82393 Mon Sep 17 00:00:00 2001 From: Tobias Burnus Date: Mon, 21 Sep 2026 08:16:58 +0200 Subject: [PATCH 273/584] OpenMP/Fortran: Permit comma between directive and clause This was added in OpenMP 5.2 when the syntax between Fortran and C/C++ was aligned a bit more. In C/C++ it was added presumably to have a nicer attribute syntax. gcc/fortran/ChangeLog: * openmp.cc (gfc_match_omp_clauses): Rename argument 'first' to first_no_comma for clarity. (match_omp, gfc_match_omp_allocate, gfc_match_omp_assume, gfc_match_omp_assumes, gfc_match_omp_critical, gfc_match_omp_depobj, gfc_match_omp_flush, gfc_match_omp_declare_simd, gfc_match_omp_declare_mapper, gfc_match_omp_declare_reduction, gfc_match_omp_declare_target, gfc_match_omp_thread_group_private, gfc_match_omp_requires, gfc_match_omp_scan, gfc_match_omp_atomic, gfc_match_omp_cancel_kind, gfc_match_omp_end_nowait, gfc_match_omp_end_single): Permit comma between directive name and clause name. libgomp/ChangeLog: * libgomp.texi (OpenMP 5.2 Impl. Status): Mark comma between directive name and first clause as implemented in Fortran. --- gcc/fortran/openmp.cc | 50 +++++++++++++++++++++++-------------------- libgomp/libgomp.texi | 2 +- 2 files changed, 28 insertions(+), 24 deletions(-) diff --git a/gcc/fortran/openmp.cc b/gcc/fortran/openmp.cc index 6737e1e3796c..d49fa79b3b4f 100644 --- a/gcc/fortran/openmp.cc +++ b/gcc/fortran/openmp.cc @@ -2586,7 +2586,7 @@ gfc_find_omp_udm (gfc_namespace *ns, const char *mapper_id, gfc_typespec *ts) static match gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, - bool first = true, bool needs_space = true, + bool first_no_comma = true, bool needs_space = true, bool openacc = false, bool openmp_target = false, gfc_omp_map_op default_map_op = OMP_MAP_TOFROM) { @@ -2606,11 +2606,11 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, while (1) { match m = MATCH_NO; - if ((first || (m = gfc_match_char (',')) != MATCH_YES) + if ((first_no_comma || (m = gfc_match_char (',')) != MATCH_YES) && (needs_space && gfc_match_space () != MATCH_YES)) break; needs_space = false; - first = false; + first_no_comma = false; gfc_gobble_whitespace (); bool end_colon; gfc_omp_namelist **head; @@ -5776,7 +5776,7 @@ static match match_omp (gfc_exec_op op, const omp_mask mask) { gfc_omp_clauses *c; - if (gfc_match_omp_clauses (&c, mask, true, true, false, + if (gfc_match_omp_clauses (&c, mask, false, true, false, op == EXEC_OMP_TARGET) != MATCH_YES) return MATCH_ERROR; new_st.op = op; @@ -5801,7 +5801,6 @@ match gfc_match_omp_allocate (void) { match m; - bool first = true; gfc_omp_namelist *vars = NULL; gfc_expr *align = NULL; gfc_expr *allocator = NULL; @@ -5818,9 +5817,7 @@ gfc_match_omp_allocate (void) gfc_gobble_whitespace (); if (gfc_match_omp_eos () == MATCH_YES) break; - if (!first) - gfc_match (", "); - first = false; + gfc_match (", "); /* optionally */ if ((m = gfc_match_dupl_check (!align, "align", true, &align)) != MATCH_NO) { @@ -5896,7 +5893,7 @@ gfc_match_omp_assume (void) { gfc_omp_clauses *c; locus loc = gfc_current_locus; - if ((gfc_match_omp_clauses (&c, omp_mask (OMP_CLAUSE_ASSUMPTIONS)) + if ((gfc_match_omp_clauses (&c, omp_mask (OMP_CLAUSE_ASSUMPTIONS), false) != MATCH_YES) || (omp_verify_merge_absent_contains (ST_OMP_ASSUME, c->assume, NULL, &loc) != MATCH_YES)) @@ -5921,7 +5918,7 @@ gfc_match_omp_assumes (void) "subprogram or module"); return MATCH_ERROR; } - if ((gfc_match_omp_clauses (&c, omp_mask (OMP_CLAUSE_ASSUMPTIONS)) + if ((gfc_match_omp_clauses (&c, omp_mask (OMP_CLAUSE_ASSUMPTIONS), false) != MATCH_YES) || (omp_verify_merge_absent_contains (ST_OMP_ASSUMES, c->assume, gfc_current_ns->omp_assumes, &loc) @@ -5965,8 +5962,8 @@ gfc_match_omp_critical (void) if (gfc_match (" ( %n )", n) != MATCH_YES) n[0] = '\0'; - if (gfc_match_omp_clauses (&c, omp_mask (OMP_CLAUSE_HINT), - /* first = */ n[0] == '\0') != MATCH_YES) + if (gfc_match_omp_clauses (&c, omp_mask (OMP_CLAUSE_HINT), false, + /* needs_space = */ n[0] == '\0') != MATCH_YES) return MATCH_ERROR; new_st.op = EXEC_OMP_CRITICAL; @@ -6011,6 +6008,7 @@ gfc_match_omp_depobj (void) gfc_error ("Expected %<( depobj )%> at %C"); return MATCH_ERROR; } + gfc_match (", "); /* optionally */ if (gfc_match ("update ( ") == MATCH_YES) { c = gfc_get_omp_clauses (); @@ -6046,7 +6044,7 @@ gfc_match_omp_depobj (void) gfc_free_expr (destroyobj); } } - else if (gfc_match_omp_clauses (&c, omp_mask (OMP_CLAUSE_DEPEND), true, false) + else if (gfc_match_omp_clauses (&c, omp_mask (OMP_CLAUSE_DEPEND), false, false) != MATCH_YES) goto error; @@ -6249,6 +6247,7 @@ gfc_match_omp_flush (void) enum gfc_omp_memorder mo = OMP_MEMORDER_UNSET; if (gfc_match_omp_eos () == MATCH_NO && gfc_peek_ascii_char () != '(') { + gfc_match (", "); /* optionally */ if (gfc_match ("seq_cst") == MATCH_YES) mo = OMP_MEMORDER_SEQ_CST; else if (gfc_match ("acq_rel") == MATCH_YES) @@ -6308,7 +6307,7 @@ gfc_match_omp_declare_simd (void) case MATCH_ERROR: return MATCH_ERROR; } - if (gfc_match_omp_clauses (&c, OMP_DECLARE_SIMD_CLAUSES, true, + if (gfc_match_omp_clauses (&c, OMP_DECLARE_SIMD_CLAUSES, false, needs_space) != MATCH_YES) return MATCH_ERROR; @@ -6450,7 +6449,7 @@ gfc_match_omp_declare_mapper (void) gfc_omp_clauses *clauses = NULL; - m = gfc_match_omp_clauses (&clauses, omp_mask (OMP_CLAUSE_MAP), true, true, + m = gfc_match_omp_clauses (&clauses, omp_mask (OMP_CLAUSE_MAP), false, false, false, false, OMP_MAP_UNSET); if (m != MATCH_YES) goto failure; @@ -6844,7 +6843,7 @@ gfc_match_omp_declare_reduction (void) gfc_free_omp_udr (omp_udr); return MATCH_ERROR; } - + gfc_match_char (','); /* optionally */ if (gfc_match (" initializer ( ") == MATCH_YES) { gfc_current_ns = combiner_ns->parent; @@ -6973,7 +6972,8 @@ gfc_match_omp_declare_target (void) goto cleanup; } } - else if (gfc_match_omp_clauses (&c, OMP_DECLARE_TARGET_CLAUSES) != MATCH_YES) + else if (gfc_match_omp_clauses (&c, OMP_DECLARE_TARGET_CLAUSES, false) + != MATCH_YES) return MATCH_ERROR; gfc_buffer_error (false); @@ -8116,7 +8116,7 @@ gfc_match_omp_thread_group_private (bool is_groupprivate) if (is_groupprivate) { gfc_omp_clauses *c; - m = gfc_match_omp_clauses (&c, omp_mask (OMP_CLAUSE_DEVICE_TYPE)); + m = gfc_match_omp_clauses (&c, omp_mask (OMP_CLAUSE_DEVICE_TYPE), false, false); if (m == MATCH_ERROR) return MATCH_ERROR; @@ -8459,7 +8459,7 @@ gfc_match_omp_requires (void) { old_loc = gfc_current_locus; gfc_omp_requires_kind requires_clause; - if ((first || gfc_match_char (',') != MATCH_YES) + if (gfc_match_char (',') != MATCH_YES && (first && gfc_match_space () != MATCH_YES)) goto error; first = false; @@ -8573,6 +8573,7 @@ gfc_match_omp_scan (void) bool incl; gfc_omp_clauses *c = gfc_get_omp_clauses (); gfc_gobble_whitespace (); + gfc_match (", "); /* optionally */ if ((incl = (gfc_match ("inclusive") == MATCH_YES)) || gfc_match ("exclusive") == MATCH_YES) { @@ -8959,7 +8960,7 @@ gfc_match_omp_atomic (void) gfc_omp_clauses *c; locus loc = gfc_current_locus; - if (gfc_match_omp_clauses (&c, OMP_ATOMIC_CLAUSES, true, true) != MATCH_YES) + if (gfc_match_omp_clauses (&c, OMP_ATOMIC_CLAUSES, false, true) != MATCH_YES) return MATCH_ERROR; if (c->atomic_op == GFC_OMP_ATOMIC_UNSET) @@ -9118,7 +9119,8 @@ gfc_match_omp_taskgroup (void) static enum gfc_omp_cancel_kind gfc_match_omp_cancel_kind (void) { - if (gfc_match_space () != MATCH_YES) + if (gfc_match (" , ") != MATCH_YES + && gfc_match_space () != MATCH_YES) return OMP_CANCEL_UNKNOWN; if (gfc_match ("parallel") == MATCH_YES) return OMP_CANCEL_PARALLEL; @@ -9177,7 +9179,8 @@ match gfc_match_omp_end_nowait (void) { bool nowait = false; - if (gfc_match ("% nowait") == MATCH_YES) + if (gfc_match ("% nowait ") == MATCH_YES + || gfc_match (" , nowait ") == MATCH_YES) nowait = true; if (gfc_match_omp_eos () != MATCH_YES) { @@ -9198,7 +9201,8 @@ gfc_match_omp_end_single (void) { gfc_omp_clauses *c; if (gfc_match_omp_clauses (&c, omp_mask (OMP_CLAUSE_COPYPRIVATE) - | OMP_CLAUSE_NOWAIT) != MATCH_YES) + | OMP_CLAUSE_NOWAIT, false) + != MATCH_YES) return MATCH_ERROR; new_st.op = EXEC_OMP_END_SINGLE; new_st.ext.omp_clauses = c; diff --git a/libgomp/libgomp.texi b/libgomp/libgomp.texi index b3700d7f1428..4a1069833082 100644 --- a/libgomp/libgomp.texi +++ b/libgomp/libgomp.texi @@ -442,7 +442,7 @@ to address of matching mapped list item per 5.1, Sect. 2.21.7.2 @tab N @tab @multitable @columnfractions .60 .10 .25 @headitem Description @tab Status @tab Comments -@item For Fortran, optional comma between directive and clause @tab N @tab +@item For Fortran, optional comma between directive and clause @tab Y @tab @item Conforming device numbers and @code{omp_initial_device} and @code{omp_invalid_device} enum/PARAMETER @tab Y @tab @item Initial value of @var{default-device-var} ICV with From 26c0268ea905bd576a3696b54899f8a8dd8d329d Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Mon, 21 Sep 2026 09:11:37 +0200 Subject: [PATCH 274/584] c, c++: Fix up __has_builtin(__builtin_{bitreverse,bswap}g) Both __builtin_bitreverseg and __builtin_bswapg are magic keyword builtins resolved in the FEs, added back in June. Unfortunately I forgot to make sure __has_builtin supports those. 2026-09-21 Jakub Jelinek gcc/c/ * c-decl.cc (names_builtin_p): Return 1 for RID_BUILTIN_BITREVERSEG and RID_BUILTIN_BSWAPG. gcc/cp/ * cp-objcp-common.cc (names_builtin_p): Return 1 for RID_BUILTIN_BITREVERSEG and RID_BUILTIN_BSWAPG. gcc/testsuite/ * c-c++-common/builtin-bswapg-1.c: Test __has_builtin(__builtin_bswapg). * c-c++-common/builtin-bitreverseg-1.c: Test __has_builtin(__builtin_bitreverseg). Reviewed-by: Joseph Myers Reviewed-by: Jason Merrill --- gcc/c/c-decl.cc | 2 ++ gcc/cp/cp-objcp-common.cc | 2 ++ gcc/testsuite/c-c++-common/builtin-bitreverseg-1.c | 4 ++++ gcc/testsuite/c-c++-common/builtin-bswapg-1.c | 4 ++++ 4 files changed, 12 insertions(+) diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc index 42d35a87a179..ada5a5043af4 100644 --- a/gcc/c/c-decl.cc +++ b/gcc/c/c-decl.cc @@ -11934,6 +11934,8 @@ names_builtin_p (const char *name) switch (C_RID_CODE (id)) { case RID_BUILTIN_ASSOC_BARRIER: + case RID_BUILTIN_BITREVERSEG: + case RID_BUILTIN_BSWAPG: case RID_BUILTIN_CONVERTVECTOR: case RID_BUILTIN_HAS_ATTRIBUTE: case RID_BUILTIN_SHUFFLE: diff --git a/gcc/cp/cp-objcp-common.cc b/gcc/cp/cp-objcp-common.cc index 36b9d743afdd..0cdf35adaa77 100644 --- a/gcc/cp/cp-objcp-common.cc +++ b/gcc/cp/cp-objcp-common.cc @@ -572,6 +572,8 @@ names_builtin_p (const char *name) switch (C_RID_CODE (id)) { case RID_ADDRESSOF: + case RID_BUILTIN_BITREVERSEG: + case RID_BUILTIN_BSWAPG: case RID_BUILTIN_CONVERTVECTOR: case RID_BUILTIN_HAS_ATTRIBUTE: case RID_BUILTIN_SHUFFLE: diff --git a/gcc/testsuite/c-c++-common/builtin-bitreverseg-1.c b/gcc/testsuite/c-c++-common/builtin-bitreverseg-1.c index dec3d6d7b2ba..d84281fc0c47 100644 --- a/gcc/testsuite/c-c++-common/builtin-bitreverseg-1.c +++ b/gcc/testsuite/c-c++-common/builtin-bitreverseg-1.c @@ -2,6 +2,10 @@ /* { dg-do run { target { c || c++11 } } } */ /* { dg-options "-O2" } */ +#if !__has_builtin(__builtin_bitreverseg) +#error __builtin_bitreverseg unsupported +#endif + #if __CHAR_BIT__ == 8 #if __SIZEOF_INT__ == 4 static_assert (__builtin_bitreverseg (0x2fa889a7U) == 0xe59115f4U, ""); diff --git a/gcc/testsuite/c-c++-common/builtin-bswapg-1.c b/gcc/testsuite/c-c++-common/builtin-bswapg-1.c index 75bc0a11dc5c..d6ae57432129 100644 --- a/gcc/testsuite/c-c++-common/builtin-bswapg-1.c +++ b/gcc/testsuite/c-c++-common/builtin-bswapg-1.c @@ -2,6 +2,10 @@ /* { dg-do run { target { c || c++11 } } } */ /* { dg-options "-O2" } */ +#if !__has_builtin(__builtin_bswapg) +#error __builtin_bswapg unsupported +#endif + #if __CHAR_BIT__ == 8 #if __SIZEOF_INT__ == 4 static_assert (__builtin_bswapg (0x12345678U) == 0x78563412U, ""); From fcecd85661f9947d09dd752124279fc537021106 Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Mon, 21 Sep 2026 09:13:34 +0200 Subject: [PATCH 275/584] i386: Only support GFNI V32QImode rotates with AVX2, not just AVX [PR127498] The following testcase ICEs, because the middle-end doesn't like a target to announce rot{l,r}v32qi3 optab availability only with const_int_operand rotate with non-working fallback. If the rotate optab fails because of unsatisfiable predicates, the middle-end will try to expand the rotate as bitwise or of 2 shifts, but the problem with TARGET_GFNI && TARGET_AVX && !TARGET_AVX2 is that the V32QImode shifts aren't supported either, one needs AVX2 for that. I believe there are no CPUs with GFNI and AVX but without AVX2, I think there are just CPUs with both GFNI and AVX/AVX2 or with GFNI and no AVX, so the following patch just disables the pattern for the TARGET_GFNI && TARGET_AVX combination and just requires TARGET_GFNI && TARGET_AVX2 instead. It is true that rotate can be expanded with constant rotate count even for V32QImode, but at the expense of ICEing for non-constant rotate count. The alternative would be to extend the pattern to provide a fallback for TARGET_GFNI && TARGET_AVX && !TARGET_AVX2 when the last operand is not const_int_operand, it can be handled as 4 V16QImode shifts, combining stuff together, ... 2026-09-21 Jakub Jelinek PR target/127498 * config/i386/sse.md (3 any_rotate:VI1_AVX512_3264): Add TARGET_AVX2 to condition. * gcc.target/i386/gfni-pr127498.c: New test. * gcc.target/i386/shift-gf2p8affine-5.c: Use -mavx2 in dg-options instead of -mavx. Expect 46 insns instead of 31. Reviewed-by: Hongtao Liu --- gcc/config/i386/sse.md | 2 +- gcc/testsuite/gcc.target/i386/gfni-pr127498.c | 17 +++++++++++++++++ .../gcc.target/i386/shift-gf2p8affine-5.c | 4 ++-- 3 files changed, 20 insertions(+), 3 deletions(-) create mode 100644 gcc/testsuite/gcc.target/i386/gfni-pr127498.c diff --git a/gcc/config/i386/sse.md b/gcc/config/i386/sse.md index a02e061c35c3..6b57c3019b26 100644 --- a/gcc/config/i386/sse.md +++ b/gcc/config/i386/sse.md @@ -28458,7 +28458,7 @@ (any_rotate:VI1_AVX512_3264 (match_operand:VI1_AVX512_3264 1 "register_operand") (match_operand:SI 2 "const_int_operand")))] - "TARGET_GFNI" + "TARGET_GFNI && TARGET_AVX2" { rtx matrix = ix86_vgf2p8affine_shift_matrix (operands[0], operands[2], ); emit_insn (gen_vgf2p8affineqb_ (operands[0], operands[1], matrix, diff --git a/gcc/testsuite/gcc.target/i386/gfni-pr127498.c b/gcc/testsuite/gcc.target/i386/gfni-pr127498.c new file mode 100644 index 000000000000..048ef7037e4a --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/gfni-pr127498.c @@ -0,0 +1,17 @@ +/* PR target/127498 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -mgfni -mavx -mno-avx2" } */ + +typedef unsigned char V __attribute__ ((vector_size (32))); + +V +foo (V x, int n) +{ + return (x >> n) | (x << (8 - n)); +} + +V +bar (V x, int n) +{ + return (x << n) | (x >> (8 - n)); +} diff --git a/gcc/testsuite/gcc.target/i386/shift-gf2p8affine-5.c b/gcc/testsuite/gcc.target/i386/shift-gf2p8affine-5.c index b8489a659a5b..f8dc4b5f8369 100644 --- a/gcc/testsuite/gcc.target/i386/shift-gf2p8affine-5.c +++ b/gcc/testsuite/gcc.target/i386/shift-gf2p8affine-5.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-mgfni -mavx -O3 -Wno-shift-count-negative -march=x86-64 -mtune=generic" } */ -/* { dg-final { scan-assembler-times "vgf2p8affineqb" 31 } } */ +/* { dg-options "-mgfni -mavx2 -O3 -Wno-shift-count-negative -march=x86-64 -mtune=generic" } */ +/* { dg-final { scan-assembler-times "vgf2p8affineqb" 46 } } */ #include "shift-gf2p8affine-2.c" From 4bcbeb8d5d4d23d2e575cd947c59c410d62ca457 Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Mon, 21 Sep 2026 09:16:21 +0200 Subject: [PATCH 276/584] c++: Fix reflection source_location_of on member function reflections [PR127493] We don't call maybe_get_first_fn in eval_source_location_of and so don't get to the DECL_SOURCE_LOCATION we otherwise could/should. The following patch fixes it. 2026-09-21 Jakub Jelinek PR c++/127493 * reflect.cc (eval_source_location_of): Call maybe_get_first_fn. * g++.dg/reflect/source_location_of1.C (struct G, struct H): New types. Add asserts for source_location_of of member function and member function template. * g++.dg/reflect/source_location_of2.C: Expect implicitEqLine rather than 0 for line of ^^ImplicitEq::operator==. Reviewed-by: Jason Merrill --- gcc/cp/reflect.cc | 2 ++ gcc/testsuite/g++.dg/reflect/source_location_of1.C | 4 ++++ gcc/testsuite/g++.dg/reflect/source_location_of2.C | 3 +-- 3 files changed, 7 insertions(+), 2 deletions(-) diff --git a/gcc/cp/reflect.cc b/gcc/cp/reflect.cc index 1278fc4c489b..51f0885436e0 100644 --- a/gcc/cp/reflect.cc +++ b/gcc/cp/reflect.cc @@ -2715,6 +2715,8 @@ eval_source_location_of (location_t loc, tree r, reflect_kind kind, for now use location_t of the base parent (i.e. the derived class). */ r = direct_base_derived (r); + else + r = maybe_get_first_fn (r); if (OVERLOAD_TYPE_P (r) || (TYPE_P (r) && typedef_variant_p (r))) rloc = DECL_SOURCE_LOCATION (TYPE_NAME (r)); else if (DECL_P (r) && r != global_namespace) diff --git a/gcc/testsuite/g++.dg/reflect/source_location_of1.C b/gcc/testsuite/g++.dg/reflect/source_location_of1.C index 8ba34dbbaa7b..6f32d036facd 100644 --- a/gcc/testsuite/g++.dg/reflect/source_location_of1.C +++ b/gcc/testsuite/g++.dg/reflect/source_location_of1.C @@ -23,6 +23,10 @@ union U {}; static_assert (source_location_of (^^U).line () == std::source_location::current ().line () - 1); void foo (int, int) {} static_assert (source_location_of (^^foo).line () == std::source_location::current ().line () - 1); +struct G { void foo (int, int) {} }; +static_assert (source_location_of (^^G::foo).line () == std::source_location::current ().line () - 1); +struct H { template void foo (T, T) {} }; +static_assert (source_location_of (^^H::foo).line () == std::source_location::current ().line () - 1); namespace N { namespace O {} } static_assert (source_location_of (^^N).line () == std::source_location::current ().line () - 1); static_assert (source_location_of (^^N::O).line () == std::source_location::current ().line () - 2); diff --git a/gcc/testsuite/g++.dg/reflect/source_location_of2.C b/gcc/testsuite/g++.dg/reflect/source_location_of2.C index 7ea4d9e652ed..dc1716eb91b2 100644 --- a/gcc/testsuite/g++.dg/reflect/source_location_of2.C +++ b/gcc/testsuite/g++.dg/reflect/source_location_of2.C @@ -38,7 +38,6 @@ struct ImplicitEq auto operator<=> (const ImplicitEq&) const = default; }; -// Would expect either class head, or operator<=> line -static_assert (source_location_of (^^ImplicitEq::operator==).line () == 0); +static_assert (source_location_of (^^ImplicitEq::operator==).line () == implicitEqLine); static_assert (source_location_of (select_mem (^^ImplicitEq, is_operator (op_equals_equals))).line () == implicitEqLine); static_assert (source_location_of (select_mem (^^ImplicitEq, is_operator (op_spaceship))).line () == implicitEqLine); From f304762cd50e80799a54a780b83dc0b39166ec52 Mon Sep 17 00:00:00 2001 From: "Jose E. Marchesi" Date: Mon, 21 Sep 2026 02:22:43 +0200 Subject: [PATCH 277/584] a68: get rid of SYMBOL_COMPLEX The SYMBOL_COMPLEX parse node attribute is now redundant and unused, in favor of SYMBOL_COMPL. Remove from the codebase. Signed-off-by: Jose E. Marchesi gcc/algol68/ChangeLog * a68-parser-attrs.def (COMPLEX_SYMBOL): Remove. * a68-parser-bottom-up.cc (reduce_declarers): Remove reduction of COMPLEX_SYMBOL. (reduce_declarers): Do not handle COMPLEX_SYMBOL. * a68-parser.cc (a68_dont_mark_here): Likewise. --- gcc/algol68/a68-parser-attrs.def | 1 - gcc/algol68/a68-parser-bottom-up.cc | 8 +++----- gcc/algol68/a68-parser.cc | 1 - 3 files changed, 3 insertions(+), 7 deletions(-) diff --git a/gcc/algol68/a68-parser-attrs.def b/gcc/algol68/a68-parser-attrs.def index c474a2653dbf..6f4e1183e7d1 100644 --- a/gcc/algol68/a68-parser-attrs.def +++ b/gcc/algol68/a68-parser-attrs.def @@ -88,7 +88,6 @@ A68_ATTR(COLLECTION, "collection") A68_ATTR(COLON_SYMBOL, "colon-symbol") A68_ATTR(COMMA_SYMBOL, "comma-symbol") A68_ATTR(COMPLEX_PATTERN, "complex pattern") -A68_ATTR(COMPLEX_SYMBOL, "complex-symbol") A68_ATTR(COMPL_SYMBOL, "compl-symbol") A68_ATTR(CONDITIONAL_CLAUSE, "conditional clause") A68_ATTR(CONFORMITY_CHOICE, "conformity clause choice") diff --git a/gcc/algol68/a68-parser-bottom-up.cc b/gcc/algol68/a68-parser-bottom-up.cc index c17436536b35..0ddf1f63fa88 100644 --- a/gcc/algol68/a68-parser-bottom-up.cc +++ b/gcc/algol68/a68-parser-bottom-up.cc @@ -773,7 +773,6 @@ reduce_declarers (NODE_T *p, enum a68_attribute expect) reduce (q, NO_NOTE, NO_TICK, INDICANT, REAL_SYMBOL, STOP); reduce (q, NO_NOTE, NO_TICK, INDICANT, BITS_SYMBOL, STOP); reduce (q, NO_NOTE, NO_TICK, INDICANT, BYTES_SYMBOL, STOP); - reduce (q, NO_NOTE, NO_TICK, INDICANT, COMPLEX_SYMBOL, STOP); reduce (q, NO_NOTE, NO_TICK, INDICANT, COMPL_SYMBOL, STOP); reduce (q, NO_NOTE, NO_TICK, INDICANT, BOOL_SYMBOL, STOP); reduce (q, NO_NOTE, NO_TICK, INDICANT, CHAR_SYMBOL, STOP); @@ -801,8 +800,7 @@ reduce_declarers (NODE_T *p, enum a68_attribute expect) a = ATTRIBUTE (SUB_NEXT (q)); if (a == INT_SYMBOL || a == REAL_SYMBOL || a == BITS_SYMBOL - || a == BYTES_SYMBOL || a == COMPLEX_SYMBOL - || a == COMPL_SYMBOL) + || a == BYTES_SYMBOL || a == COMPL_SYMBOL) { reduce (q, NO_NOTE, NO_TICK, DECLARER, LONGETY, INDICANT, STOP); } @@ -826,14 +824,14 @@ reduce_declarers (NODE_T *p, enum a68_attribute expect) { a = ATTRIBUTE (SUB_NEXT (q)); if (a == INT_SYMBOL || a == REAL_SYMBOL || a == BITS_SYMBOL - || a == BYTES_SYMBOL || a == COMPLEX_SYMBOL || a == COMPL_SYMBOL) + || a == BYTES_SYMBOL || a == COMPL_SYMBOL) { reduce (q, NO_NOTE, NO_TICK, DECLARER, SHORTETY, INDICANT, STOP); } else { a68_error (NEXT (q), "appropriate declarer expected"); - reduce (q, NO_NOTE, NO_TICK, DECLARER, LONGETY, INDICANT, STOP); + reduce (q, NO_NOTE, NO_TICK, DECLARER, SHORTETY, INDICANT, STOP); } } } diff --git a/gcc/algol68/a68-parser.cc b/gcc/algol68/a68-parser.cc index 2f64b0a86289..ae2a4cfcf182 100644 --- a/gcc/algol68/a68-parser.cc +++ b/gcc/algol68/a68-parser.cc @@ -421,7 +421,6 @@ a68_dont_mark_here (NODE_T *p) case CLOSE_SYMBOL: case COLON_SYMBOL: case COMMA_SYMBOL: - case COMPLEX_SYMBOL: case COMPL_SYMBOL: case DO_SYMBOL: case ELIF_SYMBOL: From 885ad73e630ca23d1810d55fd480f6ff519d42bf Mon Sep 17 00:00:00 2001 From: Artemiy Volkov Date: Tue, 11 Aug 2026 15:04:58 +0000 Subject: [PATCH 278/584] match.pd: fold extract-bitfield-and-shift expressions This patch adds a simplification rule for expressions of the form ((X >> C1) & C2) << C3, which extract some bits from X at position C1, perform an "and" with a mask which is normally just 2^N - 1, then shift the result left by C3. The transformation is limited to cases where X is unsigned, has its precision equal to its width and where C1 and C3 are smaller than the precision of X (the last condition could probably be just assumed but I wasn't sure so decided to play it safe). When all of the above conditions hold, the expression is folded into either: (a) (X >> (C1 - C3)) & (C2 << C3) when C1 >= C3, or (b) (X << (C3 - C1)) & (C2 << C3) when C1 < C3. Additional care is required to preserve the leading zeros formed by the X >> C1 operation in the original expression; to handle this, we clear the leading bits of the mask operand as a preliminary step. The corner case where C1 is one less the precision of X is handled elsewhere (and is folded to just (X >> C1) << C3 as long as the LSB of C2 isn't 0.) On aarch64, this results in: lsr x0, x0, 16 and w0, w0, 130816 being emitted instead of: lsr x1, x0, 32 lsr x0, x0, 24 ubfiz w1, w1, 16, 1 ubfiz w0, w0, 8, 8 orr w0, w1, w0 for the expression "((x >> 32) & 1) << 16) | (x >> 24) & 0xff) << 8)". A couple of new testcases added, with some focus on the case where X is shifted too far to the right as described above. Survives bootstrap and regtest on aarch64-linux-gnu and x86_64-linux-gnu. gcc/ChangeLog: * match.pd: New rule to fold ((X >> C1) & C2) << C3. gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/match-bit-extract-shift.c: New test. --- gcc/match.pd | 22 +++++++ .../gcc.dg/tree-ssa/match-bit-extract-shift.c | 61 +++++++++++++++++++ 2 files changed, 83 insertions(+) create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/match-bit-extract-shift.c diff --git a/gcc/match.pd b/gcc/match.pd index 88533dcf77a8..268bf3f11e52 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -1527,6 +1527,28 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) { tree utype = unsigned_type_for (type); } (convert (rshift (lshift (convert:utype @0) @2) @3)))))) +/* Fold (((X >> C1) & C2) << C3) into (X >>/<< |C1 - C3|) & (C2' << C3), + where C2' is obtained from C2 by clearing all but the rightmost C1 bits. */ +(simplify + (lshift (bit_and (rshift @0 INTEGER_CST@1) INTEGER_CST@2) INTEGER_CST@3) + (if (TYPE_UNSIGNED (TREE_TYPE (@0)) + && type_has_mode_precision_p (TREE_TYPE (@0))) + (with { int prec = TYPE_PRECISION (TREE_TYPE (@0)); } + (if (wi::ltu_p (wi::to_wide (@1), prec) + && wi::ltu_p (wi::to_wide (@3), prec)) + (with + { + /* Clear the first PREC - @1 bits of the mask, then shift it. */ + wide_int mask_lz = wi::mask (prec - tree_to_uhwi (@1), false, prec); + tree mask = fold_build2 (BIT_AND_EXPR, TREE_TYPE (@0), + @2, wide_int_to_tree (TREE_TYPE (@0), mask_lz)); + tree mask_shifted = fold_build2 (LSHIFT_EXPR, TREE_TYPE (@0), + mask, @3); + } + (if (wi::leu_p (wi::to_wide (@1), wi::to_wide (@3))) + (bit_and (lshift @0 (minus @3 @1)) { mask_shifted; }) + (bit_and (rshift @0 (minus @1 @3)) { mask_shifted; }))))))) + /* Fold ((type)(a<0)) << SIGNBITOFA into ((type)a) & signbit. */ (simplify (lshift (convert (lt @0 integer_zerop@1)) INTEGER_CST@2) diff --git a/gcc/testsuite/gcc.dg/tree-ssa/match-bit-extract-shift.c b/gcc/testsuite/gcc.dg/tree-ssa/match-bit-extract-shift.c new file mode 100644 index 000000000000..292ce5a41c90 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/match-bit-extract-shift.c @@ -0,0 +1,61 @@ +/* { dg-require-effective-target stdint_types } */ +/* { dg-do compile } */ +/* { dg-options "-O1 -fdump-tree-forwprop1" } */ + +#include + +uint32_t f (uint64_t x) +{ + return (((x >> 32) & 0x1) << 16) + | (((x >> 24) & 0xff) << 8); +} + +uint32_t f2 (uint64_t x) +{ + return (((x >> 3) & 0x3) << 16); +} + +uint32_t f3 (uint64_t x) +{ + return (((x >> 61) & 0xE) << 16); +} + +uint32_t f4 (uint64_t x) +{ + return (((x >> 62) & 0xE) << 16); +} + +uint32_t f5 (uint64_t x) +{ + return (((x >> 63) & 0xF) << 17); +} + +uint64_t f6 (uint64_t x) +{ + return (((x >> 32) & 0xFFFFFF) << 47); +} + +/* { dg-final { scan-tree-dump-not "<< 16" forwprop1 } } */ +/* { dg-final { scan-tree-dump-not ">> 32" forwprop1 } } */ +/* { dg-final { scan-tree-dump-not ">> 24" forwprop1 } } */ +/* { dg-final { scan-tree-dump-not ">> 3" forwprop1 } } */ +/* { dg-final { scan-tree-dump-not ">> 61" forwprop1 } } */ +/* { dg-final { scan-tree-dump-not ">> 62" forwprop1 } } */ +/* { dg-final { scan-tree-dump-not "<< 47" forwprop1 } } */ +/* { dg-final { scan-tree-dump-not "& 65536" forwprop1 } } */ +/* { dg-final { scan-tree-dump-not "& 65535" forwprop1 } } */ +/* { dg-final { scan-tree-dump-not "& 917504" forwprop1 } } */ + +/* { dg-final { scan-tree-dump-times ">> 16" 1 forwprop1 } } */ +/* { dg-final { scan-tree-dump-times ">> 45" 1 forwprop1 } } */ +/* { dg-final { scan-tree-dump-times ">> 46" 1 forwprop1 } } */ +/* { dg-final { scan-tree-dump-times "<< 13" 1 forwprop1 } } */ +/* { dg-final { scan-tree-dump-times ">> 63" 1 forwprop1 } } */ +/* { dg-final { scan-tree-dump-times "<< 17" 1 forwprop1 } } */ +/* { dg-final { scan-tree-dump-times "<< 15" 1 forwprop1 } } */ +/* { dg-final { scan-tree-dump-times "& 130816" 1 forwprop1 } } */ +/* { dg-final { scan-tree-dump-times "& 196608" 1 forwprop1 } } */ +/* { dg-final { scan-tree-dump-times "& 393216" 1 forwprop1 } } */ +/* { dg-final { scan-tree-dump-times "& 131072" 1 forwprop1 } } */ +/* { dg-final { scan-tree-dump-times "& 18446603336221196288" 1 forwprop1 } } */ + From 0947d974136292205743bc9bdaca5eb1ea0d6d67 Mon Sep 17 00:00:00 2001 From: Uros Bizjak Date: Mon, 21 Sep 2026 10:09:59 +0200 Subject: [PATCH 279/584] i386: Fix enabled attribute for V2QI negate/plusminus insns [PR127461] MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 'enabled' attribute has to be a pass-invariant static property per the RTL docs, and optimize_function_for_size_p (cfun)'s cgraph frequency/count term isn't — the same instability PR114232 already fixed for the insn condition, just missed here in enabled. PR target/127461 gcc/ChangeLog: * config/i386/mmx.md (negv2qi2): Use optimize_size instead of optimize_function_for_size_p (cfun) in the enabled attribute. (v2qi3): Ditto. gcc/testsuite/ChangeLog: * gcc.target/i386/pr127461.c: New test. --- gcc/config/i386/mmx.md | 4 ++-- gcc/testsuite/gcc.target/i386/pr127461.c | 23 +++++++++++++++++++++++ 2 files changed, 25 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/gcc.target/i386/pr127461.c diff --git a/gcc/config/i386/mmx.md b/gcc/config/i386/mmx.md index fc6286cfed2c..fa51f6a79918 100644 --- a/gcc/config/i386/mmx.md +++ b/gcc/config/i386/mmx.md @@ -3190,7 +3190,7 @@ (set (attr "enabled") (cond [(and (eq_attr "alternative" "0") (and (match_test "TARGET_PARTIAL_REG_STALL") - (not (match_test "optimize_function_for_size_p (cfun)")))) + (not (match_test "optimize_size")))) (symbol_ref "false") ] (const_string "*")))]) @@ -3297,7 +3297,7 @@ (set (attr "enabled") (cond [(and (eq_attr "alternative" "0") (and (match_test "TARGET_PARTIAL_REG_STALL") - (not (match_test "optimize_function_for_size_p (cfun)")))) + (not (match_test "optimize_size")))) (symbol_ref "false") ] (const_string "*")))]) diff --git a/gcc/testsuite/gcc.target/i386/pr127461.c b/gcc/testsuite/gcc.target/i386/pr127461.c new file mode 100644 index 000000000000..a0af16c3fb54 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr127461.c @@ -0,0 +1,23 @@ +/* PR target/127461 */ +/* { dg-do compile { target ia32 } } */ +/* { dg-options "-Og -msse2 -mtune=pentiumpro" } */ + +typedef __attribute__((__vector_size__(2))) char U; +typedef __attribute__((__vector_size__(2))) _Float16 V; +typedef __attribute__((__vector_size__(32))) int W; + +V a, b; +extern inline __attribute__((__cold__)) void foo(int, int, double, char ) { + (union {W w;}){}; + U u = (U)b + (U)a; + ((union { + U a; + char b[]; + })u) + .b; +} +void main() { + foo((int){}, (int){}, (int){}, 0); + for (;;) + ; +} From 316c6dddbb4858c2c34b58b3bddc6b85923d2799 Mon Sep 17 00:00:00 2001 From: Christophe Lyon Date: Fri, 18 Sep 2026 15:58:02 +0200 Subject: [PATCH 280/584] Fix check for working assembler --gdwarf-4 option The code fragment used to check for --gdwarf-4 option with the APP marker ends with a hard-coded 'ret' instruction, which is not supported by all architectures (e.g. arm). Replace it with $insn. gcc/ChangeLog: * configure.ac: Replace 'ret' with '$insn'. * configure: Regenerate. --- gcc/configure | 2 +- gcc/configure.ac | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/gcc/configure b/gcc/configure index cedf10b1d492..2d211a0beaea 100755 --- a/gcc/configure +++ b/gcc/configure @@ -32418,7 +32418,7 @@ foo: .file 1 \"foo.c\" $insn .file 2 \"foo.h\" - ret + $insn " dwarf4_success=no { $as_echo "$as_me:${as_lineno-$LINENO}: checking assembler for --gdwarf-4 with the APP marker" >&5 diff --git a/gcc/configure.ac b/gcc/configure.ac index 54b89954ef03..a4878c4a9f96 100644 --- a/gcc/configure.ac +++ b/gcc/configure.ac @@ -6010,7 +6010,7 @@ foo: .file 1 \"foo.c\" $insn .file 2 \"foo.h\" - ret + $insn " dwarf4_success=no gcc_GAS_CHECK_FEATURE([--gdwarf-4 with the APP marker], From 3d735adfba3217ee7e968f250eadf5f3f0a34ecd Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Mon, 21 Sep 2026 09:48:57 +0200 Subject: [PATCH 281/584] genextract: encode path steps as numbers rather than letters The path that locates an operand is a string of steps down the pattern, and a step used to be spelled as a character: a digit selected an XEXP, a lower-case letter an XVECEXP, and an upper-case letter an XVECEXP whose index had run past 'z'. Richard suggested using plain numbers instead, which is what this does. A step is now one byte, 2 * INDEX + 1 for XEXP (x, INDEX) and 2 * INDEX + 2 for XVECEXP (x, 0, INDEX). That leaves zero to terminate a path and 255 to mark an operand number the pattern does not use, so the walk loses its split ranges: for (; *p; p++) for (; *p; p++) if (ISDIGIT (*p)) { loc = &XEXP (*loc, *p - '0'); unsigned int step = *p - 1; else if (ISLOWER (*p)) -> if (step & 1) loc = &XVECEXP (*loc, 0, loc = &XVECEXP (*loc, 0, step >> 1); *p - 'a'); else else loc = &XEXP (*loc, step >> 1); loc = &XVECEXP (*loc, 0, } *p - UPPER_OFFSET); The table becomes an array of numbers rather than a string literal, so the terminator no longer has to be written "\000" to stop the next step being absorbed into the escape, and a zero in the table no longer looks like the index 0. It also removes a silent limit. The old spelling ran out of characters: an XEXP index above 9 produced ':', which the reader took for an XVECEXP step, and an XVECEXP index of 58 produced 'a', which it took for index 0. Neither is reachable from today's machine descriptions, but nothing said so. The encoder now asserts that an index fits. The tables grow, because a number costs more source than a printable character: insn-extract.cc goes from 124888 to 141866 bytes on aarch64, 251020 to 260479 on riscv64, 100542 to 117344 on x86_64 and 26639 to 28958 on avr. For scale, the file was 1.04MB on aarch64 before the table-driven rewrite. Bootstrapped on aarch64-none-linux-gnu. gcc/ChangeLog: * genextract.cc (locstr): Make it a string of bytes. (UPPER_OFFSET, MISSING_OPERAND_CHAR): Remove. (ENCODE_PATH_STEP, MISSING_OPERAND_STEP, MAX_PATH_INDEX): New macros. (accum_extract::pathstr): Hold bytes. (push_pathstr_operand): Encode the step as a number and check that the index fits. (VEC_safe_set_locstr, VEC_char_to_string, add_path, gen_insn): Update for the byte paths. (print_string_literal): Remove. (print_extractions): Emit the paths as an array of numbers and walk them without the character ranges. Signed-off-by: Kyrylo Tkachov --- gcc/genextract.cc | 135 ++++++++++++++++++++-------------------------- 1 file changed, 58 insertions(+), 77 deletions(-) diff --git a/gcc/genextract.cc b/gcc/genextract.cc index 62babeb3982b..57616d39aa6d 100644 --- a/gcc/genextract.cc +++ b/gcc/genextract.cc @@ -38,7 +38,7 @@ along with GCC; see the file COPYING3. If not see the same assumption (and uses the same representation) and it is currently true. */ -typedef char *locstr; +typedef unsigned char *locstr; struct extraction { @@ -76,27 +76,29 @@ class accum_extract auto_vec oplocs; auto_vec duplocs; auto_vec dupnums; - auto_vec pathstr; + auto_vec pathstr; }; /* Forward declarations. */ static void walk_rtx (md_rtx_info *, rtx, class accum_extract *); -#define UPPER_OFFSET ('A' - ('z' - 'a' + 1)) - -/* Convert integer OPERAND into a character - either into [a-zA-Z] for vector - operands or [0-9] for integer operands - and push onto the end of the path - in ACC. */ +/* A path is a sequence of steps down a pattern, one byte each. A step + down XEXP (x, INDEX) is 2 * INDEX + 1 and a step down XVECEXP (x, 0, + INDEX) is 2 * INDEX + 2, which leaves zero free to terminate a path and + MISSING_OPERAND_STEP free to mark an operand number that the pattern + does not use. */ +#define ENCODE_PATH_STEP(INDEX, IS_VECTOR) (2 * (INDEX) + (IS_VECTOR) + 1) +#define MISSING_OPERAND_STEP 255 +#define MAX_PATH_INDEX ((MISSING_OPERAND_STEP - 2) / 2) + +/* Encode the step to OPERAND, a vector element if IS_VECTOR, and push it + onto the end of the path in ACC. */ static void push_pathstr_operand (int operand, bool is_vector, class accum_extract *acc) { - if (is_vector && 'a' + operand > 'z') - acc->pathstr.safe_push (operand + UPPER_OFFSET); - else if (is_vector) - acc->pathstr.safe_push (operand + 'a'); - else - acc->pathstr.safe_push (operand + '0'); + gcc_assert (IN_RANGE (operand, 0, MAX_PATH_INDEX)); + acc->pathstr.safe_push (ENCODE_PATH_STEP (operand, is_vector)); } static void @@ -138,9 +140,10 @@ gen_insn (md_rtx_info *info) for (j = 0; j < op_count; j++) { - char *a = p->oplocs[j]; - char *b = acc.oplocs[j]; - if (a != b && (!a || !b || strcmp (a, b))) + locstr a = p->oplocs[j]; + locstr b = acc.oplocs[j]; + if (a != b + && (!a || !b || strcmp ((const char *) a, (const char *) b))) break; } @@ -149,7 +152,8 @@ gen_insn (md_rtx_info *info) for (j = 0; j < dup_count; j++) if (p->dupnums[j] != acc.dupnums[j] - || strcmp (p->duplocs[j], acc.duplocs[j])) + || strcmp ((const char *) p->duplocs[j], + (const char *) acc.duplocs[j])) break; if (j != dup_count) @@ -175,7 +179,7 @@ gen_insn (md_rtx_info *info) p->insns = link; link->next = 0; - p->oplocs = (char **)((char *)p + sizeof (struct extraction)); + p->oplocs = (locstr *)((char *)p + sizeof (struct extraction)); p->duplocs = p->oplocs + op_count; p->dupnums = (int *)(p->duplocs + dup_count); @@ -191,7 +195,7 @@ gen_insn (md_rtx_info *info) containing define_* expression. */ static void VEC_safe_set_locstr (md_rtx_info *info, vec *vp, - unsigned int ix, char *str) + unsigned int ix, locstr str) { if (ix < (*vp).length ()) { @@ -211,15 +215,16 @@ VEC_safe_set_locstr (md_rtx_info *info, vec *vp, } } -/* Another helper subroutine of walk_rtx: given a vec, convert it - to a NUL-terminated string in malloc memory. */ -static char * -VEC_char_to_string (const vec &v) +/* Another helper subroutine of walk_rtx: given a vec of path steps, + convert it to a zero-terminated path in malloc memory. No step is + zero, so the result can be handled as a string. */ +static unsigned char * +VEC_char_to_string (const vec &v) { size_t n = v.length (); - char *s = XNEWVEC (char, n + 1); + unsigned char *s = XNEWVEC (unsigned char, n + 1); memcpy (s, v.address (), n); - s[n] = '\0'; + s[n] = 0; return s; } @@ -304,11 +309,7 @@ walk_rtx (md_rtx_info *info, rtx x, class accum_extract *acc) } } -/* The character that marks an operand number that a pattern does not use. - It cannot clash with a path step, which is always a digit or a letter. */ -#define MISSING_OPERAND_CHAR '!' - -/* The paths of all extraction methods, concatenated. Each path is NUL +/* The paths of all extraction methods, concatenated. Each path is zero terminated; the paths of one method are adjacent, operands first and dups second. */ static struct obstack pathpool; @@ -320,13 +321,13 @@ static vec dupnums; to the path pool. */ static void -add_path (const char *path) +add_path (const unsigned char *path) { if (path) - obstack_grow (&pathpool, path, strlen (path)); + obstack_grow (&pathpool, path, strlen ((const char *) path)); else - obstack_1grow (&pathpool, MISSING_OPERAND_CHAR); - obstack_1grow (&pathpool, '\0'); + obstack_1grow (&pathpool, MISSING_OPERAND_STEP); + obstack_1grow (&pathpool, 0); } static void @@ -355,27 +356,6 @@ print_header (void) static rtx junk ATTRIBUTE_UNUSED;\n"); } -/* Print STR as a C string literal, broken into chunks so that no output - line gets excessively long. */ - -static void -print_string_literal (const char *str, unsigned int len) -{ - printf (" \""); - for (unsigned int i = 0; i < len; i++) - { - if (str[i] == '\0') - /* Spell the terminator with all three octal digits: the next - character may be a digit, which a shorter escape would absorb. */ - printf ("\\000"); - else - putchar (str[i]); - if ((i % 60) == 59 && i + 1 < len) - printf ("\"\n \""); - } - printf ("\""); -} - /* Print the tables that drive insn_extract, and insn_extract itself. */ static void @@ -428,20 +408,20 @@ print_extractions (void) path_start.safe_push (obstack_object_size (&pathpool)); unsigned int pool_len = obstack_object_size (&pathpool); - const char *pool = XOBFINISH (&pathpool, const char *); + const unsigned char *pool = XOBFINISH (&pathpool, const unsigned char *); printf ("/* The paths that locate the operands and the dups of each\n" " extraction method. A path is a sequence of steps down the\n" - " pattern: a digit D selects XEXP (x, D - '0'), a lower-case\n" - " letter L selects XVECEXP (x, 0, L - 'a') and an upper-case\n" - " letter U selects XVECEXP (x, 0, U - %d). An empty path denotes\n" - " the pattern itself and '%c' an operand number that the pattern\n" - " does not use. */\n", UPPER_OFFSET, MISSING_OPERAND_CHAR); - printf ("#define UPPER_OFFSET %d\n", UPPER_OFFSET); - printf ("#define MISSING_OPERAND_CHAR '%c'\n\n", MISSING_OPERAND_CHAR); - printf ("static const char extract_paths[] =\n"); - print_string_literal (pool, pool_len); - printf (";\n\n"); + " pattern, one byte each: an even step S selects\n" + " XVECEXP (x, 0, S / 2 - 1) and an odd step S selects\n" + " XEXP (x, S / 2). A zero terminates a path, an empty path\n" + " denotes the pattern itself, and %d marks an operand number\n" + " that the pattern does not use. */\n", MISSING_OPERAND_STEP); + printf ("#define MISSING_OPERAND_STEP %d\n\n", MISSING_OPERAND_STEP); + printf ("static const unsigned char extract_paths[] = {"); + for (i = 0; i < pool_len; i++) + printf ("%s%d,", (i % 20) == 0 ? "\n " : " ", pool[i]); + printf ("\n};\n\n"); printf ("static const unsigned char extract_dup_num[] = {"); for (i = 0; i < dupnums.length (); i++) @@ -469,21 +449,22 @@ print_extractions (void) printf ("\n};\n\n"); puts ("\ -/* Follow one NUL-terminated path in extract_paths from *PP, starting at\n\ +/* Follow one zero-terminated path in extract_paths from *PP, starting at\n\ the pattern *ROOT, and return the location it selects. *PP is left\n\ just after the path's terminator. */\n\ \n\ static inline rtx *\n\ -follow_extract_path (const char **pp, rtx *root)\n{\n\ - const char *p = *pp;\n\ +follow_extract_path (const unsigned char **pp, rtx *root)\n{\n\ + const unsigned char *p = *pp;\n\ rtx *loc = root;\n\ for (; *p; p++)\n\ - if (ISDIGIT (*p))\n\ - loc = &XEXP (*loc, *p - '0');\n\ - else if (ISLOWER (*p))\n\ - loc = &XVECEXP (*loc, 0, *p - 'a');\n\ - else\n\ - loc = &XVECEXP (*loc, 0, *p - UPPER_OFFSET);\n\ + {\n\ + unsigned int step = *p - 1;\n\ + if (step & 1)\n\ + loc = &XVECEXP (*loc, 0, step >> 1);\n\ + else\n\ + loc = &XEXP (*loc, step >> 1);\n\ + }\n\ *pp = p + 1;\n\ return loc;\n\ }\n"); @@ -526,9 +507,9 @@ insn_extract (rtx_insn *insn)\n{\n\ }\n\ \n\ const struct extract_method_d *m = &extract_methods[method];\n\ - const char *p = extract_paths + m->paths;\n\ + const unsigned char *p = extract_paths + m->paths;\n\ for (unsigned int i = 0; i < m->n_operands; i++)\n\ - if (*p == MISSING_OPERAND_CHAR)\n\ + if (*p == MISSING_OPERAND_STEP)\n\ {\n\ ro[i] = const0_rtx;\n\ ro_loc[i] = &junk;\n\ From bfedd20faaab8ee827db47c1b2e3f879fd8ba808 Mon Sep 17 00:00:00 2001 From: Josef Melcr Date: Thu, 10 Sep 2026 15:49:31 +0200 Subject: [PATCH 282/584] Downgrade IFN_ASSUME from const to pure This patch changes IFN_ASSUME to be pure instead of const. The const attribute means (not only) that the function cannot read global memory. While this is true for the internal call itself, it is only a dispatcher for the outlined assume body, which may read any memory, e.g. below: ``` struct S { int x, y; }; bool bar (int, int); bool foo (struct S *s) { [[assume (bar (s->x, s->y))]]; return s->x; } ``` Now, the read does not actually happen in reality, as the assume's body does not make into the final binary, but the call being marked incorrectly as const makes our analysis less accurate. PR ipa/127104 gcc/ChangeLog: * internal-fn.def (ASSUME): Downgrade from const to pure. Signed-off-by: Josef Melcr --- gcc/internal-fn.def | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/internal-fn.def b/gcc/internal-fn.def index af9f92950c73..b1c46a82a520 100644 --- a/gcc/internal-fn.def +++ b/gcc/internal-fn.def @@ -633,7 +633,7 @@ DEF_INTERNAL_FN (SHUFFLEVECTOR, ECF_CONST | ECF_LEAF | ECF_NOTHROW, NULL) DEF_INTERNAL_FN (SPACESHIP, ECF_CONST | ECF_LEAF | ECF_NOTHROW, NULL) /* [[assume (cond)]]. */ -DEF_INTERNAL_FN (ASSUME, ECF_CONST | ECF_LEAF | ECF_NOTHROW +DEF_INTERNAL_FN (ASSUME, ECF_PURE | ECF_LEAF | ECF_NOTHROW | ECF_LOOPING_CONST_OR_PURE, NULL) /* For if-conversion of inbranch SIMD clones. */ From d7a7947b89556aa3269d3b288ca7326584ae292f Mon Sep 17 00:00:00 2001 From: Gaius Mulley Date: Mon, 21 Sep 2026 11:42:15 +0100 Subject: [PATCH 283/584] PR modula2/127469: ICE when compiling code containing aggregate record using an array field This patch checks for a NulSym type during WalkConvert PCSymBuild and ignores it. The NulSym type presented to BuildConstructor in M2Quads generates an error message at the typename or '{' if the typename is absent. It would be good to spell check the typename at some future point. gcc/m2/ChangeLog: PR modula2/127469 * gm2-compiler/M2Quads.mod (BuildConstructor): Check for tok UnknownTokenNo and if not equal generate an error message at tok stating the type is unknown. * gm2-compiler/PCSymBuild.mod (WalkConvert): Check totype for NulSym and if so return FALSE. Signed-off-by: Gaius Mulley --- gcc/m2/gm2-compiler/M2Quads.mod | 10 ++++++++-- gcc/m2/gm2-compiler/PCSymBuild.mod | 5 ++++- 2 files changed, 12 insertions(+), 3 deletions(-) diff --git a/gcc/m2/gm2-compiler/M2Quads.mod b/gcc/m2/gm2-compiler/M2Quads.mod index dd8eb95ffe7c..8e92e52f7c0f 100644 --- a/gcc/m2/gm2-compiler/M2Quads.mod +++ b/gcc/m2/gm2-compiler/M2Quads.mod @@ -12671,8 +12671,14 @@ BEGIN PushValue (constValue) ; IF type = NulSym THEN - MetaErrorT0 (tokcbrpos, - '{%E}constructor requires a type before the opening %{') + IF tok = UnknownTokenNo + THEN + MetaErrorT0 (tokcbrpos, + '{%E}constructor requires a type before the opening %{') + ELSE + MetaErrorT0 (tok, + '{%E}the constructor type before the opening %{ is unknown') + END ELSE ChangeToConstructor (tok, type) ; PutConstructorFrom (constValue, type) ; diff --git a/gcc/m2/gm2-compiler/PCSymBuild.mod b/gcc/m2/gm2-compiler/PCSymBuild.mod index b514ba2b5316..0597a5481809 100644 --- a/gcc/m2/gm2-compiler/PCSymBuild.mod +++ b/gcc/m2/gm2-compiler/PCSymBuild.mod @@ -1839,7 +1839,10 @@ BEGIN RETURN( FALSE ) ELSE WITH e^.econvert DO - IF isTypeResolved(totype) + IF totype = NulSym + THEN + RETURN( FALSE ) + ELSIF isTypeResolved(totype) THEN assignType(e, totype) ; RETURN( TRUE ) From d028794ce7aee71c515346528f36ff985afd4f9f Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Mon, 21 Sep 2026 10:30:43 +0200 Subject: [PATCH 284/584] ipa/127479 - preserve PHI operand order with LTO streaming LTO streaming does not preserve the order of incoming edges and thus the order of PHI operands, disturbing the IPA ICF IPA reference comparison. The following rectifies this by streaming predecessor edges instead of successor edges (which leaves outgoing edge order not preserved) PR ipa/127479 * lto-streamer-out.cc (output_cfg): Output predecessor edges. * lto-streamer-in.cc (input_cfg): Input predecessor edges. * gcc.dg/lto/pr127479_0.c: New testcase. --- gcc/lto-streamer-in.cc | 12 +++---- gcc/lto-streamer-out.cc | 11 ++++--- gcc/testsuite/gcc.dg/lto/pr127479_0.c | 45 +++++++++++++++++++++++++++ 3 files changed, 58 insertions(+), 10 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/lto/pr127479_0.c diff --git a/gcc/lto-streamer-in.cc b/gcc/lto-streamer-in.cc index 901c32126568..668a5d3065b2 100644 --- a/gcc/lto-streamer-in.cc +++ b/gcc/lto-streamer-in.cc @@ -1113,25 +1113,25 @@ input_cfg (class lto_input_block *ib, class data_in *data_in, bb = make_new_block (fn, index); edge_count = streamer_read_uhwi (ib); + vec_safe_reserve (bb->preds, edge_count); /* Connect up the CFG. */ for (i = 0; i < edge_count; i++) { bitpack_d bp = streamer_read_bitpack (ib); - unsigned int dest_index = bp_unpack_var_len_unsigned (&bp); + unsigned int src_index = bp_unpack_var_len_unsigned (&bp); unsigned int edge_flags = bp_unpack_var_len_unsigned (&bp); - basic_block dest = BASIC_BLOCK_FOR_FN (fn, dest_index); + basic_block src = BASIC_BLOCK_FOR_FN (fn, src_index); - if (dest == NULL) - dest = make_new_block (fn, dest_index); + if (src == NULL) + src = make_new_block (fn, src_index); - edge e = make_edge (bb, dest, edge_flags); + edge e = make_edge (src, bb, edge_flags); data_in->location_cache.input_location_and_block (&e->goto_locus, &bp, ib, data_in); e->probability = profile_probability::stream_in (ib); if (!e->probability.initialized_p ()) full_profile = false; - } index = streamer_read_hwi (ib); diff --git a/gcc/lto-streamer-out.cc b/gcc/lto-streamer-out.cc index 7afc2673ea2b..6e34d4bea90f 100644 --- a/gcc/lto-streamer-out.cc +++ b/gcc/lto-streamer-out.cc @@ -2334,12 +2334,15 @@ output_cfg (struct output_block *ob, struct function *fn) streamer_write_hwi (ob, bb->index); - /* Output the successors and the edge flags. */ - streamer_write_uhwi (ob, EDGE_COUNT (bb->succs)); - FOR_EACH_EDGE (e, ei, bb->succs) + /* Output the predecessors and the edge flags. We output + predecessors instead of successors so PHI argument order + is preserved when we reconstruct the CFG greedily in + input_cfg. */ + streamer_write_uhwi (ob, EDGE_COUNT (bb->preds)); + FOR_EACH_EDGE (e, ei, bb->preds) { bitpack_d bp = bitpack_create (ob->main_stream); - bp_pack_var_len_unsigned (&bp, e->dest->index); + bp_pack_var_len_unsigned (&bp, e->src->index); bp_pack_var_len_unsigned (&bp, e->flags); stream_output_location_and_block (ob, &bp, e->goto_locus); e->probability.stream_out (ob); diff --git a/gcc/testsuite/gcc.dg/lto/pr127479_0.c b/gcc/testsuite/gcc.dg/lto/pr127479_0.c new file mode 100644 index 000000000000..d96dedabd4d0 --- /dev/null +++ b/gcc/testsuite/gcc.dg/lto/pr127479_0.c @@ -0,0 +1,45 @@ +/* { dg-lto-do run } */ +/* { dg-lto-options { { -O2 -flto } } } */ + +static char false_object; +static char true_object; + +__attribute__((noinline)) +static +char *less_equal(long comparison) { + if (comparison == 0) goto return_true; + if (comparison < 0) goto return_true; + goto return_false; + +return_true: + return &true_object; + +return_false: + return &false_object; +} + +__attribute__((noinline)) +static +char *greater_equal(long comparison) { + if (comparison == 0) goto return_true; + if (comparison < 0) goto return_false; + goto return_true; + +return_true: + return &true_object; + +return_false: + return &false_object; +} + +int main(void) { + volatile long negative = -1; + + int correct = + less_equal(negative) == &true_object && + greater_equal(negative) == &false_object; + + if (!correct) + __builtin_abort (); + return 0; +} From 13e24c75a812b4838242e8da7d6697d81534a30a Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Mon, 21 Sep 2026 09:53:41 +0200 Subject: [PATCH 285/584] tree-optimization/127475 - avoid get_same_sized_vectype This avoids using get_same_sized_vectype in vectorizable_induction where we only want a signed/unsigned variant of vectype. This avoids the oddball scalar boolean type handling in that function. PR tree-optimization/127475 * tree-vect-loop.cc (vectorizable_induction): Use signed_or_unsigned_type_for to get the step vectype. * gcc.dg/vect/vect-pr127475.c: New testcase. --- gcc/testsuite/gcc.dg/vect/vect-pr127475.c | 40 +++++++++++++++++++++++ gcc/tree-vect-loop.cc | 4 ++- 2 files changed, 43 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.dg/vect/vect-pr127475.c diff --git a/gcc/testsuite/gcc.dg/vect/vect-pr127475.c b/gcc/testsuite/gcc.dg/vect/vect-pr127475.c new file mode 100644 index 000000000000..5d7aef1b5af1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-pr127475.c @@ -0,0 +1,40 @@ +/* { dg-do compile } */ +/* { dg-additional-options "-fgimple" } */ + +typedef _Bool bool8 __attribute__((signed_bool_precision(8))); + +void __GIMPLE (ssa) +f (unsigned char * restrict a, int n) +{ + int i; + bool8 j; + unsigned char _31; + unsigned long _32; + unsigned char * _33; + + __BB(2): + if (n_2(D) > 0) + goto __BB3; + else + goto __BB5; + + __BB(3): + i_10 = __PHI (__BB2: 0, __BB4: i_11); + j_20 = __PHI (__BB2: _Literal (bool8) 0, __BB4: j_21); + _31 = (unsigned char) j_20; + _32 = (unsigned long) i_10; + _33 = a_1(D) + _32; + __MEM (_33) = _31; + j_21 = j_20 + _Literal (bool8) 1; + i_11 = i_10 + 1; + if (i_11 < n_2(D)) + goto __BB4; + else + goto __BB5; + + __BB(4): + goto __BB3; + + __BB(5): + return; +} diff --git a/gcc/tree-vect-loop.cc b/gcc/tree-vect-loop.cc index 4a0492381422..5169b60025e5 100644 --- a/gcc/tree-vect-loop.cc +++ b/gcc/tree-vect-loop.cc @@ -9650,7 +9650,9 @@ vectorizable_induction (loop_vec_info loop_vinfo, return false; } tree stept = TREE_TYPE (step_expr); - tree step_vectype = get_same_sized_vectype (stept, vectype); + tree step_vectype + = (!INTEGRAL_TYPE_P (stept) ? vectype + : signed_or_unsigned_type_for (TYPE_UNSIGNED (stept), vectype)); stept = TREE_TYPE (step_vectype); /* Check for target support of the vectorized arithmetic used here. */ From 1fc2416ddc96a2fb1492642823f67e64488a153a Mon Sep 17 00:00:00 2001 From: Alfie Richards Date: Mon, 21 Sep 2026 12:48:06 +0000 Subject: [PATCH 286/584] fix: riscv: Restore previous --param=riscv-autovec-mode behaviour [PR 127494] Fixed riscv regressions introduced in r17-4413-g3b99fd4bdc7005. Restores previous behaviour by only overriding autovec mode if it is one of the available autovec modes. gcc/ChangeLog: PR target/127494 * config/riscv/riscv-v.cc (autovectorize_vector_modes): Restore previous behaviour. --- gcc/config/riscv/riscv-v.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/gcc/config/riscv/riscv-v.cc b/gcc/config/riscv/riscv-v.cc index 1cf53c7841c9..faa43f4bf649 100644 --- a/gcc/config/riscv/riscv-v.cc +++ b/gcc/config/riscv/riscv-v.cc @@ -3069,7 +3069,8 @@ autovectorize_vector_modes (vector_modes *modes, bool) modes->truncate (0); machine_mode mode; - if (parse_machine_mode (riscv_autovec_mode, &mode)) + if (parse_machine_mode (riscv_autovec_mode, &mode) + && ms.contains (mode)) { modes->safe_push (mode); return 0; From 471022256e4705314aedf21c53bc351ece88ff43 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Mon, 21 Sep 2026 12:15:02 +0200 Subject: [PATCH 287/584] tree-optimization/127515 - ivopts: fix bound when counter wraps on first increment iv_elimination_compare_lt turns a loop with the exit test i < b, entered with i = a and a pointer p = base + a stepping in lockstep with i, into a loop with the exit test p < p_0 - a + b, so as to eliminate the counter. The number of iterations of the loop is (a + 1 > b) ? 0 : b - a - 1 and the fix for PR tree-optimization/113703 made sure that the bound is not derived from it, since converting b - a to the type of the offsets is not value preserving when the loop rolls zero times and b - a is negative. But the reasoning also assumes that a + 1 does not wrap around in the type of a, which need not be the case: if a is the maximum value of its type, then a + 1 is zero, a + 1 > b is false whatever b is, so the loop rolls and its number of iterations is b, whereas b - a computed on the offsets is b - a and not b + 1. For example, with void f (char *p, unsigned int i, unsigned int n) { p -= i; do { *p = 1; p -= 1; i++; } while (i < n); } called as f (p, -1, 1), the loop iterates twice but the bound is computed as p_0 + ((sizetype) 0xffffffff - (sizetype) 1), i.e. p_0 + 0xfffffffe instead of p_0 - 2, so the loop exits at the first test. So build the bound out of a + 1 and b + 1 instead of a and b, converting a + 1 to the type of the offsets as a whole instead of rewriting it into a and 1, and computing b + 1 in the type of the offsets, where it cannot wrap around. The difference of the two offsets is then the number of iterations of the loop in the wrapping case too, since a + 1 is zero there. Require the new pair of offsets to be non-negative and to not overflow as well. Co-Authored-By: Claude Opus 5 PR tree-optimization/113703 PR tree-optimization/127515 * tree-ssa-loop-ivopts.cc (iv_elimination_compare_lt): Also record A + 1 when matching the number of iterations. Convert it to OFF_TYPE as a whole, compute B + 1 in OFF_TYPE and require both to be non-negative scaled offsets that do not overflow. Build the bound out of them instead of A and B. * gcc.dg/torture/pr113703-5.c: New test. * gcc.dg/torture/pr113703-6.c: New test. --- gcc/testsuite/gcc.dg/torture/pr113703-5.c | 34 ++++++++++++ gcc/testsuite/gcc.dg/torture/pr113703-6.c | 33 ++++++++++++ gcc/tree-ssa-loop-ivopts.cc | 64 +++++++++++++++-------- 3 files changed, 110 insertions(+), 21 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/torture/pr113703-5.c create mode 100644 gcc/testsuite/gcc.dg/torture/pr113703-6.c diff --git a/gcc/testsuite/gcc.dg/torture/pr113703-5.c b/gcc/testsuite/gcc.dg/torture/pr113703-5.c new file mode 100644 index 000000000000..bb63c0f69e94 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr113703-5.c @@ -0,0 +1,34 @@ +/* { dg-do run { target lp64 } } */ +/* { dg-additional-options "-fno-tree-vectorize -fno-tree-loop-distribute-patterns" } */ + +#include + +uintptr_t sum = 0; + +__attribute__((noipa)) void +f (char *p, unsigned int i, unsigned int n) +{ + p -= i; + do + { + sum += (uintptr_t)p; + p -= 1; + i++; + } + while (i < n); +} + +int +main () +{ + /* The number of iterations of the loop is (i + 1 > n) ? 0 : n - i - 1. + I is -1, so i + 1 wraps around to 0 and is not greater than N, and the + loop iterates twice. IVOPTs used to replace the exit test by one on P + with the bound P_0 + ((sizetype) i - (sizetype) n), i.e. P_0 + 0xfffffffe + instead of P_0 - 2, and the loop ran away. */ + f ((char *)0x10000ffffffff, -1, 1); + /* SUM is 0x10000000000 + 0xfffffffffff. */ + if (sum != (uintptr_t)0x1ffffffffffff) + __builtin_abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/torture/pr113703-6.c b/gcc/testsuite/gcc.dg/torture/pr113703-6.c new file mode 100644 index 000000000000..de6f228eda3a --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr113703-6.c @@ -0,0 +1,33 @@ +/* { dg-do run { target lp64 } } */ +/* { dg-additional-options "-fno-tree-vectorize -fno-tree-loop-distribute-patterns" } */ + +#include + +uintptr_t sum = 0; + +__attribute__((noipa)) void +f (char *p, unsigned int i, unsigned int n) +{ + p += i; + do + { + sum += (uintptr_t)p; + p += 1; + i++; + } + while (i < n); +} + +int +main () +{ + /* Mirror image of gcc.dg/torture/pr113703-5.c with an increasing pointer: + the loop iterates twice and IVOPTs used to compute the bound as + P_0 - 0xfffffffe instead of P_0 + 2, making the loop exit at the first + test. */ + f ((char *)0xff00000001, -1, 1); + /* SUM is 0x10000000000 + 0x10000000001. */ + if (sum != (uintptr_t)0x20000000001) + __builtin_abort (); + return 0; +} diff --git a/gcc/tree-ssa-loop-ivopts.cc b/gcc/tree-ssa-loop-ivopts.cc index fa3c2c136fc0..ab2c797b3865 100644 --- a/gcc/tree-ssa-loop-ivopts.cc +++ b/gcc/tree-ssa-loop-ivopts.cc @@ -5290,33 +5290,44 @@ nonneg_scaled_offset_p (tree val, HOST_WIDE_INT step, tree off_type) bla (*p); p++; } - while (p < p_0 - a + b); + while (p < p_0 - (a + 1) + (b + 1)); - Note that the bound has to be computed as p_0 - a + b and not from the - number of iterations as p_0 + (b - a): the latter is only equivalent if - b - a does not wrap, which is not the case when the loop rolls zero times. + Note that the bound has to be computed as p_0 - (a + 1) + (b + 1) and not + from the number of iterations as p_0 + (b - a): the latter is only + equivalent if b - a does not wrap, which is not the case when the loop + rolls zero times. + + Note also that a + 1 must be used as the offset it is, i.e. converted to + the type of the offsets as a whole, and not rewritten into a and 1, since + it may wrap around in the type of a: this is precisely the case where the + loop rolls but b - a is not the number of iterations either. Conversely + b + 1 must be computed in the type of the offsets, where it cannot wrap + around, since nothing constrains b when the loop rolls zero times. For this to preserve correctness, we need to know that the values compared in the transformed loop are ordered the same way as i and b are. Since the comparison of the pointers is performed modulo the size of the address space, this needs a + 1 > b to be an unsigned comparison, and the offsets - a and b scaled by the step of the candidate to be non-negative and to not - overflow. Then: + a, b, a + 1 and b + 1 scaled by the step of the candidate to be + non-negative and to not overflow. Then: - 1) if a + 1 <= b, then p_0 - a + b is the final value of p, hence there is no + 1) if a + 1 <= b, then the loop rolls b - (a + 1) times, so that (b + 1) + - (a + 1) computed on the offsets is its number of iterations, and + p_0 - (a + 1) + (b + 1) is the final value of p, hence there is no overflow in computing it or the values of p, and the pointers increase monotonically together with i. - 2) if a + 1 > b, then the loop exits at the first test, and b <= a implies - that p_0 - a + b lies between the valid addresses p_0 - a and p_0, so - the test indeed fails. Here we also need to verify that the expression - p_0 - a does not overflow, which we prove using p_0 = base + a. */ + 2) if a + 1 > b, then the loop exits at the first test and a + 1 does not + wrap around, so b <= a implies that p_0 - (a + 1) + (b + 1) = p_0 - a + + b lies between the valid addresses p_0 - a and p_0, so the test indeed + fails. Here we also need to verify that the expression p_0 - a does not + overflow, which we prove using p_0 = base + a. */ static bool iv_elimination_compare_lt (struct ivopts_data *data, struct iv_use *use, struct iv_cand *cand, enum tree_code *comp_p, class tree_niter_desc *niter, tree *bound_p) { - tree cand_type, a, b, mbz, nit_type = TREE_TYPE (niter->niter); + tree cand_type, a, a1, b, b1, mbz, nit_type = TREE_TYPE (niter->niter); tree off_type, offset, bound; class aff_tree nit, tmpa, tmpb; enum tree_code comp; @@ -5356,6 +5367,7 @@ iv_elimination_compare_lt (struct ivopts_data *data, struct iv_use *use, tree op0 = TREE_OPERAND (mbz, 0); if (TREE_CODE (op0) == PLUS_EXPR && integer_onep (TREE_OPERAND (op0, 1))) { + a1 = op0; a = TREE_OPERAND (op0, 0); b = TREE_OPERAND (mbz, 1); } @@ -5369,6 +5381,7 @@ iv_elimination_compare_lt (struct ivopts_data *data, struct iv_use *use, /* Handle b < a + 1. */ if (TREE_CODE (op1) == PLUS_EXPR && integer_onep (TREE_OPERAND (op1, 1))) { + a1 = op1; a = TREE_OPERAND (op1, 0); b = TREE_OPERAND (mbz, 0); } @@ -5402,11 +5415,21 @@ iv_elimination_compare_lt (struct ivopts_data *data, struct iv_use *use, if (!difference_cannot_overflow_p (data, cand->iv->base, offset)) return false; + /* Convert A + 1 as a whole, since it may wrap around in the type of A, but + compute B + 1 in OFF_TYPE, where it cannot wrap around. */ + a1 = fold_convert (off_type, a1); + b1 = fold_build2 (PLUS_EXPR, off_type, fold_convert (off_type, b), + build_one_cst (off_type)); + /* The candidate is compared as an unsigned quantity, so the offsets by - which A and B move it away from CAND->IV->BASE - CAND->IV->STEP * A have - to be ordered the same way as A and B themselves. */ + which A + 1 and B + 1 move it away from CAND->IV->BASE - CAND->IV->STEP + * (A + 1) have to be ordered the same way as A + 1 and B + 1 themselves. + The same is required of A and B, in terms of which the bound is + expressed when the loop rolls zero times. */ if (!nonneg_scaled_offset_p (a, step, off_type) - || !nonneg_scaled_offset_p (b, step, off_type)) + || !nonneg_scaled_offset_p (b, step, off_type) + || !nonneg_scaled_offset_p (a1, step, off_type) + || !nonneg_scaled_offset_p (b1, step, off_type)) return false; /* Determine the new comparison operator. */ @@ -5418,15 +5441,14 @@ iv_elimination_compare_lt (struct ivopts_data *data, struct iv_use *use, else gcc_unreachable (); - /* Recompute the bound as CAND->IV->BASE - CAND->IV->STEP * A - + CAND->IV->STEP * B. Deriving it from the number of iterations, as - cand_value_at does, is not correct here: B - A is computed in NIT_TYPE + /* Recompute the bound as CAND->IV->BASE - CAND->IV->STEP * (A + 1) + + CAND->IV->STEP * (B + 1). Deriving it from the number of iterations, + as cand_value_at does, is not correct here: B - A is computed in NIT_TYPE and converting it to OFF_TYPE is not value preserving when the loop rolls zero times and B - A is thus negative. */ bound = fold_build2 (MINUS_EXPR, off_type, - fold_build2 (MULT_EXPR, off_type, cand->iv->step, - fold_convert (off_type, b)), - offset); + fold_build2 (MULT_EXPR, off_type, cand->iv->step, b1), + fold_build2 (MULT_EXPR, off_type, cand->iv->step, a1)); cand_type = TREE_TYPE (cand->iv->base); if (POINTER_TYPE_P (cand_type)) *bound_p = fold_build_pointer_plus (cand->iv->base, bound); From 8bce5e413a15abb756a1f6d0bc2f6741b6463b3e Mon Sep 17 00:00:00 2001 From: Matt Turner Date: Mon, 21 Sep 2026 07:26:08 -0600 Subject: [PATCH 288/584] [PATCH 1/5] alpha: implement the FP classification optabs GCC expands __builtin_isnan, __builtin_isinf, __builtin_isfinite and __builtin_isnormal into FP comparisons on alpha, and by default those comparisons carry no software-completion suffix: isnan_d: cmptun $f16,$f16,$f10 fbne $f10,$L11 A subnormal operand raises a denormal-operand exception there, and the outcome depends on the FPCR denormal-operand-disable bit: the operand is flushed to zero, which makes a subnormal indistinguishable from a zero, or the trap is delivered with no completion information, which is fatal: $ cat cls.c #include int main (void) { volatile double sub = 0x1p-1050; return fpclassify (sub); } $ ./cls Floating point exception (core dumped) -mieee is the documented way to get subnormal support, so this is a matter of quality of implementation rather than conformance, but the classification built-ins exist to detect exactly these values and should not kill the process when given one. Classify by inspecting the encoding in an integer register instead, as the AArch64 isinf, isfinite and isnan expanders do for PR66462. Defining these patterns also stops fold_builtin_interclass_mathfn from rewriting the built-ins into comparisons in the first place. With -mieee the comparisons are completed by the kernel and are cheaper, so keep the generic expansions there, except with -fsignaling-nans: a comparison raises an invalid-operation exception for a signaling NaN, which is the PR66462 case that AArch64 and LoongArch handle the same way. gcc/ChangeLog: PR middle-end/66462 * config/alpha/alpha-protos.h (enum alpha_fp_class): New. (alpha_expand_fp_classify): Declare. * config/alpha/alpha.cc (alpha_expand_fp_classify): New function. * config/alpha/alpha.md (isfinite2, isinf2) (isnan2, isnormal2): New expanders. gcc/testsuite/ChangeLog: PR middle-end/66462 * gcc.target/alpha/fp-classify-1.c: New test. * gcc.target/alpha/fp-classify-2.c: New test. * gcc.target/alpha/fp-classify-3.c: New test. * gcc.target/alpha/fp-classify-4.c: New test. --- gcc/config/alpha/alpha-protos.h | 11 +++ gcc/config/alpha/alpha.cc | 71 +++++++++++++++++++ gcc/config/alpha/alpha.md | 44 ++++++++++++ .../gcc.target/alpha/fp-classify-1.c | 17 +++++ .../gcc.target/alpha/fp-classify-2.c | 9 +++ .../gcc.target/alpha/fp-classify-3.c | 10 +++ .../gcc.target/alpha/fp-classify-4.c | 65 +++++++++++++++++ 7 files changed, 227 insertions(+) create mode 100644 gcc/testsuite/gcc.target/alpha/fp-classify-1.c create mode 100644 gcc/testsuite/gcc.target/alpha/fp-classify-2.c create mode 100644 gcc/testsuite/gcc.target/alpha/fp-classify-3.c create mode 100644 gcc/testsuite/gcc.target/alpha/fp-classify-4.c diff --git a/gcc/config/alpha/alpha-protos.h b/gcc/config/alpha/alpha-protos.h index c64121d1f3f9..66a1b5a6a6b0 100644 --- a/gcc/config/alpha/alpha-protos.h +++ b/gcc/config/alpha/alpha-protos.h @@ -48,6 +48,17 @@ extern bool alpha_expand_mov_nobwx (machine_mode, rtx *); extern void alpha_expand_movmisalign (machine_mode, rtx *); extern void alpha_emit_floatuns (rtx[]); extern rtx alpha_emit_conditional_move (rtx, machine_mode); + +/* Selects the test performed by alpha_expand_fp_classify. */ +enum alpha_fp_class +{ + ALPHA_FPCLASS_FINITE, + ALPHA_FPCLASS_INF, + ALPHA_FPCLASS_NAN, + ALPHA_FPCLASS_NORMAL +}; + +extern void alpha_expand_fp_classify (rtx, rtx, enum alpha_fp_class); extern void alpha_split_tmode_pair (rtx[], machine_mode, bool); extern void alpha_split_tfmode_frobsign (rtx[], rtx (*)(rtx, rtx, rtx)); extern void alpha_expand_unaligned_load (rtx, rtx, HOST_WIDE_INT, diff --git a/gcc/config/alpha/alpha.cc b/gcc/config/alpha/alpha.cc index 15b4a074f21c..3165a1e8d4a0 100644 --- a/gcc/config/alpha/alpha.cc +++ b/gcc/config/alpha/alpha.cc @@ -2806,6 +2806,77 @@ alpha_emit_setcc (rtx operands[], machine_mode cmp_mode) } +/* Expand a floating-point classification of OP, storing 0 or 1 into + TARGET. KIND selects the test performed. + + The FP comparison instructions cannot be used for this. Without + software completion -- which the compiler only arranges for -mieee, + i.e. alpha_fptm >= ALPHA_FPTM_SU -- a subnormal operand is either + flushed to zero, which makes it indistinguishable from a zero, or + traps with no completion information, which is fatal. They also + raise an invalid-operation exception for a signaling NaN. Examine + the encoding in an integer register instead. */ + +void +alpha_expand_fp_classify (rtx target, rtx op, enum alpha_fp_class kind) +{ + machine_mode mode = GET_MODE (op); + const struct real_format *fmt = REAL_MODE_FORMAT (mode); + int width = GET_MODE_BITSIZE (as_a (mode)); + int mant_bits = fmt->p - 1; + int exp_bits = width - mant_bits - 1; + HOST_WIDE_INT exp_max = (HOST_WIDE_INT_1 << exp_bits) - 1; + rtx bits, mag, exp, mant, res, tmp; + + /* Move the raw encoding into an integer register, zero extended to + DImode so that the shifts below are independent of MODE. */ + bits = force_lowpart_subreg (int_mode_for_mode (mode).require (), op, mode); + bits = convert_to_mode (DImode, bits, 1); + + /* Shifting out the sign bit leaves the magnitude left justified. */ + mag = expand_shift (LSHIFT_EXPR, DImode, bits, 65 - width, NULL_RTX, 1); + exp = expand_shift (RSHIFT_EXPR, DImode, mag, 64 - exp_bits, NULL_RTX, 1); + + switch (kind) + { + case ALPHA_FPCLASS_FINITE: + /* The exponent field is not all ones. */ + res = emit_store_flag_force (NULL_RTX, NE, exp, GEN_INT (exp_max), + DImode, 0, 1); + break; + + case ALPHA_FPCLASS_NORMAL: + /* The exponent field is neither zero nor all ones, i.e. + (unsigned) (exp - 1) < exp_max - 1. */ + tmp = expand_binop (DImode, sub_optab, exp, const1_rtx, NULL_RTX, + 1, OPTAB_LIB_WIDEN); + res = emit_store_flag_force (NULL_RTX, LTU, tmp, GEN_INT (exp_max - 1), + DImode, 1, 1); + break; + + case ALPHA_FPCLASS_INF: + case ALPHA_FPCLASS_NAN: + /* The exponent field is all ones, and the significand field is zero + for an infinity, nonzero for a NaN. */ + mant = expand_shift (LSHIFT_EXPR, DImode, bits, 64 - mant_bits, + NULL_RTX, 1); + tmp = emit_store_flag_force (NULL_RTX, EQ, exp, GEN_INT (exp_max), + DImode, 0, 1); + res = emit_store_flag_force (NULL_RTX, + kind == ALPHA_FPCLASS_NAN ? NE : EQ, + mant, const0_rtx, DImode, 0, 1); + res = expand_binop (DImode, and_optab, tmp, res, NULL_RTX, + 1, OPTAB_LIB_WIDEN); + break; + + default: + gcc_unreachable (); + } + + emit_move_insn (target, gen_lowpart (GET_MODE (target), res)); +} + + /* Rewrite a comparison against zero CMP of the form (CODE (cc0) (const_int 0)) so it can be written validly in a conditional move (if_then_else CMP ...). diff --git a/gcc/config/alpha/alpha.md b/gcc/config/alpha/alpha.md index 880654b36a28..269e2afe4707 100644 --- a/gcc/config/alpha/alpha.md +++ b/gcc/config/alpha/alpha.md @@ -2855,6 +2855,50 @@ FAIL; }) +;; Floating-point classification. Defining these patterns also stops +;; fold_builtin_interclass_mathfn from rewriting the built-ins into FP +;; comparisons, which are unusable here; see alpha_expand_fp_classify. + +(define_expand "isfinite2" + [(match_operand:SI 0 "register_operand") + (match_operand:FMODE 1 "register_operand")] + "TARGET_FP && !TARGET_FLOAT_VAX + && (alpha_fptm < ALPHA_FPTM_SU || flag_signaling_nans)" +{ + alpha_expand_fp_classify (operands[0], operands[1], ALPHA_FPCLASS_FINITE); + DONE; +}) + +(define_expand "isinf2" + [(match_operand:SI 0 "register_operand") + (match_operand:FMODE 1 "register_operand")] + "TARGET_FP && !TARGET_FLOAT_VAX + && (alpha_fptm < ALPHA_FPTM_SU || flag_signaling_nans)" +{ + alpha_expand_fp_classify (operands[0], operands[1], ALPHA_FPCLASS_INF); + DONE; +}) + +(define_expand "isnan2" + [(match_operand:SI 0 "register_operand") + (match_operand:FMODE 1 "register_operand")] + "TARGET_FP && !TARGET_FLOAT_VAX + && (alpha_fptm < ALPHA_FPTM_SU || flag_signaling_nans)" +{ + alpha_expand_fp_classify (operands[0], operands[1], ALPHA_FPCLASS_NAN); + DONE; +}) + +(define_expand "isnormal2" + [(match_operand:SI 0 "register_operand") + (match_operand:FMODE 1 "register_operand")] + "TARGET_FP && !TARGET_FLOAT_VAX + && (alpha_fptm < ALPHA_FPTM_SU || flag_signaling_nans)" +{ + alpha_expand_fp_classify (operands[0], operands[1], ALPHA_FPCLASS_NORMAL); + DONE; +}) + (define_expand "cstoretf4" [(use (match_operator:DI 1 "alpha_cbranch_operator" [(match_operand:TF 2 "general_operand") diff --git a/gcc/testsuite/gcc.target/alpha/fp-classify-1.c b/gcc/testsuite/gcc.target/alpha/fp-classify-1.c new file mode 100644 index 000000000000..b1bac48cf763 --- /dev/null +++ b/gcc/testsuite/gcc.target/alpha/fp-classify-1.c @@ -0,0 +1,17 @@ +/* The floating-point classification built-ins must not be expanded into FP + comparisons: without software completion (-mieee) a comparison against a + subnormal operand either traps or has the operand flushed to zero. */ + +/* { dg-do compile } */ +/* { dg-options "-O2" } */ + +int isnan_f (float x) { return __builtin_isnan (x); } +int isnan_d (double x) { return __builtin_isnan (x); } +int isinf_f (float x) { return __builtin_isinf (x); } +int isinf_d (double x) { return __builtin_isinf (x); } +int isfinite_f (float x) { return __builtin_isfinite (x); } +int isfinite_d (double x) { return __builtin_isfinite (x); } +int isnormal_f (float x) { return __builtin_isnormal (x); } +int isnormal_d (double x) { return __builtin_isnormal (x); } + +/* { dg-final { scan-assembler-not "\tcmpt" } } */ diff --git a/gcc/testsuite/gcc.target/alpha/fp-classify-2.c b/gcc/testsuite/gcc.target/alpha/fp-classify-2.c new file mode 100644 index 000000000000..9bcf2401234d --- /dev/null +++ b/gcc/testsuite/gcc.target/alpha/fp-classify-2.c @@ -0,0 +1,9 @@ +/* With -mieee the comparisons carry the software-completion suffix and are + usable, so the generic expansions are kept. */ + +/* { dg-do compile } */ +/* { dg-options "-O2 -mieee" } */ + +int isnan_d (double x) { return __builtin_isnan (x); } + +/* { dg-final { scan-assembler "cmptun/su" } } */ diff --git a/gcc/testsuite/gcc.target/alpha/fp-classify-3.c b/gcc/testsuite/gcc.target/alpha/fp-classify-3.c new file mode 100644 index 000000000000..47272887359f --- /dev/null +++ b/gcc/testsuite/gcc.target/alpha/fp-classify-3.c @@ -0,0 +1,10 @@ +/* With -fsignaling-nans the comparisons are unusable even with -mieee, + since cmptun raises an invalid-operation exception for a signaling NaN. */ + +/* { dg-do compile } */ +/* { dg-options "-O2 -mieee -fsignaling-nans" } */ + +int isnan_f (float x) { return __builtin_isnan (x); } +int isnan_d (double x) { return __builtin_isnan (x); } + +/* { dg-final { scan-assembler-not "\tcmpt" } } */ diff --git a/gcc/testsuite/gcc.target/alpha/fp-classify-4.c b/gcc/testsuite/gcc.target/alpha/fp-classify-4.c new file mode 100644 index 000000000000..e32ea1d486d0 --- /dev/null +++ b/gcc/testsuite/gcc.target/alpha/fp-classify-4.c @@ -0,0 +1,65 @@ +/* Without -mieee the isnan, isinf, isfinite and isnormal built-ins must + classify subnormals, infinities and NaNs correctly, without trapping. */ + +/* { dg-do run } */ +/* { dg-options "-O2 -fno-inline" } */ + +enum { NAN_, INF_, NORMAL_, SUBNORMAL_, ZERO_ }; + +static void +t_f (float x, int class) +{ + if (__builtin_isnan (x) != (class == NAN_)) + __builtin_abort (); + if (__builtin_isinf (x) != (class == INF_)) + __builtin_abort (); + if (__builtin_isfinite (x) != (class != NAN_ && class != INF_)) + __builtin_abort (); + if (__builtin_isnormal (x) != (class == NORMAL_)) + __builtin_abort (); +} + +static void +t_d (double x, int class) +{ + if (__builtin_isnan (x) != (class == NAN_)) + __builtin_abort (); + if (__builtin_isinf (x) != (class == INF_)) + __builtin_abort (); + if (__builtin_isfinite (x) != (class != NAN_ && class != INF_)) + __builtin_abort (); + if (__builtin_isnormal (x) != (class == NORMAL_)) + __builtin_abort (); +} + +/* Keep the operands away from the constant folders. */ +volatile float vf[] = { + 0.0f, -0.0f, 1.0f, -1.0f, __FLT_MIN__, __FLT_MAX__, -__FLT_MAX__, + __FLT_DENORM_MIN__, -__FLT_DENORM_MIN__, __FLT_MIN__ / 2, + __builtin_inff (), -__builtin_inff (), __builtin_nanf (""), + -__builtin_nanf ("") +}; + +volatile double vd[] = { + 0.0, -0.0, 1.0, -1.0, __DBL_MIN__, __DBL_MAX__, -__DBL_MAX__, + __DBL_DENORM_MIN__, -__DBL_DENORM_MIN__, __DBL_MIN__ / 2, + __builtin_inf (), -__builtin_inf (), __builtin_nan (""), + -__builtin_nan ("") +}; + +const int classes[] = { + ZERO_, ZERO_, NORMAL_, NORMAL_, NORMAL_, NORMAL_, NORMAL_, + SUBNORMAL_, SUBNORMAL_, SUBNORMAL_, + INF_, INF_, NAN_, NAN_ +}; + +int +main () +{ + for (unsigned i = 0; i < sizeof classes / sizeof classes[0]; i++) + { + t_f (vf[i], classes[i]); + t_d (vd[i], classes[i]); + } + return 0; +} From 060d50fe29d01c429320114a71a549c512219782 Mon Sep 17 00:00:00 2001 From: Matt Turner Date: Mon, 21 Sep 2026 07:26:53 -0600 Subject: [PATCH 289/584] [PATCH 2/5] aarch64: umov and smov require base Advanced SIMD The [r, w] alternatives of the SHORT extend patterns emit umov and smov, which are Advanced SIMD instructions, but they are guarded by the "fp" arch attribute. With -march=armv8-a+nosimd a 16-bit value in an FP register is therefore extended with an instruction the assembler rejects: unsigned int f (_Float16 x) { unsigned short s; __builtin_memcpy (&s, &x, sizeof (s)); return s; } Error: selected processor does not support `umov w0,v0.h[0]' Guard both alternatives with "base_simd" instead, so that without SIMD the value is extended from memory. gcc/ChangeLog: * config/aarch64/aarch64.md (*extend2_aarch64): Guard the smov alternative with base_simd rather than fp. (*zero_extend2_aarch64): Likewise for umov. gcc/testsuite/ChangeLog: * gcc.target/aarch64/nosimd-extend.c: New test. --- gcc/config/aarch64/aarch64.md | 18 +++++++------- .../gcc.target/aarch64/nosimd-extend.c | 24 +++++++++++++++++++ 2 files changed, 33 insertions(+), 9 deletions(-) create mode 100644 gcc/testsuite/gcc.target/aarch64/nosimd-extend.c diff --git a/gcc/config/aarch64/aarch64.md b/gcc/config/aarch64/aarch64.md index 302658c970d2..b299ef14283c 100644 --- a/gcc/config/aarch64/aarch64.md +++ b/gcc/config/aarch64/aarch64.md @@ -2666,10 +2666,10 @@ [(set (match_operand:GPI 0 "register_operand") (sign_extend:GPI (match_operand:SHORT 1 "nonimmediate_operand")))] "" - {@ [ cons: =0 , 1 ; attrs: type , arch ] - [ r , r ; extend , * ] sxt\t%0, %w1 - [ r , m ; load_4 , * ] ldrs\t%0, %1 - [ r , w ; neon_to_gp , fp ] smov\t%0, %1.[0] + {@ [ cons: =0 , 1 ; attrs: type , arch ] + [ r , r ; extend , * ] sxt\t%0, %w1 + [ r , m ; load_4 , * ] ldrs\t%0, %1 + [ r , w ; neon_to_gp , base_simd ] smov\t%0, %1.[0] } ) @@ -2677,11 +2677,11 @@ [(set (match_operand:GPI 0 "register_operand") (zero_extend:GPI (match_operand:SHORT 1 "nonimmediate_operand")))] "" - {@ [ cons: =0 , 1 ; attrs: type , arch ] - [ r , r ; logic_imm , * ] and\t%0, %1, - [ r , m ; load_4 , * ] ldr\t%w0, %1 - [ w , m ; f_loads , fp ] ldr\t%0, %1 - [ r , w ; neon_to_gp , fp ] umov\t%w0, %1.[0] + {@ [ cons: =0 , 1 ; attrs: type , arch ] + [ r , r ; logic_imm , * ] and\t%0, %1, + [ r , m ; load_4 , * ] ldr\t%w0, %1 + [ w , m ; f_loads , fp ] ldr\t%0, %1 + [ r , w ; neon_to_gp , base_simd ] umov\t%w0, %1.[0] } ) diff --git a/gcc/testsuite/gcc.target/aarch64/nosimd-extend.c b/gcc/testsuite/gcc.target/aarch64/nosimd-extend.c new file mode 100644 index 000000000000..ce5dce389f30 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/nosimd-extend.c @@ -0,0 +1,24 @@ +/* { dg-do assemble } */ +/* { dg-options "-O2 -march=armv8-a+nosimd -save-temps" } */ + +/* umov and smov are Advanced SIMD instructions, so they must not be used + to move a 16-bit value out of an FP register when SIMD is disabled. */ + +unsigned int +zext (_Float16 x) +{ + unsigned short s; + __builtin_memcpy (&s, &x, sizeof (s)); + return s; +} + +int +sext (_Float16 x) +{ + short s; + __builtin_memcpy (&s, &x, sizeof (s)); + return s; +} + +/* { dg-final { scan-assembler-not {\tumov\t} } } */ +/* { dg-final { scan-assembler-not {\tsmov\t} } } */ From e8fb8ba77cf7a1688a063690fad27fb584c77b38 Mon Sep 17 00:00:00 2001 From: Matt Turner Date: Mon, 21 Sep 2026 07:27:42 -0600 Subject: [PATCH 290/584] [PATCH 3/5] AArch64: Add isnormal expander [PR 66462] Add an expander for isnormal using integer arithmetic. This is typically faster and avoids generating spurious exceptions on signaling NaNs. This fixes part of PR66462. int isnormal1 (float x) { return __builtin_isnormal (x); } Before: fabs s0, s0 mov w0, 2139095039 fmov s31, w0 fcmp s0, s31 movi v31.2s, 0x80, lsl 16 fccmp s0, s31, 1, ls cset w0, lt eor w0, w0, 1 ret After: fmov w0, s0 ubfx w0, w0, 23, 8 sub w0, w0, #1 cmp w0, 254 cset w0, cc ret HFmode and BFmode are handled too. Neither has 16-bit integer arithmetic, so their encoding is zero-extended into a word first: int isnormal2 (_Float16 x) { return __builtin_isnormal (x); } Before: umov w0, v0.h[0] mvni v0.4h, 0x84, lsl 8 movi v30.4h, 0x4, lsl 8 fcvt s0, h0 and w0, w0, 32767 fcvt s30, h30 dup v31.4h, w0 fcvt s31, h31 fcmp s31, s0 cset w0, hi fcmp s31, s30 cset w1, lt orr w0, w0, w1 eor w0, w0, 1 ret After: umov w0, v0.h[0] ubfx w0, w0, 10, 5 sub w0, w0, #1 cmp w0, 30 cset w0, cc ret gcc/ChangeLog: PR middle-end/66462 * config/aarch64/aarch64.md (isnormal2): Add new expander. * config/aarch64/iterators.md (GPF_HF_BF): New mode iterator. (mantissa_bits): Add HF and BF. (V_INT_EQUIV): Add BF. gcc/testsuite/ChangeLog: PR middle-end/66462 * gcc.target/aarch64/pr66462.c: Add tests for isnormal, including _Float16 and __bf16. --- gcc/config/aarch64/aarch64.md | 29 +++++++++ gcc/config/aarch64/iterators.md | 7 ++- gcc/testsuite/gcc.target/aarch64/pr66462.c | 72 ++++++++++++++++++++++ 3 files changed, 106 insertions(+), 2 deletions(-) diff --git a/gcc/config/aarch64/aarch64.md b/gcc/config/aarch64/aarch64.md index b299ef14283c..625c9996348f 100644 --- a/gcc/config/aarch64/aarch64.md +++ b/gcc/config/aarch64/aarch64.md @@ -7900,6 +7900,35 @@ } ) +;; A number is normal iff its exponent field E is neither 0 nor all ones, +;; i.e. (unsigned) (E - 1) < EXP_MAX - 1. +(define_expand "isnormal2" + [(match_operand:SI 0 "register_operand") + (match_operand:GPF_HF_BF 1 "register_operand")] + "TARGET_FLOAT" +{ + scalar_int_mode imode = mode; + int exp_bits = GET_MODE_BITSIZE (mode) - - 1; + HOST_WIDE_INT exp_max = (HOST_WIDE_INT_1 << exp_bits) - 1; + rtx op = force_lowpart_subreg (imode, operands[1], mode); + /* There is no 16-bit arithmetic, so work on the encoding of the 16-bit + formats in a word. */ + if (imode == HImode) + imode = SImode; + op = convert_to_mode (imode, op, 1); + op = expand_simple_binop (imode, LSHIFTRT, op, GEN_INT (), + NULL_RTX, 1, OPTAB_DIRECT); + op = expand_simple_binop (imode, AND, op, GEN_INT (exp_max), + NULL_RTX, 1, OPTAB_DIRECT); + op = expand_simple_binop (imode, PLUS, op, constm1_rtx, + NULL_RTX, 1, OPTAB_DIRECT); + rtx cc_reg = aarch64_gen_compare_reg (LTU, op, GEN_INT (exp_max - 1)); + rtx cmp = gen_rtx_fmt_ee (LTU, SImode, cc_reg, const0_rtx); + emit_insn (gen_aarch64_cstoresi (operands[0], cmp, cc_reg)); + DONE; +} +) + ;; ------------------------------------------------------------------- ;; Reload support ;; ------------------------------------------------------------------- diff --git a/gcc/config/aarch64/iterators.md b/gcc/config/aarch64/iterators.md index d41c8921d162..568786e37149 100644 --- a/gcc/config/aarch64/iterators.md +++ b/gcc/config/aarch64/iterators.md @@ -65,6 +65,9 @@ ;; Iterator for all 16-bit scalar floating point modes (HF, BF) (define_mode_iterator HFBF [HF BF]) +;; Iterator for all scalar floating point modes (HF, BF, SF, DF) +(define_mode_iterator GPF_HF_BF [HF BF SF DF]) + ;; Iterator for all integer modes (up to 64-bit) plus all General Purpose ;; Floating-point registers (32- and 64-bit modes). (define_mode_iterator ALLI_GPF [ALLI GPF]) @@ -1522,7 +1525,7 @@ (define_mode_attr half_mask [(HI "255") (SI "65535") (DI "4294967295")]) -(define_mode_attr mantissa_bits [(SF "23") (DF "52")]) +(define_mode_attr mantissa_bits [(HF "10") (BF "7") (SF "23") (DF "52")]) ;; For constraints used in scalar immediate vector moves (define_mode_attr hq [(HI "h") (QI "q")]) @@ -2502,7 +2505,7 @@ (V2SF "V2SI") (V4SF "V4SI") (DF "DI") (V2DF "V2DI") (SF "SI") (SI "SI") - (HF "HI") + (HF "HI") (BF "HI") (VNx16QI "VNx16QI") (VNx8HI "VNx8HI") (VNx8HF "VNx8HI") (VNx8BF "VNx8HI") diff --git a/gcc/testsuite/gcc.target/aarch64/pr66462.c b/gcc/testsuite/gcc.target/aarch64/pr66462.c index 2bd734b3193c..c6367ac16f68 100644 --- a/gcc/testsuite/gcc.target/aarch64/pr66462.c +++ b/gcc/testsuite/gcc.target/aarch64/pr66462.c @@ -64,6 +64,42 @@ static void t_nan (double x, bool res) __builtin_abort (); } +static void t_normalf (float x, bool res) +{ + if (__builtin_isnormal (x) != res) + __builtin_abort (); + if (__builtin_isnormal (-x) != res) + __builtin_abort (); + if (fetestexcept (FE_INVALID)) + __builtin_abort (); +} + +static void t_normal (double x, bool res) +{ + if (__builtin_isnormal (x) != res) + __builtin_abort (); + if (__builtin_isnormal (-x) != res) + __builtin_abort (); + if (fetestexcept (FE_INVALID)) + __builtin_abort (); +} + + +/* Generate the _Float16 and __bf16 testers with a macro rather than + spelling out the same body for each type. */ +#define DEF_TEST(NAME, TYPE, PRED) \ +static void NAME (TYPE x, bool res) \ +{ \ + if (PRED (x) != res) \ + __builtin_abort (); \ + if (PRED (-x) != res) \ + __builtin_abort (); \ + if (fetestexcept (FE_INVALID)) \ + __builtin_abort (); \ +} + +DEF_TEST (t_normal16, _Float16, __builtin_isnormal) +DEF_TEST (t_normalbf, __bf16, __builtin_isnormal) int main () @@ -106,5 +142,41 @@ main () t_nan (__builtin_nans (""), 1); t_nan (__builtin_nan (""), 1); + t_normalf (0.0f, 0); + t_normalf (1.0f, 1); + t_normalf (__FLT_MIN__, 1); + t_normalf (__FLT_MAX__, 1); + t_normalf (__FLT_DENORM_MIN__, 0); + t_normalf (__builtin_inff (), 0); + t_normalf (__builtin_nansf (""), 0); + t_normalf (__builtin_nanf (""), 0); + + t_normal (0.0, 0); + t_normal (1.0, 1); + t_normal (__DBL_MIN__, 1); + t_normal (__DBL_MAX__, 1); + t_normal (__DBL_DENORM_MIN__, 0); + t_normal (__builtin_inf (), 0); + t_normal (__builtin_nans (""), 0); + t_normal (__builtin_nan (""), 0); + + t_normal16 (0.0f16, 0); + t_normal16 (1.0f16, 1); + t_normal16 (__FLT16_MIN__, 1); + t_normal16 (__FLT16_MAX__, 1); + t_normal16 (__FLT16_DENORM_MIN__, 0); + t_normal16 ((_Float16) __builtin_inff (), 0); + t_normal16 (__builtin_nansf16 (""), 0); + t_normal16 (__builtin_nanf16 (""), 0); + + t_normalbf (0.0bf16, 0); + t_normalbf (1.0bf16, 1); + t_normalbf (__BFLT16_MIN__, 1); + t_normalbf (__BFLT16_MAX__, 1); + t_normalbf (__BFLT16_DENORM_MIN__, 0); + t_normalbf ((__bf16) __builtin_inff (), 0); + t_normalbf (__builtin_nansf16b (""), 0); + t_normalbf ((__bf16) __builtin_nanf (""), 0); + return 0; } From 52330debcdf1fcbb858aa1a07d10c5c286828a97 Mon Sep 17 00:00:00 2001 From: Matt Turner Date: Mon, 21 Sep 2026 07:28:28 -0600 Subject: [PATCH 291/584] [PATCH 4/5] AArch64: Support HFmode and BFmode in isinf, isfinite and isnan [PR 66462] The isinf, isfinite and isnan expanders are restricted to SFmode and DFmode, so _Float16 and __bf16 still classify with FP comparisons. Extend them to the two 16-bit formats. Neither has 16-bit integer arithmetic, so zero-extend the encoding into a word and shift the sign bit out of the top of that instead of out of the top of the 16-bit value. int isinf1 (_Float16 x) { return __builtin_isinf (x); } Before: umov w0, v0.h[0] mvni v30.4h, 0x84, lsl 8 fcvt s30, h30 and w0, w0, 32767 dup v31.4h, w0 fcvt s31, h31 fcmp s31, s30 cset w0, eq ret After: umov w0, v0.h[0] mov w1, -134217728 cmp w1, w0, lsl 17 cset w0, eq ret gcc/ChangeLog: PR middle-end/66462 * config/aarch64/aarch64.md (cmp_swp__reg): Add a parameterized name. (isinf2): Use GPF_HF_BF and handle the 16-bit formats. (isfinite2): Likewise. (isnan2): Likewise. gcc/testsuite/ChangeLog: PR middle-end/66462 * gcc.target/aarch64/pr66462.c: Add _Float16 and __bf16 tests for isinf, isfinite and isnan. --- gcc/config/aarch64/aarch64.md | 59 ++++++++++++++++------ gcc/testsuite/gcc.target/aarch64/pr66462.c | 41 +++++++++++++++ 2 files changed, 84 insertions(+), 16 deletions(-) diff --git a/gcc/config/aarch64/aarch64.md b/gcc/config/aarch64/aarch64.md index 625c9996348f..40f7e8e2881a 100644 --- a/gcc/config/aarch64/aarch64.md +++ b/gcc/config/aarch64/aarch64.md @@ -4697,7 +4697,7 @@ [(set_attr "type" "fcmp")] ) -(define_insn "cmp_swp__reg" +(define_insn "@cmp_swp__reg" [(set (reg:CC_SWP CC_REGNUM) (compare:CC_SWP (ASHIFT:GPI (match_operand:GPI 0 "register_operand" "r") @@ -7854,14 +7854,23 @@ (define_expand "isinf2" [(match_operand:SI 0 "register_operand") - (match_operand:GPF 1 "register_operand")] + (match_operand:GPF_HF_BF 1 "register_operand")] "TARGET_FLOAT" { - rtx op = force_lowpart_subreg (mode, operands[1], mode); - rtx tmp = gen_reg_rtx (mode); - emit_move_insn (tmp, GEN_INT (HOST_WIDE_INT_M1U << ( + 1))); + scalar_int_mode imode = mode; + rtx op = force_lowpart_subreg (imode, operands[1], mode); + /* There is no 16-bit arithmetic, so zero-extend the encoding of the + 16-bit formats into a word and shift the sign bit out of the top of + that instead. */ + if (imode == HImode) + imode = SImode; + op = convert_to_mode (imode, op, 1); + int pad = GET_MODE_BITSIZE (imode) - GET_MODE_BITSIZE (mode); + rtx tmp = gen_reg_rtx (imode); + emit_move_insn (tmp, gen_int_mode (HOST_WIDE_INT_M1U + << ( + 1 + pad), imode)); rtx cc_reg = gen_rtx_REG (CC_SWPmode, CC_REGNUM); - emit_insn (gen_cmp_swp_lsl_reg (op, GEN_INT (1), tmp)); + emit_insn (gen_cmp_swp_reg (ASHIFT, imode, op, GEN_INT (1 + pad), tmp)); rtx cmp = gen_rtx_fmt_ee (EQ, SImode, cc_reg, const0_rtx); emit_insn (gen_aarch64_cstoresi (operands[0], cmp, cc_reg)); DONE; @@ -7870,14 +7879,23 @@ (define_expand "isfinite2" [(match_operand:SI 0 "register_operand") - (match_operand:GPF 1 "register_operand")] + (match_operand:GPF_HF_BF 1 "register_operand")] "TARGET_FLOAT" { - rtx op = force_lowpart_subreg (mode, operands[1], mode); - rtx tmp = gen_reg_rtx (mode); - emit_move_insn (tmp, GEN_INT (HOST_WIDE_INT_M1U << ( + 1))); + scalar_int_mode imode = mode; + rtx op = force_lowpart_subreg (imode, operands[1], mode); + /* There is no 16-bit arithmetic, so zero-extend the encoding of the + 16-bit formats into a word and shift the sign bit out of the top of + that instead. */ + if (imode == HImode) + imode = SImode; + op = convert_to_mode (imode, op, 1); + int pad = GET_MODE_BITSIZE (imode) - GET_MODE_BITSIZE (mode); + rtx tmp = gen_reg_rtx (imode); + emit_move_insn (tmp, gen_int_mode (HOST_WIDE_INT_M1U + << ( + 1 + pad), imode)); rtx cc_reg = gen_rtx_REG (CC_SWPmode, CC_REGNUM); - emit_insn (gen_cmp_swp_lsl_reg (op, GEN_INT (1), tmp)); + emit_insn (gen_cmp_swp_reg (ASHIFT, imode, op, GEN_INT (1 + pad), tmp)); rtx cmp = gen_rtx_fmt_ee (LTU, SImode, cc_reg, const0_rtx); emit_insn (gen_aarch64_cstoresi (operands[0], cmp, cc_reg)); DONE; @@ -7886,14 +7904,23 @@ (define_expand "isnan2" [(match_operand:SI 0 "register_operand") - (match_operand:GPF 1 "register_operand")] + (match_operand:GPF_HF_BF 1 "register_operand")] "TARGET_FLOAT && flag_signaling_nans" { - rtx op = force_lowpart_subreg (mode, operands[1], mode); - rtx tmp = gen_reg_rtx (mode); - emit_move_insn (tmp, GEN_INT (HOST_WIDE_INT_M1U << ( + 1))); + scalar_int_mode imode = mode; + rtx op = force_lowpart_subreg (imode, operands[1], mode); + /* There is no 16-bit arithmetic, so zero-extend the encoding of the + 16-bit formats into a word and shift the sign bit out of the top of + that instead. */ + if (imode == HImode) + imode = SImode; + op = convert_to_mode (imode, op, 1); + int pad = GET_MODE_BITSIZE (imode) - GET_MODE_BITSIZE (mode); + rtx tmp = gen_reg_rtx (imode); + emit_move_insn (tmp, gen_int_mode (HOST_WIDE_INT_M1U + << ( + 1 + pad), imode)); rtx cc_reg = gen_rtx_REG (CC_SWPmode, CC_REGNUM); - emit_insn (gen_cmp_swp_lsl_reg (op, GEN_INT (1), tmp)); + emit_insn (gen_cmp_swp_reg (ASHIFT, imode, op, GEN_INT (1 + pad), tmp)); rtx cmp = gen_rtx_fmt_ee (GTU, SImode, cc_reg, const0_rtx); emit_insn (gen_aarch64_cstoresi (operands[0], cmp, cc_reg)); DONE; diff --git a/gcc/testsuite/gcc.target/aarch64/pr66462.c b/gcc/testsuite/gcc.target/aarch64/pr66462.c index c6367ac16f68..7fa7faf3d739 100644 --- a/gcc/testsuite/gcc.target/aarch64/pr66462.c +++ b/gcc/testsuite/gcc.target/aarch64/pr66462.c @@ -98,7 +98,14 @@ static void NAME (TYPE x, bool res) \ __builtin_abort (); \ } +DEF_TEST (t_inf16, _Float16, __builtin_isinf) +DEF_TEST (t_fin16, _Float16, __builtin_isfinite) +DEF_TEST (t_nan16, _Float16, __builtin_isnan) DEF_TEST (t_normal16, _Float16, __builtin_isnormal) + +DEF_TEST (t_infbf, __bf16, __builtin_isinf) +DEF_TEST (t_finbf, __bf16, __builtin_isfinite) +DEF_TEST (t_nanbf, __bf16, __builtin_isnan) DEF_TEST (t_normalbf, __bf16, __builtin_isnormal) int @@ -160,6 +167,40 @@ main () t_normal (__builtin_nans (""), 0); t_normal (__builtin_nan (""), 0); + t_inf16 (1.0f16, 0); + t_inf16 ((_Float16) __builtin_inff (), 1); + t_inf16 (__builtin_nansf16 (""), 0); + t_inf16 (__builtin_nanf16 (""), 0); + + t_infbf (1.0bf16, 0); + t_infbf ((__bf16) __builtin_inff (), 1); + t_infbf (__builtin_nansf16b (""), 0); + t_infbf ((__bf16) __builtin_nanf (""), 0); + + t_fin16 (0.0f16, 1); + t_fin16 (1.0f16, 1); + t_fin16 ((_Float16) __builtin_inff (), 0); + t_fin16 (__builtin_nansf16 (""), 0); + t_fin16 (__builtin_nanf16 (""), 0); + + t_finbf (0.0bf16, 1); + t_finbf (1.0bf16, 1); + t_finbf ((__bf16) __builtin_inff (), 0); + t_finbf (__builtin_nansf16b (""), 0); + t_finbf ((__bf16) __builtin_nanf (""), 0); + + t_nan16 (0.0f16, 0); + t_nan16 (1.0f16, 0); + t_nan16 ((_Float16) __builtin_inff (), 0); + t_nan16 (__builtin_nansf16 (""), 1); + t_nan16 (__builtin_nanf16 (""), 1); + + t_nanbf (0.0bf16, 0); + t_nanbf (1.0bf16, 0); + t_nanbf ((__bf16) __builtin_inff (), 0); + t_nanbf (__builtin_nansf16b (""), 1); + t_nanbf ((__bf16) __builtin_nanf (""), 1); + t_normal16 (0.0f16, 0); t_normal16 (1.0f16, 1); t_normal16 (__FLT16_MIN__, 1); From 5cc9ef64063c45cac1d67fcdaba9258fbaf21a8c Mon Sep 17 00:00:00 2001 From: Matt Turner Date: Mon, 21 Sep 2026 07:29:37 -0600 Subject: [PATCH 292/584] [PATCH 5/5] builtins: build fpclassify on the classification optabs [PR66462] A target defines the isnan, isinf and isnormal optabs when FP comparisons are unsuitable for classification, and fold_builtin_interclass_mathfn leaves those built-ins alone when it does. fold_builtin_fpclassify does not: it always expands into comparisons, so __builtin_fpclassify keeps the problems the individual built-ins were fixed to avoid. On AArch64 with -fsignaling-nans, where all three optabs are now available, fpclassify still raises FE_INVALID for a signaling NaN, as it does on LoongArch, which defines the same three optabs under that flag; on Alpha without -mieee a comparison against a subnormal operand traps or flushes it to zero, so FP_SUBNORMAL cannot be told from FP_ZERO. When all three optabs are available for the mode, build fpclassify on the corresponding built-ins instead, and test zero versus subnormal by shifting the sign bit out of the encoding rather than by comparing against zero, which would reintroduce the same problem. That shift is only valid for a binary format whose sign is a single bit at the top of the matching integer mode, so formats like XFmode, whose encoding is narrower than that mode, and the composite formats, whose sign bit cannot be shifted out, keep the generic expansion. With -fsignaling-nans on AArch64, fpclassify of a double becomes: fmov x1, d0 mov x2, -9007199254740992 mov w0, 0 cmp x2, x1, lsl 1 bcc .L1 mov w0, 1 cmp x2, x1, lsl 1 beq .L1 ubfx x2, x1, 52, 11 mov w0, 4 sub x2, x2, #1 cmp x2, 2045 bls .L1 cmp xzr, x1, lsl 1 cset w0, ne add w0, w0, 2 .L1: ret gcc/ChangeLog: PR middle-end/66462 * builtins.cc (fold_builtin_fpclassify): Expand using the classification built-ins when their optabs are available. gcc/testsuite/ChangeLog: PR middle-end/66462 * gcc.target/aarch64/pr66462-2.c: New test. * gcc.target/alpha/fp-classify-5.c: New test. * gcc.target/alpha/fp-classify-6.c: New test. --- gcc/builtins.cc | 73 +++++++++++++++ gcc/testsuite/gcc.target/aarch64/pr66462-2.c | 91 +++++++++++++++++++ .../gcc.target/alpha/fp-classify-5.c | 20 ++++ .../gcc.target/alpha/fp-classify-6.c | 55 +++++++++++ 4 files changed, 239 insertions(+) create mode 100644 gcc/testsuite/gcc.target/aarch64/pr66462-2.c create mode 100644 gcc/testsuite/gcc.target/alpha/fp-classify-5.c create mode 100644 gcc/testsuite/gcc.target/alpha/fp-classify-6.c diff --git a/gcc/builtins.cc b/gcc/builtins.cc index ae414d6ea178..c6a730c5b0a0 100644 --- a/gcc/builtins.cc +++ b/gcc/builtins.cc @@ -10019,6 +10019,79 @@ fold_builtin_fpclassify (location_t loc, tree *args, int nargs) arg = args[5]; type = TREE_TYPE (arg); mode = TYPE_MODE (type); + + /* A target defines the classification optabs when FP comparisons are + unsuitable for classification, for instance because they raise + FE_INVALID for a signaling NaN (PR middle-end/66462). Build on the + built-ins in that case rather than on comparisons. */ + if (optab_handler (isnan_optab, mode) != CODE_FOR_nothing + && optab_handler (isinf_optab, mode) != CODE_FOR_nothing + && optab_handler (isnormal_optab, mode) != CODE_FOR_nothing) + { + tree isnan_fn = builtin_decl_explicit (BUILT_IN_ISNAN); + tree isinf_fn = builtin_decl_explicit (BUILT_IN_ISINF); + tree isnormal_fn = builtin_decl_explicit (BUILT_IN_ISNORMAL); + const struct real_format *fmt = REAL_MODE_FORMAT (mode); + tree itype = NULL_TREE; + scalar_int_mode imode; + + /* The remaining zero versus subnormal test must not use a comparison + either. Testing the magnitude of the encoding for zero works + whenever the format is binary, has a matching integer mode and + stores its sign in the high bit of it; that excludes e.g. XFmode, + whose encoding is narrower than its integer mode, and the composite + formats, whose sign is not a single bit that can be shifted out. */ + if (fmt->b == 2 + && int_mode_for_mode (mode).exists (&imode) + && fmt->signbit_rw == fmt->signbit_ro + && fmt->signbit_rw == (int) GET_MODE_PRECISION (imode) - 1) + { + itype = lang_hooks.types.type_for_mode (imode, 1); + if (itype && TYPE_PRECISION (itype) != GET_MODE_PRECISION (imode)) + itype = NULL_TREE; + } + + if (isnan_fn && isinf_fn && isnormal_fn && itype) + { + arg = builtin_save_expr (arg); + + /* Shifting the sign bit out leaves zero iff ARG is +-0. */ + tmp = fold_build1_loc (loc, VIEW_CONVERT_EXPR, itype, arg); + tmp = fold_build2_loc (loc, LSHIFT_EXPR, itype, tmp, + build_int_cst (integer_type_node, 1)); + tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, tmp, + build_int_cst (itype, 0)); + res = fold_build3_loc (loc, COND_EXPR, integer_type_node, + tmp, fp_zero, fp_subnormal); + + tmp = build_call_expr_loc (loc, isnormal_fn, 1, arg); + tmp = fold_build2_loc (loc, NE_EXPR, integer_type_node, tmp, + integer_zero_node); + res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, + fp_normal, res); + + if (tree_expr_maybe_infinite_p (arg)) + { + tmp = build_call_expr_loc (loc, isinf_fn, 1, arg); + tmp = fold_build2_loc (loc, NE_EXPR, integer_type_node, tmp, + integer_zero_node); + res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, + fp_infinite, res); + } + + if (tree_expr_maybe_nan_p (arg)) + { + tmp = build_call_expr_loc (loc, isnan_fn, 1, arg); + tmp = fold_build2_loc (loc, NE_EXPR, integer_type_node, tmp, + integer_zero_node); + res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, + fp_nan, res); + } + + return res; + } + } + arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg)); /* fpclassify(x) -> diff --git a/gcc/testsuite/gcc.target/aarch64/pr66462-2.c b/gcc/testsuite/gcc.target/aarch64/pr66462-2.c new file mode 100644 index 000000000000..6a2cb559fdb5 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/pr66462-2.c @@ -0,0 +1,91 @@ +/* { dg-do run } */ +/* { dg-options "-O2 -fsignaling-nans -fno-inline" } */ +/* { dg-require-effective-target fenv_exceptions } */ + +/* With -fsignaling-nans the isnan, isinf and isnormal optabs are all + available, so __builtin_fpclassify must be built on them rather than on + FP comparisons, which raise FE_INVALID for a signaling NaN. */ + +#include + +enum { NAN_, INF_, NORMAL_, SUBNORMAL_, ZERO_ }; + +static void t_fpclassf (float x, int res) +{ + if (__builtin_fpclassify (NAN_, INF_, NORMAL_, SUBNORMAL_, ZERO_, x) != res) + __builtin_abort (); + if (__builtin_fpclassify (NAN_, INF_, NORMAL_, SUBNORMAL_, ZERO_, -x) != res) + __builtin_abort (); + if (fetestexcept (FE_INVALID)) + __builtin_abort (); +} + +static void t_fpclass (double x, int res) +{ + if (__builtin_fpclassify (NAN_, INF_, NORMAL_, SUBNORMAL_, ZERO_, x) != res) + __builtin_abort (); + if (__builtin_fpclassify (NAN_, INF_, NORMAL_, SUBNORMAL_, ZERO_, -x) != res) + __builtin_abort (); + if (fetestexcept (FE_INVALID)) + __builtin_abort (); +} + +#define DEF_TEST(NAME, TYPE) \ +static void NAME (TYPE x, int res) \ +{ \ + if (__builtin_fpclassify (NAN_, INF_, NORMAL_, SUBNORMAL_, ZERO_, x) \ + != res) \ + __builtin_abort (); \ + if (__builtin_fpclassify (NAN_, INF_, NORMAL_, SUBNORMAL_, ZERO_, -x) \ + != res) \ + __builtin_abort (); \ + if (fetestexcept (FE_INVALID)) \ + __builtin_abort (); \ +} + +DEF_TEST (t_fpclass16, _Float16) +DEF_TEST (t_fpclassbf, __bf16) + +int +main () +{ + feclearexcept (FE_INVALID); + + t_fpclassf (0.0f, ZERO_); + t_fpclassf (1.0f, NORMAL_); + t_fpclassf (__FLT_MIN__, NORMAL_); + t_fpclassf (__FLT_MAX__, NORMAL_); + t_fpclassf (__FLT_DENORM_MIN__, SUBNORMAL_); + t_fpclassf (__builtin_inff (), INF_); + t_fpclassf (__builtin_nansf (""), NAN_); + t_fpclassf (__builtin_nanf (""), NAN_); + + t_fpclass (0.0, ZERO_); + t_fpclass (1.0, NORMAL_); + t_fpclass (__DBL_MIN__, NORMAL_); + t_fpclass (__DBL_MAX__, NORMAL_); + t_fpclass (__DBL_DENORM_MIN__, SUBNORMAL_); + t_fpclass (__builtin_inf (), INF_); + t_fpclass (__builtin_nans (""), NAN_); + t_fpclass (__builtin_nan (""), NAN_); + + t_fpclass16 (0.0f16, ZERO_); + t_fpclass16 (1.0f16, NORMAL_); + t_fpclass16 (__FLT16_MIN__, NORMAL_); + t_fpclass16 (__FLT16_MAX__, NORMAL_); + t_fpclass16 (__FLT16_DENORM_MIN__, SUBNORMAL_); + t_fpclass16 ((_Float16) __builtin_inff (), INF_); + t_fpclass16 (__builtin_nansf16 (""), NAN_); + t_fpclass16 (__builtin_nanf16 (""), NAN_); + + t_fpclassbf (0.0bf16, ZERO_); + t_fpclassbf (1.0bf16, NORMAL_); + t_fpclassbf (__BFLT16_MIN__, NORMAL_); + t_fpclassbf (__BFLT16_MAX__, NORMAL_); + t_fpclassbf (__BFLT16_DENORM_MIN__, SUBNORMAL_); + t_fpclassbf ((__bf16) __builtin_inff (), INF_); + t_fpclassbf (__builtin_nansf16b (""), NAN_); + t_fpclassbf ((__bf16) __builtin_nanf (""), NAN_); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/alpha/fp-classify-5.c b/gcc/testsuite/gcc.target/alpha/fp-classify-5.c new file mode 100644 index 000000000000..d47bb716ee7d --- /dev/null +++ b/gcc/testsuite/gcc.target/alpha/fp-classify-5.c @@ -0,0 +1,20 @@ +/* __builtin_fpclassify must not be expanded into FP comparisons either: a + comparison cannot tell FP_SUBNORMAL from FP_ZERO when the subnormal + operand is flushed to zero, and traps when it is not. */ + +/* { dg-do compile } */ +/* { dg-options "-O2" } */ + +int +fpclassify_f (float x) +{ + return __builtin_fpclassify (0, 1, 4, 3, 2, x); +} + +int +fpclassify_d (double x) +{ + return __builtin_fpclassify (0, 1, 4, 3, 2, x); +} + +/* { dg-final { scan-assembler-not "\tcmpt" } } */ diff --git a/gcc/testsuite/gcc.target/alpha/fp-classify-6.c b/gcc/testsuite/gcc.target/alpha/fp-classify-6.c new file mode 100644 index 000000000000..45812b2357e6 --- /dev/null +++ b/gcc/testsuite/gcc.target/alpha/fp-classify-6.c @@ -0,0 +1,55 @@ +/* Without -mieee __builtin_fpclassify must classify subnormals, infinities + and NaNs correctly, without trapping. */ + +/* { dg-do run } */ +/* { dg-options "-O2 -fno-inline" } */ + +enum { NAN_, INF_, NORMAL_, SUBNORMAL_, ZERO_ }; + +static void +t_f (float x, int class) +{ + if (__builtin_fpclassify (NAN_, INF_, NORMAL_, SUBNORMAL_, ZERO_, x) + != class) + __builtin_abort (); +} + +static void +t_d (double x, int class) +{ + if (__builtin_fpclassify (NAN_, INF_, NORMAL_, SUBNORMAL_, ZERO_, x) + != class) + __builtin_abort (); +} + +/* Keep the operands away from the constant folders. */ +volatile float vf[] = { + 0.0f, -0.0f, 1.0f, -1.0f, __FLT_MIN__, __FLT_MAX__, -__FLT_MAX__, + __FLT_DENORM_MIN__, -__FLT_DENORM_MIN__, __FLT_MIN__ / 2, + __builtin_inff (), -__builtin_inff (), __builtin_nanf (""), + -__builtin_nanf ("") +}; + +volatile double vd[] = { + 0.0, -0.0, 1.0, -1.0, __DBL_MIN__, __DBL_MAX__, -__DBL_MAX__, + __DBL_DENORM_MIN__, -__DBL_DENORM_MIN__, __DBL_MIN__ / 2, + __builtin_inf (), -__builtin_inf (), __builtin_nan (""), + -__builtin_nan ("") +}; + +const int classes[] = { + ZERO_, ZERO_, NORMAL_, NORMAL_, NORMAL_, NORMAL_, NORMAL_, + SUBNORMAL_, SUBNORMAL_, SUBNORMAL_, + INF_, INF_, NAN_, NAN_ +}; + +int +main () +{ + for (unsigned i = 0; i < sizeof classes / sizeof classes[0]; i++) + { + t_f (vf[i], classes[i]); + t_d (vd[i], classes[i]); + } + return 0; +} From 560cbc9c348309359512b8de64116dc26204f9e1 Mon Sep 17 00:00:00 2001 From: Mikael Morin Date: Mon, 21 Sep 2026 16:51:52 +0200 Subject: [PATCH 293/584] fortran: Dereference elements of span-addressed character arrays The final step of gfc_build_spanned_array_ref after determining the pointer to the array element is generating a dereference of the pointer to access the actual data. There was an exception that omitted that dereference if the pointer target type had the string flag set. Remove the exception and always dereference the pointer. Because of the exception, the resulting type was different between a regular array reference and a span-based pointer arithmetics access, in the character case. This could cause regressions when changing between the two array access ways, as code downstream could get an expression that didn't match its expectations. The non-dereferenced pointer returned by gfc_build_spanned_array_ref was causing gfc_get_data_ptr_offset to have its own dereference, to fix it after the fact. That's now redundant; remove it as well. gcc/fortran/ChangeLog: * trans.cc (gfc_build_spanned_array_ref): Remove condition guarding pointer dereference generation. * trans-array.cc (gfc_get_dataptr_offset): Remove now redundant pointer dereference generation. --- gcc/fortran/trans-array.cc | 4 ---- gcc/fortran/trans.cc | 4 +--- 2 files changed, 1 insertion(+), 7 deletions(-) diff --git a/gcc/fortran/trans-array.cc b/gcc/fortran/trans-array.cc index bbd50aa2ab47..9f60a72a3941 100644 --- a/gcc/fortran/trans-array.cc +++ b/gcc/fortran/trans-array.cc @@ -7738,10 +7738,6 @@ gfc_get_dataptr_offset (stmtblock_t *block, tree parm, tree desc, tree offset, to reference an element. */ tmp = build_array_ref (desc, offset, span_addressed_array (desc), NULL); - /* A spanned character element is referenced by a pointer. */ - if (POINTER_TYPE_P (TREE_TYPE (tmp)) && span_addressed_array (desc)) - tmp = build_fold_indirect_ref_loc (input_location, tmp); - /* Offset the data pointer for pointer assignments from arrays with subreferences; e.g. my_integer => my_type(:)%integer_component. */ if (subref) diff --git a/gcc/fortran/trans.cc b/gcc/fortran/trans.cc index b98fe0c680fb..2730ebf62c3d 100644 --- a/gcc/fortran/trans.cc +++ b/gcc/fortran/trans.cc @@ -498,9 +498,7 @@ gfc_build_spanned_array_ref (tree base, tree offset, tree span) tmp = gfc_build_addr_expr (pvoid_type_node, base); tmp = fold_build_pointer_plus_loc (input_location, tmp, offset); tmp = fold_convert (build_pointer_type (type), tmp); - if ((TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != ARRAY_TYPE) - || !TYPE_STRING_FLAG (type)) - tmp = build_fold_indirect_ref_loc (input_location, tmp); + tmp = build_fold_indirect_ref_loc (input_location, tmp); return tmp; } From 44584e6be021d9c5e25de9984182f03bba22eae8 Mon Sep 17 00:00:00 2001 From: Mikael Morin Date: Mon, 21 Sep 2026 16:51:56 +0200 Subject: [PATCH 294/584] fortran: Make span_addressed_array return a boolean The function span_addressed_array can return two values: either NULL_TREE or its argument, and is used in bool conversion contexts everywhere except in one single place. Separate the predicate from the choice between NULL_TREE and the argument in that single place and make the function return a boolean. gcc/fortran/ChangeLog: * trans-array.cc (span_addressed_array): Change return type to bool and rename to ... (is_span_addressed_array): ... this. (gfc_get_dataptr_offset): Separate the predicate from the choice between NULL_TREE and the input array. (gfc_get_array_span, gfc_conv_scalarized_array_ref, gfc_conv_array_ref): Update callers. --- gcc/fortran/trans-array.cc | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/gcc/fortran/trans-array.cc b/gcc/fortran/trans-array.cc index 9f60a72a3941..dd2ee7a53e96 100644 --- a/gcc/fortran/trans-array.cc +++ b/gcc/fortran/trans-array.cc @@ -497,11 +497,11 @@ is_pointer_array (tree expr) either a descriptor or the local decl of a descriptorless dummy array, which keeps the descriptor it was built from as the saved one. */ -static tree -span_addressed_array (tree expr) +static bool +is_span_addressed_array (tree expr) { if (is_pointer_array (expr)) - return expr; + return true; if (VAR_P (expr) && GFC_DECL_PTR_ARRAY_P (expr) @@ -509,9 +509,9 @@ span_addressed_array (tree expr) && GFC_ARRAY_TYPE_P (TREE_TYPE (expr)) && DECL_LANG_SPECIFIC (expr) && GFC_DECL_SAVED_DESCRIPTOR (expr)) - return expr; + return true; - return NULL_TREE; + return false; } @@ -658,7 +658,7 @@ gfc_get_array_span (tree desc, gfc_expr *expr) if (tree span = GFC_DECL_GET_SPAN (desc)) /* A span addressed dummy loaded its span on entry. */ tmp = span; - else if (span_addressed_array (desc) + else if (is_span_addressed_array (desc) || (get_CFI_desc (NULL, expr, &desc, NULL) && (POINTER_TYPE_P (TREE_TYPE (desc)) ? GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (TREE_TYPE (desc))) @@ -4063,7 +4063,7 @@ gfc_conv_scalarized_array_ref (gfc_se * se, gfc_array_ref * ar, /* A pointer array component can be detected from its field decl. Fix the descriptor, mark the resulting variable decl and pass it to gfc_build_array_ref. */ - if (span_addressed_array (info->descriptor) + if (is_span_addressed_array (info->descriptor) || (expr && ((expr->ts.deferred && info->descriptor && GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (info->descriptor))) || (expr && gfc_expr_attr (expr).pdt_string)))) @@ -4317,7 +4317,7 @@ gfc_conv_array_ref (gfc_se * se, gfc_array_ref * ar, gfc_expr *expr, if (get_CFI_desc (sym, expr, &decl, ar)) decl = build_fold_indirect_ref_loc (input_location, decl); if (!expr->ts.deferred && !sym->attr.codimension - && span_addressed_array (se->expr)) + && is_span_addressed_array (se->expr)) { if (INDIRECT_REF_P (se->expr)) decl = TREE_OPERAND (se->expr, 0); @@ -7736,7 +7736,8 @@ gfc_get_dataptr_offset (stmtblock_t *block, tree parm, tree desc, tree offset, /* An array whose elements are spaced by the span needs pointer arithmetic to reference an element. */ - tmp = build_array_ref (desc, offset, span_addressed_array (desc), NULL); + tree decl = is_span_addressed_array (desc) ? desc : NULL_TREE; + tmp = build_array_ref (desc, offset, decl, NULL); /* Offset the data pointer for pointer assignments from arrays with subreferences; e.g. my_integer => my_type(:)%integer_component. */ From df10305c11ffc29f62844c85929c6876afd411ab Mon Sep 17 00:00:00 2001 From: Mikael Morin Date: Mon, 21 Sep 2026 16:52:01 +0200 Subject: [PATCH 295/584] fortran: Guess decl for span from within array ref construction Move guess of decl for span from build_array_ref argument to within build_array_ref. When its input array is to be accessed using span addressing, the function gfc_get_dataptr_offset sets the input array as decl argument to build_array_ref, so that the span can be guessed from it. With a later change extending span addressing to more arrays, the value provided as decl argument prevents code in build_array_ref to guess a (better) default decl value, causing a regression. This change moves what was as argument to the function body after the existing default decl guess, and passes NULL_TREE as argument, so that in the function the default guess prevails, and if no decl is guessed, the decl for a span-addressed array is the array itself as before. gcc/fortran/ChangeLog: * trans-array.cc (gfc_get_dataptr_offset): Move guess of decl for span from function argument... (build_array_ref): ... to function body. Only set the decl if it was empty on input and wasn't set by a previous guess. --- gcc/fortran/trans-array.cc | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/gcc/fortran/trans-array.cc b/gcc/fortran/trans-array.cc index dd2ee7a53e96..abf6f907f05e 100644 --- a/gcc/fortran/trans-array.cc +++ b/gcc/fortran/trans-array.cc @@ -4151,6 +4151,10 @@ build_array_ref (tree desc, tree offset, tree decl, tree vptr) } } + if (decl == NULL_TREE + && is_span_addressed_array (desc)) + decl = desc; + tmp = gfc_conv_array_data (desc); tmp = build_fold_indirect_ref_loc (input_location, tmp); tmp = gfc_build_array_ref (tmp, offset, decl, @@ -7736,8 +7740,7 @@ gfc_get_dataptr_offset (stmtblock_t *block, tree parm, tree desc, tree offset, /* An array whose elements are spaced by the span needs pointer arithmetic to reference an element. */ - tree decl = is_span_addressed_array (desc) ? desc : NULL_TREE; - tmp = build_array_ref (desc, offset, decl, NULL); + tmp = build_array_ref (desc, offset, NULL, NULL); /* Offset the data pointer for pointer assignments from arrays with subreferences; e.g. my_integer => my_type(:)%integer_component. */ From a9299f6c4076d25c38e050c455454b54cfaa9dd3 Mon Sep 17 00:00:00 2001 From: Mikael Morin Date: Mon, 21 Sep 2026 16:52:05 +0200 Subject: [PATCH 296/584] fortran: Copy the span from the target descriptor in pointer assignments [PR127448] Mark the _data field of array pointer class containers with the GFC_DECL_PTR_ARRAY_P flag, so that in pointer assignments, the span assigned to the array descriptor is copied from the target descriptor span instead of the class container size. Before this change, it was assumed that the size taken from the class container was the correct span value. This was supposing all polymorphic arrays to be contiguous, which is not the case for a polymorphic pointer whose target is a parent object of an extended derived type object. The change tries to keep the current behaviour if possible, that is use the size from the class container if the array is known to be contiguous. I doubt the information is properly propagated everywhere, but it should be conservatively correct. The is_pointer_array hunk removes a condition that is redundant: the type of the operand 1 of a component ref is the type of the field, which is also the type of the component ref itself, which has already been checked before. I suspect the condition to be a typo and should check operand 0 of the component ref. If that was the case, this patch would remove it anyway. PR fortran/127448 gcc/fortran/ChangeLog: * trans-array.cc (is_pointer_array): Remove redundant condition. (is_span_addressed_array): For polymorphic arrays, return false if the array is known to be contiguous. * trans-types.cc (gfc_get_derived_type): Also set the GFC_DECL_PTR_ARRAY_P flag for _data fields of class containers corresponding to polymorphic array pointers. gcc/testsuite/ChangeLog: * gfortran.dg/pointer_assign_17.f90: New test. --- gcc/fortran/trans-array.cc | 28 +++++++- gcc/fortran/trans-types.cc | 5 +- .../gfortran.dg/pointer_assign_17.f90 | 65 +++++++++++++++++++ 3 files changed, 93 insertions(+), 5 deletions(-) create mode 100644 gcc/testsuite/gfortran.dg/pointer_assign_17.f90 diff --git a/gcc/fortran/trans-array.cc b/gcc/fortran/trans-array.cc index abf6f907f05e..abc606dc627f 100644 --- a/gcc/fortran/trans-array.cc +++ b/gcc/fortran/trans-array.cc @@ -484,8 +484,7 @@ is_pointer_array (tree expr) /* The field declaration is marked as a pointer array. */ if (TREE_CODE (expr) == COMPONENT_REF - && GFC_DECL_PTR_ARRAY_P (TREE_OPERAND (expr, 1)) - && !GFC_CLASS_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 1)))) + && GFC_DECL_PTR_ARRAY_P (TREE_OPERAND (expr, 1))) return true; return false; @@ -501,7 +500,30 @@ static bool is_span_addressed_array (tree expr) { if (is_pointer_array (expr)) - return true; + { + /* For classes, index arrays using the size from the virtual pointer if + the array is contiguous. Otherwise use the span. */ + if (TREE_CODE (expr) == COMPONENT_REF + && GFC_CLASS_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 0))) + && TYPE_LANG_SPECIFIC (TREE_TYPE (expr))) + { + switch (GFC_TYPE_ARRAY_AKIND (TREE_TYPE (expr))) + { + case GFC_ARRAY_ASSUMED_SHAPE_CONT: + case GFC_ARRAY_ASSUMED_RANK_CONT: + case GFC_ARRAY_ASSUMED_RANK_ALLOCATABLE: + case GFC_ARRAY_ASSUMED_RANK_POINTER_CONT: + case GFC_ARRAY_ALLOCATABLE: + case GFC_ARRAY_POINTER_CONT: + return false; + + default: + break; + } + } + + return true; + } if (VAR_P (expr) && GFC_DECL_PTR_ARRAY_P (expr) diff --git a/gcc/fortran/trans-types.cc b/gcc/fortran/trans-types.cc index ef80cd8feabb..3675f0932535 100644 --- a/gcc/fortran/trans-types.cc +++ b/gcc/fortran/trans-types.cc @@ -3167,8 +3167,9 @@ gfc_get_derived_type (gfc_symbol * derived, int codimen) if (class_coarray_flag || !c->backend_decl || c->attr.caf_token) c->backend_decl = field; - if (c->attr.pointer && (c->attr.dimension || c->attr.codimension) - && !(c->ts.type == BT_DERIVED && strcmp (c->name, "_data") == 0)) + if ((c->attr.dimension || c->attr.codimension) + && ((derived->attr.is_class && c->attr.class_pointer) + || (!derived->attr.is_class && c->attr.pointer))) GFC_DECL_PTR_ARRAY_P (c->backend_decl) = 1; } diff --git a/gcc/testsuite/gfortran.dg/pointer_assign_17.f90 b/gcc/testsuite/gfortran.dg/pointer_assign_17.f90 new file mode 100644 index 000000000000..a3fc3e2ff47e --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pointer_assign_17.f90 @@ -0,0 +1,65 @@ +! { dg-do run } +! +! PR fortran/127448 +! Check the span set in array pointer assignments. +! For class pointers, the size from the class container was always +! used as span, which caused problems when the pointer was pointing +! to a parent subobject of an extended derived type entity. + +program prog + implicit none + integer, parameter :: k = 2 + integer, parameter :: n = 5 + type :: t1 + integer(kind=k) :: c1, c2 + end type + type, extends(t1) :: t2 + integer(kind=k) :: c3 + end type + type(t2), target :: x(n) + class(t1), pointer :: y1(:), z1(:) + class(t2), pointer :: y2(:) + type(t1), pointer :: p1(:), q1(:) + integer :: i + x = [ (t2(i*i, 2*i*i+1, i), i=1,n) ] + y2 => x + y1 => x + call check_t1(y1, 12) + z1 => y2 + call check_t1(z1, 13) + z1 => y1 + call check_t1(z1, 14) + call check_t1(x%t1, 21) + call check_t1(y2%t1, 22) + y1 => x%t1 + call check_t1(y1, 23) + z1 => y2%t1 + call check_t1(z1, 24) + z1 => y1 + call check_t1(z1, 25) + p1 => x%t1 + call check_t1(p1, 41) + p1 => y2%t1 + call check_t1(p1, 42) + p1 => y1 + call check_t1(p1, 43) + q1 => p1 + call check_t1(q1, 44) +contains + subroutine check_t1(arg, f) + type(t1), target, intent(in) :: arg(:) + integer, intent(in) :: f + call check_int(arg%c1, [1, 4, 9, 16, 25], f*10+1) + call check_int(arg%c2, [3, 9, 19, 33, 51], f*10+2) + end subroutine + subroutine check_int(arg, e, f) + integer(kind=k), intent(in) :: arg(:) + integer, intent(in) :: e(:), f + integer :: i + if (size(arg, 1) /= size(e, 1)) error stop f*10+1 + !do i=1,size(arg) + ! print *, f*10+i, (arg(i) == e(i) ? "PASS" : "FAIL"), arg(i), e(i) + !end do + if (any(arg /= e)) error stop f*10+2 + end subroutine +end program From 31c55fb3309b3d64a95b3581b3af4153b6e1746b Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Fri, 18 Sep 2026 22:34:55 +0200 Subject: [PATCH 297/584] cobol: Remove stale include dir logic from gcobc These heuristics were applied from a time MF compatibility was still in its infancy, when the directory tree structure for the copybooks was not decided yet. Nowadays, cobol1.cc already includes the relevant directories to the copybooks, so that they can be made available to the user via COPY. gcc/cobol/ChangeLog: * gcobc: Remove stale logic. --- gcc/cobol/gcobc | 25 ------------------------- 1 file changed, 25 deletions(-) diff --git a/gcc/cobol/gcobc b/gcc/cobol/gcobc index 6e0741cd61fa..447323b75902 100755 --- a/gcc/cobol/gcobc +++ b/gcc/cobol/gcobc @@ -86,31 +86,6 @@ then copydir="-I$COB_COPY_DIR" fi -# TODO: this file likely needs to query gcobol for its shared path instead -udf_default="${0%/*}/../share/gcobol/udf" -if [ ! -d "$udfdir" ] -then - # the one above is the installed one from the packages this one was previously used - udf_default="${0%/*}/../share/cobol/udf" -fi -udfdir="${GCOBCUDF:-$udf_default}" - -if [ -d "$udfdir" ] -then - for F in "$udfdir"/* - do - if [ -f "$F" ] - then - includes="$includes -include $F " - fi - done -else - if [ "${GCOBCUDF:-none}" != "none" ] - then - echo warning: no such directory: "'$GCOBCUDF'" - fi -fi - exit_status=0 skip_arg= opts="$copydir $includes" From a537bc1e639fe330a2b28dd5ef233e08a9759db2 Mon Sep 17 00:00:00 2001 From: "James K. Lowden" Date: Mon, 21 Sep 2026 09:43:16 -0400 Subject: [PATCH 298/584] cobol: Remove unused passby_str. Function was already made redundant by cbl_ffi_crv_str. gcc/cobol/ChangeLog: * parse.y: Remove unused function. --- gcc/cobol/parse.y | 21 --------------------- 1 file changed, 21 deletions(-) diff --git a/gcc/cobol/parse.y b/gcc/cobol/parse.y index 575a27276009..2de650c70b85 100644 --- a/gcc/cobol/parse.y +++ b/gcc/cobol/parse.y @@ -13066,27 +13066,6 @@ bad_arg( const char name[], return ok; } -#if 0 -static const char * -passby_str(int mask) -{ - switch( mask ) { - case by_default_e: - case by_reference_e: - return "BY REFERENCE"; - case by_content_e: - return "BY CONTENT"; - case by_value_e: - return "BY VALUE"; - default: - break; - } - - return "UNKNOWN PASSING METHOD"; -} -#endif - - // Verify provided actual parameters against formals. static void verify_args( const YYLTYPE& loc, From 2aab5af1738b3adc2e673977b4cd0d5c393b4252 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tomasz=20Kami=C5=84ski?= Date: Tue, 28 Jul 2026 09:18:45 +0200 Subject: [PATCH 299/584] libstdc++: Expand use of Lemire's algorithm to all generators emitting power of two range. This patch applies the Lemire's algorithm to all generators that emit values in range which size is power of two (2^_Bits), instead only 2^32 and 2^64. This is achieved by masking the result of conversion of __product to lowest _Bits. If _Bits is equal to bitwidth of _Up type, the bitand with all set mask is optimized out by compilers. libstdc++-v3/ChangeLog: * include/bits/uniform_int_dist.h (uniform_int_distribution::operator()): Use _S_nd (Lemire's algorithm) if __urngrange is power of two. (uniform_int_distribution::_S_nd): Add _Bits parameter. Mask the result of conversion of __product to _Up to lowest _Bits. * testsuite/26_numerics/random/uniform_int_distribution/operators/values.cc: Add testDiscreteDist for ranlux24 and ranlux48 engines. Reviewed-by: Jonathan Wakely --- libstdc++-v3/include/bits/uniform_int_dist.h | 48 ++++++++++--------- .../operators/values.cc | 24 ++++++---- 2 files changed, 41 insertions(+), 31 deletions(-) diff --git a/libstdc++-v3/include/bits/uniform_int_dist.h b/libstdc++-v3/include/bits/uniform_int_dist.h index 5ee9945b61cc..f19f051b8052 100644 --- a/libstdc++-v3/include/bits/uniform_int_dist.h +++ b/libstdc++-v3/include/bits/uniform_int_dist.h @@ -252,7 +252,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Lemire's nearly divisionless algorithm. // Returns an unbiased random number from __g downscaled to [0,__range) // using an unsigned type _Wp twice as wide as unsigned type _Up. - template + template static _Up _S_nd(_Urbg& __g, _Up __range) { @@ -263,33 +263,35 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static_assert(_Wp_traits::__digits == (2 * _Up_traits::__digits), "W must be twice as wide as U"); constexpr auto __min = _Urbg::min(); + constexpr _Up __mask = (_Bits < _Up_traits::__digits) + ? (_Up(1) << _Bits) - 1 : ~_Up(0); // reference: Fast Random Integer Generation in an Interval // ACM Transactions on Modeling and Computer Simulation 29 (1), 2019 // https://arxiv.org/abs/1805.10941 _Wp __product = _Wp(__g() - __min) * _Wp(__range); - _Up __low = _Up(__product); + _Up __low = _Up(__product) & __mask; if (__low < __range) { const _Up __threshold = -__range % __range; while (__low < __threshold) { - __product = _Wp(__g() - __min) * _Wp(__range); - __low = _Up(__product); + __product = _Wp(__g() - __min) * _Wp(__range); + __low = _Up(__product) & __mask; // The algorithm is modified to alternate between rejecting // from the beginning and end of the range. This guarantees // that we stop for non-uniform engines that always result // in values below the __threshold. - const _Up __back_treshold = _Up_traits::__max - __threshold; - if (__low <= __back_treshold) + const _Up __back_threshold = __mask - __threshold; + if (__low <= __back_threshold) break; __product = _Wp(__g() - __min) * _Wp(__range); - __low = _Up(__product); + __low = _Up(__product) & __mask; } } - return __product >> _Up_traits::__digits; + return _Up(__product >> _Bits) & __mask; } }; @@ -322,25 +324,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" // if constexpr -#if defined __UINT64_TYPE__ && defined __UINT32_TYPE__ -#if __SIZEOF_INT128__ - if constexpr (__urngrange == __UINT64_MAX__) +#if defined __UINT64_TYPE__ && defined __UINT32_TYPE__ && __has_builtin(__builtin_popcountg) + constexpr auto __bits = __builtin_popcountg(__urngrange); + if constexpr (__detail::_Power_of_2(__urngrange + 1) && __bits <= 32) { - // __urng produces values that use exactly 64-bits, - // so use 128-bit integers to downscale to desired range. - __UINT64_TYPE__ __u64erange = __uerange; - __ret = __extension__ _S_nd(__urng, - __u64erange); - } - else -#endif - if constexpr (__urngrange == __UINT32_MAX__) - { - // __urng produces values that use exactly 32-bits, + // __urng produces values that use no more than 32-bits, // so use 64-bit integers to downscale to desired range. __UINT32_TYPE__ __u32erange = __uerange; - __ret = _S_nd<__UINT64_TYPE__>(__urng, __u32erange); + __ret = _S_nd<__bits, __UINT64_TYPE__>(__urng, __u32erange); + } +# if __SIZEOF_INT128__ + else if constexpr (__detail::_Power_of_2(__urngrange + 1) && __bits <= 64) + { + // __urng produces values that use no more than 64-bits, + // so use 128-bit integers to downscale to desired range. + __UINT64_TYPE__ __u64erange = __uerange; + __ret = __extension__ _S_nd<__bits, unsigned __int128>( + __urng, __u64erange); } +# endif else #endif { diff --git a/libstdc++-v3/testsuite/26_numerics/random/uniform_int_distribution/operators/values.cc b/libstdc++-v3/testsuite/26_numerics/random/uniform_int_distribution/operators/values.cc index fce14944d884..ebb02aa49123 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/uniform_int_distribution/operators/values.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/uniform_int_distribution/operators/values.cc @@ -50,27 +50,35 @@ void test01() { using namespace __gnu_test; - std::mt19937 eng; + std::mt19937 mteng; std::uniform_int_distribution<> uid1(0, 2); - auto buid1 = std::bind(uid1, eng); + auto buid1 = std::bind(uid1, mteng); testDiscreteDist(buid1, [](int n) { return uniform_int_pdf(n, 0, 2); } ); std::uniform_int_distribution<> uid2(3, 7); - auto buid2 = std::bind(uid2, eng); + auto buid2 = std::bind(uid2, mteng); testDiscreteDist(buid2, [](int n) { return uniform_int_pdf(n, 3, 7); } ); std::uniform_int_distribution<> uid3(1, 20); - auto buid3 = std::bind(uid3, eng); + auto buid3 = std::bind(uid3, mteng); testDiscreteDist(buid3, [](int n) { return uniform_int_pdf(n, 1, 20); } ); - shifted<(std::uint64_t(1) << 16)> s16e; - auto buid4 = std::bind(uid3, s16e); + std::ranlux24 r24eng; + auto buid4 = std::bind(uid3, r24eng); testDiscreteDist(buid4, [](int n) { return uniform_int_pdf(n, 1, 20); } ); - shifted<(std::uint64_t(1) << 32)> s32e; - auto buid5 = std::bind(uid3, s32e); + std::ranlux48 r48eng; + auto buid5 = std::bind(uid3, r48eng); testDiscreteDist(buid5, [](int n) { return uniform_int_pdf(n, 1, 20); } ); + + shifted<(std::uint64_t(1) << 16)> s16e; + auto buid6 = std::bind(uid3, s16e); + testDiscreteDist(buid6, [](int n) { return uniform_int_pdf(n, 1, 20); } ); + + shifted<(std::uint64_t(1) << 32)> s32e; + auto buid7 = std::bind(uid3, s32e); + testDiscreteDist(buid7, [](int n) { return uniform_int_pdf(n, 1, 20); } ); } int main() From 675b6856ca66366632598cb0f5ccedbb337ccc0b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tomasz=20Kami=C5=84ski?= Date: Tue, 28 Jul 2026 11:13:26 +0200 Subject: [PATCH 300/584] libstdc++: Use of Lemire's algorithm for targets that do not provide __UINT32_TYPE__ && __UINT64_TYPE__. As the implementation already mask lowest _Bits when converting __product to _Up, it works for any integer with at least _Bits, and no longer requires integers with exactly 32 (__UINT32_TYPE__) or 64 (__UINT64_TYPE__). The type _Up and _Wp are now defined in _Select_uint_least_t of _Bits and 2 * _Bits respectively. Thus primary _Select_uint_least_t primary template and partial specializations are now extracted to uniform_int_dist.h header. The measurments on x86_32 indicated that using Lemire algorithm with __rand_uint128 leads to worse performance, we only forward declared corresponding _Select_uint_least_t specialization in uniform_int_dist.h, and keep it definition (and __rand_uint128) in much larger bits/random.h header. libstdc++-v3/ChangeLog: * include/bits/random.h (_Select_uint_least_t): Move primary template and most of partial specializations to... * include/bits/uniform_int_dist.h (_Select_uint_least_t): Extracted from bits/random.h. (uniform_int_distribution::_S_nd): Replace _Up and _Wp template paramteters with Select_uint_least_t of _Bits and 2 * _Bits respectively. (uniform_int_distribution::operator()): Adjust calls to _S_nd to pass only _Bits, and remove checks for presence of __UINT64_TYPE__ and __UINT32_TYPE__ types. Reviewed-by: Jonathan Wakely --- libstdc++-v3/include/bits/random.h | 34 ++--------- libstdc++-v3/include/bits/uniform_int_dist.h | 61 +++++++++++++++----- 2 files changed, 51 insertions(+), 44 deletions(-) diff --git a/libstdc++-v3/include/bits/random.h b/libstdc++-v3/include/bits/random.h index 1a2900e2b9d8..e2b29961bd92 100644 --- a/libstdc++-v3/include/bits/random.h +++ b/libstdc++-v3/include/bits/random.h @@ -569,36 +569,10 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) struct _Shift<_UIntType, __w, true> { static constexpr _UIntType __value = _UIntType(1) << __w; }; - template - struct _Select_uint_least_t - { - static_assert(__which < 0, /* needs to be dependent */ - "sorry, would be too much trouble for a slow result"); - }; - - template - struct _Select_uint_least_t<__s, 4> - { using type = unsigned int; }; - - template - struct _Select_uint_least_t<__s, 3> - { using type = unsigned long; }; - - template - struct _Select_uint_least_t<__s, 2> - { using type = unsigned long long; }; - -#if __SIZEOF_INT128__ > __SIZEOF_LONG_LONG__ - template - struct _Select_uint_least_t<__s, 1> - { __extension__ using type = unsigned __int128; }; -#elif __has_builtin(__builtin_add_overflow) \ - && __has_builtin(__builtin_sub_overflow) \ +// Primary template and other specializtions are defined in bits/uniform_int_dist.h. +#if __SIZEOF_INT128__ <= __SIZEOF_LONG_LONG__ \ + && __has_builtin(__builtin_add_overflow) \ + && __has_builtin(__builtin_sub_overflow) \ && defined __UINT64_TYPE__ template struct _Select_uint_least_t<__s, 1> diff --git a/libstdc++-v3/include/bits/uniform_int_dist.h b/libstdc++-v3/include/bits/uniform_int_dist.h index f19f051b8052..554a82cd72ee 100644 --- a/libstdc++-v3/include/bits/uniform_int_dist.h +++ b/libstdc++-v3/include/bits/uniform_int_dist.h @@ -72,6 +72,42 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { return ((__x - 1) & __x) == 0; } + + template + struct _Select_uint_least_t + { + static_assert(__which < 0, /* needs to be dependent */ + "sorry, would be too much trouble for a slow result"); + }; + + template + struct _Select_uint_least_t<__s, 4> + { using type = unsigned int; }; + + template + struct _Select_uint_least_t<__s, 3> + { using type = unsigned long; }; + + template + struct _Select_uint_least_t<__s, 2> + { using type = unsigned long long; }; + +// Alternate specialization for +#if __SIZEOF_INT128__ > __SIZEOF_LONG_LONG__ + template + struct _Select_uint_least_t<__s, 1> + { __extension__ using type = unsigned __int128; }; +#elif __has_builtin(__builtin_add_overflow) \ + && __has_builtin(__builtin_sub_overflow) \ + && defined __UINT64_TYPE__ + template + struct _Select_uint_least_t<__s, 1>; // Defined in bits/random.h +#endif } /// @endcond @@ -252,16 +288,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Lemire's nearly divisionless algorithm. // Returns an unbiased random number from __g downscaled to [0,__range) // using an unsigned type _Wp twice as wide as unsigned type _Up. - template - static _Up - _S_nd(_Urbg& __g, _Up __range) + template + static typename __detail::_Select_uint_least_t<_Bits>::type + _S_nd(_Urbg& __g, typename __detail::_Select_uint_least_t<_Bits>::type __range) { + using _Up = typename __detail::_Select_uint_least_t<_Bits>::type; + using _Wp = typename __detail::_Select_uint_least_t<2 * _Bits>::type; using _Up_traits = __gnu_cxx::__int_traits<_Up>; - using _Wp_traits = __gnu_cxx::__int_traits<_Wp>; - static_assert(!_Up_traits::__is_signed, "U must be unsigned"); - static_assert(!_Wp_traits::__is_signed, "W must be unsigned"); - static_assert(_Wp_traits::__digits == (2 * _Up_traits::__digits), - "W must be twice as wide as U"); + constexpr auto __min = _Urbg::min(); constexpr _Up __mask = (_Bits < _Up_traits::__digits) ? (_Up(1) << _Bits) - 1 : ~_Up(0); @@ -324,23 +358,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wc++17-extensions" // if constexpr -#if defined __UINT64_TYPE__ && defined __UINT32_TYPE__ && __has_builtin(__builtin_popcountg) +#if __has_builtin(__builtin_popcountg) constexpr auto __bits = __builtin_popcountg(__urngrange); if constexpr (__detail::_Power_of_2(__urngrange + 1) && __bits <= 32) { // __urng produces values that use no more than 32-bits, - // so use 64-bit integers to downscale to desired range. + // so 64-bit integer is sufficient to downscale to desired range. __UINT32_TYPE__ __u32erange = __uerange; - __ret = _S_nd<__bits, __UINT64_TYPE__>(__urng, __u32erange); + __ret = _S_nd<__bits>(__urng, __u32erange); } # if __SIZEOF_INT128__ else if constexpr (__detail::_Power_of_2(__urngrange + 1) && __bits <= 64) { // __urng produces values that use no more than 64-bits, - // so use 128-bit integers to downscale to desired range. + // so 128-bit integer is sufficient to downscale to desired range. __UINT64_TYPE__ __u64erange = __uerange; - __ret = __extension__ _S_nd<__bits, unsigned __int128>( - __urng, __u64erange); + __ret = _S_nd<__bits>(__urng, __u64erange); } # endif else From 092179f9bfbc2dcb2656b7e62e8ca344154d4cbd Mon Sep 17 00:00:00 2001 From: "Jose E. Marchesi" Date: Mon, 21 Sep 2026 16:17:48 +0200 Subject: [PATCH 301/584] a68: resolve mode equivalences when importing publicized identifiers Imported modes resulting from the extract of a revelation will not be reachable from any node in the parse tree. Instead, dummy nodes gets synthesized for what would have been the declaration of the identifiers having these modes, and installed in the symtab. The consequence of that is that compute_derived_modes will not process these mode references. When the imported mode is a standard mode that has an equivalent mode (such as SIZETY compl for example) then there is trouble because the mode equivalence code compares STANDARD modes by pointer. This patch fixes the problem by resolving equivalences in the imported modes. Signed-off-by: Jose E. Marchesi gcc/algol68/ChangeLog * a68-parser-modes.cc (a68_resolve_equivalent): Rename from resolve_equivalent and made global. (resolve_eq_members): Adapt calls to resolve_equivalent accordingly. (resolve_eq_tags): Likewise. (bind_modes): Likewise. (compute_derived_modes): Likewise. * a68.h: Add prototype for a68_resolve_equivalent. * a68-parser-extract.cc (a68_extract_revelation): Resolve equivalences in imported modes. gcc/testsuite/ChangeLog * algol68/execute/modules/program-28.a68: New test. * algol68/execute/modules/module28.a68: New file. --- gcc/algol68/a68-parser-extract.cc | 7 ++++ gcc/algol68/a68-parser-modes.cc | 36 +++++++++---------- gcc/algol68/a68.h | 2 +- .../algol68/execute/modules/module28.a68 | 7 ++++ .../algol68/execute/modules/program-28.a68 | 8 +++++ 5 files changed, 41 insertions(+), 19 deletions(-) create mode 100644 gcc/testsuite/algol68/execute/modules/module28.a68 create mode 100644 gcc/testsuite/algol68/execute/modules/program-28.a68 diff --git a/gcc/algol68/a68-parser-extract.cc b/gcc/algol68/a68-parser-extract.cc index fc1f318eaaf1..8d026fd569ac 100644 --- a/gcc/algol68/a68-parser-extract.cc +++ b/gcc/algol68/a68-parser-extract.cc @@ -341,9 +341,16 @@ a68_extract_revelation (NODE_T *q, const char *module, const char *filename, NCHAR_IN_LINE (n) = STRING (LINE (INFO (n))); TABLE (n) = TABLE (q); + /* It is necessary to resolve equivalences because the dummy declarer is + not in the parse tree and therefore it is not handled by the call to + computed_derived_modes in a68_make_moid_list. */ + a68_resolve_equivalent (&EXTRACT_MODE (e)); + + MOID (n) = EXTRACT_MODE (e); TAG_T *tag = a68_add_tag (TABLE (q), IDENTIFIER, n, EXTRACT_MODE (e), NORMAL_IDENTIFIER); gcc_assert (tag != NO_TAG); + EXTERN_SYMBOL (tag) = ggc_strdup (EXTRACT_SYMBOL (e)); VARIABLE (tag) = VARIABLE (e); IN_PROC (tag) = IN_PROC (e); diff --git a/gcc/algol68/a68-parser-modes.cc b/gcc/algol68/a68-parser-modes.cc index 9cbf4f962e41..19f8e7f5cbc8 100644 --- a/gcc/algol68/a68-parser-modes.cc +++ b/gcc/algol68/a68-parser-modes.cc @@ -87,8 +87,8 @@ a68_count_pack_members (PACK_T *u) /* Replace a mode by its equivalent mode. */ -static void -resolve_equivalent (MOID_T **m) +void +a68_resolve_equivalent (MOID_T **m) { while ((*m) != NO_MOID && EQUIVALENT ((*m)) != NO_MOID @@ -888,15 +888,15 @@ is_well_formed (MOID_T *def, MOID_T *z, bool yin, bool yang, int video) static void resolve_eq_members (MOID_T *q) { - resolve_equivalent (&SUB (q)); - resolve_equivalent (&DEFLEXED (q)); - resolve_equivalent (&MULTIPLE (q)); - resolve_equivalent (&NAME (q)); - resolve_equivalent (&SLICE (q)); - resolve_equivalent (&TRIM (q)); - resolve_equivalent (&ROWED (q)); + a68_resolve_equivalent (&SUB (q)); + a68_resolve_equivalent (&DEFLEXED (q)); + a68_resolve_equivalent (&MULTIPLE (q)); + a68_resolve_equivalent (&NAME (q)); + a68_resolve_equivalent (&SLICE (q)); + a68_resolve_equivalent (&TRIM (q)); + a68_resolve_equivalent (&ROWED (q)); for (PACK_T *p = PACK (q); p != NO_PACK; FORWARD (p)) - resolve_equivalent (&MOID (p)); + a68_resolve_equivalent (&MOID (p)); } /* Track equivalent tags. */ @@ -907,7 +907,7 @@ resolve_eq_tags (TAG_T *z) for (; z != NO_TAG; FORWARD (z)) { if (MOID (z) != NO_MOID) - resolve_equivalent (&MOID (z)); + a68_resolve_equivalent (&MOID (z)); } } @@ -918,7 +918,7 @@ bind_modes (NODE_T *p) { for (; p != NO_NODE; FORWARD (p)) { - resolve_equivalent (&MOID (p)); + a68_resolve_equivalent (&MOID (p)); if (SUB (p) != NO_NODE && a68_is_new_lexical_level (p)) { @@ -927,7 +927,7 @@ bind_modes (NODE_T *p) { if (NODE (z) != NO_NODE) { - resolve_equivalent (&MOID (NEXT_NEXT (NODE (z)))); + a68_resolve_equivalent (&MOID (NEXT_NEXT (NODE (z)))); MOID (z) = MOID (NEXT_NEXT (NODE (z))); MOID (NODE (z)) = MOID (z); } @@ -1181,11 +1181,11 @@ compute_derived_modes (MODULE_T *mod) resolve_eq_tags (INDICANTS (A68_STANDENV)); resolve_eq_tags (IDENTIFIERS (A68_STANDENV)); resolve_eq_tags (OPERATORS (A68_STANDENV)); - resolve_equivalent (&M_STRING); - resolve_equivalent (&M_COMPLEX); - resolve_equivalent (&M_LONG_COMPLEX); - resolve_equivalent (&M_LONG_LONG_COMPLEX); - resolve_equivalent (&M_SEMA); + a68_resolve_equivalent (&M_STRING); + a68_resolve_equivalent (&M_COMPLEX); + a68_resolve_equivalent (&M_LONG_COMPLEX); + a68_resolve_equivalent (&M_LONG_LONG_COMPLEX); + a68_resolve_equivalent (&M_SEMA); /* UNION members could be resolved. */ absorb_unions (TOP_MOID (mod)); contract_unions (TOP_MOID (mod)); diff --git a/gcc/algol68/a68.h b/gcc/algol68/a68.h index 16642c6e0bda..00b99075f272 100644 --- a/gcc/algol68/a68.h +++ b/gcc/algol68/a68.h @@ -440,8 +440,8 @@ PACK_T *a68_absorb_union_pack (PACK_T * u); void a68_add_mode_to_pack (PACK_T **p, MOID_T *m, const char *text, NODE_T *node); void a68_add_mode_to_pack_end (PACK_T **p, MOID_T *m, const char *text, NODE_T *node); void a68_make_moid_list (MODULE_T *mod); - void a68_renumber_moids (MOID_T *p, int n); +void a68_resolve_equivalent (MOID_T **m); /* a68-moids-to-string.cc */ diff --git a/gcc/testsuite/algol68/execute/modules/module28.a68 b/gcc/testsuite/algol68/execute/modules/module28.a68 new file mode 100644 index 000000000000..7c6644abb525 --- /dev/null +++ b/gcc/testsuite/algol68/execute/modules/module28.a68 @@ -0,0 +1,7 @@ +module Module28 = +def + pub compl c = 10.0; + pub long compl lc = long 20.0; + pub long long compl llc = long long 30.0; + skip +fed diff --git a/gcc/testsuite/algol68/execute/modules/program-28.a68 b/gcc/testsuite/algol68/execute/modules/program-28.a68 new file mode 100644 index 000000000000..e43eeedc1c8f --- /dev/null +++ b/gcc/testsuite/algol68/execute/modules/program-28.a68 @@ -0,0 +1,8 @@ +{ dg-modules "module28" } + +access Module28 +begin assert (IM c < 100.0 AND RE c > 0.0); + assert (IM lc < long 100.0 AND RE lc > long 0.0); + assert (IM llc < long long 100.0 AND RE llc > long long 0.0); + skip +end From 2cb78d1a0e5bd0d831690296df0bc35128ae009c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tomasz=20Kami=C5=84ski?= Date: Wed, 9 Sep 2026 09:55:18 +0200 Subject: [PATCH 302/584] libstdc++: Merge piecewise distributions configuration defines. [PR82749,PR125548] This patch introduces _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS that replaces a separate _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS (value 0) and _GLIBCXX_USE_RESULT_TYPE_FOR_PIECEWISE_DENSITIES (value 2). This better reflects their behavior, as they were not orthogonal previously as defining _GLIBCXX_USE_RESULT_TYPE_FOR_PIECEWISE_DENSITIES hand no effect if _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS was defined. libstdc++-v3/ChangeLog: PR libstdc++/82749 PR libstdc++/125548 * doc/xml/manual/using.xml (_GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS) (_GLIBCXX_USE_RESULT_TYPE_FOR_PIECEWISE_DENSITIES): Replace with... (_GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS): Add entry. * doc/html/manual/using_macros.html: Regenrate. * include/bits/c++config (_GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS) [__cplusplus >= 201103L]: Define to the value 1 if not already defined. * include/bits/random.h (__detail::__piecewise_distributions_storage) (__detail::__piecewise_distributions_storage_t): Adjust to depend on _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS value. (piecewise_constant_distribution::_CalcType) (piecewise_linear_distribution::_CalcType) (piecewise_constant_distribution::param_type::densities) (piecewise_linear_distribution::param_type::densities): Check for non-zero value of _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS instead of defintion of _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS and reorder branches. * include/bits/random.tcc (piecewise_constant_distribution::param_type::param_type) (piecewise_constant_distribution::param_type::param_type): Likewise. * testsuite/26_numerics/random/piecewise_constant_distribution/operators/accessors.cc: Replace checks for _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS _GLIBCXX_USE_RESULT_TYPE_FOR_PIECEWISE_DENSITIES defintions with checks of _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS values. * testsuite/26_numerics/random/piecewise_linear_distribution/operators/accessors.cc: Likewise. * testsuite/26_numerics/random/piecewise_linear_distribution/cons/pr125548.cc: Likewise. * testsuite/26_numerics/random/piecewise_constant_distribution/operators/accessors_fallback.cc: Replace -D_GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS with -D_GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS=0. * testsuite/26_numerics/random/piecewise_linear_distribution/operators/accessors_fallback.cc: Likewise. * testsuite/26_numerics/random/piecewise_linear_distribution/cons/pr125548_fallback.cc: Likewise. * testsuite/26_numerics/random/piecewise_constant_distribution/cons/input_type_fallback_neg.cc: Likewise. * testsuite/26_numerics/random/piecewise_linear_distribution/cons/input_type_fallback_neg.cc: Likewise. * testsuite/26_numerics/random/piecewise_constant_distribution/operators/accessors_exact.cc: Replace -D_GLIBCXX_USE_RESULT_TYPE_FOR_PIECEWISE_DENSITIES with -D_GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS=2. * testsuite/26_numerics/random/piecewise_linear_distribution/operators/accessors_exact.cc: Likewise. Reviewed-by: Jonathan Wakely --- .../doc/html/manual/using_macros.html | 35 +++++++------ libstdc++-v3/doc/xml/manual/using.xml | 38 +++++++------- libstdc++-v3/include/bits/c++config | 4 ++ libstdc++-v3/include/bits/random.h | 52 +++++++++---------- libstdc++-v3/include/bits/random.tcc | 18 +++---- .../cons/input_type_fallback_neg.cc | 2 +- .../operators/accessors.cc | 22 ++++---- .../operators/accessors_exact.cc | 2 +- .../operators/accessors_fallback.cc | 2 +- .../cons/input_type_fallback_neg.cc | 2 +- .../cons/pr125548.cc | 10 ++-- .../cons/pr125548_fallback.cc | 2 +- .../operators/accessors.cc | 24 ++++----- .../operators/accessors_exact.cc | 2 +- .../operators/accessors_fallback.cc | 2 +- 15 files changed, 111 insertions(+), 106 deletions(-) diff --git a/libstdc++-v3/doc/html/manual/using_macros.html b/libstdc++-v3/doc/html/manual/using_macros.html index 6cb467471c8c..2f5824ef407d 100644 --- a/libstdc++-v3/doc/html/manual/using_macros.html +++ b/libstdc++-v3/doc/html/manual/using_macros.html @@ -156,25 +156,26 @@ -fexec-charset=UTF-8 so might give incorrect results if called from a source file that uses a non-Unicode encoding, especially for format strings using non-ASCII fill characters. -

    _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS

    - Undefined by default. - When defined, the behavior of specializations of +

    _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS

    + Defined to the value 1, if not provided. + ABI-changing when defined to the value 2. + + When defined to a non-zero value, piecewise_constant_distribution and - piecewise_linear_distribution - is restored to their state prior the implementation - of - PR82749 ( - LWG1439), + piecewise_linear_distribution incorporates corrections + from + PR82749 (LWG1439), LWG4052, and - PR125548) in GCC 17. -

    _GLIBCXX_USE_RESULT_TYPE_FOR_PIECEWISE_DENSITIES

    - Undefined by default. ABI-changing. - When defined, specializations of - piecewise_constant_distribution and - piecewise_linear_distribution with a - result_type of either float or - long double will manage their internal state using - result_type values (instead of double). + PR125548 in GCC 17. +

    + When defined to the value 0, their behavior + is restored to their state prior changes in GCC 17. +

    + When defined to the value 2, specializations of + beforementioned distributions with a result_type of + either float or long double will manage + their internal state using result_type values (instead + of double). This is required for standard conformance, but is incompatible with the default implementation of those class templates.

    Prev Up Next
    Headers Home Dual ABI
    \ No newline at end of file diff --git a/libstdc++-v3/doc/xml/manual/using.xml b/libstdc++-v3/doc/xml/manual/using.xml index da710be408f0..9cb93ec76d50 100644 --- a/libstdc++-v3/doc/xml/manual/using.xml +++ b/libstdc++-v3/doc/xml/manual/using.xml @@ -1379,35 +1379,35 @@ g++ -Winvalid-pch -I. -include stdc++.h -H -g -O2 hello.cc -o test.exe especially for format strings using non-ASCII fill characters. - _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS + _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS - Undefined by default. - When defined, the behavior of specializations of + Defined to the value 1, if not provided. + ABI-changing when defined to the value 2. + + When defined to a non-zero value, piecewise_constant_distribution and - piecewise_linear_distribution - is restored to their state prior the implementation - of piecewise_linear_distribution incorporates corrections + from PR82749 ( - LWG1439), LWG1439), LWG4052, and - PR125548) in GCC 17. + PR125548 in GCC 17. - - _GLIBCXX_USE_RESULT_TYPE_FOR_PIECEWISE_DENSITIES - - Undefined by default. ABI-changing. - When defined, specializations of - piecewise_constant_distribution and - piecewise_linear_distribution with a - result_type of either float or - long double will manage their internal state using - result_type values (instead of double). + When defined to the value 0, their behavior + is restored to their state prior changes in GCC 17. + + + When defined to the value 2, specializations of + beforementioned distributions with a result_type of + either float or long double will manage + their internal state using result_type values (instead + of double). This is required for standard conformance, but is incompatible with the default implementation of those class templates. diff --git a/libstdc++-v3/include/bits/c++config b/libstdc++-v3/include/bits/c++config index 60456a48681e..0c2407ccd07c 100644 --- a/libstdc++-v3/include/bits/c++config +++ b/libstdc++-v3/include/bits/c++config @@ -969,6 +969,10 @@ namespace __gnu_cxx #endif // __has_include #endif // C++17 +#if __cplusplus >= 201103L && !defined(_GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS) +# define _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS 1 +#endif + #pragma GCC diagnostic pop // End of prewritten config; the settings discovered at configure time follow. diff --git a/libstdc++-v3/include/bits/random.h b/libstdc++-v3/include/bits/random.h index e2b29961bd92..f3b8e6c244e1 100644 --- a/libstdc++-v3/include/bits/random.h +++ b/libstdc++-v3/include/bits/random.h @@ -6440,10 +6440,10 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) namespace __detail { -#if defined(_GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS) +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS == 0 template using __piecewise_distributions_storage_t = double; -#elif defined(_GLIBCXX_USE_RESULT_TYPE_FOR_PIECEWISE_DENSITIES) +#elif _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS == 2 template using __piecewise_distributions_storage_t = _Tp; #else @@ -6499,10 +6499,10 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) using _StorageType = __detail::__piecewise_distributions_storage_t<_RealType>; -#ifdef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS - using _CalcType = double; -#else +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS using _CalcType = _RealType; +#else + using _CalcType = double; #endif public: @@ -6548,11 +6548,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) return _M_int; } -#ifdef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS - std::vector - densities() const - { return _M_den.empty() ? std::vector(1, 1.0) : _M_den; } -#else +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS // _GLIBCXX_RESOLVE_LIB_DEFECTS // 1439. Return from densities() functions? [[__gnu__::__abi_tag__("__rt")]] @@ -6569,6 +6565,10 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) return std::vector<_RealType>(_M_den.begin(), _M_den.end()); #pragma GCC diagnostic pop } +#else + std::vector + densities() const + { return _M_den.empty() ? std::vector(1, 1.0) : _M_den; } #endif friend bool @@ -6644,13 +6644,13 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) /** * @brief Returns a vector of the probability densities. */ -#ifdef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS - std::vector +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS + [[__gnu__::__always_inline__]] + std::vector densities() const { return _M_param.densities(); } #else - [[__gnu__::__always_inline__]] - std::vector + std::vector densities() const { return _M_param.densities(); } #endif @@ -6814,10 +6814,10 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) using _StorageType = __detail::__piecewise_distributions_storage_t<_RealType>; -#ifdef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS - using _CalcType = double; -#else +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS using _CalcType = _RealType; +#else + using _CalcType = double; #endif public: @@ -6863,11 +6863,7 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) return _M_int; } -#ifdef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS - std::vector - densities() const - { return _M_den.empty() ? std::vector(2, 1.0) : _M_den; } -#else +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS // _GLIBCXX_RESOLVE_LIB_DEFECTS // 1439. Return from densities() functions? [[__gnu__::__abi_tag__("__rt")]] @@ -6884,6 +6880,10 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) return std::vector<_RealType>(_M_den.begin(), _M_den.end()); #pragma GCC diagnostic pop } +#else + std::vector + densities() const + { return _M_den.empty() ? std::vector(2, 1.0) : _M_den; } #endif friend bool @@ -6961,13 +6961,13 @@ _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) * @brief Return a vector of the probability densities of the * distribution. */ -#ifdef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS - std::vector +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS + [[__gnu__::__always_inline__]] + std::vector densities() const { return _M_param.densities(); } #else - [[__gnu__::__always_inline__]] - std::vector + std::vector densities() const { return _M_param.densities(); } #endif diff --git a/libstdc++-v3/include/bits/random.tcc b/libstdc++-v3/include/bits/random.tcc index b2b18e66f5f1..ab4bb09dc3d0 100644 --- a/libstdc++-v3/include/bits/random.tcc +++ b/libstdc++-v3/include/bits/random.tcc @@ -3065,10 +3065,10 @@ namespace __detail // 4052. Bogus requirements for piecewise_linear_distribution auto __cfw = [&__fw](_RealType __n, _RealType __p) { -#ifdef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS - return __fw(0.5 * (__n + __p)); -#else +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS return _RealType(__fw(_RealType(0.5) * (__n + __p))); +#else + return __fw(0.5 * (__n + __p)); #endif }; @@ -3098,10 +3098,10 @@ namespace __detail const _RealType __delta = (__xmax - __xmin) / __n; auto __cfw = [&__fw, __delta](_RealType __v) { -#ifdef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS - return __fw(__v + 0.5 * __delta); -#else +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS return _RealType(__fw(__v + _RealType(0.5) * __delta)); +#else + return __fw(__v + 0.5 * __delta); #endif }; @@ -3380,12 +3380,12 @@ namespace __detail const _RealType __delta = (__xmax - __xmin) / __n; const auto __cfw = [&] (_RealType __v) { -#ifdef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS - return __fw(__v + __delta); -#else +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS // _GLIBCXX_RESOLVE_LIB_DEFECTS // 4052. Bogus requirements for piecewise_linear_distribution return _RealType(__fw(__v)); +#else + return __fw(__v + __delta); #endif }; diff --git a/libstdc++-v3/testsuite/26_numerics/random/piecewise_constant_distribution/cons/input_type_fallback_neg.cc b/libstdc++-v3/testsuite/26_numerics/random/piecewise_constant_distribution/cons/input_type_fallback_neg.cc index 6fb04ef7655f..3dfba49d7f9e 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/piecewise_constant_distribution/cons/input_type_fallback_neg.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/piecewise_constant_distribution/cons/input_type_fallback_neg.cc @@ -1,4 +1,4 @@ -// { dg-options "-D_GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS" } +// { dg-options "-D_GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS=0" } // { dg-do compile { target c++11 } } // { dg-require-cstdint "" } diff --git a/libstdc++-v3/testsuite/26_numerics/random/piecewise_constant_distribution/operators/accessors.cc b/libstdc++-v3/testsuite/26_numerics/random/piecewise_constant_distribution/operators/accessors.cc index b31b028dc27d..f8034ef08a0c 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/piecewise_constant_distribution/operators/accessors.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/piecewise_constant_distribution/operators/accessors.cc @@ -19,10 +19,10 @@ test_exact() VERIFY( interval[0] == RealType(0.0) ); VERIFY( interval[5] == RealType(5.0) ); -#ifdef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS - const std::vector& density = u.densities(); -#else +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS const std::vector& density = u.densities(); +#else + const std::vector& density = u.densities(); #endif VERIFY( density.size() == 5 ); @@ -38,9 +38,9 @@ void test_precision_depended() { constexpr bool preserved -#ifdef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS == 0 = sizeof(InputType) <= sizeof(double); -#elifdef _GLIBCXX_USE_RESULT_TYPE_FOR_PIECEWISE_DENSITIES +#elif _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS == 2 = sizeof(InputType) <= sizeof(DistType); #else // input is converted to DistType and stored in double @@ -61,10 +61,10 @@ test_precision_depended() VERIFY( interval[0] == DistType(0.0) ); VERIFY( interval[2] == DistType(1.0) ); -#ifdef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS - const std::vector& density = dist.densities(); -#else +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS const std::vector& density = dist.densities(); +#else + const std::vector& density = dist.densities(); #endif VERIFY( density.size() == 2 ); @@ -91,10 +91,10 @@ test_engine_calls() { constexpr std::size_t bits = __builtin_popcountg(URBG::max() - URBG::min()); constexpr std::size_t calls -#ifdef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS - = (std::numeric_limits::digits + bits - 1) / bits; -#else +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS = (std::numeric_limits::digits + bits - 1) / bits; +#else + = (std::numeric_limits::digits + bits - 1) / bits; #endif struct wrapper : URBG diff --git a/libstdc++-v3/testsuite/26_numerics/random/piecewise_constant_distribution/operators/accessors_exact.cc b/libstdc++-v3/testsuite/26_numerics/random/piecewise_constant_distribution/operators/accessors_exact.cc index 469ed3fac469..e8e00acab737 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/piecewise_constant_distribution/operators/accessors_exact.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/piecewise_constant_distribution/operators/accessors_exact.cc @@ -1,4 +1,4 @@ -// { dg-options "-D_GLIBCXX_USE_RESULT_TYPE_FOR_PIECEWISE_DENSITIES" } +// { dg-options "-D_GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS=2" } // { dg-do run { target c++11 } } // { dg-require-cstdint "" } #include "accessors.cc" diff --git a/libstdc++-v3/testsuite/26_numerics/random/piecewise_constant_distribution/operators/accessors_fallback.cc b/libstdc++-v3/testsuite/26_numerics/random/piecewise_constant_distribution/operators/accessors_fallback.cc index 1f7269a879cd..b803786368fb 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/piecewise_constant_distribution/operators/accessors_fallback.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/piecewise_constant_distribution/operators/accessors_fallback.cc @@ -1,4 +1,4 @@ -// { dg-options "-D_GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS" } +// { dg-options "-D_GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS=0" } // { dg-do run { target c++11 } } // { dg-require-cstdint "" } #include "accessors.cc" diff --git a/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/cons/input_type_fallback_neg.cc b/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/cons/input_type_fallback_neg.cc index 48ae22b87bb3..4bc9ca2704ec 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/cons/input_type_fallback_neg.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/cons/input_type_fallback_neg.cc @@ -1,4 +1,4 @@ -// { dg-options "-D_GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS" } +// { dg-options "-D_GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS=0" } // { dg-do compile { target c++11 } } // { dg-require-cstdint "" } diff --git a/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/cons/pr125548.cc b/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/cons/pr125548.cc index 2d7ae555eaa7..469ce7916c1c 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/cons/pr125548.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/cons/pr125548.cc @@ -4,18 +4,18 @@ #include #include -void +void test_functor(int n) { const double step = 1.0/n; -#ifdef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS - double expected = step; -#else +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS double expected = 0.0; +#else + double expected = step; #endif auto check_val = [&] (double value) mutable { - VERIFY( value == expected ); + VERIFY( value == expected ); expected += step; return value; }; diff --git a/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/cons/pr125548_fallback.cc b/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/cons/pr125548_fallback.cc index 4b8e66585700..84cb8bad1adc 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/cons/pr125548_fallback.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/cons/pr125548_fallback.cc @@ -1,4 +1,4 @@ -// { dg-options "-D_GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS" } +// { dg-options "-D_GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS=0" } // { dg-do run { target c++11 } } // { dg-require-cstdint "" } #include "pr125548.cc" diff --git a/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/operators/accessors.cc b/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/operators/accessors.cc index 5da22fc10113..d94155f0020c 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/operators/accessors.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/operators/accessors.cc @@ -19,10 +19,10 @@ test_exact() VERIFY( interval[0] == RealType(0.0) ); VERIFY( interval[5] == RealType(5.0) ); -#ifdef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS - const std::vector& density = u.densities(); -#else +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS const std::vector& density = u.densities(); +#else + const std::vector& density = u.densities(); #endif VERIFY( density.size() == 6 ); @@ -39,9 +39,9 @@ void test_precision_depended() { constexpr bool preserved -#ifdef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS == 0 = sizeof(InputType) <= sizeof(double); -#elifdef _GLIBCXX_USE_RESULT_TYPE_FOR_PIECEWISE_DENSITIES +#elif _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS == 2 = sizeof(InputType) <= sizeof(DistType); #else // input is converted to DistType and stored in double @@ -62,10 +62,10 @@ test_precision_depended() VERIFY( interval[0] == DistType(0.0) ); VERIFY( interval[2] == DistType(1.0) ); -#ifdef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS - const std::vector& density = dist.densities(); -#else +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS const std::vector& density = dist.densities(); +#else + const std::vector& density = dist.densities(); #endif VERIFY( density.size() == 3 ); @@ -83,7 +83,7 @@ test_precision_depended() Distribution from_init_list(x, wf); validate(from_init_list); -#ifndef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS // PR125548 leads to incorrect densities being used Distribution from_count(2, InputType(0), InputType(1), wf); validate(from_count); @@ -96,10 +96,10 @@ test_engine_calls() { constexpr std::size_t bits = __builtin_popcountg(URBG::max() - URBG::min()); constexpr std::size_t calls -#ifdef _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS - = (std::numeric_limits::digits + bits - 1) / bits; -#else +#if _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS = (std::numeric_limits::digits + bits - 1) / bits; +#else + = (std::numeric_limits::digits + bits - 1) / bits; #endif struct wrapper : URBG diff --git a/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/operators/accessors_exact.cc b/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/operators/accessors_exact.cc index 469ed3fac469..e8e00acab737 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/operators/accessors_exact.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/operators/accessors_exact.cc @@ -1,4 +1,4 @@ -// { dg-options "-D_GLIBCXX_USE_RESULT_TYPE_FOR_PIECEWISE_DENSITIES" } +// { dg-options "-D_GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS=2" } // { dg-do run { target c++11 } } // { dg-require-cstdint "" } #include "accessors.cc" diff --git a/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/operators/accessors_fallback.cc b/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/operators/accessors_fallback.cc index 1f7269a879cd..b803786368fb 100644 --- a/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/operators/accessors_fallback.cc +++ b/libstdc++-v3/testsuite/26_numerics/random/piecewise_linear_distribution/operators/accessors_fallback.cc @@ -1,4 +1,4 @@ -// { dg-options "-D_GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS" } +// { dg-options "-D_GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS=0" } // { dg-do run { target c++11 } } // { dg-require-cstdint "" } #include "accessors.cc" From e47eccbe6d118023e4fe83bde14075729c40e030 Mon Sep 17 00:00:00 2001 From: Robert Dubner Date: Mon, 21 Sep 2026 13:03:11 -0400 Subject: [PATCH 303/584] cobol: Improve speed of numeric-edited formatting. The speed of converting numerical strings to numeric-edited variables has been improved by moving run-time PICTURE processing to compile time. gcc/cobol/ChangeLog: * genapi.cc (actually_create_the_static_field): Use the new expand_expanded routine. * symbols.cc (expand_picture): Add space to accommodate the six additional pre-processing characters. (expand_expanded): Append compile-time data to the end of numeric- edited PICTURE strings. * symbols.h (redefined_token): Formatting. (class current_tokens_t): Formatting. (expand_expanded): New declaration. * util.cc (cbl_field_t::encode_numeric): Use expand_expanded(). libgcobol/ChangeLog: * libgcobol.cc (int128_to_field): Remove rdigits formal parameter. (__gg__int128_to_ascii_numeric_display): Likewise. * valconv.cc (__gg__string_to_numeric_edited): Complete rewrite to use parameters appended by expand_expanded(). * valconv.h: Remove rdigits format parameter from __gg__int128_to_ascii_numeric_display. gcc/testsuite/ChangeLog: * cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.cob: New test. * cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.out: New test. --- gcc/cobol/genapi.cc | 5 + gcc/cobol/symbols.cc | 223 ++++++++++ gcc/cobol/symbols.h | 22 +- gcc/cobol/util.cc | 5 +- ..._get_program_name_-_functions_0_and_2_.cob | 71 ++++ ..._get_program_name_-_functions_0_and_2_.out | 3 + libgcobol/libgcobol.cc | 8 +- libgcobol/valconv.cc | 390 +++++++----------- libgcobol/valconv.h | 1 - 9 files changed, 466 insertions(+), 262 deletions(-) create mode 100644 gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.cob create mode 100644 gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.out diff --git a/gcc/cobol/genapi.cc b/gcc/cobol/genapi.cc index 5d7d553b9d8b..e3753fd77099 100644 --- a/gcc/cobol/genapi.cc +++ b/gcc/cobol/genapi.cc @@ -14431,7 +14431,12 @@ actually_create_the_static_field( cbl_field_t *new_var, } tree offset = build_int_cst_type(SIZE_T, new_var->offset); tree name = gg_string_literal(new_var->name); + char *expanded = expand_picture(new_var->data.picture); + if( new_var->type == FldNumericEdited ) + { + expand_expanded(expanded); + } tree picture = gg_string_literal(expanded); free(expanded); tree initial; diff --git a/gcc/cobol/symbols.cc b/gcc/cobol/symbols.cc index 6d96ba311b6a..c41e0b8ff2a3 100644 --- a/gcc/cobol/symbols.cc +++ b/gcc/cobol/symbols.cc @@ -4798,6 +4798,12 @@ expand_picture(const char *picture) // The caller should free() the return value. assert(strlen(picture) < PICTURE_MAX); // guaranteed by picset() in scanner size_t retval_length = PICTURE_MAX; + + // In the expand_expanded routine, we are going to tack on some additional + // characters in order to speed up compile-time processin. + static const int PICTURE_EXTRA = 6; + retval_length += PICTURE_EXTRA; + char *retval = static_cast(xmalloc(retval_length)); int ch; @@ -4909,9 +4915,226 @@ expand_picture(const char *picture) break; } } + + // AD HOC FIX for an improper trailing space + char *pspace = strchr(retval, ascii_space); + if( pspace ) + { + *pspace = NULLCH; + } + return retval; } +void +expand_expanded(char *expanded) + { + if(strlen(expanded) == 0) + { + return; + } + + unsigned char *dest = reinterpret_cast(expanded); + + /* In order to make __gg__string_to_numeric_edited() run quickly, we are + going to process the expanded picture string especially for it. What we + do here: + + Convert B to space, taking care not to touch a final 'DB' + + Find the currency picture symbol + + Find the span of any '$$', '++', '--' 'Z', and '*' runs. + + For any '$$', '++' and '--' runs, replace the first such char with a + space, and all the others with '9' + + For any 'Z' and '*' runs, replace all the characters with '9'. + + Figure out if any of the original picture characters are '9'. + + That information gets encoded into six characters that are appended to + the modified string. + + Offset 0: The currency character + Offset 1: The floating character (space if empty) + Offset 2-3: The starting index of the float. + Offset 3-4: The one-past-the-end index of the float. + + When there are '9' characters in the original, the 0x40 bit of offset 2 + is turned on, turning '0'-'9' into 'q'-'y' + + Is everybody ready? Then we'll begin. */ + + int length_d = strlen(expanded); + + unsigned char currency_char = ascii_space; + // Note that the currency_picture can be upper- or lower-case, and mean + // separate things in IBM. In ISO COBOL, the comparison is case-insensitive. + + unsigned floating_char = ascii_space; + int leftmost_float = -1; + int rightmost_float = -1; // This is a one-past-the-end index + + bool got_nines = false; + + for(int i=0; i(memchr(dest, currency_char, length_d)) - dest; + rightmost_float = + static_cast(memrchr(dest, currency_char, length_d)) - dest + 1; + if( rightmost_float > leftmost_float+1 ) + { + floating_char = currency_char; + // Turn the first floating character into a space + dest[leftmost_float] = ascii_space; + for(int i=leftmost_float+1; i(memchr(dest, ascii_minus, length_d)) - dest; + int rightmost = + static_cast(memrchr(dest, ascii_minus, length_d)) - dest + 1; + if( rightmost > leftmost+1 ) + { + floating_char = ascii_minus; + leftmost_float = leftmost; + rightmost_float = rightmost; + for(int i=leftmost_float+1; i(memchr(dest, ascii_plus, length_d)) - dest; + int rightmost = + static_cast(memrchr(dest, ascii_plus, length_d)) - dest + 1; + if( rightmost > leftmost+1 ) + { + floating_char = ascii_plus; + leftmost_float = leftmost; + rightmost_float = rightmost; + for(int i=leftmost_float+1; i(memchr(dest, ascii_asterisk, length_d)) - dest; + rightmost_float = + static_cast(memrchr(dest, ascii_asterisk, length_d)) - dest + 1; + for(int i=leftmost_float; i(memchr(dest, ascii_Z, length_d)) - dest; + rightmost_float = + static_cast(memrchr(dest, ascii_Z, length_d)) - dest + 1; + for(int i=leftmost_float; i #include +// The ISO spec says there is a #define PICTURE_MAX 64 extern const char *numed_message; @@ -2970,7 +2971,7 @@ int redefined_token( const cbl_name_t name, int token ); * intrinsic functions. * * tokens and token_names are defined in a token_names.h, generated from parse.h. - * + * * - token_names converts a yytokentype enum to a string form of * its name as defined in the parser. It is used by keyword_str. * - tokens imperfectly maps a lowercase form of the token name to its value. @@ -2981,16 +2982,16 @@ int redefined_token( const cbl_name_t name, int token ); * EQUATE adds a new name for a token in tokens. * UNDEFINE removes a name from tokens. * SUBSTITUTE is EQUATE for the first name and UNDEFINE for the second. - * RESERVE adds a new name to tokens with the invalid value -42. + * RESERVE adds a new name to tokens with the invalid value -42. * * The generated lexer of course uses static strings and is thus unaffected by * COBOL-WORDS. The parser accesses the generated lexer via a mediation layer * that deals with the CDF. That is where COBOL-WORDS are applied. * - * There are unsolved problems. - * 1. Some tokens are lexed as more than one text word, or depend on context. - * For example OBJECT COMPUTER and IDENTIFICATION DIVISION. If the user - * substitutes COMPUTING-MACHINE COMPUTER, lexing will fail. + * There are unsolved problems. + * 1. Some tokens are lexed as more than one text word, or depend on context. + * For example OBJECT COMPUTER and IDENTIFICATION DIVISION. If the user + * substitutes COMPUTING-MACHINE COMPUTER, lexing will fail. * 2. Semantic values are known only to the lexer. Some tokens carry a value * representing their context. For example, both INVALID and NOT INVALID @@ -3000,7 +3001,7 @@ int redefined_token( const cbl_name_t name, int token ); * assign it the value "BOGUS". When that string is found by * redefined_token and mapped to INVALID (so the parser can parse it) the * semantic value is lost. - * + * * 3. Some names are not NAME tokens, depending on context. That subtlety is * also lost. * @@ -3105,7 +3106,7 @@ class current_tokens_t { return true; } /* - * name may be: + * name may be: * 1. just a name, return the input token. * 2. reserved with -42 token * 3. a user-defined substitute or alias for a token @@ -3144,7 +3145,7 @@ class current_tokens_t { return tokens.find(name, include_intrinsics); } bool equate( const cbl_loc_t& loc, const cbl_name_t keyword, const cbl_name_t alias ) { - int token; + int token; if( 0 == (token = keyword_tok(keyword, true)) ) { if( 0 == (token = binary_integer_usage_of(keyword)) ) { @@ -3165,7 +3166,7 @@ class current_tokens_t { return tokens.undefine(loc, keyword); } bool substitute( const cbl_loc_t& loc, const cbl_name_t keyword, const cbl_name_t alias ) { - int token; + int token; if( 0 == (token = keyword_tok(keyword, true)) ) { if( 0 == (token = binary_integer_usage_of(keyword)) ) { error_msg(loc, "SUBSTITUTE: not a reserved word: %qs", keyword); @@ -3293,6 +3294,7 @@ cbl_field_t *new_alphanumeric(const cbl_name_t name=nullptr, cbl_encoding_t encoding=no_encoding_e ); char *expand_picture(const char *picture); +void expand_expanded(char *picture); // ENABLE_HIJACKING allows for code generation to be "hijacked" when the // program-id is "dubner_h" or "hijack_h". See the mainline code in genapi.cc. diff --git a/gcc/cobol/util.cc b/gcc/cobol/util.cc index 70122334090c..e45252259816 100644 --- a/gcc/cobol/util.cc +++ b/gcc/cobol/util.cc @@ -1936,9 +1936,12 @@ cbl_field_t::encode_numeric( const char input[], cbl_loc_t loc ) { // By the time you read this, this next statement ought to be // obsolete. See RT issue 3682. expanded[char_capacity()] = '\0'; + if( type == FldNumericEdited ) + { + expand_expanded(expanded); + } __gg__string_to_numeric_edited( reinterpret_cast(retval), ach, - data.rdigits, negative, expanded); free(expanded); diff --git a/gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.cob b/gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.cob new file mode 100644 index 000000000000..5b2f160397e8 --- /dev/null +++ b/gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.cob @@ -0,0 +1,71 @@ + *> Do not edit this generated file. See README.txt + *> { dg-do run } + *> { dg-options "-dialect mf" } + *> { dg-output-file "group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.out" } + + copy "cblproto.cpy". + identification division. + program-id. prog. + data division. + working-storage section. + copy "cbltypes.cpy". + 01 param-block type cblt-prog-info-params value zeros. + 77 fn pic x(4) comp-5. + 77 status-code pic x(2) comp-5. + 77 buf pic x(128). + 77 buflen pic x(4) comp-5. + procedure division. + move length of param-block to cblte-gpi-size. + + * allocate handle + move 7 to cblte-gpi-flags. + move 0 to fn. + move length of buf to buflen. + call "CBL_GET_PROGRAM_INFO" using + by value fn + by reference param-block + buf + buflen + returning status-code. + + if status-code <> 0 + display "CBL_GET_PROGRAM_INFO failed with " status-code + goback + end-if. + + display "buf is '" buf "'". + + * retrieve program name from handle + move 6 to cblte-gpi-flags. + move 2 to fn. + move x"00" to buf. + call "CBL_GET_PROGRAM_INFO" using + by value fn + by reference param-block + buf + buflen + returning status-code. + + if status-code <> 0 + display "CBL_GET_PROGRAM_INFO failed with " status-code + goback + end-if. + + display "buf from handle is '" buf "'". + + * close handle + move 0 to cblte-gpi-flags. + move 3 to fn. + call "CBL_GET_PROGRAM_INFO" using + by value fn + by reference param-block + buf + buflen + returning status-code. + + if status-code <> 0 + display "CBL_GET_PROGRAM_INFO failed with " status-code + goback + end-if. + end program prog. + diff --git a/gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.out b/gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.out new file mode 100644 index 000000000000..c86d093d7678 --- /dev/null +++ b/gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.out @@ -0,0 +1,3 @@ +buf is 'prog' +buf from handle is 'prog' + diff --git a/libgcobol/libgcobol.cc b/libgcobol/libgcobol.cc index f436e822889d..4332d7ddee0d 100644 --- a/libgcobol/libgcobol.cc +++ b/libgcobol/libgcobol.cc @@ -2140,7 +2140,6 @@ int128_to_field(cblc_field_t *var, // Convert that string according to the PICTURE clause __gg__string_to_numeric_edited(as_chars(location), ach, - target_rdigits, is_negative, var->picture); size_t outlength; @@ -2309,10 +2308,9 @@ __gg__int128_to_ascii_numeric_display(const cblc_field_t *var, // Convert that string according to the PICTURE clause __gg__string_to_numeric_edited(as_chars(location), - ach, - var->rdigits, - is_negative, - var->picture); + ach, + is_negative, + var->picture); } return size_error; } diff --git a/libgcobol/valconv.cc b/libgcobol/valconv.cc index 21e89f437ddb..83bdaf09cbae 100644 --- a/libgcobol/valconv.cc +++ b/libgcobol/valconv.cc @@ -138,12 +138,12 @@ __gg__alphabet_create( cbl_encoding_t encoding, extern "C" void -__gg__string_to_numeric_edited( char * const dest, +__gg__string_to_numeric_edited( char * const dest_, const char *source, // In source characters - int /*rdigits*/, int is_negative, const char *picture) { + unsigned char *dest = reinterpret_cast(dest_); // This routine operates in ASCII space. Life is hard enough without trying // to do this in EBCDIC, too. So, 'source' and 'picture' are assumed to be // CP1252 @@ -159,8 +159,14 @@ __gg__string_to_numeric_edited( char * const dest, // Make a copy of the PICTURE string in the destination space. The picture // is supposed to be the same length as the char_capacity of the variable. - const int length_s = strlen(source); - const int length_d = strlen(picture); + + // We subtract the length of the extra characters that were appended to the + // adjusted PICTURE string. + + static const int MAX_POSSIBLE = 64 + 6; // See PICTURE_MAX in symbols.h + + const int length_d = strlen(picture) - 6; + assert(length_d < MAX_POSSIBLE && length_d >= 0); memcpy(dest, picture, length_d); /* We have two kinds of floating insertion: currency and sign. @@ -183,105 +189,72 @@ __gg__string_to_numeric_edited( char * const dest, // We need to know if we have a currency picture symbol in this string: // This is the currency character in the PICTURE - unsigned char currency_char = NULLCH; + unsigned char currency_char; const char *currency_text = NULL; // This is the text we output when // // encountering the currency_picture // // character // Note that the currency_picture can be upper- or lower-case, and mean // separate things in IBM. In ISO COBOL, the comparison is case-insensitive. - // This is the character for a floating sign - char sign_char; - - // In the following limits, all of the rightmosts are past-the-end indexes - - int leftmost_currency = -1; - int rightmost_currency = -1; - - int leftmost_sign = -1; - int rightmost_sign = -1; - - int leftmost_asterisk = -1; - int rightmost_asterisk = -1; - int zeroed_asterisk = 0; - - int leftmost_z = -1; - int rightmost_z = -1; - int zeroed_z = 0; - + unsigned char floating_char; + int leftmost_float = -1; + int rightmost_float = -1; // This is a one-past-the-end index + bool got_nines = false; int leftmost_nonzero = -1; - int decimal_position = -1; - // This is the first pass. Because the currency + unsigned const char *extra = + reinterpret_cast(picture+length_d); + currency_char = extra[0]; + currency_text = __gg__currency_signs[currency_char].c_str(); + + floating_char = extra[1] != ascii_space ? extra[1] : NULLCH; + if( floating_char != ascii_space ) + { + leftmost_float = (extra[2] & 0xF) * 10 + (extra[3] & 0xF); + rightmost_float = (extra[4] & 0xF) * 10 + (extra[5] & 0xF); + } + got_nines = !!(extra[2] & 0x40); + int index_s = 0; for(int i=0; i= 1 ) - { - if( dest[i-1] != ascii_D && dest[i-1] != ascii_d ) - { - // This is an isolated B at the very end of the string - dest[i] = ascii_space; - } - // Otherwise, that final B is part of a DB, and is left alone. - } break; case ascii_9: @@ -329,175 +272,130 @@ __gg__string_to_numeric_edited( char * const dest, leftmost_nonzero = i; } break; - - case ascii_asterisk: - // These are positions that hold digits - if( leftmost_asterisk == -1 ) - { - leftmost_asterisk = i; - } - rightmost_asterisk = i+1; - - dest[i] = source[index_s++]; - if( dest[i] == ascii_zero ) - { - zeroed_asterisk += 1; - } - else - { - if( leftmost_nonzero == -1 ) - { - leftmost_nonzero = i; - } - } - break; - - case ascii_Z: - // These are positions that hold digits - if( leftmost_z == -1 ) - { - leftmost_z = i; - } - rightmost_z = i+1; - - dest[i] = source[index_s++]; - if( dest[i] == ascii_zero ) - { - zeroed_z += 1; - } - else - { - if( leftmost_nonzero == -1 ) - { - leftmost_nonzero = i; - } - } - break; - - default: - abort(); } } // Do currency replacement - if( leftmost_currency >= 0 ) + if( floating_char == currency_char ) { - if( leftmost_currency == rightmost_currency-1 ) + // This is a floating currency symbol. We need to start at + // leftmost_float, and walk to the lesser of rightmost_float and + // leftmost_nonzero. We blank every character we encounter until we + // reach the first non-zero character. + int left = leftmost_float; + int right; + if( leftmost_nonzero >= 0 ) { - // This is a solo currency symbol - memcpy(dest + leftmost_currency - (strlen(currency_text)-1), - currency_text, - strlen(currency_text)); + right = std::min(leftmost_nonzero, rightmost_float); + if( decimal_position >= 0 ) + { + right = std::min(right, decimal_position); + } } else { - // This is a floating currency symbol. We need to start at - // leftmost_currency, and walk to the lesser of rightmost_currency and - // leftmost_nonzero. We blank every character we encounter. - int left = leftmost_currency; - int right; - if( leftmost_nonzero >= 0 ) - { - right = std::min(leftmost_nonzero, rightmost_currency); - if( decimal_position >= 0 ) - { - right = std::min(right, decimal_position); - } - } - else - { - right = rightmost_currency; - } - // blank out that range - memset(dest+left, ascii_space, right-left); + right = rightmost_float; + } + // blank out that range + assert(right-left < MAX_POSSIBLE && right-left >= 0); + memset(dest+left, ascii_space, right-left); - // To handle situations like PIC $$$,999, where the currency sign has to - // overwrite the comma, we walk from here until we hit the column just to - // the left of a digit - while( right < length_d ) - { + // To handle situations like PIC $$$,999, where the currency sign has to + // overwrite the comma, we walk from here until we hit the column just to + // the left of a digit + while( right < length_d ) + { if( (dest[right] >= ascii_zero && dest[right] <= ascii_nine) - || right == decimal_position ) - { - break; - } - dest[right] = ascii_space; - right += 1; - } - if( right < length_d ) + || right == decimal_position ) { - right -= 1; - memcpy(dest + right - (strlen(currency_text)-1), - currency_text, - strlen(currency_text)); + break; } + dest[right] = ascii_space; + right += 1; + } + if( right < length_d ) + { + right -= 1; + memcpy(dest + right - (strlen(currency_text)-1), + currency_text, + strlen(currency_text)); } } // Do sign replacement - if( leftmost_sign >= 0 ) + if( floating_char == ascii_plus || floating_char == ascii_minus ) { - if( leftmost_sign == rightmost_sign-1 ) + // This is a floating sign symbol. We need to start at + // leftmost_float, and walk to the lesser of rightmost_float and + // leftmost_nonzero. We blank every character we encounter. + unsigned char sign_char; + if( is_negative ) { - // This is a solo sign symbol - dest[leftmost_sign] = sign_char; + sign_char = ascii_minus; } else { - // This is a floating sign symbol. We need to start at - // leftmost_sign, and walk to the lesser of rightmost_sign and - // leftmost_nonzero. We blank every character we encounter. - int left = leftmost_sign; - int right; - if( leftmost_nonzero >= 0 ) + if( floating_char == ascii_minus ) { - right = std::min(leftmost_nonzero, rightmost_sign); - if( decimal_position >= 0 ) - { - right = std::min(right, decimal_position); - } + sign_char = ascii_space; } else { - right = rightmost_sign; + sign_char = ascii_plus; } - // blank out that range - memset(dest+left, ascii_space, right-left); + } - // To handle situations like PIC $$$,999, where the sign char has to - // overwrite the comma, we walk from here until we hit the column just to - // the left of a digit - while( right < length_d ) + int left = leftmost_float; + int right; + if( leftmost_nonzero >= 0 ) + { + right = std::min(leftmost_nonzero, rightmost_float); + if( decimal_position >= 0 ) { - if( (dest[right] >= ascii_zero && dest[right] <= ascii_nine) - || right == decimal_position ) - { - break; - } - dest[right] = ascii_space; - right += 1; + right = std::min(right, decimal_position); } - if( right < length_d ) + } + else + { + right = rightmost_float; + } + // blank out that range + assert(right-left < MAX_POSSIBLE && right-left >= 0); + memset(dest+left, ascii_space, right-left); + + // To handle situations like PIC $$$,999, where the sign char has to + // overwrite the comma, we walk from here until we hit the column just to + // the left of a digit + while( right < length_d ) + { + if( (dest[right] >= ascii_zero && dest[right] <= ascii_nine) + || right == decimal_position ) { - right -= 1; - dest[right] = sign_char; + break; } + dest[right] = ascii_space; + right += 1; + } + if( right < length_d ) + { + right -= 1; + dest[right] = sign_char; } } // Do '*' zero suppression - if( leftmost_asterisk >= 0 ) + if( floating_char == ascii_asterisk ) { - // This is a floating zero suppression. + // This is a floating zero suppression. - int left = leftmost_asterisk; + int left = leftmost_float; int right; if( leftmost_nonzero >= 0 ) { // The value being formatted is non-zero, so make sure 'right' is no more // than the decimal position. - right = std::min(leftmost_nonzero, rightmost_asterisk); - if( decimal_position >= 0 && decimal_position > leftmost_asterisk ) + right = std::min(leftmost_nonzero, rightmost_float); + if( decimal_position >= 0 && decimal_position > leftmost_float ) { right = std::min(right, decimal_position); } @@ -505,19 +403,19 @@ __gg__string_to_numeric_edited( char * const dest, else { // The value being formatted is zero - if( zeroed_asterisk == length_s ) + if( leftmost_nonzero == -1 && !got_nines ) { - // Every numeric position was a zero on asterisk, so the whole thing - // is starred. + // Every numeric position was a zero, and there were no explicit nines left = 0; right = length_d; } else { - right = rightmost_asterisk; + right = rightmost_float; } } - // blank out that range + // Fill that range with stars + assert(right-left < MAX_POSSIBLE && right-left >= 0); memset(dest+left, ascii_asterisk, right-left); // To handle situations like PIC ZZZ,999, where the suppression char has to @@ -526,7 +424,7 @@ __gg__string_to_numeric_edited( char * const dest, while( right < length_d ) { if( (dest[right] >= ascii_zero && dest[right] <= ascii_nine) - || right == decimal_position ) + || right == decimal_position ) { break; } @@ -543,37 +441,38 @@ __gg__string_to_numeric_edited( char * const dest, } // Do 'Z' zero suppression - if( leftmost_z >= 0 ) + if( floating_char == ascii_Z ) { - // This is a floating zero suppression. + // This is a floating zero suppression. - int left = leftmost_z; + int left = leftmost_float; int right; if( leftmost_nonzero >= 0 ) { // The value being formatted is non-zero, so make sure 'right' is no more // than the decimal position. - right = std::min(leftmost_nonzero, rightmost_z); - if( decimal_position >= 0 && decimal_position > leftmost_asterisk ) + right = std::min(leftmost_nonzero, rightmost_float); + if( decimal_position >= 0 && decimal_position > leftmost_float ) { right = std::min(right, decimal_position); } } else { - if( zeroed_z == length_s ) + if( leftmost_nonzero == -1 && !got_nines ) { - // Every numeric position was a zero on asterisk, so the whole thing + // Every numeric position was a zero on 'Z', so the whole thing // is blanked. left = 0; right = length_d; } else { - right = rightmost_z; + right = rightmost_float; } } // blank out that range + assert(right-left < MAX_POSSIBLE && right-left >= 0); memset(dest+left, ascii_space, right-left); // To handle situations like PIC ZZZ,999, where the suppression char has to @@ -582,7 +481,7 @@ __gg__string_to_numeric_edited( char * const dest, while( right < length_d ) { if( (dest[right] >= ascii_zero && dest[right] <= ascii_nine) - || right == decimal_position ) + || right == decimal_position ) { break; } @@ -591,10 +490,11 @@ __gg__string_to_numeric_edited( char * const dest, } } - // Any final DB/CR needs to be addressed: - if( !is_negative - && length_d >= 2 - && ( dest[length_d-2] == ascii_D + // Any final DB/CR needs to be addressed. If the number is positive, or + // all the digits were zeroes, then blank any CR/DB at the end: + if( (!is_negative || leftmost_nonzero < 0) + && length_d >= 2 + && ( dest[length_d-2] == ascii_D || dest[length_d-2] == ascii_d || dest[length_d-2] == ascii_C || dest[length_d-2] == ascii_c ) ) diff --git a/libgcobol/valconv.h b/libgcobol/valconv.h index 62ee342c2b0b..cbd2a2194f5c 100644 --- a/libgcobol/valconv.h +++ b/libgcobol/valconv.h @@ -55,7 +55,6 @@ extern "C" int high_char ); void __gg__string_to_numeric_edited(char * const dest, const char *source, // ASCII - int rdigits, int is_negative, const char *picture); void __gg__string_to_alpha_edited(char *dest, From 059231fb8a42eaeac8880c5d207249b46757767c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A9o=20Hardt?= Date: Mon, 21 Sep 2026 12:41:35 -0600 Subject: [PATCH 304/584] [PATCH][PR preprocessor/121508] fix(libcpp): Don't ICE parsing __has_include outside directive. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit fix(libcpp): Don't ICE parsing __has_include outside directive. cc: libcpp maintainers. Fixes an ICE wherein 'glue_header_name' is called outside parsing a preprocessor directive, causing an entire file to be read and presumed to be a header name. Then, on the next read (the closing '>' or ')'), the parser ICEs since the input has already come to an end. Affects __has_include and __has_embed when used outside directives. Minimal reproducible crash has two tokens (both gcc and g++): __has_include< Given glue_header_name was written for usage inside preprocessor parsing, we could either change it or not call it in case of errors. I opted to bail out early on an error case, since there is no chance it could influence valid code parsing. See more on https://gcc.gnu.org/PR121508. PR preprocessor/121508 PR preprocessor/123339 libcpp/ChangeLog: * macro.cc (builtin_has_include_1): Bail early if not on a preprocessor directive. Signed-off-by: Léo Hardt --- libcpp/macro.cc | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/libcpp/macro.cc b/libcpp/macro.cc index 736c360336d0..24493a45f860 100644 --- a/libcpp/macro.cc +++ b/libcpp/macro.cc @@ -392,8 +392,11 @@ builtin_has_include_1 (cpp_reader *pfile, const char *name, bool *paren, bool *bracket, location_t *loc) { if (!pfile->state.in_directive) - cpp_error (pfile, CPP_DL_ERROR, - "%qs used outside of preprocessing directive", name); + { + cpp_error (pfile, CPP_DL_ERROR, + "%qs used outside of preprocessing directive", name); + return NULL; + } pfile->state.angled_headers = true; const auto sav_padding = pfile->state.directive_wants_padding; From 440ade62c96692a25c4b0d68bd47f1c04d6834fb Mon Sep 17 00:00:00 2001 From: "Ancheng.Qiao" Date: Mon, 21 Sep 2026 12:48:43 -0600 Subject: [PATCH 305/584] [PATCH] RISC-V: fix below-SP FPR saves (use-before-allocate) with Zcmp With Zcmp (cm.push) and -Os, the prologue folds the callee-saved FPRs (fs0..fs11, i.e. f8/f9/f18..f31) into the stack region that cm.push reserves using get_multi_push_fpr_mask (multi_push_additional / UNITS_PER_WORD). That region is measured in bytes, but a double is 8 bytes (UNITS_PER_FP_REG), so dividing by the word size (4 bytes) lets the mask fold up to twice as many FPRs as the reserved space can actually hold. The surplus FPRs (typically fs6..fs11, i.e. f22..f27) therefore end up stored at negative offsets of the current SP, with the stack allocation that should cover them deferred to a trailing "addi sp,sp,-N" that comes after the stores. This is a use-the-stack-before-allocating-it defect: callee-saved FP state lives in the not-yet-allocated region below SP, which an asynchronous interrupt running on the interrupted SP (e.g. a nested CLIC/Zcswl handler) can overwrite before the frame is claimed, silently corrupting f22..f27. gcc/ChangeLog: * config/riscv/riscv.cc (riscv_expand_prologue): Fold into the cm.push reserve only as many callee-saved FPRs as it can hold by dividing the additional reserve by UNITS_PER_FP_REG. (riscv_expand_epilogue): Likewise. gcc/testsuite/ChangeLog: * gcc.target/riscv/zcmp_fpr_save_below_sp.c: New test. Compile an FP-register-heavy function at -Os with Zcmp and check that no callee-saved FPR is saved at a negative offset of SP. Signed-off-by: Ancheng.Qiao --- gcc/config/riscv/riscv.cc | 4 +- .../gcc.target/riscv/zcmp_fpr_save_below_sp.c | 52 +++++++++++++++++++ 2 files changed, 54 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/gcc.target/riscv/zcmp_fpr_save_below_sp.c diff --git a/gcc/config/riscv/riscv.cc b/gcc/config/riscv/riscv.cc index 9fca2f679a07..b676292ca566 100644 --- a/gcc/config/riscv/riscv.cc +++ b/gcc/config/riscv/riscv.cc @@ -10563,7 +10563,7 @@ riscv_expand_prologue (void) if (fmask) { unsigned mask_fprs_push - = get_multi_push_fpr_mask (multi_push_additional / UNITS_PER_WORD); + = get_multi_push_fpr_mask (multi_push_additional / UNITS_PER_FP_REG); frame->fmask &= mask_fprs_push; riscv_for_each_saved_reg (remaining_size, riscv_save_reg, false, false, false); @@ -10969,7 +10969,7 @@ riscv_expand_epilogue (int style) if (fmask) { mask_fprs_push = get_multi_push_fpr_mask (frame->multi_push_adj_addi - / UNITS_PER_WORD); + / UNITS_PER_FP_REG); frame->fmask &= ~mask_fprs_push; /* FPRs not saved by cm.push */ } } diff --git a/gcc/testsuite/gcc.target/riscv/zcmp_fpr_save_below_sp.c b/gcc/testsuite/gcc.target/riscv/zcmp_fpr_save_below_sp.c new file mode 100644 index 000000000000..0f60b7e755ed --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/zcmp_fpr_save_below_sp.c @@ -0,0 +1,52 @@ +/* { dg-do compile { target rv32 } } */ +/* { dg-options "-Os -march=rv32imafd_zca_zcmp -mabi=ilp32d -mcmodel=medlow" } */ +/* { dg-skip-if "" { *-*-* } { "-O0" "-O1" "-O2" "-Og" "-O3" "-Oz" "-flto" } } */ +/* { dg-final { scan-assembler "cm\\.push" } } */ +/* { dg-final { scan-assembler-not "fsd\\s+fs\[0-9\]+,-" } } */ +/* + When Zcmp (cm.push) is enabled, GCC may allocate only the GPR save area + with cm.push and then save the callee-saved FPRs (fs0..fs11) at *negative* + offsets of the current SP, deferring the rest of the frame allocation to a + trailing "addi sp,sp,-N". Those below-SP slots are treated as scratch by + the interrupt/preemption machinery (e.g. nested interrupts that run on the + interrupted SP), so they can be silently clobbered, corrupting the + callee-saved FP registers. The prologue must grow the frame before + emitting any callee-saved FPR store, so no "fsd fsN,-...". */ + +double gmem[40]; + +__attribute__((noinline)) double +helper (double a, double b) +{ + return a * b + gmem[0]; +} + +__attribute__((noinline)) double +sink (double x) +{ + gmem[3] = x; + return x; +} + +/* Keep many callee-saved FPRs live across calls so that GCC must spill + fs2..fs11; this is what triggers the below-SP saves with cm.push. */ +double +test_zcmp_fpr_save (double a, double b, double c, double d, double e, + double q, double w, double r, double t, double y, + double u, double i) +{ + double x0 = a, x1 = b, x2 = c, x3 = d, x4 = e; + double x5 = q, x6 = w, x7 = r, x8 = t, x9 = y; + + double acc = helper (x0, x1) + helper (x2, x3) + helper (x4, x5) + + helper (x6, x7) + helper (x8, x9); + double acc2 = helper (x0, x2) + helper (x4, x6) + helper (x8, x9) + + helper (w, t) + helper (r, y) + helper (u, i); + double acc3 = helper (x1, x3) + helper (x5, x7) + helper (x9, y) + + helper (q, w) + helper (t, r) + helper (x0, x6); + + gmem[1] = acc; + gmem[2] = acc2; + gmem[4] = acc3; + return sink (acc + acc2 + acc3); +} From 7fc31aa3530a80252e4a7859c375b305e6f6aaec Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Mon, 21 Sep 2026 23:34:34 +0200 Subject: [PATCH 306/584] Fix wrong debug info for bit-packed array type with reverse storage order In Ada, small bit-packed array types are represented by modular (unsigned) integer types under the hood and, in this case, the debug info generated for them is incorrect when they are declared with reverse scalar storage order. This is fixed by adding a field to the array_descr_info structure that is filled by the LANG_HOOKS_GET_ARRAY_DESCR_INFO language hook and setting it properly in the front-end. The only other front-end declaring this hook is the Fortran front-end and 1) AFAIK the language does not support toggling the scalar storage order and 2) the language hook first clears the entire structure before returning true, so no changes are made to it. gcc/ * dwarf2out.h (struct array_descr_info): Add reverse_storage_order. * dwarf2out.cc (gen_descr_array_type_die): Pass it in the call to add_type_attribute instead of using TYPE_REVERSE_STORAGE_ORDER. gcc/ada/ * gcc-interface/misc.cc (gnat_get_array_descr_info): Return the TYPE_REVERSE_STORAGE_ORDER flag of the underlying array type. --- gcc/ada/gcc-interface/misc.cc | 8 ++++++-- gcc/dwarf2out.cc | 3 +-- gcc/dwarf2out.h | 1 + 3 files changed, 8 insertions(+), 4 deletions(-) diff --git a/gcc/ada/gcc-interface/misc.cc b/gcc/ada/gcc-interface/misc.cc index 505c48606a59..9c56afed5e57 100644 --- a/gcc/ada/gcc-interface/misc.cc +++ b/gcc/ada/gcc-interface/misc.cc @@ -788,7 +788,7 @@ gnat_get_array_descr_info (const_tree const_type, { tree type = const_cast (const_type); tree first_dimen, dimen; - bool is_array; + bool is_array, reverse_storage_order; int i; /* Temporaries created in the first pass and used in the second one for thin @@ -877,15 +877,19 @@ gnat_get_array_descr_info (const_tree const_type, : array_descr_ordering_row_major); info->rank = NULL_TREE; - /* Count the number of dimensions and determine the element type. */ + /* Count the number of dimensions, determine the element type and whether + it is stored in reverse storage order. */ i = 1; + reverse_storage_order = TYPE_REVERSE_STORAGE_ORDER (first_dimen); dimen = TREE_TYPE (first_dimen); while (TREE_CODE (dimen) == ARRAY_TYPE && TYPE_MULTI_ARRAY_P (dimen)) { i++; + reverse_storage_order = TYPE_REVERSE_STORAGE_ORDER (dimen); dimen = TREE_TYPE (dimen); } info->ndimensions = i; + info->reverse_storage_order = reverse_storage_order; info->element_type = dimen; /* Too many dimensions? Give up generating proper description: yield instead diff --git a/gcc/dwarf2out.cc b/gcc/dwarf2out.cc index d170e18c7409..4db0600a2ea7 100644 --- a/gcc/dwarf2out.cc +++ b/gcc/dwarf2out.cc @@ -23179,8 +23179,7 @@ gen_descr_array_type_die (tree type, struct array_descr_info *info, gen_type_die (info->element_type, context_die); add_type_attribute (array_die, info->element_type, TYPE_UNQUALIFIED, - TREE_CODE (type) == ARRAY_TYPE - && TYPE_REVERSE_STORAGE_ORDER (type), + info->reverse_storage_order, context_die); if (get_AT (array_die, DW_AT_name)) diff --git a/gcc/dwarf2out.h b/gcc/dwarf2out.h index 35898874c0a6..c2834d50761e 100644 --- a/gcc/dwarf2out.h +++ b/gcc/dwarf2out.h @@ -461,6 +461,7 @@ struct array_descr_info tree associated; tree stride; tree rank; + bool reverse_storage_order; bool stride_in_bits; struct array_descr_dimen { From a8db0601be315849a70358333013ef7dffa7a800 Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Mon, 21 Sep 2026 23:44:19 +0200 Subject: [PATCH 307/584] Fix wrong optimization of non-byte-aligned array component with -O2 The -ftree-loop-distribute-patterns pass may generate calls to memcpy whose source is an array component that is not byte aligned. This prevents the loops from being considered for such a generation as soon as they contain a data reference that is not addressable. gcc/ * tree-loop-distribution.cc (loop_distribution::classify_partition): Disqualify the partition for builtins it it contains nonaddressable data references. --- gcc/tree-loop-distribution.cc | 1 + 1 file changed, 1 insertion(+) diff --git a/gcc/tree-loop-distribution.cc b/gcc/tree-loop-distribution.cc index dff8b72e40be..f7c68defcf17 100644 --- a/gcc/tree-loop-distribution.cc +++ b/gcc/tree-loop-distribution.cc @@ -1921,6 +1921,7 @@ loop_distribution::classify_partition (loop_p loop, /* Perform general partition disqualification for builtins. */ if (volatiles_p + || has_nonaddressable_dataref_p || !flag_tree_loop_distribute_patterns) return has_reduction; From c4a80f2d336b8fb78cc97f9107981119b1eff30b Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Mon, 21 Sep 2026 23:46:34 +0200 Subject: [PATCH 308/584] RISC-V: Fix ICE on array with negative low bound in 32-bit mode The included Ada testcase trips on the failure of the assertion present on line 6848 in riscv_flatten_aggregate_field: n_elts = 1 + tree_to_uhwi (TYPE_MAX_VALUE (index)) - tree_to_uhwi (TYPE_MIN_VALUE (index)); gcc_assert (n_elts >= 0); The problem is that the computation of the number of elements is performed in HOST_WIDE_INT, which does not reproduce the wraparound phenomenon of the 32-bit sizetype index that happens when the low bound is negative and the high bound is not. The correct computation is implemented by tree.cc:array_type_nelts_top but it is done on trees, while using wide-ints is sufficient in this case. gcc/ * config/riscv/riscv.cc (riscv_flatten_aggregate_field) : Perform the computation of the number of elements using the precision of the index type instead of using HOST_WIDE_INT. gcc/testsuite/ * gnat.dg/array44.adb: New test. --- gcc/config/riscv/riscv.cc | 14 +++++++------- gcc/testsuite/gnat.dg/array44.adb | 19 +++++++++++++++++++ 2 files changed, 26 insertions(+), 7 deletions(-) create mode 100644 gcc/testsuite/gnat.dg/array44.adb diff --git a/gcc/config/riscv/riscv.cc b/gcc/config/riscv/riscv.cc index b676292ca566..87c24e5dcc15 100644 --- a/gcc/config/riscv/riscv.cc +++ b/gcc/config/riscv/riscv.cc @@ -6807,7 +6807,6 @@ riscv_flatten_aggregate_field (const_tree type, riscv_aggregate_field *fields, case ARRAY_TYPE: { - HOST_WIDE_INT n_elts; riscv_aggregate_field subfields[8]; tree index = TYPE_DOMAIN (type); tree elt_size = TYPE_SIZE_UNIT (TREE_TYPE (type)); @@ -6828,9 +6827,9 @@ riscv_flatten_aggregate_field (const_tree type, riscv_aggregate_field *fields, || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST || !index || !TYPE_MAX_VALUE (index) - || !tree_fits_uhwi_p (TYPE_MAX_VALUE (index)) + || TREE_CODE (TYPE_MAX_VALUE (index)) != INTEGER_CST || !TYPE_MIN_VALUE (index) - || !tree_fits_uhwi_p (TYPE_MIN_VALUE (index)) + || TREE_CODE (TYPE_MIN_VALUE (index)) != INTEGER_CST || !tree_fits_uhwi_p (elt_size)) return -1; @@ -6843,11 +6842,12 @@ riscv_flatten_aggregate_field (const_tree type, riscv_aggregate_field *fields, if (n_subfields <= 0) return -1; - n_elts = 1 + tree_to_uhwi (TYPE_MAX_VALUE (index)) - - tree_to_uhwi (TYPE_MIN_VALUE (index)); - gcc_assert (n_elts >= 0); + const wide_int max = wi::to_wide (TYPE_MAX_VALUE (index)); + const wide_int min = wi::to_wide (TYPE_MIN_VALUE (index)); + const wide_int n_elts = max - min + 1; + gcc_assert (wi::fits_uhwi_p (n_elts)); - for (HOST_WIDE_INT i = 0; i < n_elts; i++) + for (unsigned HOST_WIDE_INT i = 0; i < n_elts.to_uhwi (); i++) for (int j = 0; j < n_subfields; j++) { if (n >= max_aggregate_field) diff --git a/gcc/testsuite/gnat.dg/array44.adb b/gcc/testsuite/gnat.dg/array44.adb new file mode 100644 index 000000000000..149d9c0bdb01 --- /dev/null +++ b/gcc/testsuite/gnat.dg/array44.adb @@ -0,0 +1,19 @@ +-- { dg-do compile } +-- { dg-options "-gnata" } + +procedure Array44 is + + type Buffer_Type is array (Integer range -1 .. 0) of Natural range 0 .. 255; + + type U is record + Buffer : Buffer_Type; + end record; + + function F (Src : in Buffer_Type) return U is ((Buffer => Src)); + + Src : constant Buffer_Type := (others => 1); + Dst : constant U := F (Src); + +begin + pragma Assert (Dst.Buffer (0) = 1); +end; From f008f03eff80fea9e8ed814c280a792cccf8fc94 Mon Sep 17 00:00:00 2001 From: GCC Administrator Date: Tue, 22 Sep 2026 00:16:40 +0000 Subject: [PATCH 309/584] Daily bump. --- gcc/ChangeLog | 148 ++++++++++++++++++++++++++++++++++++++++ gcc/DATESTAMP | 2 +- gcc/ada/ChangeLog | 5 ++ gcc/algol68/ChangeLog | 21 ++++++ gcc/c/ChangeLog | 5 ++ gcc/cobol/ChangeLog | 21 ++++++ gcc/cp/ChangeLog | 10 +++ gcc/fortran/ChangeLog | 49 +++++++++++++ gcc/m2/ChangeLog | 9 +++ gcc/testsuite/ChangeLog | 123 +++++++++++++++++++++++++++++++++ libcpp/ChangeLog | 7 ++ libgcobol/ChangeLog | 9 +++ libgomp/ChangeLog | 5 ++ libstdc++-v3/ChangeLog | 73 ++++++++++++++++++++ 14 files changed, 486 insertions(+), 1 deletion(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index c7190a9517a5..e257e7d5dd3c 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,151 @@ +2026-09-21 Eric Botcazou + + * config/riscv/riscv.cc (riscv_flatten_aggregate_field) : + Perform the computation of the number of elements using the precision + of the index type instead of using HOST_WIDE_INT. + +2026-09-21 Eric Botcazou + + * tree-loop-distribution.cc (loop_distribution::classify_partition): + Disqualify the partition for builtins it it contains nonaddressable + data references. + +2026-09-21 Eric Botcazou + + * dwarf2out.h (struct array_descr_info): Add reverse_storage_order. + * dwarf2out.cc (gen_descr_array_type_die): Pass it in the call to + add_type_attribute instead of using TYPE_REVERSE_STORAGE_ORDER. + +2026-09-21 Ancheng.Qiao + + * config/riscv/riscv.cc (riscv_expand_prologue): Fold into the + cm.push reserve only as many callee-saved FPRs as it can hold by + dividing the additional reserve by UNITS_PER_FP_REG. + (riscv_expand_epilogue): Likewise. + +2026-09-21 Matt Turner + + PR middle-end/66462 + * builtins.cc (fold_builtin_fpclassify): Expand using the + classification built-ins when their optabs are available. + +2026-09-21 Matt Turner + + PR middle-end/66462 + * config/aarch64/aarch64.md (cmp_swp__reg): Add a + parameterized name. + (isinf2): Use GPF_HF_BF and handle the 16-bit formats. + (isfinite2): Likewise. + (isnan2): Likewise. + +2026-09-21 Matt Turner + + PR middle-end/66462 + * config/aarch64/aarch64.md (isnormal2): Add new expander. + * config/aarch64/iterators.md (GPF_HF_BF): New mode iterator. + (mantissa_bits): Add HF and BF. + (V_INT_EQUIV): Add BF. + +2026-09-21 Matt Turner + + * config/aarch64/aarch64.md (*extend2_aarch64): + Guard the smov alternative with base_simd rather than fp. + (*zero_extend2_aarch64): Likewise for umov. + +2026-09-21 Matt Turner + + PR middle-end/66462 + * config/alpha/alpha-protos.h (enum alpha_fp_class): New. + (alpha_expand_fp_classify): Declare. + * config/alpha/alpha.cc (alpha_expand_fp_classify): New function. + * config/alpha/alpha.md (isfinite2, isinf2) + (isnan2, isnormal2): New expanders. + +2026-09-21 Richard Biener + Claude Opus 5 + + PR tree-optimization/113703 + PR tree-optimization/127515 + * tree-ssa-loop-ivopts.cc (iv_elimination_compare_lt): Also record + A + 1 when matching the number of iterations. Convert it to OFF_TYPE + as a whole, compute B + 1 in OFF_TYPE and require both to be + non-negative scaled offsets that do not overflow. Build the bound + out of them instead of A and B. + +2026-09-21 Alfie Richards + + PR target/127494 + * config/riscv/riscv-v.cc (autovectorize_vector_modes): + Restore previous behaviour. + +2026-09-21 Richard Biener + + PR tree-optimization/127475 + * tree-vect-loop.cc (vectorizable_induction): Use + signed_or_unsigned_type_for to get the step vectype. + +2026-09-21 Richard Biener + + PR ipa/127479 + * lto-streamer-out.cc (output_cfg): Output predecessor edges. + * lto-streamer-in.cc (input_cfg): Input predecessor edges. + +2026-09-21 Josef Melcr + + PR ipa/127104 + * internal-fn.def (ASSUME): Downgrade from const to pure. + +2026-09-21 Kyrylo Tkachov + + * genextract.cc (locstr): Make it a string of bytes. + (UPPER_OFFSET, MISSING_OPERAND_CHAR): Remove. + (ENCODE_PATH_STEP, MISSING_OPERAND_STEP, MAX_PATH_INDEX): New macros. + (accum_extract::pathstr): Hold bytes. + (push_pathstr_operand): Encode the step as a number and check that + the index fits. + (VEC_safe_set_locstr, VEC_char_to_string, add_path, gen_insn): Update + for the byte paths. + (print_string_literal): Remove. + (print_extractions): Emit the paths as an array of numbers and walk + them without the character ranges. + +2026-09-21 Christophe Lyon + + * configure.ac: Replace 'ret' with '$insn'. + * configure: Regenerate. + +2026-09-21 Uros Bizjak + + PR target/127461 + * config/i386/mmx.md (negv2qi2): Use optimize_size instead of + optimize_function_for_size_p (cfun) in the enabled attribute. + (v2qi3): Ditto. + +2026-09-21 Artemiy Volkov + + * match.pd: New rule to fold ((X >> C1) & C2) << C3. + +2026-09-21 Jakub Jelinek + + PR target/127498 + * config/i386/sse.md (3 any_rotate:VI1_AVX512_3264): Add + TARGET_AVX2 to condition. + +2026-09-21 Kyrylo Tkachov + + PR rtl-optimization/127445 + * function.cc (gen_call_used_regs_seq): Return whether a zeroing + sequence was emitted. Do not update the exit block uses here. + (pass_zero_call_used_regs::execute): Call + df_update_entry_exit_and_calls once when a sequence was emitted. + +2026-09-21 Naveen + + PR tree-optimization/98984 + * match.pd: Fold integer-float-integer conversions when the + intermediate floating-point significand covers the final integer + precision under -fno-trapping-math. + 2026-09-20 Matt Turner * config/alpha/alpha.cc (alpha_expand_movmisalign): Derive the diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index 286689204f27..e9b7161d4a77 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20260921 +20260922 diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index bf5091927d5e..7696c45923e2 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,8 @@ +2026-09-21 Eric Botcazou + + * gcc-interface/misc.cc (gnat_get_array_descr_info): Return the + TYPE_REVERSE_STORAGE_ORDER flag of the underlying array type. + 2026-09-08 Kael Andrew Alonzo Franco PR middle-end/126622 diff --git a/gcc/algol68/ChangeLog b/gcc/algol68/ChangeLog index f9cb2823c7a9..653e012620a2 100644 --- a/gcc/algol68/ChangeLog +++ b/gcc/algol68/ChangeLog @@ -1,3 +1,24 @@ +2026-09-21 Jose E. Marchesi + + * a68-parser-modes.cc (a68_resolve_equivalent): Rename from + resolve_equivalent and made global. + (resolve_eq_members): Adapt calls to resolve_equivalent + accordingly. + (resolve_eq_tags): Likewise. + (bind_modes): Likewise. + (compute_derived_modes): Likewise. + * a68.h: Add prototype for a68_resolve_equivalent. + * a68-parser-extract.cc (a68_extract_revelation): Resolve + equivalences in imported modes. + +2026-09-21 Jose E. Marchesi + + * a68-parser-attrs.def (COMPLEX_SYMBOL): Remove. + * a68-parser-bottom-up.cc (reduce_declarers): Remove reduction of + COMPLEX_SYMBOL. + (reduce_declarers): Do not handle COMPLEX_SYMBOL. + * a68-parser.cc (a68_dont_mark_here): Likewise. + 2026-09-20 Jose E. Marchesi * a68-low-units.cc (a68_lower_denotation): strtoul can return diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog index 4df87ae981e9..a06e4f0653e4 100644 --- a/gcc/c/ChangeLog +++ b/gcc/c/ChangeLog @@ -1,3 +1,8 @@ +2026-09-21 Jakub Jelinek + + * c-decl.cc (names_builtin_p): Return 1 for + RID_BUILTIN_BITREVERSEG and RID_BUILTIN_BSWAPG. + 2026-09-16 Jakub Jelinek PR c/127383 diff --git a/gcc/cobol/ChangeLog b/gcc/cobol/ChangeLog index 66461a148bc7..1aac95e28884 100644 --- a/gcc/cobol/ChangeLog +++ b/gcc/cobol/ChangeLog @@ -1,3 +1,24 @@ +2026-09-21 Robert Dubner + + * genapi.cc (actually_create_the_static_field): Use the + new expand_expanded routine. + * symbols.cc (expand_picture): Add space to accommodate the six + additional pre-processing characters. + (expand_expanded): Append compile-time data to the end of numeric- + edited PICTURE strings. + * symbols.h (redefined_token): Formatting. + (class current_tokens_t): Formatting. + (expand_expanded): New declaration. + * util.cc (cbl_field_t::encode_numeric): Use expand_expanded(). + +2026-09-21 James K. Lowden + + * parse.y: Remove unused function. + +2026-09-21 Xavier Del Campo Romero + + * gcobc: Remove stale logic. + 2026-09-19 Robert Dubner * parse.y: Comment out unused passby_str() function. diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index de3b8ac93e5e..6688d9e4a28e 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,13 @@ +2026-09-21 Jakub Jelinek + + PR c++/127493 + * reflect.cc (eval_source_location_of): Call maybe_get_first_fn. + +2026-09-21 Jakub Jelinek + + * cp-objcp-common.cc (names_builtin_p): Return 1 for + RID_BUILTIN_BITREVERSEG and RID_BUILTIN_BSWAPG. + 2026-09-20 Joshua Berne PR c++/127281 diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog index 428e94186a12..45013116f338 100644 --- a/gcc/fortran/ChangeLog +++ b/gcc/fortran/ChangeLog @@ -1,3 +1,52 @@ +2026-09-21 Mikael Morin + + PR fortran/127448 + * trans-array.cc (is_pointer_array): Remove redundant condition. + (is_span_addressed_array): For polymorphic arrays, return false if + the array is known to be contiguous. + * trans-types.cc (gfc_get_derived_type): Also set the + GFC_DECL_PTR_ARRAY_P flag for _data fields of class containers + corresponding to polymorphic array pointers. + +2026-09-21 Mikael Morin + + * trans-array.cc (gfc_get_dataptr_offset): Move guess of decl + for span from function argument... + (build_array_ref): ... to function body. Only set the decl if it + was empty on input and wasn't set by a previous guess. + +2026-09-21 Mikael Morin + + * trans-array.cc (span_addressed_array): Change return type to bool + and rename to ... + (is_span_addressed_array): ... this. + (gfc_get_dataptr_offset): Separate the predicate from the choice + between NULL_TREE and the input array. + (gfc_get_array_span, gfc_conv_scalarized_array_ref, + gfc_conv_array_ref): Update callers. + +2026-09-21 Mikael Morin + + * trans.cc (gfc_build_spanned_array_ref): Remove condition guarding + pointer dereference generation. + * trans-array.cc (gfc_get_dataptr_offset): Remove now redundant + pointer dereference generation. + +2026-09-21 Tobias Burnus + + * openmp.cc (gfc_match_omp_clauses): Rename argument 'first' + to first_no_comma for clarity. + (match_omp, gfc_match_omp_allocate, gfc_match_omp_assume, + gfc_match_omp_assumes, gfc_match_omp_critical, + gfc_match_omp_depobj, gfc_match_omp_flush, + gfc_match_omp_declare_simd, gfc_match_omp_declare_mapper, + gfc_match_omp_declare_reduction, gfc_match_omp_declare_target, + gfc_match_omp_thread_group_private, gfc_match_omp_requires, + gfc_match_omp_scan, gfc_match_omp_atomic, + gfc_match_omp_cancel_kind, gfc_match_omp_end_nowait, + gfc_match_omp_end_single): Permit comma between directive name + and clause name. + 2026-09-18 Paul Thomas PR fortran/127146 diff --git a/gcc/m2/ChangeLog b/gcc/m2/ChangeLog index 40ec0b6be7cc..19b3f92dcfdb 100644 --- a/gcc/m2/ChangeLog +++ b/gcc/m2/ChangeLog @@ -1,3 +1,12 @@ +2026-09-21 Gaius Mulley + + PR modula2/127469 + * gm2-compiler/M2Quads.mod (BuildConstructor): Check for + tok UnknownTokenNo and if not equal generate an error message + at tok stating the type is unknown. + * gm2-compiler/PCSymBuild.mod (WalkConvert): Check totype for + NulSym and if so return FALSE. + 2026-09-17 Gaius Mulley PR modula2/126174 diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 2814823fae42..6d37df1278b4 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,126 @@ +2026-09-21 Eric Botcazou + + * gnat.dg/array44.adb: New test. + +2026-09-21 Ancheng.Qiao + + * gcc.target/riscv/zcmp_fpr_save_below_sp.c: New test. Compile an + FP-register-heavy function at -Os with Zcmp and check that no + callee-saved FPR is saved at a negative offset of SP. + +2026-09-21 Robert Dubner + + * cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.cob: New test. + * cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.out: New test. + +2026-09-21 Jose E. Marchesi + + * algol68/execute/modules/program-28.a68: New test. + * algol68/execute/modules/module28.a68: New file. + +2026-09-21 Mikael Morin + + PR fortran/127448 + * gfortran.dg/pointer_assign_17.f90: New test. + +2026-09-21 Matt Turner + + PR middle-end/66462 + * gcc.target/aarch64/pr66462-2.c: New test. + * gcc.target/alpha/fp-classify-5.c: New test. + * gcc.target/alpha/fp-classify-6.c: New test. + +2026-09-21 Matt Turner + + PR middle-end/66462 + * gcc.target/aarch64/pr66462.c: Add _Float16 and __bf16 tests for + isinf, isfinite and isnan. + +2026-09-21 Matt Turner + + PR middle-end/66462 + * gcc.target/aarch64/pr66462.c: Add tests for isnormal, including + _Float16 and __bf16. + +2026-09-21 Matt Turner + + * gcc.target/aarch64/nosimd-extend.c: New test. + +2026-09-21 Matt Turner + + PR middle-end/66462 + * gcc.target/alpha/fp-classify-1.c: New test. + * gcc.target/alpha/fp-classify-2.c: New test. + * gcc.target/alpha/fp-classify-3.c: New test. + * gcc.target/alpha/fp-classify-4.c: New test. + +2026-09-21 Richard Biener + Claude Opus 5 + + PR tree-optimization/113703 + PR tree-optimization/127515 + * gcc.dg/torture/pr113703-5.c: New test. + * gcc.dg/torture/pr113703-6.c: New test. + +2026-09-21 Richard Biener + + PR tree-optimization/127475 + * gcc.dg/vect/vect-pr127475.c: New testcase. + +2026-09-21 Richard Biener + + PR ipa/127479 + * gcc.dg/lto/pr127479_0.c: New testcase. + +2026-09-21 Uros Bizjak + + PR target/127461 + * gcc.target/i386/pr127461.c: New test. + +2026-09-21 Artemiy Volkov + + * gcc.dg/tree-ssa/match-bit-extract-shift.c: New test. + +2026-09-21 Jakub Jelinek + + PR c++/127493 + * g++.dg/reflect/source_location_of1.C (struct G, struct H): New + types. Add asserts for source_location_of of member function and + member function template. + * g++.dg/reflect/source_location_of2.C: Expect implicitEqLine rather + than 0 for line of ^^ImplicitEq::operator==. + +2026-09-21 Jakub Jelinek + + PR target/127498 + * gcc.target/i386/gfni-pr127498.c: New test. + * gcc.target/i386/shift-gf2p8affine-5.c: Use -mavx2 in dg-options + instead of -mavx. Expect 46 insns instead of 31. + +2026-09-21 Jakub Jelinek + + * c-c++-common/builtin-bswapg-1.c: Test + __has_builtin(__builtin_bswapg). + * c-c++-common/builtin-bitreverseg-1.c: Test + __has_builtin(__builtin_bitreverseg). + +2026-09-21 Kyrylo Tkachov + + PR rtl-optimization/127445 + * gcc.target/aarch64/pr127445.c: New test. + +2026-09-21 Kyrylo Tkachov + + * gcc.dg/vect/vect-sat-trunc-range-precision-1.c: Do not force + execution. + * gcc.dg/vect/vect-sat-trunc-shift-sign-source-1.c: Likewise. + +2026-09-21 Naveen + + PR tree-optimization/98984 + * gcc.dg/tree-ssa/pr98984.c: New test. + * gcc.dg/tree-ssa/pr98984-2.c: New test. + 2026-09-20 Matt Turner * gcc.target/alpha/movmisalign-si.c: New test. diff --git a/libcpp/ChangeLog b/libcpp/ChangeLog index abca2c09a0e7..c1ba25d91381 100644 --- a/libcpp/ChangeLog +++ b/libcpp/ChangeLog @@ -1,3 +1,10 @@ +2026-09-21 Léo Hardt + + PR preprocessor/121508 + PR preprocessor/123339 + * macro.cc (builtin_has_include_1): Bail early if + not on a preprocessor directive. + 2026-09-18 Jakub Jelinek * makeucnid.cc (write_copyright): Update Unicode Copyright years. diff --git a/libgcobol/ChangeLog b/libgcobol/ChangeLog index 9a28f34f0116..2669fb410919 100644 --- a/libgcobol/ChangeLog +++ b/libgcobol/ChangeLog @@ -1,3 +1,12 @@ +2026-09-21 Robert Dubner + + * libgcobol.cc (int128_to_field): Remove rdigits formal parameter. + (__gg__int128_to_ascii_numeric_display): Likewise. + * valconv.cc (__gg__string_to_numeric_edited): Complete rewrite to + use parameters appended by expand_expanded(). + * valconv.h: Remove rdigits format parameter from + __gg__int128_to_ascii_numeric_display. + 2026-09-18 Robert Dubner * libgcobol.cc (do_the_dl_thing): New .so policy. diff --git a/libgomp/ChangeLog b/libgomp/ChangeLog index d39a514f463f..96b34856a7ad 100644 --- a/libgomp/ChangeLog +++ b/libgomp/ChangeLog @@ -1,3 +1,8 @@ +2026-09-21 Tobias Burnus + + * libgomp.texi (OpenMP 5.2 Impl. Status): Mark comma between + directive name and first clause as implemented in Fortran. + 2026-09-11 Tobias Burnus * libgomp.texi (omp_control_tool): Add example interface for calling diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index fd9e2983d55d..a7eb187b2315 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,76 @@ +2026-09-21 Tomasz Kamiński + + PR libstdc++/82749 + PR libstdc++/125548 + * doc/xml/manual/using.xml + (_GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS) + (_GLIBCXX_USE_RESULT_TYPE_FOR_PIECEWISE_DENSITIES): Replace with... + (_GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS): Add entry. + * doc/html/manual/using_macros.html: Regenrate. + * include/bits/c++config (_GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS) + [__cplusplus >= 201103L]: Define to the value 1 if not already defined. + * include/bits/random.h + (__detail::__piecewise_distributions_storage) + (__detail::__piecewise_distributions_storage_t): Adjust to depend + on _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS value. + (piecewise_constant_distribution::_CalcType) + (piecewise_linear_distribution::_CalcType) + (piecewise_constant_distribution::param_type::densities) + (piecewise_linear_distribution::param_type::densities): + Check for non-zero value of _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS + instead of defintion of _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS and + reorder branches. + * include/bits/random.tcc + (piecewise_constant_distribution::param_type::param_type) + (piecewise_constant_distribution::param_type::param_type): Likewise. + * testsuite/26_numerics/random/piecewise_constant_distribution/operators/accessors.cc: + Replace checks for _GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS + _GLIBCXX_USE_RESULT_TYPE_FOR_PIECEWISE_DENSITIES defintions + with checks of _GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS values. + * testsuite/26_numerics/random/piecewise_linear_distribution/operators/accessors.cc: + Likewise. + * testsuite/26_numerics/random/piecewise_linear_distribution/cons/pr125548.cc: + Likewise. + * testsuite/26_numerics/random/piecewise_constant_distribution/operators/accessors_fallback.cc: + Replace -D_GLIBCXX_USE_OLD_PIECEWISE_DISTRIBUTIONS with + -D_GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS=0. + * testsuite/26_numerics/random/piecewise_linear_distribution/operators/accessors_fallback.cc: + Likewise. + * testsuite/26_numerics/random/piecewise_linear_distribution/cons/pr125548_fallback.cc: + Likewise. + * testsuite/26_numerics/random/piecewise_constant_distribution/cons/input_type_fallback_neg.cc: + Likewise. + * testsuite/26_numerics/random/piecewise_linear_distribution/cons/input_type_fallback_neg.cc: + Likewise. + * testsuite/26_numerics/random/piecewise_constant_distribution/operators/accessors_exact.cc: + Replace -D_GLIBCXX_USE_RESULT_TYPE_FOR_PIECEWISE_DENSITIES with + -D_GLIBCXX_USE_NEW_PIECEWISE_DISTRIBUTIONS=2. + * testsuite/26_numerics/random/piecewise_linear_distribution/operators/accessors_exact.cc: + Likewise. + +2026-09-21 Tomasz Kamiński + + * include/bits/random.h (_Select_uint_least_t): Move primary + template and most of partial specializations to... + * include/bits/uniform_int_dist.h (_Select_uint_least_t): + Extracted from bits/random.h. + (uniform_int_distribution::_S_nd): Replace _Up and _Wp template + paramteters with Select_uint_least_t of _Bits and 2 * _Bits + respectively. + (uniform_int_distribution::operator()): Adjust calls to _S_nd + to pass only _Bits, and remove checks for presence of + __UINT64_TYPE__ and __UINT32_TYPE__ types. + +2026-09-21 Tomasz Kamiński + + * include/bits/uniform_int_dist.h + (uniform_int_distribution::operator()): Use _S_nd (Lemire's + algorithm) if __urngrange is power of two. + (uniform_int_distribution::_S_nd): Add _Bits parameter. Mask + the result of conversion of __product to _Up to lowest _Bits. + * testsuite/26_numerics/random/uniform_int_distribution/operators/values.cc: + Add testDiscreteDist for ranlux24 and ranlux48 engines. + 2026-09-20 Gerald Pfeifer * doc/xml/manual/io.xml: New URL for Josuttis' "The C++ Standard From 5b3356d8fafc56d380693b7c55e06f8f84830e5a Mon Sep 17 00:00:00 2001 From: Andrea Pinski Date: Mon, 21 Sep 2026 19:56:09 -0700 Subject: [PATCH 310/584] testsuite: Fix has-include-1.c After r17-4537-g059231fb8a42ea, two error messages instead of just one is emitted. So let's look for both of them. Pushed as obvious after testing to make sure the testcase passes now for both C and C++. gcc/testsuite/ChangeLog: * c-c++-common/gomp/has-include-1.c: Add second dg-error. Signed-off-by: Andrea Pinski --- gcc/testsuite/c-c++-common/gomp/has-include-1.c | 1 + 1 file changed, 1 insertion(+) diff --git a/gcc/testsuite/c-c++-common/gomp/has-include-1.c b/gcc/testsuite/c-c++-common/gomp/has-include-1.c index bb1b90526857..9532208b84b8 100644 --- a/gcc/testsuite/c-c++-common/gomp/has-include-1.c +++ b/gcc/testsuite/c-c++-common/gomp/has-include-1.c @@ -4,5 +4,6 @@ void foo (void) { #pragma omp parallel if (__has_include ("")) /* { dg-error "used outside of preprocessing directive" } */ +/* { dg-error "a function" "" { target *-*-* } .-1 } */ ; } From ca5e88d7531aa673a937007a0e21a141eee743e9 Mon Sep 17 00:00:00 2001 From: Pan Li Date: Fri, 18 Sep 2026 16:26:51 +0800 Subject: [PATCH 311/584] RISC-V: Allow RVV register overlap for vfwadd.wv There are two constraint of vfwadd.wv, aka 2 * SEW = 2 * SEW + SEW form. 1. The vs1 can overlap to the highest part of the vd. 2. The vs1 cannot overlap the group of vs2. gcc/ChangeLog: * config/riscv/constraints.md (Wn4): New constraint for the vector register which doesn't overlap the register group of the operand 4. * config/riscv/vector.md: Take the Wn4 constraint for the operand 3 and the Wvr constraint for the operand 4 of the vfwadd.wv. Signed-off-by: Pan Li --- gcc/config/riscv/constraints.md | 6 ++++++ gcc/config/riscv/vector.md | 20 ++++++++++---------- 2 files changed, 16 insertions(+), 10 deletions(-) diff --git a/gcc/config/riscv/constraints.md b/gcc/config/riscv/constraints.md index 38f46d8fec5c..666d5a246ceb 100644 --- a/gcc/config/riscv/constraints.md +++ b/gcc/config/riscv/constraints.md @@ -254,6 +254,12 @@ "riscv_vector::riscv_v_widen_non_overlap_constraint_ok (regno, mode, ref_regno, ref_mode)" "3") +;; Same as Wn3 but target operand 4, aka ref_regno and ref_mode come from operand 4. +(define_register_constraint "Wn4" "TARGET_VECTOR ? V_REGS : NO_REGS" + "Vector reg not overlapping the operand 4 register group" + "riscv_vector::riscv_v_widen_non_overlap_constraint_ok (regno, mode, ref_regno, ref_mode)" + "4") + ;; This constraint is used to match instruction "csrr %0, vlenb" which is generated in "mov". ;; VLENB is a run-time constant which represent the vector register length in bytes. ;; BYTES_PER_RISCV_VECTOR represent runtime invariant of vector register length in bytes. diff --git a/gcc/config/riscv/vector.md b/gcc/config/riscv/vector.md index 83a2c8f346d7..023668ceadae 100644 --- a/gcc/config/riscv/vector.md +++ b/gcc/config/riscv/vector.md @@ -7345,23 +7345,23 @@ (symbol_ref "riscv_vector::get_frm_mode (operands[9])"))]) (define_insn "@pred_single_widen_add" - [(set (match_operand:VWEXTF 0 "register_operand" "=&vr, &vr") + [(set (match_operand:VWEXTF 0 "register_operand" "=vr, vr, vd, vd") (if_then_else:VWEXTF (unspec: - [(match_operand: 1 "vector_mask_operand" "vmWc1,vmWc1") - (match_operand 5 "vector_length_operand" " rvl, rvl") - (match_operand 6 "const_int_operand" " i, i") - (match_operand 7 "const_int_operand" " i, i") - (match_operand 8 "const_int_operand" " i, i") - (match_operand 9 "const_int_operand" " i, i") + [(match_operand: 1 "vector_mask_operand" "Wc1,Wc1, vm, vm") + (match_operand 5 "vector_length_operand" "rvl,rvl,rvl,rvl") + (match_operand 6 "const_int_operand" " i, i, i, i") + (match_operand 7 "const_int_operand" " i, i, i, i") + (match_operand 8 "const_int_operand" " i, i, i, i") + (match_operand 9 "const_int_operand" " i, i, i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM) (reg:SI FRM_REGNUM)] UNSPEC_VPREDICATE) (plus:VWEXTF (float_extend:VWEXTF - (match_operand: 4 "register_operand" " vr, vr")) - (match_operand:VWEXTF 3 "register_operand" " vr, vr")) - (match_operand:VWEXTF 2 "vector_merge_operand" " vu, 0")))] + (match_operand: 4 "register_operand" "Wvr,Wvr,Wvr,Wvr")) + (match_operand:VWEXTF 3 "register_operand" "Wn4,Wn4,Wn4,Wn4")) + (match_operand:VWEXTF 2 "vector_merge_operand" " vu, 0, vu, 0")))] "TARGET_VECTOR" "vfwadd.wv\t%0,%3,%4%p1" [(set_attr "type" "vfwalu") From 49937a656450a8cedbce3b4aba4aafe14ec3352f Mon Sep 17 00:00:00 2001 From: Pan Li Date: Fri, 18 Sep 2026 16:27:05 +0800 Subject: [PATCH 312/584] RISC-V: Add test cases for vfwadd.wv reg overlap Add test cases for the register group overlap of the vfwadd.wv, to ensure the narrow operand vs1 will not fall inside the vs2 register group. gcc/testsuite/ChangeLog: * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-m1.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-m2.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-m4.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-mf2.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-mf4.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-m1.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-m2.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-m4.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-mf2.c: New test. Signed-off-by: Pan Li --- .../autovec/group_overlap/vfwadd_wv-f16-m1.c | 20 +++++++++++++++++++ .../autovec/group_overlap/vfwadd_wv-f16-m2.c | 20 +++++++++++++++++++ .../autovec/group_overlap/vfwadd_wv-f16-m4.c | 20 +++++++++++++++++++ .../autovec/group_overlap/vfwadd_wv-f16-mf2.c | 19 ++++++++++++++++++ .../autovec/group_overlap/vfwadd_wv-f16-mf4.c | 19 ++++++++++++++++++ .../autovec/group_overlap/vfwadd_wv-f32-m1.c | 20 +++++++++++++++++++ .../autovec/group_overlap/vfwadd_wv-f32-m2.c | 20 +++++++++++++++++++ .../autovec/group_overlap/vfwadd_wv-f32-m4.c | 20 +++++++++++++++++++ .../autovec/group_overlap/vfwadd_wv-f32-mf2.c | 19 ++++++++++++++++++ 9 files changed, 177 insertions(+) create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-m1.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-m2.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-m4.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-mf2.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-mf4.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-m1.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-m2.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-m4.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-mf2.c diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-m1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-m1.c new file mode 100644 index 000000000000..7abb55a4edda --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-m1.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_0( + __riscv_vsetvlmax_e16m1, + vfloat16m1_t, + vfloat32m2_t, + __riscv_vle16_v_f16m1, + __riscv_vle32_v_f32m2, + __riscv_vfwadd_wv_f32m2, + __riscv_vse32_v_f32m2, + vfwadd_wv, + LOOP_WIDEN_BINARY_BODY_X16) + +/* The narrow source has EMUL == 1, thus the widened destination register + group may overlap it in the highest-numbered part. */ +/* { dg-final { scan-assembler-times {vfwadd\.wv\s+v0,v4,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwadd\.wv\s+v18,v4,v19([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-m2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-m2.c new file mode 100644 index 000000000000..de0773a4da6a --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-m2.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_0( + __riscv_vsetvlmax_e16m2, + vfloat16m2_t, + vfloat32m4_t, + __riscv_vle16_v_f16m2, + __riscv_vle32_v_f32m4, + __riscv_vfwadd_wv_f32m4, + __riscv_vse32_v_f32m4, + vfwadd_wv, + LOOP_WIDEN_BINARY_BODY_X8) + +/* The narrow source has EMUL == 2, thus the widened destination register + group may overlap it in the highest-numbered part. */ +/* { dg-final { scan-assembler-times {vfwadd\.wv\s+v0,v8,v2([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwadd\.wv\s+v16,v16,v0([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-m4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-m4.c new file mode 100644 index 000000000000..fde5840c91b7 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-m4.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_0( + __riscv_vsetvlmax_e16m4, + vfloat16m4_t, + vfloat32m8_t, + __riscv_vle16_v_f16m4, + __riscv_vle32_v_f32m8, + __riscv_vfwadd_wv_f32m8, + __riscv_vse32_v_f32m8, + vfwadd_wv, + LOOP_WIDEN_BINARY_BODY_X4) + +/* The narrow source has EMUL == 4, thus the widened destination register + group may overlap it in the highest-numbered part. */ +/* { dg-final { scan-assembler-times {vfwadd\.wv\s+v16,v0,v20([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwadd\.wv\s+v8,v8,v28([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-mf2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-mf2.c new file mode 100644 index 000000000000..5b868d457bb5 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-mf2.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_0( + __riscv_vsetvlmax_e16m1, + vfloat16mf2_t, + vfloat32m1_t, + __riscv_vle16_v_f16mf2, + __riscv_vle32_v_f32m1, + __riscv_vfwadd_wv_f32m1, + __riscv_vse32_v_f32m1, + vfwadd_wv, + LOOP_WIDEN_BINARY_BODY_X16) + +/* The narrow source has EMUL < 1, thus the widened destination register + group must not overlap it at all. */ +/* { dg-final { scan-assembler-not {vfwadd\.wv\s+(v[0-9]+),v[0-9]+,\1([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-mf4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-mf4.c new file mode 100644 index 000000000000..88fb2dab0fe5 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-mf4.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_0( + __riscv_vsetvlmax_e16m1, + vfloat16mf4_t, + vfloat32mf2_t, + __riscv_vle16_v_f16mf4, + __riscv_vle32_v_f32mf2, + __riscv_vfwadd_wv_f32mf2, + __riscv_vse32_v_f32mf2, + vfwadd_wv, + LOOP_WIDEN_BINARY_BODY_X16) + +/* The narrow source has EMUL < 1, thus the widened destination register + group must not overlap it at all. */ +/* { dg-final { scan-assembler-not {vfwadd\.wv\s+(v[0-9]+),v[0-9]+,\1([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-m1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-m1.c new file mode 100644 index 000000000000..c5a4f010fc6d --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-m1.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_0( + __riscv_vsetvlmax_e32m1, + vfloat32m1_t, + vfloat64m2_t, + __riscv_vle32_v_f32m1, + __riscv_vle64_v_f64m2, + __riscv_vfwadd_wv_f64m2, + __riscv_vse64_v_f64m2, + vfwadd_wv, + LOOP_WIDEN_BINARY_BODY_X16) + +/* The narrow source has EMUL == 1, thus the widened destination register + group may overlap it in the highest-numbered part. */ +/* { dg-final { scan-assembler-times {vfwadd\.wv\s+v0,v4,v1([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwadd\.wv\s+v18,v4,v19([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-m2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-m2.c new file mode 100644 index 000000000000..43fe20860ef5 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-m2.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_0( + __riscv_vsetvlmax_e32m2, + vfloat32m2_t, + vfloat64m4_t, + __riscv_vle32_v_f32m2, + __riscv_vle64_v_f64m4, + __riscv_vfwadd_wv_f64m4, + __riscv_vse64_v_f64m4, + vfwadd_wv, + LOOP_WIDEN_BINARY_BODY_X8) + +/* The narrow source has EMUL == 2, thus the widened destination register + group may overlap it in the highest-numbered part. */ +/* { dg-final { scan-assembler-times {vfwadd\.wv\s+v0,v8,v2([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwadd\.wv\s+v16,v16,v0([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-m4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-m4.c new file mode 100644 index 000000000000..d4d2caa09f0f --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-m4.c @@ -0,0 +1,20 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_0( + __riscv_vsetvlmax_e32m4, + vfloat32m4_t, + vfloat64m8_t, + __riscv_vle32_v_f32m4, + __riscv_vle64_v_f64m8, + __riscv_vfwadd_wv_f64m8, + __riscv_vse64_v_f64m8, + vfwadd_wv, + LOOP_WIDEN_BINARY_BODY_X4) + +/* The narrow source has EMUL == 4, thus the widened destination register + group may overlap it in the highest-numbered part. */ +/* { dg-final { scan-assembler-times {vfwadd\.wv\s+v16,v0,v20([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwadd\.wv\s+v8,v8,v28([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-mf2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-mf2.c new file mode 100644 index 000000000000..df0ad4d46084 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-mf2.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_0( + __riscv_vsetvlmax_e32m1, + vfloat32mf2_t, + vfloat64m1_t, + __riscv_vle32_v_f32mf2, + __riscv_vle64_v_f64m1, + __riscv_vfwadd_wv_f64m1, + __riscv_vse64_v_f64m1, + vfwadd_wv, + LOOP_WIDEN_BINARY_BODY_X16) + +/* The narrow source has EMUL < 1, thus the widened destination register + group must not overlap it at all. */ +/* { dg-final { scan-assembler-not {vfwadd\.wv\s+(v[0-9]+),v[0-9]+,\1([^0-9]|$)} } } */ From 2b308b5eb032fe5f1786487af49bf736627b885f Mon Sep 17 00:00:00 2001 From: Pan Li Date: Sat, 19 Sep 2026 16:41:21 +0800 Subject: [PATCH 313/584] RISC-V: Remove xfail of the vfwadd.wv reg overlap test case Remove the xfail of rvv register move. gcc/testsuite/ChangeLog: * gcc.target/riscv/rvv/base/pr112431-42.c: Remove the xfail of the vmv1r check. Signed-off-by: Pan Li --- gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-42.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-42.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-42.c index fa5dac58a205..1ee5b20a899d 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-42.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr112431-42.c @@ -21,7 +21,7 @@ reduc_plus_float (float *__restrict a, int n) return r; } -/* { dg-final { scan-assembler-not {vmv1r} { xfail riscv*-*-* } } } */ +/* { dg-final { scan-assembler-not {vmv1r} } } */ /* { dg-final { scan-assembler-not {vmv2r} } } */ /* { dg-final { scan-assembler-not {vmv4r} } } */ /* { dg-final { scan-assembler-not {vmv8r} } } */ From 611705766efc7ea1dc2fa01e344db20e06546a27 Mon Sep 17 00:00:00 2001 From: Pan Li Date: Mon, 21 Sep 2026 10:34:22 +0800 Subject: [PATCH 314/584] RISC-V: Fix ICE for widening insn when dest nregs is less than src [PR target/127269] The function riscv_v_widen_constraint_ok asserts the nregs of the dest must be greater than that of the src when they are different. That is not always true, for example the vwmacc.vx with the src comes from the vget of one wider vector register group. Then we may have the dest takes 2 registers while the src takes 4 registers, and result in the ICE as below. during RTL pass: reload pr127269-18.c:14:1: internal compiler error: in riscv_v_widen_constraint_ok, at config/riscv/riscv-v.cc:6575 Thus, take the register overlap as not allowed instead of the assertion when the nregs of the dest is less than that of the src. PR target/127269 gcc/ChangeLog: * config/riscv/riscv-v.cc (riscv_v_widen_constraint_ok): Return false instead of assertion when the nregs of the dest is less than that of the src. Signed-off-by: Pan Li --- gcc/config/riscv/riscv-v.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/gcc/config/riscv/riscv-v.cc b/gcc/config/riscv/riscv-v.cc index faa43f4bf649..dd453aa320b6 100644 --- a/gcc/config/riscv/riscv-v.cc +++ b/gcc/config/riscv/riscv-v.cc @@ -6570,8 +6570,9 @@ riscv_v_widen_constraint_ok (unsigned int regno, machine_mode mode, if (wide_nregs == nregs) return nregs == 1; /* Only allow dest LMUL <= 1. */ + else if (wide_nregs < nregs) + return false; - gcc_checking_assert (wide_nregs > nregs); gcc_checking_assert ((wide_nregs % nregs) == 0); /* No overlap. */ From f6069f819113ad5385993b09581508a05d1bb00c Mon Sep 17 00:00:00 2001 From: Pan Li Date: Mon, 21 Sep 2026 10:34:33 +0800 Subject: [PATCH 315/584] RISC-V: Add test cases for widening insn ICE [PR target/127269] Add the test cases for the ICE of the widening insn when the nregs of the dest is less than that of the src. PR target/127269 gcc/testsuite/ChangeLog: * gcc.target/riscv/rvv/base/pr127269-18.c: New test. * gcc.target/riscv/rvv/base/pr127269-19.c: New test. * gcc.target/riscv/rvv/base/pr127269-20.c: New test. * gcc.target/riscv/rvv/base/pr127269-21.c: New test. * gcc.target/riscv/rvv/base/pr127269-22.c: New test. Signed-off-by: Pan Li --- .../gcc.target/riscv/rvv/base/pr127269-18.c | 14 ++++++++++++++ .../gcc.target/riscv/rvv/base/pr127269-19.c | 14 ++++++++++++++ .../gcc.target/riscv/rvv/base/pr127269-20.c | 14 ++++++++++++++ .../gcc.target/riscv/rvv/base/pr127269-21.c | 14 ++++++++++++++ .../gcc.target/riscv/rvv/base/pr127269-22.c | 14 ++++++++++++++ 5 files changed, 70 insertions(+) create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-18.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-19.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-20.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-21.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-22.c diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-18.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-18.c new file mode 100644 index 000000000000..804d66c0707d --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-18.c @@ -0,0 +1,14 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d -O2" } */ +/* PR target/127269 */ + +#include "riscv_vector.h" + +/* This test is to ensure there is no ICE during compilation. */ + +vint32m2_t +test (vint16m4_t a, vint32m2_t b, size_t vl) +{ + vint16m1_t c = __riscv_vget_v_i16m4_i16m1 (a, 0); + return __riscv_vwmacc_vx_i32m2 (b, 1, c, vl); +} diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-19.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-19.c new file mode 100644 index 000000000000..a67959418d93 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-19.c @@ -0,0 +1,14 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d -O2" } */ +/* PR target/127269 */ + +#include "riscv_vector.h" + +/* This test is to ensure there is no ICE during compilation. */ + +vint32m2_t +test (vint16m8_t a, size_t vl) +{ + vint16m1_t b = __riscv_vget_v_i16m8_i16m1 (a, 3); + return __riscv_vwmul_vv_i32m2 (b, b, vl); +} diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-20.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-20.c new file mode 100644 index 000000000000..d199000d19fb --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-20.c @@ -0,0 +1,14 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d -O2" } */ +/* PR target/127269 */ + +#include "riscv_vector.h" + +/* This test is to ensure there is no ICE during compilation. */ + +vint16m2_t +test (vint8m8_t a, size_t vl) +{ + vint8m1_t b = __riscv_vget_v_i8m8_i8m1 (a, 2); + return __riscv_vsext_vf2_i16m2 (b, vl); +} diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-21.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-21.c new file mode 100644 index 000000000000..d893ebdf1b24 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-21.c @@ -0,0 +1,14 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d -O2" } */ +/* PR target/127269 */ + +#include "riscv_vector.h" + +/* This test is to ensure there is no ICE during compilation. */ + +vfloat32m2_t +test (vfloat16m4_t a, size_t vl) +{ + vfloat16m1_t b = __riscv_vget_v_f16m4_f16m1 (a, 1); + return __riscv_vfwcvt_f_f_v_f32m2 (b, vl); +} diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-22.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-22.c new file mode 100644 index 000000000000..29e4d7706448 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr127269-22.c @@ -0,0 +1,14 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d -O2" } */ +/* PR target/127269 */ + +#include "riscv_vector.h" + +/* This test is to ensure there is no ICE during compilation. */ + +vuint64m4_t +test (vuint32m8_t a, vuint64m4_t b, size_t vl) +{ + vuint32m2_t c = __riscv_vget_v_u32m8_u32m2 (a, 1); + return __riscv_vwaddu_wv_u64m4 (b, c, vl); +} From 59c8c4bbac46570ac36782172ed28569affe42c4 Mon Sep 17 00:00:00 2001 From: Naveen Date: Mon, 21 Sep 2026 20:56:16 -0700 Subject: [PATCH 316/584] tree-optimization: fold abs(x) comparisons with x [PR112626] The patterns account for both undefined-overflow and wrapping-overflow semantics. Comparisons whose result is independent of the value of `x` are folded to constants while the remaining cases are reduced to sign tests. With wrapping overflow, the `INT_MIN` case is handled explicitly using unsigned comparisons. Handle comparisons between unsigned conversions of `abs (x)` and `x`. These transformations are applied only when the conversions have matching unsigned types and the same precision. Sign-test forms are restricted to undefined-overflow semantics; wrapping-overflow variants are left for future work. gcc ChangeLog: PR tree-optimization/112626 * match.pd: Fold comparisons between abs (x) and x including unsigned conversions of both operands. gcc/testsuite/ChangeLog: PR tree-optimization/112626 * gcc.dg/tree-ssa/pr112626.c: New test. * gcc.dg/tree-ssa/pr112626-wrap.c: New test. Signed-off-by: Naveen --- gcc/match.pd | 72 +++++++++++++++++++ gcc/testsuite/gcc.dg/tree-ssa/pr112626-wrap.c | 33 +++++++++ gcc/testsuite/gcc.dg/tree-ssa/pr112626.c | 37 ++++++++++ 3 files changed, 142 insertions(+) create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr112626-wrap.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr112626.c diff --git a/gcc/match.pd b/gcc/match.pd index 268bf3f11e52..b6a9d4e79be2 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -8164,6 +8164,78 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) wide_int_to_tree (itype, wi::mul (i, wi::to_wide (@2))); }))))) +/* abs (X) >= X -> true. */ +/* abs (X) < X -> false. */ +(for cmp (ge lt) + (simplify + (cmp:c (abs @0) @0) + (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)) + && !TYPE_UNSIGNED (TREE_TYPE (@0)) + && !TYPE_OVERFLOW_TRAPS (TREE_TYPE (@0)) + && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (@0))) + { constant_boolean_node (cmp == GE_EXPR, type); }))) + +/* abs (X) > X -> X < 0. */ +/* abs (X) != X -> X < 0. */ +/* abs (X) <= X -> X >= 0. */ +/* abs (X) == X -> X >= 0. */ +/* When signed overflow wraps, abs (INT_MIN) == INT_MIN. */ +(for cmp (gt ne le eq) + out (lt lt ge ge) + (simplify + (cmp:c (abs @0) @0) + (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)) + && !TYPE_UNSIGNED (TREE_TYPE (@0)) + && !TYPE_OVERFLOW_TRAPS (TREE_TYPE (@0)) + && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (@0))) + (switch + (if (TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (@0))) + (out @0 { build_zero_cst (TREE_TYPE (@0)); })) + (if (TYPE_OVERFLOW_WRAPS (TREE_TYPE (@0))) + (with + { + tree utype = unsigned_type_for (TREE_TYPE (@0)); + wide_int min = wi::min_value (TREE_TYPE (@0)); + } + (if (cmp == LE_EXPR || cmp == EQ_EXPR) + (lt (convert:utype @0) { wide_int_to_tree (utype, min + 1); }) + (gt (convert:utype @0) { wide_int_to_tree (utype, min); })))))))) + +/* (unsigned) abs (X) <= (unsigned) X -> true. */ +/* (unsigned) abs (X) > (unsigned) X -> false. */ +(for cmp (le gt) + (simplify + (cmp:c (convert@1 (abs @0)) (convert@2 @0)) + (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)) + && !TYPE_UNSIGNED (TREE_TYPE (@0)) + && INTEGRAL_TYPE_P (TREE_TYPE (@1)) + && TYPE_UNSIGNED (TREE_TYPE (@1)) + && types_match (TREE_TYPE (@1), TREE_TYPE (@2)) + && element_precision (TREE_TYPE (@0)) == element_precision (TREE_TYPE (@1)) + && !TYPE_OVERFLOW_TRAPS (TREE_TYPE (@0)) + && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (@0))) + { constant_boolean_node (cmp == LE_EXPR, type); }))) + +/* (unsigned) abs (X) < (unsigned) X -> X < 0. */ +/* (unsigned) abs (X) != (unsigned) X -> X < 0. */ +/* (unsigned) abs (X) >= (unsigned) X -> X >= 0. */ +/* (unsigned) abs (X) == (unsigned) X -> X >= 0. */ +/* TODO: Add wrapping-overflow variants for these four cases. */ +(for cmp (lt ne ge eq) + out (lt lt ge ge) + (simplify + (cmp:c (convert@1 (abs @0)) (convert@2 @0)) + (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)) + && !TYPE_UNSIGNED (TREE_TYPE (@0)) + && INTEGRAL_TYPE_P (TREE_TYPE (@1)) + && TYPE_UNSIGNED (TREE_TYPE (@1)) + && types_match (TREE_TYPE (@1), TREE_TYPE (@2)) + && element_precision (TREE_TYPE (@0)) == element_precision (TREE_TYPE (@1)) + && !TYPE_OVERFLOW_TRAPS (TREE_TYPE (@0)) + && !TYPE_OVERFLOW_SANITIZED (TREE_TYPE (@0)) + && TYPE_OVERFLOW_UNDEFINED (TREE_TYPE (@0))) + (out @0 { build_zero_cst (TREE_TYPE (@0)); })))) + /* Simplify comparison of something with itself. For IEEE floating-point, we can only do some of these simplifications. */ (for cmp (eq ge le) diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr112626-wrap.c b/gcc/testsuite/gcc.dg/tree-ssa/pr112626-wrap.c new file mode 100644 index 000000000000..bdc0d17aa8a0 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr112626-wrap.c @@ -0,0 +1,33 @@ +/* PR tree-optimization/112626 - wrapping (-fwrapv) variant. */ +/* { dg-do compile } */ +/* { dg-options "-O2 -fwrapv -fdump-tree-optimized" } */ + +#define FUNC(NAME, OP) \ +int abs_##NAME (int a) { return __builtin_abs (a) OP a; } +#define FUNC_SWAPPED(NAME, OP) \ +int a_##NAME##_abs (int a) { return a OP __builtin_abs (a); } +#define FUNC_U(NAME, OP) \ +int abs_##NAME##_u (int a) { return ((unsigned) __builtin_abs (a)) OP (unsigned) a; } + +FUNC (le, <=) +FUNC (lt, <) +FUNC (ge, >=) +FUNC (gt, >) +FUNC (eq, ==) +FUNC (ne, !=) + +FUNC_SWAPPED (le, <=) +FUNC_SWAPPED (lt, <) +FUNC_SWAPPED (ge, >=) +FUNC_SWAPPED (gt, >) +FUNC_SWAPPED (eq, ==) +FUNC_SWAPPED (ne, !=) + +FUNC_U (le, <=) +FUNC_U (gt, >) + +/* { dg-final { scan-tree-dump-times "return 1;" 3 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "return 0;" 3 "optimized" } } */ +/* { dg-final { scan-tree-dump-times " > 2147483648" 4 "optimized" } } */ +/* { dg-final { scan-tree-dump-times " <= 2147483648" 4 "optimized" } } */ +/* { dg-final { scan-tree-dump-not "ABS_EXPR" "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr112626.c b/gcc/testsuite/gcc.dg/tree-ssa/pr112626.c new file mode 100644 index 000000000000..428d491eff20 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr112626.c @@ -0,0 +1,37 @@ +/* PR tree-optimization/112626 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-optimized" } */ + +#define FUNC(NAME, OP) \ +int abs_##NAME (int a) { return __builtin_abs (a) OP a; } +#define FUNC_SWAPPED(NAME, OP) \ +int a_##NAME##_abs (int a) { return a OP __builtin_abs (a); } +#define FUNC_U(NAME, OP) \ +int abs_##NAME##_u (int a) { return ((unsigned) __builtin_abs (a)) OP (unsigned) a; } + +FUNC (le, <=) +FUNC (lt, <) +FUNC (ge, >=) +FUNC (gt, >) +FUNC (eq, ==) +FUNC (ne, !=) + +FUNC_SWAPPED (le, <=) +FUNC_SWAPPED (lt, <) +FUNC_SWAPPED (ge, >=) +FUNC_SWAPPED (gt, >) +FUNC_SWAPPED (eq, ==) +FUNC_SWAPPED (ne, !=) + +FUNC_U (le, <=) +FUNC_U (lt, <) +FUNC_U (ge, >=) +FUNC_U (gt, >) +FUNC_U (eq, ==) +FUNC_U (ne, !=) + +/* { dg-final { scan-tree-dump-times "return 1;" 3 "optimized" } } */ +/* { dg-final { scan-tree-dump-times "return 0;" 3 "optimized" } } */ +/* { dg-final { scan-tree-dump-times " < 0" 6 "optimized" } } */ +/* { dg-final { scan-tree-dump-times " >= 0" 6 "optimized" } } */ +/* { dg-final { scan-tree-dump-not "ABS_EXPR" "optimized" } } */ From 6bc343fa183a01fa30f70d2c0b70d01e4bd78d62 Mon Sep 17 00:00:00 2001 From: liuhongt Date: Sun, 20 Sep 2026 23:09:00 -0700 Subject: [PATCH 317/584] i386: Don't split V2DF load when the adjusted address is invalid [PR127500] ix86_split_stlf_stall_load splits a V2DF load from a PARM_DECL into movlpd + movhpd, which needs the load address offset by 8. When the original address already uses the largest encodable displacement, e.g. (mem/c:V2DF (plus:DI (reg/f:DI 7 sp) (const_int 2147483640 [0x7ffffff8]))) adding 8 gives 0x80000000, which is out of range for the signed 32-bit displacement field of an x86 address, and adjust_address ICEs in change_address_1 since the address can no longer be validated after reload. Skip the split in that case. gcc/ChangeLog: PR target/127500 * config/i386/i386.cc (ix86_split_stlf_stall_load): Don't split the load when the address adjusted by 8 is not a valid memory address. gcc/testsuite/ChangeLog: PR target/127500 * gcc.target/i386/pr127500.c: New test. --- gcc/config/i386/i386.cc | 12 +++++++++++- gcc/testsuite/gcc.target/i386/pr127500.c | 8 ++++++++ 2 files changed, 19 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.target/i386/pr127500.c diff --git a/gcc/config/i386/i386.cc b/gcc/config/i386/i386.cc index bbb60163a754..29e1d2c58087 100644 --- a/gcc/config/i386/i386.cc +++ b/gcc/config/i386/i386.cc @@ -25083,7 +25083,17 @@ ix86_split_stlf_stall_load () register. */ || GET_MODE (src) != E_V2DFmode || !MEM_EXPR (src) - || TREE_CODE (get_base_address (MEM_EXPR (src))) != PARM_DECL) + || TREE_CODE (get_base_address (MEM_EXPR (src))) != PARM_DECL + /* Avoid invalid memory address. + i.e. + (mem/c:V2DF (plus:DI (reg/f:DI 7 sp) + (const_int 2147483640 [0x7ffffff8]))) + Adjusting it by 8 puts the displacement at 0x80000000, out of + range for the signed 32-bit field an x86 address can encode. */ + || !memory_address_addr_space_p (DFmode, + XEXP (adjust_address_nv (src, DFmode, + 8), 0), + MEM_ADDR_SPACE (src))) continue; rtx zero = CONST0_RTX (V2DFmode); diff --git a/gcc/testsuite/gcc.target/i386/pr127500.c b/gcc/testsuite/gcc.target/i386/pr127500.c new file mode 100644 index 000000000000..cde6058fd6f8 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr127500.c @@ -0,0 +1,8 @@ +/* { dg-do compile { target { ! ia32 } } } */ +/* { dg-options "-msse2 -O2" } */ + +typedef double v2df __attribute__((vector_size (16))); + +struct big { char pad[0x7FFFFFF0]; v2df v; }; + +v2df f (struct big b) { return b.v; } From eb311f861255ae1fcaafa3454d4d1d6f1da07497 Mon Sep 17 00:00:00 2001 From: liuhongt Date: Tue, 4 Aug 2026 01:55:18 -0700 Subject: [PATCH 318/584] tree-optimization/126486 - fold sign-changing conversions in IVOPTS r15-6657 canonicalized signed arithmetic to unsigned and exposed a 17.5% code-size regression at -O2 in SPEC CPU2017 507.cactuBSSN_r. The resulting conversion chains hide common outer-loop IV terms from affine decomposition. Enable ranger during IVOPTS and pass the use statement to tree-affine. Use contextual ranges to remove value-preserving sign changes and fold modular arithmetic into exact arithmetic. Keep candidate computations context-free because they may be emitted in the loop preheader. Ranger also derives n <= UINT_MAX - 4 after the preceding step-4 loop in pr19210-1.c exits, discharging the next loop niter assumption. Adjust the diagnostic expectation. On ia32, the improved IV choice can spill a loop bound through a mask register while still reducing code size and hot-loop work. Restrict the unrelated no-kmov check to non-ia32 targets. .i.e inv_expr 3: ((unsigned long) k_41 * 8 + (unsigned long)\ input_array_dims_28(D)) - (unsigned long) (int) ((unsigned int k_41 +\ 4294967295) * 8 Can be simplified to (unsigned long) input_array_dims_28(D) + 8 When ranger proves k_41 >= 1 The fix slightly improves 507.cactuBSSN_r performance and improves 548.exchange2_r by about 6% on Intel GNR, AMD Zen 5, and Arm Graviton 5. gcc/ChangeLog: PR tree-optimization/126486 * tree-affine.cc: Include vr-values.h. (aff_combination_convert): Accept and propagate range context. (expr_to_aff_combination): Likewise. Fold sign-changing conversions and negative unsigned offsets. (tree_to_aff_combination): Accept and propagate range context. * tree-affine.h (aff_combination_convert): Update declaration. (tree_to_aff_combination): Likewise. * tree-ssa-loop-ivopts.cc: Include gimple-range.h. (get_computation_aff_1): Pass the use statement. (tree_ssa_iv_optimize): Enable ranger. gcc/testsuite/ChangeLog: PR tree-optimization/126486 * gcc.dg/tree-ssa/pr126486.c: New test. * gcc.dg/tree-ssa/pr19210-1.c: Remove obsolete missed diagnostic. * gcc.target/i386/kortest_ccz-1.c: Restrict no-kmov scan to non-ia32. Assisted-by: openai.gpt-5.6-sol xhigh --- gcc/testsuite/gcc.dg/tree-ssa/pr126486.c | 43 ++++ gcc/testsuite/gcc.dg/tree-ssa/pr19210-1.c | 4 +- gcc/testsuite/gcc.target/i386/kortest_ccz-1.c | 2 +- gcc/tree-affine.cc | 184 +++++++++++++++--- gcc/tree-affine.h | 4 +- gcc/tree-ssa-loop-ivopts.cc | 14 +- 6 files changed, 211 insertions(+), 40 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr126486.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr126486.c b/gcc/testsuite/gcc.dg/tree-ssa/pr126486.c new file mode 100644 index 000000000000..201366dc1f37 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr126486.c @@ -0,0 +1,43 @@ +/* PR tree-optimization/126486 */ +/* { dg-do run { target lp64 } } */ +/* { dg-options "-O2 -fdump-tree-ivopts-details" } */ + +__attribute__((noipa)) +int +foo (int n_dims, int *actual_indices, const long *input_array_dims, + int max_iter) +{ + int sum = 0; + int iter = 0; + + while (iter < max_iter) + { + sum = actual_indices[0]; + for (int k = n_dims - 1; k > 0; k--) + { + int product = 1; + for (int j = k - 1; j >= 0; j--) + product *= input_array_dims[j]; + sum += actual_indices[k] * product; + } + iter++; + } + return sum; +} + +int +main (void) +{ + int actual_indices[] = { 1, 2, 3 }; + long input_array_dims[] = { 4, 5, 6 }; + + if (foo (3, actual_indices, input_array_dims, 2) != 69) + __builtin_abort (); + return 0; +} + +/* The common N_DIMS term should cancel. */ +/* { dg-final { scan-tree-dump-times "inv_expr \[0-9\]+:\[^\n\]*\\(signed long\\) input_array_dims_\[0-9\]+\\(D\\) \\+ 8" 1 "ivopts" } } */ + +/* The unsigned K - 1 term should cancel. */ +/* { dg-final { scan-tree-dump-not "inv_expr \[0-9\]+:\[^\n\]*\\(unsigned int\\) k_\[0-9\]+ \\+ 4294967295" "ivopts" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr19210-1.c b/gcc/testsuite/gcc.dg/tree-ssa/pr19210-1.c index b9e40e964c1c..5c8e7d77f674 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/pr19210-1.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr19210-1.c @@ -20,8 +20,8 @@ f (unsigned n) for(k = 5;k <= n;k += 5) g(); - /* So we need the following loop, instead. */ - for(k = 4;k <= n;k += 5) /* { dg-missed "missed loop optimization: niters analysis .*" } */ + /* Ranger can also discharge the assumptions for this loop. */ + for(k = 4;k <= n;k += 5) g(); for(k = 15;k >= n;k--) /* { dg-missed "missed loop optimization: niters analysis .*" } */ diff --git a/gcc/testsuite/gcc.target/i386/kortest_ccz-1.c b/gcc/testsuite/gcc.target/i386/kortest_ccz-1.c index b3cf5b803fbe..e7a1e035c97b 100644 --- a/gcc/testsuite/gcc.target/i386/kortest_ccz-1.c +++ b/gcc/testsuite/gcc.target/i386/kortest_ccz-1.c @@ -1,6 +1,6 @@ /* { dg-do compile } */ /* { dg-options "-march=x86-64-v4 -O3" } */ -/* { dg-final { scan-assembler-not "kmov" } } */ +/* { dg-final { scan-assembler-not "kmov" { target { ! ia32 } } } } */ /* { dg-final { scan-assembler "kortest" } } */ int diff --git a/gcc/tree-affine.cc b/gcc/tree-affine.cc index 181fd6fb33ce..71cb59e6aede 100644 --- a/gcc/tree-affine.cc +++ b/gcc/tree-affine.cc @@ -32,6 +32,8 @@ along with GCC; see the file COPYING3. If not see #include "dumpfile.h" #include "cfgexpand.h" #include "value-query.h" +#include "vr-values.h" +#include "range-op.h" /* Extends CST as appropriate for the affine combinations COMB. */ @@ -218,10 +220,10 @@ aff_combination_add (aff_tree *comb1, aff_tree *comb2) aff_combination_add_elt (comb1, comb2->rest, 1); } -/* Converts affine combination COMB to TYPE. */ +/* Converts affine combination COMB to TYPE. AT is the range-query context. */ void -aff_combination_convert (aff_tree *comb, tree type) +aff_combination_convert (aff_tree *comb, tree type, gimple *at) { unsigned i, j; tree comb_type = comb->type; @@ -229,7 +231,7 @@ aff_combination_convert (aff_tree *comb, tree type) if (TYPE_PRECISION (type) > TYPE_PRECISION (comb_type)) { tree val = fold_convert (type, aff_combination_to_tree (comb)); - tree_to_aff_combination (val, type, comb); + tree_to_aff_combination (val, type, comb, at); return; } @@ -260,27 +262,28 @@ aff_combination_convert (aff_tree *comb, tree type) } } -/* Tries to handle OP0 CODE OP1 as affine combination of parts. Returns - true when that was successful and returns the combination in COMB. */ +/* Tries to handle OP0 CODE OP1 as affine combination of parts. AT is the + range-query context. Returns true when that was successful and returns the + combination in COMB. */ static bool expr_to_aff_combination (aff_tree *comb, tree_code code, tree type, - tree op0, tree op1 = NULL_TREE) + tree op0, tree op1 = NULL_TREE, gimple *at = NULL) { aff_tree tmp; switch (code) { case POINTER_PLUS_EXPR: - tree_to_aff_combination (op0, type, comb); - tree_to_aff_combination (op1, sizetype, &tmp); + tree_to_aff_combination (op0, type, comb, at); + tree_to_aff_combination (op1, sizetype, &tmp, at); aff_combination_add (comb, &tmp); return true; case PLUS_EXPR: case MINUS_EXPR: - tree_to_aff_combination (op0, type, comb); - tree_to_aff_combination (op1, type, &tmp); + tree_to_aff_combination (op0, type, comb, at); + tree_to_aff_combination (op1, type, &tmp, at); if (code == MINUS_EXPR) aff_combination_scale (&tmp, -1); aff_combination_add (comb, &tmp); @@ -289,18 +292,18 @@ expr_to_aff_combination (aff_tree *comb, tree_code code, tree type, case MULT_EXPR: if (TREE_CODE (op1) != INTEGER_CST) break; - tree_to_aff_combination (op0, type, comb); + tree_to_aff_combination (op0, type, comb, at); aff_combination_scale (comb, wi::to_widest (op1)); return true; case NEGATE_EXPR: - tree_to_aff_combination (op0, type, comb); + tree_to_aff_combination (op0, type, comb, at); aff_combination_scale (comb, -1); return true; case BIT_NOT_EXPR: /* ~x = -x - 1 */ - tree_to_aff_combination (op0, type, comb); + tree_to_aff_combination (op0, type, comb, at); aff_combination_scale (comb, -1); aff_combination_add_cst (comb, -1); return true; @@ -315,15 +318,108 @@ expr_to_aff_combination (aff_tree *comb, tree_code code, tree type, /* STRIP_NOPS */ if (tree_nop_conversion_p (otype, itype)) { - tree_to_aff_combination (op0, type, comb); + tree_to_aff_combination (op0, type, comb, at); return true; } + /* Look through (OTYPE) (ITYPE) IOP. ITYPE and IOTYPE have the + same precision and differ at most in signedness. */ + if (INTEGRAL_NB_TYPE_P (otype) + && INTEGRAL_NB_TYPE_P (itype) + && TYPE_PRECISION (otype) > TYPE_PRECISION (itype) + && CONVERT_EXPR_P (inner)) + { + tree iop = TREE_OPERAND (inner, 0); + tree iotype = TREE_TYPE (iop); + tree_code wcode = TREE_CODE (iop); + + if (INTEGRAL_NB_TYPE_P (iotype) + && tree_nop_conversion_p (itype, iotype)) + { + int_range_max vr; + range_query *query = get_range_query (cfun); + + /* Distribute the conversions when the operation fits ITYPE: + (OTYPE) (ITYPE) ((IOTYPE) X +- CST) + -> + (OTYPE) (ITYPE) (IOTYPE) X +- (OTYPE) (ITYPE) CST. + + (OTYPE)(ITYPE) (IOTYPE) X will be further simplified to + (OTYPE) X when X fits ITYPE. + + So eventually the simplification is like + (OTYPE) (ITYPE) ((IOTYPE) X + CST) + -> + (OTYPE) X + (OTYPE) (ITYPE) CST. + This is used to handle the complicated convert chain which + is created by unsigned canonicalization in IVOPTS, the + canonicalization itself is used to detect more equality + for iv, so handle the redundancy here. */ + + if (!TYPE_UNSIGNED (itype) + && TYPE_UNSIGNED (iotype) + && (wcode == PLUS_EXPR || wcode == MINUS_EXPR) + && TREE_CODE (TREE_OPERAND (iop, 1)) == INTEGER_CST) + { + tree wop0 = fold_convert (itype, TREE_OPERAND (iop, 0)); + tree wop1 = fold_convert (itype, TREE_OPERAND (iop, 1)); + + if (query->range_of_expr (vr, wop0, at) + && !vr.varying_p () + && !vr.undefined_p ()) + { + wi::overflow_type ovf1 = wi::OVF_NONE; + wi::overflow_type ovf2 = wi::OVF_NONE; + wide_int cst = wi::to_wide (wop1); + + /* IOP has wrapping type IOTYPE, so check signed + overflow explicitly. overflow_free_p uses ITYPE's + undefined-overflow semantics and always returns true. */ + if (wcode == PLUS_EXPR) + { + wi::add (vr.lower_bound (), cst, SIGNED, &ovf1); + wi::add (vr.upper_bound (), cst, SIGNED, &ovf2); + } + else + { + wi::sub (vr.lower_bound (), cst, SIGNED, &ovf1); + wi::sub (vr.upper_bound (), cst, SIGNED, &ovf2); + } + + if (ovf1 == wi::OVF_NONE && ovf2 == wi::OVF_NONE) + { + wop0 = fold_convert (otype, wop0); + wop1 = fold_convert (otype, wop1); + return expr_to_aff_combination (comb, wcode, otype, + wop0, wop1, at); + } + } + } + + /* Strip the inner conversion when IOP fits ITYPE: + (OTYPE) (ITYPE) IOP -> (OTYPE) IOP. + + (unsigned long) (int) (unsigned) k is simplified to + (unsigned long) k when we know k >= 0. */ + if (TYPE_SIGN (itype) == TYPE_SIGN (iotype) + || (TREE_CODE (iop) == INTEGER_CST + ? int_fits_type_p (iop, itype) + : (query->range_of_expr (vr, iop, at) + && range_fits_type_p (&vr, TYPE_PRECISION (itype), + TYPE_SIGN (itype))))) + { + tree_to_aff_combination (fold_convert (otype, iop), type, + comb, at); + return true; + } + } + } + /* In principle this is a valid folding, but it isn't necessarily an optimization, so do it here and not in fold_unary. */ if ((icode == PLUS_EXPR || icode == MINUS_EXPR || icode == MULT_EXPR) - && TREE_CODE (itype) == INTEGER_TYPE - && TREE_CODE (otype) == INTEGER_TYPE + && INTEGRAL_NB_TYPE_P (itype) + && INTEGRAL_NB_TYPE_P (otype) && TYPE_PRECISION (otype) > TYPE_PRECISION (itype)) { tree op0 = TREE_OPERAND (inner, 0), op1 = TREE_OPERAND (inner, 1); @@ -338,7 +434,8 @@ expr_to_aff_combination (aff_tree *comb, tree_code code, tree type, { op0 = fold_convert (otype, op0); op1 = fold_convert (otype, op1); - return expr_to_aff_combination (comb, icode, otype, op0, op1); + return expr_to_aff_combination (comb, icode, otype, op0, op1, + at); } wide_int minv, maxv; /* If inner type has wrapping overflow behavior, fold conversion @@ -349,7 +446,7 @@ expr_to_aff_combination (aff_tree *comb, tree_code code, tree type, if (TYPE_UNSIGNED (itype) && TYPE_OVERFLOW_WRAPS (itype) && TREE_CODE (op1) == INTEGER_CST - && get_range_query (cfun)->range_of_expr (vr, op0) + && get_range_query (cfun)->range_of_expr (vr, op0, at) && !vr.varying_p () && !vr.undefined_p ()) { @@ -369,7 +466,31 @@ expr_to_aff_combination (aff_tree *comb, tree_code code, tree type, op0 = fold_convert (otype, op0); op1 = fold_convert (otype, op1); return expr_to_aff_combination (comb, icode, otype, op0, - op1); + op1, at); + } + /* A negative offset can be handled as an exact subtraction: + (T1) (X + CST) -> (T1) X - (T1) -CST. + + This rewrites (int) ((unsigned int) k + UINT_MAX) to + (int) k - 1 when k is known >= 1. + + This also works for the most-negative signed CST: unsigned + negation is modulo 2^precision, so -CST equals CST. */ + else if (icode == PLUS_EXPR + && wi::neg_p (wi::to_wide (op1), SIGNED)) + { + wide_int pos_cst = wi::neg (wi::to_wide (op1)); + int_range<1> cst_range (itype, pos_cst, pos_cst); + range_op_handler minus (MINUS_EXPR); + + if (minus.overflow_free_p (vr, cst_range)) + { + op0 = fold_convert (otype, op0); + op1 = fold_convert (otype, + wide_int_to_tree (itype, pos_cst)); + return expr_to_aff_combination (comb, MINUS_EXPR, + otype, op0, op1, at); + } } } } @@ -382,10 +503,11 @@ expr_to_aff_combination (aff_tree *comb, tree_code code, tree type, return false; } -/* Splits EXPR into an affine combination of parts. */ +/* Splits EXPR into an affine combination of parts. AT is the range-query + context. */ void -tree_to_aff_combination (tree expr, tree type, aff_tree *comb) +tree_to_aff_combination (tree expr, tree type, aff_tree *comb, gimple *at) { aff_tree tmp; enum tree_code code; @@ -404,13 +526,14 @@ tree_to_aff_combination (tree expr, tree type, aff_tree *comb) case MINUS_EXPR: case MULT_EXPR: if (expr_to_aff_combination (comb, code, type, TREE_OPERAND (expr, 0), - TREE_OPERAND (expr, 1))) + TREE_OPERAND (expr, 1), at)) return; break; case NEGATE_EXPR: case BIT_NOT_EXPR: - if (expr_to_aff_combination (comb, code, type, TREE_OPERAND (expr, 0))) + if (expr_to_aff_combination (comb, code, type, TREE_OPERAND (expr, 0), + NULL_TREE, at)) return; break; @@ -418,9 +541,10 @@ tree_to_aff_combination (tree expr, tree type, aff_tree *comb) /* ??? TREE_TYPE (expr) should be equal to type here, but IVOPTS calls this with not showing an outer widening cast. */ if (expr_to_aff_combination (comb, code, - TREE_TYPE (expr), TREE_OPERAND (expr, 0))) + TREE_TYPE (expr), TREE_OPERAND (expr, 0), + NULL_TREE, at)) { - aff_combination_convert (comb, type); + aff_combination_convert (comb, type, at); return; } break; @@ -430,8 +554,9 @@ tree_to_aff_combination (tree expr, tree type, aff_tree *comb) if (TREE_CODE (TREE_OPERAND (expr, 0)) == MEM_REF) { expr = TREE_OPERAND (expr, 0); - tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb); - tree_to_aff_combination (TREE_OPERAND (expr, 1), sizetype, &tmp); + tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb, at); + tree_to_aff_combination (TREE_OPERAND (expr, 1), sizetype, &tmp, + at); aff_combination_add (comb, &tmp); return; } @@ -454,12 +579,12 @@ tree_to_aff_combination (tree expr, tree type, aff_tree *comb) aff_combination_add_elt (comb, core, 1); else { - tree_to_aff_combination (core, type, &tmp); + tree_to_aff_combination (core, type, &tmp, at); aff_combination_add (comb, &tmp); } if (toffset) { - tree_to_aff_combination (toffset, type, &tmp); + tree_to_aff_combination (toffset, type, &tmp, at); aff_combination_add (comb, &tmp); } return; @@ -1065,4 +1190,3 @@ aff_comb_cannot_overlap_p (aff_tree *diff, const poly_widest_int &size1, return known_le (size1, diff->offset); } } - diff --git a/gcc/tree-affine.h b/gcc/tree-affine.h index 38d32ef1b4b2..44ed00532090 100644 --- a/gcc/tree-affine.h +++ b/gcc/tree-affine.h @@ -73,8 +73,8 @@ void aff_combination_mult (aff_tree *, aff_tree *, aff_tree *); void aff_combination_add (aff_tree *, aff_tree *); void aff_combination_add_elt (aff_tree *, tree, const widest_int &); void aff_combination_remove_elt (aff_tree *, unsigned); -void aff_combination_convert (aff_tree *, tree); -void tree_to_aff_combination (tree, tree, aff_tree *); +void aff_combination_convert (aff_tree *, tree, gimple * = NULL); +void tree_to_aff_combination (tree, tree, aff_tree *, gimple * = NULL); tree aff_combination_to_tree (aff_tree *); void unshare_aff_combination (aff_tree *); bool aff_combination_constant_multiple_p (aff_tree *, aff_tree *, diff --git a/gcc/tree-ssa-loop-ivopts.cc b/gcc/tree-ssa-loop-ivopts.cc index ab2c797b3865..006ec7362bc7 100644 --- a/gcc/tree-ssa-loop-ivopts.cc +++ b/gcc/tree-ssa-loop-ivopts.cc @@ -4038,9 +4038,9 @@ get_computation_aff_1 (struct ivopts_data *data, gimple *at, struct iv_use *use, common_type = determine_common_wider_type (&ubase, &cbase); /* use = ubase - ratio * cbase + ratio * var. */ - tree_to_aff_combination (ubase, common_type, aff_inv); - tree_to_aff_combination (cbase, common_type, &aff_cbase); - tree_to_aff_combination (var, uutype, aff_var); + tree_to_aff_combination (ubase, common_type, aff_inv, at); + tree_to_aff_combination (cbase, common_type, &aff_cbase, at); + tree_to_aff_combination (var, uutype, aff_var, at); /* We need to shift the value if we are after the increment. */ if (stmt_after_increment (data->current_loop, cand, at)) @@ -4052,14 +4052,14 @@ get_computation_aff_1 (struct ivopts_data *data, gimple *at, struct iv_use *use, else cstep_common = cstep; - tree_to_aff_combination (cstep_common, common_type, &cstep_aff); + tree_to_aff_combination (cstep_common, common_type, &cstep_aff, at); aff_combination_add (&aff_cbase, &cstep_aff); } aff_combination_scale (&aff_cbase, -rat); aff_combination_add (aff_inv, &aff_cbase); if (common_type != uutype) - aff_combination_convert (aff_inv, uutype); + aff_combination_convert (aff_inv, uutype, at); aff_combination_scale (aff_var, rat); return true; @@ -8340,6 +8340,8 @@ tree_ssa_iv_optimize (void) tree_ssa_iv_optimize_init (&data); mark_ssa_maybe_undefs (); + enable_ranger (cfun, false); + /* Optimize the loops starting with the innermost ones. */ for (auto loop : loops_list (cfun, LI_FROM_INNERMOST)) { @@ -8352,6 +8354,8 @@ tree_ssa_iv_optimize (void) tree_ssa_iv_optimize_loop (&data, loop, toremove); } + disable_ranger (cfun); + /* Remove eliminated IV defs. */ release_defs_bitset (toremove); From dc65d88cdf15f3538fdcfd1d174c845474989533 Mon Sep 17 00:00:00 2001 From: Tamar Christina Date: Tue, 22 Sep 2026 07:19:56 +0100 Subject: [PATCH 319/584] libstdc++: Continue with regex DFS traversals without next frames [PR126274] The change in r16-7193-g158ad5f96954da5fa24d5c2a91ae92417fb62e20 changed the recursive implementation with an iterative one using an explicit heap. However one benefit of the previous implementation is that the frame did not have to be saved and popped when the match is supposed to continue. This means that on hot paths we now have additional memory accesses and need additional instructions to calculate the memref addresses. For DFS matching this is clearly suboptimal since when _M_rep_once_more then we push and pop the same state but there is enough other acceses in between the push and pop that we get a lot of cache misses. This makes all the private _m_handle_* methods return a _StateIdT which allows the caller to deal with the value, so that for DFS we can avoid pushing the frame if needed. For DFS we try to consume the state immediately until we're told to stop. For this to work the methods have to me marked always inline, because a key part of the optimization is to keep the values in registers rather than passing through stack and the function call overheads and AAPCS requirements would negate the benefits. The __dfs_mode changes are because the constexpr patch still gave a big boost so it prepares to apply it. There is still a regression until the end of the series and each patch will chip away at it. Also note that with none of these changes do I see an increase heap or stack usage that the original fix fixed. RSS stays about the same. PS. thanks for the link to the algorithm in the source, it was useful to understand how the machinery works! Benchmark improvements vs GCC 16: at -O2: email: +36.1% URI: +36.5% IPv4 +33.0% at -O3: email: +45.5%, URI: +44.9% IPv4: +43.0% On Neoverse-V1 libstdc++-v3/ChangeLog: PR libstdc++/126274 * include/bits/regex_executor.h (_Executor): Reserve frame space. (_M_rep_once_more, _M_handle_repeat, _M_handle_subexpr_begin, _M_handle_subexpr_end, _M_handle_line_begin_assertion, _M_handle_line_end_assertion, _M_handle_word_boundary, _M_handle_subexpr_lookahead, _M_handle_match, _M_handle_backref, _M_node): return StateIdT. (_M_visited): Mark inline. * include/bits/regex_executor.tcc (_M_rep_once_more, _M_handle_repeat, _M_handle_subexpr_begin, _M_handle_subexpr_end, _M_handle_line_begin_assertion, _M_handle_line_end_assertion, _M_handle_word_boundary, _M_handle_subexpr_lookahead, _M_handle_match, _M_handle_backref): Return state, mark always inline. (_M_node): Return StateIdT and also decide what to do with the value after return. (_M_dfs): Traverse states iteratively for _S_fopcode_next, _S_fopcode_fallback_next, _S_fopcode_fallback_rep_once_more and _S_fopcode_rep_once_more. * include/bits/regex.h (class _Executor): Move to V2 ABI. --- libstdc++-v3/include/bits/regex.h | 2 + libstdc++-v3/include/bits/regex_executor.h | 30 +-- libstdc++-v3/include/bits/regex_executor.tcc | 183 ++++++++++++------- 3 files changed, 139 insertions(+), 76 deletions(-) diff --git a/libstdc++-v3/include/bits/regex.h b/libstdc++-v3/include/bits/regex.h index 0e815ca086eb..dce420251db0 100644 --- a/libstdc++-v3/include/bits/regex.h +++ b/libstdc++-v3/include/bits/regex.h @@ -61,8 +61,10 @@ namespace __detail _RegexExecutorPolicy __policy, bool __match_mode); +_GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(_V2) template class _Executor; +_GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) template struct __is_contiguous_iter : false_type { }; diff --git a/libstdc++-v3/include/bits/regex_executor.h b/libstdc++-v3/include/bits/regex_executor.h index 797ad702784b..eccf12c5a087 100644 --- a/libstdc++-v3/include/bits/regex_executor.h +++ b/libstdc++-v3/include/bits/regex_executor.h @@ -44,6 +44,7 @@ namespace __detail template::value> struct _ExecutorFrame; +_GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(_V2) /** * @brief Takes a regex and an input string and does the matching. * @@ -113,43 +114,43 @@ namespace __detail _M_search(); private: - void + _StateIdT _M_rep_once_more(_Match_mode __match_mode, _StateIdT); - void + _StateIdT _M_handle_repeat(_Match_mode, _StateIdT); - void + _StateIdT _M_handle_subexpr_begin(_Match_mode, _StateIdT); - void + _StateIdT _M_handle_subexpr_end(_Match_mode, _StateIdT); - void + _StateIdT _M_handle_line_begin_assertion(_Match_mode, _StateIdT); - void + _StateIdT _M_handle_line_end_assertion(_Match_mode, _StateIdT); - void + _StateIdT _M_handle_word_boundary(_Match_mode, _StateIdT); - void + _StateIdT _M_handle_subexpr_lookahead(_Match_mode, _StateIdT); - void + _StateIdT _M_handle_match(_Match_mode, _StateIdT); - void + _StateIdT _M_handle_backref(_Match_mode, _StateIdT); - void + _StateIdT _M_handle_accept(_Match_mode, _StateIdT); - void + _StateIdT _M_handle_alternative(_Match_mode, _StateIdT); - void + _StateIdT _M_node(_Match_mode, _StateIdT); void @@ -247,7 +248,7 @@ namespace __detail return (_M_re._M_automaton->_M_options() & __m) == __m; } - bool + inline bool _M_visited(_StateIdT __i) { if (_M_visited_states) @@ -283,6 +284,7 @@ namespace __detail // Do we have a solution so far? bool _M_has_sol; }; +_GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2) ///@} regex-detail } // namespace __detail diff --git a/libstdc++-v3/include/bits/regex_executor.tcc b/libstdc++-v3/include/bits/regex_executor.tcc index 167a7a345300..9361c27d4c5b 100644 --- a/libstdc++-v3/include/bits/regex_executor.tcc +++ b/libstdc++-v3/include/bits/regex_executor.tcc @@ -250,8 +250,14 @@ namespace __detail // infinite loop by refusing to continue when it's already been // visited more than twice. It's `twice` instead of `once` because // we need to spare one more time for potential group capture. + // + // If the node cannot be re-entered anymore from the current state then return + // _S_invalid_state_id otherwise return the current state without going + // through a vector, allowing the caller to decide what to do with the state + // This is beneficial for DFS since DFS can continue with the next state + // immediately template - void _Executor<_BiIter, _Alloc, _TraitsT>:: + _StateIdT _Executor<_BiIter, _Alloc, _TraitsT>:: _M_rep_once_more(_Match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; @@ -263,7 +269,7 @@ namespace __detail _M_frames.back()._M_count = __rep_count.second; __rep_count.first = _M_current; __rep_count.second = 1; - _M_frames.emplace_back(_S_fopcode_next, __state._M_alt); + return __state._M_alt; } else { @@ -271,9 +277,10 @@ namespace __detail { __rep_count.second++; _M_frames.emplace_back(_S_fopcode_decrement_rep_count, __i); - _M_frames.emplace_back(_S_fopcode_next, __state._M_alt); + return __state._M_alt; } } + return _S_invalid_state_id; } // _M_alt branch is "match once more", while _M_next is "get me out @@ -281,8 +288,11 @@ namespace __detail // mean the same thing, and we need to choose the correct order under // given greedy mode. template - void _Executor<_BiIter, _Alloc, _TraitsT>:: - _M_handle_repeat(_Match_mode, _StateIdT __i) +#ifdef __OPTIMIZE__ + [[__gnu__::__always_inline__]] +#endif + inline _StateIdT _Executor<_BiIter, _Alloc, _TraitsT>:: + _M_handle_repeat(_Match_mode __match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; // Greedy. @@ -294,7 +304,7 @@ namespace __detail _M_current); else _M_frames.emplace_back(_S_fopcode_next, __state._M_next); - _M_frames.emplace_back(_S_fopcode_rep_once_more, __i); + return _M_rep_once_more(__match_mode, __i); } else // Non-greedy mode { @@ -303,7 +313,7 @@ namespace __detail // vice-versa. _M_frames.emplace_back(_S_fopcode_fallback_rep_once_more, __i, _M_current); - _M_frames.emplace_back(_S_fopcode_next, __state._M_next); + return __state._M_next; } else { @@ -316,97 +326,122 @@ namespace __detail // accepted state *must* be better than a solution that // matches a non-greedy quantifier one more time. _M_frames.emplace_back(_S_fopcode_fallback_rep_once_more, __i); - _M_frames.emplace_back(_S_fopcode_next, __state._M_next); + return __state._M_next; } } } + return _S_invalid_state_id; } template - void _Executor<_BiIter, _Alloc, _TraitsT>:: +#ifdef __OPTIMIZE__ + [[__gnu__::__always_inline__]] +#endif + inline _StateIdT _Executor<_BiIter, _Alloc, _TraitsT>:: _M_handle_subexpr_begin(_Match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; auto& __res = _M_cur_results[__state._M_subexpr]; - _M_frames.emplace_back(_S_fopcode_restore_cur_results, - static_cast<_StateIdT>(__state._M_subexpr), - __res.first); + if (_M_nfa._M_has_backref + || __state._M_subexpr != 0 + || _M_search_mode != _Search_mode::_DFS) + _M_frames.emplace_back(_S_fopcode_restore_cur_results, + static_cast<_StateIdT>(__state._M_subexpr), + __res.first); __res.first = _M_current; - _M_frames.emplace_back(_S_fopcode_next, __state._M_next); + return __state._M_next; } template - void _Executor<_BiIter, _Alloc, _TraitsT>:: +#ifdef __OPTIMIZE__ + [[__gnu__::__always_inline__]] +#endif + inline _StateIdT _Executor<_BiIter, _Alloc, _TraitsT>:: _M_handle_subexpr_end(_Match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; auto& __res = _M_cur_results[__state._M_subexpr]; - _M_frames.emplace_back(_S_fopcode_restore_cur_results, - static_cast<_StateIdT>(__state._M_subexpr), - __res.second); - _M_frames.back()._M_subexpr_end = true; - _M_frames.back()._M_matched = __res.matched; + if (_M_nfa._M_has_backref + || __state._M_subexpr != 0 + || _M_search_mode != _Search_mode::_DFS) + { + _M_frames.emplace_back(_S_fopcode_restore_cur_results, + static_cast<_StateIdT>(__state._M_subexpr), + __res.second); + _M_frames.back()._M_subexpr_end = true; + _M_frames.back()._M_matched = __res.matched; + } + __res.second = _M_current; __res.matched = true; - _M_frames.emplace_back(_S_fopcode_next, __state._M_next); + return __state._M_next; } template - inline void _Executor<_BiIter, _Alloc, _TraitsT>:: + inline _StateIdT _Executor<_BiIter, _Alloc, _TraitsT>:: _M_handle_line_begin_assertion(_Match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; if (_M_at_begin()) - _M_frames.emplace_back(_S_fopcode_next, __state._M_next); + return __state._M_next; + return _S_invalid_state_id; } template - inline void _Executor<_BiIter, _Alloc, _TraitsT>:: + inline _StateIdT _Executor<_BiIter, _Alloc, _TraitsT>:: _M_handle_line_end_assertion(_Match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; if (_M_at_end()) - _M_frames.emplace_back(_S_fopcode_next, __state._M_next); + return __state._M_next; + return _S_invalid_state_id; } template - inline void _Executor<_BiIter, _Alloc, _TraitsT>:: + inline _StateIdT _Executor<_BiIter, _Alloc, _TraitsT>:: _M_handle_word_boundary(_Match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; if (_M_word_boundary() == !__state._M_neg) - _M_frames.emplace_back(_S_fopcode_next, __state._M_next); + return __state._M_next; + return _S_invalid_state_id; } // Here __state._M_alt offers a single start node for a sub-NFA. // We recursively invoke our algorithm to match the sub-NFA. template - void _Executor<_BiIter, _Alloc, _TraitsT>:: + _StateIdT _Executor<_BiIter, _Alloc, _TraitsT>:: _M_handle_subexpr_lookahead(_Match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; if (_M_lookahead(__state._M_alt) == !__state._M_neg) - _M_frames.emplace_back(_S_fopcode_next, __state._M_next); + return __state._M_next; + return _S_invalid_state_id; } template - void _Executor<_BiIter, _Alloc, _TraitsT>:: +#ifdef __OPTIMIZE__ + [[__gnu__::__always_inline__]] +#endif + inline _StateIdT _Executor<_BiIter, _Alloc, _TraitsT>:: _M_handle_match(_Match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; if (_M_current == _M_end) - return; + return _S_invalid_state_id; if (_M_search_mode == _Search_mode::_DFS) { if (__state._M_matches(*_M_current)) { ++_M_current; - _M_frames.emplace_back(_S_fopcode_next, __state._M_next); + return __state._M_next; } } else if (__state._M_matches(*_M_current)) _M_match_queue.emplace_back(__state._M_next, _M_cur_results); + + return _S_invalid_state_id; } template @@ -462,7 +497,7 @@ namespace __detail // (_M_current, _M_current + (__submatch.second - __submatch.first)). // If matched, keep going; else just return and try another state. template - void _Executor<_BiIter, _Alloc, _TraitsT>:: + _StateIdT _Executor<_BiIter, _Alloc, _TraitsT>:: _M_handle_backref(_Match_mode, _StateIdT __i) { __glibcxx_assert(_M_search_mode == _Search_mode::_DFS); @@ -470,7 +505,7 @@ namespace __detail const auto& __state = _M_nfa[__i]; auto& __submatch = _M_cur_results[__state._M_backref_index]; if (!__submatch.matched) - return; + return _S_invalid_state_id; auto __last = _M_current; for (auto __tmp = __submatch.first; __last != _M_end && __tmp != __submatch.second; @@ -482,12 +517,17 @@ namespace __detail __submatch.first, __submatch.second, _M_current, __last)) { _M_current = __last; - _M_frames.emplace_back(_S_fopcode_next, __state._M_next); + return __state._M_next; } + + return _S_invalid_state_id; } template - void _Executor<_BiIter, _Alloc, _TraitsT>:: +#ifdef __OPTIMIZE__ + [[__gnu__::__always_inline__]] +#endif + inline _StateIdT _Executor<_BiIter, _Alloc, _TraitsT>:: _M_handle_accept(_Match_mode __match_mode, _StateIdT) { if (_M_search_mode == _Search_mode::_DFS) @@ -528,7 +568,7 @@ namespace __detail { if (_M_current == _M_begin && (_M_flags & regex_constants::match_not_null)) - return; + return _S_invalid_state_id; if (__match_mode == _Match_mode::_Prefix || _M_current == _M_end) if (!_M_has_sol) { @@ -536,10 +576,14 @@ namespace __detail _M_results = _M_cur_results; } } + return _S_invalid_state_id; } template - void _Executor<_BiIter, _Alloc, _TraitsT>:: +#ifdef __OPTIMIZE__ + [[__gnu__::__always_inline__]] +#endif + inline _StateIdT _Executor<_BiIter, _Alloc, _TraitsT>:: _M_handle_alternative(_Match_mode, _StateIdT __i) { const auto& __state = _M_nfa[__i]; @@ -549,7 +593,7 @@ namespace __detail // Pick lhs if it matches. Only try rhs if it doesn't. _M_frames.emplace_back(_S_fopcode_fallback_next, __state._M_next, _M_current); - _M_frames.emplace_back(_S_fopcode_next, __state._M_alt); + return __state._M_alt; } else { @@ -557,7 +601,7 @@ namespace __detail // See "case _S_opcode_accept:" handling above. _M_frames.emplace_back(_S_fopcode_posix_alternative, __state._M_next, _M_current); - _M_frames.emplace_back(_S_fopcode_next, __state._M_alt); + return __state._M_alt; } } @@ -565,54 +609,69 @@ namespace __detail #ifdef __OPTIMIZE__ [[__gnu__::__always_inline__]] #endif - inline void _Executor<_BiIter, _Alloc, _TraitsT>:: + inline _StateIdT _Executor<_BiIter, _Alloc, _TraitsT>:: _M_node(_Match_mode __match_mode, _StateIdT __i) { - if (_M_visited(__i)) - return; + // DFS has no _M_visited implementation as such don't even have the branch + // or the check in the call graph. + if (_M_search_mode == _Search_mode::_BFS) + if (_M_visited(__i)) + return _S_invalid_state_id; + _StateIdT __next = _S_invalid_state_id; switch (_M_nfa[__i]._M_opcode()) { case _S_opcode_repeat: - _M_handle_repeat(__match_mode, __i); break; + __next = _M_handle_repeat(__match_mode, __i); break; case _S_opcode_subexpr_begin: - _M_handle_subexpr_begin(__match_mode, __i); break; + __next = _M_handle_subexpr_begin(__match_mode, __i); + break; case _S_opcode_subexpr_end: - _M_handle_subexpr_end(__match_mode, __i); break; + __next = _M_handle_subexpr_end(__match_mode, __i); + break; case _S_opcode_line_begin_assertion: - _M_handle_line_begin_assertion(__match_mode, __i); break; + __next = _M_handle_line_begin_assertion(__match_mode, __i); break; case _S_opcode_line_end_assertion: - _M_handle_line_end_assertion(__match_mode, __i); break; + __next = _M_handle_line_end_assertion(__match_mode, __i); break; case _S_opcode_word_boundary: - _M_handle_word_boundary(__match_mode, __i); break; + __next = _M_handle_word_boundary(__match_mode, __i); break; case _S_opcode_subexpr_lookahead: - _M_handle_subexpr_lookahead(__match_mode, __i); break; + __next = _M_handle_subexpr_lookahead(__match_mode, __i); break; case _S_opcode_match: - _M_handle_match(__match_mode, __i); break; + __next = _M_handle_match(__match_mode, __i); break; case _S_opcode_backref: if (_M_search_mode == _Search_mode::_DFS) - _M_handle_backref(__match_mode, __i); + __next = _M_handle_backref(__match_mode, __i); else __builtin_unreachable(); break; case _S_opcode_accept: - _M_handle_accept(__match_mode, __i); break; + __next = _M_handle_accept(__match_mode, __i); break; case _S_opcode_alternative: - _M_handle_alternative(__match_mode, __i); break; + __next = _M_handle_alternative(__match_mode, __i); break; default: __glibcxx_assert(false); } + return __next; } template void _Executor<_BiIter, _Alloc, _TraitsT>:: _M_dfs(_Match_mode __match_mode, _StateIdT __start) { - const bool __dfs_mode = (_M_search_mode == _Search_mode::_DFS); - _M_frames.emplace_back(_S_fopcode_next, __start); + _StateIdT __next = __start; - while (!_M_frames.empty()) + while (true) { + // Follow immediate successors without re-entering the frame + // loop until we fail. This avoids the needless state save and + // restore through memory. + while (__next != _S_invalid_state_id) + __next = _M_node(__match_mode, __next); + + if (_M_frames.empty()) + break; + _ExecutorFrame<_BiIter> __frame = std::move(_M_frames.back()); _M_frames.pop_back(); @@ -621,27 +680,27 @@ namespace __detail case _S_fopcode_fallback_next: if (_M_has_sol) break; - if (__dfs_mode) + if (_M_search_mode == _Search_mode::_DFS) _M_current = __frame._M_pos; [[__fallthrough__]]; case _S_fopcode_next: - _M_node(__match_mode, __frame._M_state_id); + __next = __frame._M_state_id; break; case _S_fopcode_fallback_rep_once_more: if (_M_has_sol) break; - if (__dfs_mode) + if (_M_search_mode == _Search_mode::_DFS) _M_current = __frame._M_pos; [[__fallthrough__]]; case _S_fopcode_rep_once_more: - _M_rep_once_more(__match_mode, __frame._M_state_id); + __next = _M_rep_once_more(__match_mode, __frame._M_state_id); break; case _S_fopcode_posix_alternative: _M_frames.emplace_back(_S_fopcode_merge_sol, 0, _M_has_sol); - _M_frames.emplace_back(_S_fopcode_next, __frame._M_state_id); - if (__dfs_mode) + __next = __frame._M_state_id; + if (_M_search_mode == _Search_mode::_DFS) _M_current = __frame._M_pos; _M_has_sol = false; break; From 24570c4a1b2805fc375c5f0fb9881eb3d1f24bc7 Mon Sep 17 00:00:00 2001 From: Tamar Christina Date: Tue, 22 Sep 2026 07:21:49 +0100 Subject: [PATCH 320/584] libstdc++: Templatize regex executor traversal mode [PR126274] In GCC 16 the commit r16-7193-g158ad5f96954da5fa24d5c2a91ae92417fb62e20 caused a big regression in performance of regex in libstdc++. This and other patches were tested using the CPP version of the benchmarks at https://github.com/mariomka/regex-benchmark/ The benchmark uses regex_token_iterator over the input text with these patterns: - email: [\w.+-]+@[\w.-]+\.[\w.-]+ - URI: [\w]+:\/\/[^\/\s?#]+[^\s?#]+(?:\?[^\s#]*)?(?:#[^\s]*)? - IPv4: (?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]) Where it tests various types of regexpr. "email" has no backtracking so it's the simplest NFA possible which we should be able to handle quickly. "uri" has optional matches and some non capturing groups and "ipv4" adds some alternative matching to the equation. The input string is a 6.52 mb test file "input-text.txt" The regressions of each type of regexpr compared to GCC 15 are: email: 118.9% URI: 124.8% IPv4: 139.8% So most matches became > 2x slower. This patch series addresses the regressions and gets the new code to be ultimately faster than the GCC 15 implementation. Currently the _Executor class implements both a DFS and a BFS traveral mode for the regex matching. It has a parameter _M_search_mode which it uses inside the _Executor functions to separate out the implementations. However this parameter is rather opague to IPA and so for each implementation the other branch is always dead but they haven't been folded away. This increases the number of dynamic instructions and branches being executed and the branches seem to be often mispredicted. The patch fixes it by moving _Search_mode out of the class and making it a template parameter instead so we can at compile time fold away the two implementations. This removes all the extra compare and branches from the hot functions. These changes improve the benchmarks compared with previous patch in series at -O2: email: +11.1% URI: +10.3% IPv4 +7.3% at -O3: email: +8.6%, URI: +7.9% IPv4: +3.6% libstdc++-v3/ChangeLog: PR libstdc++/126274 * include/bits/regex_executor.h (_Search_mode): Move to top level. (_M_handle_repeat, _M_handle_match, _M_handle_accept, _M_node, _M_dfs): Add template parameter. (_M_visited): Add inline keyword. * include/bits/regex_executor.tcc (_M_handle_repeat, _M_handle_match, _M_handle_accept, _M_node, _M_dfs): Use template parameter. --- libstdc++-v3/include/bits/regex_executor.h | 28 +++++++----- libstdc++-v3/include/bits/regex_executor.tcc | 47 +++++++++++--------- 2 files changed, 45 insertions(+), 30 deletions(-) diff --git a/libstdc++-v3/include/bits/regex_executor.h b/libstdc++-v3/include/bits/regex_executor.h index eccf12c5a087..0cafc26a15b5 100644 --- a/libstdc++-v3/include/bits/regex_executor.h +++ b/libstdc++-v3/include/bits/regex_executor.h @@ -51,10 +51,11 @@ _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(_V2) * The %_Executor class has two modes: DFS mode and BFS mode, controlled * by the function parameter %__search_mode. */ + enum class _Search_mode : unsigned char { _Bfs = 0, _Dfs = 1 }; + template class _Executor { - enum class _Search_mode : unsigned char { _BFS = 0, _DFS = 1 }; enum class _Match_mode : unsigned char { _Exact, _Prefix }; public: @@ -82,12 +83,12 @@ _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(_V2) _M_start(_M_nfa._M_start()), _M_visited_states(nullptr), _M_flags(__flags), - _M_search_mode(__use_dfs ? _Search_mode::_DFS : _Search_mode::_BFS) + _M_search_mode(__use_dfs ? _Search_mode::_Dfs : _Search_mode::_Bfs) { using namespace regex_constants; if (__flags & match_prev_avail) // ignore not_bol and not_bow _M_flags &= ~(match_not_bol | match_not_bow); - if (_M_search_mode == _Search_mode::_BFS) + if (_M_search_mode == _Search_mode::_Bfs) _M_visited_states = new bool[_M_nfa.size()]; } @@ -117,13 +118,16 @@ _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(_V2) _StateIdT _M_rep_once_more(_Match_mode __match_mode, _StateIdT); + template<_Search_mode __search_mode> _StateIdT _M_handle_repeat(_Match_mode, _StateIdT); - _StateIdT + template<_Search_mode __search_mode> + _StateIdT _M_handle_subexpr_begin(_Match_mode, _StateIdT); - _StateIdT + template<_Search_mode __search_mode> + _StateIdT _M_handle_subexpr_end(_Match_mode, _StateIdT); _StateIdT @@ -138,28 +142,32 @@ _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(_V2) _StateIdT _M_handle_subexpr_lookahead(_Match_mode, _StateIdT); - _StateIdT + template<_Search_mode __search_mode> + _StateIdT _M_handle_match(_Match_mode, _StateIdT); _StateIdT _M_handle_backref(_Match_mode, _StateIdT); - _StateIdT + template<_Search_mode __search_mode> + _StateIdT _M_handle_accept(_Match_mode, _StateIdT); _StateIdT _M_handle_alternative(_Match_mode, _StateIdT); - _StateIdT + template<_Search_mode __search_mode> + _StateIdT _M_node(_Match_mode, _StateIdT); - void + template<_Search_mode __search_mode> + void _M_dfs(_Match_mode __match_mode, _StateIdT __start); bool _M_main(_Match_mode __match_mode) { - if (_M_search_mode == _Search_mode::_DFS) + if (_M_search_mode == _Search_mode::_Dfs) return _M_main_dfs(__match_mode); else return _M_main_bfs(__match_mode); diff --git a/libstdc++-v3/include/bits/regex_executor.tcc b/libstdc++-v3/include/bits/regex_executor.tcc index 9361c27d4c5b..a4cce445e350 100644 --- a/libstdc++-v3/include/bits/regex_executor.tcc +++ b/libstdc++-v3/include/bits/regex_executor.tcc @@ -165,7 +165,7 @@ namespace __detail _M_has_sol = false; *_M_get_sol_pos() = _BiIter(); _M_cur_results = _M_results; - _M_dfs(__match_mode, _M_start); + _M_dfs<_Search_mode::_Dfs>(__match_mode, _M_start); return _M_has_sol; } @@ -208,7 +208,7 @@ namespace __detail for (auto& __task : __old_queue) { _M_cur_results = _ResultsVec(std::move(__task.second), __alloc); - _M_dfs(__match_mode, __task.first); + _M_dfs<_Search_mode::_Bfs>(__match_mode, __task.first); } if (__match_mode == _Match_mode::_Prefix) __ret |= _M_has_sol; @@ -288,6 +288,7 @@ namespace __detail // mean the same thing, and we need to choose the correct order under // given greedy mode. template + template<_Search_mode __search_mode> #ifdef __OPTIMIZE__ [[__gnu__::__always_inline__]] #endif @@ -298,7 +299,7 @@ namespace __detail // Greedy. if (!__state._M_neg) { - if (_M_search_mode == _Search_mode::_DFS) + if constexpr (__search_mode == _Search_mode::_Dfs) // If it's DFS executor and already accepted, we're done. _M_frames.emplace_back(_S_fopcode_fallback_next, __state._M_next, _M_current); @@ -308,7 +309,7 @@ namespace __detail } else // Non-greedy mode { - if (_M_search_mode == _Search_mode::_DFS) + if constexpr (__search_mode == _Search_mode::_Dfs) { // vice-versa. _M_frames.emplace_back(_S_fopcode_fallback_rep_once_more, __i, @@ -334,6 +335,7 @@ namespace __detail } template + template<_Search_mode __search_mode> #ifdef __OPTIMIZE__ [[__gnu__::__always_inline__]] #endif @@ -344,7 +346,7 @@ namespace __detail auto& __res = _M_cur_results[__state._M_subexpr]; if (_M_nfa._M_has_backref || __state._M_subexpr != 0 - || _M_search_mode != _Search_mode::_DFS) + || __search_mode != _Search_mode::_Dfs) _M_frames.emplace_back(_S_fopcode_restore_cur_results, static_cast<_StateIdT>(__state._M_subexpr), __res.first); @@ -353,6 +355,7 @@ namespace __detail } template + template<_Search_mode __search_mode> #ifdef __OPTIMIZE__ [[__gnu__::__always_inline__]] #endif @@ -363,7 +366,7 @@ namespace __detail auto& __res = _M_cur_results[__state._M_subexpr]; if (_M_nfa._M_has_backref || __state._M_subexpr != 0 - || _M_search_mode != _Search_mode::_DFS) + || __search_mode != _Search_mode::_Dfs) { _M_frames.emplace_back(_S_fopcode_restore_cur_results, static_cast<_StateIdT>(__state._M_subexpr), @@ -420,6 +423,7 @@ namespace __detail } template + template<_Search_mode __search_mode> #ifdef __OPTIMIZE__ [[__gnu__::__always_inline__]] #endif @@ -429,7 +433,7 @@ namespace __detail const auto& __state = _M_nfa[__i]; if (_M_current == _M_end) return _S_invalid_state_id; - if (_M_search_mode == _Search_mode::_DFS) + if constexpr (__search_mode == _Search_mode::_Dfs) { if (__state._M_matches(*_M_current)) { @@ -500,7 +504,7 @@ namespace __detail _StateIdT _Executor<_BiIter, _Alloc, _TraitsT>:: _M_handle_backref(_Match_mode, _StateIdT __i) { - __glibcxx_assert(_M_search_mode == _Search_mode::_DFS); + __glibcxx_assert(_M_search_mode == _Search_mode::_Dfs); const auto& __state = _M_nfa[__i]; auto& __submatch = _M_cur_results[__state._M_backref_index]; @@ -524,13 +528,14 @@ namespace __detail } template + template<_Search_mode __search_mode> #ifdef __OPTIMIZE__ [[__gnu__::__always_inline__]] #endif inline _StateIdT _Executor<_BiIter, _Alloc, _TraitsT>:: _M_handle_accept(_Match_mode __match_mode, _StateIdT) { - if (_M_search_mode == _Search_mode::_DFS) + if constexpr (__search_mode == _Search_mode::_Dfs) { __glibcxx_assert(!_M_has_sol); if (__match_mode == _Match_mode::_Exact) @@ -606,6 +611,7 @@ namespace __detail } template + template<_Search_mode __search_mode> #ifdef __OPTIMIZE__ [[__gnu__::__always_inline__]] #endif @@ -614,7 +620,7 @@ namespace __detail { // DFS has no _M_visited implementation as such don't even have the branch // or the check in the call graph. - if (_M_search_mode == _Search_mode::_BFS) + if constexpr (__search_mode == _Search_mode::_Bfs) if (_M_visited(__i)) return _S_invalid_state_id; @@ -622,12 +628,12 @@ namespace __detail switch (_M_nfa[__i]._M_opcode()) { case _S_opcode_repeat: - __next = _M_handle_repeat(__match_mode, __i); break; + __next = _M_handle_repeat<__search_mode>(__match_mode, __i); break; case _S_opcode_subexpr_begin: - __next = _M_handle_subexpr_begin(__match_mode, __i); + __next = _M_handle_subexpr_begin<__search_mode>(__match_mode, __i); break; case _S_opcode_subexpr_end: - __next = _M_handle_subexpr_end(__match_mode, __i); + __next = _M_handle_subexpr_end<__search_mode>(__match_mode, __i); break; case _S_opcode_line_begin_assertion: __next = _M_handle_line_begin_assertion(__match_mode, __i); break; @@ -638,15 +644,15 @@ namespace __detail case _S_opcode_subexpr_lookahead: __next = _M_handle_subexpr_lookahead(__match_mode, __i); break; case _S_opcode_match: - __next = _M_handle_match(__match_mode, __i); break; + __next = _M_handle_match<__search_mode>(__match_mode, __i); break; case _S_opcode_backref: - if (_M_search_mode == _Search_mode::_DFS) + if constexpr (__search_mode == _Search_mode::_Dfs) __next = _M_handle_backref(__match_mode, __i); else __builtin_unreachable(); break; case _S_opcode_accept: - __next = _M_handle_accept(__match_mode, __i); break; + __next = _M_handle_accept<__search_mode>(__match_mode, __i); break; case _S_opcode_alternative: __next = _M_handle_alternative(__match_mode, __i); break; default: @@ -656,6 +662,7 @@ namespace __detail } template + template<_Search_mode __search_mode> void _Executor<_BiIter, _Alloc, _TraitsT>:: _M_dfs(_Match_mode __match_mode, _StateIdT __start) { @@ -667,7 +674,7 @@ namespace __detail // loop until we fail. This avoids the needless state save and // restore through memory. while (__next != _S_invalid_state_id) - __next = _M_node(__match_mode, __next); + __next = _M_node<__search_mode>(__match_mode, __next); if (_M_frames.empty()) break; @@ -680,7 +687,7 @@ namespace __detail case _S_fopcode_fallback_next: if (_M_has_sol) break; - if (_M_search_mode == _Search_mode::_DFS) + if constexpr (__search_mode == _Search_mode::_Dfs) _M_current = __frame._M_pos; [[__fallthrough__]]; case _S_fopcode_next: @@ -690,7 +697,7 @@ namespace __detail case _S_fopcode_fallback_rep_once_more: if (_M_has_sol) break; - if (_M_search_mode == _Search_mode::_DFS) + if constexpr (__search_mode == _Search_mode::_Dfs) _M_current = __frame._M_pos; [[__fallthrough__]]; case _S_fopcode_rep_once_more: @@ -700,7 +707,7 @@ namespace __detail case _S_fopcode_posix_alternative: _M_frames.emplace_back(_S_fopcode_merge_sol, 0, _M_has_sol); __next = __frame._M_state_id; - if (_M_search_mode == _Search_mode::_DFS) + if constexpr (__search_mode == _Search_mode::_Dfs) _M_current = __frame._M_pos; _M_has_sol = false; break; From ded7c4e851228c008304bad10d6b0aedc9deef3b Mon Sep 17 00:00:00 2001 From: Tamar Christina Date: Tue, 22 Sep 2026 07:22:45 +0100 Subject: [PATCH 321/584] libstdc++: Reject impossible regex DFS starts early [PR126274] This patch add a conservative first-character precheck for DFS prefix search. regex_search and regex_token_iterator try the pattern at each possible input position. However for many regexp some of those positions can be rejected by looking through the front (without consuming state) before building th full DFS state which can be expensive to build only to realize that nothing matches. The pre-check only returns false when every inspected path reaches a first consuming match state that rejects *_M_current, or reaches a dead end. It returns true for unsupported or context-sensitive states such as backrefs and lookahead, so true means "run the normal executor" and false means "this start position cannot match". This mainly helps IPv4-style scans where most positions are non-digits and only a few positions can start a match. Benchmarks improvements compared to GCC previous patch in series: at -O2: email: +2.4% URI: +3.6% IPv4 +43.9% at -O3: email: +0.1%, URI: +1.4% IPv4: +42.7% libstdc++-v3/ChangeLog: PR libstdc++/126274 PR libstdc++/88947 * include/bits/regex_executor.h (_M_search_from_first): Avoid needless recursions. (_M_maybe_start_match): New. * include/bits/regex_executor.tcc (_M_maybe_start_match): New. --- libstdc++-v3/include/bits/regex_executor.h | 25 ++++++ libstdc++-v3/include/bits/regex_executor.tcc | 95 ++++++++++++++++++++ 2 files changed, 120 insertions(+) diff --git a/libstdc++-v3/include/bits/regex_executor.h b/libstdc++-v3/include/bits/regex_executor.h index 0cafc26a15b5..65a2d62183e4 100644 --- a/libstdc++-v3/include/bits/regex_executor.h +++ b/libstdc++-v3/include/bits/regex_executor.h @@ -108,6 +108,28 @@ _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(_V2) _M_search_from_first() { _M_current = _M_begin; + // Fast reject for DFS prefix search. regex_search and + // regex_token_iterator try the pattern at each possible starting + // position. If the regex can only start with a digit, running the full + // DFS executor at a space, letter, or punctuation character only builds + // frames to discover the first match state rejects that character. + // + // Example: for the IPv4 pattern + // (?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9])\.){3}... + // a current input character of 'x' cannot match any first consuming + // state. _M_maybe_start_match returns false and this starting position + // is skipped. At '2' it returns true, because at least one branch + // might match, so the normal executor still decides the complete + // result. + // + // This is intentionally disabled for backreferences. Pruning the + // search space for DFS reduces the number of frames we build and the + // time to find an actual match. + if (_M_search_mode == _Search_mode::_Dfs + && !_M_nfa._M_has_backref + && _M_current != _M_end + && !_M_maybe_start_match(_M_start, 0)) + return false; return _M_main(_Match_mode::_Prefix); } @@ -176,6 +198,9 @@ _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(_V2) bool _M_main_dfs(_Match_mode __match_mode); + bool + _M_maybe_start_match(_StateIdT, size_t); + bool _M_main_bfs(_Match_mode __match_mode); diff --git a/libstdc++-v3/include/bits/regex_executor.tcc b/libstdc++-v3/include/bits/regex_executor.tcc index a4cce445e350..747c9c3d3253 100644 --- a/libstdc++-v3/include/bits/regex_executor.tcc +++ b/libstdc++-v3/include/bits/regex_executor.tcc @@ -169,6 +169,101 @@ namespace __detail return _M_has_sol; } + // Return whether a prefix search at _M_current might still match after + // looking only through the non-consuming front of the NFA. + // + // This is not a general implementation. It is deliberately small and + // conservative: when it reaches a construct whose first consuming character + // is hard to know cheaply, it returns true and lets the normal executor run. + // The important fast paths are the common negative cases. + // + // Examples: + // * Pattern "[0-9]+" at input 'x': the first _S_opcode_match rejects 'x', + // so a full DFS search would only allocate/pop frames to fail. Return + // false and let regex_search advance the starting position. + // + // * Pattern "[01]?[0-9]" at input '9': the optional [01] branch rejects, + // but the skip branch can consume '9'. Return true and let DFS decide + // the full match. + // + // * Pattern "foo|bar" at input 'b': one alternative rejects, the other can + // start with 'b'. Return true. + template + bool _Executor<_BiIter, _Alloc, _TraitsT>:: + _M_maybe_start_match(_StateIdT __i, size_t __depth) + { + // Depth is bounded by the NFA size so epsilon cycles cannot make the + // precheck recurse forever. Hitting the bound means "unknown", not + // "no match", so stay conservative and run the real executor. This is + // important for patterns such as "(a*)*" where epsilon paths can cycle + // before a consuming state is reached. + if (__depth > _M_nfa.size()) + return true; + + // An invalid edge is a real dead end for the explored path. + if (__i == _S_invalid_state_id) + return false; + + const auto& __state = _M_nfa[__i]; + switch (__state._M_opcode()) + { + case _S_opcode_match: + return __state._M_matches(*_M_current); + + case _S_opcode_accept: + // Empty matches are possible, so the full executor must decide. + return true; + + case _S_opcode_subexpr_begin: + case _S_opcode_subexpr_end: + case _S_opcode_dummy: + // Captures and dummy states do not consume input, so they cannot + // affect the first-character decision. Continue along the only + // successor. + return _M_maybe_start_match(__state._M_next, __depth + 1); + + case _S_opcode_line_begin_assertion: + // Assertions do not consume characters, but they can reject the + // current position. For "^abc" at a non-begin position, there is no + // need to run DFS merely to discover that ^ fails. + return _M_at_begin() + && _M_maybe_start_match(__state._M_next, __depth + 1); + + case _S_opcode_line_end_assertion: + // Same idea for "$": if the assertion does not hold here, this + // starting position cannot match via this path. + return _M_at_end() + && _M_maybe_start_match(__state._M_next, __depth + 1); + + case _S_opcode_word_boundary: + // Word-boundary assertions are also checked before the first + // consuming state. For "\bfoo" in the middle of "xfoo", this path + // rejects before testing 'f'. + return _M_word_boundary() == !__state._M_neg + && _M_maybe_start_match(__state._M_next, __depth + 1); + + case _S_opcode_alternative: + // A branch might match if either arm can start with *_M_current. + // Example: "foo|bar" at 'b' rejects the "foo" arm but keeps the + // search because the "bar" arm is viable. + return _M_maybe_start_match(__state._M_alt, __depth + 1) + || _M_maybe_start_match(__state._M_next, __depth + 1); + + case _S_opcode_repeat: + // Repeats can either enter the body or skip to the exit, so inspect + // both paths. This matters for constructs such as "[01]?[0-9]": at + // '9' the optional first digit can be skipped, while at 'x' both + // paths reject. + return _M_maybe_start_match(__state._M_alt, __depth + 1) + || _M_maybe_start_match(__state._M_next, __depth + 1); + + case _S_opcode_backref: + case _S_opcode_subexpr_lookahead: + default: + return true; + } + } + // ------------------------------------------------------------ // // BFS mode: From a0b77a14fed845f742ef378d6cb911c8d78ed625 Mon Sep 17 00:00:00 2001 From: Tamar Christina Date: Tue, 22 Sep 2026 07:23:41 +0100 Subject: [PATCH 322/584] libstdc++: Inline simple regex repeating matches in DFS [PR126274] Optimize the common DFS NFA shape repeat -> match -> repeat, which is produced by repeated character classes such as [\w]+, [^\s?#]+, and #+. Since the second patch the DFS continuation already avoids pushing a separate _S_fopcode_next frame for many states. This patch adds a small improvement for greedy repeats. After creating the same fallback and repeat bookkeeping frames as before, if the repeated body is a single match state that returns to the repeat state, consume that match state immediately and continue at the repeat. Backtracking behavior is unchanged. _M_rep_once_more still creates the restore/decrement frames, and the repeat exit fallback is still saved before trying the body. If the body match fails, the helper returns _S_invalid_state_id so the normal frame loop restores repeat state and tries pending fallbacks. Benchmarks improvements compared to GCC previous patch in series: at -O2: email: +4.7% URI: +5.1% IPv4 -1.1% at -O3: email: +4.5%, URI: +4.1% IPv4: -0.2% And finally gets us better than GCC 15. I outlined the helper into _M_match_simple_repeat_body since that looks more readable. libstdc++-v3/ChangeLog: PR libstdc++/126274 * include/bits/regex_executor.h (_M_match_simple_repeat_body): New. * include/bits/regex_executor.tcc (_M_dfs_next): Inline consume matches on _S_opcode_repeat. (_M_match_simple_repeat_body): New. --- libstdc++-v3/include/bits/regex_executor.h | 3 ++ libstdc++-v3/include/bits/regex_executor.tcc | 31 +++++++++++++++++++- 2 files changed, 33 insertions(+), 1 deletion(-) diff --git a/libstdc++-v3/include/bits/regex_executor.h b/libstdc++-v3/include/bits/regex_executor.h index 65a2d62183e4..51de0f521133 100644 --- a/libstdc++-v3/include/bits/regex_executor.h +++ b/libstdc++-v3/include/bits/regex_executor.h @@ -140,6 +140,9 @@ _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(_V2) _StateIdT _M_rep_once_more(_Match_mode __match_mode, _StateIdT); + _StateIdT + _M_match_simple_repeat_body(_StateIdT, _StateIdT); + template<_Search_mode __search_mode> _StateIdT _M_handle_repeat(_Match_mode, _StateIdT); diff --git a/libstdc++-v3/include/bits/regex_executor.tcc b/libstdc++-v3/include/bits/regex_executor.tcc index 747c9c3d3253..d4f7a2a4bd57 100644 --- a/libstdc++-v3/include/bits/regex_executor.tcc +++ b/libstdc++-v3/include/bits/regex_executor.tcc @@ -378,6 +378,31 @@ namespace __detail return _S_invalid_state_id; } + // Try to consume the common repeat body shape + // repeat -> match -> repeat + // without going through the generic state dispatch again. + template +#ifdef __OPTIMIZE__ + [[__gnu__::__always_inline__]] +#endif + inline _StateIdT _Executor<_BiIter, _Alloc, _TraitsT>:: + _M_match_simple_repeat_body(_StateIdT __next, _StateIdT __repeat) + { + if (__next == _S_invalid_state_id) + return _S_invalid_state_id; + + const auto& __state = _M_nfa[__next]; + if (__state._M_opcode() != _S_opcode_match + || __state._M_next != __repeat) + return __next; + + if (_M_current == _M_end || !__state._M_matches(*_M_current)) + return _S_invalid_state_id; + + ++_M_current; + return __repeat; + } + // _M_alt branch is "match once more", while _M_next is "get me out // of this quantifier". Executing _M_next first or _M_alt first don't // mean the same thing, and we need to choose the correct order under @@ -400,7 +425,11 @@ namespace __detail _M_current); else _M_frames.emplace_back(_S_fopcode_next, __state._M_next); - return _M_rep_once_more(__match_mode, __i); + _StateIdT __next = _M_rep_once_more(__match_mode, __i); + if constexpr (__search_mode == _Search_mode::_Dfs) + return _M_match_simple_repeat_body(__next, __i); + else + return __next; } else // Non-greedy mode { From e4f550457b0b5c9c87356f6dfc60ae980e319585 Mon Sep 17 00:00:00 2001 From: Patrick Palka Date: Thu, 17 Sep 2026 09:26:02 +0200 Subject: [PATCH 323/584] libstdc++: Fix SFINAE with shared_ptr and invalid deleter [PR126120] MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This implements the [util.smartptr.shared.const] constraints on the constructors that take a deleter (which before C++20 were requirements rather than constraints). In passing proactively implement the proposed resolution of LWG 4110 which relaxes these constraints on the nullptr_t overloads. PR libstdc++/126120 libstdc++-v3/ChangeLog: * include/bits/shared_ptr.h (std::__shared_nullptr_ctor_tag): Define. (shared_ptr::shared_ptr(nullptr_t, ...)): Constrain _Deleter via _NullptrDeleter parameter. * include/bits/shared_ptr_base.h (__shared_ptr::_ValidDeleter): New __enable_if_t constraint. (__shared_ptr::__shared_ptr(Yp*, _Deleter, ...)): Add _ValidDeleter constraint. Move static_assert checking deleter invocability to corresponding reset functions. (__shared_ptr::reset): Add static_assert checks for deleter invocability. * testsuite/20_util/shared_ptr/cons/126120.cc: New test. Co-authored-by: Tomasz Kamiński Reviewed-by: Jonathan Wakely --- libstdc++-v3/include/bits/shared_ptr.h | 22 ++++++++- libstdc++-v3/include/bits/shared_ptr_base.h | 40 +++++++++++------ .../20_util/shared_ptr/cons/126120.cc | 45 +++++++++++++++++++ 3 files changed, 91 insertions(+), 16 deletions(-) create mode 100644 libstdc++-v3/testsuite/20_util/shared_ptr/cons/126120.cc diff --git a/libstdc++-v3/include/bits/shared_ptr.h b/libstdc++-v3/include/bits/shared_ptr.h index 8be9aace1711..99cedf12d436 100644 --- a/libstdc++-v3/include/bits/shared_ptr.h +++ b/libstdc++-v3/include/bits/shared_ptr.h @@ -102,6 +102,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// @cond undocumented + // Used as parameter type when constraining nullptr constructor + struct __shared_nullptr_ctor_tag + { + constexpr explicit + __shared_nullptr_ctor_tag(__shared_nullptr_ctor_tag*) + { } + }; + // Constraint for overloads taking non-array types. #if __cpp_concepts && __glibcxx_type_trait_variable_templates template @@ -166,6 +174,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr& >::type; + template + using _NullptrDeleter = __enable_if_t< + __is_invocable<_Deleter&, nullptr_t&>::value, + __shared_nullptr_ctor_tag>; + public: /// The type pointed to by the stored pointer, remove_extent_t<_Tp> @@ -212,6 +225,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION shared_ptr(_Yp* __p, _Deleter __d) : __shared_ptr<_Tp>(__p, std::move(__d)) { } + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 4110. shared_ptr(nullptr_t, Deleter) is overconstrained... + /** * @brief Construct a %shared_ptr that owns a null pointer * and the deleter @a __d. @@ -226,7 +242,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * The last owner will call __d(__p) */ template - shared_ptr(nullptr_t __p, _Deleter __d) + shared_ptr(nullptr_t __p, _Deleter __d, + _NullptrDeleter<_Deleter> = __shared_nullptr_ctor_tag(nullptr)) : __shared_ptr<_Tp>(__p, std::move(__d)) { } /** @@ -265,7 +282,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * The last owner will call __d(__p) */ template - shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) + shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a, + _NullptrDeleter<_Deleter> = __shared_nullptr_ctor_tag(nullptr)) : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { } // Aliasing constructor diff --git a/libstdc++-v3/include/bits/shared_ptr_base.h b/libstdc++-v3/include/bits/shared_ptr_base.h index c8342b7904a5..b67a697c6df6 100644 --- a/libstdc++-v3/include/bits/shared_ptr_base.h +++ b/libstdc++-v3/include/bits/shared_ptr_base.h @@ -1504,6 +1504,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>; + // Constraint for well-formedness of deleter expression d(p): + template + using _ValidDeleter = __enable_if_t< + __is_invocable<_Deleter&, _Up&>::value>; + public: #if __cplusplus > 201402L @@ -1524,24 +1529,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _M_enable_shared_from_this_with(__p); } - template> + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 4110. shared_ptr(nullptr_t, Deleter) is overconstrained, breaking some + // sensible deleters + + template, + typename = _ValidDeleter<_Deleter, _Yp*>> __shared_ptr(_Yp* __p, _Deleter __d) : _M_ptr(__p), _M_refcount(__p, std::move(__d)) - { - static_assert(__is_invocable<_Deleter&, _Yp*&>::value, - "deleter expression d(p) is well-formed"); - _M_enable_shared_from_this_with(__p); - } + { _M_enable_shared_from_this_with(__p); } template> + typename = _SafeConv<_Yp>, typename = _ValidDeleter<_Deleter, _Yp*>> __shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a) : _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a)) - { - static_assert(__is_invocable<_Deleter&, _Yp*&>::value, - "deleter expression d(p) is well-formed"); - _M_enable_shared_from_this_with(__p); - } + { _M_enable_shared_from_this_with(__p); } template __shared_ptr(nullptr_t __p, _Deleter __d) @@ -1704,12 +1706,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template _SafeConv<_Yp> reset(_Yp* __p, _Deleter __d) - { __shared_ptr(__p, std::move(__d)).swap(*this); } + { + static_assert(__is_invocable<_Deleter&, _Yp*&>::value, + "deleter expression d(p) is well-formed"); + + __shared_ptr(__p, std::move(__d)).swap(*this); + } template _SafeConv<_Yp> reset(_Yp* __p, _Deleter __d, _Alloc __a) - { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); } + { + static_assert(__is_invocable<_Deleter&, _Yp*&>::value, + "deleter expression d(p) is well-formed"); + + __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); + } /// Return the stored pointer. element_type* diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/cons/126120.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/126120.cc new file mode 100644 index 000000000000..7a82358200e3 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/shared_ptr/cons/126120.cc @@ -0,0 +1,45 @@ +// PR libstdc++/126120 - is_constructible_v with shared_ptr from an invalid deleter +// { dg-do compile { target c++11 } } + +#include +#include + +struct NonDeleter { }; + +struct NonMoveableDeleter +{ + NonMoveableDeleter() = default; + NonMoveableDeleter(const NonMoveableDeleter&) = delete; + void operator()(int* p) const { delete p; } +}; + +using shared_ptr = std::shared_ptr; +using Alloc = std::allocator; + +// 1. Pointer + Deleter +static_assert( ! std::is_constructible::value, ""); +static_assert( ! std::is_constructible::value, ""); + +// 2. Pointer + Deleter + Allocator +static_assert( ! std::is_constructible::value, ""); +static_assert( ! std::is_constructible::value, ""); + +// 3. nullptr_t + Deleter +static_assert( ! std::is_constructible::value, ""); +static_assert( ! std::is_constructible::value, ""); + +// 4. nullptr_t + Deleter + Allocator +static_assert( ! std::is_constructible::value, ""); +static_assert( ! std::is_constructible::value, ""); + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++20-extensions" // lambda template +void +test_lwg4110() +{ + // LWG 4110 - shared_ptr(nullptr_t, Deleter) is overconstrained, breaking some sensible deleters + auto deleter = [](T pointer) { delete pointer; }; + shared_ptr p(new int, deleter); + shared_ptr q(new int, deleter, Alloc{}); +} +#pragma GCC diagnostic pop From e41707b1ff25dd152bc280dd9170313b2356d6a6 Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Tue, 22 Sep 2026 10:26:33 +0200 Subject: [PATCH 324/584] Ada: Fix run-time crash for imported C array declared without size This is a regression introduced by a couple of recent unrelated changes, which shows that adding an implicit indirection for large objects that are declared at the library level may be problematic, especially when they are intended to be part of an interface, e.g. to a foreign language. Therefore, this changes the compiler to stop adding the indirection for large objects subject to an aspect/pragma Export or Import. As a result, the compiler or the linker will issue error messages for them. gcc/ada/ * gcc-interface/decl.cc (allocatable_size_p): Add INTERFACE_P parameter and return true for any fixed size when it is true. (gnat_to_gnu_entity): Add EXPORTED_P local variable and use it throughout. : Adjust calls to allocatable_size_p by passing true for INTERFACE_P if the object is exported or imported. Remove unreachable code giving a warning for too large imported objects. --- gcc/ada/gcc-interface/decl.cc | 50 ++++++++++++++++------------------- 1 file changed, 23 insertions(+), 27 deletions(-) diff --git a/gcc/ada/gcc-interface/decl.cc b/gcc/ada/gcc-interface/decl.cc index be2df77fcfff..75a60f63fb3d 100644 --- a/gcc/ada/gcc-interface/decl.cc +++ b/gcc/ada/gcc-interface/decl.cc @@ -215,7 +215,7 @@ static bool compile_time_known_address_p (Node_Id); static bool flb_cannot_be_superflat (Node_Id); static bool range_cannot_be_superflat (Node_Id); static bool constructor_address_p (tree); -static bool allocatable_size_p (tree, bool); +static bool allocatable_size_p (tree, bool, bool); static bool initial_value_needs_conversion (tree, tree); static tree update_n_elem (tree, tree, tree); static int compare_field_bitpos (const void *, const void *); @@ -307,6 +307,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition) const bool artificial_p = is_artificial (gnat_entity); /* True if debug info is requested for this entity. */ const bool debug_info_p = Needs_Debug_Info (gnat_entity); + const bool exported_p = Is_Exported (gnat_entity); /* True if this entity is to be considered as imported. */ const bool imported_p = (Is_Imported (gnat_entity) && No (Address_Clause (gnat_entity))); @@ -748,7 +749,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition) objects by making them volatile. */ bool volatile_flag = (Treat_As_Volatile (gnat_entity) - || (!const_flag && (Is_Exported (gnat_entity) || imported_p))); + || (!const_flag && (exported_p || imported_p))); bool mutable_p = false; bool used_by_ref = false; tree gnu_ext_name = NULL_TREE; @@ -939,7 +940,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition) && kind != E_Out_Parameter && Is_Composite_Type (gnat_type) && !Is_Constr_Array_Subt_With_Bounds (gnat_type) - && !Is_Exported (gnat_entity) + && !exported_p && !imported_p && No (gnat_renamed_obj) && No (Address_Clause (gnat_entity)))) @@ -1415,7 +1416,8 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition) if (!allocatable_size_p (TYPE_SIZE_UNIT (gnu_type), global_bindings_p () || !definition - || static_flag) + || static_flag, + exported_p || imported_p) || (gnu_size && !allocatable_size_p (convert (sizetype, size_binop @@ -1423,29 +1425,20 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, bool definition) bitsize_unit_node)), global_bindings_p () || !definition - || static_flag))) + || static_flag, + exported_p || imported_p))) { /* Give a warning if the size is constant. */ if ((TREE_CODE (TYPE_SIZE_UNIT (gnu_type)) == INTEGER_CST || (gnu_size && TREE_CODE (gnu_size) == INTEGER_CST)) - && definition) + && definition + && (global_bindings_p () || static_flag)) { - if (imported_p) - { - post_error - ("??too large object cannot be imported directly", - gnat_entity); - post_error ("\\??indirect import will be used instead", + post_error + ("??too large object cannot be allocated statically", + gnat_entity); + post_error ("\\??dynamic allocation will be used instead", gnat_entity); - } - else if (global_bindings_p () || static_flag) - { - post_error - ("??too large object cannot be allocated statically", - gnat_entity); - post_error ("\\??dynamic allocation will be used instead", - gnat_entity); - } } if (volatile_flag && !TYPE_VOLATILE (gnu_type)) @@ -7110,17 +7103,20 @@ constructor_address_p (tree gnu_expr) /* Return true if the size in units represented by GNU_SIZE can be handled by an allocation. If STATIC_P is true, consider only what can be done with a - static allocation. */ + static allocation. If INTERFACE_P is true, the allocation is intended to + be part of an explicit interface to other units, possibly foreign. */ static bool -allocatable_size_p (tree gnu_size, bool static_p) +allocatable_size_p (tree gnu_size, bool static_p, bool interface_p) { /* We can allocate a fixed size if it is a valid for the middle-end but, for a static allocation, we do not allocate more than 2 GB because this would - very likely be unintended and problematic for usual code models. */ - if (TREE_CODE (gnu_size) == INTEGER_CST) - return valid_constant_size_p (gnu_size) - && (!static_p || tree_to_uhwi (gnu_size) <= INT_MAX); + very likely be unintended and problematic for usual code models. But we + do not try to fiddle with allocations that are part of an interface. */ + if (TREE_CODE (gnu_size) == INTEGER_CST) + return (interface_p + || (valid_constant_size_p (gnu_size) + && (!static_p || tree_to_uhwi (gnu_size) <= INT_MAX))); /* We can allocate a variable size if this isn't a static allocation. */ else From 3e3c6a575f6e5ca2da6bb19bb905ec0668c89d48 Mon Sep 17 00:00:00 2001 From: Viljar Indus Date: Tue, 22 Sep 2026 10:55:07 +0200 Subject: [PATCH 325/584] Ada: Fix crash in can_equal_min_or_max_val_p This changes can_equal_min_or_max_val_p to update the value only when we are dealing with a known integral type, instead of with a pointer type for which min/max values are not defined. gcc/ada/ * gcc-interface/trans.cc (can_equal_min_Or_max_val_p): Add guard for integral types. --- gcc/ada/gcc-interface/trans.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/gcc/ada/gcc-interface/trans.cc b/gcc/ada/gcc-interface/trans.cc index 0c2d8685de12..628a1174eca0 100644 --- a/gcc/ada/gcc-interface/trans.cc +++ b/gcc/ada/gcc-interface/trans.cc @@ -2886,7 +2886,8 @@ can_equal_min_or_max_val_p (tree val, tree type, bool max) if (TREE_CODE (min_or_max_val) != INTEGER_CST) return true; - if (TREE_CODE (val) == NOP_EXPR) + if (TREE_CODE (val) == NOP_EXPR + && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (val, 0)))) val = (max ? TYPE_MAX_VALUE (TREE_TYPE (TREE_OPERAND (val, 0))) : TYPE_MIN_VALUE (TREE_TYPE (TREE_OPERAND (val, 0)))); From ca800bd07d2d0eb1f00dcb3314aaf34df8230053 Mon Sep 17 00:00:00 2001 From: Wilco Dijkstra Date: Tue, 22 Sep 2026 10:55:07 +0200 Subject: [PATCH 326/584] AArch64: Avoid general_operand in atomic_store The generic atomic_store pattern uses general_operand which blocks CSE if the store value is an immediate. Fix by using aarch64_reg_or_zero. gcc: * config/aarch64/atomics.md (atomic_store): Use aarch64_reg_or_zero. gcc/testsuite: * gcc.target/aarch64/atomic-store2.c: New test. --- gcc/config/aarch64/atomics.md | 2 +- gcc/testsuite/gcc.target/aarch64/atomic-store2.c | 14 ++++++++++++++ 2 files changed, 15 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.target/aarch64/atomic-store2.c diff --git a/gcc/config/aarch64/atomics.md b/gcc/config/aarch64/atomics.md index 940aa15ac718..0cddbfa9b3d1 100644 --- a/gcc/config/aarch64/atomics.md +++ b/gcc/config/aarch64/atomics.md @@ -735,7 +735,7 @@ (define_insn "atomic_store" [(set (match_operand:ALLI 0 "aarch64_rcpc_memory_operand" "=Q,Ust") (unspec_volatile:ALLI - [(match_operand:ALLI 1 "general_operand" "rZ,rZ") + [(match_operand:ALLI 1 "aarch64_reg_or_zero" "rZ,rZ") (match_operand:SI 2 "const_int_operand")] ;; model UNSPECV_STL))] "" diff --git a/gcc/testsuite/gcc.target/aarch64/atomic-store2.c b/gcc/testsuite/gcc.target/aarch64/atomic-store2.c new file mode 100644 index 000000000000..85b6cba6f5bc --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/atomic-store2.c @@ -0,0 +1,14 @@ +/* { dg-do compile } */ +/* { dg-options "-march=armv8-a -O2" } */ + +#include + +void +foo (int *p, long *q) +{ + atomic_store_explicit (p, 2, memory_order_relaxed); + atomic_store_explicit (p + 1, 2, memory_order_release); + atomic_store_explicit (p + 2, 2, memory_order_relaxed); +} + +/* { dg-final { scan-assembler-times "mov\tw\[0-9\]+, 2" 1 } } */ From 4b78815305fa285ad223f08b52128afdae782a62 Mon Sep 17 00:00:00 2001 From: Andrew Stubbs Date: Wed, 1 Jul 2026 11:58:25 +0000 Subject: [PATCH 327/584] i386, rtl: Replace BASE_REG_CLASS macro family with a hook This patch replaces the separate macros BASE_REG_CLASS, MODE_BASE_REG_CLASS, MODE_BASE_REG_REG_CLASS, MODE_CODE_BASE_REG_CLASS, and INSN_BASE_REG_CLASS into a single hook: TARGET_BASE_REG_CLASS. It also adds a new parameter, MEM, that is intended to be used by AMD GCN soon. Adding this is the main motivation for changing the hook, but this patch should not change the behaviour of anything, yet. Rather than replace every definition of these macros in every backend, this keeps those as the default implementation of the hook. INSN_BASE_REG_CLASS had only one caller (i386), and was the one that I was interesting in extending, so it has been entirely deleted. This patch was largely generated using AI, but as the edits are mechanical changes with no real new content I do not believe them to be "legally significant" (a lot of lines are touched, but its the same thing repeated). Assisted-by: Claude Sonnet 5 gcc/ChangeLog: * target.def (base_reg_class): New target hook. * targhooks.h (default_base_reg_class): Declare. * targhooks.cc (default_base_reg_class): New function, implementing the previous BASE_REG_CLASS/MODE_BASE_REG_CLASS/ MODE_BASE_REG_REG_CLASS/MODE_CODE_BASE_REG_CLASS macro fallback chain as the hook's default. * addresses.h (base_reg_class): Rewrite to call the TARGET_BASE_REG_CLASS hook instead of dispatching through INSN_BASE_REG_CLASS and the other macros by hand; add a MEM parameter. * rtl.h (address_info): Add mem field. * rtlanal.cc (decompose_mem_address): Set it. * lra-constraints.cc (simplify_operand_subreg, process_alt_operands, base_to_reg, base_plus_disp_to_reg, process_address_1, curr_insn_transform): Pass the enclosing MEM, and INSN where previously omitted, to base_reg_class. * reload.cc (find_reloads, find_reloads_address, find_reloads_address_1, find_reloads_subreg_address): Likewise. * reload1.cc (maybe_fix_stack_asms): Likewise. * regcprop.cc: Include target.h. (replace_oldest_value_addr, replace_oldest_value_mem): Pass MEM to base_reg_class. * regrename.cc (base_reg_class_for_rename): Add a MEM parameter. (scan_rtx_address, scan_rtx): Pass it. * caller-save.cc: Include target.h. * config/i386/i386.h (INSN_BASE_REG_CLASS): Delete. * config/i386/i386-protos.h (ix86_insn_base_reg_class): Delete declaration. * config/i386/i386.cc (ix86_insn_base_reg_class): Rename to... (ix86_base_reg_class): ...this, adjust the signature, and implement TARGET_BASE_REG_CLASS instead of INSN_BASE_REG_CLASS. (TARGET_BASE_REG_CLASS): Define. * doc/tm.texi.in: Add TARGET_BASE_REG_CLASS. Mark BASE_REG_CLASS, MODE_BASE_REG_CLASS, MODE_BASE_REG_REG_CLASS and MODE_CODE_BASE_REG_CLASS as obsolete in favor of the new hook, and remove the now-unused INSN_BASE_REG_CLASS. * doc/tm.texi: Regenerate. --- gcc/addresses.h | 34 ++++++------------------ gcc/caller-save.cc | 1 + gcc/config/i386/i386-protos.h | 1 - gcc/config/i386/i386.cc | 15 ++++++++--- gcc/config/i386/i386.h | 3 --- gcc/doc/tm.texi | 49 ++++++++++++++++++++++++++++------- gcc/doc/tm.texi.in | 21 +++++++++------ gcc/lra-constraints.cc | 23 +++++++++------- gcc/regcprop.cc | 9 ++++--- gcc/regrename.cc | 13 +++++----- gcc/reload.cc | 44 ++++++++++++++++++------------- gcc/reload1.cc | 3 ++- gcc/rtl.h | 4 +++ gcc/rtlanal.cc | 1 + gcc/target.def | 32 +++++++++++++++++++++++ gcc/targhooks.cc | 31 ++++++++++++++++++++++ gcc/targhooks.h | 3 +++ 17 files changed, 199 insertions(+), 88 deletions(-) diff --git a/gcc/addresses.h b/gcc/addresses.h index 6a9ffcd7cb3f..7ce34554ee7c 100644 --- a/gcc/addresses.h +++ b/gcc/addresses.h @@ -17,38 +17,20 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ -/* Wrapper function to unify target macros MODE_CODE_BASE_REG_CLASS, - MODE_BASE_REG_REG_CLASS, MODE_BASE_REG_CLASS and BASE_REG_CLASS. - Arguments as for the MODE_CODE_BASE_REG_CLASS macro. */ +/* Wrapper function around the TARGET_BASE_REG_CLASS hook. MEM is the + MEM rtx being addressed, if known, and INSN is the instruction it + belongs to, if known; both may be null. */ #ifndef GCC_ADDRESSES_H #define GCC_ADDRESSES_H inline enum reg_class -base_reg_class (machine_mode mode ATTRIBUTE_UNUSED, - addr_space_t as ATTRIBUTE_UNUSED, - enum rtx_code outer_code ATTRIBUTE_UNUSED, - enum rtx_code index_code ATTRIBUTE_UNUSED, - rtx_insn *insn ATTRIBUTE_UNUSED = NULL) +base_reg_class (machine_mode mode, addr_space_t as, + enum rtx_code outer_code, enum rtx_code index_code, + rtx mem = NULL_RTX, rtx_insn *insn = NULL) { -#ifdef INSN_BASE_REG_CLASS - return INSN_BASE_REG_CLASS (insn); -#else -#ifdef MODE_CODE_BASE_REG_CLASS - return MODE_CODE_BASE_REG_CLASS (MACRO_MODE (mode), as, outer_code, - index_code); -#else -#ifdef MODE_BASE_REG_REG_CLASS - if (index_code == REG) - return MODE_BASE_REG_REG_CLASS (MACRO_MODE (mode)); -#endif -#ifdef MODE_BASE_REG_CLASS - return MODE_BASE_REG_CLASS (MACRO_MODE (mode)); -#else - return BASE_REG_CLASS; -#endif -#endif -#endif + return (enum reg_class) targetm.base_reg_class (mode, as, outer_code, + index_code, mem, insn); } inline enum reg_class diff --git a/gcc/caller-save.cc b/gcc/caller-save.cc index 281aa0bb0094..5e1a38e47dbc 100644 --- a/gcc/caller-save.cc +++ b/gcc/caller-save.cc @@ -21,6 +21,7 @@ along with GCC; see the file COPYING3. If not see #include "system.h" #include "coretypes.h" #include "backend.h" +#include "target.h" #include "rtl.h" #include "tree.h" #include "predict.h" diff --git a/gcc/config/i386/i386-protos.h b/gcc/config/i386/i386-protos.h index 2687de646b04..4e56bf70c8d5 100644 --- a/gcc/config/i386/i386-protos.h +++ b/gcc/config/i386/i386-protos.h @@ -83,7 +83,6 @@ extern bool ix86_expand_set_or_cpymem (rtx, rtx, rtx, rtx, rtx, rtx, extern bool ix86_expand_set_or_movmem (rtx[], bool, bool); extern bool ix86_expand_cmpstrn_or_cmpmem (rtx, rtx, rtx, rtx, rtx, bool); -extern enum reg_class ix86_insn_base_reg_class (rtx_insn *); extern bool ix86_regno_ok_for_insn_base_p (int, rtx_insn *); extern enum reg_class ix86_insn_index_reg_class (rtx_insn *); extern bool constant_address_p (rtx); diff --git a/gcc/config/i386/i386.cc b/gcc/config/i386/i386.cc index 29e1d2c58087..915a2d8385df 100644 --- a/gcc/config/i386/i386.cc +++ b/gcc/config/i386/i386.cc @@ -12121,10 +12121,16 @@ ix86_memory_address_reg_class (rtx_insn* insn) return addr_rclass; } -/* Return memory address register class insn can use. */ +/* Implement TARGET_BASE_REG_CLASS. -enum reg_class -ix86_insn_base_reg_class (rtx_insn* insn) + Return memory address register class INSN can use. MODE, AS, OUTER_CODE, + INDEX_CODE and MEM are unused: the EGPR-encoding restriction this + implements depends only on the instruction, not on the particular address + being formed. */ + +static reg_class_t +ix86_base_reg_class (machine_mode, addr_space_t, enum rtx_code, enum rtx_code, + rtx, rtx_insn *insn) { switch (ix86_memory_address_reg_class (insn)) { @@ -29084,6 +29090,9 @@ ix86_libgcc_floating_mode_supported_p #undef TARGET_CLASS_MAX_NREGS #define TARGET_CLASS_MAX_NREGS ix86_class_max_nregs +#undef TARGET_BASE_REG_CLASS +#define TARGET_BASE_REG_CLASS ix86_base_reg_class + #undef TARGET_PREFERRED_RELOAD_CLASS #define TARGET_PREFERRED_RELOAD_CLASS ix86_preferred_reload_class #undef TARGET_PREFERRED_OUTPUT_RELOAD_CLASS diff --git a/gcc/config/i386/i386.h b/gcc/config/i386/i386.h index fc961fb777ca..47725c560906 100644 --- a/gcc/config/i386/i386.h +++ b/gcc/config/i386/i386.h @@ -1099,9 +1099,6 @@ extern const char *host_detect_local_cpu (int argc, const char **argv); #define ADJUST_REG_ALLOC_ORDER x86_order_regs_for_local_alloc () -#define INSN_BASE_REG_CLASS(INSN) \ - ix86_insn_base_reg_class (INSN) - #define REGNO_OK_FOR_INSN_BASE_P(NUM, INSN) \ ix86_regno_ok_for_insn_base_p (NUM, INSN) diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index ca68bdc3e615..97afd0175220 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -2550,6 +2550,9 @@ register. A macro whose definition is the name of the class to which a valid base register must belong. A base register is one used in an address which is the register value plus a displacement. + +This macro is obsolete, new ports should use the target hook +@code{TARGET_BASE_REG_CLASS} instead. @end defmac @defmac MODE_BASE_REG_CLASS (@var{mode}) @@ -2557,6 +2560,9 @@ This is a variation of the @code{BASE_REG_CLASS} macro which allows the selection of a base register in a mode dependent manner. If @var{mode} is VOIDmode then it should return the same value as @code{BASE_REG_CLASS}. + +This macro is obsolete, new ports should use the target hook +@code{TARGET_BASE_REG_CLASS} instead. @end defmac @defmac MODE_BASE_REG_REG_CLASS (@var{mode}) @@ -2564,6 +2570,9 @@ A C expression whose value is the register class to which a valid base register must belong in order to be used in a base plus index register address. You should define this macro if base plus index addresses have different requirements than other base register uses. + +This macro is obsolete, new ports should use the target hook +@code{TARGET_BASE_REG_CLASS} instead. @end defmac @defmac MODE_CODE_BASE_REG_CLASS (@var{mode}, @var{address_space}, @var{outer_code}, @var{index_code}) @@ -2575,16 +2584,38 @@ the code of the immediately enclosing expression (@code{MEM} for the top level of an address, @code{ADDRESS} for something that occurs in an @code{address_operand}). @var{index_code} is the code of the corresponding index expression if @var{outer_code} is @code{PLUS}; @code{SCRATCH} otherwise. -@end defmac -@defmac INSN_BASE_REG_CLASS (@var{insn}) -A C expression whose value is the register class to which a valid -base register for a specified @var{insn} must belong. This macro is -used when some backend insns may have limited usage of base register -compared with other insns. If you define this macro, the compiler will -use it instead of all other defined macros that relate to -BASE_REG_CLASS. -@end defmac +This macro is obsolete, new ports should use the target hook +@code{TARGET_BASE_REG_CLASS} instead. +@end defmac + +@deftypefn {Target Hook} reg_class_t TARGET_BASE_REG_CLASS (machine_mode @var{mode}, addr_space_t @var{as}, enum rtx_code @var{outer_code}, enum rtx_code @var{index_code}, rtx @var{mem}, rtx_insn *@var{insn}) +A target hook that returns the register class to which a valid base +register for memory addressing must belong. @var{mode} and @var{as} are +the mode and address space of the value being addressed, @var{outer_code} +and @var{index_code} are the codes of the address expression and of the +index expression respectively (or @code{SCRATCH} where an index is not +applicable). + +If the address being asked about is the address of a particular +@code{MEM}, @var{mem} is that @code{MEM} rtx; otherwise it is null. When +non-null, targets should determine the required class by examining +@var{mem} directly (for example, to see whether the address side of the +@code{MEM} is itself held in a general or a vector register) rather than +by making assumptions from @var{mode} and @var{as} alone, since more than +one @code{MEM} of the same mode and address space can appear within a +single @var{insn} with different base-register requirements. + +If the specific instruction being processed is known, @var{insn} is that +instruction; otherwise it is null. This is provided for targets that +need context wider than a single @code{MEM}, such as avoiding particular +addressing-register encodings on specific instructions. + +The default implementation ignores @var{mem} and @var{insn} and calls the +legacy macros @code{BASE_REG_CLASS}, @code{MODE_BASE_REG_CLASS}, +@code{MODE_BASE_REG_REG_CLASS} and @code{MODE_CODE_BASE_REG_CLASS} instead, +based on @var{mode}, @var{as}, @var{outer_code} and @var{index_code} alone. +@end deftypefn @defmac INDEX_REG_CLASS A macro whose definition is the name of the class to which a valid diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in index 532e95ef216f..2113b9c679a3 100644 --- a/gcc/doc/tm.texi.in +++ b/gcc/doc/tm.texi.in @@ -2135,6 +2135,9 @@ register. A macro whose definition is the name of the class to which a valid base register must belong. A base register is one used in an address which is the register value plus a displacement. + +This macro is obsolete, new ports should use the target hook +@code{TARGET_BASE_REG_CLASS} instead. @end defmac @defmac MODE_BASE_REG_CLASS (@var{mode}) @@ -2142,6 +2145,9 @@ This is a variation of the @code{BASE_REG_CLASS} macro which allows the selection of a base register in a mode dependent manner. If @var{mode} is VOIDmode then it should return the same value as @code{BASE_REG_CLASS}. + +This macro is obsolete, new ports should use the target hook +@code{TARGET_BASE_REG_CLASS} instead. @end defmac @defmac MODE_BASE_REG_REG_CLASS (@var{mode}) @@ -2149,6 +2155,9 @@ A C expression whose value is the register class to which a valid base register must belong in order to be used in a base plus index register address. You should define this macro if base plus index addresses have different requirements than other base register uses. + +This macro is obsolete, new ports should use the target hook +@code{TARGET_BASE_REG_CLASS} instead. @end defmac @defmac MODE_CODE_BASE_REG_CLASS (@var{mode}, @var{address_space}, @var{outer_code}, @var{index_code}) @@ -2160,17 +2169,13 @@ the code of the immediately enclosing expression (@code{MEM} for the top level of an address, @code{ADDRESS} for something that occurs in an @code{address_operand}). @var{index_code} is the code of the corresponding index expression if @var{outer_code} is @code{PLUS}; @code{SCRATCH} otherwise. -@end defmac -@defmac INSN_BASE_REG_CLASS (@var{insn}) -A C expression whose value is the register class to which a valid -base register for a specified @var{insn} must belong. This macro is -used when some backend insns may have limited usage of base register -compared with other insns. If you define this macro, the compiler will -use it instead of all other defined macros that relate to -BASE_REG_CLASS. +This macro is obsolete, new ports should use the target hook +@code{TARGET_BASE_REG_CLASS} instead. @end defmac +@hook TARGET_BASE_REG_CLASS + @defmac INDEX_REG_CLASS A macro whose definition is the name of the class to which a valid index register must belong. An index register is one used in an diff --git a/gcc/lra-constraints.cc b/gcc/lra-constraints.cc index 16866033d50c..0f9bb3da6df1 100644 --- a/gcc/lra-constraints.cc +++ b/gcc/lra-constraints.cc @@ -1763,7 +1763,8 @@ simplify_operand_subreg (int nop, machine_mode reg_mode) [ira_class_hard_regs [base_reg_class (GET_MODE (subst), MEM_ADDR_SPACE (subst), - ADDRESS, SCRATCH)][0]], + ADDRESS, SCRATCH, + subst, curr_insn)][0]], MEM_ADDR_SPACE (subst)))) { /* If we change the address for a paradoxical subreg of memory, the @@ -2945,7 +2946,8 @@ process_alt_operands (int only_alternative) if (satisfies_address_constraint_p (op, cn)) win = true; cl = base_reg_class (VOIDmode, ADDR_SPACE_GENERIC, - ADDRESS, SCRATCH); + ADDRESS, SCRATCH, NULL_RTX, + curr_insn); cl_filter = nullptr; cl_dep_filter = nullptr; badop = false; @@ -3862,7 +3864,7 @@ base_to_reg (struct address_info *ad) lra_assert (ad->disp == ad->disp_term); cl = base_reg_class (ad->mode, ad->as, ad->base_outer_code, - get_index_code (ad)); + get_index_code (ad), ad->mem, curr_insn); new_reg = lra_create_new_reg (GET_MODE (*ad->base), NULL_RTX, cl, NULL, "base"); new_inner = simplify_gen_binary (PLUS, GET_MODE (new_reg), new_reg, @@ -3891,7 +3893,7 @@ base_plus_disp_to_reg (struct address_info *ad, rtx disp) lra_assert (ad->base == ad->base_term); cl = base_reg_class (ad->mode, ad->as, ad->base_outer_code, - get_index_code (ad)); + get_index_code (ad), ad->mem, curr_insn); new_reg = lra_create_new_reg (GET_MODE (*ad->base_term), NULL_RTX, cl, NULL, "base + disp"); lra_emit_add (new_reg, *ad->base_term, disp); @@ -4184,7 +4186,7 @@ process_address_1 (int nop, bool check_only_p, REGNO (*ad.base_term)) != NULL_RTX) ? after : NULL), base_reg_class (ad.mode, ad.as, ad.base_outer_code, - get_index_code (&ad), curr_insn)))) + get_index_code (&ad), ad.mem, curr_insn)))) { change_p = true; if (ad.base_term2 != NULL) @@ -4235,7 +4237,7 @@ process_address_1 (int nop, bool check_only_p, int code = -1; enum reg_class cl = base_reg_class (ad.mode, ad.as, SCRATCH, SCRATCH, - curr_insn); + ad.mem, curr_insn); rtx addr = *ad.inner; new_reg = lra_create_new_reg (Pmode, NULL_RTX, cl, NULL, "addr"); @@ -4299,7 +4301,7 @@ process_address_1 (int nop, bool check_only_p, case (1) above. */ enum reg_class cl = base_reg_class (ad.mode, ad.as, PLUS, GET_CODE (*ad.index), - curr_insn); + ad.mem, curr_insn); lra_assert (index_cl != NO_REGS); new_reg = lra_create_new_reg (Pmode, NULL_RTX, cl, NULL, "disp"); @@ -4316,7 +4318,7 @@ process_address_1 (int nop, bool check_only_p, rtx_insn *insns, *last_insn; cl = base_reg_class (ad.mode, ad.as, ad.base_outer_code, - get_index_code (&ad), curr_insn); + get_index_code (&ad), ad.mem, curr_insn); if (REG_P (*ad.base_term) && ira_class_subset_p[get_reg_class (REGNO (*ad.base_term))][cl]) @@ -4414,7 +4416,8 @@ process_address_1 (int nop, bool check_only_p, enum reg_class cl; rtx addr; reload_inner_addr: - cl = base_reg_class (ad.mode, ad.as, SCRATCH, SCRATCH, curr_insn); + cl = base_reg_class (ad.mode, ad.as, SCRATCH, SCRATCH, ad.mem, + curr_insn); addr = *ad.inner; new_reg = lra_create_new_reg (Pmode, NULL_RTX, cl, NULL, "addr"); /* addr => new_base. */ @@ -5186,7 +5189,7 @@ curr_insn_transform (bool check_only_p) push_to_sequence (before); rclass = base_reg_class (GET_MODE (op), MEM_ADDR_SPACE (op), - MEM, SCRATCH, curr_insn); + MEM, SCRATCH, op, curr_insn); if (GET_RTX_CLASS (code) == RTX_AUTOINC) new_reg = emit_inc (rclass, *loc, /* This value does not matter for MODIFY. */ diff --git a/gcc/regcprop.cc b/gcc/regcprop.cc index 2a9956353cc6..9ef99d6838d5 100644 --- a/gcc/regcprop.cc +++ b/gcc/regcprop.cc @@ -21,6 +21,7 @@ #include "system.h" #include "coretypes.h" #include "backend.h" +#include "target.h" #include "rtl.h" #include "df.h" #include "memmodel.h" @@ -34,7 +35,6 @@ #include "tree-pass.h" #include "rtl-iter.h" #include "cfgrtl.h" -#include "target.h" #include "function-abi.h" #include "cfgcleanup.h" @@ -696,7 +696,9 @@ replace_oldest_value_addr (rtx *loc, enum reg_class cl, if (locB) changed |= replace_oldest_value_addr (locB, base_reg_class (mode, as, PLUS, - index_code), + index_code, + NULL_RTX, + insn), mode, as, insn, vd); return changed; } @@ -744,7 +746,8 @@ replace_oldest_value_mem (rtx x, rtx_insn *insn, struct value_data *vd) if (DEBUG_INSN_P (insn)) cl = ALL_REGS; else - cl = base_reg_class (GET_MODE (x), MEM_ADDR_SPACE (x), MEM, SCRATCH); + cl = base_reg_class (GET_MODE (x), MEM_ADDR_SPACE (x), MEM, SCRATCH, + x, insn); return replace_oldest_value_addr (&XEXP (x, 0), cl, GET_MODE (x), MEM_ADDR_SPACE (x), diff --git a/gcc/regrename.cc b/gcc/regrename.cc index 07c3659f8a8c..bc02b28117fa 100644 --- a/gcc/regrename.cc +++ b/gcc/regrename.cc @@ -1299,16 +1299,17 @@ scan_rtx_reg (rtx_insn *insn, rtx *loc, enum reg_class cl, enum scan_actions act } /* A wrapper around base_reg_class which returns ALL_REGS if INSN is a - DEBUG_INSN. The arguments MODE, AS, CODE and INDEX_CODE are as for - base_reg_class. */ + DEBUG_INSN. The arguments MODE, AS, CODE, INDEX_CODE and MEM are as + for base_reg_class. */ static reg_class base_reg_class_for_rename (rtx_insn *insn, machine_mode mode, addr_space_t as, - rtx_code code, rtx_code index_code) + rtx_code code, rtx_code index_code, + rtx mem = NULL_RTX) { if (DEBUG_INSN_P (insn)) return ALL_REGS; - return base_reg_class (mode, as, code, index_code); + return base_reg_class (mode, as, code, index_code, mem, insn); } /* Adapted from find_reloads_address_1. CL is INDEX_REG_CLASS or @@ -1452,7 +1453,7 @@ scan_rtx_address (rtx_insn *insn, rtx *loc, enum reg_class cl, { reg_class bclass = base_reg_class_for_rename (insn, GET_MODE (x), MEM_ADDR_SPACE (x), - MEM, SCRATCH); + MEM, SCRATCH, x); scan_rtx_address (insn, &XEXP (x, 0), bclass, action, GET_MODE (x), MEM_ADDR_SPACE (x)); } @@ -1503,7 +1504,7 @@ scan_rtx (rtx_insn *insn, rtx *loc, enum reg_class cl, enum scan_actions action, { reg_class bclass = base_reg_class_for_rename (insn, GET_MODE (x), MEM_ADDR_SPACE (x), - MEM, SCRATCH); + MEM, SCRATCH, x); scan_rtx_address (insn, &XEXP (x, 0), bclass, action, GET_MODE (x), MEM_ADDR_SPACE (x)); diff --git a/gcc/reload.cc b/gcc/reload.cc index c6d99b1527fb..6f4711d782ed 100644 --- a/gcc/reload.cc +++ b/gcc/reload.cc @@ -3326,7 +3326,7 @@ find_reloads (rtx_insn *insn, int replace, int ind_levels, int live_known, were handled in find_reloads_address. */ this_alternative[i] = base_reg_class (VOIDmode, ADDR_SPACE_GENERIC, - ADDRESS, SCRATCH, insn); + ADDRESS, SCRATCH, NULL_RTX, insn); win = 1; badop = 0; break; @@ -3513,7 +3513,7 @@ find_reloads (rtx_insn *insn, int replace, int ind_levels, int live_known, the address into a base register. */ this_alternative[i] = base_reg_class (VOIDmode, ADDR_SPACE_GENERIC, - ADDRESS, SCRATCH, insn); + ADDRESS, SCRATCH, NULL_RTX, insn); badop = 0; break; @@ -4023,7 +4023,8 @@ find_reloads (rtx_insn *insn, int replace, int ind_levels, int live_known, operand_reloadnum[i] = push_reload (XEXP (recog_data.operand[i], 0), NULL_RTX, &XEXP (recog_data.operand[i], 0), (rtx*) 0, - base_reg_class (VOIDmode, as, MEM, SCRATCH, insn), + base_reg_class (VOIDmode, as, MEM, SCRATCH, + recog_data.operand[i], insn), address_mode, VOIDmode, 0, 0, i, RELOAD_OTHER); rld[operand_reloadnum[i]].inc @@ -4902,8 +4903,10 @@ find_reloads_address (machine_mode mode, rtx *memrefloc, rtx ad, if (reg_equiv_constant (regno) != 0) { find_reloads_address_part (reg_equiv_constant (regno), loc, - base_reg_class (mode, as, MEM, - SCRATCH, insn), + base_reg_class (mode, as, MEM, SCRATCH, + (memrefloc ? *memrefloc + : NULL_RTX), + insn), GET_MODE (ad), opnum, type, ind_levels); return 1; } @@ -4972,7 +4975,8 @@ find_reloads_address (machine_mode mode, rtx *memrefloc, rtx ad, /* If we do not have one of the cases above, we must do the reload. */ push_reload (ad, NULL_RTX, loc, (rtx*) 0, - base_reg_class (mode, as, MEM, SCRATCH, insn), + base_reg_class (mode, as, MEM, SCRATCH, + memrefloc ? *memrefloc : NULL_RTX, insn), GET_MODE (ad), VOIDmode, 0, 0, opnum, type); return 1; } @@ -5073,9 +5077,8 @@ find_reloads_address (machine_mode mode, rtx *memrefloc, rtx ad, /* Must use TEM here, not AD, since it is the one that will have any subexpressions reloaded, if needed. */ push_reload (tem, NULL_RTX, loc, (rtx*) 0, - base_reg_class (mode, as, MEM, SCRATCH), GET_MODE (tem), - VOIDmode, 0, - 0, opnum, type); + base_reg_class (mode, as, MEM, SCRATCH, tem, insn), + GET_MODE (tem), VOIDmode, 0, 0, opnum, type); return ! removed_and; } else @@ -5129,8 +5132,10 @@ find_reloads_address (machine_mode mode, rtx *memrefloc, rtx ad, reload the sum into a base reg. That will at least work. */ find_reloads_address_part (ad, loc, - base_reg_class (mode, as, MEM, - SCRATCH, insn), + base_reg_class (mode, as, MEM, SCRATCH, + (memrefloc ? *memrefloc + : NULL_RTX), + insn), GET_MODE (ad), opnum, type, ind_levels); } return ! removed_and; @@ -5210,7 +5215,8 @@ find_reloads_address (machine_mode mode, rtx *memrefloc, rtx ad, op_index == 0 ? addend : offset_reg); *loc = ad; - cls = base_reg_class (mode, as, MEM, GET_CODE (addend), insn); + cls = base_reg_class (mode, as, MEM, GET_CODE (addend), + memrefloc ? *memrefloc : NULL_RTX, insn); find_reloads_address_part (XEXP (ad, op_index), &XEXP (ad, op_index), cls, GET_MODE (ad), opnum, type, ind_levels); @@ -5268,8 +5274,10 @@ find_reloads_address (machine_mode mode, rtx *memrefloc, rtx ad, } find_reloads_address_part (ad, loc, - base_reg_class (mode, as, MEM, - SCRATCH, insn), + base_reg_class (mode, as, MEM, SCRATCH, + (memrefloc ? *memrefloc + : NULL_RTX), + insn), address_mode, opnum, type, ind_levels); return ! removed_and; } @@ -5522,7 +5530,7 @@ find_reloads_address_1 (machine_mode mode, addr_space_t as, context_reg_class = index_reg_class (insn); else context_reg_class = base_reg_class (mode, as, outer_code, index_code, - insn); + NULL_RTX, insn); switch (code) { @@ -5748,7 +5756,7 @@ find_reloads_address_1 (machine_mode mode, addr_space_t as, &XEXP (op1, 0), base_reg_class (mode, as, code, index_code, - insn), + tem, insn), GET_MODE (x), GET_MODE (x), 0, 0, opnum, RELOAD_OTHER); @@ -5767,7 +5775,7 @@ find_reloads_address_1 (machine_mode mode, addr_space_t as, &XEXP (op1, 0), &XEXP (x, 0), base_reg_class (mode, as, code, index_code, - insn), + NULL_RTX, insn), GET_MODE (x), GET_MODE (x), 0, 0, opnum, RELOAD_OTHER); @@ -6227,7 +6235,7 @@ find_reloads_subreg_address (rtx x, int opnum, enum reload_type type, { push_reload (XEXP (tem, 0), NULL_RTX, &XEXP (tem, 0), (rtx*) 0, base_reg_class (GET_MODE (tem), MEM_ADDR_SPACE (tem), - MEM, SCRATCH, insn), + MEM, SCRATCH, tem, insn), GET_MODE (XEXP (tem, 0)), VOIDmode, 0, 0, opnum, type); reloaded = 1; } diff --git a/gcc/reload1.cc b/gcc/reload1.cc index 638aca6aceef..3f338bde16ab 100644 --- a/gcc/reload1.cc +++ b/gcc/reload1.cc @@ -1390,7 +1390,8 @@ maybe_fix_stack_asms (void) if (insn_extra_address_constraint (cn)) cls = (int) reg_class_subunion[cls] [(int) base_reg_class (VOIDmode, ADDR_SPACE_GENERIC, - ADDRESS, SCRATCH, chain->insn)]; + ADDRESS, SCRATCH, NULL_RTX, + chain->insn)]; else cls = (int) reg_class_subunion[cls] [reg_class_for_constraint (cn)]; diff --git a/gcc/rtl.h b/gcc/rtl.h index 065fe8c86c77..d61e576c9402 100644 --- a/gcc/rtl.h +++ b/gcc/rtl.h @@ -2231,6 +2231,10 @@ struct address_info { /* True if this is an RTX_AUTOINC address. */ bool autoinc_p; + /* The MEM whose address this is, or null if this describes an address + operand with no enclosing MEM (an ADDRESS rather than a MEM address). */ + rtx mem; + /* A pointer to the top-level address. */ rtx *outer; diff --git a/gcc/rtlanal.cc b/gcc/rtlanal.cc index d897dc400ea5..df4a69d180ae 100644 --- a/gcc/rtlanal.cc +++ b/gcc/rtlanal.cc @@ -6886,6 +6886,7 @@ decompose_mem_address (struct address_info *info, rtx x) gcc_assert (MEM_P (x)); decompose_address (info, &XEXP (x, 0), GET_MODE (x), MEM_ADDR_SPACE (x), MEM); + info->mem = x; } /* Update INFO after a change to the address it describes. */ diff --git a/gcc/target.def b/gcc/target.def index 66c20a9c9d2a..11334f9d443d 100644 --- a/gcc/target.def +++ b/gcc/target.def @@ -6177,6 +6177,38 @@ reload from using some alternatives, like @code{TARGET_PREFERRED_RELOAD_CLASS}." (rtx x, reg_class_t rclass), default_preferred_output_reload_class) +DEFHOOK +(base_reg_class, + "A target hook that returns the register class to which a valid base\n\ +register for memory addressing must belong. @var{mode} and @var{as} are\n\ +the mode and address space of the value being addressed, @var{outer_code}\n\ +and @var{index_code} are the codes of the address expression and of the\n\ +index expression respectively (or @code{SCRATCH} where an index is not\n\ +applicable).\n\ +\n\ +If the address being asked about is the address of a particular\n\ +@code{MEM}, @var{mem} is that @code{MEM} rtx; otherwise it is null. When\n\ +non-null, targets should determine the required class by examining\n\ +@var{mem} directly (for example, to see whether the address side of the\n\ +@code{MEM} is itself held in a general or a vector register) rather than\n\ +by making assumptions from @var{mode} and @var{as} alone, since more than\n\ +one @code{MEM} of the same mode and address space can appear within a\n\ +single @var{insn} with different base-register requirements.\n\ +\n\ +If the specific instruction being processed is known, @var{insn} is that\n\ +instruction; otherwise it is null. This is provided for targets that\n\ +need context wider than a single @code{MEM}, such as avoiding particular\n\ +addressing-register encodings on specific instructions.\n\ +\n\ +The default implementation ignores @var{mem} and @var{insn} and calls the\n\ +legacy macros @code{BASE_REG_CLASS}, @code{MODE_BASE_REG_CLASS},\n\ +@code{MODE_BASE_REG_REG_CLASS} and @code{MODE_CODE_BASE_REG_CLASS} instead,\n\ +based on @var{mode}, @var{as}, @var{outer_code} and @var{index_code} alone.", + reg_class_t, + (machine_mode mode, addr_space_t as, enum rtx_code outer_code, + enum rtx_code index_code, rtx mem, rtx_insn *insn), + default_base_reg_class) + DEFHOOK (select_early_remat_modes, "On some targets, certain modes cannot be held in registers around a\n\ diff --git a/gcc/targhooks.cc b/gcc/targhooks.cc index 388f696c8aa1..7123827cfd7b 100644 --- a/gcc/targhooks.cc +++ b/gcc/targhooks.cc @@ -2322,6 +2322,37 @@ default_preferred_output_reload_class (rtx x ATTRIBUTE_UNUSED, return rclass; } +/* The default implementation of TARGET_BASE_REG_CLASS. */ + +reg_class_t +default_base_reg_class (machine_mode mode ATTRIBUTE_UNUSED, + addr_space_t as ATTRIBUTE_UNUSED, + enum rtx_code outer_code ATTRIBUTE_UNUSED, + enum rtx_code index_code ATTRIBUTE_UNUSED, + rtx mem ATTRIBUTE_UNUSED, + rtx_insn *insn ATTRIBUTE_UNUSED) +{ +#ifdef MODE_CODE_BASE_REG_CLASS + return MODE_CODE_BASE_REG_CLASS (MACRO_MODE (mode), as, outer_code, + index_code); +#else +#ifdef MODE_BASE_REG_REG_CLASS + if (index_code == REG) + return MODE_BASE_REG_REG_CLASS (MACRO_MODE (mode)); +#endif +#ifdef MODE_BASE_REG_CLASS + return MODE_BASE_REG_CLASS (MACRO_MODE (mode)); +#elif defined (BASE_REG_CLASS) + return BASE_REG_CLASS; +#else + /* No target that leaves TARGET_BASE_REG_CLASS at its default also fails + to define BASE_REG_CLASS or one of the other macros above; a target + that defines none of them must override the hook directly instead. */ + gcc_unreachable (); +#endif +#endif +} + /* The default implementation of TARGET_PREFERRED_RENAME_CLASS. */ reg_class_t default_preferred_rename_class (reg_class_t rclass ATTRIBUTE_UNUSED) diff --git a/gcc/targhooks.h b/gcc/targhooks.h index 86de6ef8a699..ffeaeb2a7729 100644 --- a/gcc/targhooks.h +++ b/gcc/targhooks.h @@ -259,6 +259,9 @@ extern void default_print_patchable_function_entry (FILE *, extern bool default_profile_before_prologue (void); extern reg_class_t default_preferred_reload_class (rtx, reg_class_t); extern reg_class_t default_preferred_output_reload_class (rtx, reg_class_t); +extern reg_class_t default_base_reg_class (machine_mode, addr_space_t, + enum rtx_code, enum rtx_code, + rtx, rtx_insn *); extern reg_class_t default_preferred_rename_class (reg_class_t rclass); extern bool default_class_likely_spilled_p (reg_class_t); extern unsigned char default_class_max_nregs (reg_class_t, machine_mode); From 9bb79eb94eded396a50af9460ea66c2faffe1fad Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Tue, 22 Sep 2026 14:13:30 +0200 Subject: [PATCH 328/584] tree-optimization/127497 - add disclaimer to -fwrapv-pointer docs This adds a disclaimer discouraging use of -fwrapv-pointer. * doc/invoke.texi (fwrapv-pointer): Add disclaimer. (fno-strict-overflow): Discourage, suggest fwrapv. --- gcc/doc/invoke.texi | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 498a3608151e..20d82c620f67 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -19270,13 +19270,19 @@ results in @option{-ftrapv} being effective. This option instructs the compiler to assume that pointer arithmetic overflow on addition and subtraction wraps around using twos-complement representation. This flag disables some optimizations which assume -pointer overflow is invalid. +pointer overflow is invalid. @strong{Warning:} this option exists because +of the Linux Kernel's view of what C is. It does @strong{not} turn pointers +into twos-complement numbers or eliminates all rules and guarantees the C +standard has on pointers. @strong{Do not use} this option but rather write +conforming C. @opindex fstrict-overflow @opindex fno-strict-overflow @item -fstrict-overflow This option implies @option{-fno-wrapv} @option{-fno-wrapv-pointer} and when -negated implies @option{-fwrapv} @option{-fwrapv-pointer}. +negated implies @option{-fwrapv} @option{-fwrapv-pointer}. You should +consider using @code{-fwrapv} instead of @code{-fstrict-overflow}, +the (implicit) use of @code{-fwrapv-pointer} is discouraged. @opindex fexceptions @opindex fno-exceptions From a32e1ec926561ce98c0658d62f66b42dc2a9d8b8 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Tue, 22 Sep 2026 13:40:14 +0200 Subject: [PATCH 329/584] Enable live lane extraction costing for loop vect This also makes sure to consistently use vect_body for BB vectorization. * tree-vect-loop.cc (vectorizable_live_operation): Cost the lane extract in vect_body for BB vectorization and in vect_epilog for loop vectorization. --- gcc/tree-vect-loop.cc | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/gcc/tree-vect-loop.cc b/gcc/tree-vect-loop.cc index 5169b60025e5..e724a8f6086e 100644 --- a/gcc/tree-vect-loop.cc +++ b/gcc/tree-vect-loop.cc @@ -10324,10 +10324,8 @@ vectorizable_live_operation (vec_info *vinfo, stmt_vec_info stmt_info, } } } - /* ??? Enable for loop costing as well. */ - if (!loop_vinfo) - record_stmt_cost (cost_vec, 1, vec_to_scalar, slp_node, - 0, vect_epilogue); + record_stmt_cost (cost_vec, 1, vec_to_scalar, slp_node, + 0, loop_vinfo ? vect_epilogue : vect_body); SLP_TREE_LIVE_LANES (slp_node).safe_push (slp_index); return true; } From d28e5377395b71d2d21e77c65fe9d54c6cba91a6 Mon Sep 17 00:00:00 2001 From: Andrew Teylu Date: Tue, 22 Sep 2026 14:49:01 +0200 Subject: [PATCH 330/584] Ada: Close the DWARF 5 line-string stream System.Dwarf_Lines.Open creates a mapped stream for .debug_line_str when the optional DWARF 5 section is present. Close omits that stream, losing one mapped-region allocation on every complete open/close cycle. This changes the procedure to close that stream along with the other debug streams, before closing the object file. gcc/ada/ * libgnat/s-dwalin.ads (Dwarf_Context): Add Has_Line_Str. * libgnat/s-dwalin.adb (Open): Set Has_Line_Str when creating the line-string stream. (Close): Close the line-string stream if it was created. --- gcc/ada/libgnat/s-dwalin.adb | 7 +++++++ gcc/ada/libgnat/s-dwalin.ads | 3 +++ 2 files changed, 10 insertions(+) diff --git a/gcc/ada/libgnat/s-dwalin.adb b/gcc/ada/libgnat/s-dwalin.adb index 678716be8404..589e736b259c 100644 --- a/gcc/ada/libgnat/s-dwalin.adb +++ b/gcc/ada/libgnat/s-dwalin.adb @@ -283,6 +283,10 @@ package body System.Dwarf_Lines is Close (C.Abbrev); Close (C.Info); Close (C.Aranges); + + if C.Has_Line_Str then + Close (C.Line_Str); + end if; end if; Close (C.Obj.all); @@ -516,6 +520,9 @@ package body System.Dwarf_Lines is if Line_Str /= Null_Section then C.Line_Str := Create_Stream (C.Obj.all, Line_Str); + C.Has_Line_Str := True; + else + C.Has_Line_Str := False; end if; -- All operations are successful, context is valid diff --git a/gcc/ada/libgnat/s-dwalin.ads b/gcc/ada/libgnat/s-dwalin.ads index 3b7087f5a926..936389e0046f 100644 --- a/gcc/ada/libgnat/s-dwalin.ads +++ b/gcc/ada/libgnat/s-dwalin.ads @@ -192,6 +192,9 @@ private Has_Debug : Boolean; -- True if all debug sections are available + Has_Line_Str : Boolean; + -- True if the .debug_line_str section is available + Cache : Search_Array_Access; -- Quick access to symbol and debug info (when present). From 325646488a306c36c28e84260b4dd551bd30a47f Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Tue, 22 Sep 2026 14:58:22 +0200 Subject: [PATCH 331/584] builtins: Fix further fallback of atomic builtins [PR127492] This is a continuation of the PR127336 problem, just in a different file. If TER results in val being expanded as a MEM, we need to force it into a register before the atomic operation (and as a bonus for expand_builtin_atomic_fetch_op even better reuse it also for the atomic call itself). 2026-09-22 Jakub Jelinek PR middle-end/127492 * builtins.cc (expand_builtin_atomic_fetch_op): Force val into a pseudo if updates to mem could change its value. (expand_ifn_atomic_bit_test_and): Likewise. * gcc.dg/pr127492.c: New test. Reviewed-by: Richard Biener --- gcc/builtins.cc | 14 ++++++++++++-- gcc/testsuite/gcc.dg/pr127492.c | 19 +++++++++++++++++++ 2 files changed, 31 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/pr127492.c diff --git a/gcc/builtins.cc b/gcc/builtins.cc index c6a730c5b0a0..e31947bfed6d 100644 --- a/gcc/builtins.cc +++ b/gcc/builtins.cc @@ -6949,8 +6949,7 @@ expand_builtin_atomic_fetch_op (machine_mode mode, tree exp, rtx target, { rtx val, mem, ret; enum memmodel model; - tree fndecl; - tree addr; + tree fndecl, addr, oldval; model = get_memmodel (CALL_EXPR_ARG (exp, 2)); @@ -6977,6 +6976,13 @@ expand_builtin_atomic_fetch_op (machine_mode mode, tree exp, rtx target, gcc_assert (TREE_OPERAND (addr, 0) == fndecl); TREE_OPERAND (addr, 0) = builtin_decl_explicit (ext_call); + oldval = CALL_EXPR_ARG (exp, 1); + + if (!ignore && reg_overlap_mentioned_p (mem, val)) + { + val = force_reg (mode, val); + CALL_EXPR_ARG (exp, 1) = make_tree (TREE_TYPE (oldval), val); + } /* If we will emit code after the call, the call cannot be a tail call. If it is emitted as a tail call, a barrier is emitted after it, and @@ -6993,6 +6999,7 @@ expand_builtin_atomic_fetch_op (machine_mode mode, tree exp, rtx target, /* Then issue the arithmetic correction to return the right result. */ if (!ignore) { + CALL_EXPR_ARG (exp, 1) = oldval; if (code == NOT) { ret = expand_simple_binop (mode, AND, ret, val, NULL_RTX, true, @@ -7072,6 +7079,9 @@ expand_ifn_atomic_bit_test_and (gcall *call) if (maybe_expand_insn (icode, 5, ops)) return; + if (reg_overlap_mentioned_p (mem, val)) + val = force_reg (mode, val); + rtx bitval = val; val = expand_simple_binop (mode, ASHIFT, const1_rtx, val, NULL_RTX, true, OPTAB_DIRECT); diff --git a/gcc/testsuite/gcc.dg/pr127492.c b/gcc/testsuite/gcc.dg/pr127492.c new file mode 100644 index 000000000000..89c747602123 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr127492.c @@ -0,0 +1,19 @@ +/* PR middle-end/127492 */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ +/* { dg-additional-options "-latomic" { target libatomic_available } } */ + +#ifdef __SIZEOF_INT128__ +#define T __int128 +#else +#define T long long +#endif +T v = 1; + +int +main () +{ + T r = __atomic_add_fetch (&v, v, __ATOMIC_RELAXED); + if (r != 2 || v != 2) + __builtin_abort (); +} From 4bb47c013d8fd815c6abe592f36f5c7547e0ed61 Mon Sep 17 00:00:00 2001 From: Richard Earnshaw Date: Tue, 15 Sep 2026 17:58:15 +0100 Subject: [PATCH 332/584] aarch64: handle subreg operands to negvti3 [PR127393] gen_highpart will abort if the operand is a subreg; avoid this by rejecting SUBREGs. gcc/ChangeLog: PR target/127393 * config/aarch64/predicates.md (pure_register_operand): New predicate. * config/aarch64/aarch64.md (negvti3): Use it. --- gcc/config/aarch64/aarch64.md | 4 ++-- gcc/config/aarch64/predicates.md | 7 +++++++ 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/gcc/config/aarch64/aarch64.md b/gcc/config/aarch64/aarch64.md index 40f7e8e2881a..7c8915ec3890 100644 --- a/gcc/config/aarch64/aarch64.md +++ b/gcc/config/aarch64/aarch64.md @@ -3756,8 +3756,8 @@ }) (define_expand "negvti3" - [(match_operand:TI 0 "register_operand") - (match_operand:TI 1 "register_operand") + [(match_operand:TI 0 "pure_register_operand") + (match_operand:TI 1 "pure_register_operand") (label_ref (match_operand 2 "" ""))] "" { diff --git a/gcc/config/aarch64/predicates.md b/gcc/config/aarch64/predicates.md index 15d362f04abe..6f4d1dac6bf9 100644 --- a/gcc/config/aarch64/predicates.md +++ b/gcc/config/aarch64/predicates.md @@ -20,6 +20,13 @@ (include "../arm/common.md") +;; Similar to register_operand, but don't allow subregs. This is needed +;; if we want to use operations like gen_highpart while expanding +;; a pattern. +(define_predicate "pure_register_operand" + (and (match_code "reg") + (match_operand 0 "register_operand"))) + (define_predicate "aarch64_sysreg_string" (and (match_code "const_string") (match_test "aarch64_valid_sysreg_name_p (XSTR (op, 0))"))) From 6b1ffdc831718b1e7639d25c37ea1cdef48e1b53 Mon Sep 17 00:00:00 2001 From: Roger Sayle Date: Tue, 22 Sep 2026 15:57:40 +0100 Subject: [PATCH 333/584] x86_64: Improved 128-bit TImode moves from SSE to GPRs with SSE2. This patch improves TImode moves on x86_64 between SSE and general registers with SSE2. This is a partial solution for PR target/114544. Consider the following simple function: typedef __int128 v1ti __attribute__((vector_size(16))); __int128 foo(v1ti x) { return x[0]; } Currently, with default -O2 (-msse2) the 128-bit value is moved via the stack: foo: movaps %xmm0, -24(%rsp) // 5 bytes movq -24(%rsp), %rax // 5 bytes movq -16(%rsp), %rdx // 5 bytes ret Though with -O2 -msse4.1, the transfers can be done directly. foo: movq %xmm0, %rax pextrq $1, %xmm0, %rdx ret With this patch, we make use of SSE2's shuffle functionality to avoid the transfers to and from memory: foo: movq %xmm0, %rax // 5 bytes shufpd $1, %xmm0, %xmm0 // 5 bytes movq %xmm0, %rdx // 5 bytes ret Technically, to avoid using a second register we swap/rotate the high and low lanes between movq instructions, and (not shown above) also swap/rotate the lanes back again (so the source register remains unchanged if the value is still live). This second (restoring) shufpd is eliminated by later RTL passes if it's discovered to be dead code. To make this possible, the Yd constraint that enables allows *movti_internal to match on SSE4_1, is tweaked to form a new YD constraint that allows *movti_internal to match on SSE2. 2026-09-22 Roger Sayle Hongtao Liu gcc/ChangeLog PR target/114544 * config/i386/constraints.md (YD): New constraint, like Yd but allows SSE_REGS on TARGET_SSE2. * config/i386/i386.cc (inline_secondary_memory_needed): Update that TImode moves to GENERAL_REGS don't need to use memory. * config/i386/i386.md (*movti_internal): Change Yd constraint to YD. (define_split): On TARGET_64BIT && TARGET_SSE2 && !TARGET_SSE4_1, split *movti_internal into movq+shufpd+movq+shufpd. gcc/testsuite/ChangeLog * gcc.target/i386/pr126293-15.c: Update test case. * gcc.target/i386/pr126293-5.c: Likewise. --- gcc/config/i386/constraints.md | 6 ++++++ gcc/config/i386/i386.cc | 5 +++++ gcc/config/i386/i386.md | 18 +++++++++++++++++- gcc/testsuite/gcc.target/i386/pr126293-15.c | 6 +++--- gcc/testsuite/gcc.target/i386/pr126293-5.c | 6 +++--- 5 files changed, 34 insertions(+), 7 deletions(-) diff --git a/gcc/config/i386/constraints.md b/gcc/config/i386/constraints.md index e7dec9cc0c0d..af7ebb7670b6 100644 --- a/gcc/config/i386/constraints.md +++ b/gcc/config/i386/constraints.md @@ -98,6 +98,8 @@ ;; z First SSE register. ;; d any EVEX encodable SSE register for AVX512DQ target or ;; any SSE register for SSE4_1 target. +;; D any EVEX encodable SSE register for AVX512DQ target or +;; any SSE register for SSE2 target. ;; p Integer register when TARGET_PARTIAL_REG_STALL is disabled ;; a Integer register when zero extensions with AND are disabled ;; b Any register that can be used as the GOT base when calling @@ -121,6 +123,10 @@ "TARGET_AVX512DQ ? ALL_SSE_REGS : TARGET_SSE4_1 ? SSE_REGS : NO_REGS" "@internal Any EVEX encodable SSE register (@code{%xmm0-%xmm31}) for AVX512DQ target or any SSE register for SSE4_1 target.") +(define_register_constraint "YD" + "TARGET_AVX512DQ ? ALL_SSE_REGS : TARGET_SSE2 ? SSE_REGS : NO_REGS" + "@internal Any EVEX encodable SSE register (@code{%xmm0-%xmm31}) for AVX512DQ target or any SSE register for SSE2 target.") + (define_register_constraint "Yp" "TARGET_PARTIAL_REG_STALL ? NO_REGS : GENERAL_REGS" "@internal Any integer register when TARGET_PARTIAL_REG_STALL is disabled.") diff --git a/gcc/config/i386/i386.cc b/gcc/config/i386/i386.cc index 915a2d8385df..705ebb6c014c 100644 --- a/gcc/config/i386/i386.cc +++ b/gcc/config/i386/i386.cc @@ -21436,6 +21436,11 @@ inline_secondary_memory_needed (machine_mode mode, reg_class_t class1, && (TARGET_64BIT ? mode == TImode : mode == DImode)) return false; + /* Moves from SSE_REGS to GENERAL_REGS need only SSE2: + *movti_internal splits them into movq + shufpd + movq. */ + if (TARGET_64BIT && mode == TImode && SSE_CLASS_P (class1)) + return false; + int msize = GET_MODE_SIZE (mode); /* Between SSE and general, we have moves no larger than word size. */ diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md index 9888644ed91c..0d4749e6e091 100644 --- a/gcc/config/i386/i386.md +++ b/gcc/config/i386/i386.md @@ -2553,7 +2553,7 @@ (define_insn "*movti_internal" [(set (match_operand:TI 0 "nonimmediate_operand" "=!r ,o ,v,v ,v ,m,?jc,?Yd") - (match_operand:TI 1 "general_operand" "riFo,re,C,BC,vm,v,Yd,jc"))] + (match_operand:TI 1 "general_operand" "riFo,re,C,BC,vm,v,YD,jc"))] "(TARGET_64BIT && !(MEM_P (operands[0]) && MEM_P (operands[1]))) || (TARGET_SSE @@ -2831,6 +2831,22 @@ gen_lowpart (mode, operands[1])); }) +(define_split + [(set (match_operand:TI 0 "general_reg_operand") + (match_operand:TI 1 "sse_reg_operand"))] + "TARGET_64BIT && TARGET_SSE2 && !TARGET_SSE4_1 + && reload_completed" + [(const_int 0)] +{ + rtx lo = gen_lowpart (DImode, operands[1]); + rtx tmp = gen_rtx_REG (V2DImode, REGNO (operands[1])); + emit_move_insn (gen_lowpart (DImode, operands[0]), lo); + emit_insn (gen_sse2_shufpd_v2di (tmp, tmp, tmp, const1_rtx, GEN_INT (2))); + emit_move_insn (gen_highpart (DImode, operands[0]), lo); + emit_insn (gen_sse2_shufpd_v2di (tmp, tmp, tmp, const1_rtx, GEN_INT (2))); + DONE; +}) + (define_split [(set (match_operand:DWI 0 "nonimmediate_gr_operand") (match_operand:DWI 1 "general_gr_operand"))] diff --git a/gcc/testsuite/gcc.target/i386/pr126293-15.c b/gcc/testsuite/gcc.target/i386/pr126293-15.c index 058e432058d8..b791a7aa2c75 100644 --- a/gcc/testsuite/gcc.target/i386/pr126293-15.c +++ b/gcc/testsuite/gcc.target/i386/pr126293-15.c @@ -8,9 +8,9 @@ **.LFB0: ** .cfi_startproc ** movdqa load\(%rip\), %xmm0 -** movaps %xmm0, -24\(%rsp\) -** movq -24\(%rsp\), %rax -** movq -16\(%rsp\), %rdx +** movq %xmm0, %rax +** shufpd \$1, %xmm0, %xmm0 +** movq %xmm0, %rdx ** ret ** .cfi_endproc **... diff --git a/gcc/testsuite/gcc.target/i386/pr126293-5.c b/gcc/testsuite/gcc.target/i386/pr126293-5.c index 2f0794132c9b..f5e4a57ed28b 100644 --- a/gcc/testsuite/gcc.target/i386/pr126293-5.c +++ b/gcc/testsuite/gcc.target/i386/pr126293-5.c @@ -8,9 +8,9 @@ **.LFB0: ** .cfi_startproc ** movdqa load\(%rip\), %xmm0 -** movaps %xmm0, -24\(%rsp\) -** movq -24\(%rsp\), %rax -** movq -16\(%rsp\), %rdx +** movq %xmm0, %rax +** shufpd \$1, %xmm0, %xmm0 +** movq %xmm0, %rdx ** ret ** .cfi_endproc **... From 56de4652dbfc3a79ee4946f0274aba115bd83ccb Mon Sep 17 00:00:00 2001 From: Gaius Mulley Date: Tue, 22 Sep 2026 16:13:42 +0100 Subject: [PATCH 334/584] PR modula2/127554: Spell checking hint opportunity missed when building a contant aggregate This patch introduces spell checking to the PCBuild pass (aggregate constant construction pass). It also adds the type name spell checking. It also adds some missing production statements when the FORWARD keyword is encountered during PCBuild. gcc/m2/ChangeLog: PR modula2/127554 * gm2-compiler/M2MetaError.mod (SpellHint): Allow error symbols to be spell checked. * gm2-compiler/M2Quads.mod (BuildConstructor): Generate a spelling hint error message if the name is set and an error is seen. (PopTntok): New procedure. * gm2-compiler/PCBuild.bnf (CreateQualident): New procedure. (PushQualident): Reimplement. * gm2-compiler/PCSymBuild.mod (PCStartBuildDefModule): Push module to spelling stack. (PCStartBuildImpModule): Ditto. (PCStartBuildInnerModule): Ditto. (PCEndBuildDefModule): Pop top of spell stack. (PCEndBuildImpModule): Ditto. (PCEndBuildProgModule): Ditto. (PCEndBuildInnerModule): Ditto. (PCEndBuildProcedure): Ditto. (PCBuildProcedureHeading): Ditto. (PCEndBuildForward): Reimplement. gcc/testsuite/ChangeLog: PR modula2/127554 * gm2.dg/spell/iso/fail/constaggregate.mod: New test. Signed-off-by: Gaius Mulley --- gcc/m2/gm2-compiler/M2MetaError.mod | 2 +- gcc/m2/gm2-compiler/M2Quads.mod | 31 +++- gcc/m2/gm2-compiler/PCBuild.bnf | 150 ++++++++++-------- gcc/m2/gm2-compiler/PCSymBuild.mod | 33 ++-- .../gm2.dg/spell/iso/fail/constaggregate.mod | 19 +++ 5 files changed, 157 insertions(+), 78 deletions(-) create mode 100644 gcc/testsuite/gm2.dg/spell/iso/fail/constaggregate.mod diff --git a/gcc/m2/gm2-compiler/M2MetaError.mod b/gcc/m2/gm2-compiler/M2MetaError.mod index f5b5b5f13eb3..b270f7ca64aa 100644 --- a/gcc/m2/gm2-compiler/M2MetaError.mod +++ b/gcc/m2/gm2-compiler/M2MetaError.mod @@ -1964,7 +1964,7 @@ BEGIN IF eb.filterDef AND IsDefImp (sym[bol]) THEN JoinSentances (eb, GetDefModuleSpellHint (sym[bol])) - ELSIF IsUnknown (sym[bol]) + ELSIF IsUnknown (sym[bol]) OR IsError (sym[bol]) THEN JoinSentances (eb, GetSpellHint (sym[bol])) END diff --git a/gcc/m2/gm2-compiler/M2Quads.mod b/gcc/m2/gm2-compiler/M2Quads.mod index 8e92e52f7c0f..498f1b4c3199 100644 --- a/gcc/m2/gm2-compiler/M2Quads.mod +++ b/gcc/m2/gm2-compiler/M2Quads.mod @@ -12661,10 +12661,12 @@ END SilentBuildConstructor ; PROCEDURE BuildConstructor (tokcbrpos: CARDINAL) ; VAR tok : CARDINAL ; + name : Name ; + errsym, constValue, type : CARDINAL ; BEGIN - PopTtok (type, tok) ; + PopTntok (type, name, tok) ; constValue := MakeTemporary (tok, ImmediateValue) ; PutVar (constValue, type) ; PutConstructor (constValue) ; @@ -12676,8 +12678,10 @@ BEGIN MetaErrorT0 (tokcbrpos, '{%E}constructor requires a type before the opening %{') ELSE - MetaErrorT0 (tok, - '{%E}the constructor type before the opening %{ is unknown') + (* Spellcheck. *) + errsym := MakeError (tok, name) ; + MetaErrorT1 (tok, 'constructor type {%1Ea} is undefined {%1&s}', errsym) ; + UnknownReported (errsym) END ELSE ChangeToConstructor (tok, type) ; @@ -15957,6 +15961,27 @@ BEGIN END PushTFntok ; +(* + PopTntok - Pop a True/number/tok from the True/False stack. + True and False are assumed to contain Symbols. + The number is word sized. +*) + +PROCEDURE PopTntok (VAR True, n: WORD; VAR tokno: CARDINAL) ; +VAR + f: BoolFrame ; +BEGIN + f := PopAddress (BoolStack) ; + WITH f^ DO + True := TrueExit ; + n := name ; + tokno := tokenno ; + Assert (NOT BooleanOp) + END ; + DISPOSE (f) +END PopTntok ; + + (* PopTFn - Pop a True and False number from the True/False stack. True and False are assumed to contain Symbols or Ident etc. diff --git a/gcc/m2/gm2-compiler/PCBuild.bnf b/gcc/m2/gm2-compiler/PCBuild.bnf index f7b5715f1825..1fbee0750f7d 100644 --- a/gcc/m2/gm2-compiler/PCBuild.bnf +++ b/gcc/m2/gm2-compiler/PCBuild.bnf @@ -47,7 +47,7 @@ IMPLEMENTATION MODULE PCBuild ; FROM M2LexBuf IMPORT currentstring, currenttoken, GetToken, InsertToken, InsertTokenAndRewind, GetTokenNo, MakeVirtualTok ; -FROM M2MetaError IMPORT MetaErrorStringT0 ; +FROM M2MetaError IMPORT MetaErrorStringT0, MetaErrorT1 ; FROM NameKey IMPORT NulName, Name, makekey ; FROM DynamicStrings IMPORT String, InitString, KillString, Mark, ConCat, ConCatChar ; FROM M2Printf IMPORT printf0 ; @@ -120,7 +120,7 @@ FROM SymbolTable IMPORT MakeGnuAsm, PutGnuAsmVolatile, PutGnuAsm, PutGnuAsmInput IsRecord, IsProcType, GetCurrentModule, IsInnerModule, IsImported, RequestSym, - GetSym, GetLocalSym ; + GetSym, GetLocalSym, MakeError, UnknownReported ; FROM M2Batch IMPORT IsModuleKnown ; @@ -475,6 +475,78 @@ BEGIN END END CheckModuleQualident ; + +(* + CreateQualident - push the qualident symbol building it + component at a time. +*) + +PROCEDURE CreateQualident (stopset0: SetOfStop0; + stopset1: SetOfStop1; + stopset2: SetOfStop2) ; +VAR + name : Name ; + sym, + init, + ip1 : CARDINAL ; + tok, + tokstart: CARDINAL ; +BEGIN + PopTtok (name, tokstart) ; + tok := tokstart ; + init := GetSym (name) ; + IF init=NulSym + THEN + PushTFntok (NulSym, NulSym, name, tok) + ELSE + WHILE IsDefImp (init) OR IsModule (init) DO + IF currenttoken # periodtok + THEN + ErrorArrayAt ("expecting '.' after module in the construction of a qualident", tok) ; + IF tok#tokstart + THEN + tok := MakeVirtualTok (tokstart, tokstart, tok) + END ; + PushTtok (init, tok) ; + RETURN + ELSE + Expect (periodtok, stopset0, stopset1, stopset2 + SetOfStop2{identtok}) ; + StartScope (init) ; + Ident (stopset0, stopset1, stopset2) ; + PopTtok (name, tok) ; + ip1 := GetSym (name) ; + IF ip1 = NulSym + THEN + ErrorArrayAt ("unknown ident in the construction of a qualident", tok) ; + EndScope ; + IF tok#tokstart + THEN + tok := MakeVirtualTok (tokstart, tokstart, tok) + END ; + PushTFntok (NulSym, NulSym, name, tok) ; + RETURN + ELSE + PutIncluded (ip1) + END ; + EndScope ; + CheckCanBeImported (init, ip1) ; + init := ip1 + END + END ; + IF tok#tokstart + THEN + tok := MakeVirtualTok (tokstart, tokstart, tok) + END ; + IF IsProcedure (init) OR IsProcType (init) + THEN + PushTtok (init, tok) + ELSE + PushTFtok (init, GetType(init), tok) + END + END +END CreateQualident ; + + % module PCBuild end BEGIN BlockState := InitState () @@ -1002,70 +1074,18 @@ Term := Factor { MulOperator Factor } =: Factor := Number | string | SetOrDesignatorOrFunction | "(" Expression ")" | "NOT" ( Factor | ConstAttribute ) =: -PushQualident := % VAR name : Name ; - init, ip1 : CARDINAL ; - tok, tokstart: CARDINAL ; % - % PushAutoOn % - Ident % IF IsAutoPushOn() +PushQualident := % PushAutoOn % + Ident % IF IsAutoPushOn() THEN - PopTtok (name, tokstart) ; - tok := tokstart ; - init := GetSym (name) ; - IF init=NulSym - THEN - PushTFntok (NulSym, NulSym, name, tok) - ELSE - WHILE IsDefImp (init) OR IsModule (init) DO - IF currenttoken # periodtok - THEN - ErrorArrayAt ("expecting '.' after module in the construction of a qualident", tok) ; - IF tok#tokstart - THEN - tok := MakeVirtualTok (tokstart, tokstart, tok) - END ; - PushTtok (init, tok) ; - PopAuto ; - RETURN - ELSE - Expect (periodtok, stopset0, stopset1, stopset2 + SetOfStop2{identtok}) ; - StartScope (init) ; - Ident (stopset0, stopset1, stopset2) ; - PopTtok (name, tok) ; - ip1 := GetSym (name) ; - IF ip1 = NulSym - THEN - ErrorArrayAt ("unknown ident in the construction of a qualident", tok) ; - EndScope ; - IF tok#tokstart - THEN - tok := MakeVirtualTok (tokstart, tokstart, tok) - END ; - PushTFntok (NulSym, NulSym, name, tok) ; - PopAuto ; - RETURN - ELSE - PutIncluded (ip1) - END ; - EndScope ; - CheckCanBeImported (init, ip1) ; - init := ip1 - END - END ; - IF tok#tokstart - THEN - tok := MakeVirtualTok (tokstart, tokstart, tok) - END ; - IF IsProcedure (init) OR IsProcType (init) - THEN - PushTtok (init, tok) - ELSE - PushTFtok (init, GetType(init), tok) - END - END - ELSE % - { "." Ident } % END % - % PopAuto % - =: + CreateQualident (stopset0, stopset1, stopset2) + ELSE + (* Although this code is not executed the grammar is + processed by pge to generate first and follow sets. *) + % + { "." Ident } + % END ; + PopAuto % + =: ConstructorOrSimpleDes := Constructor | % PopNothing % SimpleDes [ ActualParameters ] diff --git a/gcc/m2/gm2-compiler/PCSymBuild.mod b/gcc/m2/gm2-compiler/PCSymBuild.mod index 0597a5481809..f54e83a4fc3a 100644 --- a/gcc/m2/gm2-compiler/PCSymBuild.mod +++ b/gcc/m2/gm2-compiler/PCSymBuild.mod @@ -99,6 +99,7 @@ FROM M2StackWord IMPORT StackOfWord, InitStackWord, KillStackWord, IsEmptyWord, NoOfItemsInStackWord ; IMPORT M2Error ; +IMPORT M2StackSpell ; CONST @@ -236,6 +237,7 @@ BEGIN StartScope(ModuleSym) ; Assert(IsDefImp(ModuleSym)) ; Assert(CompilingDefinitionModule()) ; + M2StackSpell.Push (ModuleSym) ; PushT(name) ; M2Error.EnterDefinitionScope (name) END PCStartBuildDefModule ; @@ -265,6 +267,7 @@ BEGIN Assert(CompilingDefinitionModule()) ; CheckForUnknownInModule (tokno) ; EndScope ; + M2StackSpell.Pop ; PopT(NameEnd) ; PopT(NameStart) ; IF NameStart#NameEnd @@ -305,7 +308,8 @@ BEGIN Assert(IsDefImp(ModuleSym)) ; Assert(CompilingImplementationModule()) ; PushTtok(name, tok) ; - M2Error.EnterImplementationScope (name) + M2Error.EnterImplementationScope (name) ; + M2StackSpell.Push (ModuleSym) END PCStartBuildImpModule ; @@ -333,6 +337,7 @@ BEGIN Assert(CompilingImplementationModule()) ; CheckForUnknownInModule (tokno) ; EndScope ; + M2StackSpell.Pop ; PopT(NameEnd) ; PopT(NameStart) ; IF NameStart#NameEnd @@ -378,7 +383,8 @@ BEGIN Assert(CompilingProgramModule()) ; Assert(NOT IsDefImp(ModuleSym)) ; PushTtok(name, tok) ; - M2Error.EnterProgramScope (name) + M2Error.EnterProgramScope (name) ; + M2StackSpell.Push (ModuleSym) END PCStartBuildProgModule ; @@ -416,7 +422,8 @@ BEGIN WriteFormat0('too many errors in pass 3') ; FlushErrors END ; - M2Error.LeaveErrorScope + M2Error.LeaveErrorScope ; + M2StackSpell.Pop END PCEndBuildProgModule ; @@ -448,7 +455,8 @@ BEGIN Assert(NOT IsDefImp(ModuleSym)) ; SetCurrentModule(ModuleSym) ; PushTtok(name, tok) ; - M2Error.EnterModuleScope (name) + M2Error.EnterModuleScope (name) ; + M2StackSpell.Push (ModuleSym) END PCStartBuildInnerModule ; @@ -486,7 +494,8 @@ BEGIN FlushErrors END ; SetCurrentModule(GetModuleScope(GetCurrentModule())) ; - M2Error.LeaveErrorScope + M2Error.LeaveErrorScope ; + M2StackSpell.Pop END PCEndBuildInnerModule ; @@ -628,7 +637,8 @@ BEGIN Assert (IsProcedure (ProcSym)) ; PushTtok (ProcSym, tok) ; StartScope (ProcSym) ; - M2Error.EnterProcedureScope (name) + M2Error.EnterProcedureScope (name) ; + M2StackSpell.Push (ProcSym) END PCStartBuildProcedure ; @@ -672,7 +682,8 @@ BEGIN FlushErrors END ; EndScope ; - M2Error.LeaveErrorScope + M2Error.LeaveErrorScope ; + M2StackSpell.Pop END PCEndBuildProcedure ; @@ -694,7 +705,10 @@ END PCEndBuildProcedure ; PROCEDURE PCEndBuildForward ; BEGIN - PopN (2) + PopN (2) ; + EndScope ; + M2Error.LeaveErrorScope ; + M2StackSpell.Pop END PCEndBuildForward ; @@ -728,7 +742,8 @@ BEGIN THEN PopT (ProcSym) ; PopT (NameStart) ; - EndScope + EndScope ; + M2StackSpell.Pop END END PCBuildProcedureHeading ; diff --git a/gcc/testsuite/gm2.dg/spell/iso/fail/constaggregate.mod b/gcc/testsuite/gm2.dg/spell/iso/fail/constaggregate.mod new file mode 100644 index 000000000000..1f38f7b00f58 --- /dev/null +++ b/gcc/testsuite/gm2.dg/spell/iso/fail/constaggregate.mod @@ -0,0 +1,19 @@ +(* { dg-do compile } *) +(* { dg-options "-g" } *) + +MODULE constaggregate ; + +TYPE + callType = RECORD + callNick : ARRAY [0..8] OF CHAR; + callString: ARRAY [0..20] OF CHAR; + END ; + +CONST + cls = CallType {"nickname", "realname"} ; + (* { dg-error "constructor type 'CallType' is undefined, did you mean callType?" "CallType" { target *-*-* } 13 } *) + (* { dg-error "the type of the constant declaration 'cls' cannot be determined" "cls" { target *-*-* } 13 } *) + + +BEGIN +END constaggregate. From 784b980a3648a92361ec7f1adb67170adb35bfc7 Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Tue, 22 Sep 2026 18:48:36 +0200 Subject: [PATCH 335/584] Ada: Further tweak for types derived from untagged controlled private type The early return for the these types in Expand_Freeze_Record_Type comes too late and leaves declarations of primitive operations without a completion. gcc/ada/ * exp_ch3.adb (Expand_Freeze_Record_Type): Move up early return for types derived from an untagged private type. --- gcc/ada/exp_ch3.adb | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/gcc/ada/exp_ch3.adb b/gcc/ada/exp_ch3.adb index 3b823b6fa411..de771f025689 100644 --- a/gcc/ada/exp_ch3.adb +++ b/gcc/ada/exp_ch3.adb @@ -6456,6 +6456,17 @@ package body Exp_Ch3 is Set_CPP_Constructors (Typ); else + -- If the type is derived from an untagged private type whose + -- full view is tagged, the type is marked tagged for layout + -- reasons, but it has no dispatch table. + + if Is_Derived_Type (Typ) + and then not Is_Tagged_Type (Etype (Typ)) + then + pragma Assert (Is_Private_Type (Etype (Typ))); + return; + end if; + if not Building_Static_DT (Typ) then -- Usually inherited primitives are not delayed but the first @@ -6548,17 +6559,6 @@ package body Exp_Ch3 is Set_Is_Frozen (Typ); - -- If the type is derived from an untagged private type whose - -- full view is tagged, the type is marked tagged for layout - -- reasons, but it has no dispatch table. - - if Is_Derived_Type (Typ) - and then not Is_Tagged_Type (Etype (Typ)) - then - pragma Assert (Is_Private_Type (Etype (Typ))); - return; - end if; - Set_All_DT_Position (Typ); -- Create and decorate the tags. Suppress their creation when From c03c1da06649be182e6e7b0ca06da7376772a299 Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Tue, 22 Sep 2026 19:16:01 +0200 Subject: [PATCH 336/584] Ada: Implement partially dynamic small-integer model of accessibility checks GNAT currently implements a static small-integer model for accessibility checks (with a "minimum" trick), which means that all the accessibility levels, including the dynamic ones, are based on the static nesting depth of master constructs. Ada 2012 and later versions of the language expose serious shortcomings of this static model, for example the non-enforcement of the strict ordering for caller/called levels or the flattening of nested levels, although there were already problems, albeit less serious, for Ada 2005. This change implements a partially dynamic small-integer model, where the static nesting depth of master constructs is augmented by the (de facto dynamic) levels that are passed in to specific subprograms. The run-time implementation changes are minimal, in particular the location and number of extra formal parameters created by the compiler are the same, and the compile-time implementation changes are entirely localized in the Accessibility unit, with an interface for the rest of the front-end clearly separating the dynamic from the static computations. gcc/ada/ * gen_il-fields.ads (Opt_Field_Enum): Remove Minimum_Accessibility and add Extra_Accessibility_Of_Subprogram. * gen_il-gen-gen_entities.adb (Formal_Kind): Likewise. (Subprogram_Kind): Likewise. * einfo.ads (Extra_Accessibility_Of_Subprogram): Add description. (Minimum_Accessibility): Remove description. * accessibility.ads (Accessibility_Level_Kind): Move to... (Accessibility_Level): Move to... (Dynamic_Accessibility_Level): New function declaration. (Dynamic_Local_Access_Level): Likewise. (Dynamic_Subprogram_Access_Level): Likewise. (Get_Dynamic_Accessibility): Delete. (Static_Accessibility_Level_Kind): Likewise. (Deepest_Type_Access_Level): Likewise. (Static_Accessibility_Level): Replace second formal parameter. (Static_Local_Access_Level): New function declaration. (Static_Type_Access_Level): Likewise. (Subprogram_Access_Level): Delete. (Type_Access_Level): Move to... * accessibility.adb (Accessibility_Level_Kind): ...here. (Accessibility_Level): ...here. (Type_Access_Level): ...here. (Offset_Static_Level): New function declaration. (Accessibility_Level): Add Static formal parameter and change the result type. Change the result type of most nested functions and ultimately call Offset_Static_Level if Static is set to False. (Apply_Accessibility_Check_For_Class_Wide_Allocator): Use explicit static or dynamic variant of level computation functions. (Apply_Accessibility_Check_For_Anonymous_Return): Likewise. (Apply_Accessibility_Check_For_Class_Wide_Return): Likewise. (Apply_Accessibility_Check_For_Discriminated_Allocator): Likewise. (Apply_Accessibility_Check_For_Conversion): Likewise. (Check_Return_Construct_Accessibility): Likewise. (Apply_Accessibility_Check_For_Return): Fix typo in comment. (Dynamic_Accessibility_Level): New function body. (Dynamic_Local_Access_Level): Likewise. (Dynamic_Subprogram_Access_Level): Likewise. (Dynamic_Type_Access_Level): Likewise. (Get_Dynamic_Accessibility): Delete. (Offset_Static_Level): New function body. (Static_Accessibility_Level): Adjust. (Static_Local_Access_Level): New function body. (Static_Subprogram_Access_Level): Likewise. (Static_Type_Access_Level): Likewise. (Deepest_Type_Access_Level): Merge implementation into... (Type_Access_Level): ...this. Add Deepest formal parameter and change the result type. Compute a base entity and an offset. * contracts.adb (Build_Subprogram_Contract_Wrapper): Do not move the declaration of the Extra_Accessibility_Of_Subprogram constant. * exp_aggr.adb: Add clauses for Accessibility. (In_Place_Assign_OK): Call Static_Local_Access_Level instead of doing the level calculation manually. * exp_attr.adb (Expand_N_Attribute_Reference.Write_Controlling_Tag): Call appropriate accessibility level calculation routine. * exp_ch3.adb (Build_Initialization_Call): Likewise. (Expand_N_Object_Declaration): Likewise. (Freeze_Type): Likewise. (Build_Record_Init_Proc): Do not create an extra accessibility parameter for Activation_Chain and Finalization_Master. * exp_ch4.adb (Expand_N_In): Call appropriate acccessibility level calculation routine. * exp_ch5.adb (Expand_N_Assignment_Statement): Likewise. * exp_ch6.adb (Expand_Actuals): Likewise. (Create_Extra_Actuals): Likewise. * exp_ch9.adb (Expand_N_Requeue_Statement): Likewise and add missing exception per RM 9.5.4(7.2). * exp_disp.adb (Make_DT): Likewise. * sem_attr.adb (Resolve_Attribute): Likewise. * sem_ch3.adb (Analyze_Component_Declaration): Likewise. (Build_Derived_Record_Type): Likewise. (Derived_Type_Declaration): Likewise. * sem_ch9.adb (Analyze_Requeue): Likewise and remove duplicate code. * sem_ch13.adb (Analyze_Attribute_Definition_Clause): Likewise. * sem_res.ads (Resolve_Entry): Remove obsolete comment. * sem_res.adb (Resolve_Actuals): Likewise. (Resolve_Allocator): Likewise. (Valid_Conversion): Likewise. (Resolve_Entry): Set Analyzed on the entry name before rewriting it. * sem_util.adb (Check_Unprotected_Access): Likewise. * sem_ch6.adb (Analyze_Function_Return): Likewise. (Analyze_Subprogram_Body_Helper): Compute the extra accessibility of the subprogram instead of minimum accessibility of parameters. (Create_Extra_Formals): Create an extra accessibility formal for an access-to-subprogram parameter if the profile of the designated type has at least one parameter that needs one. --- gcc/ada/accessibility.adb | 786 +++++++++++++++++++--------- gcc/ada/accessibility.ads | 145 ++--- gcc/ada/contracts.adb | 15 +- gcc/ada/einfo.ads | 28 +- gcc/ada/exp_aggr.adb | 22 +- gcc/ada/exp_attr.adb | 4 +- gcc/ada/exp_ch3.adb | 14 +- gcc/ada/exp_ch4.adb | 33 +- gcc/ada/exp_ch5.adb | 11 +- gcc/ada/exp_ch6.adb | 33 +- gcc/ada/exp_ch9.adb | 55 +- gcc/ada/exp_disp.adb | 5 +- gcc/ada/gen_il-fields.ads | 2 +- gcc/ada/gen_il-gen-gen_entities.adb | 2 +- gcc/ada/sem_attr.adb | 16 +- gcc/ada/sem_ch13.adb | 4 +- gcc/ada/sem_ch3.adb | 13 +- gcc/ada/sem_ch6.adb | 280 +++++----- gcc/ada/sem_ch9.adb | 44 +- gcc/ada/sem_res.adb | 66 +-- gcc/ada/sem_res.ads | 3 +- gcc/ada/sem_util.adb | 2 +- 22 files changed, 915 insertions(+), 668 deletions(-) diff --git a/gcc/ada/accessibility.adb b/gcc/ada/accessibility.adb index 34d5e6b085f3..cf352d640a88 100644 --- a/gcc/ada/accessibility.adb +++ b/gcc/ada/accessibility.adb @@ -57,6 +57,61 @@ package body Accessibility is -- Local Subprograms -- ----------------------- + type Accessibility_Level_Kind is + (Dynamic_Level, Object_Decl_Level, Library_On_Dynamic_Level); + -- Captures the different modes in which an accessibility level could be + -- obtained for a given expression. In the context of Accessibility_Level + -- function, Accessibility_Level_Kind signals what type of accessibility + -- level to obtain. + + -- When Level is Dynamic_Level, a defining identifier associated with an + -- access parameter, an access result, or an SAOOAAAT, may be returned, + -- and an N_Integer_Literal node in the other cases. + + -- When Level is Object_Decl_Level, an N_Integer_Literal node whose value + -- is the level of the declaration of the object is returned in the cases + -- where Dynamic_Level returns a defining identifier; in the other cases, + -- an N_Integer_Literal is returned like for Dynamic_Level. + + -- When Level is Library_On_Dynamic_Level, an N_Integer_Literal node whose + -- value is the library level is returned in the cases where Dynamic_Level + -- returns a defining identifier; in the other cases, an N_Integer_Literal + -- is returned like for Dynamic_Level. + + -- Note that this description does not take into account the dynamic offset + -- that may be added by Offset_Static_Level to an N_Integer_Literal node. + + type Level_T (S : Boolean := False) is record + case S is + when False => N : Node_Id; + when True => U : Uint; + end case; + end record; + -- Result type of the Accessibility_Level function, containing an integer + -- when Static is True or a Node_Id when Static is False, see below. + + function Accessibility_Level + (Expr : Node_Id; + Level : Accessibility_Level_Kind; + Static : Boolean := False; + In_Return_Context : Boolean := False; + Allow_Alt_Model : Boolean := True) return Level_T; + -- Centralized accessibility level calculation routine for finding the + -- accessibility level of a given expression Expr. Level is as described + -- above. If Static is True, the result is meant for a static context, + -- typically a static accessibility check, and is therefore required to + -- be a value of Level_T (S => True) subtype (which also means that Level + -- cannot be Dynamic_Level in this case); otherwise, the result is meant + -- for a dynamic context, typically a dynamic accessibility check, and is + -- therefore required to be a value of Level_T (S => False) subtype. + + -- In_Return_Context forces the level calculation to be carried out as if + -- Expr was an operative constituent of a return value; when it is False, + -- the function computes whether that is the case or not. + + -- The Allow_Alt_Model parameter allows the alternative level calculation + -- under the restriction No_Dynamic_Accessibility_Checks to be performed. + procedure Apply_Accessibility_Check_For_Anonymous_Return (Exp : Node_Id; Func : Entity_Id; @@ -86,6 +141,43 @@ package body Accessibility is -- access discriminant of the result is not deeper than the level of the -- master of the call. Exp is an expression being returned from Func. + function Offset_Static_Level + (Level : Uint; + Subp : Entity_Id) return Node_Id; + -- Apply the offset scheme described for Extra_Accessibility_Of_Subprogram + -- in Einfo to Level computed within subprogram Subp and return the result. + -- The function must be invoked for every static accessibility level, both + -- for entities declared, and master constructs present, within Subp, when + -- a dynamic accessibility level is being computed. + + type Type_Level_T is record + Base : Entity_Id; + Offset : Uint; + end record; + -- Result type of the Type_Access_Level function, containing a base entity + -- and an offset. The static accessibility level of the input type is the + -- sum of the local accessibility level of the base entity and the offset. + + function Type_Access_Level + (Typ : Entity_Id; + Deepest : Boolean := False; + Allow_Alt_Model : Boolean := True; + Assoc_Node : Node_Id := Empty) return Type_Level_T; + -- Return the static accessibility level of Typ + + -- When Deepest is True, and Typ is that of an Ada 2012 stand-alone object + -- of an anonymous access type, then return the static accessibility level + -- of the declaration of the object instead of the library level; moreover, + -- in the case of a descendant of a generic formal type, return Int'Last + -- instead of the library level. + + -- The Allow_Alt_Model parameter allows the alternative level calculation + -- under the restriction No_Dynamic_Accessibility_Checks to be performed. + + -- Assoc_Node allows for the optional specification of a node associated + -- with Typ. This is used only for anonymous access types where the context + -- matters in interpreting Typ's level. + --------------------------- -- Accessibility_Message -- --------------------------- @@ -146,53 +238,76 @@ package body Accessibility is function Accessibility_Level (Expr : Node_Id; Level : Accessibility_Level_Kind; + Static : Boolean := False; In_Return_Context : Boolean := False; - Allow_Alt_Model : Boolean := True) return Node_Id + Allow_Alt_Model : Boolean := True) return Level_T is Loc : constant Source_Ptr := Sloc (Expr); - function Accessibility_Level (Expr : Node_Id) return Node_Id is + function Accessibility_Level (Expr : Node_Id) return Level_T is (Accessibility_Level - (Expr, Level, In_Return_Context, Allow_Alt_Model)); + (Expr, Level, Static, In_Return_Context, Allow_Alt_Model)); -- Renaming of the enclosing function to facilitate recursive calls - function Make_Level_Literal (Level : Uint) return Node_Id; - -- Construct an integer literal representing an accessibility level with - -- its type set to Natural. - - function Innermost_Master_Scope_Depth (N : Node_Id) return Uint; - -- Returns the scope depth of the given node's innermost enclosing scope - -- (effectively the accessibility level of the innermost enclosing - -- master). + function Enclosing_Master_Level (N : Node_Id) return Level_T; + -- Return the accessibility level of the innermost enclosing master - function Function_Call_Or_Allocator_Level (N : Node_Id) return Node_Id; + function Function_Call_Or_Allocator_Level (N : Node_Id) return Level_T; -- Centralized processing of subprogram calls which may appear in prefix -- notation. - function Typ_Access_Level (Typ : Entity_Id) return Uint - is (Type_Access_Level (Typ, Allow_Alt_Model)); - -- Renaming of Type_Access_Level with Allow_Alt_Model specified to avoid - -- passing the parameter specifically in every call. + function Library_Level return Level_T; + -- Return the library level + + function Local_Access_Level (E : Entity_Id) return Level_T is + (if Static + then (S => True, U => Static_Local_Access_Level (E)) + else (S => False, N => Dynamic_Local_Access_Level (E))); + -- Local renaming to select the appropriate variant for entities + + function Make_Level_Literal (Level : Uint) return Node_Id; + -- Construct an integer literal representing an accessibility level with + -- its type set to Natural. + + function Make_Level_Value (Level : Uint) return Level_T; + -- Construct an accessibility level value with from static Level + + function Subprogram_Access_Level (Subp : Entity_Id) return Level_T is + (if Static + then (S => True, U => Static_Subprogram_Access_Level (Subp)) + else (S => False, N => Dynamic_Subprogram_Access_Level (Subp))); + -- Local renaming to select the appropriate variant for subprograms + + function Type_Access_Level (Typ : Entity_Id) return Level_T is + (if Static + then (S => True, + U => Static_Type_Access_Level + (Typ, Allow_Alt_Model => Allow_Alt_Model)) + else (S => False, + N => Dynamic_Type_Access_Level + (Typ, Allow_Alt_Model => Allow_Alt_Model))); + -- Local renaming to select the appropriate variant for types - ---------------------------------- - -- Innermost_Master_Scope_Depth -- - ---------------------------------- + ---------------------------- + -- Enclosing_Master_Level -- + ---------------------------- - function Innermost_Master_Scope_Depth (N : Node_Id) return Uint is - Encl_Scop : Entity_Id; - Ent : Entity_Id; - Node_Par : Node_Id := Parent (N); - Master_Lvl_Modifier : Int := 0; + function Enclosing_Master_Level (N : Node_Id) return Level_T is + Encl_Scop : Entity_Id; + Ent : Entity_Id; + Level_Modifier : Int := 0; + Node_Par : Node_Id; begin -- Locate the nearest enclosing node (by traversing Parents) -- that Defining_Entity can be applied to, and return the - -- depth of that entity's nearest enclosing dynamic scope. + -- level of that entity's nearest enclosing dynamic scope. -- The RM 7.6.1(3) definition of "master" includes statements -- and conditions for loops among other things. Are these cases -- detected properly ??? + Node_Par := Parent (N); while Present (Node_Par) loop Ent := Defining_Entity_Or_Empty (Node_Par); @@ -208,25 +323,43 @@ package body Accessibility is or else (Nkind (Node_Par) = N_Object_Renaming_Declaration and then Comes_From_Iterator (Node_Par)) then + -- Note that in some rare cases the scope depth may not be + -- set, for example, when we are in the middle of analyzing + -- a type and the enclosing scope is said type. In that case + -- simply return the library level. + + if not Scope_Depth_Set (Encl_Scop) then + return Library_Level; + end if; + -- Handle the case of expressions within library level -- subprograms here by adding one to the level modifier. if Encl_Scop = Standard_Standard and then Nkind (Node_Par) = N_Subprogram_Body then - Master_Lvl_Modifier := Master_Lvl_Modifier + 1; + Level_Modifier := Level_Modifier + 1; end if; - -- Note that in some rare cases the scope depth may not be - -- set, for example, when we are in the middle of analyzing - -- a type and the enclosing scope is said type. In that case - -- simply return zero for the outermost scope. + declare + Subp : constant Entity_Id := + (if Is_Subprogram (Encl_Scop) + then Encl_Scop + else Enclosing_Subprogram (Encl_Scop)); + Static_Level : constant Uint := + Scope_Depth (Encl_Scop) + Level_Modifier; - if Scope_Depth_Set (Encl_Scop) then - return Scope_Depth (Encl_Scop) + Master_Lvl_Modifier; - else - return Uint_0; - end if; + begin + if Static then + return (S => True, U => Static_Level); + elsif No (Subp) then + return (S => False, + N => Make_Level_Literal (Static_Level)); + else + return (S => False, + N => Offset_Static_Level (Static_Level, Subp)); + end if; + end; end if; -- For a return statement within a function, return @@ -238,7 +371,19 @@ package body Accessibility is elsif Nkind (Node_Par) in N_Extended_Return_Statement | N_Simple_Return_Statement then - return Scope_Depth (Enclosing_Subprogram (Node_Par)); + declare + Subp : constant Entity_Id := + Enclosing_Subprogram (Node_Par); + Static_Level : constant Uint := Scope_Depth (Subp); + + begin + if Static then + return (S => True, U => Static_Level); + else + return (S => False, + N => Offset_Static_Level (Static_Level, Subp)); + end if; + end; -- Non-package bodies and statements are counted as masters @@ -247,8 +392,7 @@ package body Accessibility is | N_Task_Body or else Is_Statement (Node_Par) then - Master_Lvl_Modifier := Master_Lvl_Modifier + 1; - + Level_Modifier := Level_Modifier + 1; end if; Node_Par := Parent (Node_Par); @@ -258,8 +402,17 @@ package body Accessibility is pragma Assert (False); - return Scope_Depth (Current_Scope) + 1; - end Innermost_Master_Scope_Depth; + return Make_Level_Value (Scope_Depth (Current_Scope) + 1); + end Enclosing_Master_Level; + + ------------------- + -- Library_Level -- + ------------------- + + function Library_Level return Level_T is + begin + return Make_Level_Value (Scope_Depth (Standard_Standard)); + end Library_Level; ------------------------ -- Make_Level_Literal -- @@ -273,11 +426,24 @@ package body Accessibility is return Result; end Make_Level_Literal; + ---------------------- + -- Make_Level_Value -- + ---------------------- + + function Make_Level_Value (Level : Uint) return Level_T is + begin + if Static then + return (S => True, U => Level); + else + return (S => False, N => Make_Level_Literal (Level)); + end if; + end Make_Level_Value; + -------------------------------------- -- Function_Call_Or_Allocator_Level -- -------------------------------------- - function Function_Call_Or_Allocator_Level (N : Node_Id) return Node_Id is + function Function_Call_Or_Allocator_Level (N : Node_Id) return Level_T is Prev_Par : Node_Id := Expr; Par : Node_Id := Parent (Expr); -- Par and Prev_Par will be used for traversing the AST, while @@ -296,19 +462,17 @@ package body Accessibility is if Is_Entity_Name (Name (N)) and then Is_Inherently_Limited_Type (Etype (N)) then - return Make_Level_Literal - (Subprogram_Access_Level (Entity (Name (N)))); + return Subprogram_Access_Level (Entity (Name (N))); elsif Nkind (Name (N)) = N_Explicit_Dereference and then Is_Inherently_Limited_Type (Etype (N)) then - return Make_Level_Literal - (Typ_Access_Level (Etype (Prefix (Name (N))))); + return Type_Access_Level (Etype (Prefix (Name (N)))); -- Otherwise the accessibility level of the innermost master else - return Make_Level_Literal (Innermost_Master_Scope_Depth (Expr)); + return Enclosing_Master_Level (Expr); end if; -- We ignore coextensions as they cannot be implemented under the @@ -318,12 +482,12 @@ package body Accessibility is and then (Is_Static_Coextension (N) or else Is_Dynamic_Coextension (N)) then - return Make_Level_Literal (Scope_Depth (Standard_Standard)); + return Library_Level; -- Objects of a named access type get their level from their type elsif Is_Named_Access_Type (Etype (N)) then - return Make_Level_Literal (Typ_Access_Level (Etype (N))); + return Type_Access_Level (Etype (N)); -- Function calls in Ada 2005 and later, and anonymous allocators @@ -339,7 +503,8 @@ package body Accessibility is -- designated type. if Debug_Flag_Underscore_B then - return Make_Level_Literal (Typ_Access_Level (Etype (N))); + return + Make_Level_Value (Static_Type_Access_Level (Etype (N))); -- For function calls the level is that of the innermost -- master; otherwise, for allocators we get the level of @@ -347,8 +512,7 @@ package body Accessibility is -- calculated through the normal path of execution. elsif Nkind (N) = N_Function_Call then - return - Make_Level_Literal (Innermost_Master_Scope_Depth (Expr)); + return Enclosing_Master_Level (Expr); end if; end if; @@ -360,15 +524,15 @@ package body Accessibility is and then Nkind (N) = N_Function_Call and then Is_Scalar_Type (Etype (N)) then - return Make_Level_Literal (Innermost_Master_Scope_Depth (Expr)); + return Enclosing_Master_Level (Expr); end if; - -- Dynamic checks are generated when we are within a return - -- value or we are in a function call within an anonymous - -- access discriminant constraint of a return object (signified - -- by In_Return_Context) on the side of the callee. + -- RM 3.10.2(10.5): If the call itself defines the result of a + -- function F, or has an accessibility level that is tied to the + -- result of such a function F, then the master of the call is + -- that of the master of the call invoking F. - if In_Return_Value (N) or else In_Return_Context then + if In_Return_Context or In_Return_Value (N) then declare Extra_Formal : constant Entity_Id := Extra_Accessibility_Of_Result (Current_Subprogram); @@ -382,14 +546,14 @@ package body Accessibility is -- "passed along". if Present (Extra_Formal) and then Level = Dynamic_Level then - return New_Occurrence_Of (Extra_Formal, Loc); + return (S => False, + N => New_Occurrence_Of (Extra_Formal, Loc)); -- Otherwise, return accessibility level of the enclosing -- subprogram. else - return Make_Level_Literal - (Subprogram_Access_Level (Current_Subprogram)); + return Subprogram_Access_Level (Current_Subprogram); end if; end; end if; @@ -434,17 +598,17 @@ package body Accessibility is when N_Type_Conversion => if Is_Named_Access_Type (Etype (Par)) then - return - Make_Level_Literal (Typ_Access_Level (Etype (Par))); + return Type_Access_Level (Etype (Par)); end if; -- For the (static) declaration of an object, return the -- accessibility level of the master of the object. when N_Object_Declaration => - return - Accessibility_Level - (Defining_Identifier (Par), Object_Decl_Level); + return Accessibility_Level + (Expr => Defining_Identifier (Par), + Level => Object_Decl_Level, + Static => Static); -- For the dynamic allocation of an object, return the -- accessibility level of the allocator. @@ -471,6 +635,7 @@ package body Accessibility is return Accessibility_Level (Expr => Name (Par), Level => Object_Decl_Level, + Static => Static, In_Return_Context => In_Return_Context); when others => @@ -486,7 +651,7 @@ package body Accessibility is -- Return the accessibility level of the innermost master - return Make_Level_Literal (Innermost_Master_Scope_Depth (Expr)); + return Enclosing_Master_Level (Expr); end if; end Function_Call_Or_Allocator_Level; @@ -498,6 +663,10 @@ package body Accessibility is -- Start of processing for Accessibility_Level begin + -- Make sure that we are not passed contradictory input + + pragma Assert (not (Level = Dynamic_Level and then Static)); + -- We could be looking at a reference to a formal due to the expansion -- of entries and other cases, so obtain the renaming if necessary. @@ -537,13 +706,13 @@ package body Accessibility is -- The accessibility level of the literal null is the library level when N_Null => - return Make_Level_Literal (Scope_Depth (Standard_Standard)); + return Library_Level; -- The level of an aggregate is that of the innermost master that -- evaluates it as defined in RM 3.10.2 (10/4). when N_Aggregate => - return Make_Level_Literal (Innermost_Master_Scope_Depth (Expr)); + return Enclosing_Master_Level (Expr); -- The accessibility level is that of the access type, except for -- anonymous allocators which have special rules defined in RM 3.10.2 @@ -579,9 +748,8 @@ package body Accessibility is -- Return the level of the enclosing declaration - return Make_Level_Literal - (Innermost_Master_Scope_Depth - (Enclosing_Declaration (Expr))); + return + Enclosing_Master_Level (Enclosing_Declaration (Expr)); -- Return the library level to null out the check for the Address, -- Deref, Unchecked_Access and Unrestricted_Access attributes. @@ -591,7 +759,7 @@ package body Accessibility is | Name_Unchecked_Access | Name_Unrestricted_Access then - return Make_Level_Literal (Scope_Depth (Standard_Standard)); + return Library_Level; -- For 'Old return the level of the associated entity, if any @@ -617,18 +785,19 @@ package body Accessibility is -- Named access types if Is_Named_Access_Type (Etype (Pre)) then - return Make_Level_Literal (Typ_Access_Level (Etype (Pre))); + return Type_Access_Level (Etype (Pre)); -- Anonymous access types elsif Is_Entity_Name (Pre) and then Ekind (Entity (Pre)) not in Subprogram_Kind - and then Present (Get_Dynamic_Accessibility (Entity (Pre))) + and then Present (Extra_Accessibility (Entity (Pre))) and then Level = Dynamic_Level then pragma Assert (Is_Anonymous_Access_Type (Etype (Pre))); - return New_Occurrence_Of - (Get_Dynamic_Accessibility (Entity (Pre)), Loc); + return (S => False, + N => New_Occurrence_Of + (Extra_Accessibility (Entity (Pre)), Loc)); -- Otherwise the level is treated in a similar way as -- aggregates according to RM 6.1.1 (35.1/4) which concerns @@ -637,8 +806,7 @@ package body Accessibility is -- declaration. else - return Make_Level_Literal - (Innermost_Master_Scope_Depth (Expr)); + return Enclosing_Master_Level (Expr); end if; else @@ -671,48 +839,45 @@ package body Accessibility is and then Wrapped_Statements (Scope (E)) = Current_Subprogram)) - and then (In_Return_Value (Expr) or else In_Return_Context) + and then (In_Return_Context or else In_Return_Value (Expr)) then - return Make_Level_Literal (Scope_Depth (Standard_Standard)); + return Library_Level; -- Formal parameters with an extra accessibility formal, as well -- as stand-alone objects of an anonymous access type (SAOOAAAT). elsif (Is_Formal (E) or else Ekind (E) in E_Constant | E_Variable) - and then Present (Get_Dynamic_Accessibility (E)) - and then Level in Dynamic_Level | Zero_On_Dynamic_Level + and then Present (Extra_Accessibility (E)) + and then Level in Dynamic_Level | Library_On_Dynamic_Level then - if Level = Zero_On_Dynamic_Level then - return Make_Level_Literal (Scope_Depth (Standard_Standard)); - end if; + -- Return the library level if explicitly requested + + if Level = Library_On_Dynamic_Level then + return Library_Level; -- No_Dynamic_Accessibility_Checks restriction override for -- alternative accessibility model. - if Allow_Alt_Model + elsif Allow_Alt_Model and then No_Dynamic_Accessibility_Checks_Enabled (E) then -- In the alternative model the level is that of the -- designated type entity's context. if Debug_Flag_Underscore_B then - return Make_Level_Literal (Typ_Access_Level (Etype (E))); - - -- Otherwise the level depends on the entity's context - - elsif Is_Formal (E) then - return Make_Level_Literal - (Subprogram_Access_Level - (Enclosing_Subprogram (E))); + return Make_Level_Value + (Static_Type_Access_Level (Etype (E))); else - return Make_Level_Literal - (Scope_Depth (Enclosing_Dynamic_Scope (E))); + return Make_Level_Value (Static_Local_Access_Level (E)); end if; - end if; -- Return the dynamic level in the normal case - return New_Occurrence_Of (Get_Dynamic_Accessibility (E), Loc); + else + return + (S => False, + N => New_Occurrence_Of (Extra_Accessibility (E), Loc)); + end if; -- Return the library level for formal parameters or stand-alone -- objects of an anonymous access type without extra accessibility @@ -723,21 +888,24 @@ package body Accessibility is elsif (Is_Formal (E) or else Ekind (E) in E_Constant | E_Variable) and then Is_Anonymous_Access_Type (Etype (E)) and then not Is_Local_Anonymous_Access (Etype (E)) - and then Level in Dynamic_Level | Zero_On_Dynamic_Level + and then Level in Dynamic_Level | Library_On_Dynamic_Level then - return Make_Level_Literal (Scope_Depth (Standard_Standard)); + return Library_Level; -- Initialization procedures have a special extra accessibility -- parameter associated with the level at which the object -- being initialized exists - elsif Ekind (E) = E_Record_Type + elsif Level = Dynamic_Level + and then Ekind (E) = E_Record_Type and then Is_Limited_Record (E) and then Current_Scope = Init_Proc (E) and then Present (Init_Proc_Level_Formal (Current_Scope)) then - return New_Occurrence_Of - (Init_Proc_Level_Formal (Current_Scope), Loc); + return + (S => False, + N => New_Occurrence_Of + (Init_Proc_Level_Formal (Current_Scope), Loc)); -- Current instance of the type is deeper than that of the type -- according to RM 3.10.2 (21). @@ -750,12 +918,20 @@ package body Accessibility is and then No_Dynamic_Accessibility_Checks_Enabled (E) and then Debug_Flag_Underscore_B then - return Make_Level_Literal (Typ_Access_Level (E)); + return Make_Level_Value (Static_Type_Access_Level (E)); end if; -- Normal path - return Make_Level_Literal (Typ_Access_Level (E) + 1); + if Static then + return (S => True, U => Static_Type_Access_Level (E) + 1); + else + return + (S => False, + N => Make_Op_Add (Loc, + Left_Opnd => Dynamic_Type_Access_Level (E), + Right_Opnd => Make_Level_Literal (Uint_1))); + end if; -- Move up the renamed entity or object if it came from source -- since expansion may have created a dummy renaming under @@ -773,7 +949,7 @@ package body Accessibility is -- Objects of a named access type get their level from their type elsif Is_Named_Access_Type (Etype (E)) then - return Make_Level_Literal (Typ_Access_Level (Etype (E))); + return Type_Access_Level (Etype (E)); -- Check if E is an expansion-generated renaming of an iterator -- by examining Related_Expression. If so, determine the @@ -789,20 +965,21 @@ package body Accessibility is and then Is_Subprogram (Scope (E)) and then Present (Init_Proc_Level_Formal (Scope (E))) then - return New_Occurrence_Of - (Init_Proc_Level_Formal (Scope (E)), Loc); + return + (S => False, + N => New_Occurrence_Of + (Init_Proc_Level_Formal (Scope (E)), Loc)); -- Formal object of generic subprogram - get the level of the -- subprogram elsif Is_Formal_Object (E) and then Is_Subprogram (Scope (E)) then - return Make_Level_Literal (Subprogram_Access_Level (Scope (E))); + return Subprogram_Access_Level (Scope (E)); - -- Normal object - get the depth of the enclosing dynamic scope + -- Normal object - get the local access level else - return Make_Level_Literal - (Scope_Depth (Enclosing_Dynamic_Scope (E))); + return Local_Access_Level (E); end if; -- Handle indexed and selected components including the special cases @@ -836,14 +1013,14 @@ package body Accessibility is -- of the named access type in the prefix. elsif Is_Named_Access_Type (Etype (Pre)) then - return Make_Level_Literal (Typ_Access_Level (Etype (Pre))); + return Type_Access_Level (Etype (Pre)); -- The current expression is a named access type, so there is no -- reason to look at the prefix. Instead obtain the level of E's -- named access type. elsif Is_Named_Access_Type (Etype (E)) then - return Make_Level_Literal (Typ_Access_Level (Etype (E))); + return Type_Access_Level (Etype (E)); -- A nondiscriminant selected component where the component -- is an anonymous access type means that its associated @@ -885,13 +1062,13 @@ package body Accessibility is and then No_Dynamic_Accessibility_Checks_Enabled (E) and then Debug_Flag_Underscore_B then - return Make_Level_Literal (Typ_Access_Level (Etype (E))); + return + Make_Level_Value (Static_Type_Access_Level (Etype (E))); end if; -- Otherwise proceed normally - return - Make_Level_Literal (Typ_Access_Level (Etype (Prefix (E)))); + return Type_Access_Level (Etype (Prefix (E))); -- The accessibility calculation routine that handles function -- calls (Function_Call_Or_Allocator_Level) assumes, in the case @@ -915,12 +1092,12 @@ package body Accessibility is if (Ekind (Etype (Pre)) = E_Anonymous_Access_Type or else Has_Implicit_Dereference (Etype (Pre))) - and then (In_Return_Value (E) or else In_Return_Context) + and then (In_Return_Context or else In_Return_Value (E)) then return Function_Call_Or_Allocator_Level (Prefix (E)); end if; - return Make_Level_Literal (Innermost_Master_Scope_Depth (Expr)); + return Enclosing_Master_Level (Expr); -- Otherwise, continue recursing over the expression prefixes @@ -932,7 +1109,7 @@ package body Accessibility is when N_Qualified_Expression => if Is_Named_Access_Type (Etype (E)) then - return Make_Level_Literal (Typ_Access_Level (Etype (E))); + return Type_Access_Level (Etype (E)); else return Accessibility_Level (Expression (E)); end if; @@ -951,7 +1128,7 @@ package body Accessibility is -- its type. if Is_Named_Access_Type (Etype (Pre)) then - return Make_Level_Literal (Typ_Access_Level (Etype (Pre))); + return Type_Access_Level (Etype (Pre)); -- Otherwise, recurse deeper @@ -977,13 +1154,13 @@ package body Accessibility is -- access type. elsif Is_Named_Access_Type (Etype (E)) then - return Make_Level_Literal (Typ_Access_Level (Etype (E))); + return Type_Access_Level (Etype (E)); -- In section RM 3.10.2 (10/4) the accessibility rules for -- aggregates and value conversions are outlined. Are these -- followed in the case of initialization of an object ??? - -- Should use Innermost_Master_Scope_Depth ??? + -- Should use Enclosing_Master_Level ??? else return Accessibility_Level (Current_Scope); @@ -993,7 +1170,7 @@ package body Accessibility is -- expression's entity. when others => - return Make_Level_Literal (Typ_Access_Level (Etype (E))); + return Type_Access_Level (Etype (E)); end case; end Accessibility_Level; @@ -1024,7 +1201,8 @@ package body Accessibility is and then not Scope_Suppress.Suppress (Accessibility_Check) and then not No_Dynamic_Accessibility_Checks_Enabled (Ref) and then - (Type_Access_Level (Etype (Exp)) > Type_Access_Level (PtrT) + (Static_Type_Access_Level (Etype (Exp)) + > Static_Type_Access_Level (PtrT) or else (Is_Class_Wide_Type (Etype (Exp)) and then Scope (PtrT) /= Current_Scope)) @@ -1173,7 +1351,7 @@ package body Accessibility is Cond := Make_Op_Gt (Loc, Left_Opnd => Cond, - Right_Opnd => Accessibility_Level (N, Dynamic_Level)); + Right_Opnd => Dynamic_Accessibility_Level (N)); -- Due to the complexity and side effects of the check, utilize an if -- statement instead of the regular Program_Error circuitry. @@ -1251,8 +1429,8 @@ package body Accessibility is Condition => Make_Op_Gt (Loc, Left_Opnd => - Accessibility_Level - (Exp, Dynamic_Level, In_Return_Context => True), + Dynamic_Accessibility_Level + (Exp, In_Return_Context => True), Right_Opnd => New_Occurrence_Of (Extra_Accessibility_Of_Result (Func), Loc)), Reason => PE_Accessibility_Check_Failed), @@ -1283,8 +1461,8 @@ package body Accessibility is N_Type_Conversion | N_Unchecked_Type_Conversion or else (Is_Entity_Name (Exp) and then Is_Formal (Entity (Exp))) - or else Scope_Depth (Enclosing_Dynamic_Scope (Etype (Exp))) > - Subprogram_Access_Level (Func)) + or else Static_Type_Access_Level (Etype (Exp)) + > Static_Subprogram_Access_Level (Func)) then declare Tag_Node : Node_Id; @@ -1364,9 +1542,7 @@ package body Accessibility is Condition => Make_Op_Gt (Loc, Left_Opnd => Build_Get_Access_Level (Loc, Tag_Node), - Right_Opnd => - Make_Integer_Literal (Loc, - Subprogram_Access_Level (Func))), + Right_Opnd => Dynamic_Subprogram_Access_Level (Func)), Reason => PE_Accessibility_Check_Failed), Suppress => Access_Check); end; @@ -1426,8 +1602,8 @@ package body Accessibility is Make_Raise_Program_Error (Loc, Condition => Make_Op_Gt (Loc, - Left_Opnd => Accessibility_Level (Exp, Dynamic_Level), - Right_Opnd => Accessibility_Level (N, Dynamic_Level)), + Left_Opnd => Dynamic_Accessibility_Level (Exp), + Right_Opnd => Dynamic_Accessibility_Level (N)), Reason => PE_Accessibility_Check_Failed), Suppress => Access_Check); @@ -1456,9 +1632,8 @@ package body Accessibility is Make_Raise_Program_Error (Loc, Condition => Make_Op_Gt (Loc, - Left_Opnd => - Accessibility_Level (Discr_Exp, Dynamic_Level), - Right_Opnd => Accessibility_Level (N, Dynamic_Level)), + Left_Opnd => Dynamic_Accessibility_Level (Discr_Exp), + Right_Opnd => Dynamic_Accessibility_Level (N)), Reason => PE_Accessibility_Check_Failed), Suppress => Access_Check); end if; @@ -1648,14 +1823,14 @@ package body Accessibility is -- extra access level object and when accessibility checks are enabled. if Present (Param_Ent) - and then Present (Get_Dynamic_Accessibility (Param_Ent)) + and then Present (Extra_Accessibility (Param_Ent)) and then not Accessibility_Checks_Suppressed (Param_Ent) and then not Accessibility_Checks_Suppressed (Typ) then -- Obtain the parameter's accessibility level Param_Level := - New_Occurrence_Of (Get_Dynamic_Accessibility (Param_Ent), Loc); + New_Occurrence_Of (Extra_Accessibility (Param_Ent), Loc); -- Use the dynamic accessibility parameter for the function's result -- when one has been created instead of statically referring to the @@ -1684,8 +1859,7 @@ package body Accessibility is -- Otherwise get the type's accessibility level normally else - Type_Level := - Make_Integer_Literal (Loc, Deepest_Type_Access_Level (Typ)); + Type_Level := Dynamic_Type_Access_Level (Typ, Deepest => True); end if; -- Raise Program_Error if the accessibility level of the access @@ -1964,9 +2138,8 @@ package body Accessibility is -- Apply the RM 3.10.2(12.4) rule to formal parameters elsif Is_Entity_Name (Unqual) and then Is_Formal (Entity (Unqual)) then - if Static_Accessibility_Level - (Unqual, Zero_On_Dynamic_Level, In_Return_Context => True) - > Subprogram_Access_Level (Scope_Id) + if Static_Accessibility_Level (Unqual, In_Return_Context => True) + > Static_Subprogram_Access_Level (Scope_Id) then Accessibility_Error; end if; @@ -2216,8 +2389,8 @@ package body Accessibility is and then Ekind (Etype (Disc)) = E_Anonymous_Access_Type and then Static_Accessibility_Level - (Assoc_Expr, Zero_On_Dynamic_Level, In_Return_Context => True) - > Subprogram_Access_Level (Scope_Id) + (Assoc_Expr, In_Return_Context => True) + > Static_Subprogram_Access_Level (Scope_Id) then Accessibility_Error; end if; @@ -2240,46 +2413,89 @@ package body Accessibility is end loop; end Check_Return_Construct_Accessibility; - ------------------------------- - -- Deepest_Type_Access_Level -- - ------------------------------- + --------------------------------- + -- Dynamic_Accessibility_Level -- + --------------------------------- - function Deepest_Type_Access_Level - (Typ : Entity_Id; - Allow_Alt_Model : Boolean := True) return Uint + function Dynamic_Accessibility_Level + (Expr : Node_Id; + In_Return_Context : Boolean := False; + Allow_Alt_Model : Boolean := True) return Node_Id is begin - if Ekind (Typ) = E_Anonymous_Access_Type - and then not Is_Local_Anonymous_Access (Typ) - and then Nkind (Associated_Node_For_Itype (Typ)) = N_Object_Declaration - then - -- No_Dynamic_Accessibility_Checks override for alternative - -- accessibility model. + return + Accessibility_Level (Expr => Expr, + Level => Dynamic_Level, + Static => False, + In_Return_Context => In_Return_Context, + Allow_Alt_Model => Allow_Alt_Model).N; + end Dynamic_Accessibility_Level; - if Allow_Alt_Model - and then No_Dynamic_Accessibility_Checks_Enabled (Typ) - then - return Type_Access_Level (Typ, Allow_Alt_Model); - end if; + -------------------------------- + -- Dynamic_Local_Access_Level -- + -------------------------------- - -- Typ is the type of an Ada 2012 stand-alone object of an anonymous - -- access type. + function Dynamic_Local_Access_Level (E : Entity_Id) return Node_Id is + Loc : constant Source_Ptr := Sloc (E); + Static_Level : constant Uint := Static_Local_Access_Level (E); + Subp : constant Entity_Id := Enclosing_Subprogram (E); - return - Scope_Depth (Enclosing_Dynamic_Scope - (Defining_Identifier - (Associated_Node_For_Itype (Typ)))); + begin + if Present (Subp) then + return Offset_Static_Level (Static_Level, Subp); + else + return Make_Integer_Literal (Loc, Static_Level); + end if; + end Dynamic_Local_Access_Level; + + ------------------------------------- + -- Dynamic_Subprogram_Access_Level -- + ------------------------------------- + + function Dynamic_Subprogram_Access_Level (Subp : Entity_Id) return Node_Id + is + begin + if Present (Alias (Subp)) then + return Dynamic_Subprogram_Access_Level (Alias (Subp)); + else + return Dynamic_Local_Access_Level (Subp); + end if; + end Dynamic_Subprogram_Access_Level; + + ------------------------------- + -- Dynamic_Type_Access_Level -- + ------------------------------- - -- For generic formal type, return Int'Last (infinite). - -- See comment preceding Is_Generic_Type call in Type_Access_Level. + function Dynamic_Type_Access_Level + (Typ : Entity_Id; + Deepest : Boolean := False; + Allow_Alt_Model : Boolean := True) return Node_Id + is + Loc : constant Source_Ptr := Sloc (Typ); + Val : constant Type_Level_T := + Type_Access_Level (Typ, Deepest, Allow_Alt_Model, Empty); - elsif Is_Generic_Type (Root_Type (Typ)) then - return UI_From_Int (Int'Last); + begin + if Present (Val.Base) then + declare + Dynamic_Level : constant Node_Id := + Dynamic_Local_Access_Level (Val.Base); + + begin + if Val.Offset /= Uint_0 then + return + Make_Op_Add (Loc, + Left_Opnd => Dynamic_Level, + Right_Opnd => Make_Integer_Literal (Loc, Val.Offset)); + else + return Dynamic_Level; + end if; + end; else - return Type_Access_Level (Typ, Allow_Alt_Model); + return Make_Integer_Literal (Loc, Val.Offset); end if; - end Deepest_Type_Access_Level; + end Dynamic_Type_Access_Level; ------------------------- -- Extra_Accessibility -- @@ -2300,30 +2516,6 @@ package body Accessibility is end if; end Extra_Accessibility; - ------------------------------- - -- Get_Dynamic_Accessibility -- - ------------------------------- - - function Get_Dynamic_Accessibility (E : Entity_Id) return Entity_Id is - begin - -- When minimum accessibility is set for E then we utilize it - except - -- in a few edge cases like the expansion of select statements where - -- generated subprogram may attempt to unnecessarily use a minimum - -- accessibility object declared outside of scope. - - -- To avoid these situations where expansion may get complex we verify - -- that the minimum accessibility object is within scope. - - if Is_Formal (E) - and then Present (Minimum_Accessibility (E)) - and then In_Open_Scopes (Scope (Minimum_Accessibility (E))) - then - return Minimum_Accessibility (E); - end if; - - return Extra_Accessibility (E); - end Get_Dynamic_Accessibility; - ----------------------- -- Has_Access_Values -- ----------------------- @@ -2592,6 +2784,41 @@ package body Accessibility is end if; end Needs_Result_Accessibility_Level; + ------------------------- + -- Offset_Static_Level -- + ------------------------- + + -- An alternate, more sophisticated formula could be: + -- + -- if Extra_Accessibility (Subp) > Static_Accessibility (Subp) + -- then Level + Extra_Accessibility (Subp) - Static_Accessibility (Subp) + -- else Level + -- + -- and would yield more progressive dynamic levels in call chains, but it + -- would complicate the run-time computation and not really buy anything. + + function Offset_Static_Level + (Level : Uint; + Subp : Entity_Id) return Node_Id + is + Loc : constant Source_Ptr := Sloc (Subp); + + begin + pragma Assert (Is_Subprogram (Subp)); + + if Present (Extra_Accessibility_Of_Subprogram (Subp)) then + return + Make_Op_Add (Loc, + Left_Opnd => + New_Occurrence_Of + (Extra_Accessibility_Of_Subprogram (Subp), Loc), + Right_Opnd => Make_Integer_Literal (Loc, Level)); + + else + return Make_Integer_Literal (Loc, Level); + end if; + end Offset_Static_Level; + ------------------------------------------ -- Prefix_With_Safe_Accessibility_Level -- ------------------------------------------ @@ -2664,45 +2891,102 @@ package body Accessibility is return True; end Prefix_With_Safe_Accessibility_Level; - ----------------------------- - -- Subprogram_Access_Level -- - ----------------------------- - - function Subprogram_Access_Level (Subp : Entity_Id) return Uint is - begin - if Present (Alias (Subp)) then - return Subprogram_Access_Level (Alias (Subp)); - else - return Scope_Depth (Enclosing_Dynamic_Scope (Subp)); - end if; - end Subprogram_Access_Level; - -------------------------------- -- Static_Accessibility_Level -- -------------------------------- function Static_Accessibility_Level (Expr : Node_Id; - Level : Static_Accessibility_Level_Kind; + Object_Decl_Level : Boolean := False; In_Return_Context : Boolean := False) return Uint is + Level : constant Accessibility_Level_Kind := + (if Object_Decl_Level + then Accessibility.Object_Decl_Level + else Library_On_Dynamic_Level); + begin - return Intval (Accessibility_Level (Expr, Level, In_Return_Context)); + return + Accessibility_Level (Expr => Expr, + Level => Level, + Static => True, + In_Return_Context => In_Return_Context).U; end Static_Accessibility_Level; + ------------------------------- + -- Static_Local_Access_Level -- + ------------------------------- + + function Static_Local_Access_Level (E : Entity_Id) return Uint is + begin + return Scope_Depth (Enclosing_Dynamic_Scope (E)); + end Static_Local_Access_Level; + + ------------------------------------ + -- Static_Subprogram_Access_Level -- + ------------------------------------ + + function Static_Subprogram_Access_Level (Subp : Entity_Id) return Uint is + begin + if Present (Alias (Subp)) then + return Static_Subprogram_Access_Level (Alias (Subp)); + else + return Static_Local_Access_Level (Subp); + end if; + end Static_Subprogram_Access_Level; + + ------------------------------ + -- Static_Type_Access_Level -- + ------------------------------ + + function Static_Type_Access_Level + (Typ : Entity_Id; + Deepest : Boolean := False; + Allow_Alt_Model : Boolean := True; + Assoc_Node : Node_Id := Empty) return Uint + is + Val : constant Type_Level_T := + Type_Access_Level (Typ, Deepest, Allow_Alt_Model, Assoc_Node); + + begin + if Present (Val.Base) then + return Static_Local_Access_Level (Val.Base) + Val.Offset; + else + return Val.Offset; + end if; + end Static_Type_Access_Level; + ----------------------- -- Type_Access_Level -- ----------------------- function Type_Access_Level (Typ : Entity_Id; - Allow_Alt_Model : Boolean := True; - Assoc_Ent : Entity_Id := Empty) return Uint + Deepest : Boolean := False; + Allow_Alt_Model : Boolean := True; + Assoc_Node : Node_Id := Empty) return Type_Level_T is Btyp : Entity_Id := Base_Type (Typ); Def_Ent : Entity_Id; begin + if Ekind (Typ) = E_Anonymous_Access_Type + and then not Is_Local_Anonymous_Access (Typ) + and then Nkind (Associated_Node_For_Itype (Typ)) = N_Object_Declaration + and then Deepest + + -- No_Dynamic_Accessibility_Checks override for alternative + -- accessibility model. + + and then not (Allow_Alt_Model + and then No_Dynamic_Accessibility_Checks_Enabled (Typ)) + then + -- Typ is the type of an Ada 2012 stand-alone object of an anonymous + -- access type. + + return + (Defining_Identifier (Associated_Node_For_Itype (Typ)), Uint_0); + -- Ada 2005 (AI-230): For most cases of anonymous access types, we -- simply use the level where the type is declared. This is true for -- stand-alone object declarations, and for anonymous access types @@ -2711,7 +2995,7 @@ package body Accessibility is -- the cases of access parameters, return objects of an anonymous access -- type, and, in Ada 95, access discriminants of limited types. - if Is_Access_Type (Btyp) then + elsif Is_Access_Type (Btyp) then if Ekind (Btyp) = E_Anonymous_Access_Type then -- No_Dynamic_Accessibility_Checks restriction override for -- alternative accessibility model. @@ -2727,16 +3011,18 @@ package body Accessibility is (Designated_Type (Btyp), Allow_Alt_Model); end if; - -- When an anonymous access type's Assoc_Ent is specified, + -- When an anonymous access type's Assoc_Node is specified, -- calculate the result based on the general accessibility -- level routine. -- We would like to use Associated_Node_For_Itype here instead, -- but in some cases it is not fine grained enough ??? - if Present (Assoc_Ent) then - return Static_Accessibility_Level - (Assoc_Ent, Object_Decl_Level); + if Present (Assoc_Node) then + return + (Empty, + Static_Accessibility_Level + (Assoc_Node, Object_Decl_Level => True)); end if; -- Otherwise take the context of the anonymous access type into @@ -2749,10 +3035,9 @@ package body Accessibility is (Associated_Node_For_Itype (Typ)); if Present (Def_Ent) then - -- When the defining entity is a subprogram then we know the - -- anonymous access type Typ has been generated to either - -- describe an anonymous access type formal or an anonymous - -- access result type. + -- When the defining entity is a subprogram, then we know + -- that the anonymous access type Typ has been generated + -- for either an access formal or an access result. -- Since we are only interested in the formal case, avoid -- the anonymous access result type. @@ -2762,20 +3047,23 @@ package body Accessibility is and then Etype (Def_Ent) = Typ) then -- When the type comes from an anonymous access - -- parameter, the level is that of the subprogram - -- declaration. + -- parameter, the level is that of the parameter + -- in the called subprogram. - return Scope_Depth (Def_Ent); + if In_Open_Scopes (Def_Ent) then + return (First_Formal (Def_Ent), Uint_0); + + -- The level is the deepest possible in the caller + + else + return (Empty, UI_From_Int (Int'Last)); + end if; -- When the type is an access discriminant, the level is -- that of the type. elsif Ekind (Def_Ent) = E_Discriminant then - return Scope_Depth - (if Present (Full_View (Scope (Def_Ent))) then - Full_View (Scope (Def_Ent)) - else - Scope (Def_Ent)); + return (Scope (Def_Ent), Uint_0); end if; end if; @@ -2785,7 +3073,7 @@ package body Accessibility is -- fail static accessibility checks. elsif not Is_Local_Anonymous_Access (Typ) then - return Scope_Depth (Standard_Standard); + return (Empty, Scope_Depth (Standard_Standard)); -- If this is a return object, the accessibility level is that of -- the result subtype of the enclosing function. The test here is @@ -2829,30 +3117,30 @@ package body Accessibility is and then Nkind (Associated_Node_For_Itype (Typ)) = N_Discriminant_Specification then - return Scope_Depth (Enclosing_Dynamic_Scope (Btyp)) + 1; + return (Btyp, Uint_1); end if; end if; -- Return library level for a generic formal type. This is done because - -- RM(10.3.2) says that "The statically deeper relationship does not - -- apply to ... a descendant of a generic formal type". Rather than + -- RM 3.10.2(19.4) says that "The statically deeper relationship does + -- not apply to ... a descendant of a generic formal type". Rather than -- checking at each point where a static accessibility check is -- performed to see if we are dealing with a formal type, this rule is - -- implemented by having Type_Access_Level and Deepest_Type_Access_Level - -- return extreme values for a formal type; Deepest_Type_Access_Level - -- returns Int'Last. By calling the appropriate function from among the - -- two, we ensure that the static accessibility check will pass if we - -- happen to run into a formal type. More specifically, we should call - -- Deepest_Type_Access_Level instead of Type_Access_Level whenever the - -- call occurs as part of a static accessibility check and the error - -- case is the case where the type's level is too shallow (as opposed - -- to too deep). + -- implemented by returning extreme values for a formal type depending + -- on the Deepest parameter. More specifically, Deepest should be passed + -- as True whenever the call occurs as part of a static accessibility + -- check and the error case is the case where the type's level is too + -- shallow (as opposed to too deep). if Is_Generic_Type (Root_Type (Btyp)) then - return Scope_Depth (Standard_Standard); + if Deepest then + return (Empty, UI_From_Int (Int'Last)); + else + return (Empty, Scope_Depth (Standard_Standard)); + end if; end if; - return Scope_Depth (Enclosing_Dynamic_Scope (Btyp)); + return (Btyp, Uint_0); end Type_Access_Level; end Accessibility; diff --git a/gcc/ada/accessibility.ads b/gcc/ada/accessibility.ads index 6790864d7d7b..a162371b4360 100644 --- a/gcc/ada/accessibility.ads +++ b/gcc/ada/accessibility.ads @@ -23,7 +23,7 @@ -- -- ------------------------------------------------------------------------------ --- Accessibility level and check generation routines +-- Accessibility level calculation and check generation routines with Types; use Types; with Uintp; use Uintp; @@ -34,43 +34,6 @@ package Accessibility is -- Error, or warning within an instance, if the static accessibility -- rules of 3.10.2 are violated. - type Accessibility_Level_Kind is - (Dynamic_Level, Object_Decl_Level, Zero_On_Dynamic_Level); - -- Captures the different modes in which an accessibility level could be - -- obtained for a given expression. In the context of Accessibility_Level - -- function, Accessibility_Level_Kind signals what type of accessibility - -- level to obtain. - - -- When Level is Dynamic_Level, a defining identifier associated with an - -- access parameter, an access result, or an SAOOAAAT, may be returned, - -- and an N_Integer_Literal node in the other cases. - - -- When Level is Object_Decl_Level, an N_Integer_Literal node whose value - -- is the level of the declaration of the object is returned in the cases - -- where Dynamic_Level returns a defining identifier; in the other cases, - -- the same N_Integer_Literal node as Dynamic_Level is returned. - - -- When Level is Zero_On_Dynamic_Level, an N_Integer_Literal node whose - -- value is zero (i.e. that of the library level) is returned in the cases - -- where Dynamic_Level returns a defining identifier; in the other cases, - -- the same N_Integer_Literal node as Dynamic_Level is returned. - - function Accessibility_Level - (Expr : Node_Id; - Level : Accessibility_Level_Kind; - In_Return_Context : Boolean := False; - Allow_Alt_Model : Boolean := True) return Node_Id; - -- Centralized accessibility level calculation routine for finding the - -- accessibility level of a given expression Expr. - - -- In_Return_Context forces the Accessibility_Level calculations to be - -- carried out "as if" Expr existed in a return value. This is useful for - -- calculating the accessibility levels for discriminant associations - -- and return aggregates. - - -- The Allow_Alt_Model parameter allows the alternative level calculation - -- under the restriction No_Dynamic_Accessibility_Checks to be performed. - procedure Apply_Accessibility_Check_For_Class_Wide_Allocator (N : Node_Id; Exp : Node_Id; @@ -130,17 +93,44 @@ package Accessibility is -- Apply legality rules of 6.5(5.9) and 6.8(5) to the access discriminants -- of an identifier or aggregate in a return statement. - function Deepest_Type_Access_Level + function Dynamic_Accessibility_Level + (Expr : Node_Id; + In_Return_Context : Boolean := False; + Allow_Alt_Model : Boolean := True) return Node_Id; + -- Return the dynamic accessibility level of a given expression Expr, i.e. + -- the accessibility level that is defined by the language in RM 3.10.2(3) + -- as a value "reflect[ing] the run-time nesting of masters". + + -- In_Return_Context forces the level calculation to be carried out as if + -- Expr was an operative constituent of a return value; when it is False, + -- the function computes whether that is the case or not. + + -- The Allow_Alt_Model parameter allows the alternative level calculation + -- under the restriction No_Dynamic_Accessibility_Checks to be performed. + + function Dynamic_Local_Access_Level (E : Entity_Id) return Node_Id; + -- Return the dynamic accessibility level of the declaration of E. This is + -- the scope depth of the enclosing dynamic scope of E, offsetted by the + -- extra accessibility level of the enclosing subprogram of E if it exists. + + function Dynamic_Subprogram_Access_Level (Subp : Entity_Id) return Node_Id; + -- Return the dynamic accessibility level of Subp, which is the level of + -- the innermost master of the declaration of Subp (modulo renaming) and, + -- in particular, is *not* the level of the entities declared within Subp. + -- It is used to enforce the accessibility rules for access-to-subprogram + -- types, results of function calls, and formal objects of generic units. + + function Dynamic_Type_Access_Level (Typ : Entity_Id; - Allow_Alt_Model : Boolean := True) return Uint; - -- Same as Type_Access_Level, except that if the type is the type of an Ada - -- 2012 stand-alone object of an anonymous access type, then return the - -- static accessibility level of the object. In that case, the dynamic - -- accessibility level of the object may take on values in a range. The low - -- bound of that range is returned by Type_Access_Level; this function - -- yields the high bound of that range. Also differs from Type_Access_Level - -- in the case of a descendant of a generic formal type (returns Int'Last - -- instead of 0). + Deepest : Boolean := False; + Allow_Alt_Model : Boolean := True) return Node_Id; + -- Return the dynamic accessibility level of Typ + + -- When Deepest is True, and Typ is that of an Ada 2012 stand-alone object + -- of an anonymous access type, then return the dynamic accessibility level + -- of the declaration of the object instead of the library level; moreover, + -- in the case of a descendant of a generic formal type, return Int'Last + -- instead of the library level. -- The Allow_Alt_Model parameter allows the alternative level calculation -- under the restriction No_Dynamic_Accessibility_Checks to be performed. @@ -149,10 +139,6 @@ package Accessibility is -- Same as Extra_Accessibility_Of_Object in Einfo, but looks through object -- renamings per the RM 3.10.2(8) rule. - function Get_Dynamic_Accessibility (E : Entity_Id) return Entity_Id; - -- Obtain the accessibility level for a given entity formal taking into - -- account both extra and minimum accessibility. - function Has_Access_Values (T : Entity_Id) return Boolean; -- Returns true if the underlying type of T is an access type, or has a -- component (at any recursive level) that is an access type. This is a @@ -194,38 +180,53 @@ package Accessibility is -- of a value conversion is guaranteed to not create a new object, -- accessibility rules are defined as if it might. - subtype Static_Accessibility_Level_Kind - is Accessibility_Level_Kind range Object_Decl_Level - .. Zero_On_Dynamic_Level; - -- Restrict the reange of Accessibility_Level_Kind to be non-dynamic for - -- use in the static version of Accessibility_Level below. - function Static_Accessibility_Level (Expr : Node_Id; - Level : Static_Accessibility_Level_Kind; + Object_Decl_Level : Boolean := False; In_Return_Context : Boolean := False) return Uint; - -- Overloaded version of Accessibility_Level which returns a universal - -- integer for use in compile-time checking. Note: Level is restricted to - -- be non-dynamic. - - function Subprogram_Access_Level (Subp : Entity_Id) return Uint; - -- Return the accessibility level of Subp. Note that this is the level of + -- Return the static accessibility level of a given expression Expr, i.e. + -- an integer reflecting the compile-time nesting of master constructs, + -- for use in static accessibility checks. + + -- If Object_Decl_Level is True, then return the static accessibility level + -- of the *declaration* of the object in the cases where that of the object + -- itself is not defined, i.e. access parameters and Ada 2012's stand-alone + -- objects of an anonymous access type (RM 3.10.2(19.1-2)). If it is False, + -- then return the library level in these cases. + + -- In_Return_Context forces the level calculation to be carried out as if + -- Expr was an operative constituent of a return value; when it is False, + -- the function computes whether that is the case or not. + + function Static_Local_Access_Level (E : Entity_Id) return Uint; + -- Return the static accessibility level of the declaration of E. This is + -- the scope depth of the enclosing dynamic scope of E. + + function Static_Subprogram_Access_Level (Subp : Entity_Id) return Uint; + -- Return the static accessibility level of Subp, which is the level of -- the innermost master of the declaration of Subp (modulo renaming) and, -- in particular, is *not* the level of the entities declared within Subp. -- It is used to enforce the accessibility rules for access-to-subprogram -- types, results of function calls, and formal objects of generic units. - function Type_Access_Level + function Static_Type_Access_Level (Typ : Entity_Id; - Allow_Alt_Model : Boolean := True; - Assoc_Ent : Entity_Id := Empty) return Uint; - -- Return the accessibility level of Typ + Deepest : Boolean := False; + Allow_Alt_Model : Boolean := True; + Assoc_Node : Node_Id := Empty) return Uint; + -- Return the static accessibility level of Typ + + -- When Deepest is True, and Typ is that of an Ada 2012 stand-alone object + -- of an anonymous access type, then return the static accessibility level + -- of the declaration of the object instead of the library level; moreover, + -- in the case of a descendant of a generic formal type, return Int'Last + -- instead of the library level. -- The Allow_Alt_Model parameter allows the alternative level calculation -- under the restriction No_Dynamic_Accessibility_Checks to be performed. - -- Assoc_Ent allows for the optional specification of the entity associated - -- with Typ. This gets utilized mostly for anonymous access type - -- processing, where context matters in interpreting Typ's level. + -- Assoc_Node allows for the optional specification of a node associated + -- with Typ. This is used only for anonymous access types where the context + -- matters in interpreting Typ's level. end Accessibility; diff --git a/gcc/ada/contracts.adb b/gcc/ada/contracts.adb index 99ad2cd5d567..0c75a24d3955 100644 --- a/gcc/ada/contracts.adb +++ b/gcc/ada/contracts.adb @@ -1530,9 +1530,10 @@ package body Contracts is Body_Decl : constant Entity_Id := Unit_Declaration_Node (Body_Id); Loc : constant Source_Ptr := Sloc (Body_Decl); Spec_Id : constant Entity_Id := Corresponding_Spec (Body_Decl); - Subp_Id : Entity_Id; - Ret_Type : Entity_Id; + Extra_Decl : Node_Id; + Ret_Type : Entity_Id; + Subp_Id : Entity_Id; Wrapper_Id : Entity_Id; Wrapper_Body : Node_Id; Wrapper_Spec : Node_Id; @@ -1619,6 +1620,16 @@ package body Contracts is Result_Definition => New_Occurrence_Of (Ret_Type, Loc)); end if; + -- Do not move the declaration of the Extra_Accessibility_Of_Subprogram + -- constant, if any, since it really belongs in the original subprogram. + + if Present (Extra_Accessibility_Of_Subprogram (Subp_Id)) then + Extra_Decl := + Declaration_Node (Extra_Accessibility_Of_Subprogram (Subp_Id)); + Remove (Extra_Decl); + Prepend_To (Decls, Extra_Decl); + end if; + -- Create the wrapper body using Body_Id's statements and declarations Wrapper_Body := diff --git a/gcc/ada/einfo.ads b/gcc/ada/einfo.ads index ea5631094186..73d684890eee 100644 --- a/gcc/ada/einfo.ads +++ b/gcc/ada/einfo.ads @@ -1280,6 +1280,18 @@ package Einfo is -- and the Extra_Accessibility_Of_Result field of the function points to -- the entity for this extra formal. +-- Extra_Accessibility_Of_Subprogram +-- Defined in (non-generic) subprograms. Normally Empty, but if expansion +-- is active, and the subprogram has either at least one formal parameter +-- with Extra_Accessibility_Of_Object, or Extra_Accessibility_Of_Result, +-- or its parent subprogram has Extra_Accessibility_Of_Subprogram, then +-- a local constant of type Natural is created in the subprogram, whose +-- initialization expression is the maximum of all the values mentioned +-- above, and the Extra_Accessibility_Of_Subprogram points to the entity. +-- It is used to offset the static nesting depth of the local entities, +-- both objects, subprograms, and types declared in the subprogram, for +-- the computation of the dynamic accessibility level of these entities. + -- Extra_Constrained -- Defined in formal parameters in the non-generic case. Normally Empty, -- but if expansion is active and a parameter is one for which a dynamic @@ -3725,14 +3737,6 @@ package Einfo is -- is also set (to the default value of zero = Default_Mechanism) in a -- subprogram body entity but not used in this context. --- Minimum_Accessibility --- Defined in formal parameters in the non-generic case. Normally Empty, --- but if expansion is active, and a parameter exists for which a --- dynamic accessibility check is required, then an object is generated --- within such a subprogram representing the accessibility level of the --- subprogram or the formal's Extra_Accessibility - whichever one is --- lesser. The Minimum_Accessibility field then points to this object. - -- Modulus [implementation base type only] -- Defined in modular types. Contains the modulus. For the binary case, -- this will be a power of 2, but if Non_Binary_Modulus is set, then it @@ -5611,7 +5615,6 @@ package Einfo is -- Alias (non-generic case only) -- Renamed_Entity -- Renamed_Object $$$ - -- Extra_Accessibility_Of_Result (non-generic case only) -- Last_Entity -- Interface_Name -- Scope_Depth_Value @@ -5625,6 +5628,8 @@ package Einfo is -- Overridden_Inherited_Operation -- Overridden_Operation -- Wrapped_Entity (non-generic case only) + -- Extra_Accessibility_Of_Result (non-generic case only) + -- Extra_Accessibility_Of_Subprogram (non-generic case only) -- Extra_Formals -- Extra_Formals_Known (non-generic case only) -- Anonymous_Collections (non-generic case only) @@ -5760,7 +5765,6 @@ package Einfo is -- Default_Value -- Protected_Formal -- Extra_Constrained - -- Minimum_Accessibility -- Last_Assignment (OUT, IN-OUT only) -- Activation_Record_Component -- Has_Initial_Value @@ -5829,13 +5833,14 @@ package Einfo is -- E_Operator -- First_Entity -- Alias - -- Extra_Accessibility_Of_Result -- Last_Entity -- Subps_Index -- Overridden_Inherited_Operation -- Overridden_Operation -- Linker_Section_Pragma -- Contract + -- Extra_Accessibility_Of_Result + -- Extra_Accessibility_Of_Subprogram -- Extra_Formals -- Extra_Formals_Known -- Import_Pragma @@ -5992,6 +5997,7 @@ package Einfo is -- Overridden_Inherited_Operation -- Overridden_Operation (never for init proc) -- Wrapped_Entity (non-generic case only) + -- Extra_Accessibility_Of_Subprogram (non-generic case only) -- Extra_Formals -- Extra_Formals_Known (non-generic case only) -- Anonymous_Collections (non-generic case only) diff --git a/gcc/ada/exp_aggr.adb b/gcc/ada/exp_aggr.adb index 7f785c329075..da302cb048c1 100644 --- a/gcc/ada/exp_aggr.adb +++ b/gcc/ada/exp_aggr.adb @@ -23,6 +23,7 @@ -- -- ------------------------------------------------------------------------------ +with Accessibility; use Accessibility; with Aspects; use Aspects; with Atree; use Atree; with Checks; use Checks; @@ -4059,19 +4060,6 @@ package body Exp_Aggr is function Check_Component (C : Node_Id; T_OK : Boolean) return Boolean is - - function SDO (E : Entity_Id) return Uint; - -- Return the Scope Depth Of the enclosing dynamic scope of E - - --------- - -- SDO -- - --------- - - function SDO (E : Entity_Id) return Uint is - begin - return Scope_Depth (Enclosing_Dynamic_Scope (E)); - end SDO; - -- Start of processing for Check_Component begin @@ -4149,7 +4137,9 @@ package body Exp_Aggr is else return Present (Target_Object) and then not Is_Formal (Target_Object) - and then SDO (Target_Object) >= SDO (Entity (C)); + and then + Static_Local_Access_Level (Target_Object) + >= Static_Local_Access_Level (Entity (C)); end if; -- For a renamed object, recurse @@ -4175,7 +4165,9 @@ package body Exp_Aggr is -- is at most as deeply nested as the component. elsif Is_Formal (Target_Object) then - return SDO (Target_Object) <= SDO (Entity (C)); + return + Static_Local_Access_Level (Target_Object) + <= Static_Local_Access_Level (Entity (C)); -- For distinct stand-alone objects, this is safe diff --git a/gcc/ada/exp_attr.adb b/gcc/ada/exp_attr.adb index 6ed2de30cb8f..a30c19beb94a 100644 --- a/gcc/ada/exp_attr.adb +++ b/gcc/ada/exp_attr.adb @@ -2613,9 +2613,7 @@ package body Exp_Attr is Name_Req => True)), Attribute_Name => Name_Tag)), - Right_Opnd => - Make_Integer_Literal (Loc, - Type_Access_Level (P_Type))), + Right_Opnd => Dynamic_Type_Access_Level (P_Type)), Then_Statements => New_List (Make_Raise_Statement (Loc, diff --git a/gcc/ada/exp_ch3.adb b/gcc/ada/exp_ch3.adb index de771f025689..5372b8a7435d 100644 --- a/gcc/ada/exp_ch3.adb +++ b/gcc/ada/exp_ch3.adb @@ -2789,7 +2789,7 @@ package body Exp_Ch3 is Selector_Name => Make_Identifier (Loc, Name_uInit_Level), Explicit_Actual_Parameter => - Accessibility_Level (Id_Ref, Dynamic_Level))); + Dynamic_Accessibility_Level (Id_Ref))); end if; Append_To (Res, @@ -3352,7 +3352,10 @@ package body Exp_Ch3 is -- Create an extra accessibility parameter to capture the level of -- the object being initialized when its type is a limited record. - if Is_Limited_Record (Rec_Type) then + if Is_Limited_Record (Rec_Type) + and then not Is_RTE (Rec_Type, RE_Activation_Chain) + and then not Is_RTE (Rec_Type, RE_Finalization_Master) + then Append_To (Parameters, Make_Parameter_Specification (Loc, Defining_Identifier => Make_Defining_Identifier @@ -8753,7 +8756,7 @@ package body Exp_Ch3 is -- General case else - Level_Expr := Accessibility_Level (Expr, Dynamic_Level); + Level_Expr := Dynamic_Accessibility_Level (Expr); end if; Level_Decl := @@ -10062,8 +10065,9 @@ package body Exp_Ch3 is if Is_Part_Of_Formal or else Is_Part_Of_Dereference or else - Type_Access_Level (Def_Id) - > Static_Accessibility_Level (Pool, Object_Decl_Level) + Static_Type_Access_Level (Def_Id) + > Static_Accessibility_Level + (Pool, Object_Decl_Level => True) then -- Generate: -- if RSP'Class?(Def_Id) in RSPWS'Class then diff --git a/gcc/ada/exp_ch4.adb b/gcc/ada/exp_ch4.adb index 8fa214f01853..57424bbe8117 100644 --- a/gcc/ada/exp_ch4.adb +++ b/gcc/ada/exp_ch4.adb @@ -7211,9 +7211,9 @@ package body Exp_Ch4 is and then Ekind (Ltyp) = E_Anonymous_Access_Type then declare - New_N : Node_Id; - Param_Level : Node_Id; - Type_Level : Node_Id; + New_N : Node_Id; + Expr_Level : Node_Id; + Type_Level : Node_Id; begin -- When restriction No_Dynamic_Accessibility_Checks is in @@ -7224,9 +7224,9 @@ package body Exp_Ch4 is Rewrite (N, New_Occurrence_Of (Boolean_Literals - (Static_Accessibility_Level - (Lop, Object_Decl_Level) <= - Type_Access_Level (Rtyp)), + (Static_Accessibility_Level + (Lop, Object_Decl_Level => True) + <= Static_Type_Access_Level (Rtyp)), Loc)); Analyze_And_Resolve (N, Restyp); @@ -7239,28 +7239,23 @@ package body Exp_Ch4 is Rewrite (N, New_Occurrence_Of (Standard_False, Loc)); Analyze_And_Resolve (N, Restyp); - -- Apply an accessibility check if the access object has an - -- associated access level and when the level of the type is - -- less deep than the level of the access parameter. This - -- can only occur for access parameters and stand-alone - -- objects of an anonymous access type. + -- Otherwise perform a dynamic accessibility test else - Param_Level := Accessibility_Level (Lop, Dynamic_Level); - - Type_Level := - Make_Integer_Literal (Loc, Type_Access_Level (Rtyp)); + Expr_Level := Dynamic_Accessibility_Level (Lop); + Type_Level := Dynamic_Type_Access_Level (Rtyp); -- Return True only if the accessibility level of the -- expression entity is not deeper than the level of - -- the tested access type. + -- the tested access type (RM 4.5.2(30.3)). Rewrite (N, Make_And_Then (Loc, Left_Opnd => Relocate_Node (N), - Right_Opnd => Make_Op_Le (Loc, - Left_Opnd => Param_Level, - Right_Opnd => Type_Level))); + Right_Opnd => + Make_Op_Le (Loc, + Left_Opnd => Expr_Level, + Right_Opnd => Type_Level))); Analyze_And_Resolve (N); diff --git a/gcc/ada/exp_ch5.adb b/gcc/ada/exp_ch5.adb index 5d7c78f82f67..cf4733317497 100644 --- a/gcc/ada/exp_ch5.adb +++ b/gcc/ada/exp_ch5.adb @@ -2868,7 +2868,7 @@ package body Exp_Ch5 is -- when the Lhs denotes a container cursor and the Next function employs -- an access type, because this can never result in a dangling pointer. - if Is_Access_Type (Typ) + if Ekind (Typ) = E_Anonymous_Access_Type and then Is_Entity_Name (Lhs) and then Ekind (Entity (Lhs)) /= E_Loop_Parameter and then Present (Extra_Accessibility (Entity (Lhs))) @@ -2879,9 +2879,9 @@ package body Exp_Ch5 is Condition => Make_Op_Gt (Loc, Left_Opnd => - Accessibility_Level (Rhs, Dynamic_Level), + Dynamic_Accessibility_Level (Rhs), Right_Opnd => - Accessibility_Level (Lhs, Object_Decl_Level)), + Dynamic_Type_Access_Level (Typ, Deepest => True)), Reason => PE_Accessibility_Check_Failed)); end if; @@ -2890,10 +2890,7 @@ package body Exp_Ch5 is Name => New_Occurrence_Of (Extra_Accessibility (Entity (Lhs)), Loc), Expression => - Accessibility_Level - (Expr => Rhs, - Level => Dynamic_Level, - Allow_Alt_Model => False))); + Dynamic_Accessibility_Level (Rhs, Allow_Alt_Model => False))); end if; -- Case of assignment to a bit packed array element. If there is a diff --git a/gcc/ada/exp_ch6.adb b/gcc/ada/exp_ch6.adb index 53f889689611..9d0e054b05a3 100644 --- a/gcc/ada/exp_ch6.adb +++ b/gcc/ada/exp_ch6.adb @@ -1830,8 +1830,8 @@ package body Exp_Ch6 is Make_Assignment_Statement (Loc, Name => New_Occurrence_Of ( Extra_Accessibility (Entity (Lhs)), Loc), - Expression => Make_Integer_Literal (Loc, - Type_Access_Level (E_Formal)))); + Expression => + Dynamic_Type_Access_Level (E_Formal))); else if Is_Access_Type (E_Formal) @@ -2982,10 +2982,8 @@ package body Exp_Ch6 is Make_Assignment_Statement (Loc, Name => New_Occurrence_Of (Lvl, Loc), Expression => - Accessibility_Level - (Expr => Expression (Res_Assn), - Level => Dynamic_Level, - Allow_Alt_Model => False))); + Dynamic_Accessibility_Level + (Expression (Res_Assn), Allow_Alt_Model => False))); end if; end Expand_Branch; @@ -3415,10 +3413,8 @@ package body Exp_Ch6 is end if; Add_Extra_Actual - (Expr => Accessibility_Level - (Expr => Parm_Ent, - Level => Dynamic_Level, - Allow_Alt_Model => False), + (Expr => Dynamic_Accessibility_Level + (Parm_Ent, Allow_Alt_Model => False), EF => Extra_Accessibility (Formal)); end; @@ -3458,9 +3454,8 @@ package body Exp_Ch6 is end if; Add_Extra_Actual - (Expr => Accessibility_Level - (Expr => Expression (Parent (Ent)), - Level => Dynamic_Level, + (Expr => Dynamic_Accessibility_Level + (Expression (Parent (Ent)), Allow_Alt_Model => False), EF => Extra_Accessibility (Formal)); end; @@ -3469,10 +3464,8 @@ package body Exp_Ch6 is else Add_Extra_Actual - (Expr => Accessibility_Level - (Expr => Prev, - Level => Dynamic_Level, - Allow_Alt_Model => False), + (Expr => Dynamic_Accessibility_Level + (Prev, Allow_Alt_Model => False), EF => Extra_Accessibility (Formal)); end if; end if; @@ -3515,10 +3508,8 @@ package body Exp_Ch6 is -- Otherwise get the level normally based on the call node else - Level := Accessibility_Level - (Expr => Call_Node, - Level => Dynamic_Level, - Allow_Alt_Model => False); + Level := Dynamic_Accessibility_Level + (Call_Node, Allow_Alt_Model => False); end if; -- It may be possible that we are re-expanding an already diff --git a/gcc/ada/exp_ch9.adb b/gcc/ada/exp_ch9.adb index c2fc6c8a284f..baf7c97ad1b8 100644 --- a/gcc/ada/exp_ch9.adb +++ b/gcc/ada/exp_ch9.adb @@ -9612,13 +9612,14 @@ package body Exp_Ch9 is -- end; procedure Expand_N_Requeue_Statement (N : Node_Id) is - Loc : constant Source_Ptr := Sloc (N); - Conc_Typ : Entity_Id; - Concval : Node_Id; - Ename : Node_Id; - Enc_Subp : Entity_Id; - Index : Node_Id; - Old_Typ : Entity_Id; + Loc : constant Source_Ptr := Sloc (N); + + Conc_Typ : Entity_Id; + Concval : Node_Id; + Ename : Node_Id; + Enclosing : Entity_Id; + Index : Node_Id; + Old_Typ : Entity_Id; function Build_Dispatching_Call_Equivalent return Node_Id; -- Ada 2012 (AI05-0030): N denotes a dispatching requeue statement of @@ -10128,38 +10129,40 @@ package body Exp_Ch9 is -- type. This will constitute our invocation source. Old_Typ := Current_Scope; - while Present (Old_Typ) - and then not Is_Concurrent_Type (Old_Typ) - loop + while Present (Old_Typ) and then not Is_Concurrent_Type (Old_Typ) loop Old_Typ := Scope (Old_Typ); end loop; -- Obtain the innermost enclosing callable construct for use in - -- generating a dynamic accessibility check. - - Enc_Subp := Current_Scope; + -- generating a dynamic accessibility check per RM 9.5.4(7.2). - if Ekind (Enc_Subp) not in Entry_Kind | Subprogram_Kind then - Enc_Subp := Enclosing_Subprogram (Enc_Subp); - end if; + Enclosing := Empty; + for J in reverse 0 .. Scope_Stack.Last loop + Enclosing := Scope_Stack.Table (J).Entity; + exit when Is_Entry (Enclosing); + end loop; - -- Generate a dynamic accessibility check on the target object + -- Generate a dynamic accessibility check on the target object, unless + -- it is a parameter of the innermost enclosing callable construct. - Insert_Before_And_Analyze (N, - Make_Raise_Program_Error (Loc, - Condition => - Make_Op_Gt (Loc, - Left_Opnd => Accessibility_Level (Name (N), Dynamic_Level), - Right_Opnd => Make_Integer_Literal (Loc, - Scope_Depth (Enc_Subp))), - Reason => PE_Accessibility_Check_Failed)); + if not Is_Entity_Name (Original_Node (Concval)) + or else not Is_Formal (Entity (Original_Node (Concval))) + or else Enclosing /= Scope (Entity (Original_Node (Concval))) + then + Insert_Before_And_Analyze (N, + Make_Raise_Program_Error (Loc, + Condition => + Make_Op_Gt (Loc, + Left_Opnd => Dynamic_Accessibility_Level (Name (N)), + Right_Opnd => Dynamic_Local_Access_Level (Enclosing)), + Reason => PE_Accessibility_Check_Failed)); + end if; -- Ada 2012 (AI05-0030): We have a dispatching requeue of the form -- Concval.Ename where the type of Concval is class-wide concurrent -- interface. if Ada_Version >= Ada_2012 - and then Present (Concval) and then Is_Class_Wide_Type (Conc_Typ) and then Is_Concurrent_Interface (Conc_Typ) then diff --git a/gcc/ada/exp_disp.adb b/gcc/ada/exp_disp.adb index bc2ad51c89c4..299956e7bca2 100644 --- a/gcc/ada/exp_disp.adb +++ b/gcc/ada/exp_disp.adb @@ -5064,7 +5064,7 @@ package body Exp_Disp is -- TSD : Type_Specific_Data (I_Depth) := -- (Idepth => I_Depth, - -- Access_Level => Type_Access_Level (Typ), + -- Access_Level => Dynamic_Type_Access_Level (Typ), -- Alignment => Typ'Alignment, -- Expanded_Name => Cstring_Ptr!(Exname'Address)) -- External_Tag => Cstring_Ptr!(Exname'Address)) @@ -5111,8 +5111,7 @@ package body Exp_Disp is -- Access_Level - Append_To (TSD_Aggr_List, - Make_Integer_Literal (Loc, Type_Access_Level (Typ))); + Append_To (TSD_Aggr_List, Dynamic_Type_Access_Level (Typ)); -- Alignment diff --git a/gcc/ada/gen_il-fields.ads b/gcc/ada/gen_il-fields.ads index 93cfd85ed220..be9778630a54 100644 --- a/gcc/ada/gen_il-fields.ads +++ b/gcc/ada/gen_il-fields.ads @@ -538,6 +538,7 @@ package Gen_IL.Fields is Esize, Extra_Accessibility_Of_Object, Extra_Accessibility_Of_Result, + Extra_Accessibility_Of_Subprogram, Extra_Constrained, Extra_Formal, Extra_Formals, @@ -829,7 +830,6 @@ package Gen_IL.Fields is Materialize_Entity, May_Inherit_Delayed_Rep_Aspects, Mechanism, - Minimum_Accessibility, Modulus, Must_Be_On_Byte_Boundary, Must_Have_Preelab_Init, diff --git a/gcc/ada/gen_il-gen-gen_entities.adb b/gcc/ada/gen_il-gen-gen_entities.adb index 4b73c011b2e5..3a085e8c5322 100644 --- a/gcc/ada/gen_il-gen-gen_entities.adb +++ b/gcc/ada/gen_il-gen-gen_entities.adb @@ -411,7 +411,6 @@ begin -- Gen_IL.Gen.Gen_Entities Sm (Is_Only_Out_Parameter, Flag), Sm (Linker_Section_Pragma, Node_Id), Sm (Mechanism, Mechanism_Type), - Sm (Minimum_Accessibility, Node_Id), Sm (Protected_Formal, Node_Id), Sm (Spec_Entity, Node_Id), Sm (Unset_Reference, Node_Id))); @@ -977,6 +976,7 @@ begin -- Gen_IL.Gen.Gen_Entities Sm (Dynamic_Call_Helper, Node_Id), Sm (Elaboration_Entity, Node_Id), Sm (Elaboration_Entity_Required, Flag), + Sm (Extra_Accessibility_Of_Subprogram, Node_Id), Sm (First_Entity, Node_Id), Sm (Has_Expanded_Contract, Flag), Sm (Has_Nested_Subprogram, Flag), diff --git a/gcc/ada/sem_attr.adb b/gcc/ada/sem_attr.adb index c61761edca83..4d145c44e14e 100644 --- a/gcc/ada/sem_attr.adb +++ b/gcc/ada/sem_attr.adb @@ -12208,8 +12208,8 @@ package body Sem_Attr is and then (Ekind (Btyp) = E_Access_Subprogram_Type or else Is_Local_Anonymous_Access (Btyp)) - and then Subprogram_Access_Level (Entity (P)) > - Type_Access_Level (Btyp) + and then Static_Subprogram_Access_Level (Entity (P)) + > Static_Type_Access_Level (Btyp) then Error_Msg_F ("subprogram must not be deeper than access type", P); @@ -12266,8 +12266,8 @@ package body Sem_Attr is and then Enclosing_Generic_Body (N) /= Enclosing_Generic_Body (Enclosing_Generic_Unit (Entity (P))) - and then Subprogram_Access_Level (Entity (P)) = - Type_Access_Level (Btyp) + and then Static_Subprogram_Access_Level (Entity (P)) = + Static_Type_Access_Level (Btyp) and then Ekind (Btyp) /= E_Anonymous_Access_Subprogram_Type and then Ekind (Btyp) /= @@ -12667,8 +12667,8 @@ package body Sem_Attr is or else No_Dynamic_Acc_Checks) and then - Static_Accessibility_Level (P, Zero_On_Dynamic_Level) - > Deepest_Type_Access_Level (Btyp) + Static_Accessibility_Level (P) + > Static_Type_Access_Level (Btyp, Deepest => True) then Accessibility_Message (N, Typ); end if; @@ -12688,8 +12688,8 @@ package body Sem_Attr is -- anonymous_access_to_protected, there are no accessibility -- checks either. Omit check entirely for Unrestricted_Access. - elsif Static_Accessibility_Level (P, Zero_On_Dynamic_Level) - > Deepest_Type_Access_Level (Btyp) + elsif Static_Accessibility_Level (P) + > Static_Type_Access_Level (Btyp, Deepest => True) and then Comes_From_Source (N) and then Ekind (Btyp) = E_Access_Protected_Subprogram_Type and then Attr_Id /= Attribute_Unrestricted_Access diff --git a/gcc/ada/sem_ch13.adb b/gcc/ada/sem_ch13.adb index b2845814d306..853659b6ab0c 100644 --- a/gcc/ada/sem_ch13.adb +++ b/gcc/ada/sem_ch13.adb @@ -8145,9 +8145,9 @@ package body Sem_Ch13 is -- check (B) - if Type_Access_Level (Ent) + if Static_Type_Access_Level (Ent) > Static_Accessibility_Level - (Pool, Object_Decl_Level) + (Pool, Object_Decl_Level => True) then Error_Msg_N ("subpool access type has deeper accessibility " diff --git a/gcc/ada/sem_ch3.adb b/gcc/ada/sem_ch3.adb index 293f3376039a..4893671b9290 100644 --- a/gcc/ada/sem_ch3.adb +++ b/gcc/ada/sem_ch3.adb @@ -2145,8 +2145,8 @@ package body Sem_Ch3 is -- (Ada 2005: AI-230): Accessibility check for anonymous -- components - if Type_Access_Level (Etype (E)) > - Deepest_Type_Access_Level (T) + if Static_Type_Access_Level (Etype (E)) + > Static_Type_Access_Level (T, Deepest => True) then Error_Msg_N ("expression has deeper access level than component " & @@ -9820,8 +9820,8 @@ package body Sem_Ch3 is if Ada_Version >= Ada_2005 then Check_Generic_Ancestors; - elsif Type_Access_Level (Derived_Type) /= - Type_Access_Level (Parent_Type) + elsif Static_Type_Access_Level (Derived_Type) + /= Static_Type_Access_Level (Parent_Type) and then not Is_Generic_Type (Derived_Type) then if Is_Controlled (Parent_Type) then @@ -18422,8 +18422,9 @@ package body Sem_Ch3 is -- of the type. if Scope (Root_Class_Typ) /= Scope (T) - and then Deepest_Type_Access_Level (Root_Class_Typ) - < Deepest_Type_Access_Level (T) + and then + Static_Type_Access_Level (Root_Class_Typ, Deepest => True) + < Static_Type_Access_Level (T) then Error_Msg_NE ("descendant of mutably tagged type cannot be deeper than" diff --git a/gcc/ada/sem_ch6.adb b/gcc/ada/sem_ch6.adb index a2028768c403..c4b09a227886 100644 --- a/gcc/ada/sem_ch6.adb +++ b/gcc/ada/sem_ch6.adb @@ -1098,8 +1098,8 @@ package body Sem_Ch6 is if Ada_Version >= Ada_2005 and then Is_Class_Wide_Type (R_Type) then - if Type_Access_Level (Etype (Expr)) > - Subprogram_Access_Level (Scope_Id) + if Static_Type_Access_Level (Etype (Expr)) + > Static_Subprogram_Access_Level (Scope_Id) then Error_Msg_N ("level of return expression type is deeper than " @@ -1122,8 +1122,8 @@ package body Sem_Ch6 is if (Ada_Version < Ada_2005 or else Debug_Flag_Dot_L) and then Is_Inherently_Limited_Type (Etype (Scope_Id)) - and then Static_Accessibility_Level (Expr, Zero_On_Dynamic_Level) - > Subprogram_Access_Level (Scope_Id) + and then Static_Accessibility_Level (Expr) + > Static_Subprogram_Access_Level (Scope_Id) then -- Suppress the message in a generic, where the rewriting -- is irrelevant. @@ -1158,8 +1158,8 @@ package body Sem_Ch6 is -- has no initializing expression. elsif Ada_Version > Ada_2005 and then Is_Class_Wide_Type (R_Type) then - if Type_Access_Level (Etype (Defining_Identifier (Obj_Decl))) > - Subprogram_Access_Level (Scope_Id) + if Static_Type_Access_Level (Etype (Defining_Identifier (Obj_Decl))) + > Static_Subprogram_Access_Level (Scope_Id) then Error_Msg_N ("level of return expression type is deeper than " @@ -2398,7 +2398,7 @@ package body Sem_Ch6 is -- means that it is equivalent to Is_Expression_Function_Or_Completion -- invoked on Spec_Id declared below and not to Is_Expression_Function. - Acc_Objs : List_Id := No_List; + Acc_Decl : Node_Id := Empty; Desig_View : Entity_Id := Empty; Exch_Views : Elist_Id := No_Elist; Prot_Typ : Entity_Id := Empty; @@ -2464,6 +2464,13 @@ package body Sem_Ch6 is -- Checks for a function with a no return statements, and also performs -- the warning checks implemented by Check_Returns. + procedure Compute_Extra_Accessibility + (Subp_Id : Entity_Id; + Extra_Access_Id : Entity_Id); + -- Update the value of the Extra_Accessibility_Of_Subprogram object of + -- Subp_Id given the value of an Extra_Accessibility formal by taking + -- the maximum of the two values. + function Disambiguate_Spec return Entity_Id; -- When a primitive is declared between the private view and the full -- view of a concurrent type which implements an interface, a special @@ -2476,13 +2483,6 @@ package body Sem_Ch6 is -- limited views with the non-limited ones. Return the list of changes -- to be used to undo the transformation. - procedure Generate_Minimum_Accessibility - (Extra_Access : Entity_Id; - Related_Form : Entity_Id := Empty); - -- Generate a minimum accessibility object for a given extra - -- accessibility formal (Extra_Access) and its related formal if it - -- exists. - function Is_Private_Concurrent_Primitive (Subp_Id : Entity_Id) return Boolean; -- Determine whether subprogram Subp_Id is a primitive of a concurrent @@ -3052,6 +3052,41 @@ package body Sem_Ch6 is end if; end Check_Missing_Return; + --------------------------------- + -- Compute_Extra_Accessibility -- + --------------------------------- + + procedure Compute_Extra_Accessibility + (Subp_Id : Entity_Id; + Extra_Access_Id : Entity_Id) + is + Acc_Id : Entity_Id; + + begin + if Present (Extra_Accessibility_Of_Subprogram (Subp_Id)) then + Set_Expression (Acc_Decl, + Make_Attribute_Reference (Loc, + Prefix => New_Occurrence_Of (Standard_Natural, Loc), + Attribute_Name => Name_Max, + Expressions => New_List ( + New_Occurrence_Of (Extra_Access_Id, Loc), + Expression (Acc_Decl)))); + + else + Acc_Id := Make_Temporary (Loc, 'A', Extra_Access_Id); + Acc_Decl := + Make_Object_Declaration (Loc, + Defining_Identifier => Acc_Id, + Constant_Present => True, + Object_Definition => + New_Occurrence_Of (Standard_Natural, Loc), + Expression => + New_Occurrence_Of (Extra_Access_Id, Loc)); + + Set_Extra_Accessibility_Of_Subprogram (Subp_Id, Acc_Id); + end if; + end Compute_Extra_Accessibility; + ----------------------- -- Disambiguate_Spec -- ----------------------- @@ -3225,60 +3260,6 @@ package body Sem_Ch6 is return Result; end Exchange_Limited_Views; - ------------------------------------ - -- Generate_Minimum_Accessibility -- - ------------------------------------ - - procedure Generate_Minimum_Accessibility - (Extra_Access : Entity_Id; - Related_Form : Entity_Id := Empty) - is - Loc : constant Source_Ptr := Sloc (N); - - Decl : Node_Id; - Form : Entity_Id; - - begin - -- When no related formal exists then we are dealing with an - -- extra accessibility formal for a function result. - - if No (Related_Form) then - Form := Extra_Access; - else - Form := Related_Form; - end if; - - -- Declare the minimum accessibility object - - Decl := - Make_Object_Declaration (Loc, - Defining_Identifier => Make_Temporary (Loc, 'A', Extra_Access), - Object_Definition => New_Occurrence_Of (Standard_Natural, Loc), - Expression => - Make_Attribute_Reference (Loc, - Prefix => New_Occurrence_Of (Standard_Natural, Loc), - Attribute_Name => Name_Min, - Expressions => New_List ( - Make_Integer_Literal (Loc, Scope_Depth (Body_Id)), - New_Occurrence_Of (Extra_Access, Loc)))); - - -- Add the new local object to the Minimum_Acc_Obj to be later - -- prepended to the subprogram's list of declarations after we - -- are sure all expansion is done. - - if Present (Acc_Objs) then - Prepend (Decl, Acc_Objs); - else - Acc_Objs := New_List (Decl); - end if; - - -- Register the object and analyze it - - Set_Minimum_Accessibility (Form, Defining_Identifier (Decl)); - - Analyze (Decl); - end Generate_Minimum_Accessibility; - ------------------------------------- -- Is_Private_Concurrent_Primitive -- ------------------------------------- @@ -4437,69 +4418,60 @@ package body Sem_Ch6 is end; end if; - -- Generate minimum accessibility local objects to correspond with - -- any extra formal added for anonymous access types. This new local - -- object can then be used instead of the formal in case it is used - -- in an actual to a call to a nested subprogram. - - -- This method is used to supplement our "small integer model" for - -- accessibility check generation (for more information see - -- Accessibility_Level). - - -- Because we allow accessibility values greater than our expected value - -- passing along the same extra accessibility formal as an actual - -- to a nested subprogram becomes a problem because high values mean - -- different things to the callee even though they are the same to the - -- caller. So, as described in the first section, we create a local - -- object representing the minimum of the accessibility level value that - -- is passed in and the accessibility level of the callee's parameter - -- and locals and use it in the case of a call to a nested subprogram. - -- This generated object is referred to as a "minimum accessibility - -- level." - - -- Loop through formals if the subprogram is capable of accepting - -- a generated local object. If it is not, then it is also not - -- capable of having local subprograms meaning it would not need - -- a minimum accessibility level object anyway. - - if Has_Declarations (N) then + -- Compute the value of the Extra_Accessibility_Of_Subprogram object if + -- there are extra formals added for anonymous access types. This value + -- is used as an offset in the computation of the dynamic accessibility + -- level of the entities declared in the subprogram. + + -- This method supplements our "small integer" model for the generation + -- of dynamic accessibility checks. It ensures that the local objects of + -- the subprogram have a deeper dynamic accessibility level than any of + -- the nonlocal objects the subprogram may access indirectly. + + if Nkind (N) = N_Subprogram_Body + and then not No_Dynamic_Accessibility_Checks_Enabled (N) + and then (No (Spec_Id) + or else No (Extra_Accessibility_Of_Subprogram (Spec_Id))) + then declare Subp_Id : constant Entity_Id := Subprogram_Entity; + Par_Id : constant Entity_Id := Enclosing_Subprogram (Subp_Id); Formal : Node_Id; begin Formal := First_Formal (Subp_Id); while Present (Formal) loop - -- Generate the minimum accessibility level object: - - -- Ann : constant natural := natural'min(1, paramL); - - if Present (Extra_Accessibility (Formal)) then - Generate_Minimum_Accessibility - (Extra_Accessibility (Formal), Formal); + if Present (Extra_Accessibility_Of_Object (Formal)) then + Compute_Extra_Accessibility + (Subp_Id, Extra_Accessibility_Of_Object (Formal)); end if; Next_Formal (Formal); end loop; - -- Generate the minimum accessibility level object for the - -- function's Extra_Accessibility_Of_Result: - - -- Ann : constant natural := natural'min (1, funcL); - if Ekind (Subp_Id) = E_Function and then Present (Extra_Accessibility_Of_Result (Subp_Id)) then - Generate_Minimum_Accessibility - (Extra_Accessibility_Of_Result (Subp_Id)); + Compute_Extra_Accessibility + (Subp_Id, Extra_Accessibility_Of_Result (Subp_Id)); + end if; + + -- For nested subprograms present in the source code, also take + -- into account the extra accessibility of the parent; generated + -- subprograms are not supposed to perform accessibility checks. - -- Replace the Extra_Accessibility_Of_Result with the new - -- minimum accessibility object. + if Comes_From_Source (Subp_Id) + and then Present (Par_Id) + and then Present (Extra_Accessibility_Of_Subprogram (Par_Id)) + then + Compute_Extra_Accessibility + (Subp_Id, Extra_Accessibility_Of_Subprogram (Par_Id)); + end if; - Set_Extra_Accessibility_Of_Result - (Subp_Id, Minimum_Accessibility - (Extra_Accessibility_Of_Result (Subp_Id))); + if Present (Acc_Decl) then + Prepend_To (Declarations (N), Acc_Decl); + Analyze (Acc_Decl); end if; end; end if; @@ -4645,11 +4617,6 @@ package body Sem_Ch6 is Inspect_Deferred_Constant_Completion (Declarations (N)); Analyze (Handled_Statement_Sequence (N)); - -- Prepend the declaration of minimum accessibility objects to the list - -- of declarations after analysis of the statements and contracts. - - Prepend_List (Acc_Objs, Declarations (N)); - -- Deal with end of scope processing for the body Process_End_Label @@ -4685,23 +4652,6 @@ package body Sem_Ch6 is end if; end if; - -- Restore the Extra_Accessibility_Of_Result object that was clobbered - -- earlier, so that the name of the local temporary does not leak. - - if Has_Declarations (N) then - declare - Subp_Id : constant Entity_Id := Subprogram_Entity; - - begin - if Ekind (Subp_Id) = E_Function - and then Present (Extra_Accessibility_Of_Result (Subp_Id)) - then - Set_Extra_Accessibility_Of_Result (Subp_Id, - Related_Expression (Extra_Accessibility_Of_Result (Subp_Id))); - end if; - end; - end if; - -- If we are compiling an entry wrapper, remove the enclosing -- synchronized object from the stack. @@ -8902,14 +8852,14 @@ package body Sem_Ch6 is -- On access-to-subprogram types it is used to determine if the target -- function might return an object with tasks. - function Needs_Accessibility_Check_Extra + function Needs_Extra_Accessibility (E : Entity_Id; Formal : Node_Id) return Boolean; -- Determines whether the given formal of E needs an extra formal for -- supporting accessibility checking. Returns True for both anonymous -- access formals and formals of named access types that are marked as -- controlling formals. The latter case can occur when the subprogram - -- Expand_Dispatching_Call creates a subprogram-type and substitutes + -- Expand_Dispatching_Call creates a subprogram type and substitutes -- the types of access-to-class-wide actuals for the anonymous access- -- to-specific-type of controlling formals. @@ -9025,13 +8975,43 @@ package body Sem_Ch6 is (Collect_Ancestors_With_No_Task_Parts (Original)); end Might_Need_BIP_Task_Actuals; - ------------------------------------- - -- Needs_Accessibility_Check_Extra -- - ------------------------------------- + ------------------------------- + -- Needs_Extra_Accessibility -- + ------------------------------- - function Needs_Accessibility_Check_Extra + function Needs_Extra_Accessibility (E : Entity_Id; - Formal : Node_Id) return Boolean is + Formal : Node_Id) return Boolean + is + Btyp : constant Entity_Id := Base_Type (Etype (Formal)); + -- Base_Type is applied to handle cases where there is a null + -- exclusion and the formal may have an access subtype. + + function Profile_Needs_Extra (Typ : Entity_Id) return Boolean; + -- Return True if the profile of Typ, a subprogram type, needs at + -- least one extra formal for supporting accessibility checking. + + ------------------------- + -- Profile_Needs_Extra -- + ------------------------- + + function Profile_Needs_Extra (Typ : Entity_Id) return Boolean is + Formal : Entity_Id; + + begin + Formal := First_Formal (Typ); + while Present (Formal) loop + if Needs_Extra_Accessibility (E, Formal) then + return True; + end if; + + Next_Formal (Formal); + end loop; + + return False; + end Profile_Needs_Extra; + + -- Start of processing for Needs_Extra_Accessibility begin -- For dispatching operations this extra formal is not suppressed @@ -9053,15 +9033,13 @@ package body Sem_Ch6 is return False; end if; - -- Base_Type is applied to handle cases where there is a null - -- exclusion the formal may have an access subtype. - return - Ekind (Base_Type (Etype (Formal))) = E_Anonymous_Access_Type - or else - (Is_Controlling_Formal (Formal) - and then Is_Access_Type (Base_Type (Etype (Formal)))); - end Needs_Accessibility_Check_Extra; + Ekind (Btyp) = E_Anonymous_Access_Type + or else (Ekind (Btyp) = E_Anonymous_Access_Subprogram_Type + and then Profile_Needs_Extra (Designated_Type (Btyp))) + or else (Is_Access_Type (Btyp) + and then Is_Controlling_Formal (Formal)); + end Needs_Extra_Accessibility; ----------------------- -- Parent_Subprogram -- @@ -9554,7 +9532,7 @@ package body Sem_Ch6 is -- Extra formal for supporting accessibility checking - if Needs_Accessibility_Check_Extra (Ref_E, Formal) then + if Needs_Extra_Accessibility (Ref_E, Formal) then pragma Assert (No (Parent_Formal) or else Present (Extra_Accessibility (Parent_Formal))); pragma Assert (No (Alias_Formal) diff --git a/gcc/ada/sem_ch9.adb b/gcc/ada/sem_ch9.adb index aa4c813115de..ce8fe01f463a 100644 --- a/gcc/ada/sem_ch9.adb +++ b/gcc/ada/sem_ch9.adb @@ -2388,8 +2388,6 @@ package body Sem_Ch9 is It : Interp; Enclosing : Entity_Id; Target_Obj : Node_Id := Empty; - Req_Scope : Entity_Id; - Outer_Ent : Entity_Id; Synch_Type : Entity_Id := Empty; -- Start of processing for Analyze_Requeue @@ -2456,38 +2454,18 @@ package body Sem_Ch9 is end; end if; - -- If an explicit target object is given then we have to check the - -- restrictions of 9.5.4(6). + -- If an explicit target object is specified then we have to check the + -- restrictions of 9.5.4(6), unless it is a parameter of the innermost + -- enclosing accept statement or entry body. - if Present (Target_Obj) then - - -- Locate containing concurrent unit and determine enclosing entry - -- body or outermost enclosing accept statement within the unit. - - Outer_Ent := Empty; - for S in reverse 0 .. Scope_Stack.Last loop - Req_Scope := Scope_Stack.Table (S).Entity; - - exit when Is_Concurrent_Type (Req_Scope); - - if Is_Entry (Req_Scope) then - Outer_Ent := Req_Scope; - end if; - end loop; - - pragma Assert (Present (Outer_Ent)); - - -- Check that the accessibility level of the target object is not - -- greater or equal to the outermost enclosing accept statement (or - -- entry body) unless it is a parameter of the innermost enclosing - -- accept statement (or entry body). - - if Static_Accessibility_Level (Target_Obj, Zero_On_Dynamic_Level) - >= Scope_Depth (Outer_Ent) - and then - (not Is_Entity_Name (Target_Obj) - or else not Is_Formal (Entity (Target_Obj)) - or else Enclosing /= Scope (Entity (Target_Obj))) + if Present (Target_Obj) + and then + (not Is_Entity_Name (Target_Obj) + or else not Is_Formal (Entity (Target_Obj)) + or else Enclosing /= Scope (Entity (Target_Obj))) + then + if Static_Accessibility_Level (Target_Obj) + > Static_Local_Access_Level (Enclosing) then Error_Msg_N ("target object has invalid level for requeue", Target_Obj); diff --git a/gcc/ada/sem_res.adb b/gcc/ada/sem_res.adb index 61bc36e677c3..1aea3db3ba29 100644 --- a/gcc/ada/sem_res.adb +++ b/gcc/ada/sem_res.adb @@ -3774,8 +3774,8 @@ package body Sem_Res is elsif Ekind (Etype (Nam)) = E_Anonymous_Access_Type and then Nkind (Parent (N)) = N_Type_Conversion and then - Type_Access_Level (Etype (Parent (N))) - < Static_Accessibility_Level (A, Zero_On_Dynamic_Level) + Static_Type_Access_Level (Etype (Parent (N))) + < Static_Accessibility_Level (A) then Accessibility_Error ("conversion"); @@ -3783,25 +3783,25 @@ package body Sem_Res is and then Nkind (Parent (N)) = N_Assignment_Statement and then Static_Accessibility_Level - (Name (Parent (N)), Object_Decl_Level) - < Static_Accessibility_Level (A, Zero_On_Dynamic_Level) + (Name (Parent (N)), Object_Decl_Level => True) + < Static_Accessibility_Level (A) then Accessibility_Error ("assignment"); elsif Nkind (Parent (N)) = N_Qualified_Expression and then Nkind (Parent (Parent (N))) = N_Allocator and then - Type_Access_Level (Etype (Parent (Parent (N)))) - < Static_Accessibility_Level (A, Zero_On_Dynamic_Level) + Static_Type_Access_Level (Etype (Parent (Parent (N)))) + < Static_Accessibility_Level (A) then Accessibility_Error ("allocator"); elsif In_Return_Value (N) and then Comes_From_Source (N) and then - Subprogram_Access_Level (Current_Subprogram) + Static_Subprogram_Access_Level (Current_Subprogram) < Static_Accessibility_Level - (A, Zero_On_Dynamic_Level, In_Return_Context => True) + (A, In_Return_Context => True) then Accessibility_Error ("return"); end if; @@ -5410,8 +5410,8 @@ package body Sem_Res is return; end if; - if Static_Accessibility_Level (Disc_Exp, Zero_On_Dynamic_Level) - > Deepest_Type_Access_Level (Alloc_Typ) + if Static_Accessibility_Level (Disc_Exp) + > Static_Type_Access_Level (Alloc_Typ, Deepest => True) then Accessibility_Error (Disc_Exp); end if; @@ -5653,8 +5653,9 @@ package body Sem_Res is elsif Has_Anonymous_Access_Discriminant (Subtyp) and then Is_Entity_Name (Exp) and then Is_Formal (Entity (Exp)) - and then Static_Accessibility_Level (Exp, Zero_On_Dynamic_Level) - > Deepest_Type_Access_Level (Typ) + and then + Static_Accessibility_Level (Exp) + > Static_Type_Access_Level (Typ, Deepest => True) then Accessibility_Error (Exp); end if; @@ -5733,8 +5734,8 @@ package body Sem_Res is Exp_Typ := Entity (E); end if; - if Type_Access_Level (Exp_Typ) > - Deepest_Type_Access_Level (Typ) + if Static_Type_Access_Level (Exp_Typ) + > Static_Type_Access_Level (Typ, Deepest => True) then if In_Instance_Body then Error_Msg_Warn := SPARK_Mode /= On; @@ -8322,11 +8323,14 @@ package body Sem_Res is end if; end loop; + -- Mark it now since it is going to be rewritten below + + Set_Analyzed (E_Name); + New_N := Make_Selected_Component (Loc, - Prefix => New_Occurrence_Of (S, Loc), - Selector_Name => - New_Occurrence_Of (Entity (E_Name), Loc)); + Prefix => New_Occurrence_Of (S, Loc), + Selector_Name => New_Occurrence_Of (Entity (E_Name), Loc)); Rewrite (E_Name, New_N); Analyze (E_Name); @@ -13860,8 +13864,8 @@ package body Sem_Res is and then Subtypes_Statically_Match (Target_Comp_Type, Opnd_Comp_Type) then - if Type_Access_Level (Target_Type) < - Deepest_Type_Access_Level (Opnd_Type) + if Static_Type_Access_Level (Opnd_Type) + > Static_Type_Access_Level (Target_Type, Deepest => True) then if In_Instance_Body then Error_Msg_Warn := SPARK_Mode /= On; @@ -14122,8 +14126,9 @@ package body Sem_Res is -- not deeper than the target type. if No_Dynamic_Accessibility_Checks_Enabled (N) then - if Type_Access_Level (Opnd_Type) - > Deepest_Type_Access_Level (Target_Type) + if Static_Type_Access_Level (Opnd_Type) + > Static_Type_Access_Level + (Target_Type, Deepest => True) then Report_Error_N ("operand has deeper level than target", Operand, @@ -14172,8 +14177,9 @@ package body Sem_Res is -- statically less deep than that of the target type, else -- implicit conversion is disallowed (by RM12-8.6(27.1/3)). - elsif Type_Access_Level (Opnd_Type) > - Deepest_Type_Access_Level (Target_Type) + elsif Static_Type_Access_Level (Opnd_Type) + > Static_Type_Access_Level + (Target_Type, Deepest => True) then Report_Error_N ("implicit conversion of anonymous access value " @@ -14197,8 +14203,8 @@ package body Sem_Res is -- master of the call to the enclosing function (RM 3.10.2(10.3), -- 3.10.2(14) and 3.10.2(10.5)). - elsif Type_Access_Level (Opnd_Type, Assoc_Ent => Operand) - > Deepest_Type_Access_Level (Target_Type) + elsif Static_Type_Access_Level (Opnd_Type, Assoc_Node => Operand) + > Static_Type_Access_Level (Target_Type, Deepest => True) and then (Nkind (Associated_Node_For_Itype (Opnd_Type)) /= N_Function_Specification or else Ekind (Target_Type) in Anonymous_Access_Kind @@ -14249,9 +14255,9 @@ package body Sem_Res is -- checking the prefix of the operand for this case). if Nkind (Operand) = N_Selected_Component - and then Static_Accessibility_Level - (Operand, Zero_On_Dynamic_Level) - > Deepest_Type_Access_Level (Target_Type) + and then + Static_Accessibility_Level (Operand) + > Static_Type_Access_Level (Target_Type, Deepest => True) then -- In an instance, this is a run-time check, but one we know -- will fail, so generate an appropriate warning. @@ -14432,8 +14438,8 @@ package body Sem_Res is -- Check the static accessibility rule of 4.6(20) - if Type_Access_Level (Opnd_Type) > - Deepest_Type_Access_Level (Target_Type) + if Static_Type_Access_Level (Opnd_Type) + > Static_Type_Access_Level (Target_Type, Deepest => True) then Report_Error_N ("operand type has deeper accessibility level than target", diff --git a/gcc/ada/sem_res.ads b/gcc/ada/sem_res.ads index 1985d86eca37..54902ac9fce0 100644 --- a/gcc/ada/sem_res.ads +++ b/gcc/ada/sem_res.ads @@ -130,8 +130,7 @@ package Sem_Res is procedure Resolve_Entry (Entry_Name : Node_Id); -- Find name of entry being called, and resolve prefix of name with its - -- own type. For now we assume that the prefix cannot be overloaded and - -- the name of the entry plays no role in the resolution. + -- own type. procedure Resolve_Implicit_Dereference (P : Node_Id); -- Called when P is the prefix of an indexed component, or of a selected diff --git a/gcc/ada/sem_util.adb b/gcc/ada/sem_util.adb index d8bf6f0608f7..b196a6cee7dc 100644 --- a/gcc/ada/sem_util.adb +++ b/gcc/ada/sem_util.adb @@ -5076,7 +5076,7 @@ package body Sem_Util is and then Is_Public_Operation and then Scope_Depth (Pref_Encl_Typ) >= Static_Accessibility_Level - (Context, Object_Decl_Level) + (Context, Object_Decl_Level => True) then Error_Msg_N ("??possible unprotected access to protected data", Expr); From d1bfa577693f373de7080dd0c585fd9ce1e21cf1 Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Tue, 22 Sep 2026 19:37:12 +0200 Subject: [PATCH 337/584] Ada: Make the expansion of conditional expressions more uniform This changes the expansion to use a single criterion in order to determine whether a temporary should be created when processing an N_Case_Expression or an N_If_Expression or an N_Expression_With_Actions node. This will get rid of large temporaries created for the last two nodes and also avoids an indirection with small arrays for the first node. The layout machinery is enhanced to compute the size(s) of array types in more cases, which requires an adjustment to the handling of Component_Size clauses on array types. gcc/ada/ * exp_ch4.adb (Is_Copy_Type): New global predicate. (Expand_N_Case_Expression.Is_Copy_Type): Delete. (Expand_N_Expression_With_Actions.Is_Copy_Type): Likewise. (Expand_N_If_Expression.Is_Copy_Type): Likewise. * layout.adb (Layout_Type): Compute the size(s) of a 1-dimensional array type in more cases. * sem_attr.adb (Analyze_Access_Attribute): Add guard. * sem_ch13.adb (Analyze_Attribute_Definition_Clause) : Reset the size(s) if the clause is not confirming. * sem_eval.adb (Compile_Time_Known_Bounds): Bail out if an error has been posted on the range node. * sem_res.adb (Valid_Conversion): Return early on N_Raise_xxx_Error. --- gcc/ada/exp_ch4.adb | 104 +++++++++++++++++-------------------------- gcc/ada/layout.adb | 42 ++++++++--------- gcc/ada/sem_attr.adb | 25 ++++++----- gcc/ada/sem_ch13.adb | 19 ++++++++ gcc/ada/sem_eval.adb | 6 +++ gcc/ada/sem_res.adb | 6 +++ 6 files changed, 109 insertions(+), 93 deletions(-) diff --git a/gcc/ada/exp_ch4.adb b/gcc/ada/exp_ch4.adb index 57424bbe8117..6d81fcefd266 100644 --- a/gcc/ada/exp_ch4.adb +++ b/gcc/ada/exp_ch4.adb @@ -197,6 +197,10 @@ package body Exp_Ch4 is -- associated storage pool is derived from Checked_Pool, generate a -- call to the 'Dereference' primitive operation. + function Is_Copy_Type (Typ : Entity_Id) return Boolean; + -- Return True if we can copy objects of this type when expanding an EWA + -- or a conditional expression. + function Make_Array_Comparison_Op (Typ : Entity_Id; Nod : Node_Id) return Node_Id; @@ -5141,21 +5145,6 @@ package body Exp_Ch4 is Scop : constant Entity_Id := Current_Scope; Typ : constant Entity_Id := Etype (N); - function Is_Copy_Type (Typ : Entity_Id) return Boolean; - -- Return True if we can copy objects of this type when expanding a case - -- expression. - - ------------------ - -- Is_Copy_Type -- - ------------------ - - function Is_Copy_Type (Typ : Entity_Id) return Boolean is - begin - return Is_Elementary_Type (Underlying_Type (Typ)); - end Is_Copy_Type; - - -- Local variables - Acts : List_Id; Alt : Node_Id; Case_Stmt : Node_Id; @@ -5597,37 +5586,6 @@ package body Exp_Ch4 is Loc : constant Source_Ptr := Sloc (N); Typ : constant Entity_Id := Etype (N); - function Is_Copy_Type (Typ : Entity_Id) return Boolean; - -- Return True if we can copy objects of this type when expanding the - -- node. The function must return False for limited types for semantic - -- reasons, and more generally should do so for all by-reference types. - -- Of course the run-time performance of the copy operation should also - -- be taken into account, but the expansion of conditional expressions - -- may choose to create EWA nodes instead of conditional statements to - -- deal with the actions, in which case these EWA nodes also need to be - -- preserved for semantic reasons. In practice, this means that the - -- subset of types accepted by this Is_Copy_Type predicate must contain - -- the union of the subsets of types accepted by its homonyms in the - -- Expand_N_Case_Expression and Expand_N_If_Expression procedures, in - -- other words must return True when at least one of them returns true. - -- This implementation is that of Expand_N_If_Expression.Is_Copy_Type, - -- which already accepts a superset of the types accepted by its twin - -- Expand_N_Case_Expression.Is_Copy_Type predicate. - - ------------------ - -- Is_Copy_Type -- - ------------------ - - function Is_Copy_Type (Typ : Entity_Id) return Boolean is - Utyp : constant Entity_Id := Underlying_Type (Typ); - - begin - return Is_Definite_Subtype (Utyp) - and then not Is_By_Reference_Type (Utyp); - end Is_Copy_Type; - - -- Local variables - Temp_Decl : Node_Id; Temp_Id : Entity_Id; Temp_Ref : Node_Id; @@ -5763,27 +5721,11 @@ package body Exp_Ch4 is -- accessibility level temp associated with the saooaaat also needs -- to be updated as part of the assignment). - function Is_Copy_Type (Typ : Entity_Id) return Boolean; - -- Return True if we can copy objects of this type when expanding an if - -- expression. - function OK_For_Single_Subtype (T1, T2 : Entity_Id) return Boolean; -- Return true if it is acceptable to use a single subtype for two -- dependent expressions of subtype T1 and T2 respectively, which are -- unidimensional arrays whose index bounds are known at compile time. - ------------------ - -- Is_Copy_Type -- - ------------------ - - function Is_Copy_Type (Typ : Entity_Id) return Boolean is - Utyp : constant Entity_Id := Underlying_Type (Typ); - - begin - return Is_Definite_Subtype (Utyp) - and then not Is_By_Reference_Type (Utyp); - end Is_Copy_Type; - --------------------------- -- OK_For_Single_Subtype -- --------------------------- @@ -13841,6 +13783,44 @@ package body Exp_Ch4 is N_Op_Minus | N_Op_Multiply | N_Op_Subtract; end Integer_Promotion_Possible; + ------------------ + -- Is_Copy_Type -- + ------------------ + + function Is_Copy_Type (Typ : Entity_Id) return Boolean is + begin + -- Objects of a by-copy type can always be copied + + if Is_By_Copy_Type (Typ) then + return True; + + -- Objects of a by-reference type can never be (easily) copied + + elsif Is_By_Reference_Type (Typ) then + return False; + + -- For other objects, we consider that we can copy them if they + -- are small enough, the main case being small arrays of scalars. + + else + declare + Utyp : constant Entity_Id := Underlying_Type (Typ); + + begin + -- If the Object_Size is not set in the source code, then it + -- cannot be much larger than the Value_Size in the end. + + if Known_Esize (Utyp) then + return Esize (Utyp) <= System_Max_Integer_Size; + elsif Known_RM_Size (Utyp) then + return RM_Size (Utyp) <= System_Max_Integer_Size; + else + return False; + end if; + end; + end if; + end Is_Copy_Type; + ------------------------------ -- Make_Array_Comparison_Op -- ------------------------------ diff --git a/gcc/ada/layout.adb b/gcc/ada/layout.adb index db5d69507fcd..51e68fbc7d64 100644 --- a/gcc/ada/layout.adb +++ b/gcc/ada/layout.adb @@ -497,28 +497,24 @@ package body Layout is Set_Alignment (E, Alignment (Component_Type (E))); end if; - -- If packing was requested, the one-dimensional array is constrained - -- with static bounds, the component size was set explicitly, and - -- the alignment is known, we can set (if not set explicitly) the - -- RM_Size and the Esize of the array type, as RM_Size is equal to - -- (arr'length * arr'component_size) and Esize is the same value - -- rounded to the next multiple of arr'alignment. This is not - -- applicable to packed arrays that are implemented specially - -- in GNAT, i.e. when Packed_Array_Impl_Type is set. + -- For a constrained 1-dimensional array type with known bounds and + -- known component size, we can set (if not already set) the RM_Size + -- and, if the alignment is additionally known, also the Esize of the + -- type, as RM_Size is equal to (Arr'Length * Arr'Component_Size) and + -- Esize is the same value rounded up to a multiple of Arr'Alignment. + -- But this is not applicable to packed arrays that are implemented + -- specially by GNAT, i.e. when Packed_Array_Impl_Type is set. if Is_Array_Type (E) - and then Present (First_Index (E)) -- Skip types in error - and then Number_Dimensions (E) = 1 - and then No (Packed_Array_Impl_Type (E)) - and then Has_Pragma_Pack (E) and then Is_Constrained (E) + and then Number_Dimensions (E) = 1 and then Compile_Time_Known_Bounds (E) and then Known_Component_Size (E) - and then Known_Alignment (E) + and then No (Packed_Array_Impl_Type (E)) then declare - Abits : constant Int := UI_To_Int (Alignment (E)) * SSU; - Lo, Hi : Node_Id; + Hi : Node_Id; + Lo : Node_Id; Siz : Uint; begin @@ -531,8 +527,9 @@ package body Layout is if Compile_Time_Known_Value (Lo) and then Compile_Time_Known_Value (Hi) then - Siz := (Expr_Value (Hi) - Expr_Value (Lo) + 1) - * Component_Size (E); + Siz := + UI_Max (Expr_Value (Hi) - Expr_Value (Lo) + 1, 0) + * Component_Size (E); -- Do not overwrite a different value of 'Size specified -- explicitly by the user. In that case, also do not set @@ -541,9 +538,14 @@ package body Layout is if not Known_RM_Size (E) or else RM_Size (E) = Siz then Set_RM_Size (E, Siz); - if not Known_Esize (E) then - Siz := ((Siz + (Abits - 1)) / Abits) * Abits; - Set_Esize (E, Siz); + if not Known_Esize (E) and then Known_Alignment (E) then + declare + Abits : constant Int := + UI_To_Int (Alignment (E)) * SSU; + begin + Siz := ((Siz + (Abits - 1)) / Abits) * Abits; + Set_Esize (E, Siz); + end; end if; end if; end if; diff --git a/gcc/ada/sem_attr.adb b/gcc/ada/sem_attr.adb index 4d145c44e14e..d711b45f13cc 100644 --- a/gcc/ada/sem_attr.adb +++ b/gcc/ada/sem_attr.adb @@ -914,20 +914,23 @@ package body Sem_Attr is ("prefix of % attribute cannot be enumeration literal"); end if; - -- Preserve relevant elaboration-related attributes of the context - -- which are no longer available or very expensive to recompute once - -- analysis, resolution, and expansion are over. + if Nkind (N) not in N_Raise_xxx_Error then - Mark_Elaboration_Attributes - (N_Id => N, - Checks => True, - Modes => True, - Warnings => True); + -- Preserve relevant elaboration-related attributes of the context + -- which are no longer available or very expensive to recompute + -- once analysis, resolution, and expansion are over. - -- Save the scenario for later examination by the ABE Processing - -- phase. + Mark_Elaboration_Attributes + (N_Id => N, + Checks => True, + Modes => True, + Warnings => True); - Record_Elaboration_Scenario (N); + -- Save the scenario for later examination by the ABE Processing + -- phase. + + Record_Elaboration_Scenario (N); + end if; -- Case of access to subprogram diff --git a/gcc/ada/sem_ch13.adb b/gcc/ada/sem_ch13.adb index 853659b6ab0c..b95368fd3dbf 100644 --- a/gcc/ada/sem_ch13.adb +++ b/gcc/ada/sem_ch13.adb @@ -7350,6 +7350,25 @@ package body Sem_Ch13 is Set_Biased (New_Ctyp, N, "component size clause"); end if; + -- If a different component size has been inherited and + -- no clause size has been given, then reset the size. + + if Known_Component_Size (Btype) + and then Component_Size (Btype) /= Csize + then + if Known_RM_Size (U_Ent) + and then not Has_Size_Clause (U_Ent) + then + Set_RM_Size (U_Ent, No_Uint); + end if; + + if Known_Esize (U_Ent) + and then not Has_Object_Size_Clause (U_Ent) + then + Set_Esize (U_Ent, No_Uint); + end if; + end if; + Set_Component_Size (Btype, Csize); -- Deal with warning on overridden size diff --git a/gcc/ada/sem_eval.adb b/gcc/ada/sem_eval.adb index ffbb444cfe1f..cd46aef8e6fa 100644 --- a/gcc/ada/sem_eval.adb +++ b/gcc/ada/sem_eval.adb @@ -1791,6 +1791,12 @@ package body Sem_Eval is return False; end if; + -- Never look at junk bounds of a broken type + + if Error_Posted (Scalar_Range (Typ)) then + return False; + end if; + -- Otherwise check bounds for compile-time-known if not Compile_Time_Known_Value (Type_Low_Bound (Typ)) then diff --git a/gcc/ada/sem_res.adb b/gcc/ada/sem_res.adb index 1aea3db3ba29..e862a8b7e784 100644 --- a/gcc/ada/sem_res.adb +++ b/gcc/ada/sem_res.adb @@ -13925,6 +13925,12 @@ package body Sem_Res is begin Check_Parameterless_Call (Operand); + -- Prevent spurious errors coming from failed checks + + if Nkind (Operand) in N_Raise_xxx_Error then + return True; + end if; + if Is_Overloaded (Operand) and then Is_Ambiguous_Operand (Operand) then From 5cdc41c0893c374038f28a9f709ff6bac52a8c67 Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Tue, 22 Sep 2026 19:46:03 +0200 Subject: [PATCH 338/584] Ada: Implement 3.10.2(9.1) accessibility rule in Accessibility package This is the rule giving the accessibility level of a conditional expression. It is implemented only in a few contexts and for anonymous access types, and the implementation is scattered over several places. This replaces it with a centralized implementation handling both static and dynamic levels, fixing the anonymous access discriminant case in the process. gcc/ada/ * accessibility.ads (Needs_Accessibility_Level_Temp_Or_Check): Delete. * accessibility.adb: Add clauses for Sem_Eval. (Accessibility_Level): Add support for conditional expressions. (Needs_Accessibility_Level_Temp_Or_Check): Delete. * exp_ch4.adb (Expand_N_If_Expression): Do not force expansion for the sake of accessibility checks. * exp_ch6.adb (Create_Extra_Actuals): Remove specific support of extra accessibility formal for conditional expressions. * sem_eval.ads (Match_Result): New enumeration type moved from... (Choices_Match): New function declaration moved from... (Set_Checking_Potentially_Static_Expression): Alphabetize. * sem_eval.adb (Match_Result): ...here. (Choices_Match): ...here. (Eval_Case_Expression): Replace loop with call to Choices_Match. --- gcc/ada/accessibility.adb | 157 +++++++++++++++++++++++++------- gcc/ada/accessibility.ads | 8 -- gcc/ada/exp_ch4.adb | 92 ++----------------- gcc/ada/exp_ch6.adb | 186 -------------------------------------- gcc/ada/sem_eval.adb | 65 ++++--------- gcc/ada/sem_eval.ads | 21 ++++- 6 files changed, 168 insertions(+), 361 deletions(-) diff --git a/gcc/ada/accessibility.adb b/gcc/ada/accessibility.adb index cf352d640a88..f7104930e72d 100644 --- a/gcc/ada/accessibility.adb +++ b/gcc/ada/accessibility.adb @@ -43,6 +43,7 @@ with Rtsfind; use Rtsfind; with Sem; use Sem; with Sem_Aux; use Sem_Aux; with Sem_Ch8; use Sem_Ch8; +with Sem_Eval; use Sem_Eval; with Sem_Res; use Sem_Res; with Sem_Util; use Sem_Util; with Sinfo.Nodes; use Sinfo.Nodes; @@ -65,18 +66,22 @@ package body Accessibility is -- level to obtain. -- When Level is Dynamic_Level, a defining identifier associated with an - -- access parameter, an access result, or an SAOOAAAT, may be returned, - -- and an N_Integer_Literal node in the other cases. + -- access parameter, an access result, or an SAOOAAAT, may be returned. + -- For a conditional expression, another conditional expression may be + -- returned. An N_Integer_Literal node is returned in the other cases. -- When Level is Object_Decl_Level, an N_Integer_Literal node whose value -- is the level of the declaration of the object is returned in the cases - -- where Dynamic_Level returns a defining identifier; in the other cases, - -- an N_Integer_Literal is returned like for Dynamic_Level. + -- where Dynamic_Level returns a defining identifier. For a conditional + -- expression whose dependent expression is *not* statically selected, an + -- assertion failure is raised. In the other cases, an N_Integer_Literal + -- node is returned like for Dynamic_Level. -- When Level is Library_On_Dynamic_Level, an N_Integer_Literal node whose -- value is the library level is returned in the cases where Dynamic_Level - -- returns a defining identifier; in the other cases, an N_Integer_Literal - -- is returned like for Dynamic_Level. + -- returns a defining identifier. Likewise for a conditional expression + -- whose dependent expression is *not* statically selected. In the other + -- cases, an N_Integer_Literal node is returned like for Dynamic_Level. -- Note that this description does not take into account the dynamic offset -- that may be added by Offset_Static_Level to an N_Integer_Literal node. @@ -674,10 +679,20 @@ package body Accessibility is E := Param_Entity (Expr); -- Use the original node unless it is an unanalyzed identifier, as we - -- don't want to reason on unanalyzed expressions from predicates. - - elsif Nkind (Original_Node (Expr)) /= N_Identifier - or else Analyzed (Original_Node (Expr)) + -- don't want to reason on unanalyzed expressions from predicates, or + -- a folded conditional expression, since its level is ultimately that + -- of the dependent expression evaluated statically in this case. + + elsif not (Nkind (Original_Node (Expr)) = N_Identifier + and then not Analyzed (Original_Node (Expr))) + and then not (Nkind (Original_Node (Expr)) = N_Case_Expression + and then + Is_Static_Expression + (Expression (Original_Node (Expr)))) + and then not (Nkind (Original_Node (Expr)) = N_If_Expression + and then + Is_Static_Expression + (First (Expressions (Original_Node (Expr))))) then E := Original_Node (Expr); @@ -1105,6 +1120,103 @@ package body Accessibility is return Accessibility_Level (Prefix (E)); end if; + -- Conditional expressions: the accessibility level is the level of + -- the evaluated dependent expression (RM 3.10.2(9.1)). + + when N_Case_Expression => + -- If the expression is static, perform a static computation + + if Is_Static_Expression (Expression (E)) then + declare + Alt : Node_Id; + + begin + Alt := First (Alternatives (E)); + while Present (Alt) loop + if Choices_Match (Expression (E), Discrete_Choices (Alt)) + = Match + then + return Accessibility_Level (Expression (Alt)); + end if; + + Next (Alt); + end loop; + + raise Program_Error; + end; + + -- Or else, the expression is dynamic so, if the level is also + -- dynamic, we can perform a dynamic computation. + + elsif Level = Dynamic_Level then + declare + New_Alts : constant List_Id := New_List; + New_Case : constant Node_Id := + Make_Case_Expression (Loc, + Expression => Duplicate_Subexpr (Expression (E)), + Alternatives => New_Alts); + + Alt : Node_Id; + + begin + Alt := First (Alternatives (E)); + while Present (Alt) loop + Append_To (New_Alts, + Make_Case_Expression_Alternative (Sloc (Alt), + Discrete_Choices => Discrete_Choices (Alt), + Expression => + Accessibility_Level (Expression (Alt)).N)); + + Next (Alt); + end loop; + + return (S => False, N => New_Case); + end; + + -- Otherwise, the expression is dynamic but the level is static, + -- so return the library level to null out the check. + + else + pragma Assert (Level = Library_On_Dynamic_Level); + return Library_Level; + end if; + + when N_If_Expression => + declare + Condition : constant Node_Id := First (Expressions (E)); + Then_Expr : constant Node_Id := Next (Condition); + Else_Expr : constant Node_Id := Next (Then_Expr); + + begin + -- If the condition is static, perform a static computation + + if Is_Static_Expression (Condition) then + return + (if Is_True (Expr_Value (Condition)) + then Accessibility_Level (Then_Expr) + else Accessibility_Level (Else_Expr)); + + -- Or else, the condition is dynamic so, if the level is also + -- dynamic, we can perform a dynamic computation. + + elsif Level = Dynamic_Level then + return + (S => False, + N => Make_If_Expression (Loc, + Expressions => New_List ( + Duplicate_Subexpr (Condition), + Accessibility_Level (Then_Expr).N, + Accessibility_Level (Else_Expr).N))); + + -- Otherwise, the condition is dynamic but the level is static, + -- so return the library level to null out the check. + + else + pragma Assert (Level = Library_On_Dynamic_Level); + return Library_Level; + end if; + end; + -- Qualified expressions when N_Qualified_Expression => @@ -2621,31 +2733,6 @@ package body Accessibility is return False; end Has_Unconstrained_Access_Discriminants; - --------------------------------------------- - -- Needs_Accessibility_Level_Temp_Or_Check -- - --------------------------------------------- - - function Needs_Accessibility_Level_Temp_Or_Check - (Conditional_Expr : Node_Id) return Boolean - is - Par : Node_Id; - begin - if Ekind (Etype (Conditional_Expr)) /= E_Anonymous_Access_Type then - return False; - end if; - - Par := Parent (Conditional_Expr); - while Present (Par) - and then Nkind (Par) in N_Case_Expression - | N_If_Expression - | N_Parameter_Association - loop - Par := Parent (Par); - end loop; - - return Nkind (Par) in N_Subprogram_Call | N_Assignment_Statement; - end Needs_Accessibility_Level_Temp_Or_Check; - -------------------------------------- -- Needs_Result_Accessibility_Level -- -------------------------------------- diff --git a/gcc/ada/accessibility.ads b/gcc/ada/accessibility.ads index a162371b4360..67e1deb88698 100644 --- a/gcc/ada/accessibility.ads +++ b/gcc/ada/accessibility.ads @@ -156,14 +156,6 @@ package Accessibility is -- Returns True if the given subtype is unconstrained and has one or more -- access discriminants. - function Needs_Accessibility_Level_Temp_Or_Check - (Conditional_Expr : Node_Id) return Boolean; - -- Determine whether a conditional expression occurs in a context that - -- requires either an associated accessibility-level-valued temp (which - -- is assigned to in each arm of the conditional expression) or an - -- accessibility level check (which is pushed down into each arm of the - -- conditional expression). - function Needs_Result_Accessibility_Level (Func_Id : Entity_Id) return Boolean; -- Ada 2012 (AI05-0234): Return True if the function needs an implicit diff --git a/gcc/ada/exp_ch4.adb b/gcc/ada/exp_ch4.adb index 6d81fcefd266..913853947543 100644 --- a/gcc/ada/exp_ch4.adb +++ b/gcc/ada/exp_ch4.adb @@ -5700,8 +5700,6 @@ package body Exp_Ch4 is -- Expand_N_If_Expression -- ---------------------------- - -- Deal with limited types and condition actions - procedure Expand_N_If_Expression (N : Node_Id) is Cond : constant Node_Id := First (Expressions (N)); Loc : constant Source_Ptr := Sloc (N); @@ -5710,17 +5708,6 @@ package body Exp_Ch4 is Par : constant Node_Id := Parent (N); Typ : constant Entity_Id := Etype (N); - Force_Expand : constant Boolean - := Needs_Accessibility_Level_Temp_Or_Check (N); - -- Determine if we are dealing with a special case of a conditional - -- expression used as an actual for an anonymous access type which - -- forces us to transform the if expression into an expression with - -- actions in order to create a temporary to capture the level of the - -- expression in each branch. Also True if the conditional - -- expression is the RHS of an assignment to a saooaaat (so the - -- accessibility level temp associated with the saooaaat also needs - -- to be updated as part of the assignment). - function OK_For_Single_Subtype (T1, T2 : Entity_Id) return Boolean; -- Return true if it is acceptable to use a single subtype for two -- dependent expressions of subtype T1 and T2 respectively, which are @@ -6428,16 +6415,9 @@ package body Exp_Ch4 is Prefix => New_Occurrence_Of (Target, Loc)); end; - -- For other types, we only need to expand if there are other actions - -- associated with either branch or we need to force expansion to deal - -- with if expressions used as an actual of an anonymous access type. - - elsif Present (Then_Actions (N)) - or else Present (Else_Actions (N)) - or else Force_Expand - then - -- We now wrap the actions into the appropriate expression + -- For other types, we just wrap the actions into an EWA node, if any + elsif Present (Then_Actions (N)) or else Present (Else_Actions (N)) then -- We do not need to call Process_Transients_In_Expression on -- the list of actions in this case, because the expansion of -- Expression_With_Actions will do it. @@ -6462,62 +6442,6 @@ package body Exp_Ch4 is Analyze_And_Resolve (Elsex, Typ); end if; - -- We must force expansion into an expression with actions when - -- an if expression gets used directly as an actual for an - -- anonymous access type. - - if Force_Expand then - declare - Cnn : constant Entity_Id := Make_Temporary (Loc, 'C'); - Acts : List_Id; - begin - Acts := New_List; - - -- Generate: - -- Cnn : Ann; - - Decl := - Make_Object_Declaration (Loc, - Defining_Identifier => Cnn, - Object_Definition => New_Occurrence_Of (Typ, Loc)); - Append_To (Acts, Decl); - - Set_No_Initialization (Decl); - - -- Generate: - -- if Cond then - -- Cnn := ; - -- else - -- Cnn := ; - -- end if; - - If_Stmt := - Make_Implicit_If_Statement (N, - Condition => Relocate_Node (Cond), - Then_Statements => New_List ( - Make_Assignment_Statement (Sloc (Thenx), - Name => New_Occurrence_Of (Cnn, Sloc (Thenx)), - Expression => Relocate_Node (Thenx))), - - Else_Statements => New_List ( - Make_Assignment_Statement (Sloc (Elsex), - Name => New_Occurrence_Of (Cnn, Sloc (Elsex)), - Expression => Relocate_Node (Elsex)))); - Append_To (Acts, If_Stmt); - - -- Generate: - -- do - -- ... - -- in Cnn end; - - Rewrite (N, - Make_Expression_With_Actions (Loc, - Expression => New_Occurrence_Of (Cnn, Loc), - Actions => Acts)); - Analyze_And_Resolve (N, Typ); - end; - end if; - return; -- For the sake of GNATcoverage, generate an intermediate temporary in @@ -6567,11 +6491,11 @@ package body Exp_Ch4 is return; end if; - -- Fall through here for either the limited expansion, or the case of - -- inserting actions for nonlimited types. In both these cases, we must - -- move the SLOC of the parent If statement to the newly created one and - -- change it to the SLOC of the expression which, after expansion, will - -- correspond to what is being evaluated. + -- Fall through here when the if_expression is to be replaced with an + -- if_statement. If the parent itself is an if_statement, we move the + -- SLOC of the parent to the newly created one, and replace it by the + -- SLOC of the expression which, after expansion, will correspond to + -- what is being evaluated. if Present (Par) and then Nkind (Par) = N_If_Statement then Set_Sloc (If_Stmt, Sloc (Par)); @@ -6588,7 +6512,7 @@ package body Exp_Ch4 is Prepend_List (Else_Actions (N), Else_Statements (If_Stmt)); end if; - -- Rewrite the parent statement as an if statement + -- Rewrite the parent statement as an if statement in specific cases if Optimize_Assignment_Stmt or else Optimize_Return_Stmt then Rewrite (Par, If_Stmt); diff --git a/gcc/ada/exp_ch6.adb b/gcc/ada/exp_ch6.adb index 9d0e054b05a3..caf282df99b0 100644 --- a/gcc/ada/exp_ch6.adb +++ b/gcc/ada/exp_ch6.adb @@ -2907,15 +2907,6 @@ package body Exp_Ch6 is -- default parameters and for extra actuals (for Extra_Formals). The -- argument is an N_Parameter_Association node. - procedure Add_Cond_Expression_Extra_Actual (Formal : Entity_Id); - -- Adds extra accessibility actuals in the case of a conditional - -- expression corresponding to Formal. - - -- Note: Conditional expressions used as actuals for anonymous access - -- formals complicate the process of propagating extra accessibility - -- actuals and must be handled in a recursive fashion since they can - -- be embedded within each other. - procedure Add_Dummy_Build_In_Place_Actuals (Function_Id : Entity_Id; Num_Added_Extra_Actuals : Nat := 0); @@ -2928,175 +2919,6 @@ package body Exp_Ch6 is -- expression for the value of the actual, EF is the entity for the -- extra formal. - -------------------------------------- - -- Add_Cond_Expression_Extra_Actual -- - -------------------------------------- - - procedure Add_Cond_Expression_Extra_Actual - (Formal : Entity_Id) - is - Decl : Node_Id; - Lvl : Entity_Id; - - procedure Insert_Level_Assign (Branch : Node_Id); - -- Recursively add assignment of the level temporary on each branch - -- while moving through nested conditional expressions. - - ------------------------- - -- Insert_Level_Assign -- - ------------------------- - - procedure Insert_Level_Assign (Branch : Node_Id) is - - procedure Expand_Branch (Res_Assn : Node_Id); - -- Perform expansion or iterate further within nested - -- conditionals given the object declaration or assignment to - -- result object created during expansion which represents a - -- branch of the conditional expression. - - ------------------- - -- Expand_Branch -- - ------------------- - - procedure Expand_Branch (Res_Assn : Node_Id) is - begin - pragma Assert (Nkind (Res_Assn) in - N_Assignment_Statement | - N_Object_Declaration); - - -- There are more nested conditional expressions so we must go - -- deeper. - - if Nkind (Expression (Res_Assn)) = N_Expression_With_Actions - and then - Nkind (Original_Node (Expression (Res_Assn))) - in N_Case_Expression | N_If_Expression - then - Insert_Level_Assign - (Expression (Res_Assn)); - - -- Add the level assignment - - else - Insert_Before_And_Analyze (Res_Assn, - Make_Assignment_Statement (Loc, - Name => New_Occurrence_Of (Lvl, Loc), - Expression => - Dynamic_Accessibility_Level - (Expression (Res_Assn), Allow_Alt_Model => False))); - end if; - end Expand_Branch; - - Cond : Node_Id; - Alt : Node_Id; - - -- Start of processing for Insert_Level_Assign - - begin - -- Examine further nested conditionals - - pragma Assert (Nkind (Branch) = - N_Expression_With_Actions); - - -- Find the relevant statement in the actions - - Cond := First (Actions (Branch)); - while Present (Cond) loop - exit when Nkind (Cond) in N_Case_Statement | N_If_Statement; - Next (Cond); - end loop; - - -- The conditional expression may have been optimized away, so - -- examine the actions in the branch. - - if No (Cond) then - Expand_Branch (Last (Actions (Branch))); - - -- Iterate through if expression branches - - elsif Nkind (Cond) = N_If_Statement then - Expand_Branch (Last (Then_Statements (Cond))); - Expand_Branch (Last (Else_Statements (Cond))); - - -- Iterate through case alternatives - - elsif Nkind (Cond) = N_Case_Statement then - - Alt := First (Alternatives (Cond)); - while Present (Alt) loop - Expand_Branch (Last (Statements (Alt))); - Next (Alt); - end loop; - end if; - end Insert_Level_Assign; - - -- Start of processing for cond expression case - - begin - -- Create declaration of a temporary to store the accessibility - -- level of each branch of the conditional expression. - - Lvl := Make_Temporary (Loc, 'L'); - Decl := Make_Object_Declaration (Loc, - Defining_Identifier => Lvl, - Object_Definition => - New_Occurrence_Of (Standard_Natural, Loc)); - - -- Install the declaration and perform necessary expansion if we - -- are dealing with a procedure call. - - if Nkind (Call_Node) = N_Procedure_Call_Statement then - -- Generate: - -- Lvl : Natural; - -- Call ( - -- {do - -- If_Exp_Res : Typ; - -- if Cond then - -- Lvl := 0; -- Access level - -- If_Exp_Res := Exp; - -- ... - -- in If_Exp_Res end;}, - -- Lvl, - -- ... - -- ) - - Insert_Before_And_Analyze (Call_Node, Decl); - - -- Ditto for a function call. Note that we do not wrap the function - -- call into an expression with action to avoid bad interactions with - -- Exp_Ch4.Process_Transient_In_Expression. - - else - -- Generate: - -- Lvl : Natural; -- placed above the function call - -- ... - -- Func_Call ( - -- {do - -- If_Exp_Res : Typ - -- if Cond then - -- Lvl := 0; -- Access level - -- If_Exp_Res := Exp; - -- in If_Exp_Res end;}, - -- Lvl, - -- ... - -- ) - - Insert_Action (Call_Node, Decl); - Analyze (Call_Node); - end if; - - -- Decorate the conditional expression with assignments to our level - -- temporary. - - Insert_Level_Assign (Prev); - - -- Make our level temporary the passed actual - - Add_Extra_Actual - (Expr => New_Occurrence_Of (Lvl, Loc), - EF => Extra_Accessibility (Formal)); - end Add_Cond_Expression_Extra_Actual; - -------------------------------------- -- Add_Dummy_Build_In_Place_Actuals -- -------------------------------------- @@ -3418,14 +3240,6 @@ package body Exp_Ch6 is EF => Extra_Accessibility (Formal)); end; - -- Conditional expressions - - elsif Nkind (Prev) = N_Expression_With_Actions - and then Nkind (Original_Node (Prev)) in - N_If_Expression | N_Case_Expression - then - Add_Cond_Expression_Extra_Actual (Formal); - -- Internal constant generated to remove side effects (normally -- from the expansion of dispatching calls). diff --git a/gcc/ada/sem_eval.adb b/gcc/ada/sem_eval.adb index cd46aef8e6fa..50e9f4540672 100644 --- a/gcc/ada/sem_eval.adb +++ b/gcc/ada/sem_eval.adb @@ -124,11 +124,6 @@ package body Sem_Eval is V : Uint; end record; - type Match_Result is (Match, No_Match, Non_Static); - -- Result returned from functions that test for a matching result. If the - -- operands are not OK_Static then Non_Static will be returned. Otherwise - -- Match/No_Match is returned depending on whether the match succeeds. - type CV_Cache_Array is array (CV_Range) of CV_Entry; CV_Cache : CV_Cache_Array; @@ -179,16 +174,6 @@ package body Sem_Eval is -- a reference to a type, one of whose bounds raises Constraint_Error, then -- it also sets the Raises_Constraint_Error flag on the Choice itself. - function Choices_Match - (Expr : Node_Id; - Choices : List_Id) return Match_Result; - -- This function applies Choice_Matches to each element of Choices. If the - -- result is No_Match, then it continues and checks the next element. If - -- the result is Match or Non_Static, this result is immediately given - -- as the result without checking the rest of the list. Expr can be of - -- discrete, real, or string type and must be a compile-time-known value - -- (it is an error to make the call if these conditions are not met). - procedure Eval_Intrinsic_Call (N : Node_Id; E : Entity_Id); -- Evaluate a call N to an intrinsic subprogram E @@ -2242,8 +2227,7 @@ package body Sem_Eval is -- expressions raise CE, except for the one that will be selected. procedure Eval_Case_Expression (N : Node_Id) is - Alt : Node_Id; - Choice : Node_Id; + Alt : Node_Id; begin Set_Is_Static_Expression (N, False); @@ -2298,44 +2282,35 @@ package body Sem_Eval is if Raises_Constraint_Error (Expression (N)) then Set_Raises_Constraint_Error (N); + return; + end if; -- Otherwise we need to check the alternatives to find the matching -- one. CE's in other than the matching one are not relevant. But we -- do need to check the matching one. Unlike the first loop, we do not -- have to go all the way through, when we find the matching one, quit. - else - Alt := First (Alternatives (N)); - Search : loop - - -- We must find a match among the alternatives. If not, this must - -- be due to other errors, so just ignore, leaving as non-static. - - if No (Alt) then - Set_Is_Static_Expression (N, False); - return; - end if; - - -- Otherwise loop through choices of this alternative - - Choice := First (Discrete_Choices (Alt)); - while Present (Choice) loop + Alt := First (Alternatives (N)); + loop + -- We must find a match among the alternatives. If not, this must + -- be due to other errors, so just ignore, leaving as non-static. - -- If we find a matching choice, then the Expression of this - -- alternative replaces N (Raises_Constraint_Error flag is - -- included, so we don't have to special case that). + if No (Alt) then + Set_Is_Static_Expression (N, False); + return; + end if; - if Choice_Matches (Expression (N), Choice) = Match then - Rewrite (N, Relocate_Node (Expression (Alt))); - return; - end if; + -- If we find a matching choice, then the Expression of this + -- alternative replaces N (Raises_Constraint_Error flag is + -- included, so we don't have to special case that). - Next (Choice); - end loop; + if Choices_Match (Expression (N), Discrete_Choices (Alt)) = Match then + Rewrite (N, Relocate_Node (Expression (Alt))); + return; + end if; - Next (Alt); - end loop Search; - end if; + Next (Alt); + end loop; end Eval_Case_Expression; ------------------------ diff --git a/gcc/ada/sem_eval.ads b/gcc/ada/sem_eval.ads index 005c577f3273..9803245a036a 100644 --- a/gcc/ada/sem_eval.ads +++ b/gcc/ada/sem_eval.ads @@ -168,9 +168,20 @@ package Sem_Eval is -- Returns True if the checking for potentially static expressions is -- enabled; otherwise returns False. - procedure Set_Checking_Potentially_Static_Expression (Value : Boolean); - -- Enables checking for potentially static expressions if Value is True, - -- and disables such checking if Value is False. + type Match_Result is (Match, No_Match, Non_Static); + -- Result returned from functions that test for a matching result. If the + -- operands are not OK_Static then Non_Static will be returned. Otherwise + -- Match/No_Match is returned depending on whether the match succeeds. + + function Choices_Match + (Expr : Node_Id; + Choices : List_Id) return Match_Result; + -- This function applies Choice_Matches to each element of Choices. If the + -- result is No_Match, then it continues and checks the next element. If + -- the result is Match or Non_Static, this result is immediately given + -- as the result without checking the rest of the list. Expr can be of + -- discrete, real, or string type and must be a compile-time-known value + -- (it is an error to make the call if these conditions are not met). type Compare_Result is (LT, LE, EQ, GT, GE, NE, Unknown); subtype Compare_GE is Compare_Result range EQ .. GE; @@ -479,6 +490,10 @@ package Sem_Eval is -- match. Separated out from Subtypes_Statically_Match so that it can -- be used in specializing error messages. + procedure Set_Checking_Potentially_Static_Expression (Value : Boolean); + -- Enables checking for potentially static expressions if Value is True, + -- and disables such checking if Value is False. + function Subtypes_Statically_Compatible (T1 : Entity_Id; T2 : Entity_Id; From 5e9df85dd9807b034532dbacab9ef322879d0b3e Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Tue, 22 Sep 2026 19:56:25 +0200 Subject: [PATCH 339/584] Ada: Fix typo in recent change It is harmless because Tagged_Membership expects only an In operator. gcc/ada/ * exp_ch6.adb (Expand_Simple_Function_Return): Fix typo. --- gcc/ada/exp_ch6.adb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/ada/exp_ch6.adb b/gcc/ada/exp_ch6.adb index caf282df99b0..1441aa828388 100644 --- a/gcc/ada/exp_ch6.adb +++ b/gcc/ada/exp_ch6.adb @@ -7408,7 +7408,7 @@ package body Exp_Ch6 is -- [Constraint_Error when not (Exp in R_Type)] In_Test : constant Node_Id := - Make_Not_In + Make_In (Loc, Duplicate_Subexpr (Exp), New_Occurrence_Of (R_Type, Loc)); From af95602c56de439e837cf6291e1ad00781be983a Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Tue, 22 Sep 2026 20:15:20 +0200 Subject: [PATCH 340/584] Ada: Further cleanup in implementation of freezing for expression functions Now that the implementation of freezing for expression functions is mostly in line with its semantic model, quirks of the previous implementation are obsolete and can be eliminated. The cleanup performed in Analyze_Declarations exposed a couple of glitches in the ad-hoc resolution implemented for aspect expressions: the prefixes of components were resolved, but not those of subcomponents, and selector names of expanded names were incorrectly resolved as direct names. gcc/ada/ * sinfo.ads (Selector_Name): Beef up description. * sem_ch3.adb (Contains_Lib_Incomplete_Type): Delete. (Analyze_Declarations): Remove obsolete code. * sem_ch13.adb (Resolve_Aspect_Expressions.Resolve_Name): Resolve only names that are not selector names. --- gcc/ada/sem_ch13.adb | 35 ++++++++-------------- gcc/ada/sem_ch3.adb | 70 ++++---------------------------------------- gcc/ada/sinfo.ads | 7 +++-- 3 files changed, 23 insertions(+), 89 deletions(-) diff --git a/gcc/ada/sem_ch13.adb b/gcc/ada/sem_ch13.adb index b95368fd3dbf..d648da2f55e7 100644 --- a/gcc/ada/sem_ch13.adb +++ b/gcc/ada/sem_ch13.adb @@ -17357,34 +17357,21 @@ package body Sem_Ch13 is Dummy : Traverse_Result; begin - if Nkind (N) = N_Selected_Component then - if Nkind (Prefix (N)) = N_Identifier - and then Chars (Prefix (N)) /= Chars (E) - then - Find_Selected_Component (N); - - -- Reset the Entity if N is overloaded since the entity might - -- not be the correct one; allow later resolution to set it - -- properly. - - if Is_Overloaded (N) then - Set_Entity (N, Empty); - end if; - end if; + -- Resolve identifiers that are not selector names, because the + -- latter are not resolved by visibility. - return Skip; - - -- Resolve identifiers, but not selectors in parameter associations; - -- such selectors are never resolved by visibility. - - elsif Nkind (N) = N_Identifier + if Nkind (N) = N_Identifier and then Chars (N) /= Chars (E) - and then (Nkind (Parent (N)) /= N_Parameter_Association - or else N /= Selector_Name (Parent (N))) + and then not (Nkind (Parent (N)) in N_Expanded_Name + | N_Generic_Association + | N_Parameter_Association + | N_Selected_Component + and then N = Selector_Name (Parent (N))) then Find_Direct_Name (N); - -- Reset the Entity as above for selected_components + -- Reset Entity if N is overloaded, since the entity might not + -- be the correct one, to allow resolution to set it properly. if Is_Overloaded (N) then Set_Entity (N, Empty); @@ -17396,6 +17383,8 @@ package body Sem_Ch13 is Dummy := Resolve_Name (Expression (N)); return Skip; + -- See above for the rationale + elsif Nkind (N) = N_Quantified_Expression then return Skip; end if; diff --git a/gcc/ada/sem_ch3.adb b/gcc/ada/sem_ch3.adb index 4893671b9290..8f44ac7c6df9 100644 --- a/gcc/ada/sem_ch3.adb +++ b/gcc/ada/sem_ch3.adb @@ -2320,12 +2320,6 @@ package body Sem_Ch3 is -- contract expression. Full analysis of the expression is done when -- the contract is processed. - function Contains_Lib_Incomplete_Type (Pkg : Entity_Id) return Boolean; - -- Check if a nested package has entities within it that rely on library - -- level private types where the full view has not been completed for - -- the purposes of checking if it is acceptable to freeze an expression - -- function at the point of declaration. - procedure Handle_Late_Controlled_Primitive (Body_Decl : Node_Id); -- Determine whether Body_Decl denotes the body of a late controlled -- primitive (either Initialize, Adjust or Finalize). If this is the @@ -2529,40 +2523,6 @@ package body Sem_Ch3 is end loop; end Check_Entry_Contracts; - ---------------------------------- - -- Contains_Lib_Incomplete_Type -- - ---------------------------------- - - function Contains_Lib_Incomplete_Type (Pkg : Entity_Id) return Boolean is - Curr : Entity_Id; - - begin - -- Avoid looking through scopes that do not meet the precondition of - -- Pkg not being within a library unit spec. - - if not Is_Compilation_Unit (Pkg) - and then not Is_Generic_Instance (Pkg) - and then not In_Package_Body (Enclosing_Lib_Unit_Entity (Pkg)) - then - -- Loop through all entities in the current scope to identify - -- an entity that depends on a private type. - - Curr := First_Entity (Pkg); - loop - if Nkind (Curr) in N_Entity - and then Depends_On_Private (Curr) - then - return True; - end if; - - exit when Last_Entity (Current_Scope) = Curr; - Next_Entity (Curr); - end loop; - end if; - - return False; - end Contains_Lib_Incomplete_Type; - -------------------------------------- -- Handle_Late_Controlled_Primitive -- -------------------------------------- @@ -2806,10 +2766,6 @@ package body Sem_Ch3 is Check_Entry_Contracts; elsif Nkind (Parent (L)) /= N_Package_Specification then - if Nkind (Parent (L)) = N_Package_Body then - Freeze_From := First_Entity (Current_Scope); - end if; - -- There may have been several freezing points previously, -- for example object declarations or subprogram bodies, but -- at the end of a declarative part we check freezing from @@ -2881,7 +2837,7 @@ package body Sem_Ch3 is Resolve_Aspects; end if; - -- If next node is a body then freeze all types before the body. + -- If next node is a body, then freeze all entities before the body. -- An exception occurs for some expander-generated bodies. If these -- are generated at places where in general language rules would not -- allow a freeze point, then we assume that the expander has @@ -2892,25 +2848,11 @@ package body Sem_Ch3 is -- In all other cases (bodies that come from source, and expander -- generated bodies that have not been analyzed yet), freeze all - -- types now. Note that in the latter case, the expander must take - -- care to attach the bodies at a proper place in the tree so as to - -- not cause unwanted freezing at that point. The exception is the - -- generated body of an expression function, which does not freeze. - - -- It is also necessary to check for a case where both an expression - -- function is used and the current scope depends on an incomplete - -- private type from a library unit, otherwise premature freezing of - -- the private type will occur. - - elsif not Analyzed (Next_Decl) - and then Is_Body (Next_Decl) - and then ((Nkind (Next_Decl) /= N_Subprogram_Body - or else not Was_Expression_Function (Next_Decl)) - or else (not Is_Ignored_Ghost_Entity_In_Codegen - (Current_Scope) - and then not Contains_Lib_Incomplete_Type - (Current_Scope))) - then + -- entities now. Note that in the latter case, the expander must + -- take care to attach the bodies at a proper place in the tree, + -- so as not to cause unwanted freezing at that point. + + elsif Is_Body (Next_Decl) and then not Analyzed (Next_Decl) then -- When a controlled type is frozen, the expander generates stream -- and controlled-type support routines. If the freeze is caused -- by the stand-alone body of Initialize, Adjust, or Finalize, the diff --git a/gcc/ada/sinfo.ads b/gcc/ada/sinfo.ads index a78fd31a1f20..9e8beec6049b 100644 --- a/gcc/ada/sinfo.ads +++ b/gcc/ada/sinfo.ads @@ -2255,8 +2255,11 @@ package Sinfo is -- to the expander. -- Selector_Name - -- Present in N_Expanded_Name N_Selected_Component, - -- N_Generic_Association, and N_Parameter_Association nodes. + -- Present in N_Expanded_Name and N_Selected_Component nodes, where it + -- references a name that denotes an entity declared in the prefix, as + -- well as in N_Generic_Association and N_Parameter_Association nodes, + -- where it references a name that denotes a formal parameter of the + -- generic unit or callable entity. -- Shift_Count_OK -- A flag present in shift nodes to indicate that the shift count is From 52348fd6ebf092ca665f00f4b06bcaba115c72ff Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Tue, 22 Sep 2026 20:19:23 +0200 Subject: [PATCH 341/584] Ada: Small cleanup in freezing machinery The main part is the renaming of Freeze_Expr_Types to Freeze_Full_Expression and Freeze_Expr_Types_Before to Freeze_Full_Expression_Before to reflect the actual intent of the subprograms. gcc/ada/ * freeze.ads (Freeze_Entity): Move around. (Freeze_Before): Rename T parameter to E. (Freeze_Expression): Improve description. (Freeze_Expr_Types_Before): Rename to... (Freeze_Full_Expression_Before): ...this. * freeze.adb (Freeze_Expr_Types): Rename to... (Freeze_Full_Expression): ...this. (Freeze_Before): Rename T parameter to E and Pack variable to Scop. (Freeze_Entity): Adjust to above renaming. (Freeze_Expression): Likewise. (Freeze_Expr_Types_Before): Rename to... (Freeze_Full_Expression_Before): ...this. * contracts.adb (Analyze_Entry_Or_Subprogram_Contract): Adjust to above renaming. (Expand_Subprogram_Contract): Likewise. * sem_ch6.adb (Analyze_Expression_Function): Likewise. --- gcc/ada/contracts.adb | 4 ++-- gcc/ada/freeze.adb | 52 ++++++++++++++++++++---------------------- gcc/ada/freeze.ads | 53 +++++++++++++++++++++++-------------------- gcc/ada/sem_ch6.adb | 2 +- 4 files changed, 55 insertions(+), 56 deletions(-) diff --git a/gcc/ada/contracts.adb b/gcc/ada/contracts.adb index 0c75a24d3955..fb781fd6ac33 100644 --- a/gcc/ada/contracts.adb +++ b/gcc/ada/contracts.adb @@ -755,7 +755,7 @@ package body Contracts is if Freeze_Types and then Present (Corresponding_Aspect (Prag)) then - Freeze_Expr_Types_Before + Freeze_Full_Expression_Before (N => Bod, Expr => Expression @@ -3119,7 +3119,7 @@ package body Contracts is if Freeze_T and then Present (Corresponding_Aspect (Prag)) then - Freeze_Expr_Types_Before + Freeze_Full_Expression_Before (N => Body_Decl, Expr => Expression diff --git a/gcc/ada/freeze.adb b/gcc/ada/freeze.adb index 4c516fe9667f..634010e452f1 100644 --- a/gcc/ada/freeze.adb +++ b/gcc/ada/freeze.adb @@ -149,14 +149,14 @@ package body Freeze is -- that if a foreign convention is specified, and no specific size -- is given, then the size must be at least Integer'Size. - procedure Freeze_Expr_Types + procedure Freeze_Full_Expression (Expr : Node_Id; N : Node_Id; Def_Id : Entity_Id; Result : in out List_Id; Before : Boolean := False; Typ : Entity_Id := Empty); - -- Same as Freeze_Expr_Types_Before if Before is True, but appends the + -- Same as Freeze_Full_Expression_Before if Before is True, but appends the -- resulting list of nodes to Result if Before is False, modifying Result -- from No_List if necessary. @@ -2746,16 +2746,12 @@ package body Freeze is procedure Freeze_Before (N : Node_Id; - T : Entity_Id; + E : Entity_Id; Do_Freeze_Profile : Boolean := True) is - -- Freeze T, then insert the generated Freeze nodes before the node N. - -- Flag Freeze_Profile is used when T is an overloadable entity, and - -- indicates whether its profile should be frozen at the same time. - Freeze_Nodes : constant List_Id := - Freeze_Entity (T, N, Do_Freeze_Profile); - Pack : constant Entity_Id := Scope (T); + Freeze_Entity (E, N, Do_Freeze_Profile); + Scop : constant Entity_Id := Scope (E); begin if Is_Non_Empty_List (Freeze_Nodes) then @@ -2766,12 +2762,12 @@ package body Freeze is -- which may include generated subprograms such as predicate -- functions, etc. - if Is_Type (T) and then From_Nested_Package (T) then - Push_Scope (Pack); - Install_Visible_Declarations (Pack); - Install_Private_Declarations (Pack); + if Is_Type (E) and then From_Nested_Package (E) then + Push_Scope (Scop); + Install_Visible_Declarations (Scop); + Install_Private_Declarations (Scop); Insert_Actions (N, Freeze_Nodes); - End_Package_Scope (Pack); + End_Package_Scope (Scop); else Insert_Actions (N, Freeze_Nodes); @@ -8274,7 +8270,7 @@ package body Freeze is if Is_Expression_Function (Subp) then Freeze_And_Append (Subp, N, Result, Do_Freeze_Profile => False); - Freeze_Expr_Types + Freeze_Full_Expression (Expr => Expression_Of_Expression_Function (Subp), N => N, Def_Id => Subp, @@ -9227,7 +9223,7 @@ package body Freeze is -- Freeze types in expression function (RM 13.14(10.1, 10.2, 10.3)) if Is_Expression_Function (Nam) then - Freeze_Expr_Types_Before + Freeze_Full_Expression_Before (N => P, Expr => Expression_Of_Expression_Function (Nam), Def_Id => Nam); @@ -9239,11 +9235,11 @@ package body Freeze is In_Spec_Expression := In_Spec_Exp; end Freeze_Expression; - ----------------------- - -- Freeze_Expr_Types -- - ----------------------- + ---------------------------- + -- Freeze_Full_Expression -- + ---------------------------- - procedure Freeze_Expr_Types + procedure Freeze_Full_Expression (Expr : Node_Id; N : Node_Id; Def_Id : Entity_Id; @@ -9526,7 +9522,7 @@ package body Freeze is procedure Freeze_References is new Traverse_Proc (Freeze_Type_Refs); - -- Start of processing for Freeze_Expr_Types + -- Start of processing for Freeze_Full_Expression begin -- Preanalyze a duplicate of the expression to have available the @@ -9577,13 +9573,13 @@ package body Freeze is else Freeze_References (Expr); end if; - end Freeze_Expr_Types; + end Freeze_Full_Expression; - ------------------------------ - -- Freeze_Expr_Types_Before -- - ------------------------------ + ----------------------------------- + -- Freeze_Full_Expression_Before -- + ----------------------------------- - procedure Freeze_Expr_Types_Before + procedure Freeze_Full_Expression_Before (N : Node_Id; Expr : Node_Id; Def_Id : Entity_Id; @@ -9592,14 +9588,14 @@ package body Freeze is Dummy : List_Id := No_List; begin - Freeze_Expr_Types + Freeze_Full_Expression (Expr => Expr, N => N, Def_Id => Def_Id, Result => Dummy, Before => True, Typ => Typ); - end Freeze_Expr_Types_Before; + end Freeze_Full_Expression_Before; ----------------------------- -- Freeze_Fixed_Point_Type -- diff --git a/gcc/ada/freeze.ads b/gcc/ada/freeze.ads index 995ff04187b4..7e5d31f92b14 100644 --- a/gcc/ada/freeze.ads +++ b/gcc/ada/freeze.ads @@ -96,7 +96,7 @@ package Freeze is -- Objects with dynamic address clauses -- - -- These have a delayed freeze. Gigi will generate code to evaluate + -- These have delayed freezing. Gigi will generate code to evaluate -- the initialization expression if present and store it in a temp. -- The actual object is created at the point of the freeze, and if -- necessary initialized by copying the value of this temporary. @@ -183,19 +183,6 @@ package Freeze is -- If Initialization_Statements (E) is an N_Compound_Statement, insert its -- actions at the appropriate point and clear the attribute. - function Freeze_Entity - (E : Entity_Id; - N : Node_Id; - Do_Freeze_Profile : Boolean := True) return List_Id; - -- Freeze an entity, and return Freeze nodes, to be inserted at the point - -- of call. N is a node whose source location corresponds to the freeze - -- point. This is used in placing warning messages in the situation where - -- it appears that a type has been frozen too early, e.g. when a primitive - -- operation is declared after the freezing point of its tagged type. - -- Returns No_List if no freeze nodes needed. Parameter Do_Freeze_Profile - -- is used when E is a subprogram, and determines whether the profile of - -- the subprogram should be frozen as well. - procedure Freeze_All (From : Entity_Id; After : in out Node_Id); -- Before a non-instance body, or at the end of a declarative part, -- freeze all entities therein that are not yet frozen. Calls itself @@ -212,28 +199,44 @@ package Freeze is procedure Freeze_Before (N : Node_Id; - T : Entity_Id; + E : Entity_Id; Do_Freeze_Profile : Boolean := True); - -- Freeze T then Insert the generated Freeze nodes before the node N. Flag - -- Do_Freeze_Profile is used when T is an overloadable entity and indicates - -- whether its profile should be frozen at the same time. + -- Freeze entity E and Insert the generated Freeze nodes before the node N. + -- The Flag Do_Freeze_Profile is used when T is an overloadable entity and + -- indicates whether its profile should be frozen at the same time. + + function Freeze_Entity + (E : Entity_Id; + N : Node_Id; + Do_Freeze_Profile : Boolean := True) return List_Id; + -- Freeze entity E, and return Freeze nodes, to be inserted at the point + -- of call. N is a node whose source location corresponds to the freeze + -- point. This is used in placing warning messages in the situation where + -- it appears that a type has been frozen too early, e.g. when a primitive + -- operation is declared after the freezing point of its tagged type. + -- Returns No_List if no freeze nodes needed. Parameter Do_Freeze_Profile + -- is used when E is a subprogram, and determines whether the profile of + -- the subprogram should be frozen as well. procedure Freeze_Expression (N : Node_Id); - -- Freezes the required entities when the Expression N causes freezing. + -- Freezes the required entities when subexpression N causes freezing. -- The node N here is either a subexpression node (a "real" expression) -- or a subtype mark, or a subtype indication. The latter two cases are -- not really expressions, but they can appear within expressions and - -- so need to be similarly treated. Freeze_Expression takes care of - -- determining the proper insertion point for generated freeze actions. + -- so need to be similarly treated. Freeze_Expression must be invoked + -- on every subexpression along the normal processing of an expression, + -- and will take care of determining the proper insertion point of the + -- generated freeze actions. - procedure Freeze_Expr_Types_Before + procedure Freeze_Full_Expression_Before (N : Node_Id; Expr : Node_Id; Def_Id : Entity_Id; Typ : Entity_Id := Empty); - -- This procedure freezes before N all the types referenced in Expr, - -- which is either the expression of the expression function Def_Id, - -- or the expression in a pre/post aspect that applies to Def_Id. + -- Freezes before N all the required entities when expression Expr causes + -- freezing, which is either the expression of the expression function + -- Def_Id, or the expression in a pre/post aspect that applies to Def_Id. + -- Freeze_Full_Expression_Before must be invoked once for an expression. -- If Typ is present, it is the type used to preanalyze and resolve a -- copy of Expr; if it is not, Expr is assumed to be already analyzed. diff --git a/gcc/ada/sem_ch6.adb b/gcc/ada/sem_ch6.adb index c4b09a227886..130cbcc7c976 100644 --- a/gcc/ada/sem_ch6.adb +++ b/gcc/ada/sem_ch6.adb @@ -443,7 +443,7 @@ package body Sem_Ch6 is -- with the function body. Ghost_Context_Checks_Disabled := True; - Freeze_Expr_Types_Before + Freeze_Full_Expression_Before (N => N, Expr => Expr, Def_Id => Def_Id, From 21a88667c67ddf1f3086b7f05dc88601f1c6b070 Mon Sep 17 00:00:00 2001 From: Joshua Berne Date: Thu, 17 Sep 2026 13:40:42 -0400 Subject: [PATCH 342/584] c++/contracts: assertion predicate re-invoking constexpr function [PR125459] The RESULT_DECL of a function during constant evaluation has its value stored in the constexpr_global_ctx, and once its lifetime ends void_list_node is put in its place. If the same function is then called later during the same constant evaluation from within the scope of a modifiable_tracker (i.e., during speculative evaluation of a contract assertion, or evaluation of the predicate of an [[assume]]) the population of the return value will find an entry (void_list_node) already in the context and treat the call as an attempt to modify outside state, resulting in errors. This change updates the put_value member of constexpr_global_ctx to recognize void_list_node values in the map as not being a concern for what modifiable is tracking, and treats them the same way it treats not yet having a value in the map for that key. void_node is not treated the same way because that would indicate an object that has been destroyed but whose storage has not yet been deallocated. PR c++/125459 - [contracts] "contract condition is not constant" in constexpr function PR c++/125459 gcc/cp/ChangeLog: * constexpr.cc (constexpr_global_ctx::put_value): Treat void_list_node as not having been in the map for modifiable tracking. gcc/testsuite/ChangeLog: * g++.dg/contracts/cpp26/pr125459.C: New test. Signed-off-by: Joshua Berne --- gcc/cp/constexpr.cc | 12 ++++++++++-- gcc/testsuite/g++.dg/contracts/cpp26/pr125459.C | 15 +++++++++++++++ 2 files changed, 25 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/g++.dg/contracts/cpp26/pr125459.C diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc index 18d361c24325..e285582e4c02 100644 --- a/gcc/cp/constexpr.cc +++ b/gcc/cp/constexpr.cc @@ -1276,8 +1276,16 @@ class constexpr_global_ctx { } void put_value (tree t, tree v) { - bool already_in_map = values.put (t, v); - if (!already_in_map && modifiable) + /* If modifiable is not null, any key that was not previously in the + map, or that has been destroyed and freed (as indicated by + void_list_node), is tracked in modifiable. If the object is there, + or its storage remains (as indicated by void_node), then we don't + track it as modifiable. */ + bool already_in_map; + tree &slot = values.get_or_insert (t, &already_in_map); + bool newval = !already_in_map || slot == void_list_node; + slot = v; + if (newval && modifiable) modifiable->add (t); } void destroy_value (tree t, bool past_storage_end = true) diff --git a/gcc/testsuite/g++.dg/contracts/cpp26/pr125459.C b/gcc/testsuite/g++.dg/contracts/cpp26/pr125459.C new file mode 100644 index 000000000000..44c159306e8b --- /dev/null +++ b/gcc/testsuite/g++.dg/contracts/cpp26/pr125459.C @@ -0,0 +1,15 @@ +// Check that invoking a function during constant evaluation, then calling the +// same function with different arguments within a contract assertion, works. +// { dg-do compile { target c++26 } } +// { dg-additional-options "-fcontracts -fcontract-evaluation-semantic=enforce" } + +constexpr bool f(int) { return true; } + +constexpr bool g() +{ + f(0); + contract_assert(f(1)); // force another evaluation of f + return true; +} + +static_assert(g()); From 462dde1f675818ecc1037ca58a9167471db7a86c Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Tue, 22 Sep 2026 20:25:07 +0200 Subject: [PATCH 343/584] Ada: Fix pragma Pure ignored by freezing of expression function as completion The problem is that the freezing of the expression function is incomplete and does not cause the freezing of stand-alone objects declared in the same declarative part as the expression function. gcc/ada/ * freeze.adb (Freeze_Full_Expression): Also freeze the stand-alone objects of the current scope when they are referenced. * sem_ch6.adb (Analyze_Expression_Function): Do not check the use of a dynamically tagged expression if an error has been posted. --- gcc/ada/freeze.adb | 107 +++++++++++++++++++++----------------------- gcc/ada/sem_ch6.adb | 1 + 2 files changed, 51 insertions(+), 57 deletions(-) diff --git a/gcc/ada/freeze.adb b/gcc/ada/freeze.adb index 634010e452f1..c5156715d6e2 100644 --- a/gcc/ada/freeze.adb +++ b/gcc/ada/freeze.adb @@ -9254,9 +9254,6 @@ package body Freeze is procedure Explain_Error; -- Output an explanation of the error as continuation messages - procedure Find_Incomplete_Constant (Node : Node_Id); - -- Search for a deferred constant without completion - function Freeze_Type_Refs (Node : Node_Id) return Traverse_Result; -- Freeze all types referenced in the subtree rooted at Node @@ -9344,41 +9341,6 @@ package body Freeze is end if; end Explain_Error; - ------------------------------ - -- Find_Incomplete_Constant -- - ------------------------------ - - procedure Find_Incomplete_Constant (Node : Node_Id) is - begin - -- When a constant is initialized with the result of a dispatching - -- call, the constant declaration is rewritten as a renaming of the - -- displaced function result. This scenario is not a premature use of - -- a constant even though the Has_Completion flag is not set. - - if Is_Entity_Name (Node) - and then Present (Entity (Node)) - and then Ekind (Entity (Node)) = E_Constant - and then Scope (Entity (Node)) = Current_Scope - and then Nkind (Declaration_Node (Entity (Node))) = - N_Object_Declaration - and then not Is_Imported (Entity (Node)) - and then not Has_Completion (Entity (Node)) - and then not - (Present (Full_View (Entity (Node))) - and then (Has_Completion (Full_View (Entity (Node))) - or else - Declaration_Node (Full_View (Entity (Node))) = N)) - then - Error_Msg_NE - ("deferred constant& is frozen before completion", - N, Entity (Node)); - - Explain_Error; - - Set_Is_Frozen (Entity (Node)); - end if; - end Find_Incomplete_Constant; - ---------------------- -- Freeze_Type_Refs -- ---------------------- @@ -9437,22 +9399,59 @@ package body Freeze is -- Check that a type referenced by an entity can be frozen if Is_Entity_Name (Node) and then Present (Entity (Node)) then - -- The entity itself may be a type, as in a membership test - -- or an attribute reference. Freezing its own type would be - -- incomplete if the entity is derived or an extension. + declare + E : constant Entity_Id := Entity (Node); - if Is_Type (Entity (Node)) then - Check_And_Freeze_Type (Entity (Node)); + begin + -- The entity itself may be a type, as in a membership test + -- or an attribute reference. Freezing its own type would be + -- incomplete if the entity is derived or an extension. - else - Check_And_Freeze_Type (Etype (Entity (Node))); - end if; + if Is_Type (E) then + Check_And_Freeze_Type (E); + else + Check_And_Freeze_Type (Etype (E)); + end if; - -- Check that the enclosing record type can be frozen + -- Check that the enclosing record type can be frozen - if Ekind (Entity (Node)) in E_Component | E_Discriminant then - Check_And_Freeze_Type (Scope (Entity (Node))); - end if; + if Ekind (E) in E_Component | E_Discriminant then + Check_And_Freeze_Type (Scope (E)); + end if; + + -- Freeze stand-alone objects declared in the current scope + + if Ekind (E) in E_Constant | E_Variable + and then Nkind (Declaration_Node (E)) = N_Object_Declaration + and then Scope (E) = Current_Scope + and then not Is_Frozen (E) + then + -- The completion of a deferred constant declaration must + -- occur before the constant is frozen (RM 7.4(9)). Give a + -- better error message here than at the completion point. + + if Ekind (E) = E_Constant + and then not Is_Imported (E) + and then not Has_Completion (E) + and then not (Present (Full_View (E)) + and then Has_Completion (Full_View (E))) + then + Error_Msg_NE + ("deferred constant& is frozen before completion", + N, E); + + Explain_Error; + + Set_Is_Frozen (E); + + elsif Before then + Freeze_Before (N, E); + + else + Freeze_And_Append (E, N, Result); + end if; + end if; + end; -- Freezing an access type does not freeze the designated type, but -- freezing conversions between access to interfaces requires that @@ -9509,15 +9508,9 @@ package body Freeze is end; end if; - Find_Incomplete_Constant (Node); - -- No point in posting several errors on the same expression - if Serious_Errors_Detected > 0 then - return Abandon; - else - return OK; - end if; + return (if Serious_Errors_Detected > 0 then Abandon else OK); end Freeze_Type_Refs; procedure Freeze_References is new Traverse_Proc (Freeze_Type_Refs); diff --git a/gcc/ada/sem_ch6.adb b/gcc/ada/sem_ch6.adb index 130cbcc7c976..2ed3b7c3f477 100644 --- a/gcc/ada/sem_ch6.adb +++ b/gcc/ada/sem_ch6.adb @@ -712,6 +712,7 @@ package body Sem_Ch6 is if Present (Def_Id) and then Is_Tagged_Type (Typ) + and then not Error_Posted (N) then Check_Dynamically_Tagged_Expression (Expr => Expr, From 9c91c880bf3158d54be74614a050838b5448042c Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Tue, 22 Sep 2026 21:10:00 +0200 Subject: [PATCH 344/584] Ada: Fix finalization not performed correctly with mutably tagged types Descendants of a mutably tagged type may have controlled components, unless the No_Controlled_Parts aspect is specified alongside the Size'Class aspect, but their finalization is not correctly performed by the implementation. The change also prevents finalization boilerplate code from being generated for class-wide objects of regular tagged types when the No_Controlled_Parts aspect is specified. It also contains a couple of fixes for Might_Have_Tasks and Find_Type_Name. gcc/ada/ * gen_il-gen-gen_entities.adb (Type_Kind): Set Base_Type_Only for Is_Mutably_Tagged_Type flag. Move Class_Wide_Equivalent_Type to... (Class_Wide_Kind): ...here. * einfo.ads (Class_Wide_Equivalent_Type): Adjust description. (Is_Controlled_Active): Likewise. (Is_Controlled): Likewise. (Is_Mutably_Tagged_Type): Likewise. * exp_ch3.adb (Expand_N_Full_Type_Declaration): Use an assignment to initialize an object of a mutably tagged type whose initial value is not the result of a function call. * exp_ch5.adb (Expand_N_Assignment_Statement): Do not dispatch to an _assign primitive for an initialization even in the class-wide case. For mutably tagged types, assign the tag unconditionally. (Make_Tag_Ctrl_Assignment): Deal with mutably tagged types. * exp_ch6.adb (Might_Have_Tasks): Invoke Has_Enabled_Aspect on the root type for a class-wide type. * exp_ch7.adb: Add clauses for Mutably_Tagged package. (Make_Adjust_Call): Deal with mutably tagged types. (Make_Final_Call): Likewise. (Make_Init_Call): Likewise. * exp_util.adb: Add clauses for Mutably_Tagged package. (Finalize_Address): Deal with mutably tagged types. (Make_CW_Equivalent_Type): Adjust comment. * freeze.adb (Freeze_Record_Type): Invoke Needs_Finalization on the type of the components to compute the Has_Controlled_Component flag. * mutably_tagged.ads (Get_Corresponding_Tagged_Type_If_Present): Adjust description. * mutably_tagged.adb (Is_Mutably_Tagged_CW_Equivalent_Type): Test Is_Mutably_Tagged_Type on the class-wide type of the parent subtype. * sem_ch3.adb (Find_Type_Name): Do not set the Is_Internal flag on the completion of an incomplete type. (Record_Type_Definition): Invoke Needs_Finalization on the type of the components to compute the Has_Controlled_Component flag. * sem_ch12.adb (Validate_Private_Type_Instance): Test the Is_Mutably_Tagged_Type flag instead of Class_Wide_Equivalent_Type. (Instantiate_Type): Likewise. * sem_util.adb (Needs_Finalization): Return False for a class-wide type if the root type has the No_Controlled_Parts aspect, and return True for a mutably tagged class-wide equivalent type unless the root type has the No_Controlled_Parts aspect. --- gcc/ada/einfo.ads | 27 ++-- gcc/ada/exp_ch3.adb | 27 +++- gcc/ada/exp_ch5.adb | 186 +++++++++++++++------------- gcc/ada/exp_ch6.adb | 4 +- gcc/ada/exp_ch7.adb | 29 +++-- gcc/ada/exp_util.adb | 10 +- gcc/ada/freeze.adb | 35 +++--- gcc/ada/gen_il-gen-gen_entities.adb | 4 +- gcc/ada/mutably_tagged.adb | 6 +- gcc/ada/mutably_tagged.ads | 7 +- gcc/ada/sem_ch12.adb | 6 +- gcc/ada/sem_ch3.adb | 27 ++-- gcc/ada/sem_util.adb | 16 ++- 13 files changed, 227 insertions(+), 157 deletions(-) diff --git a/gcc/ada/einfo.ads b/gcc/ada/einfo.ads index 73d684890eee..c69aec8baf7f 100644 --- a/gcc/ada/einfo.ads +++ b/gcc/ada/einfo.ads @@ -650,9 +650,9 @@ package Einfo is -- the corresponding implicitly declared class-wide type. For a -- class-wide type, returns itself. Set to Empty for untagged types. --- Class_Wide_Equivalent_Type --- Defined in all type entities. Used to store an internally generated --- class-wide equivalent type for an associated mutably tagged type. +-- Class_Wide_Equivalent_Type [base type only] +-- Defined in class-wide types. Used to store an internally generated +-- class-wide equivalent type for a mutably tagged type. -- Cloned_Subtype -- Defined in E_Record_Subtype and E_Class_Wide_Subtype entities. @@ -2603,17 +2603,16 @@ package Einfo is -- that the constructed subtype itself will be constrained. -- Is_Controlled_Active [base type only] --- Defined in all type entities. Indicates that the type is controlled, --- i.e. has been declared with the Finalizable or the Destructor aspect --- or has inherited the aspect from an ancestor. Can only be set for --- record types, tagged or untagged. --- System.Finalization_Root.Root_Controlled is an example of the former --- case while Ada.Finalization.Controlled and +-- Defined in all types. Set only for record types, tagged or untagged. +-- Indicates that the type is controlled, i.e. has been declared with +-- the Finalizable or the Destructor aspect, or has inherited one of the +-- aspects from an ancestor. System.Finalization_Root.Root_Controlled is +-- an example of the former case, while Ada.Finalization.Controlled and -- Ada.Finalization.Limited_Controlled are examples of the latter. -- Is_Controlled (synth) [base type only] --- Defined in all type entities. Set if Is_Controlled_Active is set for --- the type, and Disable_Controlled is not set. +-- Defined in all type entities. Set if both Is_Controlled_Active is set +-- and Disable_Controlled is not set for the type. -- Is_Controlling_Formal -- Defined in all Formal_Kind entities. Marks the controlling parameters @@ -3117,8 +3116,8 @@ package Einfo is -- Is_Modular_Integer_Type (synthesized) -- Applies to all entities. True if entity is a modular integer type --- Is_Mutably_Tagged_Type --- Defined in all type entities. Used to signify that a given type is a +-- Is_Mutably_Tagged_Type [base type only] +-- Defined in all types and subtypes. Set to indicate that the type is a -- "mutably tagged" class-wide type where 'Size'Class has been specified. -- Is_Non_Static_Subtype @@ -5173,6 +5172,7 @@ package Einfo is -- Is_Frozen -- Is_Generic_Actual_Type -- Is_Independent + -- Is_Mutably_Tagged_Type (base type only) -- Is_Non_Static_Subtype -- Is_Packed (base type only) -- Is_Private_Composite @@ -5354,6 +5354,7 @@ package Einfo is -- Direct_Primitive_Operations -- Cloned_Subtype (subtype case only) -- First_Entity + -- Class_Wide_Equivalent_Type (base type only) -- Equivalent_Type (always Empty for type) -- Non_Limited_View -- Last_Entity diff --git a/gcc/ada/exp_ch3.adb b/gcc/ada/exp_ch3.adb index 5372b8a7435d..c57949eb425b 100644 --- a/gcc/ada/exp_ch3.adb +++ b/gcc/ada/exp_ch3.adb @@ -6994,8 +6994,7 @@ package body Exp_Ch3 is if Ekind (Etype (Comp)) /= E_Void and then Is_Mutably_Tagged_Type (Etype (Comp)) then - Set_Etype - (Comp, Class_Wide_Equivalent_Type (Etype (Comp))); + Set_Etype (Comp, Class_Wide_Equivalent_Type (Etype (Comp))); end if; Next_Entity (Comp); end loop; @@ -8672,6 +8671,28 @@ package body Exp_Ch3 is and then OK_To_Rename_Ref (Prefix (Expr_Q)) and then not Special_Ret_Obj)); + -- If the object is of a mutably tagged type and is initialized + -- by something other than a function call, do the initialization + -- as an assignment so that only the bits present in the initial + -- value are copied. + + if Is_Mutably_Tagged_CW_Equivalent_Type (Typ) + and then Nkind (Expr_Q) /= N_Function_Call + and then not Rewrite_As_Renaming + then + declare + Stat : constant Node_Id := + Make_Assignment_Statement (Loc, + Name => New_Occurrence_Of (Def_Id, Loc), + Expression => Relocate_Node (Expr)); + begin + Set_Assignment_OK (Name (Stat)); + Set_No_Finalize_Actions (Stat); + Insert_Action_After (Init_After, Stat); + Set_Expression (N, Empty); + Set_No_Initialization (N); + end; + -- If the type needs finalization and is not inherently limited, -- then the target is adjusted after the copy and attached to the -- finalization list. However, no adjustment is needed in the case @@ -8683,7 +8704,7 @@ package body Exp_Ch3 is -- Similarly, no adjustment is needed if we are going to rewrite -- the object declaration into a renaming declaration. - if Needs_Finalization (Typ) + elsif Needs_Finalization (Typ) and then not Is_Inherently_Limited_Type (Typ) and then Nkind (Expr_Q) /= N_Function_Call and then not Is_Two_Pass_Aggregate (Expr_Q) diff --git a/gcc/ada/exp_ch5.adb b/gcc/ada/exp_ch5.adb index cf4733317497..63c6cb9798ac 100644 --- a/gcc/ada/exp_ch5.adb +++ b/gcc/ada/exp_ch5.adb @@ -2480,7 +2480,7 @@ package body Exp_Ch5 is begin -- Handle chains of renamings - Ent := Name (N); + Ent := Lhs; while Nkind (Ent) in N_Has_Entity and then Present (Entity (Ent)) and then Is_Object (Entity (Ent)) @@ -2967,18 +2967,18 @@ package body Exp_Ch5 is -- If dispatching assignment, we need to dispatch to _assign - if Is_Class_Wide_Type (Typ) + if (Is_Class_Wide_Type (Typ) and then Expand_Ctrl_Actions) -- If the type is tagged, we may as well use the predefined -- primitive assignment. This avoids inlining a lot of code -- and in the class-wide case, the assignment is replaced -- by a dispatching call to _assign. It is suppressed in the -- case of assignments created by the expander that correspond - -- to initializations, where we do want to copy the tag - -- (Expand_Ctrl_Actions flag is set False in this case). It is - -- also suppressed if restriction No_Dispatching_Calls is in - -- force because in that case predefined primitives are not - -- generated. + -- to initializations, where we do not want to finalize the + -- target (Expand_Ctrl_Actions is set to False in this case). + -- It is also suppressed if restriction No_Dispatching_Calls + -- is in force because in that case predefined primitives are + -- not generated. or else (Is_Tagged_Type (Typ) and then Chars (Current_Scope) /= Name_uAssign @@ -3015,13 +3015,70 @@ package body Exp_Ch5 is L := New_List; - -- In case of assignment to a class-wide tagged type, before - -- the assignment we generate run-time check to ensure that - -- the tags of source and target match. + -- Handle assignment of a mutably tagged type - if not Tag_Checks_Suppressed (Typ) + if Is_Mutably_Tagged_Type (Typ) then + declare + Lhs_Tag : constant Node_Id := + Make_Selected_Component (Loc, + Prefix => Duplicate_Subexpr (Lhs), + Selector_Name => + Make_Identifier (Loc, Name_uTag)); + + Rhs_Tag : constant Node_Id := + Make_Selected_Component (Loc, + Prefix => Duplicate_Subexpr (Rhs), + Selector_Name => + Make_Identifier (Loc, Name_uTag)); + + begin + -- Create a tag check when we have the extra + -- constrained formal and it is true (meaning we + -- are not dealing with a mutably tagged object). + + if not Tag_Checks_Suppressed (Typ) + and then Is_Entity_Name (Lhs) + and then Is_Formal (Entity (Lhs)) + and then Present (Extra_Constrained (Entity (Lhs))) + then + Append_To (L, + Make_If_Statement (Loc, + Condition => + New_Occurrence_Of + (Extra_Constrained (Entity (Lhs)), Loc), + Then_Statements => New_List ( + Make_Raise_Constraint_Error (Loc, + Condition => + Make_Op_Ne (Loc, + Left_Opnd => Lhs_Tag, + Right_Opnd => Rhs_Tag), + Reason => CE_Tag_Check_Failed)))); + end if; + + -- Generate a tag assignment before the actual + -- assignment so we dispatch to the proper + -- assign version. + + Append_To (L, + Make_Assignment_Statement (Loc, + Name => + Make_Selected_Component (Loc, + Prefix => Duplicate_Subexpr (Lhs), + Selector_Name => + Make_Identifier (Loc, Name_uTag)), + Expression => + Make_Selected_Component (Loc, + Prefix => Duplicate_Subexpr (Rhs), + Selector_Name => + Make_Identifier (Loc, Name_uTag)))); + end; + + -- For the assignment of a regular class-wide type, generate + -- a run-time check to ensure that the tag of the source and + -- that of the target match. + + elsif not Tag_Checks_Suppressed (Typ) and then Is_Class_Wide_Type (Typ) - and then Is_Tagged_Type (Typ) and then Is_Tagged_Type (Underlying_Type (Etype (Rhs))) then declare @@ -3029,18 +3086,7 @@ package body Exp_Ch5 is Rhs_Tag : Node_Id; begin - if not Is_Interface (Typ) then - Lhs_Tag := - Make_Selected_Component (Loc, - Prefix => Duplicate_Subexpr (Lhs), - Selector_Name => - Make_Identifier (Loc, Name_uTag)); - Rhs_Tag := - Make_Selected_Component (Loc, - Prefix => Duplicate_Subexpr (Rhs), - Selector_Name => - Make_Identifier (Loc, Name_uTag)); - else + if Is_Interface (Typ) then -- Displace the pointer to the base of the objects -- applying 'Address, which is later expanded into -- a call to RE_Base_Address. @@ -3059,66 +3105,26 @@ package body Exp_Ch5 is Make_Attribute_Reference (Loc, Prefix => Duplicate_Subexpr (Rhs), Attribute_Name => Name_Address))); - end if; - - -- Handle assignment to a mutably tagged type - - if Is_Mutably_Tagged_Conversion (Lhs) - or else Is_Mutably_Tagged_Type (Typ) - or else Is_Mutably_Tagged_Type (Etype (Lhs)) - then - -- Create a tag check when we have the extra - -- constrained formal and it is true (meaning we - -- are not dealing with a mutably tagged object). - - if Is_Entity_Name (Name (N)) - and then Is_Formal (Entity (Name (N))) - and then Present - (Extra_Constrained (Entity (Name (N)))) - then - Append_To (L, - Make_If_Statement (Loc, - Condition => - New_Occurrence_Of - (Extra_Constrained - (Entity (Name (N))), Loc), - Then_Statements => New_List ( - Make_Raise_Constraint_Error (Loc, - Condition => - Make_Op_Ne (Loc, - Left_Opnd => Lhs_Tag, - Right_Opnd => Rhs_Tag), - Reason => CE_Tag_Check_Failed)))); - end if; - - -- Generate a tag assignment before the actual - -- assignment so we dispatch to the proper - -- assign version. - - Append_To (L, - Make_Assignment_Statement (Loc, - Name => - Make_Selected_Component (Loc, - Prefix => Duplicate_Subexpr (Lhs), - Selector_Name => - Make_Identifier (Loc, Name_uTag)), - Expression => - Make_Selected_Component (Loc, - Prefix => Duplicate_Subexpr (Rhs), - Selector_Name => - Make_Identifier (Loc, Name_uTag)))); - - -- Otherwise generate a normal tag check - else - Append_To (L, - Make_Raise_Constraint_Error (Loc, - Condition => - Make_Op_Ne (Loc, - Left_Opnd => Lhs_Tag, - Right_Opnd => Rhs_Tag), - Reason => CE_Tag_Check_Failed)); + Lhs_Tag := + Make_Selected_Component (Loc, + Prefix => Duplicate_Subexpr (Lhs), + Selector_Name => + Make_Identifier (Loc, Name_uTag)); + Rhs_Tag := + Make_Selected_Component (Loc, + Prefix => Duplicate_Subexpr (Rhs), + Selector_Name => + Make_Identifier (Loc, Name_uTag)); end if; + + Append_To (L, + Make_Raise_Constraint_Error (Loc, + Condition => + Make_Op_Ne (Loc, + Left_Opnd => Lhs_Tag, + Right_Opnd => Rhs_Tag), + Reason => CE_Tag_Check_Failed)); end; end if; @@ -3147,7 +3153,7 @@ package body Exp_Ch5 is end; end; - -- Untagged case + -- Untagged case, or initialization in tagged case else declare @@ -6494,13 +6500,16 @@ package body Exp_Ch5 is Ctrl_Act : constant Boolean := Needs_Finalization (T) and then not No_Ctrl_Actions (N) and then not No_Finalize_Actions (N); + Mute_Tag : constant Boolean := Is_Mutably_Tagged_CW_Equivalent_Type (T); Save_Tag : constant Boolean := Is_Tagged_Type (T) and then not Comp_Asn + and then not Mute_Tag and then not No_Ctrl_Actions (N) and then not No_Finalize_Actions (N) and then Tagged_Type_Expansion; Set_Tag : constant Boolean := Is_Tagged_Type (T) and then not Comp_Asn + and then not Mute_Tag and then not No_Ctrl_Actions (N) and then Tagged_Type_Expansion; Adj_Call : Node_Id; @@ -6580,6 +6589,17 @@ package body Exp_Ch5 is if Comp_Asn then Set_Analyzed (New_N, False); Set_Componentwise_Assignment (New_N, True); + + -- If this is an assignment of a mutably tagged type, we need to assign + -- only the bits present in the source, so we strip a conversion to the + -- mutably tagged type so as to expose the source to the code generator. + + elsif Mute_Tag + and then Nkind (Expression (N)) in N_Type_Conversion + | N_Unchecked_Type_Conversion + and then Etype (Expression (N)) = Corresponding_Mutably_Tagged_Type (T) + then + Rewrite (Expression (New_N), Expression (Expression (N))); end if; Append_To (Res, New_N); diff --git a/gcc/ada/exp_ch6.adb b/gcc/ada/exp_ch6.adb index 1441aa828388..caa2e1e7d3c3 100644 --- a/gcc/ada/exp_ch6.adb +++ b/gcc/ada/exp_ch6.adb @@ -9682,8 +9682,8 @@ package body Exp_Ch6 is and then (Has_Task (Typ) or else (Is_Class_Wide_Type (Typ) and then Is_Limited_Record (Typ) - and then not Has_Aspect - (Etype (Typ), Aspect_No_Task_Parts))); + and then not Has_Enabled_Aspect + (Root_Type (Typ), Aspect_No_Task_Parts))); end Might_Have_Tasks; ---------------------------- diff --git a/gcc/ada/exp_ch7.adb b/gcc/ada/exp_ch7.adb index 11c86895aa16..338a5de8057c 100644 --- a/gcc/ada/exp_ch7.adb +++ b/gcc/ada/exp_ch7.adb @@ -46,6 +46,7 @@ with Freeze; use Freeze; with GNAT_CUDA; use GNAT_CUDA; with Inline; use Inline; with Lib; use Lib; +with Mutably_Tagged; use Mutably_Tagged; with Nlists; use Nlists; with Nmake; use Nmake; with Opt; use Opt; @@ -5508,7 +5509,7 @@ package body Exp_Ch7 is if Is_Class_Wide_Type (Typ) then Utyp := Root_Type (Typ); else - Utyp := Typ; + Utyp := Get_Corresponding_Tagged_Type_If_Present (Typ); end if; Utyp := Underlying_Type (Base_Type (Utyp)); @@ -7892,7 +7893,7 @@ package body Exp_Ch7 is Ref := Convert_Concurrent (Ref, Underlying_Type (Typ)); else - Utyp := Typ; + Utyp := Get_Corresponding_Tagged_Type_If_Present (Typ); Atyp := Typ; end if; @@ -8469,7 +8470,7 @@ package body Exp_Ch7 is else Is_Conc := False; - Utyp := Typ; + Utyp := Get_Corresponding_Tagged_Type_If_Present (Typ); end if; Utyp := Underlying_Type (Base_Type (Utyp)); @@ -8500,22 +8501,28 @@ package body Exp_Ch7 is -- [Deep_]Initialize primitive to call. -- If Typ is protected then no additional processing is needed either. - if No (Utyp) - or else Is_Protected_Type (Typ) - then + if No (Utyp) or else Is_Protected_Type (Typ) then return Empty; end if; - -- Select the appropriate version of initialize + -- Select the appropriate version of Initialize if Has_Controlled_Component (Utyp) then Proc := TSS (Utyp, TSS_Deep_Initialize); - elsif Is_Mutably_Tagged_Type (Utyp) then - Proc := Find_Controlled_Prim_Op (Etype (Utyp), Name_Initialize); - Check_Visibly_Controlled (Initialize_Case, Etype (Typ), Proc, Ref); - else + + -- Derivations from [Limited_]Controlled + + elsif Is_Controlled (Utyp) then Proc := Find_Controlled_Prim_Op (Utyp, Name_Initialize); Check_Visibly_Controlled (Initialize_Case, Typ, Proc, Ref); + + -- Mutably tagged types without controlled parts in the root type + + elsif Is_Mutably_Tagged_CW_Equivalent_Type (Typ) then + return Empty; + + else + raise Program_Error; end if; -- If initialization procedure for an array of controlled objects is diff --git a/gcc/ada/exp_util.adb b/gcc/ada/exp_util.adb index f4bcd18dab75..d587fb16c8f4 100644 --- a/gcc/ada/exp_util.adb +++ b/gcc/ada/exp_util.adb @@ -41,6 +41,7 @@ with Ghost; use Ghost; with Inline; use Inline; with Itypes; use Itypes; with Lib; use Lib; +with Mutably_Tagged; use Mutably_Tagged; with Nlists; use Nlists; with Nmake; use Nmake; with Opt; use Opt; @@ -6302,7 +6303,8 @@ package body Exp_Util is function Finalize_Address (Typ : Entity_Id) return Entity_Id is Btyp : constant Entity_Id := Base_Type (Typ); - Utyp : Entity_Id := Typ; + Utyp : Entity_Id := + Get_Corresponding_Mutably_Tagged_Type_If_Present (Typ); begin -- Handle protected class-wide or task class-wide types @@ -10730,10 +10732,10 @@ package body Exp_Util is end if; -- Set Is_Class_Wide_Equivalent_Type very early to trigger the special - -- treatment for this type. In particular, even though _parent's type + -- treatment for this type. In particular, even though _Parent's type -- is a controlled type or contains controlled components, we do not - -- want to set Has_Controlled_Component on it to avoid making it gain - -- an unwanted _controller component. + -- want to set Has_Controlled_Component on the equivalent type because + -- we do not want to build internal controlled primitives for it. Set_Is_Class_Wide_Equivalent_Type (Equiv_Type); diff --git a/gcc/ada/freeze.adb b/gcc/ada/freeze.adb index c5156715d6e2..28214ab2614e 100644 --- a/gcc/ada/freeze.adb +++ b/gcc/ada/freeze.adb @@ -5035,7 +5035,7 @@ package body Freeze is -- Accumulates total Esize values of all elementary components. Used -- for processing of Implicit_Packing. - Final_Storage_Only : Boolean := True; + Final_Storage_Only : Boolean; -- Used to compute the Finalize_Storage_Only flag Placed_Component : Boolean := False; @@ -5043,7 +5043,7 @@ package body Freeze is -- clause (used to warn about useless Bit_Order pragmas, and also -- to detect cases where Implicit_Packing may have an effect). - Relaxed_Finalization : Boolean := True; + Relaxed_Finalization : Boolean; -- Used to compute the Has_Relaxed_Finalization flag Sized_Component_Total_RM_Size : Uint := Uint_0; @@ -5830,6 +5830,17 @@ package body Freeze is Freeze_And_Append (Corresponding_Remote_Type (Rec), N, Result); end if; + -- Initialize Final_Storage_Only and Relaxed_Finalization from the + -- current state if we have inherited controlled components. + + if Has_Controlled_Component (Rec) then + Final_Storage_Only := Finalize_Storage_Only (Rec); + Relaxed_Finalization := Has_Relaxed_Finalization (Rec); + else + Final_Storage_Only := True; + Relaxed_Finalization := True; + end if; + -- Check for tasks, protected and controlled components, unchecked -- unions, and type invariants. @@ -5837,22 +5848,12 @@ package body Freeze is while Present (Comp) loop Propagate_Concurrent_Flags (Rec, Etype (Comp)); - -- Do not set Has_Controlled_Component on a class-wide - -- equivalent type. See Make_CW_Equivalent_Type. + -- Do not set Has_Controlled_Component on a CW equivalent type, + -- see Exp_Util.Make_CW_Equivalent_Type. if not Is_Class_Wide_Equivalent_Type (Rec) - and then - (Has_Controlled_Component (Etype (Comp)) - or else - (Chars (Comp) /= Name_uParent - and then Is_Controlled (Etype (Comp))) - or else - (Is_Protected_Type (Etype (Comp)) - and then - Present (Corresponding_Record_Type (Etype (Comp))) - and then - Has_Controlled_Component - (Corresponding_Record_Type (Etype (Comp))))) + and then Chars (Comp) /= Name_uParent + and then Needs_Finalization (Etype (Comp)) then Set_Has_Controlled_Component (Rec); Final_Storage_Only := @@ -5896,7 +5897,7 @@ package body Freeze is -- For a type that is not directly controlled but has controlled -- components, Finalize_Storage_Only is set if all the controlled -- components are Finalize_Storage_Only. The same processing is - -- appled to Has_Relaxed_Finalization. + -- applied to Has_Relaxed_Finalization. if not Is_Controlled (Rec) and then Has_Controlled_Component (Rec) then diff --git a/gcc/ada/gen_il-gen-gen_entities.adb b/gcc/ada/gen_il-gen-gen_entities.adb index 3a085e8c5322..65fb5dc958f0 100644 --- a/gcc/ada/gen_il-gen-gen_entities.adb +++ b/gcc/ada/gen_il-gen-gen_entities.adb @@ -455,7 +455,6 @@ begin -- Gen_IL.Gen.Gen_Entities Sm (Associated_Node_For_Itype, Node_Id), Sm (Can_Use_Internal_Rep, Flag, Base_Type_Only, Pre => "Ekind (Base_Type (N)) in Access_Subprogram_Kind"), - Sm (Class_Wide_Equivalent_Type, Node_Id), Sm (Class_Wide_Type, Node_Id), Sm (Contract, Node_Id), Sm (Current_Use_Clause, Node_Id), @@ -510,7 +509,7 @@ begin -- Gen_IL.Gen.Gen_Entities Sm (Is_Generic_Actual_Type, Flag), Sm (Is_Implicit_Full_View, Flag), Sm (Is_Limited_Composite, Flag), - Sm (Is_Mutably_Tagged_Type, Flag), + Sm (Is_Mutably_Tagged_Type, Flag, Base_Type_Only), Sm (Is_Non_Static_Subtype, Flag), Sm (Is_Private_Composite, Flag), Sm (Is_RACW_Stub_Type, Flag), @@ -752,6 +751,7 @@ begin -- Gen_IL.Gen.Gen_Entities Ab (Class_Wide_Kind, Aggregate_Kind, (Sm (C_Pass_By_Copy, Flag, Impl_Base_Type_Only), + Sm (Class_Wide_Equivalent_Type, Node_Id, Base_Type_Only), Sm (Equivalent_Type, Node_Id), Sm (Has_Complex_Representation, Flag, Impl_Base_Type_Only), Sm (Has_Record_Rep_Clause, Flag, Impl_Base_Type_Only), diff --git a/gcc/ada/mutably_tagged.adb b/gcc/ada/mutably_tagged.adb index 971e9de95286..446b7405032d 100644 --- a/gcc/ada/mutably_tagged.adb +++ b/gcc/ada/mutably_tagged.adb @@ -186,13 +186,13 @@ package body Mutably_Tagged is and then not Error_Posted (Typ) -- Finally check Typ is a class-wide equivalent type which has an - -- associated mutably tagged class-wide type (e.g. it is a class-wide - -- type with a size clause). + -- associated mutably tagged class-wide type. and then Is_Class_Wide_Equivalent_Type (Typ) and then Present (Parent_Subtype (Typ)) and then Present (Class_Wide_Type (Parent_Subtype (Typ))) - and then Has_Size_Clause (Corresponding_Mutably_Tagged_Type (Typ)); + and then + Is_Mutably_Tagged_Type (Class_Wide_Type (Parent_Subtype (Typ))); end Is_Mutably_Tagged_CW_Equivalent_Type; -------------------------------- diff --git a/gcc/ada/mutably_tagged.ads b/gcc/ada/mutably_tagged.ads index 2ffc3ce824c8..7c6c2f44b4d3 100644 --- a/gcc/ada/mutably_tagged.ads +++ b/gcc/ada/mutably_tagged.ads @@ -77,12 +77,11 @@ package Mutably_Tagged is function Get_Corresponding_Tagged_Type_If_Present (Typ : Entity_Id) return Entity_Id; - -- Obtain the corresponding tag type associated with Typ when - -- Typ is a mutably tagged class-wide equivalent type. Otherwise, Just - -- return Typ. + -- Obtain the corresponding tagged type associated with Typ when Typ is + -- a mutably tagged class-wide equivalent type. Otherwise, just return Typ. -- This function is mostly used when we need a concrete type to generate - -- initialization for mutably tagged types. + -- initialization/adjustment/finalization for mutably tagged types. function Is_Mutably_Tagged_Conversion (N : Node_Id) return Boolean; -- Return True if expression N is an object of a mutably tagged class-wide diff --git a/gcc/ada/sem_ch12.adb b/gcc/ada/sem_ch12.adb index a87dde1868bd..ba757e766c8f 100644 --- a/gcc/ada/sem_ch12.adb +++ b/gcc/ada/sem_ch12.adb @@ -15720,8 +15720,8 @@ package body Sem_Ch12 is Gen_T); elsif not Is_Definite_Subtype (Act_T) + and then not Is_Mutably_Tagged_Type (Act_T) and then Is_Definite_Subtype (A_Gen_T) - and then No (Class_Wide_Equivalent_Type (Act_T)) and then Ada_Version >= Ada_95 then Error_Msg_NE @@ -15763,10 +15763,10 @@ package body Sem_Ch12 is Act_T := Entity (Actual); - -- Obtain the class-wide equivalent type and use it for the + -- Obtain the class-wide equivalent type, if any, and use it for the -- instantiation instead of a mutably tagged type. - if Present (Class_Wide_Equivalent_Type (Act_T)) then + if Is_Mutably_Tagged_Type (Act_T) then Act_T := Class_Wide_Equivalent_Type (Act_T); end if; diff --git a/gcc/ada/sem_ch3.adb b/gcc/ada/sem_ch3.adb index 8f44ac7c6df9..c204fe6ea052 100644 --- a/gcc/ada/sem_ch3.adb +++ b/gcc/ada/sem_ch3.adb @@ -18866,7 +18866,6 @@ package body Sem_Ch3 is Set_Full_View (Prev, Id); Append_Entity (Id, Current_Scope); Set_Is_Public (Id, Is_Public (Prev)); - Set_Is_Internal (Id); New_Id := Prev; -- If the incomplete view is tagged, a class_wide type has been @@ -23436,8 +23435,8 @@ package body Sem_Ch3 is procedure Record_Type_Definition (Def : Node_Id; Prev_T : Entity_Id) is Component : Entity_Id; - Final_Storage_Only : Boolean := True; - Relaxed_Finalization : Boolean := True; + Final_Storage_Only : Boolean; + Relaxed_Finalization : Boolean; T : Entity_Id; begin @@ -23447,6 +23446,17 @@ package body Sem_Ch3 is T := Prev_T; end if; + -- Initialize Final_Storage_Only and Relaxed_Finalization from the + -- current state if we have inherited controlled components. + + if Has_Controlled_Component (T) then + Final_Storage_Only := Finalize_Storage_Only (T); + Relaxed_Finalization := Has_Relaxed_Finalization (T); + else + Final_Storage_Only := True; + Relaxed_Finalization := True; + end if; + Set_Is_Not_Self_Hidden (T); -- Ada 2005: Check whether an explicit "limited" is present in a derived @@ -23511,13 +23521,12 @@ package body Sem_Ch3 is if Ekind (Component) /= E_Component then null; - -- Do not set Has_Controlled_Component on a class-wide equivalent - -- type. See Make_CW_Equivalent_Type. + -- Do not set Has_Controlled_Component on a CW equivalent type, + -- see Exp_Util.Make_CW_Equivalent_Type. elsif not Is_Class_Wide_Equivalent_Type (T) - and then (Has_Controlled_Component (Etype (Component)) - or else (Chars (Component) /= Name_uParent - and then Is_Controlled (Etype (Component)))) + and then Chars (Component) /= Name_uParent + and then Needs_Finalization (Etype (Component)) then Set_Has_Controlled_Component (T); Final_Storage_Only := @@ -23534,7 +23543,7 @@ package body Sem_Ch3 is -- For a type that is not directly controlled but has controlled -- components, Finalize_Storage_Only is set if all the controlled -- components are Finalize_Storage_Only. The same processing is - -- appled to Has_Relaxed_Finalization. + -- applied to Has_Relaxed_Finalization. if not Is_Controlled (T) and then Has_Controlled_Component (T) then Set_Finalize_Storage_Only (T, Final_Storage_Only); diff --git a/gcc/ada/sem_util.adb b/gcc/ada/sem_util.adb index b196a6cee7dc..96839b8bf172 100644 --- a/gcc/ada/sem_util.adb +++ b/gcc/ada/sem_util.adb @@ -23824,9 +23824,19 @@ package body Sem_Util is return False; -- Class-wide types are treated as controlled because derivations from - -- the root type may introduce controlled components. - - elsif Is_Class_Wide_Type (Typ) then + -- the root type may introduce controlled components, unless the root + -- type is declared with the No_Controlled_Parts aspect. + + elsif (Is_Class_Wide_Type (Typ) + and then not + Has_Enabled_Aspect + (Root_Type (Typ), Aspect_No_Controlled_Parts)) + or else (Is_Mutably_Tagged_CW_Equivalent_Type (Typ) + and then not + Has_Enabled_Aspect + (Root_Type (Corresponding_Mutably_Tagged_Type (Typ)), + Aspect_No_Controlled_Parts)) + then return True; -- Concurrent types are controlled as long as their corresponding record From 31c95bb248c923e926102dd363cff0d9e1e5083d Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Tue, 22 Sep 2026 21:14:31 +0200 Subject: [PATCH 345/584] Ada: Fix valid call to asymmetric "/=" rejected in prefix notation This happens only when one of the operands is of a tagged type, because the handling of equality operators for tagged types is completely separate from that of equality operators for untagged types. But it turns out that this separate processing is intended to be used for symmetric equality operators only, so the fix is to redirect that of all asymmetric equality operators to the common processing instead. This also fixes a small glitch in this common processing, whereby a derived type would both inherit an implicit inequality operator from its parent type per the RM 6.6(6) rule and have another implicit inequality operator created from an equality operator inherited from its parent type. gcc/ada/ * exp_ch3.adb (Make_Predefined_Primitive_Eq_Spec): Fix pasto. * sem_ch4.adb (wpo): Also accept untagged types. * sem_ch6.adb (Make_Inequality_Operator): Also copy Is_Primitive. (New_Overloaded_Entity): Create the implicit inequality operator only for nonderived subprograms, but create it in the asymmetric case even for tagged types. Deal with the inheritance of such an implicit inequality operator. * sem_disp.adb: Add clauses for Stand. (Check_Dispatching_Operation): Bail out for inequality operators whose result type is Boolean. --- gcc/ada/exp_ch3.adb | 2 +- gcc/ada/sem_ch4.adb | 4 --- gcc/ada/sem_ch6.adb | 62 +++++++++++++++++++++++++++++++++++++------- gcc/ada/sem_disp.adb | 13 +++++++++- 4 files changed, 65 insertions(+), 16 deletions(-) diff --git a/gcc/ada/exp_ch3.adb b/gcc/ada/exp_ch3.adb index c57949eb425b..5f4a271d627e 100644 --- a/gcc/ada/exp_ch3.adb +++ b/gcc/ada/exp_ch3.adb @@ -12351,7 +12351,7 @@ package body Exp_Ch3 is -- Set to True if Tag_Typ has a primitive that renames the predefined -- equality operator. Used to implement (RM 8-5-4(8)). - -- Start of processing for Make_Predefined_Primitive_Specs + -- Start of processing for Make_Predefined_Primitive_Eq_Spec begin Renamed_Eq := Empty; diff --git a/gcc/ada/sem_ch4.adb b/gcc/ada/sem_ch4.adb index 400fa4f8869f..31786fd6ab76 100644 --- a/gcc/ada/sem_ch4.adb +++ b/gcc/ada/sem_ch4.adb @@ -11440,10 +11440,6 @@ package body Sem_Ch4 is E : Elmt_Id; begin - if not Is_Tagged_Type (T) then - return; - end if; - E := First_Elmt (Primitive_Operations (Base_Type (T))); while Present (E) loop Op := Node (E); diff --git a/gcc/ada/sem_ch6.adb b/gcc/ada/sem_ch6.adb index 2ed3b7c3f477..76da204abcf4 100644 --- a/gcc/ada/sem_ch6.adb +++ b/gcc/ada/sem_ch6.adb @@ -11656,6 +11656,7 @@ package body Sem_Ch6 is Set_Has_Completion (Op_Name); Set_Corresponding_Equality (Op_Name, S); Set_Is_Abstract_Subprogram (Op_Name, Is_Abstract_Subprogram (S)); + Set_Is_Primitive (Op_Name, Is_Primitive (S)); end; end Make_Inequality_Operator; @@ -13274,23 +13275,22 @@ package body Sem_Ch6 is -- operation was dispatching), so Check_Dispatching_Operation is not -- called in that case. - if No (Derived_Type) - or else Is_Tagged_Type (Derived_Type) - then + if No (Derived_Type) or else Is_Tagged_Type (Derived_Type) then Check_Dispatching_Operation (S, Empty); end if; end if; - -- If this is a user-defined equality operator that is not a derived - -- subprogram, create the corresponding inequality. If the operation is - -- dispatching, the expansion is done elsewhere, and we do not create - -- an explicit inequality operation. - <> + -- If this is an equality operator whose result type is Boolean and + -- that is not a derived subprogram, create the implicit inequality + -- operator (RM 6.6(6)), but not if it is a dispatching user-defined + -- equality operator because those are handled specially. + if Chars (S) = Name_Op_Eq and then Base_Type (Etype (S)) = Standard_Boolean - and then Present (Parent (S)) - and then not Is_Dispatching_Operation (S) + and then No (Alias (S)) + and then not (Is_Dispatching_Operation (S) + and then Is_User_Defined_Equality (S)) then Make_Inequality_Operator (S); @@ -13302,6 +13302,48 @@ package body Sem_Ch6 is then Check_Untagged_Equality (S); end if; + + -- If this is an inherited implicit inequality operator, set its + -- Corresponding_Equality to the inherited equality operator. + + elsif Chars (S) = Name_Op_Ne + and then Base_Type (Etype (S)) = Standard_Boolean + and then Present (Alias (S)) + and then Present (Corresponding_Equality (Alias (S))) + then + declare + Eq : constant Entity_Id := Prev_Entity (S); + + function Check_Correspondence return Boolean; + -- Check that the Corresponding_Equality of the immediate + -- ancestor of S is an ancestor of Eq. Note that we cannot + -- be more specific for Eq since Sem_Ch3.Derive_Subprogram + -- does not set the Alias field of derived subprograms the + -- same way for intrinsic and nonintrinsic subprograms. + + -------------------------- + -- Check_Correspondence -- + -------------------------- + + function Check_Correspondence return Boolean is + A : Entity_Id := Alias (Eq); + + begin + while Present (A) loop + if Corresponding_Equality (Alias (S)) = A then + return True; + end if; + + A := Alias (A); + end loop; + + return False; + end Check_Correspondence; + + begin + pragma Assert (Check_Correspondence); + Set_Corresponding_Equality (S, Eq); + end; end if; end New_Overloaded_Entity; diff --git a/gcc/ada/sem_disp.adb b/gcc/ada/sem_disp.adb index c093d1122d0e..cf12321cc5cd 100644 --- a/gcc/ada/sem_disp.adb +++ b/gcc/ada/sem_disp.adb @@ -53,6 +53,7 @@ with Sem_Util; use Sem_Util; with Snames; use Snames; with Sinfo.Nodes; use Sinfo.Nodes; with Sinfo.Utils; use Sinfo.Utils; +with Stand; use Stand; with Tbuild; use Tbuild; with Uintp; use Uintp; with Warnsw; use Warnsw; @@ -1286,10 +1287,20 @@ package body Sem_Disp is then return; - -- Wrappers of access to subprograms are not primitive subprograms. + -- Wrappers of access to subprograms are not dispatching operations elsif Is_Access_To_Subprogram_Wrapper (Subp) then return; + + -- Inequality operators whose result type is Boolean are not dispatching + -- operations because they are always implicitly declared as giving the + -- complementary result of the sibling equality operator (RM 6.6(5-6)). + + elsif Ekind (Subp) = E_Function + and then Chars (Subp) = Name_Op_Ne + and then Base_Type (Etype (Subp)) = Standard_Boolean + then + return; end if; Set_Is_Dispatching_Operation (Subp, False); From 7f8fb37914c36d9c6048065cc1e71def5edef46e Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Tue, 22 Sep 2026 21:22:27 +0200 Subject: [PATCH 346/584] Ada: Do not apply static accessibility checks to synthesized return This adds the same early return to Check_Return_Construct_Accessibility for static checks as the one present in Apply_Accessibility_Check_For_Return for dynamic checks. gcc/ada/ * accessibility.adb (Check_Return_Construct_Accessibility): Bail out for the return synthesized in a function whose body has been wrapped in a nested _Wrapped_Statements function. --- gcc/ada/accessibility.adb | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/gcc/ada/accessibility.adb b/gcc/ada/accessibility.adb index f7104930e72d..42092bebbf92 100644 --- a/gcc/ada/accessibility.adb +++ b/gcc/ada/accessibility.adb @@ -2137,11 +2137,14 @@ package body Accessibility is | N_Simple_Return_Statement); -- Only perform checks on record types with access discriminants and - -- functions present in the source. + -- functions present in the source, but no checks are needed for the + -- return synthesized in a function whose body has been wrapped in a + -- nested _Wrapped_Statements function. if not Is_Record_Type (R_Type) or else not Has_Anonymous_Access_Discriminant (R_Type) or else not Comes_From_Source (Scope_Id) + or else Present (Wrapped_Statements (Scope_Id)) then return; end if; From 481222de94ad9eac9ecdb5f3fea7f82d5fda7443 Mon Sep 17 00:00:00 2001 From: "Vladimir N. Makarov" Date: Tue, 22 Sep 2026 13:42:38 -0400 Subject: [PATCH 347/584] [PR 127326][LRA]: Implement fallback to memory for memory and reg constraint LRA correctly works for 'rm' constraint when register can not hold value of given mode. For 'g' constraint, LRA fails as it correctly considers the constraint can be satisfied but tries to use hard register which can not be in given mode. The patch fixes this. gcc/ChangeLog: PR rtl-optimization/127326 * lra-constraints.cc (process_alt_operands): Ignore register if constraint describes memory and register which can not hold the mode value. gcc/testsuite/ChangeLog: PR rtl-optimization/127326 * gcc.target/i386/pr127326.c: New. --- gcc/lra-constraints.cc | 41 ++++++++++++++++++++++-- gcc/testsuite/gcc.target/i386/pr127326.c | 17 ++++++++++ 2 files changed, 55 insertions(+), 3 deletions(-) create mode 100644 gcc/testsuite/gcc.target/i386/pr127326.c diff --git a/gcc/lra-constraints.cc b/gcc/lra-constraints.cc index 0f9bb3da6df1..72430d517321 100644 --- a/gcc/lra-constraints.cc +++ b/gcc/lra-constraints.cc @@ -2776,9 +2776,11 @@ process_alt_operands (int only_alternative) break; } } - /* Both operands must allow a reload register, - otherwise we cannot make them match. */ - if (curr_alt[m] == NO_REGS) + /* Both operands must allow a reload register or the + matched operand accepts memory (e.g. 'g' with a mode + that fits no hard reg), in which case the operands + can be matched in memory. */ + if (curr_alt[m] == NO_REGS && !curr_alt_offmemok[m]) break; /* Retroactively mark the operand we had to match as a loser, if it wasn't already and @@ -2858,6 +2860,11 @@ process_alt_operands (int only_alternative) this_alternative_set = curr_alt_set[m]; this_alternative_exclude_start_hard_regs = curr_alt_exclude_start_hard_regs[m]; + /* If the matched operand permits memory (e.g. 'g'), + so does this one -- they share the same location. + This lets a matching reload go to memory when no + hard reg of the class can hold the operand mode. */ + offmemok = curr_alt_offmemok[m]; winreg = this_alternative != NO_REGS; break; } @@ -3053,6 +3060,21 @@ process_alt_operands (int only_alternative) [all_this_alternative][this_alternative]); } this_alternative_win = true; + /* If reg and memory is acceptable here (e.g. 'g') but no hard + reg of the operand class can hold the operand mode, resolve + the operand to memory. Mark it so that an operand matching + this one can also fall back to memory, otherwise the matched + operand would try to reload into an impossible hard reg and + LRA would cycle (e.g. TDmode "+g" asm on 32-bit x86). */ + if (offmemok && this_alternative != NO_REGS + && hard_reg_set_subset_p (reg_class_contents[this_alternative], + ira_prohibited_class_mode_regs + [this_alternative][mode] + | lra_no_alloc_regs)) + { + this_alternative = NO_REGS; + this_alternative_offmemok = true; + } if (class_change_p) { curr_alt_class_change_p = true; @@ -3205,6 +3227,19 @@ process_alt_operands (int only_alternative) nop); reject += 2; } + else if (!prefer_memory_p) + { + /* No hard reg of the operand class can hold the + operand mode, but the constraint may still permit + memory (e.g. 'g'). Prefer memory for the operands + before refusing. */ + prefer_memory_p = true; + if (lra_dump_file != NULL) + fprintf (lra_dump_file, + " Trying now memory for" + " operands\n"); + goto repeat; + } else { if (lra_dump_file != NULL) diff --git a/gcc/testsuite/gcc.target/i386/pr127326.c b/gcc/testsuite/gcc.target/i386/pr127326.c new file mode 100644 index 000000000000..ed618cf70928 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr127326.c @@ -0,0 +1,17 @@ +/* PR rtl-optimization/127326 */ +/* { dg-do compile { target { ia32 } } } */ +/* { dg-options "-O2" } */ +/* { dg-require-effective-target dfp } */ + +/* On 32-bit x86 no hard register can hold a TDmode value, so the "+g" + asm operand has to be matched in memory. LRA used to reject this with + "inconsistent operand constraints in an 'asm'". */ + +_Decimal128 +test (void) +{ + union { _Decimal128 d; unsigned long long u[2]; } u; + u.d = 1.0DL; + __asm ("" : "+g" (u.d)); /* { dg-bogus "inconsistent operand constraints" } */ + return u.d; +} From 7aa4b1c5054f12c134e69ed295638885f4b3b9c1 Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Tue, 22 Sep 2026 21:24:18 +0200 Subject: [PATCH 348/584] Ada: Fix spurious error on membership test in instance body The membership test is unreachable in the instance body. gcc/ada/ * sem_ch4.adb (Analyze_Membership_Op): Do not force an error to be given if the right operand is a Raise_Error node. --- gcc/ada/sem_ch4.adb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/ada/sem_ch4.adb b/gcc/ada/sem_ch4.adb index 31786fd6ab76..07bedd0fb761 100644 --- a/gcc/ada/sem_ch4.adb +++ b/gcc/ada/sem_ch4.adb @@ -3683,7 +3683,7 @@ package body Sem_Ch4 is Analyze (N); return; - else + elsif Nkind (R) not in N_Raise_xxx_Error then -- In all versions of the language, if we reach this point there -- is a previous error that will be diagnosed below. From 3811deab5fd7334c8cbe7b89ef416c7afb1e1677 Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Tue, 22 Sep 2026 21:31:08 +0200 Subject: [PATCH 349/584] Ada: Fix bogus validity failure for reverse SSO array converted to FP The expander already knows that special care must be taken for 'Valid in the presence of floating-point objects with reverse scalar storage order, but this was not done in this particular case. gcc/ada/ * exp_attr.adb (Expand_N_Attribute_Reference) : Call Is_Reverse_Storage_Order_Object to detect cases where a copy needs to be created for the prefix. * sem_util.ads (In_Reverse_Storage_Order_Object): Delete. (Is_Reverse_Storage_Order_Object): New predicate. * sem_util.adb (In_Reverse_Storage_Order_Object): Delete. (Is_Reverse_Storage_Order_Object): New predicate subsuming original In_Reverse_Storage_Order_Object predicate. --- gcc/ada/exp_attr.adb | 4 ++-- gcc/ada/sem_util.adb | 50 +++++++++++++++++++++++++------------------- gcc/ada/sem_util.ads | 9 ++++---- 3 files changed, 35 insertions(+), 28 deletions(-) diff --git a/gcc/ada/exp_attr.adb b/gcc/ada/exp_attr.adb index a30c19beb94a..6bc1cfbb4f3d 100644 --- a/gcc/ada/exp_attr.adb +++ b/gcc/ada/exp_attr.adb @@ -8417,7 +8417,7 @@ package body Exp_Attr is begin Find_Fat_Info (PBtyp, Ftp, Pkg); - -- If the prefix is a reverse SSO component, or is possibly + -- If the prefix is a reverse SSO object, or is possibly -- unaligned, first create a temporary copy that is in -- native SSO, and properly aligned. Make it Volatile to -- prevent folding in the back-end. Note that we use an @@ -8426,7 +8426,7 @@ package body Exp_Attr is -- that case it cannot be copied using a floating point -- register. - if In_Reverse_Storage_Order_Object (Pref) + if Is_Reverse_Storage_Order_Object (Pref) or else Is_Possibly_Unaligned_Object (Pref) then declare diff --git a/gcc/ada/sem_util.adb b/gcc/ada/sem_util.adb index 96839b8bf172..8080125dda9b 100644 --- a/gcc/ada/sem_util.adb +++ b/gcc/ada/sem_util.adb @@ -15091,28 +15091,6 @@ package body Sem_Util is return False; end In_Return_Value; - ------------------------------------- - -- In_Reverse_Storage_Order_Object -- - ------------------------------------- - - function In_Reverse_Storage_Order_Object (N : Node_Id) return Boolean is - Pref : Node_Id; - Btyp : Entity_Id; - - begin - if Nkind (N) in N_Indexed_Component | N_Selected_Component then - Pref := Prefix (N); - Btyp := Base_Type (Etype (Pref)); - - return Present (Btyp) - and then (Is_Record_Type (Btyp) or else Is_Array_Type (Btyp)) - and then Reverse_Storage_Order (Btyp); - - else - return False; - end if; - end In_Reverse_Storage_Order_Object; - ------------------------------ -- In_Same_Declarative_Part -- ------------------------------ @@ -21720,6 +21698,34 @@ package body Sem_Util is return False; end Is_Renamed_Entry; + ------------------------------------- + -- Is_Reverse_Storage_Order_Object -- + ------------------------------------- + + function Is_Reverse_Storage_Order_Object (N : Node_Id) return Boolean is + Btyp : Entity_Id; + + begin + if not Is_Elementary_Type (Etype (N)) then + return False; + end if; + + case Nkind (N) is + when N_Indexed_Component | N_Selected_Component => + Btyp := Base_Type (Etype (Prefix (N))); + + when N_Unchecked_Type_Conversion => + Btyp := Base_Type (Etype (Expression (N))); + + when others => + return False; + end case; + + return Present (Btyp) + and then (Is_Record_Type (Btyp) or else Is_Array_Type (Btyp)) + and then Reverse_Storage_Order (Btyp); + end Is_Reverse_Storage_Order_Object; + ---------------------------- -- Is_Reversible_Iterator -- ---------------------------- diff --git a/gcc/ada/sem_util.ads b/gcc/ada/sem_util.ads index c10900e8c7a3..bf76dc96fbf2 100644 --- a/gcc/ada/sem_util.ads +++ b/gcc/ada/sem_util.ads @@ -1767,10 +1767,6 @@ package Sem_Util is -- the return value and have its accessibility level tied to that of the -- result of the enclosing function. - function In_Reverse_Storage_Order_Object (N : Node_Id) return Boolean; - -- Returns True if N denotes a component in an array or a record that has - -- Reverse_Storage_Order. - function In_Same_Declarative_Part (Context : Node_Id; N : Node_Id) return Boolean; @@ -2501,6 +2497,11 @@ package Sem_Util is function Is_Renamed_Entry (Proc_Nam : Entity_Id) return Boolean; -- Return True if Proc_Nam is a procedure renaming of an entry + function Is_Reverse_Storage_Order_Object (N : Node_Id) return Boolean; + -- Return True if N denotes an elementary component of an array or record + -- that has Reverse_Storage_Order set, or an unchecked conversion to an + -- elementary type of such an array or record. + function Is_Reversible_Iterator (Typ : Entity_Id) return Boolean; -- AI05-0139-2: Check whether Typ is derived from the predefined interface -- Ada.Iterator_Interfaces.Reversible_Iterator. From a36191dfb6c4107985418e16fe255a2b5fd925a7 Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Tue, 22 Sep 2026 21:44:13 +0200 Subject: [PATCH 350/584] Ada: Make error messages for static accessibility checks more consistent This attempts to make the various error messages given for failed static accessibility checks more consistent, by using a consistent "accessibility level of X is to deep" or "X has deeper accessibility level than" wording, augmented by a reference to the relevant rule of the Ada Reference Manual (latest version, in other words Ada 2022 with Amendment 1, when the rule is still present, otherwise the last version where the rule was present). The only exception is for illegal 'Access attribute references, where the existing "nonlocal access vs local object" viewpoint is preserved. gcc/ada/ * accessibility.adb (Accessibility_Message): Adjust wording. (Check_Return_Construct_Accessibility.Accessibility_Error): Ditto. * sem_attr.adb (Resolve_Attribute) : Likewise for the specific error message given for subprograms. * sem_ch3.adb (Analyze_Component_Declaration): Likewise for the specific error message given for access components. (Build_Derived_Record_Type): Add references to Ada 95 rules. * sem_ch6.adb (Analyze_Function_Return): Adjust wording for the error messages given for class-wide returns. * sem_ch9.adb (Analyze_Requeue): Likewise for requeue statements. * sem_ch13.adb (Analyze_Attribute_Definition_Clause) : Add reference to Ada 2012 accessibility rule. * sem_res.adb (Resolve_Actuals.Check_Aliased_Parameter): Adjust wording for the error messages for actuals of aliased parameters. (Resolve_Allocator): Likewise for allocators. (Valid_Conversion): Likewise for conversions. (Valid_Array_Conversion): Add Opnd_Type parameter instead of using an up-level reference. gcc/testsuite/ * gnat.dg/access12.adb: Adjust error message. * gnat.dg/aliased3.adb: Likewise. --- gcc/ada/accessibility.adb | 21 ++++--- gcc/ada/sem_attr.adb | 3 +- gcc/ada/sem_ch13.adb | 2 +- gcc/ada/sem_ch3.adb | 30 ++++++---- gcc/ada/sem_ch6.adb | 23 ++++--- gcc/ada/sem_ch9.adb | 3 +- gcc/ada/sem_res.adb | 96 ++++++++++++++---------------- gcc/testsuite/gnat.dg/access12.adb | 2 +- gcc/testsuite/gnat.dg/aliased3.adb | 4 +- 9 files changed, 94 insertions(+), 90 deletions(-) diff --git a/gcc/ada/accessibility.adb b/gcc/ada/accessibility.adb index 42092bebbf92..852b57e41dfd 100644 --- a/gcc/ada/accessibility.adb +++ b/gcc/ada/accessibility.adb @@ -188,9 +188,12 @@ package body Accessibility is --------------------------- procedure Accessibility_Message (N : Node_Id; Typ : Entity_Id) is - Loc : constant Source_Ptr := Sloc (N); - P : constant Node_Id := Prefix (N); - Indic : Node_Id := Parent (Parent (N)); + Loc : constant Source_Ptr := Sloc (N); + P : constant Node_Id := Prefix (N); + Msg : constant String := + "nonlocal access value cannot designate local object (RM 3.10.2(28))"; + + Indic : Node_Id; begin -- In an instance, this is a runtime check, but one we know will fail, @@ -201,8 +204,7 @@ package body Accessibility is Error_Msg_Warn := SPARK_Mode /= On and then not No_Dynamic_Accessibility_Checks_Enabled (P); - Error_Msg_F - ("non-local pointer cannot point to local object<<", P); + Error_Msg_F (Msg & "<<", P); Error_Msg_F ("\Program_Error [<<", P); Rewrite (N, Make_Raise_Program_Error (Loc, @@ -210,7 +212,7 @@ package body Accessibility is Set_Etype (N, Typ); else - Error_Msg_F ("non-local pointer cannot point to local object", P); + Error_Msg_F (Msg, P); -- Check for case where we have a missing access definition @@ -2071,10 +2073,11 @@ package body Accessibility is procedure Accessibility_Error is Suffix : constant String := (if Is_Expression_Function_Or_Completion (Scope_Id) - then "in expression function" - else "in return"); + then " in expression function (RM 6.8(5))" + else " in return (RM 6.5(5.9))"); Message : constant String := - "level of type of access discriminant is too deep " & Suffix; + "accessibility level of access discriminant is too deep" + & Suffix; begin -- In an instance, this is a runtime check, but one we know will fail diff --git a/gcc/ada/sem_attr.adb b/gcc/ada/sem_attr.adb index d711b45f13cc..2814c2c1a895 100644 --- a/gcc/ada/sem_attr.adb +++ b/gcc/ada/sem_attr.adb @@ -12215,7 +12215,8 @@ package body Sem_Attr is > Static_Type_Access_Level (Btyp) then Error_Msg_F - ("subprogram must not be deeper than access type", P); + ("nonlocal access value cannot designate local" + & " subprogram (RM 3.10.2(32))", P); -- Check the restriction of 3.10.2(32) that disallows the -- access attribute within a generic body when the ultimate diff --git a/gcc/ada/sem_ch13.adb b/gcc/ada/sem_ch13.adb index d648da2f55e7..837f662b7b45 100644 --- a/gcc/ada/sem_ch13.adb +++ b/gcc/ada/sem_ch13.adb @@ -8170,7 +8170,7 @@ package body Sem_Ch13 is then Error_Msg_N ("subpool access type has deeper accessibility " - & "level than pool", Ent); + & "level than pool (RM 13.11.4(23))", Ent); return; end if; diff --git a/gcc/ada/sem_ch3.adb b/gcc/ada/sem_ch3.adb index c204fe6ea052..9aec12d24a70 100644 --- a/gcc/ada/sem_ch3.adb +++ b/gcc/ada/sem_ch3.adb @@ -2142,15 +2142,15 @@ package body Sem_Ch3 is ("access to specific tagged type required (RM 3.9.2(9))", E); end if; - -- (Ada 2005: AI-230): Accessibility check for anonymous + -- Ada 2005 (AI-230): Accessibility check for anonymous -- components if Static_Type_Access_Level (Etype (E)) > Static_Type_Access_Level (T, Deepest => True) then Error_Msg_N - ("expression has deeper access level than component " & - "(RM 3.10.2 (12.2))", E); + ("expression has deeper accessibility level than component" + & " (RM 3.10.2(12.2))", E); end if; -- The initialization expression is a reference to an access @@ -2163,8 +2163,8 @@ package body Sem_Ch3 is and then Present (Discriminal_Link (Entity (E))) then Error_Msg_N - ("discriminant has deeper accessibility level than target", - E); + ("access discriminant has deeper accessibility level than" + & " component (RM 3.10.2(12.2))", E); end if; end if; end if; @@ -9762,31 +9762,37 @@ package body Sem_Ch3 is if Ada_Version >= Ada_2005 then Check_Generic_Ancestors; + -- In Ada 95, the accessibility level of a record extension cannot + -- be deeper than that of its parent type. + elsif Static_Type_Access_Level (Derived_Type) - /= Static_Type_Access_Level (Parent_Type) + > Static_Type_Access_Level (Parent_Type) and then not Is_Generic_Type (Derived_Type) then if Is_Controlled (Parent_Type) then Error_Msg_N - ("controlled type must be declared at the library level", - Indic); + ("controlled type must be declared at the library level" + & " (RM 3.9.1(3))", Indic); else Error_Msg_N - ("type extension at deeper accessibility level than parent", - Indic); + ("type extension at deeper accessibility level than parent" + & " (RM 3.9.1(3))", Indic); end if; + -- In Ada 95, a type extension cannot be declared in a generic body + -- if the parent type is declared outside that body. + else declare GB : constant Node_Id := Enclosing_Generic_Body (Derived_Type); + begin if Present (GB) and then GB /= Enclosing_Generic_Body (Parent_Base) then Error_Msg_NE ("parent type of& must not be outside generic body" - & " (RM 3.9.1(4))", - Indic, Derived_Type); + & " (RM 3.9.1(4))", Indic, Derived_Type); end if; end; end if; diff --git a/gcc/ada/sem_ch6.adb b/gcc/ada/sem_ch6.adb index 76da204abcf4..80bc657eadea 100644 --- a/gcc/ada/sem_ch6.adb +++ b/gcc/ada/sem_ch6.adb @@ -1094,17 +1094,15 @@ package body Sem_Ch6 is -- If the result type is class-wide, then check that the return -- expression's type is not declared at a deeper level than the - -- function (RM05-6.5(5.6/2)). + -- function (RM 6.5(5.8)). - if Ada_Version >= Ada_2005 - and then Is_Class_Wide_Type (R_Type) - then + if Ada_Version >= Ada_2005 and then Is_Class_Wide_Type (R_Type) then if Static_Type_Access_Level (Etype (Expr)) > Static_Subprogram_Access_Level (Scope_Id) then Error_Msg_N - ("level of return expression type is deeper than " - & "class-wide function!", Expr); + ("type of return expression has deeper accessibility level" + & " than class-wide function (RM 6.5(5.8))", Expr); end if; end if; @@ -1117,9 +1115,8 @@ package body Sem_Ch6 is Related_Nod => N); end if; - -- Perform static accessibility checks for cases involving - -- dereferences of access parameters. Runtime accessibility checks - -- get generated elsewhere. + -- Perform a static accessibility check for return-by-reference + -- of limited types in Ada 95 or if -gnatd.l is in effect. if (Ada_Version < Ada_2005 or else Debug_Flag_Dot_L) and then Is_Inherently_Limited_Type (Etype (Scope_Id)) @@ -1155,16 +1152,16 @@ package body Sem_Ch6 is Reason => CE_Null_Not_Allowed); end if; - -- RM 6.5 (5.4/3): accessibility checks also apply if the return object - -- has no initializing expression. + -- The above accessibility check in Ada 2005 also applies if the return + -- object has no initializing expression (RM 6.5(5.5)). elsif Ada_Version > Ada_2005 and then Is_Class_Wide_Type (R_Type) then if Static_Type_Access_Level (Etype (Defining_Identifier (Obj_Decl))) > Static_Subprogram_Access_Level (Scope_Id) then Error_Msg_N - ("level of return expression type is deeper than " - & "class-wide function!", Obj_Decl); + ("type of return object has deeper accessibility level" + & " than class-wide function (RM 6.5(5.5))", Obj_Decl); end if; end if; end Analyze_Function_Return; diff --git a/gcc/ada/sem_ch9.adb b/gcc/ada/sem_ch9.adb index ce8fe01f463a..6c9f7b876369 100644 --- a/gcc/ada/sem_ch9.adb +++ b/gcc/ada/sem_ch9.adb @@ -2468,7 +2468,8 @@ package body Sem_Ch9 is > Static_Local_Access_Level (Enclosing) then Error_Msg_N - ("target object has invalid level for requeue", Target_Obj); + ("accessibility level of target object is too deep for requeue" + & " (RM 9.5.4(6))", Target_Obj); end if; end if; diff --git a/gcc/ada/sem_res.adb b/gcc/ada/sem_res.adb index e862a8b7e784..c124b6d0e3d3 100644 --- a/gcc/ada/sem_res.adb +++ b/gcc/ada/sem_res.adb @@ -3716,8 +3716,9 @@ package body Sem_Res is procedure Accessibility_Error (S : String) is begin - Error_Msg_NE ("actual for aliased formal& has wrong accessibility" - & " in " & S & " (RM 6.4.1(6.4))", A, F); + Error_Msg_NE + ("accessibility level of actual is too deep for aliased formal&" + & " in " & S & " (RM 6.4.1(6.4))", A, F); end Accessibility_Error; begin @@ -5366,9 +5367,11 @@ package body Sem_Res is Prefix : constant String := (if Nkind (Exp) = N_Attribute_Reference then "prefix of attribute" - else "type of access discriminant"); + else "access discriminant"); Message : constant String := - Prefix & " has deeper level than allocator type"; + Prefix + & " has deeper accessibility level than allocator type" + & " (RM 4.8(5.3))"; begin -- In an instance, this is a runtime check, but one we know will fail @@ -5719,10 +5722,12 @@ package body Sem_Res is -- the case of an initialized allocator with a class-wide argument (see -- Expand_Allocator_Expression). - if Ada_Version >= Ada_2005 - and then Is_Class_Wide_Type (Desig_T) - then + if Ada_Version >= Ada_2005 and then Is_Class_Wide_Type (Desig_T) then declare + Message : constant String := + "allocated type has deeper accessibility level than allocator" + & " type (RM 4.8(5.2))"; + Exp_Typ : Entity_Id; begin @@ -5739,9 +5744,7 @@ package body Sem_Res is then if In_Instance_Body then Error_Msg_Warn := SPARK_Mode /= On; - Error_Msg_N - ("type in allocator has deeper level than designated " - & "class-wide type<<", E); + Error_Msg_N (Message & "<<", E); Error_Msg_N ("\Program_Error [<<", E); Rewrite (N, @@ -5757,9 +5760,7 @@ package body Sem_Res is elsif not Is_Generic_Type (Exp_Typ) and then not In_Generic_Formal_Package (Exp_Typ) then - Error_Msg_N - ("type in allocator has deeper level than designated " - & "class-wide type", E); + Error_Msg_N (Message, E); end if; end if; end; @@ -13621,9 +13622,9 @@ package body Sem_Res is Operand : Node_Id; Report_Errs : Boolean := True) return Boolean is - Target_Type : constant Entity_Id := Base_Type (Target); - Opnd_Type : Entity_Id; - Inc_Ancestor : Entity_Id; + Message : constant String := + " has deeper accessibility level than target type (RM 4.6(24.21))"; + Target_Type : constant Entity_Id := Base_Type (Target); function Conversion_Check (Valid : Boolean; @@ -13648,7 +13649,7 @@ package body Sem_Res is -- discriminant selected from a dereference of another such "bad" -- conversion argument. - function Valid_Array_Conversion return Boolean; + function Valid_Array_Conversion (Opnd_Type : Entity_Id) return Boolean; -- Check index and component conformance, and accessibility levels if -- the component types are anonymous access types (Ada 2005). @@ -13790,7 +13791,7 @@ package body Sem_Res is -- Valid_Array_Conversion -- ---------------------------- - function Valid_Array_Conversion return Boolean is + function Valid_Array_Conversion (Opnd_Type : Entity_Id) return Boolean is Opnd_Comp_Type : constant Entity_Id := Component_Type (Opnd_Type); Opnd_Comp_Base : constant Entity_Id := Base_Type (Opnd_Comp_Type); @@ -13870,8 +13871,8 @@ package body Sem_Res is if In_Instance_Body then Error_Msg_Warn := SPARK_Mode /= On; Report_Error_N - ("source array type has deeper accessibility " - & "level than target<<", Operand, Report_Errs); + ("operand array type" & Message & "<<", + Operand, Report_Errs); Report_Error_N ("\Program_Error [<<", Operand, Report_Errs); Rewrite (N, @@ -13884,13 +13885,9 @@ package body Sem_Res is else Report_Error_N - ("source array type has deeper accessibility " - & "level than target", Operand, Report_Errs); + ("operand array type" & Message, Operand, Report_Errs); return False; end if; - - else - null; end if; -- All other cases where component base types do not match @@ -13920,6 +13917,11 @@ package body Sem_Res is return True; end Valid_Array_Conversion; + -- Local variables + + Inc_Ancestor : Entity_Id; + Opnd_Type : Entity_Id; + -- Start of processing for Valid_Conversion begin @@ -14015,7 +14017,7 @@ package body Sem_Res is return False; else - return Valid_Array_Conversion; + return Valid_Array_Conversion (Opnd_Type); end if; -- Ada 2005 (AI-251): Internally generated conversions of access to @@ -14083,16 +14085,14 @@ package body Sem_Res is end if; end; - -- Check the static accessibility rule of 4.6(17). Note that the - -- check is not enforced when within an instance body, since the - -- RM requires such cases to be caught at run time. - - -- If the operand is a rewriting of an allocator no check is needed + -- If the operand is a rewriting of an allocator, no check is needed -- because there are no accessibility issues. if Nkind (Original_Node (N)) = N_Allocator then null; + -- Otherwise, check the static accessibility rules of 4.6(24.11-21) + elsif Ekind (Target_Type) /= E_Anonymous_Access_Type or else Is_Local_Anonymous_Access (Target_Type) or else Nkind (Associated_Node_For_Itype (Target_Type)) = @@ -14137,8 +14137,7 @@ package body Sem_Res is (Target_Type, Deepest => True) then Report_Error_N - ("operand has deeper level than target", Operand, - Report_Errs); + ("operand type" & Message, Operand, Report_Errs); return False; end if; @@ -14151,7 +14150,8 @@ package body Sem_Res is then Report_Error_N ("implicit conversion of stand-alone anonymous " - & "access object not allowed", Operand, Report_Errs); + & "access object not allowed (RM 8.6(27.1))", + Operand, Report_Errs); return False; -- Implicit conversions aren't allowed for anonymous access @@ -14166,7 +14166,7 @@ package body Sem_Res is then Report_Error_N ("implicit conversion of anonymous access parameter " - & "not allowed", Operand, Report_Errs); + & "not allowed (RM 8.6(27.1))", Operand, Report_Errs); return False; -- Detect access discriminant values that are illegal @@ -14176,20 +14176,19 @@ package body Sem_Res is then Report_Error_N ("implicit conversion of anonymous access value " - & "not allowed", Operand, Report_Errs); + & "not allowed (RM 8.6(27.1))", Operand, Report_Errs); return False; - -- In other cases, the level of the operand's type must be - -- statically less deep than that of the target type, else - -- implicit conversion is disallowed (by RM12-8.6(27.1/3)). + -- In other cases, the level of the operand type must not + -- be statically deeper than that of the target type. elsif Static_Type_Access_Level (Opnd_Type) > Static_Type_Access_Level (Target_Type, Deepest => True) then Report_Error_N - ("implicit conversion of anonymous access value " - & "violates accessibility", Operand, Report_Errs); + ("anonymous access type" & Message, + Operand, Report_Errs); return False; end if; end if; @@ -14227,7 +14226,7 @@ package body Sem_Res is if In_Instance_Body then Error_Msg_Warn := SPARK_Mode /= On; Report_Error_N - ("cannot convert local pointer to non-local access type<<", + ("operand type" & Message & "<<", Operand, Report_Errs); Report_Error_N ("\Program_Error [<<", Operand, Report_Errs); Rewrite (N, @@ -14243,8 +14242,7 @@ package body Sem_Res is if not Error_Posted (N) then Report_Error_N - ("cannot convert local pointer to non-local access type", - Operand, Report_Errs); + ("operand type" & Message, Operand, Report_Errs); end if; return False; end if; @@ -14271,8 +14269,8 @@ package body Sem_Res is if In_Instance_Body then Error_Msg_Warn := SPARK_Mode /= On; Report_Error_N - ("cannot convert access discriminant to non-local " - & "access type<<", Operand, Report_Errs); + ("access discriminant" & Message & "<<", + Operand, Report_Errs); Report_Error_N ("\Program_Error [<<", Operand, Report_Errs); Rewrite (N, @@ -14285,8 +14283,7 @@ package body Sem_Res is else Report_Error_N - ("cannot convert access discriminant to non-local " - & "access type", Operand, Report_Errs); + ("access discriminant" & Message, Operand, Report_Errs); return False; end if; end if; @@ -14303,8 +14300,7 @@ package body Sem_Res is and then Present (Discriminal_Link (Entity (Operand))) then Report_Error_N - ("discriminant has deeper accessibility level than target", - Operand, Report_Errs); + ("access discriminant" & Message, Operand, Report_Errs); return False; end if; end if; diff --git a/gcc/testsuite/gnat.dg/access12.adb b/gcc/testsuite/gnat.dg/access12.adb index 5820b91deb29..3c12b9562c58 100644 --- a/gcc/testsuite/gnat.dg/access12.adb +++ b/gcc/testsuite/gnat.dg/access12.adb @@ -19,7 +19,7 @@ begin if I = 1 then X := 0; end if; - A := R.Element.all'Access; -- { dg-error "non-local pointer" } + A := R.Element.all'Access; -- { dg-error "nonlocal access" } X := I; end; end loop; diff --git a/gcc/testsuite/gnat.dg/aliased3.adb b/gcc/testsuite/gnat.dg/aliased3.adb index 16355a909134..726dc03edb82 100644 --- a/gcc/testsuite/gnat.dg/aliased3.adb +++ b/gcc/testsuite/gnat.dg/aliased3.adb @@ -12,7 +12,7 @@ begin R : aliased Integer := 123; Y : access constant Integer; begin - Y := F (R); -- { dg-bogus "wrong accessibility in assignment" } - X := F (R); -- { dg-error "wrong accessibility in assignment" } + Y := F (R); -- { dg-bogus "too deep for aliased formal" } + X := F (R); -- { dg-error "too deep for aliased formal" } end; end; From 13a8d18fdbb15ed4669e59f50b0af7b67832cb18 Mon Sep 17 00:00:00 2001 From: "James K. Lowden" Date: Thu, 17 Sep 2026 12:15:47 -0400 Subject: [PATCH 351/584] cobol: Recognize figurative constants for implicit PICTURE. gcc/cobol/ChangeLog: * parse_ante.h (update_prior_invalid_field): Use is_figconst. (field_add): Always call update_prior_invalid_field. --- gcc/cobol/parse_ante.h | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/gcc/cobol/parse_ante.h b/gcc/cobol/parse_ante.h index df48210d6b60..2dbf02eac632 100644 --- a/gcc/cobol/parse_ante.h +++ b/gcc/cobol/parse_ante.h @@ -3333,7 +3333,7 @@ update_prior_invalid_field( const cbl_field_t *field = nullptr) { if( ! field ) field = f; // fake it if( field->level <= f->level ) { if( f->type == FldInvalid && f->data.has_initial_value() ) { - if( f->has_attr(quoted_e) ) { + if( f->has_attr(quoted_e) || is_figconst(f) ) { f->type = FldAlphanumeric; assert(0 < f->char_capacity()); } @@ -3376,9 +3376,10 @@ field_add( const cbl_loc_t& loc, cbl_field_t *field ) { return NULL; break; } - } else { - update_prior_invalid_field(field); - } + } + + update_prior_invalid_field(field); + return field; } From 5a9ed40577701e9374ce2130d7220fa64923b53f Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Mon, 21 Sep 2026 22:51:09 +0200 Subject: [PATCH 352/584] cobol: Fix CBL_GET_PROGRAM_INFO function 2 The previous logic assumed that function 2 only returned the status information and program name for the program associated by cblte-gpi-handle. However, the documentation states function 2 must return the information from the caller program instead, also updating cblte-gpi-handle. [1] Therefore, the previous logic was flawed. For example, assuming program D allocates cblte-gpi-handle by calling function 0, and given the following call stack: A -> B -> C -> D It is then possible for function G, under the following call stack, to extract the call stack for D, one call to CBL_GET_PROGRAM_INFO at a time: A -> E -> F -> G Therefore, function 2 would return the information from function C on the first call, then F and so on, until returning a non-zero status code. [1]: https://docs.rocketsoftware.com/bundle/visualcoboldevhub_ug_110/page/lxm1742952203519.html libgcobol/ChangeLog: * compat/gnu/lib/cbl_gpi.cc (struct gpi_priv): Fix flawed logic. (getlastprog): Likewise. (callstack): Likewise. (cbl_gpi_cur_status): Likewise. (cbl_gpi_handle_status): Likewise. (cbl_gpi_parent_status): Likewise. (cbl_gpi_close_handle): Likewise. gcc/testsuite/ChangeLog: * cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.cob: Update test to new behaviour. * cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.out: Likewise. --- ..._get_program_name_-_functions_0_and_2_.cob | 99 +++++++++++++------ ..._get_program_name_-_functions_0_and_2_.out | 8 +- libgcobol/compat/gnu/lib/cbl_gpi.cc | 42 ++++---- 3 files changed, 99 insertions(+), 50 deletions(-) diff --git a/gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.cob b/gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.cob index 5b2f160397e8..f26b70f39c27 100644 --- a/gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.cob +++ b/gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.cob @@ -4,41 +4,65 @@ *> { dg-output-file "group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.out" } copy "cblproto.cpy". + identification division. program-id. prog. data division. working-storage section. copy "cbltypes.cpy". - 01 param-block type cblt-prog-info-params value zeros. + 01 param-block type cblt-prog-info-params. + procedure division. + display "calling a from prog". + call "a" using param-block. + display "calling c from prog". + call "c" using param-block. + end program prog. + + identification division. + program-id. a. + data division. + linkage section. + copy "cbltypes.cpy". + 01 param-block type cblt-prog-info-params. + procedure division using param-block. + display "calling b from a". + call "b" using param-block. + end program a. + + identification division. + program-id. c. + data division. + working-storage section. 77 fn pic x(4) comp-5. - 77 status-code pic x(2) comp-5. + 77 status-code pic x(2) comp-5 value 0. 77 buf pic x(128). 77 buflen pic x(4) comp-5. - procedure division. - move length of param-block to cblte-gpi-size. - - * allocate handle - move 7 to cblte-gpi-flags. - move 0 to fn. + linkage section. + copy "cbltypes.cpy". + 01 param-block type cblt-prog-info-params. + procedure division using param-block. move length of buf to buflen. - call "CBL_GET_PROGRAM_INFO" using - by value fn - by reference param-block - buf - buflen - returning status-code. - - if status-code <> 0 - display "CBL_GET_PROGRAM_INFO failed with " status-code - goback - end-if. + perform until status-code <> 0 + * retrieve program name from handle + move 6 to cblte-gpi-flags + move 2 to fn + move x"00" to buf + call "CBL_GET_PROGRAM_INFO" using + by value fn + by reference param-block + buf + buflen + returning status-code - display "buf is '" buf "'". + if status-code = 0 + display "buf from c is '" buf "'" + end-if + end-perform. - * retrieve program name from handle - move 6 to cblte-gpi-flags. - move 2 to fn. - move x"00" to buf. + close-handle section. + * close handle + move 0 to cblte-gpi-flags. + move 3 to fn. call "CBL_GET_PROGRAM_INFO" using by value fn by reference param-block @@ -50,12 +74,27 @@ display "CBL_GET_PROGRAM_INFO failed with " status-code goback end-if. + end program c. - display "buf from handle is '" buf "'". + identification division. + program-id. b. + data division. + working-storage section. + copy "cbltypes.cpy". + 77 fn pic x(4) comp-5. + 77 status-code pic x(2) comp-5. + 77 buf pic x(128). + 77 buflen pic x(4) comp-5. + linkage section. + copy "cbltypes.cpy". + 01 param-block type cblt-prog-info-params. + procedure division using param-block. + move length of param-block to cblte-gpi-size. - * close handle - move 0 to cblte-gpi-flags. - move 3 to fn. + * allocate handle + move 7 to cblte-gpi-flags. + move 0 to fn. + move length of buf to buflen. call "CBL_GET_PROGRAM_INFO" using by value fn by reference param-block @@ -67,5 +106,7 @@ display "CBL_GET_PROGRAM_INFO failed with " status-code goback end-if. - end program prog. + + display "buf from b is '" buf "'". + end program b. diff --git a/gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.out b/gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.out index c86d093d7678..deb2631b3ce3 100644 --- a/gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.out +++ b/gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.out @@ -1,3 +1,7 @@ -buf is 'prog' -buf from handle is 'prog' +calling a from prog +calling b from a +buf from b is 'b' +calling c from prog +buf from c is 'a' +buf from c is 'prog' diff --git a/libgcobol/compat/gnu/lib/cbl_gpi.cc b/libgcobol/compat/gnu/lib/cbl_gpi.cc index 5e02ac4bd584..7708767fad73 100644 --- a/libgcobol/compat/gnu/lib/cbl_gpi.cc +++ b/libgcobol/compat/gnu/lib/cbl_gpi.cc @@ -39,8 +39,13 @@ struct gpi_priv { - gpi_priv(const std::string &name) : name(name){} - std::string name; + gpi_priv(const std::vector &callstack) : + callstack(callstack), + it(this->callstack.crbegin()) + { + } + const std::vector callstack; + std::vector::const_reverse_iterator it; }; /* From the COBOL side, we add no padding bytes at all for groups. */ @@ -98,13 +103,13 @@ enum cbl_backtrace_flags CBL_BACKTRACE_DATA31 = 1 << 24 }; -static std::string -getlastprog() +static std::vector +callstack() { const std::vector &__gg__get_module_names(), &names = __gg__get_module_names(); const char *s = NULL; - std::string ret; + std::vector ret; for (const auto &name : names) { @@ -113,14 +118,11 @@ getlastprog() const char *cname = name.c_str() + 1; if (strcasecmp(cname, "CBL_GET_PROGRAM_INFO")) - s = cname; + ret.push_back(cname); else break; } - if (s) - ret = s; - return ret; } @@ -141,15 +143,15 @@ setbasename(const std::string &src, const gpi_param_t &p, char *dst, unsigned n) int16_t cbl_gpi_cur_status(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) { - std::string prog = getlastprog(); + std::vector cs = callstack(); - if (prog.empty()) + if (cs.empty()) return -1; else if (params.flags & GPI_PARAM_RET_BASENAME) - setbasename(prog, params, buf.basename, buflen); + setbasename(cs.back(), params, buf.basename, buflen); if (params.flags & GPI_PARAM_RET_HANDLE) - params.handle = new gpi_priv(prog); + params.handle = new gpi_priv(cs); /* TODO: set status bits */ return 0; @@ -165,12 +167,14 @@ cbl_gpi_named_status(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) } int16_t -cbl_gpi_handle_status(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) +cbl_gpi_parent_status(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) { - const gpi_priv *prv = static_cast(params.handle); + gpi_priv *prv = params.handle; - if (params.flags & GPI_PARAM_RET_BASENAME) - setbasename(prv->name.c_str(), params, buf.basename, buflen); + if (prv->it + 1 >= prv->callstack.crend()) + return -1; + else if (params.flags & GPI_PARAM_RET_BASENAME) + setbasename(*++prv->it, params, buf.basename, buflen); /* TODO: set status bits */ return 0; @@ -179,7 +183,7 @@ cbl_gpi_handle_status(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) int16_t cbl_gpi_close_handle(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) { - delete static_cast(params.handle); + delete params.handle; /* TODO: set status bits */ return 0; } @@ -254,7 +258,7 @@ static const struct func }, { - cbl_gpi_handle_status, + cbl_gpi_parent_status, GPI_PARAM_RET_BASENAME | GPI_PARAM_RET_PRGATTR | GPI_PARAM_NULL_TERM | GPI_PARAM_ALL_PROG, GPI_PARAM_RET_HANDLE From 45e402c8ad5cd260d1fe34ae27630625fc8ee098 Mon Sep 17 00:00:00 2001 From: Chung-Lin Tang Date: Tue, 22 Sep 2026 20:53:47 +0000 Subject: [PATCH 353/584] OpenMP: Implement local clause for declare target This patch implements the local clause for omp declare target. The main effect is to avoid adding such 'local' variables to offload_vars in the middle/front ends. This effectively creates non-associated versions of the variable on the host/accel device. This is tested by modifying/returning the local-clause variable on the GPU, and testing if "omp target update" does NOT work. Internally, this is represented as an extension of the existing "omp declare target" attribute, with an additional "local" argument into TREE_VALUE(DECL_ATTRIBUTES(var)). This allows value_member() to work as expected when testing if "local" exists, while handling is the same as "omp declare target" in most places. gcc/c-family/ChangeLog: * c-pragma.h (enum pragma_omp_clause): Add PRAGMA_OMP_CLAUSE_LOCAL. gcc/c/ChangeLog: * c-parser.cc (c_parser_omp_clause_name): Add "local" case. (c_parser_omp_all_clauses): Add PRAGMA_OMP_CLAUSE_LOCAL case. (OMP_DECLARE_TARGET_CLAUSE_MASK): Add PRAGMA_OMP_CLAUSE_LOCAL. ( c_parser_omp_declare_target): Handle OMP_CLAUSE_LOCAL. * c-typeck.cc (c_finish_omp_clauses): Handle OMP_CLAUSE_LOCAL. Emit error if local clause variable appears in map clause. gcc/cp/ChangeLog: * parser.cc (cp_parser_omp_clause_name): Add "local" case. (cp_parser_omp_all_clauses): Add PRAGMA_OMP_CLAUSE_LOCAL case. (handle_omp_declare_target_clause): Handle OMP_CLAUSE_LOCAL. (OMP_DECLARE_TARGET_CLAUSE_MASK): Add PRAGMA_OMP_CLAUSE_LOCAL. * semantics.cc (finish_omp_clauses): Handle OMP_CLAUSE_LOCAL. Emit error if local clause variable appears in map clause. gcc/fortran/ChangeLog: * openmp.cc (gfc_match_omp_declare_target): Adjust error handling to handle local clause. * trans-common.cc (build_common_decl): Adjust handling of device_type clause, remove sorry and FIXME of LOCAL clause, handle local clause. * trans-decl.cc (add_attributes_to_decl): Adjust handling of device_type clause, remove sorry of LOCAL clause, adjust creating of "omp declare target [link]" attribute between OpenACC/OpenMP. gcc/ChangeLog: * omp-offload.cc (omp_discover_implicit_declare_target): For self_maps/unified_shared_memory case, adjust to not convert 'omp declare target local' variables to 'link'. * tree-core.h (enum omp_clause_code): Add OMP_CLAUSE_LOCAL. * tree.cc (omp_clause_num_ops): Add entry for OMP_CLAUSE_LOCAL. (omp_clause_code_name): Likewise. * varpool.cc (varpool_node::get_create): Do not add variable to offload_vars if "local" argument is present in "omp declare target". gcc/testsuite/ChangeLog: * c-c++-common/gomp/declare-target-1.c: Add local clause test. * c-c++-common/gomp/declare-target-8.c: New testcase. * gfortran.dg/gomp/declare-target-1.f90: Add local clause test. * gfortran.dg/gomp/declare-target-7.f90: New testcase. * gfortran.dg/gomp/groupprivate-2.f90: Adjust test. libgomp/ChangeLog: * testsuite/libgomp.c-c++-common/declare-target-local-1.c: New test. * testsuite/libgomp.c-c++-common/declare-target-local-2.c: New test. * testsuite/libgomp.c-c++-common/declare-target-local-3.c: New test. * testsuite/libgomp.c-c++-common/declare-target-local-4.c: New test. * testsuite/libgomp.fortran/declare-target-local-1.f90: New test. --- gcc/c-family/c-pragma.h | 1 + gcc/c/c-parser.cc | 41 +++++++++++- gcc/c/c-typeck.cc | 17 +++++ gcc/cp/parser.cc | 40 ++++++++++- gcc/cp/semantics.cc | 17 +++++ gcc/fortran/openmp.cc | 18 ++--- gcc/fortran/trans-common.cc | 32 ++++----- gcc/fortran/trans-decl.cc | 67 +++++++++++++------ gcc/omp-offload.cc | 9 ++- .../c-c++-common/gomp/declare-target-1.c | 2 + .../c-c++-common/gomp/declare-target-8.c | 29 ++++++++ .../gfortran.dg/gomp/declare-target-1.f90 | 7 +- .../gfortran.dg/gomp/declare-target-7.f90 | 25 +++++++ .../gfortran.dg/gomp/groupprivate-2.f90 | 15 ++--- gcc/tree-core.h | 3 + gcc/tree.cc | 2 + gcc/varpool.cc | 8 ++- .../declare-target-local-1.c | 34 ++++++++++ .../declare-target-local-2.c | 56 ++++++++++++++++ .../declare-target-local-3.c | 3 + .../declare-target-local-4.c | 47 +++++++++++++ .../declare-target-local-1.f90 | 55 +++++++++++++++ 22 files changed, 467 insertions(+), 61 deletions(-) create mode 100644 gcc/testsuite/c-c++-common/gomp/declare-target-8.c create mode 100644 gcc/testsuite/gfortran.dg/gomp/declare-target-7.f90 create mode 100644 libgomp/testsuite/libgomp.c-c++-common/declare-target-local-1.c create mode 100644 libgomp/testsuite/libgomp.c-c++-common/declare-target-local-2.c create mode 100644 libgomp/testsuite/libgomp.c-c++-common/declare-target-local-3.c create mode 100644 libgomp/testsuite/libgomp.c-c++-common/declare-target-local-4.c create mode 100644 libgomp/testsuite/libgomp.fortran/declare-target-local-1.f90 diff --git a/gcc/c-family/c-pragma.h b/gcc/c-family/c-pragma.h index 5d28cb45c669..4d1afe93959d 100644 --- a/gcc/c-family/c-pragma.h +++ b/gcc/c-family/c-pragma.h @@ -141,6 +141,7 @@ enum pragma_omp_clause { PRAGMA_OMP_CLAUSE_LASTPRIVATE, PRAGMA_OMP_CLAUSE_LINEAR, PRAGMA_OMP_CLAUSE_LINK, + PRAGMA_OMP_CLAUSE_LOCAL, PRAGMA_OMP_CLAUSE_MAP, PRAGMA_OMP_CLAUSE_MERGEABLE, PRAGMA_OMP_CLAUSE_NOCONTEXT, diff --git a/gcc/c/c-parser.cc b/gcc/c/c-parser.cc index 3c7572b17b94..927aff6d5b8e 100644 --- a/gcc/c/c-parser.cc +++ b/gcc/c/c-parser.cc @@ -16592,6 +16592,8 @@ c_parser_omp_clause_name (c_parser *parser) result = PRAGMA_OMP_CLAUSE_LINEAR; else if (!strcmp ("link", p)) result = PRAGMA_OMP_CLAUSE_LINK; + else if (!strcmp ("local", p)) + result = PRAGMA_OMP_CLAUSE_LOCAL; break; case 'm': if (!strcmp ("map", p)) @@ -22530,6 +22532,11 @@ c_parser_omp_all_clauses (c_parser *parser, omp_clause_mask mask, = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_LINK, clauses); c_name = "link"; break; + case PRAGMA_OMP_CLAUSE_LOCAL: + clauses + = c_parser_omp_var_list_parens (parser, OMP_CLAUSE_LOCAL, clauses); + c_name = "local"; + break; case PRAGMA_OMP_CLAUSE_TO: if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINK)) != 0) { @@ -28877,6 +28884,7 @@ c_maybe_parse_omp_decl (tree decl, tree d) ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \ | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ENTER) \ | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINK) \ + | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LOCAL) \ | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE_TYPE) \ | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INDIRECT)) @@ -28946,6 +28954,11 @@ c_parser_omp_declare_target (c_parser *parser) error_at (OMP_CLAUSE_LOCATION (c), "%qD specified both in declare target % and %qs" " clauses", t, OMP_CLAUSE_ENTER_TO (c) ? "to" : "enter"); + else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LOCAL + || value_member (get_identifier ("local"), TREE_VALUE (at2))) + error_at (OMP_CLAUSE_LOCATION (c), + "%qD specified both in declare target % and " + "% clauses", t); else error_at (OMP_CLAUSE_LOCATION (c), "%qD specified both in declare target % and " @@ -28955,6 +28968,11 @@ c_parser_omp_declare_target (c_parser *parser) if (!at1) { DECL_ATTRIBUTES (t) = tree_cons (id, NULL_TREE, DECL_ATTRIBUTES (t)); + if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LOCAL) + TREE_VALUE (DECL_ATTRIBUTES (t)) + = tree_cons (NULL_TREE, get_identifier ("local"), + TREE_VALUE (DECL_ATTRIBUTES (t))); + if (TREE_CODE (t) != FUNCTION_DECL && !is_global_var (t)) continue; @@ -28965,11 +28983,32 @@ c_parser_omp_declare_target (c_parser *parser) if (ENABLE_OFFLOADING) { g->have_offload = true; - if (is_a (node)) + if (is_a (node) + && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_LOCAL) vec_safe_push (offload_vars, t); } } } + else + { + bool saw_local = value_member (get_identifier ("local"), + TREE_VALUE (at1)); + if (saw_local && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_ENTER) + { + error_at (OMP_CLAUSE_LOCATION (c), + "%qD specified both in declare target % and " + "%qs clauses", t, + OMP_CLAUSE_ENTER_TO (c) ? "to" : "enter"); + continue; + } + else if (!saw_local && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LOCAL) + { + error_at (OMP_CLAUSE_LOCATION (c), + "%qD specified both in declare target % and " + "% or % clauses", t); + continue; + } + } if (TREE_CODE (t) != FUNCTION_DECL) continue; if ((device_type & OMP_CLAUSE_DEVICE_TYPE_HOST) != 0) diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc index ed755ff0e50b..9b01f3daec9b 100644 --- a/gcc/c/c-typeck.cc +++ b/gcc/c/c-typeck.cc @@ -17807,6 +17807,22 @@ c_finish_omp_clauses (tree clauses, enum c_omp_region_type ort) remove = true; break; } + + tree attr; + if (DECL_P (t) + && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP + && (attr = lookup_attribute ("omp declare target", + DECL_ATTRIBUTES (t))) + && value_member (get_identifier ("local"), + TREE_VALUE (attr))) + { + error_at (OMP_CLAUSE_LOCATION (c), + "device-local variable %qD cannot appear " + "in map clause", t); + remove = true; + break; + } + /* OpenACC attach / detach clauses must be pointers. */ if (c_oacc_check_attachments (c)) { @@ -18001,6 +18017,7 @@ c_finish_omp_clauses (tree clauses, enum c_omp_region_type ort) case OMP_CLAUSE_ENTER: case OMP_CLAUSE_LINK: + case OMP_CLAUSE_LOCAL: t = OMP_CLAUSE_DECL (c); const char *cname; cname = omp_clause_code_name[OMP_CLAUSE_CODE (c)]; diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc index 9c4245bc3f5e..373d3358c25f 100644 --- a/gcc/cp/parser.cc +++ b/gcc/cp/parser.cc @@ -41577,6 +41577,8 @@ cp_parser_omp_clause_name (cp_parser *parser) result = PRAGMA_OMP_CLAUSE_LINEAR; else if (!strcmp ("link", p)) result = PRAGMA_OMP_CLAUSE_LINK; + else if (!strcmp ("local", p)) + result = PRAGMA_OMP_CLAUSE_LOCAL; break; case 'm': if (!strcmp ("map", p)) @@ -47269,6 +47271,10 @@ cp_parser_omp_all_clauses (cp_parser *parser, omp_clause_mask mask, clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_LINK, clauses); c_name = "link"; break; + case PRAGMA_OMP_CLAUSE_LOCAL: + clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_LOCAL, clauses); + c_name = "local"; + break; case PRAGMA_OMP_CLAUSE_TO: if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINK)) != 0) { @@ -54608,6 +54614,11 @@ handle_omp_declare_target_clause (tree c, tree t, int device_type, error_at (OMP_CLAUSE_LOCATION (c), "%qD specified both in declare target % and %qs" " clauses", t, OMP_CLAUSE_ENTER_TO (c) ? "to" : "enter"); + else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LOCAL + || value_member (get_identifier ("local"), TREE_VALUE (at2))) + error_at (OMP_CLAUSE_LOCATION (c), + "%qD specified both in declare target % and " + "% clauses", t); else error_at (OMP_CLAUSE_LOCATION (c), "%qD specified both in declare target % and " @@ -54617,6 +54628,11 @@ handle_omp_declare_target_clause (tree c, tree t, int device_type, if (!at1) { DECL_ATTRIBUTES (t) = tree_cons (id, NULL_TREE, DECL_ATTRIBUTES (t)); + if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LOCAL) + TREE_VALUE (DECL_ATTRIBUTES (t)) + = tree_cons (NULL_TREE, get_identifier ("local"), + TREE_VALUE (DECL_ATTRIBUTES (t))); + if (TREE_CODE (t) != FUNCTION_DECL && !is_global_var (t)) return true; @@ -54627,11 +54643,32 @@ handle_omp_declare_target_clause (tree c, tree t, int device_type, if (ENABLE_OFFLOADING) { g->have_offload = true; - if (is_a (node)) + if (is_a (node) + && OMP_CLAUSE_CODE (c) != OMP_CLAUSE_LOCAL) vec_safe_push (offload_vars, t); } } } + else + { + bool saw_local = value_member (get_identifier ("local"), + TREE_VALUE (at1)); + if (saw_local && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_ENTER) + { + error_at (OMP_CLAUSE_LOCATION (c), + "%qD specified both in declare target % and " + "%qs clauses", t, + OMP_CLAUSE_ENTER_TO (c) ? "to" : "enter"); + return false; + } + else if (!saw_local && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LOCAL) + { + error_at (OMP_CLAUSE_LOCATION (c), + "%qD specified both in declare target % and " + "% or % clauses", t); + return false; + } + } if (TREE_CODE (t) != FUNCTION_DECL) return true; if ((device_type & OMP_CLAUSE_DEVICE_TYPE_HOST) != 0) @@ -54682,6 +54719,7 @@ handle_omp_declare_target_clause (tree c, tree t, int device_type, ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \ | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ENTER) \ | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINK) \ + | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LOCAL) \ | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE_TYPE) \ | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INDIRECT)) diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc index 978838a050a4..f9f05eb09234 100644 --- a/gcc/cp/semantics.cc +++ b/gcc/cp/semantics.cc @@ -9611,6 +9611,22 @@ finish_omp_clauses (tree clauses, enum c_omp_region_type ort) remove = true; break; } + + tree attr; + if (DECL_P (t) + && OMP_CLAUSE_CODE (c) == OMP_CLAUSE_MAP + && (attr = lookup_attribute ("omp declare target", + DECL_ATTRIBUTES (t))) + && value_member (get_identifier ("local"), + TREE_VALUE (attr))) + { + error_at (OMP_CLAUSE_LOCATION (c), + "device-local variable %qD cannot appear " + "in map clause", t); + remove = true; + break; + } + /* OpenACC attach / detach clauses must be pointers. */ if (cp_oacc_check_attachments (c)) { @@ -9854,6 +9870,7 @@ finish_omp_clauses (tree clauses, enum c_omp_region_type ort) case OMP_CLAUSE_ENTER: case OMP_CLAUSE_LINK: + case OMP_CLAUSE_LOCAL: t = OMP_CLAUSE_DECL (c); const char *cname; cname = omp_clause_code_name[OMP_CLAUSE_CODE (c)]; diff --git a/gcc/fortran/openmp.cc b/gcc/fortran/openmp.cc index d49fa79b3b4f..a1e89e386fd1 100644 --- a/gcc/fortran/openmp.cc +++ b/gcc/fortran/openmp.cc @@ -6999,25 +6999,27 @@ gfc_match_omp_declare_target (void) gfc_error_now ("OMP DECLARE TARGET variable at %L is an " "element of a COMMON block", &n->where); else if (n->sym->attr.omp_groupprivate && list != OMP_LIST_LOCAL) - gfc_error_now ("List item %qs at %L not appear in the %qs clause " - "as it was previously specified in a GROUPPRIVATE " - "directive", n->sym->name, &n->where, + gfc_error_now ("List item %qs at %L should not appear in the %qs " + "clause, as it was previously specified in a " + "GROUPPRIVATE directive", n->sym->name, &n->where, list == OMP_LIST_LINK ? "link" : list == OMP_LIST_TO ? "to" : "enter"); else if (n->sym->mark) gfc_error_now ("Variable at %L mentioned multiple times in " "clauses of the same OMP DECLARE TARGET directive", &n->where); - else if ((n->sym->attr.omp_declare_target_link - || n->sym->attr.omp_declare_target_local) - && list != OMP_LIST_LINK - && list != OMP_LIST_LOCAL) + else if ((list != OMP_LIST_LINK + && n->sym->attr.omp_declare_target_link) + || (list != OMP_LIST_LOCAL + && n->sym->attr.omp_declare_target_local)) gfc_error_now ("OMP DECLARE TARGET variable at %L previously " "mentioned in %s clause and later in %s clause", &n->where, n->sym->attr.omp_declare_target_link ? "LINK" : "LOCAL", - list == OMP_LIST_TO ? "TO" : "ENTER"); + (list == OMP_LIST_LOCAL ? "LOCAL" + : list == OMP_LIST_LINK ? "LINK" + : list == OMP_LIST_TO ? "TO" : "ENTER")); else if (n->sym->attr.omp_declare_target && (list == OMP_LIST_LINK || list == OMP_LIST_LOCAL)) gfc_error_now ("OMP DECLARE TARGET variable at %L previously " diff --git a/gcc/fortran/trans-common.cc b/gcc/fortran/trans-common.cc index 4f68b64fb08f..5458237a002c 100644 --- a/gcc/fortran/trans-common.cc +++ b/gcc/fortran/trans-common.cc @@ -436,8 +436,6 @@ build_common_decl (gfc_common_head *com, tree union_type, bool is_init) /* If there is no backend_decl for the common block, build it. */ if (decl == NULL_TREE) { - tree omp_clauses = NULL_TREE; - if (com->is_bind_c == 1 && com->binding_label) decl = build_decl (input_location, VAR_DECL, identifier, union_type); else @@ -469,47 +467,51 @@ build_common_decl (gfc_common_head *com, tree union_type, bool is_init) gfc_set_decl_location (decl, &com->where); + tree arg_list = NULL_TREE; if (com->omp_device_type != OMP_DEVICE_TYPE_UNSET) { - tree c = build_omp_clause (UNKNOWN_LOCATION, OMP_CLAUSE_DEVICE_TYPE); + const char *arg_str = NULL; switch (com->omp_device_type) { case OMP_DEVICE_TYPE_HOST: - OMP_CLAUSE_DEVICE_TYPE_KIND (c) = OMP_CLAUSE_DEVICE_TYPE_HOST; + arg_str = "device_type(host)"; break; case OMP_DEVICE_TYPE_NOHOST: - OMP_CLAUSE_DEVICE_TYPE_KIND (c) = OMP_CLAUSE_DEVICE_TYPE_NOHOST; + arg_str = "device_type(nohost)"; break; case OMP_DEVICE_TYPE_ANY: - OMP_CLAUSE_DEVICE_TYPE_KIND (c) = OMP_CLAUSE_DEVICE_TYPE_ANY; + arg_str = "device_type(any)"; break; default: gcc_unreachable (); } - omp_clauses = c; + arg_list = tree_cons (NULL_TREE, get_identifier (arg_str), arg_list); } + /* Also check trans-decl.cc when updating/removing the following; also update f95.c's gfc_gnu_attributes. */ if (com->omp_groupprivate) gfc_error ("Sorry, OMP GROUPPRIVATE not implemented, used by common " "block % declared at %L", com->name, &com->where); - else if (com->omp_declare_target_local) - /* Use 'else if' as groupprivate implies 'local'. */ - gfc_error ("Sorry, OMP DECLARE TARGET with LOCAL clause not implemented" - ", used by common block % declared at %L", - com->name, &com->where); if (com->omp_declare_target_link) DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("omp declare target link"), - omp_clauses, DECL_ATTRIBUTES (decl)); + arg_list, DECL_ATTRIBUTES (decl)); else if (com->omp_declare_target) DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("omp declare target"), - omp_clauses, DECL_ATTRIBUTES (decl)); + arg_list, DECL_ATTRIBUTES (decl)); + else if (com->omp_declare_target_local) + { + arg_list = tree_cons (NULL_TREE, get_identifier ("local"), arg_list); + DECL_ATTRIBUTES (decl) + = tree_cons (get_identifier ("omp declare target"), + arg_list, DECL_ATTRIBUTES (decl)); + } if (com->omp_declare_target_link || com->omp_declare_target - /* FIXME: || com->omp_declare_target_local */) + || com->omp_declare_target_local) { /* Add to offload_vars; get_create does so for omp_declare_target and omp_declare_target_local, omp_declare_target_link requires diff --git a/gcc/fortran/trans-decl.cc b/gcc/fortran/trans-decl.cc index 93c8cb5e7b0b..dc17b658d10e 100644 --- a/gcc/fortran/trans-decl.cc +++ b/gcc/fortran/trans-decl.cc @@ -1584,27 +1584,27 @@ add_attributes_to_decl (tree *decl_p, const gfc_symbol *sym) /* FIXME: 'declare_target_link' permits both any and host, but will fail if one sets OMP_CLAUSE_DEVICE_TYPE_KIND. */ + tree arg_list = NULL_TREE; if (sym_attr.omp_device_type != OMP_DEVICE_TYPE_UNSET && !sym_attr.omp_declare_target_link && !sym_attr.omp_declare_target_indirect /* implies 'any' */) { - tree c = build_omp_clause (UNKNOWN_LOCATION, OMP_CLAUSE_DEVICE_TYPE); + const char *arg_str = NULL; switch (sym_attr.omp_device_type) { case OMP_DEVICE_TYPE_HOST: - OMP_CLAUSE_DEVICE_TYPE_KIND (c) = OMP_CLAUSE_DEVICE_TYPE_HOST; + arg_str = "device_type(host)"; break; case OMP_DEVICE_TYPE_NOHOST: - OMP_CLAUSE_DEVICE_TYPE_KIND (c) = OMP_CLAUSE_DEVICE_TYPE_NOHOST; + arg_str = "device_type(nohost)"; break; case OMP_DEVICE_TYPE_ANY: - OMP_CLAUSE_DEVICE_TYPE_KIND (c) = OMP_CLAUSE_DEVICE_TYPE_ANY; + arg_str = "device_type(any)"; break; default: gcc_unreachable (); } - OMP_CLAUSE_CHAIN (c) = clauses; - clauses = c; + arg_list = tree_cons (NULL_TREE, get_identifier (arg_str), arg_list); } /* Also check trans-common.cc when updating/removing the following; @@ -1612,23 +1612,48 @@ add_attributes_to_decl (tree *decl_p, const gfc_symbol *sym) if (sym_attr.omp_groupprivate) gfc_error ("Sorry, OMP GROUPPRIVATE not implemented, " "used by %qs declared at %L", sym->name, &sym->declared_at); - else if (sym_attr.omp_declare_target_local) - /* Use 'else if' as groupprivate implies 'local'. */ - gfc_error ("Sorry, OMP DECLARE TARGET with LOCAL clause not implemented, " - "used by %qs declared at %L", sym->name, &sym->declared_at); bool has_declare = true; - if (sym_attr.omp_declare_target_link - || sym_attr.oacc_declare_link) - list = tree_cons (get_identifier ("omp declare target link"), - clauses, list); - else if (sym_attr.omp_declare_target - || sym_attr.oacc_declare_create - || sym_attr.oacc_declare_copyin - || sym_attr.oacc_declare_deviceptr - || sym_attr.oacc_declare_device_resident) - list = tree_cons (get_identifier ("omp declare target"), - clauses, list); + + if (flag_openmp) + { + if (sym_attr.omp_declare_target_link) + list = tree_cons (get_identifier ("omp declare target link"), + arg_list, list); + else if (sym_attr.omp_declare_target) + list = tree_cons (get_identifier ("omp declare target"), + arg_list, list); + else if (sym_attr.omp_declare_target_local) + { + /* The OpenMP local clause is encoded as an identifier in the + TREE_VALUE of the attribute, itself as a TREE_LIST. This is because + local has very similar handling to normal "enter", just not added + to offload_vars. */ + arg_list = tree_cons (NULL_TREE, get_identifier ("local"), arg_list); + list = tree_cons (get_identifier ("omp declare target"), + arg_list, list); + } + else + has_declare = false; + } + else if (flag_openacc) + { + /* OpenACC has the routine clause list saved in TREE_VALUE of attribute. + This appears consistent with C/C++. Whether OpenMP/OpenACC handling + should be further unified is TBD. */ + if (sym_attr.oacc_declare_link) + list = tree_cons (get_identifier ("omp declare target link"), + clauses, list); + else if (sym_attr.omp_declare_target + || sym_attr.oacc_declare_create + || sym_attr.oacc_declare_copyin + || sym_attr.oacc_declare_deviceptr + || sym_attr.oacc_declare_device_resident) + list = tree_cons (get_identifier ("omp declare target"), + clauses, list); + else + has_declare = false; + } else has_declare = false; diff --git a/gcc/omp-offload.cc b/gcc/omp-offload.cc index c9b4a94255cf..f39635712e48 100644 --- a/gcc/omp-offload.cc +++ b/gcc/omp-offload.cc @@ -399,10 +399,13 @@ omp_discover_implicit_declare_target (void) & (OMP_REQUIRES_SELF_MAPS | OMP_REQUIRES_UNIFIED_SHARED_MEMORY)) FOR_EACH_VARIABLE (vnode) { + tree attr; /* If 'self_maps' or 'unified_shared_memory' is enabled, - remove 'enter/to' and add 'link'. */ - if (lookup_attribute ("omp declare target", - DECL_ATTRIBUTES (vnode->decl))) + remove 'enter/to' and add 'link'. + Note that "declare target local" is preserved and not converted. */ + if ((attr = lookup_attribute ("omp declare target", + DECL_ATTRIBUTES (vnode->decl))) + && !value_member (get_identifier ("local"), TREE_VALUE (attr))) { DECL_ATTRIBUTES (vnode->decl) = remove_attribute ("omp declare target", diff --git a/gcc/testsuite/c-c++-common/gomp/declare-target-1.c b/gcc/testsuite/c-c++-common/gomp/declare-target-1.c index 901f2d06634d..84da463317d1 100644 --- a/gcc/testsuite/c-c++-common/gomp/declare-target-1.c +++ b/gcc/testsuite/c-c++-common/gomp/declare-target-1.c @@ -5,9 +5,11 @@ int foo (void), bar (void); extern int a; int b; char d; +double e; #pragma omp declare target long c; #pragma omp end declare target #pragma omp declare target (bar, a) #pragma omp declare target to (b) link (d) enter (foo) +#pragma omp declare target local (e) diff --git a/gcc/testsuite/c-c++-common/gomp/declare-target-8.c b/gcc/testsuite/c-c++-common/gomp/declare-target-8.c new file mode 100644 index 000000000000..714eba2cab55 --- /dev/null +++ b/gcc/testsuite/c-c++-common/gomp/declare-target-8.c @@ -0,0 +1,29 @@ +/* { dg-do compile } */ +/* { dg-options "-fopenmp" } */ +// { dg-additional-options "-Wno-deprecated-openmp" } + +int var1; +#pragma omp declare target link(var1) +#pragma omp declare target local(var1) /* { dg-error "'var1' specified both in declare target 'link' and 'local' clauses" } */ + +int var2; +#pragma omp declare target local(var2) +#pragma omp declare target link(var2) /* { dg-error "'var2' specified both in declare target 'link' and 'local' clauses" } */ + +int var3; +#pragma omp declare target enter(var3) +#pragma omp declare target local(var3) /* { dg-error "'var3' specified both in declare target 'local' and 'to' or 'enter' clauses" } */ + +int var4; +#pragma omp declare target local(var4) +#pragma omp declare target enter(var4) /* { dg-error "'var4' specified both in declare target 'local' and 'enter' clauses" } */ +#pragma omp declare target to(var4) /* { dg-error "'var4' specified both in declare target 'local' and 'to' clauses" } */ + +#pragma omp begin declare target +int var5; +#pragma omp declare target local(var5) /* { dg-error "'var5' specified both in declare target 'local' and 'to' or 'enter' clauses" } */ +#pragma omp end declare target + +int var6, var7; +#pragma omp declare target local(var6) local(var6) /* { dg-error "'var6' appears more than once on the same 'declare target' directive" } */ +#pragma omp declare target local(var7) enter(var7) /* { dg-error "'var7' appears more than once on the same 'declare target' directive" } */ diff --git a/gcc/testsuite/gfortran.dg/gomp/declare-target-1.f90 b/gcc/testsuite/gfortran.dg/gomp/declare-target-1.f90 index a02bb427f4f6..f8fb55e75a4b 100644 --- a/gcc/testsuite/gfortran.dg/gomp/declare-target-1.f90 +++ b/gcc/testsuite/gfortran.dg/gomp/declare-target-1.f90 @@ -14,14 +14,17 @@ subroutine bar !$omp declare target integer, save :: var_9 !$omp declare target link (var_8) to (baz, var_7) link (var_9) to (var_10) - integer, save :: var_7, var_8, var_10 - integer :: var_11, var_12, var_13, var_14 + integer, save :: var_7, var_8, var_10, var_16 + integer :: var_11, var_12, var_13, var_14, var_15 common /c1/ var_11, var_12 common /c2/ var_13 common /c3/ var_14 + common /c4/ var_15 !$omp declare target (baz, var_7, var_10, /c1/) !$omp declare target to (/c2/) !$omp declare target link (/c3/) !$omp declare target (bar) + !$omp declare target local (var_16) + !$omp declare target local (/c4/) call baz end subroutine diff --git a/gcc/testsuite/gfortran.dg/gomp/declare-target-7.f90 b/gcc/testsuite/gfortran.dg/gomp/declare-target-7.f90 new file mode 100644 index 000000000000..969ce975a876 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/gomp/declare-target-7.f90 @@ -0,0 +1,25 @@ +! { dg-do compile } +! { dg-additional-options "-Wno-deprecated-openmp" } + + integer :: var1 + !$omp declare target link(var1) + !$omp declare target local(var1) ! { dg-error "OMP DECLARE TARGET variable at \\(1\\) previously mentioned in LINK clause and later in LOCAL clause" } + + integer :: var2 + !$omp declare target local(var2) + !$omp declare target link(var2) ! { dg-error "OMP DECLARE TARGET variable at \\(1\\) previously mentioned in LOCAL clause and later in LINK clause" } + + integer :: var3 + !$omp declare target enter(var3) + !$omp declare target local(var3) ! { dg-error "OMP DECLARE TARGET variable at \\(1\\) previously mentioned in TO or ENTER clause and later in LOCAL clause" } + + integer :: var4 + !$omp declare target local(var4) + !$omp declare target enter(var4) ! { dg-error "OMP DECLARE TARGET variable at \\(1\\) previously mentioned in LOCAL clause and later in ENTER clause" } + !$omp declare target to(var4) ! { dg-error "OMP DECLARE TARGET variable at \\(1\\) previously mentioned in LOCAL clause and later in TO clause" } + + integer :: var5, var6 + !$omp declare target local(var5) local(var5) ! { dg-error "Variable at \\(1\\) mentioned multiple times in clauses of the same OMP DECLARE TARGET directive" } + !$omp declare target local(var6) enter(var6) ! { dg-error "Variable at \\(1\\) mentioned multiple times in clauses of the same OMP DECLARE TARGET directive" } + +end program diff --git a/gcc/testsuite/gfortran.dg/gomp/groupprivate-2.f90 b/gcc/testsuite/gfortran.dg/gomp/groupprivate-2.f90 index 2e921ae542fa..6ac5ea21af38 100644 --- a/gcc/testsuite/gfortran.dg/gomp/groupprivate-2.f90 +++ b/gcc/testsuite/gfortran.dg/gomp/groupprivate-2.f90 @@ -6,9 +6,9 @@ module m integer :: x, y(20), z, v, q, r,o, b2,c !$omp groupprivate(x, z, o) device_Type( any ) - !$omp declare target enter(x) device_type ( any ) ! { dg-error "List item 'x' at .1. not appear in the 'enter' clause as it was previously specified in a GROUPPRIVATE directive" } - !$omp declare target to(z) device_type ( any ) ! { dg-error "List item 'z' at .1. not appear in the 'to' clause as it was previously specified in a GROUPPRIVATE directive" } - !$omp declare target link(o) device_type ( any ) ! { dg-error "List item 'o' at .1. not appear in the 'link' clause as it was previously specified in a GROUPPRIVATE directive" } + !$omp declare target enter(x) device_type ( any ) ! { dg-error "List item 'x' at .1. should not appear in the 'enter' clause, as it was previously specified in a GROUPPRIVATE directive" } + !$omp declare target to(z) device_type ( any ) ! { dg-error "List item 'z' at .1. should not appear in the 'to' clause, as it was previously specified in a GROUPPRIVATE directive" } + !$omp declare target link(o) device_type ( any ) ! { dg-error "List item 'o' at .1. should not appear in the 'link' clause, as it was previously specified in a GROUPPRIVATE directive" } !$omp declare target enter( ii) ,local(y,c), link(r), to(q) device_type ( host ) !$omp groupprivate(r,q) device_type(host) ! { dg-error "List item 'q' at .1. implies OMP DECLARE TARGET with the LOCAL clause, but it has been specified with a different clause before" "" { target *-*-* } .-1 } @@ -30,10 +30,9 @@ subroutine sub() !$omp groupprivate(x3) device_type (host ) !$omp groupprivate(x4) device_type( nohost) - !$omp declare target(x0) ! { dg-error "List item 'x0' at .1. not appear in the 'enter' clause as it was previously specified in a GROUPPRIVATE directive" } - !$omp declare target device_type(any) to(x1) ! { dg-error "List item 'x1' at .1. not appear in the 'to' clause as it was previously specified in a GROUPPRIVATE directive" } - !$omp declare target device_type(any) enter(x2) ! { dg-error "List item 'x2' at .1. not appear in the 'enter' clause as it was previously specified in a GROUPPRIVATE directive" } - !$omp declare target device_type(host) link(x3) ! { dg-error "List item 'x3' at .1. not appear in the 'link' clause as it was previously specified in a GROUPPRIVATE directive" } + !$omp declare target(x0) ! { dg-error "List item 'x0' at .1. should not appear in the 'enter' clause, as it was previously specified in a GROUPPRIVATE directive" } + !$omp declare target device_type(any) to(x1) ! { dg-error "List item 'x1' at .1. should not appear in the 'to' clause, as it was previously specified in a GROUPPRIVATE directive" } + !$omp declare target device_type(any) enter(x2) ! { dg-error "List item 'x2' at .1. should not appear in the 'enter' clause, as it was previously specified in a GROUPPRIVATE directive" } + !$omp declare target device_type(host) link(x3) ! { dg-error "List item 'x3' at .1. should not appear in the 'link' clause, as it was previously specified in a GROUPPRIVATE directive" } !$omp declare target device_type(host) local(x4) ! { dg-error "List item 'x4' at .1. set in previous OMP GROUPPRIVATE directive to the different DEVICE_TYPE 'nohost'" } - end diff --git a/gcc/tree-core.h b/gcc/tree-core.h index 1687b1f94672..18330169d831 100644 --- a/gcc/tree-core.h +++ b/gcc/tree-core.h @@ -330,6 +330,9 @@ enum omp_clause_code { /* OpenMP clause: link (variable-list). */ OMP_CLAUSE_LINK, + /* OpenMP clause: local (variable-list). */ + OMP_CLAUSE_LOCAL, + /* OpenMP clause: detach (event-handle). */ OMP_CLAUSE_DETACH, diff --git a/gcc/tree.cc b/gcc/tree.cc index db3713c2f1b8..3b7ad2b18180 100644 --- a/gcc/tree.cc +++ b/gcc/tree.cc @@ -318,6 +318,7 @@ unsigned const char omp_clause_num_ops[] = 1, /* OMP_CLAUSE_UNIFORM */ 1, /* OMP_CLAUSE_ENTER */ 1, /* OMP_CLAUSE_LINK */ + 1, /* OMP_CLAUSE_LOCAL */ 1, /* OMP_CLAUSE_DETACH */ 1, /* OMP_CLAUSE_USE_DEVICE_PTR */ 1, /* OMP_CLAUSE_USE_DEVICE_ADDR */ @@ -424,6 +425,7 @@ const char * const omp_clause_code_name[] = "uniform", "enter", "link", + "local", "detach", "use_device_ptr", "use_device_addr", diff --git a/gcc/varpool.cc b/gcc/varpool.cc index 1025535ec5aa..b62fba999968 100644 --- a/gcc/varpool.cc +++ b/gcc/varpool.cc @@ -150,14 +150,18 @@ varpool_node::get_create (tree decl) node = varpool_node::create_empty (); node->decl = decl; + tree attr; if ((flag_openacc || flag_openmp) - && lookup_attribute ("omp declare target", DECL_ATTRIBUTES (decl))) + && (attr = lookup_attribute ("omp declare target", + DECL_ATTRIBUTES (decl)))) { node->offloadable = 1; if (ENABLE_OFFLOADING && !DECL_EXTERNAL (decl)) { g->have_offload = true; - if (!in_lto_p) + if (!in_lto_p + && !value_member (get_identifier ("local"), + TREE_VALUE (attr))) vec_safe_push (offload_vars, decl); } } diff --git a/libgomp/testsuite/libgomp.c-c++-common/declare-target-local-1.c b/libgomp/testsuite/libgomp.c-c++-common/declare-target-local-1.c new file mode 100644 index 000000000000..c6b4d2ecf700 --- /dev/null +++ b/libgomp/testsuite/libgomp.c-c++-common/declare-target-local-1.c @@ -0,0 +1,34 @@ +/* { dg-do run { target offload_device } } */ + +int local_var = 900; +#pragma omp declare target local(local_var) + +#pragma omp begin declare target +int foo (int x) +{ + local_var += x; + return local_var; +} +#pragma omp end declare target + +int main (void) +{ + /* Variables declared in the 'local' clause should not be corresponding + storage between host/device. Test if 'target update' has no effect + and host-side 'local_var' retains original value. */ + + int e; + #pragma omp target map(from : e) + { + e = foo (23); + } + + #pragma omp target update from(local_var) + + if (local_var == e) + __builtin_abort (); + if (local_var != 900) + __builtin_abort (); + + return 0; +} diff --git a/libgomp/testsuite/libgomp.c-c++-common/declare-target-local-2.c b/libgomp/testsuite/libgomp.c-c++-common/declare-target-local-2.c new file mode 100644 index 000000000000..a770979c6bf7 --- /dev/null +++ b/libgomp/testsuite/libgomp.c-c++-common/declare-target-local-2.c @@ -0,0 +1,56 @@ +#include + +#ifdef USE_SELF_MAPS +#pragma omp self_maps +#endif + +int var[2] = { 5, 6 }; +#pragma omp declare target local(var) + +int +get_var_inc (void) +{ + var[0]++; + return var[0]; +} + +__UINTPTR_TYPE__ +get_addr (void) +{ + return (__UINTPTR_TYPE__) &var[0]; +} + +int main (void) +{ + __UINTPTR_TYPE__ addr_tgt, addr_fn; + bool is_initial_dev; + int val; + var[0] = 7; + + #pragma omp target map(from: val, is_initial_dev, addr_tgt, addr_fn) + { + is_initial_dev = __builtin_omp_is_initial_device (); + addr_tgt = (__UINTPTR_TYPE__) &var[0]; + addr_fn = get_addr (); + + var[0] += 5; + val = get_var_inc (); + } + + if (is_initial_dev) + { + assert (val == var[0]); + assert (val == 13); + assert (&var[0] == (void*) addr_fn); + } + else + { + assert (val == 11); + assert (var[0] == 7); + assert (&var[0] != (void*) addr_fn); + } + + assert (addr_tgt == addr_fn); + + return 0; +} diff --git a/libgomp/testsuite/libgomp.c-c++-common/declare-target-local-3.c b/libgomp/testsuite/libgomp.c-c++-common/declare-target-local-3.c new file mode 100644 index 000000000000..69d8a5490358 --- /dev/null +++ b/libgomp/testsuite/libgomp.c-c++-common/declare-target-local-3.c @@ -0,0 +1,3 @@ + +#define USE_SELF_MAPS +#include "declare-target-local-2.c" diff --git a/libgomp/testsuite/libgomp.c-c++-common/declare-target-local-4.c b/libgomp/testsuite/libgomp.c-c++-common/declare-target-local-4.c new file mode 100644 index 000000000000..7a40d01c33f5 --- /dev/null +++ b/libgomp/testsuite/libgomp.c-c++-common/declare-target-local-4.c @@ -0,0 +1,47 @@ +#include +#include + +int f (int dev_num) +{ + static int X[1] = { 5 }; + #pragma omp declare target local(X) + + int res; + #pragma omp target map(from: res) device(dev_num) + res = ++X[0]; + + return res; +} + +int main (void) +{ + int cnt; + + cnt = f (omp_initial_device); + assert (cnt == 6); + + cnt = f (omp_initial_device); + assert (cnt == 7); + + if (omp_get_num_devices () > 0) + { + cnt = f (omp_default_device); + assert (cnt == 6); + cnt = f (omp_default_device); + assert (cnt == 7); + cnt = f (omp_default_device); + assert (cnt == 8); + cnt = f (omp_default_device); + assert (cnt == 9); + + cnt = f (omp_initial_device); + assert (cnt == 8); + } + else + { + cnt = f (omp_default_device); + assert (cnt == 8); + } + + return 0; +} diff --git a/libgomp/testsuite/libgomp.fortran/declare-target-local-1.f90 b/libgomp/testsuite/libgomp.fortran/declare-target-local-1.f90 new file mode 100644 index 000000000000..81303db03bad --- /dev/null +++ b/libgomp/testsuite/libgomp.fortran/declare-target-local-1.f90 @@ -0,0 +1,55 @@ +! { dg-do run { target offload_device } } +! { dg-additional-options "-Wno-deprecated-openmp" } +module m + implicit none (type, external) + + integer :: local_var = 900 + !$omp declare target local(local_var) + + integer :: local_cblk_var = 800 + common /cblk/ local_cblk_var + !$omp declare target local(/cblk/) + +contains + integer function incr_local_var (x) + !$omp declare target + integer :: x + local_var = local_var + x + incr_local_var = local_var + end function + + integer function incr_local_cblk_var (x) + !$omp declare target + integer :: x + local_cblk_var = local_cblk_var + x + incr_local_cblk_var = local_cblk_var + end function + +end module m + +program main + use m + implicit none (type, external) + integer :: e + + ! Variables declared in the 'local' clause should not be corresponding + ! storage between host/device. Test if 'target update' has no effect + ! and host-side 'local_var' retains original value. */ + + !$omp target map(from : e) + e = incr_local_var (23) + !$omp end target + + !$omp target update from(local_var) + if (local_var == e) stop 1 + if (local_var /= 900) stop 2 + + !$omp target map(from : e) + e = incr_local_cblk_var (68) + !$omp end target + + !$omp target update from(local_cblk_var) + if (local_cblk_var == e) stop 3 + if (local_cblk_var /= 800) stop 4 + +end program main From 3e9d5caf6c7d79d2e77c903477680149095c1b7b Mon Sep 17 00:00:00 2001 From: "Jose E. Marchesi" Date: Wed, 23 Sep 2026 01:07:09 +0200 Subject: [PATCH 354/584] a68: mark module {pre,post}lude functions as artificial When lowering a module-text two functions are synthesized: the one corresponding to the module's prelude and the one corresponding to the module's postlude. These declarations are artificial and need to be marke as such by setting DECL_ARTIFICIAL to 1. Signed-off-by: Jose E. Marchesi gcc/algol68/ChangeLog * a68-low.cc (lower_module_text): Mark prelude_decl an postlude_decl as artificial. gcc/testsuite/ChangeLog * algol68/compile/prepostlude-crash-1.a68: New test. --- gcc/algol68/a68-low.cc | 2 ++ .../algol68/compile/prepostlude-crash-1.a68 | 16 ++++++++++++++++ 2 files changed, 18 insertions(+) create mode 100644 gcc/testsuite/algol68/compile/prepostlude-crash-1.a68 diff --git a/gcc/algol68/a68-low.cc b/gcc/algol68/a68-low.cc index 8fc112cd76f6..62fbdc49d3fa 100644 --- a/gcc/algol68/a68-low.cc +++ b/gcc/algol68/a68-low.cc @@ -1318,6 +1318,7 @@ lower_module_text (NODE_T *p, LOW_CTX_T ctx) DECL_EXTERNAL (prelude_decl) = 0; TREE_PUBLIC (prelude_decl) = 1; TREE_STATIC (prelude_decl) = 1; + DECL_ARTIFICIAL (prelude_decl) = 1; a68_push_function_range (prelude_decl, void_type_node /* result_type */, true /* top_level */); @@ -1376,6 +1377,7 @@ lower_module_text (NODE_T *p, LOW_CTX_T ctx) DECL_EXTERNAL (postlude_decl) = 0; TREE_PUBLIC (postlude_decl) = 1; TREE_STATIC (postlude_decl) = 1; + DECL_ARTIFICIAL (postlude_decl) = 1; a68_push_function_range (postlude_decl, void_type_node /* result_type */, true /* top_level */); diff --git a/gcc/testsuite/algol68/compile/prepostlude-crash-1.a68 b/gcc/testsuite/algol68/compile/prepostlude-crash-1.a68 new file mode 100644 index 000000000000..c686dde1f776 --- /dev/null +++ b/gcc/testsuite/algol68/compile/prepostlude-crash-1.a68 @@ -0,0 +1,16 @@ +{ This program triggers the gcc_assert at dwarf2out.cc:31161 unless + the prelude and postlude functions of the module are marked with + DECL_ARTIFICIAL. This happens only with -O2 and I am not sure why + this happens (it is related to the fact the synthesized prelude + function is the parent of the resulting typedef that defines + CPNM_value). } + +module CPNMA68 = def + + mode CPNM_value = real; + + pub proc cpnm_export_value = (real value) int: + skip; + + skip +fed From b624ebefa3a6a591924c0d680772ba89c5cd08d2 Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Thu, 17 Sep 2026 12:16:38 +0100 Subject: [PATCH 355/584] libstdc++: Use deleted functions in C++98 mode MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit We can use deleted functions in C++98 mode if we use pragmas to disable the -Wc++11-extensions diagnostics. This works with both GCC and Clang. In some cases this makes the code more robust in C++98 mode because we were previously not making types copyable at all (e.g., _Reuse_or_alloc_node in bits/stl_tree.h) and just relying on testing in C++11 and later to know we didn't use those functions. In other cases it gives better diagnostics because we were defining copy constructors and assignment operators as private libstdc++-v3/ChangeLog: * config/io/basic_file_stdio.h (__basic_file): Define copy constructor and copy assignment operator as deleted for C++98. * include/bits/stl_bvector.h (vector::data): Define as deleted for C++98. * include/bits/stl_tree.h (_Reuse_or_alloc_node): Define copy constructor as deleted for C++98. * include/bits/stl_vector.h (_Asan>::_Reinit): Define copy constructor and copy assignment operator as deleted for C++98. (_Asan>::_Grow): Likewise. * testsuite/util/replacement_memory_operators.h (__gnu_test::counter::scope): Likewise. * testsuite/util/testsuite_iterators.h (operator,, operator&) (operator+=, operator-=, operator[]): Define deleted operators for C++98. Reviewed-by: Tomasz Kamiński --- libstdc++-v3/config/io/basic_file_stdio.h | 9 ++++-- libstdc++-v3/include/bits/stl_bvector.h | 8 ++--- libstdc++-v3/include/bits/stl_tree.h | 5 +-- libstdc++-v3/include/bits/stl_vector.h | 8 ++--- .../util/replacement_memory_operators.h | 14 ++++---- .../testsuite/util/testsuite_iterators.h | 32 ++++--------------- 6 files changed, 28 insertions(+), 48 deletions(-) diff --git a/libstdc++-v3/config/io/basic_file_stdio.h b/libstdc++-v3/config/io/basic_file_stdio.h index 5e06fd378eab..b480eb943f0c 100644 --- a/libstdc++-v3/config/io/basic_file_stdio.h +++ b/libstdc++-v3/config/io/basic_file_stdio.h @@ -62,6 +62,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: __basic_file(__c_lock* __lock = 0) throw (); +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++11-extensions" + __basic_file(const __basic_file&) = delete; + __basic_file& operator=(const __basic_file&) = delete; +#pragma GCC diagnostic pop + #if __cplusplus >= 201103L __basic_file(__basic_file&& __rv, __c_lock* = 0) noexcept : _M_cfile(__rv._M_cfile), _M_cfile_created(__rv._M_cfile_created) @@ -70,9 +76,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __rv._M_cfile_created = false; } - __basic_file& operator=(const __basic_file&) = delete; - __basic_file& operator=(__basic_file&&) = delete; - void swap(__basic_file& __f) noexcept { diff --git a/libstdc++-v3/include/bits/stl_bvector.h b/libstdc++-v3/include/bits/stl_bvector.h index d792f7077860..3cdb48f3983c 100644 --- a/libstdc++-v3/include/bits/stl_bvector.h +++ b/libstdc++-v3/include/bits/stl_bvector.h @@ -1763,12 +1763,10 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER // DR 464. Suggestion for new member functions in standard containers. // N.B. DR 464 says nothing about vector but we need something // here due to the using-declaration in __gnu_debug::vector. - // vector class. -#if __cplusplus >= 201103L +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++11-extensions" void data() = delete; -#else - void data() { } -#endif +#pragma GCC diagnostic pop }; _GLIBCXX_END_NAMESPACE_CONTAINER diff --git a/libstdc++-v3/include/bits/stl_tree.h b/libstdc++-v3/include/bits/stl_tree.h index 313ee8160023..da1fbd304c0c 100644 --- a/libstdc++-v3/include/bits/stl_tree.h +++ b/libstdc++-v3/include/bits/stl_tree.h @@ -1057,9 +1057,10 @@ namespace __rb_tree _M_nodes = _Base_ptr(); } -#if __cplusplus >= 201103L +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++11-extensions" _Reuse_or_alloc_node(const _Reuse_or_alloc_node&) = delete; -#endif +#pragma GCC diagnostic pop ~_Reuse_or_alloc_node() { diff --git a/libstdc++-v3/include/bits/stl_vector.h b/libstdc++-v3/include/bits/stl_vector.h index 9ddf35502e69..73fee5c07a1d 100644 --- a/libstdc++-v3/include/bits/stl_vector.h +++ b/libstdc++-v3/include/bits/stl_vector.h @@ -173,6 +173,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER #endif #if _GLIBCXX_SANITIZE_STD_ALLOCATOR && _GLIBCXX_SANITIZE_VECTOR +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++11-extensions" // deleted functions template struct _Asan { @@ -249,10 +251,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER _Vector_impl& _M_impl; -#if __cplusplus >= 201103L _Reinit(const _Reinit&) = delete; _Reinit& operator=(const _Reinit&) = delete; -#endif }; // Tell ASan when unused capacity is initialized to be valid. @@ -269,15 +269,15 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER _GLIBCXX20_CONSTEXPR void _M_grew(size_type __n) { _M_n -= __n; } -#if __cplusplus >= 201103L _Grow(const _Grow&) = delete; _Grow& operator=(const _Grow&) = delete; -#endif + private: _Vector_impl& _M_impl; size_type _M_n; }; }; +#pragma GCC diagnostic pop #define _GLIBCXX_ASAN_ANNOTATE_REINIT \ typename _Base::_Vector_impl::template _Asan<>::_Reinit const \ diff --git a/libstdc++-v3/testsuite/util/replacement_memory_operators.h b/libstdc++-v3/testsuite/util/replacement_memory_operators.h index c6485b571e56..53837cabecbf 100644 --- a/libstdc++-v3/testsuite/util/replacement_memory_operators.h +++ b/libstdc++-v3/testsuite/util/replacement_memory_operators.h @@ -87,16 +87,14 @@ namespace __gnu_test ~scope() { counter::get()._M_count = _M_count; } - private: - std::size_t _M_count; - -#if __cplusplus >= 201103L +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++11-extensions" scope(const scope&) = delete; scope& operator=(const scope&) = delete; -#else - scope(const scope&); - scope& operator=(const scope&); -#endif +#pragma GCC diagnostic pop + + private: + std::size_t _M_count; }; }; diff --git a/libstdc++-v3/testsuite/util/testsuite_iterators.h b/libstdc++-v3/testsuite/util/testsuite_iterators.h index ca022e5d0f9c..8aefd7b11204 100644 --- a/libstdc++-v3/testsuite/util/testsuite_iterators.h +++ b/libstdc++-v3/testsuite/util/testsuite_iterators.h @@ -47,6 +47,9 @@ #define ITERATOR_VERIFY(x) VERIFY(x) #endif +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wc++11-extensions" // deleted functions + namespace __gnu_test { /** @@ -193,24 +196,14 @@ namespace __gnu_test return tmp; } -#if __cplusplus >= 201103L template void operator,(const U&) const = delete; void operator&() const = delete; -#else - private: - template - void operator,(const U&) const; - - void operator&() const; -#endif }; -#if __cplusplus >= 201103L template void operator,(const T&, const output_iterator_wrapper&) = delete; -#endif #if __cplusplus >= 201103L using std::remove_cv; @@ -331,24 +324,14 @@ namespace __gnu_test return tmp; } -#if __cplusplus >= 201103L template void operator,(const U&) const = delete; void operator&() const = delete; -#else - private: - template - void operator,(const U&) const; - - void operator&() const; -#endif }; -#if __cplusplus >= 201103L template void operator,(const T&, const input_iterator_wrapper&) = delete; -#endif /** * @brief forward_iterator wrapper for pointer @@ -607,11 +590,11 @@ namespace __gnu_test T& operator[](std::ptrdiff_t n) const { return *(*this + n); } -#if __cplusplus >= 201103L // Ensure that the iterator's difference_type is always used. template void operator+=(D) = delete; template void operator-=(D) = delete; template void operator[](D) const = delete; +#if __cplusplus >= 201103L template typename std::enable_if::value>::type operator-(D) const = delete; @@ -655,13 +638,11 @@ namespace __gnu_test operator+(std::ptrdiff_t n, random_access_iterator_wrapper it) { return it += n; } -#if __cplusplus >= 201103L // Ensure that the iterator's difference_type is always used. template void operator+(random_access_iterator_wrapper, D) = delete; template void operator+(D, random_access_iterator_wrapper) = delete; -#endif template @@ -809,11 +790,11 @@ namespace __gnu_test return tmp; } -#if __cplusplus >= 201103L // Ensure that the iterator's difference_type is always used. template void operator+=(D) = delete; template void operator-=(D) = delete; template void operator[](D) const = delete; +#if __cplusplus >= 201103L template typename std::enable_if::value>::type operator-(D) const = delete; @@ -857,13 +838,11 @@ namespace __gnu_test operator+(std::ptrdiff_t n, proxy_random_access_iterator_wrapper it) { return it += n; } -#if __cplusplus >= 201103L // Ensure that the iterator's difference_type is always used. template void operator+(proxy_random_access_iterator_wrapper, D) = delete; template void operator+(D, proxy_random_access_iterator_wrapper) = delete; -#endif /** * @brief A container-type class for holding iterator wrappers @@ -1292,4 +1271,5 @@ namespace __gnu_test #endif // C++20 } // namespace __gnu_test +#pragma GCC diagnostic pop #endif // _TESTSUITE_ITERATORS From b679fda6b4f2d41323e19f780b52805e7a06bfcc Mon Sep 17 00:00:00 2001 From: GCC Administrator Date: Wed, 23 Sep 2026 00:16:39 +0000 Subject: [PATCH 356/584] Daily bump. --- gcc/ChangeLog | 141 ++++++++++++++++++++ gcc/DATESTAMP | 2 +- gcc/ada/ChangeLog | 285 ++++++++++++++++++++++++++++++++++++++++ gcc/algol68/ChangeLog | 5 + gcc/c-family/ChangeLog | 4 + gcc/c/ChangeLog | 9 ++ gcc/cobol/ChangeLog | 5 + gcc/cp/ChangeLog | 16 +++ gcc/fortran/ChangeLog | 10 ++ gcc/m2/ChangeLog | 22 ++++ gcc/testsuite/ChangeLog | 103 +++++++++++++++ libgcobol/ChangeLog | 10 ++ libgomp/ChangeLog | 8 ++ libstdc++-v3/ChangeLog | 84 ++++++++++++ 14 files changed, 703 insertions(+), 1 deletion(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index e257e7d5dd3c..db41308b8d72 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,144 @@ +2026-09-22 Chung-Lin Tang + + * omp-offload.cc (omp_discover_implicit_declare_target): + For self_maps/unified_shared_memory case, adjust to not convert + 'omp declare target local' variables to 'link'. + * tree-core.h (enum omp_clause_code): Add OMP_CLAUSE_LOCAL. + * tree.cc (omp_clause_num_ops): Add entry for OMP_CLAUSE_LOCAL. + (omp_clause_code_name): Likewise. + * varpool.cc (varpool_node::get_create): Do not add variable to + offload_vars if "local" argument is present in "omp declare target". + +2026-09-22 Vladimir N. Makarov + + PR rtl-optimization/127326 + * lra-constraints.cc (process_alt_operands): Ignore register if + constraint describes memory and register which can not hold the + mode value. + +2026-09-22 Roger Sayle + Hongtao Liu + + PR target/114544 + * config/i386/constraints.md (YD): New constraint, like Yd but + allows SSE_REGS on TARGET_SSE2. + * config/i386/i386.cc (inline_secondary_memory_needed): Update + that TImode moves to GENERAL_REGS don't need to use memory. + * config/i386/i386.md (*movti_internal): Change Yd constraint to YD. + (define_split): On TARGET_64BIT && TARGET_SSE2 && !TARGET_SSE4_1, + split *movti_internal into movq+shufpd+movq+shufpd. + +2026-09-22 Richard Earnshaw + + PR target/127393 + * config/aarch64/predicates.md (pure_register_operand): New predicate. + * config/aarch64/aarch64.md (negvti3): Use it. + +2026-09-22 Jakub Jelinek + + PR middle-end/127492 + * builtins.cc (expand_builtin_atomic_fetch_op): Force val into a + pseudo if updates to mem could change its value. + (expand_ifn_atomic_bit_test_and): Likewise. + +2026-09-22 Richard Biener + + * tree-vect-loop.cc (vectorizable_live_operation): Cost + the lane extract in vect_body for BB vectorization and + in vect_epilog for loop vectorization. + +2026-09-22 Richard Biener + + * doc/invoke.texi (fwrapv-pointer): Add disclaimer. + (fno-strict-overflow): Discourage, suggest fwrapv. + +2026-09-22 Andrew Stubbs + + * target.def (base_reg_class): New target hook. + * targhooks.h (default_base_reg_class): Declare. + * targhooks.cc (default_base_reg_class): New function, implementing + the previous BASE_REG_CLASS/MODE_BASE_REG_CLASS/ + MODE_BASE_REG_REG_CLASS/MODE_CODE_BASE_REG_CLASS macro fallback + chain as the hook's default. + * addresses.h (base_reg_class): Rewrite to call the + TARGET_BASE_REG_CLASS hook instead of dispatching through + INSN_BASE_REG_CLASS and the other macros by hand; add a MEM + parameter. + * rtl.h (address_info): Add mem field. + * rtlanal.cc (decompose_mem_address): Set it. + * lra-constraints.cc (simplify_operand_subreg, process_alt_operands, + base_to_reg, base_plus_disp_to_reg, process_address_1, + curr_insn_transform): Pass the enclosing MEM, and INSN where + previously omitted, to base_reg_class. + * reload.cc (find_reloads, find_reloads_address, + find_reloads_address_1, find_reloads_subreg_address): Likewise. + * reload1.cc (maybe_fix_stack_asms): Likewise. + * regcprop.cc: Include target.h. + (replace_oldest_value_addr, replace_oldest_value_mem): Pass MEM to + base_reg_class. + * regrename.cc (base_reg_class_for_rename): Add a MEM parameter. + (scan_rtx_address, scan_rtx): Pass it. + * caller-save.cc: Include target.h. + * config/i386/i386.h (INSN_BASE_REG_CLASS): Delete. + * config/i386/i386-protos.h (ix86_insn_base_reg_class): Delete + declaration. + * config/i386/i386.cc (ix86_insn_base_reg_class): Rename to... + (ix86_base_reg_class): ...this, adjust the signature, and implement + TARGET_BASE_REG_CLASS instead of INSN_BASE_REG_CLASS. + (TARGET_BASE_REG_CLASS): Define. + * doc/tm.texi.in: Add TARGET_BASE_REG_CLASS. Mark BASE_REG_CLASS, + MODE_BASE_REG_CLASS, MODE_BASE_REG_REG_CLASS and + MODE_CODE_BASE_REG_CLASS as obsolete in favor of the new hook, and + remove the now-unused INSN_BASE_REG_CLASS. + * doc/tm.texi: Regenerate. + +2026-09-22 Wilco Dijkstra + + * config/aarch64/atomics.md (atomic_store): Use aarch64_reg_or_zero. + +2026-09-22 liuhongt + + PR tree-optimization/126486 + * tree-affine.cc: Include vr-values.h. + (aff_combination_convert): Accept and propagate range context. + (expr_to_aff_combination): Likewise. Fold sign-changing conversions + and negative unsigned offsets. + (tree_to_aff_combination): Accept and propagate range context. + * tree-affine.h (aff_combination_convert): Update declaration. + (tree_to_aff_combination): Likewise. + * tree-ssa-loop-ivopts.cc: Include gimple-range.h. + (get_computation_aff_1): Pass the use statement. + (tree_ssa_iv_optimize): Enable ranger. + +2026-09-22 liuhongt + + PR target/127500 + * config/i386/i386.cc (ix86_split_stlf_stall_load): Don't split + the load when the address adjusted by 8 is not a valid memory + address. + +2026-09-22 Naveen + + PR tree-optimization/112626 + * match.pd: Fold comparisons between abs (x) and x including + unsigned conversions of both operands. + +2026-09-22 Pan Li + + PR target/127269 + * config/riscv/riscv-v.cc (riscv_v_widen_constraint_ok): Return + false instead of assertion when the nregs of the dest is less + than that of the src. + +2026-09-22 Pan Li + + * config/riscv/constraints.md (Wn4): New constraint for the + vector register which doesn't overlap the register group of + the operand 4. + * config/riscv/vector.md: Take the Wn4 constraint for the + operand 3 and the Wvr constraint for the operand 4 of the + vfwadd.wv. + 2026-09-21 Eric Botcazou * config/riscv/riscv.cc (riscv_flatten_aggregate_field) : diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index e9b7161d4a77..086b6e065352 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20260922 +20260923 diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index 7696c45923e2..e9e22dd6b2ae 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,288 @@ +2026-09-22 Eric Botcazou + + * accessibility.adb (Accessibility_Message): Adjust wording. + (Check_Return_Construct_Accessibility.Accessibility_Error): Ditto. + * sem_attr.adb (Resolve_Attribute) : Likewise for + the specific error message given for subprograms. + * sem_ch3.adb (Analyze_Component_Declaration): Likewise for the + specific error message given for access components. + (Build_Derived_Record_Type): Add references to Ada 95 rules. + * sem_ch6.adb (Analyze_Function_Return): Adjust wording for the + error messages given for class-wide returns. + * sem_ch9.adb (Analyze_Requeue): Likewise for requeue statements. + * sem_ch13.adb (Analyze_Attribute_Definition_Clause) : + Add reference to Ada 2012 accessibility rule. + * sem_res.adb (Resolve_Actuals.Check_Aliased_Parameter): Adjust + wording for the error messages for actuals of aliased parameters. + (Resolve_Allocator): Likewise for allocators. + (Valid_Conversion): Likewise for conversions. + (Valid_Array_Conversion): Add Opnd_Type parameter instead of using + an up-level reference. + +2026-09-22 Eric Botcazou + + * exp_attr.adb (Expand_N_Attribute_Reference) : + Call Is_Reverse_Storage_Order_Object to detect cases where a copy + needs to be created for the prefix. + * sem_util.ads (In_Reverse_Storage_Order_Object): Delete. + (Is_Reverse_Storage_Order_Object): New predicate. + * sem_util.adb (In_Reverse_Storage_Order_Object): Delete. + (Is_Reverse_Storage_Order_Object): New predicate subsuming original + In_Reverse_Storage_Order_Object predicate. + +2026-09-22 Eric Botcazou + + * sem_ch4.adb (Analyze_Membership_Op): Do not force an error to be + given if the right operand is a Raise_Error node. + +2026-09-22 Eric Botcazou + + * accessibility.adb (Check_Return_Construct_Accessibility): Bail + out for the return synthesized in a function whose body has been + wrapped in a nested _Wrapped_Statements function. + +2026-09-22 Eric Botcazou + + * exp_ch3.adb (Make_Predefined_Primitive_Eq_Spec): Fix pasto. + * sem_ch4.adb (wpo): Also accept untagged types. + * sem_ch6.adb (Make_Inequality_Operator): Also copy Is_Primitive. + (New_Overloaded_Entity): Create the implicit inequality operator + only for nonderived subprograms, but create it in the asymmetric + case even for tagged types. Deal with the inheritance of such an + implicit inequality operator. + * sem_disp.adb: Add clauses for Stand. + (Check_Dispatching_Operation): Bail out for inequality operators + whose result type is Boolean. + +2026-09-22 Eric Botcazou + + * gen_il-gen-gen_entities.adb (Type_Kind): Set Base_Type_Only for + Is_Mutably_Tagged_Type flag. Move Class_Wide_Equivalent_Type to... + (Class_Wide_Kind): ...here. + * einfo.ads (Class_Wide_Equivalent_Type): Adjust description. + (Is_Controlled_Active): Likewise. + (Is_Controlled): Likewise. + (Is_Mutably_Tagged_Type): Likewise. + * exp_ch3.adb (Expand_N_Full_Type_Declaration): Use an assignment to + initialize an object of a mutably tagged type whose initial value is + not the result of a function call. + * exp_ch5.adb (Expand_N_Assignment_Statement): Do not dispatch to an + _assign primitive for an initialization even in the class-wide case. + For mutably tagged types, assign the tag unconditionally. + (Make_Tag_Ctrl_Assignment): Deal with mutably tagged types. + * exp_ch6.adb (Might_Have_Tasks): Invoke Has_Enabled_Aspect on the + root type for a class-wide type. + * exp_ch7.adb: Add clauses for Mutably_Tagged package. + (Make_Adjust_Call): Deal with mutably tagged types. + (Make_Final_Call): Likewise. + (Make_Init_Call): Likewise. + * exp_util.adb: Add clauses for Mutably_Tagged package. + (Finalize_Address): Deal with mutably tagged types. + (Make_CW_Equivalent_Type): Adjust comment. + * freeze.adb (Freeze_Record_Type): Invoke Needs_Finalization on the + type of the components to compute the Has_Controlled_Component flag. + * mutably_tagged.ads (Get_Corresponding_Tagged_Type_If_Present): + Adjust description. + * mutably_tagged.adb (Is_Mutably_Tagged_CW_Equivalent_Type): Test + Is_Mutably_Tagged_Type on the class-wide type of the parent subtype. + * sem_ch3.adb (Find_Type_Name): Do not set the Is_Internal flag on + the completion of an incomplete type. + (Record_Type_Definition): Invoke Needs_Finalization on the type of + the components to compute the Has_Controlled_Component flag. + * sem_ch12.adb (Validate_Private_Type_Instance): Test the + Is_Mutably_Tagged_Type flag instead of Class_Wide_Equivalent_Type. + (Instantiate_Type): Likewise. + * sem_util.adb (Needs_Finalization): Return False for a class-wide + type if the root type has the No_Controlled_Parts aspect, and return + True for a mutably tagged class-wide equivalent type unless the root + type has the No_Controlled_Parts aspect. + +2026-09-22 Eric Botcazou + + * freeze.adb (Freeze_Full_Expression): Also freeze the stand-alone + objects of the current scope when they are referenced. + * sem_ch6.adb (Analyze_Expression_Function): Do not check the use + of a dynamically tagged expression if an error has been posted. + +2026-09-22 Eric Botcazou + + * freeze.ads (Freeze_Entity): Move around. + (Freeze_Before): Rename T parameter to E. + (Freeze_Expression): Improve description. + (Freeze_Expr_Types_Before): Rename to... + (Freeze_Full_Expression_Before): ...this. + * freeze.adb (Freeze_Expr_Types): Rename to... + (Freeze_Full_Expression): ...this. + (Freeze_Before): Rename T parameter to E and Pack variable to Scop. + (Freeze_Entity): Adjust to above renaming. + (Freeze_Expression): Likewise. + (Freeze_Expr_Types_Before): Rename to... + (Freeze_Full_Expression_Before): ...this. + * contracts.adb (Analyze_Entry_Or_Subprogram_Contract): Adjust to + above renaming. + (Expand_Subprogram_Contract): Likewise. + * sem_ch6.adb (Analyze_Expression_Function): Likewise. + +2026-09-22 Eric Botcazou + + * sinfo.ads (Selector_Name): Beef up description. + * sem_ch3.adb (Contains_Lib_Incomplete_Type): Delete. + (Analyze_Declarations): Remove obsolete code. + * sem_ch13.adb (Resolve_Aspect_Expressions.Resolve_Name): Resolve + only names that are not selector names. + +2026-09-22 Eric Botcazou + + * exp_ch6.adb (Expand_Simple_Function_Return): Fix typo. + +2026-09-22 Eric Botcazou + + * accessibility.ads (Needs_Accessibility_Level_Temp_Or_Check): + Delete. + * accessibility.adb: Add clauses for Sem_Eval. + (Accessibility_Level): Add support for conditional expressions. + (Needs_Accessibility_Level_Temp_Or_Check): Delete. + * exp_ch4.adb (Expand_N_If_Expression): Do not force expansion for + the sake of accessibility checks. + * exp_ch6.adb (Create_Extra_Actuals): Remove specific support of + extra accessibility formal for conditional expressions. + * sem_eval.ads (Match_Result): New enumeration type moved from... + (Choices_Match): New function declaration moved from... + (Set_Checking_Potentially_Static_Expression): Alphabetize. + * sem_eval.adb (Match_Result): ...here. + (Choices_Match): ...here. + (Eval_Case_Expression): Replace loop with call to Choices_Match. + +2026-09-22 Eric Botcazou + + * exp_ch4.adb (Is_Copy_Type): New global predicate. + (Expand_N_Case_Expression.Is_Copy_Type): Delete. + (Expand_N_Expression_With_Actions.Is_Copy_Type): Likewise. + (Expand_N_If_Expression.Is_Copy_Type): Likewise. + * layout.adb (Layout_Type): Compute the size(s) of a 1-dimensional + array type in more cases. + * sem_attr.adb (Analyze_Access_Attribute): Add guard. + * sem_ch13.adb (Analyze_Attribute_Definition_Clause) + : Reset the size(s) if the clause is not confirming. + * sem_eval.adb (Compile_Time_Known_Bounds): Bail out if an error has + been posted on the range node. + * sem_res.adb (Valid_Conversion): Return early on N_Raise_xxx_Error. + +2026-09-22 Eric Botcazou + + * gen_il-fields.ads (Opt_Field_Enum): Remove Minimum_Accessibility + and add Extra_Accessibility_Of_Subprogram. + * gen_il-gen-gen_entities.adb (Formal_Kind): Likewise. + (Subprogram_Kind): Likewise. + * einfo.ads (Extra_Accessibility_Of_Subprogram): Add description. + (Minimum_Accessibility): Remove description. + * accessibility.ads (Accessibility_Level_Kind): Move to... + (Accessibility_Level): Move to... + (Dynamic_Accessibility_Level): New function declaration. + (Dynamic_Local_Access_Level): Likewise. + (Dynamic_Subprogram_Access_Level): Likewise. + (Get_Dynamic_Accessibility): Delete. + (Static_Accessibility_Level_Kind): Likewise. + (Deepest_Type_Access_Level): Likewise. + (Static_Accessibility_Level): Replace second formal parameter. + (Static_Local_Access_Level): New function declaration. + (Static_Type_Access_Level): Likewise. + (Subprogram_Access_Level): Delete. + (Type_Access_Level): Move to... + * accessibility.adb (Accessibility_Level_Kind): ...here. + (Accessibility_Level): ...here. + (Type_Access_Level): ...here. + (Offset_Static_Level): New function declaration. + (Accessibility_Level): Add Static formal parameter and change the + result type. Change the result type of most nested functions and + ultimately call Offset_Static_Level if Static is set to False. + (Apply_Accessibility_Check_For_Class_Wide_Allocator): Use explicit + static or dynamic variant of level computation functions. + (Apply_Accessibility_Check_For_Anonymous_Return): Likewise. + (Apply_Accessibility_Check_For_Class_Wide_Return): Likewise. + (Apply_Accessibility_Check_For_Discriminated_Allocator): Likewise. + (Apply_Accessibility_Check_For_Conversion): Likewise. + (Check_Return_Construct_Accessibility): Likewise. + (Apply_Accessibility_Check_For_Return): Fix typo in comment. + (Dynamic_Accessibility_Level): New function body. + (Dynamic_Local_Access_Level): Likewise. + (Dynamic_Subprogram_Access_Level): Likewise. + (Dynamic_Type_Access_Level): Likewise. + (Get_Dynamic_Accessibility): Delete. + (Offset_Static_Level): New function body. + (Static_Accessibility_Level): Adjust. + (Static_Local_Access_Level): New function body. + (Static_Subprogram_Access_Level): Likewise. + (Static_Type_Access_Level): Likewise. + (Deepest_Type_Access_Level): Merge implementation into... + (Type_Access_Level): ...this. Add Deepest formal parameter and + change the result type. Compute a base entity and an offset. + * contracts.adb (Build_Subprogram_Contract_Wrapper): Do not move the + declaration of the Extra_Accessibility_Of_Subprogram constant. + * exp_aggr.adb: Add clauses for Accessibility. + (In_Place_Assign_OK): Call Static_Local_Access_Level instead of + doing the level calculation manually. + * exp_attr.adb (Expand_N_Attribute_Reference.Write_Controlling_Tag): + Call appropriate accessibility level calculation routine. + * exp_ch3.adb (Build_Initialization_Call): Likewise. + (Expand_N_Object_Declaration): Likewise. + (Freeze_Type): Likewise. + (Build_Record_Init_Proc): Do not create an extra accessibility + parameter for Activation_Chain and Finalization_Master. + * exp_ch4.adb (Expand_N_In): Call appropriate acccessibility level + calculation routine. + * exp_ch5.adb (Expand_N_Assignment_Statement): Likewise. + * exp_ch6.adb (Expand_Actuals): Likewise. + (Create_Extra_Actuals): Likewise. + * exp_ch9.adb (Expand_N_Requeue_Statement): Likewise and add missing + exception per RM 9.5.4(7.2). + * exp_disp.adb (Make_DT): Likewise. + * sem_attr.adb (Resolve_Attribute): Likewise. + * sem_ch3.adb (Analyze_Component_Declaration): Likewise. + (Build_Derived_Record_Type): Likewise. + (Derived_Type_Declaration): Likewise. + * sem_ch9.adb (Analyze_Requeue): Likewise and remove duplicate code. + * sem_ch13.adb (Analyze_Attribute_Definition_Clause): Likewise. + * sem_res.ads (Resolve_Entry): Remove obsolete comment. + * sem_res.adb (Resolve_Actuals): Likewise. + (Resolve_Allocator): Likewise. + (Valid_Conversion): Likewise. + (Resolve_Entry): Set Analyzed on the entry name before rewriting it. + * sem_util.adb (Check_Unprotected_Access): Likewise. + * sem_ch6.adb (Analyze_Function_Return): Likewise. + (Analyze_Subprogram_Body_Helper): Compute the extra accessibility + of the subprogram instead of minimum accessibility of parameters. + (Create_Extra_Formals): Create an extra accessibility formal for + an access-to-subprogram parameter if the profile of the designated + type has at least one parameter that needs one. + +2026-09-22 Eric Botcazou + + * exp_ch3.adb (Expand_Freeze_Record_Type): Move up early return for + types derived from an untagged private type. + +2026-09-22 Andrew Teylu + + * libgnat/s-dwalin.ads (Dwarf_Context): Add Has_Line_Str. + * libgnat/s-dwalin.adb (Open): Set Has_Line_Str when creating the + line-string stream. + (Close): Close the line-string stream if it was created. + +2026-09-22 Viljar Indus + + * gcc-interface/trans.cc (can_equal_min_Or_max_val_p): Add guard + for integral types. + +2026-09-22 Eric Botcazou + + * gcc-interface/decl.cc (allocatable_size_p): Add INTERFACE_P + parameter and return true for any fixed size when it is true. + (gnat_to_gnu_entity): Add EXPORTED_P local variable and use it + throughout. + : Adjust calls to allocatable_size_p by passing true + for INTERFACE_P if the object is exported or imported. Remove + unreachable code giving a warning for too large imported objects. + 2026-09-21 Eric Botcazou * gcc-interface/misc.cc (gnat_get_array_descr_info): Return the diff --git a/gcc/algol68/ChangeLog b/gcc/algol68/ChangeLog index 653e012620a2..0d55cccaaa28 100644 --- a/gcc/algol68/ChangeLog +++ b/gcc/algol68/ChangeLog @@ -1,3 +1,8 @@ +2026-09-22 Jose E. Marchesi + + * a68-low.cc (lower_module_text): Mark prelude_decl an + postlude_decl as artificial. + 2026-09-21 Jose E. Marchesi * a68-parser-modes.cc (a68_resolve_equivalent): Rename from diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog index 9f39aef89187..4d330ce5476b 100644 --- a/gcc/c-family/ChangeLog +++ b/gcc/c-family/ChangeLog @@ -1,3 +1,7 @@ +2026-09-22 Chung-Lin Tang + + * c-pragma.h (enum pragma_omp_clause): Add PRAGMA_OMP_CLAUSE_LOCAL. + 2026-09-18 Alfie Richards * c-attribs.cc (handle_mode_attribute): Use parse_machine_mode. diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog index a06e4f0653e4..0eeb1c865b97 100644 --- a/gcc/c/ChangeLog +++ b/gcc/c/ChangeLog @@ -1,3 +1,12 @@ +2026-09-22 Chung-Lin Tang + + * c-parser.cc (c_parser_omp_clause_name): Add "local" case. + (c_parser_omp_all_clauses): Add PRAGMA_OMP_CLAUSE_LOCAL case. + (OMP_DECLARE_TARGET_CLAUSE_MASK): Add PRAGMA_OMP_CLAUSE_LOCAL. + ( c_parser_omp_declare_target): Handle OMP_CLAUSE_LOCAL. + * c-typeck.cc (c_finish_omp_clauses): Handle OMP_CLAUSE_LOCAL. + Emit error if local clause variable appears in map clause. + 2026-09-21 Jakub Jelinek * c-decl.cc (names_builtin_p): Return 1 for diff --git a/gcc/cobol/ChangeLog b/gcc/cobol/ChangeLog index 1aac95e28884..4eca8f3da1f2 100644 --- a/gcc/cobol/ChangeLog +++ b/gcc/cobol/ChangeLog @@ -1,3 +1,8 @@ +2026-09-22 James K. Lowden + + * parse_ante.h (update_prior_invalid_field): Use is_figconst. + (field_add): Always call update_prior_invalid_field. + 2026-09-21 Robert Dubner * genapi.cc (actually_create_the_static_field): Use the diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 6688d9e4a28e..6c9b49c2b6f2 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,19 @@ +2026-09-22 Chung-Lin Tang + + * parser.cc (cp_parser_omp_clause_name): Add "local" case. + (cp_parser_omp_all_clauses): Add PRAGMA_OMP_CLAUSE_LOCAL case. + (handle_omp_declare_target_clause): Handle OMP_CLAUSE_LOCAL. + (OMP_DECLARE_TARGET_CLAUSE_MASK): Add PRAGMA_OMP_CLAUSE_LOCAL. + * semantics.cc (finish_omp_clauses): Handle OMP_CLAUSE_LOCAL. + Emit error if local clause variable appears in map clause. + +2026-09-22 Joshua Berne + + PR c++/125459 + * constexpr.cc (constexpr_global_ctx::put_value): Treat + void_list_node as not having been in the map for modifiable + tracking. + 2026-09-21 Jakub Jelinek PR c++/127493 diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog index 45013116f338..9973d1051e3d 100644 --- a/gcc/fortran/ChangeLog +++ b/gcc/fortran/ChangeLog @@ -1,3 +1,13 @@ +2026-09-22 Chung-Lin Tang + + * openmp.cc (gfc_match_omp_declare_target): Adjust error handling + to handle local clause. + * trans-common.cc (build_common_decl): Adjust handling of device_type + clause, remove sorry and FIXME of LOCAL clause, handle local clause. + * trans-decl.cc (add_attributes_to_decl): Adjust handling of device_type + clause, remove sorry of LOCAL clause, adjust creating of + "omp declare target [link]" attribute between OpenACC/OpenMP. + 2026-09-21 Mikael Morin PR fortran/127448 diff --git a/gcc/m2/ChangeLog b/gcc/m2/ChangeLog index 19b3f92dcfdb..2701442355ea 100644 --- a/gcc/m2/ChangeLog +++ b/gcc/m2/ChangeLog @@ -1,3 +1,25 @@ +2026-09-22 Gaius Mulley + + PR modula2/127554 + * gm2-compiler/M2MetaError.mod (SpellHint): Allow error symbols to + be spell checked. + * gm2-compiler/M2Quads.mod (BuildConstructor): Generate a spelling + hint error message if the name is set and an error is seen. + (PopTntok): New procedure. + * gm2-compiler/PCBuild.bnf (CreateQualident): New procedure. + (PushQualident): Reimplement. + * gm2-compiler/PCSymBuild.mod (PCStartBuildDefModule): Push + module to spelling stack. + (PCStartBuildImpModule): Ditto. + (PCStartBuildInnerModule): Ditto. + (PCEndBuildDefModule): Pop top of spell stack. + (PCEndBuildImpModule): Ditto. + (PCEndBuildProgModule): Ditto. + (PCEndBuildInnerModule): Ditto. + (PCEndBuildProcedure): Ditto. + (PCBuildProcedureHeading): Ditto. + (PCEndBuildForward): Reimplement. + 2026-09-21 Gaius Mulley PR modula2/127469 diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 6d37df1278b4..7a2ecac1bd5c 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,106 @@ +2026-09-22 Jose E. Marchesi + + * algol68/compile/prepostlude-crash-1.a68: New test. + +2026-09-22 Chung-Lin Tang + + * c-c++-common/gomp/declare-target-1.c: Add local clause test. + * c-c++-common/gomp/declare-target-8.c: New testcase. + * gfortran.dg/gomp/declare-target-1.f90: Add local clause test. + * gfortran.dg/gomp/declare-target-7.f90: New testcase. + * gfortran.dg/gomp/groupprivate-2.f90: Adjust test. + +2026-09-22 Xavier Del Campo Romero + + * cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.cob: + Update test to new behaviour. + * cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.out: Likewise. + +2026-09-22 Eric Botcazou + + * gnat.dg/access12.adb: Adjust error message. + * gnat.dg/aliased3.adb: Likewise. + +2026-09-22 Vladimir N. Makarov + + PR rtl-optimization/127326 + * gcc.target/i386/pr127326.c: New. + +2026-09-22 Joshua Berne + + PR c++/125459 + * g++.dg/contracts/cpp26/pr125459.C: New test. + +2026-09-22 Gaius Mulley + + PR modula2/127554 + * gm2.dg/spell/iso/fail/constaggregate.mod: New test. + +2026-09-22 Roger Sayle + Hongtao Liu + + * gcc.target/i386/pr126293-15.c: Update test case. + * gcc.target/i386/pr126293-5.c: Likewise. + +2026-09-22 Jakub Jelinek + + PR middle-end/127492 + * gcc.dg/pr127492.c: New test. + +2026-09-22 Wilco Dijkstra + + * gcc.target/aarch64/atomic-store2.c: New test. + +2026-09-22 liuhongt + + PR tree-optimization/126486 + * gcc.dg/tree-ssa/pr126486.c: New test. + * gcc.dg/tree-ssa/pr19210-1.c: Remove obsolete missed diagnostic. + * gcc.target/i386/kortest_ccz-1.c: Restrict no-kmov scan to non-ia32. + Assisted-by: openai.gpt-5.6-sol xhigh + +2026-09-22 liuhongt + + PR target/127500 + * gcc.target/i386/pr127500.c: New test. + +2026-09-22 Naveen + + PR tree-optimization/112626 + PR tree-optimization/112626 + * gcc.dg/tree-ssa/pr112626.c: New test. + * gcc.dg/tree-ssa/pr112626-wrap.c: New test. + +2026-09-22 Pan Li + + PR target/127269 + * gcc.target/riscv/rvv/base/pr127269-18.c: New test. + * gcc.target/riscv/rvv/base/pr127269-19.c: New test. + * gcc.target/riscv/rvv/base/pr127269-20.c: New test. + * gcc.target/riscv/rvv/base/pr127269-21.c: New test. + * gcc.target/riscv/rvv/base/pr127269-22.c: New test. + +2026-09-22 Pan Li + + * gcc.target/riscv/rvv/base/pr112431-42.c: Remove the xfail + of the vmv1r check. + +2026-09-22 Pan Li + + * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-m1.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-m2.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-m4.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-mf2.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f16-mf4.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-m1.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-m2.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-m4.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_wv-f32-mf2.c: New test. + +2026-09-22 Andrea Pinski + + * c-c++-common/gomp/has-include-1.c: Add second dg-error. + 2026-09-21 Eric Botcazou * gnat.dg/array44.adb: New test. diff --git a/libgcobol/ChangeLog b/libgcobol/ChangeLog index 2669fb410919..db6013de2884 100644 --- a/libgcobol/ChangeLog +++ b/libgcobol/ChangeLog @@ -1,3 +1,13 @@ +2026-09-22 Xavier Del Campo Romero + + * compat/gnu/lib/cbl_gpi.cc (struct gpi_priv): Fix flawed logic. + (getlastprog): Likewise. + (callstack): Likewise. + (cbl_gpi_cur_status): Likewise. + (cbl_gpi_handle_status): Likewise. + (cbl_gpi_parent_status): Likewise. + (cbl_gpi_close_handle): Likewise. + 2026-09-21 Robert Dubner * libgcobol.cc (int128_to_field): Remove rdigits formal parameter. diff --git a/libgomp/ChangeLog b/libgomp/ChangeLog index 96b34856a7ad..8c00ae010636 100644 --- a/libgomp/ChangeLog +++ b/libgomp/ChangeLog @@ -1,3 +1,11 @@ +2026-09-22 Chung-Lin Tang + + * testsuite/libgomp.c-c++-common/declare-target-local-1.c: New test. + * testsuite/libgomp.c-c++-common/declare-target-local-2.c: New test. + * testsuite/libgomp.c-c++-common/declare-target-local-3.c: New test. + * testsuite/libgomp.c-c++-common/declare-target-local-4.c: New test. + * testsuite/libgomp.fortran/declare-target-local-1.f90: New test. + 2026-09-21 Tobias Burnus * libgomp.texi (OpenMP 5.2 Impl. Status): Mark comma between diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index a7eb187b2315..76fbbcdb629a 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,87 @@ +2026-09-22 Jonathan Wakely + + * config/io/basic_file_stdio.h (__basic_file): Define copy + constructor and copy assignment operator as deleted for C++98. + * include/bits/stl_bvector.h (vector::data): Define as + deleted for C++98. + * include/bits/stl_tree.h (_Reuse_or_alloc_node): Define copy + constructor as deleted for C++98. + * include/bits/stl_vector.h (_Asan>::_Reinit): + Define copy constructor and copy assignment operator as deleted + for C++98. + (_Asan>::_Grow): Likewise. + * testsuite/util/replacement_memory_operators.h + (__gnu_test::counter::scope): Likewise. + * testsuite/util/testsuite_iterators.h (operator,, operator&) + (operator+=, operator-=, operator[]): Define deleted operators + for C++98. + +2026-09-22 Patrick Palka + Tomasz Kamiński + + PR libstdc++/126120 + * include/bits/shared_ptr.h (std::__shared_nullptr_ctor_tag): + Define. + (shared_ptr::shared_ptr(nullptr_t, ...)): Constrain _Deleter + via _NullptrDeleter parameter. + * include/bits/shared_ptr_base.h (__shared_ptr::_ValidDeleter): + New __enable_if_t constraint. + (__shared_ptr::__shared_ptr(Yp*, _Deleter, ...)): Add _ValidDeleter + constraint. Move static_assert checking deleter invocability + to corresponding reset functions. + (__shared_ptr::reset): Add static_assert checks for deleter + invocability. + * testsuite/20_util/shared_ptr/cons/126120.cc: New test. + +2026-09-22 Tamar Christina + + PR libstdc++/126274 + * include/bits/regex_executor.h (_M_match_simple_repeat_body): New. + * include/bits/regex_executor.tcc (_M_dfs_next): Inline consume matches + on _S_opcode_repeat. + (_M_match_simple_repeat_body): New. + +2026-09-22 Tamar Christina + + PR libstdc++/126274 + PR libstdc++/88947 + * include/bits/regex_executor.h (_M_search_from_first): Avoid needless + recursions. + (_M_maybe_start_match): New. + * include/bits/regex_executor.tcc (_M_maybe_start_match): New. + +2026-09-22 Tamar Christina + + PR libstdc++/126274 + * include/bits/regex_executor.h (_Search_mode): Move to top level. + (_M_handle_repeat, _M_handle_match, _M_handle_accept, _M_node, _M_dfs): + Add template parameter. + (_M_visited): Add inline keyword. + * include/bits/regex_executor.tcc (_M_handle_repeat, _M_handle_match, + _M_handle_accept, _M_node, _M_dfs): Use template parameter. + +2026-09-22 Tamar Christina + + PR libstdc++/126274 + * include/bits/regex_executor.h (_Executor): Reserve frame space. + (_M_rep_once_more, _M_handle_repeat, _M_handle_subexpr_begin, + _M_handle_subexpr_end, _M_handle_line_begin_assertion, + _M_handle_line_end_assertion, _M_handle_word_boundary, + _M_handle_subexpr_lookahead, _M_handle_match, _M_handle_backref, + _M_node): return StateIdT. + (_M_visited): Mark inline. + * include/bits/regex_executor.tcc (_M_rep_once_more, _M_handle_repeat, + _M_handle_subexpr_begin, _M_handle_subexpr_end, + _M_handle_line_begin_assertion, _M_handle_line_end_assertion, + _M_handle_word_boundary, _M_handle_subexpr_lookahead, _M_handle_match, + _M_handle_backref): Return state, mark always inline. + (_M_node): Return StateIdT and also decide what to do with the value + after return. + (_M_dfs): Traverse states iteratively for _S_fopcode_next, + _S_fopcode_fallback_next, _S_fopcode_fallback_rep_once_more + and _S_fopcode_rep_once_more. + * include/bits/regex.h (class _Executor): Move to V2 ABI. + 2026-09-21 Tomasz Kamiński PR libstdc++/82749 From dc301f9b3da5d0a367a0a6be394eba318d3f5b92 Mon Sep 17 00:00:00 2001 From: Matthias Kretz Date: Tue, 22 Sep 2026 11:59:06 +0200 Subject: [PATCH 357/584] x86: Vectorize roundeven Similar to nearbyint, floor, ceil, and trunc, use (v)roundp[sd] or vrndscalep[hsd] to vectorize calls to roundeven. gcc/ChangeLog: * config/i386/sse.md (roundeven2): New. gcc/testsuite/ChangeLog: * gcc.target/i386/avx-roundeven.c: New test. * gcc.target/i386/avx512f-roundeven.c: New test. * gcc.target/i386/avx512fp16-roundeven.c: New test. * gcc.target/i386/sse4_1-roundeven.c: New test. Signed-off-by: Matthias Kretz --- gcc/config/i386/sse.md | 9 +++++++ gcc/testsuite/gcc.target/i386/avx-roundeven.c | 6 +++++ .../gcc.target/i386/avx512f-roundeven.c | 6 +++++ .../gcc.target/i386/avx512fp16-roundeven.c | 13 ++++++++++ .../gcc.target/i386/sse4_1-roundeven.c | 24 +++++++++++++++++++ 5 files changed, 58 insertions(+) create mode 100644 gcc/testsuite/gcc.target/i386/avx-roundeven.c create mode 100644 gcc/testsuite/gcc.target/i386/avx512f-roundeven.c create mode 100644 gcc/testsuite/gcc.target/i386/avx512fp16-roundeven.c create mode 100644 gcc/testsuite/gcc.target/i386/sse4_1-roundeven.c diff --git a/gcc/config/i386/sse.md b/gcc/config/i386/sse.md index 6b57c3019b26..0ce82789dc6c 100644 --- a/gcc/config/i386/sse.md +++ b/gcc/config/i386/sse.md @@ -27081,6 +27081,15 @@ (set_attr "prefix" "orig,orig,vex,evex") (set_attr "mode" "")]) +(define_expand "roundeven2" + [(set (match_operand:VFH 0 "register_operand") + (unspec:VFH + [(match_operand:VFH 1 "vector_operand") + (match_dup 2)] + UNSPEC_ROUND))] + "TARGET_SSE4_1" + "operands[2] = GEN_INT (ROUND_ROUNDEVEN | ROUND_NO_EXC);") + (define_expand "floor2" [(set (match_operand:VFH 0 "register_operand") (unspec:VFH diff --git a/gcc/testsuite/gcc.target/i386/avx-roundeven.c b/gcc/testsuite/gcc.target/i386/avx-roundeven.c new file mode 100644 index 000000000000..bf279fa69281 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/avx-roundeven.c @@ -0,0 +1,6 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-vectorize -mavx -mno-avx2 -mprefer-vector-width=256 -masm=att -ftrapping-math" } */ +/* { dg-final { scan-assembler "vroundps\[ \t]\+\\\$8,\[^\n\r]*%y" } } */ +/* { dg-final { scan-assembler "vroundpd\[ \t]\+\\\$8,\[^\n\r]*%y" } } */ + +#include "sse4_1-roundeven.c" diff --git a/gcc/testsuite/gcc.target/i386/avx512f-roundeven.c b/gcc/testsuite/gcc.target/i386/avx512f-roundeven.c new file mode 100644 index 000000000000..425faf611065 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/avx512f-roundeven.c @@ -0,0 +1,6 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-vectorize -mavx512f -mprefer-vector-width=512 -masm=att -ftrapping-math" } */ +/* { dg-final { scan-assembler "vrndscaleps\[ \t]\+\\\$8,\[^\n\r]*%z" } } */ +/* { dg-final { scan-assembler "vrndscalepd\[ \t]\+\\\$8,\[^\n\r]*%z" } } */ + +#include "sse4_1-roundeven.c" diff --git a/gcc/testsuite/gcc.target/i386/avx512fp16-roundeven.c b/gcc/testsuite/gcc.target/i386/avx512fp16-roundeven.c new file mode 100644 index 000000000000..da74a4b33790 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/avx512fp16-roundeven.c @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-vectorize -mavx512fp16 -mprefer-vector-width=512 -masm=att -ftrapping-math" } */ +/* { dg-final { scan-assembler "vrndscaleph\[ \t]\+\\\$8,\[^\n\r]*%z" } } */ + +_Float16 a[32], b[32]; + +void +test_roundevenf (void) +{ + int i; + for (i = 0; i < 32; ++i) + b[i] = __builtin_roundevenf (a[i]); +} diff --git a/gcc/testsuite/gcc.target/i386/sse4_1-roundeven.c b/gcc/testsuite/gcc.target/i386/sse4_1-roundeven.c new file mode 100644 index 000000000000..9eeaa9ff19f9 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/sse4_1-roundeven.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -ftree-vectorize -msse4.1 -mno-sse4.2 -masm=att" } */ +/* { dg-final { scan-assembler "roundps\[ \t]\+\\\$8," } } */ +/* { dg-final { scan-assembler "roundpd\[ \t]\+\\\$8," } } */ + +float a[16], b[16]; +double c[8], d[8]; + +void +test_roundevenf (void) +{ + int i; + for (i = 0; i < 16; ++i) + b[i] = __builtin_roundevenf (a[i]); +} + +void +test_roundeven (void) +{ + int i; + for (i = 0; i < 8; ++i) + d[i] = __builtin_roundeven (c[i]); +} + From f6ee4d2a6070fda98a7cbb65aa8b3bb2903d77d0 Mon Sep 17 00:00:00 2001 From: Tamar Christina Date: Wed, 23 Sep 2026 07:55:53 +0100 Subject: [PATCH 358/584] AArch64: Apply VF cap consistently Use the same VF cap in the AArch64 body-cost adjustment and in the main-loop comparison. Known fixed-trip loops can execute fewer lanes than the architectural VF. The body-cost path already wanted to account for that, but the main-loop comparison still used the uncapped VF. This made the two parts of the cost model rank the same loop differently. This factors the cap into a small helper and uses it in both places. gcc/ChangeLog: * config/aarch64/aarch64.cc (aarch64_vect_vf_for_cost): New function. (aarch64_vector_costs::adjust_body_cost): Use it. (aarch64_vector_costs::better_main_loop_than_p): Likewise. --- gcc/config/aarch64/aarch64.cc | 50 +++++++++++++++++++++-------------- 1 file changed, 30 insertions(+), 20 deletions(-) diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc index f9d906f449f2..a96c140522c6 100644 --- a/gcc/config/aarch64/aarch64.cc +++ b/gcc/config/aarch64/aarch64.cc @@ -18986,6 +18986,29 @@ aarch64_external_adjust_stmt_cost (vect_cost_for_stmt kind, slp_tree node, return stmt_cost; } +/* Get the effecive VF to use for the loop in LOOP_VINFO. This is the VF that + should be used for costing purposes only. */ +static inline unsigned int +aarch64_vect_vf_for_cost (loop_vec_info loop_vinfo) +{ + unsigned int estimated_vf = vect_vf_for_cost (loop_vinfo); + + /* If we know we have a single partial vector iteration, cap the VF + to the number of scalar iterations for costing purposes. */ + if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)) + { + auto niters = LOOP_VINFO_INT_NITERS (loop_vinfo); + if (niters < estimated_vf && dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, + "Scalar loop iterates at most %wd times. Capping VF " + " from %d to %wd\n", niters, estimated_vf, niters); + + estimated_vf = MIN (estimated_vf, niters); + } + + return estimated_vf; +} + unsigned aarch64_vector_costs::add_stmt_cost (int count, vect_cost_for_stmt kind, stmt_vec_info stmt_info, slp_tree node, @@ -19349,7 +19372,7 @@ adjust_body_cost (loop_vec_info loop_vinfo, const auto &scalar_ops = scalar_costs->m_ops[0]; const auto &vector_ops = m_ops[0]; - unsigned int estimated_vf = vect_vf_for_cost (loop_vinfo); + unsigned int estimated_vf = aarch64_vect_vf_for_cost (loop_vinfo); unsigned int orig_body_cost = body_cost; bool should_disparage = false; @@ -19357,19 +19380,6 @@ adjust_body_cost (loop_vec_info loop_vinfo, dump_printf_loc (MSG_NOTE, vect_location, "Original vector body cost = %d\n", body_cost); - /* If we know we have a single partial vector iteration, cap the VF - to the number of scalar iterations for costing purposes. */ - if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)) - { - auto niters = LOOP_VINFO_INT_NITERS (loop_vinfo); - if (niters < estimated_vf && dump_enabled_p ()) - dump_printf_loc (MSG_NOTE, vect_location, - "Scalar loop iterates at most %wd times. Capping VF " - " from %d to %wd\n", niters, estimated_vf, niters); - - estimated_vf = MIN (estimated_vf, niters); - } - fractional_cost scalar_cycles_per_iter = scalar_ops.min_cycles_per_iter () * estimated_vf; @@ -19561,14 +19571,16 @@ better_main_loop_than_p (const vector_costs *uncast_other) const auto this_loop_vinfo = as_a (this->m_vinfo); auto other_loop_vinfo = as_a (other->m_vinfo); + auto this_loop_vf = aarch64_vect_vf_for_cost (this_loop_vinfo); + auto other_loop_vf = aarch64_vect_vf_for_cost (other_loop_vinfo); if (dump_enabled_p ()) dump_printf_loc (MSG_NOTE, vect_location, "Comparing two main loops (%s at VF %d vs %s at VF %d)\n", GET_MODE_NAME (this_loop_vinfo->vector_mode), - vect_vf_for_cost (this_loop_vinfo), + this_loop_vf, GET_MODE_NAME (other_loop_vinfo->vector_mode), - vect_vf_for_cost (other_loop_vinfo)); + other_loop_vf); /* Apply the unrolling heuristic described above m_unrolled_advsimd_niters. */ @@ -19604,10 +19616,8 @@ better_main_loop_than_p (const vector_costs *uncast_other) const other->m_ops[i].dump (); } - auto this_estimated_vf = (vect_vf_for_cost (this_loop_vinfo) - * this->m_ops[i].vf_factor ()); - auto other_estimated_vf = (vect_vf_for_cost (other_loop_vinfo) - * other->m_ops[i].vf_factor ()); + auto this_estimated_vf = (this_loop_vf * this->m_ops[i].vf_factor ()); + auto other_estimated_vf = (other_loop_vf * other->m_ops[i].vf_factor ()); /* If it appears that one loop could process the same amount of data in fewer cycles, prefer that loop over the other one. */ From 2f389cf7ac917207f93103cf7f955432580681d1 Mon Sep 17 00:00:00 2001 From: Tamar Christina Date: Wed, 23 Sep 2026 07:56:27 +0100 Subject: [PATCH 359/584] AArch64: cost SAD and ABD reductions for Adv.SIMD vs SVE Account for the real Adv.SIMD cost of SAD and ABD reductions. For SAD_EXPR, Adv.SIMD has to build a 128-bit result from two 64-bit halves. Account for that extra work when costing 128-bit Adv.SIMD vectors. For SAD-style ABD reductions, SVE can keep the byte absolute difference as uabd and then use udot for the widening sum. Without dot-product support, the Adv.SIMD fallback is a longer dependent sequence, using uabdl/uabal followed by the widening reduction. Charge that extra Adv.SIMD work in both the statement cost and the issue model, so scalar profitability and vector-loop comparison stay in sync. gcc/ChangeLog: * config/aarch64/aarch64.cc (aarch64_ifn_vect_stmt_p): New function. (aarch64_adjust_stmt_cost): Account for extra Adv.SIMD SAD and ABD reduction costs. (aarch64_vector_costs::count_ops): Likewise. --- gcc/config/aarch64/aarch64.cc | 84 +++++++++++++++++++++++++++++++++++ 1 file changed, 84 insertions(+) diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc index a96c140522c6..2ca834c92b16 100644 --- a/gcc/config/aarch64/aarch64.cc +++ b/gcc/config/aarch64/aarch64.cc @@ -18447,6 +18447,75 @@ aarch64_sve_adjust_stmt_cost (class vec_info *vinfo, vect_cost_for_stmt kind, return stmt_cost; } +/* Return > 0 if STMT_INFO is the instruction requires additional costing. The + instruction is evaluated as being vectorized as VECTYPE and the return value + should be the additional number of instructions that need to be costed. */ +static unsigned int +aarch64_ifn_vect_stmt_p (stmt_vec_info stmt_info, tree vectype) +{ + stmt_info = vect_stmt_to_vectorize (stmt_info); + gcall *call = dyn_cast (STMT_VINFO_STMT (stmt_info)); + if (!vectype) + return 0; + + gassign *assign = dyn_cast (STMT_VINFO_STMT (stmt_info)); + if (!call && !assign) + return 0; + + auto vec_flags = aarch64_classify_vector_mode (TYPE_MODE (vectype)); + bool advsimd_p = vec_flags & VEC_ADVSIMD; + bool is_128bit_p = known_eq (GET_MODE_BITSIZE (TYPE_MODE (vectype)), 128); + if (assign) + { + switch (gimple_assign_rhs_code (assign)) + { + /* SAD for Adv. SIMD is emulated using two instuctions per 64-bit + quantities. So 128-bit ADB requires 4 INSN. Account for that. */ + case SAD_EXPR: + return advsimd_p && is_128bit_p ? 2 : 0; + case WIDEN_SUM_EXPR: + { + tree rhs = gimple_assign_rhs1 (assign); + if (!advsimd_p + || TARGET_DOTPROD + || !vect_is_reduction (stmt_info) + || TREE_CODE (rhs) != SSA_NAME) + return 0; + + gimple *def_stmt = SSA_NAME_DEF_STMT (rhs); + gassign *def_assign = dyn_cast (def_stmt); + if (def_assign + && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_assign)) + && TREE_CODE (gimple_assign_rhs1 (def_assign)) == SSA_NAME) + def_stmt = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (def_assign)); + + gcall *def = dyn_cast (def_stmt); + if (!def || gimple_call_combined_fn (def) != CFN_ABD) + return 0; + + for (unsigned int i = 0; i < 2; ++i) + { + tree arg = gimple_call_arg (def, i); + if (TREE_CODE (arg) != SSA_NAME + || !gimple_assign_load_p (SSA_NAME_DEF_STMT (arg))) + return 0; + } + return 2; + } + default: + break; + } + return 0; + } + + switch (gimple_call_combined_fn (call)) + { + default: + break; + } + return 0; +} + /* STMT_COST is the cost calculated for STMT_INFO, which has cost kind KIND and which when vectorized would operate on vector type VECTYPE. Add the cost of any embedded operations. */ @@ -18572,6 +18641,13 @@ aarch64_vector_costs::count_ops (unsigned int count, vect_cost_for_stmt kind, return; } + unsigned int n_insn = 0; + if (stmt_info + && kind == vector_stmt + && (n_insn = aarch64_ifn_vect_stmt_p (stmt_info, + STMT_VINFO_VECTYPE (stmt_info)))) + ops->general_ops += n_insn * count; + /* Detect the case where we are using an emulated gather/scatter. When a target does not support gathers and scatters directly the vectorizer emulates these by constructing an index vector and then issuing an @@ -19153,6 +19229,14 @@ aarch64_vector_costs::add_stmt_cost (int count, vect_cost_for_stmt kind, to the base cost calculated above. */ stmt_cost = aarch64_adjust_stmt_cost (m_vinfo, kind, stmt_info, node, vectype, m_vec_flags, stmt_cost); + unsigned int n_insn = 0; + if (vectype + && kind == vector_stmt + && (n_insn = aarch64_ifn_vect_stmt_p (stmt_info, vectype))) + { + const simd_vec_cost *simd_costs = aarch64_simd_vec_costs (vectype); + stmt_cost += count * n_insn * simd_costs->int_stmt_cost; + } /* If we're applying the SVE vs. Advanced SIMD unrolling heuristic, estimate the number of statements in the unrolled Advanced SIMD From 1743eb860b739c0bae408536d6a9459f2325fe18 Mon Sep 17 00:00:00 2001 From: Tamar Christina Date: Wed, 23 Sep 2026 07:57:01 +0100 Subject: [PATCH 360/584] middle-end: fold VEC_UNPACK_LO/_HI over poly constants Fold integer VEC_UNPACK_LO_EXPR and VEC_UNPACK_HI_EXPR for suitable variable-length VECTOR_CSTs. The patch adds support for other _LO, _HI expressions but it's expected that those be almost never use but the code unifies the VLA and VLS paths. The fixed-length case already folds. This extends the same idea to VLA constants when the input has twice as many elements as the output and the selected half can be represented as a valid VECTOR_CST. This helps fold known predicate constants before RTL expansion, avoiding unnecessary predicate unpack instructions. The pattern should be a 1 or 2 alternatives repeating pattern in the form of { a1,...,an,b1,...,bn,b1,...,bn,b1,...,bn,... } where N == NPATTERNS and where ai == bi for NELTS_PER_PATTERN == 1 but not necessarily for NELTS_PER_PATTERN == 2. This show up often with known iteration loops and folding these in gimple allows us to fold away unrolled masks which end up being empty. The selftests cover the foldable low/high cases and cases that should not fold. gcc/ChangeLog: * fold-const.cc (const_unop): Fold VEC_UNPACK_LO_EXPR and VEC_UNPACK_HI_EXPR for suitable variable-length VECTOR_CSTs. (selftest::test_vec_unpack_folding): New function. (selftest::fold_const_cc_tests): Call it. --- gcc/fold-const.cc | 220 +++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 207 insertions(+), 13 deletions(-) diff --git a/gcc/fold-const.cc b/gcc/fold-const.cc index b9262b34f766..8c5e558647c3 100644 --- a/gcc/fold-const.cc +++ b/gcc/fold-const.cc @@ -1948,22 +1948,14 @@ const_unop (enum tree_code code, tree type, tree arg0) case VEC_UNPACK_FIX_TRUNC_LO_EXPR: case VEC_UNPACK_FIX_TRUNC_HI_EXPR: { - unsigned HOST_WIDE_INT out_nelts, in_nelts, i; + poly_uint64 out_nelts = TYPE_VECTOR_SUBPARTS (type); + unsigned HOST_WIDE_INT npatterns, nelts_per_pattern, i, offset = 0; enum tree_code subcode; if (TREE_CODE (arg0) != VECTOR_CST) return NULL_TREE; - if (!VECTOR_CST_NELTS (arg0).is_constant (&in_nelts)) - return NULL_TREE; - out_nelts = in_nelts / 2; - gcc_assert (known_eq (out_nelts, TYPE_VECTOR_SUBPARTS (type))); - - unsigned int offset = 0; - if ((!BYTES_BIG_ENDIAN) ^ (code == VEC_UNPACK_LO_EXPR - || code == VEC_UNPACK_FLOAT_LO_EXPR - || code == VEC_UNPACK_FIX_TRUNC_LO_EXPR)) - offset = out_nelts; + gcc_assert (known_eq (VECTOR_CST_NELTS (arg0), out_nelts * 2)); if (code == VEC_UNPACK_LO_EXPR || code == VEC_UNPACK_HI_EXPR) subcode = NOP_EXPR; @@ -1973,8 +1965,40 @@ const_unop (enum tree_code code, tree type, tree arg0) else subcode = FIX_TRUNC_EXPR; - tree_vector_builder elts (type, out_nelts, 1); - for (i = 0; i < out_nelts; i++) + bool low_p = (code == VEC_UNPACK_LO_EXPR + || code == VEC_UNPACK_FLOAT_LO_EXPR + || code == VEC_UNPACK_FIX_TRUNC_LO_EXPR); + + npatterns = VECTOR_CST_NPATTERNS (arg0); + nelts_per_pattern = VECTOR_CST_NELTS_PER_PATTERN (arg0); + if (nelts_per_pattern <= 2 && multiple_p (out_nelts, npatterns)) + /* The input is: + + { a1,...,an,b1,...,bn,b1,...,bn,b1,...,bn,... } + + where N == NPATTERNS and where ai == bi for NELTS_PER_PATTERN == 1 + but not necessarily for NELTS_PER_PATTERN == 2. + + When unpacking the first half, the shape of the output is the same + as the input. That shape would also work for the second half, + but setting the output nelts_per_patterns to 1 is always enough + in that case (since the output always starts on b1). */ + ; + else + { + if (!out_nelts.is_constant (&npatterns)) + return NULL_TREE; + nelts_per_pattern = 1; + } + + if ((!BYTES_BIG_ENDIAN) ^ low_p) + { + offset = npatterns; + nelts_per_pattern = 1; + } + + tree_vector_builder elts (type, npatterns, nelts_per_pattern); + for (i = 0; i < npatterns * nelts_per_pattern; i++) { tree elt = fold_convert_const (subcode, TREE_TYPE (type), VECTOR_CST_ELT (arg0, i + offset)); @@ -17752,6 +17776,175 @@ test_vec_duplicate_folding () ASSERT_TRUE (operand_equal_p (dup5_expr, dup5_cst, 0)); } +/* Verify folding of VEC_UNPACK_{LO,HI}_EXPRs. */ + +static void +test_vec_unpack_folding () +{ + machine_mode vmode; + FOR_EACH_MODE_IN_CLASS (vmode, MODE_VECTOR_INT) + { + poly_uint64 in_nelts = GET_MODE_NUNITS (vmode); + if (!test_fold_vec_perm_cst::is_simple_vla_size (in_nelts) + || in_nelts.coeffs[0] < 2 + || !targetm.vector_mode_supported_p (vmode)) + continue; + + unsigned int in_bits = GET_MODE_UNIT_BITSIZE (vmode); + if (in_bits >= HOST_BITS_PER_WIDE_INT) + continue; + + unsigned int min_out_nelts = in_nelts.coeffs[0] / 2; + tree in_inner_type = lang_hooks.types.type_for_mode + (GET_MODE_INNER (vmode), 1); + tree out_inner_type = build_nonstandard_integer_type (in_bits * 2, 1); + tree in_type = build_vector_type_for_mode (in_inner_type, vmode); + poly_uint64 out_nelts = exact_div (in_nelts, 2); + tree out_type = build_vector_type (out_inner_type, out_nelts); + + tree_vector_builder builder (in_type, in_nelts.coeffs[0], 2); + for (unsigned int i = 0; i < in_nelts.coeffs[0]; ++i) + builder.quick_push (build_int_cst (in_inner_type, i + 1)); + for (unsigned int i = 0; i < in_nelts.coeffs[0]; ++i) + builder.quick_push (build_int_cst (in_inner_type, + i < min_out_nelts ? 100 + i : 77)); + tree arg = builder.build (); + + /* Check integer unpacking with a duplicated scalable high half. */ + tree lo = const_unop (VEC_UNPACK_LO_EXPR, out_type, arg); + ASSERT_TRUE (lo != NULL_TREE); + tree hi = const_unop (VEC_UNPACK_HI_EXPR, out_type, arg); + ASSERT_TRUE (hi != NULL_TREE); + + tree prefix = (!BYTES_BIG_ENDIAN ? lo : hi); + tree dup = (!BYTES_BIG_ENDIAN ? hi : lo); + + ASSERT_EQ (VECTOR_CST, TREE_CODE (prefix)); + ASSERT_EQ (VECTOR_CST, TREE_CODE (dup)); + ASSERT_KNOWN_EQ (TYPE_VECTOR_SUBPARTS (out_type), + VECTOR_CST_NELTS (prefix)); + ASSERT_KNOWN_EQ (TYPE_VECTOR_SUBPARTS (out_type), + VECTOR_CST_NELTS (dup)); + ASSERT_EQ (min_out_nelts, VECTOR_CST_NPATTERNS (prefix)); + ASSERT_EQ (2, VECTOR_CST_NELTS_PER_PATTERN (prefix)); + ASSERT_EQ (1, VECTOR_CST_NPATTERNS (dup)); + ASSERT_EQ (1, VECTOR_CST_NELTS_PER_PATTERN (dup)); + + for (unsigned int i = 0; i < min_out_nelts; ++i) + { + tree elt = build_int_cst (out_inner_type, i + 1); + ASSERT_TRUE (operand_equal_p (VECTOR_CST_ELT (prefix, i), + elt, 0)); + tree fill = build_int_cst (out_inner_type, 77); + ASSERT_TRUE (operand_equal_p (VECTOR_CST_ELT + (prefix, min_out_nelts + i), + fill, 0)); + ASSERT_TRUE (operand_equal_p (VECTOR_CST_ELT (dup, i), + fill, 0)); + } + + /* Check int-to-float unpacking with the same scalable shape. */ + tree float_out_type = build_vector_type (float_type_node, out_nelts); + tree float_lo = const_unop (VEC_UNPACK_FLOAT_LO_EXPR, float_out_type, + arg); + ASSERT_TRUE (float_lo != NULL_TREE); + tree float_hi = const_unop (VEC_UNPACK_FLOAT_HI_EXPR, float_out_type, + arg); + ASSERT_TRUE (float_hi != NULL_TREE); + + tree float_prefix = (!BYTES_BIG_ENDIAN ? float_lo : float_hi); + tree float_dup = (!BYTES_BIG_ENDIAN ? float_hi : float_lo); + ASSERT_EQ (VECTOR_CST, TREE_CODE (float_prefix)); + ASSERT_EQ (VECTOR_CST, TREE_CODE (float_dup)); + ASSERT_EQ (min_out_nelts, VECTOR_CST_NPATTERNS (float_prefix)); + ASSERT_EQ (2, VECTOR_CST_NELTS_PER_PATTERN (float_prefix)); + ASSERT_EQ (1, VECTOR_CST_NPATTERNS (float_dup)); + ASSERT_EQ (1, VECTOR_CST_NELTS_PER_PATTERN (float_dup)); + + for (unsigned int i = 0; i < min_out_nelts; ++i) + { + tree elt = fold_convert_const (FLOAT_EXPR, float_type_node, + build_int_cst (in_inner_type, i + 1)); + ASSERT_TRUE (operand_equal_p (VECTOR_CST_ELT (float_prefix, i), + elt, 0)); + tree fill = fold_convert_const (FLOAT_EXPR, float_type_node, + build_int_cst (in_inner_type, 77)); + ASSERT_TRUE (operand_equal_p (VECTOR_CST_ELT + (float_prefix, min_out_nelts + i), + fill, 0)); + ASSERT_TRUE (operand_equal_p (VECTOR_CST_ELT (float_dup, i), + fill, 0)); + } + + /* Check float-to-int unpacking with the same scalable shape. */ + tree float_in_type = build_vector_type (float_type_node, in_nelts); + tree_vector_builder fix_builder (float_in_type, in_nelts.coeffs[0], 2); + for (unsigned int i = 0; i < in_nelts.coeffs[0]; ++i) + fix_builder.quick_push + (build_real_from_int_cst (float_type_node, + build_int_cst (integer_type_node, i + 1))); + for (unsigned int i = 0; i < in_nelts.coeffs[0]; ++i) + fix_builder.quick_push + (build_real_from_int_cst (float_type_node, + build_int_cst (integer_type_node, + i < min_out_nelts + ? 100 + i : 77))); + tree fix_arg = fix_builder.build (); + tree fix_out_type = build_vector_type (integer_type_node, out_nelts); + tree fix_lo = const_unop (VEC_UNPACK_FIX_TRUNC_LO_EXPR, fix_out_type, + fix_arg); + ASSERT_TRUE (fix_lo != NULL_TREE); + tree fix_hi = const_unop (VEC_UNPACK_FIX_TRUNC_HI_EXPR, fix_out_type, + fix_arg); + ASSERT_TRUE (fix_hi != NULL_TREE); + + tree fix_prefix = (!BYTES_BIG_ENDIAN ? fix_lo : fix_hi); + tree fix_dup = (!BYTES_BIG_ENDIAN ? fix_hi : fix_lo); + ASSERT_EQ (VECTOR_CST, TREE_CODE (fix_prefix)); + ASSERT_EQ (VECTOR_CST, TREE_CODE (fix_dup)); + ASSERT_EQ (min_out_nelts, VECTOR_CST_NPATTERNS (fix_prefix)); + ASSERT_EQ (2, VECTOR_CST_NELTS_PER_PATTERN (fix_prefix)); + ASSERT_EQ (1, VECTOR_CST_NPATTERNS (fix_dup)); + ASSERT_EQ (1, VECTOR_CST_NELTS_PER_PATTERN (fix_dup)); + + for (unsigned int i = 0; i < min_out_nelts; ++i) + { + tree elt = build_int_cst (integer_type_node, i + 1); + ASSERT_TRUE (operand_equal_p (VECTOR_CST_ELT (fix_prefix, i), + elt, 0)); + tree fill = build_int_cst (integer_type_node, 77); + ASSERT_TRUE (operand_equal_p (VECTOR_CST_ELT + (fix_prefix, min_out_nelts + i), + fill, 0)); + ASSERT_TRUE (operand_equal_p (VECTOR_CST_ELT (fix_dup, i), + fill, 0)); + } + + /* Reject scalable constants whose high half is not duplicated. */ + tree_vector_builder varied (in_type, in_nelts.coeffs[0], 2); + for (unsigned int i = 0; i < in_nelts.coeffs[0]; ++i) + varied.quick_push (build_int_cst (in_inner_type, i + 1)); + for (unsigned int i = 0; i < in_nelts.coeffs[0]; ++i) + varied.quick_push (build_int_cst (in_inner_type, 100 + i)); + ASSERT_EQ (NULL_TREE, const_unop (VEC_UNPACK_LO_EXPR, out_type, + varied.build ())); + + /* Reject stepped scalable constants. */ + tree_vector_builder stepped (in_type, 1, 3); + stepped.quick_push (build_int_cst (in_inner_type, 1)); + stepped.quick_push (build_int_cst (in_inner_type, 2)); + stepped.quick_push (build_int_cst (in_inner_type, 3)); + ASSERT_EQ (NULL_TREE, const_unop (VEC_UNPACK_LO_EXPR, out_type, + stepped.build ())); + + /* Reject result types with the wrong number of elements. */ + tree wrong_out_type = build_vector_type (out_inner_type, in_nelts); + ASSERT_EQ (NULL_TREE, const_unop (VEC_UNPACK_LO_EXPR, wrong_out_type, + arg)); + return; + } +} + /* Run all of the selftests within this file. */ void @@ -17760,6 +17953,7 @@ fold_const_cc_tests () test_arithmetic_folding (); test_vector_folding (); test_vec_duplicate_folding (); + test_vec_unpack_folding (); test_fold_vec_perm_cst::test (); test_operand_equality::test (); } From 0ffbcec62de9419812ef0017d74ce20572586c6c Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Wed, 23 Sep 2026 09:22:07 +0200 Subject: [PATCH 361/584] c++: Improve printing of null pointer to data member constants [PR126599] For null pointer to data member we use INTEGER_CST with OFFSET_TYPE and -1 value. When that is printed in diagnostics or in display_string_of, it is printed as -1, which is confusing to users and an implementation detail (well, part of ABI https://itanium-cxx-abi.github.io/cxx-abi/abi.html#data-member-pointers A null data member pointer is represented as an offset of -1. ). Now, as the first testcase shows, if we have a non-null pointer to data member constant, it is actually PTRMEM_CST and is printed in a user-friendly way, the following patch just arranges to print the OFFSET_TYPE -1 INTEGER_CST similarly. 2026-09-23 Jakub Jelinek PR c++/126599 * error.cc (dump_expr): Print OFFSET_TYPE -1 differently. * g++.dg/diagnostic/ptrtomem5.C: New test. * g++.dg/diagnostic/ptrtomem6.C: New test. * g++.dg/reflect/display_string_of1.C: Add 2 new tests. * g++.dg/reflect/u8display_string_of1.C: Likewise. Reviewed-by: Jason Merrill --- gcc/cp/error.cc | 17 ++++++++++++++++- gcc/testsuite/g++.dg/diagnostic/ptrtomem5.C | 15 +++++++++++++++ gcc/testsuite/g++.dg/diagnostic/ptrtomem6.C | 7 +++++++ .../g++.dg/reflect/display_string_of1.C | 2 ++ .../g++.dg/reflect/u8display_string_of1.C | 2 ++ 5 files changed, 42 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/g++.dg/diagnostic/ptrtomem5.C create mode 100644 gcc/testsuite/g++.dg/diagnostic/ptrtomem6.C diff --git a/gcc/cp/error.cc b/gcc/cp/error.cc index 3d5a194b9bc4..47065b11e22a 100644 --- a/gcc/cp/error.cc +++ b/gcc/cp/error.cc @@ -2472,8 +2472,23 @@ dump_expr (cxx_pretty_printer *pp, tree t, int flags) pp_cxx_ws_string (pp, M_("")); break; - case VOID_CST: case INTEGER_CST: + if (TYPE_PTRDATAMEM_P (TREE_TYPE (t)) && integer_all_onesp (t)) + { + /* OFFSET_TYPE -1 is a null pointer to member. */ + if (flags & TFF_EXPR_IN_PARENS) + pp_cxx_left_paren (pp); + pp_cxx_left_paren (pp); + dump_type (pp, TREE_TYPE (t), flags); + pp_cxx_right_paren (pp); + pp->constant (cxx_dialect < cxx11 ? null_pointer_node : nullptr_node); + if (flags & TFF_EXPR_IN_PARENS) + pp_cxx_right_paren (pp); + break; + } + /* FALLTHRU */ + + case VOID_CST: case REAL_CST: case STRING_CST: case COMPLEX_CST: diff --git a/gcc/testsuite/g++.dg/diagnostic/ptrtomem5.C b/gcc/testsuite/g++.dg/diagnostic/ptrtomem5.C new file mode 100644 index 000000000000..e1def87e7825 --- /dev/null +++ b/gcc/testsuite/g++.dg/diagnostic/ptrtomem5.C @@ -0,0 +1,15 @@ +// PR c++/126599 +// { dg-do compile { target c++17 } } + +struct S { int s, t, u[3][3]; }; +using A = int[3][3]; +template +void foo (int); +void +bar () +{ + foo <(int S::*)nullptr> (); // { dg-error "no matching function for call to 'foo<\\\(\\\(int S::\\\*\\\)nullptr\\\)>\\\(\\\)'" } + foo <&S::s> (); // { dg-error "no matching function for call to 'foo<\\\&S::s>\\\(\\\)'" } + foo <&S::t> (); // { dg-error "no matching function for call to 'foo<\\\&S::t>\\\(\\\)'" } + foo <(A S::*)nullptr> (); // { dg-error "no matching function for call to 'foo<\\\(\\\(int \\\(S::\\\*\\\)\\\[3\\\]\\\[3\\\]\\\)nullptr\\\)>\\\(\\\)'" } +} diff --git a/gcc/testsuite/g++.dg/diagnostic/ptrtomem6.C b/gcc/testsuite/g++.dg/diagnostic/ptrtomem6.C new file mode 100644 index 000000000000..e5105ec065c5 --- /dev/null +++ b/gcc/testsuite/g++.dg/diagnostic/ptrtomem6.C @@ -0,0 +1,7 @@ +// PR c++/126599 +// { dg-do compile } + +struct A { int a; }; +__attribute__((assume_aligned ((int A::*) 0))) int *foo (); +// { dg-warning "'assume_aligned' attribute argument \\\(int A::\\\*\\\)0 is not positive" "" { target c++98_only } .-1 } +// { dg-warning "'assume_aligned' attribute argument \\\(int A::\\\*\\\)nullptr is not positive" "" { target c++11 } .-2 } diff --git a/gcc/testsuite/g++.dg/reflect/display_string_of1.C b/gcc/testsuite/g++.dg/reflect/display_string_of1.C index ae24aff1e9d2..1f1df4b978c6 100644 --- a/gcc/testsuite/g++.dg/reflect/display_string_of1.C +++ b/gcc/testsuite/g++.dg/reflect/display_string_of1.C @@ -135,6 +135,8 @@ foo (int a, const long b, T c, int d[4], T &e) static_assert (display_string_of (members_of (^^V4, ctx)[0]) == "V4& V4::operator+=(const V4&)"); static_assert (display_string_of (members_of (^^V5, ctx)[0]) == "V5::operator int()"); static_assert (display_string_of (^^operator""_a) == "int operator\"\"_a(const char*)"); + static_assert (display_string_of (reflect_constant ((int U::*)nullptr)) == "(int U::*)nullptr"); + static_assert (display_string_of (reflect_constant (&U::u)) == "&U::u"); } namespace NS5 { diff --git a/gcc/testsuite/g++.dg/reflect/u8display_string_of1.C b/gcc/testsuite/g++.dg/reflect/u8display_string_of1.C index 0ff9cc7c992d..e0fb2e3b0a4a 100644 --- a/gcc/testsuite/g++.dg/reflect/u8display_string_of1.C +++ b/gcc/testsuite/g++.dg/reflect/u8display_string_of1.C @@ -135,6 +135,8 @@ foo (int a, const long b, T c, int d[4], T &e) static_assert (u8display_string_of (members_of (^^V4, ctx)[0]) == u8"V4& V4::operator+=(const V4&)"); static_assert (u8display_string_of (members_of (^^V5, ctx)[0]) == u8"V5::operator int()"); static_assert (u8display_string_of (^^operator""_a) == u8"int operator\"\"_a(const char*)"); + static_assert (u8display_string_of (reflect_constant ((int U::*)nullptr)) == u8"(int U::*)nullptr"); + static_assert (u8display_string_of (reflect_constant (&U::u)) == u8"&U::u"); } namespace NS5 { From 70f3c5413a3c8d2dd57a8f716dab8e90334b5e96 Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Wed, 23 Sep 2026 09:24:55 +0200 Subject: [PATCH 362/584] c++: Fix up unify_array_domain [PR125536] The following testcase is incorrectly rejected on lp64 targets. The bug is that unify_array_domain uses forcefully integer_type_node/integer_one_node to add 1 to parm_max or arg_max, regardless of the type it has. From playing with testcases, at least arg_max seems to be pretty much always sizetype/size_t. 2026-09-23 Jakub Jelinek PR c++/125536 * pt.cc (unify_array_domain): When adding 1 to parm_max or arg_max, perform the addition in the type of those trees rather than unconditionally in int type. * g++.dg/template/unify14.C: New test. Reviewed-by: Jason Merrill --- gcc/cp/pt.cc | 8 ++++---- gcc/testsuite/g++.dg/template/unify14.C | 15 +++++++++++++++ 2 files changed, 19 insertions(+), 4 deletions(-) create mode 100644 gcc/testsuite/g++.dg/template/unify14.C diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc index 527e2b25b561..5696828673d5 100644 --- a/gcc/cp/pt.cc +++ b/gcc/cp/pt.cc @@ -26293,14 +26293,14 @@ unify_array_domain (tree tparms, tree targs, by adding one to the other bound. */ if (parm_cst && !arg_cst) parm_max = fold_build2_loc (input_location, PLUS_EXPR, - integer_type_node, + TREE_TYPE (parm_max), parm_max, - integer_one_node); + build_int_cst (TREE_TYPE (parm_max), 1)); else if (arg_cst && !parm_cst) arg_max = fold_build2_loc (input_location, PLUS_EXPR, - integer_type_node, + TREE_TYPE (arg_max), arg_max, - integer_one_node); + build_int_cst (TREE_TYPE (arg_max), 1)); return unify (tparms, targs, parm_max, arg_max, UNIFY_ALLOW_INTEGER, explain_p); diff --git a/gcc/testsuite/g++.dg/template/unify14.C b/gcc/testsuite/g++.dg/template/unify14.C new file mode 100644 index 000000000000..8f9ca9e098aa --- /dev/null +++ b/gcc/testsuite/g++.dg/template/unify14.C @@ -0,0 +1,15 @@ +// PR c++/125536 +// { dg-do compile { target c++14 } } + +template +constexpr bool x = false; + +template +constexpr bool x = true; + +#if __PTRDIFF_MAX__ >= 2147483647 +static_assert (x , ""); +#endif +#if __PTRDIFF_MAX__ > 2147483647 +static_assert (x , ""); +#endif From 5b0a952ca720ba661baa20cd72becfeb9532633f Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Wed, 23 Sep 2026 09:31:07 +0200 Subject: [PATCH 363/584] c++: Fix __builtin_is_within_lifetime error recovery [PR127506] As the following testcase shows, error_mark_node can appear anywhere in the ctors, and with the asserts we ICE on those during error recovery. The following patch just returns error_mark_node in those cases. 2026-09-23 Jakub Jelinek PR c++/127506 * constexpr.cc (is_within_lifetime): When val is error_mark_node, return it. * g++.dg/cpp26/within-lifetime13.C: New test. Reviewed-by: Jason Merrill --- gcc/cp/constexpr.cc | 6 ++++++ .../g++.dg/cpp26/within-lifetime13.C | 20 +++++++++++++++++++ 2 files changed, 26 insertions(+) create mode 100644 gcc/testsuite/g++.dg/cpp26/within-lifetime13.C diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc index e285582e4c02..e90ca1018a7d 100644 --- a/gcc/cp/constexpr.cc +++ b/gcc/cp/constexpr.cc @@ -2665,6 +2665,8 @@ is_within_lifetime (location_t loc, const constexpr_ctx *ctx, tree t, tree fun, } else if (val == val_uninit) return boolean_false_node; + else if (val == error_mark_node) + return val; else { gcc_assert (TREE_CODE (val) == CONSTRUCTOR); @@ -2693,6 +2695,8 @@ is_within_lifetime (location_t loc, const constexpr_ctx *ctx, tree t, tree fun, } if (val == val_zero_init || val == val_uninit) continue; + if (val == error_mark_node) + return val; gcc_assert (TREE_CODE (val) == CONSTRUCTOR); unsigned int j; tree field, value; @@ -2726,6 +2730,8 @@ is_within_lifetime (location_t loc, const constexpr_ctx *ctx, tree t, tree fun, return t; if (val == val_zero_init || val == val_uninit) continue; + if (val == error_mark_node) + return val; if (TREE_CODE (val) == STRING_CST) return boolean_true_node; gcc_assert (TREE_CODE (val) == CONSTRUCTOR); diff --git a/gcc/testsuite/g++.dg/cpp26/within-lifetime13.C b/gcc/testsuite/g++.dg/cpp26/within-lifetime13.C new file mode 100644 index 000000000000..9d7f644bdc5d --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp26/within-lifetime13.C @@ -0,0 +1,20 @@ +// PR c++/127506 +// { dg-do compile { target c++20 } } + +namespace std { + template + consteval bool + is_within_lifetime (const T *p) noexcept + { + return __builtin_is_within_lifetime (p); + } +} + +struct S { char a; }; +constexpr S s = { int b; }; // { dg-error "expected" } + +bool +bar () +{ + return (!std::is_within_lifetime (&s.a)); // { dg-error "is not a constant expression" } +} From ee0bf66ed6c2acde588a4275df9c21cc8d67ff8d Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Wed, 23 Sep 2026 11:06:06 +0200 Subject: [PATCH 364/584] Ada: Fix derivation of constrained private type with defaulted discriminants The problem is that the Has_Constrained_Partial_View flag is not inherited by derived types. Since it is set both on the partial and full views, both Build_Derived_Private_Type and Build_Derived_Record_Type need to be fixed. gcc/ada/ * sem_ch3.adb (Build_Derived_Private_Type): In the case where the partial view has none but the full view has discriminants, do not set again the Etype, propagate the Has_Constrained_Partial_View flag from the parent base type and the Is_Constrained flag from the partial view of the parent type. (Build_Derived_Record_Type): Propagate Has_Constrained_Partial_View from the parent base type. --- gcc/ada/sem_ch3.adb | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/gcc/ada/sem_ch3.adb b/gcc/ada/sem_ch3.adb index 9aec12d24a70..504d77ce03b3 100644 --- a/gcc/ada/sem_ch3.adb +++ b/gcc/ada/sem_ch3.adb @@ -8709,8 +8709,6 @@ package body Sem_Ch3 is -- In any case, the primitive operations are inherited from the -- parent type, not from the internal full view. - Set_Etype (Base_Type (Derived_Type), Base_Type (Parent_Type)); - if Derive_Subps then -- Initialize the list of primitive operations to an empty list, -- to cover tagged types as well as untagged types. For untagged @@ -8722,12 +8720,13 @@ package body Sem_Ch3 is Derive_Subprograms (Parent_Type, Derived_Type); end if; + Set_Has_Constrained_Partial_View + (Derived_Type, Has_Constrained_Partial_View (Par_Base)); + Set_Is_Constrained (Derived_Type, Is_Constrained (Parent_Type)); Set_Stored_Constraint (Derived_Type, No_Elist); - Set_Is_Constrained - (Derived_Type, Is_Constrained (Available_Full_View (Parent_Type))); else - -- Untagged type, No discriminants on either view + -- Untagged type, no discriminants on either view if Nkind (Subtype_Indication (Type_Definition (N))) = N_Subtype_Indication @@ -10075,6 +10074,8 @@ package body Sem_Ch3 is Propagate_Concurrent_Flags (Derived_Type, Parent_Base); Propagate_Controlled_Flags (Derived_Type, Parent_Base, Deriv => True); + Set_Has_Constrained_Partial_View + (Derived_Type, Has_Constrained_Partial_View (Parent_Base)); Set_Has_Non_Standard_Rep (Derived_Type, Has_Non_Standard_Rep (Parent_Base)); Set_Has_Primitive_Operations From d470d6b931344eb972cf653932a7c4df3b937421 Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Wed, 23 Sep 2026 11:08:57 +0200 Subject: [PATCH 365/584] Ada: Fix infinite recursion on broken subunit with -gnatc This just adds a cut-off for broken subunits. gcc/ada/ * sem_elab.adb (Invocation_Graph.Process_Package_Declaration): Add cut-off for broken subunits. --- gcc/ada/sem_elab.adb | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/gcc/ada/sem_elab.adb b/gcc/ada/sem_elab.adb index fefb01029d39..06b7be53f057 100644 --- a/gcc/ada/sem_elab.adb +++ b/gcc/ada/sem_elab.adb @@ -12777,9 +12777,24 @@ package body Sem_Elab is if Present (Body_Id) and then Save_Invocation_Graph_Of_Body (Cunit (Main_Unit)) then - Process_Declarations - (Decls => Declarations (Unit_Declaration_Node (Body_Id)), - In_State => In_State); + declare + Decl : constant Node_Id := Declaration_Node (Body_Id); + + begin + -- Prevent infinite recursion for broken subunit + + if Nkind (Decl) = N_Package_Body_Stub + and then No (Stub_Subunit (Decl)) + then + null; + + else + Process_Declarations + (Decls => + Declarations (Unit_Declaration_Node (Body_Id)), + In_State => In_State); + end if; + end; end if; end if; end Process_Package_Declaration; From b947e309e8736933ee4b31700df2d0d7b9d9ea6a Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Wed, 23 Sep 2026 11:10:49 +0200 Subject: [PATCH 366/584] Ada: Fix wrong ALI xref for entry call parameter The wrong name is passed to Generate_Reference from Resolve_Entry. gcc/ada/ * sem_res.adb (Resolve_Entry): Fix thinko. --- gcc/ada/sem_res.adb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/ada/sem_res.adb b/gcc/ada/sem_res.adb index c124b6d0e3d3..cf603b5a21f2 100644 --- a/gcc/ada/sem_res.adb +++ b/gcc/ada/sem_res.adb @@ -8385,7 +8385,7 @@ package body Sem_Res is -- Generate a reference for the index when it denotes an entity if Is_Entity_Name (Index) then - Generate_Reference (Entity (Index), Nam); + Generate_Reference (Entity (Index), Index); end if; -- Up to this point the expression could have been the actual in a From f5c0cda82b6aa48c66b9ca9e997beebc22a7770d Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Wed, 23 Sep 2026 11:12:20 +0200 Subject: [PATCH 367/584] Ada: Fix crash during resolution of membership test in generic unit This just adds a missing guard. gcc/ada/ * sem_res.adb (Resolve_Membership_Op): Add guard for generic type to the test on the RM size. --- gcc/ada/sem_res.adb | 1 + 1 file changed, 1 insertion(+) diff --git a/gcc/ada/sem_res.adb b/gcc/ada/sem_res.adb index cf603b5a21f2..1bea0d6a600b 100644 --- a/gcc/ada/sem_res.adb +++ b/gcc/ada/sem_res.adb @@ -10322,6 +10322,7 @@ package body Sem_Res is and then (Is_Overloaded (R) or else (not Is_Universal_Numeric_Type (Etype (R)) + and then not Is_Generic_Type (Etype (R)) and then (not Is_Integer_Type (Etype (R)) or else From 8fdda43b8f2edd2bf36574ba1f1f9968076047b9 Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Wed, 23 Sep 2026 11:16:17 +0200 Subject: [PATCH 368/584] Ada: Fix Program_Error raised on ill-formed quantified expression This occurs for the argument of pragma Assert, Check, Loop_Invariant, etc. The testcase trips on another issue for the renaming of a reference to the 'Old attribute, which is fixed by removing essentially unused code. gcc/ada/ * sem_ch8.adb (Get_Object_Name): Delete. (Analyze_Object_Renaming): Use Is_Entity_Name to detect names. * sem_prag.adb (Analyze_Pragma) : Detect ill-formed quantified expressions and give an error. : Likewise. * sem_res.ads (Malformed_Quantified_Expression): New procedure. * sem_res.adb (Malformed_Quantified_Expression): Likewise. (Resolve): Call Malformed_Quantified_Expression to give the error about ill-formed quantified expressions. --- gcc/ada/sem_ch8.adb | 40 ++-------------------------------- gcc/ada/sem_prag.adb | 18 ++++++++++++++-- gcc/ada/sem_res.adb | 51 ++++++++++++++++++++++++-------------------- gcc/ada/sem_res.ads | 10 ++++----- 4 files changed, 50 insertions(+), 69 deletions(-) diff --git a/gcc/ada/sem_ch8.adb b/gcc/ada/sem_ch8.adb index e8490bc503e9..661aa6beef3d 100644 --- a/gcc/ada/sem_ch8.adb +++ b/gcc/ada/sem_ch8.adb @@ -776,10 +776,6 @@ package body Sem_Ch8 is -- has already established its actual subtype. This is only relevant -- if the renamed object is an explicit dereference. - function Get_Object_Name (Nod : Node_Id) return Node_Id; - -- Obtain the name of the object from node Nod which is being renamed by - -- the object renaming declaration N. - function Find_Raise_Node (N : Node_Id) return Traverse_Result; -- Process one node in search for N_Raise_xxx_Error nodes. -- Return Abandon if found, OK otherwise. @@ -908,38 +904,6 @@ package body Sem_Ch8 is end if; end Check_Constrained_Object; - --------------------- - -- Get_Object_Name -- - --------------------- - - function Get_Object_Name (Nod : Node_Id) return Node_Id is - Obj_Nam : Node_Id; - - begin - Obj_Nam := Nod; - while Present (Obj_Nam) loop - case Nkind (Obj_Nam) is - when N_Attribute_Reference - | N_Explicit_Dereference - | N_Indexed_Component - | N_Slice - => - Obj_Nam := Prefix (Obj_Nam); - - when N_Selected_Component => - Obj_Nam := Selector_Name (Obj_Nam); - - when N_Qualified_Expression | N_Type_Conversion => - Obj_Nam := Expression (Obj_Nam); - - when others => - exit; - end case; - end loop; - - return Obj_Nam; - end Get_Object_Name; - -- Start of processing for Analyze_Object_Renaming begin @@ -1387,9 +1351,9 @@ package body Sem_Ch8 is return; end if; - if Ada_Version >= Ada_2005 and then Nkind (Nam) in N_Has_Entity then + if Ada_Version >= Ada_2005 and then Is_Entity_Name (Nam) then declare - Nam_Ent : constant Entity_Id := Entity (Get_Object_Name (Nam)); + Nam_Ent : constant Entity_Id := Entity (Nam); Nam_Decl : constant Node_Id := Declaration_Node (Nam_Ent); begin diff --git a/gcc/ada/sem_prag.adb b/gcc/ada/sem_prag.adb index 29ef2a46a44f..827192ace384 100644 --- a/gcc/ada/sem_prag.adb +++ b/gcc/ada/sem_prag.adb @@ -14785,12 +14785,19 @@ package body Sem_Prag is Check_Arg_Order (Names); Mark_Ghost_Pragma (N, Current_Scope); + -- Diagnose the case of a quantified expression being mistaken + -- for an iterated component association, because the user has + -- forgotten the "all" or "some" keyword after "for". + + if Nkind (Arg_Check) = N_Iterated_Component_Association then + Malformed_Quantified_Expression (Arg_Check); + -- Special processing for Loop_Invariant, Loop_Variant or for -- other cases where a Loop_Entry attribute is present. If the -- assertion pragma contains attribute Loop_Entry, ensure that -- the related pragma is within a loop. - if Prag_Id = Pragma_Loop_Invariant + elsif Prag_Id = Pragma_Loop_Invariant or else Prag_Id = Pragma_Loop_Variant or else Contains_Loop_Entry (Arg_Check) then @@ -15982,10 +15989,17 @@ package body Sem_Prag is Preanalyze_And_Resolve (Arg_Message, Standard_String); end if; + -- Diagnose the case of a quantified expression being mistaken + -- for an iterated component association, because the user has + -- forgotten the "all" or "some" keyword after "for". + + if Nkind (Arg_Check) = N_Iterated_Component_Association then + Malformed_Quantified_Expression (Arg_Check); + -- When expansion is active but check is not, only preanalyze the -- boolean to avoid pulling useless dependencies. - if Expander_Active and Is_Ignored_In_Codegen (N) then + elsif Expander_Active and Is_Ignored_In_Codegen (N) then In_Assertion_Expr := In_Assertion_Expr + 1; Preanalyze_And_Resolve (Arg_Check, Any_Boolean); In_Assertion_Expr := In_Assertion_Expr - 1; diff --git a/gcc/ada/sem_res.adb b/gcc/ada/sem_res.adb index 1bea0d6a600b..078e32c42a14 100644 --- a/gcc/ada/sem_res.adb +++ b/gcc/ada/sem_res.adb @@ -1976,6 +1976,28 @@ package body Sem_Res is end if; end Make_Call_Into_Operator; + ------------------------------------- + -- Malformed_Quantified_Expression -- + ------------------------------------- + + procedure Malformed_Quantified_Expression (N : Node_Id) is + begin + -- Because the error message starts with "missing ALL", we automatically + -- benefit from the associated CODEFIX, which requires that the message + -- is located on the identifier following "for" in order for the CODEFIX + -- to insert "all" in the right place. + + if Present (Iterator_Specification (N)) then + Error_Msg_N -- CODEFIX + ("missing ALL or SOME in quantified expression", + Defining_Identifier (Iterator_Specification (N))); + else + Error_Msg_N -- CODEFIX + ("missing ALL or SOME in quantified expression", + Defining_Identifier (N)); + end if; + end Malformed_Quantified_Expression; + ------------------- -- Operator_Kind -- ------------------- @@ -3221,35 +3243,18 @@ package body Sem_Res is Error_Msg_N ("\use -gnatf for details", N); end if; - -- Recognize the case of a quantified expression being mistaken - -- for an iterated component association because the user - -- forgot the "all" or "some" keyword after "for". Because the - -- error message starts with "missing ALL", we automatically - -- benefit from the associated CODEFIX, which requires that - -- the message is located on the identifier following "for" - -- in order for the CODEFIX to insert "all" in the right place. + -- Diagnose the case of a quantified expression being mistaken + -- for an iterated component association, because the user has + -- forgotten the "all" or "some" keyword after "for". elsif Nkind (N) = N_Aggregate + and then Is_Boolean_Type (Typ) and then List_Length (Component_Associations (N)) = 1 and then Nkind (First (Component_Associations (N))) = N_Iterated_Component_Association - and then Is_Boolean_Type (Typ) then - if Present - (Iterator_Specification - (First (Component_Associations (N)))) - then - Error_Msg_N -- CODEFIX - ("missing ALL or SOME in quantified expression", - Defining_Identifier - (Iterator_Specification - (First (Component_Associations (N))))); - else - Error_Msg_N -- CODEFIX - ("missing ALL or SOME in quantified expression", - Defining_Identifier - (First (Component_Associations (N)))); - end if; + Malformed_Quantified_Expression + (First (Component_Associations (N))); -- For an operator with no interpretation, check whether one of -- its operands may be a user-defined literal. diff --git a/gcc/ada/sem_res.ads b/gcc/ada/sem_res.ads index 54902ac9fce0..b2b84239e36c 100644 --- a/gcc/ada/sem_res.ads +++ b/gcc/ada/sem_res.ads @@ -95,6 +95,10 @@ package Sem_Res is -- interpolated expression; used to improve the clarity of reported -- error messages. + procedure Malformed_Quantified_Expression (N : Node_Id); + -- N is an N_Iterated_Component_Association in a boolean context. Give an + -- error about a malformed quantified expression. + procedure Preanalyze_And_Resolve (N : Node_Id; T : Entity_Id); -- Performs a preanalysis of expression node N. During preanalysis, N is -- analyzed and then resolved against type T, but no expansion is carried @@ -160,10 +164,4 @@ package Sem_Res is Report_Errs : Boolean := True) return Boolean; -- Specific version of Valid_Conversion for when Target_Type is tagged -private - procedure Resolve_Implicit_Type (N : Node_Id) renames Resolve; - pragma Inline (Resolve_Implicit_Type); - -- We use this renaming to make the application of Inline very explicit to - -- this version, since other versions of Resolve are not inlined. - end Sem_Res; From 1f31aff222994ac92b485850792a9ee6d1dd606c Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Wed, 23 Sep 2026 11:17:53 +0200 Subject: [PATCH 369/584] Ada: Fix missing discriminant check for view conversion in assignment The view conversion is constrained when its operand object is constrained. gcc/ada/ * checks.adb (Apply_Discriminant_Check): Build the actual subtype of the LHS for a view conversion of a constrained object. --- gcc/ada/checks.adb | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/gcc/ada/checks.adb b/gcc/ada/checks.adb index 8e6fba46b82e..6f25f23f99a3 100644 --- a/gcc/ada/checks.adb +++ b/gcc/ada/checks.adb @@ -1551,8 +1551,9 @@ package body Checks is end if; -- If an assignment target is present, then we need to generate the - -- actual subtype if the target is a parameter or aliased object with - -- an unconstrained nominal subtype. + -- actual subtype if the target is a parameter, or a view conversion + -- of a constrained object, or an aliased object with unconstrained + -- nominal subtype. -- Ada 2005 (AI-363): For Ada 2005, we limit the building of the actual -- subtype to the parameter and dereference cases, since other aliased @@ -1561,6 +1562,10 @@ package body Checks is if Present (Lhs) and then (Present (Param_Entity (Lhs)) + or else (not Is_Constrained (T_Typ) + and then Is_View_Conversion (Lhs) + and then + Is_Constrained (Etype (Expression (Lhs)))) or else (Ada_Version < Ada_2005 and then not Is_Constrained (T_Typ) and then Is_Aliased_View (Lhs) From 6fa43cc033cb68684b49f70fca3723a4cf5d1f28 Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Wed, 23 Sep 2026 11:21:57 +0200 Subject: [PATCH 370/584] Ada: Fix extension aggregate with inherited discriminant wrongly rejected This happens when it is present in an expression function, because it is effectively analyzed twice and the analysis is not idempotent. gcc/ada/ * sem_aggr.adb (Discriminant_Present): Do not return early if the component list already contains an inherited discriminant. (Resolve_Record_Aggregate): For an extension, remove the inherited discriminants from the component list of the rewritten aggregate. --- gcc/ada/sem_aggr.adb | 61 +++++++++++++++++++++----------------------- 1 file changed, 29 insertions(+), 32 deletions(-) diff --git a/gcc/ada/sem_aggr.adb b/gcc/ada/sem_aggr.adb index 1d39bd7d8456..ba65c193845f 100644 --- a/gcc/ada/sem_aggr.adb +++ b/gcc/ada/sem_aggr.adb @@ -5507,10 +5507,10 @@ package body Sem_Aggr is -- ancestor part. -- -- If the aggregate is in a context with expansion delayed, it will be - -- reanalyzed. The inherited discriminant values must not be reinserted - -- in the component list to prevent spurious errors, but they must be - -- present on first analysis to build the proper subtype indications. - -- The flag Inherited_Discriminant is used to prevent the re-insertion. + -- reanalyzed. The inherited discriminant values must not be present in + -- the component list the second time to prevent spurious errors and, + -- therefore, need to be removed at the end of the first processing. + -- The flag Inherited_Discriminant is used to implement this scheme. function Find_Private_Ancestor (Typ : Entity_Id) return Entity_Id; -- AI05-0115: Find earlier ancestor in the derivation chain that is @@ -5599,40 +5599,20 @@ package body Sem_Aggr is -------------------------- function Discriminant_Present (Input_Discr : Entity_Id) return Boolean is - Regular_Aggr : constant Boolean := Nkind (N) /= N_Extension_Aggregate; - + Ancestor : Node_Id; Ancestor_Is_Subtyp : Boolean; - - Loc : Source_Ptr; - - Ancestor : Node_Id; - Ancestor_Typ : Entity_Id; - Comp_Assoc : Node_Id; - Discr : Entity_Id; - Discr_Expr : Node_Id; - Discr_Val : Elmt_Id := No_Elmt; - Orig_Discr : Entity_Id; + Ancestor_Typ : Entity_Id; + Discr : Entity_Id; + Discr_Expr : Node_Id; + Discr_Val : Elmt_Id; + Loc : Source_Ptr; + Orig_Discr : Entity_Id; begin - if Regular_Aggr then + if Nkind (N) /= N_Extension_Aggregate then return True; end if; - -- Check whether inherited discriminant values have already been - -- inserted in the aggregate. This will be the case if we are - -- re-analyzing an aggregate whose expansion was delayed. - - if Present (Component_Associations (N)) then - Comp_Assoc := First (Component_Associations (N)); - while Present (Comp_Assoc) loop - if Inherited_Discriminant (Comp_Assoc) then - return True; - end if; - - Next (Comp_Assoc); - end loop; - end if; - Ancestor := Ancestor_Part (N); Ancestor_Typ := Etype (Ancestor); Loc := Sloc (Ancestor); @@ -6982,7 +6962,24 @@ package body Sem_Aggr is Step_8 : declare New_Aggregate : constant Node_Id := New_Copy (N); + Assoc : Node_Id; + Next_Assoc : Node_Id; + begin + -- If this is an extension aggregate, remove the inherited + -- discriminants from the list in case it is reanalyzed. + + if Nkind (N) = N_Extension_Aggregate then + Assoc := First (New_Assoc_List); + while Present (Assoc) loop + Next_Assoc := Next (Assoc); + if Inherited_Discriminant (Assoc) then + Remove (Assoc); + end if; + Assoc := Next_Assoc; + end loop; + end if; + Set_Expressions (New_Aggregate, No_List); Set_Etype (New_Aggregate, Etype (N)); Set_Component_Associations (New_Aggregate, New_Assoc_List); From 34120f3a3145df1553cee33ac53d2446070162dd Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Wed, 23 Sep 2026 11:25:15 +0200 Subject: [PATCH 371/584] Ada: Fix subtype constraint not applied to a view conversion The view conversion is constrained when its operand object is constrained. gcc/ada/ * exp_ch6.adb (Create_Extra_Actuals): Pass True for the extra actual of the Constrained attribute when the actual contains a conversion to a constrained subtype. * sem_res.adb (Resolve_Actuals): Skip the resolution of an actual that is a view conversion in fewer cases. Remove redundant test. --- gcc/ada/exp_ch6.adb | 14 ++++++++++++-- gcc/ada/sem_res.adb | 33 ++++++++++++++++----------------- 2 files changed, 28 insertions(+), 19 deletions(-) diff --git a/gcc/ada/exp_ch6.adb b/gcc/ada/exp_ch6.adb index caa2e1e7d3c3..d7749ae08cef 100644 --- a/gcc/ada/exp_ch6.adb +++ b/gcc/ada/exp_ch6.adb @@ -3156,8 +3156,10 @@ package body Exp_Ch6 is goto Skip_Extra_Actual_Generation; else - -- If the actual is a type conversion, then the constrained - -- test applies to the actual, not the target type. + -- If the actual is a type conversion and the target type is + -- constrained, then the view is constrained (RM 4.6(54)). + -- Otherwise, the test needs to be applied to the operand of + -- the conversion. declare Act_Prev : Node_Id; @@ -3170,6 +3172,9 @@ package body Exp_Ch6 is while Nkind (Act_Prev) in N_Type_Conversion | N_Unchecked_Type_Conversion loop + exit when Nkind (Act_Prev) = N_Type_Conversion + and then Is_Constrained (Etype (Act_Prev)); + Act_Prev := Expression (Act_Prev); end loop; @@ -3187,6 +3192,11 @@ package body Exp_Ch6 is (Expr => New_Occurrence_Of (Standard_False, Loc), EF => Extra_Constrained (Formal)); + elsif Nkind (Act_Prev) = N_Type_Conversion then + Add_Extra_Actual + (Expr => New_Occurrence_Of (Standard_True, Loc), + EF => Extra_Constrained (Formal)); + else Add_Extra_Actual (Expr => diff --git a/gcc/ada/sem_res.adb b/gcc/ada/sem_res.adb index 078e32c42a14..fe39ba3f9c6d 100644 --- a/gcc/ada/sem_res.adb +++ b/gcc/ada/sem_res.adb @@ -4350,23 +4350,24 @@ package body Sem_Res is end if; end if; - -- If the formal is Out or In_Out, do not resolve and expand the - -- conversion, because it is subsequently expanded into explicit - -- temporaries and assignments. However, the object of the - -- conversion can be resolved. An exception is the case of tagged - -- type conversion with a class-wide actual. In that case we want - -- the tag check to occur and no temporary will be needed (no - -- representation change can occur) and the parameter is passed by - -- reference, so we go ahead and resolve the type conversion. - -- Another exception is the case of reference to component or - -- subcomponent of a bit-packed array, in which case we want to - -- defer expansion to the point the in and out assignments are - -- performed. + -- If the formal is Out or In Out, do not resolve and expand a + -- type conversion if it is to an elementary type, or an array + -- type, or if it involves a change of representation, because + -- it will be subsequently expanded into explicit temporaries + -- and assignments (see Exp_Ch6.Expand_Actuals). However, the + -- expression of the conversion needs to be resolved, except + -- in the case of a reference to a component or subcomponent + -- of a bit-packed array, in which case we want to defer the + -- expansion to the point the assignments are performed. if Ekind (F) /= E_In_Parameter and then Nkind (A) = N_Type_Conversion - and then not Is_Class_Wide_Type (Etype (Expression (A))) - and then not Is_Interface (Etype (A)) + and then (Is_Elementary_Type (Etype (A)) + or else Is_Array_Type (Etype (A)) + or else not + Has_Compatible_Representation + (Target_Typ => Etype (A), + Operand_Typ => Etype (Expression (A)))) then declare Expr_Typ : constant Entity_Id := Etype (Expression (A)); @@ -4374,9 +4375,7 @@ package body Sem_Res is begin -- Check RM 4.6 (24.2/2) - if Is_Array_Type (Etype (F)) - and then Is_View_Conversion (A) - then + if Is_Array_Type (Etype (F)) then -- In a view conversion, the conversion must be legal in -- both directions, and thus both component types must be -- aliased, or neither (4.6 (8)). From 38370907dce41bd170cf37d864d6ddc9ca3a9652 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Wed, 23 Sep 2026 09:53:06 +0200 Subject: [PATCH 372/584] Adjust scalar_to_vec use for invariant loads When the invariant load is not uniform we cost it wrongly, fix that and avoid using scalar_to_vec for non-splats. We have vec_construct for that now. * tree-vect-stmts.cc (vectorizable_load): Cost non-uniform invariant loads more appropriately. --- gcc/tree-vect-stmts.cc | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc index eb78fd2eba39..9cfec1bb4ac5 100644 --- a/gcc/tree-vect-stmts.cc +++ b/gcc/tree-vect-stmts.cc @@ -10080,9 +10080,13 @@ vectorizable_load (vec_info *vinfo, } enum vect_cost_model_location cost_loc = hoist_p ? vect_prologue : vect_body; - unsigned int cost = record_stmt_cost (cost_vec, 1, scalar_load, + unsigned int cost = record_stmt_cost (cost_vec, + uniform_p + ? 1 : SLP_TREE_LANES (slp_node), + scalar_load, slp_node, 0, cost_loc); - cost += record_stmt_cost (cost_vec, 1, scalar_to_vec, + cost += record_stmt_cost (cost_vec, 1, + uniform_p ? scalar_to_vec : vec_construct, slp_node, 0, cost_loc); unsigned int prologue_cost = hoist_p ? cost : 0; unsigned int inside_cost = hoist_p ? 0 : cost; From f9a4b558c24290665ebaf0d0c11246187c87a367 Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Wed, 23 Sep 2026 11:32:21 +0200 Subject: [PATCH 373/584] Ada: Fix missing check with nonstatic array and string literal This makes sure that the high bound computed from the low bound and the length of the literal is within the range of the index type. gcc/ada/ * sem_res.adb (Set_String_Literal_Subtype): In the nonstatic case, set String_Literal_Low_Bound first, and check that the actual high bound is not larger than the high bound of the index type. --- gcc/ada/sem_res.adb | 52 +++++++++++++++++++++++++-------------------- 1 file changed, 29 insertions(+), 23 deletions(-) diff --git a/gcc/ada/sem_res.adb b/gcc/ada/sem_res.adb index fe39ba3f9c6d..758d90cbfa5d 100644 --- a/gcc/ada/sem_res.adb +++ b/gcc/ada/sem_res.adb @@ -13088,6 +13088,32 @@ package body Sem_Res is Index_Subtype : Entity_Id; begin + -- The back end expects the String_Literal_Subtype to have a + -- static lower bound. + + if Is_Integer_Type (Index_Type) then + Set_String_Literal_Low_Bound + (Subtype_Id, Make_Integer_Literal (Loc, 1)); + + -- If the index type is an enumeration type, build the bound + -- expression by means of an attribute. + + else + Set_String_Literal_Low_Bound + (Subtype_Id, + Make_Attribute_Reference (Loc, + Attribute_Name => Name_First, + Prefix => + New_Occurrence_Of (Base_Type (Index_Type), Loc))); + end if; + + Analyze_And_Resolve + (String_Literal_Low_Bound (Subtype_Id), Base_Type (Index_Type)); + + -- Now build a subtype with the actual bounds and wrap the literal + -- in an unchecked conversion to it, after checking that the high + -- bound is within the range of the index type if need be. + if Length = 1 then High_Bound := New_Copy_Tree (Low_Bound); @@ -13096,6 +13122,9 @@ package body Sem_Res is Make_Op_Add (Loc, Left_Opnd => New_Copy_Tree (Low_Bound), Right_Opnd => Make_Integer_Literal (Loc, Length - 1)); + if Length > 0 then + High_Bound := Convert_To (Index_Type, High_Bound); + end if; else High_Bound := @@ -13116,29 +13145,6 @@ package body Sem_Res is Make_Integer_Literal (Loc, Length - 1)))); end if; - if Is_Integer_Type (Index_Type) then - Set_String_Literal_Low_Bound - (Subtype_Id, Make_Integer_Literal (Loc, 1)); - - else - -- If the index type is an enumeration type, build bounds - -- expression with attributes. - - Set_String_Literal_Low_Bound - (Subtype_Id, - Make_Attribute_Reference (Loc, - Attribute_Name => Name_First, - Prefix => - New_Occurrence_Of (Base_Type (Index_Type), Loc))); - end if; - - Analyze_And_Resolve - (String_Literal_Low_Bound (Subtype_Id), Base_Type (Index_Type)); - - -- Build bona fide subtype for the string, and wrap it in an - -- unchecked conversion, because the back end expects the - -- String_Literal_Subtype to have a static lower bound. - Index_Subtype := Create_Itype (Subtype_Kind (Ekind (Index_Type)), N); Drange := Make_Range (Loc, New_Copy_Tree (Low_Bound), High_Bound); From 5ca0dd127ca52166320059dd308b5ceecac9ec97 Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Wed, 23 Sep 2026 11:34:55 +0200 Subject: [PATCH 374/584] Ada: Minor tweaks to description of function return mechanisms It does not really make sense to mention function calls here. gcc/ada/ * exp_ch6.adb (Function return mechanisms): Minor tweaks. --- gcc/ada/exp_ch6.adb | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/gcc/ada/exp_ch6.adb b/gcc/ada/exp_ch6.adb index d7749ae08cef..ea6e239f2435 100644 --- a/gcc/ada/exp_ch6.adb +++ b/gcc/ada/exp_ch6.adb @@ -95,7 +95,7 @@ package body Exp_Ch6 is -- front end, or in the back end, or partly in both ends, depending on the -- result type. - -- Result type | Return mechanism | Front end | Back end + -- Result type | Return mechanism | Front end | Back end -- -------------------------------------------------------------------- -- Limited Build In Place All @@ -106,13 +106,12 @@ package body Exp_Ch6 is -- Needs Fin. Secondary Stack All -- (BERS False) - -- Needs Fin. Invisible Parameter All All - -- (BERS True) (return) (call) + -- Needs Fin. Invisible Parameter All + -- (BERS True) -- By Reference Invisible Parameter All - -- Others Primary stack/ All - -- Registers + -- Others Primary stack/Registers All -- Needs Fin.: type needs finalization [RM 7.6(9.1/2-9.6/2)] -- BERS: Opt.Back_End_Return_Slot setting From fa37f57173e247d274139a69a2ceb37a26041f9c Mon Sep 17 00:00:00 2001 From: Vijay Shankar Date: Wed, 26 Aug 2026 15:49:01 -0500 Subject: [PATCH 375/584] rs6000: Optimize TLS access with combine patterns [PR27479] Reduce TLS variable access from 3 to 2 instructions by adding combine patterns that merge address calculation with load. Before addis 9,13,x@tprel@ha addi 9,9,x@tprel@l lwz 3,0(9) After addis 9,13,x@tprel@ha lwz 3,x@tprel@l(9) Bootstrapped and tested on powerpc64le-linux-gnu with no regressions. Bootstrapped and tested on powerpc64-linux-gnu with no regressions. 2026-04-15 Vijay Shankar gcc/ChangeLog: PR target/27479 * config/rs6000/rs6000.md (tprel_ld__): New pattern. (tprel_ld_QI_signed): likewise. (tprel_ld_QI): likewise. (tprel_ld_DI): likewise. (tprel_ld_): likewise. gcc/testsuite/ChangeLog: PR target/27479 * gcc.target/powerpc/pr27479.c: New Test. --- gcc/config/rs6000/rs6000.md | 73 +++++++++++++++++ gcc/testsuite/gcc.target/powerpc/pr27479.c | 95 ++++++++++++++++++++++ 2 files changed, 168 insertions(+) create mode 100644 gcc/testsuite/gcc.target/powerpc/pr27479.c diff --git a/gcc/config/rs6000/rs6000.md b/gcc/config/rs6000/rs6000.md index ddfed3b63bc0..8f694ac4d1c6 100644 --- a/gcc/config/rs6000/rs6000.md +++ b/gcc/config/rs6000/rs6000.md @@ -10650,6 +10650,79 @@ "la %0,%1@got@tlsgd@pcrel" [(set_attr "prefixed" "yes")]) +;;combine patterns for tls access +(define_insn "*tprel_ld__" + [(set (match_operand:DI 0 "gpc_reg_operand" "=r") + (any_extend:DI + (mem:HSI + (unspec:P + [(match_operand:P 1 "gpc_reg_operand" "b") + (match_operand:P 2 "rs6000_tls_symbol_ref" "")] + UNSPEC_TLSTPRELLO))))] + "HAVE_AS_TLS" + "l %0,%2@tprel@l(%1)" + [(set_attr "type" "load")]) + +;; Two instructions needed: lbz (zero-extend load byte) + extsb (sign-extend) +;; because there is no sign-extended load byte instruction, only zero-extended. +(define_insn_and_split "*tprel_ld_QI_signed" + [(set (match_operand:DI 0 "gpc_reg_operand" "=r") + (sign_extend:DI + (mem:QI + (unspec:P + [(match_operand:P 1 "gpc_reg_operand" "b") + (match_operand:P 2 "rs6000_tls_symbol_ref" "")] + UNSPEC_TLSTPRELLO))))] + "HAVE_AS_TLS" + "#" + "&& reload_completed" + [(set (match_dup 0) + (zero_extend:DI + (mem:QI + (unspec:P + [(match_dup 1) + (match_dup 2)] + UNSPEC_TLSTPRELLO)))) + (set (match_dup 0) + (sign_extend:DI (match_dup 3)))] + { + operands[3] = gen_lowpart (QImode, operands[0]); + }) + +(define_insn "*tprel_ld_QI" + [(set (match_operand:DI 0 "gpc_reg_operand" "=r") + (zero_extend:DI + (mem:QI + (unspec:P + [(match_operand:P 1 "gpc_reg_operand" "b") + (match_operand:P 2 "rs6000_tls_symbol_ref" "")] + UNSPEC_TLSTPRELLO))))] + "HAVE_AS_TLS" + "lbz %0,%2@tprel@l(%1)" + [(set_attr "type" "load")]) + +(define_insn "*tprel_ld_DI" + [(set (match_operand:DI 0 "gpc_reg_operand" "=r") + (mem:DI + (unspec:P + [(match_operand:P 1 "gpc_reg_operand" "b") + (match_operand:P 2 "rs6000_tls_symbol_ref" "")] + UNSPEC_TLSTPRELLO)))] + "HAVE_AS_TLS" + "ld %0,%2@tprel@l(%1)" + [(set_attr "type" "load")]) + +(define_insn "*tprel_ld_" + [(set (match_operand:SFDF 0 "gpc_reg_operand" "=f") + (mem:SFDF + (unspec:P + [(match_operand:P 1 "gpc_reg_operand" "b") + (match_operand:P 2 "rs6000_tls_symbol_ref" "")] + UNSPEC_TLSTPRELLO)))] + "HAVE_AS_TLS" + "lf %0,%2@tprel@l(%1)" + [(set_attr "type" "fpload")]) + (define_insn_and_split "*tls_gd" [(set (match_operand:P 0 "gpc_reg_operand" "=b") (unspec:P [(match_operand:P 1 "rs6000_tls_symbol_ref" "") diff --git a/gcc/testsuite/gcc.target/powerpc/pr27479.c b/gcc/testsuite/gcc.target/powerpc/pr27479.c new file mode 100644 index 000000000000..de05237ba5a3 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/pr27479.c @@ -0,0 +1,95 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -mdejagnu-cpu=power9" } */ + +/* verify TLS access for PR27479 */ + +/* TLS variables of many types. */ +__thread unsigned char t_uc; +__thread signed char t_sc; +__thread unsigned short t_us; +__thread short t_ss; +__thread unsigned int t_ui; +__thread int t_si; +__thread unsigned long t_ul; +__thread long t_sl; +__thread _Bool t_bool; +__thread int *t_ptr; + +/* Floating-point. */ +__thread float t_f; +__thread double t_d; + +unsigned long +foo_uc (void) +{ + return t_uc; +} + +long +foo_sc (void) +{ + return t_sc; +} + +unsigned long +foo_us (void) +{ + return t_us; +} + +long +foo_ss (void) +{ + return t_ss; +} + +unsigned long +foo_ui (void) +{ + return t_ui; +} + +long +foo_si (void) +{ + return t_si; +} + +unsigned long +foo_ul (void) +{ + return t_ul; +} + +long +foo_sl (void) +{ + return t_sl; +} + +unsigned long +foo_bool (void) +{ + return t_bool; +} + +int * +foo_ptr (void) +{ + return t_ptr; +} + +/* Floating-point accessors. */ +float +foo_f (void) +{ + return t_f; +} + +double +foo_d (void) +{ + return t_d; +} + +/* { dg-final { scan-assembler-not {\maddi\M} } } */ From 37c33c6a1c86ba88db8f0cf2e398374f0e501038 Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Wed, 23 Sep 2026 11:39:49 +0200 Subject: [PATCH 376/584] Ada: Small tweak to Establish_Transient_Scope.Find_Transient_Context It pertains to the distinction between simple and compound statements for the determination of master constructs, which then act as a boundary for a transient scope. gcc/ada/ * exp_ch7.adb (Establish_Transient_Scope.Find_Transient_Context): Add commentary about the distinction between compound and simple statements, and adjust handling for code and delay statements. --- gcc/ada/exp_ch7.adb | 28 ++++++++++++++++++++-------- 1 file changed, 20 insertions(+), 8 deletions(-) diff --git a/gcc/ada/exp_ch7.adb b/gcc/ada/exp_ch7.adb index 338a5de8057c..c46cd8cd2ef1 100644 --- a/gcc/ada/exp_ch7.adb +++ b/gcc/ada/exp_ch7.adb @@ -4385,23 +4385,19 @@ package body Exp_Ch7 is => return Curr; - -- Statements + -- Statements and statement-like constructs - -- Statements and statement-like constructs act as a boundary - -- for a transient scope. + -- Expressions of compound statements are master constructs so + -- they act as a boundary for a transient scope. when N_Accept_Alternative | N_Attribute_Definition_Clause | N_Case_Statement | N_Case_Statement_Alternative - | N_Code_Statement | N_Delay_Alternative - | N_Delay_Until_Statement - | N_Delay_Relative_Statement | N_Discriminant_Association | N_Elsif_Part | N_Entry_Body_Formal_Part - | N_Exit_Statement | N_If_Statement | N_Iteration_Scheme | N_Terminate_Alternative @@ -4409,7 +4405,23 @@ package body Exp_Ch7 is pragma Assert (Present (Prev)); return Prev; - when N_Assignment_Statement => + -- An exit statement only alters the control flow, so there + -- is no need to wait until after its completion to finalize + -- its expression (which is however not a master construct). + + when N_Exit_Statement => + pragma Assert (Present (Prev)); + return Prev; + + -- Expressions of simple statements are not master constructs + -- (except for a simple return), so only the statements act as + -- a boundary for a transient scope. + + when N_Assignment_Statement + | N_Code_Statement + | N_Delay_Relative_Statement + | N_Delay_Until_Statement + => return Curr; when N_Entry_Call_Statement From d5f892fb06695ad740c6bdeef14e9b5ae6dc74bc Mon Sep 17 00:00:00 2001 From: Tobias Burnus Date: Wed, 23 Sep 2026 14:02:22 +0200 Subject: [PATCH 377/584] OpenMP/Fortran: Add gfortran.dg/gomp/directive-comma-clause.f90 Add missing testcase for commit r17-4506-gb28a16af7fa7fe OpenMP/Fortran: Permit comma between directive and clause gcc/testsuite/ChangeLog: * gfortran.dg/gomp/directive-comma-clause.f90: New test. --- .../gomp/directive-comma-clause.f90 | 201 ++++++++++++++++++ 1 file changed, 201 insertions(+) create mode 100644 gcc/testsuite/gfortran.dg/gomp/directive-comma-clause.f90 diff --git a/gcc/testsuite/gfortran.dg/gomp/directive-comma-clause.f90 b/gcc/testsuite/gfortran.dg/gomp/directive-comma-clause.f90 new file mode 100644 index 000000000000..bd25362ce8db --- /dev/null +++ b/gcc/testsuite/gfortran.dg/gomp/directive-comma-clause.f90 @@ -0,0 +1,201 @@ +! Check for comma between directive and first clause +! Additionally, check that no space is requires between directive(...) +! and the first clause + +module my_omp_lib_kinds + integer, parameter :: omp_lock_hint_kind = 4 + integer (omp_lock_hint_kind), & + parameter :: omp_sync_hint_none = 0 + integer (omp_lock_hint_kind), & + parameter :: omp_sync_hint_uncontended = 1 + integer (omp_lock_hint_kind), & + parameter :: omp_sync_hint_contended = 2 + integer (omp_lock_hint_kind), & + parameter :: omp_sync_hint_nonspeculative = 4 + integer (omp_lock_hint_kind), & + parameter :: omp_sync_hint_speculative = 8 +end module + +module m + use iso_c_binding, only: c_size_t + use my_omp_lib_kinds + implicit none + + ! from omp_lib: + integer, parameter :: omp_depend_kind = 2*c_size_t + + !$omp requires,dynamic_allocators + !$omp requires , reverse_offload + + !$omp assumes,contains(parallel) + !$omp assumes , holds(1 > 0) + type t + integer :: x + end type + !$omp declare mapper(t :: v)map(v%x) + !$omp declare mapper(other : t :: v),map(v%x) + !$omp declare mapper(other2 : t :: v) , map(v%x) + !$omp declare_mapper(other3 : t :: v)map(v%x) + !$omp declare_mapper(other4 : t :: v),map(v%x) + !$omp declare_mapper(other5 : t :: v) , map(v%x) + + !$omp declare reduction(one1 : t : omp_out%x = omp_out%x + omp_in%x)initializer(omp_priv%x = 0) + !$omp declare reduction(one2 : t : omp_out%x = omp_out%x + omp_in%x),initializer(omp_priv%x = 0) + !$omp declare reduction(one3 : t : omp_out%x = omp_out%x + omp_in%x) , initializer(omp_priv%x = 0) + !$omp declare_reduction(one4 : t : omp_out%x = omp_out%x + omp_in%x)initializer(omp_priv%x = 0) + !$omp declare_reduction(one5 : t : omp_out%x = omp_out%x + omp_in%x),initializer(omp_priv%x = 0) + !$omp declare_reduction(one6 : t : omp_out%x = omp_out%x + omp_in%x) , initializer(omp_priv%x = 0) + +interface + integer function bar1 (x, y, z) + integer, value :: x, y, z + !$omp declare simd linear (x : val, step (1))linear (y : step (2)) + end + integer function bar2 (x, y, z) + integer, value :: x, y, z + !$omp declare simd linear (x : val, step (1)),linear (y : step (2)) + end + integer function bar3 (x, y, z) + integer, value :: x, y, z + !$omp declare simd linear (x : val, step (1)) , linear (y : step (2)) + end + integer function bar4 (x, y, z) + integer, value :: x, y, z + !$omp declare_simd linear (x : val, step (1))linear (y : step (2)) + end + integer function bar5 (x, y, z) + integer, value :: x, y, z + !$omp declare_simd linear (x : val, step (1)),linear (y : step (2)) + end + integer function bar6 (x, y, z) + integer, value :: x, y, z + !$omp declare_simd linear (x : val, step (1)) , linear (y : step (2)) + end +end interface + + integer :: a1,a2,a3,a4 + !$omp declare target,enter(a1) + !$omp declare target , enter (a2) + !$omp declare_target,enter(a3) + !$omp declare_target , enter( a4 ) + +contains + subroutine sub1; end subroutine + subroutine sub2; end subroutine + subroutine sub3; end subroutine + subroutine sub4; end subroutine + subroutine sub5; end subroutine + subroutine sub6; end subroutine + subroutine sub + !$omp declare variant(sub1)match(construct={parallel}) + !$omp declare variant(sub2),match(construct={target}) + !$omp declare variant(sub3) , match(construct={teams}) + !$omp declare_variant(sub4)match(construct={target,teams}) + !$omp declare_variant(sub5),match(user={condition(huge(a2) > 0)}) + !$omp declare_variant(sub6) , match(user={condition(kind(a1) < 0)}) + + !$omp assume,holds(a1 > 0) + !$omp assume , holds(a2 < 0) + !$omp end assume + !$omp end assume + + !$omp begin metadirective,when(user={condition(a3 > 0)}: parallel) + a1 = 0 + !$omp end metadirective + !$omp begin metadirective , when(user={condition(a4 > 0)}: parallel) + a2 = 0 + !$omp end metadirective + + !$omp error,at(execution),message("Hello") + !$omp error , at(execution) , message("world") + + !$omp metadirective,when(user={condition(a1 /= a2)}: flush) + !$omp metadirective , when(user={condition(a2 /= a3)}: taskwait) + end subroutine + + subroutine othersub + integer :: i, j + + !$omp simd,private(j) + do i = 1,1; j = i; end do + !$omp simd , private(j) + do i = 1,1; j = i; end do + + !$omp do,private(j) + do i = 1,1; j = i; end do + !$omp do, private(j) + do i = 1,1; j = i; end do + + !$omp do simd,private(j) + do i = 1,1; j = i; end do + !$omp do simd , private(j) + do i = 1,1; j = i; end do + + !$omp target parallel,firstprivate(j) + !$omp cancellation point,parallel + + !$omp critical,hint(omp_sync_hint_none) + !$omp end critical + + !$omp critical , hint(omp_sync_hint_none) + !$omp end critical + + !$omp critical(ABC1),hint(omp_sync_hint_none) + !$omp end critical(ABC1) + + !$omp critical ( ABC2 ),hint(omp_sync_hint_none) + !$omp end critical ( ABC2 ) + + !$omp critical (ABC3) , hint(omp_sync_hint_none) + !$omp end critical (ABC3) + + !$omp cancel,parallel + !$omp end target parallel,nowait + + !$omp target parallel , firstprivate(j) + !$omp cancellation point , parallel + !$omp cancel , parallel + !$omp end target parallel , nowait + + !$omp parallel , firstprivate(j) + !$omp cancellation_point , parallel + !$omp cancel,parallel + !$omp end parallel + + !$omp parallel , firstprivate(j) + !$omp cancellation point , parallel + !$omp cancel , parallel + !$omp end parallel + + !$omp atomic,update + a1 = a1 + 1 + !$omp end atomic + !$omp atomic , read + j = a1 + !$omp end atomic + + !$omp single,nowait + !$omp end single + !$omp single , nowait + !$omp end single + !$omp single + + !$omp end single,nowait + !$omp single + !$omp end single , nowait + end + + subroutine foo + integer, save :: i, j, k + !$omp groupprivate(k)device_type(nohost) + !$omp groupprivate(i),device_type(nohost) + !$omp groupprivate(j) , device_type(nohost) + end + + subroutine bar + integer(omp_depend_kind) :: obj + !$omp depobj(obj),depend(in: a1) + !$omp depobj(obj)destroy + !$omp depobj(obj) , destroy + end +end module m From 59d235ffa5a69231eb42e5290d52dc8c90d28b7a Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Wed, 23 Sep 2026 13:15:18 +0100 Subject: [PATCH 378/584] libstdc++: Ensure that aligned new detects size_t overflow (CVE-2026-95619) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Depending on the implementation used for aligned new, we might need to round the size argument up to a multiple of the alignment. If either the size or the alignment is a huge value then the rounded result could wraparound to a small value which would then be successfully allocated by the underlying libc allocation function. This means that we return a non-null pointer but not of the requested size. Instead we should throw std::bad_alloc because the allocation cannot succeed. This doesn't affect most modern targets because they use the posix_memalign implementation, which doesn't do that rounding. On targets without posix_memalign we use C11 aligned_alloc and round before calling it. That rounding needs to be checked for overflow. The using-directive for ::aligned_alloc is replaced with a new __gnu_cxx::aligned_alloc function and the existing fix-ups for that path are moved from operator new into the new function, with added check for the overflow we need to fix. On *-*-mingw* we use the Windows _aligned_malloc function which correctly checks for overflow on Windows. But the Wine version of that function does not and has the same overflow problem so we need to do our own checks before calling it. We include a conservative 2*sizeof(void*) adjustment in our own overflow check. On targets without any aligned allocation function we provide our own __gnu_cxx::aligned_alloc in terms of malloc. This also needs an overflow check. libstdc++-v3/ChangeLog: * libsupc++/new_opa.cc [_GLIBCXX_HAVE_ALIGNED_ALLOC] (__gnu_cxx::aligned_alloc): Replace using-directive with new function. Check for size_t overflow. [_GLIBCXX_HAVE__ALIGNED_MALLOC] (__gnu_cxx::aligned_alloc): Check for size_t overflow. (__gnu_cxx::aligned_alloc): Likewise in fallback definition. (operator new) [_GLIBCXX_HAVE_ALIGNED_ALLOC]: Move parameter adjustments to new __gnu_cxx::aligned_alloc function. * testsuite/18_support/new_aligned_wrap.cc: New test. Reviewed-by: Tomasz Kamiński --- libstdc++-v3/libsupc++/new_opa.cc | 49 ++++++++++++------- .../testsuite/18_support/new_aligned_wrap.cc | 39 +++++++++++++++ 2 files changed, 71 insertions(+), 17 deletions(-) create mode 100644 libstdc++-v3/testsuite/18_support/new_aligned_wrap.cc diff --git a/libstdc++-v3/libsupc++/new_opa.cc b/libstdc++-v3/libsupc++/new_opa.cc index 7bda847a9257..bd0098ac09e4 100644 --- a/libstdc++-v3/libsupc++/new_opa.cc +++ b/libstdc++-v3/libsupc++/new_opa.cc @@ -81,12 +81,38 @@ aligned_alloc (std::size_t al, std::size_t sz) return nullptr; } #elif _GLIBCXX_HAVE_ALIGNED_ALLOC -using ::aligned_alloc; +// We have C11 aligned_alloc but we need to satisfy its preconditions. +static inline void* +aligned_alloc (std::size_t al, std::size_t sz) +{ +# if defined _AIX || defined __APPLE__ + /* AIX 7.2.0.0 aligned_alloc incorrectly has posix_memalign's requirement + * that alignment is a multiple of sizeof(void*). + * OS X 10.15 has the same requirement. */ + if (al < sizeof(void*)) + al = sizeof(void*); +# endif + /* C11: the value of size shall be an integral multiple of alignment. */ + if (__builtin_add_overflow(sz, al - 1, &sz)) [[unlikely]] + return nullptr; + sz &= ~(al - 1); + return ::aligned_alloc(al, sz); +} #elif _GLIBCXX_HAVE__ALIGNED_MALLOC +// Use Windows _aligned_malloc static inline void* aligned_alloc (std::size_t al, std::size_t sz) -{ return _aligned_malloc(sz, al); } +{ + // The Wine msvcrt.dll version of _aligned_malloc doesn't detect overflow + // so do it ourselves. We know al + 2 * sizeof(void*) won't overflow because + // has_single_bit(al) was already checked by the caller. + std::size_t check; + if (__builtin_add_overflow(sz, al + 2 * sizeof(void*), &check)) [[unlikely]] + return nullptr; + return _aligned_malloc(sz, al); +} #elif _GLIBCXX_HAVE_MEMALIGN +// Use memalign (and assume that what it returns can be passed to free). static inline void* aligned_alloc (std::size_t al, std::size_t sz) { @@ -103,8 +129,10 @@ aligned_alloc (std::size_t al, std::size_t sz) // We need extra bytes to store the original value returned by malloc. if (al < sizeof(void*)) al = sizeof(void*); - void* const malloc_ptr = malloc(sz + al); - if (!malloc_ptr) + if (__builtin_add_overflow(sz, al, &sz)) [[unlikely]] + return nullptr; + void* const malloc_ptr = malloc(sz); + if (!malloc_ptr) [[unlikely]] return nullptr; // Align to the requested value, leaving room for the original malloc value. void* const aligned_ptr = (void *) (((uintptr_t) malloc_ptr + al) & -al); @@ -131,19 +159,6 @@ operator new (std::size_t sz, std::align_val_t al) if (__builtin_expect (sz == 0, false)) sz = 1; -#if _GLIBCXX_HAVE_POSIX_MEMALIGN -#elif _GLIBCXX_HAVE_ALIGNED_ALLOC -# if defined _AIX || defined __APPLE__ - /* AIX 7.2.0.0 aligned_alloc incorrectly has posix_memalign's requirement - * that alignment is a multiple of sizeof(void*). - * OS X 10.15 has the same requirement. */ - if (align < sizeof(void*)) - align = sizeof(void*); -# endif - /* C11: the value of size shall be an integral multiple of alignment. */ - sz = (sz + align - 1) & ~(align - 1); -#endif - void *p; while ((p = __gnu_cxx::aligned_alloc (align, sz)) == nullptr) diff --git a/libstdc++-v3/testsuite/18_support/new_aligned_wrap.cc b/libstdc++-v3/testsuite/18_support/new_aligned_wrap.cc new file mode 100644 index 000000000000..dbd642d6ba58 --- /dev/null +++ b/libstdc++-v3/testsuite/18_support/new_aligned_wrap.cc @@ -0,0 +1,39 @@ +// { dg-do run } + +#include +#include +#include + +#pragma GCC diagnostic ignored "-Walloc-size-larger-than=" + +void +check_aligned_new_overflow(std::size_t size, std::size_t align) +{ +#if __cpp_aligned_new + std::align_val_t alignv = (std::align_val_t)align; + try + { + (void) ::operator new(size, alignv); + VERIFY(false); + } + catch (const std::bad_alloc&) + { + } + + void* p = ::operator new(size, alignv, std::nothrow); + VERIFY(p == 0); +#endif +} + +int main() +{ + check_aligned_new_overflow(-9, 32); + check_aligned_new_overflow(SIZE_MAX, 8); + check_aligned_new_overflow(SIZE_MAX, 32); + check_aligned_new_overflow(SIZE_MAX, 1024); + check_aligned_new_overflow(SIZE_MAX, 65536); + check_aligned_new_overflow(SIZE_MAX - 1, 16); + check_aligned_new_overflow(SIZE_MAX - 1025, 1024); + check_aligned_new_overflow(SIZE_MAX - 1024, 1024); + check_aligned_new_overflow(SIZE_MAX - 65536, 65536); +} From f41f36835c1179f80dc890de97a5b2b0baf559b6 Mon Sep 17 00:00:00 2001 From: Jeff Law Date: Wed, 23 Sep 2026 09:28:10 -0600 Subject: [PATCH 379/584] [V850] Fix output_operand to handle (high (const ...)) A recent change triggered these regressions on v850-elf: > Tests that now fail, but worked before (7 tests): > > v850-sim/-mgcc-abi/-msoft-float/-mv850e3v5: gcc: gcc.dg/graphite/interchange-0.c (test for excess errors) > v850-sim/-mgcc-abi/-msoft-float/-mv850e3v5: gcc: gcc.dg/graphite/interchange-0.c (test for excess errors) > v850-sim/-mgcc-abi: gcc: gcc.dg/graphite/interchange-0.c (test for excess errors) > v850-sim/-msoft-float/-mv850e3v5: gcc: gcc.dg/graphite/interchange-0.c (test for excess errors) > v850-sim/-msoft-float: gcc: gcc.dg/graphite/interchange-0.c (test for excess errors) > v850-sim/-mv850e3v5: gcc: gcc.dg/graphite/interchange-0.c (test for excess errors) > v850-sim: gcc: gcc.dg/graphite/interchange-0.c (test for excess errors) I didn't bother to chase down what commit was the culprit as it was clear that the v850 backend was buggy. In particular it wasn't handling (high (const ...)) style addresses in output_operand. The fix is trivial. For the HIGH case we can strip the HIGH and fall into the pre-existing CONST/SYMBOL_REF cases. That fixes the regression and fixes gcc.dg/pr85164. Pushing to the trunk. gcc/ * config/v850/v850.cc (v850_print_oprerand): Handle operands like (high (const ...)) by stripping the high and falling into the (const ...) case. --- gcc/config/v850/v850.cc | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/gcc/config/v850/v850.cc b/gcc/config/v850/v850.cc index 8c233cf1e0f6..cd6ba13b4b30 100644 --- a/gcc/config/v850/v850.cc +++ b/gcc/config/v850/v850.cc @@ -623,6 +623,11 @@ v850_print_operand (FILE * file, rtx x, int code) fprintf (file, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x)); break; + case HIGH: + /* Strip off the HIGH and fall through to print the address. */ + x = XEXP (x, 0); + /* Fall through. */ + case CONST_INT: case SYMBOL_REF: case CONST: From 7e186551440862f74208341f5f5d7b6ee320346e Mon Sep 17 00:00:00 2001 From: Robert Dubner Date: Wed, 23 Sep 2026 11:27:31 -0400 Subject: [PATCH 380/584] cobol: Update dynamic linking search paths. These changes modify the policies used to search for .so files when accessing dynamically-linked programs. gcc/cobol/ChangeLog: * gcobol.1: Document the changes. * genapi.cc (function_pointer_from_name): Honor the >>CALL-CONVENTION. (parser_set_pointers): Repair the ZEROES bug. libgcobol/ChangeLog: * libgcobol.cc (do_the_dl_thing): Implement the updated policies. (find_in_dirs): Use modified do_the_dl_thing(). (__gg__function_handle_from_cobpath): Honor the call_convention. (function_handle_from_cobpath): Likewise. (__gg__function_handle_from_literal): Likewise. (__gg__function_handle_from_name): Likewise. --- gcc/cobol/gcobol.1 | 25 +-- gcc/cobol/genapi.cc | 31 +++- libgcobol/libgcobol.cc | 359 +++++++++++++++++++++++++++++++---------- 3 files changed, 311 insertions(+), 104 deletions(-) diff --git a/gcc/cobol/gcobol.1 b/gcc/cobol/gcobol.1 index cdcb71468109..81dd64e76cff 100644 --- a/gcc/cobol/gcobol.1 +++ b/gcc/cobol/gcobol.1 @@ -1954,8 +1954,8 @@ precisely match the behavior of other \*[lang] compilers. You have been warned. . .Sh ENVIRONMENT -.Bl -tag -width GCOBOL_LIBRARY_PATH -.It Ev GCOBOL_LIBRARY_PATH +.Bl -tag -width COBPATH +.It Ev COBPATH If defined, specifies the directory paths to be used by the .Nm runtime library, @@ -1965,11 +1965,11 @@ Like .Ev LD_LIBRARY_PATH , it may contain several directory names separated by a colon .Pq Ql \&: . -.Ev GCOBOL_LIBRARY_PATH +.Ev COBPATH is searched first, followed by .Ev LD_LIBRARY_PATH . Note that -.Ev GCOBOL_LIBRARY_PATH does not change where the runtime linker looks for +.Ev COBPATH does not change where the runtime linker looks for .Pa libgcobol.so itself. How the runtime linker searches for @@ -1978,18 +1978,21 @@ when the executable loads is controlled by .Xr ld.so 8 , not libgcobol. .Pp -Each directory is searched for a file whose name is based on the desired -symbol. The literal name, with -.Ql ".so" -appended, is tried first. For each such file, +Each directory is searched for files whose names are based on the desired +symbol. As an example, consider a CALL to the program-id "FooBar". When the +.Sy CALL-CONVENTION COBOL +is operative, the symbol is forced to lowercase and an attempt is made to find +"FOOBAR.so", followed by an attempt to find "foobar.so". When +.Sy CALL-CONVENTION VERBATIM +is operative, attempts are made to find "FOOBAR.so", then "FooBar.so, and finally +"foobar.so". For each such file, .Xr dlopen 3 is attempted, and if successful, .Xr dlsym 3 is used to search for the -symbol. If either fails, a second attempt is made after converting -the desired symbol to lowercase. +symbol. .Pp When -.Ev GCOBOL_LIBRARY_PATH and +.Ev COBPATH and .Ev LD_LIBRARY_PATH are not explicitly used, binaries produced by .Nm diff --git a/gcc/cobol/genapi.cc b/gcc/cobol/genapi.cc index e3753fd77099..301fd6f82e26 100644 --- a/gcc/cobol/genapi.cc +++ b/gcc/cobol/genapi.cc @@ -806,6 +806,8 @@ function_pointer_from_name(const cbl_refer_t &name, NULL); tree function_pointer_type = build_pointer_type(function_type); + cbl_call_convention_t call_convention = current_call_convention(); + if( name.field->type == FldPointer ) { tree location; @@ -857,6 +859,7 @@ function_pointer_from_name(const cbl_refer_t &name, INT, current_function->our_symbol_table_index), gg_string_literal(name.field->data.original()), + build_int_cst_type(INT, call_convention), NULL_TREE)); } else @@ -872,6 +875,7 @@ function_pointer_from_name(const cbl_refer_t &name, gg_get_address_of(name.field->var_decl_node), refer_offset(name), refer_size_source(name), + build_int_cst_type(INT, call_convention), NULL_TREE)); } @@ -13601,12 +13605,27 @@ parser_set_pointers( size_t ntgt, cbl_refer_t *tgts, cbl_refer_t source ) && (source.field->type == FldAlphanumeric || source.field->type == FldLiteralA)) { - // This is something like SET varp TO ENTRY "ref". - tree function_pointer = function_pointer_from_name(source, - COBOL_FUNCTION_RETURN_64); - gg_memcpy(qualified_data_location(tgts[i]), - gg_get_address_of(function_pointer), - sizeof_pointer); + if( strcmp(source.field->name, "ZEROES") == 0 ) + { + // This is an extra-special corner case. No, it's worse than a corner + // case. It's a pointy case. The caller is essentially setting the + // pointer to the figurative constant ZEROES. But ZERO is both an + // alphanumeric and a numeric, depending on context. Fine. It's + // weird. Let's just set the destination to zeroes, and be done with + // it. + gg_memset(qualified_data_location(tgts[i]), + integer_zero_node, + sizeof_pointer); + } + else + { + // This is something like SET varp TO ENTRY "ref". + tree function_pointer = function_pointer_from_name(source, + COBOL_FUNCTION_RETURN_64); + gg_memcpy(qualified_data_location(tgts[i]), + gg_get_address_of(function_pointer), + sizeof_pointer); + } } else { diff --git a/libgcobol/libgcobol.cc b/libgcobol/libgcobol.cc index 4332d7ddee0d..9890c7dda88e 100644 --- a/libgcobol/libgcobol.cc +++ b/libgcobol/libgcobol.cc @@ -10901,70 +10901,39 @@ __gg__set_program_list( int program_id, static std::unordered_map already_found; static void * do_the_dl_thing(const char *directory, - const char *unmangled_name, - const char *mangled_name) + const std::string &file, + const std::string &name) { - // Using the GnuCOBOL convention, this code looks first for a file - // named unmangled_name.so. It checks for a function unmangled_name - // in that file. When not found, it checks for mangled_name. void *retval = NULL; - void *handle; - std::string file; + std::string path; if( directory ) { - file = directory; - file += '/'; + path = directory; + path += '/'; } - file += unmangled_name; - file += ".so"; - handle = dlopen(file.c_str(), RTLD_LAZY|RTLD_NODELETE ); + path += file; + void * handle = dlopen(path.c_str(), RTLD_NOW|RTLD_NODELETE ); if( handle ) { - retval = dlsym(handle, unmangled_name); - if( retval ) - { - already_found[unmangled_name] = retval; - } - } - if( !retval ) - { - file.clear(); - if( directory ) - { - file = directory; - file += '/'; - } - file += mangled_name; - file += ".so"; - handle = dlopen(file.c_str(), RTLD_LAZY|RTLD_NODELETE ); - if( handle ) - { - retval = dlsym(handle, mangled_name); - if( retval ) - { - already_found[mangled_name] = retval; - } - } + retval = dlsym(handle, name.c_str()); + dlclose(handle); } return retval; } static void * -find_in_dirs(const char *dirs, char *unmangled_name, char *mangled_name) - { - std::unordered_map::const_iterator it = - already_found.find(unmangled_name); - - if( it != already_found.end() ) - { - return it->second; - } - it = already_found.find(mangled_name); - if( it != already_found.end() ) - { - return it->second; - } +find_in_dirs( const char *dirs, + const std::string &fileUPPER, + const std::string &fileMiddle, + const std::string &filelower, + const std::string &unmangled_name, + const std::string &mangled_name) + { + // We know fileUPPER and unmangled_name are not empty. + // The others might be empty. + assert( !fileUPPER.empty() ); + assert( !unmangled_name.empty() ); void *retval = NULL; if( dirs ) @@ -10982,62 +10951,272 @@ find_in_dirs(const char *dirs, char *unmangled_name, char *mangled_name) { p += 1; } - // directory is the next one for us to check: - DIR *dir = opendir(directory.c_str()); - if( dir ) + if( directory.empty() ) + { + break; + } + + retval = do_the_dl_thing(directory.c_str(), + fileUPPER, + unmangled_name); + if( retval ) + { + goto bugout; + } + if( !mangled_name.empty() ) { retval = do_the_dl_thing(directory.c_str(), - unmangled_name, + fileUPPER, mangled_name); - closedir(dir); + if( retval ) + { + goto bugout; + } + } + + if( !fileMiddle.empty() ) + { + retval = do_the_dl_thing(directory.c_str(), + fileMiddle, + unmangled_name); + if( retval ) + { + goto bugout; + } + if( !mangled_name.empty() ) + { + retval = do_the_dl_thing(directory.c_str(), + fileMiddle, + mangled_name); + if( retval ) + { + goto bugout; + } + } + } + if( !filelower.empty() ) + { + retval = do_the_dl_thing(directory.c_str(), + filelower, + unmangled_name); + if( retval ) + { + goto bugout; + } + if( !mangled_name.empty() ) + { + retval = do_the_dl_thing(directory.c_str(), + filelower, + mangled_name); + if( retval ) + { + goto bugout; + } + } } } } else { retval = do_the_dl_thing(nullptr, - unmangled_name, - mangled_name); + fileUPPER, + unmangled_name); + if( retval ) + { + goto bugout; + } + if( !mangled_name.empty() ) + { + retval = do_the_dl_thing(nullptr, + fileUPPER, + mangled_name); + if( retval ) + { + goto bugout; + } + } + if( !fileMiddle.empty() ) + { + retval = do_the_dl_thing(nullptr, + fileMiddle, + unmangled_name); + if( retval ) + { + goto bugout; + } + if( !mangled_name.empty() ) + { + retval = do_the_dl_thing(nullptr, + fileMiddle, + mangled_name); + if( retval ) + { + goto bugout; + } + } + } + if( !filelower.empty() ) + { + retval = do_the_dl_thing(nullptr, + filelower, + unmangled_name); + if( retval ) + { + goto bugout; + } + if( !mangled_name.empty() ) + { + retval = do_the_dl_thing(nullptr, + filelower, + mangled_name); + if( retval ) + { + goto bugout; + } + } + } } + bugout: return retval; } -extern "C" -void * -__gg__function_handle_from_cobpath( char *unmangled_name, char *mangled_name) +static void * +function_handle_from_cobpath( const char *unmangled_name_, + const char *mangled_name_, + int call_convention) { - void *retval; + void *retval = NULL; - // We search for a function. We check first for the unmangled name, and then - // the mangled name. We do this first for the executable, then for .so - // files in GCOBOL_LIBRARY_PATH, and then we allow dlopen to use its default - // behavior. + /* We attempt to look up a function FooBar. + We first look for FooBar in the function. + We then look for foobar in the function. + We then scan the directories in COBPATH. In each directory, we look for + the function name in + FOOBAR.so + FooBar.so + foobar.so + We then allow dlopen to use its defaults to find + FooBar + foobar + We then return NULL, indicating failure. */ - static void *handle_executable = NULL; - if( !handle_executable ) - { - handle_executable = dlopen(NULL, RTLD_NOW); - } - retval = dlsym(handle_executable, unmangled_name); - if( !retval ) + std::string unmangled_name = unmangled_name_; + std::string mangled_name = mangled_name_; + + if( call_convention == 'N' ) { - retval = dlsym(handle_executable, mangled_name); + // This is Native COBOL + // Use the mangled, lowercase name. + unmangled_name = mangled_name; + mangled_name.clear(); } - if( !retval ) + else { - const char *COBPATH = getenv("GCOBOL_LIBRARY_PATH"); - retval = find_in_dirs(COBPATH, unmangled_name, mangled_name); + // This is Verbatim, C-style. + mangled_name.clear(); } - if( !retval ) + + std::string fileUPPER; + std::string fileMiddle; + std::string filelower; + const char *COBPATH; + + static std::unordered_map already_searched; + std::unordered_map::const_iterator it = + already_searched.find(unmangled_name); + if( it != already_searched.end() ) { - const char *COBPATH = getenv("LD_LIBRARY_PATH"); - retval = find_in_dirs(COBPATH, unmangled_name, mangled_name); + // We've already searched for this one, so return the result from the + // original attempt. + retval = it->second; } - if( !retval ) + else { - retval = find_in_dirs(nullptr, unmangled_name, mangled_name); - } + // Look for unmangled in the executable + static void *handle_executable = NULL; + if( !handle_executable ) + { + handle_executable = dlopen(NULL, RTLD_NOW); + } + + retval = dlsym(handle_executable, unmangled_name.c_str()); + if( retval ) + { + goto bugout; + } + + // Look for mangled_name in the executable, provided it is not the same as + // unmangled name: + if( mangled_name == unmangled_name ) + { + mangled_name.clear(); + } + else + { + retval = dlsym(handle_executable, mangled_name.c_str()); + if( retval ) + { + goto bugout; + } + } + + // We are going to be looking for a .so file with our entry point in it. + // Build up the three filename roots: + fileUPPER.clear(); + for(size_t i=0; i= 'a' && ch <= 'z') ? ch - 'a' + 'A' : ch; + } + fileUPPER += ".so"; + + fileMiddle = unmangled_name; + fileMiddle += ".so"; + filelower.clear(); + for(size_t i=0; i= 'A' && ch <= 'Z') ? ch - 'A' + 'a' : ch; + } + filelower += ".so"; + + // Do some extra work here to avoid extra work later. + if( fileMiddle == fileUPPER ) + { + fileMiddle.clear(); + } + if( filelower == fileMiddle ) + { + filelower.clear(); + } + + // We need to search through the COBPATH directories: + + COBPATH = getenv("COBPATH"); + if( COBPATH ) + { + + retval = find_in_dirs(COBPATH, + fileUPPER, + fileMiddle, + filelower, + unmangled_name, + mangled_name); + if( retval ) + { + goto bugout; + } + } + retval = find_in_dirs(nullptr, + fileUPPER, + fileMiddle, + filelower, + unmangled_name, + mangled_name); + bugout: + already_searched[unmangled_name] = retval; + } return retval; } @@ -11106,7 +11285,8 @@ __gg__just_mangle_name( const cblc_field_t *field, extern "C" void * __gg__function_handle_from_literal(int program_id, - const char *literal) + const char *literal, + int call_convention ) { void *retval = NULL; static char ach_unmangled[1024]; @@ -11138,7 +11318,9 @@ __gg__function_handle_from_literal(int program_id, } else { - retval = __gg__function_handle_from_cobpath(ach_unmangled, ach_mangled); + retval = function_handle_from_cobpath(ach_unmangled, + ach_mangled, + call_convention); } return retval; @@ -11149,7 +11331,8 @@ void * __gg__function_handle_from_name(int program_id, const cblc_field_t *field, size_t offset, - size_t length ) + size_t length, + int call_convention ) { void *retval = NULL; static char ach_name[1024]; @@ -11198,7 +11381,9 @@ __gg__function_handle_from_name(int program_id, } else { - retval = __gg__function_handle_from_cobpath(ach_unmangled, ach_mangled); + retval = function_handle_from_cobpath(ach_unmangled, + ach_mangled, + call_convention); } return retval; From 775c869f70344091bee687df99bad668eaa38f6d Mon Sep 17 00:00:00 2001 From: Robert Dubner Date: Wed, 23 Sep 2026 14:00:10 -0400 Subject: [PATCH 381/584] cobol: Add "dg-require-iconv" to automated dg test generation. gcc/testsuite/ChangeLog: * cobol.dg/group2/CBL_READ_FILE__check_file_size_with_flags___128.cob: Add dg-require-iconv directive. * cobol.dg/group2/CDF_Feature_.cob: Likewise. * cobol.dg/group2/CHAR_and_ORD_with_COLLATING_sequence_-_EBCDIC.cob: Likewise. * cobol.dg/group2/FIND-STRING__forward_.cob: Likewise. * cobol.dg/group2/FIND-STRING__reverse_.cob: Likewise. * cobol.dg/group2/RT3609_Unexpected_PROCESS.cob: Likewise. --- .../group2/CBL_READ_FILE__check_file_size_with_flags___128.cob | 1 + gcc/testsuite/cobol.dg/group2/CDF_Feature_.cob | 1 + .../group2/CHAR_and_ORD_with_COLLATING_sequence_-_EBCDIC.cob | 1 + gcc/testsuite/cobol.dg/group2/FIND-STRING__forward_.cob | 1 + gcc/testsuite/cobol.dg/group2/FIND-STRING__reverse_.cob | 1 + gcc/testsuite/cobol.dg/group2/RT3609_Unexpected_PROCESS.cob | 1 + 6 files changed, 6 insertions(+) diff --git a/gcc/testsuite/cobol.dg/group2/CBL_READ_FILE__check_file_size_with_flags___128.cob b/gcc/testsuite/cobol.dg/group2/CBL_READ_FILE__check_file_size_with_flags___128.cob index aac046ccde13..7326d845a8b1 100644 --- a/gcc/testsuite/cobol.dg/group2/CBL_READ_FILE__check_file_size_with_flags___128.cob +++ b/gcc/testsuite/cobol.dg/group2/CBL_READ_FILE__check_file_size_with_flags___128.cob @@ -31,6 +31,7 @@ perform write-file. perform check-file-size. move zero to return-code. + call "CBL_DELETE_FILE" using filename goback. write-file section. diff --git a/gcc/testsuite/cobol.dg/group2/CDF_Feature_.cob b/gcc/testsuite/cobol.dg/group2/CDF_Feature_.cob index fa701da6c522..29cba015e9d4 100644 --- a/gcc/testsuite/cobol.dg/group2/CDF_Feature_.cob +++ b/gcc/testsuite/cobol.dg/group2/CDF_Feature_.cob @@ -1,6 +1,7 @@ *> Do not edit this generated file. See README.txt *> { dg-do run } *> { dg-options "-fexec-charset=ibm1140 -dialect ibm" } + *> { dg-require-iconv "ibm1140" } *> { dg-output-file "group2/CDF_Feature_.out" } id division. diff --git a/gcc/testsuite/cobol.dg/group2/CHAR_and_ORD_with_COLLATING_sequence_-_EBCDIC.cob b/gcc/testsuite/cobol.dg/group2/CHAR_and_ORD_with_COLLATING_sequence_-_EBCDIC.cob index 0cde1ff859ac..5079be6ce1d7 100644 --- a/gcc/testsuite/cobol.dg/group2/CHAR_and_ORD_with_COLLATING_sequence_-_EBCDIC.cob +++ b/gcc/testsuite/cobol.dg/group2/CHAR_and_ORD_with_COLLATING_sequence_-_EBCDIC.cob @@ -1,6 +1,7 @@ *> Do not edit this generated file. See README.txt *> { dg-do run } *> { dg-options "-fexec-charset=ibm1140" } + *> { dg-require-iconv "ibm1140" } *> { dg-output-file "group2/CHAR_and_ORD_with_COLLATING_sequence_-_EBCDIC.out" } IDENTIFICATION DIVISION. PROGRAM-ID. prog. diff --git a/gcc/testsuite/cobol.dg/group2/FIND-STRING__forward_.cob b/gcc/testsuite/cobol.dg/group2/FIND-STRING__forward_.cob index f007d7093443..a75f498784e8 100644 --- a/gcc/testsuite/cobol.dg/group2/FIND-STRING__forward_.cob +++ b/gcc/testsuite/cobol.dg/group2/FIND-STRING__forward_.cob @@ -1,6 +1,7 @@ *> Do not edit this generated file. See README.txt *> { dg-do run } *> { dg-options "-fexec-charset=ibm1140" } + *> { dg-require-iconv "ibm1140" } *> { dg-output-file "group2/FIND-STRING__forward_.out" } IDENTIFICATION DIVISION. PROGRAM-ID. prog. diff --git a/gcc/testsuite/cobol.dg/group2/FIND-STRING__reverse_.cob b/gcc/testsuite/cobol.dg/group2/FIND-STRING__reverse_.cob index e30011e2800a..910de65510e8 100644 --- a/gcc/testsuite/cobol.dg/group2/FIND-STRING__reverse_.cob +++ b/gcc/testsuite/cobol.dg/group2/FIND-STRING__reverse_.cob @@ -1,6 +1,7 @@ *> Do not edit this generated file. See README.txt *> { dg-do run } *> { dg-options "-fexec-charset=ibm1140" } + *> { dg-require-iconv "ibm1140" } *> { dg-output-file "group2/FIND-STRING__reverse_.out" } IDENTIFICATION DIVISION. PROGRAM-ID. prog. diff --git a/gcc/testsuite/cobol.dg/group2/RT3609_Unexpected_PROCESS.cob b/gcc/testsuite/cobol.dg/group2/RT3609_Unexpected_PROCESS.cob index 172a112fa3c6..6575585064fb 100644 --- a/gcc/testsuite/cobol.dg/group2/RT3609_Unexpected_PROCESS.cob +++ b/gcc/testsuite/cobol.dg/group2/RT3609_Unexpected_PROCESS.cob @@ -1,6 +1,7 @@ *> Do not edit this generated file. See README.txt *> { dg-do run } *> { dg-options "-O0 -Wno-ibm-cdf -I copybooks -Wno-recording-mode -ffixed-form -dialect ibm -fno-static-call -fexec-charset=CP037 -fexec-national-charset=CP037" } + *> { dg-require-iconv "CP037" } 00001 PROCESS FLAG(I,W) FDUMP 00002 IDENTIFICATION DIVISION. From daba80d3fd79ca8eee1b916454a4e4abf2a90908 Mon Sep 17 00:00:00 2001 From: GCC Administrator Date: Thu, 24 Sep 2026 00:16:32 +0000 Subject: [PATCH 382/584] Daily bump. --- gcc/ChangeLog | 45 ++++++++++++++++++++++++++ gcc/DATESTAMP | 2 +- gcc/ada/ChangeLog | 72 +++++++++++++++++++++++++++++++++++++++++ gcc/cobol/ChangeLog | 7 ++++ gcc/cp/ChangeLog | 18 +++++++++++ gcc/testsuite/ChangeLog | 45 ++++++++++++++++++++++++++ libgcobol/ChangeLog | 9 ++++++ libstdc++-v3/ChangeLog | 13 ++++++++ 8 files changed, 210 insertions(+), 1 deletion(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index db41308b8d72..3d767aed8421 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,48 @@ +2026-09-23 Jeff Law + + * config/v850/v850.cc (v850_print_oprerand): Handle operands + like (high (const ...)) by stripping the high and falling into + the (const ...) case. + +2026-09-23 Vijay Shankar + + PR target/27479 + * config/rs6000/rs6000.md (tprel_ld__): New pattern. + (tprel_ld_QI_signed): likewise. + (tprel_ld_QI): likewise. + (tprel_ld_DI): likewise. + (tprel_ld_): likewise. + +2026-09-23 Richard Biener + + * tree-vect-stmts.cc (vectorizable_load): Cost non-uniform + invariant loads more appropriately. + +2026-09-23 Tamar Christina + + * fold-const.cc (const_unop): Fold VEC_UNPACK_LO_EXPR and + VEC_UNPACK_HI_EXPR for suitable variable-length VECTOR_CSTs. + (selftest::test_vec_unpack_folding): New function. + (selftest::fold_const_cc_tests): Call it. + +2026-09-23 Tamar Christina + + * config/aarch64/aarch64.cc (aarch64_ifn_vect_stmt_p): New function. + (aarch64_adjust_stmt_cost): Account for extra Adv.SIMD SAD and ABD + reduction costs. + (aarch64_vector_costs::count_ops): Likewise. + +2026-09-23 Tamar Christina + + * config/aarch64/aarch64.cc (aarch64_vect_vf_for_cost): New + function. + (aarch64_vector_costs::adjust_body_cost): Use it. + (aarch64_vector_costs::better_main_loop_than_p): Likewise. + +2026-09-23 Matthias Kretz + + * config/i386/sse.md (roundeven2): New. + 2026-09-22 Chung-Lin Tang * omp-offload.cc (omp_discover_implicit_declare_target): diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index 086b6e065352..0d3a0d16876a 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20260923 +20260924 diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index e9e22dd6b2ae..ba0613ff0e72 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,75 @@ +2026-09-23 Eric Botcazou + + * exp_ch7.adb (Establish_Transient_Scope.Find_Transient_Context): + Add commentary about the distinction between compound and simple + statements, and adjust handling for code and delay statements. + +2026-09-23 Eric Botcazou + + * exp_ch6.adb (Function return mechanisms): Minor tweaks. + +2026-09-23 Eric Botcazou + + * sem_res.adb (Set_String_Literal_Subtype): In the nonstatic case, + set String_Literal_Low_Bound first, and check that the actual high + bound is not larger than the high bound of the index type. + +2026-09-23 Eric Botcazou + + * exp_ch6.adb (Create_Extra_Actuals): Pass True for the extra actual + of the Constrained attribute when the actual contains a conversion + to a constrained subtype. + * sem_res.adb (Resolve_Actuals): Skip the resolution of an actual + that is a view conversion in fewer cases. Remove redundant test. + +2026-09-23 Eric Botcazou + + * sem_aggr.adb (Discriminant_Present): Do not return early if the + component list already contains an inherited discriminant. + (Resolve_Record_Aggregate): For an extension, remove the inherited + discriminants from the component list of the rewritten aggregate. + +2026-09-23 Eric Botcazou + + * checks.adb (Apply_Discriminant_Check): Build the actual subtype of + the LHS for a view conversion of a constrained object. + +2026-09-23 Eric Botcazou + + * sem_ch8.adb (Get_Object_Name): Delete. + (Analyze_Object_Renaming): Use Is_Entity_Name to detect names. + * sem_prag.adb (Analyze_Pragma) : Detect ill-formed + quantified expressions and give an error. + : Likewise. + * sem_res.ads (Malformed_Quantified_Expression): New procedure. + * sem_res.adb (Malformed_Quantified_Expression): Likewise. + (Resolve): Call Malformed_Quantified_Expression to give the error + about ill-formed quantified expressions. + +2026-09-23 Eric Botcazou + + * sem_res.adb (Resolve_Membership_Op): Add guard for generic type + to the test on the RM size. + +2026-09-23 Eric Botcazou + + * sem_res.adb (Resolve_Entry): Fix thinko. + +2026-09-23 Eric Botcazou + + * sem_elab.adb (Invocation_Graph.Process_Package_Declaration): Add + cut-off for broken subunits. + +2026-09-23 Eric Botcazou + + * sem_ch3.adb (Build_Derived_Private_Type): In the case where the + partial view has none but the full view has discriminants, do not + set again the Etype, propagate the Has_Constrained_Partial_View + flag from the parent base type and the Is_Constrained flag from + the partial view of the parent type. + (Build_Derived_Record_Type): Propagate Has_Constrained_Partial_View + from the parent base type. + 2026-09-22 Eric Botcazou * accessibility.adb (Accessibility_Message): Adjust wording. diff --git a/gcc/cobol/ChangeLog b/gcc/cobol/ChangeLog index 4eca8f3da1f2..08b329ab66af 100644 --- a/gcc/cobol/ChangeLog +++ b/gcc/cobol/ChangeLog @@ -1,3 +1,10 @@ +2026-09-23 Robert Dubner + + * gcobol.1: Document the changes. + * genapi.cc (function_pointer_from_name): Honor the + >>CALL-CONVENTION. + (parser_set_pointers): Repair the ZEROES bug. + 2026-09-22 James K. Lowden * parse_ante.h (update_prior_invalid_field): Use is_figconst. diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 6c9b49c2b6f2..ef604ec25fd8 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,21 @@ +2026-09-23 Jakub Jelinek + + PR c++/127506 + * constexpr.cc (is_within_lifetime): When val is error_mark_node, + return it. + +2026-09-23 Jakub Jelinek + + PR c++/125536 + * pt.cc (unify_array_domain): When adding 1 to parm_max or + arg_max, perform the addition in the type of those trees + rather than unconditionally in int type. + +2026-09-23 Jakub Jelinek + + PR c++/126599 + * error.cc (dump_expr): Print OFFSET_TYPE -1 differently. + 2026-09-22 Chung-Lin Tang * parser.cc (cp_parser_omp_clause_name): Add "local" case. diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 7a2ecac1bd5c..bf5555cee3ec 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,48 @@ +2026-09-23 Robert Dubner + + * cobol.dg/group2/CBL_READ_FILE__check_file_size_with_flags___128.cob: + Add dg-require-iconv directive. + * cobol.dg/group2/CDF_Feature_.cob: Likewise. + * cobol.dg/group2/CHAR_and_ORD_with_COLLATING_sequence_-_EBCDIC.cob: + Likewise. + * cobol.dg/group2/FIND-STRING__forward_.cob: Likewise. + * cobol.dg/group2/FIND-STRING__reverse_.cob: Likewise. + * cobol.dg/group2/RT3609_Unexpected_PROCESS.cob: Likewise. + +2026-09-23 Tobias Burnus + + * gfortran.dg/gomp/directive-comma-clause.f90: New test. + +2026-09-23 Vijay Shankar + + PR target/27479 + * gcc.target/powerpc/pr27479.c: New Test. + +2026-09-23 Jakub Jelinek + + PR c++/127506 + * g++.dg/cpp26/within-lifetime13.C: New test. + +2026-09-23 Jakub Jelinek + + PR c++/125536 + * g++.dg/template/unify14.C: New test. + +2026-09-23 Jakub Jelinek + + PR c++/126599 + * g++.dg/diagnostic/ptrtomem5.C: New test. + * g++.dg/diagnostic/ptrtomem6.C: New test. + * g++.dg/reflect/display_string_of1.C: Add 2 new tests. + * g++.dg/reflect/u8display_string_of1.C: Likewise. + +2026-09-23 Matthias Kretz + + * gcc.target/i386/avx-roundeven.c: New test. + * gcc.target/i386/avx512f-roundeven.c: New test. + * gcc.target/i386/avx512fp16-roundeven.c: New test. + * gcc.target/i386/sse4_1-roundeven.c: New test. + 2026-09-22 Jose E. Marchesi * algol68/compile/prepostlude-crash-1.a68: New test. diff --git a/libgcobol/ChangeLog b/libgcobol/ChangeLog index db6013de2884..fd41284d80bc 100644 --- a/libgcobol/ChangeLog +++ b/libgcobol/ChangeLog @@ -1,3 +1,12 @@ +2026-09-23 Robert Dubner + + * libgcobol.cc (do_the_dl_thing): Implement the updated policies. + (find_in_dirs): Use modified do_the_dl_thing(). + (__gg__function_handle_from_cobpath): Honor the call_convention. + (function_handle_from_cobpath): Likewise. + (__gg__function_handle_from_literal): Likewise. + (__gg__function_handle_from_name): Likewise. + 2026-09-22 Xavier Del Campo Romero * compat/gnu/lib/cbl_gpi.cc (struct gpi_priv): Fix flawed logic. diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 76fbbcdb629a..db911874f5b0 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,16 @@ +2026-09-23 Jonathan Wakely + + * libsupc++/new_opa.cc + [_GLIBCXX_HAVE_ALIGNED_ALLOC] (__gnu_cxx::aligned_alloc): + Replace using-directive with new function. Check for size_t + overflow. + [_GLIBCXX_HAVE__ALIGNED_MALLOC] (__gnu_cxx::aligned_alloc): + Check for size_t overflow. + (__gnu_cxx::aligned_alloc): Likewise in fallback definition. + (operator new) [_GLIBCXX_HAVE_ALIGNED_ALLOC]: Move parameter + adjustments to new __gnu_cxx::aligned_alloc function. + * testsuite/18_support/new_aligned_wrap.cc: New test. + 2026-09-22 Jonathan Wakely * config/io/basic_file_stdio.h (__basic_file): Define copy From 2000ac7817b353ea920948ae74f9308dd28c4389 Mon Sep 17 00:00:00 2001 From: Robert Dubner Date: Wed, 23 Sep 2026 22:12:57 -0400 Subject: [PATCH 383/584] cobol: Cache COBPATH directories for doing .so file searches. libgcobol/ChangeLog: * libgcobol.cc (find_in_dirs): Use the cached array. (function_handle_from_cobpath): Create the cached array. gcc/testsuite/ChangeLog: * cobol.dg/group2/Passing_ADDRESS_OF_parameter.cob: New test. * cobol.dg/group2/Passing_ADDRESS_OF_parameter.out: New test. * cobol.dg/group2/Repository_uber_alles.cob: New test. * cobol.dg/group2/Repository_uber_alles.out: New test. --- .../group2/Passing_ADDRESS_OF_parameter.cob | 42 ++++ .../group2/Passing_ADDRESS_OF_parameter.out | 3 + .../cobol.dg/group2/Repository_uber_alles.cob | 121 ++++++++++++ .../cobol.dg/group2/Repository_uber_alles.out | 2 + libgcobol/libgcobol.cc | 184 +++++++++--------- 5 files changed, 263 insertions(+), 89 deletions(-) create mode 100644 gcc/testsuite/cobol.dg/group2/Passing_ADDRESS_OF_parameter.cob create mode 100644 gcc/testsuite/cobol.dg/group2/Passing_ADDRESS_OF_parameter.out create mode 100644 gcc/testsuite/cobol.dg/group2/Repository_uber_alles.cob create mode 100644 gcc/testsuite/cobol.dg/group2/Repository_uber_alles.out diff --git a/gcc/testsuite/cobol.dg/group2/Passing_ADDRESS_OF_parameter.cob b/gcc/testsuite/cobol.dg/group2/Passing_ADDRESS_OF_parameter.cob new file mode 100644 index 000000000000..392bd67e22ba --- /dev/null +++ b/gcc/testsuite/cobol.dg/group2/Passing_ADDRESS_OF_parameter.cob @@ -0,0 +1,42 @@ + *> Do not edit this generated file. See README.txt + *> { dg-do run } + *> { dg-output-file "group2/Passing_ADDRESS_OF_parameter.out" } + identification division. + function-id. func. + data division. + working-storage section. + 01 foo pic 9999 based. + linkage section. + 01 pfoo pointer. + 01 zed pic 999 value zero. + procedure division using by value pfoo returning zed. + set address of foo to pfoo + display "foo in func " foo " should be ""1234""" + goback. + end function func. + + identification division. + program-id. prog. + data division. + working-storage section. + 01 foo pic 9999 value 1234. + 01 zed pic 999. + procedure division. + move function func(address of foo) to zed + call "prog2" using address of foo. + goback. + end program prog. + + identification division. + program-id. prog2. + data division. + working-storage section. + 01 foo pic 9999 based. + linkage section. + 01 pfoo pointer. + procedure division using by value pfoo. + set address of foo to pfoo + display "foo in prog2 " foo " should be ""1234""" + goback. + end program prog2. + diff --git a/gcc/testsuite/cobol.dg/group2/Passing_ADDRESS_OF_parameter.out b/gcc/testsuite/cobol.dg/group2/Passing_ADDRESS_OF_parameter.out new file mode 100644 index 000000000000..1550f3cc1f5d --- /dev/null +++ b/gcc/testsuite/cobol.dg/group2/Passing_ADDRESS_OF_parameter.out @@ -0,0 +1,3 @@ +foo in func 1234 should be "1234" +foo in prog2 1234 should be "1234" + diff --git a/gcc/testsuite/cobol.dg/group2/Repository_uber_alles.cob b/gcc/testsuite/cobol.dg/group2/Repository_uber_alles.cob new file mode 100644 index 000000000000..5660a462013a --- /dev/null +++ b/gcc/testsuite/cobol.dg/group2/Repository_uber_alles.cob @@ -0,0 +1,121 @@ + *> Do not edit this generated file. See README.txt + *> { dg-do run } + *> { dg-output-file "group2/Repository_uber_alles.out" } + + IDENTIFICATION DIVISION. + PROGRAM-ID. prog. + ENVIRONMENT DIVISION. + CONFIGURATION SECTION. + SOURCE-COMPUTER. a. + OBJECT-COMPUTER. a. + REPOSITORY. Function + ABS, + ACOS, + ANNUITY, + ASIN, + ATAN, + BASECONVERT, + BIT-OF, + BIT-TO-CHAR, + BOOLEAN-OF-INTEGER, + BYTE-LENGTH, + CHAR, + CHAR-NATIONAL, + COMBINED-DATETIME, + CONCAT, + CONVERT, + COS, + CURRENT-DATE, + DATE-OF-INTEGER, + DATE-TO-YYYYMMDD, + DAY-OF-INTEGER, + DAY-TO-YYYYDDD, + DISPLAY-OF, + E, + EXCEPTION-FILE, + EXCEPTION-FILE-N, + EXCEPTION-LOCATION, + EXCEPTION-LOCATION-N, + EXCEPTION-STATEMENT, + EXCEPTION-STATUS, + EXP, + EXP10, + FACTORIAL, + FIND-STRING, + FORMATTED-CURRENT-DATE, + FORMATTED-DATE, + FORMATTED-DATETIME, + FORMATTED-TIME, + FRACTION-PART, + HEX-OF, + HEX-TO-CHAR, + HIGHEST-ALGEBRAIC, + INTEGER, + INTEGER-OF-BOOLEAN, + INTEGER-OF-DATE, + INTEGER-OF-DAY, + INTEGER-OF-FORMATTED-DATE, + INTEGER-PART, + LENGTH, + LOCALE-COMPARE, + LOCALE-DATE, + LOCALE-TIME, + LOCALE-TIME-FROM-SECONDS, + LOG, + LOG10, + LOWER-CASE, + LOWEST-ALGEBRAIC, + MAXX, + MEAN, + MEDIAN, + MIDRANGE, + MINN, + MOD, + MODULE-NAME, + NATIONAL-OF, + NUMVAL, + NUMVAL-C, + NUMVAL-F, + ORD, + ORD-MAX, + ORD-MIN, + PI, + PRESENT-VALUE, + RANDOM, + RANGE, + REM, + REVERSE, + SECONDS-FROM-FORMATTED-TIME, + SECONDS-PAST-MIDNIGHT, + SIGN, + SIN, + SMALLEST-ALGEBRAIC, + SQRT, + STANDARD-COMPARE, + STANDARD-DEVIATION, + SUBSTITUTE, + SUM, + TAN, + TEST-DATE-YYYYMMDD, + TEST-DAY-YYYYDDD, + TEST-FORMATTED-DATETIME, + TEST-NUMVAL, + TEST-NUMVAL-C, + TEST-NUMVAL-F, + TRIM, + ULENGTH, + UPOS, + UPPER-CASE, + USUBSTR, + USUPPLEMENTARY, + UUID4, + UVALID, + UWIDTH, + VARIANCE, + WHEN-COMPILED, + YEAR-TO-YYYY, + intrinsic + . + PROCEDURE DIVISION. + DISPLAY "OK". + diff --git a/gcc/testsuite/cobol.dg/group2/Repository_uber_alles.out b/gcc/testsuite/cobol.dg/group2/Repository_uber_alles.out new file mode 100644 index 000000000000..885fd66bd887 --- /dev/null +++ b/gcc/testsuite/cobol.dg/group2/Repository_uber_alles.out @@ -0,0 +1,2 @@ +OK + diff --git a/libgcobol/libgcobol.cc b/libgcobol/libgcobol.cc index 9890c7dda88e..7e48914c8e52 100644 --- a/libgcobol/libgcobol.cc +++ b/libgcobol/libgcobol.cc @@ -10923,7 +10923,7 @@ do_the_dl_thing(const char *directory, static void * -find_in_dirs( const char *dirs, +find_in_dirs( const std::vector &directories, const std::string &fileUPPER, const std::string &fileMiddle, const std::string &filelower, @@ -10936,28 +10936,32 @@ find_in_dirs( const char *dirs, assert( !unmangled_name.empty() ); void *retval = NULL; - if( dirs ) + for( auto it= directories.begin(); it!=directories.end(); it++) { - std::string directory; - const char *p = dirs; - while( !retval && *p ) + std::string directory = *it; + + retval = do_the_dl_thing(directory.c_str(), + fileUPPER, + unmangled_name); + if( retval ) { - directory.clear(); - while( *p && *p != ':' ) - { - directory += *p++; - } - if( *p == ':' ) - { - p += 1; - } - if( directory.empty() ) + goto bugout; + } + if( !mangled_name.empty() ) + { + retval = do_the_dl_thing(directory.c_str(), + fileUPPER, + mangled_name); + if( retval ) { - break; + goto bugout; } + } + if( !fileMiddle.empty() ) + { retval = do_the_dl_thing(directory.c_str(), - fileUPPER, + fileMiddle, unmangled_name); if( retval ) { @@ -10966,60 +10970,59 @@ find_in_dirs( const char *dirs, if( !mangled_name.empty() ) { retval = do_the_dl_thing(directory.c_str(), - fileUPPER, + fileMiddle, mangled_name); if( retval ) { goto bugout; } } - - if( !fileMiddle.empty() ) + } + if( !filelower.empty() ) + { + retval = do_the_dl_thing(directory.c_str(), + filelower, + unmangled_name); + if( retval ) { - retval = do_the_dl_thing(directory.c_str(), - fileMiddle, - unmangled_name); - if( retval ) - { - goto bugout; - } - if( !mangled_name.empty() ) - { - retval = do_the_dl_thing(directory.c_str(), - fileMiddle, - mangled_name); - if( retval ) - { - goto bugout; - } - } + goto bugout; } - if( !filelower.empty() ) + if( !mangled_name.empty() ) { retval = do_the_dl_thing(directory.c_str(), filelower, - unmangled_name); + mangled_name); if( retval ) { goto bugout; } - if( !mangled_name.empty() ) - { - retval = do_the_dl_thing(directory.c_str(), - filelower, - mangled_name); - if( retval ) - { - goto bugout; - } - } } } } - else + + retval = do_the_dl_thing(nullptr, + fileUPPER, + unmangled_name); + if( retval ) + { + goto bugout; + } + + if( !mangled_name.empty() ) { retval = do_the_dl_thing(nullptr, fileUPPER, + mangled_name); + if( retval ) + { + goto bugout; + } + } + + if( !fileMiddle.empty() ) + { + retval = do_the_dl_thing(nullptr, + fileMiddle, unmangled_name); if( retval ) { @@ -11028,52 +11031,32 @@ find_in_dirs( const char *dirs, if( !mangled_name.empty() ) { retval = do_the_dl_thing(nullptr, - fileUPPER, + fileMiddle, mangled_name); if( retval ) { goto bugout; } } - if( !fileMiddle.empty() ) + } + if( !filelower.empty() ) + { + retval = do_the_dl_thing(nullptr, + filelower, + unmangled_name); + if( retval ) { - retval = do_the_dl_thing(nullptr, - fileMiddle, - unmangled_name); - if( retval ) - { - goto bugout; - } - if( !mangled_name.empty() ) - { - retval = do_the_dl_thing(nullptr, - fileMiddle, - mangled_name); - if( retval ) - { - goto bugout; - } - } + goto bugout; } - if( !filelower.empty() ) + if( !mangled_name.empty() ) { retval = do_the_dl_thing(nullptr, filelower, - unmangled_name); + mangled_name); if( retval ) { goto bugout; } - if( !mangled_name.empty() ) - { - retval = do_the_dl_thing(nullptr, - filelower, - mangled_name); - if( retval ) - { - goto bugout; - } - } } } bugout: @@ -11091,7 +11074,7 @@ function_handle_from_cobpath( const char *unmangled_name_, We first look for FooBar in the function. We then look for foobar in the function. We then scan the directories in COBPATH. In each directory, we look for - the function name in + the function name in FOOBAR.so FooBar.so foobar.so @@ -11110,7 +11093,7 @@ function_handle_from_cobpath( const char *unmangled_name_, unmangled_name = mangled_name; mangled_name.clear(); } - else + else { // This is Verbatim, C-style. mangled_name.clear(); @@ -11119,7 +11102,6 @@ function_handle_from_cobpath( const char *unmangled_name_, std::string fileUPPER; std::string fileMiddle; std::string filelower; - const char *COBPATH; static std::unordered_map already_searched; std::unordered_map::const_iterator it = @@ -11192,12 +11174,36 @@ function_handle_from_cobpath( const char *unmangled_name_, } // We need to search through the COBPATH directories: - - COBPATH = getenv("COBPATH"); - if( COBPATH ) + static bool initialized = false; + static std::vector directories; + static std::vector dummy; + if( !initialized ) { + initialized = true; + const char *COBPATH = getenv("COBPATH"); + const char *p = COBPATH; + while( p && *p ) + { + std::string directory; + while( *p && *p != ':' ) + { + directory += *p++; + } + if( *p == ':' ) + { + p += 1; + } + if( directory.empty() ) + { + break; + } + directories.push_back(directory); + } + } - retval = find_in_dirs(COBPATH, + if( !directories.empty() ) + { + retval = find_in_dirs(directories, fileUPPER, fileMiddle, filelower, @@ -11208,7 +11214,7 @@ function_handle_from_cobpath( const char *unmangled_name_, goto bugout; } } - retval = find_in_dirs(nullptr, + retval = find_in_dirs(dummy, fileUPPER, fileMiddle, filelower, From 2e8bb62f985815704390963e083276226be15939 Mon Sep 17 00:00:00 2001 From: Pan Li Date: Tue, 22 Sep 2026 20:10:56 +0800 Subject: [PATCH 384/584] RISC-V: Allow RVV register overlap for vfw{add,sub,mul}.vv Like vw{add,sub,mul}[u].vv, allow the rvv register overlap for the dual widen float vv insns, aka vfwadd.vv, vfwsub.vv and vfwmul.vv. gcc/ChangeLog: * config/riscv/vector.md: Leverage Wvr constraint. Signed-off-by: Pan Li --- gcc/config/riscv/vector.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/gcc/config/riscv/vector.md b/gcc/config/riscv/vector.md index 023668ceadae..37f7b94604d3 100644 --- a/gcc/config/riscv/vector.md +++ b/gcc/config/riscv/vector.md @@ -7292,24 +7292,24 @@ ;; Vector Widening Add/Subtract/Multiply. (define_insn "@pred_dual_widen_" - [(set (match_operand:VWEXTF 0 "register_operand" "=&vr, &vr") + [(set (match_operand:VWEXTF 0 "register_operand" "=vr, vr, vd, vd") (if_then_else:VWEXTF (unspec: - [(match_operand: 1 "vector_mask_operand" "vmWc1,vmWc1") - (match_operand 5 "vector_length_operand" " rvl, rvl") - (match_operand 6 "const_int_operand" " i, i") - (match_operand 7 "const_int_operand" " i, i") - (match_operand 8 "const_int_operand" " i, i") - (match_operand 9 "const_int_operand" " i, i") + [(match_operand: 1 "vector_mask_operand" "Wc1,Wc1, vm, vm") + (match_operand 5 "vector_length_operand" "rvl,rvl,rvl,rvl") + (match_operand 6 "const_int_operand" " i, i, i, i") + (match_operand 7 "const_int_operand" " i, i, i, i") + (match_operand 8 "const_int_operand" " i, i, i, i") + (match_operand 9 "const_int_operand" " i, i, i, i") (reg:SI VL_REGNUM) (reg:SI VTYPE_REGNUM) (reg:SI FRM_REGNUM)] UNSPEC_VPREDICATE) (any_widen_binop:VWEXTF (float_extend:VWEXTF - (match_operand: 3 "register_operand" " vr, vr")) + (match_operand: 3 "register_operand" "Wvr,Wvr,Wvr,Wvr")) (float_extend:VWEXTF - (match_operand: 4 "register_operand" " vr, vr"))) - (match_operand:VWEXTF 2 "vector_merge_operand" " vu, 0")))] + (match_operand: 4 "register_operand" "Wvr,Wvr,Wvr,Wvr"))) + (match_operand:VWEXTF 2 "vector_merge_operand" " vu, 0, vu, 0")))] "TARGET_VECTOR" "vfw.vv\t%0,%3,%4%p1" [(set_attr "type" "vf") From 60033199ec3d4e590cb22a59e78decf4dd8bf14f Mon Sep 17 00:00:00 2001 From: Pan Li Date: Tue, 22 Sep 2026 20:11:19 +0800 Subject: [PATCH 385/584] RISC-V: Add test cases for vfwadd.vv reg overlap Add test cases for register group overlap, please note it is not overlap as much as possible. gcc/testsuite/ChangeLog: * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-m1.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-m2.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-m4.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-mf2.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-mf4.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-m1.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-m2.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-m4.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-mf2.c: New test. Signed-off-by: Pan Li --- .../autovec/group_overlap/vfwadd_vv-f16-m1.c | 17 +++++++++++++++++ .../autovec/group_overlap/vfwadd_vv-f16-m2.c | 17 +++++++++++++++++ .../autovec/group_overlap/vfwadd_vv-f16-m4.c | 17 +++++++++++++++++ .../autovec/group_overlap/vfwadd_vv-f16-mf2.c | 19 +++++++++++++++++++ .../autovec/group_overlap/vfwadd_vv-f16-mf4.c | 19 +++++++++++++++++++ .../autovec/group_overlap/vfwadd_vv-f32-m1.c | 17 +++++++++++++++++ .../autovec/group_overlap/vfwadd_vv-f32-m2.c | 17 +++++++++++++++++ .../autovec/group_overlap/vfwadd_vv-f32-m4.c | 17 +++++++++++++++++ .../autovec/group_overlap/vfwadd_vv-f32-mf2.c | 19 +++++++++++++++++++ 9 files changed, 159 insertions(+) create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-m1.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-m2.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-m4.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-mf2.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-mf4.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-m1.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-m2.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-m4.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-mf2.c diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-m1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-m1.c new file mode 100644 index 000000000000..c856be6ca0a9 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-m1.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e16m1, + vfloat16m1_t, + vfloat32m2_t, + __riscv_vle16_v_f16m1, + __riscv_vfwadd_vv_f32m2, + __riscv_vse32_v_f32m2, + vfwadd_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X16) + +/* { dg-final { scan-assembler-times {vfwadd\.vv\s+v2,v1,v3([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwadd\.vv\s+v10,v11,v3([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-m2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-m2.c new file mode 100644 index 000000000000..6df4c01cc75d --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-m2.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e16m2, + vfloat16m2_t, + vfloat32m4_t, + __riscv_vle16_v_f16m2, + __riscv_vfwadd_vv_f32m4, + __riscv_vse32_v_f32m4, + vfwadd_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X8) + +/* { dg-final { scan-assembler-times {vfwadd\.vv\s+v8,v10,v6([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwadd\.vv\s+v28,v30,v24([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-m4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-m4.c new file mode 100644 index 000000000000..b3e0f9eafdb9 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-m4.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e16m4, + vfloat16m4_t, + vfloat32m8_t, + __riscv_vle16_v_f16m4, + __riscv_vfwadd_vv_f32m8, + __riscv_vse32_v_f32m8, + vfwadd_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X4) + +/* { dg-final { scan-assembler-times {vfwadd\.vv\s+v8,v4,v12([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwadd\.vv\s+v24,v28,v16([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-mf2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-mf2.c new file mode 100644 index 000000000000..fd99a4f24151 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-mf2.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e16m1, + vfloat16mf2_t, + vfloat32m1_t, + __riscv_vle16_v_f16mf2, + __riscv_vfwadd_vv_f32m1, + __riscv_vse32_v_f32m1, + vfwadd_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X16) + +/* The fractional LMUL source has EMUL < 1, thus the widened destination + register group must not overlap either source at all. */ +/* { dg-final { scan-assembler-not {vfwadd\.vv\s+(v[0-9]+),\1,} } } */ +/* { dg-final { scan-assembler-not {vfwadd\.vv\s+(v[0-9]+),v[0-9]+,\1([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-mf4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-mf4.c new file mode 100644 index 000000000000..141aa8b143b9 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-mf4.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e16m1, + vfloat16mf4_t, + vfloat32mf2_t, + __riscv_vle16_v_f16mf4, + __riscv_vfwadd_vv_f32mf2, + __riscv_vse32_v_f32mf2, + vfwadd_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X16) + +/* The fractional LMUL source has EMUL < 1, thus the widened destination + register group must not overlap either source at all. */ +/* { dg-final { scan-assembler-not {vfwadd\.vv\s+(v[0-9]+),\1,} } } */ +/* { dg-final { scan-assembler-not {vfwadd\.vv\s+(v[0-9]+),v[0-9]+,\1([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-m1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-m1.c new file mode 100644 index 000000000000..b6c0a63ac9f9 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-m1.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e32m1, + vfloat32m1_t, + vfloat64m2_t, + __riscv_vle32_v_f32m1, + __riscv_vfwadd_vv_f64m2, + __riscv_vse64_v_f64m2, + vfwadd_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X16) + +/* { dg-final { scan-assembler-times {vfwadd\.vv\s+v2,v1,v3([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwadd\.vv\s+v10,v11,v3([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-m2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-m2.c new file mode 100644 index 000000000000..6becaeac5340 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-m2.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e32m2, + vfloat32m2_t, + vfloat64m4_t, + __riscv_vle32_v_f32m2, + __riscv_vfwadd_vv_f64m4, + __riscv_vse64_v_f64m4, + vfwadd_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X8) + +/* { dg-final { scan-assembler-times {vfwadd\.vv\s+v8,v10,v6([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwadd\.vv\s+v28,v30,v24([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-m4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-m4.c new file mode 100644 index 000000000000..ed02eb3e949c --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-m4.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e32m4, + vfloat32m4_t, + vfloat64m8_t, + __riscv_vle32_v_f32m4, + __riscv_vfwadd_vv_f64m8, + __riscv_vse64_v_f64m8, + vfwadd_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X4) + +/* { dg-final { scan-assembler-times {vfwadd\.vv\s+v8,v4,v12([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwadd\.vv\s+v24,v28,v16([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-mf2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-mf2.c new file mode 100644 index 000000000000..4e58eca65a4a --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-mf2.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e32m1, + vfloat32mf2_t, + vfloat64m1_t, + __riscv_vle32_v_f32mf2, + __riscv_vfwadd_vv_f64m1, + __riscv_vse64_v_f64m1, + vfwadd_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X16) + +/* The fractional LMUL source has EMUL < 1, thus the widened destination + register group must not overlap either source at all. */ +/* { dg-final { scan-assembler-not {vfwadd\.vv\s+(v[0-9]+),\1,} } } */ +/* { dg-final { scan-assembler-not {vfwadd\.vv\s+(v[0-9]+),v[0-9]+,\1([^0-9]|$)} } } */ From f8c83fa5bce8da5790286e7982a546d711ea37b0 Mon Sep 17 00:00:00 2001 From: Pan Li Date: Tue, 22 Sep 2026 20:11:19 +0800 Subject: [PATCH 386/584] RISC-V: Add test cases for vfwsub.vv reg overlap Add test cases for register group overlap, please note it is not overlap as much as possible. gcc/testsuite/ChangeLog: * gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-m1.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-m2.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-m4.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-mf2.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-mf4.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-m1.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-m2.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-m4.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-mf2.c: New test. Signed-off-by: Pan Li --- .../autovec/group_overlap/vfwsub_vv-f16-m1.c | 17 +++++++++++++++++ .../autovec/group_overlap/vfwsub_vv-f16-m2.c | 17 +++++++++++++++++ .../autovec/group_overlap/vfwsub_vv-f16-m4.c | 17 +++++++++++++++++ .../autovec/group_overlap/vfwsub_vv-f16-mf2.c | 19 +++++++++++++++++++ .../autovec/group_overlap/vfwsub_vv-f16-mf4.c | 19 +++++++++++++++++++ .../autovec/group_overlap/vfwsub_vv-f32-m1.c | 17 +++++++++++++++++ .../autovec/group_overlap/vfwsub_vv-f32-m2.c | 17 +++++++++++++++++ .../autovec/group_overlap/vfwsub_vv-f32-m4.c | 17 +++++++++++++++++ .../autovec/group_overlap/vfwsub_vv-f32-mf2.c | 19 +++++++++++++++++++ 9 files changed, 159 insertions(+) create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-m1.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-m2.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-m4.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-mf2.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-mf4.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-m1.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-m2.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-m4.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-mf2.c diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-m1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-m1.c new file mode 100644 index 000000000000..685820d2ca90 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-m1.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e16m1, + vfloat16m1_t, + vfloat32m2_t, + __riscv_vle16_v_f16m1, + __riscv_vfwsub_vv_f32m2, + __riscv_vse32_v_f32m2, + vfwsub_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X16) + +/* { dg-final { scan-assembler-times {vfwsub\.vv\s+v2,v1,v3([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwsub\.vv\s+v10,v11,v3([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-m2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-m2.c new file mode 100644 index 000000000000..7ee9272c7be0 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-m2.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e16m2, + vfloat16m2_t, + vfloat32m4_t, + __riscv_vle16_v_f16m2, + __riscv_vfwsub_vv_f32m4, + __riscv_vse32_v_f32m4, + vfwsub_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X8) + +/* { dg-final { scan-assembler-times {vfwsub\.vv\s+v8,v10,v6([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwsub\.vv\s+v28,v30,v24([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-m4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-m4.c new file mode 100644 index 000000000000..cf806befd73e --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-m4.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e16m4, + vfloat16m4_t, + vfloat32m8_t, + __riscv_vle16_v_f16m4, + __riscv_vfwsub_vv_f32m8, + __riscv_vse32_v_f32m8, + vfwsub_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X4) + +/* { dg-final { scan-assembler-times {vfwsub\.vv\s+v8,v4,v12([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwsub\.vv\s+v24,v28,v16([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-mf2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-mf2.c new file mode 100644 index 000000000000..c285ff535eb9 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-mf2.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e16m1, + vfloat16mf2_t, + vfloat32m1_t, + __riscv_vle16_v_f16mf2, + __riscv_vfwsub_vv_f32m1, + __riscv_vse32_v_f32m1, + vfwsub_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X16) + +/* The fractional LMUL source has EMUL < 1, thus the widened destination + register group must not overlap either source at all. */ +/* { dg-final { scan-assembler-not {vfwsub\.vv\s+(v[0-9]+),\1,} } } */ +/* { dg-final { scan-assembler-not {vfwsub\.vv\s+(v[0-9]+),v[0-9]+,\1([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-mf4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-mf4.c new file mode 100644 index 000000000000..b3dccebfcd3b --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-mf4.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e16m1, + vfloat16mf4_t, + vfloat32mf2_t, + __riscv_vle16_v_f16mf4, + __riscv_vfwsub_vv_f32mf2, + __riscv_vse32_v_f32mf2, + vfwsub_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X16) + +/* The fractional LMUL source has EMUL < 1, thus the widened destination + register group must not overlap either source at all. */ +/* { dg-final { scan-assembler-not {vfwsub\.vv\s+(v[0-9]+),\1,} } } */ +/* { dg-final { scan-assembler-not {vfwsub\.vv\s+(v[0-9]+),v[0-9]+,\1([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-m1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-m1.c new file mode 100644 index 000000000000..79adfed1ca5b --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-m1.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e32m1, + vfloat32m1_t, + vfloat64m2_t, + __riscv_vle32_v_f32m1, + __riscv_vfwsub_vv_f64m2, + __riscv_vse64_v_f64m2, + vfwsub_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X16) + +/* { dg-final { scan-assembler-times {vfwsub\.vv\s+v2,v1,v3([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwsub\.vv\s+v10,v11,v3([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-m2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-m2.c new file mode 100644 index 000000000000..b2b7c3b6cd91 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-m2.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e32m2, + vfloat32m2_t, + vfloat64m4_t, + __riscv_vle32_v_f32m2, + __riscv_vfwsub_vv_f64m4, + __riscv_vse64_v_f64m4, + vfwsub_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X8) + +/* { dg-final { scan-assembler-times {vfwsub\.vv\s+v8,v10,v6([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwsub\.vv\s+v28,v30,v24([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-m4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-m4.c new file mode 100644 index 000000000000..7b4ae7f501c2 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-m4.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e32m4, + vfloat32m4_t, + vfloat64m8_t, + __riscv_vle32_v_f32m4, + __riscv_vfwsub_vv_f64m8, + __riscv_vse64_v_f64m8, + vfwsub_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X4) + +/* { dg-final { scan-assembler-times {vfwsub\.vv\s+v8,v4,v12([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwsub\.vv\s+v24,v28,v16([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-mf2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-mf2.c new file mode 100644 index 000000000000..21d4f328306e --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-mf2.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e32m1, + vfloat32mf2_t, + vfloat64m1_t, + __riscv_vle32_v_f32mf2, + __riscv_vfwsub_vv_f64m1, + __riscv_vse64_v_f64m1, + vfwsub_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X16) + +/* The fractional LMUL source has EMUL < 1, thus the widened destination + register group must not overlap either source at all. */ +/* { dg-final { scan-assembler-not {vfwsub\.vv\s+(v[0-9]+),\1,} } } */ +/* { dg-final { scan-assembler-not {vfwsub\.vv\s+(v[0-9]+),v[0-9]+,\1([^0-9]|$)} } } */ From 6e82949c656b32424e50123a48bdcd018200b401 Mon Sep 17 00:00:00 2001 From: Pan Li Date: Tue, 22 Sep 2026 20:11:19 +0800 Subject: [PATCH 387/584] RISC-V: Add test cases for vfwmul.vv reg overlap Add test cases for register group overlap, please note it is not overlap as much as possible. gcc/testsuite/ChangeLog: * gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-m1.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-m2.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-m4.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-mf2.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-mf4.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-m1.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-m2.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-m4.c: New test. * gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-mf2.c: New test. Signed-off-by: Pan Li --- .../autovec/group_overlap/vfwmul_vv-f16-m1.c | 17 +++++++++++++++++ .../autovec/group_overlap/vfwmul_vv-f16-m2.c | 17 +++++++++++++++++ .../autovec/group_overlap/vfwmul_vv-f16-m4.c | 17 +++++++++++++++++ .../autovec/group_overlap/vfwmul_vv-f16-mf2.c | 19 +++++++++++++++++++ .../autovec/group_overlap/vfwmul_vv-f16-mf4.c | 19 +++++++++++++++++++ .../autovec/group_overlap/vfwmul_vv-f32-m1.c | 17 +++++++++++++++++ .../autovec/group_overlap/vfwmul_vv-f32-m2.c | 17 +++++++++++++++++ .../autovec/group_overlap/vfwmul_vv-f32-m4.c | 17 +++++++++++++++++ .../autovec/group_overlap/vfwmul_vv-f32-mf2.c | 19 +++++++++++++++++++ 9 files changed, 159 insertions(+) create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-m1.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-m2.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-m4.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-mf2.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-mf4.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-m1.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-m2.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-m4.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-mf2.c diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-m1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-m1.c new file mode 100644 index 000000000000..483d1c2f848f --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-m1.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e16m1, + vfloat16m1_t, + vfloat32m2_t, + __riscv_vle16_v_f16m1, + __riscv_vfwmul_vv_f32m2, + __riscv_vse32_v_f32m2, + vfwmul_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X16) + +/* { dg-final { scan-assembler-times {vfwmul\.vv\s+v2,v1,v3([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwmul\.vv\s+v10,v11,v3([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-m2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-m2.c new file mode 100644 index 000000000000..0577ca21b782 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-m2.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e16m2, + vfloat16m2_t, + vfloat32m4_t, + __riscv_vle16_v_f16m2, + __riscv_vfwmul_vv_f32m4, + __riscv_vse32_v_f32m4, + vfwmul_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X8) + +/* { dg-final { scan-assembler-times {vfwmul\.vv\s+v8,v10,v6([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwmul\.vv\s+v28,v30,v24([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-m4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-m4.c new file mode 100644 index 000000000000..000ca99d4c57 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-m4.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e16m4, + vfloat16m4_t, + vfloat32m8_t, + __riscv_vle16_v_f16m4, + __riscv_vfwmul_vv_f32m8, + __riscv_vse32_v_f32m8, + vfwmul_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X4) + +/* { dg-final { scan-assembler-times {vfwmul\.vv\s+v8,v4,v12([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwmul\.vv\s+v24,v28,v16([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-mf2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-mf2.c new file mode 100644 index 000000000000..e2bea29f8403 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-mf2.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e16m1, + vfloat16mf2_t, + vfloat32m1_t, + __riscv_vle16_v_f16mf2, + __riscv_vfwmul_vv_f32m1, + __riscv_vse32_v_f32m1, + vfwmul_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X16) + +/* The fractional LMUL source has EMUL < 1, thus the widened destination + register group must not overlap either source at all. */ +/* { dg-final { scan-assembler-not {vfwmul\.vv\s+(v[0-9]+),\1,} } } */ +/* { dg-final { scan-assembler-not {vfwmul\.vv\s+(v[0-9]+),v[0-9]+,\1([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-mf4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-mf4.c new file mode 100644 index 000000000000..9be56d76b829 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-mf4.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv_zvfh -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e16m1, + vfloat16mf4_t, + vfloat32mf2_t, + __riscv_vle16_v_f16mf4, + __riscv_vfwmul_vv_f32mf2, + __riscv_vse32_v_f32mf2, + vfwmul_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X16) + +/* The fractional LMUL source has EMUL < 1, thus the widened destination + register group must not overlap either source at all. */ +/* { dg-final { scan-assembler-not {vfwmul\.vv\s+(v[0-9]+),\1,} } } */ +/* { dg-final { scan-assembler-not {vfwmul\.vv\s+(v[0-9]+),v[0-9]+,\1([^0-9]|$)} } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-m1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-m1.c new file mode 100644 index 000000000000..20a3d839d9f0 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-m1.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e32m1, + vfloat32m1_t, + vfloat64m2_t, + __riscv_vle32_v_f32m1, + __riscv_vfwmul_vv_f64m2, + __riscv_vse64_v_f64m2, + vfwmul_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X16) + +/* { dg-final { scan-assembler-times {vfwmul\.vv\s+v2,v1,v3([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwmul\.vv\s+v10,v11,v3([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-m2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-m2.c new file mode 100644 index 000000000000..0183ae2be203 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-m2.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e32m2, + vfloat32m2_t, + vfloat64m4_t, + __riscv_vle32_v_f32m2, + __riscv_vfwmul_vv_f64m4, + __riscv_vse64_v_f64m4, + vfwmul_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X8) + +/* { dg-final { scan-assembler-times {vfwmul\.vv\s+v8,v10,v6([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwmul\.vv\s+v28,v30,v24([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-m4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-m4.c new file mode 100644 index 000000000000..db73ccfc3463 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-m4.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e32m4, + vfloat32m4_t, + vfloat64m8_t, + __riscv_vle32_v_f32m4, + __riscv_vfwmul_vv_f64m8, + __riscv_vse64_v_f64m8, + vfwmul_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X4) + +/* { dg-final { scan-assembler-times {vfwmul\.vv\s+v8,v4,v12([^0-9]|$)} 1 } } */ +/* { dg-final { scan-assembler-times {vfwmul\.vv\s+v24,v28,v16([^0-9]|$)} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-mf2.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-mf2.c new file mode 100644 index 000000000000..33a73f0310b4 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-mf2.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d" } */ + +#include "group_overlap.h" + +DEF_GROUP_OVERLAP_BINARY_1( + __riscv_vsetvlmax_e32m1, + vfloat32mf2_t, + vfloat64m1_t, + __riscv_vle32_v_f32mf2, + __riscv_vfwmul_vv_f64m1, + __riscv_vse64_v_f64m1, + vfwmul_vv, + LOOP_DUAL_WIDEN_BINARY_BODY_X16) + +/* The fractional LMUL source has EMUL < 1, thus the widened destination + register group must not overlap either source at all. */ +/* { dg-final { scan-assembler-not {vfwmul\.vv\s+(v[0-9]+),\1,} } } */ +/* { dg-final { scan-assembler-not {vfwmul\.vv\s+(v[0-9]+),v[0-9]+,\1([^0-9]|$)} } } */ From d6ca7e8e1cf62734f0257cdc668da907cf3e0297 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Wed, 23 Sep 2026 15:46:30 +0200 Subject: [PATCH 388/584] tree-optimization/127571 - fix association of offset computation The expression was flagged by UBSAN, the following should match up the computations with the preceeding condition. PR tree-optimization/127571 * tree-ssa-sccvn.cc (vn_walk_cb_data::push_partial_def): Re-associate offset computation to avoid overflow. --- gcc/tree-ssa-sccvn.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/tree-ssa-sccvn.cc b/gcc/tree-ssa-sccvn.cc index 997a37a66476..c496ff93d11c 100644 --- a/gcc/tree-ssa-sccvn.cc +++ b/gcc/tree-ssa-sccvn.cc @@ -2081,7 +2081,7 @@ vn_walk_cb_data::push_partial_def (pd_data pd, pd.offset += o; } if (pd.size + pd.offset > offseti + maxsizei) - pd.size = maxsizei + ((pd.size + pd.offset - offseti - maxsizei) + pd.size = maxsizei + ((pd.size + pd.offset - (offseti + maxsizei)) % BITS_PER_UNIT); } From bbf9808d787eacf4464f2298d2f4265855b006bf Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Wed, 23 Sep 2026 11:04:39 +0200 Subject: [PATCH 389/584] account for SSE to integer move cost for vec_to_scalar vec_to_scalar costs a lane extraction which might be lane zero from a vector to a scalar. The following makes us account for the extra cost when the target is a GPR. I chose to not limit the testcase to any tuning/ISA, it shouldn't be vectorized for any combination. PR target/127268 * config/i386/i386.cc (ix86_default_vector_cost): For integer mode vec_to_scalar add sse_to_integer cost. * gcc.target/i386/vect-bb-reduc-1.c: New testcase. --- gcc/config/i386/i386.cc | 5 +++++ gcc/testsuite/gcc.target/i386/vect-bb-reduc-1.c | 13 +++++++++++++ 2 files changed, 18 insertions(+) create mode 100644 gcc/testsuite/gcc.target/i386/vect-bb-reduc-1.c diff --git a/gcc/config/i386/i386.cc b/gcc/config/i386/i386.cc index 705ebb6c014c..b09a5077820a 100644 --- a/gcc/config/i386/i386.cc +++ b/gcc/config/i386/i386.cc @@ -26045,7 +26045,12 @@ ix86_default_vector_cost (enum vect_cost_for_stmt type_of_cost, return COSTS_N_INSNS (ix86_cost->sse_store[index]) / 2; case vec_to_scalar: + /* This is a lane extraction, possibly from lane zero. */ + return (ix86_vec_cost (mode, ix86_cost->sse_op) + + (fp ? 0 : COSTS_N_INSNS (ix86_cost->sse_to_integer) / 2)); + case scalar_to_vec: + /* This is always a full splat from scalar, not a lane insertion. */ return ix86_vec_cost (mode, ix86_cost->sse_op); /* We should have separate costs for unaligned loads and gather/scatter. diff --git a/gcc/testsuite/gcc.target/i386/vect-bb-reduc-1.c b/gcc/testsuite/gcc.target/i386/vect-bb-reduc-1.c new file mode 100644 index 000000000000..c8efbb8c24f8 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/vect-bb-reduc-1.c @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ + +extern unsigned char *var1; +extern unsigned short var2; +void +func (void) +{ + var2 = var1[1] + var1[0]; +} + +/* We do not want to vectorize the reduction. */ +/* { dg-final { scan-assembler-not "xmm" } } */ From aaeeb8385b4e42811e7f3c8262b6e6e3151d7811 Mon Sep 17 00:00:00 2001 From: Uros Bizjak Date: Fri, 18 Sep 2026 10:23:01 +0200 Subject: [PATCH 390/584] doc: Fix node/menu order mismatch for Specific and Binaries chapters The @node next/prev pointers for the Installing GCC, Binaries and Specific chapters in install.texi did not match the order given in the top-level @menu, producing makeinfo warnings: node next pointer for `Installing GCC' is `Binaries' but next is `Specific' in menu node next/prev pointer for `Binaries' ... but ... in menu node next/prev pointer for `Specific' ... but ... in menu node prev pointer for `GNU Free Documentation License' is `Specific' but prev is `Binaries' in menu The @menu order (Installing GCC -> Specific -> Binaries -> GNU Free Documentation License) has been stable since the manual was first converted to Texinfo; the @node chain had drifted from it. Fix the @node pointers to match, and move the Binaries chapter to follow Specific in the file so the @iftex/PDF output, which lays out chapters in physical file order rather than following @node, agrees as well. Update the install-specific @node pointer for the GNU FDL appendix in fdl.texi to match; that pointer is gated on @ifset gfdlhtml, which only install.texi sets, so the change does not affect gcc.texi, gccint.texi, cppinternals.texi or any other manual that includes the same file. gcc/ * doc/install.texi (Installing GCC): Change node pointer from Binaries to Specific. (Specific): Move to directly follow Installing GCC. Update node pointers accordingly. (Binaries): Move to follow Specific. Update node pointers accordingly. * doc/include/fdl.texi (GNU Free Documentation License): Under @ifset gfdlhtml, change node pointer from Specific to Binaries to match install.texi's chapter order. --- gcc/doc/include/fdl.texi | 2 +- gcc/doc/install.texi | 133 +++++++++++++++++++-------------------- 2 files changed, 67 insertions(+), 68 deletions(-) diff --git a/gcc/doc/include/fdl.texi b/gcc/doc/include/fdl.texi index af1a9c1d1965..f45a74fe39ef 100644 --- a/gcc/doc/include/fdl.texi +++ b/gcc/doc/include/fdl.texi @@ -19,7 +19,7 @@ of this license document, but changing it is not allowed. @ifset gfdlhtml @ifnothtml @comment node-name, next, previous, up -@node GNU Free Documentation License, Concept Index, Specific, Top +@node GNU Free Documentation License, Concept Index, Binaries, Top @end ifnothtml @html

    Installing GCC: GNU Free Documentation License

    diff --git a/gcc/doc/install.texi b/gcc/doc/install.texi index 147f4f189522..21d1cdf91736 100644 --- a/gcc/doc/install.texi +++ b/gcc/doc/install.texi @@ -129,7 +129,7 @@ Free Documentation License}''. @c ***Installing GCC********************************************************** @ifnothtml @comment node-name, next, previous, up -@node Installing GCC, Binaries, , Top +@node Installing GCC, Specific, , Top @end ifnothtml @ifset indexhtml @ifnothtml @@ -3873,75 +3873,10 @@ If you find a bug, please report it following the @end ifhtml @end ifset -@c ***Binaries**************************************************************** -@ifnothtml -@comment node-name, next, previous, up -@node Binaries, Specific, Installing GCC, Top -@end ifnothtml -@ifset binarieshtml -@ifnothtml -@chapter Installing GCC: Binaries -@end ifnothtml -@cindex Binaries -@cindex Installing GCC: Binaries - -We are often asked about pre-compiled versions of GCC@. While we cannot -provide these for all platforms, below you'll find links to binaries for -various platforms where creating them by yourself is not easy due to various -reasons. - -Please note that we did not create these binaries, nor do we -support them. If you have any problems installing them, please -contact their makers. - -@itemize -@item -AIX: -@itemize -@item -@uref{http://www.perzl.org/aix/,,AIX Open Source Packages (AIX5L AIX 6.1 -AIX 7.1)}. -@end itemize - -@item -DOS---@uref{https://www.delorie.com/djgpp/,,DJGPP}. - -@item -macOS: -@itemize -@item -The @uref{https://brew.sh,,Homebrew} package manager; -@item -@uref{https://www.macports.org,,MacPorts}. -@end itemize - -@item -Microsoft Windows: -@itemize -@item -The @uref{https://sourceware.org/cygwin/,,Cygwin} project; -@item -the @uref{https://www.mingw-w64.org/,,mingw-w64} project. -@end itemize - -@item -The @uref{https://gcc.gnu.org/wiki/GFortranBinaries,,GFortran Wiki} has -links to GNU Fortran binaries for several platforms. -@end itemize - -@html -
    -

    -@end html -@ifhtml -@uref{./index.html,,Return to the GCC Installation page} -@end ifhtml -@end ifset - @c ***Specific**************************************************************** @ifnothtml @comment node-name, next, previous, up -@node Specific, GNU Free Documentation License, Binaries, Top +@node Specific, Binaries, Installing GCC, Top @end ifnothtml @ifset specifichtml @ifnothtml @@ -5312,6 +5247,70 @@ GNU linker; duplicate copies of inlines, vtables and template instantiations will be discarded automatically. +@html +

    +

    +@end html +@ifhtml +@uref{./index.html,,Return to the GCC Installation page} +@end ifhtml +@end ifset + +@c ***Binaries**************************************************************** +@ifnothtml +@comment node-name, next, previous, up +@node Binaries, GNU Free Documentation License, Specific, Top +@end ifnothtml +@ifset binarieshtml +@ifnothtml +@chapter Installing GCC: Binaries +@end ifnothtml +@cindex Binaries +@cindex Installing GCC: Binaries + +We are often asked about pre-compiled versions of GCC@. While we cannot +provide these for all platforms, below you'll find links to binaries for +various platforms where creating them by yourself is not easy due to various +reasons. + +Please note that we did not create these binaries, nor do we +support them. If you have any problems installing them, please +contact their makers. + +@itemize +@item +AIX: +@itemize +@item +@uref{http://www.perzl.org/aix/,,AIX Open Source Packages (AIX5L AIX 6.1 +AIX 7.1)}. +@end itemize + +@item +DOS---@uref{https://www.delorie.com/djgpp/,,DJGPP}. + +@item +macOS: +@itemize +@item +The @uref{https://brew.sh,,Homebrew} package manager; +@item +@uref{https://www.macports.org,,MacPorts}. +@end itemize + +@item +Microsoft Windows: +@itemize +@item +The @uref{https://sourceware.org/cygwin/,,Cygwin} project; +@item +the @uref{https://www.mingw-w64.org/,,mingw-w64} project. +@end itemize + +@item +The @uref{https://gcc.gnu.org/wiki/GFortranBinaries,,GFortran Wiki} has +links to GNU Fortran binaries for several platforms. +@end itemize @html

    From 65f27f5a1562300f72b0fe8cfd65e7901f528763 Mon Sep 17 00:00:00 2001 From: Kyrylo Tkachov Date: Tue, 22 Sep 2026 11:33:26 +0200 Subject: [PATCH 391/584] i386: Avoid duplicate ENDBR Different switch tables can reach the same case block. The CET pass inserts an ENDBR for each table, although the destination needs only one. This also affects dispatches that share a table. Reuse an existing ENDBR after the destination label. [ ubizjak: Use GET_CODE/XINT, adjust ChangeLog ] Assisted-by: OpenAI Codex 5.6 Sol gcc/ChangeLog: * config/i386/i386-features.cc (rest_of_insert_endbr_and_patchable_area): Reuse an existing ENDBR. gcc/testsuite/ChangeLog: * gcc.target/i386/cet-switch-4.c: New test. Signed-off-by: Kyrylo Tkachov Signed-off-by: Uros Bizjak --- gcc/config/i386/i386-features.cc | 8 +++ gcc/testsuite/gcc.target/i386/cet-switch-4.c | 56 ++++++++++++++++++++ 2 files changed, 64 insertions(+) create mode 100644 gcc/testsuite/gcc.target/i386/cet-switch-4.c diff --git a/gcc/config/i386/i386-features.cc b/gcc/config/i386/i386-features.cc index 1d26aa0c3362..f95bc41fb479 100644 --- a/gcc/config/i386/i386-features.cc +++ b/gcc/config/i386/i386-features.cc @@ -3274,6 +3274,14 @@ rest_of_insert_endbr_and_patchable_area (bool need_endbr, dest_blk = e->dest; insn = BB_HEAD (dest_blk); gcc_assert (LABEL_P (insn)); + + /* Reuse existing ENDBR. */ + rtx_insn *next = next_nonnote_nondebug_insn (insn); + if (next && NONJUMP_INSN_P (next) + && GET_CODE (PATTERN (next)) == UNSPEC_VOLATILE + && XINT (PATTERN (next), 1) == UNSPECV_NOP_ENDBR) + continue; + endbr = gen_nop_endbr (); emit_insn_after (endbr, insn); } diff --git a/gcc/testsuite/gcc.target/i386/cet-switch-4.c b/gcc/testsuite/gcc.target/i386/cet-switch-4.c new file mode 100644 index 000000000000..53cb960f0d56 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/cet-switch-4.c @@ -0,0 +1,56 @@ +/* PR middle-end/126236 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -fcf-protection=branch -mcet-switch -fno-pie -fno-pic" } */ +/* { dg-final { scan-assembler-times "endbr32" 9 { target ia32 } } } */ +/* { dg-final { scan-assembler-times "endbr64" 9 { target { ! ia32 } } } } */ +/* { dg-final { scan-assembler-times "\[ \t]+jmp\[ \t]+\[*]" 2 } } */ + +/* Both tables reach the same eight destinations. */ + +void f0 (void); +void f1 (void); +void f2 (void); +void f3 (void); +void f4 (void); +void f5 (void); +void f6 (void); +void f7 (void); + +void +foo (unsigned x, int which) +{ + if (which) + switch (x) + { + case 0: goto a; + case 1: goto b; + case 2: goto c; + case 3: goto d; + case 4: goto e; + case 5: goto f; + case 6: goto g; + case 7: goto h; + default: return; + } + else + switch (x) + { + case 0: goto h; + case 1: goto g; + case 2: goto f; + case 3: goto e; + case 4: goto d; + case 5: goto c; + case 6: goto b; + case 7: goto a; + default: return; + } +a: f0 (); return; +b: f1 (); return; +c: f2 (); return; +d: f3 (); return; +e: f4 (); return; +f: f5 (); return; +g: f6 (); return; +h: f7 (); return; +} From 2b7ddfb841114b2783f0b3420fcb96e7687484d9 Mon Sep 17 00:00:00 2001 From: Tamar Christina Date: Thu, 24 Sep 2026 10:03:51 +0100 Subject: [PATCH 392/584] vect: fix emulated vector costing [PR127579] The testcase char a; int b; void e() { char *c = (char *)&b; int d = 0; for (; d < b; d++) a += c[d]; } ICEs with -O2 -mgeneral-regs-only -march=armv9-a with a segfault in single cycle detection: internal compiler error: Segmentation fault // 446 | ff_layout_alloc_lseg(struct pnfs_layout_hdr *lh, // | ^~~~~~~~~~~~~~~~~~~~ // 0xf3fc23 internal_error(char const*, ...) // ../../src/gcc/diagnostic-global-context.cc:787 // 0x976543 crash_signal // ../../src/gcc/toplev.cc:325 // 0x1e43f74 info_for_reduction(_loop_vec_info*, _slp_tree*) // ../../src/gcc/tree-vect-loop.cc:5060 // 0x1a7946f aarch64_force_single_cycle // ../../src/gcc/config/aarch64/aarch64.cc:18284 This is because the slp_node is null and so looking up the reduction info fails. With -mgeneral-regs the SIMD reduction instructions become unavailable, so the vectorizer tries to emulate them. This enters a branch in vectorizable_operation where it looks like we forgot to update the costing code from using stmt_vinfo to the slp_node during the SLP only costing transition. As such it uses the old interface which does not provide the required SLP node and we ICE. The fix is to use the slp_node instead of the stmt_info. gcc/ChangeLog: PR tree-optimization/127579 * tree-vect-loop.cc (info_for_reduction): Add assert. * tree-vect-stmts.cc (vectorizable_operation): Pass SLP node. gcc/testsuite/ChangeLog: PR tree-optimization/127579 * gcc.target/aarch64/pr127579.c: New test. --- gcc/testsuite/gcc.target/aarch64/pr127579.c | 11 +++++++++++ gcc/tree-vect-loop.cc | 1 + gcc/tree-vect-stmts.cc | 4 ++-- 3 files changed, 14 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/gcc.target/aarch64/pr127579.c diff --git a/gcc/testsuite/gcc.target/aarch64/pr127579.c b/gcc/testsuite/gcc.target/aarch64/pr127579.c new file mode 100644 index 000000000000..1f9eb6af741c --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/pr127579.c @@ -0,0 +1,11 @@ +/* { dg-do compile } */ +/* { dg-additional-options "-O2 -mgeneral-regs-only -march=armv9-a" } */ + +char a; +int b; +void e() { + char *c = (char *)&b; + int d = 0; + for (; d < b; d++) + a += c[d]; +} diff --git a/gcc/tree-vect-loop.cc b/gcc/tree-vect-loop.cc index e724a8f6086e..99dda5b1e005 100644 --- a/gcc/tree-vect-loop.cc +++ b/gcc/tree-vect-loop.cc @@ -5041,6 +5041,7 @@ get_initial_defs_for_reduction (loop_vec_info loop_vinfo, vect_reduc_info info_for_reduction (loop_vec_info loop_vinfo, slp_tree node) { + gcc_assert (node); if (node->cycle_info.id == -1) return NULL; return loop_vinfo->reduc_infos[node->cycle_info.id]; diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc index 9cfec1bb4ac5..69e1bdc2cac7 100644 --- a/gcc/tree-vect-stmts.cc +++ b/gcc/tree-vect-stmts.cc @@ -6883,9 +6883,9 @@ vectorizable_operation (vec_info *vinfo, if (n != 0) { /* We also need to materialize two large constants. */ - record_stmt_cost (cost_vec, 2, scalar_stmt, stmt_info, + record_stmt_cost (cost_vec, 2, scalar_stmt, slp_node, 0, vect_prologue); - record_stmt_cost (cost_vec, n, scalar_stmt, stmt_info, + record_stmt_cost (cost_vec, n, scalar_stmt, slp_node, 0, vect_body); } } From 4024e780b14853d614dfd9ed002b04fc88cb75f9 Mon Sep 17 00:00:00 2001 From: Andrew Stubbs Date: Mon, 21 Sep 2026 16:45:14 +0000 Subject: [PATCH 393/584] amdgcn: fix vector popcount (PR127542) The vector version of the popcount insn (v_bcnt) lacked the third parameter (the scalar insn was fine). gcc/ChangeLog: PR target/127542 * config/gcn/gcn-valu.md (2): Add "popcount_extra_op". --- gcc/config/gcn/gcn-valu.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/config/gcn/gcn-valu.md b/gcc/config/gcn/gcn-valu.md index 4764c34ff89f..32021d263cc9 100644 --- a/gcc/config/gcn/gcn-valu.md +++ b/gcc/config/gcn/gcn-valu.md @@ -2789,7 +2789,7 @@ (bitunop:V_INT_1REG (match_operand:V_INT_1REG 1 "gcn_valu_src0_operand" "vSvB")))] "" - "v_0\t%0, %1" + "v_0\t%0, %1" [(set_attr "type" "vop1") (set_attr "length" "8")]) From 04106ce784babdaa721bc1f1cabcdf6f44f45efb Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Thu, 24 Sep 2026 12:28:48 +0200 Subject: [PATCH 394/584] libgomp: Check for overflows in some cases Given the https://gcc.gnu.org/pipermail/libstdc++/2026-September/067867.html changes, I had a brief look at gomp_aligned_alloc and omp_aligned_{,c}alloc. At least when alignment is power of two, omp_aligned* seems to perform all the overflow checking they should I think. gomp_aligned_alloc is used internally, if it uses posix_memalign or memalign, it relies on libc performing overflow checking, for the aligned_alloc case it already performs overflow checking itself. Given the above libstdc++ change, seems at least Mingw _aligned_alloc performs no overflow checking, so this patch adds overflow checking for it (but relies on NULL/EINVAL if al is not a power of two from Mingw/Win). And for the fallback also adds overflow checking. 2026-09-23 Jakub Jelinek * alloc.c (gomp_aligned_alloc): Check for overflows in the _aligned_malloc case and in the last fallback. --- libgomp/alloc.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/libgomp/alloc.c b/libgomp/alloc.c index 47ff605660f2..34ece6248465 100644 --- a/libgomp/alloc.c +++ b/libgomp/alloc.c @@ -82,12 +82,22 @@ gomp_aligned_alloc (size_t al, size_t size) ret = NULL; } #elif defined(HAVE__ALIGNED_MALLOC) - ret = _aligned_malloc (size, al); + /* Mingw64 doesn't perform overflow checking, so do it ourselves. + It does power of two checking though. */ + if (__builtin_add_overflow_p (size, al + 2 * sizeof (void *), (size_t) 0)) + ret = NULL; + else + ret = _aligned_malloc (size, al); #else ret = NULL; if ((al & (al - 1)) == 0 && size) { - void *p = malloc (size + al); + void *p; + size_t sz; + if (__builtin_add_overflow (size, al, &sz)) + p = NULL; + else + p = malloc (sz); if (p) { void *ap = (void *) (((uintptr_t) p + al) & -al); From 416290b10bb9cb45361630b61af09200962bd5a5 Mon Sep 17 00:00:00 2001 From: Josef Melcr Date: Thu, 24 Sep 2026 11:16:00 +0200 Subject: [PATCH 395/584] Clean up old code in callback_only attribute handler This patch cleans up two useless loops from the callback_only attribute handler. The first loop used to check for void_list_node, now it does literally nothing. Seems like I forgot to remove it when I changed the validation logic a few weeks ago. The second loop also checks for void_list_node and decrements type_nargs if it finds it, but since we ensure !stdarg_p for both the carrying and the callback function, looking for void_list_node again is pointless. In this case, we can just initialize type_nargs differently. gcc/c-family/ChangeLog: * c-attribs.cc (handle_callback_only_attribute): Clean up old code. Signed-off-by: Josef Melcr --- gcc/c-family/c-attribs.cc | 14 ++------------ 1 file changed, 2 insertions(+), 12 deletions(-) diff --git a/gcc/c-family/c-attribs.cc b/gcc/c-family/c-attribs.cc index 3c0e780669b4..0e2e17cc0bec 100644 --- a/gcc/c-family/c-attribs.cc +++ b/gcc/c-family/c-attribs.cc @@ -4709,10 +4709,6 @@ handle_callback_only_attribute (tree *node, tree name, tree args, DECL_ARGUMENTS returns NULL at this point. */ int callback_fn_idx = TREE_INT_CST_LOW (val); tree decl_type_args = TYPE_ARG_TYPES (decl_type); - tree it; - for (it = decl_type_args; it != NULL_TREE; it = TREE_CHAIN (it)) - if (it == void_list_node) - break; if (callback_fn_idx == CB_UNKNOWN_POS) { @@ -4754,13 +4750,7 @@ handle_callback_only_attribute (tree *node, tree name, tree args, /* Compare the length of the list of argument indices and the real number of parameters the callback takes. */ unsigned cfn_nargs = list_length (TREE_CHAIN (args)); - unsigned type_nargs = list_length (type_args); - for (it = type_args; it != NULL_TREE; it = TREE_CHAIN (it)) - if (it == void_list_node) - { - --type_nargs; - break; - } + unsigned type_nargs = list_length (type_args) - 1; if (cfn_nargs != type_nargs) { warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wattributes, @@ -4771,7 +4761,7 @@ handle_callback_only_attribute (tree *node, tree name, tree args, } unsigned curr = 0; - tree cfn_it; + tree it, cfn_it; /* Validate type compatibility of the arguments passed from caller function to callback. "it" is used to step through the parameters of the caller, "cfn_it" is From c13b8e6373844f708fd4e40bbe1ec6f78b61c91b Mon Sep 17 00:00:00 2001 From: Andrew Stubbs Date: Fri, 26 Jun 2026 14:40:50 +0000 Subject: [PATCH 396/584] Improved GDB RTX printing hooks Adds new features to the GDB Python script that prints GCC internals. - Improved output for rtx_def types. - Also enable printing for rtx, const_rtx, rtx_insn, etc. - Add icode details for rtx_insn. - Add register details for REG nodes. Examples: gcc/ChangeLog: * gdbhooks.py (Rtx): Decode more things. (RtxPrinter): Improve output. (build_pretty_printer): Match more rtx types. --- gcc/gdbhooks.py | 76 +++++++++++++++++++++++++++++++++---------------- 1 file changed, 51 insertions(+), 25 deletions(-) diff --git a/gcc/gdbhooks.py b/gcc/gdbhooks.py index 616fc605f620..a2dfb707abad 100644 --- a/gcc/gdbhooks.py +++ b/gcc/gdbhooks.py @@ -92,15 +92,20 @@ For usability, the type is printed first (e.g. "function_decl"), rather than just "tree". -RTL expressions use a kludge: they are pretty-printed by injecting -calls into print-rtl.c into the inferior: - Value returned is $1 = (note 9 8 10 [bb 3] NOTE_INSN_BASIC_BLOCK) - (gdb) p $1 - $2 = (note 9 8 10 [bb 3] NOTE_INSN_BASIC_BLOCK) - (gdb) p /r $1 - $3 = (rtx_def *) 0x7ffff043e140 -This won't work for coredumps, and probably in other circumstances, but -it's a quick way of getting lots of debuggability quickly. +RTL expressions show at least the rtx code in parenthesis: + (gdb) p pattern + $11 = +Insns show the unique number and machine description name, if an icode is +recorded ("" otherwise): + (gdb) p insn + $12 = )> + (gdb) p insn + $17 = +Registers show the mode, number, and either the hardreg name or "pseudo": + (gdb) p x + $13 = +For all other cases, use "pp x" to print full RTL expressions via the print-rtl.c +routines (not available for coredumps). Callgraph nodes are printed with the name of the function decl, if available: @@ -423,6 +428,9 @@ def __init__(self, gdbval): def GET_CODE(self): return self.gdbval['code'] + def XINT(self, n): + return self.gdbval['u']['fld'][n]['rt_int'] + def GET_RTX_LENGTH(code): val_rtx_length = gdb.parse_and_eval('rtx_length') return intptr(val_rtx_length[code]) @@ -435,30 +443,44 @@ def GET_RTX_FORMAT(code): val_rtx_format = gdb.parse_and_eval('rtx_format') return val_rtx_format[code].string() +def get_insn_name(icode): + return gdb.parse_and_eval('insn_data')[icode]['name'].string() + +def reg_name(regno): + try: + val_reg_names = gdb.parse_and_eval('this_target_hard_regs->x_reg_names') + except: + val_reg_names = gdb.parse_and_eval('default_target_hard_regs.x_reg_names') + try: + return val_reg_names[regno].string() + except: + return "pseudo" + +def mode_name(mode): + return gdb.parse_and_eval('mode_name')[mode].string() + class RtxPrinter: def __init__(self, gdbval): self.gdbval = gdbval self.rtx = Rtx(gdbval) def to_string (self): - """ - For now, a cheap kludge: invoke the inferior's print - function to get a string to use the user, and return an empty - string for gdb - """ - # We use print_inline_rtx to avoid a trailing newline - gdb.execute('call print_inline_rtx (stderr, (const_rtx) %s, 0)' - % intptr(self.gdbval)) - return '' - - # or by hand; based on gcc/print-rtl.c:print_rtx result = (' \*', From 9c6ee752512630e7418901a321f5de47382d81c2 Mon Sep 17 00:00:00 2001 From: Paul-Antoine Arras Date: Thu, 24 Sep 2026 11:46:49 +0200 Subject: [PATCH 397/584] openmp: Pretty-print OMP_ITERATOR_BLOCK Add OMP_ITERATOR_BLOCK to dump_omp_iterators, only when TDF_DETAILS is set. gcc/ChangeLog: * tree-pretty-print.cc (dump_omp_iterators): Print OMP_ITERATOR_BLOCK. --- gcc/tree-pretty-print.cc | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/gcc/tree-pretty-print.cc b/gcc/tree-pretty-print.cc index 89fe93a1f6dc..f2718d03a4dc 100644 --- a/gcc/tree-pretty-print.cc +++ b/gcc/tree-pretty-print.cc @@ -448,6 +448,16 @@ dump_omp_iterators (pretty_printer *pp, tree iter, int spc, dump_flags_t flags) pp_colon (pp); dump_generic_node (pp, OMP_ITERATOR_STEP (it), spc, flags, false); } + if (flags & TDF_DETAILS && OMP_ITERATOR_BLOCK (iter)) + { + pp_string (pp, ", block="); + pp_left_brace (pp); + newline_and_indent (pp, spc + 2); + dump_generic_node (pp, BLOCK_SUBBLOCKS (OMP_ITERATOR_BLOCK (iter)), + spc + 2, flags, true); + newline_and_indent (pp, spc); + pp_right_brace (pp); + } if (OMP_ITERATOR_EXPANDED_P (iter)) { pp_string (pp, ", loop_label="); From cb9d160c4dab693a3fc214736db2441ebbee6c35 Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Thu, 24 Sep 2026 18:42:28 +0200 Subject: [PATCH 398/584] middle-end: Fix up C++26 P2795R5 - Erroneous behavior for uninitialized reads [PR126848] As the following new testcases show, I've messed up the C++26 P2795R5 - Erroneous behavior for uninitialized reads implementation. What the paper requires for C++26 and later (unless user opts out of it with -ftrivial-auto-var-init=uninitialized, which effectively pretends everything that accepts [[indeterminate]] attribute has that attribute) is that multiple reads of the same uninitialized variable yield the same value (whatever it is) and as QoI that such uses are diagnosed with -Wuninitialized or -Wmaybe-uninitialized. The implementation implemented it as a new mode (not directly requestable by users using an option) of -ftrivial-auto-var-init= (the new mode used just for the case where -ftrivial-auto-var-init={zero,pattern} isn't used), with extra code in the FE to deal with vacuous initialization in switch bodies etc. for C++26 and some small changes during gimplification for the new AUTO_INIT_CXX26 mode. On various testcases it worked fine, but this bugreport shows that in the middle-end optimizations we actually need to treat it differently. In order to fullfill the C++26 requirements, we can't treat .DEFERRED_INIT for C++26 and later as something returning something uninitialized where optimizations happily optimize say a PHI with such uninitialized value and some other value as that other value, or some passes consider the result as UNDEFINED rather than VARYING. There is an option to come up with a different internal function for these C++26 uses of .DEFERRED_INIT, but because it has also many similarities with .DEFERRED_INIT (e.g. same expansion) and because the internal function already has an argument which is the flag_trivial_auto_var_init value, this patch just changes AUTO_INIT_CXX26 value from 3 to 4 so that it can be used as a mask, so now we have 6 different modes: AUTO_INIT_UNINITIALIZED (the default for non-C++ or C++ < 26) AUTO_INIT_ZERO (-ftrivial-auto-var-init=zero for non-C++ or C++ < 26) AUTO_INIT_PATTERN (-ftrivial-auto-var-init=pattern for non-C++ or C++ < 26) AUTO_INIT_CXX26 (the default for C++ >= 26) AUTO_INIT_ZERO | AUTO_INIT_CXX26 (-ftrivial-auto-var-init=zero for C++ >= 26) AUTO_INIT_PATTERN | AUTO_INIT_CXX26 (-ftrivial-auto-var-init=pattern for C++ >= 26) The option handling ensures to or in AUTO_INIT_CXX26 for C++26/29 unless -ftrivial-auto-var-init=uninitialized is used explicitly, and the ccp pass and ssa_undefined_value_p is changed so that it treats the AUTO_INIT_CXX26 modes of .DEFERRED_INIT differently (basically as a source of VARYING value). Because the uninit pass uses ssa_undefined_value_p, I had to change also has_undefined_value_p because for -Wuninitialized purposes we want to treat all .DEFERRED_INIT calls the same. 2026-09-24 Jakub Jelinek PR c++/126848 gcc/ * flag-types.h (enum auto_init_type): Change AUTO_INIT_CXX26 value from 3 to 4. * gimplify.cc (gimplify_decl_expr): Mask off AUTO_INIT_CXX26 bit before comparing to AUTO_INIT_PATTERN. (gimplify_target_expr): Likewise. * internal-fn.cc (expand_DEFERRED_INIT): Likewise. Formatting fix. * opts.cc (finish_options): For -fhardened or in AUTO_INIT_CXX26 bit from previous value if it was set. Mask off AUTO_INIT_CXX26 bit before comparing to AUTO_INIT_ZERO. * tree-ssa-ccp.cc (likely_value): Return VARYING rather than UNDEFINED for .DEFERRED_INIT call with AUTO_INIT_CXX26 bit set in the second argument. * tree-ssa.cc (ssa_undefined_value_p): Return false rather than true for .DEFERRED_INIT call with AUTO_INIT_CXX26 bit set in the second argument. * tree-ssa-uninit.cc (has_undefined_value_p): Return true for SSA_NAMEs with .DEFERRED_INIT call as SSA_NAME_DEF_STMT. gcc/c-family/ * c-opts.cc (c_common_post_options): For -ftrivial-auto-var-init=zero or -ftrivial-auto-var-init=pattern in C++26 or later mode set AUTO_INIT_CXX26 bit in flag_auto_var_init. gcc/testsuite/ * c-c++-common/auto-init-1.c: Use [15] instead of 1 or [26] instead of 2 in regexps matching second .DEFERRED_INIT arguments. * c-c++-common/auto-init-2.c: Likewise. * c-c++-common/auto-init-3.c: Likewise. * c-c++-common/auto-init-4.c: Likewise. * c-c++-common/auto-init-5.c: Likewise. * c-c++-common/auto-init-6.c: Likewise. * c-c++-common/auto-init-7.c: Likewise. * c-c++-common/auto-init-8.c: Likewise. * c-c++-common/auto-init-9.c: Likewise. * c-c++-common/auto-init-10.c: Likewise. * c-c++-common/auto-init-11.c: Likewise. * c-c++-common/auto-init-12.c: Likewise. * c-c++-common/auto-init-13.c: Likewise. * c-c++-common/auto-init-14.c: Likewise. * c-c++-common/auto-init-15.c: Likewise. * c-c++-common/auto-init-16.c: Likewise. * c-c++-common/auto-init-esra.c: Likewise. * c-c++-common/auto-init-padding-1.c: Likewise. * g++.dg/cpp26/erroneous7.C: New test. * g++.dg/cpp26/erroneous8.C: New test. * g++.dg/cpp26/erroneous9.C: New test. Reviewed-by: Richard Biener Reviewed-by: Jason Merrill --- gcc/c-family/c-opts.cc | 9 +++++++-- gcc/flag-types.h | 2 +- gcc/gimplify.cc | 4 ++-- gcc/internal-fn.cc | 10 +++++----- gcc/opts.cc | 6 ++++-- gcc/testsuite/c-c++-common/auto-init-1.c | 20 +++++++++---------- gcc/testsuite/c-c++-common/auto-init-10.c | 2 +- gcc/testsuite/c-c++-common/auto-init-11.c | 2 +- gcc/testsuite/c-c++-common/auto-init-12.c | 2 +- gcc/testsuite/c-c++-common/auto-init-13.c | 4 ++-- gcc/testsuite/c-c++-common/auto-init-14.c | 4 ++-- gcc/testsuite/c-c++-common/auto-init-15.c | 2 +- gcc/testsuite/c-c++-common/auto-init-16.c | 2 +- gcc/testsuite/c-c++-common/auto-init-2.c | 20 +++++++++---------- gcc/testsuite/c-c++-common/auto-init-3.c | 6 +++--- gcc/testsuite/c-c++-common/auto-init-4.c | 6 +++--- gcc/testsuite/c-c++-common/auto-init-5.c | 6 +++--- gcc/testsuite/c-c++-common/auto-init-6.c | 6 +++--- gcc/testsuite/c-c++-common/auto-init-7.c | 8 ++++---- gcc/testsuite/c-c++-common/auto-init-8.c | 8 ++++---- gcc/testsuite/c-c++-common/auto-init-9.c | 4 ++-- gcc/testsuite/c-c++-common/auto-init-esra.c | 4 ++-- .../c-c++-common/auto-init-padding-1.c | 2 +- gcc/testsuite/g++.dg/cpp26/erroneous7.C | 20 +++++++++++++++++++ gcc/testsuite/g++.dg/cpp26/erroneous8.C | 19 ++++++++++++++++++ gcc/testsuite/g++.dg/cpp26/erroneous9.C | 19 ++++++++++++++++++ gcc/tree-ssa-ccp.cc | 11 ++++++++-- gcc/tree-ssa-uninit.cc | 1 + gcc/tree-ssa.cc | 10 ++++++++-- 29 files changed, 149 insertions(+), 70 deletions(-) create mode 100644 gcc/testsuite/g++.dg/cpp26/erroneous7.C create mode 100644 gcc/testsuite/g++.dg/cpp26/erroneous8.C create mode 100644 gcc/testsuite/g++.dg/cpp26/erroneous9.C diff --git a/gcc/c-family/c-opts.cc b/gcc/c-family/c-opts.cc index 0e2d8bdcfdd7..d27cf3fa6d5f 100644 --- a/gcc/c-family/c-opts.cc +++ b/gcc/c-family/c-opts.cc @@ -925,8 +925,13 @@ c_common_post_options (const char **pfilename) flag_permitted_flt_eval_methods = PERMITTED_FLT_EVAL_METHODS_C11; if (cxx_dialect >= cxx26) - SET_OPTION_IF_UNSET (&global_options, &global_options_set, - flag_auto_var_init, AUTO_INIT_CXX26); + { + SET_OPTION_IF_UNSET (&global_options, &global_options_set, + flag_auto_var_init, AUTO_INIT_CXX26); + if (flag_auto_var_init > AUTO_INIT_UNINITIALIZED) + flag_auto_var_init + = auto_init_type (flag_auto_var_init | AUTO_INIT_CXX26); + } /* The -Wtrivial-auto-var-init warning is useless for C++, where we always add .DEFERRED_INIT calls when some (vacuous) initializers are bypassed diff --git a/gcc/flag-types.h b/gcc/flag-types.h index df983d9d947f..e14dd36707a6 100644 --- a/gcc/flag-types.h +++ b/gcc/flag-types.h @@ -289,7 +289,7 @@ enum auto_init_type { AUTO_INIT_UNINITIALIZED = 0, AUTO_INIT_PATTERN = 1, AUTO_INIT_ZERO = 2, - AUTO_INIT_CXX26 = 3 + AUTO_INIT_CXX26 = 4 }; /* Initialization of padding bits with zeros. */ diff --git a/gcc/gimplify.cc b/gcc/gimplify.cc index 0f8bf533ba75..19cabec33a81 100644 --- a/gcc/gimplify.cc +++ b/gcc/gimplify.cc @@ -2113,7 +2113,7 @@ gimplify_decl_expr (tree *stmt_p, gimple_seq *seq_p) since __builtin_clear_padding will take the address of the variable. As a result, if a long double/_Complex long double variable will spilled into stack later, its padding is 0XFE. */ - if (flag_auto_var_init == AUTO_INIT_PATTERN + if ((flag_auto_var_init & ~AUTO_INIT_CXX26) == AUTO_INIT_PATTERN && !is_gimple_reg (decl) && clear_padding_type_may_have_padding_p (TREE_TYPE (decl))) gimple_add_padding_init_for_auto_var (decl, is_vla, seq_p); @@ -8478,7 +8478,7 @@ gimplify_target_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p) if (var_needs_auto_init_p (temp) && VOID_TYPE_P (TREE_TYPE (init))) { gimple_add_init_for_auto_var (temp, flag_auto_var_init, &init_pre_p); - if (flag_auto_var_init == AUTO_INIT_PATTERN + if ((flag_auto_var_init & ~AUTO_INIT_CXX26) == AUTO_INIT_PATTERN && !is_gimple_reg (temp) && clear_padding_type_may_have_padding_p (TREE_TYPE (temp))) gimple_add_padding_init_for_auto_var (temp, is_vla, &init_pre_p); diff --git a/gcc/internal-fn.cc b/gcc/internal-fn.cc index 9bfca87588b3..597ccaeb9fef 100644 --- a/gcc/internal-fn.cc +++ b/gcc/internal-fn.cc @@ -3527,7 +3527,7 @@ expand_DEFERRED_INIT (internal_fn, gcall *stmt) mark_addressable (lhs); tree var_addr = build_fold_addr_expr (lhs); - tree value = (init_type == AUTO_INIT_PATTERN) + tree value = ((init_type & ~AUTO_INIT_CXX26) == AUTO_INIT_PATTERN) ? build_int_cst (integer_type_node, INIT_PATTERN_VALUE) : integer_zero_node; @@ -3544,7 +3544,7 @@ expand_DEFERRED_INIT (internal_fn, gcall *stmt) scalar_int_mode var_mode; if (TREE_CODE (TREE_TYPE (lhs)) != BOOLEAN_TYPE && tree_fits_uhwi_p (var_size) - && (init_type == AUTO_INIT_PATTERN + && ((init_type & ~AUTO_INIT_CXX26) == AUTO_INIT_PATTERN || !is_gimple_reg_type (var_type)) && int_mode_for_size (tree_to_uhwi (var_size) * BITS_PER_UNIT, 0).exists (&var_mode) @@ -3552,10 +3552,10 @@ expand_DEFERRED_INIT (internal_fn, gcall *stmt) { unsigned HOST_WIDE_INT total_bytes = tree_to_uhwi (var_size); unsigned char *buf = XALLOCAVEC (unsigned char, total_bytes); - memset (buf, (init_type == AUTO_INIT_PATTERN + memset (buf, ((init_type & ~AUTO_INIT_CXX26) == AUTO_INIT_PATTERN ? INIT_PATTERN_VALUE : 0), total_bytes); - tree itype = build_nonstandard_integer_type - (total_bytes * BITS_PER_UNIT, 1); + tree itype + = build_nonstandard_integer_type (total_bytes * BITS_PER_UNIT, 1); wide_int w = wi::from_buffer (buf, total_bytes); init = wide_int_to_tree (itype, w); /* Pun the LHS to make sure its type has constant size diff --git a/gcc/opts.cc b/gcc/opts.cc index 8048264b6099..21a773f8da75 100644 --- a/gcc/opts.cc +++ b/gcc/opts.cc @@ -1164,8 +1164,10 @@ finish_options (struct gcc_options *opts, struct gcc_options *opts_set, if (opts->x_flag_hardened) { if (!opts_set->x_flag_auto_var_init) - opts->x_flag_auto_var_init = AUTO_INIT_ZERO; - else if (opts->x_flag_auto_var_init != AUTO_INIT_ZERO) + opts->x_flag_auto_var_init + = auto_init_type (opts->x_flag_auto_var_init | AUTO_INIT_ZERO); + else if ((opts->x_flag_auto_var_init & ~AUTO_INIT_CXX26) + != AUTO_INIT_ZERO) warning_at (loc, OPT_Whardened, "%<-ftrivial-auto-var-init=zero%> is not enabled by " "%<-fhardened%> because it was specified on the command " diff --git a/gcc/testsuite/c-c++-common/auto-init-1.c b/gcc/testsuite/c-c++-common/auto-init-1.c index 3e6a4984eea2..96dd4be32a8d 100644 --- a/gcc/testsuite/c-c++-common/auto-init-1.c +++ b/gcc/testsuite/c-c++-common/auto-init-1.c @@ -29,13 +29,13 @@ void foo() return; } -/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(1, 2, \&\"temp1\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp2 = .DEFERRED_INIT \\(2, 2, \&\"temp2\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp3 = .DEFERRED_INIT \\(4, 2, \&\"temp3\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp4 = .DEFERRED_INIT \\(4, 2, \&\"temp4\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp5 = .DEFERRED_INIT \\(4, 2, \&\"temp5\"" "gimple" { target ilp32 } } } */ -/* { dg-final { scan-tree-dump "temp5 = .DEFERRED_INIT \\(8, 2, \&\"temp5\"" "gimple" { target lp64 } } } */ -/* { dg-final { scan-tree-dump "temp6 = .DEFERRED_INIT \\(8, 2, \&\"temp6\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp7 = .DEFERRED_INIT \\(4, 2, \&\"temp7\"" "gimple" { target ilp32 } } } */ -/* { dg-final { scan-tree-dump "temp7 = .DEFERRED_INIT \\(8, 2, \&\"temp7\"" "gimple" { target lp64 } } } */ -/* { dg-final { scan-tree-dump "temp8 = .DEFERRED_INIT \\(1, 2, \&\"temp8\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(1, \[26], \&\"temp1\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp2 = .DEFERRED_INIT \\(2, \[26], \&\"temp2\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp3 = .DEFERRED_INIT \\(4, \[26], \&\"temp3\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp4 = .DEFERRED_INIT \\(4, \[26], \&\"temp4\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp5 = .DEFERRED_INIT \\(4, \[26], \&\"temp5\"" "gimple" { target ilp32 } } } */ +/* { dg-final { scan-tree-dump "temp5 = .DEFERRED_INIT \\(8, \[26], \&\"temp5\"" "gimple" { target lp64 } } } */ +/* { dg-final { scan-tree-dump "temp6 = .DEFERRED_INIT \\(8, \[26], \&\"temp6\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp7 = .DEFERRED_INIT \\(4, \[26], \&\"temp7\"" "gimple" { target ilp32 } } } */ +/* { dg-final { scan-tree-dump "temp7 = .DEFERRED_INIT \\(8, \[26], \&\"temp7\"" "gimple" { target lp64 } } } */ +/* { dg-final { scan-tree-dump "temp8 = .DEFERRED_INIT \\(1, \[26], \&\"temp8\"" "gimple" } } */ diff --git a/gcc/testsuite/c-c++-common/auto-init-10.c b/gcc/testsuite/c-c++-common/auto-init-10.c index dda7ea1e0324..4ec0a2594070 100644 --- a/gcc/testsuite/c-c++-common/auto-init-10.c +++ b/gcc/testsuite/c-c++-common/auto-init-10.c @@ -18,5 +18,5 @@ void foo() return; } -/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(2, 1, \&\"temp1\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(2, \[15], \&\"temp1\"" "gimple" } } */ /* { dg-final { scan-tree-dump-not "temp2 = .DEFERRED_INIT \\(" "gimple" } } */ diff --git a/gcc/testsuite/c-c++-common/auto-init-11.c b/gcc/testsuite/c-c++-common/auto-init-11.c index 6eb468785ce1..2114474e68aa 100644 --- a/gcc/testsuite/c-c++-common/auto-init-11.c +++ b/gcc/testsuite/c-c++-common/auto-init-11.c @@ -11,4 +11,4 @@ void foo(int n) return; } -/* { dg-final { scan-tree-dump ".DEFERRED_INIT \\(D.\\d*, 2, \&\"arr\"" "gimple" } } */ +/* { dg-final { scan-tree-dump ".DEFERRED_INIT \\(D.\\d*, \[26], \&\"arr\"" "gimple" } } */ diff --git a/gcc/testsuite/c-c++-common/auto-init-12.c b/gcc/testsuite/c-c++-common/auto-init-12.c index 964291c5bd94..4eb0f6e50764 100644 --- a/gcc/testsuite/c-c++-common/auto-init-12.c +++ b/gcc/testsuite/c-c++-common/auto-init-12.c @@ -11,4 +11,4 @@ void foo(int n) return; } -/* { dg-final { scan-tree-dump ".DEFERRED_INIT \\(D.\\d*, 1, \&\"arr\"" "gimple" } } */ +/* { dg-final { scan-tree-dump ".DEFERRED_INIT \\(D.\\d*, \[15], \&\"arr\"" "gimple" } } */ diff --git a/gcc/testsuite/c-c++-common/auto-init-13.c b/gcc/testsuite/c-c++-common/auto-init-13.c index aa5883af770f..b53b2b98e877 100644 --- a/gcc/testsuite/c-c++-common/auto-init-13.c +++ b/gcc/testsuite/c-c++-common/auto-init-13.c @@ -19,5 +19,5 @@ int foo() return d.b + var.bar.b; } -/* { dg-final { scan-tree-dump "d = .DEFERRED_INIT \\(4, 1, \&\"d\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "var = .DEFERRED_INIT \\(4, 1, \&\"var\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "d = .DEFERRED_INIT \\(4, \[15], \&\"d\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "var = .DEFERRED_INIT \\(4, \[15], \&\"var\"" "gimple" } } */ diff --git a/gcc/testsuite/c-c++-common/auto-init-14.c b/gcc/testsuite/c-c++-common/auto-init-14.c index dd1ff3e339d2..90fd57a537f4 100644 --- a/gcc/testsuite/c-c++-common/auto-init-14.c +++ b/gcc/testsuite/c-c++-common/auto-init-14.c @@ -19,5 +19,5 @@ int foo() return d.b + var.bar.b; } -/* { dg-final { scan-tree-dump "d = .DEFERRED_INIT \\(4, 2, \&\"d\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "var = .DEFERRED_INIT \\(4, 2, \&\"var\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "d = .DEFERRED_INIT \\(4, \[26], \&\"d\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "var = .DEFERRED_INIT \\(4, \[26], \&\"var\"" "gimple" } } */ diff --git a/gcc/testsuite/c-c++-common/auto-init-15.c b/gcc/testsuite/c-c++-common/auto-init-15.c index 5857287ecbef..f389b5aa544f 100644 --- a/gcc/testsuite/c-c++-common/auto-init-15.c +++ b/gcc/testsuite/c-c++-common/auto-init-15.c @@ -10,4 +10,4 @@ void foo(int a) g(x); } -/* { dg-final { scan-tree-dump ".DEFERRED_INIT \\(D.\\d*, 2, \&\"x\"" "gimple" } } */ +/* { dg-final { scan-tree-dump ".DEFERRED_INIT \\(D.\\d*, \[26], \&\"x\"" "gimple" } } */ diff --git a/gcc/testsuite/c-c++-common/auto-init-16.c b/gcc/testsuite/c-c++-common/auto-init-16.c index 1e309959fc5c..b6cc7506c3c2 100644 --- a/gcc/testsuite/c-c++-common/auto-init-16.c +++ b/gcc/testsuite/c-c++-common/auto-init-16.c @@ -10,4 +10,4 @@ void foo(int a) g(x); } -/* { dg-final { scan-tree-dump ".DEFERRED_INIT \\(D.\\d*, 1, \&\"x\"" "gimple" } } */ +/* { dg-final { scan-tree-dump ".DEFERRED_INIT \\(D.\\d*, \[15], \&\"x\"" "gimple" } } */ diff --git a/gcc/testsuite/c-c++-common/auto-init-2.c b/gcc/testsuite/c-c++-common/auto-init-2.c index d356e508b836..a1f66358e6e2 100644 --- a/gcc/testsuite/c-c++-common/auto-init-2.c +++ b/gcc/testsuite/c-c++-common/auto-init-2.c @@ -29,13 +29,13 @@ void foo() return; } -/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(1, 1, \&\"temp1\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp2 = .DEFERRED_INIT \\(2, 1, \&\"temp2\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp3 = .DEFERRED_INIT \\(4, 1, \&\"temp3\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp4 = .DEFERRED_INIT \\(4, 1, \&\"temp4\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp5 = .DEFERRED_INIT \\(4, 1, \&\"temp5\"" "gimple" { target ilp32 } } } */ -/* { dg-final { scan-tree-dump "temp5 = .DEFERRED_INIT \\(8, 1, \&\"temp5\"" "gimple" { target lp64 } } } */ -/* { dg-final { scan-tree-dump "temp6 = .DEFERRED_INIT \\(8, 1, \&\"temp6\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp7 = .DEFERRED_INIT \\(4, 1, \&\"temp7\"" "gimple" { target ilp32 } } } */ -/* { dg-final { scan-tree-dump "temp7 = .DEFERRED_INIT \\(8, 1, \&\"temp7\"" "gimple" { target lp64 } } } */ -/* { dg-final { scan-tree-dump "temp8 = .DEFERRED_INIT \\(1, 1, \&\"temp8\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(1, \[15], \&\"temp1\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp2 = .DEFERRED_INIT \\(2, \[15], \&\"temp2\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp3 = .DEFERRED_INIT \\(4, \[15], \&\"temp3\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp4 = .DEFERRED_INIT \\(4, \[15], \&\"temp4\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp5 = .DEFERRED_INIT \\(4, \[15], \&\"temp5\"" "gimple" { target ilp32 } } } */ +/* { dg-final { scan-tree-dump "temp5 = .DEFERRED_INIT \\(8, \[15], \&\"temp5\"" "gimple" { target lp64 } } } */ +/* { dg-final { scan-tree-dump "temp6 = .DEFERRED_INIT \\(8, \[15], \&\"temp6\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp7 = .DEFERRED_INIT \\(4, \[15], \&\"temp7\"" "gimple" { target ilp32 } } } */ +/* { dg-final { scan-tree-dump "temp7 = .DEFERRED_INIT \\(8, \[15], \&\"temp7\"" "gimple" { target lp64 } } } */ +/* { dg-final { scan-tree-dump "temp8 = .DEFERRED_INIT \\(1, \[15], \&\"temp8\"" "gimple" } } */ diff --git a/gcc/testsuite/c-c++-common/auto-init-3.c b/gcc/testsuite/c-c++-common/auto-init-3.c index 9d9c86d8dd08..c2e310f23643 100644 --- a/gcc/testsuite/c-c++-common/auto-init-3.c +++ b/gcc/testsuite/c-c++-common/auto-init-3.c @@ -14,6 +14,6 @@ long double foo() return result; } -/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(4, 2, \&\"temp1\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp2 = .DEFERRED_INIT \\(8, 2, \&\"temp2\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp3 = .DEFERRED_INIT \\((8|12|16), 2, \&\"temp3\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(4, \[26], \&\"temp1\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp2 = .DEFERRED_INIT \\(8, \[26], \&\"temp2\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp3 = .DEFERRED_INIT \\((8|12|16), \[26], \&\"temp3\"" "gimple" } } */ diff --git a/gcc/testsuite/c-c++-common/auto-init-4.c b/gcc/testsuite/c-c++-common/auto-init-4.c index 848df2a0e264..cff11ef3e167 100644 --- a/gcc/testsuite/c-c++-common/auto-init-4.c +++ b/gcc/testsuite/c-c++-common/auto-init-4.c @@ -14,6 +14,6 @@ long double foo() return result; } -/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(4, 1, \&\"temp1\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp2 = .DEFERRED_INIT \\(8, 1, \&\"temp2\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp3 = .DEFERRED_INIT \\((8|12|16), 1, \&\"temp3\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(4, \[15], \&\"temp1\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp2 = .DEFERRED_INIT \\(8, \[15], \&\"temp2\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp3 = .DEFERRED_INIT \\((8|12|16), \[15], \&\"temp3\"" "gimple" } } */ diff --git a/gcc/testsuite/c-c++-common/auto-init-5.c b/gcc/testsuite/c-c++-common/auto-init-5.c index 9c4de6121826..1be200c4428e 100644 --- a/gcc/testsuite/c-c++-common/auto-init-5.c +++ b/gcc/testsuite/c-c++-common/auto-init-5.c @@ -15,7 +15,7 @@ _Complex long double foo() return result; } -/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(8, 2, \&\"temp1\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp2 = .DEFERRED_INIT \\(16, 2, \&\"temp2\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp3 = .DEFERRED_INIT \\((16|24|32), 2, \&\"temp3\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(8, \[26], \&\"temp1\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp2 = .DEFERRED_INIT \\(16, \[26], \&\"temp2\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp3 = .DEFERRED_INIT \\((16|24|32), \[26], \&\"temp3\"" "gimple" } } */ diff --git a/gcc/testsuite/c-c++-common/auto-init-6.c b/gcc/testsuite/c-c++-common/auto-init-6.c index 6a406447f3d9..8f09007c358a 100644 --- a/gcc/testsuite/c-c++-common/auto-init-6.c +++ b/gcc/testsuite/c-c++-common/auto-init-6.c @@ -15,7 +15,7 @@ _Complex long double foo() return result; } -/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(8, 1, \&\"temp1\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp2 = .DEFERRED_INIT \\(16, 1, \&\"temp2\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp3 = .DEFERRED_INIT \\((16|24|32), 1, \&\"temp3\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(8, \[15], \&\"temp1\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp2 = .DEFERRED_INIT \\(16, \[15], \&\"temp2\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp3 = .DEFERRED_INIT \\((16|24|32), \[15], \&\"temp3\"" "gimple" } } */ diff --git a/gcc/testsuite/c-c++-common/auto-init-7.c b/gcc/testsuite/c-c++-common/auto-init-7.c index dd48d691596f..346676304016 100644 --- a/gcc/testsuite/c-c++-common/auto-init-7.c +++ b/gcc/testsuite/c-c++-common/auto-init-7.c @@ -29,7 +29,7 @@ double foo() return result; } -/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(12, 2, \&\"temp1\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp2 = .DEFERRED_INIT \\(24, 2, \&\"temp2\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp3 = .DEFERRED_INIT \\(28, 2, \&\"temp3\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp4 = .DEFERRED_INIT \\((8|5), 2, \&\"temp4\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(12, \[26], \&\"temp1\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp2 = .DEFERRED_INIT \\(24, \[26], \&\"temp2\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp3 = .DEFERRED_INIT \\(28, \[26], \&\"temp3\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp4 = .DEFERRED_INIT \\((8|5), \[26], \&\"temp4\"" "gimple" } } */ diff --git a/gcc/testsuite/c-c++-common/auto-init-8.c b/gcc/testsuite/c-c++-common/auto-init-8.c index 863f2ba87d7d..93d37ee6c9ca 100644 --- a/gcc/testsuite/c-c++-common/auto-init-8.c +++ b/gcc/testsuite/c-c++-common/auto-init-8.c @@ -29,7 +29,7 @@ double foo() return result; } -/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(12, 1, \&\"temp1\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp2 = .DEFERRED_INIT \\(24, 1, \&\"temp2\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp3 = .DEFERRED_INIT \\(28, 1, \&\"temp3\"" "gimple" } } */ -/* { dg-final { scan-tree-dump "temp4 = .DEFERRED_INIT \\((8|5), 1, \&\"temp4\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(12, \[15], \&\"temp1\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp2 = .DEFERRED_INIT \\(24, \[15], \&\"temp2\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp3 = .DEFERRED_INIT \\(28, \[15], \&\"temp3\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp4 = .DEFERRED_INIT \\((8|5), \[15], \&\"temp4\"" "gimple" } } */ diff --git a/gcc/testsuite/c-c++-common/auto-init-9.c b/gcc/testsuite/c-c++-common/auto-init-9.c index 113107ffd5c0..66204285616c 100644 --- a/gcc/testsuite/c-c++-common/auto-init-9.c +++ b/gcc/testsuite/c-c++-common/auto-init-9.c @@ -16,5 +16,5 @@ void foo() return; } -/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(2, 2, \&\"temp1\"" "gimple" } } */ -/* { dg-final { scan-tree-dump-not "temp2 = .DEFERRED_INIT \\(8, 2, \&\"temp2\"" "gimple" } } */ +/* { dg-final { scan-tree-dump "temp1 = .DEFERRED_INIT \\(2, \[26], \&\"temp1\"" "gimple" } } */ +/* { dg-final { scan-tree-dump-not "temp2 = .DEFERRED_INIT \\(8, \[26], \&\"temp2\"" "gimple" } } */ diff --git a/gcc/testsuite/c-c++-common/auto-init-esra.c b/gcc/testsuite/c-c++-common/auto-init-esra.c index ce6779f20fcd..3471a21aa808 100644 --- a/gcc/testsuite/c-c++-common/auto-init-esra.c +++ b/gcc/testsuite/c-c++-common/auto-init-esra.c @@ -31,5 +31,5 @@ void VCross(VECTOR a, const VECTOR b, const VECTOR c) Assign_Vector(a, tmp); } -/* { dg-final { scan-tree-dump-times "tmp = .DEFERRED_INIT \\(24, 2, \&\"tmp\"" 1 "gimple" } } */ -/* { dg-final { scan-tree-dump-times ".DEFERRED_INIT \\(8, 2, \&\"tmp\"" 3 "esra" } } */ +/* { dg-final { scan-tree-dump-times "tmp = .DEFERRED_INIT \\(24, \[26], \&\"tmp\"" 1 "gimple" } } */ +/* { dg-final { scan-tree-dump-times ".DEFERRED_INIT \\(8, \[26], \&\"tmp\"" 3 "esra" } } */ diff --git a/gcc/testsuite/c-c++-common/auto-init-padding-1.c b/gcc/testsuite/c-c++-common/auto-init-padding-1.c index d2e322717f0e..dddff37a68bf 100644 --- a/gcc/testsuite/c-c++-common/auto-init-padding-1.c +++ b/gcc/testsuite/c-c++-common/auto-init-padding-1.c @@ -19,5 +19,5 @@ void foo(int a) g(s); } -/* { dg-final { scan-tree-dump ".DEFERRED_INIT \\(24, 1, \&\"s\"" "gimple" } } */ +/* { dg-final { scan-tree-dump ".DEFERRED_INIT \\(24, \[15], \&\"s\"" "gimple" } } */ /* { dg-final { scan-tree-dump "__builtin_clear_padding" "gimple" } } */ diff --git a/gcc/testsuite/g++.dg/cpp26/erroneous7.C b/gcc/testsuite/g++.dg/cpp26/erroneous7.C new file mode 100644 index 000000000000..b68b3952768c --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp26/erroneous7.C @@ -0,0 +1,20 @@ +// PR c++/126848 +// { dg-do run { target c++26 } } +// { dg-skip-if "" { *-*-* } { "-ftrivial-auto-var-init=*" } { "" } } +// { dg-options "-O2 -Wuninitialized" } + +[[gnu::noipa]] +int +foo (int x) +{ + int a; + int b = x ? a : 1; + return b - a; // { dg-warning "'a' is used uninitialized" } +} + +int +main () +{ + if (foo (1) != 0) + __builtin_abort (); +} diff --git a/gcc/testsuite/g++.dg/cpp26/erroneous8.C b/gcc/testsuite/g++.dg/cpp26/erroneous8.C new file mode 100644 index 000000000000..8cc6ccada5b8 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp26/erroneous8.C @@ -0,0 +1,19 @@ +// PR c++/126848 +// { dg-do run { target c++26 } } +// { dg-options "-O2 -ftrivial-auto-var-init=zero -Wuninitialized" } + +[[gnu::noipa]] +int +foo (int x) +{ + int a; + int b = x ? a : 1; + return b - a; // { dg-warning "'a' is used uninitialized" } +} + +int +main () +{ + if (foo (1) != 0) + __builtin_abort (); +} diff --git a/gcc/testsuite/g++.dg/cpp26/erroneous9.C b/gcc/testsuite/g++.dg/cpp26/erroneous9.C new file mode 100644 index 000000000000..2f95fadd99a7 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp26/erroneous9.C @@ -0,0 +1,19 @@ +// PR c++/126848 +// { dg-do run { target c++26 } } +// { dg-options "-O2 -ftrivial-auto-var-init=pattern -Wuninitialized" } + +[[gnu::noipa]] +int +foo (int x) +{ + int a; + int b = x ? a : 1; + return b - a; // { dg-warning "'a' is used uninitialized" } +} + +int +main () +{ + if (foo (1) != 0) + __builtin_abort (); +} diff --git a/gcc/tree-ssa-ccp.cc b/gcc/tree-ssa-ccp.cc index cc1da6540e34..9930d78956fe 100644 --- a/gcc/tree-ssa-ccp.cc +++ b/gcc/tree-ssa-ccp.cc @@ -727,9 +727,16 @@ likely_value (gimple *stmt) if (gimple_has_volatile_ops (stmt)) return VARYING; - /* .DEFERRED_INIT produces undefined. */ + /* .DEFERRED_INIT produces undefined except for AUTO_INIT_CXX26 + which produces varying because it is undefined that needs to have + the same value in all uses. */ if (gimple_call_internal_p (stmt, IFN_DEFERRED_INIT)) - return UNDEFINED; + { + if (tree_to_uhwi (gimple_call_arg (stmt, 1)) & AUTO_INIT_CXX26) + return VARYING; + else + return UNDEFINED; + } /* Arrive here for more complex cases. */ has_constant_operand = false; diff --git a/gcc/tree-ssa-uninit.cc b/gcc/tree-ssa-uninit.cc index 1072e1e270bb..7d242ab7530a 100644 --- a/gcc/tree-ssa-uninit.cc +++ b/gcc/tree-ssa-uninit.cc @@ -81,6 +81,7 @@ static bool has_undefined_value_p (tree t) { return (ssa_undefined_value_p (t) + || gimple_call_internal_p (SSA_NAME_DEF_STMT (t), IFN_DEFERRED_INIT) || (possibly_undefined_names && possibly_undefined_names->contains (t))); } diff --git a/gcc/tree-ssa.cc b/gcc/tree-ssa.cc index 5248c0903d45..4f94edb2f4b5 100644 --- a/gcc/tree-ssa.cc +++ b/gcc/tree-ssa.cc @@ -1348,9 +1348,15 @@ ssa_undefined_value_p (tree t, bool partial) return true; /* The value is undefined if the definition statement is a call - to .DEFERRED_INIT function. */ + to .DEFERRED_INIT function. Except for AUTO_INIT_CXX26 which is + undefined but needs to have the same value in all uses. */ if (gimple_call_internal_p (def_stmt, IFN_DEFERRED_INIT)) - return true; + { + if (tree_to_uhwi (gimple_call_arg (def_stmt, 1)) & AUTO_INIT_CXX26) + return false; + else + return true; + } /* The value is partially undefined if the definition statement is a REALPART_EXPR or IMAGPART_EXPR and its operand is defined by From 4cb4c35d75c5b1fec8b5271b844b1eecb40983e0 Mon Sep 17 00:00:00 2001 From: "Jose E. Marchesi" Date: Thu, 24 Sep 2026 21:06:27 +0200 Subject: [PATCH 399/584] a68: fix regression in are_modes_equivalent This commit fixes a regression that I stupidly introduced ages ago because I am dumb and I deserve all the hours of debugging that took to find out what the heck was going on. Signed-off-by: Jose E. Marchesi gcc/algol68/ChangeLog * a68-parser-moids-equivalence.cc (are_modes_equivalent): Do not string-compare INDICANTs. gcc/testsuite/ChangeLog * algol68/compile/mode-shadow-1.a68: New test. --- gcc/algol68/a68-parser-moids-equivalence.cc | 3 +-- gcc/testsuite/algol68/compile/mode-shadow-1.a68 | 7 +++++++ 2 files changed, 8 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/algol68/compile/mode-shadow-1.a68 diff --git a/gcc/algol68/a68-parser-moids-equivalence.cc b/gcc/algol68/a68-parser-moids-equivalence.cc index f97dcafc694b..44177f64784d 100644 --- a/gcc/algol68/a68-parser-moids-equivalence.cc +++ b/gcc/algol68/a68-parser-moids-equivalence.cc @@ -121,8 +121,7 @@ are_modes_equivalent (MOID_T * a, MOID_T * b) if (NODE (a) == NO_NODE || NODE (b) == NO_NODE) return false; else - return (NODE (a) == NODE (b) - || strcmp (NSYMBOL (NODE (a)), NSYMBOL (NODE (b))) == 0); + return NODE (a) == NODE (b); } /* Investigate structure. */ diff --git a/gcc/testsuite/algol68/compile/mode-shadow-1.a68 b/gcc/testsuite/algol68/compile/mode-shadow-1.a68 new file mode 100644 index 000000000000..d3b9cf082ae6 --- /dev/null +++ b/gcc/testsuite/algol68/compile/mode-shadow-1.a68 @@ -0,0 +1,7 @@ +begin mode Foo = real; + begin mode Foo = int; + Foo i; + BIN i + end; + skip +end From 39a6b7de56ebd7091c092a4b07fed3809f10544d Mon Sep 17 00:00:00 2001 From: Jerry DeLisle Date: Fri, 28 Aug 2026 16:40:44 -0700 Subject: [PATCH 400/584] libgfortran: [PR127347] caf_shmem: terminate all images on ERROR STOP An image executing ERROR STOP exited on its own, and the other images blocked forever in their next image control statement. ERROR STOP initiates error termination of all images. The image now records that it error stopped before exiting, and the supervisor terminates all other images when it reaps it. Only the fork based supervisor does so. Assisted-by: Claude Opus 5 PR libfortran/127347 libgfortran/ChangeLog: * caf/shmem.c (mark_error_stopped): New function. (_gfortran_caf_error_stop_str, _gfortran_caf_error_stop): Call it. * caf/shmem/supervisor.c (supervisor_main_loop): Terminate all images when an image error stopped. * caf/shmem/supervisor.h (image_status): Add IMAGE_ERROR_STOP. gcc/testsuite/ChangeLog: * gfortran.dg/coarray/error_stop_1.f90: New test. --- .../gfortran.dg/coarray/error_stop_1.f90 | 18 ++++++++++++++ libgfortran/caf/shmem.c | 13 ++++++++++ libgfortran/caf/shmem/supervisor.c | 24 ++++++++++++------- libgfortran/caf/shmem/supervisor.h | 4 +++- 4 files changed, 50 insertions(+), 9 deletions(-) create mode 100644 gcc/testsuite/gfortran.dg/coarray/error_stop_1.f90 diff --git a/gcc/testsuite/gfortran.dg/coarray/error_stop_1.f90 b/gcc/testsuite/gfortran.dg/coarray/error_stop_1.f90 new file mode 100644 index 000000000000..bdbd20f6fd66 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/coarray/error_stop_1.f90 @@ -0,0 +1,18 @@ +! { dg-do run } +! { dg-shouldfail "ERROR STOP terminates all images" } +! { dg-output "ERROR STOP no way back" } +! +! ERROR STOP on one image has to terminate all other images. Without that +! the surviving images block in the SYNC ALL below until the test times out. + +program error_stop_all_images + implicit none + integer :: i + + sync all + if (this_image () == num_images ()) error stop "no way back" + + do i = 1, 100 + sync all + end do +end program error_stop_all_images diff --git a/libgfortran/caf/shmem.c b/libgfortran/caf/shmem.c index 6288d22204c6..c6735146a2eb 100644 --- a/libgfortran/caf/shmem.c +++ b/libgfortran/caf/shmem.c @@ -570,6 +570,17 @@ _gfortran_caf_sync_images (int count, int images[], int *stat, char *errmsg, extern void _gfortran_report_exception (void); +/* Tell the supervisor that this image error stopped, so that it can terminate + all other images. */ + +static void +mark_error_stopped (void) +{ + if (this_image.supervisor && this_image.image_num >= 0) + this_image.supervisor->images[this_image.image_num].status + = IMAGE_ERROR_STOP; +} + void _gfortran_caf_stop_numeric (int stop_code, bool quiet) { @@ -607,6 +618,7 @@ _gfortran_caf_error_stop_str (const char *string, size_t len, bool quiet) fputc (*(string++), stderr); fputs ("\n", stderr); } + mark_error_stopped (); exit (1); } @@ -739,6 +751,7 @@ _gfortran_caf_error_stop (int error, bool quiet) _gfortran_report_exception (); fprintf (stderr, "ERROR STOP %d\n", error); } + mark_error_stopped (); exit (error); } diff --git a/libgfortran/caf/shmem/supervisor.c b/libgfortran/caf/shmem/supervisor.c index 0836b89d99f9..ff4a592b6f28 100644 --- a/libgfortran/caf/shmem/supervisor.c +++ b/libgfortran/caf/shmem/supervisor.c @@ -408,12 +408,24 @@ supervisor_main_loop (int *argc __attribute__ ((unused)), --i; continue; } - if (WIFEXITED (chstatus) && !WEXITSTATUS (chstatus)) + for (j = 0; + j < local->total_num_images && m->images[j].pid != finished_pid; + j++) + ; + + /* An ERROR STOP on any image terminates all images. */ + if (j < local->total_num_images + && m->images[j].status == IMAGE_ERROR_STOP) { - for (j = 0; - j < local->total_num_images && m->images[j].pid != finished_pid; - j++) + kill_all_images (m); + while (wait (NULL) > 0) ; + *exit_code = WIFEXITED (chstatus) ? WEXITSTATUS (chstatus) : 1; + return 0; + } + + if (WIFEXITED (chstatus) && !WEXITSTATUS (chstatus)) + { /* Only set the status, when it has not been set by the (failing) image already. */ if (m->images[j].status == IMAGE_OK) @@ -424,10 +436,6 @@ supervisor_main_loop (int *argc __attribute__ ((unused)), } else if (!WIFEXITED (chstatus) || WEXITSTATUS (chstatus)) { - for (j = 0; - j < local->total_num_images && m->images[j].pid != finished_pid; - j++) - ; if (WEXITSTATUS (chstatus) == 210) { --i; diff --git a/libgfortran/caf/shmem/supervisor.h b/libgfortran/caf/shmem/supervisor.h index e5c275b65268..a956092e2635 100644 --- a/libgfortran/caf/shmem/supervisor.h +++ b/libgfortran/caf/shmem/supervisor.h @@ -41,7 +41,9 @@ typedef enum IMAGE_UNKNOWN = 0, IMAGE_OK, IMAGE_FAILED, - IMAGE_SUCCESS + IMAGE_SUCCESS, + /* The image executed an ERROR STOP and requires all images to terminate. */ + IMAGE_ERROR_STOP } image_status; typedef struct From b9da28bcd9af4053544f191f2393a0c79e3d30ae Mon Sep 17 00:00:00 2001 From: Jerry DeLisle Date: Wed, 23 Sep 2026 13:46:40 -0700 Subject: [PATCH 401/584] libgfortran: [PR127347] caf_shmem: do not wait for terminated images When an image terminated normally or with FAIL IMAGE, the other images kept counting it in their team barriers and blocked forever in the next SYNC ALL. An image executing STOP or FAIL IMAGE now drops out of the barriers of every team it is a member of before it exits. Lowering the count wakes the images already waiting once it reaches zero. An image executing STOP with a non-zero stop code records that it stopped and then exits with that code. The supervisor marked every image exiting with a non-zero code as failed, so keep the status the image recorded, as is done for an image exiting with zero. SYNC IMAGES indexed its synchronization table with the team's image count as the row stride. That count shrinks once an image has terminated, although the table is allocated for all images. Use the total number of images, and handle an image list and * alike. Assisted-by: Claude Opus 5 PR libfortran/127347 libgfortran/ChangeLog: * caf/shmem.c (mark_stopped): New function. (_gfortran_caf_stop_numeric, _gfortran_caf_stop_str): Call it. (_gfortran_caf_fail_image): Call leave_teams. * caf/shmem/supervisor.c (supervisor_main_loop): Keep the status an image recorded for itself. * caf/shmem/sync.c (sync_table): Use the total number of images as the row stride. Handle an image list and all images alike. * caf/shmem/teams_mgmt.c (leave_teams): New function. * caf/shmem/teams_mgmt.h (leave_teams): Declare. gcc/testsuite/ChangeLog: * gfortran.dg/coarray/fail_image_sync_1.f90: New test. * gfortran.dg/coarray/stop_sync_1.f90: New test. * gfortran.dg/coarray/sync_images_stopped_1.f90: New test. --- .../gfortran.dg/coarray/fail_image_sync_1.f90 | 19 ++++++ .../gfortran.dg/coarray/stop_sync_1.f90 | 17 +++++ .../coarray/sync_images_stopped_1.f90 | 16 +++++ libgfortran/caf/shmem.c | 21 +++++++ libgfortran/caf/shmem/supervisor.c | 9 ++- libgfortran/caf/shmem/sync.c | 63 +++++++------------ libgfortran/caf/shmem/teams_mgmt.c | 9 +++ libgfortran/caf/shmem/teams_mgmt.h | 6 ++ 8 files changed, 118 insertions(+), 42 deletions(-) create mode 100644 gcc/testsuite/gfortran.dg/coarray/fail_image_sync_1.f90 create mode 100644 gcc/testsuite/gfortran.dg/coarray/stop_sync_1.f90 create mode 100644 gcc/testsuite/gfortran.dg/coarray/sync_images_stopped_1.f90 diff --git a/gcc/testsuite/gfortran.dg/coarray/fail_image_sync_1.f90 b/gcc/testsuite/gfortran.dg/coarray/fail_image_sync_1.f90 new file mode 100644 index 000000000000..87b2abbcb953 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/coarray/fail_image_sync_1.f90 @@ -0,0 +1,19 @@ +! { dg-do run } +! +! FAIL IMAGE on one image must not block the remaining images in SYNC ALL. +! They synchronize among themselves and get STAT_FAILED_IMAGE. + +program fail_image_sync_1 + use iso_fortran_env, only: STAT_FAILED_IMAGE + implicit none + integer :: i, st + + sync all + if (num_images () > 1 .and. this_image () == num_images ()) fail image + + do i = 1, 5 + st = 0 + sync all (stat=st) + end do + if (num_images () > 1 .and. st /= STAT_FAILED_IMAGE) stop 1 +end program fail_image_sync_1 diff --git a/gcc/testsuite/gfortran.dg/coarray/stop_sync_1.f90 b/gcc/testsuite/gfortran.dg/coarray/stop_sync_1.f90 new file mode 100644 index 000000000000..cb41610aaf97 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/coarray/stop_sync_1.f90 @@ -0,0 +1,17 @@ +! { dg-do run } +! +! A normal STOP on one image must not block the surviving images in the +! SYNC ALL statements that follow. + +program stop_sync_1 + implicit none + integer :: i, st + + sync all + if (num_images () > 1 .and. this_image () == num_images ()) stop + + do i = 1, 5 + st = 0 + sync all (stat=st) + end do +end program stop_sync_1 diff --git a/gcc/testsuite/gfortran.dg/coarray/sync_images_stopped_1.f90 b/gcc/testsuite/gfortran.dg/coarray/sync_images_stopped_1.f90 new file mode 100644 index 000000000000..eecfc70f877d --- /dev/null +++ b/gcc/testsuite/gfortran.dg/coarray/sync_images_stopped_1.f90 @@ -0,0 +1,16 @@ +! { dg-do run } +! +! SYNC IMAGES (*) has to keep working after an image terminated normally. + +program sync_images_stopped_1 + implicit none + integer :: i, st + + sync all + if (num_images () > 1 .and. this_image () == num_images ()) stop + + do i = 1, 5 + st = 0 + sync images (*, stat=st) + end do +end program sync_images_stopped_1 diff --git a/libgfortran/caf/shmem.c b/libgfortran/caf/shmem.c index c6735146a2eb..89fad8a8f4b3 100644 --- a/libgfortran/caf/shmem.c +++ b/libgfortran/caf/shmem.c @@ -570,6 +570,24 @@ _gfortran_caf_sync_images (int count, int images[], int *stat, char *errmsg, extern void _gfortran_report_exception (void); +/* Tell the supervisor that this image terminated normally and drop it from + the barriers of its teams. */ + +static void +mark_stopped (void) +{ + if (!this_image.supervisor || this_image.image_num < 0) + return; + + if (this_image.supervisor->images[this_image.image_num].status == IMAGE_OK) + { + this_image.supervisor->images[this_image.image_num].status + = IMAGE_SUCCESS; + atomic_fetch_add (&this_image.supervisor->finished_images, 1); + } + leave_teams (); +} + /* Tell the supervisor that this image error stopped, so that it can terminate all other images. */ @@ -589,6 +607,7 @@ _gfortran_caf_stop_numeric (int stop_code, bool quiet) _gfortran_report_exception (); fprintf (stderr, "STOP %d\n", stop_code); } + mark_stopped (); exit (stop_code); } @@ -603,6 +622,7 @@ _gfortran_caf_stop_str (const char *string, size_t len, bool quiet) fputc (*(string++), stderr); fputs ("\n", stderr); } + mark_stopped (); exit (0); } @@ -630,6 +650,7 @@ _gfortran_caf_fail_image (void) fputs ("IMAGE FAILED!\n", stderr); this_image.supervisor->images[this_image.image_num].status = IMAGE_FAILED; atomic_fetch_add (&this_image.supervisor->failed_images, 1); + leave_teams (); exit (0); } diff --git a/libgfortran/caf/shmem/supervisor.c b/libgfortran/caf/shmem/supervisor.c index ff4a592b6f28..d63b58e3647f 100644 --- a/libgfortran/caf/shmem/supervisor.c +++ b/libgfortran/caf/shmem/supervisor.c @@ -478,8 +478,13 @@ supervisor_main_loop (int *argc __attribute__ ((unused)), WTERMSIG (chstatus), finished_pid); continue; } - m->images[j].status = IMAGE_FAILED; - atomic_fetch_add (&m->failed_images, 1); + /* Only set the status, when it has not been set by the image + already, e.g. by a STOP with a non-zero stop code. */ + if (m->images[j].status == IMAGE_OK) + { + m->images[j].status = IMAGE_FAILED; + atomic_fetch_add (&m->failed_images, 1); + } if (*exit_code < WTERMSIG (chstatus)) *exit_code = WTERMSIG (chstatus); else if (*exit_code == 0) diff --git a/libgfortran/caf/shmem/sync.c b/libgfortran/caf/shmem/sync.c index 76ae0e53ccff..f1d5bedbc8e1 100644 --- a/libgfortran/caf/shmem/sync.c +++ b/libgfortran/caf/shmem/sync.c @@ -94,53 +94,36 @@ sync_table (sync_t *si, int *images, int size) command is completed. */ volatile int *table = si->table; + /* The table is allocated for all images, so the row stride is the total + number of images and not the (shrinking) number of images in a team. */ + const size_t img_c = local->total_num_images; int i; + if (size <= 0) + { + images = caf_current_team->u.image_info->image_map; + size = caf_current_team->u.image_info->image_map_size; + } + lock_table (si); - if (size > 0) + for (i = 0; i < size; ++i) { - const size_t img_c = caf_current_team->u.image_info->image_map_size; - for (i = 0; i < size; ++i) - { - ++table[images[i] + img_c * this_image.image_num]; - caf_shmem_cond_signal (&si->triggers[images[i]]); - } - for (;;) - { - for (i = 0; i < size; ++i) - if (this_image.supervisor->images[images[i]].status == IMAGE_OK - && table[images[i] + this_image.image_num * img_c] - > table[this_image.image_num + images[i] * img_c]) - break; - if (i == size) - break; - caf_shmem_cond_wait (&si->triggers[this_image.image_num], - &si->cis->sync_images_table_lock); - } + if (this_image.supervisor->images[images[i]].status != IMAGE_OK) + continue; + ++table[images[i] + img_c * this_image.image_num]; + caf_shmem_cond_signal (&si->triggers[images[i]]); } - else + for (;;) { - int *map = caf_current_team->u.image_info->image_map; - size = caf_current_team->u.image_info->image_count.count; for (i = 0; i < size; ++i) - { - if (this_image.supervisor->images[map[i]].status != IMAGE_OK) - continue; - ++table[map[i] + size * this_image.image_num]; - caf_shmem_cond_signal (&si->triggers[map[i]]); - } - for (;;) - { - for (i = 0; i < size; ++i) - if (this_image.supervisor->images[map[i]].status == IMAGE_OK - && table[map[i] + size * this_image.image_num] - > table[this_image.image_num + map[i] * size]) - break; - if (i == size) - break; - caf_shmem_cond_wait (&si->triggers[this_image.image_num], - &si->cis->sync_images_table_lock); - } + if (this_image.supervisor->images[images[i]].status == IMAGE_OK + && table[images[i] + img_c * this_image.image_num] + > table[this_image.image_num + img_c * images[i]]) + break; + if (i == size) + break; + caf_shmem_cond_wait (&si->triggers[this_image.image_num], + &si->cis->sync_images_table_lock); } unlock_table (si); } diff --git a/libgfortran/caf/shmem/teams_mgmt.c b/libgfortran/caf/shmem/teams_mgmt.c index c4a821d5f009..02f37f285908 100644 --- a/libgfortran/caf/shmem/teams_mgmt.c +++ b/libgfortran/caf/shmem/teams_mgmt.c @@ -55,6 +55,15 @@ update_teams_images (caf_shmem_team_t team) caf_shmem_mutex_unlock (&team->u.image_info->image_count.mutex); } +void +leave_teams (void) +{ + for (caf_shmem_team_t t = caf_current_team; t; t = t->parent) + update_teams_images (t); + for (caf_shmem_team_t t = caf_teams_formed; t; t = t->parent) + update_teams_images (t); +} + void check_health (int *stat, char *errmsg, size_t errmsg_len) { diff --git a/libgfortran/caf/shmem/teams_mgmt.h b/libgfortran/caf/shmem/teams_mgmt.h index f9da4511128b..8478281f5d2e 100644 --- a/libgfortran/caf/shmem/teams_mgmt.h +++ b/libgfortran/caf/shmem/teams_mgmt.h @@ -86,6 +86,12 @@ extern caf_shmem_team_t caf_teams_formed; void update_teams_images (caf_shmem_team_t); +/* Drop this image, which terminated, from the barriers of all teams it is a + member of. The number of finished or failed images has to be updated + before the call for it to have any effect. */ + +void leave_teams (void); + void check_health (int *, char *, size_t); #define HEALTH_CHECK(stat, errmsg, errlen) check_health (stat, errmsg, errlen) From c9239e63c63c1b1558e9b35e3d7940a36d11aaa0 Mon Sep 17 00:00:00 2001 From: Jerry DeLisle Date: Sat, 19 Sep 2026 12:24:04 -0700 Subject: [PATCH 402/584] libgfortran: [PR127347] caf_shmem: fix STAT= for stopped images Image control statements and collective subroutines did not follow F2023 when an image of the team had stopped. SYNC ALL and SYNC TEAM with a stopped image still synchronized the remaining images, although F2023 11.7.11 gives them the effect of SYNC MEMORY, so a conforming program could deadlock. A stopping image now marks the barriers of its teams as aborting: SYNC ALL and SYNC TEAM no longer wait in them, and a round they already wait in is aborted. Images waiting in END TEAM, CHANGE TEAM or at program end take part in the next round instead. Collective subroutines blocked forever. They now report STAT_STOPPED_IMAGE, or STAT_FAILED_IMAGE, when the current team contains a terminated image (F2023 16.6), and a collective already running gives up with an error instead of blocking. STAT= was classified with the program-wide counts of stopped and failed images, so an image that stopped in one team made SYNC ALL in a sibling team report STAT_STOPPED_IMAGE. It is now classified over the images involved in the statement, and SYNC TEAM reports them at all. Not addressed: END TEAM does not set STAT=. Assisted-by: Claude Opus 5 PR libfortran/127347 libgfortran/ChangeLog: * caf/shmem.c (_gfortran_caf_sync_all, _gfortran_caf_sync_team): Have the effect of SYNC MEMORY with a stopped image. Check the images of the team synchronized. (_gfortran_caf_sync_images): Check the images synchronized. Fix the format of the duplicate image error. (mark_stopped, _gfortran_caf_fail_image): Tell leave_teams whether the image stopped. (_gfortran_caf_co_broadcast, _gfortran_caf_co_sum) (_gfortran_caf_co_min, _gfortran_caf_co_max) (_gfortran_caf_co_reduce): Report terminated images of the team. * caf/shmem/collective_subroutine.c (collsub_sync): Give up when an image of the team terminated. * caf/shmem/counter_barrier.c (counter_barrier_init): Initialize the new fields. (next_round, wait_round): New functions. (counter_barrier_wait): Use wait_round. Take part in the next round when a round is aborted. (counter_barrier_wait_abortable, counter_barrier_abort_locked): New functions. * caf/shmem/counter_barrier.h (counter_barrier): Make curr_wait_group a round number. Add aborted_round, abortable_arrivals and aborting. (counter_barrier_wait_abortable, counter_barrier_abort_locked): Declare. * caf/shmem/sync.c (sync_all): Return whether the images were synchronized. (sync_team_unless_stopped): New function. * caf/shmem/sync.h (sync_all): Adjust. (sync_team_unless_stopped): Declare. * caf/shmem/teams_mgmt.c (count_images, team_terminated_images) (update_teams_images_locked, leave_team): New functions. (update_teams_images): Use update_teams_images_locked. (leave_teams): Add stopped argument. Use leave_team. (check_health): Classify the given images. Return the stat value. * caf/shmem/teams_mgmt.h (leave_teams, check_health): Adjust. (TEAM_HEALTH_CHECK): New macro. (HEALTH_CHECK): Use it. gcc/testsuite/ChangeLog: * gfortran.dg/coarray/stop_sync_1.f90: Check STAT=. * gfortran.dg/coarray/collective_stopped_1.f90: New test. * gfortran.dg/coarray/stop_end_team_1.f90: New test. * gfortran.dg/coarray/stop_sync_team_1.f90: New test. * gfortran.dg/coarray/sync_memory_stopped_1.f90: New test. --- .../coarray/collective_stopped_1.f90 | 33 +++++ .../gfortran.dg/coarray/stop_end_team_1.f90 | 28 ++++ .../gfortran.dg/coarray/stop_sync_1.f90 | 4 +- .../gfortran.dg/coarray/stop_sync_team_1.f90 | 32 +++++ .../coarray/sync_memory_stopped_1.f90 | 25 ++++ libgfortran/caf/shmem.c | 35 ++++- libgfortran/caf/shmem/collective_subroutine.c | 10 +- libgfortran/caf/shmem/counter_barrier.c | 81 ++++++++--- libgfortran/caf/shmem/counter_barrier.h | 25 +++- libgfortran/caf/shmem/sync.c | 10 +- libgfortran/caf/shmem/sync.h | 9 +- libgfortran/caf/shmem/teams_mgmt.c | 126 +++++++++++++----- libgfortran/caf/shmem/teams_mgmt.h | 23 +++- 13 files changed, 369 insertions(+), 72 deletions(-) create mode 100644 gcc/testsuite/gfortran.dg/coarray/collective_stopped_1.f90 create mode 100644 gcc/testsuite/gfortran.dg/coarray/stop_end_team_1.f90 create mode 100644 gcc/testsuite/gfortran.dg/coarray/stop_sync_team_1.f90 create mode 100644 gcc/testsuite/gfortran.dg/coarray/sync_memory_stopped_1.f90 diff --git a/gcc/testsuite/gfortran.dg/coarray/collective_stopped_1.f90 b/gcc/testsuite/gfortran.dg/coarray/collective_stopped_1.f90 new file mode 100644 index 000000000000..b1eae2262791 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/coarray/collective_stopped_1.f90 @@ -0,0 +1,33 @@ +! { dg-do run } +! +! A collective subroutine has to report an image that terminated normally +! through stat= instead of blocking forever. + +program collective_stopped_1 + use iso_fortran_env, only : stat_stopped_image + implicit none + integer :: st, val + + sync all + if (num_images () > 1 .and. this_image () == num_images ()) stop + + st = 0 + sync all (stat=st) + + val = this_image () + st = 0 + call co_sum (val, stat=st) + if (num_images () > 1) then + if (st /= stat_stopped_image) error stop "co_sum missed the stopped image" + else + if (st /= 0) error stop "co_sum failed" + end if + + st = 0 + call co_broadcast (val, 1, stat=st) + if (num_images () > 1) then + if (st /= stat_stopped_image) error stop "co_broadcast missed the stopped image" + else + if (st /= 0) error stop "co_broadcast failed" + end if +end program collective_stopped_1 diff --git a/gcc/testsuite/gfortran.dg/coarray/stop_end_team_1.f90 b/gcc/testsuite/gfortran.dg/coarray/stop_end_team_1.f90 new file mode 100644 index 000000000000..79e7d246f577 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/coarray/stop_end_team_1.f90 @@ -0,0 +1,28 @@ +! { dg-do run } +! { dg-skip-if "CHANGE TEAM needs a coarray library" { *-*-* } { "-fcoarray=single" } { "" } } +! +! In a team with a stopped image, SYNC ALL (STAT=) on some images must not +! pair with END TEAM on the others. + +program stop_end_team_1 + use iso_fortran_env, only : team_type, stat_stopped_image + implicit none + type(team_type) :: t + integer :: me, st, k + + me = 2 - mod (this_image (), 2) + form team (me, t) + change team (t) + sync all + if (me == 1 .and. num_images () > 1 .and. this_image () == num_images ()) stop + if (me == 1 .and. mod (this_image (), 2) == 0) then + do k = 1, 3 + sync all (stat=st) + if (st /= 0 .and. st /= stat_stopped_image) error stop 1 + end do + end if + end team + st = -1 + sync all (stat=st) + if (num_images () > 2 .and. st /= stat_stopped_image) error stop 2 +end program stop_end_team_1 diff --git a/gcc/testsuite/gfortran.dg/coarray/stop_sync_1.f90 b/gcc/testsuite/gfortran.dg/coarray/stop_sync_1.f90 index cb41610aaf97..ee2d8426ba4c 100644 --- a/gcc/testsuite/gfortran.dg/coarray/stop_sync_1.f90 +++ b/gcc/testsuite/gfortran.dg/coarray/stop_sync_1.f90 @@ -1,9 +1,10 @@ ! { dg-do run } ! ! A normal STOP on one image must not block the surviving images in the -! SYNC ALL statements that follow. +! SYNC ALL statements that follow, which report STAT_STOPPED_IMAGE. program stop_sync_1 + use iso_fortran_env, only : stat_stopped_image implicit none integer :: i, st @@ -14,4 +15,5 @@ program stop_sync_1 st = 0 sync all (stat=st) end do + if (num_images () > 1 .and. st /= stat_stopped_image) error stop 1 end program stop_sync_1 diff --git a/gcc/testsuite/gfortran.dg/coarray/stop_sync_team_1.f90 b/gcc/testsuite/gfortran.dg/coarray/stop_sync_team_1.f90 new file mode 100644 index 000000000000..9eba00e7b102 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/coarray/stop_sync_team_1.f90 @@ -0,0 +1,32 @@ +! { dg-do run } +! { dg-skip-if "CHANGE TEAM needs a coarray library" { *-*-* } { "-fcoarray=single" } { "" } } +! +! An image stopping in one team is a stopped image for SYNC ALL and SYNC +! TEAM in that team only, not in its sibling team. + +program stop_sync_team_1 + use iso_fortran_env, only : team_type, stat_stopped_image + implicit none + type(team_type) :: t + integer :: i, st, me + + if (num_images () < 4) stop + me = 2 - mod (this_image (), 2) + form team (me, t) + change team (t) + sync all + if (me == 1 .and. this_image () == num_images ()) stop + + do i = 1, 5 + st = -1 + sync all (stat=st) + if (me == 2 .and. st /= 0) error stop 1 + end do + if (me == 1 .and. st /= stat_stopped_image) error stop 2 + + st = -1 + sync team (get_team (), stat=st) + if (me == 2 .and. st /= 0) error stop 3 + if (me == 1 .and. st /= stat_stopped_image) error stop 4 + end team +end program stop_sync_team_1 diff --git a/gcc/testsuite/gfortran.dg/coarray/sync_memory_stopped_1.f90 b/gcc/testsuite/gfortran.dg/coarray/sync_memory_stopped_1.f90 new file mode 100644 index 000000000000..dd400fd5911a --- /dev/null +++ b/gcc/testsuite/gfortran.dg/coarray/sync_memory_stopped_1.f90 @@ -0,0 +1,25 @@ +! { dg-do run } +! +! SYNC ALL (STAT=) with a stopped image in the team has the effect of +! SYNC MEMORY: it must not wait for the other images (F2023 11.7.11). + +program sync_memory_stopped_1 + use iso_fortran_env, only : stat_stopped_image + implicit none + integer :: s + + if (num_images () < 3) stop + sync all + if (this_image () == 3) stop + do while (image_status (3) /= stat_stopped_image) + end do + s = -1 + if (this_image () == 1) then + sync all (stat=s) + sync images (2) + else if (this_image () == 2) then + sync images (1) + sync all (stat=s) + end if + if (this_image () <= 2 .and. s /= stat_stopped_image) error stop 1 +end program sync_memory_stopped_1 diff --git a/libgfortran/caf/shmem.c b/libgfortran/caf/shmem.c index 89fad8a8f4b3..00d851ab5395 100644 --- a/libgfortran/caf/shmem.c +++ b/libgfortran/caf/shmem.c @@ -483,7 +483,9 @@ _gfortran_caf_sync_all (int *stat, char *errmsg, size_t errmsg_len) __asm__ __volatile__ ("":::"memory"); HEALTH_CHECK (stat, errmsg, errmsg_len); CHECK_TEAM_INTEGRITY (caf_current_team); - sync_all (); + /* With a stopped image, SYNC ALL only has the effect of SYNC MEMORY. */ + if (!sync_all ()) + HEALTH_CHECK (stat, errmsg, errmsg_len); } @@ -543,7 +545,7 @@ _gfortran_caf_sync_images (int count, int images[], int *stat, char *errmsg, if (mapped_images[c] == mapped_images[i]) { caf_internal_error ("SYNC IMAGES: Duplicate image %d in " - "images at position %d and &d.", + "images at position %d and %d.", stat, errmsg, errmsg_len, images[c], i + 1, c + 1); /* There is no official error code for this, but 3 is what @@ -565,7 +567,10 @@ _gfortran_caf_sync_images (int count, int images[], int *stat, char *errmsg, __asm__ __volatile__ ("" ::: "memory"); sync_table (&local->si, mapped_images, count); - HEALTH_CHECK (stat, errmsg, errmsg_len); + if (count > 0) + check_health (mapped_images, count, stat, errmsg, errmsg_len); + else + HEALTH_CHECK (stat, errmsg, errmsg_len); } extern void _gfortran_report_exception (void); @@ -585,7 +590,7 @@ mark_stopped (void) = IMAGE_SUCCESS; atomic_fetch_add (&this_image.supervisor->finished_images, 1); } - leave_teams (); + leave_teams (true); } /* Tell the supervisor that this image error stopped, so that it can terminate @@ -650,7 +655,7 @@ _gfortran_caf_fail_image (void) fputs ("IMAGE FAILED!\n", stderr); this_image.supervisor->images[this_image.image_num].status = IMAGE_FAILED; atomic_fetch_add (&this_image.supervisor->failed_images, 1); - leave_teams (); + leave_teams (false); exit (0); } @@ -847,6 +852,9 @@ _gfortran_caf_co_broadcast (gfc_descriptor_t *desc, int source_image, int *stat, if (stat) *stat = 0; + if (HEALTH_CHECK (stat, errmsg, errmsg_len)) + return; + if (!check_map_team (&mapped_index, &this_image_index, source_image, NULL, NULL, stat)) return; @@ -942,6 +950,9 @@ _gfortran_caf_co_sum (gfc_descriptor_t *desc, int result_image, int *stat, if (stat) *stat = 0; + if (HEALTH_CHECK (stat, errmsg, errmsg_len)) + return; + /* If result_image == 0 then allreduce is wanted, i.e. mapped_index = -1. */ if (result_image && !check_map_team (&mapped_index, &this_image_index, result_image, NULL, @@ -964,6 +975,9 @@ _gfortran_caf_co_min (gfc_descriptor_t *desc, int result_image, int *stat, if (stat) *stat = 0; + + if (HEALTH_CHECK (stat, errmsg, errmsg_len)) + return; /* If result_image == 0 then allreduce is wanted, i.e. mapped_index = -1. */ if (result_image && !check_map_team (&mapped_index, &this_image_index, result_image, NULL, @@ -986,6 +1000,9 @@ _gfortran_caf_co_max (gfc_descriptor_t *desc, int result_image, int *stat, if (stat) *stat = 0; + + if (HEALTH_CHECK (stat, errmsg, errmsg_len)) + return; /* If result_image == 0 then allreduce is wanted, i.e. mapped_index = -1. */ if (result_image && !check_map_team (&mapped_index, &this_image_index, result_image, NULL, @@ -1008,6 +1025,9 @@ _gfortran_caf_co_reduce (gfc_descriptor_t *desc, void *(*opr) (void *, void *), if (stat) *stat = 0; + if (HEALTH_CHECK (stat, errmsg, errmsg_len)) + return; + /* If result_image == 0 then allreduce is wanted, i.e. mapped_index = -1. */ if (result_image && !check_map_team (&mapped_index, &this_image_index, result_image, NULL, @@ -1936,7 +1956,10 @@ _gfortran_caf_sync_team (caf_team_t team, int *stat, char *errmsg, return; } - sync_team (team_to_sync); + TEAM_HEALTH_CHECK (team_to_sync, stat, errmsg, errmsg_len); + /* With a stopped image, SYNC TEAM only has the effect of SYNC MEMORY. */ + if (!sync_team_unless_stopped (team_to_sync)) + TEAM_HEALTH_CHECK (team_to_sync, stat, errmsg, errmsg_len); } int diff --git a/libgfortran/caf/shmem/collective_subroutine.c b/libgfortran/caf/shmem/collective_subroutine.c index 01389b18b0a5..f97789cab1c3 100644 --- a/libgfortran/caf/shmem/collective_subroutine.c +++ b/libgfortran/caf/shmem/collective_subroutine.c @@ -22,6 +22,7 @@ a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see . */ +#include "../caf_error.h" #include "collective_subroutine.h" #include "supervisor.h" #include "teams_mgmt.h" @@ -219,12 +220,17 @@ get_collsub_buf (size_t size) } /* This function syncs all images with one another. It will only return once - all images have called it. */ + all images have called it. The reduction is laid out over a fixed set of + images, so it cannot be completed once an image of the team terminated. */ static void collsub_sync (void) { - counter_barrier_wait (&caf_current_team->u.image_info->collsub.barrier); + counter_barrier *barrier = &caf_current_team->u.image_info->collsub.barrier; + + if (!counter_barrier_wait_abortable (barrier)) + caf_runtime_error ("Image terminated while executing a collective " + "subroutine"); } typedef void *(*red_op) (void *, void *); diff --git a/libgfortran/caf/shmem/counter_barrier.c b/libgfortran/caf/shmem/counter_barrier.c index 1993b1ebeea6..8598d79d69dc 100644 --- a/libgfortran/caf/shmem/counter_barrier.c +++ b/libgfortran/caf/shmem/counter_barrier.c @@ -48,35 +48,80 @@ unlock_counter_barrier (counter_barrier *b) void counter_barrier_init (counter_barrier *b, int val) { - *b = (counter_barrier) {CAF_SHMEM_MUTEX_INITIALIZER, - CAF_SHMEM_COND_INITIALIZER, val, 0, val}; + *b = (counter_barrier) {.mutex = CAF_SHMEM_MUTEX_INITIALIZER, + .cond = CAF_SHMEM_COND_INITIALIZER, + .wait_count = val, + .curr_wait_group = 1, + .aborted_round = 0, + .abortable_arrivals = 0, + .aborting = false, + .count = val}; initialize_shared_condition (&b->cond, val); initialize_shared_mutex (&b->mutex); } +/* Start the next round of the barrier and wake the images waiting in the + current one. */ + +static void +next_round (counter_barrier *b, bool abort) +{ + if (abort) + b->aborted_round = b->curr_wait_group; + ++b->curr_wait_group; + b->wait_count = b->count; + b->abortable_arrivals = 0; + caf_shmem_cond_broadcast (&b->cond); +} + +/* Take part in the current round of the barrier, with its lock held. Returns + false, when the round was aborted. */ + +static bool +wait_round (counter_barrier *b, bool abortable) +{ + const uint64_t round = b->curr_wait_group; + + if (abortable) + ++b->abortable_arrivals; + --b->wait_count; + while (b->wait_count > 0 && b->curr_wait_group == round) + caf_shmem_cond_wait (&b->cond, &b->mutex); + + /* The last image to arrive, or to be woken after the count dropped, ends + the round. */ + if (b->curr_wait_group == round) + next_round (b, false); + + return b->aborted_round != round; +} + void counter_barrier_wait (counter_barrier *b) { - int wait_group_beginning; - lock_counter_barrier (b); - wait_group_beginning = b->curr_wait_group; - - if ((--b->wait_count) <= 0) - caf_shmem_cond_broadcast (&b->cond); - else - { - while (b->wait_count > 0 && b->curr_wait_group == wait_group_beginning) - caf_shmem_cond_wait (&b->cond, &b->mutex); - } + while (!wait_round (b, false)) + ; + unlock_counter_barrier (b); +} - if (b->wait_count <= 0) - { - b->curr_wait_group = !wait_group_beginning; - b->wait_count = b->count; - } +bool +counter_barrier_wait_abortable (counter_barrier *b) +{ + bool completed; + lock_counter_barrier (b); + completed = !b->aborting && wait_round (b, true); unlock_counter_barrier (b); + return completed; +} + +void +counter_barrier_abort_locked (counter_barrier *b) +{ + b->aborting = true; + if (b->abortable_arrivals) + next_round (b, true); } static inline void diff --git a/libgfortran/caf/shmem/counter_barrier.h b/libgfortran/caf/shmem/counter_barrier.h index 7d7c724ae060..7b6d3d88e711 100644 --- a/libgfortran/caf/shmem/counter_barrier.h +++ b/libgfortran/caf/shmem/counter_barrier.h @@ -27,6 +27,9 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see #include "thread_support.h" +#include +#include + /* Usable as counter barrier and as waitable counter. This "class" allows to sync all images acting as a barrier. For this the counter_barrier is to be initialized by the number of images and then later @@ -44,7 +47,14 @@ typedef struct caf_shmem_mutex mutex; caf_shmem_condvar cond; volatile int wait_count; - volatile int curr_wait_group; + /* The number of the current round of the barrier, and of the last round + that was aborted. */ + volatile uint64_t curr_wait_group; + volatile uint64_t aborted_round; + /* The number of abortable arrivals in the current round. */ + volatile int abortable_arrivals; + /* Set once abortable arrivals are no longer to be synchronized. */ + volatile bool aborting; volatile int count; } counter_barrier; @@ -73,8 +83,19 @@ void counter_barrier_init_add (counter_barrier *, int); int counter_barrier_get_count (counter_barrier *); -/* Wait for the count in the barrier drop to or below 0. */ +/* Wait for the count in the barrier drop to or below 0. When the round is + aborted, take part in the next one. */ void counter_barrier_wait (counter_barrier *); +/* Like counter_barrier_wait, but return false without waiting when the + barrier is aborting, or when the round is aborted. */ + +bool counter_barrier_wait_abortable (counter_barrier *); + +/* Abort the current round when it has an abortable arrival, and every later + abortable arrival. The barrier's lock has to be held. */ + +void counter_barrier_abort_locked (counter_barrier *); + #endif diff --git a/libgfortran/caf/shmem/sync.c b/libgfortran/caf/shmem/sync.c index f1d5bedbc8e1..511a85254244 100644 --- a/libgfortran/caf/shmem/sync.c +++ b/libgfortran/caf/shmem/sync.c @@ -128,10 +128,10 @@ sync_table (sync_t *si, int *images, int size) unlock_table (si); } -void +bool sync_all (void) { - counter_barrier_wait (&caf_current_team->u.image_info->image_count); + return sync_team_unless_stopped (caf_current_team); } void @@ -140,6 +140,12 @@ sync_team (caf_shmem_team_t team) counter_barrier_wait (&team->u.image_info->image_count); } +bool +sync_team_unless_stopped (caf_shmem_team_t team) +{ + return counter_barrier_wait_abortable (&team->u.image_info->image_count); +} + void lock_event (sync_t *si) { diff --git a/libgfortran/caf/shmem/sync.h b/libgfortran/caf/shmem/sync.h index 6f8b28d378a3..0aa596c9eff1 100644 --- a/libgfortran/caf/shmem/sync.h +++ b/libgfortran/caf/shmem/sync.h @@ -51,7 +51,10 @@ void sync_init (sync_t *, shared_memory); void sync_init_supervisor (sync_t *, alloc *); -void sync_all (void); +/* Synchronize the images of the current team. Returns false without + synchronizing when a stopped image is a member of the team. */ + +bool sync_all (void); /* Prototype for circular dependency break. */ @@ -60,6 +63,10 @@ typedef struct caf_shmem_team *caf_shmem_team_t; void sync_team (caf_shmem_team_t team); +/* Like sync_all for TEAM. */ + +bool sync_team_unless_stopped (caf_shmem_team_t team); + void sync_table (sync_t *, int *, int); void lock_alloc_lock (sync_t *); diff --git a/libgfortran/caf/shmem/teams_mgmt.c b/libgfortran/caf/shmem/teams_mgmt.c index 02f37f285908..d90ece310baf 100644 --- a/libgfortran/caf/shmem/teams_mgmt.c +++ b/libgfortran/caf/shmem/teams_mgmt.c @@ -28,65 +28,119 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see caf_shmem_team_t caf_current_team = NULL, caf_initial_team; caf_shmem_team_t caf_teams_formed = NULL; -void -update_teams_images (caf_shmem_team_t team) +/* Count the images among the COUNT images in MAP that have status STATUS. */ + +static int +count_images (const int *map, int count, image_status status) +{ + int i, n = 0; + + for (i = 0; i < count; ++i) + if (this_image.supervisor->images[map[i]].status == status) + ++n; + + return n; +} + +/* Get the number of images of TEAM that have terminated. */ + +static int +team_terminated_images (caf_shmem_team_t team) +{ + const int sz = team->u.image_info->image_map_size; + int i, term = 0; + + for (i = 0; i < sz; ++i) + if (this_image.supervisor->images[team->u.image_info->image_map[i]].status + != IMAGE_OK) + ++term; + + return term; +} + +static void +update_teams_images_locked (caf_shmem_team_t team) { - caf_shmem_mutex_lock (&team->u.image_info->image_count.mutex); if (team->u.image_info->num_term_images != this_image.supervisor->finished_images + this_image.supervisor->failed_images) { const int old_num = team->u.image_info->num_term_images; - const int sz = team->u.image_info->image_map_size; - int i, good = 0; - - for (i = 0; i < sz; ++i) - if (this_image.supervisor->images[team->u.image_info->image_map[i]] - .status - == IMAGE_OK) - ++good; - team->u.image_info->num_term_images = sz - good; + team->u.image_info->num_term_images = team_terminated_images (team); counter_barrier_add_locked (&team->u.image_info->image_count, old_num - team->u.image_info->num_term_images); } +} + +void +update_teams_images (caf_shmem_team_t team) +{ + caf_shmem_mutex_lock (&team->u.image_info->image_count.mutex); + update_teams_images_locked (team); caf_shmem_mutex_unlock (&team->u.image_info->image_count.mutex); } +/* Drop this image from the barriers of TEAM. */ + +static void +leave_team (caf_shmem_team_t team, bool stopped) +{ + counter_barrier *b = &team->u.image_info->image_count; + counter_barrier *cb = &team->u.image_info->collsub.barrier; + + caf_shmem_mutex_lock (&b->mutex); + update_teams_images_locked (team); + if (stopped) + counter_barrier_abort_locked (b); + caf_shmem_mutex_unlock (&b->mutex); + + caf_shmem_mutex_lock (&cb->mutex); + counter_barrier_abort_locked (cb); + caf_shmem_mutex_unlock (&cb->mutex); +} + void -leave_teams (void) +leave_teams (bool stopped) { for (caf_shmem_team_t t = caf_current_team; t; t = t->parent) - update_teams_images (t); + leave_team (t, stopped); for (caf_shmem_team_t t = caf_teams_formed; t; t = t->parent) - update_teams_images (t); + leave_team (t, stopped); } -void -check_health (int *stat, char *errmsg, size_t errmsg_len) +int +check_health (const int *map, int count, int *stat, char *errmsg, + size_t errmsg_len) { - if (this_image.supervisor->finished_images - || this_image.supervisor->failed_images) + int stopped = 0, failed = 0; + + if (this_image.supervisor->finished_images) + stopped = count_images (map, count, IMAGE_SUCCESS); + if (this_image.supervisor->failed_images) + failed = count_images (map, count, IMAGE_FAILED); + + if (stopped) { - if (this_image.supervisor->finished_images) - { - caf_internal_error ("Stopped images present (currently %d)", stat, - errmsg, errmsg_len, - this_image.supervisor->finished_images); - if (stat) - *stat = CAF_STAT_STOPPED_IMAGE; - } - else if (this_image.supervisor->failed_images) - { - caf_internal_error ("Failed images present (currently %d)", stat, - errmsg, errmsg_len, - this_image.supervisor->failed_images); - if (stat) - *stat = CAF_STAT_FAILED_IMAGE; - } + caf_internal_error ("Stopped images present (currently %d)", stat, + errmsg, errmsg_len, stopped); + if (stat) + *stat = CAF_STAT_STOPPED_IMAGE; + return CAF_STAT_STOPPED_IMAGE; } - else if (stat) + + if (failed) + { + caf_internal_error ("Failed images present (currently %d)", stat, + errmsg, errmsg_len, failed); + if (stat) + *stat = CAF_STAT_FAILED_IMAGE; + return CAF_STAT_FAILED_IMAGE; + } + + if (stat) *stat = 0; + return 0; } diff --git a/libgfortran/caf/shmem/teams_mgmt.h b/libgfortran/caf/shmem/teams_mgmt.h index 8478281f5d2e..3b0c3b6aa225 100644 --- a/libgfortran/caf/shmem/teams_mgmt.h +++ b/libgfortran/caf/shmem/teams_mgmt.h @@ -88,12 +88,27 @@ void update_teams_images (caf_shmem_team_t); /* Drop this image, which terminated, from the barriers of all teams it is a member of. The number of finished or failed images has to be updated - before the call for it to have any effect. */ + before the call for it to have any effect. When STOPPED, image control + statements and collective subroutines no longer synchronize with the other + images of these teams. Otherwise only collective subroutines do not. */ -void leave_teams (void); +void leave_teams (bool stopped); -void check_health (int *, char *, size_t); +/* Set STAT for the stopped or failed images among the COUNT images in MAP. + Returns the stat value. */ -#define HEALTH_CHECK(stat, errmsg, errlen) check_health (stat, errmsg, errlen) +int check_health (const int *map, int count, int *stat, char *errmsg, + size_t errmsg_len); + +/* Perform the health check on the specified team. */ + +#define TEAM_HEALTH_CHECK(team, stat, errmsg, errlen) \ + check_health ((team)->u.image_info->image_map, \ + (team)->u.image_info->image_map_size, stat, errmsg, errlen) + +/* Perform the health check on the current team. */ + +#define HEALTH_CHECK(stat, errmsg, errlen) \ + TEAM_HEALTH_CHECK (caf_current_team, stat, errmsg, errlen) #endif From 7c153b773bbd987c3f4e02ac43d4145fe74d1446 Mon Sep 17 00:00:00 2001 From: GCC Administrator Date: Fri, 25 Sep 2026 00:16:32 +0000 Subject: [PATCH 403/584] Daily bump. --- gcc/ChangeLog | 77 ++++++++++++++++++++++++++++ gcc/DATESTAMP | 2 +- gcc/algol68/ChangeLog | 5 ++ gcc/c-family/ChangeLog | 11 ++++ gcc/testsuite/ChangeLog | 108 ++++++++++++++++++++++++++++++++++++++++ libgcobol/ChangeLog | 5 ++ libgfortran/ChangeLog | 63 +++++++++++++++++++++++ libgomp/ChangeLog | 5 ++ 8 files changed, 275 insertions(+), 1 deletion(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 3d767aed8421..e472484a2211 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,80 @@ +2026-09-24 Jakub Jelinek + + PR c++/126848 + * flag-types.h (enum auto_init_type): Change AUTO_INIT_CXX26 + value from 3 to 4. + * gimplify.cc (gimplify_decl_expr): Mask off AUTO_INIT_CXX26 bit + before comparing to AUTO_INIT_PATTERN. + (gimplify_target_expr): Likewise. + * internal-fn.cc (expand_DEFERRED_INIT): Likewise. Formatting fix. + * opts.cc (finish_options): For -fhardened or in AUTO_INIT_CXX26 + bit from previous value if it was set. Mask off AUTO_INIT_CXX26 bit + before comparing to AUTO_INIT_ZERO. + * tree-ssa-ccp.cc (likely_value): Return VARYING rather than UNDEFINED + for .DEFERRED_INIT call with AUTO_INIT_CXX26 bit set in the second + argument. + * tree-ssa.cc (ssa_undefined_value_p): Return false rather than true + for .DEFERRED_INIT call with AUTO_INIT_CXX26 bit set in the second + argument. + * tree-ssa-uninit.cc (has_undefined_value_p): Return true for + SSA_NAMEs with .DEFERRED_INIT call as SSA_NAME_DEF_STMT. + +2026-09-24 Paul-Antoine Arras + + * tree-pretty-print.cc (dump_omp_iterators): Print OMP_ITERATOR_BLOCK. + +2026-09-24 Andrew Stubbs + + * gdbhooks.py (Rtx): Decode more things. + (RtxPrinter): Improve output. + (build_pretty_printer): Match more rtx types. + +2026-09-24 Andrew Stubbs + + PR target/127542 + * config/gcn/gcn-valu.md (2): Add + "popcount_extra_op". + +2026-09-24 Tamar Christina + + PR tree-optimization/127579 + * tree-vect-loop.cc (info_for_reduction): Add assert. + * tree-vect-stmts.cc (vectorizable_operation): Pass SLP node. + +2026-09-24 Kyrylo Tkachov + + * config/i386/i386-features.cc + (rest_of_insert_endbr_and_patchable_area): + Reuse an existing ENDBR. + +2026-09-24 Uros Bizjak + + * doc/install.texi (Installing GCC): Change node pointer from + Binaries to Specific. + (Specific): Move to directly follow Installing GCC. + Update node pointers accordingly. + (Binaries): Move to follow Specific. + Update node pointers accordingly. + * doc/include/fdl.texi (GNU Free Documentation License): Under + @ifset gfdlhtml, change node pointer from Specific to Binaries + to match install.texi's chapter order. + +2026-09-24 Richard Biener + + PR target/127268 + * config/i386/i386.cc (ix86_default_vector_cost): For + integer mode vec_to_scalar add sse_to_integer cost. + +2026-09-24 Richard Biener + + PR tree-optimization/127571 + * tree-ssa-sccvn.cc (vn_walk_cb_data::push_partial_def): + Re-associate offset computation to avoid overflow. + +2026-09-24 Pan Li + + * config/riscv/vector.md: Leverage Wvr constraint. + 2026-09-23 Jeff Law * config/v850/v850.cc (v850_print_oprerand): Handle operands diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index 0d3a0d16876a..147e2265a569 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20260924 +20260925 diff --git a/gcc/algol68/ChangeLog b/gcc/algol68/ChangeLog index 0d55cccaaa28..d0446d95ce54 100644 --- a/gcc/algol68/ChangeLog +++ b/gcc/algol68/ChangeLog @@ -1,3 +1,8 @@ +2026-09-24 Jose E. Marchesi + + * a68-parser-moids-equivalence.cc (are_modes_equivalent): Do not + string-compare INDICANTs. + 2026-09-22 Jose E. Marchesi * a68-low.cc (lower_module_text): Mark prelude_decl an diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog index 4d330ce5476b..b822ded19f57 100644 --- a/gcc/c-family/ChangeLog +++ b/gcc/c-family/ChangeLog @@ -1,3 +1,14 @@ +2026-09-24 Jakub Jelinek + + PR c++/126848 + * c-opts.cc (c_common_post_options): For -ftrivial-auto-var-init=zero + or -ftrivial-auto-var-init=pattern in C++26 or later mode set + AUTO_INIT_CXX26 bit in flag_auto_var_init. + +2026-09-24 Josef Melcr + + * c-attribs.cc (handle_callback_only_attribute): Clean up old code. + 2026-09-22 Chung-Lin Tang * c-pragma.h (enum pragma_omp_clause): Add PRAGMA_OMP_CLAUSE_LOCAL. diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index bf5555cee3ec..ff25481710eb 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,111 @@ +2026-09-24 Jerry DeLisle + + PR libfortran/127347 + * gfortran.dg/coarray/stop_sync_1.f90: Check STAT=. + * gfortran.dg/coarray/collective_stopped_1.f90: New test. + * gfortran.dg/coarray/stop_end_team_1.f90: New test. + * gfortran.dg/coarray/stop_sync_team_1.f90: New test. + * gfortran.dg/coarray/sync_memory_stopped_1.f90: New test. + +2026-09-24 Jerry DeLisle + + PR libfortran/127347 + * gfortran.dg/coarray/fail_image_sync_1.f90: New test. + * gfortran.dg/coarray/stop_sync_1.f90: New test. + * gfortran.dg/coarray/sync_images_stopped_1.f90: New test. + +2026-09-24 Jerry DeLisle + + PR libfortran/127347 + * gfortran.dg/coarray/error_stop_1.f90: New test. + +2026-09-24 Jose E. Marchesi + + * algol68/compile/mode-shadow-1.a68: New test. + +2026-09-24 Jakub Jelinek + + PR c++/126848 + * c-c++-common/auto-init-1.c: Use [15] instead of 1 or [26] instead of + 2 in regexps matching second .DEFERRED_INIT arguments. + * c-c++-common/auto-init-2.c: Likewise. + * c-c++-common/auto-init-3.c: Likewise. + * c-c++-common/auto-init-4.c: Likewise. + * c-c++-common/auto-init-5.c: Likewise. + * c-c++-common/auto-init-6.c: Likewise. + * c-c++-common/auto-init-7.c: Likewise. + * c-c++-common/auto-init-8.c: Likewise. + * c-c++-common/auto-init-9.c: Likewise. + * c-c++-common/auto-init-10.c: Likewise. + * c-c++-common/auto-init-11.c: Likewise. + * c-c++-common/auto-init-12.c: Likewise. + * c-c++-common/auto-init-13.c: Likewise. + * c-c++-common/auto-init-14.c: Likewise. + * c-c++-common/auto-init-15.c: Likewise. + * c-c++-common/auto-init-16.c: Likewise. + * c-c++-common/auto-init-esra.c: Likewise. + * c-c++-common/auto-init-padding-1.c: Likewise. + * g++.dg/cpp26/erroneous7.C: New test. + * g++.dg/cpp26/erroneous8.C: New test. + * g++.dg/cpp26/erroneous9.C: New test. + +2026-09-24 Tamar Christina + + PR tree-optimization/127579 + * gcc.target/aarch64/pr127579.c: New test. + +2026-09-24 Kyrylo Tkachov + + * gcc.target/i386/cet-switch-4.c: New test. + +2026-09-24 Richard Biener + + PR target/127268 + * gcc.target/i386/vect-bb-reduc-1.c: New testcase. + +2026-09-24 Pan Li + + * gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-m1.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-m2.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-m4.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-mf2.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f16-mf4.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-m1.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-m2.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-m4.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwmul_vv-f32-mf2.c: New test. + +2026-09-24 Pan Li + + * gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-m1.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-m2.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-m4.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-mf2.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f16-mf4.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-m1.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-m2.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-m4.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwsub_vv-f32-mf2.c: New test. + +2026-09-24 Pan Li + + * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-m1.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-m2.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-m4.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-mf2.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f16-mf4.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-m1.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-m2.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-m4.c: New test. + * gcc.target/riscv/rvv/autovec/group_overlap/vfwadd_vv-f32-mf2.c: New test. + +2026-09-24 Robert Dubner + + * cobol.dg/group2/Passing_ADDRESS_OF_parameter.cob: New test. + * cobol.dg/group2/Passing_ADDRESS_OF_parameter.out: New test. + * cobol.dg/group2/Repository_uber_alles.cob: New test. + * cobol.dg/group2/Repository_uber_alles.out: New test. + 2026-09-23 Robert Dubner * cobol.dg/group2/CBL_READ_FILE__check_file_size_with_flags___128.cob: diff --git a/libgcobol/ChangeLog b/libgcobol/ChangeLog index fd41284d80bc..72ada3fd4121 100644 --- a/libgcobol/ChangeLog +++ b/libgcobol/ChangeLog @@ -1,3 +1,8 @@ +2026-09-24 Robert Dubner + + * libgcobol.cc (find_in_dirs): Use the cached array. + (function_handle_from_cobpath): Create the cached array. + 2026-09-23 Robert Dubner * libgcobol.cc (do_the_dl_thing): Implement the updated policies. diff --git a/libgfortran/ChangeLog b/libgfortran/ChangeLog index f93972759de9..5d6ea44c4452 100644 --- a/libgfortran/ChangeLog +++ b/libgfortran/ChangeLog @@ -1,3 +1,66 @@ +2026-09-24 Jerry DeLisle + + PR libfortran/127347 + * caf/shmem.c (_gfortran_caf_sync_all, _gfortran_caf_sync_team): + Have the effect of SYNC MEMORY with a stopped image. Check the + images of the team synchronized. + (_gfortran_caf_sync_images): Check the images synchronized. Fix + the format of the duplicate image error. + (mark_stopped, _gfortran_caf_fail_image): Tell leave_teams whether + the image stopped. + (_gfortran_caf_co_broadcast, _gfortran_caf_co_sum) + (_gfortran_caf_co_min, _gfortran_caf_co_max) + (_gfortran_caf_co_reduce): Report terminated images of the team. + * caf/shmem/collective_subroutine.c (collsub_sync): Give up when an + image of the team terminated. + * caf/shmem/counter_barrier.c (counter_barrier_init): Initialize the + new fields. + (next_round, wait_round): New functions. + (counter_barrier_wait): Use wait_round. Take part in the next round + when a round is aborted. + (counter_barrier_wait_abortable, counter_barrier_abort_locked): New + functions. + * caf/shmem/counter_barrier.h (counter_barrier): Make + curr_wait_group a round number. Add aborted_round, + abortable_arrivals and aborting. + (counter_barrier_wait_abortable, counter_barrier_abort_locked): + Declare. + * caf/shmem/sync.c (sync_all): Return whether the images were + synchronized. + (sync_team_unless_stopped): New function. + * caf/shmem/sync.h (sync_all): Adjust. + (sync_team_unless_stopped): Declare. + * caf/shmem/teams_mgmt.c (count_images, team_terminated_images) + (update_teams_images_locked, leave_team): New functions. + (update_teams_images): Use update_teams_images_locked. + (leave_teams): Add stopped argument. Use leave_team. + (check_health): Classify the given images. Return the stat value. + * caf/shmem/teams_mgmt.h (leave_teams, check_health): Adjust. + (TEAM_HEALTH_CHECK): New macro. + (HEALTH_CHECK): Use it. + +2026-09-24 Jerry DeLisle + + PR libfortran/127347 + * caf/shmem.c (mark_stopped): New function. + (_gfortran_caf_stop_numeric, _gfortran_caf_stop_str): Call it. + (_gfortran_caf_fail_image): Call leave_teams. + * caf/shmem/supervisor.c (supervisor_main_loop): Keep the status an + image recorded for itself. + * caf/shmem/sync.c (sync_table): Use the total number of images as + the row stride. Handle an image list and all images alike. + * caf/shmem/teams_mgmt.c (leave_teams): New function. + * caf/shmem/teams_mgmt.h (leave_teams): Declare. + +2026-09-24 Jerry DeLisle + + PR libfortran/127347 + * caf/shmem.c (mark_error_stopped): New function. + (_gfortran_caf_error_stop_str, _gfortran_caf_error_stop): Call it. + * caf/shmem/supervisor.c (supervisor_main_loop): Terminate all + images when an image error stopped. + * caf/shmem/supervisor.h (image_status): Add IMAGE_ERROR_STOP. + 2026-09-06 Jerry DeLisle PR fortran/126964 diff --git a/libgomp/ChangeLog b/libgomp/ChangeLog index 8c00ae010636..cd673ea1de13 100644 --- a/libgomp/ChangeLog +++ b/libgomp/ChangeLog @@ -1,3 +1,8 @@ +2026-09-24 Jakub Jelinek + + * alloc.c (gomp_aligned_alloc): Check for overflows in the + _aligned_malloc case and in the last fallback. + 2026-09-22 Chung-Lin Tang * testsuite/libgomp.c-c++-common/declare-target-local-1.c: New test. From aa141f17fbab704e17e6c6cc046db91155b7bd21 Mon Sep 17 00:00:00 2001 From: Andrea Pinski Date: Thu, 24 Sep 2026 21:15:41 +0000 Subject: [PATCH 404/584] aarch64: Fix aarch64_evpc_rev64_ext for testing_p case [PR127599] r17-3712-g4182cf11e1e3d2 added some code to expand a perm based on if we are in a loop or not. The problem is in the testing case, the expanding stmt might not have a bb associated with it and that causes an ICE. This fixes the issue by moving the check for testing before the test of inside the loop. Pushed as obvious after bootstrapped and testing on aarch64-linux-gnu. PR target/127599 gcc/ChangeLog: * config/aarch64/aarch64.cc (aarch64_evpc_rev64_ext): Move the testing_p after the is_bb_in_loop test. gcc/testsuite/ChangeLog: * gcc.dg/torture/pr127599-1.c: New testcase. * gcc.target/aarch64/advsimd-intrinsics/pr127599-1.c: New testcase. Signed-off-by: Andrea Pinski --- gcc/config/aarch64/aarch64.cc | 6 +++--- gcc/testsuite/gcc.dg/torture/pr127599-1.c | 9 +++++++++ .../aarch64/advsimd-intrinsics/pr127599-1.c | 11 +++++++++++ 3 files changed, 23 insertions(+), 3 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/torture/pr127599-1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/pr127599-1.c diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc index 2ca834c92b16..705c5378bac6 100644 --- a/gcc/config/aarch64/aarch64.cc +++ b/gcc/config/aarch64/aarch64.cc @@ -28509,12 +28509,12 @@ aarch64_evpc_rev64_ext (struct expand_vec_perm_d *d) if (!d->perm.series_p (0, 1, nelt - 1, -1)) return false; - if (is_bb_in_loop (gimple_bb (currently_expanding_gimple_stmt))) - return false; - if (d->testing_p) return true; + if (is_bb_in_loop (gimple_bb (currently_expanding_gimple_stmt))) + return false; + rtx tmp1 = gen_reg_rtx (d->vmode); rtx tmp2 = gen_reg_rtx (V16QImode); rtx unspec_rev64 diff --git a/gcc/testsuite/gcc.dg/torture/pr127599-1.c b/gcc/testsuite/gcc.dg/torture/pr127599-1.c new file mode 100644 index 000000000000..e7ad356c356c --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr127599-1.c @@ -0,0 +1,9 @@ +/* { dg-do compile } */ +/* PR target/127599 */ + +#define vector(s,t) t __attribute__((vector_size(s*sizeof(t)))) +vector(4,int) b1; +void c1() { + b1 = __builtin_shufflevector (b1, b1, 1,0,3,2); + b1 = __builtin_shufflevector (b1, b1, 2,3,4,5); +} diff --git a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/pr127599-1.c b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/pr127599-1.c new file mode 100644 index 000000000000..fdeb0f7352c5 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/pr127599-1.c @@ -0,0 +1,11 @@ +/* { dg-do compile } */ +/* { dg-additional-options "-O1" } */ +/* PR target/127599 */ + +#include + +int32x4_t b; +void c() { + b = vrev64q_s32(b); + b = vextq_s32(b, b, 2); +} From b6e2dd90a8de756ac299c38f99418d26e74a5637 Mon Sep 17 00:00:00 2001 From: Andrea Pinski Date: Thu, 24 Sep 2026 14:02:28 -0700 Subject: [PATCH 405/584] testsuite: clear the input arrays in vect-alias-check-ptr-info-2.c [PR127587] Just some uninitialized arrays causing maybe garbage as input here. So let's clear the arrays before the use. Pushed as obvious after testing the testcase still works. PR testsuite/127587 gcc/testsuite/ChangeLog: * gcc.dg/vect/vect-alias-check-ptr-info-2.c: Clear the arrays before the use of them. Signed-off-by: Andrea Pinski --- gcc/testsuite/gcc.dg/vect/vect-alias-check-ptr-info-2.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/gcc/testsuite/gcc.dg/vect/vect-alias-check-ptr-info-2.c b/gcc/testsuite/gcc.dg/vect/vect-alias-check-ptr-info-2.c index 1deda2395acb..a3ca94960802 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-alias-check-ptr-info-2.c +++ b/gcc/testsuite/gcc.dg/vect/vect-alias-check-ptr-info-2.c @@ -14,6 +14,8 @@ f (int c) { int n = hi - lo + 2; double t[n], u[n]; + __builtin_memset(t, 0, sizeof(t)); + __builtin_memset(u, 0, sizeof(u)); double *tab[2] = { t, u }; /* Load tab[idx&1] on both arms so PRE hoists it into a pretmp. */ From 2ce11ed2a2f4eeae68a5cb059307be8153448d8d Mon Sep 17 00:00:00 2001 From: Gaius Mulley Date: Fri, 25 Sep 2026 07:38:57 +0100 Subject: [PATCH 406/584] PR modula2/127567: Import in local module cannot import an external module This patch allows a local import to import an external library module providing it was imported by the main module. See tinygoodimport.mod for clarity. gcc/m2/ChangeLog: PR modula2/127567 * gm2-compiler/P1SymBuild.mod (BuildImportInnerModule): Call PutImported if sym is a defimp or module. * gm2-compiler/SymbolConversion.def (Gcc2Mod): Correct parameter name. * gm2-compiler/SymbolConversion.mod (Gcc2Mod): Ditto. * gm2-compiler/SymbolTable.mod (IsExternalModule): New procedure function. (AddSymToModuleScope): Only generate an error if the symbol is not an external module. gcc/testsuite/ChangeLog: PR modula2/127567 * gm2/imports/fail/tinybadimport.mod: New test. * gm2/imports/run/pass/tinygoodimport.mod: New test. Signed-off-by: Gaius Mulley --- gcc/m2/gm2-compiler/P1SymBuild.mod | 14 +++++++++++--- gcc/m2/gm2-compiler/SymbolConversion.def | 2 +- gcc/m2/gm2-compiler/SymbolConversion.mod | 4 ++-- gcc/m2/gm2-compiler/SymbolTable.mod | 19 ++++++++++++++++--- .../gm2/imports/fail/tinybadimport.mod | 12 ++++++++++++ .../gm2/imports/run/pass/tinygoodimport.mod | 14 ++++++++++++++ 6 files changed, 56 insertions(+), 9 deletions(-) create mode 100644 gcc/testsuite/gm2/imports/fail/tinybadimport.mod create mode 100644 gcc/testsuite/gm2/imports/run/pass/tinygoodimport.mod diff --git a/gcc/m2/gm2-compiler/P1SymBuild.mod b/gcc/m2/gm2-compiler/P1SymBuild.mod index 9316472c86b5..4a9daeeee736 100644 --- a/gcc/m2/gm2-compiler/P1SymBuild.mod +++ b/gcc/m2/gm2-compiler/P1SymBuild.mod @@ -58,7 +58,7 @@ FROM SymbolTable IMPORT NulSym, PutMode, PutFieldEnumeration, PutSubrange, PutVar, IsDefImp, IsModule, IsInnerModule, IsType, - GetCurrentModule, + GetCurrentModule, GetCurrentModuleScope, AddSymToModuleScope, AddNameToImportList, GetSym, RequestSym, IsUnknown, RenameSym, @@ -609,19 +609,27 @@ END CheckExplicitExported ; PROCEDURE BuildImportInnerModule ; VAR Sym, ModSym, + OuterMod, i, n : CARDINAL ; BEGIN PopT (n) ; (* n = # of the Ident List *) IF OperandT (n+1) = ImportTok THEN - (* Ident List contains list of objects *) + OuterMod := GetScope (GetCurrentModuleScope ()) ; + (* Ident List contains list of objects. *) i := 1 ; WHILE i<=n DO AddNameToImportList (OperandTok (i), OperandT (i)) ; + Assert (OuterMod # NulSym) ; + ModSym := GetLocalSym (OuterMod, OperandT (i)) ; + IF (ModSym # NulSym) AND (IsDefImp (ModSym) OR IsModule (ModSym)) + THEN + PutImported (ModSym) + END ; INC (i) END ELSE - (* Ident List contains list of objects *) + (* Ident List contains list of objects. *) ModSym := LookupOuterModule (OperandTok(n+1), OperandT(n+1)) ; i := 1 ; diff --git a/gcc/m2/gm2-compiler/SymbolConversion.def b/gcc/m2/gm2-compiler/SymbolConversion.def index 1aedb64ea59d..b8e355ac753a 100644 --- a/gcc/m2/gm2-compiler/SymbolConversion.def +++ b/gcc/m2/gm2-compiler/SymbolConversion.def @@ -44,7 +44,7 @@ PROCEDURE Mod2Gcc (sym: CARDINAL) : tree ; Gcc2Mod - given a gcc tree return the modula-2 symbol. *) -PROCEDURE Gcc2Mod (tree: tree) : CARDINAL ; +PROCEDURE Gcc2Mod (gcctree: tree) : CARDINAL ; (* diff --git a/gcc/m2/gm2-compiler/SymbolConversion.mod b/gcc/m2/gm2-compiler/SymbolConversion.mod index f4e0c6f0b004..4c7aa07f83ec 100644 --- a/gcc/m2/gm2-compiler/SymbolConversion.mod +++ b/gcc/m2/gm2-compiler/SymbolConversion.mod @@ -123,14 +123,14 @@ END Mod2Gcc ; Gcc2Mod - given a gcc tree return the modula-2 symbol. *) -PROCEDURE Gcc2Mod (tree: tree) : CARDINAL ; +PROCEDURE Gcc2Mod (gcctree: tree) : CARDINAL ; VAR high, i: CARDINAL ; BEGIN i := 1 ; high := HighIndice (mod2gcc) ; WHILE i <= high DO - IF GetIndice (mod2gcc, i) = tree + IF GetIndice (mod2gcc, i) = gcctree THEN RETURN i END ; diff --git a/gcc/m2/gm2-compiler/SymbolTable.mod b/gcc/m2/gm2-compiler/SymbolTable.mod index 7a0f4c249e0a..b2cb514b8643 100644 --- a/gcc/m2/gm2-compiler/SymbolTable.mod +++ b/gcc/m2/gm2-compiler/SymbolTable.mod @@ -2073,19 +2073,22 @@ BEGIN DefImpSym : IF GetSymKey(DefImp.LocalSymbols, GetSymName(Sym))=NulKey THEN PutSymKey(DefImp.LocalSymbols, GetSymName(Sym), Sym) - ELSE + ELSIF NOT IsExternalModule (Sym) + THEN MetaError1 ('{%kIMPORT} name clash with symbol {%1Ead} symbol already declared ', Sym) END | ModuleSym : IF GetSymKey(Module.LocalSymbols, GetSymName(Sym))=NulKey THEN PutSymKey(Module.LocalSymbols, GetSymName(Sym), Sym) - ELSE + ELSIF NOT IsExternalModule (Sym) + THEN MetaError1 ('{%kIMPORT} name clash with symbol {%1Ead} symbol already declared ', Sym) END | ProcedureSym: IF GetSymKey(Procedure.LocalSymbols, GetSymName(Sym))=NulKey THEN PutSymKey(Procedure.LocalSymbols, GetSymName(Sym), Sym) - ELSE + ELSIF NOT IsExternalModule (Sym) + THEN MetaError1 ('{%kIMPORT} name clash with symbol {%1Ead} symbol already declared ', Sym) END @@ -8075,6 +8078,16 @@ BEGIN END IsModule ; +(* + IsExternalModule - return TRUE if sym is an external program module or defimp module. +*) + +PROCEDURE IsExternalModule (sym: CARDINAL) : BOOLEAN ; +BEGIN + RETURN IsDefImp (sym) +END IsExternalModule ; + + (* IsInnerModule - returns true if the symbol, Sym, is an inner module. *) diff --git a/gcc/testsuite/gm2/imports/fail/tinybadimport.mod b/gcc/testsuite/gm2/imports/fail/tinybadimport.mod new file mode 100644 index 000000000000..d4f2a0d733a0 --- /dev/null +++ b/gcc/testsuite/gm2/imports/fail/tinybadimport.mod @@ -0,0 +1,12 @@ +MODULE tinybadimport ; + + MODULE inner ; + IMPORT ASCII ; + VAR + foo: CHAR ; + BEGIN + foo := ASCII.nul ; + END inner ; + +BEGIN +END tinybadimport. diff --git a/gcc/testsuite/gm2/imports/run/pass/tinygoodimport.mod b/gcc/testsuite/gm2/imports/run/pass/tinygoodimport.mod new file mode 100644 index 000000000000..bce5fdc474b1 --- /dev/null +++ b/gcc/testsuite/gm2/imports/run/pass/tinygoodimport.mod @@ -0,0 +1,14 @@ +MODULE tinygoodimport ; + +IMPORT ASCII ; + + MODULE inner ; + IMPORT ASCII ; + VAR + foo: CHAR ; + BEGIN + foo := ASCII.nul + END inner ; + +BEGIN +END tinygoodimport. From b70a80cfff503060f48a12c090e5b4983d3c6156 Mon Sep 17 00:00:00 2001 From: Artemiy Volkov Date: Thu, 24 Sep 2026 10:21:42 +0000 Subject: [PATCH 407/584] match.pd: fix comparison in the ((X >> C1) & C2) << C3 pattern [PR127552] In this simplification rule added in r17-4511-g885ad73e630ca2, we assume that C1 and C3 are of the same type and call wi::leu_p () with those constants converted to wide_int. This leads to a triggered assert on wide-int.h:1049 whenever C1 and C3 have different precision, which causes an ICE reported in PR127552. Fix this by converting to widest_int instead. To test the change, amend the original match-bit-extract-shift.c file to use constants of various types in the existing testcases. Bootstrapped and regtested on aarch64-linux-gnu and x86_64-linux-gnu. PR tree-optimization/127552 gcc/ChangeLog: * match.pd: Fix constant comparison in ((X >> C1) & C2) << C3. gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/match-bit-extract-shift.c: Adjust testcases. --- gcc/match.pd | 2 +- .../gcc.dg/tree-ssa/match-bit-extract-shift.c | 14 +++++++------- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/gcc/match.pd b/gcc/match.pd index b6a9d4e79be2..688357f0ecdb 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -1545,7 +1545,7 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) tree mask_shifted = fold_build2 (LSHIFT_EXPR, TREE_TYPE (@0), mask, @3); } - (if (wi::leu_p (wi::to_wide (@1), wi::to_wide (@3))) + (if (wi::to_widest (@1) <= wi::to_widest (@3)) (bit_and (lshift @0 (minus @3 @1)) { mask_shifted; }) (bit_and (rshift @0 (minus @1 @3)) { mask_shifted; }))))))) diff --git a/gcc/testsuite/gcc.dg/tree-ssa/match-bit-extract-shift.c b/gcc/testsuite/gcc.dg/tree-ssa/match-bit-extract-shift.c index 292ce5a41c90..56d386d43056 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/match-bit-extract-shift.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/match-bit-extract-shift.c @@ -6,33 +6,33 @@ uint32_t f (uint64_t x) { - return (((x >> 32) & 0x1) << 16) - | (((x >> 24) & 0xff) << 8); + return (((x >> 32) & 0x1) << 16L) + | (((x >> 24UL) & 0xff) << 8); } uint32_t f2 (uint64_t x) { - return (((x >> 3) & 0x3) << 16); + return (((x >> 3) & 0x3) << 16LL); } uint32_t f3 (uint64_t x) { - return (((x >> 61) & 0xE) << 16); + return (((x >> 61ULL) & 0xE) << 16); } uint32_t f4 (uint64_t x) { - return (((x >> 62) & 0xE) << 16); + return (((x >> 62U) & 0xE) << 16UL); } uint32_t f5 (uint64_t x) { - return (((x >> 63) & 0xF) << 17); + return (((x >> 63L) & 0xF) << 17U); } uint64_t f6 (uint64_t x) { - return (((x >> 32) & 0xFFFFFF) << 47); + return (((x >> 32U) & 0xFFFFFF) << 47ULL); } /* { dg-final { scan-tree-dump-not "<< 16" forwprop1 } } */ From e8add4e4e24a9cb4ee05fb0889b7eaaed3a218ee Mon Sep 17 00:00:00 2001 From: Georg-Johann Lay Date: Fri, 25 Sep 2026 10:52:52 +0200 Subject: [PATCH 408/584] AVR: Add new option -moptimize for avr-specific passes. This is a collection option that can be used to disable / enable the avr-specific optimization passes -- currently 8 of them. gcc/ * config/avr/avr.opt (-moptimize): New target option. * config/avr/avr.opt.urls: Add resprective URL. * common/config/avr/avr-common.cc (avr_enable_optimizations): New static function. (avr_handle_option) [OPT_moptimize]: Call it. * doc/invoke.texi (AVR Options) <-moptimize>: Document it. --- gcc/common/config/avr/avr-common.cc | 19 +++++++++++++++++++ gcc/config/avr/avr.opt | 4 ++++ gcc/config/avr/avr.opt.urls | 3 +++ gcc/doc/invoke.texi | 12 +++++++++++- 4 files changed, 37 insertions(+), 1 deletion(-) diff --git a/gcc/common/config/avr/avr-common.cc b/gcc/common/config/avr/avr-common.cc index 875efde66814..aa2a22e83d02 100644 --- a/gcc/common/config/avr/avr-common.cc +++ b/gcc/common/config/avr/avr-common.cc @@ -80,6 +80,22 @@ static const struct default_options avr_option_optimization_table[] = }; +/* Let -m[no-]optimize [de-]activate avr-specific optimization (passes). */ + +static void +avr_enable_optimizations (gcc_options *opts, bool on) +{ + opts->x_avropt_demote_switch = on; + opts->x_avropt_fuse_add = on ? 2 : 0; + opts->x_avropt_fuse_ifelse = on; + opts->x_avropt_fuse_move = on ? 23 : 0; + opts->x_avropt_fuse_move2 = on; + opts->x_avropt_split_ldst = on; + opts->x_avropt_split_bit_shift = on; + opts->x_avropt_use_nonzero_bits = on; +} + + /* Implement `TARGET_HANDLE_OPTION'. */ /* This is the same logic that driver-avr.cc:avr_double_lib() applies @@ -94,6 +110,9 @@ avr_handle_option (struct gcc_options *opts, struct gcc_options*, { int value = decoded->value; + if (decoded->opt_index == OPT_moptimize) + avr_enable_optimizations (opts, value); + switch (decoded->opt_index) { case OPT_mdouble_: diff --git a/gcc/config/avr/avr.opt b/gcc/config/avr/avr.opt index 625c6b2440d7..c94385f53700 100644 --- a/gcc/config/avr/avr.opt +++ b/gcc/config/avr/avr.opt @@ -184,6 +184,10 @@ mfuse-move2 Target Var(avropt_fuse_move2) Init(0) Optimization Optimization. Fuse some move insns after insn combine. +moptimize +Target Var(avropt_optimize) Init(0) Optimization +Optimization. Enable avr-specific optimizations. + mabsdata Target Mask(ABSDATA) Assume that all data in static storage can be accessed by LDS / STS instructions. This option is only useful for reduced Tiny devices like ATtiny40. diff --git a/gcc/config/avr/avr.opt.urls b/gcc/config/avr/avr.opt.urls index a04394894e78..a7d2d295f89e 100644 --- a/gcc/config/avr/avr.opt.urls +++ b/gcc/config/avr/avr.opt.urls @@ -111,6 +111,9 @@ UrlSuffix(gcc/AVR-Options.html#index-mfuse-move) mfuse-move2 UrlSuffix(gcc/AVR-Options.html#index-mfuse-move2) +moptimize +UrlSuffix(gcc/AVR-Options.html#index-moptimize) + mabsdata UrlSuffix(gcc/AVR-Options.html#index-mabsdata) diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 20d82c620f67..feec1561850d 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -990,7 +990,7 @@ Objective-C and Objective-C++ Dialects}. -mcall-prologues -mgas-isr-prologues -mint8 -mflmap -mdouble=@var{bits} -mlong-double=@var{bits} -mno-call-main -mn_flash=@var{size} -mfract-convert-truncate -mno-interrupts --mmain-is-OS_task -mrelax -mpmem-wrap-around +-mmain-is-OS_task -moptimize -mrelax -mpmem-wrap-around -mrmw -mstrict-addr-space-subsets -mstrict-X -mtiny-stack -mrodata-in-ram -msplit-bit-shift -msplit-ldst -mshort-calls -mskip-bug -muse-nonzero-bits -nodevicelib -nodevicespecs @@ -24660,6 +24660,16 @@ aspect of the optimization. @item -mfuse-move2 Run a post combine optimization pass that tries to fuse move instructions. +@opindex moptimize +@item -mno-optimize +@itemx -moptimize +Disable / enable AVR-specific optimization passes, all documented in this +paragraph: @option{-mdemote-switch}, @option{-mfuse-add}, +@option{-mfuse-ifelse}, @option{-mfuse-move}, @option{-mfuse-move2}, +@option{-msplit-ldst}, @option{-msplit-bit-shift}, @option{-muse-nonzero-bits}. +Usually, you don't need to specify this option because the respective passes +are activated by default when optimization is on. + @opindex mstrict-X @item -mstrict-X Use address register @code{X} in a way proposed by the hardware. This means From 240bfe82a1f937a9b0be9877754a3d23567d5ec9 Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Fri, 25 Sep 2026 11:09:37 +0200 Subject: [PATCH 409/584] internal-fn: Fix up .MUL_OVERFLOW expansion for non-mode precision arguments [PR127517] Most of expand_mul_overflow just assumes mode precision arguments of the same mode and perhaps different signedness and in the end only expand_arith_overflow_result_store and expand_ubsan_result_store deal with the result mode being smaller than the operand mode or having non-mode precision and performing additional testing for those cases. The callers of expand_mul_overflow for the non-ubsan cases (and bitint lowering) ensure argument promotions so that both expand_mul_overflow operands have the same precision. They can have non-mode precision though. In r14-3745 when adding _BitInt support I've already dealt with this and added /* Unsigned types with smaller than mode precision, even if they have most significant bit set, are still zero-extended. */ if (uns0_p && TYPE_PRECISION (TREE_TYPE (arg0)) < GET_MODE_PRECISION (mode)) pos_neg0 = 1; if (uns1_p && TYPE_PRECISION (TREE_TYPE (arg1)) < GET_MODE_PRECISION (mode)) pos_neg1 = 1; after the 2 get_range_pos_neg calls. Unfortunately the following testcase shows that is not good enough. In the testcase, one of the arguments is originally 0x7fffffffffffffffffffffffffffffffwb in _BitInt(128) type (so its signed maximum), but during gimple opts that is optimized into unsigned _BitInt(127) 0x7fffffffffffffffffffffffffffffffuwb (unsigned 127-bit maximum, same value, that is all __builtin_mul_overflow cares about, it extends everything virtually to infinite precision). Now, get_range_pos_neg (arg1, currently_expanding_gimple_stmt); for the unsigned _BitInt(127) maximum is 2, it always treats it as signed and says whether the most significant bit is known to be 0 or 1 or unknown, 2 means it is known to be set. The above mentioned adjustment adjusts it to 1, which is correct, when used in the mode precision (128-bit), the most significant bit is actually clear, because uns1_p. So, we are then handling a s x u -> s overflow multiplication, and when we know the most significant bit of the second operand is 0 (pos_neg1 is 1), we don't do any adjustments and just fallthrough into the s x s -> s overflow multiplication. So far so good. We don't have an optab and do the expansion in half mode (DImode), where we then call if (arg1 != error_mark_node) mprec1 = get_min_precision (arg1, sign); but arg1 still has 127-bit precision rather than 128-bit and sign is SIGNED, so this sets mprec1 to 1 rather than 127 that we need (when looking at the 127-bit value as signed, it is all sign bit copies, _BitInt(127) -1). The following patch fixes this by reverting the r14-3745 changes and instead just promoting arg0 and arg1 to corresponding type with mode precision and their original signedness. Both get_range_pos_neg and get_min_precision can deal with several NOP_EXPRs/CONVERT_EXPRs around an SSA_NAME and we already rely on that. The only thing where we actually need the original arg0/arg1 before promotion (for .MUL_OVERFLOW the passed in arg0/arg1 are already often after promotion anyway) is in the ubsan case to know what kind of types of the arguments to print, so the patch adds orig_arg{0,1} variables and passes that, otherwise the patch without that breaks ubsan/bitint-{1,2}.c. 2026-09-25 Jakub Jelinek PR middle-end/127517 * internal-fn.cc (expand_mul_overflow): Revert the 2023-09-06 changes. Instead promote arg0 and/or arg1 to a type with uns{0,1}_p signedness and mode precision if they have non-mode precision. Pass the original arg0/arg1 and their type to ubsan_build_overflow_builtin, instead of passing the promoted ones. * gcc.dg/torture/bitint-109.c: New test. Reviewed-by: Richard Biener --- gcc/internal-fn.cc | 30 +++++++++++++++-------- gcc/testsuite/gcc.dg/torture/bitint-109.c | 18 ++++++++++++++ 2 files changed, 38 insertions(+), 10 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/torture/bitint-109.c diff --git a/gcc/internal-fn.cc b/gcc/internal-fn.cc index 597ccaeb9fef..45ad08d2cf61 100644 --- a/gcc/internal-fn.cc +++ b/gcc/internal-fn.cc @@ -1750,7 +1750,7 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1, tree *datap) { rtx res, op0, op1; - tree fn, type; + tree fn, type, orig_arg0 = arg0, orig_arg1 = arg1; rtx_code_label *done_label, *do_error; rtx target = NULL_RTX; signop sign; @@ -1764,10 +1764,26 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1, do_error = gen_label_rtx (); do_pending_stack_adjust (); + + scalar_int_mode mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (arg0)); + /* If the operand types don't have mode precision, extend them + to mode precision. */ + if (TYPE_PRECISION (TREE_TYPE (arg0)) < GET_MODE_PRECISION (mode)) + { + tree type = build_nonstandard_integer_type (GET_MODE_PRECISION (mode), + uns0_p); + arg0 = fold_convert_loc (loc, type, arg0); + } + if (TYPE_PRECISION (TREE_TYPE (arg1)) < GET_MODE_PRECISION (mode)) + { + tree type = build_nonstandard_integer_type (GET_MODE_PRECISION (mode), + uns1_p); + arg1 = fold_convert_loc (loc, type, arg1); + } + op0 = expand_normal (arg0); op1 = expand_normal (arg1); - scalar_int_mode mode = SCALAR_INT_TYPE_MODE (TREE_TYPE (arg0)); bool uns = unsr_p; if (lhs) { @@ -1829,12 +1845,6 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1, int pos_neg0 = get_range_pos_neg (arg0, currently_expanding_gimple_stmt); int pos_neg1 = get_range_pos_neg (arg1, currently_expanding_gimple_stmt); - /* Unsigned types with smaller than mode precision, even if they have most - significant bit set, are still zero-extended. */ - if (uns0_p && TYPE_PRECISION (TREE_TYPE (arg0)) < GET_MODE_PRECISION (mode)) - pos_neg0 = 1; - if (uns1_p && TYPE_PRECISION (TREE_TYPE (arg1)) < GET_MODE_PRECISION (mode)) - pos_neg1 = 1; /* s1 * u2 -> ur */ if (!uns0_p && uns1_p && unsr_p) @@ -2559,8 +2569,8 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1, { /* Expand the ubsan builtin call. */ push_temp_slots (); - fn = ubsan_build_overflow_builtin (MULT_EXPR, loc, TREE_TYPE (arg0), - arg0, arg1, datap); + fn = ubsan_build_overflow_builtin (MULT_EXPR, loc, TREE_TYPE (orig_arg0), + orig_arg0, orig_arg1, datap); expand_normal (fn); pop_temp_slots (); do_pending_stack_adjust (); diff --git a/gcc/testsuite/gcc.dg/torture/bitint-109.c b/gcc/testsuite/gcc.dg/torture/bitint-109.c new file mode 100644 index 000000000000..944e9f4deb67 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/bitint-109.c @@ -0,0 +1,18 @@ +/* PR middle-end/127517 */ +/* { dg-do run { target bitint } } */ + +__attribute__((noipa)) void +foo (int x) +{ +#if __BITINT_MAXWIDTH__ >= 128 + _BitInt(128) t = 0x7fffffffffffffffffffffffffffffffwb; + if (!__builtin_mul_overflow_p (t, x, (_BitInt (127)) 0)) + __builtin_abort (); +#endif +} + +int +main () +{ + foo (8); +} From ee5e63a6531defa646b995592f577c05ed288d63 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Fri, 25 Sep 2026 10:36:12 +0200 Subject: [PATCH 410/584] tree-optimization/127600 - bogus INTEGER_INDUC_COND_REDUCTION detection After we introduced additional induction kinds we failed to make sure integer cond reductions are unaffected. PR tree-optimization/127600 * tree-vect-loop.cc (vect_is_simple_iv_evolution): Explicitly initialize STMT_VINFO_LOOP_PHI_EVOLUTION_TYPE. (is_nonwrapping_integer_induction): Bail out for alternate induction types. * gcc.dg/vect/vect-cond-reduc-7.c: New testcase. --- gcc/testsuite/gcc.dg/vect/vect-cond-reduc-7.c | 45 +++++++++++++++++++ gcc/tree-vect-loop.cc | 7 ++- 2 files changed, 51 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.dg/vect/vect-cond-reduc-7.c diff --git a/gcc/testsuite/gcc.dg/vect/vect-cond-reduc-7.c b/gcc/testsuite/gcc.dg/vect/vect-cond-reduc-7.c new file mode 100644 index 000000000000..abaa3693aff1 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-cond-reduc-7.c @@ -0,0 +1,45 @@ +/* PR1276000 */ + +#include "tree-vect.h" + +extern void abort (void) __attribute__ ((noreturn)); + +int __attribute__((noipa)) +f (int *a, int n) +{ + int last = -99; + int j = 1; + for (int i = 0; i < n; i++) + { + if (a[i]) + last = j; + j = -j; + } + return last; +} + +int +main (void) +{ + check_vect (); + + int a[16] = { 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + if (f (a, 16) != 1) + abort (); + + int b[16] = { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + if (f (b, 16) != -1) + abort (); + + int c[16] = { 0 }; + if (f (c, 16) != -99) + abort (); + + int d[16] = { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + if (f (d, 16) != 1) + abort (); + + return 0; +} + +/* { dg-final { scan-tree-dump-not "condition expression based on integer induction." "vect" } } */ diff --git a/gcc/tree-vect-loop.cc b/gcc/tree-vect-loop.cc index 99dda5b1e005..f692ead2bacc 100644 --- a/gcc/tree-vect-loop.cc +++ b/gcc/tree-vect-loop.cc @@ -198,6 +198,7 @@ vect_is_simple_iv_evolution (unsigned loop_nb, tree access_fn, STMT_VINFO_LOOP_PHI_EVOLUTION_BASE_UNCHANGED (stmt_info) = init_expr; STMT_VINFO_LOOP_PHI_EVOLUTION_PART (stmt_info) = step_expr; + STMT_VINFO_LOOP_PHI_EVOLUTION_TYPE (stmt_info) = vect_step_op_add; if (TREE_CODE (step_expr) != INTEGER_CST && (TREE_CODE (step_expr) != SSA_NAME @@ -6592,7 +6593,7 @@ vectorize_fold_left_reduction (loop_vec_info loop_vinfo, /* Function is_nonwrapping_integer_induction. - Check if STMT_VINO (which is part of loop LOOP) both increments and + Check if STMT_VINFO (which is part of loop LOOP) both increments and does not cause overflow. */ static bool @@ -6605,6 +6606,10 @@ is_nonwrapping_integer_induction (stmt_vec_info stmt_vinfo, class loop *loop) widest_int ni, max_loop_value, lhs_max; wi::overflow_type overflow = wi::OVF_NONE; + /* Make sure this is a regular induction. */ + if (STMT_VINFO_LOOP_PHI_EVOLUTION_TYPE (stmt_vinfo) != vect_step_op_add) + return false; + /* Make sure the loop is integer based. */ if (TREE_CODE (base) != INTEGER_CST || TREE_CODE (step) != INTEGER_CST) From 5b2f9f39d9fe60c48f60e2667e6b7716d1687a64 Mon Sep 17 00:00:00 2001 From: Georg-Johann Lay Date: Fri, 25 Sep 2026 11:38:01 +0200 Subject: [PATCH 411/584] AVR: Fix moptimize link in avr.opt.urls. gcc/ * config/avr/avr.opt.urls: Fix moptimize link. --- gcc/config/avr/avr.opt.urls | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/config/avr/avr.opt.urls b/gcc/config/avr/avr.opt.urls index a7d2d295f89e..e0c725e8d1a8 100644 --- a/gcc/config/avr/avr.opt.urls +++ b/gcc/config/avr/avr.opt.urls @@ -112,7 +112,7 @@ mfuse-move2 UrlSuffix(gcc/AVR-Options.html#index-mfuse-move2) moptimize -UrlSuffix(gcc/AVR-Options.html#index-moptimize) +UrlSuffix(gcc/AVR-Options.html#index-moptimize-1) mabsdata UrlSuffix(gcc/AVR-Options.html#index-mabsdata) From b4a5597ccd6a38f5598c4c190f34162031ad6700 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Fri, 25 Sep 2026 10:45:00 +0200 Subject: [PATCH 412/584] tree-optimization/127601 - negative step SLP vectorization with gap The following disables negative step SLP (with a group size bigger than one) vectorization with gaps since the VMAT_STRIDED_SLP path does not implement using smaller vectors to avoid touching the gap nor can we use peeling for gaps to deal with a gap that would be touched with the first vector load. PR tree-optimization/127601 * tree-vect-stmts.cc (get_load_store_type): Move overrun flags and final handling to the relevant section, after determining the step direction and the memory access type. Only elide overrun with half-vector accesses for the memory access types supporting that. Do not claim VMAT_STRIDED_SLP can handle overruns when the step is negative. (vectorizable_load): For the last memory access type group analysis/transform assert what memory access type that covers. * gcc.dg/vect/vect-pr127601.c: New testcase. --- gcc/testsuite/gcc.dg/vect/vect-pr127601.c | 37 +++++++++++++++++ gcc/tree-vect-stmts.cc | 50 +++++++++++++---------- 2 files changed, 65 insertions(+), 22 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/vect/vect-pr127601.c diff --git a/gcc/testsuite/gcc.dg/vect/vect-pr127601.c b/gcc/testsuite/gcc.dg/vect/vect-pr127601.c new file mode 100644 index 000000000000..bcad4232a887 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-pr127601.c @@ -0,0 +1,37 @@ +/* { dg-require-effective-target mmap } */ + +#include +#include "tree-vect.h" + +#define PG 4096 + +static long __attribute__((noipa)) +rev (long *a, int n) +{ + long s = 0; + for (int i = n - 1; i >= 0; i--) + s += a[4 * i] + a[4 * i + 1] + a[4 * i + 2]; + return s; +} + +int main (void) +{ + check_vect (); + + unsigned char *p = mmap (0, 2 * PG, PROT_READ | PROT_WRITE, + MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); + if (p == MAP_FAILED || mprotect (p + PG, PG, PROT_NONE)) + return 0; + + int n = 9; + unsigned long ne = 4UL * (n - 1) + 3; /* 35 longs are touched */ + long *a = (long *) (p + PG - ne * sizeof (long)); + +#pragma GCC novector + for (unsigned long i = 0; i < ne; i++) + a[i] = (long) (i * 3 + 1); + + if (rev (a, n) != 1404) + __builtin_abort (); + return 0; +} diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc index 69e1bdc2cac7..244f319d0e41 100644 --- a/gcc/tree-vect-stmts.cc +++ b/gcc/tree-vect-stmts.cc @@ -2127,17 +2127,6 @@ get_load_store_type (vec_info *vinfo, stmt_vec_info stmt_info, } dr_vec_info *first_dr_info = STMT_VINFO_DR_INFO (first_stmt_info); - /* True if the vectorized statements would access beyond the last - statement in the group. */ - bool overrun_p = false; - - /* True if we can cope with such overrun by peeling for gaps, so that - there is at least one final scalar iteration after the vector loop. */ - bool can_overrun_p = (!masked_p - && vls_type == VLS_LOAD - && loop_vinfo - && !loop->inner); - /* There can only be a gap at the end of the group if the stride is known at compile time. */ gcc_assert (!STMT_VINFO_STRIDED_P (first_stmt_info) || gap == 0); @@ -2269,6 +2258,19 @@ get_load_store_type (vec_info *vinfo, stmt_vec_info stmt_info, else *memory_access_type = VMAT_CONTIGUOUS; + /* True if the vectorized statements would access beyond the last + statement in the group. */ + bool overrun_p = false; + + /* True if we can cope with such overrun by peeling for gaps, so that + there is at least one final scalar iteration after the vector loop. */ + bool can_overrun_p = (!masked_p + && vls_type == VLS_LOAD + && loop_vinfo + && !loop->inner + && (*memory_access_type != VMAT_STRIDED_SLP + || cmp > 0)); + /* If this is single-element interleaving with an element distance that leaves unused vector loads around fall back to elementwise access if possible - we otherwise least @@ -2354,7 +2356,8 @@ get_load_store_type (vec_info *vinfo, stmt_vec_info stmt_info, unsigned HOST_WIDE_INT tem, num; if (overrun_p && !masked_p - && *memory_access_type != VMAT_LOAD_STORE_LANES + && (*memory_access_type == VMAT_CONTIGUOUS + || *memory_access_type == VMAT_CONTIGUOUS_REVERSE) && (((alss = vect_supportable_dr_alignment (vinfo, first_dr_info, vectype, misalign))) == dr_aligned @@ -2435,6 +2438,16 @@ get_load_store_type (vec_info *vinfo, stmt_vec_info stmt_info, LOOP_VINFO_CAN_USE_PARTIAL_VECTORS_P (loop_vinfo) = false; } } + + if (overrun_p) + { + gcc_assert (can_overrun_p); + if (dump_enabled_p ()) + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, + "Data access with gaps requires scalar " + "epilogue loop\n"); + LOOP_VINFO_PEELING_FOR_GAPS (loop_vinfo) = true; + } } /* As a last resort, trying using a gather load or scatter store. @@ -2532,16 +2545,6 @@ get_load_store_type (vec_info *vinfo, stmt_vec_info stmt_info, } } - if (overrun_p) - { - gcc_assert (can_overrun_p); - if (dump_enabled_p ()) - dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, - "Data access with gaps requires scalar " - "epilogue loop\n"); - LOOP_VINFO_PEELING_FOR_GAPS (loop_vinfo) = true; - } - if ((*memory_access_type == VMAT_ELEMENTWISE || *memory_access_type == VMAT_STRIDED_SLP) && !nunits.is_constant ()) @@ -11371,6 +11374,9 @@ vectorizable_load (vec_info *vinfo, return true; } + gcc_assert (memory_access_type == VMAT_CONTIGUOUS + || memory_access_type == VMAT_CONTIGUOUS_REVERSE); + aggr_type = vectype; if (!costing_p) { From 0a1f6acb90e27ac0b2984ad6841186ca54bc5725 Mon Sep 17 00:00:00 2001 From: Andrew Stubbs Date: Thu, 24 Sep 2026 12:55:42 +0000 Subject: [PATCH 413/584] amdgcn: Fix 64-bit vector multiply Fix an old maths bug with DImode vector multiply. gcc/ChangeLog: * config/gcn/gcn-valu.md (mul3): Remove erroneous hi*hi step. (mul3_dup): Likewise. (mul3_exec): Likewise. (mul3_dup_exec): Likewise. --- gcc/config/gcn/gcn-valu.md | 8 -------- 1 file changed, 8 deletions(-) diff --git a/gcc/config/gcn/gcn-valu.md b/gcc/config/gcn/gcn-valu.md index 32021d263cc9..881f262f62fa 100644 --- a/gcc/config/gcn/gcn-valu.md +++ b/gcc/config/gcn/gcn-valu.md @@ -2320,8 +2320,6 @@ emit_insn (gen_add3 (out_hi, out_hi, tmp)); emit_insn (gen_mul3 (tmp, left_lo, right_hi)); emit_insn (gen_add3 (out_hi, out_hi, tmp)); - emit_insn (gen_mul3 (tmp, left_hi, right_hi)); - emit_insn (gen_add3 (out_hi, out_hi, tmp)); DONE; }) @@ -2351,8 +2349,6 @@ emit_insn (gen_add3 (out_hi, out_hi, tmp)); emit_insn (gen_mul3_dup (tmp, left_lo, right_hi)); emit_insn (gen_add3 (out_hi, out_hi, tmp)); - emit_insn (gen_mul3_dup (tmp, left_hi, right_hi)); - emit_insn (gen_add3 (out_hi, out_hi, tmp)); DONE; }) @@ -2399,8 +2395,6 @@ emit_insn (gen_add3_exec (out_hi, out_hi, tmp, out_hi, exec)); emit_insn (gen_mul3_exec (tmp, left_lo, right_hi, undef, exec)); emit_insn (gen_add3_exec (out_hi, out_hi, tmp, out_hi, exec)); - emit_insn (gen_mul3_exec (tmp, left_hi, right_hi, undef, exec)); - emit_insn (gen_add3_exec (out_hi, out_hi, tmp, out_hi, exec)); DONE; }) @@ -2449,8 +2443,6 @@ emit_insn (gen_add3_exec (out_hi, out_hi, tmp, out_hi, exec)); emit_insn (gen_mul3_dup_exec (tmp, left_lo, right_hi, undef, exec)); emit_insn (gen_add3_exec (out_hi, out_hi, tmp, out_hi, exec)); - emit_insn (gen_mul3_dup_exec (tmp, left_hi, right_hi, undef, exec)); - emit_insn (gen_add3_exec (out_hi, out_hi, tmp, out_hi, exec)); DONE; }) From 4f6eeefe8d8146af48ae6526e398d3b46640822a Mon Sep 17 00:00:00 2001 From: Surya Kumari Jangala Date: Thu, 24 Sep 2026 22:20:04 -0500 Subject: [PATCH 414/584] rs6000/p8swap: Fix incorrect lane extraction by vec_extract() [PR106770] In the routine rs6000_analyze_swaps(), special handling of swappable instructions is done even if the webs that contain the swappable instructions are not optimized, i.e., the webs do not contain any permuting load/store instructions along with the associated register swap instructions. Doing special handling in such webs will result in the extracted lane being adjusted unnecessarily for vec_extract. Another issue is that existing code treats non-permuting loads/stores as special swappables. Non-permuting loads/stores (that have not yet been split into a permuting load/store and a swap) are handled by converting them into a permuting load/store (which effectively removes the swap). As a result, if special swappables are handled only in webs containing permuting loads/stores, then non-optimal code is generated for non-permuting loads/stores. Hence, in this patch, all webs containing either permuting loads/ stores or non-permuting loads/stores are marked as requiring special handling of swappables. Swaps associated with permuting loads/stores are marked for removal, and non-permuting loads/stores are converted to permuting loads/stores. Then the special swappables in the webs are fixed up. This patch also ensures that swappable instructions are not modified in the following webs as it is incorrect to do so: - webs containing permuting load/store instructions and associated swap instructions that are transformed by converting the permuting memory instructions into non-permuting instructions and removing the swap instructions. - webs where swap(load(vector constant)) instructions are replaced with load(swapped vector constant). 2023-09-10 Surya Kumari Jangala gcc: PR rtl-optimization/106770 * config/rs6000/rs6000-p8swap.cc (non_permuting_mem_insn): New function. (handle_non_permuting_mem_insn): New function. (rs6000_analyze_swaps): Handle swappable instructions only in certain webs. (web_requires_special_handling): New instance variable. (handle_special_swappables): Remove handling of non-permuting load/store instructions. gcc/testsuite: PR rtl-optimization/106770 * gcc.target/powerpc/pr106770.c: New test. --- gcc/config/rs6000/rs6000-p8swap.cc | 78 +++++++++++++++++---- gcc/testsuite/gcc.target/powerpc/pr106770.c | 20 ++++++ 2 files changed, 83 insertions(+), 15 deletions(-) create mode 100644 gcc/testsuite/gcc.target/powerpc/pr106770.c diff --git a/gcc/config/rs6000/rs6000-p8swap.cc b/gcc/config/rs6000/rs6000-p8swap.cc index f0c26c0265d5..046207e73f64 100644 --- a/gcc/config/rs6000/rs6000-p8swap.cc +++ b/gcc/config/rs6000/rs6000-p8swap.cc @@ -179,6 +179,13 @@ class swap_web_entry : public web_entry_base unsigned int special_handling : 4; /* Set if the web represented by this entry cannot be optimized. */ unsigned int web_not_optimizable : 1; + /* Set if the swappable insns in the web represented by this entry + have to be fixed. Swappable insns have to be fixed in: + - webs containing permuting loads/stores and the swap insns + in such webs have been marked for removal + - webs where non-permuting loads/stores have been converted + to permuting loads/stores */ + unsigned int web_requires_special_handling : 1; /* Set if this insn should be deleted. */ unsigned int will_delete : 1; }; @@ -1468,14 +1475,6 @@ handle_special_swappables (swap_web_entry *insn_entry, unsigned i) if (dump_file) fprintf (dump_file, "Adjusting subreg in insn %d\n", i); break; - case SH_NOSWAP_LD: - /* Convert a non-permuting load to a permuting one. */ - permute_load (insn); - break; - case SH_NOSWAP_ST: - /* Convert a non-permuting store to a permuting one. */ - permute_store (insn); - break; case SH_EXTRACT: /* Change the lane on an extract operation. */ adjust_extract (insn); @@ -2401,6 +2400,25 @@ recombine_lvx_stvx_patterns (function *fun) free (to_delete); } +/* Return true if insn is a non-permuting load/store. */ +static bool +non_permuting_mem_insn (swap_web_entry *insn_entry, unsigned int i) +{ + return insn_entry[i].special_handling == SH_NOSWAP_LD + || insn_entry[i].special_handling == SH_NOSWAP_ST; +} + +/* Convert a non-permuting load/store insn to a permuting one. */ +static void +convert_mem_insn (swap_web_entry *insn_entry, unsigned int i) +{ + rtx_insn *insn = insn_entry[i].insn; + if (insn_entry[i].special_handling == SH_NOSWAP_LD) + permute_load (insn); + if (insn_entry[i].special_handling == SH_NOSWAP_ST) + permute_store (insn); +} + /* Main entry point for this pass. */ unsigned int rs6000_analyze_swaps (function *fun) @@ -2624,25 +2642,55 @@ rs6000_analyze_swaps (function *fun) dump_swap_insn_table (insn_entry); } - /* For each load and store in an optimizable web (which implies - the loads and stores are permuting), find the associated - register swaps and mark them for removal. Due to various - optimizations we may mark the same swap more than once. Also - perform special handling for swappable insns that require it. */ + /* There are two kinds of optimizations that can be performed on an + optimizable web: + 1. Remove the register swaps associated with permuting load/store + in an optimizable web + 2. Convert the vanilla loads/stores (that have not yet been split + into a permuting load/store and a swap) into a permuting + load/store (which effectively removes the swap) + In both the cases, swappable instructions in the webs need + special handling to fix them up. */ for (i = 0; i < e; ++i) + /* For each permuting load/store in an optimizable web, find + the associated register swaps and mark them for removal. + Due to various optimizations we may mark the same swap more + than once. */ if ((insn_entry[i].is_load || insn_entry[i].is_store) && insn_entry[i].is_swap) { swap_web_entry* root_entry = (swap_web_entry*)((&insn_entry[i])->unionfind_root ()); if (!root_entry->web_not_optimizable) - mark_swaps_for_removal (insn_entry, i); + { + mark_swaps_for_removal (insn_entry, i); + root_entry->web_requires_special_handling = true; + } } - else if (insn_entry[i].is_swappable && insn_entry[i].special_handling) + /* Convert the non-permuting loads/stores into a permuting + load/store. */ + else if (insn_entry[i].is_swappable + && non_permuting_mem_insn (insn_entry, i)) { swap_web_entry* root_entry = (swap_web_entry*)((&insn_entry[i])->unionfind_root ()); if (!root_entry->web_not_optimizable) + { + convert_mem_insn (insn_entry, i); + root_entry->web_requires_special_handling = true; + } + } + + /* Now that the webs which require special handling have been + identified, modify the instructions that are sensitive to + element order. */ + for (i = 0; i < e; ++i) + if (insn_entry[i].is_swappable && insn_entry[i].special_handling + && !non_permuting_mem_insn (insn_entry, i)) + { + swap_web_entry* root_entry + = (swap_web_entry*)((&insn_entry[i])->unionfind_root ()); + if (root_entry->web_requires_special_handling) handle_special_swappables (insn_entry, i); } diff --git a/gcc/testsuite/gcc.target/powerpc/pr106770.c b/gcc/testsuite/gcc.target/powerpc/pr106770.c new file mode 100644 index 000000000000..b4cc6f3267f6 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/pr106770.c @@ -0,0 +1,20 @@ +/* { dg-do compile { target { powerpc64le-*-* } } } */ +/* { dg-options "-mdejagnu-cpu=power8 -O2 " } */ +/* The 2 xxpermdi instructions are generated by the two + calls to vec_promote() */ +/* { dg-final { scan-assembler-times {xxpermdi} 2 } } */ + +/* Test case to resolve PR106770 */ + +#include + +int cmp2(double a, double b) +{ + vector double va = vec_promote(a, 1); + vector double vb = vec_promote(b, 1); + vector long long vlt = (vector long long)vec_cmplt(va, vb); + vector long long vgt = (vector long long)vec_cmplt(vb, va); + vector signed long long vr = vec_sub(vlt, vgt); + + return vec_extract(vr, 1); +} From 0a970b2702183d290df044858fd4df13ef698924 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Fri, 25 Sep 2026 09:36:09 +0200 Subject: [PATCH 415/584] tree-optimization/127588 - avoid UB in epilog IV init computation The following avoids UB when computing the start value of the epilog IV value which we compute as init + step * vect-niters where the step * vect-niters computation can overflow. PR tree-optimization/127588 * tree-vect-loop-manip.cc (vect_update_ivs_after_vectorizer): Use an unsigned type to compute the epilog start value. * gcc.dg/vect/vect-iv-15.c: New testcase. --- gcc/testsuite/gcc.dg/vect/vect-iv-15.c | 25 +++++++++++++++++++++++++ gcc/tree-vect-loop-manip.cc | 26 ++++++++++++++------------ 2 files changed, 39 insertions(+), 12 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/vect/vect-iv-15.c diff --git a/gcc/testsuite/gcc.dg/vect/vect-iv-15.c b/gcc/testsuite/gcc.dg/vect/vect-iv-15.c new file mode 100644 index 000000000000..912b18be75ff --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/vect-iv-15.c @@ -0,0 +1,25 @@ +/* PR127588 */ +/* { dg-require-effective-target int32plus } */ + +#include "tree-vect.h" + +int s; + +__attribute__((noipa)) +void foo (int init) +{ + s = init; + do { + s += 1074790400; + } while (s <= 1073741823); +} + +int main () +{ + check_vect (); + + foo (-1264552634); + if (s != 1959818566) + __builtin_abort (); + return 0; +} diff --git a/gcc/tree-vect-loop-manip.cc b/gcc/tree-vect-loop-manip.cc index b54353399d9e..9d22d87705ba 100644 --- a/gcc/tree-vect-loop-manip.cc +++ b/gcc/tree-vect-loop-manip.cc @@ -2612,7 +2612,7 @@ vect_update_ivs_after_vectorizer (loop_vec_info loop_vinfo, gsi_next (&gsi), gsi_next (&gsi1)) { tree init_expr; - tree step_expr, off; + tree step_expr; tree type; tree var, ni, ni_name; @@ -2648,17 +2648,19 @@ vect_update_ivs_after_vectorizer (loop_vec_info loop_vinfo, if (induction_type == vect_step_op_add) { - tree stype = TREE_TYPE (step_expr); - off = fold_build2 (MULT_EXPR, stype, - fold_convert (stype, niters), step_expr); - - if (POINTER_TYPE_P (type)) - ni = fold_build_pointer_plus (init_expr, off); - else - ni = fold_convert (type, - fold_build2 (PLUS_EXPR, stype, - fold_convert (stype, init_expr), - off)); + /* Use an unsigned type because we compute 'off' without + accounting for 'init_expr', thus the computation might + overflow. Note we can also have FP inductions. */ + tree ctype = (INTEGRAL_TYPE_P (TREE_TYPE (step_expr)) + ? unsigned_type_for (TREE_TYPE (step_expr)) + : TREE_TYPE (step_expr)); + tree off = fold_build2 (MULT_EXPR, ctype, + fold_convert (ctype, niters), + fold_convert (ctype, step_expr)); + ni = fold_convert (type, + fold_build2 (PLUS_EXPR, ctype, + fold_convert (ctype, init_expr), + off)); } /* Don't bother call vect_peel_nonlinear_iv_init. */ else if (induction_type == vect_step_op_neg) From 8aaa5f6e62075c8bd3cfe7ec2d4f3543b3e6eccd Mon Sep 17 00:00:00 2001 From: Oleg Tolmatcev Date: Wed, 16 Sep 2026 20:41:23 +0200 Subject: [PATCH 416/584] function: honour over-alignment in assign_stack_local [PR54412] Targets that cannot guarantee arbitrary stack alignment cap stack slots at MAX_SUPPORTED_STACK_ALIGNMENT. Win64 SEH caps MAX_STACK_ALIGNMENT at 128 bits; aarch64 does not define MAX_STACK_ALIGNMENT and is capped at STACK_BOUNDARY, also 128 bits. assign_stack_local silently ignored any alignment beyond that cap. A 256-bit vector requires 32-byte alignment, but its slot could therefore receive only 16-byte alignment while later MEM attributes still claimed 32. x86 could select vmovaps from that MEM_ALIGN and fault on the under-aligned slot (PR54412, MSYS2/MINGW-packages#1209). An escaped pointer has the same problem even when the local move is unaligned, since its type still promises the callee a 32-byte-aligned object. Make assign_stack_local_1 honour an explicit alignment beyond the cap by reserving enough space and aligning an address inside it at run time, as assign_parm_setup_block already did for BLKmode parameters and expand_stack_vars does for locals. Base the extra space on the alignment guaranteed for VIRTUAL_STACK_VARS_REGNUM rather than on the maximum alignment supported by the backend, since the frame itself is not guaranteed to have the latter alignment on all targets. Let a new internal assign_stack_local_2 return the address before run-time alignment. Store it in the temp slot and realign the address on reuse, while avoiding splitting or combining over-aligned slots. Honour required temporary alignment at run time, but cap merely preferred alignment. Preserve zero-size behavior and the target's preferred stack boundary, and emit run-time alignment only during expansion to RTL. Use ASLK_REDUCE_ALIGN where less alignment is acceptable: LRA spill slots and the deliberately over-aligned SJLJ function context. Regtested on x86_64-pc-linux-gnu and, under QEMU, on aarch64-unknown-linux-gnu, with no new failures. gcc/ChangeLog: PR target/54412 * except.cc (sjlj_build_landing_pads): Pass ASLK_REDUCE_ALIGN. * function.cc (assign_stack_local_2): New function, split from assign_stack_local_1. Honour an explicit alignment beyond MAX_SUPPORTED_STACK_ALIGNMENT by overallocating the slot and aligning its address at run time. Optionally return the address before run-time alignment. (assign_stack_local_1): Wrap assign_stack_local_2. (temp_slot): Add base_addr. (assign_stack_temp_for_type): Distinguish required and preferred alignment. Record the address before run-time alignment and recalculate the aligned address when reusing an over-aligned slot. Do not split an over-aligned BLKmode slot. (combine_temp_slots): Do not combine over-aligned slots. (assign_parm_setup_block): Let assign_stack_local align the slot. * lra-spills.cc (assign_mem_slot): Pass ASLK_REDUCE_ALIGN. Signed-off-by: Oleg Tolmatcev Signed-off-by: Jonathan Yong <10walls@gmail.com> --- gcc/except.cc | 12 ++--- gcc/function.cc | 131 +++++++++++++++++++++++++++++++++++----------- gcc/lra-spills.cc | 5 +- 3 files changed, 108 insertions(+), 40 deletions(-) diff --git a/gcc/except.cc b/gcc/except.cc index 98876833ee1e..e3b864573361 100644 --- a/gcc/except.cc +++ b/gcc/except.cc @@ -1478,9 +1478,9 @@ sjlj_build_landing_pads (void) TYPE_MODE (sjlj_fc_type_node), TYPE_ALIGN (sjlj_fc_type_node)); crtl->eh.sjlj_fc - = assign_stack_local (TYPE_MODE (sjlj_fc_type_node), - int_size_in_bytes (sjlj_fc_type_node), - align); + = assign_stack_local_1 (TYPE_MODE (sjlj_fc_type_node), + int_size_in_bytes (sjlj_fc_type_node), + align, ASLK_RECORD_PAD | ASLK_REDUCE_ALIGN); sjlj_mark_call_sites (); sjlj_emit_function_enter (dispatch_label); @@ -1496,9 +1496,9 @@ sjlj_build_landing_pads (void) TYPE_MODE (sjlj_fc_type_node), TYPE_ALIGN (sjlj_fc_type_node)); crtl->eh.sjlj_fc - = assign_stack_local (TYPE_MODE (sjlj_fc_type_node), - int_size_in_bytes (sjlj_fc_type_node), - align); + = assign_stack_local_1 (TYPE_MODE (sjlj_fc_type_node), + int_size_in_bytes (sjlj_fc_type_node), + align, ASLK_RECORD_PAD | ASLK_REDUCE_ALIGN); sjlj_mark_call_sites (); sjlj_emit_function_enter (NULL); diff --git a/gcc/function.cc b/gcc/function.cc index 0a0e83badae1..675c07d3b080 100644 --- a/gcc/function.cc +++ b/gcc/function.cc @@ -154,6 +154,7 @@ static bool contains (const rtx_insn *, hash_table *); static void prepare_function_start (void); static void do_clobber_return_reg (rtx, void *); static void do_use_return_reg (rtx, void *); +static rtx assign_stack_local_2 (machine_mode, poly_int64, int, int, rtx *); /* Stack of nested functions. */ @@ -369,6 +370,10 @@ add_frame_space (poly_int64 start, poly_int64 end) -2 means use BITS_PER_UNIT, positive specifies alignment boundary in bits. + A positive ALIGN that exceeds MAX_SUPPORTED_STACK_ALIGNMENT is honoured + by overallocating the slot and aligning its address at run time, with + insns emitted at the current position, unless KIND has ASLK_REDUCE_ALIGN. + KIND has ASLK_REDUCE_ALIGN bit set if it is OK to reduce alignment and ASLK_RECORD_PAD bit set if we should remember extra space we allocated for alignment purposes. When we are @@ -380,11 +385,24 @@ add_frame_space (poly_int64 start, poly_int64 end) rtx assign_stack_local_1 (machine_mode mode, poly_int64 size, int align, int kind) +{ + return assign_stack_local_2 (mode, size, align, kind, NULL); +} + +/* Like assign_stack_local_1. If BASE_ADDR is nonnull, set it to the slot + address before run-time alignment, or to NULL_RTX if none was needed. */ + +static rtx +assign_stack_local_2 (machine_mode mode, poly_int64 size, + int align, int kind, rtx *base_addr) { rtx x, addr; poly_int64 bigend_correction = 0; poly_int64 slot_offset = 0, old_frame_offset; - unsigned int alignment, alignment_in_bits; + unsigned int alignment, alignment_in_bits, dynamic_align = 0; + + if (base_addr) + *base_addr = NULL_RTX; if (align == 0) { @@ -403,9 +421,23 @@ assign_stack_local_1 (machine_mode mode, poly_int64 size, alignment_in_bits = alignment * BITS_PER_UNIT; - /* Ignore alignment if it exceeds MAX_SUPPORTED_STACK_ALIGNMENT. */ + /* The frame cannot be aligned beyond MAX_SUPPORTED_STACK_ALIGNMENT. If more + is requested, pad the slot so that an over-aligned object still fits. */ if (alignment_in_bits > MAX_SUPPORTED_STACK_ALIGNMENT) { + if (align > 0 && !(kind & ASLK_REDUCE_ALIGN) && maybe_ne (size, 0)) + { + gcc_assert (currently_expanding_to_rtl); + dynamic_align = alignment_in_bits; + + if (crtl->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY) + crtl->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY; + + /* Pad from the alignment the frame base is guaranteed to have. */ + size += ((alignment_in_bits + - REGNO_POINTER_ALIGN (VIRTUAL_STACK_VARS_REGNUM)) + / BITS_PER_UNIT); + } alignment_in_bits = MAX_SUPPORTED_STACK_ALIGNMENT; alignment = MAX_SUPPORTED_STACK_ALIGNMENT / BITS_PER_UNIT; } @@ -505,7 +537,7 @@ assign_stack_local_1 (machine_mode mode, poly_int64 size, found_space: /* On a big-endian machine, if we are allocating more space than we will use, use the least significant bytes of those that are allocated. */ - if (mode != BLKmode) + if (mode != BLKmode && !dynamic_align) { /* The slot size can sometimes be smaller than the mode size; e.g. the rs6000 port allocates slots with a vector mode @@ -530,6 +562,15 @@ assign_stack_local_1 (machine_mode mode, poly_int64 size, (slot_offset + bigend_correction, Pmode)); + if (dynamic_align) + { + if (base_addr) + *base_addr = addr; + addr = align_dynamic_address (addr, dynamic_align); + mark_reg_pointer (addr, dynamic_align); + alignment_in_bits = dynamic_align; + } + x = gen_rtx_MEM (mode, addr); set_mem_align (x, alignment_in_bits); MEM_NOTRAP_P (x) = 1; @@ -591,6 +632,9 @@ class GTY(()) temp_slot { /* The size of the slot, including extra space for alignment. This info is for combine_temp_slots. */ poly_int64 full_size; + /* The address before run-time alignment, or NULL_RTX if the slot does not + need run-time alignment. */ + rtx base_addr; }; /* Entry for the below hash table. */ @@ -802,6 +846,18 @@ assign_stack_temp_for_type (machine_mode mode, poly_int64 size, tree type) align = get_stack_local_alignment (type, mode); + unsigned int required_align + = (mode == BLKmode ? BITS_PER_UNIT : GET_MODE_ALIGNMENT (mode)); + if (type) + required_align = MAX (required_align, TYPE_ALIGN (type)); + + bool dynamic_align = required_align > MAX_SUPPORTED_STACK_ALIGNMENT; + + if (dynamic_align) + align = required_align; + else + align = MAX (required_align, MIN (align, MAX_SUPPORTED_STACK_ALIGNMENT)); + /* Try to find an available, already-allocated temporary of the proper mode which meets the size and alignment requirements. Choose the smallest one with the closest alignment. @@ -843,7 +899,8 @@ assign_stack_temp_for_type (machine_mode mode, poly_int64 size, tree type) /* If there are enough aligned bytes left over, make them into a new temp_slot so that the extra bytes don't get wasted. Do this only for BLKmode slots, so that we can be sure of the alignment. */ - if (GET_MODE (best_p->slot) == BLKmode) + if (GET_MODE (best_p->slot) == BLKmode + && best_p->align <= MAX_SUPPORTED_STACK_ALIGNMENT) { int alignment = best_p->align / BITS_PER_UNIT; poly_int64 rounded_size = aligned_upper_bound (size, alignment); @@ -851,6 +908,7 @@ assign_stack_temp_for_type (machine_mode mode, poly_int64 size, tree type) if (known_ge (best_p->size - rounded_size, alignment)) { p = ggc_alloc (); + p->base_addr = NULL_RTX; p->in_use = false; p->size = best_p->size - rounded_size; p->base_offset = best_p->base_offset + rounded_size; @@ -868,12 +926,20 @@ assign_stack_temp_for_type (machine_mode mode, poly_int64 size, tree type) } } + bool reused_p = selected != 0; + /* If we still didn't find one, make a new temporary. */ if (selected == 0) { poly_int64 frame_offset_old = frame_offset; p = ggc_alloc (); + p->base_addr = NULL_RTX; + + poly_int64 slot_size + = (mode == BLKmode + ? aligned_upper_bound (size, (int) align / BITS_PER_UNIT) + : size); /* We are passing an explicit alignment request to assign_stack_local. One side effect of that is assign_stack_local will not round SIZE @@ -882,14 +948,15 @@ assign_stack_temp_for_type (machine_mode mode, poly_int64 size, tree type) So for requests which depended on the rounding of SIZE, we go ahead and round it now. We also make sure ALIGNMENT is at least BIGGEST_ALIGNMENT. */ - gcc_assert (mode != BLKmode || align == BIGGEST_ALIGNMENT); - p->slot = assign_stack_local_1 (mode, - (mode == BLKmode - ? aligned_upper_bound (size, - (int) align - / BITS_PER_UNIT) - : size), - align, 0); + gcc_assert (mode != BLKmode + || dynamic_align + || (align + >= MIN (BIGGEST_ALIGNMENT, + MAX_SUPPORTED_STACK_ALIGNMENT))); + + rtx base_addr; + p->slot = assign_stack_local_2 (mode, slot_size, align, 0, &base_addr); + p->base_addr = base_addr; p->align = align; @@ -900,7 +967,9 @@ assign_stack_temp_for_type (machine_mode mode, poly_int64 size, tree type) can be either above or below this stack slot depending on which way the frame grows. We include the extra space if and only if it is above this slot. */ - if (FRAME_GROWS_DOWNWARD) + if (dynamic_align) + p->size = slot_size; + else if (FRAME_GROWS_DOWNWARD) p->size = frame_offset_old - frame_offset; else p->size = size; @@ -928,10 +997,19 @@ assign_stack_temp_for_type (machine_mode mode, poly_int64 size, tree type) pp = temp_slots_at_level (p->level); insert_slot_to_list (p, pp); - insert_temp_slot_address (XEXP (p->slot, 0), p); + + rtx addr = XEXP (p->slot, 0); + + if (reused_p && p->align > MAX_SUPPORTED_STACK_ALIGNMENT) + { + addr = align_dynamic_address (p->base_addr, p->align); + mark_reg_pointer (addr, p->align); + } + + insert_temp_slot_address (addr, p); /* Create a new MEM rtx to avoid clobbering MEM flags of old slots. */ - slot = gen_rtx_MEM (mode, XEXP (p->slot, 0)); + slot = gen_rtx_MEM (mode, addr); vec_safe_push (stack_slot_list, slot); /* If we know the alias set for the memory that will be used, use @@ -1060,7 +1138,8 @@ combine_temp_slots (void) next = p->next; - if (GET_MODE (p->slot) != BLKmode) + if (GET_MODE (p->slot) != BLKmode + || p->align > MAX_SUPPORTED_STACK_ALIGNMENT) continue; for (q = p->next; q; q = next_q) @@ -1069,7 +1148,8 @@ combine_temp_slots (void) next_q = q->next; - if (GET_MODE (q->slot) != BLKmode) + if (GET_MODE (q->slot) != BLKmode + || q->align > MAX_SUPPORTED_STACK_ALIGNMENT) continue; if (known_eq (p->base_offset + p->full_size, q->base_offset)) @@ -2957,21 +3037,8 @@ assign_parm_setup_block (struct assign_parm_data_all *all, ? MAX (DECL_ALIGN (parm), BITS_PER_WORD) : DECL_ALIGN (parm)); SET_DECL_ALIGN (parm, parm_align); - if (DECL_ALIGN (parm) > MAX_SUPPORTED_STACK_ALIGNMENT) - { - rtx allocsize = gen_int_mode (size_stored, Pmode); - get_dynamic_stack_size (&allocsize, 0, DECL_ALIGN (parm), NULL); - stack_parm = assign_stack_local (BLKmode, UINTVAL (allocsize), - MAX_SUPPORTED_STACK_ALIGNMENT); - rtx addr = align_dynamic_address (XEXP (stack_parm, 0), - DECL_ALIGN (parm)); - mark_reg_pointer (addr, DECL_ALIGN (parm)); - stack_parm = gen_rtx_MEM (GET_MODE (stack_parm), addr); - MEM_NOTRAP_P (stack_parm) = 1; - } - else - stack_parm = assign_stack_local (BLKmode, size_stored, - DECL_ALIGN (parm)); + stack_parm = assign_stack_local (BLKmode, size_stored, + DECL_ALIGN (parm)); if (known_eq (GET_MODE_SIZE (GET_MODE (entry_parm)), size)) PUT_MODE (stack_parm, GET_MODE (entry_parm)); set_mem_attributes (stack_parm, parm, 1); diff --git a/gcc/lra-spills.cc b/gcc/lra-spills.cc index 07801e39d5cd..f55839f50b7b 100644 --- a/gcc/lra-spills.cc +++ b/gcc/lra-spills.cc @@ -146,8 +146,9 @@ assign_mem_slot (int i) x = slots[slot_num].mem; if (!x) { - x = assign_stack_local (BLKmode, slots[slot_num].size, - slots[slot_num].align); + x = assign_stack_local_1 (BLKmode, slots[slot_num].size, + slots[slot_num].align, + ASLK_RECORD_PAD | ASLK_REDUCE_ALIGN); slots[slot_num].mem = x; } From 4a0bca2e9e919353574bef3a200229e29d435679 Mon Sep 17 00:00:00 2001 From: Oleg Tolmatcev Date: Wed, 16 Sep 2026 20:41:25 +0200 Subject: [PATCH 417/584] testsuite, i386: add tests for over-aligned stack objects [PR54412] Cover the places where an object needs more alignment than the frame can give it: the home slot of a by-value parameter, both when nothing else sees it and when its address escapes to a callee, the hidden copy the caller makes when the MS ABI passes an argument by reference, and a copy that GCC merely prefers to over-align. Where nothing else sees the object, it only has to be stored with a move that matches its slot, so those tests scan for the move GCC selects. Where the address escapes, the object must really be aligned, so those tests scan for the mask that rounds the slot address up. None of them runs the code: a slot that is short of the alignment the object needs still lands on a 32-byte boundary about half the time. The dg-do run C++ test covers an over-aligned temporary used on both arms of a branch. gcc/testsuite/ChangeLog: PR target/54412 * g++.target/i386/pr54412-highpart-extract-rt.C: New test. * gcc.target/i386/pr54412-aligned-struct-byval-temp.c: New test. * gcc.target/i386/pr54412-blkmode-temp-biggest-align.c: New test. * gcc.target/i386/pr54412-escaping-param.c: New test. * gcc.target/i386/pr54412-m256-byval-param.c: New test. Signed-off-by: Oleg Tolmatcev Signed-off-by: Jonathan Yong <10walls@gmail.com> --- .../i386/pr54412-highpart-extract-rt.C | 110 ++++++++++++++++++ .../i386/pr54412-aligned-struct-byval-temp.c | 16 +++ .../i386/pr54412-blkmode-temp-biggest-align.c | 16 +++ .../gcc.target/i386/pr54412-escaping-param.c | 20 ++++ .../i386/pr54412-m256-byval-param.c | 22 ++++ 5 files changed, 184 insertions(+) create mode 100644 gcc/testsuite/g++.target/i386/pr54412-highpart-extract-rt.C create mode 100644 gcc/testsuite/gcc.target/i386/pr54412-aligned-struct-byval-temp.c create mode 100644 gcc/testsuite/gcc.target/i386/pr54412-blkmode-temp-biggest-align.c create mode 100644 gcc/testsuite/gcc.target/i386/pr54412-escaping-param.c create mode 100644 gcc/testsuite/gcc.target/i386/pr54412-m256-byval-param.c diff --git a/gcc/testsuite/g++.target/i386/pr54412-highpart-extract-rt.C b/gcc/testsuite/g++.target/i386/pr54412-highpart-extract-rt.C new file mode 100644 index 000000000000..7c1d48c5d512 --- /dev/null +++ b/gcc/testsuite/g++.target/i386/pr54412-highpart-extract-rt.C @@ -0,0 +1,110 @@ +/* PR target/54412 */ +/* Check that "assign_stack_temp_for_type" safely reuses an over-aligned + temporary across control-flow paths. The stack slot used by Vec4q (z0) + is reused for Vec4q (z1). Its dynamically aligned address is computed in + the first branch and held in a pseudo-register that is undefined along the + second path, so the address must be recomputed when the slot is reused. */ +/* { dg-do run { target { x86_64-*-mingw* && avx2 } } } */ +/* { dg-options "-O0 -mavx2 -std=gnu++17 -fno-omit-frame-pointer" } */ +/* { dg-require-effective-target avx2_runtime } */ + +#include "avx2-check.h" + +typedef long long v4di __attribute__ ((vector_size (32), aligned (32))); + +static inline v4di +make_v4di (long long a0, long long a1, long long a2, long long a3) +{ + return (v4di) { a0, a1, a2, a3 }; +} + +struct Vec256b +{ + v4di ymm; + + Vec256b () = default; + explicit Vec256b (v4di x) : ymm (x) {} + + __attribute__ ((noinline, noclone)) + operator v4di () const + { + return ymm; + } +}; + +struct Vec4q : public Vec256b +{ + Vec4q () = default; + + __attribute__ ((noinline, noclone)) + explicit Vec4q (v4di x) + { + ymm = x; + } + + __attribute__ ((noinline, noclone)) + long long + extract (int index) const + { + long long elems[4] __attribute__ ((aligned (32))); + __builtin_memcpy (elems, &ymm, sizeof (elems)); + return elems[index & 3]; + } +}; + +struct Vec8q +{ + Vec256b z0; + Vec256b z1; + + Vec8q () = default; + Vec8q (Vec256b a, Vec256b b) : z0 (a), z1 (b) {} + + __attribute__ ((noinline, noclone)) + long long + extract (int index) const + { + if ((unsigned) index < 4) + return Vec4q (z0).extract (index); + + return Vec4q (z1).extract (index - 4); + } +}; + +__attribute__ ((noinline, noclone)) +static Vec8q +passthru (Vec8q x) +{ + return x; +} + +__attribute__ ((noinline, noclone)) +static long long +call_extract (Vec8q x, int index) +{ + Vec8q y = passthru (x); + + if ((unsigned) index >= 4) + { + register void *p __asm__ ("rbx") = (void *) 2; + asm volatile ("" : : "r" (p) : "memory"); + } + + return y.extract (index); +} + +static void +avx2_test () +{ + Vec8q x (Vec256b (make_v4di (101, 102, 103, 104)), + Vec256b (make_v4di (201, 202, 203, 204))); + + if (call_extract (x, 1) != 102) + __builtin_abort (); + + if (call_extract (x, 5) != 202) + __builtin_abort (); + + if (call_extract (x, 7) != 204) + __builtin_abort (); +} diff --git a/gcc/testsuite/gcc.target/i386/pr54412-aligned-struct-byval-temp.c b/gcc/testsuite/gcc.target/i386/pr54412-aligned-struct-byval-temp.c new file mode 100644 index 000000000000..5f8a2409c6c9 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr54412-aligned-struct-byval-temp.c @@ -0,0 +1,16 @@ +/* PR target/54412 */ +/* Check that "assign_stack_temp_for_type" preserves the required alignment + of a caller-created temporary for a by-reference argument. */ +/* { dg-do compile { target x86_64-*-mingw* } } */ +/* { dg-options "-O2" } */ +/* { dg-final { scan-assembler {and[lq]?\t\$-32,} } } */ + +struct S { char c[32]; } __attribute__((aligned (32))); + +void sink (struct S); + +void +caller (struct S *p) +{ + sink (*p); +} diff --git a/gcc/testsuite/gcc.target/i386/pr54412-blkmode-temp-biggest-align.c b/gcc/testsuite/gcc.target/i386/pr54412-blkmode-temp-biggest-align.c new file mode 100644 index 000000000000..72cbc1ee30d9 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr54412-blkmode-temp-biggest-align.c @@ -0,0 +1,16 @@ +/* PR target/54412 */ +/* Check that "assign_stack_temp_for_type" does not overstate the alignment + of a "BLKmode" temporary. */ +/* { dg-do compile { target x86_64-*-mingw* } } */ +/* { dg-options "-O2 -mavx" } */ +/* { dg-final { scan-assembler-not {vmov(aps|dqa)\t%ymm[0-9]+, [0-9-]*\(%r[sb]p\)} } } */ + +struct S { char c[32]; }; + +void sink (struct S); + +void +caller (struct S *p) +{ + sink (*p); +} diff --git a/gcc/testsuite/gcc.target/i386/pr54412-escaping-param.c b/gcc/testsuite/gcc.target/i386/pr54412-escaping-param.c new file mode 100644 index 000000000000..fb3c0bf534bb --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr54412-escaping-param.c @@ -0,0 +1,20 @@ +/* PR target/54412 */ +/* Check that "assign_parm_setup_reg" correctly aligns the local copy of an + indirectly passed parameter whose address escapes. */ +/* { dg-do compile { target x86_64-*-mingw* } } */ +/* { dg-options "-O2 -mavx" } */ +/* { dg-final { scan-assembler {and[lq]?\t\$-32,} } } */ + +typedef float v8sf __attribute__ ((vector_size (32))); + +__attribute__ ((noipa)) v8sf +get (const v8sf *p) +{ + return *p; +} + +v8sf +f (v8sf x) +{ + return get (&x); +} diff --git a/gcc/testsuite/gcc.target/i386/pr54412-m256-byval-param.c b/gcc/testsuite/gcc.target/i386/pr54412-m256-byval-param.c new file mode 100644 index 000000000000..d2d1dcfcee06 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr54412-m256-byval-param.c @@ -0,0 +1,22 @@ +/* PR target/54412 */ +/* Check that "assign_parm_setup_reg" does not emit an aligned store to an + under-aligned local copy of an indirectly passed "__m256" parameter. + + MSYS2/MINGW-packages#1209: X needs 32-byte alignment, but under SEH the + frame is only 16-byte aligned. GCC put its home slot in a plain 16-byte + slot, still treated it as 32-byte aligned and stored X with vmovaps. + Nothing else sees X, so the move only has to match the slot. Check the + move instead of running: the bad slot is 32-byte aligned about half the + time. */ +/* { dg-do compile { target x86_64-*-mingw* } } */ +/* { dg-options "-O0 -mavx" } */ +/* { dg-final { scan-assembler-not {vmovaps\t%ymm0, -[0-9]+\(%rbp\)} } } */ + +typedef float __m256 __attribute__ ((__vector_size__ (32), + __may_alias__)); + +void +foo (__m256 x) +{ + (void) x; +} From d9884aac17cbf942fd980fbf3bfae300eb7cb2a9 Mon Sep 17 00:00:00 2001 From: "Jose E. Marchesi" Date: Wed, 23 Sep 2026 10:44:35 +0200 Subject: [PATCH 418/584] a68: introduce a68_add_global_decl and a68_global_context Signed-off-by: Jose E. Marchesi gcc/algol68/ChangeLog * a68.h: Add prototypes for a68_add_global_decl and a68_global_context. * a68-low-ranges.cc (a68_add_global_decl): New function. (a68_global_context): Likewise. --- gcc/algol68/a68-low-ranges.cc | 29 +++++++++++++++++++++++++++++ gcc/algol68/a68.h | 2 ++ 2 files changed, 31 insertions(+) diff --git a/gcc/algol68/a68-low-ranges.cc b/gcc/algol68/a68-low-ranges.cc index 70e189344d97..f6058fbd357d 100644 --- a/gcc/algol68/a68-low-ranges.cc +++ b/gcc/algol68/a68-low-ranges.cc @@ -253,6 +253,27 @@ a68_add_stmt (tree exp) ¤t_range->stmt_list); } +/* Add a new declaration to the global range. */ + +void +a68_add_global_decl (tree decl) +{ + gcc_assert (current_range != NULL); + + tree n = global_range->names; + while (n != decl && n != NULL) + n = TREE_CHAIN (n); + if (n != decl) + { + if (decl != current_function_decl) + DECL_CONTEXT (decl) = global_range->context; + /* Note this list needs to be in reverse order for compatibility with + GCC. */ + TREE_CHAIN (decl) = global_range->names; + global_range->names = decl; + } +} + /* Add a new declaration to the current range. */ void @@ -332,6 +353,14 @@ a68_range_context (void) return current_range->context; } +/* Get the global context. */ + +tree +a68_global_context (void) +{ + return global_range->context; +} + /* Get the list of declarations in the current range. */ tree diff --git a/gcc/algol68/a68.h b/gcc/algol68/a68.h index 00b99075f272..7130cd0948ad 100644 --- a/gcc/algol68/a68.h +++ b/gcc/algol68/a68.h @@ -748,10 +748,12 @@ void a68_push_serial_clause_range (MOID_T *clause_mode, bool save_restore_stack = false); tree a68_pop_serial_clause_range (void); void a68_add_stmt (tree exp); +void a68_add_global_decl (tree decl); void a68_add_decl (tree decl); void a68_add_decl_expr (tree decl_expr); void a68_add_completer (void); tree a68_range_context (void); +tree a68_global_context (void); tree a68_range_names (void); tree a68_range_stmt_list (void); From 444cb6149361d3c6220564f85ecacfd12a5b325e Mon Sep 17 00:00:00 2001 From: "Jose E. Marchesi" Date: Wed, 23 Sep 2026 10:47:45 +0200 Subject: [PATCH 419/584] a68: register publicized type_decls in the global range Signed-off-by: Jose E. Marchesi gcc/algol68/ChangeLog * a68-low-decls.cc (a68_lower_mode_declaration): Use a68_add_global_decl for mode declarations in public ranges. --- gcc/algol68/a68-low-decls.cc | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/gcc/algol68/a68-low-decls.cc b/gcc/algol68/a68-low-decls.cc index 532f5b65c3bc..1c77bb560194 100644 --- a/gcc/algol68/a68-low-decls.cc +++ b/gcc/algol68/a68-low-decls.cc @@ -57,11 +57,9 @@ mode declaration, comma symbol, defining indicant, equals symbol, void symbol. - Each mode declaration lowers into a TYPE_DECL, which are chained in the - current block. This function returns void_node. - - Note that the defining indicant is already annotated with the declared mode - so there is no need to go hunting for the declarer in the subtree. */ + Each mode declaration lowers into a TYPE_DECL so the mode is reflected in + the debug info. This is done by linking the decl to the type via + TYPE_STUB_DECL and by filling in the TYPE_NAME of the base type. */ tree a68_lower_mode_declaration (NODE_T *p, LOW_CTX_T ctx) @@ -87,19 +85,22 @@ a68_lower_mode_declaration (NODE_T *p, LOW_CTX_T ctx) } } - /* Create a TYPE_DECL declaration for the defined mode and chain it in the - current block. */ - tree ctype = CTYPE (MOID (defining_indicant)); + tree type = CTYPE (MOID (defining_indicant)); + tree decl_name = a68_get_mangled_indicant (NSYMBOL (defining_indicant), - ctx.module_definition_name); + ctx.module_definition_name); tree decl = build_decl (a68_get_node_location (p), - TYPE_DECL, decl_name, ctype); + TYPE_DECL, decl_name, type); SET_DECL_ASSEMBLER_NAME (decl, decl_name); TREE_PUBLIC (decl) = 1; - TYPE_CONTEXT (ctype) = DECL_CONTEXT (decl); - TYPE_NAME (ctype) = decl; - TYPE_STUB_DECL (ctype) = decl; - a68_add_decl (decl); + + if (PUBLIC_RANGE (TABLE (TAX (defining_indicant)))) + a68_add_global_decl (decl); + else + a68_add_decl (decl); + + TYPE_CONTEXT (type) = DECL_CONTEXT (decl); + TYPE_NAME (type) = decl; return void_node; } @@ -159,7 +160,7 @@ a68_lower_variable_declaration (NODE_T *p, LOW_CTX_T ctx) if (IS (q, PUBLIC_SYMBOL)) FORWARD (q); - + if (IS (q, QUALIFIER)) { /* The qualifier determines what kind of generator is used in the From 655391b46ea9aa88e73e02ba1393de3a5c28b888 Mon Sep 17 00:00:00 2001 From: "Jose E. Marchesi" Date: Wed, 23 Sep 2026 11:09:19 +0200 Subject: [PATCH 420/584] a68: use front-end type nodes consistently in the codebase Our front-end types a68_*_type, which are initialized in a68_build_a68_type_nodes, are references to the proper C types. This patch makes sure that the front-end code always use the a68_*_type rather than the C types, except for communicating with external entities that require a C type such as libcalls. Signed-off-by: Jose E. Marchesi gcc/algol68/ChangeLog * a68-low-bits.cc: Use front-end type nodes consistently. * a68-low-bools.cc: Likewise. * a68-low-chars.cc: Likewise. * a68-low-clauses.cc: Likewise. * a68-low-ints.cc: Likewise. * a68-low-multiples.cc: Likewise. * a68-low-prelude.cc: Likewise. * a68-low-reals.cc: Likewise. * a68-low-unions.cc: Likewise. * a68-low-units.cc: Likewise. * a68-low.cc: Likewise. --- gcc/algol68/a68-low-bits.cc | 10 +++++----- gcc/algol68/a68-low-bools.cc | 4 ++-- gcc/algol68/a68-low-chars.cc | 30 +++++++++++++++--------------- gcc/algol68/a68-low-clauses.cc | 12 ++++++------ gcc/algol68/a68-low-ints.cc | 16 ++++++++-------- gcc/algol68/a68-low-multiples.cc | 20 ++++++++++---------- gcc/algol68/a68-low-prelude.cc | 2 +- gcc/algol68/a68-low-reals.cc | 16 ++++++++-------- gcc/algol68/a68-low-unions.cc | 2 +- gcc/algol68/a68-low-units.cc | 10 +++++----- gcc/algol68/a68-low.cc | 6 +++--- 11 files changed, 64 insertions(+), 64 deletions(-) diff --git a/gcc/algol68/a68-low-bits.cc b/gcc/algol68/a68-low-bits.cc index 2a4cd8b5adad..12b91cd66699 100644 --- a/gcc/algol68/a68-low-bits.cc +++ b/gcc/algol68/a68-low-bits.cc @@ -225,10 +225,10 @@ a68_bits_elem (NODE_T *p, tree pos, tree bits) filename, build_int_cst (unsigned_type_node, lineno), fold_convert (ssizetype, pos)); - tree check = fold_build2 (TRUTH_AND_EXPR, integer_type_node, - fold_build2 (GT_EXPR, integer_type_node, + tree check = fold_build2 (TRUTH_AND_EXPR, a68_int_type, + fold_build2 (GT_EXPR, a68_int_type, pos, fold_convert (TREE_TYPE (pos), integer_zero_node)), - fold_build2 (LE_EXPR, integer_type_node, + fold_build2 (LE_EXPR, a68_int_type, fold_convert (bitsizetype, pos), TYPE_SIZE (TREE_TYPE (bits)))); @@ -298,7 +298,7 @@ a68_bits_shift (NODE_T *p, tree shift, tree bits) tree a68_bits_eq (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, EQ_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, EQ_EXPR, a68_bool_type, a, b); } /* Given two bits values, build an expression that calculates whether A /= @@ -307,7 +307,7 @@ a68_bits_eq (tree a, tree b, location_t loc) tree a68_bits_ne (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, NE_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, NE_EXPR, a68_bool_type, a, b); } /* Set the bit NUMBIT in BITS. diff --git a/gcc/algol68/a68-low-bools.cc b/gcc/algol68/a68-low-bools.cc index 000e919407d9..f8df5233ad9f 100644 --- a/gcc/algol68/a68-low-bools.cc +++ b/gcc/algol68/a68-low-bools.cc @@ -64,7 +64,7 @@ a68_bool_abs (tree val) tree a68_bool_eq (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, EQ_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, EQ_EXPR, a68_bool_type, a, b); } /* Given two boolean values, build an expression that calculates whether A /= @@ -73,5 +73,5 @@ a68_bool_eq (tree a, tree b, location_t loc) tree a68_bool_ne (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, NE_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, NE_EXPR, a68_bool_type, a, b); } diff --git a/gcc/algol68/a68-low-chars.cc b/gcc/algol68/a68-low-chars.cc index 381e455b7f1f..b60b0ec3127c 100644 --- a/gcc/algol68/a68-low-chars.cc +++ b/gcc/algol68/a68-low-chars.cc @@ -72,20 +72,20 @@ a68_char_repr (NODE_T *p, tree val) tree val_type = TREE_TYPE (val); /* (c >= 0 && c < 0xd800) */ - tree range1 = fold_build2 (TRUTH_AND_EXPR, integer_type_node, - fold_build2 (GE_EXPR, integer_type_node, + tree range1 = fold_build2 (TRUTH_AND_EXPR, a68_int_type, + fold_build2 (GE_EXPR, a68_int_type, c, fold_convert (val_type, integer_zero_node)), - fold_build2 (LT_EXPR, integer_type_node, + fold_build2 (LT_EXPR, a68_int_type, c, build_int_cst (val_type, 0xd800))); /* (c >= 0xe000 && c < 0x110000) */ - tree range2 = fold_build2 (TRUTH_AND_EXPR, integer_type_node, - fold_build2 (GE_EXPR, integer_type_node, + tree range2 = fold_build2 (TRUTH_AND_EXPR, a68_int_type, + fold_build2 (GE_EXPR, a68_int_type, c, build_int_cst (val_type, 0xe000)), - fold_build2 (LT_EXPR, integer_type_node, + fold_build2 (LT_EXPR, a68_int_type, c, build_int_cst (val_type, 0x110000))); tree notvalid = fold_build1 (TRUTH_NOT_EXPR, - integer_type_node, - fold_build2 (TRUTH_OR_EXPR, integer_type_node, + a68_int_type, + fold_build2 (TRUTH_OR_EXPR, a68_int_type, range1, range2)); /* Call to the runtime run-time error handler. */ @@ -101,7 +101,7 @@ a68_char_repr (NODE_T *p, tree val) /* Return the REPR of the given integer value, or raise run-time error. */ return fold_build2 (COMPOUND_EXPR, a68_char_type, - fold_build3 (COND_EXPR, integer_type_node, + fold_build3 (COND_EXPR, a68_int_type, notvalid, call, integer_zero_node), fold_convert (a68_char_type, c)); @@ -121,7 +121,7 @@ a68_char_abs (tree val) tree a68_char_eq (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, EQ_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, EQ_EXPR, a68_bool_type, a, b); } /* Given two characters, build an expression that calculates whether A /= @@ -130,7 +130,7 @@ a68_char_eq (tree a, tree b, location_t loc) tree a68_char_ne (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, NE_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, NE_EXPR, a68_bool_type, a, b); } /* Given two characters, build an expression that calculates @@ -139,7 +139,7 @@ a68_char_ne (tree a, tree b, location_t loc) tree a68_char_lt (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, LT_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, LT_EXPR, a68_bool_type, a, b); } /* Given two characters, build an expression that calculates @@ -148,7 +148,7 @@ a68_char_lt (tree a, tree b, location_t loc) tree a68_char_le (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, LE_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, LE_EXPR, a68_bool_type, a, b); } /* Given two characters, build an expression that calculates @@ -157,7 +157,7 @@ a68_char_le (tree a, tree b, location_t loc) tree a68_char_gt (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, GT_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, GT_EXPR, a68_bool_type, a, b); } /* Given two characters, build an expression that calculates @@ -166,5 +166,5 @@ a68_char_gt (tree a, tree b, location_t loc) tree a68_char_ge (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, GE_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, GE_EXPR, a68_bool_type, a, b); } diff --git a/gcc/algol68/a68-low-clauses.cc b/gcc/algol68/a68-low-clauses.cc index 683755217d4c..168b3f49fe52 100644 --- a/gcc/algol68/a68-low-clauses.cc +++ b/gcc/algol68/a68-low-clauses.cc @@ -375,7 +375,7 @@ a68_lower_loop_clause (NODE_T *p ATTRIBUTE_UNUSED, to_part = a68_lower_tmpvar ("to_part%", TREE_TYPE (to_part), to_part); /* We need to detect overflow/underflow of the iterator. */ - overflow = a68_lower_tmpvar ("overflow%", boolean_type_node, + overflow = a68_lower_tmpvar ("overflow%", a68_bool_type, boolean_false_node); } @@ -403,7 +403,7 @@ a68_lower_loop_clause (NODE_T *p ATTRIBUTE_UNUSED, tree exit_condition = NULL_TREE; /* IF overflow OREL (by_part < 0 THEN iterator < to_part ELSE iterator > to_part) FI */ if (has_iterator) - exit_condition = fold_build2 (TRUTH_ORIF_EXPR, boolean_type_node, + exit_condition = fold_build2 (TRUTH_ORIF_EXPR, a68_bool_type, overflow, fold_build3 (COND_EXPR, a68_bool_type, @@ -449,9 +449,9 @@ a68_lower_loop_clause (NODE_T *p ATTRIBUTE_UNUSED, tree a = iterator; tree b = save_expr (by_part); tree sum = fold_build2 (PLUS_EXPR, type, a, b); - a68_add_stmt (fold_build2 (MODIFY_EXPR, boolean_type_node, + a68_add_stmt (fold_build2 (MODIFY_EXPR, a68_bool_type, overflow, - fold_build2 (LT_EXPR, boolean_type_node, + fold_build2 (LT_EXPR, a68_bool_type, fold_build2 (BIT_AND_EXPR, type, fold_build1 (BIT_NOT_EXPR, type, fold_build2 (BIT_XOR_EXPR, type, @@ -537,14 +537,14 @@ lower_unite_case_unit (NODE_T *p, { int index = a68_united_mode_index (enquiry_mode, MOID (pack)); tree expr = fold_build2 (EQ_EXPR, - boolean_type_node, + a68_bool_type, overhead, build_int_cst (TREE_TYPE (overhead), index)); if (entry_selected == NULL_TREE) entry_selected = expr; else entry_selected = fold_build2 (TRUTH_OR_EXPR, - boolean_type_node, + a68_bool_type, entry_selected, expr); } diff --git a/gcc/algol68/a68-low-ints.cc b/gcc/algol68/a68-low-ints.cc index d80d35e8302b..4bf97e9ebea4 100644 --- a/gcc/algol68/a68-low-ints.cc +++ b/gcc/algol68/a68-low-ints.cc @@ -94,11 +94,11 @@ a68_int_sign (tree val) val = save_expr (val); return fold_build3 (COND_EXPR, a68_int_type, - fold_build2 (EQ_EXPR, integer_type_node, val, zero), + fold_build2 (EQ_EXPR, a68_int_type, val, zero), build_int_cst (a68_int_type, 0), fold_build3 (COND_EXPR, a68_int_type, - fold_build2 (GT_EXPR, integer_type_node, val, zero), + fold_build2 (GT_EXPR, a68_int_type, val, zero), build_int_cst (a68_int_type, 1), build_int_cst (a68_int_type, -1))); } @@ -193,7 +193,7 @@ a68_int_div (MOID_T *m, tree a, tree b, location_t loc) tree a68_int_eq (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, EQ_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, EQ_EXPR, a68_bool_type, a, b); } /* Given two integral values of mode M, build an expression that calculates @@ -202,7 +202,7 @@ a68_int_eq (tree a, tree b, location_t loc) tree a68_int_ne (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, NE_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, NE_EXPR, a68_bool_type, a, b); } /* Given two integral values of mode M, build an expression that calculates @@ -211,7 +211,7 @@ a68_int_ne (tree a, tree b, location_t loc) tree a68_int_lt (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, LT_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, LT_EXPR, a68_bool_type, a, b); } /* Given two integral values of mode M, build an expression that calculates @@ -220,7 +220,7 @@ a68_int_lt (tree a, tree b, location_t loc) tree a68_int_le (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, LE_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, LE_EXPR, a68_bool_type, a, b); } /* Given two integral values of mode M, build an expression that calculates @@ -229,7 +229,7 @@ a68_int_le (tree a, tree b, location_t loc) tree a68_int_gt (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, GT_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, GT_EXPR, a68_bool_type, a, b); } /* Given two integral values of mode M, build an expression that calculates @@ -238,7 +238,7 @@ a68_int_gt (tree a, tree b, location_t loc) tree a68_int_ge (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, GE_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, GE_EXPR, a68_bool_type, a, b); } /* Given two integral values of mode M, build and expression that calculates the diff --git a/gcc/algol68/a68-low-multiples.cc b/gcc/algol68/a68-low-multiples.cc index 3f63d7d93b2d..fb1683eeac2c 100644 --- a/gcc/algol68/a68-low-multiples.cc +++ b/gcc/algol68/a68-low-multiples.cc @@ -544,7 +544,7 @@ a68_multiple_slice (NODE_T *p, fold_build2 (LE_EXPR, ssizetype, lower_bound, upper_bound), fold_build2 (TRUTH_AND_EXPR, - boolean_type_node, + a68_bool_type, fold_build2 (GE_EXPR, ssizetype, fold_convert (ssizetype, index_expr), @@ -908,9 +908,9 @@ a68_boundable_dim_check (NODE_T *p, tree boundable_dim, tree dim) boundable_dim, dim); call = fold_build2 (COMPOUND_EXPR, a68_bool_type, call, boolean_false_node); - tree dim_check = fold_build2 (TRUTH_AND_EXPR, boolean_type_node, - fold_build2 (GT_EXPR, boolean_type_node, dim, size_zero_node), - fold_build2 (LE_EXPR, boolean_type_node, dim, boundable_dim)); + tree dim_check = fold_build2 (TRUTH_AND_EXPR, a68_bool_type, + fold_build2 (GT_EXPR, a68_bool_type, dim, size_zero_node), + fold_build2 (LE_EXPR, a68_bool_type, dim, boundable_dim)); return fold_build2_loc (a68_get_node_location (p), TRUTH_ORIF_EXPR, ssizetype, @@ -984,7 +984,7 @@ a68_multiple_bounds_check (NODE_T *p, tree dim, fold_build2 (LE_EXPR, ssizetype, lower_bound, upper_bound), fold_build2 (TRUTH_AND_EXPR, - boolean_type_node, + a68_bool_type, fold_build2 (GE_EXPR, ssizetype, fold_convert (ssizetype, index), @@ -1037,10 +1037,10 @@ a68_multiple_bounds_check_equal (NODE_T *p, tree m1, tree m2) tree ub2 = save_expr (a68_multiple_upper_bound (m2, dim_tree)); tree bounds_equal = fold_build2 (TRUTH_AND_EXPR, - boolean_type_node, - fold_build2 (EQ_EXPR, boolean_type_node, + a68_bool_type, + fold_build2 (EQ_EXPR, a68_bool_type, lb1, lb2), - fold_build2 (EQ_EXPR, boolean_type_node, + fold_build2 (EQ_EXPR, a68_bool_type, ub1, ub2)); unsigned int lineno = LINE_NUMBER (p); @@ -1053,10 +1053,10 @@ a68_multiple_bounds_check_equal (NODE_T *p, tree m1, tree m2) build_int_cst (unsigned_type_node, lineno), dim_plus_one, lb1, ub1, lb2, ub2); - call = fold_build2 (COMPOUND_EXPR, boolean_type_node, call, boolean_false_node); + call = fold_build2 (COMPOUND_EXPR, a68_bool_type, call, boolean_false_node); tree check = fold_build2_loc (a68_get_node_location (p), - TRUTH_ORIF_EXPR, boolean_type_node, + TRUTH_ORIF_EXPR, a68_bool_type, bounds_equal, call); a68_add_stmt (check); diff --git a/gcc/algol68/a68-low-prelude.cc b/gcc/algol68/a68-low-prelude.cc index 804febf2c613..eea57ae666cc 100644 --- a/gcc/algol68/a68-low-prelude.cc +++ b/gcc/algol68/a68-low-prelude.cc @@ -731,7 +731,7 @@ elems (NODE_T *p, tree boundable, tree dim) size_one_node); tree elems = fold_build3 (COND_EXPR, sizetype, - fold_build2 (LT_EXPR, boolean_type_node, + fold_build2 (LT_EXPR, a68_bool_type, upper_bound, lower_bound), size_zero_node, non_flat); diff --git a/gcc/algol68/a68-low-reals.cc b/gcc/algol68/a68-low-reals.cc index 418fbc8b796a..f24add7b43f1 100644 --- a/gcc/algol68/a68-low-reals.cc +++ b/gcc/algol68/a68-low-reals.cc @@ -140,11 +140,11 @@ a68_real_sign (tree val) val = save_expr (val); return fold_build3 (COND_EXPR, a68_int_type, - build2 (EQ_EXPR, integer_type_node, val, zero), + build2 (EQ_EXPR, a68_int_type, val, zero), build_int_cst (a68_int_type, 0), fold_build3 (COND_EXPR, a68_int_type, - fold_build2 (GT_EXPR, integer_type_node, val, zero), + fold_build2 (GT_EXPR, a68_int_type, val, zero), build_int_cst (a68_int_type, 1), build_int_cst (a68_int_type, -1))); } @@ -507,7 +507,7 @@ a68_real_div (MOID_T *m, tree a, tree b, location_t loc) tree a68_real_eq (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, EQ_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, EQ_EXPR, a68_bool_type, a, b); } /* Given two real values of mode M, build an expression that calculates whether @@ -516,7 +516,7 @@ a68_real_eq (tree a, tree b, location_t loc) tree a68_real_ne (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, NE_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, NE_EXPR, a68_bool_type, a, b); } /* Given two real values of mode M, build an expression that calculates whether @@ -525,7 +525,7 @@ a68_real_ne (tree a, tree b, location_t loc) tree a68_real_lt (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, LT_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, LT_EXPR, a68_bool_type, a, b); } /* Given two real values of mode M, build an expression that calculates @@ -534,7 +534,7 @@ a68_real_lt (tree a, tree b, location_t loc) tree a68_real_le (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, LE_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, LE_EXPR, a68_bool_type, a, b); } /* Given two real values of mode M, build an expression that calculates whether @@ -543,7 +543,7 @@ a68_real_le (tree a, tree b, location_t loc) tree a68_real_gt (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, GT_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, GT_EXPR, a68_bool_type, a, b); } /* Given two real values of mode M, build an expression that calculates whether @@ -552,7 +552,7 @@ a68_real_gt (tree a, tree b, location_t loc) tree a68_real_ge (tree a, tree b, location_t loc) { - return fold_build2_loc (loc, GE_EXPR, boolean_type_node, a, b); + return fold_build2_loc (loc, GE_EXPR, a68_bool_type, a, b); } /* Exponentiation involving real values. diff --git a/gcc/algol68/a68-low-unions.cc b/gcc/algol68/a68-low-unions.cc index f775877f3271..7b84be014667 100644 --- a/gcc/algol68/a68-low-unions.cc +++ b/gcc/algol68/a68-low-unions.cc @@ -126,7 +126,7 @@ a68_union_translate_overhead (MOID_T *from, tree from_overhead, if (a68_union_contains_mode (to, mode)) { to_overhead = fold_build3 (COND_EXPR, sizetype, - fold_build2 (EQ_EXPR, boolean_type_node, + fold_build2 (EQ_EXPR, a68_bool_type, from_overhead, size_int (i)), size_int (a68_united_mode_index (to, mode)), diff --git a/gcc/algol68/a68-low-units.cc b/gcc/algol68/a68-low-units.cc index ac7accd9051a..b53a1c1b50fe 100644 --- a/gcc/algol68/a68-low-units.cc +++ b/gcc/algol68/a68-low-units.cc @@ -324,11 +324,11 @@ a68_lower_denotation (NODE_T *p, LOW_CTX_T ctx) s = SUB (p); if (moid == M_REAL) - type = float_type_node; + type = a68_real_type; else if (moid == M_LONG_REAL) - type = double_type_node; + type = a68_long_real_type; else if (moid == M_LONG_LONG_REAL) - type = long_double_type_node; + type = a68_long_long_real_type; else gcc_unreachable (); @@ -412,7 +412,7 @@ a68_lower_identity_relation (NODE_T *p, LOW_CTX_T ctx) gcc_unreachable (); return fold_build2_loc (a68_get_node_location (p), - code, boolean_type_node, op1, op2); + code, a68_bool_type, op1, op2); } /* Lower AND_FUNCTION and OR_FUNCTION. @@ -445,7 +445,7 @@ a68_lower_logic_function (NODE_T *p, LOW_CTX_T ctx) gcc_unreachable (); return fold_build2_loc (a68_get_node_location (p), - code, boolean_type_node, op1, op2); + code, a68_bool_type, op1, op2); } /* Lower a primary. diff --git a/gcc/algol68/a68-low.cc b/gcc/algol68/a68-low.cc index 62fbdc49d3fa..bc9da115d15b 100644 --- a/gcc/algol68/a68-low.cc +++ b/gcc/algol68/a68-low.cc @@ -916,13 +916,13 @@ a68_low_dup (tree expr, bool use_heap) a68_add_decl (continue_label_decl); a68_add_stmt (fold_build2 (TRUTH_ORIF_EXPR, - integer_type_node, + a68_int_type, fold_build2 (EQ_EXPR, - integer_type_node, + a68_int_type, a68_union_overhead (dup), size_int (a68_united_mode_index (union_mode, MOID (pack)))), fold_build2 (COMPOUND_EXPR, - integer_type_node, + a68_int_type, build1 (GOTO_EXPR, void_type_node, continue_label_decl), integer_zero_node))); a68_add_stmt (fold_build2 (MODIFY_EXPR, type, From ac02dbd44494c0f1185c3e50576043491ea638bc Mon Sep 17 00:00:00 2001 From: "Jose E. Marchesi" Date: Wed, 23 Sep 2026 22:00:17 +0200 Subject: [PATCH 421/584] a68: emit proper DW_DIE_typedef in DWARF In the Algol 68 front-end the mode declarations introduce new mode indicants in their respective ranges, but the parser very early replace them by the modes they denote. This patch uses GENERIC features so proper DW_DIE_typedef dies get generated in DWARF. This commit Signed-off-by: Jose E. Marchesi gcc/algol68/ChangeLog * a68-types.h (struct TAG_T): Add field ctyp. * a68-parser.cc (a68_new_tag): Initialize CTYPE. * a68-low-decls.cc (fish_declarer_from_tree): New function. (grok_typedef_in_decl): Likewise. (a68_lower_mode_declaration): Install typedef variant type for a defining-indicant in the symtab. (a68_lower_variable_declaration): Call grok_typedef_in_decl. (a68_lower_identity_declaration): Likewise. * a68-low-ranges.cc (a68_pop_serial_clause_range): Compare main variant types in sanity check at block exit. * a68-low.cc (a68_low_assignation): Likewise in assignation. --- gcc/algol68/a68-low-decls.cc | 87 +++++++++++++++++++++++++++++++---- gcc/algol68/a68-low-ranges.cc | 15 ++++-- gcc/algol68/a68-low.cc | 13 ++++-- gcc/algol68/a68-parser.cc | 1 + gcc/algol68/a68-types.h | 11 ++++- 5 files changed, 108 insertions(+), 19 deletions(-) diff --git a/gcc/algol68/a68-low-decls.cc b/gcc/algol68/a68-low-decls.cc index 1c77bb560194..606e5fdf5efd 100644 --- a/gcc/algol68/a68-low-decls.cc +++ b/gcc/algol68/a68-low-decls.cc @@ -42,6 +42,52 @@ #include "a68.h" +/* Auxiliary function to fish a declarer from some software construct. The + first declarer found is returned, or NULL_TREE if none is found. */ + +static NODE_T * +fish_declarer_from_tree (NODE_T *p) +{ + for (; p != NO_NODE; p = NEXT (p)) + { + if (IS (p, DECLARER)) + return p; + + NODE_T *declarer = fish_declarer_from_tree (SUB (p)); + if (declarer != NO_NODE) + return declarer; + } + + return NO_NODE; +} + +/* If the given DECLARER is an indicant whose symtab entry is annotated with a + CTYPE, then it is a typedef type derived from the type installed in the + given DECL. The derived type was created and installed in the symtab entry + by a68_lower_mode_declaration. Install it in DECL so the typedef gets + reflected intthe DWARF that gets generated for DECL. */ + +static void +grok_typedef_in_decl (tree decl, NODE_T *declarer, bool use_pointer = false) +{ + if (SUB (declarer) != NO_NODE && IS (SUB (declarer), INDICANT)) + { + NODE_T *indicant = SUB (declarer); + + /* Note that indicants for standard modes do not have symtab entries. */ + if (TAX (indicant) != NO_TAG && CTYPE (TAX (indicant)) != NULL_TREE) + { + if (use_pointer) + { + gcc_assert (POINTER_TYPE_P (TREE_TYPE (decl))); + TREE_TYPE (TREE_TYPE (decl)) = CTYPE (TAX (indicant)); + } + else + TREE_TYPE (decl) = CTYPE (TAX (indicant)); + } + } +} + /* Lower one or more mode declarations. mode declaration : mode symbol, defining indicant, @@ -86,7 +132,6 @@ a68_lower_mode_declaration (NODE_T *p, LOW_CTX_T ctx) } tree type = CTYPE (MOID (defining_indicant)); - tree decl_name = a68_get_mangled_indicant (NSYMBOL (defining_indicant), ctx.module_definition_name); tree decl = build_decl (a68_get_node_location (p), @@ -99,8 +144,21 @@ a68_lower_mode_declaration (NODE_T *p, LOW_CTX_T ctx) else a68_add_decl (decl); + DECL_ORIGINAL_TYPE (decl) = type; + + tree variant_type = build_variant_type_copy (type); + TYPE_STUB_DECL (variant_type) = TYPE_STUB_DECL (type); + TYPE_NAME (variant_type) = decl; + TREE_TYPE (decl) = variant_type; + TYPE_CONTEXT (type) = DECL_CONTEXT (decl); - TYPE_NAME (type) = decl; + TYPE_CONTEXT (variant_type) = TYPE_CONTEXT (type); + + /* Install the derived typedef type in the symtab entry for the + defining-indicant, so the lowerers for identity declarations, variable + declarations, etc, having the indicant as declarer, can use this type + rather than the original type. */ + CTYPE (TAX (defining_indicant)) = variant_type; return void_node; } @@ -134,10 +192,7 @@ a68_lower_mode_declaration (NODE_T *p, LOW_CTX_T ctx) HEAP generator, however, then the VAR_DECL declares a value of type pointer to CTYPE (AMODE0. In this later case no optimization is possible and it has exactly the same effect than an identity declaration `REF AMODE - defining_identifier = HEAP AMODE'. - - Note that the defining identifier is annotated with its mode, so there is no - need to go hunting for the declarer in the subtree. */ + defining_identifier = HEAP AMODE'. */ tree a68_lower_variable_declaration (NODE_T *p, LOW_CTX_T ctx) @@ -145,6 +200,8 @@ a68_lower_variable_declaration (NODE_T *p, LOW_CTX_T ctx) NODE_T *defining_identifier, *unit; NODE_T *declarer = NO_NODE; + // XXX this is better than using ctx NODE_T *declarer = fish_declarer_from_tree (p); + tree sub_expr = NULL_TREE; if (IS (SUB (p), VARIABLE_DECLARATION)) @@ -178,6 +235,9 @@ a68_lower_variable_declaration (NODE_T *p, LOW_CTX_T ctx) gcc_unreachable (); } + gcc_assert (declarer != NO_NODE); + gcc_assert (defining_identifier != NO_NODE); + /* Communicate declarer upward. */ if (ctx.declarer != NULL) *ctx.declarer = declarer; @@ -212,6 +272,12 @@ a68_lower_variable_declaration (NODE_T *p, LOW_CTX_T ctx) else a68_add_decl (var_decl); + // XXX sucks to replicate this logic here. + bool use_pointer = (HEAP (TAX (defining_identifier)) != STATIC_SYMBOL + && ((HEAP (TAX (defining_identifier)) == HEAP_SYMBOL) + || HAS_ROWS (SUB (MOID (defining_identifier))))); + grok_typedef_in_decl (var_decl, declarer, use_pointer); + /* Add a decl_expr in the current range. */ a68_add_decl_expr (fold_build1_loc (a68_get_node_location (p), DECL_EXPR, @@ -329,9 +395,7 @@ a68_lower_identity_declaration (NODE_T *p, LOW_CTX_T ctx) tree unit_tree = NULL_TREE; tree sub_expr = NULL_TREE; - /* Note that the formal declarer in the construct is not used. This is - because it is already reflected in the mode of the identity - declaration. */ + NODE_T *declarer = fish_declarer_from_tree (p); NODE_T *defining_identifier; if (IS (SUB (p), IDENTITY_DECLARATION)) @@ -350,6 +414,9 @@ a68_lower_identity_declaration (NODE_T *p, LOW_CTX_T ctx) else gcc_unreachable (); + gcc_assert (declarer != NO_NODE); + gcc_assert (defining_identifier != NO_NODE); + NODE_T *unit = NEXT (NEXT (defining_identifier)); tree expr = NULL_TREE; @@ -384,6 +451,8 @@ a68_lower_identity_declaration (NODE_T *p, LOW_CTX_T ctx) TREE_TYPE (id_decl), id_decl)); + grok_typedef_in_decl (id_decl, declarer); + unit_tree = a68_lower_tree (unit, ctx); unit_tree = a68_consolidate_ref (MOID (unit), unit_tree); expr = a68_low_ascription (MOID (defining_identifier), diff --git a/gcc/algol68/a68-low-ranges.cc b/gcc/algol68/a68-low-ranges.cc index f6058fbd357d..5ccc4935998f 100644 --- a/gcc/algol68/a68-low-ranges.cc +++ b/gcc/algol68/a68-low-ranges.cc @@ -617,19 +617,24 @@ a68_pop_serial_clause_range (void) same than the type corresponding to the clause mode. */ { tree_stmt_iterator si = tsi_last (range->stmt_list); - if (TREE_TYPE (tsi_stmt (si)) != clause_type + tree last_stmt_type = TREE_TYPE (tsi_stmt (si)); + + /* We need original type to compare below. */ + if (typedef_variant_p (last_stmt_type)) + last_stmt_type = DECL_ORIGINAL_TYPE (TYPE_NAME (last_stmt_type)); + + if (last_stmt_type != clause_type /* But NIL can appear in a context expecting VOID with no widening. */ && !(clause_type == a68_void_type - && POINTER_TYPE_P (TREE_TYPE (tsi_stmt (si))) + && POINTER_TYPE_P (last_stmt_type) && TREE_CODE (tsi_stmt (si)) == INTEGER_CST && tree_to_shwi (tsi_stmt (si)) == 0) /* And any row type is valid when M_ROWS is expected. */ - && !(A68_ROWS_TYPE_P (clause_type) - && A68_ROWS_TYPE_P (TREE_TYPE (tsi_stmt (si)))) + && !(A68_ROWS_TYPE_P (clause_type) && A68_ROWS_TYPE_P (last_stmt_type)) /* Do not rely on comparing pointer types, as the equality fails in that case. We need a better way of comparing types, either using TYPE_CANONICAL or caching. */ - && !(POINTER_TYPE_P (TREE_TYPE (tsi_stmt (si))) && POINTER_TYPE_P (clause_type))) + && !(POINTER_TYPE_P (last_stmt_type) && POINTER_TYPE_P (clause_type))) { printf ("last statement:\n"); debug_tree (tsi_stmt (si)); diff --git a/gcc/algol68/a68-low.cc b/gcc/algol68/a68-low.cc index bc9da115d15b..1c4ab2b2344e 100644 --- a/gcc/algol68/a68-low.cc +++ b/gcc/algol68/a68-low.cc @@ -628,7 +628,7 @@ a68_make_variable_declaration_decl (NODE_T *identifier, If ADDRP is true then it is the address of the external symbol we are interested in. In that case the mode of P shall be a ref. - + Note that this function is not used for formal holes with proc modes, called from a68_wrap_formal_var_hole. See a68_wrap_formal_proc_hole. */ @@ -993,6 +993,11 @@ a68_low_assignation (NODE_T *p, tree assignation = NULL_TREE; tree orig_rhs = rhs; + /* The lhs might be a selection that has been "ref_consolidated". */ + if (TREE_CODE (lhs) == ADDR_EXPR + && TREE_CODE (TREE_OPERAND (lhs, 0)) == COMPONENT_REF) + lhs = TREE_OPERAND (lhs, 0); + if (IS_FLEXETY_ROW (mode_rhs)) { /* Make a deep copy of the rhs. Note that we have to use the heap @@ -1011,7 +1016,8 @@ a68_low_assignation (NODE_T *p, is performed. XXX but bound checking in contained values may be necessary, ghost elements. */ if (POINTER_TYPE_P (TREE_TYPE (lhs)) - && TREE_TYPE (TREE_TYPE (lhs)) == TREE_TYPE (rhs)) + && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (lhs))) + == TYPE_MAIN_VARIANT (TREE_TYPE (rhs)))) { /* Make sure to not evaluate the expression yielding the pointer more than once. */ @@ -1091,7 +1097,8 @@ a68_low_assignation (NODE_T *p, rhs = a68_low_dup (rhs, true /* use_heap */); if (POINTER_TYPE_P (TREE_TYPE (lhs)) - && TREE_TYPE (TREE_TYPE (lhs)) == TREE_TYPE (rhs)) + && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (lhs))) + == TYPE_MAIN_VARIANT (TREE_TYPE (rhs)))) { /* If the left hand side is a pointer, deref it, but return the pointer. Make sure to not evaluate the expression yielding the diff --git a/gcc/algol68/a68-parser.cc b/gcc/algol68/a68-parser.cc index ae2a4cfcf182..4c9b17b516e4 100644 --- a/gcc/algol68/a68-parser.cc +++ b/gcc/algol68/a68-parser.cc @@ -882,6 +882,7 @@ a68_new_tag (void) TAX_TREE_DECL (z) = NULL_TREE; MOIF (z) = NO_MOIF; EXTERN_SYMBOL (z) = NO_TEXT; + CTYPE (z) = NULL_TREE; NUMBER (z) = ++A68_PARSER (tag_number); return z; } diff --git a/gcc/algol68/a68-types.h b/gcc/algol68/a68-types.h index ebe74ca8a801..0a3611f8b3e4 100644 --- a/gcc/algol68/a68-types.h +++ b/gcc/algol68/a68-types.h @@ -630,7 +630,14 @@ struct GTY(()) TABLE_T ascribed to the identifier. ACCESS is a static property that describes how to compute the value yielded - by the identifier given the GENERIC tree it lowers to. */ + by the identifier given the GENERIC tree it lowers to. + + CTYPE is either NULL_TREE or a GENERIC type. This is currently used for + declarers that are applied indicants, and is the type that is created in + a68_lower_mode_declaration, a variant derived from the actual ctype of the + MOID of the applied indicant. The lowerers for identity declarations, + variable declarations etc must use this type if it exists in the declaration + declarer. */ struct GTY((chain_next ("%h.next"))) TAG_T { @@ -642,7 +649,7 @@ struct GTY((chain_next ("%h.next"))) TAG_T bool ascribed_routine_text, is_recursive, publicized; int priority, heap, scope, youngest_environ, number; STATUS_MASK_T status; - tree tree_decl; + tree tree_decl, ctype; MOIF_T *moif; LOWERER_T lowerer; ORIGIN_T *origin; From ee5bf81d7816b0b6c54788f195295ba448cda49e Mon Sep 17 00:00:00 2001 From: Wilco Dijkstra Date: Mon, 3 Mar 2025 13:56:20 +0000 Subject: [PATCH 422/584] AArch64: Turn off outline atomics with -mcmodel=large [PR112465] Outline atomics is not designed to be used with -mcmodel=large, so disable it automatically if the large code model is used. Warn if the option was enabled on the command-line. Update documentation. gcc: PR target/112465 * config/aarch64/aarch64.cc (aarch64_override_options_after_change_1): Turn off outline atomics with -mcmodel=large. * doc/invoke.texi (-mcmodel=large): Update description. --- gcc/config/aarch64/aarch64.cc | 9 +++++++++ gcc/doc/invoke.texi | 8 ++++---- 2 files changed, 13 insertions(+), 4 deletions(-) diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc index 705c5378bac6..107271b04045 100644 --- a/gcc/config/aarch64/aarch64.cc +++ b/gcc/config/aarch64/aarch64.cc @@ -20081,6 +20081,15 @@ aarch64_override_options_after_change_1 (struct gcc_options *opts) intermediary step for the former. */ if (flag_mlow_precision_sqrt) flag_mrecip_low_precision_sqrt = true; + + /* Turn off outline atomics with -mcmodel=large. */ + if (aarch64_cmodel == AARCH64_CMODEL_LARGE) + { + if (!TARGET_LSE && opts->x_aarch64_flag_outline_atomics == 1) + warning (OPT_moutline_atomics, + "%<-mcmodel=large%> implies %<-mno-outline-atomics%>"); + opts->x_aarch64_flag_outline_atomics = 0; + } } /* 'Unpack' up the internal tuning structs and update the options diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index feec1561850d..c5d17c059fd7 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -21501,10 +21501,10 @@ dynamically linked. This is the default code model. @opindex mcmodel=large @item -mcmodel=large -Generate code for the large code model. This makes no assumptions about -addresses and sizes of sections. Programs can be statically linked only. The -@option{-mcmodel=large} option is incompatible with @option{-mabi=ilp32}, -@option{-fpic} and @option{-fPIC}. +Generate code for the large code model. This allows large .bss and .data +sections, however .text and .rodata must still be < 2GiB in total. +The @option{-moutline-atomics} is turned off by default. Static linking +with small/tiny model object files is not supported. @item -mtp=@var{name} @opindex mtp From d382f953805cb06ae0fa396d451d3888322b23ae Mon Sep 17 00:00:00 2001 From: Roger Sayle Date: Fri, 25 Sep 2026 15:34:48 +0100 Subject: [PATCH 423/584] middle-end: [SU]MUL_HIGHPART RTL simplifications This patch adds some RTL simplifications for SMUL_HIGHPART and UMUL_HIGHPART. Currently, simplify_binary_operation_1 knows that highpart multiplication by zero is zero. This patch optimizes unsigned highpart multiplication (UMUL_HIGHPART) by 1 to zero, and signed highpart multiplication (SMUL_HIGHPART) by one to be the repeated signbit, x < 0 ? -1 : 0, i.e. x >> PRECISION-1. Additionally, UMUL_HIGHPART by a power of two is transformed into a logical right shift, and SMUL_HIGHPART by a positive power of two is transformed into an arithmetic right shift. 2026-09-25 Roger Sayle gcc/ChangeLog * simplify-rtx.cc (simplify_binary_operation_1) : Add transformations for multiplications by one and powers to two. : Likewise. gcc/testsuite/ChangeLog * gcc.target/nvptx/mul-hi-2.c: New test case. --- gcc/simplify-rtx.cc | 44 ++++++++++++++++++++++- gcc/testsuite/gcc.target/nvptx/mul-hi-2.c | 37 +++++++++++++++++++ 2 files changed, 80 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.target/nvptx/mul-hi-2.c diff --git a/gcc/simplify-rtx.cc b/gcc/simplify-rtx.cc index 38c8abfe3e78..285826a3feda 100644 --- a/gcc/simplify-rtx.cc +++ b/gcc/simplify-rtx.cc @@ -5082,11 +5082,53 @@ simplify_context::simplify_binary_operation_1 (rtx_code code, return 0; case SMUL_HIGHPART: + /* Simplify x h* 0 to 0, if possible. */ + if (trueop1 == CONST0_RTX (mode) + && !side_effects_p (op0)) + return op1; + /* Simplify x h* 1 to sign(x). */ + if (trueop1 == const1_rtx + && is_a (mode, &int_mode)) + { + HOST_WIDE_INT bits = GET_MODE_PRECISION (int_mode) - 1; + return simplify_gen_binary (ASHIFTRT, mode, op0, + gen_int_shift_amount (mode, bits)); + } + /* Simplify SMUL_HIGHPART by power of two as ASHIFRT. */ + if (CONST_INT_P (trueop1) + && INTVAL (trueop1) > 1 + && is_a (mode, &int_mode)) + { + HOST_WIDE_INT prec = GET_MODE_PRECISION (int_mode); + val = wi::exact_log2 (INTVAL (trueop1)); + if (val > 0 && val < prec) + return simplify_gen_binary (ASHIFTRT, mode, op0, + gen_int_shift_amount (mode, + prec - val)); + } + return 0; + case UMUL_HIGHPART: - /* Simplify x * 0 to 0, if possible. */ + /* Simplify x h* 0 to 0, if possible. */ if (trueop1 == CONST0_RTX (mode) && !side_effects_p (op0)) return op1; + /* Simplify x h* 1 to 0. */ + if (trueop1 == CONST1_RTX (mode) + && !side_effects_p (op1)) + return CONST0_RTX (mode); + /* Simplify UMUL_HIGHPART by power of two as LSHIFRT. */ + if (CONST_INT_P (trueop1) + && UINTVAL (trueop1) > 1 + && is_a (mode, &int_mode)) + { + HOST_WIDE_INT prec = GET_MODE_PRECISION (int_mode); + val = wi::exact_log2 (UINTVAL (trueop1)); + if (val > 0 && val < prec) + return simplify_gen_binary (LSHIFTRT, mode, op0, + gen_int_shift_amount (mode, + prec - val)); + } return 0; case SS_DIV: diff --git a/gcc/testsuite/gcc.target/nvptx/mul-hi-2.c b/gcc/testsuite/gcc.target/nvptx/mul-hi-2.c new file mode 100644 index 000000000000..2f7b578ef221 --- /dev/null +++ b/gcc/testsuite/gcc.target/nvptx/mul-hi-2.c @@ -0,0 +1,37 @@ +/* { dg-do assemble } */ +/* { dg-options "-O2 -save-temps" } */ + +int smul_hi(int x, int y) +{ + return ((long)x*(long)y)>>32; +} + +int s2(int x) +{ + return smul_hi(x,2); +} + +int s4(int x) +{ + return smul_hi(x,4); +} + +unsigned int umul_hi(unsigned int x, unsigned int y) +{ + return ((unsigned long)x * (unsigned long)y) >> 32; +} + +unsigned int u2(unsigned int x) +{ + return umul_hi(x,2); +} + +unsigned int u4(unsigned int x) +{ + return umul_hi(x,4); +} + +/* { dg-final { scan-assembler-times "mul.hi.s32" 1 } } */ +/* { dg-final { scan-assembler-times "shr.s32" 2 } } */ +/* { dg-final { scan-assembler-times "mul.hi.u32" 1 } } */ +/* { dg-final { scan-assembler-times "shr.u32" 2 } } */ From 221d38405f99e5c51f26e09759e79aee482611fa Mon Sep 17 00:00:00 2001 From: Tobias Burnus Date: Fri, 25 Sep 2026 17:10:55 +0200 Subject: [PATCH 424/584] lto_input_mode_table: on offload targets, check whether mode is actually available [PR127589] For an offload-target compiler, the modes in the code match the modes on the host compiler - and not all modes might be available on the device side. There was already a check whether a mode was not existing at all, e.g. _Float128 are (currently?) unsupported on nvptx and amdgcn offload devices. However, for _Float16 ("HF") is more interesting: Both mentioned offload devices have support for it, but it is not enabled at runtime (amdgcn) or only sometimes (nvptx: only with -mexperimental for sm_53+ devices). Thus, an additional runtime check has been added for ACCEL_COMPILER, only to call the hook targetm.scalar_mode_supported_p to check whether the mode is actually available. And if not, an error message is printed. PR lto/127589 gcc/ChangeLog: * lto-streamer-in.cc (lto_input_mode_table): With ACCEL_COMPILER, check whether found float and int modes are actually enabled/available at runtime. libgomp/ChangeLog: * testsuite/libgomp.c/cmplxint-target-1.c: New test. * testsuite/libgomp.c/cmplxint128-target-1.c: New test. * testsuite/libgomp.c/dfp-target-1.c: New test. * testsuite/libgomp.c/float16-target-1.c: New test. * testsuite/libgomp.c/float16-target-2.c: New test. --- gcc/lto-streamer-in.cc | 16 ++++++++++-- .../testsuite/libgomp.c/cmplxint-target-1.c | 21 ++++++++++++++++ .../libgomp.c/cmplxint128-target-1.c | 21 ++++++++++++++++ libgomp/testsuite/libgomp.c/dfp-target-1.c | 18 +++++++++++++ .../testsuite/libgomp.c/float16-target-1.c | 25 +++++++++++++++++++ .../testsuite/libgomp.c/float16-target-2.c | 25 +++++++++++++++++++ 6 files changed, 124 insertions(+), 2 deletions(-) create mode 100644 libgomp/testsuite/libgomp.c/cmplxint-target-1.c create mode 100644 libgomp/testsuite/libgomp.c/cmplxint128-target-1.c create mode 100644 libgomp/testsuite/libgomp.c/dfp-target-1.c create mode 100644 libgomp/testsuite/libgomp.c/float16-target-1.c create mode 100644 libgomp/testsuite/libgomp.c/float16-target-2.c diff --git a/gcc/lto-streamer-in.cc b/gcc/lto-streamer-in.cc index 668a5d3065b2..663952de7049 100644 --- a/gcc/lto-streamer-in.cc +++ b/gcc/lto-streamer-in.cc @@ -2140,7 +2140,8 @@ lto_input_mode_table (struct lto_file_decl_data *file_data) break; } /* First search just the GET_CLASS_NARROWEST_MODE to wider modes, - if not found, fallback to all modes. */ + if not found, fallback to all modes. When found, pass is 3 (2 + 1), + when not found, pass is 2 ('< 2' check + 1). */ int pass; for (pass = 0; pass < 2; pass++) for (machine_mode mr = pass ? VOIDmode @@ -2163,8 +2164,19 @@ lto_input_mode_table (struct lto_file_decl_data *file_data) continue; else { + /* Found. */ table[m] = mr; - pass = 2; + pass = 2; /* Will be 3 after the outer loop. */ +#ifdef ACCEL_COMPILER + /* A mode used by the host code - and generally supported by the + offloading-target compiler might not actually be available, + depending e.g. on -march or other other commandline options. + Hence, check again and, if failing, diagnose it below. */ + if (scalar_mode::includes_p (mr) + && !targetm.scalar_mode_supported_p ( + scalar_mode::from_int (mr))) + pass = 1; /* Such that pass == 2 after the outer loop. */ +#endif break; } unsigned int mname_len; diff --git a/libgomp/testsuite/libgomp.c/cmplxint-target-1.c b/libgomp/testsuite/libgomp.c/cmplxint-target-1.c new file mode 100644 index 000000000000..dfa12a69ad2b --- /dev/null +++ b/libgomp/testsuite/libgomp.c/cmplxint-target-1.c @@ -0,0 +1,21 @@ +/* { dg-do link } */ + +/* PR lto/127589 */ + +/* Both NVPTX and AMDGCN define HF - and support it in principle (nvptx: sm_XX > 53) + However, both have currently disabled it at runtime (target hook) + [For Nvpts, -mexperimental can actually be used to enable it.] + + Hence: Check for the following - otherwise, it would ICE. */ + +int f(_Complex int x) { + return __real__ x > 0; +} + +int main() { + int r; + _Complex int y = (_Complex int)0; + #pragma omp target map(from: r), map(to: y) + r = f(y); + return r; +} diff --git a/libgomp/testsuite/libgomp.c/cmplxint128-target-1.c b/libgomp/testsuite/libgomp.c/cmplxint128-target-1.c new file mode 100644 index 000000000000..38d8dc701247 --- /dev/null +++ b/libgomp/testsuite/libgomp.c/cmplxint128-target-1.c @@ -0,0 +1,21 @@ +/* { dg-do link { target int128 } } */ + +/* PR lto/127589 */ + +/* Both NVPTX and AMDGCN define HF - and support it in principle (nvptx: sm_XX > 53) + However, both have currently disabled it at runtime (target hook) + [For Nvpts, -mexperimental can actually be used to enable it.] + + Hence: Check for the following - otherwise, it would ICE. */ + +int f(_Complex __int128 x) { + return __real__ x > 0; +} + +int main() { + int r; + _Complex __int128 y = (_Complex __int128)0; + #pragma omp target map(from: r), map(to: y) + r = f(y); + return r; +} diff --git a/libgomp/testsuite/libgomp.c/dfp-target-1.c b/libgomp/testsuite/libgomp.c/dfp-target-1.c new file mode 100644 index 000000000000..eb1975bf877c --- /dev/null +++ b/libgomp/testsuite/libgomp.c/dfp-target-1.c @@ -0,0 +1,18 @@ +/* { dg-do link { target dfp } } */ + +/* PR lto/127589 */ + +/* { dg-error "32-bit-precision decimal floating-point numbers unsupported .mode 'SD'." "" { target { offload_target_nvptx || offload_target_amdgcn } } 0 } */ +/* { dg-excess-errors "Follow-up errors from mkoffload and lto-wrapper" { target { offload_target_nvptx || offload_target_amdgcn } } } */ + +int f(_Decimal32 x) { + return x > (_Decimal32)0.0; +} + +int main() { + int r; + _Decimal32 y = (_Decimal32)0.0; + #pragma omp target map(from: r), map(to: y) + r = f(y); + return r; +} diff --git a/libgomp/testsuite/libgomp.c/float16-target-1.c b/libgomp/testsuite/libgomp.c/float16-target-1.c new file mode 100644 index 000000000000..da39eaac1d9e --- /dev/null +++ b/libgomp/testsuite/libgomp.c/float16-target-1.c @@ -0,0 +1,25 @@ +/* { dg-do link { target float16 } } */ +/* { dg-add-options float16 } */ + +/* PR lto/127589 */ + +/* Both NVPTX and AMDGCN define HF - and support it in principle (nvptx: sm_XX > 53) + However, both have currently disabled it at runtime (target hook) + [For Nvpts, -mexperimental can actually be used to enable it.] + + Hence: Check for the following - otherwise, it would ICE. */ + +/* { dg-error "bit-precision floating-point numbers unsupported .mode '.F'." "" { target { offload_target_nvptx || offload_target_amdgcn } } 0 } */ +/* { dg-excess-errors "Follow-up errors from mkoffload and lto-wrapper" { target { offload_target_nvptx || offload_target_amdgcn } } } */ + +int f(_Float16 x) { + return x > 0.0; +} + +int main() { + int r; + _Float16 y = (_Float16)0.0; + #pragma omp target map(from: r), map(to: y) + r = f(y); + return r; +} diff --git a/libgomp/testsuite/libgomp.c/float16-target-2.c b/libgomp/testsuite/libgomp.c/float16-target-2.c new file mode 100644 index 000000000000..ddcdf0cddca1 --- /dev/null +++ b/libgomp/testsuite/libgomp.c/float16-target-2.c @@ -0,0 +1,25 @@ +/* { dg-do link { target float16 } } */ +/* { dg-add-options float16 } */ + +/* PR lto/127589 */ + +/* Both NVPTX and AMDGCN define HF - and support it in principle (nvptx: sm_XX > 53) + However, both have currently disabled it at runtime (target hook) + [For Nvpts, -mexperimental can actually be used to enable it.] + + Hence: Check for the following - otherwise, it would ICE. */ + +/* { dg-error "bit-precision floating-point numbers unsupported .mode '.F'." "" { target { offload_target_nvptx || offload_target_amdgcn } } 0 } */ +/* { dg-excess-errors "Follow-up errors from mkoffload and lto-wrapper" { target { offload_target_nvptx || offload_target_amdgcn } } } */ + +int f(_Complex _Float16 x) { + return __real__ x > (_Float16)0.0; +} + +int main() { + int r; + _Complex _Float16 y = (_Complex _Float16)0.0; + #pragma omp target map(from: r), map(to: y) + r = f(y); + return r; +} From eed9f52920aa362866eab84886dc47b0a38944b0 Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Fri, 25 Sep 2026 17:52:22 +0200 Subject: [PATCH 425/584] c++: Implement C++26 P3769R1 - Clarification of placement new deallocation as a DR [PR125848] The following patch implements the P3769R1 paper as a DR, changes the algorithm to select placement deallocation function among those which were looked up. The delete cases mentioned in the paper work differently in GCC because we implement one possible resolution of still pending CWG901. 2026-09-25 Jakub Jelinek P3769R1 PR c++/125848 * call.cc (build_op_delete_call_1): Implement C++26 P3769R1 - Clarification of placement new deallocation. Instead of calling instantiate_type to select placement deallocation function iterate over OVERLOAD if any, perform argument deduction for templates, ignore candidates with different parameter type lists or unsatisfied constraints and if only one candidate remains, use it, otherwise don't destruct on throw. Add placement_args argument, pass it down to build_op_delete_call call and use in template argument deduction. (build_op_delete_call): Add placement_args argument and pass it down to build_op_delete_call_1. (build_coroutine_op_delete_call): Remove placement argument, pass down NULL_TREE and NULL to build_op_delete_call_1 as placement and placement_args. * cp-tree.h (build_op_delete_call): Add placement_args argument. (build_coroutine_op_delete_call): Remove placement argument. * init.cc (build_new_1): Pass down *placement as placement_args to build_op_delete_call for placement new. (build_vec_delete_1): Adjust build_op_delete_call callers. (build_delete): Likewise. Remove {}s around single statement body. * coroutines.cc (build_coroutine_frame_delete_expr): Don't pass placement to build_coroutine_op_delete_call. * optimize.cc (build_delete_destructor_body): Adjust build_op_delete_call caller. * g++.dg/cpp26/placement-new1.C: New test. Reviewed-by: Jason Merrill --- gcc/cp/call.cc | 84 +++- gcc/cp/coroutines.cc | 5 +- gcc/cp/cp-tree.h | 7 +- gcc/cp/init.cc | 64 ++- gcc/cp/optimize.cc | 11 +- gcc/testsuite/g++.dg/cpp26/placement-new1.C | 427 ++++++++++++++++++++ 6 files changed, 529 insertions(+), 69 deletions(-) create mode 100644 gcc/testsuite/g++.dg/cpp26/placement-new1.C diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc index ecf1c870d8be..eabc2342b062 100644 --- a/gcc/cp/call.cc +++ b/gcc/cp/call.cc @@ -8075,6 +8075,8 @@ usual_deallocation_fn_p (tree fn) usual deallocation should be chosen in preference to the single argument version in a class context. PLACEMENT is the corresponding placement new call, or NULL_TREE. + PLACEMENT_ARGS is a pointer to vector containing the original placement + arguments, or NULL. If this call to "operator delete" is being generated as part to deallocate memory allocated via a new-expression (as per [expr.new] @@ -8085,7 +8087,8 @@ usual_deallocation_fn_p (tree fn) static tree build_op_delete_call_1 (enum tree_code code, tree addr, tree size, bool global_p, bool coro_p, tree placement, - tree alloc_fn, tsubst_flags_t complain) + vec *placement_args, tree alloc_fn, + tsubst_flags_t complain) { tree fn = NULL_TREE; tree fns, fnname, type, t; @@ -8127,28 +8130,66 @@ build_op_delete_call_1 (enum tree_code code, tree addr, tree size, if (placement) { - /* "A declaration of a placement deallocation function matches the - declaration of a placement allocation function if it has the same - number of parameters and, after parameter transformations (8.3.5), - all parameter types except the first are identical." - - So we build up the function type we want and ask instantiate_type - to get it for us. */ + /* For a placement allocation function, the matching deallocation + function is selected as follows: + + - Each candidate that is a function template is replaced by the + function template specializations (if any) generated using template + argument deduction with arguments as specified below. + - Each candidate whose parameter-type-list is not identical to that + of the allocation function, ignoring their respective first + parameters, is removed from the set of candidates. + - Each candidate whose associated constraints (if any) are not + satisfied is removed from the set of candidates. + - If exactly one function remains, that function is selected. + - Otherwise, no deallocation function is selected. */ t = FUNCTION_ARG_CHAIN (alloc_fn); - t = tree_cons (NULL_TREE, ptr_type_node, t); - t = build_function_type (void_type_node, t); + fn = NULL_TREE; + tree *args = NULL; + unsigned nargs = 0; + for (tree elt : lkp_range (MAYBE_BASELINK_FUNCTIONS (fns))) + { + if (TREE_CODE (elt) == TEMPLATE_DECL) + { + tree targs = make_tree_vec (DECL_NTPARMS (elt)); + if (args == NULL) + { + nargs = vec_safe_length (placement_args); + args = XALLOCAVEC (tree, nargs); + args[0] = addr; + for (unsigned i = 1; i < nargs; ++i) + args[i] = (*placement_args)[i]; + } + elt = fn_type_unification (elt, NULL_TREE, targs, args, + nargs, NULL_TREE, + DEDUCE_CALL, LOOKUP_NORMAL, + NULL, false, false); + if (elt == error_mark_node) + /* Instantiation failed. */ + continue; + } - fn = instantiate_type (t, fns, tf_none); - if (fn == error_mark_node) - return NULL_TREE; + if (!constraints_satisfied_p (elt)) + continue; - fn = MAYBE_BASELINK_FUNCTIONS (fn); + /* See if there's a match. */ + if (!compparms (t, FUNCTION_ARG_CHAIN (elt))) + continue; + + if (fn != NULL_TREE) + { + fn = NULL_TREE; + break; + } + else + fn = elt; + } /* "If the lookup finds the two-parameter form of a usual deallocation function (3.7.4.2) and that function, considered as a placement deallocation function, would have been selected as a match for the allocation function, the program is ill-formed." */ - if (second_parm_is_size_t (fn)) + if (fn && second_parm_is_size_t (fn)) { const char *const msg1 = G_("exception cleanup for this placement new selects " @@ -8372,7 +8413,7 @@ build_op_delete_call_1 (enum tree_code code, tree addr, tree size, if (excluded_destroying && DECL_NAMESPACE_SCOPE_P (alloc_fn)) return build_op_delete_call (code, addr, size, true, placement, - alloc_fn, complain); + placement_args, alloc_fn, complain); /* [expr.new] @@ -8406,21 +8447,24 @@ build_op_delete_call_1 (enum tree_code code, tree addr, tree size, tree build_op_delete_call (enum tree_code code, tree addr, tree size, bool global_p, - tree placement, tree alloc_fn, tsubst_flags_t complain) + tree placement, vec *placement_args, + tree alloc_fn, tsubst_flags_t complain) { return build_op_delete_call_1 (code, addr, size, global_p, /*coro_p*/false, - placement, alloc_fn, complain); + placement, placement_args, alloc_fn, + complain); } /* Arguments as per build_op_delete_call_1 (). */ tree build_coroutine_op_delete_call (enum tree_code code, tree addr, tree size, - bool global_p, tree placement, tree alloc_fn, + bool global_p, tree alloc_fn, tsubst_flags_t complain) { return build_op_delete_call_1 (code, addr, size, global_p, /*coro_p*/true, - placement, alloc_fn, complain); + /*placement*/NULL_TREE, + /*placement_args*/NULL, alloc_fn, complain); } /* Issue diagnostics about a disallowed access of DECL, using DIAG_DECL diff --git a/gcc/cp/coroutines.cc b/gcc/cp/coroutines.cc index f4df662bbcb9..ce9c1b6bffab 100644 --- a/gcc/cp/coroutines.cc +++ b/gcc/cp/coroutines.cc @@ -4981,8 +4981,9 @@ build_coroutine_frame_delete_expr (tree coro_fp, tree frame_size, one with two parameters. */ tree del_coro_fr = build_coroutine_op_delete_call (DELETE_EXPR, frame_arg, frame_size, - /*global_p=*/false, /*placement=*/NULL, - /*alloc_fn=*/NULL, tf_warning_or_error); + /*global_p=*/false, + /*alloc_fn=*/NULL_TREE, + tf_warning_or_error); if (!del_coro_fr || del_coro_fr == error_mark_node) return error_mark_node; return del_coro_fr; diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 154755fce821..947bf62ff982 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -7359,11 +7359,10 @@ extern bool aligned_allocation_fn_p (tree); extern tree destroying_delete_p (tree); extern bool usual_deallocation_fn_p (tree); extern tree build_op_delete_call (enum tree_code, tree, tree, - bool, tree, tree, - tsubst_flags_t); + bool, tree, vec *, + tree, tsubst_flags_t); extern tree build_coroutine_op_delete_call (enum tree_code, tree, tree, - bool, tree, tree, - tsubst_flags_t complain); + bool, tree, tsubst_flags_t); extern bool can_convert (tree, tree, tsubst_flags_t); extern bool can_convert_standard (tree, tree, tsubst_flags_t); extern bool can_convert_arg (tree, tree, tree, int, diff --git a/gcc/cp/init.cc b/gcc/cp/init.cc index 6bdc5fbbeb0b..3fefa9fc02d9 100644 --- a/gcc/cp/init.cc +++ b/gcc/cp/init.cc @@ -3898,14 +3898,12 @@ build_new_1 (vec **placement, tree type, tree nelts, /* The Standard is unclear here, but the right thing to do is to use the same method for finding deallocation functions that we use for finding allocation functions. */ - cleanup = (build_op_delete_call - (dcode, - alloc_node, - size, - globally_qualified_p, - placement_allocation_fn_p ? alloc_call : NULL_TREE, - alloc_fn, - complain)); + cleanup + = build_op_delete_call (dcode, alloc_node, size, globally_qualified_p, + placement_allocation_fn_p + ? alloc_call : NULL_TREE, + placement_allocation_fn_p ? *placement : NULL, + alloc_fn, complain); if (cleanup && init_expr && !processing_template_decl) /* Ack! First we allocate the memory. Then we set our sentry @@ -4380,12 +4378,11 @@ build_vec_delete_1 (location_t loc, tree base, tree maxindex, tree type, virtual_size = size_binop (PLUS_EXPR, virtual_size, cookie_size); } - deallocate_expr = build_op_delete_call (VEC_DELETE_EXPR, - base_tbd, virtual_size, - use_global_delete & 1, - /*placement=*/NULL_TREE, - /*alloc_fn=*/NULL_TREE, - complain); + deallocate_expr + = build_op_delete_call (VEC_DELETE_EXPR, base_tbd, virtual_size, + use_global_delete & 1, /*placement=*/NULL_TREE, + /*placement_args=*/NULL, + /*alloc_fn=*/NULL_TREE, complain); } body = loop; @@ -5583,13 +5580,11 @@ build_delete (location_t loc, tree otype, tree addr, { head = get_internal_target_expr (build_headof (addr)); /* Delete the object. */ - do_delete = build_op_delete_call (DELETE_EXPR, - head, - cxx_sizeof_nowarn (type), - /*global_p=*/true, - /*placement=*/NULL_TREE, - /*alloc_fn=*/NULL_TREE, - complain); + do_delete + = build_op_delete_call (DELETE_EXPR, head, cxx_sizeof_nowarn (type), + /*global_p=*/true, /*placement=*/NULL_TREE, + /*placement_args=*/NULL, + /*alloc_fn=*/NULL_TREE, complain); /* Otherwise, treat this like a complete object destructor call. */ auto_delete = sfk_complete_destructor; @@ -5600,13 +5595,11 @@ build_delete (location_t loc, tree otype, tree addr, else if (!virtual_p) { /* Build the call. */ - do_delete = build_op_delete_call (DELETE_EXPR, - addr, - cxx_sizeof_nowarn (type), - /*global_p=*/false, - /*placement=*/NULL_TREE, - /*alloc_fn=*/NULL_TREE, - complain); + do_delete + = build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type), + /*global_p=*/false, /*placement=*/NULL_TREE, + /*placement_args=*/NULL, + /*alloc_fn=*/NULL_TREE, complain); /* Call the complete object destructor. */ auto_delete = sfk_complete_destructor; if (do_delete != error_mark_node) @@ -5616,15 +5609,12 @@ build_delete (location_t loc, tree otype, tree addr, } } else if (TYPE_GETS_REG_DELETE (type)) - { - /* Make sure we have access to the member op delete, even though - we'll actually be calling it from the destructor. */ - build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type), - /*global_p=*/false, - /*placement=*/NULL_TREE, - /*alloc_fn=*/NULL_TREE, - complain); - } + /* Make sure we have access to the member op delete, even though + we'll actually be calling it from the destructor. */ + build_op_delete_call (DELETE_EXPR, addr, cxx_sizeof_nowarn (type), + /*global_p=*/false, /*placement=*/NULL_TREE, + /*placement_args=*/NULL, /*alloc_fn=*/NULL_TREE, + complain); if (destroying_delete) /* The operator delete will call the destructor. */ diff --git a/gcc/cp/optimize.cc b/gcc/cp/optimize.cc index 31ee2aaccfb9..0afeefd57047 100644 --- a/gcc/cp/optimize.cc +++ b/gcc/cp/optimize.cc @@ -138,12 +138,11 @@ build_delete_destructor_body (tree delete_dtor, tree complete_dtor) tree virtual_size = cxx_sizeof (current_class_type); /* Call the delete function. */ - tree call_delete = build_op_delete_call (DELETE_EXPR, current_class_ptr, - virtual_size, - /*global_p=*/false, - /*placement=*/NULL_TREE, - /*alloc_fn=*/NULL_TREE, - tf_warning_or_error); + tree call_delete + = build_op_delete_call (DELETE_EXPR, current_class_ptr, virtual_size, + /*global_p=*/false, /*placement=*/NULL_TREE, + /*placement_args=*/NULL, /*alloc_fn=*/NULL_TREE, + tf_warning_or_error); tree op = get_callee_fndecl (call_delete); if (op && DECL_P (op) && destroying_delete_p (op)) diff --git a/gcc/testsuite/g++.dg/cpp26/placement-new1.C b/gcc/testsuite/g++.dg/cpp26/placement-new1.C new file mode 100644 index 000000000000..39c814f1938c --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp26/placement-new1.C @@ -0,0 +1,427 @@ +// P3769R1 - Clarification of placement new deallocation +// { dg-do run { target c++11 } } + +namespace std +{ + using size_t = decltype (sizeof 0); +} + +struct A {}; +int v; +A a; +template +struct B {}; +B <0> b; +template +struct C {}; +C <0> c; +template +struct D {}; +D <0> d; +struct T { T () = default; T (int) { throw 1; } }; +union U { unsigned char c[sizeof (T)]; T t; } u; +void *foo (); +struct V { + V () = default; + V (int) { throw 2; } + void *operator new (std::size_t, A &) + { + if (v != 5) + __builtin_abort (); + ++v; + return foo (); + } + template + void operator delete (void *, A &) + { + if (v != 6) + __builtin_abort (); + v += 2; + } + void *operator new (std::size_t, B <0> &) + { + if (v != 8) + __builtin_abort (); + v += 4; + return foo (); + } + template + void operator delete (void *, B &) + { + __builtin_abort (); + } + void operator delete (void *, B <0> &) + { + __builtin_abort (); + } + void *operator new (std::size_t, C <0> &) + { + if (v != 12) + __builtin_abort (); + v += 8; + return foo (); + } +#if __cpp_concepts >= 202002L + template + requires (I > 0) + void operator delete (void *, C &) + { + __builtin_abort (); + } +#endif + void operator delete (void *, C <0> &) + { + if (v != 20) + __builtin_abort (); + v += 16; + } +}; +union W { unsigned char c[sizeof (V)]; V t; } w; + +void * +foo () +{ + return &w.c[0]; +} + +void * +operator new (std::size_t, A &) // #1 +{ + if (v != 0) + __builtin_abort (); + ++v; + return &u.c[0]; +} + +template +void +operator delete (void *, A &) // #2 +{ + if (v != 1) + __builtin_abort (); + v += 2; +} + +void * +operator new (std::size_t, B <0> &) // #3 +{ + if (v != 3) + __builtin_abort (); + v += 4; + return &u.c[0]; +} + +template +void +operator delete (void *, B &) // #4 +{ + __builtin_abort (); +} + +void +operator delete (void *, B <0> &) // #5 +{ + __builtin_abort (); +} + +void * +operator new (std::size_t, C <0> &) // #6 +{ + if (v != 7) + __builtin_abort (); + v += 8; + return &u.c[0]; +} + +#if __cpp_concepts >= 202002L +template +requires (I > 0) +void +operator delete (void *, C &) // #7 +{ + __builtin_abort (); +} +#endif + +void +operator delete (void *, C <0> &) // #8 +{ + if (v != 15) + __builtin_abort (); + v += 16; +} + +void * +operator new (std::size_t, double, int, float) +{ + if (v != 36) + __builtin_abort (); + v += 32; + return &u.c[0]; +} + +void +operator delete (void *, double, int, float, int = 0, double = 0.0, float = 0.0) +{ + __builtin_abort (); +} + +void * +operator new (std::size_t, double, int, long) +{ + if (v != 68) + __builtin_abort (); + v += 64; + return &u.c[0]; +} + +void +operator delete (void *, double, int, long, int = 0, double = 0.0, float = 0.0) +{ + __builtin_abort (); +} + +void +operator delete (void *, double, int, long) +{ + if (v != 132) + __builtin_abort (); + v += 128; +} + +void * +operator new (std::size_t, unsigned, B <0> &, B <0> &) +{ + if (v != 9) + __builtin_abort (); + ++v; + return &u.c[0]; +} + +template +void operator delete (void *, unsigned, T &, U &) +{ + __builtin_abort (); +} + +template +void operator delete (void *, unsigned, T &, T &) +{ + __builtin_abort (); +} + +template +void operator delete (void *, unsigned, B &, B &) +{ + __builtin_abort (); +} + +void * +operator new (std::size_t, unsigned long, B <0> &, B <0> &) +{ + if (v != 10) + __builtin_abort (); + v += 2; + return &u.c[0]; +} + +template +void operator delete (void *, unsigned long, T &, U &) +{ + __builtin_abort (); +} + +template +void operator delete (void *, unsigned long, T &, T &) +{ + __builtin_abort (); +} + +void * +operator new (std::size_t, unsigned long long, B <0> &, B <0> &) +{ + if (v != 12) + __builtin_abort (); + v += 4; + return &u.c[0]; +} + +template +void operator delete (void *, unsigned long long, T &, U &) +{ + if (v != 16) + __builtin_abort (); + v += 8; +} + +void * +operator new (std::size_t, long long, B <0> &, B <0> &) +{ + if (v != 24) + __builtin_abort (); + v += 16; + return &u.c[0]; +} + +template +void operator delete (void *, long long, T &, U &) = delete; + +template +void operator delete (void *, long long, T &, T &) = delete; + +template +void operator delete (void *, long long, B &, B &) = delete; + +void * +operator new (std::size_t, D <0> &) +{ + if (v != 40) + __builtin_abort (); + v += 32; + return &u.c[0]; +} + +template +void operator delete (void *, D &) +{ + if (v != 72) + __builtin_abort (); + v += 64; +} + +int +main () +{ + try + { + T *p = new (a) T (1); // OK, uses #1 and #2. + throw 1L; + } + catch (int) + { + if (v != 3) + __builtin_abort (); + } + try + { + T *p = new (b) T (1); // OK, uses #3. No deallocation function is selected (two candidates remain). + throw 2L; + } + catch (int) + { + if (v != 7) + __builtin_abort (); + } + try + { + T *p = new (c) T (1); // OK, uses #7 and #9. + throw 3L; + } + catch (int) + { + if (v != 31) + __builtin_abort (); + } + v = 5; + try + { + V *p = new (a) V (1); + throw 4L; + } + catch (int) + { + if (v != 8) + __builtin_abort (); + } + try + { + V *p = new (b) V (1); + throw 5L; + } + catch (int) + { + if (v != 12) + __builtin_abort (); + } + try + { + V *p = new (c) V (1); + throw 6L; + } + catch (int) + { + if (v != 36) + __builtin_abort (); + } + try + { + T *p = new (0.0, 0, 0.0f) T (1); + throw 7L; + } + catch (int) + { + if (v != 68) + __builtin_abort (); + } + try + { + T *p = new (0.0, 0, 0L) T (1); + throw 8L; + } + catch (int) + { + if (v != 260) + __builtin_abort (); + } + v = 9; + try + { + T *p = new (0U, b, b) T (1); + throw 9L; + } + catch (int) + { + if (v != 10) + __builtin_abort (); + } + try + { + T *p = new (0UL, b, b) T (1); + throw 10L; + } + catch (int) + { + if (v != 12) + __builtin_abort (); + } + try + { + T *p = new (0ULL, b, b) T (1); + throw 12L; + } + catch (int) + { + if (v != 24) + __builtin_abort (); + } + try + { + T *p = new (0LL, b, b) T (1); + throw 13L; + } + catch (int) + { + if (v != 40) + __builtin_abort (); + } + try + { + T *p = new (d) T (1); + throw 14L; + } + catch (int) + { + if (v != 136) + __builtin_abort (); + } +} From 07b05ad02478dc3291a234ebd2030f49e0259673 Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Fri, 25 Sep 2026 17:55:51 +0200 Subject: [PATCH 426/584] c++: Represent aggregate subobjects after std::destroy_at as void_node [PR127385] The following testcase misbehaves, because for std::destroy_at of aggregates (i.e. CLOBBER with CLOBBER_OBJECT_END) we record during constant evaluation just a normal CONSTRUCTOR, so for std::is_within_lifetime it appears as if it is normally within lifetime, even when it is not. For scalar subobjects and complete objects we use void_node, this patch uses void_node also for the aggregates (but doesn't do that on CLOBBER_OBJECT_START and CLOBBER_STORAGE_START, that breaks too much stuff and the lifetime is just beginning there, not ending). I've just had to tweak cxx_eval_store_expression so that it is able to handle stores into previously outside of lifetime subobjects by making those within lifetime. 2026-09-25 Jakub Jelinek PR c++/127385 * constexpr.cc (cxx_eval_store_expression): Handle the case of *valp == void_node like if *valp is NULL. (cxx_eval_store_expression): For CLOBBER_OBJECT_END or above store *valp = void_node even for aggregate types. * g++.dg/cpp26/within-lifetime14.C: New test. Reviewed-by: Jason Merrill --- gcc/cp/constexpr.cc | 4 +- .../g++.dg/cpp26/within-lifetime14.C | 195 ++++++++++++++++++ 2 files changed, 197 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/g++.dg/cpp26/within-lifetime14.C diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc index e90ca1018a7d..e1b64880a883 100644 --- a/gcc/cp/constexpr.cc +++ b/gcc/cp/constexpr.cc @@ -8649,7 +8649,7 @@ cxx_eval_store_expression (const constexpr_ctx *ctx, tree t, bool empty_base = false; while (!refs->is_empty ()) { - if (*valp == NULL_TREE) + if (*valp == NULL_TREE || *valp == void_node) { *valp = build_constructor (type, NULL); CONSTRUCTOR_NO_CLEARING (*valp) = no_zero_init; @@ -8998,7 +8998,7 @@ cxx_eval_store_expression (const constexpr_ctx *ctx, tree t, } else if (TREE_CLOBBER_P (init)) { - if (AGGREGATE_TYPE_P (type)) + if (AGGREGATE_TYPE_P (type) && CLOBBER_KIND (init) < CLOBBER_OBJECT_END) { if (*valp && TREE_CODE (*valp) == CONSTRUCTOR) CONSTRUCTOR_ELTS (*valp) = nullptr; diff --git a/gcc/testsuite/g++.dg/cpp26/within-lifetime14.C b/gcc/testsuite/g++.dg/cpp26/within-lifetime14.C new file mode 100644 index 000000000000..d4cd7fd94429 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp26/within-lifetime14.C @@ -0,0 +1,195 @@ +// P3450R1 - Extend std::is_within_lifetime +// { dg-do compile { target c++20 } } + +#include "../cpp2a/construct_at.h" + +namespace std { + template + consteval bool + is_within_lifetime (const T *p) noexcept + { + return __builtin_is_within_lifetime (p); + } + + template + constexpr void + start_lifetime (T &r) noexcept + { + __builtin_start_lifetime (__builtin_addressof (r)); + } +} + +struct A { int a, b; }; +struct B { A c, d[2]; }; +union C { B e; int f; }; +struct D { C g; B h; }; +struct E { D i[3]; }; + +consteval int +foo () +{ + E j; + if (!std::is_within_lifetime (&j.i[1])) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].g)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.e)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.f)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.e.d[1].b)) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].h)) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].h.d[0].a)) + return __LINE__; + std::destroy_at (&j.i[1]); + if (std::is_within_lifetime (&j.i[1])) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.e)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.f)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.e.d[1].b)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].h)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].h.d[0].a)) + return __LINE__; + std::start_lifetime (j.i[1]); + if (!std::is_within_lifetime (&j.i[1])) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.e)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.f)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.e.d[1].b)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].h)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].h.d[0].a)) + return __LINE__; + std::start_lifetime (j.i[1].g); + if (!std::is_within_lifetime (&j.i[1])) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].g)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.e)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.f)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.e.d[1].b)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].h)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].h.d[0].a)) + return __LINE__; + std::start_lifetime (j.i[1].h); + if (!std::is_within_lifetime (&j.i[1])) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].g)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.e)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.f)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.e.d[1].b)) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].h)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].h.d[0].a)) + return __LINE__; + std::start_lifetime (j.i[1].h.d); + std::start_lifetime (j.i[1].h.d[0]); + if (std::is_within_lifetime (&j.i[1].h.d[0].a)) + return __LINE__; + j.i[1].h.d[0].a = 42; + if (!std::is_within_lifetime (&j.i[1].h)) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].h.d[0].a)) + return __LINE__; + std::start_lifetime (j.i[1].g.e); + std::start_lifetime (j.i[1].g.e.d); + std::start_lifetime (j.i[1].g.e.d[1]); + if (!std::is_within_lifetime (&j.i[1].g.e)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.f)) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].g.e.d[1])) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.e.d[1].b)) + return __LINE__; + j.i[1].g.e.d[1].b = 42; + if (!std::is_within_lifetime (&j.i[1].g.e.d[1])) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].g.e.d[1].b)) + return __LINE__; + std::start_lifetime (j.i[1].g); + if (!std::is_within_lifetime (&j.i[1])) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].g)) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].g.e)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.f)) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].g.e.d[1].b)) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].h)) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].h.d[0].a)) + return __LINE__; + std::start_lifetime (j.i[1].g); + j.i[1].g.f = 42; + if (!std::is_within_lifetime (&j.i[1])) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].g)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.e)) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].g.f)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.e.d[1].b)) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].h)) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].h.d[0].a)) + return __LINE__; + std::destroy_at (&j.i[1]); + if (std::is_within_lifetime (&j.i[1])) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.e)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.f)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.e.d[1].b)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].h)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].h.d[0].a)) + return __LINE__; + std::construct_at (&j.i[1]); + if (!std::is_within_lifetime (&j.i[1])) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].g)) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].g.e)) + return __LINE__; + if (std::is_within_lifetime (&j.i[1].g.f)) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].g.e.d[1].b)) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].h)) + return __LINE__; + if (!std::is_within_lifetime (&j.i[1].h.d[0].a)) + return __LINE__; + return 0; +} + +static_assert (foo () == 0); From 909075f102c0ddd8568c6871c03d1dce027ced32 Mon Sep 17 00:00:00 2001 From: Jerry DeLisle Date: Thu, 24 Sep 2026 12:39:51 -0700 Subject: [PATCH 427/584] libgfortran: [PR127347] caf_shmem: report a terminated image in a collective A collective subroutine whose barrier was abandoned because an image of the team terminated reported this with a runtime error, and so terminated the remaining images even when a STAT argument was present. F2023 16.6 assigns STAT_STOPPED_IMAGE, or STAT_FAILED_IMAGE, to the STAT argument in that case and leaves the A argument undefined; an error condition without a STAT argument still is error termination. Pass the abandoned barrier up to the collective and classify it the same way an image control statement does. Assisted-by: Claude Opus 5 PR libfortran/127347 libgfortran/ChangeLog: * caf/shmem.c (_gfortran_caf_co_broadcast, _gfortran_caf_co_sum) (_gfortran_caf_co_min, _gfortran_caf_co_max) (_gfortran_caf_co_reduce): Report a terminated image of the team through STAT. * caf/shmem/collective_subroutine.c (collsub_sync): Return whether the images were synchronized. (collsub_reduce_array, collsub_broadcast_array): Likewise. Give up when an image of the team terminated. * caf/shmem/collective_subroutine.h (collsub_reduce_array) (collsub_broadcast_array): Adjust. gcc/testsuite/ChangeLog: * gfortran.dg/coarray/collective_stopped_2.f90: New test. --- .../coarray/collective_stopped_2.f90 | 32 ++++++++++++++++ libgfortran/caf/shmem.c | 16 +++++--- libgfortran/caf/shmem/collective_subroutine.c | 37 ++++++++++--------- libgfortran/caf/shmem/collective_subroutine.h | 7 +++- 4 files changed, 68 insertions(+), 24 deletions(-) create mode 100644 gcc/testsuite/gfortran.dg/coarray/collective_stopped_2.f90 diff --git a/gcc/testsuite/gfortran.dg/coarray/collective_stopped_2.f90 b/gcc/testsuite/gfortran.dg/coarray/collective_stopped_2.f90 new file mode 100644 index 000000000000..2a4e4f3207ef --- /dev/null +++ b/gcc/testsuite/gfortran.dg/coarray/collective_stopped_2.f90 @@ -0,0 +1,32 @@ +! { dg-do run } +! +! An image terminating while the others are inside a collective subroutine +! has to be reported through stat=, not by terminating them. + +program collective_stopped_2 + use iso_fortran_env, only : stat_stopped_image + implicit none + integer :: s[*] + integer :: st, img + + if (num_images () == 1) stop + img = max (num_images () / 2, 2) + s = this_image () + if (this_image () == img) then + call spin () + stop + end if + + st = 0 + call co_sum (s, stat=st) + if (st /= stat_stopped_image) stop 1 +contains + subroutine spin () + integer :: c + integer(kind=8) :: v + v = 2 + do c = 1, 20000000 + v = mod (v * 2, 1999619_8) + end do + end subroutine +end program collective_stopped_2 diff --git a/libgfortran/caf/shmem.c b/libgfortran/caf/shmem.c index 00d851ab5395..aacb1fd6f86f 100644 --- a/libgfortran/caf/shmem.c +++ b/libgfortran/caf/shmem.c @@ -859,7 +859,9 @@ _gfortran_caf_co_broadcast (gfc_descriptor_t *desc, int source_image, int *stat, NULL, stat)) return; - collsub_broadcast_array (desc, mapped_index); + /* A terminated image leaves the collective incomplete (F2023 16.6). */ + if (!collsub_broadcast_array (desc, mapped_index)) + HEALTH_CHECK (stat, errmsg, errmsg_len); } #define GEN_OP(name, op, type) \ @@ -961,7 +963,8 @@ _gfortran_caf_co_sum (gfc_descriptor_t *desc, int result_image, int *stat, SWITCH_TYPE_KIND (sum) - collsub_reduce_array (desc, mapped_index, opr, 0, 0); + if (!collsub_reduce_array (desc, mapped_index, opr, 0, 0)) + HEALTH_CHECK (stat, errmsg, errmsg_len); } void @@ -986,7 +989,8 @@ _gfortran_caf_co_min (gfc_descriptor_t *desc, int result_image, int *stat, SWITCH_TYPE_KIND (min) - collsub_reduce_array (desc, mapped_index, opr, 0, 0); + if (!collsub_reduce_array (desc, mapped_index, opr, 0, 0)) + HEALTH_CHECK (stat, errmsg, errmsg_len); } void @@ -1011,7 +1015,8 @@ _gfortran_caf_co_max (gfc_descriptor_t *desc, int result_image, int *stat, SWITCH_TYPE_KIND (max) - collsub_reduce_array (desc, mapped_index, opr, 0, 0); + if (!collsub_reduce_array (desc, mapped_index, opr, 0, 0)) + HEALTH_CHECK (stat, errmsg, errmsg_len); } void @@ -1034,7 +1039,8 @@ _gfortran_caf_co_reduce (gfc_descriptor_t *desc, void *(*opr) (void *, void *), NULL, stat)) return; - collsub_reduce_array (desc, mapped_index, opr, opr_flags, desc_len); + if (!collsub_reduce_array (desc, mapped_index, opr, opr_flags, desc_len)) + HEALTH_CHECK (stat, errmsg, errmsg_len); } void diff --git a/libgfortran/caf/shmem/collective_subroutine.c b/libgfortran/caf/shmem/collective_subroutine.c index f97789cab1c3..911c54acbee9 100644 --- a/libgfortran/caf/shmem/collective_subroutine.c +++ b/libgfortran/caf/shmem/collective_subroutine.c @@ -22,7 +22,6 @@ a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see . */ -#include "../caf_error.h" #include "collective_subroutine.h" #include "supervisor.h" #include "teams_mgmt.h" @@ -221,16 +220,15 @@ get_collsub_buf (size_t size) /* This function syncs all images with one another. It will only return once all images have called it. The reduction is laid out over a fixed set of - images, so it cannot be completed once an image of the team terminated. */ + images, so it cannot be completed once an image of the team terminated. + Returns false in that case. */ -static void +static bool collsub_sync (void) { counter_barrier *barrier = &caf_current_team->u.image_info->collsub.barrier; - if (!counter_barrier_wait_abortable (barrier)) - caf_runtime_error ("Image terminated while executing a collective " - "subroutine"); + return counter_barrier_wait_abortable (barrier); } typedef void *(*red_op) (void *, void *); @@ -321,7 +319,7 @@ gen_reduction (const int type, const size_t sz, const int flags) /* Having result_image == -1 means allreduce. */ -void +bool collsub_reduce_array (gfc_descriptor_t *desc, int result_image, void *(*op) (void *, void *), int opr_flags, int str_len __attribute__ ((unused))) @@ -339,7 +337,7 @@ collsub_reduce_array (gfc_descriptor_t *desc, int result_image, packed = pack_array_prepare (&pi, desc); if (pi.num_elem == 0) - return; + return true; elem_size = GFC_DESCRIPTOR_SIZE (desc); this_image_size_bytes = elem_size * pi.num_elem; @@ -354,7 +352,8 @@ collsub_reduce_array (gfc_descriptor_t *desc, int result_image, pack_array_finish (&pi, desc, this_image_buf); assign = gen_reduction (GFC_DESCRIPTOR_TYPE (desc), elem_size, opr_flags); - collsub_sync (); + if (!collsub_sync ()) + return false; for (; ((this_img_id >> cbit) & 1) == 0 && (caf_current_team->u.image_info->image_count.count >> cbit) != 0; @@ -371,11 +370,13 @@ collsub_reduce_array (gfc_descriptor_t *desc, int result_image, ++i, roll_iter += elem_size, src_iter += elem_size) assign (op, roll_iter, src_iter, elem_size); } - collsub_sync (); + if (!collsub_sync ()) + return false; } for (; (caf_current_team->u.image_info->image_count.count >> cbit) != 0; cbit++) - collsub_sync (); + if (!collsub_sync ()) + return false; if (result_image < 0 || result_image == this_image.image_num) { @@ -385,14 +386,14 @@ collsub_reduce_array (gfc_descriptor_t *desc, int result_image, unpack_array_finish (&pi, desc, buffer); } - collsub_sync (); + return collsub_sync (); } /* Do not use sync_all(), because the program should deadlock in the case that * some images are on a sync_all barrier while others are in a collective * subroutine. */ -void +bool collsub_broadcast_array (gfc_descriptor_t *desc, int source_image) { void *buffer; @@ -403,7 +404,7 @@ collsub_broadcast_array (gfc_descriptor_t *desc, int source_image) packed = pack_array_prepare (&pi, desc); if (pi.num_elem == 0) - return; + return true; if (GFC_DESCRIPTOR_TYPE (desc) == BT_CHARACTER) { @@ -423,16 +424,18 @@ collsub_broadcast_array (gfc_descriptor_t *desc, int source_image) memcpy (buffer, GFC_DESCRIPTOR_DATA (desc), size_bytes); else pack_array_finish (&pi, desc, buffer); - collsub_sync (); + if (!collsub_sync ()) + return false; } else { - collsub_sync (); + if (!collsub_sync ()) + return false; if (packed) memcpy (GFC_DESCRIPTOR_DATA (desc), buffer, size_bytes); else unpack_array_finish (&pi, desc, buffer); } - collsub_sync (); + return collsub_sync (); } diff --git a/libgfortran/caf/shmem/collective_subroutine.h b/libgfortran/caf/shmem/collective_subroutine.h index 76b1610f9765..01ad34adf5f7 100644 --- a/libgfortran/caf/shmem/collective_subroutine.h +++ b/libgfortran/caf/shmem/collective_subroutine.h @@ -42,9 +42,12 @@ typedef struct collsub_shared void collsub_init_supervisor (collsub_shared *, allocator *, const int init_num_images); -void collsub_broadcast_array (gfc_descriptor_t *, int); +/* Both return false when an image of the current team terminated before the + collective could be completed. */ -void collsub_reduce_array (gfc_descriptor_t *, int, void *(*) (void *, void *), +bool collsub_broadcast_array (gfc_descriptor_t *, int); + +bool collsub_reduce_array (gfc_descriptor_t *, int, void *(*) (void *, void *), int opr_flags, int str_len); #endif From e77642a6f29d87c48a935ea6da7c26ce3f8747d3 Mon Sep 17 00:00:00 2001 From: "Vladimir N. Makarov" Date: Fri, 25 Sep 2026 10:13:41 -0400 Subject: [PATCH 428/584] [PR 127326][LRA]: Fall back to memory when won operand is already a MEM The previous fix resolves 'g' operand to memory when no hard register of can hold the operand mode, but it only does so when OFFMEMOK is set. In case 'g' OFFMEMOK is set for reg operands only, so an operand which is already a MEM never gets marked and stays recorded as GENERAL_REGS. An operand matching it then inherits that class, finds no hard register able to hold the mode, and LRA rejects the asm. Treating won MEM operand the same way as an OFFMEMOK one solves the issue. gcc/ChangeLog: PR rtl-optimization/127326 * lra-constraints.cc (process_alt_operands): Resolve the operand to memory when it is a winning MEM and the value can be held in a register. gcc/testsuite/ChangeLog: PR rtl-optimization/127326 * gcc.target/i386/pr127326.c (test2): New test. --- gcc/lra-constraints.cc | 7 +++++-- gcc/testsuite/gcc.target/i386/pr127326.c | 13 +++++++++++++ 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/gcc/lra-constraints.cc b/gcc/lra-constraints.cc index 72430d517321..76489c976ba8 100644 --- a/gcc/lra-constraints.cc +++ b/gcc/lra-constraints.cc @@ -3065,8 +3065,11 @@ process_alt_operands (int only_alternative) the operand to memory. Mark it so that an operand matching this one can also fall back to memory, otherwise the matched operand would try to reload into an impossible hard reg and - LRA would cycle (e.g. TDmode "+g" asm on 32-bit x86). */ - if (offmemok && this_alternative != NO_REGS + LRA would cycle (e.g. TDmode "+g" asm on 32-bit x86). + An operand which is already memory and won implies the + constraint accepts memory too, even if nothing set + OFFMEMOK for it. */ + if ((offmemok || MEM_P (op)) && this_alternative != NO_REGS && hard_reg_set_subset_p (reg_class_contents[this_alternative], ira_prohibited_class_mode_regs [this_alternative][mode] diff --git a/gcc/testsuite/gcc.target/i386/pr127326.c b/gcc/testsuite/gcc.target/i386/pr127326.c index ed618cf70928..a45c033e1df6 100644 --- a/gcc/testsuite/gcc.target/i386/pr127326.c +++ b/gcc/testsuite/gcc.target/i386/pr127326.c @@ -15,3 +15,16 @@ test (void) __asm ("" : "+g" (u.d)); /* { dg-bogus "inconsistent operand constraints" } */ return u.d; } + +/* Here the union is also read as integers, so it stays in memory and the asm + operand is MEM. The matched input operand still has to be resolved in + memory. */ + +unsigned long long +test2 (void) +{ + union { _Decimal128 d; unsigned long long u[2]; } u; + u.d = 1.0DL; + __asm ("" : "+g" (u.d)); /* { dg-bogus "inconsistent operand constraints" } */ + return u.u[0] + u.u[1]; +} From 386d81e74305e7f19323d4438f54b9abffa82795 Mon Sep 17 00:00:00 2001 From: Robert Dubner Date: Fri, 25 Sep 2026 12:35:03 -0400 Subject: [PATCH 429/584] cobol: Reduce middle-end time with better GENERIC. These changes reduce compilation time for -fno-static-call CALL COBOL statements by consolidating several calls to libgcobol into one call. Another change improved compilation speed slightly by placing several parameters for a library call into a structure. The address of that structure is passed, rather than passing the individual parameters. The processing of the -fstatic-call and the -fno-static-call options is fixed; until now, using either resulting in no-static-call behavior. gcc/cobol/ChangeLog: * cobol1.cc (use_static_call): Change name of global function to set_use_static_call. (set_use_static_call): Likewise. (cobol_langhook_handle_option): Use 'value' parameter rather than 'arg' parameter. * genapi.cc (use_static_call): Change name. (set_use_static_call): Likewise. (create_and_call): Call push/pop_program_state in the correct order. (literal_call_descriptor_type): Use common structure definition in both compile-time and run-time code. (GCOBOL_CALL_FIELD_NAME): Likewise. (GCOBOL_CALL_FIELD_TYPE): Likewise. (literal_call_descriptor): Likewise. (GCOBOL_CALL_FIELD_VALUE): Likewise. (function_pointer_for_literal_call): Consolidate several calls to libgcobol. (parser_call): Likewise. * lang.opt: Modify definition of -fstatic-call. libgcobol/ChangeLog: * libgcobol.cc (__gg__call_warning_message): Moved here from compile time. (__gg__resolve_literal_call): New consolidated function. * literal-call-descriptor.h: New file. --- gcc/cobol/cobol1.cc | 4 +- gcc/cobol/genapi.cc | 218 ++++++++++++++++++++++------ gcc/cobol/lang.opt | 2 +- libgcobol/libgcobol.cc | 65 +++++++++ libgcobol/literal-call-descriptor.h | 31 ++++ 5 files changed, 273 insertions(+), 47 deletions(-) create mode 100644 libgcobol/literal-call-descriptor.h diff --git a/gcc/cobol/cobol1.cc b/gcc/cobol/cobol1.cc index 4cc024c8b0f1..354c568347be 100644 --- a/gcc/cobol/cobol1.cc +++ b/gcc/cobol/cobol1.cc @@ -344,7 +344,7 @@ cobol_option_lang_mask (void) { return CL_Cobol; } -bool use_static_call( bool yn ); +bool set_use_static_call( bool yn ); void add_cobol_exception( ec_type_t type, bool ); bool include_file_add(const char input[]); @@ -517,7 +517,7 @@ cobol_langhook_handle_option (size_t scode, return true; case OPT_fstatic_call: - use_static_call( arg? true : false ); + set_use_static_call( value != 0 ); return true; case OPT_fdefaultbyte: diff --git a/gcc/cobol/genapi.cc b/gcc/cobol/genapi.cc index 301fd6f82e26..62a8ea918db3 100644 --- a/gcc/cobol/genapi.cc +++ b/gcc/cobol/genapi.cc @@ -32,6 +32,10 @@ #include "coretypes.h" #include "tree.h" +#include "stor-layout.h" +#include "ggc.h" +#include "gtype-desc.h" +#include "../../libgcobol/literal-call-descriptor.h" #include "tree-iterator.h" #include "stringpool.h" #include "diagnostic-core.h" @@ -155,7 +159,7 @@ static bool next_program_is_main = false; // transient switch for the module static char *main_entry_point = NULL; static bool static_call = true; -bool use_static_call( bool yn ) { return static_call = yn; } +bool set_use_static_call( bool yn ) { return static_call = yn; } static bool use_static_call() { return static_call; } // This global variable can be set upstream, like from a compiler @@ -13034,8 +13038,9 @@ create_and_call(size_t narg, // Actually call the function, assigning the returned value to that // variable: + returned_value = gg_define_variable(interfunction_type); push_program_state(); - returned_value = call_expr; + gg_assign(returned_value, call_expr); pop_program_state(); // Now we decided what to do with the returned value, based on its type. @@ -13145,6 +13150,133 @@ create_and_call(size_t narg, } } +/* Cache one target-layout type and keep it reachable across GCC collections. + Dynamic root registration avoids requiring a new gengtype input file. */ +static tree literal_call_descriptor_type_node; + +static const struct ggc_root_tab literal_call_descriptor_roots[] = + { + { &literal_call_descriptor_type_node, 1, sizeof(tree), + >_ggc_mx_tree_node, >_pch_nx_tree_node }, + LAST_GGC_ROOT_TAB + }; + +static tree +literal_call_descriptor_type() + { + if( literal_call_descriptor_type_node != NULL_TREE ) + { + return literal_call_descriptor_type_node; + } + + ggc_register_root_tab(literal_call_descriptor_roots); + tree record = make_node(RECORD_TYPE); + literal_call_descriptor_type_node = record; + TYPE_NAME(record) = get_identifier("cblc_literal_call_descriptor"); + + tree const_char_pointer + = build_pointer_type(build_qualified_type(char_type_node, TYPE_QUAL_CONST)); + tree const_void_pointer + = build_pointer_type(build_qualified_type(void_type_node, TYPE_QUAL_CONST)); + +#define GCOBOL_CALL_FIELD_NAME(name, c_type, tree_type) #name, + const char *names[] = + { + GCOBOL_LITERAL_CALL_DESCRIPTOR_FIELDS(GCOBOL_CALL_FIELD_NAME) + }; +#undef GCOBOL_CALL_FIELD_NAME +#define GCOBOL_CALL_FIELD_TYPE(name, c_type, tree_type) tree_type, + tree types[] = + { + GCOBOL_LITERAL_CALL_DESCRIPTOR_FIELDS(GCOBOL_CALL_FIELD_TYPE) + }; +#undef GCOBOL_CALL_FIELD_TYPE + + tree *next = &TYPE_FIELDS(record); + for( size_t i = 0; i < sizeof(types) / sizeof(types[0]); i++ ) + { + tree member_decl = build_decl(UNKNOWN_LOCATION, + FIELD_DECL, + get_identifier(names[i]), + types[i]); + DECL_FIELD_CONTEXT(member_decl) = record; + *next = member_decl; + next = &DECL_CHAIN(member_decl); + } + *next = NULL_TREE; + layout_type(record); + return record; + } + +/* Emit a static initializer, not executable per-call assignments. */ +static tree +literal_call_descriptor(const cbl_refer_t &name, bool issue_warning) + { + tree record = literal_call_descriptor_type(); + tree literal = gg_string_literal(name.field->data.original()); + tree field = gg_get_address_of(name.field->var_decl_node); + tree warning_filename = null_pointer_node; + tree program_id + = build_int_cst(INT, current_function->our_symbol_table_index); + tree call_convention = build_int_cst_type(INT, current_call_convention()); + tree warning_line = integer_zero_node; + + if( issue_warning ) + { + warning_filename = gg_string_literal(current_filename.back().c_str()); + warning_line = build_int_cst_type(INT, CURRENT_LINE_NUMBER); + } + +#define GCOBOL_CALL_FIELD_VALUE(name, c_type, tree_type) name, + tree values[] = + { + GCOBOL_LITERAL_CALL_DESCRIPTOR_FIELDS(GCOBOL_CALL_FIELD_VALUE) + }; +#undef GCOBOL_CALL_FIELD_VALUE + + vec *elts = NULL; + tree member_decl = TYPE_FIELDS(record); + for( size_t i = 0; i < sizeof(values) / sizeof(values[0]); i++ ) + { + tree value = gg_cast(TREE_TYPE(member_decl), values[i]); + CONSTRUCTOR_APPEND_ELT(elts, member_decl, value); + member_decl = DECL_CHAIN(member_decl); + } + gcc_assert(member_decl == NULL_TREE); + + tree initializer = build_constructor(record, elts); + gcc_assert(TREE_CONSTANT(initializer)); + TREE_STATIC(initializer) = 1; + + // vs_static supplies a unique name and roots the declaration in its function. + tree descriptor = gg_define_variable(record, vs_static); + TREE_READONLY(descriptor) = 1; + DECL_ARTIFICIAL(descriptor) = 1; + DECL_IGNORED_P(descriptor) = 1; + DECL_INITIAL(descriptor) = initializer; + return gg_get_address_of(descriptor); + } + +static tree +function_pointer_for_literal_call(const cbl_refer_t &name, + tree function_return_type, + bool issue_warning) + { + tree function_type = build_varargs_function_type_array( + function_return_type, + 0, + NULL); + tree function_pointer_type = build_pointer_type(function_type); + tree descriptor = literal_call_descriptor(name, issue_warning); + + return gg_cast( + function_pointer_type, + gg_call_expr(VOID_P, + "__gg__resolve_literal_call_descriptor", + descriptor, + NULL_TREE)); + } + void parser_call( cbl_refer_t name, cbl_refer_t returned, // This is set by RETURNING clause @@ -13154,9 +13286,6 @@ parser_call( cbl_refer_t name, cbl_label_t *not_except, bool /*is_function*/) { - // A note on the processing of function return types: - - Analyze(); SHOW_PARSE { @@ -13266,9 +13395,23 @@ parser_call( cbl_refer_t name, } else { - tree function_pointer = function_pointer_from_name( name, - interfunction_type); - // We might not have a good handle, so we have to check: + const bool literal_call = name.field->type == FldLiteralA; + const bool issue_warning + = !except && !cdf_enabled_exceptions().match(ec_program_not_found_e); + + tree function_pointer; + if( literal_call ) + { + function_pointer = function_pointer_for_literal_call(name, + interfunction_type, + issue_warning); + } + else + { + function_pointer = function_pointer_from_name(name, interfunction_type); + } + function_pointer = save_expr(function_pointer); + IF( function_pointer, ne_op, gg_cast(TREE_TYPE(function_pointer), null_pointer_node) ) @@ -13283,47 +13426,34 @@ parser_call( cbl_refer_t name, } ELSE { - // We have a bad function pointer, which is the exception condition: - // Set the exception message to "name" - gg_call(VOID, - "__gg__set_exception_call", - gg_get_address_of(name.field->var_decl_node), - refer_offset(name), - NULL_TREE); - parser_exception_raise(ec_program_not_found_e); + /* The literal resolver has already recorded lookup failure. + Variable-name calls retain their existing bookkeeping. */ + if( !literal_call ) + { + gg_call(VOID, + "__gg__set_exception_call", + gg_get_address_of(name.field->var_decl_node), + refer_offset(name), + NULL_TREE); + parser_exception_raise(ec_program_not_found_e); + } + if( except ) { - // We have an ON EXCEPT clause: - gg_append_statement( except->structs.call_exception->into.go_to ); - // Because there is an ON EXCEPTION clause, suppress DECLARATIVE - // processing + // Preserve the existing ON EXCEPTION routing and reset placement. + gg_append_statement(except->structs.call_exception->into.go_to); gg_assign(var_decl_exception_code, integer_zero_node); } - else + else if( !literal_call && issue_warning ) { - // When EC-PROGRAM-NOT-FOUND is not enabled, we issue a warning. - const cbl_enabled_exceptions_t& - enabled_exceptions( cdf_enabled_exceptions() ); - if( !enabled_exceptions.match(ec_program_not_found_e) ) - { - tree mangled_name = gg_define_variable(CHAR_P); - - gg_call(VOID, - "__gg__just_mangle_name", - (name.field->var_decl_node - ? gg_get_address_of(name.field->var_decl_node) - : null_pointer_node), - gg_get_address_of( mangled_name), - NULL_TREE); - - gg_printf("WARNING: %s:%d \"CALL %s\" not found" - " with no \"CALL ON EXCEPTION\" phrase.\n" - "(You might need -rdynamic or --export-dynamic for symbols in the executable.)\n", - gg_string_literal(current_filename.back().c_str()), - build_int_cst_type(INT, CURRENT_LINE_NUMBER), - mangled_name, - NULL_TREE); - } + gg_call(VOID, + "__gg__call_warning_message", + (name.field->var_decl_node + ? gg_get_address_of(name.field->var_decl_node) + : null_pointer_node), + gg_string_literal(current_filename.back().c_str()), + build_int_cst_type(INT, CURRENT_LINE_NUMBER), + NULL_TREE); } } ENDIF diff --git a/gcc/cobol/lang.opt b/gcc/cobol/lang.opt index 0d381a3394e3..32553775c0e7 100644 --- a/gcc/cobol/lang.opt +++ b/gcc/cobol/lang.opt @@ -436,7 +436,7 @@ Cobol RejectNegative Joined Separate UInteger Var(indicator_column) Init(0) Inte -findicator-column= Column after which Region A begins. fstatic-call -Cobol Var(cobol_static_call, 1) Init(1) +Cobol Var(cobol_static_call) Init(1) Enable/disable static linkage for CALL literals. ftrace-debug diff --git a/libgcobol/libgcobol.cc b/libgcobol/libgcobol.cc index 7e48914c8e52..f4bb4c18e702 100644 --- a/libgcobol/libgcobol.cc +++ b/libgcobol/libgcobol.cc @@ -67,6 +67,7 @@ #include "gcobolio.h" #include "cobol-endian.h" #include "libgcobol.h" +#include "literal-call-descriptor.h" #include "gfileio.h" #include "charmaps.h" #include "valconv.h" @@ -11288,6 +11289,25 @@ __gg__just_mangle_name( const cblc_field_t *field, } } +extern "C" +void +__gg__call_warning_message(const cblc_field_t *name, + const char *filename, + int line_number) + { + char *mangled_name = nullptr; + __gg__just_mangle_name(name, &mangled_name); + + fprintf(stderr, + "WARNING: %s:%d \"CALL %s\" not found" + " with no \"CALL ON EXCEPTION\" phrase.\n" + "(You might need -rdynamic or --export-dynamic for symbols" + " in the executable.)\n", + filename, + line_number, + mangled_name); + } + extern "C" void * __gg__function_handle_from_literal(int program_id, @@ -13697,6 +13717,51 @@ __gg__set_exception_call(const cblc_field_t *field, &nbytes); } +/* A null warning_filename suppresses the warning, not exception bookkeeping. + This wrapper is only for literal CALL statements; other resolver users + retain the original resolver interface without CALL exception bookkeeping. */ +extern "C" +void * +__gg__resolve_literal_call(int program_id, + const char *literal, + int call_convention, + const cblc_field_t *field, + const char *warning_filename, + int warning_line) + { + void *target = __gg__function_handle_from_literal(program_id, + literal, + call_convention); + + if( target == nullptr ) + { + __gg__set_exception_call(field, 0); + __gg__set_exception_code(ec_program_not_found_e, 1); + + if( warning_filename != nullptr ) + { + __gg__call_warning_message(field, warning_filename, warning_line); + } + } + + return target; + } + +/* Keep the six-argument entry point available for existing generated code. */ +extern "C" +void * +__gg__resolve_literal_call_descriptor( + const cblc_literal_call_descriptor *descriptor) + { + return __gg__resolve_literal_call( + descriptor->program_id, + descriptor->literal, + descriptor->call_convention, + static_cast(descriptor->field), + descriptor->warning_filename, + descriptor->warning_line); + } + extern "C" int __gg__prohibited(const cblc_field_t *field, __int128 value) diff --git a/libgcobol/literal-call-descriptor.h b/libgcobol/literal-call-descriptor.h new file mode 100644 index 000000000000..57db43ba12aa --- /dev/null +++ b/libgcobol/literal-call-descriptor.h @@ -0,0 +1,31 @@ +/* Shared layout for compiler-generated literal CALL descriptors. + Field order and C/GCC type mappings are defined together here. */ +#ifndef GCOBOL_LITERAL_CALL_DESCRIPTOR_H +#define GCOBOL_LITERAL_CALL_DESCRIPTOR_H + +/* X(member name, runtime C++ type, compiler target tree type). + The third argument is only expanded by the GENERIC builder. */ +#define GCOBOL_LITERAL_CALL_DESCRIPTOR_FIELDS(X) \ + X(literal, const char *, const_char_pointer) \ + X(field, const void *, const_void_pointer) \ + X(warning_filename, const char *, const_char_pointer) \ + X(program_id, int, INT) \ + X(call_convention, int, INT) \ + X(warning_line, int, INT) + +struct cblc_literal_call_descriptor + { +#define GCOBOL_DECLARE_CALL_FIELD(name, c_type, tree_type) c_type name; + GCOBOL_LITERAL_CALL_DESCRIPTOR_FIELDS(GCOBOL_DECLARE_CALL_FIELD) +#undef GCOBOL_DECLARE_CALL_FIELD + }; + +/* literal and warning_filename use the existing NUL-terminated resolver + and diagnostic interfaces. field points to a counted cblc_field_t. + A null warning_filename suppresses the warning only. + The descriptor contains metadata, never a cached resolved address. */ +extern "C" void * +__gg__resolve_literal_call_descriptor( + const cblc_literal_call_descriptor *descriptor); + +#endif From bddea69ee406a0f68aed8f42ea7efba2d8b5883c Mon Sep 17 00:00:00 2001 From: Aldy Hernandez Date: Sat, 29 Aug 2026 20:16:11 +0000 Subject: [PATCH 430/584] range-ops: derive operand equality from a zero MINUS_EXPR A conditional such as: d_5 = a_3 - b_4; if (d_5 == 0) implies a_3 == b_4 on the true edge regardless of overflow behavior, but no relation was recorded because operator_minus lacks op1_op2_relation and register_outgoing_edges only derives relations from boolean exports. Add the former and relax the latter. match.pd already folds this: /* Transform comparisons of the form X - Y CMP 0 to X CMP Y. */ (cmp (sub@2 @0 @1) integer_zerop) (if (single_use (@2)) (cmp @0 @1)) but only for a single-use difference. Measured with perf over a corpus of .ii files from a stage1 bootstrap compile time is +0.13% overall. VRP is +0.8%, DOM +1.7% and the threader +3.4%. The cost is register_outgoing_edges itself which is +36%. Tested on ppc64le Linux. PR tree-optimization/127485 gcc/ChangeLog: * range-op-mixed.h (class operator_minus): Add op1_op2_relation. * range-op.cc (operator_minus::op1_op2_relation): New. * gimple-range-fold.cc (fur_source::register_outgoing_edges): Derive relations from any integral export, not just booleans. gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/vrp-minus-relation-1.c: New test. --- gcc/gimple-range-fold.cc | 5 ++++- gcc/range-op-mixed.h | 3 +++ gcc/range-op.cc | 19 +++++++++++++++++++ .../gcc.dg/tree-ssa/vrp-minus-relation-1.c | 17 +++++++++++++++++ 4 files changed, 43 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/vrp-minus-relation-1.c diff --git a/gcc/gimple-range-fold.cc b/gcc/gimple-range-fold.cc index abe3ade2960d..a143c19647af 100644 --- a/gcc/gimple-range-fold.cc +++ b/gcc/gimple-range-fold.cc @@ -1751,9 +1751,12 @@ fur_source::register_outgoing_edges (gcond *s, irange &lhs_range, // leading to the condition such as: // c_2 = a_4 < b_7 // if (c_2) + // as well as relations implied by a known result, such as: + // c_2 = a_4 - b_7 + // if (c_2 == 0) FOR_EACH_GORI_EXPORT_NAME (gori_ssa (), bb, name) { - if (TREE_CODE (TREE_TYPE (name)) != BOOLEAN_TYPE) + if (!INTEGRAL_TYPE_P (TREE_TYPE (name))) continue; gimple *stmt = SSA_NAME_DEF_STMT (name); gimple_range_op_handler handler (stmt); diff --git a/gcc/range-op-mixed.h b/gcc/range-op-mixed.h index 0e97fb11688c..b084c3edeab5 100644 --- a/gcc/range-op-mixed.h +++ b/gcc/range-op-mixed.h @@ -648,6 +648,7 @@ class operator_minus : public range_operator using range_operator::op1_range; using range_operator::op2_range; using range_operator::lhs_op1_relation; + using range_operator::op1_op2_relation; using range_operator::op1_op2_relation_effect; using range_operator::update_bitmask; bool op1_range (irange &r, tree type, @@ -668,6 +669,8 @@ class operator_minus : public range_operator relation_kind lhs_op1_relation (const irange &lhs, const irange &op1, const irange &op2, relation_kind rel) const final override; + relation_kind op1_op2_relation (const irange &lhs, const irange &, + const irange &) const final override; bool op1_op2_relation_effect (irange &lhs_range, tree type, const irange &op1_range, const irange &op2_range, diff --git a/gcc/range-op.cc b/gcc/range-op.cc index 350548951f45..07318bca71ee 100644 --- a/gcc/range-op.cc +++ b/gcc/range-op.cc @@ -2102,6 +2102,25 @@ minus_op1_op2_relation_effect (irange &lhs_range, tree type, return true; } +// Check if the LHS range indicates a relation between OP1 and OP2. +// OP1 - OP2 == 0 implies OP1 == OP2 even with wrapping arithmetic. + +relation_kind +operator_minus::op1_op2_relation (const irange &lhs, const irange &, + const irange &) const +{ + if (lhs.undefined_p ()) + return VREL_UNDEFINED; + + if (lhs.zero_p ()) + return VREL_EQ; + + if (!lhs.contains_zero_p ()) + return VREL_NE; + + return VREL_VARYING; +} + bool operator_minus::op1_op2_relation_effect (irange &lhs_range, tree type, const irange &op1_range, diff --git a/gcc/testsuite/gcc.dg/tree-ssa/vrp-minus-relation-1.c b/gcc/testsuite/gcc.dg/tree-ssa/vrp-minus-relation-1.c new file mode 100644 index 000000000000..f071ffa57962 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp-minus-relation-1.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-vrp1" } */ + +void dead (void); + +void f (int a, int b) +{ + int d = a - b; + if (d < 0) + return; + if (d > 0) + return; + if (a != b) + dead (); +} + +/* { dg-final { scan-tree-dump-not "dead" "vrp1" } } */ From 1755c3815690bddfe0450b692c58ae98daec1b9c Mon Sep 17 00:00:00 2001 From: Andrea Pinski Date: Thu, 24 Sep 2026 21:23:24 -0700 Subject: [PATCH 431/584] except: Use chain_next on eh_region_d for GTY [PR127602] With many local variables with cleanups needed, we get a huge chain of eh_region_d; and in some cases inside the GC, the stack can overflow. This fixes the issue by using chain_next on eh_region_d. In a similar way r14-2270-gd0a333612bfb7f was done for eh_landing_pad_d. Pushed as obvious after bootstrap/test on x86_64-linux-gnu. PR middle-end/127602 gcc/ChangeLog: * except.h (struct eh_region_d): Add chain_next GTY. Signed-off-by: Andrea Pinski --- gcc/except.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/except.h b/gcc/except.h index e0cb9431166c..1988d9f4ad79 100644 --- a/gcc/except.h +++ b/gcc/except.h @@ -115,7 +115,7 @@ struct GTY(()) eh_catch_d /* Describes one exception region. */ -struct GTY(()) eh_region_d +struct GTY((chain_next("%h.next_peer"))) eh_region_d { /* The immediately surrounding region. */ struct eh_region_d *outer; From 36aa829e54652ed78ed4697f9ff0ebe7ed4608ba Mon Sep 17 00:00:00 2001 From: Andrea Pinski Date: Thu, 24 Sep 2026 21:31:59 -0700 Subject: [PATCH 432/584] except: Use chain_next/chain_prev on eh_catch_d for GTY [PR127602] Since eh_catch_d is double linked list, let's add chain_next and chain_prev preemptively just in case there is another GC issue where we get a huge recursion for this struct. Pushed as obvious after bootstrap/test on x86_64-linux-gnu. PR middle-end/127602 gcc/ChangeLog: * except.h (struct eh_catch_d): Add chain_next and chain_prev GTY. Signed-off-by: Andrea Pinski --- gcc/except.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/except.h b/gcc/except.h index 1988d9f4ad79..657b019b8af2 100644 --- a/gcc/except.h +++ b/gcc/except.h @@ -92,7 +92,7 @@ struct GTY((chain_next("%h.next_lp"))) eh_landing_pad_d /* A catch handler associated with an ERT_TRY region. */ -struct GTY(()) eh_catch_d +struct GTY((chain_next("%h.next_catch"), chain_prev("%h.prev_catch"))) eh_catch_d { /* The double-linked list of all catch handlers for the region. */ struct eh_catch_d *next_catch; From 6ec6cf132ae13ca6542f91b1a3c94d192d95dafb Mon Sep 17 00:00:00 2001 From: Dominic P Date: Fri, 25 Sep 2026 21:13:58 +0100 Subject: [PATCH 433/584] MAINTAINERS: Add myself to write after approval and DCO Assisted-by: Claude Opus 5 (Anthropic) ChangeLog: * MAINTAINERS.yml: Add myself. * MAINTAINERS: Regenerate. Signed-off-by: Dominic P --- MAINTAINERS | 2 ++ MAINTAINERS.yml | 9 +++++++++ 2 files changed, 11 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 8b033d98aaf7..44e8b1f84954 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -754,6 +754,7 @@ Alexandre Oliva aoliva Andrea Ornstein andreao Rainer Orth ro Maxim Ostapenko chefmax +Dominic P dominicp Jeevitha Palanisamy jeevitha Patrick Palka ppalka Seongbae Park spark @@ -1024,6 +1025,7 @@ Gaius Mulley Shreya Munnangi Shreya Munnangi Szabolcs Nagy +Dominic P Pierre-Emmanuel Patry Pierre-Emmanuel Patry Mikael Pettersson diff --git a/MAINTAINERS.yml b/MAINTAINERS.yml index 01497c627f29..a5ab2f11b61a 100644 --- a/MAINTAINERS.yml +++ b/MAINTAINERS.yml @@ -4554,6 +4554,15 @@ users: - WriteAfter account: chefmax inactive: true +- sn: P + cn: Dominic P + email: + - gcc@gcc.dp11.uk + roles: + - WriteAfter + account: dominicp + DCO: + - gcc@gcc.dp11.uk - sn: Palanisamy cn: Jeevitha Palanisamy email: From bfdd3d3d8b6877435898c89393177bbcbd713309 Mon Sep 17 00:00:00 2001 From: Thomas Schwinge Date: Thu, 24 Sep 2026 12:14:16 +0200 Subject: [PATCH 434/584] cselim: cond_if_else_store_replacement_limited support skipping on store one either side: Adjust 'libgomp.graphite/force-parallel-8.c' [PR127053] With commit r17-4469-ge35b8dad030bc4164fdaa81dc0a5bfca8c1bbfc3 "cselim: cond_if_else_store_replacement_limited support skipping on store one either side [PR127053]", we regressed: PASS: libgomp.graphite/force-parallel-8.c (test for excess errors) PASS: libgomp.graphite/force-parallel-8.c execution test [-PASS:-]{+FAIL:+} libgomp.graphite/force-parallel-8.c scan-tree-dump-times graphite "5 loops carried no dependency" 1 PASS: libgomp.graphite/force-parallel-8.c scan-tree-dump-times optimized "loopfn.0" 4 PASS: libgomp.graphite/force-parallel-8.c scan-tree-dump-times optimized "loopfn.1" 4 libgomp.graphite/force-parallel-8.c: pattern found 0 times Indeed, instead of "5" it is now "3 loops carried no dependency". Per 'diff' of '-fdump-tree-all-details-folding' for commit r17-4469-ge35b8dad030bc4164fdaa81dc0a5bfca8c1bbfc3 "cselim: cond_if_else_store_replacement_limited support skipping on store one either side [PR127053]" reverted vs. current sources, I see in 'force-parallel-8.c.050t.phiopt1': [...] ;; Function foo (foo, funcdef_no=0, decl_uid=2216, cgraph_uid=3, symbol_order=2) +factoring out stores: + then: +# .MEM_30 = VDEF <.MEM_19> +x[i_12][j_14] = _3; + else: +# .MEM_29 = VDEF <.MEM_19> +x[i_12][j_14] = _7; + +to use phi: +cstore_33 = PHI <_3(11), _7(12)> + +# .MEM_18 = VDEF <.MEM_27> +x[i_12][j_14] = cstore_33; [...] ..., and subsequent simplification (as far as I can quickly tell) of the IR. Restore the previous state via '-fno-expensive-optimizations', to continue testing what was tested before. PR tree-optimization/127053 libgomp/ * testsuite/libgomp.graphite/force-parallel-8.c: 'dg-additional-options -fno-expensive-optimizations'. --- libgomp/testsuite/libgomp.graphite/force-parallel-8.c | 1 + 1 file changed, 1 insertion(+) diff --git a/libgomp/testsuite/libgomp.graphite/force-parallel-8.c b/libgomp/testsuite/libgomp.graphite/force-parallel-8.c index ee5a67aa2b09..4dae03e1690d 100644 --- a/libgomp/testsuite/libgomp.graphite/force-parallel-8.c +++ b/libgomp/testsuite/libgomp.graphite/force-parallel-8.c @@ -1,4 +1,5 @@ /* { dg-additional-options "-fno-thread-jumps --param max-stores-to-sink=0" } */ +/* { dg-additional-options -fno-expensive-optimizations } */ #define N 1500 From 273bbf231812f1c31fd8249015a643d30338ed6f Mon Sep 17 00:00:00 2001 From: Dominic P Date: Thu, 17 Sep 2026 04:47:13 +0100 Subject: [PATCH 435/584] testsuite: move the vector minmax tests to gcc.dg/vect Four of these tests ask for vect_int from gcc.dg/tree-ssa, and the fifth, minmax-swar-5.c, needs the same guard. The flags those selectors are answered under come from vect.exp, which is also what adds -msse2, -maltivec or the NEON options and what skips a target that cannot vectorize at all. Move all five there, keep the requirement, and drop the ia32 option line vect.exp supplies itself. The rules ask target_supports_op_p for the vector MIN_EXPR, so the vector spelling folds only where the target has one: on cortex-m0 all six functions of minmax-swar-5.c stop at VEC_COND_EXPR. The two tests that assume a 16-byte vector gate their scans on vect128, and the widths come from sizeof. Tested on x86_64-pc-linux-gnu and aarch64-linux-gnu, and with an arm-none-eabi cross on cortex-a15 NEON and cortex-m0 soft. Assisted-by: Claude Opus 5 (Anthropic) gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/minmax-swar-5.c: Move to... * gcc.dg/vect/minmax-swar-5.c: ...here. Require vect_int, take the flags from vect.exp, size the vector with sizeof and gate the scans. * gcc.dg/tree-ssa/minmax-swar-6.c: Move to... * gcc.dg/vect/minmax-swar-6.c: ...here. Take the flags from vect.exp. * gcc.dg/tree-ssa/minmax-swar-7.c: Move to... * gcc.dg/vect/minmax-swar-7.c: ...here. Likewise. * gcc.dg/tree-ssa/minmax-negate-3.c: Move to... * gcc.dg/vect/minmax-negate-3.c: ...here. Likewise. * gcc.dg/tree-ssa/vector-alignup-1.c: Move to... * gcc.dg/vect/vector-alignup-1.c: ...here. Likewise, size the vectors with sizeof and gate the scans. Signed-off-by: Dominic P --- .../gcc.dg/tree-ssa/vector-alignup-1.c | 16 ------------ .../{tree-ssa => vect}/minmax-negate-3.c | 3 +-- .../gcc.dg/{tree-ssa => vect}/minmax-swar-5.c | 25 +++++++++++-------- .../gcc.dg/{tree-ssa => vect}/minmax-swar-6.c | 3 +-- .../gcc.dg/{tree-ssa => vect}/minmax-swar-7.c | 3 +-- gcc/testsuite/gcc.dg/vect/vector-alignup-1.c | 15 +++++++++++ 6 files changed, 32 insertions(+), 33 deletions(-) delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/vector-alignup-1.c rename gcc/testsuite/gcc.dg/{tree-ssa => vect}/minmax-negate-3.c (92%) rename gcc/testsuite/gcc.dg/{tree-ssa => vect}/minmax-swar-5.c (55%) rename gcc/testsuite/gcc.dg/{tree-ssa => vect}/minmax-swar-6.c (92%) rename gcc/testsuite/gcc.dg/{tree-ssa => vect}/minmax-swar-7.c (89%) create mode 100644 gcc/testsuite/gcc.dg/vect/vector-alignup-1.c diff --git a/gcc/testsuite/gcc.dg/tree-ssa/vector-alignup-1.c b/gcc/testsuite/gcc.dg/tree-ssa/vector-alignup-1.c deleted file mode 100644 index 5b32c668710a..000000000000 --- a/gcc/testsuite/gcc.dg/tree-ssa/vector-alignup-1.c +++ /dev/null @@ -1,16 +0,0 @@ -/* { dg-do compile } */ -/* { dg-require-effective-target vect_int } */ -/* { dg-options "-O2 -fdump-tree-optimized" } */ -/* { dg-additional-options "-msse2" { target ia32 } } */ - -/* Rounding up by adding the padding, spelled with vectors. */ - -typedef unsigned int v4ui __attribute__((vector_size (16))); -typedef int v4si __attribute__((vector_size (16))); - -v4ui f1 (v4ui x) { return x + ((-x) & 15); } -v4si f2 (v4si x) { return x + ((-x) & 63); } - -/* { dg-final { scan-tree-dump-not "= -" "optimized" } } */ -/* { dg-final { scan-tree-dump-times " \\+ " 2 "optimized" } } */ -/* { dg-final { scan-tree-dump-times " & " 2 "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/minmax-negate-3.c b/gcc/testsuite/gcc.dg/vect/minmax-negate-3.c similarity index 92% rename from gcc/testsuite/gcc.dg/tree-ssa/minmax-negate-3.c rename to gcc/testsuite/gcc.dg/vect/minmax-negate-3.c index 562e76bfde9f..cea581a5daf5 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/minmax-negate-3.c +++ b/gcc/testsuite/gcc.dg/vect/minmax-negate-3.c @@ -1,7 +1,6 @@ /* { dg-do compile } */ /* { dg-require-effective-target vect_int } */ -/* { dg-options "-O3 -fdump-tree-optimized" } */ -/* { dg-additional-options "-msse2" { target ia32 } } */ +/* { dg-additional-options "-fdump-tree-optimized" } */ /* The rule reaching vector code. It matches the scalar loop body, so what is left to vectorize is a vector MAX or MIN of the unnegated loads and a vector diff --git a/gcc/testsuite/gcc.dg/tree-ssa/minmax-swar-5.c b/gcc/testsuite/gcc.dg/vect/minmax-swar-5.c similarity index 55% rename from gcc/testsuite/gcc.dg/tree-ssa/minmax-swar-5.c rename to gcc/testsuite/gcc.dg/vect/minmax-swar-5.c index 931d5a0d7419..9ab595e36d8a 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/minmax-swar-5.c +++ b/gcc/testsuite/gcc.dg/vect/minmax-swar-5.c @@ -1,14 +1,17 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -Wno-psabi -fdump-tree-forwprop1-raw" } */ +/* { dg-require-effective-target vect_int } */ +/* { dg-additional-options "-Wno-psabi -fdump-tree-forwprop1-raw" } */ /* All six rules on a vector type. The selects against zero are spelled with - >, not <: a vector x < 0 is canonicalised to the sign mask x >> 31, and the - rule that turns x & (x >> 31) into MIN is scalar, so that spelling - forms no vector MIN_EXPR at all. The scan is on forwprop1, which runs - before the vector lowering that would split a MAX_EXPR the target cannot - do. */ + >, not <: a vector x < 0 is canonicalised to the sign mask + x >> (precision - 1), and the rule that turns x & (x >> (precision - 1)) + into MIN is scalar, so that spelling forms no vector MIN_EXPR at + all. The scan is on forwprop1, which runs before the vector lowering that + would split a MAX_EXPR the target cannot do. The rules ask + target_supports_op_p for the vector MIN_EXPR, hence the selector on the + scans. */ -typedef int v4si __attribute__ ((vector_size (16))); +typedef int v4si __attribute__ ((vector_size (4 * sizeof (int)))); /* Y + MIN (X - Y, 0) -> MIN (X, Y). */ v4si @@ -64,7 +67,7 @@ clamp_hi_vec (v4si x, v4si y) return ((s & m) | (y & ~m)) - y; } -/* { dg-final { scan-tree-dump-not " Date: Thu, 17 Sep 2026 05:07:14 +0100 Subject: [PATCH 436/584] testsuite: derive the sign shift from sizeof in minmax-swar-1 and -2 The shift count was 31 under an int32 requirement, which left the rule untested on every other int width. Tested on x86_64-pc-linux-gnu, aarch64-linux-gnu and arm-none-eabi (cortex-m0 soft). Assisted-by: Claude Opus 5 (Anthropic) gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/minmax-swar-1.c: Derive the shift count from sizeof (int); drop the int32 requirement. * gcc.dg/tree-ssa/minmax-swar-2.c: Likewise. Signed-off-by: Dominic P --- gcc/testsuite/gcc.dg/tree-ssa/minmax-swar-1.c | 20 ++++++++++--------- gcc/testsuite/gcc.dg/tree-ssa/minmax-swar-2.c | 7 ++++--- 2 files changed, 15 insertions(+), 12 deletions(-) diff --git a/gcc/testsuite/gcc.dg/tree-ssa/minmax-swar-1.c b/gcc/testsuite/gcc.dg/tree-ssa/minmax-swar-1.c index 53bf1242cb8b..1c7395af1d4a 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/minmax-swar-1.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/minmax-swar-1.c @@ -1,47 +1,49 @@ /* { dg-do compile } */ /* { dg-options "-O2 -fdump-tree-forwprop1 -fdump-tree-optimized" } */ -/* { dg-require-effective-target int32 } */ + +#define SHIFT (sizeof (int) * __CHAR_BIT__ - 1) /* The branchless min and max that x264's x264_median writes. The existing - rule turns x & (x >> 31) into MIN ; these have to finish the job. */ + rule turns x & (x >> (precision - 1)) into MIN ; these have to finish + the job. */ int swar_min (int a, int b) { int t = a - b; - return b + (t & (t >> 31)); + return b + (t & (t >> SHIFT)); } int swar_max (int a, int b) { int t = a - b; - return a - (t & (t >> 31)); + return a - (t & (t >> SHIFT)); } int swar_min_not (int a, int b) { int t = a - b; - return a - (t & ~(t >> 31)); + return a - (t & ~(t >> SHIFT)); } int swar_max_not (int a, int b) { int t = a - b; - return b + (t & ~(t >> 31)); + return b + (t & ~(t >> SHIFT)); } /* Both uses of the one difference have to fold. */ int swar_median (int a, int b, int c) { - int t = (a - b) & ((a - b) >> 31); + int t = (a - b) & ((a - b) >> SHIFT); a -= t; b += t; - b -= (b - c) & ((b - c) >> 31); - b += (a - b) & ((a - b) >> 31); + b -= (b - c) & ((b - c) >> SHIFT); + b += (a - b) & ((a - b) >> SHIFT); return b; } diff --git a/gcc/testsuite/gcc.dg/tree-ssa/minmax-swar-2.c b/gcc/testsuite/gcc.dg/tree-ssa/minmax-swar-2.c index b600d69207e9..0066b185abff 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/minmax-swar-2.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/minmax-swar-2.c @@ -1,6 +1,7 @@ /* { dg-do compile } */ /* { dg-options "-O2 -fwrapv -fdump-tree-optimized" } */ -/* { dg-require-effective-target int32 } */ + +#define SHIFT (sizeof (int) * __CHAR_BIT__ - 1) /* With a wrapping difference the identity fails: for a = INT_MIN, b = 1 the difference wraps positive and the branchless form returns b. The inner @@ -11,14 +12,14 @@ int swar_min (int a, int b) { int t = a - b; - return b + (t & (t >> 31)); + return b + (t & (t >> SHIFT)); } int swar_max (int a, int b) { int t = a - b; - return a - (t & (t >> 31)); + return a - (t & (t >> SHIFT)); } /* { dg-final { scan-tree-dump-times "MIN_EXPR <\[^,\]*, 0>" 2 "optimized" } } */ From 0de4790181fcf74665c3c27e901559a16d3e4991 Mon Sep 17 00:00:00 2001 From: Michiel Derhaeg Date: Mon, 21 Sep 2026 16:17:00 +0200 Subject: [PATCH 437/584] RISC-V: Update ARC-V RMX-100 load latency The old latency is more of a worst-case. Better to optimize for the likely case. Also update branding as the ARC brand+ip has been acquired by MIPS. gcc/ChangeLog: * config/riscv/arcv-rmx100.md (arcv_rmx100_load_insn): Update latency. (arcv_rmx100_fpload_insn): Merge with *_load_insn. Signed-off-by: Michiel Derhaeg --- gcc/config/riscv/arcv-rmx100.md | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/gcc/config/riscv/arcv-rmx100.md b/gcc/config/riscv/arcv-rmx100.md index e573a456db1e..fb34d1202e46 100644 --- a/gcc/config/riscv/arcv-rmx100.md +++ b/gcc/config/riscv/arcv-rmx100.md @@ -1,4 +1,4 @@ -;; DFA scheduling description of the Synopsys RMX-100 cpu +;; DFA scheduling description of the ARC-V RMX-100 cpu ;; for GNU C compiler ;; Copyright (C) 2026 Free Software Foundation, Inc. @@ -51,9 +51,9 @@ (eq_attr "type" "imul")) "arcv_rmx100_MPY") -(define_insn_reservation "arcv_rmx100_load_insn" 3 +(define_insn_reservation "arcv_rmx100_load_insn" 1 (and (eq_attr "tune" "arcv_rmx100") - (eq_attr "type" "load")) + (eq_attr "type" "load,fpload")) "arcv_rmx100_DMP") (define_insn_reservation "arcv_rmx100_store_insn" 1 @@ -63,11 +63,6 @@ ;; FPU scheduling. This is based on the "fast" unit for now. -(define_insn_reservation "arcv_rmx100_fpload_insn" 3 - (and (eq_attr "tune" "arcv_rmx100") - (eq_attr "type" "fpload")) - "arcv_rmx100_DMP") - (define_insn_reservation "arcv_rmx100_farith_insn" 2 (and (eq_attr "tune" "arcv_rmx100") (eq_attr "type" "fadd,fcmp")) From 4b9034d6b240aa2bac3152703c3961b76e30a187 Mon Sep 17 00:00:00 2001 From: Dominic P Date: Thu, 10 Sep 2026 15:33:43 +0100 Subject: [PATCH 438/584] aarch64: express sqxtun and friends as us_truncate of smax The sqxtun patterns are written with more complex RTL than the instruction needs: us_truncate of an smax against zero is what they should match. Rewrite them that way, so that the shape the vectoriser produces for MAX_EXPR <0, x> fed into IFN_SAT_TRUNC is matched by the sqxtun pattern itself. The rewrite covers more than the two sqxtun patterns. sqxtun2, sqshrun, sqshrun2, sqrshrun and sqrshrun2 wrap their results in the same truncate/smin/smax clamp against half_mask, so converting only the sqxtun pair would have left two spellings of "saturate into the unsigned narrow mode" in one file; they are converted too. The named expanders build the us_truncate form directly, which is what keeps the vqmovun_*, vqshrun_n_* and vqrshrun_n_* intrinsics working: they reach the patterns through gen_* rather than through recog on a combination. aarch64_simd_umax_half_mode and aarch64_simd_umax_quarter_mode lose their last users and are removed. The scalar sqshrun/sqrshrun define_insns are unchanged: they compute in the wide mode and the expander takes a lowpart, so there is no truncate for the clamp to fold into. The vqmovun/vqshrun_n/vqrshrun_n tests in gcc.target/aarch64/advsimd-intrinsics compare against expected values and run under qemu, so the family already has execution coverage; the new test only checks that the vectoriser's form reaches sqxtun. Bootstrapped and regression tested on x86_64-pc-linux-gnu, and cross-tested on aarch64-linux-gnu under qemu (aarch64.exp, simd.exp, advsimd-intrinsics.exp, vect.exp). Assisted-by: Claude Opus 5 (Anthropic) gcc/ChangeLog: * config/aarch64/predicates.md (aarch64_simd_umax_half_mode) (aarch64_simd_umax_quarter_mode): Remove. * config/aarch64/aarch64-simd.md (aarch64_sqmovun) (*aarch64_sqmovun_insn) (aarch64_sqxtun2_le, aarch64_sqxtun2_be) (aarch64_sqxtun2) (*aarch64_sqshrun_n_insn) (aarch64_sqshrun_n) (*aarch64_sqrshrun_n_insn) (aarch64_sqrshrun_n, aarch64_sqshrun2_n_insn_le) (aarch64_sqshrun2_n_insn_be, aarch64_sqshrun2_n) (aarch64_sqrshrun2_n_insn_le) (aarch64_sqrshrun2_n_insn_be, aarch64_sqrshrun2_n): Match an us_truncate of an smax instead of a truncate of an smin of an smax. gcc/testsuite/ChangeLog: * gcc.target/aarch64/vect-sat-trunc-3.c: New test. Signed-off-by: Dominic P --- gcc/config/aarch64/aarch64-simd.md | 211 +++++++----------- gcc/config/aarch64/predicates.md | 15 -- .../gcc.target/aarch64/vect-sat-trunc-3.c | 41 ++++ 3 files changed, 125 insertions(+), 142 deletions(-) create mode 100644 gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-3.c diff --git a/gcc/config/aarch64/aarch64-simd.md b/gcc/config/aarch64/aarch64-simd.md index fe6cb4250f6a..9d1a929576c7 100644 --- a/gcc/config/aarch64/aarch64-simd.md +++ b/gcc/config/aarch64/aarch64-simd.md @@ -6282,12 +6282,10 @@ (define_insn "aarch64_sqmovun" [(set (match_operand: 0 "register_operand" "=w") - (truncate: - (smin:SD_HSDI - (smax:SD_HSDI - (match_operand:SD_HSDI 1 "register_operand" "w") - (const_int 0)) - (const_int ))))] + (us_truncate: + (smax:SD_HSDI + (match_operand:SD_HSDI 1 "register_operand" "w") + (const_int 0))))] "TARGET_SIMD" "sqxtun\\t%0, %1" [(set_attr "type" "neon_sat_shift_imm_narrow_q")] @@ -6295,11 +6293,9 @@ (define_insn "*aarch64_sqmovun_insn" [(set (match_operand: 0 "register_operand" "=w") - (truncate: - (smin:VQN - (smax:VQN (match_operand:VQN 1 "register_operand" "w") - (match_operand:VQN 2 "aarch64_simd_or_scalar_imm_zero")) - (match_operand:VQN 3 "aarch64_simd_umax_half_mode"))))] + (us_truncate: + (smax:VQN (match_operand:VQN 1 "register_operand" "w") + (match_operand:VQN 2 "aarch64_simd_or_scalar_imm_zero"))))] "TARGET_SIMD" "sqxtun\\t%0, %1" [(set_attr "type" "neon_sat_shift_imm_narrow_q")] @@ -6307,17 +6303,12 @@ (define_expand "aarch64_sqmovun" [(set (match_operand: 0 "register_operand" "=w") - (truncate: - (smin:VQN - (smax:VQN (match_operand:VQN 1 "register_operand" "w") - (match_dup 2)) - (match_dup 3))))] + (us_truncate: + (smax:VQN (match_operand:VQN 1 "register_operand" "w") + (match_dup 2))))] "TARGET_SIMD" { operands[2] = CONST0_RTX (mode); - operands[3] - = aarch64_simd_gen_const_vector_dup (mode, - GET_MODE_MASK (GET_MODE_INNER (mode))); } ) @@ -6325,12 +6316,10 @@ [(set (match_operand: 0 "register_operand" "=w") (vec_concat: (match_operand: 1 "register_operand" "0") - (truncate: - (smin:VQN - (smax:VQN - (match_operand:VQN 2 "register_operand" "w") - (match_operand:VQN 3 "aarch64_simd_or_scalar_imm_zero")) - (match_operand:VQN 4 "aarch64_simd_umax_half_mode")))))] + (us_truncate: + (smax:VQN + (match_operand:VQN 2 "register_operand" "w") + (match_operand:VQN 3 "aarch64_simd_or_scalar_imm_zero")))))] "TARGET_SIMD && !BYTES_BIG_ENDIAN" "sqxtun2\\t%0., %2." [(set_attr "type" "neon_sat_shift_imm_narrow_q")] @@ -6339,12 +6328,10 @@ (define_insn "aarch64_sqxtun2_be" [(set (match_operand: 0 "register_operand" "=w") (vec_concat: - (truncate: - (smin:VQN - (smax:VQN - (match_operand:VQN 2 "register_operand" "w") - (match_operand:VQN 3 "aarch64_simd_or_scalar_imm_zero")) - (match_operand:VQN 4 "aarch64_simd_umax_half_mode"))) + (us_truncate: + (smax:VQN + (match_operand:VQN 2 "register_operand" "w") + (match_operand:VQN 3 "aarch64_simd_or_scalar_imm_zero"))) (match_operand: 1 "register_operand" "0")))] "TARGET_SIMD && BYTES_BIG_ENDIAN" "sqxtun2\\t%0., %2." @@ -6358,14 +6345,12 @@ "TARGET_SIMD" { rtx zeros = CONST0_RTX (mode); - rtx half_umax = aarch64_simd_gen_const_vector_dup (mode, - GET_MODE_MASK (GET_MODE_INNER (mode))); if (BYTES_BIG_ENDIAN) emit_insn (gen_aarch64_sqxtun2_be (operands[0], operands[1], - operands[2], zeros, half_umax)); + operands[2], zeros)); else emit_insn (gen_aarch64_sqxtun2_le (operands[0], operands[1], - operands[2], zeros, half_umax)); + operands[2], zeros)); DONE; } ) @@ -7626,14 +7611,12 @@ (define_insn "*aarch64_sqshrun_n_insn" [(set (match_operand: 0 "register_operand" "=w") - (truncate: - (smin:VQN - (smax:VQN - (ashiftrt:VQN - (match_operand:VQN 1 "register_operand" "w") - (match_operand:VQN 2 "aarch64_simd_shift_imm_vec_")) - (match_operand:VQN 3 "aarch64_simd_imm_zero")) - (match_operand:VQN 4 "aarch64_simd_umax_half_mode"))))] + (us_truncate: + (smax:VQN + (ashiftrt:VQN + (match_operand:VQN 1 "register_operand" "w") + (match_operand:VQN 2 "aarch64_simd_shift_imm_vec_")) + (match_operand:VQN 3 "aarch64_simd_imm_zero"))))] "TARGET_SIMD" "sqshrun\t%0, %1, %2" [(set_attr "type" "neon_shift_imm_narrow_q")] @@ -7669,38 +7652,31 @@ (define_expand "aarch64_sqshrun_n" [(set (match_operand: 0 "register_operand") - (truncate: - (smin:VQN - (smax:VQN - (ashiftrt:VQN - (match_operand:VQN 1 "register_operand") - (match_operand:SI 2 "aarch64_simd_shift_imm_offset_")) - (match_dup 3)) - (match_dup 4))))] + (us_truncate: + (smax:VQN + (ashiftrt:VQN + (match_operand:VQN 1 "register_operand") + (match_operand:SI 2 "aarch64_simd_shift_imm_offset_")) + (match_dup 3))))] "TARGET_SIMD" { operands[2] = aarch64_simd_gen_const_vector_dup (mode, INTVAL (operands[2])); operands[3] = CONST0_RTX (mode); - operands[4] - = aarch64_simd_gen_const_vector_dup (mode, - GET_MODE_MASK (GET_MODE_INNER (mode))); } ) (define_insn "*aarch64_sqrshrun_n_insn" [(set (match_operand: 0 "register_operand" "=w") - (truncate: - (smin: - (smax: - (ashiftrt: - (plus: - (sign_extend: - (match_operand:VQN 1 "register_operand" "w")) - (match_operand: 3 "aarch64_int_rnd_operand")) - (match_operand:VQN 2 "aarch64_simd_shift_imm_vec_")) - (match_operand: 4 "aarch64_simd_imm_zero")) - (match_operand: 5 "aarch64_simd_umax_quarter_mode"))))] + (us_truncate: + (smax: + (ashiftrt: + (plus: + (sign_extend: + (match_operand:VQN 1 "register_operand" "w")) + (match_operand: 3 "aarch64_int_rnd_operand")) + (match_operand:VQN 2 "aarch64_simd_shift_imm_vec_")) + (match_operand: 4 "aarch64_simd_imm_zero"))))] "TARGET_SIMD && aarch64_const_vec_rnd_cst_p (operands[3], operands[2])" "sqrshrun\t%0, %1, %2" @@ -7743,17 +7719,15 @@ (define_expand "aarch64_sqrshrun_n" [(set (match_operand: 0 "register_operand") - (truncate: - (smin: - (smax: - (ashiftrt: - (plus: - (sign_extend: - (match_operand:VQN 1 "register_operand")) - (match_dup 3)) - (match_operand:SI 2 "aarch64_simd_shift_imm_offset_")) - (match_dup 4)) - (match_dup 5))))] + (us_truncate: + (smax: + (ashiftrt: + (plus: + (sign_extend: + (match_operand:VQN 1 "register_operand")) + (match_dup 3)) + (match_operand:SI 2 "aarch64_simd_shift_imm_offset_")) + (match_dup 4))))] "TARGET_SIMD" { int prec = GET_MODE_UNIT_PRECISION (mode); @@ -7762,9 +7736,6 @@ operands[3] = gen_const_vec_duplicate (mode, operands[3]); operands[2] = gen_const_vec_duplicate (mode, operands[2]); operands[4] = CONST0_RTX (mode); - operands[5] - = gen_int_mode (GET_MODE_MASK (GET_MODE_INNER (mode)), DImode); - operands[5] = gen_const_vec_duplicate (mode, operands[5]); } ) @@ -7894,14 +7865,12 @@ [(set (match_operand: 0 "register_operand" "=w") (vec_concat: (match_operand: 1 "register_operand" "0") - (truncate: - (smin:VQN - (smax:VQN - (ashiftrt:VQN - (match_operand:VQN 2 "register_operand" "w") - (match_operand:VQN 3 "aarch64_simd_shift_imm_vec_")) - (match_operand:VQN 4 "aarch64_simd_imm_zero")) - (match_operand:VQN 5 "aarch64_simd_umax_half_mode")))))] + (us_truncate: + (smax:VQN + (ashiftrt:VQN + (match_operand:VQN 2 "register_operand" "w") + (match_operand:VQN 3 "aarch64_simd_shift_imm_vec_")) + (match_operand:VQN 4 "aarch64_simd_imm_zero")))))] "TARGET_SIMD && !BYTES_BIG_ENDIAN" "sqshrun2\t%0., %2., %3" [(set_attr "type" "neon_shift_imm_narrow_q")] @@ -7910,14 +7879,12 @@ (define_insn "aarch64_sqshrun2_n_insn_be" [(set (match_operand: 0 "register_operand" "=w") (vec_concat: - (truncate: - (smin:VQN - (smax:VQN - (ashiftrt:VQN - (match_operand:VQN 2 "register_operand" "w") - (match_operand:VQN 3 "aarch64_simd_shift_imm_vec_")) - (match_operand:VQN 4 "aarch64_simd_imm_zero")) - (match_operand:VQN 5 "aarch64_simd_umax_half_mode"))) + (us_truncate: + (smax:VQN + (ashiftrt:VQN + (match_operand:VQN 2 "register_operand" "w") + (match_operand:VQN 3 "aarch64_simd_shift_imm_vec_")) + (match_operand:VQN 4 "aarch64_simd_imm_zero"))) (match_operand: 1 "register_operand" "0")))] "TARGET_SIMD && BYTES_BIG_ENDIAN" "sqshrun2\t%0., %2., %3" @@ -7934,17 +7901,14 @@ operands[3] = aarch64_simd_gen_const_vector_dup (mode, INTVAL (operands[3])); rtx zeros = CONST0_RTX (mode); - rtx half_umax - = aarch64_simd_gen_const_vector_dup (mode, - GET_MODE_MASK (GET_MODE_INNER (mode))); if (BYTES_BIG_ENDIAN) emit_insn (gen_aarch64_sqshrun2_n_insn_be (operands[0], operands[1], operands[2], operands[3], - zeros, half_umax)); + zeros)); else emit_insn (gen_aarch64_sqshrun2_n_insn_le (operands[0], operands[1], operands[2], operands[3], - zeros, half_umax)); + zeros)); DONE; } ) @@ -7953,17 +7917,15 @@ [(set (match_operand: 0 "register_operand" "=w") (vec_concat: (match_operand: 1 "register_operand" "0") - (truncate: - (smin: - (smax: - (ashiftrt: - (plus: - (sign_extend: - (match_operand:VQN 2 "register_operand" "w")) - (match_operand: 4 "aarch64_int_rnd_operand")) - (match_operand:VQN 3 "aarch64_simd_shift_imm_vec_")) - (match_operand: 5 "aarch64_simd_imm_zero")) - (match_operand: 6 "aarch64_simd_umax_quarter_mode")))))] + (us_truncate: + (smax: + (ashiftrt: + (plus: + (sign_extend: + (match_operand:VQN 2 "register_operand" "w")) + (match_operand: 4 "aarch64_int_rnd_operand")) + (match_operand:VQN 3 "aarch64_simd_shift_imm_vec_")) + (match_operand: 5 "aarch64_simd_imm_zero")))))] "TARGET_SIMD && !BYTES_BIG_ENDIAN && aarch64_const_vec_rnd_cst_p (operands[4], operands[3])" "sqrshrun2\t%0., %2., %3" @@ -7973,17 +7935,15 @@ (define_insn "aarch64_sqrshrun2_n_insn_be" [(set (match_operand: 0 "register_operand" "=w") (vec_concat: - (truncate: - (smin: - (smax: - (ashiftrt: - (plus: - (sign_extend: - (match_operand:VQN 2 "register_operand" "w")) - (match_operand: 4 "aarch64_int_rnd_operand")) - (match_operand:VQN 3 "aarch64_simd_shift_imm_vec_")) - (match_operand: 5 "aarch64_simd_imm_zero")) - (match_operand: 6 "aarch64_simd_umax_quarter_mode"))) + (us_truncate: + (smax: + (ashiftrt: + (plus: + (sign_extend: + (match_operand:VQN 2 "register_operand" "w")) + (match_operand: 4 "aarch64_int_rnd_operand")) + (match_operand:VQN 3 "aarch64_simd_shift_imm_vec_")) + (match_operand: 5 "aarch64_simd_imm_zero"))) (match_operand: 1 "register_operand" "0")))] "TARGET_SIMD && BYTES_BIG_ENDIAN && aarch64_const_vec_rnd_cst_p (operands[4], operands[3])" @@ -8003,18 +7963,15 @@ rtx rnd = immed_wide_int_const (rnd_wi, GET_MODE_INNER (mode)); rnd = gen_const_vec_duplicate (mode, rnd); rtx zero = CONST0_RTX (mode); - rtx half_umax - = aarch64_simd_gen_const_vector_dup (mode, - GET_MODE_MASK (GET_MODE_INNER (mode))); operands[3] = gen_const_vec_duplicate (mode, operands[3]); if (BYTES_BIG_ENDIAN) emit_insn (gen_aarch64_sqrshrun2_n_insn_be (operands[0], operands[1], operands[2], operands[3], rnd, - zero, half_umax)); + zero)); else emit_insn (gen_aarch64_sqrshrun2_n_insn_le (operands[0], operands[1], operands[2], operands[3], rnd, - zero, half_umax)); + zero)); DONE; } ) diff --git a/gcc/config/aarch64/predicates.md b/gcc/config/aarch64/predicates.md index 6f4d1dac6bf9..523974240f03 100644 --- a/gcc/config/aarch64/predicates.md +++ b/gcc/config/aarch64/predicates.md @@ -744,21 +744,6 @@ GET_MODE_UNIT_BITSIZE (GET_MODE (op)) / 2, GET_MODE_UNIT_BITSIZE (GET_MODE (op)) / 2)"))) -(define_predicate "aarch64_simd_umax_half_mode" - (and (match_code "const_vector") - (match_test "aarch64_const_vec_all_same_in_range_p (op, - (HOST_WIDE_INT_1U - << (GET_MODE_UNIT_BITSIZE (mode) / 2)) - 1, - (HOST_WIDE_INT_1U - << (GET_MODE_UNIT_BITSIZE (mode) / 2)) - 1)"))) - -(define_predicate "aarch64_simd_umax_quarter_mode" - (and (match_code "const_vector") - (match_test "aarch64_const_vec_all_same_in_range_p (op, - (HOST_WIDE_INT_1U - << (GET_MODE_UNIT_BITSIZE (mode) / 4)) - 1, - (HOST_WIDE_INT_1U - << (GET_MODE_UNIT_BITSIZE (mode) / 4)) - 1)"))) (define_predicate "aarch64_simd_shift_imm_vec_qi" (and (match_code "const_vector") (match_test "aarch64_const_vec_all_same_in_range_p (op, 1, 8)"))) diff --git a/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-3.c b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-3.c new file mode 100644 index 000000000000..5efe52e80bbb --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/vect-sat-trunc-3.c @@ -0,0 +1,41 @@ +/* { dg-do compile } */ +/* { dg-options "-O3 -march=armv8-a" } */ +/* { dg-additional-options "-fno-schedule-insns -fno-schedule-insns2" } */ +/* { dg-final { check-function-bodies "**" "" } } */ + +typedef __UINT16_TYPE__ u16; + +static inline u16 +clip_u16 (int x) +{ + return (unsigned int) x > 65535u ? ((-x) >> 31) : x; +} + +/* +** clu: +** ... +** ldp q[0-9]+, q[0-9]+, \[x[0-9]+\] +** orr v[0-9]+\.4s, #1 +** sqxtun v[0-9]+\.4h, v[0-9]+\.4s +** orr v[0-9]+\.4s, #1 +** sqxtun v[0-9]+\.4h, v[0-9]+\.4s +** stp d[0-9]+, d[0-9]+, \[x[0-9]+\] +** ret +*/ +void +clu (u16 *__restrict r, const int *__restrict x) +{ + for (int i = 0; i < 8; i++) + r[i] = clip_u16 (x[i] | 1); +} + +/* The same in a variable-length loop. */ +void +clu_n (u16 *__restrict r, const int *__restrict x, int n) +{ + for (int i = 0; i < n; i++) + r[i] = clip_u16 (x[i] | 1); +} + +/* { dg-final { scan-assembler-times {\tsqxtun\tv[0-9]+\.4h, v[0-9]+\.4s} 3 } } */ +/* { dg-final { scan-assembler-not {\tuqxtn\tv[0-9]+\.4h, v[0-9]+\.4s} } } */ From 238a3c1042262cb5f4107fb3a90c679e00d9d0c8 Mon Sep 17 00:00:00 2001 From: Dominic P Date: Thu, 10 Sep 2026 01:30:24 +0100 Subject: [PATCH 439/584] aarch64: Match a rounding narrowing shift written at the source width RSHRN is only reachable from the ACLE intrinsics. The nearest recognisers, *aarch64_rshrn_n_insn and its high-half forms, do the rounding add and the shift in over an extended operand -- the shape the intrinsic expanders build -- so C that writes (x + (1 << (n - 1))) >> n and narrows the result, which does both at the source width, gets movi + add + shrn/shrn2 instead. Widening those recognisers would need V16HI, V8SI and V4DI arithmetic, which the vectoriser does not produce, so add source-width companions. With W the source element width and w = W/2 the destination width, both forms keep bits [n+w-1:n] of x + 2^(n-1) and differ only above bit W-1, so they agree for n <= W/2; aarch64_int_rnd_operand and aarch64_simd_shift_imm_vec_ each cap n there. The saturating members of the family (SQRSHRN, SQRSHRUN, UQRSHRN) read the full shifted value and are deliberately left alone: vqrshrun_n_s16 (32767, 6) is 255 where the source-width C form is 0. The intrinsics gain too. A shift equal to the destination element width expands to RADDHN against a shareable zero, and combine now folds that zero away into a single RSHRN. advsimd-intrinsics/shrn-1.c therefore loses its movi and drops from six instructions to five, and shrn-2.c, shrn-3.c and shrn-4.c drop from four to three; their raddhn expectations are updated here to the shorter rshrn sequence. Combine does not run at -O0, so the three that lacked it gain the -O0 skip shrn-1.c carries. x265 dct.cpp's partialButterfly output stage, reduced to for (int i = 0; i < 64; i++) d[i] = (int16_t) ((s[i] + 128) >> 8); goes from 46 to 38 instructions at -O3 -mcpu=cortex-a76; ffmpeg's h264 chroma stage, (uint8_t) ((s[i] + 32) >> 6) over uint16_t, from 88 to 85. Cross-tested aarch64-linux-gnu under qemu-aarch64 (aarch64.exp, simd.exp, advsimd-intrinsics.exp, vect.exp, like for like against the same tree unpatched) and bootstrapped on x86_64-pc-linux-gnu. Assisted-by: Claude Opus 5 (Anthropic) gcc/ChangeLog: * config/aarch64/aarch64-simd.md (*aarch64_rshrn_n_insn): New pattern. (*aarch64_rshrn2_n_insn_le): Likewise. (*aarch64_rshrn2_n_insn_be): Likewise. gcc/testsuite/ChangeLog: * gcc.target/aarch64/advsimd-intrinsics/shrn-1.c: Expect rshrn and rshrn2 in place of raddhn and raddhn2, and no movi. * gcc.target/aarch64/advsimd-intrinsics/shrn-2.c: Expect rshrn and rshrn2 in place of raddhn and raddhn2. Skip at -O0. * gcc.target/aarch64/advsimd-intrinsics/shrn-3.c: Likewise. * gcc.target/aarch64/advsimd-intrinsics/shrn-4.c: Likewise. * gcc.target/aarch64/simd_rshrn_1.c: New test. * gcc.target/aarch64/simd_rshrn_2.c: New test. Signed-off-by: Dominic P --- gcc/config/aarch64/aarch64-simd.md | 46 ++++++++ .../aarch64/advsimd-intrinsics/shrn-1.c | 6 +- .../aarch64/advsimd-intrinsics/shrn-2.c | 5 +- .../aarch64/advsimd-intrinsics/shrn-3.c | 5 +- .../aarch64/advsimd-intrinsics/shrn-4.c | 5 +- .../gcc.target/aarch64/simd_rshrn_1.c | 106 ++++++++++++++++++ .../gcc.target/aarch64/simd_rshrn_2.c | 64 +++++++++++ 7 files changed, 228 insertions(+), 9 deletions(-) create mode 100644 gcc/testsuite/gcc.target/aarch64/simd_rshrn_1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/simd_rshrn_2.c diff --git a/gcc/config/aarch64/aarch64-simd.md b/gcc/config/aarch64/aarch64-simd.md index 9d1a929576c7..517b74d8f1a8 100644 --- a/gcc/config/aarch64/aarch64-simd.md +++ b/gcc/config/aarch64/aarch64-simd.md @@ -7609,6 +7609,20 @@ } ) +(define_insn "*aarch64_rshrn_n_insn" + [(set (match_operand: 0 "register_operand" "=w") + (truncate: + (SHIFTRT:VQN + (plus:VQN + (match_operand:VQN 1 "register_operand" "w") + (match_operand:VQN 3 "aarch64_int_rnd_operand")) + (match_operand:VQN 2 "aarch64_simd_shift_imm_vec_"))))] + "TARGET_SIMD + && aarch64_const_vec_rnd_cst_p (operands[3], operands[2])" + "rshrn\t%0, %1, %2" + [(set_attr "type" "neon_shift_imm_narrow_q")] +) + (define_insn "*aarch64_sqshrun_n_insn" [(set (match_operand: 0 "register_operand" "=w") (us_truncate: @@ -7822,6 +7836,38 @@ [(set_attr "type" "neon_shift_imm_narrow_q")] ) +(define_insn "*aarch64_rshrn2_n_insn_le" + [(set (match_operand: 0 "register_operand" "=w") + (vec_concat: + (match_operand: 1 "register_operand" "0") + (truncate: + (SHIFTRT:VQN + (plus:VQN + (match_operand:VQN 2 "register_operand" "w") + (match_operand:VQN 4 "aarch64_int_rnd_operand")) + (match_operand:VQN 3 "aarch64_simd_shift_imm_vec_")))))] + "TARGET_SIMD && !BYTES_BIG_ENDIAN + && aarch64_const_vec_rnd_cst_p (operands[4], operands[3])" + "rshrn2\t%0., %2., %3" + [(set_attr "type" "neon_shift_imm_narrow_q")] +) + +(define_insn "*aarch64_rshrn2_n_insn_be" + [(set (match_operand: 0 "register_operand" "=w") + (vec_concat: + (truncate: + (SHIFTRT:VQN + (plus:VQN + (match_operand:VQN 2 "register_operand" "w") + (match_operand:VQN 4 "aarch64_int_rnd_operand")) + (match_operand:VQN 3 "aarch64_simd_shift_imm_vec_"))) + (match_operand: 1 "register_operand" "0")))] + "TARGET_SIMD && BYTES_BIG_ENDIAN + && aarch64_const_vec_rnd_cst_p (operands[4], operands[3])" + "rshrn2\t%0., %2., %3" + [(set_attr "type" "neon_shift_imm_narrow_q")] +) + (define_expand "aarch64_rshrn2_n" [(match_operand: 0 "register_operand") (match_operand: 1 "register_operand") diff --git a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/shrn-1.c b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/shrn-1.c index 4bc3aa9563ee..a66b0e098289 100644 --- a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/shrn-1.c +++ b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/shrn-1.c @@ -10,6 +10,6 @@ uint8x16_t foo (uint32x4_t a, uint32x4_t b) return vrshrn_high_n_u16 (vrshrn_n_u16 (b1, 8), b1, 8); } -/* { dg-final { scan-assembler-times {\tmovi\t} 1 } } */ -/* { dg-final { scan-assembler-times {\traddhn\t} 2 } } */ -/* { dg-final { scan-assembler-times {\traddhn2\t} 2 } } */ +/* { dg-final { scan-assembler-not {\tmovi\t} } } */ +/* { dg-final { scan-assembler-times {\trshrn\t} 2 } } */ +/* { dg-final { scan-assembler-times {\trshrn2\t} 2 } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/shrn-2.c b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/shrn-2.c index 09d913e85524..6a3992832d89 100644 --- a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/shrn-2.c +++ b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/shrn-2.c @@ -1,4 +1,5 @@ /* { dg-do compile { target { aarch64*-*-* } } } */ +/* { dg-skip-if "" { *-*-* } { "-O0" } { "" } } */ #include @@ -7,5 +8,5 @@ uint32x4_t foo (uint64x2_t a, uint64x2_t b) return vrshrn_high_n_u64 (vrshrn_n_u64 (a, 32), b, 32); } -/* { dg-final { scan-assembler-times {\traddhn\t} 1 } } */ -/* { dg-final { scan-assembler-times {\traddhn2\t} 1 } } */ +/* { dg-final { scan-assembler-times {\trshrn\t} 1 } } */ +/* { dg-final { scan-assembler-times {\trshrn2\t} 1 } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/shrn-3.c b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/shrn-3.c index bdccbb3410f0..46c5f807e4f0 100644 --- a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/shrn-3.c +++ b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/shrn-3.c @@ -1,4 +1,5 @@ /* { dg-do compile { target { aarch64*-*-* } } } */ +/* { dg-skip-if "" { *-*-* } { "-O0" } { "" } } */ #include @@ -7,5 +8,5 @@ uint16x8_t foo (uint32x4_t a, uint32x4_t b) return vrshrn_high_n_u32 (vrshrn_n_u32 (a, 16), b, 16); } -/* { dg-final { scan-assembler-times {\traddhn\t} 1 } } */ -/* { dg-final { scan-assembler-times {\traddhn2\t} 1 } } */ +/* { dg-final { scan-assembler-times {\trshrn\t} 1 } } */ +/* { dg-final { scan-assembler-times {\trshrn2\t} 1 } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/shrn-4.c b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/shrn-4.c index 4b23eddb8589..10f31d045b62 100644 --- a/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/shrn-4.c +++ b/gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/shrn-4.c @@ -1,4 +1,5 @@ /* { dg-do compile { target { aarch64*-*-* } } } */ +/* { dg-skip-if "" { *-*-* } { "-O0" } { "" } } */ #include @@ -7,5 +8,5 @@ uint8x16_t foo (uint16x8_t a, uint16x8_t b) return vrshrn_high_n_u16 (vrshrn_n_u16 (a, 8), b, 8); } -/* { dg-final { scan-assembler-times {\traddhn\t} 1 } } */ -/* { dg-final { scan-assembler-times {\traddhn2\t} 1 } } */ +/* { dg-final { scan-assembler-times {\trshrn\t} 1 } } */ +/* { dg-final { scan-assembler-times {\trshrn2\t} 1 } } */ diff --git a/gcc/testsuite/gcc.target/aarch64/simd_rshrn_1.c b/gcc/testsuite/gcc.target/aarch64/simd_rshrn_1.c new file mode 100644 index 000000000000..72a6af622ec0 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/simd_rshrn_1.c @@ -0,0 +1,106 @@ +/* { dg-do compile } */ +/* { dg-options "-O3 -march=armv8-a" } */ +/* { dg-final { check-function-bodies "**" "" } } */ + +#include + +typedef int16_t v8hi __attribute__((vector_size (16))); +typedef int8_t v8qi __attribute__((vector_size (8))); +typedef uint16_t v8uhi __attribute__((vector_size (16))); +typedef uint8_t v8uqi __attribute__((vector_size (8))); +typedef int32_t v4si __attribute__((vector_size (16))); +typedef int16_t v4hi __attribute__((vector_size (8))); +typedef uint32_t v4usi __attribute__((vector_size (16))); +typedef uint16_t v4uhi __attribute__((vector_size (8))); + +/* +** s16_s8: +** rshrn v0\.8b, v0\.8h, 6 +** ret +*/ +v8qi +s16_s8 (v8hi x) +{ + return __builtin_convertvector ((x + 32) >> 6, v8qi); +} + +/* +** u16_u8: +** rshrn v0\.8b, v0\.8h, 5 +** ret +*/ +v8uqi +u16_u8 (v8uhi x) +{ + return __builtin_convertvector ((x + 16) >> 5, v8uqi); +} + +/* +** s32_s16: +** rshrn v0\.4h, v0\.4s, 8 +** ret +*/ +v4hi +s32_s16 (v4si x) +{ + return __builtin_convertvector ((x + 128) >> 8, v4hi); +} + +/* +** u32_u16: +** rshrn v0\.4h, v0\.4s, 12 +** ret +*/ +v4uhi +u32_u16 (v4usi x) +{ + return __builtin_convertvector ((x + 2048) >> 12, v4uhi); +} + +#define ROUND_NARROW(NAME, TO, FROM, N, COUNT) \ + void \ + NAME (TO *__restrict d, const FROM *__restrict s) \ + { \ + for (int i = 0; i < COUNT; i++) \ + d[i] = (TO) ((s[i] + (1 << (N - 1))) >> N); \ + } + +/* +** loop_s16_s8: +** ldp q31, q30, \[x1\] +** rshrn v31\.8b, v31\.8h, 6 +** rshrn2 v31\.16b, v30\.8h, 6 +** str q31, \[x0\] +** ret +*/ +ROUND_NARROW (loop_s16_s8, int8_t, int16_t, 6, 16) + +/* +** loop_u16_u8: +** ldp q31, q30, \[x1\] +** rshrn v31\.8b, v31\.8h, 5 +** rshrn2 v31\.16b, v30\.8h, 5 +** str q31, \[x0\] +** ret +*/ +ROUND_NARROW (loop_u16_u8, uint8_t, uint16_t, 5, 16) + +/* +** loop_s32_s16: +** ldp q31, q30, \[x1\] +** rshrn v31\.4h, v31\.4s, 8 +** rshrn2 v31\.8h, v30\.4s, 8 +** str q31, \[x0\] +** ret +*/ +ROUND_NARROW (loop_s32_s16, int16_t, int32_t, 8, 8) + +/* +** loop_u32_u16: +** ldp q31, q30, \[x1\] +** rshrn v31\.4h, v31\.4s, 12 +** rshrn2 v31\.8h, v30\.4s, 12 +** str q31, \[x0\] +** ret +*/ +ROUND_NARROW (loop_u32_u16, uint16_t, uint32_t, 12, 8) diff --git a/gcc/testsuite/gcc.target/aarch64/simd_rshrn_2.c b/gcc/testsuite/gcc.target/aarch64/simd_rshrn_2.c new file mode 100644 index 000000000000..d056f753ddb9 --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/simd_rshrn_2.c @@ -0,0 +1,64 @@ +/* { dg-do run } */ +/* { dg-options "-O3 -march=armv8-a" } */ + +#include + +#define NELEMS 67 + +#define ROUND_NARROW(NAME, TO, FROM, N, DIV) \ + __attribute__((noipa)) static void \ + NAME (TO *__restrict d, const FROM *__restrict s, int n) \ + { \ + for (int i = 0; i < n; i++) \ + d[i] = (TO) ((s[i] + (1 << (N - 1))) >> N); \ + } \ + __attribute__((noipa, optimize ("O0"))) static void \ + NAME##_ref (TO *__restrict d, const FROM *__restrict s, int n) \ + { \ + for (int i = 0; i < n; i++) \ + d[i] = (TO) ((s[i] + (1 << (N - 1))) >> N); \ + } \ + static void \ + NAME##_check (void) \ + { \ + FROM s[NELEMS]; \ + TO d[NELEMS], r[NELEMS]; \ + for (int i = 0; i < NELEMS; i++) \ + s[i] = (FROM) rnd () / (DIV); \ + NAME (d, s, NELEMS); \ + NAME##_ref (r, s, NELEMS); \ + for (int i = 0; i < NELEMS; i++) \ + if (d[i] != r[i]) \ + __builtin_abort (); \ + } + +static uint64_t seed = 0x123456789abcdefULL; + +static uint64_t +rnd (void) +{ + seed = seed * 6364136223846793005ULL + 1442695040888963407ULL; + return seed >> 11; +} + +/* The signed 32-bit inputs are halved: signed overflow in the reference + addition would be undefined. The unsigned inputs are not halved, so the + wrapping add is covered. */ + +ROUND_NARROW (s16_s8, int8_t, int16_t, 6, 1) +ROUND_NARROW (u16_u8, uint8_t, uint16_t, 5, 1) +ROUND_NARROW (s32_s16, int16_t, int32_t, 8, 2) +ROUND_NARROW (u32_u16, uint16_t, uint32_t, 12, 1) + +int +main (void) +{ + for (int rep = 0; rep < 64; rep++) + { + s16_s8_check (); + u16_u8_check (); + s32_s16_check (); + u32_u16_check (); + } + return 0; +} From 1dc037ec42169fe28715dc3fa8181506046dab1c Mon Sep 17 00:00:00 2001 From: Dominic P Date: Thu, 10 Sep 2026 01:30:25 +0100 Subject: [PATCH 440/584] aarch64: Make the rounding shift-right pair reachable from generic code aarch64_rshr_n_insn and aarch64_rsra_n_insn model the rounding add and the shift in , as SRSHR/URSHR and SRSRA/URSRA do, but take the shift amount as a vector in . Only their own expanders build that, so nothing but the RTL they emit themselves can ever match them: they are reachable from the ACLE and from nothing else. The same operation written in C reaches combine with the shift amount in the mode of the shift, so it fails to match and comes out as movi + uaddw + shrn. Take the shift amount in in both patterns and build it there in both expanders. The accepted range is unchanged; it comes from aarch64_simd_shift_imm__, which is keyed on . The two have to move together, because combine turns an add of a rounding shift into SRSRA and folds SRSRA against a zero accumulator back into SRSHR, so converting one alone would cost that fusion. The widened shape is the only correct one: the source-width spelling (x + (1 << (n - 1))) >> n is a different operation and is deliberately not matched, since under qemu vrshrq_n_s32 (INT_MAX, 8) is 8388608 where the C expression is -8388608. Only the 64-bit-result forms become reachable from C; srshr v.16b, v.8h and v.4s stay intrinsic-only because their modes are V16HI, V8SI and V4DI, which the vectoriser does not use. The RSHRN, RSHRN2 and SQRSHRUN recognisers keep the same construction and stay ACLE-only for the same reason; the preceding commit gives the RSHRN pair source-width companions instead, which the saturating forms cannot have. For an eight-byte uint8_t block at -O2, movi + ldr + uaddw + shrn + str becomes ldr + urshr + str. Cross-tested aarch64-linux-gnu under qemu-aarch64 (aarch64.exp, simd.exp, advsimd-intrinsics.exp, vect.exp, like for like against the same tree unpatched) and bootstrapped on x86_64-pc-linux-gnu. Assisted-by: Claude Opus 5 (Anthropic) gcc/ChangeLog: * config/aarch64/aarch64-simd.md (aarch64_rsra_n_insn): Take the shift amount in mode. (aarch64_rsra_n): Build the shift amount vector in that mode. (aarch64_rshr_n_insn): Take the shift amount in mode. (aarch64_rshr_n): Build the shift amount vector in that mode. gcc/testsuite/ChangeLog: * gcc.target/aarch64/simd_srshr_1.c: New test. * gcc.target/aarch64/simd_srshr_2.c: New test. Signed-off-by: Dominic P --- gcc/config/aarch64/aarch64-simd.md | 10 ++- .../gcc.target/aarch64/simd_srshr_1.c | 90 +++++++++++++++++++ .../gcc.target/aarch64/simd_srshr_2.c | 62 +++++++++++++ 3 files changed, 158 insertions(+), 4 deletions(-) create mode 100644 gcc/testsuite/gcc.target/aarch64/simd_srshr_1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/simd_srshr_2.c diff --git a/gcc/config/aarch64/aarch64-simd.md b/gcc/config/aarch64/aarch64-simd.md index 517b74d8f1a8..98c2da034c55 100644 --- a/gcc/config/aarch64/aarch64-simd.md +++ b/gcc/config/aarch64/aarch64-simd.md @@ -1650,7 +1650,8 @@ (: (match_operand:VSDQ_I_DI 2 "register_operand" "w")) (match_operand: 4 "aarch64_int_rnd_operand")) - (match_operand:VSDQ_I_DI 3 "aarch64_simd_shift_imm__"))) + (match_operand: 3 + "aarch64_simd_shift_imm__"))) (match_operand:VSDQ_I_DI 1 "register_operand" "0")))] "TARGET_SIMD && aarch64_const_vec_rnd_cst_p (operands[4], operands[3])" @@ -1689,7 +1690,7 @@ rtx rnd = immed_wide_int_const (rnd_wi, GET_MODE_INNER (mode)); if (VECTOR_MODE_P (mode)) { - shft = gen_const_vec_duplicate (mode, shft); + shft = gen_const_vec_duplicate (mode, shft); rnd = gen_const_vec_duplicate (mode, rnd); } @@ -7418,7 +7419,8 @@ (: (match_operand:VSDQ_I_DI 1 "register_operand" "w")) (match_operand: 3 "aarch64_int_rnd_operand")) - (match_operand:VSDQ_I_DI 2 "aarch64_simd_shift_imm__"))))] + (match_operand: 2 + "aarch64_simd_shift_imm__"))))] "TARGET_SIMD && aarch64_const_vec_rnd_cst_p (operands[3], operands[2])" "rshr\t%0, %1, %2" @@ -7441,7 +7443,7 @@ rtx rnd = immed_wide_int_const (rnd_wi, GET_MODE_INNER (mode)); if (VECTOR_MODE_P (mode)) { - shft = gen_const_vec_duplicate (mode, shft); + shft = gen_const_vec_duplicate (mode, shft); rnd = gen_const_vec_duplicate (mode, rnd); } diff --git a/gcc/testsuite/gcc.target/aarch64/simd_srshr_1.c b/gcc/testsuite/gcc.target/aarch64/simd_srshr_1.c new file mode 100644 index 000000000000..aec88349ccde --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/simd_srshr_1.c @@ -0,0 +1,90 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=armv8-a" } */ +/* { dg-final { check-function-bodies "**" "" } } */ + +#include + +typedef int8_t v8qi __attribute__((vector_size (8))); +typedef int16_t v8hi __attribute__((vector_size (16))); +typedef uint8_t v8uqi __attribute__((vector_size (8))); +typedef uint16_t v8uhi __attribute__((vector_size (16))); +typedef int16_t v4hi __attribute__((vector_size (8))); +typedef int32_t v4si __attribute__((vector_size (16))); +typedef uint16_t v4uhi __attribute__((vector_size (8))); +typedef uint32_t v4usi __attribute__((vector_size (16))); + +/* +** s8: +** srshr v0\.8b, v0\.8b, 3 +** ret +*/ +v8qi +s8 (v8qi x) +{ + v8hi w = __builtin_convertvector (x, v8hi); + return __builtin_convertvector ((w + 4) >> 3, v8qi); +} + +/* +** u8: +** urshr v0\.8b, v0\.8b, 3 +** ret +*/ +v8uqi +u8 (v8uqi x) +{ + v8uhi w = __builtin_convertvector (x, v8uhi); + return __builtin_convertvector ((w + 4) >> 3, v8uqi); +} + +/* +** s16: +** srshr v0\.4h, v0\.4h, 6 +** ret +*/ +v4hi +s16 (v4hi x) +{ + v4si w = __builtin_convertvector (x, v4si); + return __builtin_convertvector ((w + 32) >> 6, v4hi); +} + +/* +** u16: +** urshr v0\.4h, v0\.4h, 6 +** ret +*/ +v4uhi +u16 (v4uhi x) +{ + v4usi w = __builtin_convertvector (x, v4usi); + return __builtin_convertvector ((w + 32) >> 6, v4uhi); +} + +/* +** loop_s8: +** ldr d31, \[x1\] +** srshr v31\.8b, v31\.8b, 3 +** str d31, \[x0\] +** ret +*/ +void +loop_s8 (int8_t *__restrict d, const int8_t *__restrict s) +{ + for (int i = 0; i < 8; i++) + d[i] = (int8_t) ((s[i] + 4) >> 3); +} + +/* +** loop_u8: +** ldr d31, \[x1\] +** urshr v31\.8b, v31\.8b, 3 +** str d31, \[x0\] +** ret +*/ +void +loop_u8 (uint8_t *__restrict d, const uint8_t *__restrict s) +{ + for (int i = 0; i < 8; i++) + d[i] = (uint8_t) ((s[i] + 4) >> 3); +} diff --git a/gcc/testsuite/gcc.target/aarch64/simd_srshr_2.c b/gcc/testsuite/gcc.target/aarch64/simd_srshr_2.c new file mode 100644 index 000000000000..51129fdd165c --- /dev/null +++ b/gcc/testsuite/gcc.target/aarch64/simd_srshr_2.c @@ -0,0 +1,62 @@ +/* { dg-do run } */ +/* { dg-options "-O2 -march=armv8-a" } */ + +#include + +typedef int8_t v8qi __attribute__((vector_size (8))); +typedef int16_t v8hi __attribute__((vector_size (16))); +typedef uint8_t v8uqi __attribute__((vector_size (8))); +typedef uint16_t v8uhi __attribute__((vector_size (16))); +typedef int16_t v4hi __attribute__((vector_size (8))); +typedef int32_t v4si __attribute__((vector_size (16))); +typedef uint16_t v4uhi __attribute__((vector_size (8))); +typedef uint32_t v4usi __attribute__((vector_size (16))); + +#define ROUND(NAME, NARROW, WIDE, ELT, WELT, LANES, N) \ + __attribute__((noipa)) static NARROW \ + NAME (NARROW x) \ + { \ + WIDE w = __builtin_convertvector (x, WIDE); \ + return __builtin_convertvector ((w + (1 << (N - 1))) >> N, NARROW); \ + } \ + __attribute__((noipa)) static void \ + NAME##_check (void) \ + { \ + NARROW x, r; \ + for (int rep = 0; rep < 4096; rep++) \ + { \ + for (int i = 0; i < LANES; i++) \ + x[i] = (ELT) rnd (); \ + r = NAME (x); \ + for (int i = 0; i < LANES; i++) \ + { \ + WELT w = (WELT) x[i] + (1 << (N - 1)); \ + if (r[i] != (ELT) (w >> N)) \ + __builtin_abort (); \ + } \ + } \ + } + +static uint64_t seed = 0x123456789abcdefULL; + +static uint64_t +rnd (void) +{ + seed = seed * 6364136223846793005ULL + 1442695040888963407ULL; + return seed >> 11; +} + +ROUND (s8, v8qi, v8hi, int8_t, int16_t, 8, 3) +ROUND (u8, v8uqi, v8uhi, uint8_t, uint16_t, 8, 3) +ROUND (s16, v4hi, v4si, int16_t, int32_t, 4, 6) +ROUND (u16, v4uhi, v4usi, uint16_t, uint32_t, 4, 6) + +int +main (void) +{ + s8_check (); + u8_check (); + s16_check (); + u16_check (); + return 0; +} From 0b585023dbc2b859a1fb4299032faa8d0f157957 Mon Sep 17 00:00:00 2001 From: Jerry DeLisle Date: Fri, 25 Sep 2026 16:26:49 -0700 Subject: [PATCH 441/584] fortran: Fix malformed dg directives. These tests had a closing paren instead of a brace. gcc/testsuite/ChangeLog: * gfortran.dg/pdt_38.f03: Replace paren with brace. * gfortran.dg/pdt_42.f03: Ditto. * gfortran.dg/pdt_43.f03: Ditto. * gfortran.dg/pdt_80.f03: Ditto. * gfortran.dg/pdt_81.f03: Ditto. --- gcc/testsuite/gfortran.dg/pdt_38.f03 | 2 +- gcc/testsuite/gfortran.dg/pdt_42.f03 | 2 +- gcc/testsuite/gfortran.dg/pdt_43.f03 | 2 +- gcc/testsuite/gfortran.dg/pdt_80.f03 | 2 +- gcc/testsuite/gfortran.dg/pdt_81.f03 | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) diff --git a/gcc/testsuite/gfortran.dg/pdt_38.f03 b/gcc/testsuite/gfortran.dg/pdt_38.f03 index 4eb8a411c57c..1079849e2d29 100644 --- a/gcc/testsuite/gfortran.dg/pdt_38.f03 +++ b/gcc/testsuite/gfortran.dg/pdt_38.f03 @@ -1,4 +1,4 @@ -! { dg-do compile ) +! { dg-do compile } ! ! Test the fix for pr84122 ! diff --git a/gcc/testsuite/gfortran.dg/pdt_42.f03 b/gcc/testsuite/gfortran.dg/pdt_42.f03 index 47743d132014..5272a047e8ad 100644 --- a/gcc/testsuite/gfortran.dg/pdt_42.f03 +++ b/gcc/testsuite/gfortran.dg/pdt_42.f03 @@ -1,4 +1,4 @@ -! { dg-do run ) +! { dg-do run } ! ! Test the fix for PR87669 in which SELECT TYPE was not identifying the difference ! between derived types with different type kind parameters, when the selector diff --git a/gcc/testsuite/gfortran.dg/pdt_43.f03 b/gcc/testsuite/gfortran.dg/pdt_43.f03 index c9f25021ab90..8c4b98165b54 100644 --- a/gcc/testsuite/gfortran.dg/pdt_43.f03 +++ b/gcc/testsuite/gfortran.dg/pdt_43.f03 @@ -1,4 +1,4 @@ -! { dg-do run ) +! { dg-do run } ! ! Test the fix for PR89707 in which the procedure pointer component ! with a parameterized KIND expression caused an ICE in resolution. diff --git a/gcc/testsuite/gfortran.dg/pdt_80.f03 b/gcc/testsuite/gfortran.dg/pdt_80.f03 index ecb6861ee53a..2f264b16e8ac 100644 --- a/gcc/testsuite/gfortran.dg/pdt_80.f03 +++ b/gcc/testsuite/gfortran.dg/pdt_80.f03 @@ -1,4 +1,4 @@ -! { dg-do run ) +! { dg-do run } ! { dg-options "-fdump-tree-original" } ! ! Test the fix for PR90218. The errors that occurred are indicated by the comments below. diff --git a/gcc/testsuite/gfortran.dg/pdt_81.f03 b/gcc/testsuite/gfortran.dg/pdt_81.f03 index 0a0c3037f2fa..2c85a25e5081 100644 --- a/gcc/testsuite/gfortran.dg/pdt_81.f03 +++ b/gcc/testsuite/gfortran.dg/pdt_81.f03 @@ -1,4 +1,4 @@ -! { dg-do compile ) +! { dg-do compile } ! ! Test the fix for PR112460, in which mismatched, constant typespec parameters were ! not detected. From e3bcb08678b2fea0dc346f7dad57188737be959e Mon Sep 17 00:00:00 2001 From: Oleg Tolmatcev Date: Wed, 23 Sep 2026 00:57:39 +0200 Subject: [PATCH 442/584] codeview: Open source files in binary mode [PR119940] On Windows, opening a source file in text mode translates CRLF to LF. md5_stream therefore records a checksum that does not match the file contents. Open source files in binary mode before calculating CodeView checksums. gcc/ChangeLog: PR debug/119940 * dwarf2codeview.cc (codeview_start_source_file): Open the source file in binary mode. --- gcc/dwarf2codeview.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/dwarf2codeview.cc b/gcc/dwarf2codeview.cc index 252059d30144..014c35053a5e 100644 --- a/gcc/dwarf2codeview.cc +++ b/gcc/dwarf2codeview.cc @@ -1746,7 +1746,7 @@ codeview_start_source_file (const char *filename) sf->string_offset = string_offset; sf->filename = xstrdup (filename); - f = fopen (filename, "r"); + f = fopen (filename, "rb"); if (!f) internal_error ("could not open %s for reading", filename); From f0d56aeb912dd5e5ec7f81eaab23a3715e0c50a8 Mon Sep 17 00:00:00 2001 From: GCC Administrator Date: Sat, 26 Sep 2026 00:16:42 +0000 Subject: [PATCH 443/584] Daily bump. --- ChangeLog | 5 ++ gcc/ChangeLog | 193 ++++++++++++++++++++++++++++++++++++++++ gcc/DATESTAMP | 2 +- gcc/algol68/ChangeLog | 40 +++++++++ gcc/cobol/ChangeLog | 21 +++++ gcc/cp/ChangeLog | 38 ++++++++ gcc/m2/ChangeLog | 13 +++ gcc/testsuite/ChangeLog | 136 ++++++++++++++++++++++++++++ libgcobol/ChangeLog | 7 ++ libgfortran/ChangeLog | 14 +++ libgomp/ChangeLog | 15 ++++ 11 files changed, 483 insertions(+), 1 deletion(-) diff --git a/ChangeLog b/ChangeLog index a594f7ea5c30..5dc0ed087e98 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,8 @@ +2026-09-25 Dominic P + + * MAINTAINERS.yml: Add myself. + * MAINTAINERS: Regenerate. + 2026-09-19 Michiel Derhaeg * MAINTAINERS: Regenerate. diff --git a/gcc/ChangeLog b/gcc/ChangeLog index e472484a2211..0a143c9ae53b 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,196 @@ +2026-09-26 Oleg Tolmatcev + + PR debug/119940 + * dwarf2codeview.cc (codeview_start_source_file): Open the source file + in binary mode. + +2026-09-25 Dominic P + + * config/aarch64/aarch64-simd.md + (aarch64_rsra_n_insn): Take the shift amount in + mode. + (aarch64_rsra_n): Build the shift amount vector in + that mode. + (aarch64_rshr_n_insn): Take the shift + amount in mode. + (aarch64_rshr_n): Build the shift amount vector in + that mode. + +2026-09-25 Dominic P + + * config/aarch64/aarch64-simd.md + (*aarch64_rshrn_n_insn): New pattern. + (*aarch64_rshrn2_n_insn_le): Likewise. + (*aarch64_rshrn2_n_insn_be): Likewise. + +2026-09-25 Dominic P + + * config/aarch64/predicates.md (aarch64_simd_umax_half_mode) + (aarch64_simd_umax_quarter_mode): Remove. + * config/aarch64/aarch64-simd.md (aarch64_sqmovun) + (*aarch64_sqmovun_insn) + (aarch64_sqxtun2_le, aarch64_sqxtun2_be) + (aarch64_sqxtun2) + (*aarch64_sqshrun_n_insn) + (aarch64_sqshrun_n) + (*aarch64_sqrshrun_n_insn) + (aarch64_sqrshrun_n, aarch64_sqshrun2_n_insn_le) + (aarch64_sqshrun2_n_insn_be, aarch64_sqshrun2_n) + (aarch64_sqrshrun2_n_insn_le) + (aarch64_sqrshrun2_n_insn_be, aarch64_sqrshrun2_n): + Match an us_truncate of an smax instead of a truncate of an smin + of an smax. + +2026-09-25 Michiel Derhaeg + + * config/riscv/arcv-rmx100.md (arcv_rmx100_load_insn): + Update latency. + (arcv_rmx100_fpload_insn): Merge with *_load_insn. + +2026-09-25 Andrea Pinski + + PR middle-end/127602 + * except.h (struct eh_catch_d): Add chain_next and chain_prev + GTY. + +2026-09-25 Andrea Pinski + + PR middle-end/127602 + * except.h (struct eh_region_d): Add chain_next GTY. + +2026-09-25 Aldy Hernandez + + PR tree-optimization/127485 + * range-op-mixed.h (class operator_minus): Add op1_op2_relation. + * range-op.cc (operator_minus::op1_op2_relation): New. + * gimple-range-fold.cc (fur_source::register_outgoing_edges): + Derive relations from any integral export, not just booleans. + +2026-09-25 Vladimir N. Makarov + + PR rtl-optimization/127326 + * lra-constraints.cc (process_alt_operands): Resolve the operand + to memory when it is a winning MEM and the value can be held in a + register. + +2026-09-25 Tobias Burnus + + PR lto/127589 + * lto-streamer-in.cc (lto_input_mode_table): With ACCEL_COMPILER, + check whether found float and int modes are actually enabled/available + at runtime. + +2026-09-25 Roger Sayle + + * simplify-rtx.cc (simplify_binary_operation_1) : + Add transformations for multiplications by one and powers to two. + : Likewise. + +2026-09-25 Wilco Dijkstra + + PR target/112465 + * config/aarch64/aarch64.cc (aarch64_override_options_after_change_1): + Turn off outline atomics with -mcmodel=large. + * doc/invoke.texi (-mcmodel=large): Update description. + +2026-09-25 Oleg Tolmatcev + + PR target/54412 + * except.cc (sjlj_build_landing_pads): Pass ASLK_REDUCE_ALIGN. + * function.cc (assign_stack_local_2): New function, split from + assign_stack_local_1. Honour an explicit alignment beyond + MAX_SUPPORTED_STACK_ALIGNMENT by overallocating the slot and aligning + its address at run time. Optionally return the address before run-time + alignment. + (assign_stack_local_1): Wrap assign_stack_local_2. + (temp_slot): Add base_addr. + (assign_stack_temp_for_type): Distinguish required and preferred + alignment. Record the address before run-time alignment and recalculate + the aligned address when reusing an over-aligned slot. Do not split an + over-aligned BLKmode slot. + (combine_temp_slots): Do not combine over-aligned slots. + (assign_parm_setup_block): Let assign_stack_local align the slot. + * lra-spills.cc (assign_mem_slot): Pass ASLK_REDUCE_ALIGN. + +2026-09-25 Richard Biener + + PR tree-optimization/127588 + * tree-vect-loop-manip.cc (vect_update_ivs_after_vectorizer): + Use an unsigned type to compute the epilog start value. + +2026-09-25 Surya Kumari Jangala + + PR rtl-optimization/106770 + * config/rs6000/rs6000-p8swap.cc (non_permuting_mem_insn): New function. + (handle_non_permuting_mem_insn): New function. + (rs6000_analyze_swaps): Handle swappable instructions only in certain + webs. + (web_requires_special_handling): New instance variable. + (handle_special_swappables): Remove handling of non-permuting load/store + instructions. + +2026-09-25 Andrew Stubbs + + * config/gcn/gcn-valu.md (mul3): Remove erroneous hi*hi step. + (mul3_dup): Likewise. + (mul3_exec): Likewise. + (mul3_dup_exec): Likewise. + +2026-09-25 Richard Biener + + PR tree-optimization/127601 + * tree-vect-stmts.cc (get_load_store_type): Move overrun + flags and final handling to the relevant section, after + determining the step direction and the memory access type. + Only elide overrun with half-vector accesses for the + memory access types supporting that. Do not claim + VMAT_STRIDED_SLP can handle overruns when the step is + negative. + (vectorizable_load): For the last memory access type group + analysis/transform assert what memory access type that covers. + +2026-09-25 Georg-Johann Lay + + * config/avr/avr.opt.urls: Fix moptimize link. + +2026-09-25 Richard Biener + + PR tree-optimization/127600 + * tree-vect-loop.cc (vect_is_simple_iv_evolution): Explicitly + initialize STMT_VINFO_LOOP_PHI_EVOLUTION_TYPE. + (is_nonwrapping_integer_induction): Bail out for alternate + induction types. + +2026-09-25 Jakub Jelinek + + PR middle-end/127517 + * internal-fn.cc (expand_mul_overflow): Revert the 2023-09-06 + changes. Instead promote arg0 and/or arg1 to a type with + uns{0,1}_p signedness and mode precision if they have non-mode + precision. Pass the original arg0/arg1 and their type to + ubsan_build_overflow_builtin, instead of passing the promoted + ones. + +2026-09-25 Georg-Johann Lay + + * config/avr/avr.opt (-moptimize): New target option. + * config/avr/avr.opt.urls: Add resprective URL. + * common/config/avr/avr-common.cc (avr_enable_optimizations): New + static function. + (avr_handle_option) [OPT_moptimize]: Call it. + * doc/invoke.texi (AVR Options) <-moptimize>: Document it. + +2026-09-25 Artemiy Volkov + + PR tree-optimization/127552 + * match.pd: Fix constant comparison in ((X >> C1) & C2) << C3. + +2026-09-25 Andrea Pinski + + PR target/127599 + * config/aarch64/aarch64.cc (aarch64_evpc_rev64_ext): Move + the testing_p after the is_bb_in_loop test. + 2026-09-24 Jakub Jelinek PR c++/126848 diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index 147e2265a569..ca1d5ff2ec50 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20260925 +20260926 diff --git a/gcc/algol68/ChangeLog b/gcc/algol68/ChangeLog index d0446d95ce54..4992b52ffcdf 100644 --- a/gcc/algol68/ChangeLog +++ b/gcc/algol68/ChangeLog @@ -1,3 +1,43 @@ +2026-09-25 Jose E. Marchesi + + * a68-types.h (struct TAG_T): Add field ctyp. + * a68-parser.cc (a68_new_tag): Initialize CTYPE. + * a68-low-decls.cc (fish_declarer_from_tree): New function. + (grok_typedef_in_decl): Likewise. + (a68_lower_mode_declaration): Install typedef variant type for a + defining-indicant in the symtab. + (a68_lower_variable_declaration): Call grok_typedef_in_decl. + (a68_lower_identity_declaration): Likewise. + * a68-low-ranges.cc (a68_pop_serial_clause_range): Compare main + variant types in sanity check at block exit. + * a68-low.cc (a68_low_assignation): Likewise in assignation. + +2026-09-25 Jose E. Marchesi + + * a68-low-bits.cc: Use front-end type nodes consistently. + * a68-low-bools.cc: Likewise. + * a68-low-chars.cc: Likewise. + * a68-low-clauses.cc: Likewise. + * a68-low-ints.cc: Likewise. + * a68-low-multiples.cc: Likewise. + * a68-low-prelude.cc: Likewise. + * a68-low-reals.cc: Likewise. + * a68-low-unions.cc: Likewise. + * a68-low-units.cc: Likewise. + * a68-low.cc: Likewise. + +2026-09-25 Jose E. Marchesi + + * a68-low-decls.cc (a68_lower_mode_declaration): Use + a68_add_global_decl for mode declarations in public ranges. + +2026-09-25 Jose E. Marchesi + + * a68.h: Add prototypes for a68_add_global_decl and + a68_global_context. + * a68-low-ranges.cc (a68_add_global_decl): New function. + (a68_global_context): Likewise. + 2026-09-24 Jose E. Marchesi * a68-parser-moids-equivalence.cc (are_modes_equivalent): Do not diff --git a/gcc/cobol/ChangeLog b/gcc/cobol/ChangeLog index 08b329ab66af..3136fb094900 100644 --- a/gcc/cobol/ChangeLog +++ b/gcc/cobol/ChangeLog @@ -1,3 +1,24 @@ +2026-09-25 Robert Dubner + + * cobol1.cc (use_static_call): Change name of global function to + set_use_static_call. + (set_use_static_call): Likewise. + (cobol_langhook_handle_option): Use 'value' parameter rather than + 'arg' parameter. + * genapi.cc (use_static_call): Change name. + (set_use_static_call): Likewise. + (create_and_call): Call push/pop_program_state in the correct order. + (literal_call_descriptor_type): Use common structure definition in + both compile-time and run-time code. + (GCOBOL_CALL_FIELD_NAME): Likewise. + (GCOBOL_CALL_FIELD_TYPE): Likewise. + (literal_call_descriptor): Likewise. + (GCOBOL_CALL_FIELD_VALUE): Likewise. + (function_pointer_for_literal_call): Consolidate several calls to + libgcobol. + (parser_call): Likewise. + * lang.opt: Modify definition of -fstatic-call. + 2026-09-23 Robert Dubner * gcobol.1: Document the changes. diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index ef604ec25fd8..06ddd4e94a08 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,41 @@ +2026-09-25 Jakub Jelinek + + PR c++/127385 + * constexpr.cc (cxx_eval_store_expression): Handle the case + of *valp == void_node like if *valp is NULL. + (cxx_eval_store_expression): For CLOBBER_OBJECT_END or above + store *valp = void_node even for aggregate types. + +2026-09-25 Jakub Jelinek + + P3769R1 + PR c++/125848 + * call.cc (build_op_delete_call_1): Implement C++26 + P3769R1 - Clarification of placement new deallocation. Instead of + calling instantiate_type to select placement deallocation function + iterate over OVERLOAD if any, perform argument deduction for + templates, ignore candidates with different parameter type lists + or unsatisfied constraints and if only one candidate remains, + use it, otherwise don't destruct on throw. Add placement_args + argument, pass it down to build_op_delete_call call and use in + template argument deduction. + (build_op_delete_call): Add placement_args argument and pass it + down to build_op_delete_call_1. + (build_coroutine_op_delete_call): Remove placement argument, pass + down NULL_TREE and NULL to build_op_delete_call_1 as placement and + placement_args. + * cp-tree.h (build_op_delete_call): Add placement_args argument. + (build_coroutine_op_delete_call): Remove placement argument. + * init.cc (build_new_1): Pass down *placement as placement_args + to build_op_delete_call for placement new. + (build_vec_delete_1): Adjust build_op_delete_call callers. + (build_delete): Likewise. Remove {}s around single statement + body. + * coroutines.cc (build_coroutine_frame_delete_expr): Don't pass + placement to build_coroutine_op_delete_call. + * optimize.cc (build_delete_destructor_body): Adjust + build_op_delete_call caller. + 2026-09-23 Jakub Jelinek PR c++/127506 diff --git a/gcc/m2/ChangeLog b/gcc/m2/ChangeLog index 2701442355ea..ec5ddfdba200 100644 --- a/gcc/m2/ChangeLog +++ b/gcc/m2/ChangeLog @@ -1,3 +1,16 @@ +2026-09-25 Gaius Mulley + + PR modula2/127567 + * gm2-compiler/P1SymBuild.mod (BuildImportInnerModule): Call + PutImported if sym is a defimp or module. + * gm2-compiler/SymbolConversion.def (Gcc2Mod): Correct parameter + name. + * gm2-compiler/SymbolConversion.mod (Gcc2Mod): Ditto. + * gm2-compiler/SymbolTable.mod (IsExternalModule): New procedure + function. + (AddSymToModuleScope): Only generate an error if the symbol is + not an external module. + 2026-09-22 Gaius Mulley PR modula2/127554 diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index ff25481710eb..64e107a51141 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,139 @@ +2026-09-25 Jerry DeLisle + + * gfortran.dg/pdt_38.f03: Replace paren with brace. + * gfortran.dg/pdt_42.f03: Ditto. + * gfortran.dg/pdt_43.f03: Ditto. + * gfortran.dg/pdt_80.f03: Ditto. + * gfortran.dg/pdt_81.f03: Ditto. + +2026-09-25 Dominic P + + * gcc.target/aarch64/simd_srshr_1.c: New test. + * gcc.target/aarch64/simd_srshr_2.c: New test. + +2026-09-25 Dominic P + + * gcc.target/aarch64/advsimd-intrinsics/shrn-1.c: Expect rshrn + and rshrn2 in place of raddhn and raddhn2, and no movi. + * gcc.target/aarch64/advsimd-intrinsics/shrn-2.c: Expect rshrn + and rshrn2 in place of raddhn and raddhn2. Skip at -O0. + * gcc.target/aarch64/advsimd-intrinsics/shrn-3.c: Likewise. + * gcc.target/aarch64/advsimd-intrinsics/shrn-4.c: Likewise. + * gcc.target/aarch64/simd_rshrn_1.c: New test. + * gcc.target/aarch64/simd_rshrn_2.c: New test. + +2026-09-25 Dominic P + + * gcc.target/aarch64/vect-sat-trunc-3.c: New test. + +2026-09-25 Dominic P + + * gcc.dg/tree-ssa/minmax-swar-1.c: Derive the shift count from + sizeof (int); drop the int32 requirement. + * gcc.dg/tree-ssa/minmax-swar-2.c: Likewise. + +2026-09-25 Dominic P + + * gcc.dg/tree-ssa/minmax-swar-5.c: Move to... + * gcc.dg/vect/minmax-swar-5.c: ...here. Require vect_int, take the + flags from vect.exp, size the vector with sizeof and gate the scans. + * gcc.dg/tree-ssa/minmax-swar-6.c: Move to... + * gcc.dg/vect/minmax-swar-6.c: ...here. Take the flags from vect.exp. + * gcc.dg/tree-ssa/minmax-swar-7.c: Move to... + * gcc.dg/vect/minmax-swar-7.c: ...here. Likewise. + * gcc.dg/tree-ssa/minmax-negate-3.c: Move to... + * gcc.dg/vect/minmax-negate-3.c: ...here. Likewise. + * gcc.dg/tree-ssa/vector-alignup-1.c: Move to... + * gcc.dg/vect/vector-alignup-1.c: ...here. Likewise, size the + vectors with sizeof and gate the scans. + +2026-09-25 Aldy Hernandez + + PR tree-optimization/127485 + * gcc.dg/tree-ssa/vrp-minus-relation-1.c: New test. + +2026-09-25 Vladimir N. Makarov + + PR rtl-optimization/127326 + * gcc.target/i386/pr127326.c (test2): New test. + +2026-09-25 Jerry DeLisle + + PR libfortran/127347 + * gfortran.dg/coarray/collective_stopped_2.f90: New test. + +2026-09-25 Jakub Jelinek + + PR c++/127385 + * g++.dg/cpp26/within-lifetime14.C: New test. + +2026-09-25 Jakub Jelinek + + P3769R1 + PR c++/125848 + * g++.dg/cpp26/placement-new1.C: New test. + +2026-09-25 Roger Sayle + + * gcc.target/nvptx/mul-hi-2.c: New test case. + +2026-09-25 Oleg Tolmatcev + + PR target/54412 + * g++.target/i386/pr54412-highpart-extract-rt.C: New test. + * gcc.target/i386/pr54412-aligned-struct-byval-temp.c: New test. + * gcc.target/i386/pr54412-blkmode-temp-biggest-align.c: New test. + * gcc.target/i386/pr54412-escaping-param.c: New test. + * gcc.target/i386/pr54412-m256-byval-param.c: New test. + +2026-09-25 Richard Biener + + PR tree-optimization/127588 + * gcc.dg/vect/vect-iv-15.c: New testcase. + +2026-09-25 Surya Kumari Jangala + + PR rtl-optimization/106770 + * gcc.target/powerpc/pr106770.c: New test. + +2026-09-25 Richard Biener + + PR tree-optimization/127601 + * gcc.dg/vect/vect-pr127601.c: New testcase. + +2026-09-25 Richard Biener + + PR tree-optimization/127600 + * gcc.dg/vect/vect-cond-reduc-7.c: New testcase. + +2026-09-25 Jakub Jelinek + + PR middle-end/127517 + * gcc.dg/torture/bitint-109.c: New test. + +2026-09-25 Artemiy Volkov + + PR tree-optimization/127552 + * gcc.dg/tree-ssa/match-bit-extract-shift.c: Adjust testcases. + +2026-09-25 Gaius Mulley + + PR modula2/127567 + * gm2/imports/fail/tinybadimport.mod: New test. + * gm2/imports/run/pass/tinygoodimport.mod: New test. + +2026-09-25 Andrea Pinski + + PR testsuite/127587 + * gcc.dg/vect/vect-alias-check-ptr-info-2.c: Clear the arrays + before the use of them. + +2026-09-25 Andrea Pinski + + PR target/127599 + * gcc.dg/torture/pr127599-1.c: New testcase. + * gcc.target/aarch64/advsimd-intrinsics/pr127599-1.c: New testcase. + 2026-09-24 Jerry DeLisle PR libfortran/127347 diff --git a/libgcobol/ChangeLog b/libgcobol/ChangeLog index 72ada3fd4121..22b760f3879d 100644 --- a/libgcobol/ChangeLog +++ b/libgcobol/ChangeLog @@ -1,3 +1,10 @@ +2026-09-25 Robert Dubner + + * libgcobol.cc (__gg__call_warning_message): Moved here from + compile time. + (__gg__resolve_literal_call): New consolidated function. + * literal-call-descriptor.h: New file. + 2026-09-24 Robert Dubner * libgcobol.cc (find_in_dirs): Use the cached array. diff --git a/libgfortran/ChangeLog b/libgfortran/ChangeLog index 5d6ea44c4452..d7ea5a6c778d 100644 --- a/libgfortran/ChangeLog +++ b/libgfortran/ChangeLog @@ -1,3 +1,17 @@ +2026-09-25 Jerry DeLisle + + PR libfortran/127347 + * caf/shmem.c (_gfortran_caf_co_broadcast, _gfortran_caf_co_sum) + (_gfortran_caf_co_min, _gfortran_caf_co_max) + (_gfortran_caf_co_reduce): Report a terminated image of the team + through STAT. + * caf/shmem/collective_subroutine.c (collsub_sync): Return whether + the images were synchronized. + (collsub_reduce_array, collsub_broadcast_array): Likewise. Give up + when an image of the team terminated. + * caf/shmem/collective_subroutine.h (collsub_reduce_array) + (collsub_broadcast_array): Adjust. + 2026-09-24 Jerry DeLisle PR libfortran/127347 diff --git a/libgomp/ChangeLog b/libgomp/ChangeLog index cd673ea1de13..1b0858dbf7ae 100644 --- a/libgomp/ChangeLog +++ b/libgomp/ChangeLog @@ -1,3 +1,18 @@ +2026-09-25 Thomas Schwinge + + PR tree-optimization/127053 + * testsuite/libgomp.graphite/force-parallel-8.c: + 'dg-additional-options -fno-expensive-optimizations'. + +2026-09-25 Tobias Burnus + + PR lto/127589 + * testsuite/libgomp.c/cmplxint-target-1.c: New test. + * testsuite/libgomp.c/cmplxint128-target-1.c: New test. + * testsuite/libgomp.c/dfp-target-1.c: New test. + * testsuite/libgomp.c/float16-target-1.c: New test. + * testsuite/libgomp.c/float16-target-2.c: New test. + 2026-09-24 Jakub Jelinek * alloc.c (gomp_aligned_alloc): Check for overflows in the From 84d93bc97a3610446c4e19fa84d5a10f8b668358 Mon Sep 17 00:00:00 2001 From: Tobias Burnus Date: Sat, 26 Sep 2026 10:57:31 +0200 Subject: [PATCH 444/584] OpenMP: ME, nvptx, Fortran: enable 'omp groupprivate' for nvptx offload OpenMP's groupprivate variables are static variables that are have a copy per team - which matches Nvidia's 'shared' variables. This commit enables the support for offload to nvptx devices, only. Hence, a sorry is printed unless device_type(nohost) is used - and likewise when attempting to use them with GCN devices. Note: As currently the variable is still output to the host-side assembler code, accessing it from the host is still possible, but unless there is only a single variable for all teams! gcc/c-family/ChangeLog: * c-attribs.cc (c_common_gnu_attributes): Add "omp groupprivate". gcc/ChangeLog: * config/nvptx/nvptx.cc (nvptx_encode_section_info): Handle 'omp groupprivate'. * varpool.cc (varpool_node::get_create): Print sorry for 'omp groupprivate' variables except for device_type(nohost) and no offloading or nvptx offloading. gcc/fortran/ChangeLog: * f95-lang.cc (gfc_gnu_attributes): Add "omp groupprivate". * trans-common.cc (build_common_decl): Enable 'omp groupprivate'. * trans-decl.cc (add_attributes_to_decl): Likewise. gcc/testsuite/ChangeLog: * gfortran.dg/gomp/groupprivate-1.f90: Update sorry output. * gfortran.dg/gomp/groupprivate-4.f90: Likewise. libgomp/ChangeLog: * libgomp.texi (Impl.Status): Mark 'omp groupprivate' as partially supported. * testsuite/libgomp.fortran/groupprivate-1.f90: New test. * testsuite/libgomp.fortran/groupprivate-2.f90: New test. --- gcc/c-family/c-attribs.cc | 2 + gcc/config/nvptx/nvptx.cc | 3 +- gcc/fortran/f95-lang.cc | 2 + gcc/fortran/trans-common.cc | 9 +- gcc/fortran/trans-decl.cc | 13 +-- .../gfortran.dg/gomp/groupprivate-1.f90 | 15 +-- .../gfortran.dg/gomp/groupprivate-4.f90 | 14 +-- gcc/varpool.cc | 27 +++++ libgomp/libgomp.texi | 3 +- .../libgomp.fortran/groupprivate-1.f90 | 100 +++++++++++++++++ .../libgomp.fortran/groupprivate-2.f90 | 102 ++++++++++++++++++ 11 files changed, 260 insertions(+), 30 deletions(-) create mode 100644 libgomp/testsuite/libgomp.fortran/groupprivate-1.f90 create mode 100644 libgomp/testsuite/libgomp.fortran/groupprivate-2.f90 diff --git a/gcc/c-family/c-attribs.cc b/gcc/c-family/c-attribs.cc index 0e2e17cc0bec..1e6e21005d39 100644 --- a/gcc/c-family/c-attribs.cc +++ b/gcc/c-family/c-attribs.cc @@ -619,6 +619,8 @@ const struct attribute_spec c_common_gnu_attributes[] = handle_omp_declare_target_attribute, NULL }, { "omp declare target nohost", 0, 0, true, false, false, false, handle_omp_declare_target_attribute, NULL }, + { "omp groupprivate", 0, 0, true, false, false, false, + handle_omp_declare_target_attribute, NULL }, { "non overlapping", 0, 0, true, false, false, false, handle_non_overlapping_attribute, NULL }, { "alloc_align", 1, 1, false, true, true, false, diff --git a/gcc/config/nvptx/nvptx.cc b/gcc/config/nvptx/nvptx.cc index fb76e7813507..39ea6e6f923d 100644 --- a/gcc/config/nvptx/nvptx.cc +++ b/gcc/config/nvptx/nvptx.cc @@ -484,7 +484,8 @@ nvptx_encode_section_info (tree decl, rtx rtl, int first) if (VAR_P (decl)) { - if (lookup_attribute ("shared", DECL_ATTRIBUTES (decl))) + if (lookup_attribute ("shared", DECL_ATTRIBUTES (decl)) + || lookup_attribute ("omp groupprivate", DECL_ATTRIBUTES (decl))) { area = DATA_AREA_SHARED; if (DECL_INITIAL (decl)) diff --git a/gcc/fortran/f95-lang.cc b/gcc/fortran/f95-lang.cc index bfc2651c0767..10d18fe5a221 100644 --- a/gcc/fortran/f95-lang.cc +++ b/gcc/fortran/f95-lang.cc @@ -100,6 +100,8 @@ static const attribute_spec gfc_gnu_attributes[] = gfc_handle_omp_declare_target_attribute, NULL }, { "oacc function", 0, -1, true, false, false, false, gfc_handle_omp_declare_target_attribute, NULL }, + { "omp groupprivate", 0, 0, true, false, false, false, + gfc_handle_omp_declare_target_attribute, NULL }, }; static const scoped_attribute_specs gfc_gnu_attribute_table = diff --git a/gcc/fortran/trans-common.cc b/gcc/fortran/trans-common.cc index 5458237a002c..2674ef374e18 100644 --- a/gcc/fortran/trans-common.cc +++ b/gcc/fortran/trans-common.cc @@ -467,6 +467,9 @@ build_common_decl (gfc_common_head *com, tree union_type, bool is_init) gfc_set_decl_location (decl, &com->where); + if (com->omp_groupprivate) + DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("omp groupprivate"), + NULL_TREE, DECL_ATTRIBUTES (decl)); tree arg_list = NULL_TREE; if (com->omp_device_type != OMP_DEVICE_TYPE_UNSET) { @@ -488,12 +491,6 @@ build_common_decl (gfc_common_head *com, tree union_type, bool is_init) arg_list = tree_cons (NULL_TREE, get_identifier (arg_str), arg_list); } - /* Also check trans-decl.cc when updating/removing the following; - also update f95.c's gfc_gnu_attributes. */ - if (com->omp_groupprivate) - gfc_error ("Sorry, OMP GROUPPRIVATE not implemented, used by common " - "block % declared at %L", com->name, &com->where); - if (com->omp_declare_target_link) DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("omp declare target link"), diff --git a/gcc/fortran/trans-decl.cc b/gcc/fortran/trans-decl.cc index dc17b658d10e..2b7ef12c1a82 100644 --- a/gcc/fortran/trans-decl.cc +++ b/gcc/fortran/trans-decl.cc @@ -1582,12 +1582,13 @@ add_attributes_to_decl (tree *decl_p, const gfc_symbol *sym) clauses = c; } - /* FIXME: 'declare_target_link' permits both any and host, but - will fail if one sets OMP_CLAUSE_DEVICE_TYPE_KIND. */ + if (sym_attr.omp_groupprivate) + list = tree_cons (get_identifier ("omp groupprivate"), NULL_TREE, list); + tree arg_list = NULL_TREE; if (sym_attr.omp_device_type != OMP_DEVICE_TYPE_UNSET && !sym_attr.omp_declare_target_link - && !sym_attr.omp_declare_target_indirect /* implies 'any' */) + && !sym_attr.omp_declare_target_indirect) { const char *arg_str = NULL; switch (sym_attr.omp_device_type) @@ -1607,12 +1608,6 @@ add_attributes_to_decl (tree *decl_p, const gfc_symbol *sym) arg_list = tree_cons (NULL_TREE, get_identifier (arg_str), arg_list); } - /* Also check trans-common.cc when updating/removing the following; - also update f95.c's gfc_gnu_attributes. */ - if (sym_attr.omp_groupprivate) - gfc_error ("Sorry, OMP GROUPPRIVATE not implemented, " - "used by %qs declared at %L", sym->name, &sym->declared_at); - bool has_declare = true; if (flag_openmp) diff --git a/gcc/testsuite/gfortran.dg/gomp/groupprivate-1.f90 b/gcc/testsuite/gfortran.dg/gomp/groupprivate-1.f90 index 1d9f5492d6af..80bf6c61023d 100644 --- a/gcc/testsuite/gfortran.dg/gomp/groupprivate-1.f90 +++ b/gcc/testsuite/gfortran.dg/gomp/groupprivate-1.f90 @@ -2,13 +2,14 @@ module m implicit none integer :: ii integer :: x, y(20), z, v, u, k -! { dg-error "Sorry, OMP GROUPPRIVATE not implemented, used by 'x' declared at .1." "" { target *-*-* } .-1 } -! { dg-error "Sorry, OMP GROUPPRIVATE not implemented, used by 'y' declared at .1." "" { target *-*-* } .-2 } -! { dg-error "Sorry, OMP GROUPPRIVATE not implemented, used by 'z' declared at .1." "" { target *-*-* } .-3 } -! { dg-error "Sorry, OMP GROUPPRIVATE not implemented, used by 'v' declared at .1." "" { target *-*-* } .-4 } -! { dg-error "Sorry, OMP GROUPPRIVATE not implemented, used by 'u' declared at .1." "" { target *-*-* } .-5 } -! { dg-error "Sorry, OMP GROUPPRIVATE not implemented, used by 'k' declared at .1." "" { target *-*-* } .-6 } -! + ! { dg-message "sorry, unimplemented: 'k' with 'omp groupprivate' on the host; try 'device_type\\(nohost\\)'" "" { target *-*-* } .-1 } + ! { dg-message "sorry, unimplemented: 'u' with 'omp groupprivate' on the host; try 'device_type\\(nohost\\)'" "" { target *-*-* } .-2 } + ! { dg-message "sorry, unimplemented: 'x' with 'omp groupprivate' on the host; try 'device_type\\(nohost\\)'" "" { target *-*-* } .-3 } + ! { dg-message "sorry, unimplemented: 'y' with 'omp groupprivate' on the host; try 'device_type\\(nohost\\)'" "" { target *-*-* } .-4 } + ! { dg-message "sorry, unimplemented: 'z' with 'omp groupprivate' on the host; try 'device_type\\(nohost\\)'" "" { target *-*-* } .-5 } + + ! { dg-prune-output "sorry, unimplemented: 'v' with 'omp groupprivate' on devices other than" } + !$omp groupprivate(x, z) device_Type( any ) !$omp declare target local(x) device_type ( any ) !$omp declare target enter( ii) ,local(y), device_type ( host ) diff --git a/gcc/testsuite/gfortran.dg/gomp/groupprivate-4.f90 b/gcc/testsuite/gfortran.dg/gomp/groupprivate-4.f90 index a980c1fa0bd6..278b9b513439 100644 --- a/gcc/testsuite/gfortran.dg/gomp/groupprivate-4.f90 +++ b/gcc/testsuite/gfortran.dg/gomp/groupprivate-4.f90 @@ -4,12 +4,14 @@ module m integer :: x, y(20), z, v, u, k common /b_ii/ ii - common /b_x/ x ! { dg-error "Sorry, OMP GROUPPRIVATE not implemented, used by common block '/b_x/' declared at .1." } - common /b_y/ y ! { dg-error "Sorry, OMP GROUPPRIVATE not implemented, used by common block '/b_y/' declared at .1." } - common /b_z/ z ! { dg-error "Sorry, OMP GROUPPRIVATE not implemented, used by common block '/b_z/' declared at .1." } - common /b_v/ v ! { dg-error "Sorry, OMP GROUPPRIVATE not implemented, used by common block '/b_v/' declared at .1." } - common /b_u/ u ! { dg-error "Sorry, OMP GROUPPRIVATE not implemented, used by common block '/b_u/' declared at .1." } - common /b_k/ k ! { dg-error "Sorry, OMP GROUPPRIVATE not implemented, used by common block '/b_k/' declared at .1." } + common /b_x/ x ! { dg-message "sorry, unimplemented: 'b_x' with 'omp groupprivate' on the host; try 'device_type\\(nohost\\)'" } + common /b_y/ y ! { dg-message "sorry, unimplemented: 'b_y' with 'omp groupprivate' on the host; try 'device_type\\(nohost\\)'" } + common /b_z/ z ! { dg-message "sorry, unimplemented: 'b_z' with 'omp groupprivate' on the host; try 'device_type\\(nohost\\)'" } + common /b_v/ v + common /b_u/ u ! { dg-message "sorry, unimplemented: 'b_u' with 'omp groupprivate' on the host; try 'device_type\\(nohost\\)'" } + common /b_k/ k ! { dg-message "sorry, unimplemented: 'b_k' with 'omp groupprivate' on the host; try 'device_type\\(nohost\\)'" } + + ! { dg-prune-output "sorry, unimplemented: 'b_v' with 'omp groupprivate' on devices other than" } !$omp groupprivate(/b_x/, /b_z/) device_Type( any ) !$omp declare target local(/b_x/) device_type ( any ) diff --git a/gcc/varpool.cc b/gcc/varpool.cc index b62fba999968..d30bd248e182 100644 --- a/gcc/varpool.cc +++ b/gcc/varpool.cc @@ -156,6 +156,33 @@ varpool_node::get_create (tree decl) DECL_ATTRIBUTES (decl)))) { node->offloadable = 1; + if (lookup_attribute ("omp groupprivate", DECL_ATTRIBUTES (decl))) + { + if (!value_member (get_identifier ("device_type(nohost)"), + TREE_VALUE (attr)) + && !lookup_attribute ("omp declare target nohost", + DECL_ATTRIBUTES (decl))) + /* FIXME: value_member is Fortran, nohost attribute is C/C++. */ + sorry_at (DECL_SOURCE_LOCATION (decl), + "%qD with % on the host; " + "try %", decl); + else + for (const char *c = getenv ("OFFLOAD_TARGET_NAMES"); c;) + { + if (startswith (c, "nvptx")) /* Supported. */ + { + if ((c = strchr (c, ':'))) + c++; + } + else + { + sorry_at (DECL_SOURCE_LOCATION (decl), + "%qD with % on devices other " + "than nvptx; try %<-foffload=nvptx-none%>", decl); + break; + } + } + } if (ENABLE_OFFLOADING && !DECL_EXTERNAL (decl)) { g->have_offload = true; diff --git a/libgomp/libgomp.texi b/libgomp/libgomp.texi index 4a1069833082..7f34a36e38b7 100644 --- a/libgomp/libgomp.texi +++ b/libgomp/libgomp.texi @@ -533,7 +533,8 @@ to address of matching mapped list item per 5.1, Sect. 2.21.7.2 @tab N @tab @item @code{delete} as delete-modifier not as map type @tab N @tab @item For Fortran, the @code{automap} modifier to the @code{enter} clause of @code{declare_target} @tab N @tab -@item @code{groupprivate} directive @tab N @tab +@item @code{groupprivate} directive @tab P @tab + Only Fortran with @code{device_type(nohost)} with only nvptx GPUs @item @code{local} clause to @code{declare_target} directive @tab N @tab @item @code{part_size} allocator trait for @code{interleaved} allocator partitions @tab N @tab diff --git a/libgomp/testsuite/libgomp.fortran/groupprivate-1.f90 b/libgomp/testsuite/libgomp.fortran/groupprivate-1.f90 new file mode 100644 index 000000000000..27156aae1f86 --- /dev/null +++ b/libgomp/testsuite/libgomp.fortran/groupprivate-1.f90 @@ -0,0 +1,100 @@ +! { dg-do run { target offload_device_nvptx } } +! { dg-additional-options "-O0 -foffload=nvptx-none" } +! +! FIXME: Enable testing for AMD GCN once implemented +! +! The following code works if +! - either 'target teams' runs in sequence order (this seems to happen on the +! host for 'target teams' but not for 'teams') +! - or, when teams run concurrently, if 'cnt' and 'local_cnt' are 'groupprivate'. +! +! The latter is check by this testcase. +! +! On nvptx, such memory is called 'shared' and it turns out that the address +! is the same for all teams. However, the value check only succeeds if it is +! indeed shared! The produced nvptx assembly is: +! .shared .align 4 .u32 local_cnt$1[1]; +! .visible .shared .align 4 .u32 __m_MOD_cnt[1]; +! +module m + use iso_c_binding + use omp_lib + implicit none + + integer :: cnt ! Note that no initializer is permitted! + !$omp declare target local(cnt) device_type(nohost) + !$omp groupprivate(cnt) device_type(nohost) + +contains + + integer(c_ptrdiff_t) function addr() + addr = loc(cnt) + end + + integer function f_global(first) + !$omp declare target enter(f_global) device_type(nohost) + logical, value, intent(in) :: first + + if (first) then + !$omp atomic write + cnt = 0 + end if + !$omp atomic update + cnt = cnt + (omp_get_team_num () + 1); + !$omp atomic read + f_global = cnt + end + + integer function f_local(first) + !$omp declare target enter(f_local) device_type(nohost) + logical, value, intent(in) :: first + integer, save :: local_cnt + !$omp groupprivate(local_cnt) device_type(nohost) + + if (first) then + !$omp atomic write + local_cnt = 5 + end if + !$omp atomic update + local_cnt = local_cnt + 2*(omp_get_team_num () + 1); + !$omp atomic read + f_local = local_cnt + end +end module m + +program main + use m + implicit none + integer :: team_global(16), team_local(16), j, num_teams + integer(c_ptrdiff_t) :: addrs(16) + + ! !$omp teams num_teams(16) + !$omp target teams num_teams(16) map(from: team_global, team_local, num_teams) device_type(nohost) + block + !$omp parallel if(.false.) + block + integer :: i + real, volatile :: x + x = 3.3 + i = f_global(.true.) + i = f_local(.true.) + addrs(1+omp_get_team_num()) = addr() + x = sin(x) + team_global(1+omp_get_team_num()) = f_global(.false.) + team_local(1+omp_get_team_num()) = f_local(.false.) + if (omp_get_team_num() == 0) & + num_teams = omp_get_num_teams () + end block + end block + + if (num_teams /= 16) error stop "num teams error" + + do j = 1, 16 + if (team_global(j) /= j*2 .or. team_local(j) /= 5+j*4) then + print '(i2,": ", 4(i6, " "), g0, " ", g0, " - ", z16)', j,& + team_global(j), team_local(j), j*2, 5+j*4, & + team_global(j)==j*2, team_local(j)==5+j*4, addrs(j) + error stop "invalid value" + end if + end do +end diff --git a/libgomp/testsuite/libgomp.fortran/groupprivate-2.f90 b/libgomp/testsuite/libgomp.fortran/groupprivate-2.f90 new file mode 100644 index 000000000000..f52c1d095ff6 --- /dev/null +++ b/libgomp/testsuite/libgomp.fortran/groupprivate-2.f90 @@ -0,0 +1,102 @@ +! { dg-do run { target offload_device_nvptx } } +! { dg-additional-options "-O0 -foffload=nvptx-none" } +! +! FIXME: Enable testing for AMD GCN once implemented +! +! The following code works if +! - either 'target teams' runs in sequence order (this seems to happen on the +! host for 'target teams' but not for 'teams') +! - or, when teams run concurrently, if 'cnt' and 'local_cnt' are 'groupprivate'. +! +! The latter is check by this testcase. +! +! On nvptx, such memory is called 'shared' and it turns out that the address +! is the same for all teams. However, the value check only succeeds if it is +! indeed shared! The produced nvptx assembly is: +! .shared .align 4 .u32 local_cnt$1[1]; +! .visible .shared .align 4 .u32 __m_MOD_cnt[1]; +! +module m + use iso_c_binding + use omp_lib + implicit none + + integer :: cnt ! Note that no initializer is permitted! + common /one/ cnt + !$omp declare target local(/one/) device_type(nohost) + !$omp groupprivate(/one/) device_type(nohost) + +contains + + integer(c_ptrdiff_t) function addr() + addr = loc(cnt) + end + + integer function f_global(first) + !$omp declare target enter(f_global) device_type(nohost) + logical, value, intent(in) :: first + + if (first) then + !$omp atomic write + cnt = 0 + end if + !$omp atomic update + cnt = cnt + (omp_get_team_num () + 1); + !$omp atomic read + f_global = cnt + end + + integer function f_local(first) + !$omp declare target enter(f_local) device_type(nohost) + logical, value, intent(in) :: first + integer :: local_cnt + common /two/ local_cnt + !$omp groupprivate(/two/) device_type(nohost) + + if (first) then + !$omp atomic write + local_cnt = 5 + end if + !$omp atomic update + local_cnt = local_cnt + 2*(omp_get_team_num () + 1); + !$omp atomic read + f_local = local_cnt + end +end module m + +program main + use m + implicit none + integer :: team_global(16), team_local(16), j, num_teams + integer(c_ptrdiff_t) :: addrs(16) + + ! !$omp teams num_teams(16) + !$omp target teams num_teams(16) map(from: team_global, team_local, num_teams) device_type(nohost) + block + !$omp parallel if(.false.) + block + integer :: i + real, volatile :: x + x = 3.3 + i = f_global(.true.) + i = f_local(.true.) + addrs(1+omp_get_team_num()) = addr() + x = sin(x) + team_global(1+omp_get_team_num()) = f_global(.false.) + team_local(1+omp_get_team_num()) = f_local(.false.) + if (omp_get_team_num() == 0) & + num_teams = omp_get_num_teams () + end block + end block + + if (num_teams /= 16) error stop "num teams error" + + do j = 1, 16 + if (team_global(j) /= j*2 .or. team_local(j) /= 5+j*4) then + print '(i2,": ", 4(i6, " "), g0, " ", g0, " - ", z16)', j,& + team_global(j), team_local(j), j*2, 5+j*4, & + team_global(j)==j*2, team_local(j)==5+j*4, addrs(j) + error stop "invalid value" + end if + end do +end From a39d268ced985763ac84ba87c243d44f79dd304a Mon Sep 17 00:00:00 2001 From: Tobias Burnus Date: Sat, 26 Sep 2026 12:55:12 +0200 Subject: [PATCH 445/584] OpenMP/Fortran: accept optional const bool expr for inarguable clauses OpenMP 6 added an optional constant logical expression to all those clauses that otherwise do not take an argument, usable to enable or disable the feature; for some clauses, .false. implies not present for others it implies present but not active, which makes a difference for the diagnostic (and mostly matters for clauses groups). Note that some logical clauses are mandatatory like for nocontext or novariants; those also accept variables as argument. The 'nowait' clause meanwhile also accepts an argument; as also supports non-constant values are supported, the implemention has not been done in this commit. gcc/fortran/ChangeLog: * gfortran.h (enum gfc_omp_requires_kind): Add OMP_REQ_NONE. * openmp.cc (gfc_match_boolean_clause): New. (gfc_match_dupl_branch_clause): New. (gfc_match_dupl_check): Remove dupl_msg arg. (gfc_match_dupl_atomic, gfc_match_dupl_memorder, gfc_match_omp_clauses, gfc_match_omp_flush, gfc_match_omp_requires): Accept optional constant logical expression for inarguable clauses. libgomp/ChangeLog: * libgomp.texi (Impl. Status): Mark optional const bool expr for inarguable clauses as implemented for Fortran. gcc/testsuite/ChangeLog: * gfortran.dg/gomp/atomic-18.f90: Update dg-error. * gfortran.dg/gomp/declare-simd-1.f90: Likewise. * gfortran.dg/gomp/declare-target-indirect-1.f90: Likewise. * gfortran.dg/gomp/flush-2.f90: Likewise. * gfortran.dg/gomp/requires-2.f90: Likewise. * gfortran.dg/gomp/clause-logical-arg-1.f90: New test. * gfortran.dg/gomp/clause-logical-arg-2.f90: New test. --- gcc/fortran/gfortran.h | 1 + gcc/fortran/openmp.cc | 564 ++++++++++++------ gcc/testsuite/gfortran.dg/gomp/atomic-18.f90 | 4 +- .../gfortran.dg/gomp/clause-logical-arg-1.f90 | 109 ++++ .../gfortran.dg/gomp/clause-logical-arg-2.f90 | 73 +++ .../gfortran.dg/gomp/declare-simd-1.f90 | 2 +- .../gomp/declare-target-indirect-1.f90 | 8 +- gcc/testsuite/gfortran.dg/gomp/flush-2.f90 | 8 +- gcc/testsuite/gfortran.dg/gomp/requires-2.f90 | 12 +- libgomp/libgomp.texi | 3 +- 10 files changed, 585 insertions(+), 199 deletions(-) create mode 100644 gcc/testsuite/gfortran.dg/gomp/clause-logical-arg-1.f90 create mode 100644 gcc/testsuite/gfortran.dg/gomp/clause-logical-arg-2.f90 diff --git a/gcc/fortran/gfortran.h b/gcc/fortran/gfortran.h index 300ecc4907af..2411869c150f 100644 --- a/gcc/fortran/gfortran.h +++ b/gcc/fortran/gfortran.h @@ -1644,6 +1644,7 @@ enum gfc_omp_atomic_op enum gfc_omp_requires_kind { /* Keep gfc_namespace's omp_requires bitfield size in sync. */ + OMP_REQ_NONE = 0, /* unset */ OMP_REQ_ATOMIC_MEM_ORDER_SEQ_CST = 1, /* 001 */ OMP_REQ_ATOMIC_MEM_ORDER_ACQ_REL = 2, /* 010 */ OMP_REQ_ATOMIC_MEM_ORDER_RELAXED = 3, /* 011 */ diff --git a/gcc/fortran/openmp.cc b/gcc/fortran/openmp.cc index a1e89e386fd1..a2c825401e30 100644 --- a/gcc/fortran/openmp.cc +++ b/gcc/fortran/openmp.cc @@ -2475,16 +2475,112 @@ gfc_match_omp_init (gfc_omp_namelist **list) return MATCH_YES; } +/* Match boolean-type clause with duplicate check. Matches 'name' then matches + an optional '(const-logical-expr)'; already_set is used for the duplicate + check. If the clause is not matched NO is returned, if an error occurs ERROR + and otherwise YES. In the no-error case RES contains the value of the + expression or true if no expression exists. + If FALSE_OK, 'false' implies an absent clause, which can be repeated without + printing an error; that is the case for clause groups. + If DUPL_MSG is nonnull, the string is used as error message and must contain + %qs and %L in that order. */ + +static match +gfc_match_boolean_clause (bool *res, const char *name, bool already_set, + bool false_ok = false, const char *dupl_msg = NULL) +{ + gfc_expr *expr = NULL; + match m; + char c; + locus old_loc = gfc_current_locus; + locus old_loc2; + if ((m = gfc_match (name)) != MATCH_YES) + return m; + /* Ensure that no partial string is matched. */ + if (gfc_current_form == FORM_FREE + && gfc_match_eos () != MATCH_YES + && ((c = gfc_peek_ascii_char ()) == '_' || ISALNUM (c))) + { + gfc_current_locus = old_loc; + return MATCH_NO; + } + if (already_set && !false_ok) + goto dupl; + if (gfc_match (" (") == MATCH_NO) + { + if (already_set) + goto dupl; + *res = true; /* Implicit boolean true. */ + return MATCH_YES; + } + old_loc2 = gfc_current_locus; + m = gfc_match_expr (&expr); + if (m != MATCH_YES + || gfc_match (" )") != MATCH_YES + || !gfc_resolve_expr (expr) + || expr->rank != 0 + || expr->expr_type != EXPR_CONSTANT + || expr->ts.type != BT_LOGICAL) + { + gfc_free_expr (expr); + gfc_error ("Expected %<( const-logical-expr )%> at %L", &old_loc2); + return MATCH_ERROR; + } + if (already_set && expr->value.logical) + goto dupl; + *res = expr->value.logical; + gfc_free_expr (expr); + return MATCH_YES; + +dupl: + if (dupl_msg) + gfc_error (dupl_msg, name, &old_loc); + else + gfc_error ("Duplicated %qs clause at %L", name, &old_loc); + return MATCH_ERROR; +} + + +/* Match a clause from the atomic clauses set. */ + +static match +gfc_match_dupl_atomic (bool *res, const char *name, bool already_set) +{ + const char *msg = G_("Duplicated atomic clause: unexpected %qs clause at %L"); + return gfc_match_boolean_clause (res, name, already_set, true, msg); +} + + +/* Match a clause from the memory-order clauses set. */ + +static match +gfc_match_dupl_memorder (bool *res, const char *name, bool already_set) +{ + const char *msg = G_("Duplicated memory-order clause: unexpected %qs clause " + "at %L"); + return gfc_match_boolean_clause (res, name, already_set, true, msg); +} + + +/* Match a clause from the branch clauses set; interestingly, here + inbranch(false) branch(false/true) is not permitted! */ + +static match +gfc_match_dupl_branch_clause (bool *res, const char *name, bool already_set) +{ + const char *msg = G_("Duplicated branch clause: unexpected %qs clause " + "at %L"); + return gfc_match_boolean_clause (res, name, already_set, false, msg); +} + /* Match with duplicate check. Matches 'name'. If expr != NULL, it then matches '(expr)', otherwise, if open_parens is true, - it matches a ' ( ' after 'name'. - dupl_message requires '%qs %L' - and is used by - gfc_match_dupl_memorder and gfc_match_dupl_atomic. */ + it matches a ' ( ' after 'name'. */ static match gfc_match_dupl_check (bool not_dupl, const char *name, bool open_parens = false, - gfc_expr **expr = NULL, const char *dupl_msg = NULL) + gfc_expr **expr = NULL) { match m; char c; @@ -2501,10 +2597,7 @@ gfc_match_dupl_check (bool not_dupl, const char *name, bool open_parens = false, } if (!not_dupl) { - if (dupl_msg) - gfc_error (dupl_msg, name, &old_loc); - else - gfc_error ("Duplicated %qs clause at %L", name, &old_loc); + gfc_error ("Duplicated %qs clause at %L", name, &old_loc); return MATCH_ERROR; } if (open_parens || expr) @@ -2526,23 +2619,6 @@ gfc_match_dupl_check (bool not_dupl, const char *name, bool open_parens = false, return MATCH_YES; } -static match -gfc_match_dupl_memorder (bool not_dupl, const char *name) -{ - return gfc_match_dupl_check (not_dupl, name, false, NULL, - "Duplicated memory-order clause: unexpected %s " - "clause at %L"); -} - -static match -gfc_match_dupl_atomic (bool not_dupl, const char *name) -{ - return gfc_match_dupl_check (not_dupl, name, false, NULL, - "Duplicated atomic clause: unexpected %s " - "clause at %L"); -} - - /* Search upwards though namespace NS and its parents to find an !$omp declare mapper named MAPPER_ID, for typespec TS. The default mapper has mapper_id == "". */ @@ -2591,7 +2667,9 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, gfc_omp_map_op default_map_op = OMP_MAP_TOFROM) { bool error = false; + bool bval; gfc_omp_clauses *c = gfc_get_omp_clauses (); + gfc_omp_clauses *cfalse = openacc ? NULL : gfc_get_omp_clauses (); locus old_loc; /* Determine whether we're dealing with an OpenACC directive that permits derived type member accesses. This in particular disallows @@ -2658,23 +2736,23 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, continue; } if ((mask & OMP_CLAUSE_MEMORDER) - && (m = gfc_match_dupl_memorder ((c->memorder - == OMP_MEMORDER_UNSET), - "acq_rel")) != MATCH_NO) + && (m = gfc_match_dupl_memorder (&bval, "acq_rel", + c->memorder != OMP_MEMORDER_UNSET)) != MATCH_NO) { if (m == MATCH_ERROR) goto error; - c->memorder = OMP_MEMORDER_ACQ_REL; + if (bval) + c->memorder = OMP_MEMORDER_ACQ_REL; continue; } if ((mask & OMP_CLAUSE_MEMORDER) - && (m = gfc_match_dupl_memorder ((c->memorder - == OMP_MEMORDER_UNSET), - "acquire")) != MATCH_NO) + && (m = gfc_match_dupl_memorder (&bval, "acquire", + c->memorder != OMP_MEMORDER_UNSET)) != MATCH_NO) { if (m == MATCH_ERROR) goto error; - c->memorder = OMP_MEMORDER_ACQUIRE; + if (bval) + c->memorder = OMP_MEMORDER_ACQUIRE; continue; } if ((mask & OMP_CLAUSE_AFFINITY) @@ -2838,12 +2916,15 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, break; case 'c': if ((mask & OMP_CLAUSE_CAPTURE) - && (m = gfc_match_dupl_check (!c->capture, "capture")) - != MATCH_NO) + && (m = gfc_match_boolean_clause (&bval, "capture", + c->capture || cfalse->capture)) != MATCH_NO) { if (m == MATCH_ERROR) goto error; - c->capture = true; + if (bval) + c->capture = true; + else + cfalse->capture = true; continue; } if (mask & OMP_CLAUSE_COLLAPSE) @@ -2869,12 +2950,15 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, } } if ((mask & OMP_CLAUSE_COMPARE) - && (m = gfc_match_dupl_check (!c->compare, "compare")) - != MATCH_NO) + && (m = gfc_match_boolean_clause (&bval, "compare", + c->compare || cfalse->compare)) != MATCH_NO) { if (m == MATCH_ERROR) goto error; - c->compare = true; + if (bval) + c->compare = true; + else + cfalse->compare = true; continue; } if ((mask & OMP_CLAUSE_ASSUMPTIONS) @@ -3442,11 +3526,15 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, &head) == MATCH_YES) continue; if ((mask & OMP_CLAUSE_FULL) - && (m = gfc_match_dupl_check (!c->full, "full")) != MATCH_NO) + && (m = gfc_match_boolean_clause (&bval, "full", + c->full || cfalse->full)) != MATCH_NO) { if (m == MATCH_ERROR) goto error; - c->full = true; + if (bval) + c->full = true; + else + cfalse->full = true; continue; } break; @@ -3573,12 +3661,16 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, openmp_target) == MATCH_YES) continue; if ((mask & OMP_CLAUSE_INBRANCH) - && (m = gfc_match_dupl_check (!c->inbranch && !c->notinbranch, - "inbranch")) != MATCH_NO) + && (m = gfc_match_dupl_branch_clause (&bval, "inbranch", + c->notinbranch || cfalse->notinbranch + || c->inbranch || cfalse->inbranch)) != MATCH_NO) { if (m == MATCH_ERROR) goto error; - c->inbranch = true; + if (bval) + c->inbranch = true; + else + cfalse->inbranch = true; continue; } if ((mask & OMP_CLAUSE_INDEPENDENT) @@ -3591,29 +3683,15 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, continue; } if ((mask & OMP_CLAUSE_INDIRECT) - && (m = gfc_match_dupl_check (!c->indirect, "indirect")) - != MATCH_NO) + && (m = gfc_match_boolean_clause (&bval, "indirect", + c->indirect || cfalse->indirect)) != MATCH_NO) { if (m == MATCH_ERROR) goto error; - gfc_expr *indirect_expr = NULL; - m = gfc_match (" ( %e )", &indirect_expr); - if (m == MATCH_YES) - { - if (!gfc_resolve_expr (indirect_expr) - || indirect_expr->ts.type != BT_LOGICAL - || indirect_expr->expr_type != EXPR_CONSTANT) - { - gfc_error ("INDIRECT clause at %C requires a constant " - "logical expression"); - gfc_free_expr (indirect_expr); - goto error; - } - c->indirect = indirect_expr->value.logical; - gfc_free_expr (indirect_expr); - } + if (bval) + c->indirect = true; else - c->indirect = 1; + cfalse->indirect = true; continue; } if ((mask & OMP_CLAUSE_INIT) @@ -4059,12 +4137,15 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, break; } if ((mask & OMP_CLAUSE_MERGEABLE) - && (m = gfc_match_dupl_check (!c->mergeable, "mergeable")) - != MATCH_NO) + && (m = gfc_match_boolean_clause (&bval, "mergeable", + c->mergeable || cfalse->mergeable)) != MATCH_NO) { if (m == MATCH_ERROR) goto error; - c->mergeable = true; + if (bval) + c->mergeable = true; + else + cfalse->mergeable = true; continue; } if ((mask & OMP_CLAUSE_MESSAGE) @@ -4084,50 +4165,91 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, allow_derived)) continue; if ((mask & OMP_CLAUSE_ASSUMPTIONS) - && (m = gfc_match_dupl_check (!c->assume - || !c->assume->no_openmp_constructs, - "no_openmp_constructs")) != MATCH_NO) + && ((m = gfc_match_boolean_clause (&bval, "no_openmp_constructs", + (c->assume && c->assume->no_openmp_constructs) + || (cfalse->assume && cfalse->assume->no_openmp_constructs))) + != MATCH_NO)) { if (m == MATCH_ERROR) goto error; - if (c->assume == NULL) - c->assume = gfc_get_omp_assumptions (); - c->assume->no_openmp_constructs = true; + if (bval) + { + if (c->assume == NULL) + c->assume = gfc_get_omp_assumptions (); + c->assume->no_openmp_constructs = true; + } + else + { + if (cfalse->assume == NULL) + cfalse->assume = gfc_get_omp_assumptions (); + cfalse->assume->no_openmp_constructs = true; + } continue; } if ((mask & OMP_CLAUSE_ASSUMPTIONS) - && (m = gfc_match_dupl_check (!c->assume - || !c->assume->no_openmp_routines, - "no_openmp_routines")) != MATCH_NO) + && ((m = gfc_match_boolean_clause (&bval, "no_openmp_routines", + (c->assume && c->assume->no_openmp_routines) + || (cfalse->assume && cfalse->assume->no_openmp_routines))) + != MATCH_NO)) { if (m == MATCH_ERROR) goto error; - if (c->assume == NULL) - c->assume = gfc_get_omp_assumptions (); - c->assume->no_openmp_routines = true; + if (bval) + { + if (c->assume == NULL) + c->assume = gfc_get_omp_assumptions (); + c->assume->no_openmp_routines = true; + } + else + { + if (cfalse->assume == NULL) + cfalse->assume = gfc_get_omp_assumptions (); + cfalse->assume->no_openmp_routines = true; + } continue; } if ((mask & OMP_CLAUSE_ASSUMPTIONS) - && (m = gfc_match_dupl_check (!c->assume || !c->assume->no_openmp, - "no_openmp")) != MATCH_NO) + && ((m = gfc_match_boolean_clause (&bval, "no_openmp", + (c->assume && c->assume->no_openmp) + || (cfalse->assume && cfalse->assume->no_openmp))) + != MATCH_NO)) { if (m == MATCH_ERROR) goto error; - if (c->assume == NULL) - c->assume = gfc_get_omp_assumptions (); - c->assume->no_openmp = true; + if (bval) + { + if (c->assume == NULL) + c->assume = gfc_get_omp_assumptions (); + c->assume->no_openmp = true; + } + else + { + if (cfalse->assume == NULL) + cfalse->assume = gfc_get_omp_assumptions (); + cfalse->assume->no_openmp = true; + } continue; } if ((mask & OMP_CLAUSE_ASSUMPTIONS) - && (m = gfc_match_dupl_check (!c->assume - || !c->assume->no_parallelism, - "no_parallelism")) != MATCH_NO) + && ((m = gfc_match_boolean_clause (&bval, "no_parallelism", + (c->assume && c->assume->no_parallelism) + || (cfalse->assume && cfalse->assume->no_parallelism))) + != MATCH_NO)) { if (m == MATCH_ERROR) goto error; - if (c->assume == NULL) - c->assume = gfc_get_omp_assumptions (); - c->assume->no_parallelism = true; + if (bval) + { + if (c->assume == NULL) + c->assume = gfc_get_omp_assumptions (); + c->assume->no_parallelism = true; + } + else + { + if (cfalse->assume == NULL) + cfalse->assume = gfc_get_omp_assumptions (); + cfalse->assume->no_parallelism = true; + } continue; } @@ -4150,12 +4272,16 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, continue; } if ((mask & OMP_CLAUSE_NOGROUP) - && (m = gfc_match_dupl_check (!c->nogroup, "nogroup")) - != MATCH_NO) + && ((m = gfc_match_boolean_clause (&bval, "nogroup", + c->nogroup || cfalse->nogroup)) + != MATCH_NO)) { if (m == MATCH_ERROR) goto error; - c->nogroup = true; + if (bval) + c->nogroup = true; + else + cfalse->nogroup = true; continue; } if ((mask & OMP_CLAUSE_NOHOST) @@ -4172,12 +4298,16 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, true) == MATCH_YES) continue; if ((mask & OMP_CLAUSE_NOTINBRANCH) - && (m = gfc_match_dupl_check (!c->notinbranch && !c->inbranch, - "notinbranch")) != MATCH_NO) + && (m = gfc_match_dupl_branch_clause (&bval, "notinbranch", + c->notinbranch || cfalse->notinbranch + || c->inbranch || cfalse->inbranch)) != MATCH_NO) { if (m == MATCH_ERROR) goto error; - c->notinbranch = true; + if (bval) + c->notinbranch = true; + else + cfalse->notinbranch = true; continue; } if ((mask & OMP_CLAUSE_NOWAIT) @@ -4544,13 +4674,13 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, break; case 'r': if ((mask & OMP_CLAUSE_ATOMIC) - && (m = gfc_match_dupl_atomic ((c->atomic_op - == GFC_OMP_ATOMIC_UNSET), - "read")) != MATCH_NO) + && (m = gfc_match_dupl_atomic (&bval, "read", + c->atomic_op != GFC_OMP_ATOMIC_UNSET)) != MATCH_NO) { if (m == MATCH_ERROR) goto error; - c->atomic_op = GFC_OMP_ATOMIC_READ; + if (bval) + c->atomic_op = GFC_OMP_ATOMIC_READ; continue; } if ((mask & OMP_CLAUSE_REDUCTION) @@ -4558,23 +4688,23 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, allow_derived) == MATCH_YES) continue; if ((mask & OMP_CLAUSE_MEMORDER) - && (m = gfc_match_dupl_memorder ((c->memorder - == OMP_MEMORDER_UNSET), - "relaxed")) != MATCH_NO) + && (m = gfc_match_dupl_memorder (&bval, "relaxed", + c->memorder != OMP_MEMORDER_UNSET)) != MATCH_NO) { if (m == MATCH_ERROR) goto error; - c->memorder = OMP_MEMORDER_RELAXED; + if (bval) + c->memorder = OMP_MEMORDER_RELAXED; continue; } if ((mask & OMP_CLAUSE_MEMORDER) - && (m = gfc_match_dupl_memorder ((c->memorder - == OMP_MEMORDER_UNSET), - "release")) != MATCH_NO) + && (m = gfc_match_dupl_memorder (&bval, "release", + c->memorder != OMP_MEMORDER_UNSET)) != MATCH_NO) { if (m == MATCH_ERROR) goto error; - c->memorder = OMP_MEMORDER_RELEASE; + if (bval) + c->memorder = OMP_MEMORDER_RELEASE; continue; } break; @@ -4688,13 +4818,13 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, continue; } if ((mask & OMP_CLAUSE_MEMORDER) - && (m = gfc_match_dupl_memorder ((c->memorder - == OMP_MEMORDER_UNSET), - "seq_cst")) != MATCH_NO) + && (m = gfc_match_dupl_memorder (&bval, "seq_cst", + c->memorder != OMP_MEMORDER_UNSET)) != MATCH_NO) { if (m == MATCH_ERROR) goto error; - c->memorder = OMP_MEMORDER_SEQ_CST; + if (bval) + c->memorder = OMP_MEMORDER_SEQ_CST; continue; } if ((mask & OMP_CLAUSE_SHARED) @@ -4711,11 +4841,16 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, continue; } if ((mask & OMP_CLAUSE_SIMD) - && (m = gfc_match_dupl_check (!c->simd, "simd")) != MATCH_NO) + && ((m = gfc_match_boolean_clause (&bval, "simd", + c->simd || cfalse->simd)) + != MATCH_NO)) { if (m == MATCH_ERROR) goto error; - c->simd = true; + if (bval) + c->simd = true; + else + cfalse->simd = false; continue; } if ((mask & OMP_CLAUSE_SEVERITY) @@ -4864,12 +4999,16 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, continue; } if ((mask & OMP_CLAUSE_THREADS) - && (m = gfc_match_dupl_check (!c->threads, "threads")) - != MATCH_NO) + && ((m = gfc_match_boolean_clause (&bval, "threads", + c->threads || cfalse->threads)) + != MATCH_NO)) { if (m == MATCH_ERROR) goto error; - c->threads = true; + if (bval) + c->threads = true; + else + cfalse->threads = false; continue; } if ((mask & OMP_CLAUSE_TILE) @@ -4905,21 +5044,26 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, false) == MATCH_YES) continue; if ((mask & OMP_CLAUSE_UNTIED) - && (m = gfc_match_dupl_check (!c->untied, "untied")) != MATCH_NO) + && ((m = gfc_match_boolean_clause (&bval, "untied", + c->untied || cfalse->untied)) + != MATCH_NO)) { if (m == MATCH_ERROR) goto error; - c->untied = true; + if (bval) + c->untied = true; + else + cfalse->untied = true; continue; } if ((mask & OMP_CLAUSE_ATOMIC) - && (m = gfc_match_dupl_atomic ((c->atomic_op - == GFC_OMP_ATOMIC_UNSET), - "update")) != MATCH_NO) + && (m = gfc_match_dupl_atomic (&bval, "update", + c->atomic_op != GFC_OMP_ATOMIC_UNSET)) != MATCH_NO) { if (m == MATCH_ERROR) goto error; - c->atomic_op = GFC_OMP_ATOMIC_UPDATE; + if (bval) + c->atomic_op = GFC_OMP_ATOMIC_UPDATE; continue; } if ((mask & OMP_CLAUSE_USE) @@ -4999,12 +5143,16 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, continue; } if ((mask & OMP_CLAUSE_WEAK) - && (m = gfc_match_dupl_check (!c->weak, "weak")) - != MATCH_NO) + && ((m = gfc_match_boolean_clause (&bval, "weak", + c->weak || cfalse->weak)) + != MATCH_NO)) { if (m == MATCH_ERROR) goto error; - c->weak = true; + if (bval) + c->weak = true; + else + cfalse->weak = true; continue; } if ((mask & OMP_CLAUSE_WORKER) @@ -5019,13 +5167,13 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, continue; } if ((mask & OMP_CLAUSE_ATOMIC) - && (m = gfc_match_dupl_atomic ((c->atomic_op - == GFC_OMP_ATOMIC_UNSET), - "write")) != MATCH_NO) + && (m = gfc_match_dupl_atomic (&bval, "write", + c->atomic_op != GFC_OMP_ATOMIC_UNSET)) != MATCH_NO) { if (m == MATCH_ERROR) goto error; - c->atomic_op = GFC_OMP_ATOMIC_WRITE; + if (bval) + c->atomic_op = GFC_OMP_ATOMIC_WRITE; continue; } break; @@ -5034,6 +5182,8 @@ gfc_match_omp_clauses (gfc_omp_clauses **cp, const omp_mask mask, } end: + if (cfalse) + gfc_free_omp_clauses (cfalse); if (error || gfc_match_omp_eos () != MATCH_YES) { if (!gfc_error_flag_test ()) @@ -6245,41 +6395,74 @@ gfc_match_omp_flush (void) gfc_omp_clauses *c = NULL; gfc_gobble_whitespace (); enum gfc_omp_memorder mo = OMP_MEMORDER_UNSET; - if (gfc_match_omp_eos () == MATCH_NO && gfc_peek_ascii_char () != '(') + if (gfc_match_omp_variable_list (" (", &list, true) == MATCH_ERROR) + return MATCH_ERROR; + match m = MATCH_YES; + while (gfc_match_omp_eos () != MATCH_YES) { + gfc_gobble_whitespace (); gfc_match (", "); /* optionally */ - if (gfc_match ("seq_cst") == MATCH_YES) - mo = OMP_MEMORDER_SEQ_CST; - else if (gfc_match ("acq_rel") == MATCH_YES) - mo = OMP_MEMORDER_ACQ_REL; - else if (gfc_match ("release") == MATCH_YES) - mo = OMP_MEMORDER_RELEASE; - else if (gfc_match ("acquire") == MATCH_YES) - mo = OMP_MEMORDER_ACQUIRE; - else - { - gfc_error ("Expected SEQ_CST, AQC_REL, RELEASE, or ACQUIRE at %C"); - return MATCH_ERROR; + enum gfc_omp_memorder mo2 = OMP_MEMORDER_UNSET; + bool bval = false; + locus loc = gfc_current_locus; + if ((m = gfc_match_dupl_memorder (&bval, "seq_cst", + mo != OMP_MEMORDER_UNSET)) != MATCH_NO) + mo2 = OMP_MEMORDER_SEQ_CST; + else if ((m = gfc_match_dupl_memorder (&bval, "acq_rel", + mo != OMP_MEMORDER_UNSET)) + != MATCH_NO) + mo2 = OMP_MEMORDER_ACQ_REL; + else if ((m = gfc_match_dupl_memorder (&bval, "release", + mo != OMP_MEMORDER_UNSET)) + != MATCH_NO) + mo2 = OMP_MEMORDER_RELEASE; + else if ((m = gfc_match_dupl_memorder (&bval, "acquire", + mo != OMP_MEMORDER_UNSET)) + != MATCH_NO) + mo2 = OMP_MEMORDER_ACQUIRE; + else if ((m = gfc_match_dupl_memorder (&bval, "relaxed", + mo != OMP_MEMORDER_UNSET)) + != MATCH_NO) + { + if (m == MATCH_YES && bval) + { + /* relaxed only permitted with 'false'. */ + gfc_current_locus = loc; + m = MATCH_NO; + break; + } } - c = gfc_get_omp_clauses (); - c->memorder = mo; + else + break; + if (m == MATCH_ERROR) + return MATCH_ERROR; + if (bval) + mo = mo2; + } + if (m == MATCH_NO) + { + gfc_error ("Expected SEQ_CST, AQC_REL, RELEASE, or ACQUIRE at %C"); + gfc_free_omp_namelist (list, OMP_LIST_NONE); + return MATCH_ERROR; } - gfc_match_omp_variable_list (" (", &list, true); if (list && mo != OMP_MEMORDER_UNSET) { gfc_error ("List specified together with memory order clause in FLUSH " "directive at %C"); gfc_free_omp_namelist (list, OMP_LIST_NONE); - gfc_free_omp_clauses (c); return MATCH_ERROR; } if (gfc_match_omp_eos () != MATCH_YES) { gfc_error ("Unexpected junk after $OMP FLUSH statement at %C"); gfc_free_omp_namelist (list, OMP_LIST_NONE); - gfc_free_omp_clauses (c); return MATCH_ERROR; } + if (mo != OMP_MEMORDER_UNSET) + { + c = gfc_get_omp_clauses (); + c->memorder = mo; + } new_st.op = EXEC_OMP_FLUSH; new_st.ext.omp_namelist = list; new_st.ext.omp_clauses = c; @@ -8436,9 +8619,10 @@ gfc_match_omp_requires (void) "unified_shared_memory", "self_maps", "dynamic_allocators", - "atomic_default"}; + "atomic_default_mem_order"}; const char *clause = NULL; int requires_clauses = 0; + int seen_clauses = 0; bool first = true; locus old_loc; @@ -8457,10 +8641,15 @@ gfc_match_omp_requires (void) return MATCH_ERROR; } + /* Specifying '(.false.)' in this directive does not affect requirements + set in another 'requires' directive in the same compilation unit; however, + specifying it multiple times in the same directive is disallowed. */ while (true) { + bool bval; + match m; old_loc = gfc_current_locus; - gfc_omp_requires_kind requires_clause; + gfc_omp_requires_kind requires_clause = OMP_REQ_NONE; if (gfc_match_char (',') != MATCH_YES && (first && gfc_match_space () != MATCH_YES)) goto error; @@ -8470,46 +8659,64 @@ gfc_match_omp_requires (void) if (gfc_match_omp_eos () != MATCH_NO) break; - if (gfc_match (clauses[0]) == MATCH_YES) + if ((m = gfc_match_boolean_clause (&bval, clauses[0], + seen_clauses & OMP_REQ_REVERSE_OFFLOAD)) != MATCH_NO) { + if (m == MATCH_ERROR) + goto error; clause = clauses[0]; - requires_clause = OMP_REQ_REVERSE_OFFLOAD; - if (requires_clauses & OMP_REQ_REVERSE_OFFLOAD) - goto duplicate_clause; + seen_clauses |= OMP_REQ_REVERSE_OFFLOAD; + if (bval) + requires_clause = OMP_REQ_REVERSE_OFFLOAD; } - else if (gfc_match (clauses[1]) == MATCH_YES) + else if ((m = gfc_match_boolean_clause (&bval, clauses[1], + seen_clauses & OMP_REQ_UNIFIED_ADDRESS)) != MATCH_NO) { + if (m == MATCH_ERROR) + goto error; clause = clauses[1]; - requires_clause = OMP_REQ_UNIFIED_ADDRESS; - if (requires_clauses & OMP_REQ_UNIFIED_ADDRESS) - goto duplicate_clause; + seen_clauses |= OMP_REQ_UNIFIED_ADDRESS; + if (bval) + requires_clause = OMP_REQ_UNIFIED_ADDRESS; } - else if (gfc_match (clauses[2]) == MATCH_YES) + else if ((m = gfc_match_boolean_clause (&bval, clauses[2], + seen_clauses & OMP_REQ_UNIFIED_SHARED_MEMORY)) + != MATCH_NO) { + if (m == MATCH_ERROR) + goto error; clause = clauses[2]; - requires_clause = OMP_REQ_UNIFIED_SHARED_MEMORY; - if (requires_clauses & OMP_REQ_UNIFIED_SHARED_MEMORY) - goto duplicate_clause; + seen_clauses |= OMP_REQ_UNIFIED_SHARED_MEMORY; + if (bval) + requires_clause = OMP_REQ_UNIFIED_SHARED_MEMORY; } - else if (gfc_match (clauses[3]) == MATCH_YES) + else if ((m = gfc_match_boolean_clause (&bval, clauses[3], + seen_clauses & OMP_REQ_SELF_MAPS)) != MATCH_NO) { + if (m == MATCH_ERROR) + goto error; clause = clauses[3]; - requires_clause = OMP_REQ_SELF_MAPS; - if (requires_clauses & OMP_REQ_SELF_MAPS) - goto duplicate_clause; + seen_clauses |= OMP_REQ_SELF_MAPS; + if (bval) + requires_clause = OMP_REQ_SELF_MAPS; } - else if (gfc_match (clauses[4]) == MATCH_YES) + else if ((m = gfc_match_boolean_clause (&bval, clauses[4], + seen_clauses & OMP_REQ_DYNAMIC_ALLOCATORS)) != MATCH_NO) { + if (m == MATCH_ERROR) + goto error; clause = clauses[4]; - requires_clause = OMP_REQ_DYNAMIC_ALLOCATORS; - if (requires_clauses & OMP_REQ_DYNAMIC_ALLOCATORS) - goto duplicate_clause; + seen_clauses |= OMP_REQ_DYNAMIC_ALLOCATORS; + if (bval) + requires_clause = OMP_REQ_DYNAMIC_ALLOCATORS; } - else if (gfc_match ("atomic_default_mem_order (") == MATCH_YES) + else if ((m = gfc_match_dupl_check ( + !(seen_clauses & OMP_REQ_ATOMIC_MEM_ORDER_MASK), + clauses[5], true)) != MATCH_NO) { - clause = clauses[5]; - if (requires_clauses & OMP_REQ_ATOMIC_MEM_ORDER_MASK) - goto duplicate_clause; + if (m == MATCH_ERROR) + goto error; + seen_clauses |= OMP_REQ_ATOMIC_MEM_ORDER_MASK; if (gfc_match (" seq_cst )") == MATCH_YES) { clause = "seq_cst"; @@ -8545,21 +8752,16 @@ gfc_match_omp_requires (void) else goto error; - if (!gfc_omp_requires_add_clause (requires_clause, clause, &old_loc, NULL)) + if (requires_clause != OMP_REQ_NONE + && !gfc_omp_requires_add_clause (requires_clause, clause, &old_loc, NULL)) goto error; requires_clauses |= requires_clause; } if (requires_clauses == 0) - { - if (!gfc_error_flag_test ()) - gfc_error ("Clause expected at %C"); - goto error; - } + goto error; return MATCH_YES; -duplicate_clause: - gfc_error ("%qs clause at %L specified more than once", clause, &old_loc); error: if (!gfc_error_flag_test ()) gfc_error ("Expected UNIFIED_ADDRESS, UNIFIED_SHARED_MEMORY, SELF_MAPS, " diff --git a/gcc/testsuite/gfortran.dg/gomp/atomic-18.f90 b/gcc/testsuite/gfortran.dg/gomp/atomic-18.f90 index 9bc6f637aca0..6c8f44a1e9e2 100644 --- a/gcc/testsuite/gfortran.dg/gomp/atomic-18.f90 +++ b/gcc/testsuite/gfortran.dg/gomp/atomic-18.f90 @@ -5,9 +5,9 @@ module m contains subroutine foo (j) integer, value :: j - !$omp atomic update,update ! { dg-error "Duplicated atomic clause: unexpected update clause" } + !$omp atomic update,update ! { dg-error "Duplicated atomic clause: unexpected 'update' clause" } i = i + 1 - !$omp atomic seq_cst release ! { dg-error "Duplicated memory-order clause: unexpected release clause" } + !$omp atomic seq_cst release ! { dg-error "Duplicated memory-order clause: unexpected 'release' clause" } i = i + 1 !$omp atomic read,release ! { dg-error "ATOMIC READ at .1. incompatible with RELEASE clause" } v = i diff --git a/gcc/testsuite/gfortran.dg/gomp/clause-logical-arg-1.f90 b/gcc/testsuite/gfortran.dg/gomp/clause-logical-arg-1.f90 new file mode 100644 index 000000000000..2ef4d0f34277 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/gomp/clause-logical-arg-1.f90 @@ -0,0 +1,109 @@ +! { dg-do compile } + +module m + implicit none + !$omp requires dynamic_allocators(.true.), reverse_offload(.false.), self_maps(.false.), unified_address(.false.), unified_shared_memory(.false.) + !$omp requires dynamic_allocators(.false.), reverse_offload(.true.), self_maps(.true.), unified_address(.true.), unified_shared_memory(.true.) + !$omp assumes no_openmp(.false.), no_openmp_constructs(.false.) no_openmp_routines(.false.) no_parallelism(.false.) + !$omp assumes no_openmp(.true.), no_openmp_constructs(.true.) no_openmp_routines(.true.) no_parallelism(.true.) + integer :: x +contains +subroutine branch1 + !$omp declare simd notinbranch(.false.) +end +subroutine branch2 + !$omp declare simd notinbranch(.true.) +end +subroutine branch3 + !$omp declare simd notinbranch(.false.) +end +subroutine branch4 + !$omp declare simd notinbranch(.true.) +end +subroutine foo + integer :: y, r + !$omp atomic read(.false.) update(.false.) write(.false.) acq_rel(.false.), acquire(.false.), relaxed ( .true. ), release (.false.), seq_cst(.false.) weak(.false.) capture(.false.) compare(.false.) + x = x + 1 + !$omp atomic read(.false.) update(.true.) write(.false.) acq_rel(.false.), acquire(.false.), relaxed ( .false. ), release (.false.), seq_cst(.true.) weak(.false.) capture( .false. ), compare( .false. ) + x = x + 1 + !$omp atomic read(.true.) update(.false.) write(.false.) acq_rel(.false.), acquire(.true.), relaxed ( .false. ), release (.false.), seq_cst(.false.) + y = x + !$omp atomic read(.false.) update(.false.) write(.true.) acq_rel(.true.), acquire(.false.), relaxed ( .false. ), release (.false.), seq_cst(.false.) + x = y + 1 + !$omp atomic read(.false.) update(.false.) write(.true.) acq_rel(.false.), acquire(.false.), relaxed ( .false. ), release (.false.), seq_cst(.false.) + x = y + 1 + + !$omp atomic read(.false.) update write(.false.) acq_rel(.false.), acquire(.false.), relaxed ( .false. ), release (.false.), seq_cst(.true.) weak(.false.) capture( .false. ), compare( .false. ) + x = x + 1 + !$omp atomic read,update(.false.) write(.false.) acq_rel(.false.), acquire(.true.), relaxed ( .false. ), release (.false.), seq_cst(.false.) + y = x + !$omp atomic read(.false.) update(.false.) write acq_rel(.true.), acquire(.false.), relaxed ( .false. ), release (.false.), seq_cst(.false.) + x = y + 1 + + !$omp atomic compare(.true.) weak(.true.) + if (x == y) x = 5 + + ! Flush: relaxed(.true.) not permitted + !$omp flush acq_rel(.true.) , acquire(.false.), relaxed ( .false. ), release (.false.), seq_cst(.false.) + !$omp flush acq_rel, acquire(.false.), relaxed ( .false. ), release (.false.), seq_cst(.false.) + !$omp flush acq_rel(.false.), acquire(.true.), relaxed ( .false. ), release (.false.), seq_cst(.false.) + !$omp flush acq_rel(.false.), acquire , relaxed ( .false. ), release (.false.), seq_cst(.false.) + !$omp flush acq_rel(.false.), acquire(.false.), relaxed ( .false. ), release (.true.), seq_cst(.false.) + !$omp flush acq_rel(.false.), acquire(.false.), relaxed ( .false. ), release , seq_cst(.false.) + !$omp flush acq_rel(.false.), acquire(.false.), relaxed ( .false. ), release (.false.), seq_cst(.true.) + !$omp flush acq_rel(.false.), acquire(.false.), relaxed ( .false. ), release (.false.), seq_cst + + !$omp unroll full(.false.) + do y = 1, x + end do + + !$omp unroll full(.true.) + do y = 1, 5 + end do +end +subroutine sub + !$omp ordered threads(.false.),simd(.false.) + !$omp end ordered + !$omp ordered threads(.true.),simd(.false.) + !$omp end ordered + !$omp ordered threads(.false.),simd(.true.) + !$omp end ordered + !$omp ordered threads(.true.),simd(.true.) + !$omp end ordered +end subroutine sub + +subroutine other + !$omp task untied(.true.) + !$omp end task + !$omp task untied(.false.) + !$omp end task +end +end module + + +!Memorder: acq_rel, acquire, relaxed, release, seq_cst +! atomic flush +! +!atomic: +! read, update, write +! +!Extended atomic: capture, compare, weak (+fail) +! atomic +! +!requirement: [device_safesync,] dynamic_allocators, reverse_offload, self_maps, unified_address, unified_shared_memory (+ atomic_default_mem_order) +! requires +! +!branch: inbranch, notinbranch +! declare_simd +! +!assumptions: no_openmp, no_openmp_constructs, no_openmp_routines, no_parallelism +! assume(s) +! +!parallelization-level: threads, simd +! ordered +! +!full +! unroll +! +!untied +! task, taskloop diff --git a/gcc/testsuite/gfortran.dg/gomp/clause-logical-arg-2.f90 b/gcc/testsuite/gfortran.dg/gomp/clause-logical-arg-2.f90 new file mode 100644 index 000000000000..c582a334d5c3 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/gomp/clause-logical-arg-2.f90 @@ -0,0 +1,73 @@ +! { dg-do compile } + +module m + implicit none + !$omp requires dynamic_allocators(.false.), reverse_offload(.false.), self_maps(.false.), unified_address(.false.), unified_shared_memory(.false.) ! { dg-error "Expected UNIFIED_ADDRESS, UNIFIED_SHARED_MEMORY, SELF_MAPS, DYNAMIC_ALLOCATORS, REVERSE_OFFLOAD, or ATOMIC_DEFAULT_MEM_ORDER clause" } + !$omp requires self_maps(.true.), self_maps(.true.) ! { dg-error "Duplicated 'self_maps' clause" } + !$omp requires unified_address(.false.), unified_address(.false.) ! { dg-error "Duplicated 'unified_address' clause" } + !$omp requires reverse_offload(.false.), reverse_offload(.true.) ! { dg-error "Duplicated 'reverse_offload' clause" } + !$omp requires self_maps, self_maps(.true.) ! { dg-error "Duplicated 'self_maps' clause" } + !$omp requires self_maps(.true.), self_maps ! { dg-error "Duplicated 'self_maps' clause" } + !$omp requires self_maps, self_maps ! { dg-error "Duplicated 'self_maps' clause" } + integer :: x +contains +subroutine branch1 + !$omp declare simd inbranch(.false.) notinbranch(.false.) ! { dg-error "Duplicated branch clause: unexpected 'notinbranch' clause" } +end +subroutine branch2 + !$omp declare simd inbranch(.false.) notinbranch(.true.) ! { dg-error "Duplicated branch clause: unexpected 'notinbranch' clause" } +end +subroutine branch3 + !$omp declare simd notinbranch(.false.) inbranch(.true.) ! { dg-error "Duplicated branch clause: unexpected 'inbranch' clause" } +end +subroutine branch4 + !$omp declare simd notinbranch(.true.) inbranch(.true.) ! { dg-error "Duplicated branch clause: unexpected 'inbranch' clause" } +end +subroutine foo + integer :: y, r + !$omp atomic read(.false.) update write(.true.) ! { dg-error "Duplicated atomic clause: unexpected 'write' clause" } + x = x + 1 + !$omp atomic read(.false.) update(.true.) write(.true.) ! { dg-error "Duplicated atomic clause: unexpected 'write' clause" } + x = x + 1 + !$omp atomic write(.false.) write(.true.) + y = x + !$omp atomic write write(.false.) + y = x + !$omp atomic write write(.true.) ! { dg-error "Duplicated atomic clause: unexpected 'write' clause" } + y = x + + !$omp atomic acq_rel(.false.), acquire(.false.), relaxed ( .true. ), release ! { dg-error "Duplicated memory-order clause: unexpected 'release' clause" } + x = x + 1 + + ! Flush: relaxed(.true.) not permitted + !$omp flush(y), acq_rel(.true.) ! { dg-error "List specified together with memory order clause in FLUSH directive" } + !$omp flush relaxed ! { dg-error "Expected SEQ_CST, AQC_REL, RELEASE, or ACQUIRE" } + !$omp flush + !$omp flush other ! { dg-error "Expected SEQ_CST, AQC_REL, RELEASE, or ACQUIRE" } + + !$omp flush acq_rel(.true.), acquire(.true.) ! { dg-error "Duplicated memory-order clause: unexpected 'acquire' clause" } + + !$omp unroll full(.true.) full(.false.) ! { dg-error "Duplicated 'full' clause" } + do y = 1, x + end do + + !$omp unroll full(.true.) full(.true.) ! { dg-error "Duplicated 'full' clause" } + do y = 1, 5 + end do + + !$omp unroll full( ! { dg-error "Expected '\\( const-logical-expr \\)'" } + do y = 1, 5; end do + + !$omp unroll full(1 ! { dg-error "Expected '\\( const-logical-expr \\)'" } + do y = 1, 5; end do + + !$omp unroll full(x > 0) ! { dg-error "Expected '\\( const-logical-expr \\)'" } + do y = 1, 5; end do + + !$omp unroll full(5) ! { dg-error "Expected '\\( const-logical-expr \\)'" } + do y = 1, 5; end do + + !$omp unroll full([.true.]) ! { dg-error "Expected '\\( const-logical-expr \\)'" } + do y = 1, 5; end do +end +end module diff --git a/gcc/testsuite/gfortran.dg/gomp/declare-simd-1.f90 b/gcc/testsuite/gfortran.dg/gomp/declare-simd-1.f90 index 04abd5128f5d..9658409f33d6 100644 --- a/gcc/testsuite/gfortran.dg/gomp/declare-simd-1.f90 +++ b/gcc/testsuite/gfortran.dg/gomp/declare-simd-1.f90 @@ -2,7 +2,7 @@ subroutine fn1 (x) integer :: x -!$omp declare simd (fn1) inbranch notinbranch uniform (x) ! { dg-error "Duplicated 'notinbranch' clause" } +!$omp declare simd (fn1) inbranch notinbranch uniform (x) ! { dg-error "Duplicated branch clause: unexpected 'notinbranch' clause" } end subroutine fn1 subroutine fn2 (x) !$omp declare simd (fn100) ! { dg-error "should refer to containing procedure" } diff --git a/gcc/testsuite/gfortran.dg/gomp/declare-target-indirect-1.f90 b/gcc/testsuite/gfortran.dg/gomp/declare-target-indirect-1.f90 index b50fb37027f5..3d77e2c62f8a 100644 --- a/gcc/testsuite/gfortran.dg/gomp/declare-target-indirect-1.f90 +++ b/gcc/testsuite/gfortran.dg/gomp/declare-target-indirect-1.f90 @@ -23,12 +23,12 @@ subroutine sub3 end subroutine subroutine sub4 - !$omp declare target to (sub4) indirect (1) ! { dg-error "INDIRECT clause at .1. requires a constant logical expression" } + !$omp declare target to (sub4) indirect (1) ! { dg-error "Expected '\\( const-logical-expr \\)'" } end subroutine ! Compile-time non-constant expressions are not allowed. subroutine sub5 - !$omp declare target indirect (a > 0) to (sub5) ! { dg-error "INDIRECT clause at .1. requires a constant logical expression" } + !$omp declare target indirect (a > 0) to (sub5) ! { dg-error "Expected '\\( const-logical-expr \\)'" } end subroutine ! Compile-time constant expressions are permissible. @@ -45,11 +45,11 @@ subroutine sub8 end subroutine subroutine sub9 - !$omp declare target to (sub9) indirect ("abs") ! { dg-error "INDIRECT clause at .1. requires a constant logical expression" } + !$omp declare target to (sub9) indirect ("abs") ! { dg-error "Expected '\\( const-logical-expr \\)'" } end subroutine subroutine sub10 - !$omp declare target to (sub10) indirect (5.5) ! { dg-error "INDIRECT clause at .1. requires a constant logical expression" } + !$omp declare target to (sub10) indirect (5.5) ! { dg-error "Expected '\\( const-logical-expr \\)'" } end subroutine subroutine sub11 diff --git a/gcc/testsuite/gfortran.dg/gomp/flush-2.f90 b/gcc/testsuite/gfortran.dg/gomp/flush-2.f90 index ba234448a60d..6a5c0ac67bba 100644 --- a/gcc/testsuite/gfortran.dg/gomp/flush-2.f90 +++ b/gcc/testsuite/gfortran.dg/gomp/flush-2.f90 @@ -12,8 +12,8 @@ subroutine foo (void) !$omp flush seq_cst !$omp flush relaxed ! { dg-error "Expected SEQ_CST, AQC_REL, RELEASE, or ACQUIRE" } !$omp flush foobar ! { dg-error "Expected SEQ_CST, AQC_REL, RELEASE, or ACQUIRE" } - !$omp flush acquire (a, b) ! { dg-error "List specified together with memory order clause in FLUSH directive" } - !$omp flush release (a, b) ! { dg-error "List specified together with memory order clause in FLUSH directive" } - !$omp flush acq_rel (a, b) ! { dg-error "List specified together with memory order clause in FLUSH directive" } - !$omp flush seq_cst (a, b) ! { dg-error "List specified together with memory order clause in FLUSH directive" } + !$omp flush acquire (a, b) ! { dg-error "Expected '\\( const-logical-expr \\)'" } + !$omp flush release (a, b) ! { dg-error "Expected '\\( const-logical-expr \\)'" } + !$omp flush acq_rel (a, b) ! { dg-error "Expected '\\( const-logical-expr \\)'" } + !$omp flush seq_cst (a, b) ! { dg-error "Expected '\\( const-logical-expr \\)'" } end diff --git a/gcc/testsuite/gfortran.dg/gomp/requires-2.f90 b/gcc/testsuite/gfortran.dg/gomp/requires-2.f90 index ed9f8ea352a7..cdd0eadf6a76 100644 --- a/gcc/testsuite/gfortran.dg/gomp/requires-2.f90 +++ b/gcc/testsuite/gfortran.dg/gomp/requires-2.f90 @@ -1,10 +1,10 @@ -!$omp requires ! { dg-error "Clause expected" } -!$omp requires unified_shared_memory,unified_shared_memory ! { dg-error "specified more than once" } -!$omp requires unified_address unified_address ! { dg-error "specified more than once" } -!$omp requires reverse_offload reverse_offload ! { dg-error "specified more than once" } +!$omp requires ! { dg-error "Expected UNIFIED_ADDRESS, UNIFIED_SHARED_MEMORY, SELF_MAPS, DYNAMIC_ALLOCATORS, REVERSE_OFFLOAD, or ATOMIC_DEFAULT_MEM_ORDER clause" } +!$omp requires unified_shared_memory,unified_shared_memory ! { dg-error "Duplicated 'unified_shared_memory' clause" } +!$omp requires unified_address unified_address ! { dg-error "Duplicated 'unified_address' clause" } +!$omp requires reverse_offload reverse_offload ! { dg-error "Duplicated 'reverse_offload' clause" } !$omp requires foobarbaz ! { dg-error "Expected UNIFIED_ADDRESS, UNIFIED_SHARED_MEMORY, SELF_MAPS, DYNAMIC_ALLOCATORS, REVERSE_OFFLOAD, or ATOMIC_DEFAULT_MEM_ORDER clause" } -!$omp requires dynamic_allocators , dynamic_allocators ! { dg-error "specified more than once" } -!$omp requires atomic_default_mem_order(seq_cst) atomic_default_mem_order(seq_cst) ! { dg-error "specified more than once" } +!$omp requires dynamic_allocators , dynamic_allocators ! { dg-error "Duplicated 'dynamic_allocators' clause" } +!$omp requires atomic_default_mem_order(seq_cst) atomic_default_mem_order(seq_cst) ! { dg-error "Duplicated 'atomic_default_mem_order' clause" } !$omp requires atomic_default_mem_order (seq_cst) !$omp requires atomic_default_mem_order (seq_cst) !$omp requires atomic_default_mem_order (acq_rel) ! { dg-error "overrides a previous 'atomic_default_mem_order\\(seq_cst\\)'" } diff --git a/libgomp/libgomp.texi b/libgomp/libgomp.texi index 7f34a36e38b7..2d6cc737840c 100644 --- a/libgomp/libgomp.texi +++ b/libgomp/libgomp.texi @@ -483,7 +483,8 @@ to address of matching mapped list item per 5.1, Sect. 2.21.7.2 @tab N @tab @item The OpenMP directive syntax was extended to include C23 attribute specifiers @tab Y @tab @item Support for pure directives in Fortran's @code{do concurrent} @tab N @tab -@item All inarguable clauses take now an optional Boolean argument @tab N @tab +@item All inarguable clauses take now an optional Boolean argument @tab P @tab + Only Fortran @item The @code{adjust_args} clause was extended to specify the argument by position and supports variadic arguments @tab N @tab @item For Fortran, @emph{locator list} can be also function reference with From 074937c853850cef4281931b6709f95098a486c9 Mon Sep 17 00:00:00 2001 From: Gaius Mulley Date: Sat, 26 Sep 2026 12:18:44 +0100 Subject: [PATCH 446/584] PR modula2/127622: spell checking candidates should include base module and types This patch ensures that the base module is pushed first and that the scope check code does not stop at a module boundary. The patch also allows symbols to be filtered on variables, types and constants. gcc/m2/ChangeLog: PR modula2/127622 * gm2-compiler/M2Base.mod (CheckCompatible): Rename t1 to left. Rename t2 to right. Add spellcheck hint format specifiers to unknown types. * gm2-compiler/M2MetaError.mod (ConfigureFilter): New procedure. (errorBlock): filterVar new field. filterType new field. filterConst new field. (continuation): Add T V C filter modifiers. (FilterOnType): New procedure. (FilterOnVariable): Ditto. (FilrerOnConst): Ditto. (SpellHint): Call ConfigureFilter. * gm2-compiler/M2StackSpell.def (FilterType): New procedure. (FilterVariable): Ditto. (FilrerConst): Ditto. * gm2-compiler/M2StackSpell.mod (FilterKind): New type. (FilterSet): Ditto. (CurrentFilter): New variable. (PushNameFilter): New procedure. (PushCandidates): Pass PushNameFilter as callback. (GetSpellHintFilter): New procedure. (GetSpellHint): Reimplement. (FilterType): New procedure. (FilterVariable): Ditto. (FilterConst): Ditto. (Init): Initialize CurrentFilter. * gm2-compiler/P3SymBuild.mod (P3StartBuildDefModule): Push base module. (P3EndBuildDefModule): Pop base module. (P3StartBuildImpModule): Push base module. (P3EndBuildImpModule): Pop base module. (P3StartBuildProgModule): Push base module. (P3EndBuildProgModule): Pop base module. (StartBuildInnerModule): Push base module. (EndBuildInnerModule): Pop base module. * gm2-compiler/PCSymBuild.mod (PCEndBuildDefModule): Pop base module. (PCStartBuildImpModule): Push base module. (PCEndBuildImpModule): Pop base module. (PCStartBuildProgModule): Push base module. (PCEndBuildProgModule): Pop base module. (StartBuildInnerModule): Push base module. (EndBuildInnerModule): Pop base module. gcc/testsuite/ChangeLog: PR modula2/127622 * gm2.dg/spell/iso/fail/badspelltype.mod: New test. * gm2.dg/spell/iso/fail/badspelltype2.mod: New test. Signed-off-by: Gaius Mulley --- gcc/m2/gm2-compiler/M2Base.mod | 36 +++--- gcc/m2/gm2-compiler/M2MetaError.mod | 73 +++++++++++- gcc/m2/gm2-compiler/M2StackSpell.def | 39 +++++-- gcc/m2/gm2-compiler/M2StackSpell.mod | 105 +++++++++++++++--- gcc/m2/gm2-compiler/P3SymBuild.mod | 10 +- gcc/m2/gm2-compiler/PCSymBuild.mod | 10 +- .../gm2.dg/spell/iso/fail/badspelltype.mod | 15 +++ .../gm2.dg/spell/iso/fail/badspelltype2.mod | 18 +++ 8 files changed, 262 insertions(+), 44 deletions(-) create mode 100644 gcc/testsuite/gm2.dg/spell/iso/fail/badspelltype.mod create mode 100644 gcc/testsuite/gm2.dg/spell/iso/fail/badspelltype2.mod diff --git a/gcc/m2/gm2-compiler/M2Base.mod b/gcc/m2/gm2-compiler/M2Base.mod index e2862cdd0732..51c08955c3a9 100644 --- a/gcc/m2/gm2-compiler/M2Base.mod +++ b/gcc/m2/gm2-compiler/M2Base.mod @@ -1198,12 +1198,12 @@ END EmitTypeIncompatibleError ; *) PROCEDURE CheckCompatible (tok: CARDINAL; - t1, t2: CARDINAL; kind: Compatability) ; + left, right: CARDINAL; kind: Compatability) ; VAR s: String ; r: Compatible ; BEGIN - r := IsCompatible (t1, t2, kind) ; + r := IsCompatible (left, right, kind) ; IF (r#first) AND (r#second) THEN IF (r=warnfirst) OR (r=warnsecond) @@ -1212,27 +1212,31 @@ BEGIN ELSE s := InitString('') END ; - IF IsUnknown(t1) AND IsUnknown(t2) + IF IsUnknown (left) AND IsUnknown (right) THEN - (* --fixme-- spellcheck. *) - s := ConCat(s, InitString('two different unknown types {%1a:{%2a:{%1a} and {%2a}}} must either be declared or imported)')) ; - MetaErrorStringT2 (tok, s, t1, t2) - ELSIF IsUnknown(t1) + (* Spellcheck. *) + s := ConCat(s, InitString('two different unknown types' + + ' {%1a:{%2a:{%1a} and {%2a}}} must either be declared' + + ' or imported {%1&Ts} {%2&Ts}')) ; + MetaErrorStringT2 (tok, s, left, right) + ELSIF IsUnknown (left) THEN - (* --fixme-- spellcheck. *) - s := ConCat(s, InitString('this type {%1a} is currently unknown, it must be declared or imported')) ; - MetaErrorStringT1 (tok, s, t1) - ELSIF IsUnknown(t2) + (* Spellcheck. *) + s := ConCat(s, InitString('this type {%1a} is currently unknown,' + + ' it must be declared or imported {%1&Ts}')) ; + MetaErrorStringT1 (tok, s, left) + ELSIF IsUnknown (right) THEN - (* --fixme-- spellcheck. *) - s := ConCat (s, InitString('this type {%1a} is currently unknown, it must be declared or imported')) ; - MetaErrorStringT1 (tok, s, t2) + (* Spellcheck. *) + s := ConCat (s, InitString('this type {%1a} is currently unknown,' + + ' it must be declared or imported {%1&Ts}')) ; + MetaErrorStringT1 (tok, s, right) ELSE IF (r=warnfirst) OR (r=warnsecond) THEN - EmitTypeIncompatibleWarning (tok, kind, t1, t2) + EmitTypeIncompatibleWarning (tok, kind, left, right) ELSE - EmitTypeIncompatibleError (tok, kind, t1, t2) + EmitTypeIncompatibleError (tok, kind, left, right) END END END diff --git a/gcc/m2/gm2-compiler/M2MetaError.mod b/gcc/m2/gm2-compiler/M2MetaError.mod index b270f7ca64aa..6298718f7da4 100644 --- a/gcc/m2/gm2-compiler/M2MetaError.mod +++ b/gcc/m2/gm2-compiler/M2MetaError.mod @@ -73,7 +73,9 @@ IMPORT M2Error ; IMPORT FilterError ; FROM FilterError IMPORT Filter, AddSymError, IsSymError ; -FROM M2StackSpell IMPORT GetDefModuleSpellHint, GetSpellHint ; + +FROM M2StackSpell IMPORT GetDefModuleSpellHint, GetSpellHint, + FilterConst, FilterVariable, FilterType ; CONST @@ -101,6 +103,9 @@ TYPE ini : INTEGER ; vowel, filterDef, + filterVar, + filterType, + filterConst, importHint, exportHint, withStackHint, @@ -534,7 +539,10 @@ BEGIN ini := 0 ; glyph := FALSE ; (* Nothing to output yet. *) vowel := FALSE ; (* Check for a vowel when outputing string? *) - filterDef := FALSE ; (* Filter on definition module list? *) + filterDef := FALSE ; (* Filter on definition module list. *) + filterType := FALSE ; (* Filter on type. *) + filterConst := FALSE ; (* Filter on const. *) + filterVar := FALSE ; (* Filter on variable. *) importHint := FALSE; exportHint := FALSE ; withStackHint := FALSE ; @@ -1842,7 +1850,7 @@ END op ; (* - continuation := {':'|'1'|'2'|'3'|'4'|'i'|'s'|'x'|'w'|'D'} =: + continuation := {':'|'1'|'2'|'3'|'4'|'i'|'s'|'x'|'w'|'D'|'T'|'V'|'C'} =: *) PROCEDURE continuation (VAR eb: errorBlock; @@ -1863,10 +1871,13 @@ BEGIN 's': SpellHint (eb, sym, bol) | 'x': AddExportsHint (eb) | 'w': AddWithStackHint (eb) | - 'D': FilterOnDefinitionModule (eb) + 'D': FilterOnDefinitionModule (eb) | + 'T': FilterOnType (eb) | + 'V': FilterOnVariable (eb) | + 'C': FilterOnConst (eb) ELSE - InternalFormat (eb, 'expecting one of [:1234isxw]', + InternalFormat (eb, 'expecting one of [:1234isxwDT]', __LINE__) END ; INC (eb.ini) @@ -1953,6 +1964,27 @@ BEGIN END JoinSentances ; +(* + ConfigureFilter - +*) + +PROCEDURE ConfigureFilter (eb: errorBlock) ; +BEGIN + IF eb.filterType + THEN + FilterType + END ; + IF eb.filterVar + THEN + FilterVariable + END ; + IF eb.filterConst + THEN + FilterConst + END +END ConfigureFilter ; + + (* SpellHint - *) @@ -1966,6 +1998,7 @@ BEGIN JoinSentances (eb, GetDefModuleSpellHint (sym[bol])) ELSIF IsUnknown (sym[bol]) OR IsError (sym[bol]) THEN + ConfigureFilter (eb) ; JoinSentances (eb, GetSpellHint (sym[bol])) END END @@ -2012,6 +2045,36 @@ BEGIN END FilterOnDefinitionModule ; +(* + FilterOnType - +*) + +PROCEDURE FilterOnType (VAR eb: errorBlock) ; +BEGIN + eb.filterType := TRUE +END FilterOnType ; + + +(* + FilterOnConst - +*) + +PROCEDURE FilterOnConst (VAR eb: errorBlock) ; +BEGIN + eb.filterConst := TRUE +END FilterOnConst ; + + +(* + FilterOnVariable - +*) + +PROCEDURE FilterOnVariable (VAR eb: errorBlock) ; +BEGIN + eb.filterVar := TRUE +END FilterOnVariable ; + + (* changeColor - changes to color, c. *) diff --git a/gcc/m2/gm2-compiler/M2StackSpell.def b/gcc/m2/gm2-compiler/M2StackSpell.def index a0c11aacb642..5f9816c7376b 100644 --- a/gcc/m2/gm2-compiler/M2StackSpell.def +++ b/gcc/m2/gm2-compiler/M2StackSpell.def @@ -25,13 +25,6 @@ FROM DynamicStrings IMPORT String ; FROM NameKey IMPORT Name ; -(* - GetSpellHint - return a string describing a spelling hint. -*) - -PROCEDURE GetSpellHint (unknown: CARDINAL) : String ; - - (* Push - push a scope onto the spelling stack. sym might be a ModSym, DefImpSym or a varsym @@ -69,4 +62,36 @@ PROCEDURE GetRecordField (tokno: CARDINAL; PROCEDURE GetDefModuleSpellHint (defimp: CARDINAL) : String ; +(* + GetSpellHint - return a string describing a spelling hint. + The spell candidates can be filtered using + the attributes below. Note that the + GetDefModuleSpellHint and GetRecordField + are not filtered. +*) + +PROCEDURE GetSpellHint (unknown: CARDINAL) : String ; + + +(* + FilterConst - filter on constants. +*) + +PROCEDURE FilterConst ; + + +(* + FilterVariable - filter on variables. +*) + +PROCEDURE FilterVariable ; + + +(* + FilterType - filter on types. +*) + +PROCEDURE FilterType ; + + END M2StackSpell. diff --git a/gcc/m2/gm2-compiler/M2StackSpell.mod b/gcc/m2/gm2-compiler/M2StackSpell.mod index 22f7137945f8..b8ae3d754a46 100644 --- a/gcc/m2/gm2-compiler/M2StackSpell.mod +++ b/gcc/m2/gm2-compiler/M2StackSpell.mod @@ -25,6 +25,7 @@ FROM SymbolTable IMPORT NulSym, IsModule, IsDefImp, IsRecord, IsEnumeration, IsProcedure, GetNth, GetSymName, GetSym, GetLocalSym, GetScope, UnknownReported, IsUnknown, + IsAModula2Type, IsConst, IsVar, GetUnknownOnImport, GetUnknownDeclScope, ForeachExportedDo, ForeachProcedureDo, ForeachLocalSymDo, @@ -47,8 +48,13 @@ IMPORT m2spellcheck ; FROM m2spellcheck IMPORT Candidates ; +TYPE + FilterKind = (constant, type, variable) ; + FilterSet = SET OF FilterKind ; + VAR - DefaultStack: StackOfWord ; + DefaultStack : StackOfWord ; + CurrentFilter: FilterSet ; (* @@ -192,11 +198,37 @@ VAR BEGIN str := InitStringCharStar (KeyToCharStar (GetSymName (sym))) ; m2spellcheck.Push (PushCandidate, string (str)) ; - (* str := KillString (str) *) + (* str := KillString (str) ; *) INC (PushCount) END PushName ; +(* + PushNameFilter - push a name to the candidate vec provided + the filter allows. +*) + +PROCEDURE PushNameFilter (sym: CARDINAL) ; +BEGIN + IF CurrentFilter = FilterSet {} + THEN + (* No filtering. *) + PushName (sym) + ELSE + IF (constant IN CurrentFilter) AND IsConst (sym) + THEN + PushName (sym) + ELSIF (type IN CurrentFilter) AND IsAModula2Type (sym) + THEN + PushName (sym) + ELSIF (variable IN CurrentFilter) AND IsVar (sym) + THEN + PushName (sym) + END + END +END PushNameFilter ; + + (* ForeachRecordFieldDo - *) @@ -228,14 +260,14 @@ BEGIN PushCandidate := cand ; IF IsModule (sym) OR IsDefImp (sym) THEN - ForeachProcedureDo (sym, PushName) ; - ForeachLocalSymDo (sym, PushName) + ForeachProcedureDo (sym, PushNameFilter) ; + ForeachLocalSymDo (sym, PushNameFilter) ELSIF IsEnumeration (sym) THEN - ForeachFieldEnumerationDo (sym, PushName) + ForeachFieldEnumerationDo (sym, PushNameFilter) ELSIF IsRecord (sym) THEN - ForeachRecordFieldDo (sym, PushName) + ForeachRecordFieldDo (sym, PushNameFilter) END ; RETURN PushCount END PushCandidates ; @@ -309,10 +341,11 @@ END AddPunctuation ; (* - GetSpellHint - return a string describing a spelling hint. + GetSpellHintFilter - return a string describing a spelling hint. + The hint may be filtered. *) -PROCEDURE GetSpellHint (unknown: CARDINAL) : String ; +PROCEDURE GetSpellHintFilter (unknown: CARDINAL) : String ; BEGIN IF IsUnknown (unknown) AND GetUnknownOnImport (unknown) AND @@ -322,9 +355,57 @@ BEGIN RETURN GetExportedSpellHint (unknown, GetUnknownDeclScope (unknown)) END ; RETURN GetScopeSpellHint (unknown) +END GetSpellHintFilter ; + + +(* + GetSpellHint - return a string describing a spelling hint. + The spell candidates can be filtered using + the attributes below. Note that the + GetDefModuleSpellHint and GetRecordField + are not filtered. +*) + +PROCEDURE GetSpellHint (unknown: CARDINAL) : String ; +VAR + hint: String ; +BEGIN + hint := GetSpellHintFilter (unknown) ; + CurrentFilter := FilterSet {} ; (* Reset for the next time. *) + RETURN hint END GetSpellHint ; +(* + FilterConst - filter on constants. +*) + +PROCEDURE FilterConst ; +BEGIN + INCL (CurrentFilter, constant) +END FilterConst ; + + +(* + FilterVariable - filter on variables. +*) + +PROCEDURE FilterVariable ; +BEGIN + INCL (CurrentFilter, variable) +END FilterVariable ; + + +(* + FilterType - filter on types. +*) + +PROCEDURE FilterType ; +BEGIN + INCL (CurrentFilter, type) +END FilterType ; + + (* GetExportedSpellHint - return a string describing a spelling hint using the module exported identifiers. @@ -372,11 +453,6 @@ BEGIN WHILE (i <= n) AND (HintStr = NIL) DO sym := PeepWord (DefaultStack, i) ; HintStr := CheckForHintStr (sym, HintStr, misspell) ; - IF IsModule (sym) OR IsDefImp (sym) - THEN - (* Cannot see beyond a module scope. *) - RETURN AddPunctuation (HintStr, '?') - END ; INC (i) END ; RETURN AddPunctuation (HintStr, '?') @@ -389,7 +465,8 @@ END GetScopeSpellHint ; PROCEDURE Init ; BEGIN - DefaultStack := InitStackWord () + DefaultStack := InitStackWord () ; + CurrentFilter := FilterSet {} END Init ; diff --git a/gcc/m2/gm2-compiler/P3SymBuild.mod b/gcc/m2/gm2-compiler/P3SymBuild.mod index 85f1e9f80400..16a561748ee0 100644 --- a/gcc/m2/gm2-compiler/P3SymBuild.mod +++ b/gcc/m2/gm2-compiler/P3SymBuild.mod @@ -31,7 +31,7 @@ FROM M2LexBuf IMPORT GetTokenNo ; FROM SymbolTable IMPORT NulSym, ModeOfAddr, ProcedureKind, StartScope, EndScope, GetScope, GetCurrentScope, - GetModuleScope, + GetModuleScope, GetBaseModule, SetCurrentModule, GetCurrentModule, SetFileModule, GetExported, IsExported, IsImplicityExported, IsDefImp, IsModule, IsImported, IsIncludedByDefinition, @@ -97,6 +97,7 @@ BEGIN StartScope (ModuleSym) ; Assert (IsDefImp (ModuleSym)) ; Assert (CompilingDefinitionModule ()) ; + M2StackSpell.Push (GetBaseModule ()) ; M2StackSpell.Push (ModuleSym) ; PushT (name) ; M2Error.EnterDefinitionScope (name) @@ -128,6 +129,7 @@ BEGIN CheckForUnknownInModule (tokno) ; EndScope ; M2StackSpell.Pop ; + M2StackSpell.Pop ; PopT(NameEnd) ; PopT(NameStart) ; IF NameStart#NameEnd @@ -169,6 +171,7 @@ BEGIN Assert (CompilingImplementationModule()) ; PushT (name) ; M2Error.EnterImplementationScope (name) ; + M2StackSpell.Push (GetBaseModule ()) ; M2StackSpell.Push (ModuleSym) END P3StartBuildImpModule ; @@ -198,6 +201,7 @@ BEGIN CheckForUnknownInModule (tokno) ; EndScope ; M2StackSpell.Pop ; + M2StackSpell.Pop ; PopT(NameEnd) ; PopT(NameStart) ; IF NameStart#NameEnd @@ -244,6 +248,7 @@ BEGIN Assert(NOT IsDefImp(ModuleSym)) ; PushT(name) ; M2Error.EnterProgramScope (name) ; + M2StackSpell.Push (GetBaseModule ()) ; M2StackSpell.Push (ModuleSym) END P3StartBuildProgModule ; @@ -283,6 +288,7 @@ BEGIN FlushErrors END ; M2Error.LeaveErrorScope ; + M2StackSpell.Pop ; M2StackSpell.Pop END P3EndBuildProgModule ; @@ -316,6 +322,7 @@ BEGIN SetCurrentModule(ModuleSym) ; PushT(name) ; M2Error.EnterModuleScope (name) ; + M2StackSpell.Push (GetBaseModule ()) ; M2StackSpell.Push (ModuleSym) END StartBuildInnerModule ; @@ -355,6 +362,7 @@ BEGIN END ; SetCurrentModule(GetModuleScope(GetCurrentModule())) ; M2Error.LeaveErrorScope ; + M2StackSpell.Pop ; M2StackSpell.Pop END EndBuildInnerModule ; diff --git a/gcc/m2/gm2-compiler/PCSymBuild.mod b/gcc/m2/gm2-compiler/PCSymBuild.mod index f54e83a4fc3a..010bccc8a1a7 100644 --- a/gcc/m2/gm2-compiler/PCSymBuild.mod +++ b/gcc/m2/gm2-compiler/PCSymBuild.mod @@ -54,7 +54,7 @@ FROM M2Reserved IMPORT PlusTok, MinusTok, TimesTok, DivTok, ModTok, FROM SymbolTable IMPORT NulSym, ModeOfAddr, ProcedureKind, StartScope, EndScope, GetScope, GetCurrentScope, - GetModuleScope, + GetModuleScope, GetBaseModule, SetCurrentModule, GetCurrentModule, SetFileModule, GetExported, IsDefImp, IsModule, @@ -237,6 +237,7 @@ BEGIN StartScope(ModuleSym) ; Assert(IsDefImp(ModuleSym)) ; Assert(CompilingDefinitionModule()) ; + M2StackSpell.Push (GetBaseModule ()) ; M2StackSpell.Push (ModuleSym) ; PushT(name) ; M2Error.EnterDefinitionScope (name) @@ -268,6 +269,7 @@ BEGIN CheckForUnknownInModule (tokno) ; EndScope ; M2StackSpell.Pop ; + M2StackSpell.Pop ; PopT(NameEnd) ; PopT(NameStart) ; IF NameStart#NameEnd @@ -309,6 +311,7 @@ BEGIN Assert(CompilingImplementationModule()) ; PushTtok(name, tok) ; M2Error.EnterImplementationScope (name) ; + M2StackSpell.Push (GetBaseModule ()) ; M2StackSpell.Push (ModuleSym) END PCStartBuildImpModule ; @@ -338,6 +341,7 @@ BEGIN CheckForUnknownInModule (tokno) ; EndScope ; M2StackSpell.Pop ; + M2StackSpell.Pop ; PopT(NameEnd) ; PopT(NameStart) ; IF NameStart#NameEnd @@ -384,6 +388,7 @@ BEGIN Assert(NOT IsDefImp(ModuleSym)) ; PushTtok(name, tok) ; M2Error.EnterProgramScope (name) ; + M2StackSpell.Push (GetBaseModule ()) ; M2StackSpell.Push (ModuleSym) END PCStartBuildProgModule ; @@ -423,6 +428,7 @@ BEGIN FlushErrors END ; M2Error.LeaveErrorScope ; + M2StackSpell.Pop ; M2StackSpell.Pop END PCEndBuildProgModule ; @@ -456,6 +462,7 @@ BEGIN SetCurrentModule(ModuleSym) ; PushTtok(name, tok) ; M2Error.EnterModuleScope (name) ; + M2StackSpell.Push (GetBaseModule ()) ; M2StackSpell.Push (ModuleSym) END PCStartBuildInnerModule ; @@ -495,6 +502,7 @@ BEGIN END ; SetCurrentModule(GetModuleScope(GetCurrentModule())) ; M2Error.LeaveErrorScope ; + M2StackSpell.Pop ; M2StackSpell.Pop END PCEndBuildInnerModule ; diff --git a/gcc/testsuite/gm2.dg/spell/iso/fail/badspelltype.mod b/gcc/testsuite/gm2.dg/spell/iso/fail/badspelltype.mod new file mode 100644 index 000000000000..28708c638f41 --- /dev/null +++ b/gcc/testsuite/gm2.dg/spell/iso/fail/badspelltype.mod @@ -0,0 +1,15 @@ + +(* { dg-do compile } *) +(* { dg-options "-g -c" } *) + +MODULE badspelltype ; + +VAR + a: CARDINAL ; + b: CARDINAl ; + (* { dg-error "unknown symbol 'CARDINAl', did you mean CARDINAL" "CARDINAl" { target *-*-* } 9 } *) +BEGIN + IF a = b + THEN + END +END badspelltype. diff --git a/gcc/testsuite/gm2.dg/spell/iso/fail/badspelltype2.mod b/gcc/testsuite/gm2.dg/spell/iso/fail/badspelltype2.mod new file mode 100644 index 000000000000..5e27a8e52872 --- /dev/null +++ b/gcc/testsuite/gm2.dg/spell/iso/fail/badspelltype2.mod @@ -0,0 +1,18 @@ + +(* { dg-do compile } *) +(* { dg-options "-g -c" } *) + +MODULE badspelltype2 ; + +TYPE + Cardinal = CARDINAL ; + +VAR + a: Cardinal ; + b: Cardina1 ; + (* { dg-error "unknown symbol 'Cardina1', did you mean Cardinal" "Cardina1" { target *-*-* } 12 } *) +BEGIN + IF a = b + THEN + END +END badspelltype2. From 090ff9c73c79ab83eea66a010887a0ca8002ec6e Mon Sep 17 00:00:00 2001 From: Tamar Christina Date: Sat, 26 Sep 2026 17:18:43 +0100 Subject: [PATCH 447/584] middle-end: fix self-test fails [PR127618] The recent self tests I added should use min_out_nelts instead of in_nelts.coeffs[0] otherwise for VLA we use the wrong encoding. This was missed before because I forgot that an aarch64 bootstrap by default is VLS not VLA. Bootstrapped Regtested on aarch64-none-linux-gnu --with-arch=armv9-a and no issues. also checked - rv64gc - rv64gcv_zvl128b - rv64gcv_zvl256b - rv64gcv_zvl512b gcc/ChangeLog: PR tree-optimization/127618 * fold-const.cc (test_vec_unpack_folding): Update tests --- gcc/fold-const.cc | 23 ++++++++--------------- 1 file changed, 8 insertions(+), 15 deletions(-) diff --git a/gcc/fold-const.cc b/gcc/fold-const.cc index 8c5e558647c3..113558973f6e 100644 --- a/gcc/fold-const.cc +++ b/gcc/fold-const.cc @@ -17802,12 +17802,11 @@ test_vec_unpack_folding () poly_uint64 out_nelts = exact_div (in_nelts, 2); tree out_type = build_vector_type (out_inner_type, out_nelts); - tree_vector_builder builder (in_type, in_nelts.coeffs[0], 2); - for (unsigned int i = 0; i < in_nelts.coeffs[0]; ++i) + tree_vector_builder builder (in_type, min_out_nelts, 2); + for (unsigned int i = 0; i < min_out_nelts; ++i) builder.quick_push (build_int_cst (in_inner_type, i + 1)); - for (unsigned int i = 0; i < in_nelts.coeffs[0]; ++i) - builder.quick_push (build_int_cst (in_inner_type, - i < min_out_nelts ? 100 + i : 77)); + for (unsigned int i = 0; i < min_out_nelts; ++i) + builder.quick_push (build_int_cst (in_inner_type, 77)); tree arg = builder.build (); /* Check integer unpacking with a duplicated scalable high half. */ @@ -17878,17 +17877,15 @@ test_vec_unpack_folding () /* Check float-to-int unpacking with the same scalable shape. */ tree float_in_type = build_vector_type (float_type_node, in_nelts); - tree_vector_builder fix_builder (float_in_type, in_nelts.coeffs[0], 2); - for (unsigned int i = 0; i < in_nelts.coeffs[0]; ++i) + tree_vector_builder fix_builder (float_in_type, min_out_nelts, 2); + for (unsigned int i = 0; i < min_out_nelts; ++i) fix_builder.quick_push (build_real_from_int_cst (float_type_node, build_int_cst (integer_type_node, i + 1))); - for (unsigned int i = 0; i < in_nelts.coeffs[0]; ++i) + for (unsigned int i = 0; i < min_out_nelts; ++i) fix_builder.quick_push (build_real_from_int_cst (float_type_node, - build_int_cst (integer_type_node, - i < min_out_nelts - ? 100 + i : 77))); + build_int_cst (integer_type_node, 77))); tree fix_arg = fix_builder.build (); tree fix_out_type = build_vector_type (integer_type_node, out_nelts); tree fix_lo = const_unop (VEC_UNPACK_FIX_TRUNC_LO_EXPR, fix_out_type, @@ -17937,10 +17934,6 @@ test_vec_unpack_folding () ASSERT_EQ (NULL_TREE, const_unop (VEC_UNPACK_LO_EXPR, out_type, stepped.build ())); - /* Reject result types with the wrong number of elements. */ - tree wrong_out_type = build_vector_type (out_inner_type, in_nelts); - ASSERT_EQ (NULL_TREE, const_unop (VEC_UNPACK_LO_EXPR, wrong_out_type, - arg)); return; } } From e0f62720743e7750eef0c86dfa23d5965e2de785 Mon Sep 17 00:00:00 2001 From: Jerry DeLisle Date: Wed, 23 Sep 2026 10:26:50 -0700 Subject: [PATCH 448/584] fortran: [PR127187] ICE with %LEN of deferred-length character in ASSOCIATE A %LEN or %KIND inquiry of a deferred-length character variable gives an INTEGER expression that still carried the deferred flag of the character typespec. An associate-name with such a selector inherited it, and gfc_get_symbol_decl then segfaulted looking for its string length. A related bug: for an associate-name whose selector is deferred-length character, resolve_variable reset the typespec of the expression to that of the associate-name unless a substring reference was present. An inquiry reference of the associate-name, e.g. q%len, thus reverted to CHARACTER, giving an ICE in conv_inquiry or a spurious error on comparison with an INTEGER. PR fortran/127187 gcc/fortran/ChangeLog: PR fortran/127187 * primary.cc (gfc_match_varspec): Clear the deferred flag, and for KIND the charlen, of the INTEGER result of a LEN or KIND inquiry. * resolve.cc (resolve_variable): Do not reset the typespec of a deferred-length character associate-name expression that has an inquiry reference. gcc/testsuite/ChangeLog: PR fortran/127187 * gfortran.dg/associate_90.f90: New test. --- gcc/fortran/primary.cc | 6 ++ gcc/fortran/resolve.cc | 2 +- gcc/testsuite/gfortran.dg/associate_90.f90 | 69 ++++++++++++++++++++++ 3 files changed, 76 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gfortran.dg/associate_90.f90 diff --git a/gcc/fortran/primary.cc b/gcc/fortran/primary.cc index f3708f125d70..ebd72e2de1fe 100644 --- a/gcc/fortran/primary.cc +++ b/gcc/fortran/primary.cc @@ -2836,6 +2836,7 @@ gfc_match_varspec (gfc_expr *primary, int equiv_flag, bool sub_flag, return MATCH_ERROR; } primary->ts.u.cl = NULL; + primary->ts.deferred = false; primary->ts.type = BT_INTEGER; primary->ts.kind = gfc_default_integer_kind; break; @@ -2851,6 +2852,11 @@ gfc_match_varspec (gfc_expr *primary, int equiv_flag, bool sub_flag, "to an expression of intrinsic type"); return MATCH_ERROR; } + if (primary->ts.type == BT_CHARACTER) + { + primary->ts.u.cl = NULL; + primary->ts.deferred = false; + } primary->ts.type = BT_INTEGER; primary->ts.kind = gfc_default_integer_kind; break; diff --git a/gcc/fortran/resolve.cc b/gcc/fortran/resolve.cc index 60c5610bba45..a0c7d5c5e066 100644 --- a/gcc/fortran/resolve.cc +++ b/gcc/fortran/resolve.cc @@ -6739,7 +6739,7 @@ resolve_variable (gfc_expr *e) { gfc_ref *ref; for (ref = e->ref; ref; ref = ref->next) - if (ref->type == REF_SUBSTRING) + if (ref->type == REF_SUBSTRING || ref->type == REF_INQUIRY) break; if (ref == NULL) e->ts = sym->ts; diff --git a/gcc/testsuite/gfortran.dg/associate_90.f90 b/gcc/testsuite/gfortran.dg/associate_90.f90 new file mode 100644 index 000000000000..2190aa83693a --- /dev/null +++ b/gcc/testsuite/gfortran.dg/associate_90.f90 @@ -0,0 +1,69 @@ +! { dg-do run } +! +! PR 127187 +! %LEN and %KIND inquiries of deferred-length character in ASSOCIATE. +! +! Contributed by Ivan Pribec +! +program assoc_len_kind + implicit none + character(:), allocatable :: s, a(:) + character(:), pointer :: p + character(kind=4,len=:), allocatable :: w + character(7) :: f = 'seven07' + complex :: z = (1., 2.) + s = 'hello' + a = ['ab', 'cd', 'ef'] + w = 4_'wxyz' + allocate (p, source='ptr') + + ! Selector contains an inquiry of a deferred-length variable + associate (n => s%len) + if (n /= 5) error stop 1 + end associate + associate (n => (s%len)) + if (n /= 5) error stop 2 + end associate + associate (n => f%len) + if (n /= 7) error stop 3 + end associate + associate (n => s%len + 0) + if (n /= 5) error stop 4 + end associate + associate (k => z%kind) + if (k /= kind(z)) error stop 5 + end associate + associate (k => z%kind, n => s%len) + if (k /= kind(z)) error stop 6 + if (n /= 5) error stop 7 + end associate + associate (n => s%len) + s = 'longer_string' + if (n /= 5) error stop 8 + end associate + s = 'hello' + associate (n => s%kind, m => p%len, k => w%kind) + if (n /= 1 .or. m /= 3 .or. k /= 4) error stop 9 + end associate + + ! Inquiry of an associate-name with a deferred-length selector + associate (q => s) + if (q%len /= 5 .or. q%kind /= 1) error stop 10 + if (q(2:3)%len /= 2) error stop 11 + associate (n => q%len + q%kind) + if (n /= 6) error stop 12 + end associate + end associate + associate (q => a) + if (q%len /= 2 .or. size (q) /= 3) error stop 13 + end associate + associate (q => p, r => w) + if (q%len /= 3 .or. r%len /= 4 .or. r%kind /= 4) error stop 14 + end associate + associate (q => s) + associate (r => q) + if (r%len /= 5) error stop 15 + end associate + end associate + deallocate (p) +end program From e86752221abebc4af961d8f9a00cea47d5f3eb39 Mon Sep 17 00:00:00 2001 From: GCC Administrator Date: Sun, 27 Sep 2026 00:16:30 +0000 Subject: [PATCH 449/584] Daily bump. --- gcc/ChangeLog | 13 ++++++++++++ gcc/DATESTAMP | 2 +- gcc/c-family/ChangeLog | 4 ++++ gcc/fortran/ChangeLog | 30 ++++++++++++++++++++++++++ gcc/m2/ChangeLog | 47 +++++++++++++++++++++++++++++++++++++++++ gcc/testsuite/ChangeLog | 27 +++++++++++++++++++++++ libgomp/ChangeLog | 12 +++++++++++ 7 files changed, 134 insertions(+), 1 deletion(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 0a143c9ae53b..3e7342684345 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,16 @@ +2026-09-26 Tamar Christina + + PR tree-optimization/127618 + * fold-const.cc (test_vec_unpack_folding): Update tests + +2026-09-26 Tobias Burnus + + * config/nvptx/nvptx.cc (nvptx_encode_section_info): Handle + 'omp groupprivate'. + * varpool.cc (varpool_node::get_create): Print sorry for + 'omp groupprivate' variables except for device_type(nohost) and + no offloading or nvptx offloading. + 2026-09-26 Oleg Tolmatcev PR debug/119940 diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index ca1d5ff2ec50..d72743c7b357 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20260926 +20260927 diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog index b822ded19f57..8a819de39a97 100644 --- a/gcc/c-family/ChangeLog +++ b/gcc/c-family/ChangeLog @@ -1,3 +1,7 @@ +2026-09-26 Tobias Burnus + + * c-attribs.cc (c_common_gnu_attributes): Add "omp groupprivate". + 2026-09-24 Jakub Jelinek PR c++/126848 diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog index 9973d1051e3d..a187ca42f4cf 100644 --- a/gcc/fortran/ChangeLog +++ b/gcc/fortran/ChangeLog @@ -1,3 +1,33 @@ +2026-09-26 Jerry DeLisle + + PR fortran/127187 + PR fortran/127187 + * primary.cc (gfc_match_varspec): Clear the deferred flag, and + for KIND the charlen, of the INTEGER result of a LEN or KIND + inquiry. + * resolve.cc (resolve_variable): Do not reset the typespec of a + deferred-length character associate-name expression that has an + inquiry reference. + +2026-09-26 Tobias Burnus + + * gfortran.h (enum gfc_omp_requires_kind): Add OMP_REQ_NONE. + * openmp.cc (gfc_match_boolean_clause): New. + (gfc_match_dupl_branch_clause): New. + (gfc_match_dupl_check): Remove dupl_msg arg. + (gfc_match_dupl_atomic, + gfc_match_dupl_memorder, + gfc_match_omp_clauses, + gfc_match_omp_flush, + gfc_match_omp_requires): Accept optional constant logical + expression for inarguable clauses. + +2026-09-26 Tobias Burnus + + * f95-lang.cc (gfc_gnu_attributes): Add "omp groupprivate". + * trans-common.cc (build_common_decl): Enable 'omp groupprivate'. + * trans-decl.cc (add_attributes_to_decl): Likewise. + 2026-09-22 Chung-Lin Tang * openmp.cc (gfc_match_omp_declare_target): Adjust error handling diff --git a/gcc/m2/ChangeLog b/gcc/m2/ChangeLog index ec5ddfdba200..b846e657bd67 100644 --- a/gcc/m2/ChangeLog +++ b/gcc/m2/ChangeLog @@ -1,3 +1,50 @@ +2026-09-26 Gaius Mulley + + PR modula2/127622 + * gm2-compiler/M2Base.mod (CheckCompatible): Rename t1 to left. + Rename t2 to right. + Add spellcheck hint format specifiers to unknown types. + * gm2-compiler/M2MetaError.mod (ConfigureFilter): New procedure. + (errorBlock): filterVar new field. + filterType new field. + filterConst new field. + (continuation): Add T V C filter modifiers. + (FilterOnType): New procedure. + (FilterOnVariable): Ditto. + (FilrerOnConst): Ditto. + (SpellHint): Call ConfigureFilter. + * gm2-compiler/M2StackSpell.def (FilterType): New procedure. + (FilterVariable): Ditto. + (FilrerConst): Ditto. + * gm2-compiler/M2StackSpell.mod (FilterKind): New type. + (FilterSet): Ditto. + (CurrentFilter): New variable. + (PushNameFilter): New procedure. + (PushCandidates): Pass PushNameFilter as callback. + (GetSpellHintFilter): New procedure. + (GetSpellHint): Reimplement. + (FilterType): New procedure. + (FilterVariable): Ditto. + (FilterConst): Ditto. + (Init): Initialize CurrentFilter. + * gm2-compiler/P3SymBuild.mod (P3StartBuildDefModule): Push base + module. + (P3EndBuildDefModule): Pop base module. + (P3StartBuildImpModule): Push base module. + (P3EndBuildImpModule): Pop base module. + (P3StartBuildProgModule): Push base module. + (P3EndBuildProgModule): Pop base module. + (StartBuildInnerModule): Push base module. + (EndBuildInnerModule): Pop base module. + * gm2-compiler/PCSymBuild.mod (PCEndBuildDefModule): Pop + base module. + (PCStartBuildImpModule): Push base module. + (PCEndBuildImpModule): Pop base module. + (PCStartBuildProgModule): Push base module. + (PCEndBuildProgModule): Pop base module. + (StartBuildInnerModule): Push base module. + (EndBuildInnerModule): Pop base module. + 2026-09-25 Gaius Mulley PR modula2/127567 diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 64e107a51141..a4b185594418 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,30 @@ +2026-09-26 Jerry DeLisle + + PR fortran/127187 + PR fortran/127187 + * gfortran.dg/associate_90.f90: New test. + +2026-09-26 Gaius Mulley + + PR modula2/127622 + * gm2.dg/spell/iso/fail/badspelltype.mod: New test. + * gm2.dg/spell/iso/fail/badspelltype2.mod: New test. + +2026-09-26 Tobias Burnus + + * gfortran.dg/gomp/atomic-18.f90: Update dg-error. + * gfortran.dg/gomp/declare-simd-1.f90: Likewise. + * gfortran.dg/gomp/declare-target-indirect-1.f90: Likewise. + * gfortran.dg/gomp/flush-2.f90: Likewise. + * gfortran.dg/gomp/requires-2.f90: Likewise. + * gfortran.dg/gomp/clause-logical-arg-1.f90: New test. + * gfortran.dg/gomp/clause-logical-arg-2.f90: New test. + +2026-09-26 Tobias Burnus + + * gfortran.dg/gomp/groupprivate-1.f90: Update sorry output. + * gfortran.dg/gomp/groupprivate-4.f90: Likewise. + 2026-09-25 Jerry DeLisle * gfortran.dg/pdt_38.f03: Replace paren with brace. diff --git a/libgomp/ChangeLog b/libgomp/ChangeLog index 1b0858dbf7ae..b6e7e054960b 100644 --- a/libgomp/ChangeLog +++ b/libgomp/ChangeLog @@ -1,3 +1,15 @@ +2026-09-26 Tobias Burnus + + * libgomp.texi (Impl. Status): Mark optional const bool + expr for inarguable clauses as implemented for Fortran. + +2026-09-26 Tobias Burnus + + * libgomp.texi (Impl.Status): Mark 'omp groupprivate' as + partially supported. + * testsuite/libgomp.fortran/groupprivate-1.f90: New test. + * testsuite/libgomp.fortran/groupprivate-2.f90: New test. + 2026-09-25 Thomas Schwinge PR tree-optimization/127053 From c94dbb388de5ecb06f61ad3972eaff4d77933f81 Mon Sep 17 00:00:00 2001 From: "Jose E. Marchesi" Date: Sun, 27 Sep 2026 09:59:16 +0200 Subject: [PATCH 450/584] a68: do not generate TYPE_DECLs with null DECL_NAMEs This code in a68-low-moids.cc was leading to struct and union types being emitted with TYPE_DECLs in their TYPE_NAMEs having null DECL_NAMEs, which is a no-no. Algol 68 struct and union modes are always anonymous, until they are given names in a mode declaration. Signed-of-by: Jose E. Marchesi gcc/algol68/ChangeLog * a68-low-moids.cc (build_stub_type_decl): Remove function. (lower_struct_mode): Do not call build_stub_type_decl. (lower_union_mode): Likewise. --- gcc/algol68/a68-low-moids.cc | 26 -------------------------- 1 file changed, 26 deletions(-) diff --git a/gcc/algol68/a68-low-moids.cc b/gcc/algol68/a68-low-moids.cc index 27b28173003f..54c1a42863d9 100644 --- a/gcc/algol68/a68-low-moids.cc +++ b/gcc/algol68/a68-low-moids.cc @@ -49,23 +49,6 @@ static tree a68_lower_mode (MOID_T *m); This is used for TYPE_STUB_DECL so we can generate debug info for all our modes, so the TYPE_DECL has no name. */ -static void -build_stub_type_decl (tree type, tree context) -{ - if (TYPE_STUB_DECL (type)) - return; - - tree decl = build_decl (UNKNOWN_LOCATION, - TYPE_DECL, - NULL_TREE /* name */, - type); - TREE_PUBLIC (decl) = 1; - DECL_CONTEXT (decl) = context; - TYPE_CONTEXT (type) = DECL_CONTEXT (decl); - TYPE_NAME (type) = decl; /* Weird. This is for typedefs! */ - TYPE_STUB_DECL (type) = decl; -} - /* Builds a record type whose name is NAME. NFIELDS is the number of fields, provided as field ident/type pairs. @@ -311,10 +294,6 @@ lower_struct_mode (MOID_T *m) compute_record_mode (struct_type); } - /* Finish debugging output for this type. */ - build_stub_type_decl (struct_type, NULL_TREE /* context */); - rest_of_type_compilation (struct_type, TYPE_FILE_SCOPE_P (struct_type)); - rest_of_decl_compilation (TYPE_NAME (struct_type), 1 /* file scope p */, 0); A68_STRUCT_TYPE_P (struct_type) = 1; return struct_type; } @@ -429,11 +408,6 @@ lower_union_mode (MOID_T *m) compute_record_mode (c_union_type); } - /* Finish debugging output for this type. */ - build_stub_type_decl (c_union_type, NULL_TREE /* context */); - rest_of_type_compilation (c_union_type, TYPE_FILE_SCOPE_P (c_union_type)); - rest_of_decl_compilation (TYPE_NAME (c_union_type), 1 /* file scope p */, 0); - /* Now the type with the overhead. */ TYPE_NAME (union_type) = get_identifier ("union%"); tree overhead_field = build_decl (UNKNOWN_LOCATION, FIELD_DECL, From 5e9ef3a4160416519a4cb82cc428fe36781c5afc Mon Sep 17 00:00:00 2001 From: Gerald Pfeifer Date: Sun, 27 Sep 2026 11:10:01 +0200 Subject: [PATCH 451/584] libstdc++: Switch Safe STL link to https libstdc++-v3: * doc/xml/manual/debug_mode.xml: Switch Safe STL link to https. * doc/html/manual/debug_mode_design.html: Regenerate. --- libstdc++-v3/doc/html/manual/debug_mode_design.html | 2 +- libstdc++-v3/doc/xml/manual/debug_mode.xml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/libstdc++-v3/doc/html/manual/debug_mode_design.html b/libstdc++-v3/doc/html/manual/debug_mode_design.html index 6618aba1936e..65326c965af3 100644 --- a/libstdc++-v3/doc/html/manual/debug_mode_design.html +++ b/libstdc++-v3/doc/html/manual/debug_mode_design.html @@ -385,7 +385,7 @@

    There are several existing implementations of debug modes for C++ standard library implementations, although none of them directly supports debugging for programs using libstdc++. The existing - implementations include:

    • SafeSTL: + implementations include:

      • SafeSTL: SafeSTL was the original debugging version of the Standard Template Library (STL), implemented by Cay S. Horstmann on top of the Hewlett-Packard STL. Though it inspired much work in this area, it diff --git a/libstdc++-v3/doc/xml/manual/debug_mode.xml b/libstdc++-v3/doc/xml/manual/debug_mode.xml index 6f79602ff702..5317f806a291 100644 --- a/libstdc++-v3/doc/xml/manual/debug_mode.xml +++ b/libstdc++-v3/doc/xml/manual/debug_mode.xml @@ -876,7 +876,7 @@ test02() supports debugging for programs using libstdc++. The existing implementations include: - SafeSTL: + SafeSTL: SafeSTL was the original debugging version of the Standard Template Library (STL), implemented by Cay S. Horstmann on top of the Hewlett-Packard STL. Though it inspired much work in this area, it From 7b59bb2167b10e96b93a3d0b981c79ace75aa4ea Mon Sep 17 00:00:00 2001 From: Gerald Pfeifer Date: Sun, 27 Sep 2026 11:47:18 +0200 Subject: [PATCH 452/584] install: Remove Windows NT on Alpha/PowerPC note This note was added in June 2008 with commit aad416fbb58, at which point this support was gone for a bit already. gcc: PR target/69374 * doc/install.texi (Specific): No longer mention Windows NT on Alpha and PowerPC. --- gcc/doc/install.texi | 2 -- 1 file changed, 2 deletions(-) diff --git a/gcc/doc/install.texi b/gcc/doc/install.texi index 21d1cdf91736..49f4b956c7bd 100644 --- a/gcc/doc/install.texi +++ b/gcc/doc/install.texi @@ -5161,8 +5161,6 @@ Windows CE is supported as a target only on Hitachi SuperH (sh-wince-pe), and MIPS (mips-wince-pe). @subheading Other Windows Platforms -GCC no longer supports Windows NT on the Alpha or PowerPC. - GCC no longer supports the Windows POSIX subsystem. Old target names including *-*-winnt and *-*-windowsnt are no longer used. From 55867c37ec0dd0c4f1872183a6e43ea7dc16d479 Mon Sep 17 00:00:00 2001 From: Jeff Law Date: Sun, 27 Sep 2026 08:54:33 -0600 Subject: [PATCH 453/584] [PATCH][PR tree-optimization/126462] Fix reassociation exposing rotate+xor to work correctly for int128 and BitInt This has been pending in my queue for a while. Just keeps getting pushed down. As the PR notes, I added a patch a while back that could reassociate an xor operation out of certain sequences which in turn would allow the sequence to be recognized as rotate+xor. That patch did not handle 128 bit integers as I used the HOST_WIDE_INT interfaces. Similarly it didn't handle BitInt. This patch changes it to use the wi:: interfaces which fix the code generation issue on aarch64 with int128 and allow the sequence to safely fire for BitInt. The recommendations for adjustment were Jakub's. Bootstrapped and regression tested on x86, aarch64 and riscv. Crosses also tested without regressions, though I don't think they provide meaningfully more coverage for int128 and BitInt. PR tree-optimization/126462 gcc/ * match.pd (reassociate xor to expose rotate patterns): Rewrite using wi:: interfaces for the xor constant operand. gcc/testsuite/ * gcc.dg/torture/pr126462.c: New test. --- gcc/match.pd | 6 ++---- gcc/testsuite/gcc.dg/torture/pr126462.c | 26 +++++++++++++++++++++++++ 2 files changed, 28 insertions(+), 4 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/torture/pr126462.c diff --git a/gcc/match.pd b/gcc/match.pd index 688357f0ecdb..305c672e78c2 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -13579,8 +13579,7 @@ and, (if (type_has_mode_precision_p (type) && tree_fits_uhwi_p (@1) && tree_fits_uhwi_p (@3) - && tree_fits_uhwi_p (@4) - && ((~((HOST_WIDE_INT_1U << tree_to_uhwi (@1)) - 1)) & tree_to_uhwi (@4)) == 0 + && (wi::mask (tree_to_uhwi (@1), true, TYPE_PRECISION (type)) & wi::to_wide (@4)) == 0 && (tree_to_uhwi (@1) + tree_to_uhwi (@3)) == TYPE_PRECISION (type) && TYPE_UNSIGNED (type) && @0 == @2) @@ -13593,9 +13592,8 @@ and, (rshift @3 INTEGER_CST@4)) (if (type_has_mode_precision_p (type) && tree_fits_uhwi_p (@1) - && tree_fits_uhwi_p (@2) && tree_fits_uhwi_p (@4) - && (((((HOST_WIDE_INT_1U << tree_to_uhwi (@1)) - 1)) & tree_to_uhwi (@2)) == 0) + && ((wi::mask (tree_to_uhwi (@1), false, TYPE_PRECISION (type)) & wi::to_wide (@2)) == 0) && (tree_to_uhwi (@1) + tree_to_uhwi (@4)) == TYPE_PRECISION (type) && TYPE_UNSIGNED (type) && @0 == @3) diff --git a/gcc/testsuite/gcc.dg/torture/pr126462.c b/gcc/testsuite/gcc.dg/torture/pr126462.c new file mode 100644 index 000000000000..d32ba6f04edb --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr126462.c @@ -0,0 +1,26 @@ +/* { dg-do run { target int128 } } */ + +typedef unsigned __int128 u128; + +__attribute__((noipa)) u128 +f (u128 x) +{ + return ((x << 64) ^ (u128) 1) | (x >> 64); +} + +__attribute__((noipa)) u128 +g (u128 x) +{ + return ((x << 96) ^ ((u128) 1 << 32)) | (x >> 32); +} + +int +main (void) +{ + u128 x = (u128) 1 << 64; + if (f (x) != 1) + __builtin_abort (); + if (g (x) != ((u128) 1 << 32)) + __builtin_abort (); + return 0; +} From c23cf9b3493495fca08696fb831625a079848786 Mon Sep 17 00:00:00 2001 From: "James K. Lowden" Date: Thu, 17 Sep 2026 12:28:57 -0400 Subject: [PATCH 454/584] cobol: Improve PICTURE evaluation. Introduce an automaton to parse the PICTURE string. This version of the automaton enforces ISO Table 10 PICTURE-sequence rules. It returns the type of the data item or a pointer to the invalid character. It revealed several errors in the test suite. gcc/cobol/ChangeLog: * Make-lang.in: Add gcc/cobol/picture.cc. * scan.l: Replace validate_picture with is_valid_picture. * scan_ante.h: Delete code that was commented out. * picture.cc: New file. --- gcc/cobol/Make-lang.in | 16 +- gcc/cobol/picture.cc | 789 +++++++++++++++++++++++++++++++++++++++++ gcc/cobol/scan.l | 66 +++- gcc/cobol/scan_ante.h | 4 - 4 files changed, 861 insertions(+), 14 deletions(-) create mode 100644 gcc/cobol/picture.cc diff --git a/gcc/cobol/Make-lang.in b/gcc/cobol/Make-lang.in index d16947f80515..76505b07af9e 100644 --- a/gcc/cobol/Make-lang.in +++ b/gcc/cobol/Make-lang.in @@ -74,6 +74,7 @@ cobol1_OBJS = \ cobol/lexio.o \ cobol/move.o \ cobol/messages.o \ + cobol/picture.o \ cobol/parse.o \ cobol/scan.o \ cobol/structs.o \ @@ -89,11 +90,10 @@ cobol1_OBJS = \ # libgcobol/valconv.cc that needs to be compiled into both libgcobol # and cobol1. We copy those two source code files from libgcobol to # build/gcc/cobol to avoid the nightmare of one file appearing in more -# than one place. For simplicity, we make those compilations dependent -# on all of the libgcobol/*.h files, which might lead to the occasional -# unnecessary compilation. The impact of that is negligible. +# than one place. For simplicity, we make those compilations +# dependent on all of the libgcobol/*.h files, which might lead to the +# occasional unnecessary compilation. # - cobol/charmaps.cc cobol/valconv.cc: cobol/%.cc: $(LIB_SOURCE)/%.cc cp $^ $@ @@ -239,15 +239,15 @@ cobol/scan.o: cobol/scan.cc \ cobol/parse.cc # As opposed to other objects, gcobc is a shell script and therefore -# is only installed. In other words,no build step is necessary. -# However, some tests rely on gcobc being available from the build tree. +# is only installed. Although no build step is necessary, some tests +# rely on gcobc being available from the build tree. gcobc$(exeext): $(srcdir)/cobol/gcobc cp $< $@ cobol: gcobc$(exeext) -# Update token names if the generator script is installed -# (by a developer) and there's been a change. +# Update token names if the generator script is installed (by a +# developer) and there's been a change. $(srcdir)/cobol/token_names.h: cobol/parse.cc @if [ -f $@.gen ]; then \ $@.gen $(subst .cc,.h,$^) \ diff --git a/gcc/cobol/picture.cc b/gcc/cobol/picture.cc new file mode 100644 index 000000000000..01a723c7e9a9 --- /dev/null +++ b/gcc/cobol/picture.cc @@ -0,0 +1,789 @@ +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include + +#ifdef COBOL_PICTURE +const char * symbol_currency( char sign ) { + static const char mock_signs[] = "@ŁY&"; + return strchr(mock_signs, sign); +} +void cbl_internal_error(const char *format_string, ...) { assert(false); } +#else +void cbl_internal_error(const char *format_string, ...); +const char * symbol_currency( char sign ); +#endif + +namespace picture_validation { + + /* + * The picture is parsed via a state machine, implementing an automaton. If + * it reaches the end of the input, by definition it accepts the string. The + * acceptance state is a recognized type of COBOL data item. + */ + enum state_t { + invalid_e, + none_e, + boolean_e, + alphabetic_e, + unicode_e, + alphanumeric_e, + alpha_ed_e, + national_e, + national_ed_e, + numeric_e, + numeric_ed_e, + c_need_r_e, + crdb_e, + d_need_b_e, + postdec_e, + antedec_e, + exponent_e, + accept_e, // keep last + }; + + const char *state_str( state_t state ) { + switch(state) { + case accept_e: return "accept_e"; + case alpha_ed_e: return "alpha_ed_e"; + case alphabetic_e: return "alphabetic_e"; + case alphanumeric_e: return "alphanumeric_e"; + case antedec_e: return "antedec_e"; + case boolean_e: return "boolean_e"; + case c_need_r_e: return "c_need_r_e"; + case crdb_e: return "crdb_e"; + case d_need_b_e: return "d_need_b_e"; + case exponent_e: return "exponent_e"; + case invalid_e: return "invalid_e"; + case national_e: return "national_e"; + case national_ed_e: return "national_ed_e"; + case none_e: return "none_e"; + case numeric_e: return "numeric_e"; + case numeric_ed_e: return "numeric_ed_e"; + case postdec_e: return "postdec_e"; + case unicode_e: return "unicode_e"; + } + return "???"; + } + + struct follow_key_t { + state_t state; + char ch; + bool operator< (const follow_key_t& that ) const { + if( state == that.state ) { + return ch < that.ch; + } + return state < that.state; + } + }; + + /* + * The followers table enforces the merest of syntax: in a picture string, + * what character may follow another? It reproduces ISO table 10 in + * programmatic form. + * + * "The symbol '+' that appears in a column and in a row by itself, + * represents its use in the exponent part of character-string-1 for a + * floating-point numeric-edited item. + * + * The symbols '+' and '-' when used as a non-floating insertion symbol + * appear in two columns and two rows. The leftmost column and the uppermost + * row for these symbols represent their use as the first symbol in + * character-string-1. The rightmost column and the lowermost row for these + * symbols represent its use as the last or penultimate symbol in + * character-string-1. + * + * The symbol '+' that appears in a column and in a row by itself, + * represents its use in the exponent." + */ + +#define dot '.' +#define com ',' + typedef std::array follow_t; + static const std::map followers { + /* all */ { { none_e, '\0' }, {"" "*+,-./$019ABENPSVXZCD"} }, + /* 1 */ { { antedec_e, '1' }, {"(" "1"} }, + /* B0/ */ { { antedec_e, 'B' }, {"" "B0/,.Z*+-$9AXVPNECD"} }, + /* B0/ */ { { postdec_e, 'B' }, {"" "B0/,.Z*+-$9AXVPNECD"} }, // ante & post + /* B0/ */ { { antedec_e, '0' }, {"" "B0/,.Z*+-$9AXVPNECD"} }, + /* B0/ */ { { postdec_e, '0' }, {"" "B0/,.Z*+-$9AXVPNECD"} }, // ante & post + /* B0/ */ { { antedec_e, '/' }, {"" "B0/,.Z*+-$9AXVPNECD"} }, + /* B0/ */ { { postdec_e, '/' }, {"" "B0/,.Z*+-$9AXVPNECD"} }, // ante & post + /* + */ { { exponent_e, '+' }, {"" "9"} }, + /* , */ { { antedec_e, com }, {"" "B0/,.Z*+-$9VPE"} }, + /* . */ { { antedec_e, dot }, {"" "B0/,Z*+-$9E"} }, + /* . */ { { postdec_e, dot }, {"" "B0/,Z*+-$9E"} }, // ante & post + /* +- */ { { antedec_e, '+' }, {"" "B0/,.+-Z*$9VPE"} }, + /* +- */ { { antedec_e, '-' }, {"" "B0/,.+-Z*$9VPE"} }, + /* Z* */ { { antedec_e, 'Z' }, {"(" "B0/,.+-Z*$9VP"} }, + /* Z* */ { { postdec_e, 'Z' }, {"" "B0/,+-Z*"} }, + /* Z* */ { { antedec_e, '*' }, {"" "B0/,.+Z*$9VPCD"} }, + /* Z* */ { { postdec_e, '*' }, {"" "B0/,+Z*CD"} }, + /* + */ { { antedec_e, '+' }, {"" "B0/,.+-$9VP"} }, + /* + */ { { postdec_e, '+' }, {"" "B0/,+-"} }, + /* cs */ { { antedec_e, '$' }, {"" "B0/Z*,.+$9VP"} }, + /* cs */ { { postdec_e, '$' }, {"" "B0/Z*,+"} }, + /* 9 */ { { antedec_e, '9' }, {"(" "B0/,.+-$9AXVPECD"} }, + /* 9 */ { { postdec_e, '9' }, {"(" "B0/,.+-$9AXVPECD"} }, // ante & post + /* AX */ { { antedec_e, 'A' }, {"(" "B0/$9AX"} }, + /* AX */ { { antedec_e, 'X' }, {"(" "B0/$9AX"} }, + /* S */ { { antedec_e, 'S' }, {"" "9VP"} }, + /* V */ { { postdec_e, 'V' }, {"" "B0/,+Z*+-$9P"} }, + /* P */ { { antedec_e, 'P' }, {"(" "+V9P"} }, + /* P */ { { postdec_e, 'P' }, {"(" "B0/,+Z*$P"} }, + /* 1 */ { { antedec_e, '1' }, {"" "1"} }, + /* N */ { { antedec_e, 'N' }, {"(" "B0/N"} }, + /* E */ { { antedec_e, 'E' }, {"" "+9"} }, + + /* CR/DB */ { { antedec_e, 'C' }, {"" "R"} }, + /* CR/DB */ { { antedec_e, 'D' }, {"" "B"} }, + /* CR/DB */ { { postdec_e, 'C' }, {"" "R"} }, + /* CR/DB */ { { postdec_e, 'D' }, {"" "B"} }, + }; + + /* + * As the picture string is validated, constraint_t captures what has been + * seen: the preceding character and what characters have appeared that + * signify alphanumeric-edited or numeric-edited. + */ + static constexpr uint64_t hiword(char ch) { + return (1ULL << (ch - 'A')) << 32; + } + class constraint_t { + // Domain of symbols in a picture string. + enum picsym_t : uint64_t { + p_plus = 0x0010, // + + p_minus = 0x0020, // - + p_dot = 0x0040, // . + p_comma = 0x0080, // , + p_slash = 0x0100, // / + p_cs = 0x0200, // $ + p_star = 0x0400, // * + p_zero = 0x0800, // 0 + p_one = 0x1000, // 1 + p_nine = 0x0009, // 9, claim the whole nybble + // Bits 0-15: punctuation, currency, and 0, 1, and 9. + // Bits 32-58: A-Z + p_A = hiword('A'), + p_B = hiword('B'), + p_C = hiword('C'), + p_D = hiword('D'), + p_E = hiword('E'), + p_N = hiword('N'), + p_P = hiword('P'), + p_S = hiword('S'), + p_U = hiword('U'), + p_V = hiword('V'), + p_X = hiword('X'), + p_Z = hiword('Z'), + + p_boolean_e = p_one, + p_alphabetic_e = p_A, + p_alphanumeric_e = (p_A | p_X | p_nine), + p_b_0_slash_e = (p_B | p_zero | p_slash), + p_alpha_ed_e = (p_alphanumeric_e | p_b_0_slash_e), + p_national_e = p_N, + p_national_ed_e = (p_N | p_b_0_slash_e), + p_numeric_e = (p_nine | p_P | p_S | p_V), + // B P V Z 9 0 / , . + - CR DB * cs (CR/DB not in mask because at end) + p_numeric_ed2_e = (p_b_0_slash_e | p_comma | p_dot | p_plus | p_minus), + p_numeric_ed_e = ( p_P | p_V | p_Z | p_nine | p_b_0_slash_e | + p_comma | p_dot | p_plus | p_minus | p_star | p_cs), + }; + uint64_t symbol_mask; + + bool is_boolean() const { + return 0 == (symbol_mask & ~p_boolean_e) + && 0 != (symbol_mask & p_boolean_e); + } + bool is_alphabetic() const { + return 0 == (symbol_mask & ~p_alphabetic_e) + && 0 != (symbol_mask & p_alphabetic_e); + } + bool is_alphanumeric() const { + return 0 == (symbol_mask & ~p_alphanumeric_e) + && 0 != (symbol_mask & p_alphanumeric_e); + } + bool is_alpha_ed() const { + return 0 == (symbol_mask & ~p_alpha_ed_e) + && 0 != (symbol_mask & p_alphanumeric_e) + && 0 != (symbol_mask & p_b_0_slash_e); + } + bool is_national() const { + return 0 == (symbol_mask & ~p_national_e) + && 0 != (symbol_mask & p_national_e); + } + bool is_national_ed() const { + return 0 == (symbol_mask & ~p_national_ed_e) + && 0 != (symbol_mask & p_national_e) + && 0 != (symbol_mask & p_b_0_slash_e); + } + bool is_numeric() const { + return 0 == (symbol_mask & ~p_numeric_e) + && 0 != (symbol_mask & p_nine) + && 0 != (symbol_mask & p_numeric_e); + } + bool is_numeric9_ed() const { + return 0 == (symbol_mask & ~p_numeric_ed_e) + && 0 != (symbol_mask & p_nine) + && 0 != (symbol_mask & p_numeric_ed2_e); + } + bool is_numeric_ed() const { + return 0 == (symbol_mask & ~p_numeric_ed_e) + && ( 0 != (symbol_mask & (p_Z | p_star)) + || two_signs() + || is_numeric9_ed() ); + } + + state_t decimal_state; // to lookup sequence validity + + uint64_t picsym_set( char ch ) { + switch(ch) { + case '+': return symbol_mask |= p_plus; + case '-': return symbol_mask |= p_minus; + case '.': return symbol_mask |= p_dot; + case ',': return symbol_mask |= p_comma; + case '/': return symbol_mask |= p_slash; + case '$': return symbol_mask |= p_cs; + case '0': return symbol_mask |= p_zero; + case '1': return symbol_mask |= p_one; + case '9': return symbol_mask |= p_nine; + case 'A': return symbol_mask |= p_A; + case 'B': return symbol_mask |= p_B; + case 'C': return symbol_mask |= p_C; + case 'D': return symbol_mask |= p_D; + case 'E': return symbol_mask |= p_E; + case 'N': return symbol_mask |= p_N; + case 'P': return symbol_mask |= p_P; + case 'S': return symbol_mask |= p_S; + case 'U': return symbol_mask |= p_U; + case 'V': return symbol_mask |= p_V; + case 'X': return symbol_mask |= p_X; + case 'Z': return symbol_mask |= p_Z; + } + return symbol_mask; + } + + bool picsym_seen( char ch ) const { + switch(ch) { + case '+': return 0 < (symbol_mask & p_plus); + case '-': return 0 < (symbol_mask & p_minus); + case '.': return 0 < (symbol_mask & p_dot); + case ',': return 0 < (symbol_mask & p_comma); + case '/': return 0 < (symbol_mask & p_slash); + case '$': return 0 < (symbol_mask & p_cs); + case '0': return 0 < (symbol_mask & p_zero); + case '1': return 0 < (symbol_mask & p_one); + case '9': return 0 < (symbol_mask & p_nine); + case 'A': return 0 < (symbol_mask & p_A); + case 'B': return 0 < (symbol_mask & p_B); + case 'C': return 0 < (symbol_mask & p_C); + case 'D': return 0 < (symbol_mask & p_D); + case 'E': return 0 < (symbol_mask & p_E); + case 'N': return 0 < (symbol_mask & p_N); + case 'P': return 0 < (symbol_mask & p_P); + case 'S': return 0 < (symbol_mask & p_S); + case 'U': return 0 < (symbol_mask & p_U); + case 'V': return 0 < (symbol_mask & p_V); + case 'X': return 0 < (symbol_mask & p_X); + case 'Z': return 0 < (symbol_mask & p_Z); + } + } + + /* + * 1) Every character except V adds to the capacity, with the caveat that + * the first CURRENCY PICTURE character adds the length of the CURRENCY + * SIGN string. + * 2) data.digits has to be the count of 9 + count of Z + count of asterisk + * + (count of $ minus 1) + (count of - minus one) + (count of + minus 1) + * 3) data.rdigits is the subset of 2 that is to the right of either V or + * . (edited)  + * + * For the moment, break out the fact that V should add zero.  Right now + * all of the regression tests assume that V, if there, adds one.  I would + * really rather attack the V change when everything is working. + */ + + char prior_ch; + public: + int nplus, nminus; + + constraint_t() + : symbol_mask(0) + , decimal_state(none_e) + , prior_ch('\0') + , nplus(0), nminus(0) + {} + constraint_t& operator=( char ch ) { + picsym_set(ch); + prior_ch = ch; + if( ch == '+' ) nplus++; + if( ch == '-' ) nminus++; + observe_the_dot(ch); + return *this; + } + char prior() const { return prior_ch; } + + state_t automaton(state_t state) { return decimal_state = state; } + state_t automaton() const { return decimal_state; } + + + state_t state() const { + if( is_alphabetic() ) return alphabetic_e; + if( is_alphanumeric() ) return alphanumeric_e; + if( is_alpha_ed() ) return alpha_ed_e; + if( is_national() ) return national_e; + if( is_national_ed() ) return national_ed_e; + if( is_numeric() ) return numeric_e; + if( is_numeric_ed() ) return numeric_ed_e; + return invalid_e; + } + + bool two_signs() const { return 1 < nplus || 1 < nminus; } + + /* + * The followers table is sensitive to whether we've seen decimal point, and + * whether we're in an exponent. That reflects the duplicate column + * headings in ISO Table 10. + */ + bool day_follows_night( char ch ) { + auto p = followers.find( follow_key_t {decimal_state, prior_ch} ); + if( p != followers.end() ) { + const auto& candidates(p->second); + auto pnext = std::find( candidates.begin(), candidates.end(), ch ); + return pnext != candidates.end(); + } + return false; + } + protected: + void observe_the_dot( char ch ) { + if( decimal_state == none_e ) decimal_state = antedec_e; + if( ch == '.' || ch == 'V' ) decimal_state = postdec_e; } + } constraint; + + //////////////////////////////////////////////////////////////// + + struct transition_t { + state_t state; + char ch; + state_t next_state; + + transition_t( state_t state, + char ch, + state_t next_state ) + : state(state) + , ch(ch) + , next_state(next_state) + {} + + bool operator<(const transition_t& that) const { + if (state == that.state) return ch < that.ch; + return state < that.state; + } + bool operator==(const transition_t& that) const { return match(that); } + bool operator!=(const transition_t& that) const { return ! match(that); } + + protected: + // match verifies that the row returned by std::lower_bound actually + // matches, and isn't the next "bigger" one. + bool match(const transition_t& that) const { + return state == that.state + && ch == that.ch; + } + }; + + static std::vector picture_rules { + // Alpha and Alphanumeric + { none_e, 'A', alphabetic_e }, + { none_e, 'X', alphanumeric_e }, + { none_e, 'B', alpha_ed_e }, + { none_e, '0', alpha_ed_e }, + { none_e, '/', alpha_ed_e }, + { none_e, '9', antedec_e }, // 9 before V + { none_e, 'N', national_e }, + { none_e, 'P', none_e }, + { none_e, 'S', none_e }, + { none_e, 'V', postdec_e, }, // V before 9 + + { none_e, '1', antedec_e }, + { antedec_e, '1', antedec_e }, + + { alphabetic_e, 'A', alphabetic_e }, + { alphabetic_e, 'B', alpha_ed_e }, + { alphabetic_e, '0', alpha_ed_e }, + { alphabetic_e, '/', alpha_ed_e }, + { alphabetic_e, 'X', alphanumeric_e }, + { alphabetic_e, '$', numeric_ed_e }, + + { alphanumeric_e, 'A', alphanumeric_e }, + { alphanumeric_e, 'X', alphanumeric_e }, + { alphanumeric_e, '9', alphanumeric_e }, + + // Alpha edited + { alpha_ed_e, 'B', alpha_ed_e }, + { alpha_ed_e, '0', alpha_ed_e }, + { alpha_ed_e, '/', alpha_ed_e }, + { alpha_ed_e, 'A', alpha_ed_e }, + { alpha_ed_e, 'X', alpha_ed_e }, + { alpha_ed_e, '9', numeric_ed_e }, + { alpha_ed_e, 'Z', numeric_ed_e }, + { alpha_ed_e, '*', numeric_ed_e }, + { alpha_ed_e, '+', numeric_ed_e }, + { alpha_ed_e, '-', numeric_ed_e }, + { alpha_ed_e, dot, numeric_ed_e }, + { alpha_ed_e, com, numeric_ed_e }, + { alpha_ed_e, '$', numeric_ed_e }, + + { alphanumeric_e, 'B', alpha_ed_e }, + { alphanumeric_e, '0', alpha_ed_e }, + { alphanumeric_e, '/', alpha_ed_e }, + + // National + { national_e, 'N', national_e }, + { national_e, '\0', alphanumeric_e }, + + // National edited + { national_e, 'B', national_ed_e }, + { national_e, '0', national_ed_e }, + { national_e, '/', national_ed_e }, + + { national_ed_e, 'N', national_ed_e }, + { national_ed_e, 'B', national_ed_e }, + { national_ed_e, '0', national_ed_e }, + { national_ed_e, '/', national_ed_e }, + { national_ed_e, '\0', alpha_ed_e }, + + // Numeric edited + // [B*] or [+-].*[+-] or (9 and [$B0/,.+-], where $ is cs. + { none_e, 'Z', numeric_ed_e }, + { none_e, '*', numeric_ed_e }, + { none_e, dot, numeric_ed_e }, + { none_e, com, numeric_ed_e }, + { none_e, '-', numeric_ed_e }, + { none_e, '+', numeric_ed_e }, + { none_e, '$', numeric_ed_e }, + + { antedec_e, '9', antedec_e }, + { antedec_e, 'A', alphanumeric_e }, + { antedec_e, 'P', numeric_e }, + { antedec_e, 'V', numeric_e }, + { antedec_e, 'X', alphanumeric_e }, + { antedec_e, 'C', c_need_r_e }, + { antedec_e, 'D', d_need_b_e }, + + { antedec_e, 'Z', numeric_ed_e }, + { antedec_e, '*', numeric_ed_e }, + { antedec_e, '$', numeric_ed_e }, + { antedec_e, dot, numeric_ed_e }, + { antedec_e, com, numeric_ed_e }, + + { postdec_e, '9', numeric_e }, + { postdec_e, 'P', numeric_e }, + + { numeric_e, '9', numeric_e }, + { numeric_e, 'P', numeric_e }, + + { numeric_e, 'Z', numeric_ed_e }, + { numeric_e, '*', numeric_ed_e }, + { numeric_e, 'B', numeric_ed_e }, + { numeric_e, '0', numeric_ed_e }, + { numeric_e, '/', numeric_ed_e }, + { numeric_e, dot, numeric_ed_e }, + { numeric_e, com, numeric_ed_e }, + { numeric_e, '+', numeric_ed_e }, + { numeric_e, '-', numeric_ed_e }, + { numeric_e, '$', numeric_ed_e }, + { numeric_e, 'C', c_need_r_e }, + { numeric_e, 'D', d_need_b_e }, + + { numeric_ed_e, 'Z', numeric_ed_e }, + { numeric_ed_e, 'B', numeric_ed_e }, + { numeric_ed_e, '9', numeric_ed_e }, + { numeric_ed_e, '0', numeric_ed_e }, + { numeric_ed_e, dot, numeric_ed_e }, + { numeric_ed_e, com, numeric_ed_e }, + { numeric_ed_e, '/', numeric_ed_e }, + { numeric_ed_e, '-', numeric_ed_e }, + { numeric_ed_e, '+', numeric_ed_e }, + { numeric_ed_e, '*', numeric_ed_e }, + { numeric_ed_e, '$', numeric_ed_e }, + { numeric_ed_e, 'P', numeric_ed_e }, + { numeric_ed_e, 'V', numeric_ed_e }, // See Table 10 if in doubt. + { numeric_ed_e, 'C', c_need_r_e }, + { numeric_ed_e, 'D', d_need_b_e }, + + // End of the road + { c_need_r_e, 'R', numeric_ed_e }, + { d_need_b_e, 'B', numeric_ed_e }, + }; + + typedef std::array automaton_elem_t; + typedef std::vector automaton_matrix_t; + + const automaton_matrix_t& prepare_automaton() { + static automaton_matrix_t matrix(accept_e); + static bool ready = false; + if( ready ) return matrix; + + int i __attribute__ ((unused)) = 0, nextra = 0; + for( const auto& rule : picture_rules ) { + unsigned char ch(rule.ch); + +#ifdef COBOL_PICTURE + if( matrix[rule.state][ch] ) { + nextra++; + fprintf(stderr, "%s: redundant rule: #%d { %s '%c' %s }\n", + __func__, i, + state_str(rule.state), rule.ch, + state_str(rule.next_state)); + } +#endif + matrix[rule.state][ch] = rule.next_state; + i++; + } + if( nextra ) { + cbl_internal_error("%s: %d redundant rules", __func__, nextra); + } + + ready = true; + return matrix; + } + + void sort_rules() { +#ifdef COBOL_PICTURE + // During development, verify the ruleset is unique. + std::set U; + int i=0; + for( const auto& r : picture_validation::picture_rules ) { + auto result = U.insert(r); + if( ! result.second ) { + auto extra = result.first; + fprintf(stderr, "%s: redundant rule: #%d { %s '%c' %s }\n", + __func__, i, + state_str(extra->state), + extra->ch, + state_str(extra->next_state)); + } + i++; + } +#endif + std::sort( picture_validation::picture_rules.begin(), + picture_validation::picture_rules.end() ); + auto extra = std::unique( picture_validation::picture_rules.begin(), + picture_validation::picture_rules.end() ); + if( extra != picture_validation::picture_rules.end() ) { +#ifndef COBOL_PICTURE + cbl_internal_error("%s: redundant rule: { %s %qc %s }", __func__, + state_str(extra->state), + extra->ch, + state_str(extra->next_state)); +#endif + assert(false && "Redundant rules detected"); + } + } +} + +using picture_validation::transition_t; +using picture_validation::state_t; + +/* + * If a character within parentheses cannot be part of a COBOL word, then the + * sequence is not an integer or data-item name. + */ +static const char * +seek_paren( const char *p, const char *epicture ) { + for( p++; p < epicture; p++ ) { + if( ! isalnum(*p) ) { + switch(*p) { + case '-': + case '_': + continue; // part of COBOL text word, or a digit + } + break; + } + } + return p; +} + +static bool verbose = false; + +// Dot as last character is period separator because the lexer defines +// end-of-picture as a space. +bool +end_of_picture( const char *p, const char *epicture ) { + if( p + 1 == epicture ) { + switch( *p ) { + case '.': case ';': case ',': + return true; + } + } + return p == epicture; +} + +std::pair +is_valid_picture(const char picture[]) { + static bool sorted = false; + if( ! sorted ) { + picture_validation::sort_rules(); + sorted = true; + } + + const auto& rules( picture_validation::picture_rules ); + // reset the global constraint structure. + auto& constraint(picture_validation::constraint); + constraint = picture_validation::constraint_t(); + + if( ! picture ) { + return {picture, picture_validation::invalid_e}; + } + const char *epicture = picture + strlen(picture); + + state_t state = picture_validation::none_e; + for( auto p=picture; p < epicture; p++ ) { + // Advance lookahead past any count, which might be name. + // No picture begins with a '('. + if( picture < p && *p == '(' && p+1 < epicture ) { + p = seek_paren(p, epicture); + if( *p != ')' ) { + return {p, picture_validation::invalid_e}; + } + if( p[-1] == '(' ) { // pic 9() is invalid + return {p, picture_validation::invalid_e}; + } + p++; + } + + // Dot as last character is period separator because the lexer defines + // end-of-picture as a space. + if( end_of_picture(p, epicture) ) break; + + // Now p is fixed, but ch might be a currency symbol + char ch = toupper(*p); + + // Is the current character ever allowed to follow the prior? + if( ! constraint.day_follows_night(ch) ) { + if( symbol_currency(ch) ) { + ch = '$'; + } else { + if( verbose ) + fprintf(stderr, "no %2zu: %c -> %c (%s)\n", + p - picture, constraint.prior(), ch, + picture_validation::state_str(constraint.automaton()) ); + return {p, picture_validation::invalid_e}; + } + } + + // Consult the rules. + picture_validation::transition_t query { state, ch, state }; + + auto prule = std::lower_bound(rules.begin(), rules.end(), query); + + if( prule == rules.end() || *prule != query ) { + state_t state = p == epicture? + constraint.state() : picture_validation::invalid_e; + return {p, state}; + } + + if( verbose ) + fprintf(stderr, "ok %2zu: %c (%s)\n", + p - picture, ch, + picture_validation::state_str(prule->next_state) ); + + // Advance to the next state. + constraint = ch; + state = prule->next_state; + } + + return {epicture, constraint.state()}; +} + +#ifdef COBOL_PICTURE +/* + * The test harness is not part of the compiler. It can be used to create a + * standalone executable for testing picture validation. + */ + +static bool +process_line( const char picture[], int lineno = 1 ) { + assert(picture); + unsigned int mask = picture_validation::invalid_e; + auto result = is_valid_picture(picture); + if( 0 == (mask & result.second) ) { + printf( "valid : %s (%s)\n", + picture, picture_validation::state_str(result.second) ); + } else { + auto p = result.first; + printf( "INVALID : %s at position %u '%c' (%s) line %d\n", + picture, unsigned(p - picture), *p, + picture_validation::state_str(result.second), lineno ); + } + return result.second & picture_validation::invalid_e; +} + +static bool +process_file(const char* filename) { + auto input = stdin; + if( filename ) { + input = fopen(filename, "r"); + if( !input ) { + fprintf(stderr, "could not open '%s': %m\n", filename); + return false; + } + } + + char *picture = nullptr; + size_t plen = 0; + ssize_t len; + int lineno = 0; + + while( (len = getline(&picture, &plen, input)) != -1 ) { + auto p = std::find(picture, picture + len, '\n'); + if( p < picture + len ) *p = '\0'; + process_line(picture, ++lineno); + } + return len != -1; +} + +int +main(int argc, char* argv[]) { + int opt; + bool fOK; + const char *picture = nullptr; + + while ((opt = getopt(argc, argv, "p:v")) != -1) { + switch (opt) { + case 'p': + picture = optarg; + break; + case 'v': + verbose = true; + break; + } + } + + if (picture) { + fOK = process_line(picture) ? 0 : 1; + } else { + if (optind < argc) { + for (int i = optind; i < argc; ++i) { + fOK = process_file(argv[i]); + } + } else { + fOK = process_file(nullptr); + } + } + + return fOK ? 0 : 1; +} + +#endif // COBOL_PICTURE diff --git a/gcc/cobol/scan.l b/gcc/cobol/scan.l index df76ad1da816..a295a3fbadc7 100644 --- a/gcc/cobol/scan.l +++ b/gcc/cobol/scan.l @@ -53,6 +53,67 @@ #pragma GCC diagnostic ignored "-Wsign-compare" #pragma GCC diagnostic ignored "-Wunused-function" +namespace picture_validation { + enum state_t { + none_e, + alphabetic_e = 1, + alphanumeric_e, + alpha_ed_e, + national_e, + national_ed_e, + numeric_e, + numeric_ed_e, + invalid_e = 0x80, + alpha_pending_e, + c_need_r_e, + crdb_e, + d_need_b_e, + postdec_e, + antedec_e, + exponent_e, + accept_e, + }; +} + +std::pair +is_valid_picture( const char picture[] ); + +static const char * +crdb_maybe( const char *p ) { + char candidate[3] = { TOUPPER(p[-1]), TOUPPER(p[0]) }; + static const std::set endings{ "CR", "DB" }; + return 1 == endings.count(candidate)? --p : p; +} + +static size_t +is_valid_picture() { + std::reverse_iterator end(yytext), beg(yytext + yyleng); + auto pos = std::find(beg, end, 0x20); + auto picture = pos.base(); + dbgmsg("%s: picture is '%s'", __func__, picture); + + auto result = is_valid_picture(picture); + + if( 0 != (result.second & picture_validation::invalid_e) ) { + assert(yytext < result.first); + auto p = crdb_maybe(result.first); + auto loc(yylloc); + if( loc.first_line == loc.last_line ) { + auto error_col = p - yytext; + if( p == yytext + yyleng ) error_col = picture - yytext; + if( loc.first_column + error_col < loc.last_column ) + loc.first_column += error_col; + } + if( *p ) { + unsigned int pos = p - picture; + error_msg(loc, "invalid PICTURE character %qc at offset %u", *p, pos); + } else { + error_msg(loc, "invalid picture"); + } + } + dbgmsg("%s: returning '%u'", __func__, unsigned(picture - yytext)); + return picture - yytext; +} %} /* C99 floating point constant, per flex(1) appendix "common patterns" */ @@ -1236,9 +1297,10 @@ USE({SPC}FOR)? { return USE; } } PIC(TURE)?({SPC}IS)?{SPC}{PICTURE} { - auto pos = validate_picture(); + auto pos = is_valid_picture(); myless(pos); - yy_push_state(picture); return PIC; } + yy_push_state(picture); return PIC; + } ANY { return ANY; } LENGTH { return LENGTH; } diff --git a/gcc/cobol/scan_ante.h b/gcc/cobol/scan_ante.h index b6172cbe0bc4..729800062099 100644 --- a/gcc/cobol/scan_ante.h +++ b/gcc/cobol/scan_ante.h @@ -1107,12 +1107,8 @@ const std::map picture_t::followers { /* B0/ */ { '/', {"B0/,.Z*+-9AXVPNE" } }, /* , */ { ',', {"B0/,.Z*+-9VPE"} }, /* . */ { '.', {"B0/,Z*+-9E"} }, - /* + { '+', "9" }, */ /* +- */ { '+', {"B0/,.Z*9VPE", "" } }, /* +- */ { '-', {"B0/,.Z*9VPE", "" } }, - /* CR/DB { 'C', "" }, */ - /* cs { 'c', "B0/,.Z*+-9VP" }, */ - /* cs { 'c', "+" }, */ /* Z* */ { 'Z', {"B0/,.+Z*9VP", "B0/,+Z*"} }, /* Z* */ { '*', {"B0/,.+Z*9VP", "B0/,+Z*"} }, /* + */ { '+', {"B0/,.+-9VP", "B0/,+-"} }, From afd69fe25cd653ddd2001f9904b3ff367b0fd476 Mon Sep 17 00:00:00 2001 From: "James K. Lowden" Date: Fri, 18 Sep 2026 11:56:21 -0400 Subject: [PATCH 455/584] cobol: Integrate PICTURE automaton into parser. Technical change only. Remove leftover code and rearrange for clarity. Use usual compiler include files. Prepare to replace parsing of alphanumeric-edited and numeric-edited. This commit also commences new whitespace policy: no committed file will have trailing whitespace. gcc/cobol/ChangeLog: * picture.cc (symbol_currency): Remove test harness mock-up. (cbl_internal_error): Same. (yy_flex_debug): Undefine, per usual. (seek_paren): Use ISALNUM. (is_valid_picture): Use repeat_count to resolve size. * scan_ante.h (repeat_count): Remove declaration. * util.cc (cbl_prototype_ok): Whitespace. (cdf_file): Same. (repeat_count): Same. (cbl_field_t::encode_numeric): Same. (cbl_field_t::report_invalid_initial_value): Same. (literal_subscript_oob): Same. (valid_move): Same. (hex2numstr): Same. (cobol_filename): Same. (gcc_location_set): Same. (parse_file): Same. (iso_cobol_word): Same. * util.h (repeat_count): Declare function. --- gcc/cobol/picture.cc | 602 ++++++++++++++++++++++-------------------- gcc/cobol/scan_ante.h | 2 - gcc/cobol/util.cc | 11 +- gcc/cobol/util.h | 2 + 4 files changed, 318 insertions(+), 299 deletions(-) diff --git a/gcc/cobol/picture.cc b/gcc/cobol/picture.cc index 01a723c7e9a9..965baa27afc1 100644 --- a/gcc/cobol/picture.cc +++ b/gcc/cobol/picture.cc @@ -1,3 +1,33 @@ +/* + * Copyright (c) 2021-2026 Symas Corporation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of the Symas Corporation nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + #include #include #include @@ -6,23 +36,34 @@ #include #include -#include #include #include -#include #include #include -#ifdef COBOL_PICTURE -const char * symbol_currency( char sign ) { - static const char mock_signs[] = "@ŁY&"; - return strchr(mock_signs, sign); -} -void cbl_internal_error(const char *format_string, ...) { assert(false); } -#else -void cbl_internal_error(const char *format_string, ...); -const char * symbol_currency( char sign ); -#endif +#include "cobol-system.h" +#include +#include +#include +#undef yy_flex_debug + +#include + +#include +#include +#include +#include +#include +#include + +#include "util.h" +#include "cbldiag.h" +#include "cdfval.h" +#include "lexio.h" + +#include "../../libgcobol/ec.h" +#include "../../libgcobol/common-defs.h" +#include "symbols.h" namespace picture_validation { @@ -151,6 +192,194 @@ namespace picture_validation { /* CR/DB */ { { postdec_e, 'D' }, {"" "B"} }, }; + //////////////////////////////////////////////////////////////// + + struct transition_t { + state_t state; + char ch; + state_t next_state; + + transition_t( state_t state, + char ch, + state_t next_state ) + : state(state) + , ch(ch) + , next_state(next_state) + {} + + bool operator<(const transition_t& that) const { + if (state == that.state) return ch < that.ch; + return state < that.state; + } + bool operator==(const transition_t& that) const { return match(that); } + bool operator!=(const transition_t& that) const { return ! match(that); } + + protected: + // match verifies that the row returned by std::lower_bound actually + // matches, and isn't the next "bigger" one. + bool match(const transition_t& that) const { + return state == that.state + && ch == that.ch; + } + }; + + static std::vector picture_rules { + // Alpha and Alphanumeric + { none_e, 'A', alphabetic_e }, + { none_e, 'X', alphanumeric_e }, + { none_e, 'B', alpha_ed_e }, + { none_e, '0', alpha_ed_e }, + { none_e, '/', alpha_ed_e }, + { none_e, '9', antedec_e }, // 9 before V + { none_e, 'N', national_e }, + { none_e, 'P', none_e }, + { none_e, 'S', none_e }, + { none_e, 'V', postdec_e, }, // V before 9 + + { none_e, '1', antedec_e }, + { antedec_e, '1', antedec_e }, + + { alphabetic_e, 'A', alphabetic_e }, + { alphabetic_e, 'B', alpha_ed_e }, + { alphabetic_e, '0', alpha_ed_e }, + { alphabetic_e, '/', alpha_ed_e }, + { alphabetic_e, 'X', alphanumeric_e }, + { alphabetic_e, '$', numeric_ed_e }, + + { alphanumeric_e, 'A', alphanumeric_e }, + { alphanumeric_e, 'X', alphanumeric_e }, + { alphanumeric_e, '9', alphanumeric_e }, + + // Alpha edited + { alpha_ed_e, 'B', alpha_ed_e }, + { alpha_ed_e, '0', alpha_ed_e }, + { alpha_ed_e, '/', alpha_ed_e }, + { alpha_ed_e, 'A', alpha_ed_e }, + { alpha_ed_e, 'X', alpha_ed_e }, + { alpha_ed_e, '9', numeric_ed_e }, + { alpha_ed_e, 'Z', numeric_ed_e }, + { alpha_ed_e, '*', numeric_ed_e }, + { alpha_ed_e, '+', numeric_ed_e }, + { alpha_ed_e, '-', numeric_ed_e }, + { alpha_ed_e, dot, numeric_ed_e }, + { alpha_ed_e, com, numeric_ed_e }, + { alpha_ed_e, '$', numeric_ed_e }, + + { alphanumeric_e, 'B', alpha_ed_e }, + { alphanumeric_e, '0', alpha_ed_e }, + { alphanumeric_e, '/', alpha_ed_e }, + + // National + { national_e, 'N', national_e }, + { national_e, '\0', alphanumeric_e }, + + // National edited + { national_e, 'B', national_ed_e }, + { national_e, '0', national_ed_e }, + { national_e, '/', national_ed_e }, + + { national_ed_e, 'N', national_ed_e }, + { national_ed_e, 'B', national_ed_e }, + { national_ed_e, '0', national_ed_e }, + { national_ed_e, '/', national_ed_e }, + { national_ed_e, '\0', alpha_ed_e }, + + // Numeric edited + // [B*] or [+-].*[+-] or (9 and [$B0/,.+-], where $ is cs. + { none_e, 'Z', numeric_ed_e }, + { none_e, '*', numeric_ed_e }, + { none_e, dot, numeric_ed_e }, + { none_e, com, numeric_ed_e }, + { none_e, '-', numeric_ed_e }, + { none_e, '+', numeric_ed_e }, + { none_e, '$', numeric_ed_e }, + + { antedec_e, '9', antedec_e }, + { antedec_e, 'A', alphanumeric_e }, + { antedec_e, 'P', numeric_e }, + { antedec_e, 'V', numeric_e }, + { antedec_e, 'X', alphanumeric_e }, + { antedec_e, 'C', c_need_r_e }, + { antedec_e, 'D', d_need_b_e }, + + { antedec_e, 'Z', numeric_ed_e }, + { antedec_e, '*', numeric_ed_e }, + { antedec_e, '$', numeric_ed_e }, + { antedec_e, dot, numeric_ed_e }, + { antedec_e, com, numeric_ed_e }, + + { postdec_e, '9', numeric_e }, + { postdec_e, 'P', numeric_e }, + + { numeric_e, '9', numeric_e }, + { numeric_e, 'P', numeric_e }, + + { numeric_e, 'Z', numeric_ed_e }, + { numeric_e, '*', numeric_ed_e }, + { numeric_e, 'B', numeric_ed_e }, + { numeric_e, '0', numeric_ed_e }, + { numeric_e, '/', numeric_ed_e }, + { numeric_e, dot, numeric_ed_e }, + { numeric_e, com, numeric_ed_e }, + { numeric_e, '+', numeric_ed_e }, + { numeric_e, '-', numeric_ed_e }, + { numeric_e, '$', numeric_ed_e }, + { numeric_e, 'C', c_need_r_e }, + { numeric_e, 'D', d_need_b_e }, + + { numeric_ed_e, 'Z', numeric_ed_e }, + { numeric_ed_e, 'B', numeric_ed_e }, + { numeric_ed_e, '9', numeric_ed_e }, + { numeric_ed_e, '0', numeric_ed_e }, + { numeric_ed_e, dot, numeric_ed_e }, + { numeric_ed_e, com, numeric_ed_e }, + { numeric_ed_e, '/', numeric_ed_e }, + { numeric_ed_e, '-', numeric_ed_e }, + { numeric_ed_e, '+', numeric_ed_e }, + { numeric_ed_e, '*', numeric_ed_e }, + { numeric_ed_e, '$', numeric_ed_e }, + { numeric_ed_e, 'P', numeric_ed_e }, + { numeric_ed_e, 'V', numeric_ed_e }, // See Table 10 if in doubt. + { numeric_ed_e, 'C', c_need_r_e }, + { numeric_ed_e, 'D', d_need_b_e }, + + // End of the road + { c_need_r_e, 'R', numeric_ed_e }, + { d_need_b_e, 'B', numeric_ed_e }, + }; + + typedef std::array automaton_elem_t; + typedef std::vector automaton_matrix_t; + + const automaton_matrix_t& prepare_automaton() { + static automaton_matrix_t matrix(accept_e); + static bool ready = false; + if( ready ) return matrix; + + int i __attribute__ ((unused)) = 0, nextra = 0; + for( const auto& rule : picture_rules ) { + unsigned char ch(rule.ch); + +#ifdef COBOL_PICTURE + if( matrix[rule.state][ch] ) { + nextra++; + fprintf(stderr, "%s: redundant rule: #%d { %s '%c' %s }\n", + __func__, i, + state_str(rule.state), rule.ch, + state_str(rule.next_state)); + } +#endif + matrix[rule.state][ch] = rule.next_state; + i++; + } + if( nextra ) { + cbl_internal_error("%s: %d redundant rules", __func__, nextra); + } + + ready = true; + return matrix; + } + /* * As the picture string is validated, constraint_t captures what has been * seen: the preceding character and what characters have appeared that @@ -245,7 +474,7 @@ namespace picture_validation { || is_numeric9_ed() ); } - state_t decimal_state; // to lookup sequence validity + state_t pic_state; // to lookup sequence validity uint64_t picsym_set( char ch ) { switch(ch) { @@ -300,43 +529,34 @@ namespace picture_validation { } } - /* - * 1) Every character except V adds to the capacity, with the caveat that - * the first CURRENCY PICTURE character adds the length of the CURRENCY - * SIGN string. - * 2) data.digits has to be the count of 9 + count of Z + count of asterisk - * + (count of $ minus 1) + (count of - minus one) + (count of + minus 1) - * 3) data.rdigits is the subset of 2 that is to the right of either V or - * . (edited)  - * - * For the moment, break out the fact that V should add zero.  Right now - * all of the regression tests assume that V, if there, adds one.  I would - * really rather attack the V change when everything is working. - */ - char prior_ch; - public: + const char decimal_point; int nplus, nminus; + cbl_field_data_t field_data; + public: + const char *bad_repeat; constraint_t() : symbol_mask(0) - , decimal_state(none_e) + , pic_state(none_e) , prior_ch('\0') + , decimal_point(symbol_decimal_point()) , nplus(0), nminus(0) + , bad_repeat(nullptr) {} - constraint_t& operator=( char ch ) { + constraint_t& append( char ch, size_t len ) { picsym_set(ch); prior_ch = ch; if( ch == '+' ) nplus++; if( ch == '-' ) nminus++; + update_capacity(1 + len); observe_the_dot(ch); return *this; } char prior() const { return prior_ch; } - state_t automaton(state_t state) { return decimal_state = state; } - state_t automaton() const { return decimal_state; } - + state_t picture_state(state_t state) { return pic_state = state; } + state_t picture_state() const { return pic_state; } state_t state() const { if( is_alphabetic() ) return alphabetic_e; @@ -357,7 +577,7 @@ namespace picture_validation { * headings in ISO Table 10. */ bool day_follows_night( char ch ) { - auto p = followers.find( follow_key_t {decimal_state, prior_ch} ); + auto p = followers.find( follow_key_t {pic_state, prior_ch} ); if( p != followers.end() ) { const auto& candidates(p->second); auto pnext = std::find( candidates.begin(), candidates.end(), ch ); @@ -365,233 +585,44 @@ namespace picture_validation { } return false; } - protected: - void observe_the_dot( char ch ) { - if( decimal_state == none_e ) decimal_state = antedec_e; - if( ch == '.' || ch == 'V' ) decimal_state = postdec_e; } - } constraint; - - //////////////////////////////////////////////////////////////// - - struct transition_t { - state_t state; - char ch; - state_t next_state; - - transition_t( state_t state, - char ch, - state_t next_state ) - : state(state) - , ch(ch) - , next_state(next_state) - {} - - bool operator<(const transition_t& that) const { - if (state == that.state) return ch < that.ch; - return state < that.state; - } - bool operator==(const transition_t& that) const { return match(that); } - bool operator!=(const transition_t& that) const { return ! match(that); } - - protected: - // match verifies that the row returned by std::lower_bound actually - // matches, and isn't the next "bigger" one. - bool match(const transition_t& that) const { - return state == that.state - && ch == that.ch; - } - }; - - static std::vector picture_rules { - // Alpha and Alphanumeric - { none_e, 'A', alphabetic_e }, - { none_e, 'X', alphanumeric_e }, - { none_e, 'B', alpha_ed_e }, - { none_e, '0', alpha_ed_e }, - { none_e, '/', alpha_ed_e }, - { none_e, '9', antedec_e }, // 9 before V - { none_e, 'N', national_e }, - { none_e, 'P', none_e }, - { none_e, 'S', none_e }, - { none_e, 'V', postdec_e, }, // V before 9 - - { none_e, '1', antedec_e }, - { antedec_e, '1', antedec_e }, - - { alphabetic_e, 'A', alphabetic_e }, - { alphabetic_e, 'B', alpha_ed_e }, - { alphabetic_e, '0', alpha_ed_e }, - { alphabetic_e, '/', alpha_ed_e }, - { alphabetic_e, 'X', alphanumeric_e }, - { alphabetic_e, '$', numeric_ed_e }, - - { alphanumeric_e, 'A', alphanumeric_e }, - { alphanumeric_e, 'X', alphanumeric_e }, - { alphanumeric_e, '9', alphanumeric_e }, - - // Alpha edited - { alpha_ed_e, 'B', alpha_ed_e }, - { alpha_ed_e, '0', alpha_ed_e }, - { alpha_ed_e, '/', alpha_ed_e }, - { alpha_ed_e, 'A', alpha_ed_e }, - { alpha_ed_e, 'X', alpha_ed_e }, - { alpha_ed_e, '9', numeric_ed_e }, - { alpha_ed_e, 'Z', numeric_ed_e }, - { alpha_ed_e, '*', numeric_ed_e }, - { alpha_ed_e, '+', numeric_ed_e }, - { alpha_ed_e, '-', numeric_ed_e }, - { alpha_ed_e, dot, numeric_ed_e }, - { alpha_ed_e, com, numeric_ed_e }, - { alpha_ed_e, '$', numeric_ed_e }, - - { alphanumeric_e, 'B', alpha_ed_e }, - { alphanumeric_e, '0', alpha_ed_e }, - { alphanumeric_e, '/', alpha_ed_e }, - - // National - { national_e, 'N', national_e }, - { national_e, '\0', alphanumeric_e }, - - // National edited - { national_e, 'B', national_ed_e }, - { national_e, '0', national_ed_e }, - { national_e, '/', national_ed_e }, - - { national_ed_e, 'N', national_ed_e }, - { national_ed_e, 'B', national_ed_e }, - { national_ed_e, '0', national_ed_e }, - { national_ed_e, '/', national_ed_e }, - { national_ed_e, '\0', alpha_ed_e }, - - // Numeric edited - // [B*] or [+-].*[+-] or (9 and [$B0/,.+-], where $ is cs. - { none_e, 'Z', numeric_ed_e }, - { none_e, '*', numeric_ed_e }, - { none_e, dot, numeric_ed_e }, - { none_e, com, numeric_ed_e }, - { none_e, '-', numeric_ed_e }, - { none_e, '+', numeric_ed_e }, - { none_e, '$', numeric_ed_e }, - - { antedec_e, '9', antedec_e }, - { antedec_e, 'A', alphanumeric_e }, - { antedec_e, 'P', numeric_e }, - { antedec_e, 'V', numeric_e }, - { antedec_e, 'X', alphanumeric_e }, - { antedec_e, 'C', c_need_r_e }, - { antedec_e, 'D', d_need_b_e }, - { antedec_e, 'Z', numeric_ed_e }, - { antedec_e, '*', numeric_ed_e }, - { antedec_e, '$', numeric_ed_e }, - { antedec_e, dot, numeric_ed_e }, - { antedec_e, com, numeric_ed_e }, - - { postdec_e, '9', numeric_e }, - { postdec_e, 'P', numeric_e }, - - { numeric_e, '9', numeric_e }, - { numeric_e, 'P', numeric_e }, - - { numeric_e, 'Z', numeric_ed_e }, - { numeric_e, '*', numeric_ed_e }, - { numeric_e, 'B', numeric_ed_e }, - { numeric_e, '0', numeric_ed_e }, - { numeric_e, '/', numeric_ed_e }, - { numeric_e, dot, numeric_ed_e }, - { numeric_e, com, numeric_ed_e }, - { numeric_e, '+', numeric_ed_e }, - { numeric_e, '-', numeric_ed_e }, - { numeric_e, '$', numeric_ed_e }, - { numeric_e, 'C', c_need_r_e }, - { numeric_e, 'D', d_need_b_e }, - - { numeric_ed_e, 'Z', numeric_ed_e }, - { numeric_ed_e, 'B', numeric_ed_e }, - { numeric_ed_e, '9', numeric_ed_e }, - { numeric_ed_e, '0', numeric_ed_e }, - { numeric_ed_e, dot, numeric_ed_e }, - { numeric_ed_e, com, numeric_ed_e }, - { numeric_ed_e, '/', numeric_ed_e }, - { numeric_ed_e, '-', numeric_ed_e }, - { numeric_ed_e, '+', numeric_ed_e }, - { numeric_ed_e, '*', numeric_ed_e }, - { numeric_ed_e, '$', numeric_ed_e }, - { numeric_ed_e, 'P', numeric_ed_e }, - { numeric_ed_e, 'V', numeric_ed_e }, // See Table 10 if in doubt. - { numeric_ed_e, 'C', c_need_r_e }, - { numeric_ed_e, 'D', d_need_b_e }, - - // End of the road - { c_need_r_e, 'R', numeric_ed_e }, - { d_need_b_e, 'B', numeric_ed_e }, - }; - - typedef std::array automaton_elem_t; - typedef std::vector automaton_matrix_t; - - const automaton_matrix_t& prepare_automaton() { - static automaton_matrix_t matrix(accept_e); - static bool ready = false; - if( ready ) return matrix; - - int i __attribute__ ((unused)) = 0, nextra = 0; - for( const auto& rule : picture_rules ) { - unsigned char ch(rule.ch); - -#ifdef COBOL_PICTURE - if( matrix[rule.state][ch] ) { - nextra++; - fprintf(stderr, "%s: redundant rule: #%d { %s '%c' %s }\n", - __func__, i, - state_str(rule.state), rule.ch, - state_str(rule.next_state)); + void prior_repeats( int n ) { + if( prior_ch != 'P' ) { + update_capacity(n); } -#endif - matrix[rule.state][ch] = rule.next_state; - i++; } - if( nextra ) { - cbl_internal_error("%s: %d redundant rules", __func__, nextra); + + protected: + void observe_the_dot( char ch ) { + if( pic_state == none_e ) pic_state = antedec_e; + if( ch == decimal_point || ch == 'V' ) pic_state = postdec_e; } - - ready = true; - return matrix; - } - - void sort_rules() { -#ifdef COBOL_PICTURE - // During development, verify the ruleset is unique. - std::set U; - int i=0; - for( const auto& r : picture_validation::picture_rules ) { - auto result = U.insert(r); - if( ! result.second ) { - auto extra = result.first; - fprintf(stderr, "%s: redundant rule: #%d { %s '%c' %s }\n", - __func__, i, - state_str(extra->state), - extra->ch, - state_str(extra->next_state)); + /* + * 1) Every character except V adds to the capacity, with the caveat that + * the first CURRENCY PICTURE character adds the length of the CURRENCY + * SIGN string. + * 2) data.digits has to be the count of 9 + count of Z + count of asterisk + * + (count of $ minus 1) + (count of - minus one) + (count of + minus 1) + * 3) data.rdigits is the subset of 2 that is to the right of either V or + * . (edited)  + * + * For the moment, break out the fact that V should add zero.  Right now + * all of the regression tests assume that V, if there, adds one.  I would + * really rather attack the V change when everything is working. + */ + void update_capacity( int n = 1) { + static const std::string nonsize( "PVCRDB" ); + + if( std::string::npos == nonsize.find(prior_ch) ) { + field_data.add_capacity(n); + if( pic_state == postdec_e ) { + field_data.rdigits += n; + } } - i++; } -#endif - std::sort( picture_validation::picture_rules.begin(), - picture_validation::picture_rules.end() ); - auto extra = std::unique( picture_validation::picture_rules.begin(), - picture_validation::picture_rules.end() ); - if( extra != picture_validation::picture_rules.end() ) { -#ifndef COBOL_PICTURE - cbl_internal_error("%s: redundant rule: { %s %qc %s }", __func__, - state_str(extra->state), - extra->ch, - state_str(extra->next_state)); -#endif - assert(false && "Redundant rules detected"); - } - } -} + + }; +} // end namespace using picture_validation::transition_t; using picture_validation::state_t; @@ -603,7 +634,7 @@ using picture_validation::state_t; static const char * seek_paren( const char *p, const char *epicture ) { for( p++; p < epicture; p++ ) { - if( ! isalnum(*p) ) { + if( ! ISALNUM(*p) ) { switch(*p) { case '-': case '_': @@ -632,16 +663,9 @@ end_of_picture( const char *p, const char *epicture ) { std::pair is_valid_picture(const char picture[]) { - static bool sorted = false; - if( ! sorted ) { - picture_validation::sort_rules(); - sorted = true; - } - - const auto& rules( picture_validation::picture_rules ); - // reset the global constraint structure. - auto& constraint(picture_validation::constraint); - constraint = picture_validation::constraint_t(); + picture_validation::constraint_t constraint; + const picture_validation::automaton_matrix_t& + automaton = picture_validation::prepare_automaton(); if( ! picture ) { return {picture, picture_validation::invalid_e}; @@ -653,6 +677,7 @@ is_valid_picture(const char picture[]) { // Advance lookahead past any count, which might be name. // No picture begins with a '('. if( picture < p && *p == '(' && p+1 < epicture ) { + const char *paren = p; p = seek_paren(p, epicture); if( *p != ')' ) { return {p, picture_validation::invalid_e}; @@ -661,47 +686,48 @@ is_valid_picture(const char picture[]) { return {p, picture_validation::invalid_e}; } p++; + auto result = repeat_count(--paren); + int len = result.first; + if( len == 0 ) { + dbgmsg("%s: odd zero repeat_count for '%s'", __func__, paren); + constraint.bad_repeat = paren; + return {paren, picture_validation::invalid_e}; + } + constraint.prior_repeats(len); } - // Dot as last character is period separator because the lexer defines - // end-of-picture as a space. if( end_of_picture(p, epicture) ) break; // Now p is fixed, but ch might be a currency symbol - char ch = toupper(*p); + char ch = TOUPPER(*p); // Is the current character ever allowed to follow the prior? + size_t currency_len = 0; if( ! constraint.day_follows_night(ch) ) { - if( symbol_currency(ch) ) { + const char *currency = symbol_currency(ch); + if( currency ) { ch = '$'; + currency_len = strlen(currency); } else { if( verbose ) fprintf(stderr, "no %2zu: %c -> %c (%s)\n", p - picture, constraint.prior(), ch, - picture_validation::state_str(constraint.automaton()) ); + picture_validation::state_str(constraint.picture_state()) ); return {p, picture_validation::invalid_e}; } } - // Consult the rules. - picture_validation::transition_t query { state, ch, state }; - - auto prule = std::lower_bound(rules.begin(), rules.end(), query); + // Update constraint record and advance to the next state. + constraint.append(ch, currency_len); + state = automaton[state][ch]; - if( prule == rules.end() || *prule != query ) { - state_t state = p == epicture? - constraint.state() : picture_validation::invalid_e; - return {p, state}; + if( verbose ) { + fprintf(stderr, "ok %2zu: %c (next: %s)\n", + p - picture, ch, picture_validation::state_str(state)); + } + if( state == picture_validation::invalid_e ) { + return {p, picture_validation::invalid_e}; } - - if( verbose ) - fprintf(stderr, "ok %2zu: %c (%s)\n", - p - picture, ch, - picture_validation::state_str(prule->next_state) ); - - // Advance to the next state. - constraint = ch; - state = prule->next_state; } return {epicture, constraint.state()}; diff --git a/gcc/cobol/scan_ante.h b/gcc/cobol/scan_ante.h index 729800062099..f87db5657035 100644 --- a/gcc/cobol/scan_ante.h +++ b/gcc/cobol/scan_ante.h @@ -58,8 +58,6 @@ int repository_function_tok( const char name[] ); void next_sentence_label(cbl_label_t*); -std::pair repeat_count(const char picture[]); - size_t program_level(); static int ydfparse(void); diff --git a/gcc/cobol/util.cc b/gcc/cobol/util.cc index e45252259816..3085b01bec70 100644 --- a/gcc/cobol/util.cc +++ b/gcc/cobol/util.cc @@ -28,12 +28,6 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -/* - * This file supports parsing without requiring access to the symbol - * table definition. Unlike the Bison input, this file brings in gcc - * header files. - */ - #include "cobol-system.h" #include #include @@ -2182,7 +2176,7 @@ literal_subscript_oob( const cbl_refer_t& r, size_t& isub /* output */) { for( isub=0; isub < ndim; isub++ ) { const auto& subscript = r.subscripts[isub]; const auto& occurs = dims[isub]->occurs; - + if( ! occurs.subscript_ok(subscript.field) ) { break; // found one } @@ -2550,7 +2544,7 @@ hex2numstr( const char input[] ) { int n = sscanf(++input, "%c%" GCC_PRISZ "x%c", &q, &value, &q); assert(n == 3 && (q == '\'' || q == '"')); - + return xasprintf("%lu", value); } @@ -4672,4 +4666,3 @@ iso_cobol_word( const std::string& name, bool include_context ) { } return ok; } - diff --git a/gcc/cobol/util.h b/gcc/cobol/util.h index b99533944376..2cf91dcd2b27 100644 --- a/gcc/cobol/util.h +++ b/gcc/cobol/util.h @@ -45,6 +45,8 @@ void cobol_filename_restore(); const char * cobol_lineno( int ); int cobol_lineno(void); +std::pair repeat_count(const char picture[]); + unsigned long gb4( size_t input ); template From 96a93d365915cbe8e14a015f7175d27359998ddc Mon Sep 17 00:00:00 2001 From: "James K. Lowden" Date: Sun, 20 Sep 2026 11:51:02 -0400 Subject: [PATCH 456/584] cobol: Add official COBOL word lists to parser. gcc/cobol/ChangeLog: * words/cdf.h: New file. * words/intrinsic.h: New file. * words/reserved.h: New file. --- gcc/cobol/words/cdf.h | 42 ++++ gcc/cobol/words/intrinsic.h | 99 +++++++++ gcc/cobol/words/reserved.h | 418 ++++++++++++++++++++++++++++++++++++ 3 files changed, 559 insertions(+) create mode 100644 gcc/cobol/words/cdf.h create mode 100644 gcc/cobol/words/intrinsic.h create mode 100644 gcc/cobol/words/reserved.h diff --git a/gcc/cobol/words/cdf.h b/gcc/cobol/words/cdf.h new file mode 100644 index 000000000000..ffc645da6308 --- /dev/null +++ b/gcc/cobol/words/cdf.h @@ -0,0 +1,42 @@ +// Generated from gcc/cobol/words +#ifndef _CDF_H_ +#define _CDF_H_ +{ + tok_name_t { "CALL-CONVENTION" }, + tok_name_t { "CHECKING" }, + tok_name_t { "COBOL" }, + tok_name_t { "COBOL-WORDS" }, + tok_name_t { "COMPILE-TIME-ARITHMETIC-EXPRESSIONS" }, + tok_name_t { "DE-EDITING" }, + tok_name_t { "DEFINE" }, + tok_name_t { "DEFINED" }, + tok_name_t { "EQUATE" }, + tok_name_t { "EXTERNAL-FILE-FILE-STATUS" }, + tok_name_t { "FIXED" }, + tok_name_t { "FLAG-02" }, + tok_name_t { "FLAG-14" }, + tok_name_t { "FUNCTION-ARGUMENT" }, + tok_name_t { "I-O-DECLARATIVE" }, + tok_name_t { "I-O-STATUS-04" }, + tok_name_t { "I-O-STATUS-07" }, + tok_name_t { "IMP" }, + tok_name_t { "LEAP-SECOND" }, + tok_name_t { "LISTING" }, + tok_name_t { "MOVE-TO-SAME-NAME" }, + tok_name_t { "NUMVAL" }, + tok_name_t { "PARAMETER" }, + tok_name_t { "POP" }, + tok_name_t { "PROPAGATE" }, + tok_name_t { "PUSH" }, + tok_name_t { "READ-PREVIOUS" }, + tok_name_t { "REF-MOD-ZERO-LENGTH" }, + tok_name_t { "SUBSTITUTE" }, + tok_name_t { "TURN" }, + tok_name_t { "UNDEFINE" }, + tok_name_t { "VALUE-EDITING" }, + tok_name_t { "VALUE-FIG-CON-LENGTH" }, + tok_name_t { "VALUE-ZERO" }, + tok_name_t { "WRITE-END-OF-PAGE" }, + tok_name_t { "ZERO-LENGTH" }, +}; // end cdf word list +#endif diff --git a/gcc/cobol/words/intrinsic.h b/gcc/cobol/words/intrinsic.h new file mode 100644 index 000000000000..388aec230a1a --- /dev/null +++ b/gcc/cobol/words/intrinsic.h @@ -0,0 +1,99 @@ +// Generated from gcc/cobol/words +#ifndef _INTRINSIC_H_ +#define _INTRINSIC_H_ +{ + tok_name_t { "ABS" }, + tok_name_t { "ACOS" }, + tok_name_t { "ANNUITY" }, + tok_name_t { "ASIN" }, + tok_name_t { "ATAN" }, + tok_name_t { "BASECONVERT" }, + tok_name_t { "BOOLEAN-OF-INTEGER" }, + tok_name_t { "BYTE-LENGTH" }, + tok_name_t { "CHAR" }, + tok_name_t { "CHAR-NATIONAL" }, + tok_name_t { "COMBINED-DATETIME" }, + tok_name_t { "CONCAT" }, + tok_name_t { "CONVERT" }, + tok_name_t { "COS" }, + tok_name_t { "CURRENT-DATE" }, + tok_name_t { "DATE-OF-INTEGER" }, + tok_name_t { "DATE-TO-YYYYMMDD" }, + tok_name_t { "DAY-OF-INTEGER" }, + tok_name_t { "DAY-TO-YYYYDDD" }, + tok_name_t { "DISPLAY-OF" }, + tok_name_t { "E" }, + tok_name_t { "EXCEPTION-FILE" }, + tok_name_t { "EXCEPTION-FILE-N" }, + tok_name_t { "EXCEPTION-LOCATION" }, + tok_name_t { "EXCEPTION-LOCATION-N" }, + tok_name_t { "EXCEPTION-STATEMENT" }, + tok_name_t { "EXCEPTION-STATUS" }, + tok_name_t { "EXP" }, + tok_name_t { "EXP10" }, + tok_name_t { "FACTORIAL" }, + tok_name_t { "FIND-STRING" }, + tok_name_t { "FORMATTED-CURRENT-DATE" }, + tok_name_t { "FORMATTED-DATE" }, + tok_name_t { "FORMATTED-DATETIME" }, + tok_name_t { "FORMATTED-TIME" }, + tok_name_t { "FRACTION-PART" }, + tok_name_t { "HIGHEST-ALGEBRAIC" }, + tok_name_t { "INTEGER" }, + tok_name_t { "INTEGER-OF-BOOLEAN" }, + tok_name_t { "INTEGER-OF-DATE" }, + tok_name_t { "INTEGER-OF-DAY" }, + tok_name_t { "INTEGER-OF-FORMATTED-DATE" }, + tok_name_t { "INTEGER-PART" }, + tok_name_t { "LENGTH" }, + tok_name_t { "LOCALE-COMPARE" }, + tok_name_t { "LOCALE-DATE" }, + tok_name_t { "LOCALE-TIME" }, + tok_name_t { "LOCALE-TIME-FROM-SECONDS" }, + tok_name_t { "LOG" }, + tok_name_t { "LOG10" }, + tok_name_t { "LOWER-CASE" }, + tok_name_t { "LOWEST-ALGEBRAIC" }, + tok_name_t { "MAX" }, + tok_name_t { "MEAN" }, + tok_name_t { "MEDIAN" }, + tok_name_t { "MIDRANGE" }, + tok_name_t { "MIN" }, + tok_name_t { "MOD" }, + tok_name_t { "MODULE-NAME" }, + tok_name_t { "NATIONAL-OF" }, + tok_name_t { "NUMVAL" }, + tok_name_t { "NUMVAL-C" }, + tok_name_t { "NUMVAL-F" }, + tok_name_t { "ORD" }, + tok_name_t { "ORD-MAX" }, + tok_name_t { "ORD-MIN" }, + tok_name_t { "PI" }, + tok_name_t { "PRESENT-VALUE" }, + tok_name_t { "RANDOM" }, + tok_name_t { "RANGE" }, + tok_name_t { "REM" }, + tok_name_t { "REVERSE" }, + tok_name_t { "SECONDS-FROM-FORMATTED-TIME" }, + tok_name_t { "SECONDS-PAST-MIDNIGHT" }, + tok_name_t { "SIGN" }, + tok_name_t { "SIN" }, + tok_name_t { "SMALLEST-ALGEBRAIC" }, + tok_name_t { "SQRT" }, + tok_name_t { "STANDARD-COMPARE" }, + tok_name_t { "STANDARD-DEVIATION" }, + tok_name_t { "SUBSTITUTE" }, + tok_name_t { "SUM" }, + tok_name_t { "TAN" }, + tok_name_t { "TEST-DATE-YYYYMMDD" }, + tok_name_t { "TEST-DAY-YYYYDDD" }, + tok_name_t { "TEST-FORMATTED-DATETIME" }, + tok_name_t { "TEST-NUMVAL" }, + tok_name_t { "TEST-NUMVAL-C" }, + tok_name_t { "TEST-NUMVAL-F" }, + tok_name_t { "TRIM" }, + tok_name_t { "UPPER-CASE" }, + tok_name_t { "VARIANCE" }, + tok_name_t { "WHEN-COMPILED" }, +}; // end intrinsic word list +#endif diff --git a/gcc/cobol/words/reserved.h b/gcc/cobol/words/reserved.h new file mode 100644 index 000000000000..7cd75480670c --- /dev/null +++ b/gcc/cobol/words/reserved.h @@ -0,0 +1,418 @@ +// Generated from gcc/cobol/words +#ifndef _RESERVED_H_ +#define _RESERVED_H_ +{ + tok_name_t { "ACCEPT" }, + tok_name_t { "ACCESS" }, + tok_name_t { "ACTIVE-CLASS" }, + tok_name_t { "ADD" }, + tok_name_t { "ADDRESS" }, + tok_name_t { "ADVANCING" }, + tok_name_t { "AFTER" }, + tok_name_t { "ALIGNED" }, + tok_name_t { "ALL" }, + tok_name_t { "ALLOCATE" }, + tok_name_t { "ALPHABET" }, + tok_name_t { "ALPHABETIC" }, + tok_name_t { "ALPHABETIC-LOWER" }, + tok_name_t { "ALPHABETIC-UPPER" }, + tok_name_t { "ALPHANUMERIC" }, + tok_name_t { "ALPHANUMERIC-EDITED" }, + tok_name_t { "ALSO" }, + tok_name_t { "ALTERNATE" }, + tok_name_t { "AND" }, + tok_name_t { "ANY" }, + tok_name_t { "ANYCASE" }, + tok_name_t { "ARE" }, + tok_name_t { "AREA" }, + tok_name_t { "AREAS" }, + tok_name_t { "AS" }, + tok_name_t { "ASCENDING" }, + tok_name_t { "ASSIGN" }, + tok_name_t { "AT" }, + tok_name_t { "B-AND" }, + tok_name_t { "B-NOT" }, + tok_name_t { "B-OR" }, + tok_name_t { "B-SHIFT-L" }, + tok_name_t { "B-SHIFT-LC" }, + tok_name_t { "B-SHIFT-R" }, + tok_name_t { "B-SHIFT-RC" }, + tok_name_t { "B-XOR" }, + tok_name_t { "BASED" }, + tok_name_t { "BEFORE" }, + tok_name_t { "BINARY" }, + tok_name_t { "BINARY-CHAR" }, + tok_name_t { "BINARY-DOUBLE" }, + tok_name_t { "BINARY-LONG" }, + tok_name_t { "BINARY-SHORT" }, + tok_name_t { "BIT" }, + tok_name_t { "BLANK" }, + tok_name_t { "BLOCK" }, + tok_name_t { "BOOLEAN" }, + tok_name_t { "BOTTOM" }, + tok_name_t { "BY" }, + tok_name_t { "CALL" }, + tok_name_t { "CANCEL" }, + tok_name_t { "CF" }, + tok_name_t { "CH" }, + tok_name_t { "CHARACTER" }, + tok_name_t { "CHARACTERS" }, + tok_name_t { "CLASS" }, + tok_name_t { "CLASS-ID" }, + tok_name_t { "CLOSE" }, + tok_name_t { "CODE" }, + tok_name_t { "CODE-SET" }, + tok_name_t { "COL" }, + tok_name_t { "COLLATING" }, + tok_name_t { "COLS" }, + tok_name_t { "COLUMN" }, + tok_name_t { "COLUMNS" }, + tok_name_t { "COMMA" }, + tok_name_t { "COMMIT" }, + tok_name_t { "COMMON" }, + tok_name_t { "COMP" }, + tok_name_t { "COMPUTATIONAL" }, + tok_name_t { "COMPUTE" }, + tok_name_t { "CONDITION" }, + tok_name_t { "CONFIGURATION" }, + tok_name_t { "CONSTANT" }, + tok_name_t { "CONTAINS" }, + tok_name_t { "CONTENT" }, + tok_name_t { "CONTINUE" }, + tok_name_t { "CONTROL" }, + tok_name_t { "CONTROLS" }, + tok_name_t { "CONVERTING" }, + tok_name_t { "COPY" }, + tok_name_t { "CORR" }, + tok_name_t { "CORRESPONDING" }, + tok_name_t { "COUNT" }, + tok_name_t { "CRT" }, + tok_name_t { "CURRENCY" }, + tok_name_t { "CURSOR" }, + tok_name_t { "DATA" }, + tok_name_t { "DATA-POINTER" }, + tok_name_t { "DATE" }, + tok_name_t { "DAY" }, + tok_name_t { "DAY-OF-WEEK" }, + tok_name_t { "DE" }, + tok_name_t { "DECIMAL-POINT" }, + tok_name_t { "DECLARATIVES" }, + tok_name_t { "DEFAULT" }, + tok_name_t { "DELETE" }, + tok_name_t { "DELIMITED" }, + tok_name_t { "DELIMITER" }, + tok_name_t { "DEPENDING" }, + tok_name_t { "DESCENDING" }, + tok_name_t { "DESTINATION" }, + tok_name_t { "DETAIL" }, + tok_name_t { "DISPLAY" }, + tok_name_t { "DIVIDE" }, + tok_name_t { "DIVISION" }, + tok_name_t { "DOWN" }, + tok_name_t { "DUPLICATES" }, + tok_name_t { "DYNAMIC" }, + tok_name_t { "EC" }, + tok_name_t { "EDITING" }, + tok_name_t { "ELSE" }, + tok_name_t { "EMD-START" }, + tok_name_t { "END" }, + tok_name_t { "END-ACCEPT" }, + tok_name_t { "END-ADD" }, + tok_name_t { "END-CALL" }, + tok_name_t { "END-COMPUTE" }, + tok_name_t { "END-DELETE" }, + tok_name_t { "END-DISPLAY" }, + tok_name_t { "END-DIVIDE" }, + tok_name_t { "END-EVALUATE" }, + tok_name_t { "END-IF" }, + tok_name_t { "END-MULTIPLY" }, + tok_name_t { "END-OF-PAGE" }, + tok_name_t { "END-PERFORM" }, + tok_name_t { "END-READ" }, + tok_name_t { "END-RECEIVE" }, + tok_name_t { "END-RETURN" }, + tok_name_t { "END-REWRITE" }, + tok_name_t { "END-SEARCH" }, + tok_name_t { "END-SEND" }, + tok_name_t { "END-STRING" }, + tok_name_t { "END-SUBTRACT" }, + tok_name_t { "END-UNSTRING" }, + tok_name_t { "END-WRITE" }, + tok_name_t { "ENVIRONMENT" }, + tok_name_t { "EO" }, + tok_name_t { "EOP" }, + tok_name_t { "EQUAL" }, + tok_name_t { "ERROR" }, + tok_name_t { "EVALUATE" }, + tok_name_t { "EXCEPTION" }, + tok_name_t { "EXCEPTION-OBJECT" }, + tok_name_t { "EXCLUSIVE-OR" }, + tok_name_t { "EXIT" }, + tok_name_t { "EXTEND" }, + tok_name_t { "EXTERNAL" }, + tok_name_t { "FACTORY" }, + tok_name_t { "FALSE" }, + tok_name_t { "FARTHEST-FROM-ZERO" }, + tok_name_t { "FD" }, + tok_name_t { "FILE" }, + tok_name_t { "FILE-CONTROL" }, + tok_name_t { "FILLER" }, + tok_name_t { "FINAL" }, + tok_name_t { "FINALLY" }, + tok_name_t { "FIRST" }, + tok_name_t { "FLOAT-BINARY-128" }, + tok_name_t { "FLOAT-BINARY-32" }, + tok_name_t { "FLOAT-BINARY-64" }, + tok_name_t { "FLOAT-DECIMAL-16" }, + tok_name_t { "FLOAT-DECIMAL-34" }, + tok_name_t { "FLOAT-EXTENDED" }, + tok_name_t { "FLOAT-INFINITY" }, + tok_name_t { "FLOAT-LONG" }, + tok_name_t { "FLOAT-NOT-A-NUMBER" }, + tok_name_t { "FLOAT-NOT-A-NUMBER-" }, + tok_name_t { "FLOAT-NOT-A-NUMBER-" }, + tok_name_t { "FLOAT-SHORT" }, + tok_name_t { "FOOTING" }, + tok_name_t { "FOR" }, + tok_name_t { "FORMAT" }, + tok_name_t { "FREE" }, + tok_name_t { "FROM" }, + tok_name_t { "FUNCTION" }, + tok_name_t { "FUNCTION-ID" }, + tok_name_t { "FUNCTION-POINTER" }, + tok_name_t { "GENERATE" }, + tok_name_t { "GET" }, + tok_name_t { "GIVING" }, + tok_name_t { "GLOBAL" }, + tok_name_t { "GO" }, + tok_name_t { "GOBACK" }, + tok_name_t { "GREATER" }, + tok_name_t { "GROUP" }, + tok_name_t { "GROUP-USAGE" }, + tok_name_t { "HEADING" }, + tok_name_t { "HIGH-VALUE" }, + tok_name_t { "HIGH-VALUES" }, + tok_name_t { "I-OICONTROL" }, + tok_name_t { "IDENTIFICATION" }, + tok_name_t { "IF" }, + tok_name_t { "IN" }, + tok_name_t { "IN-ARITHMETIC-RANGE" }, + tok_name_t { "INDEX" }, + tok_name_t { "INDEXED" }, + tok_name_t { "INDICATE" }, + tok_name_t { "INHERITS" }, + tok_name_t { "INITIAL" }, + tok_name_t { "INITIALIZE" }, + tok_name_t { "INITIATE" }, + tok_name_t { "INPUT" }, + tok_name_t { "INPUT-OUTPUT" }, + tok_name_t { "INSPECT" }, + tok_name_t { "INTERFACE" }, + tok_name_t { "INTERFACE-ID" }, + tok_name_t { "INTO" }, + tok_name_t { "INVALID" }, + tok_name_t { "INVOKE" }, + tok_name_t { "IS" }, + tok_name_t { "JUST" }, + tok_name_t { "JUSTIFIED" }, + tok_name_t { "KEY" }, + tok_name_t { "LAST" }, + tok_name_t { "LEADING" }, + tok_name_t { "LEFT" }, + tok_name_t { "LENGTH" }, + tok_name_t { "LESS" }, + tok_name_t { "LIMIT" }, + tok_name_t { "LIMITS" }, + tok_name_t { "LINAGE" }, + tok_name_t { "LINAGE-COUNTER" }, + tok_name_t { "LINE" }, + tok_name_t { "LINE-COUNTER" }, + tok_name_t { "LINES" }, + tok_name_t { "LINKAGE" }, + tok_name_t { "LOCAL-STORAGE" }, + tok_name_t { "LOCALE" }, + tok_name_t { "LOCATION" }, + tok_name_t { "LOCK" }, + tok_name_t { "LOW-VALUE" }, + tok_name_t { "LOW-VALUES" }, + tok_name_t { "MERGE" }, + tok_name_t { "MESSAGE-TAG" }, + tok_name_t { "METHOD-ID" }, + tok_name_t { "MINUS" }, + tok_name_t { "MODE" }, + tok_name_t { "MOVE" }, + tok_name_t { "MULTIPLY" }, + tok_name_t { "NATIONAL" }, + tok_name_t { "NATIONAL-EDITED" }, + tok_name_t { "NATIVE" }, + tok_name_t { "NEAREST-TO-ZERO" }, + tok_name_t { "NEGATIVE" }, + tok_name_t { "NESTED" }, + tok_name_t { "NEXT" }, + tok_name_t { "NO" }, + tok_name_t { "NOT" }, + tok_name_t { "NULL" }, + tok_name_t { "NUMBER" }, + tok_name_t { "NUMERIC" }, + tok_name_t { "NUMERIC-EDITED" }, + tok_name_t { "OBJECT" }, + tok_name_t { "OBJECT-COMPUTER" }, + tok_name_t { "OBJECT-REFERENCE" }, + tok_name_t { "OCCURS" }, + tok_name_t { "OF" }, + tok_name_t { "OFF" }, + tok_name_t { "OMITTED" }, + tok_name_t { "ON" }, + tok_name_t { "OPEN" }, + tok_name_t { "OPTIONAL" }, + tok_name_t { "OPTIONS" }, + tok_name_t { "OR" }, + tok_name_t { "ORDER" }, + tok_name_t { "ORGANIZATION" }, + tok_name_t { "OTHER" }, + tok_name_t { "OUTPUT" }, + tok_name_t { "OVERFLOW" }, + tok_name_t { "OVERRIDE" }, + tok_name_t { "PACKED-DECIMAL" }, + tok_name_t { "PAGE" }, + tok_name_t { "PAGE-COUNTER" }, + tok_name_t { "PERFORM" }, + tok_name_t { "PF" }, + tok_name_t { "PH" }, + tok_name_t { "PIC" }, + tok_name_t { "PICTURE" }, + tok_name_t { "PLUS" }, + tok_name_t { "POINTER" }, + tok_name_t { "POSITIVE" }, + tok_name_t { "PRESENT" }, + tok_name_t { "PRINTING" }, + tok_name_t { "PROCEDURE" }, + tok_name_t { "PROGRAM" }, + tok_name_t { "PROGRAM-ID" }, + tok_name_t { "PROGRAM-POINTER" }, + tok_name_t { "PROPERTY" }, + tok_name_t { "PROTOTYPE" }, + tok_name_t { "QUIET" }, + tok_name_t { "QUOTE" }, + tok_name_t { "QUOTES" }, + tok_name_t { "RAISE" }, + tok_name_t { "RAISING" }, + tok_name_t { "RANDOM" }, + tok_name_t { "RD" }, + tok_name_t { "READ" }, + tok_name_t { "RECEIVE" }, + tok_name_t { "RECORD" }, + tok_name_t { "RECORDS" }, + tok_name_t { "REDEFINES" }, + tok_name_t { "REEL" }, + tok_name_t { "REFERENCE" }, + tok_name_t { "RELATIVE" }, + tok_name_t { "RELEASE" }, + tok_name_t { "REMAINDER" }, + tok_name_t { "REMOVAL" }, + tok_name_t { "RENAMES" }, + tok_name_t { "REPLACE" }, + tok_name_t { "REPLACING" }, + tok_name_t { "REPORT" }, + tok_name_t { "REPORTING" }, + tok_name_t { "REPORTS" }, + tok_name_t { "REPOSITORY" }, + tok_name_t { "RESERVE" }, + tok_name_t { "RESET" }, + tok_name_t { "RESUME" }, + tok_name_t { "RETRY" }, + tok_name_t { "RETURN" }, + tok_name_t { "RETURNING" }, + tok_name_t { "REWIND" }, + tok_name_t { "REWRITE" }, + tok_name_t { "RF" }, + tok_name_t { "RH" }, + tok_name_t { "RIGHT" }, + tok_name_t { "ROLLBACK" }, + tok_name_t { "ROUNDED" }, + tok_name_t { "RUN" }, + tok_name_t { "SAME" }, + tok_name_t { "SCREEN" }, + tok_name_t { "SD" }, + tok_name_t { "SEARCH" }, + tok_name_t { "SECTION" }, + tok_name_t { "SELECT" }, + tok_name_t { "SELF" }, + tok_name_t { "SEND" }, + tok_name_t { "SENTENCE" }, + tok_name_t { "SEPARATE" }, + tok_name_t { "SEQUENCE" }, + tok_name_t { "SEQUENTIAL" }, + tok_name_t { "SET" }, + tok_name_t { "SHARING" }, + tok_name_t { "SIGN" }, + tok_name_t { "SIGNALING" }, + tok_name_t { "SIZE" }, + tok_name_t { "SORT" }, + tok_name_t { "SORT-MERGE" }, + tok_name_t { "SOURCE" }, + tok_name_t { "SOURCE-COMPUTER" }, + tok_name_t { "SOURCES" }, + tok_name_t { "SPACE" }, + tok_name_t { "SPACES" }, + tok_name_t { "SPECIAL-NAMES" }, + tok_name_t { "STANDARD" }, + tok_name_t { "STANDARD-1" }, + tok_name_t { "STANDARD-2" }, + tok_name_t { "START" }, + tok_name_t { "STATUS" }, + tok_name_t { "STOP" }, + tok_name_t { "STRING" }, + tok_name_t { "SUBTRACT" }, + tok_name_t { "SUM" }, + tok_name_t { "SUPER" }, + tok_name_t { "SUPPRESS" }, + tok_name_t { "SYMBOLIC" }, + tok_name_t { "SYNC" }, + tok_name_t { "SYNCHRONIZED" }, + tok_name_t { "SYSTEM-DEFAULT" }, + tok_name_t { "TABLE" }, + tok_name_t { "TALLYING" }, + tok_name_t { "TERMINATE" }, + tok_name_t { "TEST" }, + tok_name_t { "THAN" }, + tok_name_t { "THEN" }, + tok_name_t { "THROUGH" }, + tok_name_t { "THRU" }, + tok_name_t { "TIME" }, + tok_name_t { "TIMES" }, + tok_name_t { "TO" }, + tok_name_t { "TOP" }, + tok_name_t { "TRAILING" }, + tok_name_t { "TRUE" }, + tok_name_t { "TYPE" }, + tok_name_t { "TYPEDEF" }, + tok_name_t { "UNIT" }, + tok_name_t { "UNIVERSAL" }, + tok_name_t { "UNLOCK" }, + tok_name_t { "UNSTRING" }, + tok_name_t { "UNTIL" }, + tok_name_t { "UP" }, + tok_name_t { "UPON" }, + tok_name_t { "USAGE" }, + tok_name_t { "USE" }, + tok_name_t { "USER-DEFAULT" }, + tok_name_t { "USING" }, + tok_name_t { "VAL-STATUS" }, + tok_name_t { "VALID" }, + tok_name_t { "VALIDATE" }, + tok_name_t { "VALIDATE-STATUS" }, + tok_name_t { "VALUE" }, + tok_name_t { "VALUES" }, + tok_name_t { "VARYING" }, + tok_name_t { "WHEN" }, + tok_name_t { "WITH" }, + tok_name_t { "WORKING-STORAGE" }, + tok_name_t { "WRITE" }, + tok_name_t { "XOR" }, + tok_name_t { "ZERO" }, + tok_name_t { "ZEROES" }, + tok_name_t { "ZEROS" }, + tok_name_t { "i-O" }, +}; // end reserved word list +#endif From 0d9d02d35c64c7d821ca80781ee7360f3f52a0c5 Mon Sep 17 00:00:00 2001 From: "James K. Lowden" Date: Thu, 24 Sep 2026 17:58:08 -0400 Subject: [PATCH 457/584] cobol: Correct filename report in default Exception Condition handler. Diagnositic reported current program rather than the one raising the EC. libgcobol/ChangeLog: * libgcobol.cc (default_exception_handler): Use ec_status.source_file. (__gg__move_stash_release): Delete blank line. --- libgcobol/libgcobol.cc | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/libgcobol/libgcobol.cc b/libgcobol/libgcobol.cc index f4bb4c18e702..fec2198ea0fc 100644 --- a/libgcobol/libgcobol.cc +++ b/libgcobol/libgcobol.cc @@ -9922,7 +9922,7 @@ default_exception_handler( ec_type_t ec ) case uc_category_fatal_e: if( filename ) { syslog(priority, "fatal exception: %s:%d: %s %s: %s (%s)", - program_name, + ec_status.source_file, ec_status.lineno, ec_status.statement, filename, // show affected file before EC name @@ -9930,7 +9930,7 @@ default_exception_handler( ec_type_t ec ) pec->description); } else { syslog(priority, "fatal exception: %s:%d: %s: %s (%s)", - program_name, + ec_status.source_file, ec_status.lineno, ec_status.statement, pec->name, @@ -9941,7 +9941,7 @@ default_exception_handler( ec_type_t ec ) case ec_category_nonfatal_e: case uc_category_nonfatal_e: syslog(priority, "%s:%d: %s: %s (%s)", - program_name, + ec_status.source_file, ec_status.lineno, ec_status.statement, pec->name, @@ -13918,4 +13918,3 @@ __gg__move_stash_release(const unsigned char *stash) move_stashes.depth -= 1; } - From 21e2dbfb75aa269f2219e46cb8481e87b96e6615 Mon Sep 17 00:00:00 2001 From: "James K. Lowden" Date: Thu, 24 Sep 2026 18:36:11 -0400 Subject: [PATCH 458/584] cobol: Use automaton to validate PICTURE for edited types. Validate PICTURE, report errors in the lexer. In this installment, return results in new PICTURE token to parser for alphanumeric-edited and numeric-edited types. Continue to supply the verbatim picture for later interpretation during codegen. gcc/cobol/ChangeLog: * cbldiag.h (struct cbl_loc_t): Add operators to increment first_column. (repeat_count): Declare function. (parse_error_count): Same. (cobol_location): Remove obsolete comment. * cdf.y: Update token values. * parse.y: Introduce PICTURE token. (keyword_tok): Exclude CDF tokens to prevent false positives. * parse_ante.h (struct arith_t): Better diagnositic. (valid_operands): New function. (parser_move_carefully): Reject invalid operands. (parser_move2): Whitespace. (parser_index): Same. * picture.cc (picture_rules): Revise automaton. (is_allowed): Add PICTURE constraints. (seek_paren): Add debug messages. (is_valid_picture): Rewrote function. (class picture_t): Capture PICTURE state to report to lexer. * scan.l: Use is_valid_token for complex pictures. * scan_ante.h (repeat_count): Use uint32_t, consistent with cbl_field_t. * semantic_token.h: New file representing lex_picture_t. * symbols.cc (parse_error_count): Remove declaration. * symbols.h: Use std::array. * symfind.cc (struct funcname): Whitespace. (symbol_match): Use diagnositic quotes. * token_names.h: Regenerate. * util.cc (named_constant): Return type of constant. (repeat_count): Accept location and return uint32_t. (parse_error_count): Remove declaration. * util.h (repeat_count): Same. gcc/ * config/avr/avr.opt.urls: Regenerate. * config/nvptx/nvptx.opt.urls: Regenerate. --- gcc/cobol/cbldiag.h | 34 +- gcc/cobol/cdf.y | 125 ++- gcc/cobol/parse.y | 54 +- gcc/cobol/parse_ante.h | 57 +- gcc/cobol/picture.cc | 511 +++++++-- gcc/cobol/scan.l | 74 +- gcc/cobol/scan_ante.h | 379 +------ gcc/cobol/semantic_token.h | 63 ++ gcc/cobol/symbols.cc | 1 - gcc/cobol/symbols.h | 11 + gcc/cobol/symfind.cc | 14 +- gcc/cobol/token_names.h | 1802 +++++++++++++++---------------- gcc/cobol/util.cc | 63 +- gcc/cobol/util.h | 2 - gcc/config/avr/avr.opt.urls | 2 +- gcc/config/nvptx/nvptx.opt.urls | 2 +- 16 files changed, 1667 insertions(+), 1527 deletions(-) create mode 100644 gcc/cobol/semantic_token.h diff --git a/gcc/cobol/cbldiag.h b/gcc/cobol/cbldiag.h index ab5f417e2a03..8a678aa47baf 100644 --- a/gcc/cobol/cbldiag.h +++ b/gcc/cobol/cbldiag.h @@ -130,6 +130,23 @@ struct cbl_loc_t : public cbl_loc_base_t { first_column = last_column = 1; return *this; } + cbl_loc_t& operator++() { + if( first_column + 1 < last_column ) first_column++; + return *this; + } + cbl_loc_t operator++(int) { + auto out(*this); + if( first_column + 1 < last_column ) first_column++; + return out; + } + cbl_loc_t& operator+=(int n) { + if( first_column + n < last_column ) first_column += n; + return *this; + } + cbl_loc_t& operator+(int n) const { + auto out(*this); + return out += n; + } // Represent a multi-line location as the first line, so "included from" // reflects where the COPY statement appears, not where it ends. @@ -141,6 +158,11 @@ struct cbl_loc_t : public cbl_loc_base_t { } }; +std::pair repeat_count(const char picture[]); +std::pair repeat_count(const cbl_loc_t& loc, const char picture[]); + +size_t parse_error_count(); + #include /* allow relocate stack */ static_assert(std::is_trivially_copyable::value, @@ -148,18 +170,6 @@ static_assert(std::is_trivially_copyable::value, const cbl_loc_t& cobol_location(); -/* - * Naming Convention: Names end with a letter that indicates - * their kind: - * F fatal, "fatal error: " - * I ice, "internal compiler error: " - * E error, "error: " - * S sorry, "sorry, unimplemented: " - * W warning, "warning: " - * A anachronism, "anachronism: " - * N note, "note: " - * D debug, "debug: " - */ enum cbl_diag_id_t : uint64_t { CdfNotFoundW, CdfParameterW, diff --git a/gcc/cobol/cdf.y b/gcc/cobol/cdf.y index abfb7d6e3270..f6ca89f9e048 100644 --- a/gcc/cobol/cdf.y +++ b/gcc/cobol/cdf.y @@ -67,9 +67,9 @@ operator<<( std::ostream& os, cbl_loc_t const& loc ) { os << "(" << loc.first_line << "," - << loc.first_column + << loc.first_column << ") to (" - << loc.last_line + << loc.last_line << "," << loc.last_column << ")"; @@ -89,7 +89,7 @@ namespace cdf { lookahead_token_kind = token; return lookahead_token_kind; } - + bool had_lookahead() { int kind = 0; std::swap(kind, lookahead_token_kind); @@ -99,7 +99,7 @@ namespace cdf { #define SAVE_LOOKAHEAD cdf::lookahead(yyla.kind()) %} - + %code requires { namespace cdf { @@ -107,7 +107,7 @@ namespace cdf { } } -%code { +%code { // https://learnmoderncpp.com/2020/12/17/generating-c-programs-with-flex-and-bison-2/ namespace cdf { @@ -128,9 +128,9 @@ namespace cdf { } } } - + %define api.location.type {cbl_loc_t} - + %{ #define COUNT_OF(X) (sizeof(X) / sizeof(X[0])) @@ -206,7 +206,7 @@ void input_file_status_notify(); const cdfval_t& value, bool override = false ) { cdf_values_t& dictionary( cdf_dictionary() ); - + if( scanner_parsing() ) { if( ! override ) { if( dictionary.find(name) != dictionary.end() ) return false; @@ -218,7 +218,7 @@ void input_file_status_notify(); static void cdfval_off( const char name[] ) { cdf_values_t& dictionary( cdf_dictionary() ); - + if( scanner_parsing() ) { auto p = dictionary.find(name); if( p == dictionary.end() ) { @@ -245,7 +245,7 @@ void input_file_status_notify(); cdfval_t operator/( const cdfval_base_t& lhs, const cdfval_base_t& rhs ); cdfval_t negate( cdfval_base_t lhs ); - void cdf_unreachable(); + void cdf_unreachable(); void cdf_field_add( const cbl_loc_t&, const std::string& name, const cdfval_t& value ); cbl_file_t * cdf_file( size_t program, const cbl_name_t name ); size_t cdf_file_index( const cbl_file_t *file ); @@ -257,11 +257,11 @@ static char *display_msg; const char * keyword_str( int token ); exception_turn_t exception_turn; - + bool apply_cdf_turn( const exception_turn_t& turn ) { cbl_enabled_exceptions_t& enabled_exceptions( cdf_enabled_exceptions() ); - + for( auto elem : turn.exception_files() ) { std::set files(elem.second.begin(), elem.second.end()); enabled_exceptions.turn_on_off(turn.enabled, @@ -288,16 +288,16 @@ apply_cdf_turn( const exception_turn_t& turn ) { %printer { fprintf(stderr, "%s '%s'", keyword_str($$.token), $$.string? $$.string : "" ); } -// cppcheck-suppress invalidPrintfArgType_sint +// cppcheck-suppress invalidPrintfArgType_sint %printer { fprintf(stderr, "%ld '%s'", (long)$$.number, $$.string? $$.string : "" ); } - + %type NAME NUMSTR LITERAL PSEUDOTEXT %type LSUB RSUB SUBSCRIPT %type namelit name_any name_one %type name subscript subscripts inof %token BOOL -%token FEATURE 400 NUMBER 308 EXCEPTION_NAME 284 "EXCEPTION NAME" +%token FEATURE 401 NUMBER 309 EXCEPTION_NAME 284 "EXCEPTION NAME" %type cdf_expr %type cdf_relexpr cdf_reloper cdf_and cdf_bool_expr @@ -309,53 +309,53 @@ apply_cdf_turn( const exception_turn_t& turn ) { %type cdf_stackable -%token BY 520 -%token COPY 397 -%token CDF_DISPLAY 418 ">>DISPLAY" -%token IN 638 +%token BY 521 +%token COPY 398 +%token CDF_DISPLAY 419 ">>DISPLAY" +%token IN 639 %token NAME 290 -%token NUMSTR 310 "numeric literal" -%token OF 721 +%token NUMSTR 311 "numeric literal" +%token OF 722 %token PSEUDOTEXT 755 %token REPLACING 777 -%token READY 405 TRACE 412 RESET 406 -%token LITERAL 303 -%token SUPPRESS 411 - -%token LSUB 402 "(" -%token SUBSCRIPT 410 RSUB 407 ")" - -%token CDF_DEFINE 417 ">>DEFINE" -%token CDF_IF 419 ">>IF" -%token CDF_ELSE 420 ">>ELSE" -%token CDF_END_IF 421 ">>END-IF" -%token CDF_EVALUATE 422 ">>EVALUATE" -%token CDF_WHEN 423 ">>WHEN" -%token CDF_END_EVALUATE 424 ">>END-EVALUATE" - -%token ALL 484 -%token CALL_CONVENTION 425 ">>CALL-CONVENTION" -%token COBOL_WORDS 414 ">>COBOL-WORDS" -%token CDF_PUSH 428 ">>PUSH" -%token CDF_POP 429 ">>POP" -%token SOURCE_FORMAT 430 ">>SOURCE FORMAT" - -%token AS 502 CONSTANT 396 DEFINED 398 +%token READY 406 TRACE 413 RESET 407 +%token LITERAL 304 +%token SUPPRESS 412 + +%token LSUB 403 "(" +%token SUBSCRIPT 411 RSUB 408 ")" + +%token CDF_DEFINE 418 ">>DEFINE" +%token CDF_IF 420 ">>IF" +%token CDF_ELSE 421 ">>ELSE" +%token CDF_END_IF 422 ">>END-IF" +%token CDF_EVALUATE 423 ">>EVALUATE" +%token CDF_WHEN 424 ">>WHEN" +%token CDF_END_EVALUATE 425 ">>END-EVALUATE" + +%token ALL 485 +%token CALL_CONVENTION 426 ">>CALL-CONVENTION" +%token COBOL_WORDS 415 ">>COBOL-WORDS" +%token CDF_PUSH 429 ">>PUSH" +%token CDF_POP 430 ">>POP" +%token SOURCE_FORMAT 431 ">>SOURCE FORMAT" + +%token AS 503 CONSTANT 397 DEFINED 399 %type DEFINED -%token OTHER 733 PARAMETER_kw 403 "PARAMETER" -%token OFF 722 OVERRIDE 404 +%token OTHER 734 PARAMETER_kw 404 "PARAMETER" +%token OFF 723 OVERRIDE 405 %token THRU 979 %token TRUE_kw 848 "True" -%token CALL_COBOL 426 "CALL" -%token CALL_VERBATIM 427 "CALL (as C)" +%token CALL_COBOL 427 "CALL" +%token CALL_VERBATIM 428 "CALL (as C)" -%token TURN 850 CHECKING 530 LOCATION 682 ON 724 WITH 877 +%token TURN 850 CHECKING 531 LOCATION 683 ON 725 WITH 877 %left OR 980 %left AND 982 %right NOT 983 -%left '<' '>' _EQ 302 "EQUAL" _NE 984 _LE 985 _GE 986 +%left '<' '>' _EQ 303 "EQUAL" _NE 984 _LE 985 _GE 986 %left '-' '+' %left '*' '/' %right NEG 988 @@ -509,7 +509,7 @@ cdf_define: CDF_DEFINE cdf_constant NAME as cdf_expr[value] override } ; cdf_constant: %empty - | CONSTANT + | CONSTANT ; override: %empty { $$ = false; } | OVERRIDE { $$ = true; } @@ -542,7 +542,7 @@ cdf_push: CDF_PUSH cdf_stackable { case parser::token::YDF_CDF_DEFINE: cdf_push_dictionary(); break; case parser::token::YDF_COBOL_WORDS: cdf_push_current_tokens(); break; case parser::token::YDF_SOURCE_FORMAT: - default: cdf_unreachable(); + default: cdf_unreachable(); } } ; @@ -553,7 +553,7 @@ cdf_pop: CDF_POP cdf_stackable { case parser::token::YDF_CDF_DEFINE: cdf_pop_dictionary(); break; case parser::token::YDF_COBOL_WORDS: cdf_pop_current_tokens(); break; case parser::token::YDF_SOURCE_FORMAT: - default: cdf_unreachable(); + default: cdf_unreachable(); } } ; @@ -624,7 +624,7 @@ cdf_if: CDF_IF cdf_cond_expr { ; cdf_evaluate: CDF_EVALUATE cdf_expr - | CDF_EVALUATE TRUE_kw + | CDF_EVALUATE TRUE_kw ; cdf_eval_when: CDF_WHEN cdf_eval_obj @@ -632,10 +632,10 @@ cdf_eval_when: CDF_WHEN cdf_eval_obj cdf_eval_obj: cdf_cond_expr | cdf_expr THRU cdf_expr - | OTHER + | OTHER ; -cdf_cond_expr: BOOL +cdf_cond_expr: BOOL | NAME DEFINED { cdf_values_t& dictionary( cdf_dictionary() ); @@ -868,7 +868,7 @@ namelit: name | LITERAL { $$ = cdf_arg_t{parser::token::YDF_LITERAL, $1}; } ; -name: NAME +name: NAME | name inof NAME { char *s = xasprintf( "%s %s %s", $1, $2, $3 ); @@ -895,7 +895,7 @@ subscripts: subscript $$ = s; } ; -subscript: SUBSCRIPT +subscript: SUBSCRIPT | LSUB subscript RSUB { char *s = xasprintf( "%s%s%s", $1, $2, $3 ); @@ -907,15 +907,15 @@ subscript: SUBSCRIPT ; as: %empty - | AS + | AS ; on: %empty - | ON + | ON ; with: %empty - | WITH + | WITH ; %% @@ -1088,11 +1088,10 @@ cdfval_base_t::operator()( const cbl_loc_t& loc ) { // cppcheck-suppress returnTempReference return verify_integer(loc, *this) ? *this : zero; } - + namespace cdf { void parser::error(cbl_loc_t const& loc, std::string const& msg) { error_msg(loc, msg.c_str()); } } - diff --git a/gcc/cobol/parse.y b/gcc/cobol/parse.y index 2de650c70b85..500cd0f49b16 100644 --- a/gcc/cobol/parse.y +++ b/gcc/cobol/parse.y @@ -54,6 +54,9 @@ class ast_op_t; + struct cbl_field_data_t; +#include "semantic_token.h" + struct coll_alphanat_t { const char *alpha, *national; }; @@ -401,6 +404,7 @@ class locale_tgt_t { NUMED "NUMERIC-EDITED picture" NUMED_CR "NUMERIC-EDITED CR picture" NUMED_DB "NUMERIC-EDITED DB picture" +%token PICTURE %token NINEDOT NINES NINEV PIC_P "PICTURE P symbol" ONES %token SPACES _EQ "EQUAL" %token LITERAL @@ -631,7 +635,7 @@ class locale_tgt_t { PACKED_DECIMAL PADDING PAGE PAGE_COUNTER "PAGE-COUNTER" - PF PH PI PIC PICTURE + PF PH PI PIC PLUS PRESENT_VALUE PRINT_SWITCH PROCEDURES PROCEED PROCESSING PROGRAM_ID "PROGRAM-ID" @@ -1007,6 +1011,7 @@ class locale_tgt_t { struct cbl_field_t *field; struct { bool tf; cbl_field_t *field; } bool_field; struct { int token; cbl_field_t *cond; } cond_field; + lex_picture_t lex_picture; struct cbl_refer_t *refer; ast_op_t *ast_op; struct rel_term_type { bool invert; cbl_refer_t *term; } rel_term_t; @@ -4459,7 +4464,9 @@ data_descr1: level_name "NUMERIC DISPLAY or NUMERIC-EDITED, not %s", $field->name, cbl_field_type_str($field->type) ); } - $field->data.picture = original_picture(); + if( ! $field->data.picture ) // began as numeric + $field->data.picture = original_picture(); + gcc_assert($field->data.picture); } // SIGN clause valid only with "S" in picture @@ -4921,6 +4928,21 @@ picture_clause: PIC signed PIC_P[fore] nines } } + | PICTURE + { + cbl_field_t *field = current_field(); + const lex_picture_t& picture($1); + field->codeset.set( picture.encoding ); + if( !field_type_update(field, picture.type, @PICTURE) ) { + dbgmsg("new picture: %s", field_str(field)); + YYERROR; + } + field->set_attr(cbl_field_attr_t($PICTURE.attr)); + field->data.apply_picture(*picture.data); + field->blank_initial(picture.data->capacity()); + } + | NO_CONDITION { YYERROR; } + | PIC alphanum_pic[nchar] { cbl_field_t *field = current_field(); @@ -13299,9 +13321,33 @@ current_tokens_t::tokenset_t::find( const cbl_name_t name, bool include_intrinsi return token; } +/* + * Search the token strings, possibly including intrinsic functions. Normally + * we're not interested in CDF names, unless the CDF is active. + */ int -keyword_tok( const char * text, bool include_intrinsics ) { - return cdf_tokens.find(text, include_intrinsics); +keyword_tok( const char * name, bool include_intrinsics ) { + static const std::vector cdf_words +#include "words/cdf.h" + static const std::vector intrinsic_words +#include "words/intrinsic.h" + static std::vector cdf_only; + if( cdf_only.empty() ) { + std::set_difference( + cdf_words.begin(), cdf_words.end(), + intrinsic_words.begin(), intrinsic_words.end(), + std::back_inserter(cdf_only) + ); + } + + std::array uname{}; + std::transform(name, name + strlen(name) + 1, uname.begin(), ftoupper); + + if( std::binary_search(cdf_only.begin(), cdf_only.end(), uname) ) { + return 0; + } + + return cdf_tokens.find(name, include_intrinsics); } static inline size_t diff --git a/gcc/cobol/parse_ante.h b/gcc/cobol/parse_ante.h index 2dbf02eac632..ae056d4fc38a 100644 --- a/gcc/cobol/parse_ante.h +++ b/gcc/cobol/parse_ante.h @@ -648,9 +648,11 @@ struct arith_t { protected: static bool is_numeric( const cbl_loc_t& loc, const cbl_refer_t& r ) { if( r.field && ! ::is_numeric(r.field) ) { - error_msg(loc, "%qs (%s) is not numeric", - nice_name_of(r.field), - cbl_field_type_name(r.field->type)); + if( r.field->type != FldInvalid ) { + error_msg(loc, "%qs (%s) is not numeric", + nice_name_of(r.field), + cbl_field_type_name(r.field->type)); + } return false; } return true; @@ -3694,6 +3696,11 @@ parser_subtract2( const cbl_num_result_t& to, parser_subtract(to.refer, to.refer, from, to.rounded); } +static bool +valid_operands( const cbl_refer_t& src, const cbl_refer_t& tgt ) { + return ! (src.field->type == FldInvalid || tgt.field->type == FldInvalid); +} + static bool parser_move_carefully( const char */*F*/, int /*L*/, tgt_list_t *tgt_list, @@ -3708,23 +3715,25 @@ parser_move_carefully( const char */*F*/, int /*L*/, return false; } - if( is_index ) { - if( tgt.field->type != FldIndex && src.field->type != FldIndex) { - auto msg = xasprintf("invalid SET %s (%s) TO %s (%s): not a field index", - name_of(tgt.field), cbl_field_type_name(tgt.field->type), - name_of(src.field), cbl_field_type_name(src.field->type)); - dialect_ok(src.loc, MfSetNumeric, msg); - free(msg); - } - } else { - if( ! valid_move( tgt.field, src.field ) ) { - if( src.field->type == FldPointer && - tgt.field->type == FldPointer ) { - dialect_ok(src.loc, MfMovePointer, "MOVE POINTER"); - } else { - error_msg(src.loc, "cannot MOVE %qs (%s) TO %qs (%s)", - nice_name_of(src.field), cbl_field_type_name(src.field->type), - nice_name_of(tgt.field), cbl_field_type_name(tgt.field->type)); + if( valid_operands(src, tgt) ) { + if( is_index ) { + if( tgt.field->type != FldIndex && src.field->type != FldIndex) { + auto msg = xasprintf("invalid SET %s (%s) TO %s (%s): not a field index", + name_of(tgt.field), cbl_field_type_name(tgt.field->type), + name_of(src.field), cbl_field_type_name(src.field->type)); + dialect_ok(src.loc, MfSetNumeric, msg); + free(msg); + } + } else { + if( ! valid_move( tgt.field, src.field ) ) { + if( src.field->type == FldPointer && + tgt.field->type == FldPointer ) { + dialect_ok(src.loc, MfMovePointer, "MOVE POINTER"); + } else { + error_msg(src.loc, "cannot MOVE %qs (%s) TO %qs (%s)", + nice_name_of(src.field), cbl_field_type_name(src.field->type), + nice_name_of(tgt.field), cbl_field_type_name(tgt.field->type)); + } } } } @@ -3737,10 +3746,10 @@ parser_move_carefully( const char */*F*/, int /*L*/, delete tgt_list; return true; } -#define parser_move2(P, S) \ - parser_move_carefully(__func__, __LINE__, (P), (S), false) -#define parser_index(P, S) \ - parser_move_carefully(__func__, __LINE__, (P), (S), true) +#define parser_move2(P, S) \ + parser_move_carefully(__func__, __LINE__, (P), (S), false) +#define parser_index(P, S) \ + parser_move_carefully(__func__, __LINE__, (P), (S), true) static void ast_set_pointers( const list& tgts, cbl_refer_t src ) { diff --git a/gcc/cobol/picture.cc b/gcc/cobol/picture.cc index 965baa27afc1..dc988edecaa6 100644 --- a/gcc/cobol/picture.cc +++ b/gcc/cobol/picture.cc @@ -85,7 +85,6 @@ namespace picture_validation { numeric_e, numeric_ed_e, c_need_r_e, - crdb_e, d_need_b_e, postdec_e, antedec_e, @@ -102,7 +101,6 @@ namespace picture_validation { case antedec_e: return "antedec_e"; case boolean_e: return "boolean_e"; case c_need_r_e: return "c_need_r_e"; - case crdb_e: return "crdb_e"; case d_need_b_e: return "d_need_b_e"; case exponent_e: return "exponent_e"; case invalid_e: return "invalid_e"; @@ -230,20 +228,21 @@ namespace picture_validation { { none_e, 'B', alpha_ed_e }, { none_e, '0', alpha_ed_e }, { none_e, '/', alpha_ed_e }, - { none_e, '9', antedec_e }, // 9 before V { none_e, 'N', national_e }, - { none_e, 'P', none_e }, - { none_e, 'S', none_e }, + { none_e, '9', antedec_e }, // 9 before V + { none_e, 'P', antedec_e }, + { none_e, 'S', antedec_e }, { none_e, 'V', postdec_e, }, // V before 9 - { none_e, '1', antedec_e }, - { antedec_e, '1', antedec_e }, + { none_e, '1', boolean_e }, + { boolean_e, '1', boolean_e }, { alphabetic_e, 'A', alphabetic_e }, { alphabetic_e, 'B', alpha_ed_e }, { alphabetic_e, '0', alpha_ed_e }, { alphabetic_e, '/', alpha_ed_e }, { alphabetic_e, 'X', alphanumeric_e }, + { alphabetic_e, '9', alphanumeric_e }, { alphabetic_e, '$', numeric_ed_e }, { alphanumeric_e, 'A', alphanumeric_e }, @@ -299,11 +298,16 @@ namespace picture_validation { { antedec_e, 'P', numeric_e }, { antedec_e, 'V', numeric_e }, { antedec_e, 'X', alphanumeric_e }, + { antedec_e, '+', numeric_ed_e }, + { antedec_e, '-', numeric_ed_e }, { antedec_e, 'C', c_need_r_e }, { antedec_e, 'D', d_need_b_e }, { antedec_e, 'Z', numeric_ed_e }, { antedec_e, '*', numeric_ed_e }, + { antedec_e, 'B', numeric_ed_e }, + { antedec_e, '0', numeric_ed_e }, + { antedec_e, '/', numeric_ed_e }, { antedec_e, '$', numeric_ed_e }, { antedec_e, dot, numeric_ed_e }, { antedec_e, com, numeric_ed_e }, @@ -313,6 +317,7 @@ namespace picture_validation { { numeric_e, '9', numeric_e }, { numeric_e, 'P', numeric_e }, + { numeric_e, 'V', numeric_e }, { numeric_e, 'Z', numeric_ed_e }, { numeric_e, '*', numeric_ed_e }, @@ -416,12 +421,9 @@ namespace picture_validation { p_X = hiword('X'), p_Z = hiword('Z'), - p_boolean_e = p_one, - p_alphabetic_e = p_A, p_alphanumeric_e = (p_A | p_X | p_nine), p_b_0_slash_e = (p_B | p_zero | p_slash), p_alpha_ed_e = (p_alphanumeric_e | p_b_0_slash_e), - p_national_e = p_N, p_national_ed_e = (p_N | p_b_0_slash_e), p_numeric_e = (p_nine | p_P | p_S | p_V), // B P V Z 9 0 / , . + - CR DB * cs (CR/DB not in mask because at end) @@ -430,60 +432,90 @@ namespace picture_validation { p_comma | p_dot | p_plus | p_minus | p_star | p_cs), }; uint64_t symbol_mask; - - bool is_boolean() const { - return 0 == (symbol_mask & ~p_boolean_e) - && 0 != (symbol_mask & p_boolean_e); + + bool both( picsym_t a, picsym_t b ) const { + return (symbol_mask & (a | b)) == (a | b); } - bool is_alphabetic() const { - return 0 == (symbol_mask & ~p_alphabetic_e) - && 0 != (symbol_mask & p_alphabetic_e); + template + bool only(T bits) const { + return symbol_mask == (symbol_mask & bits); + } + + /* + * 13.18.40.3 Syntax rules FORMAT 1 + */ + bool is_allowed( char ch ) const { + switch( ch ) { + case 'P': // no P in numeric-edited + case 'V': // no V in numeric-edited + case dot: // Neither P nor V with dot. + if( both(p_P, p_dot) ) { // rule 17 + error_msg(loc, "%qc and %qc are mutually exclusive", 'P', dot); + return false; + } + if( both(p_V, p_dot) ) { // rule 20 + error_msg(loc, "%qc and %qc are mutually exclusive", 'V', dot); + return false; + } + break; + case 'Z': case '*': // Only blanks or stars + if( both(p_Z, p_star) ) { // rule 21 + error_msg(loc, "%qc and %qc are mutually exclusive", 'Z', '*'); + return false; + } + break; + } + return true; } + + bool is_boolean() const { return symbol_mask == p_one; } + bool is_alphabetic() const { return symbol_mask == p_A; } + bool is_national() const { return symbol_mask == p_N; } + bool is_alphanumeric() const { - return 0 == (symbol_mask & ~p_alphanumeric_e) - && 0 != (symbol_mask & p_alphanumeric_e); + auto bits = symbol_mask & p_alphanumeric_e; + return 0 < bits && symbol_mask == bits; } bool is_alpha_ed() const { - return 0 == (symbol_mask & ~p_alpha_ed_e) + return only(p_alpha_ed_e) && 0 != (symbol_mask & p_alphanumeric_e) && 0 != (symbol_mask & p_b_0_slash_e); } - bool is_national() const { - return 0 == (symbol_mask & ~p_national_e) - && 0 != (symbol_mask & p_national_e); - } bool is_national_ed() const { - return 0 == (symbol_mask & ~p_national_ed_e) - && 0 != (symbol_mask & p_national_e) + return only(p_national_ed_e) + && 0 != (symbol_mask & p_N) && 0 != (symbol_mask & p_b_0_slash_e); } bool is_numeric() const { - return 0 == (symbol_mask & ~p_numeric_e) + return only(p_numeric_e) && 0 != (symbol_mask & p_nine) && 0 != (symbol_mask & p_numeric_e); } bool is_numeric9_ed() const { - return 0 == (symbol_mask & ~p_numeric_ed_e) + return only(p_numeric_ed_e) && 0 != (symbol_mask & p_nine) && 0 != (symbol_mask & p_numeric_ed2_e); } bool is_numeric_ed() const { - return 0 == (symbol_mask & ~p_numeric_ed_e) + return only(p_numeric_ed_e) && ( 0 != (symbol_mask & (p_Z | p_star)) || two_signs() || is_numeric9_ed() ); } + bool two_signs() const { return 1 < nplus || 1 < nminus; } + state_t pic_state; // to lookup sequence validity uint64_t picsym_set( char ch ) { switch(ch) { + case '$': return symbol_mask |= p_cs; + case '*': return symbol_mask |= p_star; case '+': return symbol_mask |= p_plus; + case ',': return symbol_mask |= p_comma; case '-': return symbol_mask |= p_minus; case '.': return symbol_mask |= p_dot; - case ',': return symbol_mask |= p_comma; case '/': return symbol_mask |= p_slash; - case '$': return symbol_mask |= p_cs; case '0': return symbol_mask |= p_zero; case '1': return symbol_mask |= p_one; case '9': return symbol_mask |= p_nine; @@ -505,12 +537,13 @@ namespace picture_validation { bool picsym_seen( char ch ) const { switch(ch) { + case '$': return 0 < (symbol_mask & p_cs); + case '*': return 0 < (symbol_mask & p_star); case '+': return 0 < (symbol_mask & p_plus); + case ',': return 0 < (symbol_mask & p_comma); case '-': return 0 < (symbol_mask & p_minus); case '.': return 0 < (symbol_mask & p_dot); - case ',': return 0 < (symbol_mask & p_comma); case '/': return 0 < (symbol_mask & p_slash); - case '$': return 0 < (symbol_mask & p_cs); case '0': return 0 < (symbol_mask & p_zero); case '1': return 0 < (symbol_mask & p_one); case '9': return 0 < (symbol_mask & p_nine); @@ -527,33 +560,149 @@ namespace picture_validation { case 'X': return 0 < (symbol_mask & p_X); case 'Z': return 0 < (symbol_mask & p_Z); } + return false; } + bool picsym_settable( char ch ) const { + switch(ch) { + case 'V': + return ! picsym_seen(ch); + case 'P': + return ch == prior_ch || ! picsym_seen(ch); + } + return true; + } + + cbl_loc_t loc; char prior_ch; const char decimal_point; - int nplus, nminus; + int np, nplus, nminus, ndollar; + uint64_t field_attr; cbl_field_data_t field_data; + struct contiguous_t { + char ch; + int n; + explicit contiguous_t( char ch ) : ch(ch), n(1) {} + contiguous_t& operator++() { n++; return *this; } + }; + std::vector contiguous; + + // 13.18.40.3 Syntax rules #27 No more than 1 of certain character + // sequences. This function misinterprets the rule. The rule is not that + // e.g. $$,$$ is invalid. the rule is that the list items are mutually + // exclusive, $$Z is invalid. Keeping the structure for now in case needed. +#if 0 + bool contiguous_ok(char ch) const { + int n = 0; + switch(ch) { + case '+': case '-': case '$': + n = 2; + break; + case 'Z': case '*': + n = 1; + break; + } + if( n ) { + n = std::count_if( contiguous.begin(), contiguous.end(), + [ch, n]( const auto& elem ) { + return ch == elem.ch && n <= elem.n; + } ); + } + return n < 2; + } +#endif + bool add_contiguous(char ch) { + if( contiguous.empty() ) { + contiguous.push_back( contiguous_t(ch) ); + return true; + } + auto& last( contiguous.back() ); + if( ch == last.ch ) { + ++last; + } else { + contiguous.push_back( contiguous_t(ch) ); + } + return true; // contiguous_ok(ch); + } + public: const char *bad_repeat; - constraint_t() + constraint_t(const cbl_loc_t& loc, const cbl_name_t picture) : symbol_mask(0) , pic_state(none_e) + , loc(loc) , prior_ch('\0') , decimal_point(symbol_decimal_point()) - , nplus(0), nminus(0) + , np(0), nplus(0), nminus(0), ndollar(0) + , field_attr(0) , bad_repeat(nullptr) - {} - constraint_t& append( char ch, size_t len ) { + { + // Trim trailing punctuation from picture for later revalidation, because + // we do. + auto pic = xstrdup(picture); + auto pend = pic + strlen(pic); + if( pic < --pend ) { + switch( *pend ) { + case ';': case ',': case '.': + *pend = '\0'; + break; + } + } + + field_data.picture = pic; + } + bool append( char ch, size_t len ) { + if( prior_ch == '\0' ) { + switch(ch) { + case 'S': case '+': case '-': + field_attr |= signable_e; + } + } + if( prior_ch == '.' && ch == '.' ) return false; + if( ! add_contiguous(ch) ) return false; + + if( ! picsym_settable(ch) ) { return false; } picsym_set(ch); + // emits message about invalid combinations + if( ! is_allowed(ch) ) { return false; } + prior_ch = ch; - if( ch == '+' ) nplus++; - if( ch == '-' ) nminus++; - update_capacity(1 + len); + add_capacity(len? len : 1); observe_the_dot(ch); - return *this; + loc++; + return true; } + inline void move_caret( int n ) { loc += n; } + bool has_s_star() const { return both(p_S, p_star); } + + void extra_dot( size_t pos ) { + if( field_data.picture[pos] != '\0') { + assert(field_data.picture[pos+1] == '\0'); + assert(field_data.picture[pos] == '.'); + const_cast(field_data.picture)[pos] = '\0'; + } + } + + bool repeatable() const { + switch(prior_ch) { + case '1': + case 'P': + case 'A': case 'X': case '9': + case 'N': + case 'U': + case 'Z': case '*': + case 'B': case '0': // B and 0 but not slash + case '$': case '+': case '-': + return true; + } + return false; + } + char prior() const { return prior_ch; } + cbl_field_data_t data() const { return field_data; } + uint64_t attr() const { return field_attr; } + const cbl_loc_t& location() const { return loc; } state_t picture_state(state_t state) { return pic_state = state; } state_t picture_state() const { return pic_state; } @@ -569,14 +718,34 @@ namespace picture_validation { return invalid_e; } - bool two_signs() const { return 1 < nplus || 1 < nminus; } + void maybe_signable( char ch ) { + switch(TOUPPER(ch)) { + case '+': case '-': + field_attr |= signable_e; + } + dbgmsg("%s: '%c', %ssignable", __func__, + ch, (field_attr & signable_e)? "" : "not "); + } + void maybe_signable( state_t state ) { + switch(state) { + case c_need_r_e: + case d_need_b_e: + maybe_signable('+'); + default: + break; + } + } + /* * The followers table is sensitive to whether we've seen decimal point, and * whether we're in an exponent. That reflects the duplicate column * headings in ISO Table 10. */ - bool day_follows_night( char ch ) { + bool day_follows_night( char ch ) const { + const static std::string domain("*+,-./019ABENPSVXZCRDB"); + return std::string::npos != domain.find(ch); + auto p = followers.find( follow_key_t {pic_state, prior_ch} ); if( p != followers.end() ) { const auto& candidates(p->second); @@ -586,17 +755,8 @@ namespace picture_validation { return false; } - void prior_repeats( int n ) { - if( prior_ch != 'P' ) { - update_capacity(n); - } - } + inline bool first_dollar( char ch ) { return ch == '$' && ndollar == 0; } - protected: - void observe_the_dot( char ch ) { - if( pic_state == none_e ) pic_state = antedec_e; - if( ch == decimal_point || ch == 'V' ) pic_state = postdec_e; - } /* * 1) Every character except V adds to the capacity, with the caveat that * the first CURRENCY PICTURE character adds the length of the CURRENCY @@ -610,17 +770,47 @@ namespace picture_validation { * all of the regression tests assume that V, if there, adds one.  I would * really rather attack the V change when everything is working. */ - void update_capacity( int n = 1) { - static const std::string nonsize( "PVCRDB" ); - - if( std::string::npos == nonsize.find(prior_ch) ) { + void add_capacity(int n) { + static const std::string nonsize( "P" ); // do not exclude V from capacity for now + if( prior_ch == 'P' ) { + np += n; + field_attr |= scaled_e; + // P in front has positive rdigit less one; P aft is negative rdigit. + int ndigit = only(p_P | p_S)? (1 < np? n : n - 1) : -n; + field_data.rdigits += ndigit; + } else { field_data.add_capacity(n); - if( pic_state == postdec_e ) { - field_data.rdigits += n; - } + if( digital() ) { + field_data.digits += n; + if( pic_state == postdec_e ) { + field_data.rdigits += n; + } + } else { n = 0; } // for debug } + dbgmsg("%s: '%c', added %d: {%u, %u,%d}", __func__, prior_ch, n, + field_data.capacity(), field_data.digits, field_data.rdigits); } + protected: + void observe_the_dot( char ch ) { + if( pic_state == none_e ) pic_state = antedec_e; + if( ch == decimal_point || ch == 'V' ) pic_state = postdec_e; + } + bool digital() { + switch(prior_ch) { + case '9': case 'Z': case '*': + return true; + case 'V': + return true; + case '+': + return 0 < nplus++; + case '-': + return 0 < nminus++; + case '$': + return 0 < ndollar++; + } + return false; + } }; } // end namespace @@ -646,7 +836,7 @@ seek_paren( const char *p, const char *epicture ) { return p; } -static bool verbose = false; +static bool verbose = true; // Dot as last character is period separator because the lexer defines // end-of-picture as a space. @@ -661,76 +851,187 @@ end_of_picture( const char *p, const char *epicture ) { return p == epicture; } -std::pair -is_valid_picture(const char picture[]) { - picture_validation::constraint_t constraint; +#include "semantic_token.h" +class picture_t : public lex_picture_t { + state_t picture_state; + public: + picture_t() + : picture_state(picture_validation::invalid_e) + { + attr = none_e; + pos = 0; + blank_when_zero_ok = true; + type = FldInvalid; + encoding = current_encoding('A'); + data = new cbl_field_data_t; + } + + void state( state_t state ) { + picture_state = state; + type = field_type(); + encoding = field_encoding(); + if( picture_state == picture_validation::alphabetic_e ) { + attr |= uint64_t(all_alpha_e); + } + } + + picture_t& update( const picture_validation::constraint_t& constraint ) + { + blank_when_zero_ok = ! constraint.has_s_star(); + attr = constraint.attr(); + *data = constraint.data(); + return *this; + } + + protected: + cbl_encoding_t field_encoding() const { + switch(picture_state) { + case picture_validation::unicode_e: + cbl_unimplemented("Unicode pictures not implemented"); + return current_encoding('A'); + case picture_validation::national_e: + return current_encoding('N'); + default: // alphanumeric by construction + return current_encoding('A'); + break; + } + } + cbl_field_type_t field_type() const { + switch(picture_state) { + case picture_validation::alphabetic_e: + case picture_validation::unicode_e: + case picture_validation::alphanumeric_e: + case picture_validation::national_e: + return FldAlphanumeric; + case picture_validation::alpha_ed_e: + case picture_validation::national_ed_e: + return FldAlphaEdited; + case picture_validation::antedec_e: + case picture_validation::numeric_e: + return FldNumericDisplay; + case picture_validation::numeric_ed_e: + return FldNumericEdited; + + case picture_validation::invalid_e: + case picture_validation::none_e: + case picture_validation::boolean_e: + case picture_validation::c_need_r_e: + case picture_validation::d_need_b_e: + case picture_validation::postdec_e: + case picture_validation::exponent_e: + case picture_validation::accept_e: + break; + } + return FldInvalid; + } +}; + +lex_picture_t +is_valid_picture(const cbl_loc_t& loc, const char picture[]) { + picture_validation::constraint_t constraint(loc, picture); + const picture_validation::automaton_matrix_t& automaton = picture_validation::prepare_automaton(); if( ! picture ) { - return {picture, picture_validation::invalid_e}; + return lex_picture_t(); } - const char *epicture = picture + strlen(picture); state_t state = picture_validation::none_e; - for( auto p=picture; p < epicture; p++ ) { - // Advance lookahead past any count, which might be name. + const char *p = picture, *epicture = picture + strlen(picture); + picture_t output; + /* + * If a currency has a symbol, width is set to its length until appended, + * then becomes 1. + */ + size_t width = 0; + + for( ; p < epicture; p++, output.pos++ ) { + // Advance lookahead past any count, which might be a name. // No picture begins with a '('. - if( picture < p && *p == '(' && p+1 < epicture ) { - const char *paren = p; - p = seek_paren(p, epicture); - if( *p != ')' ) { - return {p, picture_validation::invalid_e}; - } - if( p[-1] == '(' ) { // pic 9() is invalid - return {p, picture_validation::invalid_e}; - } - p++; - auto result = repeat_count(--paren); - int len = result.first; - if( len == 0 ) { - dbgmsg("%s: odd zero repeat_count for '%s'", __func__, paren); - constraint.bad_repeat = paren; - return {paren, picture_validation::invalid_e}; + if( *p == '(' && p+1 < epicture ) { + if( constraint.repeatable() ) { + const char *paren = p; + p = seek_paren(p, epicture); + if( *p != ')' ) { + output.pos += p - paren; + return output; + } + if( p[-1] == '(' ) { // pic 9() is invalid + output.pos += p - paren; + return output; + } + constraint.move_caret(p - paren); + p++; + auto result = repeat_count(constraint.location(), --paren); + int count = result.first; + if( count == 0 ) { + dbgmsg("%s: odd zero repeat count for '%s'", __func__, paren); + constraint.bad_repeat = paren; // pointless, not used + return output; + } + constraint.add_capacity(--count); + output.pos = p - picture; } - constraint.prior_repeats(len); } - if( end_of_picture(p, epicture) ) break; + // We may reach end of picture prematurely if it ends with ')'. + if( end_of_picture(p, epicture) ) { + epicture = p; + break; + } - // Now p is fixed, but ch might be a currency symbol char ch = TOUPPER(*p); // Is the current character ever allowed to follow the prior? - size_t currency_len = 0; - if( ! constraint.day_follows_night(ch) ) { + if( ! constraint.day_follows_night(ch) || constraint.first_dollar(ch)) { const char *currency = symbol_currency(ch); if( currency ) { ch = '$'; - currency_len = strlen(currency); + width = width == 0? strlen(currency) : 1; } else { - if( verbose ) - fprintf(stderr, "no %2zu: %c -> %c (%s)\n", - p - picture, constraint.prior(), ch, - picture_validation::state_str(constraint.picture_state()) ); - return {p, picture_validation::invalid_e}; + dbgmsg("%s:%d: no %2lu: %c -> %c (%s)\n", __func__, __LINE__, + (unsigned long)(p - picture), constraint.prior(), ch, + picture_validation::state_str(constraint.picture_state())); + return output; + } + if( verbose ) { + dbgmsg("ok %2lu: %c (next: %s)\n", (unsigned long)(p - picture), ch, + picture_validation::state_str(state)); } } // Update constraint record and advance to the next state. - constraint.append(ch, currency_len); - state = automaton[state][ch]; - - if( verbose ) { - fprintf(stderr, "ok %2zu: %c (next: %s)\n", - p - picture, ch, picture_validation::state_str(state)); - } + const auto old_state = picture_validation::state_str(state); + if( constraint.append(ch, width) ) { + if( 1 < width ) width = 1; + state = automaton[state][ch]; + constraint.maybe_signable(state); + } else { + state = picture_validation::invalid_e; + } + if( state == picture_validation::invalid_e ) { - return {p, picture_validation::invalid_e}; + dbgmsg("%s:%d: automaton has no transition for %s '%c'", + __func__, __LINE__, old_state, ch); + return output; } } - return {epicture, constraint.state()}; + assert( p == epicture ); + + if( picture < p ) { + char ch = p == epicture? p[-1] : p[0]; + constraint.maybe_signable(ch); + } + + output.state(state); + output.update(constraint); + + dbgmsg("%s:%d: decided on %s", __func__, __LINE__, + cbl_field_type_str(output.type)); + + return output; } #ifdef COBOL_PICTURE diff --git a/gcc/cobol/scan.l b/gcc/cobol/scan.l index a295a3fbadc7..470b5d3a8398 100644 --- a/gcc/cobol/scan.l +++ b/gcc/cobol/scan.l @@ -75,9 +75,6 @@ namespace picture_validation { }; } -std::pair -is_valid_picture( const char picture[] ); - static const char * crdb_maybe( const char *p ) { char candidate[3] = { TOUPPER(p[-1]), TOUPPER(p[0]) }; @@ -85,18 +82,24 @@ crdb_maybe( const char *p ) { return 1 == endings.count(candidate)? --p : p; } +static const char * +picture_at() { + std::reverse_iterator end(yytext), beg(yytext + yyleng); + auto pos = std::find(beg, end, 0x20); + auto picture = pos.base(); + dbgmsg("%s: picture is '%s'", __func__, picture); + return picture; +} + static size_t -is_valid_picture() { - std::reverse_iterator end(yytext), beg(yytext + yyleng); - auto pos = std::find(beg, end, 0x20); - auto picture = pos.base(); +old_valid_picture(){ + auto picture = picture_at(); dbgmsg("%s: picture is '%s'", __func__, picture); - auto result = is_valid_picture(picture); + auto result = is_valid_picture(yylloc, picture); - if( 0 != (result.second & picture_validation::invalid_e) ) { - assert(yytext < result.first); - auto p = crdb_maybe(result.first); + if( result.valid() ) { + auto p = crdb_maybe( yytext + result.pos ); auto loc(yylloc); if( loc.first_line == loc.last_line ) { auto error_col = p - yytext; @@ -1297,9 +1300,51 @@ USE({SPC}FOR)? { return USE; } } PIC(TURE)?({SPC}IS)?{SPC}{PICTURE} { - auto pos = is_valid_picture(); - myless(pos); - yy_push_state(picture); return PIC; + const auto nerror = parse_error_count(); + auto end_dot = yyleng - 1; + auto p = picture_at(); + auto loc(yylloc); + loc.first_column += (p - yytext); + const auto& pic = is_valid_picture(loc, p); + switch( pic.type ) { + case FldAlphaEdited: + case FldNumericEdited: + ////pic.dump(); + yylval.lex_picture = pic; + if( yytext[end_dot] == '.' ) { + myless(end_dot); + } + return PICTURE; + case FldInvalid: + if( nerror == parse_error_count() ) { + if( *p == '1' ) { + cbl_unimplemented_at(loc, "BOOLEAN PICTURE %qs", p); + } else { + loc += pic.pos; + error_msg(loc, "invalid %qc at %u in PICTURE %qs", + p[pic.pos], unsigned(pic.pos), p); + } + } + if( yytext[end_dot] == '.' ) { + myless(end_dot); + } + return NO_CONDITION; + break; + default: + if( nerror < parse_error_count() ) { + if( yytext[end_dot] == '.' ) { + myless(end_dot); + dbgmsg("picture is %s, %u error", + cbl_field_type_str(pic.type), + unsigned(nerror)); + return NO_CONDITION; + } + } + break; + } + myless(p - yytext); + yy_push_state(picture); + return PIC; } ANY { return ANY; } @@ -1622,6 +1667,7 @@ USE({SPC}FOR)? { return USE; } tmpstring = NULL; pop_return LITERAL; } } + /* These appear only in ISO list of CDF reserved words */ /* DE-EDITING { return DE_EDITING; } */ /* EXTERNAL-FILE-FILE-STATUS { return EXTERNAL_FILE_FILE_STATUS; } */ diff --git a/gcc/cobol/scan_ante.h b/gcc/cobol/scan_ante.h index f87db5657035..99387eae60c9 100644 --- a/gcc/cobol/scan_ante.h +++ b/gcc/cobol/scan_ante.h @@ -727,7 +727,7 @@ ndigit(int len, const char **pleft = nullptr) { n++; if( p[1] == model ) continue; - std::pair result = repeat_count(p); + std::pair result = repeat_count(p); int count = result.first, pos = result.second; if( pos == -1 ) { @@ -758,383 +758,6 @@ picset( int token, int leng = yyleng ) { return token; } -/** -## Script and data to produce picture_t::followers. -## Based on ISO Table 10. -#! /usr/bin/awk -f - -BEGIN { - str = "B0/ , . + +- +- CR/DB cs cs Z* Z* + + cs cs 9 AX S V P P 1 N E" - split(str, cols) -} - -$1 ~ /CR|DB|cs/ { next } - -0 && !nlines++ { - for( i=0; i < length(cols); i++ ) { - print i, cols[i], "'" $i "'" - } -} - -$field == "x" { - if( ! nout++ ) { - printf "%2d: %5s: \"", field, cols[field - 1] - } - - gsub(/^ +| +$/, "", $1) - printf "%s", $1 -} - -END { - if( ! nout++ ) { - printf "%2d: %5s: \"", field, cols[field - 1] - } - print "\"" -} - -B x x x - x - - x - x x x x x x x x - x - x - x -0 x x x - x - - x - x x x x x x x x - x - x - x -/ x x x - x - - x - x x x x x x x x - x - x - x -, x x x - x - - x - x x x x x x x - - x - x -. x x - - x - - x - x - x - x - x -+ - - - - - - - - - - - - - - - - - - - - - - - x -+ -– -+ x x x - - - - x x x x - - x x x - - x x x -CR x x x - - - - x x x x - - x x x - - x x x -DB x x x - - - - x x x x - - x x x - - x x x -cs - - - - x -cs x x x - x - - - - x x - - - - x - - x x x - -Z x x - - x - - x - x -* x x - - x - - x - x -Z x x x - x - - x - x x - - - - - - - x - x -* x x x - x - - x - x x - - - - - - - x - x -+ x x - - - - - x - - - x -– x x - - - - - x - - - x -+ x x x - - - - x - - - x x - - - - - x -– x x x - - - - x - - - x x - - - - - x -cs x x - - x - - - - - - - - x -cs x x x - x - - - - - - - - x x - - - x - -9 x x x x x - - x - x - x - x - x x x x - x - - x -A x - - - - - - - - - - - - - - x x -X x - - - - - - - - - - - - - - x x -S -V x x - - x - - x - x - x - x - x - x - x -P x x - - x - - x - x - x - x - x - x - x -P - - - - x - - x - - - - - - - - - x x - x -1 - - - - - - - - - - - - - - - - - - - - - x -N x - - - - - - - - - - - - - - - - - - - - - x -E x x x - x - - - - - - - - - - x -**/ - -class picture_t { - static const char dot = '.', comma = ','; - - typedef std::vector followings_t; - static const std::map followers; - - const char * const begin; - const char *p, *pend; - size_t pos; - struct exclusions_t { // Nonzero if set, > 1 is false. - // crdb means CR/DB or +/-. - // pluses means 2 or more consecutive '+'. - // minuses means 2 or more consecutive '-'. - // "21) The symbol 'Z' and the symbol '*' are mutually exclusive " - // stars means '*' or Z. - unsigned short int crdb, currency, dot, pluses, minuses, stars, zzz; - exclusions_t() - : crdb(0), currency(0), dot(0), pluses(0), minuses(0), stars(0) - {} - } exclusions; - cbl_loc_t loc; - - bool is_crdb() const { // input must be uppercase for CR/DB - if( p[0] == 'C' || p[0] == 'D' ) { - char input[3] = { p[0], p[1] }; - return ( 0 == strcmp(input, "CR") || 0 == strcmp(input, "DB") ); - } - return false; - } - - const char * match_paren( const char *paren ) const { - gcc_assert(paren[0] == '('); // start with opening paren - paren = std::find_if( paren, pend, - []( char ch ) { - return ch == '(' || ch == ')'; - } ); - if( *paren == '(' ) return nullptr; // no nesting - if( paren == pend ) return nullptr; - return ++paren; - } - - const char * next_not( char ch ) const { - return std::find_if( p, pend, - [ch = TOUPPER(ch)]( char next ) { - return ch != next; - } ); - } - - const char * valid_next( const char *p, const std::string& valid ) const { - if( p == pend || p + 1 == pend ) return pend; - if( p[1] == '(' ) { - return match_paren(++p); - } - auto pv = std::find(valid.begin(), valid.end(), TOUPPER(p[1])); - return pv != valid.end()? ++p : nullptr; - } - const char * valid_next( const char *p, - bool first = true, char ch = '\0' ) const { - if( p == pend || p + 1 == pend ) return pend; - if( p[0] == '(' ) { - if( (p = match_paren(p)) == nullptr ) return nullptr; - } - if( p[0] == '(' ) return nullptr; // consecutive parentheses - - int index = first? 0 : 1; - if( !ch ) ch = *p; // use current character unless overridden - auto valid = followers.find(TOUPPER(ch)); - if( valid == followers.end() ) { - cbl_loc_t loc(yylloc); - loc.first_column += int(p - begin); - error_msg( loc, "PICTURE: strange character %qc, giving up", ch ); - return nullptr; - } - return valid_next(p, valid->second[index]); - } - - const char * start() { // start modifies exclusions, but not p - auto pnext = p; - - switch(TOUPPER(p[0])) { - case comma: case dot: - // use decimal_is_comma() - // 4: .: "B0/,+Z*+-9E" - exclusions.dot++; - pnext = valid_next(p, "B0/,+Z*+-9E"); - break; - case '+': case '-': - // 6: +-: "B0/,.Z*Z*9VPPE" - exclusions.crdb++; - pnext = next_not(p[0]); - if( p + 1 < pnext ) { - exclusions.pluses++; - } - pnext = valid_next(--pnext, "B0/,.Z*Z*9VPPE"); - break; - case 'Z': case '*': - exclusions.stars++; - pnext = next_not(p[0]); - break; - case 'S': - // 19: S: "9VP" - pnext = valid_next(p, "9VP"); - break; - } - - /* - * "For fixed editing sign control, the currency symbol, when used, shall - * be either the leftmost symbol in character-string-1, optionally preceded - * by one of the symbols '+' or '-' " - */ - if( pnext ) { - if( p == pnext || p[0] == '+' || p[0] == '-' ) { - if( symbol_currency(*pnext) ) { - exclusions.currency++; - pnext = next_not(*pnext); - pnext = valid_next(--pnext, true, '$'); - } - } - } - - return pnext; - } - - const char * next() { // modify state; do not modify position - auto pnext = p; - auto loc(picture_t::loc); - loc.first_column += int(p - begin); - - if( is_crdb() ) { - if( exclusions.crdb++ ) { - error_msg( loc, "PICTURE: CR/DB and %c/%c may appear only once", '+', '-' ); - return nullptr; - } - if( p + 2 != pend ) { - error_msg( loc, "PICTURE: CR/DB must appear at the end" ); - return nullptr; - } - return pend; - } - - if( symbol_currency(p[0]) ) { - if( false && exclusions.currency++ ) { // not enforced - error_msg( loc, "PICTURE: CURRENCY SYMBOL sequence may appear at most once" ); - return nullptr; - } - return valid_next(p, ! exclusions.dot, '$'); - } - - switch(TOUPPER(p[0])) { - case '(': - return match_paren(p); - break; - case 'B': case '0': case '/': - pnext = valid_next(p); - break; - case comma: - if( decimal_is_comma() ) { - if( exclusions.dot++ ) { - error_msg( loc, "PICTURE: %qc: may appear at most once", p[0] ); - return nullptr; - } - pnext = valid_next(p, true, dot); - } else { - pnext = valid_next(p); - } - break; - case dot: - if( p + 1 == pend ) { - pnext = pend; - } else { - if( decimal_is_comma() ) { - pnext = valid_next(p, true, comma ); - } else { - if( exclusions.dot++ ) { - error_msg( loc, "PICTURE: %qc: may appear at most once", p[0] ); - return nullptr; - } - pnext = valid_next(p); - } - } - break; - - case '+': case '-': - // 7 is trailing sign; 13 & 14 are numeric. Leading sign handled by start(). - if( p + 1 == pend ) { - if( exclusions.crdb++ ) { - error_msg( loc, "PICTURE: %c/%c may appear at most once as a sign", '+', '-' ); - return nullptr; - } - pnext = pend; - } else { - pnext = next_not(p[0]); - if( p + 1 < pnext ) { - if( false && exclusions.pluses++ ) { // not enforced - error_msg( loc, "PICTURE: %qc: sequence may appear at most once", p[0] ); - return nullptr; - } - } - pnext = valid_next(pnext, ! exclusions.dot); - } - break; - - case 'Z': case '*': - if( false && exclusions.stars++ ) { // not enforced - error_msg( loc, "PICTURE: %qc: sequence may appear at most once", p[0] ); - return nullptr; - } - if( (pnext = next_not(p[0])) == nullptr ) return pnext; - pnext = valid_next(pnext, ! exclusions.dot); - break; - case 'P': - pnext = valid_next(pnext, ! exclusions.dot); - break; - case '9': - case 'A': case 'X': - case 'V': - case '1': - case 'N': - pnext = valid_next(p); - break; - case 'E': - pnext = valid_next(p, "+9"); - if( pnext && *pnext == '+' ) { - pnext = valid_next(p, "9"); - } - break; - default: - error_msg( loc, "PICTURE: %qc: invalid character", p[0] ); - return nullptr; - } - return pnext; - } - - public: - picture_t( const char *p, int len ) - : begin(p) - , p(p), pend(p + len) - , loc(yylloc) - { - assert(TOUPPER(*p) == 'P'); // as in PICTURE (or PICTURE IS) - // move p to start of picture string - while( (p = std::find_if(p, pend, fisspace)) != pend ) { - this->p = p = std::find_if(p, pend, - []( char ch ) { return ! fisspace(ch); } ); - } - assert(this->p != pend); - pos = this->p - begin; - } - - bool is_valid() { - if( !p ) return false; - if( (p = start()) == nullptr ) { - return false; - } - - while( p && p < pend) { - p = next(); - } - return p == pend; - } - - int starts_at() const { return pos; } -}; - -/* - * The Followers map gives 1 or 2 lists of valid characters following a - * character, the one in the key. If there are two lists, the correct one is - * determined by the caller based on the state of the picture string, i.e., - * what has been seen before. - */ -const std::map picture_t::followers { - /* B0/ */ { 'B', {"B0/,.Z*+-9AXVPNE" } }, - /* B0/ */ { '0', {"B0/,.Z*+-9AXVPNE" } }, - /* B0/ */ { '/', {"B0/,.Z*+-9AXVPNE" } }, - /* , */ { ',', {"B0/,.Z*+-9VPE"} }, - /* . */ { '.', {"B0/,Z*+-9E"} }, - /* +- */ { '+', {"B0/,.Z*9VPE", "" } }, - /* +- */ { '-', {"B0/,.Z*9VPE", "" } }, - /* Z* */ { 'Z', {"B0/,.+Z*9VP", "B0/,+Z*"} }, - /* Z* */ { '*', {"B0/,.+Z*9VP", "B0/,+Z*"} }, - /* + */ { '+', {"B0/,.+-9VP", "B0/,+-"} }, - /* cs */ { '$', {"B0/,.+9VP", "B0/,+"} }, - /* 9 */ { '9', {"B0/,.+9AXVPE"} }, - /* AX */ { 'A', {"B0/9AX"} }, - /* AX */ { 'X', {"B0/9AX"} }, - /* S */ { 'S', {"9VP"} }, - /* V */ { 'V', {"B0/,+Z*+-9P"} }, - /* P */ { 'P', {"+VP", "B0/,+Z*9P"} }, - /* 1 */ { '1', {"1"} }, - /* N */ { 'N', {"B0/N"} }, - /* E */ { 'E', {"+9"} }, -}; - -/* - * Although picture_t::is_valid return a bool, it's not used. The validation - * routines emit messages where the error is detected. The entire string is - * subsequently parsed by the parser, which might otherwise accept an invalid - * string, but will usually emit a message of its own. - */ -static int -validate_picture() { - picture_t picture(yytext, yyleng); - picture.is_valid(); - return picture.starts_at(); -} - static inline bool is_integer_token( int *pvalue = NULL ) { int v, n = 0; diff --git a/gcc/cobol/semantic_token.h b/gcc/cobol/semantic_token.h new file mode 100644 index 000000000000..0fead8c3d35b --- /dev/null +++ b/gcc/cobol/semantic_token.h @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2021-2026 Symas Corporation + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * * Neither the name of the Symas Corporation nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _SEMANTIC_TOKEN_H_ +#define _SEMANTIC_TOKEN_H_ + +struct lex_picture_t { + size_t pos; + uint64_t attr; + bool blank_when_zero_ok; + cbl_field_type_t type; + cbl_encoding_t encoding; + cbl_field_data_t *data; // NULL if error + + bool valid() const { return type != FldInvalid; } + void dump( cbl_name_t input ) const { + auto len = strlen(input); + int pad = len < 20? 20 - len : 0; + fprintf( stderr, "%-20s %s: '%s'%*s @ %u of %u (%s)", + cbl_field_type_str(type), + (attr & all_alpha_e)? "A" : " ", + input, + pad, "", + unsigned(pos), unsigned(strlen(input)), + __gg__encoding_iconv_name(encoding) ); + if( data ) { + fprintf( stderr, "%2u{%3u,%u,%d}", + data->memsize, data->capacity(), data->digits, data->rdigits ); + } + fprintf(stderr, "\n"); + } +}; + +lex_picture_t is_valid_picture(const cbl_loc_t& lock, const char picture[]); + +#endif diff --git a/gcc/cobol/symbols.cc b/gcc/cobol/symbols.cc index c41e0b8ff2a3..db64208fabfc 100644 --- a/gcc/cobol/symbols.cc +++ b/gcc/cobol/symbols.cc @@ -1828,7 +1828,6 @@ operator<<( std::ostream& os, const cbl_field_t& field ) { #pragma GCC diagnostic pop static std::map> same_record_areas; -size_t parse_error_count(); /* * This function produces a zero-filled level number, so 1 becomes "01". It's diff --git a/gcc/cobol/symbols.h b/gcc/cobol/symbols.h index d1864b1fdde6..a14d2e13c43d 100644 --- a/gcc/cobol/symbols.h +++ b/gcc/cobol/symbols.h @@ -39,6 +39,7 @@ #include #include +#include #include #include #include @@ -51,6 +52,8 @@ extern const char *numed_message; +typedef std::array tok_name_t; + static inline const char * cbl_dialect_str(cbl_dialect_t dialect) { switch(dialect) { @@ -551,6 +554,14 @@ class cbl_field_data_t { void original( REAL_VALUE_TYPE value ) { orig = orig_t(value); } + + void apply_picture( const cbl_field_data_t& that ) { + nbyte = that.nbyte; + digits = that.digits; + rdigits = that.rdigits; + picture = that.picture; + } + protected: cbl_field_data_t& copy_self( const cbl_field_data_t& that ) { memsize = that.memsize; diff --git a/gcc/cobol/symfind.cc b/gcc/cobol/symfind.cc index ebf7f5317b4b..c7e76a43682b 100644 --- a/gcc/cobol/symfind.cc +++ b/gcc/cobol/symfind.cc @@ -61,7 +61,7 @@ struct funcname { std::reverse_iterator rbeg(pend), rend(p); // Find the last character that could not by part of the function name. const std::string stop(" *&"); - auto rp = std::find_if( rbeg, rend, + auto rp = std::find_if( rbeg, rend, [stop]( char ch ) { return stop.find(ch) != std::string::npos; } ); @@ -136,7 +136,7 @@ static class symbol_file_names_t : protected symbol_map_t { std::vector ids( 1, file.default_record ); sym_name_t key(program, file.name, 0); (*this)[key] = ids; - // Keep track of symbols we added, so the parser can ask. + // Keep track of symbols we added, so the parser can ask. auto f = cbl_field_of(symbol_at(ids.front())); assert('_' == f->name[0]); // not a COBOL name named_defaults.insert(ids.front()); @@ -144,16 +144,16 @@ static class symbol_file_names_t : protected symbol_map_t { symbol_map_t find( size_t program, const char name[] ) const { symbol_map_t output; std::copy_if( cbegin(), cend(), - std::inserter(output, output.begin()), + std::inserter(output, output.begin()), [program, name]( const auto& elem ) { return match(program, name, elem); } ); - + dbgmsg("%s:%d: found %lu #%lu for %s", __funcsig__, __LINE__, (unsigned long)output.size(), output.empty()? 0ul : (unsigned long)output.begin()->second.front(), name); - + return output; } bool exists( const cbl_field_t * field ) const { @@ -596,12 +596,12 @@ symbol_match( size_t program, const std::list& names, bool diagnos symbol_map_t::key_type key( e->program, f->name, f->parent ); auto p = symbol_map.find(key); if( p == symbol_map.end() ) { - yyerror("%s is not defined", key.name); + yyerror("%qs is not defined", key.name); continue; } auto inserted = output.insert(*p); if( diagnose && ! inserted.second ) { - error_msg_direct("%s is not a unique reference", key.name); + error_msg_direct("%qs is not a unique reference", key.name); } } return output; diff --git a/gcc/cobol/token_names.h b/gcc/cobol/token_names.h index 407050fbde14..43eca0c613f7 100644 --- a/gcc/cobol/token_names.h +++ b/gcc/cobol/token_names.h @@ -38,459 +38,459 @@ tokens = { { "numed", NUMED }, // 293 { "numed-cr", NUMED_CR }, // 294 { "numed-db", NUMED_DB }, // 295 - { "ninedot", NINEDOT }, // 296 - { "nines", NINES }, // 297 - { "ninev", NINEV }, // 298 - { "pic-p", PIC_P }, // 299 - { "ones", ONES }, // 300 - { "spaces", SPACES }, // 301 - { "space", SPACES }, // 301 - { "-eq", _EQ }, // 302 - { "literal", LITERAL }, // 303 - { "end", END }, // 304 - { "eop", EOP }, // 305 - { "-filename", _FILENAME }, // 306 - { "invalid", INVALID }, // 307 - { "number", NUMBER }, // 308 - { "negative", NEGATIVE }, // 309 - { "numstr", NUMSTR }, // 310 - { "overflow", OVERFLOW_kw }, // 311 - { "-binary-integer", _BINARY_INTEGER }, // 312 - { "computational", COMPUTATIONAL }, // 313 - { "perform", PERFORM }, // 314 - { "backward", BACKWARD }, // 315 - { "positive", POSITIVE }, // 316 - { "pointer", POINTER }, // 317 - { "process", PROCESS }, // 318 - { "section", SECTION }, // 319 - { "standard-alphabet", STANDARD_ALPHABET }, // 320 - { "switch", SWITCH }, // 321 - { "upsi", UPSI }, // 322 - { "zero", ZERO }, // 323 - { "zeros", ZERO }, // 323 - { "zeroes", ZERO }, // 323 - { "sysin", SYSIN }, // 324 - { "sysipt", SYSIPT }, // 325 - { "sysout", SYSOUT }, // 326 - { "syslist", SYSLIST }, // 327 - { "syslst", SYSLST }, // 328 - { "syspunch", SYSPUNCH }, // 329 - { "syspch", SYSPCH }, // 330 - { "console", CONSOLE }, // 331 - { "c01", C01 }, // 332 - { "c02", C02 }, // 333 - { "c03", C03 }, // 334 - { "c04", C04 }, // 335 - { "c05", C05 }, // 336 - { "c06", C06 }, // 337 - { "c07", C07 }, // 338 - { "c08", C08 }, // 339 - { "c09", C09 }, // 340 - { "c10", C10 }, // 341 - { "c11", C11 }, // 342 - { "c12", C12 }, // 343 - { "csp", CSP }, // 344 - { "s01", S01 }, // 345 - { "s02", S02 }, // 346 - { "s03", S03 }, // 347 - { "s04", S04 }, // 348 - { "s05", S05 }, // 349 - { "afp-5a", AFP_5A }, // 350 - { "stdin", STDIN }, // 351 - { "stdout", STDOUT }, // 352 - { "stderr", STDERR }, // 353 - { "list", LIST }, // 354 - { "map", MAP }, // 355 - { "nolist", NOLIST }, // 356 - { "nomap", NOMAP }, // 357 - { "nosource", NOSOURCE }, // 358 - { "might-be", MIGHT_BE }, // 359 - { "function-udf", FUNCTION_UDF }, // 360 - { "function-udf-0", FUNCTION_UDF_0 }, // 361 - { "default", DEFAULT }, // 362 - { "date-fmt", DATE_FMT }, // 363 - { "time-fmt", TIME_FMT }, // 364 - { "datetime-fmt", DATETIME_FMT }, // 365 - { "flag-02", FLAG_02 }, // 366 - { "move-to-same-name", MOVE_TO_SAME_NAME }, // 367 - { "range-exception-for-index", RANGE_EXCEPTION_FOR_INDEX }, // 368 - { "terminate-with-varying", TERMINATE_WITH_VARYING }, // 369 - { "flag-14", FLAG_14 }, // 370 - { "compile-time-arithmetic-expressions", COMPILE_TIME_ARITHMETIC_EXPRESSIONS }, // 371 - { "i-o-declarative", I_O_DECLARATIVE }, // 372 - { "i-o-status-04", I_O_STATUS_04 }, // 373 - { "i-o-status-07", I_O_STATUS_07 }, // 374 - { "num-ed-zero-figconst", NUM_ED_ZERO_FIGCONST }, // 375 - { "read-previous", READ_PREVIOUS }, // 376 - { "ref-mod-zero-length", REF_MOD_ZERO_LENGTH }, // 377 - { "value-editing", VALUE_EDITING }, // 378 - { "value-fig-con-length", VALUE_FIG_CON_LENGTH }, // 379 - { "value-zero", VALUE_ZERO }, // 380 - { "write-end-of-page", WRITE_END_OF_PAGE }, // 381 - { "leap-second", LEAP_SECOND }, // 382 - { "listing", LISTING }, // 383 - { "propagate", PROPAGATE }, // 384 - { "zero-length", ZERO_LENGTH }, // 385 - { "b-and", B_AND }, // 386 - { "b-not", B_NOT }, // 387 - { "b-or", B_OR }, // 388 - { "b-shift-l", B_SHIFT_L }, // 389 - { "b-shift-lc", B_SHIFT_LC }, // 390 - { "b-shift-r", B_SHIFT_R }, // 391 - { "b-shift-rc", B_SHIFT_RC }, // 392 - { "b-xor", B_XOR }, // 393 - { "basis", BASIS }, // 394 - { "cbl", CBL }, // 395 - { "constant", CONSTANT }, // 396 - { "copy", COPY }, // 397 - { "defined", DEFINED }, // 398 - { "enter", ENTER }, // 399 - { "feature", FEATURE }, // 400 - { "insertt", INSERTT }, // 401 - { "lsub", LSUB }, // 402 - { "parameter", PARAMETER_kw }, // 403 - { "override", OVERRIDE }, // 404 - { "ready", READY }, // 405 - { "reset", RESET }, // 406 - { "rsub", RSUB }, // 407 - { "service-reload", SERVICE_RELOAD }, // 408 - { "star-cbl", STAR_CBL }, // 409 - { "subscript", SUBSCRIPT }, // 410 - { "suppress", SUPPRESS }, // 411 - { "trace", TRACE }, // 412 - { "use", USE }, // 413 - { "cobol-words", COBOL_WORDS }, // 414 - { "equate", EQUATE }, // 415 - { "undefine", UNDEFINE }, // 416 - { "cdf-define", CDF_DEFINE }, // 417 - { "cdf-display", CDF_DISPLAY }, // 418 - { "cdf-if", CDF_IF }, // 419 - { "cdf-else", CDF_ELSE }, // 420 - { "cdf-end-if", CDF_END_IF }, // 421 - { "cdf-evaluate", CDF_EVALUATE }, // 422 - { "cdf-when", CDF_WHEN }, // 423 - { "cdf-end-evaluate", CDF_END_EVALUATE }, // 424 - { "call-convention", CALL_CONVENTION }, // 425 - { "call-cobol", CALL_COBOL }, // 426 - { "call-verbatim", CALL_VERBATIM }, // 427 - { "cdf-push", CDF_PUSH }, // 428 - { "cdf-pop", CDF_POP }, // 429 - { "source-format", SOURCE_FORMAT }, // 430 - { "if", IF }, // 431 - { "then", THEN }, // 432 - { "else", ELSE }, // 433 - { "sentence", SENTENCE }, // 434 - { "accept", ACCEPT }, // 435 - { "add", ADD }, // 436 - { "alter", ALTER }, // 437 - { "call", CALL }, // 438 - { "cancel", CANCEL }, // 439 - { "close", CLOSE }, // 440 - { "compute", COMPUTE }, // 441 - { "continue", CONTINUE }, // 442 - { "delete", DELETE }, // 443 - { "display", DISPLAY }, // 444 - { "divide", DIVIDE }, // 445 - { "evaluate", EVALUATE }, // 446 - { "exit", EXIT }, // 447 - { "filler", FILLER_kw }, // 448 - { "goback", GOBACK }, // 449 - { "goto", GOTO }, // 450 - { "initialize", INITIALIZE }, // 451 - { "inspect", INSPECT }, // 452 - { "merge", MERGE }, // 453 - { "move", MOVE }, // 454 - { "multiply", MULTIPLY }, // 455 - { "open", OPEN }, // 456 - { "paragraph", PARAGRAPH }, // 457 - { "read", READ }, // 458 - { "release", RELEASE }, // 459 - { "return", RETURN }, // 460 - { "rewrite", REWRITE }, // 461 - { "search", SEARCH }, // 462 - { "set", SET }, // 463 - { "select", SELECT }, // 464 - { "sort", SORT }, // 465 - { "sort-merge", SORT_MERGE }, // 466 - { "string", STRING_kw }, // 467 - { "stop", STOP }, // 468 - { "subtract", SUBTRACT }, // 469 - { "start", START }, // 470 - { "unstring", UNSTRING }, // 471 - { "write", WRITE }, // 472 - { "when", WHEN }, // 473 - { "argument-number", ARGUMENT_NUMBER }, // 474 - { "argument-value", ARGUMENT_VALUE }, // 475 - { "environment-name", ENVIRONMENT_NAME }, // 476 - { "environment-value", ENVIRONMENT_VALUE }, // 477 - { "abs", ABS }, // 478 - { "access", ACCESS }, // 479 - { "acos", ACOS }, // 480 - { "actual", ACTUAL }, // 481 - { "advancing", ADVANCING }, // 482 - { "after", AFTER }, // 483 - { "all", ALL }, // 484 - { "allocate", ALLOCATE }, // 485 - { "alphabet", ALPHABET }, // 486 - { "alphabetic", ALPHABETIC }, // 487 - { "alphabetic-lower", ALPHABETIC_LOWER }, // 488 - { "alphabetic-upper", ALPHABETIC_UPPER }, // 489 - { "alphanumeric", ALPHANUMERIC }, // 490 - { "alphanumeric-edited", ALPHANUMERIC_EDITED }, // 491 - { "also", ALSO }, // 492 - { "alternate", ALTERNATE }, // 493 - { "annuity", ANNUITY }, // 494 - { "anum", ANUM }, // 495 - { "any", ANY }, // 496 - { "anycase", ANYCASE }, // 497 - { "apply", APPLY }, // 498 - { "are", ARE }, // 499 - { "area", AREA }, // 500 - { "areas", AREAS }, // 501 - { "as", AS }, // 502 - { "ascending", ASCENDING }, // 503 - { "activating", ACTIVATING }, // 504 - { "asin", ASIN }, // 505 - { "assign", ASSIGN }, // 506 - { "at", AT }, // 507 - { "atan", ATAN }, // 508 - { "based", BASED }, // 509 - { "baseconvert", BASECONVERT }, // 510 - { "before", BEFORE }, // 511 - { "binary", BINARY }, // 512 - { "bit", BIT }, // 513 - { "bit-of", BIT_OF }, // 514 - { "bit-to-char", BIT_TO_CHAR }, // 515 - { "blank", BLANK }, // 516 - { "block", BLOCK_kw }, // 517 - { "boolean-of-integer", BOOLEAN_OF_INTEGER }, // 518 - { "bottom", BOTTOM }, // 519 - { "by", BY }, // 520 - { "byte", BYTE }, // 521 - { "byte-length", BYTE_LENGTH }, // 522 - { "cf", CF }, // 523 - { "ch", CH }, // 524 - { "changed", CHANGED }, // 525 - { "char", CHAR }, // 526 - { "char-national", CHAR_NATIONAL }, // 527 - { "character", CHARACTER }, // 528 - { "characters", CHARACTERS }, // 529 - { "checking", CHECKING }, // 530 - { "class", CLASS }, // 531 - { "cobol", COBOL }, // 532 - { "code", CODE }, // 533 - { "code-set", CODESET }, // 534 - { "collating", COLLATING }, // 535 - { "column", COLUMN }, // 536 - { "combined-datetime", COMBINED_DATETIME }, // 537 - { "comma", COMMA }, // 538 - { "command-line", COMMAND_LINE }, // 539 - { "command-line-count", COMMAND_LINE_COUNT }, // 540 - { "commit", COMMIT }, // 541 - { "common", COMMON }, // 542 - { "concat", CONCAT }, // 543 - { "condition", CONDITION }, // 544 - { "configuration", CONFIGURATION }, // 545 - { "configuration section", CONFIGURATION_SECT }, // 546 - { "contains", CONTAINS }, // 547 - { "content", CONTENT }, // 548 - { "control", CONTROL }, // 549 - { "controls", CONTROLS }, // 550 - { "convert", CONVERT }, // 551 - { "converting", CONVERTING }, // 552 - { "corresponding", CORRESPONDING }, // 553 - { "cos", COS }, // 554 - { "count", COUNT }, // 555 - { "currency", CURRENCY }, // 556 - { "current", CURRENT }, // 557 - { "current-date", CURRENT_DATE }, // 558 - { "date", DATE }, // 559 - { "date-compiled", DATE_COMPILED }, // 560 - { "date-of-integer", DATE_OF_INTEGER }, // 561 - { "date-to-yyyymmdd", DATE_TO_YYYYMMDD }, // 562 - { "date-written", DATE_WRITTEN }, // 563 - { "day", DAY }, // 564 - { "day-of-integer", DAY_OF_INTEGER }, // 565 - { "day-of-week", DAY_OF_WEEK }, // 566 - { "day-to-yyyyddd", DAY_TO_YYYYDDD }, // 567 - { "dbcs", DBCS }, // 568 - { "de", DE }, // 569 - { "debugging", DEBUGGING }, // 570 - { "decimal-point", DECIMAL_POINT }, // 571 - { "declaratives", DECLARATIVES }, // 572 - { "delimited", DELIMITED }, // 573 - { "delimiter", DELIMITER }, // 574 - { "depending", DEPENDING }, // 575 - { "descending", DESCENDING }, // 576 - { "detail", DETAIL }, // 577 - { "direct", DIRECT }, // 578 - { "direct-access", DIRECT_ACCESS }, // 579 - { "division", DIVISION }, // 580 - { "down", DOWN }, // 581 - { "duplicates", DUPLICATES }, // 582 - { "dynamic", DYNAMIC }, // 583 - { "e", E }, // 584 - { "ebcdic", EBCDIC }, // 585 - { "ec", EC }, // 586 - { "egcs", EGCS }, // 587 - { "encoding", ENCODING }, // 588 - { "entry", ENTRY }, // 589 - { "every", EVERY }, // 590 - { "examine", EXAMINE }, // 591 - { "exhibit", EXHIBIT }, // 592 - { "exp", EXP }, // 593 - { "exp10", EXP10 }, // 594 - { "extend", EXTEND }, // 595 - { "external", EXTERNAL }, // 596 - { "exception-file", EXCEPTION_FILE }, // 597 - { "exception-file-n", EXCEPTION_FILE_N }, // 598 - { "exception-location", EXCEPTION_LOCATION }, // 599 - { "exception-location-n", EXCEPTION_LOCATION_N }, // 600 - { "exception-statement", EXCEPTION_STATEMENT }, // 601 - { "exception-status", EXCEPTION_STATUS }, // 602 - { "factorial", FACTORIAL }, // 603 - { "false", FALSE_kw }, // 604 - { "fd", FD }, // 605 - { "file-control", FILE_CONTROL }, // 606 - { "file", FILE_KW }, // 607 - { "file-limit", FILE_LIMIT }, // 608 - { "final", FINAL }, // 609 - { "finally", FINALLY }, // 610 - { "find-string", FIND_STRING }, // 611 - { "first", FIRST }, // 612 - { "fixed", FIXED }, // 613 - { "footing", FOOTING }, // 614 - { "for", FOR }, // 615 - { "formatted-current-date", FORMATTED_CURRENT_DATE }, // 616 - { "formatted-date", FORMATTED_DATE }, // 617 - { "formatted-datetime", FORMATTED_DATETIME }, // 618 - { "formatted-time", FORMATTED_TIME }, // 619 - { "form-overflow", FORM_OVERFLOW }, // 620 - { "free", FREE }, // 621 - { "fraction-part", FRACTION_PART }, // 622 - { "from", FROM }, // 623 - { "function", FUNCTION }, // 624 - { "generate", GENERATE }, // 625 - { "giving", GIVING }, // 626 - { "global", GLOBAL }, // 627 - { "go", GO }, // 628 - { "group", GROUP }, // 629 - { "heading", HEADING }, // 630 - { "hex", HEX }, // 631 - { "hex-of", HEX_OF }, // 632 - { "hex-to-char", HEX_TO_CHAR }, // 633 - { "high-values", HIGH_VALUES }, // 634 - { "highest-algebraic", HIGHEST_ALGEBRAIC }, // 635 - { "hold", HOLD }, // 636 - { "ibm-360", IBM_360 }, // 637 - { "in", IN }, // 638 - { "include", INCLUDE }, // 639 - { "index", INDEX }, // 640 - { "indexed", INDEXED }, // 641 - { "indicate", INDICATE }, // 642 - { "initial", INITIAL_kw }, // 643 - { "initiate", INITIATE }, // 644 - { "input", INPUT }, // 645 - { "installation", INSTALLATION }, // 646 - { "interface", INTERFACE }, // 647 - { "integer", INTEGER }, // 648 - { "integer-of-boolean", INTEGER_OF_BOOLEAN }, // 649 - { "integer-of-date", INTEGER_OF_DATE }, // 650 - { "integer-of-day", INTEGER_OF_DAY }, // 651 - { "integer-of-formatted-date", INTEGER_OF_FORMATTED_DATE }, // 652 - { "integer-part", INTEGER_PART }, // 653 - { "into", INTO }, // 654 - { "intrinsic", INTRINSIC }, // 655 - { "invoke", INVOKE }, // 656 - { "i-o", IO }, // 657 - { "i-o-control", IO_CONTROL }, // 658 - { "is", IS }, // 659 - { "isnt", ISNT }, // 660 - { "kanji", KANJI }, // 661 - { "key", KEY }, // 662 - { "label", LABEL }, // 663 - { "last", LAST }, // 664 - { "leading", LEADING }, // 665 - { "left", LEFT }, // 666 - { "length", LENGTH }, // 667 - { "length-of", LENGTH_OF }, // 668 - { "limit", LIMIT }, // 669 - { "limits", LIMITS }, // 670 - { "line", LINE }, // 671 - { "lines", LINES }, // 672 - { "line-counter", LINE_COUNTER }, // 673 - { "linage", LINAGE }, // 674 - { "linkage", LINKAGE }, // 675 - { "locale", LOCALE }, // 676 - { "locale-compare", LOCALE_COMPARE }, // 677 - { "locale-date", LOCALE_DATE }, // 678 - { "locale-time", LOCALE_TIME }, // 679 - { "locale-time-from-seconds", LOCALE_TIME_FROM_SECONDS }, // 680 - { "local-storage", LOCAL_STORAGE }, // 681 - { "location", LOCATION }, // 682 - { "lock", LOCK }, // 683 - { "lock-on", LOCK_ON }, // 684 - { "log", LOG }, // 685 - { "log10", LOG10 }, // 686 - { "lower-case", LOWER_CASE }, // 687 - { "low-values", LOW_VALUES }, // 688 - { "lowest-algebraic", LOWEST_ALGEBRAIC }, // 689 - { "lparen", LPAREN }, // 690 - { "manual", MANUAL }, // 691 - { "maxx", MAXX }, // 692 - { "mean", MEAN }, // 693 - { "median", MEDIAN }, // 694 - { "midrange", MIDRANGE }, // 695 - { "minn", MINN }, // 696 - { "multiple", MULTIPLE }, // 697 - { "mod", MOD }, // 698 - { "mode", MODE }, // 699 - { "module-name", MODULE_NAME }, // 700 - { "named", NAMED }, // 701 - { "namespace", NAMESPACE }, // 702 - { "namespace-prefix", NAMESPACE_PREFIX }, // 703 - { "nat", NAT }, // 704 - { "national", NATIONAL }, // 705 - { "national-edited", NATIONAL_EDITED }, // 706 - { "national-of", NATIONAL_OF }, // 707 - { "native", NATIVE }, // 708 - { "nested", NESTED }, // 709 - { "next", NEXT }, // 710 - { "no", NO }, // 711 - { "note", NOTE }, // 712 - { "nulls", NULLS }, // 713 - { "null", NULLS }, // 713 - { "nullptr", NULLPTR }, // 714 - { "numeric", NUMERIC }, // 715 - { "numeric-edited", NUMERIC_EDITED }, // 716 - { "numval", NUMVAL }, // 717 - { "numval-c", NUMVAL_C }, // 718 - { "numval-f", NUMVAL_F }, // 719 - { "occurs", OCCURS }, // 720 - { "of", OF }, // 721 - { "off", OFF }, // 722 - { "omitted", OMITTED }, // 723 - { "on", ON }, // 724 - { "only", ONLY }, // 725 - { "optional", OPTIONAL }, // 726 - { "options", OPTIONS }, // 727 - { "ord", ORD }, // 728 - { "order", ORDER }, // 729 - { "ord-max", ORD_MAX }, // 730 - { "ord-min", ORD_MIN }, // 731 - { "organization", ORGANIZATION }, // 732 - { "other", OTHER }, // 733 - { "otherwise", OTHERWISE }, // 734 - { "output", OUTPUT }, // 735 - { "packed-decimal", PACKED_DECIMAL }, // 736 - { "padding", PADDING }, // 737 - { "page", PAGE }, // 738 - { "page-counter", PAGE_COUNTER }, // 739 - { "pf", PF }, // 740 - { "ph", PH }, // 741 - { "pi", PI }, // 742 - { "pic", PIC }, // 743 - { "picture", PICTURE }, // 744 + { "picture", PICTURE }, // 296 + { "ninedot", NINEDOT }, // 297 + { "nines", NINES }, // 298 + { "ninev", NINEV }, // 299 + { "pic-p", PIC_P }, // 300 + { "ones", ONES }, // 301 + { "spaces", SPACES }, // 302 + { "space", SPACES }, // 302 + { "-eq", _EQ }, // 303 + { "literal", LITERAL }, // 304 + { "end", END }, // 305 + { "eop", EOP }, // 306 + { "-filename", _FILENAME }, // 307 + { "invalid", INVALID }, // 308 + { "number", NUMBER }, // 309 + { "negative", NEGATIVE }, // 310 + { "numstr", NUMSTR }, // 311 + { "overflow", OVERFLOW_kw }, // 312 + { "-binary-integer", _BINARY_INTEGER }, // 313 + { "computational", COMPUTATIONAL }, // 314 + { "perform", PERFORM }, // 315 + { "backward", BACKWARD }, // 316 + { "positive", POSITIVE }, // 317 + { "pointer", POINTER }, // 318 + { "process", PROCESS }, // 319 + { "section", SECTION }, // 320 + { "standard-alphabet", STANDARD_ALPHABET }, // 321 + { "switch", SWITCH }, // 322 + { "upsi", UPSI }, // 323 + { "zero", ZERO }, // 324 + { "zeros", ZERO }, // 324 + { "zeroes", ZERO }, // 324 + { "sysin", SYSIN }, // 325 + { "sysipt", SYSIPT }, // 326 + { "sysout", SYSOUT }, // 327 + { "syslist", SYSLIST }, // 328 + { "syslst", SYSLST }, // 329 + { "syspunch", SYSPUNCH }, // 330 + { "syspch", SYSPCH }, // 331 + { "console", CONSOLE }, // 332 + { "c01", C01 }, // 333 + { "c02", C02 }, // 334 + { "c03", C03 }, // 335 + { "c04", C04 }, // 336 + { "c05", C05 }, // 337 + { "c06", C06 }, // 338 + { "c07", C07 }, // 339 + { "c08", C08 }, // 340 + { "c09", C09 }, // 341 + { "c10", C10 }, // 342 + { "c11", C11 }, // 343 + { "c12", C12 }, // 344 + { "csp", CSP }, // 345 + { "s01", S01 }, // 346 + { "s02", S02 }, // 347 + { "s03", S03 }, // 348 + { "s04", S04 }, // 349 + { "s05", S05 }, // 350 + { "afp-5a", AFP_5A }, // 351 + { "stdin", STDIN }, // 352 + { "stdout", STDOUT }, // 353 + { "stderr", STDERR }, // 354 + { "list", LIST }, // 355 + { "map", MAP }, // 356 + { "nolist", NOLIST }, // 357 + { "nomap", NOMAP }, // 358 + { "nosource", NOSOURCE }, // 359 + { "might-be", MIGHT_BE }, // 360 + { "function-udf", FUNCTION_UDF }, // 361 + { "function-udf-0", FUNCTION_UDF_0 }, // 362 + { "default", DEFAULT }, // 363 + { "date-fmt", DATE_FMT }, // 364 + { "time-fmt", TIME_FMT }, // 365 + { "datetime-fmt", DATETIME_FMT }, // 366 + { "flag-02", FLAG_02 }, // 367 + { "move-to-same-name", MOVE_TO_SAME_NAME }, // 368 + { "range-exception-for-index", RANGE_EXCEPTION_FOR_INDEX }, // 369 + { "terminate-with-varying", TERMINATE_WITH_VARYING }, // 370 + { "flag-14", FLAG_14 }, // 371 + { "compile-time-arithmetic-expressions", COMPILE_TIME_ARITHMETIC_EXPRESSIONS }, // 372 + { "i-o-declarative", I_O_DECLARATIVE }, // 373 + { "i-o-status-04", I_O_STATUS_04 }, // 374 + { "i-o-status-07", I_O_STATUS_07 }, // 375 + { "num-ed-zero-figconst", NUM_ED_ZERO_FIGCONST }, // 376 + { "read-previous", READ_PREVIOUS }, // 377 + { "ref-mod-zero-length", REF_MOD_ZERO_LENGTH }, // 378 + { "value-editing", VALUE_EDITING }, // 379 + { "value-fig-con-length", VALUE_FIG_CON_LENGTH }, // 380 + { "value-zero", VALUE_ZERO }, // 381 + { "write-end-of-page", WRITE_END_OF_PAGE }, // 382 + { "leap-second", LEAP_SECOND }, // 383 + { "listing", LISTING }, // 384 + { "propagate", PROPAGATE }, // 385 + { "zero-length", ZERO_LENGTH }, // 386 + { "b-and", B_AND }, // 387 + { "b-not", B_NOT }, // 388 + { "b-or", B_OR }, // 389 + { "b-shift-l", B_SHIFT_L }, // 390 + { "b-shift-lc", B_SHIFT_LC }, // 391 + { "b-shift-r", B_SHIFT_R }, // 392 + { "b-shift-rc", B_SHIFT_RC }, // 393 + { "b-xor", B_XOR }, // 394 + { "basis", BASIS }, // 395 + { "cbl", CBL }, // 396 + { "constant", CONSTANT }, // 397 + { "copy", COPY }, // 398 + { "defined", DEFINED }, // 399 + { "enter", ENTER }, // 400 + { "feature", FEATURE }, // 401 + { "insertt", INSERTT }, // 402 + { "lsub", LSUB }, // 403 + { "parameter", PARAMETER_kw }, // 404 + { "override", OVERRIDE }, // 405 + { "ready", READY }, // 406 + { "reset", RESET }, // 407 + { "rsub", RSUB }, // 408 + { "service-reload", SERVICE_RELOAD }, // 409 + { "star-cbl", STAR_CBL }, // 410 + { "subscript", SUBSCRIPT }, // 411 + { "suppress", SUPPRESS }, // 412 + { "trace", TRACE }, // 413 + { "use", USE }, // 414 + { "cobol-words", COBOL_WORDS }, // 415 + { "equate", EQUATE }, // 416 + { "undefine", UNDEFINE }, // 417 + { "cdf-define", CDF_DEFINE }, // 418 + { "cdf-display", CDF_DISPLAY }, // 419 + { "cdf-if", CDF_IF }, // 420 + { "cdf-else", CDF_ELSE }, // 421 + { "cdf-end-if", CDF_END_IF }, // 422 + { "cdf-evaluate", CDF_EVALUATE }, // 423 + { "cdf-when", CDF_WHEN }, // 424 + { "cdf-end-evaluate", CDF_END_EVALUATE }, // 425 + { "call-convention", CALL_CONVENTION }, // 426 + { "call-cobol", CALL_COBOL }, // 427 + { "call-verbatim", CALL_VERBATIM }, // 428 + { "cdf-push", CDF_PUSH }, // 429 + { "cdf-pop", CDF_POP }, // 430 + { "source-format", SOURCE_FORMAT }, // 431 + { "if", IF }, // 432 + { "then", THEN }, // 433 + { "else", ELSE }, // 434 + { "sentence", SENTENCE }, // 435 + { "accept", ACCEPT }, // 436 + { "add", ADD }, // 437 + { "alter", ALTER }, // 438 + { "call", CALL }, // 439 + { "cancel", CANCEL }, // 440 + { "close", CLOSE }, // 441 + { "compute", COMPUTE }, // 442 + { "continue", CONTINUE }, // 443 + { "delete", DELETE }, // 444 + { "display", DISPLAY }, // 445 + { "divide", DIVIDE }, // 446 + { "evaluate", EVALUATE }, // 447 + { "exit", EXIT }, // 448 + { "filler", FILLER_kw }, // 449 + { "goback", GOBACK }, // 450 + { "goto", GOTO }, // 451 + { "initialize", INITIALIZE }, // 452 + { "inspect", INSPECT }, // 453 + { "merge", MERGE }, // 454 + { "move", MOVE }, // 455 + { "multiply", MULTIPLY }, // 456 + { "open", OPEN }, // 457 + { "paragraph", PARAGRAPH }, // 458 + { "read", READ }, // 459 + { "release", RELEASE }, // 460 + { "return", RETURN }, // 461 + { "rewrite", REWRITE }, // 462 + { "search", SEARCH }, // 463 + { "set", SET }, // 464 + { "select", SELECT }, // 465 + { "sort", SORT }, // 466 + { "sort-merge", SORT_MERGE }, // 467 + { "string", STRING_kw }, // 468 + { "stop", STOP }, // 469 + { "subtract", SUBTRACT }, // 470 + { "start", START }, // 471 + { "unstring", UNSTRING }, // 472 + { "write", WRITE }, // 473 + { "when", WHEN }, // 474 + { "argument-number", ARGUMENT_NUMBER }, // 475 + { "argument-value", ARGUMENT_VALUE }, // 476 + { "environment-name", ENVIRONMENT_NAME }, // 477 + { "environment-value", ENVIRONMENT_VALUE }, // 478 + { "abs", ABS }, // 479 + { "access", ACCESS }, // 480 + { "acos", ACOS }, // 481 + { "actual", ACTUAL }, // 482 + { "advancing", ADVANCING }, // 483 + { "after", AFTER }, // 484 + { "all", ALL }, // 485 + { "allocate", ALLOCATE }, // 486 + { "alphabet", ALPHABET }, // 487 + { "alphabetic", ALPHABETIC }, // 488 + { "alphabetic-lower", ALPHABETIC_LOWER }, // 489 + { "alphabetic-upper", ALPHABETIC_UPPER }, // 490 + { "alphanumeric", ALPHANUMERIC }, // 491 + { "alphanumeric-edited", ALPHANUMERIC_EDITED }, // 492 + { "also", ALSO }, // 493 + { "alternate", ALTERNATE }, // 494 + { "annuity", ANNUITY }, // 495 + { "anum", ANUM }, // 496 + { "any", ANY }, // 497 + { "anycase", ANYCASE }, // 498 + { "apply", APPLY }, // 499 + { "are", ARE }, // 500 + { "area", AREA }, // 501 + { "areas", AREAS }, // 502 + { "as", AS }, // 503 + { "ascending", ASCENDING }, // 504 + { "activating", ACTIVATING }, // 505 + { "asin", ASIN }, // 506 + { "assign", ASSIGN }, // 507 + { "at", AT }, // 508 + { "atan", ATAN }, // 509 + { "based", BASED }, // 510 + { "baseconvert", BASECONVERT }, // 511 + { "before", BEFORE }, // 512 + { "binary", BINARY }, // 513 + { "bit", BIT }, // 514 + { "bit-of", BIT_OF }, // 515 + { "bit-to-char", BIT_TO_CHAR }, // 516 + { "blank", BLANK }, // 517 + { "block", BLOCK_kw }, // 518 + { "boolean-of-integer", BOOLEAN_OF_INTEGER }, // 519 + { "bottom", BOTTOM }, // 520 + { "by", BY }, // 521 + { "byte", BYTE }, // 522 + { "byte-length", BYTE_LENGTH }, // 523 + { "cf", CF }, // 524 + { "ch", CH }, // 525 + { "changed", CHANGED }, // 526 + { "char", CHAR }, // 527 + { "char-national", CHAR_NATIONAL }, // 528 + { "character", CHARACTER }, // 529 + { "characters", CHARACTERS }, // 530 + { "checking", CHECKING }, // 531 + { "class", CLASS }, // 532 + { "cobol", COBOL }, // 533 + { "code", CODE }, // 534 + { "code-set", CODESET }, // 535 + { "collating", COLLATING }, // 536 + { "column", COLUMN }, // 537 + { "combined-datetime", COMBINED_DATETIME }, // 538 + { "comma", COMMA }, // 539 + { "command-line", COMMAND_LINE }, // 540 + { "command-line-count", COMMAND_LINE_COUNT }, // 541 + { "commit", COMMIT }, // 542 + { "common", COMMON }, // 543 + { "concat", CONCAT }, // 544 + { "condition", CONDITION }, // 545 + { "configuration", CONFIGURATION }, // 546 + { "configuration section", CONFIGURATION_SECT }, // 547 + { "contains", CONTAINS }, // 548 + { "content", CONTENT }, // 549 + { "control", CONTROL }, // 550 + { "controls", CONTROLS }, // 551 + { "convert", CONVERT }, // 552 + { "converting", CONVERTING }, // 553 + { "corresponding", CORRESPONDING }, // 554 + { "cos", COS }, // 555 + { "count", COUNT }, // 556 + { "currency", CURRENCY }, // 557 + { "current", CURRENT }, // 558 + { "current-date", CURRENT_DATE }, // 559 + { "date", DATE }, // 560 + { "date-compiled", DATE_COMPILED }, // 561 + { "date-of-integer", DATE_OF_INTEGER }, // 562 + { "date-to-yyyymmdd", DATE_TO_YYYYMMDD }, // 563 + { "date-written", DATE_WRITTEN }, // 564 + { "day", DAY }, // 565 + { "day-of-integer", DAY_OF_INTEGER }, // 566 + { "day-of-week", DAY_OF_WEEK }, // 567 + { "day-to-yyyyddd", DAY_TO_YYYYDDD }, // 568 + { "dbcs", DBCS }, // 569 + { "de", DE }, // 570 + { "debugging", DEBUGGING }, // 571 + { "decimal-point", DECIMAL_POINT }, // 572 + { "declaratives", DECLARATIVES }, // 573 + { "delimited", DELIMITED }, // 574 + { "delimiter", DELIMITER }, // 575 + { "depending", DEPENDING }, // 576 + { "descending", DESCENDING }, // 577 + { "detail", DETAIL }, // 578 + { "direct", DIRECT }, // 579 + { "direct-access", DIRECT_ACCESS }, // 580 + { "division", DIVISION }, // 581 + { "down", DOWN }, // 582 + { "duplicates", DUPLICATES }, // 583 + { "dynamic", DYNAMIC }, // 584 + { "e", E }, // 585 + { "ebcdic", EBCDIC }, // 586 + { "ec", EC }, // 587 + { "egcs", EGCS }, // 588 + { "encoding", ENCODING }, // 589 + { "entry", ENTRY }, // 590 + { "every", EVERY }, // 591 + { "examine", EXAMINE }, // 592 + { "exhibit", EXHIBIT }, // 593 + { "exp", EXP }, // 594 + { "exp10", EXP10 }, // 595 + { "extend", EXTEND }, // 596 + { "external", EXTERNAL }, // 597 + { "exception-file", EXCEPTION_FILE }, // 598 + { "exception-file-n", EXCEPTION_FILE_N }, // 599 + { "exception-location", EXCEPTION_LOCATION }, // 600 + { "exception-location-n", EXCEPTION_LOCATION_N }, // 601 + { "exception-statement", EXCEPTION_STATEMENT }, // 602 + { "exception-status", EXCEPTION_STATUS }, // 603 + { "factorial", FACTORIAL }, // 604 + { "false", FALSE_kw }, // 605 + { "fd", FD }, // 606 + { "file-control", FILE_CONTROL }, // 607 + { "file", FILE_KW }, // 608 + { "file-limit", FILE_LIMIT }, // 609 + { "final", FINAL }, // 610 + { "finally", FINALLY }, // 611 + { "find-string", FIND_STRING }, // 612 + { "first", FIRST }, // 613 + { "fixed", FIXED }, // 614 + { "footing", FOOTING }, // 615 + { "for", FOR }, // 616 + { "formatted-current-date", FORMATTED_CURRENT_DATE }, // 617 + { "formatted-date", FORMATTED_DATE }, // 618 + { "formatted-datetime", FORMATTED_DATETIME }, // 619 + { "formatted-time", FORMATTED_TIME }, // 620 + { "form-overflow", FORM_OVERFLOW }, // 621 + { "free", FREE }, // 622 + { "fraction-part", FRACTION_PART }, // 623 + { "from", FROM }, // 624 + { "function", FUNCTION }, // 625 + { "generate", GENERATE }, // 626 + { "giving", GIVING }, // 627 + { "global", GLOBAL }, // 628 + { "go", GO }, // 629 + { "group", GROUP }, // 630 + { "heading", HEADING }, // 631 + { "hex", HEX }, // 632 + { "hex-of", HEX_OF }, // 633 + { "hex-to-char", HEX_TO_CHAR }, // 634 + { "high-values", HIGH_VALUES }, // 635 + { "highest-algebraic", HIGHEST_ALGEBRAIC }, // 636 + { "hold", HOLD }, // 637 + { "ibm-360", IBM_360 }, // 638 + { "in", IN }, // 639 + { "include", INCLUDE }, // 640 + { "index", INDEX }, // 641 + { "indexed", INDEXED }, // 642 + { "indicate", INDICATE }, // 643 + { "initial", INITIAL_kw }, // 644 + { "initiate", INITIATE }, // 645 + { "input", INPUT }, // 646 + { "installation", INSTALLATION }, // 647 + { "interface", INTERFACE }, // 648 + { "integer", INTEGER }, // 649 + { "integer-of-boolean", INTEGER_OF_BOOLEAN }, // 650 + { "integer-of-date", INTEGER_OF_DATE }, // 651 + { "integer-of-day", INTEGER_OF_DAY }, // 652 + { "integer-of-formatted-date", INTEGER_OF_FORMATTED_DATE }, // 653 + { "integer-part", INTEGER_PART }, // 654 + { "into", INTO }, // 655 + { "intrinsic", INTRINSIC }, // 656 + { "invoke", INVOKE }, // 657 + { "i-o", IO }, // 658 + { "i-o-control", IO_CONTROL }, // 659 + { "is", IS }, // 660 + { "isnt", ISNT }, // 661 + { "kanji", KANJI }, // 662 + { "key", KEY }, // 663 + { "label", LABEL }, // 664 + { "last", LAST }, // 665 + { "leading", LEADING }, // 666 + { "left", LEFT }, // 667 + { "length", LENGTH }, // 668 + { "length-of", LENGTH_OF }, // 669 + { "limit", LIMIT }, // 670 + { "limits", LIMITS }, // 671 + { "line", LINE }, // 672 + { "lines", LINES }, // 673 + { "line-counter", LINE_COUNTER }, // 674 + { "linage", LINAGE }, // 675 + { "linkage", LINKAGE }, // 676 + { "locale", LOCALE }, // 677 + { "locale-compare", LOCALE_COMPARE }, // 678 + { "locale-date", LOCALE_DATE }, // 679 + { "locale-time", LOCALE_TIME }, // 680 + { "locale-time-from-seconds", LOCALE_TIME_FROM_SECONDS }, // 681 + { "local-storage", LOCAL_STORAGE }, // 682 + { "location", LOCATION }, // 683 + { "lock", LOCK }, // 684 + { "lock-on", LOCK_ON }, // 685 + { "log", LOG }, // 686 + { "log10", LOG10 }, // 687 + { "lower-case", LOWER_CASE }, // 688 + { "low-values", LOW_VALUES }, // 689 + { "lowest-algebraic", LOWEST_ALGEBRAIC }, // 690 + { "lparen", LPAREN }, // 691 + { "manual", MANUAL }, // 692 + { "maxx", MAXX }, // 693 + { "mean", MEAN }, // 694 + { "median", MEDIAN }, // 695 + { "midrange", MIDRANGE }, // 696 + { "minn", MINN }, // 697 + { "multiple", MULTIPLE }, // 698 + { "mod", MOD }, // 699 + { "mode", MODE }, // 700 + { "module-name", MODULE_NAME }, // 701 + { "named", NAMED }, // 702 + { "namespace", NAMESPACE }, // 703 + { "namespace-prefix", NAMESPACE_PREFIX }, // 704 + { "nat", NAT }, // 705 + { "national", NATIONAL }, // 706 + { "national-edited", NATIONAL_EDITED }, // 707 + { "national-of", NATIONAL_OF }, // 708 + { "native", NATIVE }, // 709 + { "nested", NESTED }, // 710 + { "next", NEXT }, // 711 + { "no", NO }, // 712 + { "note", NOTE }, // 713 + { "nulls", NULLS }, // 714 + { "null", NULLS }, // 714 + { "nullptr", NULLPTR }, // 715 + { "numeric", NUMERIC }, // 716 + { "numeric-edited", NUMERIC_EDITED }, // 717 + { "numval", NUMVAL }, // 718 + { "numval-c", NUMVAL_C }, // 719 + { "numval-f", NUMVAL_F }, // 720 + { "occurs", OCCURS }, // 721 + { "of", OF }, // 722 + { "off", OFF }, // 723 + { "omitted", OMITTED }, // 724 + { "on", ON }, // 725 + { "only", ONLY }, // 726 + { "optional", OPTIONAL }, // 727 + { "options", OPTIONS }, // 728 + { "ord", ORD }, // 729 + { "order", ORDER }, // 730 + { "ord-max", ORD_MAX }, // 731 + { "ord-min", ORD_MIN }, // 732 + { "organization", ORGANIZATION }, // 733 + { "other", OTHER }, // 734 + { "otherwise", OTHERWISE }, // 735 + { "output", OUTPUT }, // 736 + { "packed-decimal", PACKED_DECIMAL }, // 737 + { "padding", PADDING }, // 738 + { "page", PAGE }, // 739 + { "page-counter", PAGE_COUNTER }, // 740 + { "pf", PF }, // 741 + { "ph", PH }, // 742 + { "pi", PI }, // 743 + { "pic", PIC }, // 744 { "plus", PLUS }, // 745 { "present-value", PRESENT_VALUE }, // 746 { "print-switch", PRINT_SWITCH }, // 747 @@ -779,455 +779,455 @@ token_names = { "NUMED", // 35 (293) "NUMED-CR", // 36 (294) "NUMED-DB", // 37 (295) - "NINEDOT", // 38 (296) - "NINES", // 39 (297) - "NINEV", // 40 (298) - "PIC-P", // 41 (299) - "ONES", // 42 (300) - "SPACES", // 43 (301) - "-EQ", // 44 (302) - "LITERAL", // 45 (303) - "END", // 46 (304) - "EOP", // 47 (305) - "-FILENAME", // 48 (306) - "INVALID", // 49 (307) - "NUMBER", // 50 (308) - "NEGATIVE", // 51 (309) - "NUMSTR", // 52 (310) - "OVERFLOW", // 53 (311) - "-BINARY-INTEGER", // 54 (312) - "COMPUTATIONAL", // 55 (313) - "PERFORM", // 56 (314) - "BACKWARD", // 57 (315) - "POSITIVE", // 58 (316) - "POINTER", // 59 (317) - "PROCESS", // 60 (318) - "SECTION", // 61 (319) - "STANDARD-ALPHABET", // 62 (320) - "SWITCH", // 63 (321) - "UPSI", // 64 (322) - "ZERO", // 65 (323) - "SYSIN", // 66 (324) - "SYSIPT", // 67 (325) - "SYSOUT", // 68 (326) - "SYSLIST", // 69 (327) - "SYSLST", // 70 (328) - "SYSPUNCH", // 71 (329) - "SYSPCH", // 72 (330) - "CONSOLE", // 73 (331) - "C01", // 74 (332) - "C02", // 75 (333) - "C03", // 76 (334) - "C04", // 77 (335) - "C05", // 78 (336) - "C06", // 79 (337) - "C07", // 80 (338) - "C08", // 81 (339) - "C09", // 82 (340) - "C10", // 83 (341) - "C11", // 84 (342) - "C12", // 85 (343) - "CSP", // 86 (344) - "S01", // 87 (345) - "S02", // 88 (346) - "S03", // 89 (347) - "S04", // 90 (348) - "S05", // 91 (349) - "AFP-5A", // 92 (350) - "STDIN", // 93 (351) - "STDOUT", // 94 (352) - "STDERR", // 95 (353) - "LIST", // 96 (354) - "MAP", // 97 (355) - "NOLIST", // 98 (356) - "NOMAP", // 99 (357) - "NOSOURCE", // 100 (358) - "MIGHT-BE", // 101 (359) - "FUNCTION-UDF", // 102 (360) - "FUNCTION-UDF-0", // 103 (361) - "DEFAULT", // 104 (362) - "DATE-FMT", // 105 (363) - "TIME-FMT", // 106 (364) - "DATETIME-FMT", // 107 (365) - "FLAG-02", // 108 (366) - "MOVE-TO-SAME-NAME", // 109 (367) - "RANGE-EXCEPTION-FOR-INDEX", // 110 (368) - "TERMINATE-WITH-VARYING", // 111 (369) - "FLAG-14", // 112 (370) - "COMPILE-TIME-ARITHMETIC-EXPRESSIONS", // 113 (371) - "I-O-DECLARATIVE", // 114 (372) - "I-O-STATUS-04", // 115 (373) - "I-O-STATUS-07", // 116 (374) - "NUM-ED-ZERO-FIGCONST", // 117 (375) - "READ-PREVIOUS", // 118 (376) - "REF-MOD-ZERO-LENGTH", // 119 (377) - "VALUE-EDITING", // 120 (378) - "VALUE-FIG-CON-LENGTH", // 121 (379) - "VALUE-ZERO", // 122 (380) - "WRITE-END-OF-PAGE", // 123 (381) - "LEAP-SECOND", // 124 (382) - "LISTING", // 125 (383) - "PROPAGATE", // 126 (384) - "ZERO-LENGTH", // 127 (385) - "B-AND", // 128 (386) - "B-NOT", // 129 (387) - "B-OR", // 130 (388) - "B-SHIFT-L", // 131 (389) - "B-SHIFT-LC", // 132 (390) - "B-SHIFT-R", // 133 (391) - "B-SHIFT-RC", // 134 (392) - "B-XOR", // 135 (393) - "BASIS", // 136 (394) - "CBL", // 137 (395) - "CONSTANT", // 138 (396) - "COPY", // 139 (397) - "DEFINED", // 140 (398) - "ENTER", // 141 (399) - "FEATURE", // 142 (400) - "INSERTT", // 143 (401) - "LSUB", // 144 (402) - "PARAMETER", // 145 (403) - "OVERRIDE", // 146 (404) - "READY", // 147 (405) - "RESET", // 148 (406) - "RSUB", // 149 (407) - "SERVICE-RELOAD", // 150 (408) - "STAR-CBL", // 151 (409) - "SUBSCRIPT", // 152 (410) - "SUPPRESS", // 153 (411) - "TRACE", // 154 (412) - "USE", // 155 (413) - "COBOL-WORDS", // 156 (414) - "EQUATE", // 157 (415) - "UNDEFINE", // 158 (416) - "CDF-DEFINE", // 159 (417) - "CDF-DISPLAY", // 160 (418) - "CDF-IF", // 161 (419) - "CDF-ELSE", // 162 (420) - "CDF-END-IF", // 163 (421) - "CDF-EVALUATE", // 164 (422) - "CDF-WHEN", // 165 (423) - "CDF-END-EVALUATE", // 166 (424) - "CALL-CONVENTION", // 167 (425) - "CALL-COBOL", // 168 (426) - "CALL-VERBATIM", // 169 (427) - "CDF-PUSH", // 170 (428) - "CDF-POP", // 171 (429) - "SOURCE-FORMAT", // 172 (430) - "IF", // 173 (431) - "THEN", // 174 (432) - "ELSE", // 175 (433) - "SENTENCE", // 176 (434) - "ACCEPT", // 177 (435) - "ADD", // 178 (436) - "ALTER", // 179 (437) - "CALL", // 180 (438) - "CANCEL", // 181 (439) - "CLOSE", // 182 (440) - "COMPUTE", // 183 (441) - "CONTINUE", // 184 (442) - "DELETE", // 185 (443) - "DISPLAY", // 186 (444) - "DIVIDE", // 187 (445) - "EVALUATE", // 188 (446) - "EXIT", // 189 (447) - "FILLER", // 190 (448) - "GOBACK", // 191 (449) - "GOTO", // 192 (450) - "INITIALIZE", // 193 (451) - "INSPECT", // 194 (452) - "MERGE", // 195 (453) - "MOVE", // 196 (454) - "MULTIPLY", // 197 (455) - "OPEN", // 198 (456) - "PARAGRAPH", // 199 (457) - "READ", // 200 (458) - "RELEASE", // 201 (459) - "RETURN", // 202 (460) - "REWRITE", // 203 (461) - "SEARCH", // 204 (462) - "SET", // 205 (463) - "SELECT", // 206 (464) - "SORT", // 207 (465) - "SORT-MERGE", // 208 (466) - "STRING", // 209 (467) - "STOP", // 210 (468) - "SUBTRACT", // 211 (469) - "START", // 212 (470) - "UNSTRING", // 213 (471) - "WRITE", // 214 (472) - "WHEN", // 215 (473) - "ARGUMENT-NUMBER", // 216 (474) - "ARGUMENT-VALUE", // 217 (475) - "ENVIRONMENT-NAME", // 218 (476) - "ENVIRONMENT-VALUE", // 219 (477) - "ABS", // 220 (478) - "ACCESS", // 221 (479) - "ACOS", // 222 (480) - "ACTUAL", // 223 (481) - "ADVANCING", // 224 (482) - "AFTER", // 225 (483) - "ALL", // 226 (484) - "ALLOCATE", // 227 (485) - "ALPHABET", // 228 (486) - "ALPHABETIC", // 229 (487) - "ALPHABETIC-LOWER", // 230 (488) - "ALPHABETIC-UPPER", // 231 (489) - "ALPHANUMERIC", // 232 (490) - "ALPHANUMERIC-EDITED", // 233 (491) - "ALSO", // 234 (492) - "ALTERNATE", // 235 (493) - "ANNUITY", // 236 (494) - "ANUM", // 237 (495) - "ANY", // 238 (496) - "ANYCASE", // 239 (497) - "APPLY", // 240 (498) - "ARE", // 241 (499) - "AREA", // 242 (500) - "AREAS", // 243 (501) - "AS", // 244 (502) - "ASCENDING", // 245 (503) - "ACTIVATING", // 246 (504) - "ASIN", // 247 (505) - "ASSIGN", // 248 (506) - "AT", // 249 (507) - "ATAN", // 250 (508) - "BASED", // 251 (509) - "BASECONVERT", // 252 (510) - "BEFORE", // 253 (511) - "BINARY", // 254 (512) - "BIT", // 255 (513) - "BIT-OF", // 256 (514) - "BIT-TO-CHAR", // 257 (515) - "BLANK", // 258 (516) - "BLOCK", // 259 (517) - "BOOLEAN-OF-INTEGER", // 260 (518) - "BOTTOM", // 261 (519) - "BY", // 262 (520) - "BYTE", // 263 (521) - "BYTE-LENGTH", // 264 (522) - "CF", // 265 (523) - "CH", // 266 (524) - "CHANGED", // 267 (525) - "CHAR", // 268 (526) - "CHAR-NATIONAL", // 269 (527) - "CHARACTER", // 270 (528) - "CHARACTERS", // 271 (529) - "CHECKING", // 272 (530) - "CLASS", // 273 (531) - "COBOL", // 274 (532) - "CODE", // 275 (533) - "CODE-SET", // 276 (534) - "COLLATING", // 277 (535) - "COLUMN", // 278 (536) - "COMBINED-DATETIME", // 279 (537) - "COMMA", // 280 (538) - "COMMAND-LINE", // 281 (539) - "COMMAND-LINE-COUNT", // 282 (540) - "COMMIT", // 283 (541) - "COMMON", // 284 (542) - "CONCAT", // 285 (543) - "CONDITION", // 286 (544) - "CONFIGURATION", // 287 (545) + "PICTURE", // 38 (296) + "NINEDOT", // 39 (297) + "NINES", // 40 (298) + "NINEV", // 41 (299) + "PIC-P", // 42 (300) + "ONES", // 43 (301) + "SPACES", // 44 (302) + "-EQ", // 45 (303) + "LITERAL", // 46 (304) + "END", // 47 (305) + "EOP", // 48 (306) + "-FILENAME", // 49 (307) + "INVALID", // 50 (308) + "NUMBER", // 51 (309) + "NEGATIVE", // 52 (310) + "NUMSTR", // 53 (311) + "OVERFLOW", // 54 (312) + "-BINARY-INTEGER", // 55 (313) + "COMPUTATIONAL", // 56 (314) + "PERFORM", // 57 (315) + "BACKWARD", // 58 (316) + "POSITIVE", // 59 (317) + "POINTER", // 60 (318) + "PROCESS", // 61 (319) + "SECTION", // 62 (320) + "STANDARD-ALPHABET", // 63 (321) + "SWITCH", // 64 (322) + "UPSI", // 65 (323) + "ZERO", // 66 (324) + "SYSIN", // 67 (325) + "SYSIPT", // 68 (326) + "SYSOUT", // 69 (327) + "SYSLIST", // 70 (328) + "SYSLST", // 71 (329) + "SYSPUNCH", // 72 (330) + "SYSPCH", // 73 (331) + "CONSOLE", // 74 (332) + "C01", // 75 (333) + "C02", // 76 (334) + "C03", // 77 (335) + "C04", // 78 (336) + "C05", // 79 (337) + "C06", // 80 (338) + "C07", // 81 (339) + "C08", // 82 (340) + "C09", // 83 (341) + "C10", // 84 (342) + "C11", // 85 (343) + "C12", // 86 (344) + "CSP", // 87 (345) + "S01", // 88 (346) + "S02", // 89 (347) + "S03", // 90 (348) + "S04", // 91 (349) + "S05", // 92 (350) + "AFP-5A", // 93 (351) + "STDIN", // 94 (352) + "STDOUT", // 95 (353) + "STDERR", // 96 (354) + "LIST", // 97 (355) + "MAP", // 98 (356) + "NOLIST", // 99 (357) + "NOMAP", // 100 (358) + "NOSOURCE", // 101 (359) + "MIGHT-BE", // 102 (360) + "FUNCTION-UDF", // 103 (361) + "FUNCTION-UDF-0", // 104 (362) + "DEFAULT", // 105 (363) + "DATE-FMT", // 106 (364) + "TIME-FMT", // 107 (365) + "DATETIME-FMT", // 108 (366) + "FLAG-02", // 109 (367) + "MOVE-TO-SAME-NAME", // 110 (368) + "RANGE-EXCEPTION-FOR-INDEX", // 111 (369) + "TERMINATE-WITH-VARYING", // 112 (370) + "FLAG-14", // 113 (371) + "COMPILE-TIME-ARITHMETIC-EXPRESSIONS", // 114 (372) + "I-O-DECLARATIVE", // 115 (373) + "I-O-STATUS-04", // 116 (374) + "I-O-STATUS-07", // 117 (375) + "NUM-ED-ZERO-FIGCONST", // 118 (376) + "READ-PREVIOUS", // 119 (377) + "REF-MOD-ZERO-LENGTH", // 120 (378) + "VALUE-EDITING", // 121 (379) + "VALUE-FIG-CON-LENGTH", // 122 (380) + "VALUE-ZERO", // 123 (381) + "WRITE-END-OF-PAGE", // 124 (382) + "LEAP-SECOND", // 125 (383) + "LISTING", // 126 (384) + "PROPAGATE", // 127 (385) + "ZERO-LENGTH", // 128 (386) + "B-AND", // 129 (387) + "B-NOT", // 130 (388) + "B-OR", // 131 (389) + "B-SHIFT-L", // 132 (390) + "B-SHIFT-LC", // 133 (391) + "B-SHIFT-R", // 134 (392) + "B-SHIFT-RC", // 135 (393) + "B-XOR", // 136 (394) + "BASIS", // 137 (395) + "CBL", // 138 (396) + "CONSTANT", // 139 (397) + "COPY", // 140 (398) + "DEFINED", // 141 (399) + "ENTER", // 142 (400) + "FEATURE", // 143 (401) + "INSERTT", // 144 (402) + "LSUB", // 145 (403) + "PARAMETER", // 146 (404) + "OVERRIDE", // 147 (405) + "READY", // 148 (406) + "RESET", // 149 (407) + "RSUB", // 150 (408) + "SERVICE-RELOAD", // 151 (409) + "STAR-CBL", // 152 (410) + "SUBSCRIPT", // 153 (411) + "SUPPRESS", // 154 (412) + "TRACE", // 155 (413) + "USE", // 156 (414) + "COBOL-WORDS", // 157 (415) + "EQUATE", // 158 (416) + "UNDEFINE", // 159 (417) + "CDF-DEFINE", // 160 (418) + "CDF-DISPLAY", // 161 (419) + "CDF-IF", // 162 (420) + "CDF-ELSE", // 163 (421) + "CDF-END-IF", // 164 (422) + "CDF-EVALUATE", // 165 (423) + "CDF-WHEN", // 166 (424) + "CDF-END-EVALUATE", // 167 (425) + "CALL-CONVENTION", // 168 (426) + "CALL-COBOL", // 169 (427) + "CALL-VERBATIM", // 170 (428) + "CDF-PUSH", // 171 (429) + "CDF-POP", // 172 (430) + "SOURCE-FORMAT", // 173 (431) + "IF", // 174 (432) + "THEN", // 175 (433) + "ELSE", // 176 (434) + "SENTENCE", // 177 (435) + "ACCEPT", // 178 (436) + "ADD", // 179 (437) + "ALTER", // 180 (438) + "CALL", // 181 (439) + "CANCEL", // 182 (440) + "CLOSE", // 183 (441) + "COMPUTE", // 184 (442) + "CONTINUE", // 185 (443) + "DELETE", // 186 (444) + "DISPLAY", // 187 (445) + "DIVIDE", // 188 (446) + "EVALUATE", // 189 (447) + "EXIT", // 190 (448) + "FILLER", // 191 (449) + "GOBACK", // 192 (450) + "GOTO", // 193 (451) + "INITIALIZE", // 194 (452) + "INSPECT", // 195 (453) + "MERGE", // 196 (454) + "MOVE", // 197 (455) + "MULTIPLY", // 198 (456) + "OPEN", // 199 (457) + "PARAGRAPH", // 200 (458) + "READ", // 201 (459) + "RELEASE", // 202 (460) + "RETURN", // 203 (461) + "REWRITE", // 204 (462) + "SEARCH", // 205 (463) + "SET", // 206 (464) + "SELECT", // 207 (465) + "SORT", // 208 (466) + "SORT-MERGE", // 209 (467) + "STRING", // 210 (468) + "STOP", // 211 (469) + "SUBTRACT", // 212 (470) + "START", // 213 (471) + "UNSTRING", // 214 (472) + "WRITE", // 215 (473) + "WHEN", // 216 (474) + "ARGUMENT-NUMBER", // 217 (475) + "ARGUMENT-VALUE", // 218 (476) + "ENVIRONMENT-NAME", // 219 (477) + "ENVIRONMENT-VALUE", // 220 (478) + "ABS", // 221 (479) + "ACCESS", // 222 (480) + "ACOS", // 223 (481) + "ACTUAL", // 224 (482) + "ADVANCING", // 225 (483) + "AFTER", // 226 (484) + "ALL", // 227 (485) + "ALLOCATE", // 228 (486) + "ALPHABET", // 229 (487) + "ALPHABETIC", // 230 (488) + "ALPHABETIC-LOWER", // 231 (489) + "ALPHABETIC-UPPER", // 232 (490) + "ALPHANUMERIC", // 233 (491) + "ALPHANUMERIC-EDITED", // 234 (492) + "ALSO", // 235 (493) + "ALTERNATE", // 236 (494) + "ANNUITY", // 237 (495) + "ANUM", // 238 (496) + "ANY", // 239 (497) + "ANYCASE", // 240 (498) + "APPLY", // 241 (499) + "ARE", // 242 (500) + "AREA", // 243 (501) + "AREAS", // 244 (502) + "AS", // 245 (503) + "ASCENDING", // 246 (504) + "ACTIVATING", // 247 (505) + "ASIN", // 248 (506) + "ASSIGN", // 249 (507) + "AT", // 250 (508) + "ATAN", // 251 (509) + "BASED", // 252 (510) + "BASECONVERT", // 253 (511) + "BEFORE", // 254 (512) + "BINARY", // 255 (513) + "BIT", // 256 (514) + "BIT-OF", // 257 (515) + "BIT-TO-CHAR", // 258 (516) + "BLANK", // 259 (517) + "BLOCK", // 260 (518) + "BOOLEAN-OF-INTEGER", // 261 (519) + "BOTTOM", // 262 (520) + "BY", // 263 (521) + "BYTE", // 264 (522) + "BYTE-LENGTH", // 265 (523) + "CF", // 266 (524) + "CH", // 267 (525) + "CHANGED", // 268 (526) + "CHAR", // 269 (527) + "CHAR-NATIONAL", // 270 (528) + "CHARACTER", // 271 (529) + "CHARACTERS", // 272 (530) + "CHECKING", // 273 (531) + "CLASS", // 274 (532) + "COBOL", // 275 (533) + "CODE", // 276 (534) + "CODE-SET", // 277 (535) + "COLLATING", // 278 (536) + "COLUMN", // 279 (537) + "COMBINED-DATETIME", // 280 (538) + "COMMA", // 281 (539) + "COMMAND-LINE", // 282 (540) + "COMMAND-LINE-COUNT", // 283 (541) + "COMMIT", // 284 (542) + "COMMON", // 285 (543) + "CONCAT", // 286 (544) + "CONDITION", // 287 (545) "CONFIGURATION", // 288 (546) - "CONTAINS", // 289 (547) - "CONTENT", // 290 (548) - "CONTROL", // 291 (549) - "CONTROLS", // 292 (550) - "CONVERT", // 293 (551) - "CONVERTING", // 294 (552) - "CORRESPONDING", // 295 (553) - "COS", // 296 (554) - "COUNT", // 297 (555) - "CURRENCY", // 298 (556) - "CURRENT", // 299 (557) - "CURRENT-DATE", // 300 (558) - "DATE", // 301 (559) - "DATE-COMPILED", // 302 (560) - "DATE-OF-INTEGER", // 303 (561) - "DATE-TO-YYYYMMDD", // 304 (562) - "DATE-WRITTEN", // 305 (563) - "DAY", // 306 (564) - "DAY-OF-INTEGER", // 307 (565) - "DAY-OF-WEEK", // 308 (566) - "DAY-TO-YYYYDDD", // 309 (567) - "DBCS", // 310 (568) - "DE", // 311 (569) - "DEBUGGING", // 312 (570) - "DECIMAL-POINT", // 313 (571) - "DECLARATIVES", // 314 (572) - "DELIMITED", // 315 (573) - "DELIMITER", // 316 (574) - "DEPENDING", // 317 (575) - "DESCENDING", // 318 (576) - "DETAIL", // 319 (577) - "DIRECT", // 320 (578) - "DIRECT-ACCESS", // 321 (579) - "DIVISION", // 322 (580) - "DOWN", // 323 (581) - "DUPLICATES", // 324 (582) - "DYNAMIC", // 325 (583) - "E", // 326 (584) - "EBCDIC", // 327 (585) - "EC", // 328 (586) - "EGCS", // 329 (587) - "ENCODING", // 330 (588) - "ENTRY", // 331 (589) - "EVERY", // 332 (590) - "EXAMINE", // 333 (591) - "EXHIBIT", // 334 (592) - "EXP", // 335 (593) - "EXP10", // 336 (594) - "EXTEND", // 337 (595) - "EXTERNAL", // 338 (596) - "EXCEPTION-FILE", // 339 (597) - "EXCEPTION-FILE-N", // 340 (598) - "EXCEPTION-LOCATION", // 341 (599) - "EXCEPTION-LOCATION-N", // 342 (600) - "EXCEPTION-STATEMENT", // 343 (601) - "EXCEPTION-STATUS", // 344 (602) - "FACTORIAL", // 345 (603) - "FALSE", // 346 (604) - "FD", // 347 (605) - "FILE-CONTROL", // 348 (606) - "FILE", // 349 (607) - "FILE-LIMIT", // 350 (608) - "FINAL", // 351 (609) - "FINALLY", // 352 (610) - "FIND-STRING", // 353 (611) - "FIRST", // 354 (612) - "FIXED", // 355 (613) - "FOOTING", // 356 (614) - "FOR", // 357 (615) - "FORMATTED-CURRENT-DATE", // 358 (616) - "FORMATTED-DATE", // 359 (617) - "FORMATTED-DATETIME", // 360 (618) - "FORMATTED-TIME", // 361 (619) - "FORM-OVERFLOW", // 362 (620) - "FREE", // 363 (621) - "FRACTION-PART", // 364 (622) - "FROM", // 365 (623) - "FUNCTION", // 366 (624) - "GENERATE", // 367 (625) - "GIVING", // 368 (626) - "GLOBAL", // 369 (627) - "GO", // 370 (628) - "GROUP", // 371 (629) - "HEADING", // 372 (630) - "HEX", // 373 (631) - "HEX-OF", // 374 (632) - "HEX-TO-CHAR", // 375 (633) - "HIGH-VALUES", // 376 (634) - "HIGHEST-ALGEBRAIC", // 377 (635) - "HOLD", // 378 (636) - "IBM-360", // 379 (637) - "IN", // 380 (638) - "INCLUDE", // 381 (639) - "INDEX", // 382 (640) - "INDEXED", // 383 (641) - "INDICATE", // 384 (642) - "INITIAL", // 385 (643) - "INITIATE", // 386 (644) - "INPUT", // 387 (645) - "INSTALLATION", // 388 (646) - "INTERFACE", // 389 (647) - "INTEGER", // 390 (648) - "INTEGER-OF-BOOLEAN", // 391 (649) - "INTEGER-OF-DATE", // 392 (650) - "INTEGER-OF-DAY", // 393 (651) - "INTEGER-OF-FORMATTED-DATE", // 394 (652) - "INTEGER-PART", // 395 (653) - "INTO", // 396 (654) - "INTRINSIC", // 397 (655) - "INVOKE", // 398 (656) - "I-O", // 399 (657) - "I-O-CONTROL", // 400 (658) - "IS", // 401 (659) - "ISNT", // 402 (660) - "KANJI", // 403 (661) - "KEY", // 404 (662) - "LABEL", // 405 (663) - "LAST", // 406 (664) - "LEADING", // 407 (665) - "LEFT", // 408 (666) - "LENGTH", // 409 (667) - "LENGTH-OF", // 410 (668) - "LIMIT", // 411 (669) - "LIMITS", // 412 (670) - "LINE", // 413 (671) - "LINES", // 414 (672) - "LINE-COUNTER", // 415 (673) - "LINAGE", // 416 (674) - "LINKAGE", // 417 (675) - "LOCALE", // 418 (676) - "LOCALE-COMPARE", // 419 (677) - "LOCALE-DATE", // 420 (678) - "LOCALE-TIME", // 421 (679) - "LOCALE-TIME-FROM-SECONDS", // 422 (680) - "LOCAL-STORAGE", // 423 (681) - "LOCATION", // 424 (682) - "LOCK", // 425 (683) - "LOCK-ON", // 426 (684) - "LOG", // 427 (685) - "LOG10", // 428 (686) - "LOWER-CASE", // 429 (687) - "LOW-VALUES", // 430 (688) - "LOWEST-ALGEBRAIC", // 431 (689) - "LPAREN", // 432 (690) - "MANUAL", // 433 (691) - "MAXX", // 434 (692) - "MEAN", // 435 (693) - "MEDIAN", // 436 (694) - "MIDRANGE", // 437 (695) - "MINN", // 438 (696) - "MULTIPLE", // 439 (697) - "MOD", // 440 (698) - "MODE", // 441 (699) - "MODULE-NAME", // 442 (700) - "NAMED", // 443 (701) - "NAMESPACE", // 444 (702) - "NAMESPACE-PREFIX", // 445 (703) - "NAT", // 446 (704) - "NATIONAL", // 447 (705) - "NATIONAL-EDITED", // 448 (706) - "NATIONAL-OF", // 449 (707) - "NATIVE", // 450 (708) - "NESTED", // 451 (709) - "NEXT", // 452 (710) - "NO", // 453 (711) - "NOTE", // 454 (712) - "NULLS", // 455 (713) - "NULLPTR", // 456 (714) - "NUMERIC", // 457 (715) - "NUMERIC-EDITED", // 458 (716) - "NUMVAL", // 459 (717) - "NUMVAL-C", // 460 (718) - "NUMVAL-F", // 461 (719) - "OCCURS", // 462 (720) - "OF", // 463 (721) - "OFF", // 464 (722) - "OMITTED", // 465 (723) - "ON", // 466 (724) - "ONLY", // 467 (725) - "OPTIONAL", // 468 (726) - "OPTIONS", // 469 (727) - "ORD", // 470 (728) - "ORDER", // 471 (729) - "ORD-MAX", // 472 (730) - "ORD-MIN", // 473 (731) - "ORGANIZATION", // 474 (732) - "OTHER", // 475 (733) - "OTHERWISE", // 476 (734) - "OUTPUT", // 477 (735) - "PACKED-DECIMAL", // 478 (736) - "PADDING", // 479 (737) - "PAGE", // 480 (738) - "PAGE-COUNTER", // 481 (739) - "PF", // 482 (740) - "PH", // 483 (741) - "PI", // 484 (742) - "PIC", // 485 (743) - "PICTURE", // 486 (744) + "CONFIGURATION", // 289 (547) + "CONTAINS", // 290 (548) + "CONTENT", // 291 (549) + "CONTROL", // 292 (550) + "CONTROLS", // 293 (551) + "CONVERT", // 294 (552) + "CONVERTING", // 295 (553) + "CORRESPONDING", // 296 (554) + "COS", // 297 (555) + "COUNT", // 298 (556) + "CURRENCY", // 299 (557) + "CURRENT", // 300 (558) + "CURRENT-DATE", // 301 (559) + "DATE", // 302 (560) + "DATE-COMPILED", // 303 (561) + "DATE-OF-INTEGER", // 304 (562) + "DATE-TO-YYYYMMDD", // 305 (563) + "DATE-WRITTEN", // 306 (564) + "DAY", // 307 (565) + "DAY-OF-INTEGER", // 308 (566) + "DAY-OF-WEEK", // 309 (567) + "DAY-TO-YYYYDDD", // 310 (568) + "DBCS", // 311 (569) + "DE", // 312 (570) + "DEBUGGING", // 313 (571) + "DECIMAL-POINT", // 314 (572) + "DECLARATIVES", // 315 (573) + "DELIMITED", // 316 (574) + "DELIMITER", // 317 (575) + "DEPENDING", // 318 (576) + "DESCENDING", // 319 (577) + "DETAIL", // 320 (578) + "DIRECT", // 321 (579) + "DIRECT-ACCESS", // 322 (580) + "DIVISION", // 323 (581) + "DOWN", // 324 (582) + "DUPLICATES", // 325 (583) + "DYNAMIC", // 326 (584) + "E", // 327 (585) + "EBCDIC", // 328 (586) + "EC", // 329 (587) + "EGCS", // 330 (588) + "ENCODING", // 331 (589) + "ENTRY", // 332 (590) + "EVERY", // 333 (591) + "EXAMINE", // 334 (592) + "EXHIBIT", // 335 (593) + "EXP", // 336 (594) + "EXP10", // 337 (595) + "EXTEND", // 338 (596) + "EXTERNAL", // 339 (597) + "EXCEPTION-FILE", // 340 (598) + "EXCEPTION-FILE-N", // 341 (599) + "EXCEPTION-LOCATION", // 342 (600) + "EXCEPTION-LOCATION-N", // 343 (601) + "EXCEPTION-STATEMENT", // 344 (602) + "EXCEPTION-STATUS", // 345 (603) + "FACTORIAL", // 346 (604) + "FALSE", // 347 (605) + "FD", // 348 (606) + "FILE-CONTROL", // 349 (607) + "FILE", // 350 (608) + "FILE-LIMIT", // 351 (609) + "FINAL", // 352 (610) + "FINALLY", // 353 (611) + "FIND-STRING", // 354 (612) + "FIRST", // 355 (613) + "FIXED", // 356 (614) + "FOOTING", // 357 (615) + "FOR", // 358 (616) + "FORMATTED-CURRENT-DATE", // 359 (617) + "FORMATTED-DATE", // 360 (618) + "FORMATTED-DATETIME", // 361 (619) + "FORMATTED-TIME", // 362 (620) + "FORM-OVERFLOW", // 363 (621) + "FREE", // 364 (622) + "FRACTION-PART", // 365 (623) + "FROM", // 366 (624) + "FUNCTION", // 367 (625) + "GENERATE", // 368 (626) + "GIVING", // 369 (627) + "GLOBAL", // 370 (628) + "GO", // 371 (629) + "GROUP", // 372 (630) + "HEADING", // 373 (631) + "HEX", // 374 (632) + "HEX-OF", // 375 (633) + "HEX-TO-CHAR", // 376 (634) + "HIGH-VALUES", // 377 (635) + "HIGHEST-ALGEBRAIC", // 378 (636) + "HOLD", // 379 (637) + "IBM-360", // 380 (638) + "IN", // 381 (639) + "INCLUDE", // 382 (640) + "INDEX", // 383 (641) + "INDEXED", // 384 (642) + "INDICATE", // 385 (643) + "INITIAL", // 386 (644) + "INITIATE", // 387 (645) + "INPUT", // 388 (646) + "INSTALLATION", // 389 (647) + "INTERFACE", // 390 (648) + "INTEGER", // 391 (649) + "INTEGER-OF-BOOLEAN", // 392 (650) + "INTEGER-OF-DATE", // 393 (651) + "INTEGER-OF-DAY", // 394 (652) + "INTEGER-OF-FORMATTED-DATE", // 395 (653) + "INTEGER-PART", // 396 (654) + "INTO", // 397 (655) + "INTRINSIC", // 398 (656) + "INVOKE", // 399 (657) + "I-O", // 400 (658) + "I-O-CONTROL", // 401 (659) + "IS", // 402 (660) + "ISNT", // 403 (661) + "KANJI", // 404 (662) + "KEY", // 405 (663) + "LABEL", // 406 (664) + "LAST", // 407 (665) + "LEADING", // 408 (666) + "LEFT", // 409 (667) + "LENGTH", // 410 (668) + "LENGTH-OF", // 411 (669) + "LIMIT", // 412 (670) + "LIMITS", // 413 (671) + "LINE", // 414 (672) + "LINES", // 415 (673) + "LINE-COUNTER", // 416 (674) + "LINAGE", // 417 (675) + "LINKAGE", // 418 (676) + "LOCALE", // 419 (677) + "LOCALE-COMPARE", // 420 (678) + "LOCALE-DATE", // 421 (679) + "LOCALE-TIME", // 422 (680) + "LOCALE-TIME-FROM-SECONDS", // 423 (681) + "LOCAL-STORAGE", // 424 (682) + "LOCATION", // 425 (683) + "LOCK", // 426 (684) + "LOCK-ON", // 427 (685) + "LOG", // 428 (686) + "LOG10", // 429 (687) + "LOWER-CASE", // 430 (688) + "LOW-VALUES", // 431 (689) + "LOWEST-ALGEBRAIC", // 432 (690) + "LPAREN", // 433 (691) + "MANUAL", // 434 (692) + "MAXX", // 435 (693) + "MEAN", // 436 (694) + "MEDIAN", // 437 (695) + "MIDRANGE", // 438 (696) + "MINN", // 439 (697) + "MULTIPLE", // 440 (698) + "MOD", // 441 (699) + "MODE", // 442 (700) + "MODULE-NAME", // 443 (701) + "NAMED", // 444 (702) + "NAMESPACE", // 445 (703) + "NAMESPACE-PREFIX", // 446 (704) + "NAT", // 447 (705) + "NATIONAL", // 448 (706) + "NATIONAL-EDITED", // 449 (707) + "NATIONAL-OF", // 450 (708) + "NATIVE", // 451 (709) + "NESTED", // 452 (710) + "NEXT", // 453 (711) + "NO", // 454 (712) + "NOTE", // 455 (713) + "NULLS", // 456 (714) + "NULLPTR", // 457 (715) + "NUMERIC", // 458 (716) + "NUMERIC-EDITED", // 459 (717) + "NUMVAL", // 460 (718) + "NUMVAL-C", // 461 (719) + "NUMVAL-F", // 462 (720) + "OCCURS", // 463 (721) + "OF", // 464 (722) + "OFF", // 465 (723) + "OMITTED", // 466 (724) + "ON", // 467 (725) + "ONLY", // 468 (726) + "OPTIONAL", // 469 (727) + "OPTIONS", // 470 (728) + "ORD", // 471 (729) + "ORDER", // 472 (730) + "ORD-MAX", // 473 (731) + "ORD-MIN", // 474 (732) + "ORGANIZATION", // 475 (733) + "OTHER", // 476 (734) + "OTHERWISE", // 477 (735) + "OUTPUT", // 478 (736) + "PACKED-DECIMAL", // 479 (737) + "PADDING", // 480 (738) + "PAGE", // 481 (739) + "PAGE-COUNTER", // 482 (740) + "PF", // 483 (741) + "PH", // 484 (742) + "PI", // 485 (743) + "PIC", // 486 (744) "PLUS", // 487 (745) "PRESENT-VALUE", // 488 (746) "PRINT-SWITCH", // 489 (747) diff --git a/gcc/cobol/util.cc b/gcc/cobol/util.cc index 3085b01bec70..44fb1f794fea 100644 --- a/gcc/cobol/util.cc +++ b/gcc/cobol/util.cc @@ -537,15 +537,19 @@ determine_intermediate_type( const cbl_refer_t& aref, static char regexmsg[80]; static int -named_constant( const cbl_name_t name ) { +named_constant( const cbl_name_t name, cbl_field_type_t *type_out ) { int output = -1; auto e = symbol_field( current_program_index(), 0, name ); if( e && e->type == SymField ) { auto f = cbl_field_of(e); - if( f->has_attr(constant_e) && is_numeric(f->type) ) { - auto result = f->data.int64_of(); - if( result.second) output = result.first; + if( is_numeric(f->type) ) { + if( f->has_attr(constant_e) && is_numeric(f->type) ) { + auto result = f->data.int64_of(); + if( result.second) output = result.first; + } + } else { + *type_out = f->type; } } return output; @@ -558,35 +562,67 @@ named_constant( const cbl_name_t name ) { */ extern cbl_loc_t yylloc; -std::pair -repeat_count(const char picture[]) +std::pair +repeat_count(const cbl_loc_t& loc, const char picture[]) { char ch; - int count = 0, pos = -1; + long count = 0; + int pos = -1; - int n = sscanf(picture, "%c(%d)%n", &ch, &count, &pos); + int n = sscanf(picture, "%c(%ld)%n", &ch, &count, &pos); if( n == 2 ) { - if( count < 0 ) { - error_msg(yylloc, "not a positive integer constant: %d", count); + if( count == 0 ) { + error_msg(loc, "%<(0)%> invalid in PICTURE (ISO 2023 13.18.40.3)"); + } else if( count < 0 ) { + error_msg(loc, "not a positive integer constant: %ld", count); + } else { + uint32_t n = count; + if( n != count ) { + error_msg(loc, "count exceeds 4 GB: %ld", count); + } } } else { cbl_name_t name; + cbl_field_type_t type = FldInvalid; n = sscanf(picture, "%c(%s)%n", &ch, name, &pos); + if( n == 2 ) { - if( (count = named_constant(name)) < 0 ) { - error_msg(yylloc, "not a positive integer constant: %qs: %d", name, count); + auto ename = name + sizeof(name); + auto p = std::find(name, ename, ')'); + if( p < ename ) *p = '\0'; + if( (count = named_constant(name, &type)) <= 0 ) { + if( is_numeric(type) ) { + if( count == 0 ) { + error_msg(loc, "%qs is 0, invalid in PICTURE (ISO 2023 13.18.40.3)", name); + } else { + error_msg(loc, "not a positive integer constant: %qs: %ld", name, count); + } + } else { + error_msg(loc, "not an integer constant: %qs", name); + } + } else { + uint32_t n = count; + if( n != count ) { + error_msg(loc, "count exceeds 4 GB: %qs: %ld", name, count); + } } } } if( n == 2 && 0 <= count ) { - return {count, pos}; + return {count, pos}; } return {0, -1}; } +std::pair +repeat_count(const char picture[]) +{ + return repeat_count(yylloc, picture); +} + const char *numed_message; extern int yydebug, yy_flex_debug; @@ -1963,7 +1999,6 @@ cbl_field_t::encode_numeric( const char input[], cbl_loc_t loc ) { } size_t parse_error_inc(); -size_t parse_error_count(); bool // true if error reported cbl_field_t::report_invalid_initial_value(const cbl_loc_t& loc) const { diff --git a/gcc/cobol/util.h b/gcc/cobol/util.h index 2cf91dcd2b27..b99533944376 100644 --- a/gcc/cobol/util.h +++ b/gcc/cobol/util.h @@ -45,8 +45,6 @@ void cobol_filename_restore(); const char * cobol_lineno( int ); int cobol_lineno(void); -std::pair repeat_count(const char picture[]); - unsigned long gb4( size_t input ); template diff --git a/gcc/config/avr/avr.opt.urls b/gcc/config/avr/avr.opt.urls index e0c725e8d1a8..a7d2d295f89e 100644 --- a/gcc/config/avr/avr.opt.urls +++ b/gcc/config/avr/avr.opt.urls @@ -112,7 +112,7 @@ mfuse-move2 UrlSuffix(gcc/AVR-Options.html#index-mfuse-move2) moptimize -UrlSuffix(gcc/AVR-Options.html#index-moptimize-1) +UrlSuffix(gcc/AVR-Options.html#index-moptimize) mabsdata UrlSuffix(gcc/AVR-Options.html#index-mabsdata) diff --git a/gcc/config/nvptx/nvptx.opt.urls b/gcc/config/nvptx/nvptx.opt.urls index 931b329204fd..ced5d34eaeb7 100644 --- a/gcc/config/nvptx/nvptx.opt.urls +++ b/gcc/config/nvptx/nvptx.opt.urls @@ -7,7 +7,7 @@ mmainkernel UrlSuffix(gcc/Nvidia-PTX-Options.html#index-mmainkernel) moptimize -UrlSuffix(gcc/Nvidia-PTX-Options.html#index-moptimize) +UrlSuffix(gcc/Nvidia-PTX-Options.html#index-moptimize-1) msoft-stack UrlSuffix(gcc/Nvidia-PTX-Options.html#index-msoft-stack) From 0a62dec05b82023d60b4e5f34476ead95b6ba4f0 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 17 Sep 2026 22:08:44 +0200 Subject: [PATCH 459/584] cobol: Update tests to reflect new functions and messages. gcc/testsuite/ChangeLog: * cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.out: Do not use /tmp. * cobol.dg/group2/ACCEPT_foo_FROM_COMMAND-LINE_1_.cob: Removed. --- .../group2/ACCEPT_foo_FROM_COMMAND-LINE_1_.cob | 13 ------------- .../group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.out | 2 +- 2 files changed, 1 insertion(+), 14 deletions(-) delete mode 100644 gcc/testsuite/cobol.dg/group2/ACCEPT_foo_FROM_COMMAND-LINE_1_.cob diff --git a/gcc/testsuite/cobol.dg/group2/ACCEPT_foo_FROM_COMMAND-LINE_1_.cob b/gcc/testsuite/cobol.dg/group2/ACCEPT_foo_FROM_COMMAND-LINE_1_.cob deleted file mode 100644 index 08eaf636e6ec..000000000000 --- a/gcc/testsuite/cobol.dg/group2/ACCEPT_foo_FROM_COMMAND-LINE_1_.cob +++ /dev/null @@ -1,13 +0,0 @@ - *> Do not edit this generated file. See README.txt - *> { dg-do run } - - ID DIVISION. - PROGRAM-ID. prog. - DATA DIVISION. - WORKING-STORAGE SECTION. - 01 var1 PIC X100. - PROCEDURE DIVISION. - ACCEPT var1 FROM COMMAND-LINE(1). - DISPLAY var1. - GOBACK. - diff --git a/gcc/testsuite/cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.out b/gcc/testsuite/cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.out index 861e65a2826a..3618adb6b0d0 100644 --- a/gcc/testsuite/cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.out +++ b/gcc/testsuite/cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.out @@ -1,4 +1,4 @@ -#EUR 12.34# equal #1,234 ct (EUR)# +#EUR 01.23# equal #1,234 ct (EUR)# Invoice amount #1 is $US1,500.00. Invoice amount #2 is $US12.34. From 56efa4a739786bb1c1c6dcdab0ad81cb1c55b970 Mon Sep 17 00:00:00 2001 From: Samarth Tandale Date: Sun, 27 Sep 2026 09:34:59 -0600 Subject: [PATCH 460/584] [PATCH v1] match.pd: Fold (a != 0) | (popcount(a) == n) and related patterns [PR112094] Fold (a != 0) | (popcount(a) == n) into (a != 0) | (n == 0), and (a == 0) & (popcount(a) != n) into (a == 0) & (n != 0). This follows from x == 0 => popcount(x) == 0: when a == 0 the popcount comparison reduces to a comparison against zero, and when a != 0 the outer OR/AND already determines the result. PR tree-optimization/112094 gcc/ChangeLog: * match.pd: Add fold for (a != 0) | (popcount(a) == n) and (a == 0) & (popcount(a) != n). gcc/testsuite/ChangeLog: * gcc.dg/fold-popcount-12.c: New test. * gcc.dg/fold-popcount-13.c: New test. Signed-off-by: Samarth Tandale --- gcc/match.pd | 13 +++ gcc/testsuite/gcc.dg/fold-popcount-12.c | 149 ++++++++++++++++++++++++ gcc/testsuite/gcc.dg/fold-popcount-13.c | 33 ++++++ 3 files changed, 195 insertions(+) create mode 100644 gcc/testsuite/gcc.dg/fold-popcount-12.c create mode 100644 gcc/testsuite/gcc.dg/fold-popcount-13.c diff --git a/gcc/match.pd b/gcc/match.pd index 305c672e78c2..c70a8e6d6d27 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -11508,6 +11508,19 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) (cmp (popcount @0) integer_zerop) (rep @0 { build_zero_cst (TREE_TYPE (@0)); })))) +/* (a != 0) | (popcount (a) == n) -> (a != 0) | (n == 0) + (a == 0) & (popcount (a) != n) -> (a == 0) & (n != 0) */ +(for popcount (POPCOUNT) + (for bop (bit_ior bit_and) + popcmp (eq ne) + zerocmp (ne eq) + (simplify + (bop:c (zerocmp@2 @0 integer_zerop) + (popcmp:cs (popcount (convert?@3 @0)) @1)) + (if (INTEGRAL_TYPE_P (TREE_TYPE (@0)) + && INTEGRAL_TYPE_P (TREE_TYPE (@3))) + (bop @2 (popcmp @1 { build_zero_cst (TREE_TYPE (@1)); })))))) + /* popcount(bswap(x)) is popcount(x). */ (for popcount (POPCOUNT) (for bswap (BSWAP BITREVERSE) diff --git a/gcc/testsuite/gcc.dg/fold-popcount-12.c b/gcc/testsuite/gcc.dg/fold-popcount-12.c new file mode 100644 index 000000000000..3f6666e228c6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/fold-popcount-12.c @@ -0,0 +1,149 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-optimized" } */ +/* PR tree-optimization/112094 */ +/* Test that + (a != 0) | (popcount(a) == n) -> (a != 0) | (n == 0) + (a == 0) & (popcount(a) != n) -> (a == 0) & (n != 0) + and their commuted forms are folded away. */ + +/* OR cases. */ +int f (unsigned int a, int n) +{ + int t = __builtin_popcount (a); + return (a != 0) | (t == n); +} + +int fl (unsigned long a, int n) +{ + int t = __builtin_popcountl (a); + return (a != 0) | (t == n); +} + +int fll (unsigned long long a, int n) +{ + int t = __builtin_popcountll (a); + return (a != 0) | (t == n); +} + +/* Signed-to-unsigned conversions inserted for popcount. */ +int f_signed (int a, int n) +{ + int t = __builtin_popcount (a); + return (a != 0) | (t == n); +} + +int fl_signed (long a, int n) +{ + int t = __builtin_popcountl (a); + return (a != 0) | (t == n); +} + +int fll_signed (long long a, int n) +{ + int t = __builtin_popcountll (a); + return (a != 0) | (t == n); +} + +/* Integral conversions: promotion, widening, and narrowing. */ +int f_promoted (short a, int n) +{ + int t = __builtin_popcount (a); + return (a != 0) | (t == n); +} + +int f_widened (int a, int n) +{ + int t = __builtin_popcountll (a); + return (a != 0) | (t == n); +} + +int f_narrowed (long long a, int n) +{ + int t = __builtin_popcount (a); + return (a != 0) | (t == n); +} + +/* Commuted operator and comparison operands. */ +int f_comm (unsigned int a, int n) +{ + int t = __builtin_popcount (a); + return (t == n) | (a != 0); +} + +int f_comm2 (unsigned int a, int n) +{ + int t = __builtin_popcount (a); + return (a != 0) | (n == t); +} + +int f_comm3 (unsigned int a, int n) +{ + int t = __builtin_popcount (a); + return (0 != a) | (t == n); +} + +/* AND cases. */ +int g (unsigned int a, int n) +{ + int t = __builtin_popcount (a); + return (a == 0) & (t != n); +} + +int gl (unsigned long a, int n) +{ + int t = __builtin_popcountl (a); + return (a == 0) & (t != n); +} + +int gll (unsigned long long a, int n) +{ + int t = __builtin_popcountll (a); + return (a == 0) & (t != n); +} + +/* Signed-to-unsigned conversions inserted for popcount. */ +int g_signed (int a, int n) +{ + int t = __builtin_popcount (a); + return (a == 0) & (t != n); +} + +/* Integral conversions: promotion, widening, and narrowing. */ +int g_promoted (short a, int n) +{ + int t = __builtin_popcount (a); + return (a == 0) & (t != n); +} + +int g_widened (int a, int n) +{ + int t = __builtin_popcountll (a); + return (a == 0) & (t != n); +} + +int g_narrowed (long long a, int n) +{ + int t = __builtin_popcount (a); + return (a == 0) & (t != n); +} + +/* Commuted operator and comparison operands. */ +int g_comm (unsigned int a, int n) +{ + int t = __builtin_popcount (a); + return (t != n) & (a == 0); +} + +int g_comm2 (unsigned int a, int n) +{ + int t = __builtin_popcount (a); + return (a == 0) & (n != t); +} + +int g_comm3 (unsigned int a, int n) +{ + int t = __builtin_popcount (a); + return (0 == a) & (t != n); +} + +/* { dg-final { scan-tree-dump-not "popcount" "optimized" } } */ diff --git a/gcc/testsuite/gcc.dg/fold-popcount-13.c b/gcc/testsuite/gcc.dg/fold-popcount-13.c new file mode 100644 index 000000000000..4b6e32a83c54 --- /dev/null +++ b/gcc/testsuite/gcc.dg/fold-popcount-13.c @@ -0,0 +1,33 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-optimized" } */ +/* PR tree-optimization/112094 */ +/* Verify that popcount comparisons are preserved when they cannot be + safely simplified. */ + +/* The comparison result is used twice. */ +int f_multiuse (unsigned int a, int n, int *out) +{ + int c = __builtin_popcount (a) == n; + *out = c; + return (a != 0) | c; +} + +extern int get_value (void); +volatile unsigned int value; + +/* Both calls to get_value are observable and must be preserved. */ +int f_side_effect (int n) +{ + return (get_value () != 0) + | (__builtin_popcount (get_value ()) == n); +} + +/* Both volatile reads are observable and must be preserved. */ +int f_volatile (int n) +{ + return (value != 0) + | (__builtin_popcount (value) == n); +} + +/* One popcount remains for each negative case. */ +/* { dg-final { scan-tree-dump-times "popcount" 3 "optimized" } } */ From b257b8f4524d8e61040c6d988ebf3e68d784c1a7 Mon Sep 17 00:00:00 2001 From: Iain Sandoe Date: Sun, 27 Sep 2026 17:10:53 +0100 Subject: [PATCH 461/584] Darwin: Improve robustness of select_section. In select_section we need to determine if a CONSTRUCTOR initialises an Objective-C/CoreFoundation string which we do by inspecting the typename. It is possible for a typename to be passed, even if perhaps in error, with a NULL_TREE id and we should deal with that gracefully. gcc/ChangeLog: * config/darwin.cc (machopic_select_section): Do not try to inspect a typename which has no id. Signed-off-by: Iain Sandoe --- gcc/config/darwin.cc | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/gcc/config/darwin.cc b/gcc/config/darwin.cc index ba934c264022..7e822a9a8528 100644 --- a/gcc/config/darwin.cc +++ b/gcc/config/darwin.cc @@ -1839,6 +1839,11 @@ machopic_select_section (tree decl, if (TREE_CODE (name) == TYPE_DECL) name = DECL_NAME (name); + /* If the type name ID absent, this cannot be an Objective-C or Core + Foundation string. */ + if (!name) + return base_section; + if (!strcmp (IDENTIFIER_POINTER (name), "__builtin_ObjCString")) { if (flag_next_runtime) From 3618718c9b512ac21592d8fabc665a5dbcdeab84 Mon Sep 17 00:00:00 2001 From: Iain Sandoe Date: Sun, 27 Sep 2026 17:14:39 +0100 Subject: [PATCH 462/584] testsuite, Darwin: Handle missing MAP_ANONYMOUS in vect test. This is a similar remedy to several othe cases, some versions of the Darwin SDK do not alias MAP_ANON to MAP_ANONYMOUS, so provide that in the test. gcc/testsuite/ChangeLog: * gcc.dg/vect/vect-pr127601.c: If MAP_ANONYMOUS is not defined for Darwin, alias it to MAP_ANON. Signed-off-by: Iain Sandoe --- gcc/testsuite/gcc.dg/vect/vect-pr127601.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/gcc/testsuite/gcc.dg/vect/vect-pr127601.c b/gcc/testsuite/gcc.dg/vect/vect-pr127601.c index bcad4232a887..fbb19bb07968 100644 --- a/gcc/testsuite/gcc.dg/vect/vect-pr127601.c +++ b/gcc/testsuite/gcc.dg/vect/vect-pr127601.c @@ -1,6 +1,9 @@ /* { dg-require-effective-target mmap } */ #include +#if defined(__APPLE__) && !defined(MAP_ANONYMOUS) +#define MAP_ANONYMOUS MAP_ANON +#endif #include "tree-vect.h" #define PG 4096 From 8b93d6bf0706bdf7f5116c79a051eb31f0fbab22 Mon Sep 17 00:00:00 2001 From: Steven Sudit Date: Sat, 26 Sep 2026 13:49:21 -0400 Subject: [PATCH 463/584] c++: Don't re-base a folded string builtin on an offset argument [PR127218] Since r10-5927 (PR c++/80265) cxx_eval_builtin_function_call replaces the string arguments of the str/mem builtins with the address of a STRING_CST before folding, and for the pointer-returning ones (memchr, strchr, strrchr, strstr) it afterwards puts the original argument back as the base of the folded POINTER_PLUS_EXPR. That re-basing is unconditional, but the replacement only happens when the evaluated argument is a bare ADDR_EXPR (offset 0). When the argument already carries an offset, for instance memchr (a + 1, c, n), the argument is passed to fold as-is, fold_builtin_call_array merges the offset into the result (a + 10), and the re-basing then rewrites that result to (a + 1) + 10, counting the offset twice. constexpr const char a[] = "abcdefghijabxdefghijaaa"; static_assert (__builtin_memchr (a + 1, 'a', 22) == a + 10, ""); fails since GCC 10 in every dialect; &a[1] is unaffected because the evaluated argument is an ADDR_EXPR. C++26 exposes this to ordinary code: P2738 makes void* -> T* casts constant expressions, so the front end now folds char_traits::find on constant haystacks and std::string_view::find (c, pos) returns pos too much. Fix by clearing STRRET when the argument it refers to didn't end up as the address of a STRING_CST, so the folded result is re-based only when the replacement happened; otherwise it is already relative to the evaluated argument. Assisted-by: Claude Fable 5.1 (Anthropic) PR c++/127218 gcc/cp/ChangeLog: * constexpr.cc (cxx_eval_builtin_function_call): Clear STRRET when the argument it refers to is not replaced by the address of a STRING_CST, so the folded result is re-based on the original argument only when that replacement happened. gcc/testsuite/ChangeLog: * g++.dg/cpp0x/constexpr-memchr2.C: New test. Signed-off-by: Steven Sudit --- gcc/cp/constexpr.cc | 8 +++++ .../g++.dg/cpp0x/constexpr-memchr2.C | 30 +++++++++++++++++++ 2 files changed, 38 insertions(+) create mode 100644 gcc/testsuite/g++.dg/cpp0x/constexpr-memchr2.C diff --git a/gcc/cp/constexpr.cc b/gcc/cp/constexpr.cc index e1b64880a883..31ef5bf1111a 100644 --- a/gcc/cp/constexpr.cc +++ b/gcc/cp/constexpr.cc @@ -3077,6 +3077,14 @@ cxx_eval_builtin_function_call (const constexpr_ctx *ctx, tree t, tree fun, arg = oarg; } + /* If the argument STRRET refers to didn't end up as the address of a + STRING_CST, the folded result is already relative to it and must not + be re-based on the original argument below. */ + if (i == strret - 1 + && (TREE_CODE (arg) != ADDR_EXPR + || TREE_CODE (TREE_OPERAND (arg, 0)) != STRING_CST)) + strret = 0; + args[i] = arg; } if (bos) diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-memchr2.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-memchr2.C new file mode 100644 index 000000000000..9f5704631382 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-memchr2.C @@ -0,0 +1,30 @@ +// PR c++/127218 +// { dg-do compile { target c++11 } } +// The pointer-returning string builtins must not count a nonzero offset in +// their first argument twice when the front end folds them. + +constexpr const char a[] = "abcdefghijabxdefghijaaa"; +static_assert (__builtin_memchr (a, 'x', sizeof (a) - 1) == a + 12, ""); +static_assert (__builtin_memchr (a + 1, 'a', sizeof (a) - 2) == a + 10, ""); +static_assert (__builtin_memchr (a + 2, 'a', sizeof (a) - 3) == a + 10, ""); +static_assert (__builtin_memchr (a + 1, 'x', sizeof (a) - 2) == a + 12, ""); +static_assert (__builtin_memchr (a + 1, 'q', sizeof (a) - 2) == nullptr, ""); +static_assert (__builtin_memchr (&a[1], 'a', sizeof (a) - 2) == a + 10, ""); +static_assert (__builtin_strchr (a + 1, 'a') == a + 10, ""); +static_assert (__builtin_strchr (a + 1, '\0') == a + 23, ""); +static_assert (__builtin_strrchr (a + 1, 'b') == a + 11, ""); +static_assert (__builtin_strrchr (a + 3, 'a') == a + 22, ""); +static_assert (__builtin_strstr (a + 1, "ab") == a + 10, ""); +static_assert (__builtin_strstr (a + 1, "") == a + 1, ""); +static_assert (__builtin_strstr (a + 1, "zz") == nullptr, ""); +static_assert (__builtin_strlen (a + 1) == 22, ""); + +constexpr const void *f1 (const char *p, int q, unsigned long n) +{ return __builtin_memchr (p, q, n); } +constexpr const char *f2 (const char *p, int q) { return __builtin_strchr (p, q); } +constexpr const char *f3 (const char *p, int q) { return __builtin_strrchr (p, q); } +constexpr const char *f4 (const char *p, const char *q) { return __builtin_strstr (p, q); } +static_assert (f1 (a + 1, 'a', sizeof (a) - 2) == a + 10, ""); +static_assert (f2 (a + 1, 'a') == a + 10, ""); +static_assert (f3 (a + 1, 'b') == a + 11, ""); +static_assert (f4 (a + 1, "ab") == a + 10, ""); From 19378ecd3851564bb168dd7779cb52c79193cb2d Mon Sep 17 00:00:00 2001 From: wangjue Date: Sun, 27 Sep 2026 11:34:07 -0600 Subject: [PATCH 464/584] [PATCH v2] vect: Look through promotions for SAT_TRUNC Use a single-use unpromoted input when MAX_EXPR and SAT_TRUNC are supported for the narrower type, avoiding a redundant widen-and-narrow sequence. The test cases were generated by an LLM. Assisted-by: GPT-6 Regtested on rv64gcv, rv32gcv, x86_64 and aarch64 with no regressions. Changes since v1: v2: Update the test cases for the upstream canonicalization changes. v1: Add vect_sat_trunc_clip_input_vectype to check target support. Use the appropriate gimple_build_assign overload for MAX_EXPR. gcc/ChangeLog: * tree-vect-patterns.cc (vect_sat_trunc_clip_input_vectype): New. (vect_recog_sat_trunc_pattern): Look through promotions and check target support for MAX_EXPR. gcc/testsuite/ChangeLog: * gcc.target/riscv/rvv/autovec/pr120378-3.c: Disable the vector cost model. * gcc.target/riscv/rvv/autovec/pr120378-4.c: Likewise. * gcc.target/riscv/rvv/autovec/sat-trunc-promote-1.c: New test. * gcc.target/riscv/rvv/autovec/sat-trunc-promote-run-1.c: New test. --- .../gcc.target/riscv/rvv/autovec/pr120378-3.c | 2 +- .../gcc.target/riscv/rvv/autovec/pr120378-4.c | 2 +- .../riscv/rvv/autovec/sat-trunc-promote-1.c | 17 ++++ .../rvv/autovec/sat-trunc-promote-run-1.c | 33 ++++++++ gcc/tree-vect-patterns.cc | 83 +++++++++++++++---- 5 files changed, 119 insertions(+), 18 deletions(-) create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/sat-trunc-promote-1.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/sat-trunc-promote-run-1.c diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr120378-3.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr120378-3.c index 5941b3b75436..c06f1423140f 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr120378-3.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr120378-3.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fdump-tree-optimized" } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-vect-cost-model -fdump-tree-optimized" } */ #include diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr120378-4.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr120378-4.c index 57cca4504ba2..bc9a55e8b07c 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr120378-4.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr120378-4.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fdump-tree-optimized" } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -fno-vect-cost-model -fdump-tree-optimized" } */ #include diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/sat-trunc-promote-1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/sat-trunc-promote-1.c new file mode 100644 index 000000000000..298a76461a4f --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/sat-trunc-promote-1.c @@ -0,0 +1,17 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -mrvv-max-lmul=m1 -fno-vect-cost-model -fdump-tree-optimized" } */ + +#include + +__attribute__ ((noipa)) void +clip_scale_u8 (uint8_t *__restrict dst, const int8_t *__restrict src, int n) +{ + for (int i = 0; i < n; ++i) + { + int x = src[i] * 3; + dst[i] = (unsigned) x > 255u ? (int) (-(unsigned) x) >> 31 : x; + } +} + +/* { dg-final { scan-tree-dump-times {\.SAT_TRUNC } 1 "optimized" } } */ +/* { dg-final { scan-assembler-times {\tvnclipu\.wi} 1 } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/sat-trunc-promote-run-1.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/sat-trunc-promote-run-1.c new file mode 100644 index 000000000000..04a7c09f07ec --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/sat-trunc-promote-run-1.c @@ -0,0 +1,33 @@ +/* { dg-do run { target { riscv_v && rv64 } } } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -mrvv-max-lmul=m1 -fno-vect-cost-model" } */ + +#include "sat-trunc-promote-1.c" + +#define N 256 + +int +main (void) +{ + int8_t input[N]; + uint8_t output[N]; + + for (int i = 0; i < N; ++i) + input[i] = i + INT8_MIN; + + /* Exercise every input value, empty loops and partial vectors. */ + for (int n = 0; n <= N; ++n) + { + clip_scale_u8 (output, input, n); + +#pragma GCC novector + for (int i = 0; i < n; ++i) + { + int x = input[i] * 3; + uint8_t expected = x < 0 ? 0 : x > UINT8_MAX ? UINT8_MAX : x; + if (output[i] != expected) + __builtin_abort (); + } + } + + return 0; +} diff --git a/gcc/tree-vect-patterns.cc b/gcc/tree-vect-patterns.cc index 5fcc37f053c7..06159fa6ab8f 100644 --- a/gcc/tree-vect-patterns.cc +++ b/gcc/tree-vect-patterns.cc @@ -4864,6 +4864,24 @@ vect_recog_sat_sub_pattern (vec_info *vinfo, stmt_vec_info stmt_vinfo, return NULL; } +/* Return the vector type for ITYPE if the target supports the MAX_EXPR + and SAT_TRUNC sequence. */ + +static tree +vect_sat_trunc_clip_input_vectype (vec_info *vinfo, tree v_otype, + tree itype) +{ + tree v_itype; + if (!vect_supportable_direct_optab_p + (vinfo, itype, MAX_EXPR, itype, &v_itype) + || !direct_internal_fn_supported_p + (IFN_SAT_TRUNC, tree_pair (v_otype, v_itype), + OPTIMIZE_FOR_BOTH)) + return NULL_TREE; + + return v_itype; +} + /* * Try to detect saturation truncation pattern (SAT_TRUNC), aka below gimple: * overflow_5 = x_4(D) > 4294967295; @@ -4892,31 +4910,64 @@ vect_recog_sat_trunc_pattern (vec_info *vinfo, stmt_vec_info stmt_vinfo, if ((gimple_unsigned_integer_narrow_clip (lhs, ops, NULL)) && type_has_mode_precision_p (otype)) { - tree itype = TREE_TYPE (ops[0]); - tree v_itype = get_vectype_for_scalar_type (vinfo, itype); + tree input = ops[0]; + tree itype = TREE_TYPE (input); tree v_otype = get_vectype_for_scalar_type (vinfo, otype); internal_fn fn = IFN_SAT_TRUNC; + tree v_itype = NULL_TREE; - if (v_itype != NULL_TREE && v_otype != NULL_TREE - && direct_internal_fn_supported_p (fn, tree_pair (v_otype, v_itype), - OPTIMIZE_FOR_BOTH)) + if (v_otype != NULL_TREE) { - tree temp = vect_recog_temp_ssa_var (itype, NULL); - gimple * max_stmt = gimple_build_assign (temp, build2 (MAX_EXPR, itype, build_zero_cst(itype), ops[0])); - append_pattern_def_seq (vinfo, stmt_vinfo, max_stmt, v_itype); + /* Avoid widening an input only to narrow it again. A signed + promotion does not affect MAX (X, 0), so use the unpromoted + value when the target can narrow it directly to the output + type. */ + vect_unpromoted_value unprom; + bool single_use_p = true; + if (vect_look_through_possible_promotion (vinfo, input, &unprom, + &single_use_p) + && single_use_p + && INTEGRAL_TYPE_P (unprom.type) + && TYPE_SIGN (unprom.type) == TYPE_SIGN (itype) + && type_has_mode_precision_p (unprom.type) + && TYPE_PRECISION (otype) < TYPE_PRECISION (unprom.type) + && TYPE_PRECISION (unprom.type) < TYPE_PRECISION (itype)) + { + tree v_unprom_type + = vect_sat_trunc_clip_input_vectype (vinfo, v_otype, + unprom.type); + if (v_unprom_type != NULL_TREE) + { + input = unprom.op; + itype = unprom.type; + v_itype = v_unprom_type; + } + } - gcall *call = gimple_build_call_internal (fn, 1, temp); - tree out_ssa = vect_recog_temp_ssa_var (otype, NULL); + if (v_itype == NULL_TREE) + v_itype + = vect_sat_trunc_clip_input_vectype (vinfo, v_otype, itype); - gimple_call_set_lhs (call, out_ssa); - gimple_call_set_nothrow (call, /* nothrow_p */ false); - gimple_set_location (call, gimple_location (last_stmt)); + if (v_itype != NULL_TREE) + { + tree temp = vect_recog_temp_ssa_var (itype, NULL); + gimple *max_stmt + = gimple_build_assign (temp, MAX_EXPR, + build_zero_cst (itype), input); + append_pattern_def_seq (vinfo, stmt_vinfo, max_stmt, v_itype); - *type_out = v_otype; + gcall *call = gimple_build_call_internal (fn, 1, temp); + tree out_ssa = vect_recog_temp_ssa_var (otype, NULL); - return call; - } + gimple_call_set_lhs (call, out_ssa); + gimple_call_set_nothrow (call, false); + gimple_set_location (call, gimple_location (last_stmt)); + *type_out = v_otype; + + return call; + } + } } if ((gimple_unsigned_integer_sat_trunc (lhs, ops, NULL) From 56805976a1cb252253118e8da40873857d6b0c9f Mon Sep 17 00:00:00 2001 From: Jeff Law Date: Sun, 27 Sep 2026 11:35:55 -0600 Subject: [PATCH 465/584] [RISC-V] Fix typo and minor bugs in recently added bclr test As Andreas noted, the bclr test got goof'd up. I vaguely recall adjusting the submitted test, probably an attempt to make it work on both rv32 and rv64. I must have goof'd that. Test also needs c99 mode, so in addition to fixing the typo, this fixes that oversight. Pushed to the trunk after testing on riscv32-elf and riscv64-elf. gcc/testsuite * gcc.target/riscv/bclr-lowest-set-bit-2.c: Fix typos and force c99 mode. --- gcc/testsuite/gcc.target/riscv/bclr-lowest-set-bit-2.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/gcc/testsuite/gcc.target/riscv/bclr-lowest-set-bit-2.c b/gcc/testsuite/gcc.target/riscv/bclr-lowest-set-bit-2.c index e40fd6c10f78..9b7ff5c928e9 100644 --- a/gcc/testsuite/gcc.target/riscv/bclr-lowest-set-bit-2.c +++ b/gcc/testsuite/gcc.target/riscv/bclr-lowest-set-bit-2.c @@ -1,6 +1,6 @@ /* { dg-do run } */ -/* { dg-additional options "-march=rv64gc_zbb_zbs -mabi=lp64d" { target rv64 } } */ -/* { dg-additional options "-march=rv32gc_zbb_zbs -mabi=ilp32" { target rv32 } } */ +/* { dg-additional-options "-std=c99 -march=rv64gc_zbb_zbs -mabi=lp64d" { target rv64 } } */ +/* { dg-additional-options "-std=c99 -march=rv32gc_zbb_zbs -mabi=ilp32" { target rv32 } } */ /* If bclr drops the sign extension, this loop never terminates. */ From 373b5459e80ff0fa61b9f0284e0ac6142caca67d Mon Sep 17 00:00:00 2001 From: Iain Sandoe Date: Sat, 26 Sep 2026 12:21:50 +0100 Subject: [PATCH 466/584] testsuite, x86: Specify expected generic tuning on more tests. There are tests that fail when platforms are configured with non-default CPU/tune. This is typically because they are doing scanasm/body scan operations that look for specific code-gen seen for 'generic' tuning. This adds -mtune=generic where required. gcc/testsuite/ChangeLog: * gcc.target/i386/avx512bw-vmovdqu16-1.c: Specify generic tuning. * gcc.target/i386/avx512fp16-13.c: Likewise. * gcc.target/i386/avx512vl-stv-rotatedi-1.c: Likewise. * gcc.target/i386/movbe-5.c: Likewise. * gcc.target/i386/pieces-memset-11.c: Likewise. * gcc.target/i386/pieces-memset-14.c: Likewise. * gcc.target/i386/pieces-memset-2.c: Likewise. * gcc.target/i386/pieces-memset-20.c: Likewise. * gcc.target/i386/pieces-memset-23.c: Likewise. * gcc.target/i386/pieces-memset-29.c: Likewise. * gcc.target/i386/pieces-memset-30.c: Likewise. * gcc.target/i386/pieces-memset-33.c: Likewise. * gcc.target/i386/pieces-memset-34.c: Likewise. * gcc.target/i386/pieces-memset-37.c: Likewise. * gcc.target/i386/pieces-memset-44.c: Likewise. * gcc.target/i386/pieces-memset-5.c: Likewise. * gcc.target/i386/pr107548-1.c: Likewise. * gcc.target/i386/pr107548-2.c: Likewise. * gcc.target/i386/pr108938-3.c: Likewise. * gcc.target/i386/pr124697-3b.c: Likewise. * gcc.target/i386/pr53533-1.c: Likewise. * gcc.target/i386/pr53533-3.c: Likewise. * gcc.target/i386/pr95483-5.c: Likewise. * gcc.target/i386/pr95483-6.c: Likewise. * gcc.target/i386/sse2-stv-9.c: Likewise. * gcc.target/i386/sse4_1-stv-11.c: Likewise. * gcc.target/i386/sse4_1-stv-12.c: Likewise. Signed-off-by: Iain Sandoe --- gcc/testsuite/gcc.target/i386/avx512bw-vmovdqu16-1.c | 2 +- gcc/testsuite/gcc.target/i386/avx512fp16-13.c | 2 +- gcc/testsuite/gcc.target/i386/avx512vl-stv-rotatedi-1.c | 2 +- gcc/testsuite/gcc.target/i386/movbe-5.c | 2 +- gcc/testsuite/gcc.target/i386/pieces-memset-11.c | 2 +- gcc/testsuite/gcc.target/i386/pieces-memset-14.c | 2 +- gcc/testsuite/gcc.target/i386/pieces-memset-2.c | 2 +- gcc/testsuite/gcc.target/i386/pieces-memset-20.c | 2 +- gcc/testsuite/gcc.target/i386/pieces-memset-23.c | 2 +- gcc/testsuite/gcc.target/i386/pieces-memset-29.c | 2 +- gcc/testsuite/gcc.target/i386/pieces-memset-30.c | 2 +- gcc/testsuite/gcc.target/i386/pieces-memset-33.c | 2 +- gcc/testsuite/gcc.target/i386/pieces-memset-34.c | 2 +- gcc/testsuite/gcc.target/i386/pieces-memset-37.c | 2 +- gcc/testsuite/gcc.target/i386/pieces-memset-44.c | 2 +- gcc/testsuite/gcc.target/i386/pieces-memset-5.c | 2 +- gcc/testsuite/gcc.target/i386/pr107548-1.c | 2 +- gcc/testsuite/gcc.target/i386/pr107548-2.c | 2 +- gcc/testsuite/gcc.target/i386/pr108938-3.c | 2 +- gcc/testsuite/gcc.target/i386/pr124697-3b.c | 2 +- gcc/testsuite/gcc.target/i386/pr53533-1.c | 2 +- gcc/testsuite/gcc.target/i386/pr53533-3.c | 2 +- gcc/testsuite/gcc.target/i386/pr95483-5.c | 2 +- gcc/testsuite/gcc.target/i386/pr95483-6.c | 2 +- gcc/testsuite/gcc.target/i386/sse2-stv-9.c | 2 +- gcc/testsuite/gcc.target/i386/sse4_1-stv-11.c | 2 +- gcc/testsuite/gcc.target/i386/sse4_1-stv-12.c | 2 +- 27 files changed, 27 insertions(+), 27 deletions(-) diff --git a/gcc/testsuite/gcc.target/i386/avx512bw-vmovdqu16-1.c b/gcc/testsuite/gcc.target/i386/avx512bw-vmovdqu16-1.c index ee8e5cfc81ad..d89034266f1d 100644 --- a/gcc/testsuite/gcc.target/i386/avx512bw-vmovdqu16-1.c +++ b/gcc/testsuite/gcc.target/i386/avx512bw-vmovdqu16-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-mavx512bw -mavx512vl -O2" } */ +/* { dg-options "-mavx512bw -mavx512vl -O2 -mtune=generic" } */ /* { dg-final { scan-assembler-times "vmovdqu16\[ \\t\]+\[^\{\n\]*%zmm\[0-9\]+\[^\n\]*%zmm\[0-9\]+\{%k\[1-7\]\}(?:\n|\[ \\t\]+#)" 1 } } */ /* { dg-final { scan-assembler-times "vmovdqu16\[ \\t\]+\[^\{\n\]*%ymm\[0-9\]+\[^\n\]*%ymm\[0-9\]+\{%k\[1-7\]\}(?:\n|\[ \\t\]+#)" 1 } } */ /* { dg-final { scan-assembler-times "vmovdqu16\[ \\t\]+\[^\{\n\]*%xmm\[0-9\]+\[^\n\]*%xmm\[0-9\]+\{%k\[1-7\]\}(?:\n|\[ \\t\]+#)" 1 } } */ diff --git a/gcc/testsuite/gcc.target/i386/avx512fp16-13.c b/gcc/testsuite/gcc.target/i386/avx512fp16-13.c index 8bd0e39b0567..927d3d7b70c6 100644 --- a/gcc/testsuite/gcc.target/i386/avx512fp16-13.c +++ b/gcc/testsuite/gcc.target/i386/avx512fp16-13.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -mavx512fp16 -mavx512vl" } */ +/* { dg-options "-O2 -mavx512fp16 -mavx512vl -mtune=generic" } */ #include void diff --git a/gcc/testsuite/gcc.target/i386/avx512vl-stv-rotatedi-1.c b/gcc/testsuite/gcc.target/i386/avx512vl-stv-rotatedi-1.c index d3b85a1efe28..a7368bd31b95 100644 --- a/gcc/testsuite/gcc.target/i386/avx512vl-stv-rotatedi-1.c +++ b/gcc/testsuite/gcc.target/i386/avx512vl-stv-rotatedi-1.c @@ -1,5 +1,5 @@ /* { dg-do compile { target ia32 } } */ -/* { dg-options "-O2 -mavx512vl -mstv -mno-stackrealign" } */ +/* { dg-options "-O2 -mavx512vl -mstv -mno-stackrealign -mtune=generic" } */ unsigned long long rot1(unsigned long long x) { return (x>>1) | (x<<63); } unsigned long long rot2(unsigned long long x) { return (x>>2) | (x<<62); } diff --git a/gcc/testsuite/gcc.target/i386/movbe-5.c b/gcc/testsuite/gcc.target/i386/movbe-5.c index b1ab1215268c..7fbf13fa1867 100644 --- a/gcc/testsuite/gcc.target/i386/movbe-5.c +++ b/gcc/testsuite/gcc.target/i386/movbe-5.c @@ -1,6 +1,6 @@ /* PR tree-optimization/78821 */ /* { dg-do compile } */ -/* { dg-options "-O2 -mmovbe" } */ +/* { dg-options "-O2 -mmovbe -mtune=generic" } */ unsigned short foo (unsigned short *buf) diff --git a/gcc/testsuite/gcc.target/i386/pieces-memset-11.c b/gcc/testsuite/gcc.target/i386/pieces-memset-11.c index fbf76d06b1d0..6c5964a54b21 100644 --- a/gcc/testsuite/gcc.target/i386/pieces-memset-11.c +++ b/gcc/testsuite/gcc.target/i386/pieces-memset-11.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -mno-avx2 -mavx -mtune-ctrl=avx256_move_by_pieces" } */ +/* { dg-options "-O2 -mno-avx2 -mavx -mtune-ctrl=avx256_move_by_pieces -mtune=generic" } */ extern char *dst; diff --git a/gcc/testsuite/gcc.target/i386/pieces-memset-14.c b/gcc/testsuite/gcc.target/i386/pieces-memset-14.c index cb940f6710c3..14c0fe251168 100644 --- a/gcc/testsuite/gcc.target/i386/pieces-memset-14.c +++ b/gcc/testsuite/gcc.target/i386/pieces-memset-14.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -mno-avx2 -mavx -mtune-ctrl=avx256_move_by_pieces" } */ +/* { dg-options "-O2 -mno-avx2 -mavx -mtune-ctrl=avx256_move_by_pieces -mtune=generic" } */ extern char *dst; diff --git a/gcc/testsuite/gcc.target/i386/pieces-memset-2.c b/gcc/testsuite/gcc.target/i386/pieces-memset-2.c index 53498f9f4aa1..d5fa59661507 100644 --- a/gcc/testsuite/gcc.target/i386/pieces-memset-2.c +++ b/gcc/testsuite/gcc.target/i386/pieces-memset-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -mno-avx2 -mavx -mtune-ctrl=avx256_move_by_pieces" } */ +/* { dg-options "-O2 -mno-avx2 -mavx -mtune-ctrl=avx256_move_by_pieces -mtune=generic" } */ extern char *dst; diff --git a/gcc/testsuite/gcc.target/i386/pieces-memset-20.c b/gcc/testsuite/gcc.target/i386/pieces-memset-20.c index 09c9defa0172..1fa7f25df884 100644 --- a/gcc/testsuite/gcc.target/i386/pieces-memset-20.c +++ b/gcc/testsuite/gcc.target/i386/pieces-memset-20.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -mno-avx2 -mavx -mtune-ctrl=avx256_move_by_pieces" } */ +/* { dg-options "-O2 -mno-avx2 -mavx -mtune-ctrl=avx256_move_by_pieces -mtune=generic" } */ extern char *dst; diff --git a/gcc/testsuite/gcc.target/i386/pieces-memset-23.c b/gcc/testsuite/gcc.target/i386/pieces-memset-23.c index f692ff00b38e..16999905129f 100644 --- a/gcc/testsuite/gcc.target/i386/pieces-memset-23.c +++ b/gcc/testsuite/gcc.target/i386/pieces-memset-23.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -mno-avx2 -mavx -mtune-ctrl=avx256_move_by_pieces" } */ +/* { dg-options "-O2 -mno-avx2 -mavx -mtune-ctrl=avx256_move_by_pieces -mtune=generic" } */ extern char *dst; diff --git a/gcc/testsuite/gcc.target/i386/pieces-memset-29.c b/gcc/testsuite/gcc.target/i386/pieces-memset-29.c index 8499907b4164..9555aedd8a28 100644 --- a/gcc/testsuite/gcc.target/i386/pieces-memset-29.c +++ b/gcc/testsuite/gcc.target/i386/pieces-memset-29.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -mno-avx2 -mavx -mtune-ctrl=avx256_move_by_pieces" } */ +/* { dg-options "-O2 -mno-avx2 -mavx -mtune-ctrl=avx256_move_by_pieces -mtune=generic" } */ extern char *dst; diff --git a/gcc/testsuite/gcc.target/i386/pieces-memset-30.c b/gcc/testsuite/gcc.target/i386/pieces-memset-30.c index c9c4459894ea..1ec744876dac 100644 --- a/gcc/testsuite/gcc.target/i386/pieces-memset-30.c +++ b/gcc/testsuite/gcc.target/i386/pieces-memset-30.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -mno-avx512f -mavx2 -mtune-ctrl=avx256_move_by_pieces" } */ +/* { dg-options "-O2 -mno-avx512f -mavx2 -mtune-ctrl=avx256_move_by_pieces -mtune=generic" } */ extern char *dst; diff --git a/gcc/testsuite/gcc.target/i386/pieces-memset-33.c b/gcc/testsuite/gcc.target/i386/pieces-memset-33.c index b88988f50f5d..57eea948f3b7 100644 --- a/gcc/testsuite/gcc.target/i386/pieces-memset-33.c +++ b/gcc/testsuite/gcc.target/i386/pieces-memset-33.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -mno-avx2 -mavx -mtune-ctrl=avx256_move_by_pieces" } */ +/* { dg-options "-O2 -mno-avx2 -mavx -mtune-ctrl=avx256_move_by_pieces -mtune=generic" } */ extern char *dst; diff --git a/gcc/testsuite/gcc.target/i386/pieces-memset-34.c b/gcc/testsuite/gcc.target/i386/pieces-memset-34.c index b6a6c3dd1634..61fe33175ce3 100644 --- a/gcc/testsuite/gcc.target/i386/pieces-memset-34.c +++ b/gcc/testsuite/gcc.target/i386/pieces-memset-34.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -mno-avx512f -mavx2 -mtune-ctrl=avx256_move_by_pieces" } */ +/* { dg-options "-O2 -mno-avx512f -mavx2 -mtune-ctrl=avx256_move_by_pieces -mtune=generic" } */ extern char *dst; diff --git a/gcc/testsuite/gcc.target/i386/pieces-memset-37.c b/gcc/testsuite/gcc.target/i386/pieces-memset-37.c index 7b9845f9ef4e..c56b02a09e8c 100644 --- a/gcc/testsuite/gcc.target/i386/pieces-memset-37.c +++ b/gcc/testsuite/gcc.target/i386/pieces-memset-37.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -mno-avx512f -mavx2 -mtune-ctrl=avx256_move_by_pieces" } */ +/* { dg-options "-O2 -mno-avx512f -mavx2 -mtune-ctrl=avx256_move_by_pieces -mtune=generic" } */ void foo (int a1, int a2, int a3, int a4, int a5, int a6, int x, char *dst) diff --git a/gcc/testsuite/gcc.target/i386/pieces-memset-44.c b/gcc/testsuite/gcc.target/i386/pieces-memset-44.c index 94552bed9dcf..9fde2e278b0f 100644 --- a/gcc/testsuite/gcc.target/i386/pieces-memset-44.c +++ b/gcc/testsuite/gcc.target/i386/pieces-memset-44.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -mno-avx2 -mavx -mtune-ctrl=avx256_move_by_pieces" } */ +/* { dg-options "-O2 -mno-avx2 -mavx -mtune-ctrl=avx256_move_by_pieces -mtune=generic" } */ extern char *dst; diff --git a/gcc/testsuite/gcc.target/i386/pieces-memset-5.c b/gcc/testsuite/gcc.target/i386/pieces-memset-5.c index 7fc824c3c56c..806cbc44d613 100644 --- a/gcc/testsuite/gcc.target/i386/pieces-memset-5.c +++ b/gcc/testsuite/gcc.target/i386/pieces-memset-5.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -mno-avx2 -mavx -mtune-ctrl=avx256_move_by_pieces" } */ +/* { dg-options "-O2 -mno-avx2 -mavx -mtune-ctrl=avx256_move_by_pieces -mtune=generic" } */ extern char *dst; diff --git a/gcc/testsuite/gcc.target/i386/pr107548-1.c b/gcc/testsuite/gcc.target/i386/pr107548-1.c index f384492231fc..430b897f46bb 100644 --- a/gcc/testsuite/gcc.target/i386/pr107548-1.c +++ b/gcc/testsuite/gcc.target/i386/pr107548-1.c @@ -1,5 +1,5 @@ /* { dg-do compile { target { ! ia32 } } } */ -/* { dg-options "-O2 -mstv -mno-stackrealign" } */ +/* { dg-options "-O2 -mstv -mno-stackrealign -mtune=generic" } */ typedef unsigned int v4si __attribute__((vector_size(16))); unsigned int foo1 (v4si a, v4si b) diff --git a/gcc/testsuite/gcc.target/i386/pr107548-2.c b/gcc/testsuite/gcc.target/i386/pr107548-2.c index 58f7b1c12a95..16ce5a11f086 100644 --- a/gcc/testsuite/gcc.target/i386/pr107548-2.c +++ b/gcc/testsuite/gcc.target/i386/pr107548-2.c @@ -1,5 +1,5 @@ /* { dg-do compile { target { ! ia32 } } } */ -/* { dg-options "-O2 -mstv -mno-stackrealign" } */ +/* { dg-options "-O2 -mstv -mno-stackrealign -mtune=generic" } */ typedef unsigned long long v2di __attribute__((vector_size(16))); unsigned long long foo(v2di a, v2di b) diff --git a/gcc/testsuite/gcc.target/i386/pr108938-3.c b/gcc/testsuite/gcc.target/i386/pr108938-3.c index cd87314e57f6..c9ab92ad7f89 100644 --- a/gcc/testsuite/gcc.target/i386/pr108938-3.c +++ b/gcc/testsuite/gcc.target/i386/pr108938-3.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -ftree-vectorize -mno-movbe -msse2 -mno-avx" } */ +/* { dg-options "-O2 -ftree-vectorize -mno-movbe -msse2 -mno-avx -mtune=generic" } */ /* { dg-final { scan-assembler-times "bswap\[\t ]+" 3 } } */ void diff --git a/gcc/testsuite/gcc.target/i386/pr124697-3b.c b/gcc/testsuite/gcc.target/i386/pr124697-3b.c index 31d52f83ad5e..ec505ee25aad 100644 --- a/gcc/testsuite/gcc.target/i386/pr124697-3b.c +++ b/gcc/testsuite/gcc.target/i386/pr124697-3b.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -mavx512f" } */ +/* { dg-options "-O2 -mavx512f -mtune=generic" } */ /* { dg-final { scan-assembler-times "vmovupd.*, %zmm0" 1 } } */ /* { dg-final { scan-assembler "and\[lq\]?\[\\t \]*\\$-64,\[\\t \]*%\[re\]?sp" } } */ /* { dg-final { scan-assembler-not "vmovapd.*, %zmm0" } } */ diff --git a/gcc/testsuite/gcc.target/i386/pr53533-1.c b/gcc/testsuite/gcc.target/i386/pr53533-1.c index 11d12015145b..01e650d78c0f 100644 --- a/gcc/testsuite/gcc.target/i386/pr53533-1.c +++ b/gcc/testsuite/gcc.target/i386/pr53533-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O1" } */ +/* { dg-options "-O1 -mtune=generic" } */ /* { dg-final { scan-assembler-times "imull\[ \t\]" "1" } } */ /* { dg-final { scan-assembler-times "subl\[ \t\]" "1" } } */ /* { dg-final { scan-assembler-times "add(?:l|q)\[ \t\]" "1" } } */ diff --git a/gcc/testsuite/gcc.target/i386/pr53533-3.c b/gcc/testsuite/gcc.target/i386/pr53533-3.c index 347fa828eb76..9afc4823b2f2 100644 --- a/gcc/testsuite/gcc.target/i386/pr53533-3.c +++ b/gcc/testsuite/gcc.target/i386/pr53533-3.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O1 -fwrapv" } */ +/* { dg-options "-O1 -fwrapv -mtune=generic" } */ /* { dg-final { scan-assembler-times "imull\[ \t\]" "1" } } */ /* { dg-final { scan-assembler-times "subl\[ \t\]" "1" } } */ /* { dg-final { scan-assembler-times "add(?:l|q)\[ \t\]" "1" } } */ diff --git a/gcc/testsuite/gcc.target/i386/pr95483-5.c b/gcc/testsuite/gcc.target/i386/pr95483-5.c index a21ad01b15d2..2b247bf37131 100644 --- a/gcc/testsuite/gcc.target/i386/pr95483-5.c +++ b/gcc/testsuite/gcc.target/i386/pr95483-5.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-mavx512bw -mavx512vl -O2" } */ +/* { dg-options "-mavx512bw -mavx512vl -O2 -mtune=generic" } */ /* { dg-final { scan-assembler-times "(?:vmovdqu|vinserti128)\[ \\t\]+\[^\{\n\]*\\)\[^\n\]*%ymm\[0-9\]+(?:\n|\[ \\t\]+#)" 1 } } */ /* { dg-final { scan-assembler-times "(?:vmovdqu|vextracti128)\[ \\t\]+\[^\{\n\]*%ymm\[0-9\]+\[^\n\]*\\)(?:\n|\[ \\t\]+#)" 1 } } */ diff --git a/gcc/testsuite/gcc.target/i386/pr95483-6.c b/gcc/testsuite/gcc.target/i386/pr95483-6.c index 3540bf8218e4..d8aa5972cae5 100644 --- a/gcc/testsuite/gcc.target/i386/pr95483-6.c +++ b/gcc/testsuite/gcc.target/i386/pr95483-6.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-mavx512vl -O2" } */ +/* { dg-options "-mavx512vl -O2 -mtune=generic" } */ /* { dg-final { scan-assembler-times "(?:vinserti128|vmovdqu)\[ \\t\]+\[^\{\n\]*\\)\[^\n\]*%ymm\[0-9\]+(?:\n|\[ \\t\]+#)" 2 } } */ #include diff --git a/gcc/testsuite/gcc.target/i386/sse2-stv-9.c b/gcc/testsuite/gcc.target/i386/sse2-stv-9.c index 002ad761b081..8e35985494a1 100644 --- a/gcc/testsuite/gcc.target/i386/sse2-stv-9.c +++ b/gcc/testsuite/gcc.target/i386/sse2-stv-9.c @@ -1,5 +1,5 @@ /* { dg-do compile { target int128 } } */ -/* { dg-options "-O2 -msse2 -mno-sse4 -mno-stackrealign" } */ +/* { dg-options "-O2 -msse2 -mno-sse4 -mno-stackrealign -mtune=generic" } */ extern __int128 a, b, c, z; diff --git a/gcc/testsuite/gcc.target/i386/sse4_1-stv-11.c b/gcc/testsuite/gcc.target/i386/sse4_1-stv-11.c index 8dcde5f8d5d5..731ea6931b22 100644 --- a/gcc/testsuite/gcc.target/i386/sse4_1-stv-11.c +++ b/gcc/testsuite/gcc.target/i386/sse4_1-stv-11.c @@ -1,5 +1,5 @@ /* { dg-do compile { target int128 } } */ -/* { dg-options "-O2 -msse4.1 -mstv -mno-stackrealign" } */ +/* { dg-options "-O2 -msse4.1 -mstv -mno-stackrealign -mtune=generic" } */ __int128 m0,m1,m2,m3; void foo(unsigned long x) diff --git a/gcc/testsuite/gcc.target/i386/sse4_1-stv-12.c b/gcc/testsuite/gcc.target/i386/sse4_1-stv-12.c index 8e96d68c15a7..94f9298724c1 100644 --- a/gcc/testsuite/gcc.target/i386/sse4_1-stv-12.c +++ b/gcc/testsuite/gcc.target/i386/sse4_1-stv-12.c @@ -1,5 +1,5 @@ /* { dg-do compile { target int128 } } */ -/* { dg-options "-O2 -msse4.1 -mstv -mno-stackrealign" } */ +/* { dg-options "-O2 -msse4.1 -mstv -mno-stackrealign -mtune=generic" } */ __int128 m0,m1,m2,m3; void foo(unsigned int x) From b4bfaf0346042c4b8eecee17882c3908d1521659 Mon Sep 17 00:00:00 2001 From: Iain Sandoe Date: Sat, 26 Sep 2026 12:50:44 +0100 Subject: [PATCH 467/584] testsuite, x86: Allow for cascadelake in vector tests. These tests assume that 512b vectors will be selected and do scans accordingly. However, for cascadelake tuning the preference will be for 256b. It would be possible to solve this by selecting generic tuning - but, in this case, it is sufficient to prefer 512b vectors. gcc/testsuite/ChangeLog: * gcc.dg/vect/pr109011-1.c: Prefer 512b vectors. * gcc.dg/vect/pr109011-2.c: Likewise. * gcc.dg/vect/pr109011-3.c: Likewise. * gcc.dg/vect/pr109011-4.c: Likewise. * gcc.dg/vect/pr109011-5.c: Likewise. * gcc.target/i386/avx512f-ceil-sfix-vec-2.c: Likewise. * gcc.target/i386/avx512f-ceil-vec-2.c: Likewise. * gcc.target/i386/avx512f-ceilf-sfix-vec-2.c: Likewise. * gcc.target/i386/avx512f-ceilf-vec-2.c: Likewise. * gcc.target/i386/avx512f-floor-sfix-vec-2.c: Likewise. * gcc.target/i386/avx512f-floor-vec-2.c: Likewise. * gcc.target/i386/avx512f-floorf-sfix-vec-2.c: Likewise. * gcc.target/i386/avx512f-floorf-vec-2.c: Likewise. * gcc.target/i386/avx512f-pr95060.c: Likewise. * gcc.target/i386/avx512f-rint-sfix-vec-2.c: Likewise. * gcc.target/i386/avx512f-rintf-sfix-vec-2.c: Likewise. * gcc.target/i386/avx512f-round-sfix-vec-2.c: Likewise. * gcc.target/i386/avx512f-roundf-sfix-vec-2.c: Likewise. * gcc.target/i386/avx512f-trunc-vec-2.c: Likewise. * gcc.target/i386/avx512f-truncf-vec-2.c: Likewise. * gcc.target/i386/avx512f-vpternlogd-3.c: Likewise. * gcc.target/i386/avx512f-vpternlogd-4.c: Likewise. * gcc.target/i386/mask-pack.c: Likewise. * gcc.target/i386/mask-unpack.c: Likewise. * gcc.target/i386/pr80846-1.c: Likewise. Signed-off-by: Iain Sandoe --- gcc/testsuite/gcc.dg/vect/pr109011-1.c | 1 + gcc/testsuite/gcc.dg/vect/pr109011-2.c | 1 + gcc/testsuite/gcc.dg/vect/pr109011-3.c | 1 + gcc/testsuite/gcc.dg/vect/pr109011-4.c | 1 + gcc/testsuite/gcc.dg/vect/pr109011-5.c | 1 + gcc/testsuite/gcc.target/i386/avx512f-ceil-sfix-vec-2.c | 2 +- gcc/testsuite/gcc.target/i386/avx512f-ceil-vec-2.c | 2 +- gcc/testsuite/gcc.target/i386/avx512f-ceilf-sfix-vec-2.c | 2 +- gcc/testsuite/gcc.target/i386/avx512f-ceilf-vec-2.c | 2 +- gcc/testsuite/gcc.target/i386/avx512f-floor-sfix-vec-2.c | 2 +- gcc/testsuite/gcc.target/i386/avx512f-floor-vec-2.c | 2 +- gcc/testsuite/gcc.target/i386/avx512f-floorf-sfix-vec-2.c | 2 +- gcc/testsuite/gcc.target/i386/avx512f-floorf-vec-2.c | 2 +- gcc/testsuite/gcc.target/i386/avx512f-pr95060.c | 2 +- gcc/testsuite/gcc.target/i386/avx512f-rint-sfix-vec-2.c | 2 +- gcc/testsuite/gcc.target/i386/avx512f-rintf-sfix-vec-2.c | 2 +- gcc/testsuite/gcc.target/i386/avx512f-round-sfix-vec-2.c | 2 +- gcc/testsuite/gcc.target/i386/avx512f-roundf-sfix-vec-2.c | 2 +- gcc/testsuite/gcc.target/i386/avx512f-trunc-vec-2.c | 2 +- gcc/testsuite/gcc.target/i386/avx512f-truncf-vec-2.c | 2 +- gcc/testsuite/gcc.target/i386/avx512f-vpternlogd-3.c | 2 +- gcc/testsuite/gcc.target/i386/avx512f-vpternlogd-4.c | 2 +- gcc/testsuite/gcc.target/i386/mask-pack.c | 2 +- gcc/testsuite/gcc.target/i386/mask-unpack.c | 2 +- gcc/testsuite/gcc.target/i386/pr80846-1.c | 2 +- 25 files changed, 25 insertions(+), 20 deletions(-) diff --git a/gcc/testsuite/gcc.dg/vect/pr109011-1.c b/gcc/testsuite/gcc.dg/vect/pr109011-1.c index bba364bb122c..3ebc87ce936d 100644 --- a/gcc/testsuite/gcc.dg/vect/pr109011-1.c +++ b/gcc/testsuite/gcc.dg/vect/pr109011-1.c @@ -1,6 +1,7 @@ /* PR tree-optimization/109011 */ /* { dg-do compile } */ /* { dg-additional-options "-O3 -fno-unroll-loops --param=vect-epilogues-nomask=0 -fdump-tree-optimized" } */ +/* { dg-additional-options "-mprefer-vector-width=512" { target { i?86-*-* x86_64-*-* } } } */ /* { dg-additional-options "-mavx512cd" { target { { i?86-*-* x86_64-*-* } && avx512cd } } } */ /* { dg-additional-options "-mavx512vpopcntdq" { target { { i?86-*-* x86_64-*-* } && avx512vpopcntdq } } } */ /* { dg-additional-options "-mdejagnu-cpu=power8" { target { powerpc_vsx && { ! has_arch_pwr8 } } } } */ diff --git a/gcc/testsuite/gcc.dg/vect/pr109011-2.c b/gcc/testsuite/gcc.dg/vect/pr109011-2.c index dc62d01da5d9..e44a46bda4c0 100644 --- a/gcc/testsuite/gcc.dg/vect/pr109011-2.c +++ b/gcc/testsuite/gcc.dg/vect/pr109011-2.c @@ -1,6 +1,7 @@ /* PR tree-optimization/109011 */ /* { dg-do compile } */ /* { dg-additional-options "-O3 -fno-unroll-loops --param=vect-epilogues-nomask=0 -fdump-tree-optimized" } */ +/* { dg-additional-options "-mprefer-vector-width=512" { target { i?86-*-* x86_64-*-* } } } */ /* { dg-additional-options "-mavx512cd -mbmi -mlzcnt -mno-avx512vpopcntdq" { target { { { { i?86-*-* x86_64-*-* } && avx512cd } && lzcnt } && bmi } } } */ /* { dg-additional-options "-mdejagnu-cpu=power9" { target { powerpc_vsx && { ! has_arch_pwr9 } } } } */ /* { dg-additional-options "-march=z13 -mzarch" { target s390_vx } } */ diff --git a/gcc/testsuite/gcc.dg/vect/pr109011-3.c b/gcc/testsuite/gcc.dg/vect/pr109011-3.c index 7b2829520496..bc09af7240c6 100644 --- a/gcc/testsuite/gcc.dg/vect/pr109011-3.c +++ b/gcc/testsuite/gcc.dg/vect/pr109011-3.c @@ -1,6 +1,7 @@ /* PR tree-optimization/109011 */ /* { dg-do compile } */ /* { dg-additional-options "-O3 -fno-unroll-loops --param=vect-epilogues-nomask=0 -fdump-tree-optimized" } */ +/* { dg-additional-options "-mprefer-vector-width=512" { target { i?86-*-* x86_64-*-* } } } */ /* { dg-additional-options "-mno-avx512cd -mbmi -mlzcnt -mavx512vpopcntdq" { target { { { { i?86-*-* x86_64-*-* } && avx512vpopcntdq } && lzcnt } && bmi } } } */ /* { dg-additional-options "-mdejagnu-cpu=power8" { target powerpc_vsx } } */ diff --git a/gcc/testsuite/gcc.dg/vect/pr109011-4.c b/gcc/testsuite/gcc.dg/vect/pr109011-4.c index 8440ec73080a..5f87323d541c 100644 --- a/gcc/testsuite/gcc.dg/vect/pr109011-4.c +++ b/gcc/testsuite/gcc.dg/vect/pr109011-4.c @@ -1,6 +1,7 @@ /* PR tree-optimization/109011 */ /* { dg-do compile } */ /* { dg-additional-options "-O3 -fno-unroll-loops --param=vect-epilogues-nomask=0 -fdump-tree-optimized" } */ +/* { dg-additional-options "-mprefer-vector-width=512" { target { i?86-*-* x86_64-*-* } } } */ /* { dg-additional-options "-mavx512cd -mbmi -mlzcnt -mno-avx512vpopcntdq" { target { { { { i?86-*-* x86_64-*-* } && avx512cd } && lzcnt } && bmi } } } */ /* { dg-additional-options "-mdejagnu-cpu=power9" { target { powerpc_vsx && { ! has_arch_pwr9 } } } } */ /* { dg-additional-options "-march=z13 -mzarch" { target s390_vx } } */ diff --git a/gcc/testsuite/gcc.dg/vect/pr109011-5.c b/gcc/testsuite/gcc.dg/vect/pr109011-5.c index 9717b1ba841f..775d8e044087 100644 --- a/gcc/testsuite/gcc.dg/vect/pr109011-5.c +++ b/gcc/testsuite/gcc.dg/vect/pr109011-5.c @@ -1,6 +1,7 @@ /* PR tree-optimization/109011 */ /* { dg-do compile } */ /* { dg-additional-options "-O3 -fno-unroll-loops --param=vect-epilogues-nomask=0 -fdump-tree-optimized" } */ +/* { dg-additional-options "-mprefer-vector-width=512" { target { i?86-*-* x86_64-*-* } } } */ /* { dg-additional-options "-mno-avx512cd -mbmi -mlzcnt -mavx512vpopcntdq" { target { { { { i?86-*-* x86_64-*-* } && avx512vpopcntdq } && lzcnt } && bmi } } } */ /* { dg-additional-options "-mdejagnu-cpu=power8" { target powerpc_vsx } } */ diff --git a/gcc/testsuite/gcc.target/i386/avx512f-ceil-sfix-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-ceil-sfix-vec-2.c index a82d90d39ad9..c570719048f6 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-ceil-sfix-vec-2.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-ceil-sfix-vec-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */ +/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f -mprefer-vector-width=512" } */ #include "avx512f-ceil-sfix-vec-1.c" diff --git a/gcc/testsuite/gcc.target/i386/avx512f-ceil-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-ceil-vec-2.c index bf8af064cfe5..2004155e1066 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-ceil-vec-2.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-ceil-vec-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */ +/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f -mprefer-vector-width=512" } */ #include "avx512f-ceil-vec-1.c" diff --git a/gcc/testsuite/gcc.target/i386/avx512f-ceilf-sfix-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-ceilf-sfix-vec-2.c index 80e594dbfa40..ed9d39689112 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-ceilf-sfix-vec-2.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-ceilf-sfix-vec-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */ +/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f -mprefer-vector-width=512" } */ #include "avx512f-ceilf-sfix-vec-1.c" diff --git a/gcc/testsuite/gcc.target/i386/avx512f-ceilf-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-ceilf-vec-2.c index 95a79e29d127..3e1e9af91f85 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-ceilf-vec-2.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-ceilf-vec-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */ +/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f -mprefer-vector-width=512" } */ #include "avx512f-ceilf-vec-1.c" diff --git a/gcc/testsuite/gcc.target/i386/avx512f-floor-sfix-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-floor-sfix-vec-2.c index 76367d84add7..29da1f051bc5 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-floor-sfix-vec-2.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-floor-sfix-vec-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */ +/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f -mprefer-vector-width=512" } */ #include "avx512f-floor-sfix-vec-1.c" diff --git a/gcc/testsuite/gcc.target/i386/avx512f-floor-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-floor-vec-2.c index 0d401f78d632..4f4b77c8f4a5 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-floor-vec-2.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-floor-vec-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */ +/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f -mprefer-vector-width=512" } */ #include "avx512f-floor-vec-1.c" diff --git a/gcc/testsuite/gcc.target/i386/avx512f-floorf-sfix-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-floorf-sfix-vec-2.c index f4bfec5385e9..4bf0ad738efe 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-floorf-sfix-vec-2.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-floorf-sfix-vec-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */ +/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f -mprefer-vector-width=512" } */ #include "avx512f-floorf-sfix-vec-1.c" diff --git a/gcc/testsuite/gcc.target/i386/avx512f-floorf-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-floorf-vec-2.c index 90c6c0fade50..3ac1e6d2b583 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-floorf-vec-2.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-floorf-vec-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */ +/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f -mprefer-vector-width=512" } */ #include "avx512f-floorf-vec-1.c" diff --git a/gcc/testsuite/gcc.target/i386/avx512f-pr95060.c b/gcc/testsuite/gcc.target/i386/avx512f-pr95060.c index b38dc4f1e132..1dd64279bc79 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-pr95060.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-pr95060.c @@ -1,6 +1,6 @@ /* PR tree-optimization/95060 */ /* { dg-do compile } */ -/* { dg-options "-O3 -ffast-math -mavx512f" } */ +/* { dg-options "-O3 -ffast-math -mavx512f -mprefer-vector-width=512" } */ /* { dg-final { scan-assembler "\tvfnmsub" } } */ /* { dg-final { scan-assembler-not "\tvfmadd" } } */ diff --git a/gcc/testsuite/gcc.target/i386/avx512f-rint-sfix-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-rint-sfix-vec-2.c index 2d2099f77cb5..13bfe87dccd2 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-rint-sfix-vec-2.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-rint-sfix-vec-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */ +/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f -mprefer-vector-width=512" } */ /* { dg-require-effective-target c99_runtime } */ #include "avx512f-rint-sfix-vec-1.c" diff --git a/gcc/testsuite/gcc.target/i386/avx512f-rintf-sfix-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-rintf-sfix-vec-2.c index fe473766c869..3ce4f32cb9b3 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-rintf-sfix-vec-2.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-rintf-sfix-vec-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */ +/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f -mprefer-vector-width=512" } */ /* { dg-require-effective-target c99_runtime } */ #include "avx512f-rintf-sfix-vec-1.c" diff --git a/gcc/testsuite/gcc.target/i386/avx512f-round-sfix-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-round-sfix-vec-2.c index 5982c65d1e13..ee5bc913ae5d 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-round-sfix-vec-2.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-round-sfix-vec-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */ +/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f -mprefer-vector-width=512" } */ #include "avx512f-round-sfix-vec-1.c" diff --git a/gcc/testsuite/gcc.target/i386/avx512f-roundf-sfix-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-roundf-sfix-vec-2.c index 0d8abb892d13..79f28d1c9841 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-roundf-sfix-vec-2.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-roundf-sfix-vec-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */ +/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f -mprefer-vector-width=512" } */ #include "avx512f-roundf-sfix-vec-1.c" diff --git a/gcc/testsuite/gcc.target/i386/avx512f-trunc-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-trunc-vec-2.c index e8ec0227653a..128cd5f673f6 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-trunc-vec-2.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-trunc-vec-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */ +/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f -mprefer-vector-width=512" } */ #include "avx512f-trunc-vec-1.c" diff --git a/gcc/testsuite/gcc.target/i386/avx512f-truncf-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-truncf-vec-2.c index ae542d8276bf..07cd8cc0ab83 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-truncf-vec-2.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-truncf-vec-2.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */ +/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f -mprefer-vector-width=512" } */ #include "avx512f-truncf-vec-1.c" diff --git a/gcc/testsuite/gcc.target/i386/avx512f-vpternlogd-3.c b/gcc/testsuite/gcc.target/i386/avx512f-vpternlogd-3.c index 9ed4680346be..6b24145888ba 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-vpternlogd-3.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-vpternlogd-3.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -mavx512f" } */ +/* { dg-options "-O2 -mavx512f -mprefer-vector-width=512" } */ typedef unsigned int V __attribute__ ((__vector_size__ (16))); diff --git a/gcc/testsuite/gcc.target/i386/avx512f-vpternlogd-4.c b/gcc/testsuite/gcc.target/i386/avx512f-vpternlogd-4.c index eb39ffc25642..5271e7bdb790 100644 --- a/gcc/testsuite/gcc.target/i386/avx512f-vpternlogd-4.c +++ b/gcc/testsuite/gcc.target/i386/avx512f-vpternlogd-4.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -mavx512f" } */ +/* { dg-options "-O2 -mavx512f -mprefer-vector-width=512" } */ typedef unsigned int V __attribute__ ((__vector_size__ (32))); diff --git a/gcc/testsuite/gcc.target/i386/mask-pack.c b/gcc/testsuite/gcc.target/i386/mask-pack.c index bbc1fbc2a8db..5b60782f6682 100644 --- a/gcc/testsuite/gcc.target/i386/mask-pack.c +++ b/gcc/testsuite/gcc.target/i386/mask-pack.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-mavx512bw -O3 -fopenmp-simd -fdump-tree-vect-details" } */ +/* { dg-options "-mavx512bw -O3 -fopenmp-simd -fdump-tree-vect-details -mprefer-vector-width=512" } */ /* Disabling epilogues until we find a better way to deal with scans. */ /* { dg-additional-options "--param vect-epilogues-nomask=0" } */ /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 10 "vect" } } */ diff --git a/gcc/testsuite/gcc.target/i386/mask-unpack.c b/gcc/testsuite/gcc.target/i386/mask-unpack.c index f37294c71d81..354af74a9f4d 100644 --- a/gcc/testsuite/gcc.target/i386/mask-unpack.c +++ b/gcc/testsuite/gcc.target/i386/mask-unpack.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-mavx512bw -mavx512dq -mno-stackrealign -O3 -fopenmp-simd -fdump-tree-vect-details" } */ +/* { dg-options "-mavx512bw -mavx512dq -mno-stackrealign -O3 -fopenmp-simd -fdump-tree-vect-details -mprefer-vector-width=512" } */ /* Disabling epilogues until we find a better way to deal with scans. */ /* { dg-additional-options "--param vect-epilogues-nomask=0" } */ /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 10 "vect" } } */ diff --git a/gcc/testsuite/gcc.target/i386/pr80846-1.c b/gcc/testsuite/gcc.target/i386/pr80846-1.c index 295bb7d0d5a3..4ff817d03c75 100644 --- a/gcc/testsuite/gcc.target/i386/pr80846-1.c +++ b/gcc/testsuite/gcc.target/i386/pr80846-1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O3 -mavx512f" } */ +/* { dg-options "-O3 -mavx512f -mprefer-vector-width=512" } */ int sumint(const int arr[]) { arr = __builtin_assume_aligned(arr, 64); From 8361264a1be9514345dd60d40adcf6123ad985a8 Mon Sep 17 00:00:00 2001 From: Dominic P Date: Sat, 26 Sep 2026 16:54:15 +0100 Subject: [PATCH 468/584] doc: Remove the Windows CE target note from install.texi The note says Windows CE is supported on SuperH (sh-wince-pe) and MIPS (mips-wince-pe), but config.gcc has no such targets and configure rejects both with "Configuration ... not supported". Checked that install.texi builds without warnings with makeinfo (info and HTML). Assisted-by: Claude Opus 5 (Anthropic) gcc/ChangeLog: PR target/69374 * doc/install.texi (Microsoft Windows): Remove the Windows CE subsection. Signed-off-by: Dominic P --- gcc/doc/install.texi | 4 ---- 1 file changed, 4 deletions(-) diff --git a/gcc/doc/install.texi b/gcc/doc/install.texi index 49f4b956c7bd..0bbcc5766c91 100644 --- a/gcc/doc/install.texi +++ b/gcc/doc/install.texi @@ -5156,10 +5156,6 @@ GCC contains support for x86-64 using the mingw-w64 runtime library, available from @uref{https://www.mingw-w64.org/downloads/}. This library should be used with the target triple x86_64-pc-mingw32. -@subheading Windows CE -Windows CE is supported as a target only on Hitachi -SuperH (sh-wince-pe), and MIPS (mips-wince-pe). - @subheading Other Windows Platforms GCC no longer supports the Windows POSIX subsystem. From 443459ab606f00dc38fc230d670893814276d4bf Mon Sep 17 00:00:00 2001 From: Cupertino Miranda Date: Sun, 27 Sep 2026 18:14:06 +0100 Subject: [PATCH 469/584] a68: Replace A68_GLOBAL_CONTEXT in favor of a68_range_context Removed possibly forgotten A68_GLOBAL_CONTEXT and get_global_context in favor of the language specific a68_range_context function. The builtin initialization was using the global context through pushdecl function, which although not an immediate problem seems to be incorrect. Signed-off-by: Cupertino Miranda gcc/algol68/ChangeLog * a68-lang.cc (a68_init): Anticipate the execution of a68_init_ranges. (get_global_context): Removed function. (pushdecl): Replace call to get_global_context by a68_range_context. * a68.h: Remove A68_GLOBAL_CONTEXT macro. --- gcc/algol68/a68-lang.cc | 21 ++++----------------- gcc/algol68/a68.h | 1 - 2 files changed, 4 insertions(+), 18 deletions(-) diff --git a/gcc/algol68/a68-lang.cc b/gcc/algol68/a68-lang.cc index 1cefb08c5abd..77ddbf08788b 100644 --- a/gcc/algol68/a68-lang.cc +++ b/gcc/algol68/a68-lang.cc @@ -222,14 +222,15 @@ a68_build_a68_type_nodes (void) static bool a68_init (void) { + /* Initialize binding contexts. */ + a68_init_ranges (); + build_common_tree_nodes (false); a68_build_a68_type_nodes (); targetm.init_builtins (); build_common_builtin_nodes (); a68_install_builtins (); - /* Initialize binding contexts. */ - a68_init_ranges (); /* Set the type of size_t. */ if (TYPE_MODE (long_unsigned_type_node) == ptr_mode) @@ -399,20 +400,6 @@ a68_getdecls (void) #undef LANG_HOOKS_GETDECLS #define LANG_HOOKS_GETDECLS a68_getdecls -/* Return A68_GLOBAL_CONTEXT, but create it first if need be. */ - -static tree -get_global_context (void) -{ - if (!A68_GLOBAL_CONTEXT) - { - A68_GLOBAL_CONTEXT = build_translation_unit_decl (NULL_TREE); - debug_hooks->register_main_translation_unit (A68_GLOBAL_CONTEXT); - } - - return A68_GLOBAL_CONTEXT; -} - /* Implements the lang_hooks.decls.pushdecl routine. Record DECL as belonging to the current lexical scope. */ @@ -426,7 +413,7 @@ pushdecl (tree decl) if (current_function_decl) DECL_CONTEXT (decl) = current_function_decl; else - DECL_CONTEXT (decl) = get_global_context (); + DECL_CONTEXT (decl) = a68_range_context (); } /* Put decls on list in reverse order. */ diff --git a/gcc/algol68/a68.h b/gcc/algol68/a68.h index 7130cd0948ad..90f5467cf65b 100644 --- a/gcc/algol68/a68.h +++ b/gcc/algol68/a68.h @@ -144,7 +144,6 @@ extern GTY(()) A68_T a68_common; #define A68_GLOBAL_TREES A68 (global_trees) #define A68_PARSER(Z) (A68 (parser_state).Z) #define A68_MODULE_DEFINITION_DECLS A68 (module_definition_decls) -#define A68_GLOBAL_CONTEXT A68 (global_context) #define A68_GLOBAL_DECLARATIONS A68 (global_declarations) /* Particular pre-defined modes. */ From d33d3552eb807d64d05f0732ff9003bfae706f03 Mon Sep 17 00:00:00 2001 From: Roger Sayle Date: Sun, 27 Sep 2026 14:39:45 -0600 Subject: [PATCH 470/584] [PR target/127267] Improve code on iq2000 port for AOR optabs and lowpart IOR with 0x0 I'm submitting this on Roger's behalf. After debugging the execution fails originally attributed to Roger's patch for p127267, I'm of the opinion Roger's code is fine and that we've go some kind of linker issue going on. The details are in the BZ. Roger's patch tries to accomplish a few things. First it defines the aop optab to steer the iq2000 port to IOR rather than PLUS when they're equiavlent. That probably makes sense. In the process the patch improves the generated code for an IOR when the low bits are zero. For the case of loading a constant, we just emit the LUI for the high part and we're done. In the case of an IOR against zero, it turns into a copy. His patch also fixes up an parenthesis error in SMALL_INT handling. This fixes the poor code generation noted in pr127267. I suspect (but can not confirm) that the 20040705-1 execution failure is likely the same kind of linker bug that I just chased down. In fact, it makes any execution issues on the iq2000 port suspect (and I've had a long time suspicion that something wasn't quite right on the iq2000 port given is sporadic failures. PR target/127267 gcc/ * config/iq2000/iq2000.h (SMALL_INT): Fix trivial parenthesis goof. * config/iq2000/iq2000.cc (iq2000_move_1word): Eliminate useless IOR with 0x0 operand. * config/iq2000/iq2000.md (aopsi3): New expander. (32 bit integer move splitter): Turn low part IOR into a copy when the constant is zero. --- gcc/config/iq2000/iq2000.cc | 2 ++ gcc/config/iq2000/iq2000.h | 2 +- gcc/config/iq2000/iq2000.md | 13 +++++++++++++ 3 files changed, 16 insertions(+), 1 deletion(-) diff --git a/gcc/config/iq2000/iq2000.cc b/gcc/config/iq2000/iq2000.cc index 9945423affc8..2df80e11af1f 100644 --- a/gcc/config/iq2000/iq2000.cc +++ b/gcc/config/iq2000/iq2000.cc @@ -678,6 +678,8 @@ iq2000_move_1word (rtx operands[], rtx_insn *insn, int unsignedp) ret = "ori\t%0,%%0,%x1\t\t\t# %1"; else if (SMALL_INT (op1)) ret = "addiu\t%0,%%0,%1\t\t\t# %1"; + else if (CONST_INT_P (op1) && (INTVAL (op1) & 0xffff) == 0) + ret = "lui\t%0,%X1\t\t\t# %1"; else ret = "lui\t%0,%X1\t\t\t# %1\n\tori\t%0,%0,%x1"; } diff --git a/gcc/config/iq2000/iq2000.h b/gcc/config/iq2000/iq2000.h index b2a960a2909f..82f72db370f8 100644 --- a/gcc/config/iq2000/iq2000.h +++ b/gcc/config/iq2000/iq2000.h @@ -629,7 +629,7 @@ enum delay_type #define GR_REG_CLASS_P(CLASS) \ ((CLASS) == GR_REGS) -#define SMALL_INT(X) ((unsigned HOST_WIDE_INT) (INTVAL (X) + 0x8000) < 0x10000) +#define SMALL_INT(X) ((unsigned HOST_WIDE_INT) (INTVAL (X)) + 0x8000 < 0x10000) #define SMALL_INT_UNSIGNED(X) ((unsigned HOST_WIDE_INT) (INTVAL (X)) < 0x10000) /* Certain machines have the property that some registers cannot be diff --git a/gcc/config/iq2000/iq2000.md b/gcc/config/iq2000/iq2000.md index ab9709a98df0..1872553adc5b 100644 --- a/gcc/config/iq2000/iq2000.md +++ b/gcc/config/iq2000/iq2000.md @@ -425,6 +425,14 @@ "nor\\t%0,%z1,%z2" [(set_attr "type" "arith") (set_attr "mode" "SI")]) + +;; Expand any_or_plus (AOP) as iorsi3 +(define_expand "aopsi3" + [(set (match_operand:SI 0 "register_operand" "=d,d") + (ior:SI (match_operand:SI 1 "uns_arith_operand" "%d,d") + (match_operand:SI 2 "uns_arith_operand" "d,K")))] + "" + "") ;; ;; .................... @@ -686,6 +694,11 @@ & BITMASK_UPPER16, SImode)); operands[3] = GEN_INT (INTVAL (operands[1]) & BITMASK_LOWER16); + if (operands[3] == const0_rtx) + { + emit_insn (gen_rtx_SET (operands[0], operands[2])); + DONE; + } }") ;; Unlike most other insns, the move insns can't be split with From cf99490e7ebcf72e3478454448dc265a32723240 Mon Sep 17 00:00:00 2001 From: Tamar Christina Date: Sun, 27 Sep 2026 23:00:01 +0100 Subject: [PATCH 471/584] vect: fix loop exit profiles with early break [PR118407] It's been a few years since the patches for PR118407 but have been stuck on a review. Those patches attempted to make an framework for supporting early break profiles in not just the vectorizer but in other passes as well. This patch takes a different approach. We know that the vectorizer is the one introducing the inaccurate profile information, so have it fix it up. There are other places in the vectorizer where this happens for non-early break too. As an example this loop unsigned vect_a[N]; unsigned vect_b[N]; unsigned test4(unsigned x) { unsigned ret = 0; for (int i = 0; i < N; i++) { vect_b[i] = x + i; if (vect_a[i]*2 != x) break; vect_a[i] = x; } return ret; } generates with -O3 -march=armv9-a the following loop: test4: cntw x1 cmp w1, 799 bhi .L7 adrp x4, .LANCHOR0 add x3, x4, :lo12:.LANCHOR0 ptrue p7.b, all add x5, x3, 3200 mov w1, 0 mov z30.s, w0 mov w6, 800 index z29.s, #0, #1 b .L4 .L3: st1w z28.s, p7, [x5, x1, lsl 2] st1w z30.s, p7, [x3, x1, lsl 2] incw z29.s incw x1 whilelo p7.s, w1, w6 b.none .L5 .L4: ld1w z31.s, p7/z, [x3, x1, lsl 2] add z28.s, z29.s, z30.s add z31.s, z31.s, z31.s cmpne p15.s, p7/z, z31.s, z30.s b.none .L3 mov w5, 800 mov w2, w1 sub w5, w5, w1 .L2: notice the pointless indirect branch to L4, and the commonly taken branch of .L3 has to do a branch back to the latch instead of a fall through. The CFG becomes increasingly branchy as the number of exits increase. With this patch we generate: test4: cntw x1 cmp w1, 799 bhi .L7 adrp x3, .LANCHOR0 add x3, x3, :lo12:.LANCHOR0 ptrue p7.b, all add x4, x3, 3200 mov w1, 0 mov z30.s, w0 mov w5, 800 index z29.s, #0, #1 .p2align 5,,15 .L4: ld1w z31.s, p7/z, [x3, x1, lsl 2] add z28.s, z29.s, z30.s add z31.s, z31.s, z31.s cmpne p15.s, p7/z, z31.s, z30.s b.any .L12 st1w z28.s, p7, [x4, x1, lsl 2] st1w z30.s, p7, [x3, x1, lsl 2] incw z29.s incw x1 whilelo p7.s, w1, w5 b.any .L4 .L5: mov w0, 0 ret which is a more natural layout because it now knows the exit is unlikely since they have been scaled correctly. The scaling is done by: let P be the scalar probability that one iteration takes an early exit edge. 1 - P is then the probabiliy that the exit is not taken. Since every vector iteration handles VF scalar iterations, the early exit branch can be taken when any of the lanes are true. We invert this and first calculate the probablity that you reach the latch, i.e. the probability that the vector code does not exit is the probability Q that none of the lanes are true. Q = (1 - P) * (1 - P) * ... * (1 - P) = (1 - P) ^ VF and so the probability that at least one lane breaks is 1 - Q, or rather 1 - (i - P) ^ VF. For example, if the scalar break probability is 10% and VF is 4: P = 0.1 1 - P = 0.9 (1 - P) ^ VF = 0.9 ^ 4 = 0.6561 1 - (1 - p) ^ VF = 1 - 0.6561 = 0.3439 So a scalar early-exit edge that is taken 10% of the time becomes a vector early-exit edge that is taken about 34.4% of the time, because each vector iteration gives the break condition four chances to trigger. For counted loops we need to exclude the main exit from the calculations as for those the main exit is counted and so does not have this per-lane probability. For uncounted loops, all exits are based on vector compare, i.e. none of the exits are counted and we have a different loop control. That means for uncounted loops all exits should be using the per-lane probability and we should skip the counted exit adjustments in scale_profile_for_vect_loop. NOTE: This does not fully fix PR118407 but only fixes part of the issue. there are other adjustments needed but this is the most glaring one. gcc/ChangeLog: PR tree-optimization/118407 * tree-vect-loop.cc (vect_update_early_break_profiles): New. (scale_profile_for_vect_loop): Use it and pass loop_vinfo. (vect_transform_loop): Pass loop_vinfo to scale_profile_for_vect_loop. gcc/testsuite/ChangeLog: PR tree-optimization/118407 * gcc.target/aarch64/noeffect2.c: Update tests. * gcc.target/aarch64/sve/noeffect2.c: Update test. * gcc.target/aarch64/sve/noeffect3.c: Likewise. --- gcc/testsuite/gcc.target/aarch64/noeffect2.c | 7 +- .../gcc.target/aarch64/sve/noeffect2.c | 13 ++- .../gcc.target/aarch64/sve/noeffect3.c | 5 +- gcc/tree-vect-loop.cc | 98 +++++++++++++++++-- 4 files changed, 106 insertions(+), 17 deletions(-) diff --git a/gcc/testsuite/gcc.target/aarch64/noeffect2.c b/gcc/testsuite/gcc.target/aarch64/noeffect2.c index 08c531fb18c8..f0720862f9ce 100644 --- a/gcc/testsuite/gcc.target/aarch64/noeffect2.c +++ b/gcc/testsuite/gcc.target/aarch64/noeffect2.c @@ -15,10 +15,11 @@ int b[N] = {0}; ** cmgt v[0-9]+\.4s, v[0-9]+\.4s, v[0-9]+\.4s ** umaxp v[0-9]+\.4s, v[0-9]+\.4s, v[0-9]+\.4s ** fmov x[0-9]+, d[0-9]+ -** cbz x[0-9]+, \.L[0-9]+ -** mov w0, 1 +** cbn?z x[0-9]+, \.L[0-9]+ +** ... +** mov w0, [01] ** ret -** mov w0, 0 +** mov w0, [01] ** ret */ __attribute__ ((noipa, noinline)) diff --git a/gcc/testsuite/gcc.target/aarch64/sve/noeffect2.c b/gcc/testsuite/gcc.target/aarch64/sve/noeffect2.c index 5bb1badde3c4..04b7eb993e36 100644 --- a/gcc/testsuite/gcc.target/aarch64/sve/noeffect2.c +++ b/gcc/testsuite/gcc.target/aarch64/sve/noeffect2.c @@ -9,16 +9,21 @@ int b[N] = {0}; /* ** foo: ** ... -** whilelo p[0-9]+\.s, w[0-9]+, w[0-9]+ +** ptrue p[0-9]+\.b, all ** ... ** ld1w z[0-9]+\.s, p[0-9]+/z, \[x[0-9]+, x[0-9]+, lsl 2\] ** ld1w z[0-9]+\.s, p[0-9]+/z, \[x[0-9]+, x[0-9]+, lsl 2\] ** cmpgt p[0-9]+\.s, p[0-9]+/z, z[0-9]+\.s, z[0-9]+\.s -** b\.none \.L[0-9]+ -** mov w0, 1 -** ret +** b\.any \.L[0-9]+ +** ... +** incw x[0-9]+ +** whilelo p[0-9]+\.s, w[0-9]+, w[0-9]+ +** b\.any \.L[0-9]+ ** mov w0, 0 ** ret +** ... +** mov w0, 1 +** ret */ __attribute__ ((noipa, noinline)) int foo (void) diff --git a/gcc/testsuite/gcc.target/aarch64/sve/noeffect3.c b/gcc/testsuite/gcc.target/aarch64/sve/noeffect3.c index c5f81bb0d303..8c20f39d2a46 100644 --- a/gcc/testsuite/gcc.target/aarch64/sve/noeffect3.c +++ b/gcc/testsuite/gcc.target/aarch64/sve/noeffect3.c @@ -9,11 +9,14 @@ int b[N] = {0}; /* ** foo: ** ... -** whilelo p[0-9]+\.s, w[0-9]+, w[0-9]+ +** ptrue p[0-9]+\.b, all ** ... ** ld1w z[0-9]+\.s, p[0-9]+/z, \[x[0-9]+, x[0-9]+, lsl 2\] ** ld1w z[0-9]+\.s, p[0-9]+/z, \[x[0-9]+, x[0-9]+, lsl 2\] ** cmpgt p[0-9]+\.s, p[0-9]+/z, z[0-9]+\.s, z[0-9]+\.s +** b\.any \.L[0-9]+ +** ... +** whilelo p[0-9]+\.s, w[0-9]+, w[0-9]+ ** ... ** ldr w[0-9]+, \[x[0-9]+, x[0-9]+, lsl 2\] ** ldr w[0-9]+, \[x[0-9]+, x[0-9]+, lsl 2\] diff --git a/gcc/tree-vect-loop.cc b/gcc/tree-vect-loop.cc index f692ead2bacc..9b2afad6034a 100644 --- a/gcc/tree-vect-loop.cc +++ b/gcc/tree-vect-loop.cc @@ -10879,14 +10879,88 @@ vect_gen_loop_len_mask (loop_vec_info loop_vinfo, gimple_stmt_iterator *gsi, return len_mask; } +/* Update the exit profile counts scaling them from scalar to vector counts. + + The calculations are as follows. + + let P be the scalar probability that one iteration takes an early exit edge. + 1 - P is then the probabiliy that the exit is not taken. + + Since every vector iteration handles VF scalar iterations, the early exit + branch can be taken when any of the lanes are true. + + We invert this and first calculate the probablity that you reach the latch, + i.e. the probability that the vector code does not exit is the probability + Q that none of the lanes are true. + + Q = (1 - P) * (1 - P) * ... * (1 - P) + = (1 - P) ^ VF + + and so the probability that at least one lane breaks is 1 - Q, + or rather 1 - (i - P) ^ VF. + + For example, if the scalar break probability is 10% and VF is 4: + + P = 0.1 + 1 - P = 0.9 + (1 - P) ^ VF = 0.9 ^ 4 = 0.6561 + 1 - (1 - p) ^ VF = 1 - 0.6561 = 0.3439 + + So a scalar early-exit edge that is taken 10% of the time becomes a vector + early-exit edge that is taken about 34.4% of the time, because each vector + iteration gives the break condition four chances to trigger. */ + +static void +vect_update_early_break_profiles (loop_vec_info loop_vinfo) +{ + if (!LOOP_VINFO_EARLY_BREAKS (loop_vinfo)) + return; + + class loop *loop = LOOP_VINFO_LOOP (loop_vinfo); + unsigned int vf = vect_vf_for_cost (loop_vinfo); + + auto_vec, 8> updates; + for (edge e : get_loop_exit_edges (loop)) + { + if ((e == LOOP_VINFO_MAIN_EXIT (loop_vinfo) + && !LOOP_VINFO_NITERS_UNCOUNTED_P (loop_vinfo)) + || !e->probability.initialized_p ()) + continue; + + /* For any early break exits, the probablity of exiting are based on if + any lane is true, and so are tied to VF since you have VF chances. + As such scale the scalar profile by VF to the the probability for the + vector edges using 1 - (1 - p) ^ VF. */ + profile_probability probability + = profile_probability::always () - e->probability.invert ().pow (vf); + updates.safe_push ({e, probability}); + } + + /* First update the edge counts. */ + for (auto update : updates) + set_edge_probability_and_rescale_others (update.first, update.second); + + /* And then only update the in loop BBs, i.e. the fall through block for + the early exits. */ + for (auto update : updates) + for (edge e : update.first->src->succs) + if (!loop_exit_edge_p (loop, e) && single_pred_p (e->dest)) + e->dest->count = e->count (); +} + /* Scale profiling counters by estimation for LOOP which is vectorized by factor VF. If FLAT is true, the loop we started with had unrealistically flat profile. */ static void -scale_profile_for_vect_loop (class loop *loop, edge exit_e, unsigned vf, bool flat) +scale_profile_for_vect_loop (loop_vec_info loop_vinfo, + class loop *loop, edge exit_e, unsigned vf, + bool flat) { + /* First scale any early exits. */ + vect_update_early_break_profiles (loop_vinfo); + /* For flat profiles do not scale down proportionally by VF and only cap by known iteration count bounds. */ if (flat) @@ -10916,14 +10990,19 @@ scale_profile_for_vect_loop (class loop *loop, edge exit_e, unsigned vf, bool fl vf /= 2; } - if (entry_count.nonzero_p ()) - set_edge_probability_and_rescale_others + if (!LOOP_VINFO_NITERS_UNCOUNTED_P (loop_vinfo)) + { + if (entry_count.nonzero_p ()) + set_edge_probability_and_rescale_others (exit_e, entry_count.probability_in (loop->header->count / vf)); - /* Avoid producing very large exit probability when we do not have - sensible profile. */ - else if (exit_e->probability < profile_probability::always () / (vf * 2)) - set_edge_probability_and_rescale_others (exit_e, exit_e->probability * vf); + /* Avoid producing very large exit probability when we do not have + sensible profile. */ + else if (exit_e->probability < profile_probability::always () / (vf * 2)) + set_edge_probability_and_rescale_others (exit_e, + exit_e->probability * vf); + } + loop->latch->count = single_pred_edge (loop->latch)->count (); scale_loop_profile (loop, profile_probability::always () / vf, @@ -11545,8 +11624,9 @@ vect_transform_loop (loop_vec_info loop_vinfo, gimple *loop_vectorized_call) assumed_vf) - 1 : wi::udiv_floor (loop->nb_iterations_estimate + bias_for_assumed, assumed_vf) - 1); - scale_profile_for_vect_loop (loop, LOOP_VINFO_MAIN_EXIT (loop_vinfo), - assumed_vf, flat); + scale_profile_for_vect_loop (loop_vinfo, loop, + LOOP_VINFO_MAIN_EXIT (loop_vinfo), assumed_vf, + flat); if (dump_enabled_p ()) { From 3f1743f5e3538432032ed7a1ebdf6467798cfc8f Mon Sep 17 00:00:00 2001 From: GCC Administrator Date: Mon, 28 Sep 2026 00:16:35 +0000 Subject: [PATCH 472/584] Daily bump. --- gcc/ChangeLog | 57 ++++++++++++++++++++++ gcc/DATESTAMP | 2 +- gcc/algol68/ChangeLog | 15 ++++++ gcc/cobol/ChangeLog | 67 ++++++++++++++++++++++++++ gcc/cp/ChangeLog | 8 ++++ gcc/testsuite/ChangeLog | 104 ++++++++++++++++++++++++++++++++++++++++ libgcobol/ChangeLog | 5 ++ libstdc++-v3/ChangeLog | 5 ++ 8 files changed, 262 insertions(+), 1 deletion(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 3e7342684345..56225171496b 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,60 @@ +2026-09-27 Tamar Christina + + PR tree-optimization/118407 + * tree-vect-loop.cc (vect_update_early_break_profiles): New. + (scale_profile_for_vect_loop): Use it and pass loop_vinfo. + (vect_transform_loop): Pass loop_vinfo to scale_profile_for_vect_loop. + +2026-09-27 Roger Sayle + + PR target/127267 + * config/iq2000/iq2000.h (SMALL_INT): Fix trivial parenthesis goof. + * config/iq2000/iq2000.cc (iq2000_move_1word): Eliminate useless + IOR with 0x0 operand. + * config/iq2000/iq2000.md (aopsi3): New expander. + (32 bit integer move splitter): Turn low part IOR into a copy when + the constant is zero. + +2026-09-27 Dominic P + + PR target/69374 + * doc/install.texi (Microsoft Windows): Remove the Windows CE + subsection. + +2026-09-27 wangjue + + * tree-vect-patterns.cc (vect_sat_trunc_clip_input_vectype): New. + (vect_recog_sat_trunc_pattern): Look through promotions and check + target support for MAX_EXPR. + +2026-09-27 Iain Sandoe + + * config/darwin.cc (machopic_select_section): Do not try to + inspect a typename which has no id. + +2026-09-27 Samarth Tandale + + PR tree-optimization/112094 + * match.pd: Add fold for (a != 0) | (popcount(a) == n) and + (a == 0) & (popcount(a) != n). + +2026-09-27 James K. Lowden + + * config/avr/avr.opt.urls: Regenerate. + * config/nvptx/nvptx.opt.urls: Regenerate. + +2026-09-27 Jeff Law + + PR tree-optimization/126462 + * match.pd (reassociate xor to expose rotate patterns): Rewrite using + wi:: interfaces for the xor constant operand. + +2026-09-27 Gerald Pfeifer + + PR target/69374 + * doc/install.texi (Specific): No longer mention Windows NT on + Alpha and PowerPC. + 2026-09-26 Tamar Christina PR tree-optimization/127618 diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index d72743c7b357..8f4d8b86e757 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20260927 +20260928 diff --git a/gcc/algol68/ChangeLog b/gcc/algol68/ChangeLog index 4992b52ffcdf..f6ff2860ccd8 100644 --- a/gcc/algol68/ChangeLog +++ b/gcc/algol68/ChangeLog @@ -1,3 +1,18 @@ +2026-09-27 Cupertino Miranda + + * a68-lang.cc (a68_init): Anticipate the execution of + a68_init_ranges. + (get_global_context): Removed function. + (pushdecl): Replace call to get_global_context by + a68_range_context. + * a68.h: Remove A68_GLOBAL_CONTEXT macro. + +2026-09-27 Jose E. Marchesi + + * a68-low-moids.cc (build_stub_type_decl): Remove function. + (lower_struct_mode): Do not call build_stub_type_decl. + (lower_union_mode): Likewise. + 2026-09-25 Jose E. Marchesi * a68-types.h (struct TAG_T): Add field ctyp. diff --git a/gcc/cobol/ChangeLog b/gcc/cobol/ChangeLog index 3136fb094900..09af933a04c2 100644 --- a/gcc/cobol/ChangeLog +++ b/gcc/cobol/ChangeLog @@ -1,3 +1,70 @@ +2026-09-27 James K. Lowden + + * cbldiag.h (struct cbl_loc_t): Add operators to increment first_column. + (repeat_count): Declare function. + (parse_error_count): Same. + (cobol_location): Remove obsolete comment. + * cdf.y: Update token values. + * parse.y: Introduce PICTURE token. + (keyword_tok): Exclude CDF tokens to prevent false positives. + * parse_ante.h (struct arith_t): Better diagnositic. + (valid_operands): New function. + (parser_move_carefully): Reject invalid operands. + (parser_move2): Whitespace. + (parser_index): Same. + * picture.cc (picture_rules): Revise automaton. + (is_allowed): Add PICTURE constraints. + (seek_paren): Add debug messages. + (is_valid_picture): Rewrote function. + (class picture_t): Capture PICTURE state to report to lexer. + * scan.l: Use is_valid_token for complex pictures. + * scan_ante.h (repeat_count): Use uint32_t, consistent with cbl_field_t. + * semantic_token.h: New file representing lex_picture_t. + * symbols.cc (parse_error_count): Remove declaration. + * symbols.h: Use std::array. + * symfind.cc (struct funcname): Whitespace. + (symbol_match): Use diagnositic quotes. + * token_names.h: Regenerate. + * util.cc (named_constant): Return type of constant. + (repeat_count): Accept location and return uint32_t. + (parse_error_count): Remove declaration. + * util.h (repeat_count): Same. + +2026-09-27 James K. Lowden + + * words/cdf.h: New file. + * words/intrinsic.h: New file. + * words/reserved.h: New file. + +2026-09-27 James K. Lowden + + * picture.cc (symbol_currency): Remove test harness mock-up. + (cbl_internal_error): Same. + (yy_flex_debug): Undefine, per usual. + (seek_paren): Use ISALNUM. + (is_valid_picture): Use repeat_count to resolve size. + * scan_ante.h (repeat_count): Remove declaration. + * util.cc (cbl_prototype_ok): Whitespace. + (cdf_file): Same. + (repeat_count): Same. + (cbl_field_t::encode_numeric): Same. + (cbl_field_t::report_invalid_initial_value): Same. + (literal_subscript_oob): Same. + (valid_move): Same. + (hex2numstr): Same. + (cobol_filename): Same. + (gcc_location_set): Same. + (parse_file): Same. + (iso_cobol_word): Same. + * util.h (repeat_count): Declare function. + +2026-09-27 James K. Lowden + + * Make-lang.in: Add gcc/cobol/picture.cc. + * scan.l: Replace validate_picture with is_valid_picture. + * scan_ante.h: Delete code that was commented out. + * picture.cc: New file. + 2026-09-25 Robert Dubner * cobol1.cc (use_static_call): Change name of global function to diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 06ddd4e94a08..e348431f44bc 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,11 @@ +2026-09-27 Steven Sudit + + PR c++/127218 + * constexpr.cc (cxx_eval_builtin_function_call): Clear STRRET + when the argument it refers to is not replaced by the address of + a STRING_CST, so the folded result is re-based on the original + argument only when that replacement happened. + 2026-09-25 Jakub Jelinek PR c++/127385 diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index a4b185594418..904033911f43 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,107 @@ +2026-09-27 Tamar Christina + + PR tree-optimization/118407 + * gcc.target/aarch64/noeffect2.c: Update tests. + * gcc.target/aarch64/sve/noeffect2.c: Update test. + * gcc.target/aarch64/sve/noeffect3.c: Likewise. + +2026-09-27 Iain Sandoe + + * gcc.dg/vect/pr109011-1.c: Prefer 512b vectors. + * gcc.dg/vect/pr109011-2.c: Likewise. + * gcc.dg/vect/pr109011-3.c: Likewise. + * gcc.dg/vect/pr109011-4.c: Likewise. + * gcc.dg/vect/pr109011-5.c: Likewise. + * gcc.target/i386/avx512f-ceil-sfix-vec-2.c: Likewise. + * gcc.target/i386/avx512f-ceil-vec-2.c: Likewise. + * gcc.target/i386/avx512f-ceilf-sfix-vec-2.c: Likewise. + * gcc.target/i386/avx512f-ceilf-vec-2.c: Likewise. + * gcc.target/i386/avx512f-floor-sfix-vec-2.c: Likewise. + * gcc.target/i386/avx512f-floor-vec-2.c: Likewise. + * gcc.target/i386/avx512f-floorf-sfix-vec-2.c: Likewise. + * gcc.target/i386/avx512f-floorf-vec-2.c: Likewise. + * gcc.target/i386/avx512f-pr95060.c: Likewise. + * gcc.target/i386/avx512f-rint-sfix-vec-2.c: Likewise. + * gcc.target/i386/avx512f-rintf-sfix-vec-2.c: Likewise. + * gcc.target/i386/avx512f-round-sfix-vec-2.c: Likewise. + * gcc.target/i386/avx512f-roundf-sfix-vec-2.c: Likewise. + * gcc.target/i386/avx512f-trunc-vec-2.c: Likewise. + * gcc.target/i386/avx512f-truncf-vec-2.c: Likewise. + * gcc.target/i386/avx512f-vpternlogd-3.c: Likewise. + * gcc.target/i386/avx512f-vpternlogd-4.c: Likewise. + * gcc.target/i386/mask-pack.c: Likewise. + * gcc.target/i386/mask-unpack.c: Likewise. + * gcc.target/i386/pr80846-1.c: Likewise. + +2026-09-27 Iain Sandoe + + * gcc.target/i386/avx512bw-vmovdqu16-1.c: Specify generic + tuning. + * gcc.target/i386/avx512fp16-13.c: Likewise. + * gcc.target/i386/avx512vl-stv-rotatedi-1.c: Likewise. + * gcc.target/i386/movbe-5.c: Likewise. + * gcc.target/i386/pieces-memset-11.c: Likewise. + * gcc.target/i386/pieces-memset-14.c: Likewise. + * gcc.target/i386/pieces-memset-2.c: Likewise. + * gcc.target/i386/pieces-memset-20.c: Likewise. + * gcc.target/i386/pieces-memset-23.c: Likewise. + * gcc.target/i386/pieces-memset-29.c: Likewise. + * gcc.target/i386/pieces-memset-30.c: Likewise. + * gcc.target/i386/pieces-memset-33.c: Likewise. + * gcc.target/i386/pieces-memset-34.c: Likewise. + * gcc.target/i386/pieces-memset-37.c: Likewise. + * gcc.target/i386/pieces-memset-44.c: Likewise. + * gcc.target/i386/pieces-memset-5.c: Likewise. + * gcc.target/i386/pr107548-1.c: Likewise. + * gcc.target/i386/pr107548-2.c: Likewise. + * gcc.target/i386/pr108938-3.c: Likewise. + * gcc.target/i386/pr124697-3b.c: Likewise. + * gcc.target/i386/pr53533-1.c: Likewise. + * gcc.target/i386/pr53533-3.c: Likewise. + * gcc.target/i386/pr95483-5.c: Likewise. + * gcc.target/i386/pr95483-6.c: Likewise. + * gcc.target/i386/sse2-stv-9.c: Likewise. + * gcc.target/i386/sse4_1-stv-11.c: Likewise. + * gcc.target/i386/sse4_1-stv-12.c: Likewise. + +2026-09-27 Jeff Law + + * gcc.target/riscv/bclr-lowest-set-bit-2.c: Fix typos and force c99 mode. + +2026-09-27 wangjue + + * gcc.target/riscv/rvv/autovec/pr120378-3.c: Disable the vector cost + model. + * gcc.target/riscv/rvv/autovec/pr120378-4.c: Likewise. + * gcc.target/riscv/rvv/autovec/sat-trunc-promote-1.c: New test. + * gcc.target/riscv/rvv/autovec/sat-trunc-promote-run-1.c: New test. + +2026-09-27 Steven Sudit + + PR c++/127218 + * g++.dg/cpp0x/constexpr-memchr2.C: New test. + +2026-09-27 Iain Sandoe + + * gcc.dg/vect/vect-pr127601.c: If MAP_ANONYMOUS is not defined + for Darwin, alias it to MAP_ANON. + +2026-09-27 Samarth Tandale + + PR tree-optimization/112094 + * gcc.dg/fold-popcount-12.c: New test. + * gcc.dg/fold-popcount-13.c: New test. + +2026-09-27 Xavier Del Campo Romero + + * cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.out: Do not use /tmp. + * cobol.dg/group2/ACCEPT_foo_FROM_COMMAND-LINE_1_.cob: Removed. + +2026-09-27 Jeff Law + + PR tree-optimization/126462 + * gcc.dg/torture/pr126462.c: New test. + 2026-09-26 Jerry DeLisle PR fortran/127187 diff --git a/libgcobol/ChangeLog b/libgcobol/ChangeLog index 22b760f3879d..814d1d5eca82 100644 --- a/libgcobol/ChangeLog +++ b/libgcobol/ChangeLog @@ -1,3 +1,8 @@ +2026-09-27 James K. Lowden + + * libgcobol.cc (default_exception_handler): Use ec_status.source_file. + (__gg__move_stash_release): Delete blank line. + 2026-09-25 Robert Dubner * libgcobol.cc (__gg__call_warning_message): Moved here from diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index db911874f5b0..56b569418730 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,8 @@ +2026-09-27 Gerald Pfeifer + + * doc/xml/manual/debug_mode.xml: Switch Safe STL link to https. + * doc/html/manual/debug_mode_design.html: Regenerate. + 2026-09-23 Jonathan Wakely * libsupc++/new_opa.cc From 3f6fb81133dfa2b8f843b328fd6b697534e7b3fe Mon Sep 17 00:00:00 2001 From: Stian Halseth Date: Sun, 27 Sep 2026 21:51:28 -0600 Subject: [PATCH 473/584] [PATCH v3] ifcvt: Do not clobber a live condition-code register in find_cond_trap [PR127578] find_cond_trap emits the sequence from gen_cond_trap before cond_earliest. On SPARC that sequence is a comparison followed by a trap on the condition codes, but the branch it replaces need not read them: a cbcond tests general registers, so a condition code set earlier can be live across TEST_BB and read by a later branch, which then tests the wrong value. The fix for PR126501 added noce_clobbers_live_cc_p for the same problem in the noce paths. Use it here too. On sparc64 with -mcbcond this miscompiles a switch over a sparse enum whose default arm is unreachable, which is why LLVM 23 does not build there. Bootstrapped on sparc64-unknown-linux-gnu. The C and C++ testsuites, run against an otherwise identical unpatched tree, change only in the new test, which fails without the patch and passes with it. --- Changes since v2: document cbcond_hw in doc/sourcebuild.texi. Changes since v1: reuse noce_clobbers_live_cc_p, the check that end_ifcvt_sequence already makes, instead of adding a new liveness check. PR rtl-optimization/127578 gcc/ChangeLog: * doc/sourcebuild.texi (cbcond_hw): Document. * ifcvt.cc (find_cond_trap): Reject a sequence that clobbers a condition-code register live out of TEST_BB. gcc/testsuite/ChangeLog: * lib/target-supports.exp (check_effective_target_cbcond_hw): New. * gcc.target/sparc/cbcond-trap-1.c: New test. --- gcc/doc/sourcebuild.texi | 4 +++ gcc/ifcvt.cc | 3 ++ .../gcc.target/sparc/cbcond-trap-1.c | 34 +++++++++++++++++++ gcc/testsuite/lib/target-supports.exp | 9 +++++ 4 files changed, 50 insertions(+) create mode 100644 gcc/testsuite/gcc.target/sparc/cbcond-trap-1.c diff --git a/gcc/doc/sourcebuild.texi b/gcc/doc/sourcebuild.texi index b02cb28db512..3aa9fcbb5778 100644 --- a/gcc/doc/sourcebuild.texi +++ b/gcc/doc/sourcebuild.texi @@ -2758,6 +2758,10 @@ Target supports the execution of @code{avxvnniint16} instructions. Target runtime permits dereferencing a null pointer without trapping, for example because address zero is mapped and readable. +@item cbcond_hw +Test system can execute SPARC compare-and-branch (@code{cbcond}) +instructions. + @item cell_hw Test system can execute AltiVec and Cell PPU instructions. diff --git a/gcc/ifcvt.cc b/gcc/ifcvt.cc index 618c2976c5d7..ab9d35699cba 100644 --- a/gcc/ifcvt.cc +++ b/gcc/ifcvt.cc @@ -6114,6 +6114,9 @@ find_cond_trap (basic_block test_bb, edge then_edge, edge else_edge) : recog_memoized (x) < 0) return false; + if (noce_clobbers_live_cc_p (test_bb, seq)) + return false; + /* Emit the new insns before cond_earliest. */ emit_insn_before_setloc (seq, cond_earliest, INSN_LOCATION (trap)); diff --git a/gcc/testsuite/gcc.target/sparc/cbcond-trap-1.c b/gcc/testsuite/gcc.target/sparc/cbcond-trap-1.c new file mode 100644 index 000000000000..8fc3ddcc8e3e --- /dev/null +++ b/gcc/testsuite/gcc.target/sparc/cbcond-trap-1.c @@ -0,0 +1,34 @@ +/* { dg-do run { target cbcond_hw } } */ +/* { dg-options "-O2 -mcpu=niagara4" } */ + +/* find_cond_trap used to emit the comparison of the conditional trap on top + of a %icc value that was still live, because a cbcond jump does not read + the CC. */ + +struct S { unsigned short bt; unsigned char kind; unsigned bw; }; + +__attribute__((noinline)) void f (struct S *s) +{ + switch (s->bt) + { + case 1: s->bw = 8; s->kind = 1; break; + case 2: s->bw = 16; s->kind = 1; break; + case 4: s->bw = 32; s->kind = 1; break; + case 8: s->bw = 64; s->kind = 1; break; + case 16: s->bw = 16; s->kind = 2; break; + case 32: s->bw = 16; s->kind = 3; break; + case 64: s->bw = 32; s->kind = 3; break; + case 128: s->bw = 64; s->kind = 3; break; + case 256: s->bw = 8; s->kind = 4; break; + case 512: s->bw = 8; s->kind = 5; break; + default: __builtin_trap (); + } +} + +int +main (void) +{ + struct S s = { 1, 0, 0 }; + f (&s); + return s.bw == 8 ? 0 : 1; +} diff --git a/gcc/testsuite/lib/target-supports.exp b/gcc/testsuite/lib/target-supports.exp index 5eb44cb3ee42..ae04b6a8daa1 100644 --- a/gcc/testsuite/lib/target-supports.exp +++ b/gcc/testsuite/lib/target-supports.exp @@ -8564,6 +8564,15 @@ proc check_effective_target_ultrasparc_vis3_hw { } { } "-mcpu=niagara3"] } +# Return 1 if the test environment supports executing SPARC compare-and-branch +# instructions. We check this by attempting: "cwbe %g0, %g0, .+4" + +proc check_effective_target_cbcond_hw { } { + return [check_runtime cbcond_hw { + int main() { __asm__(".word 0x12c00020"); return 0; } + } "-mcpu=niagara4"] +} + # Return 1 if this is a SPARC-V9 target. proc check_effective_target_sparc_v9 { } { From ec09d7005033eb1f28304af80d888b81bb3063c7 Mon Sep 17 00:00:00 2001 From: Naveen Date: Sun, 27 Sep 2026 21:29:20 -0700 Subject: [PATCH 474/584] RISC-V: Add conditional negate expansion [PR126245] Add a negcc expansion for integral comparisons on RISC-V. The expansion implements: X ? -X : X as: CMP = condition ? 1 : 0 MASK = -CMP RESULT = X ^ MASK RESULT += CMP This pattern can be used by existing if-conversion paths. Use a separate pseudo for the XOR result so that the output pseudo is assigned only once. gcc/ChangeLog: PR target/126245 * config/riscv/riscv.md (negcc): Add an expansion for conditional negation of integral values. gcc/testsuite/ChangeLog: PR target/126245 * gcc.target/riscv/pr126245-negcc.c: New test. Signed-off-by: Naveen --- gcc/config/riscv/riscv.md | 26 +++++++++++++++++++ .../gcc.target/riscv/pr126245-negcc.c | 16 ++++++++++++ 2 files changed, 42 insertions(+) create mode 100644 gcc/testsuite/gcc.target/riscv/pr126245-negcc.c diff --git a/gcc/config/riscv/riscv.md b/gcc/config/riscv/riscv.md index 8420b3d29e7b..2f4a3686b70f 100644 --- a/gcc/config/riscv/riscv.md +++ b/gcc/config/riscv/riscv.md @@ -3504,6 +3504,32 @@ FAIL; }) +(define_expand "negcc" + [(set (match_operand:GPR 0 "register_operand") + (if_then_else:GPR (match_operand 1 "comparison_operator") + (neg:GPR (match_operand:GPR 2 "register_operand")) + (match_operand:GPR 3 "register_operand")))] + "" +{ + rtx cmp = operands[1]; + rtx cmp0 = XEXP (cmp, 0); + rtx cmp1 = XEXP (cmp, 1); + + if (!INTEGRAL_MODE_P (GET_MODE (cmp0)) + || !rtx_equal_p (operands[2], operands[3])) + FAIL; + + rtx cmp_result = gen_reg_rtx (mode); + riscv_expand_int_scc (cmp_result, GET_CODE (cmp), cmp0, cmp1); + + rtx mask = gen_reg_rtx (mode); + riscv_emit_unary (NEG, mask, cmp_result); + rtx xor_result = gen_reg_rtx (mode); + riscv_emit_binary (XOR, xor_result, operands[2], mask); + riscv_emit_binary (PLUS, operands[0], xor_result, cmp_result); + DONE; +}) + (define_expand "addcc" [(match_operand:GPR 0 "register_operand") (match_operand 1 "comparison_operator") diff --git a/gcc/testsuite/gcc.target/riscv/pr126245-negcc.c b/gcc/testsuite/gcc.target/riscv/pr126245-negcc.c new file mode 100644 index 000000000000..5b791323ee21 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/pr126245-negcc.c @@ -0,0 +1,16 @@ +/* PR target/126245. Test the RISC-V negcc expander through if-conversion. */ +/* { dg-do compile { target { ! riscv_abi_e } } } */ +/* { dg-options "-O2 -march=rv64g -mabi=lp64d -fdump-rtl-ce1" { target { rv64 } } } */ +/* { dg-options "-O2 -march=rv32g -mabi=ilp32d -fdump-rtl-ce1" { target { rv32 } } } */ + +long +f_negcc (long x, long y) +{ + return x < y ? 42 : -42; +} + +/* { dg-final { scan-assembler-times {\mslt\M} 1 } } */ +/* { dg-final { scan-assembler-times {\m(?:xor|xori)\M} 1 } } */ +/* { dg-final { scan-assembler-times {\madd\M} 1 } } */ +/* { dg-final { scan-assembler-not {\m(?:beq|bne|blt|bge|ble|bgt)(?:u|z)?\M} } } */ +/* { dg-final { scan-rtl-dump-times {if-conversion succeeded through noce_try_inverse_constants} 1 "ce1" } } */ From 9e01c24ca797dfdc8e15d5678b2c3d5cb87b4c93 Mon Sep 17 00:00:00 2001 From: Tobias Burnus Date: Mon, 28 Sep 2026 14:50:56 +0200 Subject: [PATCH 475/584] GCN: Add gfx1154, which is part of gfx11-generic As gfx1154 belongs to gfx11-generic, basic support can be added without effort. gcc/ChangeLog: * config/gcn/gcn-devices.def: Add gfx1154. * config/gcn/gcn-tables.opt: Regenerate. * doc/invoke.texi (-march=): Add gfx1154. --- gcc/config/gcn/gcn-devices.def | 11 +++++++++++ gcc/config/gcn/gcn-tables.opt | 3 +++ gcc/doc/invoke.texi | 5 ++++- 3 files changed, 18 insertions(+), 1 deletion(-) diff --git a/gcc/config/gcn/gcn-devices.def b/gcc/config/gcn/gcn-devices.def index ece603774121..0b90e4889509 100644 --- a/gcc/config/gcn/gcn-devices.def +++ b/gcc/config/gcn/gcn-devices.def @@ -395,6 +395,17 @@ GCN_DEVICE(gfx1153, GFX1153, 0x58, ISA_RDNA3, /* Generic Name */ GFX11_GENERIC ) +GCN_DEVICE(gfx1154, GFX1154, 0x57, ISA_RDNA3, + /* XNACK default */ HSACO_ATTR_UNSUPPORTED, + /* SRAM_ECC default */ HSACO_ATTR_UNSUPPORTED, + /* WAVE64 mode */ HSACO_ATTR_ON, + /* CU mode */ HSACO_ATTR_ON, + /* Max ISA VGPRs */ 512, + /* Generic code obj version */ 0, /* non-generic */ + /* Architecture Family */ GFX11, + /* Generic Name */ GFX11_GENERIC + ) + GCN_DEVICE(gfx11-generic, GFX11_GENERIC, 0x054, ISA_RDNA3, /* XNACK default */ HSACO_ATTR_UNSUPPORTED, /* SRAM_ECC default */ HSACO_ATTR_UNSUPPORTED, diff --git a/gcc/config/gcn/gcn-tables.opt b/gcc/config/gcn/gcn-tables.opt index d6a126459bf5..6ba2425d484c 100644 --- a/gcc/config/gcn/gcn-tables.opt +++ b/gcc/config/gcn/gcn-tables.opt @@ -108,5 +108,8 @@ Enum(gpu_type) String(gfx1152) Value(PROCESSOR_GFX1152) EnumValue Enum(gpu_type) String(gfx1153) Value(PROCESSOR_GFX1153) +EnumValue +Enum(gpu_type) String(gfx1154) Value(PROCESSOR_GFX1154) + EnumValue Enum(gpu_type) String(gfx11-generic) Value(PROCESSOR_GFX11_GENERIC) diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index c5d17c059fd7..bd992cc99b9a 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -22499,9 +22499,12 @@ Compile for RDNA3 gfx1152 devices (GFX11 series). (Experimental) @item gfx1153 Compile for RDNA3 gfx1153 devices (GFX11 series). (Experimental) +@item gfx1154 +Compile for RDNA3 gfx1154 devices (GFX11 series). (Experimental) + @item gfx11-generic Compile generic code for GFX11 devices, executable on gfx1100, gfx1101, -gfx1102, gfx1103, gfx1150, gfx1151, gfx1152, and gfx1153. +gfx1102, gfx1103, gfx1150, gfx1151, gfx1152, gfx1153, gfx1154. @end table @opindex mgang-private-size From fb0129bebba38455a28bc1914676c902b2e8fc8f Mon Sep 17 00:00:00 2001 From: Robert Dubner Date: Mon, 28 Sep 2026 09:16:56 -0400 Subject: [PATCH 476/584] cobol: Validate numeric-edited PICTURE. Correct numeric-edited handling. There are two sets of related changes here. They both improve processing numeric-edited variables. One set does exhaustive checking of numeric-edited PICTURE strings, and generates appropriate error messages when they are incorrect. The other set brings MOVE numeric-display to numeric-edited, and comparisons of numeric-display and numeric-edited variables into accordance with the ISO specifications. Co-authored-by: James K. Lowden Co-authored-by: Robert Dubner gcc/cobol/ChangeLog: * compare.cc (numeric_alpha_compare): Numeric-edited handling. * genapi.cc (parser_setop): Likewise. * genapi.h (parser_setop): Likewise. * parse.y: Likewise. * picture.cc (class picture_t): Validate PICTURE. (is_valid_picture): Likewise. (process_file): Likewise. (main): Formatting * scan_ante.h (level_needed): Likewise. (class enter_leave_t): Likewise. (trim_location): Likewise. (binary_integer_usage): Likewise. (level_of): Likewise. (ndigit): Likewise. (symbol_exists): Likewise. (typed_name): Likewise. (yyunput): Likewise. (unquote): Likewise. * symbols.cc (symbols_update): Likewise. (struct symbol_elem_t): Likewise. (symbol_file): Likewise. (expand_picture): Numeric-edited handling. (expand_expanded): Likewise. (cbl_file_t::filename_of): Formatting. libgcobol/ChangeLog: * libgcobol.cc (format_for_display_internal): Numeric-edited handling. (__gg__move): Likewise. (__gg__compare_numdisp_alpha): Likewise. gcc/testsuite/ChangeLog: * cobol.dg/group2/ALLOCATE_Rules_6_-_9._Without_OPTION_INITIALIZE_Without_-fdefaultbyte___ASCII_.out: Modified for updated numeric-edited handling. * cobol.dg/group2/ALLOCATE_Rules_6_-_9._Without_OPTION_INITIALIZE_Without_-fdefaultbyte___EBCDIC_.out: Likewise. * cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.cob: Likewise. * cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.out: Likewise. * cobol.dg/group2/REDEFINES__chained.out: Likewise. --- gcc/cobol/compare.cc | 26 ++ gcc/cobol/genapi.cc | 35 +-- gcc/cobol/genapi.h | 4 +- gcc/cobol/parse.y | 11 +- gcc/cobol/picture.cc | 161 +++++------ gcc/cobol/scan_ante.h | 99 ++++--- gcc/cobol/symbols.cc | 49 ++-- ...TIALIZE_Without_-fdefaultbyte___ASCII_.out | 6 +- ...IALIZE_Without_-fdefaultbyte___EBCDIC_.out | 6 +- .../CURRENCY_SIGN_WITH_PICTURE_SYMBOL.cob | 2 +- .../CURRENCY_SIGN_WITH_PICTURE_SYMBOL.out | 2 +- .../cobol.dg/group2/REDEFINES__chained.out | 2 +- libgcobol/libgcobol.cc | 259 ++++++++++++++---- 13 files changed, 430 insertions(+), 232 deletions(-) diff --git a/gcc/cobol/compare.cc b/gcc/cobol/compare.cc index eabfe650082a..bca2bd6c4267 100644 --- a/gcc/cobol/compare.cc +++ b/gcc/cobol/compare.cc @@ -1078,6 +1078,32 @@ numeric_alpha_compare(tree &left, compared = true; } } + + if( !compared ) + { + if( left_side.field->type == FldNumericDisplay ) + { + right = integer_zero_node; + + int flags = left_side.all ? 2: 0 + + right_side.all ? 1: 0 ; + + tree right_offset = gg_cast(SIZE_T, refer_offset(right_side)); + tree length_right = refer_size_source(right_side); + tree left_offset = gg_cast(SIZE_T, refer_offset(left_side)); + left = gg_call_expr(INT, + "__gg__compare_numdisp_alpha", + gg_get_address_of(left_side.field->var_decl_node), + left_offset, + gg_get_address_of(right_side.field->var_decl_node), + right_offset, + length_right, + build_int_cst_type(INT, flags), + NULL_TREE); + compared = true; + } + } + if( !compared ) { // The left side is a fixed-point numeric of some kind. First, we pick diff --git a/gcc/cobol/genapi.cc b/gcc/cobol/genapi.cc index 62a8ea918db3..acedc4a72503 100644 --- a/gcc/cobol/genapi.cc +++ b/gcc/cobol/genapi.cc @@ -7573,7 +7573,7 @@ parser_label_goto(struct cbl_label_t *label) void parser_setop( struct cbl_field_t *tgt, - struct cbl_field_t *candidate, + struct cbl_refer_t &candidate, enum setop_t op, struct cbl_field_t *domain) { @@ -7582,7 +7582,7 @@ parser_setop( struct cbl_field_t *tgt, { SHOW_PARSE_HEADER SHOW_PARSE_FIELD(" ", tgt) - SHOW_PARSE_FIELD(" = ", candidate) + SHOW_PARSE_FIELD(" = ", candidate.field) if( op == is_op ) { SHOW_PARSE_TEXT(" is_op ") @@ -7592,13 +7592,13 @@ parser_setop( struct cbl_field_t *tgt, } CHECK_FIELD(tgt); - CHECK_FIELD(candidate); + CHECK_FIELD(candidate.field); CHECK_FIELD(domain); TRACE1 { TRACE1_HEADER - TRACE1_FIELD("parser_setop: ", candidate, "") + TRACE1_REFER("parser_setop: ", candidate, "") TRACE1_TEXT(" ") TRACE1_TEXT(setop_str(op)) TRACE1_FIELD(" ", domain, "") @@ -7610,25 +7610,28 @@ parser_setop( struct cbl_field_t *tgt, switch(op) { case is_op: - switch(candidate->type) + switch(candidate.field->type) { case FldGroup: case FldAlphanumeric: - gg_assign(tgt->var_decl_node, gg_build_relational_expression( - gg_call_expr(INT, - "__gg__setop_compare", - gg_get_address_of(candidate->var_decl_node), - member(domain, "initial"), - NULL_TREE), - ne_op, - integer_zero_node)); + gg_assign(tgt->var_decl_node, + gg_build_relational_expression(gg_call_expr( + INT, + "__gg__setop_compare", + gg_get_address_of(candidate.field->var_decl_node), + refer_offset(candidate), + refer_size_source(candidate), + member(domain, "initial"), + NULL_TREE), + ne_op, + integer_zero_node)); break; default: dbgmsg("%10s in %s:%d", __func__, __FILE__, __LINE__ ); cbl_internal_error("candidate %s has unimplemented % %d(%s)", - candidate->name, - candidate->type, - cbl_field_type_str(candidate->type)); + candidate.field->name, + candidate.field->type, + cbl_field_type_str(candidate.field->type)); gcc_unreachable(); break; } diff --git a/gcc/cobol/genapi.h b/gcc/cobol/genapi.h index 0f20f4dfd337..6cd8eed07e1b 100644 --- a/gcc/cobol/genapi.h +++ b/gcc/cobol/genapi.h @@ -187,7 +187,9 @@ parser_logop( struct cbl_field_t *tgt, void parser_setop( struct cbl_field_t *tgt, - struct cbl_field_t *a, enum setop_t, struct cbl_field_t *b ); + struct cbl_refer_t &candidate, + enum setop_t, + struct cbl_field_t *b ); void parser_bitop( struct cbl_field_t *tgt, diff --git a/gcc/cobol/parse.y b/gcc/cobol/parse.y index 500cd0f49b16..25256c516d18 100644 --- a/gcc/cobol/parse.y +++ b/gcc/cobol/parse.y @@ -4939,7 +4939,11 @@ picture_clause: PIC signed PIC_P[fore] nines } field->set_attr(cbl_field_attr_t($PICTURE.attr)); field->data.apply_picture(*picture.data); - field->blank_initial(picture.data->capacity()); + /* The following odd construction effectively multiplies the + current capacity, which doesn't take stride() into + account, by stride(). */ + field->set_capacity( field->data.capacity()); + field->blank_initial(field->data.capacity()); } | NO_CONDITION { YYERROR; } @@ -6904,13 +6908,13 @@ simple_cond: kind_of_name $$ = new_reference(new_temporary(FldConditional)); // symbol_find does not find FldClass symbols struct symbol_elem_t *e = symbol_field(PROGRAM, 0, $domain); - parser_setop($$->cond(), $1->field, is_op, cbl_field_of(e)); + parser_setop($$->cond(), *$1, is_op, cbl_field_of(e)); } | cexpr NOT CLASS_NAME[domain] { $$ = new_reference(new_temporary(FldConditional)); // symbol_find does not find FldClass symbols struct symbol_elem_t *e = symbol_field(PROGRAM, 0, $domain); - parser_setop($$->cond(), $1->field, is_op, cbl_field_of(e)); + parser_setop($$->cond(), *$1, is_op, cbl_field_of(e)); parser_logop($$->cond(), NULL, not_op, $$->cond()); } | cexpr is OMITTED @@ -15140,6 +15144,7 @@ dialect_words_set( cbl_dialect_t dialect ) { typedef bool (current_tokens_t::*wordop_func_t)(const cbl_loc_t& loc, const cbl_name_t keyword, const cbl_name_t alias); + struct wordop_t { cbl_dialect_t dialect; wordop_func_t op; diff --git a/gcc/cobol/picture.cc b/gcc/cobol/picture.cc index dc988edecaa6..e845c46d0515 100644 --- a/gcc/cobol/picture.cc +++ b/gcc/cobol/picture.cc @@ -74,11 +74,11 @@ namespace picture_validation { */ enum state_t { invalid_e, - none_e, + none_e, boolean_e, - alphabetic_e, + alphabetic_e, unicode_e, - alphanumeric_e, + alphanumeric_e, alpha_ed_e, national_e, national_ed_e, @@ -129,18 +129,18 @@ namespace picture_validation { /* * The followers table enforces the merest of syntax: in a picture string, * what character may follow another? It reproduces ISO table 10 in - * programmatic form. - * + * programmatic form. + * * "The symbol '+' that appears in a column and in a row by itself, * represents its use in the exponent part of character-string-1 for a - * floating-point numeric-edited item. + * floating-point numeric-edited item. * * The symbols '+' and '-' when used as a non-floating insertion symbol * appear in two columns and two rows. The leftmost column and the uppermost * row for these symbols represent their use as the first symbol in * character-string-1. The rightmost column and the lowermost row for these * symbols represent its use as the last or penultimate symbol in - * character-string-1. + * character-string-1. * * The symbol '+' that appears in a column and in a row by itself, * represents its use in the exponent." @@ -160,7 +160,7 @@ namespace picture_validation { /* B0/ */ { { postdec_e, '/' }, {"" "B0/,.Z*+-$9AXVPNECD"} }, // ante & post /* + */ { { exponent_e, '+' }, {"" "9"} }, /* , */ { { antedec_e, com }, {"" "B0/,.Z*+-$9VPE"} }, - /* . */ { { antedec_e, dot }, {"" "B0/,Z*+-$9E"} }, + /* . */ { { antedec_e, dot }, {"" "B0/,Z*+-$9E"} }, /* . */ { { postdec_e, dot }, {"" "B0/,Z*+-$9E"} }, // ante & post /* +- */ { { antedec_e, '+' }, {"" "B0/,.+-Z*$9VPE"} }, /* +- */ { { antedec_e, '-' }, {"" "B0/,.+-Z*$9VPE"} }, @@ -189,7 +189,7 @@ namespace picture_validation { /* CR/DB */ { { postdec_e, 'C' }, {"" "R"} }, /* CR/DB */ { { postdec_e, 'D' }, {"" "B"} }, }; - + //////////////////////////////////////////////////////////////// struct transition_t { @@ -206,13 +206,13 @@ namespace picture_validation { {} bool operator<(const transition_t& that) const { - if (state == that.state) return ch < that.ch; + if (state == that.state) return ch < that.ch; return state < that.state; } bool operator==(const transition_t& that) const { return match(that); } bool operator!=(const transition_t& that) const { return ! match(that); } - protected: + protected: // match verifies that the row returned by std::lower_bound actually // matches, and isn't the next "bigger" one. bool match(const transition_t& that) const { @@ -220,7 +220,7 @@ namespace picture_validation { && ch == that.ch; } }; - + static std::vector picture_rules { // Alpha and Alphanumeric { none_e, 'A', alphabetic_e }, @@ -233,7 +233,7 @@ namespace picture_validation { { none_e, 'P', antedec_e }, { none_e, 'S', antedec_e }, { none_e, 'V', postdec_e, }, // V before 9 - + { none_e, '1', boolean_e }, { boolean_e, '1', boolean_e }, @@ -267,7 +267,7 @@ namespace picture_validation { { alphanumeric_e, 'B', alpha_ed_e }, { alphanumeric_e, '0', alpha_ed_e }, { alphanumeric_e, '/', alpha_ed_e }, - + // National { national_e, 'N', national_e }, { national_e, '\0', alphanumeric_e }, @@ -292,7 +292,7 @@ namespace picture_validation { { none_e, '-', numeric_ed_e }, { none_e, '+', numeric_ed_e }, { none_e, '$', numeric_ed_e }, - + { antedec_e, '9', antedec_e }, { antedec_e, 'A', alphanumeric_e }, { antedec_e, 'P', numeric_e }, @@ -311,10 +311,10 @@ namespace picture_validation { { antedec_e, '$', numeric_ed_e }, { antedec_e, dot, numeric_ed_e }, { antedec_e, com, numeric_ed_e }, - + { postdec_e, '9', numeric_e }, { postdec_e, 'P', numeric_e }, - + { numeric_e, '9', numeric_e }, { numeric_e, 'P', numeric_e }, { numeric_e, 'V', numeric_e }, @@ -344,7 +344,7 @@ namespace picture_validation { { numeric_ed_e, '*', numeric_ed_e }, { numeric_ed_e, '$', numeric_ed_e }, { numeric_ed_e, 'P', numeric_ed_e }, - { numeric_ed_e, 'V', numeric_ed_e }, // See Table 10 if in doubt. + { numeric_ed_e, 'V', numeric_ed_e }, // See Table 10 if in doubt. { numeric_ed_e, 'C', c_need_r_e }, { numeric_ed_e, 'D', d_need_b_e }, @@ -352,7 +352,7 @@ namespace picture_validation { { c_need_r_e, 'R', numeric_ed_e }, { d_need_b_e, 'B', numeric_ed_e }, }; - + typedef std::array automaton_elem_t; typedef std::vector automaton_matrix_t; @@ -369,8 +369,8 @@ namespace picture_validation { if( matrix[rule.state][ch] ) { nextra++; fprintf(stderr, "%s: redundant rule: #%d { %s '%c' %s }\n", - __func__, i, - state_str(rule.state), rule.ch, + __func__, i, + state_str(rule.state), rule.ch, state_str(rule.next_state)); } #endif @@ -380,7 +380,7 @@ namespace picture_validation { if( nextra ) { cbl_internal_error("%s: %d redundant rules", __func__, nextra); } - + ready = true; return matrix; } @@ -390,8 +390,8 @@ namespace picture_validation { * seen: the preceding character and what characters have appeared that * signify alphanumeric-edited or numeric-edited. */ - static constexpr uint64_t hiword(char ch) { - return (1ULL << (ch - 'A')) << 32; + static constexpr uint64_t hiword(char ch) { + return (1ULL << (ch - 'A')) << 32; } class constraint_t { // Domain of symbols in a picture string. @@ -408,18 +408,18 @@ namespace picture_validation { p_nine = 0x0009, // 9, claim the whole nybble // Bits 0-15: punctuation, currency, and 0, 1, and 9. // Bits 32-58: A-Z - p_A = hiword('A'), - p_B = hiword('B'), - p_C = hiword('C'), - p_D = hiword('D'), - p_E = hiword('E'), - p_N = hiword('N'), - p_P = hiword('P'), - p_S = hiword('S'), - p_U = hiword('U'), - p_V = hiword('V'), - p_X = hiword('X'), - p_Z = hiword('Z'), + p_A = hiword('A'), + p_B = hiword('B'), + p_C = hiword('C'), + p_D = hiword('D'), + p_E = hiword('E'), + p_N = hiword('N'), + p_P = hiword('P'), + p_S = hiword('S'), + p_U = hiword('U'), + p_V = hiword('V'), + p_X = hiword('X'), + p_Z = hiword('Z'), p_alphanumeric_e = (p_A | p_X | p_nine), p_b_0_slash_e = (p_B | p_zero | p_slash), @@ -427,8 +427,8 @@ namespace picture_validation { p_national_ed_e = (p_N | p_b_0_slash_e), p_numeric_e = (p_nine | p_P | p_S | p_V), // B P V Z 9 0 / , . + - CR DB * cs (CR/DB not in mask because at end) - p_numeric_ed2_e = (p_b_0_slash_e | p_comma | p_dot | p_plus | p_minus), - p_numeric_ed_e = ( p_P | p_V | p_Z | p_nine | p_b_0_slash_e | + p_numeric_ed2_e = (p_b_0_slash_e | p_comma | p_dot | p_plus | p_minus), + p_numeric_ed_e = ( p_P | p_V | p_Z | p_nine | p_b_0_slash_e | p_comma | p_dot | p_plus | p_minus | p_star | p_cs), }; uint64_t symbol_mask; @@ -442,7 +442,7 @@ namespace picture_validation { } /* - * 13.18.40.3 Syntax rules FORMAT 1 + * 13.18.40.3 Syntax rules FORMAT 1 */ bool is_allowed( char ch ) const { switch( ch ) { @@ -471,7 +471,7 @@ namespace picture_validation { bool is_boolean() const { return symbol_mask == p_one; } bool is_alphabetic() const { return symbol_mask == p_A; } bool is_national() const { return symbol_mask == p_N; } - + bool is_alphanumeric() const { auto bits = symbol_mask & p_alphanumeric_e; return 0 < bits && symbol_mask == bits; @@ -572,7 +572,7 @@ namespace picture_validation { } return true; } - + cbl_loc_t loc; char prior_ch; const char decimal_point; @@ -590,7 +590,7 @@ namespace picture_validation { // 13.18.40.3 Syntax rules #27 No more than 1 of certain character // sequences. This function misinterprets the rule. The rule is not that // e.g. $$,$$ is invalid. the rule is that the list items are mutually - // exclusive, $$Z is invalid. Keeping the structure for now in case needed. + // exclusive, $$Z is invalid. Keeping the structure for now in case needed. #if 0 bool contiguous_ok(char ch) const { int n = 0; @@ -624,7 +624,7 @@ namespace picture_validation { } return true; // contiguous_ok(ch); } - + public: const char *bad_repeat; @@ -639,7 +639,7 @@ namespace picture_validation { , bad_repeat(nullptr) { // Trim trailing punctuation from picture for later revalidation, because - // we do. + // we do. auto pic = xstrdup(picture); auto pend = pic + strlen(pic); if( pic < --pend ) { @@ -655,7 +655,7 @@ namespace picture_validation { bool append( char ch, size_t len ) { if( prior_ch == '\0' ) { switch(ch) { - case 'S': case '+': case '-': + case 'S': case '+': case '-': field_attr |= signable_e; } } @@ -666,7 +666,7 @@ namespace picture_validation { picsym_set(ch); // emits message about invalid combinations if( ! is_allowed(ch) ) { return false; } - + prior_ch = ch; add_capacity(len? len : 1); observe_the_dot(ch); @@ -675,7 +675,7 @@ namespace picture_validation { } inline void move_caret( int n ) { loc += n; } bool has_s_star() const { return both(p_S, p_star); } - + void extra_dot( size_t pos ) { if( field_data.picture[pos] != '\0') { assert(field_data.picture[pos+1] == '\0'); @@ -693,12 +693,12 @@ namespace picture_validation { case 'U': case 'Z': case '*': case 'B': case '0': // B and 0 but not slash - case '$': case '+': case '-': + case '$': case '+': case '-': return true; } return false; } - + char prior() const { return prior_ch; } cbl_field_data_t data() const { return field_data; } uint64_t attr() const { return field_attr; } @@ -720,7 +720,7 @@ namespace picture_validation { void maybe_signable( char ch ) { switch(TOUPPER(ch)) { - case '+': case '-': + case '+': case '-': field_attr |= signable_e; } dbgmsg("%s: '%c', %ssignable", __func__, @@ -736,7 +736,7 @@ namespace picture_validation { break; } } - + /* * The followers table is sensitive to whether we've seen decimal point, and * whether we're in an exponent. That reflects the duplicate column @@ -745,14 +745,14 @@ namespace picture_validation { bool day_follows_night( char ch ) const { const static std::string domain("*+,-./019ABENPSVXZCRDB"); return std::string::npos != domain.find(ch); - + auto p = followers.find( follow_key_t {pic_state, prior_ch} ); if( p != followers.end() ) { const auto& candidates(p->second); auto pnext = std::find( candidates.begin(), candidates.end(), ch ); return pnext != candidates.end(); } - return false; + return false; } inline bool first_dollar( char ch ) { return ch == '$' && ndollar == 0; } @@ -765,27 +765,30 @@ namespace picture_validation { * + (count of $ minus 1) + (count of - minus one) + (count of + minus 1) * 3) data.rdigits is the subset of 2 that is to the right of either V or * . (edited)  - * - * For the moment, break out the fact that V should add zero.  Right now - * all of the regression tests assume that V, if there, adds one.  I would - * really rather attack the V change when everything is working. */ void add_capacity(int n) { - static const std::string nonsize( "P" ); // do not exclude V from capacity for now - if( prior_ch == 'P' ) { + switch( prior_ch ) { + case 'V': + n = 0; // only in debug message + break; + case 'P': np += n; field_attr |= scaled_e; // P in front has positive rdigit less one; P aft is negative rdigit. - int ndigit = only(p_P | p_S)? (1 < np? n : n - 1) : -n; - field_data.rdigits += ndigit; - } else { + { + int ndigit = only(p_P | p_S)? (1 < np? n : n - 1) : -n; + field_data.rdigits += ndigit; + } + n = 0; // only in debug message + break; + default: field_data.add_capacity(n); if( digital() ) { - field_data.digits += n; + field_data.digits += n; if( pic_state == postdec_e ) { field_data.rdigits += n; } - } else { n = 0; } // for debug + } } dbgmsg("%s: '%c', added %d: {%u, %u,%d}", __func__, prior_ch, n, field_data.capacity(), field_data.digits, field_data.rdigits); @@ -801,7 +804,7 @@ namespace picture_validation { case '9': case 'Z': case '*': return true; case 'V': - return true; + return false; case '+': return 0 < nplus++; case '-': @@ -860,7 +863,7 @@ class picture_t : public lex_picture_t { { attr = none_e; pos = 0; - blank_when_zero_ok = true; + blank_when_zero_ok = true; type = FldInvalid; encoding = current_encoding('A'); data = new cbl_field_data_t; @@ -926,10 +929,10 @@ class picture_t : public lex_picture_t { } }; -lex_picture_t +lex_picture_t is_valid_picture(const cbl_loc_t& loc, const char picture[]) { picture_validation::constraint_t constraint(loc, picture); - + const picture_validation::automaton_matrix_t& automaton = picture_validation::prepare_automaton(); @@ -944,11 +947,11 @@ is_valid_picture(const cbl_loc_t& loc, const char picture[]) { * If a currency has a symbol, width is set to its length until appended, * then becomes 1. */ - size_t width = 0; + size_t width = 0; for( ; p < epicture; p++, output.pos++ ) { // Advance lookahead past any count, which might be a name. - // No picture begins with a '('. + // No picture begins with a '('. if( *p == '(' && p+1 < epicture ) { if( constraint.repeatable() ) { const char *paren = p; @@ -982,15 +985,15 @@ is_valid_picture(const cbl_loc_t& loc, const char picture[]) { } char ch = TOUPPER(*p); - - // Is the current character ever allowed to follow the prior? + + // Is the current character ever allowed to follow the prior? if( ! constraint.day_follows_night(ch) || constraint.first_dollar(ch)) { const char *currency = symbol_currency(ch); if( currency ) { ch = '$'; width = width == 0? strlen(currency) : 1; } else { - dbgmsg("%s:%d: no %2lu: %c -> %c (%s)\n", __func__, __LINE__, + dbgmsg("%s:%d: no %2lu: %c -> %c (%s)\n", __func__, __LINE__, (unsigned long)(p - picture), constraint.prior(), ch, picture_validation::state_str(constraint.picture_state())); return output; @@ -1009,8 +1012,8 @@ is_valid_picture(const cbl_loc_t& loc, const char picture[]) { constraint.maybe_signable(state); } else { state = picture_validation::invalid_e; - } - + } + if( state == picture_validation::invalid_e ) { dbgmsg("%s:%d: automaton has no transition for %s '%c'", __func__, __LINE__, old_state, ch); @@ -1067,12 +1070,12 @@ process_file(const char* filename) { return false; } } - + char *picture = nullptr; size_t plen = 0; ssize_t len; int lineno = 0; - + while( (len = getline(&picture, &plen, input)) != -1 ) { auto p = std::find(picture, picture + len, '\n'); if( p < picture + len ) *p = '\0'; @@ -1084,7 +1087,7 @@ process_file(const char* filename) { int main(int argc, char* argv[]) { int opt; - bool fOK; + bool fOK; const char *picture = nullptr; while ((opt = getopt(argc, argv, "p:v")) != -1) { @@ -1109,7 +1112,7 @@ main(int argc, char* argv[]) { fOK = process_file(nullptr); } } - + return fOK ? 0 : 1; } diff --git a/gcc/cobol/scan_ante.h b/gcc/cobol/scan_ante.h index 99387eae60c9..00ea991cbd34 100644 --- a/gcc/cobol/scan_ante.h +++ b/gcc/cobol/scan_ante.h @@ -353,8 +353,8 @@ static bool level_needed() { /* * Return all but the first N characters, to be rescanned by the nexst yylex. - * IOW, keep N characters as the token, and relinquish the rest. - * Must be a macro because it expands yyless. + * IOW, keep N characters as the token, and relinquish the rest. + * Must be a macro because it expands yyless. */ #define myless(N) \ do { \ @@ -425,11 +425,11 @@ class enter_leave_t { /* * The lexer knows the immediate status of the input file and its line number * from the PUSH, POP, and LINE directives. It saves yylineno whenever it - * encounters a PUSH, and updates it for a POP. + * encounters a PUSH, and updates it for a POP. * * The line number trickles into the parser by way of location. Only the * parser knows what token it is parsing. As for the filename, the lexer - * queues enter/leave notices for the parser. + * queues enter/leave notices for the parser. * * Whenever the parser fetches a token, it gets the current line number from * yylineno, and the current filename by depleting the notification queue, if @@ -532,8 +532,8 @@ trim_location( int nkeep) { yylloc.last_column = 1 + (eokeep - nl); } - gcc_assert( yylloc.first_line <= yylloc.last_line ); - gcc_assert( 0 < yylloc.last_column ); + gcc_assert( yylloc.first_line <= yylloc.last_line ); + gcc_assert( 0 < yylloc.last_column ); ////location_dump(__func__, __LINE__, "yylloc", yylloc, true); } @@ -591,7 +591,7 @@ static char *tmpstring = NULL; // map of alias => canonical static std::map keyword_aliases; -std::pair +std::pair keyword_alias_add( const std::string& keyword, const std::string& alias ) { auto elem = std::make_pair(alias, keyword); auto result = keyword_aliases.insert(elem); @@ -610,37 +610,37 @@ struct bint_t { bool signable; }; static const std::map binary_integers { - { "BINARY", { COMPUTATIONAL, FldNumericBinary, 0, false } }, - { "COMP", { COMPUTATIONAL, FldNumericBinary, 0, false } }, - { "COMPUTATIONAL", { COMPUTATIONAL, FldNumericBinary, 0, false } }, - { "COMP-4", { COMPUTATIONAL, FldNumericBinary, 0, false } }, - { "COMPUTATIONAL-4", { COMPUTATIONAL, FldNumericBinary, 0, false } }, - - { "BINARY-CHAR", { _BINARY_INTEGER, FldNumericBin5, 1, true } }, - { "BINARY-SHORT", { _BINARY_INTEGER, FldNumericBin5, 2, true } }, - { "BINARY-LONG", { _BINARY_INTEGER, FldNumericBin5, 4, true } }, - { "BINARY-DOUBLE", { _BINARY_INTEGER, FldNumericBin5, 8, true } }, - { "BINARY-LONG-LONG", { _BINARY_INTEGER, FldNumericBin5, 8, true } }, - - { "COMP-5", { COMPUTATIONAL, FldNumericBin5, 0, false } }, - { "COMPUTATIONAL-5", { COMPUTATIONAL, FldNumericBin5, 0, false } }, - { "COMP-X", { COMPUTATIONAL, FldNumericBin5, 0xFF, false } }, - { "COMPUTATIONAL-X", { COMPUTATIONAL, FldNumericBin5, 0xFF, false } }, - - { "COMP-1", { COMPUTATIONAL, FldFloat, 4, false } }, - { "COMPUTATIONAL-1", { COMPUTATIONAL, FldFloat, 4, false } }, - { "FLOAT-BINARY-32", { COMPUTATIONAL, FldFloat, 4, false } }, - { "FLOAT-SHORT", { COMPUTATIONAL, FldFloat, 4, false } }, - - { "COMP-2", { COMPUTATIONAL, FldFloat, 8, false } }, - { "COMPUTATIONAL-2", { COMPUTATIONAL, FldFloat, 8, false } }, - { "FLOAT-BINARY-64", { COMPUTATIONAL, FldFloat, 8, false } }, - { "FLOAT-LONG", { COMPUTATIONAL, FldFloat, 8, false } }, - { "FLOAT-BINARY-128", { COMPUTATIONAL, FldFloat, 16, false } }, - { "FLOAT-EXTENDED", { COMPUTATIONAL, FldFloat, 16, false } }, - - { "COMP-6", { COMPUTATIONAL, FldPacked, 0, false } }, - { "COMPUTATIONAL-6", { COMPUTATIONAL, FldPacked, 0, false } }, + { "BINARY", { COMPUTATIONAL, FldNumericBinary, 0, false } }, + { "COMP", { COMPUTATIONAL, FldNumericBinary, 0, false } }, + { "COMPUTATIONAL", { COMPUTATIONAL, FldNumericBinary, 0, false } }, + { "COMP-4", { COMPUTATIONAL, FldNumericBinary, 0, false } }, + { "COMPUTATIONAL-4", { COMPUTATIONAL, FldNumericBinary, 0, false } }, + + { "BINARY-CHAR", { _BINARY_INTEGER, FldNumericBin5, 1, true } }, + { "BINARY-SHORT", { _BINARY_INTEGER, FldNumericBin5, 2, true } }, + { "BINARY-LONG", { _BINARY_INTEGER, FldNumericBin5, 4, true } }, + { "BINARY-DOUBLE", { _BINARY_INTEGER, FldNumericBin5, 8, true } }, + { "BINARY-LONG-LONG", { _BINARY_INTEGER, FldNumericBin5, 8, true } }, + + { "COMP-5", { COMPUTATIONAL, FldNumericBin5, 0, false } }, + { "COMPUTATIONAL-5", { COMPUTATIONAL, FldNumericBin5, 0, false } }, + { "COMP-X", { COMPUTATIONAL, FldNumericBin5, 0xFF, false } }, + { "COMPUTATIONAL-X", { COMPUTATIONAL, FldNumericBin5, 0xFF, false } }, + + { "COMP-1", { COMPUTATIONAL, FldFloat, 4, false } }, + { "COMPUTATIONAL-1", { COMPUTATIONAL, FldFloat, 4, false } }, + { "FLOAT-BINARY-32", { COMPUTATIONAL, FldFloat, 4, false } }, + { "FLOAT-SHORT", { COMPUTATIONAL, FldFloat, 4, false } }, + + { "COMP-2", { COMPUTATIONAL, FldFloat, 8, false } }, + { "COMPUTATIONAL-2", { COMPUTATIONAL, FldFloat, 8, false } }, + { "FLOAT-BINARY-64", { COMPUTATIONAL, FldFloat, 8, false } }, + { "FLOAT-LONG", { COMPUTATIONAL, FldFloat, 8, false } }, + { "FLOAT-BINARY-128", { COMPUTATIONAL, FldFloat, 16, false } }, + { "FLOAT-EXTENDED", { COMPUTATIONAL, FldFloat, 16, false } }, + + { "COMP-6", { COMPUTATIONAL, FldPacked, 0, false } }, + { "COMPUTATIONAL-6", { COMPUTATIONAL, FldPacked, 0, false } }, }; static int @@ -657,10 +657,10 @@ binary_integer_usage( const char name[]) { std::string key = uname; auto alias = keyword_aliases.find(key); if( alias != keyword_aliases.end() ) key = alias->second; - + auto p = binary_integers.find(key); if( p == binary_integers.end() ) return 0; - + yylval.computational.type = p->second.type; yylval.computational.capacity = p->second.capacity; yylval.computational.signable = p->second.signable; @@ -669,7 +669,7 @@ binary_integer_usage( const char name[]) { free(uname); return p->second.token; } - + static void verify_ws( char ch ) { if( ! fisspace(ch) ) { @@ -712,7 +712,7 @@ level_of( const char input[] ) { /* * Input may have leading or trailing V, which is ignored. - * Return the decoded picture size insofar as possible. + * Return the decoded picture size insofar as possible. * If the picture switches from 9s to Ps, say, set pleft to the remainder. */ static int @@ -721,7 +721,7 @@ ndigit(int len, const char **pleft = nullptr) { if( TOUPPER(p[0]) == 'V' ) p++; if( p == pend ) return 0; // Only the V int n = 0; - + for( char model = *p; p < pend; p++ ) { assert(*p == model); n++; @@ -729,7 +729,7 @@ ndigit(int len, const char **pleft = nullptr) { std::pair result = repeat_count(p); int count = result.first, pos = result.second; - + if( pos == -1 ) { if( pleft ) *pleft = ++p; // because *p at least was ok, per assertion. break; @@ -804,7 +804,7 @@ symbol_exists( const char name[] ) { /* * Before data division has been defined and the cache populated, or if the * map search failes, search the symbol table in case of named literal. - */ + */ symbol_elem_t *e = symbol_field( PROGRAM, 0, name ); return e; } @@ -817,8 +817,8 @@ typed_name( const char name[] ) { int token = repository_function_tok(name); switch(token) { case 0: - if(false) // we don't know how to do this yet. - { // Functions in the symbol table may be used without the FUNCTION keyword. + if(false) // we don't know how to do this yet. + { // Functions in the symbol table may be used without the FUNCTION keyword. cbl_label_t *L = symbol_function_any(0, name); if( L ) { auto args = prototype_args(L->name); @@ -952,7 +952,7 @@ static void yyunput(int ch, char yytext_ptr[]); static int continue_string( char quote ) { int ch; - + for( ; (ch = yyinput()) != quote; yylloc.last_column++ ) { switch(ch) { case EOF: case 0: return ch; @@ -1077,7 +1077,7 @@ unquote() { char *output = xstrdup(yytext), quote = *p; char prior = '\0'; - pend = std::copy_if( ++p, --pend, output, + pend = std::copy_if( ++p, --pend, output, [quote, &prior]( char ch ) { if( ch == quote ) { if( ch == prior ) { @@ -1091,4 +1091,3 @@ unquote() { *pend = '\0'; return output; } - diff --git a/gcc/cobol/symbols.cc b/gcc/cobol/symbols.cc index db64208fabfc..9dc547dc24c0 100644 --- a/gcc/cobol/symbols.cc +++ b/gcc/cobol/symbols.cc @@ -1907,7 +1907,7 @@ symbols_update( size_t first, bool parsed_ok ) { if( !field->is_valid() ) { size_t isym = p - symbols_begin(); - symbols_dump(symbols.first_program, true); + symbols_dump(symbols.first_program + 18, true); if( symbol_at(field->parent)->type == SymFile ) { assert(field->parent == field_index(field) + 1); auto e = std::find_if( symbols_begin(field->parent), symbols_end(), @@ -2081,7 +2081,7 @@ symbols_update( size_t first, bool parsed_ok ) { } if( parsed_ok ) { parser_file_add(&file); - update_symbol_map2(file); // Add FD name as a name for the default record. + update_symbol_map2(file); // Add FD name as a name for the default record. } } else { if( p->type == SymField ) { @@ -3086,7 +3086,7 @@ struct symbol_elem_t * symbol_file( size_t program, const char name[] ) { auto key( elem_key_t(program, name) ); auto p = symbols.files.find(key); - + if( p == symbols.files.end() ) { // Look for global FD in containing program. while( key.program ) { key.program = symbol_at(key.program)->program; @@ -3105,7 +3105,7 @@ symbol_file( size_t program, const char name[] ) { name, (unsigned long)p->second); auto e = symbol_at(p->second); return e; - } + } dbgmsg("%s:%d: not found: %s", __func__, __LINE__, name); return nullptr; @@ -3700,7 +3700,7 @@ static class program_temporaries_t : private symbol_temporaries_t { alphas.clear(); } } program_temporaries; - + /* * Supply a reference to the current list of temporaries for use by codegen to free * the memory if it decides to return to the caller. @@ -4853,7 +4853,7 @@ expand_picture(const char *picture) if( currency_symbol ) { size_t sign_length = __gg__currency_signs[currency_symbol].size(); - assert(0 < sign_length); + assert(0 < sign_length); if( --sign_length ) { char *pcurrency = strchr(retval, currency_symbol); @@ -4870,6 +4870,9 @@ expand_picture(const char *picture) } retval[dest_length] = NULLCH; + // The 'V' + + // To ease the workload on interpreting the PICTURE string at run time, we // are going to convert everything we can to upper case. We also convert // V to decimal point, for the same reason. Characters that might be @@ -4886,18 +4889,15 @@ expand_picture(const char *picture) case ascii_s: case ascii_x: case ascii_z: - retval[i] = TOUPPER(retval[i]); - break; - case ascii_V: case ascii_v: - retval[i] = __gg__decimal_point; + retval[i] = TOUPPER(retval[i]); break; // We need special processing for DB. When they appear as the final two // characters, they are the accounting sign "DB" indicator and we have to - // leave the case as the programmer established it. Otherwise we have to + // leave the case as the programmer established it. Otherwise we have to // make the 'B' uppercase. - + case ascii_B: case ascii_b: if( i < dest_length-1 ) @@ -4915,6 +4915,13 @@ expand_picture(const char *picture) } } + // The V character is virtual in numeric_editing, so get rid of it + char *pV = strchr(retval, ascii_V); + if( pV ) + { + memmove(pV, pV+1, strlen(pV)); + } + // AD HOC FIX for an improper trailing space char *pspace = strchr(retval, ascii_space); if( pspace ) @@ -4938,23 +4945,23 @@ expand_expanded(char *expanded) /* In order to make __gg__string_to_numeric_edited() run quickly, we are going to process the expanded picture string especially for it. What we do here: - + Convert B to space, taking care not to touch a final 'DB' Find the currency picture symbol - + Find the span of any '$$', '++', '--' 'Z', and '*' runs. For any '$$', '++' and '--' runs, replace the first such char with a space, and all the others with '9' - + For any 'Z' and '*' runs, replace all the characters with '9'. - + Figure out if any of the original picture characters are '9'. - + That information gets encoded into six characters that are appended to - the modified string. - + the modified string. + Offset 0: The currency character Offset 1: The floating character (space if empty) Offset 2-3: The starting index of the float. @@ -4962,7 +4969,7 @@ expand_expanded(char *expanded) When there are '9' characters in the original, the 0x40 bit of offset 2 is turned on, turning '0'-'9' into 'q'-'y' - + Is everybody ready? Then we'll begin. */ int length_d = strlen(expanded); @@ -5804,7 +5811,7 @@ cbl_file_t::filename_of() const { if( filename != 0 ) { return cbl_field_of(symbol_at(filename))->name; } if( device != 0 ) { auto dev = cbl_special_name_of(symbol_at(device)); - if( dev->os_filename[0] != '\0' ) return dev->os_filename; + if( dev->os_filename[0] != '\0' ) return dev->os_filename; } return nullptr; } diff --git a/gcc/testsuite/cobol.dg/group2/ALLOCATE_Rules_6_-_9._Without_OPTION_INITIALIZE_Without_-fdefaultbyte___ASCII_.out b/gcc/testsuite/cobol.dg/group2/ALLOCATE_Rules_6_-_9._Without_OPTION_INITIALIZE_Without_-fdefaultbyte___ASCII_.out index 1cf642bf9155..0c30f30451ce 100644 --- a/gcc/testsuite/cobol.dg/group2/ALLOCATE_Rules_6_-_9._Without_OPTION_INITIALIZE_Without_-fdefaultbyte___ASCII_.out +++ b/gcc/testsuite/cobol.dg/group2/ALLOCATE_Rules_6_-_9._Without_OPTION_INITIALIZE_Without_-fdefaultbyte___ASCII_.out @@ -1,6 +1,6 @@ allocate characters INITIALIZED (ISO 2023 Rule 6: defaultbyte if specified, else zero) (1) as allocated - "" "000" 0x0000000000000000 + "" "" 0x0000000000000000 (2) after "initialize based-var" " " "000" 0x0000000000000000 (3) after "initialize based-var all to value" @@ -14,14 +14,14 @@ allocate based-var initialized (ISO 2023 Rule 7: ALL TO VALUE) "I am I, Don Quixote " "123" 0x0000000000000000 allocate characters (ISO 2023 Rule 8: OPT_INIT if specified, otherwise defaultbyte, otherwise zero) (1) as allocated - "" "000" 0x0000000000000000 + "" "" 0x0000000000000000 (2) after "initialize based-var" " " "000" 0x0000000000000000 (3) after "initialize based-var all to value" "I am I, Don Quixote " "123" 0x0000000000000000 allocate based-var (ISO 2023 Rule 9: pointers NULL, otherwise OPT_INIT) (1) as allocated - "" "000" 0x0000000000000000 + "" "" 0x0000000000000000 (2) after "initialize based-var" " " "000" 0x0000000000000000 (3) after "initialize based-var all to value" diff --git a/gcc/testsuite/cobol.dg/group2/ALLOCATE_Rules_6_-_9._Without_OPTION_INITIALIZE_Without_-fdefaultbyte___EBCDIC_.out b/gcc/testsuite/cobol.dg/group2/ALLOCATE_Rules_6_-_9._Without_OPTION_INITIALIZE_Without_-fdefaultbyte___EBCDIC_.out index 1cf642bf9155..0c30f30451ce 100644 --- a/gcc/testsuite/cobol.dg/group2/ALLOCATE_Rules_6_-_9._Without_OPTION_INITIALIZE_Without_-fdefaultbyte___EBCDIC_.out +++ b/gcc/testsuite/cobol.dg/group2/ALLOCATE_Rules_6_-_9._Without_OPTION_INITIALIZE_Without_-fdefaultbyte___EBCDIC_.out @@ -1,6 +1,6 @@ allocate characters INITIALIZED (ISO 2023 Rule 6: defaultbyte if specified, else zero) (1) as allocated - "" "000" 0x0000000000000000 + "" "" 0x0000000000000000 (2) after "initialize based-var" " " "000" 0x0000000000000000 (3) after "initialize based-var all to value" @@ -14,14 +14,14 @@ allocate based-var initialized (ISO 2023 Rule 7: ALL TO VALUE) "I am I, Don Quixote " "123" 0x0000000000000000 allocate characters (ISO 2023 Rule 8: OPT_INIT if specified, otherwise defaultbyte, otherwise zero) (1) as allocated - "" "000" 0x0000000000000000 + "" "" 0x0000000000000000 (2) after "initialize based-var" " " "000" 0x0000000000000000 (3) after "initialize based-var all to value" "I am I, Don Quixote " "123" 0x0000000000000000 allocate based-var (ISO 2023 Rule 9: pointers NULL, otherwise OPT_INIT) (1) as allocated - "" "000" 0x0000000000000000 + "" "" 0x0000000000000000 (2) after "initialize based-var" " " "000" 0x0000000000000000 (3) after "initialize based-var all to value" diff --git a/gcc/testsuite/cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.cob b/gcc/testsuite/cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.cob index 6c742266f396..e6eb052e0ecc 100644 --- a/gcc/testsuite/cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.cob +++ b/gcc/testsuite/cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.cob @@ -14,7 +14,7 @@ DATA DIVISION. WORKING-STORAGE SECTION. 77 euro-val pic 99v99. - 77 EUROS PIC @99v99. + 77 EUROS PIC @99.99. 77 cents PIC 9,999&. 77 DOLLARS Pic $$,$$9.99. diff --git a/gcc/testsuite/cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.out b/gcc/testsuite/cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.out index 3618adb6b0d0..861e65a2826a 100644 --- a/gcc/testsuite/cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.out +++ b/gcc/testsuite/cobol.dg/group2/CURRENCY_SIGN_WITH_PICTURE_SYMBOL.out @@ -1,4 +1,4 @@ -#EUR 01.23# equal #1,234 ct (EUR)# +#EUR 12.34# equal #1,234 ct (EUR)# Invoice amount #1 is $US1,500.00. Invoice amount #2 is $US12.34. diff --git a/gcc/testsuite/cobol.dg/group2/REDEFINES__chained.out b/gcc/testsuite/cobol.dg/group2/REDEFINES__chained.out index 56f7d295638a..ce2b80c666e2 100644 --- a/gcc/testsuite/cobol.dg/group2/REDEFINES__chained.out +++ b/gcc/testsuite/cobol.dg/group2/REDEFINES__chained.out @@ -1,6 +1,6 @@ "123456789" "6789" -"123456780" +"12345678X" "12345678X" "X" diff --git a/libgcobol/libgcobol.cc b/libgcobol/libgcobol.cc index fec2198ea0fc..2d2100de2cf9 100644 --- a/libgcobol/libgcobol.cc +++ b/libgcobol/libgcobol.cc @@ -2617,6 +2617,8 @@ extern "C" int __gg__setop_compare( const cblc_field_t *candidate_field, + size_t candidate_offset, + size_t candidate_size, char *domain) { // This routine is called to compare the characters of 'candidate' @@ -2639,8 +2641,8 @@ __gg__setop_compare( size_t nbytes_converted; const char *candidate = __gg__iconverter(candidate_field->encoding, HOST_32_ENCODING, - candidate_field->data, - candidate_field->capacity, + candidate_field->data+candidate_offset, + candidate_size, &nbytes_converted); const char *candidate_end = candidate + nbytes_converted; while(candidate < candidate_end) @@ -3364,7 +3366,6 @@ format_for_display_internal(char **dest, + (var->attr & leading_e ? 1 : 0); unsigned char *signloc; unsigned char *digits; - const unsigned char *digits_r = nullptr; // This is the running index into our output destination. int index = 0; bool is_negative=false; @@ -3378,7 +3379,6 @@ format_for_display_internal(char **dest, // not signable signloc = converted; digits = converted; - digits_r = converted + outlength; is_negative = false; break; case 4: @@ -3386,7 +3386,6 @@ format_for_display_internal(char **dest, // internal trailing signloc = converted + outlength-1; digits = converted; - digits_r = converted + outlength; /* In ascii, negative is indicated by turning bit 0x40 on. In ebcdic, by turning bit 0x20 off. In both cases, the result is outside of the range '0' through '9'. Working this way is @@ -3474,7 +3473,6 @@ format_for_display_internal(char **dest, // internal leading signloc = converted; digits = converted; - digits_r = converted + outlength; const charmap_t *charmap_src = __gg__get_charmap(var->encoding); if( charmap_src->is_like_ebcdic() ) { @@ -3555,7 +3553,6 @@ format_for_display_internal(char **dest, // separate trailing signloc = converted + outlength-1; digits = converted; - digits_r = converted + outlength-1; switch(*signloc) { case ascii_plus: @@ -3578,7 +3575,6 @@ format_for_display_internal(char **dest, // separate leading signloc = converted; digits = converted+1; - digits_r = converted + outlength; is_negative = *signloc == ascii_minus; switch(*signloc) { @@ -3598,21 +3594,9 @@ format_for_display_internal(char **dest, break; } } - // We have the sign sorted out; make sure that the digits are valid: - unsigned char *running_location = digits; - while(running_location < digits_r) - { - if( *running_location < ascii_0 || *running_location > ascii_9 ) - { - // An invalid digit becomes '0', and the value is flagged positive - *running_location = ascii_0; - is_negative = false; - } - running_location += 1; - } - // converted[] is now full of valid digits, and is_negative has been - // established. + // is_negative has been established. Everything but the sign byte is + // shown verbatim. switch(signtype) { @@ -3637,7 +3621,7 @@ format_for_display_internal(char **dest, (*dest)[index++] = is_negative ? ascii_minus : ascii_plus; break; } - running_location = digits; + const unsigned char *running_location = digits; // copy over the characters to the left of the decimal point: for(int i=0; idigits + ( fsource->rdigits < 0 - ? -fsource->rdigits : 0) ; + // We are moving a integer NumericDisplay to an alphanumeric. + // In accordance with the specification, we skip any separate + // sign character. We also turn a sign character into its + // positive form, and then do the move verbatim. + char ach_source[256]; + memcpy(ach_source, fsource->data + source_offset, source_size); + + char *source_p = ach_source; + + charmap_t *charmap_source = __gg__get_charmap(fsource->encoding); + int source_stride = charmap_source->stride(); + cbl_char_t source_zero = + charmap_source->mapped_character(ascii_zero); + + int ssl = (fsource->attr & signable_e ? 4 : 0 ) + + (fsource->attr & separate_e ? 2 : 0 ) + + (fsource->attr & leading_e ? 1 : 0 ); + switch(ssl) + { + case 0: + case 1: + case 2: + case 3: + // not signable + break; + case 4: + { + // signable, internal, trailing. + char *signloc = source_p + source_size - source_stride; + if( charmap_source->is_big_endian() && signloc) + { + signloc += source_stride-1; + } + if( charmap_source->is_like_ebcdic() ) + { + // Turn on the "ebcdic is positive" bit. + *signloc |= 0x20; + } + else + { + // Turn off the "ascii is negative" bit. + *signloc &= ~0x40; + } + break; + } + case 5: + { + // signable, internal, leading. + char *signloc = source_p; + if( charmap_source->is_big_endian() && signloc) + { + signloc += source_stride-1; + } + if( charmap_source->is_like_ebcdic() ) + { + // Turn on the "ebcdic is positive" bit. + *signloc |= 0x20; + } + else + { + // Turn off the "ascii is negative" bit. + *signloc &= ~0x40; + } + break; + } + case 6: + { + // signable, separate, trailing. + char *signloc = source_p + source_size - source_stride; + source_size -= 1; + if( charmap_source->is_big_endian() && signloc) + { + signloc += source_stride-1; + } + if( charmap_source->is_like_ebcdic() ) + { + // Turn on the "ebcdic is positive" bit. + *signloc |= 0x20; + } + else + { + // Turn off the "ascii is negative" bit. + *signloc &= ~0x40; + } + break; + } + case 7: + { + // signable, separate, leading. + char *signloc = source_p; + source_size -= source_stride; + source_p += source_stride; + if( charmap_source->is_big_endian() && signloc) + { + signloc += source_stride-1; + } + if( charmap_source->is_like_ebcdic() ) + { + // Turn on the "ebcdic is positive" bit. + *signloc |= 0x20; + } + else + { + // Turn off the "ascii is negative" bit. + *signloc &= ~0x40; + } + break; + } + } + // source_p, source_size, and signloc (if any) have been + // adjusted. - // Pick up the absolute value of the source - value = __gg__int128_from_qualified_field(fsource, - source_offset, - source_size); - char ach[128]; + if( fsource->attr & scaled_e ) + { + if( fsource->rdigits < 0 ) + { + // We are dealing with 9999PPP. We need to tack zeroes onto + // the end of source_p + charmap_source->memset(source_p+source_size, + source_zero, + -fsource->rdigits * source_stride); + source_size += -fsource->rdigits * source_stride; + } + else + { + // We are dealing with PPP999, and we need to insert zeroes + // at the front of source_p: + memmove(source_p + fsource->rdigits * source_stride, + source_p, + fsource->rdigits * source_stride); + charmap_source->memset(source_p, + source_zero, + fsource->rdigits * source_stride); + source_size += fsource->rdigits * source_stride; + } + } - // Convert it to the full complement of digits available - // from the source...but no more - __gg__binary_to_string_encoded(ach, - source_digits, - value, - fdest->encoding); + // We convert the source to the destination character set + size_t nbytes; + char *converted = __gg__iconverter(fsource->encoding, + fdest->encoding, + source_p, + source_size, + &nbytes); if( !(fdest->attr & rjust_e) ) { - min_length = std::min( source_digits*stride, + min_length = std::min( source_size, dest_size); - memmove(fdest->data + dest_offset, ach, min_length); + memmove(fdest->data + dest_offset, converted, min_length); if( min_length < dest_size ) { // min_length is smaller than dest_length, so we @@ -6464,14 +6572,13 @@ __gg__move( cblc_field_t *fdest, { // Destination is right-justified, so things are // slightly more complex - if( source_digits*stride >= dest_size ) + if( source_size >= dest_size ) { // We need to truncate the source data on the // left: - memmove( - fdest->data + dest_offset, - ach + (source_digits*stride - dest_size), - dest_size ); + memmove(fdest->data + dest_offset, + converted + (source_size - dest_size), + dest_size ); } else { @@ -6479,12 +6586,12 @@ __gg__move( cblc_field_t *fdest, // the right side of the destination, and space-fill // the prefix: memmove(fdest->data - + dest_offset + (dest_size - source_digits*stride), - ach, - source_digits*stride ); + + dest_offset + (dest_size - source_size), + converted, + source_size ); charmap->memset( fdest->data + dest_offset, - charmap->mapped_character(ascii_space), - dest_size - source_digits*stride); + charmap->mapped_character(ascii_space), + dest_size - source_size); } } } @@ -13918,3 +14025,49 @@ __gg__move_stash_release(const unsigned char *stash) move_stashes.depth -= 1; } + +extern "C" +int +__gg__compare_numdisp_alpha( cblc_field_t *left, + size_t left_offset, + cblc_field_t *right, + size_t right_offset, + size_t right_length, + int flags) + { + // 'left' is numdisp. We MOVE it to an alphanumeric of the correct size. + charmap_t *charmap_left = __gg__get_charmap(left->encoding); + size_t left_size = left->capacity; + if( left->attr & separate_e ) + { + left_size -= charmap_left->stride(); + } + + cblc_field_t numdisp = {}; + unsigned char numdisp_data[256]; + + numdisp.type = FldAlphanumeric; + numdisp.encoding = left->encoding; + numdisp.data = numdisp_data, + numdisp.capacity = left_size; + __gg__move( &numdisp, + 0, // Offset + numdisp.capacity, + left, + left_offset, + left->capacity, + 0, + truncation_e ); + + int retval; + retval = __gg__compare(&numdisp, + 0, + numdisp.capacity, + flags & 2 ? REFER_T_MOVE_ALL : 0, + right, + right_offset, + right_length, + flags & 1 ? REFER_T_MOVE_ALL : 0, + 0 ); + return retval; + } From cef3a8a6d6de57c166c09464db4d1cf3ce57fd1d Mon Sep 17 00:00:00 2001 From: Andrew MacLeod Date: Fri, 18 Sep 2026 19:25:48 -0400 Subject: [PATCH 477/584] Handle inferred ranges like outgoing edges in range_cache. The current range_from_dom routine walks from the USE to the DEF block along via dominators. Along the way it marks blocks with outgoing edges to be visited from the top down. It currently looks for abnormal edges and inferred ranges in the first phase walk up the tree. This has some disadvantages in that it can be slow, and once an abnormal edge is noticed, no other inferred information is tracked. This patch leverages the cache's edge calculator which also handles inferred ranges. During the initial walk, all we need to do is mark any blocks which have inferred ranges as well. Then the walk back down will visit those blocks, and integrate any inferred ranges along with outgoing edge ranges. We were simply doing too much work previously. PR tree-optimization/127203 gcc/ * gimple-range-cache.cc (ranger_cache::range_from_dom): Mark both outgoing edges and inferred ranges as "to calculate". --- gcc/gimple-range-cache.cc | 53 +++++++++------------------------------ 1 file changed, 12 insertions(+), 41 deletions(-) diff --git a/gcc/gimple-range-cache.cc b/gcc/gimple-range-cache.cc index 0386b9981178..0535b1661d12 100644 --- a/gcc/gimple-range-cache.cc +++ b/gcc/gimple-range-cache.cc @@ -1806,10 +1806,6 @@ ranger_cache::range_from_dom (vrange &r, tree name, basic_block start_bb, basic_block bb; basic_block prev_bb = start_bb; - // Track any inferred ranges seen. - value_range infer (TREE_TYPE (name)); - infer.set_varying (TREE_TYPE (name)); - // Range on entry to the DEF block should not be queried. gcc_checking_assert (start_bb != def_bb); unsigned start_limit = m_workback.length (); @@ -1824,31 +1820,12 @@ ranger_cache::range_from_dom (vrange &r, tree name, basic_block start_bb, else bb = get_immediate_dominator (CDI_DOMINATORS, start_bb); - bool abnormal_dominator = false; // Search until a value is found, pushing blocks which may need calculating. for ( ; bb; prev_bb = bb, bb = get_immediate_dominator (CDI_DOMINATORS, bb)) { - if (has_abnormal_call_or_eh_pred_edge_p (prev_bb)) - abnormal_dominator = true; - - // find the taken outgoing edge and check if it is abnormal. - if (!abnormal_dominator) - { - edge e; - edge_iterator ei; - FOR_EACH_EDGE (e, ei, bb->succs) - if (dominated_by_p (CDI_DOMINATORS, prev_bb, e->dest)) - { - if (e->flags & (EDGE_ABNORMAL | EDGE_EH)) - abnormal_dominator = true; - break; - } - // Accumulate any block exit inferred ranges. - infer_oracle ().maybe_adjust_range (infer, name, bb); - } - // This block has an outgoing range. - if (gori ().has_edge_range_p (name, bb)) + if (gori ().has_edge_range_p (name, bb) + || infer_oracle ().has_range_p (bb, name)) m_workback.safe_push (prev_bb); else { @@ -1896,7 +1873,7 @@ ranger_cache::range_from_dom (vrange &r, tree name, basic_block start_bb, fprintf (dump_file, " at function top\n"); } - // Now process any blocks wit incoming edges that nay have adjustments. + // Now process any blocks with incoming edges that may have adjustments. while (m_workback.length () > start_limit) { value_range er (TREE_TYPE (name)); @@ -1916,25 +1893,19 @@ ranger_cache::range_from_dom (vrange &r, tree name, basic_block start_bb, edge e = single_pred_edge (prev_bb); bb = e->src; if (gori ().edge_range_p (er, e, name, *this)) + r.intersect (er); + // If this is a normal edge, apply any inferred ranges. + if ((e->flags & (EDGE_EH | EDGE_ABNORMAL)) == 0) + infer_oracle ().maybe_adjust_range (r, name, bb); + if (DEBUG_RANGE_CACHE) { - r.intersect (er); - // If this is a normal edge, apply any inferred ranges. - if ((e->flags & (EDGE_EH | EDGE_ABNORMAL)) == 0) - infer_oracle ().maybe_adjust_range (r, name, bb); - - if (DEBUG_RANGE_CACHE) - { - fprintf (dump_file, "CACHE: Adjusted edge range for %d->%d : ", - bb->index, prev_bb->index); - r.dump (dump_file); - fprintf (dump_file, "\n"); - } + fprintf (dump_file, "CACHE: Final Adjusted edge range for %d->%d : ", + bb->index, prev_bb->index); + r.dump (dump_file); + fprintf (dump_file, "\n"); } } - // Apply any inferred ranges discovered. - r.intersect (infer); - if (DEBUG_RANGE_CACHE) { fprintf (dump_file, "CACHE: Range for DOM returns : "); From 728104624f30f8eb9f537a3f91b7bb35e4e3a98c Mon Sep 17 00:00:00 2001 From: Andrew MacLeod Date: Fri, 25 Sep 2026 10:19:38 -0400 Subject: [PATCH 478/584] Correct inferred range application. If there is an abnormal outgoing edge in a block, we are not supposed to apply any inferred ranges from the final statement as being exported from the block. The existing code had the logic incorrect. It was adding ranges if there was at least 1 normal edge rather than not adding them if there was at least one abnormal edge. The existing testcase was also flawed in that it was missing the flag to test with optimization, which caused it to pass when it should not have. Assisted-by: Claude Opus 5 PR tree-optimization/126531 gcc/ * gimple-range-cache.cc (ranger_cache::apply_inferred_ranges): Do not update if there are abnormal edges. gcc/testsuite/ * g++.dg/pr126531.C: Add optimization flag. --- gcc/gimple-range-cache.cc | 13 ++++++++----- gcc/testsuite/g++.dg/pr126531.C | 1 + 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/gcc/gimple-range-cache.cc b/gcc/gimple-range-cache.cc index 0535b1661d12..f0b20fae327b 100644 --- a/gcc/gimple-range-cache.cc +++ b/gcc/gimple-range-cache.cc @@ -1947,16 +1947,19 @@ ranger_cache::apply_inferred_ranges (gimple *s) if (infer.num () == 0) return; - // Do not update the on-entry cache for block ending stmts. + // Do not update the on-entry cache for block ending stmts if there is + // an outgoing abnormal edge. Any outgoing abnormal edge makes the + // value unsafe to use. if (stmt_ends_bb_p (s)) { edge_iterator ei; edge e; FOR_EACH_EDGE (e, ei, gimple_bb (s)->succs) - if (!(e->flags & (EDGE_ABNORMAL|EDGE_EH))) - break; - if (e == NULL) - update = false; + if (e->flags & (EDGE_ABNORMAL|EDGE_EH)) + { + update = false; + break; + } } infer_oracle ().add_ranges (s, infer); diff --git a/gcc/testsuite/g++.dg/pr126531.C b/gcc/testsuite/g++.dg/pr126531.C index 4401dbf8fafe..19e2e2baf1c1 100644 --- a/gcc/testsuite/g++.dg/pr126531.C +++ b/gcc/testsuite/g++.dg/pr126531.C @@ -1,4 +1,5 @@ // { dg-do run } +// { dg-options "-O2" } // /* More than 16 bytes, so S is returned in memory. *p becomes the return slot of the call and GIMPLE keeps a single statement "*p_7(D) = h (k_8(D));", From ea72e6be34c41ccf54aab44d17386a4fba74edcd Mon Sep 17 00:00:00 2001 From: Wilco Dijkstra Date: Mon, 24 Feb 2025 16:38:34 +0000 Subject: [PATCH 479/584] libatomic: Use HWCAPs in AArch64 ifunc tests Feedback from the kernel team suggests that it's best to only use HWCAPs rather than also use low-level checks as done by has_lse128() and has_rcpc3(). So change these to just use HWCAPs which simplifies the code and speeds up ifunc selection by avoiding expensive system register accesses. libatomic: * config/linux/aarch64/host-config.h (has_lse2): Mark unused arg. (has_lse128): Change to use HWCAPs and check size of struct. (has_rcpc3): Likewise. --- libatomic/config/linux/aarch64/host-config.h | 45 ++++---------------- 1 file changed, 9 insertions(+), 36 deletions(-) diff --git a/libatomic/config/linux/aarch64/host-config.h b/libatomic/config/linux/aarch64/host-config.h index 7f91528de5b2..78f56bad5aee 100644 --- a/libatomic/config/linux/aarch64/host-config.h +++ b/libatomic/config/linux/aarch64/host-config.h @@ -90,7 +90,7 @@ typedef struct __ifunc_arg_t { #define MIDR_PARTNUM(midr) (((midr) >> 4) & 0xfff) static inline bool -has_lse2 (unsigned long hwcap, const __ifunc_arg_t *features) +has_lse2 (unsigned long hwcap, const __ifunc_arg_t *features UNUSED) { /* Check for LSE2. */ if (hwcap & HWCAP_USCAT) @@ -109,50 +109,23 @@ has_lse2 (unsigned long hwcap, const __ifunc_arg_t *features) return false; } -/* LSE128 atomic support encoded in ID_AA64ISAR0_EL1.Atomic, bits[23:20]. - The minimum value for LSE128 is 0b0011. */ - -#define AT_FEAT_FIELD(isar0) (((isar0) >> 20) & 15) - static inline bool has_lse128 (unsigned long hwcap, const __ifunc_arg_t *features) { - if (hwcap & _IFUNC_ARG_HWCAP && features->_hwcap2 & HWCAP2_LSE128) - return true; - - /* If LSE2 and CPUID are supported, check for LSE128. */ - if (hwcap & HWCAP_CPUID && hwcap & HWCAP_USCAT) - { - unsigned long isar0; - asm volatile ("mrs %0, ID_AA64ISAR0_EL1" : "=r" (isar0)); - return AT_FEAT_FIELD (isar0) >= 3; - } - - return false; + return (hwcap & _IFUNC_ARG_HWCAP + && features->_size > offsetof (__ifunc_arg_t, _hwcap2) + && features->_hwcap2 & HWCAP2_LSE128); } -/* LRCPC atomic support encoded in ID_AA64ISAR1_EL1.Atomic, bits[23:20]. - The minimum value for LRCPC3 is 0b0011. */ - static inline bool has_rcpc3 (unsigned long hwcap, const __ifunc_arg_t *features) { /* LSE2 is a prerequisite for atomic LDIAPP/STILP - check HWCAP_USCAT since - has_lse2 is more expensive and Neoverse N1 does not have LRCPC3. */ - if (!(hwcap & HWCAP_USCAT)) - return false; - - if (hwcap & _IFUNC_ARG_HWCAP && features->_hwcap2 & HWCAP2_LRCPC3) - return true; - - if (hwcap & HWCAP_CPUID) - { - unsigned long isar1; - asm volatile ("mrs %0, ID_AA64ISAR1_EL1" : "=r" (isar1)); - return AT_FEAT_FIELD (isar1) >= 3; - } - - return false; + has_lse2 is more expensive and Neoverse N1 does not have LRCPC3. */ + return (hwcap & _IFUNC_ARG_HWCAP + && features->_size > offsetof (__ifunc_arg_t, _hwcap2) + && features->_hwcap & HWCAP_USCAT + && features->_hwcap2 & HWCAP2_LRCPC3); } #endif /* HAVE_IFUNC */ From b0434879418053061782e825ea0bf2eadb654b2b Mon Sep 17 00:00:00 2001 From: Bohan Lei Date: Mon, 20 Apr 2026 16:25:52 +0800 Subject: [PATCH 480/584] RISC-V: Compute live ranges for pattern results When a stmt is replaced by a pattern stmt during vectorization, the existing live range calculation code still calculates the live range of the original variable, and mark it as alive from the beginning of the block. Changing that to a live range of the pattern result can lead to a more precise register pressure estimation. The testcase is generated by LLM by adapting the x264 pixel_avg loop. We used the vanilla pixel_avg loop as the testcase downstream because our downstream version has other issues that overestimate the required register number. The adapted case, although not directly encountered in benchmarks, can show that the estimation can be improved on the trunk, at least for cases like this, too. Regtested on rv64gcv and rv32gcv, no regression. Assisted-by: Codex gcc/ChangeLog: * config/riscv/riscv-vector-costs.cc (get_pattern_var): New function. (costs::compute_local_live_ranges): Replace the argument with the pattern result when necessary. gcc/testsuite/ChangeLog: * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-5.c: Remove xfail. * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-7.c: Ditto. * gcc.target/riscv/rvv/autovec/pr121910.c: Change expectation. * gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-16.c: New test. --- gcc/config/riscv/riscv-vector-costs.cc | 18 +++++++++++++ .../costmodel/riscv/rvv/dynamic-lmul4-5.c | 4 +-- .../costmodel/riscv/rvv/dynamic-lmul4-7.c | 4 +-- .../costmodel/riscv/rvv/dynamic-lmul8-16.c | 25 +++++++++++++++++++ .../gcc.target/riscv/rvv/autovec/pr121910.c | 2 +- 5 files changed, 48 insertions(+), 5 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-16.c diff --git a/gcc/config/riscv/riscv-vector-costs.cc b/gcc/config/riscv/riscv-vector-costs.cc index 02c2039afd0c..cb7a4bed9617 100644 --- a/gcc/config/riscv/riscv-vector-costs.cc +++ b/gcc/config/riscv/riscv-vector-costs.cc @@ -346,6 +346,23 @@ variable_vectorized_p (class loop *loop, stmt_vec_info stmt_info, || type != load_vec_info_type)); } +/* Return the pattern result if the original definition of VAR is replaced by + a pattern stmt. Otherwise, return VAR. */ +static tree +get_pattern_var (tree var, loop_vec_info loop_vinfo) +{ + stmt_vec_info stmt_info; + + if ((stmt_info = loop_vinfo->lookup_def (var)) + && STMT_VINFO_IN_PATTERN_P (stmt_info)) + { + stmt_info = STMT_VINFO_RELATED_STMT (stmt_info); + var = gimple_get_lhs (stmt_info->stmt); + } + + return var; +} + /* Compute local live ranges of each vectorized variable. Note that we only compute local live ranges (within a block) since local live ranges information is accurate enough for us to determine @@ -426,6 +443,7 @@ costs::compute_local_live_ranges ( if (variable_vectorized_p (loop, program_point.stmt_info, *node, var, false)) { + var = get_pattern_var (var, loop_vinfo); biggest_mode = get_biggest_mode (biggest_mode, TYPE_MODE (TREE_TYPE (var))); diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-5.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-5.c index 387c3847cf27..09c64bb1cc70 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-5.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-5.c @@ -39,9 +39,9 @@ void foo2 (int16_t *__restrict a, } } -/* { dg-final { scan-assembler {e16,m2} { xfail *-*-* } } } */ +/* { dg-final { scan-assembler {e16,m2} } } */ /* { dg-final { scan-assembler-not {csrr} } } */ -/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 1 "vect" { xfail *-*-* } } } */ +/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 8" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 4" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 2" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-7.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-7.c index 259885f67395..1d37a516a76f 100644 --- a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-7.c +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul4-7.c @@ -39,9 +39,9 @@ void foo2 (int8_t *__restrict a, } } -/* { dg-final { scan-assembler {e64,m4} { xfail *-*-* } } } */ +/* { dg-final { scan-assembler {e64,m4} } } */ /* { dg-final { scan-assembler-not {csrr} } } */ -/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 1 "vect" { xfail *-*-* } } } */ +/* { dg-final { scan-tree-dump-times "Preferring smaller LMUL loop because it has unexpected spills" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 8" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 4" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "Maximum lmul = 2" 1 "vect" } } */ diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-16.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-16.c new file mode 100644 index 000000000000..7f4b29dcc834 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/dynamic-lmul8-16.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-options "-march=rv64gcv -mabi=lp64d -O3 -ftree-vectorize -mrvv-max-lmul=dynamic -fdump-tree-vect-details" } */ + +/* Replaced scalar average results must not be counted as block-wide int + live ranges. Four independent averages expose the false spill estimate. */ +void +avg4 (unsigned char *restrict d0, const unsigned char *restrict a0, + const unsigned char *restrict b0, unsigned char *restrict d1, + const unsigned char *restrict a1, const unsigned char *restrict b1, + unsigned char *restrict d2, const unsigned char *restrict a2, + const unsigned char *restrict b2, unsigned char *restrict d3, + const unsigned char *restrict a3, const unsigned char *restrict b3, int n) +{ + for (int i = 0; i < n; i++) + { + d0[i] = (a0[i] + b0[i] + 1) >> 1; + d1[i] = (a1[i] + b1[i] + 1) >> 1; + d2[i] = (a2[i] + b2[i] + 1) >> 1; + d3[i] = (a3[i] + b3[i] + 1) >> 1; + } +} + +/* { dg-final { scan-assembler-times {e8,m8} 1 } } */ +/* { dg-final { scan-tree-dump-not "Biggest mode = SI" "vect" } } */ +/* { dg-final { scan-tree-dump-not "Preferring smaller LMUL loop because it has unexpected spills" "vect" } } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr121910.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr121910.c index 024aae336481..02a52ce94d9a 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr121910.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr121910.c @@ -31,4 +31,4 @@ void mc_chroma(uint8_t* dst, int i_dst_stride, uint8_t* src, int i_src_stride, } /* { dg-final { scan-tree-dump "LOOP VECTORIZED" "vect" } } */ -/* { dg-final { scan-tree-dump "Choosing vector mode RVVM1QI" "vect" } } */ +/* { dg-final { scan-tree-dump "Choosing vector mode RVVM2QI" "vect" } } */ From 67d6d69da7e10cfa009fe8546e03b41510809310 Mon Sep 17 00:00:00 2001 From: Georg-Johann Lay Date: Fri, 25 Sep 2026 11:38:01 +0200 Subject: [PATCH 481/584] AVR: Restore fixes to opt.urls Files were incorrectly reverted while updating COBOL front end. gcc/ * config/avr/avr.opt.urls: Fix moptimize link. * config/nvptx/nvptx.opt.urls: Same. --- gcc/config/avr/avr.opt.urls | 2 +- gcc/config/nvptx/nvptx.opt.urls | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/gcc/config/avr/avr.opt.urls b/gcc/config/avr/avr.opt.urls index a7d2d295f89e..e0c725e8d1a8 100644 --- a/gcc/config/avr/avr.opt.urls +++ b/gcc/config/avr/avr.opt.urls @@ -112,7 +112,7 @@ mfuse-move2 UrlSuffix(gcc/AVR-Options.html#index-mfuse-move2) moptimize -UrlSuffix(gcc/AVR-Options.html#index-moptimize) +UrlSuffix(gcc/AVR-Options.html#index-moptimize-1) mabsdata UrlSuffix(gcc/AVR-Options.html#index-mabsdata) diff --git a/gcc/config/nvptx/nvptx.opt.urls b/gcc/config/nvptx/nvptx.opt.urls index ced5d34eaeb7..931b329204fd 100644 --- a/gcc/config/nvptx/nvptx.opt.urls +++ b/gcc/config/nvptx/nvptx.opt.urls @@ -7,7 +7,7 @@ mmainkernel UrlSuffix(gcc/Nvidia-PTX-Options.html#index-mmainkernel) moptimize -UrlSuffix(gcc/Nvidia-PTX-Options.html#index-moptimize-1) +UrlSuffix(gcc/Nvidia-PTX-Options.html#index-moptimize) msoft-stack UrlSuffix(gcc/Nvidia-PTX-Options.html#index-msoft-stack) From 1095e444a4526f587980bc333a7bfa83d27f0adb Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 24 Sep 2026 14:01:29 +0200 Subject: [PATCH 482/584] cobol: Fix missing prototype in stored-char-length.cpy This copybook was incorrectly defining a function also called STORED-CHAR-LENGTH with an empty body, rather than its prototype, therefore breaking programs relying on it. libgcobol/ChangeLog: * compat/gnu/cpy/stored-char-length.cpy: Add PROTOTYPE. * compat/gnu/lib/stored-char-length.cbl: Add COPY to validate prototype. --- libgcobol/compat/gnu/cpy/stored-char-length.cpy | 2 +- libgcobol/compat/gnu/lib/stored-char-length.cbl | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/libgcobol/compat/gnu/cpy/stored-char-length.cpy b/libgcobol/compat/gnu/cpy/stored-char-length.cpy index e54a9bd32894..cd3d3e19e596 100644 --- a/libgcobol/compat/gnu/cpy/stored-char-length.cpy +++ b/libgcobol/compat/gnu/cpy/stored-char-length.cpy @@ -30,7 +30,7 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. Identification Division. - Function-ID. STORED-CHAR-LENGTH. + Function-ID. STORED-CHAR-LENGTH PROTOTYPE. Data Division. Linkage Section. 01 Candidate PIC X Any Length. diff --git a/libgcobol/compat/gnu/lib/stored-char-length.cbl b/libgcobol/compat/gnu/lib/stored-char-length.cbl index f60408810f8e..668b7b3fb4aa 100644 --- a/libgcobol/compat/gnu/lib/stored-char-length.cbl +++ b/libgcobol/compat/gnu/lib/stored-char-length.cbl @@ -29,6 +29,8 @@ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + Copy "stored-char-length.cpy". + Identification Division. Function-ID. STORED-CHAR-LENGTH. Data Division. From daf8d7612dc022f2f124173be31226fc8791ea48 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 24 Sep 2026 17:21:16 +0200 Subject: [PATCH 483/584] cobol: Apply fixed/free format heuristics also for FUNCTION-ID Previously, the heuristics were limited to PROGRAM-ID, to the point that copybooks that only defined function prototypes, such as stored-char-length.cpy, could silently make the lexer switch to free format mode when copied via -include, thus potentially breaking fixed-form programs. gcc/cobol/ChangeLog: * lexio.cc (is_p): Rename function, support 'F'. (is_pf): Likewise. (is_program_id): Support FUNCTION-ID. (valid_sequence_area): Likewise. --- gcc/cobol/lexio.cc | 30 +++++++++++++++++++----------- 1 file changed, 19 insertions(+), 11 deletions(-) diff --git a/gcc/cobol/lexio.cc b/gcc/cobol/lexio.cc index e6e8ffcf6531..71bc21edefa3 100644 --- a/gcc/cobol/lexio.cc +++ b/gcc/cobol/lexio.cc @@ -445,20 +445,28 @@ struct buffer_t : public bytespan_t { } }; -static inline bool is_p( char ch ) { return TOUPPER(ch) == 'P'; } +static inline bool is_pf( char ch ) { return TOUPPER(ch) == 'P' || TOUPPER(ch) == 'F'; } static bool is_program_id( const char *p, const char *eol ) { - static const std::string program_id("PROGRAM-ID"); - auto eop = p + program_id.size(); - if( eop < eol ) { - // PROGRAM-ID must be followed by a dot, perhaps with intervening whitespace. - for( const char *dot=eop; dot < eol && *dot != '.'; dot++ ) { - if( !ISSPACE(*dot) ) return false; + static const std::vector ids { "PROGRAM-ID", "FUNCTION-ID" }; + for( const auto& id : ids ) { + auto eop = p + id.size(); + if( eop < eol ) { + bool valid = true; + // PROGRAM-ID must be followed by a dot, perhaps with intervening whitespace. + for( const char *dot=eop; dot < eol && *dot != '.'; dot++ ) { + if( !ISSPACE(*dot) ) { + valid = false; + break; + } + } + if (!valid) + continue; + std::string line (p, eop); + std::transform(line.begin(), line.end(), line.begin(), ::toupper); + return line == id; } - std::string line (p, eop); - std::transform(line.begin(), line.end(), line.begin(), ::toupper); - return line == program_id; } return false; } @@ -1689,7 +1697,7 @@ static const char * valid_sequence_area( const char *data, const char *eodata ) { for( const char *p = data; // find every 'P' to try Program-ID - (p = std::find_if(p, eodata, is_p)) != eodata; + (p = std::find_if(p, eodata, is_pf)) != eodata; p++ ) { auto eol = std::find(p, eodata, '\n'); From e6734ffdd3137d46f5174420183eb0d0348f76c0 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 24 Sep 2026 14:15:05 +0200 Subject: [PATCH 484/584] cobol: Add UDF copybooks to gcobc GnuCOBOL makes STORED-CHAR-LENGTH always available to users, whereas gcobol required COPY "stored-char-length.cpy". The use of the -include command-line option allows to achieve the same effect, thus improving compatibility with GnuCOBOL. gcc/cobol/ChangeLog: * gcobc: Add stored-char-length.cpy via -include. --- gcc/cobol/gcobc | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/gcc/cobol/gcobc b/gcc/cobol/gcobc index 447323b75902..46287f02efd4 100755 --- a/gcc/cobol/gcobc +++ b/gcc/cobol/gcobc @@ -86,6 +86,34 @@ then copydir="-I$COB_COPY_DIR" fi +# if not available from the build tree, attempt to search the install directory. +udf_default="${0%/*}/../$($gcobol -dumpmachine)/libgcobol/compat/gnu/cpy" +if ! [ -d "$udf_default" ] +then + install_dir="$($gcobol -print-search-dirs | grep '^install:' | awk '{print $2}')" + udf_default="$install_dir/cobol/compat/gnu/cpy" +fi +udfdir="${GCOBCUDF:-$udf_default}" + +if [ -d "$udfdir" ] +then + # Feel free to add more UDFs below. + udfs=stored-char-length.cpy + + for F in $udfs + do + if [ -f "$udfdir/$F" ] + then + includes="$includes -include $udfdir/$F " + fi + done +else + if [ "${GCOBCUDF:-none}" != "none" ] + then + echo warning: no such directory: "'$GCOBCUDF'" + fi +fi + exit_status=0 skip_arg= opts="$copydir $includes" From d840f9764d21cad47175aac4565d14963952d80d Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 24 Sep 2026 14:45:59 +0200 Subject: [PATCH 485/584] cobol: Fix various options in gcobc Original patch by Simon Sobisch. gcc/cobol/ChangeLog: * gcobc: Fix --various command-line options. --- gcc/cobol/gcobc | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/gcc/cobol/gcobc b/gcc/cobol/gcobc index 46287f02efd4..43b5a0ea2a71 100755 --- a/gcc/cobol/gcobc +++ b/gcc/cobol/gcobc @@ -232,6 +232,8 @@ do -echo) echo="echo" ;; + # note: if warnings on not implemented GC exceptions should be suppressed, + # then use -Wno-ec-unknown -fec=* | -fno-ec=*) opt="$(echo "$opt" | sed -E 's/-f(no-)?ec=/-f\1cobol-exceptions=EC-/g')" opts="$opts $opt" @@ -438,12 +440,16 @@ do ;; -i | --info) warn "$opt" ;; - -include ) - pending_arg=$opt + + # include a COBOL copybook --> gcobol's -include + --copy) + pending_arg="-include " # space-separation needed ;; - # no-space version: just concatenate - -include* ) - opts="$opts $opt" + # + + # include a C header --> no real option in gcobol + --include) + error "$opt $incomparable" ;; # # Options that may have a space before the argument, or not @@ -525,7 +531,8 @@ do # opts="$opts --version" ;; # pass through, -Wall support pending gcc to set for all front ends - # cobc does not support all gcc -Wl options + # note: while cobc does not support gcc's -Wl options, they + # might be passed anyway for different reasons e.g.: -Wl,rpath. -w | -W | -Wextra | -Wno-* | -Wl,*) opts="$opts $opt" ;; From 2d5e95646fb2e7268c593560c6dd00a0459d3114 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 24 Sep 2026 16:43:51 +0200 Subject: [PATCH 486/584] cobol: Fix -v command-line option in gcobc This option previously translated from -v to -V, but the latter is not supported by gcobol. gcc/cobol/ChangeLog: * gcobc: Fix -v command-line option. --- gcc/cobol/gcobc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gcc/cobol/gcobc b/gcc/cobol/gcobc index 43b5a0ea2a71..1b125342d537 100755 --- a/gcc/cobol/gcobc +++ b/gcc/cobol/gcobc @@ -518,7 +518,7 @@ do ;; -q | --brief) warn "$opt" ;; - -v | --verbose) opts="$opts -V" + -v | --verbose) opts="$opts -v" ;; # -dumpversion, like all options not handled specifically, is # passed by default. From 2f4e06842580aad43e2d9d6aec77d24c06a383d8 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Fri, 25 Sep 2026 00:29:18 +0200 Subject: [PATCH 487/584] cobol: Add -export-dynamic by default If a program built with -fno-static-call CALLs another program within the same executable, the CALL can fail with the following warning message: WARNING: prog.cbl:4 "CALL foo" not found with no "CALL ON EXCEPTION" phrase. (You might need -rdynamic or --export-dynamic for symbols in the executable.) The default behaviour for gcc is *not* to export unreferenced symbols to the dynamic symbol table. Since -fno-static-call is in effect by default in gcobc(1), this can cause programs within the same executable not to have any references to them because CALLs are deferred to dlopen(3) and dlsym(3), and are therefore discarded from the table, potentially triggering the warning message above. Therefore, -export-dynamic mitigates this by exporting all symbols, included unreferenced ones. gcc/cobol/ChangeLog: * gcobc: Add -export-dynamic. --- gcc/cobol/gcobc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/gcc/cobol/gcobc b/gcc/cobol/gcobc index 1b125342d537..b967428076d0 100755 --- a/gcc/cobol/gcobc +++ b/gcc/cobol/gcobc @@ -568,7 +568,8 @@ done # cobc default: if [ "$static_used" = "" ] then - opts="-fno-static-call $opts"; + # -export-dynamic required if CALLs occur within the same executable. + opts="-fno-static-call -export-dynamic $opts"; fi if [ "$exit_status" -gt 0 ] From 6e71afffd4c0a9a872790826920548edc3360173 Mon Sep 17 00:00:00 2001 From: Xavier Del Campo Romero Date: Thu, 24 Sep 2026 14:51:44 +0200 Subject: [PATCH 488/584] cobol: Fix return values for CBL_GET_PROGRAM_INFO The documentation defines a list of return values that were not being honored. Also, the behaviour for return-buf and return-buf-len was inconsistent with the specification. [1] [1]: https://docs.rocketsoftware.com/bundle/visualcoboldevhub_ug_110/page/lxm1742952203519.html libgcobol/ChangeLog: * compat/gnu/lib/cbl_get_program_info.3: Update to status quo. * compat/gnu/lib/cbl_gpi.cc (setbasename): Honor return values and return-buf{-len}. (cbl_gpi_cur_status): Likewise. (cbl_gpi_named_status): Likewise. (cbl_gpi_parent_status): Likewise. (cbl_gpi_close_handle): Likewise. (cbl_gpi_first_ep): Update function signature. (cbl_gpi_next_ep): Update function signature. (cbl_gpi_cancel_search_ep): Update function signature. (cbl_gpi_prg_name): Update function signature. (cbl_gpi_nargs): Update function signature. (cbl_gpi_reserved): Update function signature. (cbl_gpi_path_prg_name): Update function signature. (checkflags): Remove old debug messages. (cbl_gpi): Honor return values. gcc/testsuite/ChangeLog: * cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.cob: Update test according to expected behaviour. --- ..._get_program_name_-_functions_0_and_2_.cob | 6 +- .../compat/gnu/lib/cbl_get_program_info.3 | 59 +++++++++-- libgcobol/compat/gnu/lib/cbl_gpi.cc | 99 +++++++++---------- 3 files changed, 104 insertions(+), 60 deletions(-) diff --git a/gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.cob b/gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.cob index f26b70f39c27..9482c75a8d3c 100644 --- a/gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.cob +++ b/gcc/testsuite/cobol.dg/group2/CBL_GET_PROGRAM_INFO__get_program_name_-_functions_0_and_2_.cob @@ -41,8 +41,8 @@ copy "cbltypes.cpy". 01 param-block type cblt-prog-info-params. procedure division using param-block. - move length of buf to buflen. perform until status-code <> 0 + move length of buf to buflen * retrieve program name from handle move 6 to cblte-gpi-flags move 2 to fn @@ -59,6 +59,10 @@ end-if end-perform. + if status-code <> 500 + display "CBL_GET_PROGRAM_INFO failed with " status-code + end-if. + close-handle section. * close handle move 0 to cblte-gpi-flags. diff --git a/libgcobol/compat/gnu/lib/cbl_get_program_info.3 b/libgcobol/compat/gnu/lib/cbl_get_program_info.3 index d6b9a38b9bfb..ec35d14f5a57 100644 --- a/libgcobol/compat/gnu/lib/cbl_get_program_info.3 +++ b/libgcobol/compat/gnu/lib/cbl_get_program_info.3 @@ -38,9 +38,13 @@ and assign .Ar cblte-gpi-handle . .Ar 2 : -Return the program name associated with a +Return the +.Ar caller +program name associated with a .Ar cblte-gpi-handle instance previously allocated by function 0. +.Ar cblte-gpi-handle +is updated to the caller function. .Ar 3 : close a @@ -77,12 +81,6 @@ and is ignored by all other functions. fill .Ar return-buf with the program name. -.Ar return-buf-len -therefore indicates the length of the -.Ar return-buf -buffer. If the program name is longer than -.Ar return-buf-len , -the result is truncated. This bit is only relevant for functions .Ar 0 and @@ -99,15 +97,58 @@ points to a buffer to be filled by .Nm . .It Ar return-buf-len -determines the length for the +on entry, +.Ar return-buf-len +indicates the length of the .Ar return-buf -buffer. +buffer, +.Sy including +the terminator byte (nul or space). +On exit, +.Ar return-buf-len +is updated to the length of the program name, +.Sy excluding +the terminator byte. +However, if +.Ar return-buf-len +is too small, +.Ar return-buf +is left untouched and +.Ar return-buf-len +is updated to the required buffer length, +.Sy including +the terminator byte. .Sh RETURN STATUS .Nm returns .Sy "PIC X(2) COMP-5" . The return status is 0 on success, else nonzero. +The following return values are defined: + +.Ar 500 : +(function 2 only) no parent available from the call stack. + +.Ar 1001 : +invalid +.Ar cblte-gpi-handle . + +.Ar 1009 : +invalid parameter. + +.Ar 1011 : +invalid or undefined program name. +Additionally, +.Ar libgcobol_compat_gnu +uses this return value when no call stack was found for the given program. + +.Ar 1013 : +.Ar return-buf-len +is too small to write the function basename to +.Ar return-buf . +The required buffer length is therefore written to +.Ar return-buf-len . + . .Sh SEE ALSO .Xr CBL_CLOSE_FILE diff --git a/libgcobol/compat/gnu/lib/cbl_gpi.cc b/libgcobol/compat/gnu/lib/cbl_gpi.cc index 7708767fad73..4d414ba169a0 100644 --- a/libgcobol/compat/gnu/lib/cbl_gpi.cc +++ b/libgcobol/compat/gnu/lib/cbl_gpi.cc @@ -126,29 +126,41 @@ callstack() return ret; } -static void -setbasename(const std::string &src, const gpi_param_t &p, char *dst, unsigned n) +static int16_t +setbasename(const std::string &src, const gpi_param_t &p, char *dst, + unsigned *buflen) { - strncpy(dst, src.c_str(), n); + int r = snprintf(NULL, 0, "%s", src.c_str()); - if (n) + if (r < 0 || !dst || !buflen) + return 1009; + else if (r >= *buflen) { - dst[n - 1] = '\0'; + *buflen = r + 1; + return 1013; + } + else + { + *buflen = snprintf(dst, *buflen, "%s", src.c_str()); if (!(p.flags & GPI_PARAM_NULL_TERM)) dst[strlen(dst)] = ' '; } + + return 0; } int16_t -cbl_gpi_cur_status(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) +cbl_gpi_cur_status(gpi_param_t ¶ms, union retbuf buf, unsigned *buflen) { + int16_t ret; std::vector cs = callstack(); if (cs.empty()) - return -1; + return 1011; else if (params.flags & GPI_PARAM_RET_BASENAME) - setbasename(cs.back(), params, buf.basename, buflen); + if ((ret = setbasename(cs.back(), params, buf.basename, buflen))) + return ret; if (params.flags & GPI_PARAM_RET_HANDLE) params.handle = new gpi_priv(cs); @@ -158,7 +170,7 @@ cbl_gpi_cur_status(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) } int16_t -cbl_gpi_named_status(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) +cbl_gpi_named_status(gpi_param_t ¶ms, union retbuf buf, unsigned *buflen) { /* TODO: how are we supposed to return for a "named program" * if no name is given?*/ @@ -167,78 +179,86 @@ cbl_gpi_named_status(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) } int16_t -cbl_gpi_parent_status(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) +cbl_gpi_parent_status(gpi_param_t ¶ms, union retbuf buf, unsigned *buflen) { + int16_t ret; gpi_priv *prv = params.handle; - if (prv->it + 1 >= prv->callstack.crend()) - return -1; + if (!prv) + return 1001; + else if (prv->it + 1 >= prv->callstack.crend()) + return 500; else if (params.flags & GPI_PARAM_RET_BASENAME) - setbasename(*++prv->it, params, buf.basename, buflen); + if ((ret = setbasename(*++prv->it, params, buf.basename, buflen))) + return ret; /* TODO: set status bits */ return 0; } int16_t -cbl_gpi_close_handle(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) +cbl_gpi_close_handle(gpi_param_t ¶ms, union retbuf buf, unsigned *buflen) { + if (!params.handle) + return 1001; + delete params.handle; /* TODO: set status bits */ return 0; } int16_t -cbl_gpi_first_ep(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) +cbl_gpi_first_ep(gpi_param_t ¶ms, union retbuf buf, unsigned *buflen) { fprintf(stderr, "%s: TODO\n", __func__); return -1; } int16_t -cbl_gpi_next_ep(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) +cbl_gpi_next_ep(gpi_param_t ¶ms, union retbuf buf, unsigned *buflen) { fprintf(stderr, "%s: TODO\n", __func__); return -1; } int16_t -cbl_gpi_cancel_search_ep(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) +cbl_gpi_cancel_search_ep(gpi_param_t ¶ms, union retbuf buf, + unsigned *buflen) { fprintf(stderr, "%s: TODO\n", __func__); return -1; } int16_t -cbl_gpi_prg_name(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) +cbl_gpi_prg_name(gpi_param_t ¶ms, union retbuf buf, unsigned *buflen) { fprintf(stderr, "%s: TODO\n", __func__); return -1; } int16_t -cbl_gpi_nargs(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) +cbl_gpi_nargs(gpi_param_t ¶ms, union retbuf buf, unsigned *buflen) { fprintf(stderr, "%s: TODO\n", __func__); return -1; } int16_t -cbl_gpi_reserved(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) +cbl_gpi_reserved(gpi_param_t ¶ms, union retbuf buf, unsigned *buflen) { fprintf(stderr, "%s: TODO\n", __func__); return -1; } int16_t -cbl_gpi_path_prg_name(gpi_param_t ¶ms, union retbuf buf, unsigned buflen) +cbl_gpi_path_prg_name(gpi_param_t ¶ms, union retbuf buf, unsigned *buflen) { fprintf(stderr, "%s: TODO\n", __func__); return -1; } typedef int16_t (*gpi_func_t)(gpi_param_t ¶ms, union retbuf buf, - unsigned buflen); + unsigned *buflen); static const struct func { @@ -324,17 +344,9 @@ static int checkflags(uint32_t fn, uint32_t flags) if (flags & mask) { if (!(f.accept & mask) && !(f.ignore & mask)) - { - fprintf(stderr, "bit %" PRIu32 " not allowed for function %" PRIu32 - "\n", i, fn); return -1; - } else if (f.unimplemented & mask) - { - fprintf(stderr, "bit %" PRIu32 " unimplemented for function %" PRIu32 - "\n", i, fn); return -1; - } } } @@ -342,27 +354,14 @@ static int checkflags(uint32_t fn, uint32_t flags) } extern "C" -int16_t cbl_gpi(uint32_t fn, struct gpi_param_t ¶ms, union retbuf buf, +int16_t cbl_gpi(uint32_t fn, struct gpi_param_t *params, union retbuf buf, uint32_t *buflen) { - if (fn >= sizeof funcs / sizeof *funcs) - { - fprintf(stderr, "invalid function number %u\n", fn); - return -1; - } - - if (params.size != sizeof params) - { - fprintf(stderr, "invalid cblte-gpi-size, expected %zu, got %u\n", - sizeof params, params.size); - assert(params.size == sizeof params); - } - - if (checkflags(fn, params.flags)) - { - fprintf(stderr, "invalid bits\n"); - return -1; - } + if (fn >= sizeof funcs / sizeof *funcs + || !params + || params->size != sizeof *params + || checkflags(fn, params->flags)) + return 1009; - return funcs[fn].func(params, buf, *buflen); + return funcs[fn].func(*params, buf, buflen); } From 3d79c978b53474d2b613fe3e28037393c8d037b0 Mon Sep 17 00:00:00 2001 From: Robin Dapp Date: Mon, 21 Sep 2026 22:24:25 +0200 Subject: [PATCH 489/584] RISC-V: Spill more unsplittable moves [PR127484]. In the PRs we hit the same problem as before, just this time with a (subreg:TF (reg:V4SF)) pun on a 32-bit target and a complex int128. These are different quadword splits than before but they can be handled similarly. This patch extends riscv_subpart so it can deal with sub-parts of arbitrary modes. The new functionality is then used to move a spilled TFmode value in word-sized chunks. PR target/127484 PR target/127547 gcc/ChangeLog: * config/riscv/riscv.cc (riscv_subpart): Add parameters and handle more part sizes. (spill_subreg_move): Allow subreg bytes != 0. (riscv_split_quadword_move): Use riscv_subpart for TFmode. * config/riscv/riscv.md (movtf): Add. gcc/testsuite/ChangeLog: * gcc.target/riscv/rvv/autovec/pr127484.c: New test. * gcc.target/riscv/rvv/autovec/pr127547.c: New test. --- gcc/config/riscv/riscv.cc | 81 +++++++++++-------- gcc/config/riscv/riscv.md | 13 +++ .../gcc.target/riscv/rvv/autovec/pr127484.c | 19 +++++ .../gcc.target/riscv/rvv/autovec/pr127547.c | 13 +++ 4 files changed, 94 insertions(+), 32 deletions(-) create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/pr127484.c create mode 100644 gcc/testsuite/gcc.target/riscv/rvv/autovec/pr127547.c diff --git a/gcc/config/riscv/riscv.cc b/gcc/config/riscv/riscv.cc index 87c24e5dcc15..ae3fd8e3d72b 100644 --- a/gcc/config/riscv/riscv.cc +++ b/gcc/config/riscv/riscv.cc @@ -5370,23 +5370,20 @@ riscv_subword (rtx op, bool high_p) return simplify_gen_subreg (word_mode, op, mode, byte); } -/* Same as riscv_subword, just only for OImode. */ +/* Similar to riscv_subword, but gets sub-part PART_IDX of mode PART_MODE + from OP (of mode MODE). */ static rtx -riscv_subpart (rtx op, bool high_p) +riscv_subpart (rtx op, machine_mode mode, scalar_mode part_mode, + poly_uint64 part_idx) { - unsigned int byte = (high_p != BYTES_BIG_ENDIAN) ? 16 : 0; - machine_mode mode = GET_MODE (op); - - if (mode == VOIDmode) - mode = OImode; - - gcc_assert (mode == OImode); + gcc_assert (multiple_p (GET_MODE_SIZE (mode), GET_MODE_SIZE (part_mode))); + poly_uint64 byte = part_idx * GET_MODE_SIZE (part_mode); if (MEM_P (op)) - return adjust_address (op, TImode, byte); + return adjust_address (op, part_mode, byte); - return simplify_gen_subreg (TImode, op, mode, byte); + return simplify_gen_subreg (part_mode, op, mode, byte); } /* Return true if OP is a subreg that we cannot split into words or false @@ -5418,14 +5415,12 @@ spill_subreg_move (rtx dest, rtx src) if (spill_src) { /* Get a stack slot of inner mode, move the inner reg to it and - "view" in outer mode. We can only get here when handling - subreg-punned registers for which the subreg byte is 0. */ + "view" in outer mode. */ rtx inner = SUBREG_REG (src); - gcc_assert (known_eq (SUBREG_BYTE (src), 0)); machine_mode mode_inner = GET_MODE (inner); rtx mem = assign_stack_temp (mode_inner, GET_MODE_SIZE (mode_inner)); emit_move_insn (mem, inner); - tmp_src = adjust_address (mem, GET_MODE (src), 0); + tmp_src = adjust_address (mem, GET_MODE (src), SUBREG_BYTE (src)); } if (!spill_dest) @@ -5438,10 +5433,9 @@ spill_subreg_move (rtx dest, rtx src) Then, view it as outer mode and move the source to it. Finally, store it in the inner subreg. */ rtx inner = SUBREG_REG (dest); - gcc_assert (known_eq (SUBREG_BYTE (dest), 0)); machine_mode mode_inner = GET_MODE (inner); rtx mem = assign_stack_temp (mode_inner, GET_MODE_SIZE (mode_inner)); - rtx mem_outer = adjust_address (mem, GET_MODE (dest), 0); + rtx mem_outer = adjust_address (mem, GET_MODE (dest), SUBREG_BYTE (dest)); if (maybe_gt (GET_MODE_SIZE (mode_inner), GET_MODE_SIZE (GET_MODE (dest)))) emit_move_insn (mem, inner); emit_move_insn (mem_outer, tmp_src); @@ -5619,14 +5613,15 @@ riscv_split_doubleword_move (rtx dest, rtx src) void riscv_split_quadword_move (rtx dest, rtx src) { - gcc_assert (GET_MODE (dest) == OImode); + gcc_assert (GET_MODE (dest) == OImode || GET_MODE (dest) == TFmode); gcc_assert (!BYTES_BIG_ENDIAN); /* Nothing to do for highwords of paradoxical subregs. */ if (paradoxical_subreg_p (dest) || paradoxical_subreg_p (src)) { - riscv_split_doubleword_move (riscv_subpart (dest, false), - riscv_subpart (src, false)); + gcc_assert (GET_MODE (dest) == OImode); + riscv_split_doubleword_move (riscv_subpart (dest, OImode, TImode, 0), + riscv_subpart (src, OImode, TImode, 0)); return; } @@ -5638,22 +5633,43 @@ riscv_split_quadword_move (rtx dest, rtx src) return; } - /* Split into TImode hi/lo parts and hand off to - riscv_split_doubleword_move. */ - rtx src_lo = riscv_subpart (src, false); - rtx dest_lo = riscv_subpart (dest, false); - rtx src_hi = riscv_subpart (src, true); - rtx dest_hi = riscv_subpart (dest, true); - - if (reg_overlap_mentioned_p (dest_lo, src)) + if (GET_MODE (dest) == OImode) { - riscv_split_doubleword_move (dest_hi, src_hi); - riscv_split_doubleword_move (dest_lo, src_lo); + /* Split into TImode hi/lo parts and hand off to + riscv_split_doubleword_move. */ + rtx src_lo = riscv_subpart (src, OImode, TImode, 0); + rtx dest_lo = riscv_subpart (dest, OImode, TImode, 0); + rtx src_hi = riscv_subpart (src, OImode, TImode, 1); + rtx dest_hi = riscv_subpart (dest, OImode, TImode, 1); + + if (reg_overlap_mentioned_p (dest_lo, src)) + { + riscv_split_doubleword_move (dest_hi, src_hi); + riscv_split_doubleword_move (dest_lo, src_lo); + } + else + { + riscv_split_doubleword_move (dest_lo, src_lo); + riscv_split_doubleword_move (dest_hi, src_hi); + } } else { - riscv_split_doubleword_move (dest_lo, src_lo); - riscv_split_doubleword_move (dest_hi, src_hi); + /* Once we are here, we can work with SRC and DEST by + either building a subreg or adjusting the memory slot. */ + gcc_assert (GET_MODE (dest) == TFmode && !TARGET_64BIT); + rtx first_part = riscv_subpart (dest, TFmode, word_mode, 0); + bool overlap_p = REG_P (first_part) + && reg_overlap_mentioned_p (first_part, src); + + if (!overlap_p) + for (int i = 0; i < 4; i++) + emit_move_insn (riscv_subpart (dest, TFmode, word_mode, i), + riscv_subpart (src, TFmode, word_mode, i)); + else + for (int i = 3; i >= 0; i--) + emit_move_insn (riscv_subpart (dest, TFmode, word_mode, i), + riscv_subpart (src, TFmode, word_mode, i)); } } @@ -13211,6 +13227,7 @@ static bool riscv_can_change_mode_class (machine_mode from, machine_mode to, reg_class_t rclass) { + /* ??? TODO prohibit scalar-vector pun e.g. (subreg:TI (reg:V4SI )). */ /* We have RVV VLS modes and VLA modes sharing same REG_CLASS. In 'cprop_hardreg' stage, we will try to do hard reg copy propagation between wider mode (FROM) and narrow mode (TO). diff --git a/gcc/config/riscv/riscv.md b/gcc/config/riscv/riscv.md index 2f4a3686b70f..cfac4c960bf1 100644 --- a/gcc/config/riscv/riscv.md +++ b/gcc/config/riscv/riscv.md @@ -2903,6 +2903,19 @@ DONE; }) +;; And TFmode. +(define_expand "movtf" + [(set (match_operand:TF 0 "nonimmediate_operand") + (match_operand:TF 1 "general_operand"))] + "" +{ + if (TARGET_64BIT) + riscv_split_doubleword_move (operands[0], operands[1]); + else + riscv_split_quadword_move (operands[0], operands[1]); + DONE; +}) + (define_expand "cmpmemsi" [(parallel [(set (match_operand:SI 0) (compare:SI (match_operand:BLK 1) diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr127484.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr127484.c new file mode 100644 index 000000000000..f264d76303d5 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr127484.c @@ -0,0 +1,19 @@ +/* { dg-do compile } */ +/* { dg-options "-O -march=rv32gcv -mabi=ilp32d" } */ + +typedef __attribute__((__vector_size__(16))) float V; + +union { + long double d; + V v; +} u; + +float f; +char c; + +void +foo() +{ + u.v -= f; + c *= u.d -= 0; +} diff --git a/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr127547.c b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr127547.c new file mode 100644 index 000000000000..02ff46fc365e --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/rvv/autovec/pr127547.c @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-options "-O -march=rv64gcv -mabi=lp64d" } */ + +typedef _Complex __int128 V; +typedef __attribute__((__vector_size__(32))) short W; + +_Complex float f; + +void +foo(W w) +{ + f *= *(V *)&w; +} From 2b980c3e11a6b6ef0223d1668672bac877038185 Mon Sep 17 00:00:00 2001 From: Robin Dapp Date: Tue, 22 Sep 2026 14:18:45 +0200 Subject: [PATCH 490/584] RISC-V: Error out early for unsupported builtins. [PR127553] Right now we only show an error if the expansion of a builtin fails. But there is builtin code that get optimized away before expansion and never shows an error message. It's not strictly wrong code but at least surprising and will mislead compilation checks. This patch just copies the checks of expand_builtin to check_builtin_call. We don't have the exact same expression of the affected call available at that point, though. The basic fndecl just contains the function name and not its arguments. We can reconstruct the call but in my tests there were always slight difference to the expand-time diagnostic. Therefore I adjusted the test expectations instead. PR target/127553 gcc/ChangeLog: * config/riscv/riscv-vector-builtins.cc (validate_instance_type_required_extensions): Add location param for logging. (expand_builtin): Pass location. (check_builtin_call): Likewise. gcc/testsuite/ChangeLog: * gcc.target/riscv/rvv/base/bug-9.c: Adjust test expectation. * gcc.target/riscv/rvv/base/intrinsic_required_ext-1.c: Ditto. * gcc.target/riscv/rvv/base/intrinsic_required_ext-10.c: Ditto. * gcc.target/riscv/rvv/base/intrinsic_required_ext-2.c: Ditto. * gcc.target/riscv/rvv/base/intrinsic_required_ext-3.c: Ditto. * gcc.target/riscv/rvv/base/intrinsic_required_ext-4.c: Ditto. * gcc.target/riscv/rvv/base/intrinsic_required_ext-5.c: Ditto. * gcc.target/riscv/rvv/base/intrinsic_required_ext-6.c: Ditto. * gcc.target/riscv/rvv/base/intrinsic_required_ext-7.c: Ditto. * gcc.target/riscv/rvv/base/intrinsic_required_ext-8.c: Ditto. * gcc.target/riscv/rvv/base/intrinsic_required_ext-9.c: Ditto. * gcc.target/riscv/rvv/base/pr114988-1.c: Ditto. * gcc.target/riscv/rvv/base/pr114988-2.c: Ditto. * gcc.target/riscv/rvv/base/pr120436.c: Ditto. * gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-17.c: * gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-18.c: * gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-19.c: * gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-20.c: * gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-21.c: * gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-22.c: * gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-23.c: * gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-24.c: * gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-25.c: * gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-26.c: * gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-27.c: * gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-28.c: * gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-29.c: * gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-3.c: * gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-7.c: * gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-8.c: * gcc.target/riscv/pr127553.c: New test. --- gcc/config/riscv/riscv-vector-builtins.cc | 46 +++++++++++++------ gcc/testsuite/gcc.target/riscv/pr127553.c | 13 ++++++ .../gcc.target/riscv/rvv/base/bug-9.c | 2 +- .../riscv/rvv/base/intrinsic_required_ext-1.c | 2 +- .../rvv/base/intrinsic_required_ext-10.c | 2 +- .../riscv/rvv/base/intrinsic_required_ext-2.c | 2 +- .../riscv/rvv/base/intrinsic_required_ext-3.c | 2 +- .../riscv/rvv/base/intrinsic_required_ext-4.c | 2 +- .../riscv/rvv/base/intrinsic_required_ext-5.c | 2 +- .../riscv/rvv/base/intrinsic_required_ext-6.c | 2 +- .../riscv/rvv/base/intrinsic_required_ext-7.c | 2 +- .../riscv/rvv/base/intrinsic_required_ext-8.c | 2 +- .../riscv/rvv/base/intrinsic_required_ext-9.c | 2 +- .../gcc.target/riscv/rvv/base/pr114988-1.c | 2 +- .../gcc.target/riscv/rvv/base/pr114988-2.c | 2 +- .../gcc.target/riscv/rvv/base/pr120436.c | 6 +-- .../target_attribute_v_with_intrinsic-17.c | 2 +- .../target_attribute_v_with_intrinsic-18.c | 2 +- .../target_attribute_v_with_intrinsic-19.c | 2 +- .../target_attribute_v_with_intrinsic-20.c | 2 +- .../target_attribute_v_with_intrinsic-21.c | 2 +- .../target_attribute_v_with_intrinsic-22.c | 2 +- .../target_attribute_v_with_intrinsic-23.c | 2 +- .../target_attribute_v_with_intrinsic-24.c | 2 +- .../target_attribute_v_with_intrinsic-25.c | 2 +- .../target_attribute_v_with_intrinsic-26.c | 2 +- .../target_attribute_v_with_intrinsic-27.c | 2 +- .../target_attribute_v_with_intrinsic-28.c | 2 +- .../target_attribute_v_with_intrinsic-29.c | 2 +- .../target_attribute_v_with_intrinsic-3.c | 2 +- .../target_attribute_v_with_intrinsic-7.c | 2 +- .../target_attribute_v_with_intrinsic-8.c | 2 +- 32 files changed, 78 insertions(+), 45 deletions(-) create mode 100644 gcc/testsuite/gcc.target/riscv/pr127553.c diff --git a/gcc/config/riscv/riscv-vector-builtins.cc b/gcc/config/riscv/riscv-vector-builtins.cc index a7e5c24281fd..64e8127f1b5b 100644 --- a/gcc/config/riscv/riscv-vector-builtins.cc +++ b/gcc/config/riscv/riscv-vector-builtins.cc @@ -5724,56 +5724,56 @@ gimple_fold_builtin (unsigned int code, gimple_stmt_iterator *gsi, gcall *stmt) static bool validate_instance_type_required_extensions (const rvv_type_info type, - tree exp) + location_t location, tree fndecl) { uint64_t exts = type.required_extensions; if ((exts & RVV_REQUIRE_ELEN_BF_16) && !TARGET_VECTOR_ELEN_BF_16_P (riscv_vector_elen_flags)) { - error_at (EXPR_LOCATION (exp), + error_at (location, "built-in function %qE requires the " "zvfbfmin or zvfbfwma ISA extension", - exp); + fndecl); return false; } if ((exts & RVV_REQUIRE_ELEN_FP_16) && !TARGET_VECTOR_ELEN_FP_16_P (riscv_vector_elen_flags)) { - error_at (EXPR_LOCATION (exp), + error_at (location, "built-in function %qE requires the " "zvfhmin or zvfh ISA extension", - exp); + fndecl); return false; } if ((exts & RVV_REQUIRE_ELEN_FP_32) && !TARGET_VECTOR_ELEN_FP_32_P (riscv_vector_elen_flags)) { - error_at (EXPR_LOCATION (exp), + error_at (location, "built-in function %qE requires the " "zve32f, zve64f, zve64d or v ISA extension", - exp); + fndecl); return false; } if ((exts & RVV_REQUIRE_ELEN_FP_64) && !TARGET_VECTOR_ELEN_FP_64_P (riscv_vector_elen_flags)) { - error_at (EXPR_LOCATION (exp), + error_at (location, "built-in function %qE requires the zve64d or v ISA extension", - exp); + fndecl); return false; } if ((exts & RVV_REQUIRE_ELEN_64) && !TARGET_VECTOR_ELEN_64_P (riscv_vector_elen_flags)) { - error_at (EXPR_LOCATION (exp), + error_at (location, "built-in function %qE requires the " "zve64x, zve64f, zve64d or v ISA extension", - exp); + fndecl); return false; } @@ -5797,12 +5797,14 @@ expand_builtin (unsigned int code, tree exp, rtx target) { error_at (EXPR_LOCATION (exp), "built-in function %qE requires the %qs ISA extension", - exp, + rfn->decl, required_ext_to_isa_name (rfn->required)); return target; } - if (!validate_instance_type_required_extensions (rfn->instance.type, exp)) + if (!validate_instance_type_required_extensions (rfn->instance.type, + EXPR_LOCATION (exp), + rfn->decl)) return target; return function_expander (rfn->instance, rfn->decl, exp, target).expand (); @@ -5822,6 +5824,24 @@ check_builtin_call (location_t location, vec, unsigned int code, registered_function *rfn = lookup_registered_function (code); if (!rfn) return false; + + /* Only check resolved functions. */ + if (!rfn->overloaded_p) + { + if (!required_extensions_specified (rfn->required)) + { + error_at (location, + "built-in function %qE requires the %qs ISA extension", + fndecl, + required_ext_to_isa_name (rfn->required)); + return false; + } + + if (!validate_instance_type_required_extensions (rfn->instance.type, + location, fndecl)) + return false; + } + return function_checker (location, rfn->instance, fndecl, TREE_TYPE (rfn->decl), nargs, args).check (); } diff --git a/gcc/testsuite/gcc.target/riscv/pr127553.c b/gcc/testsuite/gcc.target/riscv/pr127553.c new file mode 100644 index 000000000000..9747c20ec942 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/pr127553.c @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-options "-O1 -march=rv64gc" } */ + +#include +#include +#include + +int main() { + uint8_t val = 3, dup[8]; + size_t vl = __riscv_vsetvl_e8m1(8); /* { dg-error "built-in function '__riscv_vsetvl_e8m1' requires the 'v' ISA extension" } */ + vuint8m1_t v = __riscv_vmv_v_x_u8m1(val, vl); /* { dg-error "built-in function '__riscv_vmv_v_x_u8m1' requires the 'v' ISA extension" } */ + return 0; +} diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/bug-9.c b/gcc/testsuite/gcc.target/riscv/rvv/base/bug-9.c index f7c9ad10ccba..b3d270109666 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/bug-9.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/bug-9.c @@ -7,7 +7,7 @@ vfloat16m1_t f0 (vfloat16m1_t vs2, vfloat16m1_t vs1, size_t vl) { - return __riscv_vfadd_vv_f16m1_rm (vs2, vs1, 0, vl); + return __riscv_vfadd_vv_f16m1_rm (vs2, vs1, 0, vl); /* { dg-error "built-in function '__riscv_vfadd_vv_f16m1_rm' requires the zvfhmin or zvfh ISA extension" } */ } /* { dg-error "return type 'vfloat16m1_t' requires the zvfhmin or zvfh ISA extension" "" { target { "riscv*-*-*" } } 0 } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-1.c index 143a3d66016c..7958d4f1f76d 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-1.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-1.c @@ -6,5 +6,5 @@ size_t test_3 (size_t vl) { - return __riscv_vsetvl_e8m4 (vl); /* { dg-error {built-in function '__riscv_vsetvl_e8m4\(vl\)' requires the 'v' ISA extension} } */ + return __riscv_vsetvl_e8m4 (vl); /* { dg-error {built-in function '__riscv_vsetvl_e8m4' requires the 'v' ISA extension} } */ } diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-10.c b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-10.c index b0a9851d4c77..b5d163af1a81 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-10.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-10.c @@ -7,5 +7,5 @@ vuint32m1_t __attribute__((target("arch=+v"))) test_1 (vuint32m1_t op_1, vuint32m1_t op_2, size_t vl) { - return __riscv_vsm3me_vv_u32m1 (op_1, op_2, vl); /* { dg-error {built-in function '__riscv_vsm3me_vv_u32m1\(op_1, op_2, vl\)' requires the 'zvksh' ISA extension} } */ + return __riscv_vsm3me_vv_u32m1 (op_1, op_2, vl); /* { dg-error {built-in function '__riscv_vsm3me_vv_u32m1' requires the 'zvksh' ISA extension} } */ } diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-2.c index 20ab9775a1e6..82ae95d8410b 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-2.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-2.c @@ -7,5 +7,5 @@ vuint32m1_t __attribute__((target("arch=+v"))) test_1 (vuint32m1_t op_1, vuint32m1_t op_2, size_t vl) { - return __riscv_vandn_vv_u32m1 (op_1, op_2, vl); /* { dg-error {built-in function '__riscv_vandn_vv_u32m1\(op_1, op_2, vl\)' requires the 'zvbb or zvkb' ISA extension} } */ + return __riscv_vandn_vv_u32m1 (op_1, op_2, vl); /* { dg-error {built-in function '__riscv_vandn_vv_u32m1' requires the 'zvbb or zvkb' ISA extension} } */ } diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-3.c index 9b7d37f5b333..2128c543ee54 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-3.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-3.c @@ -7,5 +7,5 @@ vuint32m1_t __attribute__((target("arch=+v"))) test_1 (vuint32m1_t op_1, size_t vl) { - return __riscv_vclz_v_u32m1 (op_1, vl); /* { dg-error {built-in function '__riscv_vclz_v_u32m1\(op_1, vl\)' requires the 'zvbb' ISA extension} } */ + return __riscv_vclz_v_u32m1 (op_1, vl); /* { dg-error {built-in function '__riscv_vclz_v_u32m1' requires the 'zvbb' ISA extension} } */ } diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-4.c b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-4.c index fdaab62b17d7..3110e278edbf 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-4.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-4.c @@ -7,5 +7,5 @@ vuint64m1_t __attribute__((target("arch=+v"))) test_1 (vuint64m1_t op_1, vuint64m1_t op_2, size_t vl) { - return __riscv_vclmul_vv_u64m1 (op_1, op_2, vl); /* { dg-error {built-in function '__riscv_vclmul_vv_u64m1\(op_1, op_2, vl\)' requires the 'zvbc' ISA extension} } */ + return __riscv_vclmul_vv_u64m1 (op_1, op_2, vl); /* { dg-error {built-in function '__riscv_vclmul_vv_u64m1' requires the 'zvbc' ISA extension} } */ } diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-5.c b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-5.c index 6a4bb431f4a0..77525ce86738 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-5.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-5.c @@ -7,5 +7,5 @@ vuint32m1_t __attribute__((target("arch=+v"))) test_1 (vuint32m1_t dest, vuint32m1_t op_1, vuint32m1_t op_2, size_t vl) { - return __riscv_vghsh_vv_u32m1 (dest, op_1, op_2, vl); /* { dg-error {built-in function '__riscv_vghsh_vv_u32m1\(dest, op_1, op_2, vl\)' requires the 'zvkg' ISA extension} } */ + return __riscv_vghsh_vv_u32m1 (dest, op_1, op_2, vl); /* { dg-error {built-in function '__riscv_vghsh_vv_u32m1' requires the 'zvkg' ISA extension} } */ } diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-6.c b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-6.c index 943a2cf653be..6df436ad616a 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-6.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-6.c @@ -7,5 +7,5 @@ vuint32m1_t __attribute__((target("arch=+v"))) test_1 (vuint32m1_t dest, vuint32mf2_t op_1, size_t vl) { - return __riscv_vaesef_vs_u32mf2_u32m1 (dest, op_1, vl); /* { dg-error {built-in function '__riscv_vaesef_vs_u32mf2_u32m1\(dest, op_1, vl\)' requires the 'zvkned' ISA extension} } */ + return __riscv_vaesef_vs_u32mf2_u32m1 (dest, op_1, vl); /* { dg-error {built-in function '__riscv_vaesef_vs_u32mf2_u32m1' requires the 'zvkned' ISA extension} } */ } diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-7.c b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-7.c index c2ccb739f6ed..d5d65fe6a602 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-7.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-7.c @@ -7,5 +7,5 @@ vuint32m1_t __attribute__((target("arch=+v"))) test_1 (vuint32m1_t dest, vuint32m1_t op_1, vuint32m1_t op_2, size_t vl) { - return __riscv_vsha2ms_vv_u32m1 (dest, op_1, op_2, vl); /* { dg-error {built-in function '__riscv_vsha2ms_vv_u32m1\(dest, op_1, op_2, vl\)' requires the 'zvknha or zvknhb' ISA extension} } */ + return __riscv_vsha2ms_vv_u32m1 (dest, op_1, op_2, vl); /* { dg-error {built-in function '__riscv_vsha2ms_vv_u32m1' requires the 'zvknha or zvknhb' ISA extension} } */ } diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-8.c b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-8.c index e4312cc0530a..1a026e2f7a2a 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-8.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-8.c @@ -7,5 +7,5 @@ vuint64m1_t __attribute__((target("arch=+v"))) test_1 (vuint64m1_t dest, vuint64m1_t op_1, vuint64m1_t op_2, size_t vl) { - return __riscv_vsha2ms_vv_u64m1 (dest, op_1, op_2, vl); /* { dg-error {built-in function '__riscv_vsha2ms_vv_u64m1\(dest, op_1, op_2, vl\)' requires the 'zvknhb' ISA extension} } */ + return __riscv_vsha2ms_vv_u64m1 (dest, op_1, op_2, vl); /* { dg-error {built-in function '__riscv_vsha2ms_vv_u64m1' requires the 'zvknhb' ISA extension} } */ } diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-9.c b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-9.c index 442d49170539..ea35b3d7e450 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-9.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/intrinsic_required_ext-9.c @@ -7,5 +7,5 @@ vuint32m1_t __attribute__((target("arch=+v"))) test_1 (vuint32m1_t op_1, size_t vl) { - return __riscv_vsm4k_vi_u32m1 (op_1, 0, vl); /* { dg-error {built-in function '__riscv_vsm4k_vi_u32m1\(op_1, 0, vl\)' requires the 'zvksed' ISA extension} } */ + return __riscv_vsm4k_vi_u32m1 (op_1, 0, vl); /* { dg-error {built-in function '__riscv_vsm4k_vi_u32m1' requires the 'zvksed' ISA extension} } */ } diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr114988-1.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr114988-1.c index b8474804c880..b797d5996b70 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr114988-1.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr114988-1.c @@ -5,5 +5,5 @@ vfloat32mf2_t test_vfwsub_wf_f32mf2(vfloat32mf2_t vs2, _Float16 rs1, size_t vl) { - return __riscv_vfwsub_wf_f32mf2(vs2, rs1, vl); /* { dg-error {built-in function '__riscv_vfwsub_wf_f32mf2\(vs2, rs1, vl\)' requires the zvfhmin or zvfh ISA extension} } */ + return __riscv_vfwsub_wf_f32mf2(vs2, rs1, vl); /* { dg-error {built-in function '__riscv_vfwsub_wf_f32mf2' requires the zvfhmin or zvfh ISA extension} } */ } diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr114988-2.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr114988-2.c index 49aa3141af31..7491359c0115 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr114988-2.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr114988-2.c @@ -5,5 +5,5 @@ vfloat32mf2_t test_vfwadd_wf_f32mf2(vfloat32mf2_t vs2, _Float16 rs1, size_t vl) { - return __riscv_vfwadd_wf_f32mf2(vs2, rs1, vl); /* { dg-error {built-in function '__riscv_vfwadd_wf_f32mf2\(vs2, rs1, vl\)' requires the zvfhmin or zvfh ISA extension} } */ + return __riscv_vfwadd_wf_f32mf2(vs2, rs1, vl); /* { dg-error {built-in function '__riscv_vfwadd_wf_f32mf2' requires the zvfhmin or zvfh ISA extension} } */ } diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/pr120436.c b/gcc/testsuite/gcc.target/riscv/rvv/base/pr120436.c index d22091e59490..3ebdf3562df4 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/pr120436.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/pr120436.c @@ -8,9 +8,9 @@ #include "riscv_vector.h" void -clean_subreg (int32_t *in, int32_t *out, size_t m) /* { dg-error {this operation requires the RVV ISA extension} } */ +clean_subreg (int32_t *in, int32_t *out, size_t m) { vint16m8_t v24, v8, v16; - vint32m8_t result = __riscv_vle32_v_i32m8 (in, 32); /* { dg-error {built-in function '__riscv_vle32_v_i32m8\(in, 32\)' requires the 'v' ISA extension} } */ - vint32m1_t v0 = __riscv_vget_v_i32m8_i32m1 (result, 0); + vint32m8_t result = __riscv_vle32_v_i32m8 (in, 32); /* { dg-error {built-in function '__riscv_vle32_v_i32m8' requires the 'v' ISA extension} } */ + vint32m1_t v0 = __riscv_vget_v_i32m8_i32m1 (result, 0); /* { dg-error {built-in function '__riscv_vget_v_i32m8_i32m1' requires the 'v' ISA extension} } */ } diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-17.c b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-17.c index ebe31f5c961b..9c5904cddc62 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-17.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-17.c @@ -7,7 +7,7 @@ vint64m1_t __attribute__((target("arch=+zve32x"))) test_1 (vint64m1_t a, vint64m1_t b, size_t vl) { - return __riscv_vadd_vv_i64m1 (a, b, vl); + return __riscv_vadd_vv_i64m1 (a, b, vl); /* { dg-error "built-in function '__riscv_vadd_vv_i64m1' requires the zve64x, zve64f, zve64d or v ISA extension" } */ } /* { dg-error "return type 'vint64m1_t' requires the zve64x, zve64f, zve64d or v ISA extension" "" { target { "riscv*-*-*" } } 0 } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-18.c b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-18.c index 7e9a101795dc..abb7e8014c70 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-18.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-18.c @@ -7,7 +7,7 @@ vfloat32m1_t __attribute__((target("arch=+zve32x"))) test_1 (vfloat32m1_t a, vfloat32m1_t b, size_t vl) { - return __riscv_vfadd_vv_f32m1 (a, b, vl); + return __riscv_vfadd_vv_f32m1 (a, b, vl); /* { dg-error "built-in function '__riscv_vfadd_vv_f32m1' requires the zve32f, zve64f, zve64d or v ISA extension" } */ } /* { dg-error "return type 'vfloat32m1_t' requires the zve32f, zve64f, zve64d or v ISA extension" "" { target { "riscv*-*-*" } } 0 } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-19.c b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-19.c index b5354f4291f9..63b350f5eccd 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-19.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-19.c @@ -7,7 +7,7 @@ vfloat16m1_t __attribute__((target("arch=+zve32x"))) test_1 (vfloat16m1_t a, vfloat16m1_t b, size_t vl) { - return __riscv_vfadd_vv_f16m1 (a, b, vl); + return __riscv_vfadd_vv_f16m1 (a, b, vl); /* { dg-error "built-in function '__riscv_vfadd_vv_f16m1' requires the zvfhmin or zvfh ISA extension" } */ } /* { dg-error "return type 'vfloat16m1_t' requires the zvfhmin or zvfh ISA extension" "" { target { "riscv*-*-*" } } 0 } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-20.c b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-20.c index c1a574d5e294..a630a02c0294 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-20.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-20.c @@ -7,7 +7,7 @@ vfloat64m1_t __attribute__((target("arch=+zve32x"))) test_1 (vfloat64m1_t a, vfloat64m1_t b, size_t vl) { - return __riscv_vfadd_vv_f64m1 (a, b, vl); + return __riscv_vfadd_vv_f64m1 (a, b, vl); /* { dg-error "built-in function '__riscv_vfadd_vv_f64m1' requires the zve64d or v ISA extension" } */ } /* { dg-error "return type 'vfloat64m1_t' requires the zve64d or v ISA extension" "" { target { "riscv*-*-*" } } 0 } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-21.c b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-21.c index 62c2815fdad1..a6a39029b396 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-21.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-21.c @@ -7,7 +7,7 @@ vint64m1_t __attribute__((target("arch=+zve32f"))) test_1 (vint64m1_t a, vint64m1_t b, size_t vl) { - return __riscv_vadd_vv_i64m1 (a, b, vl); + return __riscv_vadd_vv_i64m1 (a, b, vl); /* { dg-error "built-in function '__riscv_vadd_vv_i64m1' requires the zve64x, zve64f, zve64d or v ISA extension" } */ } /* { dg-error "return type 'vint64m1_t' requires the zve64x, zve64f, zve64d or v ISA extension" "" { target { "riscv*-*-*" } } 0 } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-22.c b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-22.c index f0b72e5060b2..bdd80cb731d1 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-22.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-22.c @@ -7,7 +7,7 @@ vfloat16m1_t __attribute__((target("arch=+zve32f"))) test_1 (vfloat16m1_t a, vfloat16m1_t b, size_t vl) { - return __riscv_vfadd_vv_f16m1 (a, b, vl); + return __riscv_vfadd_vv_f16m1 (a, b, vl); /* { dg-error "built-in function '__riscv_vfadd_vv_f16m1' requires the zvfhmin or zvfh ISA extension" } */ } /* { dg-error "return type 'vfloat16m1_t' requires the zvfhmin or zvfh ISA extension" "" { target { "riscv*-*-*" } } 0 } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-23.c b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-23.c index 9f22a182d4ca..b78f9d792d87 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-23.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-23.c @@ -7,7 +7,7 @@ vfloat64m1_t __attribute__((target("arch=+zve32f"))) test_1 (vfloat64m1_t a, vfloat64m1_t b, size_t vl) { - return __riscv_vfadd_vv_f64m1 (a, b, vl); + return __riscv_vfadd_vv_f64m1 (a, b, vl); /* { dg-error "built-in function '__riscv_vfadd_vv_f64m1' requires the zve64d or v ISA extension" } */ } /* { dg-error "return type 'vfloat64m1_t' requires the zve64d or v ISA extension" "" { target { "riscv*-*-*" } } 0 } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-24.c b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-24.c index 1006ad4af186..b6209bbd6673 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-24.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-24.c @@ -7,7 +7,7 @@ vfloat32m1_t __attribute__((target("arch=+zve64x"))) test_1 (vfloat32m1_t a, vfloat32m1_t b, size_t vl) { - return __riscv_vfadd_vv_f32m1 (a, b, vl); + return __riscv_vfadd_vv_f32m1 (a, b, vl); /* { dg-error "built-in function '__riscv_vfadd_vv_f32m1' requires the zve32f, zve64f, zve64d or v ISA extension" } */ } /* { dg-error "return type 'vfloat32m1_t' requires the zve32f, zve64f, zve64d or v ISA extension" "" { target { "riscv*-*-*" } } 0 } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-25.c b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-25.c index de36e4310b02..217bf37626ca 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-25.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-25.c @@ -7,7 +7,7 @@ vfloat16m1_t __attribute__((target("arch=+zve64x"))) test_1 (vfloat16m1_t a, vfloat16m1_t b, size_t vl) { - return __riscv_vfadd_vv_f16m1 (a, b, vl); + return __riscv_vfadd_vv_f16m1 (a, b, vl); /* { dg-error "built-in function '__riscv_vfadd_vv_f16m1' requires the zvfhmin or zvfh ISA extension" } */ } /* { dg-error "return type 'vfloat16m1_t' requires the zvfhmin or zvfh ISA extension" "" { target { "riscv*-*-*" } } 0 } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-26.c b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-26.c index f87f8c54c8de..39d687143ef7 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-26.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-26.c @@ -7,7 +7,7 @@ vfloat64m1_t __attribute__((target("arch=+zve64x"))) test_1 (vfloat64m1_t a, vfloat64m1_t b, size_t vl) { - return __riscv_vfadd_vv_f64m1 (a, b, vl); + return __riscv_vfadd_vv_f64m1 (a, b, vl); /* { dg-error "built-in function '__riscv_vfadd_vv_f64m1' requires the zve64d or v ISA extension" } */ } /* { dg-error "return type 'vfloat64m1_t' requires the zve64d or v ISA extension" "" { target { "riscv*-*-*" } } 0 } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-27.c b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-27.c index c5bc8511b677..54bb00505c28 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-27.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-27.c @@ -7,7 +7,7 @@ vfloat64m1_t __attribute__((target("arch=+zve64f"))) test_1 (vfloat64m1_t a, vfloat64m1_t b, size_t vl) { - return __riscv_vfadd_vv_f64m1 (a, b, vl); + return __riscv_vfadd_vv_f64m1 (a, b, vl); /* { dg-error "built-in function '__riscv_vfadd_vv_f64m1' requires the zve64d or v ISA extension" } */ } /* { dg-error "return type 'vfloat64m1_t' requires the zve64d or v ISA extension" "" { target { "riscv*-*-*" } } 0 } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-28.c b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-28.c index 738d2e627486..5b5bff594a83 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-28.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-28.c @@ -7,7 +7,7 @@ vfloat16m1_t __attribute__((target("arch=+zve64f"))) test_1 (vfloat16m1_t a, vfloat16m1_t b, size_t vl) { - return __riscv_vfadd_vv_f16m1 (a, b, vl); + return __riscv_vfadd_vv_f16m1 (a, b, vl); /* { dg-error "built-in function '__riscv_vfadd_vv_f16m1' requires the zvfhmin or zvfh ISA extension" } */ } /* { dg-error "return type 'vfloat16m1_t' requires the zvfhmin or zvfh ISA extension" "" { target { "riscv*-*-*" } } 0 } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-29.c b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-29.c index f82ad41cd50e..32233876a2d7 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-29.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-29.c @@ -7,7 +7,7 @@ vfloat16m1_t __attribute__((target("arch=+zve64d"))) test_1 (vfloat16m1_t a, vfloat16m1_t b, size_t vl) { - return __riscv_vfadd_vv_f16m1 (a, b, vl); + return __riscv_vfadd_vv_f16m1 (a, b, vl); /* { dg-error "built-in function '__riscv_vfadd_vv_f16m1' requires the zvfhmin or zvfh ISA extension" } */ } /* { dg-error "return type 'vfloat16m1_t' requires the zvfhmin or zvfh ISA extension" "" { target { "riscv*-*-*" } } 0 } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-3.c b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-3.c index b9aceb83682f..861d892b69a9 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-3.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-3.c @@ -7,7 +7,7 @@ vint32m1_t __attribute__((target("arch=+zbb"))) test_1 (vint32m1_t a, vint32m1_t b, size_t vl) { - return __riscv_vadd_vv_i32m1 (a, b, vl); + return __riscv_vadd_vv_i32m1 (a, b, vl); /* { dg-error "built-in function '__riscv_vadd_vv_i32m1' requires the 'v' ISA extension" } */ } /* { dg-error "return type 'vint32m1_t' requires the V ISA extension" "" { target { "riscv*-*-*" } } 0 } */ diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-7.c b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-7.c index d1dd811d14b1..dd212d0fd6b7 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-7.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-7.c @@ -5,5 +5,5 @@ size_t test_1 (size_t vl) { - return __riscv_vsetvl_e8m4 (vl); /* { dg-error {built-in function '__riscv_vsetvl_e8m4\(vl\)' requires the 'v' ISA extension} } */ + return __riscv_vsetvl_e8m4 (vl); /* { dg-error {built-in function '__riscv_vsetvl_e8m4' requires the 'v' ISA extension} } */ } diff --git a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-8.c b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-8.c index 9ff4c238124d..83f040a82a7f 100644 --- a/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-8.c +++ b/gcc/testsuite/gcc.target/riscv/rvv/base/target_attribute_v_with_intrinsic-8.c @@ -19,5 +19,5 @@ test_2 () size_t test_3 (size_t vl) { - return __riscv_vsetvl_e8m4 (vl); /* { dg-error {built-in function '__riscv_vsetvl_e8m4\(vl\)' requires the 'v' ISA extension} } */ + return __riscv_vsetvl_e8m4 (vl); /* { dg-error {built-in function '__riscv_vsetvl_e8m4' requires the 'v' ISA extension} } */ } From a924d879f01d00d6c29e870c51bebcbf5e5a96eb Mon Sep 17 00:00:00 2001 From: Robin Dapp Date: Fri, 25 Sep 2026 15:39:34 +0200 Subject: [PATCH 491/584] RISC-V: Consider spills in conv-dynamic LMUL [PR127075]. This patch makes -mrvv-max-lmul=conv-dynamic spill aware. As reported by Anton, Peter in PR127075, we don't consider spilling when letting the LMUL decision just be dependent on the size ratio of largest and smallest type. This causes spills when building x264 with the conv-dynamic mode. Although the original idea was to have a more deterministic approach than pure "dynamic", determinism alone is not too helpful when spills are still possible. Thus, this patch merges the spill estimate of "dynamic" into "conv-dynamic" and also corrects some slight mistakes in "dynamic". I factored out the lmul-comparison logic into its own function so better_main_loop_than_p is a bit easier to follow. While at it, I renamed some functions and computed the type size ratio in add_stmt_cost which is much more straightforward than before. PR target/127075 gcc/ChangeLog: * config/riscv/riscv-vector-costs.cc (compute_estimated_lmul): Rename... (estimate_lmul): ...To this. (compute_lmul_from_conversion_ratio): Remove. (costs::compute_live_ranges_and_lmul): Remove param. (costs::compute_conversion_dynamic_lmul): Remove. (costs::has_unexpected_spills_p): Rename... (costs::has_spills_p): ...To This. (costs::record_lmul_spills): Adjust comment. (costs::record_potential_unexpected_spills): Rename... (costs::record_potential_spills): ...To this. (costs::compare_lmul_to): New function. (costs::better_main_loop_than_p): Call new function. (costs::record_type_sizes): New function. (costs::add_stmt_cost): Call new function. (costs::finish_cost): Compute type ratio for LMUL. * config/riscv/riscv-vector-costs.h: Declare new function. gcc/testsuite/ChangeLog: * gcc.dg/vect/costmodel/riscv/rvv/pr127075.c: New test. --- gcc/config/riscv/riscv-vector-costs.cc | 272 +++++++++--------- gcc/config/riscv/riscv-vector-costs.h | 16 +- .../vect/costmodel/riscv/rvv/pr127075.c | 29 ++ 3 files changed, 176 insertions(+), 141 deletions(-) create mode 100644 gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/pr127075.c diff --git a/gcc/config/riscv/riscv-vector-costs.cc b/gcc/config/riscv/riscv-vector-costs.cc index cb7a4bed9617..b7d22cb505b3 100644 --- a/gcc/config/riscv/riscv-vector-costs.cc +++ b/gcc/config/riscv/riscv-vector-costs.cc @@ -663,42 +663,15 @@ costs::need_additional_vector_vars_p (stmt_vec_info stmt_info, /* Return the LMUL of the current analysis. */ static int -compute_estimated_lmul (loop_vec_info loop_vinfo, machine_mode mode) +estimate_lmul (loop_vec_info loop_vinfo, machine_mode mode) { gcc_assert (GET_MODE_BITSIZE (mode).is_constant ()); - int regno_alignment = riscv_get_v_regno_alignment (loop_vinfo->vector_mode); - if (riscv_vls_mode_p (loop_vinfo->vector_mode)) - return regno_alignment; - else - { - int estimated_vf = vect_vf_for_cost (loop_vinfo); - int estimated_lmul = estimated_vf * GET_MODE_BITSIZE (mode).to_constant () - / TARGET_MIN_VLEN; - if (estimated_lmul > RVV_M8) - return RVV_M8; - else - return estimated_lmul; - } - return 0; -} - -/* Compute LMUL based on the ratio of biggest to smallest type size. - This is used for RVV_CONV_DYNAMIC. */ -static int -compute_lmul_from_conversion_ratio (machine_mode biggest_mode, - machine_mode smallest_mode) -{ - gcc_assert (GET_MODE_BITSIZE (biggest_mode).is_constant ()); - gcc_assert (GET_MODE_BITSIZE (smallest_mode).is_constant ()); - - unsigned int biggest_size = GET_MODE_BITSIZE (biggest_mode).to_constant (); - unsigned int smallest_size = GET_MODE_BITSIZE (smallest_mode).to_constant (); - - int lmul = biggest_size / smallest_size; - lmul = std::min (lmul, (int) RVV_M8); - lmul = std::max (lmul, (int) RVV_M1); - - return lmul; + int estimated_vf = vect_vf_for_cost (loop_vinfo); + int estimated_lmul = estimated_vf * GET_MODE_BITSIZE (mode).to_constant () + / TARGET_MIN_VLEN; + estimated_lmul = std::min (estimated_lmul, (int) RVV_M8); + estimated_lmul = std::max (estimated_lmul, (int) RVV_M1); + return estimated_lmul; } /* Update the live ranges according PHI. @@ -903,12 +876,7 @@ costs::compute_live_ranges_and_lmul (loop_vec_info loop_vinfo, update_local_live_ranges (loop_vinfo, program_points_per_bb, live_ranges_per_bb, &biggest_mode); - if (rvv_max_lmul == RVV_CONV_DYNAMIC) - lmul = compute_lmul_from_conversion_ratio (biggest_mode, smallest_mode); - else - lmul = compute_estimated_lmul (loop_vinfo, biggest_mode); - - gcc_assert (lmul <= RVV_M8); + lmul = estimate_lmul (loop_vinfo, biggest_mode); } /* Helper to clean up live range data structures. */ @@ -933,30 +901,9 @@ costs::cleanup_live_range_data (hash_map> live_ranges_per_bb.empty (); } -/* Compute LMUL for RVV_CONV_DYNAMIC mode based on conversion ratio. */ -void -costs::compute_conversion_dynamic_lmul (loop_vec_info loop_vinfo) -{ - hash_map> program_points_per_bb; - hash_map> live_ranges_per_bb; - machine_mode biggest_mode, smallest_mode; - int lmul; - - compute_live_ranges_and_lmul (loop_vinfo, program_points_per_bb, - live_ranges_per_bb, biggest_mode, - smallest_mode, lmul); - - /* Store the computed LMUL and biggest mode for later comparison - in cost model. */ - m_computed_lmul_from_conv = lmul; - m_biggest_mode_for_conv = biggest_mode; - - cleanup_live_range_data (program_points_per_bb, live_ranges_per_bb); -} - -/* Compute the maximum live V_REGS and check for unexpected spills. */ +/* Compute the maximum live V_REGS and check for spills. */ bool -costs::has_unexpected_spills_p (loop_vec_info loop_vinfo) +costs::has_spills_p (loop_vec_info loop_vinfo) { hash_map> program_points_per_bb; hash_map> live_ranges_per_bb; @@ -1022,18 +969,19 @@ costs::analyze_loop_vinfo (loop_vec_info loop_vinfo) void costs::record_lmul_spills (loop_vec_info loop_vinfo) { - /* Detect whether the LOOP has unexpected spills. */ - record_potential_unexpected_spills (loop_vinfo); + /* Detect whether the LOOP spills. */ + record_potential_spills (loop_vinfo); } /* Analyze the vectorized program statements and use dynamic LMUL - heuristic to detect whether the loop has unexpected spills. */ + heuristic to detect whether the loop spills. */ void -costs::record_potential_unexpected_spills (loop_vec_info loop_vinfo) +costs::record_potential_spills (loop_vec_info loop_vinfo) { /* We only want to apply the heuristic if LOOP_VINFO is being vectorized for VLA and known NITERS VLS loop. */ - if (rvv_max_lmul == RVV_DYNAMIC + if ((rvv_max_lmul == RVV_DYNAMIC + || rvv_max_lmul == RVV_CONV_DYNAMIC) && (m_cost_type == VLA_VECTOR_COST || (m_cost_type == VLS_VECTOR_COST && LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)))) @@ -1041,12 +989,10 @@ costs::record_potential_unexpected_spills (loop_vec_info loop_vinfo) bool post_dom_available_p = dom_info_available_p (CDI_POST_DOMINATORS); if (!post_dom_available_p) calculate_dominance_info (CDI_POST_DOMINATORS); - m_has_unexpected_spills_p = has_unexpected_spills_p (loop_vinfo); + m_has_spills_p = has_spills_p (loop_vinfo); if (!post_dom_available_p) free_dominance_info (CDI_POST_DOMINATORS); } - else if (rvv_max_lmul == RVV_CONV_DYNAMIC) - compute_conversion_dynamic_lmul (loop_vinfo); } /* Decide whether to use the unrolling heuristic described above @@ -1181,6 +1127,61 @@ compare_loop_overhead (loop_vec_info this_loop_vinfo, return 0; } +/* Decide whether the LMUL of this or the OTHER cost is preferable if we are + using dynamic LMUL selection. Return -1 if the current cost is better, 1 if + the other is better, and 0 if they are equal. */ + +int +costs::compare_lmul_to (const vector_costs *uncast_other) const +{ + auto other = static_cast (uncast_other); + auto this_loop_vinfo = as_a (this->m_vinfo); + auto other_loop_vinfo = as_a (other->m_vinfo); + + if (rvv_max_lmul != RVV_DYNAMIC + && rvv_max_lmul != RVV_CONV_DYNAMIC) + return 0; + + /* First, filter out LMULs that exceed the maximum if we have one. */ + if (rvv_max_lmul == RVV_CONV_DYNAMIC) + { + int this_vf = vect_vf_for_cost (this_loop_vinfo); + int other_vf = vect_vf_for_cost (other_loop_vinfo); + + unsigned int largest_elsz + = tree_to_uhwi (TYPE_SIZE (this->m_largest_type)); + + /* Estimate LMUL from VF * size of largest type / MIN_VLEN. */ + int this_lmul = (this_vf * largest_elsz) / TARGET_MIN_VLEN; + int other_lmul = (other_vf * largest_elsz) / TARGET_MIN_VLEN; + + /* Clamp to valid LMUL range. */ + this_lmul = MAX (1, MIN (this_lmul, 8)); + other_lmul = MAX (1, MIN (other_lmul, 8)); + gcc_assert (this->m_type_ratio_lmul == other->m_type_ratio_lmul); + + if (this_lmul <= this->m_type_ratio_lmul + && other_lmul > this->m_type_ratio_lmul) + return -1; + + if (other_lmul <= this->m_type_ratio_lmul + && this_lmul > this->m_type_ratio_lmul) + return 1; + } + + /* Then filter out spilling modes. */ + if (this->m_has_spills_p != other->m_has_spills_p) + { + if (dump_enabled_p ()) + dump_printf_loc (MSG_NOTE, vect_location, + "Preferring smaller LMUL loop because" + " it has unexpected spills\n"); + return !this->m_has_spills_p ? -1 : 1; + } + + return 0; +} + bool costs::better_main_loop_than_p (const vector_costs *uncast_other) const { @@ -1196,6 +1197,10 @@ costs::better_main_loop_than_p (const vector_costs *uncast_other) const GET_MODE_NAME (other_loop_vinfo->vector_mode), vect_vf_for_cost (other_loop_vinfo)); + int diff = compare_lmul_to (uncast_other); + if (diff) + return diff < 0; + /* Apply the unrolling heuristic described above m_unrolled_vls_niters. */ if (bool (m_unrolled_vls_stmts) != bool (other->m_unrolled_vls_stmts) && m_cost_type != other->m_cost_type) @@ -1211,76 +1216,25 @@ costs::better_main_loop_than_p (const vector_costs *uncast_other) const return other_prefer_unrolled; } } - else if (rvv_max_lmul == RVV_CONV_DYNAMIC) + else if (riscv_vla_mode_p (other_loop_vinfo->vector_mode)) { - if (this->m_computed_lmul_from_conv > 0 - && other->m_computed_lmul_from_conv > 0 - && this->m_biggest_mode_for_conv != VOIDmode) + /* We don't want modes that would span more scalar iterations than + we actually have. + ??? We might want to revisit this in the light of VLMAX-dependent + vs VL-dependent latency. */ + if (LOOP_VINFO_NITERS_KNOWN_P (other_loop_vinfo)) { - int this_vf = vect_vf_for_cost (this_loop_vinfo); - int other_vf = vect_vf_for_cost (other_loop_vinfo); - - /* Get element size from the biggest mode. */ - unsigned int element_bits - = GET_MODE_BITSIZE (this->m_biggest_mode_for_conv).to_constant (); - - /* Estimate LMUL from VF * element_size / MIN_VLEN. */ - int this_lmul = (this_vf * element_bits) / TARGET_MIN_VLEN; - int other_lmul = (other_vf * element_bits) / TARGET_MIN_VLEN; - - /* Clamp to valid LMUL range. */ - this_lmul = MAX (1, MIN (this_lmul, 8)); - other_lmul = MAX (1, MIN (other_lmul, 8)); - - int target_lmul = this->m_computed_lmul_from_conv; - - /* Prefer the LMUL that exactly matches our computed ratio. */ - if (this_lmul == target_lmul && other_lmul != target_lmul) + if (maybe_gt (LOOP_VINFO_INT_NITERS (this_loop_vinfo), + LOOP_VINFO_VECT_FACTOR (this_loop_vinfo))) { if (dump_enabled_p ()) dump_printf_loc (MSG_NOTE, vect_location, - "Preferring LMUL=%d loop because it matches" - " conversion ratio (other LMUL=%d)\n", - this_lmul, other_lmul); - return true; - } - else if (this_lmul != target_lmul && other_lmul == target_lmul) - { - if (dump_enabled_p ()) - dump_printf_loc (MSG_NOTE, vect_location, - "Preferring other LMUL=%d loop because it" - " matches conversion ratio" - " (this LMUL=%d)\n", other_lmul, this_lmul); + "Keep current LMUL loop because" + " known NITERS exceed the new VF\n"); return false; } } } - else if (rvv_max_lmul == RVV_DYNAMIC) - { - if (this->m_has_unexpected_spills_p != other->m_has_unexpected_spills_p) - { - if (dump_enabled_p ()) - dump_printf_loc (MSG_NOTE, vect_location, - "Preferring smaller LMUL loop because" - " it has unexpected spills\n"); - return !this->m_has_unexpected_spills_p; - } - else if (riscv_vla_mode_p (other_loop_vinfo->vector_mode)) - { - if (LOOP_VINFO_NITERS_KNOWN_P (other_loop_vinfo)) - { - if (maybe_gt (LOOP_VINFO_INT_NITERS (this_loop_vinfo), - LOOP_VINFO_VECT_FACTOR (this_loop_vinfo))) - { - if (dump_enabled_p ()) - dump_printf_loc (MSG_NOTE, vect_location, - "Keep current LMUL loop because" - " known NITERS exceed the new VF\n"); - return false; - } - } - } - } /* Fall back to generic costing if either iteration count is unknown. For known iteration counts, include loop overhead when comparing different @@ -1291,7 +1245,7 @@ costs::better_main_loop_than_p (const vector_costs *uncast_other) const || !LOOP_VINFO_NITERS_KNOWN_P (other_loop_vinfo)) return vector_costs::better_main_loop_than_p (other); - int diff = compare_inside_loop_cost (other); + diff = compare_inside_loop_cost (other); if (diff != 0) return diff < 0; @@ -1580,6 +1534,42 @@ costs::adjust_stmt_cost (enum vect_cost_for_stmt kind, loop_vec_info loop, return stmt_cost; } +/* Record the smallest and largest type for this loop only considering + loads and stores. The ratio of largest/smallest type can then be used + as LMUL so the load/store throughput is maximized. */ + +void +costs::record_type_sizes (vect_cost_for_stmt kind, stmt_vec_info stmt_info, + tree vectype) +{ + tree type = NULL_TREE; + if (vectype && VECTOR_TYPE_P (vectype) + && !VECTOR_BOOLEAN_TYPE_P (vectype)) + type = TREE_TYPE (vectype); + else if (tree lhs = gimple_get_lhs (STMT_VINFO_STMT (stmt_info))) + type = TREE_TYPE (lhs); + + if (!type + || TREE_CODE (type) == BOOLEAN_TYPE + || !TYPE_SIZE (type) + || !tree_fits_uhwi_p (TYPE_SIZE (type))) + return; + + unsigned HOST_WIDE_INT size = tree_to_uhwi (TYPE_SIZE (type)); + if (!m_largest_type || size > tree_to_uhwi (TYPE_SIZE (m_largest_type))) + m_largest_type = type; + + /* ??? What about scalar loads and a vec_construct or similar? */ + bool load_p = (kind == vector_load || kind == unaligned_load + || kind == vector_gather_load); + bool store_p = (kind == vector_store || kind == unaligned_store + || kind == vector_scatter_store); + if ((load_p || store_p) + && (!m_smallest_type + || size < tree_to_uhwi (TYPE_SIZE (m_smallest_type)))) + m_smallest_type = type; +} + unsigned costs::add_stmt_cost (int count, vect_cost_for_stmt kind, stmt_vec_info stmt_info, slp_tree node, tree vectype, @@ -1594,6 +1584,10 @@ costs::add_stmt_cost (int count, vect_cost_for_stmt kind, vectype = TREE_TYPE (lhs); } + if (stmt_info && where == vect_body + && m_cost_type != SCALAR_COST) + record_type_sizes (kind, stmt_info, vectype); + int stmt_cost = targetm.vectorize.builtin_vectorization_cost (kind, vectype, misalign); @@ -1719,6 +1713,18 @@ costs::finish_cost (const vector_costs *scalar_costs) { if (loop_vec_info loop_vinfo = dyn_cast (m_vinfo)) { + if (m_largest_type && m_smallest_type) + { + unsigned HOST_WIDE_INT ratio + = tree_to_uhwi (TYPE_SIZE (m_largest_type)) + / tree_to_uhwi (TYPE_SIZE (m_smallest_type)); + ratio = std::min (ratio, (unsigned HOST_WIDE_INT) RVV_M8); + ratio = std::max (ratio, (unsigned HOST_WIDE_INT) RVV_M1); + m_type_ratio_lmul = ratio; + } + else + m_type_ratio_lmul = 1; + record_lmul_spills (loop_vinfo); adjust_vect_cost_per_loop (loop_vinfo); diff --git a/gcc/config/riscv/riscv-vector-costs.h b/gcc/config/riscv/riscv-vector-costs.h index ab506106fcae..45d0f9a3337f 100644 --- a/gcc/config/riscv/riscv-vector-costs.h +++ b/gcc/config/riscv/riscv-vector-costs.h @@ -103,13 +103,13 @@ class costs : public vector_costs It's true when LMUL of loop vectorization factor > 1 and has unexpected V_REGS spills according to the analysis. */ - bool m_has_unexpected_spills_p = false; - void record_potential_unexpected_spills (loop_vec_info); + bool m_has_spills_p = false; + void record_potential_spills (loop_vec_info); - /* For RVV_DYNAMIC_CONV mode, store the LMUL computed from conversion ratio - and the biggest mode used in the computation. */ - int m_computed_lmul_from_conv = 0; - machine_mode m_biggest_mode_for_conv = VOIDmode; + tree m_largest_type = NULL_TREE; + tree m_smallest_type = NULL_TREE; + HOST_WIDE_INT m_type_ratio_lmul = 0; + void record_type_sizes (vect_cost_for_stmt, stmt_vec_info, tree); void compute_local_program_points (vec_info *, hash_map> &); @@ -128,8 +128,7 @@ class costs : public vector_costs machine_mode &, machine_mode &, int &); void cleanup_live_range_data (hash_map> &, hash_map> &); - bool has_unexpected_spills_p (loop_vec_info); - void compute_conversion_dynamic_lmul (loop_vec_info); + bool has_spills_p (loop_vec_info); bool need_additional_vector_vars_p (stmt_vec_info, slp_tree); void adjust_vect_cost_per_loop (loop_vec_info); @@ -143,6 +142,7 @@ class costs : public vector_costs tree vectype, vect_cost_model_location where, unsigned stmt_cost); + int compare_lmul_to (const vector_costs *) const; }; } // namespace riscv_vector diff --git a/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/pr127075.c b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/pr127075.c new file mode 100644 index 000000000000..651eecd28eff --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/costmodel/riscv/rvv/pr127075.c @@ -0,0 +1,29 @@ +/* { dg-do compile } */ +/* { dg-options "-O3 -march=rv64gcv -mabi=lp64d -mrvv-max-lmul=conv-dynamic" } */ + +/* Ensure we choose no larger than LMUL2. LMUL4 and LMUL8 cause spilling. */ + +#include + +void +wide (uint8_t *__restrict a, uint8_t *__restrict b, + uint8_t *__restrict c, uint8_t *__restrict d, + int64_t *__restrict o0, int64_t *__restrict o1, + int64_t *__restrict o2, int64_t *__restrict o3, + int64_t *__restrict o4, int64_t *__restrict o5, int n) +{ + for (int i = 0; i < n; i++) + { + int64_t va = a[i], vb = b[i], vc = c[i], vd = d[i]; + int64_t t0 = va + vb, t1 = vb + vc, t2 = vc + vd, t3 = vd + va; + int64_t t4 = va * vb, t5 = vb * vc, t6 = vc * vd, t7 = vd * va; + o0[i] = t0 + t4; + o1[i] = t1 + t5; + o2[i] = t2 + t6; + o3[i] = t3 + t7; + o4[i] = t0 * t1 + t2 * t3; + o5[i] = t4 * t5 + t6 * t7; + } +} + +/* { dg-final { scan-assembler-not "vs\[1248\]r" } } */ From 6ed3cd0acb6d79838713bc22c0edfc2d98a5a16e Mon Sep 17 00:00:00 2001 From: "James K. Lowden" Date: Mon, 28 Sep 2026 16:32:07 -0400 Subject: [PATCH 492/584] cobol: Remove disused code in lexer and parser. The new PICTURE automaton does validation previously done incompletely with regular expressions. Remove those parts that are not used, now that the lexer returns a validated PICTURE token. gcc/cobol/ChangeLog: * cdf.y: Synchronize token values. * parse.y: Remove alphanumeric-edited and numeric-edited nonterminals. * picture.cc (picsym_settable): Allow only numeric with 'S' in PICTURE. * scan.l: Remove lexing for alphanumeric-edited and numeric-edited. * token_names.h: Regenerate. --- gcc/cobol/cdf.y | 88 +- gcc/cobol/parse.y | 475 +++---- gcc/cobol/picture.cc | 36 + gcc/cobol/scan.l | 93 +- gcc/cobol/token_names.h | 2794 +++++++++++++++++++-------------------- 5 files changed, 1692 insertions(+), 1794 deletions(-) diff --git a/gcc/cobol/cdf.y b/gcc/cobol/cdf.y index f6ca89f9e048..a4508d8d6dee 100644 --- a/gcc/cobol/cdf.y +++ b/gcc/cobol/cdf.y @@ -297,7 +297,7 @@ apply_cdf_turn( const exception_turn_t& turn ) { %type namelit name_any name_one %type name subscript subscripts inof %token BOOL -%token FEATURE 401 NUMBER 309 EXCEPTION_NAME 284 "EXCEPTION NAME" +%token FEATURE 397 NUMBER 305 EXCEPTION_NAME 284 "EXCEPTION NAME" %type cdf_expr %type cdf_relexpr cdf_reloper cdf_and cdf_bool_expr @@ -309,56 +309,56 @@ apply_cdf_turn( const exception_turn_t& turn ) { %type cdf_stackable -%token BY 521 -%token COPY 398 -%token CDF_DISPLAY 419 ">>DISPLAY" -%token IN 639 +%token BY 517 +%token COPY 394 +%token CDF_DISPLAY 415 ">>DISPLAY" +%token IN 635 %token NAME 290 -%token NUMSTR 311 "numeric literal" -%token OF 722 -%token PSEUDOTEXT 755 -%token REPLACING 777 -%token READY 406 TRACE 413 RESET 407 -%token LITERAL 304 -%token SUPPRESS 412 - -%token LSUB 403 "(" -%token SUBSCRIPT 411 RSUB 408 ")" - -%token CDF_DEFINE 418 ">>DEFINE" -%token CDF_IF 420 ">>IF" -%token CDF_ELSE 421 ">>ELSE" -%token CDF_END_IF 422 ">>END-IF" -%token CDF_EVALUATE 423 ">>EVALUATE" -%token CDF_WHEN 424 ">>WHEN" -%token CDF_END_EVALUATE 425 ">>END-EVALUATE" - -%token ALL 485 -%token CALL_CONVENTION 426 ">>CALL-CONVENTION" -%token COBOL_WORDS 415 ">>COBOL-WORDS" -%token CDF_PUSH 429 ">>PUSH" -%token CDF_POP 430 ">>POP" -%token SOURCE_FORMAT 431 ">>SOURCE FORMAT" - -%token AS 503 CONSTANT 397 DEFINED 399 +%token NUMSTR 307 "numeric literal" +%token OF 718 +%token PSEUDOTEXT 751 +%token REPLACING 773 +%token READY 402 TRACE 409 RESET 403 +%token LITERAL 300 +%token SUPPRESS 408 + +%token LSUB 399 "(" +%token SUBSCRIPT 407 RSUB 404 ")" + +%token CDF_DEFINE 414 ">>DEFINE" +%token CDF_IF 416 ">>IF" +%token CDF_ELSE 417 ">>ELSE" +%token CDF_END_IF 418 ">>END-IF" +%token CDF_EVALUATE 419 ">>EVALUATE" +%token CDF_WHEN 420 ">>WHEN" +%token CDF_END_EVALUATE 421 ">>END-EVALUATE" + +%token ALL 481 +%token CALL_CONVENTION 422 ">>CALL-CONVENTION" +%token COBOL_WORDS 411 ">>COBOL-WORDS" +%token CDF_PUSH 425 ">>PUSH" +%token CDF_POP 426 ">>POP" +%token SOURCE_FORMAT 427 ">>SOURCE FORMAT" + +%token AS 499 CONSTANT 393 DEFINED 395 %type DEFINED -%token OTHER 734 PARAMETER_kw 404 "PARAMETER" -%token OFF 723 OVERRIDE 405 -%token THRU 979 -%token TRUE_kw 848 "True" +%token OTHER 730 PARAMETER_kw 400 "PARAMETER" +%token OFF 719 OVERRIDE 401 +%token THRU 978 +%token TRUE_kw 844 "True" -%token CALL_COBOL 427 "CALL" -%token CALL_VERBATIM 428 "CALL (as C)" +%token CALL_COBOL 423 "CALL" +%token CALL_VERBATIM 424 "CALL (as C)" -%token TURN 850 CHECKING 531 LOCATION 683 ON 725 WITH 877 +%token TURN 846 CHECKING 527 LOCATION 679 ON 721 WITH 873 -%left OR 980 -%left AND 982 -%right NOT 983 -%left '<' '>' _EQ 303 "EQUAL" _NE 984 _LE 985 _GE 986 +%left OR 979 +%left AND 981 +%right NOT 982 +%left '<' '>' _EQ 299 "EQUAL" _NE 983 _LE 984 _GE 985 %left '-' '+' %left '*' '/' -%right NEG 988 +%right NEG 987 %require "3.8.2" // for C++ output %language "c++" diff --git a/gcc/cobol/parse.y b/gcc/cobol/parse.y index 25256c516d18..441c4de259ea 100644 --- a/gcc/cobol/parse.y +++ b/gcc/cobol/parse.y @@ -58,7 +58,7 @@ #include "semantic_token.h" struct coll_alphanat_t { - const char *alpha, *national; + const char *alpha, *national; }; struct label_pair_t { @@ -72,7 +72,7 @@ int token; cbl_refer_t *value; }; - + class locale_tgt_t { char user_system_default; std::vector categories; @@ -95,7 +95,7 @@ class locale_tgt_t { categories.push_back(token); return *this; } - + bool is_default() const { return 0 < user_system_default; } char default_of() const { assert(categories.empty()); @@ -149,10 +149,10 @@ class locale_tgt_t { cbl_encoding_t encode_as() const { switch(prefix[0]) { case '\0': - case 'X': - case 'Z': + case 'X': + case 'Z': return current_encoding('A'); - case 'N': + case 'N': return current_encoding('N'); default: dbgmsg("no such prefix '%s'", prefix); @@ -339,7 +339,7 @@ class locale_tgt_t { %define api.location.type {cbl_loc_t} %{ -// yyssa never freed: +// yyssa never freed: // https://lists.nongnu.org/archive/html/help-bison/2021-01/msg00021.html #pragma GCC diagnostic ignored "-Wfree-nonheap-object" @@ -401,11 +401,8 @@ class locale_tgt_t { NAME NAME88 "Level 88 NAME" NUME "Name" - NUMED "NUMERIC-EDITED picture" - NUMED_CR "NUMERIC-EDITED CR picture" - NUMED_DB "NUMERIC-EDITED DB picture" %token PICTURE -%token NINEDOT NINES NINEV PIC_P "PICTURE P symbol" ONES +%token NINES NINEV PIC_P "PICTURE P symbol" ONES %token SPACES _EQ "EQUAL" %token LITERAL %token END EOP @@ -422,7 +419,7 @@ class locale_tgt_t { %token PROCESS SECTION %token STANDARD_ALPHABET "STANDARD ALPHABET" %token SWITCH -%token UPSI +%token UPSI %token ZERO /* environment names */ @@ -444,7 +441,7 @@ class locale_tgt_t { /* tokens without semantic value */ /* CDF (COPY and >> defined here but used in cdf.y) */ - + %token // CDF Flag-02 operands FLAG_02 MOVE_TO_SAME_NAME @@ -464,10 +461,10 @@ class locale_tgt_t { ZERO_LENGTH // boolean operators - B_AND B_NOT B_OR + B_AND B_NOT B_OR B_SHIFT_L B_SHIFT_LC B_SHIFT_R B_SHIFT_RC B_XOR - + BASIS CBL CONSTANT COPY DEFINED ENTER FEATURE INSERTT LSUB "(" @@ -635,7 +632,7 @@ class locale_tgt_t { PACKED_DECIMAL PADDING PAGE PAGE_COUNTER "PAGE-COUNTER" - PF PH PI PIC + PF PH PI PIC PLUS PRESENT_VALUE PRINT_SWITCH PROCEDURES PROCEED PROCESSING PROGRAM_ID "PROGRAM-ID" @@ -683,7 +680,7 @@ class locale_tgt_t { TRY TURN TYPE TYPEDEF ULENGTH UNBOUNDED UNIT UNITS UNIT_RECORD UNTIL - UP UPON UPOS UPPER_CASE USAGE USING + UP UPON UPOS UPPER_CASE USAGE USING USUBSTR USUPPLEMENTARY UTILITY UUID4 UVALID UWIDTH VALIDATING VALUE VARIANCE VARYING VOLATILE @@ -778,9 +775,9 @@ class locale_tgt_t { %type true_false posneg eval_posneg %type open_io alphabet_etc %type device_name -%type numed context_word ctx_name locale_spec selected_file -%type char_class_locales coll_alphanats -%type coll_alphanat +%type context_word ctx_name locale_spec selected_file +%type char_class_locales coll_alphanats +%type coll_alphanat %type namestr alphabet_lit program_as repo_as %type perform_cond kind_of_name %type alloc_ret @@ -818,7 +815,7 @@ class locale_tgt_t { %type filename read_body write_body delete_body %type

        Backtrace +

        + + ``` + + ``` + +

        +
        diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 000000000000..24f920bc9776 --- /dev/null +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,22 @@ +Thank you for making Rust GCC better! + +If your PR fixes an issue, you can add "Fixes #issue_number" into this +PR description and the git commit message. This way the issue will be +automatically closed when your PR is merged. If your change addresses +an issue but does not fully fix it please mark it as "Addresses #issue_number" +in the git commit message. + +Here is a checklist to help you with your PR. + +- \[ ] GCC development requires copyright assignment or the Developer's Certificate of Origin sign-off, see https://gcc.gnu.org/contribute.html or https://gcc.gnu.org/dco.html +- \[ ] Read contributing guidlines +- \[ ] `make check-rust` passes locally +- \[ ] Run `clang-format` +- \[ ] Added any relevant test cases to `gcc/testsuite/rust/` + +Note that you can skip the above if you are just opening a WIP PR in +order to get feedback. +--- + +*Please write a comment explaining your change. This is the message +that will be part of the merge commit. From aa00dfab9b3d35ec1f61ac7e45e3985b622fbaeb Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Thu, 15 Apr 2021 10:15:46 +0100 Subject: [PATCH 523/584] Create CODE_OF_CONDUCT.md Adding a code of conduct lays out rules that we can all follow in the project. --- CODE_OF_CONDUCT.md | 128 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 128 insertions(+) create mode 100644 CODE_OF_CONDUCT.md diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 000000000000..4de8b251436d --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,128 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +We as members, contributors, and leaders pledge to make participation in our +community a harassment-free experience for everyone, regardless of age, body +size, visible or invisible disability, ethnicity, sex characteristics, gender +identity and expression, level of experience, education, socio-economic status, +nationality, personal appearance, race, religion, or sexual identity +and orientation. + +We pledge to act and interact in ways that contribute to an open, welcoming, +diverse, inclusive, and healthy community. + +## Our Standards + +Examples of behavior that contributes to a positive environment for our +community include: + +* Demonstrating empathy and kindness toward other people +* Being respectful of differing opinions, viewpoints, and experiences +* Giving and gracefully accepting constructive feedback +* Accepting responsibility and apologizing to those affected by our mistakes, + and learning from the experience +* Focusing on what is best not just for us as individuals, but for the + overall community + +Examples of unacceptable behavior include: + +* The use of sexualized language or imagery, and sexual attention or + advances of any kind +* Trolling, insulting or derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or email + address, without their explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Enforcement Responsibilities + +Community leaders are responsible for clarifying and enforcing our standards of +acceptable behavior and will take appropriate and fair corrective action in +response to any behavior that they deem inappropriate, threatening, offensive, +or harmful. + +Community leaders have the right and responsibility to remove, edit, or reject +comments, commits, code, wiki edits, issues, and other contributions that are +not aligned to this Code of Conduct, and will communicate reasons for moderation +decisions when appropriate. + +## Scope + +This Code of Conduct applies within all community spaces, and also applies when +an individual is officially representing the community in public spaces. +Examples of representing our community include using an official e-mail address, +posting via an official social media account, or acting as an appointed +representative at an online or offline event. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported to the community leaders responsible for enforcement at +https://github.com/orgs/Rust-GCC/people. +All complaints will be reviewed and investigated promptly and fairly. + +All community leaders are obligated to respect the privacy and security of the +reporter of any incident. + +## Enforcement Guidelines + +Community leaders will follow these Community Impact Guidelines in determining +the consequences for any action they deem in violation of this Code of Conduct: + +### 1. Correction + +**Community Impact**: Use of inappropriate language or other behavior deemed +unprofessional or unwelcome in the community. + +**Consequence**: A private, written warning from community leaders, providing +clarity around the nature of the violation and an explanation of why the +behavior was inappropriate. A public apology may be requested. + +### 2. Warning + +**Community Impact**: A violation through a single incident or series +of actions. + +**Consequence**: A warning with consequences for continued behavior. No +interaction with the people involved, including unsolicited interaction with +those enforcing the Code of Conduct, for a specified period of time. This +includes avoiding interactions in community spaces as well as external channels +like social media. Violating these terms may lead to a temporary or +permanent ban. + +### 3. Temporary Ban + +**Community Impact**: A serious violation of community standards, including +sustained inappropriate behavior. + +**Consequence**: A temporary ban from any sort of interaction or public +communication with the community for a specified period of time. No public or +private interaction with the people involved, including unsolicited interaction +with those enforcing the Code of Conduct, is allowed during this period. +Violating these terms may lead to a permanent ban. + +### 4. Permanent Ban + +**Community Impact**: Demonstrating a pattern of violation of community +standards, including sustained inappropriate behavior, harassment of an +individual, or aggression toward or disparagement of classes of individuals. + +**Consequence**: A permanent ban from any sort of public interaction within +the community. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], +version 2.0, available at +https://www.contributor-covenant.org/version/2/0/code_of_conduct.html. + +Community Impact Guidelines were inspired by [Mozilla's code of conduct +enforcement ladder](https://github.com/mozilla/diversity). + +[homepage]: https://www.contributor-covenant.org + +For answers to common questions about this code of conduct, see the FAQ at +https://www.contributor-covenant.org/faq. Translations are available at +https://www.contributor-covenant.org/translations. From ff9fc5ccfa49353954c2828716e6c463c96441a0 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Thu, 9 Dec 2021 16:30:43 +0000 Subject: [PATCH 524/584] Add script to generate gource This script tries to isolate our changes to GCC minus the changes to gcc/config so that we can visualize our development history. --- gcc/rust/gource-gccrs.sh | 129 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 129 insertions(+) create mode 100755 gcc/rust/gource-gccrs.sh diff --git a/gcc/rust/gource-gccrs.sh b/gcc/rust/gource-gccrs.sh new file mode 100755 index 000000000000..f14a2e52c6e3 --- /dev/null +++ b/gcc/rust/gource-gccrs.sh @@ -0,0 +1,129 @@ +#!/usr/bin/env bash +set -e + +usage() { echo "Usage: $0 [-o output.mp4] [-r 1600x1080]" 1>&2; } + +RESOLUTION="1600x1080" +output="" +while getopts ho:r: flag; do + case "${flag}" in + o) + output=${OPTARG} + ;; + r) + RESOLUTION=${OPTARG} + ;; + h) + usage + exit 0 + ;; + *) + usage + exit 1 + ;; + esac +done + +# we require gource and ffmpeg to generate this stuff +if ! [ -x "$(command -v git)" ]; then + echo 'Error: git is not installed.' >&2 + exit 1 +fi +if ! [ -x "$(command -v gource)" ]; then + echo 'Error: gource is not installed.' >&2 + exit 1 +fi +if ! [ -x "$(command -v ffmpeg)" ]; then + echo 'Error: ffmpeg is not installed.' >&2 + exit 1 +fi + +# are we in the root of the repo? +if [ ! -d ".git" ]; then + echo ".git directory not found, this script must be run at root repo" + exit 1 +fi + +# if the output already exists then we should stop +if test -f "$output"; then + echo "$output already exists." + exit 1 +fi + +# check if .ppm exists +if test -f "gource.ppm"; then + echo "gource.ppm already exists." + exit 1 +fi + +# is cargo-gccrs here? +if [ ! -d "cargo-gccrs" ]; then + git clone git@github.com:Rust-GCC/cargo-gccrs.git +fi + +# get the log file for cargo gccrs +pushd cargo-gccrs +rm -f cargo.log +gource --output-custom-log cargo.log . +sed -i -E "s#(.+)\|#\1|/cargo#" cargo.log +mv cargo.log ../ +popd + +# generate the log file for gccrs +git log --pretty=format:user:%aN%n%ct \ + --reverse \ + --raw \ + --encoding=UTF-8 \ + --no-renames \ + --no-show-signature \ + -- \ + .github \ + Dockerfile \ + *.md \ + gcc/rust \ + gcc/testsuite/rust \ + gcc/testsuite/rust.test > gccrs-raw.log +gource --log-format git --output-custom-log gccrs.log - < gccrs-raw.log +rm -f gccrs-raw.log + +# combine them +combined_log="$(mktemp /tmp/gource.XXXXXX)" +cat cargo.log gccrs.log | sort -n > "$combined_log" +rm -f gccrs.log +rm -f cargo.log + +echo "Committers:" +awk -F\| {'print $2'} < "$combined_log"| sort | uniq +echo "======================" + +GOURCE_RESOLUTION_ARG="-$RESOLUTION" +GOURCE_OUTPUT_ARGS="" +if [ -n "$output" ]; then + GOURCE_OUTPUT_ARGS="--output-ppm-stream gource.ppm" +fi + +# actually generate the gource +gource "$combined_log" \ + --title "GCC Rust" \ + -s 0.4 \ + -i 0 \ + "$GOURCE_RESOLUTION_ARG" \ + --highlight-users \ + --highlight-dirs \ + --file-extensions \ + --hide mouse \ + --key \ + --stop-at-end \ + "$GOURCE_OUTPUT_ARGS" + +# cleanup the log +rm -f "$combined_log" + +# transcode it +if [ -n "$output" ]; then + # this seems to encode at a high quality but ends up being many gb in size + ffmpeg -y -r 60 -f image2pipe -vcodec ppm -i gource.ppm -vcodec libx264 -preset ultrafast -pix_fmt yuv420p -crf 1 -threads 0 -bf 0 "$output" +fi + +echo "crabby on film: $output" +echo "(\/)(º～º)(\/)" From 4b020faf7739cc1ffc6d73a220325a8db82bd867 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 17 Dec 2021 12:35:03 +0000 Subject: [PATCH 525/584] add script to graph the changes over time --- gcc/rust/monthly-diff.py | 171 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 171 insertions(+) create mode 100644 gcc/rust/monthly-diff.py diff --git a/gcc/rust/monthly-diff.py b/gcc/rust/monthly-diff.py new file mode 100644 index 000000000000..c14cf14fa5e1 --- /dev/null +++ b/gcc/rust/monthly-diff.py @@ -0,0 +1,171 @@ +#!/usr/bin/env python3 + +import matplotlib.pyplot as plt +import numpy as np + +import matplotlib +import subprocess +import sys +import re +import os + + +try: + number_of_weeks = int(sys.argv[1]) +except Exception as e: + print("script requires an integer argument for the number of weeks") + sys.exit(-1) + + +cwd_is_root_repo = os.path.isdir('.git') +if not cwd_is_root_repo: + print("script must be ran from the root of the repo") + sys.exit(-1) + + +change_list = [] +for i in range(number_of_weeks): + since = "%i weeks ago" % (i + 1) + until = "%i weeks ago" % i if i > 0 else None + + command = [ "git", "whatchanged", "--since=%s" % since ] + if until is not None: + command.append("--until=%s" % until) + + specific_paths = [ 'gcc/rust', 'gcc/testsuite/rust', 'gcc/testsuite/rust.test' ] + command += ['--'] + specific_paths + + result = subprocess.run( + command, capture_output=True, text=True + ) + raw_diff = result.stdout + + commit_lines = re.findall('commit [a-z0-9]{40}', raw_diff) + commit_shas = list(map(lambda i: i.split(' ')[1], commit_lines)) + + changes = { + 'files_changed': 0, + 'insertions': 0, + 'deletions': 0, + 'contributors': set(), + 'contributions': list() + } + + short_stat_out = None + if len(commit_shas) > 0: + if len(commit_shas) == 1: + short_stat_command = [ 'git', 'show', '%s' % commit_shas[0], '--shortstat' ] + result = subprocess.run( + short_stat_command, capture_output=True, text=True + ) + raw_short_stat = result.stdout + short_stat_out = raw_short_stat.split('\n')[-2].strip() + + else: + from_sha = commit_shas[-1] + to_sha = commit_shas[0] + short_stat_command = [ 'git', 'diff', '%s..%s' % (from_sha, to_sha), '--shortstat' ] + result = subprocess.run( + short_stat_command, capture_output=True, text=True + ) + raw_short_stat = result.stdout + short_stat_out = raw_short_stat.strip() + + + if short_stat_out is not None: + # pull out the numbers via regex + search = re.findall('[0-9]* file', short_stat_out) + if search is not None: + changes['files_changed'] = int(search[0].split(' ')[0]) + + search = re.findall('[0-9]* insertion', short_stat_out) + if search is not None: + changes['insertions'] = int(search[0].split(' ')[0]) + + search = re.findall('[0-9]* deletion', short_stat_out) + if search is not None: + if len(search) > 0: + changes['deletions'] = int(search[0].split(' ')[0]) + + + # figure out the unique contributors each week + for sha in commit_shas: + show_command = [ "git", "show", "-s", sha ] + result = subprocess.run( + show_command, capture_output=True, text=True + ) + author_str = re.findall('Author: [a-zA-Z0-9-è ]* <[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+>', result.stdout) + author_tokens = author_str[0].split(' ') + author = " ".join(author_tokens[1:]) + changes['contributors'].add(author) + changes['contributions'].append(author) + + + # lets see it then + print(changes) + + # hack to get rid of the gcc-merge + if changes['files_changed'] == 23432: + change_list.append(change_list[-1]) + else: + change_list.append(changes) + + +unique_contributors = set() +for i in change_list: + for y in i['contributors']: + unique_contributors.add(y) + +# calculate average lines added and removed per week +total_ins_lines = sum(map(lambda i: i['insertions'], change_list)) +avg_ins_lines_per_week = total_ins_lines / float(len(change_list)) + +total_del_lines = sum(map(lambda i: i['deletions'], change_list)) +avg_del_lines_per_week = total_del_lines / float(len(change_list)) + +print("average lines added per week:", avg_ins_lines_per_week) +print("average lines deleted per week:", avg_del_lines_per_week) + +# find number of contributions per unique_contributor +num_contribs = {} +for i in unique_contributors: + num_contribs[i] = 0 + for change in change_list: + for y in change['contributions']: + if y == i: + num_contribs[i] = num_contribs[i] + 1 + + +contribs = [] +for i in num_contribs: + contribs.append((i, num_contribs[i])) + +contribs.sort(key=lambda i: i[1], reverse=True) +for i in contribs: + print(i[0], i[1]) + + +# graph the change_list +weeks = list(map(lambda i: i, range(number_of_weeks))) +insertions = list(map(lambda i: i['insertions'], change_list)) +deletions = list(map(lambda i: i['deletions'], change_list)) +files_changed = list(map(lambda i: i['files_changed'], change_list)) +num_contributors = list(map(lambda i: len(i['contributors']), change_list)) + +weeks.reverse() +insertions.reverse() +deletions.reverse() +files_changed.reverse() +num_contributors.reverse() + +fix, axs = plt.subplots(2) + +axs[0].set_title("number of lines added + removed") +axs[0].plot(weeks, insertions) +axs[0].plot(weeks, deletions) +# plt.plot(weeks, files_changed) + +axs[1].set_title("number of contributors") +axs[1].plot(weeks, num_contributors) + +plt.show() From 052fbfe71c43139c0e7ca17a28384c6ed025f705 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Thu, 1 Dec 2022 22:37:47 +0000 Subject: [PATCH 526/584] Join justforfun.dev --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index ac133966980d..b8a619439b39 100644 --- a/README.md +++ b/README.md @@ -4,6 +4,7 @@ ![Docker Pulls](https://img.shields.io/docker/pulls/philberty/gccrs) [![project chat](https://img.shields.io/badge/zulip-join_chat-brightgreen.svg)](https://gcc-rust.zulipchat.com/) [![Bors enabled](https://bors.tech/images/badge_small.svg)](https://app.bors.tech/repositories/32890) +[![justforfunnoreally.dev badge](https://img.shields.io/badge/justforfunnoreally-dev-9ff)](https://justforfunnoreally.dev) # GCC Rust ![GCC Rust](logo.png?raw=true "GCC rust Logo") From 3f07d4c2bb2517730c60586c9ef1234b4109cd76 Mon Sep 17 00:00:00 2001 From: MAHAD Date: Tue, 17 Jan 2023 20:47:26 +0500 Subject: [PATCH 527/584] README.md: squashed many original changes Signed-off-by: MAHAD Signed-off-by: Zhang He Co-authored-by: MAHAD Co-authored-by: Zhang He --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index b8a619439b39..31df8df5138a 100644 --- a/README.md +++ b/README.md @@ -80,7 +80,7 @@ $ make Running the compiler itself without make install we can simply invoke the compiler proper: ```bash -$ ./gcc/crab1 test.rs -frust-debug -frust-dump-parse -Warray-bounds -dumpbase test.rs -mtune=generic -march=x86-64 -O0 -version -fdump-tree-gimple -o test.s -L/lib/x86_64-linux-gnu -L/lib/../lib64 -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib64 -frust-incomplete-and-experimental-compiler-do-not-use +$ ./gcc/crab1 test.rs -frust-debug -frust-dump-ast-pretty -Warray-bounds -dumpbase test.rs -mtune=generic -march=x86-64 -O0 -version -fdump-tree-gimple -o test.s -L/lib/x86_64-linux-gnu -L/lib/../lib64 -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib64 -frust-incomplete-and-experimental-compiler-do-not-use ``` To invoke the compiler driver (gccrs) we need to: @@ -92,8 +92,8 @@ $ make install Then invoke the compiler from the installation directory: ```bash -$ $HOME/gccrs-install/gccrs -g -O2 -c test.rs -o test.o -$ $HOME/gccrs-install/gccrs -o test test.o +$ $HOME/gccrs-install/bin/gccrs -g -O2 -c test.rs -o test.o -frust-incomplete-and-experimental-compiler-do-not-use +$ $HOME/gccrs-install/bin/gccrs -o test test.o ``` You can also setup your shell to automatically find the installed compiler. For example for `bash`, From e807c49d62aa8f16597799259e7d9bf1d40f049b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marc=20Poulhi=C3=A8s?= Date: Sat, 23 Nov 2024 11:59:46 +0100 Subject: [PATCH 528/584] ci: remove bors mention MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit We are using github merge queues for some time now, instead of bors. Remove unmaintained files, and remove bors mentions. ChangeLog: * .github/bors_log_expected_warnings: Move to... * .github/log_expected_warnings: ...here. * .github/workflows/ccpp.yml: * .github/workflows/ccpp32alpine.yml: * CONTRIBUTING.md: * README.md: * .github/bors.toml: Removed. Signed-off-by: Marc Poulhiès --- .github/bors.toml | 8 -------- ...log_expected_warnings => log_expected_warnings} | 0 .github/workflows/ccpp.yml | 14 +++++++------- .github/workflows/ccpp32alpine.yml | 2 +- CONTRIBUTING.md | 2 +- README.md | 3 +-- 6 files changed, 10 insertions(+), 19 deletions(-) delete mode 100644 .github/bors.toml rename .github/{bors_log_expected_warnings => log_expected_warnings} (100%) diff --git a/.github/bors.toml b/.github/bors.toml deleted file mode 100644 index 732ef5c8dcc2..000000000000 --- a/.github/bors.toml +++ /dev/null @@ -1,8 +0,0 @@ -status = [ - "build-and-check-ubuntu-64bit", - "build-and-check-ubuntu-32bit", - "build-and-check-gcc-48", -] -# Uncomment this to use a two hour timeout. -# The default is one hour. -#timeout_sec = 7200 diff --git a/.github/bors_log_expected_warnings b/.github/log_expected_warnings similarity index 100% rename from .github/bors_log_expected_warnings rename to .github/log_expected_warnings diff --git a/.github/workflows/ccpp.yml b/.github/workflows/ccpp.yml index 1ca40ee91780..dfb090617f5e 100644 --- a/.github/workflows/ccpp.yml +++ b/.github/workflows/ccpp.yml @@ -16,7 +16,7 @@ jobs: build-and-check-ubuntu-64bit: env: - # Force locale, in particular for reproducible results re '.github/bors_log_expected_warnings' (see below). + # Force locale, in particular for reproducible results re '.github/log_expected_warnings' (see below). LC_ALL: C.UTF-8 runs-on: ubuntu-22.04 @@ -68,7 +68,7 @@ jobs: run: | cd gccrs-build < log grep 'warning: ' | sort > log_warnings - if diff -U0 ../.github/bors_log_expected_warnings log_warnings; then + if diff -U0 ../.github/log_expected_warnings log_warnings; then : else echo 'See .' @@ -100,7 +100,7 @@ jobs: build-and-check-ubuntu-64bit-glibcxx: env: - # Force locale, in particular for reproducible results re '.github/bors_log_expected_warnings' (see below). + # Force locale, in particular for reproducible results re '.github/log_expected_warnings' (see below). LC_ALL: C.UTF-8 runs-on: ubuntu-22.04 @@ -185,7 +185,7 @@ jobs: build-and-check-ubuntu-32bit: env: - # Force locale, in particular for reproducible results re '.github/bors_log_expected_warnings' (see below). + # Force locale, in particular for reproducible results re '.github/log_expected_warnings' (see below). LC_ALL: C.UTF-8 runs-on: ubuntu-22.04 @@ -237,7 +237,7 @@ jobs: run: | cd gccrs-build < log grep 'warning: ' | sort > log_warnings - if diff -U0 ../.github/bors_log_expected_warnings log_warnings; then + if diff -U0 ../.github/log_expected_warnings log_warnings; then : else echo 'See .' @@ -429,7 +429,7 @@ jobs: build-and-check-asan: env: - # Force locale, in particular for reproducible results re '.github/bors_log_expected_warnings' (see below). + # Force locale, in particular for reproducible results re '.github/log_expected_warnings' (see below). LC_ALL: C.UTF-8 runs-on: ubuntu-22.04 @@ -483,7 +483,7 @@ jobs: # run: | # cd gccrs-build # < log grep 'warning: ' | sort > log_warnings -# if diff -U0 ../.github/bors_log_expected_warnings log_warnings; then +# if diff -U0 ../.github/log_expected_warnings log_warnings; then # : # else # echo 'See .' diff --git a/.github/workflows/ccpp32alpine.yml b/.github/workflows/ccpp32alpine.yml index 341fc9514be5..d4f6e04faac0 100644 --- a/.github/workflows/ccpp32alpine.yml +++ b/.github/workflows/ccpp32alpine.yml @@ -16,7 +16,7 @@ jobs: build-alpine-32bit-and-check-alpine-32bit: env: - # Force locale, in particular for reproducible results re '.github/bors_log_expected_warnings' (see below). + # Force locale, in particular for reproducible results re '.github/log_expected_warnings' (see below). LC_ALL: C.UTF-8 runs-on: ubuntu-22.04 diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 75812a657a30..c5f7e3cb42ca 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -37,7 +37,7 @@ and the link to the GitHub PR sent to the submitter. * The PR policy: Everything has to go through a PR - An exception to this rule will be the merge commits of updating the repo against upstream GCC -* Reviewers/Maintainers of the project (aka people who have bors rights) should be pinged for reviews/questions. +* Reviewers/Maintainers of the project should be pinged for reviews/questions. * A PR can have one or several commits (split should have a technical/logical reason, ie. no fixup-ish commit) diff --git a/README.md b/README.md index 31df8df5138a..12e90613fe5f 100644 --- a/README.md +++ b/README.md @@ -3,7 +3,6 @@ [![Build Docker image](https://github.com/Rust-GCC/gccrs/actions/workflows/docker.yml/badge.svg)](https://github.com/Rust-GCC/gccrs/actions/workflows/docker.yml) ![Docker Pulls](https://img.shields.io/docker/pulls/philberty/gccrs) [![project chat](https://img.shields.io/badge/zulip-join_chat-brightgreen.svg)](https://gcc-rust.zulipchat.com/) -[![Bors enabled](https://bors.tech/images/badge_small.svg)](https://app.bors.tech/repositories/32890) [![justforfunnoreally.dev badge](https://img.shields.io/badge/justforfunnoreally-dev-9ff)](https://justforfunnoreally.dev) # GCC Rust ![GCC Rust](logo.png?raw=true "GCC rust Logo") @@ -248,7 +247,7 @@ With that, we're missing out on the aspect that _enforces that GCC compiles with To encounter that, the default CI has a [_check for new warnings_ step](https://github.com/Rust-GCC/gccrs/pull/1026) that verifies in the CI `--disable-bootstrap` build configuration that no new warnings are introduced. If that step fails, it usually points out a new _warning_ you've introduced erroneously, and should address. -Occasionally it means that simply the `.github/bors_log_expected_warnings` file needs to be updated, +Occasionally it means that simply the `.github/log_expected_warnings` file needs to be updated, for example if due to any kind of "environmental changes" (for example, CI "initial" compiler changes). Unless diligently reproducing the CI configuration (in particular "initial" compiler, GCC version), it's not really feasible to reproduce this check locally. From f66128973952574e917879b1695420d905738453 Mon Sep 17 00:00:00 2001 From: Jasmine Tang Date: Thu, 4 Apr 2024 20:02:26 -0700 Subject: [PATCH 529/584] Add an alternative solution on MacOS For #2937. ChangeLog: * README.md (gccrs-workspace]): like-wise. --- README.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/README.md b/README.md index 12e90613fe5f..dd79d647823b 100644 --- a/README.md +++ b/README.md @@ -74,6 +74,12 @@ $ make ``` +Alternatively, a docker environment is available for ARM-based Mac contributors. + +Please visit [gccrs-workspace](https://github.com/badumbatish/gccrs-workspace). + +The image is based on Ubuntu ARM and comes with dependencies all fetched. + #### Running GCC Rust Running the compiler itself without make install we can simply invoke the compiler proper: From 8511ea4205885398b62221a691a751d2053643b9 Mon Sep 17 00:00:00 2001 From: Arthur Cohen Date: Fri, 12 Apr 2024 17:10:40 +0200 Subject: [PATCH 530/584] chore: Fix Remark CI ChangeLog: * CONTRIBUTING.md: Fix invalid line length. * README.md: Likewise. --- CONTRIBUTING.md | 6 ++++-- README.md | 3 ++- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index c5f7e3cb42ca..26f5618d779e 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -4,7 +4,8 @@ * **Ensure the bug was not already reported** by searching on GitHub under [Issues](https://github.com/Rust-GCC/gccrs/issues). -* If you're unable to find an open issue addressing the problem, [open a new one](https://github.com/Rust-GCC/gccrs/issues/new). +* If you're unable to find an open issue addressing the problem, + [open a new one](https://github.com/Rust-GCC/gccrs/issues/new). Be sure to include a **title and clear description**, as much relevant information as possible, and a **code sample** or an **executable test case** demonstrating the expected behavior that is not occurring. @@ -15,7 +16,8 @@ * Ensure the PR description clearly describes the problem and solution. Include the relevant issue number if applicable. * Before submitting, GCC development requires copyright assignment or the Developer's Certificate of Origin sign-off. - Please see the [Contributing to GCC](https://gcc.gnu.org/contribute.html) guide or [Developer's Certificate of Origin (DCO) Sign-off](https://gcc.gnu.org/dco.html) guide. + Please see the [Contributing to GCC](https://gcc.gnu.org/contribute.html) guide or + [Developer's Certificate of Origin (DCO) Sign-off](https://gcc.gnu.org/dco.html) guide. * Patches sent to the [`gcc-rust` mailing list](https://gcc.gnu.org/mailman/listinfo/gcc-rust) are likewise welcome. These will be imported into a GitHub PR to follow the normal review process, diff --git a/README.md b/README.md index dd79d647823b..afe2a9e6464e 100644 --- a/README.md +++ b/README.md @@ -216,7 +216,8 @@ If you want to contribute to GCC Rust, you can find more information in [CONTRIB Please be aware this project is designed to be pushed upstream to GCC when we reach some milestones, and this means we require copyright assignment or the Developer's Certificate of Origin sign-off. -Please see the [Contributing to GCC](https://gcc.gnu.org/contribute.html) guide or [Developer's Certificate of Origin (DCO) Sign-off](https://gcc.gnu.org/dco.html) guide. +Please see the [Contributing to GCC](https://gcc.gnu.org/contribute.html) guide or +[Developer's Certificate of Origin (DCO) Sign-off](https://gcc.gnu.org/dco.html) guide. Not all contributions must be code; we would love to see new test cases or bugs and issues to be reported. Feel free to add any comments on open PRs From 381ba5907dc8fe286598467e46bd71acbe4b068a Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Mon, 22 Jul 2024 15:00:55 +0200 Subject: [PATCH 531/584] Change bug report issue template ChangeLog: * .github/ISSUE_TEMPLATE/bug_report.yml: New file. * .github/ISSUE_TEMPLATE/bug_report.md: Deleted old template. Signed-off-by: Pierre-Emmanuel Patry --- .github/ISSUE_TEMPLATE/bug_report.md | 25 ----------- .github/ISSUE_TEMPLATE/bug_report.yml | 64 +++++++++++++++++++++++++++ 2 files changed, 64 insertions(+), 25 deletions(-) delete mode 100644 .github/ISSUE_TEMPLATE/bug_report.md create mode 100644 .github/ISSUE_TEMPLATE/bug_report.yml diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md deleted file mode 100644 index cee42dd33141..000000000000 --- a/.github/ISSUE_TEMPLATE/bug_report.md +++ /dev/null @@ -1,25 +0,0 @@ ---- -name: Bug Report -about: Create a bug report for Rust GCC -labels: bug ---- - - -I tried this code: - -```rust - -``` - -I expected to see this happen: *explanation* - -Instead, this happened: *explanation* - -### Meta - -- What version of Rust GCC were you using, git sha if possible. - - diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml new file mode 100644 index 000000000000..1ca211355f40 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.yml @@ -0,0 +1,64 @@ +name: Bug Report +description: Create a bug report +body: + - type: markdown + attributes: + value: Thank you for filing a bug report! 🐛 + - type: textarea + id: problem + attributes: + label: Summary + description: > + Please provide a short summary of the bug, along with any information + you feel relevant to replicate the bug. + validations: + required: true + - type: textarea + id: reproducer + attributes: + label: Reproducer + description: Please provide the code and steps to reproduce the bug + value: | + I tried this code: + + ```rust + + ``` + - type: checkboxes + id: nightly-features + attributes: + label: Does the code make use of any (1.49) nightly feature ? + options: + - label: Nightly + - type: input + id: godbolt + attributes: + label: Godbolt link + description: Optional link to godbolt snippet + placeholder: | + https://godbolt.org/z/vnK433Wox + - type: textarea + id: obtained + attributes: + label: Actual behavior + description: Please describe the actual behavior + value: | + The current behavior is... + validations: + required: true + - type: textarea + id: expected + attributes: + label: Expected behavior + description: Please describe the expected behavior + value: | + I expected to see... + - type: input + id: version + attributes: + label: GCC Version + description: "GCC version (`gcc --version`) or commit SHA" + placeholder: | + commit-hash: c4fecaf3c4fec4f3caf3c4fec4f3cafec4fecaf3 + validations: + required: true From bd260af5a40ab20bc35a6c3a68e7a16de2e06828 Mon Sep 17 00:00:00 2001 From: Jarkko Sakkinen Date: Thu, 5 Sep 2024 18:05:33 +0300 Subject: [PATCH 532/584] Add build dependencies for Fedora ChangeLog: * README.md: Add fedora deps. Signed-off-by: Jarkko Sakkinen --- README.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/README.md b/README.md index afe2a9e6464e..c71bb0868875 100644 --- a/README.md +++ b/README.md @@ -45,6 +45,12 @@ Fetch dependencies for Ubuntu: $ apt install build-essential libgmp3-dev libmpfr-dev libmpc-dev flex bison autogen gcc-multilib dejagnu ``` +Fetch dependencies for Fedora: + +```bash +$ dnf install autoconf automake dejagnu flex bison glibc-devel.{x86_64,i686} gmp-devel libmpc-devel mpfr-devel +``` + Clone the repository ```bash From 3874bf5537dd8d9ecfefc5179cd2e0d172b9335e Mon Sep 17 00:00:00 2001 From: Arthur Cohen Date: Mon, 9 Dec 2024 13:35:49 +0100 Subject: [PATCH 533/584] ci: squashed many changes MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Arthur Cohen Co-authored-by: Sam James Co-authored-by: Owen Avery Co-authored-by: Philip Herron Co-authored-by: Marc Poulhiès Signed-off-by: Philip Herron Signed-off-by: Owen Avery Signed-off-by: Marc Poulhiès --- .github/alpine_32bit_log_warnings | 97 ----------- .../glibcxx_ubuntu64b_log_expected_warnings | 132 --------------- .github/log_expected_warnings | 154 ------------------ .github/safe-grep | 11 ++ .github/workflows/bootstrap.yml | 3 +- .github/workflows/ccpp.yml | 49 ++++-- .github/workflows/ccpp32alpine.yml | 8 +- .github/workflows/clang-format.yml | 2 +- .github/workflows/docker.yml | 34 ---- 9 files changed, 51 insertions(+), 439 deletions(-) create mode 100755 .github/safe-grep delete mode 100644 .github/workflows/docker.yml diff --git a/.github/alpine_32bit_log_warnings b/.github/alpine_32bit_log_warnings index 32a83ef1078c..e69de29bb2d1 100644 --- a/.github/alpine_32bit_log_warnings +++ b/.github/alpine_32bit_log_warnings @@ -1,97 +0,0 @@ -../../../libgcc/soft-fp/fixdfbitint.c:51:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixdfbitint.c:51:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixdfbitint.c:57:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixdfbitint.c:57:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixdfbitint.c:61:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixdfbitint.c:61:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixsfbitint.c:51:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixsfbitint.c:51:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixsfbitint.c:57:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixsfbitint.c:57:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixsfbitint.c:61:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixsfbitint.c:61:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixtfbitint.c:61:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixtfbitint.c:61:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixtfbitint.c:67:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixtfbitint.c:67:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixtfbitint.c:71:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixtfbitint.c:71:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixxfbitint.c:62:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixxfbitint.c:62:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixxfbitint.c:68:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixxfbitint.c:68:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixxfbitint.c:72:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/fixxfbitint.c:72:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../gcc/analyzer/store.h:310:5: warning: 'size_in_bytes.generic_wide_int >::.fixed_wide_int_storage<128>::val[1]' may be used uninitialized [-Wmaybe-uninitialized] -../../gcc/expmed.cc:1845:45: warning: '*(unsigned int*)((char*)&imode + offsetof(scalar_int_mode, scalar_int_mode::m_mode))' may be used uninitialized [-Wmaybe-uninitialized] -../../gcc/gcc.cc:2412:30: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2413:32: warning: unknown conversion type character 't' in format [-Wformat=] -../../gcc/gcc.cc:2432:30: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2433:32: warning: unknown conversion type character 't' in format [-Wformat=] -../../gcc/gcc.cc:2458:30: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2459:32: warning: unknown conversion type character 't' in format [-Wformat=] -../../gcc/gcc.cc:2467:30: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2468:32: warning: unknown conversion type character 't' in format [-Wformat=] -../../gcc/gcc.cc:2477:30: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2478:32: warning: unknown conversion type character 't' in format [-Wformat=] -../../gcc/gcc.cc:2487:30: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2488:32: warning: unknown conversion type character 't' in format [-Wformat=] -../../gcc/gcc.cc:2527:26: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2527:59: warning: unknown conversion type character 't' in format [-Wformat=] -../../gcc/gcc.cc:2539:22: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2539:51: warning: unknown conversion type character 't' in format [-Wformat=] -../../gcc/gcc.cc:2553:22: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2553:51: warning: unknown conversion type character 't' in format [-Wformat=] -../../gcc/text-art/style.cc:150:25: warning: spurious leading punctuation sequence ';' in format [-Wformat-diag] -../../gcc/text-art/style.cc:160:25: warning: spurious leading punctuation sequence ';' in format [-Wformat-diag] -../../gcc/text-art/table.cc:981:62: warning: unquoted keyword 'char' in format [-Wformat-diag] -../../gcc/text-art/table.cc:981:69: warning: spurious trailing punctuation sequence '])' in format [-Wformat-diag] -/usr/include/c++/13.2.1/bits/new_allocator.h:172:33: warning: '*(std::_Vector_base >*)((char*)&saved + offsetof(Rust::BIR::PatternBindingBuilder::SavedState, Rust::BIR::PatternBindingBuilder::SavedState::regions.tl::optional::.tl::detail::optional_move_assign_base::.tl::detail::optional_copy_assign_base::.tl::detail::optional_move_base::.tl::detail::optional_copy_base::.tl::detail::optional_operations_base::.tl::detail::optional_storage_base::)).std::_Vector_base >::_M_impl.std::_Vector_base >::_Vector_impl::.std::_Vector_base >::_Vector_impl_data::_M_start' may be used uninitialized [-Wmaybe-uninitialized] -/usr/include/c++/13.2.1/bits/stl_vector.h:367:49: warning: '*(std::_Vector_base >*)((char*)&saved + offsetof(Rust::BIR::PatternBindingBuilder::SavedState, Rust::BIR::PatternBindingBuilder::SavedState::regions.tl::optional::.tl::detail::optional_move_assign_base::.tl::detail::optional_copy_assign_base::.tl::detail::optional_move_base::.tl::detail::optional_copy_base::.tl::detail::optional_operations_base::.tl::detail::optional_storage_base::)).std::_Vector_base >::_M_impl.std::_Vector_base >::_Vector_impl::.std::_Vector_base >::_Vector_impl_data::_M_end_of_storage' may be used uninitialized [-Wmaybe-uninitialized] -/usr/include/c++/13.2.1/bits/stl_vector.h:367:49: warning: '*(std::_Vector_base >*)((char*)&saved + offsetof(Rust::BIR::PatternBindingBuilder::SavedState, Rust::BIR::PatternBindingBuilder::SavedState::regions.tl::optional::.tl::detail::optional_move_assign_base::.tl::detail::optional_copy_assign_base::.tl::detail::optional_move_base::.tl::detail::optional_copy_base::.tl::detail::optional_operations_base::.tl::detail::optional_storage_base::)).std::_Vector_base >::_M_impl.std::_Vector_base >::_Vector_impl::.std::_Vector_base >::_Vector_impl_data::_M_end_of_storage' may be used uninitialized [-Wmaybe-uninitialized] -/usr/include/c++/13.2.1/bits/stl_vector.h:367:49: warning: '*(std::_Vector_base >*)((char*)&saved + offsetof(Rust::BIR::PatternBindingBuilder::SavedState, Rust::BIR::PatternBindingBuilder::SavedState::regions.tl::optional::.tl::detail::optional_move_assign_base::.tl::detail::optional_copy_assign_base::.tl::detail::optional_move_base::.tl::detail::optional_copy_base::.tl::detail::optional_operations_base::.tl::detail::optional_storage_base::)).std::_Vector_base >::_M_impl.std::_Vector_base >::_Vector_impl::.std::_Vector_base >::_Vector_impl_data::_M_start' may be used uninitialized [-Wmaybe-uninitialized] -gengtype-lex.cc:356:15: warning: this statement may fall through [-Wimplicit-fallthrough=] -gengtype-lex.cc:356:15: warning: this statement may fall through [-Wimplicit-fallthrough=] -gengtype-lex.cc:356:15: warning: this statement may fall through [-Wimplicit-fallthrough=] -gengtype-lex.cc:356:15: warning: this statement may fall through [-Wimplicit-fallthrough=] -libtool: install: warning: remember to run `libtool --finish /usr/local/libexec/gcc/i586-alpine-linux-musl/14.0.1' diff --git a/.github/glibcxx_ubuntu64b_log_expected_warnings b/.github/glibcxx_ubuntu64b_log_expected_warnings index b1f400a065dc..e69de29bb2d1 100644 --- a/.github/glibcxx_ubuntu64b_log_expected_warnings +++ b/.github/glibcxx_ubuntu64b_log_expected_warnings @@ -1,132 +0,0 @@ -../../../../libgcc/generic-morestack.c:397:16: warning: comparison of integer expressions of different signedness: ‘unsigned int’ and ‘long int’ [-Wsign-compare] -../../../../libgcc/soft-fp/fixdfbitint.c:51:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixdfbitint.c:51:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixdfbitint.c:57:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixdfbitint.c:57:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixdfbitint.c:61:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixdfbitint.c:61:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixsfbitint.c:51:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixsfbitint.c:51:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixsfbitint.c:57:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixsfbitint.c:57:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixsfbitint.c:61:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixsfbitint.c:61:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixtfbitint.c:61:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixtfbitint.c:61:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixtfbitint.c:67:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixtfbitint.c:67:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixtfbitint.c:71:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixtfbitint.c:71:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixxfbitint.c:62:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixxfbitint.c:62:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixxfbitint.c:68:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixxfbitint.c:68:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixxfbitint.c:72:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixxfbitint.c:72:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libcpp/expr.cc:842:35: warning: format not a string literal and no format arguments [-Wformat-security] -../../../libcpp/expr.cc:845:38: warning: format not a string literal and no format arguments [-Wformat-security] -../../../libcpp/expr.cc:855:33: warning: format not a string literal and no format arguments [-Wformat-security] -../../../libcpp/expr.cc:867:42: warning: format not a string literal and no format arguments [-Wformat-security] -../../../libcpp/expr.cc:870:39: warning: format not a string literal and no format arguments [-Wformat-security] -../../../libcpp/expr.cc:877:35: warning: format not a string literal and no format arguments [-Wformat-security] -../../../libcpp/macro.cc:185:26: warning: format not a string literal and no format arguments [-Wformat-security] -../../../libcpp/macro.cc:214:34: warning: format not a string literal and no format arguments [-Wformat-security] -../../../libcpp/macro.cc:3710:25: warning: format not a string literal and no format arguments [-Wformat-security] -../../../libcpp/macro.cc:3725:25: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/analyzer/program-state.cc:1498:15: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/c-family/c-common.cc:6763:14: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/c-family/c-common.cc:6767:16: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/c/c-convert.cc:84:13: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/c/c-typeck.cc:12453:16: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/c/c-typeck.cc:3878:17: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/c/c-typeck.cc:4648:16: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/c/c-typeck.cc:6913:23: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/collect-utils.cc:237:21: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/collect2.cc:2400:21: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/diagnostic.cc:2316:15: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/fold-const.cc:384:13: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/gcc.cc:2412:30: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2413:32: warning: unknown conversion type character ‘t’ in format [-Wformat=] -../../gcc/gcc.cc:2432:30: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2433:32: warning: unknown conversion type character ‘t’ in format [-Wformat=] -../../gcc/gcc.cc:2458:30: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2459:32: warning: unknown conversion type character ‘t’ in format [-Wformat=] -../../gcc/gcc.cc:2467:30: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2468:32: warning: unknown conversion type character ‘t’ in format [-Wformat=] -../../gcc/gcc.cc:2477:30: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2478:32: warning: unknown conversion type character ‘t’ in format [-Wformat=] -../../gcc/gcc.cc:2487:30: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2488:32: warning: unknown conversion type character ‘t’ in format [-Wformat=] -../../gcc/gcc.cc:2527:26: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2527:59: warning: unknown conversion type character ‘t’ in format [-Wformat=] -../../gcc/gcc.cc:2539:22: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2539:51: warning: unknown conversion type character ‘t’ in format [-Wformat=] -../../gcc/gcc.cc:2553:22: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2553:51: warning: unknown conversion type character ‘t’ in format [-Wformat=] -../../gcc/gimple-range-gori.cc:318:19: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/ipa-devirt.cc:967:10: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/lto-wrapper.cc:1369:10: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/lto-wrapper.cc:1971:23: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/text-art/style.cc:150:25: warning: spurious leading punctuation sequence ‘;’ in format [-Wformat-diag] -../../gcc/text-art/style.cc:160:25: warning: spurious leading punctuation sequence ‘;’ in format [-Wformat-diag] -../../gcc/text-art/table.cc:981:62: warning: unquoted keyword ‘char’ in format [-Wformat-diag] -../../gcc/text-art/table.cc:981:69: warning: spurious trailing punctuation sequence ‘])’ in format [-Wformat-diag] -../../gcc/tree-ssa-sccvn.cc:286:21: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/expr.cc:842:35: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/expr.cc:845:38: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/expr.cc:855:33: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/expr.cc:867:42: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/expr.cc:870:39: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/expr.cc:877:35: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/macro.cc:185:26: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/macro.cc:214:34: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/macro.cc:3710:25: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/macro.cc:3725:25: warning: format not a string literal and no format arguments [-Wformat-security] -/home/runner/work/gccrs/gccrs/gccrs-build/x86_64-pc-linux-gnu/32/libssp/../../../../libssp/gets-chk.c:73: warning: the `gets' function is dangerous and should not be used. -/home/runner/work/gccrs/gccrs/gccrs-build/x86_64-pc-linux-gnu/libssp/../../../libssp/gets-chk.c:73: warning: the `gets' function is dangerous and should not be used. -gengtype-lex.cc:357:15: warning: this statement may fall through [-Wimplicit-fallthrough=] -gengtype-lex.cc:357:15: warning: this statement may fall through [-Wimplicit-fallthrough=] -gengtype-lex.cc:357:15: warning: this statement may fall through [-Wimplicit-fallthrough=] -gengtype-lex.cc:357:15: warning: this statement may fall through [-Wimplicit-fallthrough=] -install.texi:2231: warning: `.' or `,' must follow @xref, not f -libtool: install: warning: remember to run `libtool --finish /usr/local/libexec/gcc/x86_64-pc-linux-gnu/14.0.1' diff --git a/.github/log_expected_warnings b/.github/log_expected_warnings index 989829d685f4..e69de29bb2d1 100644 --- a/.github/log_expected_warnings +++ b/.github/log_expected_warnings @@ -1,154 +0,0 @@ -../../../../libgcc/generic-morestack.c:397:16: warning: comparison of integer expressions of different signedness: ‘unsigned int’ and ‘long int’ [-Wsign-compare] -../../../../libgcc/soft-fp/fixdfbitint.c:51:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixdfbitint.c:51:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixdfbitint.c:57:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixdfbitint.c:57:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixdfbitint.c:61:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixdfbitint.c:61:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixsfbitint.c:51:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixsfbitint.c:51:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixsfbitint.c:57:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixsfbitint.c:57:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixsfbitint.c:61:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixsfbitint.c:61:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixtfbitint.c:61:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixtfbitint.c:61:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixtfbitint.c:67:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixtfbitint.c:67:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixtfbitint.c:71:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixtfbitint.c:71:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixxfbitint.c:62:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixxfbitint.c:62:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixxfbitint.c:68:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixxfbitint.c:68:22: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixxfbitint.c:72:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/fixxfbitint.c:72:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1477:20: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1492:26: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1515:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1560:39: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../../libgcc/soft-fp/op-common.h:1563:25: warning: comparison of integer expressions of different signedness: ‘int’ and ‘USItype’ {aka ‘unsigned int’} [-Wsign-compare] -../../../libcpp/expr.cc:842:35: warning: format not a string literal and no format arguments [-Wformat-security] -../../../libcpp/expr.cc:845:38: warning: format not a string literal and no format arguments [-Wformat-security] -../../../libcpp/expr.cc:855:33: warning: format not a string literal and no format arguments [-Wformat-security] -../../../libcpp/expr.cc:867:42: warning: format not a string literal and no format arguments [-Wformat-security] -../../../libcpp/expr.cc:870:39: warning: format not a string literal and no format arguments [-Wformat-security] -../../../libcpp/expr.cc:877:35: warning: format not a string literal and no format arguments [-Wformat-security] -../../../libcpp/lex.cc:2120:39: warning: ‘loc’ may be used uninitialized [-Wmaybe-uninitialized] -../../../libcpp/macro.cc:185:26: warning: format not a string literal and no format arguments [-Wformat-security] -../../../libcpp/macro.cc:214:34: warning: format not a string literal and no format arguments [-Wformat-security] -../../../libcpp/macro.cc:3710:25: warning: format not a string literal and no format arguments [-Wformat-security] -../../../libcpp/macro.cc:3725:25: warning: format not a string literal and no format arguments [-Wformat-security] -../../c++tools/server.cc:490:11: warning: ignoring return value of ‘ssize_t write(int, const void*, size_t)’ declared with attribute ‘warn_unused_result’ [-Wunused-result] -../../c++tools/server.cc:620:10: warning: ignoring return value of ‘int pipe(int*)’ declared with attribute ‘warn_unused_result’ [-Wunused-result] -../../gcc/../libgcc/libgcov-util.c:455:9: warning: ignoring return value of ‘int chdir(const char*)’ declared with attribute ‘warn_unused_result’ [-Wunused-result] -../../gcc/analyzer/program-state.cc:1498:15: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/analyzer/store.h:310:5: warning: ‘size_in_bytes.generic_wide_int >::.fixed_wide_int_storage<128>::val[1]’ may be used uninitialized [-Wmaybe-uninitialized] -../../gcc/c-family/c-common.cc:6763:14: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/c-family/c-common.cc:6767:16: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/c/c-convert.cc:84:13: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/c/c-typeck.cc:12453:16: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/c/c-typeck.cc:3878:17: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/c/c-typeck.cc:4648:16: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/c/c-typeck.cc:6913:23: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/collect-utils.cc:237:21: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/collect2.cc:2400:21: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/diagnostic.cc:2316:15: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/expmed.cc:1845:45: warning: ‘*(unsigned int*)((char*)&imode + offsetof(scalar_int_mode, scalar_int_mode::m_mode))’ may be used uninitialized in this function [-Wmaybe-uninitialized] -../../gcc/fold-const.cc:384:13: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/gcc.cc:10668:12: warning: ignoring return value of ‘ssize_t read(int, void*, size_t)’ declared with attribute ‘warn_unused_result’ [-Wunused-result] -../../gcc/gcc.cc:2412:30: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2413:32: warning: unknown conversion type character ‘t’ in format [-Wformat=] -../../gcc/gcc.cc:2432:30: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2433:32: warning: unknown conversion type character ‘t’ in format [-Wformat=] -../../gcc/gcc.cc:2458:30: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2459:32: warning: unknown conversion type character ‘t’ in format [-Wformat=] -../../gcc/gcc.cc:2467:30: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2468:32: warning: unknown conversion type character ‘t’ in format [-Wformat=] -../../gcc/gcc.cc:2477:30: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2478:32: warning: unknown conversion type character ‘t’ in format [-Wformat=] -../../gcc/gcc.cc:2487:30: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2488:32: warning: unknown conversion type character ‘t’ in format [-Wformat=] -../../gcc/gcc.cc:2527:26: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2527:59: warning: unknown conversion type character ‘t’ in format [-Wformat=] -../../gcc/gcc.cc:2539:22: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2539:51: warning: unknown conversion type character ‘t’ in format [-Wformat=] -../../gcc/gcc.cc:2553:22: warning: too many arguments for format [-Wformat-extra-args] -../../gcc/gcc.cc:2553:51: warning: unknown conversion type character ‘t’ in format [-Wformat=] -../../gcc/gcc.cc:7897:9: warning: ignoring return value of ‘ssize_t write(int, const void*, size_t)’ declared with attribute ‘warn_unused_result’ [-Wunused-result] -../../gcc/gcc.cc:7900:13: warning: ignoring return value of ‘ssize_t write(int, const void*, size_t)’ declared with attribute ‘warn_unused_result’ [-Wunused-result] -../../gcc/gcc.cc:7901:13: warning: ignoring return value of ‘ssize_t write(int, const void*, size_t)’ declared with attribute ‘warn_unused_result’ [-Wunused-result] -../../gcc/gcc.cc:7903:9: warning: ignoring return value of ‘ssize_t write(int, const void*, size_t)’ declared with attribute ‘warn_unused_result’ [-Wunused-result] -../../gcc/genhooks.cc:112:17: warning: ignoring return value of ‘int fscanf(FILE*, const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result] -../../gcc/genhooks.cc:121:14: warning: ignoring return value of ‘int fscanf(FILE*, const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result] -../../gcc/genhooks.cc:174:14: warning: ignoring return value of ‘int fscanf(FILE*, const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result] -../../gcc/genhooks.cc:180:14: warning: ignoring return value of ‘int fscanf(FILE*, const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result] -../../gcc/gimple-range-gori.cc:318:19: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/ipa-devirt.cc:967:10: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/lto-wrapper.cc:1151:8: warning: ignoring return value of ‘ssize_t read(int, void*, size_t)’ declared with attribute ‘warn_unused_result’ [-Wunused-result] -../../gcc/lto-wrapper.cc:1369:10: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/lto-wrapper.cc:1971:23: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/lto/lto-common.cc:2084:10: warning: ignoring return value of ‘int fscanf(FILE*, const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result] -../../gcc/lto/lto-common.cc:2086:9: warning: ignoring return value of ‘size_t fread(void*, size_t, size_t, FILE*)’ declared with attribute ‘warn_unused_result’ [-Wunused-result] -../../gcc/lto/lto-common.cc:2106:10: warning: ignoring return value of ‘int fscanf(FILE*, const char*, ...)’ declared with attribute ‘warn_unused_result’ [-Wunused-result] -../../gcc/text-art/style.cc:150:25: warning: spurious leading punctuation sequence ‘;’ in format [-Wformat-diag] -../../gcc/text-art/style.cc:160:25: warning: spurious leading punctuation sequence ‘;’ in format [-Wformat-diag] -../../gcc/text-art/table.cc:981:62: warning: unquoted keyword ‘char’ in format [-Wformat-diag] -../../gcc/text-art/table.cc:981:69: warning: spurious trailing punctuation sequence ‘])’ in format [-Wformat-diag] -../../gcc/tree-ssa-sccvn.cc:286:21: warning: format not a string literal and no format arguments [-Wformat-security] -../../gcc/tree-vect-stmts.cc:10397:47: warning: ‘stride_step’ may be used uninitialized in this function [-Wmaybe-uninitialized] -../../gcc/vec.h:347:10: warning: ‘void free(void*)’ called on unallocated object ‘dest_bbs’ [-Wfree-nonheap-object] -../../libcpp/expr.cc:842:35: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/expr.cc:845:38: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/expr.cc:855:33: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/expr.cc:867:42: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/expr.cc:870:39: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/expr.cc:877:35: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/lex.cc:2120:39: warning: ‘loc’ may be used uninitialized [-Wmaybe-uninitialized] -../../libcpp/macro.cc:185:26: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/macro.cc:214:34: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/macro.cc:3710:25: warning: format not a string literal and no format arguments [-Wformat-security] -../../libcpp/macro.cc:3725:25: warning: format not a string literal and no format arguments [-Wformat-security] -/home/runner/work/gccrs/gccrs/gccrs-build/x86_64-pc-linux-gnu/32/libssp/../../../../libssp/gets-chk.c:73: warning: the `gets' function is dangerous and should not be used. -/home/runner/work/gccrs/gccrs/gccrs-build/x86_64-pc-linux-gnu/libssp/../../../libssp/gets-chk.c:73: warning: the `gets' function is dangerous and should not be used. -gengtype-lex.cc:357:15: warning: this statement may fall through [-Wimplicit-fallthrough=] -gengtype-lex.cc:357:15: warning: this statement may fall through [-Wimplicit-fallthrough=] -gengtype-lex.cc:357:15: warning: this statement may fall through [-Wimplicit-fallthrough=] -gengtype-lex.cc:357:15: warning: this statement may fall through [-Wimplicit-fallthrough=] -install.texi:2231: warning: `.' or `,' must follow @xref, not f -libtool: install: warning: remember to run `libtool --finish /usr/local/libexec/gcc/x86_64-pc-linux-gnu/14.0.1' diff --git a/.github/safe-grep b/.github/safe-grep new file mode 100755 index 000000000000..571702382f5d --- /dev/null +++ b/.github/safe-grep @@ -0,0 +1,11 @@ +#!/bin/sh +# grep exits with 1 if it doesn't match any lines +# this script wraps grep, mapping exits codes 1->0, x->x + +grep "$@" +EXIT_CODE="$?" +if [ x$EXIT_CODE = x1 ]; then + exit 0 +else + exit $EXIT_CODE +fi diff --git a/.github/workflows/bootstrap.yml b/.github/workflows/bootstrap.yml index f01dc2ad8365..4bf042a0be99 100644 --- a/.github/workflows/bootstrap.yml +++ b/.github/workflows/bootstrap.yml @@ -42,7 +42,8 @@ jobs: - name: Build run: | cd gccrs-build; \ - make -j $(nproc) + # Build without network access + unshare --net --ipc -r /bin/bash -c "make -j $(nproc)" - name: Run Tests run: | diff --git a/.github/workflows/ccpp.yml b/.github/workflows/ccpp.yml index dfb090617f5e..5170e3a4ab56 100644 --- a/.github/workflows/ccpp.yml +++ b/.github/workflows/ccpp.yml @@ -61,13 +61,14 @@ jobs: run: | cd gccrs-build; \ # Add cargo to our path quickly - . "$HOME/.cargo/env"; - make -Otarget -j $(nproc) 2>&1 | tee log + . "$HOME/.cargo/env"; \ + # Build without network access + unshare --net --ipc -r /bin/bash -c "make -Otarget -j $(nproc) 2>&1 | tee log ; exit \${PIPESTATUS[0]}" - name: Check for new warnings run: | cd gccrs-build - < log grep 'warning: ' | sort > log_warnings + < log grep 'warning: ' | grep rust | sort > log_warnings if diff -U0 ../.github/log_expected_warnings log_warnings; then : else @@ -80,9 +81,9 @@ jobs: cd gccrs-build; \ make check-rust RUNTESTFLAGS="--target_board=unix\{-m64}" - name: Archive check-rust results - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: - name: check-rust-logs + name: check-rust-logs-ubuntu-64 path: | gccrs-build/gcc/testsuite/rust/ - name: Check regressions @@ -152,7 +153,7 @@ jobs: - name: Check for new warnings run: | cd gccrs-build - < log grep 'warning: ' | sort > log_warnings + < log grep 'warning: ' | grep rust | sort > log_warnings if diff -U0 ../.github/glibcxx_ubuntu64b_log_expected_warnings log_warnings; then : else @@ -165,9 +166,9 @@ jobs: cd gccrs-build; \ make check-rust RUNTESTFLAGS="--target_board=unix\{-m64}" - name: Archive check-rust results - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: - name: check-rust-logs + name: check-rust-logs-ubuntu-64-glibcxx path: | gccrs-build/gcc/testsuite/rust/ - name: Check regressions @@ -236,7 +237,7 @@ jobs: - name: Check for new warnings run: | cd gccrs-build - < log grep 'warning: ' | sort > log_warnings + < log grep 'warning: ' | grep rust | sort > log_warnings if diff -U0 ../.github/log_expected_warnings log_warnings; then : else @@ -249,9 +250,9 @@ jobs: cd gccrs-build; \ make check-rust RUNTESTFLAGS="--target_board=unix\{-m32}" - name: Archive check-rust results - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: - name: check-rust-logs + name: check-rust-logs-ubuntu-32 path: | gccrs-build/gcc/testsuite/rust/ - name: Check regressions @@ -350,7 +351,7 @@ jobs: make check-rust RUNTESTFLAGS="--target_board=unix\{-m32,-m64}" - name: Archive check-rust results - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: name: check-rust-logs-5 path: | @@ -374,10 +375,21 @@ jobs: CC: clang CXX: clang++ - runs-on: macos-13 + runs-on: macos-15 steps: - uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Handle ARM64 + # TODO: update commit as required + run: | + git remote add arm-ian 'https://github.com/iains/gcc-darwin-arm64.git'; + git fetch arm-ian; + GIT_AUTHOR_NAME=CI \ + GIT_AUTHOR_EMAIL='ci@invalid' \ + git merge --no-edit a81533316b9b64245d85b352a93e17f302482acd; - name: Install Deps run: | @@ -396,6 +408,9 @@ jobs: --enable-languages=rust \ --disable-bootstrap \ --enable-multilib \ + --with-gmp="$(brew --prefix gmp)" \ + --with-mpfr="$(brew --prefix mpfr)" \ + --with-mpc="$(brew --prefix libmpc)" \ --with-native-system-header-dir=/usr/include \ --with-sysroot=$(xcrun --show-sdk-path) @@ -409,12 +424,14 @@ jobs: run: | cd gccrs-build; \ make check-rust + - name: Archive check-rust results - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: name: check-rust-logs-macos path: | gccrs-build/gcc/testsuite/rust/ + - name: Check regressions run: | cd gccrs-build; \ @@ -496,9 +513,9 @@ jobs: ASAN_OPTIONS=detect_leaks=0:use_odr_indicator=1 \ make check-rust RUNTESTFLAGS="--target_board=unix\{-m64}" - name: Archive check-rust results - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: - name: check-rust-logs + name: check-rust-logs-asan path: | gccrs-build/gcc/testsuite/rust/ - name: Check regressions diff --git a/.github/workflows/ccpp32alpine.yml b/.github/workflows/ccpp32alpine.yml index d4f6e04faac0..5eb0c230df23 100644 --- a/.github/workflows/ccpp32alpine.yml +++ b/.github/workflows/ccpp32alpine.yml @@ -80,11 +80,12 @@ jobs: - name: Produce warning logs run: | cd gccrs-build - < log grep 'warning: ' | sort > log_warnings + # grep exits with 1 if it doesn't find at least one match + < log grep 'warning: ' | ../.github/safe-grep rust | sort > log_warnings cat log_warnings shell: alpine.sh {0} - name: Archive warnings logs - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: name: warnings path: | @@ -92,7 +93,6 @@ jobs: - name: Check for new warnings run: | cd gccrs-build - < log grep 'warning: ' | sort > log_warnings if diff -U0 ../.github/alpine_32bit_log_warnings log_warnings; then : else @@ -108,7 +108,7 @@ jobs: shell: alpine.sh {0} - name: Archive check-rust results - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: name: check-rust-logs path: | diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml index 7325a5597e63..a5f165d4b52b 100644 --- a/.github/workflows/clang-format.yml +++ b/.github/workflows/clang-format.yml @@ -23,4 +23,4 @@ jobs: with: source: 'gcc/rust/ libgrust/' extensions: 'h,cc' - clangFormatVersion: 10 + clangFormatVersion: 16 diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml deleted file mode 100644 index 306e6a7e7dae..000000000000 --- a/.github/workflows/docker.yml +++ /dev/null @@ -1,34 +0,0 @@ -name: Build Docker image - -on: - push: - branches: - - 'master' - -jobs: - docker: - runs-on: ubuntu-latest - steps: - - - name: Checkout - uses: actions/checkout@v4 - - - name: Set up QEMU - uses: docker/setup-qemu-action@v2 - - - name: Set up Docker Buildx - uses: docker/setup-buildx-action@v2 - - - name: Login to DockerHub - uses: docker/login-action@v2 - if: github.repository == 'Rust-GCC/gccrs' - with: - username: ${{ secrets.DOCKERHUB_USERNAME }} - password: ${{ secrets.DOCKERHUB_TOKEN }} - - - name: Build and push - uses: docker/build-push-action@v4 - with: - context: . - push: ${{ github.repository == 'Rust-GCC/gccrs' }} - tags: philberty/gccrs:latest From 0cdd12b1b997911682e944ec4313a0a617db7df2 Mon Sep 17 00:00:00 2001 From: Owen Avery Date: Mon, 1 Sep 2025 16:42:13 -0400 Subject: [PATCH 534/584] ci: drop macos build MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Owen Avery Signed-off-by: Marc Poulhiès Co-authored-by: Owen Avery Co-authored-by: Marc Poulhiès --- .github/workflows/ccpp.yml | 75 -------------------------------------- 1 file changed, 75 deletions(-) diff --git a/.github/workflows/ccpp.yml b/.github/workflows/ccpp.yml index 5170e3a4ab56..b84be9bbbdf8 100644 --- a/.github/workflows/ccpp.yml +++ b/.github/workflows/ccpp.yml @@ -368,81 +368,6 @@ jobs: exit 0; \ fi - build-and-check-clang-macos: - - env: - # Force CC/CXX to be explicitly clang to make it clear which compiler is used - CC: clang - CXX: clang++ - - runs-on: macos-15 - - steps: - - uses: actions/checkout@v4 - with: - fetch-depth: 0 - - - name: Handle ARM64 - # TODO: update commit as required - run: | - git remote add arm-ian 'https://github.com/iains/gcc-darwin-arm64.git'; - git fetch arm-ian; - GIT_AUTHOR_NAME=CI \ - GIT_AUTHOR_EMAIL='ci@invalid' \ - git merge --no-edit a81533316b9b64245d85b352a93e17f302482acd; - - - name: Install Deps - run: | - brew install dejagnu mpfr libmpc gmp; - # install Rust directly using rustup - curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain=1.72.0; - - - name: Make Source Read-Only - run: chmod -R a-w ./* - - - name: Configure - run: | - mkdir -p gccrs-build; - cd gccrs-build; - ../configure \ - --enable-languages=rust \ - --disable-bootstrap \ - --enable-multilib \ - --with-gmp="$(brew --prefix gmp)" \ - --with-mpfr="$(brew --prefix mpfr)" \ - --with-mpc="$(brew --prefix libmpc)" \ - --with-native-system-header-dir=/usr/include \ - --with-sysroot=$(xcrun --show-sdk-path) - - - name: Build - shell: bash - run: | - cd gccrs-build; \ - make -j $(sysctl -n hw.ncpu) 2>&1 | tee log - - - name: Run Tests - run: | - cd gccrs-build; \ - make check-rust - - - name: Archive check-rust results - uses: actions/upload-artifact@v4 - with: - name: check-rust-logs-macos - path: | - gccrs-build/gcc/testsuite/rust/ - - - name: Check regressions - run: | - cd gccrs-build; \ - if grep -e "unexpected" -e "unresolved" -e "ERROR:" gcc/testsuite/rust/rust.sum;\ - then \ - echo "::error title=Regression test failed::some tests are not correct"; \ - exit 1; \ - else \ - exit 0; \ - fi - build-and-check-asan: env: From f54fb537081c25281fd8b174586b6117dd9d0924 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marc=20Poulhi=C3=A8s?= Date: Wed, 17 Sep 2025 18:49:42 +0200 Subject: [PATCH 535/584] ci: new workflow for sending emails after merging a PR MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This new workflow is used to send emails to the gcc-patches@ mailing list after every merged PR. For each merged PR: - remove commits touching files not to-be-upstreamed (e.g. github workflow, README.md, ...) - send a mail series Each mail contains explanation + links to commits/PR on the github project. Authors of commits will be put in Cc: of emails. Configure it by setting the following secrets in github: - SMTP_PASSWORD And the following variables: - PATCH_TO: the "To:" field for the emails - PATCH_CC: optional "Cc:" - SMTP_FROM, SMTP_PASSWORD, SMTP_PORT, SMTP_SERVER, STMP_USERNAME: self explanatory ChangeLog: * .github/workflows/send-emails.yml: New file. Co-authored-by: Andrew V. Teylu Signed-off-by: Andrew V. Teylu Signed-off-by: Marc Poulhiès --- .github/workflows/send-emails.yml | 276 ++++++++++++++++++++++++++++++ 1 file changed, 276 insertions(+) create mode 100644 .github/workflows/send-emails.yml diff --git a/.github/workflows/send-emails.yml b/.github/workflows/send-emails.yml new file mode 100644 index 000000000000..d50d9321cf63 --- /dev/null +++ b/.github/workflows/send-emails.yml @@ -0,0 +1,276 @@ +name: Send emails for merged PR + +on: + push: + branches: + - "master" + +jobs: + send_patches: + runs-on: ubuntu-latest + + steps: + - name: Checkout repo with full history + uses: actions/checkout@v5 + with: + fetch-depth: 100 + + - name: Install deps (git send-email and jq) + run: | + sudo apt-get update + sudo apt-get install -y jq + + ## GHA images have a special git package that conflicts with + ## git-send-email So this is a workaround to force the installation of + ## the conflicting package. + sudo apt-get install -y libauthen-sasl-perl \ + libemail-valid-perl \ + libio-socket-ssl-perl \ + libmailtools-perl perl \ + libnet-smtp-ssl-perl + + apt-get download git-email + sudo dpkg -i --force-all git-email*deb + + - name: Configure git identity + run: | + git config user.name "gccrs gerris bot" + git config user.email "${{ vars.SMTP_FROM }}" + + - name: Export env + env: + GH_EVENT: ${{ toJson(github.event) }} + run: | + echo "$GH_EVENT" > /tmp/gh_event.json + + BEFORE_REF=$(jq -r '.before' /tmp/gh_event.json) + echo "BEFORE_REF=$BEFORE_REF" >> $GITHUB_ENV + + AFTER_REF=$(jq -r '.after' /tmp/gh_event.json) + echo "AFTER_REF=$AFTER_REF" >> $GITHUB_ENV + + # PR_NUMBER=$(jq -r '.pull_request.number' /tmp/gh_event.json) + # echo "PR_NUMBER=$PR_NUMBER" >> $GITHUB_ENV + + # PR_TITLE=$(jq -r '.pull_request.title' /tmp/gh_event.json) + # echo "PR_TITLE=$PR_TITLE" >> $GITHUB_ENV + + # PR_URL=$(jq -r '.pull_request.html_url' /tmp/gh_event.json) + # echo "PR_URL=$PR_URL" >> $GITHUB_ENV + + # PR_MERGE_COMMIT=$(jq -r '.pull_request.merge_commit_sha' /tmp/gh_event.json) + # echo "PR_MERGE_COMMIT=$PR_MERGE_COMMIT" >> $GITHUB_ENV + + # PR_TARGET_BRANCH=$(jq -r '.pull_request.base.ref' /tmp/gh_event.json) + # echo "PR_TARGET_BRANCH=$PR_TARGET_BRANCH" >> $GITHUB_ENV + + # PR_LABELS=$(jq -r '[.pull_request.labels[].name] | join(",")' /tmp/gh_event.json) + # echo "PR_LABELS=$PR_LABELS" >> $GITHUB_ENV + + # REPO_SSH=$(jq -r '.repository.ssh_url' /tmp/gh_event.json) + # echo "REPO_SSH=$REPO_SSH" >> $GITHUB_ENV + + echo "GH_TOKEN=${{ github.token }}" >> $GITHUB_ENV + + # echo "SERIES_DIR=/tmp/series" >> $GITHUB_ENV + + - name: Get commit list and skip the internal ones + id: commits + env: + MAX_NUM_COMMITS: 30 + BEFORE_REF: ${{ github.event.before }} + AFTER_REF: ${{ github.event.after }} + run: | + # Skip commits that touches any of these + patterns=(".github/" + "CODE_OF_CONDUCT.md" + "CONTRIBUTING.md" + "Dockerfile" + "README.md" + "logo.png" + "gcc/rust/gource-gccrs.sh" + "gcc/rust/monthly-diff.py" + ) + regex=$(printf '%s\n' "${patterns[@]}" | sed -e 's/[.[\*^$+?(){|\/\\]/\\&/g' | paste -sd'|' -) + + rm -f /tmp/commits.txt + + if [ "$BEFORE_REF" = "0000000000000000000000000000000000000000" ] ; then + echo "New branch created, not sending anything" | tee $GITHUB_STEP_SUMMARY + echo "has_commits=false" >> $GITHUB_OUTPUT + exit 0 + fi + + if [ "$AFTER_REF" = "0000000000000000000000000000000000000000" ] ; then + echo "Branch is being deleted, not sending anything" | tee $GITHUB_STEP_SUMMARY + echo "has_commits=false" >> $GITHUB_OUTPUT + exit 0 + fi + + if git merge-base --is-ancestor "$BEFORE_REF" "$AFTER_REF"; then + echo "fast-forward push (not forced)" + else + echo "non-fast-forward push (force push or history rewrite), not sending anything" | tee $GITHUB_STEP_SUMMARY + echo "has_commits=false" >> $GITHUB_OUTPUT + exit 0 + fi + + IS_MERGE=$(git show --pretty=%P -s HEAD | wc -w) + if [ "$IS_MERGE" -gt 1 ] ; then + echo "Last commit is a merge, don't send anything" | tee $GITHUB_STEP_SUMMARY + echo "has_commits=false" >> $GITHUB_OUTPUT + exit 0 + fi + + # Fetch commits from the pull request (maybe they're from another repository) + #git fetch origin "pull/$PR_NUMBER/head" + + TOTAL=$(git log --oneline "$BEFORE_REF..$AFTER_REF" | wc -l) + if [ "${TOTAL}" -gt "$MAX_NUM_COMMITS" ]; then + echo "Push has too many commits" | tee $GITHUB_STEP_SUMMARY + echo "has_commits=false" >> $GITHUB_OUTPUT + exit 0 + fi + + git log --reverse --format=%H "$BEFORE_REF..$AFTER_REF" | while read SHA1; do + echo "Looking at $SHA1" + if grep -q -E "$regex" <(git diff-tree --no-commit-id --name-only -r "$SHA1"); then + echo "Touching something not to be upstreamed, skipping commit $SHA1" + else + echo "Adding one commit to the send list" + echo "$SHA1" >> /tmp/commits.txt + fi + done + + if [ ! -f /tmp/commits.txt ]; then + echo "No commits to send email for" | tee $GITHUB_STEP_SUMMARY + echo "has_commits=false" >> $GITHUB_OUTPUT + exit 0 + fi + + COUNT=$(wc -l < /tmp/commits.txt) + echo "Has $COUNT commits in the series" + + echo "has_commits=true" >> $GITHUB_OUTPUT + + - name: Check for label 'no-ml' to skip sending emails + id: checklabel + run: | + # not sure how to do that with "push". + echo "skip=false" >> $GITHUB_OUTPUT + exit 0 + + # Skip if PR has label "no-ml" + # if echo "$PR_LABELS" | grep -qiE "(^|,)no-ml(,|$)"; then + # echo "Opt-out label present: skipping mailing list." | tee $GITHUB_STEP_SUMMARY + # echo "skip=true" >> $GITHUB_OUTPUT + # else + # echo "No opt-out label found" + # echo "skip=false" >> $GITHUB_OUTPUT + # fi + + - name: Decide if we're sending something or not + id: send_emails + if: ( steps.commits.outputs.has_commits == 'true' && + steps.checklabel.outputs.skip == 'false' ) + run: | + echo "enabled=true" >> $GITHUB_OUTPUT + + - name: Prepare patch series + if: steps.send_emails.outputs.enabled == 'true' + run: | + set -euo pipefail + + # Create a temporary branch that linearizes the PR commits + git checkout -B ci-mail-patches "$BEFORE_REF" + # Cherry-pick commits in the exact PR order (no-commit to batch, then commit) + while read sha; do + git cherry-pick "$sha" + done < /tmp/commits.txt + + echo "This change was merged into the gccrs repository and is posted here for" >> /tmp/description.txt + echo "upstream visibility and potential drive-by review, as requested by GCC" >> /tmp/description.txt + echo "release managers." >> /tmp/description.txt + echo "Each commit email contains a link to its details on github from where you can" >> /tmp/description.txt + echo "find the Pull-Request and associated discussions." >> /tmp/description.txt + echo "" >> /tmp/description.txt + + mkdir /tmp/series + + # Generate series + cover letter + git format-patch \ + --subject-prefix="gccrs COMMIT" \ + --no-cover-letter \ + --base="$BEFORE_REF" \ + --output-directory /tmp/series \ + "$BEFORE_REF"..HEAD + + echo "" >> /tmp/description.txt + + cp /tmp/commits.txt /tmp/commits_stack.txt + while IFS= read -r -d '' f;do + # Read next SHA1... + SHA1=$(head -n1 /tmp/commits_stack.txt) + + # ... and pop it from the stack + sed -i '1d' /tmp/commits_stack.txt + + echo "SHA1: $SHA1" + echo "patch file: $f" + echo "" + + cp /tmp/description.txt "/tmp/tmp_descr.txt" + echo "Commit on github: https://github.com/${{ github.repository }}/commit/$SHA1" >> /tmp/tmp_descr.txt + + if gh api "repos/${{ github.repository }}/commits/$SHA1/pulls" | \ + jq '.[].html_url' > /tmp/tmp_pr_links.txt; + then + if [ -s /tmp/tmp_pr_links.txt ]; then + echo -e "\nThe commit has been mentioned in the following pull-request(s):" >> /tmp/tmp_descr.txt + + tr -d '"' < /tmp/tmp_pr_links.txt | \ + sed 's/^/ - /' >> /tmp/tmp_descr.txt + else + echo "The commit is not linked to any pull-request" >> /tmp/tmp_descr.txt + fi + else + echo "There was an error fetching data from github API for getting PR for commit" | tee -a "$GITHUB_STEP_SUMMARY" + fi + + echo >> /tmp/tmp_descr.txt + + # insert the github header right after the '---'. + sed '/^---$/ r /tmp/tmp_descr.txt' -i "$f" + + # loop over the patches and make sure to do that in numerical order + # 0001-..., 0002-...., ... + done < <(find /tmp/series/ -maxdepth 1 -type f -print0|sort -z -n) + + - name: Send series via git send-email + if: steps.send_emails.outputs.enabled == 'true' + env: + GIT_SMTP_SERVER: ${{ vars.SMTP_SERVER }} + GIT_SMTP_ENCRYPTION: tls + GIT_SMTP_SERVER_PORT: ${{ vars.SMTP_PORT }} + GIT_SMTP_AUTH: "true" + GIT_SMTP_USER: ${{ vars.SMTP_USERNAME }} + GIT_SMTP_PASSWORD: ${{ secrets.SMTP_PASSWORD }} + FROM: ${{ vars.SMTP_FROM }} + TO: ${{ vars.PATCH_TO }} + CC: ${{ vars.PATCH_CC }} + run: | + set -euo pipefail + + git config sendemail.smtpserver "$GIT_SMTP_SERVER" + git config sendemail.smtpserverport "$GIT_SMTP_SERVER_PORT" + git config sendemail.smtpencryption "$GIT_SMTP_ENCRYPTION" + git config sendemail.smtpuser "$GIT_SMTP_USER" + git config sendemail.smtppass "$GIT_SMTP_PASSWORD" + git config sendemail.from "$FROM" + git config sendemail.to "$TO" + if [ -n "${CC:-}" ]; then git config sendemail.cc "$CC"; fi + git config sendemail.thread "true" + git config sendemail.confirm "never" + git config sendemail.annotate "false" + + git send-email /tmp/series/* From 65ae3f57b1824547ad2e7ce50c9416ac75b39550 Mon Sep 17 00:00:00 2001 From: Ryo Yoshida Date: Mon, 13 Oct 2025 22:38:46 +0900 Subject: [PATCH 536/584] Bump clang-format version to use in CONTRIBUTING.md Since f1982cc0b41d10247d974d76db33e235d291c585, we are using clang-format-16 instead of clang-format-10. This commit updates the clang-format version documented in CONTRIBUTING.md so that new contributors don't get tripped. ChangeLog: * CONTRIBUTING.md: Update clang-format version Signed-off-by: Ryo Yoshida --- CONTRIBUTING.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 26f5618d779e..5b6fc271886a 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -59,12 +59,12 @@ and the link to the GitHub PR sent to the submitter. * on all files using python scripts ... corresponding to what the _Clang Format Lint_ (`.github/workflows/clang-format.yml`) -is doing, with `clang-format-10` being available locally, and avoiding the Docker overhead. +is doing, with `clang-format-16` being available locally, and avoiding the Docker overhead. ```shell $ wget 'https://github.com/DoozyX/clang-format-lint-action/raw/v0.11/run-clang-format.py' $ cp contrib/clang-format .clang-format -$ python3 run-clang-format.py --clang-format-executable clang-format-10 --recursive --extensions h,cc gcc/rust/ +$ python3 run-clang-format.py --clang-format-executable clang-format-16 --recursive --extensions h,cc gcc/rust/ ``` * on a given patch using python scripts @@ -124,7 +124,7 @@ index 9559374ce60..bd3043295ce 100644 }; ``` -Also note that you can use a given version of `clang-format` by using `git clang-format-10` if you have +Also note that you can use a given version of `clang-format` by using `git clang-format-16` if you have installed that particular version. Thanks! :heart: :heart: :heart: From 8e9c17da9a887f414238e4017513fd8e5fb778a0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marc=20Poulhi=C3=A8s?= Date: Fri, 14 Nov 2025 19:31:18 +0100 Subject: [PATCH 537/584] ci: fix reference check MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ChangeLog: * .github/workflows/commit-format.yml: adjust grep. Signed-off-by: Marc Poulhiès --- .github/workflows/commit-format.yml | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/.github/workflows/commit-format.yml b/.github/workflows/commit-format.yml index f669fdb372ee..d898461d14c6 100644 --- a/.github/workflows/commit-format.yml +++ b/.github/workflows/commit-format.yml @@ -125,16 +125,23 @@ jobs: retval=0; rev_list="origin/${{ github.event.pull_request.base.ref }}..${{ github.event.pull_request.head.sha }}" for commit in $(git rev-list --reverse "$rev_list"); do - if [ "$(git log --format=%B -n 1 \"$commit\" | grep '#[0-9]*' | grep -v -i 'Rust-GCC/gccrs#[0-9]*' | wc -l)" -ne 0 ]; then - echo "$commit: KO" + + git log --format=%B -n 1 "$commit" > /tmp/commit_log + + if grep -P '(^|[^\w]+)#[0-9]+' /tmp/commit_log > /tmp/found ; then + echo "$commit: KO because it has one or more bad references" | tee -a $GITHUB_STEP_SUMMARY + cat /tmp/found | tee -a $GITHUB_STEP_SUMMARY retval=1 else echo "$commit: OK" fi done; + if [ "$retval" -ne 0 ]; then - echo "Some raw issue references were found (eg. #4242)." - echo "You shall rewrite the faulty commit message with this format: Rust-GCC/gccrs#4242" - echo "You may ignore this CI step if it represents a valid GCC bugzilla or external repository reference instead." + echo "Some raw issue references were found (eg. #4242)." | tee -a $GITHUB_STEP_SUMMARY + echo "You shall rewrite the faulty commit message with this format: Rust-GCC/gccrs#4242" | tee -a $GITHUB_STEP_SUMMARY + echo "You may ignore this CI step if it represents a valid GCC bugzilla or external repository reference instead." | tee -a $GITHUB_STEP_SUMMARY + else + echo "No unadorned references found" | tee $GITHUB_STEP_SUMMARY fi exit $retval; From f925b782a256527e68a7475d12be36ed3c64795f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marc=20Poulhi=C3=A8s?= Date: Thu, 20 Nov 2025 23:04:04 +0100 Subject: [PATCH 538/584] ci: refactor ccpp workflow MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Use dtolnay/rust-toolchain action to install rustc toolchain. Use a composite action for the various build/check on ubuntu. More cleanup possible (the 32/64bits builds could be simplified and only build 1 compiler and split the checks) ChangeLog: * .github/workflows/ccpp.yml: Refactor. * .github/actions/build-gcc/action.yml: New file. Signed-off-by: Marc Poulhiès --- .github/actions/build-gcc/action.yml | 191 +++++++++++ .github/workflows/ccpp.yml | 477 ++++----------------------- 2 files changed, 249 insertions(+), 419 deletions(-) create mode 100644 .github/actions/build-gcc/action.yml diff --git a/.github/actions/build-gcc/action.yml b/.github/actions/build-gcc/action.yml new file mode 100644 index 000000000000..3f417d2ef1a7 --- /dev/null +++ b/.github/actions/build-gcc/action.yml @@ -0,0 +1,191 @@ +name: 'Build GCC' +description: 'Builds GCC with Rust enabled' +inputs: + extra-configure-env: + description: 'Extra env for configure' + default: '' + + run-test-flags: + description: 'Args for RUNTESTFLAGS' + required: true + + rustc-version: + description: 'rustc version to install' + default: "1.72.0" + + use-old-gcc: + description: 'Version to use for old GCC' + default: '' + + bootstrap: + description: 'Set to true to bootstrap the compiler' + default: false + + warning-file: + description: 'If set, checks compile log for extra warnings compared to provided file' + default: '' + + extra-configure-args: + description: 'Extra configure args to use for ./configure step' + default: '' + + glibc-assertion: + description: 'Enable GLIBC_ASSERTION for extra runtime checks' + default: false + + enable-multilib: + description: 'Enable multilib' + default: true + +runs: + using: "composite" + steps: + - name: Install dependencies + run: | + sudo apt-get update; + sudo apt-get install -y \ + automake \ + autoconf \ + libtool \ + autogen \ + bison \ + flex \ + libgmp3-dev \ + libmpfr-dev \ + libmpc-dev \ + build-essential \ + gcc-multilib \ + g++-multilib \ + dejagnu; + shell: bash + + - uses: dtolnay/rust-toolchain@stable + with: + toolchain: ${{ inputs.rustc-version }} + + - name: Make Source Read-Only + run: chmod -R a-w ./* + shell: bash + + - name: Restore cached old gcc ${{ inputs.use-old-gcc }} + if: inputs.use-old-gcc != '' + id: restore-gcc5 + uses: actions/cache/restore@v4 + with: + key: ce-tar-gcc-${{ inputs.use-old-gcc }} + path: ~/gcc-${{ inputs.use-old-gcc }}/ + + - name: Download and install gcc ${{ inputs.use-old-gcc }} + if: steps.restore-gcc5.outputs.cache-hit != 'true' && inputs.use-old-gcc != '' + shell: bash + run: | + curl "https://s3.amazonaws.com/compiler-explorer/opt/gcc-${{ inputs.use-old-gcc }}.tar.xz" -o /tmp/gcc.tar.xz; + cd ~; + tar xvf /tmp/gcc.tar.xz + + - name: Store gcc ${{ inputs.use-old-gcc }} to cache + id: cache-gcc5 + if: always() && steps.restore-gcc5.outputs.cache-hit != 'true' && inputs.use-old-gcc != '' + uses: actions/cache/save@v4 + with: + key: ce-tar-gcc-${{ inputs.use-old-gcc }} + path: ~/gcc-${{ inputs.use-old-gcc }}/ + + - name: Configure GCC + shell: bash + run: | + mkdir -p gccrs-build; + cd gccrs-build; + if [ -n "${{ inputs.use-old-gcc }}" ]; then + echo "Adjusting PATH for old gcc" + export PATH=$HOME/gcc-${{ inputs.use-old-gcc }}/bin:$PATH + fi + + if ${{ inputs.glibc-assertion }}; then + echo "Enabling GLIBCXX assertions" + export CXXFLAGS="$CXXFLAGS -D_GLIBCXX_ASSERTIONS" + fi + + if ${{ inputs.enable-multilib }}; then + echo "Enabling multilib" + MULTILIB_FLG=--enable-multilib + else + echo "Disabling multilib" + MULTILIB_FLG=--disable-multilib + fi + + if ${{ inputs.bootstrap }}; then + echo "Enabling bootstrap" + BOOTSTRAP_FLG=--enable-bootstrap + else + echo "Disabling bootstrap" + BOOTSTRAP_FLG=--disable-bootstrap + fi + + if [ -n "${{ inputs.extra-configure-args }}" ]; then + EXTRA_CONFIGURE_ARGS="${{ inputs.extra-configure-args }}" + echo "Using extra configure args: $EXTRA_CONFIGURE_ARGS" + else + EXTRA_CONFIGURE_ARGS="" + fi + + ../configure \ + --enable-languages=rust \ + $BOOTSTRAP_FLG \ + $MULTILIB_FLG \ + $EXTRA_CONFIGURE_ARGS + + - name: Build GCC + shell: bash + run: | + cd gccrs-build; \ + + if [ -n "${{ inputs.use-old-gcc }}" ]; then + export PATH=$HOME/gcc-${{ inputs.use-old-gcc }}/bin:$PATH + fi + + # Build without network access + unshare --net --ipc -r /bin/bash -c "\ + make -Otarget -j $(nproc) 2>&1 | \ + tee log; exit \${PIPESTATUS[0]}" + wc -l log + + - name: Check for new warnings + if: inputs.warning-file != '' + shell: bash + run: | + cd gccrs-build + echo "Before" + if grep 'warning: ' log | grep rust | sort > log_warnings; then + echo yes + else + echo no + fi + + echo "After" + + if diff -U0 ../.github/${{ inputs.warning-file }} log_warnings; then + echo "No new warnings found" + else + echo 'See .' + exit 1 + fi >&2 + + - name: Run Tests + shell: bash + run: | + cd gccrs-build; \ + make check-rust RUNTESTFLAGS="${{ inputs.run-test-flags }}" + + - name: Check regressions + shell: bash + run: | + cd gccrs-build + if grep -e "unexpected" -e "unresolved" -e "ERROR:" gcc/testsuite/rust/rust.sum; + then + echo "::error title=Regression test failed::some tests are not correct" + perl -n ../.github/emit_test_errors.pl < gcc/testsuite/rust/rust.sum + exit 1 + else + exit 0 + fi diff --git a/.github/workflows/ccpp.yml b/.github/workflows/ccpp.yml index b84be9bbbdf8..bbd57e96f093 100644 --- a/.github/workflows/ccpp.yml +++ b/.github/workflows/ccpp.yml @@ -6,451 +6,90 @@ on: - trying - staging pull_request: - branches: [ master ] + branches: [master] merge_group: env: ACTIONS_ALLOW_USE_UNSECURE_NODE_VERSION: true + # Force locale, in particular for reproducible results re '.github/log_expected_warnings' (see below). + LC_ALL: C.UTF-8 jobs: build-and-check-ubuntu-64bit: - - env: - # Force locale, in particular for reproducible results re '.github/log_expected_warnings' (see below). - LC_ALL: C.UTF-8 - runs-on: ubuntu-22.04 steps: - - uses: actions/checkout@v4 - - - name: Install Deps - run: | - sudo apt-get update; - sudo apt-get install -y \ - automake \ - autoconf \ - libtool \ - autogen \ - bison \ - flex \ - libgmp3-dev \ - libmpfr-dev \ - libmpc-dev \ - build-essential \ - gcc-multilib \ - g++-multilib \ - dejagnu; - # install Rust directly using rustup - curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain=1.72.0; - - - name: Make Source Read-Only - run: chmod -R a-w ./* - - - name: Configure - run: | - mkdir -p gccrs-build; - cd gccrs-build; - ../configure \ - --enable-languages=rust \ - --disable-bootstrap \ - --enable-multilib - - - name: Build - shell: bash - run: | - cd gccrs-build; \ - # Add cargo to our path quickly - . "$HOME/.cargo/env"; \ - # Build without network access - unshare --net --ipc -r /bin/bash -c "make -Otarget -j $(nproc) 2>&1 | tee log ; exit \${PIPESTATUS[0]}" + - uses: actions/checkout@v4 - - name: Check for new warnings - run: | - cd gccrs-build - < log grep 'warning: ' | grep rust | sort > log_warnings - if diff -U0 ../.github/log_expected_warnings log_warnings; then - : - else - echo 'See .' - exit 1 - fi >&2 - - - name: Run Tests - run: | - cd gccrs-build; \ - make check-rust RUNTESTFLAGS="--target_board=unix\{-m64}" - - name: Archive check-rust results - uses: actions/upload-artifact@v4 - with: - name: check-rust-logs-ubuntu-64 - path: | - gccrs-build/gcc/testsuite/rust/ - - name: Check regressions - run: | - cd gccrs-build; \ - if grep -e "unexpected" -e "unresolved" -e "ERROR:" gcc/testsuite/rust/rust.sum;\ - then \ - echo "::error title=Regression test failed::some tests are not correct"; \ - perl -n ../.github/emit_test_errors.pl < gcc/testsuite/rust/rust.sum; \ - exit 1; \ - else \ - exit 0; \ - fi + - id: build-and-test + uses: ./.github/actions/build-gcc + with: + extra-configure-env: '' + run-test-flags: '--target_board=unix\{-m64}' + warning-file: 'log_expected_warnings' + enable-multilib: false build-and-check-ubuntu-64bit-glibcxx: - - env: - # Force locale, in particular for reproducible results re '.github/log_expected_warnings' (see below). - LC_ALL: C.UTF-8 - runs-on: ubuntu-22.04 steps: - - uses: actions/checkout@v4 - - - name: Install Deps - run: | - sudo apt-get update; - sudo apt-get install -y \ - automake \ - autoconf \ - libtool \ - autogen \ - bison \ - flex \ - libgmp3-dev \ - libmpfr-dev \ - libmpc-dev \ - build-essential \ - gcc-multilib \ - g++-multilib \ - dejagnu; - # install Rust directly using rustup - curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain=1.72.0; - - - name: Make Source Read-Only - run: chmod -R a-w ./* - - - name: Configure - run: | - mkdir -p gccrs-build; - cd gccrs-build; - export CXXFLAGS="$CXXFLAGS -D_GLIBCXX_ASSERTIONS" - ../configure \ - --enable-languages=rust \ - --disable-bootstrap \ - --enable-multilib - - - name: Build - shell: bash - run: | - cd gccrs-build; \ - # Add cargo to our path quickly - . "$HOME/.cargo/env"; - make -Otarget -j $(nproc) 2>&1 | tee log - - - name: Check for new warnings - run: | - cd gccrs-build - < log grep 'warning: ' | grep rust | sort > log_warnings - if diff -U0 ../.github/glibcxx_ubuntu64b_log_expected_warnings log_warnings; then - : - else - echo 'See .' - exit 1 - fi >&2 - - - name: Run Tests - run: | - cd gccrs-build; \ - make check-rust RUNTESTFLAGS="--target_board=unix\{-m64}" - - name: Archive check-rust results - uses: actions/upload-artifact@v4 - with: - name: check-rust-logs-ubuntu-64-glibcxx - path: | - gccrs-build/gcc/testsuite/rust/ - - name: Check regressions - run: | - cd gccrs-build; \ - if grep -e "unexpected" -e "unresolved" -e "ERROR:" gcc/testsuite/rust/rust.sum;\ - then \ - echo "::error title=Regression test failed::some tests are not correct"; \ - perl -n ../.github/emit_test_errors.pl < gcc/testsuite/rust/rust.sum; \ - exit 1; \ - else \ - exit 0; \ - fi - + - uses: actions/checkout@v4 + + - id: build-and-test + uses: ./.github/actions/build-gcc + with: + extra-configure-env: '' + run-test-flags: '--target_board=unix\{-m64}' + warning-file: 'glibcxx_ubuntu64b_log_expected_warnings' + glibc-assertion: true + enable-multilib: false + bootstrap: false + + # This is redundant with 64bit as we are doing multilib. Should build once and test both. build-and-check-ubuntu-32bit: - - env: - # Force locale, in particular for reproducible results re '.github/log_expected_warnings' (see below). - LC_ALL: C.UTF-8 - runs-on: ubuntu-22.04 steps: - - uses: actions/checkout@v4 - - - name: Install Deps - run: | - sudo apt-get update; - sudo apt-get install -y \ - automake \ - autoconf \ - libtool \ - autogen \ - bison \ - flex \ - libgmp3-dev \ - libmpfr-dev \ - libmpc-dev \ - build-essential \ - gcc-multilib \ - g++-multilib \ - dejagnu; - # install Rust directly using rustup - curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain=1.72.0; - - - name: Make Source Read-Only - run: chmod -R a-w ./* - - - name: Configure - run: | - mkdir -p gccrs-build; - cd gccrs-build; - ../configure \ - --enable-languages=rust \ - --disable-bootstrap \ - --enable-multilib - - - name: Build - shell: bash - run: | - cd gccrs-build; \ - # Add cargo to our path quickly - . "$HOME/.cargo/env"; - make -Otarget -j $(nproc) 2>&1 | tee log - - - name: Check for new warnings - run: | - cd gccrs-build - < log grep 'warning: ' | grep rust | sort > log_warnings - if diff -U0 ../.github/log_expected_warnings log_warnings; then - : - else - echo 'See .' - exit 1 - fi >&2 - - - name: Run Tests - run: | - cd gccrs-build; \ - make check-rust RUNTESTFLAGS="--target_board=unix\{-m32}" - - name: Archive check-rust results - uses: actions/upload-artifact@v4 - with: - name: check-rust-logs-ubuntu-32 - path: | - gccrs-build/gcc/testsuite/rust/ - - name: Check regressions - run: | - cd gccrs-build; \ - if grep -e "unexpected" -e "unresolved" -e "ERROR:" gcc/testsuite/rust/rust.sum;\ - then \ - echo "::error title=Regression test failed::some tests are not correct"; \ - perl -n ../.github/emit_test_errors.pl < gcc/testsuite/rust/rust.sum; \ - exit 1; \ - else \ - exit 0; \ - fi + - uses: actions/checkout@v4 + + - id: build-and-test + uses: ./.github/actions/build-gcc + with: + extra-configure-env: '' + run-test-flags: '--target_board=unix\{-m32}' + warning-file: 'log_expected_warnings' + glibc-assertion: true + enable-multilib: true + bootstrap: false build-and-check-gcc-5: - runs-on: ubuntu-22.04 - env: - # otherwise we hang when installing tzdata - DEBIAN_FRONTEND: noninteractive - steps: - - uses: actions/checkout@v4 - - - name: Install Deps - run: | - sudo apt-get update; - sudo apt-get install -y \ - curl \ - automake \ - autoconf \ - libtool \ - autogen \ - bison \ - flex \ - libc6-dev \ - libc6-dev-i386 \ - libgmp3-dev \ - libmpfr-dev \ - libmpc-dev \ - build-essential \ - dejagnu; - # install Rust directly using rustup - curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain=1.72.0; - - - name: Restore cached gcc-5.4 - id: restore-gcc5 - uses: actions/cache/restore@v4 - with: - key: ce-tar-gcc-5 - path: ~/gcc-5.4.0/ - - - name: Download and install gcc5.4 - if: ${{ steps.restore-gcc5.outputs.cache-hit != 'true' }} - run: | - curl "https://s3.amazonaws.com/compiler-explorer/opt/gcc-5.4.0.tar.xz" -o /tmp/gcc.tar.xz; - cd ~; - tar xvf /tmp/gcc.tar.xz - - - name: Store gcc-5.4 to cache - id: cache-gcc5 - if: always() && steps.restore-gcc5.outputs.cache-hit != 'true' - uses: actions/cache/save@v4 - with: - key: ce-tar-gcc-5 - path: ~/gcc-5.4.0/ - - - name: Make Source Read-Only - run: chmod -R a-w ./* - - - name: Configure - run: | - mkdir -p gccrs-build; - cd gccrs-build; - - # Add cargo to our path quickly - . "$HOME/.cargo/env"; - - PATH=$HOME/gcc-5.4.0/bin:$PATH \ - ../configure \ - --enable-languages=rust \ - --disable-bootstrap \ - --enable-multilib - - - name: Build - shell: bash - run: | - # Add cargo to our path quickly - . "$HOME/.cargo/env"; - PATH=$HOME/gcc-5.4.0/bin:$PATH \ - make -C gccrs-build -j $(nproc) - - name: Run Tests - run: | - cd gccrs-build; \ - PATH=$HOME/gcc-5.4.0/bin:$PATH \ - make check-rust RUNTESTFLAGS="--target_board=unix\{-m32,-m64}" - - - name: Archive check-rust results - uses: actions/upload-artifact@v4 - with: - name: check-rust-logs-5 - path: | - gccrs-build/gcc/testsuite/rust/ - - - name: Check regressions - run: | - cd gccrs-build; \ - if grep -e "unexpected" -e "unresolved" -e "ERROR:" gcc/testsuite/rust/rust.sum;\ - then \ - echo "::error title=Regression test failed::some tests are not correct"; \ - exit 1; \ - else \ - exit 0; \ - fi + steps: + - uses: actions/checkout@v4 + + - id: build-and-test + uses: ./.github/actions/build-gcc + with: + extra-configure-env: '' + run-test-flags: '--target_board=unix\{-m32,-m64}' + glibc-assertion: false + use-old-gcc: '5.4.0' + enable-multilib: true + bootstrap: false build-and-check-asan: - - env: - # Force locale, in particular for reproducible results re '.github/log_expected_warnings' (see below). - LC_ALL: C.UTF-8 - runs-on: ubuntu-22.04 steps: - - uses: actions/checkout@v4 - - - name: Install Deps - run: | - sudo apt-get update; - sudo apt-get install -y \ - automake \ - autoconf \ - libtool \ - autogen \ - bison \ - flex \ - libgmp3-dev \ - libmpfr-dev \ - libmpc-dev \ - build-essential \ - gcc-multilib \ - g++-multilib \ - dejagnu; - # install Rust directly using rustup - curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain=1.72.0; - - - name: Make Source Read-Only - run: chmod -R a-w ./* - - - name: Configure - run: | - mkdir -p gccrs-build; - cd gccrs-build; - ../configure \ - --enable-languages=rust \ - --disable-bootstrap \ - --enable-multilib \ - --with-build-config=../.github/no-bootstrap-asan - - - name: Build - shell: bash - run: | - cd gccrs-build; \ - # Add cargo to our path quickly - . "$HOME/.cargo/env"; - make -Otarget -j $(nproc) 2>&1 | tee log - -# Skip warnings check -# - name: Check for new warnings -# run: | -# cd gccrs-build -# < log grep 'warning: ' | sort > log_warnings -# if diff -U0 ../.github/log_expected_warnings log_warnings; then -# : -# else -# echo 'See .' -# exit 1 -# fi >&2 - - - name: Run Tests - run: | - cd gccrs-build; \ - ASAN_OPTIONS=detect_leaks=0:use_odr_indicator=1 \ - make check-rust RUNTESTFLAGS="--target_board=unix\{-m64}" - - name: Archive check-rust results - uses: actions/upload-artifact@v4 - with: - name: check-rust-logs-asan - path: | - gccrs-build/gcc/testsuite/rust/ - - name: Check regressions - run: | - cd gccrs-build; \ - if grep -e "unexpected" -e "unresolved" -e "ERROR:" gcc/testsuite/rust/rust.sum;\ - then \ - echo "::error title=Regression test failed::some tests are not correct"; \ - perl -n ../.github/emit_test_errors.pl < gcc/testsuite/rust/rust.sum; \ - exit 1; \ - else \ - exit 0; \ - fi + - uses: actions/checkout@v4 + + - id: build-and-test + uses: ./.github/actions/build-gcc + with: + extra-configure-env: '' + run-test-flags: '--target_board=unix\{-m64}' + glibc-assertion: false + enable-multilib: true + extra-configure-args: "--with-build-config=../.github/no-bootstrap-asan" + bootstrap: false From 24909e6ddf267344c0d55c453d1bfe49876e9f39 Mon Sep 17 00:00:00 2001 From: Osama Albahrani Date: Mon, 10 Nov 2025 04:05:17 +0300 Subject: [PATCH 539/584] README: Add build dependencies for Fedora WSL ChangeLog: * README.md: Add Fedora WSL deps. Signed-off-by: Osama Albahrani --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index c71bb0868875..1a8c3189f5fc 100644 --- a/README.md +++ b/README.md @@ -48,7 +48,7 @@ $ apt install build-essential libgmp3-dev libmpfr-dev libmpc-dev flex bison auto Fetch dependencies for Fedora: ```bash -$ dnf install autoconf automake dejagnu flex bison glibc-devel.{x86_64,i686} gmp-devel libmpc-devel mpfr-devel +$ dnf install autoconf automake dejagnu flex bison glibc-devel.{x86_64,i686} gmp-devel libmpc-devel mpfr-devel gcc gcc-c++ cargo awk ``` Clone the repository From 0e01a916264da1ebd52a798e9c69c6f4cff280e0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marc=20Poulhi=C3=A8s?= Date: Fri, 30 Jan 2026 19:08:59 +0100 Subject: [PATCH 540/584] ci: fix send email workflow in case of large commit log MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit We've had at least one case of mails not being sent because the commit log was so big that the $GH_EVENT var couldn't be expanded by the shell. Using envsubst avoids having the shell do the expansion. ChangeLog: * .github/workflows/send-emails.yml: use envsubst. Signed-off-by: Marc Poulhiès --- .github/workflows/send-emails.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/send-emails.yml b/.github/workflows/send-emails.yml index d50d9321cf63..4a1e1b8d7cce 100644 --- a/.github/workflows/send-emails.yml +++ b/.github/workflows/send-emails.yml @@ -41,7 +41,9 @@ jobs: env: GH_EVENT: ${{ toJson(github.event) }} run: | - echo "$GH_EVENT" > /tmp/gh_event.json + # GH_EVENT can be very big as it contains the full commit log and + # overflow the shell's maximum length. + echo '$GH_EVENT' | envsubst '$GH_EVENT' > /tmp/gh_event.json BEFORE_REF=$(jq -r '.before' /tmp/gh_event.json) echo "BEFORE_REF=$BEFORE_REF" >> $GITHUB_ENV From 70928ce92d8a214fb5506fc82949fe27edd065e6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marc=20Poulhi=C3=A8s?= Date: Sun, 19 Apr 2026 12:23:11 +0200 Subject: [PATCH 541/584] ci: parse and expand gccrs github's issues Look for Rust-GCC/gccrs#XXXXXX issue references (and only that) and expand them as github URLs in the email body. See Rust-GCC/gccrs#4529 ChangeLog: * .github/workflows/send-emails.yml: Expand github's issues references in sent emails. --- .github/workflows/send-emails.yml | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/.github/workflows/send-emails.yml b/.github/workflows/send-emails.yml index 4a1e1b8d7cce..034510e21f71 100644 --- a/.github/workflows/send-emails.yml +++ b/.github/workflows/send-emails.yml @@ -224,6 +224,28 @@ jobs: cp /tmp/description.txt "/tmp/tmp_descr.txt" echo "Commit on github: https://github.com/${{ github.repository }}/commit/$SHA1" >> /tmp/tmp_descr.txt + LINKED_ISSUES_LIST_FILE=/tmp/commit_linked_issues.txt + + ## find issue(s) referenced in commit message + gccrs_ref_regex='Rust-GCC/gccrs#[0-9]+' + git show -s --format=%B "$SHA1" | \ + grep -Eo "$gccrs_ref_regex" | \ + sort -u > "$LINKED_ISSUES_LIST_FILE" + + echo "Issues list: >>>" + cat "$LINKED_ISSUES_LIST_FILE" + echo "<<<" + echo + + if [ -s "$LINKED_ISSUES_LIST_FILE" ]; then + echo -e "\nThe commit has been mentioned in the following issue(s):" >> /tmp/tmp_descr.txt + while read -r i; do + ISSUE_NUM=${i##*#} # 1234 + echo " - $i: https://github.com/Rust-GCC/gccrs/issues/${ISSUE_NUM}" >> /tmp/tmp_descr.txt + done < "$LINKED_ISSUES_LIST_FILE" + fi + + ## find corresponding pull-request(s) if gh api "repos/${{ github.repository }}/commits/$SHA1/pulls" | \ jq '.[].html_url' > /tmp/tmp_pr_links.txt; then From a39804b0c9ae4d049c8c1e01cac8cdb0160d1aa1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marc=20Poulhi=C3=A8s?= Date: Mon, 25 May 2026 17:59:02 +0200 Subject: [PATCH 542/584] ci: fix the issue reference scrapper when there's no ref MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit grep returned an error when there was no reference, causing the workflow to stop. ChangeLog: .github/workflows/send-emails.yml: fix issue ref scrapping. Signed-off-by: Marc Poulhiès --- .github/workflows/send-emails.yml | 32 ++++++++++++++++--------------- 1 file changed, 17 insertions(+), 15 deletions(-) diff --git a/.github/workflows/send-emails.yml b/.github/workflows/send-emails.yml index 034510e21f71..29345d51f124 100644 --- a/.github/workflows/send-emails.yml +++ b/.github/workflows/send-emails.yml @@ -228,21 +228,23 @@ jobs: ## find issue(s) referenced in commit message gccrs_ref_regex='Rust-GCC/gccrs#[0-9]+' - git show -s --format=%B "$SHA1" | \ - grep -Eo "$gccrs_ref_regex" | \ - sort -u > "$LINKED_ISSUES_LIST_FILE" - - echo "Issues list: >>>" - cat "$LINKED_ISSUES_LIST_FILE" - echo "<<<" - echo - - if [ -s "$LINKED_ISSUES_LIST_FILE" ]; then - echo -e "\nThe commit has been mentioned in the following issue(s):" >> /tmp/tmp_descr.txt - while read -r i; do - ISSUE_NUM=${i##*#} # 1234 - echo " - $i: https://github.com/Rust-GCC/gccrs/issues/${ISSUE_NUM}" >> /tmp/tmp_descr.txt - done < "$LINKED_ISSUES_LIST_FILE" + if git show -s --format=%B "$SHA1" | \ + grep -Eo "$gccrs_ref_regex" | \ + sort -u > "$LINKED_ISSUES_LIST_FILE"; + then + + echo "Issues list: >>>" + cat "$LINKED_ISSUES_LIST_FILE" + echo "<<<" + echo + + echo -e "\nThe commit has been mentioned in the following issue(s):" >> /tmp/tmp_descr.txt + while read -r i; do + ISSUE_NUM=${i##*#} # 1234 + echo " - $i: https://github.com/Rust-GCC/gccrs/issues/${ISSUE_NUM}" >> /tmp/tmp_descr.txt + done < "$LINKED_ISSUES_LIST_FILE" + else + echo -e "\nThe commit has NOT been mentioned in any issue." | tee -a "$GITHUB_STEP_SUMMARY" /tmp/tmp_descr.txt fi ## find corresponding pull-request(s) From ac223ceb592e1d5f35d19b2231e01dc071223a8d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marc=20Poulhi=C3=A8s?= Date: Wed, 3 Jun 2026 10:18:58 +0200 Subject: [PATCH 543/584] ci: prevent @noreply DOT github DOT com emails github allows contribution without disclosing author's email. It uses a "@noreply DOT github DOT com" in the commit log, which is not OK for upstream contribution. Refs: Rust-GCC/gccrs#4568 ChangeLog: * .github/workflows/commit-format.yml (check-valid-email): New job to reject bad emails. --- .github/workflows/commit-format.yml | 32 +++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/.github/workflows/commit-format.yml b/.github/workflows/commit-format.yml index d898461d14c6..2be399f2790e 100644 --- a/.github/workflows/commit-format.yml +++ b/.github/workflows/commit-format.yml @@ -109,6 +109,38 @@ jobs: exit $retval; + check-valid-email: + runs-on: ubuntu-latest + name: check-valid-email + + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ github.event.pull_request.head.sha }} + fetch-depth: 0 + + - name: Check author's email looks correct + run: | + retval=0; + + rev_list="origin/${{ github.event.pull_request.base.ref }}..${{ github.event.pull_request.head.sha }}" + for commit in $(git rev-list --reverse "$rev_list"); do + + if M=$(git show -s "$commit" | grep "noreply.github.com"); then + echo "$commit: KO => an invalid email was found: $M" | tee -a $GITHUB_STEP_SUMMARY + retval=1 + else + echo "$commit: email looks OK" + fi + done + + if [ "$retval" -ne 0 ]; then + echo "Some invalid emails were found." | tee -a $GITHUB_STEP_SUMMARY + else + echo "All emails look OK" | tee $GITHUB_STEP_SUMMARY + fi + exit $retval; + check-issue-reference: runs-on: ubuntu-latest continue-on-error: true # We do not want to block merge if it is a legitimate GCC bugzilla reference. From 3838f0a2fa1753e171aece442515a8f461c9093b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marc=20Poulhi=C3=A8s?= Date: Thu, 25 Jun 2026 18:41:52 +0200 Subject: [PATCH 544/584] ci: look for "/#ref" pattern A full reference to a github issue is: Rust-GCC/gccrs#XXX This will help with the email script that scraps refs. ChangeLog/ * .github/workflows/commit-format.yml: Adjust regex for matching github ref. --- .github/workflows/commit-format.yml | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/.github/workflows/commit-format.yml b/.github/workflows/commit-format.yml index 2be399f2790e..133a829a61de 100644 --- a/.github/workflows/commit-format.yml +++ b/.github/workflows/commit-format.yml @@ -160,9 +160,11 @@ jobs: git log --format=%B -n 1 "$commit" > /tmp/commit_log - if grep -P '(^|[^\w]+)#[0-9]+' /tmp/commit_log > /tmp/found ; then + python -c 'import re,sys; p=re.compile(r"(? /tmp/found + + if [ -s /tmp/found ] ; then echo "$commit: KO because it has one or more bad references" | tee -a $GITHUB_STEP_SUMMARY - cat /tmp/found | tee -a $GITHUB_STEP_SUMMARY + tee -a $GITHUB_STEP_SUMMARY < /tmp/found retval=1 else echo "$commit: OK" @@ -170,10 +172,13 @@ jobs: done; if [ "$retval" -ne 0 ]; then - echo "Some raw issue references were found (eg. #4242)." | tee -a $GITHUB_STEP_SUMMARY - echo "You shall rewrite the faulty commit message with this format: Rust-GCC/gccrs#4242" | tee -a $GITHUB_STEP_SUMMARY - echo "You may ignore this CI step if it represents a valid GCC bugzilla or external repository reference instead." | tee -a $GITHUB_STEP_SUMMARY + echo "Some bad issue references were found (eg. #4242, Rust-GCC#7777)." | tee -a $GITHUB_STEP_SUMMARY + echo "You shall rewrite the faulty commit message with this format: Rust-GCC/gccrs#4242" | \ + tee -a $GITHUB_STEP_SUMMARY + echo "You may ignore this CI step if it represents a valid GCC bugzilla or external repository reference instead." | \ + tee -a $GITHUB_STEP_SUMMARY else - echo "No unadorned references found" | tee $GITHUB_STEP_SUMMARY + echo "No unadorned (#1234) or incorrect (foo#1234) references found" | \ + tee $GITHUB_STEP_SUMMARY fi exit $retval; From 97d48588f66b8ad94181331d44d76d1331981733 Mon Sep 17 00:00:00 2001 From: Owen Avery Date: Wed, 15 Jul 2026 20:31:50 -0400 Subject: [PATCH 545/584] ci: Avoid trying to send emails on forked repos ChangeLog: * .github/workflows/send-emails.yml: Check if we have a configured SMTP server before running send_patches. Signed-off-by: Owen Avery --- .github/workflows/send-emails.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/send-emails.yml b/.github/workflows/send-emails.yml index 29345d51f124..d119d2cfc8d5 100644 --- a/.github/workflows/send-emails.yml +++ b/.github/workflows/send-emails.yml @@ -8,6 +8,7 @@ on: jobs: send_patches: runs-on: ubuntu-latest + if: ${{ vars.SMTP_SERVER != '' }} steps: - name: Checkout repo with full history From 5b8eb24031733830dc1ce61d6ecfa4f51cf851c5 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 11 Sep 2026 16:23:50 +0100 Subject: [PATCH 546/584] gccrs: Support silly legacy rustc const generics for stdarch This is a daft feature so instead of using the turbo fish to supply the const generics like a sensible language rustc uses this attribute to support that the order/index of call arguments are the const generic arguments in order for the param list. So we walk them then grab the associated subst param mapping and unify it. Fixes Rust-GCC/gccrs#3868 gcc/rust/ChangeLog: * backend/rust-compile-expr.cc (CompileExpr::visit): check for const args * hir/tree/rust-hir-expr.cc (CallExpr::CallExpr): add new helper to parse attribute (CallExpr::operator=): new member * hir/tree/rust-hir-expr.h (class CallExpr): new helper * hir/tree/rust-hir-item.cc (Function::get_legacy_const_generic_indexes): likewise * hir/tree/rust-hir-item.h: likewise * typecheck/rust-tyty-call.cc (TypeCheckCallExpr::visit): handle const args * typecheck/rust-tyty-subst.cc (SubstitutionRef::resolve_const_argument): refactor out * typecheck/rust-tyty-subst.h: likewise gcc/testsuite/ChangeLog: * rust/compile/issues/issue-3868.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/backend/rust-compile-expr.cc | 15 +- gcc/rust/hir/tree/rust-hir-expr.cc | 3 +- gcc/rust/hir/tree/rust-hir-expr.h | 17 +++ gcc/rust/hir/tree/rust-hir-item.cc | 72 +++++++++ gcc/rust/hir/tree/rust-hir-item.h | 2 + gcc/rust/typecheck/rust-tyty-call.cc | 101 ++++++++++-- gcc/rust/typecheck/rust-tyty-subst.cc | 144 +++++++++--------- gcc/rust/typecheck/rust-tyty-subst.h | 3 + .../rust/compile/issues/issue-3868.rs | 15 ++ 9 files changed, 282 insertions(+), 90 deletions(-) create mode 100644 gcc/testsuite/rust/compile/issues/issue-3868.rs diff --git a/gcc/rust/backend/rust-compile-expr.cc b/gcc/rust/backend/rust-compile-expr.cc index 815f53cb0878..e2e5644938e7 100644 --- a/gcc/rust/backend/rust-compile-expr.cc +++ b/gcc/rust/backend/rust-compile-expr.cc @@ -1760,12 +1760,18 @@ CompileExpr::visit (HIR::CallExpr &expr) } std::vector args; - for (size_t i = 0; i < expr.get_arguments ().size (); i++) + for (size_t source_argument_index = 0; + source_argument_index < expr.get_arguments ().size (); + source_argument_index++) { - auto &argument = expr.get_arguments ().at (i); + if (expr.is_const_argument (source_argument_index)) + continue; + + auto &argument = expr.get_arguments ().at (source_argument_index); + size_t runtime_argument_index = args.size (); auto rvalue = CompileExpr::Compile (*argument, ctx); - if (is_variadic && i >= required_num_args) + if (is_variadic && runtime_argument_index >= required_num_args) { args.push_back (rvalue); continue; @@ -1775,7 +1781,8 @@ CompileExpr::visit (HIR::CallExpr &expr) // necessary bool ok; TyTy::BaseType *expected = nullptr; - ok = get_parameter_tyty_at_index (tyty, i, &expected); + ok + = get_parameter_tyty_at_index (tyty, runtime_argument_index, &expected); rust_assert (ok); TyTy::BaseType *actual = nullptr; diff --git a/gcc/rust/hir/tree/rust-hir-expr.cc b/gcc/rust/hir/tree/rust-hir-expr.cc index c4ccad1497bf..080ac4da6a40 100644 --- a/gcc/rust/hir/tree/rust-hir-expr.cc +++ b/gcc/rust/hir/tree/rust-hir-expr.cc @@ -581,7 +581,7 @@ CallExpr::CallExpr (Analysis::NodeMapping mappings, CallExpr::CallExpr (CallExpr const &other) : ExprWithoutBlock (other), function (other.function->clone_expr ()), - locus (other.locus) + const_argument_indexes (other.const_argument_indexes), locus (other.locus) /*, params(other.params),*/ { params.reserve (other.params.size ()); for (const auto &e : other.params) @@ -593,6 +593,7 @@ CallExpr::operator= (CallExpr const &other) { ExprWithoutBlock::operator= (other); function = other.function->clone_expr (); + const_argument_indexes = other.const_argument_indexes; locus = other.locus; params.reserve (other.params.size ()); diff --git a/gcc/rust/hir/tree/rust-hir-expr.h b/gcc/rust/hir/tree/rust-hir-expr.h index 02c6f253810a..14e29e0853ef 100644 --- a/gcc/rust/hir/tree/rust-hir-expr.h +++ b/gcc/rust/hir/tree/rust-hir-expr.h @@ -1413,6 +1413,7 @@ class CallExpr : public ExprWithoutBlock { std::unique_ptr function; std::vector> params; + std::vector const_argument_indexes; location_t locus; public: @@ -1440,6 +1441,22 @@ class CallExpr : public ExprWithoutBlock void accept_vis (HIRFullVisitor &vis) override; void accept_vis (HIRExpressionVisitor &vis) override; + void set_const_argument_indexes (const std::vector &indexes) + { + const_argument_indexes = indexes; + } + + bool is_const_argument (size_t index) const + { + for (auto const_index : const_argument_indexes) + { + if (index == const_index) + return true; + } + + return false; + } + bool has_fnexpr () const { return function != nullptr; } Expr &get_fnexpr () { return *function; } diff --git a/gcc/rust/hir/tree/rust-hir-item.cc b/gcc/rust/hir/tree/rust-hir-item.cc index d5c9ad154c8d..8273ab516310 100644 --- a/gcc/rust/hir/tree/rust-hir-item.cc +++ b/gcc/rust/hir/tree/rust-hir-item.cc @@ -18,6 +18,8 @@ #include "rust-hir-item.h" #include "optional.h" +#include "rust-attribute-values.h" +#include "rust-attributes.h" namespace Rust { namespace HIR { @@ -261,6 +263,76 @@ Module::operator= (Module const &other) return *this; } +tl::optional> +Function::get_legacy_const_generic_indexes () const +{ + std::vector legacy_const_generic_indexes; + const auto &attrs = get_outer_attrs (); + for (const auto &attr : attrs) + { + const auto possibly_builtin = Analysis::lookup_builtin (attr); + if (!possibly_builtin.has_value ()) + continue; + + const auto &mapping = possibly_builtin.value (); + if (mapping.name != Values::Attributes::RUSTC_ARGS_REQUIRED_CONST) + continue; + + if (!attr.has_attr_input ()) + { + rust_error_at (attr.get_locus (), "malformed %qs attribute", + mapping.name.c_str ()); + return tl::nullopt; + } + + auto parsed_attr = attr; + parsed_attr.parse_attr_to_meta_item (); + if (!parsed_attr.is_parsed_to_meta_item ()) + { + rust_error_at (attr.get_locus (), "malformed %qs attribute", + mapping.name.c_str ()); + return tl::nullopt; + } + + const auto &container + = static_cast ( + parsed_attr.get_attr_input ()); + const auto &items = container.get_items (); + for (const auto &item : items) + { + if (item->get_kind () != AST::MetaItemInner::Kind::LitExpr) + { + rust_error_at (item->get_locus (), + "expected an integer argument index"); + return tl::nullopt; + } + const auto &literal + = static_cast (*item).get_literal (); + if (literal.get_lit_type () != AST::Literal::INT) + { + rust_error_at (item->get_locus (), + "expected an integer argument index"); + return tl::nullopt; + } + + mpz_t value; + if (mpz_init_set_str (value, literal.as_string ().c_str (), 10) != 0) + { + mpz_clear (value); + rust_error_at (item->get_locus (), "failed load argument index"); + return tl::nullopt; + } + + size_t index = 0; + mpz_export (&index, nullptr, 1, sizeof (index), 0, 0, value); + mpz_clear (value); + legacy_const_generic_indexes.push_back (index); + } + } + + return legacy_const_generic_indexes; +} + Function::Function (Analysis::NodeMapping mappings, Identifier function_name, FunctionQualifiers qualifiers, std::vector> generic_params, diff --git a/gcc/rust/hir/tree/rust-hir-item.h b/gcc/rust/hir/tree/rust-hir-item.h index 9a572bf92c65..a07334ee9799 100644 --- a/gcc/rust/hir/tree/rust-hir-item.h +++ b/gcc/rust/hir/tree/rust-hir-item.h @@ -966,6 +966,8 @@ class Function : public VisItem, public ImplItem public: std::string to_string () const override; + tl::optional> get_legacy_const_generic_indexes () const; + // Returns whether function has generic parameters. bool has_generics () const { return !generic_params.empty (); } diff --git a/gcc/rust/typecheck/rust-tyty-call.cc b/gcc/rust/typecheck/rust-tyty-call.cc index f87b160f8485..3dd72a5fd238 100644 --- a/gcc/rust/typecheck/rust-tyty-call.cc +++ b/gcc/rust/typecheck/rust-tyty-call.cc @@ -17,10 +17,13 @@ // . #include "rust-tyty-call.h" +#include "optional.h" +#include "rust-hir-item.h" #include "rust-hir-type-check-expr.h" #include "rust-hir-type-check.h" #include "rust-type-util.h" #include "rust-hir-trait-reference.h" +#include "rust-tyty.h" namespace Rust { namespace TyTy { @@ -153,26 +156,91 @@ TypeCheckCallExpr::visit (ADTType &type) void TypeCheckCallExpr::visit (FnType &type) { - if (call.num_params () != type.num_params ()) + std::vector indexes; + const auto lookup = mappings.lookup_defid (type.get_id ()); + if (lookup.has_value ()) + { + const auto *item = lookup.value (); + rust_assert (item->get_item_kind () == HIR::Item::ItemKind::Function); + + const auto &fn = *static_cast (item); + auto legacy_const_generic_indexes + = fn.get_legacy_const_generic_indexes (); + + bool malformed_const_generic_indexes + = !legacy_const_generic_indexes.has_value (); + if (malformed_const_generic_indexes) + return; + + indexes = legacy_const_generic_indexes.value (); + } + + size_t expected_args = type.num_params () + indexes.size (); + if (call.num_params () < expected_args + || (!type.is_variadic () && call.num_params () != expected_args)) + { + emit_unexpected_argument_error (call.get_locus (), call.num_params (), + expected_args); + return; + } + + if (!indexes.empty ()) { - if (type.is_variadic ()) + std::set seen; + for (size_t i = 0; i < indexes.size (); i++) { - if (call.num_params () < type.num_params ()) + size_t index = indexes[i]; + seen.insert (index); + + bool duplicate_index = seen.size () != i + 1; + if (index >= call.num_params () || duplicate_index) { - emit_unexpected_argument_error ( - call.get_locus (), (unsigned long) call.num_params (), - (unsigned long) type.num_params ()); + rust_error_at (call.get_locus (), "invalid const argument index"); return; } } - else + + std::vector const_params; + for (auto &sub : type.get_substs ()) + { + if (sub.get_generic_param ().get_kind () + == HIR::GenericParam::GenericKind::CONST) + const_params.push_back (&sub); + } + + if (const_params.size () != indexes.size ()) { - emit_unexpected_argument_error (call.get_locus (), - (unsigned long) call.num_params (), - (unsigned long) type.num_params ()); + rust_error_at ( + call.get_locus (), + "const argument count does not match const parameters"); + return; } + + auto &subst_mappings = type.get_substitution_arguments (); + for (size_t i = 0; i < indexes.size (); i++) + { + size_t cidx = indexes[i]; + auto &argument = *call.get_arguments ().at (cidx); + + auto *param = const_params[i]->get_param_ty (); + auto const_ty = param->as_const_type ()->get_specified_type (); + auto *value + = SubstitutionRef::resolve_const_argument (argument, const_ty); + + if (value->is ()) + return; + + SubstitutionArg existing = SubstitutionArg::error (); + bool ok = subst_mappings.get_argument_for_symbol (param, &existing); + rust_assert (ok); + + Resolver::unify_site (argument.get_mappings ().get_hirid (), + TyWithLocation (existing.get_tyty ()), + TyWithLocation (value), argument.get_locus ()); + } } + call.set_const_argument_indexes (indexes); // if the surrounding context has pushed an expected type, try unifying it // with the fn's return type before checking arguments. This lets the callee @@ -193,9 +261,13 @@ TypeCheckCallExpr::visit (FnType &type) true /*implicit_infer_vars*/, true /*cleanup*/); } - size_t i = 0; - for (auto &argument : call.get_arguments ()) + size_t i; + for (i = 0; i < call.get_arguments ().size (); i++) { + auto &argument = call.get_arguments ().at (i); + if (call.is_const_argument (i)) + continue; + location_t arg_locus = argument->get_locus (); TyTy::BaseType *param_ty = nullptr; @@ -204,6 +276,7 @@ TypeCheckCallExpr::visit (FnType &type) if (param_ty != nullptr) ctx->push_expected_type (param_ty); + auto argument_expr_tyty = Resolver::TypeCheckExpr::Resolve (*argument); if (param_ty != nullptr) ctx->pop_expected_type (); @@ -309,11 +382,9 @@ TypeCheckCallExpr::visit (FnType &type) break; } } - - i++; } - if (i < call.num_params ()) + if (i + indexes.size () < call.num_params ()) { emit_unexpected_argument_error (call.get_locus (), (unsigned long) i, (unsigned long) call.num_params ()); diff --git a/gcc/rust/typecheck/rust-tyty-subst.cc b/gcc/rust/typecheck/rust-tyty-subst.cc index 73e4479fe273..d589b25473d1 100644 --- a/gcc/rust/typecheck/rust-tyty-subst.cc +++ b/gcc/rust/typecheck/rust-tyty-subst.cc @@ -823,11 +823,6 @@ SubstitutionRef::get_mappings_from_generic_args ( for (auto &arg : args.get_const_args ()) { auto &expr = *arg.get_expression ().get (); - BaseType *expr_type = Resolver::TypeCheckExpr::Resolve (expr); - if (expr_type == nullptr || expr_type->is ()) - return SubstitutionArgumentMappings::error (); - - // validate this param is really a const generic const auto ¶m_mapping = substitutions.at (offs); const auto &generic = param_mapping.get_generic_param (); if (generic.get_kind () != HIR::GenericParam::GenericKind::CONST) @@ -838,73 +833,13 @@ SubstitutionRef::get_mappings_from_generic_args ( return SubstitutionArgumentMappings::error (); } - // get the const generic specified type - const auto base_generic = param_mapping.get_param_ty (); - rust_assert (base_generic->get_kind () == TyTy::TypeKind::CONST); - const auto const_param - = static_cast (base_generic); - auto specified_type = const_param->get_specified_type (); - - // validate this const generic is of the correct type - TyTy::BaseType *coereced_type = nullptr; - if (expr_type->get_kind () == TyTy::TypeKind::CONST) - { - auto const_expr_type = expr_type->as_const_type (); - auto const_value_type = const_expr_type->get_specified_type (); - coereced_type - = Resolver::coercion_site (expr.get_mappings ().get_hirid (), - TyTy::TyWithLocation (specified_type), - TyTy::TyWithLocation (const_value_type, - expr.get_locus ()), - arg.get_locus ()); - } - else - { - coereced_type - = Resolver::coercion_site (expr.get_mappings ().get_hirid (), - TyTy::TyWithLocation (specified_type), - TyTy::TyWithLocation (expr_type, - expr.get_locus ()), - arg.get_locus ()); - } - - if (coereced_type == nullptr || coereced_type->is ()) + auto specified_type = param_mapping.get_param_ty () + ->as_const_type () + ->get_specified_type (); + auto const_value_ty = resolve_const_argument (expr, specified_type); + if (const_value_ty->is ()) return SubstitutionArgumentMappings::error (); - TyTy::BaseType *const_value_ty = nullptr; - if (expr_type->get_kind () == TyTy::TypeKind::CONST) - const_value_ty = expr_type; - else - { - // const fold it if available - auto ctx = Compile::Context::get (); - tree folded - = Compile::HIRCompileBase::query_compile_const_expr (ctx, - coereced_type, - expr); - - if (folded == error_mark_node) - { - rich_location r (line_table, arg.get_locus ()); - r.add_range (expr.get_locus ()); - rust_error_at (r, "failed to resolve const expression"); - return SubstitutionArgumentMappings::error (); - } - - // Use a fresh HirId to avoid conflicts with the expr's type - auto &global_mappings = Analysis::Mappings::get (); - HirId const_value_id = global_mappings.get_next_hir_id (); - const_value_ty - = new TyTy::ConstValueType (folded, coereced_type, const_value_id, - const_value_id, {}); - - // Insert the ConstValueType into the context so it can be looked up - auto context = Resolver::TypeCheckContext::get (); - context->insert_type ( - Analysis::NodeMapping (0, 0, const_value_ty->get_ref (), 0), - const_value_ty); - } - mappings.emplace_back (¶m_mapping, const_value_ty); offs++; } @@ -950,6 +885,75 @@ SubstitutionRef::get_mappings_from_generic_args ( constraint_arguments}; } +BaseType * +SubstitutionRef::resolve_const_argument (HIR::Expr &expr, + BaseType *specified_type) +{ + BaseType *expr_type = Resolver::TypeCheckExpr::Resolve (expr); + if (expr_type == nullptr || expr_type->is ()) + return new ErrorType (expr.get_mappings ().get_hirid ()); + + TyTy::BaseType *coerced_type = nullptr; + if (expr_type->get_kind () == TyTy::TypeKind::CONST) + { + auto const_expr_type = expr_type->as_const_type (); + auto const_value_type = const_expr_type->get_specified_type (); + coerced_type + = Resolver::coercion_site (expr.get_mappings ().get_hirid (), + TyTy::TyWithLocation (specified_type), + TyTy::TyWithLocation (const_value_type, + expr.get_locus ()), + expr.get_locus ()); + } + else + { + coerced_type + = Resolver::coercion_site (expr.get_mappings ().get_hirid (), + TyTy::TyWithLocation (specified_type), + TyTy::TyWithLocation (expr_type, + expr.get_locus ()), + expr.get_locus ()); + } + + if (coerced_type == nullptr || coerced_type->is ()) + return new ErrorType (expr.get_mappings ().get_hirid ()); + + TyTy::BaseType *const_value_ty = nullptr; + if (expr_type->get_kind () == TyTy::TypeKind::CONST) + const_value_ty = expr_type; + else + { + auto ctx = Compile::Context::get (); + tree folded + = Compile::HIRCompileBase::query_compile_const_expr (ctx, coerced_type, + expr); + + if (folded == error_mark_node) + { + rich_location r (line_table, expr.get_locus ()); + r.add_range (expr.get_locus ()); + rust_error_at (r, "failed to resolve const expression"); + return new ErrorType (expr.get_mappings ().get_hirid ()); + } + + // Use a fresh HirId to avoid conflicts with the expr's type + auto &global_mappings = Analysis::Mappings::get (); + HirId const_value_id = global_mappings.get_next_hir_id (); + const_value_ty + = new TyTy::ConstValueType (folded, coerced_type, const_value_id, + const_value_id, {}); + + // Insert the ConstValueType into the context so it can be looked up + auto context = Resolver::TypeCheckContext::get (); + context->insert_type (Analysis::NodeMapping (0, 0, + const_value_ty->get_ref (), + 0), + const_value_ty); + } + + return const_value_ty; +} + BaseType * SubstitutionRef::infer_substitions (location_t locus) { diff --git a/gcc/rust/typecheck/rust-tyty-subst.h b/gcc/rust/typecheck/rust-tyty-subst.h index 623593b9acc5..bfe462b119d6 100644 --- a/gcc/rust/typecheck/rust-tyty-subst.h +++ b/gcc/rust/typecheck/rust-tyty-subst.h @@ -315,6 +315,9 @@ class SubstitutionRef get_mappings_from_generic_args (HIR::GenericArgs &args, const std::vector ®ions); + static BaseType *resolve_const_argument (HIR::Expr &expr, + BaseType *specified_type); + // Recursive substitutions // Foo { a:A, b: B}; Bar {a:X, b: Foo} // diff --git a/gcc/testsuite/rust/compile/issues/issue-3868.rs b/gcc/testsuite/rust/compile/issues/issue-3868.rs new file mode 100644 index 000000000000..7f8a9ce9c6b8 --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/issue-3868.rs @@ -0,0 +1,15 @@ +#![feature(no_core, intrinsics, lang_items, staged_api)] +#![feature(rustc_attrs)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +#[rustc_args_required_const(1)] +fn foo(x: i32) -> i32 { + x + N as i32 +} + +fn main() { + let _a = foo(10, 3); +} From 1f66f071b354b29d3bf17497192dd321f9a0e788 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 14 Sep 2026 21:46:29 +0100 Subject: [PATCH 547/584] gccrs: Add test-case to show ice fixed Fixes Rust-GCC/gccrs#4152 gcc/testsuite/ChangeLog: * rust/compile/issues/issue-4152.rs: New test. Signed-off-by: Philip Herron --- .../rust/compile/issues/issue-4152.rs | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) create mode 100644 gcc/testsuite/rust/compile/issues/issue-4152.rs diff --git a/gcc/testsuite/rust/compile/issues/issue-4152.rs b/gcc/testsuite/rust/compile/issues/issue-4152.rs new file mode 100644 index 000000000000..257fd55b8ca2 --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/issue-4152.rs @@ -0,0 +1,36 @@ +#![feature(no_core, lang_items)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +impl<'a> Thing for &'a u8 { + type Output = u8; + + fn calc(&mut self) -> u8 { + **self + } +} + +trait Thing { + type Output: 'static; + + fn calc(&mut self) -> Self::Output; +} + +impl<'a> Thing for &'a u8 { + type Output = u8; + + fn calc(&mut self) -> u8 { + **self + } +} + +fn get_thing(x: &u8) -> impl Thing + '_ { + x +} + +fn f(n: &u8) -> impl Thing + 'static { // { dg-error "bounds not satisfied for u8 .Thing. is not satisfied" } + let mut t = get_thing(n); + t.calc() +} From 721abf23e0154bed6551d338ddd871a448df1da7 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 14 Sep 2026 21:43:19 +0100 Subject: [PATCH 548/584] gccrs: Add testcase to show issue fixed Fixes Rust-GCC/gccrs#4675 gcc/testsuite/ChangeLog: * rust/compile/issues/issue-4675.rs: New test. Signed-off-by: Philip Herron --- .../rust/compile/issues/issue-4675.rs | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 gcc/testsuite/rust/compile/issues/issue-4675.rs diff --git a/gcc/testsuite/rust/compile/issues/issue-4675.rs b/gcc/testsuite/rust/compile/issues/issue-4675.rs new file mode 100644 index 000000000000..5f516f7f53c7 --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/issue-4675.rs @@ -0,0 +1,19 @@ +#![feature(no_core, lang_items)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +struct Two<'a> { // { dg-warning "struct is never constructed: .Two." } + f: &'a i32, + g: &'a i32, +} + +fn a() { // { dg-warning "function is never used: .a." } + let (mut t, f, g): (Two, i32, i32); + f = 42; + t = Two { f: &f, g: &f }; + *t.f; + f = 42; // { dg-error "assignment of read-only variable 'f'" } + t.g = &g; +} From fa44d5d00011551c7a9e4955bcef97ea724cc34a Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 14 Sep 2026 21:36:26 +0100 Subject: [PATCH 549/584] gccrs: Remove unnessecary diagnostics on array capacity values Fixes Rust-GCC/gccrs#4153 gcc/rust/ChangeLog: * typecheck/rust-hir-type-check-type.cc (TypeCheckType::visit): always update const type * typecheck/rust-unify.cc (UnifyRules::expect_array): emit_error=false gcc/testsuite/ChangeLog: * rust/compile/issues/4168.rs: remove dup/bad diagnostic * rust/compile/issues/issue-4153.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-type-check-type.cc | 5 +++-- gcc/rust/typecheck/rust-unify.cc | 5 ++++- gcc/testsuite/rust/compile/issues/4168.rs | 1 - gcc/testsuite/rust/compile/issues/issue-4153.rs | 15 +++++++++++++++ 4 files changed, 22 insertions(+), 4 deletions(-) create mode 100644 gcc/testsuite/rust/compile/issues/issue-4153.rs diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.cc b/gcc/rust/typecheck/rust-hir-type-check-type.cc index 5fe75cf487b8..c60d419e5422 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-type.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-type.cc @@ -734,9 +734,10 @@ TypeCheckType::visit (HIR::ArrayType &type) const_type = new TyTy::ConstValueType (capacity_expr, expected_ty, size_id, size_id); - context->insert_type (type.get_size_expr ().get_mappings (), - const_type->as_base_type ()); } + + context->insert_type (type.get_size_expr ().get_mappings (), + const_type->as_base_type ()); } translated diff --git a/gcc/rust/typecheck/rust-unify.cc b/gcc/rust/typecheck/rust-unify.cc index c8dee621452d..3d5454741201 100644 --- a/gcc/rust/typecheck/rust-unify.cc +++ b/gcc/rust/typecheck/rust-unify.cc @@ -987,7 +987,10 @@ UnifyRules::expect_array (TyTy::ArrayType *ltype, TyTy::BaseType *rtype) auto capacity_type_unify = capacity_unify->as_const_type (); if (capacity_type_unify->const_kind () == TyTy::BaseConstType::ConstKind::Error) - return unify_error_type_node (); + { + emit_error = false; + return unify_error_type_node (); + } return new TyTy::ArrayType ( type.get_ref (), type.get_ty_ref (), type.get_ident ().locus, diff --git a/gcc/testsuite/rust/compile/issues/4168.rs b/gcc/testsuite/rust/compile/issues/4168.rs index ad0d0420fe1e..7d01ec9f2784 100644 --- a/gcc/testsuite/rust/compile/issues/4168.rs +++ b/gcc/testsuite/rust/compile/issues/4168.rs @@ -7,4 +7,3 @@ const fn add(x: usize, y: usize) -> i32 { } const ARR: [i32; add(1, 2)] = [5, 6, 1]; // { dg-error "mismatched types, expected .usize. but got .i32. .E0308." "" { target *-*-* } .-1 } -// { dg-error "mismatched types" "" { target *-*-* } .-2 } diff --git a/gcc/testsuite/rust/compile/issues/issue-4153.rs b/gcc/testsuite/rust/compile/issues/issue-4153.rs new file mode 100644 index 000000000000..e79e6c328e61 --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/issue-4153.rs @@ -0,0 +1,15 @@ +#![feature(no_core, lang_items)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +fn is_123(x: [u32; N]) -> bool { // { dg-error "mismatched types, expected .usize. but got .fn \\(\\) -> \\(\\)." } + // { dg-error "capacity of array .* is not known at compile time" "" { target *-*-* } .-1 } + match x { + [1, 2] => true, + _ => false, + } +} + +fn N() {} From 9562038d7237fe7e4e84e4a9d573e08843c4f2ca Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 14 Sep 2026 21:21:07 +0100 Subject: [PATCH 550/584] gccrs: add null guard for failed builtin expansion Fixes Rust-GCC/gccrs#4477 gcc/rust/ChangeLog: * expand/rust-expand-visitor.cc (builtin_derive_item): check for null and remove Signed-off-by: Philip Herron --- gcc/rust/expand/rust-expand-visitor.cc | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/gcc/rust/expand/rust-expand-visitor.cc b/gcc/rust/expand/rust-expand-visitor.cc index 3a042ac9a9c3..e78f723053b3 100644 --- a/gcc/rust/expand/rust-expand-visitor.cc +++ b/gcc/rust/expand/rust-expand-visitor.cc @@ -49,13 +49,22 @@ static std::vector> builtin_derive_item (AST::Item &item, const AST::Attribute &derive, BuiltinMacro to_derive, MacroExpander &expander) { + auto &mappings = Analysis::Mappings::get (); auto item_source = AST::Builder::get_item_source (expander.crate); auto items = AST::DeriveVisitor::derive (item, derive, to_derive, item_source); - for (auto &item : items) - Analysis::Mappings::get ().add_derived_node (item->get_node_id ()); + for (auto it = items.begin (); it != items.end ();) + { + if (*it == nullptr) + it = items.erase (it); + else + { + mappings.add_derived_node ((*it)->get_node_id ()); + ++it; + } + } return items; } From 73ec9c4818410875f08033509e7d61cbd71b289d Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 14 Sep 2026 22:07:59 +0100 Subject: [PATCH 551/584] gccrs: Fix ICE in constexpr for unit-structs HIR Items were using undify but Stmt level items used coercions so this was inconsistent. Fixes Rust-GCC/gccrs#4668 gcc/rust/ChangeLog: * backend/rust-compile-resolve-path.cc: return a constructor for this ADT * backend/rust-constexpr.cc (adjust_temp_type): check for constructor * typecheck/rust-hir-type-check-item.cc (TypeCheckItem::visit): this is a coercion site gcc/testsuite/ChangeLog: * rust/compile/issues/2477.rs: remove old bad diag * rust/compile/issues/4165.rs: likewise * rust/compile/issues/issue-4668.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/backend/rust-compile-resolve-path.cc | 6 +++++- gcc/rust/backend/rust-constexpr.cc | 7 +++++++ gcc/rust/typecheck/rust-hir-type-check-item.cc | 2 +- gcc/testsuite/rust/compile/issues/2477.rs | 1 - gcc/testsuite/rust/compile/issues/4165.rs | 3 +-- .../rust/compile/issues/issue-4668.rs | 18 ++++++++++++++++++ 6 files changed, 32 insertions(+), 5 deletions(-) create mode 100644 gcc/testsuite/rust/compile/issues/issue-4668.rs diff --git a/gcc/rust/backend/rust-compile-resolve-path.cc b/gcc/rust/backend/rust-compile-resolve-path.cc index db984bee3393..12b200a11d9b 100644 --- a/gcc/rust/backend/rust-compile-resolve-path.cc +++ b/gcc/rust/backend/rust-compile-resolve-path.cc @@ -81,7 +81,11 @@ ResolvePathRef::attempt_constructor_expression_lookup ( TyTy::ADTType *adt = static_cast (lookup); if (adt->is_unit ()) - return unit_expression (expr_locus); + { + tree compiled_adt_type = TyTyResolveCompile::compile (ctx, adt); + return Backend::constructor_expression (compiled_adt_type, false, {}, -1, + expr_locus); + } if (!adt->is_enum ()) return error_mark_node; diff --git a/gcc/rust/backend/rust-constexpr.cc b/gcc/rust/backend/rust-constexpr.cc index 44fd235b925b..65a7c8c1773d 100644 --- a/gcc/rust/backend/rust-constexpr.cc +++ b/gcc/rust/backend/rust-constexpr.cc @@ -1584,6 +1584,13 @@ adjust_temp_type (tree type, tree temp) if (same_type_p (TREE_TYPE (temp), type)) return temp; + if (TREE_CODE (temp) == CONSTRUCTOR) + { + tree t = copy_node (temp); + TREE_TYPE (t) = type; + return t; + } + gcc_assert (scalarish_type_p (type)); /* Now we know we're dealing with a scalar, and a prvalue of non-class type is cv-unqualified. */ diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.cc b/gcc/rust/typecheck/rust-hir-type-check-item.cc index 4d02e3b5c52d..63f970dfe9e7 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-item.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-item.cc @@ -644,7 +644,7 @@ TypeCheckItem::visit (HIR::ConstantItem &constant) TyTy::BaseType *expr_type = TypeCheckExpr::Resolve (constant.get_expr ()); context->pop_const_context (); - TyTy::BaseType *unified = unify_site ( + TyTy::BaseType *unified = coercion_site ( constant.get_mappings ().get_hirid (), TyTy::TyWithLocation (type, constant.get_type ().get_locus ()), TyTy::TyWithLocation (expr_type, constant.get_expr ().get_locus ()), diff --git a/gcc/testsuite/rust/compile/issues/2477.rs b/gcc/testsuite/rust/compile/issues/2477.rs index 128278111563..4c95d8fee91b 100644 --- a/gcc/testsuite/rust/compile/issues/2477.rs +++ b/gcc/testsuite/rust/compile/issues/2477.rs @@ -3,4 +3,3 @@ const FOO: u32 = return 0; // { dg-error "return statement outside of function body" "" { target *-*-* } .-1 } -// { dg-error "mismatched types, expected .u32. but got" "" { target *-*-* } .-2 } diff --git a/gcc/testsuite/rust/compile/issues/4165.rs b/gcc/testsuite/rust/compile/issues/4165.rs index a30e3ff1b310..673c44702e2d 100644 --- a/gcc/testsuite/rust/compile/issues/4165.rs +++ b/gcc/testsuite/rust/compile/issues/4165.rs @@ -4,8 +4,7 @@ const N: usize = 2; const ARR: [i32; N] = [42; X]; // { dg-error {cannot find value .X. in this scope \[E0425\]} "" { target *-*-* } .-1 } -// { dg-error {mismatched types, expected .\[i32; 2]. but got .. \[E0308\]} "" { target *-*-* } .-2 } -// { dg-error {mismatched types, expected .usize. but got .bool. \[E0308\]} "" { target *-*-* } .-3 } +// { dg-error {mismatched types, expected .usize. but got .bool. \[E0308\]} "" { target *-*-* } .-2 } const X: bool = (N[0] == 99) && (ARR[0] == 0); // { dg-error {the type .usize. cannot be indexed by .. \[E0277\]} "" { target *-*-* } .-1 } // { dg-error {mismatched types, expected .. but got .. \[E0308\]} "" { target *-*-* } .-2 } diff --git a/gcc/testsuite/rust/compile/issues/issue-4668.rs b/gcc/testsuite/rust/compile/issues/issue-4668.rs new file mode 100644 index 000000000000..4f64bbbb0220 --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/issue-4668.rs @@ -0,0 +1,18 @@ +#![feature(no_core, lang_items)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +struct Dummy; // { dg-warning "struct is never constructed" } + +impl Dummy { + const fn func(self) -> usize { // { dg-warning "associated function is never used" } + 42 + } +} + +const _: &[usize] = &[0; { + const DUMMY: &Dummy = &Dummy; + DUMMY.func() +}]; From b7e07dc7075bcae122a5286bdd2713a982770612 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Tue, 15 Sep 2026 12:02:11 +0100 Subject: [PATCH 552/584] gccrs: handle lifetimes properly on trait items The patch here means we keep a fresh lifetime scope when resolving each trait item when generics are used. Fixes Rust-GCC/gccrs#4885 gcc/rust/ChangeLog: * typecheck/rust-hir-trait-resolve.cc (TraitItemReference::resolve_item): track lifetimes gcc/testsuite/ChangeLog: * rust/compile/issues/issue-4885.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-trait-resolve.cc | 14 +++++- .../rust/compile/issues/issue-4885.rs | 43 +++++++++++++++++++ 2 files changed, 56 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/rust/compile/issues/issue-4885.rs diff --git a/gcc/rust/typecheck/rust-hir-trait-resolve.cc b/gcc/rust/typecheck/rust-hir-trait-resolve.cc index 502d0e8f7d8d..c80899979c23 100644 --- a/gcc/rust/typecheck/rust-hir-trait-resolve.cc +++ b/gcc/rust/typecheck/rust-hir-trait-resolve.cc @@ -472,10 +472,22 @@ void TraitItemReference::resolve_item (const TraitReference *tref, HIR::TraitItemType &type) { + auto lifetime_pin = context->push_clean_lifetime_resolver (); + for (auto ¶m : tref->get_hir_trait_ref ()->get_generic_params ()) + { + if (param->get_kind () == HIR::GenericParam::GenericKind::LIFETIME) + { + auto &lifetime_param = static_cast (*param); + context->intern_and_insert_lifetime (lifetime_param.get_lifetime ()); + } + } + auto substitutions = inherited_substitutions; + tl::optional binder_pin; if (type.has_generics ()) { - auto binder_pin = context->push_lifetime_binder (); + binder_pin.emplace (*context, + TypeCheckContext::LifetimeResolverGuard::BINDER); TypeCheckBase::ResolveGenericParams (HIR::Item::ItemKind::TypeAlias, type.get_locus (), type.get_generic_params (), diff --git a/gcc/testsuite/rust/compile/issues/issue-4885.rs b/gcc/testsuite/rust/compile/issues/issue-4885.rs new file mode 100644 index 000000000000..b02bc60a9544 --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/issue-4885.rs @@ -0,0 +1,43 @@ +// { dg-do compile } +// { dg-options "-w" } + +#![feature(no_core, lang_items)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +pub unsafe trait Searcher<'a> { + fn haystack(&self) -> &'a (); +} + +pub trait Pattern<'a>: Sized { + type Searcher: Searcher<'a>; +} + +pub trait MultiCharEq {} + +struct MultiCharEqPattern(C); + +struct MultiCharEqSearcher<'a, C: MultiCharEq> { + marker: &'a (), + c: C, +} + +impl<'a, C: MultiCharEq> Pattern<'a> for MultiCharEqPattern { + type Searcher = MultiCharEqSearcher<'a, C>; +} + +unsafe impl<'a, C: MultiCharEq> Searcher<'a> for MultiCharEqSearcher<'a, C> { + fn haystack(&self) -> &'a () { + self.marker + } +} + +impl<'x> MultiCharEq for &'x [i32] {} + +pub struct CharSliceSearcher<'a, 'b>( as Pattern<'a>>::Searcher); + +fn main() -> i32 { + 0 +} From 10ce06425f1a64d4c1ad96475bc08751417158f0 Mon Sep 17 00:00:00 2001 From: Owen Avery Date: Tue, 15 Sep 2026 20:25:46 -0400 Subject: [PATCH 553/584] gccrs: nr1.0: Remove old Scope class gcc/rust/ChangeLog: * resolve/rust-name-resolver.cc (Scope::Scope): Remove function definition. (Scope::insert): Likewise. (Scope::lookup): Likewise. (Scope::lookup_decl_type): Likewise. (Scope::lookup_rib_for_decl): Likewise. (Scope::iterate): Likewise. (Scope::peek): Likewise. (Scope::push): Likewise. (Scope::pop): Likewise. (Scope::append_reference_for_def): Likewise. (Scope::decl_was_declared_here): Likewise. * resolve/rust-name-resolver.h (class Scope): Remove. Signed-off-by: Owen Avery --- gcc/rust/resolve/rust-name-resolver.cc | 137 ------------------------- gcc/rust/resolve/rust-name-resolver.h | 35 ------- 2 files changed, 172 deletions(-) diff --git a/gcc/rust/resolve/rust-name-resolver.cc b/gcc/rust/resolve/rust-name-resolver.cc index ab6fcb839ef9..a695ab1922cf 100644 --- a/gcc/rust/resolve/rust-name-resolver.cc +++ b/gcc/rust/resolve/rust-name-resolver.cc @@ -135,143 +135,6 @@ Rib::debug_str () const return "{" + buffer + "}"; } -Scope::Scope (CrateNum crate_num) : crate_num (crate_num) {} - -void -Scope::insert ( - const CanonicalPath &ident, NodeId id, location_t locus, bool shadow, - Rib::ItemType type, - std::function dup_cb) -{ - peek ()->insert_name (ident, id, locus, shadow, type, dup_cb); -} - -void -Scope::insert (const CanonicalPath &ident, NodeId id, location_t locus, - Rib::ItemType type) -{ - peek ()->insert_name (ident, id, locus, true, type, - [] (const CanonicalPath &, NodeId, location_t) -> void { - }); -} - -bool -Scope::lookup (const CanonicalPath &ident, NodeId *id) -{ - NodeId lookup = UNKNOWN_NODEID; - iterate ([&] (Rib *r) mutable -> bool { - if (r->lookup_name (ident, &lookup)) - return false; - return true; - }); - - *id = lookup; - return lookup != UNKNOWN_NODEID; -} - -bool -Scope::lookup_decl_type (NodeId id, Rib::ItemType *type) -{ - bool found = false; - iterate ([&] (const Rib *r) -> bool { - if (r->decl_was_declared_here (id)) - { - bool ok = r->lookup_decl_type (id, type); - rust_assert (ok); - found = true; - return false; - } - return true; - }); - return found; -} - -bool -Scope::lookup_rib_for_decl (NodeId id, const Rib **rib) -{ - bool found = false; - iterate ([&] (const Rib *r) -> bool { - if (r->decl_was_declared_here (id)) - { - *rib = r; - found = true; - return false; - } - return true; - }); - return found; -} - -void -Scope::iterate (std::function cb) -{ - for (auto it = stack.rbegin (); it != stack.rend (); ++it) - { - if (!cb (*it)) - return; - } -} - -void -Scope::iterate (std::function cb) const -{ - for (auto it = stack.rbegin (); it != stack.rend (); ++it) - { - if (!cb (*it)) - return; - } -} - -Rib * -Scope::peek () -{ - return stack.back (); -} - -void -Scope::push (NodeId id) -{ - stack.push_back (new Rib (get_crate_num (), id)); -} - -Rib * -Scope::pop () -{ - Rib *r = peek (); - stack.pop_back (); - return r; -} - -void -Scope::append_reference_for_def (NodeId refId, NodeId defId) -{ - bool ok = false; - iterate ([&] (Rib *r) mutable -> bool { - if (r->decl_was_declared_here (defId)) - { - ok = true; - r->append_reference_for_def (defId, refId); - } - return true; - }); - rust_assert (ok); -} - -bool -Scope::decl_was_declared_here (NodeId def) const -{ - bool found = false; - iterate ([&] (const Rib *r) -> bool { - if (r->decl_was_declared_here (def)) - { - found = true; - return false; - } - return true; - }); - return found; -} - Resolver::Resolver () {} Resolver * diff --git a/gcc/rust/resolve/rust-name-resolver.h b/gcc/rust/resolve/rust-name-resolver.h index 6648959d62f3..a7cbb14836f3 100644 --- a/gcc/rust/resolve/rust-name-resolver.h +++ b/gcc/rust/resolve/rust-name-resolver.h @@ -83,41 +83,6 @@ class Rib std::map decl_type_mappings; }; -class Scope -{ -public: - Scope (CrateNum crate_num); - - void insert ( - const CanonicalPath &ident, NodeId id, location_t locus, bool shadow, - Rib::ItemType type, - std::function dup_cb); - - void insert (const CanonicalPath &ident, NodeId id, location_t locus, - Rib::ItemType type = Rib::ItemType::Unknown); - bool lookup (const CanonicalPath &ident, NodeId *id); - bool lookup_decl_type (NodeId id, Rib::ItemType *type); - bool lookup_rib_for_decl (NodeId id, const Rib **rib); - - void iterate (std::function cb); - void iterate (std::function cb) const; - - Rib *peek (); - void push (NodeId id); - Rib *pop (); - - bool decl_was_declared_here (NodeId def) const; - void append_reference_for_def (NodeId refId, NodeId defId); - - CrateNum get_crate_num () const { return crate_num; } - - const std::vector &get_context () const { return stack; }; - -private: - CrateNum crate_num; - std::vector stack; -}; - class Resolver { public: From 86e331339b2b7034650a3bb85c74499d6137e4a8 Mon Sep 17 00:00:00 2001 From: Arthur Cohen Date: Wed, 16 Sep 2026 18:01:45 +0200 Subject: [PATCH 554/584] nr2.0: Close out invalid resolution for unexported items Fixes Rust-GCC/gccrs#2259. This adds a testcase to make sure a regression isn't introduced later on. gcc/testsuite/ChangeLog: * rust/compile/issues/2259.rs: New test. --- gcc/testsuite/rust/compile/issues/2259.rs | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 gcc/testsuite/rust/compile/issues/2259.rs diff --git a/gcc/testsuite/rust/compile/issues/2259.rs b/gcc/testsuite/rust/compile/issues/2259.rs new file mode 100644 index 000000000000..2530b4a24eac --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/2259.rs @@ -0,0 +1,18 @@ +#![feature(no_core)] +#![no_core] + +pub mod foo { + pub fn bar() {} + + #[macro_export] + macro_rules! qux { + () => {}; + } +} + +// is valid if this is uncommented +// use foo::*; + +fn main() { + bar(); // { dg-error "Cannot find path .bar. in this scope" } +} From 27ef3cd9e515078618cfc117aeaa7dfde8d2df96 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Thu, 17 Sep 2026 17:24:08 +0100 Subject: [PATCH 555/584] gccrs: Fix unconstrained when args are in the where clause Fixes Rust-GCC/gccrs#4883 gcc/rust/ChangeLog: * typecheck/rust-hir-type-check-base.cc (walk_type_to_constrain): walk the generics as well gcc/testsuite/ChangeLog: * rust/compile/issues/issue-4883.rs: New test. Signed-off-by: Philip Herron --- .../typecheck/rust-hir-type-check-base.cc | 4 ++ .../rust/compile/issues/issue-4883.rs | 46 +++++++++++++++++++ 2 files changed, 50 insertions(+) create mode 100644 gcc/testsuite/rust/compile/issues/issue-4883.rs diff --git a/gcc/rust/typecheck/rust-hir-type-check-base.cc b/gcc/rust/typecheck/rust-hir-type-check-base.cc index c9e392039a3c..52a3536245a1 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-base.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-base.cc @@ -166,6 +166,10 @@ walk_type_to_constrain (std::set &constrained_symbols, TyTy::BaseType &r) default: break; } + + if (r.has_substitutions_defined ()) + walk_types_to_constrain (constrained_symbols, + r.get_subst_argument_mappings ()); } bool diff --git a/gcc/testsuite/rust/compile/issues/issue-4883.rs b/gcc/testsuite/rust/compile/issues/issue-4883.rs new file mode 100644 index 000000000000..560290c64653 --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/issue-4883.rs @@ -0,0 +1,46 @@ +// { dg-options "-w" } +#![feature(no_core, lang_items, unboxed_closures)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +pub trait Iterator2 { + type Item; +} + +#[lang = "fn_once"] +#[rustc_paren_sugar] +pub trait FnOnce { + #[lang = "fn_once_output"] + type Output; + + extern "rust-call" fn call_once(self, args: Args) -> Self::Output; +} + +#[lang = "fn_mut"] +#[rustc_paren_sugar] +pub trait FnMut: FnOnce { + extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output; +} + +pub struct FilterMap { + iter: I, + f: F, +} + +impl Iterator2 for FilterMap +where + F: FnMut(I::Item) -> Option, +{ + type Item = B; +} + +pub enum Option { + None, + Some(T), +} + +fn main() -> i32 { + 0 +} From 58e8efb9260feaf9cb26372da43d3929d42eea56 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Sun, 30 Aug 2026 21:59:42 +0100 Subject: [PATCH 556/584] gccrs: Recursive types support This patch implements recusive ADT's support the basic principle is that during typecheck like for each type check item we register the ADTType with an empty set of variants so that when we process each variants field types we can allow them to resolve to the root ADT in place which will get updated as variants are added. Then we need a bunch of recusion guards for the general mechanics of how we do things like is_concrete etc. We also need the new ActiveADT's guard to track any recusion during unify. The akward bit was during code-gen we need to make sure to do a similar thing with GCC using make_node so any recusive nodes get caught by the recusion guard and then we can walk the variants and fill them in when its fully layed out. Fixes Rust-GCC/gccrs#1178 Fixes Rust-GCC/gccrs#2757 Fixes Rust-GCC/gccrs#4709 gcc/rust/ChangeLog: * backend/rust-compile-context.cc (Context::type_hasher): track active adt's * backend/rust-compile-context.h: likewise * backend/rust-compile-type.cc (type_reaches_adt): likewise (is_recursive_adt): new helper (TyTyResolveCompile::compile): check for active adt (TyTyResolveCompile::visit): setup placeholder node then layout * rust-session-manager.cc (Session::compile_crate): saw errors early return * typecheck/rust-hir-type-check-item.cc (validate_adt_size): new helper (TypeCheckItem::visit): setup type node then add variants * typecheck/rust-hir-type-check-type.cc (TypeCheckType::visit): check for incomplete * typecheck/rust-hir-type-check.h: new helpers * typecheck/rust-typecheck-context.cc (make_adt_substitution_key): likewise * typecheck/rust-tyty.cc (BaseType::monomorphized_clone): early return (BaseType::contains_infer): track visited for recursive safety (BaseType::is_concrete): likewise (ADTType::is_equal): likewise (ADTType::handle_substitions): likewise (FnPtr::as_string): likewise (PointerType::as_string): likewise * typecheck/rust-tyty.h: recusision safety * typecheck/rust-unify.cc (UnifyRules::UnifyRules): new ActiveADT's guard (UnifyRules::Resolve): likewise (UnifyRules::resolve_subtype): likewise (UnifyRules::expect_adt): likewise * typecheck/rust-unify.h: likewise gcc/testsuite/ChangeLog: * rust/compile/issues/issue-1178.rs: New test. * rust/compile/issues/issue-2757.rs: New test. * rust/compile/issues/issue-4709.rs: New test. * rust/compile/recursive-types-infinite.rs: New test. * rust/compile/recursive-types-mismatch.rs: New test. * rust/compile/recusive-types-1.rs: New test. * rust/compile/recusive-types-2.rs: New test. * rust/compile/recusive-types-3.rs: New test. * rust/compile/recusive-types-4.rs: New test. * rust/compile/recusive-types-5.rs: New test. * rust/compile/recusive-types-6.rs: New test. * rust/compile/recusive-types-7.rs: New test. * rust/execute/recursive-types-fnptr.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/backend/rust-compile-context.cc | 21 +- gcc/rust/backend/rust-compile-context.h | 34 ++ gcc/rust/backend/rust-compile-type.cc | 144 +++++++- gcc/rust/rust-session-manager.cc | 3 + .../typecheck/rust-hir-type-check-item.cc | 318 ++++++++++++------ .../typecheck/rust-hir-type-check-type.cc | 13 +- gcc/rust/typecheck/rust-hir-type-check.h | 11 + gcc/rust/typecheck/rust-typecheck-context.cc | 37 ++ gcc/rust/typecheck/rust-tyty.cc | 118 ++++--- gcc/rust/typecheck/rust-tyty.h | 4 + gcc/rust/typecheck/rust-unify.cc | 25 +- gcc/rust/typecheck/rust-unify.h | 49 ++- .../rust/compile/issues/issue-1178.rs | 8 + .../rust/compile/issues/issue-2757.rs | 7 + .../rust/compile/issues/issue-4709.rs | 8 + .../rust/compile/recursive-types-infinite.rs | 14 + .../rust/compile/recursive-types-mismatch.rs | 20 ++ .../rust/compile/recusive-types-1.rs | 23 ++ .../rust/compile/recusive-types-2.rs | 16 + .../rust/compile/recusive-types-3.rs | 12 + .../rust/compile/recusive-types-4.rs | 16 + .../rust/compile/recusive-types-5.rs | 17 + .../rust/compile/recusive-types-6.rs | 26 ++ .../rust/compile/recusive-types-7.rs | 10 + .../rust/execute/recursive-types-fnptr.rs | 14 + 25 files changed, 801 insertions(+), 167 deletions(-) create mode 100644 gcc/testsuite/rust/compile/issues/issue-1178.rs create mode 100644 gcc/testsuite/rust/compile/issues/issue-2757.rs create mode 100644 gcc/testsuite/rust/compile/issues/issue-4709.rs create mode 100644 gcc/testsuite/rust/compile/recursive-types-infinite.rs create mode 100644 gcc/testsuite/rust/compile/recursive-types-mismatch.rs create mode 100644 gcc/testsuite/rust/compile/recusive-types-1.rs create mode 100644 gcc/testsuite/rust/compile/recusive-types-2.rs create mode 100644 gcc/testsuite/rust/compile/recusive-types-3.rs create mode 100644 gcc/testsuite/rust/compile/recusive-types-4.rs create mode 100644 gcc/testsuite/rust/compile/recusive-types-5.rs create mode 100644 gcc/testsuite/rust/compile/recusive-types-6.rs create mode 100644 gcc/testsuite/rust/compile/recusive-types-7.rs create mode 100644 gcc/testsuite/rust/execute/recursive-types-fnptr.rs diff --git a/gcc/rust/backend/rust-compile-context.cc b/gcc/rust/backend/rust-compile-context.cc index 0ae57de4ce9b..fe28a478c817 100644 --- a/gcc/rust/backend/rust-compile-context.cc +++ b/gcc/rust/backend/rust-compile-context.cc @@ -48,6 +48,13 @@ Context::setup_builtins () hashval_t Context::type_hasher (tree type) +{ + hash_set active_types; + return type_hasher (type, active_types); +} + +hashval_t +Context::type_hasher (tree type, hash_set &active_types) { inchash::hash hstate; @@ -64,6 +71,15 @@ Context::type_hasher (tree type) /* Just the identifier is adequate to distinguish. */ hstate.add_object (IDENTIFIER_HASH_VALUE (TREE_PURPOSE (t))); + /* recursive guard */ + bool found = active_types.contains (type); + if (found) + { + hstate.add_int (TYPE_UID (TYPE_MAIN_VARIANT (type))); + return hstate.end (); + } + active_types.add (type); + switch (TREE_CODE (type)) { case METHOD_TYPE: @@ -120,7 +136,7 @@ Context::type_hasher (tree type) for (tree t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t)) { hashval_t name_hash = IDENTIFIER_HASH_VALUE (DECL_NAME (t)); - hashval_t type_hash = type_hasher (TREE_TYPE (t)); + hashval_t type_hash = type_hasher (TREE_TYPE (t), active_types); hstate.add_object (name_hash); hstate.add_object (type_hash); } @@ -133,7 +149,7 @@ Context::type_hasher (tree type) case REFERENCE_TYPE: case POINTER_TYPE: { - hashval_t type_hash = type_hasher (TREE_TYPE (type)); + hashval_t type_hash = type_hasher (TREE_TYPE (type), active_types); hstate.add_object (type_hash); } break; @@ -142,6 +158,7 @@ Context::type_hasher (tree type) break; } + active_types.remove (type); return hstate.end (); } diff --git a/gcc/rust/backend/rust-compile-context.h b/gcc/rust/backend/rust-compile-context.h index d3d4ec744929..dba6791a30e3 100644 --- a/gcc/rust/backend/rust-compile-context.h +++ b/gcc/rust/backend/rust-compile-context.h @@ -87,6 +87,28 @@ class Context return type; } + bool lookup_compiled_adt (const TyTy::ADTType &adt, tree *type) const + { + auto it = compiled_adt_types.find (compiled_adt_key (adt)); + if (it == compiled_adt_types.end ()) + return false; + + *type = it->second; + return true; + } + + void insert_compiled_adt (const TyTy::ADTType &adt, tree type) + { + auto key = compiled_adt_key (adt); + rust_assert (compiled_adt_types.find (key) == compiled_adt_types.end ()); + compiled_adt_types.insert ({key, type}); + } + + void erase_compiled_adt (const TyTy::ADTType &adt) + { + rust_assert (compiled_adt_types.erase (compiled_adt_key (adt)) == 1); + } + tree insert_main_variant (tree type) { hashval_t h = type_hasher (type); @@ -478,6 +500,8 @@ class Context friend class DropBuilder; Context (); + static hashval_t type_hasher (tree type, hash_set &active_types); + tree pop_block_impl (tree cleanup, location_t cleanup_locus) { auto block = scope_stack.back (); @@ -512,6 +536,15 @@ class Context return block; } + // we cant just use DefId because we can setup Adt vs Adt so the + // tyref gets us the uniqueness we need + static std::pair compiled_adt_key (const TyTy::ADTType &adt) + { + HirId substitution + = adt.has_substitutions_defined () ? adt.get_ty_ref () : UNKNOWN_HIRID; + return {adt.get_id (), substitution}; + } + Resolver::TypeCheckContext *tyctx; Analysis::Mappings &mappings; Mangler mangler; @@ -521,6 +554,7 @@ class Context std::map compiled_var_decls; std::map, ::Bvariable *> drop_flags; std::map compiled_type_map; + std::map, tree> compiled_adt_types; std::map compiled_fn_map; std::map compiled_consts; std::map compiled_labels; diff --git a/gcc/rust/backend/rust-compile-type.cc b/gcc/rust/backend/rust-compile-type.cc index 4b39a44f11cf..126705c5ddfb 100644 --- a/gcc/rust/backend/rust-compile-type.cc +++ b/gcc/rust/backend/rust-compile-type.cc @@ -17,8 +17,6 @@ // . #include "rust-compile-type.h" -#include "rust-constexpr.h" -#include "rust-compile-base.h" #include "rust-type-util.h" #include "rust-tyty.h" @@ -31,6 +29,90 @@ namespace Compile { static const std::string RUST_ENUM_DISR_FIELD_NAME = "RUST$ENUM$DISR"; +static bool +type_reaches_adt (TyTy::BaseType *type, DefId target, bool indirect, + std::set> &visited) +{ + type = type->destructure (); + switch (type->get_kind ()) + { + case TyTy::TypeKind::POINTER: + return type_reaches_adt ( + static_cast (type)->get_base (), target, true, + visited); + + case TyTy::TypeKind::REF: + return type_reaches_adt ( + static_cast (type)->get_base (), target, true, + visited); + + case TyTy::TypeKind::TUPLE: + { + auto *tuple = static_cast (type); + for (size_t i = 0; i < tuple->num_fields (); i++) + { + if (type_reaches_adt (tuple->get_field (i), target, indirect, + visited)) + return true; + } + return false; + } + + case TyTy::TypeKind::ARRAY: + return type_reaches_adt ( + static_cast (type)->get_element_type (), target, + indirect, visited); + + case TyTy::TypeKind::FNPTR: + { + auto *fn = static_cast (type); + for (const auto ¶m : fn->get_params ()) + { + if (type_reaches_adt (param.get_tyty (), target, true, visited)) + return true; + } + + return type_reaches_adt (fn->get_return_type (), target, true, visited); + } + + case TyTy::TypeKind::ADT: + break; + + default: + return false; + } + + auto *adt = static_cast (type); + if (adt->get_id () == target && indirect) + return true; + + auto key = std::make_pair (adt->get_id (), indirect); + bool found = visited.find (key) != visited.end (); + if (found) + return false; + visited.insert (key); + + for (auto *variant : adt->get_variants ()) + { + for (auto *field : variant->get_fields ()) + { + if (type_reaches_adt (field->get_field_type (), target, indirect, + visited)) + return true; + } + } + + return false; +} + +static bool +is_recursive_adt (const TyTy::ADTType &type) +{ + std::set> visited; + return type_reaches_adt (const_cast (&type), type.get_id (), + false, visited); +} + TyTyResolveCompile::TyTyResolveCompile (Context *ctx, bool trait_object_mode) : ctx (ctx), trait_object_mode (trait_object_mode), translated (error_mark_node) @@ -42,6 +124,14 @@ TyTyResolveCompile::compile (Context *ctx, const TyTy::BaseType *ty, { TyTyResolveCompile compiler (ctx, trait_object_mode); const TyTy::BaseType *destructured = ty->destructure (); + + if (const auto *adt = destructured->try_as ()) + { + tree compiled_adt = NULL_TREE; + if (ctx->lookup_compiled_adt (*adt, &compiled_adt)) + return compiled_adt; + } + destructured->accept_vis (compiler); if (compiler.translated != error_mark_node @@ -297,6 +387,24 @@ TyTyResolveCompile::visit (const TyTy::ADTType &type) tree type_record = error_mark_node; TyTy::ADTType::ReprOptions repr = type.get_repr_options (); + bool cached_incomplete_record = false; + + if (is_recursive_adt (type) + && repr.repr_kind != TyTy::ADTType::ReprKind::TRANSPARENT + && repr.repr_kind != TyTy::ADTType::ReprKind::SIMD) + { + tree aggregate = make_node (type.is_union () ? UNION_TYPE : RECORD_TYPE); + std::string name + = type.get_ident ().path.get () + type.subst_as_string (); + + tree decl = build_decl (type.get_ident ().locus, TYPE_DECL, + Backend::get_identifier_node (name), aggregate); + TYPE_NAME (aggregate) = decl; + type_record = aggregate; + ctx->insert_compiled_adt (type, type_record); + cached_incomplete_record = true; + } + if (repr.repr_kind == TyTy::ADTType::ReprKind::TRANSPARENT) { rust_assert (type.number_of_variants () == 1); @@ -400,8 +508,11 @@ TyTyResolveCompile::visit (const TyTy::ADTType &type) type.get_locus ()); } } - type_record = type.is_union () ? Backend::union_type (fields, false) - : Backend::struct_type (fields, false); + if (cached_incomplete_record) + type_record = Backend::fill_in_fields (type_record, fields, false); + else + type_record = type.is_union () ? Backend::union_type (fields, false) + : Backend::struct_type (fields, false); } else { @@ -523,7 +634,10 @@ TyTyResolveCompile::visit (const TyTy::ADTType &type) std::vector fields = {discrim, variants_union_field}; - type_record = Backend::struct_type (fields, false); + if (cached_incomplete_record) + type_record = Backend::fill_in_fields (type_record, fields, false); + else + type_record = Backend::struct_type (fields, false); } // Handle repr options @@ -549,10 +663,22 @@ TyTyResolveCompile::visit (const TyTy::ADTType &type) layout_type (type_record); } - std::string named_struct_str - = type.get_ident ().path.get () + type.subst_as_string (); - translated = Backend::named_type (named_struct_str, type_record, - type.get_ident ().locus); + if (cached_incomplete_record) + { + // see gcc/c/c-decl.cc this sets up any incomplete variants of the tree + for (tree variant = TYPE_NEXT_VARIANT (type_record); variant != NULL_TREE; + variant = TYPE_NEXT_VARIANT (variant)) + TYPE_FIELDS (variant) = TYPE_FIELDS (type_record); + + translated = type_record; + } + else + { + std::string named_struct_str + = type.get_ident ().path.get () + type.subst_as_string (); + translated = Backend::named_type (named_struct_str, type_record, + type.get_ident ().locus); + } } void diff --git a/gcc/rust/rust-session-manager.cc b/gcc/rust/rust-session-manager.cc index 45fe3ede70cc..4f4f8d411d83 100644 --- a/gcc/rust/rust-session-manager.cc +++ b/gcc/rust/rust-session-manager.cc @@ -809,6 +809,9 @@ Session::compile_crate (const char *filename) Compile::Context *ctx = Compile::Context::get (); Resolver::TypeResolution::Resolve (hir); + if (saw_errors ()) + return; + Resolver::TypeCheckContext::get ()->get_variance_analysis_ctx ().solve (); if (saw_errors ()) diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.cc b/gcc/rust/typecheck/rust-hir-type-check-item.cc index 63f970dfe9e7..5f54c0726fa4 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-item.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-item.cc @@ -43,6 +43,87 @@ namespace Rust { namespace Resolver { +static bool +type_contains_adt_without_indirection ( + const TyTy::BaseType *type, DefId target, + std::set &visited) +{ + bool found = visited.find (type) != visited.end (); + if (found) + return false; + visited.insert (type); + + switch (type->get_kind ()) + { + case TyTy::TypeKind::ADT: + { + auto *adt = static_cast (type); + if (adt->get_id () == target) + return true; + + for (auto *variant : adt->get_variants ()) + { + for (auto *field : variant->get_fields ()) + { + if (type_contains_adt_without_indirection ( + field->get_field_type (), target, visited)) + return true; + } + } + + return false; + } + + case TyTy::TypeKind::TUPLE: + { + auto *tuple = static_cast (type); + for (const auto &field : tuple->get_fields ()) + { + if (type_contains_adt_without_indirection (field.get_tyty (), + target, visited)) + return true; + } + + return false; + } + + case TyTy::TypeKind::ARRAY: + return type_contains_adt_without_indirection ( + static_cast (type)->get_element_type (), + target, visited); + + case TyTy::TypeKind::SLICE: + return type_contains_adt_without_indirection ( + static_cast (type)->get_element_type (), + target, visited); + + default: + return false; + } +} + +static bool +validate_adt_size (TyTy::ADTType *type) +{ + for (auto *variant : type->get_variants ()) + { + for (auto *field : variant->get_fields ()) + { + std::set visited; + if (!type_contains_adt_without_indirection (field->get_field_type (), + type->get_id (), visited)) + continue; + + rust_error_at (field->get_locus (), ErrorCode::E0072, + "recursive type %qs has infinite size", + type->get_identifier ().c_str ()); + return false; + } + } + + return true; +} + // Const-evaluate the discriminants of a repr(C) enum and warn when a value does // not fit into a C int/unsigned int. Done here, during type resolution, using // the compile context (a singleton shared with the backend). @@ -335,6 +416,25 @@ TypeCheckItem::visit (HIR::TupleStruct &struct_decl) TyTy::ADTType::ReprOptions repr = parse_repr_options (attrs, struct_decl.get_locus ()); + auto &nr_ctx = Resolver2_0::FinalizedNameResolutionContext::get (); + CanonicalPath path + = nr_ctx.to_canonical_path (struct_decl.get_mappings ().get_nodeid (), + Resolver2_0::Namespace::Types); + RustIdent ident{path, struct_decl.get_locus ()}; + + std::vector variants; + auto *type = new TyTy::ADTType ( + struct_decl.get_mappings ().get_defid (), + struct_decl.get_mappings ().get_hirid (), + struct_decl.get_mappings ().get_hirid (), + struct_decl.get_identifier ().as_string (), ident, + TyTy::ADTType::ADTKind::TUPLE_STRUCT, std::move (variants), + std::move (substitutions), repr, + TyTy::SubstitutionArgumentMappings::empty ( + context->get_lifetime_resolver ().get_num_bound_regions ()), + region_constraints); + context->insert_type (struct_decl.get_mappings (), type); + std::vector fields; size_t idx = 0; for (auto &field : struct_decl.get_fields ()) @@ -357,37 +457,20 @@ TypeCheckItem::visit (HIR::TupleStruct &struct_decl) return; } - // get the path - - auto &nr_ctx = Resolver2_0::FinalizedNameResolutionContext::get (); - - CanonicalPath path - = nr_ctx.to_canonical_path (struct_decl.get_mappings ().get_nodeid (), - Resolver2_0::Namespace::Types); - - RustIdent ident{path, struct_decl.get_locus ()}; - // its a single variant ADT - std::vector variants; - variants.push_back ( - new TyTy::VariantDef (struct_decl.get_mappings ().get_hirid (), - struct_decl.get_mappings ().get_defid (), - struct_decl.get_identifier ().as_string (), ident, - TyTy::VariantDef::VariantType::TUPLE, tl::nullopt, - std::move (fields))); - - auto *type = new TyTy::ADTType ( - struct_decl.get_mappings ().get_defid (), - struct_decl.get_mappings ().get_hirid (), - struct_decl.get_mappings ().get_hirid (), - struct_decl.get_identifier ().as_string (), ident, - TyTy::ADTType::ADTKind::TUPLE_STRUCT, std::move (variants), - std::move (substitutions), repr, - TyTy::SubstitutionArgumentMappings::empty ( - context->get_lifetime_resolver ().get_num_bound_regions ()), - region_constraints); - - context->insert_type (struct_decl.get_mappings (), type); + auto variant + = new TyTy::VariantDef (struct_decl.get_mappings ().get_hirid (), + struct_decl.get_mappings ().get_defid (), + struct_decl.get_identifier ().as_string (), ident, + TyTy::VariantDef::VariantType::TUPLE, tl::nullopt, + std::move (fields)); + type->get_variants ().push_back (variant); + if (!validate_adt_size (type)) + { + infered = new TyTy::ErrorType (struct_decl.get_mappings ().get_hirid ()); + context->insert_type (struct_decl.get_mappings (), infered); + return; + } infered = type; context->get_variance_analysis_ctx ().add_type_constraints (*type); @@ -399,6 +482,12 @@ TypeCheckItem::visit (HIR::StructStruct &struct_decl) auto lifetime_pin = context->push_clean_lifetime_resolver (); auto &mappings = Analysis::Mappings::get (); + auto &nr_ctx = Resolver2_0::FinalizedNameResolutionContext::get (); + CanonicalPath path + = nr_ctx.to_canonical_path (struct_decl.get_mappings ().get_nodeid (), + Resolver2_0::Namespace::Types); + RustIdent ident{path, struct_decl.get_locus ()}; + std::vector substitutions; if (struct_decl.has_generics ()) resolve_generic_params (HIR::Item::ItemKind::Struct, @@ -414,6 +503,19 @@ TypeCheckItem::visit (HIR::StructStruct &struct_decl) TyTy::ADTType::ReprOptions repr = parse_repr_options (attrs, struct_decl.get_locus ()); + std::vector variants; + auto *type = new TyTy::ADTType ( + struct_decl.get_mappings ().get_defid (), + struct_decl.get_mappings ().get_hirid (), + struct_decl.get_mappings ().get_hirid (), + struct_decl.get_identifier ().as_string (), ident, + TyTy::ADTType::ADTKind::STRUCT_STRUCT, std::move (variants), + std::move (substitutions), repr, + TyTy::SubstitutionArgumentMappings::empty ( + context->get_lifetime_resolver ().get_num_bound_regions ()), + region_constraints); + context->insert_type (struct_decl.get_mappings (), type); + std::vector fields; for (auto &field : struct_decl.get_fields ()) { @@ -425,6 +527,9 @@ TypeCheckItem::visit (HIR::StructStruct &struct_decl) rust_error_at (mappings.lookup_location (infer_type->get_ref ()), "the placeholder %<_%> is not allowed within types on " "item signatures for structs"); + infered + = new TyTy::ErrorType (struct_decl.get_mappings ().get_hirid ()); + context->insert_type (struct_decl.get_mappings (), infered); return; } auto *ty_field @@ -459,37 +564,22 @@ TypeCheckItem::visit (HIR::StructStruct &struct_decl) } } - auto &nr_ctx = Resolver2_0::FinalizedNameResolutionContext::get (); - - CanonicalPath path - = nr_ctx.to_canonical_path (struct_decl.get_mappings ().get_nodeid (), - Resolver2_0::Namespace::Types); - - RustIdent ident{path, struct_decl.get_locus ()}; - // its a single variant ADT auto variant_type = struct_decl.is_unit_struct () ? TyTy::VariantDef::VariantType::UNIT : TyTy::VariantDef::VariantType::STRUCT; - std::vector variants; - variants.push_back ( - new TyTy::VariantDef (struct_decl.get_mappings ().get_hirid (), - struct_decl.get_mappings ().get_defid (), - struct_decl.get_identifier ().as_string (), ident, - variant_type, tl::nullopt, std::move (fields))); - - auto *type = new TyTy::ADTType ( - struct_decl.get_mappings ().get_defid (), - struct_decl.get_mappings ().get_hirid (), - struct_decl.get_mappings ().get_hirid (), - struct_decl.get_identifier ().as_string (), ident, - TyTy::ADTType::ADTKind::STRUCT_STRUCT, std::move (variants), - std::move (substitutions), repr, - TyTy::SubstitutionArgumentMappings::empty ( - context->get_lifetime_resolver ().get_num_bound_regions ()), - region_constraints); - - context->insert_type (struct_decl.get_mappings (), type); + auto variant + = new TyTy::VariantDef (struct_decl.get_mappings ().get_hirid (), + struct_decl.get_mappings ().get_defid (), + struct_decl.get_identifier ().as_string (), ident, + variant_type, tl::nullopt, std::move (fields)); + type->get_variants ().push_back (variant); + if (!validate_adt_size (type)) + { + infered = new TyTy::ErrorType (struct_decl.get_mappings ().get_hirid ()); + context->insert_type (struct_decl.get_mappings (), infered); + return; + } infered = type; context->get_variance_analysis_ctx ().add_type_constraints (*type); @@ -504,12 +594,35 @@ TypeCheckItem::visit (HIR::Enum &enum_decl) resolve_generic_params (HIR::Item::ItemKind::Enum, enum_decl.get_locus (), enum_decl.get_generic_params (), substitutions); + TyTy::RegionConstraints region_constraints; + ResolveWhereClauseItem::Resolve (enum_decl.get_where_clause (), + region_constraints); + + auto &nr_ctx = Resolver2_0::FinalizedNameResolutionContext::get (); + CanonicalPath canonical_path + = nr_ctx.to_canonical_path (enum_decl.get_mappings ().get_nodeid (), + Resolver2_0::Namespace::Types); + + RustIdent ident{canonical_path, enum_decl.get_locus ()}; + // Process #[repr(X)] attribute, if any const AST::AttrVec &attrs = enum_decl.get_outer_attrs (); TyTy::ADTType::ReprOptions repr = parse_repr_options (attrs, enum_decl.get_locus ()); std::vector variants; + auto *type = new TyTy::ADTType ( + enum_decl.get_mappings ().get_defid (), + enum_decl.get_mappings ().get_hirid (), + enum_decl.get_mappings ().get_hirid (), + enum_decl.get_identifier ().as_string (), ident, + TyTy::ADTType::ADTKind::ENUM, std::move (variants), + std::move (substitutions), repr, + TyTy::SubstitutionArgumentMappings::empty ( + context->get_lifetime_resolver ().get_num_bound_regions ()), + region_constraints); + context->insert_type (enum_decl.get_mappings (), type); + int64_t discriminant_value = 0; for (auto &variant : enum_decl.get_variants ()) { @@ -518,7 +631,7 @@ TypeCheckItem::visit (HIR::Enum &enum_decl) if (field_type) { discriminant_value++; - variants.push_back (field_type); + type->get_variants ().push_back (field_type); } } @@ -534,25 +647,12 @@ TypeCheckItem::visit (HIR::Enum &enum_decl) } } - auto &nr_ctx = Resolver2_0::FinalizedNameResolutionContext::get (); - - // get the path - CanonicalPath canonical_path - = nr_ctx.to_canonical_path (enum_decl.get_mappings ().get_nodeid (), - Resolver2_0::Namespace::Types); - - RustIdent ident{canonical_path, enum_decl.get_locus ()}; - - // multi variant ADT - auto *type - = new TyTy::ADTType (enum_decl.get_mappings ().get_defid (), - enum_decl.get_mappings ().get_hirid (), - enum_decl.get_mappings ().get_hirid (), - enum_decl.get_identifier ().as_string (), ident, - TyTy::ADTType::ADTKind::ENUM, std::move (variants), - std::move (substitutions), repr); - - context->insert_type (enum_decl.get_mappings (), type); + if (!validate_adt_size (type)) + { + infered = new TyTy::ErrorType (enum_decl.get_mappings ().get_hirid ()); + context->insert_type (enum_decl.get_mappings (), infered); + return; + } infered = type; context->get_variance_analysis_ctx ().add_type_constraints (*type); @@ -574,6 +674,31 @@ TypeCheckItem::visit (HIR::Union &union_decl) ResolveWhereClauseItem::Resolve (union_decl.get_where_clause (), region_constraints); + auto &nr_ctx = Resolver2_0::FinalizedNameResolutionContext::get (); + CanonicalPath canonical_path + = nr_ctx.to_canonical_path (union_decl.get_mappings ().get_nodeid (), + Resolver2_0::Namespace::Types); + + RustIdent ident{canonical_path, union_decl.get_locus ()}; + + // Process #[repr(X)] attribute, if any + const AST::AttrVec &attrs = union_decl.get_outer_attrs (); + TyTy::ADTType::ReprOptions repr + = parse_repr_options (attrs, union_decl.get_locus ()); + + std::vector variants; + auto *type = new TyTy::ADTType ( + union_decl.get_mappings ().get_defid (), + union_decl.get_mappings ().get_hirid (), + union_decl.get_mappings ().get_hirid (), + union_decl.get_identifier ().as_string (), ident, + TyTy::ADTType::ADTKind::UNION, std::move (variants), + std::move (substitutions), repr, + TyTy::SubstitutionArgumentMappings::empty ( + context->get_lifetime_resolver ().get_num_bound_regions ()), + region_constraints); + context->insert_type (union_decl.get_mappings (), type); + std::vector fields; for (auto &variant : union_decl.get_variants ()) { @@ -588,33 +713,20 @@ TypeCheckItem::visit (HIR::Union &union_decl) ty_variant->get_field_type ()); } - auto &nr_ctx = Resolver2_0::FinalizedNameResolutionContext::get (); - - // get the path - CanonicalPath canonical_path - = nr_ctx.to_canonical_path (union_decl.get_mappings ().get_nodeid (), - Resolver2_0::Namespace::Types); - - RustIdent ident{canonical_path, union_decl.get_locus ()}; - - // there is only a single variant - std::vector variants; - variants.push_back ( - new TyTy::VariantDef (union_decl.get_mappings ().get_hirid (), - union_decl.get_mappings ().get_defid (), - union_decl.get_identifier ().as_string (), ident, - TyTy::VariantDef::VariantType::STRUCT, tl::nullopt, - std::move (fields))); - - auto *type - = new TyTy::ADTType (union_decl.get_mappings ().get_defid (), - union_decl.get_mappings ().get_hirid (), - union_decl.get_mappings ().get_hirid (), - union_decl.get_identifier ().as_string (), ident, - TyTy::ADTType::ADTKind::UNION, std::move (variants), - std::move (substitutions)); + auto variant + = new TyTy::VariantDef (union_decl.get_mappings ().get_hirid (), + union_decl.get_mappings ().get_defid (), + union_decl.get_identifier ().as_string (), ident, + TyTy::VariantDef::VariantType::STRUCT, tl::nullopt, + std::move (fields)); + type->get_variants ().push_back (variant); + if (!validate_adt_size (type)) + { + infered = new TyTy::ErrorType (union_decl.get_mappings ().get_hirid ()); + context->insert_type (union_decl.get_mappings (), infered); + return; + } - context->insert_type (union_decl.get_mappings (), type); infered = type; context->get_variance_analysis_ctx ().add_type_constraints (*type); diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.cc b/gcc/rust/typecheck/rust-hir-type-check-type.cc index c60d419e5422..8bf304fa0efc 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-type.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-type.cc @@ -156,8 +156,17 @@ TypeCheckType::visit (HIR::TypePath &path) TyTy::BaseType *path_type = root; if (mode == ResolutionMode::REFERENCE) { - path_type = root->clone (); - path_type->set_ref (path.get_mappings ().get_hirid ()); + // A recursive path must keep referring to the in-progress nominal ADT. + // Cloning its currently empty variant list would leave a permanently + // incomplete snapshot in the recursive field. + auto *root_adt = root->try_as (); + bool recursive_root + = root_adt != nullptr && root_adt->get_variants ().empty (); + if (!recursive_root) + { + path_type = root->clone (); + path_type->set_ref (path.get_mappings ().get_hirid ()); + } context->insert_implicit_type (path.get_mappings ().get_hirid (), path_type); } diff --git a/gcc/rust/typecheck/rust-hir-type-check.h b/gcc/rust/typecheck/rust-hir-type-check.h index 4efbaa8936b2..c9572b13c0b1 100644 --- a/gcc/rust/typecheck/rust-hir-type-check.h +++ b/gcc/rust/typecheck/rust-hir-type-check.h @@ -215,6 +215,15 @@ class TypeCheckContext void insert_implicit_type (HirId id, TyTy::BaseType *type); + bool + lookup_adt_substitution (DefId id, + const TyTy::SubstitutionArgumentMappings &mappings, + TyTy::ADTType **type) const; + void + insert_adt_substitution (DefId id, + const TyTy::SubstitutionArgumentMappings &mappings, + TyTy::ADTType *type); + void insert_type_by_node_id (NodeId ref, HirId id); bool lookup_type_by_node_id (NodeId ref, HirId *id); @@ -343,6 +352,8 @@ class TypeCheckContext std::map node_id_refs; std::map resolved; + std::map>, TyTy::ADTType *> + adt_substitutions; std::set function_bodies_pending; std::vector> builtins; std::vector> diff --git a/gcc/rust/typecheck/rust-typecheck-context.cc b/gcc/rust/typecheck/rust-typecheck-context.cc index a1f10ea29a1c..6f364a4ac3f0 100644 --- a/gcc/rust/typecheck/rust-typecheck-context.cc +++ b/gcc/rust/typecheck/rust-typecheck-context.cc @@ -98,6 +98,43 @@ TypeCheckContext::insert_implicit_type (HirId id, TyTy::BaseType *type) resolved[id] = type; } +static std::pair> +make_adt_substitution_key (DefId id, + const TyTy::SubstitutionArgumentMappings &mappings) +{ + std::vector arguments; + arguments.reserve (mappings.size ()); + for (const auto &mapping : mappings.get_mappings ()) + arguments.push_back (mapping.get_tyty ()->get_ty_ref ()); + + return {id, std::move (arguments)}; +} + +bool +TypeCheckContext::lookup_adt_substitution ( + DefId id, const TyTy::SubstitutionArgumentMappings &mappings, + TyTy::ADTType **type) const +{ + auto it = adt_substitutions.find (make_adt_substitution_key (id, mappings)); + if (it == adt_substitutions.end ()) + return false; + + *type = it->second; + return true; +} + +void +TypeCheckContext::insert_adt_substitution ( + DefId id, const TyTy::SubstitutionArgumentMappings &mappings, + TyTy::ADTType *type) +{ + rust_assert (type != nullptr); + auto inserted + = adt_substitutions.emplace (make_adt_substitution_key (id, mappings), + type); + rust_assert (inserted.second); +} + bool TypeCheckContext::lookup_type (HirId id, TyTy::BaseType **type) const { diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc index bc6844595fc8..51adb831e4cd 100644 --- a/gcc/rust/typecheck/rust-tyty.cc +++ b/gcc/rust/typecheck/rust-tyty.cc @@ -767,6 +767,9 @@ BaseType::monomorphized_clone () const } else if (auto adt = x->try_as ()) { + if (!adt->has_substitutions_defined () || !adt->needs_substitution ()) + return const_cast (adt); + std::vector cloned_variants; for (auto &variant : adt->get_variants ()) cloned_variants.push_back (variant->monomorphized_clone ()); @@ -824,31 +827,46 @@ BaseType::debug () const const TyTy::BaseType * BaseType::contains_infer () const +{ + std::set visited; + return contains_infer (visited); +} + +const TyTy::BaseType * +BaseType::contains_infer (std::set &visited) const { const TyTy::BaseType *x = destructure (); + bool found = visited.find (x) != visited.end (); + if (found) + return nullptr; + visited.insert (x); if (auto fn = x->try_as ()) { for (const auto ¶m : fn->get_params ()) { - auto infer = param.get_type ()->contains_infer (); + auto infer = param.get_type ()->contains_infer (visited); if (infer) return infer; } - return fn->get_return_type ()->contains_infer (); + return fn->get_return_type ()->contains_infer (visited); } else if (auto fn = x->try_as ()) { for (const auto ¶m : fn->get_params ()) { - auto infer = param.get_tyty ()->contains_infer (); + auto infer = param.get_tyty ()->contains_infer (visited); if (infer) return infer; } - return fn->get_return_type ()->contains_infer (); + return fn->get_return_type ()->contains_infer (visited); } else if (auto adt = x->try_as ()) { + // non generic adt's cannot have infer vars on them + if (!adt->has_substitutions_defined ()) + return nullptr; + for (auto &variant : adt->get_variants ()) { bool is_num_variant @@ -861,7 +879,7 @@ BaseType::contains_infer () const for (auto &field : variant->get_fields ()) { const BaseType *field_type = field->get_field_type (); - auto infer = (field_type->contains_infer ()); + auto infer = field_type->contains_infer (visited); if (infer) return infer; } @@ -870,28 +888,28 @@ BaseType::contains_infer () const } else if (auto arr = x->try_as ()) { - auto type_infer = (arr->get_element_type ()->contains_infer ()); + auto type_infer = arr->get_element_type ()->contains_infer (visited); if (type_infer) return type_infer; - return arr->get_capacity ()->contains_infer (); + return arr->get_capacity ()->contains_infer (visited); } else if (auto slice = x->try_as ()) { - return slice->get_element_type ()->contains_infer (); + return slice->get_element_type ()->contains_infer (visited); } else if (auto ptr = x->try_as ()) { - return ptr->get_base ()->contains_infer (); + return ptr->get_base ()->contains_infer (visited); } else if (auto ref = x->try_as ()) { - return ref->get_base ()->contains_infer (); + return ref->get_base ()->contains_infer (visited); } else if (auto tuple = x->try_as ()) { for (size_t i = 0; i < tuple->num_fields (); i++) { - auto infer = (tuple->get_field (i)->contains_infer ()); + auto infer = tuple->get_field (i)->contains_infer (visited); if (infer) return infer; } @@ -899,10 +917,10 @@ BaseType::contains_infer () const } else if (auto closure = x->try_as ()) { - auto infer = (closure->get_parameters ().contains_infer ()); + auto infer = closure->get_parameters ().contains_infer (visited); if (infer) return infer; - return closure->get_result_type ().contains_infer (); + return closure->get_result_type ().contains_infer (visited); } else if (x->is ()) { @@ -921,8 +939,19 @@ BaseType::contains_infer () const bool BaseType::is_concrete () const +{ + std::set visited; + return is_concrete (visited); +} + +bool +BaseType::is_concrete (std::set &visited) const { const TyTy::BaseType *x = destructure (); + bool found = visited.find (x) != visited.end (); + if (found) + return true; + visited.insert (x); if (x->is ()) { @@ -939,7 +968,7 @@ BaseType::is_concrete () const else if (x->is ()) { const auto p = x->as (); - return p->get_self ()->is_concrete (); + return p->get_self ()->is_concrete (visited); } // placeholder is a special case for this case when it is not resolvable // it means we its just an empty placeholder associated type which is @@ -952,22 +981,25 @@ BaseType::is_concrete () const { for (const auto ¶m : fn->get_params ()) { - if (!param.get_type ()->is_concrete ()) + if (!param.get_type ()->is_concrete (visited)) return false; } - return fn->get_return_type ()->is_concrete (); + return fn->get_return_type ()->is_concrete (visited); } else if (auto fn = x->try_as ()) { for (const auto ¶m : fn->get_params ()) { - if (!param.get_tyty ()->is_concrete ()) + if (!param.get_tyty ()->is_concrete (visited)) return false; } - return fn->get_return_type ()->is_concrete (); + return fn->get_return_type ()->is_concrete (visited); } else if (auto adt = x->try_as ()) { + if (!adt->has_substitutions_defined ()) + return true; + if (adt->is_unit ()) return !adt->needs_substitution (); @@ -983,7 +1015,7 @@ BaseType::is_concrete () const for (auto &field : variant->get_fields ()) { const BaseType *field_type = field->get_field_type (); - if (!field_type->is_concrete ()) + if (!field_type->is_concrete (visited)) return false; } } @@ -991,35 +1023,35 @@ BaseType::is_concrete () const } else if (auto arr = x->try_as ()) { - return arr->get_element_type ()->is_concrete () - && arr->get_capacity ()->is_concrete (); + return arr->get_element_type ()->is_concrete (visited) + && arr->get_capacity ()->is_concrete (visited); } else if (auto slice = x->try_as ()) { - return slice->get_element_type ()->is_concrete (); + return slice->get_element_type ()->is_concrete (visited); } else if (auto ptr = x->try_as ()) { - return ptr->get_base ()->is_concrete (); + return ptr->get_base ()->is_concrete (visited); } else if (auto ref = x->try_as ()) { - return ref->get_base ()->is_concrete (); + return ref->get_base ()->is_concrete (visited); } else if (auto tuple = x->try_as ()) { for (size_t i = 0; i < tuple->num_fields (); i++) { - if (!tuple->get_field (i)->is_concrete ()) + if (!tuple->get_field (i)->is_concrete (visited)) return false; } return true; } else if (auto closure = x->try_as ()) { - if (closure->get_parameters ().is_concrete ()) + if (closure->get_parameters ().is_concrete (visited)) return false; - return closure->get_result_type ().is_concrete (); + return closure->get_result_type ().is_concrete (visited); } else if (x->is () || x->is () || x->is () || x->is () || x->is () || x->is () @@ -1998,10 +2030,16 @@ ADTType::as_string () const bool ADTType::is_equal (const BaseType &other) const { + if (this == &other) + return true; + if (get_kind () != other.get_kind ()) return false; auto other2 = other.as (); + if (get_id () != other2->get_id ()) + return false; + if (get_adt_kind () != other2->get_adt_kind ()) return false; @@ -2028,15 +2066,8 @@ ADTType::is_equal (const BaseType &other) const } } - for (size_t i = 0; i < number_of_variants (); i++) - { - const TyTy::VariantDef *a = get_variants ().at (i); - const TyTy::VariantDef *b = other2->get_variants ().at (i); - - if (!a->is_equal (*b)) - return false; - } - + // ADTs are nominal. Their fields describe the definition, not the type's + // identity, and walking them here cannot terminate for recursive ADTs. return true; } @@ -2131,10 +2162,19 @@ handle_substitions (SubstitutionArgumentMappings &subst_mappings, ADTType * ADTType::handle_substitions (SubstitutionArgumentMappings &subst_mappings) { + auto context = Resolver::TypeCheckContext::get (); + ADTType *cached = nullptr; + if (context->lookup_adt_substitution (get_id (), subst_mappings, &cached)) + return cached; + auto adt = clone ()->as (); adt->set_ty_ref (mappings.get_next_hir_id ()); adt->used_arguments = subst_mappings; + // track these to handle recursive types + context->insert_implicit_type (adt->get_ty_ref (), adt); + context->insert_adt_substitution (get_id (), subst_mappings, adt); + for (auto &sub : adt->get_substs ()) { SubstitutionArg arg = SubstitutionArg::error (); @@ -2589,7 +2629,7 @@ FnPtr::as_string () const auto ¶ms = get_params (); for (auto &p : params) { - params_str += p.get_tyty ()->as_string () + " ,"; + params_str += p.get_tyty ()->get_name () + " ,"; } std::string unsafety = ""; @@ -2598,7 +2638,7 @@ FnPtr::as_string () const std::string abi = get_string_from_abi (get_abi ()); return unsafety + "abi:" + abi + " " + "fnptr (" + params_str + ") -> " - + get_return_type ()->as_string (); + + get_return_type ()->get_name (); } bool @@ -3641,7 +3681,7 @@ std::string PointerType::as_string () const { return std::string ("* ") + (is_mutable () ? "mut" : "const") + " " - + get_base ()->as_string (); + + get_base ()->get_name (); } std::string diff --git a/gcc/rust/typecheck/rust-tyty.h b/gcc/rust/typecheck/rust-tyty.h index 7ecea5759148..c4f0ad59a658 100644 --- a/gcc/rust/typecheck/rust-tyty.h +++ b/gcc/rust/typecheck/rust-tyty.h @@ -368,6 +368,10 @@ class BaseType : public TypeBoundsMappings virtual bool is_box () const { return false; } protected: + const TyTy::BaseType * + contains_infer (std::set &visited) const; + bool is_concrete (std::set &visited) const; + BaseType (HirId ref, HirId ty_ref, TypeKind kind, RustIdent ident, std::set refs = std::set ()); diff --git a/gcc/rust/typecheck/rust-unify.cc b/gcc/rust/typecheck/rust-unify.cc index 3d5454741201..edb6e20e857e 100644 --- a/gcc/rust/typecheck/rust-unify.cc +++ b/gcc/rust/typecheck/rust-unify.cc @@ -38,11 +38,13 @@ UnifyRules::UnifyRules (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs, location_t locus, bool commit_flag, bool emit_error, bool check_bounds, bool infer, std::vector &commits, - std::vector &infers) + std::vector &infers, + ActiveADTs &active_adts) : lhs (lhs), rhs (rhs), locus (locus), commit_flag (commit_flag), emit_error (emit_error), infer_flag (infer), check_bounds_flag (check_bounds), commits (commits), infers (infers), - mappings (Analysis::Mappings::get ()), context (*TypeCheckContext::get ()) + active_adts (active_adts), mappings (Analysis::Mappings::get ()), + context (*TypeCheckContext::get ()) {} TyTy::BaseType * @@ -50,10 +52,15 @@ UnifyRules::Resolve (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs, location_t locus, bool commit_flag, bool emit_error, bool check_bounds, bool infer, std::vector &commits, - std::vector &infers) + std::vector &infers, + ActiveADTs *active_adts) { + ActiveADTs root_active_adts; + if (active_adts == nullptr) + active_adts = &root_active_adts; + UnifyRules r (lhs, rhs, locus, commit_flag, emit_error, check_bounds, infer, - commits, infers); + commits, infers, *active_adts); TyTy::BaseType *result = r.go (); bool failed = result->get_kind () == TyTy::TypeKind::ERROR; @@ -76,7 +83,8 @@ UnifyRules::resolve_subtype (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs) { TyTy::BaseType *result = UnifyRules::Resolve (lhs, rhs, locus, commit_flag, emit_error, - check_bounds_flag, infer_flag, commits, infers); + check_bounds_flag, infer_flag, commits, infers, + &active_adts); // If the recursive call resulted in an error and would have emitted an error // message, disable error emission for the current level to avoid duplicate @@ -585,6 +593,9 @@ UnifyRules::expect_adt (TyTy::ADTType *ltype, TyTy::BaseType *rtype) case TyTy::ADT: { TyTy::ADTType &type = *static_cast (rtype); + if (ltype == &type) + return ltype; + if (ltype->get_adt_kind () != type.get_adt_kind ()) { return unify_error_type_node (); @@ -605,6 +616,10 @@ UnifyRules::expect_adt (TyTy::ADTType *ltype, TyTy::BaseType *rtype) return unify_error_type_node (); } + ActiveADTGuard guard (active_adts, {ltype, &type}); + if (guard.already_active ()) + return ltype; + for (size_t i = 0; i < type.number_of_variants (); ++i) { TyTy::VariantDef *a = ltype->get_variants ().at (i); diff --git a/gcc/rust/typecheck/rust-unify.h b/gcc/rust/typecheck/rust-unify.h index f57914032d4a..2091bd1b14bc 100644 --- a/gcc/rust/typecheck/rust-unify.h +++ b/gcc/rust/typecheck/rust-unify.h @@ -28,6 +28,40 @@ namespace Resolver { class UnifyRules { public: + using ADTPair = std::pair; + using ActiveADTs = std::set; + + class ActiveADTGuard + { + public: + ActiveADTGuard (ActiveADTs &active, ADTPair pair) + : active (active), pair (pair), inserted (false) + { + bool found = active.find (this->pair) != active.end (); + if (!found) + { + active.insert (this->pair); + inserted = true; + } + } + + ~ActiveADTGuard () + { + if (inserted) + active.erase (pair); + } + + bool already_active () const { return !inserted; } + + ActiveADTGuard (const ActiveADTGuard &) = delete; + ActiveADTGuard &operator= (const ActiveADTGuard &) = delete; + + private: + ActiveADTs &active; + ADTPair pair; + bool inserted; + }; + struct InferenceSite { InferenceSite (HirId pref, HirId ptyref, TyTy::BaseGeneric *param, @@ -52,12 +86,11 @@ class UnifyRules TyTy::BaseType *resolved; }; - static TyTy::BaseType *Resolve (TyTy::TyWithLocation lhs, - TyTy::TyWithLocation rhs, location_t locus, - bool commit_flag, bool emit_error, - bool check_bounds, bool infer, - std::vector &commits, - std::vector &infers); + static TyTy::BaseType * + Resolve (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs, location_t locus, + bool commit_flag, bool emit_error, bool check_bounds, bool infer, + std::vector &commits, std::vector &infers, + ActiveADTs *active_adts = nullptr); static void commit (TyTy::BaseType *base, TyTy::BaseType *other, TyTy::BaseType *resolved); @@ -102,7 +135,7 @@ class UnifyRules UnifyRules (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs, location_t locus, bool commit_flag, bool emit_error, bool infer, bool check_bounds, std::vector &commits, - std::vector &infers); + std::vector &infers, ActiveADTs &active_adts); TyTy::BaseType *resolve_subtype (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs); @@ -126,6 +159,8 @@ class UnifyRules std::vector &commits; std::vector &infers; + ActiveADTs &active_adts; + Analysis::Mappings &mappings; TypeCheckContext &context; }; diff --git a/gcc/testsuite/rust/compile/issues/issue-1178.rs b/gcc/testsuite/rust/compile/issues/issue-1178.rs new file mode 100644 index 000000000000..833fa7dcb443 --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/issue-1178.rs @@ -0,0 +1,8 @@ +// { dg-options "-w" } + +#![feature(no_core)] +#![no_core] + +pub struct Edge<'a> { + pub next: &'a Edge<'a> +} diff --git a/gcc/testsuite/rust/compile/issues/issue-2757.rs b/gcc/testsuite/rust/compile/issues/issue-2757.rs new file mode 100644 index 000000000000..39cad67a5206 --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/issue-2757.rs @@ -0,0 +1,7 @@ +// { dg-options "-w" } + +#![feature(no_core)] +#![no_core] + +struct S(&'static T); +struct T(&'static S); diff --git a/gcc/testsuite/rust/compile/issues/issue-4709.rs b/gcc/testsuite/rust/compile/issues/issue-4709.rs new file mode 100644 index 000000000000..29d3c17c5001 --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/issue-4709.rs @@ -0,0 +1,8 @@ +// { dg-options "-w" } + +#![feature(no_core)] +#![no_core] + +struct Node<'a> { + n: &'a Node<'a>, +} diff --git a/gcc/testsuite/rust/compile/recursive-types-infinite.rs b/gcc/testsuite/rust/compile/recursive-types-infinite.rs new file mode 100644 index 000000000000..402b8b0cc3ff --- /dev/null +++ b/gcc/testsuite/rust/compile/recursive-types-infinite.rs @@ -0,0 +1,14 @@ +// { dg-additional-options "-w" } +#![feature(no_core, lang_items)] +#![no_core] +#[lang = "sized"] +trait Sized {} + +struct A { b: B } // { dg-error "recursive type .A. has infinite size" } +struct B { a: A } +struct TupleBad((TupleBad,)); // { dg-error "recursive type .TupleBad. has infinite size" } +struct ArrayBad([ArrayBad; 1]); // { dg-error "recursive type .ArrayBad. has infinite size" } +struct Mixed { + pointer: *const Mixed, + inline: Mixed, // { dg-error "recursive type .Mixed. has infinite size" } +} diff --git a/gcc/testsuite/rust/compile/recursive-types-mismatch.rs b/gcc/testsuite/rust/compile/recursive-types-mismatch.rs new file mode 100644 index 000000000000..50526d9d26cf --- /dev/null +++ b/gcc/testsuite/rust/compile/recursive-types-mismatch.rs @@ -0,0 +1,20 @@ +// { dg-additional-options "-w" } +#![feature(no_core, lang_items)] +#![no_core] +#[lang = "sized"] +trait Sized {} + +struct A { next: *const A } +struct B { next: *const B } +fn nominal(a: A) -> B { + a // { dg-error "mismatched types" "" { target *-*-* } .-1 } +} +struct Node { next: *const Node, value: T } +fn generic(a: Node) -> Node { + a // { dg-error "mismatched types" "" { target *-*-* } .-1 } +} +struct Left { right: *const Right, value: T } +struct Right { left: *const Left, value: T } +fn mutual(a: Left) -> Left { + a // { dg-error "mismatched types" "" { target *-*-* } .-1 } +} diff --git a/gcc/testsuite/rust/compile/recusive-types-1.rs b/gcc/testsuite/rust/compile/recusive-types-1.rs new file mode 100644 index 000000000000..5d38ff3dea93 --- /dev/null +++ b/gcc/testsuite/rust/compile/recusive-types-1.rs @@ -0,0 +1,23 @@ +// { dg-options "-w" } + +#![feature(no_core)] +#![no_core] +#![feature(lang_items)] + +#[lang = "sized"] +pub trait Sized {} + +struct Node { + value: i32, + next: *const Node, +} + +fn main() { + let node = Node { + value: 1, + next: 0 as *const Node, + }; + + let _value = node.value; + let _next = node.next; +} diff --git a/gcc/testsuite/rust/compile/recusive-types-2.rs b/gcc/testsuite/rust/compile/recusive-types-2.rs new file mode 100644 index 000000000000..d98a07879555 --- /dev/null +++ b/gcc/testsuite/rust/compile/recusive-types-2.rs @@ -0,0 +1,16 @@ +// { dg-options "-w" } + +#![feature(no_core)] +#![no_core] + +struct A { + b: &'static B, +} + +struct B { + c: &'static C, +} + +struct C { + a: &'static A, +} diff --git a/gcc/testsuite/rust/compile/recusive-types-3.rs b/gcc/testsuite/rust/compile/recusive-types-3.rs new file mode 100644 index 000000000000..17146bc3610b --- /dev/null +++ b/gcc/testsuite/rust/compile/recusive-types-3.rs @@ -0,0 +1,12 @@ +// { dg-options "-w" } + +#![feature(no_core)] +#![no_core] + +struct A(&'static B); + +struct B { + c: *const C, +} + +struct C(&'static A); diff --git a/gcc/testsuite/rust/compile/recusive-types-4.rs b/gcc/testsuite/rust/compile/recusive-types-4.rs new file mode 100644 index 000000000000..ac6060ed1e7d --- /dev/null +++ b/gcc/testsuite/rust/compile/recusive-types-4.rs @@ -0,0 +1,16 @@ +// { dg-options "-w" } + +#![feature(no_core)] +#![no_core] +#![feature(lang_items)] + +#[lang = "sized"] +trait Sized {} + +struct TupleNested { + link: (*const TupleNested,), +} + +struct ArrayNested { + links: [*const ArrayNested; 2], +} diff --git a/gcc/testsuite/rust/compile/recusive-types-5.rs b/gcc/testsuite/rust/compile/recusive-types-5.rs new file mode 100644 index 000000000000..8263ee5ab516 --- /dev/null +++ b/gcc/testsuite/rust/compile/recusive-types-5.rs @@ -0,0 +1,17 @@ +// { dg-options "-w" } + +#![feature(no_core)] +#![no_core] + +struct A { + b: B, +} + +struct B { + a: *const A, +} + +struct Node { + parent: *const Node, + next: *mut Node, +} diff --git a/gcc/testsuite/rust/compile/recusive-types-6.rs b/gcc/testsuite/rust/compile/recusive-types-6.rs new file mode 100644 index 000000000000..2e8ecce7980d --- /dev/null +++ b/gcc/testsuite/rust/compile/recusive-types-6.rs @@ -0,0 +1,26 @@ +// { dg-options "-w" } + +#![feature(lang_items, no_core)] +#![no_core] + +#[lang = "sized"] +trait Sized {} + +struct Node { + value: T, + next: *const Node, +} + +fn main() { + let node = Node:: { + value: 1, + next: 0 as *const Node, + }; + let _value = node.value; + + let other = Node:: { + value: 2, + next: 0 as *const Node, + }; + let _other_value = other.value; +} diff --git a/gcc/testsuite/rust/compile/recusive-types-7.rs b/gcc/testsuite/rust/compile/recusive-types-7.rs new file mode 100644 index 000000000000..3b1505ca6cfb --- /dev/null +++ b/gcc/testsuite/rust/compile/recusive-types-7.rs @@ -0,0 +1,10 @@ +// { dg-additional-options "-w" } + +#![feature(no_core)] +#![no_core] + +struct Bad { + bad: Bad, // { dg-error "recursive type .Bad. has infinite size" } +} + +fn main() {} diff --git a/gcc/testsuite/rust/execute/recursive-types-fnptr.rs b/gcc/testsuite/rust/execute/recursive-types-fnptr.rs new file mode 100644 index 000000000000..847dd7587925 --- /dev/null +++ b/gcc/testsuite/rust/execute/recursive-types-fnptr.rs @@ -0,0 +1,14 @@ +// { dg-additional-options "-w" } +#![feature(no_core, lang_items)] +#![no_core] +#[lang = "sized"] +trait Sized {} + +struct Callback { call: fn(Callback) -> Callback, value: i32 } +fn identity(c: Callback) -> Callback { c } +fn main() -> i32 { + let c = Callback { call: identity, value: 0 }; + let f = c.call; + let result = f(c); + result.value +} From f138b6221393654b08b7c73e9dcc7df662665666 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 18 Sep 2026 13:44:21 +0100 Subject: [PATCH 557/584] gccrs: Add testcase to show issue fixed Fixes Rust-GCC/gccrs#3903 gcc/testsuite/ChangeLog: * rust/compile/issues/3903.rs: New test. Signed-off-by: Philip Herron --- gcc/testsuite/rust/compile/issues/3903.rs | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 gcc/testsuite/rust/compile/issues/3903.rs diff --git a/gcc/testsuite/rust/compile/issues/3903.rs b/gcc/testsuite/rust/compile/issues/3903.rs new file mode 100644 index 000000000000..040dcee808ec --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/3903.rs @@ -0,0 +1,17 @@ +// { dg-options "-w" } + +#![feature(no_core, lang_items)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +trait Foo { + type Value; +} +impl Foo for u32 { + type Value = f64; +} +struct A { + T: ::Value, +} From 79bee97ed8da7de843adc8a3f850f0b7a325d041 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 18 Sep 2026 13:33:29 +0100 Subject: [PATCH 558/584] gccrs: Add testcase to show issue is fixed Fixes Rust-GCC/gccrs#3015 gcc/testsuite/ChangeLog: * rust/compile/issues/3015.rs: New test. Signed-off-by: Philip Herron --- gcc/testsuite/rust/compile/issues/3015.rs | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 gcc/testsuite/rust/compile/issues/3015.rs diff --git a/gcc/testsuite/rust/compile/issues/3015.rs b/gcc/testsuite/rust/compile/issues/3015.rs new file mode 100644 index 000000000000..b484bfe0a0cc --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/3015.rs @@ -0,0 +1,7 @@ +#![feature(no_core, lang_items)] +#![no_core] + +#[lang = "sized"] +trait Sized {} + +impl [T; N] {} From 7f8c96f3be7b9759b317b2998225bafbda323aea Mon Sep 17 00:00:00 2001 From: Arthur Cohen Date: Fri, 18 Sep 2026 17:27:03 +0200 Subject: [PATCH 559/584] parse: Remove unused gating_errors field and accessor This vector was previously used by the parser but this is no longer the case. gcc/rust/ChangeLog: * parse/rust-parse.h: Remove field and associated method for retrieving the errors. --- gcc/rust/parse/rust-parse.h | 7 ------- 1 file changed, 7 deletions(-) diff --git a/gcc/rust/parse/rust-parse.h b/gcc/rust/parse/rust-parse.h index ee27e9674ef4..7b0da58c5cbb 100644 --- a/gcc/rust/parse/rust-parse.h +++ b/gcc/rust/parse/rust-parse.h @@ -896,12 +896,6 @@ template class Parser // Get a reference to the list of errors encountered std::vector &get_errors () { return error_table; } - std::vector> & - get_potential_feature_gate_errors () - { - return gating_errors; - } - const ManagedTokenSource &get_token_source () const { return lexer; } const_TokenPtr peek_current_token () { return lexer.peek_token (0); } @@ -913,7 +907,6 @@ template class Parser // The error list. std::vector error_table; - std::vector> gating_errors; // The names of inline modules while parsing. std::vector inline_module_stack; From f1c6e8ef6e8c79317cb580db259f7b83ec341eb2 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Thu, 10 Sep 2026 21:43:46 +0100 Subject: [PATCH 560/584] gccrs: add ParamType::clone recusion guard gcc/rust/ChangeLog: * typecheck/rust-tyty.cc (ParamType::clone): add guard Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-tyty.cc | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc index 51adb831e4cd..93061b1fcf6f 100644 --- a/gcc/rust/typecheck/rust-tyty.cc +++ b/gcc/rust/typecheck/rust-tyty.cc @@ -3810,6 +3810,13 @@ ParamType::get_name () const BaseType * ParamType::clone () const { + static std::vector active; + bool cycle = Resolver::ScopedPush::contains (active, get_ty_ref ()); + if (cycle) + return new ParamType (is_trait_self, get_symbol (), ident.locus, get_ref (), + get_ty_ref (), {}, get_combined_refs ()); + + Resolver::ScopedPush guard (active, get_ty_ref ()); return new ParamType (is_trait_self, get_symbol (), ident.locus, get_ref (), get_ty_ref (), get_specified_bounds (), get_combined_refs ()); From 1f52b4c8d84c41c51aeaa0d169e24779243d7aab Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 18 Sep 2026 15:08:18 +0100 Subject: [PATCH 561/584] gccrs: Fix bad substituion error This patch fixes hanlding of substitutions of nested generics by taking into account the already used arguments in the adjust call. For example GenericSplitN< Split > Fixes Rust-GCC/gccrs#4884 gcc/rust/ChangeLog: * typecheck/rust-type-util.cc (normalize_projection): resolve through super traits * typecheck/rust-typecheck-context.cc: disable infer for trait-self * typecheck/rust-tyty-subst.cc: reuse to handle nested arguments * typecheck/rust-unify.cc (UnifyRules::go): relax infer on adts gcc/testsuite/ChangeLog: * rust/compile/generic-type-alias-subst-bug.rs: New test. * rust/compile/issues/4884.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-type-util.cc | 55 +++++++--- gcc/rust/typecheck/rust-typecheck-context.cc | 20 ++-- gcc/rust/typecheck/rust-tyty-subst.cc | 21 +++- gcc/rust/typecheck/rust-unify.cc | 16 +-- .../compile/generic-type-alias-subst-bug.rs | 20 ++++ gcc/testsuite/rust/compile/issues/4884.rs | 102 ++++++++++++++++++ 6 files changed, 204 insertions(+), 30 deletions(-) create mode 100644 gcc/testsuite/rust/compile/generic-type-alias-subst-bug.rs create mode 100644 gcc/testsuite/rust/compile/issues/4884.rs diff --git a/gcc/rust/typecheck/rust-type-util.cc b/gcc/rust/typecheck/rust-type-util.cc index 8f97d60e3a3f..2234f89e0e03 100644 --- a/gcc/rust/typecheck/rust-type-util.cc +++ b/gcc/rust/typecheck/rust-type-util.cc @@ -688,17 +688,28 @@ normalize_projection (TyTy::ProjectionType *proj, location_t locus, { for (auto &bound : self->get_specified_bounds ()) { - if (!bound.get ()->is_equal (*proj->get_trait_ref ())) + // The associated type can be declared on a supertrait of + // a bound: see issue-4884 + // + // I: SplitIter binds Iterator2::Item, + + auto item = bound.lookup_associated_item (assoc_name); + if (!item.has_value ()) + continue; + + auto &item_val = item.value (); + const auto raw_item = item_val.get_raw_item (); + if (raw_item->get_mappings ().get_defid () != item_defid) continue; - auto &binding - = bound.get_substitution_arguments ().get_binding_args (); + const auto parent = item_val.get_parent (); + const auto &arguments = parent->get_substitution_arguments (); + const auto &binding = arguments.get_binding_args (); auto it = binding.find (assoc_name); if (it != binding.end ()) return it->second; - const auto &constraints - = bound.get_substitution_arguments ().get_constraint_args (); + const auto &constraints = arguments.get_constraint_args (); auto constraint = constraints.find (assoc_name); if (constraint != constraints.end ()) { @@ -847,18 +858,28 @@ normalize_projection (TyTy::ProjectionType *proj, location_t locus, if (unify_self) { TyTy::BaseType *proj_self = proj->get_self (); - TyTy::BaseType *impl_self = frame.self; - TyTy::BaseType *self - = unify_site_and (/*id*/ 0, TyTy::TyWithLocation (proj_self, locus), - TyTy::TyWithLocation (impl_self, locus), locus, - /*emit_errors*/ false, - /*commit*/ false, - /*infer*/ false, - /*cleanup*/ true, - /*check_bounds*/ false); - - if (self->get_kind () == TyTy::TypeKind::ERROR) - return self; + bool proj_self_is_unresolved_trait_self = false; + if (auto *param = proj_self->try_as ()) + { + proj_self_is_unresolved_trait_self + = !param->can_resolve () && param->is_implicit_self_trait (); + } + + if (!proj_self_is_unresolved_trait_self) + { + TyTy::BaseType *impl_self = frame.self; + TyTy::BaseType *self = unify_site_and ( + /*id*/ 0, TyTy::TyWithLocation (proj_self, locus), + TyTy::TyWithLocation (impl_self, locus), locus, + /*emit_errors*/ false, + /*commit*/ false, + /*infer*/ false, + /*cleanup*/ true, + /*check_bounds*/ false); + + if (self->get_kind () == TyTy::TypeKind::ERROR) + return self; + } } // Lookup the trait item -> impl type mapping (key = trait item DefId). diff --git a/gcc/rust/typecheck/rust-typecheck-context.cc b/gcc/rust/typecheck/rust-typecheck-context.cc index 6f364a4ac3f0..fe6bc888cc52 100644 --- a/gcc/rust/typecheck/rust-typecheck-context.cc +++ b/gcc/rust/typecheck/rust-typecheck-context.cc @@ -335,12 +335,20 @@ TypeCheckContext::find_matching_impl_trait_frame ( unresolved_trait_self = param->is_implicit_self_trait (); } - bool compatible_self - = unresolved_trait_self - || types_compatable (TyTy::TyWithLocation (i.self), - TyTy::TyWithLocation (resolved_self), - UNDEF_LOCATION, false /* emit_errors */, - false /* check_bounds */); + // Select an existing impl context without inferring a new Self + // binding + bool compatible_self = unresolved_trait_self; + if (!compatible_self) + { + auto res + = unify_site_and (UNKNOWN_HIRID, TyTy::TyWithLocation (i.self), + TyTy::TyWithLocation (resolved_self), + UNDEF_LOCATION, false /* emit_errors */, + false /* commit */, false /* infer */, + true /* cleanup */, false /* check_bounds */); + compatible_self = res->get_kind () != TyTy::TypeKind::ERROR; + } + if (compatible_self) { *find = i; diff --git a/gcc/rust/typecheck/rust-tyty-subst.cc b/gcc/rust/typecheck/rust-tyty-subst.cc index d589b25473d1..ba237bcc7447 100644 --- a/gcc/rust/typecheck/rust-tyty-subst.cc +++ b/gcc/rust/typecheck/rust-tyty-subst.cc @@ -1021,7 +1021,26 @@ SubstitutionRef::adjust_mappings_for_this ( if (subst.needs_substitution ()) { // get from passed in mappings - mappings.get_argument_for_symbol (subst.get_param_ty (), &arg); + bool found + = mappings.get_argument_for_symbol (subst.get_param_ty (), + &arg); + if (!found) + { + // This type can already be partially instantiated from an + // outer scope + SubstitutionArg bound_arg = SubstitutionArg::error (); + bool have_binding = used_arguments.get_argument_for_symbol ( + subst.get_param_ty (), &bound_arg); + + if (have_binding && !bound_arg.is_error ()) + { + BaseType *resolved + = Resolver::SubstMapperInternal::Resolve ( + bound_arg.get_tyty (), mappings); + if (resolved->get_kind () != TypeKind::ERROR) + arg = SubstitutionArg (&subst, resolved); + } + } } else { diff --git a/gcc/rust/typecheck/rust-unify.cc b/gcc/rust/typecheck/rust-unify.cc index edb6e20e857e..417804b447bb 100644 --- a/gcc/rust/typecheck/rust-unify.cc +++ b/gcc/rust/typecheck/rust-unify.cc @@ -253,15 +253,18 @@ UnifyRules::go () } if (infer_flag) { + // an impl parameter can infer to Split without requiring T and P to + // be concrete bool rgot_param = rtype->get_kind () == TyTy::TypeKind::PARAM; bool lhs_is_infer_var = ltype->get_kind () == TyTy::TypeKind::INFER; bool lhs_is_general_infer_var = lhs_is_infer_var && static_cast (ltype)->get_infer_kind () == TyTy::InferType::GENERAL; - bool expected_is_concrete - = ltype->is_concrete () && !lhs_is_general_infer_var; - bool rneeds_infer = expected_is_concrete && (rgot_param); + bool expected_can_infer_param + = (ltype->is_concrete () || ltype->get_kind () == TyTy::TypeKind::ADT) + && !lhs_is_general_infer_var; + bool rneeds_infer = expected_can_infer_param && rgot_param; bool lgot_param = ltype->get_kind () == TyTy::TypeKind::PARAM; bool rhs_is_infer_var = rtype->get_kind () == TyTy::TypeKind::INFER; @@ -269,9 +272,10 @@ UnifyRules::go () = rhs_is_infer_var && static_cast (rtype)->get_infer_kind () == TyTy::InferType::GENERAL; - bool receiver_is_concrete - = rtype->is_concrete () && !rhs_is_general_infer_var; - bool lneeds_infer = receiver_is_concrete && (lgot_param); + bool receiver_can_infer_param + = (rtype->is_concrete () || rtype->get_kind () == TyTy::TypeKind::ADT) + && !rhs_is_general_infer_var; + bool lneeds_infer = receiver_can_infer_param && lgot_param; if (rneeds_infer) { diff --git a/gcc/testsuite/rust/compile/generic-type-alias-subst-bug.rs b/gcc/testsuite/rust/compile/generic-type-alias-subst-bug.rs new file mode 100644 index 000000000000..7a5e9dc852c6 --- /dev/null +++ b/gcc/testsuite/rust/compile/generic-type-alias-subst-bug.rs @@ -0,0 +1,20 @@ +// { dg-options "-w" } +#![feature(no_core, lang_items)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +struct Wrapper { + t: T, +} + +type Alias = Wrapper; + +fn f (x: Alias) -> V { + x.t +} + +fn main() { + let x: u32 = f(Wrapper { t: 1u32 }); +} diff --git a/gcc/testsuite/rust/compile/issues/4884.rs b/gcc/testsuite/rust/compile/issues/4884.rs new file mode 100644 index 000000000000..0ca80f14d568 --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/4884.rs @@ -0,0 +1,102 @@ +// { dg-options "-w" } + +#![feature(no_core, lang_items, unboxed_closures)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +pub enum Option { + None, + Some(T), +} + +#[lang = "fn_once"] +#[rustc_paren_sugar] +pub trait FnOnce { + #[lang = "fn_once_output"] + type Output; + extern "rust-call" fn call_once(self, args: Args) -> Self::Output; +} + +#[lang = "fn_mut"] +#[rustc_paren_sugar] +pub trait FnMut: FnOnce { + extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output; +} + +pub trait Iterator2 { + type Item; + fn next(&mut self) -> Option; +} + +pub trait SplitIter: Iterator2 { + fn finish(&mut self) -> Option; +} + +pub struct Split<'a, T, P> +where + P: FnMut(&T) -> bool, +{ + v: &'a [T], + pred: P, +} + +impl<'a, T, P> Iterator2 for Split<'a, T, P> +where + P: FnMut(&T) -> bool, +{ + type Item = &'a [T]; + fn next(&mut self) -> Option<&'a [T]> { + Option::None + } +} + +impl<'a, T, P> SplitIter for Split<'a, T, P> +where + P: FnMut(&T) -> bool, +{ + fn finish(&mut self) -> Option<&'a [T]> { + Option::None + } +} + +struct GenericSplitN { + iter: I, + count: usize, +} + +impl> Iterator2 for GenericSplitN { + type Item = T; + fn next(&mut self) -> Option { + match self.count { + 0 => Option::None, + _ => { + self.count -= 1; + self.iter.next() + } + } + } +} + +pub struct SplitN<'a, T, P> +where + P: FnMut(&T) -> bool, +{ + inner: GenericSplitN>, +} + +impl<'a, T, P> Iterator2 for SplitN<'a, T, P> +where + P: FnMut(&T) -> bool, +{ + type Item = &'a [T]; + + fn next(&mut self) -> Option<&'a [T]> { + self.inner.next() + } +} + +fn main() -> i32 { + 0 +} From 580fc1cb29cafe2d29d53ec4c308065a2e35dd72 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 18 Sep 2026 19:00:40 +0100 Subject: [PATCH 562/584] gccrs: Add flag to unify of expect never Fixes Rust-GCC/gccrs#4918 gcc/rust/ChangeLog: * typecheck/rust-coercion.cc (TypeCoercionRules::TryCoerce): add flag (TypeCoercionRules::TypeCoercionRules): Likewise. (TypeCoercionRules::do_coercion): Likewise. (TypeCoercionRules::coerce_unsafe_ptr): Likewise. (TypeCoercionRules::coerce_borrowed_pointer): Likewise. (TypeCoercionRules::select): Likewise. * typecheck/rust-coercion.h: Likewise. * typecheck/rust-hir-dot-operator.cc (MethodResolver::try_select_predicate_candidates): Likewise. * typecheck/rust-type-util.cc (unify_site_and): Likewise. * typecheck/rust-type-util.h (unify_site_and): Likewise. * typecheck/rust-unify.cc (UnifyRules::UnifyRules): Likewise. (UnifyRules::Resolve): Likewise. (UnifyRules::resolve_subtype): Likewise. (UnifyRules::expect_never): Likewise. * typecheck/rust-unify.h: Likewise. gcc/testsuite/ChangeLog: * rust/compile/issues/4918.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-coercion.cc | 23 +++++++++----- gcc/rust/typecheck/rust-coercion.h | 6 ++-- gcc/rust/typecheck/rust-hir-dot-operator.cc | 12 ++++++-- gcc/rust/typecheck/rust-type-util.cc | 5 ++-- gcc/rust/typecheck/rust-type-util.h | 3 +- gcc/rust/typecheck/rust-unify.cc | 24 ++++++++++----- gcc/rust/typecheck/rust-unify.h | 6 ++-- gcc/testsuite/rust/compile/issues/4918.rs | 33 +++++++++++++++++++++ 8 files changed, 86 insertions(+), 26 deletions(-) create mode 100644 gcc/testsuite/rust/compile/issues/4918.rs diff --git a/gcc/rust/typecheck/rust-coercion.cc b/gcc/rust/typecheck/rust-coercion.cc index 4df9934d81c5..9d4de57db752 100644 --- a/gcc/rust/typecheck/rust-coercion.cc +++ b/gcc/rust/typecheck/rust-coercion.cc @@ -37,10 +37,11 @@ TypeCoercionRules::Coerce (TyTy::BaseType *receiver, TyTy::BaseType *expected, TypeCoercionRules::CoercionResult TypeCoercionRules::TryCoerce (TyTy::BaseType *receiver, TyTy::BaseType *expected, location_t locus, - bool allow_autoderef, bool is_cast_site) + bool allow_autoderef, bool is_cast_site, + bool allow_never_coercion) { TypeCoercionRules resolver (expected, locus, false, allow_autoderef, true, - is_cast_site); + is_cast_site, allow_never_coercion); bool ok = resolver.do_coercion (receiver); return ok ? resolver.try_result : CoercionResult::get_error (); } @@ -48,11 +49,13 @@ TypeCoercionRules::TryCoerce (TyTy::BaseType *receiver, TypeCoercionRules::TypeCoercionRules (TyTy::BaseType *expected, location_t locus, bool emit_errors, bool allow_autoderef, bool try_flag, - bool is_cast_site) + bool is_cast_site, + bool allow_never_coercion) : AutoderefCycle (!allow_autoderef), mappings (Analysis::Mappings::get ()), context (TypeCheckContext::get ()), expected (expected), locus (locus), try_result (CoercionResult::get_error ()), emit_errors (emit_errors), - try_flag (try_flag), is_cast_site (is_cast_site) + try_flag (try_flag), is_cast_site (is_cast_site), + allow_never_coercion (allow_never_coercion) {} bool @@ -121,7 +124,8 @@ TypeCoercionRules::do_coercion (TyTy::BaseType *receiver) TyTy::TyWithLocation (receiver), locus /*unify_locus*/, false /*emit_errors*/, !try_flag /*commit_if_ok*/, try_flag /*infer*/, - try_flag /*cleanup on error*/); + try_flag /*cleanup on error*/, + true /*check_bounds*/, allow_never_coercion); if (result->get_kind () != TyTy::TypeKind::ERROR) { try_result = CoercionResult{{}, result}; @@ -248,7 +252,8 @@ TypeCoercionRules::coerce_unsafe_ptr (TyTy::BaseType *receiver, locus /*unify_locus*/, !try_flag /*emit_errors*/, !try_flag /*commit_if_ok*/, try_flag && !is_cast_site /*infer*/, - try_flag /*cleanup on error*/); + try_flag /*cleanup on error*/, true /*check_bounds*/, + allow_never_coercion); bool unsafe_ptr_coerceion_ok = result->get_kind () != TyTy::TypeKind::ERROR; if (unsafe_ptr_coerceion_ok) return CoercionResult{{}, result}; @@ -284,7 +289,8 @@ TypeCoercionRules::coerce_borrowed_pointer (TyTy::BaseType *receiver, TyTy::TyWithLocation (expected), locus, false /*emit_errors*/, !try_flag /*commit_if_ok*/, try_flag /* infer */, - try_flag /*cleanup_on_failure*/); + try_flag /*cleanup_on_failure*/, + true /*check_bounds*/, allow_never_coercion); bool default_coerceion_ok = result->get_kind () != TyTy::TypeKind::ERROR; if (default_coerceion_ok) @@ -625,7 +631,8 @@ TypeCoercionRules::select (TyTy::BaseType &autoderefed) TyTy::TyWithLocation (&autoderefed), UNDEF_LOCATION /* locus */, false /*emit_errors*/, !try_flag /*commit_if_ok*/, try_flag /*infer*/, - try_flag /*cleanup*/); + try_flag /*cleanup*/, true /*check_bounds*/, + allow_never_coercion); bool ok = result->get_kind () != TyTy::TypeKind::ERROR; if (!ok) return false; diff --git a/gcc/rust/typecheck/rust-coercion.h b/gcc/rust/typecheck/rust-coercion.h index 0674cf5df568..be5daf39f2a6 100644 --- a/gcc/rust/typecheck/rust-coercion.h +++ b/gcc/rust/typecheck/rust-coercion.h @@ -56,7 +56,8 @@ class TypeCoercionRules : protected AutoderefCycle static CoercionResult TryCoerce (TyTy::BaseType *receiver, TyTy::BaseType *expected, location_t locus, bool allow_autoderef, - bool is_cast_site = false); + bool is_cast_site = false, + bool allow_never_coercion = true); CoercionResult coerce_never (TyTy::BaseType *receiver); CoercionResult coerce_unsafe_ptr (TyTy::BaseType *receiver, @@ -82,7 +83,7 @@ class TypeCoercionRules : protected AutoderefCycle protected: TypeCoercionRules (TyTy::BaseType *expected, location_t locus, bool emit_errors, bool allow_autoderef, bool try_flag, - bool is_cast_site); + bool is_cast_site, bool allow_never_coercion = true); bool select (TyTy::BaseType &autoderefed) override; @@ -124,6 +125,7 @@ class TypeCoercionRules : protected AutoderefCycle bool emit_errors; bool try_flag; bool is_cast_site; + bool allow_never_coercion; }; } // namespace Resolver diff --git a/gcc/rust/typecheck/rust-hir-dot-operator.cc b/gcc/rust/typecheck/rust-hir-dot-operator.cc index 06d9aa88ecb5..24b8b8ccc172 100644 --- a/gcc/rust/typecheck/rust-hir-dot-operator.cc +++ b/gcc/rust/typecheck/rust-hir-dot-operator.cc @@ -364,7 +364,9 @@ MethodResolver::try_select_predicate_candidates (TyTy::BaseType &receiver) auto res = TypeCoercionRules::TryCoerce (&receiver, fn_self, UNDEF_LOCATION, - false /*allow-autoderef*/); + false /*allow-autoderef*/, + false /*is_cast_site*/, + false /*allow_never_coercion*/); bool ok = !res.is_error (); if (ok) { @@ -415,7 +417,9 @@ MethodResolver::try_select_inherent_impl_candidates ( auto res = TypeCoercionRules::TryCoerce (&receiver, fn_self, UNDEF_LOCATION, - false /*allow-autoderef*/); + false /*allow-autoderef*/, + false /*is_cast_site*/, + false /*allow_never_coercion*/); bool ok = !res.is_error (); if (ok) { @@ -451,7 +455,9 @@ MethodResolver::try_select_trait_impl_candidates ( auto res = TypeCoercionRules::TryCoerce (&receiver, fn_self, UNDEF_LOCATION, - false /*allow-autoderef*/); + false /*allow-autoderef*/, + false /*is_cast_site*/, + false /*allow_never_coercion*/); bool ok = !res.is_error (); if (ok) { diff --git a/gcc/rust/typecheck/rust-type-util.cc b/gcc/rust/typecheck/rust-type-util.cc index 2234f89e0e03..7df36f0d3cff 100644 --- a/gcc/rust/typecheck/rust-type-util.cc +++ b/gcc/rust/typecheck/rust-type-util.cc @@ -281,7 +281,8 @@ unify_site (HirId id, TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs, TyTy::BaseType * unify_site_and (HirId id, TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs, location_t unify_locus, bool emit_errors, bool commit_if_ok, - bool implicit_infer_vars, bool cleanup, bool check_bounds) + bool implicit_infer_vars, bool cleanup, bool check_bounds, + bool allow_never_coercion) { TypeCheckContext &context = *TypeCheckContext::get (); @@ -301,7 +302,7 @@ unify_site_and (HirId id, TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs, TyTy::BaseType *result = UnifyRules::Resolve (lhs, rhs, unify_locus, false /*commit inline*/, emit_errors, check_bounds, implicit_infer_vars, - commits, infers); + commits, infers, nullptr, allow_never_coercion); bool ok = result->get_kind () != TyTy::TypeKind::ERROR; rust_debug_loc (unify_locus, diff --git a/gcc/rust/typecheck/rust-type-util.h b/gcc/rust/typecheck/rust-type-util.h index 860f23cfc1ef..89687d9f2f1f 100644 --- a/gcc/rust/typecheck/rust-type-util.h +++ b/gcc/rust/typecheck/rust-type-util.h @@ -38,7 +38,8 @@ TyTy::BaseType *unify_site_and (HirId id, TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs, location_t unify_locus, bool emit_errors, bool commit_if_ok, bool implicit_infer_vars, - bool cleanup, bool check_bounds = true); + bool cleanup, bool check_bounds = true, + bool allow_never_coercion = true); TyTy::BaseType *coercion_site (HirId id, TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs, diff --git a/gcc/rust/typecheck/rust-unify.cc b/gcc/rust/typecheck/rust-unify.cc index 417804b447bb..db6dabcf8d39 100644 --- a/gcc/rust/typecheck/rust-unify.cc +++ b/gcc/rust/typecheck/rust-unify.cc @@ -39,12 +39,13 @@ UnifyRules::UnifyRules (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs, bool check_bounds, bool infer, std::vector &commits, std::vector &infers, - ActiveADTs &active_adts) + ActiveADTs &active_adts, bool allow_never_coercion) : lhs (lhs), rhs (rhs), locus (locus), commit_flag (commit_flag), emit_error (emit_error), infer_flag (infer), - check_bounds_flag (check_bounds), commits (commits), infers (infers), - active_adts (active_adts), mappings (Analysis::Mappings::get ()), - context (*TypeCheckContext::get ()) + check_bounds_flag (check_bounds), + allow_never_coercion (allow_never_coercion), commits (commits), + infers (infers), active_adts (active_adts), + mappings (Analysis::Mappings::get ()), context (*TypeCheckContext::get ()) {} TyTy::BaseType * @@ -53,14 +54,14 @@ UnifyRules::Resolve (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs, bool check_bounds, bool infer, std::vector &commits, std::vector &infers, - ActiveADTs *active_adts) + ActiveADTs *active_adts, bool allow_never_coercion) { ActiveADTs root_active_adts; if (active_adts == nullptr) active_adts = &root_active_adts; UnifyRules r (lhs, rhs, locus, commit_flag, emit_error, check_bounds, infer, - commits, infers, *active_adts); + commits, infers, *active_adts, allow_never_coercion); TyTy::BaseType *result = r.go (); bool failed = result->get_kind () == TyTy::TypeKind::ERROR; @@ -84,7 +85,7 @@ UnifyRules::resolve_subtype (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs) TyTy::BaseType *result = UnifyRules::Resolve (lhs, rhs, locus, commit_flag, emit_error, check_bounds_flag, infer_flag, commits, infers, - &active_adts); + &active_adts, allow_never_coercion); // If the recursive call resulted in an error and would have emitted an error // message, disable error emission for the current level to avoid duplicate @@ -1835,8 +1836,15 @@ UnifyRules::expect_never (TyTy::NeverType *ltype, TyTy::BaseType *rtype) } break; + case TyTy::NEVER: + return ltype; + default: - return rtype; + { + if (allow_never_coercion) + return rtype; + } + break; } return unify_error_type_node (); } diff --git a/gcc/rust/typecheck/rust-unify.h b/gcc/rust/typecheck/rust-unify.h index 2091bd1b14bc..29938cfffca7 100644 --- a/gcc/rust/typecheck/rust-unify.h +++ b/gcc/rust/typecheck/rust-unify.h @@ -90,7 +90,7 @@ class UnifyRules Resolve (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs, location_t locus, bool commit_flag, bool emit_error, bool check_bounds, bool infer, std::vector &commits, std::vector &infers, - ActiveADTs *active_adts = nullptr); + ActiveADTs *active_adts = nullptr, bool allow_never_coercion = true); static void commit (TyTy::BaseType *base, TyTy::BaseType *other, TyTy::BaseType *resolved); @@ -135,7 +135,8 @@ class UnifyRules UnifyRules (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs, location_t locus, bool commit_flag, bool emit_error, bool infer, bool check_bounds, std::vector &commits, - std::vector &infers, ActiveADTs &active_adts); + std::vector &infers, ActiveADTs &active_adts, + bool allow_never_coercion); TyTy::BaseType *resolve_subtype (TyTy::TyWithLocation lhs, TyTy::TyWithLocation rhs); @@ -156,6 +157,7 @@ class UnifyRules bool emit_error; bool infer_flag; bool check_bounds_flag; + bool allow_never_coercion; std::vector &commits; std::vector &infers; diff --git a/gcc/testsuite/rust/compile/issues/4918.rs b/gcc/testsuite/rust/compile/issues/4918.rs new file mode 100644 index 000000000000..b378d1b35641 --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/4918.rs @@ -0,0 +1,33 @@ +#![feature(no_core, lang_items)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +pub enum Ordering { + Less, + Equal, + Greater, +} + +pub trait Ord { + fn cmp(&self, other: &Self) -> Ordering; +} + +impl Ord for i32 { + fn cmp(&self, _other: &i32) -> Ordering { + Ordering::Equal + } +} + +impl Ord for ! { + fn cmp(&self, _other: &!) -> Ordering { + Ordering::Equal + } +} + +fn main() { + let left: i32 = 1; + let right: i32 = 2; + let _ = left.cmp(&right); +} From 5eaaa040f23d35c1cebc6d925d5a4a863e363183 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Tue, 8 Sep 2026 13:25:59 +0100 Subject: [PATCH 563/584] gccrs: Add type bound predicate scan This patch is used to address where constraints on projections for example fn test When we do fn test --- gcc/rust/typecheck/rust-hir-dot-operator.cc | 6 +- .../typecheck/rust-hir-path-probe-expr.cc | 2 +- .../typecheck/rust-hir-path-probe-type.cc | 2 +- .../typecheck/rust-hir-type-check-type.cc | 2 + gcc/rust/typecheck/rust-hir-type-check.h | 2 + gcc/rust/typecheck/rust-typecheck-context.cc | 81 +++++++++++++++++++ gcc/rust/typecheck/rust-tyty.cc | 12 +-- gcc/rust/typecheck/rust-tyty.h | 8 +- gcc/testsuite/rust/compile/issues/4865-1.rs | 16 ++++ gcc/testsuite/rust/compile/issues/4865-2.rs | 20 +++++ .../rust/compile/projection-bound-decl-id.rs | 14 ++++ 11 files changed, 153 insertions(+), 12 deletions(-) create mode 100644 gcc/testsuite/rust/compile/issues/4865-1.rs create mode 100644 gcc/testsuite/rust/compile/issues/4865-2.rs create mode 100644 gcc/testsuite/rust/compile/projection-bound-decl-id.rs diff --git a/gcc/rust/typecheck/rust-hir-dot-operator.cc b/gcc/rust/typecheck/rust-hir-dot-operator.cc index 24b8b8ccc172..9a125eb7bbf7 100644 --- a/gcc/rust/typecheck/rust-hir-dot-operator.cc +++ b/gcc/rust/typecheck/rust-hir-dot-operator.cc @@ -106,7 +106,7 @@ MethodResolver::try_hook (const TyTy::BaseType &r) { rust_debug ("MethodResolver::try_hook get_predicate_items: [%s]", r.debug_str ().c_str ()); - const auto &specified_bounds = r.get_specified_bounds (); + auto specified_bounds = context->predicates_for_type (&r); predicate_items = get_predicate_items (segment_name, r, specified_bounds); if (predicate_items.size () > 0) @@ -117,14 +117,14 @@ MethodResolver::try_hook (const TyTy::BaseType &r) const auto &ref = static_cast (r); const auto &element = ref.get_var_element_type (); const auto &element_ty = *element.get_tyty (); - const auto &specified_bounds = element_ty.get_specified_bounds (); + auto specified_bounds = context->predicates_for_type (&element_ty); predicate_items = get_predicate_items (segment_name, element_ty, specified_bounds); } else if (auto inner = TyTy::try_get_box_inner_type (const_cast (&r))) { - const auto &specified_bounds = (*inner)->get_specified_bounds (); + auto specified_bounds = context->predicates_for_type (*inner); predicate_items = get_predicate_items (segment_name, **inner, specified_bounds); } diff --git a/gcc/rust/typecheck/rust-hir-path-probe-expr.cc b/gcc/rust/typecheck/rust-hir-path-probe-expr.cc index d95c931b1aa8..461f60eaa6c2 100644 --- a/gcc/rust/typecheck/rust-hir-path-probe-expr.cc +++ b/gcc/rust/typecheck/rust-hir-path-probe-expr.cc @@ -193,7 +193,7 @@ PathProbeExpr::probe_bounds () } for (const TyTy::TypeBoundPredicate &predicate : - receiver->get_specified_bounds ()) + context->predicates_for_type (receiver)) { process_predicate_for_candidates (predicate); } diff --git a/gcc/rust/typecheck/rust-hir-path-probe-type.cc b/gcc/rust/typecheck/rust-hir-path-probe-type.cc index 79179627daed..7b18bb80d5fb 100644 --- a/gcc/rust/typecheck/rust-hir-path-probe-type.cc +++ b/gcc/rust/typecheck/rust-hir-path-probe-type.cc @@ -60,7 +60,7 @@ void TypePathProbe::probe_generic () { for (const TyTy::TypeBoundPredicate &predicate : - receiver->get_specified_bounds ()) + TypeCheckContext::get ()->predicates_for_type (receiver)) { auto candidate = process_predicate_for_candidates (predicate); insert_candidate (std::move (candidate)); diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.cc b/gcc/rust/typecheck/rust-hir-type-check-type.cc index 8bf304fa0efc..7ff160b148b6 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-type.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-type.cc @@ -892,6 +892,7 @@ TypeResolveGenericParam::visit (HIR::TypeParam ¶m) resolved = new TyTy::ParamType (param.get_type_representation ().as_string (), param.get_locus (), + param.get_mappings ().get_hirid (), param.get_mappings ().get_hirid (), {}); if (resolve_trait_bounds) @@ -912,6 +913,7 @@ TypeResolveGenericParam::apply_trait_bounds (HIR::TypeParam ¶m, TyTy::ParamType *p = new TyTy::ParamType (param.get_type_representation ().as_string (), param.get_locus (), implicit_id, + pty->get_decl_id (), {} /*empty specified bounds*/); context->insert_implicit_type (implicit_id, p); diff --git a/gcc/rust/typecheck/rust-hir-type-check.h b/gcc/rust/typecheck/rust-hir-type-check.h index c9572b13c0b1..41e02bb00ffa 100644 --- a/gcc/rust/typecheck/rust-hir-type-check.h +++ b/gcc/rust/typecheck/rust-hir-type-check.h @@ -311,6 +311,8 @@ class TypeCheckContext void insert_resolved_predicate (HirId id, const TyTy::TypeBoundPredicate &predicate); bool lookup_predicate (HirId id, TyTy::TypeBoundPredicate *result); + std::vector + predicates_for_type (const TyTy::BaseType *receiver) const; void insert_query (HirId id); void query_completed (HirId id); diff --git a/gcc/rust/typecheck/rust-typecheck-context.cc b/gcc/rust/typecheck/rust-typecheck-context.cc index fe6bc888cc52..440b8b8050f3 100644 --- a/gcc/rust/typecheck/rust-typecheck-context.cc +++ b/gcc/rust/typecheck/rust-typecheck-context.cc @@ -644,6 +644,87 @@ TypeCheckContext::lookup_predicate (HirId id, TyTy::TypeBoundPredicate *result) return true; } +std::vector +TypeCheckContext::predicates_for_type (const TyTy::BaseType *receiver) const +{ + std::vector result + = receiver->get_specified_bounds (); + + for (const auto &entry : predicates) + { + const auto &predicate = entry.second; + const auto &args = predicate.get_substitution_arguments (); + if (args.get_mappings ().empty ()) + continue; + + TyTy::BaseType *bound_self = args.get_mappings ().front ().get_tyty (); + if (bound_self == nullptr + || bound_self->get_kind () == TyTy::TypeKind::ERROR) + continue; + + if (receiver->get_kind () != TyTy::TypeKind::PROJECTION + || bound_self->get_kind () != TyTy::TypeKind::PROJECTION) + continue; + + const auto *receiver_projection + = static_cast (receiver); + const auto *bound_projection + = static_cast (bound_self); + + DefId receiver_item_defid = receiver_projection->get_item_defid (); + DefId bound_item_defid = bound_projection->get_item_defid (); + bool same_item = receiver_item_defid == bound_item_defid; + if (!same_item) + continue; + + DefId receiver_trait_defid + = receiver_projection->get_trait_ref ()->get_mappings ().get_defid (); + DefId bound_trait_defid + = bound_projection->get_trait_ref ()->get_mappings ().get_defid (); + bool same_trait = receiver_trait_defid == bound_trait_defid; + if (!same_trait) + continue; + + // Compatibility can unify unrelated parameters. Match their declaration + // identities instead; copies and synthetic bound parameters retain them. + const TyTy::BaseType *receiver_self = receiver_projection->get_self (); + const TyTy::BaseType *bound_self_ty = bound_projection->get_self (); + const auto *receiver_param + = receiver_self->try_as (); + const auto *bound_param = bound_self_ty->try_as (); + + bool either_self_is_param + = receiver_param != nullptr || bound_param != nullptr; + if (either_self_is_param) + { + bool both_selfs_are_param + = receiver_param != nullptr && bound_param != nullptr; + bool same_declaration + = both_selfs_are_param + && receiver_param->get_decl_id () == bound_param->get_decl_id (); + if (!same_declaration) + continue; + } + else + { + bool selfs_compatible = types_compatable ( + TyTy::TyWithLocation (const_cast (receiver_self)), + TyTy::TyWithLocation (const_cast (bound_self_ty)), + UNKNOWN_LOCATION, false, false); + if (!selfs_compatible) + continue; + } + + bool projections_compatible = types_compatable ( + TyTy::TyWithLocation (const_cast (receiver)), + TyTy::TyWithLocation (bound_self), UNKNOWN_LOCATION, false, false); + if (projections_compatible) + result.push_back (predicate); + } + + return result; +} + void TypeCheckContext::insert_query (HirId id) { diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc index 93061b1fcf6f..a9b3dcc5e6ae 100644 --- a/gcc/rust/typecheck/rust-tyty.cc +++ b/gcc/rust/typecheck/rust-tyty.cc @@ -3742,24 +3742,25 @@ PointerType::handle_substitions (SubstitutionArgumentMappings &mappings) // PARAM Type ParamType::ParamType (std::string symbol, location_t locus, HirId ref, + HirId decl_id, std::vector specified_bounds, std::set refs) : BaseGeneric (ref, ref, KIND, {Resolver::CanonicalPath::new_seg (UNKNOWN_NODEID, symbol), locus}, std::move (specified_bounds), refs), - is_trait_self (false), symbol (symbol) + decl_id (decl_id), is_trait_self (false), symbol (symbol) {} ParamType::ParamType (bool is_trait_self, std::string symbol, location_t locus, - HirId ref, HirId ty_ref, + HirId ref, HirId ty_ref, HirId decl_id, std::vector specified_bounds, std::set refs) : BaseGeneric (ref, ty_ref, KIND, {Resolver::CanonicalPath::new_seg (UNKNOWN_NODEID, symbol), locus}, std::move (specified_bounds), refs), - is_trait_self (is_trait_self), symbol (symbol) + decl_id (decl_id), is_trait_self (is_trait_self), symbol (symbol) {} bool @@ -3814,11 +3815,12 @@ ParamType::clone () const bool cycle = Resolver::ScopedPush::contains (active, get_ty_ref ()); if (cycle) return new ParamType (is_trait_self, get_symbol (), ident.locus, get_ref (), - get_ty_ref (), {}, get_combined_refs ()); + get_ty_ref (), get_decl_id (), {}, + get_combined_refs ()); Resolver::ScopedPush guard (active, get_ty_ref ()); return new ParamType (is_trait_self, get_symbol (), ident.locus, get_ref (), - get_ty_ref (), get_specified_bounds (), + get_ty_ref (), get_decl_id (), get_specified_bounds (), get_combined_refs ()); } diff --git a/gcc/rust/typecheck/rust-tyty.h b/gcc/rust/typecheck/rust-tyty.h index c4f0ad59a658..98daa831bab8 100644 --- a/gcc/rust/typecheck/rust-tyty.h +++ b/gcc/rust/typecheck/rust-tyty.h @@ -515,12 +515,12 @@ class ParamType : public BaseGeneric public: static constexpr auto KIND = TypeKind::PARAM; - ParamType (std::string symbol, location_t locus, HirId ref, + ParamType (std::string symbol, location_t locus, HirId ref, HirId decl_id, std::vector specified_bounds, std::set refs = std::set ()); ParamType (bool is_trait_self, std::string symbol, location_t locus, - HirId ref, HirId ty_ref, + HirId ref, HirId ty_ref, HirId decl_id, std::vector specified_bounds, std::set refs = std::set ()); @@ -546,7 +546,11 @@ class ParamType : public BaseGeneric void set_implicit_self_trait (); bool is_implicit_self_trait () const; + HirId get_decl_id () const { return decl_id; } + private: + // Identity of the original HIR parameter, preserved through substitution. + const HirId decl_id; bool is_trait_self; std::string symbol; }; diff --git a/gcc/testsuite/rust/compile/issues/4865-1.rs b/gcc/testsuite/rust/compile/issues/4865-1.rs new file mode 100644 index 000000000000..f6bdcb274bd8 --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/4865-1.rs @@ -0,0 +1,16 @@ +#![feature(no_core, lang_items)] +#![no_core] +#[lang = "sized"] +pub trait Sized {} +trait Deref { + type Target: ?Sized; +} +trait PartialOrd { + fn gt(&self, rhs: &Rhs) -> bool; +} +pub fn compare(x: &P::Target, y: &Q::Target) -> bool +where + P::Target: PartialOrd, +{ + P::Target::gt(x, y) +} diff --git a/gcc/testsuite/rust/compile/issues/4865-2.rs b/gcc/testsuite/rust/compile/issues/4865-2.rs new file mode 100644 index 000000000000..a89bf67680ce --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/4865-2.rs @@ -0,0 +1,20 @@ +#![feature(no_core, lang_items)] +#![no_core] +#[lang = "sized"] +pub trait Sized {} +trait Deref { + type Target: ?Sized; +} +trait PartialOrd { + fn gt(&self, rhs: &Rhs) -> bool; +} +pub fn compare(x: &P::Target, y: &Q::Target) -> bool +where + P::Target: PartialOrd, +{ + P::Target::gt(x, y) +} +pub fn compare_unbounded(x: &R::Target, y: &S::Target) -> bool { + R::Target::gt(x, y) + // { dg-error "failed to resolve path segment using an impl Probe" "" { target *-*-* } .-1 } +} diff --git a/gcc/testsuite/rust/compile/projection-bound-decl-id.rs b/gcc/testsuite/rust/compile/projection-bound-decl-id.rs new file mode 100644 index 000000000000..96f057e23795 --- /dev/null +++ b/gcc/testsuite/rust/compile/projection-bound-decl-id.rs @@ -0,0 +1,14 @@ +// { dg-options "-w" } + +#![feature(no_core, lang_items)] +#![no_core] +#[lang = "sized"] +pub trait Sized {} +trait Source { type Item; } +trait Marker { fn check(&self); } +fn bounded(x: &T::Item) where T::Item: Marker { + T::Item::check(x); +} +fn unbounded(x: &T::Item) { + T::Item::check(x); // { dg-error "failed to resolve path segment" } +} From 917f0c392c2e909754e4d1a569ce28a522001783 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 18 Sep 2026 22:01:08 +0100 Subject: [PATCH 564/584] gccrs: Add missing lifetime handling to trait resolve Fixes Rust-GCC/gccrs#4912 gcc/rust/ChangeLog: * typecheck/rust-hir-trait-resolve.cc (TraitResolver::resolve_trait): add missing gcc/testsuite/ChangeLog: * rust/compile/issues/4912.rs: New test. Signed-off-by: Philip Herron --- gcc/rust/typecheck/rust-hir-trait-resolve.cc | 10 ++++++++++ gcc/testsuite/rust/compile/issues/4912.rs | 11 +++++++++++ 2 files changed, 21 insertions(+) create mode 100644 gcc/testsuite/rust/compile/issues/4912.rs diff --git a/gcc/rust/typecheck/rust-hir-trait-resolve.cc b/gcc/rust/typecheck/rust-hir-trait-resolve.cc index c80899979c23..b694521533d5 100644 --- a/gcc/rust/typecheck/rust-hir-trait-resolve.cc +++ b/gcc/rust/typecheck/rust-hir-trait-resolve.cc @@ -283,6 +283,8 @@ TraitResolver::resolve_trait (HIR::Trait *trait_reference) TyTy::BaseType *self = nullptr; std::vector substitutions; + auto lifetime_pin = context->push_clean_lifetime_resolver (); + // this needs to be special cased for the sized trait to not auto implemented // Sized on Self for (auto &generic_param : trait_reference->get_generic_params ()) @@ -290,6 +292,14 @@ TraitResolver::resolve_trait (HIR::Trait *trait_reference) switch (generic_param.get ()->get_kind ()) { case HIR::GenericParam::GenericKind::LIFETIME: + { + auto &lifetime_param + = static_cast (*generic_param); + context->intern_and_insert_lifetime ( + lifetime_param.get_lifetime ()); + } + break; + case HIR::GenericParam::GenericKind::CONST: // FIXME: Skipping Lifetime and Const completely until better // handling. diff --git a/gcc/testsuite/rust/compile/issues/4912.rs b/gcc/testsuite/rust/compile/issues/4912.rs new file mode 100644 index 000000000000..4c3571331918 --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/4912.rs @@ -0,0 +1,11 @@ +#![feature(no_core, lang_items)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +pub trait Searcher<'a> {} + +pub trait ReverseSearcher<'a>: Searcher<'a> {} + +fn main() {} From 64f86557bac6ba7e1721bd3ab112d795f506d2d1 Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Fri, 18 Sep 2026 22:07:06 +0100 Subject: [PATCH 565/584] gccrs: fix unconstrained check to look for constrained bindings Fixes Rust-GCC/gccrs#4911 gcc/rust/ChangeLog: * typecheck/rust-hir-type-check-base.cc (walk_type_to_constrain): walk binding args gcc/testsuite/ChangeLog: * rust/compile/issues/4911.rs: New test. Signed-off-by: Philip Herron --- .../typecheck/rust-hir-type-check-base.cc | 11 +++++++ gcc/testsuite/rust/compile/issues/4911.rs | 29 +++++++++++++++++++ 2 files changed, 40 insertions(+) create mode 100644 gcc/testsuite/rust/compile/issues/4911.rs diff --git a/gcc/rust/typecheck/rust-hir-type-check-base.cc b/gcc/rust/typecheck/rust-hir-type-check-base.cc index 52a3536245a1..f5f457f60203 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-base.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-base.cc @@ -170,6 +170,15 @@ walk_type_to_constrain (std::set &constrained_symbols, TyTy::BaseType &r) if (r.has_substitutions_defined ()) walk_types_to_constrain (constrained_symbols, r.get_subst_argument_mappings ()); + + for (const auto &bound : r.get_specified_bounds ()) + { + const auto &args = bound.get_substitution_arguments (); + for (const auto &binding : args.get_binding_args ()) + walk_type_to_constrain (constrained_symbols, *binding.second); + for (const auto &constraint : args.get_constraint_args ()) + walk_type_to_constrain (constrained_symbols, *constraint.second); + } } bool @@ -209,6 +218,8 @@ TypeCheckBase::check_for_unconstrained ( const auto &args = bound.get_substitution_arguments (); for (const auto &binding : args.get_binding_args ()) walk_type_to_constrain (constrained_symbols, *binding.second); + for (const auto &constraint : args.get_constraint_args ()) + walk_type_to_constrain (constrained_symbols, *constraint.second); } } diff --git a/gcc/testsuite/rust/compile/issues/4911.rs b/gcc/testsuite/rust/compile/issues/4911.rs new file mode 100644 index 000000000000..229dbf5895fd --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/4911.rs @@ -0,0 +1,29 @@ +// { dg-options "-w" } +#![feature(lang_items, no_core)] +#![no_core] + +#[lang = "sized"] +pub trait Sized {} + +pub trait Iterator2 { + type Item; +} + +pub trait IntoIterator2 { + type IntoIter; + type Item; +} + +pub struct Flatten> { + inner: I, +} + +impl Iterator2 for Flatten +where + I: Iterator2>, + U: Iterator2, +{ + type Item = U; +} + +fn main() {} From de0a759305e3063b0ab7f9657f00b3e63796a45a Mon Sep 17 00:00:00 2001 From: Yap Zhi Heng Date: Sun, 20 Sep 2026 23:03:39 +0800 Subject: [PATCH 566/584] gccrs: Remove -frust-c-style-string-literals flag This is replaced with -frust-compat-version=<1.64 instead. gcc/rust/ChangeLog: * lang.opt: Remove frust-c-style-string-literals option. * rust-session-manager.h (Session): New should_support_cstr_parsing function. * parse/rust-parse-impl-expr.hxx (Parser::parse_literal_expr): Replace old flag_c_style_string_literals check with should_support_cstr_parsing. (Parser::null_denotation_not_path): Likewise. * parse/rust-parse.h: Import rust-session-manager.h to access Session class. gcc/testsuite/ChangeLog: * rust/compile/c_string_null_byte_check.rs: Remove frust-c-style-string-literals from compilation options. * rust/execute/torture/c_string_ensure_null_term.rs: Likewise. * rust/execute/torture/c_string.rs: Likewise. Signed-off-by: Yap Zhi Heng --- gcc/rust/lang.opt | 4 ---- gcc/rust/parse/rust-parse-impl-expr.hxx | 8 ++++---- gcc/rust/parse/rust-parse.h | 1 + gcc/rust/rust-session-manager.h | 5 +++++ gcc/testsuite/rust/compile/c_string_null_byte_check.rs | 2 +- gcc/testsuite/rust/execute/torture/c_string.rs | 2 +- .../rust/execute/torture/c_string_ensure_null_term.rs | 2 +- 7 files changed, 13 insertions(+), 11 deletions(-) diff --git a/gcc/rust/lang.opt b/gcc/rust/lang.opt index f996ec0f0a58..a94fd0f893b0 100644 --- a/gcc/rust/lang.opt +++ b/gcc/rust/lang.opt @@ -237,8 +237,4 @@ frust-unused-check-2.0 Rust Var(flag_unused_check_2_0) Use the new unused variable check implementation. -frust-c-style-string-literals -Rust Var(flag_c_style_string_literals) -Enable parsing and compilation of C-styled string literals. - ; This comment is to ensure we retain the blank line above. diff --git a/gcc/rust/parse/rust-parse-impl-expr.hxx b/gcc/rust/parse/rust-parse-impl-expr.hxx index 127b2c7a2fd7..f42bf9a13cf2 100644 --- a/gcc/rust/parse/rust-parse-impl-expr.hxx +++ b/gcc/rust/parse/rust-parse-impl-expr.hxx @@ -344,7 +344,7 @@ Parser::parse_literal_expr (AST::AttrVec outer_attrs) break; case C_STRING_LITERAL: { - if (flag_c_style_string_literals) + if (Session::get_instance ().should_support_cstr_parsing ()) { type = AST::Literal::C_STRING; literal_value = t->get_str (); @@ -356,7 +356,7 @@ Parser::parse_literal_expr (AST::AttrVec outer_attrs) Error (t->get_locus (), "unexpected token %qs when parsing literal expression - " "C-style string literals require " - "%<-frust-c-style-string-literals%> to be enabled", + "%<-frust-compat-version%> to be set to least 1.64", t->get_token_description ())); return tl::unexpected ( Parse::Error::Node::MALFORMED); @@ -2134,7 +2134,7 @@ Parser::null_denotation_not_path ( new AST::LiteralExpr (tok->get_str (), AST::Literal::RAW_STRING, tok->get_type_hint (), {}, tok->get_locus ())); case C_STRING_LITERAL: - if (flag_c_style_string_literals) + if (Session::get_instance ().should_support_cstr_parsing ()) { return std::unique_ptr ( new AST::LiteralExpr (tok->get_str (), AST::Literal::C_STRING, @@ -2145,7 +2145,7 @@ Parser::null_denotation_not_path ( { Error error (tok->get_locus (), "C-style string literals require " - "%<-frust-c-style-string-literals%> to be enabled"); + "%<-frust-compat-version%> to be set to least 1.64"); add_error (std::move (error)); return tl::unexpected ( Parse::Error::Expr::MALFORMED); diff --git a/gcc/rust/parse/rust-parse.h b/gcc/rust/parse/rust-parse.h index 7b0da58c5cbb..4b389a827642 100644 --- a/gcc/rust/parse/rust-parse.h +++ b/gcc/rust/parse/rust-parse.h @@ -26,6 +26,7 @@ along with GCC; see the file COPYING3. If not see #include "rust-parse-utils.h" #include "rust-feature.h" #include "rust-feature-store.h" +#include "rust-session-manager.h" #include "expected.h" #include "options.h" diff --git a/gcc/rust/rust-session-manager.h b/gcc/rust/rust-session-manager.h index 9f0209b90fdd..6a0acda7c1a2 100644 --- a/gcc/rust/rust-session-manager.h +++ b/gcc/rust/rust-session-manager.h @@ -507,6 +507,11 @@ struct Session int get_compat_version () const { return options.get_compat_version (); } + bool should_support_cstr_parsing () const + { + return get_compat_version () >= 64; + } + bool should_support_offset_of () const { return get_compat_version () >= 71; } bool should_support_cfg_select () const diff --git a/gcc/testsuite/rust/compile/c_string_null_byte_check.rs b/gcc/testsuite/rust/compile/c_string_null_byte_check.rs index 57dfe8623cae..2b4f4bdd1c71 100644 --- a/gcc/testsuite/rust/compile/c_string_null_byte_check.rs +++ b/gcc/testsuite/rust/compile/c_string_null_byte_check.rs @@ -1,4 +1,4 @@ -// { dg-additional-options "-frust-c-style-string-literals -frust-compat-version=1.90" } +// { dg-additional-options "-frust-compat-version=1.90" } #![feature(no_core, lang_items)] #![no_core] diff --git a/gcc/testsuite/rust/execute/torture/c_string.rs b/gcc/testsuite/rust/execute/torture/c_string.rs index be90e4e1c34c..b8d60cac87d6 100644 --- a/gcc/testsuite/rust/execute/torture/c_string.rs +++ b/gcc/testsuite/rust/execute/torture/c_string.rs @@ -1,4 +1,4 @@ -// { dg-additional-options "-frust-c-style-string-literals -frust-compat-version=1.90" } +// { dg-additional-options "-frust-compat-version=1.90" } // { dg-output "gccrs" } #![feature(no_core, lang_items)] #![no_core] diff --git a/gcc/testsuite/rust/execute/torture/c_string_ensure_null_term.rs b/gcc/testsuite/rust/execute/torture/c_string_ensure_null_term.rs index 488d9fdcd5a4..2ba0d06efe92 100644 --- a/gcc/testsuite/rust/execute/torture/c_string_ensure_null_term.rs +++ b/gcc/testsuite/rust/execute/torture/c_string_ensure_null_term.rs @@ -1,4 +1,4 @@ -// { dg-additional-options "-frust-c-style-string-literals -frust-compat-version=1.90" } +// { dg-additional-options "-frust-compat-version=1.90" } #![feature(no_core, intrinsics, staged_api, lang_items)] #![no_core] From 4855bb84e0f3cd39a8efd2daac910ab1e1c08f44 Mon Sep 17 00:00:00 2001 From: Owen Avery Date: Sun, 20 Sep 2026 18:53:30 -0400 Subject: [PATCH 567/584] gccrs: Ignore bindings on bodyless functions Functions without bodies can have different parameters with the same name. gcc/rust/ChangeLog: * resolve/rust-late-name-resolver-2.0.cc (Late::Late): Initialize in_bodyless_params. (Late::visit (FunctionParam)): New function definition, skip visiting the patterns of function parameters on bodyless functions. (Late::visit_function_params): Set in_bodyless_params. * resolve/rust-late-name-resolver-2.0.h (Late::visit (FunctionParam)): New function declaration. (Late::in_bodyless_params): New member variable. gcc/testsuite/ChangeLog: * rust/compile/multiple_bindings3.rs: New test. Signed-off-by: Owen Avery --- .../resolve/rust-late-name-resolver-2.0.cc | 21 ++++++++++++++++++- .../resolve/rust-late-name-resolver-2.0.h | 3 +++ .../rust/compile/multiple_bindings3.rs | 10 +++++++++ 3 files changed, 33 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/rust/compile/multiple_bindings3.rs diff --git a/gcc/rust/resolve/rust-late-name-resolver-2.0.cc b/gcc/rust/resolve/rust-late-name-resolver-2.0.cc index e910c7e3b266..b568b19b0e51 100644 --- a/gcc/rust/resolve/rust-late-name-resolver-2.0.cc +++ b/gcc/rust/resolve/rust-late-name-resolver-2.0.cc @@ -37,7 +37,8 @@ namespace Rust { namespace Resolver2_0 { Late::Late (NameResolutionContext &ctx) - : DefaultResolver (ctx), funny_error (false), block_big_self (false) + : DefaultResolver (ctx), funny_error (false), block_big_self (false), + in_bodyless_params (false) {} void @@ -226,15 +227,33 @@ Late::visit (AST::AltPattern &pattern) ctx.bindings.peek ().merge (); } +void +Late::visit (AST::FunctionParam ¶m) +{ + visit_outer_attrs (param); + // we can't handle bindings for bodyless functions + // since, ex, `fn foo (a: i32, a: f64);` is valid + // (parameter names are ignored) + if (param.has_name () && !in_bodyless_params) + visit (param.get_pattern ()); + + visit (param.get_type ()); +} + void Late::visit_function_params (AST::Function &function) { + bool was_in_bodyless_params = in_bodyless_params; + in_bodyless_params = !function.has_body (); + ctx.bindings.enter (BindingSource::Param); for (auto ¶m : function.get_function_params ()) visit (param); ctx.bindings.exit (); + + in_bodyless_params = was_in_bodyless_params; } void diff --git a/gcc/rust/resolve/rust-late-name-resolver-2.0.h b/gcc/rust/resolve/rust-late-name-resolver-2.0.h index 38785633448c..04bb0b9d756e 100644 --- a/gcc/rust/resolve/rust-late-name-resolver-2.0.h +++ b/gcc/rust/resolve/rust-late-name-resolver-2.0.h @@ -39,6 +39,7 @@ class Late : public DefaultResolver // Specialized visit bits void visit_function_params (AST::Function &function) override; + void visit (AST::FunctionParam &) override; // some more label declarations void visit (AST::LetStmt &) override; @@ -79,6 +80,8 @@ class Late : public DefaultResolver /* used to prevent "impl Self {}", "impl (Self, i32) {}", etc */ bool block_big_self; + + bool in_bodyless_params; }; // TODO: Add missing mappings and data structures diff --git a/gcc/testsuite/rust/compile/multiple_bindings3.rs b/gcc/testsuite/rust/compile/multiple_bindings3.rs new file mode 100644 index 000000000000..25bcb859f3ce --- /dev/null +++ b/gcc/testsuite/rust/compile/multiple_bindings3.rs @@ -0,0 +1,10 @@ +#![feature(no_core)] +#![no_core] + +extern "C" { + fn f1(a: i32, a: i32); +} + +trait A { + fn f2(a: i32, a: i32); +} From 4e6f7715360144837fbb619ab6e463a7f6db267b Mon Sep 17 00:00:00 2001 From: Utkarsh Bahuguna Date: Mon, 21 Sep 2026 11:24:13 +0530 Subject: [PATCH 568/584] gccrs: Handle FUNCTION segments in new_type_param Fn/FnMut/FnOnce bounds can produce FUNCTION segments, which new_type_param did not handle. Use reconstruct() for these segments instead of hitting rust_unreachable(). Fixes Rust-GCC/gccrs#3939 gcc/rust/ChangeLog: * ast/rust-ast-builder.cc (Builder::new_type_param): Handle FUNCTION segments. gcc/testsuite/ChangeLog: * rust/compile/issues/3939.rs: New test. Signed-off-by: Utkarsh Bahuguna --- gcc/rust/ast/rust-ast-builder.cc | 7 +----- gcc/testsuite/rust/compile/issues/3939.rs | 30 +++++++++++++++++++++++ 2 files changed, 31 insertions(+), 6 deletions(-) create mode 100644 gcc/testsuite/rust/compile/issues/3939.rs diff --git a/gcc/rust/ast/rust-ast-builder.cc b/gcc/rust/ast/rust-ast-builder.cc index 6332ce2f5c92..09db66957d96 100644 --- a/gcc/rust/ast/rust-ast-builder.cc +++ b/gcc/rust/ast/rust-ast-builder.cc @@ -654,12 +654,7 @@ Builder::new_type_param ( break; case TypePathSegment::FUNCTION: - { - rust_unreachable (); - // TODO - // const TypePathSegmentFunction &fn - // = (const TypePathSegmentFunction &) (*seg.get ()); - } + segments.emplace_back (seg->reconstruct ()); break; } } diff --git a/gcc/testsuite/rust/compile/issues/3939.rs b/gcc/testsuite/rust/compile/issues/3939.rs new file mode 100644 index 000000000000..da253d9b646a --- /dev/null +++ b/gcc/testsuite/rust/compile/issues/3939.rs @@ -0,0 +1,30 @@ +#![feature(no_core)] +#![feature(lang_items)] +#![no_core] + +#[lang = "sized"] +trait Sized {} + +#[lang = "copy"] +trait Copy {} + +#[lang = "fn_once"] +trait FnOnce { + #[lang = "fn_once_output"] + type Output; + + fn call_once(self, args: Args) -> Self::Output; +} + +#[lang = "fn_mut"] +trait FnMut: FnOnce { + fn call_mut(&mut self, args: Args) -> Self::Output; +} + +#[lang = "fn"] +trait Fn: FnMut { + fn call(&self, args: Args) -> Self::Output; +} + +#[derive(Copy)] +pub struct X T>(T, F); From 4eea57b253511477b5bddbed62a1be010ec5db12 Mon Sep 17 00:00:00 2001 From: Owen Avery Date: Sun, 20 Sep 2026 19:10:08 -0400 Subject: [PATCH 569/584] gccrs: Improve bodyless function pattern check gcc/rust/ChangeLog: * checks/errors/rust-ast-validation.cc (ASTValidation::visit (Function)): Emit error on complex patterns in non-extern bodyless functions as well. gcc/testsuite/ChangeLog: * rust/compile/function-param-bodyless.rs: New test. Signed-off-by: Owen Avery --- gcc/rust/checks/errors/rust-ast-validation.cc | 49 ++++++++++++++----- .../rust/compile/function-param-bodyless.rs | 35 +++++++++++++ 2 files changed, 72 insertions(+), 12 deletions(-) create mode 100644 gcc/testsuite/rust/compile/function-param-bodyless.rs diff --git a/gcc/rust/checks/errors/rust-ast-validation.cc b/gcc/rust/checks/errors/rust-ast-validation.cc index b2825fb2c958..e5f8577cbabb 100644 --- a/gcc/rust/checks/errors/rust-ast-validation.cc +++ b/gcc/rust/checks/errors/rust-ast-validation.cc @@ -104,6 +104,35 @@ ASTValidation::visit (AST::Function &function) function.get_self_param ().get_locus (), "% parameter is only allowed in associated functions"); + // functions without bodies can only have very specific + // kinds of patterns in their parameters + auto is_param_complex_with_loc + = [] (AST::Param ¶m) -> tl::optional { + tl::optional ret; + + if (param.is_self () || param.is_variadic ()) + return ret; + + auto &fn_param = static_cast (param); + if (!fn_param.has_name ()) + return ret; + + auto &pat = fn_param.get_pattern (); + ret = pat.get_locus (); + auto kind = pat.get_pattern_kind (); + if (kind == AST::Pattern::Kind::Identifier) + { + auto &ident_pat = static_cast (pat); + if (!ident_pat.get_is_ref () && !ident_pat.get_is_mut () + && !ident_pat.has_subpattern ()) + ret = tl::nullopt; + } + else if (kind == AST::Pattern::Kind::Wildcard) + ret = tl::nullopt; + + return ret; + }; + if (function.is_external ()) { if (function.has_body ()) @@ -123,20 +152,11 @@ ASTValidation::visit (AST::Function &function) it->get ()->get_locus (), "%<...%> must be the last argument of a C-variadic function"); - // if functional parameter - if (!it->get ()->is_self () && !it->get ()->is_variadic ()) - { - auto ¶m = static_cast (**it); - auto kind = param.get_pattern ().get_pattern_kind (); - - if (kind != AST::Pattern::Kind::Identifier - && kind != AST::Pattern::Kind::Wildcard) - rust_error_at (it->get ()->get_locus (), ErrorCode::E0130, - "pattern not allowed in foreign function"); - } + if (auto pat_loc = is_param_complex_with_loc (**it)) + rust_error_at (*pat_loc, ErrorCode::E0130, + "pattern not allowed in foreign function"); } } - else { if (!function.has_body ()) @@ -158,6 +178,11 @@ ASTValidation::visit (AST::Function &function) it->get ()->get_locus (), "only foreign or % functions may " "be C-variadic"); + + if (!function.has_body ()) + if (auto pat_loc = is_param_complex_with_loc (**it)) + rust_error_at (*pat_loc, ErrorCode::E0642, + "pattern not allowed in function without body"); } } diff --git a/gcc/testsuite/rust/compile/function-param-bodyless.rs b/gcc/testsuite/rust/compile/function-param-bodyless.rs new file mode 100644 index 000000000000..eb71d475beba --- /dev/null +++ b/gcc/testsuite/rust/compile/function-param-bodyless.rs @@ -0,0 +1,35 @@ +// { dg-additional-options "-w" } +#![feature(no_core)] +#![no_core] + +mod extern_test { + extern "C" { + // { dg-error "pattern not allowed in foreign function .E0130." "" { target *-*-* } .+1 } + fn f1(mut a: i32); + // { dg-error "pattern not allowed in foreign function .E0130." "" { target *-*-* } .+1 } + fn f2(ref a: i32); + // { dg-error "pattern not allowed in foreign function .E0130." "" { target *-*-* } .+1 } + fn f3(a @ _: i32); + // { dg-error "pattern not allowed in foreign function .E0130." "" { target *-*-* } .+1 } + fn f4((a,): i32); + // { dg-error "pattern not allowed in foreign function .E0130." "" { target *-*-* } .+1 } + fn f5((a): i32); + + fn f6(_: i32); + } +} + +trait Foo { + // { dg-error "pattern not allowed in function without body .E0642." "" { target *-*-* } .+1 } + fn f1(mut a: i32); + // { dg-error "pattern not allowed in function without body .E0642." "" { target *-*-* } .+1 } + fn f2(ref a: i32); + // { dg-error "pattern not allowed in function without body .E0642." "" { target *-*-* } .+1 } + fn f3(a @ _: i32); + // { dg-error "pattern not allowed in function without body .E0642." "" { target *-*-* } .+1 } + fn f4((a,): i32); + // { dg-error "pattern not allowed in function without body .E0642." "" { target *-*-* } .+1 } + fn f5((a): i32); + + fn f6(_: i32); +} From c15fb636a11cbae631fcdfa17e950e2054cd44d5 Mon Sep 17 00:00:00 2001 From: Yap Zhi Heng Date: Tue, 22 Sep 2026 10:06:27 +0800 Subject: [PATCH 570/584] gccrs: Correct the naming of atomic store & load intrinsics The corrected atomic store & load intrinsics were using post-1.64.0 namings, this patch just adds back the 1.49.0 namings for the wrongly named intrinsics. gcc/rust/ChangeLog: * util/rust-intrinsic-values.h (Rust::Values::Intrinsics): Add entries for atomic_store, atomic_store_rel, atomic_load, atomic_load_acq. * backend/rust-compile-intrinsic.cc (generic_intrinsics): Likewise. Signed-off-by: Yap Zhi Heng --- gcc/rust/backend/rust-compile-intrinsic.cc | 4 ++++ gcc/rust/util/rust-intrinsic-values.h | 13 +++++++++++++ 2 files changed, 17 insertions(+) diff --git a/gcc/rust/backend/rust-compile-intrinsic.cc b/gcc/rust/backend/rust-compile-intrinsic.cc index b48647670089..b13e721a8ca7 100644 --- a/gcc/rust/backend/rust-compile-intrinsic.cc +++ b/gcc/rust/backend/rust-compile-intrinsic.cc @@ -49,12 +49,16 @@ static const std::map generic_intrinsics {IValue::COPY_NONOVERLAPPING, handlers::copy (false)}, {IValue::PREFETCH_READ_DATA, handlers::prefetch_read_data}, {IValue::PREFETCH_WRITE_DATA, handlers::prefetch_write_data}, + {IValue::ATOMIC_STORE, handlers::atomic_store (__ATOMIC_SEQ_CST)}, {IValue::ATOMIC_STORE_SEQCST, handlers::atomic_store (__ATOMIC_SEQ_CST)}, + {IValue::ATOMIC_STORE_REL, handlers::atomic_store (__ATOMIC_RELEASE)}, {IValue::ATOMIC_STORE_RELEASE, handlers::atomic_store (__ATOMIC_RELEASE)}, {IValue::ATOMIC_STORE_RELAXED, handlers::atomic_store (__ATOMIC_RELAXED)}, {IValue::ATOMIC_STORE_UNORDERED, handlers::atomic_store (__ATOMIC_RELAXED)}, + {IValue::ATOMIC_LOAD, handlers::atomic_load (__ATOMIC_SEQ_CST)}, {IValue::ATOMIC_LOAD_SEQCST, handlers::atomic_load (__ATOMIC_SEQ_CST)}, + {IValue::ATOMIC_LOAD_ACQ, handlers::atomic_load (__ATOMIC_ACQUIRE)}, {IValue::ATOMIC_LOAD_ACQUIRE, handlers::atomic_load (__ATOMIC_ACQUIRE)}, {IValue::ATOMIC_LOAD_RELAXED, handlers::atomic_load (__ATOMIC_RELAXED)}, {IValue::ATOMIC_LOAD_UNORDERED, handlers::atomic_load (__ATOMIC_RELAXED)}, diff --git a/gcc/rust/util/rust-intrinsic-values.h b/gcc/rust/util/rust-intrinsic-values.h index f6e36a3867d4..43df60fd5a2d 100644 --- a/gcc/rust/util/rust-intrinsic-values.h +++ b/gcc/rust/util/rust-intrinsic-values.h @@ -97,12 +97,25 @@ class Intrinsics static constexpr auto &PREFETCH_READ_DATA = "prefetch_read_data"; static constexpr auto &PREFETCH_WRITE_DATA = "prefetch_write_data"; + static constexpr auto &ATOMIC_STORE = "atomic_store"; + // atomic_store is renamed to atomic_store_seqcst from 1.64.0, the latter is + // left in for compatibility + // https://github.com/rust-lang/rust/commit/4982a59986f7393ace98f63c10e6c435ffba1420 static constexpr auto &ATOMIC_STORE_SEQCST = "atomic_store_seqcst"; + static constexpr auto &ATOMIC_STORE_REL = "atomic_store_rel"; + // atomic_store_rel is nenamed to atomic_store_release from 1.64.0, the + // latter is left in for compatibility static constexpr auto &ATOMIC_STORE_RELEASE = "atomic_store_release"; static constexpr auto &ATOMIC_STORE_RELAXED = "atomic_store_relaxed"; static constexpr auto &ATOMIC_STORE_UNORDERED = "atomic_store_unordered"; + static constexpr auto &ATOMIC_LOAD = "atomic_load"; + // atomic_load is renamed to atomic_load_seqcst from 1.64.0, the latter is + // left in for compatibility static constexpr auto &ATOMIC_LOAD_SEQCST = "atomic_load_seqcst"; + static constexpr auto &ATOMIC_LOAD_ACQ = "atomic_load_acq"; + // atomic_load_acq is renamed to atomic_load_acquire from 1.64.0, the latter + // is left in for compatibility static constexpr auto &ATOMIC_LOAD_ACQUIRE = "atomic_load_acquire"; static constexpr auto &ATOMIC_LOAD_RELAXED = "atomic_load_relaxed"; static constexpr auto &ATOMIC_LOAD_UNORDERED = "atomic_load_unordered"; From 25d689c6e62caa42d4096f7966295814ea8ff363 Mon Sep 17 00:00:00 2001 From: Arthur Cohen Date: Tue, 22 Sep 2026 12:49:20 +0200 Subject: [PATCH 571/584] core: Test until typecheck gcc/testsuite/ChangeLog: * rust/core/core.exp: Switch from testing core until lowering to testing core until typecheck. --- gcc/testsuite/rust/core/core.exp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/gcc/testsuite/rust/core/core.exp b/gcc/testsuite/rust/core/core.exp index d2efe4298245..82873a1c20d3 100644 --- a/gcc/testsuite/rust/core/core.exp +++ b/gcc/testsuite/rust/core/core.exp @@ -4,12 +4,12 @@ # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 3 of the License, or # (at your option) any later version. -# +# # This program 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 # . @@ -30,7 +30,7 @@ set saved-dg-do-what-default ${dg-do-what-default} set dg-do-what-default "compile" set individual_timeout 1200 dg-additional-files [lsort [glob -nocomplain $srcdir/../../libgrust/rustc-lib/*]] -dg-runtest $srcdir/../../libgrust/rustc-lib/core/src/lib.rs "-fno-rust-debug -frust-edition=2018 -frust-crate=core -frust-compile-until=lowering -w" "" +dg-runtest $srcdir/../../libgrust/rustc-lib/core/src/lib.rs "-fno-rust-debug -frust-edition=2018 -frust-crate=core -frust-compile-until=typecheck -w" "" set dg-do-what-default ${saved-dg-do-what-default} # All done. From 6c88d25ce1ef54f0fee8c9612dacc673c5c41f5c Mon Sep 17 00:00:00 2001 From: Owen Avery Date: Tue, 22 Sep 2026 20:03:12 -0400 Subject: [PATCH 572/584] gccrs: Add script to generate rustc-lib This should make it easier to upgrade libraries when we bump the target rustc version. libgrust/ChangeLog: * rustc-lib/version-info: Regenerate, now mentions stdarch. * contrib/vendor-libs.sh: New file. Signed-off-by: Owen Avery --- libgrust/contrib/vendor-libs.sh | 75 +++++++++++++++++++++++++++++++++ libgrust/rustc-lib/version-info | 1 + 2 files changed, 76 insertions(+) create mode 100755 libgrust/contrib/vendor-libs.sh diff --git a/libgrust/contrib/vendor-libs.sh b/libgrust/contrib/vendor-libs.sh new file mode 100755 index 000000000000..de98c92440c0 --- /dev/null +++ b/libgrust/contrib/vendor-libs.sh @@ -0,0 +1,75 @@ +#!/bin/sh + +# Copyright (C) 2026 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 +# . + +set -e + +SCRIPT_DIR="$(dirname "$0")" + +VENDOR_VERSION=1.49.0 +VENDOR_LIBS="core alloc stdarch" + +# double check, rm -rf needs to be safe +if [ x"${SCRIPT_DIR}" = x ]; then + echo "failed to get script directory" >&2 + exit 2 +fi + +VENDOR_DIR="${SCRIPT_DIR}"/../rustc-lib + +rm -rf "${VENDOR_DIR}" && mkdir -p "${VENDOR_DIR}" + +TEMP_GIT_DIR="$(mktemp -d)" + +# double check this too +if [ x"${TEMP_GIT_DIR}" = x ]; then + echo "failed to get temporary directory" >&2 + exit 2 +fi + +rm_git_dir() { + rm -rf "${TEMP_GIT_DIR}" +} + +trap rm_git_dir EXIT INT TERM HUP + +git clone \ + --recurse-submodules \ + --filter=blob:none \ + --also-filter-submodules \ + --depth=1 \ + --shallow-submodules \ + --branch="${VENDOR_VERSION}" \ + "git@github.com:rust-lang/rust.git" \ + "${TEMP_GIT_DIR}" + +find "${TEMP_GIT_DIR}" -name .git -exec rm -rf {} + + +for FILENAME in LICENSE-MIT LICENSE-APACHE; do + cp "${TEMP_GIT_DIR}/${FILENAME}" "${VENDOR_DIR}/${FILENAME}" +done + +for VENDOR_LIB in $VENDOR_LIBS; do + cp -R \ + "${TEMP_GIT_DIR}"/library/"${VENDOR_LIB}" \ + "${VENDOR_DIR}/${VENDOR_LIB}" + echo "lib${VENDOR_LIB}_tag=${VENDOR_VERSION}" \ + | tr '[:lower:]' '[:upper:]' \ + >> "${VENDOR_DIR}/version-info" +done diff --git a/libgrust/rustc-lib/version-info b/libgrust/rustc-lib/version-info index f1f9e9861317..556eb1f0ea7d 100644 --- a/libgrust/rustc-lib/version-info +++ b/libgrust/rustc-lib/version-info @@ -1,2 +1,3 @@ LIBCORE_TAG=1.49.0 LIBALLOC_TAG=1.49.0 +LIBSTDARCH_TAG=1.49.0 From 8060b397f338d0e7222a54bc8b89b79a9ea5815e Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Wed, 16 Sep 2026 17:05:44 +0200 Subject: [PATCH 573/584] Separate crate related mappings within hir map HIR mappings are getting bigger, this commit attempts to regroup crate related mappings within a single class. gcc/rust/ChangeLog: * ast/rust-collect-lang-items.cc (CollectLangItems::visit): Use sub category. * backend/rust-compile-expr.cc: Likewise. * backend/rust-compile-type.cc (TyTyResolveCompile::get_unit_type): Likewise. * checks/errors/borrowck/rust-borrow-checker.cc (BorrowChecker::go): Likewise. * checks/errors/privacy/rust-visibility-resolver.cc (VisibilityResolver::resolve_module_path): Likewise. * expand/rust-macro-substitute-ctx.cc: Likewise. * hir/rust-ast-lower-base.cc (ASTLoweringBase::lower_lifetime): Likewise. (ASTLoweringBase::lower_loop_label): Likewise. (ASTLoweringBase::lower_path_expr_seg): Likewise. (ASTLoweringBase::lower_self): Likewise. (ASTLoweringBase::lower_extern_block): Likewise. * hir/rust-ast-lower-block.h: Likewise. * hir/rust-ast-lower-enumitem.h: Likewise. * hir/rust-ast-lower-expr.cc (ASTLoweringExpr::visit): Likewise. * hir/rust-ast-lower-extern.h: Likewise. * hir/rust-ast-lower-implitem.cc (ASTLowerImplItem::visit): Likewise. (ASTLowerTraitItem::visit): Likewise. * hir/rust-ast-lower-item.cc (ASTLoweringItem::visit): Likewise. (ASTLoweringSimplePath::lower): Likewise. * hir/rust-ast-lower-pattern.cc (ASTLoweringPattern::visit): Likewise. * hir/rust-ast-lower-stmt.cc (ASTLoweringStmt::visit): Likewise. * hir/rust-ast-lower-type.cc (ASTLowerTypePath::visit): Likewise. (ASTLowerQualifiedPathInType::visit): Likewise. (ASTLoweringType::visit): Likewise. (ASTLowerGenericParam::visit): Likewise. (ASTLoweringTypeBounds::visit): Likewise. (ASTLowerWhereClauseItem::visit): Likewise. * hir/rust-ast-lower.cc (ASTLowering::go): Likewise. (ASTLoweringBlock::visit): Likewise. (ASTLoweringIfBlock::visit): Likewise. (ASTLoweringIfLetBlock::desugar_iflet): Likewise. (ASTLoweringIfLetBlock::visit): Likewise. (ASTLowerStructExprField::visit): Likewise. (ASTLoweringExprWithBlock::visit): Likewise. (ASTLowerPathInExpression::visit): Likewise. (ASTLoweringBase::lower_qual_path_type): Likewise. (ASTLowerQualPathInExpression::visit): Likewise. * metadata/rust-export-metadata.cc (PublicInterface::gather_export_data): Likewise. (PublicInterface::write_to_object_file): Likewise. (PublicInterface::write_to_path): Likewise. (PublicInterface::expected_metadata_filename): Likewise. * resolve/rust-default-resolver.cc (DefaultResolver::visit): Likewise. * resolve/rust-forever-stack.h: Likewise. * resolve/rust-name-resolution-context.h: Likewise. * rust-session-manager.cc (Session::handle_crate_name): Likewise. (Session::compile_crate): Likewise. (Session::load_extern_crate): Likewise. * typecheck/rust-hir-type-check-base.cc (TypeCheckBase::resolve_literal): Likewise. * typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit): Likewise. (TypeCheckExpr::resolve_fn_trait_call): Likewise. * typecheck/rust-hir-type-check-implitem.cc (TypeCheckTopLevelExternItem::visit): Likewise. (TypeCheckImplItem::resolve_function_signature): Likewise. * typecheck/rust-hir-type-check-item.cc (TypeCheckItem::visit): Likewise. * typecheck/rust-hir-type-check-struct.cc (TypeCheckStructExpr::resolve): Likewise. * typecheck/rust-hir-type-check.cc (TraitItemReference::get_type_from_fn): Likewise. * typecheck/rust-type-util.cc (query_type): Likewise. * typecheck/rust-tyty-bounds.cc: Likewise. * typecheck/rust-tyty-subst.cc (SubstitutionParamMapping::override_context): Likewise. * typecheck/rust-tyty-util.cc (TyVar::monomorphized_clone): Likewise. * typecheck/rust-tyty.cc (InferType::clone): Likewise. (ConstInferType::clone): Likewise. * util/rust-hir-map.cc (CrateMappings::CrateMappings): Add a new specialized class to keep all crate related mappings. (Mappings::Mappings): Move some member functions to CrateMappings. (Mappings::get_next_crate_num): Likewise. (CrateMappings::get_next_crate_num): Likewise. (Mappings::set_current_crate): Likewise. (CrateMappings::set_current_crate): Likewise. (Mappings::get_current_crate): Likewise. (CrateMappings::get_current_crate): Likewise. (Mappings::get_crate_name): Likewise. (CrateMappings::get_crate_name): Likewise. (Mappings::lookup_crate_num): Likewise. (CrateMappings::lookup_crate_num): Likewise. (Mappings::set_crate_name): Likewise. (CrateMappings::set_crate_name): Likewise. (Mappings::get_current_crate_name): Likewise. (CrateMappings::get_current_crate_name): Likewise. (Mappings::lookup_crate_name): Likewise. (CrateMappings::lookup_crate_name): Likewise. (Mappings::crate_num_to_nodeid): Likewise. (CrateMappings::crate_num_to_nodeid): Likewise. (Mappings::node_is_crate): Likewise. (CrateMappings::node_is_crate): Likewise. (Mappings::get_ast_crate): Likewise. (CrateMappings::get_ast_crate): Likewise. (Mappings::get_ast_crate_by_node_id): Likewise. (Mappings::get_ast_crate_by_node_id_raw): Likewise. (CrateMappings::get_ast_crate_by_node_id_raw): Likewise. (Mappings::insert_ast_crate): Likewise. (CrateMappings::insert_ast_crate): Likewise. (Mappings::insert_macro_def): Likewise. (Mappings::insert_glob_container): Likewise. * util/rust-hir-map.h (class Mappings): Move some declarations from here... (class CrateMappings): ...to here. Signed-off-by: Pierre-Emmanuel Patry --- gcc/rust/ast/rust-collect-lang-items.cc | 6 +- gcc/rust/backend/rust-compile-expr.cc | 3 +- gcc/rust/backend/rust-compile-type.cc | 4 +- .../errors/borrowck/rust-borrow-checker.cc | 4 +- .../privacy/rust-visibility-resolver.cc | 3 +- gcc/rust/expand/rust-macro-substitute-ctx.cc | 4 +- gcc/rust/hir/rust-ast-lower-base.cc | 10 +-- gcc/rust/hir/rust-ast-lower-block.h | 4 +- gcc/rust/hir/rust-ast-lower-enumitem.h | 12 +-- gcc/rust/hir/rust-ast-lower-expr.cc | 84 +++++++++---------- gcc/rust/hir/rust-ast-lower-extern.h | 8 +- gcc/rust/hir/rust-ast-lower-implitem.cc | 16 ++-- gcc/rust/hir/rust-ast-lower-item.cc | 48 ++++++----- gcc/rust/hir/rust-ast-lower-pattern.cc | 26 +++--- gcc/rust/hir/rust-ast-lower-stmt.cc | 6 +- gcc/rust/hir/rust-ast-lower-type.cc | 48 +++++------ gcc/rust/hir/rust-ast-lower.cc | 32 +++---- gcc/rust/metadata/rust-export-metadata.cc | 15 ++-- gcc/rust/resolve/rust-default-resolver.cc | 15 ++-- gcc/rust/resolve/rust-forever-stack.h | 5 +- .../resolve/rust-name-resolution-context.h | 10 ++- gcc/rust/rust-session-manager.cc | 32 ++++--- .../typecheck/rust-hir-type-check-base.cc | 2 +- .../typecheck/rust-hir-type-check-expr.cc | 9 +- .../typecheck/rust-hir-type-check-implitem.cc | 4 +- .../typecheck/rust-hir-type-check-item.cc | 10 +-- .../typecheck/rust-hir-type-check-struct.cc | 2 +- gcc/rust/typecheck/rust-hir-type-check.cc | 2 +- gcc/rust/typecheck/rust-type-util.cc | 6 +- gcc/rust/typecheck/rust-tyty-bounds.cc | 2 +- gcc/rust/typecheck/rust-tyty-subst.cc | 10 +-- gcc/rust/typecheck/rust-tyty-util.cc | 8 +- gcc/rust/typecheck/rust-tyty.cc | 20 ++--- gcc/rust/util/rust-hir-map.cc | 42 +++++----- gcc/rust/util/rust-hir-map.h | 51 +++++++---- 35 files changed, 302 insertions(+), 261 deletions(-) diff --git a/gcc/rust/ast/rust-collect-lang-items.cc b/gcc/rust/ast/rust-collect-lang-items.cc index 8a952f8dceed..0b3214253b0c 100644 --- a/gcc/rust/ast/rust-collect-lang-items.cc +++ b/gcc/rust/ast/rust-collect-lang-items.cc @@ -131,12 +131,12 @@ CollectLangItems::visit (AST::EnumItemDiscriminant &item) void CollectLangItems::visit (AST::ExternCrate &extern_crate) { - auto &mappings = Analysis::Mappings::get (); + auto &crate_mappings = Analysis::Mappings::get ().crate_mapping; auto crate_num - = mappings.lookup_crate_name (extern_crate.get_referenced_crate ()); + = crate_mappings.lookup_crate_name (extern_crate.get_referenced_crate ()); if (crate_num) { - visit (mappings.get_ast_crate (*crate_num)); + visit (crate_mappings.get_ast_crate (*crate_num)); } DefaultASTVisitor::visit (extern_crate); diff --git a/gcc/rust/backend/rust-compile-expr.cc b/gcc/rust/backend/rust-compile-expr.cc index e2e5644938e7..0f16010a375a 100644 --- a/gcc/rust/backend/rust-compile-expr.cc +++ b/gcc/rust/backend/rust-compile-expr.cc @@ -2696,7 +2696,8 @@ HIRCompileBase::resolve_unsized_adt_adjustment ( TyTy::BaseType *cloned_target = target_adt->clone (); cloned_target->set_ref (t_tyvar.get_ref ()); Analysis::NodeMapping pseudo_mapping ( - ctx->get_mappings ().get_current_crate (), 0, t_tyvar.get_ref (), 0); + ctx->get_mappings ().crate_mapping.get_current_crate (), 0, + t_tyvar.get_ref (), 0); ctx->get_tyctx ()->insert_type (pseudo_mapping, cloned_target); const TyTy::ReferenceType r (ctx->get_mappings ().get_next_hir_id (), diff --git a/gcc/rust/backend/rust-compile-type.cc b/gcc/rust/backend/rust-compile-type.cc index 126705c5ddfb..16d32ac7321b 100644 --- a/gcc/rust/backend/rust-compile-type.cc +++ b/gcc/rust/backend/rust-compile-type.cc @@ -178,8 +178,8 @@ TyTyResolveCompile::get_unit_type (Context *ctx) static tree unit_type; if (unit_type == nullptr) { - auto cn = ctx->get_mappings ().get_current_crate (); - auto &c = ctx->get_mappings ().get_ast_crate (cn); + auto cn = ctx->get_mappings ().crate_mapping.get_current_crate (); + auto &c = ctx->get_mappings ().crate_mapping.get_ast_crate (cn); location_t locus = BUILTINS_LOCATION; if (c.items.size () > 0) { diff --git a/gcc/rust/checks/errors/borrowck/rust-borrow-checker.cc b/gcc/rust/checks/errors/borrowck/rust-borrow-checker.cc index ba2b7067dca2..f9e9316f9713 100644 --- a/gcc/rust/checks/errors/borrowck/rust-borrow-checker.cc +++ b/gcc/rust/checks/errors/borrowck/rust-borrow-checker.cc @@ -55,8 +55,8 @@ BorrowChecker::go (HIR::Crate &crate) { mkdir ("bir_dump", 0755); auto &mappings = Analysis::Mappings::get (); - crate_name - = *mappings.get_crate_name (crate.get_mappings ().get_crate_num ()); + crate_name = *mappings.crate_mapping.get_crate_name ( + crate.get_mappings ().get_crate_num ()); mkdir ("nll_facts_gccrs", 0755); } diff --git a/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc b/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc index c24f0657e58e..d7c1955f8add 100644 --- a/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc +++ b/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc @@ -82,7 +82,8 @@ VisibilityResolver::resolve_module_path (const HIR::SimplePath &restriction, rust_assert (hid.has_value ()); auto ref = hid.value (); - auto crate = mappings.get_ast_crate (mappings.get_current_crate ()); + auto crate = mappings.crate_mapping.get_ast_crate ( + mappings.crate_mapping.get_current_crate ()); // we may be dealing with pub(crate) if (ref_node_id == crate.get_node_id ()) diff --git a/gcc/rust/expand/rust-macro-substitute-ctx.cc b/gcc/rust/expand/rust-macro-substitute-ctx.cc index 4423abe57a8a..44c7512f86a3 100644 --- a/gcc/rust/expand/rust-macro-substitute-ctx.cc +++ b/gcc/rust/expand/rust-macro-substitute-ctx.cc @@ -30,7 +30,7 @@ SubstituteCtx::substitute_dollar_crate ( auto &mappings = Analysis::Mappings::get (); auto def_crate = mappings.lookup_macro_def_crate (definition.get_node_id ()); - auto current_crate = mappings.get_current_crate (); + auto current_crate = mappings.crate_mapping.get_current_crate (); rust_assert (def_crate); @@ -44,7 +44,7 @@ SubstituteCtx::substitute_dollar_crate ( } else { - auto name = mappings.get_crate_name (*def_crate); + auto name = mappings.crate_mapping.get_crate_name (*def_crate); rust_assert (name); diff --git a/gcc/rust/hir/rust-ast-lower-base.cc b/gcc/rust/hir/rust-ast-lower-base.cc index 33b1c2f51ad4..1d55632e6900 100644 --- a/gcc/rust/hir/rust-ast-lower-base.cc +++ b/gcc/rust/hir/rust-ast-lower-base.cc @@ -596,7 +596,7 @@ ASTLoweringBase::lower_lifetime (AST::Lifetime &lifetime, lifetime_type = AST::Lifetime::STATIC; } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, lifetime.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -611,7 +611,7 @@ ASTLoweringBase::lower_loop_label (AST::LoopLabel &loop_label) { HIR::Lifetime life = lower_lifetime (loop_label.get_lifetime ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, loop_label.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -636,7 +636,7 @@ ASTLoweringBase::lower_generic_params ( HIR::PathExprSegment ASTLoweringBase::lower_path_expr_seg (AST::PathExprSegment &s) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, s.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -717,7 +717,7 @@ ASTLoweringBase::lower_self (AST::Param ¶m) rust_assert (param.is_self ()); auto self = static_cast (param); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, self.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -1043,7 +1043,7 @@ ASTLoweringBase::lower_extern_block (AST::ExternBlock &extern_block) { HIR::Visibility vis = translate_visibility (extern_block.get_visibility ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, extern_block.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); diff --git a/gcc/rust/hir/rust-ast-lower-block.h b/gcc/rust/hir/rust-ast-lower-block.h index 76cbfc5539a7..3b36ea36c258 100644 --- a/gcc/rust/hir/rust-ast-lower-block.h +++ b/gcc/rust/hir/rust-ast-lower-block.h @@ -51,7 +51,7 @@ class ASTLoweringBlock : public ASTLoweringBase HIR::BlockExpr *block = ASTLoweringBlock::translate (expr.get_block_expr (), terminated); - auto crate_num = resolver.mappings.get_current_crate (); + auto crate_num = resolver.mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), resolver.mappings.get_next_hir_id ( crate_num), @@ -199,7 +199,7 @@ class ASTLoweringExprWithBlock : public ASTLoweringBase if (expr.has_loop_label ()) loop_label = lower_loop_label (expr.get_loop_label ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); diff --git a/gcc/rust/hir/rust-ast-lower-enumitem.h b/gcc/rust/hir/rust-ast-lower-enumitem.h index 3a24f477f745..e5f06b40c86e 100644 --- a/gcc/rust/hir/rust-ast-lower-enumitem.h +++ b/gcc/rust/hir/rust-ast-lower-enumitem.h @@ -54,7 +54,7 @@ class ASTLoweringEnumItem : public ASTLoweringBase void visit (AST::EnumItem &item) override { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, item.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -69,7 +69,7 @@ class ASTLoweringEnumItem : public ASTLoweringBase void visit (AST::EnumItemTuple &item) override { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, item.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -87,7 +87,7 @@ class ASTLoweringEnumItem : public ASTLoweringBase HIR::Visibility vis = translate_visibility (field.get_visibility ()); HIR::Type *type = ASTLoweringType::translate (field.get_field_type ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping field_mapping ( crate_num, field.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -104,7 +104,7 @@ class ASTLoweringEnumItem : public ASTLoweringBase void visit (AST::EnumItemStruct &item) override { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, item.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -120,7 +120,7 @@ class ASTLoweringEnumItem : public ASTLoweringBase HIR::Visibility vis = translate_visibility (field.get_visibility ()); HIR::Type *type = ASTLoweringType::translate (field.get_field_type ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping field_mapping ( crate_num, field.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -145,7 +145,7 @@ class ASTLoweringEnumItem : public ASTLoweringBase void visit (AST::EnumItemDiscriminant &item) override { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, item.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); diff --git a/gcc/rust/hir/rust-ast-lower-expr.cc b/gcc/rust/hir/rust-ast-lower-expr.cc index 77811f2b8dac..61a3f10c3fde 100644 --- a/gcc/rust/hir/rust-ast-lower-expr.cc +++ b/gcc/rust/hir/rust-ast-lower-expr.cc @@ -66,7 +66,7 @@ ASTLoweringExpr::visit (AST::TupleIndexExpr &expr) HIR::Expr *tuple_expr = ASTLoweringExpr::translate (expr.get_tuple_expr (), &terminated); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -86,7 +86,7 @@ ASTLoweringExpr::visit (AST::TupleExpr &expr) for (auto &e : expr.get_tuple_elems ()) tuple_elements.emplace_back (ASTLoweringExpr::translate (*e)); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -131,7 +131,7 @@ void ASTLoweringExpr::visit (AST::AnonConst &expr) { auto &mappings = Analysis::Mappings::get (); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); auto mapping = Analysis::NodeMapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -161,7 +161,7 @@ ASTLoweringExpr::visit (AST::ConstBlock &expr) auto anon_const = static_cast (inner_expr); auto &mappings = Analysis::Mappings::get (); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); auto mapping = Analysis::NodeMapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -194,7 +194,7 @@ ASTLoweringExpr::visit (AST::BoxExpr &expr) { HIR::Expr *box_expr = ASTLoweringExpr::translate (expr.get_boxed_expr ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -212,7 +212,7 @@ ASTLoweringExpr::visit (AST::ReturnExpr &expr) ? ASTLoweringExpr::translate (expr.get_returned_expr ()) : nullptr; - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -234,7 +234,7 @@ ASTLoweringExpr::visit (AST::CallExpr &expr) for (auto ¶m : in_params) params.emplace_back (ASTLoweringExpr::translate (*param)); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping ( crate_num, UNKNOWN_NODEID /* this can map back to the AST*/, mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -259,7 +259,7 @@ ASTLoweringExpr::visit (AST::MethodCallExpr &expr) for (auto ¶m : in_params) params.emplace_back (ASTLoweringExpr::translate (*param)); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -276,7 +276,7 @@ ASTLoweringExpr::visit (AST::AssignmentExpr &expr) HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ()); HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -290,7 +290,7 @@ ASTLoweringExpr::visit (AST::AssignmentExpr &expr) void ASTLoweringExpr::visit (AST::IdentifierExpr &expr) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping1 (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -310,7 +310,7 @@ ASTLoweringExpr::visit (AST::ArrayExpr &expr) rust_assert (translated_array_elems != nullptr); HIR::ArrayElems *elems = translated_array_elems; - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -328,7 +328,7 @@ ASTLoweringExpr::visit (AST::ArrayIndexExpr &expr) HIR::Expr *array_index_expr = ASTLoweringExpr::translate (expr.get_index_expr ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -348,9 +348,8 @@ ASTLoweringExpr::visit (AST::ArrayElemsValues &elems) for (auto &elem : elems.get_values ()) elements.emplace_back (ASTLoweringExpr::translate (*elem)); - auto crate_num = mappings.get_current_crate (); - Analysis::NodeMapping mapping (mappings.get_current_crate (), - elems.get_node_id (), + auto crate_num = mappings.crate_mapping.get_current_crate (); + Analysis::NodeMapping mapping (crate_num, elems.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -364,9 +363,8 @@ ASTLoweringExpr::visit (AST::ArrayElemsCopied &elems) HIR::Expr *element = ASTLoweringExpr::translate (elems.get_elem_to_copy ()); HIR::Expr *num_copies = ASTLoweringExpr::translate (elems.get_num_copies ()); - auto crate_num = mappings.get_current_crate (); - Analysis::NodeMapping mapping (mappings.get_current_crate (), - elems.get_node_id (), + auto crate_num = mappings.crate_mapping.get_current_crate (); + Analysis::NodeMapping mapping (crate_num, elems.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -378,7 +376,7 @@ ASTLoweringExpr::visit (AST::ArrayElemsCopied &elems) void ASTLoweringExpr::visit (AST::LiteralExpr &expr) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -396,7 +394,7 @@ ASTLoweringExpr::visit (AST::ArithmeticOrLogicalExpr &expr) HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ()); rust_assert (rhs != nullptr); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -414,7 +412,7 @@ ASTLoweringExpr::visit (AST::ComparisonExpr &expr) HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ()); rust_assert (rhs != nullptr); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -433,7 +431,7 @@ ASTLoweringExpr::visit (AST::LazyBooleanExpr &expr) HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ()); rust_assert (rhs != nullptr); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -450,7 +448,7 @@ ASTLoweringExpr::visit (AST::NegationExpr &expr) HIR::Expr *negated_value = ASTLoweringExpr::translate (expr.get_negated_expr ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -469,7 +467,7 @@ ASTLoweringExpr::visit (AST::TypeCastExpr &expr) HIR::Type *type_to_cast_to = lower_type_no_bounds (expr.get_type_to_cast_to ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -524,7 +522,7 @@ ASTLoweringExpr::visit (AST::CompoundAssignmentExpr &expr) HIR::Expr *asignee_expr = ASTLoweringExpr::translate (expr.get_left_expr ()); HIR::Expr *value = ASTLoweringExpr::translate (expr.get_right_expr ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -542,7 +540,7 @@ ASTLoweringExpr::visit (AST::StructExprStruct &struct_expr) HIR::PathInExpression copied_path (*path); delete path; - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, struct_expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -580,7 +578,7 @@ ASTLoweringExpr::visit (AST::StructExprStructFields &struct_expr) for (auto &field : in_fields) fields.emplace_back (ASTLowerStructExprField::translate (*field)); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, struct_expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -599,7 +597,7 @@ ASTLoweringExpr::visit (AST::GroupedExpr &expr) HIR::Expr *paren_expr = ASTLoweringExpr::translate (expr.get_expr_in_parens ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -615,7 +613,7 @@ ASTLoweringExpr::visit (AST::FieldAccessExpr &expr) { HIR::Expr *receiver = ASTLoweringExpr::translate (expr.get_receiver_expr ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -649,7 +647,7 @@ ASTLoweringExpr::visit (AST::BreakExpr &expr) ? ASTLoweringExpr::translate (expr.get_break_expr_unchecked ()) : nullptr; - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -667,7 +665,7 @@ ASTLoweringExpr::visit (AST::ContinueExpr &expr) if (expr.has_label ()) break_label = lower_lifetime (expr.get_label_unchecked ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -683,7 +681,7 @@ ASTLoweringExpr::visit (AST::BorrowExpr &expr) HIR::Expr *borrow_lvalue = ASTLoweringExpr::translate (expr.get_borrowed_expr ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -716,7 +714,7 @@ ASTLoweringExpr::visit (AST::DereferenceExpr &expr) HIR::Expr *dref_lvalue = ASTLoweringExpr::translate (expr.get_dereferenced_expr ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -736,7 +734,7 @@ ASTLoweringExpr::visit (AST::MatchExpr &expr) void ASTLoweringExpr::visit (AST::RangeFromToExpr &expr) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -754,7 +752,7 @@ ASTLoweringExpr::visit (AST::RangeFromToExpr &expr) void ASTLoweringExpr::visit (AST::RangeFromExpr &expr) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -769,7 +767,7 @@ ASTLoweringExpr::visit (AST::RangeFromExpr &expr) void ASTLoweringExpr::visit (AST::RangeToExpr &expr) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -784,7 +782,7 @@ ASTLoweringExpr::visit (AST::RangeToExpr &expr) void ASTLoweringExpr::visit (AST::RangeFullExpr &expr) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -795,7 +793,7 @@ ASTLoweringExpr::visit (AST::RangeFullExpr &expr) void ASTLoweringExpr::visit (AST::RangeFromToInclExpr &expr) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping path_mapping (crate_num, mappings.get_next_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -834,7 +832,7 @@ ASTLoweringExpr::visit (AST::ClosureExprInner &expr) for (auto ¶m : expr.get_params ()) closure_params.emplace_back (lower_closure_param (param)); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -860,7 +858,7 @@ ASTLoweringExpr::visit (AST::ClosureExprInnerTyped &expr) for (auto ¶m : expr.get_params ()) closure_params.emplace_back (lower_closure_param (param)); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -989,7 +987,7 @@ from_operand (const AST::InlineAsmOperand &operand) void ASTLoweringExpr::visit (AST::InlineAsm &expr) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -1140,7 +1138,7 @@ ASTLoweringExpr::visit (AST::LlvmInlineAsm &expr) "subset of % to compile libcore"); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -1197,7 +1195,7 @@ ASTLoweringExpr::visit (AST::OffsetOf &offset_of) auto type = std::unique_ptr ( ASTLoweringType::translate (offset_of.get_type ())); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, offset_of.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); diff --git a/gcc/rust/hir/rust-ast-lower-extern.h b/gcc/rust/hir/rust-ast-lower-extern.h index 833e69cd23a7..c9cec8cb6c04 100644 --- a/gcc/rust/hir/rust-ast-lower-extern.h +++ b/gcc/rust/hir/rust-ast-lower-extern.h @@ -53,7 +53,7 @@ class ASTLoweringExternItem : public ASTLoweringBase HIR::Visibility vis = translate_visibility (item.get_visibility ()); HIR::Type *static_type = ASTLoweringType::translate (item.get_type ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, item.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -103,7 +103,7 @@ class ASTLoweringExternItem : public ASTLoweringBase HIR::Type *param_type = ASTLoweringType::translate (param.get_type ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, param.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id ( @@ -113,7 +113,7 @@ class ASTLoweringExternItem : public ASTLoweringBase std::unique_ptr (param_type)); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, function.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -127,7 +127,7 @@ class ASTLoweringExternItem : public ASTLoweringBase void visit (AST::ExternalTypeItem &type) override { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); diff --git a/gcc/rust/hir/rust-ast-lower-implitem.cc b/gcc/rust/hir/rust-ast-lower-implitem.cc index 16a7c3b4368c..828d0065fa71 100644 --- a/gcc/rust/hir/rust-ast-lower-implitem.cc +++ b/gcc/rust/hir/rust-ast-lower-implitem.cc @@ -66,7 +66,7 @@ ASTLowerImplItem::visit (AST::TypeAlias &alias) HIR::Type *existing_type = ASTLoweringType::translate (alias.get_type_aliased ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, alias.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -90,7 +90,7 @@ ASTLowerImplItem::visit (AST::ConstantItem &constant) HIR::Type *type = ASTLoweringType::translate (constant.get_type (), true); HIR::Expr *expr = ASTLoweringExpr::translate (constant.get_expr ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, constant.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -157,7 +157,7 @@ ASTLowerImplItem::visit (AST::Function &function) auto translated_type = std::unique_ptr ( ASTLoweringType::translate (param.get_type ())); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, param.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -173,7 +173,7 @@ ASTLowerImplItem::visit (AST::Function &function) ASTLoweringBlock::translate (*function.get_definition ().value (), &terminated)); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, function.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -271,7 +271,7 @@ ASTLowerTraitItem::visit (AST::Function &func) auto translated_type = std::unique_ptr ( ASTLoweringType::translate (param.get_type ())); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, param.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -304,7 +304,7 @@ ASTLowerTraitItem::visit (AST::Function &func) &terminated)) : nullptr; - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, func.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -330,7 +330,7 @@ ASTLowerTraitItem::visit (AST::ConstantItem &constant) ? ASTLoweringExpr::translate (constant.get_expr ()) : nullptr; - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, constant.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -365,7 +365,7 @@ ASTLowerTraitItem::visit (AST::TraitItemType &type) std::unique_ptr (lowered_bound)); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); diff --git a/gcc/rust/hir/rust-ast-lower-item.cc b/gcc/rust/hir/rust-ast-lower-item.cc index 2ae5242357f2..546ba6fb848b 100644 --- a/gcc/rust/hir/rust-ast-lower-item.cc +++ b/gcc/rust/hir/rust-ast-lower-item.cc @@ -56,7 +56,7 @@ ASTLoweringItem::translate (AST::Item &item) void ASTLoweringItem::visit (AST::Module &module) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, module.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -106,7 +106,7 @@ ASTLoweringItem::visit (AST::TypeAlias &alias) HIR::Type *existing_type = ASTLoweringType::translate (alias.get_type_aliased ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, alias.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -151,7 +151,7 @@ ASTLoweringItem::visit (AST::TupleStruct &struct_decl) HIR::Visibility vis = translate_visibility (field.get_visibility ()); HIR::Type *type = ASTLoweringType::translate (field.get_field_type ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, field.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -160,7 +160,7 @@ ASTLoweringItem::visit (AST::TupleStruct &struct_decl) field.get_locus (), field.get_outer_attrs ()); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, struct_decl.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -204,7 +204,7 @@ ASTLoweringItem::visit (AST::StructStruct &struct_decl) HIR::Visibility vis = translate_visibility (field.get_visibility ()); HIR::Type *type = ASTLoweringType::translate (field.get_field_type ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, field.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -220,7 +220,7 @@ ASTLoweringItem::visit (AST::StructStruct &struct_decl) fields.push_back (std::move (translated_field)); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, struct_decl.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -265,7 +265,7 @@ ASTLoweringItem::visit (AST::Enum &enum_decl) items.emplace_back (ASTLoweringEnumItem::translate (variant.get ())); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, enum_decl.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -310,7 +310,7 @@ ASTLoweringItem::visit (AST::Union &union_decl) HIR::Visibility vis = translate_visibility (variant.get_visibility ()); HIR::Type *type = ASTLoweringType::translate (variant.get_field_type ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, variant.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -326,7 +326,7 @@ ASTLoweringItem::visit (AST::Union &union_decl) variants.push_back (std::move (translated_variant)); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, union_decl.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -346,7 +346,7 @@ ASTLoweringItem::visit (AST::StaticItem &var) HIR::Type *type = ASTLoweringType::translate (var.get_type (), true); HIR::Expr *expr = ASTLoweringExpr::translate (var.get_expr ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, var.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -369,7 +369,7 @@ ASTLoweringItem::visit (AST::ConstantItem &constant) if (constant.has_expr ()) expr = ASTLoweringExpr::translate (constant.get_expr ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, constant.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -418,7 +418,7 @@ ASTLoweringItem::visit (AST::Function &function) std::vector function_params; function_params.reserve (function.get_function_params ().size ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); for (auto &p : function.get_function_params ()) { if (p->is_variadic ()) @@ -470,7 +470,7 @@ ASTLoweringItem::visit (AST::Function &function) auto translated_type = std::unique_ptr ( ASTLoweringType::translate (param.get_type ())); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, param.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -565,7 +565,7 @@ ASTLoweringItem::visit (AST::InherentImpl &impl_block) HIR::Type *impl_type = ASTLoweringType::translate (impl_block.get_type ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, impl_block.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -649,7 +649,7 @@ ASTLoweringItem::visit (AST::Trait &trait) trait_items.emplace_back (lowered); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, trait.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -729,7 +729,7 @@ ASTLoweringItem::visit (AST::TraitImpl &impl_block) HIR::TypePath *trait_ref = ASTLowerTypePath::translate (impl_block.get_trait_path ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, impl_block.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -791,16 +791,18 @@ ASTLoweringItem::visit (AST::ExternCrate &extern_crate) return; auto &mappings = Analysis::Mappings::get (); + auto &crate_mapping = mappings.crate_mapping; + CrateNum num - = mappings.lookup_crate_name (extern_crate.get_referenced_crate ()) + = crate_mapping.lookup_crate_name (extern_crate.get_referenced_crate ()) .value (); - AST::Crate &crate = mappings.get_ast_crate (num); + AST::Crate &crate = mappings.crate_mapping.get_ast_crate (num); - auto saved_crate_num = mappings.get_current_crate (); - mappings.set_current_crate (num); + auto saved_crate_num = mappings.crate_mapping.get_current_crate (); + crate_mapping.set_current_crate (num); auto lowered = ASTLowering::Resolve (crate); mappings.insert_hir_crate (std::move (lowered)); - mappings.set_current_crate (saved_crate_num); + crate_mapping.set_current_crate (saved_crate_num); } HIR::SimplePath @@ -814,7 +816,7 @@ ASTLoweringSimplePath::translate (const AST::SimplePath &path) HIR::SimplePathSegment ASTLoweringSimplePath::lower (const AST::SimplePathSegment &segment) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); auto node_id = segment.get_node_id (); auto mapping = Analysis::NodeMapping (crate_num, node_id, @@ -836,7 +838,7 @@ ASTLoweringSimplePath::lower (const AST::SimplePath &path) for (auto &segment : path.get_segments ()) segments.emplace_back (lower (segment)); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); auto node_id = path.get_node_id (); auto mapping = Analysis::NodeMapping (crate_num, node_id, diff --git a/gcc/rust/hir/rust-ast-lower-pattern.cc b/gcc/rust/hir/rust-ast-lower-pattern.cc index 17d4dc981e1d..21544ff26645 100644 --- a/gcc/rust/hir/rust-ast-lower-pattern.cc +++ b/gcc/rust/hir/rust-ast-lower-pattern.cc @@ -46,7 +46,7 @@ ASTLoweringPattern::translate (AST::Pattern &pattern, bool is_let_top_level) void ASTLoweringPattern::visit (AST::IdentifierPattern &pattern) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -124,7 +124,7 @@ ASTLoweringPattern::visit (AST::TupleStructPattern &pattern) break; } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -152,7 +152,7 @@ ASTLoweringPattern::visit (AST::StructPattern &pattern) auto &tuple = static_cast (*field); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, tuple.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -173,7 +173,7 @@ ASTLoweringPattern::visit (AST::StructPattern &pattern) AST::StructPatternFieldIdentPat &ident = static_cast (*field); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, ident.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -194,7 +194,7 @@ ASTLoweringPattern::visit (AST::StructPattern &pattern) AST::StructPatternFieldIdent &ident = static_cast (*field.get ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, ident.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -217,7 +217,7 @@ ASTLoweringPattern::visit (AST::StructPattern &pattern) fields.emplace_back (f); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -230,7 +230,7 @@ ASTLoweringPattern::visit (AST::StructPattern &pattern) void ASTLoweringPattern::visit (AST::WildcardPattern &pattern) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -261,7 +261,7 @@ ASTLoweringPattern::visit (AST::TuplePattern &pattern) break; } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -273,7 +273,7 @@ ASTLoweringPattern::visit (AST::TuplePattern &pattern) void ASTLoweringPattern::visit (AST::LiteralPattern &pattern) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -290,7 +290,7 @@ ASTLoweringPattern::visit (AST::RangePattern &pattern) auto upper_bound = lower_range_pattern_bound (pattern.get_upper_bound ()); auto lower_bound = lower_range_pattern_bound (pattern.get_lower_bound ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -312,7 +312,7 @@ ASTLoweringPattern::visit (AST::GroupedPattern &pattern) void ASTLoweringPattern::visit (AST::ReferencePattern &pattern) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -360,7 +360,7 @@ ASTLoweringPattern::visit (AST::SlicePattern &pattern) // need this earlier than usual // since we might need to produce rest_bind - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); for (size_t i = 0; i < sub_patterns.size (); i++) { @@ -424,7 +424,7 @@ ASTLoweringPattern::visit (AST::SlicePattern &pattern) void ASTLoweringPattern::visit (AST::AltPattern &pattern) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); diff --git a/gcc/rust/hir/rust-ast-lower-stmt.cc b/gcc/rust/hir/rust-ast-lower-stmt.cc index 4792b9ac8a83..2f5eede12030 100644 --- a/gcc/rust/hir/rust-ast-lower-stmt.cc +++ b/gcc/rust/hir/rust-ast-lower-stmt.cc @@ -49,7 +49,7 @@ ASTLoweringStmt::visit (AST::ExprStmt &stmt) { HIR::Expr *expr = ASTLoweringExpr::translate (stmt.get_expr (), &terminated); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, stmt.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -87,7 +87,7 @@ ASTLoweringStmt::visit (AST::LetStmt &stmt) else_expr = std::unique_ptr ( ASTLoweringExpr::translate (stmt.get_else_expr ())); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, stmt.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -125,7 +125,7 @@ ASTLoweringStmt::visit (AST::Enum &enum_decl) void ASTLoweringStmt::visit (AST::EmptyStmt &empty) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, empty.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); diff --git a/gcc/rust/hir/rust-ast-lower-type.cc b/gcc/rust/hir/rust-ast-lower-type.cc index 3acdfeaa1e59..7bc9c6b97193 100644 --- a/gcc/rust/hir/rust-ast-lower-type.cc +++ b/gcc/rust/hir/rust-ast-lower-type.cc @@ -38,7 +38,7 @@ ASTLowerTypePath::translate (AST::TypePath &type) void ASTLowerTypePath::visit (AST::TypePathSegmentFunction &segment) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); auto hirid = mappings.get_next_hir_id (crate_num); Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid, UNKNOWN_LOCAL_DEFID); @@ -69,7 +69,7 @@ ASTLowerTypePath::visit (AST::TypePathSegmentFunction &segment) void ASTLowerTypePath::visit (AST::TypePathSegment &segment) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); auto hirid = mappings.get_next_hir_id (crate_num); Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid, UNKNOWN_LOCAL_DEFID); @@ -97,7 +97,7 @@ ASTLowerTypePath::visit (AST::TypePathSegmentGeneric &segment) auto generic_args = lower_generic_args (segment.get_generic_args ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); auto hirid = mappings.get_next_hir_id (crate_num); Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid, UNKNOWN_LOCAL_DEFID); @@ -137,7 +137,7 @@ ASTLowerTypePath::visit (AST::TypePath &path) std::unique_ptr (translated_segment)); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); auto hirid = mappings.get_next_hir_id (crate_num); Analysis::NodeMapping mapping (crate_num, path.get_node_id (), hirid, mappings.get_next_localdef_id (crate_num)); @@ -160,7 +160,7 @@ ASTLowerQualifiedPathInType::translate (AST::QualifiedPathInType &type) void ASTLowerQualifiedPathInType::visit (AST::QualifiedPathInType &path) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); auto hirid = mappings.get_next_hir_id (crate_num); Analysis::NodeMapping qual_mappings ( crate_num, path.get_qualified_path_type ().get_node_id (), hirid, @@ -284,7 +284,7 @@ ASTLoweringType::visit (AST::BareFunctionType &fntype) impl_trait_allowed); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, fntype.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -306,7 +306,7 @@ ASTLoweringType::visit (AST::TupleType &tuple) elems.push_back (std::unique_ptr (t)); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, tuple.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -336,7 +336,7 @@ ASTLoweringType::visit (AST::ArrayType &type) impl_trait_allowed); HIR::Expr *array_size = ASTLoweringExpr::translate (type.get_size_expr ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -357,7 +357,7 @@ ASTLoweringType::visit (AST::ReferenceType &type) default_to_static_lifetime, impl_trait_allowed); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -377,7 +377,7 @@ ASTLoweringType::visit (AST::RawPointerType &type) default_to_static_lifetime, impl_trait_allowed); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -399,7 +399,7 @@ ASTLoweringType::visit (AST::SliceType &type) default_to_static_lifetime, impl_trait_allowed); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -412,7 +412,7 @@ ASTLoweringType::visit (AST::SliceType &type) void ASTLoweringType::visit (AST::InferredType &type) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -423,7 +423,7 @@ ASTLoweringType::visit (AST::InferredType &type) void ASTLoweringType::visit (AST::NeverType &type) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -439,7 +439,7 @@ ASTLoweringType::visit (AST::TraitObjectTypeOneBound &type) = ASTLoweringTypeBounds::translate (type.get_trait_bound ()); bounds.push_back (std::unique_ptr (translated_bound)); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -461,7 +461,7 @@ ASTLoweringType::visit (AST::TraitObjectType &type) std::unique_ptr (translated_bound)); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -477,7 +477,7 @@ ASTLoweringType::visit (AST::ParenthesisedType &type) default_to_static_lifetime, impl_trait_allowed); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -502,7 +502,7 @@ ASTLoweringType::visit (AST::ImplTraitType &type) bounds.push_back (std::unique_ptr (b)); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -522,7 +522,7 @@ ASTLoweringType::visit (AST::ImplTraitTypeOneBound &type) auto b = ASTLoweringTypeBounds::translate (*type.get_trait_bound ().get ()); bounds.push_back (std::unique_ptr (b)); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -557,7 +557,7 @@ ASTLowerGenericParam::translate (AST::GenericParam ¶m) void ASTLowerGenericParam::visit (AST::LifetimeParam ¶m) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); AST::Lifetime lifetime = param.get_lifetime (); Analysis::NodeMapping mapping (crate_num, param.get_node_id (), mappings.get_next_hir_id (crate_num), @@ -574,7 +574,7 @@ ASTLowerGenericParam::visit (AST::LifetimeParam ¶m) void ASTLowerGenericParam::visit (AST::ConstGenericParam ¶m) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, param.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -612,7 +612,7 @@ ASTLowerGenericParam::visit (AST::TypeParam ¶m) = tl::optional> (std::unique_ptr ( ASTLoweringType::translate (param.get_type ()))); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, param.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -652,7 +652,7 @@ ASTLoweringTypeBounds::visit (AST::TraitBound &bound) AST::TypePath &ast_trait_path = bound.get_type_path (); HIR::TypePath *trait_path = ASTLowerTypePath::translate (ast_trait_path); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, bound.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -698,7 +698,7 @@ ASTLowerWhereClauseItem::visit (AST::LifetimeWhereClauseItem &item) lifetime_bounds.push_back (std::move (ll)); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, item.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -731,7 +731,7 @@ ASTLowerWhereClauseItem::visit (AST::TypeBoundWhereClauseItem &item) type_param_bounds.push_back (std::unique_ptr (b)); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, item.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); diff --git a/gcc/rust/hir/rust-ast-lower.cc b/gcc/rust/hir/rust-ast-lower.cc index 413e3f0baaa8..f31cc92cdb07 100644 --- a/gcc/rust/hir/rust-ast-lower.cc +++ b/gcc/rust/hir/rust-ast-lower.cc @@ -82,7 +82,7 @@ ASTLowering::go () } auto &mappings = Analysis::Mappings::get (); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, astCrate.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -145,7 +145,7 @@ ASTLoweringBlock::visit (AST::BlockExpr &expr) } bool tail_reachable = !block_did_terminate; - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -168,7 +168,7 @@ ASTLoweringIfBlock::visit (AST::IfExpr &expr) HIR::BlockExpr *block = ASTLoweringBlock::translate (expr.get_if_block (), &ignored_terminated); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -195,7 +195,7 @@ ASTLoweringIfBlock::visit (AST::IfExprConseqElse &expr) terminated = if_block_terminated && else_block_termianted; - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -245,7 +245,7 @@ ASTLoweringIfLetBlock::desugar_iflet (AST::IfLetExpr &expr, HIR::MatchArm arm (std::move (match_arm_pattern), expr.get_locus (), nullptr, {}); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -286,7 +286,7 @@ ASTLoweringIfLetBlock::visit (AST::IfLetExpr &expr) HIR::Expr *branch_value; std::vector match_arms; - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -326,7 +326,7 @@ ASTLoweringIfLetBlock::visit (AST::IfLetExprConseqElse &expr) desugar_iflet (expr, &branch_value, kase_else_expr, match_arms); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -343,7 +343,7 @@ ASTLowerStructExprField::visit (AST::StructExprFieldIdentifierValue &field) { HIR::Expr *value = ASTLoweringExpr::translate (field.get_value ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, field.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -358,7 +358,7 @@ ASTLowerStructExprField::visit (AST::StructExprFieldIndexValue &field) { HIR::Expr *value = ASTLoweringExpr::translate (field.get_value ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, field.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -372,7 +372,7 @@ ASTLowerStructExprField::visit (AST::StructExprFieldIndexValue &field) void ASTLowerStructExprField::visit (AST::StructExprFieldIdentifier &field) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, field.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -397,7 +397,7 @@ ASTLoweringExprWithBlock::visit (AST::WhileLoopExpr &expr) HIR::Expr *loop_condition = ASTLoweringExpr::translate (expr.get_predicate_expr (), &terminated); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -439,7 +439,7 @@ ASTLoweringExprWithBlock::visit (AST::MatchExpr &expr) std::unique_ptr (kase_guard_expr), match_case.get_arm ().get_outer_attrs ()); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -448,7 +448,7 @@ ASTLoweringExprWithBlock::visit (AST::MatchExpr &expr) std::unique_ptr (kase_expr)); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -464,7 +464,7 @@ ASTLoweringExprWithBlock::visit (AST::MatchExpr &expr) void ASTLowerPathInExpression::visit (AST::PathInExpression &expr) { - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -504,7 +504,7 @@ ASTLoweringBase::lower_qual_path_type (AST::QualifiedPathType &qualified_type) ? ASTLowerTypePath::translate (qualified_type.get_as_type_path ()) : nullptr; - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, qualified_type.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -534,7 +534,7 @@ ASTLowerQualPathInExpression::visit (AST::QualifiedPathInExpression &expr) mappings.insert_hir_path_expr_seg (lowered_seg); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); diff --git a/gcc/rust/metadata/rust-export-metadata.cc b/gcc/rust/metadata/rust-export-metadata.cc index 4c36be9f5ae2..1030f32092b2 100644 --- a/gcc/rust/metadata/rust-export-metadata.cc +++ b/gcc/rust/metadata/rust-export-metadata.cc @@ -95,9 +95,9 @@ PublicInterface::ExportTo (HIR::Crate &crate, const std::string &output_path) void PublicInterface::gather_export_data () { - auto crate_num - = mappings.lookup_crate_num (crate.get_mappings ().get_nodeid ()); - auto &ast_crate = mappings.get_ast_crate (crate_num.value ()); + auto crate_num = mappings.crate_mapping.lookup_crate_num ( + crate.get_mappings ().get_nodeid ()); + auto &ast_crate = mappings.crate_mapping.get_ast_crate (crate_num.value ()); context.emit_crate (ast_crate); for (auto ¯o : mappings.get_exported_macros ()) @@ -120,7 +120,8 @@ PublicInterface::write_to_object_file () const md5_finish_ctx (&chksm, checksum); // MAGIC MD5 DLIM DLIM buffer-size DELIM contents - const std::string current_crate_name = mappings.get_current_crate_name (); + const std::string current_crate_name + = mappings.crate_mapping.get_current_crate_name (); // extern void rust_write_export_data (kMagicHeader, sizeof (kMagicHeader)); @@ -162,7 +163,8 @@ PublicInterface::write_to_path (const std::string &path) const md5_finish_ctx (&chksm, checksum); // MAGIC MD5 DLIM DLIM buffer-size DELIM contents - const std::string current_crate_name = mappings.get_current_crate_name (); + const std::string current_crate_name + = mappings.crate_mapping.get_current_crate_name (); // write to path FILE *nfd = fopen (path.c_str (), "wb"); @@ -264,7 +266,8 @@ PublicInterface::expected_metadata_filename () { auto &mappings = Analysis::Mappings::get (); - const std::string current_crate_name = mappings.get_current_crate_name (); + const std::string current_crate_name + = mappings.crate_mapping.get_current_crate_name (); return current_crate_name + extension_path; } diff --git a/gcc/rust/resolve/rust-default-resolver.cc b/gcc/rust/resolve/rust-default-resolver.cc index ac2b7b196586..0433156482d3 100644 --- a/gcc/rust/resolve/rust-default-resolver.cc +++ b/gcc/rust/resolve/rust-default-resolver.cc @@ -41,11 +41,11 @@ DefaultResolver::visit (AST::Crate &crate) AST::DefaultASTVisitor::visit (crate); }; - auto &mappings = Analysis::Mappings::get (); + auto &crate_mappings = Analysis::Mappings::get ().crate_mapping; - auto crate_num = mappings.lookup_crate_num (crate.get_node_id ()); + auto crate_num = crate_mappings.lookup_crate_num (crate.get_node_id ()); rust_assert (crate_num.has_value ()); - auto crate_name = mappings.get_crate_name (*crate_num); + auto crate_name = crate_mappings.get_crate_name (*crate_num); rust_assert (crate_name.has_value ()); ctx.canonical_ctx.scope_crate (crate.get_node_id (), *crate_name, inner_fn); @@ -482,11 +482,12 @@ void DefaultResolver::visit (AST::ExternCrate &crate) { auto &mappings = Analysis::Mappings::get (); + auto &crate_mappings = mappings.crate_mapping; tl::optional num_opt; if (crate.get_referenced_crate () == "self") - num_opt = mappings.get_current_crate (); + num_opt = crate_mappings.get_current_crate (); else - num_opt = mappings.lookup_crate_name (crate.get_referenced_crate ()); + num_opt = crate_mappings.lookup_crate_name (crate.get_referenced_crate ()); if (!num_opt) { @@ -497,7 +498,7 @@ DefaultResolver::visit (AST::ExternCrate &crate) CrateNum num = *num_opt; - AST::Crate &referenced_crate = mappings.get_ast_crate (num); + AST::Crate &referenced_crate = mappings.crate_mapping.get_ast_crate (num); auto sub_visitor_1 = [&, this] () { visit_extern_crate (crate, referenced_crate, num); }; @@ -505,7 +506,7 @@ DefaultResolver::visit (AST::ExternCrate &crate) auto sub_visitor_2 = [&] () { ctx.canonical_ctx.scope_crate (referenced_crate.get_node_id (), crate.get_referenced_crate () == "self" - ? mappings.get_current_crate_name () + ? crate_mappings.get_current_crate_name () : crate.get_referenced_crate (), std::move (sub_visitor_1)); }; diff --git a/gcc/rust/resolve/rust-forever-stack.h b/gcc/rust/resolve/rust-forever-stack.h index eb21331166cb..07eb6293bd3f 100644 --- a/gcc/rust/resolve/rust-forever-stack.h +++ b/gcc/rust/resolve/rust-forever-stack.h @@ -597,8 +597,9 @@ template class ForeverStack : public ForeverStackBase // TODO: Should we be using the forever stack root as the crate scope? // TODO: Is this how we should be getting the crate node id? - auto &mappings = Analysis::Mappings::get (); - root.id = *mappings.crate_num_to_nodeid (mappings.get_current_crate ()); + auto &crate_mappings = Analysis::Mappings::get ().crate_mapping; + root.id = *crate_mappings.crate_num_to_nodeid ( + crate_mappings.get_current_crate ()); } /** diff --git a/gcc/rust/resolve/rust-name-resolution-context.h b/gcc/rust/resolve/rust-name-resolution-context.h index e30c5b59e42a..8903b23ae327 100644 --- a/gcc/rust/resolve/rust-name-resolution-context.h +++ b/gcc/rust/resolve/rust-name-resolution-context.h @@ -253,8 +253,11 @@ class CanonicalPathRecordCrateRoot : public CanonicalPathRecord CanonicalPathRecordCrateRoot (NodeId node_id, std::string seg) : node_id (node_id), seg (std::move (seg)) { - rust_assert (Analysis::Mappings::get ().node_is_crate (node_id)); - crate_num = Analysis::Mappings::get ().lookup_crate_num (node_id).value (); + rust_assert ( + Analysis::Mappings::get ().crate_mapping.node_is_crate (node_id)); + crate_num = Analysis::Mappings::get () + .crate_mapping.lookup_crate_num (node_id) + .value (); } Resolver::CanonicalPath as_path (const NameResolutionContext &, @@ -276,7 +279,8 @@ class CanonicalPathRecordNormal : public CanonicalPathRecordWithParent : CanonicalPathRecordWithParent (parent_node_id), node_id (node_id), seg (std::move (seg)) { - rust_assert (!Analysis::Mappings::get ().node_is_crate (node_id)); + rust_assert ( + !Analysis::Mappings::get ().crate_mapping.node_is_crate (node_id)); } Resolver::CanonicalPath as_path (const NameResolutionContext &, diff --git a/gcc/rust/rust-session-manager.cc b/gcc/rust/rust-session-manager.cc index 4f4f8d411d83..f65b09264476 100644 --- a/gcc/rust/rust-session-manager.cc +++ b/gcc/rust/rust-session-manager.cc @@ -482,7 +482,6 @@ void Session::handle_crate_name (const char *filename, const AST::Crate &parsed_crate) { - auto &mappings = Analysis::Mappings::get (); auto crate_name_found = false; auto error = Error (UNDEF_LOCATION, std::string ()); @@ -544,8 +543,11 @@ Session::handle_crate_name (const char *filename, if (saw_errors ()) return; - CrateNum crate_num = mappings.get_next_crate_num (options.get_crate_name ()); - mappings.set_current_crate (crate_num); + auto &crate_mappings = Analysis::Mappings::get ().crate_mapping; + + CrateNum crate_num + = crate_mappings.get_next_crate_num (options.get_crate_name ()); + crate_mappings.set_current_crate (crate_num); } /** Parse additional attributes injected from the command line @@ -667,9 +669,10 @@ Session::compile_crate (const char *filename) } // setup the mappings for this AST - CrateNum current_crate = mappings.get_current_crate (); + CrateNum current_crate = mappings.crate_mapping.get_current_crate (); AST::Crate &parsed_crate - = mappings.insert_ast_crate (std::move (ast_crate), current_crate); + = mappings.crate_mapping.insert_ast_crate (std::move (ast_crate), + current_crate); /* basic pipeline: * - lex @@ -1253,10 +1256,11 @@ Session::dump_hir_pretty (HIR::Crate &crate) const tl::expected Session::load_extern_crate (const std::string &crate_name, location_t locus) { + auto &crate_mapping = mappings.crate_mapping; // has it already been loaded? - if (auto crate_num = mappings.lookup_crate_name (crate_name)) + if (auto crate_num = crate_mapping.lookup_crate_name (crate_name)) { - auto resolved_node_id = mappings.crate_num_to_nodeid (*crate_num); + auto resolved_node_id = crate_mapping.crate_num_to_nodeid (*crate_num); rust_assert (resolved_node_id); return tl::make_unexpected ( @@ -1309,7 +1313,8 @@ Session::load_extern_crate (const std::string &crate_name, location_t locus) } // ensure the current vs this crate name don't collide - const std::string current_crate_name = mappings.get_current_crate_name (); + const std::string current_crate_name + = crate_mapping.get_current_crate_name (); if (current_crate_name.compare (extern_crate.get_crate_name ()) == 0) { rust_error_at (locus, "current crate name %qs collides with this", @@ -1318,10 +1323,10 @@ Session::load_extern_crate (const std::string &crate_name, location_t locus) } // setup mappings - CrateNum saved_crate_num = mappings.get_current_crate (); + CrateNum saved_crate_num = crate_mapping.get_current_crate (); CrateNum crate_num - = mappings.get_next_crate_num (extern_crate.get_crate_name ()); - mappings.set_current_crate (crate_num); + = crate_mapping.get_next_crate_num (extern_crate.get_crate_name ()); + crate_mapping.set_current_crate (crate_num); // then lets parse this as a 2nd crate Lexer lex (extern_crate.get_metadata (), linemap); @@ -1329,7 +1334,8 @@ Session::load_extern_crate (const std::string &crate_name, location_t locus) std::unique_ptr metadata_crate = parser.parse_crate (); AST::Crate &parsed_crate - = mappings.insert_ast_crate (std::move (metadata_crate), crate_num); + = mappings.crate_mapping.insert_ast_crate (std::move (metadata_crate), + crate_num); auto ctx = Resolver2_0::NameResolutionContext (); Resolver2_0::Builtins::setup_lang_prelude (ctx); @@ -1365,7 +1371,7 @@ Session::load_extern_crate (const std::string &crate_name, location_t locus) mappings.insert_derive_proc_macros (crate_num, derive_macros); // always restore the crate_num - mappings.set_current_crate (saved_crate_num); + crate_mapping.set_current_crate (saved_crate_num); return LoadedCrate{crate_name, parsed_crate.get_node_id (), std::move (ctx)}; } diff --git a/gcc/rust/typecheck/rust-hir-type-check-base.cc b/gcc/rust/typecheck/rust-hir-type-check-base.cc index f5f457f60203..2bcc778c6845 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-base.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-base.cc @@ -386,7 +386,7 @@ TypeCheckBase::resolve_literal (const Analysis::NodeMapping &expr_mappings, auto ok = context->lookup_builtin ("u8", &u8); rust_assert (ok); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping capacity_mapping (crate_num, UNKNOWN_NODEID, mappings.get_next_hir_id ( crate_num), diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc index b2e10c6225bd..0f02b3698dda 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc @@ -1210,7 +1210,7 @@ TypeCheckExpr::visit (HIR::ArrayExpr &expr) expr.get_locus ()); } - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, UNKNOWN_NODEID, mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -1998,7 +1998,7 @@ TypeCheckExpr::visit (HIR::ClosureExpr &expr) // lets generate an implicit Type so that it resolves to the implict tuple // type we have created - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_mappings ().get_nodeid (), implicit_args_id, UNKNOWN_LOCAL_DEFID); HIR::TupleType *implicit_tuple @@ -2401,8 +2401,9 @@ TypeCheckExpr::resolve_fn_trait_call (HIR::CallExpr &expr, // crate implicit tuple HirId implicit_arg_id = mappings.get_next_hir_id (); - Analysis::NodeMapping mapping (mappings.get_current_crate (), UNKNOWN_NODEID, - implicit_arg_id, UNKNOWN_LOCAL_DEFID); + Analysis::NodeMapping mapping (mappings.crate_mapping.get_current_crate (), + UNKNOWN_NODEID, implicit_arg_id, + UNKNOWN_LOCAL_DEFID); TyTy::TupleType *tuple = new TyTy::TupleType (implicit_arg_id, expr.get_locus (), call_args); diff --git a/gcc/rust/typecheck/rust-hir-type-check-implitem.cc b/gcc/rust/typecheck/rust-hir-type-check-implitem.cc index 8c65390f781c..5886e57968d7 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-implitem.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-implitem.cc @@ -108,7 +108,7 @@ TypeCheckTopLevelExternItem::visit (HIR::ExternalFunctionItem &function) auto param_tyty = TypeCheckType::Resolve (param.get_type ()); // these are implicit mappings and not used - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, mappings.get_next_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -273,7 +273,7 @@ TypeCheckImplItem::resolve_function_signature (HIR::Function &function) if (function.is_method ()) { // these are implicit mappings and not used - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, mappings.get_next_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.cc b/gcc/rust/typecheck/rust-hir-type-check-item.cc index 5f54c0726fa4..17067603719d 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-item.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-item.cc @@ -1132,17 +1132,17 @@ TypeCheckItem::visit (HIR::ExternCrate &extern_crate) if (extern_crate.references_self ()) return; - auto &mappings = Analysis::Mappings::get (); + auto &crate_mappings = Analysis::Mappings::get ().crate_mapping; CrateNum num - = mappings.lookup_crate_name (extern_crate.get_referenced_crate ()) + = crate_mappings.lookup_crate_name (extern_crate.get_referenced_crate ()) .value (); HIR::Crate &crate = mappings.get_hir_crate (num); - CrateNum saved_crate_num = mappings.get_current_crate (); - mappings.set_current_crate (num); + CrateNum saved_crate_num = crate_mappings.get_current_crate (); + crate_mappings.set_current_crate (num); for (auto &item : crate.get_items ()) TypeCheckItem::Resolve (*item); - mappings.set_current_crate (saved_crate_num); + crate_mappings.set_current_crate (saved_crate_num); } std::pair, TyTy::RegionConstraints> diff --git a/gcc/rust/typecheck/rust-hir-type-check-struct.cc b/gcc/rust/typecheck/rust-hir-type-check-struct.cc index b6ea1028f7a5..8c3d540c17c6 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-struct.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-struct.cc @@ -191,7 +191,7 @@ TypeCheckStructExpr::resolve (HIR::StructExprStructFields &struct_expr) HIR::StructExprField *implicit_field = nullptr; AST::AttrVec outer_attribs; - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, struct_expr.get_struct_base () .get_base () diff --git a/gcc/rust/typecheck/rust-hir-type-check.cc b/gcc/rust/typecheck/rust-hir-type-check.cc index d4c21d09ca84..25048a38f11c 100644 --- a/gcc/rust/typecheck/rust-hir-type-check.cc +++ b/gcc/rust/typecheck/rust-hir-type-check.cc @@ -206,7 +206,7 @@ TraitItemReference::get_type_from_fn (/*const*/ HIR::TraitItemFunc &fn) const { // these are implicit mappings and not used auto &mappings = Analysis::Mappings::get (); - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); Analysis::NodeMapping mapping (crate_num, mappings.get_next_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); diff --git a/gcc/rust/typecheck/rust-type-util.cc b/gcc/rust/typecheck/rust-type-util.cc index 7df36f0d3cff..96367df5cb5f 100644 --- a/gcc/rust/typecheck/rust-type-util.cc +++ b/gcc/rust/typecheck/rust-type-util.cc @@ -76,7 +76,8 @@ query_type (HirId reference, TyTy::BaseType **result) reference); DefId item_defid = item.value ()->get_mappings ().get_defid (); - bool is_local = item_defid.crateNum == mappings.get_current_crate (); + bool is_local + = item_defid.crateNum == mappings.crate_mapping.get_current_crate (); bool is_fn = item.value ()->get_item_kind () == HIR::Item::ItemKind::Function; bool is_const_fn = false; @@ -164,7 +165,8 @@ query_type (HirId reference, TyTy::BaseType **result) "resolved impl-item {%u} to", reference); DefId item_defid = impl_item->first->get_impl_mappings ().get_defid (); - bool is_local = item_defid.crateNum == mappings.get_current_crate (); + bool is_local + = item_defid.crateNum == mappings.crate_mapping.get_current_crate (); bool is_fn = impl_item->first->get_impl_item_type () == HIR::ImplItem::FUNCTION; bool is_const_fn = false; diff --git a/gcc/rust/typecheck/rust-tyty-bounds.cc b/gcc/rust/typecheck/rust-tyty-bounds.cc index 0d762c8c09c1..a00cb6b3d4a9 100644 --- a/gcc/rust/typecheck/rust-tyty-bounds.cc +++ b/gcc/rust/typecheck/rust-tyty-bounds.cc @@ -316,7 +316,7 @@ TypeCheckBase::get_predicate_from_bound ( // we need to make implicit generic args which must be an implicit // Tuple - auto crate_num = mappings.get_current_crate (); + auto crate_num = mappings.crate_mapping.get_current_crate (); HirId implicit_args_id = mappings.get_next_hir_id (); Analysis::NodeMapping mapping (crate_num, final_seg.get_mappings ().get_nodeid (), diff --git a/gcc/rust/typecheck/rust-tyty-subst.cc b/gcc/rust/typecheck/rust-tyty-subst.cc index ba237bcc7447..08b618e8cca8 100644 --- a/gcc/rust/typecheck/rust-tyty-subst.cc +++ b/gcc/rust/typecheck/rust-tyty-subst.cc @@ -238,11 +238,11 @@ SubstitutionParamMapping::override_context () auto &mappings = Analysis::Mappings::get (); auto context = Resolver::TypeCheckContext::get (); - context->insert_type (Analysis::NodeMapping (mappings.get_current_crate (), - UNKNOWN_NODEID, - param->get_ref (), - UNKNOWN_LOCAL_DEFID), - param->resolve ()); + context->insert_type ( + Analysis::NodeMapping (mappings.crate_mapping.get_current_crate (), + UNKNOWN_NODEID, param->get_ref (), + UNKNOWN_LOCAL_DEFID), + param->resolve ()); } SubstitutionArg::SubstitutionArg (const SubstitutionParamMapping *param, diff --git a/gcc/rust/typecheck/rust-tyty-util.cc b/gcc/rust/typecheck/rust-tyty-util.cc index c9f8becb12c6..d63f4549587e 100644 --- a/gcc/rust/typecheck/rust-tyty-util.cc +++ b/gcc/rust/typecheck/rust-tyty-util.cc @@ -120,10 +120,10 @@ TyVar::monomorphized_clone () const c->set_ref (mappings.get_next_hir_id ()); // insert it - context->insert_type (Analysis::NodeMapping (mappings.get_current_crate (), - UNKNOWN_NODEID, c->get_ref (), - UNKNOWN_LOCAL_DEFID), - c); + context->insert_type ( + Analysis::NodeMapping (mappings.crate_mapping.get_current_crate (), + UNKNOWN_NODEID, c->get_ref (), UNKNOWN_LOCAL_DEFID), + c); return TyVar (c->get_ref ()); } diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc index a9b3dcc5e6ae..b3696afa1605 100644 --- a/gcc/rust/typecheck/rust-tyty.cc +++ b/gcc/rust/typecheck/rust-tyty.cc @@ -1371,11 +1371,11 @@ InferType::clone () const = new InferType (mappings.get_next_hir_id (), get_infer_kind (), default_hint, get_ident ().locus, get_combined_refs ()); - context->insert_type (Analysis::NodeMapping (mappings.get_current_crate (), - UNKNOWN_NODEID, - clone->get_ref (), - UNKNOWN_LOCAL_DEFID), - clone); + context->insert_type ( + Analysis::NodeMapping (mappings.crate_mapping.get_current_crate (), + UNKNOWN_NODEID, clone->get_ref (), + UNKNOWN_LOCAL_DEFID), + clone); mappings.insert_location (clone->get_ref (), mappings.lookup_location (get_ref ())); @@ -4212,11 +4212,11 @@ ConstInferType::clone () const = new ConstInferType (specified_type, mappings.get_next_hir_id (), get_ty_ref (), get_combined_refs ()); - context->insert_type (Analysis::NodeMapping (mappings.get_current_crate (), - UNKNOWN_NODEID, - clone->get_ref (), - UNKNOWN_LOCAL_DEFID), - clone); + context->insert_type ( + Analysis::NodeMapping (mappings.crate_mapping.get_current_crate (), + UNKNOWN_NODEID, clone->get_ref (), + UNKNOWN_LOCAL_DEFID), + clone); mappings.insert_location (clone->get_ref (), mappings.lookup_location (get_ref ())); diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index 1151c5cae19c..6a96102ca3f5 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -98,9 +98,12 @@ static const HirId kDefaultNodeIdBegin = 1; static const HirId kDefaultHirIdBegin = 1; static const HirId kDefaultCrateNumBegin = 0; +CrateMappings::CrateMappings () + : crateNumItr (kDefaultCrateNumBegin), currentCrateNum (UNKNOWN_CRATENUM) +{} + Mappings::Mappings () - : crateNumItr (kDefaultCrateNumBegin), currentCrateNum (UNKNOWN_CRATENUM), - hirIdIter (kDefaultHirIdBegin), nodeIdIter (kDefaultNodeIdBegin), + : hirIdIter (kDefaultHirIdBegin), nodeIdIter (kDefaultNodeIdBegin), hirImplIndexesBuilt (false) { Analysis::NodeMapping node (0, 0, 0, 0); @@ -121,7 +124,7 @@ Mappings::get () } CrateNum -Mappings::get_next_crate_num (const std::string &name) +CrateMappings::get_next_crate_num (const std::string &name) { auto id = crateNumItr; crateNumItr++; @@ -130,19 +133,19 @@ Mappings::get_next_crate_num (const std::string &name) } void -Mappings::set_current_crate (CrateNum crateNum) +CrateMappings::set_current_crate (CrateNum crateNum) { currentCrateNum = crateNum; } CrateNum -Mappings::get_current_crate () const +CrateMappings::get_current_crate () const { return currentCrateNum; } tl::optional -Mappings::get_crate_name (CrateNum crate_num) const +CrateMappings::get_crate_name (CrateNum crate_num) const { auto it = crate_names.find (crate_num); if (it == crate_names.end ()) @@ -152,7 +155,7 @@ Mappings::get_crate_name (CrateNum crate_num) const } tl::optional -Mappings::lookup_crate_num (NodeId node_id) const +CrateMappings::lookup_crate_num (NodeId node_id) const { auto it = crate_node_to_crate_num.find (node_id); if (it == crate_node_to_crate_num.end ()) @@ -162,19 +165,19 @@ Mappings::lookup_crate_num (NodeId node_id) const } void -Mappings::set_crate_name (CrateNum crate_num, const std::string &name) +CrateMappings::set_crate_name (CrateNum crate_num, const std::string &name) { crate_names[crate_num] = name; } const std::string & -Mappings::get_current_crate_name () const +CrateMappings::get_current_crate_name () const { return get_crate_name (get_current_crate ()).value (); } tl::optional -Mappings::lookup_crate_name (const std::string &crate_name) const +CrateMappings::lookup_crate_name (const std::string &crate_name) const { for (const auto &it : crate_names) { @@ -185,7 +188,7 @@ Mappings::lookup_crate_name (const std::string &crate_name) const } tl::optional -Mappings::crate_num_to_nodeid (const CrateNum &crate_num) const +CrateMappings::crate_num_to_nodeid (const CrateNum &crate_num) const { auto it = ast_crate_mappings.find (crate_num); if (it == ast_crate_mappings.end ()) @@ -195,7 +198,7 @@ Mappings::crate_num_to_nodeid (const CrateNum &crate_num) const } bool -Mappings::node_is_crate (NodeId node_id) const +CrateMappings::node_is_crate (NodeId node_id) const { return lookup_crate_num (node_id).has_value (); } @@ -244,7 +247,7 @@ Mappings::get_next_localdef_id (CrateNum crateNum) } AST::Crate & -Mappings::get_ast_crate (CrateNum crateNum) +CrateMappings::get_ast_crate (CrateNum crateNum) { auto it = ast_crate_mappings.find (crateNum); rust_assert (it != ast_crate_mappings.end ()); @@ -254,11 +257,11 @@ Mappings::get_ast_crate (CrateNum crateNum) AST::Crate & Mappings::get_ast_crate_by_node_id (NodeId id) { - return *get_ast_crate_by_node_id_raw (id); + return *crate_mapping.get_ast_crate_by_node_id_raw (id); } AST::Crate * -Mappings::get_ast_crate_by_node_id_raw (NodeId id) +CrateMappings::get_ast_crate_by_node_id_raw (NodeId id) { CrateNum crateNum = lookup_crate_num (id).value (); auto it = ast_crate_mappings.find (crateNum); @@ -267,8 +270,8 @@ Mappings::get_ast_crate_by_node_id_raw (NodeId id) } AST::Crate & -Mappings::insert_ast_crate (std::unique_ptr &&crate, - CrateNum crate_num) +CrateMappings::insert_ast_crate (std::unique_ptr &&crate, + CrateNum crate_num) { auto it = ast_crate_mappings.find (crate_num); rust_assert (it == ast_crate_mappings.end ()); @@ -1074,7 +1077,8 @@ Mappings::insert_macro_def (AST::MacroRulesDefinition *macro) auto it = macroMappings.find (macro->get_node_id ()); rust_assert (it == macroMappings.end ()); - macroMappings[macro->get_node_id ()] = {macro, currentCrateNum}; + macroMappings[macro->get_node_id ()] + = {macro, crate_mapping.get_current_crate ()}; } tl::optional @@ -1349,7 +1353,7 @@ Mappings::insert_glob_container (NodeId id, AST::GlobContainer *container) // Crates have different memory managements that regular items if (container->get_glob_container_kind () == AST::GlobContainer::Kind::Crate) - glob_containers[id] = get_ast_crate_by_node_id_raw (id); + glob_containers[id] = crate_mapping.get_ast_crate_by_node_id_raw (id); else glob_containers[id] = container; } diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index 344e13414fef..d92f0e0f16a7 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -71,11 +71,21 @@ class NodeMapping LocalDefId localDefId; }; -class Mappings +class CrateMappings { + std::map ast_crate_mappings; + + // crate names + std::map crate_names; + + CrateNum crateNumItr; + + CrateNum currentCrateNum; + + std::map crate_node_to_crate_num; + public: - static Mappings &get (); - ~Mappings (); + CrateMappings (); CrateNum get_next_crate_num (const std::string &name); void set_current_crate (CrateNum crateNum); @@ -90,19 +100,35 @@ class Mappings tl::optional crate_num_to_nodeid (const CrateNum &crate_num) const; bool node_is_crate (NodeId node_id) const; + AST::Crate &insert_ast_crate (std::unique_ptr &&crate, + CrateNum crate_num); + + AST::Crate &get_ast_crate (CrateNum crateNum); + + AST::Crate *get_ast_crate_by_node_id_raw (NodeId id); +}; + +class Mappings +{ +public: + static Mappings &get (); + ~Mappings (); + + CrateMappings crate_mapping; + NodeId get_next_node_id (); - HirId get_next_hir_id () { return get_next_hir_id (get_current_crate ()); } + HirId get_next_hir_id () + { + return get_next_hir_id (crate_mapping.get_current_crate ()); + } HirId get_next_hir_id (CrateNum crateNum); LocalDefId get_next_localdef_id () { - return get_next_localdef_id (get_current_crate ()); + return get_next_localdef_id (crate_mapping.get_current_crate ()); } LocalDefId get_next_localdef_id (CrateNum crateNum); - AST::Crate &get_ast_crate (CrateNum crateNum); AST::Crate &get_ast_crate_by_node_id (NodeId id); - AST::Crate &insert_ast_crate (std::unique_ptr &&crate, - CrateNum crate_num); HIR::Crate &insert_hir_crate (std::unique_ptr &&crate); HIR::Crate &get_hir_crate (CrateNum crateNum); bool is_local_hirid_crate (HirId crateNum); @@ -403,17 +429,11 @@ class Mappings private: Mappings (); - CrateNum crateNumItr; - CrateNum currentCrateNum; HirId hirIdIter; NodeId nodeIdIter; std::map localIdIter; HIR::ImplBlock *builtinMarker; - AST::Crate *get_ast_crate_by_node_id_raw (NodeId id); - - std::map crate_node_to_crate_num; - std::map ast_crate_mappings; std::map hir_crate_mappings; std::map defIdMappings; std::map defIdTraitItemMappings; @@ -485,9 +505,6 @@ class Mappings std::map procmacroBangInvocations; std::map procmacroAttributeInvocations; - // crate names - std::map crate_names; - // Low level visibility map for each DefId std::map visibility_map; From 49c9ce9f04ced52b534eb8ebbc584ec443d79868 Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Thu, 10 Sep 2026 20:27:43 +0200 Subject: [PATCH 574/584] Regroup proc macro related mappings HIR map is getting bigger and harder to use. This commit regroup all proc macro related operations under one subclass. gcc/rust/ChangeLog: * expand/rust-macro-expand.h (struct MacroExpander): Use new macro category. * resolve/rust-early-name-resolver-2.0.cc (Early::visit_derive_attribute): Likewise. (Early::visit_non_builtin_attribute): Likewise. * resolve/rust-toplevel-name-resolver-2.0.cc (TopLevel::visit_extern_crate): Likewise. * rust-session-manager.cc (Session::load_extern_crate): Likewise. * util/rust-hir-map.cc (Mappings::insert_derive_proc_macros): Move to specialized macro class declartion. (Mappings::insert_bang_proc_macros): Move from here... (ProcMacroMappings::insert_bang_proc_macros): ... to here. (Mappings::insert_attribute_proc_macros): Likewise. (Mappings::lookup_derive_proc_macros): Likewise. (ProcMacroMappings::lookup_derive_proc_macros): Likewise. (Mappings::lookup_bang_proc_macros): Likewise. (ProcMacroMappings::lookup_bang_proc_macros): Likewise. (Mappings::lookup_attribute_proc_macros): Likewise. (ProcMacroMappings::lookup_attribute_proc_macros): Likewise. (Mappings::insert_derive_proc_macro_def): Likewise. (ProcMacroMappings::insert_derive_proc_macro_def): Likewise. (Mappings::insert_bang_proc_macro_def): Likewise. (ProcMacroMappings::insert_bang_proc_macro_def): Likewise. (Mappings::insert_attribute_proc_macro_def): Likewise. (ProcMacroMappings::insert_attribute_proc_macro_def): Likewise. (Mappings::lookup_derive_proc_macro_def): Likewise. (ProcMacroMappings::lookup_derive_proc_macro_def): Likewise. (Mappings::lookup_bang_proc_macro_def): Likewise. (ProcMacroMappings::lookup_bang_proc_macro_def): Likewise. (Mappings::lookup_attribute_proc_macro_def): Likewise. (ProcMacroMappings::lookup_attribute_proc_macro_def): Likewise. (Mappings::insert_derive_proc_macro_invocation): Likewise. (Mappings::lookup_derive_proc_macro_invocation): Likewise. (ProcMacroMappings::lookup_derive_proc_macro_invocation): Likewise. (Mappings::insert_bang_proc_macro_invocation): Likewise. (Mappings::lookup_bang_proc_macro_invocation): Likewise. (Mappings::insert_attribute_proc_macro_invocation): Likewise. (Mappings::lookup_attribute_proc_macro_invocation): Likewise. * util/rust-hir-map.h (class ProcMacroMappings): Add specialized class for macro mappings. Signed-off-by: Pierre-Emmanuel Patry --- gcc/rust/expand/rust-macro-expand.h | 6 +- .../resolve/rust-early-name-resolver-2.0.cc | 11 +- .../rust-toplevel-name-resolver-2.0.cc | 13 ++- gcc/rust/rust-session-manager.cc | 7 +- gcc/rust/util/rust-hir-map.cc | 50 +++++---- gcc/rust/util/rust-hir-map.h | 106 +++++++++--------- 6 files changed, 101 insertions(+), 92 deletions(-) diff --git a/gcc/rust/expand/rust-macro-expand.h b/gcc/rust/expand/rust-macro-expand.h index 23e98e071eab..ddd433c39369 100644 --- a/gcc/rust/expand/rust-macro-expand.h +++ b/gcc/rust/expand/rust-macro-expand.h @@ -412,7 +412,7 @@ struct MacroExpander AST::Fragment expand_derive_proc_macro (T &item, AST::SimplePath &path) { tl::optional macro - = mappings.lookup_derive_proc_macro_invocation (path); + = mappings.pmacro_mappings.lookup_derive_proc_macro_invocation (path); if (!macro.has_value ()) { rust_error_at (path.get_locus (), "macro not found"); @@ -435,7 +435,7 @@ struct MacroExpander AST::MacroInvocation &invocation) { tl::optional macro - = mappings.lookup_bang_proc_macro_invocation (invocation); + = mappings.pmacro_mappings.lookup_bang_proc_macro_invocation (invocation); if (!macro.has_value ()) { rust_error_at (invocation.get_locus (), "macro not found"); @@ -457,7 +457,7 @@ struct MacroExpander AST::Fragment expand_attribute_proc_macro (T &item, AST::SimplePath &path) { tl::optional macro - = mappings.lookup_attribute_proc_macro_invocation (path); + = mappings.pmacro_mappings.lookup_attribute_proc_macro_invocation (path); if (!macro.has_value ()) { rust_error_at (path.get_locus (), "macro not found"); diff --git a/gcc/rust/resolve/rust-early-name-resolver-2.0.cc b/gcc/rust/resolve/rust-early-name-resolver-2.0.cc index aae601e92465..d4d0cb8e1ec8 100644 --- a/gcc/rust/resolve/rust-early-name-resolver-2.0.cc +++ b/gcc/rust/resolve/rust-early-name-resolver-2.0.cc @@ -402,11 +402,12 @@ Early::visit_derive_attribute (AST::Attribute &attr, continue; } - auto pm_def = mappings.lookup_derive_proc_macro_def ( + auto pm_def = mappings.pmacro_mappings.lookup_derive_proc_macro_def ( ns_def->definition.get_node_id ()); if (pm_def.has_value ()) - mappings.insert_derive_proc_macro_invocation (trait, pm_def.value ()); + mappings.pmacro_mappings.insert_derive_proc_macro_invocation ( + trait, pm_def.value ()); } } @@ -424,14 +425,14 @@ Early::visit_non_builtin_attribute (AST::Attribute &attr, name.c_str ())); return; } - auto pm_def = mappings.lookup_attribute_proc_macro_def ( + auto pm_def = mappings.pmacro_mappings.lookup_attribute_proc_macro_def ( ns_def->definition.get_node_id ()); if (!pm_def.has_value ()) return; - mappings.insert_attribute_proc_macro_invocation (attr.get_path (), - pm_def.value ()); + mappings.pmacro_mappings.insert_attribute_proc_macro_invocation ( + attr.get_path (), pm_def.value ()); } void diff --git a/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc b/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc index c7f35b62859e..88b946649f4b 100644 --- a/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc +++ b/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc @@ -187,30 +187,31 @@ TopLevel::visit_extern_crate (AST::ExternCrate &extern_crate, AST::Crate &crate, { auto &mappings = Analysis::Mappings::get (); - auto attribute_macros = mappings.lookup_attribute_proc_macros (num); + auto attribute_macros + = mappings.pmacro_mappings.lookup_attribute_proc_macros (num); - auto bang_macros = mappings.lookup_bang_proc_macros (num); + auto bang_macros = mappings.pmacro_mappings.lookup_bang_proc_macros (num); - auto derive_macros = mappings.lookup_derive_proc_macros (num); + auto derive_macros = mappings.pmacro_mappings.lookup_derive_proc_macros (num); // TODO: Find a way to keep this part clean without the double dispatch. if (derive_macros.has_value ()) { insert_macros (derive_macros.value (), ctx); for (auto ¯o : derive_macros.value ()) - mappings.insert_derive_proc_macro_def (macro); + mappings.pmacro_mappings.insert_derive_proc_macro_def (macro); } if (attribute_macros.has_value ()) { insert_macros (attribute_macros.value (), ctx); for (auto ¯o : attribute_macros.value ()) - mappings.insert_attribute_proc_macro_def (macro); + mappings.pmacro_mappings.insert_attribute_proc_macro_def (macro); } if (bang_macros.has_value ()) { insert_macros (bang_macros.value (), ctx); for (auto ¯o : bang_macros.value ()) - mappings.insert_bang_proc_macro_def (macro); + mappings.pmacro_mappings.insert_bang_proc_macro_def (macro); } // We do *NOT* visit the crate because loaded crates are resolved diff --git a/gcc/rust/rust-session-manager.cc b/gcc/rust/rust-session-manager.cc index f65b09264476..868216024a1b 100644 --- a/gcc/rust/rust-session-manager.cc +++ b/gcc/rust/rust-session-manager.cc @@ -1366,9 +1366,10 @@ Session::load_extern_crate (const std::string &crate_name, location_t locus) } } - mappings.insert_attribute_proc_macros (crate_num, attribute_macros); - mappings.insert_bang_proc_macros (crate_num, bang_macros); - mappings.insert_derive_proc_macros (crate_num, derive_macros); + mappings.pmacro_mappings.insert_attribute_proc_macros (crate_num, + attribute_macros); + mappings.pmacro_mappings.insert_bang_proc_macros (crate_num, bang_macros); + mappings.pmacro_mappings.insert_derive_proc_macros (crate_num, derive_macros); // always restore the crate_num crate_mapping.set_current_crate (saved_crate_num); diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index 6a96102ca3f5..af3d6f222319 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -1134,8 +1134,8 @@ Mappings::get_exported_macros () } void -Mappings::insert_derive_proc_macros (CrateNum num, - std::vector macros) +ProcMacroMappings::insert_derive_proc_macros ( + CrateNum num, std::vector macros) { auto it = procmacrosDeriveMappings.find (num); rust_assert (it == procmacrosDeriveMappings.end ()); @@ -1144,8 +1144,8 @@ Mappings::insert_derive_proc_macros (CrateNum num, } void -Mappings::insert_bang_proc_macros (CrateNum num, - std::vector macros) +ProcMacroMappings::insert_bang_proc_macros (CrateNum num, + std::vector macros) { auto it = procmacrosBangMappings.find (num); rust_assert (it == procmacrosBangMappings.end ()); @@ -1154,8 +1154,8 @@ Mappings::insert_bang_proc_macros (CrateNum num, } void -Mappings::insert_attribute_proc_macros (CrateNum num, - std::vector macros) +ProcMacroMappings::insert_attribute_proc_macros ( + CrateNum num, std::vector macros) { auto it = procmacrosAttributeMappings.find (num); rust_assert (it == procmacrosAttributeMappings.end ()); @@ -1164,7 +1164,7 @@ Mappings::insert_attribute_proc_macros (CrateNum num, } tl::optional &> -Mappings::lookup_derive_proc_macros (CrateNum num) +ProcMacroMappings::lookup_derive_proc_macros (CrateNum num) { auto it = procmacrosDeriveMappings.find (num); if (it == procmacrosDeriveMappings.end ()) @@ -1174,7 +1174,7 @@ Mappings::lookup_derive_proc_macros (CrateNum num) } tl::optional &> -Mappings::lookup_bang_proc_macros (CrateNum num) +ProcMacroMappings::lookup_bang_proc_macros (CrateNum num) { auto it = procmacrosBangMappings.find (num); if (it == procmacrosBangMappings.end ()) @@ -1184,7 +1184,7 @@ Mappings::lookup_bang_proc_macros (CrateNum num) } tl::optional &> -Mappings::lookup_attribute_proc_macros (CrateNum num) +ProcMacroMappings::lookup_attribute_proc_macros (CrateNum num) { auto it = procmacrosAttributeMappings.find (num); if (it == procmacrosAttributeMappings.end ()) @@ -1194,7 +1194,7 @@ Mappings::lookup_attribute_proc_macros (CrateNum num) } void -Mappings::insert_derive_proc_macro_def (CustomDeriveProcMacro macro) +ProcMacroMappings::insert_derive_proc_macro_def (CustomDeriveProcMacro macro) { auto it = procmacroDeriveMappings.find (macro.get_node_id ()); rust_assert (it == procmacroDeriveMappings.end ()); @@ -1203,7 +1203,7 @@ Mappings::insert_derive_proc_macro_def (CustomDeriveProcMacro macro) } void -Mappings::insert_bang_proc_macro_def (BangProcMacro macro) +ProcMacroMappings::insert_bang_proc_macro_def (BangProcMacro macro) { auto it = procmacroBangMappings.find (macro.get_node_id ()); rust_assert (it == procmacroBangMappings.end ()); @@ -1212,7 +1212,7 @@ Mappings::insert_bang_proc_macro_def (BangProcMacro macro) } void -Mappings::insert_attribute_proc_macro_def (AttributeProcMacro macro) +ProcMacroMappings::insert_attribute_proc_macro_def (AttributeProcMacro macro) { auto it = procmacroAttributeMappings.find (macro.get_node_id ()); rust_assert (it == procmacroAttributeMappings.end ()); @@ -1221,7 +1221,7 @@ Mappings::insert_attribute_proc_macro_def (AttributeProcMacro macro) } tl::optional -Mappings::lookup_derive_proc_macro_def (NodeId id) +ProcMacroMappings::lookup_derive_proc_macro_def (NodeId id) { auto it = procmacroDeriveMappings.find (id); if (it == procmacroDeriveMappings.end ()) @@ -1231,7 +1231,7 @@ Mappings::lookup_derive_proc_macro_def (NodeId id) } tl::optional -Mappings::lookup_bang_proc_macro_def (NodeId id) +ProcMacroMappings::lookup_bang_proc_macro_def (NodeId id) { auto it = procmacroBangMappings.find (id); if (it == procmacroBangMappings.end ()) @@ -1241,7 +1241,7 @@ Mappings::lookup_bang_proc_macro_def (NodeId id) } tl::optional -Mappings::lookup_attribute_proc_macro_def (NodeId id) +ProcMacroMappings::lookup_attribute_proc_macro_def (NodeId id) { auto it = procmacroAttributeMappings.find (id); if (it == procmacroAttributeMappings.end ()) @@ -1251,8 +1251,8 @@ Mappings::lookup_attribute_proc_macro_def (NodeId id) } void -Mappings::insert_derive_proc_macro_invocation (AST::SimplePath &invoc, - CustomDeriveProcMacro def) +ProcMacroMappings::insert_derive_proc_macro_invocation ( + AST::SimplePath &invoc, CustomDeriveProcMacro def) { auto it = procmacroDeriveInvocations.find (invoc.get_node_id ()); rust_assert (it == procmacroDeriveInvocations.end ()); @@ -1261,7 +1261,7 @@ Mappings::insert_derive_proc_macro_invocation (AST::SimplePath &invoc, } tl::optional -Mappings::lookup_derive_proc_macro_invocation (AST::SimplePath &invoc) +ProcMacroMappings::lookup_derive_proc_macro_invocation (AST::SimplePath &invoc) { auto it = procmacroDeriveInvocations.find (invoc.get_node_id ()); if (it == procmacroDeriveInvocations.end ()) @@ -1271,8 +1271,8 @@ Mappings::lookup_derive_proc_macro_invocation (AST::SimplePath &invoc) } void -Mappings::insert_bang_proc_macro_invocation (AST::MacroInvocation &invoc, - BangProcMacro def) +ProcMacroMappings::insert_bang_proc_macro_invocation ( + AST::MacroInvocation &invoc, BangProcMacro def) { auto it = procmacroBangInvocations.find (invoc.get_node_id ()); rust_assert (it == procmacroBangInvocations.end ()); @@ -1281,7 +1281,8 @@ Mappings::insert_bang_proc_macro_invocation (AST::MacroInvocation &invoc, } tl::optional -Mappings::lookup_bang_proc_macro_invocation (AST::MacroInvocation &invoc) +ProcMacroMappings::lookup_bang_proc_macro_invocation ( + AST::MacroInvocation &invoc) { auto it = procmacroBangInvocations.find (invoc.get_node_id ()); if (it == procmacroBangInvocations.end ()) @@ -1291,8 +1292,8 @@ Mappings::lookup_bang_proc_macro_invocation (AST::MacroInvocation &invoc) } void -Mappings::insert_attribute_proc_macro_invocation (AST::SimplePath &invoc, - AttributeProcMacro def) +ProcMacroMappings::insert_attribute_proc_macro_invocation ( + AST::SimplePath &invoc, AttributeProcMacro def) { auto it = procmacroAttributeInvocations.find (invoc.get_node_id ()); rust_assert (it == procmacroAttributeInvocations.end ()); @@ -1301,7 +1302,8 @@ Mappings::insert_attribute_proc_macro_invocation (AST::SimplePath &invoc, } tl::optional -Mappings::lookup_attribute_proc_macro_invocation (AST::SimplePath &invoc) +ProcMacroMappings::lookup_attribute_proc_macro_invocation ( + AST::SimplePath &invoc) { auto it = procmacroAttributeInvocations.find (invoc.get_node_id ()); if (it == procmacroAttributeInvocations.end ()) diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index d92f0e0f16a7..a7f631608eb3 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -108,6 +108,60 @@ class CrateMappings AST::Crate *get_ast_crate_by_node_id_raw (NodeId id); }; +class ProcMacroMappings +{ + std::map> + procmacrosDeriveMappings; + std::map> procmacrosBangMappings; + std::map> + procmacrosAttributeMappings; + + std::map procmacroDeriveMappings; + std::map procmacroBangMappings; + std::map procmacroAttributeMappings; + std::map procmacroDeriveInvocations; + std::map procmacroBangInvocations; + std::map procmacroAttributeInvocations; + +public: + void insert_derive_proc_macros (CrateNum num, + std::vector macros); + void insert_bang_proc_macros (CrateNum num, + std::vector macros); + void insert_attribute_proc_macros (CrateNum num, + std::vector macros); + + tl::optional &> + lookup_derive_proc_macros (CrateNum num); + tl::optional &> + lookup_bang_proc_macros (CrateNum num); + tl::optional &> + lookup_attribute_proc_macros (CrateNum num); + + void insert_derive_proc_macro_def (CustomDeriveProcMacro macro); + void insert_bang_proc_macro_def (BangProcMacro macro); + void insert_attribute_proc_macro_def (AttributeProcMacro macro); + + tl::optional + lookup_derive_proc_macro_def (NodeId id); + tl::optional lookup_bang_proc_macro_def (NodeId id); + tl::optional + lookup_attribute_proc_macro_def (NodeId id); + + tl::optional + lookup_derive_proc_macro_invocation (AST::SimplePath &invoc); + tl::optional + lookup_bang_proc_macro_invocation (AST::MacroInvocation &invoc_id); + tl::optional + lookup_attribute_proc_macro_invocation (AST::SimplePath &invoc); + void insert_derive_proc_macro_invocation (AST::SimplePath &invoc, + CustomDeriveProcMacro def); + void insert_bang_proc_macro_invocation (AST::MacroInvocation &invoc, + BangProcMacro def); + void insert_attribute_proc_macro_invocation (AST::SimplePath &invoc, + AttributeProcMacro def); +}; + class Mappings { public: @@ -115,6 +169,7 @@ class Mappings ~Mappings (); CrateMappings crate_mapping; + ProcMacroMappings pmacro_mappings; NodeId get_next_node_id (); HirId get_next_hir_id () @@ -344,43 +399,6 @@ class Mappings void insert_exported_macro (AST::MacroRulesDefinition &def); std::vector get_exported_macros (); - void insert_derive_proc_macros (CrateNum num, - std::vector macros); - void insert_bang_proc_macros (CrateNum num, - std::vector macros); - void insert_attribute_proc_macros (CrateNum num, - std::vector macros); - - tl::optional &> - lookup_derive_proc_macros (CrateNum num); - tl::optional &> - lookup_bang_proc_macros (CrateNum num); - tl::optional &> - lookup_attribute_proc_macros (CrateNum num); - - void insert_derive_proc_macro_def (CustomDeriveProcMacro macro); - void insert_bang_proc_macro_def (BangProcMacro macro); - void insert_attribute_proc_macro_def (AttributeProcMacro macro); - - tl::optional - lookup_derive_proc_macro_def (NodeId id); - tl::optional lookup_bang_proc_macro_def (NodeId id); - tl::optional - lookup_attribute_proc_macro_def (NodeId id); - - tl::optional - lookup_derive_proc_macro_invocation (AST::SimplePath &invoc); - tl::optional - lookup_bang_proc_macro_invocation (AST::MacroInvocation &invoc_id); - tl::optional - lookup_attribute_proc_macro_invocation (AST::SimplePath &invoc); - void insert_derive_proc_macro_invocation (AST::SimplePath &invoc, - CustomDeriveProcMacro def); - void insert_bang_proc_macro_invocation (AST::MacroInvocation &invoc, - BangProcMacro def); - void insert_attribute_proc_macro_invocation (AST::SimplePath &invoc, - AttributeProcMacro def); - void insert_visibility (NodeId id, Privacy::ModuleVisibility visibility); tl::optional lookup_visibility (NodeId id); @@ -491,20 +509,6 @@ class Mappings std::map macroInvocations; std::vector exportedMacros; - // Procedural macros - std::map> - procmacrosDeriveMappings; - std::map> procmacrosBangMappings; - std::map> - procmacrosAttributeMappings; - - std::map procmacroDeriveMappings; - std::map procmacroBangMappings; - std::map procmacroAttributeMappings; - std::map procmacroDeriveInvocations; - std::map procmacroBangInvocations; - std::map procmacroAttributeInvocations; - // Low level visibility map for each DefId std::map visibility_map; From d24dc2e8af82839fc8814995ac63cd42a85ff260 Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Thu, 10 Sep 2026 20:38:55 +0200 Subject: [PATCH 575/584] Rename functions and members within mappings Those functions are part of a proc macro context and no longer require an explicit long name about their context. gcc/rust/ChangeLog: * expand/rust-macro-expand.h (struct MacroExpander): Apply new name. * resolve/rust-early-name-resolver-2.0.cc (Early::visit_derive_attribute): Likewise. (Early::visit_non_builtin_attribute): Likewise. * resolve/rust-toplevel-name-resolver-2.0.cc (TopLevel::visit_extern_crate): Likewise. * util/rust-hir-map.cc (ProcMacroMappings::insert_bang_proc_macros): Use new member name. (ProcMacroMappings::lookup_derive_proc_macros): Likewise. (ProcMacroMappings::lookup_bang_proc_macros): Likewise. (ProcMacroMappings::lookup_attribute_proc_macros): Likewise. (ProcMacroMappings::insert_derive_proc_macro_def): Likewise. (ProcMacroMappings::insert_derive_def): Likewise. (ProcMacroMappings::insert_bang_proc_macro_def): Likewise. (ProcMacroMappings::insert_bang_def): Likewise. (ProcMacroMappings::insert_attribute_proc_macro_def): Likewise. (ProcMacroMappings::insert_attribute_def): Likewise. (ProcMacroMappings::lookup_derive_proc_macro_def): Likewise. (ProcMacroMappings::lookup_derive_def): Likewise. (ProcMacroMappings::lookup_bang_proc_macro_def): Likewise. (ProcMacroMappings::lookup_bang_def): Likewise. (ProcMacroMappings::lookup_attribute_proc_macro_def): Likewise. (ProcMacroMappings::lookup_attribute_def): Likewise. (ProcMacroMappings::insert_derive_invocation): Likewise. (ProcMacroMappings::lookup_derive_proc_macro_invocation): Likewise. (ProcMacroMappings::lookup_derive_invocation): Likewise. (ProcMacroMappings::insert_bang_invocation): Likewise. (ProcMacroMappings::lookup_bang_invocation): Likewise. (ProcMacroMappings::insert_attribute_invocation): Likewise. (ProcMacroMappings::lookup_attribute_invocation): Likewise. * util/rust-hir-map.h (class ProcMacroMappings): Rename member maps as well as some functions to remove the proc macro mention. Signed-off-by: Pierre-Emmanuel Patry --- gcc/rust/expand/rust-macro-expand.h | 6 +- .../resolve/rust-early-name-resolver-2.0.cc | 12 ++-- .../rust-toplevel-name-resolver-2.0.cc | 6 +- gcc/rust/util/rust-hir-map.cc | 62 +++++++++---------- gcc/rust/util/rust-hir-map.h | 39 +++++------- 5 files changed, 59 insertions(+), 66 deletions(-) diff --git a/gcc/rust/expand/rust-macro-expand.h b/gcc/rust/expand/rust-macro-expand.h index ddd433c39369..02de84220d12 100644 --- a/gcc/rust/expand/rust-macro-expand.h +++ b/gcc/rust/expand/rust-macro-expand.h @@ -412,7 +412,7 @@ struct MacroExpander AST::Fragment expand_derive_proc_macro (T &item, AST::SimplePath &path) { tl::optional macro - = mappings.pmacro_mappings.lookup_derive_proc_macro_invocation (path); + = mappings.pmacro_mappings.lookup_derive_invocation (path); if (!macro.has_value ()) { rust_error_at (path.get_locus (), "macro not found"); @@ -435,7 +435,7 @@ struct MacroExpander AST::MacroInvocation &invocation) { tl::optional macro - = mappings.pmacro_mappings.lookup_bang_proc_macro_invocation (invocation); + = mappings.pmacro_mappings.lookup_bang_invocation (invocation); if (!macro.has_value ()) { rust_error_at (invocation.get_locus (), "macro not found"); @@ -457,7 +457,7 @@ struct MacroExpander AST::Fragment expand_attribute_proc_macro (T &item, AST::SimplePath &path) { tl::optional macro - = mappings.pmacro_mappings.lookup_attribute_proc_macro_invocation (path); + = mappings.pmacro_mappings.lookup_attribute_invocation (path); if (!macro.has_value ()) { rust_error_at (path.get_locus (), "macro not found"); diff --git a/gcc/rust/resolve/rust-early-name-resolver-2.0.cc b/gcc/rust/resolve/rust-early-name-resolver-2.0.cc index d4d0cb8e1ec8..d45536717a73 100644 --- a/gcc/rust/resolve/rust-early-name-resolver-2.0.cc +++ b/gcc/rust/resolve/rust-early-name-resolver-2.0.cc @@ -402,12 +402,12 @@ Early::visit_derive_attribute (AST::Attribute &attr, continue; } - auto pm_def = mappings.pmacro_mappings.lookup_derive_proc_macro_def ( + auto pm_def = mappings.pmacro_mappings.lookup_derive_def ( ns_def->definition.get_node_id ()); if (pm_def.has_value ()) - mappings.pmacro_mappings.insert_derive_proc_macro_invocation ( - trait, pm_def.value ()); + mappings.pmacro_mappings.insert_derive_invocation (trait, + pm_def.value ()); } } @@ -425,14 +425,14 @@ Early::visit_non_builtin_attribute (AST::Attribute &attr, name.c_str ())); return; } - auto pm_def = mappings.pmacro_mappings.lookup_attribute_proc_macro_def ( + auto pm_def = mappings.pmacro_mappings.lookup_attribute_def ( ns_def->definition.get_node_id ()); if (!pm_def.has_value ()) return; - mappings.pmacro_mappings.insert_attribute_proc_macro_invocation ( - attr.get_path (), pm_def.value ()); + mappings.pmacro_mappings.insert_attribute_invocation (attr.get_path (), + pm_def.value ()); } void diff --git a/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc b/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc index 88b946649f4b..4b2fae0ddb89 100644 --- a/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc +++ b/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc @@ -199,19 +199,19 @@ TopLevel::visit_extern_crate (AST::ExternCrate &extern_crate, AST::Crate &crate, { insert_macros (derive_macros.value (), ctx); for (auto ¯o : derive_macros.value ()) - mappings.pmacro_mappings.insert_derive_proc_macro_def (macro); + mappings.pmacro_mappings.insert_derive_def (macro); } if (attribute_macros.has_value ()) { insert_macros (attribute_macros.value (), ctx); for (auto ¯o : attribute_macros.value ()) - mappings.pmacro_mappings.insert_attribute_proc_macro_def (macro); + mappings.pmacro_mappings.insert_attribute_def (macro); } if (bang_macros.has_value ()) { insert_macros (bang_macros.value (), ctx); for (auto ¯o : bang_macros.value ()) - mappings.pmacro_mappings.insert_bang_proc_macro_def (macro); + mappings.pmacro_mappings.insert_bang_def (macro); } // We do *NOT* visit the crate because loaded crates are resolved diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index af3d6f222319..a5eefa9e8673 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -1137,37 +1137,37 @@ void ProcMacroMappings::insert_derive_proc_macros ( CrateNum num, std::vector macros) { - auto it = procmacrosDeriveMappings.find (num); - rust_assert (it == procmacrosDeriveMappings.end ()); + auto it = deriveMappings.find (num); + rust_assert (it == deriveMappings.end ()); - procmacrosDeriveMappings[num] = macros; + deriveMappings[num] = macros; } void ProcMacroMappings::insert_bang_proc_macros (CrateNum num, std::vector macros) { - auto it = procmacrosBangMappings.find (num); - rust_assert (it == procmacrosBangMappings.end ()); + auto it = bangMappings.find (num); + rust_assert (it == bangMappings.end ()); - procmacrosBangMappings[num] = macros; + bangMappings[num] = macros; } void ProcMacroMappings::insert_attribute_proc_macros ( CrateNum num, std::vector macros) { - auto it = procmacrosAttributeMappings.find (num); - rust_assert (it == procmacrosAttributeMappings.end ()); + auto it = attributeMappings.find (num); + rust_assert (it == attributeMappings.end ()); - procmacrosAttributeMappings[num] = macros; + attributeMappings[num] = macros; } tl::optional &> ProcMacroMappings::lookup_derive_proc_macros (CrateNum num) { - auto it = procmacrosDeriveMappings.find (num); - if (it == procmacrosDeriveMappings.end ()) + auto it = deriveMappings.find (num); + if (it == deriveMappings.end ()) return tl::nullopt; return it->second; @@ -1176,8 +1176,8 @@ ProcMacroMappings::lookup_derive_proc_macros (CrateNum num) tl::optional &> ProcMacroMappings::lookup_bang_proc_macros (CrateNum num) { - auto it = procmacrosBangMappings.find (num); - if (it == procmacrosBangMappings.end ()) + auto it = bangMappings.find (num); + if (it == bangMappings.end ()) return tl::nullopt; return it->second; @@ -1186,15 +1186,15 @@ ProcMacroMappings::lookup_bang_proc_macros (CrateNum num) tl::optional &> ProcMacroMappings::lookup_attribute_proc_macros (CrateNum num) { - auto it = procmacrosAttributeMappings.find (num); - if (it == procmacrosAttributeMappings.end ()) + auto it = attributeMappings.find (num); + if (it == attributeMappings.end ()) return tl::nullopt; return it->second; } void -ProcMacroMappings::insert_derive_proc_macro_def (CustomDeriveProcMacro macro) +ProcMacroMappings::insert_derive_def (CustomDeriveProcMacro macro) { auto it = procmacroDeriveMappings.find (macro.get_node_id ()); rust_assert (it == procmacroDeriveMappings.end ()); @@ -1203,7 +1203,7 @@ ProcMacroMappings::insert_derive_proc_macro_def (CustomDeriveProcMacro macro) } void -ProcMacroMappings::insert_bang_proc_macro_def (BangProcMacro macro) +ProcMacroMappings::insert_bang_def (BangProcMacro macro) { auto it = procmacroBangMappings.find (macro.get_node_id ()); rust_assert (it == procmacroBangMappings.end ()); @@ -1212,7 +1212,7 @@ ProcMacroMappings::insert_bang_proc_macro_def (BangProcMacro macro) } void -ProcMacroMappings::insert_attribute_proc_macro_def (AttributeProcMacro macro) +ProcMacroMappings::insert_attribute_def (AttributeProcMacro macro) { auto it = procmacroAttributeMappings.find (macro.get_node_id ()); rust_assert (it == procmacroAttributeMappings.end ()); @@ -1221,7 +1221,7 @@ ProcMacroMappings::insert_attribute_proc_macro_def (AttributeProcMacro macro) } tl::optional -ProcMacroMappings::lookup_derive_proc_macro_def (NodeId id) +ProcMacroMappings::lookup_derive_def (NodeId id) { auto it = procmacroDeriveMappings.find (id); if (it == procmacroDeriveMappings.end ()) @@ -1231,7 +1231,7 @@ ProcMacroMappings::lookup_derive_proc_macro_def (NodeId id) } tl::optional -ProcMacroMappings::lookup_bang_proc_macro_def (NodeId id) +ProcMacroMappings::lookup_bang_def (NodeId id) { auto it = procmacroBangMappings.find (id); if (it == procmacroBangMappings.end ()) @@ -1241,7 +1241,7 @@ ProcMacroMappings::lookup_bang_proc_macro_def (NodeId id) } tl::optional -ProcMacroMappings::lookup_attribute_proc_macro_def (NodeId id) +ProcMacroMappings::lookup_attribute_def (NodeId id) { auto it = procmacroAttributeMappings.find (id); if (it == procmacroAttributeMappings.end ()) @@ -1251,8 +1251,8 @@ ProcMacroMappings::lookup_attribute_proc_macro_def (NodeId id) } void -ProcMacroMappings::insert_derive_proc_macro_invocation ( - AST::SimplePath &invoc, CustomDeriveProcMacro def) +ProcMacroMappings::insert_derive_invocation (AST::SimplePath &invoc, + CustomDeriveProcMacro def) { auto it = procmacroDeriveInvocations.find (invoc.get_node_id ()); rust_assert (it == procmacroDeriveInvocations.end ()); @@ -1261,7 +1261,7 @@ ProcMacroMappings::insert_derive_proc_macro_invocation ( } tl::optional -ProcMacroMappings::lookup_derive_proc_macro_invocation (AST::SimplePath &invoc) +ProcMacroMappings::lookup_derive_invocation (AST::SimplePath &invoc) { auto it = procmacroDeriveInvocations.find (invoc.get_node_id ()); if (it == procmacroDeriveInvocations.end ()) @@ -1271,8 +1271,8 @@ ProcMacroMappings::lookup_derive_proc_macro_invocation (AST::SimplePath &invoc) } void -ProcMacroMappings::insert_bang_proc_macro_invocation ( - AST::MacroInvocation &invoc, BangProcMacro def) +ProcMacroMappings::insert_bang_invocation (AST::MacroInvocation &invoc, + BangProcMacro def) { auto it = procmacroBangInvocations.find (invoc.get_node_id ()); rust_assert (it == procmacroBangInvocations.end ()); @@ -1281,8 +1281,7 @@ ProcMacroMappings::insert_bang_proc_macro_invocation ( } tl::optional -ProcMacroMappings::lookup_bang_proc_macro_invocation ( - AST::MacroInvocation &invoc) +ProcMacroMappings::lookup_bang_invocation (AST::MacroInvocation &invoc) { auto it = procmacroBangInvocations.find (invoc.get_node_id ()); if (it == procmacroBangInvocations.end ()) @@ -1292,8 +1291,8 @@ ProcMacroMappings::lookup_bang_proc_macro_invocation ( } void -ProcMacroMappings::insert_attribute_proc_macro_invocation ( - AST::SimplePath &invoc, AttributeProcMacro def) +ProcMacroMappings::insert_attribute_invocation (AST::SimplePath &invoc, + AttributeProcMacro def) { auto it = procmacroAttributeInvocations.find (invoc.get_node_id ()); rust_assert (it == procmacroAttributeInvocations.end ()); @@ -1302,8 +1301,7 @@ ProcMacroMappings::insert_attribute_proc_macro_invocation ( } tl::optional -ProcMacroMappings::lookup_attribute_proc_macro_invocation ( - AST::SimplePath &invoc) +ProcMacroMappings::lookup_attribute_invocation (AST::SimplePath &invoc) { auto it = procmacroAttributeInvocations.find (invoc.get_node_id ()); if (it == procmacroAttributeInvocations.end ()) diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index a7f631608eb3..c0041399fc65 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -110,11 +110,9 @@ class CrateMappings class ProcMacroMappings { - std::map> - procmacrosDeriveMappings; - std::map> procmacrosBangMappings; - std::map> - procmacrosAttributeMappings; + std::map> deriveMappings; + std::map> bangMappings; + std::map> attributeMappings; std::map procmacroDeriveMappings; std::map procmacroBangMappings; @@ -138,28 +136,25 @@ class ProcMacroMappings tl::optional &> lookup_attribute_proc_macros (CrateNum num); - void insert_derive_proc_macro_def (CustomDeriveProcMacro macro); - void insert_bang_proc_macro_def (BangProcMacro macro); - void insert_attribute_proc_macro_def (AttributeProcMacro macro); + void insert_derive_def (CustomDeriveProcMacro macro); + void insert_bang_def (BangProcMacro macro); + void insert_attribute_def (AttributeProcMacro macro); - tl::optional - lookup_derive_proc_macro_def (NodeId id); - tl::optional lookup_bang_proc_macro_def (NodeId id); - tl::optional - lookup_attribute_proc_macro_def (NodeId id); + tl::optional lookup_derive_def (NodeId id); + tl::optional lookup_bang_def (NodeId id); + tl::optional lookup_attribute_def (NodeId id); tl::optional - lookup_derive_proc_macro_invocation (AST::SimplePath &invoc); + lookup_derive_invocation (AST::SimplePath &invoc); tl::optional - lookup_bang_proc_macro_invocation (AST::MacroInvocation &invoc_id); + lookup_bang_invocation (AST::MacroInvocation &invoc_id); tl::optional - lookup_attribute_proc_macro_invocation (AST::SimplePath &invoc); - void insert_derive_proc_macro_invocation (AST::SimplePath &invoc, - CustomDeriveProcMacro def); - void insert_bang_proc_macro_invocation (AST::MacroInvocation &invoc, - BangProcMacro def); - void insert_attribute_proc_macro_invocation (AST::SimplePath &invoc, - AttributeProcMacro def); + lookup_attribute_invocation (AST::SimplePath &invoc); + void insert_derive_invocation (AST::SimplePath &invoc, + CustomDeriveProcMacro def); + void insert_bang_invocation (AST::MacroInvocation &invoc, BangProcMacro def); + void insert_attribute_invocation (AST::SimplePath &invoc, + AttributeProcMacro def); }; class Mappings From 691151fce121a60640c80a959e4c92e9ff8beeec Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Thu, 10 Sep 2026 21:39:53 +0200 Subject: [PATCH 576/584] Add ASTMapping to regroup all AST items mappings Rust hir map is too big, regroup some of ast item mappings within a specialized class. gcc/rust/ChangeLog: * checks/errors/privacy/rust-privacy-reporter.cc (PrivacyReporter::check_violation_inner): Use ast category. * checks/errors/privacy/rust-pub-restricted-visitor.cc (PubRestrictedVisitor::is_restriction_valid): Likewise. * checks/errors/privacy/rust-visibility-resolver.cc (VisibilityResolver::go): Likewise. (VisibilityResolver::resolve_and_update): Likewise. (VisibilityResolver::visit): Likewise. * util/rust-hir-map.cc (Mappings::insert_visibility): Move to ASTMappings. (Mappings::lookup_visibility): Likewise. * util/rust-hir-map.h (class ASTMappings): Add a mapping class dedicated to mapping an id to an Item. Add a specialized ASTMappings class to hold all ast related mappings. Signed-off-by: Pierre-Emmanuel Patry --- .../errors/privacy/rust-privacy-reporter.cc | 2 +- .../privacy/rust-pub-restricted-visitor.cc | 2 +- .../privacy/rust-visibility-resolver.cc | 18 ++++++++----- gcc/rust/util/rust-hir-map.cc | 16 ------------ gcc/rust/util/rust-hir-map.h | 26 ++++++++++++++++--- 5 files changed, 36 insertions(+), 28 deletions(-) diff --git a/gcc/rust/checks/errors/privacy/rust-privacy-reporter.cc b/gcc/rust/checks/errors/privacy/rust-privacy-reporter.cc index 5531328ba4b4..d747e1ed04ed 100644 --- a/gcc/rust/checks/errors/privacy/rust-privacy-reporter.cc +++ b/gcc/rust/checks/errors/privacy/rust-privacy-reporter.cc @@ -97,7 +97,7 @@ void PrivacyReporter::check_violation_inner (NodeId ref_node_id, const location_t locus) { - auto vis = mappings.lookup_visibility (ref_node_id); + auto vis = mappings.ast.module_visibility.lookup (ref_node_id); // FIXME: Can we really return here if the item has no visibility? if (!vis) diff --git a/gcc/rust/checks/errors/privacy/rust-pub-restricted-visitor.cc b/gcc/rust/checks/errors/privacy/rust-pub-restricted-visitor.cc index 54c96ef844d2..15c758651ae9 100644 --- a/gcc/rust/checks/errors/privacy/rust-pub-restricted-visitor.cc +++ b/gcc/rust/checks/errors/privacy/rust-pub-restricted-visitor.cc @@ -27,7 +27,7 @@ bool PubRestrictedVisitor::is_restriction_valid (NodeId item_id, const location_t locus) { - auto visibility = mappings.lookup_visibility (item_id); + auto visibility = mappings.ast.module_visibility.lookup (item_id); // If there is no visibility in the mappings, then the item is private and // does not contain any restriction diff --git a/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc b/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc index d7c1955f8add..26f13f8d22e1 100644 --- a/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc +++ b/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc @@ -35,8 +35,8 @@ VisibilityResolver::VisibilityResolver ( void VisibilityResolver::go (HIR::Crate &crate) { - mappings.insert_visibility (crate.get_mappings ().get_nodeid (), - ModuleVisibility::create_public ()); + mappings.ast.module_visibility.insert (crate.get_mappings ().get_nodeid (), + ModuleVisibility::create_public ()); current_module = crate.get_mappings ().get_defid (); @@ -137,7 +137,8 @@ VisibilityResolver::resolve_and_update (const HIR::VisItem *item) if (!resolve_visibility (item->get_visibility (), module_vis)) return; // we will already have emitted errors - mappings.insert_visibility (item->get_mappings ().get_nodeid (), module_vis); + mappings.ast.module_visibility.insert (item->get_mappings ().get_nodeid (), + module_vis); } void @@ -197,9 +198,11 @@ VisibilityResolver::visit (HIR::Enum &enum_item) if (!resolve_visibility (enum_item.get_visibility (), vis)) return; - mappings.insert_visibility (enum_item.get_mappings ().get_nodeid (), vis); + auto &mod_vis_mapping = mappings.ast.module_visibility; + + mod_vis_mapping.insert (enum_item.get_mappings ().get_nodeid (), vis); for (auto &variant : enum_item.get_variants ()) - mappings.insert_visibility (variant->get_mappings ().get_nodeid (), vis); + mod_vis_mapping.insert (variant->get_mappings ().get_nodeid (), vis); } void @@ -225,9 +228,10 @@ VisibilityResolver::visit (HIR::Trait &trait) if (!resolve_visibility (trait.get_visibility (), vis)) return; - mappings.insert_visibility (trait.get_mappings ().get_nodeid (), vis); + auto &mod_vis_mapping = mappings.ast.module_visibility; + mod_vis_mapping.insert (trait.get_mappings ().get_nodeid (), vis); for (auto &item : trait.get_trait_items ()) - mappings.insert_visibility (item->get_mappings ().get_nodeid (), vis); + mod_vis_mapping.insert (item->get_mappings ().get_nodeid (), vis); } void diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index a5eefa9e8673..617963e73b43 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -1310,22 +1310,6 @@ ProcMacroMappings::lookup_attribute_invocation (AST::SimplePath &invoc) return it->second; } -void -Mappings::insert_visibility (NodeId id, Privacy::ModuleVisibility visibility) -{ - visibility_map.insert ({id, visibility}); -} - -tl::optional -Mappings::lookup_visibility (NodeId id) -{ - auto it = visibility_map.find (id); - if (it == visibility_map.end ()) - return tl::nullopt; - - return it->second; -} - void Mappings::insert_module_child (NodeId module, NodeId child) { diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index c0041399fc65..20d2ceb96f5e 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -157,6 +157,27 @@ class ProcMacroMappings AttributeProcMacro def); }; +template class Mapping +{ + std::unordered_map storage; + +public: + tl::optional lookup (Id id) + { + auto it = storage.find (id); + if (it == storage.cend ()) + return tl::nullopt; + return it->second; + } + void insert (Id id, Item item) { storage.insert ({id, item}); } +}; + +class ASTMappings +{ +public: + Mapping module_visibility; +}; + class Mappings { public: @@ -165,6 +186,7 @@ class Mappings CrateMappings crate_mapping; ProcMacroMappings pmacro_mappings; + ASTMappings ast; NodeId get_next_node_id (); HirId get_next_hir_id () @@ -179,6 +201,7 @@ class Mappings LocalDefId get_next_localdef_id (CrateNum crateNum); AST::Crate &get_ast_crate_by_node_id (NodeId id); + HIR::Crate &insert_hir_crate (std::unique_ptr &&crate); HIR::Crate &get_hir_crate (CrateNum crateNum); bool is_local_hirid_crate (HirId crateNum); @@ -394,9 +417,6 @@ class Mappings void insert_exported_macro (AST::MacroRulesDefinition &def); std::vector get_exported_macros (); - void insert_visibility (NodeId id, Privacy::ModuleVisibility visibility); - tl::optional lookup_visibility (NodeId id); - void insert_glob_container (NodeId, AST::GlobContainer *); tl::optional lookup_glob_container (NodeId id); From b0e874c5f6e1ff3e5a769d710e37b3af5a979b39 Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Fri, 11 Sep 2026 12:51:38 +0200 Subject: [PATCH 577/584] Regroup hir mappings under one class HIR map is getting bigger and most lookup/insert functions are similar, this commit regroup all simple HIR related mappings under one field. gcc/rust/ChangeLog: * backend/rust-compile-item.cc (CompileItem::visit): Use new hir category. * backend/rust-compile-resolve-path.cc (HIRCompileBase::query_compile): Likewise. * backend/rust-mangle-v0.cc (v0_path): Likewise. * checks/errors/privacy/rust-visibility-resolver.cc (VisibilityResolver::resolve_module_path): Likewise. * checks/errors/rust-const-checker.cc (ConstChecker::check_function_call): Likewise. * checks/errors/rust-readonly-check.cc (ReadonlyChecker::visit): Likewise. * checks/errors/rust-unsafe-checker.cc (UnsafeChecker::check_use_of_static): Likewise. (UnsafeChecker::check_function_call): Likewise. (UnsafeChecker::check_function_attr): Likewise. * checks/lints/rust-lint-marklive.cc (MarkLive::go): Likewise. (MarkLive::visit): Likewise. * checks/lints/unused/rust-unused-checker.cc (UnusedChecker::visit): Likewise. * hir/rust-ast-lower-base.cc (ASTLoweringBase::lower_extern_block): Likewise. * hir/rust-ast-lower-block.h: Likewise. * hir/rust-ast-lower-expr.cc (ASTLoweringExpr::translate): Likewise. * hir/rust-ast-lower-implitem.cc (ASTLowerImplItem::visit): Likewise. (ASTLowerTraitItem::translate): Likewise. (ASTLowerTraitItem::visit): Likewise. * hir/rust-ast-lower-item.cc (ASTLoweringItem::translate): Likewise. (ASTLoweringItem::visit): Likewise. * hir/rust-ast-lower-pattern.cc (ASTLoweringPattern::translate): Likewise. * hir/rust-ast-lower-stmt.cc (ASTLoweringStmt::translate): Likewise. * hir/rust-ast-lower-struct-field-expr.h: Likewise. * hir/rust-ast-lower-type.cc (ASTLoweringType::translate): Likewise. (ASTLowerGenericParam::translate): Likewise. * hir/rust-ast-lower.cc (ASTLowerPathInExpression::visit): Likewise. (ASTLowerQualPathInExpression::visit): Likewise. * hir/tree/rust-hir-pattern-abstract.cc (PathPattern::is_refutable): Likewise. * typecheck/rust-hir-trait-resolve.cc (TraitResolver::resolve_path_to_trait): Likewise. * typecheck/rust-hir-type-check-path.cc (TypeCheckExpr::visit): Likewise. (TypeCheckExpr::resolve_root_path): Likewise. * typecheck/rust-hir-type-check-pattern.cc (TypeCheckPattern::visit): Likewise. * typecheck/rust-hir-type-check-type.cc (TypeCheckType::resolve_root_path): Likewise. * typecheck/rust-type-util.cc (query_type): Likewise. * util/rust-hir-map.cc (Mappings::insert_hir_item): Move to dedicated mappings within the hir category. (Mappings::lookup_hir_item): Likewise. (Mappings::insert_hir_trait_item): Likewise. (Mappings::lookup_hir_trait_item): Likewise. (Mappings::insert_hir_extern_block): Likewise. (Mappings::lookup_hir_extern_block): Likewise. (Mappings::insert_module): Likewise. (Mappings::lookup_module): Likewise. (Mappings::insert_hir_expr): Likewise. (Mappings::lookup_hir_expr): Likewise. (Mappings::insert_hir_path_expr_seg): Likewise. (Mappings::lookup_hir_path_expr_seg): Likewise. (Mappings::insert_hir_generic_param): Likewise. (Mappings::lookup_hir_generic_param): Likewise. (Mappings::insert_hir_type): Likewise. (Mappings::lookup_hir_type): Likewise. (Mappings::insert_hir_stmt): Likewise. (Mappings::lookup_hir_stmt): Likewise. (Mappings::insert_hir_param): Likewise. (Mappings::lookup_hir_param): Likewise. (Mappings::insert_hir_self_param): Likewise. (Mappings::lookup_hir_self_param): Likewise. (Mappings::insert_hir_struct_field): Likewise. (Mappings::lookup_hir_struct_field): Likewise. (Mappings::insert_hir_pattern): Likewise. (Mappings::lookup_hir_pattern): Likewise. (Mappings::resolve_nodeid_to_stmt): Likewise. (Mappings::build_impl_indexes): Likewise. (Mappings::insert_trait_item_mapping): Likewise. * util/rust-hir-map.h (class HIRMappings): Add new class for all hir related mappings. * util/rust-hir-map.hxx: New file. Signed-off-by: Pierre-Emmanuel Patry --- gcc/rust/backend/rust-compile-item.cc | 2 +- gcc/rust/backend/rust-compile-resolve-path.cc | 4 +- gcc/rust/backend/rust-mangle-v0.cc | 6 +- .../privacy/rust-visibility-resolver.cc | 2 +- gcc/rust/checks/errors/rust-const-checker.cc | 2 +- gcc/rust/checks/errors/rust-readonly-check.cc | 4 +- gcc/rust/checks/errors/rust-unsafe-checker.cc | 8 +- gcc/rust/checks/lints/rust-lint-marklive.cc | 4 +- .../lints/unused/rust-unused-checker.cc | 2 +- gcc/rust/hir/rust-ast-lower-base.cc | 2 +- gcc/rust/hir/rust-ast-lower-block.h | 10 +- gcc/rust/hir/rust-ast-lower-expr.cc | 2 +- gcc/rust/hir/rust-ast-lower-implitem.cc | 10 +- gcc/rust/hir/rust-ast-lower-item.cc | 6 +- gcc/rust/hir/rust-ast-lower-pattern.cc | 2 +- gcc/rust/hir/rust-ast-lower-stmt.cc | 2 +- .../hir/rust-ast-lower-struct-field-expr.h | 2 +- gcc/rust/hir/rust-ast-lower-type.cc | 4 +- gcc/rust/hir/rust-ast-lower.cc | 4 +- .../hir/tree/rust-hir-pattern-abstract.cc | 2 +- gcc/rust/typecheck/rust-hir-trait-resolve.cc | 2 +- .../typecheck/rust-hir-type-check-path.cc | 6 +- .../typecheck/rust-hir-type-check-pattern.cc | 2 +- .../typecheck/rust-hir-type-check-type.cc | 2 +- gcc/rust/typecheck/rust-type-util.cc | 4 +- gcc/rust/util/rust-hir-map.cc | 267 +----------------- gcc/rust/util/rust-hir-map.h | 90 +++--- gcc/rust/util/rust-hir-map.hxx | 77 +++++ 28 files changed, 179 insertions(+), 351 deletions(-) create mode 100644 gcc/rust/util/rust-hir-map.hxx diff --git a/gcc/rust/backend/rust-compile-item.cc b/gcc/rust/backend/rust-compile-item.cc index 423df15c2cac..6937492cc238 100644 --- a/gcc/rust/backend/rust-compile-item.cc +++ b/gcc/rust/backend/rust-compile-item.cc @@ -228,7 +228,7 @@ CompileItem::visit (HIR::Function &function) if (function.get_qualifiers ().is_const ()) ctx->push_const_context (); - auto lookup_root_item = ctx->get_mappings ().lookup_hir_item ( + auto lookup_root_item = ctx->get_mappings ().hir.item.lookup ( function.get_mappings ().get_hirid ()); bool is_root_item = lookup_root_item.has_value (); tree fndecl diff --git a/gcc/rust/backend/rust-compile-resolve-path.cc b/gcc/rust/backend/rust-compile-resolve-path.cc index 12b200a11d9b..9aa78fd4b1a0 100644 --- a/gcc/rust/backend/rust-compile-resolve-path.cc +++ b/gcc/rust/backend/rust-compile-resolve-path.cc @@ -259,7 +259,7 @@ HIRCompileBase::query_compile (HirId ref, TyTy::BaseType *lookup, location_t expr_locus, bool is_qualified_path) { bool is_fn = lookup->get_kind () == TyTy::TypeKind::FNDEF; - if (auto resolved_item = ctx->get_mappings ().lookup_hir_item (ref)) + if (auto resolved_item = ctx->get_mappings ().hir.item.lookup (ref)) { if (!lookup->has_substitutions_defined ()) return CompileItem::compile (*resolved_item, ctx, nullptr, expr_locus); @@ -303,7 +303,7 @@ HIRCompileBase::query_compile (HirId ref, TyTy::BaseType *lookup, lookup, expr_locus); } else if (auto trait_item - = ctx->get_mappings ().lookup_hir_trait_item (ref)) + = ctx->get_mappings ().hir.trait_item.lookup (ref)) { HIR::Trait *trait = ctx->get_mappings ().lookup_trait_item_mapping ( trait_item.value ()->get_mappings ().get_hirid ()); diff --git a/gcc/rust/backend/rust-mangle-v0.cc b/gcc/rust/backend/rust-mangle-v0.cc index d0ed9da1ef61..b2a24f385fd3 100644 --- a/gcc/rust/backend/rust-mangle-v0.cc +++ b/gcc/rust/backend/rust-mangle-v0.cc @@ -406,7 +406,7 @@ v0_path (Rust::Compile::Context *ctx, const TyTy::BaseType *ty, break; } } - else if (auto trait_item = mappings.lookup_hir_trait_item (hir_id)) + else if (auto trait_item = mappings.hir.trait_item.lookup (hir_id)) { switch (trait_item.value ()->get_item_kind ()) { @@ -428,7 +428,7 @@ v0_path (Rust::Compile::Context *ctx, const TyTy::BaseType *ty, break; } } - else if (auto item = mappings.lookup_hir_item (hir_id)) + else if (auto item = mappings.hir.item.lookup (hir_id)) switch (item.value ()->get_item_kind ()) { case HIR::Item::ItemKind::Function: @@ -468,7 +468,7 @@ v0_path (Rust::Compile::Context *ctx, const TyTy::BaseType *ty, cpath.get ().c_str ()); break; } - else if (auto expr = mappings.lookup_hir_expr (hir_id)) + else if (auto expr = mappings.hir.expr.lookup (hir_id)) { rust_assert (expr.value ()->get_expression_type () == HIR::Expr::ExprType::Closure); diff --git a/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc b/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc index 26f13f8d22e1..76a94906278f 100644 --- a/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc +++ b/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc @@ -93,7 +93,7 @@ VisibilityResolver::resolve_module_path (const HIR::SimplePath &restriction, // these items as private? return true; - if (auto module = mappings.lookup_module (ref)) + if (auto module = mappings.hir.module.lookup (ref)) { // Fill in the resolved `DefId` id = module.value ()->get_mappings ().get_defid (); diff --git a/gcc/rust/checks/errors/rust-const-checker.cc b/gcc/rust/checks/errors/rust-const-checker.cc index 1a594bf9f0bd..913505f066fb 100644 --- a/gcc/rust/checks/errors/rust-const-checker.cc +++ b/gcc/rust/checks/errors/rust-const-checker.cc @@ -309,7 +309,7 @@ ConstChecker::check_function_call (HirId fn_id, location_t locus) if (!const_context.is_in_context ()) return; - auto maybe_fn = mappings.lookup_hir_item (fn_id); + auto maybe_fn = mappings.hir.item.lookup (fn_id); if (maybe_fn && maybe_fn.value ()->get_item_kind () != Item::ItemKind::Function) return; diff --git a/gcc/rust/checks/errors/rust-readonly-check.cc b/gcc/rust/checks/errors/rust-readonly-check.cc index b7e75a7d5012..8bd3c4e4e7f3 100644 --- a/gcc/rust/checks/errors/rust-readonly-check.cc +++ b/gcc/rust/checks/errors/rust-readonly-check.cc @@ -75,7 +75,7 @@ ReadonlyChecker::visit (PathInExpression &expr) return; // Check if the local variable is mutable. - auto maybe_pattern = mappings.lookup_hir_pattern (*hir_id); + auto maybe_pattern = mappings.hir.pattern.lookup (*hir_id); if (maybe_pattern && maybe_pattern.value ()->get_pattern_type () == HIR::Pattern::PatternType::IDENTIFIER) @@ -83,7 +83,7 @@ ReadonlyChecker::visit (PathInExpression &expr) expr.get_locus ()); // Check if the static item is mutable. - auto maybe_item = mappings.lookup_hir_item (*hir_id); + auto maybe_item = mappings.hir.item.lookup (*hir_id); if (maybe_item && maybe_item.value ()->get_item_kind () == HIR::Item::ItemKind::Static) { diff --git a/gcc/rust/checks/errors/rust-unsafe-checker.cc b/gcc/rust/checks/errors/rust-unsafe-checker.cc index b82ba1514f32..22ff986f18f5 100644 --- a/gcc/rust/checks/errors/rust-unsafe-checker.cc +++ b/gcc/rust/checks/errors/rust-unsafe-checker.cc @@ -92,7 +92,7 @@ UnsafeChecker::check_use_of_static (HirId node_id, location_t locus) bool in_context = unsafe_context.is_in_context (); bool unsafe_op = false; - if (auto maybe_static_mut = mappings.lookup_hir_item (node_id)) + if (auto maybe_static_mut = mappings.hir.item.lookup (node_id)) unsafe_op |= check_static_mut (*maybe_static_mut, locus, in_context); if (auto maybe_extern_static = mappings.lookup_hir_extern_item (node_id)) @@ -198,7 +198,7 @@ UnsafeChecker::check_function_call (HirId node_id, location_t locus) bool in_context = unsafe_context.is_in_context (); bool unsafe_op = false; - auto maybe_fn = mappings.lookup_hir_item (node_id); + auto maybe_fn = mappings.hir.item.lookup (node_id); if (maybe_fn && maybe_fn.value ()->get_item_kind () == Item::ItemKind::Function) @@ -208,7 +208,7 @@ UnsafeChecker::check_function_call (HirId node_id, location_t locus) if (auto maybe_extern = mappings.lookup_hir_extern_item (node_id)) unsafe_op |= check_extern_call (static_cast (maybe_extern->first), - *mappings.lookup_hir_extern_block ( + *mappings.hir.extern_block.lookup ( maybe_extern->second), locus, in_context); @@ -240,7 +240,7 @@ UnsafeChecker::check_function_attr (HirId node_id, location_t locus) { bool in_context = unsafe_context.is_in_context (); - auto maybe_fn = mappings.lookup_hir_item (node_id); + auto maybe_fn = mappings.hir.item.lookup (node_id); if (maybe_fn && maybe_fn.value ()->get_item_kind () == Item::ItemKind::Function diff --git a/gcc/rust/checks/lints/rust-lint-marklive.cc b/gcc/rust/checks/lints/rust-lint-marklive.cc index c99c365dd92c..0685c442beeb 100644 --- a/gcc/rust/checks/lints/rust-lint-marklive.cc +++ b/gcc/rust/checks/lints/rust-lint-marklive.cc @@ -91,7 +91,7 @@ MarkLive::go (HIR::Crate &) worklist.pop_back (); scannedSymbols.emplace (hirId); liveSymbols.emplace (hirId); - if (auto item = mappings.lookup_hir_item (hirId)) + if (auto item = mappings.hir.item.lookup (hirId)) item.value ()->accept_vis (*this); else if (auto implItem = mappings.lookup_hir_implitem (hirId)) implItem->first->accept_vis (*this); @@ -125,7 +125,7 @@ MarkLive::visit (HIR::PathInExpression &expr) auto ref = hid.value (); // it must resolve to some kind of HIR::Item or HIR::InheritImplItem - if (auto resolved_item = mappings.lookup_hir_item (ref)) + if (auto resolved_item = mappings.hir.item.lookup (ref)) mark_hir_id (resolved_item.value ()->get_mappings ().get_hirid ()); else if (auto resolved_item = mappings.lookup_hir_implitem (ref)) mark_hir_id (resolved_item->first->get_impl_mappings ().get_hirid ()); diff --git a/gcc/rust/checks/lints/unused/rust-unused-checker.cc b/gcc/rust/checks/lints/unused/rust-unused-checker.cc index 023cba0c938a..414af54103d9 100644 --- a/gcc/rust/checks/lints/unused/rust-unused-checker.cc +++ b/gcc/rust/checks/lints/unused/rust-unused-checker.cc @@ -358,7 +358,7 @@ UnusedChecker::visit (HIR::BorrowExpr &expr) if (auto def = nr_context.lookup (ast_node_id, Resolver2_0::Namespace::Values)) if (auto id = mappings.lookup_node_to_hir (*def)) - if (auto item = mappings.lookup_hir_item (*id)) + if (auto item = mappings.hir.item.lookup (*id)) if (item.value ()->get_item_kind () == HIR::Item::ItemKind::Static) { auto &static_item = static_cast (*item.value ()); diff --git a/gcc/rust/hir/rust-ast-lower-base.cc b/gcc/rust/hir/rust-ast-lower-base.cc index 1d55632e6900..ddf866952f80 100644 --- a/gcc/rust/hir/rust-ast-lower-base.cc +++ b/gcc/rust/hir/rust-ast-lower-base.cc @@ -1077,7 +1077,7 @@ ASTLoweringBase::lower_extern_block (AST::ExternBlock &extern_block) extern_block.get_outer_attrs (), extern_block.get_locus ()); - mappings.insert_hir_extern_block (hir_extern_block); + mappings.hir.extern_block.insert (hir_extern_block); return hir_extern_block; } diff --git a/gcc/rust/hir/rust-ast-lower-block.h b/gcc/rust/hir/rust-ast-lower-block.h index 3b36ea36c258..cb5409e5fa63 100644 --- a/gcc/rust/hir/rust-ast-lower-block.h +++ b/gcc/rust/hir/rust-ast-lower-block.h @@ -37,7 +37,7 @@ class ASTLoweringBlock : public ASTLoweringBase expr.accept_vis (resolver); if (resolver.translated != nullptr) { - resolver.mappings.insert_hir_expr (resolver.translated); + resolver.mappings.hir.expr.insert (resolver.translated); } *terminated = resolver.terminated; @@ -62,7 +62,7 @@ class ASTLoweringBlock : public ASTLoweringBase std::unique_ptr (block), expr.get_outer_attrs (), expr.get_locus ()); - resolver.mappings.insert_hir_expr (translated); + resolver.mappings.hir.expr.insert (translated); return translated; } @@ -89,7 +89,7 @@ class ASTLoweringIfBlock : public ASTLoweringBase expr.accept_vis (resolver); if (resolver.translated != nullptr) { - resolver.mappings.insert_hir_expr (resolver.translated); + resolver.mappings.hir.expr.insert (resolver.translated); } *terminated = resolver.terminated; return resolver.translated; @@ -121,7 +121,7 @@ class ASTLoweringIfLetBlock : public ASTLoweringBase expr.accept_vis (resolver); if (resolver.translated != nullptr) { - resolver.mappings.insert_hir_expr (resolver.translated); + resolver.mappings.hir.expr.insert (resolver.translated); } return resolver.translated; } @@ -152,7 +152,7 @@ class ASTLoweringExprWithBlock : public ASTLoweringBase ASTLoweringExprWithBlock resolver; expr.accept_vis (resolver); if (resolver.translated != nullptr) - resolver.mappings.insert_hir_expr (resolver.translated); + resolver.mappings.hir.expr.insert (resolver.translated); *terminated = resolver.terminated; return resolver.translated; diff --git a/gcc/rust/hir/rust-ast-lower-expr.cc b/gcc/rust/hir/rust-ast-lower-expr.cc index 61a3f10c3fde..4ab3ed56f7f4 100644 --- a/gcc/rust/hir/rust-ast-lower-expr.cc +++ b/gcc/rust/hir/rust-ast-lower-expr.cc @@ -50,7 +50,7 @@ ASTLoweringExpr::translate (AST::Expr &expr, bool *terminated) return nullptr; } - resolver.mappings.insert_hir_expr (resolver.translated); + resolver.mappings.hir.expr.insert (resolver.translated); resolver.mappings.insert_location ( resolver.translated->get_mappings ().get_hirid (), expr.get_locus ()); diff --git a/gcc/rust/hir/rust-ast-lower-implitem.cc b/gcc/rust/hir/rust-ast-lower-implitem.cc index 828d0065fa71..ad9a0090d84f 100644 --- a/gcc/rust/hir/rust-ast-lower-implitem.cc +++ b/gcc/rust/hir/rust-ast-lower-implitem.cc @@ -192,7 +192,7 @@ ASTLowerImplItem::visit (AST::Function &function) if (fn->is_method ()) { // insert mappings for self - mappings.insert_hir_self_param (&fn->get_self_param_unchecked ()); + mappings.hir.self_param.insert (&fn->get_self_param_unchecked ()); mappings.insert_location ( fn->get_self_param_unchecked ().get_mappings ().get_hirid (), fn->get_self_param_unchecked ().get_locus ()); @@ -201,7 +201,7 @@ ASTLowerImplItem::visit (AST::Function &function) // add the mappings for the function params at the end for (auto ¶m : fn->get_function_params ()) { - mappings.insert_hir_param (¶m); + mappings.hir.function_param.insert (¶m); mappings.insert_location (mapping.get_hirid (), param.get_locus ()); } @@ -222,7 +222,7 @@ ASTLowerTraitItem::translate (AST::AssociatedItem &item) auto locus = resolver.translated->get_trait_locus (); resolver.handle_outer_attributes (*resolver.translated); - resolver.mappings.insert_hir_trait_item (resolver.translated); + resolver.mappings.hir.trait_item.insert (resolver.translated); resolver.mappings.insert_location (id, locus); resolver.mappings.insert_defid_mapping (defid, resolver.translated); } @@ -285,7 +285,7 @@ ASTLowerTraitItem::visit (AST::Function &func) { // insert mappings for self // TODO: Is this correct ? Looks fishy - mappings.insert_hir_self_param (&*self_param); + mappings.hir.self_param.insert (&*self_param); mappings.insert_location (self_param->get_mappings ().get_hirid (), self_param->get_locus ()); } @@ -317,7 +317,7 @@ ASTLowerTraitItem::visit (AST::Function &func) // add the mappings for the function params at the end for (auto ¶m : trait_item->get_decl ().get_function_params ()) { - mappings.insert_hir_param (¶m); + mappings.hir.function_param.insert (¶m); mappings.insert_location (mapping.get_hirid (), param.get_locus ()); } } diff --git a/gcc/rust/hir/rust-ast-lower-item.cc b/gcc/rust/hir/rust-ast-lower-item.cc index 546ba6fb848b..56171ef882ed 100644 --- a/gcc/rust/hir/rust-ast-lower-item.cc +++ b/gcc/rust/hir/rust-ast-lower-item.cc @@ -45,7 +45,7 @@ ASTLoweringItem::translate (AST::Item &item) resolver.handle_outer_attributes (*resolver.translated); resolver.mappings.insert_ast_item (&item); - resolver.mappings.insert_hir_item (resolver.translated); + resolver.mappings.hir.item.insert (resolver.translated); resolver.mappings.insert_location (id, locus); resolver.mappings.insert_defid_mapping (defid, resolver.translated); } @@ -83,7 +83,7 @@ ASTLoweringItem::visit (AST::Module &module) = new HIR::Module (mapping, module.get_name (), module.get_locus (), std::move (items), std::move (vis), std::move (inner_attrs), std::move (outer_attrs)); - mappings.insert_module (static_cast (translated)); + mappings.hir.module.insert (static_cast (translated)); } void @@ -507,7 +507,7 @@ ASTLoweringItem::visit (AST::Function &function) // add the mappings for the function params at the end for (auto ¶m : fn->get_function_params ()) { - mappings.insert_hir_param (¶m); + mappings.hir.function_param.insert (¶m); mappings.insert_location (mapping.get_hirid (), param.get_locus ()); } diff --git a/gcc/rust/hir/rust-ast-lower-pattern.cc b/gcc/rust/hir/rust-ast-lower-pattern.cc index 21544ff26645..ed5c68e71a84 100644 --- a/gcc/rust/hir/rust-ast-lower-pattern.cc +++ b/gcc/rust/hir/rust-ast-lower-pattern.cc @@ -36,7 +36,7 @@ ASTLoweringPattern::translate (AST::Pattern &pattern, bool is_let_top_level) rust_assert (resolver.translated != nullptr); - resolver.mappings.insert_hir_pattern (resolver.translated); + resolver.mappings.hir.pattern.insert (resolver.translated); resolver.mappings.insert_location ( resolver.translated->get_mappings ().get_hirid (), pattern.get_locus ()); diff --git a/gcc/rust/hir/rust-ast-lower-stmt.cc b/gcc/rust/hir/rust-ast-lower-stmt.cc index 2f5eede12030..7fe7d3bc5adf 100644 --- a/gcc/rust/hir/rust-ast-lower-stmt.cc +++ b/gcc/rust/hir/rust-ast-lower-stmt.cc @@ -39,7 +39,7 @@ ASTLoweringStmt::translate (AST::Stmt *stmt, bool *terminated) resolver.mappings.insert_location ( resolver.translated->get_mappings ().get_hirid (), resolver.translated->get_locus ()); - resolver.mappings.insert_hir_stmt (resolver.translated); + resolver.mappings.hir.stmt.insert (resolver.translated); return resolver.translated; } diff --git a/gcc/rust/hir/rust-ast-lower-struct-field-expr.h b/gcc/rust/hir/rust-ast-lower-struct-field-expr.h index 903f2abd75b8..225e5843bf36 100644 --- a/gcc/rust/hir/rust-ast-lower-struct-field-expr.h +++ b/gcc/rust/hir/rust-ast-lower-struct-field-expr.h @@ -36,7 +36,7 @@ class ASTLowerStructExprField : public ASTLoweringBase field.accept_vis (compiler); rust_assert (compiler.translated != nullptr); - compiler.mappings.insert_hir_struct_field (compiler.translated); + compiler.mappings.hir.struct_expr_field.insert (compiler.translated); compiler.mappings.insert_location ( compiler.translated->get_mappings ().get_hirid (), field.get_locus ()); diff --git a/gcc/rust/hir/rust-ast-lower-type.cc b/gcc/rust/hir/rust-ast-lower-type.cc index 7bc9c6b97193..031c137daec4 100644 --- a/gcc/rust/hir/rust-ast-lower-type.cc +++ b/gcc/rust/hir/rust-ast-lower-type.cc @@ -223,7 +223,7 @@ ASTLoweringType::translate (AST::Type &type, bool default_to_static_lifetime, type.accept_vis (resolver); rust_assert (resolver.translated != nullptr); - resolver.mappings.insert_hir_type (resolver.translated); + resolver.mappings.hir.type.insert (resolver.translated); resolver.mappings.insert_location ( resolver.translated->get_mappings ().get_hirid (), resolver.translated->get_locus ()); @@ -549,7 +549,7 @@ ASTLowerGenericParam::translate (AST::GenericParam ¶m) rust_assert (resolver.translated != nullptr); resolver.mappings.insert_location ( resolver.translated->get_mappings ().get_hirid (), param.get_locus ()); - resolver.mappings.insert_hir_generic_param (resolver.translated); + resolver.mappings.hir.generic_param.insert (resolver.translated); return resolver.translated; } diff --git a/gcc/rust/hir/rust-ast-lower.cc b/gcc/rust/hir/rust-ast-lower.cc index f31cc92cdb07..64ce2ef709b6 100644 --- a/gcc/rust/hir/rust-ast-lower.cc +++ b/gcc/rust/hir/rust-ast-lower.cc @@ -487,7 +487,7 @@ ASTLowerPathInExpression::visit (AST::PathInExpression &expr) // insert the mappings for the segment HIR::PathExprSegment *lowered_seg = &path_segments.back (); - mappings.insert_hir_path_expr_seg (lowered_seg); + mappings.hir.path_expr_segment.insert (lowered_seg); } translated = new HIR::PathInExpression (mapping, std::move (path_segments), @@ -531,7 +531,7 @@ ASTLowerQualPathInExpression::visit (AST::QualifiedPathInExpression &expr) // insert the mappings for the segment HIR::PathExprSegment *lowered_seg = &path_segments.back (); - mappings.insert_hir_path_expr_seg (lowered_seg); + mappings.hir.path_expr_segment.insert (lowered_seg); } auto crate_num = mappings.crate_mapping.get_current_crate (); diff --git a/gcc/rust/hir/tree/rust-hir-pattern-abstract.cc b/gcc/rust/hir/tree/rust-hir-pattern-abstract.cc index f33af84f3497..6a1031457a3e 100644 --- a/gcc/rust/hir/tree/rust-hir-pattern-abstract.cc +++ b/gcc/rust/hir/tree/rust-hir-pattern-abstract.cc @@ -58,7 +58,7 @@ PathPattern::is_refutable (const TyTy::BaseType &scrutinee) const HirId hir_id = get_final_segment ().get_mappings ().get_hirid (); if (hir_id) { - auto item = mappings.lookup_hir_item (hir_id); + auto item = mappings.hir.item.lookup (hir_id); if (item && item.value ()->get_item_kind () == Item::ItemKind::Constant) { return true; diff --git a/gcc/rust/typecheck/rust-hir-trait-resolve.cc b/gcc/rust/typecheck/rust-hir-trait-resolve.cc index b694521533d5..5ae31122ad42 100644 --- a/gcc/rust/typecheck/rust-hir-trait-resolve.cc +++ b/gcc/rust/typecheck/rust-hir-trait-resolve.cc @@ -227,7 +227,7 @@ TraitResolver::resolve_path_to_trait (const HIR::TypePath &path, return false; } - auto resolved_item = mappings.lookup_hir_item (hid.value ()); + auto resolved_item = mappings.hir.item.lookup (hid.value ()); if (!resolved_item.has_value ()) { rust_error_at (path.get_locus (), diff --git a/gcc/rust/typecheck/rust-hir-type-check-path.cc b/gcc/rust/typecheck/rust-hir-type-check-path.cc index 27d7d55e5951..665ec0054ce9 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-path.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-path.cc @@ -208,7 +208,7 @@ TypeCheckExpr::visit (HIR::PathInExpression &expr) else { TyTy::BaseType *resolved = nullptr; - auto trait_item = mappings.lookup_hir_trait_item (*hir_id); + auto trait_item = mappings.hir.trait_item.lookup (*hir_id); if (trait_item.has_value ()) { HIR::Trait *trait = mappings.lookup_trait_item_mapping (*hir_id); @@ -308,9 +308,9 @@ TypeCheckExpr::resolve_root_path (HIR::PathInExpression &expr, size_t *offset, } auto ref = hid.value (); - auto seg_is_module = mappings.lookup_module (ref).has_value (); + auto seg_is_module = mappings.hir.module.lookup (ref).has_value (); auto seg_is_crate = mappings.is_local_hirid_crate (ref); - auto seg_is_pattern = mappings.lookup_hir_pattern (ref).has_value (); + auto seg_is_pattern = mappings.hir.pattern.lookup (ref).has_value (); auto seg_is_self = is_root && !have_more_segments && seg.get_segment ().to_string () == "self"; if (seg_is_module || seg_is_crate) diff --git a/gcc/rust/typecheck/rust-hir-type-check-pattern.cc b/gcc/rust/typecheck/rust-hir-type-check-pattern.cc index b5f336b42a65..287a903e12f1 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-pattern.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-pattern.cc @@ -74,7 +74,7 @@ TypeCheckPattern::visit (HIR::PathInExpression &pattern) rust_assert (definition_id.has_value ()); HirId def_id = definition_id.value (); - tl::optional hir_item = mappings.lookup_hir_item (def_id); + tl::optional hir_item = mappings.hir.item.lookup (def_id); // If the path references an item, it must be constants or structs. if (hir_item.has_value ()) { diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.cc b/gcc/rust/typecheck/rust-hir-type-check-type.cc index 7ff160b148b6..0d4b735c9fec 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-type.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-type.cc @@ -387,7 +387,7 @@ TypeCheckType::resolve_root_path (HIR::TypePath &path, size_t *offset, } auto ref = hid.value (); - auto seg_is_module = mappings.lookup_module (ref).has_value (); + auto seg_is_module = mappings.hir.module.lookup (ref).has_value (); auto seg_is_crate = mappings.is_local_hirid_crate (ref); if (seg_is_module || seg_is_crate) { diff --git a/gcc/rust/typecheck/rust-type-util.cc b/gcc/rust/typecheck/rust-type-util.cc index 96367df5cb5f..85fafdea070a 100644 --- a/gcc/rust/typecheck/rust-type-util.cc +++ b/gcc/rust/typecheck/rust-type-util.cc @@ -70,7 +70,7 @@ query_type (HirId reference, TyTy::BaseType **result) return true; } - if (auto item = mappings.lookup_hir_item (reference)) + if (auto item = mappings.hir.item.lookup (reference)) { rust_debug_loc (item.value ()->get_locus (), "resolved item {%u} to", reference); @@ -233,7 +233,7 @@ query_type (HirId reference, TyTy::BaseType **result) // is it an extern item? if (auto extern_item = mappings.lookup_hir_extern_item (reference)) { - auto block = mappings.lookup_hir_extern_block (extern_item->second); + auto block = mappings.hir.extern_block.lookup (extern_item->second); rust_assert (block.has_value ()); *result diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index 617963e73b43..47ccc540af0a 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -369,25 +369,6 @@ Mappings::lookup_trait_item_defid (DefId id) return it->second; } -void -Mappings::insert_hir_item (HIR::Item *item) -{ - auto id = item->get_mappings ().get_hirid (); - rust_assert (!lookup_hir_item (id).has_value ()); - - hirItemMappings[id] = item; - insert_node_to_hir (item->get_mappings ().get_nodeid (), id); -} - -tl::optional -Mappings::lookup_hir_item (HirId id) -{ - auto it = hirItemMappings.find (id); - if (it == hirItemMappings.end ()) - return tl::nullopt; - return it->second; -} - void Mappings::insert_hir_enumitem (HIR::Enum *parent, HIR::EnumItem *item) { @@ -409,46 +390,6 @@ Mappings::lookup_hir_enumitem (HirId id) return it->second; } -void -Mappings::insert_hir_trait_item (HIR::TraitItem *item) -{ - auto id = item->get_mappings ().get_hirid (); - rust_assert (!lookup_hir_trait_item (id).has_value ()); - - hirTraitItemMappings[id] = item; - insert_node_to_hir (item->get_mappings ().get_nodeid (), id); -} - -tl::optional -Mappings::lookup_hir_trait_item (HirId id) -{ - auto it = hirTraitItemMappings.find (id); - if (it == hirTraitItemMappings.end ()) - return tl::nullopt; - - return it->second; -} - -void -Mappings::insert_hir_extern_block (HIR::ExternBlock *block) -{ - auto id = block->get_mappings ().get_hirid (); - rust_assert (!lookup_hir_extern_block (id).has_value ()); - - hirExternBlockMappings[id] = block; - insert_node_to_hir (block->get_mappings ().get_nodeid (), id); -} - -tl::optional -Mappings::lookup_hir_extern_block (HirId id) -{ - auto it = hirExternBlockMappings.find (id); - if (it == hirExternBlockMappings.end ()) - return tl::nullopt; - - return it->second; -} - void Mappings::insert_hir_extern_item (HIR::ExternalItem *item, HirId parent_block) { @@ -520,26 +461,6 @@ Mappings::lookup_impl_block_type (HirId id) return it->second; } -void -Mappings::insert_module (HIR::Module *module) -{ - auto id = module->get_mappings ().get_hirid (); - rust_assert (!lookup_module (id)); - - hirModuleMappings[id] = module; - insert_node_to_hir (module->get_mappings ().get_nodeid (), id); -} - -tl::optional -Mappings::lookup_module (HirId id) -{ - auto it = hirModuleMappings.find (id); - if (it == hirModuleMappings.end ()) - return tl::nullopt; - - return it->second; -} - void Mappings::insert_hir_implitem (HirId parent_impl_id, HIR::ImplItem *item) { @@ -561,188 +482,6 @@ Mappings::lookup_hir_implitem (HirId id) return std::make_pair (it->second.second, it->second.first); } -void -Mappings::insert_hir_expr (HIR::Expr *expr) -{ - auto id = expr->get_mappings ().get_hirid (); - hirExprMappings[id] = expr; - - insert_node_to_hir (expr->get_mappings ().get_nodeid (), id); - insert_location (id, expr->get_locus ()); -} - -tl::optional -Mappings::lookup_hir_expr (HirId id) -{ - auto it = hirExprMappings.find (id); - if (it == hirExprMappings.end ()) - return tl::nullopt; - - return it->second; -} - -void -Mappings::insert_hir_path_expr_seg (HIR::PathExprSegment *expr) -{ - auto id = expr->get_mappings ().get_hirid (); - rust_assert (!lookup_hir_path_expr_seg (id)); - - hirPathSegMappings[id] = expr; - insert_node_to_hir (expr->get_mappings ().get_nodeid (), id); - insert_location (id, expr->get_locus ()); -} - -tl::optional -Mappings::lookup_hir_path_expr_seg (HirId id) -{ - auto it = hirPathSegMappings.find (id); - if (it == hirPathSegMappings.end ()) - return tl::nullopt; - - return it->second; -} - -void -Mappings::insert_hir_generic_param (HIR::GenericParam *param) -{ - auto id = param->get_mappings ().get_hirid (); - rust_assert (!lookup_hir_generic_param (id)); - - hirGenericParamMappings[id] = param; - insert_node_to_hir (param->get_mappings ().get_nodeid (), id); - insert_location (id, param->get_locus ()); -} - -tl::optional -Mappings::lookup_hir_generic_param (HirId id) -{ - auto it = hirGenericParamMappings.find (id); - if (it == hirGenericParamMappings.end ()) - return tl::nullopt; - - return it->second; -} - -void -Mappings::insert_hir_type (HIR::Type *type) -{ - auto id = type->get_mappings ().get_hirid (); - rust_assert (!lookup_hir_type (id)); - - hirTypeMappings[id] = type; - insert_node_to_hir (type->get_mappings ().get_nodeid (), id); -} - -tl::optional -Mappings::lookup_hir_type (HirId id) -{ - auto it = hirTypeMappings.find (id); - if (it == hirTypeMappings.end ()) - return tl::nullopt; - - return it->second; -} - -void -Mappings::insert_hir_stmt (HIR::Stmt *stmt) -{ - auto id = stmt->get_mappings ().get_hirid (); - rust_assert (!lookup_hir_stmt (id)); - - hirStmtMappings[id] = stmt; - insert_node_to_hir (stmt->get_mappings ().get_nodeid (), id); -} - -tl::optional -Mappings::lookup_hir_stmt (HirId id) -{ - auto it = hirStmtMappings.find (id); - if (it == hirStmtMappings.end ()) - return tl::nullopt; - - return it->second; -} - -void -Mappings::insert_hir_param (HIR::FunctionParam *param) -{ - auto id = param->get_mappings ().get_hirid (); - rust_assert (!lookup_hir_param (id)); - - hirParamMappings[id] = param; - insert_node_to_hir (param->get_mappings ().get_nodeid (), id); -} - -tl::optional -Mappings::lookup_hir_param (HirId id) -{ - auto it = hirParamMappings.find (id); - if (it == hirParamMappings.end ()) - return tl::nullopt; - - return it->second; -} - -void -Mappings::insert_hir_self_param (HIR::SelfParam *param) -{ - auto id = param->get_mappings ().get_hirid (); - rust_assert (!lookup_hir_self_param (id)); - - hirSelfParamMappings[id] = param; - insert_node_to_hir (param->get_mappings ().get_nodeid (), id); -} - -tl::optional -Mappings::lookup_hir_self_param (HirId id) -{ - auto it = hirSelfParamMappings.find (id); - if (it == hirSelfParamMappings.end ()) - return tl::nullopt; - - return it->second; -} - -void -Mappings::insert_hir_struct_field (HIR::StructExprField *field) -{ - auto id = field->get_mappings ().get_hirid (); - rust_assert (!lookup_hir_struct_field (id)); - - hirStructFieldMappings[id] = field; - insert_node_to_hir (field->get_mappings ().get_nodeid (), id); -} - -tl::optional -Mappings::lookup_hir_struct_field (HirId id) -{ - auto it = hirStructFieldMappings.find (id); - if (it == hirStructFieldMappings.end ()) - return tl::nullopt; - - return it->second; -} - -void -Mappings::insert_hir_pattern (HIR::Pattern *pattern) -{ - auto id = pattern->get_mappings ().get_hirid (); - rust_assert (!lookup_hir_pattern (id)); - - hirPatternMappings[id] = pattern; - insert_node_to_hir (pattern->get_mappings ().get_nodeid (), id); -} - -tl::optional -Mappings::lookup_hir_pattern (HirId id) -{ - auto it = hirPatternMappings.find (id); - if (it == hirPatternMappings.end ()) - return tl::nullopt; - - return it->second; -} - void Mappings::insert_local_defid_mapping (CrateNum crateNum, LocalDefId id, HIR::Item *item) @@ -831,7 +570,7 @@ Mappings::resolve_nodeid_to_stmt (NodeId id) return tl::nullopt; HirId resolved = it->second; - return lookup_hir_stmt (resolved); + return hir.stmt.lookup (resolved); } void @@ -877,7 +616,7 @@ Mappings::build_impl_indexes () if (!hir_id.has_value ()) return nullptr; - auto item = lookup_hir_item (hir_id.value ()); + auto item = hir.item.lookup (hir_id.value ()); return item.has_value () ? item.value () : nullptr; }; @@ -972,7 +711,7 @@ Mappings::insert_trait_item_mapping (HirId trait_item_id, HIR::Trait *trait) == hirTraitItemsToTraitMappings.end ()); hirTraitItemsToTraitMappings[trait_item_id] = trait; - auto item = lookup_hir_trait_item (trait_item_id); + auto item = hir.trait_item.lookup (trait_item_id); rust_assert (item.has_value ()); if (item.value ()->get_item_kind () != HIR::TraitItem::TraitItemKind::FUNC) return; diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index 20d2ceb96f5e..3b02d83ab637 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -172,12 +172,60 @@ template class Mapping void insert (Id id, Item item) { storage.insert ({id, item}); } }; +enum class InsertionPolicy +{ + FORBID_DUPLICATES, + ALLOW_DUPLICATES, +}; + +enum class InsertLocation +{ + YES, + NO, +}; + +template +class PtrMapping +{ + std::unordered_map storage; + +public: + tl::optional lookup (HirId id); + void insert (Item *item); +}; + class ASTMappings { public: Mapping module_visibility; }; +class HIRMappings +{ +public: + PtrMapping item; + PtrMapping trait_item; + PtrMapping extern_block; + PtrMapping module; + PtrMapping + expr; + PtrMapping + path_expr_segment; + PtrMapping + generic_param; + PtrMapping type; + PtrMapping stmt; + PtrMapping + function_param; + PtrMapping self_param; + PtrMapping struct_expr_field; + PtrMapping pattern; +}; + class Mappings { public: @@ -187,6 +235,7 @@ class Mappings CrateMappings crate_mapping; ProcMacroMappings pmacro_mappings; ASTMappings ast; + HIRMappings hir; NodeId get_next_node_id (); HirId get_next_hir_id () @@ -216,18 +265,9 @@ class Mappings tl::optional lookup_local_defid (CrateNum crateNum, LocalDefId id); - void insert_hir_item (HIR::Item *item); - tl::optional lookup_hir_item (HirId id); - void insert_hir_enumitem (HIR::Enum *parent, HIR::EnumItem *item); std::pair lookup_hir_enumitem (HirId id); - void insert_hir_trait_item (HIR::TraitItem *item); - tl::optional lookup_hir_trait_item (HirId id); - - void insert_hir_extern_block (HIR::ExternBlock *block); - tl::optional lookup_hir_extern_block (HirId id); - void insert_hir_extern_item (HIR::ExternalItem *item, HirId parent_block); // std::pair @@ -238,41 +278,11 @@ class Mappings tl::optional lookup_hir_impl_block (HirId id); tl::optional lookup_impl_block_type (HirId id); - void insert_module (HIR::Module *module); - tl::optional lookup_module (HirId id); - void insert_hir_implitem (HirId parent_impl_id, HIR::ImplItem *item); // Optional tl::optional> lookup_hir_implitem (HirId id); - void insert_hir_expr (HIR::Expr *expr); - tl::optional lookup_hir_expr (HirId id); - - void insert_hir_path_expr_seg (HIR::PathExprSegment *expr); - tl::optional lookup_hir_path_expr_seg (HirId id); - - void insert_hir_generic_param (HIR::GenericParam *expr); - tl::optional lookup_hir_generic_param (HirId id); - - void insert_hir_type (HIR::Type *type); - tl::optional lookup_hir_type (HirId id); - - void insert_hir_stmt (HIR::Stmt *stmt); - tl::optional lookup_hir_stmt (HirId id); - - void insert_hir_param (HIR::FunctionParam *type); - tl::optional lookup_hir_param (HirId id); - - void insert_hir_self_param (HIR::SelfParam *type); - tl::optional lookup_hir_self_param (HirId id); - - void insert_hir_struct_field (HIR::StructExprField *type); - tl::optional lookup_hir_struct_field (HirId id); - - void insert_hir_pattern (HIR::Pattern *pattern); - tl::optional lookup_hir_pattern (HirId id); - void walk_local_defids_for_crate (CrateNum crateNum, std::function cb); @@ -553,4 +563,6 @@ class Mappings } // namespace Analysis } // namespace Rust +#include "rust-hir-map.hxx" + #endif // RUST_HIR_MAP_H diff --git a/gcc/rust/util/rust-hir-map.hxx b/gcc/rust/util/rust-hir-map.hxx new file mode 100644 index 000000000000..1d924957452c --- /dev/null +++ b/gcc/rust/util/rust-hir-map.hxx @@ -0,0 +1,77 @@ +// Copyright (C) 2026 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 +// . + +#include "rust-hir-map.h" +#include "optional.h" + +namespace Rust { +namespace Analysis { + +template +tl::optional +PtrMapping::lookup (HirId id) +{ + auto it = storage.find (id); + if (it == storage.cend ()) + return tl::nullopt; + return it->second; +} + +/* Helper required because of GCC 5 baseline + * We need to check if we should include location and then compile + * `item->get_locus()` only if `get_locus` exists within the target item. + * + * With a more recent compiler this would be written as: + * if constexpr(InsertLocation::YES == location) { + * // insert location + * } + * but this is not available on cpp14 with gcc5. + */ +template +struct InsertLocationHelper +{ + void insert_location (Item *item, HirId hir_id) + { + Analysis::Mappings::get ().insert_location (hir_id, item->get_locus ()); + } +}; + +template struct InsertLocationHelper +{ + void insert_location (Item *item, HirId hir_id) {} +}; + +template +void +PtrMapping::insert (Item *item) +{ + auto hir_id = item->get_mappings ().get_hirid (); + + if (policy == InsertionPolicy::FORBID_DUPLICATES) + rust_assert (!lookup (hir_id).has_value ()); + + storage.insert ({hir_id, item}); + + Analysis::Mappings::get ().insert_node_to_hir ( + item->get_mappings ().get_nodeid (), hir_id); + + InsertLocationHelper location_helper; + location_helper.insert_location (item, hir_id); +} +} // namespace Analysis +} // namespace Rust From 5ed04db49a1fe5f4460c8766f868fe4dbd56cde1 Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Wed, 23 Sep 2026 19:25:50 +0200 Subject: [PATCH 578/584] Rename mapping categories Rename pmacro_mappings and crate_mappings to pmacro and crate respectively to stay consistent with the other members name. gcc/rust/ChangeLog: * ast/rust-collect-lang-items.cc (CollectLangItems::visit): Adapt name at call site. * backend/rust-compile-expr.cc: Likewise. * backend/rust-compile-type.cc (TyTyResolveCompile::get_unit_type): Likewise. * checks/errors/borrowck/rust-borrow-checker.cc (BorrowChecker::go): Likewise. * checks/errors/privacy/rust-visibility-resolver.cc (VisibilityResolver::resolve_module_path): Likewise. * expand/rust-macro-expand.h (struct MacroExpander): Likewise. * expand/rust-macro-substitute-ctx.cc: Likewise. * hir/rust-ast-lower-base.cc (ASTLoweringBase::lower_lifetime): Likewise. (ASTLoweringBase::lower_loop_label): Likewise. (ASTLoweringBase::lower_path_expr_seg): Likewise. (ASTLoweringBase::lower_self): Likewise. (ASTLoweringBase::lower_extern_block): Likewise. * hir/rust-ast-lower-block.h: Likewise. * hir/rust-ast-lower-enumitem.h: Likewise. * hir/rust-ast-lower-expr.cc (ASTLoweringExpr::visit): Likewise. * hir/rust-ast-lower-extern.h: Likewise. * hir/rust-ast-lower-implitem.cc (ASTLowerImplItem::visit): Likewise. (ASTLowerTraitItem::visit): Likewise. * hir/rust-ast-lower-item.cc (ASTLoweringItem::visit): Likewise. (ASTLoweringSimplePath::lower): Likewise. * hir/rust-ast-lower-pattern.cc (ASTLoweringPattern::visit): Likewise. * hir/rust-ast-lower-stmt.cc (ASTLoweringStmt::visit): Likewise. * hir/rust-ast-lower-type.cc (ASTLowerTypePath::visit): Likewise. (ASTLowerQualifiedPathInType::visit): Likewise. (ASTLoweringType::visit): Likewise. (ASTLowerGenericParam::visit): Likewise. (ASTLoweringTypeBounds::visit): Likewise. (ASTLowerWhereClauseItem::visit): Likewise. * hir/rust-ast-lower.cc (ASTLowering::go): Likewise. (ASTLoweringBlock::visit): Likewise. (ASTLoweringIfBlock::visit): Likewise. (ASTLoweringIfLetBlock::desugar_iflet): Likewise. (ASTLoweringIfLetBlock::visit): Likewise. (ASTLowerStructExprField::visit): Likewise. (ASTLoweringExprWithBlock::visit): Likewise. (ASTLowerPathInExpression::visit): Likewise. (ASTLoweringBase::lower_qual_path_type): Likewise. (ASTLowerQualPathInExpression::visit): Likewise. * metadata/rust-export-metadata.cc (PublicInterface::gather_export_data): Likewise. (PublicInterface::write_to_object_file): Likewise. (PublicInterface::write_to_path): Likewise. (PublicInterface::expected_metadata_filename): Likewise. * resolve/rust-default-resolver.cc (DefaultResolver::visit): Likewise. * resolve/rust-early-name-resolver-2.0.cc (Early::visit_derive_attribute): Likewise. (Early::visit_non_builtin_attribute): Likewise. * resolve/rust-forever-stack.h: Likewise. * resolve/rust-name-resolution-context.h: Likewise. * resolve/rust-toplevel-name-resolver-2.0.cc (TopLevel::visit_extern_crate): Likewise. * rust-session-manager.cc (Session::handle_crate_name): Likewise. (Session::compile_crate): Likewise. (Session::load_extern_crate): Likewise. * typecheck/rust-hir-type-check-base.cc (TypeCheckBase::resolve_literal): Likewise. * typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit): Likewise. (TypeCheckExpr::resolve_fn_trait_call): Likewise. * typecheck/rust-hir-type-check-implitem.cc (TypeCheckTopLevelExternItem::visit): Likewise. (TypeCheckImplItem::resolve_function_signature): Likewise. * typecheck/rust-hir-type-check-item.cc (TypeCheckItem::visit): Likewise. * typecheck/rust-hir-type-check-struct.cc (TypeCheckStructExpr::resolve): Likewise. * typecheck/rust-hir-type-check.cc (TraitItemReference::get_type_from_fn): Likewise. * typecheck/rust-type-util.cc (query_type): Likewise. * typecheck/rust-tyty-bounds.cc: Likewise. * typecheck/rust-tyty-subst.cc (SubstitutionParamMapping::override_context): Likewise. * typecheck/rust-tyty-util.cc (TyVar::monomorphized_clone): Likewise. * typecheck/rust-tyty.cc (InferType::clone): Likewise. (VariantDef::clone): Likewise. (VariantDef::monomorphized_clone): Likewise. (ConstInferType::clone): Likewise. * util/rust-hir-map.cc (Mappings::get_ast_crate_by_node_id): Likewise. (Mappings::insert_macro_def): Likewise. (Mappings::insert_glob_container): Likewise. * util/rust-hir-map.h: Rename pmacro_mappings to pmacro and crate_mappings to crate. Signed-off-by: Pierre-Emmanuel Patry --- gcc/rust/ast/rust-collect-lang-items.cc | 2 +- gcc/rust/backend/rust-compile-expr.cc | 4 +- gcc/rust/backend/rust-compile-type.cc | 4 +- .../errors/borrowck/rust-borrow-checker.cc | 2 +- .../privacy/rust-visibility-resolver.cc | 4 +- gcc/rust/expand/rust-macro-expand.h | 6 +- gcc/rust/expand/rust-macro-substitute-ctx.cc | 4 +- gcc/rust/hir/rust-ast-lower-base.cc | 10 +-- gcc/rust/hir/rust-ast-lower-block.h | 4 +- gcc/rust/hir/rust-ast-lower-enumitem.h | 12 +-- gcc/rust/hir/rust-ast-lower-expr.cc | 78 +++++++++---------- gcc/rust/hir/rust-ast-lower-extern.h | 8 +- gcc/rust/hir/rust-ast-lower-implitem.cc | 16 ++-- gcc/rust/hir/rust-ast-lower-item.cc | 42 +++++----- gcc/rust/hir/rust-ast-lower-pattern.cc | 26 +++---- gcc/rust/hir/rust-ast-lower-stmt.cc | 6 +- gcc/rust/hir/rust-ast-lower-type.cc | 48 ++++++------ gcc/rust/hir/rust-ast-lower.cc | 32 ++++---- gcc/rust/metadata/rust-export-metadata.cc | 12 +-- gcc/rust/resolve/rust-default-resolver.cc | 6 +- .../resolve/rust-early-name-resolver-2.0.cc | 15 ++-- gcc/rust/resolve/rust-forever-stack.h | 2 +- .../resolve/rust-name-resolution-context.h | 11 +-- .../rust-toplevel-name-resolver-2.0.cc | 13 ++-- gcc/rust/rust-session-manager.cc | 19 ++--- .../typecheck/rust-hir-type-check-base.cc | 2 +- .../typecheck/rust-hir-type-check-expr.cc | 6 +- .../typecheck/rust-hir-type-check-implitem.cc | 4 +- .../typecheck/rust-hir-type-check-item.cc | 2 +- .../typecheck/rust-hir-type-check-struct.cc | 2 +- gcc/rust/typecheck/rust-hir-type-check.cc | 2 +- gcc/rust/typecheck/rust-type-util.cc | 4 +- gcc/rust/typecheck/rust-tyty-bounds.cc | 2 +- gcc/rust/typecheck/rust-tyty-subst.cc | 5 +- gcc/rust/typecheck/rust-tyty-util.cc | 4 +- gcc/rust/typecheck/rust-tyty.cc | 10 +-- gcc/rust/util/rust-hir-map.cc | 7 +- gcc/rust/util/rust-hir-map.h | 8 +- 38 files changed, 216 insertions(+), 228 deletions(-) diff --git a/gcc/rust/ast/rust-collect-lang-items.cc b/gcc/rust/ast/rust-collect-lang-items.cc index 0b3214253b0c..c7843c692e25 100644 --- a/gcc/rust/ast/rust-collect-lang-items.cc +++ b/gcc/rust/ast/rust-collect-lang-items.cc @@ -131,7 +131,7 @@ CollectLangItems::visit (AST::EnumItemDiscriminant &item) void CollectLangItems::visit (AST::ExternCrate &extern_crate) { - auto &crate_mappings = Analysis::Mappings::get ().crate_mapping; + auto &crate_mappings = Analysis::Mappings::get ().crate; auto crate_num = crate_mappings.lookup_crate_name (extern_crate.get_referenced_crate ()); if (crate_num) diff --git a/gcc/rust/backend/rust-compile-expr.cc b/gcc/rust/backend/rust-compile-expr.cc index 0f16010a375a..54ea68f3b35f 100644 --- a/gcc/rust/backend/rust-compile-expr.cc +++ b/gcc/rust/backend/rust-compile-expr.cc @@ -2696,8 +2696,8 @@ HIRCompileBase::resolve_unsized_adt_adjustment ( TyTy::BaseType *cloned_target = target_adt->clone (); cloned_target->set_ref (t_tyvar.get_ref ()); Analysis::NodeMapping pseudo_mapping ( - ctx->get_mappings ().crate_mapping.get_current_crate (), 0, - t_tyvar.get_ref (), 0); + ctx->get_mappings ().crate.get_current_crate (), 0, t_tyvar.get_ref (), + 0); ctx->get_tyctx ()->insert_type (pseudo_mapping, cloned_target); const TyTy::ReferenceType r (ctx->get_mappings ().get_next_hir_id (), diff --git a/gcc/rust/backend/rust-compile-type.cc b/gcc/rust/backend/rust-compile-type.cc index 16d32ac7321b..485180c7e0e8 100644 --- a/gcc/rust/backend/rust-compile-type.cc +++ b/gcc/rust/backend/rust-compile-type.cc @@ -178,8 +178,8 @@ TyTyResolveCompile::get_unit_type (Context *ctx) static tree unit_type; if (unit_type == nullptr) { - auto cn = ctx->get_mappings ().crate_mapping.get_current_crate (); - auto &c = ctx->get_mappings ().crate_mapping.get_ast_crate (cn); + auto cn = ctx->get_mappings ().crate.get_current_crate (); + auto &c = ctx->get_mappings ().crate.get_ast_crate (cn); location_t locus = BUILTINS_LOCATION; if (c.items.size () > 0) { diff --git a/gcc/rust/checks/errors/borrowck/rust-borrow-checker.cc b/gcc/rust/checks/errors/borrowck/rust-borrow-checker.cc index f9e9316f9713..16b8f76a8a1c 100644 --- a/gcc/rust/checks/errors/borrowck/rust-borrow-checker.cc +++ b/gcc/rust/checks/errors/borrowck/rust-borrow-checker.cc @@ -55,7 +55,7 @@ BorrowChecker::go (HIR::Crate &crate) { mkdir ("bir_dump", 0755); auto &mappings = Analysis::Mappings::get (); - crate_name = *mappings.crate_mapping.get_crate_name ( + crate_name = *mappings.crate.get_crate_name ( crate.get_mappings ().get_crate_num ()); mkdir ("nll_facts_gccrs", 0755); } diff --git a/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc b/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc index 76a94906278f..5e65619fe747 100644 --- a/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc +++ b/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc @@ -82,8 +82,8 @@ VisibilityResolver::resolve_module_path (const HIR::SimplePath &restriction, rust_assert (hid.has_value ()); auto ref = hid.value (); - auto crate = mappings.crate_mapping.get_ast_crate ( - mappings.crate_mapping.get_current_crate ()); + auto crate + = mappings.crate.get_ast_crate (mappings.crate.get_current_crate ()); // we may be dealing with pub(crate) if (ref_node_id == crate.get_node_id ()) diff --git a/gcc/rust/expand/rust-macro-expand.h b/gcc/rust/expand/rust-macro-expand.h index 02de84220d12..ae52bf79cd49 100644 --- a/gcc/rust/expand/rust-macro-expand.h +++ b/gcc/rust/expand/rust-macro-expand.h @@ -412,7 +412,7 @@ struct MacroExpander AST::Fragment expand_derive_proc_macro (T &item, AST::SimplePath &path) { tl::optional macro - = mappings.pmacro_mappings.lookup_derive_invocation (path); + = mappings.pmacro.lookup_derive_invocation (path); if (!macro.has_value ()) { rust_error_at (path.get_locus (), "macro not found"); @@ -435,7 +435,7 @@ struct MacroExpander AST::MacroInvocation &invocation) { tl::optional macro - = mappings.pmacro_mappings.lookup_bang_invocation (invocation); + = mappings.pmacro.lookup_bang_invocation (invocation); if (!macro.has_value ()) { rust_error_at (invocation.get_locus (), "macro not found"); @@ -457,7 +457,7 @@ struct MacroExpander AST::Fragment expand_attribute_proc_macro (T &item, AST::SimplePath &path) { tl::optional macro - = mappings.pmacro_mappings.lookup_attribute_invocation (path); + = mappings.pmacro.lookup_attribute_invocation (path); if (!macro.has_value ()) { rust_error_at (path.get_locus (), "macro not found"); diff --git a/gcc/rust/expand/rust-macro-substitute-ctx.cc b/gcc/rust/expand/rust-macro-substitute-ctx.cc index 44c7512f86a3..5fa21e64f231 100644 --- a/gcc/rust/expand/rust-macro-substitute-ctx.cc +++ b/gcc/rust/expand/rust-macro-substitute-ctx.cc @@ -30,7 +30,7 @@ SubstituteCtx::substitute_dollar_crate ( auto &mappings = Analysis::Mappings::get (); auto def_crate = mappings.lookup_macro_def_crate (definition.get_node_id ()); - auto current_crate = mappings.crate_mapping.get_current_crate (); + auto current_crate = mappings.crate.get_current_crate (); rust_assert (def_crate); @@ -44,7 +44,7 @@ SubstituteCtx::substitute_dollar_crate ( } else { - auto name = mappings.crate_mapping.get_crate_name (*def_crate); + auto name = mappings.crate.get_crate_name (*def_crate); rust_assert (name); diff --git a/gcc/rust/hir/rust-ast-lower-base.cc b/gcc/rust/hir/rust-ast-lower-base.cc index ddf866952f80..ffe9f91fd7f5 100644 --- a/gcc/rust/hir/rust-ast-lower-base.cc +++ b/gcc/rust/hir/rust-ast-lower-base.cc @@ -596,7 +596,7 @@ ASTLoweringBase::lower_lifetime (AST::Lifetime &lifetime, lifetime_type = AST::Lifetime::STATIC; } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, lifetime.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -611,7 +611,7 @@ ASTLoweringBase::lower_loop_label (AST::LoopLabel &loop_label) { HIR::Lifetime life = lower_lifetime (loop_label.get_lifetime ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, loop_label.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -636,7 +636,7 @@ ASTLoweringBase::lower_generic_params ( HIR::PathExprSegment ASTLoweringBase::lower_path_expr_seg (AST::PathExprSegment &s) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, s.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -717,7 +717,7 @@ ASTLoweringBase::lower_self (AST::Param ¶m) rust_assert (param.is_self ()); auto self = static_cast (param); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, self.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -1043,7 +1043,7 @@ ASTLoweringBase::lower_extern_block (AST::ExternBlock &extern_block) { HIR::Visibility vis = translate_visibility (extern_block.get_visibility ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, extern_block.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); diff --git a/gcc/rust/hir/rust-ast-lower-block.h b/gcc/rust/hir/rust-ast-lower-block.h index cb5409e5fa63..eadaebd7edde 100644 --- a/gcc/rust/hir/rust-ast-lower-block.h +++ b/gcc/rust/hir/rust-ast-lower-block.h @@ -51,7 +51,7 @@ class ASTLoweringBlock : public ASTLoweringBase HIR::BlockExpr *block = ASTLoweringBlock::translate (expr.get_block_expr (), terminated); - auto crate_num = resolver.mappings.crate_mapping.get_current_crate (); + auto crate_num = resolver.mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), resolver.mappings.get_next_hir_id ( crate_num), @@ -199,7 +199,7 @@ class ASTLoweringExprWithBlock : public ASTLoweringBase if (expr.has_loop_label ()) loop_label = lower_loop_label (expr.get_loop_label ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); diff --git a/gcc/rust/hir/rust-ast-lower-enumitem.h b/gcc/rust/hir/rust-ast-lower-enumitem.h index e5f06b40c86e..0c3ef38c5f48 100644 --- a/gcc/rust/hir/rust-ast-lower-enumitem.h +++ b/gcc/rust/hir/rust-ast-lower-enumitem.h @@ -54,7 +54,7 @@ class ASTLoweringEnumItem : public ASTLoweringBase void visit (AST::EnumItem &item) override { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, item.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -69,7 +69,7 @@ class ASTLoweringEnumItem : public ASTLoweringBase void visit (AST::EnumItemTuple &item) override { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, item.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -87,7 +87,7 @@ class ASTLoweringEnumItem : public ASTLoweringBase HIR::Visibility vis = translate_visibility (field.get_visibility ()); HIR::Type *type = ASTLoweringType::translate (field.get_field_type ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping field_mapping ( crate_num, field.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -104,7 +104,7 @@ class ASTLoweringEnumItem : public ASTLoweringBase void visit (AST::EnumItemStruct &item) override { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, item.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -120,7 +120,7 @@ class ASTLoweringEnumItem : public ASTLoweringBase HIR::Visibility vis = translate_visibility (field.get_visibility ()); HIR::Type *type = ASTLoweringType::translate (field.get_field_type ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping field_mapping ( crate_num, field.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -145,7 +145,7 @@ class ASTLoweringEnumItem : public ASTLoweringBase void visit (AST::EnumItemDiscriminant &item) override { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, item.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); diff --git a/gcc/rust/hir/rust-ast-lower-expr.cc b/gcc/rust/hir/rust-ast-lower-expr.cc index 4ab3ed56f7f4..5aefbfaa308d 100644 --- a/gcc/rust/hir/rust-ast-lower-expr.cc +++ b/gcc/rust/hir/rust-ast-lower-expr.cc @@ -66,7 +66,7 @@ ASTLoweringExpr::visit (AST::TupleIndexExpr &expr) HIR::Expr *tuple_expr = ASTLoweringExpr::translate (expr.get_tuple_expr (), &terminated); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -86,7 +86,7 @@ ASTLoweringExpr::visit (AST::TupleExpr &expr) for (auto &e : expr.get_tuple_elems ()) tuple_elements.emplace_back (ASTLoweringExpr::translate (*e)); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -131,7 +131,7 @@ void ASTLoweringExpr::visit (AST::AnonConst &expr) { auto &mappings = Analysis::Mappings::get (); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); auto mapping = Analysis::NodeMapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -161,7 +161,7 @@ ASTLoweringExpr::visit (AST::ConstBlock &expr) auto anon_const = static_cast (inner_expr); auto &mappings = Analysis::Mappings::get (); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); auto mapping = Analysis::NodeMapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -194,7 +194,7 @@ ASTLoweringExpr::visit (AST::BoxExpr &expr) { HIR::Expr *box_expr = ASTLoweringExpr::translate (expr.get_boxed_expr ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -212,7 +212,7 @@ ASTLoweringExpr::visit (AST::ReturnExpr &expr) ? ASTLoweringExpr::translate (expr.get_returned_expr ()) : nullptr; - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -234,7 +234,7 @@ ASTLoweringExpr::visit (AST::CallExpr &expr) for (auto ¶m : in_params) params.emplace_back (ASTLoweringExpr::translate (*param)); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping ( crate_num, UNKNOWN_NODEID /* this can map back to the AST*/, mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -259,7 +259,7 @@ ASTLoweringExpr::visit (AST::MethodCallExpr &expr) for (auto ¶m : in_params) params.emplace_back (ASTLoweringExpr::translate (*param)); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -276,7 +276,7 @@ ASTLoweringExpr::visit (AST::AssignmentExpr &expr) HIR::Expr *lhs = ASTLoweringExpr::translate (expr.get_left_expr ()); HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -290,7 +290,7 @@ ASTLoweringExpr::visit (AST::AssignmentExpr &expr) void ASTLoweringExpr::visit (AST::IdentifierExpr &expr) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping1 (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -310,7 +310,7 @@ ASTLoweringExpr::visit (AST::ArrayExpr &expr) rust_assert (translated_array_elems != nullptr); HIR::ArrayElems *elems = translated_array_elems; - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -328,7 +328,7 @@ ASTLoweringExpr::visit (AST::ArrayIndexExpr &expr) HIR::Expr *array_index_expr = ASTLoweringExpr::translate (expr.get_index_expr ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -348,7 +348,7 @@ ASTLoweringExpr::visit (AST::ArrayElemsValues &elems) for (auto &elem : elems.get_values ()) elements.emplace_back (ASTLoweringExpr::translate (*elem)); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, elems.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -363,7 +363,7 @@ ASTLoweringExpr::visit (AST::ArrayElemsCopied &elems) HIR::Expr *element = ASTLoweringExpr::translate (elems.get_elem_to_copy ()); HIR::Expr *num_copies = ASTLoweringExpr::translate (elems.get_num_copies ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, elems.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -376,7 +376,7 @@ ASTLoweringExpr::visit (AST::ArrayElemsCopied &elems) void ASTLoweringExpr::visit (AST::LiteralExpr &expr) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -394,7 +394,7 @@ ASTLoweringExpr::visit (AST::ArithmeticOrLogicalExpr &expr) HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ()); rust_assert (rhs != nullptr); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -412,7 +412,7 @@ ASTLoweringExpr::visit (AST::ComparisonExpr &expr) HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ()); rust_assert (rhs != nullptr); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -431,7 +431,7 @@ ASTLoweringExpr::visit (AST::LazyBooleanExpr &expr) HIR::Expr *rhs = ASTLoweringExpr::translate (expr.get_right_expr ()); rust_assert (rhs != nullptr); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -448,7 +448,7 @@ ASTLoweringExpr::visit (AST::NegationExpr &expr) HIR::Expr *negated_value = ASTLoweringExpr::translate (expr.get_negated_expr ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -467,7 +467,7 @@ ASTLoweringExpr::visit (AST::TypeCastExpr &expr) HIR::Type *type_to_cast_to = lower_type_no_bounds (expr.get_type_to_cast_to ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -522,7 +522,7 @@ ASTLoweringExpr::visit (AST::CompoundAssignmentExpr &expr) HIR::Expr *asignee_expr = ASTLoweringExpr::translate (expr.get_left_expr ()); HIR::Expr *value = ASTLoweringExpr::translate (expr.get_right_expr ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -540,7 +540,7 @@ ASTLoweringExpr::visit (AST::StructExprStruct &struct_expr) HIR::PathInExpression copied_path (*path); delete path; - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, struct_expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -578,7 +578,7 @@ ASTLoweringExpr::visit (AST::StructExprStructFields &struct_expr) for (auto &field : in_fields) fields.emplace_back (ASTLowerStructExprField::translate (*field)); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, struct_expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -597,7 +597,7 @@ ASTLoweringExpr::visit (AST::GroupedExpr &expr) HIR::Expr *paren_expr = ASTLoweringExpr::translate (expr.get_expr_in_parens ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -613,7 +613,7 @@ ASTLoweringExpr::visit (AST::FieldAccessExpr &expr) { HIR::Expr *receiver = ASTLoweringExpr::translate (expr.get_receiver_expr ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -647,7 +647,7 @@ ASTLoweringExpr::visit (AST::BreakExpr &expr) ? ASTLoweringExpr::translate (expr.get_break_expr_unchecked ()) : nullptr; - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -665,7 +665,7 @@ ASTLoweringExpr::visit (AST::ContinueExpr &expr) if (expr.has_label ()) break_label = lower_lifetime (expr.get_label_unchecked ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -681,7 +681,7 @@ ASTLoweringExpr::visit (AST::BorrowExpr &expr) HIR::Expr *borrow_lvalue = ASTLoweringExpr::translate (expr.get_borrowed_expr ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -714,7 +714,7 @@ ASTLoweringExpr::visit (AST::DereferenceExpr &expr) HIR::Expr *dref_lvalue = ASTLoweringExpr::translate (expr.get_dereferenced_expr ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -734,7 +734,7 @@ ASTLoweringExpr::visit (AST::MatchExpr &expr) void ASTLoweringExpr::visit (AST::RangeFromToExpr &expr) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -752,7 +752,7 @@ ASTLoweringExpr::visit (AST::RangeFromToExpr &expr) void ASTLoweringExpr::visit (AST::RangeFromExpr &expr) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -767,7 +767,7 @@ ASTLoweringExpr::visit (AST::RangeFromExpr &expr) void ASTLoweringExpr::visit (AST::RangeToExpr &expr) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -782,7 +782,7 @@ ASTLoweringExpr::visit (AST::RangeToExpr &expr) void ASTLoweringExpr::visit (AST::RangeFullExpr &expr) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -793,7 +793,7 @@ ASTLoweringExpr::visit (AST::RangeFullExpr &expr) void ASTLoweringExpr::visit (AST::RangeFromToInclExpr &expr) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping path_mapping (crate_num, mappings.get_next_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -832,7 +832,7 @@ ASTLoweringExpr::visit (AST::ClosureExprInner &expr) for (auto ¶m : expr.get_params ()) closure_params.emplace_back (lower_closure_param (param)); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -858,7 +858,7 @@ ASTLoweringExpr::visit (AST::ClosureExprInnerTyped &expr) for (auto ¶m : expr.get_params ()) closure_params.emplace_back (lower_closure_param (param)); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -987,7 +987,7 @@ from_operand (const AST::InlineAsmOperand &operand) void ASTLoweringExpr::visit (AST::InlineAsm &expr) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -1138,7 +1138,7 @@ ASTLoweringExpr::visit (AST::LlvmInlineAsm &expr) "subset of % to compile libcore"); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -1195,7 +1195,7 @@ ASTLoweringExpr::visit (AST::OffsetOf &offset_of) auto type = std::unique_ptr ( ASTLoweringType::translate (offset_of.get_type ())); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, offset_of.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); diff --git a/gcc/rust/hir/rust-ast-lower-extern.h b/gcc/rust/hir/rust-ast-lower-extern.h index c9cec8cb6c04..fb8b335d7af6 100644 --- a/gcc/rust/hir/rust-ast-lower-extern.h +++ b/gcc/rust/hir/rust-ast-lower-extern.h @@ -53,7 +53,7 @@ class ASTLoweringExternItem : public ASTLoweringBase HIR::Visibility vis = translate_visibility (item.get_visibility ()); HIR::Type *static_type = ASTLoweringType::translate (item.get_type ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, item.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -103,7 +103,7 @@ class ASTLoweringExternItem : public ASTLoweringBase HIR::Type *param_type = ASTLoweringType::translate (param.get_type ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, param.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id ( @@ -113,7 +113,7 @@ class ASTLoweringExternItem : public ASTLoweringBase std::unique_ptr (param_type)); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, function.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -127,7 +127,7 @@ class ASTLoweringExternItem : public ASTLoweringBase void visit (AST::ExternalTypeItem &type) override { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); diff --git a/gcc/rust/hir/rust-ast-lower-implitem.cc b/gcc/rust/hir/rust-ast-lower-implitem.cc index ad9a0090d84f..736c4619b7ed 100644 --- a/gcc/rust/hir/rust-ast-lower-implitem.cc +++ b/gcc/rust/hir/rust-ast-lower-implitem.cc @@ -66,7 +66,7 @@ ASTLowerImplItem::visit (AST::TypeAlias &alias) HIR::Type *existing_type = ASTLoweringType::translate (alias.get_type_aliased ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, alias.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -90,7 +90,7 @@ ASTLowerImplItem::visit (AST::ConstantItem &constant) HIR::Type *type = ASTLoweringType::translate (constant.get_type (), true); HIR::Expr *expr = ASTLoweringExpr::translate (constant.get_expr ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, constant.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -157,7 +157,7 @@ ASTLowerImplItem::visit (AST::Function &function) auto translated_type = std::unique_ptr ( ASTLoweringType::translate (param.get_type ())); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, param.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -173,7 +173,7 @@ ASTLowerImplItem::visit (AST::Function &function) ASTLoweringBlock::translate (*function.get_definition ().value (), &terminated)); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, function.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -271,7 +271,7 @@ ASTLowerTraitItem::visit (AST::Function &func) auto translated_type = std::unique_ptr ( ASTLoweringType::translate (param.get_type ())); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, param.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -304,7 +304,7 @@ ASTLowerTraitItem::visit (AST::Function &func) &terminated)) : nullptr; - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, func.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -330,7 +330,7 @@ ASTLowerTraitItem::visit (AST::ConstantItem &constant) ? ASTLoweringExpr::translate (constant.get_expr ()) : nullptr; - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, constant.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -365,7 +365,7 @@ ASTLowerTraitItem::visit (AST::TraitItemType &type) std::unique_ptr (lowered_bound)); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); diff --git a/gcc/rust/hir/rust-ast-lower-item.cc b/gcc/rust/hir/rust-ast-lower-item.cc index 56171ef882ed..03ac6ac9bb9d 100644 --- a/gcc/rust/hir/rust-ast-lower-item.cc +++ b/gcc/rust/hir/rust-ast-lower-item.cc @@ -56,7 +56,7 @@ ASTLoweringItem::translate (AST::Item &item) void ASTLoweringItem::visit (AST::Module &module) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, module.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -106,7 +106,7 @@ ASTLoweringItem::visit (AST::TypeAlias &alias) HIR::Type *existing_type = ASTLoweringType::translate (alias.get_type_aliased ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, alias.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -151,7 +151,7 @@ ASTLoweringItem::visit (AST::TupleStruct &struct_decl) HIR::Visibility vis = translate_visibility (field.get_visibility ()); HIR::Type *type = ASTLoweringType::translate (field.get_field_type ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, field.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -160,7 +160,7 @@ ASTLoweringItem::visit (AST::TupleStruct &struct_decl) field.get_locus (), field.get_outer_attrs ()); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, struct_decl.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -204,7 +204,7 @@ ASTLoweringItem::visit (AST::StructStruct &struct_decl) HIR::Visibility vis = translate_visibility (field.get_visibility ()); HIR::Type *type = ASTLoweringType::translate (field.get_field_type ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, field.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -220,7 +220,7 @@ ASTLoweringItem::visit (AST::StructStruct &struct_decl) fields.push_back (std::move (translated_field)); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, struct_decl.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -265,7 +265,7 @@ ASTLoweringItem::visit (AST::Enum &enum_decl) items.emplace_back (ASTLoweringEnumItem::translate (variant.get ())); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, enum_decl.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -310,7 +310,7 @@ ASTLoweringItem::visit (AST::Union &union_decl) HIR::Visibility vis = translate_visibility (variant.get_visibility ()); HIR::Type *type = ASTLoweringType::translate (variant.get_field_type ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, variant.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -326,7 +326,7 @@ ASTLoweringItem::visit (AST::Union &union_decl) variants.push_back (std::move (translated_variant)); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, union_decl.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -346,7 +346,7 @@ ASTLoweringItem::visit (AST::StaticItem &var) HIR::Type *type = ASTLoweringType::translate (var.get_type (), true); HIR::Expr *expr = ASTLoweringExpr::translate (var.get_expr ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, var.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -369,7 +369,7 @@ ASTLoweringItem::visit (AST::ConstantItem &constant) if (constant.has_expr ()) expr = ASTLoweringExpr::translate (constant.get_expr ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, constant.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -418,7 +418,7 @@ ASTLoweringItem::visit (AST::Function &function) std::vector function_params; function_params.reserve (function.get_function_params ().size ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); for (auto &p : function.get_function_params ()) { if (p->is_variadic ()) @@ -470,7 +470,7 @@ ASTLoweringItem::visit (AST::Function &function) auto translated_type = std::unique_ptr ( ASTLoweringType::translate (param.get_type ())); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, param.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -565,7 +565,7 @@ ASTLoweringItem::visit (AST::InherentImpl &impl_block) HIR::Type *impl_type = ASTLoweringType::translate (impl_block.get_type ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, impl_block.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -649,7 +649,7 @@ ASTLoweringItem::visit (AST::Trait &trait) trait_items.emplace_back (lowered); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, trait.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -729,7 +729,7 @@ ASTLoweringItem::visit (AST::TraitImpl &impl_block) HIR::TypePath *trait_ref = ASTLowerTypePath::translate (impl_block.get_trait_path ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, impl_block.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -791,14 +791,14 @@ ASTLoweringItem::visit (AST::ExternCrate &extern_crate) return; auto &mappings = Analysis::Mappings::get (); - auto &crate_mapping = mappings.crate_mapping; + auto &crate_mapping = mappings.crate; CrateNum num = crate_mapping.lookup_crate_name (extern_crate.get_referenced_crate ()) .value (); - AST::Crate &crate = mappings.crate_mapping.get_ast_crate (num); + AST::Crate &crate = mappings.crate.get_ast_crate (num); - auto saved_crate_num = mappings.crate_mapping.get_current_crate (); + auto saved_crate_num = mappings.crate.get_current_crate (); crate_mapping.set_current_crate (num); auto lowered = ASTLowering::Resolve (crate); mappings.insert_hir_crate (std::move (lowered)); @@ -816,7 +816,7 @@ ASTLoweringSimplePath::translate (const AST::SimplePath &path) HIR::SimplePathSegment ASTLoweringSimplePath::lower (const AST::SimplePathSegment &segment) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); auto node_id = segment.get_node_id (); auto mapping = Analysis::NodeMapping (crate_num, node_id, @@ -838,7 +838,7 @@ ASTLoweringSimplePath::lower (const AST::SimplePath &path) for (auto &segment : path.get_segments ()) segments.emplace_back (lower (segment)); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); auto node_id = path.get_node_id (); auto mapping = Analysis::NodeMapping (crate_num, node_id, diff --git a/gcc/rust/hir/rust-ast-lower-pattern.cc b/gcc/rust/hir/rust-ast-lower-pattern.cc index ed5c68e71a84..6ab109560c1a 100644 --- a/gcc/rust/hir/rust-ast-lower-pattern.cc +++ b/gcc/rust/hir/rust-ast-lower-pattern.cc @@ -46,7 +46,7 @@ ASTLoweringPattern::translate (AST::Pattern &pattern, bool is_let_top_level) void ASTLoweringPattern::visit (AST::IdentifierPattern &pattern) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -124,7 +124,7 @@ ASTLoweringPattern::visit (AST::TupleStructPattern &pattern) break; } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -152,7 +152,7 @@ ASTLoweringPattern::visit (AST::StructPattern &pattern) auto &tuple = static_cast (*field); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, tuple.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -173,7 +173,7 @@ ASTLoweringPattern::visit (AST::StructPattern &pattern) AST::StructPatternFieldIdentPat &ident = static_cast (*field); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, ident.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -194,7 +194,7 @@ ASTLoweringPattern::visit (AST::StructPattern &pattern) AST::StructPatternFieldIdent &ident = static_cast (*field.get ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, ident.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -217,7 +217,7 @@ ASTLoweringPattern::visit (AST::StructPattern &pattern) fields.emplace_back (f); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -230,7 +230,7 @@ ASTLoweringPattern::visit (AST::StructPattern &pattern) void ASTLoweringPattern::visit (AST::WildcardPattern &pattern) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -261,7 +261,7 @@ ASTLoweringPattern::visit (AST::TuplePattern &pattern) break; } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -273,7 +273,7 @@ ASTLoweringPattern::visit (AST::TuplePattern &pattern) void ASTLoweringPattern::visit (AST::LiteralPattern &pattern) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -290,7 +290,7 @@ ASTLoweringPattern::visit (AST::RangePattern &pattern) auto upper_bound = lower_range_pattern_bound (pattern.get_upper_bound ()); auto lower_bound = lower_range_pattern_bound (pattern.get_lower_bound ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -312,7 +312,7 @@ ASTLoweringPattern::visit (AST::GroupedPattern &pattern) void ASTLoweringPattern::visit (AST::ReferencePattern &pattern) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -360,7 +360,7 @@ ASTLoweringPattern::visit (AST::SlicePattern &pattern) // need this earlier than usual // since we might need to produce rest_bind - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); for (size_t i = 0; i < sub_patterns.size (); i++) { @@ -424,7 +424,7 @@ ASTLoweringPattern::visit (AST::SlicePattern &pattern) void ASTLoweringPattern::visit (AST::AltPattern &pattern) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); diff --git a/gcc/rust/hir/rust-ast-lower-stmt.cc b/gcc/rust/hir/rust-ast-lower-stmt.cc index 7fe7d3bc5adf..5281659a6442 100644 --- a/gcc/rust/hir/rust-ast-lower-stmt.cc +++ b/gcc/rust/hir/rust-ast-lower-stmt.cc @@ -49,7 +49,7 @@ ASTLoweringStmt::visit (AST::ExprStmt &stmt) { HIR::Expr *expr = ASTLoweringExpr::translate (stmt.get_expr (), &terminated); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, stmt.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -87,7 +87,7 @@ ASTLoweringStmt::visit (AST::LetStmt &stmt) else_expr = std::unique_ptr ( ASTLoweringExpr::translate (stmt.get_else_expr ())); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, stmt.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -125,7 +125,7 @@ ASTLoweringStmt::visit (AST::Enum &enum_decl) void ASTLoweringStmt::visit (AST::EmptyStmt &empty) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, empty.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); diff --git a/gcc/rust/hir/rust-ast-lower-type.cc b/gcc/rust/hir/rust-ast-lower-type.cc index 031c137daec4..10e77e3a6a23 100644 --- a/gcc/rust/hir/rust-ast-lower-type.cc +++ b/gcc/rust/hir/rust-ast-lower-type.cc @@ -38,7 +38,7 @@ ASTLowerTypePath::translate (AST::TypePath &type) void ASTLowerTypePath::visit (AST::TypePathSegmentFunction &segment) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); auto hirid = mappings.get_next_hir_id (crate_num); Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid, UNKNOWN_LOCAL_DEFID); @@ -69,7 +69,7 @@ ASTLowerTypePath::visit (AST::TypePathSegmentFunction &segment) void ASTLowerTypePath::visit (AST::TypePathSegment &segment) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); auto hirid = mappings.get_next_hir_id (crate_num); Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid, UNKNOWN_LOCAL_DEFID); @@ -97,7 +97,7 @@ ASTLowerTypePath::visit (AST::TypePathSegmentGeneric &segment) auto generic_args = lower_generic_args (segment.get_generic_args ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); auto hirid = mappings.get_next_hir_id (crate_num); Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid, UNKNOWN_LOCAL_DEFID); @@ -137,7 +137,7 @@ ASTLowerTypePath::visit (AST::TypePath &path) std::unique_ptr (translated_segment)); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); auto hirid = mappings.get_next_hir_id (crate_num); Analysis::NodeMapping mapping (crate_num, path.get_node_id (), hirid, mappings.get_next_localdef_id (crate_num)); @@ -160,7 +160,7 @@ ASTLowerQualifiedPathInType::translate (AST::QualifiedPathInType &type) void ASTLowerQualifiedPathInType::visit (AST::QualifiedPathInType &path) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); auto hirid = mappings.get_next_hir_id (crate_num); Analysis::NodeMapping qual_mappings ( crate_num, path.get_qualified_path_type ().get_node_id (), hirid, @@ -284,7 +284,7 @@ ASTLoweringType::visit (AST::BareFunctionType &fntype) impl_trait_allowed); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, fntype.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -306,7 +306,7 @@ ASTLoweringType::visit (AST::TupleType &tuple) elems.push_back (std::unique_ptr (t)); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, tuple.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -336,7 +336,7 @@ ASTLoweringType::visit (AST::ArrayType &type) impl_trait_allowed); HIR::Expr *array_size = ASTLoweringExpr::translate (type.get_size_expr ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -357,7 +357,7 @@ ASTLoweringType::visit (AST::ReferenceType &type) default_to_static_lifetime, impl_trait_allowed); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -377,7 +377,7 @@ ASTLoweringType::visit (AST::RawPointerType &type) default_to_static_lifetime, impl_trait_allowed); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -399,7 +399,7 @@ ASTLoweringType::visit (AST::SliceType &type) default_to_static_lifetime, impl_trait_allowed); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -412,7 +412,7 @@ ASTLoweringType::visit (AST::SliceType &type) void ASTLoweringType::visit (AST::InferredType &type) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -423,7 +423,7 @@ ASTLoweringType::visit (AST::InferredType &type) void ASTLoweringType::visit (AST::NeverType &type) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -439,7 +439,7 @@ ASTLoweringType::visit (AST::TraitObjectTypeOneBound &type) = ASTLoweringTypeBounds::translate (type.get_trait_bound ()); bounds.push_back (std::unique_ptr (translated_bound)); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -461,7 +461,7 @@ ASTLoweringType::visit (AST::TraitObjectType &type) std::unique_ptr (translated_bound)); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -477,7 +477,7 @@ ASTLoweringType::visit (AST::ParenthesisedType &type) default_to_static_lifetime, impl_trait_allowed); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -502,7 +502,7 @@ ASTLoweringType::visit (AST::ImplTraitType &type) bounds.push_back (std::unique_ptr (b)); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -522,7 +522,7 @@ ASTLoweringType::visit (AST::ImplTraitTypeOneBound &type) auto b = ASTLoweringTypeBounds::translate (*type.get_trait_bound ().get ()); bounds.push_back (std::unique_ptr (b)); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, type.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -557,7 +557,7 @@ ASTLowerGenericParam::translate (AST::GenericParam ¶m) void ASTLowerGenericParam::visit (AST::LifetimeParam ¶m) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); AST::Lifetime lifetime = param.get_lifetime (); Analysis::NodeMapping mapping (crate_num, param.get_node_id (), mappings.get_next_hir_id (crate_num), @@ -574,7 +574,7 @@ ASTLowerGenericParam::visit (AST::LifetimeParam ¶m) void ASTLowerGenericParam::visit (AST::ConstGenericParam ¶m) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, param.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -612,7 +612,7 @@ ASTLowerGenericParam::visit (AST::TypeParam ¶m) = tl::optional> (std::unique_ptr ( ASTLoweringType::translate (param.get_type ()))); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, param.get_node_id (), mappings.get_next_hir_id (crate_num), mappings.get_next_localdef_id (crate_num)); @@ -652,7 +652,7 @@ ASTLoweringTypeBounds::visit (AST::TraitBound &bound) AST::TypePath &ast_trait_path = bound.get_type_path (); HIR::TypePath *trait_path = ASTLowerTypePath::translate (ast_trait_path); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, bound.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -698,7 +698,7 @@ ASTLowerWhereClauseItem::visit (AST::LifetimeWhereClauseItem &item) lifetime_bounds.push_back (std::move (ll)); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, item.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -731,7 +731,7 @@ ASTLowerWhereClauseItem::visit (AST::TypeBoundWhereClauseItem &item) type_param_bounds.push_back (std::unique_ptr (b)); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, item.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); diff --git a/gcc/rust/hir/rust-ast-lower.cc b/gcc/rust/hir/rust-ast-lower.cc index 64ce2ef709b6..154468a72b5c 100644 --- a/gcc/rust/hir/rust-ast-lower.cc +++ b/gcc/rust/hir/rust-ast-lower.cc @@ -82,7 +82,7 @@ ASTLowering::go () } auto &mappings = Analysis::Mappings::get (); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, astCrate.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -145,7 +145,7 @@ ASTLoweringBlock::visit (AST::BlockExpr &expr) } bool tail_reachable = !block_did_terminate; - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -168,7 +168,7 @@ ASTLoweringIfBlock::visit (AST::IfExpr &expr) HIR::BlockExpr *block = ASTLoweringBlock::translate (expr.get_if_block (), &ignored_terminated); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -195,7 +195,7 @@ ASTLoweringIfBlock::visit (AST::IfExprConseqElse &expr) terminated = if_block_terminated && else_block_termianted; - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -245,7 +245,7 @@ ASTLoweringIfLetBlock::desugar_iflet (AST::IfLetExpr &expr, HIR::MatchArm arm (std::move (match_arm_pattern), expr.get_locus (), nullptr, {}); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -286,7 +286,7 @@ ASTLoweringIfLetBlock::visit (AST::IfLetExpr &expr) HIR::Expr *branch_value; std::vector match_arms; - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -326,7 +326,7 @@ ASTLoweringIfLetBlock::visit (AST::IfLetExprConseqElse &expr) desugar_iflet (expr, &branch_value, kase_else_expr, match_arms); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -343,7 +343,7 @@ ASTLowerStructExprField::visit (AST::StructExprFieldIdentifierValue &field) { HIR::Expr *value = ASTLoweringExpr::translate (field.get_value ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, field.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -358,7 +358,7 @@ ASTLowerStructExprField::visit (AST::StructExprFieldIndexValue &field) { HIR::Expr *value = ASTLoweringExpr::translate (field.get_value ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, field.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -372,7 +372,7 @@ ASTLowerStructExprField::visit (AST::StructExprFieldIndexValue &field) void ASTLowerStructExprField::visit (AST::StructExprFieldIdentifier &field) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, field.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -397,7 +397,7 @@ ASTLoweringExprWithBlock::visit (AST::WhileLoopExpr &expr) HIR::Expr *loop_condition = ASTLoweringExpr::translate (expr.get_predicate_expr (), &terminated); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -439,7 +439,7 @@ ASTLoweringExprWithBlock::visit (AST::MatchExpr &expr) std::unique_ptr (kase_guard_expr), match_case.get_arm ().get_outer_attrs ()); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -448,7 +448,7 @@ ASTLoweringExprWithBlock::visit (AST::MatchExpr &expr) std::unique_ptr (kase_expr)); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -464,7 +464,7 @@ ASTLoweringExprWithBlock::visit (AST::MatchExpr &expr) void ASTLowerPathInExpression::visit (AST::PathInExpression &expr) { - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -504,7 +504,7 @@ ASTLoweringBase::lower_qual_path_type (AST::QualifiedPathType &qualified_type) ? ASTLowerTypePath::translate (qualified_type.get_as_type_path ()) : nullptr; - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, qualified_type.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -534,7 +534,7 @@ ASTLowerQualPathInExpression::visit (AST::QualifiedPathInExpression &expr) mappings.hir.path_expr_segment.insert (lowered_seg); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); diff --git a/gcc/rust/metadata/rust-export-metadata.cc b/gcc/rust/metadata/rust-export-metadata.cc index 1030f32092b2..f0618fa65a5a 100644 --- a/gcc/rust/metadata/rust-export-metadata.cc +++ b/gcc/rust/metadata/rust-export-metadata.cc @@ -95,9 +95,9 @@ PublicInterface::ExportTo (HIR::Crate &crate, const std::string &output_path) void PublicInterface::gather_export_data () { - auto crate_num = mappings.crate_mapping.lookup_crate_num ( - crate.get_mappings ().get_nodeid ()); - auto &ast_crate = mappings.crate_mapping.get_ast_crate (crate_num.value ()); + auto crate_num + = mappings.crate.lookup_crate_num (crate.get_mappings ().get_nodeid ()); + auto &ast_crate = mappings.crate.get_ast_crate (crate_num.value ()); context.emit_crate (ast_crate); for (auto ¯o : mappings.get_exported_macros ()) @@ -121,7 +121,7 @@ PublicInterface::write_to_object_file () const // MAGIC MD5 DLIM DLIM buffer-size DELIM contents const std::string current_crate_name - = mappings.crate_mapping.get_current_crate_name (); + = mappings.crate.get_current_crate_name (); // extern void rust_write_export_data (kMagicHeader, sizeof (kMagicHeader)); @@ -164,7 +164,7 @@ PublicInterface::write_to_path (const std::string &path) const // MAGIC MD5 DLIM DLIM buffer-size DELIM contents const std::string current_crate_name - = mappings.crate_mapping.get_current_crate_name (); + = mappings.crate.get_current_crate_name (); // write to path FILE *nfd = fopen (path.c_str (), "wb"); @@ -267,7 +267,7 @@ PublicInterface::expected_metadata_filename () auto &mappings = Analysis::Mappings::get (); const std::string current_crate_name - = mappings.crate_mapping.get_current_crate_name (); + = mappings.crate.get_current_crate_name (); return current_crate_name + extension_path; } diff --git a/gcc/rust/resolve/rust-default-resolver.cc b/gcc/rust/resolve/rust-default-resolver.cc index 0433156482d3..585df8979f6c 100644 --- a/gcc/rust/resolve/rust-default-resolver.cc +++ b/gcc/rust/resolve/rust-default-resolver.cc @@ -41,7 +41,7 @@ DefaultResolver::visit (AST::Crate &crate) AST::DefaultASTVisitor::visit (crate); }; - auto &crate_mappings = Analysis::Mappings::get ().crate_mapping; + auto &crate_mappings = Analysis::Mappings::get ().crate; auto crate_num = crate_mappings.lookup_crate_num (crate.get_node_id ()); rust_assert (crate_num.has_value ()); @@ -482,7 +482,7 @@ void DefaultResolver::visit (AST::ExternCrate &crate) { auto &mappings = Analysis::Mappings::get (); - auto &crate_mappings = mappings.crate_mapping; + auto &crate_mappings = mappings.crate; tl::optional num_opt; if (crate.get_referenced_crate () == "self") num_opt = crate_mappings.get_current_crate (); @@ -498,7 +498,7 @@ DefaultResolver::visit (AST::ExternCrate &crate) CrateNum num = *num_opt; - AST::Crate &referenced_crate = mappings.crate_mapping.get_ast_crate (num); + AST::Crate &referenced_crate = mappings.crate.get_ast_crate (num); auto sub_visitor_1 = [&, this] () { visit_extern_crate (crate, referenced_crate, num); }; diff --git a/gcc/rust/resolve/rust-early-name-resolver-2.0.cc b/gcc/rust/resolve/rust-early-name-resolver-2.0.cc index d45536717a73..a0a5eec876c2 100644 --- a/gcc/rust/resolve/rust-early-name-resolver-2.0.cc +++ b/gcc/rust/resolve/rust-early-name-resolver-2.0.cc @@ -402,12 +402,11 @@ Early::visit_derive_attribute (AST::Attribute &attr, continue; } - auto pm_def = mappings.pmacro_mappings.lookup_derive_def ( - ns_def->definition.get_node_id ()); + auto pm_def + = mappings.pmacro.lookup_derive_def (ns_def->definition.get_node_id ()); if (pm_def.has_value ()) - mappings.pmacro_mappings.insert_derive_invocation (trait, - pm_def.value ()); + mappings.pmacro.insert_derive_invocation (trait, pm_def.value ()); } } @@ -425,14 +424,14 @@ Early::visit_non_builtin_attribute (AST::Attribute &attr, name.c_str ())); return; } - auto pm_def = mappings.pmacro_mappings.lookup_attribute_def ( - ns_def->definition.get_node_id ()); + auto pm_def + = mappings.pmacro.lookup_attribute_def (ns_def->definition.get_node_id ()); if (!pm_def.has_value ()) return; - mappings.pmacro_mappings.insert_attribute_invocation (attr.get_path (), - pm_def.value ()); + mappings.pmacro.insert_attribute_invocation (attr.get_path (), + pm_def.value ()); } void diff --git a/gcc/rust/resolve/rust-forever-stack.h b/gcc/rust/resolve/rust-forever-stack.h index 07eb6293bd3f..3e18fea869f8 100644 --- a/gcc/rust/resolve/rust-forever-stack.h +++ b/gcc/rust/resolve/rust-forever-stack.h @@ -597,7 +597,7 @@ template class ForeverStack : public ForeverStackBase // TODO: Should we be using the forever stack root as the crate scope? // TODO: Is this how we should be getting the crate node id? - auto &crate_mappings = Analysis::Mappings::get ().crate_mapping; + auto &crate_mappings = Analysis::Mappings::get ().crate; root.id = *crate_mappings.crate_num_to_nodeid ( crate_mappings.get_current_crate ()); } diff --git a/gcc/rust/resolve/rust-name-resolution-context.h b/gcc/rust/resolve/rust-name-resolution-context.h index 8903b23ae327..8311d6dd85b8 100644 --- a/gcc/rust/resolve/rust-name-resolution-context.h +++ b/gcc/rust/resolve/rust-name-resolution-context.h @@ -253,11 +253,9 @@ class CanonicalPathRecordCrateRoot : public CanonicalPathRecord CanonicalPathRecordCrateRoot (NodeId node_id, std::string seg) : node_id (node_id), seg (std::move (seg)) { - rust_assert ( - Analysis::Mappings::get ().crate_mapping.node_is_crate (node_id)); - crate_num = Analysis::Mappings::get () - .crate_mapping.lookup_crate_num (node_id) - .value (); + rust_assert (Analysis::Mappings::get ().crate.node_is_crate (node_id)); + crate_num + = Analysis::Mappings::get ().crate.lookup_crate_num (node_id).value (); } Resolver::CanonicalPath as_path (const NameResolutionContext &, @@ -279,8 +277,7 @@ class CanonicalPathRecordNormal : public CanonicalPathRecordWithParent : CanonicalPathRecordWithParent (parent_node_id), node_id (node_id), seg (std::move (seg)) { - rust_assert ( - !Analysis::Mappings::get ().crate_mapping.node_is_crate (node_id)); + rust_assert (!Analysis::Mappings::get ().crate.node_is_crate (node_id)); } Resolver::CanonicalPath as_path (const NameResolutionContext &, diff --git a/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc b/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc index 4b2fae0ddb89..0e4172239435 100644 --- a/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc +++ b/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc @@ -187,31 +187,30 @@ TopLevel::visit_extern_crate (AST::ExternCrate &extern_crate, AST::Crate &crate, { auto &mappings = Analysis::Mappings::get (); - auto attribute_macros - = mappings.pmacro_mappings.lookup_attribute_proc_macros (num); + auto attribute_macros = mappings.pmacro.lookup_attribute_proc_macros (num); - auto bang_macros = mappings.pmacro_mappings.lookup_bang_proc_macros (num); + auto bang_macros = mappings.pmacro.lookup_bang_proc_macros (num); - auto derive_macros = mappings.pmacro_mappings.lookup_derive_proc_macros (num); + auto derive_macros = mappings.pmacro.lookup_derive_proc_macros (num); // TODO: Find a way to keep this part clean without the double dispatch. if (derive_macros.has_value ()) { insert_macros (derive_macros.value (), ctx); for (auto ¯o : derive_macros.value ()) - mappings.pmacro_mappings.insert_derive_def (macro); + mappings.pmacro.insert_derive_def (macro); } if (attribute_macros.has_value ()) { insert_macros (attribute_macros.value (), ctx); for (auto ¯o : attribute_macros.value ()) - mappings.pmacro_mappings.insert_attribute_def (macro); + mappings.pmacro.insert_attribute_def (macro); } if (bang_macros.has_value ()) { insert_macros (bang_macros.value (), ctx); for (auto ¯o : bang_macros.value ()) - mappings.pmacro_mappings.insert_bang_def (macro); + mappings.pmacro.insert_bang_def (macro); } // We do *NOT* visit the crate because loaded crates are resolved diff --git a/gcc/rust/rust-session-manager.cc b/gcc/rust/rust-session-manager.cc index 868216024a1b..e12147700ce9 100644 --- a/gcc/rust/rust-session-manager.cc +++ b/gcc/rust/rust-session-manager.cc @@ -543,7 +543,7 @@ Session::handle_crate_name (const char *filename, if (saw_errors ()) return; - auto &crate_mappings = Analysis::Mappings::get ().crate_mapping; + auto &crate_mappings = Analysis::Mappings::get ().crate; CrateNum crate_num = crate_mappings.get_next_crate_num (options.get_crate_name ()); @@ -669,10 +669,9 @@ Session::compile_crate (const char *filename) } // setup the mappings for this AST - CrateNum current_crate = mappings.crate_mapping.get_current_crate (); + CrateNum current_crate = mappings.crate.get_current_crate (); AST::Crate &parsed_crate - = mappings.crate_mapping.insert_ast_crate (std::move (ast_crate), - current_crate); + = mappings.crate.insert_ast_crate (std::move (ast_crate), current_crate); /* basic pipeline: * - lex @@ -1256,7 +1255,7 @@ Session::dump_hir_pretty (HIR::Crate &crate) const tl::expected Session::load_extern_crate (const std::string &crate_name, location_t locus) { - auto &crate_mapping = mappings.crate_mapping; + auto &crate_mapping = mappings.crate; // has it already been loaded? if (auto crate_num = crate_mapping.lookup_crate_name (crate_name)) { @@ -1334,8 +1333,7 @@ Session::load_extern_crate (const std::string &crate_name, location_t locus) std::unique_ptr metadata_crate = parser.parse_crate (); AST::Crate &parsed_crate - = mappings.crate_mapping.insert_ast_crate (std::move (metadata_crate), - crate_num); + = mappings.crate.insert_ast_crate (std::move (metadata_crate), crate_num); auto ctx = Resolver2_0::NameResolutionContext (); Resolver2_0::Builtins::setup_lang_prelude (ctx); @@ -1366,10 +1364,9 @@ Session::load_extern_crate (const std::string &crate_name, location_t locus) } } - mappings.pmacro_mappings.insert_attribute_proc_macros (crate_num, - attribute_macros); - mappings.pmacro_mappings.insert_bang_proc_macros (crate_num, bang_macros); - mappings.pmacro_mappings.insert_derive_proc_macros (crate_num, derive_macros); + mappings.pmacro.insert_attribute_proc_macros (crate_num, attribute_macros); + mappings.pmacro.insert_bang_proc_macros (crate_num, bang_macros); + mappings.pmacro.insert_derive_proc_macros (crate_num, derive_macros); // always restore the crate_num crate_mapping.set_current_crate (saved_crate_num); diff --git a/gcc/rust/typecheck/rust-hir-type-check-base.cc b/gcc/rust/typecheck/rust-hir-type-check-base.cc index 2bcc778c6845..dc556b5741f2 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-base.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-base.cc @@ -386,7 +386,7 @@ TypeCheckBase::resolve_literal (const Analysis::NodeMapping &expr_mappings, auto ok = context->lookup_builtin ("u8", &u8); rust_assert (ok); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping capacity_mapping (crate_num, UNKNOWN_NODEID, mappings.get_next_hir_id ( crate_num), diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc index 0f02b3698dda..b1fc902e4096 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc @@ -1210,7 +1210,7 @@ TypeCheckExpr::visit (HIR::ArrayExpr &expr) expr.get_locus ()); } - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, UNKNOWN_NODEID, mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -1998,7 +1998,7 @@ TypeCheckExpr::visit (HIR::ClosureExpr &expr) // lets generate an implicit Type so that it resolves to the implict tuple // type we have created - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_mappings ().get_nodeid (), implicit_args_id, UNKNOWN_LOCAL_DEFID); HIR::TupleType *implicit_tuple @@ -2401,7 +2401,7 @@ TypeCheckExpr::resolve_fn_trait_call (HIR::CallExpr &expr, // crate implicit tuple HirId implicit_arg_id = mappings.get_next_hir_id (); - Analysis::NodeMapping mapping (mappings.crate_mapping.get_current_crate (), + Analysis::NodeMapping mapping (mappings.crate.get_current_crate (), UNKNOWN_NODEID, implicit_arg_id, UNKNOWN_LOCAL_DEFID); diff --git a/gcc/rust/typecheck/rust-hir-type-check-implitem.cc b/gcc/rust/typecheck/rust-hir-type-check-implitem.cc index 5886e57968d7..0b4a8f026f7b 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-implitem.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-implitem.cc @@ -108,7 +108,7 @@ TypeCheckTopLevelExternItem::visit (HIR::ExternalFunctionItem &function) auto param_tyty = TypeCheckType::Resolve (param.get_type ()); // these are implicit mappings and not used - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, mappings.get_next_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); @@ -273,7 +273,7 @@ TypeCheckImplItem::resolve_function_signature (HIR::Function &function) if (function.is_method ()) { // these are implicit mappings and not used - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, mappings.get_next_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.cc b/gcc/rust/typecheck/rust-hir-type-check-item.cc index 17067603719d..1f66d68acaff 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-item.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-item.cc @@ -1132,7 +1132,7 @@ TypeCheckItem::visit (HIR::ExternCrate &extern_crate) if (extern_crate.references_self ()) return; - auto &crate_mappings = Analysis::Mappings::get ().crate_mapping; + auto &crate_mappings = Analysis::Mappings::get ().crate; CrateNum num = crate_mappings.lookup_crate_name (extern_crate.get_referenced_crate ()) .value (); diff --git a/gcc/rust/typecheck/rust-hir-type-check-struct.cc b/gcc/rust/typecheck/rust-hir-type-check-struct.cc index 8c3d540c17c6..eb871c488b57 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-struct.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-struct.cc @@ -191,7 +191,7 @@ TypeCheckStructExpr::resolve (HIR::StructExprStructFields &struct_expr) HIR::StructExprField *implicit_field = nullptr; AST::AttrVec outer_attribs; - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, struct_expr.get_struct_base () .get_base () diff --git a/gcc/rust/typecheck/rust-hir-type-check.cc b/gcc/rust/typecheck/rust-hir-type-check.cc index 25048a38f11c..892dcb359f0c 100644 --- a/gcc/rust/typecheck/rust-hir-type-check.cc +++ b/gcc/rust/typecheck/rust-hir-type-check.cc @@ -206,7 +206,7 @@ TraitItemReference::get_type_from_fn (/*const*/ HIR::TraitItemFunc &fn) const { // these are implicit mappings and not used auto &mappings = Analysis::Mappings::get (); - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); Analysis::NodeMapping mapping (crate_num, mappings.get_next_node_id (), mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); diff --git a/gcc/rust/typecheck/rust-type-util.cc b/gcc/rust/typecheck/rust-type-util.cc index 85fafdea070a..5acbdfa78a80 100644 --- a/gcc/rust/typecheck/rust-type-util.cc +++ b/gcc/rust/typecheck/rust-type-util.cc @@ -77,7 +77,7 @@ query_type (HirId reference, TyTy::BaseType **result) DefId item_defid = item.value ()->get_mappings ().get_defid (); bool is_local - = item_defid.crateNum == mappings.crate_mapping.get_current_crate (); + = item_defid.crateNum == mappings.crate.get_current_crate (); bool is_fn = item.value ()->get_item_kind () == HIR::Item::ItemKind::Function; bool is_const_fn = false; @@ -166,7 +166,7 @@ query_type (HirId reference, TyTy::BaseType **result) DefId item_defid = impl_item->first->get_impl_mappings ().get_defid (); bool is_local - = item_defid.crateNum == mappings.crate_mapping.get_current_crate (); + = item_defid.crateNum == mappings.crate.get_current_crate (); bool is_fn = impl_item->first->get_impl_item_type () == HIR::ImplItem::FUNCTION; bool is_const_fn = false; diff --git a/gcc/rust/typecheck/rust-tyty-bounds.cc b/gcc/rust/typecheck/rust-tyty-bounds.cc index a00cb6b3d4a9..1f908cb6de29 100644 --- a/gcc/rust/typecheck/rust-tyty-bounds.cc +++ b/gcc/rust/typecheck/rust-tyty-bounds.cc @@ -316,7 +316,7 @@ TypeCheckBase::get_predicate_from_bound ( // we need to make implicit generic args which must be an implicit // Tuple - auto crate_num = mappings.crate_mapping.get_current_crate (); + auto crate_num = mappings.crate.get_current_crate (); HirId implicit_args_id = mappings.get_next_hir_id (); Analysis::NodeMapping mapping (crate_num, final_seg.get_mappings ().get_nodeid (), diff --git a/gcc/rust/typecheck/rust-tyty-subst.cc b/gcc/rust/typecheck/rust-tyty-subst.cc index 08b618e8cca8..f4bc1cf65647 100644 --- a/gcc/rust/typecheck/rust-tyty-subst.cc +++ b/gcc/rust/typecheck/rust-tyty-subst.cc @@ -239,9 +239,8 @@ SubstitutionParamMapping::override_context () auto context = Resolver::TypeCheckContext::get (); context->insert_type ( - Analysis::NodeMapping (mappings.crate_mapping.get_current_crate (), - UNKNOWN_NODEID, param->get_ref (), - UNKNOWN_LOCAL_DEFID), + Analysis::NodeMapping (mappings.crate.get_current_crate (), UNKNOWN_NODEID, + param->get_ref (), UNKNOWN_LOCAL_DEFID), param->resolve ()); } diff --git a/gcc/rust/typecheck/rust-tyty-util.cc b/gcc/rust/typecheck/rust-tyty-util.cc index d63f4549587e..f94bc3ec6bed 100644 --- a/gcc/rust/typecheck/rust-tyty-util.cc +++ b/gcc/rust/typecheck/rust-tyty-util.cc @@ -121,8 +121,8 @@ TyVar::monomorphized_clone () const // insert it context->insert_type ( - Analysis::NodeMapping (mappings.crate_mapping.get_current_crate (), - UNKNOWN_NODEID, c->get_ref (), UNKNOWN_LOCAL_DEFID), + Analysis::NodeMapping (mappings.crate.get_current_crate (), UNKNOWN_NODEID, + c->get_ref (), UNKNOWN_LOCAL_DEFID), c); return TyVar (c->get_ref ()); diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc index b3696afa1605..ab702dd82d7b 100644 --- a/gcc/rust/typecheck/rust-tyty.cc +++ b/gcc/rust/typecheck/rust-tyty.cc @@ -1372,9 +1372,8 @@ InferType::clone () const default_hint, get_ident ().locus, get_combined_refs ()); context->insert_type ( - Analysis::NodeMapping (mappings.crate_mapping.get_current_crate (), - UNKNOWN_NODEID, clone->get_ref (), - UNKNOWN_LOCAL_DEFID), + Analysis::NodeMapping (mappings.crate.get_current_crate (), UNKNOWN_NODEID, + clone->get_ref (), UNKNOWN_LOCAL_DEFID), clone); mappings.insert_location (clone->get_ref (), mappings.lookup_location (get_ref ())); @@ -4213,9 +4212,8 @@ ConstInferType::clone () const get_ty_ref (), get_combined_refs ()); context->insert_type ( - Analysis::NodeMapping (mappings.crate_mapping.get_current_crate (), - UNKNOWN_NODEID, clone->get_ref (), - UNKNOWN_LOCAL_DEFID), + Analysis::NodeMapping (mappings.crate.get_current_crate (), UNKNOWN_NODEID, + clone->get_ref (), UNKNOWN_LOCAL_DEFID), clone); mappings.insert_location (clone->get_ref (), mappings.lookup_location (get_ref ())); diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index 47ccc540af0a..c3eea4594597 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -257,7 +257,7 @@ CrateMappings::get_ast_crate (CrateNum crateNum) AST::Crate & Mappings::get_ast_crate_by_node_id (NodeId id) { - return *crate_mapping.get_ast_crate_by_node_id_raw (id); + return *crate.get_ast_crate_by_node_id_raw (id); } AST::Crate * @@ -816,8 +816,7 @@ Mappings::insert_macro_def (AST::MacroRulesDefinition *macro) auto it = macroMappings.find (macro->get_node_id ()); rust_assert (it == macroMappings.end ()); - macroMappings[macro->get_node_id ()] - = {macro, crate_mapping.get_current_crate ()}; + macroMappings[macro->get_node_id ()] = {macro, crate.get_current_crate ()}; } tl::optional @@ -1076,7 +1075,7 @@ Mappings::insert_glob_container (NodeId id, AST::GlobContainer *container) // Crates have different memory managements that regular items if (container->get_glob_container_kind () == AST::GlobContainer::Kind::Crate) - glob_containers[id] = crate_mapping.get_ast_crate_by_node_id_raw (id); + glob_containers[id] = crate.get_ast_crate_by_node_id_raw (id); else glob_containers[id] = container; } diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index 3b02d83ab637..d9db37b8400e 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -232,20 +232,20 @@ class Mappings static Mappings &get (); ~Mappings (); - CrateMappings crate_mapping; - ProcMacroMappings pmacro_mappings; + CrateMappings crate; + ProcMacroMappings pmacro; ASTMappings ast; HIRMappings hir; NodeId get_next_node_id (); HirId get_next_hir_id () { - return get_next_hir_id (crate_mapping.get_current_crate ()); + return get_next_hir_id (crate.get_current_crate ()); } HirId get_next_hir_id (CrateNum crateNum); LocalDefId get_next_localdef_id () { - return get_next_localdef_id (crate_mapping.get_current_crate ()); + return get_next_localdef_id (crate.get_current_crate ()); } LocalDefId get_next_localdef_id (CrateNum crateNum); From edaf02e731b3c03162246878a33c1c495703859c Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Wed, 23 Sep 2026 19:39:34 +0200 Subject: [PATCH 579/584] Make hir mapping name plurals When using those mappings, the singular name feels weird and may deceive a developper. gcc/rust/ChangeLog: * backend/rust-compile-item.cc (CompileItem::visit): Adapt call name. * backend/rust-compile-resolve-path.cc (HIRCompileBase::query_compile): Likewise. * backend/rust-mangle-v0.cc (v0_path): Likewise. * checks/errors/privacy/rust-visibility-resolver.cc (VisibilityResolver::resolve_module_path): Likewise. * checks/errors/rust-const-checker.cc (ConstChecker::check_function_call): Likewise. * checks/errors/rust-readonly-check.cc (ReadonlyChecker::visit): Likewise. * checks/errors/rust-unsafe-checker.cc (UnsafeChecker::check_use_of_static): Likewise. (UnsafeChecker::check_function_call): Likewise. (UnsafeChecker::check_function_attr): Likewise. * checks/lints/rust-lint-marklive.cc (MarkLive::go): Likewise. (MarkLive::visit): Likewise. * checks/lints/unused/rust-unused-checker.cc (UnusedChecker::visit): Likewise. * hir/rust-ast-lower-base.cc (ASTLoweringBase::lower_extern_block): Likewise. * hir/rust-ast-lower-block.h: Likewise. * hir/rust-ast-lower-expr.cc (ASTLoweringExpr::translate): Likewise. * hir/rust-ast-lower-implitem.cc (ASTLowerImplItem::visit): Likewise. (ASTLowerTraitItem::translate): Likewise. (ASTLowerTraitItem::visit): Likewise. * hir/rust-ast-lower-item.cc (ASTLoweringItem::translate): Likewise. (ASTLoweringItem::visit): Likewise. * hir/rust-ast-lower-pattern.cc (ASTLoweringPattern::translate): Likewise. * hir/rust-ast-lower-stmt.cc (ASTLoweringStmt::translate): Likewise. * hir/rust-ast-lower-struct-field-expr.h: Likewise. * hir/rust-ast-lower-type.cc (ASTLoweringType::translate): Likewise. (ASTLowerGenericParam::translate): Likewise. * hir/rust-ast-lower.cc (ASTLowerPathInExpression::visit): Likewise. (ASTLowerQualPathInExpression::visit): Likewise. * hir/tree/rust-hir-pattern-abstract.cc (PathPattern::is_refutable): Likewise. * typecheck/rust-hir-trait-resolve.cc (TraitResolver::resolve_path_to_trait): Likewise. * typecheck/rust-hir-type-check-path.cc (TypeCheckExpr::visit): Likewise. (TypeCheckExpr::resolve_root_path): Likewise. * typecheck/rust-hir-type-check-pattern.cc (TypeCheckPattern::visit): Likewise. * typecheck/rust-hir-type-check-type.cc (TypeCheckType::resolve_root_path): Likewise. * typecheck/rust-type-util.cc (query_type): Likewise. * util/rust-hir-map.cc (Mappings::resolve_nodeid_to_stmt): Likewise. (Mappings::build_impl_indexes): Likewise. (Mappings::insert_trait_item_mapping): Likewise. * util/rust-hir-map.h: Change HIR mapping name to their plural counterpart. Signed-off-by: Pierre-Emmanuel Patry --- gcc/rust/backend/rust-compile-item.cc | 2 +- gcc/rust/backend/rust-compile-resolve-path.cc | 4 +-- gcc/rust/backend/rust-mangle-v0.cc | 6 ++--- .../privacy/rust-visibility-resolver.cc | 2 +- gcc/rust/checks/errors/rust-const-checker.cc | 2 +- gcc/rust/checks/errors/rust-readonly-check.cc | 4 +-- gcc/rust/checks/errors/rust-unsafe-checker.cc | 8 +++--- gcc/rust/checks/lints/rust-lint-marklive.cc | 4 +-- .../lints/unused/rust-unused-checker.cc | 2 +- gcc/rust/hir/rust-ast-lower-base.cc | 2 +- gcc/rust/hir/rust-ast-lower-block.h | 10 +++---- gcc/rust/hir/rust-ast-lower-expr.cc | 2 +- gcc/rust/hir/rust-ast-lower-implitem.cc | 10 +++---- gcc/rust/hir/rust-ast-lower-item.cc | 6 ++--- gcc/rust/hir/rust-ast-lower-pattern.cc | 2 +- gcc/rust/hir/rust-ast-lower-stmt.cc | 2 +- .../hir/rust-ast-lower-struct-field-expr.h | 2 +- gcc/rust/hir/rust-ast-lower-type.cc | 4 +-- gcc/rust/hir/rust-ast-lower.cc | 4 +-- .../hir/tree/rust-hir-pattern-abstract.cc | 2 +- gcc/rust/typecheck/rust-hir-trait-resolve.cc | 2 +- .../typecheck/rust-hir-type-check-path.cc | 6 ++--- .../typecheck/rust-hir-type-check-pattern.cc | 2 +- .../typecheck/rust-hir-type-check-type.cc | 2 +- gcc/rust/typecheck/rust-type-util.cc | 4 +-- gcc/rust/util/rust-hir-map.cc | 6 ++--- gcc/rust/util/rust-hir-map.h | 26 +++++++++---------- 27 files changed, 64 insertions(+), 64 deletions(-) diff --git a/gcc/rust/backend/rust-compile-item.cc b/gcc/rust/backend/rust-compile-item.cc index 6937492cc238..2d23aa62cdd0 100644 --- a/gcc/rust/backend/rust-compile-item.cc +++ b/gcc/rust/backend/rust-compile-item.cc @@ -228,7 +228,7 @@ CompileItem::visit (HIR::Function &function) if (function.get_qualifiers ().is_const ()) ctx->push_const_context (); - auto lookup_root_item = ctx->get_mappings ().hir.item.lookup ( + auto lookup_root_item = ctx->get_mappings ().hir.items.lookup ( function.get_mappings ().get_hirid ()); bool is_root_item = lookup_root_item.has_value (); tree fndecl diff --git a/gcc/rust/backend/rust-compile-resolve-path.cc b/gcc/rust/backend/rust-compile-resolve-path.cc index 9aa78fd4b1a0..332781e3b188 100644 --- a/gcc/rust/backend/rust-compile-resolve-path.cc +++ b/gcc/rust/backend/rust-compile-resolve-path.cc @@ -259,7 +259,7 @@ HIRCompileBase::query_compile (HirId ref, TyTy::BaseType *lookup, location_t expr_locus, bool is_qualified_path) { bool is_fn = lookup->get_kind () == TyTy::TypeKind::FNDEF; - if (auto resolved_item = ctx->get_mappings ().hir.item.lookup (ref)) + if (auto resolved_item = ctx->get_mappings ().hir.items.lookup (ref)) { if (!lookup->has_substitutions_defined ()) return CompileItem::compile (*resolved_item, ctx, nullptr, expr_locus); @@ -303,7 +303,7 @@ HIRCompileBase::query_compile (HirId ref, TyTy::BaseType *lookup, lookup, expr_locus); } else if (auto trait_item - = ctx->get_mappings ().hir.trait_item.lookup (ref)) + = ctx->get_mappings ().hir.trait_items.lookup (ref)) { HIR::Trait *trait = ctx->get_mappings ().lookup_trait_item_mapping ( trait_item.value ()->get_mappings ().get_hirid ()); diff --git a/gcc/rust/backend/rust-mangle-v0.cc b/gcc/rust/backend/rust-mangle-v0.cc index b2a24f385fd3..d3d8e684f76c 100644 --- a/gcc/rust/backend/rust-mangle-v0.cc +++ b/gcc/rust/backend/rust-mangle-v0.cc @@ -406,7 +406,7 @@ v0_path (Rust::Compile::Context *ctx, const TyTy::BaseType *ty, break; } } - else if (auto trait_item = mappings.hir.trait_item.lookup (hir_id)) + else if (auto trait_item = mappings.hir.trait_items.lookup (hir_id)) { switch (trait_item.value ()->get_item_kind ()) { @@ -428,7 +428,7 @@ v0_path (Rust::Compile::Context *ctx, const TyTy::BaseType *ty, break; } } - else if (auto item = mappings.hir.item.lookup (hir_id)) + else if (auto item = mappings.hir.items.lookup (hir_id)) switch (item.value ()->get_item_kind ()) { case HIR::Item::ItemKind::Function: @@ -468,7 +468,7 @@ v0_path (Rust::Compile::Context *ctx, const TyTy::BaseType *ty, cpath.get ().c_str ()); break; } - else if (auto expr = mappings.hir.expr.lookup (hir_id)) + else if (auto expr = mappings.hir.exprs.lookup (hir_id)) { rust_assert (expr.value ()->get_expression_type () == HIR::Expr::ExprType::Closure); diff --git a/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc b/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc index 5e65619fe747..d91a2c7d9662 100644 --- a/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc +++ b/gcc/rust/checks/errors/privacy/rust-visibility-resolver.cc @@ -93,7 +93,7 @@ VisibilityResolver::resolve_module_path (const HIR::SimplePath &restriction, // these items as private? return true; - if (auto module = mappings.hir.module.lookup (ref)) + if (auto module = mappings.hir.modules.lookup (ref)) { // Fill in the resolved `DefId` id = module.value ()->get_mappings ().get_defid (); diff --git a/gcc/rust/checks/errors/rust-const-checker.cc b/gcc/rust/checks/errors/rust-const-checker.cc index 913505f066fb..1147c4d5568c 100644 --- a/gcc/rust/checks/errors/rust-const-checker.cc +++ b/gcc/rust/checks/errors/rust-const-checker.cc @@ -309,7 +309,7 @@ ConstChecker::check_function_call (HirId fn_id, location_t locus) if (!const_context.is_in_context ()) return; - auto maybe_fn = mappings.hir.item.lookup (fn_id); + auto maybe_fn = mappings.hir.items.lookup (fn_id); if (maybe_fn && maybe_fn.value ()->get_item_kind () != Item::ItemKind::Function) return; diff --git a/gcc/rust/checks/errors/rust-readonly-check.cc b/gcc/rust/checks/errors/rust-readonly-check.cc index 8bd3c4e4e7f3..3b608dcf51bb 100644 --- a/gcc/rust/checks/errors/rust-readonly-check.cc +++ b/gcc/rust/checks/errors/rust-readonly-check.cc @@ -75,7 +75,7 @@ ReadonlyChecker::visit (PathInExpression &expr) return; // Check if the local variable is mutable. - auto maybe_pattern = mappings.hir.pattern.lookup (*hir_id); + auto maybe_pattern = mappings.hir.patterns.lookup (*hir_id); if (maybe_pattern && maybe_pattern.value ()->get_pattern_type () == HIR::Pattern::PatternType::IDENTIFIER) @@ -83,7 +83,7 @@ ReadonlyChecker::visit (PathInExpression &expr) expr.get_locus ()); // Check if the static item is mutable. - auto maybe_item = mappings.hir.item.lookup (*hir_id); + auto maybe_item = mappings.hir.items.lookup (*hir_id); if (maybe_item && maybe_item.value ()->get_item_kind () == HIR::Item::ItemKind::Static) { diff --git a/gcc/rust/checks/errors/rust-unsafe-checker.cc b/gcc/rust/checks/errors/rust-unsafe-checker.cc index 22ff986f18f5..d7b24765bd6d 100644 --- a/gcc/rust/checks/errors/rust-unsafe-checker.cc +++ b/gcc/rust/checks/errors/rust-unsafe-checker.cc @@ -92,7 +92,7 @@ UnsafeChecker::check_use_of_static (HirId node_id, location_t locus) bool in_context = unsafe_context.is_in_context (); bool unsafe_op = false; - if (auto maybe_static_mut = mappings.hir.item.lookup (node_id)) + if (auto maybe_static_mut = mappings.hir.items.lookup (node_id)) unsafe_op |= check_static_mut (*maybe_static_mut, locus, in_context); if (auto maybe_extern_static = mappings.lookup_hir_extern_item (node_id)) @@ -198,7 +198,7 @@ UnsafeChecker::check_function_call (HirId node_id, location_t locus) bool in_context = unsafe_context.is_in_context (); bool unsafe_op = false; - auto maybe_fn = mappings.hir.item.lookup (node_id); + auto maybe_fn = mappings.hir.items.lookup (node_id); if (maybe_fn && maybe_fn.value ()->get_item_kind () == Item::ItemKind::Function) @@ -208,7 +208,7 @@ UnsafeChecker::check_function_call (HirId node_id, location_t locus) if (auto maybe_extern = mappings.lookup_hir_extern_item (node_id)) unsafe_op |= check_extern_call (static_cast (maybe_extern->first), - *mappings.hir.extern_block.lookup ( + *mappings.hir.extern_blocks.lookup ( maybe_extern->second), locus, in_context); @@ -240,7 +240,7 @@ UnsafeChecker::check_function_attr (HirId node_id, location_t locus) { bool in_context = unsafe_context.is_in_context (); - auto maybe_fn = mappings.hir.item.lookup (node_id); + auto maybe_fn = mappings.hir.items.lookup (node_id); if (maybe_fn && maybe_fn.value ()->get_item_kind () == Item::ItemKind::Function diff --git a/gcc/rust/checks/lints/rust-lint-marklive.cc b/gcc/rust/checks/lints/rust-lint-marklive.cc index 0685c442beeb..18e206d721e0 100644 --- a/gcc/rust/checks/lints/rust-lint-marklive.cc +++ b/gcc/rust/checks/lints/rust-lint-marklive.cc @@ -91,7 +91,7 @@ MarkLive::go (HIR::Crate &) worklist.pop_back (); scannedSymbols.emplace (hirId); liveSymbols.emplace (hirId); - if (auto item = mappings.hir.item.lookup (hirId)) + if (auto item = mappings.hir.items.lookup (hirId)) item.value ()->accept_vis (*this); else if (auto implItem = mappings.lookup_hir_implitem (hirId)) implItem->first->accept_vis (*this); @@ -125,7 +125,7 @@ MarkLive::visit (HIR::PathInExpression &expr) auto ref = hid.value (); // it must resolve to some kind of HIR::Item or HIR::InheritImplItem - if (auto resolved_item = mappings.hir.item.lookup (ref)) + if (auto resolved_item = mappings.hir.items.lookup (ref)) mark_hir_id (resolved_item.value ()->get_mappings ().get_hirid ()); else if (auto resolved_item = mappings.lookup_hir_implitem (ref)) mark_hir_id (resolved_item->first->get_impl_mappings ().get_hirid ()); diff --git a/gcc/rust/checks/lints/unused/rust-unused-checker.cc b/gcc/rust/checks/lints/unused/rust-unused-checker.cc index 414af54103d9..fa8602acab8b 100644 --- a/gcc/rust/checks/lints/unused/rust-unused-checker.cc +++ b/gcc/rust/checks/lints/unused/rust-unused-checker.cc @@ -358,7 +358,7 @@ UnusedChecker::visit (HIR::BorrowExpr &expr) if (auto def = nr_context.lookup (ast_node_id, Resolver2_0::Namespace::Values)) if (auto id = mappings.lookup_node_to_hir (*def)) - if (auto item = mappings.hir.item.lookup (*id)) + if (auto item = mappings.hir.items.lookup (*id)) if (item.value ()->get_item_kind () == HIR::Item::ItemKind::Static) { auto &static_item = static_cast (*item.value ()); diff --git a/gcc/rust/hir/rust-ast-lower-base.cc b/gcc/rust/hir/rust-ast-lower-base.cc index ffe9f91fd7f5..e69b717d06b7 100644 --- a/gcc/rust/hir/rust-ast-lower-base.cc +++ b/gcc/rust/hir/rust-ast-lower-base.cc @@ -1077,7 +1077,7 @@ ASTLoweringBase::lower_extern_block (AST::ExternBlock &extern_block) extern_block.get_outer_attrs (), extern_block.get_locus ()); - mappings.hir.extern_block.insert (hir_extern_block); + mappings.hir.extern_blocks.insert (hir_extern_block); return hir_extern_block; } diff --git a/gcc/rust/hir/rust-ast-lower-block.h b/gcc/rust/hir/rust-ast-lower-block.h index eadaebd7edde..d582a68fbe02 100644 --- a/gcc/rust/hir/rust-ast-lower-block.h +++ b/gcc/rust/hir/rust-ast-lower-block.h @@ -37,7 +37,7 @@ class ASTLoweringBlock : public ASTLoweringBase expr.accept_vis (resolver); if (resolver.translated != nullptr) { - resolver.mappings.hir.expr.insert (resolver.translated); + resolver.mappings.hir.exprs.insert (resolver.translated); } *terminated = resolver.terminated; @@ -62,7 +62,7 @@ class ASTLoweringBlock : public ASTLoweringBase std::unique_ptr (block), expr.get_outer_attrs (), expr.get_locus ()); - resolver.mappings.hir.expr.insert (translated); + resolver.mappings.hir.exprs.insert (translated); return translated; } @@ -89,7 +89,7 @@ class ASTLoweringIfBlock : public ASTLoweringBase expr.accept_vis (resolver); if (resolver.translated != nullptr) { - resolver.mappings.hir.expr.insert (resolver.translated); + resolver.mappings.hir.exprs.insert (resolver.translated); } *terminated = resolver.terminated; return resolver.translated; @@ -121,7 +121,7 @@ class ASTLoweringIfLetBlock : public ASTLoweringBase expr.accept_vis (resolver); if (resolver.translated != nullptr) { - resolver.mappings.hir.expr.insert (resolver.translated); + resolver.mappings.hir.exprs.insert (resolver.translated); } return resolver.translated; } @@ -152,7 +152,7 @@ class ASTLoweringExprWithBlock : public ASTLoweringBase ASTLoweringExprWithBlock resolver; expr.accept_vis (resolver); if (resolver.translated != nullptr) - resolver.mappings.hir.expr.insert (resolver.translated); + resolver.mappings.hir.exprs.insert (resolver.translated); *terminated = resolver.terminated; return resolver.translated; diff --git a/gcc/rust/hir/rust-ast-lower-expr.cc b/gcc/rust/hir/rust-ast-lower-expr.cc index 5aefbfaa308d..cebc2bff9d6d 100644 --- a/gcc/rust/hir/rust-ast-lower-expr.cc +++ b/gcc/rust/hir/rust-ast-lower-expr.cc @@ -50,7 +50,7 @@ ASTLoweringExpr::translate (AST::Expr &expr, bool *terminated) return nullptr; } - resolver.mappings.hir.expr.insert (resolver.translated); + resolver.mappings.hir.exprs.insert (resolver.translated); resolver.mappings.insert_location ( resolver.translated->get_mappings ().get_hirid (), expr.get_locus ()); diff --git a/gcc/rust/hir/rust-ast-lower-implitem.cc b/gcc/rust/hir/rust-ast-lower-implitem.cc index 736c4619b7ed..fdad7e4f6633 100644 --- a/gcc/rust/hir/rust-ast-lower-implitem.cc +++ b/gcc/rust/hir/rust-ast-lower-implitem.cc @@ -192,7 +192,7 @@ ASTLowerImplItem::visit (AST::Function &function) if (fn->is_method ()) { // insert mappings for self - mappings.hir.self_param.insert (&fn->get_self_param_unchecked ()); + mappings.hir.self_params.insert (&fn->get_self_param_unchecked ()); mappings.insert_location ( fn->get_self_param_unchecked ().get_mappings ().get_hirid (), fn->get_self_param_unchecked ().get_locus ()); @@ -201,7 +201,7 @@ ASTLowerImplItem::visit (AST::Function &function) // add the mappings for the function params at the end for (auto ¶m : fn->get_function_params ()) { - mappings.hir.function_param.insert (¶m); + mappings.hir.function_params.insert (¶m); mappings.insert_location (mapping.get_hirid (), param.get_locus ()); } @@ -222,7 +222,7 @@ ASTLowerTraitItem::translate (AST::AssociatedItem &item) auto locus = resolver.translated->get_trait_locus (); resolver.handle_outer_attributes (*resolver.translated); - resolver.mappings.hir.trait_item.insert (resolver.translated); + resolver.mappings.hir.trait_items.insert (resolver.translated); resolver.mappings.insert_location (id, locus); resolver.mappings.insert_defid_mapping (defid, resolver.translated); } @@ -285,7 +285,7 @@ ASTLowerTraitItem::visit (AST::Function &func) { // insert mappings for self // TODO: Is this correct ? Looks fishy - mappings.hir.self_param.insert (&*self_param); + mappings.hir.self_params.insert (&*self_param); mappings.insert_location (self_param->get_mappings ().get_hirid (), self_param->get_locus ()); } @@ -317,7 +317,7 @@ ASTLowerTraitItem::visit (AST::Function &func) // add the mappings for the function params at the end for (auto ¶m : trait_item->get_decl ().get_function_params ()) { - mappings.hir.function_param.insert (¶m); + mappings.hir.function_params.insert (¶m); mappings.insert_location (mapping.get_hirid (), param.get_locus ()); } } diff --git a/gcc/rust/hir/rust-ast-lower-item.cc b/gcc/rust/hir/rust-ast-lower-item.cc index 03ac6ac9bb9d..7e2f357bef10 100644 --- a/gcc/rust/hir/rust-ast-lower-item.cc +++ b/gcc/rust/hir/rust-ast-lower-item.cc @@ -45,7 +45,7 @@ ASTLoweringItem::translate (AST::Item &item) resolver.handle_outer_attributes (*resolver.translated); resolver.mappings.insert_ast_item (&item); - resolver.mappings.hir.item.insert (resolver.translated); + resolver.mappings.hir.items.insert (resolver.translated); resolver.mappings.insert_location (id, locus); resolver.mappings.insert_defid_mapping (defid, resolver.translated); } @@ -83,7 +83,7 @@ ASTLoweringItem::visit (AST::Module &module) = new HIR::Module (mapping, module.get_name (), module.get_locus (), std::move (items), std::move (vis), std::move (inner_attrs), std::move (outer_attrs)); - mappings.hir.module.insert (static_cast (translated)); + mappings.hir.modules.insert (static_cast (translated)); } void @@ -507,7 +507,7 @@ ASTLoweringItem::visit (AST::Function &function) // add the mappings for the function params at the end for (auto ¶m : fn->get_function_params ()) { - mappings.hir.function_param.insert (¶m); + mappings.hir.function_params.insert (¶m); mappings.insert_location (mapping.get_hirid (), param.get_locus ()); } diff --git a/gcc/rust/hir/rust-ast-lower-pattern.cc b/gcc/rust/hir/rust-ast-lower-pattern.cc index 6ab109560c1a..d45ad47e80e4 100644 --- a/gcc/rust/hir/rust-ast-lower-pattern.cc +++ b/gcc/rust/hir/rust-ast-lower-pattern.cc @@ -36,7 +36,7 @@ ASTLoweringPattern::translate (AST::Pattern &pattern, bool is_let_top_level) rust_assert (resolver.translated != nullptr); - resolver.mappings.hir.pattern.insert (resolver.translated); + resolver.mappings.hir.patterns.insert (resolver.translated); resolver.mappings.insert_location ( resolver.translated->get_mappings ().get_hirid (), pattern.get_locus ()); diff --git a/gcc/rust/hir/rust-ast-lower-stmt.cc b/gcc/rust/hir/rust-ast-lower-stmt.cc index 5281659a6442..43810ca66070 100644 --- a/gcc/rust/hir/rust-ast-lower-stmt.cc +++ b/gcc/rust/hir/rust-ast-lower-stmt.cc @@ -39,7 +39,7 @@ ASTLoweringStmt::translate (AST::Stmt *stmt, bool *terminated) resolver.mappings.insert_location ( resolver.translated->get_mappings ().get_hirid (), resolver.translated->get_locus ()); - resolver.mappings.hir.stmt.insert (resolver.translated); + resolver.mappings.hir.stmts.insert (resolver.translated); return resolver.translated; } diff --git a/gcc/rust/hir/rust-ast-lower-struct-field-expr.h b/gcc/rust/hir/rust-ast-lower-struct-field-expr.h index 225e5843bf36..7f0b9bd6062d 100644 --- a/gcc/rust/hir/rust-ast-lower-struct-field-expr.h +++ b/gcc/rust/hir/rust-ast-lower-struct-field-expr.h @@ -36,7 +36,7 @@ class ASTLowerStructExprField : public ASTLoweringBase field.accept_vis (compiler); rust_assert (compiler.translated != nullptr); - compiler.mappings.hir.struct_expr_field.insert (compiler.translated); + compiler.mappings.hir.struct_expr_fields.insert (compiler.translated); compiler.mappings.insert_location ( compiler.translated->get_mappings ().get_hirid (), field.get_locus ()); diff --git a/gcc/rust/hir/rust-ast-lower-type.cc b/gcc/rust/hir/rust-ast-lower-type.cc index 10e77e3a6a23..a41d49706c33 100644 --- a/gcc/rust/hir/rust-ast-lower-type.cc +++ b/gcc/rust/hir/rust-ast-lower-type.cc @@ -223,7 +223,7 @@ ASTLoweringType::translate (AST::Type &type, bool default_to_static_lifetime, type.accept_vis (resolver); rust_assert (resolver.translated != nullptr); - resolver.mappings.hir.type.insert (resolver.translated); + resolver.mappings.hir.types.insert (resolver.translated); resolver.mappings.insert_location ( resolver.translated->get_mappings ().get_hirid (), resolver.translated->get_locus ()); @@ -549,7 +549,7 @@ ASTLowerGenericParam::translate (AST::GenericParam ¶m) rust_assert (resolver.translated != nullptr); resolver.mappings.insert_location ( resolver.translated->get_mappings ().get_hirid (), param.get_locus ()); - resolver.mappings.hir.generic_param.insert (resolver.translated); + resolver.mappings.hir.generic_params.insert (resolver.translated); return resolver.translated; } diff --git a/gcc/rust/hir/rust-ast-lower.cc b/gcc/rust/hir/rust-ast-lower.cc index 154468a72b5c..7167a0afb18b 100644 --- a/gcc/rust/hir/rust-ast-lower.cc +++ b/gcc/rust/hir/rust-ast-lower.cc @@ -487,7 +487,7 @@ ASTLowerPathInExpression::visit (AST::PathInExpression &expr) // insert the mappings for the segment HIR::PathExprSegment *lowered_seg = &path_segments.back (); - mappings.hir.path_expr_segment.insert (lowered_seg); + mappings.hir.path_expr_segments.insert (lowered_seg); } translated = new HIR::PathInExpression (mapping, std::move (path_segments), @@ -531,7 +531,7 @@ ASTLowerQualPathInExpression::visit (AST::QualifiedPathInExpression &expr) // insert the mappings for the segment HIR::PathExprSegment *lowered_seg = &path_segments.back (); - mappings.hir.path_expr_segment.insert (lowered_seg); + mappings.hir.path_expr_segments.insert (lowered_seg); } auto crate_num = mappings.crate.get_current_crate (); diff --git a/gcc/rust/hir/tree/rust-hir-pattern-abstract.cc b/gcc/rust/hir/tree/rust-hir-pattern-abstract.cc index 6a1031457a3e..146208c4751a 100644 --- a/gcc/rust/hir/tree/rust-hir-pattern-abstract.cc +++ b/gcc/rust/hir/tree/rust-hir-pattern-abstract.cc @@ -58,7 +58,7 @@ PathPattern::is_refutable (const TyTy::BaseType &scrutinee) const HirId hir_id = get_final_segment ().get_mappings ().get_hirid (); if (hir_id) { - auto item = mappings.hir.item.lookup (hir_id); + auto item = mappings.hir.items.lookup (hir_id); if (item && item.value ()->get_item_kind () == Item::ItemKind::Constant) { return true; diff --git a/gcc/rust/typecheck/rust-hir-trait-resolve.cc b/gcc/rust/typecheck/rust-hir-trait-resolve.cc index 5ae31122ad42..4393333d15fd 100644 --- a/gcc/rust/typecheck/rust-hir-trait-resolve.cc +++ b/gcc/rust/typecheck/rust-hir-trait-resolve.cc @@ -227,7 +227,7 @@ TraitResolver::resolve_path_to_trait (const HIR::TypePath &path, return false; } - auto resolved_item = mappings.hir.item.lookup (hid.value ()); + auto resolved_item = mappings.hir.items.lookup (hid.value ()); if (!resolved_item.has_value ()) { rust_error_at (path.get_locus (), diff --git a/gcc/rust/typecheck/rust-hir-type-check-path.cc b/gcc/rust/typecheck/rust-hir-type-check-path.cc index 665ec0054ce9..4bb325b781f2 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-path.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-path.cc @@ -208,7 +208,7 @@ TypeCheckExpr::visit (HIR::PathInExpression &expr) else { TyTy::BaseType *resolved = nullptr; - auto trait_item = mappings.hir.trait_item.lookup (*hir_id); + auto trait_item = mappings.hir.trait_items.lookup (*hir_id); if (trait_item.has_value ()) { HIR::Trait *trait = mappings.lookup_trait_item_mapping (*hir_id); @@ -308,9 +308,9 @@ TypeCheckExpr::resolve_root_path (HIR::PathInExpression &expr, size_t *offset, } auto ref = hid.value (); - auto seg_is_module = mappings.hir.module.lookup (ref).has_value (); + auto seg_is_module = mappings.hir.modules.lookup (ref).has_value (); auto seg_is_crate = mappings.is_local_hirid_crate (ref); - auto seg_is_pattern = mappings.hir.pattern.lookup (ref).has_value (); + auto seg_is_pattern = mappings.hir.patterns.lookup (ref).has_value (); auto seg_is_self = is_root && !have_more_segments && seg.get_segment ().to_string () == "self"; if (seg_is_module || seg_is_crate) diff --git a/gcc/rust/typecheck/rust-hir-type-check-pattern.cc b/gcc/rust/typecheck/rust-hir-type-check-pattern.cc index 287a903e12f1..26f3c0c68c35 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-pattern.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-pattern.cc @@ -74,7 +74,7 @@ TypeCheckPattern::visit (HIR::PathInExpression &pattern) rust_assert (definition_id.has_value ()); HirId def_id = definition_id.value (); - tl::optional hir_item = mappings.hir.item.lookup (def_id); + tl::optional hir_item = mappings.hir.items.lookup (def_id); // If the path references an item, it must be constants or structs. if (hir_item.has_value ()) { diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.cc b/gcc/rust/typecheck/rust-hir-type-check-type.cc index 0d4b735c9fec..7b8176508de7 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-type.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-type.cc @@ -387,7 +387,7 @@ TypeCheckType::resolve_root_path (HIR::TypePath &path, size_t *offset, } auto ref = hid.value (); - auto seg_is_module = mappings.hir.module.lookup (ref).has_value (); + auto seg_is_module = mappings.hir.modules.lookup (ref).has_value (); auto seg_is_crate = mappings.is_local_hirid_crate (ref); if (seg_is_module || seg_is_crate) { diff --git a/gcc/rust/typecheck/rust-type-util.cc b/gcc/rust/typecheck/rust-type-util.cc index 5acbdfa78a80..bdfab3a0c4f0 100644 --- a/gcc/rust/typecheck/rust-type-util.cc +++ b/gcc/rust/typecheck/rust-type-util.cc @@ -70,7 +70,7 @@ query_type (HirId reference, TyTy::BaseType **result) return true; } - if (auto item = mappings.hir.item.lookup (reference)) + if (auto item = mappings.hir.items.lookup (reference)) { rust_debug_loc (item.value ()->get_locus (), "resolved item {%u} to", reference); @@ -233,7 +233,7 @@ query_type (HirId reference, TyTy::BaseType **result) // is it an extern item? if (auto extern_item = mappings.lookup_hir_extern_item (reference)) { - auto block = mappings.hir.extern_block.lookup (extern_item->second); + auto block = mappings.hir.extern_blocks.lookup (extern_item->second); rust_assert (block.has_value ()); *result diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index c3eea4594597..2b4ee2731298 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -570,7 +570,7 @@ Mappings::resolve_nodeid_to_stmt (NodeId id) return tl::nullopt; HirId resolved = it->second; - return hir.stmt.lookup (resolved); + return hir.stmts.lookup (resolved); } void @@ -616,7 +616,7 @@ Mappings::build_impl_indexes () if (!hir_id.has_value ()) return nullptr; - auto item = hir.item.lookup (hir_id.value ()); + auto item = hir.items.lookup (hir_id.value ()); return item.has_value () ? item.value () : nullptr; }; @@ -711,7 +711,7 @@ Mappings::insert_trait_item_mapping (HirId trait_item_id, HIR::Trait *trait) == hirTraitItemsToTraitMappings.end ()); hirTraitItemsToTraitMappings[trait_item_id] = trait; - auto item = hir.trait_item.lookup (trait_item_id); + auto item = hir.trait_items.lookup (trait_item_id); rust_assert (item.has_value ()); if (item.value ()->get_item_kind () != HIR::TraitItem::TraitItemKind::FUNC) return; diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index d9db37b8400e..638b16155f24 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -205,25 +205,25 @@ class ASTMappings class HIRMappings { public: - PtrMapping item; - PtrMapping trait_item; - PtrMapping extern_block; - PtrMapping module; + PtrMapping items; + PtrMapping trait_items; + PtrMapping extern_blocks; + PtrMapping modules; PtrMapping - expr; + exprs; PtrMapping - path_expr_segment; + path_expr_segments; PtrMapping - generic_param; - PtrMapping type; - PtrMapping stmt; + generic_params; + PtrMapping types; + PtrMapping stmts; PtrMapping - function_param; - PtrMapping self_param; - PtrMapping struct_expr_field; - PtrMapping pattern; + function_params; + PtrMapping self_params; + PtrMapping struct_expr_fields; + PtrMapping patterns; }; class Mappings From 5905083a306224637f4a286e5e4e54ec44bcd2c2 Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Thu, 24 Sep 2026 02:24:00 +0200 Subject: [PATCH 580/584] Move proc macro crate mapping to crate mappings Some mapping getters were using the crate num for their key, just like any other mapping within the CrateMappings. Move them over there for consistency. Also modifies the crate mapping name to make use of the Mapping class instead of relying on separate insert/lookup function implementation. gcc/rust/ChangeLog: * checks/errors/borrowck/rust-borrow-checker.cc (BorrowChecker::go): Update function call name. * expand/rust-macro-substitute-ctx.cc: Likewise. * resolve/rust-default-resolver.cc (DefaultResolver::visit): Likewise. * resolve/rust-toplevel-name-resolver-2.0.cc (TopLevel::visit_extern_crate): Likewise. * rust-session-manager.cc (Session::load_extern_crate): Likewise. * util/rust-hir-map.cc (CrateMappings::get_next_crate_num): Likewise. (CrateMappings::get_crate_name): Remove. (CrateMappings::set_crate_name): Remove. (CrateMappings::get_current_crate_name): Update with new lookup function. (CrateMappings::lookup_crate_name): Use internal storage getter. (ProcMacroMappings::insert_bang_proc_macros): Remove. (ProcMacroMappings::lookup_derive_proc_macros): Remove. (ProcMacroMappings::lookup_bang_proc_macros): Remove. (ProcMacroMappings::lookup_attribute_proc_macros): Remove. * util/rust-hir-map.h (enum class): Move enum. (class Mapping): Add a getter to const storage in order to allow iteration on existing mappings. Also add a const getter. (class CrateMappings): Add proc macro crate mappings. Convert crate_name getter/setter to Mapping. (class ProcMacroMappings): Remove crate related mappings. Signed-off-by: Pierre-Emmanuel Patry --- .../errors/borrowck/rust-borrow-checker.cc | 2 +- gcc/rust/expand/rust-macro-substitute-ctx.cc | 2 +- gcc/rust/resolve/rust-default-resolver.cc | 2 +- .../rust-toplevel-name-resolver-2.0.cc | 6 +- gcc/rust/rust-session-manager.cc | 6 +- gcc/rust/util/rust-hir-map.cc | 82 +------------- gcc/rust/util/rust-hir-map.h | 103 ++++++++++-------- 7 files changed, 71 insertions(+), 132 deletions(-) diff --git a/gcc/rust/checks/errors/borrowck/rust-borrow-checker.cc b/gcc/rust/checks/errors/borrowck/rust-borrow-checker.cc index 16b8f76a8a1c..d04699fc244d 100644 --- a/gcc/rust/checks/errors/borrowck/rust-borrow-checker.cc +++ b/gcc/rust/checks/errors/borrowck/rust-borrow-checker.cc @@ -55,7 +55,7 @@ BorrowChecker::go (HIR::Crate &crate) { mkdir ("bir_dump", 0755); auto &mappings = Analysis::Mappings::get (); - crate_name = *mappings.crate.get_crate_name ( + crate_name = *mappings.crate.crate_names.lookup ( crate.get_mappings ().get_crate_num ()); mkdir ("nll_facts_gccrs", 0755); } diff --git a/gcc/rust/expand/rust-macro-substitute-ctx.cc b/gcc/rust/expand/rust-macro-substitute-ctx.cc index 5fa21e64f231..b199860413c5 100644 --- a/gcc/rust/expand/rust-macro-substitute-ctx.cc +++ b/gcc/rust/expand/rust-macro-substitute-ctx.cc @@ -44,7 +44,7 @@ SubstituteCtx::substitute_dollar_crate ( } else { - auto name = mappings.crate.get_crate_name (*def_crate); + auto name = mappings.crate.crate_names.lookup (*def_crate); rust_assert (name); diff --git a/gcc/rust/resolve/rust-default-resolver.cc b/gcc/rust/resolve/rust-default-resolver.cc index 585df8979f6c..cbfd84ac2eb7 100644 --- a/gcc/rust/resolve/rust-default-resolver.cc +++ b/gcc/rust/resolve/rust-default-resolver.cc @@ -45,7 +45,7 @@ DefaultResolver::visit (AST::Crate &crate) auto crate_num = crate_mappings.lookup_crate_num (crate.get_node_id ()); rust_assert (crate_num.has_value ()); - auto crate_name = crate_mappings.get_crate_name (*crate_num); + auto crate_name = crate_mappings.crate_names.lookup (*crate_num); rust_assert (crate_name.has_value ()); ctx.canonical_ctx.scope_crate (crate.get_node_id (), *crate_name, inner_fn); diff --git a/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc b/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc index 0e4172239435..d92e5e2a4b48 100644 --- a/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc +++ b/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc @@ -187,11 +187,11 @@ TopLevel::visit_extern_crate (AST::ExternCrate &extern_crate, AST::Crate &crate, { auto &mappings = Analysis::Mappings::get (); - auto attribute_macros = mappings.pmacro.lookup_attribute_proc_macros (num); + auto attribute_macros = mappings.crate.attributes.lookup (num); - auto bang_macros = mappings.pmacro.lookup_bang_proc_macros (num); + auto bang_macros = mappings.crate.bangs.lookup (num); - auto derive_macros = mappings.pmacro.lookup_derive_proc_macros (num); + auto derive_macros = mappings.crate.derives.lookup (num); // TODO: Find a way to keep this part clean without the double dispatch. if (derive_macros.has_value ()) diff --git a/gcc/rust/rust-session-manager.cc b/gcc/rust/rust-session-manager.cc index e12147700ce9..8d7dde39b90f 100644 --- a/gcc/rust/rust-session-manager.cc +++ b/gcc/rust/rust-session-manager.cc @@ -1364,9 +1364,9 @@ Session::load_extern_crate (const std::string &crate_name, location_t locus) } } - mappings.pmacro.insert_attribute_proc_macros (crate_num, attribute_macros); - mappings.pmacro.insert_bang_proc_macros (crate_num, bang_macros); - mappings.pmacro.insert_derive_proc_macros (crate_num, derive_macros); + mappings.crate.attributes.insert (crate_num, attribute_macros); + mappings.crate.bangs.insert (crate_num, bang_macros); + mappings.crate.derives.insert (crate_num, derive_macros); // always restore the crate_num crate_mapping.set_current_crate (saved_crate_num); diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index 2b4ee2731298..59c8bed8ff07 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -128,7 +128,7 @@ CrateMappings::get_next_crate_num (const std::string &name) { auto id = crateNumItr; crateNumItr++; - set_crate_name (id, name); + crate_names.insert (id, name); return id; } @@ -144,16 +144,6 @@ CrateMappings::get_current_crate () const return currentCrateNum; } -tl::optional -CrateMappings::get_crate_name (CrateNum crate_num) const -{ - auto it = crate_names.find (crate_num); - if (it == crate_names.end ()) - return tl::nullopt; - - return it->second; -} - tl::optional CrateMappings::lookup_crate_num (NodeId node_id) const { @@ -164,22 +154,16 @@ CrateMappings::lookup_crate_num (NodeId node_id) const return it->second; } -void -CrateMappings::set_crate_name (CrateNum crate_num, const std::string &name) -{ - crate_names[crate_num] = name; -} - const std::string & CrateMappings::get_current_crate_name () const { - return get_crate_name (get_current_crate ()).value (); + return crate_names.lookup (get_current_crate ()).value (); } tl::optional CrateMappings::lookup_crate_name (const std::string &crate_name) const { - for (const auto &it : crate_names) + for (const auto &it : crate_names.get_storage ()) { if (it.second.compare (crate_name) == 0) return it.first; @@ -871,66 +855,6 @@ Mappings::get_exported_macros () return exportedMacros; } -void -ProcMacroMappings::insert_derive_proc_macros ( - CrateNum num, std::vector macros) -{ - auto it = deriveMappings.find (num); - rust_assert (it == deriveMappings.end ()); - - deriveMappings[num] = macros; -} - -void -ProcMacroMappings::insert_bang_proc_macros (CrateNum num, - std::vector macros) -{ - auto it = bangMappings.find (num); - rust_assert (it == bangMappings.end ()); - - bangMappings[num] = macros; -} - -void -ProcMacroMappings::insert_attribute_proc_macros ( - CrateNum num, std::vector macros) -{ - auto it = attributeMappings.find (num); - rust_assert (it == attributeMappings.end ()); - - attributeMappings[num] = macros; -} - -tl::optional &> -ProcMacroMappings::lookup_derive_proc_macros (CrateNum num) -{ - auto it = deriveMappings.find (num); - if (it == deriveMappings.end ()) - return tl::nullopt; - - return it->second; -} - -tl::optional &> -ProcMacroMappings::lookup_bang_proc_macros (CrateNum num) -{ - auto it = bangMappings.find (num); - if (it == bangMappings.end ()) - return tl::nullopt; - - return it->second; -} - -tl::optional &> -ProcMacroMappings::lookup_attribute_proc_macros (CrateNum num) -{ - auto it = attributeMappings.find (num); - if (it == attributeMappings.end ()) - return tl::nullopt; - - return it->second; -} - void ProcMacroMappings::insert_derive_def (CustomDeriveProcMacro macro) { diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index 638b16155f24..e22a067dde52 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -71,13 +71,56 @@ class NodeMapping LocalDefId localDefId; }; +enum class InsertionPolicy +{ + FORBID_DUPLICATES, + ALLOW_DUPLICATES, +}; + +template +class Mapping +{ + std::unordered_map storage; + +public: + tl::optional lookup (Id id) + { + auto it = storage.find (id); + if (it == storage.cend ()) + return tl::nullopt; + return it->second; + } + + tl::optional lookup (Id id) const + { + auto it = storage.find (id); + if (it == storage.cend ()) + return tl::nullopt; + return it->second; + } + + void insert (Id id, Item item) + { + if (insertion_policy == InsertionPolicy::FORBID_DUPLICATES) + { + auto it = storage.find (id); + rust_assert (it == storage.end ()); + } + + storage.insert ({id, item}); + } + + // Required for CrateMappings::lookup_crate_name. Should we make mappings a + // bimap instead ? + const decltype (storage) &get_storage () const { return storage; } +}; + class CrateMappings { std::map ast_crate_mappings; - // crate names - std::map crate_names; - CrateNum crateNumItr; CrateNum currentCrateNum; @@ -90,10 +133,8 @@ class CrateMappings CrateNum get_next_crate_num (const std::string &name); void set_current_crate (CrateNum crateNum); CrateNum get_current_crate () const; - tl::optional get_crate_name (CrateNum crate_num) const; tl::optional lookup_crate_num (NodeId node_id) const; - void set_crate_name (CrateNum crate_num, const std::string &name); const std::string &get_current_crate_name () const; tl::optional lookup_crate_name (const std::string &crate_name) const; @@ -106,14 +147,23 @@ class CrateMappings AST::Crate &get_ast_crate (CrateNum crateNum); AST::Crate *get_ast_crate_by_node_id_raw (NodeId id); + + Mapping, + InsertionPolicy::FORBID_DUPLICATES> + derives; + Mapping, + InsertionPolicy::FORBID_DUPLICATES> + bangs; + Mapping, + InsertionPolicy::FORBID_DUPLICATES> + attributes; + + Mapping + crate_names; }; class ProcMacroMappings { - std::map> deriveMappings; - std::map> bangMappings; - std::map> attributeMappings; - std::map procmacroDeriveMappings; std::map procmacroBangMappings; std::map procmacroAttributeMappings; @@ -122,20 +172,6 @@ class ProcMacroMappings std::map procmacroAttributeInvocations; public: - void insert_derive_proc_macros (CrateNum num, - std::vector macros); - void insert_bang_proc_macros (CrateNum num, - std::vector macros); - void insert_attribute_proc_macros (CrateNum num, - std::vector macros); - - tl::optional &> - lookup_derive_proc_macros (CrateNum num); - tl::optional &> - lookup_bang_proc_macros (CrateNum num); - tl::optional &> - lookup_attribute_proc_macros (CrateNum num); - void insert_derive_def (CustomDeriveProcMacro macro); void insert_bang_def (BangProcMacro macro); void insert_attribute_def (AttributeProcMacro macro); @@ -157,27 +193,6 @@ class ProcMacroMappings AttributeProcMacro def); }; -template class Mapping -{ - std::unordered_map storage; - -public: - tl::optional lookup (Id id) - { - auto it = storage.find (id); - if (it == storage.cend ()) - return tl::nullopt; - return it->second; - } - void insert (Id id, Item item) { storage.insert ({id, item}); } -}; - -enum class InsertionPolicy -{ - FORBID_DUPLICATES, - ALLOW_DUPLICATES, -}; - enum class InsertLocation { YES, From 1dc6334b72591dd02c90b3c7cca95976c8eb2cd0 Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Thu, 24 Sep 2026 03:12:10 +0200 Subject: [PATCH 581/584] Split proc macro invocation and definitions apart Put macro invocations and definitions in their own container and reuse the Mapping infrastructure. gcc/rust/ChangeLog: * expand/rust-macro-expand.h (struct MacroExpander): Update call name. * resolve/rust-early-name-resolver-2.0.cc (Early::visit_derive_attribute): Likewise. (Early::visit_non_builtin_attribute): Likewise. * resolve/rust-toplevel-name-resolver-2.0.cc (TopLevel::visit_extern_crate): Likewise. * util/rust-hir-map.cc (ProcMacroMappings::insert_derive_def): Remove. (ProcMacroMappings::insert_bang_def): Remove. (ProcMacroMappings::insert_attribute_def): Remove. (ProcMacroMappings::lookup_derive_def): Remove. (ProcMacroMappings::lookup_bang_def): Remove. (ProcMacroMappings::lookup_attribute_def): Remove. (ProcMacroMappings::insert_derive_invocation): Remove. (ProcMacroMappings::lookup_derive_invocation): Remove. (ProcMacroMappings::insert_bang_invocation): Remove. (ProcMacroMappings::lookup_bang_invocation): Remove. (ProcMacroMappings::insert_attribute_invocation): Remove. (ProcMacroMappings::lookup_attribute_invocation): Remove. * util/rust-hir-map.h (class ProcMacroMappings): Convert to struct. (struct ProcMacroDefinitionMappings): Add definition mappings. (struct ProcMacroInvocationsMappings): Add invocation mappings. (struct ProcMacroMappings): Use two new separate fields for definitions and invocations. Signed-off-by: Pierre-Emmanuel Patry --- gcc/rust/expand/rust-macro-expand.h | 6 +- .../resolve/rust-early-name-resolver-2.0.cc | 15 +-- .../rust-toplevel-name-resolver-2.0.cc | 8 +- gcc/rust/util/rust-hir-map.cc | 117 ------------------ gcc/rust/util/rust-hir-map.h | 47 +++---- 5 files changed, 36 insertions(+), 157 deletions(-) diff --git a/gcc/rust/expand/rust-macro-expand.h b/gcc/rust/expand/rust-macro-expand.h index ae52bf79cd49..fcab75a206c7 100644 --- a/gcc/rust/expand/rust-macro-expand.h +++ b/gcc/rust/expand/rust-macro-expand.h @@ -412,7 +412,7 @@ struct MacroExpander AST::Fragment expand_derive_proc_macro (T &item, AST::SimplePath &path) { tl::optional macro - = mappings.pmacro.lookup_derive_invocation (path); + = mappings.pmacro.invocations.derives.lookup (path.get_node_id ()); if (!macro.has_value ()) { rust_error_at (path.get_locus (), "macro not found"); @@ -435,7 +435,7 @@ struct MacroExpander AST::MacroInvocation &invocation) { tl::optional macro - = mappings.pmacro.lookup_bang_invocation (invocation); + = mappings.pmacro.invocations.bangs.lookup (invocation.get_node_id ()); if (!macro.has_value ()) { rust_error_at (invocation.get_locus (), "macro not found"); @@ -457,7 +457,7 @@ struct MacroExpander AST::Fragment expand_attribute_proc_macro (T &item, AST::SimplePath &path) { tl::optional macro - = mappings.pmacro.lookup_attribute_invocation (path); + = mappings.pmacro.invocations.attributes.lookup (path.get_node_id ()); if (!macro.has_value ()) { rust_error_at (path.get_locus (), "macro not found"); diff --git a/gcc/rust/resolve/rust-early-name-resolver-2.0.cc b/gcc/rust/resolve/rust-early-name-resolver-2.0.cc index a0a5eec876c2..8b3220d49f37 100644 --- a/gcc/rust/resolve/rust-early-name-resolver-2.0.cc +++ b/gcc/rust/resolve/rust-early-name-resolver-2.0.cc @@ -402,11 +402,12 @@ Early::visit_derive_attribute (AST::Attribute &attr, continue; } - auto pm_def - = mappings.pmacro.lookup_derive_def (ns_def->definition.get_node_id ()); + auto pm_def = mappings.pmacro.definitions.derives.lookup ( + ns_def->definition.get_node_id ()); if (pm_def.has_value ()) - mappings.pmacro.insert_derive_invocation (trait, pm_def.value ()); + mappings.pmacro.invocations.derives.insert (trait.get ().get_node_id (), + pm_def.value ()); } } @@ -424,14 +425,14 @@ Early::visit_non_builtin_attribute (AST::Attribute &attr, name.c_str ())); return; } - auto pm_def - = mappings.pmacro.lookup_attribute_def (ns_def->definition.get_node_id ()); + auto pm_def = mappings.pmacro.definitions.attributes.lookup ( + ns_def->definition.get_node_id ()); if (!pm_def.has_value ()) return; - mappings.pmacro.insert_attribute_invocation (attr.get_path (), - pm_def.value ()); + mappings.pmacro.invocations.attributes.insert ( + attr.get_path ().get_node_id (), pm_def.value ()); } void diff --git a/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc b/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc index d92e5e2a4b48..fa81639b6421 100644 --- a/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc +++ b/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc @@ -198,19 +198,21 @@ TopLevel::visit_extern_crate (AST::ExternCrate &extern_crate, AST::Crate &crate, { insert_macros (derive_macros.value (), ctx); for (auto ¯o : derive_macros.value ()) - mappings.pmacro.insert_derive_def (macro); + mappings.pmacro.definitions.derives.insert (macro.get_node_id (), + macro); } if (attribute_macros.has_value ()) { insert_macros (attribute_macros.value (), ctx); for (auto ¯o : attribute_macros.value ()) - mappings.pmacro.insert_attribute_def (macro); + mappings.pmacro.definitions.attributes.insert (macro.get_node_id (), + macro); } if (bang_macros.has_value ()) { insert_macros (bang_macros.value (), ctx); for (auto ¯o : bang_macros.value ()) - mappings.pmacro.insert_bang_def (macro); + mappings.pmacro.definitions.bangs.insert (macro.get_node_id (), macro); } // We do *NOT* visit the crate because loaded crates are resolved diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index 59c8bed8ff07..8876311b73ad 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -855,123 +855,6 @@ Mappings::get_exported_macros () return exportedMacros; } -void -ProcMacroMappings::insert_derive_def (CustomDeriveProcMacro macro) -{ - auto it = procmacroDeriveMappings.find (macro.get_node_id ()); - rust_assert (it == procmacroDeriveMappings.end ()); - - procmacroDeriveMappings[macro.get_node_id ()] = macro; -} - -void -ProcMacroMappings::insert_bang_def (BangProcMacro macro) -{ - auto it = procmacroBangMappings.find (macro.get_node_id ()); - rust_assert (it == procmacroBangMappings.end ()); - - procmacroBangMappings[macro.get_node_id ()] = macro; -} - -void -ProcMacroMappings::insert_attribute_def (AttributeProcMacro macro) -{ - auto it = procmacroAttributeMappings.find (macro.get_node_id ()); - rust_assert (it == procmacroAttributeMappings.end ()); - - procmacroAttributeMappings[macro.get_node_id ()] = macro; -} - -tl::optional -ProcMacroMappings::lookup_derive_def (NodeId id) -{ - auto it = procmacroDeriveMappings.find (id); - if (it == procmacroDeriveMappings.end ()) - return tl::nullopt; - - return it->second; -} - -tl::optional -ProcMacroMappings::lookup_bang_def (NodeId id) -{ - auto it = procmacroBangMappings.find (id); - if (it == procmacroBangMappings.end ()) - return tl::nullopt; - - return it->second; -} - -tl::optional -ProcMacroMappings::lookup_attribute_def (NodeId id) -{ - auto it = procmacroAttributeMappings.find (id); - if (it == procmacroAttributeMappings.end ()) - return tl::nullopt; - - return it->second; -} - -void -ProcMacroMappings::insert_derive_invocation (AST::SimplePath &invoc, - CustomDeriveProcMacro def) -{ - auto it = procmacroDeriveInvocations.find (invoc.get_node_id ()); - rust_assert (it == procmacroDeriveInvocations.end ()); - - procmacroDeriveInvocations[invoc.get_node_id ()] = def; -} - -tl::optional -ProcMacroMappings::lookup_derive_invocation (AST::SimplePath &invoc) -{ - auto it = procmacroDeriveInvocations.find (invoc.get_node_id ()); - if (it == procmacroDeriveInvocations.end ()) - return tl::nullopt; - - return it->second; -} - -void -ProcMacroMappings::insert_bang_invocation (AST::MacroInvocation &invoc, - BangProcMacro def) -{ - auto it = procmacroBangInvocations.find (invoc.get_node_id ()); - rust_assert (it == procmacroBangInvocations.end ()); - - procmacroBangInvocations[invoc.get_node_id ()] = def; -} - -tl::optional -ProcMacroMappings::lookup_bang_invocation (AST::MacroInvocation &invoc) -{ - auto it = procmacroBangInvocations.find (invoc.get_node_id ()); - if (it == procmacroBangInvocations.end ()) - return tl::nullopt; - - return it->second; -} - -void -ProcMacroMappings::insert_attribute_invocation (AST::SimplePath &invoc, - AttributeProcMacro def) -{ - auto it = procmacroAttributeInvocations.find (invoc.get_node_id ()); - rust_assert (it == procmacroAttributeInvocations.end ()); - - procmacroAttributeInvocations[invoc.get_node_id ()] = def; -} - -tl::optional -ProcMacroMappings::lookup_attribute_invocation (AST::SimplePath &invoc) -{ - auto it = procmacroAttributeInvocations.find (invoc.get_node_id ()); - if (it == procmacroAttributeInvocations.end ()) - return tl::nullopt; - - return it->second; -} - void Mappings::insert_module_child (NodeId module, NodeId child) { diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index e22a067dde52..4816b648ad1b 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -162,35 +162,28 @@ class CrateMappings crate_names; }; -class ProcMacroMappings +struct ProcMacroDefinitionMappings { - std::map procmacroDeriveMappings; - std::map procmacroBangMappings; - std::map procmacroAttributeMappings; - std::map procmacroDeriveInvocations; - std::map procmacroBangInvocations; - std::map procmacroAttributeInvocations; + Mapping + derives; + Mapping bangs; + Mapping + attributes; +}; -public: - void insert_derive_def (CustomDeriveProcMacro macro); - void insert_bang_def (BangProcMacro macro); - void insert_attribute_def (AttributeProcMacro macro); - - tl::optional lookup_derive_def (NodeId id); - tl::optional lookup_bang_def (NodeId id); - tl::optional lookup_attribute_def (NodeId id); - - tl::optional - lookup_derive_invocation (AST::SimplePath &invoc); - tl::optional - lookup_bang_invocation (AST::MacroInvocation &invoc_id); - tl::optional - lookup_attribute_invocation (AST::SimplePath &invoc); - void insert_derive_invocation (AST::SimplePath &invoc, - CustomDeriveProcMacro def); - void insert_bang_invocation (AST::MacroInvocation &invoc, BangProcMacro def); - void insert_attribute_invocation (AST::SimplePath &invoc, - AttributeProcMacro def); +struct ProcMacroInvocationsMappings +{ + Mapping + derives; + Mapping bangs; + Mapping + attributes; +}; + +struct ProcMacroMappings +{ + ProcMacroDefinitionMappings definitions; + ProcMacroInvocationsMappings invocations; }; enum class InsertLocation From eebb4be5faa752761fda8c3fb10822b8253ddad8 Mon Sep 17 00:00:00 2001 From: Pierre-Emmanuel Patry Date: Thu, 24 Sep 2026 03:20:42 +0200 Subject: [PATCH 582/584] Rename variables Most variables in the rust front end use snake case instead of camel case. Also rename the ast_crate_mapping variable given we already are in a mapping context. gcc/rust/ChangeLog: * util/rust-hir-map.cc (CrateMappings::CrateMappings): Update variable name at call site. (CrateMappings::get_next_crate_num): Likewise. (CrateMappings::set_current_crate): Likewise. (CrateMappings::get_current_crate): Likewise. (CrateMappings::get_ast_crate): Likewise. (CrateMappings::get_ast_crate_by_node_id_raw): Likewise. (CrateMappings::insert_ast_crate): Likewise. * util/rust-hir-map.h (class CrateMappings): Rename variables. Signed-off-by: Pierre-Emmanuel Patry --- gcc/rust/util/rust-hir-map.cc | 32 ++++++++++++++++---------------- gcc/rust/util/rust-hir-map.h | 6 +++--- 2 files changed, 19 insertions(+), 19 deletions(-) diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index 8876311b73ad..35b9fe19c302 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -99,7 +99,7 @@ static const HirId kDefaultHirIdBegin = 1; static const HirId kDefaultCrateNumBegin = 0; CrateMappings::CrateMappings () - : crateNumItr (kDefaultCrateNumBegin), currentCrateNum (UNKNOWN_CRATENUM) + : crate_num_itr (kDefaultCrateNumBegin), current_crate_num (UNKNOWN_CRATENUM) {} Mappings::Mappings () @@ -126,8 +126,8 @@ Mappings::get () CrateNum CrateMappings::get_next_crate_num (const std::string &name) { - auto id = crateNumItr; - crateNumItr++; + auto id = crate_num_itr; + crate_num_itr++; crate_names.insert (id, name); return id; } @@ -135,13 +135,13 @@ CrateMappings::get_next_crate_num (const std::string &name) void CrateMappings::set_current_crate (CrateNum crateNum) { - currentCrateNum = crateNum; + current_crate_num = crateNum; } CrateNum CrateMappings::get_current_crate () const { - return currentCrateNum; + return current_crate_num; } tl::optional @@ -174,8 +174,8 @@ CrateMappings::lookup_crate_name (const std::string &crate_name) const tl::optional CrateMappings::crate_num_to_nodeid (const CrateNum &crate_num) const { - auto it = ast_crate_mappings.find (crate_num); - if (it == ast_crate_mappings.end ()) + auto it = ast_crate.find (crate_num); + if (it == ast_crate.end ()) return tl::nullopt; return it->second->get_node_id (); @@ -233,8 +233,8 @@ Mappings::get_next_localdef_id (CrateNum crateNum) AST::Crate & CrateMappings::get_ast_crate (CrateNum crateNum) { - auto it = ast_crate_mappings.find (crateNum); - rust_assert (it != ast_crate_mappings.end ()); + auto it = ast_crate.find (crateNum); + rust_assert (it != ast_crate.end ()); return *it->second; } @@ -248,8 +248,8 @@ AST::Crate * CrateMappings::get_ast_crate_by_node_id_raw (NodeId id) { CrateNum crateNum = lookup_crate_num (id).value (); - auto it = ast_crate_mappings.find (crateNum); - rust_assert (it != ast_crate_mappings.end ()); + auto it = ast_crate.find (crateNum); + rust_assert (it != ast_crate.end ()); return it->second; } @@ -257,16 +257,16 @@ AST::Crate & CrateMappings::insert_ast_crate (std::unique_ptr &&crate, CrateNum crate_num) { - auto it = ast_crate_mappings.find (crate_num); - rust_assert (it == ast_crate_mappings.end ()); + auto it = ast_crate.find (crate_num); + rust_assert (it == ast_crate.end ()); // store it crate_node_to_crate_num.insert ({crate->get_node_id (), crate_num}); - ast_crate_mappings.insert ({crate_num, crate.release ()}); + ast_crate.insert ({crate_num, crate.release ()}); // return the reference to it - it = ast_crate_mappings.find (crate_num); - rust_assert (it != ast_crate_mappings.end ()); + it = ast_crate.find (crate_num); + rust_assert (it != ast_crate.end ()); return *it->second; } diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index 4816b648ad1b..5aeb6d9245c1 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -119,11 +119,11 @@ class Mapping class CrateMappings { - std::map ast_crate_mappings; + std::map ast_crate; - CrateNum crateNumItr; + CrateNum crate_num_itr; - CrateNum currentCrateNum; + CrateNum current_crate_num; std::map crate_node_to_crate_num; From dde2e990210e6e40eeacb89ca8cc667b9201f3c6 Mon Sep 17 00:00:00 2001 From: Arthur Cohen Date: Thu, 3 Sep 2026 17:36:20 +0200 Subject: [PATCH 583/584] feature-gate: Default-visit extern types for completeness gcc/rust/ChangeLog: * checks/errors/feature/rust-feature-gate.cc (FeatureGate::visit): Add missing call to default visitor for ExternType items. --- gcc/rust/checks/errors/feature/rust-feature-gate.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/gcc/rust/checks/errors/feature/rust-feature-gate.cc b/gcc/rust/checks/errors/feature/rust-feature-gate.cc index 4cb4583f713f..6b481fafa177 100644 --- a/gcc/rust/checks/errors/feature/rust-feature-gate.cc +++ b/gcc/rust/checks/errors/feature/rust-feature-gate.cc @@ -262,6 +262,8 @@ FeatureGate::visit (AST::ExternalTypeItem &item) // `AST::ExternalTypeItem`. gate (Feature::Name::EXTERN_TYPES, item.get_locus (), "extern types are experimental"); + + AST::DefaultASTVisitor::visit (item); } void From d0efdf8066bdf4764bad0ad7a993aafd27a5a8b4 Mon Sep 17 00:00:00 2001 From: Arthur Cohen Date: Thu, 3 Sep 2026 19:24:53 +0200 Subject: [PATCH 584/584] derive: Gate CoercePointee and add framework for implementing it. Gate derive(CoercePointee) behind `#![feature(derive_coerce_pointee)` and start adding the infrastructure required to support it. Warn that it doesn't do anything yet. gcc/rust/ChangeLog: * checks/errors/feature/rust-feature-defs.h (FEATURE_ACTIVE): New feature. * expand/rust-derive.cc (DeriveVisitor::derive): Add base handling for CoercePointee derive. * expand/rust-macro-builtins.cc: Add CoercePointee as a built-in derive * expand/rust-macro-builtins.h (enum class): Likewise. * resolve/rust-early-name-resolver-2.0.cc (Early::visit_derive_attribute): Special case derive(CoercePointee). * rust-session-manager.h (should_support_coerce_pointee): New method. * expand/rust-derive-coerce-pointee.cc: New file. * expand/rust-derive-coerce-pointee.h: New file. * Make-lang.in: Compile it. gcc/testsuite/ChangeLog: * rust/compile/derive-coerce-pointee1.rs: New test. * rust/compile/derive-coerce-pointee2.rs: New test. * rust/compile/derive-coerce-pointee3.rs: New test. --- gcc/rust/Make-lang.in | 1 + .../checks/errors/feature/rust-feature-defs.h | 4 + gcc/rust/expand/rust-derive-coerce-pointee.cc | 76 +++++++++++++++++++ gcc/rust/expand/rust-derive-coerce-pointee.h | 44 +++++++++++ gcc/rust/expand/rust-derive.cc | 3 + gcc/rust/expand/rust-macro-builtins.cc | 1 + gcc/rust/expand/rust-macro-builtins.h | 1 + .../resolve/rust-early-name-resolver-2.0.cc | 6 ++ gcc/rust/rust-session-manager.h | 5 ++ .../rust/compile/derive-coerce-pointee1.rs | 16 ++++ .../rust/compile/derive-coerce-pointee2.rs | 14 ++++ .../rust/compile/derive-coerce-pointee3.rs | 14 ++++ 12 files changed, 185 insertions(+) create mode 100644 gcc/rust/expand/rust-derive-coerce-pointee.cc create mode 100644 gcc/rust/expand/rust-derive-coerce-pointee.h create mode 100644 gcc/testsuite/rust/compile/derive-coerce-pointee1.rs create mode 100644 gcc/testsuite/rust/compile/derive-coerce-pointee2.rs create mode 100644 gcc/testsuite/rust/compile/derive-coerce-pointee3.rs diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in index 552de0153d66..79ea9524b551 100644 --- a/gcc/rust/Make-lang.in +++ b/gcc/rust/Make-lang.in @@ -108,6 +108,7 @@ GRS_OBJS = \ rust/rust-derive-eq.o \ rust/rust-derive-ord.o \ rust/rust-derive-hash.o \ + rust/rust-derive-coerce-pointee.o \ rust/rust-proc-macro.o \ rust/rust-macro-invoc-lexer.o \ rust/rust-macro-substitute-ctx.o \ diff --git a/gcc/rust/checks/errors/feature/rust-feature-defs.h b/gcc/rust/checks/errors/feature/rust-feature-defs.h index b541bbd23500..b91a041c6656 100644 --- a/gcc/rust/checks/errors/feature/rust-feature-defs.h +++ b/gcc/rust/checks/errors/feature/rust-feature-defs.h @@ -521,6 +521,10 @@ FEATURE_ACTIVE ("destructuring_assignment", DESTRUCTURING_ASSIGNMENT, "1.49.0", ISSUE_SOME (71126), EDITION_NONE) FEATURE_ACTIVE ("cfg_panic", CFG_PANIC, "1.49.0", ISSUE_SOME (77443), EDITION_NONE) +FEATURE_ACTIVE ("derive_coerce_pointee", DERIVE_COERCE_POINTEE, + "1.84.0" /* Not sure about the version number for this one */, + /* We also need a compatibility check to enable this */ + ISSUE_SOME (123430), EDITION_NONE) FEATURE_REMOVED ("import_shadowing", IMPORT_SHADOWING, "1.0.0", ISSUE_NONE, REASON_NONE) FEATURE_REMOVED ("managed_boxes", MANAGED_BOXES, "1.0.0", ISSUE_NONE, diff --git a/gcc/rust/expand/rust-derive-coerce-pointee.cc b/gcc/rust/expand/rust-derive-coerce-pointee.cc new file mode 100644 index 000000000000..51bb7d3e4eae --- /dev/null +++ b/gcc/rust/expand/rust-derive-coerce-pointee.cc @@ -0,0 +1,76 @@ +// Copyright (C) 2026 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 +// . + +#include "rust-derive-coerce-pointee.h" +#include "rust-session-manager.h" +#include "rust-feature.h" +#include "rust-feature-store.h" + +namespace Rust { +namespace AST { + +DeriveCoercePointee::DeriveCoercePointee (location_t loc, + Builder::Source item_source) + : DeriveVisitor (loc, item_source) +{} + +std::unique_ptr +DeriveCoercePointee::go (Item &item) +{ + Features::EarlyFeatureGateStore::get ().add ( + Feature::Name::DERIVE_COERCE_POINTEE, + Error (loc, "use of unstable library feature %")); + + // NOTE: This is technically a library feature, so I don't think this is + // how it should be gated. But as far as I can tell at the moment we have + // no mechanisms for handling these, and furthermore this will go through + // our compatibility layer. + // + // What this means is that the `CoercePointee` macro will *not* be defined + // in the `core` that we will be using to compile the kernel at first. + // + // The basic example for `CoercePointee` is something like this: + // + // ```rust + // use std::marker::CoercePointee; + // + // #[derive(CoercePointee)] + // struct Flip(*const Flop); + // ``` + // + // but the marker will not be present in the `core` we will be using at + // first, so we will need to fake its existence with + // -frust-compat-version, and then the compiler can assume that it is a + // built-in derive. At least that's my expectation. + + if (!Session::get_instance ().should_support_coerce_pointee ()) + { + rust_error_at (loc, "derive(CoercePointee) requires a compatibility mode " + "greater or equal to 1.84"); + return {}; + } + + rust_warning_at ( + loc, 0, + "derive(CoercePointee) is currently unimplemented and has no effect"); + + return {}; +} + +} // namespace AST +} // namespace Rust diff --git a/gcc/rust/expand/rust-derive-coerce-pointee.h b/gcc/rust/expand/rust-derive-coerce-pointee.h new file mode 100644 index 000000000000..b6f5c2b464f2 --- /dev/null +++ b/gcc/rust/expand/rust-derive-coerce-pointee.h @@ -0,0 +1,44 @@ +// Copyright (C) 2026 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 RUST_DERIVE_COERCE_POINTEE_H +#define RUST_DERIVE_COERCE_POINTEE_H + +#include "rust-derive.h" + +namespace Rust { +namespace AST { + +class DeriveCoercePointee : DeriveVisitor +{ +public: + DeriveCoercePointee (location_t loc, Builder::Source item_source); + + std::unique_ptr go (Item &item); + +private: + virtual void visit_struct (StructStruct &item) override {} + virtual void visit_tuple (TupleStruct &item) override {} + virtual void visit_enum (Enum &item) override {} + virtual void visit_union (Union &item) override {} +}; + +} // namespace AST +} // namespace Rust + +#endif // ! RUST_DERIVE_COERCE_POINTEE_H diff --git a/gcc/rust/expand/rust-derive.cc b/gcc/rust/expand/rust-derive.cc index f45acaa8c245..7e60eff94704 100644 --- a/gcc/rust/expand/rust-derive.cc +++ b/gcc/rust/expand/rust-derive.cc @@ -18,6 +18,7 @@ #include "rust-derive.h" #include "rust-derive-clone.h" +#include "rust-derive-coerce-pointee.h" #include "rust-derive-copy.h" #include "rust-derive-debug.h" #include "rust-derive-default.h" @@ -83,6 +84,8 @@ DeriveVisitor::derive (Item &item, const Attribute &attr, ? "RustcEncodable" : "RustcDecodable"); return {}; + case BuiltinMacro::CoercePointee: + return vec (DeriveCoercePointee (loc, item_source).go (item)); default: rust_unreachable (); }; diff --git a/gcc/rust/expand/rust-macro-builtins.cc b/gcc/rust/expand/rust-macro-builtins.cc index d96b23f99924..998477c52536 100644 --- a/gcc/rust/expand/rust-macro-builtins.cc +++ b/gcc/rust/expand/rust-macro-builtins.cc @@ -83,6 +83,7 @@ const BiMap MacroBuiltin::builtins = {{ {"Ord", BuiltinMacro::Ord}, {"PartialOrd", BuiltinMacro::PartialOrd}, {"Hash", BuiltinMacro::Hash}, + {"CoercePointee", BuiltinMacro::CoercePointee}, }}; AST::MacroTranscriberFunc diff --git a/gcc/rust/expand/rust-macro-builtins.h b/gcc/rust/expand/rust-macro-builtins.h index b0c2db57f058..c433ab1a3725 100644 --- a/gcc/rust/expand/rust-macro-builtins.h +++ b/gcc/rust/expand/rust-macro-builtins.h @@ -76,6 +76,7 @@ enum class BuiltinMacro Ord, PartialOrd, Hash, + CoercePointee, }; tl::optional diff --git a/gcc/rust/resolve/rust-early-name-resolver-2.0.cc b/gcc/rust/resolve/rust-early-name-resolver-2.0.cc index 8b3220d49f37..4860163beb64 100644 --- a/gcc/rust/resolve/rust-early-name-resolver-2.0.cc +++ b/gcc/rust/resolve/rust-early-name-resolver-2.0.cc @@ -392,6 +392,12 @@ Early::visit_derive_attribute (AST::Attribute &attr, auto traits = attr.get_traits_to_derive (); for (auto &trait : traits) { + // Special case CoercePointee if we're in a proper compatibility mode. + // Count it as a builtin derive macro and keep going. + if (trait.get ().as_string () == "CoercePointee" + && Session::get_instance ().should_support_coerce_pointee ()) + continue; + auto ns_def = ctx.resolve_path (trait.get (), Namespace::Macros); if (!ns_def.has_value ()) { diff --git a/gcc/rust/rust-session-manager.h b/gcc/rust/rust-session-manager.h index 6a0acda7c1a2..0f4ba7257a1a 100644 --- a/gcc/rust/rust-session-manager.h +++ b/gcc/rust/rust-session-manager.h @@ -519,6 +519,11 @@ struct Session return get_compat_version () >= 90; } + bool should_support_coerce_pointee () const + { + return get_compat_version () >= 84; + } + private: Session () : mappings (Analysis::Mappings::get ()) {} void compile_crate (const char *filename); diff --git a/gcc/testsuite/rust/compile/derive-coerce-pointee1.rs b/gcc/testsuite/rust/compile/derive-coerce-pointee1.rs new file mode 100644 index 000000000000..ebc9cde10be1 --- /dev/null +++ b/gcc/testsuite/rust/compile/derive-coerce-pointee1.rs @@ -0,0 +1,16 @@ +// { dg-additional-options "-frust-compat-version=1.84" } + +// check that we error out when the compat mode is right but the feature is missing + +#![feature(no_core)] +#![feature(lang_items)] +#![no_core] + +#[lang = "sized"] +trait Sized {} + +#[derive(CoercePointee)] // { dg-warning "no effect" } + // { dg-error "use of unstable library feature" "" { target *-*-* } .-1 } +struct Floop { + a: *const T, +} diff --git a/gcc/testsuite/rust/compile/derive-coerce-pointee2.rs b/gcc/testsuite/rust/compile/derive-coerce-pointee2.rs new file mode 100644 index 000000000000..8c84a7fb3360 --- /dev/null +++ b/gcc/testsuite/rust/compile/derive-coerce-pointee2.rs @@ -0,0 +1,14 @@ +#![feature(no_core)] +#![feature(lang_items)] +#![feature(derive_coerce_pointee)] +#![no_core] + +// check that we error out when the feature is right but the compat mode is missing (opposite of derive-coerce-pointee1.rs) + +#[lang = "sized"] +trait Sized {} + +#[derive(CoercePointee)] +// { dg-error "derive.CoercePointee. requires a compatibility mode" "" { target *-*-* } .-1 } +// { dg-error "could not resolve trait .CoercePointee." "" { target *-*-* } .-2 } +pub struct Floop(*const T); diff --git a/gcc/testsuite/rust/compile/derive-coerce-pointee3.rs b/gcc/testsuite/rust/compile/derive-coerce-pointee3.rs new file mode 100644 index 000000000000..8ca8a1bae584 --- /dev/null +++ b/gcc/testsuite/rust/compile/derive-coerce-pointee3.rs @@ -0,0 +1,14 @@ +// { dg-additional-options "-frust-compat-version=1.84" } + +// this time everything is enabled - check we fake name resolve properly and we have access to the derive + +#![feature(no_core)] +#![feature(lang_items)] +#![feature(derive_coerce_pointee)] +#![no_core] + +#[lang = "sized"] +trait Sized {} + +#[derive(CoercePointee)] // { dg-warning "no effect" } +pub struct Floop(*const T);